ZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5hc3NlbWJseS5mZWF0dXJlLy5jdnNpZ25vcmUgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuYXNzZW1ibHkuZmVhdHVyZS8uY3ZzaWdub3JlCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkZThiNzNmLi4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5hc3NlbWJseS5mZWF0dXJlLy5jdnNpZ25vcmUKKysrIC9kZXYvbnVsbApAQCAtMSwyICswLDAgQEAKLWJ1aWxkLnhtbAotb3JnLmVjbGlwc2UuanB0XzEuMC4wLioKZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5hc3NlbWJseS5mZWF0dXJlLy5wcm9qZWN0IGIvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmFzc2VtYmx5LmZlYXR1cmUvLnByb2plY3QKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDFlMjExYWYuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmFzc2VtYmx5LmZlYXR1cmUvLnByb2plY3QKKysrIC9kZXYvbnVsbApAQCAtMSwxNyArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPHByb2plY3REZXNjcmlwdGlvbj4KLQk8bmFtZT5vcmcuZWNsaXBzZS5qcHQuYXNzZW1ibHkuZmVhdHVyZTwvbmFtZT4KLQk8Y29tbWVudD48L2NvbW1lbnQ+Ci0JPHByb2plY3RzPgotCTwvcHJvamVjdHM+Ci0JPGJ1aWxkU3BlYz4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5GZWF0dXJlQnVpbGRlcjwvbmFtZT4KLQkJCTxhcmd1bWVudHM+Ci0JCQk8L2FyZ3VtZW50cz4KLQkJPC9idWlsZENvbW1hbmQ+Ci0JPC9idWlsZFNwZWM+Ci0JPG5hdHVyZXM+Ci0JCTxuYXR1cmU+b3JnLmVjbGlwc2UucGRlLkZlYXR1cmVOYXR1cmU8L25hdHVyZT4KLQk8L25hdHVyZXM+Ci08L3Byb2plY3REZXNjcmlwdGlvbj4KZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5hc3NlbWJseS5mZWF0dXJlL2J1aWxkLnByb3BlcnRpZXMgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuYXNzZW1ibHkuZmVhdHVyZS9idWlsZC5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0NzBiNGJjLi4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5hc3NlbWJseS5mZWF0dXJlL2J1aWxkLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwxNiArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi1iaW4uaW5jbHVkZXMgPSBmZWF0dXJlLnhtbCxcCi0gICAgICAgICAgICAgICBlY2xpcHNlX3VwZGF0ZV8xMjAuanBnLFwKLSAgICAgICAgICAgICAgIGVwbC12MTAuaHRtbCxcCi0gICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwsXAotICAgICAgICAgICAgICAgZmVhdHVyZS5wcm9wZXJ0aWVzCi0gICAgICAgICAgICAgICAKXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuYXNzZW1ibHkuZmVhdHVyZS9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnIGIvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmFzc2VtYmx5LmZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmZkZjcwOC4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuYXNzZW1ibHkuZmVhdHVyZS9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmFzc2VtYmx5LmZlYXR1cmUvZXBsLXYxMC5odG1sIGIvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmFzc2VtYmx5LmZlYXR1cmUvZXBsLXYxMC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlZDRiMTk2Li4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5hc3NlbWJseS5mZWF0dXJlL2VwbC12MTAuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDMyOCArMCwwIEBACi08aHRtbCB4bWxuczpvPSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTpvZmZpY2UiCi14bWxuczp3PSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTp3b3JkIgoteG1sbnM9Imh0dHA6Ly93d3cudzMub3JnL1RSL1JFQy1odG1sNDAiPgotCi08aGVhZD4KLTxtZXRhIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD13aW5kb3dzLTEyNTIiPgotPG1ldGEgbmFtZT1Qcm9nSWQgY29udGVudD1Xb3JkLkRvY3VtZW50PgotPG1ldGEgbmFtZT1HZW5lcmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgOSI+Ci08bWV0YSBuYW1lPU9yaWdpbmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgOSI+Ci08bGluayByZWw9RmlsZS1MaXN0Ci1ocmVmPSIuL0VjbGlwc2UlMjBFUEwlMjAyMDAzXzExXzEwJTIwRmluYWxfZmlsZXMvZmlsZWxpc3QueG1sIj4KLTx0aXRsZT5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gVmVyc2lvbiAxLjA8L3RpdGxlPgotPCEtLVtpZiBndGUgbXNvIDldPjx4bWw+Ci0gPG86RG9jdW1lbnRQcm9wZXJ0aWVzPgotICA8bzpSZXZpc2lvbj4yPC9vOlJldmlzaW9uPgotICA8bzpUb3RhbFRpbWU+MzwvbzpUb3RhbFRpbWU+Ci0gIDxvOkNyZWF0ZWQ+MjAwNC0wMy0wNVQyMzowMzowMFo8L286Q3JlYXRlZD4KLSAgPG86TGFzdFNhdmVkPjIwMDQtMDMtMDVUMjM6MDM6MDBaPC9vOkxhc3RTYXZlZD4KLSAgPG86UGFnZXM+NDwvbzpQYWdlcz4KLSAgPG86V29yZHM+MTYyNjwvbzpXb3Jkcz4KLSAgPG86Q2hhcmFjdGVycz45MjcwPC9vOkNoYXJhY3RlcnM+Ci0gICA8bzpMaW5lcz43NzwvbzpMaW5lcz4KLSAgPG86UGFyYWdyYXBocz4xODwvbzpQYXJhZ3JhcGhzPgotICA8bzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4xMTM4NDwvbzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4KLSAgPG86VmVyc2lvbj45LjQ0MDI8L286VmVyc2lvbj4KLSA8L286RG9jdW1lbnRQcm9wZXJ0aWVzPgotPC94bWw+PCFbZW5kaWZdLS0+PCEtLVtpZiBndGUgbXNvIDldPjx4bWw+Ci0gPHc6V29yZERvY3VtZW50PgotICA8dzpUcmFja1JldmlzaW9ucy8+Ci0gPC93OldvcmREb2N1bWVudD4KLTwveG1sPjwhW2VuZGlmXS0tPgotPHN0eWxlPgotPCEtLQotIC8qIEZvbnQgRGVmaW5pdGlvbnMgKi8KLUBmb250LWZhY2UKLQl7Zm9udC1mYW1pbHk6VGFob21hOwotCXBhbm9zZS0xOjIgMTEgNiA0IDMgNSA0IDQgMiA0OwotCW1zby1mb250LWNoYXJzZXQ6MDsKLQltc28tZ2VuZXJpYy1mb250LWZhbWlseTpzd2lzczsKLQltc28tZm9udC1waXRjaDp2YXJpYWJsZTsKLQltc28tZm9udC1zaWduYXR1cmU6NTUzNjc5NDk1IC0yMTQ3NDgzNjQ4IDggMCA2NjA0NyAwO30KLSAvKiBTdHlsZSBEZWZpbml0aW9ucyAqLwotcC5Nc29Ob3JtYWwsIGxpLk1zb05vcm1hbCwgZGl2Lk1zb05vcm1hbAotCXttc28tc3R5bGUtcGFyZW50OiIiOwotCW1hcmdpbjowaW47Ci0JbWFyZ2luLWJvdHRvbTouMDAwMXB0OwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXAKLQl7bWFyZ2luLXJpZ2h0OjBpbjsKLQltc28tbWFyZ2luLXRvcC1hbHQ6YXV0bzsKLQltc28tbWFyZ2luLWJvdHRvbS1hbHQ6YXV0bzsKLQltYXJnaW4tbGVmdDowaW47Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZToxMi4wcHQ7Ci0JZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotcC5CYWxsb29uVGV4dCwgbGkuQmFsbG9vblRleHQsIGRpdi5CYWxsb29uVGV4dAotCXttc28tc3R5bGUtbmFtZToiQmFsbG9vbiBUZXh0IjsKLQltYXJnaW46MGluOwotCW1hcmdpbi1ib3R0b206LjAwMDFwdDsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjguMHB0OwotCWZvbnQtZmFtaWx5OlRhaG9tYTsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1AcGFnZSBTZWN0aW9uMQotCXtzaXplOjguNWluIDExLjBpbjsKLQltYXJnaW46MS4waW4gMS4yNWluIDEuMGluIDEuMjVpbjsKLQltc28taGVhZGVyLW1hcmdpbjouNWluOwotCW1zby1mb290ZXItbWFyZ2luOi41aW47Ci0JbXNvLXBhcGVyLXNvdXJjZTowO30KLWRpdi5TZWN0aW9uMQotCXtwYWdlOlNlY3Rpb24xO30KLS0tPgotPC9zdHlsZT4KLTwvaGVhZD4KLQotPGJvZHkgbGFuZz1FTi1VUyBzdHlsZT0ndGFiLWludGVydmFsOi41aW4nPgotCi08ZGl2IGNsYXNzPVNlY3Rpb24xPgotCi08cCBhbGlnbj1jZW50ZXIgc3R5bGU9J3RleHQtYWxpZ246Y2VudGVyJz48Yj5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gdiAxLjA8L2I+Ci08L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5USEUgQUNDT01QQU5ZSU5HIFBST0dSQU0gSVMgUFJPVklERUQgVU5ERVIKLVRIRSBURVJNUyBPRiBUSElTIEVDTElQU0UgUFVCTElDIExJQ0VOU0UgKCZxdW90O0FHUkVFTUVOVCZxdW90OykuIEFOWSBVU0UsCi1SRVBST0RVQ1RJT04gT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIENPTlNUSVRVVEVTIFJFQ0lQSUVOVCdTIEFDQ0VQVEFOQ0UKLU9GIFRISVMgQUdSRUVNRU5ULjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+MS4gREVGSU5JVElPTlM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtDb250cmlidXRpb24mcXVvdDsgbWVhbnM6PC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pbiB0aGUgY2FzZSBvZiB0aGUgaW5pdGlhbCBDb250cmlidXRvciwgdGhlIGluaXRpYWwgY29kZSBhbmQgZG9jdW1lbnRhdGlvbgotZGlzdHJpYnV0ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGFuZDxiciBjbGVhcj1sZWZ0PgotYikgaW4gdGhlIGNhc2Ugb2YgZWFjaCBzdWJzZXF1ZW50IENvbnRyaWJ1dG9yOjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmkpCi1jaGFuZ2VzIHRvIHRoZSBQcm9ncmFtLCBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paSkKLWFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbTs8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz53aGVyZQotc3VjaCBjaGFuZ2VzIGFuZC9vciBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gb3JpZ2luYXRlIGZyb20gYW5kIGFyZSBkaXN0cmlidXRlZAotYnkgdGhhdCBwYXJ0aWN1bGFyIENvbnRyaWJ1dG9yLiBBIENvbnRyaWJ1dGlvbiAnb3JpZ2luYXRlcycgZnJvbSBhIENvbnRyaWJ1dG9yCi1pZiBpdCB3YXMgYWRkZWQgdG8gdGhlIFByb2dyYW0gYnkgc3VjaCBDb250cmlidXRvciBpdHNlbGYgb3IgYW55b25lIGFjdGluZyBvbgotc3VjaCBDb250cmlidXRvcidzIGJlaGFsZi4gQ29udHJpYnV0aW9ucyBkbyBub3QgaW5jbHVkZSBhZGRpdGlvbnMgdG8gdGhlCi1Qcm9ncmFtIHdoaWNoOiAoaSkgYXJlIHNlcGFyYXRlIG1vZHVsZXMgb2Ygc29mdHdhcmUgZGlzdHJpYnV0ZWQgaW4gY29uanVuY3Rpb24KLXdpdGggdGhlIFByb2dyYW0gdW5kZXIgdGhlaXIgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBhbmQgKGlpKSBhcmUgbm90IGRlcml2YXRpdmUKLXdvcmtzIG9mIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7Q29udHJpYnV0b3ImcXVvdDsgbWVhbnMgYW55IHBlcnNvbiBvcgotZW50aXR5IHRoYXQgZGlzdHJpYnV0ZXMgdGhlIFByb2dyYW0uPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtMaWNlbnNlZCBQYXRlbnRzICZxdW90OyBtZWFuIHBhdGVudAotY2xhaW1zIGxpY2Vuc2FibGUgYnkgYSBDb250cmlidXRvciB3aGljaCBhcmUgbmVjZXNzYXJpbHkgaW5mcmluZ2VkIGJ5IHRoZSB1c2UKLW9yIHNhbGUgb2YgaXRzIENvbnRyaWJ1dGlvbiBhbG9uZSBvciB3aGVuIGNvbWJpbmVkIHdpdGggdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtQcm9ncmFtJnF1b3Q7IG1lYW5zIHRoZSBDb250cmlidXRpb25zCi1kaXN0cmlidXRlZCBpbiBhY2NvcmRhbmNlIHdpdGggdGhpcyBBZ3JlZW1lbnQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtSZWNpcGllbnQmcXVvdDsgbWVhbnMgYW55b25lIHdobwotcmVjZWl2ZXMgdGhlIFByb2dyYW0gdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGluY2x1ZGluZyBhbGwgQ29udHJpYnV0b3JzLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Mi4gR1JBTlQgT0YgUklHSFRTPC9zcGFuPjwvYj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQKLWEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLCByb3lhbHR5LWZyZWUgY29weXJpZ2h0IGxpY2Vuc2UgdG88c3Bhbgotc3R5bGU9J2NvbG9yOnJlZCc+IDwvc3Bhbj5yZXByb2R1Y2UsIHByZXBhcmUgZGVyaXZhdGl2ZSB3b3JrcyBvZiwgcHVibGljbHkKLWRpc3BsYXksIHB1YmxpY2x5IHBlcmZvcm0sIGRpc3RyaWJ1dGUgYW5kIHN1YmxpY2Vuc2UgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoCi1Db250cmlidXRvciwgaWYgYW55LCBhbmQgc3VjaCBkZXJpdmF0aXZlIHdvcmtzLCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUKLWZvcm0uPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikKLVN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMKLVJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSw8c3BhbiBzdHlsZT0nY29sb3I6Z3JlZW4nPiA8L3NwYW4+cm95YWx0eS1mcmVlCi1wYXRlbnQgbGljZW5zZSB1bmRlciBMaWNlbnNlZCBQYXRlbnRzIHRvIG1ha2UsIHVzZSwgc2VsbCwgb2ZmZXIgdG8gc2VsbCwgaW1wb3J0Ci1hbmQgb3RoZXJ3aXNlIHRyYW5zZmVyIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBpbiBzb3VyY2UKLWNvZGUgYW5kIG9iamVjdCBjb2RlIGZvcm0uIFRoaXMgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgYXBwbHkgdG8gdGhlIGNvbWJpbmF0aW9uCi1vZiB0aGUgQ29udHJpYnV0aW9uIGFuZCB0aGUgUHJvZ3JhbSBpZiwgYXQgdGhlIHRpbWUgdGhlIENvbnRyaWJ1dGlvbiBpcyBhZGRlZAotYnkgdGhlIENvbnRyaWJ1dG9yLCBzdWNoIGFkZGl0aW9uIG9mIHRoZSBDb250cmlidXRpb24gY2F1c2VzIHN1Y2ggY29tYmluYXRpb24KLXRvIGJlIGNvdmVyZWQgYnkgdGhlIExpY2Vuc2VkIFBhdGVudHMuIFRoZSBwYXRlbnQgbGljZW5zZSBzaGFsbCBub3QgYXBwbHkgdG8KLWFueSBvdGhlciBjb21iaW5hdGlvbnMgd2hpY2ggaW5jbHVkZSB0aGUgQ29udHJpYnV0aW9uLiBObyBoYXJkd2FyZSBwZXIgc2UgaXMKLWxpY2Vuc2VkIGhlcmV1bmRlci4gPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YykKLVJlY2lwaWVudCB1bmRlcnN0YW5kcyB0aGF0IGFsdGhvdWdoIGVhY2ggQ29udHJpYnV0b3IgZ3JhbnRzIHRoZSBsaWNlbnNlcyB0byBpdHMKLUNvbnRyaWJ1dGlvbnMgc2V0IGZvcnRoIGhlcmVpbiwgbm8gYXNzdXJhbmNlcyBhcmUgcHJvdmlkZWQgYnkgYW55IENvbnRyaWJ1dG9yCi10aGF0IHRoZSBQcm9ncmFtIGRvZXMgbm90IGluZnJpbmdlIHRoZSBwYXRlbnQgb3Igb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5Ci1yaWdodHMgb2YgYW55IG90aGVyIGVudGl0eS4gRWFjaCBDb250cmlidXRvciBkaXNjbGFpbXMgYW55IGxpYWJpbGl0eSB0byBSZWNpcGllbnQKLWZvciBjbGFpbXMgYnJvdWdodCBieSBhbnkgb3RoZXIgZW50aXR5IGJhc2VkIG9uIGluZnJpbmdlbWVudCBvZiBpbnRlbGxlY3R1YWwKLXByb3BlcnR5IHJpZ2h0cyBvciBvdGhlcndpc2UuIEFzIGEgY29uZGl0aW9uIHRvIGV4ZXJjaXNpbmcgdGhlIHJpZ2h0cyBhbmQKLWxpY2Vuc2VzIGdyYW50ZWQgaGVyZXVuZGVyLCBlYWNoIFJlY2lwaWVudCBoZXJlYnkgYXNzdW1lcyBzb2xlIHJlc3BvbnNpYmlsaXR5Ci10byBzZWN1cmUgYW55IG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgbmVlZGVkLCBpZiBhbnkuIEZvciBleGFtcGxlLAotaWYgYSB0aGlyZCBwYXJ0eSBwYXRlbnQgbGljZW5zZSBpcyByZXF1aXJlZCB0byBhbGxvdyBSZWNpcGllbnQgdG8gZGlzdHJpYnV0ZQotdGhlIFByb2dyYW0sIGl0IGlzIFJlY2lwaWVudCdzIHJlc3BvbnNpYmlsaXR5IHRvIGFjcXVpcmUgdGhhdCBsaWNlbnNlIGJlZm9yZQotZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtLjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmQpCi1FYWNoIENvbnRyaWJ1dG9yIHJlcHJlc2VudHMgdGhhdCB0byBpdHMga25vd2xlZGdlIGl0IGhhcyBzdWZmaWNpZW50IGNvcHlyaWdodAotcmlnaHRzIGluIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgdG8gZ3JhbnQgdGhlIGNvcHlyaWdodCBsaWNlbnNlIHNldCBmb3J0aCBpbgotdGhpcyBBZ3JlZW1lbnQuIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4zLiBSRVFVSVJFTUVOVFM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5BIENvbnRyaWJ1dG9yIG1heSBjaG9vc2UgdG8gZGlzdHJpYnV0ZSB0aGUKLVByb2dyYW0gaW4gb2JqZWN0IGNvZGUgZm9ybSB1bmRlciBpdHMgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBwcm92aWRlZCB0aGF0Ojwvc3Bhbj4KLTwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWl0IGNvbXBsaWVzIHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50OyBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKQotaXRzIGxpY2Vuc2UgYWdyZWVtZW50Ojwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmkpCi1lZmZlY3RpdmVseSBkaXNjbGFpbXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIHdhcnJhbnRpZXMgYW5kCi1jb25kaXRpb25zLCBleHByZXNzIGFuZCBpbXBsaWVkLCBpbmNsdWRpbmcgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIHRpdGxlCi1hbmQgbm9uLWluZnJpbmdlbWVudCwgYW5kIGltcGxpZWQgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIG1lcmNoYW50YWJpbGl0eQotYW5kIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlOyA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paSkKLWVmZmVjdGl2ZWx5IGV4Y2x1ZGVzIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCBsaWFiaWxpdHkgZm9yIGRhbWFnZXMsCi1pbmNsdWRpbmcgZGlyZWN0LCBpbmRpcmVjdCwgc3BlY2lhbCwgaW5jaWRlbnRhbCBhbmQgY29uc2VxdWVudGlhbCBkYW1hZ2VzLCBzdWNoCi1hcyBsb3N0IHByb2ZpdHM7IDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpaSkKLXN0YXRlcyB0aGF0IGFueSBwcm92aXNpb25zIHdoaWNoIGRpZmZlciBmcm9tIHRoaXMgQWdyZWVtZW50IGFyZSBvZmZlcmVkIGJ5IHRoYXQKLUNvbnRyaWJ1dG9yIGFsb25lIGFuZCBub3QgYnkgYW55IG90aGVyIHBhcnR5OyBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pdikKLXN0YXRlcyB0aGF0IHNvdXJjZSBjb2RlIGZvciB0aGUgUHJvZ3JhbSBpcyBhdmFpbGFibGUgZnJvbSBzdWNoIENvbnRyaWJ1dG9yLCBhbmQKLWluZm9ybXMgbGljZW5zZWVzIGhvdyB0byBvYnRhaW4gaXQgaW4gYSByZWFzb25hYmxlIG1hbm5lciBvbiBvciB0aHJvdWdoIGEKLW1lZGl1bSBjdXN0b21hcmlseSB1c2VkIGZvciBzb2Z0d2FyZSBleGNoYW5nZS48c3BhbiBzdHlsZT0nY29sb3I6Ymx1ZSc+IDwvc3Bhbj48L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+V2hlbiB0aGUgUHJvZ3JhbSBpcyBtYWRlIGF2YWlsYWJsZSBpbiBzb3VyY2UKLWNvZGUgZm9ybTo8L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWl0IG11c3QgYmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhpcyBBZ3JlZW1lbnQ7IGFuZCA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKSBhCi1jb3B5IG9mIHRoaXMgQWdyZWVtZW50IG11c3QgYmUgaW5jbHVkZWQgd2l0aCBlYWNoIGNvcHkgb2YgdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Db250cmlidXRvcnMgbWF5IG5vdCByZW1vdmUgb3IgYWx0ZXIgYW55Ci1jb3B5cmlnaHQgbm90aWNlcyBjb250YWluZWQgd2l0aGluIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RWFjaCBDb250cmlidXRvciBtdXN0IGlkZW50aWZ5IGl0c2VsZiBhcyB0aGUKLW9yaWdpbmF0b3Igb2YgaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCBpbiBhIG1hbm5lciB0aGF0IHJlYXNvbmFibHkgYWxsb3dzCi1zdWJzZXF1ZW50IFJlY2lwaWVudHMgdG8gaWRlbnRpZnkgdGhlIG9yaWdpbmF0b3Igb2YgdGhlIENvbnRyaWJ1dGlvbi4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjQuIENPTU1FUkNJQUwgRElTVFJJQlVUSU9OPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Q29tbWVyY2lhbCBkaXN0cmlidXRvcnMgb2Ygc29mdHdhcmUgbWF5Ci1hY2NlcHQgY2VydGFpbiByZXNwb25zaWJpbGl0aWVzIHdpdGggcmVzcGVjdCB0byBlbmQgdXNlcnMsIGJ1c2luZXNzIHBhcnRuZXJzCi1hbmQgdGhlIGxpa2UuIFdoaWxlIHRoaXMgbGljZW5zZSBpcyBpbnRlbmRlZCB0byBmYWNpbGl0YXRlIHRoZSBjb21tZXJjaWFsIHVzZQotb2YgdGhlIFByb2dyYW0sIHRoZSBDb250cmlidXRvciB3aG8gaW5jbHVkZXMgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsCi1wcm9kdWN0IG9mZmVyaW5nIHNob3VsZCBkbyBzbyBpbiBhIG1hbm5lciB3aGljaCBkb2VzIG5vdCBjcmVhdGUgcG90ZW50aWFsCi1saWFiaWxpdHkgZm9yIG90aGVyIENvbnRyaWJ1dG9ycy4gVGhlcmVmb3JlLCBpZiBhIENvbnRyaWJ1dG9yIGluY2x1ZGVzIHRoZQotUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgc3VjaCBDb250cmlidXRvciAoJnF1b3Q7Q29tbWVyY2lhbAotQ29udHJpYnV0b3ImcXVvdDspIGhlcmVieSBhZ3JlZXMgdG8gZGVmZW5kIGFuZCBpbmRlbW5pZnkgZXZlcnkgb3RoZXIKLUNvbnRyaWJ1dG9yICgmcXVvdDtJbmRlbW5pZmllZCBDb250cmlidXRvciZxdW90OykgYWdhaW5zdCBhbnkgbG9zc2VzLCBkYW1hZ2VzIGFuZAotY29zdHMgKGNvbGxlY3RpdmVseSAmcXVvdDtMb3NzZXMmcXVvdDspIGFyaXNpbmcgZnJvbSBjbGFpbXMsIGxhd3N1aXRzIGFuZCBvdGhlcgotbGVnYWwgYWN0aW9ucyBicm91Z2h0IGJ5IGEgdGhpcmQgcGFydHkgYWdhaW5zdCB0aGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgdG8KLXRoZSBleHRlbnQgY2F1c2VkIGJ5IHRoZSBhY3RzIG9yIG9taXNzaW9ucyBvZiBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4KLWNvbm5lY3Rpb24gd2l0aCBpdHMgZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0Ci1vZmZlcmluZy4gVGhlIG9ibGlnYXRpb25zIGluIHRoaXMgc2VjdGlvbiBkbyBub3QgYXBwbHkgdG8gYW55IGNsYWltcyBvciBMb3NzZXMKLXJlbGF0aW5nIHRvIGFueSBhY3R1YWwgb3IgYWxsZWdlZCBpbnRlbGxlY3R1YWwgcHJvcGVydHkgaW5mcmluZ2VtZW50LiBJbiBvcmRlcgotdG8gcXVhbGlmeSwgYW4gSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbXVzdDogYSkgcHJvbXB0bHkgbm90aWZ5IHRoZSBDb21tZXJjaWFsCi1Db250cmlidXRvciBpbiB3cml0aW5nIG9mIHN1Y2ggY2xhaW0sIGFuZCBiKSBhbGxvdyB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvcgotdG8gY29udHJvbCwgYW5kIGNvb3BlcmF0ZSB3aXRoIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluLCB0aGUgZGVmZW5zZSBhbmQKLWFueSByZWxhdGVkIHNldHRsZW1lbnQgbmVnb3RpYXRpb25zLiBUaGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbWF5IHBhcnRpY2lwYXRlCi1pbiBhbnkgc3VjaCBjbGFpbSBhdCBpdHMgb3duIGV4cGVuc2UuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Gb3IgZXhhbXBsZSwgYSBDb250cmlidXRvciBtaWdodCBpbmNsdWRlIHRoZQotUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgUHJvZHVjdCBYLiBUaGF0IENvbnRyaWJ1dG9yIGlzIHRoZW4gYQotQ29tbWVyY2lhbCBDb250cmlidXRvci4gSWYgdGhhdCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRoZW4gbWFrZXMgcGVyZm9ybWFuY2UKLWNsYWltcywgb3Igb2ZmZXJzIHdhcnJhbnRpZXMgcmVsYXRlZCB0byBQcm9kdWN0IFgsIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQKLXdhcnJhbnRpZXMgYXJlIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvcidzIHJlc3BvbnNpYmlsaXR5IGFsb25lLiBVbmRlciB0aGlzCi1zZWN0aW9uLCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB3b3VsZCBoYXZlIHRvIGRlZmVuZCBjbGFpbXMgYWdhaW5zdCB0aGUKLW90aGVyIENvbnRyaWJ1dG9ycyByZWxhdGVkIHRvIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcywgYW5kIGlmIGEKLWNvdXJ0IHJlcXVpcmVzIGFueSBvdGhlciBDb250cmlidXRvciB0byBwYXkgYW55IGRhbWFnZXMgYXMgYSByZXN1bHQsIHRoZQotQ29tbWVyY2lhbCBDb250cmlidXRvciBtdXN0IHBheSB0aG9zZSBkYW1hZ2VzLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+NS4gTk8gV0FSUkFOVFk8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTCi1BR1JFRU1FTlQsIFRIRSBQUk9HUkFNIElTIFBST1ZJREVEIE9OIEFOICZxdW90O0FTIElTJnF1b3Q7IEJBU0lTLCBXSVRIT1VUCi1XQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIEVJVEhFUiBFWFBSRVNTIE9SIElNUExJRUQgSU5DTFVESU5HLAotV0lUSE9VVCBMSU1JVEFUSU9OLCBBTlkgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIFRJVExFLCBOT04tSU5GUklOR0VNRU5ULAotTUVSQ0hBTlRBQklMSVRZIE9SIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBFYWNoIFJlY2lwaWVudCBpcyBzb2xlbHkKLXJlc3BvbnNpYmxlIGZvciBkZXRlcm1pbmluZyB0aGUgYXBwcm9wcmlhdGVuZXNzIG9mIHVzaW5nIGFuZCBkaXN0cmlidXRpbmcgdGhlCi1Qcm9ncmFtIGFuZCBhc3N1bWVzIGFsbCByaXNrcyBhc3NvY2lhdGVkIHdpdGggaXRzIGV4ZXJjaXNlIG9mIHJpZ2h0cyB1bmRlciB0aGlzCi1BZ3JlZW1lbnQgLCBpbmNsdWRpbmcgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSByaXNrcyBhbmQgY29zdHMgb2YgcHJvZ3JhbSBlcnJvcnMsCi1jb21wbGlhbmNlIHdpdGggYXBwbGljYWJsZSBsYXdzLCBkYW1hZ2UgdG8gb3IgbG9zcyBvZiBkYXRhLCBwcm9ncmFtcyBvcgotZXF1aXBtZW50LCBhbmQgdW5hdmFpbGFiaWxpdHkgb3IgaW50ZXJydXB0aW9uIG9mIG9wZXJhdGlvbnMuIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz42LiBESVNDTEFJTUVSIE9GIExJQUJJTElUWTwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMKLUFHUkVFTUVOVCwgTkVJVEhFUiBSRUNJUElFTlQgTk9SIEFOWSBDT05UUklCVVRPUlMgU0hBTEwgSEFWRSBBTlkgTElBQklMSVRZIEZPUgotQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0oSU5DTFVESU5HIFdJVEhPVVQgTElNSVRBVElPTiBMT1NUIFBST0ZJVFMpLCBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQotT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcKLU5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT1IgRElTVFJJQlVUSU9OIE9GCi1USEUgUFJPR1JBTSBPUiBUSEUgRVhFUkNJU0UgT0YgQU5ZIFJJR0hUUyBHUkFOVEVEIEhFUkVVTkRFUiwgRVZFTiBJRiBBRFZJU0VEIE9GCi1USEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0VTLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Ny4gR0VORVJBTDwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPklmIGFueSBwcm92aXNpb24gb2YgdGhpcyBBZ3JlZW1lbnQgaXMgaW52YWxpZAotb3IgdW5lbmZvcmNlYWJsZSB1bmRlciBhcHBsaWNhYmxlIGxhdywgaXQgc2hhbGwgbm90IGFmZmVjdCB0aGUgdmFsaWRpdHkgb3IKLWVuZm9yY2VhYmlsaXR5IG9mIHRoZSByZW1haW5kZXIgb2YgdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBhbmQgd2l0aG91dAotZnVydGhlciBhY3Rpb24gYnkgdGhlIHBhcnRpZXMgaGVyZXRvLCBzdWNoIHByb3Zpc2lvbiBzaGFsbCBiZSByZWZvcm1lZCB0byB0aGUKLW1pbmltdW0gZXh0ZW50IG5lY2Vzc2FyeSB0byBtYWtlIHN1Y2ggcHJvdmlzaW9uIHZhbGlkIGFuZCBlbmZvcmNlYWJsZS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPklmIFJlY2lwaWVudCBpbnN0aXR1dGVzIHBhdGVudCBsaXRpZ2F0aW9uCi1hZ2FpbnN0IGFueSBlbnRpdHkgKGluY2x1ZGluZyBhIGNyb3NzLWNsYWltIG9yIGNvdW50ZXJjbGFpbSBpbiBhIGxhd3N1aXQpCi1hbGxlZ2luZyB0aGF0IHRoZSBQcm9ncmFtIGl0c2VsZiAoZXhjbHVkaW5nIGNvbWJpbmF0aW9ucyBvZiB0aGUgUHJvZ3JhbSB3aXRoCi1vdGhlciBzb2Z0d2FyZSBvciBoYXJkd2FyZSkgaW5mcmluZ2VzIHN1Y2ggUmVjaXBpZW50J3MgcGF0ZW50KHMpLCB0aGVuIHN1Y2gKLVJlY2lwaWVudCdzIHJpZ2h0cyBncmFudGVkIHVuZGVyIFNlY3Rpb24gMihiKSBzaGFsbCB0ZXJtaW5hdGUgYXMgb2YgdGhlIGRhdGUKLXN1Y2ggbGl0aWdhdGlvbiBpcyBmaWxlZC4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkFsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQKLXNoYWxsIHRlcm1pbmF0ZSBpZiBpdCBmYWlscyB0byBjb21wbHkgd2l0aCBhbnkgb2YgdGhlIG1hdGVyaWFsIHRlcm1zIG9yCi1jb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50IGFuZCBkb2VzIG5vdCBjdXJlIHN1Y2ggZmFpbHVyZSBpbiBhIHJlYXNvbmFibGUKLXBlcmlvZCBvZiB0aW1lIGFmdGVyIGJlY29taW5nIGF3YXJlIG9mIHN1Y2ggbm9uY29tcGxpYW5jZS4gSWYgYWxsIFJlY2lwaWVudCdzCi1yaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgdGVybWluYXRlLCBSZWNpcGllbnQgYWdyZWVzIHRvIGNlYXNlIHVzZSBhbmQKLWRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBhcyBzb29uIGFzIHJlYXNvbmFibHkgcHJhY3RpY2FibGUuIEhvd2V2ZXIsCi1SZWNpcGllbnQncyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIEFncmVlbWVudCBhbmQgYW55IGxpY2Vuc2VzIGdyYW50ZWQgYnkKLVJlY2lwaWVudCByZWxhdGluZyB0byB0aGUgUHJvZ3JhbSBzaGFsbCBjb250aW51ZSBhbmQgc3Vydml2ZS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkV2ZXJ5b25lIGlzIHBlcm1pdHRlZCB0byBjb3B5IGFuZCBkaXN0cmlidXRlCi1jb3BpZXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGJ1dCBpbiBvcmRlciB0byBhdm9pZCBpbmNvbnNpc3RlbmN5IHRoZSBBZ3JlZW1lbnQgaXMKLWNvcHlyaWdodGVkIGFuZCBtYXkgb25seSBiZSBtb2RpZmllZCBpbiB0aGUgZm9sbG93aW5nIG1hbm5lci4gVGhlIEFncmVlbWVudAotU3Rld2FyZCByZXNlcnZlcyB0aGUgcmlnaHQgdG8gcHVibGlzaCBuZXcgdmVyc2lvbnMgKGluY2x1ZGluZyByZXZpc2lvbnMpIG9mCi10aGlzIEFncmVlbWVudCBmcm9tIHRpbWUgdG8gdGltZS4gTm8gb25lIG90aGVyIHRoYW4gdGhlIEFncmVlbWVudCBTdGV3YXJkIGhhcwotdGhlIHJpZ2h0IHRvIG1vZGlmeSB0aGlzIEFncmVlbWVudC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyB0aGUgaW5pdGlhbAotQWdyZWVtZW50IFN0ZXdhcmQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWF5IGFzc2lnbiB0aGUgcmVzcG9uc2liaWxpdHkgdG8KLXNlcnZlIGFzIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCB0byBhIHN1aXRhYmxlIHNlcGFyYXRlIGVudGl0eS4gRWFjaCBuZXcgdmVyc2lvbgotb2YgdGhlIEFncmVlbWVudCB3aWxsIGJlIGdpdmVuIGEgZGlzdGluZ3Vpc2hpbmcgdmVyc2lvbiBudW1iZXIuIFRoZSBQcm9ncmFtCi0oaW5jbHVkaW5nIENvbnRyaWJ1dGlvbnMpIG1heSBhbHdheXMgYmUgZGlzdHJpYnV0ZWQgc3ViamVjdCB0byB0aGUgdmVyc2lvbiBvZgotdGhlIEFncmVlbWVudCB1bmRlciB3aGljaCBpdCB3YXMgcmVjZWl2ZWQuIEluIGFkZGl0aW9uLCBhZnRlciBhIG5ldyB2ZXJzaW9uIG9mCi10aGUgQWdyZWVtZW50IGlzIHB1Ymxpc2hlZCwgQ29udHJpYnV0b3IgbWF5IGVsZWN0IHRvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0KLShpbmNsdWRpbmcgaXRzIENvbnRyaWJ1dGlvbnMpIHVuZGVyIHRoZSBuZXcgdmVyc2lvbi4gRXhjZXB0IGFzIGV4cHJlc3NseSBzdGF0ZWQKLWluIFNlY3Rpb25zIDIoYSkgYW5kIDIoYikgYWJvdmUsIFJlY2lwaWVudCByZWNlaXZlcyBubyByaWdodHMgb3IgbGljZW5zZXMgdG8KLXRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgb2YgYW55IENvbnRyaWJ1dG9yIHVuZGVyIHRoaXMgQWdyZWVtZW50LCB3aGV0aGVyCi1leHByZXNzbHksIGJ5IGltcGxpY2F0aW9uLCBlc3RvcHBlbCBvciBvdGhlcndpc2UuIEFsbCByaWdodHMgaW4gdGhlIFByb2dyYW0gbm90Ci1leHByZXNzbHkgZ3JhbnRlZCB1bmRlciB0aGlzIEFncmVlbWVudCBhcmUgcmVzZXJ2ZWQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5UaGlzIEFncmVlbWVudCBpcyBnb3Zlcm5lZCBieSB0aGUgbGF3cyBvZiB0aGUKLVN0YXRlIG9mIE5ldyBZb3JrIGFuZCB0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGxhd3Mgb2YgdGhlIFVuaXRlZCBTdGF0ZXMgb2YKLUFtZXJpY2EuIE5vIHBhcnR5IHRvIHRoaXMgQWdyZWVtZW50IHdpbGwgYnJpbmcgYSBsZWdhbCBhY3Rpb24gdW5kZXIgdGhpcwotQWdyZWVtZW50IG1vcmUgdGhhbiBvbmUgeWVhciBhZnRlciB0aGUgY2F1c2Ugb2YgYWN0aW9uIGFyb3NlLiBFYWNoIHBhcnR5IHdhaXZlcwotaXRzIHJpZ2h0cyB0byBhIGp1cnkgdHJpYWwgaW4gYW55IHJlc3VsdGluZyBsaXRpZ2F0aW9uLjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PCFbaWYgIXN1cHBvcnRFbXB0eVBhcmFzXT4mbmJzcDs8IVtlbmRpZl0+PG86cD48L286cD48L3A+Ci0KLTwvZGl2PgotCi08L2JvZHk+Ci0KLTwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuYXNzZW1ibHkuZmVhdHVyZS9mZWF0dXJlLnByb3BlcnRpZXMgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuYXNzZW1ibHkuZmVhdHVyZS9mZWF0dXJlLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDBhZTQyYmIuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmFzc2VtYmx5LmZlYXR1cmUvZmVhdHVyZS5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTQ0ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgZmVhdHVyZS5wcm9wZXJ0aWVzCi0jIGNvbnRhaW5zIGV4dGVybmFsaXplZCBzdHJpbmdzIGZvciBmZWF0dXJlLnhtbAotIyAiJWZvbyIgaW4gZmVhdHVyZS54bWwgY29ycmVzcG9uZHMgdG8gdGhlIGtleSAiZm9vIiBpbiB0aGlzIGZpbGUKLSMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKLSMgVGhpcyBmaWxlIHNob3VsZCBiZSB0cmFuc2xhdGVkLgotCi0jICJmZWF0dXJlTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBmZWF0dXJlCi1mZWF0dXJlTmFtZT1KYXZhIFBlcnNpc3RlbmNlIEFQSSBUb29scwotCi0jICJwcm92aWRlck5hbWUiIHByb3BlcnR5IC0gbmFtZSBvZiB0aGUgY29tcGFueSB0aGF0IHByb3ZpZGVzIHRoZSBmZWF0dXJlCi1wcm92aWRlck5hbWU9RWNsaXBzZS5vcmcKLQotIyAidXBkYXRlU2l0ZU5hbWUiIHByb3BlcnR5IC0gbGFiZWwgZm9yIHRoZSB1cGRhdGUgc2l0ZQotdXBkYXRlU2l0ZU5hbWU9VGhlIEVjbGlwc2UgV2ViIFRvb2xzIFBsYXRmb3JtIChXVFApIFByb2plY3QgdXBkYXRlIHNpdGUKLQotIyAiZGVzY3JpcHRpb24iIHByb3BlcnR5IC0gZGVzY3JpcHRpb24gb2YgdGhlIGZlYXR1cmUKLWRlc2NyaXB0aW9uPUphdmEgUGVyc2lzdGVuY2UgQVBJIFRvb2xzIC0gUnVudGltZQotCi0jICJjb3B5cmlnaHQiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIENvcHlyaWdodCIKLWNvcHlyaWdodD1cCi1Db3B5cmlnaHQgKGMpIDIwMDYgT3JhY2xlIENvcnBvcmF0aW9uLlxuXAotQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFsc1xuXAotYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wXG5cCi13aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdFxuXAotaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWxcblwKLVxuXAotQ29udHJpYnV0b3JzOlxuXAotICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvblxuCi0jIyMjIyMjIyMjIyMjIyMjIGVuZCBvZiBjb3B5cmlnaHQgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0KLSMgImxpY2Vuc2VVUkwiIHByb3BlcnR5IC0gVVJMIG9mIHRoZSAiRmVhdHVyZSBMaWNlbnNlIgotIyBkbyBub3QgdHJhbnNsYXRlIHZhbHVlIC0ganVzdCBjaGFuZ2UgdG8gcG9pbnQgdG8gYSBsb2NhbGUtc3BlY2lmaWMgSFRNTCBwYWdlCi1saWNlbnNlVVJMPWxpY2Vuc2UuaHRtbAotCi0jICJsaWNlbnNlIiBwcm9wZXJ0eSAtIHRleHQgb2YgdGhlICJGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIgotIyBzaG91bGQgYmUgcGxhaW4gdGV4dCB2ZXJzaW9uIG9mIGxpY2Vuc2UgYWdyZWVtZW50IHBvaW50ZWQgdG8gYmUgImxpY2Vuc2VVUkwiCi1saWNlbnNlPVwKLUVDTElQU0UgRk9VTkRBVElPTiBTT0ZUV0FSRSBVU0VSIEFHUkVFTUVOVFxuXAotTWFyY2ggMTcsIDIwMDVcblwKLVxuXAotVXNhZ2UgT2YgQ29udGVudFxuXAotXG5cCi1USEUgRUNMSVBTRSBGT1VOREFUSU9OIE1BS0VTIEFWQUlMQUJMRSBTT0ZUV0FSRSwgRE9DVU1FTlRBVElPTiwgSU5GT1JNQVRJT04gQU5EL09SXG5cCi1PVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTIChDT0xMRUNUSVZFTFkgIkNPTlRFTlQiKS5cblwKLVVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJU1xuXAotQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SXG5cCi1OT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VXG5cCi1BR1JFRSBUSEFUIFlPVVIgVVNFIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRISVMgQUdSRUVNRU5UXG5cCi1BTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UU1xuXAotT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEVcblwKLVRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORCBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlNcblwKLU9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEXG5cCi1CRUxPVywgVEhFTiBZT1UgTUFZIE5PVCBVU0UgVEhFIENPTlRFTlQuXG5cCi1cblwKLUFwcGxpY2FibGUgTGljZW5zZXNcblwKLVxuXAotVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb25cblwKLWlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgUHVibGljXG5cCi1MaWNlbnNlIFZlcnNpb24gMS4wICgiRVBMIikuIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpc1xuXAotQ29udGVudCBhbmQgaXMgYWxzbyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuXG5cCi1Gb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC5cblwKLVxuXAotQ29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsXG5cCi1kb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlLm9yZyBDVlNcblwKLXJlcG9zaXRvcnkgKCJSZXBvc2l0b3J5IikgaW4gQ1ZTIG1vZHVsZXMgKCJNb2R1bGVzIikgYW5kIG1hZGUgYXZhaWxhYmxlXG5cCi1hcyBkb3dubG9hZGFibGUgYXJjaGl2ZXMgKCJEb3dubG9hZHMiKS5cblwKLVxuXAotICAgLSBDb250ZW50IG1heSBiZSBzdHJ1Y3R1cmVkIGFuZCBwYWNrYWdlZCBpbnRvIG1vZHVsZXMgdG8gZmFjaWxpdGF0ZSBkZWxpdmVyaW5nLFxuXAotICAgICBleHRlbmRpbmcsIGFuZCB1cGdyYWRpbmcgdGhlIENvbnRlbnQuIFR5cGljYWwgbW9kdWxlcyBtYXkgaW5jbHVkZSBwbHVnLWlucyAoIlBsdWctaW5zIiksXG5cCi0gICAgIHBsdWctaW4gZnJhZ21lbnRzICgiRnJhZ21lbnRzIiksIGFuZCBmZWF0dXJlcyAoIkZlYXR1cmVzIikuXG5cCi0gICAtIEVhY2ggUGx1Zy1pbiBvciBGcmFnbWVudCBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IG9yIEpBUiAoSmF2YT8gQVJjaGl2ZSlcblwKLSAgICAgaW4gYSBkaXJlY3RvcnkgbmFtZWQgInBsdWdpbnMiLlxuXAotICAgLSBBIEZlYXR1cmUgaXMgYSBidW5kbGUgb2Ygb25lIG9yIG1vcmUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhbmQgYXNzb2NpYXRlZCBtYXRlcmlhbC5cblwKLSAgICAgRWFjaCBGZWF0dXJlIG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3RvcnkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgImZlYXR1cmVzIi5cblwKLSAgICAgV2l0aGluIGEgRmVhdHVyZSwgZmlsZXMgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uXG5cCi0gICAgIG51bWJlcnMgb2YgdGhlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYXNzb2NpYXRlZCB3aXRoIHRoYXQgRmVhdHVyZS5cblwKLSAgIC0gRmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzXG5cCi0gICAgIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIEluY2x1ZGVkIEZlYXR1cmVzLlxuXAotXG5cCi1GZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgiSW5jbHVkZWQgRmVhdHVyZXMiKS4gRmlsZXMgbmFtZWRcblwKLSJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mXG5cCi1JbmNsdWRlZCBGZWF0dXJlcy5cblwKLVxuXAotVGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZVxuXAotY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICJhYm91dC5odG1sIiAoIkFib3V0cyIpLiBUaGUgdGVybXMgYW5kXG5cCi1jb25kaXRpb25zIGdvdmVybmluZyBGZWF0dXJlcyBhbmQgSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZFxuXAotaW4gZmlsZXMgbmFtZWQgImxpY2Vuc2UuaHRtbCIgKCJGZWF0dXJlIExpY2Vuc2VzIikuIEFib3V0cyBhbmQgRmVhdHVyZVxuXAotTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55IGRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZVxuXAotaW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyBsb2NhdGlvbnM6XG5cCi1cblwKLSAgIC0gVGhlIHRvcC1sZXZlbCAocm9vdCkgZGlyZWN0b3J5XG5cCi0gICAtIFBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzXG5cCi0gICAtIEluc2lkZSBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHBhY2thZ2VkIGFzIEpBUnNcblwKLSAgIC0gU3ViLWRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgInNyYyIgb2YgY2VydGFpbiBQbHVnLWluc1xuXAotICAgLSBGZWF0dXJlIGRpcmVjdG9yaWVzXG5cCi1cblwKLU5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIGluc3RhbGxlZCB1c2luZyB0aGVcblwKLUVjbGlwc2UgVXBkYXRlIE1hbmFnZXIsIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoIkZlYXR1cmUgVXBkYXRlXG5cCi1MaWNlbnNlIikgZHVyaW5nIHRoZSBpbnN0YWxsYXRpb24gcHJvY2Vzcy4gSWYgdGhlIEZlYXR1cmUgY29udGFpbnNcblwKLUluY2x1ZGVkIEZlYXR1cmVzLCB0aGUgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBzaG91bGQgZWl0aGVyIHByb3ZpZGUgeW91XG5cCi13aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgdGhlIEluY2x1ZGVkIEZlYXR1cmVzIG9yIGluZm9ybVxuXAoteW91IHdoZXJlIHlvdSBjYW4gbG9jYXRlIHRoZW0uIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSBmb3VuZCBpblxuXAotdGhlICJsaWNlbnNlIiBwcm9wZXJ0eSBvZiBmaWxlcyBuYW1lZCAiZmVhdHVyZS5wcm9wZXJ0aWVzIi4gU3VjaCBBYm91dHMsXG5cCi1GZWF0dXJlIExpY2Vuc2VzIGFuZCBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBjb250YWluIHRoZSB0ZXJtcyBhbmRcblwKLWNvbmRpdGlvbnMgKG9yIHJlZmVyZW5jZXMgdG8gc3VjaCB0ZXJtcyBhbmQgY29uZGl0aW9ucykgdGhhdCBnb3Zlcm4geW91clxuXAotdXNlIG9mIHRoZSBhc3NvY2lhdGVkIENvbnRlbnQgaW4gdGhhdCBkaXJlY3RvcnkuXG5cCi1cblwKLVRIRSBBQk9VVFMsIEZFQVRVUkUgTElDRU5TRVMgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUlxuXAotVE8gVEhFIEVQTCBPUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuXG5cCi1TT01FIE9GIFRIRVNFIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6XG5cCi1cblwKLSAgICAtIENvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sKVxuXAotICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UpXG5cCi0gICAgLSBBcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjApXG5cCi0gICAgLSBJQk0gUHVibGljIExpY2Vuc2UgMS4wIChhdmFpbGFibGUgYXQgaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2RldmVsb3BlcndvcmtzL29wZW5zb3VyY2UvbGljZW5zZTEwLmh0bWwpXG5cCi0gICAgLSBNZXRybyBMaW5rIFB1YmxpYyBMaWNlbnNlIDEuMDAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbClcblwKLSAgICAtIE1vemlsbGEgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjEgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWwpXG5cCi1cblwKLUlUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1JcblwKLVRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlXG5cCi1pcyBwcm92aWRlZCwgcGxlYXNlIGNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9uc1xuXAotZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LlxuXAotXG5cCi1DcnlwdG9ncmFwaHlcblwKLVxuXAotQ29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlXG5cCi1jdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsXG5cCi1hbmQvb3IgcmUtZXhwb3J0IHRvIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFXG5cCi11c2luZyBhbnkgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cyxcblwKLXJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIG9yIHVzZSxcblwKLWFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLlxuXAotXG5cCi1KYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIFN1biBNaWNyb3N5c3RlbXMsIEluYy4gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC5cbgotIyMjIyMjIyMjIyMgZW5kIG9mIGxpY2Vuc2UgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuYXNzZW1ibHkuZmVhdHVyZS9mZWF0dXJlLnhtbCBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5hc3NlbWJseS5mZWF0dXJlL2ZlYXR1cmUueG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2OTIwMzI2Li4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5hc3NlbWJseS5mZWF0dXJlL2ZlYXR1cmUueG1sCisrKyAvZGV2L251bGwKQEAgLTEsMzQgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxmZWF0dXJlCi0gICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LmFzc2VtYmx5LmZlYXR1cmUiCi0gICAgICBsYWJlbD0iJWZlYXR1cmVOYW1lIgotICAgICAgdmVyc2lvbj0iMi4xLjAucXVhbGlmaWVyIgotICAgICAgcHJvdmlkZXItbmFtZT0iJXByb3ZpZGVyTmFtZSIKLSAgICAgIGltYWdlPSJlY2xpcHNlX3VwZGF0ZV8xMjAuanBnIj4KLQotICAgPGRlc2NyaXB0aW9uPgotICAgICAgJWRlc2NyaXB0aW9uCi0gICA8L2Rlc2NyaXB0aW9uPgotCi0gICA8Y29weXJpZ2h0PgotICAgICAgJWNvcHlyaWdodAotICAgPC9jb3B5cmlnaHQ+Ci0KLSAgIDxsaWNlbnNlIHVybD0ibGljZW5zZS5odG1sIj4KLSAgICAgICVsaWNlbnNlCi0gICA8L2xpY2Vuc2U+Ci0KLSAgIDx1cmw+Ci0gICAgICA8dXBkYXRlIGxhYmVsPSIldXBkYXRlU2l0ZU5hbWUiIHVybD0iaHR0cDovL2Rvd25sb2FkLmVjbGlwc2Uub3JnL3dlYnRvb2xzL3VwZGF0ZXMiLz4KLSAgICAgIDxkaXNjb3ZlcnkgbGFiZWw9IldlYiBUb29scyBQbGF0Zm9ybSAoV1RQKSBVcGRhdGVzIiB1cmw9Imh0dHA6Ly9kb3dubG9hZC5lY2xpcHNlLm9yZy93ZWJ0b29scy91cGRhdGVzIi8+Ci0gICA8L3VybD4KLQotICAgPGluY2x1ZGVzCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LmZlYXR1cmUiCi0gICAgICAgICB2ZXJzaW9uPSIwLjAuMCIvPgotCi0gICA8aW5jbHVkZXMKLSAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZSIKLSAgICAgICAgIHZlcnNpb249IjAuMC4wIi8+Ci0KLTwvZmVhdHVyZT4KZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5hc3NlbWJseS5mZWF0dXJlL2xpY2Vuc2UuaHRtbCBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5hc3NlbWJseS5mZWF0dXJlL2xpY2Vuc2UuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjM0NzA2MC4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuYXNzZW1ibHkuZmVhdHVyZS9saWNlbnNlLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSw5MyArMCwwIEBACi08IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wMSBUcmFuc2l0aW9uYWwvL0VOIiAiaHR0cDovL3d3dy53M2Mub3JnL1RSLzE5OTkvUkVDLWh0bWw0MDEtMTk5OTEyMjQvbG9vc2UuZHRkIj4KLTwhLS0gc2F2ZWQgZnJvbSB1cmw9KDAwNDQpaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwvbm90aWNlLmh0bWwgLS0+Ci08SFRNTD48SEVBRD48VElUTEU+RWNsaXBzZS5vcmcgU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L1RJVExFPgotPE1FVEEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PWlzby04ODU5LTEiPgotPE1FVEEgY29udGVudD0iTVNIVE1MIDYuMDAuMjgwMC4xNDc5IiBuYW1lPUdFTkVSQVRPUj48L0hFQUQ+Ci08Qk9EWSBsYW5nPUVOLVVTIHZMaW5rPXB1cnBsZSBsaW5rPWJsdWU+Ci08SDI+RWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9IMj4KLTxQPkphbnVhcnkgMjgsIDIwMDU8L1A+Ci08SDM+VXNhZ2UgT2YgQ29udGVudDwvSDM+Ci08UD5USEUgRUNMSVBTRSBGT1VOREFUSU9OIE1BS0VTIEFWQUlMQUJMRSBTT0ZUV0FSRSwgRE9DVU1FTlRBVElPTiwgSU5GT1JNQVRJT04gCi1BTkQvT1IgT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUyAoQ09MTEVDVElWRUxZICJDT05URU5UIikuIFVTRSBPRiAKLVRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIAotVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgCi1CRUxPVy4gQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVSBBR1JFRSBUSEFUIFlPVVIgVVNFIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIAotQlkgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIAotQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiBJRiBZT1UgRE8gTk9UIEFHUkVFIFRPIFRIRSAKLVRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORCBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIAotQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVywgVEhFTiBZT1UgCi1NQVkgTk9UIFVTRSBUSEUgQ09OVEVOVC48L1A+Ci08SDM+QXBwbGljYWJsZSBMaWNlbnNlczwvSDM+Ci08UD5Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgCi1Gb3VuZGF0aW9uIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgCi1QdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXMgCi1Db250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCA8QSAKLWhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvQT4uIAotRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9QPgotPFA+Q29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsIAotZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZS5vcmcgQ1ZTIHJlcG9zaXRvcnkgCi0oIlJlcG9zaXRvcnkiKSBpbiBDVlMgbW9kdWxlcyAoIk1vZHVsZXMiKSBhbmQgbWFkZSBhdmFpbGFibGUgYXMgZG93bmxvYWRhYmxlIAotYXJjaGl2ZXMgKCJEb3dubG9hZHMiKS48L1A+Ci08UD5Db250ZW50IG1heSBiZSBhcHBvcnRpb25lZCBpbnRvIHBsdWctaW5zICgiUGx1Zy1pbnMiKSwgcGx1Zy1pbiBmcmFnbWVudHMgCi0oIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLiBBIEZlYXR1cmUgaXMgYSBidW5kbGUgb2Ygb25lIG9yIG1vcmUgCi1QbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLiBGaWxlcyBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSAKLWNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIHRoZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIAotYXNzb2NpYXRlZCB3aXRoIGEgRmVhdHVyZS4gUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBhcmUgbG9jYXRlZCBpbiBkaXJlY3RvcmllcyAKLW5hbWVkICJwbHVnaW5zIiBhbmQgRmVhdHVyZXMgYXJlIGxvY2F0ZWQgaW4gZGlyZWN0b3JpZXMgbmFtZWQgImZlYXR1cmVzIi48L1A+Ci08UD5GZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgiSW5jbHVkZWQgRmVhdHVyZXMiKS4gRmlsZXMgbmFtZWQgCi0iZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCAKLUZlYXR1cmVzLjwvUD4KLTxQPlRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmUgY29udGFpbmVkIAotaW4gZmlsZXMgbmFtZWQgImFib3V0Lmh0bWwiICgiQWJvdXRzIikuIFRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgCi1GZWF0dXJlcyBhbmQgSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAibGljZW5zZS5odG1sIiAKLSgiRmVhdHVyZSBMaWNlbnNlcyIpLiBBYm91dHMgYW5kIEZlYXR1cmUgTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55IAotZGlyZWN0b3J5IG9mIGEgRG93bmxvYWQgb3IgTW9kdWxlIGluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgCi1sb2NhdGlvbnM6PC9QPgotPFVMPgotICA8TEk+VGhlIHRvcC1sZXZlbCAocm9vdCkgZGlyZWN0b3J5IAotICA8TEk+UGx1Zy1pbiBhbmQgRnJhZ21lbnQgZGlyZWN0b3JpZXMgCi0gIDxMST5TdWJkaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnMgCi0gIDxMST5GZWF0dXJlIGRpcmVjdG9yaWVzIDwvTEk+PC9VTD4KLTxQPk5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIGluc3RhbGxlZCAKLXVzaW5nIHRoZSBFY2xpcHNlIFVwZGF0ZSBNYW5hZ2VyLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFVwZGF0ZSAKLUxpY2Vuc2UiKSBkdXJpbmcgdGhlIGluc3RhbGxhdGlvbiBwcm9jZXNzLiBJZiB0aGUgRmVhdHVyZSBjb250YWlucyBJbmNsdWRlZCAKLUZlYXR1cmVzLCB0aGUgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBzaG91bGQgZWl0aGVyIHByb3ZpZGUgeW91IHdpdGggdGhlIHRlcm1zIAotYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvciBpbmZvcm0geW91IHdoZXJlIHlvdSBjYW4gCi1sb2NhdGUgdGhlbS4gRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgbWF5IGJlIGZvdW5kIGluIHRoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgCi1maWxlcyBuYW1lZCAiZmVhdHVyZS5wcm9wZXJ0aWVzIi4gU3VjaCBBYm91dHMsIEZlYXR1cmUgTGljZW5zZXMgYW5kIEZlYXR1cmUgCi1VcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgKG9yIHJlZmVyZW5jZXMgdG8gc3VjaCB0ZXJtcyAKLWFuZCBjb25kaXRpb25zKSB0aGF0IGdvdmVybiB5b3VyIHVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluIHRoYXQgCi1kaXJlY3RvcnkuPC9QPgotPFA+VEhFIEFCT1VUUywgRkVBVFVSRSBMSUNFTlNFUyBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSIFRPIFRIRSBFUEwgCi1PUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuIFNPTUUgT0YgVEhFU0UgCi1PVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOjwvUD4KLTxVTD4KLSAgPExJPkNvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWw8L0E+KSAKLQotICA8TEk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRTwvQT4pIAotCi0gIDxMST5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjA8L0E+KSAKLQotICA8TEk+SUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vZGV2ZWxvcGVyd29ya3Mvb3BlbnNvdXJjZS9saWNlbnNlMTAuaHRtbCI+aHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2RldmVsb3BlcndvcmtzL29wZW5zb3VyY2UvbGljZW5zZTEwLmh0bWw8L0E+KSAKLQotICA8TEk+TWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sIj5odHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbDwvQT4pIAotCi0gIDxMST5Nb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbCI+aHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sPC9BPikgCi0gIDwvTEk+PC9VTD4KLTxQPklUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1IgCi1UTyBVU0UgT0YgVEhFIENPTlRFTlQuIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2Ugb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBpcyAKLXByb3ZpZGVkLCBwbGVhc2UgY29udGFjdCB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHRvIGRldGVybWluZSB3aGF0IHRlcm1zIGFuZCAKLWNvbmRpdGlvbnMgZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LjwvUD4KLTxIMz5DcnlwdG9ncmFwaHk8L0gzPgotPFA+Q29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlIAotY3VycmVudGx5IG1heSBoYXZlIHJlc3RyaWN0aW9ucyBvbiB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBhbmQgdXNlLCBhbmQvb3IgCi1yZS1leHBvcnQgdG8gYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkUgdXNpbmcgYW55IAotZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cywgcmVndWxhdGlvbnMgYW5kIHBvbGljaWVzIAotY29uY2VybmluZyB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgCi10byBzZWUgaWYgdGhpcyBpcyBwZXJtaXR0ZWQuPC9QPjwvQk9EWT48L0hUTUw+CmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQucGF0Y2gvLnByb2plY3QgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQucGF0Y2gvLnByb2plY3QKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGI3YTJiZjUuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnBhdGNoLy5wcm9qZWN0CisrKyAvZGV2L251bGwKQEAgLTEsMTcgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxwcm9qZWN0RGVzY3JpcHRpb24+Ci0JPG5hbWU+b3JnLmVjbGlwc2UuanB0LnBhdGNoPC9uYW1lPgotCTxjb21tZW50PjwvY29tbWVudD4KLQk8cHJvamVjdHM+Ci0JPC9wcm9qZWN0cz4KLQk8YnVpbGRTcGVjPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLkZlYXR1cmVCdWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQk8L2J1aWxkU3BlYz4KLQk8bmF0dXJlcz4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5wZGUuRmVhdHVyZU5hdHVyZTwvbmF0dXJlPgotCTwvbmF0dXJlcz4KLTwvcHJvamVjdERlc2NyaXB0aW9uPgpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnBhdGNoL2J1aWxkLnByb3BlcnRpZXMgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQucGF0Y2gvYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzM4MWZiMi4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQucGF0Y2gvYnVpbGQucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDEwICswLDAgQEAKLWJpbi5pbmNsdWRlcyA9IGZlYXR1cmUueG1sLFwKLSAgICAgICAgICAgICAgIGxpY2Vuc2UuaHRtbCxcCi0gICAgICAgICAgICAgICBmZWF0dXJlLnByb3BlcnRpZXMsXAotICAgICAgICAgICAgICAgZXBsLXYxMC5odG1sLFwKLSAgICAgICAgICAgICAgIGVjbGlwc2VfdXBkYXRlXzEyMC5qcGcKLXNyYy5pbmNsdWRlcyA9IGVjbGlwc2VfdXBkYXRlXzEyMC5qcGcsXAotICAgICAgICAgICAgICAgZXBsLXYxMC5odG1sLFwKLSAgICAgICAgICAgICAgIGZlYXR1cmUucHJvcGVydGllcyxcCi0gICAgICAgICAgICAgICBmZWF0dXJlLnhtbCxcCi0gICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwKZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5wYXRjaC9idWlsZG5vdGVzX29yZy5lY2xpcHNlLmpwdC5wYXRjaC5odG1sIGIvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnBhdGNoL2J1aWxkbm90ZXNfb3JnLmVjbGlwc2UuanB0LnBhdGNoLmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDBkMTE1ZjQuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnBhdGNoL2J1aWxkbm90ZXNfb3JnLmVjbGlwc2UuanB0LnBhdGNoLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSwyMCArMCwwIEBACi08IWRvY3R5cGUgaHRtbCBwdWJsaWMgIi0vL3czYy8vZHRkIGh0bWwgNC4wIHRyYW5zaXRpb25hbC8vZW4iPgotPGh0bWw+Ci0KLTxoZWFkPgotICAgPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9aXNvLTg4NTktMSI+Ci0gICA8bWV0YSBuYW1lPSJCdWlsZCIgY29udGVudD0iQnVpbGQiPgotICAgPHRpdGxlPkphdmEgUGVyc2lzdGVuY2UgVG9vbHMgKEpUUCkgMS4wLjIgUGF0Y2hlczwvdGl0bGU+Ci08L2hlYWQ+Ci0KLTxib2R5PgotCi08aDE+SlRQIDIuMC4yIFBhdGNoZXM8L2gxPgotCi08aDI+RmVhdHVyZSBQYXRjaGVkOiBvcmcuZWNsaXBzZS5qcHQucGF0Y2g8L2gyPgotPGgzPlBsdWdpbihzKSByZXBsYWNlZDo8L2gzPgotPHVsPjxsaT5vcmcuZWNsaXBzZS5qcHQuZ2VuPC9saT48L3VsPgotPHA+QnVnIDxhIGhyZWY9J2h0dHBzOi8vYnVncy5lY2xpcHNlLm9yZy8yMjAyOTcnPjIyMDI5NzwvYT4uIEVudGl0eSBnZW5lcmF0aW9uIGNyZWF0ZXMgRW1iZWRkYWJsZXMgd2l0aCBjb21waWxlIGVycm9ycyBpbiBzb21lIGNhc2VzLjwvcD4KLQotCi08L2JvZHk+PC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5wYXRjaC9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnIGIvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnBhdGNoL2VjbGlwc2VfdXBkYXRlXzEyMC5qcGcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJmZGY3MDguLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnBhdGNoL2VjbGlwc2VfdXBkYXRlXzEyMC5qcGcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQucGF0Y2gvZXBsLXYxMC5odG1sIGIvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnBhdGNoL2VwbC12MTAuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWQ0YjE5Ni4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQucGF0Y2gvZXBsLXYxMC5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsMzI4ICswLDAgQEAKLTxodG1sIHhtbG5zOm89InVybjpzY2hlbWFzLW1pY3Jvc29mdC1jb206b2ZmaWNlOm9mZmljZSIKLXhtbG5zOnc9InVybjpzY2hlbWFzLW1pY3Jvc29mdC1jb206b2ZmaWNlOndvcmQiCi14bWxucz0iaHR0cDovL3d3dy53My5vcmcvVFIvUkVDLWh0bWw0MCI+Ci0KLTxoZWFkPgotPG1ldGEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXdpbmRvd3MtMTI1MiI+Ci08bWV0YSBuYW1lPVByb2dJZCBjb250ZW50PVdvcmQuRG9jdW1lbnQ+Ci08bWV0YSBuYW1lPUdlbmVyYXRvciBjb250ZW50PSJNaWNyb3NvZnQgV29yZCA5Ij4KLTxtZXRhIG5hbWU9T3JpZ2luYXRvciBjb250ZW50PSJNaWNyb3NvZnQgV29yZCA5Ij4KLTxsaW5rIHJlbD1GaWxlLUxpc3QKLWhyZWY9Ii4vRWNsaXBzZSUyMEVQTCUyMDIwMDNfMTFfMTAlMjBGaW5hbF9maWxlcy9maWxlbGlzdC54bWwiPgotPHRpdGxlPkVjbGlwc2UgUHVibGljIExpY2Vuc2UgLSBWZXJzaW9uIDEuMDwvdGl0bGU+Ci08IS0tW2lmIGd0ZSBtc28gOV0+PHhtbD4KLSA8bzpEb2N1bWVudFByb3BlcnRpZXM+Ci0gIDxvOlJldmlzaW9uPjI8L286UmV2aXNpb24+Ci0gIDxvOlRvdGFsVGltZT4zPC9vOlRvdGFsVGltZT4KLSAgPG86Q3JlYXRlZD4yMDA0LTAzLTA1VDIzOjAzOjAwWjwvbzpDcmVhdGVkPgotICA8bzpMYXN0U2F2ZWQ+MjAwNC0wMy0wNVQyMzowMzowMFo8L286TGFzdFNhdmVkPgotICA8bzpQYWdlcz40PC9vOlBhZ2VzPgotICA8bzpXb3Jkcz4xNjI2PC9vOldvcmRzPgotICA8bzpDaGFyYWN0ZXJzPjkyNzA8L286Q2hhcmFjdGVycz4KLSAgIDxvOkxpbmVzPjc3PC9vOkxpbmVzPgotICA8bzpQYXJhZ3JhcGhzPjE4PC9vOlBhcmFncmFwaHM+Ci0gIDxvOkNoYXJhY3RlcnNXaXRoU3BhY2VzPjExMzg0PC9vOkNoYXJhY3RlcnNXaXRoU3BhY2VzPgotICA8bzpWZXJzaW9uPjkuNDQwMjwvbzpWZXJzaW9uPgotIDwvbzpEb2N1bWVudFByb3BlcnRpZXM+Ci08L3htbD48IVtlbmRpZl0tLT48IS0tW2lmIGd0ZSBtc28gOV0+PHhtbD4KLSA8dzpXb3JkRG9jdW1lbnQ+Ci0gIDx3OlRyYWNrUmV2aXNpb25zLz4KLSA8L3c6V29yZERvY3VtZW50PgotPC94bWw+PCFbZW5kaWZdLS0+Ci08c3R5bGU+Ci08IS0tCi0gLyogRm9udCBEZWZpbml0aW9ucyAqLwotQGZvbnQtZmFjZQotCXtmb250LWZhbWlseTpUYWhvbWE7Ci0JcGFub3NlLTE6MiAxMSA2IDQgMyA1IDQgNCAyIDQ7Ci0JbXNvLWZvbnQtY2hhcnNldDowOwotCW1zby1nZW5lcmljLWZvbnQtZmFtaWx5OnN3aXNzOwotCW1zby1mb250LXBpdGNoOnZhcmlhYmxlOwotCW1zby1mb250LXNpZ25hdHVyZTo1NTM2Nzk0OTUgLTIxNDc0ODM2NDggOCAwIDY2MDQ3IDA7fQotIC8qIFN0eWxlIERlZmluaXRpb25zICovCi1wLk1zb05vcm1hbCwgbGkuTXNvTm9ybWFsLCBkaXYuTXNvTm9ybWFsCi0Je21zby1zdHlsZS1wYXJlbnQ6IiI7Ci0JbWFyZ2luOjBpbjsKLQltYXJnaW4tYm90dG9tOi4wMDAxcHQ7Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZToxMi4wcHQ7Ci0JZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotcAotCXttYXJnaW4tcmlnaHQ6MGluOwotCW1zby1tYXJnaW4tdG9wLWFsdDphdXRvOwotCW1zby1tYXJnaW4tYm90dG9tLWFsdDphdXRvOwotCW1hcmdpbi1sZWZ0OjBpbjsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjEyLjBwdDsKLQlmb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1wLkJhbGxvb25UZXh0LCBsaS5CYWxsb29uVGV4dCwgZGl2LkJhbGxvb25UZXh0Ci0Je21zby1zdHlsZS1uYW1lOiJCYWxsb29uIFRleHQiOwotCW1hcmdpbjowaW47Ci0JbWFyZ2luLWJvdHRvbTouMDAwMXB0OwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6OC4wcHQ7Ci0JZm9udC1mYW1pbHk6VGFob21hOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLUBwYWdlIFNlY3Rpb24xCi0Je3NpemU6OC41aW4gMTEuMGluOwotCW1hcmdpbjoxLjBpbiAxLjI1aW4gMS4waW4gMS4yNWluOwotCW1zby1oZWFkZXItbWFyZ2luOi41aW47Ci0JbXNvLWZvb3Rlci1tYXJnaW46LjVpbjsKLQltc28tcGFwZXItc291cmNlOjA7fQotZGl2LlNlY3Rpb24xCi0Je3BhZ2U6U2VjdGlvbjE7fQotLS0+Ci08L3N0eWxlPgotPC9oZWFkPgotCi08Ym9keSBsYW5nPUVOLVVTIHN0eWxlPSd0YWItaW50ZXJ2YWw6LjVpbic+Ci0KLTxkaXYgY2xhc3M9U2VjdGlvbjE+Ci0KLTxwIGFsaWduPWNlbnRlciBzdHlsZT0ndGV4dC1hbGlnbjpjZW50ZXInPjxiPkVjbGlwc2UgUHVibGljIExpY2Vuc2UgLSB2IDEuMDwvYj4KLTwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPlRIRSBBQ0NPTVBBTllJTkcgUFJPR1JBTSBJUyBQUk9WSURFRCBVTkRFUgotVEhFIFRFUk1TIE9GIFRISVMgRUNMSVBTRSBQVUJMSUMgTElDRU5TRSAoJnF1b3Q7QUdSRUVNRU5UJnF1b3Q7KS4gQU5ZIFVTRSwKLVJFUFJPRFVDVElPTiBPUiBESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gQ09OU1RJVFVURVMgUkVDSVBJRU5UJ1MgQUNDRVBUQU5DRQotT0YgVEhJUyBBR1JFRU1FTlQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4xLiBERUZJTklUSU9OUzwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0NvbnRyaWJ1dGlvbiZxdW90OyBtZWFuczo8L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWluIHRoZSBjYXNlIG9mIHRoZSBpbml0aWFsIENvbnRyaWJ1dG9yLCB0aGUgaW5pdGlhbCBjb2RlIGFuZCBkb2N1bWVudGF0aW9uCi1kaXN0cmlidXRlZCB1bmRlciB0aGlzIEFncmVlbWVudCwgYW5kPGJyIGNsZWFyPWxlZnQ+Ci1iKSBpbiB0aGUgY2FzZSBvZiBlYWNoIHN1YnNlcXVlbnQgQ29udHJpYnV0b3I6PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aSkKLWNoYW5nZXMgdG8gdGhlIFByb2dyYW0sIGFuZDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpKQotYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtOzwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPndoZXJlCi1zdWNoIGNoYW5nZXMgYW5kL29yIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbSBvcmlnaW5hdGUgZnJvbSBhbmQgYXJlIGRpc3RyaWJ1dGVkCi1ieSB0aGF0IHBhcnRpY3VsYXIgQ29udHJpYnV0b3IuIEEgQ29udHJpYnV0aW9uICdvcmlnaW5hdGVzJyBmcm9tIGEgQ29udHJpYnV0b3IKLWlmIGl0IHdhcyBhZGRlZCB0byB0aGUgUHJvZ3JhbSBieSBzdWNoIENvbnRyaWJ1dG9yIGl0c2VsZiBvciBhbnlvbmUgYWN0aW5nIG9uCi1zdWNoIENvbnRyaWJ1dG9yJ3MgYmVoYWxmLiBDb250cmlidXRpb25zIGRvIG5vdCBpbmNsdWRlIGFkZGl0aW9ucyB0byB0aGUKLVByb2dyYW0gd2hpY2g6IChpKSBhcmUgc2VwYXJhdGUgbW9kdWxlcyBvZiBzb2Z0d2FyZSBkaXN0cmlidXRlZCBpbiBjb25qdW5jdGlvbgotd2l0aCB0aGUgUHJvZ3JhbSB1bmRlciB0aGVpciBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIGFuZCAoaWkpIGFyZSBub3QgZGVyaXZhdGl2ZQotd29ya3Mgb2YgdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtDb250cmlidXRvciZxdW90OyBtZWFucyBhbnkgcGVyc29uIG9yCi1lbnRpdHkgdGhhdCBkaXN0cmlidXRlcyB0aGUgUHJvZ3JhbS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0xpY2Vuc2VkIFBhdGVudHMgJnF1b3Q7IG1lYW4gcGF0ZW50Ci1jbGFpbXMgbGljZW5zYWJsZSBieSBhIENvbnRyaWJ1dG9yIHdoaWNoIGFyZSBuZWNlc3NhcmlseSBpbmZyaW5nZWQgYnkgdGhlIHVzZQotb3Igc2FsZSBvZiBpdHMgQ29udHJpYnV0aW9uIGFsb25lIG9yIHdoZW4gY29tYmluZWQgd2l0aCB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O1Byb2dyYW0mcXVvdDsgbWVhbnMgdGhlIENvbnRyaWJ1dGlvbnMKLWRpc3RyaWJ1dGVkIGluIGFjY29yZGFuY2Ugd2l0aCB0aGlzIEFncmVlbWVudC48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O1JlY2lwaWVudCZxdW90OyBtZWFucyBhbnlvbmUgd2hvCi1yZWNlaXZlcyB0aGUgUHJvZ3JhbSB1bmRlciB0aGlzIEFncmVlbWVudCwgaW5jbHVkaW5nIGFsbCBDb250cmlidXRvcnMuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4yLiBHUkFOVCBPRiBSSUdIVFM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1TdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudAotYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsIHJveWFsdHktZnJlZSBjb3B5cmlnaHQgbGljZW5zZSB0bzxzcGFuCi1zdHlsZT0nY29sb3I6cmVkJz4gPC9zcGFuPnJlcHJvZHVjZSwgcHJlcGFyZSBkZXJpdmF0aXZlIHdvcmtzIG9mLCBwdWJsaWNseQotZGlzcGxheSwgcHVibGljbHkgcGVyZm9ybSwgZGlzdHJpYnV0ZSBhbmQgc3VibGljZW5zZSB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2gKLUNvbnRyaWJ1dG9yLCBpZiBhbnksIGFuZCBzdWNoIGRlcml2YXRpdmUgd29ya3MsIGluIHNvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZQotZm9ybS48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKQotU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cwotUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLDxzcGFuIHN0eWxlPSdjb2xvcjpncmVlbic+IDwvc3Bhbj5yb3lhbHR5LWZyZWUKLXBhdGVudCBsaWNlbnNlIHVuZGVyIExpY2Vuc2VkIFBhdGVudHMgdG8gbWFrZSwgdXNlLCBzZWxsLCBvZmZlciB0byBzZWxsLCBpbXBvcnQKLWFuZCBvdGhlcndpc2UgdHJhbnNmZXIgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoIENvbnRyaWJ1dG9yLCBpZiBhbnksIGluIHNvdXJjZQotY29kZSBhbmQgb2JqZWN0IGNvZGUgZm9ybS4gVGhpcyBwYXRlbnQgbGljZW5zZSBzaGFsbCBhcHBseSB0byB0aGUgY29tYmluYXRpb24KLW9mIHRoZSBDb250cmlidXRpb24gYW5kIHRoZSBQcm9ncmFtIGlmLCBhdCB0aGUgdGltZSB0aGUgQ29udHJpYnV0aW9uIGlzIGFkZGVkCi1ieSB0aGUgQ29udHJpYnV0b3IsIHN1Y2ggYWRkaXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBjYXVzZXMgc3VjaCBjb21iaW5hdGlvbgotdG8gYmUgY292ZXJlZCBieSB0aGUgTGljZW5zZWQgUGF0ZW50cy4gVGhlIHBhdGVudCBsaWNlbnNlIHNoYWxsIG5vdCBhcHBseSB0bwotYW55IG90aGVyIGNvbWJpbmF0aW9ucyB3aGljaCBpbmNsdWRlIHRoZSBDb250cmlidXRpb24uIE5vIGhhcmR3YXJlIHBlciBzZSBpcwotbGljZW5zZWQgaGVyZXVuZGVyLiA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5jKQotUmVjaXBpZW50IHVuZGVyc3RhbmRzIHRoYXQgYWx0aG91Z2ggZWFjaCBDb250cmlidXRvciBncmFudHMgdGhlIGxpY2Vuc2VzIHRvIGl0cwotQ29udHJpYnV0aW9ucyBzZXQgZm9ydGggaGVyZWluLCBubyBhc3N1cmFuY2VzIGFyZSBwcm92aWRlZCBieSBhbnkgQ29udHJpYnV0b3IKLXRoYXQgdGhlIFByb2dyYW0gZG9lcyBub3QgaW5mcmluZ2UgdGhlIHBhdGVudCBvciBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkKLXJpZ2h0cyBvZiBhbnkgb3RoZXIgZW50aXR5LiBFYWNoIENvbnRyaWJ1dG9yIGRpc2NsYWltcyBhbnkgbGlhYmlsaXR5IHRvIFJlY2lwaWVudAotZm9yIGNsYWltcyBicm91Z2h0IGJ5IGFueSBvdGhlciBlbnRpdHkgYmFzZWQgb24gaW5mcmluZ2VtZW50IG9mIGludGVsbGVjdHVhbAotcHJvcGVydHkgcmlnaHRzIG9yIG90aGVyd2lzZS4gQXMgYSBjb25kaXRpb24gdG8gZXhlcmNpc2luZyB0aGUgcmlnaHRzIGFuZAotbGljZW5zZXMgZ3JhbnRlZCBoZXJldW5kZXIsIGVhY2ggUmVjaXBpZW50IGhlcmVieSBhc3N1bWVzIHNvbGUgcmVzcG9uc2liaWxpdHkKLXRvIHNlY3VyZSBhbnkgb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5IHJpZ2h0cyBuZWVkZWQsIGlmIGFueS4gRm9yIGV4YW1wbGUsCi1pZiBhIHRoaXJkIHBhcnR5IHBhdGVudCBsaWNlbnNlIGlzIHJlcXVpcmVkIHRvIGFsbG93IFJlY2lwaWVudCB0byBkaXN0cmlidXRlCi10aGUgUHJvZ3JhbSwgaXQgaXMgUmVjaXBpZW50J3MgcmVzcG9uc2liaWxpdHkgdG8gYWNxdWlyZSB0aGF0IGxpY2Vuc2UgYmVmb3JlCi1kaXN0cmlidXRpbmcgdGhlIFByb2dyYW0uPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+ZCkKLUVhY2ggQ29udHJpYnV0b3IgcmVwcmVzZW50cyB0aGF0IHRvIGl0cyBrbm93bGVkZ2UgaXQgaGFzIHN1ZmZpY2llbnQgY29weXJpZ2h0Ci1yaWdodHMgaW4gaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCB0byBncmFudCB0aGUgY29weXJpZ2h0IGxpY2Vuc2Ugc2V0IGZvcnRoIGluCi10aGlzIEFncmVlbWVudC4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjMuIFJFUVVJUkVNRU5UUzwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkEgQ29udHJpYnV0b3IgbWF5IGNob29zZSB0byBkaXN0cmlidXRlIHRoZQotUHJvZ3JhbSBpbiBvYmplY3QgY29kZSBmb3JtIHVuZGVyIGl0cyBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIHByb3ZpZGVkIHRoYXQ6PC9zcGFuPgotPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaXQgY29tcGxpZXMgd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQ7IGFuZDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpCi1pdHMgbGljZW5zZSBhZ3JlZW1lbnQ6PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aSkKLWVmZmVjdGl2ZWx5IGRpc2NsYWltcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgd2FycmFudGllcyBhbmQKLWNvbmRpdGlvbnMsIGV4cHJlc3MgYW5kIGltcGxpZWQsIGluY2x1ZGluZyB3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgdGl0bGUKLWFuZCBub24taW5mcmluZ2VtZW50LCBhbmQgaW1wbGllZCB3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgbWVyY2hhbnRhYmlsaXR5Ci1hbmQgZml0bmVzcyBmb3IgYSBwYXJ0aWN1bGFyIHB1cnBvc2U7IDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpKQotZWZmZWN0aXZlbHkgZXhjbHVkZXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIGxpYWJpbGl0eSBmb3IgZGFtYWdlcywKLWluY2x1ZGluZyBkaXJlY3QsIGluZGlyZWN0LCBzcGVjaWFsLCBpbmNpZGVudGFsIGFuZCBjb25zZXF1ZW50aWFsIGRhbWFnZXMsIHN1Y2gKLWFzIGxvc3QgcHJvZml0czsgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWlpKQotc3RhdGVzIHRoYXQgYW55IHByb3Zpc2lvbnMgd2hpY2ggZGlmZmVyIGZyb20gdGhpcyBBZ3JlZW1lbnQgYXJlIG9mZmVyZWQgYnkgdGhhdAotQ29udHJpYnV0b3IgYWxvbmUgYW5kIG5vdCBieSBhbnkgb3RoZXIgcGFydHk7IGFuZDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPml2KQotc3RhdGVzIHRoYXQgc291cmNlIGNvZGUgZm9yIHRoZSBQcm9ncmFtIGlzIGF2YWlsYWJsZSBmcm9tIHN1Y2ggQ29udHJpYnV0b3IsIGFuZAotaW5mb3JtcyBsaWNlbnNlZXMgaG93IHRvIG9idGFpbiBpdCBpbiBhIHJlYXNvbmFibGUgbWFubmVyIG9uIG9yIHRocm91Z2ggYQotbWVkaXVtIGN1c3RvbWFyaWx5IHVzZWQgZm9yIHNvZnR3YXJlIGV4Y2hhbmdlLjxzcGFuIHN0eWxlPSdjb2xvcjpibHVlJz4gPC9zcGFuPjwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5XaGVuIHRoZSBQcm9ncmFtIGlzIG1hZGUgYXZhaWxhYmxlIGluIHNvdXJjZQotY29kZSBmb3JtOjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaXQgbXVzdCBiZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGlzIEFncmVlbWVudDsgYW5kIDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpIGEKLWNvcHkgb2YgdGhpcyBBZ3JlZW1lbnQgbXVzdCBiZSBpbmNsdWRlZCB3aXRoIGVhY2ggY29weSBvZiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkNvbnRyaWJ1dG9ycyBtYXkgbm90IHJlbW92ZSBvciBhbHRlciBhbnkKLWNvcHlyaWdodCBub3RpY2VzIGNvbnRhaW5lZCB3aXRoaW4gdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FYWNoIENvbnRyaWJ1dG9yIG11c3QgaWRlbnRpZnkgaXRzZWxmIGFzIHRoZQotb3JpZ2luYXRvciBvZiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIGluIGEgbWFubmVyIHRoYXQgcmVhc29uYWJseSBhbGxvd3MKLXN1YnNlcXVlbnQgUmVjaXBpZW50cyB0byBpZGVudGlmeSB0aGUgb3JpZ2luYXRvciBvZiB0aGUgQ29udHJpYnV0aW9uLiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+NC4gQ09NTUVSQ0lBTCBESVNUUklCVVRJT048L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Db21tZXJjaWFsIGRpc3RyaWJ1dG9ycyBvZiBzb2Z0d2FyZSBtYXkKLWFjY2VwdCBjZXJ0YWluIHJlc3BvbnNpYmlsaXRpZXMgd2l0aCByZXNwZWN0IHRvIGVuZCB1c2VycywgYnVzaW5lc3MgcGFydG5lcnMKLWFuZCB0aGUgbGlrZS4gV2hpbGUgdGhpcyBsaWNlbnNlIGlzIGludGVuZGVkIHRvIGZhY2lsaXRhdGUgdGhlIGNvbW1lcmNpYWwgdXNlCi1vZiB0aGUgUHJvZ3JhbSwgdGhlIENvbnRyaWJ1dG9yIHdobyBpbmNsdWRlcyB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwKLXByb2R1Y3Qgb2ZmZXJpbmcgc2hvdWxkIGRvIHNvIGluIGEgbWFubmVyIHdoaWNoIGRvZXMgbm90IGNyZWF0ZSBwb3RlbnRpYWwKLWxpYWJpbGl0eSBmb3Igb3RoZXIgQ29udHJpYnV0b3JzLiBUaGVyZWZvcmUsIGlmIGEgQ29udHJpYnV0b3IgaW5jbHVkZXMgdGhlCi1Qcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBzdWNoIENvbnRyaWJ1dG9yICgmcXVvdDtDb21tZXJjaWFsCi1Db250cmlidXRvciZxdW90OykgaGVyZWJ5IGFncmVlcyB0byBkZWZlbmQgYW5kIGluZGVtbmlmeSBldmVyeSBvdGhlcgotQ29udHJpYnV0b3IgKCZxdW90O0luZGVtbmlmaWVkIENvbnRyaWJ1dG9yJnF1b3Q7KSBhZ2FpbnN0IGFueSBsb3NzZXMsIGRhbWFnZXMgYW5kCi1jb3N0cyAoY29sbGVjdGl2ZWx5ICZxdW90O0xvc3NlcyZxdW90OykgYXJpc2luZyBmcm9tIGNsYWltcywgbGF3c3VpdHMgYW5kIG90aGVyCi1sZWdhbCBhY3Rpb25zIGJyb3VnaHQgYnkgYSB0aGlyZCBwYXJ0eSBhZ2FpbnN0IHRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciB0bwotdGhlIGV4dGVudCBjYXVzZWQgYnkgdGhlIGFjdHMgb3Igb21pc3Npb25zIG9mIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvciBpbgotY29ubmVjdGlvbiB3aXRoIGl0cyBkaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3QKLW9mZmVyaW5nLiBUaGUgb2JsaWdhdGlvbnMgaW4gdGhpcyBzZWN0aW9uIGRvIG5vdCBhcHBseSB0byBhbnkgY2xhaW1zIG9yIExvc3NlcwotcmVsYXRpbmcgdG8gYW55IGFjdHVhbCBvciBhbGxlZ2VkIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBpbmZyaW5nZW1lbnQuIEluIG9yZGVyCi10byBxdWFsaWZ5LCBhbiBJbmRlbW5pZmllZCBDb250cmlidXRvciBtdXN0OiBhKSBwcm9tcHRseSBub3RpZnkgdGhlIENvbW1lcmNpYWwKLUNvbnRyaWJ1dG9yIGluIHdyaXRpbmcgb2Ygc3VjaCBjbGFpbSwgYW5kIGIpIGFsbG93IHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yCi10byBjb250cm9sLCBhbmQgY29vcGVyYXRlIHdpdGggdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4sIHRoZSBkZWZlbnNlIGFuZAotYW55IHJlbGF0ZWQgc2V0dGxlbWVudCBuZWdvdGlhdGlvbnMuIFRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciBtYXkgcGFydGljaXBhdGUKLWluIGFueSBzdWNoIGNsYWltIGF0IGl0cyBvd24gZXhwZW5zZS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkZvciBleGFtcGxlLCBhIENvbnRyaWJ1dG9yIG1pZ2h0IGluY2x1ZGUgdGhlCi1Qcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBQcm9kdWN0IFguIFRoYXQgQ29udHJpYnV0b3IgaXMgdGhlbiBhCi1Db21tZXJjaWFsIENvbnRyaWJ1dG9yLiBJZiB0aGF0IENvbW1lcmNpYWwgQ29udHJpYnV0b3IgdGhlbiBtYWtlcyBwZXJmb3JtYW5jZQotY2xhaW1zLCBvciBvZmZlcnMgd2FycmFudGllcyByZWxhdGVkIHRvIFByb2R1Y3QgWCwgdGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZAotd2FycmFudGllcyBhcmUgc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yJ3MgcmVzcG9uc2liaWxpdHkgYWxvbmUuIFVuZGVyIHRoaXMKLXNlY3Rpb24sIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHdvdWxkIGhhdmUgdG8gZGVmZW5kIGNsYWltcyBhZ2FpbnN0IHRoZQotb3RoZXIgQ29udHJpYnV0b3JzIHJlbGF0ZWQgdG8gdGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZCB3YXJyYW50aWVzLCBhbmQgaWYgYQotY291cnQgcmVxdWlyZXMgYW55IG90aGVyIENvbnRyaWJ1dG9yIHRvIHBheSBhbnkgZGFtYWdlcyBhcyBhIHJlc3VsdCwgdGhlCi1Db21tZXJjaWFsIENvbnRyaWJ1dG9yIG11c3QgcGF5IHRob3NlIGRhbWFnZXMuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz41LiBOTyBXQVJSQU5UWTwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMKLUFHUkVFTUVOVCwgVEhFIFBST0dSQU0gSVMgUFJPVklERUQgT04gQU4gJnF1b3Q7QVMgSVMmcXVvdDsgQkFTSVMsIFdJVEhPVVQKLVdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgRUlUSEVSIEVYUFJFU1MgT1IgSU1QTElFRCBJTkNMVURJTkcsCi1XSVRIT1VUIExJTUlUQVRJT04sIEFOWSBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgVElUTEUsIE5PTi1JTkZSSU5HRU1FTlQsCi1NRVJDSEFOVEFCSUxJVFkgT1IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIEVhY2ggUmVjaXBpZW50IGlzIHNvbGVseQotcmVzcG9uc2libGUgZm9yIGRldGVybWluaW5nIHRoZSBhcHByb3ByaWF0ZW5lc3Mgb2YgdXNpbmcgYW5kIGRpc3RyaWJ1dGluZyB0aGUKLVByb2dyYW0gYW5kIGFzc3VtZXMgYWxsIHJpc2tzIGFzc29jaWF0ZWQgd2l0aCBpdHMgZXhlcmNpc2Ugb2YgcmlnaHRzIHVuZGVyIHRoaXMKLUFncmVlbWVudCAsIGluY2x1ZGluZyBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIHJpc2tzIGFuZCBjb3N0cyBvZiBwcm9ncmFtIGVycm9ycywKLWNvbXBsaWFuY2Ugd2l0aCBhcHBsaWNhYmxlIGxhd3MsIGRhbWFnZSB0byBvciBsb3NzIG9mIGRhdGEsIHByb2dyYW1zIG9yCi1lcXVpcG1lbnQsIGFuZCB1bmF2YWlsYWJpbGl0eSBvciBpbnRlcnJ1cHRpb24gb2Ygb3BlcmF0aW9ucy4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjYuIERJU0NMQUlNRVIgT0YgTElBQklMSVRZPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUwotQUdSRUVNRU5ULCBORUlUSEVSIFJFQ0lQSUVOVCBOT1IgQU5ZIENPTlRSSUJVVE9SUyBTSEFMTCBIQVZFIEFOWSBMSUFCSUxJVFkgRk9SCi1BTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLShJTkNMVURJTkcgV0lUSE9VVCBMSU1JVEFUSU9OIExPU1QgUFJPRklUUyksIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCi1PRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORwotTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPUiBESVNUUklCVVRJT04gT0YKLVRIRSBQUk9HUkFNIE9SIFRIRSBFWEVSQ0lTRSBPRiBBTlkgUklHSFRTIEdSQU5URUQgSEVSRVVOREVSLCBFVkVOIElGIEFEVklTRUQgT0YKLVRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRVMuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz43LiBHRU5FUkFMPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+SWYgYW55IHByb3Zpc2lvbiBvZiB0aGlzIEFncmVlbWVudCBpcyBpbnZhbGlkCi1vciB1bmVuZm9yY2VhYmxlIHVuZGVyIGFwcGxpY2FibGUgbGF3LCBpdCBzaGFsbCBub3QgYWZmZWN0IHRoZSB2YWxpZGl0eSBvcgotZW5mb3JjZWFiaWxpdHkgb2YgdGhlIHJlbWFpbmRlciBvZiB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGFuZCB3aXRob3V0Ci1mdXJ0aGVyIGFjdGlvbiBieSB0aGUgcGFydGllcyBoZXJldG8sIHN1Y2ggcHJvdmlzaW9uIHNoYWxsIGJlIHJlZm9ybWVkIHRvIHRoZQotbWluaW11bSBleHRlbnQgbmVjZXNzYXJ5IHRvIG1ha2Ugc3VjaCBwcm92aXNpb24gdmFsaWQgYW5kIGVuZm9yY2VhYmxlLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+SWYgUmVjaXBpZW50IGluc3RpdHV0ZXMgcGF0ZW50IGxpdGlnYXRpb24KLWFnYWluc3QgYW55IGVudGl0eSAoaW5jbHVkaW5nIGEgY3Jvc3MtY2xhaW0gb3IgY291bnRlcmNsYWltIGluIGEgbGF3c3VpdCkKLWFsbGVnaW5nIHRoYXQgdGhlIFByb2dyYW0gaXRzZWxmIChleGNsdWRpbmcgY29tYmluYXRpb25zIG9mIHRoZSBQcm9ncmFtIHdpdGgKLW90aGVyIHNvZnR3YXJlIG9yIGhhcmR3YXJlKSBpbmZyaW5nZXMgc3VjaCBSZWNpcGllbnQncyBwYXRlbnQocyksIHRoZW4gc3VjaAotUmVjaXBpZW50J3MgcmlnaHRzIGdyYW50ZWQgdW5kZXIgU2VjdGlvbiAyKGIpIHNoYWxsIHRlcm1pbmF0ZSBhcyBvZiB0aGUgZGF0ZQotc3VjaCBsaXRpZ2F0aW9uIGlzIGZpbGVkLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+QWxsIFJlY2lwaWVudCdzIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudAotc2hhbGwgdGVybWluYXRlIGlmIGl0IGZhaWxzIHRvIGNvbXBseSB3aXRoIGFueSBvZiB0aGUgbWF0ZXJpYWwgdGVybXMgb3IKLWNvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQgYW5kIGRvZXMgbm90IGN1cmUgc3VjaCBmYWlsdXJlIGluIGEgcmVhc29uYWJsZQotcGVyaW9kIG9mIHRpbWUgYWZ0ZXIgYmVjb21pbmcgYXdhcmUgb2Ygc3VjaCBub25jb21wbGlhbmNlLiBJZiBhbGwgUmVjaXBpZW50J3MKLXJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCB0ZXJtaW5hdGUsIFJlY2lwaWVudCBhZ3JlZXMgdG8gY2Vhc2UgdXNlIGFuZAotZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGFzIHNvb24gYXMgcmVhc29uYWJseSBwcmFjdGljYWJsZS4gSG93ZXZlciwKLVJlY2lwaWVudCdzIG9ibGlnYXRpb25zIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFuZCBhbnkgbGljZW5zZXMgZ3JhbnRlZCBieQotUmVjaXBpZW50IHJlbGF0aW5nIHRvIHRoZSBQcm9ncmFtIHNoYWxsIGNvbnRpbnVlIGFuZCBzdXJ2aXZlLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RXZlcnlvbmUgaXMgcGVybWl0dGVkIHRvIGNvcHkgYW5kIGRpc3RyaWJ1dGUKLWNvcGllcyBvZiB0aGlzIEFncmVlbWVudCwgYnV0IGluIG9yZGVyIHRvIGF2b2lkIGluY29uc2lzdGVuY3kgdGhlIEFncmVlbWVudCBpcwotY29weXJpZ2h0ZWQgYW5kIG1heSBvbmx5IGJlIG1vZGlmaWVkIGluIHRoZSBmb2xsb3dpbmcgbWFubmVyLiBUaGUgQWdyZWVtZW50Ci1TdGV3YXJkIHJlc2VydmVzIHRoZSByaWdodCB0byBwdWJsaXNoIG5ldyB2ZXJzaW9ucyAoaW5jbHVkaW5nIHJldmlzaW9ucykgb2YKLXRoaXMgQWdyZWVtZW50IGZyb20gdGltZSB0byB0aW1lLiBObyBvbmUgb3RoZXIgdGhhbiB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgaGFzCi10aGUgcmlnaHQgdG8gbW9kaWZ5IHRoaXMgQWdyZWVtZW50LiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIHRoZSBpbml0aWFsCi1BZ3JlZW1lbnQgU3Rld2FyZC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYXkgYXNzaWduIHRoZSByZXNwb25zaWJpbGl0eSB0bwotc2VydmUgYXMgdGhlIEFncmVlbWVudCBTdGV3YXJkIHRvIGEgc3VpdGFibGUgc2VwYXJhdGUgZW50aXR5LiBFYWNoIG5ldyB2ZXJzaW9uCi1vZiB0aGUgQWdyZWVtZW50IHdpbGwgYmUgZ2l2ZW4gYSBkaXN0aW5ndWlzaGluZyB2ZXJzaW9uIG51bWJlci4gVGhlIFByb2dyYW0KLShpbmNsdWRpbmcgQ29udHJpYnV0aW9ucykgbWF5IGFsd2F5cyBiZSBkaXN0cmlidXRlZCBzdWJqZWN0IHRvIHRoZSB2ZXJzaW9uIG9mCi10aGUgQWdyZWVtZW50IHVuZGVyIHdoaWNoIGl0IHdhcyByZWNlaXZlZC4gSW4gYWRkaXRpb24sIGFmdGVyIGEgbmV3IHZlcnNpb24gb2YKLXRoZSBBZ3JlZW1lbnQgaXMgcHVibGlzaGVkLCBDb250cmlidXRvciBtYXkgZWxlY3QgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbQotKGluY2x1ZGluZyBpdHMgQ29udHJpYnV0aW9ucykgdW5kZXIgdGhlIG5ldyB2ZXJzaW9uLiBFeGNlcHQgYXMgZXhwcmVzc2x5IHN0YXRlZAotaW4gU2VjdGlvbnMgMihhKSBhbmQgMihiKSBhYm92ZSwgUmVjaXBpZW50IHJlY2VpdmVzIG5vIHJpZ2h0cyBvciBsaWNlbnNlcyB0bwotdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBvZiBhbnkgQ29udHJpYnV0b3IgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIHdoZXRoZXIKLWV4cHJlc3NseSwgYnkgaW1wbGljYXRpb24sIGVzdG9wcGVsIG9yIG90aGVyd2lzZS4gQWxsIHJpZ2h0cyBpbiB0aGUgUHJvZ3JhbSBub3QKLWV4cHJlc3NseSBncmFudGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFyZSByZXNlcnZlZC48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPlRoaXMgQWdyZWVtZW50IGlzIGdvdmVybmVkIGJ5IHRoZSBsYXdzIG9mIHRoZQotU3RhdGUgb2YgTmV3IFlvcmsgYW5kIHRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgbGF3cyBvZiB0aGUgVW5pdGVkIFN0YXRlcyBvZgotQW1lcmljYS4gTm8gcGFydHkgdG8gdGhpcyBBZ3JlZW1lbnQgd2lsbCBicmluZyBhIGxlZ2FsIGFjdGlvbiB1bmRlciB0aGlzCi1BZ3JlZW1lbnQgbW9yZSB0aGFuIG9uZSB5ZWFyIGFmdGVyIHRoZSBjYXVzZSBvZiBhY3Rpb24gYXJvc2UuIEVhY2ggcGFydHkgd2FpdmVzCi1pdHMgcmlnaHRzIHRvIGEganVyeSB0cmlhbCBpbiBhbnkgcmVzdWx0aW5nIGxpdGlnYXRpb24uPC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48IVtpZiAhc3VwcG9ydEVtcHR5UGFyYXNdPiZuYnNwOzwhW2VuZGlmXT48bzpwPjwvbzpwPjwvcD4KLQotPC9kaXY+Ci0KLTwvYm9keT4KLQotPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5wYXRjaC9mZWF0dXJlLnByb3BlcnRpZXMgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQucGF0Y2gvZmVhdHVyZS5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhODQ1N2VhLi4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5wYXRjaC9mZWF0dXJlLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwxNDMgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBDb3B5cmlnaHQgKGMpIDIwMDYgT3JhY2xlLgotIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCi0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAotIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAotIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0KLSMgImZlYXR1cmVOYW1lIiBwcm9wZXJ0eSAtIG5hbWUgb2YgdGhlIGZlYXR1cmUKLWZlYXR1cmVOYW1lPUphdmEgUGVyc2lzdGVuY2UgVG9vbHMgKEpUUCkgUGF0Y2hlcwotCi0jICJwcm92aWRlck5hbWUiIHByb3BlcnR5IC0gbmFtZSBvZiB0aGUgY29tcGFueSB0aGF0IHByb3ZpZGVzIHRoZSBmZWF0dXJlCi1wcm92aWRlck5hbWU9RWNsaXBzZS5vcmcKLQotIyAidXBkYXRlU2l0ZU5hbWUiIHByb3BlcnR5IC0gbGFiZWwgZm9yIHRoZSB1cGRhdGUgc2l0ZQotdXBkYXRlU2l0ZU5hbWU9VGhlIEVjbGlwc2UgV2ViIFRvb2xzIFBsYXRmb3JtIChXVFApIFByb2plY3QgdXBkYXRlIHNpdGUKLQotIyAiZGVzY3JpcHRpb24iIHByb3BlcnR5IC0gZGVzY3JpcHRpb24gb2YgdGhlIGZlYXR1cmUKLWRlc2NyaXB0aW9uPVwKLVBhdGNoKHMpIGZvciBKYXZhIFBlcnNpc3RlbmNlIEFQSSAoSlBBKSBUb29scy4gXG5cCi1TZWUgYnVnIDIyMDI5NyAoaHR0cHM6Ly9idWdzLmVjbGlwc2Uub3JnL2J1Z3MvMjIwMjk3KSBFbnRpdHkgZ2VuZXJhdGlvbiBjcmVhdGVzIEVtYmVkZGFibGVzIHdpdGggY29tcGlsZSBlcnJvcnMgaW4gc29tZSBjYXNlcyBcblwKLQotCi0jICJjb3B5cmlnaHQiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIENvcHlyaWdodCIKLWNvcHlyaWdodD1cCi1Db3B5cmlnaHQgKGMpIDIwMDYtMDggT3JhY2xlIENvcnBvcmF0aW9uLlxuXAotQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFsc1xuXAotYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wXG5cCi13aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdFxuXAotaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWxcblwKLVxuXAotQ29udHJpYnV0b3JzOlxuXAotICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvblxuCi0jIyMjIyMjIyMjIyMjIyMjIGVuZCBvZiBjb3B5cmlnaHQgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0KLSMgImxpY2Vuc2VVUkwiIHByb3BlcnR5IC0gVVJMIG9mIHRoZSAiRmVhdHVyZSBMaWNlbnNlIgotIyBkbyBub3QgdHJhbnNsYXRlIHZhbHVlIC0ganVzdCBjaGFuZ2UgdG8gcG9pbnQgdG8gYSBsb2NhbGUtc3BlY2lmaWMgSFRNTCBwYWdlCi1saWNlbnNlVVJMPWxpY2Vuc2UuaHRtbAotCi0jICJsaWNlbnNlIiBwcm9wZXJ0eSAtIHRleHQgb2YgdGhlICJGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIgotIyBzaG91bGQgYmUgcGxhaW4gdGV4dCB2ZXJzaW9uIG9mIGxpY2Vuc2UgYWdyZWVtZW50IHBvaW50ZWQgdG8gYmUgImxpY2Vuc2VVUkwiCi1saWNlbnNlPVwKLUVDTElQU0UgRk9VTkRBVElPTiBTT0ZUV0FSRSBVU0VSIEFHUkVFTUVOVFxuXAotSnVuZSAwNiwgMjAwN1xuXAotXG5cCi1Vc2FnZSBPZiBDb250ZW50XG5cCi1cblwKLVRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiBBTkQvT1JcblwKLU9USEVSIE1BVEVSSUFMUyBGT1IgT1BFTiBTT1VSQ0UgUFJPSkVDVFMgKENPTExFQ1RJVkVMWSAiQ09OVEVOVCIpLlxuXAotVVNFIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTXG5cCi1BR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBMSUNFTlNFIEFHUkVFTUVOVFMgT1JcblwKLU5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIEJZIFVTSU5HIFRIRSBDT05URU5ULCBZT1VcblwKLUFHUkVFIFRIQVQgWU9VUiBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhJUyBBR1JFRU1FTlRcblwKLUFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTXG5cCi1PUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiBJRiBZT1UgRE8gTk9UIEFHUkVFIFRPIFRIRVxuXAotVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OU1xuXAotT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRURcblwKLUJFTE9XLCBUSEVOIFlPVSBNQVkgTk9UIFVTRSBUSEUgQ09OVEVOVC5cblwKLVxuXAotQXBwbGljYWJsZSBMaWNlbnNlc1xuXAotXG5cCi1Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvblxuXAotaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRWNsaXBzZSBQdWJsaWNcblwKLUxpY2Vuc2UgVmVyc2lvbiAxLjAgKCJFUEwiKS4gQSBjb3B5IG9mIHRoZSBFUEwgaXMgcHJvdmlkZWQgd2l0aCB0aGlzXG5cCi1Db250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC5cblwKLUZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAiUHJvZ3JhbSIgd2lsbCBtZWFuIHRoZSBDb250ZW50LlxuXAotXG5cCi1Db250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSxcblwKLWRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2Uub3JnIENWU1xuXAotcmVwb3NpdG9yeSAoIlJlcG9zaXRvcnkiKSBpbiBDVlMgbW9kdWxlcyAoIk1vZHVsZXMiKSBhbmQgbWFkZSBhdmFpbGFibGVcblwKLWFzIGRvd25sb2FkYWJsZSBhcmNoaXZlcyAoIkRvd25sb2FkcyIpLlxuXAotXG5cCi0gICAtIENvbnRlbnQgbWF5IGJlIHN0cnVjdHVyZWQgYW5kIHBhY2thZ2VkIGludG8gbW9kdWxlcyB0byBmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsXG5cCi0gICAgIGV4dGVuZGluZywgYW5kIHVwZ3JhZGluZyB0aGUgQ29udGVudC4gVHlwaWNhbCBtb2R1bGVzIG1heSBpbmNsdWRlIHBsdWctaW5zICgiUGx1Zy1pbnMiKSxcblwKLSAgICAgcGx1Zy1pbiBmcmFnbWVudHMgKCJGcmFnbWVudHMiKSwgYW5kIGZlYXR1cmVzICgiRmVhdHVyZXMiKS5cblwKLSAgIC0gRWFjaCBQbHVnLWluIG9yIEZyYWdtZW50IG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3Rvcnkgb3IgSkFSIChKYXZhPyBBUmNoaXZlKVxuXAotICAgICBpbiBhIGRpcmVjdG9yeSBuYW1lZCAicGx1Z2lucyIuXG5cCi0gICAtIEEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLlxuXAotICAgICBFYWNoIEZlYXR1cmUgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAiZmVhdHVyZXMiLlxuXAotICAgICBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb25cblwKLSAgICAgbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhc3NvY2lhdGVkIHdpdGggdGhhdCBGZWF0dXJlLlxuXAotICAgLSBGZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgiSW5jbHVkZWQgRmVhdHVyZXMiKS4gV2l0aGluIGEgRmVhdHVyZSwgZmlsZXNcblwKLSAgICAgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgRmVhdHVyZXMuXG5cCi1cblwKLUZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBGaWxlcyBuYW1lZFxuXAotImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2ZcblwKLUluY2x1ZGVkIEZlYXR1cmVzLlxuXAotXG5cCi1UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlXG5cCi1jb250YWluZWQgaW4gZmlsZXMgbmFtZWQgImFib3V0Lmh0bWwiICgiQWJvdXRzIikuIFRoZSB0ZXJtcyBhbmRcblwKLWNvbmRpdGlvbnMgZ292ZXJuaW5nIEZlYXR1cmVzIGFuZCBJbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkXG5cCi1pbiBmaWxlcyBuYW1lZCAibGljZW5zZS5odG1sIiAoIkZlYXR1cmUgTGljZW5zZXMiKS4gQWJvdXRzIGFuZCBGZWF0dXJlXG5cCi1MaWNlbnNlcyBtYXkgYmUgbG9jYXRlZCBpbiBhbnkgZGlyZWN0b3J5IG9mIGEgRG93bmxvYWQgb3IgTW9kdWxlXG5cCi1pbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIGxvY2F0aW9uczpcblwKLVxuXAotICAgLSBUaGUgdG9wLWxldmVsIChyb290KSBkaXJlY3RvcnlcblwKLSAgIC0gUGx1Zy1pbiBhbmQgRnJhZ21lbnQgZGlyZWN0b3JpZXNcblwKLSAgIC0gSW5zaWRlIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgcGFja2FnZWQgYXMgSkFSc1xuXAotICAgLSBTdWItZGlyZWN0b3JpZXMgb2YgdGhlIGRpcmVjdG9yeSBuYW1lZCAic3JjIiBvZiBjZXJ0YWluIFBsdWctaW5zXG5cCi0gICAtIEZlYXR1cmUgZGlyZWN0b3JpZXNcblwKLVxuXAotTm90ZTogaWYgYSBGZWF0dXJlIG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgaW5zdGFsbGVkIHVzaW5nIHRoZVxuXAotRWNsaXBzZSBVcGRhdGUgTWFuYWdlciwgeW91IG11c3QgYWdyZWUgdG8gYSBsaWNlbnNlICgiRmVhdHVyZSBVcGRhdGVcblwKLUxpY2Vuc2UiKSBkdXJpbmcgdGhlIGluc3RhbGxhdGlvbiBwcm9jZXNzLiBJZiB0aGUgRmVhdHVyZSBjb250YWluc1xuXAotSW5jbHVkZWQgRmVhdHVyZXMsIHRoZSBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIHNob3VsZCBlaXRoZXIgcHJvdmlkZSB5b3VcblwKLXdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IgaW5mb3JtXG5cCi15b3Ugd2hlcmUgeW91IGNhbiBsb2NhdGUgdGhlbS4gRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgbWF5IGJlIGZvdW5kIGluXG5cCi10aGUgImxpY2Vuc2UiIHByb3BlcnR5IG9mIGZpbGVzIG5hbWVkICJmZWF0dXJlLnByb3BlcnRpZXMiLiBTdWNoIEFib3V0cyxcblwKLUZlYXR1cmUgTGljZW5zZXMgYW5kIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIHRlcm1zIGFuZFxuXAotY29uZGl0aW9ucyAob3IgcmVmZXJlbmNlcyB0byBzdWNoIHRlcm1zIGFuZCBjb25kaXRpb25zKSB0aGF0IGdvdmVybiB5b3VyXG5cCi11c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbiB0aGF0IGRpcmVjdG9yeS5cblwKLVxuXAotVEhFIEFCT1VUUywgRkVBVFVSRSBMSUNFTlNFUyBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSXG5cCi1UTyBUSEUgRVBMIE9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy5cblwKLVNPTUUgT0YgVEhFU0UgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTpcblwKLVxuXAotICAgIC0gQ29tbW9uIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwpXG5cCi0gICAgLSBBcGFjaGUgU29mdHdhcmUgTGljZW5zZSAxLjEgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRSlcblwKLSAgICAtIEFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDIuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMClcblwKLSAgICAtIElCTSBQdWJsaWMgTGljZW5zZSAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vZGV2ZWxvcGVyd29ya3Mvb3BlbnNvdXJjZS9saWNlbnNlMTAuaHRtbClcblwKLSAgICAtIE1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sKVxuXAotICAgIC0gTW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbClcblwKLSAgICAtIENvbW1vbiBEZXZlbG9wbWVudCBhbmQgRGlzdHJpYnV0aW9uIExpY2Vuc2UgKENEREwpIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sKVxuXAotXG5cCi1JVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCBDT05ESVRJT05TIFBSSU9SXG5cCi1UTyBVU0UgT0YgVEhFIENPTlRFTlQuIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2Ugb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZVxuXAotaXMgcHJvdmlkZWQsIHBsZWFzZSBjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIGNvbmRpdGlvbnNcblwKLWdvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC5cblwKLVxuXAotQ3J5cHRvZ3JhcGh5XG5cCi1cblwKLUNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZVxuXAotY3VycmVudGx5IG1heSBoYXZlIHJlc3RyaWN0aW9ucyBvbiB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBhbmQgdXNlLFxuXAotYW5kL29yIHJlLWV4cG9ydCB0byBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRVxuXAotdXNpbmcgYW55IGVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsXG5cCi1yZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgY29uY2VybmluZyB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBvciB1c2UsXG5cCi1hbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIHRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC5cblwKLVxuXAotSmF2YSBhbmQgYWxsIEphdmEtYmFzZWQgdHJhZGVtYXJrcyBhcmUgdHJhZGVtYXJrcyBvZiBTdW4gTWljcm9zeXN0ZW1zLCBJbmMuIGluIHRoZSBVbml0ZWQgU3RhdGVzLCBvdGhlciBjb3VudHJpZXMsIG9yIGJvdGguXG4KLSMjIyMjIyMjIyMjIGVuZCBvZiBsaWNlbnNlIHByb3BlcnR5ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnBhdGNoL2ZlYXR1cmUueG1sIGIvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnBhdGNoL2ZlYXR1cmUueG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0ZmFlOTJiLi4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5wYXRjaC9mZWF0dXJlLnhtbAorKysgL2Rldi9udWxsCkBAIC0xLDM1ICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08ZmVhdHVyZQotICAgICAgaWQ9Im9yZy5lY2xpcHNlLmpwdC5wYXRjaCIKLSAgICAgIGxhYmVsPSIlZmVhdHVyZU5hbWUiCi0gICAgICB2ZXJzaW9uPSIxLjAuMi5xdWFsaWZpZXIiCi0gICAgICBwcm92aWRlci1uYW1lPSIlcHJvdmlkZXJOYW1lIj4KLQotICAgPGRlc2NyaXB0aW9uIHVybD0iaHR0cDovL2Rvd25sb2FkLmVjbGlwc2Uub3JnL3dlYnRvb2xzL3BhdGNoZXMvIj4KLSAgICAgICVkZXNjcmlwdGlvbgotICAgPC9kZXNjcmlwdGlvbj4KLQotICAgPGNvcHlyaWdodD4KLSAgICAgICVjb3B5cmlnaHQKLSAgIDwvY29weXJpZ2h0PgotCi0gICA8bGljZW5zZSB1cmw9IiVsaWNlbnNlVVJMIj4KLSAgICAgICVsaWNlbnNlCi0gICA8L2xpY2Vuc2U+Ci0KLSAgIDx1cmw+Ci0gICAgICA8dXBkYXRlIGxhYmVsPSJXZWIgVG9vbHMgUGxhdGZvcm0gKFdUUCkgUGF0Y2hlcyIgdXJsPSJodHRwOi8vZG93bmxvYWQuZWNsaXBzZS5vcmcvd2VidG9vbHMvcGF0Y2hlcy8iLz4KLSAgIDwvdXJsPgotCi0gICA8cmVxdWlyZXM+Ci0gICAgICA8aW1wb3J0IGZlYXR1cmU9Im9yZy5lY2xpcHNlLmpwdC5mZWF0dXJlIiB2ZXJzaW9uPSIxLjAuMi52MjAwODAyMTQwMTAwLTc3LTdfQ1lRQ0QyQ2FMWUNIQ0QiIHBhdGNoPSJ0cnVlIi8+Ci0gICA8L3JlcXVpcmVzPgotCi0gICA8cGx1Z2luCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LmdlbiIKLSAgICAgICAgIGRvd25sb2FkLXNpemU9IjAiCi0gICAgICAgICBpbnN0YWxsLXNpemU9IjAiCi0gICAgICAgICB2ZXJzaW9uPSIwLjAuMCIKLSAgICAgICAgIHVucGFjaz0iZmFsc2UiLz4KLQotPC9mZWF0dXJlPgpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnBhdGNoL2xpY2Vuc2UuaHRtbCBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5wYXRjaC9saWNlbnNlLmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDIzNDcwNjAuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnBhdGNoL2xpY2Vuc2UuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDkzICswLDAgQEAKLTwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAxIFRyYW5zaXRpb25hbC8vRU4iICJodHRwOi8vd3d3LnczYy5vcmcvVFIvMTk5OS9SRUMtaHRtbDQwMS0xOTk5MTIyNC9sb29zZS5kdGQiPgotPCEtLSBzYXZlZCBmcm9tIHVybD0oMDA0NClodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC9ub3RpY2UuaHRtbCAtLT4KLTxIVE1MPjxIRUFEPjxUSVRMRT5FY2xpcHNlLm9yZyBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvVElUTEU+Ci08TUVUQSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9aXNvLTg4NTktMSI+Ci08TUVUQSBjb250ZW50PSJNU0hUTUwgNi4wMC4yODAwLjE0NzkiIG5hbWU9R0VORVJBVE9SPjwvSEVBRD4KLTxCT0RZIGxhbmc9RU4tVVMgdkxpbms9cHVycGxlIGxpbms9Ymx1ZT4KLTxIMj5FY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L0gyPgotPFA+SmFudWFyeSAyOCwgMjAwNTwvUD4KLTxIMz5Vc2FnZSBPZiBDb250ZW50PC9IMz4KLTxQPlRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiAKLUFORC9PUiBPVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTIChDT0xMRUNUSVZFTFkgIkNPTlRFTlQiKS4gVVNFIE9GIAotVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCAKLUJFTE9XLiBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VIEFHUkVFIFRIQVQgWU9VUiBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgCi1CWSBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgCi1BR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFIAotVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgCi1BUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLCBUSEVOIFlPVSAKLU1BWSBOT1QgVVNFIFRIRSBDT05URU5ULjwvUD4KLTxIMz5BcHBsaWNhYmxlIExpY2Vuc2VzPC9IMz4KLTxQPlVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSAKLUZvdW5kYXRpb24gaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRWNsaXBzZSAKLVB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wICgiRVBMIikuIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpcyAKLUNvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IDxBIAotaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sPC9BPi4gCi1Gb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC48L1A+Ci08UD5Db250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSwgCi1kb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlLm9yZyBDVlMgcmVwb3NpdG9yeSAKLSgiUmVwb3NpdG9yeSIpIGluIENWUyBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIGF2YWlsYWJsZSBhcyBkb3dubG9hZGFibGUgCi1hcmNoaXZlcyAoIkRvd25sb2FkcyIpLjwvUD4KLTxQPkNvbnRlbnQgbWF5IGJlIGFwcG9ydGlvbmVkIGludG8gcGx1Zy1pbnMgKCJQbHVnLWlucyIpLCBwbHVnLWluIGZyYWdtZW50cyAKLSgiRnJhZ21lbnRzIiksIGFuZCBmZWF0dXJlcyAoIkZlYXR1cmVzIikuIEEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSAKLVBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuIEZpbGVzIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IAotY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgdGhlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgCi1hc3NvY2lhdGVkIHdpdGggYSBGZWF0dXJlLiBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIGFyZSBsb2NhdGVkIGluIGRpcmVjdG9yaWVzIAotbmFtZWQgInBsdWdpbnMiIGFuZCBGZWF0dXJlcyBhcmUgbG9jYXRlZCBpbiBkaXJlY3RvcmllcyBuYW1lZCAiZmVhdHVyZXMiLjwvUD4KLTxQPkZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBGaWxlcyBuYW1lZCAKLSJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIEluY2x1ZGVkIAotRmVhdHVyZXMuPC9QPgotPFA+VGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZSBjb250YWluZWQgCi1pbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyAKLUZlYXR1cmVzIGFuZCBJbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICJsaWNlbnNlLmh0bWwiIAotKCJGZWF0dXJlIExpY2Vuc2VzIikuIEFib3V0cyBhbmQgRmVhdHVyZSBMaWNlbnNlcyBtYXkgYmUgbG9jYXRlZCBpbiBhbnkgCi1kaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGUgaW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyAKLWxvY2F0aW9uczo8L1A+Ci08VUw+Ci0gIDxMST5UaGUgdG9wLWxldmVsIChyb290KSBkaXJlY3RvcnkgCi0gIDxMST5QbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3RvcmllcyAKLSAgPExJPlN1YmRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgInNyYyIgb2YgY2VydGFpbiBQbHVnLWlucyAKLSAgPExJPkZlYXR1cmUgZGlyZWN0b3JpZXMgPC9MST48L1VMPgotPFA+Tm90ZTogaWYgYSBGZWF0dXJlIG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgaW5zdGFsbGVkIAotdXNpbmcgdGhlIEVjbGlwc2UgVXBkYXRlIE1hbmFnZXIsIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoIkZlYXR1cmUgVXBkYXRlIAotTGljZW5zZSIpIGR1cmluZyB0aGUgaW5zdGFsbGF0aW9uIHByb2Nlc3MuIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zIEluY2x1ZGVkIAotRmVhdHVyZXMsIHRoZSBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIHNob3VsZCBlaXRoZXIgcHJvdmlkZSB5b3Ugd2l0aCB0aGUgdGVybXMgCi1hbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgdGhlIEluY2x1ZGVkIEZlYXR1cmVzIG9yIGluZm9ybSB5b3Ugd2hlcmUgeW91IGNhbiAKLWxvY2F0ZSB0aGVtLiBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW4gdGhlICJsaWNlbnNlIiBwcm9wZXJ0eSBvZiAKLWZpbGVzIG5hbWVkICJmZWF0dXJlLnByb3BlcnRpZXMiLiBTdWNoIEFib3V0cywgRmVhdHVyZSBMaWNlbnNlcyBhbmQgRmVhdHVyZSAKLVVwZGF0ZSBMaWNlbnNlcyBjb250YWluIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyAob3IgcmVmZXJlbmNlcyB0byBzdWNoIHRlcm1zIAotYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXIgdXNlIG9mIHRoZSBhc3NvY2lhdGVkIENvbnRlbnQgaW4gdGhhdCAKLWRpcmVjdG9yeS48L1A+Ci08UD5USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVIgVE8gVEhFIEVQTCAKLU9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy4gU09NRSBPRiBUSEVTRSAKLU9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6PC9QPgotPFVMPgotICA8TEk+Q29tbW9uIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbDwvQT4pIAotCi0gIDxMST5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAxLjEgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFPC9BPikgCi0KLSAgPExJPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDIuMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMDwvQT4pIAotCi0gIDxMST5JQk0gUHVibGljIExpY2Vuc2UgMS4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sIj5odHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vZGV2ZWxvcGVyd29ya3Mvb3BlbnNvdXJjZS9saWNlbnNlMTAuaHRtbDwvQT4pIAotCi0gIDxMST5NZXRybyBMaW5rIFB1YmxpYyBMaWNlbnNlIDEuMDAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwiPmh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sPC9BPikgCi0KLSAgPExJPk1vemlsbGEgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjEgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sIj5odHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWw8L0E+KSAKLSAgPC9MST48L1VMPgotPFA+SVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgQ09ORElUSU9OUyBQUklPUiAKLVRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIGlzIAotcHJvdmlkZWQsIHBsZWFzZSBjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIAotY29uZGl0aW9ucyBnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuPC9QPgotPEgzPkNyeXB0b2dyYXBoeTwvSDM+Ci08UD5Db250ZW50IG1heSBjb250YWluIGVuY3J5cHRpb24gc29mdHdhcmUuIFRoZSBjb3VudHJ5IGluIHdoaWNoIHlvdSBhcmUgCi1jdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsIGFuZC9vciAKLXJlLWV4cG9ydCB0byBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRSB1c2luZyBhbnkgCi1lbmNyeXB0aW9uIHNvZnR3YXJlLCBwbGVhc2UgY2hlY2sgdGhlIGNvdW50cnkncyBsYXdzLCByZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgCi1jb25jZXJuaW5nIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIG9yIHVzZSwgYW5kIHJlLWV4cG9ydCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLCAKLXRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC48L1A+PC9CT0RZPjwvSFRNTD4KZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5zZGsvLmN2c2lnbm9yZSBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5zZGsvLmN2c2lnbm9yZQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmMyYWJmNy4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuc2RrLy5jdnNpZ25vcmUKKysrIC9kZXYvbnVsbApAQCAtMSw0ICswLDAgQEAKLSouYmluLmRpc3QuemlwCi1idWlsZC54bWwKLWZlYXR1cmVzCi1wbHVnaW5zCmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuc2RrLy5wcm9qZWN0IGIvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnNkay8ucHJvamVjdApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODIxZDQ1My4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuc2RrLy5wcm9qZWN0CisrKyAvZGV2L251bGwKQEAgLTEsMTcgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxwcm9qZWN0RGVzY3JpcHRpb24+Ci0JPG5hbWU+b3JnLmVjbGlwc2UuanB0LnNkazwvbmFtZT4KLQk8Y29tbWVudD48L2NvbW1lbnQ+Ci0JPHByb2plY3RzPgotCTwvcHJvamVjdHM+Ci0JPGJ1aWxkU3BlYz4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5GZWF0dXJlQnVpbGRlcjwvbmFtZT4KLQkJCTxhcmd1bWVudHM+Ci0JCQk8L2FyZ3VtZW50cz4KLQkJPC9idWlsZENvbW1hbmQ+Ci0JPC9idWlsZFNwZWM+Ci0JPG5hdHVyZXM+Ci0JCTxuYXR1cmU+b3JnLmVjbGlwc2UucGRlLkZlYXR1cmVOYXR1cmU8L25hdHVyZT4KLQk8L25hdHVyZXM+Ci08L3Byb2plY3REZXNjcmlwdGlvbj4KZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5zZGsvYnVpbGQucHJvcGVydGllcyBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5zZGsvYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzIwMDkzOS4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuc2RrL2J1aWxkLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwxNSArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi1iaW4uaW5jbHVkZXMgPSBmZWF0dXJlLnhtbCxcCi0gICAgICAgICAgICAgICBlY2xpcHNlX3VwZGF0ZV8xMjAuanBnLFwKLSAgICAgICAgICAgICAgIGVwbC12MTAuaHRtbCxcCi0gICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwsXAotICAgICAgICAgICAgICAgZmVhdHVyZS5wcm9wZXJ0aWVzCmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuc2RrL2VjbGlwc2VfdXBkYXRlXzEyMC5qcGcgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuc2RrL2VjbGlwc2VfdXBkYXRlXzEyMC5qcGcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJmZGY3MDguLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnNkay9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnNkay9lcGwtdjEwLmh0bWwgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuc2RrL2VwbC12MTAuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWQ0YjE5Ni4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuc2RrL2VwbC12MTAuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDMyOCArMCwwIEBACi08aHRtbCB4bWxuczpvPSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTpvZmZpY2UiCi14bWxuczp3PSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTp3b3JkIgoteG1sbnM9Imh0dHA6Ly93d3cudzMub3JnL1RSL1JFQy1odG1sNDAiPgotCi08aGVhZD4KLTxtZXRhIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD13aW5kb3dzLTEyNTIiPgotPG1ldGEgbmFtZT1Qcm9nSWQgY29udGVudD1Xb3JkLkRvY3VtZW50PgotPG1ldGEgbmFtZT1HZW5lcmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgOSI+Ci08bWV0YSBuYW1lPU9yaWdpbmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgOSI+Ci08bGluayByZWw9RmlsZS1MaXN0Ci1ocmVmPSIuL0VjbGlwc2UlMjBFUEwlMjAyMDAzXzExXzEwJTIwRmluYWxfZmlsZXMvZmlsZWxpc3QueG1sIj4KLTx0aXRsZT5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gVmVyc2lvbiAxLjA8L3RpdGxlPgotPCEtLVtpZiBndGUgbXNvIDldPjx4bWw+Ci0gPG86RG9jdW1lbnRQcm9wZXJ0aWVzPgotICA8bzpSZXZpc2lvbj4yPC9vOlJldmlzaW9uPgotICA8bzpUb3RhbFRpbWU+MzwvbzpUb3RhbFRpbWU+Ci0gIDxvOkNyZWF0ZWQ+MjAwNC0wMy0wNVQyMzowMzowMFo8L286Q3JlYXRlZD4KLSAgPG86TGFzdFNhdmVkPjIwMDQtMDMtMDVUMjM6MDM6MDBaPC9vOkxhc3RTYXZlZD4KLSAgPG86UGFnZXM+NDwvbzpQYWdlcz4KLSAgPG86V29yZHM+MTYyNjwvbzpXb3Jkcz4KLSAgPG86Q2hhcmFjdGVycz45MjcwPC9vOkNoYXJhY3RlcnM+Ci0gICA8bzpMaW5lcz43NzwvbzpMaW5lcz4KLSAgPG86UGFyYWdyYXBocz4xODwvbzpQYXJhZ3JhcGhzPgotICA8bzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4xMTM4NDwvbzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4KLSAgPG86VmVyc2lvbj45LjQ0MDI8L286VmVyc2lvbj4KLSA8L286RG9jdW1lbnRQcm9wZXJ0aWVzPgotPC94bWw+PCFbZW5kaWZdLS0+PCEtLVtpZiBndGUgbXNvIDldPjx4bWw+Ci0gPHc6V29yZERvY3VtZW50PgotICA8dzpUcmFja1JldmlzaW9ucy8+Ci0gPC93OldvcmREb2N1bWVudD4KLTwveG1sPjwhW2VuZGlmXS0tPgotPHN0eWxlPgotPCEtLQotIC8qIEZvbnQgRGVmaW5pdGlvbnMgKi8KLUBmb250LWZhY2UKLQl7Zm9udC1mYW1pbHk6VGFob21hOwotCXBhbm9zZS0xOjIgMTEgNiA0IDMgNSA0IDQgMiA0OwotCW1zby1mb250LWNoYXJzZXQ6MDsKLQltc28tZ2VuZXJpYy1mb250LWZhbWlseTpzd2lzczsKLQltc28tZm9udC1waXRjaDp2YXJpYWJsZTsKLQltc28tZm9udC1zaWduYXR1cmU6NTUzNjc5NDk1IC0yMTQ3NDgzNjQ4IDggMCA2NjA0NyAwO30KLSAvKiBTdHlsZSBEZWZpbml0aW9ucyAqLwotcC5Nc29Ob3JtYWwsIGxpLk1zb05vcm1hbCwgZGl2Lk1zb05vcm1hbAotCXttc28tc3R5bGUtcGFyZW50OiIiOwotCW1hcmdpbjowaW47Ci0JbWFyZ2luLWJvdHRvbTouMDAwMXB0OwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXAKLQl7bWFyZ2luLXJpZ2h0OjBpbjsKLQltc28tbWFyZ2luLXRvcC1hbHQ6YXV0bzsKLQltc28tbWFyZ2luLWJvdHRvbS1hbHQ6YXV0bzsKLQltYXJnaW4tbGVmdDowaW47Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZToxMi4wcHQ7Ci0JZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotcC5CYWxsb29uVGV4dCwgbGkuQmFsbG9vblRleHQsIGRpdi5CYWxsb29uVGV4dAotCXttc28tc3R5bGUtbmFtZToiQmFsbG9vbiBUZXh0IjsKLQltYXJnaW46MGluOwotCW1hcmdpbi1ib3R0b206LjAwMDFwdDsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjguMHB0OwotCWZvbnQtZmFtaWx5OlRhaG9tYTsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1AcGFnZSBTZWN0aW9uMQotCXtzaXplOjguNWluIDExLjBpbjsKLQltYXJnaW46MS4waW4gMS4yNWluIDEuMGluIDEuMjVpbjsKLQltc28taGVhZGVyLW1hcmdpbjouNWluOwotCW1zby1mb290ZXItbWFyZ2luOi41aW47Ci0JbXNvLXBhcGVyLXNvdXJjZTowO30KLWRpdi5TZWN0aW9uMQotCXtwYWdlOlNlY3Rpb24xO30KLS0tPgotPC9zdHlsZT4KLTwvaGVhZD4KLQotPGJvZHkgbGFuZz1FTi1VUyBzdHlsZT0ndGFiLWludGVydmFsOi41aW4nPgotCi08ZGl2IGNsYXNzPVNlY3Rpb24xPgotCi08cCBhbGlnbj1jZW50ZXIgc3R5bGU9J3RleHQtYWxpZ246Y2VudGVyJz48Yj5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gdiAxLjA8L2I+Ci08L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5USEUgQUNDT01QQU5ZSU5HIFBST0dSQU0gSVMgUFJPVklERUQgVU5ERVIKLVRIRSBURVJNUyBPRiBUSElTIEVDTElQU0UgUFVCTElDIExJQ0VOU0UgKCZxdW90O0FHUkVFTUVOVCZxdW90OykuIEFOWSBVU0UsCi1SRVBST0RVQ1RJT04gT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIENPTlNUSVRVVEVTIFJFQ0lQSUVOVCdTIEFDQ0VQVEFOQ0UKLU9GIFRISVMgQUdSRUVNRU5ULjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+MS4gREVGSU5JVElPTlM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtDb250cmlidXRpb24mcXVvdDsgbWVhbnM6PC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pbiB0aGUgY2FzZSBvZiB0aGUgaW5pdGlhbCBDb250cmlidXRvciwgdGhlIGluaXRpYWwgY29kZSBhbmQgZG9jdW1lbnRhdGlvbgotZGlzdHJpYnV0ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGFuZDxiciBjbGVhcj1sZWZ0PgotYikgaW4gdGhlIGNhc2Ugb2YgZWFjaCBzdWJzZXF1ZW50IENvbnRyaWJ1dG9yOjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmkpCi1jaGFuZ2VzIHRvIHRoZSBQcm9ncmFtLCBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paSkKLWFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbTs8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz53aGVyZQotc3VjaCBjaGFuZ2VzIGFuZC9vciBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gb3JpZ2luYXRlIGZyb20gYW5kIGFyZSBkaXN0cmlidXRlZAotYnkgdGhhdCBwYXJ0aWN1bGFyIENvbnRyaWJ1dG9yLiBBIENvbnRyaWJ1dGlvbiAnb3JpZ2luYXRlcycgZnJvbSBhIENvbnRyaWJ1dG9yCi1pZiBpdCB3YXMgYWRkZWQgdG8gdGhlIFByb2dyYW0gYnkgc3VjaCBDb250cmlidXRvciBpdHNlbGYgb3IgYW55b25lIGFjdGluZyBvbgotc3VjaCBDb250cmlidXRvcidzIGJlaGFsZi4gQ29udHJpYnV0aW9ucyBkbyBub3QgaW5jbHVkZSBhZGRpdGlvbnMgdG8gdGhlCi1Qcm9ncmFtIHdoaWNoOiAoaSkgYXJlIHNlcGFyYXRlIG1vZHVsZXMgb2Ygc29mdHdhcmUgZGlzdHJpYnV0ZWQgaW4gY29uanVuY3Rpb24KLXdpdGggdGhlIFByb2dyYW0gdW5kZXIgdGhlaXIgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBhbmQgKGlpKSBhcmUgbm90IGRlcml2YXRpdmUKLXdvcmtzIG9mIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7Q29udHJpYnV0b3ImcXVvdDsgbWVhbnMgYW55IHBlcnNvbiBvcgotZW50aXR5IHRoYXQgZGlzdHJpYnV0ZXMgdGhlIFByb2dyYW0uPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtMaWNlbnNlZCBQYXRlbnRzICZxdW90OyBtZWFuIHBhdGVudAotY2xhaW1zIGxpY2Vuc2FibGUgYnkgYSBDb250cmlidXRvciB3aGljaCBhcmUgbmVjZXNzYXJpbHkgaW5mcmluZ2VkIGJ5IHRoZSB1c2UKLW9yIHNhbGUgb2YgaXRzIENvbnRyaWJ1dGlvbiBhbG9uZSBvciB3aGVuIGNvbWJpbmVkIHdpdGggdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtQcm9ncmFtJnF1b3Q7IG1lYW5zIHRoZSBDb250cmlidXRpb25zCi1kaXN0cmlidXRlZCBpbiBhY2NvcmRhbmNlIHdpdGggdGhpcyBBZ3JlZW1lbnQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtSZWNpcGllbnQmcXVvdDsgbWVhbnMgYW55b25lIHdobwotcmVjZWl2ZXMgdGhlIFByb2dyYW0gdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGluY2x1ZGluZyBhbGwgQ29udHJpYnV0b3JzLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Mi4gR1JBTlQgT0YgUklHSFRTPC9zcGFuPjwvYj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQKLWEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLCByb3lhbHR5LWZyZWUgY29weXJpZ2h0IGxpY2Vuc2UgdG88c3Bhbgotc3R5bGU9J2NvbG9yOnJlZCc+IDwvc3Bhbj5yZXByb2R1Y2UsIHByZXBhcmUgZGVyaXZhdGl2ZSB3b3JrcyBvZiwgcHVibGljbHkKLWRpc3BsYXksIHB1YmxpY2x5IHBlcmZvcm0sIGRpc3RyaWJ1dGUgYW5kIHN1YmxpY2Vuc2UgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoCi1Db250cmlidXRvciwgaWYgYW55LCBhbmQgc3VjaCBkZXJpdmF0aXZlIHdvcmtzLCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUKLWZvcm0uPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikKLVN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMKLVJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSw8c3BhbiBzdHlsZT0nY29sb3I6Z3JlZW4nPiA8L3NwYW4+cm95YWx0eS1mcmVlCi1wYXRlbnQgbGljZW5zZSB1bmRlciBMaWNlbnNlZCBQYXRlbnRzIHRvIG1ha2UsIHVzZSwgc2VsbCwgb2ZmZXIgdG8gc2VsbCwgaW1wb3J0Ci1hbmQgb3RoZXJ3aXNlIHRyYW5zZmVyIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBpbiBzb3VyY2UKLWNvZGUgYW5kIG9iamVjdCBjb2RlIGZvcm0uIFRoaXMgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgYXBwbHkgdG8gdGhlIGNvbWJpbmF0aW9uCi1vZiB0aGUgQ29udHJpYnV0aW9uIGFuZCB0aGUgUHJvZ3JhbSBpZiwgYXQgdGhlIHRpbWUgdGhlIENvbnRyaWJ1dGlvbiBpcyBhZGRlZAotYnkgdGhlIENvbnRyaWJ1dG9yLCBzdWNoIGFkZGl0aW9uIG9mIHRoZSBDb250cmlidXRpb24gY2F1c2VzIHN1Y2ggY29tYmluYXRpb24KLXRvIGJlIGNvdmVyZWQgYnkgdGhlIExpY2Vuc2VkIFBhdGVudHMuIFRoZSBwYXRlbnQgbGljZW5zZSBzaGFsbCBub3QgYXBwbHkgdG8KLWFueSBvdGhlciBjb21iaW5hdGlvbnMgd2hpY2ggaW5jbHVkZSB0aGUgQ29udHJpYnV0aW9uLiBObyBoYXJkd2FyZSBwZXIgc2UgaXMKLWxpY2Vuc2VkIGhlcmV1bmRlci4gPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YykKLVJlY2lwaWVudCB1bmRlcnN0YW5kcyB0aGF0IGFsdGhvdWdoIGVhY2ggQ29udHJpYnV0b3IgZ3JhbnRzIHRoZSBsaWNlbnNlcyB0byBpdHMKLUNvbnRyaWJ1dGlvbnMgc2V0IGZvcnRoIGhlcmVpbiwgbm8gYXNzdXJhbmNlcyBhcmUgcHJvdmlkZWQgYnkgYW55IENvbnRyaWJ1dG9yCi10aGF0IHRoZSBQcm9ncmFtIGRvZXMgbm90IGluZnJpbmdlIHRoZSBwYXRlbnQgb3Igb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5Ci1yaWdodHMgb2YgYW55IG90aGVyIGVudGl0eS4gRWFjaCBDb250cmlidXRvciBkaXNjbGFpbXMgYW55IGxpYWJpbGl0eSB0byBSZWNpcGllbnQKLWZvciBjbGFpbXMgYnJvdWdodCBieSBhbnkgb3RoZXIgZW50aXR5IGJhc2VkIG9uIGluZnJpbmdlbWVudCBvZiBpbnRlbGxlY3R1YWwKLXByb3BlcnR5IHJpZ2h0cyBvciBvdGhlcndpc2UuIEFzIGEgY29uZGl0aW9uIHRvIGV4ZXJjaXNpbmcgdGhlIHJpZ2h0cyBhbmQKLWxpY2Vuc2VzIGdyYW50ZWQgaGVyZXVuZGVyLCBlYWNoIFJlY2lwaWVudCBoZXJlYnkgYXNzdW1lcyBzb2xlIHJlc3BvbnNpYmlsaXR5Ci10byBzZWN1cmUgYW55IG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgbmVlZGVkLCBpZiBhbnkuIEZvciBleGFtcGxlLAotaWYgYSB0aGlyZCBwYXJ0eSBwYXRlbnQgbGljZW5zZSBpcyByZXF1aXJlZCB0byBhbGxvdyBSZWNpcGllbnQgdG8gZGlzdHJpYnV0ZQotdGhlIFByb2dyYW0sIGl0IGlzIFJlY2lwaWVudCdzIHJlc3BvbnNpYmlsaXR5IHRvIGFjcXVpcmUgdGhhdCBsaWNlbnNlIGJlZm9yZQotZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtLjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmQpCi1FYWNoIENvbnRyaWJ1dG9yIHJlcHJlc2VudHMgdGhhdCB0byBpdHMga25vd2xlZGdlIGl0IGhhcyBzdWZmaWNpZW50IGNvcHlyaWdodAotcmlnaHRzIGluIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgdG8gZ3JhbnQgdGhlIGNvcHlyaWdodCBsaWNlbnNlIHNldCBmb3J0aCBpbgotdGhpcyBBZ3JlZW1lbnQuIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4zLiBSRVFVSVJFTUVOVFM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5BIENvbnRyaWJ1dG9yIG1heSBjaG9vc2UgdG8gZGlzdHJpYnV0ZSB0aGUKLVByb2dyYW0gaW4gb2JqZWN0IGNvZGUgZm9ybSB1bmRlciBpdHMgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBwcm92aWRlZCB0aGF0Ojwvc3Bhbj4KLTwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWl0IGNvbXBsaWVzIHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50OyBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKQotaXRzIGxpY2Vuc2UgYWdyZWVtZW50Ojwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmkpCi1lZmZlY3RpdmVseSBkaXNjbGFpbXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIHdhcnJhbnRpZXMgYW5kCi1jb25kaXRpb25zLCBleHByZXNzIGFuZCBpbXBsaWVkLCBpbmNsdWRpbmcgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIHRpdGxlCi1hbmQgbm9uLWluZnJpbmdlbWVudCwgYW5kIGltcGxpZWQgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIG1lcmNoYW50YWJpbGl0eQotYW5kIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlOyA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paSkKLWVmZmVjdGl2ZWx5IGV4Y2x1ZGVzIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCBsaWFiaWxpdHkgZm9yIGRhbWFnZXMsCi1pbmNsdWRpbmcgZGlyZWN0LCBpbmRpcmVjdCwgc3BlY2lhbCwgaW5jaWRlbnRhbCBhbmQgY29uc2VxdWVudGlhbCBkYW1hZ2VzLCBzdWNoCi1hcyBsb3N0IHByb2ZpdHM7IDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpaSkKLXN0YXRlcyB0aGF0IGFueSBwcm92aXNpb25zIHdoaWNoIGRpZmZlciBmcm9tIHRoaXMgQWdyZWVtZW50IGFyZSBvZmZlcmVkIGJ5IHRoYXQKLUNvbnRyaWJ1dG9yIGFsb25lIGFuZCBub3QgYnkgYW55IG90aGVyIHBhcnR5OyBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pdikKLXN0YXRlcyB0aGF0IHNvdXJjZSBjb2RlIGZvciB0aGUgUHJvZ3JhbSBpcyBhdmFpbGFibGUgZnJvbSBzdWNoIENvbnRyaWJ1dG9yLCBhbmQKLWluZm9ybXMgbGljZW5zZWVzIGhvdyB0byBvYnRhaW4gaXQgaW4gYSByZWFzb25hYmxlIG1hbm5lciBvbiBvciB0aHJvdWdoIGEKLW1lZGl1bSBjdXN0b21hcmlseSB1c2VkIGZvciBzb2Z0d2FyZSBleGNoYW5nZS48c3BhbiBzdHlsZT0nY29sb3I6Ymx1ZSc+IDwvc3Bhbj48L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+V2hlbiB0aGUgUHJvZ3JhbSBpcyBtYWRlIGF2YWlsYWJsZSBpbiBzb3VyY2UKLWNvZGUgZm9ybTo8L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWl0IG11c3QgYmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhpcyBBZ3JlZW1lbnQ7IGFuZCA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKSBhCi1jb3B5IG9mIHRoaXMgQWdyZWVtZW50IG11c3QgYmUgaW5jbHVkZWQgd2l0aCBlYWNoIGNvcHkgb2YgdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Db250cmlidXRvcnMgbWF5IG5vdCByZW1vdmUgb3IgYWx0ZXIgYW55Ci1jb3B5cmlnaHQgbm90aWNlcyBjb250YWluZWQgd2l0aGluIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RWFjaCBDb250cmlidXRvciBtdXN0IGlkZW50aWZ5IGl0c2VsZiBhcyB0aGUKLW9yaWdpbmF0b3Igb2YgaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCBpbiBhIG1hbm5lciB0aGF0IHJlYXNvbmFibHkgYWxsb3dzCi1zdWJzZXF1ZW50IFJlY2lwaWVudHMgdG8gaWRlbnRpZnkgdGhlIG9yaWdpbmF0b3Igb2YgdGhlIENvbnRyaWJ1dGlvbi4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjQuIENPTU1FUkNJQUwgRElTVFJJQlVUSU9OPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Q29tbWVyY2lhbCBkaXN0cmlidXRvcnMgb2Ygc29mdHdhcmUgbWF5Ci1hY2NlcHQgY2VydGFpbiByZXNwb25zaWJpbGl0aWVzIHdpdGggcmVzcGVjdCB0byBlbmQgdXNlcnMsIGJ1c2luZXNzIHBhcnRuZXJzCi1hbmQgdGhlIGxpa2UuIFdoaWxlIHRoaXMgbGljZW5zZSBpcyBpbnRlbmRlZCB0byBmYWNpbGl0YXRlIHRoZSBjb21tZXJjaWFsIHVzZQotb2YgdGhlIFByb2dyYW0sIHRoZSBDb250cmlidXRvciB3aG8gaW5jbHVkZXMgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsCi1wcm9kdWN0IG9mZmVyaW5nIHNob3VsZCBkbyBzbyBpbiBhIG1hbm5lciB3aGljaCBkb2VzIG5vdCBjcmVhdGUgcG90ZW50aWFsCi1saWFiaWxpdHkgZm9yIG90aGVyIENvbnRyaWJ1dG9ycy4gVGhlcmVmb3JlLCBpZiBhIENvbnRyaWJ1dG9yIGluY2x1ZGVzIHRoZQotUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgc3VjaCBDb250cmlidXRvciAoJnF1b3Q7Q29tbWVyY2lhbAotQ29udHJpYnV0b3ImcXVvdDspIGhlcmVieSBhZ3JlZXMgdG8gZGVmZW5kIGFuZCBpbmRlbW5pZnkgZXZlcnkgb3RoZXIKLUNvbnRyaWJ1dG9yICgmcXVvdDtJbmRlbW5pZmllZCBDb250cmlidXRvciZxdW90OykgYWdhaW5zdCBhbnkgbG9zc2VzLCBkYW1hZ2VzIGFuZAotY29zdHMgKGNvbGxlY3RpdmVseSAmcXVvdDtMb3NzZXMmcXVvdDspIGFyaXNpbmcgZnJvbSBjbGFpbXMsIGxhd3N1aXRzIGFuZCBvdGhlcgotbGVnYWwgYWN0aW9ucyBicm91Z2h0IGJ5IGEgdGhpcmQgcGFydHkgYWdhaW5zdCB0aGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgdG8KLXRoZSBleHRlbnQgY2F1c2VkIGJ5IHRoZSBhY3RzIG9yIG9taXNzaW9ucyBvZiBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4KLWNvbm5lY3Rpb24gd2l0aCBpdHMgZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0Ci1vZmZlcmluZy4gVGhlIG9ibGlnYXRpb25zIGluIHRoaXMgc2VjdGlvbiBkbyBub3QgYXBwbHkgdG8gYW55IGNsYWltcyBvciBMb3NzZXMKLXJlbGF0aW5nIHRvIGFueSBhY3R1YWwgb3IgYWxsZWdlZCBpbnRlbGxlY3R1YWwgcHJvcGVydHkgaW5mcmluZ2VtZW50LiBJbiBvcmRlcgotdG8gcXVhbGlmeSwgYW4gSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbXVzdDogYSkgcHJvbXB0bHkgbm90aWZ5IHRoZSBDb21tZXJjaWFsCi1Db250cmlidXRvciBpbiB3cml0aW5nIG9mIHN1Y2ggY2xhaW0sIGFuZCBiKSBhbGxvdyB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvcgotdG8gY29udHJvbCwgYW5kIGNvb3BlcmF0ZSB3aXRoIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluLCB0aGUgZGVmZW5zZSBhbmQKLWFueSByZWxhdGVkIHNldHRsZW1lbnQgbmVnb3RpYXRpb25zLiBUaGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbWF5IHBhcnRpY2lwYXRlCi1pbiBhbnkgc3VjaCBjbGFpbSBhdCBpdHMgb3duIGV4cGVuc2UuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Gb3IgZXhhbXBsZSwgYSBDb250cmlidXRvciBtaWdodCBpbmNsdWRlIHRoZQotUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgUHJvZHVjdCBYLiBUaGF0IENvbnRyaWJ1dG9yIGlzIHRoZW4gYQotQ29tbWVyY2lhbCBDb250cmlidXRvci4gSWYgdGhhdCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRoZW4gbWFrZXMgcGVyZm9ybWFuY2UKLWNsYWltcywgb3Igb2ZmZXJzIHdhcnJhbnRpZXMgcmVsYXRlZCB0byBQcm9kdWN0IFgsIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQKLXdhcnJhbnRpZXMgYXJlIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvcidzIHJlc3BvbnNpYmlsaXR5IGFsb25lLiBVbmRlciB0aGlzCi1zZWN0aW9uLCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB3b3VsZCBoYXZlIHRvIGRlZmVuZCBjbGFpbXMgYWdhaW5zdCB0aGUKLW90aGVyIENvbnRyaWJ1dG9ycyByZWxhdGVkIHRvIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcywgYW5kIGlmIGEKLWNvdXJ0IHJlcXVpcmVzIGFueSBvdGhlciBDb250cmlidXRvciB0byBwYXkgYW55IGRhbWFnZXMgYXMgYSByZXN1bHQsIHRoZQotQ29tbWVyY2lhbCBDb250cmlidXRvciBtdXN0IHBheSB0aG9zZSBkYW1hZ2VzLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+NS4gTk8gV0FSUkFOVFk8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTCi1BR1JFRU1FTlQsIFRIRSBQUk9HUkFNIElTIFBST1ZJREVEIE9OIEFOICZxdW90O0FTIElTJnF1b3Q7IEJBU0lTLCBXSVRIT1VUCi1XQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIEVJVEhFUiBFWFBSRVNTIE9SIElNUExJRUQgSU5DTFVESU5HLAotV0lUSE9VVCBMSU1JVEFUSU9OLCBBTlkgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIFRJVExFLCBOT04tSU5GUklOR0VNRU5ULAotTUVSQ0hBTlRBQklMSVRZIE9SIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBFYWNoIFJlY2lwaWVudCBpcyBzb2xlbHkKLXJlc3BvbnNpYmxlIGZvciBkZXRlcm1pbmluZyB0aGUgYXBwcm9wcmlhdGVuZXNzIG9mIHVzaW5nIGFuZCBkaXN0cmlidXRpbmcgdGhlCi1Qcm9ncmFtIGFuZCBhc3N1bWVzIGFsbCByaXNrcyBhc3NvY2lhdGVkIHdpdGggaXRzIGV4ZXJjaXNlIG9mIHJpZ2h0cyB1bmRlciB0aGlzCi1BZ3JlZW1lbnQgLCBpbmNsdWRpbmcgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSByaXNrcyBhbmQgY29zdHMgb2YgcHJvZ3JhbSBlcnJvcnMsCi1jb21wbGlhbmNlIHdpdGggYXBwbGljYWJsZSBsYXdzLCBkYW1hZ2UgdG8gb3IgbG9zcyBvZiBkYXRhLCBwcm9ncmFtcyBvcgotZXF1aXBtZW50LCBhbmQgdW5hdmFpbGFiaWxpdHkgb3IgaW50ZXJydXB0aW9uIG9mIG9wZXJhdGlvbnMuIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz42LiBESVNDTEFJTUVSIE9GIExJQUJJTElUWTwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMKLUFHUkVFTUVOVCwgTkVJVEhFUiBSRUNJUElFTlQgTk9SIEFOWSBDT05UUklCVVRPUlMgU0hBTEwgSEFWRSBBTlkgTElBQklMSVRZIEZPUgotQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0oSU5DTFVESU5HIFdJVEhPVVQgTElNSVRBVElPTiBMT1NUIFBST0ZJVFMpLCBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQotT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcKLU5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT1IgRElTVFJJQlVUSU9OIE9GCi1USEUgUFJPR1JBTSBPUiBUSEUgRVhFUkNJU0UgT0YgQU5ZIFJJR0hUUyBHUkFOVEVEIEhFUkVVTkRFUiwgRVZFTiBJRiBBRFZJU0VEIE9GCi1USEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0VTLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Ny4gR0VORVJBTDwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPklmIGFueSBwcm92aXNpb24gb2YgdGhpcyBBZ3JlZW1lbnQgaXMgaW52YWxpZAotb3IgdW5lbmZvcmNlYWJsZSB1bmRlciBhcHBsaWNhYmxlIGxhdywgaXQgc2hhbGwgbm90IGFmZmVjdCB0aGUgdmFsaWRpdHkgb3IKLWVuZm9yY2VhYmlsaXR5IG9mIHRoZSByZW1haW5kZXIgb2YgdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBhbmQgd2l0aG91dAotZnVydGhlciBhY3Rpb24gYnkgdGhlIHBhcnRpZXMgaGVyZXRvLCBzdWNoIHByb3Zpc2lvbiBzaGFsbCBiZSByZWZvcm1lZCB0byB0aGUKLW1pbmltdW0gZXh0ZW50IG5lY2Vzc2FyeSB0byBtYWtlIHN1Y2ggcHJvdmlzaW9uIHZhbGlkIGFuZCBlbmZvcmNlYWJsZS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPklmIFJlY2lwaWVudCBpbnN0aXR1dGVzIHBhdGVudCBsaXRpZ2F0aW9uCi1hZ2FpbnN0IGFueSBlbnRpdHkgKGluY2x1ZGluZyBhIGNyb3NzLWNsYWltIG9yIGNvdW50ZXJjbGFpbSBpbiBhIGxhd3N1aXQpCi1hbGxlZ2luZyB0aGF0IHRoZSBQcm9ncmFtIGl0c2VsZiAoZXhjbHVkaW5nIGNvbWJpbmF0aW9ucyBvZiB0aGUgUHJvZ3JhbSB3aXRoCi1vdGhlciBzb2Z0d2FyZSBvciBoYXJkd2FyZSkgaW5mcmluZ2VzIHN1Y2ggUmVjaXBpZW50J3MgcGF0ZW50KHMpLCB0aGVuIHN1Y2gKLVJlY2lwaWVudCdzIHJpZ2h0cyBncmFudGVkIHVuZGVyIFNlY3Rpb24gMihiKSBzaGFsbCB0ZXJtaW5hdGUgYXMgb2YgdGhlIGRhdGUKLXN1Y2ggbGl0aWdhdGlvbiBpcyBmaWxlZC4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkFsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQKLXNoYWxsIHRlcm1pbmF0ZSBpZiBpdCBmYWlscyB0byBjb21wbHkgd2l0aCBhbnkgb2YgdGhlIG1hdGVyaWFsIHRlcm1zIG9yCi1jb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50IGFuZCBkb2VzIG5vdCBjdXJlIHN1Y2ggZmFpbHVyZSBpbiBhIHJlYXNvbmFibGUKLXBlcmlvZCBvZiB0aW1lIGFmdGVyIGJlY29taW5nIGF3YXJlIG9mIHN1Y2ggbm9uY29tcGxpYW5jZS4gSWYgYWxsIFJlY2lwaWVudCdzCi1yaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgdGVybWluYXRlLCBSZWNpcGllbnQgYWdyZWVzIHRvIGNlYXNlIHVzZSBhbmQKLWRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBhcyBzb29uIGFzIHJlYXNvbmFibHkgcHJhY3RpY2FibGUuIEhvd2V2ZXIsCi1SZWNpcGllbnQncyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIEFncmVlbWVudCBhbmQgYW55IGxpY2Vuc2VzIGdyYW50ZWQgYnkKLVJlY2lwaWVudCByZWxhdGluZyB0byB0aGUgUHJvZ3JhbSBzaGFsbCBjb250aW51ZSBhbmQgc3Vydml2ZS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkV2ZXJ5b25lIGlzIHBlcm1pdHRlZCB0byBjb3B5IGFuZCBkaXN0cmlidXRlCi1jb3BpZXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGJ1dCBpbiBvcmRlciB0byBhdm9pZCBpbmNvbnNpc3RlbmN5IHRoZSBBZ3JlZW1lbnQgaXMKLWNvcHlyaWdodGVkIGFuZCBtYXkgb25seSBiZSBtb2RpZmllZCBpbiB0aGUgZm9sbG93aW5nIG1hbm5lci4gVGhlIEFncmVlbWVudAotU3Rld2FyZCByZXNlcnZlcyB0aGUgcmlnaHQgdG8gcHVibGlzaCBuZXcgdmVyc2lvbnMgKGluY2x1ZGluZyByZXZpc2lvbnMpIG9mCi10aGlzIEFncmVlbWVudCBmcm9tIHRpbWUgdG8gdGltZS4gTm8gb25lIG90aGVyIHRoYW4gdGhlIEFncmVlbWVudCBTdGV3YXJkIGhhcwotdGhlIHJpZ2h0IHRvIG1vZGlmeSB0aGlzIEFncmVlbWVudC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyB0aGUgaW5pdGlhbAotQWdyZWVtZW50IFN0ZXdhcmQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWF5IGFzc2lnbiB0aGUgcmVzcG9uc2liaWxpdHkgdG8KLXNlcnZlIGFzIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCB0byBhIHN1aXRhYmxlIHNlcGFyYXRlIGVudGl0eS4gRWFjaCBuZXcgdmVyc2lvbgotb2YgdGhlIEFncmVlbWVudCB3aWxsIGJlIGdpdmVuIGEgZGlzdGluZ3Vpc2hpbmcgdmVyc2lvbiBudW1iZXIuIFRoZSBQcm9ncmFtCi0oaW5jbHVkaW5nIENvbnRyaWJ1dGlvbnMpIG1heSBhbHdheXMgYmUgZGlzdHJpYnV0ZWQgc3ViamVjdCB0byB0aGUgdmVyc2lvbiBvZgotdGhlIEFncmVlbWVudCB1bmRlciB3aGljaCBpdCB3YXMgcmVjZWl2ZWQuIEluIGFkZGl0aW9uLCBhZnRlciBhIG5ldyB2ZXJzaW9uIG9mCi10aGUgQWdyZWVtZW50IGlzIHB1Ymxpc2hlZCwgQ29udHJpYnV0b3IgbWF5IGVsZWN0IHRvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0KLShpbmNsdWRpbmcgaXRzIENvbnRyaWJ1dGlvbnMpIHVuZGVyIHRoZSBuZXcgdmVyc2lvbi4gRXhjZXB0IGFzIGV4cHJlc3NseSBzdGF0ZWQKLWluIFNlY3Rpb25zIDIoYSkgYW5kIDIoYikgYWJvdmUsIFJlY2lwaWVudCByZWNlaXZlcyBubyByaWdodHMgb3IgbGljZW5zZXMgdG8KLXRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgb2YgYW55IENvbnRyaWJ1dG9yIHVuZGVyIHRoaXMgQWdyZWVtZW50LCB3aGV0aGVyCi1leHByZXNzbHksIGJ5IGltcGxpY2F0aW9uLCBlc3RvcHBlbCBvciBvdGhlcndpc2UuIEFsbCByaWdodHMgaW4gdGhlIFByb2dyYW0gbm90Ci1leHByZXNzbHkgZ3JhbnRlZCB1bmRlciB0aGlzIEFncmVlbWVudCBhcmUgcmVzZXJ2ZWQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5UaGlzIEFncmVlbWVudCBpcyBnb3Zlcm5lZCBieSB0aGUgbGF3cyBvZiB0aGUKLVN0YXRlIG9mIE5ldyBZb3JrIGFuZCB0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGxhd3Mgb2YgdGhlIFVuaXRlZCBTdGF0ZXMgb2YKLUFtZXJpY2EuIE5vIHBhcnR5IHRvIHRoaXMgQWdyZWVtZW50IHdpbGwgYnJpbmcgYSBsZWdhbCBhY3Rpb24gdW5kZXIgdGhpcwotQWdyZWVtZW50IG1vcmUgdGhhbiBvbmUgeWVhciBhZnRlciB0aGUgY2F1c2Ugb2YgYWN0aW9uIGFyb3NlLiBFYWNoIHBhcnR5IHdhaXZlcwotaXRzIHJpZ2h0cyB0byBhIGp1cnkgdHJpYWwgaW4gYW55IHJlc3VsdGluZyBsaXRpZ2F0aW9uLjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PCFbaWYgIXN1cHBvcnRFbXB0eVBhcmFzXT4mbmJzcDs8IVtlbmRpZl0+PG86cD48L286cD48L3A+Ci0KLTwvZGl2PgotCi08L2JvZHk+Ci0KLTwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuc2RrL2ZlYXR1cmUucHJvcGVydGllcyBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5zZGsvZmVhdHVyZS5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhYmIwYzg4Li4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5zZGsvZmVhdHVyZS5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTQ1ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgZmVhdHVyZS5wcm9wZXJ0aWVzCi0jIGNvbnRhaW5zIGV4dGVybmFsaXplZCBzdHJpbmdzIGZvciBmZWF0dXJlLnhtbAotIyAiJWZvbyIgaW4gZmVhdHVyZS54bWwgY29ycmVzcG9uZHMgdG8gdGhlIGtleSAiZm9vIiBpbiB0aGlzIGZpbGUKLSMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKLSMgVGhpcyBmaWxlIHNob3VsZCBiZSB0cmFuc2xhdGVkLgotCi0jICJmZWF0dXJlTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBmZWF0dXJlCi1mZWF0dXJlTmFtZT1EYWxpIEphdmEgUGVyc2lzdGVuY2UgQVBJIChKUEEpIHByb2plY3QgU0RLCi0KLSMgInByb3ZpZGVyTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBjb21wYW55IHRoYXQgcHJvdmlkZXMgdGhlIGZlYXR1cmUKLXByb3ZpZGVyTmFtZT1FY2xpcHNlLm9yZwotCi0jICJ1cGRhdGVTaXRlTmFtZSIgcHJvcGVydHkgLSBsYWJlbCBmb3IgdGhlIHVwZGF0ZSBzaXRlCi11cGRhdGVTaXRlTmFtZT1UaGUgRWNsaXBzZSBXZWIgVG9vbHMgUGxhdGZvcm0gKFdUUCkgUHJvamVjdCB1cGRhdGUgc2l0ZQotCi0jICJkZXNjcmlwdGlvbiIgcHJvcGVydHkgLSBkZXNjcmlwdGlvbiBvZiB0aGUgZmVhdHVyZQotZGVzY3JpcHRpb249RGFsaSBKYXZhIFBlcnNpc3RlbmNlIEFQSSAoSlBBKSBwcm9qZWN0IFNESwotCi0jICJjb3B5cmlnaHQiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIENvcHlyaWdodCIKLWNvcHlyaWdodD1cCi1Db3B5cmlnaHQgKGMpIDIwMDYgT3JhY2xlIENvcnBvcmF0aW9uLlxuXAotQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFsc1xuXAotYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wXG5cCi13aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdFxuXAotaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWxcblwKLVxuXAotQ29udHJpYnV0b3JzOlxuXAotICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvblxuCi0jIyMjIyMjIyMjIyMjIyMjIGVuZCBvZiBjb3B5cmlnaHQgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0KLSMgImxpY2Vuc2VVUkwiIHByb3BlcnR5IC0gVVJMIG9mIHRoZSAiRmVhdHVyZSBMaWNlbnNlIgotIyBkbyBub3QgdHJhbnNsYXRlIHZhbHVlIC0ganVzdCBjaGFuZ2UgdG8gcG9pbnQgdG8gYSBsb2NhbGUtc3BlY2lmaWMgSFRNTCBwYWdlCi1saWNlbnNlVVJMPWxpY2Vuc2UuaHRtbAotCi0jICJsaWNlbnNlIiBwcm9wZXJ0eSAtIHRleHQgb2YgdGhlICJGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIgotIyBzaG91bGQgYmUgcGxhaW4gdGV4dCB2ZXJzaW9uIG9mIGxpY2Vuc2UgYWdyZWVtZW50IHBvaW50ZWQgdG8gYmUgImxpY2Vuc2VVUkwiCi1saWNlbnNlPVwKLUVDTElQU0UgRk9VTkRBVElPTiBTT0ZUV0FSRSBVU0VSIEFHUkVFTUVOVFxuXAotSnVuZSAwNiwgMjAwN1xuXAotXG5cCi1Vc2FnZSBPZiBDb250ZW50XG5cCi1cblwKLVRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiBBTkQvT1JcblwKLU9USEVSIE1BVEVSSUFMUyBGT1IgT1BFTiBTT1VSQ0UgUFJPSkVDVFMgKENPTExFQ1RJVkVMWSAiQ09OVEVOVCIpLlxuXAotVVNFIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTXG5cCi1BR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBMSUNFTlNFIEFHUkVFTUVOVFMgT1JcblwKLU5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIEJZIFVTSU5HIFRIRSBDT05URU5ULCBZT1VcblwKLUFHUkVFIFRIQVQgWU9VUiBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhJUyBBR1JFRU1FTlRcblwKLUFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTXG5cCi1PUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiBJRiBZT1UgRE8gTk9UIEFHUkVFIFRPIFRIRVxuXAotVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OU1xuXAotT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRURcblwKLUJFTE9XLCBUSEVOIFlPVSBNQVkgTk9UIFVTRSBUSEUgQ09OVEVOVC5cblwKLVxuXAotQXBwbGljYWJsZSBMaWNlbnNlc1xuXAotXG5cCi1Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvblxuXAotaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRWNsaXBzZSBQdWJsaWNcblwKLUxpY2Vuc2UgVmVyc2lvbiAxLjAgKCJFUEwiKS4gQSBjb3B5IG9mIHRoZSBFUEwgaXMgcHJvdmlkZWQgd2l0aCB0aGlzXG5cCi1Db250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC5cblwKLUZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAiUHJvZ3JhbSIgd2lsbCBtZWFuIHRoZSBDb250ZW50LlxuXAotXG5cCi1Db250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSxcblwKLWRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2Uub3JnIENWU1xuXAotcmVwb3NpdG9yeSAoIlJlcG9zaXRvcnkiKSBpbiBDVlMgbW9kdWxlcyAoIk1vZHVsZXMiKSBhbmQgbWFkZSBhdmFpbGFibGVcblwKLWFzIGRvd25sb2FkYWJsZSBhcmNoaXZlcyAoIkRvd25sb2FkcyIpLlxuXAotXG5cCi0gICAtIENvbnRlbnQgbWF5IGJlIHN0cnVjdHVyZWQgYW5kIHBhY2thZ2VkIGludG8gbW9kdWxlcyB0byBmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsXG5cCi0gICAgIGV4dGVuZGluZywgYW5kIHVwZ3JhZGluZyB0aGUgQ29udGVudC4gVHlwaWNhbCBtb2R1bGVzIG1heSBpbmNsdWRlIHBsdWctaW5zICgiUGx1Zy1pbnMiKSxcblwKLSAgICAgcGx1Zy1pbiBmcmFnbWVudHMgKCJGcmFnbWVudHMiKSwgYW5kIGZlYXR1cmVzICgiRmVhdHVyZXMiKS5cblwKLSAgIC0gRWFjaCBQbHVnLWluIG9yIEZyYWdtZW50IG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3Rvcnkgb3IgSkFSIChKYXZhPyBBUmNoaXZlKVxuXAotICAgICBpbiBhIGRpcmVjdG9yeSBuYW1lZCAicGx1Z2lucyIuXG5cCi0gICAtIEEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLlxuXAotICAgICBFYWNoIEZlYXR1cmUgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAiZmVhdHVyZXMiLlxuXAotICAgICBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb25cblwKLSAgICAgbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhc3NvY2lhdGVkIHdpdGggdGhhdCBGZWF0dXJlLlxuXAotICAgLSBGZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgiSW5jbHVkZWQgRmVhdHVyZXMiKS4gV2l0aGluIGEgRmVhdHVyZSwgZmlsZXNcblwKLSAgICAgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgRmVhdHVyZXMuXG5cCi1cblwKLUZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBGaWxlcyBuYW1lZFxuXAotImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2ZcblwKLUluY2x1ZGVkIEZlYXR1cmVzLlxuXAotXG5cCi1UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlXG5cCi1jb250YWluZWQgaW4gZmlsZXMgbmFtZWQgImFib3V0Lmh0bWwiICgiQWJvdXRzIikuIFRoZSB0ZXJtcyBhbmRcblwKLWNvbmRpdGlvbnMgZ292ZXJuaW5nIEZlYXR1cmVzIGFuZCBJbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkXG5cCi1pbiBmaWxlcyBuYW1lZCAibGljZW5zZS5odG1sIiAoIkZlYXR1cmUgTGljZW5zZXMiKS4gQWJvdXRzIGFuZCBGZWF0dXJlXG5cCi1MaWNlbnNlcyBtYXkgYmUgbG9jYXRlZCBpbiBhbnkgZGlyZWN0b3J5IG9mIGEgRG93bmxvYWQgb3IgTW9kdWxlXG5cCi1pbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIGxvY2F0aW9uczpcblwKLVxuXAotICAgLSBUaGUgdG9wLWxldmVsIChyb290KSBkaXJlY3RvcnlcblwKLSAgIC0gUGx1Zy1pbiBhbmQgRnJhZ21lbnQgZGlyZWN0b3JpZXNcblwKLSAgIC0gSW5zaWRlIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgcGFja2FnZWQgYXMgSkFSc1xuXAotICAgLSBTdWItZGlyZWN0b3JpZXMgb2YgdGhlIGRpcmVjdG9yeSBuYW1lZCAic3JjIiBvZiBjZXJ0YWluIFBsdWctaW5zXG5cCi0gICAtIEZlYXR1cmUgZGlyZWN0b3JpZXNcblwKLVxuXAotTm90ZTogaWYgYSBGZWF0dXJlIG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgaW5zdGFsbGVkIHVzaW5nIHRoZVxuXAotRWNsaXBzZSBVcGRhdGUgTWFuYWdlciwgeW91IG11c3QgYWdyZWUgdG8gYSBsaWNlbnNlICgiRmVhdHVyZSBVcGRhdGVcblwKLUxpY2Vuc2UiKSBkdXJpbmcgdGhlIGluc3RhbGxhdGlvbiBwcm9jZXNzLiBJZiB0aGUgRmVhdHVyZSBjb250YWluc1xuXAotSW5jbHVkZWQgRmVhdHVyZXMsIHRoZSBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIHNob3VsZCBlaXRoZXIgcHJvdmlkZSB5b3VcblwKLXdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IgaW5mb3JtXG5cCi15b3Ugd2hlcmUgeW91IGNhbiBsb2NhdGUgdGhlbS4gRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgbWF5IGJlIGZvdW5kIGluXG5cCi10aGUgImxpY2Vuc2UiIHByb3BlcnR5IG9mIGZpbGVzIG5hbWVkICJmZWF0dXJlLnByb3BlcnRpZXMiLiBTdWNoIEFib3V0cyxcblwKLUZlYXR1cmUgTGljZW5zZXMgYW5kIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIHRlcm1zIGFuZFxuXAotY29uZGl0aW9ucyAob3IgcmVmZXJlbmNlcyB0byBzdWNoIHRlcm1zIGFuZCBjb25kaXRpb25zKSB0aGF0IGdvdmVybiB5b3VyXG5cCi11c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbiB0aGF0IGRpcmVjdG9yeS5cblwKLVxuXAotVEhFIEFCT1VUUywgRkVBVFVSRSBMSUNFTlNFUyBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSXG5cCi1UTyBUSEUgRVBMIE9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy5cblwKLVNPTUUgT0YgVEhFU0UgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTpcblwKLVxuXAotICAgIC0gQ29tbW9uIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwpXG5cCi0gICAgLSBBcGFjaGUgU29mdHdhcmUgTGljZW5zZSAxLjEgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRSlcblwKLSAgICAtIEFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDIuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMClcblwKLSAgICAtIElCTSBQdWJsaWMgTGljZW5zZSAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vZGV2ZWxvcGVyd29ya3Mvb3BlbnNvdXJjZS9saWNlbnNlMTAuaHRtbClcblwKLSAgICAtIE1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sKVxuXAotICAgIC0gTW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbClcblwKLSAgICAtIENvbW1vbiBEZXZlbG9wbWVudCBhbmQgRGlzdHJpYnV0aW9uIExpY2Vuc2UgKENEREwpIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sKVxuXAotXG5cCi1JVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCBDT05ESVRJT05TIFBSSU9SXG5cCi1UTyBVU0UgT0YgVEhFIENPTlRFTlQuIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2Ugb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZVxuXAotaXMgcHJvdmlkZWQsIHBsZWFzZSBjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIGNvbmRpdGlvbnNcblwKLWdvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC5cblwKLVxuXAotQ3J5cHRvZ3JhcGh5XG5cCi1cblwKLUNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZVxuXAotY3VycmVudGx5IG1heSBoYXZlIHJlc3RyaWN0aW9ucyBvbiB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBhbmQgdXNlLFxuXAotYW5kL29yIHJlLWV4cG9ydCB0byBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRVxuXAotdXNpbmcgYW55IGVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsXG5cCi1yZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgY29uY2VybmluZyB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBvciB1c2UsXG5cCi1hbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIHRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC5cblwKLVxuXAotSmF2YSBhbmQgYWxsIEphdmEtYmFzZWQgdHJhZGVtYXJrcyBhcmUgdHJhZGVtYXJrcyBvZiBTdW4gTWljcm9zeXN0ZW1zLCBJbmMuIGluIHRoZSBVbml0ZWQgU3RhdGVzLCBvdGhlciBjb3VudHJpZXMsIG9yIGJvdGguXG4KLSMjIyMjIyMjIyMjIGVuZCBvZiBsaWNlbnNlIHByb3BlcnR5ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnNkay9mZWF0dXJlLnhtbCBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5zZGsvZmVhdHVyZS54bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGM3ZjFmZTUuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnNkay9mZWF0dXJlLnhtbAorKysgL2Rldi9udWxsCkBAIC0xLDQyICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08ZmVhdHVyZQotICAgICAgaWQ9Im9yZy5lY2xpcHNlLmpwdC5zZGsiCi0gICAgICBsYWJlbD0iJWZlYXR1cmVOYW1lIgotICAgICAgdmVyc2lvbj0iMi4xLjAucXVhbGlmaWVyIgotICAgICAgcHJvdmlkZXItbmFtZT0iJXByb3ZpZGVyTmFtZSIKLSAgICAgIHBsdWdpbj0ib3JnLmVjbGlwc2UuanB0IgotICAgICAgaW1hZ2U9ImVjbGlwc2VfdXBkYXRlXzEyMC5qcGciPgotCi0gICA8ZGVzY3JpcHRpb24+Ci0gICAgICAlZGVzY3JpcHRpb24KLSAgIDwvZGVzY3JpcHRpb24+Ci0KLSAgIDxjb3B5cmlnaHQ+Ci0gICAgICAlY29weXJpZ2h0Ci0gICA8L2NvcHlyaWdodD4KLQotICAgPGxpY2Vuc2UgdXJsPSJsaWNlbnNlLmh0bWwiPgotICAgICAgJWxpY2Vuc2UKLSAgIDwvbGljZW5zZT4KLQotICAgPHVybD4KLSAgICAgIDx1cGRhdGUgbGFiZWw9IiV1cGRhdGVTaXRlTmFtZSIgdXJsPSJodHRwOi8vZG93bmxvYWQuZWNsaXBzZS5vcmcvd2VidG9vbHMvdXBkYXRlcyIvPgotICAgICAgPGRpc2NvdmVyeSBsYWJlbD0iV2ViIFRvb2xzIFBsYXRmb3JtIChXVFApIFVwZGF0ZXMiIHVybD0iaHR0cDovL2Rvd25sb2FkLmVjbGlwc2Uub3JnL3dlYnRvb2xzL3VwZGF0ZXMiLz4KLSAgIDwvdXJsPgotCi0gICA8aW5jbHVkZXMKLSAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHRfc2RrLmZlYXR1cmUiCi0gICAgICAgICB2ZXJzaW9uPSIwLjAuMCIvPgotCi0gICA8aW5jbHVkZXMKLSAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmtfc2RrLmZlYXR1cmUiCi0gICAgICAgICB2ZXJzaW9uPSIwLjAuMCIvPgotCi0gICA8cGx1Z2luCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0IgotICAgICAgICAgZG93bmxvYWQtc2l6ZT0iMCIKLSAgICAgICAgIGluc3RhbGwtc2l6ZT0iMCIKLSAgICAgICAgIHZlcnNpb249IjAuMC4wIgotICAgICAgICAgdW5wYWNrPSJmYWxzZSIvPgotCi08L2ZlYXR1cmU+CmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuc2RrL2xpY2Vuc2UuaHRtbCBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5zZGsvbGljZW5zZS5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3NmFiZmI0Li4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5zZGsvbGljZW5zZS5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsOTggKzAsMCBAQAotPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEgVHJhbnNpdGlvbmFsLy9FTiIgImh0dHA6Ly93d3cudzNjLm9yZy9UUi8xOTk5L1JFQy1odG1sNDAxLTE5OTkxMjI0L2xvb3NlLmR0ZCI+Ci08IS0tIHNhdmVkIGZyb20gdXJsPSgwMDQ0KWh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsL25vdGljZS5odG1sIC0tPgotPEhUTUw+PEhFQUQ+PFRJVExFPkVjbGlwc2Uub3JnIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9USVRMRT4KLTxNRVRBIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4KLTxNRVRBIGNvbnRlbnQ9Ik1TSFRNTCA2LjAwLjI4MDAuMTQ3OSIgbmFtZT1HRU5FUkFUT1I+PC9IRUFEPgotPEJPRFkgbGFuZz1FTi1VUyB2TGluaz1wdXJwbGUgbGluaz1ibHVlPgotPEgyPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvSDI+Ci08UD5KdW5lIDA2LCAyMDA3PC9QPgotPEgzPlVzYWdlIE9mIENvbnRlbnQ8L0gzPgotPFA+VEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIAotQU5EL09SIE9USEVSIE1BVEVSSUFMUyBGT1IgT1BFTiBTT1VSQ0UgUFJPSkVDVFMgKENPTExFQ1RJVkVMWSAiQ09OVEVOVCIpLiBVU0UgT0YgCi1USEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSAKLVRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIAotQkVMT1cuIEJZIFVTSU5HIFRIRSBDT05URU5ULCBZT1UgQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCAKLUJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSAKLUFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSAKLUFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIAotTUFZIE5PVCBVU0UgVEhFIENPTlRFTlQuPC9QPgotPEgzPkFwcGxpY2FibGUgTGljZW5zZXM8L0gzPgotPFA+VW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIAotRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIAotUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKCJFUEwiKS4gQSBjb3B5IG9mIHRoZSBFUEwgaXMgcHJvdmlkZWQgd2l0aCB0aGlzIAotQ29udGVudCBhbmQgaXMgYWxzbyBhdmFpbGFibGUgYXQgPEEgCi1ocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L0E+LiAKLUZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAiUHJvZ3JhbSIgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvUD4KLTxQPkNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLCAKLWRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2Uub3JnIENWUyByZXBvc2l0b3J5IAotKCJSZXBvc2l0b3J5IikgaW4gQ1ZTIG1vZHVsZXMgKCJNb2R1bGVzIikgYW5kIG1hZGUgYXZhaWxhYmxlIGFzIGRvd25sb2FkYWJsZSAKLWFyY2hpdmVzICgiRG93bmxvYWRzIikuPC9QPgotPFA+Q29udGVudCBtYXkgYmUgYXBwb3J0aW9uZWQgaW50byBwbHVnLWlucyAoIlBsdWctaW5zIiksIHBsdWctaW4gZnJhZ21lbnRzIAotKCJGcmFnbWVudHMiKSwgYW5kIGZlYXR1cmVzICgiRmVhdHVyZXMiKS4gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIAotUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhbmQgYXNzb2NpYXRlZCBtYXRlcmlhbC4gRmlsZXMgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgCi1jb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyAKLWFzc29jaWF0ZWQgd2l0aCBhIEZlYXR1cmUuIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgYXJlIGxvY2F0ZWQgaW4gZGlyZWN0b3JpZXMgCi1uYW1lZCAicGx1Z2lucyIgYW5kIEZlYXR1cmVzIGFyZSBsb2NhdGVkIGluIGRpcmVjdG9yaWVzIG5hbWVkICJmZWF0dXJlcyIuPC9QPgotPFA+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIEZpbGVzIG5hbWVkIAotImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgCi1GZWF0dXJlcy48L1A+Ci08UD5UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlIGNvbnRhaW5lZCAKLWluIGZpbGVzIG5hbWVkICJhYm91dC5odG1sIiAoIkFib3V0cyIpLiBUaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIAotRmVhdHVyZXMgYW5kIEluY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgImxpY2Vuc2UuaHRtbCIgCi0oIkZlYXR1cmUgTGljZW5zZXMiKS4gQWJvdXRzIGFuZCBGZWF0dXJlIExpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSAKLWRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZSBpbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIAotbG9jYXRpb25zOjwvUD4KLTxVTD4KLSAgPExJPlRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeSAKLSAgPExJPlBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzIAotICA8TEk+U3ViZGlyZWN0b3JpZXMgb2YgdGhlIGRpcmVjdG9yeSBuYW1lZCAic3JjIiBvZiBjZXJ0YWluIFBsdWctaW5zIAotICA8TEk+RmVhdHVyZSBkaXJlY3RvcmllcyA8L0xJPjwvVUw+Ci08UD5Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgCi11c2luZyB0aGUgRWNsaXBzZSBVcGRhdGUgTWFuYWdlciwgeW91IG11c3QgYWdyZWUgdG8gYSBsaWNlbnNlICgiRmVhdHVyZSBVcGRhdGUgCi1MaWNlbnNlIikgZHVyaW5nIHRoZSBpbnN0YWxsYXRpb24gcHJvY2Vzcy4gSWYgdGhlIEZlYXR1cmUgY29udGFpbnMgSW5jbHVkZWQgCi1GZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdSB3aXRoIHRoZSB0ZXJtcyAKLWFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IgaW5mb3JtIHlvdSB3aGVyZSB5b3UgY2FuIAotbG9jYXRlIHRoZW0uIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSBmb3VuZCBpbiB0aGUgImxpY2Vuc2UiIHByb3BlcnR5IG9mIAotZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIuIFN1Y2ggQWJvdXRzLCBGZWF0dXJlIExpY2Vuc2VzIGFuZCBGZWF0dXJlIAotVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgCi1hbmQgY29uZGl0aW9ucykgdGhhdCBnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbiB0aGF0IAotZGlyZWN0b3J5LjwvUD4KLTxQPlRIRSBBQk9VVFMsIEZFQVRVUkUgTElDRU5TRVMgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUiBUTyBUSEUgRVBMIAotT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLiBTT01FIE9GIFRIRVNFIAotT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTo8L1A+Ci08VUw+Ci0gIDxMST5Db21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sPC9BPikgCi0KLSAgPExJPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRSI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0U8L0E+KSAKLQotICA8TEk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMCI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wPC9BPikgCi0KLSAgPExJPklCTSBQdWJsaWMgTGljZW5zZSAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2RldmVsb3BlcndvcmtzL29wZW5zb3VyY2UvbGljZW5zZTEwLmh0bWwiPmh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sPC9BPikgCi0KLSAgPExJPk1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbCI+aHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWw8L0E+KSAKLQotICA8TEk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWwiPmh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbDwvQT4pIAotICA8L0xJPgotICAgCi0gIDxMST5Db21tb24gRGV2ZWxvcG1lbnQgYW5kIERpc3RyaWJ1dGlvbiBMaWNlbnNlIChDRERMKSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwiPmh0dHA6Ly93d3cuc3VuLmNvbS9jZGRsL2NkZGwuaHRtbCk8L0E+Ci0gIDwvTEk+Ci08L1VMPgotPFA+SVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgQ09ORElUSU9OUyBQUklPUiAKLVRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIGlzIAotcHJvdmlkZWQsIHBsZWFzZSBjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIAotY29uZGl0aW9ucyBnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuPC9QPgotPEgzPkNyeXB0b2dyYXBoeTwvSDM+Ci08UD5Db250ZW50IG1heSBjb250YWluIGVuY3J5cHRpb24gc29mdHdhcmUuIFRoZSBjb3VudHJ5IGluIHdoaWNoIHlvdSBhcmUgCi1jdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsIGFuZC9vciAKLXJlLWV4cG9ydCB0byBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRSB1c2luZyBhbnkgCi1lbmNyeXB0aW9uIHNvZnR3YXJlLCBwbGVhc2UgY2hlY2sgdGhlIGNvdW50cnkncyBsYXdzLCByZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgCi1jb25jZXJuaW5nIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIG9yIHVzZSwgYW5kIHJlLWV4cG9ydCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLCAKLXRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC48L1A+PC9CT0RZPjwvSFRNTD4KZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5hc3NlbWJseS5mZWF0dXJlLy5jdnNpZ25vcmUgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMuYXNzZW1ibHkuZmVhdHVyZS8uY3ZzaWdub3JlCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyNTQ0NjkzLi4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5hc3NlbWJseS5mZWF0dXJlLy5jdnNpZ25vcmUKKysrIC9kZXYvbnVsbApAQCAtMSwzICswLDAgQEAKLSouYmluLmRpc3QuemlwCi1idWlsZC54bWwKLW9yZy5lY2xpcHNlLmpwdC50ZXN0c18xLjAuMC4qClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmFzc2VtYmx5LmZlYXR1cmUvLnByb2plY3QgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMuYXNzZW1ibHkuZmVhdHVyZS8ucHJvamVjdApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjM0ODk5Yy4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMuYXNzZW1ibHkuZmVhdHVyZS8ucHJvamVjdAorKysgL2Rldi9udWxsCkBAIC0xLDE3ICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08cHJvamVjdERlc2NyaXB0aW9uPgotCTxuYW1lPm9yZy5lY2xpcHNlLmpwdC50ZXN0cy5hc3NlbWJseS5mZWF0dXJlPC9uYW1lPgotCTxjb21tZW50PjwvY29tbWVudD4KLQk8cHJvamVjdHM+Ci0JPC9wcm9qZWN0cz4KLQk8YnVpbGRTcGVjPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLkZlYXR1cmVCdWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQk8L2J1aWxkU3BlYz4KLQk8bmF0dXJlcz4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5wZGUuRmVhdHVyZU5hdHVyZTwvbmF0dXJlPgotCTwvbmF0dXJlcz4KLTwvcHJvamVjdERlc2NyaXB0aW9uPgpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmFzc2VtYmx5LmZlYXR1cmUvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzIGIvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmFzc2VtYmx5LmZlYXR1cmUvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxN2FjYjY1Li4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5hc3NlbWJseS5mZWF0dXJlLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcworKysgL2Rldi9udWxsCkBAIC0xLDMgKzAsMCBAQAotI1N1biBNYXkgMjcgMTU6MTE6MDUgRURUIDIwMDcKLWVjbGlwc2UucHJlZmVyZW5jZXMudmVyc2lvbj0xCi1lbmNvZGluZy88cHJvamVjdD49SVNPLTg4NTktMQpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmFzc2VtYmx5LmZlYXR1cmUvYnVpbGQucHJvcGVydGllcyBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5hc3NlbWJseS5mZWF0dXJlL2J1aWxkLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDdmNDc2OTQuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmFzc2VtYmx5LmZlYXR1cmUvYnVpbGQucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDUgKzAsMCBAQAotYmluLmluY2x1ZGVzID0gZmVhdHVyZS54bWwsXAotICAgICAgICAgICAgICAgZWNsaXBzZV91cGRhdGVfMTIwLmpwZyxcCi0gICAgICAgICAgICAgICBlcGwtdjEwLmh0bWwsXAotICAgICAgICAgICAgICAgbGljZW5zZS5odG1sLFwKLSAgICAgICAgICAgICAgIGZlYXR1cmUucHJvcGVydGllcwpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmFzc2VtYmx5LmZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZyBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5hc3NlbWJseS5mZWF0dXJlL2VjbGlwc2VfdXBkYXRlXzEyMC5qcGcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJmZGY3MDguLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmFzc2VtYmx5LmZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5hc3NlbWJseS5mZWF0dXJlL2VwbC12MTAuaHRtbCBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5hc3NlbWJseS5mZWF0dXJlL2VwbC12MTAuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWQ0YjE5Ni4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMuYXNzZW1ibHkuZmVhdHVyZS9lcGwtdjEwLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSwzMjggKzAsMCBAQAotPGh0bWwgeG1sbnM6bz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6b2ZmaWNlIgoteG1sbnM6dz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6d29yZCIKLXhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy9UUi9SRUMtaHRtbDQwIj4KLQotPGhlYWQ+Ci08bWV0YSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9d2luZG93cy0xMjUyIj4KLTxtZXRhIG5hbWU9UHJvZ0lkIGNvbnRlbnQ9V29yZC5Eb2N1bWVudD4KLTxtZXRhIG5hbWU9R2VuZXJhdG9yIGNvbnRlbnQ9Ik1pY3Jvc29mdCBXb3JkIDkiPgotPG1ldGEgbmFtZT1PcmlnaW5hdG9yIGNvbnRlbnQ9Ik1pY3Jvc29mdCBXb3JkIDkiPgotPGxpbmsgcmVsPUZpbGUtTGlzdAotaHJlZj0iLi9FY2xpcHNlJTIwRVBMJTIwMjAwM18xMV8xMCUyMEZpbmFsX2ZpbGVzL2ZpbGVsaXN0LnhtbCI+Ci08dGl0bGU+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIFZlcnNpb24gMS4wPC90aXRsZT4KLTwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDxvOkRvY3VtZW50UHJvcGVydGllcz4KLSAgPG86UmV2aXNpb24+MjwvbzpSZXZpc2lvbj4KLSAgPG86VG90YWxUaW1lPjM8L286VG90YWxUaW1lPgotICA8bzpDcmVhdGVkPjIwMDQtMDMtMDVUMjM6MDM6MDBaPC9vOkNyZWF0ZWQ+Ci0gIDxvOkxhc3RTYXZlZD4yMDA0LTAzLTA1VDIzOjAzOjAwWjwvbzpMYXN0U2F2ZWQ+Ci0gIDxvOlBhZ2VzPjQ8L286UGFnZXM+Ci0gIDxvOldvcmRzPjE2MjY8L286V29yZHM+Ci0gIDxvOkNoYXJhY3RlcnM+OTI3MDwvbzpDaGFyYWN0ZXJzPgotICAgPG86TGluZXM+Nzc8L286TGluZXM+Ci0gIDxvOlBhcmFncmFwaHM+MTg8L286UGFyYWdyYXBocz4KLSAgPG86Q2hhcmFjdGVyc1dpdGhTcGFjZXM+MTEzODQ8L286Q2hhcmFjdGVyc1dpdGhTcGFjZXM+Ci0gIDxvOlZlcnNpb24+OS40NDAyPC9vOlZlcnNpb24+Ci0gPC9vOkRvY3VtZW50UHJvcGVydGllcz4KLTwveG1sPjwhW2VuZGlmXS0tPjwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDx3OldvcmREb2N1bWVudD4KLSAgPHc6VHJhY2tSZXZpc2lvbnMvPgotIDwvdzpXb3JkRG9jdW1lbnQ+Ci08L3htbD48IVtlbmRpZl0tLT4KLTxzdHlsZT4KLTwhLS0KLSAvKiBGb250IERlZmluaXRpb25zICovCi1AZm9udC1mYWNlCi0Je2ZvbnQtZmFtaWx5OlRhaG9tYTsKLQlwYW5vc2UtMToyIDExIDYgNCAzIDUgNCA0IDIgNDsKLQltc28tZm9udC1jaGFyc2V0OjA7Ci0JbXNvLWdlbmVyaWMtZm9udC1mYW1pbHk6c3dpc3M7Ci0JbXNvLWZvbnQtcGl0Y2g6dmFyaWFibGU7Ci0JbXNvLWZvbnQtc2lnbmF0dXJlOjU1MzY3OTQ5NSAtMjE0NzQ4MzY0OCA4IDAgNjYwNDcgMDt9Ci0gLyogU3R5bGUgRGVmaW5pdGlvbnMgKi8KLXAuTXNvTm9ybWFsLCBsaS5Nc29Ob3JtYWwsIGRpdi5Nc29Ob3JtYWwKLQl7bXNvLXN0eWxlLXBhcmVudDoiIjsKLQltYXJnaW46MGluOwotCW1hcmdpbi1ib3R0b206LjAwMDFwdDsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjEyLjBwdDsKLQlmb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1wCi0Je21hcmdpbi1yaWdodDowaW47Ci0JbXNvLW1hcmdpbi10b3AtYWx0OmF1dG87Ci0JbXNvLW1hcmdpbi1ib3R0b20tYWx0OmF1dG87Ci0JbWFyZ2luLWxlZnQ6MGluOwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXAuQmFsbG9vblRleHQsIGxpLkJhbGxvb25UZXh0LCBkaXYuQmFsbG9vblRleHQKLQl7bXNvLXN0eWxlLW5hbWU6IkJhbGxvb24gVGV4dCI7Ci0JbWFyZ2luOjBpbjsKLQltYXJnaW4tYm90dG9tOi4wMDAxcHQ7Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZTo4LjBwdDsKLQlmb250LWZhbWlseTpUYWhvbWE7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotQHBhZ2UgU2VjdGlvbjEKLQl7c2l6ZTo4LjVpbiAxMS4waW47Ci0JbWFyZ2luOjEuMGluIDEuMjVpbiAxLjBpbiAxLjI1aW47Ci0JbXNvLWhlYWRlci1tYXJnaW46LjVpbjsKLQltc28tZm9vdGVyLW1hcmdpbjouNWluOwotCW1zby1wYXBlci1zb3VyY2U6MDt9Ci1kaXYuU2VjdGlvbjEKLQl7cGFnZTpTZWN0aW9uMTt9Ci0tLT4KLTwvc3R5bGU+Ci08L2hlYWQ+Ci0KLTxib2R5IGxhbmc9RU4tVVMgc3R5bGU9J3RhYi1pbnRlcnZhbDouNWluJz4KLQotPGRpdiBjbGFzcz1TZWN0aW9uMT4KLQotPHAgYWxpZ249Y2VudGVyIHN0eWxlPSd0ZXh0LWFsaWduOmNlbnRlcic+PGI+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIHYgMS4wPC9iPgotPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+VEhFIEFDQ09NUEFOWUlORyBQUk9HUkFNIElTIFBST1ZJREVEIFVOREVSCi1USEUgVEVSTVMgT0YgVEhJUyBFQ0xJUFNFIFBVQkxJQyBMSUNFTlNFICgmcXVvdDtBR1JFRU1FTlQmcXVvdDspLiBBTlkgVVNFLAotUkVQUk9EVUNUSU9OIE9SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBDT05TVElUVVRFUyBSRUNJUElFTlQnUyBBQ0NFUFRBTkNFCi1PRiBUSElTIEFHUkVFTUVOVC48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjEuIERFRklOSVRJT05TPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7Q29udHJpYnV0aW9uJnF1b3Q7IG1lYW5zOjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaW4gdGhlIGNhc2Ugb2YgdGhlIGluaXRpYWwgQ29udHJpYnV0b3IsIHRoZSBpbml0aWFsIGNvZGUgYW5kIGRvY3VtZW50YXRpb24KLWRpc3RyaWJ1dGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBhbmQ8YnIgY2xlYXI9bGVmdD4KLWIpIGluIHRoZSBjYXNlIG9mIGVhY2ggc3Vic2VxdWVudCBDb250cmlidXRvcjo8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pKQotY2hhbmdlcyB0byB0aGUgUHJvZ3JhbSwgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWkpCi1hZGRpdGlvbnMgdG8gdGhlIFByb2dyYW07PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+d2hlcmUKLXN1Y2ggY2hhbmdlcyBhbmQvb3IgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIG9yaWdpbmF0ZSBmcm9tIGFuZCBhcmUgZGlzdHJpYnV0ZWQKLWJ5IHRoYXQgcGFydGljdWxhciBDb250cmlidXRvci4gQSBDb250cmlidXRpb24gJ29yaWdpbmF0ZXMnIGZyb20gYSBDb250cmlidXRvcgotaWYgaXQgd2FzIGFkZGVkIHRvIHRoZSBQcm9ncmFtIGJ5IHN1Y2ggQ29udHJpYnV0b3IgaXRzZWxmIG9yIGFueW9uZSBhY3Rpbmcgb24KLXN1Y2ggQ29udHJpYnV0b3IncyBiZWhhbGYuIENvbnRyaWJ1dGlvbnMgZG8gbm90IGluY2x1ZGUgYWRkaXRpb25zIHRvIHRoZQotUHJvZ3JhbSB3aGljaDogKGkpIGFyZSBzZXBhcmF0ZSBtb2R1bGVzIG9mIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIGluIGNvbmp1bmN0aW9uCi13aXRoIHRoZSBQcm9ncmFtIHVuZGVyIHRoZWlyIG93biBsaWNlbnNlIGFncmVlbWVudCwgYW5kIChpaSkgYXJlIG5vdCBkZXJpdmF0aXZlCi13b3JrcyBvZiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0NvbnRyaWJ1dG9yJnF1b3Q7IG1lYW5zIGFueSBwZXJzb24gb3IKLWVudGl0eSB0aGF0IGRpc3RyaWJ1dGVzIHRoZSBQcm9ncmFtLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7TGljZW5zZWQgUGF0ZW50cyAmcXVvdDsgbWVhbiBwYXRlbnQKLWNsYWltcyBsaWNlbnNhYmxlIGJ5IGEgQ29udHJpYnV0b3Igd2hpY2ggYXJlIG5lY2Vzc2FyaWx5IGluZnJpbmdlZCBieSB0aGUgdXNlCi1vciBzYWxlIG9mIGl0cyBDb250cmlidXRpb24gYWxvbmUgb3Igd2hlbiBjb21iaW5lZCB3aXRoIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7UHJvZ3JhbSZxdW90OyBtZWFucyB0aGUgQ29udHJpYnV0aW9ucwotZGlzdHJpYnV0ZWQgaW4gYWNjb3JkYW5jZSB3aXRoIHRoaXMgQWdyZWVtZW50Ljwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7UmVjaXBpZW50JnF1b3Q7IG1lYW5zIGFueW9uZSB3aG8KLXJlY2VpdmVzIHRoZSBQcm9ncmFtIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBpbmNsdWRpbmcgYWxsIENvbnRyaWJ1dG9ycy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjIuIEdSQU5UIE9GIFJJR0hUUzwvc3Bhbj48L2I+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLVN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50Ci1hIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwgcm95YWx0eS1mcmVlIGNvcHlyaWdodCBsaWNlbnNlIHRvPHNwYW4KLXN0eWxlPSdjb2xvcjpyZWQnPiA8L3NwYW4+cmVwcm9kdWNlLCBwcmVwYXJlIGRlcml2YXRpdmUgd29ya3Mgb2YsIHB1YmxpY2x5Ci1kaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBkaXN0cmlidXRlIGFuZCBzdWJsaWNlbnNlIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaAotQ29udHJpYnV0b3IsIGlmIGFueSwgYW5kIHN1Y2ggZGVyaXZhdGl2ZSB3b3JrcywgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlCi1mb3JtLjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpCi1TdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzCi1SZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsPHNwYW4gc3R5bGU9J2NvbG9yOmdyZWVuJz4gPC9zcGFuPnJveWFsdHktZnJlZQotcGF0ZW50IGxpY2Vuc2UgdW5kZXIgTGljZW5zZWQgUGF0ZW50cyB0byBtYWtlLCB1c2UsIHNlbGwsIG9mZmVyIHRvIHNlbGwsIGltcG9ydAotYW5kIG90aGVyd2lzZSB0cmFuc2ZlciB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgaW4gc291cmNlCi1jb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLiBUaGlzIHBhdGVudCBsaWNlbnNlIHNoYWxsIGFwcGx5IHRvIHRoZSBjb21iaW5hdGlvbgotb2YgdGhlIENvbnRyaWJ1dGlvbiBhbmQgdGhlIFByb2dyYW0gaWYsIGF0IHRoZSB0aW1lIHRoZSBDb250cmlidXRpb24gaXMgYWRkZWQKLWJ5IHRoZSBDb250cmlidXRvciwgc3VjaCBhZGRpdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGNhdXNlcyBzdWNoIGNvbWJpbmF0aW9uCi10byBiZSBjb3ZlcmVkIGJ5IHRoZSBMaWNlbnNlZCBQYXRlbnRzLiBUaGUgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgbm90IGFwcGx5IHRvCi1hbnkgb3RoZXIgY29tYmluYXRpb25zIHdoaWNoIGluY2x1ZGUgdGhlIENvbnRyaWJ1dGlvbi4gTm8gaGFyZHdhcmUgcGVyIHNlIGlzCi1saWNlbnNlZCBoZXJldW5kZXIuIDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmMpCi1SZWNpcGllbnQgdW5kZXJzdGFuZHMgdGhhdCBhbHRob3VnaCBlYWNoIENvbnRyaWJ1dG9yIGdyYW50cyB0aGUgbGljZW5zZXMgdG8gaXRzCi1Db250cmlidXRpb25zIHNldCBmb3J0aCBoZXJlaW4sIG5vIGFzc3VyYW5jZXMgYXJlIHByb3ZpZGVkIGJ5IGFueSBDb250cmlidXRvcgotdGhhdCB0aGUgUHJvZ3JhbSBkb2VzIG5vdCBpbmZyaW5nZSB0aGUgcGF0ZW50IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQotcmlnaHRzIG9mIGFueSBvdGhlciBlbnRpdHkuIEVhY2ggQ29udHJpYnV0b3IgZGlzY2xhaW1zIGFueSBsaWFiaWxpdHkgdG8gUmVjaXBpZW50Ci1mb3IgY2xhaW1zIGJyb3VnaHQgYnkgYW55IG90aGVyIGVudGl0eSBiYXNlZCBvbiBpbmZyaW5nZW1lbnQgb2YgaW50ZWxsZWN0dWFsCi1wcm9wZXJ0eSByaWdodHMgb3Igb3RoZXJ3aXNlLiBBcyBhIGNvbmRpdGlvbiB0byBleGVyY2lzaW5nIHRoZSByaWdodHMgYW5kCi1saWNlbnNlcyBncmFudGVkIGhlcmV1bmRlciwgZWFjaCBSZWNpcGllbnQgaGVyZWJ5IGFzc3VtZXMgc29sZSByZXNwb25zaWJpbGl0eQotdG8gc2VjdXJlIGFueSBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG5lZWRlZCwgaWYgYW55LiBGb3IgZXhhbXBsZSwKLWlmIGEgdGhpcmQgcGFydHkgcGF0ZW50IGxpY2Vuc2UgaXMgcmVxdWlyZWQgdG8gYWxsb3cgUmVjaXBpZW50IHRvIGRpc3RyaWJ1dGUKLXRoZSBQcm9ncmFtLCBpdCBpcyBSZWNpcGllbnQncyByZXNwb25zaWJpbGl0eSB0byBhY3F1aXJlIHRoYXQgbGljZW5zZSBiZWZvcmUKLWRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbS48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5kKQotRWFjaCBDb250cmlidXRvciByZXByZXNlbnRzIHRoYXQgdG8gaXRzIGtub3dsZWRnZSBpdCBoYXMgc3VmZmljaWVudCBjb3B5cmlnaHQKLXJpZ2h0cyBpbiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIHRvIGdyYW50IHRoZSBjb3B5cmlnaHQgbGljZW5zZSBzZXQgZm9ydGggaW4KLXRoaXMgQWdyZWVtZW50LiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+My4gUkVRVUlSRU1FTlRTPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+QSBDb250cmlidXRvciBtYXkgY2hvb3NlIHRvIGRpc3RyaWJ1dGUgdGhlCi1Qcm9ncmFtIGluIG9iamVjdCBjb2RlIGZvcm0gdW5kZXIgaXRzIG93biBsaWNlbnNlIGFncmVlbWVudCwgcHJvdmlkZWQgdGhhdDo8L3NwYW4+Ci08L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pdCBjb21wbGllcyB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudDsgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikKLWl0cyBsaWNlbnNlIGFncmVlbWVudDo8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pKQotZWZmZWN0aXZlbHkgZGlzY2xhaW1zIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCB3YXJyYW50aWVzIGFuZAotY29uZGl0aW9ucywgZXhwcmVzcyBhbmQgaW1wbGllZCwgaW5jbHVkaW5nIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiB0aXRsZQotYW5kIG5vbi1pbmZyaW5nZW1lbnQsIGFuZCBpbXBsaWVkIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiBtZXJjaGFudGFiaWxpdHkKLWFuZCBmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZTsgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWkpCi1lZmZlY3RpdmVseSBleGNsdWRlcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgbGlhYmlsaXR5IGZvciBkYW1hZ2VzLAotaW5jbHVkaW5nIGRpcmVjdCwgaW5kaXJlY3QsIHNwZWNpYWwsIGluY2lkZW50YWwgYW5kIGNvbnNlcXVlbnRpYWwgZGFtYWdlcywgc3VjaAotYXMgbG9zdCBwcm9maXRzOyA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paWkpCi1zdGF0ZXMgdGhhdCBhbnkgcHJvdmlzaW9ucyB3aGljaCBkaWZmZXIgZnJvbSB0aGlzIEFncmVlbWVudCBhcmUgb2ZmZXJlZCBieSB0aGF0Ci1Db250cmlidXRvciBhbG9uZSBhbmQgbm90IGJ5IGFueSBvdGhlciBwYXJ0eTsgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aXYpCi1zdGF0ZXMgdGhhdCBzb3VyY2UgY29kZSBmb3IgdGhlIFByb2dyYW0gaXMgYXZhaWxhYmxlIGZyb20gc3VjaCBDb250cmlidXRvciwgYW5kCi1pbmZvcm1zIGxpY2Vuc2VlcyBob3cgdG8gb2J0YWluIGl0IGluIGEgcmVhc29uYWJsZSBtYW5uZXIgb24gb3IgdGhyb3VnaCBhCi1tZWRpdW0gY3VzdG9tYXJpbHkgdXNlZCBmb3Igc29mdHdhcmUgZXhjaGFuZ2UuPHNwYW4gc3R5bGU9J2NvbG9yOmJsdWUnPiA8L3NwYW4+PC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPldoZW4gdGhlIFByb2dyYW0gaXMgbWFkZSBhdmFpbGFibGUgaW4gc291cmNlCi1jb2RlIGZvcm06PC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pdCBtdXN0IGJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoaXMgQWdyZWVtZW50OyBhbmQgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikgYQotY29weSBvZiB0aGlzIEFncmVlbWVudCBtdXN0IGJlIGluY2x1ZGVkIHdpdGggZWFjaCBjb3B5IG9mIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Q29udHJpYnV0b3JzIG1heSBub3QgcmVtb3ZlIG9yIGFsdGVyIGFueQotY29weXJpZ2h0IG5vdGljZXMgY29udGFpbmVkIHdpdGhpbiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVhY2ggQ29udHJpYnV0b3IgbXVzdCBpZGVudGlmeSBpdHNlbGYgYXMgdGhlCi1vcmlnaW5hdG9yIG9mIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgaW4gYSBtYW5uZXIgdGhhdCByZWFzb25hYmx5IGFsbG93cwotc3Vic2VxdWVudCBSZWNpcGllbnRzIHRvIGlkZW50aWZ5IHRoZSBvcmlnaW5hdG9yIG9mIHRoZSBDb250cmlidXRpb24uIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz40LiBDT01NRVJDSUFMIERJU1RSSUJVVElPTjwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkNvbW1lcmNpYWwgZGlzdHJpYnV0b3JzIG9mIHNvZnR3YXJlIG1heQotYWNjZXB0IGNlcnRhaW4gcmVzcG9uc2liaWxpdGllcyB3aXRoIHJlc3BlY3QgdG8gZW5kIHVzZXJzLCBidXNpbmVzcyBwYXJ0bmVycwotYW5kIHRoZSBsaWtlLiBXaGlsZSB0aGlzIGxpY2Vuc2UgaXMgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY29tbWVyY2lhbCB1c2UKLW9mIHRoZSBQcm9ncmFtLCB0aGUgQ29udHJpYnV0b3Igd2hvIGluY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbAotcHJvZHVjdCBvZmZlcmluZyBzaG91bGQgZG8gc28gaW4gYSBtYW5uZXIgd2hpY2ggZG9lcyBub3QgY3JlYXRlIHBvdGVudGlhbAotbGlhYmlsaXR5IGZvciBvdGhlciBDb250cmlidXRvcnMuIFRoZXJlZm9yZSwgaWYgYSBDb250cmlidXRvciBpbmNsdWRlcyB0aGUKLVByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIHN1Y2ggQ29udHJpYnV0b3IgKCZxdW90O0NvbW1lcmNpYWwKLUNvbnRyaWJ1dG9yJnF1b3Q7KSBoZXJlYnkgYWdyZWVzIHRvIGRlZmVuZCBhbmQgaW5kZW1uaWZ5IGV2ZXJ5IG90aGVyCi1Db250cmlidXRvciAoJnF1b3Q7SW5kZW1uaWZpZWQgQ29udHJpYnV0b3ImcXVvdDspIGFnYWluc3QgYW55IGxvc3NlcywgZGFtYWdlcyBhbmQKLWNvc3RzIChjb2xsZWN0aXZlbHkgJnF1b3Q7TG9zc2VzJnF1b3Q7KSBhcmlzaW5nIGZyb20gY2xhaW1zLCBsYXdzdWl0cyBhbmQgb3RoZXIKLWxlZ2FsIGFjdGlvbnMgYnJvdWdodCBieSBhIHRoaXJkIHBhcnR5IGFnYWluc3QgdGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIHRvCi10aGUgZXh0ZW50IGNhdXNlZCBieSB0aGUgYWN0cyBvciBvbWlzc2lvbnMgb2Ygc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluCi1jb25uZWN0aW9uIHdpdGggaXRzIGRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdAotb2ZmZXJpbmcuIFRoZSBvYmxpZ2F0aW9ucyBpbiB0aGlzIHNlY3Rpb24gZG8gbm90IGFwcGx5IHRvIGFueSBjbGFpbXMgb3IgTG9zc2VzCi1yZWxhdGluZyB0byBhbnkgYWN0dWFsIG9yIGFsbGVnZWQgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGluZnJpbmdlbWVudC4gSW4gb3JkZXIKLXRvIHF1YWxpZnksIGFuIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG11c3Q6IGEpIHByb21wdGx5IG5vdGlmeSB0aGUgQ29tbWVyY2lhbAotQ29udHJpYnV0b3IgaW4gd3JpdGluZyBvZiBzdWNoIGNsYWltLCBhbmQgYikgYWxsb3cgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IKLXRvIGNvbnRyb2wsIGFuZCBjb29wZXJhdGUgd2l0aCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiwgdGhlIGRlZmVuc2UgYW5kCi1hbnkgcmVsYXRlZCBzZXR0bGVtZW50IG5lZ290aWF0aW9ucy4gVGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG1heSBwYXJ0aWNpcGF0ZQotaW4gYW55IHN1Y2ggY2xhaW0gYXQgaXRzIG93biBleHBlbnNlLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Rm9yIGV4YW1wbGUsIGEgQ29udHJpYnV0b3IgbWlnaHQgaW5jbHVkZSB0aGUKLVByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIFByb2R1Y3QgWC4gVGhhdCBDb250cmlidXRvciBpcyB0aGVuIGEKLUNvbW1lcmNpYWwgQ29udHJpYnV0b3IuIElmIHRoYXQgQ29tbWVyY2lhbCBDb250cmlidXRvciB0aGVuIG1ha2VzIHBlcmZvcm1hbmNlCi1jbGFpbXMsIG9yIG9mZmVycyB3YXJyYW50aWVzIHJlbGF0ZWQgdG8gUHJvZHVjdCBYLCB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kCi13YXJyYW50aWVzIGFyZSBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IncyByZXNwb25zaWJpbGl0eSBhbG9uZS4gVW5kZXIgdGhpcwotc2VjdGlvbiwgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3Igd291bGQgaGF2ZSB0byBkZWZlbmQgY2xhaW1zIGFnYWluc3QgdGhlCi1vdGhlciBDb250cmlidXRvcnMgcmVsYXRlZCB0byB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMsIGFuZCBpZiBhCi1jb3VydCByZXF1aXJlcyBhbnkgb3RoZXIgQ29udHJpYnV0b3IgdG8gcGF5IGFueSBkYW1hZ2VzIGFzIGEgcmVzdWx0LCB0aGUKLUNvbW1lcmNpYWwgQ29udHJpYnV0b3IgbXVzdCBwYXkgdGhvc2UgZGFtYWdlcy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjUuIE5PIFdBUlJBTlRZPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUwotQUdSRUVNRU5ULCBUSEUgUFJPR1JBTSBJUyBQUk9WSURFRCBPTiBBTiAmcXVvdDtBUyBJUyZxdW90OyBCQVNJUywgV0lUSE9VVAotV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBFSVRIRVIgRVhQUkVTUyBPUiBJTVBMSUVEIElOQ0xVRElORywKLVdJVEhPVVQgTElNSVRBVElPTiwgQU5ZIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBUSVRMRSwgTk9OLUlORlJJTkdFTUVOVCwKLU1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gRWFjaCBSZWNpcGllbnQgaXMgc29sZWx5Ci1yZXNwb25zaWJsZSBmb3IgZGV0ZXJtaW5pbmcgdGhlIGFwcHJvcHJpYXRlbmVzcyBvZiB1c2luZyBhbmQgZGlzdHJpYnV0aW5nIHRoZQotUHJvZ3JhbSBhbmQgYXNzdW1lcyBhbGwgcmlza3MgYXNzb2NpYXRlZCB3aXRoIGl0cyBleGVyY2lzZSBvZiByaWdodHMgdW5kZXIgdGhpcwotQWdyZWVtZW50ICwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgcmlza3MgYW5kIGNvc3RzIG9mIHByb2dyYW0gZXJyb3JzLAotY29tcGxpYW5jZSB3aXRoIGFwcGxpY2FibGUgbGF3cywgZGFtYWdlIHRvIG9yIGxvc3Mgb2YgZGF0YSwgcHJvZ3JhbXMgb3IKLWVxdWlwbWVudCwgYW5kIHVuYXZhaWxhYmlsaXR5IG9yIGludGVycnVwdGlvbiBvZiBvcGVyYXRpb25zLiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Ni4gRElTQ0xBSU1FUiBPRiBMSUFCSUxJVFk8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTCi1BR1JFRU1FTlQsIE5FSVRIRVIgUkVDSVBJRU5UIE5PUiBBTlkgQ09OVFJJQlVUT1JTIFNIQUxMIEhBVkUgQU5ZIExJQUJJTElUWSBGT1IKLUFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwotKElOQ0xVRElORyBXSVRIT1VUIExJTUlUQVRJT04gTE9TVCBQUk9GSVRTKSwgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKLU9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HCi1ORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9SIERJU1RSSUJVVElPTiBPRgotVEhFIFBST0dSQU0gT1IgVEhFIEVYRVJDSVNFIE9GIEFOWSBSSUdIVFMgR1JBTlRFRCBIRVJFVU5ERVIsIEVWRU4gSUYgQURWSVNFRCBPRgotVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFUy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjcuIEdFTkVSQUw8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5JZiBhbnkgcHJvdmlzaW9uIG9mIHRoaXMgQWdyZWVtZW50IGlzIGludmFsaWQKLW9yIHVuZW5mb3JjZWFibGUgdW5kZXIgYXBwbGljYWJsZSBsYXcsIGl0IHNoYWxsIG5vdCBhZmZlY3QgdGhlIHZhbGlkaXR5IG9yCi1lbmZvcmNlYWJpbGl0eSBvZiB0aGUgcmVtYWluZGVyIG9mIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgYW5kIHdpdGhvdXQKLWZ1cnRoZXIgYWN0aW9uIGJ5IHRoZSBwYXJ0aWVzIGhlcmV0bywgc3VjaCBwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlCi1taW5pbXVtIGV4dGVudCBuZWNlc3NhcnkgdG8gbWFrZSBzdWNoIHByb3Zpc2lvbiB2YWxpZCBhbmQgZW5mb3JjZWFibGUuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5JZiBSZWNpcGllbnQgaW5zdGl0dXRlcyBwYXRlbnQgbGl0aWdhdGlvbgotYWdhaW5zdCBhbnkgZW50aXR5IChpbmNsdWRpbmcgYSBjcm9zcy1jbGFpbSBvciBjb3VudGVyY2xhaW0gaW4gYSBsYXdzdWl0KQotYWxsZWdpbmcgdGhhdCB0aGUgUHJvZ3JhbSBpdHNlbGYgKGV4Y2x1ZGluZyBjb21iaW5hdGlvbnMgb2YgdGhlIFByb2dyYW0gd2l0aAotb3RoZXIgc29mdHdhcmUgb3IgaGFyZHdhcmUpIGluZnJpbmdlcyBzdWNoIFJlY2lwaWVudCdzIHBhdGVudChzKSwgdGhlbiBzdWNoCi1SZWNpcGllbnQncyByaWdodHMgZ3JhbnRlZCB1bmRlciBTZWN0aW9uIDIoYikgc2hhbGwgdGVybWluYXRlIGFzIG9mIHRoZSBkYXRlCi1zdWNoIGxpdGlnYXRpb24gaXMgZmlsZWQuIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5BbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50Ci1zaGFsbCB0ZXJtaW5hdGUgaWYgaXQgZmFpbHMgdG8gY29tcGx5IHdpdGggYW55IG9mIHRoZSBtYXRlcmlhbCB0ZXJtcyBvcgotY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudCBhbmQgZG9lcyBub3QgY3VyZSBzdWNoIGZhaWx1cmUgaW4gYSByZWFzb25hYmxlCi1wZXJpb2Qgb2YgdGltZSBhZnRlciBiZWNvbWluZyBhd2FyZSBvZiBzdWNoIG5vbmNvbXBsaWFuY2UuIElmIGFsbCBSZWNpcGllbnQncwotcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHRlcm1pbmF0ZSwgUmVjaXBpZW50IGFncmVlcyB0byBjZWFzZSB1c2UgYW5kCi1kaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gYXMgc29vbiBhcyByZWFzb25hYmx5IHByYWN0aWNhYmxlLiBIb3dldmVyLAotUmVjaXBpZW50J3Mgb2JsaWdhdGlvbnMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYW5kIGFueSBsaWNlbnNlcyBncmFudGVkIGJ5Ci1SZWNpcGllbnQgcmVsYXRpbmcgdG8gdGhlIFByb2dyYW0gc2hhbGwgY29udGludWUgYW5kIHN1cnZpdmUuIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FdmVyeW9uZSBpcyBwZXJtaXR0ZWQgdG8gY29weSBhbmQgZGlzdHJpYnV0ZQotY29waWVzIG9mIHRoaXMgQWdyZWVtZW50LCBidXQgaW4gb3JkZXIgdG8gYXZvaWQgaW5jb25zaXN0ZW5jeSB0aGUgQWdyZWVtZW50IGlzCi1jb3B5cmlnaHRlZCBhbmQgbWF5IG9ubHkgYmUgbW9kaWZpZWQgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXIuIFRoZSBBZ3JlZW1lbnQKLVN0ZXdhcmQgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHB1Ymxpc2ggbmV3IHZlcnNpb25zIChpbmNsdWRpbmcgcmV2aXNpb25zKSBvZgotdGhpcyBBZ3JlZW1lbnQgZnJvbSB0aW1lIHRvIHRpbWUuIE5vIG9uZSBvdGhlciB0aGFuIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCBoYXMKLXRoZSByaWdodCB0byBtb2RpZnkgdGhpcyBBZ3JlZW1lbnQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgdGhlIGluaXRpYWwKLUFncmVlbWVudCBTdGV3YXJkLiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1heSBhc3NpZ24gdGhlIHJlc3BvbnNpYmlsaXR5IHRvCi1zZXJ2ZSBhcyB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgdG8gYSBzdWl0YWJsZSBzZXBhcmF0ZSBlbnRpdHkuIEVhY2ggbmV3IHZlcnNpb24KLW9mIHRoZSBBZ3JlZW1lbnQgd2lsbCBiZSBnaXZlbiBhIGRpc3Rpbmd1aXNoaW5nIHZlcnNpb24gbnVtYmVyLiBUaGUgUHJvZ3JhbQotKGluY2x1ZGluZyBDb250cmlidXRpb25zKSBtYXkgYWx3YXlzIGJlIGRpc3RyaWJ1dGVkIHN1YmplY3QgdG8gdGhlIHZlcnNpb24gb2YKLXRoZSBBZ3JlZW1lbnQgdW5kZXIgd2hpY2ggaXQgd2FzIHJlY2VpdmVkLiBJbiBhZGRpdGlvbiwgYWZ0ZXIgYSBuZXcgdmVyc2lvbiBvZgotdGhlIEFncmVlbWVudCBpcyBwdWJsaXNoZWQsIENvbnRyaWJ1dG9yIG1heSBlbGVjdCB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtCi0oaW5jbHVkaW5nIGl0cyBDb250cmlidXRpb25zKSB1bmRlciB0aGUgbmV3IHZlcnNpb24uIEV4Y2VwdCBhcyBleHByZXNzbHkgc3RhdGVkCi1pbiBTZWN0aW9ucyAyKGEpIGFuZCAyKGIpIGFib3ZlLCBSZWNpcGllbnQgcmVjZWl2ZXMgbm8gcmlnaHRzIG9yIGxpY2Vuc2VzIHRvCi10aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IG9mIGFueSBDb250cmlidXRvciB1bmRlciB0aGlzIEFncmVlbWVudCwgd2hldGhlcgotZXhwcmVzc2x5LCBieSBpbXBsaWNhdGlvbiwgZXN0b3BwZWwgb3Igb3RoZXJ3aXNlLiBBbGwgcmlnaHRzIGluIHRoZSBQcm9ncmFtIG5vdAotZXhwcmVzc2x5IGdyYW50ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYXJlIHJlc2VydmVkLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+VGhpcyBBZ3JlZW1lbnQgaXMgZ292ZXJuZWQgYnkgdGhlIGxhd3Mgb2YgdGhlCi1TdGF0ZSBvZiBOZXcgWW9yayBhbmQgdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBsYXdzIG9mIHRoZSBVbml0ZWQgU3RhdGVzIG9mCi1BbWVyaWNhLiBObyBwYXJ0eSB0byB0aGlzIEFncmVlbWVudCB3aWxsIGJyaW5nIGEgbGVnYWwgYWN0aW9uIHVuZGVyIHRoaXMKLUFncmVlbWVudCBtb3JlIHRoYW4gb25lIHllYXIgYWZ0ZXIgdGhlIGNhdXNlIG9mIGFjdGlvbiBhcm9zZS4gRWFjaCBwYXJ0eSB3YWl2ZXMKLWl0cyByaWdodHMgdG8gYSBqdXJ5IHRyaWFsIGluIGFueSByZXN1bHRpbmcgbGl0aWdhdGlvbi48L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjwhW2lmICFzdXBwb3J0RW1wdHlQYXJhc10+Jm5ic3A7PCFbZW5kaWZdPjxvOnA+PC9vOnA+PC9wPgotCi08L2Rpdj4KLQotPC9ib2R5PgotCi08L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmFzc2VtYmx5LmZlYXR1cmUvZmVhdHVyZS5wcm9wZXJ0aWVzIGIvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmFzc2VtYmx5LmZlYXR1cmUvZmVhdHVyZS5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2YjU4ZmU2Li4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5hc3NlbWJseS5mZWF0dXJlL2ZlYXR1cmUucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDE0NSArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIGZlYXR1cmUucHJvcGVydGllcwotIyBjb250YWlucyBleHRlcm5hbGl6ZWQgc3RyaW5ncyBmb3IgZmVhdHVyZS54bWwKLSMgIiVmb28iIGluIGZlYXR1cmUueG1sIGNvcnJlc3BvbmRzIHRvIHRoZSBrZXkgImZvbyIgaW4gdGhpcyBmaWxlCi0jIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCi0jIFRoaXMgZmlsZSBzaG91bGQgYmUgdHJhbnNsYXRlZC4KLQotIyAiZmVhdHVyZU5hbWUiIHByb3BlcnR5IC0gbmFtZSBvZiB0aGUgZmVhdHVyZQotZmVhdHVyZU5hbWU9RGFsaSBKYXZhIFBlcnNpc3RlbmNlIEFQSSAoSlBBKSBwcm9qZWN0IFRlc3RzCi0KLSMgInByb3ZpZGVyTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBjb21wYW55IHRoYXQgcHJvdmlkZXMgdGhlIGZlYXR1cmUKLXByb3ZpZGVyTmFtZT1FY2xpcHNlLm9yZwotCi0jICJ1cGRhdGVTaXRlTmFtZSIgcHJvcGVydHkgLSBsYWJlbCBmb3IgdGhlIHVwZGF0ZSBzaXRlCi11cGRhdGVTaXRlTmFtZT1UaGUgRWNsaXBzZSBXZWIgVG9vbHMgUGxhdGZvcm0gKFdUUCkgUHJvamVjdCB1cGRhdGUgc2l0ZQotCi0jICJkZXNjcmlwdGlvbiIgcHJvcGVydHkgLSBkZXNjcmlwdGlvbiBvZiB0aGUgZmVhdHVyZQotZGVzY3JpcHRpb249RGFsaSBKYXZhIFBlcnNpc3RlbmNlIEFQSSAoSlBBKSBwcm9qZWN0IFRlc3RzCi0KLSMgImNvcHlyaWdodCIgcHJvcGVydHkgLSB0ZXh0IG9mIHRoZSAiRmVhdHVyZSBVcGRhdGUgQ29weXJpZ2h0IgotY29weXJpZ2h0PVwKLUNvcHlyaWdodCAoYykgMjAwNiBPcmFjbGUgQ29ycG9yYXRpb24uXG5cCi1BbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzXG5cCi1hcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjBcblwKLXdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0XG5cCi1odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbFxuXAotXG5cCi1Db250cmlidXRvcnM6XG5cCi0gICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uXG4KLSMjIyMjIyMjIyMjIyMjIyMgZW5kIG9mIGNvcHlyaWdodCBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotIyAibGljZW5zZVVSTCIgcHJvcGVydHkgLSBVUkwgb2YgdGhlICJGZWF0dXJlIExpY2Vuc2UiCi0jIGRvIG5vdCB0cmFuc2xhdGUgdmFsdWUgLSBqdXN0IGNoYW5nZSB0byBwb2ludCB0byBhIGxvY2FsZS1zcGVjaWZpYyBIVE1MIHBhZ2UKLWxpY2Vuc2VVUkw9bGljZW5zZS5odG1sCi0KLSMgImxpY2Vuc2UiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIExpY2Vuc2UiCi0jIHNob3VsZCBiZSBwbGFpbiB0ZXh0IHZlcnNpb24gb2YgbGljZW5zZSBhZ3JlZW1lbnQgcG9pbnRlZCB0byBiZSAibGljZW5zZVVSTCIKLWxpY2Vuc2U9XAotRUNMSVBTRSBGT1VOREFUSU9OIFNPRlRXQVJFIFVTRVIgQUdSRUVNRU5UXG5cCi1KdW5lIDA2LCAyMDA3XG5cCi1cblwKLVVzYWdlIE9mIENvbnRlbnRcblwKLVxuXAotVEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUlxuXAotT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUyAoQ09MTEVDVElWRUxZICJDT05URU5UIikuXG5cCi1VU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVNcblwKLUFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUlxuXAotTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVVxuXAotQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVFxuXAotQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFNcblwKLU9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFXG5cCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TXG5cCi1PRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRFxuXAotQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULlxuXAotXG5cCi1BcHBsaWNhYmxlIExpY2Vuc2VzXG5cCi1cblwKLVVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uXG5cCi1pcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpY1xuXAotTGljZW5zZSBWZXJzaW9uIDEuMCAoIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXNcblwKLUNvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLlxuXAotRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuXG5cCi1cblwKLUNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLFxuXAotZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZS5vcmcgQ1ZTXG5cCi1yZXBvc2l0b3J5ICgiUmVwb3NpdG9yeSIpIGluIENWUyBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIGF2YWlsYWJsZVxuXAotYXMgZG93bmxvYWRhYmxlIGFyY2hpdmVzICgiRG93bmxvYWRzIikuXG5cCi1cblwKLSAgIC0gQ29udGVudCBtYXkgYmUgc3RydWN0dXJlZCBhbmQgcGFja2FnZWQgaW50byBtb2R1bGVzIHRvIGZhY2lsaXRhdGUgZGVsaXZlcmluZyxcblwKLSAgICAgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiBUeXBpY2FsIG1vZHVsZXMgbWF5IGluY2x1ZGUgcGx1Zy1pbnMgKCJQbHVnLWlucyIpLFxuXAotICAgICBwbHVnLWluIGZyYWdtZW50cyAoIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLlxuXAotICAgLSBFYWNoIFBsdWctaW4gb3IgRnJhZ21lbnQgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBvciBKQVIgKEphdmE/IEFSY2hpdmUpXG5cCi0gICAgIGluIGEgZGlyZWN0b3J5IG5hbWVkICJwbHVnaW5zIi5cblwKLSAgIC0gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuXG5cCi0gICAgIEVhY2ggRmVhdHVyZSBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IGluIGEgZGlyZWN0b3J5IG5hbWVkICJmZWF0dXJlcyIuXG5cCi0gICAgIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvblxuXAotICAgICBudW1iZXJzIG9mIHRoZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuXG5cCi0gICAtIEZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlc1xuXAotICAgICBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy5cblwKLVxuXAotRmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIEZpbGVzIG5hbWVkXG5cCi0iZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZlxuXAotSW5jbHVkZWQgRmVhdHVyZXMuXG5cCi1cblwKLVRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmVcblwKLWNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZFxuXAotY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kIEluY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWRcblwKLWluIGZpbGVzIG5hbWVkICJsaWNlbnNlLmh0bWwiICgiRmVhdHVyZSBMaWNlbnNlcyIpLiBBYm91dHMgYW5kIEZlYXR1cmVcblwKLUxpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSBkaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGVcblwKLWluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOlxuXAotXG5cCi0gICAtIFRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeVxuXAotICAgLSBQbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3Rvcmllc1xuXAotICAgLSBJbnNpZGUgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBwYWNrYWdlZCBhcyBKQVJzXG5cCi0gICAtIFN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnNcblwKLSAgIC0gRmVhdHVyZSBkaXJlY3Rvcmllc1xuXAotXG5cCi1Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlXG5cCi1FY2xpcHNlIFVwZGF0ZSBNYW5hZ2VyLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFVwZGF0ZVxuXAotTGljZW5zZSIpIGR1cmluZyB0aGUgaW5zdGFsbGF0aW9uIHByb2Nlc3MuIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zXG5cCi1JbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdVxuXAotd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvciBpbmZvcm1cblwKLXlvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW5cblwKLXRoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIuIFN1Y2ggQWJvdXRzLFxuXAotRmVhdHVyZSBMaWNlbnNlcyBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kXG5cCi1jb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXJcblwKLXVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluIHRoYXQgZGlyZWN0b3J5LlxuXAotXG5cCi1USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVJcblwKLVRPIFRIRSBFUEwgT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLlxuXAotU09NRSBPRiBUSEVTRSBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOlxuXAotXG5cCi0gICAgLSBDb21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbClcblwKLSAgICAtIEFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFKVxuXAotICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wKVxuXAotICAgIC0gSUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sKVxuXAotICAgIC0gTWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwpXG5cCi0gICAgLSBNb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sKVxuXAotICAgIC0gQ29tbW9uIERldmVsb3BtZW50IGFuZCBEaXN0cmlidXRpb24gTGljZW5zZSAoQ0RETCkgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwpXG5cCi1cblwKLUlUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1JcblwKLVRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlXG5cCi1pcyBwcm92aWRlZCwgcGxlYXNlIGNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9uc1xuXAotZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LlxuXAotXG5cCi1DcnlwdG9ncmFwaHlcblwKLVxuXAotQ29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlXG5cCi1jdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsXG5cCi1hbmQvb3IgcmUtZXhwb3J0IHRvIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFXG5cCi11c2luZyBhbnkgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cyxcblwKLXJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIG9yIHVzZSxcblwKLWFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLlxuXAotXG5cCi1KYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIFN1biBNaWNyb3N5c3RlbXMsIEluYy4gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC5cbgotIyMjIyMjIyMjIyMgZW5kIG9mIGxpY2Vuc2UgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMuYXNzZW1ibHkuZmVhdHVyZS9mZWF0dXJlLnhtbCBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5hc3NlbWJseS5mZWF0dXJlL2ZlYXR1cmUueG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4YzFkODE5Li4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5hc3NlbWJseS5mZWF0dXJlL2ZlYXR1cmUueG1sCisrKyAvZGV2L251bGwKQEAgLTEsMjggKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxmZWF0dXJlCi0gICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LnRlc3RzLmFzc2VtYmx5LmZlYXR1cmUiCi0gICAgICBsYWJlbD0iJWZlYXR1cmVOYW1lIgotICAgICAgdmVyc2lvbj0iMi4xLjAucXVhbGlmaWVyIgotICAgICAgcHJvdmlkZXItbmFtZT0iJXByb3ZpZGVyTmFtZSI+Ci0KLSAgIDxkZXNjcmlwdGlvbj4KLSAgICAgICVkZXNjcmlwdGlvbgotICAgPC9kZXNjcmlwdGlvbj4KLQotICAgPGNvcHlyaWdodD4KLSAgICAgICVjb3B5cmlnaHQKLSAgIDwvY29weXJpZ2h0PgotCi0gICA8bGljZW5zZSB1cmw9ImxpY2Vuc2UuaHRtbCI+Ci0gICAgICAlbGljZW5zZQotICAgPC9saWNlbnNlPgotCi0gICA8dXJsPgotICAgICAgPHVwZGF0ZSBsYWJlbD0iJXVwZGF0ZVNpdGVOYW1lIiB1cmw9Imh0dHA6Ly9kb3dubG9hZC5lY2xpcHNlLm9yZy93ZWJ0b29scy91cGRhdGVzLyIvPgotICAgPC91cmw+Ci0KLSAgIDxpbmNsdWRlcwotICAgICAgICAgaWQ9Im9yZy5lY2xpcHNlLmpwdC50ZXN0cy5mZWF0dXJlIgotICAgICAgICAgdmVyc2lvbj0iMC4wLjAiLz4KLQotPC9mZWF0dXJlPgpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmFzc2VtYmx5LmZlYXR1cmUvbGljZW5zZS5odG1sIGIvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmFzc2VtYmx5LmZlYXR1cmUvbGljZW5zZS5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1NjQ0NTk4Li4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5hc3NlbWJseS5mZWF0dXJlL2xpY2Vuc2UuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDk4ICswLDAgQEAKLTwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAxIFRyYW5zaXRpb25hbC8vRU4iICJodHRwOi8vd3d3LnczYy5vcmcvVFIvMTk5OS9SRUMtaHRtbDQwMS0xOTk5MTIyNC9sb29zZS5kdGQiPgotPCEtLSBzYXZlZCBmcm9tIHVybD0oMDA0NClodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC9ub3RpY2UuaHRtbCAtLT4KLTxIVE1MPjxIRUFEPjxUSVRMRT5FY2xpcHNlLm9yZyBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvVElUTEU+Ci08TUVUQSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9aXNvLTg4NTktMSI+Ci08TUVUQSBjb250ZW50PSJNU0hUTUwgNi4wMC4yODAwLjE0NzkiIG5hbWU9R0VORVJBVE9SPjwvSEVBRD4KLTxCT0RZIGxhbmc9RU4tVVMgdkxpbms9cHVycGxlIGxpbms9Ymx1ZT4KLTxIMj5FY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L0gyPgotPFA+SnVuZSAwNiwgMjAwNzwvUD4KLTxIMz5Vc2FnZSBPZiBDb250ZW50PC9IMz4KLTxQPlRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiAKLUFORC9PUiBPVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTIChDT0xMRUNUSVZFTFkgIkNPTlRFTlQiKS4gVVNFIE9GIAotVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCAKLUJFTE9XLiBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VIEFHUkVFIFRIQVQgWU9VUiBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgCi1CWSBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgCi1BR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFIAotVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgCi1BUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLCBUSEVOIFlPVSAKLU1BWSBOT1QgVVNFIFRIRSBDT05URU5ULjwvUD4KLTxIMz5BcHBsaWNhYmxlIExpY2Vuc2VzPC9IMz4KLTxQPlVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSAKLUZvdW5kYXRpb24gaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRWNsaXBzZSAKLVB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wICgiRVBMIikuIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpcyAKLUNvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IDxBIAotaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sPC9BPi4gCi1Gb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC48L1A+Ci08UD5Db250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSwgCi1kb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlLm9yZyBDVlMgcmVwb3NpdG9yeSAKLSgiUmVwb3NpdG9yeSIpIGluIENWUyBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIGF2YWlsYWJsZSBhcyBkb3dubG9hZGFibGUgCi1hcmNoaXZlcyAoIkRvd25sb2FkcyIpLjwvUD4KLTxQPkNvbnRlbnQgbWF5IGJlIGFwcG9ydGlvbmVkIGludG8gcGx1Zy1pbnMgKCJQbHVnLWlucyIpLCBwbHVnLWluIGZyYWdtZW50cyAKLSgiRnJhZ21lbnRzIiksIGFuZCBmZWF0dXJlcyAoIkZlYXR1cmVzIikuIEEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSAKLVBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuIEZpbGVzIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IAotY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgdGhlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgCi1hc3NvY2lhdGVkIHdpdGggYSBGZWF0dXJlLiBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIGFyZSBsb2NhdGVkIGluIGRpcmVjdG9yaWVzIAotbmFtZWQgInBsdWdpbnMiIGFuZCBGZWF0dXJlcyBhcmUgbG9jYXRlZCBpbiBkaXJlY3RvcmllcyBuYW1lZCAiZmVhdHVyZXMiLjwvUD4KLTxQPkZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBGaWxlcyBuYW1lZCAKLSJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIEluY2x1ZGVkIAotRmVhdHVyZXMuPC9QPgotPFA+VGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZSBjb250YWluZWQgCi1pbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyAKLUZlYXR1cmVzIGFuZCBJbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICJsaWNlbnNlLmh0bWwiIAotKCJGZWF0dXJlIExpY2Vuc2VzIikuIEFib3V0cyBhbmQgRmVhdHVyZSBMaWNlbnNlcyBtYXkgYmUgbG9jYXRlZCBpbiBhbnkgCi1kaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGUgaW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyAKLWxvY2F0aW9uczo8L1A+Ci08VUw+Ci0gIDxMST5UaGUgdG9wLWxldmVsIChyb290KSBkaXJlY3RvcnkgCi0gIDxMST5QbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3RvcmllcyAKLSAgPExJPlN1YmRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgInNyYyIgb2YgY2VydGFpbiBQbHVnLWlucyAKLSAgPExJPkZlYXR1cmUgZGlyZWN0b3JpZXMgPC9MST48L1VMPgotPFA+Tm90ZTogaWYgYSBGZWF0dXJlIG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgaW5zdGFsbGVkIAotdXNpbmcgdGhlIEVjbGlwc2UgVXBkYXRlIE1hbmFnZXIsIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoIkZlYXR1cmUgVXBkYXRlIAotTGljZW5zZSIpIGR1cmluZyB0aGUgaW5zdGFsbGF0aW9uIHByb2Nlc3MuIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zIEluY2x1ZGVkIAotRmVhdHVyZXMsIHRoZSBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIHNob3VsZCBlaXRoZXIgcHJvdmlkZSB5b3Ugd2l0aCB0aGUgdGVybXMgCi1hbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgdGhlIEluY2x1ZGVkIEZlYXR1cmVzIG9yIGluZm9ybSB5b3Ugd2hlcmUgeW91IGNhbiAKLWxvY2F0ZSB0aGVtLiBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW4gdGhlICJsaWNlbnNlIiBwcm9wZXJ0eSBvZiAKLWZpbGVzIG5hbWVkICJmZWF0dXJlLnByb3BlcnRpZXMiLiBTdWNoIEFib3V0cywgRmVhdHVyZSBMaWNlbnNlcyBhbmQgRmVhdHVyZSAKLVVwZGF0ZSBMaWNlbnNlcyBjb250YWluIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyAob3IgcmVmZXJlbmNlcyB0byBzdWNoIHRlcm1zIAotYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXIgdXNlIG9mIHRoZSBhc3NvY2lhdGVkIENvbnRlbnQgaW4gdGhhdCAKLWRpcmVjdG9yeS48L1A+Ci08UD5USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVIgVE8gVEhFIEVQTCAKLU9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy4gU09NRSBPRiBUSEVTRSAKLU9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6PC9QPgotPFVMPgotICA8TEk+Q29tbW9uIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbDwvQT4pIAotCi0gIDxMST5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAxLjEgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFPC9BPikgCi0KLSAgPExJPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDIuMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMDwvQT4pIAotCi0gIDxMST5JQk0gUHVibGljIExpY2Vuc2UgMS4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sIj5odHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vZGV2ZWxvcGVyd29ya3Mvb3BlbnNvdXJjZS9saWNlbnNlMTAuaHRtbDwvQT4pIAotCi0gIDxMST5NZXRybyBMaW5rIFB1YmxpYyBMaWNlbnNlIDEuMDAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwiPmh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sPC9BPikgCi0KLSAgPExJPk1vemlsbGEgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjEgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sIj5odHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWw8L0E+KSAKLSAgPC9MST4KLSAgICAKLSAgPExJPkNvbW1vbiBEZXZlbG9wbWVudCBhbmQgRGlzdHJpYnV0aW9uIExpY2Vuc2UgKENEREwpIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuc3VuLmNvbS9jZGRsL2NkZGwuaHRtbCI+aHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sKTwvQT4KLSAgPC9MST4KLTwvVUw+Ci08UD5JVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCBDT05ESVRJT05TIFBSSU9SIAotVE8gVVNFIE9GIFRIRSBDT05URU5ULiBJZiBubyBBYm91dCwgRmVhdHVyZSBMaWNlbnNlIG9yIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2UgaXMgCi1wcm92aWRlZCwgcGxlYXNlIGNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgCi1jb25kaXRpb25zIGdvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC48L1A+Ci08SDM+Q3J5cHRvZ3JhcGh5PC9IMz4KLTxQPkNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZSAKLWN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSwgYW5kL29yIAotcmUtZXhwb3J0IHRvIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFIHVzaW5nIGFueSAKLWVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsIHJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyAKLWNvbmNlcm5pbmcgdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgb3IgdXNlLCBhbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIAotdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLjwvUD48L0JPRFk+PC9IVE1MPgpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLy5jdnNpZ25vcmUgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMvLmN2c2lnbm9yZQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjU0NDY5My4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMvLmN2c2lnbm9yZQorKysgL2Rldi9udWxsCkBAIC0xLDMgKzAsMCBAQAotKi5iaW4uZGlzdC56aXAKLWJ1aWxkLnhtbAotb3JnLmVjbGlwc2UuanB0LnRlc3RzXzEuMC4wLioKXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMvLnByb2plY3QgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMvLnByb2plY3QKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDNkMWRkZTYuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLy5wcm9qZWN0CisrKyAvZGV2L251bGwKQEAgLTEsMTcgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxwcm9qZWN0RGVzY3JpcHRpb24+Ci0JPG5hbWU+b3JnLmVjbGlwc2UuanB0LnRlc3RzPC9uYW1lPgotCTxjb21tZW50PjwvY29tbWVudD4KLQk8cHJvamVjdHM+Ci0JPC9wcm9qZWN0cz4KLQk8YnVpbGRTcGVjPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLkZlYXR1cmVCdWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQk8L2J1aWxkU3BlYz4KLQk8bmF0dXJlcz4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5wZGUuRmVhdHVyZU5hdHVyZTwvbmF0dXJlPgotCTwvbmF0dXJlcz4KLTwvcHJvamVjdERlc2NyaXB0aW9uPgpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcyBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDE3YWNiNjUuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcworKysgL2Rldi9udWxsCkBAIC0xLDMgKzAsMCBAQAotI1N1biBNYXkgMjcgMTU6MTE6MDUgRURUIDIwMDcKLWVjbGlwc2UucHJlZmVyZW5jZXMudmVyc2lvbj0xCi1lbmNvZGluZy88cHJvamVjdD49SVNPLTg4NTktMQpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzL2J1aWxkLnByb3BlcnRpZXMgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMvYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggN2Y0NzY5NC4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMvYnVpbGQucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDUgKzAsMCBAQAotYmluLmluY2x1ZGVzID0gZmVhdHVyZS54bWwsXAotICAgICAgICAgICAgICAgZWNsaXBzZV91cGRhdGVfMTIwLmpwZyxcCi0gICAgICAgICAgICAgICBlcGwtdjEwLmh0bWwsXAotICAgICAgICAgICAgICAgbGljZW5zZS5odG1sLFwKLSAgICAgICAgICAgICAgIGZlYXR1cmUucHJvcGVydGllcwpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzL2VjbGlwc2VfdXBkYXRlXzEyMC5qcGcgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMvZWNsaXBzZV91cGRhdGVfMTIwLmpwZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmZkZjcwOC4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMvZWNsaXBzZV91cGRhdGVfMTIwLmpwZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy9lcGwtdjEwLmh0bWwgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMvZXBsLXYxMC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlZDRiMTk2Li4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy9lcGwtdjEwLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSwzMjggKzAsMCBAQAotPGh0bWwgeG1sbnM6bz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6b2ZmaWNlIgoteG1sbnM6dz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6d29yZCIKLXhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy9UUi9SRUMtaHRtbDQwIj4KLQotPGhlYWQ+Ci08bWV0YSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9d2luZG93cy0xMjUyIj4KLTxtZXRhIG5hbWU9UHJvZ0lkIGNvbnRlbnQ9V29yZC5Eb2N1bWVudD4KLTxtZXRhIG5hbWU9R2VuZXJhdG9yIGNvbnRlbnQ9Ik1pY3Jvc29mdCBXb3JkIDkiPgotPG1ldGEgbmFtZT1PcmlnaW5hdG9yIGNvbnRlbnQ9Ik1pY3Jvc29mdCBXb3JkIDkiPgotPGxpbmsgcmVsPUZpbGUtTGlzdAotaHJlZj0iLi9FY2xpcHNlJTIwRVBMJTIwMjAwM18xMV8xMCUyMEZpbmFsX2ZpbGVzL2ZpbGVsaXN0LnhtbCI+Ci08dGl0bGU+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIFZlcnNpb24gMS4wPC90aXRsZT4KLTwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDxvOkRvY3VtZW50UHJvcGVydGllcz4KLSAgPG86UmV2aXNpb24+MjwvbzpSZXZpc2lvbj4KLSAgPG86VG90YWxUaW1lPjM8L286VG90YWxUaW1lPgotICA8bzpDcmVhdGVkPjIwMDQtMDMtMDVUMjM6MDM6MDBaPC9vOkNyZWF0ZWQ+Ci0gIDxvOkxhc3RTYXZlZD4yMDA0LTAzLTA1VDIzOjAzOjAwWjwvbzpMYXN0U2F2ZWQ+Ci0gIDxvOlBhZ2VzPjQ8L286UGFnZXM+Ci0gIDxvOldvcmRzPjE2MjY8L286V29yZHM+Ci0gIDxvOkNoYXJhY3RlcnM+OTI3MDwvbzpDaGFyYWN0ZXJzPgotICAgPG86TGluZXM+Nzc8L286TGluZXM+Ci0gIDxvOlBhcmFncmFwaHM+MTg8L286UGFyYWdyYXBocz4KLSAgPG86Q2hhcmFjdGVyc1dpdGhTcGFjZXM+MTEzODQ8L286Q2hhcmFjdGVyc1dpdGhTcGFjZXM+Ci0gIDxvOlZlcnNpb24+OS40NDAyPC9vOlZlcnNpb24+Ci0gPC9vOkRvY3VtZW50UHJvcGVydGllcz4KLTwveG1sPjwhW2VuZGlmXS0tPjwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDx3OldvcmREb2N1bWVudD4KLSAgPHc6VHJhY2tSZXZpc2lvbnMvPgotIDwvdzpXb3JkRG9jdW1lbnQ+Ci08L3htbD48IVtlbmRpZl0tLT4KLTxzdHlsZT4KLTwhLS0KLSAvKiBGb250IERlZmluaXRpb25zICovCi1AZm9udC1mYWNlCi0Je2ZvbnQtZmFtaWx5OlRhaG9tYTsKLQlwYW5vc2UtMToyIDExIDYgNCAzIDUgNCA0IDIgNDsKLQltc28tZm9udC1jaGFyc2V0OjA7Ci0JbXNvLWdlbmVyaWMtZm9udC1mYW1pbHk6c3dpc3M7Ci0JbXNvLWZvbnQtcGl0Y2g6dmFyaWFibGU7Ci0JbXNvLWZvbnQtc2lnbmF0dXJlOjU1MzY3OTQ5NSAtMjE0NzQ4MzY0OCA4IDAgNjYwNDcgMDt9Ci0gLyogU3R5bGUgRGVmaW5pdGlvbnMgKi8KLXAuTXNvTm9ybWFsLCBsaS5Nc29Ob3JtYWwsIGRpdi5Nc29Ob3JtYWwKLQl7bXNvLXN0eWxlLXBhcmVudDoiIjsKLQltYXJnaW46MGluOwotCW1hcmdpbi1ib3R0b206LjAwMDFwdDsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjEyLjBwdDsKLQlmb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1wCi0Je21hcmdpbi1yaWdodDowaW47Ci0JbXNvLW1hcmdpbi10b3AtYWx0OmF1dG87Ci0JbXNvLW1hcmdpbi1ib3R0b20tYWx0OmF1dG87Ci0JbWFyZ2luLWxlZnQ6MGluOwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXAuQmFsbG9vblRleHQsIGxpLkJhbGxvb25UZXh0LCBkaXYuQmFsbG9vblRleHQKLQl7bXNvLXN0eWxlLW5hbWU6IkJhbGxvb24gVGV4dCI7Ci0JbWFyZ2luOjBpbjsKLQltYXJnaW4tYm90dG9tOi4wMDAxcHQ7Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZTo4LjBwdDsKLQlmb250LWZhbWlseTpUYWhvbWE7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotQHBhZ2UgU2VjdGlvbjEKLQl7c2l6ZTo4LjVpbiAxMS4waW47Ci0JbWFyZ2luOjEuMGluIDEuMjVpbiAxLjBpbiAxLjI1aW47Ci0JbXNvLWhlYWRlci1tYXJnaW46LjVpbjsKLQltc28tZm9vdGVyLW1hcmdpbjouNWluOwotCW1zby1wYXBlci1zb3VyY2U6MDt9Ci1kaXYuU2VjdGlvbjEKLQl7cGFnZTpTZWN0aW9uMTt9Ci0tLT4KLTwvc3R5bGU+Ci08L2hlYWQ+Ci0KLTxib2R5IGxhbmc9RU4tVVMgc3R5bGU9J3RhYi1pbnRlcnZhbDouNWluJz4KLQotPGRpdiBjbGFzcz1TZWN0aW9uMT4KLQotPHAgYWxpZ249Y2VudGVyIHN0eWxlPSd0ZXh0LWFsaWduOmNlbnRlcic+PGI+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIHYgMS4wPC9iPgotPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+VEhFIEFDQ09NUEFOWUlORyBQUk9HUkFNIElTIFBST1ZJREVEIFVOREVSCi1USEUgVEVSTVMgT0YgVEhJUyBFQ0xJUFNFIFBVQkxJQyBMSUNFTlNFICgmcXVvdDtBR1JFRU1FTlQmcXVvdDspLiBBTlkgVVNFLAotUkVQUk9EVUNUSU9OIE9SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBDT05TVElUVVRFUyBSRUNJUElFTlQnUyBBQ0NFUFRBTkNFCi1PRiBUSElTIEFHUkVFTUVOVC48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjEuIERFRklOSVRJT05TPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7Q29udHJpYnV0aW9uJnF1b3Q7IG1lYW5zOjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaW4gdGhlIGNhc2Ugb2YgdGhlIGluaXRpYWwgQ29udHJpYnV0b3IsIHRoZSBpbml0aWFsIGNvZGUgYW5kIGRvY3VtZW50YXRpb24KLWRpc3RyaWJ1dGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBhbmQ8YnIgY2xlYXI9bGVmdD4KLWIpIGluIHRoZSBjYXNlIG9mIGVhY2ggc3Vic2VxdWVudCBDb250cmlidXRvcjo8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pKQotY2hhbmdlcyB0byB0aGUgUHJvZ3JhbSwgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWkpCi1hZGRpdGlvbnMgdG8gdGhlIFByb2dyYW07PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+d2hlcmUKLXN1Y2ggY2hhbmdlcyBhbmQvb3IgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIG9yaWdpbmF0ZSBmcm9tIGFuZCBhcmUgZGlzdHJpYnV0ZWQKLWJ5IHRoYXQgcGFydGljdWxhciBDb250cmlidXRvci4gQSBDb250cmlidXRpb24gJ29yaWdpbmF0ZXMnIGZyb20gYSBDb250cmlidXRvcgotaWYgaXQgd2FzIGFkZGVkIHRvIHRoZSBQcm9ncmFtIGJ5IHN1Y2ggQ29udHJpYnV0b3IgaXRzZWxmIG9yIGFueW9uZSBhY3Rpbmcgb24KLXN1Y2ggQ29udHJpYnV0b3IncyBiZWhhbGYuIENvbnRyaWJ1dGlvbnMgZG8gbm90IGluY2x1ZGUgYWRkaXRpb25zIHRvIHRoZQotUHJvZ3JhbSB3aGljaDogKGkpIGFyZSBzZXBhcmF0ZSBtb2R1bGVzIG9mIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIGluIGNvbmp1bmN0aW9uCi13aXRoIHRoZSBQcm9ncmFtIHVuZGVyIHRoZWlyIG93biBsaWNlbnNlIGFncmVlbWVudCwgYW5kIChpaSkgYXJlIG5vdCBkZXJpdmF0aXZlCi13b3JrcyBvZiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0NvbnRyaWJ1dG9yJnF1b3Q7IG1lYW5zIGFueSBwZXJzb24gb3IKLWVudGl0eSB0aGF0IGRpc3RyaWJ1dGVzIHRoZSBQcm9ncmFtLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7TGljZW5zZWQgUGF0ZW50cyAmcXVvdDsgbWVhbiBwYXRlbnQKLWNsYWltcyBsaWNlbnNhYmxlIGJ5IGEgQ29udHJpYnV0b3Igd2hpY2ggYXJlIG5lY2Vzc2FyaWx5IGluZnJpbmdlZCBieSB0aGUgdXNlCi1vciBzYWxlIG9mIGl0cyBDb250cmlidXRpb24gYWxvbmUgb3Igd2hlbiBjb21iaW5lZCB3aXRoIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7UHJvZ3JhbSZxdW90OyBtZWFucyB0aGUgQ29udHJpYnV0aW9ucwotZGlzdHJpYnV0ZWQgaW4gYWNjb3JkYW5jZSB3aXRoIHRoaXMgQWdyZWVtZW50Ljwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7UmVjaXBpZW50JnF1b3Q7IG1lYW5zIGFueW9uZSB3aG8KLXJlY2VpdmVzIHRoZSBQcm9ncmFtIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBpbmNsdWRpbmcgYWxsIENvbnRyaWJ1dG9ycy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjIuIEdSQU5UIE9GIFJJR0hUUzwvc3Bhbj48L2I+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLVN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50Ci1hIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwgcm95YWx0eS1mcmVlIGNvcHlyaWdodCBsaWNlbnNlIHRvPHNwYW4KLXN0eWxlPSdjb2xvcjpyZWQnPiA8L3NwYW4+cmVwcm9kdWNlLCBwcmVwYXJlIGRlcml2YXRpdmUgd29ya3Mgb2YsIHB1YmxpY2x5Ci1kaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBkaXN0cmlidXRlIGFuZCBzdWJsaWNlbnNlIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaAotQ29udHJpYnV0b3IsIGlmIGFueSwgYW5kIHN1Y2ggZGVyaXZhdGl2ZSB3b3JrcywgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlCi1mb3JtLjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpCi1TdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzCi1SZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsPHNwYW4gc3R5bGU9J2NvbG9yOmdyZWVuJz4gPC9zcGFuPnJveWFsdHktZnJlZQotcGF0ZW50IGxpY2Vuc2UgdW5kZXIgTGljZW5zZWQgUGF0ZW50cyB0byBtYWtlLCB1c2UsIHNlbGwsIG9mZmVyIHRvIHNlbGwsIGltcG9ydAotYW5kIG90aGVyd2lzZSB0cmFuc2ZlciB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgaW4gc291cmNlCi1jb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLiBUaGlzIHBhdGVudCBsaWNlbnNlIHNoYWxsIGFwcGx5IHRvIHRoZSBjb21iaW5hdGlvbgotb2YgdGhlIENvbnRyaWJ1dGlvbiBhbmQgdGhlIFByb2dyYW0gaWYsIGF0IHRoZSB0aW1lIHRoZSBDb250cmlidXRpb24gaXMgYWRkZWQKLWJ5IHRoZSBDb250cmlidXRvciwgc3VjaCBhZGRpdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGNhdXNlcyBzdWNoIGNvbWJpbmF0aW9uCi10byBiZSBjb3ZlcmVkIGJ5IHRoZSBMaWNlbnNlZCBQYXRlbnRzLiBUaGUgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgbm90IGFwcGx5IHRvCi1hbnkgb3RoZXIgY29tYmluYXRpb25zIHdoaWNoIGluY2x1ZGUgdGhlIENvbnRyaWJ1dGlvbi4gTm8gaGFyZHdhcmUgcGVyIHNlIGlzCi1saWNlbnNlZCBoZXJldW5kZXIuIDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmMpCi1SZWNpcGllbnQgdW5kZXJzdGFuZHMgdGhhdCBhbHRob3VnaCBlYWNoIENvbnRyaWJ1dG9yIGdyYW50cyB0aGUgbGljZW5zZXMgdG8gaXRzCi1Db250cmlidXRpb25zIHNldCBmb3J0aCBoZXJlaW4sIG5vIGFzc3VyYW5jZXMgYXJlIHByb3ZpZGVkIGJ5IGFueSBDb250cmlidXRvcgotdGhhdCB0aGUgUHJvZ3JhbSBkb2VzIG5vdCBpbmZyaW5nZSB0aGUgcGF0ZW50IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQotcmlnaHRzIG9mIGFueSBvdGhlciBlbnRpdHkuIEVhY2ggQ29udHJpYnV0b3IgZGlzY2xhaW1zIGFueSBsaWFiaWxpdHkgdG8gUmVjaXBpZW50Ci1mb3IgY2xhaW1zIGJyb3VnaHQgYnkgYW55IG90aGVyIGVudGl0eSBiYXNlZCBvbiBpbmZyaW5nZW1lbnQgb2YgaW50ZWxsZWN0dWFsCi1wcm9wZXJ0eSByaWdodHMgb3Igb3RoZXJ3aXNlLiBBcyBhIGNvbmRpdGlvbiB0byBleGVyY2lzaW5nIHRoZSByaWdodHMgYW5kCi1saWNlbnNlcyBncmFudGVkIGhlcmV1bmRlciwgZWFjaCBSZWNpcGllbnQgaGVyZWJ5IGFzc3VtZXMgc29sZSByZXNwb25zaWJpbGl0eQotdG8gc2VjdXJlIGFueSBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG5lZWRlZCwgaWYgYW55LiBGb3IgZXhhbXBsZSwKLWlmIGEgdGhpcmQgcGFydHkgcGF0ZW50IGxpY2Vuc2UgaXMgcmVxdWlyZWQgdG8gYWxsb3cgUmVjaXBpZW50IHRvIGRpc3RyaWJ1dGUKLXRoZSBQcm9ncmFtLCBpdCBpcyBSZWNpcGllbnQncyByZXNwb25zaWJpbGl0eSB0byBhY3F1aXJlIHRoYXQgbGljZW5zZSBiZWZvcmUKLWRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbS48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5kKQotRWFjaCBDb250cmlidXRvciByZXByZXNlbnRzIHRoYXQgdG8gaXRzIGtub3dsZWRnZSBpdCBoYXMgc3VmZmljaWVudCBjb3B5cmlnaHQKLXJpZ2h0cyBpbiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIHRvIGdyYW50IHRoZSBjb3B5cmlnaHQgbGljZW5zZSBzZXQgZm9ydGggaW4KLXRoaXMgQWdyZWVtZW50LiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+My4gUkVRVUlSRU1FTlRTPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+QSBDb250cmlidXRvciBtYXkgY2hvb3NlIHRvIGRpc3RyaWJ1dGUgdGhlCi1Qcm9ncmFtIGluIG9iamVjdCBjb2RlIGZvcm0gdW5kZXIgaXRzIG93biBsaWNlbnNlIGFncmVlbWVudCwgcHJvdmlkZWQgdGhhdDo8L3NwYW4+Ci08L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pdCBjb21wbGllcyB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudDsgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikKLWl0cyBsaWNlbnNlIGFncmVlbWVudDo8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pKQotZWZmZWN0aXZlbHkgZGlzY2xhaW1zIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCB3YXJyYW50aWVzIGFuZAotY29uZGl0aW9ucywgZXhwcmVzcyBhbmQgaW1wbGllZCwgaW5jbHVkaW5nIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiB0aXRsZQotYW5kIG5vbi1pbmZyaW5nZW1lbnQsIGFuZCBpbXBsaWVkIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiBtZXJjaGFudGFiaWxpdHkKLWFuZCBmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZTsgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWkpCi1lZmZlY3RpdmVseSBleGNsdWRlcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgbGlhYmlsaXR5IGZvciBkYW1hZ2VzLAotaW5jbHVkaW5nIGRpcmVjdCwgaW5kaXJlY3QsIHNwZWNpYWwsIGluY2lkZW50YWwgYW5kIGNvbnNlcXVlbnRpYWwgZGFtYWdlcywgc3VjaAotYXMgbG9zdCBwcm9maXRzOyA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paWkpCi1zdGF0ZXMgdGhhdCBhbnkgcHJvdmlzaW9ucyB3aGljaCBkaWZmZXIgZnJvbSB0aGlzIEFncmVlbWVudCBhcmUgb2ZmZXJlZCBieSB0aGF0Ci1Db250cmlidXRvciBhbG9uZSBhbmQgbm90IGJ5IGFueSBvdGhlciBwYXJ0eTsgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aXYpCi1zdGF0ZXMgdGhhdCBzb3VyY2UgY29kZSBmb3IgdGhlIFByb2dyYW0gaXMgYXZhaWxhYmxlIGZyb20gc3VjaCBDb250cmlidXRvciwgYW5kCi1pbmZvcm1zIGxpY2Vuc2VlcyBob3cgdG8gb2J0YWluIGl0IGluIGEgcmVhc29uYWJsZSBtYW5uZXIgb24gb3IgdGhyb3VnaCBhCi1tZWRpdW0gY3VzdG9tYXJpbHkgdXNlZCBmb3Igc29mdHdhcmUgZXhjaGFuZ2UuPHNwYW4gc3R5bGU9J2NvbG9yOmJsdWUnPiA8L3NwYW4+PC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPldoZW4gdGhlIFByb2dyYW0gaXMgbWFkZSBhdmFpbGFibGUgaW4gc291cmNlCi1jb2RlIGZvcm06PC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pdCBtdXN0IGJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoaXMgQWdyZWVtZW50OyBhbmQgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikgYQotY29weSBvZiB0aGlzIEFncmVlbWVudCBtdXN0IGJlIGluY2x1ZGVkIHdpdGggZWFjaCBjb3B5IG9mIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Q29udHJpYnV0b3JzIG1heSBub3QgcmVtb3ZlIG9yIGFsdGVyIGFueQotY29weXJpZ2h0IG5vdGljZXMgY29udGFpbmVkIHdpdGhpbiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVhY2ggQ29udHJpYnV0b3IgbXVzdCBpZGVudGlmeSBpdHNlbGYgYXMgdGhlCi1vcmlnaW5hdG9yIG9mIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgaW4gYSBtYW5uZXIgdGhhdCByZWFzb25hYmx5IGFsbG93cwotc3Vic2VxdWVudCBSZWNpcGllbnRzIHRvIGlkZW50aWZ5IHRoZSBvcmlnaW5hdG9yIG9mIHRoZSBDb250cmlidXRpb24uIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz40LiBDT01NRVJDSUFMIERJU1RSSUJVVElPTjwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkNvbW1lcmNpYWwgZGlzdHJpYnV0b3JzIG9mIHNvZnR3YXJlIG1heQotYWNjZXB0IGNlcnRhaW4gcmVzcG9uc2liaWxpdGllcyB3aXRoIHJlc3BlY3QgdG8gZW5kIHVzZXJzLCBidXNpbmVzcyBwYXJ0bmVycwotYW5kIHRoZSBsaWtlLiBXaGlsZSB0aGlzIGxpY2Vuc2UgaXMgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY29tbWVyY2lhbCB1c2UKLW9mIHRoZSBQcm9ncmFtLCB0aGUgQ29udHJpYnV0b3Igd2hvIGluY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbAotcHJvZHVjdCBvZmZlcmluZyBzaG91bGQgZG8gc28gaW4gYSBtYW5uZXIgd2hpY2ggZG9lcyBub3QgY3JlYXRlIHBvdGVudGlhbAotbGlhYmlsaXR5IGZvciBvdGhlciBDb250cmlidXRvcnMuIFRoZXJlZm9yZSwgaWYgYSBDb250cmlidXRvciBpbmNsdWRlcyB0aGUKLVByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIHN1Y2ggQ29udHJpYnV0b3IgKCZxdW90O0NvbW1lcmNpYWwKLUNvbnRyaWJ1dG9yJnF1b3Q7KSBoZXJlYnkgYWdyZWVzIHRvIGRlZmVuZCBhbmQgaW5kZW1uaWZ5IGV2ZXJ5IG90aGVyCi1Db250cmlidXRvciAoJnF1b3Q7SW5kZW1uaWZpZWQgQ29udHJpYnV0b3ImcXVvdDspIGFnYWluc3QgYW55IGxvc3NlcywgZGFtYWdlcyBhbmQKLWNvc3RzIChjb2xsZWN0aXZlbHkgJnF1b3Q7TG9zc2VzJnF1b3Q7KSBhcmlzaW5nIGZyb20gY2xhaW1zLCBsYXdzdWl0cyBhbmQgb3RoZXIKLWxlZ2FsIGFjdGlvbnMgYnJvdWdodCBieSBhIHRoaXJkIHBhcnR5IGFnYWluc3QgdGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIHRvCi10aGUgZXh0ZW50IGNhdXNlZCBieSB0aGUgYWN0cyBvciBvbWlzc2lvbnMgb2Ygc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluCi1jb25uZWN0aW9uIHdpdGggaXRzIGRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdAotb2ZmZXJpbmcuIFRoZSBvYmxpZ2F0aW9ucyBpbiB0aGlzIHNlY3Rpb24gZG8gbm90IGFwcGx5IHRvIGFueSBjbGFpbXMgb3IgTG9zc2VzCi1yZWxhdGluZyB0byBhbnkgYWN0dWFsIG9yIGFsbGVnZWQgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGluZnJpbmdlbWVudC4gSW4gb3JkZXIKLXRvIHF1YWxpZnksIGFuIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG11c3Q6IGEpIHByb21wdGx5IG5vdGlmeSB0aGUgQ29tbWVyY2lhbAotQ29udHJpYnV0b3IgaW4gd3JpdGluZyBvZiBzdWNoIGNsYWltLCBhbmQgYikgYWxsb3cgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IKLXRvIGNvbnRyb2wsIGFuZCBjb29wZXJhdGUgd2l0aCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiwgdGhlIGRlZmVuc2UgYW5kCi1hbnkgcmVsYXRlZCBzZXR0bGVtZW50IG5lZ290aWF0aW9ucy4gVGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG1heSBwYXJ0aWNpcGF0ZQotaW4gYW55IHN1Y2ggY2xhaW0gYXQgaXRzIG93biBleHBlbnNlLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Rm9yIGV4YW1wbGUsIGEgQ29udHJpYnV0b3IgbWlnaHQgaW5jbHVkZSB0aGUKLVByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIFByb2R1Y3QgWC4gVGhhdCBDb250cmlidXRvciBpcyB0aGVuIGEKLUNvbW1lcmNpYWwgQ29udHJpYnV0b3IuIElmIHRoYXQgQ29tbWVyY2lhbCBDb250cmlidXRvciB0aGVuIG1ha2VzIHBlcmZvcm1hbmNlCi1jbGFpbXMsIG9yIG9mZmVycyB3YXJyYW50aWVzIHJlbGF0ZWQgdG8gUHJvZHVjdCBYLCB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kCi13YXJyYW50aWVzIGFyZSBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IncyByZXNwb25zaWJpbGl0eSBhbG9uZS4gVW5kZXIgdGhpcwotc2VjdGlvbiwgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3Igd291bGQgaGF2ZSB0byBkZWZlbmQgY2xhaW1zIGFnYWluc3QgdGhlCi1vdGhlciBDb250cmlidXRvcnMgcmVsYXRlZCB0byB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMsIGFuZCBpZiBhCi1jb3VydCByZXF1aXJlcyBhbnkgb3RoZXIgQ29udHJpYnV0b3IgdG8gcGF5IGFueSBkYW1hZ2VzIGFzIGEgcmVzdWx0LCB0aGUKLUNvbW1lcmNpYWwgQ29udHJpYnV0b3IgbXVzdCBwYXkgdGhvc2UgZGFtYWdlcy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjUuIE5PIFdBUlJBTlRZPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUwotQUdSRUVNRU5ULCBUSEUgUFJPR1JBTSBJUyBQUk9WSURFRCBPTiBBTiAmcXVvdDtBUyBJUyZxdW90OyBCQVNJUywgV0lUSE9VVAotV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBFSVRIRVIgRVhQUkVTUyBPUiBJTVBMSUVEIElOQ0xVRElORywKLVdJVEhPVVQgTElNSVRBVElPTiwgQU5ZIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBUSVRMRSwgTk9OLUlORlJJTkdFTUVOVCwKLU1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gRWFjaCBSZWNpcGllbnQgaXMgc29sZWx5Ci1yZXNwb25zaWJsZSBmb3IgZGV0ZXJtaW5pbmcgdGhlIGFwcHJvcHJpYXRlbmVzcyBvZiB1c2luZyBhbmQgZGlzdHJpYnV0aW5nIHRoZQotUHJvZ3JhbSBhbmQgYXNzdW1lcyBhbGwgcmlza3MgYXNzb2NpYXRlZCB3aXRoIGl0cyBleGVyY2lzZSBvZiByaWdodHMgdW5kZXIgdGhpcwotQWdyZWVtZW50ICwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgcmlza3MgYW5kIGNvc3RzIG9mIHByb2dyYW0gZXJyb3JzLAotY29tcGxpYW5jZSB3aXRoIGFwcGxpY2FibGUgbGF3cywgZGFtYWdlIHRvIG9yIGxvc3Mgb2YgZGF0YSwgcHJvZ3JhbXMgb3IKLWVxdWlwbWVudCwgYW5kIHVuYXZhaWxhYmlsaXR5IG9yIGludGVycnVwdGlvbiBvZiBvcGVyYXRpb25zLiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Ni4gRElTQ0xBSU1FUiBPRiBMSUFCSUxJVFk8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTCi1BR1JFRU1FTlQsIE5FSVRIRVIgUkVDSVBJRU5UIE5PUiBBTlkgQ09OVFJJQlVUT1JTIFNIQUxMIEhBVkUgQU5ZIExJQUJJTElUWSBGT1IKLUFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwotKElOQ0xVRElORyBXSVRIT1VUIExJTUlUQVRJT04gTE9TVCBQUk9GSVRTKSwgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKLU9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HCi1ORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9SIERJU1RSSUJVVElPTiBPRgotVEhFIFBST0dSQU0gT1IgVEhFIEVYRVJDSVNFIE9GIEFOWSBSSUdIVFMgR1JBTlRFRCBIRVJFVU5ERVIsIEVWRU4gSUYgQURWSVNFRCBPRgotVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFUy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjcuIEdFTkVSQUw8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5JZiBhbnkgcHJvdmlzaW9uIG9mIHRoaXMgQWdyZWVtZW50IGlzIGludmFsaWQKLW9yIHVuZW5mb3JjZWFibGUgdW5kZXIgYXBwbGljYWJsZSBsYXcsIGl0IHNoYWxsIG5vdCBhZmZlY3QgdGhlIHZhbGlkaXR5IG9yCi1lbmZvcmNlYWJpbGl0eSBvZiB0aGUgcmVtYWluZGVyIG9mIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgYW5kIHdpdGhvdXQKLWZ1cnRoZXIgYWN0aW9uIGJ5IHRoZSBwYXJ0aWVzIGhlcmV0bywgc3VjaCBwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlCi1taW5pbXVtIGV4dGVudCBuZWNlc3NhcnkgdG8gbWFrZSBzdWNoIHByb3Zpc2lvbiB2YWxpZCBhbmQgZW5mb3JjZWFibGUuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5JZiBSZWNpcGllbnQgaW5zdGl0dXRlcyBwYXRlbnQgbGl0aWdhdGlvbgotYWdhaW5zdCBhbnkgZW50aXR5IChpbmNsdWRpbmcgYSBjcm9zcy1jbGFpbSBvciBjb3VudGVyY2xhaW0gaW4gYSBsYXdzdWl0KQotYWxsZWdpbmcgdGhhdCB0aGUgUHJvZ3JhbSBpdHNlbGYgKGV4Y2x1ZGluZyBjb21iaW5hdGlvbnMgb2YgdGhlIFByb2dyYW0gd2l0aAotb3RoZXIgc29mdHdhcmUgb3IgaGFyZHdhcmUpIGluZnJpbmdlcyBzdWNoIFJlY2lwaWVudCdzIHBhdGVudChzKSwgdGhlbiBzdWNoCi1SZWNpcGllbnQncyByaWdodHMgZ3JhbnRlZCB1bmRlciBTZWN0aW9uIDIoYikgc2hhbGwgdGVybWluYXRlIGFzIG9mIHRoZSBkYXRlCi1zdWNoIGxpdGlnYXRpb24gaXMgZmlsZWQuIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5BbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50Ci1zaGFsbCB0ZXJtaW5hdGUgaWYgaXQgZmFpbHMgdG8gY29tcGx5IHdpdGggYW55IG9mIHRoZSBtYXRlcmlhbCB0ZXJtcyBvcgotY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudCBhbmQgZG9lcyBub3QgY3VyZSBzdWNoIGZhaWx1cmUgaW4gYSByZWFzb25hYmxlCi1wZXJpb2Qgb2YgdGltZSBhZnRlciBiZWNvbWluZyBhd2FyZSBvZiBzdWNoIG5vbmNvbXBsaWFuY2UuIElmIGFsbCBSZWNpcGllbnQncwotcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHRlcm1pbmF0ZSwgUmVjaXBpZW50IGFncmVlcyB0byBjZWFzZSB1c2UgYW5kCi1kaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gYXMgc29vbiBhcyByZWFzb25hYmx5IHByYWN0aWNhYmxlLiBIb3dldmVyLAotUmVjaXBpZW50J3Mgb2JsaWdhdGlvbnMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYW5kIGFueSBsaWNlbnNlcyBncmFudGVkIGJ5Ci1SZWNpcGllbnQgcmVsYXRpbmcgdG8gdGhlIFByb2dyYW0gc2hhbGwgY29udGludWUgYW5kIHN1cnZpdmUuIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FdmVyeW9uZSBpcyBwZXJtaXR0ZWQgdG8gY29weSBhbmQgZGlzdHJpYnV0ZQotY29waWVzIG9mIHRoaXMgQWdyZWVtZW50LCBidXQgaW4gb3JkZXIgdG8gYXZvaWQgaW5jb25zaXN0ZW5jeSB0aGUgQWdyZWVtZW50IGlzCi1jb3B5cmlnaHRlZCBhbmQgbWF5IG9ubHkgYmUgbW9kaWZpZWQgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXIuIFRoZSBBZ3JlZW1lbnQKLVN0ZXdhcmQgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHB1Ymxpc2ggbmV3IHZlcnNpb25zIChpbmNsdWRpbmcgcmV2aXNpb25zKSBvZgotdGhpcyBBZ3JlZW1lbnQgZnJvbSB0aW1lIHRvIHRpbWUuIE5vIG9uZSBvdGhlciB0aGFuIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCBoYXMKLXRoZSByaWdodCB0byBtb2RpZnkgdGhpcyBBZ3JlZW1lbnQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgdGhlIGluaXRpYWwKLUFncmVlbWVudCBTdGV3YXJkLiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1heSBhc3NpZ24gdGhlIHJlc3BvbnNpYmlsaXR5IHRvCi1zZXJ2ZSBhcyB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgdG8gYSBzdWl0YWJsZSBzZXBhcmF0ZSBlbnRpdHkuIEVhY2ggbmV3IHZlcnNpb24KLW9mIHRoZSBBZ3JlZW1lbnQgd2lsbCBiZSBnaXZlbiBhIGRpc3Rpbmd1aXNoaW5nIHZlcnNpb24gbnVtYmVyLiBUaGUgUHJvZ3JhbQotKGluY2x1ZGluZyBDb250cmlidXRpb25zKSBtYXkgYWx3YXlzIGJlIGRpc3RyaWJ1dGVkIHN1YmplY3QgdG8gdGhlIHZlcnNpb24gb2YKLXRoZSBBZ3JlZW1lbnQgdW5kZXIgd2hpY2ggaXQgd2FzIHJlY2VpdmVkLiBJbiBhZGRpdGlvbiwgYWZ0ZXIgYSBuZXcgdmVyc2lvbiBvZgotdGhlIEFncmVlbWVudCBpcyBwdWJsaXNoZWQsIENvbnRyaWJ1dG9yIG1heSBlbGVjdCB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtCi0oaW5jbHVkaW5nIGl0cyBDb250cmlidXRpb25zKSB1bmRlciB0aGUgbmV3IHZlcnNpb24uIEV4Y2VwdCBhcyBleHByZXNzbHkgc3RhdGVkCi1pbiBTZWN0aW9ucyAyKGEpIGFuZCAyKGIpIGFib3ZlLCBSZWNpcGllbnQgcmVjZWl2ZXMgbm8gcmlnaHRzIG9yIGxpY2Vuc2VzIHRvCi10aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IG9mIGFueSBDb250cmlidXRvciB1bmRlciB0aGlzIEFncmVlbWVudCwgd2hldGhlcgotZXhwcmVzc2x5LCBieSBpbXBsaWNhdGlvbiwgZXN0b3BwZWwgb3Igb3RoZXJ3aXNlLiBBbGwgcmlnaHRzIGluIHRoZSBQcm9ncmFtIG5vdAotZXhwcmVzc2x5IGdyYW50ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYXJlIHJlc2VydmVkLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+VGhpcyBBZ3JlZW1lbnQgaXMgZ292ZXJuZWQgYnkgdGhlIGxhd3Mgb2YgdGhlCi1TdGF0ZSBvZiBOZXcgWW9yayBhbmQgdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBsYXdzIG9mIHRoZSBVbml0ZWQgU3RhdGVzIG9mCi1BbWVyaWNhLiBObyBwYXJ0eSB0byB0aGlzIEFncmVlbWVudCB3aWxsIGJyaW5nIGEgbGVnYWwgYWN0aW9uIHVuZGVyIHRoaXMKLUFncmVlbWVudCBtb3JlIHRoYW4gb25lIHllYXIgYWZ0ZXIgdGhlIGNhdXNlIG9mIGFjdGlvbiBhcm9zZS4gRWFjaCBwYXJ0eSB3YWl2ZXMKLWl0cyByaWdodHMgdG8gYSBqdXJ5IHRyaWFsIGluIGFueSByZXN1bHRpbmcgbGl0aWdhdGlvbi48L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjwhW2lmICFzdXBwb3J0RW1wdHlQYXJhc10+Jm5ic3A7PCFbZW5kaWZdPjxvOnA+PC9vOnA+PC9wPgotCi08L2Rpdj4KLQotPC9ib2R5PgotCi08L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzL2ZlYXR1cmUucHJvcGVydGllcyBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy9mZWF0dXJlLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDZiNThmZTYuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzL2ZlYXR1cmUucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDE0NSArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIGZlYXR1cmUucHJvcGVydGllcwotIyBjb250YWlucyBleHRlcm5hbGl6ZWQgc3RyaW5ncyBmb3IgZmVhdHVyZS54bWwKLSMgIiVmb28iIGluIGZlYXR1cmUueG1sIGNvcnJlc3BvbmRzIHRvIHRoZSBrZXkgImZvbyIgaW4gdGhpcyBmaWxlCi0jIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCi0jIFRoaXMgZmlsZSBzaG91bGQgYmUgdHJhbnNsYXRlZC4KLQotIyAiZmVhdHVyZU5hbWUiIHByb3BlcnR5IC0gbmFtZSBvZiB0aGUgZmVhdHVyZQotZmVhdHVyZU5hbWU9RGFsaSBKYXZhIFBlcnNpc3RlbmNlIEFQSSAoSlBBKSBwcm9qZWN0IFRlc3RzCi0KLSMgInByb3ZpZGVyTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBjb21wYW55IHRoYXQgcHJvdmlkZXMgdGhlIGZlYXR1cmUKLXByb3ZpZGVyTmFtZT1FY2xpcHNlLm9yZwotCi0jICJ1cGRhdGVTaXRlTmFtZSIgcHJvcGVydHkgLSBsYWJlbCBmb3IgdGhlIHVwZGF0ZSBzaXRlCi11cGRhdGVTaXRlTmFtZT1UaGUgRWNsaXBzZSBXZWIgVG9vbHMgUGxhdGZvcm0gKFdUUCkgUHJvamVjdCB1cGRhdGUgc2l0ZQotCi0jICJkZXNjcmlwdGlvbiIgcHJvcGVydHkgLSBkZXNjcmlwdGlvbiBvZiB0aGUgZmVhdHVyZQotZGVzY3JpcHRpb249RGFsaSBKYXZhIFBlcnNpc3RlbmNlIEFQSSAoSlBBKSBwcm9qZWN0IFRlc3RzCi0KLSMgImNvcHlyaWdodCIgcHJvcGVydHkgLSB0ZXh0IG9mIHRoZSAiRmVhdHVyZSBVcGRhdGUgQ29weXJpZ2h0IgotY29weXJpZ2h0PVwKLUNvcHlyaWdodCAoYykgMjAwNiBPcmFjbGUgQ29ycG9yYXRpb24uXG5cCi1BbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzXG5cCi1hcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjBcblwKLXdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0XG5cCi1odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbFxuXAotXG5cCi1Db250cmlidXRvcnM6XG5cCi0gICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uXG4KLSMjIyMjIyMjIyMjIyMjIyMgZW5kIG9mIGNvcHlyaWdodCBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotIyAibGljZW5zZVVSTCIgcHJvcGVydHkgLSBVUkwgb2YgdGhlICJGZWF0dXJlIExpY2Vuc2UiCi0jIGRvIG5vdCB0cmFuc2xhdGUgdmFsdWUgLSBqdXN0IGNoYW5nZSB0byBwb2ludCB0byBhIGxvY2FsZS1zcGVjaWZpYyBIVE1MIHBhZ2UKLWxpY2Vuc2VVUkw9bGljZW5zZS5odG1sCi0KLSMgImxpY2Vuc2UiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIExpY2Vuc2UiCi0jIHNob3VsZCBiZSBwbGFpbiB0ZXh0IHZlcnNpb24gb2YgbGljZW5zZSBhZ3JlZW1lbnQgcG9pbnRlZCB0byBiZSAibGljZW5zZVVSTCIKLWxpY2Vuc2U9XAotRUNMSVBTRSBGT1VOREFUSU9OIFNPRlRXQVJFIFVTRVIgQUdSRUVNRU5UXG5cCi1KdW5lIDA2LCAyMDA3XG5cCi1cblwKLVVzYWdlIE9mIENvbnRlbnRcblwKLVxuXAotVEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUlxuXAotT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUyAoQ09MTEVDVElWRUxZICJDT05URU5UIikuXG5cCi1VU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVNcblwKLUFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUlxuXAotTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVVxuXAotQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVFxuXAotQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFNcblwKLU9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFXG5cCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TXG5cCi1PRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRFxuXAotQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULlxuXAotXG5cCi1BcHBsaWNhYmxlIExpY2Vuc2VzXG5cCi1cblwKLVVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uXG5cCi1pcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpY1xuXAotTGljZW5zZSBWZXJzaW9uIDEuMCAoIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXNcblwKLUNvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLlxuXAotRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuXG5cCi1cblwKLUNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLFxuXAotZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZS5vcmcgQ1ZTXG5cCi1yZXBvc2l0b3J5ICgiUmVwb3NpdG9yeSIpIGluIENWUyBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIGF2YWlsYWJsZVxuXAotYXMgZG93bmxvYWRhYmxlIGFyY2hpdmVzICgiRG93bmxvYWRzIikuXG5cCi1cblwKLSAgIC0gQ29udGVudCBtYXkgYmUgc3RydWN0dXJlZCBhbmQgcGFja2FnZWQgaW50byBtb2R1bGVzIHRvIGZhY2lsaXRhdGUgZGVsaXZlcmluZyxcblwKLSAgICAgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiBUeXBpY2FsIG1vZHVsZXMgbWF5IGluY2x1ZGUgcGx1Zy1pbnMgKCJQbHVnLWlucyIpLFxuXAotICAgICBwbHVnLWluIGZyYWdtZW50cyAoIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLlxuXAotICAgLSBFYWNoIFBsdWctaW4gb3IgRnJhZ21lbnQgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBvciBKQVIgKEphdmE/IEFSY2hpdmUpXG5cCi0gICAgIGluIGEgZGlyZWN0b3J5IG5hbWVkICJwbHVnaW5zIi5cblwKLSAgIC0gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuXG5cCi0gICAgIEVhY2ggRmVhdHVyZSBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IGluIGEgZGlyZWN0b3J5IG5hbWVkICJmZWF0dXJlcyIuXG5cCi0gICAgIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvblxuXAotICAgICBudW1iZXJzIG9mIHRoZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuXG5cCi0gICAtIEZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlc1xuXAotICAgICBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy5cblwKLVxuXAotRmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIEZpbGVzIG5hbWVkXG5cCi0iZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZlxuXAotSW5jbHVkZWQgRmVhdHVyZXMuXG5cCi1cblwKLVRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmVcblwKLWNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZFxuXAotY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kIEluY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWRcblwKLWluIGZpbGVzIG5hbWVkICJsaWNlbnNlLmh0bWwiICgiRmVhdHVyZSBMaWNlbnNlcyIpLiBBYm91dHMgYW5kIEZlYXR1cmVcblwKLUxpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSBkaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGVcblwKLWluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOlxuXAotXG5cCi0gICAtIFRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeVxuXAotICAgLSBQbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3Rvcmllc1xuXAotICAgLSBJbnNpZGUgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBwYWNrYWdlZCBhcyBKQVJzXG5cCi0gICAtIFN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnNcblwKLSAgIC0gRmVhdHVyZSBkaXJlY3Rvcmllc1xuXAotXG5cCi1Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlXG5cCi1FY2xpcHNlIFVwZGF0ZSBNYW5hZ2VyLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFVwZGF0ZVxuXAotTGljZW5zZSIpIGR1cmluZyB0aGUgaW5zdGFsbGF0aW9uIHByb2Nlc3MuIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zXG5cCi1JbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdVxuXAotd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvciBpbmZvcm1cblwKLXlvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW5cblwKLXRoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIuIFN1Y2ggQWJvdXRzLFxuXAotRmVhdHVyZSBMaWNlbnNlcyBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kXG5cCi1jb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXJcblwKLXVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluIHRoYXQgZGlyZWN0b3J5LlxuXAotXG5cCi1USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVJcblwKLVRPIFRIRSBFUEwgT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLlxuXAotU09NRSBPRiBUSEVTRSBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOlxuXAotXG5cCi0gICAgLSBDb21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbClcblwKLSAgICAtIEFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFKVxuXAotICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wKVxuXAotICAgIC0gSUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sKVxuXAotICAgIC0gTWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwpXG5cCi0gICAgLSBNb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sKVxuXAotICAgIC0gQ29tbW9uIERldmVsb3BtZW50IGFuZCBEaXN0cmlidXRpb24gTGljZW5zZSAoQ0RETCkgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwpXG5cCi1cblwKLUlUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1JcblwKLVRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlXG5cCi1pcyBwcm92aWRlZCwgcGxlYXNlIGNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9uc1xuXAotZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LlxuXAotXG5cCi1DcnlwdG9ncmFwaHlcblwKLVxuXAotQ29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlXG5cCi1jdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsXG5cCi1hbmQvb3IgcmUtZXhwb3J0IHRvIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFXG5cCi11c2luZyBhbnkgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cyxcblwKLXJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIG9yIHVzZSxcblwKLWFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLlxuXAotXG5cCi1KYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIFN1biBNaWNyb3N5c3RlbXMsIEluYy4gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC5cbgotIyMjIyMjIyMjIyMgZW5kIG9mIGxpY2Vuc2UgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMvZmVhdHVyZS54bWwgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMvZmVhdHVyZS54bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAyMGZhNDQuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzL2ZlYXR1cmUueG1sCisrKyAvZGV2L251bGwKQEAgLTEsMjggKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxmZWF0dXJlCi0gICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LnRlc3RzIgotICAgICAgbGFiZWw9IiVmZWF0dXJlTmFtZSIKLSAgICAgIHZlcnNpb249IjIuMS4wLnF1YWxpZmllciIKLSAgICAgIHByb3ZpZGVyLW5hbWU9IiVwcm92aWRlck5hbWUiPgotCi0gICA8ZGVzY3JpcHRpb24+Ci0gICAgICAlZGVzY3JpcHRpb24KLSAgIDwvZGVzY3JpcHRpb24+Ci0KLSAgIDxjb3B5cmlnaHQ+Ci0gICAgICAlY29weXJpZ2h0Ci0gICA8L2NvcHlyaWdodD4KLQotICAgPGxpY2Vuc2UgdXJsPSJsaWNlbnNlLmh0bWwiPgotICAgICAgJWxpY2Vuc2UKLSAgIDwvbGljZW5zZT4KLQotICAgPHVybD4KLSAgICAgIDx1cGRhdGUgbGFiZWw9IiV1cGRhdGVTaXRlTmFtZSIgdXJsPSJodHRwOi8vZG93bmxvYWQuZWNsaXBzZS5vcmcvd2VidG9vbHMvdXBkYXRlcy8iLz4KLSAgIDwvdXJsPgotCi0gICA8aW5jbHVkZXMKLSAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHQudGVzdHMuZmVhdHVyZSIKLSAgICAgICAgIHZlcnNpb249IjAuMC4wIi8+Ci0KLTwvZmVhdHVyZT4KZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy9saWNlbnNlLmh0bWwgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMvbGljZW5zZS5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1NjQ0NTk4Li4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy9saWNlbnNlLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSw5OCArMCwwIEBACi08IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wMSBUcmFuc2l0aW9uYWwvL0VOIiAiaHR0cDovL3d3dy53M2Mub3JnL1RSLzE5OTkvUkVDLWh0bWw0MDEtMTk5OTEyMjQvbG9vc2UuZHRkIj4KLTwhLS0gc2F2ZWQgZnJvbSB1cmw9KDAwNDQpaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwvbm90aWNlLmh0bWwgLS0+Ci08SFRNTD48SEVBRD48VElUTEU+RWNsaXBzZS5vcmcgU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L1RJVExFPgotPE1FVEEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PWlzby04ODU5LTEiPgotPE1FVEEgY29udGVudD0iTVNIVE1MIDYuMDAuMjgwMC4xNDc5IiBuYW1lPUdFTkVSQVRPUj48L0hFQUQ+Ci08Qk9EWSBsYW5nPUVOLVVTIHZMaW5rPXB1cnBsZSBsaW5rPWJsdWU+Ci08SDI+RWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9IMj4KLTxQPkp1bmUgMDYsIDIwMDc8L1A+Ci08SDM+VXNhZ2UgT2YgQ29udGVudDwvSDM+Ci08UD5USEUgRUNMSVBTRSBGT1VOREFUSU9OIE1BS0VTIEFWQUlMQUJMRSBTT0ZUV0FSRSwgRE9DVU1FTlRBVElPTiwgSU5GT1JNQVRJT04gCi1BTkQvT1IgT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUyAoQ09MTEVDVElWRUxZICJDT05URU5UIikuIFVTRSBPRiAKLVRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIAotVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgCi1CRUxPVy4gQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVSBBR1JFRSBUSEFUIFlPVVIgVVNFIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIAotQlkgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIAotQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiBJRiBZT1UgRE8gTk9UIEFHUkVFIFRPIFRIRSAKLVRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORCBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIAotQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVywgVEhFTiBZT1UgCi1NQVkgTk9UIFVTRSBUSEUgQ09OVEVOVC48L1A+Ci08SDM+QXBwbGljYWJsZSBMaWNlbnNlczwvSDM+Ci08UD5Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgCi1Gb3VuZGF0aW9uIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgCi1QdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXMgCi1Db250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCA8QSAKLWhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvQT4uIAotRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9QPgotPFA+Q29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsIAotZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZS5vcmcgQ1ZTIHJlcG9zaXRvcnkgCi0oIlJlcG9zaXRvcnkiKSBpbiBDVlMgbW9kdWxlcyAoIk1vZHVsZXMiKSBhbmQgbWFkZSBhdmFpbGFibGUgYXMgZG93bmxvYWRhYmxlIAotYXJjaGl2ZXMgKCJEb3dubG9hZHMiKS48L1A+Ci08UD5Db250ZW50IG1heSBiZSBhcHBvcnRpb25lZCBpbnRvIHBsdWctaW5zICgiUGx1Zy1pbnMiKSwgcGx1Zy1pbiBmcmFnbWVudHMgCi0oIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLiBBIEZlYXR1cmUgaXMgYSBidW5kbGUgb2Ygb25lIG9yIG1vcmUgCi1QbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLiBGaWxlcyBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSAKLWNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIHRoZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIAotYXNzb2NpYXRlZCB3aXRoIGEgRmVhdHVyZS4gUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBhcmUgbG9jYXRlZCBpbiBkaXJlY3RvcmllcyAKLW5hbWVkICJwbHVnaW5zIiBhbmQgRmVhdHVyZXMgYXJlIGxvY2F0ZWQgaW4gZGlyZWN0b3JpZXMgbmFtZWQgImZlYXR1cmVzIi48L1A+Ci08UD5GZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgiSW5jbHVkZWQgRmVhdHVyZXMiKS4gRmlsZXMgbmFtZWQgCi0iZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCAKLUZlYXR1cmVzLjwvUD4KLTxQPlRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmUgY29udGFpbmVkIAotaW4gZmlsZXMgbmFtZWQgImFib3V0Lmh0bWwiICgiQWJvdXRzIikuIFRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgCi1GZWF0dXJlcyBhbmQgSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAibGljZW5zZS5odG1sIiAKLSgiRmVhdHVyZSBMaWNlbnNlcyIpLiBBYm91dHMgYW5kIEZlYXR1cmUgTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55IAotZGlyZWN0b3J5IG9mIGEgRG93bmxvYWQgb3IgTW9kdWxlIGluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgCi1sb2NhdGlvbnM6PC9QPgotPFVMPgotICA8TEk+VGhlIHRvcC1sZXZlbCAocm9vdCkgZGlyZWN0b3J5IAotICA8TEk+UGx1Zy1pbiBhbmQgRnJhZ21lbnQgZGlyZWN0b3JpZXMgCi0gIDxMST5TdWJkaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnMgCi0gIDxMST5GZWF0dXJlIGRpcmVjdG9yaWVzIDwvTEk+PC9VTD4KLTxQPk5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIGluc3RhbGxlZCAKLXVzaW5nIHRoZSBFY2xpcHNlIFVwZGF0ZSBNYW5hZ2VyLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFVwZGF0ZSAKLUxpY2Vuc2UiKSBkdXJpbmcgdGhlIGluc3RhbGxhdGlvbiBwcm9jZXNzLiBJZiB0aGUgRmVhdHVyZSBjb250YWlucyBJbmNsdWRlZCAKLUZlYXR1cmVzLCB0aGUgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBzaG91bGQgZWl0aGVyIHByb3ZpZGUgeW91IHdpdGggdGhlIHRlcm1zIAotYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvciBpbmZvcm0geW91IHdoZXJlIHlvdSBjYW4gCi1sb2NhdGUgdGhlbS4gRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgbWF5IGJlIGZvdW5kIGluIHRoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgCi1maWxlcyBuYW1lZCAiZmVhdHVyZS5wcm9wZXJ0aWVzIi4gU3VjaCBBYm91dHMsIEZlYXR1cmUgTGljZW5zZXMgYW5kIEZlYXR1cmUgCi1VcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgKG9yIHJlZmVyZW5jZXMgdG8gc3VjaCB0ZXJtcyAKLWFuZCBjb25kaXRpb25zKSB0aGF0IGdvdmVybiB5b3VyIHVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluIHRoYXQgCi1kaXJlY3RvcnkuPC9QPgotPFA+VEhFIEFCT1VUUywgRkVBVFVSRSBMSUNFTlNFUyBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSIFRPIFRIRSBFUEwgCi1PUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuIFNPTUUgT0YgVEhFU0UgCi1PVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOjwvUD4KLTxVTD4KLSAgPExJPkNvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWw8L0E+KSAKLQotICA8TEk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRTwvQT4pIAotCi0gIDxMST5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjA8L0E+KSAKLQotICA8TEk+SUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vZGV2ZWxvcGVyd29ya3Mvb3BlbnNvdXJjZS9saWNlbnNlMTAuaHRtbCI+aHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2RldmVsb3BlcndvcmtzL29wZW5zb3VyY2UvbGljZW5zZTEwLmh0bWw8L0E+KSAKLQotICA8TEk+TWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sIj5odHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbDwvQT4pIAotCi0gIDxMST5Nb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbCI+aHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sPC9BPikgCi0gIDwvTEk+Ci0gICAgCi0gIDxMST5Db21tb24gRGV2ZWxvcG1lbnQgYW5kIERpc3RyaWJ1dGlvbiBMaWNlbnNlIChDRERMKSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwiPmh0dHA6Ly93d3cuc3VuLmNvbS9jZGRsL2NkZGwuaHRtbCk8L0E+Ci0gIDwvTEk+Ci08L1VMPgotPFA+SVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgQ09ORElUSU9OUyBQUklPUiAKLVRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIGlzIAotcHJvdmlkZWQsIHBsZWFzZSBjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIAotY29uZGl0aW9ucyBnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuPC9QPgotPEgzPkNyeXB0b2dyYXBoeTwvSDM+Ci08UD5Db250ZW50IG1heSBjb250YWluIGVuY3J5cHRpb24gc29mdHdhcmUuIFRoZSBjb3VudHJ5IGluIHdoaWNoIHlvdSBhcmUgCi1jdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsIGFuZC9vciAKLXJlLWV4cG9ydCB0byBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRSB1c2luZyBhbnkgCi1lbmNyeXB0aW9uIHNvZnR3YXJlLCBwbGVhc2UgY2hlY2sgdGhlIGNvdW50cnkncyBsYXdzLCByZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgCi1jb25jZXJuaW5nIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIG9yIHVzZSwgYW5kIHJlLWV4cG9ydCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLCAKLXRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC48L1A+PC9CT0RZPjwvSFRNTD4KZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC8uY3ZzaWdub3JlIGIvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0Ly5jdnNpZ25vcmUKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGRlOGI3M2YuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0Ly5jdnNpZ25vcmUKKysrIC9kZXYvbnVsbApAQCAtMSwyICswLDAgQEAKLWJ1aWxkLnhtbAotb3JnLmVjbGlwc2UuanB0XzEuMC4wLioKZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC8ucHJvamVjdCBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC8ucHJvamVjdApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYjdhYWVjMi4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQvLnByb2plY3QKKysrIC9kZXYvbnVsbApAQCAtMSwxNyArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPHByb2plY3REZXNjcmlwdGlvbj4KLQk8bmFtZT5vcmcuZWNsaXBzZS5qcHQ8L25hbWU+Ci0JPGNvbW1lbnQ+PC9jb21tZW50PgotCTxwcm9qZWN0cz4KLQk8L3Byb2plY3RzPgotCTxidWlsZFNwZWM+Ci0JCTxidWlsZENvbW1hbmQ+Ci0JCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuRmVhdHVyZUJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCTwvYnVpbGRTcGVjPgotCTxuYXR1cmVzPgotCQk8bmF0dXJlPm9yZy5lY2xpcHNlLnBkZS5GZWF0dXJlTmF0dXJlPC9uYXR1cmU+Ci0JPC9uYXR1cmVzPgotPC9wcm9qZWN0RGVzY3JpcHRpb24+CmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQvYnVpbGQucHJvcGVydGllcyBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC9idWlsZC5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0NzBiNGJjLi4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC9idWlsZC5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTYgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBDb3B5cmlnaHQgKGMpIDIwMDYgT3JhY2xlLgotIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCi0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAotIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAotIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlLiAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotYmluLmluY2x1ZGVzID0gZmVhdHVyZS54bWwsXAotICAgICAgICAgICAgICAgZWNsaXBzZV91cGRhdGVfMTIwLmpwZyxcCi0gICAgICAgICAgICAgICBlcGwtdjEwLmh0bWwsXAotICAgICAgICAgICAgICAgbGljZW5zZS5odG1sLFwKLSAgICAgICAgICAgICAgIGZlYXR1cmUucHJvcGVydGllcwotICAgICAgICAgICAgICAgClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0L2VjbGlwc2VfdXBkYXRlXzEyMC5qcGcgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQvZWNsaXBzZV91cGRhdGVfMTIwLmpwZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmZkZjcwOC4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQvZWNsaXBzZV91cGRhdGVfMTIwLmpwZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC9lcGwtdjEwLmh0bWwgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQvZXBsLXYxMC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlZDRiMTk2Li4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC9lcGwtdjEwLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSwzMjggKzAsMCBAQAotPGh0bWwgeG1sbnM6bz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6b2ZmaWNlIgoteG1sbnM6dz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6d29yZCIKLXhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy9UUi9SRUMtaHRtbDQwIj4KLQotPGhlYWQ+Ci08bWV0YSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9d2luZG93cy0xMjUyIj4KLTxtZXRhIG5hbWU9UHJvZ0lkIGNvbnRlbnQ9V29yZC5Eb2N1bWVudD4KLTxtZXRhIG5hbWU9R2VuZXJhdG9yIGNvbnRlbnQ9Ik1pY3Jvc29mdCBXb3JkIDkiPgotPG1ldGEgbmFtZT1PcmlnaW5hdG9yIGNvbnRlbnQ9Ik1pY3Jvc29mdCBXb3JkIDkiPgotPGxpbmsgcmVsPUZpbGUtTGlzdAotaHJlZj0iLi9FY2xpcHNlJTIwRVBMJTIwMjAwM18xMV8xMCUyMEZpbmFsX2ZpbGVzL2ZpbGVsaXN0LnhtbCI+Ci08dGl0bGU+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIFZlcnNpb24gMS4wPC90aXRsZT4KLTwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDxvOkRvY3VtZW50UHJvcGVydGllcz4KLSAgPG86UmV2aXNpb24+MjwvbzpSZXZpc2lvbj4KLSAgPG86VG90YWxUaW1lPjM8L286VG90YWxUaW1lPgotICA8bzpDcmVhdGVkPjIwMDQtMDMtMDVUMjM6MDM6MDBaPC9vOkNyZWF0ZWQ+Ci0gIDxvOkxhc3RTYXZlZD4yMDA0LTAzLTA1VDIzOjAzOjAwWjwvbzpMYXN0U2F2ZWQ+Ci0gIDxvOlBhZ2VzPjQ8L286UGFnZXM+Ci0gIDxvOldvcmRzPjE2MjY8L286V29yZHM+Ci0gIDxvOkNoYXJhY3RlcnM+OTI3MDwvbzpDaGFyYWN0ZXJzPgotICAgPG86TGluZXM+Nzc8L286TGluZXM+Ci0gIDxvOlBhcmFncmFwaHM+MTg8L286UGFyYWdyYXBocz4KLSAgPG86Q2hhcmFjdGVyc1dpdGhTcGFjZXM+MTEzODQ8L286Q2hhcmFjdGVyc1dpdGhTcGFjZXM+Ci0gIDxvOlZlcnNpb24+OS40NDAyPC9vOlZlcnNpb24+Ci0gPC9vOkRvY3VtZW50UHJvcGVydGllcz4KLTwveG1sPjwhW2VuZGlmXS0tPjwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDx3OldvcmREb2N1bWVudD4KLSAgPHc6VHJhY2tSZXZpc2lvbnMvPgotIDwvdzpXb3JkRG9jdW1lbnQ+Ci08L3htbD48IVtlbmRpZl0tLT4KLTxzdHlsZT4KLTwhLS0KLSAvKiBGb250IERlZmluaXRpb25zICovCi1AZm9udC1mYWNlCi0Je2ZvbnQtZmFtaWx5OlRhaG9tYTsKLQlwYW5vc2UtMToyIDExIDYgNCAzIDUgNCA0IDIgNDsKLQltc28tZm9udC1jaGFyc2V0OjA7Ci0JbXNvLWdlbmVyaWMtZm9udC1mYW1pbHk6c3dpc3M7Ci0JbXNvLWZvbnQtcGl0Y2g6dmFyaWFibGU7Ci0JbXNvLWZvbnQtc2lnbmF0dXJlOjU1MzY3OTQ5NSAtMjE0NzQ4MzY0OCA4IDAgNjYwNDcgMDt9Ci0gLyogU3R5bGUgRGVmaW5pdGlvbnMgKi8KLXAuTXNvTm9ybWFsLCBsaS5Nc29Ob3JtYWwsIGRpdi5Nc29Ob3JtYWwKLQl7bXNvLXN0eWxlLXBhcmVudDoiIjsKLQltYXJnaW46MGluOwotCW1hcmdpbi1ib3R0b206LjAwMDFwdDsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjEyLjBwdDsKLQlmb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1wCi0Je21hcmdpbi1yaWdodDowaW47Ci0JbXNvLW1hcmdpbi10b3AtYWx0OmF1dG87Ci0JbXNvLW1hcmdpbi1ib3R0b20tYWx0OmF1dG87Ci0JbWFyZ2luLWxlZnQ6MGluOwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXAuQmFsbG9vblRleHQsIGxpLkJhbGxvb25UZXh0LCBkaXYuQmFsbG9vblRleHQKLQl7bXNvLXN0eWxlLW5hbWU6IkJhbGxvb24gVGV4dCI7Ci0JbWFyZ2luOjBpbjsKLQltYXJnaW4tYm90dG9tOi4wMDAxcHQ7Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZTo4LjBwdDsKLQlmb250LWZhbWlseTpUYWhvbWE7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotQHBhZ2UgU2VjdGlvbjEKLQl7c2l6ZTo4LjVpbiAxMS4waW47Ci0JbWFyZ2luOjEuMGluIDEuMjVpbiAxLjBpbiAxLjI1aW47Ci0JbXNvLWhlYWRlci1tYXJnaW46LjVpbjsKLQltc28tZm9vdGVyLW1hcmdpbjouNWluOwotCW1zby1wYXBlci1zb3VyY2U6MDt9Ci1kaXYuU2VjdGlvbjEKLQl7cGFnZTpTZWN0aW9uMTt9Ci0tLT4KLTwvc3R5bGU+Ci08L2hlYWQ+Ci0KLTxib2R5IGxhbmc9RU4tVVMgc3R5bGU9J3RhYi1pbnRlcnZhbDouNWluJz4KLQotPGRpdiBjbGFzcz1TZWN0aW9uMT4KLQotPHAgYWxpZ249Y2VudGVyIHN0eWxlPSd0ZXh0LWFsaWduOmNlbnRlcic+PGI+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIHYgMS4wPC9iPgotPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+VEhFIEFDQ09NUEFOWUlORyBQUk9HUkFNIElTIFBST1ZJREVEIFVOREVSCi1USEUgVEVSTVMgT0YgVEhJUyBFQ0xJUFNFIFBVQkxJQyBMSUNFTlNFICgmcXVvdDtBR1JFRU1FTlQmcXVvdDspLiBBTlkgVVNFLAotUkVQUk9EVUNUSU9OIE9SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBDT05TVElUVVRFUyBSRUNJUElFTlQnUyBBQ0NFUFRBTkNFCi1PRiBUSElTIEFHUkVFTUVOVC48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjEuIERFRklOSVRJT05TPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7Q29udHJpYnV0aW9uJnF1b3Q7IG1lYW5zOjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaW4gdGhlIGNhc2Ugb2YgdGhlIGluaXRpYWwgQ29udHJpYnV0b3IsIHRoZSBpbml0aWFsIGNvZGUgYW5kIGRvY3VtZW50YXRpb24KLWRpc3RyaWJ1dGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBhbmQ8YnIgY2xlYXI9bGVmdD4KLWIpIGluIHRoZSBjYXNlIG9mIGVhY2ggc3Vic2VxdWVudCBDb250cmlidXRvcjo8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pKQotY2hhbmdlcyB0byB0aGUgUHJvZ3JhbSwgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWkpCi1hZGRpdGlvbnMgdG8gdGhlIFByb2dyYW07PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+d2hlcmUKLXN1Y2ggY2hhbmdlcyBhbmQvb3IgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIG9yaWdpbmF0ZSBmcm9tIGFuZCBhcmUgZGlzdHJpYnV0ZWQKLWJ5IHRoYXQgcGFydGljdWxhciBDb250cmlidXRvci4gQSBDb250cmlidXRpb24gJ29yaWdpbmF0ZXMnIGZyb20gYSBDb250cmlidXRvcgotaWYgaXQgd2FzIGFkZGVkIHRvIHRoZSBQcm9ncmFtIGJ5IHN1Y2ggQ29udHJpYnV0b3IgaXRzZWxmIG9yIGFueW9uZSBhY3Rpbmcgb24KLXN1Y2ggQ29udHJpYnV0b3IncyBiZWhhbGYuIENvbnRyaWJ1dGlvbnMgZG8gbm90IGluY2x1ZGUgYWRkaXRpb25zIHRvIHRoZQotUHJvZ3JhbSB3aGljaDogKGkpIGFyZSBzZXBhcmF0ZSBtb2R1bGVzIG9mIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIGluIGNvbmp1bmN0aW9uCi13aXRoIHRoZSBQcm9ncmFtIHVuZGVyIHRoZWlyIG93biBsaWNlbnNlIGFncmVlbWVudCwgYW5kIChpaSkgYXJlIG5vdCBkZXJpdmF0aXZlCi13b3JrcyBvZiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0NvbnRyaWJ1dG9yJnF1b3Q7IG1lYW5zIGFueSBwZXJzb24gb3IKLWVudGl0eSB0aGF0IGRpc3RyaWJ1dGVzIHRoZSBQcm9ncmFtLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7TGljZW5zZWQgUGF0ZW50cyAmcXVvdDsgbWVhbiBwYXRlbnQKLWNsYWltcyBsaWNlbnNhYmxlIGJ5IGEgQ29udHJpYnV0b3Igd2hpY2ggYXJlIG5lY2Vzc2FyaWx5IGluZnJpbmdlZCBieSB0aGUgdXNlCi1vciBzYWxlIG9mIGl0cyBDb250cmlidXRpb24gYWxvbmUgb3Igd2hlbiBjb21iaW5lZCB3aXRoIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7UHJvZ3JhbSZxdW90OyBtZWFucyB0aGUgQ29udHJpYnV0aW9ucwotZGlzdHJpYnV0ZWQgaW4gYWNjb3JkYW5jZSB3aXRoIHRoaXMgQWdyZWVtZW50Ljwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7UmVjaXBpZW50JnF1b3Q7IG1lYW5zIGFueW9uZSB3aG8KLXJlY2VpdmVzIHRoZSBQcm9ncmFtIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBpbmNsdWRpbmcgYWxsIENvbnRyaWJ1dG9ycy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjIuIEdSQU5UIE9GIFJJR0hUUzwvc3Bhbj48L2I+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLVN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50Ci1hIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwgcm95YWx0eS1mcmVlIGNvcHlyaWdodCBsaWNlbnNlIHRvPHNwYW4KLXN0eWxlPSdjb2xvcjpyZWQnPiA8L3NwYW4+cmVwcm9kdWNlLCBwcmVwYXJlIGRlcml2YXRpdmUgd29ya3Mgb2YsIHB1YmxpY2x5Ci1kaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBkaXN0cmlidXRlIGFuZCBzdWJsaWNlbnNlIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaAotQ29udHJpYnV0b3IsIGlmIGFueSwgYW5kIHN1Y2ggZGVyaXZhdGl2ZSB3b3JrcywgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlCi1mb3JtLjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpCi1TdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzCi1SZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsPHNwYW4gc3R5bGU9J2NvbG9yOmdyZWVuJz4gPC9zcGFuPnJveWFsdHktZnJlZQotcGF0ZW50IGxpY2Vuc2UgdW5kZXIgTGljZW5zZWQgUGF0ZW50cyB0byBtYWtlLCB1c2UsIHNlbGwsIG9mZmVyIHRvIHNlbGwsIGltcG9ydAotYW5kIG90aGVyd2lzZSB0cmFuc2ZlciB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgaW4gc291cmNlCi1jb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLiBUaGlzIHBhdGVudCBsaWNlbnNlIHNoYWxsIGFwcGx5IHRvIHRoZSBjb21iaW5hdGlvbgotb2YgdGhlIENvbnRyaWJ1dGlvbiBhbmQgdGhlIFByb2dyYW0gaWYsIGF0IHRoZSB0aW1lIHRoZSBDb250cmlidXRpb24gaXMgYWRkZWQKLWJ5IHRoZSBDb250cmlidXRvciwgc3VjaCBhZGRpdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGNhdXNlcyBzdWNoIGNvbWJpbmF0aW9uCi10byBiZSBjb3ZlcmVkIGJ5IHRoZSBMaWNlbnNlZCBQYXRlbnRzLiBUaGUgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgbm90IGFwcGx5IHRvCi1hbnkgb3RoZXIgY29tYmluYXRpb25zIHdoaWNoIGluY2x1ZGUgdGhlIENvbnRyaWJ1dGlvbi4gTm8gaGFyZHdhcmUgcGVyIHNlIGlzCi1saWNlbnNlZCBoZXJldW5kZXIuIDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmMpCi1SZWNpcGllbnQgdW5kZXJzdGFuZHMgdGhhdCBhbHRob3VnaCBlYWNoIENvbnRyaWJ1dG9yIGdyYW50cyB0aGUgbGljZW5zZXMgdG8gaXRzCi1Db250cmlidXRpb25zIHNldCBmb3J0aCBoZXJlaW4sIG5vIGFzc3VyYW5jZXMgYXJlIHByb3ZpZGVkIGJ5IGFueSBDb250cmlidXRvcgotdGhhdCB0aGUgUHJvZ3JhbSBkb2VzIG5vdCBpbmZyaW5nZSB0aGUgcGF0ZW50IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQotcmlnaHRzIG9mIGFueSBvdGhlciBlbnRpdHkuIEVhY2ggQ29udHJpYnV0b3IgZGlzY2xhaW1zIGFueSBsaWFiaWxpdHkgdG8gUmVjaXBpZW50Ci1mb3IgY2xhaW1zIGJyb3VnaHQgYnkgYW55IG90aGVyIGVudGl0eSBiYXNlZCBvbiBpbmZyaW5nZW1lbnQgb2YgaW50ZWxsZWN0dWFsCi1wcm9wZXJ0eSByaWdodHMgb3Igb3RoZXJ3aXNlLiBBcyBhIGNvbmRpdGlvbiB0byBleGVyY2lzaW5nIHRoZSByaWdodHMgYW5kCi1saWNlbnNlcyBncmFudGVkIGhlcmV1bmRlciwgZWFjaCBSZWNpcGllbnQgaGVyZWJ5IGFzc3VtZXMgc29sZSByZXNwb25zaWJpbGl0eQotdG8gc2VjdXJlIGFueSBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG5lZWRlZCwgaWYgYW55LiBGb3IgZXhhbXBsZSwKLWlmIGEgdGhpcmQgcGFydHkgcGF0ZW50IGxpY2Vuc2UgaXMgcmVxdWlyZWQgdG8gYWxsb3cgUmVjaXBpZW50IHRvIGRpc3RyaWJ1dGUKLXRoZSBQcm9ncmFtLCBpdCBpcyBSZWNpcGllbnQncyByZXNwb25zaWJpbGl0eSB0byBhY3F1aXJlIHRoYXQgbGljZW5zZSBiZWZvcmUKLWRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbS48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5kKQotRWFjaCBDb250cmlidXRvciByZXByZXNlbnRzIHRoYXQgdG8gaXRzIGtub3dsZWRnZSBpdCBoYXMgc3VmZmljaWVudCBjb3B5cmlnaHQKLXJpZ2h0cyBpbiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIHRvIGdyYW50IHRoZSBjb3B5cmlnaHQgbGljZW5zZSBzZXQgZm9ydGggaW4KLXRoaXMgQWdyZWVtZW50LiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+My4gUkVRVUlSRU1FTlRTPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+QSBDb250cmlidXRvciBtYXkgY2hvb3NlIHRvIGRpc3RyaWJ1dGUgdGhlCi1Qcm9ncmFtIGluIG9iamVjdCBjb2RlIGZvcm0gdW5kZXIgaXRzIG93biBsaWNlbnNlIGFncmVlbWVudCwgcHJvdmlkZWQgdGhhdDo8L3NwYW4+Ci08L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pdCBjb21wbGllcyB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudDsgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikKLWl0cyBsaWNlbnNlIGFncmVlbWVudDo8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pKQotZWZmZWN0aXZlbHkgZGlzY2xhaW1zIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCB3YXJyYW50aWVzIGFuZAotY29uZGl0aW9ucywgZXhwcmVzcyBhbmQgaW1wbGllZCwgaW5jbHVkaW5nIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiB0aXRsZQotYW5kIG5vbi1pbmZyaW5nZW1lbnQsIGFuZCBpbXBsaWVkIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiBtZXJjaGFudGFiaWxpdHkKLWFuZCBmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZTsgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWkpCi1lZmZlY3RpdmVseSBleGNsdWRlcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgbGlhYmlsaXR5IGZvciBkYW1hZ2VzLAotaW5jbHVkaW5nIGRpcmVjdCwgaW5kaXJlY3QsIHNwZWNpYWwsIGluY2lkZW50YWwgYW5kIGNvbnNlcXVlbnRpYWwgZGFtYWdlcywgc3VjaAotYXMgbG9zdCBwcm9maXRzOyA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paWkpCi1zdGF0ZXMgdGhhdCBhbnkgcHJvdmlzaW9ucyB3aGljaCBkaWZmZXIgZnJvbSB0aGlzIEFncmVlbWVudCBhcmUgb2ZmZXJlZCBieSB0aGF0Ci1Db250cmlidXRvciBhbG9uZSBhbmQgbm90IGJ5IGFueSBvdGhlciBwYXJ0eTsgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aXYpCi1zdGF0ZXMgdGhhdCBzb3VyY2UgY29kZSBmb3IgdGhlIFByb2dyYW0gaXMgYXZhaWxhYmxlIGZyb20gc3VjaCBDb250cmlidXRvciwgYW5kCi1pbmZvcm1zIGxpY2Vuc2VlcyBob3cgdG8gb2J0YWluIGl0IGluIGEgcmVhc29uYWJsZSBtYW5uZXIgb24gb3IgdGhyb3VnaCBhCi1tZWRpdW0gY3VzdG9tYXJpbHkgdXNlZCBmb3Igc29mdHdhcmUgZXhjaGFuZ2UuPHNwYW4gc3R5bGU9J2NvbG9yOmJsdWUnPiA8L3NwYW4+PC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPldoZW4gdGhlIFByb2dyYW0gaXMgbWFkZSBhdmFpbGFibGUgaW4gc291cmNlCi1jb2RlIGZvcm06PC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pdCBtdXN0IGJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoaXMgQWdyZWVtZW50OyBhbmQgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikgYQotY29weSBvZiB0aGlzIEFncmVlbWVudCBtdXN0IGJlIGluY2x1ZGVkIHdpdGggZWFjaCBjb3B5IG9mIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Q29udHJpYnV0b3JzIG1heSBub3QgcmVtb3ZlIG9yIGFsdGVyIGFueQotY29weXJpZ2h0IG5vdGljZXMgY29udGFpbmVkIHdpdGhpbiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVhY2ggQ29udHJpYnV0b3IgbXVzdCBpZGVudGlmeSBpdHNlbGYgYXMgdGhlCi1vcmlnaW5hdG9yIG9mIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgaW4gYSBtYW5uZXIgdGhhdCByZWFzb25hYmx5IGFsbG93cwotc3Vic2VxdWVudCBSZWNpcGllbnRzIHRvIGlkZW50aWZ5IHRoZSBvcmlnaW5hdG9yIG9mIHRoZSBDb250cmlidXRpb24uIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz40LiBDT01NRVJDSUFMIERJU1RSSUJVVElPTjwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkNvbW1lcmNpYWwgZGlzdHJpYnV0b3JzIG9mIHNvZnR3YXJlIG1heQotYWNjZXB0IGNlcnRhaW4gcmVzcG9uc2liaWxpdGllcyB3aXRoIHJlc3BlY3QgdG8gZW5kIHVzZXJzLCBidXNpbmVzcyBwYXJ0bmVycwotYW5kIHRoZSBsaWtlLiBXaGlsZSB0aGlzIGxpY2Vuc2UgaXMgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY29tbWVyY2lhbCB1c2UKLW9mIHRoZSBQcm9ncmFtLCB0aGUgQ29udHJpYnV0b3Igd2hvIGluY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbAotcHJvZHVjdCBvZmZlcmluZyBzaG91bGQgZG8gc28gaW4gYSBtYW5uZXIgd2hpY2ggZG9lcyBub3QgY3JlYXRlIHBvdGVudGlhbAotbGlhYmlsaXR5IGZvciBvdGhlciBDb250cmlidXRvcnMuIFRoZXJlZm9yZSwgaWYgYSBDb250cmlidXRvciBpbmNsdWRlcyB0aGUKLVByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIHN1Y2ggQ29udHJpYnV0b3IgKCZxdW90O0NvbW1lcmNpYWwKLUNvbnRyaWJ1dG9yJnF1b3Q7KSBoZXJlYnkgYWdyZWVzIHRvIGRlZmVuZCBhbmQgaW5kZW1uaWZ5IGV2ZXJ5IG90aGVyCi1Db250cmlidXRvciAoJnF1b3Q7SW5kZW1uaWZpZWQgQ29udHJpYnV0b3ImcXVvdDspIGFnYWluc3QgYW55IGxvc3NlcywgZGFtYWdlcyBhbmQKLWNvc3RzIChjb2xsZWN0aXZlbHkgJnF1b3Q7TG9zc2VzJnF1b3Q7KSBhcmlzaW5nIGZyb20gY2xhaW1zLCBsYXdzdWl0cyBhbmQgb3RoZXIKLWxlZ2FsIGFjdGlvbnMgYnJvdWdodCBieSBhIHRoaXJkIHBhcnR5IGFnYWluc3QgdGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIHRvCi10aGUgZXh0ZW50IGNhdXNlZCBieSB0aGUgYWN0cyBvciBvbWlzc2lvbnMgb2Ygc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluCi1jb25uZWN0aW9uIHdpdGggaXRzIGRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdAotb2ZmZXJpbmcuIFRoZSBvYmxpZ2F0aW9ucyBpbiB0aGlzIHNlY3Rpb24gZG8gbm90IGFwcGx5IHRvIGFueSBjbGFpbXMgb3IgTG9zc2VzCi1yZWxhdGluZyB0byBhbnkgYWN0dWFsIG9yIGFsbGVnZWQgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGluZnJpbmdlbWVudC4gSW4gb3JkZXIKLXRvIHF1YWxpZnksIGFuIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG11c3Q6IGEpIHByb21wdGx5IG5vdGlmeSB0aGUgQ29tbWVyY2lhbAotQ29udHJpYnV0b3IgaW4gd3JpdGluZyBvZiBzdWNoIGNsYWltLCBhbmQgYikgYWxsb3cgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IKLXRvIGNvbnRyb2wsIGFuZCBjb29wZXJhdGUgd2l0aCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiwgdGhlIGRlZmVuc2UgYW5kCi1hbnkgcmVsYXRlZCBzZXR0bGVtZW50IG5lZ290aWF0aW9ucy4gVGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG1heSBwYXJ0aWNpcGF0ZQotaW4gYW55IHN1Y2ggY2xhaW0gYXQgaXRzIG93biBleHBlbnNlLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Rm9yIGV4YW1wbGUsIGEgQ29udHJpYnV0b3IgbWlnaHQgaW5jbHVkZSB0aGUKLVByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIFByb2R1Y3QgWC4gVGhhdCBDb250cmlidXRvciBpcyB0aGVuIGEKLUNvbW1lcmNpYWwgQ29udHJpYnV0b3IuIElmIHRoYXQgQ29tbWVyY2lhbCBDb250cmlidXRvciB0aGVuIG1ha2VzIHBlcmZvcm1hbmNlCi1jbGFpbXMsIG9yIG9mZmVycyB3YXJyYW50aWVzIHJlbGF0ZWQgdG8gUHJvZHVjdCBYLCB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kCi13YXJyYW50aWVzIGFyZSBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IncyByZXNwb25zaWJpbGl0eSBhbG9uZS4gVW5kZXIgdGhpcwotc2VjdGlvbiwgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3Igd291bGQgaGF2ZSB0byBkZWZlbmQgY2xhaW1zIGFnYWluc3QgdGhlCi1vdGhlciBDb250cmlidXRvcnMgcmVsYXRlZCB0byB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMsIGFuZCBpZiBhCi1jb3VydCByZXF1aXJlcyBhbnkgb3RoZXIgQ29udHJpYnV0b3IgdG8gcGF5IGFueSBkYW1hZ2VzIGFzIGEgcmVzdWx0LCB0aGUKLUNvbW1lcmNpYWwgQ29udHJpYnV0b3IgbXVzdCBwYXkgdGhvc2UgZGFtYWdlcy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjUuIE5PIFdBUlJBTlRZPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUwotQUdSRUVNRU5ULCBUSEUgUFJPR1JBTSBJUyBQUk9WSURFRCBPTiBBTiAmcXVvdDtBUyBJUyZxdW90OyBCQVNJUywgV0lUSE9VVAotV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBFSVRIRVIgRVhQUkVTUyBPUiBJTVBMSUVEIElOQ0xVRElORywKLVdJVEhPVVQgTElNSVRBVElPTiwgQU5ZIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBUSVRMRSwgTk9OLUlORlJJTkdFTUVOVCwKLU1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gRWFjaCBSZWNpcGllbnQgaXMgc29sZWx5Ci1yZXNwb25zaWJsZSBmb3IgZGV0ZXJtaW5pbmcgdGhlIGFwcHJvcHJpYXRlbmVzcyBvZiB1c2luZyBhbmQgZGlzdHJpYnV0aW5nIHRoZQotUHJvZ3JhbSBhbmQgYXNzdW1lcyBhbGwgcmlza3MgYXNzb2NpYXRlZCB3aXRoIGl0cyBleGVyY2lzZSBvZiByaWdodHMgdW5kZXIgdGhpcwotQWdyZWVtZW50ICwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgcmlza3MgYW5kIGNvc3RzIG9mIHByb2dyYW0gZXJyb3JzLAotY29tcGxpYW5jZSB3aXRoIGFwcGxpY2FibGUgbGF3cywgZGFtYWdlIHRvIG9yIGxvc3Mgb2YgZGF0YSwgcHJvZ3JhbXMgb3IKLWVxdWlwbWVudCwgYW5kIHVuYXZhaWxhYmlsaXR5IG9yIGludGVycnVwdGlvbiBvZiBvcGVyYXRpb25zLiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Ni4gRElTQ0xBSU1FUiBPRiBMSUFCSUxJVFk8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTCi1BR1JFRU1FTlQsIE5FSVRIRVIgUkVDSVBJRU5UIE5PUiBBTlkgQ09OVFJJQlVUT1JTIFNIQUxMIEhBVkUgQU5ZIExJQUJJTElUWSBGT1IKLUFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwotKElOQ0xVRElORyBXSVRIT1VUIExJTUlUQVRJT04gTE9TVCBQUk9GSVRTKSwgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKLU9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HCi1ORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9SIERJU1RSSUJVVElPTiBPRgotVEhFIFBST0dSQU0gT1IgVEhFIEVYRVJDSVNFIE9GIEFOWSBSSUdIVFMgR1JBTlRFRCBIRVJFVU5ERVIsIEVWRU4gSUYgQURWSVNFRCBPRgotVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFUy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjcuIEdFTkVSQUw8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5JZiBhbnkgcHJvdmlzaW9uIG9mIHRoaXMgQWdyZWVtZW50IGlzIGludmFsaWQKLW9yIHVuZW5mb3JjZWFibGUgdW5kZXIgYXBwbGljYWJsZSBsYXcsIGl0IHNoYWxsIG5vdCBhZmZlY3QgdGhlIHZhbGlkaXR5IG9yCi1lbmZvcmNlYWJpbGl0eSBvZiB0aGUgcmVtYWluZGVyIG9mIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgYW5kIHdpdGhvdXQKLWZ1cnRoZXIgYWN0aW9uIGJ5IHRoZSBwYXJ0aWVzIGhlcmV0bywgc3VjaCBwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlCi1taW5pbXVtIGV4dGVudCBuZWNlc3NhcnkgdG8gbWFrZSBzdWNoIHByb3Zpc2lvbiB2YWxpZCBhbmQgZW5mb3JjZWFibGUuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5JZiBSZWNpcGllbnQgaW5zdGl0dXRlcyBwYXRlbnQgbGl0aWdhdGlvbgotYWdhaW5zdCBhbnkgZW50aXR5IChpbmNsdWRpbmcgYSBjcm9zcy1jbGFpbSBvciBjb3VudGVyY2xhaW0gaW4gYSBsYXdzdWl0KQotYWxsZWdpbmcgdGhhdCB0aGUgUHJvZ3JhbSBpdHNlbGYgKGV4Y2x1ZGluZyBjb21iaW5hdGlvbnMgb2YgdGhlIFByb2dyYW0gd2l0aAotb3RoZXIgc29mdHdhcmUgb3IgaGFyZHdhcmUpIGluZnJpbmdlcyBzdWNoIFJlY2lwaWVudCdzIHBhdGVudChzKSwgdGhlbiBzdWNoCi1SZWNpcGllbnQncyByaWdodHMgZ3JhbnRlZCB1bmRlciBTZWN0aW9uIDIoYikgc2hhbGwgdGVybWluYXRlIGFzIG9mIHRoZSBkYXRlCi1zdWNoIGxpdGlnYXRpb24gaXMgZmlsZWQuIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5BbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50Ci1zaGFsbCB0ZXJtaW5hdGUgaWYgaXQgZmFpbHMgdG8gY29tcGx5IHdpdGggYW55IG9mIHRoZSBtYXRlcmlhbCB0ZXJtcyBvcgotY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudCBhbmQgZG9lcyBub3QgY3VyZSBzdWNoIGZhaWx1cmUgaW4gYSByZWFzb25hYmxlCi1wZXJpb2Qgb2YgdGltZSBhZnRlciBiZWNvbWluZyBhd2FyZSBvZiBzdWNoIG5vbmNvbXBsaWFuY2UuIElmIGFsbCBSZWNpcGllbnQncwotcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHRlcm1pbmF0ZSwgUmVjaXBpZW50IGFncmVlcyB0byBjZWFzZSB1c2UgYW5kCi1kaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gYXMgc29vbiBhcyByZWFzb25hYmx5IHByYWN0aWNhYmxlLiBIb3dldmVyLAotUmVjaXBpZW50J3Mgb2JsaWdhdGlvbnMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYW5kIGFueSBsaWNlbnNlcyBncmFudGVkIGJ5Ci1SZWNpcGllbnQgcmVsYXRpbmcgdG8gdGhlIFByb2dyYW0gc2hhbGwgY29udGludWUgYW5kIHN1cnZpdmUuIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FdmVyeW9uZSBpcyBwZXJtaXR0ZWQgdG8gY29weSBhbmQgZGlzdHJpYnV0ZQotY29waWVzIG9mIHRoaXMgQWdyZWVtZW50LCBidXQgaW4gb3JkZXIgdG8gYXZvaWQgaW5jb25zaXN0ZW5jeSB0aGUgQWdyZWVtZW50IGlzCi1jb3B5cmlnaHRlZCBhbmQgbWF5IG9ubHkgYmUgbW9kaWZpZWQgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXIuIFRoZSBBZ3JlZW1lbnQKLVN0ZXdhcmQgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHB1Ymxpc2ggbmV3IHZlcnNpb25zIChpbmNsdWRpbmcgcmV2aXNpb25zKSBvZgotdGhpcyBBZ3JlZW1lbnQgZnJvbSB0aW1lIHRvIHRpbWUuIE5vIG9uZSBvdGhlciB0aGFuIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCBoYXMKLXRoZSByaWdodCB0byBtb2RpZnkgdGhpcyBBZ3JlZW1lbnQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgdGhlIGluaXRpYWwKLUFncmVlbWVudCBTdGV3YXJkLiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1heSBhc3NpZ24gdGhlIHJlc3BvbnNpYmlsaXR5IHRvCi1zZXJ2ZSBhcyB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgdG8gYSBzdWl0YWJsZSBzZXBhcmF0ZSBlbnRpdHkuIEVhY2ggbmV3IHZlcnNpb24KLW9mIHRoZSBBZ3JlZW1lbnQgd2lsbCBiZSBnaXZlbiBhIGRpc3Rpbmd1aXNoaW5nIHZlcnNpb24gbnVtYmVyLiBUaGUgUHJvZ3JhbQotKGluY2x1ZGluZyBDb250cmlidXRpb25zKSBtYXkgYWx3YXlzIGJlIGRpc3RyaWJ1dGVkIHN1YmplY3QgdG8gdGhlIHZlcnNpb24gb2YKLXRoZSBBZ3JlZW1lbnQgdW5kZXIgd2hpY2ggaXQgd2FzIHJlY2VpdmVkLiBJbiBhZGRpdGlvbiwgYWZ0ZXIgYSBuZXcgdmVyc2lvbiBvZgotdGhlIEFncmVlbWVudCBpcyBwdWJsaXNoZWQsIENvbnRyaWJ1dG9yIG1heSBlbGVjdCB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtCi0oaW5jbHVkaW5nIGl0cyBDb250cmlidXRpb25zKSB1bmRlciB0aGUgbmV3IHZlcnNpb24uIEV4Y2VwdCBhcyBleHByZXNzbHkgc3RhdGVkCi1pbiBTZWN0aW9ucyAyKGEpIGFuZCAyKGIpIGFib3ZlLCBSZWNpcGllbnQgcmVjZWl2ZXMgbm8gcmlnaHRzIG9yIGxpY2Vuc2VzIHRvCi10aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IG9mIGFueSBDb250cmlidXRvciB1bmRlciB0aGlzIEFncmVlbWVudCwgd2hldGhlcgotZXhwcmVzc2x5LCBieSBpbXBsaWNhdGlvbiwgZXN0b3BwZWwgb3Igb3RoZXJ3aXNlLiBBbGwgcmlnaHRzIGluIHRoZSBQcm9ncmFtIG5vdAotZXhwcmVzc2x5IGdyYW50ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYXJlIHJlc2VydmVkLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+VGhpcyBBZ3JlZW1lbnQgaXMgZ292ZXJuZWQgYnkgdGhlIGxhd3Mgb2YgdGhlCi1TdGF0ZSBvZiBOZXcgWW9yayBhbmQgdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBsYXdzIG9mIHRoZSBVbml0ZWQgU3RhdGVzIG9mCi1BbWVyaWNhLiBObyBwYXJ0eSB0byB0aGlzIEFncmVlbWVudCB3aWxsIGJyaW5nIGEgbGVnYWwgYWN0aW9uIHVuZGVyIHRoaXMKLUFncmVlbWVudCBtb3JlIHRoYW4gb25lIHllYXIgYWZ0ZXIgdGhlIGNhdXNlIG9mIGFjdGlvbiBhcm9zZS4gRWFjaCBwYXJ0eSB3YWl2ZXMKLWl0cyByaWdodHMgdG8gYSBqdXJ5IHRyaWFsIGluIGFueSByZXN1bHRpbmcgbGl0aWdhdGlvbi48L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjwhW2lmICFzdXBwb3J0RW1wdHlQYXJhc10+Jm5ic3A7PCFbZW5kaWZdPjxvOnA+PC9vOnA+PC9wPgotCi08L2Rpdj4KLQotPC9ib2R5PgotCi08L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0L2ZlYXR1cmUucHJvcGVydGllcyBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC9mZWF0dXJlLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDBhZTQyYmIuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0L2ZlYXR1cmUucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDE0NCArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIGZlYXR1cmUucHJvcGVydGllcwotIyBjb250YWlucyBleHRlcm5hbGl6ZWQgc3RyaW5ncyBmb3IgZmVhdHVyZS54bWwKLSMgIiVmb28iIGluIGZlYXR1cmUueG1sIGNvcnJlc3BvbmRzIHRvIHRoZSBrZXkgImZvbyIgaW4gdGhpcyBmaWxlCi0jIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCi0jIFRoaXMgZmlsZSBzaG91bGQgYmUgdHJhbnNsYXRlZC4KLQotIyAiZmVhdHVyZU5hbWUiIHByb3BlcnR5IC0gbmFtZSBvZiB0aGUgZmVhdHVyZQotZmVhdHVyZU5hbWU9SmF2YSBQZXJzaXN0ZW5jZSBBUEkgVG9vbHMKLQotIyAicHJvdmlkZXJOYW1lIiBwcm9wZXJ0eSAtIG5hbWUgb2YgdGhlIGNvbXBhbnkgdGhhdCBwcm92aWRlcyB0aGUgZmVhdHVyZQotcHJvdmlkZXJOYW1lPUVjbGlwc2Uub3JnCi0KLSMgInVwZGF0ZVNpdGVOYW1lIiBwcm9wZXJ0eSAtIGxhYmVsIGZvciB0aGUgdXBkYXRlIHNpdGUKLXVwZGF0ZVNpdGVOYW1lPVRoZSBFY2xpcHNlIFdlYiBUb29scyBQbGF0Zm9ybSAoV1RQKSBQcm9qZWN0IHVwZGF0ZSBzaXRlCi0KLSMgImRlc2NyaXB0aW9uIiBwcm9wZXJ0eSAtIGRlc2NyaXB0aW9uIG9mIHRoZSBmZWF0dXJlCi1kZXNjcmlwdGlvbj1KYXZhIFBlcnNpc3RlbmNlIEFQSSBUb29scyAtIFJ1bnRpbWUKLQotIyAiY29weXJpZ2h0IiBwcm9wZXJ0eSAtIHRleHQgb2YgdGhlICJGZWF0dXJlIFVwZGF0ZSBDb3B5cmlnaHQiCi1jb3B5cmlnaHQ9XAotQ29weXJpZ2h0IChjKSAyMDA2IE9yYWNsZSBDb3Jwb3JhdGlvbi5cblwKLUFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHNcblwKLWFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMFxuXAotd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXRcblwKLWh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sXG5cCi1cblwKLUNvbnRyaWJ1dG9yczpcblwKLSAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb25cbgotIyMjIyMjIyMjIyMjIyMjIyBlbmQgb2YgY29weXJpZ2h0IHByb3BlcnR5ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotCi0jICJsaWNlbnNlVVJMIiBwcm9wZXJ0eSAtIFVSTCBvZiB0aGUgIkZlYXR1cmUgTGljZW5zZSIKLSMgZG8gbm90IHRyYW5zbGF0ZSB2YWx1ZSAtIGp1c3QgY2hhbmdlIHRvIHBvaW50IHRvIGEgbG9jYWxlLXNwZWNpZmljIEhUTUwgcGFnZQotbGljZW5zZVVSTD1saWNlbnNlLmh0bWwKLQotIyAibGljZW5zZSIgcHJvcGVydHkgLSB0ZXh0IG9mIHRoZSAiRmVhdHVyZSBVcGRhdGUgTGljZW5zZSIKLSMgc2hvdWxkIGJlIHBsYWluIHRleHQgdmVyc2lvbiBvZiBsaWNlbnNlIGFncmVlbWVudCBwb2ludGVkIHRvIGJlICJsaWNlbnNlVVJMIgotbGljZW5zZT1cCi1FQ0xJUFNFIEZPVU5EQVRJT04gU09GVFdBUkUgVVNFUiBBR1JFRU1FTlRcblwKLU1hcmNoIDE3LCAyMDA1XG5cCi1cblwKLVVzYWdlIE9mIENvbnRlbnRcblwKLVxuXAotVEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUlxuXAotT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUyAoQ09MTEVDVElWRUxZICJDT05URU5UIikuXG5cCi1VU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVNcblwKLUFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUlxuXAotTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVVxuXAotQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVFxuXAotQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFNcblwKLU9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFXG5cCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TXG5cCi1PRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRFxuXAotQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULlxuXAotXG5cCi1BcHBsaWNhYmxlIExpY2Vuc2VzXG5cCi1cblwKLVVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uXG5cCi1pcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpY1xuXAotTGljZW5zZSBWZXJzaW9uIDEuMCAoIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXNcblwKLUNvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLlxuXAotRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuXG5cCi1cblwKLUNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLFxuXAotZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZS5vcmcgQ1ZTXG5cCi1yZXBvc2l0b3J5ICgiUmVwb3NpdG9yeSIpIGluIENWUyBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIGF2YWlsYWJsZVxuXAotYXMgZG93bmxvYWRhYmxlIGFyY2hpdmVzICgiRG93bmxvYWRzIikuXG5cCi1cblwKLSAgIC0gQ29udGVudCBtYXkgYmUgc3RydWN0dXJlZCBhbmQgcGFja2FnZWQgaW50byBtb2R1bGVzIHRvIGZhY2lsaXRhdGUgZGVsaXZlcmluZyxcblwKLSAgICAgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiBUeXBpY2FsIG1vZHVsZXMgbWF5IGluY2x1ZGUgcGx1Zy1pbnMgKCJQbHVnLWlucyIpLFxuXAotICAgICBwbHVnLWluIGZyYWdtZW50cyAoIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLlxuXAotICAgLSBFYWNoIFBsdWctaW4gb3IgRnJhZ21lbnQgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBvciBKQVIgKEphdmE/IEFSY2hpdmUpXG5cCi0gICAgIGluIGEgZGlyZWN0b3J5IG5hbWVkICJwbHVnaW5zIi5cblwKLSAgIC0gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuXG5cCi0gICAgIEVhY2ggRmVhdHVyZSBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IGluIGEgZGlyZWN0b3J5IG5hbWVkICJmZWF0dXJlcyIuXG5cCi0gICAgIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvblxuXAotICAgICBudW1iZXJzIG9mIHRoZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuXG5cCi0gICAtIEZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlc1xuXAotICAgICBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy5cblwKLVxuXAotRmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIEZpbGVzIG5hbWVkXG5cCi0iZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZlxuXAotSW5jbHVkZWQgRmVhdHVyZXMuXG5cCi1cblwKLVRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmVcblwKLWNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZFxuXAotY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kIEluY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWRcblwKLWluIGZpbGVzIG5hbWVkICJsaWNlbnNlLmh0bWwiICgiRmVhdHVyZSBMaWNlbnNlcyIpLiBBYm91dHMgYW5kIEZlYXR1cmVcblwKLUxpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSBkaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGVcblwKLWluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOlxuXAotXG5cCi0gICAtIFRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeVxuXAotICAgLSBQbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3Rvcmllc1xuXAotICAgLSBJbnNpZGUgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBwYWNrYWdlZCBhcyBKQVJzXG5cCi0gICAtIFN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnNcblwKLSAgIC0gRmVhdHVyZSBkaXJlY3Rvcmllc1xuXAotXG5cCi1Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlXG5cCi1FY2xpcHNlIFVwZGF0ZSBNYW5hZ2VyLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFVwZGF0ZVxuXAotTGljZW5zZSIpIGR1cmluZyB0aGUgaW5zdGFsbGF0aW9uIHByb2Nlc3MuIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zXG5cCi1JbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdVxuXAotd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvciBpbmZvcm1cblwKLXlvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW5cblwKLXRoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIuIFN1Y2ggQWJvdXRzLFxuXAotRmVhdHVyZSBMaWNlbnNlcyBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kXG5cCi1jb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXJcblwKLXVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluIHRoYXQgZGlyZWN0b3J5LlxuXAotXG5cCi1USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVJcblwKLVRPIFRIRSBFUEwgT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLlxuXAotU09NRSBPRiBUSEVTRSBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOlxuXAotXG5cCi0gICAgLSBDb21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbClcblwKLSAgICAtIEFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFKVxuXAotICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wKVxuXAotICAgIC0gSUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sKVxuXAotICAgIC0gTWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwpXG5cCi0gICAgLSBNb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sKVxuXAotXG5cCi1JVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCBDT05ESVRJT05TIFBSSU9SXG5cCi1UTyBVU0UgT0YgVEhFIENPTlRFTlQuIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2Ugb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZVxuXAotaXMgcHJvdmlkZWQsIHBsZWFzZSBjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIGNvbmRpdGlvbnNcblwKLWdvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC5cblwKLVxuXAotQ3J5cHRvZ3JhcGh5XG5cCi1cblwKLUNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZVxuXAotY3VycmVudGx5IG1heSBoYXZlIHJlc3RyaWN0aW9ucyBvbiB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBhbmQgdXNlLFxuXAotYW5kL29yIHJlLWV4cG9ydCB0byBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRVxuXAotdXNpbmcgYW55IGVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsXG5cCi1yZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgY29uY2VybmluZyB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBvciB1c2UsXG5cCi1hbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIHRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC5cblwKLVxuXAotSmF2YSBhbmQgYWxsIEphdmEtYmFzZWQgdHJhZGVtYXJrcyBhcmUgdHJhZGVtYXJrcyBvZiBTdW4gTWljcm9zeXN0ZW1zLCBJbmMuIGluIHRoZSBVbml0ZWQgU3RhdGVzLCBvdGhlciBjb3VudHJpZXMsIG9yIGJvdGguXG4KLSMjIyMjIyMjIyMjIGVuZCBvZiBsaWNlbnNlIHByb3BlcnR5ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0L2ZlYXR1cmUueG1sIGIvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0L2ZlYXR1cmUueG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkMzNmOTNmLi4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC9mZWF0dXJlLnhtbAorKysgL2Rldi9udWxsCkBAIC0xLDQyICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08ZmVhdHVyZQotICAgICAgaWQ9Im9yZy5lY2xpcHNlLmpwdCIKLSAgICAgIGxhYmVsPSIlZmVhdHVyZU5hbWUiCi0gICAgICB2ZXJzaW9uPSIyLjEuMC5xdWFsaWZpZXIiCi0gICAgICBwcm92aWRlci1uYW1lPSIlcHJvdmlkZXJOYW1lIgotICAgICAgcGx1Z2luPSJvcmcuZWNsaXBzZS5qcHQiCi0gICAgICBpbWFnZT0iZWNsaXBzZV91cGRhdGVfMTIwLmpwZyI+Ci0KLSAgIDxkZXNjcmlwdGlvbj4KLSAgICAgICVkZXNjcmlwdGlvbgotICAgPC9kZXNjcmlwdGlvbj4KLQotICAgPGNvcHlyaWdodD4KLSAgICAgICVjb3B5cmlnaHQKLSAgIDwvY29weXJpZ2h0PgotCi0gICA8bGljZW5zZSB1cmw9ImxpY2Vuc2UuaHRtbCI+Ci0gICAgICAlbGljZW5zZQotICAgPC9saWNlbnNlPgotCi0gICA8dXJsPgotICAgICAgPHVwZGF0ZSBsYWJlbD0iJXVwZGF0ZVNpdGVOYW1lIiB1cmw9Imh0dHA6Ly9kb3dubG9hZC5lY2xpcHNlLm9yZy93ZWJ0b29scy91cGRhdGVzIi8+Ci0gICAgICA8ZGlzY292ZXJ5IGxhYmVsPSJXZWIgVG9vbHMgUGxhdGZvcm0gKFdUUCkgVXBkYXRlcyIgdXJsPSJodHRwOi8vZG93bmxvYWQuZWNsaXBzZS5vcmcvd2VidG9vbHMvdXBkYXRlcyIvPgotICAgPC91cmw+Ci0KLSAgIDxpbmNsdWRlcwotICAgICAgICAgaWQ9Im9yZy5lY2xpcHNlLmpwdC5mZWF0dXJlIgotICAgICAgICAgdmVyc2lvbj0iMC4wLjAiLz4KLQotICAgPGluY2x1ZGVzCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUiCi0gICAgICAgICB2ZXJzaW9uPSIwLjAuMCIvPgotCi0gICA8cGx1Z2luCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0IgotICAgICAgICAgZG93bmxvYWQtc2l6ZT0iMCIKLSAgICAgICAgIGluc3RhbGwtc2l6ZT0iMCIKLSAgICAgICAgIHZlcnNpb249IjAuMC4wIgotICAgICAgICAgdW5wYWNrPSJmYWxzZSIvPgotCi08L2ZlYXR1cmU+CmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQvbGljZW5zZS5odG1sIGIvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0L2xpY2Vuc2UuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjM0NzA2MC4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQvbGljZW5zZS5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsOTMgKzAsMCBAQAotPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEgVHJhbnNpdGlvbmFsLy9FTiIgImh0dHA6Ly93d3cudzNjLm9yZy9UUi8xOTk5L1JFQy1odG1sNDAxLTE5OTkxMjI0L2xvb3NlLmR0ZCI+Ci08IS0tIHNhdmVkIGZyb20gdXJsPSgwMDQ0KWh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsL25vdGljZS5odG1sIC0tPgotPEhUTUw+PEhFQUQ+PFRJVExFPkVjbGlwc2Uub3JnIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9USVRMRT4KLTxNRVRBIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4KLTxNRVRBIGNvbnRlbnQ9Ik1TSFRNTCA2LjAwLjI4MDAuMTQ3OSIgbmFtZT1HRU5FUkFUT1I+PC9IRUFEPgotPEJPRFkgbGFuZz1FTi1VUyB2TGluaz1wdXJwbGUgbGluaz1ibHVlPgotPEgyPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvSDI+Ci08UD5KYW51YXJ5IDI4LCAyMDA1PC9QPgotPEgzPlVzYWdlIE9mIENvbnRlbnQ8L0gzPgotPFA+VEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIAotQU5EL09SIE9USEVSIE1BVEVSSUFMUyBGT1IgT1BFTiBTT1VSQ0UgUFJPSkVDVFMgKENPTExFQ1RJVkVMWSAiQ09OVEVOVCIpLiBVU0UgT0YgCi1USEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSAKLVRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIAotQkVMT1cuIEJZIFVTSU5HIFRIRSBDT05URU5ULCBZT1UgQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCAKLUJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSAKLUFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSAKLUFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIAotTUFZIE5PVCBVU0UgVEhFIENPTlRFTlQuPC9QPgotPEgzPkFwcGxpY2FibGUgTGljZW5zZXM8L0gzPgotPFA+VW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIAotRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIAotUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKCJFUEwiKS4gQSBjb3B5IG9mIHRoZSBFUEwgaXMgcHJvdmlkZWQgd2l0aCB0aGlzIAotQ29udGVudCBhbmQgaXMgYWxzbyBhdmFpbGFibGUgYXQgPEEgCi1ocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L0E+LiAKLUZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAiUHJvZ3JhbSIgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvUD4KLTxQPkNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLCAKLWRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2Uub3JnIENWUyByZXBvc2l0b3J5IAotKCJSZXBvc2l0b3J5IikgaW4gQ1ZTIG1vZHVsZXMgKCJNb2R1bGVzIikgYW5kIG1hZGUgYXZhaWxhYmxlIGFzIGRvd25sb2FkYWJsZSAKLWFyY2hpdmVzICgiRG93bmxvYWRzIikuPC9QPgotPFA+Q29udGVudCBtYXkgYmUgYXBwb3J0aW9uZWQgaW50byBwbHVnLWlucyAoIlBsdWctaW5zIiksIHBsdWctaW4gZnJhZ21lbnRzIAotKCJGcmFnbWVudHMiKSwgYW5kIGZlYXR1cmVzICgiRmVhdHVyZXMiKS4gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIAotUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhbmQgYXNzb2NpYXRlZCBtYXRlcmlhbC4gRmlsZXMgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgCi1jb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyAKLWFzc29jaWF0ZWQgd2l0aCBhIEZlYXR1cmUuIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgYXJlIGxvY2F0ZWQgaW4gZGlyZWN0b3JpZXMgCi1uYW1lZCAicGx1Z2lucyIgYW5kIEZlYXR1cmVzIGFyZSBsb2NhdGVkIGluIGRpcmVjdG9yaWVzIG5hbWVkICJmZWF0dXJlcyIuPC9QPgotPFA+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIEZpbGVzIG5hbWVkIAotImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgCi1GZWF0dXJlcy48L1A+Ci08UD5UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlIGNvbnRhaW5lZCAKLWluIGZpbGVzIG5hbWVkICJhYm91dC5odG1sIiAoIkFib3V0cyIpLiBUaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIAotRmVhdHVyZXMgYW5kIEluY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgImxpY2Vuc2UuaHRtbCIgCi0oIkZlYXR1cmUgTGljZW5zZXMiKS4gQWJvdXRzIGFuZCBGZWF0dXJlIExpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSAKLWRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZSBpbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIAotbG9jYXRpb25zOjwvUD4KLTxVTD4KLSAgPExJPlRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeSAKLSAgPExJPlBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzIAotICA8TEk+U3ViZGlyZWN0b3JpZXMgb2YgdGhlIGRpcmVjdG9yeSBuYW1lZCAic3JjIiBvZiBjZXJ0YWluIFBsdWctaW5zIAotICA8TEk+RmVhdHVyZSBkaXJlY3RvcmllcyA8L0xJPjwvVUw+Ci08UD5Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgCi11c2luZyB0aGUgRWNsaXBzZSBVcGRhdGUgTWFuYWdlciwgeW91IG11c3QgYWdyZWUgdG8gYSBsaWNlbnNlICgiRmVhdHVyZSBVcGRhdGUgCi1MaWNlbnNlIikgZHVyaW5nIHRoZSBpbnN0YWxsYXRpb24gcHJvY2Vzcy4gSWYgdGhlIEZlYXR1cmUgY29udGFpbnMgSW5jbHVkZWQgCi1GZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdSB3aXRoIHRoZSB0ZXJtcyAKLWFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IgaW5mb3JtIHlvdSB3aGVyZSB5b3UgY2FuIAotbG9jYXRlIHRoZW0uIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSBmb3VuZCBpbiB0aGUgImxpY2Vuc2UiIHByb3BlcnR5IG9mIAotZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIuIFN1Y2ggQWJvdXRzLCBGZWF0dXJlIExpY2Vuc2VzIGFuZCBGZWF0dXJlIAotVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgCi1hbmQgY29uZGl0aW9ucykgdGhhdCBnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbiB0aGF0IAotZGlyZWN0b3J5LjwvUD4KLTxQPlRIRSBBQk9VVFMsIEZFQVRVUkUgTElDRU5TRVMgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUiBUTyBUSEUgRVBMIAotT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLiBTT01FIE9GIFRIRVNFIAotT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTo8L1A+Ci08VUw+Ci0gIDxMST5Db21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sPC9BPikgCi0KLSAgPExJPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRSI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0U8L0E+KSAKLQotICA8TEk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMCI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wPC9BPikgCi0KLSAgPExJPklCTSBQdWJsaWMgTGljZW5zZSAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2RldmVsb3BlcndvcmtzL29wZW5zb3VyY2UvbGljZW5zZTEwLmh0bWwiPmh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sPC9BPikgCi0KLSAgPExJPk1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbCI+aHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWw8L0E+KSAKLQotICA8TEk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWwiPmh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbDwvQT4pIAotICA8L0xJPjwvVUw+Ci08UD5JVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCBDT05ESVRJT05TIFBSSU9SIAotVE8gVVNFIE9GIFRIRSBDT05URU5ULiBJZiBubyBBYm91dCwgRmVhdHVyZSBMaWNlbnNlIG9yIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2UgaXMgCi1wcm92aWRlZCwgcGxlYXNlIGNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgCi1jb25kaXRpb25zIGdvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC48L1A+Ci08SDM+Q3J5cHRvZ3JhcGh5PC9IMz4KLTxQPkNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZSAKLWN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSwgYW5kL29yIAotcmUtZXhwb3J0IHRvIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFIHVzaW5nIGFueSAKLWVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsIHJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyAKLWNvbmNlcm5pbmcgdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgb3IgdXNlLCBhbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIAotdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLjwvUD48L0JPRFk+PC9IVE1MPgpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5hc3NlbWJseS5mZWF0dXJlLy5jdnNpZ25vcmUgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHRfc2RrLmFzc2VtYmx5LmZlYXR1cmUvLmN2c2lnbm9yZQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmMyYWJmNy4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHRfc2RrLmFzc2VtYmx5LmZlYXR1cmUvLmN2c2lnbm9yZQorKysgL2Rldi9udWxsCkBAIC0xLDQgKzAsMCBAQAotKi5iaW4uZGlzdC56aXAKLWJ1aWxkLnhtbAotZmVhdHVyZXMKLXBsdWdpbnMKZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuYXNzZW1ibHkuZmVhdHVyZS8ucHJvamVjdCBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuYXNzZW1ibHkuZmVhdHVyZS8ucHJvamVjdApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTkwMTM3Mi4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHRfc2RrLmFzc2VtYmx5LmZlYXR1cmUvLnByb2plY3QKKysrIC9kZXYvbnVsbApAQCAtMSwxNyArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPHByb2plY3REZXNjcmlwdGlvbj4KLQk8bmFtZT5vcmcuZWNsaXBzZS5qcHRfc2RrLmFzc2VtYmx5LmZlYXR1cmU8L25hbWU+Ci0JPGNvbW1lbnQ+PC9jb21tZW50PgotCTxwcm9qZWN0cz4KLQk8L3Byb2plY3RzPgotCTxidWlsZFNwZWM+Ci0JCTxidWlsZENvbW1hbmQ+Ci0JCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuRmVhdHVyZUJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCTwvYnVpbGRTcGVjPgotCTxuYXR1cmVzPgotCQk8bmF0dXJlPm9yZy5lY2xpcHNlLnBkZS5GZWF0dXJlTmF0dXJlPC9uYXR1cmU+Ci0JPC9uYXR1cmVzPgotPC9wcm9qZWN0RGVzY3JpcHRpb24+CmRpZmYgLS1naXQgYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHRfc2RrLmFzc2VtYmx5LmZlYXR1cmUvYnVpbGQucHJvcGVydGllcyBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuYXNzZW1ibHkuZmVhdHVyZS9idWlsZC5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3MjAwOTM5Li4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuYXNzZW1ibHkuZmVhdHVyZS9idWlsZC5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTUgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBDb3B5cmlnaHQgKGMpIDIwMDYgT3JhY2xlLgotIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCi0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAotIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAotIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlLiAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotYmluLmluY2x1ZGVzID0gZmVhdHVyZS54bWwsXAotICAgICAgICAgICAgICAgZWNsaXBzZV91cGRhdGVfMTIwLmpwZyxcCi0gICAgICAgICAgICAgICBlcGwtdjEwLmh0bWwsXAotICAgICAgICAgICAgICAgbGljZW5zZS5odG1sLFwKLSAgICAgICAgICAgICAgIGZlYXR1cmUucHJvcGVydGllcwpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5hc3NlbWJseS5mZWF0dXJlL2VjbGlwc2VfdXBkYXRlXzEyMC5qcGcgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHRfc2RrLmFzc2VtYmx5LmZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmZkZjcwOC4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHRfc2RrLmFzc2VtYmx5LmZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuYXNzZW1ibHkuZmVhdHVyZS9lcGwtdjEwLmh0bWwgYi9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHRfc2RrLmFzc2VtYmx5LmZlYXR1cmUvZXBsLXYxMC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlZDRiMTk2Li4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuYXNzZW1ibHkuZmVhdHVyZS9lcGwtdjEwLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSwzMjggKzAsMCBAQAotPGh0bWwgeG1sbnM6bz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6b2ZmaWNlIgoteG1sbnM6dz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6d29yZCIKLXhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy9UUi9SRUMtaHRtbDQwIj4KLQotPGhlYWQ+Ci08bWV0YSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9d2luZG93cy0xMjUyIj4KLTxtZXRhIG5hbWU9UHJvZ0lkIGNvbnRlbnQ9V29yZC5Eb2N1bWVudD4KLTxtZXRhIG5hbWU9R2VuZXJhdG9yIGNvbnRlbnQ9Ik1pY3Jvc29mdCBXb3JkIDkiPgotPG1ldGEgbmFtZT1PcmlnaW5hdG9yIGNvbnRlbnQ9Ik1pY3Jvc29mdCBXb3JkIDkiPgotPGxpbmsgcmVsPUZpbGUtTGlzdAotaHJlZj0iLi9FY2xpcHNlJTIwRVBMJTIwMjAwM18xMV8xMCUyMEZpbmFsX2ZpbGVzL2ZpbGVsaXN0LnhtbCI+Ci08dGl0bGU+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIFZlcnNpb24gMS4wPC90aXRsZT4KLTwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDxvOkRvY3VtZW50UHJvcGVydGllcz4KLSAgPG86UmV2aXNpb24+MjwvbzpSZXZpc2lvbj4KLSAgPG86VG90YWxUaW1lPjM8L286VG90YWxUaW1lPgotICA8bzpDcmVhdGVkPjIwMDQtMDMtMDVUMjM6MDM6MDBaPC9vOkNyZWF0ZWQ+Ci0gIDxvOkxhc3RTYXZlZD4yMDA0LTAzLTA1VDIzOjAzOjAwWjwvbzpMYXN0U2F2ZWQ+Ci0gIDxvOlBhZ2VzPjQ8L286UGFnZXM+Ci0gIDxvOldvcmRzPjE2MjY8L286V29yZHM+Ci0gIDxvOkNoYXJhY3RlcnM+OTI3MDwvbzpDaGFyYWN0ZXJzPgotICAgPG86TGluZXM+Nzc8L286TGluZXM+Ci0gIDxvOlBhcmFncmFwaHM+MTg8L286UGFyYWdyYXBocz4KLSAgPG86Q2hhcmFjdGVyc1dpdGhTcGFjZXM+MTEzODQ8L286Q2hhcmFjdGVyc1dpdGhTcGFjZXM+Ci0gIDxvOlZlcnNpb24+OS40NDAyPC9vOlZlcnNpb24+Ci0gPC9vOkRvY3VtZW50UHJvcGVydGllcz4KLTwveG1sPjwhW2VuZGlmXS0tPjwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDx3OldvcmREb2N1bWVudD4KLSAgPHc6VHJhY2tSZXZpc2lvbnMvPgotIDwvdzpXb3JkRG9jdW1lbnQ+Ci08L3htbD48IVtlbmRpZl0tLT4KLTxzdHlsZT4KLTwhLS0KLSAvKiBGb250IERlZmluaXRpb25zICovCi1AZm9udC1mYWNlCi0Je2ZvbnQtZmFtaWx5OlRhaG9tYTsKLQlwYW5vc2UtMToyIDExIDYgNCAzIDUgNCA0IDIgNDsKLQltc28tZm9udC1jaGFyc2V0OjA7Ci0JbXNvLWdlbmVyaWMtZm9udC1mYW1pbHk6c3dpc3M7Ci0JbXNvLWZvbnQtcGl0Y2g6dmFyaWFibGU7Ci0JbXNvLWZvbnQtc2lnbmF0dXJlOjU1MzY3OTQ5NSAtMjE0NzQ4MzY0OCA4IDAgNjYwNDcgMDt9Ci0gLyogU3R5bGUgRGVmaW5pdGlvbnMgKi8KLXAuTXNvTm9ybWFsLCBsaS5Nc29Ob3JtYWwsIGRpdi5Nc29Ob3JtYWwKLQl7bXNvLXN0eWxlLXBhcmVudDoiIjsKLQltYXJnaW46MGluOwotCW1hcmdpbi1ib3R0b206LjAwMDFwdDsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjEyLjBwdDsKLQlmb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1wCi0Je21hcmdpbi1yaWdodDowaW47Ci0JbXNvLW1hcmdpbi10b3AtYWx0OmF1dG87Ci0JbXNvLW1hcmdpbi1ib3R0b20tYWx0OmF1dG87Ci0JbWFyZ2luLWxlZnQ6MGluOwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXAuQmFsbG9vblRleHQsIGxpLkJhbGxvb25UZXh0LCBkaXYuQmFsbG9vblRleHQKLQl7bXNvLXN0eWxlLW5hbWU6IkJhbGxvb24gVGV4dCI7Ci0JbWFyZ2luOjBpbjsKLQltYXJnaW4tYm90dG9tOi4wMDAxcHQ7Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZTo4LjBwdDsKLQlmb250LWZhbWlseTpUYWhvbWE7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotQHBhZ2UgU2VjdGlvbjEKLQl7c2l6ZTo4LjVpbiAxMS4waW47Ci0JbWFyZ2luOjEuMGluIDEuMjVpbiAxLjBpbiAxLjI1aW47Ci0JbXNvLWhlYWRlci1tYXJnaW46LjVpbjsKLQltc28tZm9vdGVyLW1hcmdpbjouNWluOwotCW1zby1wYXBlci1zb3VyY2U6MDt9Ci1kaXYuU2VjdGlvbjEKLQl7cGFnZTpTZWN0aW9uMTt9Ci0tLT4KLTwvc3R5bGU+Ci08L2hlYWQ+Ci0KLTxib2R5IGxhbmc9RU4tVVMgc3R5bGU9J3RhYi1pbnRlcnZhbDouNWluJz4KLQotPGRpdiBjbGFzcz1TZWN0aW9uMT4KLQotPHAgYWxpZ249Y2VudGVyIHN0eWxlPSd0ZXh0LWFsaWduOmNlbnRlcic+PGI+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIHYgMS4wPC9iPgotPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+VEhFIEFDQ09NUEFOWUlORyBQUk9HUkFNIElTIFBST1ZJREVEIFVOREVSCi1USEUgVEVSTVMgT0YgVEhJUyBFQ0xJUFNFIFBVQkxJQyBMSUNFTlNFICgmcXVvdDtBR1JFRU1FTlQmcXVvdDspLiBBTlkgVVNFLAotUkVQUk9EVUNUSU9OIE9SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBDT05TVElUVVRFUyBSRUNJUElFTlQnUyBBQ0NFUFRBTkNFCi1PRiBUSElTIEFHUkVFTUVOVC48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjEuIERFRklOSVRJT05TPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7Q29udHJpYnV0aW9uJnF1b3Q7IG1lYW5zOjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaW4gdGhlIGNhc2Ugb2YgdGhlIGluaXRpYWwgQ29udHJpYnV0b3IsIHRoZSBpbml0aWFsIGNvZGUgYW5kIGRvY3VtZW50YXRpb24KLWRpc3RyaWJ1dGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBhbmQ8YnIgY2xlYXI9bGVmdD4KLWIpIGluIHRoZSBjYXNlIG9mIGVhY2ggc3Vic2VxdWVudCBDb250cmlidXRvcjo8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pKQotY2hhbmdlcyB0byB0aGUgUHJvZ3JhbSwgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWkpCi1hZGRpdGlvbnMgdG8gdGhlIFByb2dyYW07PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+d2hlcmUKLXN1Y2ggY2hhbmdlcyBhbmQvb3IgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIG9yaWdpbmF0ZSBmcm9tIGFuZCBhcmUgZGlzdHJpYnV0ZWQKLWJ5IHRoYXQgcGFydGljdWxhciBDb250cmlidXRvci4gQSBDb250cmlidXRpb24gJ29yaWdpbmF0ZXMnIGZyb20gYSBDb250cmlidXRvcgotaWYgaXQgd2FzIGFkZGVkIHRvIHRoZSBQcm9ncmFtIGJ5IHN1Y2ggQ29udHJpYnV0b3IgaXRzZWxmIG9yIGFueW9uZSBhY3Rpbmcgb24KLXN1Y2ggQ29udHJpYnV0b3IncyBiZWhhbGYuIENvbnRyaWJ1dGlvbnMgZG8gbm90IGluY2x1ZGUgYWRkaXRpb25zIHRvIHRoZQotUHJvZ3JhbSB3aGljaDogKGkpIGFyZSBzZXBhcmF0ZSBtb2R1bGVzIG9mIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIGluIGNvbmp1bmN0aW9uCi13aXRoIHRoZSBQcm9ncmFtIHVuZGVyIHRoZWlyIG93biBsaWNlbnNlIGFncmVlbWVudCwgYW5kIChpaSkgYXJlIG5vdCBkZXJpdmF0aXZlCi13b3JrcyBvZiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0NvbnRyaWJ1dG9yJnF1b3Q7IG1lYW5zIGFueSBwZXJzb24gb3IKLWVudGl0eSB0aGF0IGRpc3RyaWJ1dGVzIHRoZSBQcm9ncmFtLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7TGljZW5zZWQgUGF0ZW50cyAmcXVvdDsgbWVhbiBwYXRlbnQKLWNsYWltcyBsaWNlbnNhYmxlIGJ5IGEgQ29udHJpYnV0b3Igd2hpY2ggYXJlIG5lY2Vzc2FyaWx5IGluZnJpbmdlZCBieSB0aGUgdXNlCi1vciBzYWxlIG9mIGl0cyBDb250cmlidXRpb24gYWxvbmUgb3Igd2hlbiBjb21iaW5lZCB3aXRoIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7UHJvZ3JhbSZxdW90OyBtZWFucyB0aGUgQ29udHJpYnV0aW9ucwotZGlzdHJpYnV0ZWQgaW4gYWNjb3JkYW5jZSB3aXRoIHRoaXMgQWdyZWVtZW50Ljwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7UmVjaXBpZW50JnF1b3Q7IG1lYW5zIGFueW9uZSB3aG8KLXJlY2VpdmVzIHRoZSBQcm9ncmFtIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBpbmNsdWRpbmcgYWxsIENvbnRyaWJ1dG9ycy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjIuIEdSQU5UIE9GIFJJR0hUUzwvc3Bhbj48L2I+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLVN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50Ci1hIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwgcm95YWx0eS1mcmVlIGNvcHlyaWdodCBsaWNlbnNlIHRvPHNwYW4KLXN0eWxlPSdjb2xvcjpyZWQnPiA8L3NwYW4+cmVwcm9kdWNlLCBwcmVwYXJlIGRlcml2YXRpdmUgd29ya3Mgb2YsIHB1YmxpY2x5Ci1kaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBkaXN0cmlidXRlIGFuZCBzdWJsaWNlbnNlIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaAotQ29udHJpYnV0b3IsIGlmIGFueSwgYW5kIHN1Y2ggZGVyaXZhdGl2ZSB3b3JrcywgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlCi1mb3JtLjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpCi1TdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzCi1SZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsPHNwYW4gc3R5bGU9J2NvbG9yOmdyZWVuJz4gPC9zcGFuPnJveWFsdHktZnJlZQotcGF0ZW50IGxpY2Vuc2UgdW5kZXIgTGljZW5zZWQgUGF0ZW50cyB0byBtYWtlLCB1c2UsIHNlbGwsIG9mZmVyIHRvIHNlbGwsIGltcG9ydAotYW5kIG90aGVyd2lzZSB0cmFuc2ZlciB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgaW4gc291cmNlCi1jb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLiBUaGlzIHBhdGVudCBsaWNlbnNlIHNoYWxsIGFwcGx5IHRvIHRoZSBjb21iaW5hdGlvbgotb2YgdGhlIENvbnRyaWJ1dGlvbiBhbmQgdGhlIFByb2dyYW0gaWYsIGF0IHRoZSB0aW1lIHRoZSBDb250cmlidXRpb24gaXMgYWRkZWQKLWJ5IHRoZSBDb250cmlidXRvciwgc3VjaCBhZGRpdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGNhdXNlcyBzdWNoIGNvbWJpbmF0aW9uCi10byBiZSBjb3ZlcmVkIGJ5IHRoZSBMaWNlbnNlZCBQYXRlbnRzLiBUaGUgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgbm90IGFwcGx5IHRvCi1hbnkgb3RoZXIgY29tYmluYXRpb25zIHdoaWNoIGluY2x1ZGUgdGhlIENvbnRyaWJ1dGlvbi4gTm8gaGFyZHdhcmUgcGVyIHNlIGlzCi1saWNlbnNlZCBoZXJldW5kZXIuIDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmMpCi1SZWNpcGllbnQgdW5kZXJzdGFuZHMgdGhhdCBhbHRob3VnaCBlYWNoIENvbnRyaWJ1dG9yIGdyYW50cyB0aGUgbGljZW5zZXMgdG8gaXRzCi1Db250cmlidXRpb25zIHNldCBmb3J0aCBoZXJlaW4sIG5vIGFzc3VyYW5jZXMgYXJlIHByb3ZpZGVkIGJ5IGFueSBDb250cmlidXRvcgotdGhhdCB0aGUgUHJvZ3JhbSBkb2VzIG5vdCBpbmZyaW5nZSB0aGUgcGF0ZW50IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQotcmlnaHRzIG9mIGFueSBvdGhlciBlbnRpdHkuIEVhY2ggQ29udHJpYnV0b3IgZGlzY2xhaW1zIGFueSBsaWFiaWxpdHkgdG8gUmVjaXBpZW50Ci1mb3IgY2xhaW1zIGJyb3VnaHQgYnkgYW55IG90aGVyIGVudGl0eSBiYXNlZCBvbiBpbmZyaW5nZW1lbnQgb2YgaW50ZWxsZWN0dWFsCi1wcm9wZXJ0eSByaWdodHMgb3Igb3RoZXJ3aXNlLiBBcyBhIGNvbmRpdGlvbiB0byBleGVyY2lzaW5nIHRoZSByaWdodHMgYW5kCi1saWNlbnNlcyBncmFudGVkIGhlcmV1bmRlciwgZWFjaCBSZWNpcGllbnQgaGVyZWJ5IGFzc3VtZXMgc29sZSByZXNwb25zaWJpbGl0eQotdG8gc2VjdXJlIGFueSBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG5lZWRlZCwgaWYgYW55LiBGb3IgZXhhbXBsZSwKLWlmIGEgdGhpcmQgcGFydHkgcGF0ZW50IGxpY2Vuc2UgaXMgcmVxdWlyZWQgdG8gYWxsb3cgUmVjaXBpZW50IHRvIGRpc3RyaWJ1dGUKLXRoZSBQcm9ncmFtLCBpdCBpcyBSZWNpcGllbnQncyByZXNwb25zaWJpbGl0eSB0byBhY3F1aXJlIHRoYXQgbGljZW5zZSBiZWZvcmUKLWRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbS48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5kKQotRWFjaCBDb250cmlidXRvciByZXByZXNlbnRzIHRoYXQgdG8gaXRzIGtub3dsZWRnZSBpdCBoYXMgc3VmZmljaWVudCBjb3B5cmlnaHQKLXJpZ2h0cyBpbiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIHRvIGdyYW50IHRoZSBjb3B5cmlnaHQgbGljZW5zZSBzZXQgZm9ydGggaW4KLXRoaXMgQWdyZWVtZW50LiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+My4gUkVRVUlSRU1FTlRTPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+QSBDb250cmlidXRvciBtYXkgY2hvb3NlIHRvIGRpc3RyaWJ1dGUgdGhlCi1Qcm9ncmFtIGluIG9iamVjdCBjb2RlIGZvcm0gdW5kZXIgaXRzIG93biBsaWNlbnNlIGFncmVlbWVudCwgcHJvdmlkZWQgdGhhdDo8L3NwYW4+Ci08L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pdCBjb21wbGllcyB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudDsgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikKLWl0cyBsaWNlbnNlIGFncmVlbWVudDo8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pKQotZWZmZWN0aXZlbHkgZGlzY2xhaW1zIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCB3YXJyYW50aWVzIGFuZAotY29uZGl0aW9ucywgZXhwcmVzcyBhbmQgaW1wbGllZCwgaW5jbHVkaW5nIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiB0aXRsZQotYW5kIG5vbi1pbmZyaW5nZW1lbnQsIGFuZCBpbXBsaWVkIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiBtZXJjaGFudGFiaWxpdHkKLWFuZCBmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZTsgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWkpCi1lZmZlY3RpdmVseSBleGNsdWRlcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgbGlhYmlsaXR5IGZvciBkYW1hZ2VzLAotaW5jbHVkaW5nIGRpcmVjdCwgaW5kaXJlY3QsIHNwZWNpYWwsIGluY2lkZW50YWwgYW5kIGNvbnNlcXVlbnRpYWwgZGFtYWdlcywgc3VjaAotYXMgbG9zdCBwcm9maXRzOyA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paWkpCi1zdGF0ZXMgdGhhdCBhbnkgcHJvdmlzaW9ucyB3aGljaCBkaWZmZXIgZnJvbSB0aGlzIEFncmVlbWVudCBhcmUgb2ZmZXJlZCBieSB0aGF0Ci1Db250cmlidXRvciBhbG9uZSBhbmQgbm90IGJ5IGFueSBvdGhlciBwYXJ0eTsgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aXYpCi1zdGF0ZXMgdGhhdCBzb3VyY2UgY29kZSBmb3IgdGhlIFByb2dyYW0gaXMgYXZhaWxhYmxlIGZyb20gc3VjaCBDb250cmlidXRvciwgYW5kCi1pbmZvcm1zIGxpY2Vuc2VlcyBob3cgdG8gb2J0YWluIGl0IGluIGEgcmVhc29uYWJsZSBtYW5uZXIgb24gb3IgdGhyb3VnaCBhCi1tZWRpdW0gY3VzdG9tYXJpbHkgdXNlZCBmb3Igc29mdHdhcmUgZXhjaGFuZ2UuPHNwYW4gc3R5bGU9J2NvbG9yOmJsdWUnPiA8L3NwYW4+PC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPldoZW4gdGhlIFByb2dyYW0gaXMgbWFkZSBhdmFpbGFibGUgaW4gc291cmNlCi1jb2RlIGZvcm06PC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pdCBtdXN0IGJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoaXMgQWdyZWVtZW50OyBhbmQgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikgYQotY29weSBvZiB0aGlzIEFncmVlbWVudCBtdXN0IGJlIGluY2x1ZGVkIHdpdGggZWFjaCBjb3B5IG9mIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Q29udHJpYnV0b3JzIG1heSBub3QgcmVtb3ZlIG9yIGFsdGVyIGFueQotY29weXJpZ2h0IG5vdGljZXMgY29udGFpbmVkIHdpdGhpbiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVhY2ggQ29udHJpYnV0b3IgbXVzdCBpZGVudGlmeSBpdHNlbGYgYXMgdGhlCi1vcmlnaW5hdG9yIG9mIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgaW4gYSBtYW5uZXIgdGhhdCByZWFzb25hYmx5IGFsbG93cwotc3Vic2VxdWVudCBSZWNpcGllbnRzIHRvIGlkZW50aWZ5IHRoZSBvcmlnaW5hdG9yIG9mIHRoZSBDb250cmlidXRpb24uIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz40LiBDT01NRVJDSUFMIERJU1RSSUJVVElPTjwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkNvbW1lcmNpYWwgZGlzdHJpYnV0b3JzIG9mIHNvZnR3YXJlIG1heQotYWNjZXB0IGNlcnRhaW4gcmVzcG9uc2liaWxpdGllcyB3aXRoIHJlc3BlY3QgdG8gZW5kIHVzZXJzLCBidXNpbmVzcyBwYXJ0bmVycwotYW5kIHRoZSBsaWtlLiBXaGlsZSB0aGlzIGxpY2Vuc2UgaXMgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY29tbWVyY2lhbCB1c2UKLW9mIHRoZSBQcm9ncmFtLCB0aGUgQ29udHJpYnV0b3Igd2hvIGluY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbAotcHJvZHVjdCBvZmZlcmluZyBzaG91bGQgZG8gc28gaW4gYSBtYW5uZXIgd2hpY2ggZG9lcyBub3QgY3JlYXRlIHBvdGVudGlhbAotbGlhYmlsaXR5IGZvciBvdGhlciBDb250cmlidXRvcnMuIFRoZXJlZm9yZSwgaWYgYSBDb250cmlidXRvciBpbmNsdWRlcyB0aGUKLVByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIHN1Y2ggQ29udHJpYnV0b3IgKCZxdW90O0NvbW1lcmNpYWwKLUNvbnRyaWJ1dG9yJnF1b3Q7KSBoZXJlYnkgYWdyZWVzIHRvIGRlZmVuZCBhbmQgaW5kZW1uaWZ5IGV2ZXJ5IG90aGVyCi1Db250cmlidXRvciAoJnF1b3Q7SW5kZW1uaWZpZWQgQ29udHJpYnV0b3ImcXVvdDspIGFnYWluc3QgYW55IGxvc3NlcywgZGFtYWdlcyBhbmQKLWNvc3RzIChjb2xsZWN0aXZlbHkgJnF1b3Q7TG9zc2VzJnF1b3Q7KSBhcmlzaW5nIGZyb20gY2xhaW1zLCBsYXdzdWl0cyBhbmQgb3RoZXIKLWxlZ2FsIGFjdGlvbnMgYnJvdWdodCBieSBhIHRoaXJkIHBhcnR5IGFnYWluc3QgdGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIHRvCi10aGUgZXh0ZW50IGNhdXNlZCBieSB0aGUgYWN0cyBvciBvbWlzc2lvbnMgb2Ygc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluCi1jb25uZWN0aW9uIHdpdGggaXRzIGRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdAotb2ZmZXJpbmcuIFRoZSBvYmxpZ2F0aW9ucyBpbiB0aGlzIHNlY3Rpb24gZG8gbm90IGFwcGx5IHRvIGFueSBjbGFpbXMgb3IgTG9zc2VzCi1yZWxhdGluZyB0byBhbnkgYWN0dWFsIG9yIGFsbGVnZWQgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGluZnJpbmdlbWVudC4gSW4gb3JkZXIKLXRvIHF1YWxpZnksIGFuIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG11c3Q6IGEpIHByb21wdGx5IG5vdGlmeSB0aGUgQ29tbWVyY2lhbAotQ29udHJpYnV0b3IgaW4gd3JpdGluZyBvZiBzdWNoIGNsYWltLCBhbmQgYikgYWxsb3cgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IKLXRvIGNvbnRyb2wsIGFuZCBjb29wZXJhdGUgd2l0aCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiwgdGhlIGRlZmVuc2UgYW5kCi1hbnkgcmVsYXRlZCBzZXR0bGVtZW50IG5lZ290aWF0aW9ucy4gVGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG1heSBwYXJ0aWNpcGF0ZQotaW4gYW55IHN1Y2ggY2xhaW0gYXQgaXRzIG93biBleHBlbnNlLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Rm9yIGV4YW1wbGUsIGEgQ29udHJpYnV0b3IgbWlnaHQgaW5jbHVkZSB0aGUKLVByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIFByb2R1Y3QgWC4gVGhhdCBDb250cmlidXRvciBpcyB0aGVuIGEKLUNvbW1lcmNpYWwgQ29udHJpYnV0b3IuIElmIHRoYXQgQ29tbWVyY2lhbCBDb250cmlidXRvciB0aGVuIG1ha2VzIHBlcmZvcm1hbmNlCi1jbGFpbXMsIG9yIG9mZmVycyB3YXJyYW50aWVzIHJlbGF0ZWQgdG8gUHJvZHVjdCBYLCB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kCi13YXJyYW50aWVzIGFyZSBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IncyByZXNwb25zaWJpbGl0eSBhbG9uZS4gVW5kZXIgdGhpcwotc2VjdGlvbiwgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3Igd291bGQgaGF2ZSB0byBkZWZlbmQgY2xhaW1zIGFnYWluc3QgdGhlCi1vdGhlciBDb250cmlidXRvcnMgcmVsYXRlZCB0byB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMsIGFuZCBpZiBhCi1jb3VydCByZXF1aXJlcyBhbnkgb3RoZXIgQ29udHJpYnV0b3IgdG8gcGF5IGFueSBkYW1hZ2VzIGFzIGEgcmVzdWx0LCB0aGUKLUNvbW1lcmNpYWwgQ29udHJpYnV0b3IgbXVzdCBwYXkgdGhvc2UgZGFtYWdlcy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjUuIE5PIFdBUlJBTlRZPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUwotQUdSRUVNRU5ULCBUSEUgUFJPR1JBTSBJUyBQUk9WSURFRCBPTiBBTiAmcXVvdDtBUyBJUyZxdW90OyBCQVNJUywgV0lUSE9VVAotV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBFSVRIRVIgRVhQUkVTUyBPUiBJTVBMSUVEIElOQ0xVRElORywKLVdJVEhPVVQgTElNSVRBVElPTiwgQU5ZIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBUSVRMRSwgTk9OLUlORlJJTkdFTUVOVCwKLU1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gRWFjaCBSZWNpcGllbnQgaXMgc29sZWx5Ci1yZXNwb25zaWJsZSBmb3IgZGV0ZXJtaW5pbmcgdGhlIGFwcHJvcHJpYXRlbmVzcyBvZiB1c2luZyBhbmQgZGlzdHJpYnV0aW5nIHRoZQotUHJvZ3JhbSBhbmQgYXNzdW1lcyBhbGwgcmlza3MgYXNzb2NpYXRlZCB3aXRoIGl0cyBleGVyY2lzZSBvZiByaWdodHMgdW5kZXIgdGhpcwotQWdyZWVtZW50ICwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgcmlza3MgYW5kIGNvc3RzIG9mIHByb2dyYW0gZXJyb3JzLAotY29tcGxpYW5jZSB3aXRoIGFwcGxpY2FibGUgbGF3cywgZGFtYWdlIHRvIG9yIGxvc3Mgb2YgZGF0YSwgcHJvZ3JhbXMgb3IKLWVxdWlwbWVudCwgYW5kIHVuYXZhaWxhYmlsaXR5IG9yIGludGVycnVwdGlvbiBvZiBvcGVyYXRpb25zLiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Ni4gRElTQ0xBSU1FUiBPRiBMSUFCSUxJVFk8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTCi1BR1JFRU1FTlQsIE5FSVRIRVIgUkVDSVBJRU5UIE5PUiBBTlkgQ09OVFJJQlVUT1JTIFNIQUxMIEhBVkUgQU5ZIExJQUJJTElUWSBGT1IKLUFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwotKElOQ0xVRElORyBXSVRIT1VUIExJTUlUQVRJT04gTE9TVCBQUk9GSVRTKSwgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKLU9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HCi1ORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9SIERJU1RSSUJVVElPTiBPRgotVEhFIFBST0dSQU0gT1IgVEhFIEVYRVJDSVNFIE9GIEFOWSBSSUdIVFMgR1JBTlRFRCBIRVJFVU5ERVIsIEVWRU4gSUYgQURWSVNFRCBPRgotVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFUy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjcuIEdFTkVSQUw8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5JZiBhbnkgcHJvdmlzaW9uIG9mIHRoaXMgQWdyZWVtZW50IGlzIGludmFsaWQKLW9yIHVuZW5mb3JjZWFibGUgdW5kZXIgYXBwbGljYWJsZSBsYXcsIGl0IHNoYWxsIG5vdCBhZmZlY3QgdGhlIHZhbGlkaXR5IG9yCi1lbmZvcmNlYWJpbGl0eSBvZiB0aGUgcmVtYWluZGVyIG9mIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgYW5kIHdpdGhvdXQKLWZ1cnRoZXIgYWN0aW9uIGJ5IHRoZSBwYXJ0aWVzIGhlcmV0bywgc3VjaCBwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlCi1taW5pbXVtIGV4dGVudCBuZWNlc3NhcnkgdG8gbWFrZSBzdWNoIHByb3Zpc2lvbiB2YWxpZCBhbmQgZW5mb3JjZWFibGUuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5JZiBSZWNpcGllbnQgaW5zdGl0dXRlcyBwYXRlbnQgbGl0aWdhdGlvbgotYWdhaW5zdCBhbnkgZW50aXR5IChpbmNsdWRpbmcgYSBjcm9zcy1jbGFpbSBvciBjb3VudGVyY2xhaW0gaW4gYSBsYXdzdWl0KQotYWxsZWdpbmcgdGhhdCB0aGUgUHJvZ3JhbSBpdHNlbGYgKGV4Y2x1ZGluZyBjb21iaW5hdGlvbnMgb2YgdGhlIFByb2dyYW0gd2l0aAotb3RoZXIgc29mdHdhcmUgb3IgaGFyZHdhcmUpIGluZnJpbmdlcyBzdWNoIFJlY2lwaWVudCdzIHBhdGVudChzKSwgdGhlbiBzdWNoCi1SZWNpcGllbnQncyByaWdodHMgZ3JhbnRlZCB1bmRlciBTZWN0aW9uIDIoYikgc2hhbGwgdGVybWluYXRlIGFzIG9mIHRoZSBkYXRlCi1zdWNoIGxpdGlnYXRpb24gaXMgZmlsZWQuIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5BbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50Ci1zaGFsbCB0ZXJtaW5hdGUgaWYgaXQgZmFpbHMgdG8gY29tcGx5IHdpdGggYW55IG9mIHRoZSBtYXRlcmlhbCB0ZXJtcyBvcgotY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudCBhbmQgZG9lcyBub3QgY3VyZSBzdWNoIGZhaWx1cmUgaW4gYSByZWFzb25hYmxlCi1wZXJpb2Qgb2YgdGltZSBhZnRlciBiZWNvbWluZyBhd2FyZSBvZiBzdWNoIG5vbmNvbXBsaWFuY2UuIElmIGFsbCBSZWNpcGllbnQncwotcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHRlcm1pbmF0ZSwgUmVjaXBpZW50IGFncmVlcyB0byBjZWFzZSB1c2UgYW5kCi1kaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gYXMgc29vbiBhcyByZWFzb25hYmx5IHByYWN0aWNhYmxlLiBIb3dldmVyLAotUmVjaXBpZW50J3Mgb2JsaWdhdGlvbnMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYW5kIGFueSBsaWNlbnNlcyBncmFudGVkIGJ5Ci1SZWNpcGllbnQgcmVsYXRpbmcgdG8gdGhlIFByb2dyYW0gc2hhbGwgY29udGludWUgYW5kIHN1cnZpdmUuIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FdmVyeW9uZSBpcyBwZXJtaXR0ZWQgdG8gY29weSBhbmQgZGlzdHJpYnV0ZQotY29waWVzIG9mIHRoaXMgQWdyZWVtZW50LCBidXQgaW4gb3JkZXIgdG8gYXZvaWQgaW5jb25zaXN0ZW5jeSB0aGUgQWdyZWVtZW50IGlzCi1jb3B5cmlnaHRlZCBhbmQgbWF5IG9ubHkgYmUgbW9kaWZpZWQgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXIuIFRoZSBBZ3JlZW1lbnQKLVN0ZXdhcmQgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHB1Ymxpc2ggbmV3IHZlcnNpb25zIChpbmNsdWRpbmcgcmV2aXNpb25zKSBvZgotdGhpcyBBZ3JlZW1lbnQgZnJvbSB0aW1lIHRvIHRpbWUuIE5vIG9uZSBvdGhlciB0aGFuIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCBoYXMKLXRoZSByaWdodCB0byBtb2RpZnkgdGhpcyBBZ3JlZW1lbnQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgdGhlIGluaXRpYWwKLUFncmVlbWVudCBTdGV3YXJkLiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1heSBhc3NpZ24gdGhlIHJlc3BvbnNpYmlsaXR5IHRvCi1zZXJ2ZSBhcyB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgdG8gYSBzdWl0YWJsZSBzZXBhcmF0ZSBlbnRpdHkuIEVhY2ggbmV3IHZlcnNpb24KLW9mIHRoZSBBZ3JlZW1lbnQgd2lsbCBiZSBnaXZlbiBhIGRpc3Rpbmd1aXNoaW5nIHZlcnNpb24gbnVtYmVyLiBUaGUgUHJvZ3JhbQotKGluY2x1ZGluZyBDb250cmlidXRpb25zKSBtYXkgYWx3YXlzIGJlIGRpc3RyaWJ1dGVkIHN1YmplY3QgdG8gdGhlIHZlcnNpb24gb2YKLXRoZSBBZ3JlZW1lbnQgdW5kZXIgd2hpY2ggaXQgd2FzIHJlY2VpdmVkLiBJbiBhZGRpdGlvbiwgYWZ0ZXIgYSBuZXcgdmVyc2lvbiBvZgotdGhlIEFncmVlbWVudCBpcyBwdWJsaXNoZWQsIENvbnRyaWJ1dG9yIG1heSBlbGVjdCB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtCi0oaW5jbHVkaW5nIGl0cyBDb250cmlidXRpb25zKSB1bmRlciB0aGUgbmV3IHZlcnNpb24uIEV4Y2VwdCBhcyBleHByZXNzbHkgc3RhdGVkCi1pbiBTZWN0aW9ucyAyKGEpIGFuZCAyKGIpIGFib3ZlLCBSZWNpcGllbnQgcmVjZWl2ZXMgbm8gcmlnaHRzIG9yIGxpY2Vuc2VzIHRvCi10aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IG9mIGFueSBDb250cmlidXRvciB1bmRlciB0aGlzIEFncmVlbWVudCwgd2hldGhlcgotZXhwcmVzc2x5LCBieSBpbXBsaWNhdGlvbiwgZXN0b3BwZWwgb3Igb3RoZXJ3aXNlLiBBbGwgcmlnaHRzIGluIHRoZSBQcm9ncmFtIG5vdAotZXhwcmVzc2x5IGdyYW50ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYXJlIHJlc2VydmVkLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+VGhpcyBBZ3JlZW1lbnQgaXMgZ292ZXJuZWQgYnkgdGhlIGxhd3Mgb2YgdGhlCi1TdGF0ZSBvZiBOZXcgWW9yayBhbmQgdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBsYXdzIG9mIHRoZSBVbml0ZWQgU3RhdGVzIG9mCi1BbWVyaWNhLiBObyBwYXJ0eSB0byB0aGlzIEFncmVlbWVudCB3aWxsIGJyaW5nIGEgbGVnYWwgYWN0aW9uIHVuZGVyIHRoaXMKLUFncmVlbWVudCBtb3JlIHRoYW4gb25lIHllYXIgYWZ0ZXIgdGhlIGNhdXNlIG9mIGFjdGlvbiBhcm9zZS4gRWFjaCBwYXJ0eSB3YWl2ZXMKLWl0cyByaWdodHMgdG8gYSBqdXJ5IHRyaWFsIGluIGFueSByZXN1bHRpbmcgbGl0aWdhdGlvbi48L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjwhW2lmICFzdXBwb3J0RW1wdHlQYXJhc10+Jm5ic3A7PCFbZW5kaWZdPjxvOnA+PC9vOnA+PC9wPgotCi08L2Rpdj4KLQotPC9ib2R5PgotCi08L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5hc3NlbWJseS5mZWF0dXJlL2ZlYXR1cmUucHJvcGVydGllcyBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuYXNzZW1ibHkuZmVhdHVyZS9mZWF0dXJlLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGFiYjBjODguLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5hc3NlbWJseS5mZWF0dXJlL2ZlYXR1cmUucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDE0NSArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIGZlYXR1cmUucHJvcGVydGllcwotIyBjb250YWlucyBleHRlcm5hbGl6ZWQgc3RyaW5ncyBmb3IgZmVhdHVyZS54bWwKLSMgIiVmb28iIGluIGZlYXR1cmUueG1sIGNvcnJlc3BvbmRzIHRvIHRoZSBrZXkgImZvbyIgaW4gdGhpcyBmaWxlCi0jIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCi0jIFRoaXMgZmlsZSBzaG91bGQgYmUgdHJhbnNsYXRlZC4KLQotIyAiZmVhdHVyZU5hbWUiIHByb3BlcnR5IC0gbmFtZSBvZiB0aGUgZmVhdHVyZQotZmVhdHVyZU5hbWU9RGFsaSBKYXZhIFBlcnNpc3RlbmNlIEFQSSAoSlBBKSBwcm9qZWN0IFNESwotCi0jICJwcm92aWRlck5hbWUiIHByb3BlcnR5IC0gbmFtZSBvZiB0aGUgY29tcGFueSB0aGF0IHByb3ZpZGVzIHRoZSBmZWF0dXJlCi1wcm92aWRlck5hbWU9RWNsaXBzZS5vcmcKLQotIyAidXBkYXRlU2l0ZU5hbWUiIHByb3BlcnR5IC0gbGFiZWwgZm9yIHRoZSB1cGRhdGUgc2l0ZQotdXBkYXRlU2l0ZU5hbWU9VGhlIEVjbGlwc2UgV2ViIFRvb2xzIFBsYXRmb3JtIChXVFApIFByb2plY3QgdXBkYXRlIHNpdGUKLQotIyAiZGVzY3JpcHRpb24iIHByb3BlcnR5IC0gZGVzY3JpcHRpb24gb2YgdGhlIGZlYXR1cmUKLWRlc2NyaXB0aW9uPURhbGkgSmF2YSBQZXJzaXN0ZW5jZSBBUEkgKEpQQSkgcHJvamVjdCBTREsKLQotIyAiY29weXJpZ2h0IiBwcm9wZXJ0eSAtIHRleHQgb2YgdGhlICJGZWF0dXJlIFVwZGF0ZSBDb3B5cmlnaHQiCi1jb3B5cmlnaHQ9XAotQ29weXJpZ2h0IChjKSAyMDA2IE9yYWNsZSBDb3Jwb3JhdGlvbi5cblwKLUFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHNcblwKLWFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMFxuXAotd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXRcblwKLWh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sXG5cCi1cblwKLUNvbnRyaWJ1dG9yczpcblwKLSAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb25cbgotIyMjIyMjIyMjIyMjIyMjIyBlbmQgb2YgY29weXJpZ2h0IHByb3BlcnR5ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotCi0jICJsaWNlbnNlVVJMIiBwcm9wZXJ0eSAtIFVSTCBvZiB0aGUgIkZlYXR1cmUgTGljZW5zZSIKLSMgZG8gbm90IHRyYW5zbGF0ZSB2YWx1ZSAtIGp1c3QgY2hhbmdlIHRvIHBvaW50IHRvIGEgbG9jYWxlLXNwZWNpZmljIEhUTUwgcGFnZQotbGljZW5zZVVSTD1saWNlbnNlLmh0bWwKLQotIyAibGljZW5zZSIgcHJvcGVydHkgLSB0ZXh0IG9mIHRoZSAiRmVhdHVyZSBVcGRhdGUgTGljZW5zZSIKLSMgc2hvdWxkIGJlIHBsYWluIHRleHQgdmVyc2lvbiBvZiBsaWNlbnNlIGFncmVlbWVudCBwb2ludGVkIHRvIGJlICJsaWNlbnNlVVJMIgotbGljZW5zZT1cCi1FQ0xJUFNFIEZPVU5EQVRJT04gU09GVFdBUkUgVVNFUiBBR1JFRU1FTlRcblwKLUp1bmUgMDYsIDIwMDdcblwKLVxuXAotVXNhZ2UgT2YgQ29udGVudFxuXAotXG5cCi1USEUgRUNMSVBTRSBGT1VOREFUSU9OIE1BS0VTIEFWQUlMQUJMRSBTT0ZUV0FSRSwgRE9DVU1FTlRBVElPTiwgSU5GT1JNQVRJT04gQU5EL09SXG5cCi1PVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTIChDT0xMRUNUSVZFTFkgIkNPTlRFTlQiKS5cblwKLVVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJU1xuXAotQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SXG5cCi1OT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VXG5cCi1BR1JFRSBUSEFUIFlPVVIgVVNFIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRISVMgQUdSRUVNRU5UXG5cCi1BTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UU1xuXAotT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEVcblwKLVRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORCBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlNcblwKLU9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEXG5cCi1CRUxPVywgVEhFTiBZT1UgTUFZIE5PVCBVU0UgVEhFIENPTlRFTlQuXG5cCi1cblwKLUFwcGxpY2FibGUgTGljZW5zZXNcblwKLVxuXAotVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb25cblwKLWlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgUHVibGljXG5cCi1MaWNlbnNlIFZlcnNpb24gMS4wICgiRVBMIikuIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpc1xuXAotQ29udGVudCBhbmQgaXMgYWxzbyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuXG5cCi1Gb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC5cblwKLVxuXAotQ29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsXG5cCi1kb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlLm9yZyBDVlNcblwKLXJlcG9zaXRvcnkgKCJSZXBvc2l0b3J5IikgaW4gQ1ZTIG1vZHVsZXMgKCJNb2R1bGVzIikgYW5kIG1hZGUgYXZhaWxhYmxlXG5cCi1hcyBkb3dubG9hZGFibGUgYXJjaGl2ZXMgKCJEb3dubG9hZHMiKS5cblwKLVxuXAotICAgLSBDb250ZW50IG1heSBiZSBzdHJ1Y3R1cmVkIGFuZCBwYWNrYWdlZCBpbnRvIG1vZHVsZXMgdG8gZmFjaWxpdGF0ZSBkZWxpdmVyaW5nLFxuXAotICAgICBleHRlbmRpbmcsIGFuZCB1cGdyYWRpbmcgdGhlIENvbnRlbnQuIFR5cGljYWwgbW9kdWxlcyBtYXkgaW5jbHVkZSBwbHVnLWlucyAoIlBsdWctaW5zIiksXG5cCi0gICAgIHBsdWctaW4gZnJhZ21lbnRzICgiRnJhZ21lbnRzIiksIGFuZCBmZWF0dXJlcyAoIkZlYXR1cmVzIikuXG5cCi0gICAtIEVhY2ggUGx1Zy1pbiBvciBGcmFnbWVudCBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IG9yIEpBUiAoSmF2YT8gQVJjaGl2ZSlcblwKLSAgICAgaW4gYSBkaXJlY3RvcnkgbmFtZWQgInBsdWdpbnMiLlxuXAotICAgLSBBIEZlYXR1cmUgaXMgYSBidW5kbGUgb2Ygb25lIG9yIG1vcmUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhbmQgYXNzb2NpYXRlZCBtYXRlcmlhbC5cblwKLSAgICAgRWFjaCBGZWF0dXJlIG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3RvcnkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgImZlYXR1cmVzIi5cblwKLSAgICAgV2l0aGluIGEgRmVhdHVyZSwgZmlsZXMgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uXG5cCi0gICAgIG51bWJlcnMgb2YgdGhlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYXNzb2NpYXRlZCB3aXRoIHRoYXQgRmVhdHVyZS5cblwKLSAgIC0gRmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzXG5cCi0gICAgIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIEluY2x1ZGVkIEZlYXR1cmVzLlxuXAotXG5cCi1GZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgiSW5jbHVkZWQgRmVhdHVyZXMiKS4gRmlsZXMgbmFtZWRcblwKLSJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mXG5cCi1JbmNsdWRlZCBGZWF0dXJlcy5cblwKLVxuXAotVGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZVxuXAotY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICJhYm91dC5odG1sIiAoIkFib3V0cyIpLiBUaGUgdGVybXMgYW5kXG5cCi1jb25kaXRpb25zIGdvdmVybmluZyBGZWF0dXJlcyBhbmQgSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZFxuXAotaW4gZmlsZXMgbmFtZWQgImxpY2Vuc2UuaHRtbCIgKCJGZWF0dXJlIExpY2Vuc2VzIikuIEFib3V0cyBhbmQgRmVhdHVyZVxuXAotTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55IGRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZVxuXAotaW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyBsb2NhdGlvbnM6XG5cCi1cblwKLSAgIC0gVGhlIHRvcC1sZXZlbCAocm9vdCkgZGlyZWN0b3J5XG5cCi0gICAtIFBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzXG5cCi0gICAtIEluc2lkZSBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHBhY2thZ2VkIGFzIEpBUnNcblwKLSAgIC0gU3ViLWRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgInNyYyIgb2YgY2VydGFpbiBQbHVnLWluc1xuXAotICAgLSBGZWF0dXJlIGRpcmVjdG9yaWVzXG5cCi1cblwKLU5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIGluc3RhbGxlZCB1c2luZyB0aGVcblwKLUVjbGlwc2UgVXBkYXRlIE1hbmFnZXIsIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoIkZlYXR1cmUgVXBkYXRlXG5cCi1MaWNlbnNlIikgZHVyaW5nIHRoZSBpbnN0YWxsYXRpb24gcHJvY2Vzcy4gSWYgdGhlIEZlYXR1cmUgY29udGFpbnNcblwKLUluY2x1ZGVkIEZlYXR1cmVzLCB0aGUgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBzaG91bGQgZWl0aGVyIHByb3ZpZGUgeW91XG5cCi13aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgdGhlIEluY2x1ZGVkIEZlYXR1cmVzIG9yIGluZm9ybVxuXAoteW91IHdoZXJlIHlvdSBjYW4gbG9jYXRlIHRoZW0uIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSBmb3VuZCBpblxuXAotdGhlICJsaWNlbnNlIiBwcm9wZXJ0eSBvZiBmaWxlcyBuYW1lZCAiZmVhdHVyZS5wcm9wZXJ0aWVzIi4gU3VjaCBBYm91dHMsXG5cCi1GZWF0dXJlIExpY2Vuc2VzIGFuZCBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBjb250YWluIHRoZSB0ZXJtcyBhbmRcblwKLWNvbmRpdGlvbnMgKG9yIHJlZmVyZW5jZXMgdG8gc3VjaCB0ZXJtcyBhbmQgY29uZGl0aW9ucykgdGhhdCBnb3Zlcm4geW91clxuXAotdXNlIG9mIHRoZSBhc3NvY2lhdGVkIENvbnRlbnQgaW4gdGhhdCBkaXJlY3RvcnkuXG5cCi1cblwKLVRIRSBBQk9VVFMsIEZFQVRVUkUgTElDRU5TRVMgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUlxuXAotVE8gVEhFIEVQTCBPUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuXG5cCi1TT01FIE9GIFRIRVNFIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6XG5cCi1cblwKLSAgICAtIENvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sKVxuXAotICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UpXG5cCi0gICAgLSBBcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjApXG5cCi0gICAgLSBJQk0gUHVibGljIExpY2Vuc2UgMS4wIChhdmFpbGFibGUgYXQgaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2RldmVsb3BlcndvcmtzL29wZW5zb3VyY2UvbGljZW5zZTEwLmh0bWwpXG5cCi0gICAgLSBNZXRybyBMaW5rIFB1YmxpYyBMaWNlbnNlIDEuMDAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbClcblwKLSAgICAtIE1vemlsbGEgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjEgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWwpXG5cCi0gICAgLSBDb21tb24gRGV2ZWxvcG1lbnQgYW5kIERpc3RyaWJ1dGlvbiBMaWNlbnNlIChDRERMKSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuc3VuLmNvbS9jZGRsL2NkZGwuaHRtbClcblwKLVxuXAotSVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgQ09ORElUSU9OUyBQUklPUlxuXAotVE8gVVNFIE9GIFRIRSBDT05URU5ULiBJZiBubyBBYm91dCwgRmVhdHVyZSBMaWNlbnNlIG9yIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VcblwKLWlzIHByb3ZpZGVkLCBwbGVhc2UgY29udGFjdCB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHRvIGRldGVybWluZSB3aGF0IHRlcm1zIGFuZCBjb25kaXRpb25zXG5cCi1nb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuXG5cCi1cblwKLUNyeXB0b2dyYXBoeVxuXAotXG5cCi1Db250ZW50IG1heSBjb250YWluIGVuY3J5cHRpb24gc29mdHdhcmUuIFRoZSBjb3VudHJ5IGluIHdoaWNoIHlvdSBhcmVcblwKLWN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSxcblwKLWFuZC9vciByZS1leHBvcnQgdG8gYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkVcblwKLXVzaW5nIGFueSBlbmNyeXB0aW9uIHNvZnR3YXJlLCBwbGVhc2UgY2hlY2sgdGhlIGNvdW50cnkncyBsYXdzLFxuXAotcmVndWxhdGlvbnMgYW5kIHBvbGljaWVzIGNvbmNlcm5pbmcgdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgb3IgdXNlLFxuXAotYW5kIHJlLWV4cG9ydCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLCB0byBzZWUgaWYgdGhpcyBpcyBwZXJtaXR0ZWQuXG5cCi1cblwKLUphdmEgYW5kIGFsbCBKYXZhLWJhc2VkIHRyYWRlbWFya3MgYXJlIHRyYWRlbWFya3Mgb2YgU3VuIE1pY3Jvc3lzdGVtcywgSW5jLiBpbiB0aGUgVW5pdGVkIFN0YXRlcywgb3RoZXIgY291bnRyaWVzLCBvciBib3RoLlxuCi0jIyMjIyMjIyMjIyBlbmQgb2YgbGljZW5zZSBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuYXNzZW1ibHkuZmVhdHVyZS9mZWF0dXJlLnhtbCBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuYXNzZW1ibHkuZmVhdHVyZS9mZWF0dXJlLnhtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjNmYjE3Zi4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHRfc2RrLmFzc2VtYmx5LmZlYXR1cmUvZmVhdHVyZS54bWwKKysrIC9kZXYvbnVsbApAQCAtMSwzNCArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPGZlYXR1cmUKLSAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHRfc2RrLmFzc2VtYmx5LmZlYXR1cmUiCi0gICAgICBsYWJlbD0iJWZlYXR1cmVOYW1lIgotICAgICAgdmVyc2lvbj0iMi4xLjAucXVhbGlmaWVyIgotICAgICAgcHJvdmlkZXItbmFtZT0iJXByb3ZpZGVyTmFtZSIKLSAgICAgIGltYWdlPSJlY2xpcHNlX3VwZGF0ZV8xMjAuanBnIj4KLQotICAgPGRlc2NyaXB0aW9uPgotICAgICAgJWRlc2NyaXB0aW9uCi0gICA8L2Rlc2NyaXB0aW9uPgotCi0gICA8Y29weXJpZ2h0PgotICAgICAgJWNvcHlyaWdodAotICAgPC9jb3B5cmlnaHQ+Ci0KLSAgIDxsaWNlbnNlIHVybD0ibGljZW5zZS5odG1sIj4KLSAgICAgICVsaWNlbnNlCi0gICA8L2xpY2Vuc2U+Ci0KLSAgIDx1cmw+Ci0gICAgICA8dXBkYXRlIGxhYmVsPSIldXBkYXRlU2l0ZU5hbWUiIHVybD0iaHR0cDovL2Rvd25sb2FkLmVjbGlwc2Uub3JnL3dlYnRvb2xzL3VwZGF0ZXMiLz4KLSAgICAgIDxkaXNjb3ZlcnkgbGFiZWw9IldlYiBUb29scyBQbGF0Zm9ybSAoV1RQKSBVcGRhdGVzIiB1cmw9Imh0dHA6Ly9kb3dubG9hZC5lY2xpcHNlLm9yZy93ZWJ0b29scy91cGRhdGVzIi8+Ci0gICA8L3VybD4KLQotICAgPGluY2x1ZGVzCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0X3Nkay5mZWF0dXJlIgotICAgICAgICAgdmVyc2lvbj0iMC4wLjAiLz4KLQotICAgPGluY2x1ZGVzCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rX3Nkay5mZWF0dXJlIgotICAgICAgICAgdmVyc2lvbj0iMC4wLjAiLz4KLQotPC9mZWF0dXJlPgpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5hc3NlbWJseS5mZWF0dXJlL2xpY2Vuc2UuaHRtbCBiL2Fzc2VtYmx5L2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuYXNzZW1ibHkuZmVhdHVyZS9saWNlbnNlLmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDc2YWJmYjQuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5hc3NlbWJseS5mZWF0dXJlL2xpY2Vuc2UuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDk4ICswLDAgQEAKLTwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAxIFRyYW5zaXRpb25hbC8vRU4iICJodHRwOi8vd3d3LnczYy5vcmcvVFIvMTk5OS9SRUMtaHRtbDQwMS0xOTk5MTIyNC9sb29zZS5kdGQiPgotPCEtLSBzYXZlZCBmcm9tIHVybD0oMDA0NClodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC9ub3RpY2UuaHRtbCAtLT4KLTxIVE1MPjxIRUFEPjxUSVRMRT5FY2xpcHNlLm9yZyBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvVElUTEU+Ci08TUVUQSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9aXNvLTg4NTktMSI+Ci08TUVUQSBjb250ZW50PSJNU0hUTUwgNi4wMC4yODAwLjE0NzkiIG5hbWU9R0VORVJBVE9SPjwvSEVBRD4KLTxCT0RZIGxhbmc9RU4tVVMgdkxpbms9cHVycGxlIGxpbms9Ymx1ZT4KLTxIMj5FY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L0gyPgotPFA+SnVuZSAwNiwgMjAwNzwvUD4KLTxIMz5Vc2FnZSBPZiBDb250ZW50PC9IMz4KLTxQPlRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiAKLUFORC9PUiBPVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTIChDT0xMRUNUSVZFTFkgIkNPTlRFTlQiKS4gVVNFIE9GIAotVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCAKLUJFTE9XLiBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VIEFHUkVFIFRIQVQgWU9VUiBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgCi1CWSBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgCi1BR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFIAotVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgCi1BUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLCBUSEVOIFlPVSAKLU1BWSBOT1QgVVNFIFRIRSBDT05URU5ULjwvUD4KLTxIMz5BcHBsaWNhYmxlIExpY2Vuc2VzPC9IMz4KLTxQPlVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSAKLUZvdW5kYXRpb24gaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRWNsaXBzZSAKLVB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wICgiRVBMIikuIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpcyAKLUNvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IDxBIAotaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sPC9BPi4gCi1Gb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC48L1A+Ci08UD5Db250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSwgCi1kb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlLm9yZyBDVlMgcmVwb3NpdG9yeSAKLSgiUmVwb3NpdG9yeSIpIGluIENWUyBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIGF2YWlsYWJsZSBhcyBkb3dubG9hZGFibGUgCi1hcmNoaXZlcyAoIkRvd25sb2FkcyIpLjwvUD4KLTxQPkNvbnRlbnQgbWF5IGJlIGFwcG9ydGlvbmVkIGludG8gcGx1Zy1pbnMgKCJQbHVnLWlucyIpLCBwbHVnLWluIGZyYWdtZW50cyAKLSgiRnJhZ21lbnRzIiksIGFuZCBmZWF0dXJlcyAoIkZlYXR1cmVzIikuIEEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSAKLVBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuIEZpbGVzIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IAotY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgdGhlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgCi1hc3NvY2lhdGVkIHdpdGggYSBGZWF0dXJlLiBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIGFyZSBsb2NhdGVkIGluIGRpcmVjdG9yaWVzIAotbmFtZWQgInBsdWdpbnMiIGFuZCBGZWF0dXJlcyBhcmUgbG9jYXRlZCBpbiBkaXJlY3RvcmllcyBuYW1lZCAiZmVhdHVyZXMiLjwvUD4KLTxQPkZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBGaWxlcyBuYW1lZCAKLSJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIEluY2x1ZGVkIAotRmVhdHVyZXMuPC9QPgotPFA+VGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZSBjb250YWluZWQgCi1pbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyAKLUZlYXR1cmVzIGFuZCBJbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICJsaWNlbnNlLmh0bWwiIAotKCJGZWF0dXJlIExpY2Vuc2VzIikuIEFib3V0cyBhbmQgRmVhdHVyZSBMaWNlbnNlcyBtYXkgYmUgbG9jYXRlZCBpbiBhbnkgCi1kaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGUgaW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyAKLWxvY2F0aW9uczo8L1A+Ci08VUw+Ci0gIDxMST5UaGUgdG9wLWxldmVsIChyb290KSBkaXJlY3RvcnkgCi0gIDxMST5QbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3RvcmllcyAKLSAgPExJPlN1YmRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgInNyYyIgb2YgY2VydGFpbiBQbHVnLWlucyAKLSAgPExJPkZlYXR1cmUgZGlyZWN0b3JpZXMgPC9MST48L1VMPgotPFA+Tm90ZTogaWYgYSBGZWF0dXJlIG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgaW5zdGFsbGVkIAotdXNpbmcgdGhlIEVjbGlwc2UgVXBkYXRlIE1hbmFnZXIsIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoIkZlYXR1cmUgVXBkYXRlIAotTGljZW5zZSIpIGR1cmluZyB0aGUgaW5zdGFsbGF0aW9uIHByb2Nlc3MuIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zIEluY2x1ZGVkIAotRmVhdHVyZXMsIHRoZSBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIHNob3VsZCBlaXRoZXIgcHJvdmlkZSB5b3Ugd2l0aCB0aGUgdGVybXMgCi1hbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgdGhlIEluY2x1ZGVkIEZlYXR1cmVzIG9yIGluZm9ybSB5b3Ugd2hlcmUgeW91IGNhbiAKLWxvY2F0ZSB0aGVtLiBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW4gdGhlICJsaWNlbnNlIiBwcm9wZXJ0eSBvZiAKLWZpbGVzIG5hbWVkICJmZWF0dXJlLnByb3BlcnRpZXMiLiBTdWNoIEFib3V0cywgRmVhdHVyZSBMaWNlbnNlcyBhbmQgRmVhdHVyZSAKLVVwZGF0ZSBMaWNlbnNlcyBjb250YWluIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyAob3IgcmVmZXJlbmNlcyB0byBzdWNoIHRlcm1zIAotYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXIgdXNlIG9mIHRoZSBhc3NvY2lhdGVkIENvbnRlbnQgaW4gdGhhdCAKLWRpcmVjdG9yeS48L1A+Ci08UD5USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVIgVE8gVEhFIEVQTCAKLU9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy4gU09NRSBPRiBUSEVTRSAKLU9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6PC9QPgotPFVMPgotICA8TEk+Q29tbW9uIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbDwvQT4pIAotCi0gIDxMST5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAxLjEgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFPC9BPikgCi0KLSAgPExJPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDIuMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMDwvQT4pIAotCi0gIDxMST5JQk0gUHVibGljIExpY2Vuc2UgMS4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sIj5odHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vZGV2ZWxvcGVyd29ya3Mvb3BlbnNvdXJjZS9saWNlbnNlMTAuaHRtbDwvQT4pIAotCi0gIDxMST5NZXRybyBMaW5rIFB1YmxpYyBMaWNlbnNlIDEuMDAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwiPmh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sPC9BPikgCi0KLSAgPExJPk1vemlsbGEgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjEgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sIj5odHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWw8L0E+KSAKLSAgPC9MST4KLSAgIAotICA8TEk+Q29tbW9uIERldmVsb3BtZW50IGFuZCBEaXN0cmlidXRpb24gTGljZW5zZSAoQ0RETCkgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sIj5odHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwpPC9BPgotICA8L0xJPgotPC9VTD4KLTxQPklUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1IgCi1UTyBVU0UgT0YgVEhFIENPTlRFTlQuIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2Ugb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBpcyAKLXByb3ZpZGVkLCBwbGVhc2UgY29udGFjdCB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHRvIGRldGVybWluZSB3aGF0IHRlcm1zIGFuZCAKLWNvbmRpdGlvbnMgZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LjwvUD4KLTxIMz5DcnlwdG9ncmFwaHk8L0gzPgotPFA+Q29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlIAotY3VycmVudGx5IG1heSBoYXZlIHJlc3RyaWN0aW9ucyBvbiB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBhbmQgdXNlLCBhbmQvb3IgCi1yZS1leHBvcnQgdG8gYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkUgdXNpbmcgYW55IAotZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cywgcmVndWxhdGlvbnMgYW5kIHBvbGljaWVzIAotY29uY2VybmluZyB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgCi10byBzZWUgaWYgdGhpcyBpcyBwZXJtaXR0ZWQuPC9QPjwvQk9EWT48L0hUTUw+CmRpZmYgLS1naXQgYS9hc3NlbWJseS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC8uY3ZzaWdub3JlIGIvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvLmN2c2lnbm9yZQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzk0MDFhMi4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC8uY3ZzaWdub3JlCisrKyAvZGV2L251bGwKQEAgLTEsMiArMCwwIEBACi1idWlsZC54bWwKLW9yZy5lY2xpcHNlLmpwdF8xLjAuMC4qClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvLnByb2plY3QgYi9hc3NlbWJseS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC8ucHJvamVjdApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjUxYjA0Yy4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC8ucHJvamVjdAorKysgL2Rldi9udWxsCkBAIC0xLDIyICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08cHJvamVjdERlc2NyaXB0aW9uPgotCTxuYW1lPm9yZy5lY2xpcHNlLmpwdDwvbmFtZT4KLQk8Y29tbWVudD48L2NvbW1lbnQ+Ci0JPHByb2plY3RzPgotCTwvcHJvamVjdHM+Ci0JPGJ1aWxkU3BlYz4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5NYW5pZmVzdEJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLlNjaGVtYUJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCTwvYnVpbGRTcGVjPgotCTxuYXR1cmVzPgotCQk8bmF0dXJlPm9yZy5lY2xpcHNlLnBkZS5QbHVnaW5OYXR1cmU8L25hdHVyZT4KLQk8L25hdHVyZXM+Ci08L3Byb2plY3REZXNjcmlwdGlvbj4KZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Ly5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcyBiL2Fzc2VtYmx5L3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Ly5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNGFlYzI5ZC4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMKKysrIC9kZXYvbnVsbApAQCAtMSwzICswLDAgQEAKLSNTdW4gTWF5IDI3IDE1OjEwOjA5IEVEVCAyMDA3Ci1lY2xpcHNlLnByZWZlcmVuY2VzLnZlcnNpb249MQotZW5jb2RpbmcvPHByb2plY3Q+PUlTTy04ODU5LTEKZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0L01FVEEtSU5GL01BTklGRVNULk1GIGIvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvTUVUQS1JTkYvTUFOSUZFU1QuTUYKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDk0ZTNiYmQuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvTUVUQS1JTkYvTUFOSUZFU1QuTUYKKysrIC9kZXYvbnVsbApAQCAtMSw3ICswLDAgQEAKLU1hbmlmZXN0LVZlcnNpb246IDEuMAotQnVuZGxlLU1hbmlmZXN0VmVyc2lvbjogMgotQnVuZGxlLU5hbWU6ICVwbHVnaW5OYW1lCi1CdW5kbGUtU3ltYm9saWNOYW1lOiBvcmcuZWNsaXBzZS5qcHQ7IHNpbmdsZXRvbjo9dHJ1ZQotQnVuZGxlLVZlcnNpb246IDIuMS4wLnF1YWxpZmllcgotQnVuZGxlLUxvY2FsaXphdGlvbjogcGx1Z2luCi1CdW5kbGUtVmVuZG9yOiAlcHJvdmlkZXJOYW1lCmRpZmYgLS1naXQgYS9hc3NlbWJseS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC9hYm91dC5odG1sIGIvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvYWJvdXQuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggY2E2MDZiMS4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC9hYm91dC5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsMzQgKzAsMCBAQAotPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMC8vRU4iPgotPEhUTUw+Ci0KLTxoZWFkPgotPHRpdGxlPkFib3V0PC90aXRsZT4KLTxtZXRhIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1JU08tODg1OS0xIj4KLTwvaGVhZD4KLQotPEJPRFkgbGFuZz0iRU4tVVMiPgotCi08SDM+QWJvdXQgVGhpcyBDb250ZW50PC9IMz4KLQotPFA+SnVuZSAwNiwgMjAwNzwvUD4KLQotPEgzPkxpY2Vuc2U8L0gzPgotCi08UD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBhbGwgY29udGVudCBpbiB0aGlzIHBsdWctaW4gCi0oIkNvbnRlbnQiKS4gVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQgYmVsb3csIHRoZSBDb250ZW50IGlzIHByb3ZpZGVkIHRvIHlvdSAKLXVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAKLSgiRVBMIikuIEEgY29weSBvZiB0aGUgRVBMIGlzIGF2YWlsYWJsZSBhdAotPEEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9vcmcvZG9jdW1lbnRzL2VwbC12MTAucGhwIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL29yZy9kb2N1bWVudHMvZXBsLXYxMC5waHA8L0E+LiAKLUZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAiUHJvZ3JhbSIgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvUD4KLQotPFA+SWYgeW91IGRpZCBub3QgcmVjZWl2ZSB0aGlzIENvbnRlbnQgZGlyZWN0bHkgZnJvbSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uLCB0aGUgCi1Db250ZW50IGlzIGJlaW5nIHJlZGlzdHJpYnV0ZWQgYnkgYW5vdGhlciBwYXJ0eSAoIlJlZGlzdHJpYnV0b3IiKSBhbmQgZGlmZmVyZW50IAotdGVybXMgYW5kIGNvbmRpdGlvbnMgbWF5IGFwcGx5IHRvIHlvdXIgdXNlIG9mIGFueSBvYmplY3QgY29kZSBpbiB0aGUgQ29udGVudC4gCi1DaGVjayB0aGUgUmVkaXN0cmlidXRvcidzIGxpY2Vuc2UgdGhhdCB3YXMgcHJvdmlkZWQgd2l0aCB0aGUgQ29udGVudC4gSWYgbm8gc3VjaCAKLWxpY2Vuc2UgZXhpc3RzLCBjb250YWN0IHRoZSBSZWRpc3RyaWJ1dG9yLiBVbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCBiZWxvdywgdGhlIAotdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVQTCBzdGlsbCBhcHBseSB0byBhbnkgc291cmNlIGNvZGUgaW4gdGhlIENvbnRlbnQgCi1hbmQgc3VjaCBzb3VyY2UgY29kZSBtYXkgYmUgb2J0YWluZWQgYXQKLTxBIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnLzwvQT4uPC9QPgotCi08L0JPRFk+Ci08L0hUTUw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvYWJvdXQuaW5pIGIvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvYWJvdXQuaW5pCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1ODhhMzI1Li4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0L2Fib3V0LmluaQorKysgL2Rldi9udWxsCkBAIC0xLDQ0ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotIyBhYm91dC5pbmkKLSMgY29udGFpbnMgaW5mb3JtYXRpb24gYWJvdXQgYSBmZWF0dXJlCi0jIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCi0jICIla2V5IiBhcmUgZXh0ZXJuYWxpemVkIHN0cmluZ3MgZGVmaW5lZCBpbiBhYm91dC5wcm9wZXJ0aWVzCi0jIFRoaXMgZmlsZSBkb2VzIG5vdCBuZWVkIHRvIGJlIHRyYW5zbGF0ZWQuCi0KLSMgUHJvcGVydHkgImFib3V0VGV4dCIgY29udGFpbnMgYmx1cmIgZm9yICJBYm91dCIgZGlhbG9nICh0cmFuc2xhdGVkKQotYWJvdXRUZXh0PSVibHVyYgotCi0jIFByb3BlcnR5ICJ3aW5kb3dJbWFnZSIgY29udGFpbnMgcGF0aCB0byB3aW5kb3cgaWNvbiAoMTZ4MTYpCi0jIG5lZWRlZCBmb3IgcHJpbWFyeSBmZWF0dXJlcyBvbmx5Ci0KLSMgUHJvcGVydHkgImZlYXR1cmVJbWFnZSIgY29udGFpbnMgcGF0aCB0byBmZWF0dXJlIGltYWdlICgzMngzMikKLWZlYXR1cmVJbWFnZT1lY2xpcHNlMzIuZ2lmCi0KLSMgUHJvcGVydHkgImFib3V0SW1hZ2UiIGNvbnRhaW5zIHBhdGggdG8gcHJvZHVjdCBpbWFnZSAoNTAweDMzMCBvciAxMTV4MTY0KQotIyBuZWVkZWQgZm9yIHByaW1hcnkgZmVhdHVyZXMgb25seQotCi0jIFByb3BlcnR5ICJhcHBOYW1lIiBjb250YWlucyBuYW1lIG9mIHRoZSBhcHBsaWNhdGlvbiAodHJhbnNsYXRlZCkKLSMgbmVlZGVkIGZvciBwcmltYXJ5IGZlYXR1cmVzIG9ubHkKLQotIyBQcm9wZXJ0eSAid2VsY29tZVBhZ2UiIGNvbnRhaW5zIHBhdGggdG8gd2VsY29tZSBwYWdlIChzcGVjaWFsIFhNTC1iYXNlZCBmb3JtYXQpCi0jIG9wdGlvbmFsCi0KLSMgUHJvcGVydHkgIndlbGNvbWVQZXJzcGVjdGl2ZSIgY29udGFpbnMgdGhlIGlkIG9mIHRoZSBwZXJzcGVjdGl2ZSBpbiB3aGljaCB0aGUKLSMgd2VsY29tZSBwYWdlIGlzIHRvIGJlIG9wZW5lZC4KLSMgb3B0aW9uYWwKLQotIyBQcm9wZXJ0eSAidGlwc0FuZFRyaWNrc0hyZWYiIGNvbnRhaW5zIHRoZSBIZWxwIHRvcGljIGhyZWYgdG8gYSB0aXBzIGFuZCB0cmlja3MgcGFnZSAKLSMgb3B0aW9uYWwKLXRpcHNBbmRUcmlja3NIcmVmPS9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGlwc19hbmRfdHJpY2tzLmh0bQotCi0KZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0L2Fib3V0Lm1hcHBpbmdzIGIvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvYWJvdXQubWFwcGluZ3MKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJkZGFhYjQuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvYWJvdXQubWFwcGluZ3MKKysrIC9kZXYvbnVsbApAQCAtMSw2ICswLDAgQEAKLSMgYWJvdXQubWFwcGluZ3MKLSMgY29udGFpbnMgZmlsbC1pbnMgZm9yIGFib3V0LnByb3BlcnRpZXMKLSMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKLSMgVGhpcyBmaWxlIGRvZXMgbm90IG5lZWQgdG8gYmUgdHJhbnNsYXRlZC4KLQotMD1AYnVpbGRAClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvYWJvdXQucHJvcGVydGllcyBiL2Fzc2VtYmx5L3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0L2Fib3V0LnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDE1OWJmY2UuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvYWJvdXQucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDI0ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotIyBhYm91dC5wcm9wZXJ0aWVzCi0jIGNvbnRhaW5zIGV4dGVybmFsaXplZCBzdHJpbmdzIGZvciBhYm91dC5pbmkKLSMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKLSMgZmlsbC1pbnMgYXJlIHN1cHBsaWVkIGJ5IGFib3V0Lm1hcHBpbmdzCi0jIFRoaXMgZmlsZSBzaG91bGQgYmUgdHJhbnNsYXRlZC4KLQotYmx1cmI9SmF2YSBQZXJzaXN0ZW5jZSBBUEkgVG9vbHNcblwKLVxuXAotVmVyc2lvbjoge2ZlYXR1cmVWZXJzaW9ufVxuXAotQnVpbGQgaWQ6IHswfVxuXAotXG5cCi0oYykgQ29weXJpZ2h0IEVjbGlwc2UgY29udHJpYnV0b3JzIGFuZCBvdGhlcnMgMjAwNi4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG5cCi1WaXNpdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL3dlYnRvb2xzCmRpZmYgLS1naXQgYS9hc3NlbWJseS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC9idWlsZC5wcm9wZXJ0aWVzIGIvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMGNjZmIwZS4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC9idWlsZC5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTkgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDcgT3JhY2xlLgotIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCi0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAotIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAotIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlLiAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotYmluLmluY2x1ZGVzID0gTUVUQS1JTkYvLFwKLSAgICAgICAgICAgICAgIGFib3V0LmluaSxcCi0gICAgICAgICAgICAgICBhYm91dC5odG1sLFwKLSAgICAgICAgICAgICAgIGFib3V0Lm1hcHBpbmdzLFwKLSAgICAgICAgICAgICAgIGFib3V0LnByb3BlcnRpZXMsXAotICAgICAgICAgICAgICAgZWNsaXBzZTMyLmdpZixcCi0gICAgICAgICAgICAgICBlY2xpcHNlMzIucG5nLFwKLSAgICAgICAgICAgICAgIHBsdWdpbi5wcm9wZXJ0aWVzLFwKLSAgICAgICAgICAgICAgIGNvbXBvbmVudC54bWwKZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0L2NvbXBvbmVudC54bWwgYi9hc3NlbWJseS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC9jb21wb25lbnQueG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxMWYxMzNmLi4wMDAwMDAwCi0tLSBhL2Fzc2VtYmx5L3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0L2NvbXBvbmVudC54bWwKKysrIC9kZXYvbnVsbApAQCAtMSwxMiArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPGNvbXBvbmVudCAgeG1sbnM9Imh0dHA6Ly9lY2xpcHNlLm9yZy93dHAvcmVsZW5nL3Rvb2xzL2NvbXBvbmVudC1tb2RlbCIgbmFtZT0ib3JnLmVjbGlwc2UuanB0Ij4KLTxkZXNjcmlwdGlvbiB1cmw9IiI+PC9kZXNjcmlwdGlvbj4KLTxjb21wb25lbnQtZGVwZW5kcyB1bnJlc3RyaWN0ZWQ9InRydWUiPjwvY29tcG9uZW50LWRlcGVuZHM+Ci08cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5qcHQiIGZyYWdtZW50PSJmYWxzZSIvPgotPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2UuanB0LmNvcmUiIGZyYWdtZW50PSJmYWxzZSIvPgotPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2UuanB0LmRiIiBmcmFnbWVudD0iZmFsc2UiLz4KLTxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLmpwdC5kYi51aSIgZnJhZ21lbnQ9ImZhbHNlIi8+Ci08cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5qcHQuZ2VuIiBmcmFnbWVudD0iZmFsc2UiLz4KLTxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLmpwdC51aSIgZnJhZ21lbnQ9ImZhbHNlIi8+Ci08cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5qcHQudXRpbGl0eSIgZnJhZ21lbnQ9ImZhbHNlIi8+Ci08L2NvbXBvbmVudD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9hc3NlbWJseS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC9lY2xpcHNlMzIuZ2lmIGIvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvZWNsaXBzZTMyLmdpZgpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTZhZDdjYy4uMDAwMDAwMAotLS0gYS9hc3NlbWJseS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC9lY2xpcHNlMzIuZ2lmCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvZWNsaXBzZTMyLnBuZyBiL2Fzc2VtYmx5L3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0L2VjbGlwc2UzMi5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDU2OGZhYzEuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvZWNsaXBzZTMyLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2Fzc2VtYmx5L3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0L3BsdWdpbi5wcm9wZXJ0aWVzIGIvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvcGx1Z2luLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGY0NWEwOGQuLjAwMDAwMDAKLS0tIGEvYXNzZW1ibHkvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQvcGx1Z2luLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwxMyArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0KLXBsdWdpbk5hbWUgPSBKYXZhIFBlcnNpc3RlbmNlIEFQSSBUb29scwotcHJvdmlkZXJOYW1lID0gRWNsaXBzZS5vcmcKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS8uY3ZzaWdub3JlIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlLy5jdnNpZ25vcmUKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGMxNDQ4N2MuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlLy5jdnNpZ25vcmUKKysrIC9kZXYvbnVsbApAQCAtMSArMCwwIEBACi1idWlsZC54bWwKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS8ucHJvamVjdCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS8ucHJvamVjdApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTNmMTliMS4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvLnByb2plY3QKKysrIC9kZXYvbnVsbApAQCAtMSwxNyArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPHByb2plY3REZXNjcmlwdGlvbj4KLQk8bmFtZT5vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZTwvbmFtZT4KLQk8Y29tbWVudD48L2NvbW1lbnQ+Ci0JPHByb2plY3RzPgotCTwvcHJvamVjdHM+Ci0JPGJ1aWxkU3BlYz4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5GZWF0dXJlQnVpbGRlcjwvbmFtZT4KLQkJCTxhcmd1bWVudHM+Ci0JCQk8L2FyZ3VtZW50cz4KLQkJPC9idWlsZENvbW1hbmQ+Ci0JPC9idWlsZFNwZWM+Ci0JPG5hdHVyZXM+Ci0JCTxuYXR1cmU+b3JnLmVjbGlwc2UucGRlLkZlYXR1cmVOYXR1cmU8L25hdHVyZT4KLQk8L25hdHVyZXM+Ci08L3Byb2plY3REZXNjcmlwdGlvbj4KZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkYWI1ODM3Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMKKysrIC9kZXYvbnVsbApAQCAtMSwzICswLDAgQEAKLSNTdW4gTWF5IDI3IDE1OjEwOjQ3IEVEVCAyMDA3Ci1lY2xpcHNlLnByZWZlcmVuY2VzLnZlcnNpb249MQotZW5jb2RpbmcvPHByb2plY3Q+PUlTTy04ODU5LTEKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9idWlsZC5wcm9wZXJ0aWVzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL2J1aWxkLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDcyMDA5MzkuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL2J1aWxkLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwxNSArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi1iaW4uaW5jbHVkZXMgPSBmZWF0dXJlLnhtbCxcCi0gICAgICAgICAgICAgICBlY2xpcHNlX3VwZGF0ZV8xMjAuanBnLFwKLSAgICAgICAgICAgICAgIGVwbC12MTAuaHRtbCxcCi0gICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwsXAotICAgICAgICAgICAgICAgZmVhdHVyZS5wcm9wZXJ0aWVzCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiZmRmNzA4Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL2VwbC12MTAuaHRtbCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9lcGwtdjEwLmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVkNGIxOTYuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL2VwbC12MTAuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDMyOCArMCwwIEBACi08aHRtbCB4bWxuczpvPSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTpvZmZpY2UiCi14bWxuczp3PSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTp3b3JkIgoteG1sbnM9Imh0dHA6Ly93d3cudzMub3JnL1RSL1JFQy1odG1sNDAiPgotCi08aGVhZD4KLTxtZXRhIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD13aW5kb3dzLTEyNTIiPgotPG1ldGEgbmFtZT1Qcm9nSWQgY29udGVudD1Xb3JkLkRvY3VtZW50PgotPG1ldGEgbmFtZT1HZW5lcmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgOSI+Ci08bWV0YSBuYW1lPU9yaWdpbmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgOSI+Ci08bGluayByZWw9RmlsZS1MaXN0Ci1ocmVmPSIuL0VjbGlwc2UlMjBFUEwlMjAyMDAzXzExXzEwJTIwRmluYWxfZmlsZXMvZmlsZWxpc3QueG1sIj4KLTx0aXRsZT5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gVmVyc2lvbiAxLjA8L3RpdGxlPgotPCEtLVtpZiBndGUgbXNvIDldPjx4bWw+Ci0gPG86RG9jdW1lbnRQcm9wZXJ0aWVzPgotICA8bzpSZXZpc2lvbj4yPC9vOlJldmlzaW9uPgotICA8bzpUb3RhbFRpbWU+MzwvbzpUb3RhbFRpbWU+Ci0gIDxvOkNyZWF0ZWQ+MjAwNC0wMy0wNVQyMzowMzowMFo8L286Q3JlYXRlZD4KLSAgPG86TGFzdFNhdmVkPjIwMDQtMDMtMDVUMjM6MDM6MDBaPC9vOkxhc3RTYXZlZD4KLSAgPG86UGFnZXM+NDwvbzpQYWdlcz4KLSAgPG86V29yZHM+MTYyNjwvbzpXb3Jkcz4KLSAgPG86Q2hhcmFjdGVycz45MjcwPC9vOkNoYXJhY3RlcnM+Ci0gICA8bzpMaW5lcz43NzwvbzpMaW5lcz4KLSAgPG86UGFyYWdyYXBocz4xODwvbzpQYXJhZ3JhcGhzPgotICA8bzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4xMTM4NDwvbzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4KLSAgPG86VmVyc2lvbj45LjQ0MDI8L286VmVyc2lvbj4KLSA8L286RG9jdW1lbnRQcm9wZXJ0aWVzPgotPC94bWw+PCFbZW5kaWZdLS0+PCEtLVtpZiBndGUgbXNvIDldPjx4bWw+Ci0gPHc6V29yZERvY3VtZW50PgotICA8dzpUcmFja1JldmlzaW9ucy8+Ci0gPC93OldvcmREb2N1bWVudD4KLTwveG1sPjwhW2VuZGlmXS0tPgotPHN0eWxlPgotPCEtLQotIC8qIEZvbnQgRGVmaW5pdGlvbnMgKi8KLUBmb250LWZhY2UKLQl7Zm9udC1mYW1pbHk6VGFob21hOwotCXBhbm9zZS0xOjIgMTEgNiA0IDMgNSA0IDQgMiA0OwotCW1zby1mb250LWNoYXJzZXQ6MDsKLQltc28tZ2VuZXJpYy1mb250LWZhbWlseTpzd2lzczsKLQltc28tZm9udC1waXRjaDp2YXJpYWJsZTsKLQltc28tZm9udC1zaWduYXR1cmU6NTUzNjc5NDk1IC0yMTQ3NDgzNjQ4IDggMCA2NjA0NyAwO30KLSAvKiBTdHlsZSBEZWZpbml0aW9ucyAqLwotcC5Nc29Ob3JtYWwsIGxpLk1zb05vcm1hbCwgZGl2Lk1zb05vcm1hbAotCXttc28tc3R5bGUtcGFyZW50OiIiOwotCW1hcmdpbjowaW47Ci0JbWFyZ2luLWJvdHRvbTouMDAwMXB0OwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXAKLQl7bWFyZ2luLXJpZ2h0OjBpbjsKLQltc28tbWFyZ2luLXRvcC1hbHQ6YXV0bzsKLQltc28tbWFyZ2luLWJvdHRvbS1hbHQ6YXV0bzsKLQltYXJnaW4tbGVmdDowaW47Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZToxMi4wcHQ7Ci0JZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotcC5CYWxsb29uVGV4dCwgbGkuQmFsbG9vblRleHQsIGRpdi5CYWxsb29uVGV4dAotCXttc28tc3R5bGUtbmFtZToiQmFsbG9vbiBUZXh0IjsKLQltYXJnaW46MGluOwotCW1hcmdpbi1ib3R0b206LjAwMDFwdDsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjguMHB0OwotCWZvbnQtZmFtaWx5OlRhaG9tYTsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1AcGFnZSBTZWN0aW9uMQotCXtzaXplOjguNWluIDExLjBpbjsKLQltYXJnaW46MS4waW4gMS4yNWluIDEuMGluIDEuMjVpbjsKLQltc28taGVhZGVyLW1hcmdpbjouNWluOwotCW1zby1mb290ZXItbWFyZ2luOi41aW47Ci0JbXNvLXBhcGVyLXNvdXJjZTowO30KLWRpdi5TZWN0aW9uMQotCXtwYWdlOlNlY3Rpb24xO30KLS0tPgotPC9zdHlsZT4KLTwvaGVhZD4KLQotPGJvZHkgbGFuZz1FTi1VUyBzdHlsZT0ndGFiLWludGVydmFsOi41aW4nPgotCi08ZGl2IGNsYXNzPVNlY3Rpb24xPgotCi08cCBhbGlnbj1jZW50ZXIgc3R5bGU9J3RleHQtYWxpZ246Y2VudGVyJz48Yj5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gdiAxLjA8L2I+Ci08L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5USEUgQUNDT01QQU5ZSU5HIFBST0dSQU0gSVMgUFJPVklERUQgVU5ERVIKLVRIRSBURVJNUyBPRiBUSElTIEVDTElQU0UgUFVCTElDIExJQ0VOU0UgKCZxdW90O0FHUkVFTUVOVCZxdW90OykuIEFOWSBVU0UsCi1SRVBST0RVQ1RJT04gT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIENPTlNUSVRVVEVTIFJFQ0lQSUVOVCdTIEFDQ0VQVEFOQ0UKLU9GIFRISVMgQUdSRUVNRU5ULjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+MS4gREVGSU5JVElPTlM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtDb250cmlidXRpb24mcXVvdDsgbWVhbnM6PC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pbiB0aGUgY2FzZSBvZiB0aGUgaW5pdGlhbCBDb250cmlidXRvciwgdGhlIGluaXRpYWwgY29kZSBhbmQgZG9jdW1lbnRhdGlvbgotZGlzdHJpYnV0ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGFuZDxiciBjbGVhcj1sZWZ0PgotYikgaW4gdGhlIGNhc2Ugb2YgZWFjaCBzdWJzZXF1ZW50IENvbnRyaWJ1dG9yOjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmkpCi1jaGFuZ2VzIHRvIHRoZSBQcm9ncmFtLCBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paSkKLWFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbTs8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz53aGVyZQotc3VjaCBjaGFuZ2VzIGFuZC9vciBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gb3JpZ2luYXRlIGZyb20gYW5kIGFyZSBkaXN0cmlidXRlZAotYnkgdGhhdCBwYXJ0aWN1bGFyIENvbnRyaWJ1dG9yLiBBIENvbnRyaWJ1dGlvbiAnb3JpZ2luYXRlcycgZnJvbSBhIENvbnRyaWJ1dG9yCi1pZiBpdCB3YXMgYWRkZWQgdG8gdGhlIFByb2dyYW0gYnkgc3VjaCBDb250cmlidXRvciBpdHNlbGYgb3IgYW55b25lIGFjdGluZyBvbgotc3VjaCBDb250cmlidXRvcidzIGJlaGFsZi4gQ29udHJpYnV0aW9ucyBkbyBub3QgaW5jbHVkZSBhZGRpdGlvbnMgdG8gdGhlCi1Qcm9ncmFtIHdoaWNoOiAoaSkgYXJlIHNlcGFyYXRlIG1vZHVsZXMgb2Ygc29mdHdhcmUgZGlzdHJpYnV0ZWQgaW4gY29uanVuY3Rpb24KLXdpdGggdGhlIFByb2dyYW0gdW5kZXIgdGhlaXIgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBhbmQgKGlpKSBhcmUgbm90IGRlcml2YXRpdmUKLXdvcmtzIG9mIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7Q29udHJpYnV0b3ImcXVvdDsgbWVhbnMgYW55IHBlcnNvbiBvcgotZW50aXR5IHRoYXQgZGlzdHJpYnV0ZXMgdGhlIFByb2dyYW0uPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtMaWNlbnNlZCBQYXRlbnRzICZxdW90OyBtZWFuIHBhdGVudAotY2xhaW1zIGxpY2Vuc2FibGUgYnkgYSBDb250cmlidXRvciB3aGljaCBhcmUgbmVjZXNzYXJpbHkgaW5mcmluZ2VkIGJ5IHRoZSB1c2UKLW9yIHNhbGUgb2YgaXRzIENvbnRyaWJ1dGlvbiBhbG9uZSBvciB3aGVuIGNvbWJpbmVkIHdpdGggdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtQcm9ncmFtJnF1b3Q7IG1lYW5zIHRoZSBDb250cmlidXRpb25zCi1kaXN0cmlidXRlZCBpbiBhY2NvcmRhbmNlIHdpdGggdGhpcyBBZ3JlZW1lbnQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtSZWNpcGllbnQmcXVvdDsgbWVhbnMgYW55b25lIHdobwotcmVjZWl2ZXMgdGhlIFByb2dyYW0gdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGluY2x1ZGluZyBhbGwgQ29udHJpYnV0b3JzLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Mi4gR1JBTlQgT0YgUklHSFRTPC9zcGFuPjwvYj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQKLWEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLCByb3lhbHR5LWZyZWUgY29weXJpZ2h0IGxpY2Vuc2UgdG88c3Bhbgotc3R5bGU9J2NvbG9yOnJlZCc+IDwvc3Bhbj5yZXByb2R1Y2UsIHByZXBhcmUgZGVyaXZhdGl2ZSB3b3JrcyBvZiwgcHVibGljbHkKLWRpc3BsYXksIHB1YmxpY2x5IHBlcmZvcm0sIGRpc3RyaWJ1dGUgYW5kIHN1YmxpY2Vuc2UgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoCi1Db250cmlidXRvciwgaWYgYW55LCBhbmQgc3VjaCBkZXJpdmF0aXZlIHdvcmtzLCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUKLWZvcm0uPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikKLVN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMKLVJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSw8c3BhbiBzdHlsZT0nY29sb3I6Z3JlZW4nPiA8L3NwYW4+cm95YWx0eS1mcmVlCi1wYXRlbnQgbGljZW5zZSB1bmRlciBMaWNlbnNlZCBQYXRlbnRzIHRvIG1ha2UsIHVzZSwgc2VsbCwgb2ZmZXIgdG8gc2VsbCwgaW1wb3J0Ci1hbmQgb3RoZXJ3aXNlIHRyYW5zZmVyIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBpbiBzb3VyY2UKLWNvZGUgYW5kIG9iamVjdCBjb2RlIGZvcm0uIFRoaXMgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgYXBwbHkgdG8gdGhlIGNvbWJpbmF0aW9uCi1vZiB0aGUgQ29udHJpYnV0aW9uIGFuZCB0aGUgUHJvZ3JhbSBpZiwgYXQgdGhlIHRpbWUgdGhlIENvbnRyaWJ1dGlvbiBpcyBhZGRlZAotYnkgdGhlIENvbnRyaWJ1dG9yLCBzdWNoIGFkZGl0aW9uIG9mIHRoZSBDb250cmlidXRpb24gY2F1c2VzIHN1Y2ggY29tYmluYXRpb24KLXRvIGJlIGNvdmVyZWQgYnkgdGhlIExpY2Vuc2VkIFBhdGVudHMuIFRoZSBwYXRlbnQgbGljZW5zZSBzaGFsbCBub3QgYXBwbHkgdG8KLWFueSBvdGhlciBjb21iaW5hdGlvbnMgd2hpY2ggaW5jbHVkZSB0aGUgQ29udHJpYnV0aW9uLiBObyBoYXJkd2FyZSBwZXIgc2UgaXMKLWxpY2Vuc2VkIGhlcmV1bmRlci4gPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YykKLVJlY2lwaWVudCB1bmRlcnN0YW5kcyB0aGF0IGFsdGhvdWdoIGVhY2ggQ29udHJpYnV0b3IgZ3JhbnRzIHRoZSBsaWNlbnNlcyB0byBpdHMKLUNvbnRyaWJ1dGlvbnMgc2V0IGZvcnRoIGhlcmVpbiwgbm8gYXNzdXJhbmNlcyBhcmUgcHJvdmlkZWQgYnkgYW55IENvbnRyaWJ1dG9yCi10aGF0IHRoZSBQcm9ncmFtIGRvZXMgbm90IGluZnJpbmdlIHRoZSBwYXRlbnQgb3Igb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5Ci1yaWdodHMgb2YgYW55IG90aGVyIGVudGl0eS4gRWFjaCBDb250cmlidXRvciBkaXNjbGFpbXMgYW55IGxpYWJpbGl0eSB0byBSZWNpcGllbnQKLWZvciBjbGFpbXMgYnJvdWdodCBieSBhbnkgb3RoZXIgZW50aXR5IGJhc2VkIG9uIGluZnJpbmdlbWVudCBvZiBpbnRlbGxlY3R1YWwKLXByb3BlcnR5IHJpZ2h0cyBvciBvdGhlcndpc2UuIEFzIGEgY29uZGl0aW9uIHRvIGV4ZXJjaXNpbmcgdGhlIHJpZ2h0cyBhbmQKLWxpY2Vuc2VzIGdyYW50ZWQgaGVyZXVuZGVyLCBlYWNoIFJlY2lwaWVudCBoZXJlYnkgYXNzdW1lcyBzb2xlIHJlc3BvbnNpYmlsaXR5Ci10byBzZWN1cmUgYW55IG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgbmVlZGVkLCBpZiBhbnkuIEZvciBleGFtcGxlLAotaWYgYSB0aGlyZCBwYXJ0eSBwYXRlbnQgbGljZW5zZSBpcyByZXF1aXJlZCB0byBhbGxvdyBSZWNpcGllbnQgdG8gZGlzdHJpYnV0ZQotdGhlIFByb2dyYW0sIGl0IGlzIFJlY2lwaWVudCdzIHJlc3BvbnNpYmlsaXR5IHRvIGFjcXVpcmUgdGhhdCBsaWNlbnNlIGJlZm9yZQotZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtLjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmQpCi1FYWNoIENvbnRyaWJ1dG9yIHJlcHJlc2VudHMgdGhhdCB0byBpdHMga25vd2xlZGdlIGl0IGhhcyBzdWZmaWNpZW50IGNvcHlyaWdodAotcmlnaHRzIGluIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgdG8gZ3JhbnQgdGhlIGNvcHlyaWdodCBsaWNlbnNlIHNldCBmb3J0aCBpbgotdGhpcyBBZ3JlZW1lbnQuIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4zLiBSRVFVSVJFTUVOVFM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5BIENvbnRyaWJ1dG9yIG1heSBjaG9vc2UgdG8gZGlzdHJpYnV0ZSB0aGUKLVByb2dyYW0gaW4gb2JqZWN0IGNvZGUgZm9ybSB1bmRlciBpdHMgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBwcm92aWRlZCB0aGF0Ojwvc3Bhbj4KLTwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWl0IGNvbXBsaWVzIHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50OyBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKQotaXRzIGxpY2Vuc2UgYWdyZWVtZW50Ojwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmkpCi1lZmZlY3RpdmVseSBkaXNjbGFpbXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIHdhcnJhbnRpZXMgYW5kCi1jb25kaXRpb25zLCBleHByZXNzIGFuZCBpbXBsaWVkLCBpbmNsdWRpbmcgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIHRpdGxlCi1hbmQgbm9uLWluZnJpbmdlbWVudCwgYW5kIGltcGxpZWQgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIG1lcmNoYW50YWJpbGl0eQotYW5kIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlOyA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paSkKLWVmZmVjdGl2ZWx5IGV4Y2x1ZGVzIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCBsaWFiaWxpdHkgZm9yIGRhbWFnZXMsCi1pbmNsdWRpbmcgZGlyZWN0LCBpbmRpcmVjdCwgc3BlY2lhbCwgaW5jaWRlbnRhbCBhbmQgY29uc2VxdWVudGlhbCBkYW1hZ2VzLCBzdWNoCi1hcyBsb3N0IHByb2ZpdHM7IDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpaSkKLXN0YXRlcyB0aGF0IGFueSBwcm92aXNpb25zIHdoaWNoIGRpZmZlciBmcm9tIHRoaXMgQWdyZWVtZW50IGFyZSBvZmZlcmVkIGJ5IHRoYXQKLUNvbnRyaWJ1dG9yIGFsb25lIGFuZCBub3QgYnkgYW55IG90aGVyIHBhcnR5OyBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pdikKLXN0YXRlcyB0aGF0IHNvdXJjZSBjb2RlIGZvciB0aGUgUHJvZ3JhbSBpcyBhdmFpbGFibGUgZnJvbSBzdWNoIENvbnRyaWJ1dG9yLCBhbmQKLWluZm9ybXMgbGljZW5zZWVzIGhvdyB0byBvYnRhaW4gaXQgaW4gYSByZWFzb25hYmxlIG1hbm5lciBvbiBvciB0aHJvdWdoIGEKLW1lZGl1bSBjdXN0b21hcmlseSB1c2VkIGZvciBzb2Z0d2FyZSBleGNoYW5nZS48c3BhbiBzdHlsZT0nY29sb3I6Ymx1ZSc+IDwvc3Bhbj48L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+V2hlbiB0aGUgUHJvZ3JhbSBpcyBtYWRlIGF2YWlsYWJsZSBpbiBzb3VyY2UKLWNvZGUgZm9ybTo8L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWl0IG11c3QgYmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhpcyBBZ3JlZW1lbnQ7IGFuZCA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKSBhCi1jb3B5IG9mIHRoaXMgQWdyZWVtZW50IG11c3QgYmUgaW5jbHVkZWQgd2l0aCBlYWNoIGNvcHkgb2YgdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Db250cmlidXRvcnMgbWF5IG5vdCByZW1vdmUgb3IgYWx0ZXIgYW55Ci1jb3B5cmlnaHQgbm90aWNlcyBjb250YWluZWQgd2l0aGluIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RWFjaCBDb250cmlidXRvciBtdXN0IGlkZW50aWZ5IGl0c2VsZiBhcyB0aGUKLW9yaWdpbmF0b3Igb2YgaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCBpbiBhIG1hbm5lciB0aGF0IHJlYXNvbmFibHkgYWxsb3dzCi1zdWJzZXF1ZW50IFJlY2lwaWVudHMgdG8gaWRlbnRpZnkgdGhlIG9yaWdpbmF0b3Igb2YgdGhlIENvbnRyaWJ1dGlvbi4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjQuIENPTU1FUkNJQUwgRElTVFJJQlVUSU9OPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Q29tbWVyY2lhbCBkaXN0cmlidXRvcnMgb2Ygc29mdHdhcmUgbWF5Ci1hY2NlcHQgY2VydGFpbiByZXNwb25zaWJpbGl0aWVzIHdpdGggcmVzcGVjdCB0byBlbmQgdXNlcnMsIGJ1c2luZXNzIHBhcnRuZXJzCi1hbmQgdGhlIGxpa2UuIFdoaWxlIHRoaXMgbGljZW5zZSBpcyBpbnRlbmRlZCB0byBmYWNpbGl0YXRlIHRoZSBjb21tZXJjaWFsIHVzZQotb2YgdGhlIFByb2dyYW0sIHRoZSBDb250cmlidXRvciB3aG8gaW5jbHVkZXMgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsCi1wcm9kdWN0IG9mZmVyaW5nIHNob3VsZCBkbyBzbyBpbiBhIG1hbm5lciB3aGljaCBkb2VzIG5vdCBjcmVhdGUgcG90ZW50aWFsCi1saWFiaWxpdHkgZm9yIG90aGVyIENvbnRyaWJ1dG9ycy4gVGhlcmVmb3JlLCBpZiBhIENvbnRyaWJ1dG9yIGluY2x1ZGVzIHRoZQotUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgc3VjaCBDb250cmlidXRvciAoJnF1b3Q7Q29tbWVyY2lhbAotQ29udHJpYnV0b3ImcXVvdDspIGhlcmVieSBhZ3JlZXMgdG8gZGVmZW5kIGFuZCBpbmRlbW5pZnkgZXZlcnkgb3RoZXIKLUNvbnRyaWJ1dG9yICgmcXVvdDtJbmRlbW5pZmllZCBDb250cmlidXRvciZxdW90OykgYWdhaW5zdCBhbnkgbG9zc2VzLCBkYW1hZ2VzIGFuZAotY29zdHMgKGNvbGxlY3RpdmVseSAmcXVvdDtMb3NzZXMmcXVvdDspIGFyaXNpbmcgZnJvbSBjbGFpbXMsIGxhd3N1aXRzIGFuZCBvdGhlcgotbGVnYWwgYWN0aW9ucyBicm91Z2h0IGJ5IGEgdGhpcmQgcGFydHkgYWdhaW5zdCB0aGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgdG8KLXRoZSBleHRlbnQgY2F1c2VkIGJ5IHRoZSBhY3RzIG9yIG9taXNzaW9ucyBvZiBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4KLWNvbm5lY3Rpb24gd2l0aCBpdHMgZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0Ci1vZmZlcmluZy4gVGhlIG9ibGlnYXRpb25zIGluIHRoaXMgc2VjdGlvbiBkbyBub3QgYXBwbHkgdG8gYW55IGNsYWltcyBvciBMb3NzZXMKLXJlbGF0aW5nIHRvIGFueSBhY3R1YWwgb3IgYWxsZWdlZCBpbnRlbGxlY3R1YWwgcHJvcGVydHkgaW5mcmluZ2VtZW50LiBJbiBvcmRlcgotdG8gcXVhbGlmeSwgYW4gSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbXVzdDogYSkgcHJvbXB0bHkgbm90aWZ5IHRoZSBDb21tZXJjaWFsCi1Db250cmlidXRvciBpbiB3cml0aW5nIG9mIHN1Y2ggY2xhaW0sIGFuZCBiKSBhbGxvdyB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvcgotdG8gY29udHJvbCwgYW5kIGNvb3BlcmF0ZSB3aXRoIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluLCB0aGUgZGVmZW5zZSBhbmQKLWFueSByZWxhdGVkIHNldHRsZW1lbnQgbmVnb3RpYXRpb25zLiBUaGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbWF5IHBhcnRpY2lwYXRlCi1pbiBhbnkgc3VjaCBjbGFpbSBhdCBpdHMgb3duIGV4cGVuc2UuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Gb3IgZXhhbXBsZSwgYSBDb250cmlidXRvciBtaWdodCBpbmNsdWRlIHRoZQotUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgUHJvZHVjdCBYLiBUaGF0IENvbnRyaWJ1dG9yIGlzIHRoZW4gYQotQ29tbWVyY2lhbCBDb250cmlidXRvci4gSWYgdGhhdCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRoZW4gbWFrZXMgcGVyZm9ybWFuY2UKLWNsYWltcywgb3Igb2ZmZXJzIHdhcnJhbnRpZXMgcmVsYXRlZCB0byBQcm9kdWN0IFgsIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQKLXdhcnJhbnRpZXMgYXJlIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvcidzIHJlc3BvbnNpYmlsaXR5IGFsb25lLiBVbmRlciB0aGlzCi1zZWN0aW9uLCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB3b3VsZCBoYXZlIHRvIGRlZmVuZCBjbGFpbXMgYWdhaW5zdCB0aGUKLW90aGVyIENvbnRyaWJ1dG9ycyByZWxhdGVkIHRvIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcywgYW5kIGlmIGEKLWNvdXJ0IHJlcXVpcmVzIGFueSBvdGhlciBDb250cmlidXRvciB0byBwYXkgYW55IGRhbWFnZXMgYXMgYSByZXN1bHQsIHRoZQotQ29tbWVyY2lhbCBDb250cmlidXRvciBtdXN0IHBheSB0aG9zZSBkYW1hZ2VzLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+NS4gTk8gV0FSUkFOVFk8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTCi1BR1JFRU1FTlQsIFRIRSBQUk9HUkFNIElTIFBST1ZJREVEIE9OIEFOICZxdW90O0FTIElTJnF1b3Q7IEJBU0lTLCBXSVRIT1VUCi1XQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIEVJVEhFUiBFWFBSRVNTIE9SIElNUExJRUQgSU5DTFVESU5HLAotV0lUSE9VVCBMSU1JVEFUSU9OLCBBTlkgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIFRJVExFLCBOT04tSU5GUklOR0VNRU5ULAotTUVSQ0hBTlRBQklMSVRZIE9SIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBFYWNoIFJlY2lwaWVudCBpcyBzb2xlbHkKLXJlc3BvbnNpYmxlIGZvciBkZXRlcm1pbmluZyB0aGUgYXBwcm9wcmlhdGVuZXNzIG9mIHVzaW5nIGFuZCBkaXN0cmlidXRpbmcgdGhlCi1Qcm9ncmFtIGFuZCBhc3N1bWVzIGFsbCByaXNrcyBhc3NvY2lhdGVkIHdpdGggaXRzIGV4ZXJjaXNlIG9mIHJpZ2h0cyB1bmRlciB0aGlzCi1BZ3JlZW1lbnQgLCBpbmNsdWRpbmcgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSByaXNrcyBhbmQgY29zdHMgb2YgcHJvZ3JhbSBlcnJvcnMsCi1jb21wbGlhbmNlIHdpdGggYXBwbGljYWJsZSBsYXdzLCBkYW1hZ2UgdG8gb3IgbG9zcyBvZiBkYXRhLCBwcm9ncmFtcyBvcgotZXF1aXBtZW50LCBhbmQgdW5hdmFpbGFiaWxpdHkgb3IgaW50ZXJydXB0aW9uIG9mIG9wZXJhdGlvbnMuIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz42LiBESVNDTEFJTUVSIE9GIExJQUJJTElUWTwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMKLUFHUkVFTUVOVCwgTkVJVEhFUiBSRUNJUElFTlQgTk9SIEFOWSBDT05UUklCVVRPUlMgU0hBTEwgSEFWRSBBTlkgTElBQklMSVRZIEZPUgotQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0oSU5DTFVESU5HIFdJVEhPVVQgTElNSVRBVElPTiBMT1NUIFBST0ZJVFMpLCBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQotT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcKLU5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT1IgRElTVFJJQlVUSU9OIE9GCi1USEUgUFJPR1JBTSBPUiBUSEUgRVhFUkNJU0UgT0YgQU5ZIFJJR0hUUyBHUkFOVEVEIEhFUkVVTkRFUiwgRVZFTiBJRiBBRFZJU0VEIE9GCi1USEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0VTLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Ny4gR0VORVJBTDwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPklmIGFueSBwcm92aXNpb24gb2YgdGhpcyBBZ3JlZW1lbnQgaXMgaW52YWxpZAotb3IgdW5lbmZvcmNlYWJsZSB1bmRlciBhcHBsaWNhYmxlIGxhdywgaXQgc2hhbGwgbm90IGFmZmVjdCB0aGUgdmFsaWRpdHkgb3IKLWVuZm9yY2VhYmlsaXR5IG9mIHRoZSByZW1haW5kZXIgb2YgdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBhbmQgd2l0aG91dAotZnVydGhlciBhY3Rpb24gYnkgdGhlIHBhcnRpZXMgaGVyZXRvLCBzdWNoIHByb3Zpc2lvbiBzaGFsbCBiZSByZWZvcm1lZCB0byB0aGUKLW1pbmltdW0gZXh0ZW50IG5lY2Vzc2FyeSB0byBtYWtlIHN1Y2ggcHJvdmlzaW9uIHZhbGlkIGFuZCBlbmZvcmNlYWJsZS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPklmIFJlY2lwaWVudCBpbnN0aXR1dGVzIHBhdGVudCBsaXRpZ2F0aW9uCi1hZ2FpbnN0IGFueSBlbnRpdHkgKGluY2x1ZGluZyBhIGNyb3NzLWNsYWltIG9yIGNvdW50ZXJjbGFpbSBpbiBhIGxhd3N1aXQpCi1hbGxlZ2luZyB0aGF0IHRoZSBQcm9ncmFtIGl0c2VsZiAoZXhjbHVkaW5nIGNvbWJpbmF0aW9ucyBvZiB0aGUgUHJvZ3JhbSB3aXRoCi1vdGhlciBzb2Z0d2FyZSBvciBoYXJkd2FyZSkgaW5mcmluZ2VzIHN1Y2ggUmVjaXBpZW50J3MgcGF0ZW50KHMpLCB0aGVuIHN1Y2gKLVJlY2lwaWVudCdzIHJpZ2h0cyBncmFudGVkIHVuZGVyIFNlY3Rpb24gMihiKSBzaGFsbCB0ZXJtaW5hdGUgYXMgb2YgdGhlIGRhdGUKLXN1Y2ggbGl0aWdhdGlvbiBpcyBmaWxlZC4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkFsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQKLXNoYWxsIHRlcm1pbmF0ZSBpZiBpdCBmYWlscyB0byBjb21wbHkgd2l0aCBhbnkgb2YgdGhlIG1hdGVyaWFsIHRlcm1zIG9yCi1jb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50IGFuZCBkb2VzIG5vdCBjdXJlIHN1Y2ggZmFpbHVyZSBpbiBhIHJlYXNvbmFibGUKLXBlcmlvZCBvZiB0aW1lIGFmdGVyIGJlY29taW5nIGF3YXJlIG9mIHN1Y2ggbm9uY29tcGxpYW5jZS4gSWYgYWxsIFJlY2lwaWVudCdzCi1yaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgdGVybWluYXRlLCBSZWNpcGllbnQgYWdyZWVzIHRvIGNlYXNlIHVzZSBhbmQKLWRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBhcyBzb29uIGFzIHJlYXNvbmFibHkgcHJhY3RpY2FibGUuIEhvd2V2ZXIsCi1SZWNpcGllbnQncyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIEFncmVlbWVudCBhbmQgYW55IGxpY2Vuc2VzIGdyYW50ZWQgYnkKLVJlY2lwaWVudCByZWxhdGluZyB0byB0aGUgUHJvZ3JhbSBzaGFsbCBjb250aW51ZSBhbmQgc3Vydml2ZS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkV2ZXJ5b25lIGlzIHBlcm1pdHRlZCB0byBjb3B5IGFuZCBkaXN0cmlidXRlCi1jb3BpZXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGJ1dCBpbiBvcmRlciB0byBhdm9pZCBpbmNvbnNpc3RlbmN5IHRoZSBBZ3JlZW1lbnQgaXMKLWNvcHlyaWdodGVkIGFuZCBtYXkgb25seSBiZSBtb2RpZmllZCBpbiB0aGUgZm9sbG93aW5nIG1hbm5lci4gVGhlIEFncmVlbWVudAotU3Rld2FyZCByZXNlcnZlcyB0aGUgcmlnaHQgdG8gcHVibGlzaCBuZXcgdmVyc2lvbnMgKGluY2x1ZGluZyByZXZpc2lvbnMpIG9mCi10aGlzIEFncmVlbWVudCBmcm9tIHRpbWUgdG8gdGltZS4gTm8gb25lIG90aGVyIHRoYW4gdGhlIEFncmVlbWVudCBTdGV3YXJkIGhhcwotdGhlIHJpZ2h0IHRvIG1vZGlmeSB0aGlzIEFncmVlbWVudC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyB0aGUgaW5pdGlhbAotQWdyZWVtZW50IFN0ZXdhcmQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWF5IGFzc2lnbiB0aGUgcmVzcG9uc2liaWxpdHkgdG8KLXNlcnZlIGFzIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCB0byBhIHN1aXRhYmxlIHNlcGFyYXRlIGVudGl0eS4gRWFjaCBuZXcgdmVyc2lvbgotb2YgdGhlIEFncmVlbWVudCB3aWxsIGJlIGdpdmVuIGEgZGlzdGluZ3Vpc2hpbmcgdmVyc2lvbiBudW1iZXIuIFRoZSBQcm9ncmFtCi0oaW5jbHVkaW5nIENvbnRyaWJ1dGlvbnMpIG1heSBhbHdheXMgYmUgZGlzdHJpYnV0ZWQgc3ViamVjdCB0byB0aGUgdmVyc2lvbiBvZgotdGhlIEFncmVlbWVudCB1bmRlciB3aGljaCBpdCB3YXMgcmVjZWl2ZWQuIEluIGFkZGl0aW9uLCBhZnRlciBhIG5ldyB2ZXJzaW9uIG9mCi10aGUgQWdyZWVtZW50IGlzIHB1Ymxpc2hlZCwgQ29udHJpYnV0b3IgbWF5IGVsZWN0IHRvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0KLShpbmNsdWRpbmcgaXRzIENvbnRyaWJ1dGlvbnMpIHVuZGVyIHRoZSBuZXcgdmVyc2lvbi4gRXhjZXB0IGFzIGV4cHJlc3NseSBzdGF0ZWQKLWluIFNlY3Rpb25zIDIoYSkgYW5kIDIoYikgYWJvdmUsIFJlY2lwaWVudCByZWNlaXZlcyBubyByaWdodHMgb3IgbGljZW5zZXMgdG8KLXRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgb2YgYW55IENvbnRyaWJ1dG9yIHVuZGVyIHRoaXMgQWdyZWVtZW50LCB3aGV0aGVyCi1leHByZXNzbHksIGJ5IGltcGxpY2F0aW9uLCBlc3RvcHBlbCBvciBvdGhlcndpc2UuIEFsbCByaWdodHMgaW4gdGhlIFByb2dyYW0gbm90Ci1leHByZXNzbHkgZ3JhbnRlZCB1bmRlciB0aGlzIEFncmVlbWVudCBhcmUgcmVzZXJ2ZWQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5UaGlzIEFncmVlbWVudCBpcyBnb3Zlcm5lZCBieSB0aGUgbGF3cyBvZiB0aGUKLVN0YXRlIG9mIE5ldyBZb3JrIGFuZCB0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGxhd3Mgb2YgdGhlIFVuaXRlZCBTdGF0ZXMgb2YKLUFtZXJpY2EuIE5vIHBhcnR5IHRvIHRoaXMgQWdyZWVtZW50IHdpbGwgYnJpbmcgYSBsZWdhbCBhY3Rpb24gdW5kZXIgdGhpcwotQWdyZWVtZW50IG1vcmUgdGhhbiBvbmUgeWVhciBhZnRlciB0aGUgY2F1c2Ugb2YgYWN0aW9uIGFyb3NlLiBFYWNoIHBhcnR5IHdhaXZlcwotaXRzIHJpZ2h0cyB0byBhIGp1cnkgdHJpYWwgaW4gYW55IHJlc3VsdGluZyBsaXRpZ2F0aW9uLjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PCFbaWYgIXN1cHBvcnRFbXB0eVBhcmFzXT4mbmJzcDs8IVtlbmRpZl0+PG86cD48L286cD48L3A+Ci0KLTwvZGl2PgotCi08L2JvZHk+Ci0KLTwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvZmVhdHVyZS5wcm9wZXJ0aWVzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL2ZlYXR1cmUucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmYwZmQ4MC4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvZmVhdHVyZS5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTQwICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotCi0jICJmZWF0dXJlTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBmZWF0dXJlCi1mZWF0dXJlTmFtZT1KYXZhIFBlcnNpc3RlbmNlIEFQSSBUb29scyAtIEVjbGlwc2VMaW5rIFN1cHBvcnQgKE9wdGlvbmFsKQotCi0jICJwcm92aWRlck5hbWUiIHByb3BlcnR5IC0gbmFtZSBvZiB0aGUgY29tcGFueSB0aGF0IHByb3ZpZGVzIHRoZSBmZWF0dXJlCi1wcm92aWRlck5hbWU9RWNsaXBzZS5vcmcKLQotIyAidXBkYXRlU2l0ZU5hbWUiIHByb3BlcnR5IC0gbGFiZWwgZm9yIHRoZSB1cGRhdGUgc2l0ZQotdXBkYXRlU2l0ZU5hbWU9VGhlIEVjbGlwc2UgV2ViIFRvb2xzIFBsYXRmb3JtIChXVFApIFByb2plY3QgdXBkYXRlIHNpdGUKLQotIyAiZGVzY3JpcHRpb24iIHByb3BlcnR5IC0gZGVzY3JpcHRpb24gb2YgdGhlIGZlYXR1cmUKLWRlc2NyaXB0aW9uPUphdmEgUGVyc2lzdGVuY2UgQVBJIFRvb2xzIC0gRWNsaXBzZUxpbmsgU3VwcG9ydCAoT3B0aW9uYWwpCi0KLSMgImNvcHlyaWdodCIgcHJvcGVydHkgLSB0ZXh0IG9mIHRoZSAiRmVhdHVyZSBVcGRhdGUgQ29weXJpZ2h0IgotY29weXJpZ2h0PVwKLUNvcHlyaWdodCAoYykgMjAwNi0wOCBPcmFjbGUgQ29ycG9yYXRpb24uXG5cCi1BbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzXG5cCi1hcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjBcblwKLXdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0XG5cCi1odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbFxuXAotXG5cCi1Db250cmlidXRvcnM6XG5cCi0gICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uXG4KLSMjIyMjIyMjIyMjIyMjIyMgZW5kIG9mIGNvcHlyaWdodCBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotIyAibGljZW5zZVVSTCIgcHJvcGVydHkgLSBVUkwgb2YgdGhlICJGZWF0dXJlIExpY2Vuc2UiCi0jIGRvIG5vdCB0cmFuc2xhdGUgdmFsdWUgLSBqdXN0IGNoYW5nZSB0byBwb2ludCB0byBhIGxvY2FsZS1zcGVjaWZpYyBIVE1MIHBhZ2UKLWxpY2Vuc2VVUkw9bGljZW5zZS5odG1sCi0KLSMgImxpY2Vuc2UiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIExpY2Vuc2UiCi0jIHNob3VsZCBiZSBwbGFpbiB0ZXh0IHZlcnNpb24gb2YgbGljZW5zZSBhZ3JlZW1lbnQgcG9pbnRlZCB0byBiZSAibGljZW5zZVVSTCIKLWxpY2Vuc2U9XAotRUNMSVBTRSBGT1VOREFUSU9OIFNPRlRXQVJFIFVTRVIgQUdSRUVNRU5UXG5cCi1KdW5lIDA2LCAyMDA3XG5cCi1cblwKLVVzYWdlIE9mIENvbnRlbnRcblwKLVxuXAotVEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUlxuXAotT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUyAoQ09MTEVDVElWRUxZICJDT05URU5UIikuXG5cCi1VU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVNcblwKLUFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUlxuXAotTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVVxuXAotQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVFxuXAotQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFNcblwKLU9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFXG5cCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TXG5cCi1PRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRFxuXAotQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULlxuXAotXG5cCi1BcHBsaWNhYmxlIExpY2Vuc2VzXG5cCi1cblwKLVVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uXG5cCi1pcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpY1xuXAotTGljZW5zZSBWZXJzaW9uIDEuMCAoIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXNcblwKLUNvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLlxuXAotRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuXG5cCi1cblwKLUNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLFxuXAotZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZS5vcmcgQ1ZTXG5cCi1yZXBvc2l0b3J5ICgiUmVwb3NpdG9yeSIpIGluIENWUyBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIGF2YWlsYWJsZVxuXAotYXMgZG93bmxvYWRhYmxlIGFyY2hpdmVzICgiRG93bmxvYWRzIikuXG5cCi1cblwKLSAgIC0gQ29udGVudCBtYXkgYmUgc3RydWN0dXJlZCBhbmQgcGFja2FnZWQgaW50byBtb2R1bGVzIHRvIGZhY2lsaXRhdGUgZGVsaXZlcmluZyxcblwKLSAgICAgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiBUeXBpY2FsIG1vZHVsZXMgbWF5IGluY2x1ZGUgcGx1Zy1pbnMgKCJQbHVnLWlucyIpLFxuXAotICAgICBwbHVnLWluIGZyYWdtZW50cyAoIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLlxuXAotICAgLSBFYWNoIFBsdWctaW4gb3IgRnJhZ21lbnQgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBvciBKQVIgKEphdmE/IEFSY2hpdmUpXG5cCi0gICAgIGluIGEgZGlyZWN0b3J5IG5hbWVkICJwbHVnaW5zIi5cblwKLSAgIC0gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuXG5cCi0gICAgIEVhY2ggRmVhdHVyZSBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IGluIGEgZGlyZWN0b3J5IG5hbWVkICJmZWF0dXJlcyIuXG5cCi0gICAgIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvblxuXAotICAgICBudW1iZXJzIG9mIHRoZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuXG5cCi0gICAtIEZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlc1xuXAotICAgICBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy5cblwKLVxuXAotRmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIEZpbGVzIG5hbWVkXG5cCi0iZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZlxuXAotSW5jbHVkZWQgRmVhdHVyZXMuXG5cCi1cblwKLVRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmVcblwKLWNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZFxuXAotY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kIEluY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWRcblwKLWluIGZpbGVzIG5hbWVkICJsaWNlbnNlLmh0bWwiICgiRmVhdHVyZSBMaWNlbnNlcyIpLiBBYm91dHMgYW5kIEZlYXR1cmVcblwKLUxpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSBkaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGVcblwKLWluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOlxuXAotXG5cCi0gICAtIFRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeVxuXAotICAgLSBQbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3Rvcmllc1xuXAotICAgLSBJbnNpZGUgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBwYWNrYWdlZCBhcyBKQVJzXG5cCi0gICAtIFN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnNcblwKLSAgIC0gRmVhdHVyZSBkaXJlY3Rvcmllc1xuXAotXG5cCi1Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlXG5cCi1FY2xpcHNlIFVwZGF0ZSBNYW5hZ2VyLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFVwZGF0ZVxuXAotTGljZW5zZSIpIGR1cmluZyB0aGUgaW5zdGFsbGF0aW9uIHByb2Nlc3MuIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zXG5cCi1JbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdVxuXAotd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvciBpbmZvcm1cblwKLXlvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW5cblwKLXRoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIuIFN1Y2ggQWJvdXRzLFxuXAotRmVhdHVyZSBMaWNlbnNlcyBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kXG5cCi1jb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXJcblwKLXVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluIHRoYXQgZGlyZWN0b3J5LlxuXAotXG5cCi1USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVJcblwKLVRPIFRIRSBFUEwgT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLlxuXAotU09NRSBPRiBUSEVTRSBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOlxuXAotXG5cCi0gICAgLSBDb21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbClcblwKLSAgICAtIEFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFKVxuXAotICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wKVxuXAotICAgIC0gSUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sKVxuXAotICAgIC0gTWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwpXG5cCi0gICAgLSBNb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sKVxuXAotICAgIC0gQ29tbW9uIERldmVsb3BtZW50IGFuZCBEaXN0cmlidXRpb24gTGljZW5zZSAoQ0RETCkgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwpXG5cCi1cblwKLUlUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1JcblwKLVRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlXG5cCi1pcyBwcm92aWRlZCwgcGxlYXNlIGNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9uc1xuXAotZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LlxuXAotXG5cCi1DcnlwdG9ncmFwaHlcblwKLVxuXAotQ29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlXG5cCi1jdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsXG5cCi1hbmQvb3IgcmUtZXhwb3J0IHRvIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFXG5cCi11c2luZyBhbnkgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cyxcblwKLXJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIG9yIHVzZSxcblwKLWFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLlxuXAotXG5cCi1KYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIFN1biBNaWNyb3N5c3RlbXMsIEluYy4gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC5cbgotIyMjIyMjIyMjIyMgZW5kIG9mIGxpY2Vuc2UgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvZmVhdHVyZS54bWwgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvZmVhdHVyZS54bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGU2MGFiNzMuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL2ZlYXR1cmUueG1sCisrKyAvZGV2L251bGwKQEAgLTEsNTIgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxmZWF0dXJlCi0gICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUiCi0gICAgICBsYWJlbD0iJWZlYXR1cmVOYW1lIgotICAgICAgdmVyc2lvbj0iMi4yLjAucXVhbGlmaWVyIgotICAgICAgcHJvdmlkZXItbmFtZT0iJXByb3ZpZGVyTmFtZSIKLSAgICAgIGltYWdlPSJlY2xpcHNlX3VwZGF0ZV8xMjAuanBnIj4KLQotICAgPGRlc2NyaXB0aW9uPgotICAgICAgJWRlc2NyaXB0aW9uCi0gICA8L2Rlc2NyaXB0aW9uPgotCi0gICA8Y29weXJpZ2h0PgotICAgICAgJWNvcHlyaWdodAotICAgPC9jb3B5cmlnaHQ+Ci0KLSAgIDxsaWNlbnNlIHVybD0ibGljZW5zZS5odG1sIj4KLSAgICAgICVsaWNlbnNlCi0gICA8L2xpY2Vuc2U+Ci0KLSAgIDx1cmw+Ci0gICAgICA8dXBkYXRlIGxhYmVsPSJXZWIgVG9vbHMgUGxhdGZvcm0gKFdUUCkgVXBkYXRlcyIgdXJsPSJodHRwOi8vZG93bmxvYWQuZWNsaXBzZS5vcmcvd2VidG9vbHMvdXBkYXRlcyIvPgotICAgICAgPGRpc2NvdmVyeSBsYWJlbD0iV2ViIFRvb2xzIFBsYXRmb3JtIChXVFApIFVwZGF0ZXMiIHVybD0iaHR0cDovL2Rvd25sb2FkLmVjbGlwc2Uub3JnL3dlYnRvb2xzL3VwZGF0ZXMiLz4KLSAgICAgIDxkaXNjb3ZlcnkgbGFiZWw9IkRhbGkgSmF2YSBQZXJzaXN0ZW5jZSBBUEkgVG9vbHMgKEpQQSkgVXBkYXRlcyIgdXJsPSJodHRwOi8vZG93bmxvYWQuZWNsaXBzZS5vcmcvd2VidG9vbHMvdXBkYXRlcy8iLz4KLSAgIDwvdXJsPgotCi0gICA8cmVxdWlyZXM+Ci0gICAgICA8aW1wb3J0IGZlYXR1cmU9Im9yZy5lY2xpcHNlLmpwdC5mZWF0dXJlIiB2ZXJzaW9uPSIyLjIuMCIvPgotICAgPC9yZXF1aXJlcz4KLQotICAgPHBsdWdpbgotICAgICAgICAgaWQ9Im9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlIgotICAgICAgICAgZG93bmxvYWQtc2l6ZT0iMCIKLSAgICAgICAgIGluc3RhbGwtc2l6ZT0iMCIKLSAgICAgICAgIHZlcnNpb249IjAuMC4wIgotICAgICAgICAgdW5wYWNrPSJmYWxzZSIvPgotCi0gICA8cGx1Z2luCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpIgotICAgICAgICAgZG93bmxvYWQtc2l6ZT0iMCIKLSAgICAgICAgIGluc3RhbGwtc2l6ZT0iMCIKLSAgICAgICAgIHZlcnNpb249IjAuMC4wIgotICAgICAgICAgdW5wYWNrPSJmYWxzZSIvPgotCi0gICA8cGx1Z2luCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuIgotICAgICAgICAgZG93bmxvYWQtc2l6ZT0iMCIKLSAgICAgICAgIGluc3RhbGwtc2l6ZT0iMCIKLSAgICAgICAgIHZlcnNpb249IjAuMC4wIgotICAgICAgICAgdW5wYWNrPSJmYWxzZSIvPgotCi08L2ZlYXR1cmU+CmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvbGljZW5zZS5odG1sIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL2xpY2Vuc2UuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZmM3NzM3Mi4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvbGljZW5zZS5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsOTggKzAsMCBAQAotPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEgVHJhbnNpdGlvbmFsLy9FTiIgImh0dHA6Ly93d3cudzNjLm9yZy9UUi8xOTk5L1JFQy1odG1sNDAxLTE5OTkxMjI0L2xvb3NlLmR0ZCI+Ci08IS0tIHNhdmVkIGZyb20gdXJsPSgwMDQ0KWh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsL25vdGljZS5odG1sIC0tPgotPEhUTUw+PEhFQUQ+PFRJVExFPkVjbGlwc2Uub3JnIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9USVRMRT4KLTxNRVRBIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4KLTxNRVRBIGNvbnRlbnQ9Ik1TSFRNTCA2LjAwLjI4MDAuMTQ3OSIgbmFtZT1HRU5FUkFUT1I+PC9IRUFEPgotPEJPRFkgbGFuZz1FTi1VUyB2TGluaz1wdXJwbGUgbGluaz1ibHVlPgotPEgyPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvSDI+Ci08UD5KdW5lIDA2LCAyMDA3PC9QPgotPEgzPlVzYWdlIE9mIENvbnRlbnQ8L0gzPgotPFA+VEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIAotQU5EL09SIE9USEVSIE1BVEVSSUFMUyBGT1IgT1BFTiBTT1VSQ0UgUFJPSkVDVFMgKENPTExFQ1RJVkVMWSAiQ09OVEVOVCIpLiBVU0UgT0YgCi1USEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSAKLVRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIAotQkVMT1cuIEJZIFVTSU5HIFRIRSBDT05URU5ULCBZT1UgQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCAKLUJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSAKLUFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSAKLUFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIAotTUFZIE5PVCBVU0UgVEhFIENPTlRFTlQuPC9QPgotPEgzPkFwcGxpY2FibGUgTGljZW5zZXM8L0gzPgotPFA+VW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIAotRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIAotUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKCJFUEwiKS4gQSBjb3B5IG9mIHRoZSBFUEwgaXMgcHJvdmlkZWQgd2l0aCB0aGlzIAotQ29udGVudCBhbmQgaXMgYWxzbyBhdmFpbGFibGUgYXQgPEEgCi1ocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L0E+LiAKLUZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAiUHJvZ3JhbSIgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvUD4KLTxQPkNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLCAKLWRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2Uub3JnIENWUyByZXBvc2l0b3J5IAotKCJSZXBvc2l0b3J5IikgaW4gQ1ZTIG1vZHVsZXMgKCJNb2R1bGVzIikgYW5kIG1hZGUgYXZhaWxhYmxlIGFzIGRvd25sb2FkYWJsZSAKLWFyY2hpdmVzICgiRG93bmxvYWRzIikuPC9QPgotPFA+Q29udGVudCBtYXkgYmUgYXBwb3J0aW9uZWQgaW50byBwbHVnLWlucyAoIlBsdWctaW5zIiksIHBsdWctaW4gZnJhZ21lbnRzIAotKCJGcmFnbWVudHMiKSwgYW5kIGZlYXR1cmVzICgiRmVhdHVyZXMiKS4gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIAotUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhbmQgYXNzb2NpYXRlZCBtYXRlcmlhbC4gRmlsZXMgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgCi1jb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyAKLWFzc29jaWF0ZWQgd2l0aCBhIEZlYXR1cmUuIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgYXJlIGxvY2F0ZWQgaW4gZGlyZWN0b3JpZXMgCi1uYW1lZCAicGx1Z2lucyIgYW5kIEZlYXR1cmVzIGFyZSBsb2NhdGVkIGluIGRpcmVjdG9yaWVzIG5hbWVkICJmZWF0dXJlcyIuPC9QPgotPFA+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIEZpbGVzIG5hbWVkIAotImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgCi1GZWF0dXJlcy48L1A+Ci08UD5UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlIGNvbnRhaW5lZCAKLWluIGZpbGVzIG5hbWVkICJhYm91dC5odG1sIiAoIkFib3V0cyIpLiBUaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIAotRmVhdHVyZXMgYW5kIEluY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgImxpY2Vuc2UuaHRtbCIgCi0oIkZlYXR1cmUgTGljZW5zZXMiKS4gQWJvdXRzIGFuZCBGZWF0dXJlIExpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSAKLWRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZSBpbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIAotbG9jYXRpb25zOjwvUD4KLTxVTD4KLSAgPExJPlRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeSAKLSAgPExJPlBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzIAotICA8TEk+U3ViZGlyZWN0b3JpZXMgb2YgdGhlIGRpcmVjdG9yeSBuYW1lZCAic3JjIiBvZiBjZXJ0YWluIFBsdWctaW5zIAotICA8TEk+RmVhdHVyZSBkaXJlY3RvcmllcyA8L0xJPjwvVUw+Ci08UD5Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgCi11c2luZyB0aGUgRWNsaXBzZSBVcGRhdGUgTWFuYWdlciwgeW91IG11c3QgYWdyZWUgdG8gYSBsaWNlbnNlICgiRmVhdHVyZSBVcGRhdGUgCi1MaWNlbnNlIikgZHVyaW5nIHRoZSBpbnN0YWxsYXRpb24gcHJvY2Vzcy4gSWYgdGhlIEZlYXR1cmUgY29udGFpbnMgSW5jbHVkZWQgCi1GZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdSB3aXRoIHRoZSB0ZXJtcyAKLWFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IgaW5mb3JtIHlvdSB3aGVyZSB5b3UgY2FuIAotbG9jYXRlIHRoZW0uIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSBmb3VuZCBpbiB0aGUgImxpY2Vuc2UiIHByb3BlcnR5IG9mIAotZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIuIFN1Y2ggQWJvdXRzLCBGZWF0dXJlIExpY2Vuc2VzIGFuZCBGZWF0dXJlIAotVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgCi1hbmQgY29uZGl0aW9ucykgdGhhdCBnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbiB0aGF0IAotZGlyZWN0b3J5LjwvUD4KLTxQPlRIRSBBQk9VVFMsIEZFQVRVUkUgTElDRU5TRVMgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUiBUTyBUSEUgRVBMIAotT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLiBTT01FIE9GIFRIRVNFIAotT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTo8L1A+Ci08VUw+Ci0gIDxMST5Db21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sPC9BPikgCi0KLSAgPExJPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRSI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0U8L0E+KSAKLQotICA8TEk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMCI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wPC9BPikgCi0KLSAgPExJPklCTSBQdWJsaWMgTGljZW5zZSAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2RldmVsb3BlcndvcmtzL29wZW5zb3VyY2UvbGljZW5zZTEwLmh0bWwiPmh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sPC9BPikgCi0KLSAgPExJPk1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbCI+aHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWw8L0E+KSAKLQotICA8TEk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWwiPmh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbDwvQT4pIAotICA8L0xJPgotICAKLSAgPExJPkNvbW1vbiBEZXZlbG9wbWVudCBhbmQgRGlzdHJpYnV0aW9uIExpY2Vuc2UgKENEREwpIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuc3VuLmNvbS9jZGRsL2NkZGwuaHRtbCI+aHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sKTwvQT4KLSAgPC9MST4KLTwvVUw+Ci08UD5JVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCBDT05ESVRJT05TIFBSSU9SIAotVE8gVVNFIE9GIFRIRSBDT05URU5ULiBJZiBubyBBYm91dCwgRmVhdHVyZSBMaWNlbnNlIG9yIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2UgaXMgCi1wcm92aWRlZCwgcGxlYXNlIGNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgCi1jb25kaXRpb25zIGdvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC48L1A+Ci08SDM+Q3J5cHRvZ3JhcGh5PC9IMz4KLTxQPkNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZSAKLWN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSwgYW5kL29yIAotcmUtZXhwb3J0IHRvIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFIHVzaW5nIGFueSAKLWVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsIHJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyAKLWNvbmNlcm5pbmcgdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgb3IgdXNlLCBhbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIAotdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLjwvUD48L0JPRFk+PC9IVE1MPgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2Fib3V0Lmh0bWwgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvYWJvdXQuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDQ5MTZkZi4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvYWJvdXQuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDI3ICswLDAgQEAKLTwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAvL0VOIj4KLTxodG1sPgotPGhlYWQ+Ci08dGl0bGU+QWJvdXQ8L3RpdGxlPgotPG1ldGEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiPgotPC9oZWFkPgotPGJvZHkgbGFuZz0iRU4tVVMiPgotPGgyPkFib3V0IFRoaXMgQ29udGVudDwvaDI+Ci0KLTxwPkp1bmUgMDYsIDIwMDc8L3A+CQotPGgzPkxpY2Vuc2U8L2gzPgotCi08cD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBhbGwgY29udGVudCBpbiB0aGlzIHBsdWctaW4gKCZxdW90O0NvbnRlbnQmcXVvdDspLiAgVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQgYmVsb3csIHRoZSBDb250ZW50IGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlCi1FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wICgmcXVvdDtFUEwmcXVvdDspLiAgQSBjb3B5IG9mIHRoZSBFUEwgaXMgYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT4uCi1Gb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgJnF1b3Q7UHJvZ3JhbSZxdW90OyB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9wPgotCi08cD5JZiB5b3UgZGlkIG5vdCByZWNlaXZlIHRoaXMgQ29udGVudCBkaXJlY3RseSBmcm9tIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24sIHRoZSBDb250ZW50IGlzIGJlaW5nIHJlZGlzdHJpYnV0ZWQgYnkgYW5vdGhlciBwYXJ0eSAoJnF1b3Q7UmVkaXN0cmlidXRvciZxdW90OykgYW5kIGRpZmZlcmVudCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBtYXkKLWFwcGx5IHRvIHlvdXIgdXNlIG9mIGFueSBvYmplY3QgY29kZSBpbiB0aGUgQ29udGVudC4gIENoZWNrIHRoZSBSZWRpc3RyaWJ1dG9yJ3MgbGljZW5zZSB0aGF0IHdhcyBwcm92aWRlZCB3aXRoIHRoZSBDb250ZW50LiAgSWYgbm8gc3VjaCBsaWNlbnNlIGV4aXN0cywgY29udGFjdCB0aGUgUmVkaXN0cmlidXRvci4gIFVubGVzcyBvdGhlcndpc2UKLWluZGljYXRlZCBiZWxvdywgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFUEwgc3RpbGwgYXBwbHkgdG8gYW55IHNvdXJjZSBjb2RlIGluIHRoZSBDb250ZW50LjwvcD4KLQotPGgzPlNvdXJjZSBDb2RlPC9oMz4KLTxwPlRoaXMgcGx1Zy1pbiBjb250YWlucyBzb3VyY2UgY29kZSB6aXAgZmlsZXMgKCZxdW90O1NvdXJjZSBaaXBzJnF1b3Q7KSB0aGF0IGNvcnJlc3BvbmQgdG8gYmluYXJ5IGNvbnRlbnQgaW4gb3RoZXIgcGx1Zy1pbnMuIFRoZXNlIFNvdXJjZSBaaXBzIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciBkaWZmZXJlbnQgbGljZW5zZQotYWdyZWVtZW50cyBhbmQvb3Igbm90aWNlcy4gRGV0YWlscyBhYm91dCB0aGVzZSBsaWNlbnNlIGFncmVlbWVudHMgYW5kIG5vdGljZXMgYXJlIGNvbnRhaW5lZCBpbiAmcXVvdDthYm91dC5odG1sJnF1b3Q7IGZpbGVzICgmcXVvdDtBYm91dHMmcXVvdDspIGxvY2F0ZWQgaW4gc3ViLWRpcmVjdG9yaWVzIGluIHRoZQotc3JjLyBkaXJlY3Rvcnkgb2YgdGhpcyBwbHVnLWluLiBTdWNoIEFib3V0cyBnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIFNvdXJjZSBaaXBzIGluIHRoYXQgZGlyZWN0b3J5LCBub3QgdGhlIEVQTC48L3A+Ci0KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9hYm91dC5pbmkgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvYWJvdXQuaW5pCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyZGVlMzZhLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9hYm91dC5pbmkKKysrIC9kZXYvbnVsbApAQCAtMSwzMSArMCwwIEBACi0jIGFib3V0LmluaQotIyBjb250YWlucyBpbmZvcm1hdGlvbiBhYm91dCBhIGZlYXR1cmUKLSMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKLSMgIiVrZXkiIGFyZSBleHRlcm5hbGl6ZWQgc3RyaW5ncyBkZWZpbmVkIGluIGFib3V0LnByb3BlcnRpZXMKLSMgVGhpcyBmaWxlIGRvZXMgbm90IG5lZWQgdG8gYmUgdHJhbnNsYXRlZC4KLQotIyBQcm9wZXJ0eSAiYWJvdXRUZXh0IiBjb250YWlucyBibHVyYiBmb3IgIkFib3V0IiBkaWFsb2cgKHRyYW5zbGF0ZWQpCi1hYm91dFRleHQ9JWJsdXJiCi0KLSMgUHJvcGVydHkgIndpbmRvd0ltYWdlIiBjb250YWlucyBwYXRoIHRvIHdpbmRvdyBpY29uICgxNngxNikKLSMgbmVlZGVkIGZvciBwcmltYXJ5IGZlYXR1cmVzIG9ubHkKLQotIyBQcm9wZXJ0eSAiZmVhdHVyZUltYWdlIiBjb250YWlucyBwYXRoIHRvIGZlYXR1cmUgaW1hZ2UgKDMyeDMyKQotZmVhdHVyZUltYWdlPWVjbGlwc2UzMi5naWYKLQotIyBQcm9wZXJ0eSAiYWJvdXRJbWFnZSIgY29udGFpbnMgcGF0aCB0byBwcm9kdWN0IGltYWdlICg1MDB4MzMwIG9yIDExNXgxNjQpCi0jIG5lZWRlZCBmb3IgcHJpbWFyeSBmZWF0dXJlcyBvbmx5Ci0KLSMgUHJvcGVydHkgImFwcE5hbWUiIGNvbnRhaW5zIG5hbWUgb2YgdGhlIGFwcGxpY2F0aW9uIChub3QgdHJhbnNsYXRlZCkKLSMgbmVlZGVkIGZvciBwcmltYXJ5IGZlYXR1cmVzIG9ubHkKLQotIyBQcm9wZXJ0eSAid2VsY29tZVBhZ2UiIGNvbnRhaW5zIHBhdGggdG8gd2VsY29tZSBwYWdlIChzcGVjaWFsIFhNTC1iYXNlZCBmb3JtYXQpCi0jIG9wdGlvbmFsCi0KLSMgUHJvcGVydHkgIndlbGNvbWVQZXJzcGVjdGl2ZSIgY29udGFpbnMgdGhlIGlkIG9mIHRoZSBwZXJzcGVjdGl2ZSBpbiB3aGljaCB0aGUKLSMgd2VsY29tZSBwYWdlIGlzIHRvIGJlIG9wZW5lZC4KLSMgb3B0aW9uYWwKLQotCi0KLQpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2Fib3V0Lm1hcHBpbmdzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2Fib3V0Lm1hcHBpbmdzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhMjgzOTBhLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9hYm91dC5tYXBwaW5ncworKysgL2Rldi9udWxsCkBAIC0xLDYgKzAsMCBAQAotIyBhYm91dC5tYXBwaW5ncwotIyBjb250YWlucyBmaWxsLWlucyBmb3IgYWJvdXQucHJvcGVydGllcwotIyBqYXZhLmlvLlByb3BlcnRpZXMgZmlsZSAoSVNPIDg4NTktMSB3aXRoICJcIiBlc2NhcGVzKQotIyBUaGlzIGZpbGUgZG9lcyBub3QgbmVlZCB0byBiZSB0cmFuc2xhdGVkLgotCi0wPUBidWlsZEAKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9hYm91dC5wcm9wZXJ0aWVzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2Fib3V0LnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDUwYzBhOWUuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2Fib3V0LnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwyNiArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgYWJvdXQucHJvcGVydGllcwotIyBjb250YWlucyBleHRlcm5hbGl6ZWQgc3RyaW5ncyBmb3IgYWJvdXQuaW5pCi0jIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCi0jIGZpbGwtaW5zIGFyZSBzdXBwbGllZCBieSBhYm91dC5tYXBwaW5ncwotIyBUaGlzIGZpbGUgc2hvdWxkIGJlIHRyYW5zbGF0ZWQuCi0jCi0jIERvIG5vdCB0cmFuc2xhdGUgYW55IHZhbHVlcyBzdXJyb3VuZGVkIGJ5IHt9Ci0KLWJsdXJiPUphdmEgUGVyc2lzdGVuY2UgQVBJIFRvb2xzIC0gRWNsaXBzZUxpbmsgU3VwcG9ydCBTb3VyY2VcblwKLVxuXAotVmVyc2lvbjoge2ZlYXR1cmVWZXJzaW9ufVxuXAotQnVpbGQgaWQ6IHswfVxuXAotXG5cCi0oYykgQ29weXJpZ2h0IEVjbGlwc2UgY29udHJpYnV0b3JzIGFuZCBvdGhlcnMgMjAwNS4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG5cCi1WaXNpdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL3dlYnRvb2xzCi0KZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9idWlsZC5wcm9wZXJ0aWVzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2J1aWxkLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDZkY2ZjZDYuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2J1aWxkLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwyMSArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLWJpbi5pbmNsdWRlcyA9IFwKLSAgICAgICAgICAgICAgIGFib3V0Lmh0bWwsXAotICAgICAgICAgICAgICAgYWJvdXQuaW5pLFwKLSAgICAgICAgICAgICAgIGFib3V0Lm1hcHBpbmdzLFwKLSAgICAgICAgICAgICAgIGFib3V0LnByb3BlcnRpZXMsXAotICAgICAgICAgICAgICAgZWNsaXBzZTMyLmdpZixcCi0gICAgICAgICAgICAgICBwbHVnaW4ucHJvcGVydGllcyxcCi0gICAgICAgICAgICAgICBwbHVnaW4ueG1sLFwKLSAgICAgICAgICAgICAgIHNyYy8qKixcCi0gICAgICAgICAgICAgICBNRVRBLUlORi8KLXNvdXJjZVBsdWdpbiA9IHRydWUKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9lY2xpcHNlMzIuZ2lmIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2VjbGlwc2UzMi5naWYKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGU2YWQ3Y2MuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2VjbGlwc2UzMi5naWYKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvZWNsaXBzZTMyLnBuZyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9lY2xpcHNlMzIucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1MGFlNDlkLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9lY2xpcHNlMzIucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2VjbGlwc2VfdXBkYXRlXzEyMC5qcGcgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmZkZjcwOC4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9lcGwtdjEwLmh0bWwgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvZXBsLXYxMC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMjJhZDI5Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9lcGwtdjEwLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSwzMjggKzAsMCBAQAotPGh0bWwgeG1sbnM6bz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6b2ZmaWNlIgoteG1sbnM6dz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6d29yZCIKLXhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy9UUi9SRUMtaHRtbDQwIj4KLQotPGhlYWQ+Ci08bWV0YSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9d2luZG93cy0xMjUyIj4KLTxtZXRhIG5hbWU9UHJvZ0lkIGNvbnRlbnQ9V29yZC5Eb2N1bWVudD4KLTxtZXRhIG5hbWU9R2VuZXJhdG9yIGNvbnRlbnQ9Ik1pY3Jvc29mdCBXb3JkIDkiPgotPG1ldGEgbmFtZT1PcmlnaW5hdG9yIGNvbnRlbnQ9Ik1pY3Jvc29mdCBXb3JkIDkiPgotPGxpbmsgcmVsPUZpbGUtTGlzdAotaHJlZj0iLi9FY2xpcHNlJTIwRVBMJTIwMjAwM18xMV8xMCUyMEZpbmFsX2ZpbGVzL2ZpbGVsaXN0LnhtbCI+Ci08dGl0bGU+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIFZlcnNpb24gMS4wPC90aXRsZT4KLTwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDxvOkRvY3VtZW50UHJvcGVydGllcz4KLSAgPG86UmV2aXNpb24+MjwvbzpSZXZpc2lvbj4KLSAgPG86VG90YWxUaW1lPjM8L286VG90YWxUaW1lPgotICA8bzpDcmVhdGVkPjIwMDQtMDMtMDVUMjM6MDM6MDBaPC9vOkNyZWF0ZWQ+Ci0gIDxvOkxhc3RTYXZlZD4yMDA0LTAzLTA1VDIzOjAzOjAwWjwvbzpMYXN0U2F2ZWQ+Ci0gIDxvOlBhZ2VzPjQ8L286UGFnZXM+Ci0gIDxvOldvcmRzPjE2MjY8L286V29yZHM+Ci0gIDxvOkNoYXJhY3RlcnM+OTI3MDwvbzpDaGFyYWN0ZXJzPgotICAgPG86TGluZXM+Nzc8L286TGluZXM+Ci0gIDxvOlBhcmFncmFwaHM+MTg8L286UGFyYWdyYXBocz4KLSAgPG86Q2hhcmFjdGVyc1dpdGhTcGFjZXM+MTEzODQ8L286Q2hhcmFjdGVyc1dpdGhTcGFjZXM+Ci0gIDxvOlZlcnNpb24+OS40NDAyPC9vOlZlcnNpb24+Ci0gPC9vOkRvY3VtZW50UHJvcGVydGllcz4KLTwveG1sPjwhW2VuZGlmXS0tPjwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDx3OldvcmREb2N1bWVudD4KLSAgPHc6VHJhY2tSZXZpc2lvbnMvPgotIDwvdzpXb3JkRG9jdW1lbnQ+Ci08L3htbD48IVtlbmRpZl0tLT4KLTxzdHlsZT4KLTwhLS0KLSAvKiBGb250IERlZmluaXRpb25zICovCi1AZm9udC1mYWNlCi0Je2ZvbnQtZmFtaWx5OlRhaG9tYTsKLQlwYW5vc2UtMToyIDExIDYgNCAzIDUgNCA0IDIgNDsKLQltc28tZm9udC1jaGFyc2V0OjA7Ci0JbXNvLWdlbmVyaWMtZm9udC1mYW1pbHk6c3dpc3M7Ci0JbXNvLWZvbnQtcGl0Y2g6dmFyaWFibGU7Ci0JbXNvLWZvbnQtc2lnbmF0dXJlOjU1MzY3OTQ5NSAtMjE0NzQ4MzY0OCA4IDAgNjYwNDcgMDt9Ci0gLyogU3R5bGUgRGVmaW5pdGlvbnMgKi8KLXAuTXNvTm9ybWFsLCBsaS5Nc29Ob3JtYWwsIGRpdi5Nc29Ob3JtYWwKLQl7bXNvLXN0eWxlLXBhcmVudDoiIjsKLQltYXJnaW46MGluOwotCW1hcmdpbi1ib3R0b206LjAwMDFwdDsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjEyLjBwdDsKLQlmb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1wCi0Je21hcmdpbi1yaWdodDowaW47Ci0JbXNvLW1hcmdpbi10b3AtYWx0OmF1dG87Ci0JbXNvLW1hcmdpbi1ib3R0b20tYWx0OmF1dG87Ci0JbWFyZ2luLWxlZnQ6MGluOwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXAuQmFsbG9vblRleHQsIGxpLkJhbGxvb25UZXh0LCBkaXYuQmFsbG9vblRleHQKLQl7bXNvLXN0eWxlLW5hbWU6IkJhbGxvb24gVGV4dCI7Ci0JbWFyZ2luOjBpbjsKLQltYXJnaW4tYm90dG9tOi4wMDAxcHQ7Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZTo4LjBwdDsKLQlmb250LWZhbWlseTpUYWhvbWE7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotQHBhZ2UgU2VjdGlvbjEKLQl7c2l6ZTo4LjVpbiAxMS4waW47Ci0JbWFyZ2luOjEuMGluIDEuMjVpbiAxLjBpbiAxLjI1aW47Ci0JbXNvLWhlYWRlci1tYXJnaW46LjVpbjsKLQltc28tZm9vdGVyLW1hcmdpbjouNWluOwotCW1zby1wYXBlci1zb3VyY2U6MDt9Ci1kaXYuU2VjdGlvbjEKLQl7cGFnZTpTZWN0aW9uMTt9Ci0tLT4KLTwvc3R5bGU+Ci08L2hlYWQ+Ci0KLTxib2R5IGxhbmc9RU4tVVMgc3R5bGU9J3RhYi1pbnRlcnZhbDouNWluJz4KLQotPGRpdiBjbGFzcz1TZWN0aW9uMT4KLQotPHAgYWxpZ249Y2VudGVyIHN0eWxlPSd0ZXh0LWFsaWduOmNlbnRlcic+PGI+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIHYgMS4wPC9iPgotPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+VEhFIEFDQ09NUEFOWUlORyBQUk9HUkFNIElTIFBST1ZJREVEIFVOREVSCi1USEUgVEVSTVMgT0YgVEhJUyBFQ0xJUFNFIFBVQkxJQyBMSUNFTlNFICgmcXVvdDtBR1JFRU1FTlQmcXVvdDspLiBBTlkgVVNFLAotUkVQUk9EVUNUSU9OIE9SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBDT05TVElUVVRFUyBSRUNJUElFTlQnUyBBQ0NFUFRBTkNFCi1PRiBUSElTIEFHUkVFTUVOVC48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjEuIERFRklOSVRJT05TPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7Q29udHJpYnV0aW9uJnF1b3Q7IG1lYW5zOjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaW4gdGhlIGNhc2Ugb2YgdGhlIGluaXRpYWwgQ29udHJpYnV0b3IsIHRoZSBpbml0aWFsIGNvZGUgYW5kIGRvY3VtZW50YXRpb24KLWRpc3RyaWJ1dGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBhbmQ8YnIgY2xlYXI9bGVmdD4KLWIpIGluIHRoZSBjYXNlIG9mIGVhY2ggc3Vic2VxdWVudCBDb250cmlidXRvcjo8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pKQotY2hhbmdlcyB0byB0aGUgUHJvZ3JhbSwgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWkpCi1hZGRpdGlvbnMgdG8gdGhlIFByb2dyYW07PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+d2hlcmUKLXN1Y2ggY2hhbmdlcyBhbmQvb3IgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIG9yaWdpbmF0ZSBmcm9tIGFuZCBhcmUgZGlzdHJpYnV0ZWQKLWJ5IHRoYXQgcGFydGljdWxhciBDb250cmlidXRvci4gQSBDb250cmlidXRpb24gJ29yaWdpbmF0ZXMnIGZyb20gYSBDb250cmlidXRvcgotaWYgaXQgd2FzIGFkZGVkIHRvIHRoZSBQcm9ncmFtIGJ5IHN1Y2ggQ29udHJpYnV0b3IgaXRzZWxmIG9yIGFueW9uZSBhY3Rpbmcgb24KLXN1Y2ggQ29udHJpYnV0b3IncyBiZWhhbGYuIENvbnRyaWJ1dGlvbnMgZG8gbm90IGluY2x1ZGUgYWRkaXRpb25zIHRvIHRoZQotUHJvZ3JhbSB3aGljaDogKGkpIGFyZSBzZXBhcmF0ZSBtb2R1bGVzIG9mIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIGluIGNvbmp1bmN0aW9uCi13aXRoIHRoZSBQcm9ncmFtIHVuZGVyIHRoZWlyIG93biBsaWNlbnNlIGFncmVlbWVudCwgYW5kIChpaSkgYXJlIG5vdCBkZXJpdmF0aXZlCi13b3JrcyBvZiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0NvbnRyaWJ1dG9yJnF1b3Q7IG1lYW5zIGFueSBwZXJzb24gb3IKLWVudGl0eSB0aGF0IGRpc3RyaWJ1dGVzIHRoZSBQcm9ncmFtLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7TGljZW5zZWQgUGF0ZW50cyAmcXVvdDsgbWVhbiBwYXRlbnQKLWNsYWltcyBsaWNlbnNhYmxlIGJ5IGEgQ29udHJpYnV0b3Igd2hpY2ggYXJlIG5lY2Vzc2FyaWx5IGluZnJpbmdlZCBieSB0aGUgdXNlCi1vciBzYWxlIG9mIGl0cyBDb250cmlidXRpb24gYWxvbmUgb3Igd2hlbiBjb21iaW5lZCB3aXRoIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7UHJvZ3JhbSZxdW90OyBtZWFucyB0aGUgQ29udHJpYnV0aW9ucwotZGlzdHJpYnV0ZWQgaW4gYWNjb3JkYW5jZSB3aXRoIHRoaXMgQWdyZWVtZW50Ljwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7UmVjaXBpZW50JnF1b3Q7IG1lYW5zIGFueW9uZSB3aG8KLXJlY2VpdmVzIHRoZSBQcm9ncmFtIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBpbmNsdWRpbmcgYWxsIENvbnRyaWJ1dG9ycy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjIuIEdSQU5UIE9GIFJJR0hUUzwvc3Bhbj48L2I+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLVN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50Ci1hIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwgcm95YWx0eS1mcmVlIGNvcHlyaWdodCBsaWNlbnNlIHRvPHNwYW4KLXN0eWxlPSdjb2xvcjpyZWQnPiA8L3NwYW4+cmVwcm9kdWNlLCBwcmVwYXJlIGRlcml2YXRpdmUgd29ya3Mgb2YsIHB1YmxpY2x5Ci1kaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBkaXN0cmlidXRlIGFuZCBzdWJsaWNlbnNlIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaAotQ29udHJpYnV0b3IsIGlmIGFueSwgYW5kIHN1Y2ggZGVyaXZhdGl2ZSB3b3JrcywgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlCi1mb3JtLjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpCi1TdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzCi1SZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsPHNwYW4gc3R5bGU9J2NvbG9yOmdyZWVuJz4gPC9zcGFuPnJveWFsdHktZnJlZQotcGF0ZW50IGxpY2Vuc2UgdW5kZXIgTGljZW5zZWQgUGF0ZW50cyB0byBtYWtlLCB1c2UsIHNlbGwsIG9mZmVyIHRvIHNlbGwsIGltcG9ydAotYW5kIG90aGVyd2lzZSB0cmFuc2ZlciB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgaW4gc291cmNlCi1jb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLiBUaGlzIHBhdGVudCBsaWNlbnNlIHNoYWxsIGFwcGx5IHRvIHRoZSBjb21iaW5hdGlvbgotb2YgdGhlIENvbnRyaWJ1dGlvbiBhbmQgdGhlIFByb2dyYW0gaWYsIGF0IHRoZSB0aW1lIHRoZSBDb250cmlidXRpb24gaXMgYWRkZWQKLWJ5IHRoZSBDb250cmlidXRvciwgc3VjaCBhZGRpdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGNhdXNlcyBzdWNoIGNvbWJpbmF0aW9uCi10byBiZSBjb3ZlcmVkIGJ5IHRoZSBMaWNlbnNlZCBQYXRlbnRzLiBUaGUgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgbm90IGFwcGx5IHRvCi1hbnkgb3RoZXIgY29tYmluYXRpb25zIHdoaWNoIGluY2x1ZGUgdGhlIENvbnRyaWJ1dGlvbi4gTm8gaGFyZHdhcmUgcGVyIHNlIGlzCi1saWNlbnNlZCBoZXJldW5kZXIuIDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmMpCi1SZWNpcGllbnQgdW5kZXJzdGFuZHMgdGhhdCBhbHRob3VnaCBlYWNoIENvbnRyaWJ1dG9yIGdyYW50cyB0aGUgbGljZW5zZXMgdG8gaXRzCi1Db250cmlidXRpb25zIHNldCBmb3J0aCBoZXJlaW4sIG5vIGFzc3VyYW5jZXMgYXJlIHByb3ZpZGVkIGJ5IGFueSBDb250cmlidXRvcgotdGhhdCB0aGUgUHJvZ3JhbSBkb2VzIG5vdCBpbmZyaW5nZSB0aGUgcGF0ZW50IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQotcmlnaHRzIG9mIGFueSBvdGhlciBlbnRpdHkuIEVhY2ggQ29udHJpYnV0b3IgZGlzY2xhaW1zIGFueSBsaWFiaWxpdHkgdG8gUmVjaXBpZW50Ci1mb3IgY2xhaW1zIGJyb3VnaHQgYnkgYW55IG90aGVyIGVudGl0eSBiYXNlZCBvbiBpbmZyaW5nZW1lbnQgb2YgaW50ZWxsZWN0dWFsCi1wcm9wZXJ0eSByaWdodHMgb3Igb3RoZXJ3aXNlLiBBcyBhIGNvbmRpdGlvbiB0byBleGVyY2lzaW5nIHRoZSByaWdodHMgYW5kCi1saWNlbnNlcyBncmFudGVkIGhlcmV1bmRlciwgZWFjaCBSZWNpcGllbnQgaGVyZWJ5IGFzc3VtZXMgc29sZSByZXNwb25zaWJpbGl0eQotdG8gc2VjdXJlIGFueSBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG5lZWRlZCwgaWYgYW55LiBGb3IgZXhhbXBsZSwKLWlmIGEgdGhpcmQgcGFydHkgcGF0ZW50IGxpY2Vuc2UgaXMgcmVxdWlyZWQgdG8gYWxsb3cgUmVjaXBpZW50IHRvIGRpc3RyaWJ1dGUKLXRoZSBQcm9ncmFtLCBpdCBpcyBSZWNpcGllbnQncyByZXNwb25zaWJpbGl0eSB0byBhY3F1aXJlIHRoYXQgbGljZW5zZSBiZWZvcmUKLWRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbS48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5kKQotRWFjaCBDb250cmlidXRvciByZXByZXNlbnRzIHRoYXQgdG8gaXRzIGtub3dsZWRnZSBpdCBoYXMgc3VmZmljaWVudCBjb3B5cmlnaHQKLXJpZ2h0cyBpbiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIHRvIGdyYW50IHRoZSBjb3B5cmlnaHQgbGljZW5zZSBzZXQgZm9ydGggaW4KLXRoaXMgQWdyZWVtZW50LiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+My4gUkVRVUlSRU1FTlRTPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+QSBDb250cmlidXRvciBtYXkgY2hvb3NlIHRvIGRpc3RyaWJ1dGUgdGhlCi1Qcm9ncmFtIGluIG9iamVjdCBjb2RlIGZvcm0gdW5kZXIgaXRzIG93biBsaWNlbnNlIGFncmVlbWVudCwgcHJvdmlkZWQgdGhhdDo8L3NwYW4+Ci08L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pdCBjb21wbGllcyB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudDsgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikKLWl0cyBsaWNlbnNlIGFncmVlbWVudDo8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pKQotZWZmZWN0aXZlbHkgZGlzY2xhaW1zIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCB3YXJyYW50aWVzIGFuZAotY29uZGl0aW9ucywgZXhwcmVzcyBhbmQgaW1wbGllZCwgaW5jbHVkaW5nIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiB0aXRsZQotYW5kIG5vbi1pbmZyaW5nZW1lbnQsIGFuZCBpbXBsaWVkIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiBtZXJjaGFudGFiaWxpdHkKLWFuZCBmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZTsgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWkpCi1lZmZlY3RpdmVseSBleGNsdWRlcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgbGlhYmlsaXR5IGZvciBkYW1hZ2VzLAotaW5jbHVkaW5nIGRpcmVjdCwgaW5kaXJlY3QsIHNwZWNpYWwsIGluY2lkZW50YWwgYW5kIGNvbnNlcXVlbnRpYWwgZGFtYWdlcywgc3VjaAotYXMgbG9zdCBwcm9maXRzOyA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paWkpCi1zdGF0ZXMgdGhhdCBhbnkgcHJvdmlzaW9ucyB3aGljaCBkaWZmZXIgZnJvbSB0aGlzIEFncmVlbWVudCBhcmUgb2ZmZXJlZCBieSB0aGF0Ci1Db250cmlidXRvciBhbG9uZSBhbmQgbm90IGJ5IGFueSBvdGhlciBwYXJ0eTsgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aXYpCi1zdGF0ZXMgdGhhdCBzb3VyY2UgY29kZSBmb3IgdGhlIFByb2dyYW0gaXMgYXZhaWxhYmxlIGZyb20gc3VjaCBDb250cmlidXRvciwgYW5kCi1pbmZvcm1zIGxpY2Vuc2VlcyBob3cgdG8gb2J0YWluIGl0IGluIGEgcmVhc29uYWJsZSBtYW5uZXIgb24gb3IgdGhyb3VnaCBhCi1tZWRpdW0gY3VzdG9tYXJpbHkgdXNlZCBmb3Igc29mdHdhcmUgZXhjaGFuZ2UuPHNwYW4gc3R5bGU9J2NvbG9yOmJsdWUnPiA8L3NwYW4+PC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPldoZW4gdGhlIFByb2dyYW0gaXMgbWFkZSBhdmFpbGFibGUgaW4gc291cmNlCi1jb2RlIGZvcm06PC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pdCBtdXN0IGJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoaXMgQWdyZWVtZW50OyBhbmQgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikgYQotY29weSBvZiB0aGlzIEFncmVlbWVudCBtdXN0IGJlIGluY2x1ZGVkIHdpdGggZWFjaCBjb3B5IG9mIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Q29udHJpYnV0b3JzIG1heSBub3QgcmVtb3ZlIG9yIGFsdGVyIGFueQotY29weXJpZ2h0IG5vdGljZXMgY29udGFpbmVkIHdpdGhpbiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVhY2ggQ29udHJpYnV0b3IgbXVzdCBpZGVudGlmeSBpdHNlbGYgYXMgdGhlCi1vcmlnaW5hdG9yIG9mIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgaW4gYSBtYW5uZXIgdGhhdCByZWFzb25hYmx5IGFsbG93cwotc3Vic2VxdWVudCBSZWNpcGllbnRzIHRvIGlkZW50aWZ5IHRoZSBvcmlnaW5hdG9yIG9mIHRoZSBDb250cmlidXRpb24uIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz40LiBDT01NRVJDSUFMIERJU1RSSUJVVElPTjwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkNvbW1lcmNpYWwgZGlzdHJpYnV0b3JzIG9mIHNvZnR3YXJlIG1heQotYWNjZXB0IGNlcnRhaW4gcmVzcG9uc2liaWxpdGllcyB3aXRoIHJlc3BlY3QgdG8gZW5kIHVzZXJzLCBidXNpbmVzcyBwYXJ0bmVycwotYW5kIHRoZSBsaWtlLiBXaGlsZSB0aGlzIGxpY2Vuc2UgaXMgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY29tbWVyY2lhbCB1c2UKLW9mIHRoZSBQcm9ncmFtLCB0aGUgQ29udHJpYnV0b3Igd2hvIGluY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbAotcHJvZHVjdCBvZmZlcmluZyBzaG91bGQgZG8gc28gaW4gYSBtYW5uZXIgd2hpY2ggZG9lcyBub3QgY3JlYXRlIHBvdGVudGlhbAotbGlhYmlsaXR5IGZvciBvdGhlciBDb250cmlidXRvcnMuIFRoZXJlZm9yZSwgaWYgYSBDb250cmlidXRvciBpbmNsdWRlcyB0aGUKLVByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIHN1Y2ggQ29udHJpYnV0b3IgKCZxdW90O0NvbW1lcmNpYWwKLUNvbnRyaWJ1dG9yJnF1b3Q7KSBoZXJlYnkgYWdyZWVzIHRvIGRlZmVuZCBhbmQgaW5kZW1uaWZ5IGV2ZXJ5IG90aGVyCi1Db250cmlidXRvciAoJnF1b3Q7SW5kZW1uaWZpZWQgQ29udHJpYnV0b3ImcXVvdDspIGFnYWluc3QgYW55IGxvc3NlcywgZGFtYWdlcyBhbmQKLWNvc3RzIChjb2xsZWN0aXZlbHkgJnF1b3Q7TG9zc2VzJnF1b3Q7KSBhcmlzaW5nIGZyb20gY2xhaW1zLCBsYXdzdWl0cyBhbmQgb3RoZXIKLWxlZ2FsIGFjdGlvbnMgYnJvdWdodCBieSBhIHRoaXJkIHBhcnR5IGFnYWluc3QgdGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIHRvCi10aGUgZXh0ZW50IGNhdXNlZCBieSB0aGUgYWN0cyBvciBvbWlzc2lvbnMgb2Ygc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluCi1jb25uZWN0aW9uIHdpdGggaXRzIGRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdAotb2ZmZXJpbmcuIFRoZSBvYmxpZ2F0aW9ucyBpbiB0aGlzIHNlY3Rpb24gZG8gbm90IGFwcGx5IHRvIGFueSBjbGFpbXMgb3IgTG9zc2VzCi1yZWxhdGluZyB0byBhbnkgYWN0dWFsIG9yIGFsbGVnZWQgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGluZnJpbmdlbWVudC4gSW4gb3JkZXIKLXRvIHF1YWxpZnksIGFuIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG11c3Q6IGEpIHByb21wdGx5IG5vdGlmeSB0aGUgQ29tbWVyY2lhbAotQ29udHJpYnV0b3IgaW4gd3JpdGluZyBvZiBzdWNoIGNsYWltLCBhbmQgYikgYWxsb3cgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IKLXRvIGNvbnRyb2wsIGFuZCBjb29wZXJhdGUgd2l0aCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiwgdGhlIGRlZmVuc2UgYW5kCi1hbnkgcmVsYXRlZCBzZXR0bGVtZW50IG5lZ290aWF0aW9ucy4gVGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG1heSBwYXJ0aWNpcGF0ZQotaW4gYW55IHN1Y2ggY2xhaW0gYXQgaXRzIG93biBleHBlbnNlLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Rm9yIGV4YW1wbGUsIGEgQ29udHJpYnV0b3IgbWlnaHQgaW5jbHVkZSB0aGUKLVByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIFByb2R1Y3QgWC4gVGhhdCBDb250cmlidXRvciBpcyB0aGVuIGEKLUNvbW1lcmNpYWwgQ29udHJpYnV0b3IuIElmIHRoYXQgQ29tbWVyY2lhbCBDb250cmlidXRvciB0aGVuIG1ha2VzIHBlcmZvcm1hbmNlCi1jbGFpbXMsIG9yIG9mZmVycyB3YXJyYW50aWVzIHJlbGF0ZWQgdG8gUHJvZHVjdCBYLCB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kCi13YXJyYW50aWVzIGFyZSBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IncyByZXNwb25zaWJpbGl0eSBhbG9uZS4gVW5kZXIgdGhpcwotc2VjdGlvbiwgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3Igd291bGQgaGF2ZSB0byBkZWZlbmQgY2xhaW1zIGFnYWluc3QgdGhlCi1vdGhlciBDb250cmlidXRvcnMgcmVsYXRlZCB0byB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMsIGFuZCBpZiBhCi1jb3VydCByZXF1aXJlcyBhbnkgb3RoZXIgQ29udHJpYnV0b3IgdG8gcGF5IGFueSBkYW1hZ2VzIGFzIGEgcmVzdWx0LCB0aGUKLUNvbW1lcmNpYWwgQ29udHJpYnV0b3IgbXVzdCBwYXkgdGhvc2UgZGFtYWdlcy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjUuIE5PIFdBUlJBTlRZPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUwotQUdSRUVNRU5ULCBUSEUgUFJPR1JBTSBJUyBQUk9WSURFRCBPTiBBTiAmcXVvdDtBUyBJUyZxdW90OyBCQVNJUywgV0lUSE9VVAotV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBFSVRIRVIgRVhQUkVTUyBPUiBJTVBMSUVEIElOQ0xVRElORywKLVdJVEhPVVQgTElNSVRBVElPTiwgQU5ZIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBUSVRMRSwgTk9OLUlORlJJTkdFTUVOVCwKLU1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gRWFjaCBSZWNpcGllbnQgaXMgc29sZWx5Ci1yZXNwb25zaWJsZSBmb3IgZGV0ZXJtaW5pbmcgdGhlIGFwcHJvcHJpYXRlbmVzcyBvZiB1c2luZyBhbmQgZGlzdHJpYnV0aW5nIHRoZQotUHJvZ3JhbSBhbmQgYXNzdW1lcyBhbGwgcmlza3MgYXNzb2NpYXRlZCB3aXRoIGl0cyBleGVyY2lzZSBvZiByaWdodHMgdW5kZXIgdGhpcwotQWdyZWVtZW50ICwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgcmlza3MgYW5kIGNvc3RzIG9mIHByb2dyYW0gZXJyb3JzLAotY29tcGxpYW5jZSB3aXRoIGFwcGxpY2FibGUgbGF3cywgZGFtYWdlIHRvIG9yIGxvc3Mgb2YgZGF0YSwgcHJvZ3JhbXMgb3IKLWVxdWlwbWVudCwgYW5kIHVuYXZhaWxhYmlsaXR5IG9yIGludGVycnVwdGlvbiBvZiBvcGVyYXRpb25zLiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Ni4gRElTQ0xBSU1FUiBPRiBMSUFCSUxJVFk8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTCi1BR1JFRU1FTlQsIE5FSVRIRVIgUkVDSVBJRU5UIE5PUiBBTlkgQ09OVFJJQlVUT1JTIFNIQUxMIEhBVkUgQU5ZIExJQUJJTElUWSBGT1IKLUFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwotKElOQ0xVRElORyBXSVRIT1VUIExJTUlUQVRJT04gTE9TVCBQUk9GSVRTKSwgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKLU9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HCi1ORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9SIERJU1RSSUJVVElPTiBPRgotVEhFIFBST0dSQU0gT1IgVEhFIEVYRVJDSVNFIE9GIEFOWSBSSUdIVFMgR1JBTlRFRCBIRVJFVU5ERVIsIEVWRU4gSUYgQURWSVNFRCBPRgotVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFUy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjcuIEdFTkVSQUw8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5JZiBhbnkgcHJvdmlzaW9uIG9mIHRoaXMgQWdyZWVtZW50IGlzIGludmFsaWQKLW9yIHVuZW5mb3JjZWFibGUgdW5kZXIgYXBwbGljYWJsZSBsYXcsIGl0IHNoYWxsIG5vdCBhZmZlY3QgdGhlIHZhbGlkaXR5IG9yCi1lbmZvcmNlYWJpbGl0eSBvZiB0aGUgcmVtYWluZGVyIG9mIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgYW5kIHdpdGhvdXQKLWZ1cnRoZXIgYWN0aW9uIGJ5IHRoZSBwYXJ0aWVzIGhlcmV0bywgc3VjaCBwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlCi1taW5pbXVtIGV4dGVudCBuZWNlc3NhcnkgdG8gbWFrZSBzdWNoIHByb3Zpc2lvbiB2YWxpZCBhbmQgZW5mb3JjZWFibGUuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5JZiBSZWNpcGllbnQgaW5zdGl0dXRlcyBwYXRlbnQgbGl0aWdhdGlvbgotYWdhaW5zdCBhbnkgZW50aXR5IChpbmNsdWRpbmcgYSBjcm9zcy1jbGFpbSBvciBjb3VudGVyY2xhaW0gaW4gYSBsYXdzdWl0KQotYWxsZWdpbmcgdGhhdCB0aGUgUHJvZ3JhbSBpdHNlbGYgKGV4Y2x1ZGluZyBjb21iaW5hdGlvbnMgb2YgdGhlIFByb2dyYW0gd2l0aAotb3RoZXIgc29mdHdhcmUgb3IgaGFyZHdhcmUpIGluZnJpbmdlcyBzdWNoIFJlY2lwaWVudCdzIHBhdGVudChzKSwgdGhlbiBzdWNoCi1SZWNpcGllbnQncyByaWdodHMgZ3JhbnRlZCB1bmRlciBTZWN0aW9uIDIoYikgc2hhbGwgdGVybWluYXRlIGFzIG9mIHRoZSBkYXRlCi1zdWNoIGxpdGlnYXRpb24gaXMgZmlsZWQuIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5BbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50Ci1zaGFsbCB0ZXJtaW5hdGUgaWYgaXQgZmFpbHMgdG8gY29tcGx5IHdpdGggYW55IG9mIHRoZSBtYXRlcmlhbCB0ZXJtcyBvcgotY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudCBhbmQgZG9lcyBub3QgY3VyZSBzdWNoIGZhaWx1cmUgaW4gYSByZWFzb25hYmxlCi1wZXJpb2Qgb2YgdGltZSBhZnRlciBiZWNvbWluZyBhd2FyZSBvZiBzdWNoIG5vbmNvbXBsaWFuY2UuIElmIGFsbCBSZWNpcGllbnQncwotcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHRlcm1pbmF0ZSwgUmVjaXBpZW50IGFncmVlcyB0byBjZWFzZSB1c2UgYW5kCi1kaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gYXMgc29vbiBhcyByZWFzb25hYmx5IHByYWN0aWNhYmxlLiBIb3dldmVyLAotUmVjaXBpZW50J3Mgb2JsaWdhdGlvbnMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYW5kIGFueSBsaWNlbnNlcyBncmFudGVkIGJ5Ci1SZWNpcGllbnQgcmVsYXRpbmcgdG8gdGhlIFByb2dyYW0gc2hhbGwgY29udGludWUgYW5kIHN1cnZpdmUuIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FdmVyeW9uZSBpcyBwZXJtaXR0ZWQgdG8gY29weSBhbmQgZGlzdHJpYnV0ZQotY29waWVzIG9mIHRoaXMgQWdyZWVtZW50LCBidXQgaW4gb3JkZXIgdG8gYXZvaWQgaW5jb25zaXN0ZW5jeSB0aGUgQWdyZWVtZW50IGlzCi1jb3B5cmlnaHRlZCBhbmQgbWF5IG9ubHkgYmUgbW9kaWZpZWQgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXIuIFRoZSBBZ3JlZW1lbnQKLVN0ZXdhcmQgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHB1Ymxpc2ggbmV3IHZlcnNpb25zIChpbmNsdWRpbmcgcmV2aXNpb25zKSBvZgotdGhpcyBBZ3JlZW1lbnQgZnJvbSB0aW1lIHRvIHRpbWUuIE5vIG9uZSBvdGhlciB0aGFuIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCBoYXMKLXRoZSByaWdodCB0byBtb2RpZnkgdGhpcyBBZ3JlZW1lbnQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgdGhlIGluaXRpYWwKLUFncmVlbWVudCBTdGV3YXJkLiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1heSBhc3NpZ24gdGhlIHJlc3BvbnNpYmlsaXR5IHRvCi1zZXJ2ZSBhcyB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgdG8gYSBzdWl0YWJsZSBzZXBhcmF0ZSBlbnRpdHkuIEVhY2ggbmV3IHZlcnNpb24KLW9mIHRoZSBBZ3JlZW1lbnQgd2lsbCBiZSBnaXZlbiBhIGRpc3Rpbmd1aXNoaW5nIHZlcnNpb24gbnVtYmVyLiBUaGUgUHJvZ3JhbQotKGluY2x1ZGluZyBDb250cmlidXRpb25zKSBtYXkgYWx3YXlzIGJlIGRpc3RyaWJ1dGVkIHN1YmplY3QgdG8gdGhlIHZlcnNpb24gb2YKLXRoZSBBZ3JlZW1lbnQgdW5kZXIgd2hpY2ggaXQgd2FzIHJlY2VpdmVkLiBJbiBhZGRpdGlvbiwgYWZ0ZXIgYSBuZXcgdmVyc2lvbiBvZgotdGhlIEFncmVlbWVudCBpcyBwdWJsaXNoZWQsIENvbnRyaWJ1dG9yIG1heSBlbGVjdCB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtCi0oaW5jbHVkaW5nIGl0cyBDb250cmlidXRpb25zKSB1bmRlciB0aGUgbmV3IHZlcnNpb24uIEV4Y2VwdCBhcyBleHByZXNzbHkgc3RhdGVkCi1pbiBTZWN0aW9ucyAyKGEpIGFuZCAyKGIpIGFib3ZlLCBSZWNpcGllbnQgcmVjZWl2ZXMgbm8gcmlnaHRzIG9yIGxpY2Vuc2VzIHRvCi10aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IG9mIGFueSBDb250cmlidXRvciB1bmRlciB0aGlzIEFncmVlbWVudCwgd2hldGhlcgotZXhwcmVzc2x5LCBieSBpbXBsaWNhdGlvbiwgZXN0b3BwZWwgb3Igb3RoZXJ3aXNlLiBBbGwgcmlnaHRzIGluIHRoZSBQcm9ncmFtIG5vdAotZXhwcmVzc2x5IGdyYW50ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYXJlIHJlc2VydmVkLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+VGhpcyBBZ3JlZW1lbnQgaXMgZ292ZXJuZWQgYnkgdGhlIGxhd3Mgb2YgdGhlCi1TdGF0ZSBvZiBOZXcgWW9yayBhbmQgdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBsYXdzIG9mIHRoZSBVbml0ZWQgU3RhdGVzIG9mCi1BbWVyaWNhLiBObyBwYXJ0eSB0byB0aGlzIEFncmVlbWVudCB3aWxsIGJyaW5nIGEgbGVnYWwgYWN0aW9uIHVuZGVyIHRoaXMKLUFncmVlbWVudCBtb3JlIHRoYW4gb25lIHllYXIgYWZ0ZXIgdGhlIGNhdXNlIG9mIGFjdGlvbiBhcm9zZS4gRWFjaCBwYXJ0eSB3YWl2ZXMKLWl0cyByaWdodHMgdG8gYSBqdXJ5IHRyaWFsIGluIGFueSByZXN1bHRpbmcgbGl0aWdhdGlvbi48L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjwhW2lmICFzdXBwb3J0RW1wdHlQYXJhc10+Jm5ic3A7PCFbZW5kaWZdPjxvOnA+PC9vOnA+PC9wPgotCi08L2Rpdj4KLQotPC9ib2R5PgotCi08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvbGljZW5zZS5odG1sIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2xpY2Vuc2UuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMTRiMWQ1MC4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvbGljZW5zZS5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsODMgKzAsMCBAQAotPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMC8vRU4iPgotPGh0bWw+Ci08aGVhZD4KLTxtZXRhIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4KLTx0aXRsZT5FY2xpcHNlLm9yZyBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvdGl0bGU+Ci08L2hlYWQ+Ci0KLTxib2R5IGxhbmc9IkVOLVVTIiBsaW5rPWJsdWUgdmxpbms9cHVycGxlPgotPGgyPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvaDI+Ci08cD5KdW5lIDA2LCAyMDA3PC9wPgotCi08aDM+VXNhZ2UgT2YgQ29udGVudDwvaDM+Ci0KLTxwPlRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiBBTkQvT1IgT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUwotICAgKENPTExFQ1RJVkVMWSAmcXVvdDtDT05URU5UJnF1b3Q7KS4gIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQKLSAgIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VIEFHUkVFIFRIQVQgWU9VUiBVU0UKLSAgIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SCi0gICBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQKLSAgIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULjwvcD4KLSAgIAotPGgzPkFwcGxpY2FibGUgTGljZW5zZXM8L2gzPiAgIAotICAgCi08cD5Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wCi0gICAoJnF1b3Q7RVBMJnF1b3Q7KS4gIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpcyBDb250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L2E+LgotICAgRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICZxdW90O1Byb2dyYW0mcXVvdDsgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvcD4KLQotPHA+Q29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsIGRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2Uub3JnIENWUyByZXBvc2l0b3J5ICgmcXVvdDtSZXBvc2l0b3J5JnF1b3Q7KSBpbiBDVlMKLSAgIG1vZHVsZXMgKCZxdW90O01vZHVsZXMmcXVvdDspIGFuZCBtYWRlIGF2YWlsYWJsZSBhcyBkb3dubG9hZGFibGUgYXJjaGl2ZXMgKCZxdW90O0Rvd25sb2FkcyZxdW90OykuPC9wPgotICAgCi08dWw+Ci0JPGxpPkNvbnRlbnQgbWF5IGJlIHN0cnVjdHVyZWQgYW5kIHBhY2thZ2VkIGludG8gbW9kdWxlcyB0byBmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsIGV4dGVuZGluZywgYW5kIHVwZ3JhZGluZyB0aGUgQ29udGVudC4gIFR5cGljYWwgbW9kdWxlcyBtYXkgaW5jbHVkZSBwbHVnLWlucyAoJnF1b3Q7UGx1Zy1pbnMmcXVvdDspLCBwbHVnLWluIGZyYWdtZW50cyAoJnF1b3Q7RnJhZ21lbnRzJnF1b3Q7KSwgYW5kIGZlYXR1cmVzICgmcXVvdDtGZWF0dXJlcyZxdW90OykuPC9saT4KLQk8bGk+RWFjaCBQbHVnLWluIG9yIEZyYWdtZW50IG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3Rvcnkgb3IgSkFSIChKYXZhJnRyYWRlOyBBUmNoaXZlKSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtwbHVnaW5zJnF1b3Q7LjwvbGk+Ci0JPGxpPkEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLiAgRWFjaCBGZWF0dXJlIG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3RvcnkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgJnF1b3Q7ZmVhdHVyZXMmcXVvdDsuICBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnhtbCZxdW90OyBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgdGhlIFBsdWctaW5zCi0gICAgICBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuPC9saT4KLQk8bGk+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoJnF1b3Q7SW5jbHVkZWQgRmVhdHVyZXMmcXVvdDspLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnhtbCZxdW90OyBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgRmVhdHVyZXMuPC9saT4KLTwvdWw+ICAgCi0gCi08cD5UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAmcXVvdDthYm91dC5odG1sJnF1b3Q7ICgmcXVvdDtBYm91dHMmcXVvdDspLiBUaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIEZlYXR1cmVzIGFuZAotSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAmcXVvdDtsaWNlbnNlLmh0bWwmcXVvdDsgKCZxdW90O0ZlYXR1cmUgTGljZW5zZXMmcXVvdDspLiAgQWJvdXRzIGFuZCBGZWF0dXJlIExpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSBkaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGUKLWluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOjwvcD4KLQotPHVsPgotCTxsaT5UaGUgdG9wLWxldmVsIChyb290KSBkaXJlY3Rvcnk8L2xpPgotCTxsaT5QbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3RvcmllczwvbGk+Ci0JPGxpPkluc2lkZSBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHBhY2thZ2VkIGFzIEpBUnM8L2xpPgotCTxsaT5TdWItZGlyZWN0b3JpZXMgb2YgdGhlIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtzcmMmcXVvdDsgb2YgY2VydGFpbiBQbHVnLWluczwvbGk+Ci0JPGxpPkZlYXR1cmUgZGlyZWN0b3JpZXM8L2xpPgotPC91bD4KLQkJCi08cD5Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlIEVjbGlwc2UgVXBkYXRlIE1hbmFnZXIsIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoJnF1b3Q7RmVhdHVyZSBVcGRhdGUgTGljZW5zZSZxdW90OykgZHVyaW5nIHRoZQotaW5zdGFsbGF0aW9uIHByb2Nlc3MuICBJZiB0aGUgRmVhdHVyZSBjb250YWlucyBJbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdSB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgdGhlIEluY2x1ZGVkIEZlYXR1cmVzIG9yCi1pbmZvcm0geW91IHdoZXJlIHlvdSBjYW4gbG9jYXRlIHRoZW0uICBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW4gdGhlICZxdW90O2xpY2Vuc2UmcXVvdDsgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgJnF1b3Q7ZmVhdHVyZS5wcm9wZXJ0aWVzJnF1b3Q7IGZvdW5kIHdpdGhpbiBhIEZlYXR1cmUuCi1TdWNoIEFib3V0cywgRmVhdHVyZSBMaWNlbnNlcywgYW5kIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXIgdXNlIG9mIHRoZSBhc3NvY2lhdGVkIENvbnRlbnQgaW4KLXRoYXQgZGlyZWN0b3J5LjwvcD4KLQotPHA+VEhFIEFCT1VUUywgRkVBVFVSRSBMSUNFTlNFUywgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUiBUTyBUSEUgRVBMIE9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy4gIFNPTUUgT0YgVEhFU0UKLU9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6PC9wPgotCi08dWw+Ci0JPGxpPkNvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbDwvYT4pPC9saT4KLQk8bGk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFPC9hPik8L2xpPgotCTxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMDwvYT4pPC9saT4KLQk8bGk+SUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sIj5odHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vZGV2ZWxvcGVyd29ya3Mvb3BlbnNvdXJjZS9saWNlbnNlMTAuaHRtbDwvYT4pPC9saT4JCi0JPGxpPk1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sIj5odHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbDwvYT4pPC9saT4KLQk8bGk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbCI+aHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sPC9hPik8L2xpPgotICAKLSAgPExJPkNvbW1vbiBEZXZlbG9wbWVudCBhbmQgRGlzdHJpYnV0aW9uIExpY2Vuc2UgKENEREwpIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuc3VuLmNvbS9jZGRsL2NkZGwuaHRtbCI+aHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sKTwvQT4KLSAgPC9MST4KLTwvVUw+Ci0KLTxwPklUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1IgVE8gVVNFIE9GIFRIRSBDT05URU5ULiAgSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSwgb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBpcyBwcm92aWRlZCwgcGxlYXNlCi1jb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LjwvcD4KLQotPGgzPkNyeXB0b2dyYXBoeTwvaDM+Ci0KLTxwPkNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZSBjdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsIGFuZC9vciByZS1leHBvcnQgdG8KLSAgIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFIHVzaW5nIGFueSBlbmNyeXB0aW9uIHNvZnR3YXJlLCBwbGVhc2UgY2hlY2sgdGhlIGNvdW50cnkncyBsYXdzLCByZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgY29uY2VybmluZyB0aGUgaW1wb3J0LAotICAgcG9zc2Vzc2lvbiwgb3IgdXNlLCBhbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIHRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC48L3A+Ci0gICAKLTxzbWFsbD5KYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIFN1biBNaWNyb3N5c3RlbXMsIEluYy4gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC48L3NtYWxsPiAgIAotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL3BsdWdpbi5wcm9wZXJ0aWVzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL3BsdWdpbi5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkMGQ1ZjFjLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9wbHVnaW4ucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDEzICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotcGx1Z2luTmFtZSA9IEphdmEgUGVyc2lzdGVuY2UgQVBJIFRvb2xzIC0gRWNsaXBzZUxpbmsgU3VwcG9ydAotcHJvdmlkZXJOYW1lID0gRWNsaXBzZS5vcmcKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvYnVpbGQucHJvcGVydGllcyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNTNhYmU2Ni4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVGZWF0dXJlL2J1aWxkLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwxNiArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLWJpbi5pbmNsdWRlcyA9IFwKLSAgICAgICAgICAgICAgIGVwbC12MTAuaHRtbCxcCi0gICAgICAgICAgICAgICBlY2xpcHNlX3VwZGF0ZV8xMjAuanBnLFwKLSAgICAgICAgICAgICAgIGZlYXR1cmUueG1sLFwKLSAgICAgICAgICAgICAgIGZlYXR1cmUucHJvcGVydGllcyxcCi0gICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmZkZjcwOC4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVGZWF0dXJlL2VjbGlwc2VfdXBkYXRlXzEyMC5qcGcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVGZWF0dXJlL2VwbC12MTAuaHRtbCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvZXBsLXYxMC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMjJhZDI5Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvZXBsLXYxMC5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsMzI4ICswLDAgQEAKLTxodG1sIHhtbG5zOm89InVybjpzY2hlbWFzLW1pY3Jvc29mdC1jb206b2ZmaWNlOm9mZmljZSIKLXhtbG5zOnc9InVybjpzY2hlbWFzLW1pY3Jvc29mdC1jb206b2ZmaWNlOndvcmQiCi14bWxucz0iaHR0cDovL3d3dy53My5vcmcvVFIvUkVDLWh0bWw0MCI+Ci0KLTxoZWFkPgotPG1ldGEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXdpbmRvd3MtMTI1MiI+Ci08bWV0YSBuYW1lPVByb2dJZCBjb250ZW50PVdvcmQuRG9jdW1lbnQ+Ci08bWV0YSBuYW1lPUdlbmVyYXRvciBjb250ZW50PSJNaWNyb3NvZnQgV29yZCA5Ij4KLTxtZXRhIG5hbWU9T3JpZ2luYXRvciBjb250ZW50PSJNaWNyb3NvZnQgV29yZCA5Ij4KLTxsaW5rIHJlbD1GaWxlLUxpc3QKLWhyZWY9Ii4vRWNsaXBzZSUyMEVQTCUyMDIwMDNfMTFfMTAlMjBGaW5hbF9maWxlcy9maWxlbGlzdC54bWwiPgotPHRpdGxlPkVjbGlwc2UgUHVibGljIExpY2Vuc2UgLSBWZXJzaW9uIDEuMDwvdGl0bGU+Ci08IS0tW2lmIGd0ZSBtc28gOV0+PHhtbD4KLSA8bzpEb2N1bWVudFByb3BlcnRpZXM+Ci0gIDxvOlJldmlzaW9uPjI8L286UmV2aXNpb24+Ci0gIDxvOlRvdGFsVGltZT4zPC9vOlRvdGFsVGltZT4KLSAgPG86Q3JlYXRlZD4yMDA0LTAzLTA1VDIzOjAzOjAwWjwvbzpDcmVhdGVkPgotICA8bzpMYXN0U2F2ZWQ+MjAwNC0wMy0wNVQyMzowMzowMFo8L286TGFzdFNhdmVkPgotICA8bzpQYWdlcz40PC9vOlBhZ2VzPgotICA8bzpXb3Jkcz4xNjI2PC9vOldvcmRzPgotICA8bzpDaGFyYWN0ZXJzPjkyNzA8L286Q2hhcmFjdGVycz4KLSAgIDxvOkxpbmVzPjc3PC9vOkxpbmVzPgotICA8bzpQYXJhZ3JhcGhzPjE4PC9vOlBhcmFncmFwaHM+Ci0gIDxvOkNoYXJhY3RlcnNXaXRoU3BhY2VzPjExMzg0PC9vOkNoYXJhY3RlcnNXaXRoU3BhY2VzPgotICA8bzpWZXJzaW9uPjkuNDQwMjwvbzpWZXJzaW9uPgotIDwvbzpEb2N1bWVudFByb3BlcnRpZXM+Ci08L3htbD48IVtlbmRpZl0tLT48IS0tW2lmIGd0ZSBtc28gOV0+PHhtbD4KLSA8dzpXb3JkRG9jdW1lbnQ+Ci0gIDx3OlRyYWNrUmV2aXNpb25zLz4KLSA8L3c6V29yZERvY3VtZW50PgotPC94bWw+PCFbZW5kaWZdLS0+Ci08c3R5bGU+Ci08IS0tCi0gLyogRm9udCBEZWZpbml0aW9ucyAqLwotQGZvbnQtZmFjZQotCXtmb250LWZhbWlseTpUYWhvbWE7Ci0JcGFub3NlLTE6MiAxMSA2IDQgMyA1IDQgNCAyIDQ7Ci0JbXNvLWZvbnQtY2hhcnNldDowOwotCW1zby1nZW5lcmljLWZvbnQtZmFtaWx5OnN3aXNzOwotCW1zby1mb250LXBpdGNoOnZhcmlhYmxlOwotCW1zby1mb250LXNpZ25hdHVyZTo1NTM2Nzk0OTUgLTIxNDc0ODM2NDggOCAwIDY2MDQ3IDA7fQotIC8qIFN0eWxlIERlZmluaXRpb25zICovCi1wLk1zb05vcm1hbCwgbGkuTXNvTm9ybWFsLCBkaXYuTXNvTm9ybWFsCi0Je21zby1zdHlsZS1wYXJlbnQ6IiI7Ci0JbWFyZ2luOjBpbjsKLQltYXJnaW4tYm90dG9tOi4wMDAxcHQ7Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZToxMi4wcHQ7Ci0JZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotcAotCXttYXJnaW4tcmlnaHQ6MGluOwotCW1zby1tYXJnaW4tdG9wLWFsdDphdXRvOwotCW1zby1tYXJnaW4tYm90dG9tLWFsdDphdXRvOwotCW1hcmdpbi1sZWZ0OjBpbjsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjEyLjBwdDsKLQlmb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1wLkJhbGxvb25UZXh0LCBsaS5CYWxsb29uVGV4dCwgZGl2LkJhbGxvb25UZXh0Ci0Je21zby1zdHlsZS1uYW1lOiJCYWxsb29uIFRleHQiOwotCW1hcmdpbjowaW47Ci0JbWFyZ2luLWJvdHRvbTouMDAwMXB0OwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6OC4wcHQ7Ci0JZm9udC1mYW1pbHk6VGFob21hOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLUBwYWdlIFNlY3Rpb24xCi0Je3NpemU6OC41aW4gMTEuMGluOwotCW1hcmdpbjoxLjBpbiAxLjI1aW4gMS4waW4gMS4yNWluOwotCW1zby1oZWFkZXItbWFyZ2luOi41aW47Ci0JbXNvLWZvb3Rlci1tYXJnaW46LjVpbjsKLQltc28tcGFwZXItc291cmNlOjA7fQotZGl2LlNlY3Rpb24xCi0Je3BhZ2U6U2VjdGlvbjE7fQotLS0+Ci08L3N0eWxlPgotPC9oZWFkPgotCi08Ym9keSBsYW5nPUVOLVVTIHN0eWxlPSd0YWItaW50ZXJ2YWw6LjVpbic+Ci0KLTxkaXYgY2xhc3M9U2VjdGlvbjE+Ci0KLTxwIGFsaWduPWNlbnRlciBzdHlsZT0ndGV4dC1hbGlnbjpjZW50ZXInPjxiPkVjbGlwc2UgUHVibGljIExpY2Vuc2UgLSB2IDEuMDwvYj4KLTwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPlRIRSBBQ0NPTVBBTllJTkcgUFJPR1JBTSBJUyBQUk9WSURFRCBVTkRFUgotVEhFIFRFUk1TIE9GIFRISVMgRUNMSVBTRSBQVUJMSUMgTElDRU5TRSAoJnF1b3Q7QUdSRUVNRU5UJnF1b3Q7KS4gQU5ZIFVTRSwKLVJFUFJPRFVDVElPTiBPUiBESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gQ09OU1RJVFVURVMgUkVDSVBJRU5UJ1MgQUNDRVBUQU5DRQotT0YgVEhJUyBBR1JFRU1FTlQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4xLiBERUZJTklUSU9OUzwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0NvbnRyaWJ1dGlvbiZxdW90OyBtZWFuczo8L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWluIHRoZSBjYXNlIG9mIHRoZSBpbml0aWFsIENvbnRyaWJ1dG9yLCB0aGUgaW5pdGlhbCBjb2RlIGFuZCBkb2N1bWVudGF0aW9uCi1kaXN0cmlidXRlZCB1bmRlciB0aGlzIEFncmVlbWVudCwgYW5kPGJyIGNsZWFyPWxlZnQ+Ci1iKSBpbiB0aGUgY2FzZSBvZiBlYWNoIHN1YnNlcXVlbnQgQ29udHJpYnV0b3I6PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aSkKLWNoYW5nZXMgdG8gdGhlIFByb2dyYW0sIGFuZDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpKQotYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtOzwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPndoZXJlCi1zdWNoIGNoYW5nZXMgYW5kL29yIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbSBvcmlnaW5hdGUgZnJvbSBhbmQgYXJlIGRpc3RyaWJ1dGVkCi1ieSB0aGF0IHBhcnRpY3VsYXIgQ29udHJpYnV0b3IuIEEgQ29udHJpYnV0aW9uICdvcmlnaW5hdGVzJyBmcm9tIGEgQ29udHJpYnV0b3IKLWlmIGl0IHdhcyBhZGRlZCB0byB0aGUgUHJvZ3JhbSBieSBzdWNoIENvbnRyaWJ1dG9yIGl0c2VsZiBvciBhbnlvbmUgYWN0aW5nIG9uCi1zdWNoIENvbnRyaWJ1dG9yJ3MgYmVoYWxmLiBDb250cmlidXRpb25zIGRvIG5vdCBpbmNsdWRlIGFkZGl0aW9ucyB0byB0aGUKLVByb2dyYW0gd2hpY2g6IChpKSBhcmUgc2VwYXJhdGUgbW9kdWxlcyBvZiBzb2Z0d2FyZSBkaXN0cmlidXRlZCBpbiBjb25qdW5jdGlvbgotd2l0aCB0aGUgUHJvZ3JhbSB1bmRlciB0aGVpciBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIGFuZCAoaWkpIGFyZSBub3QgZGVyaXZhdGl2ZQotd29ya3Mgb2YgdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtDb250cmlidXRvciZxdW90OyBtZWFucyBhbnkgcGVyc29uIG9yCi1lbnRpdHkgdGhhdCBkaXN0cmlidXRlcyB0aGUgUHJvZ3JhbS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0xpY2Vuc2VkIFBhdGVudHMgJnF1b3Q7IG1lYW4gcGF0ZW50Ci1jbGFpbXMgbGljZW5zYWJsZSBieSBhIENvbnRyaWJ1dG9yIHdoaWNoIGFyZSBuZWNlc3NhcmlseSBpbmZyaW5nZWQgYnkgdGhlIHVzZQotb3Igc2FsZSBvZiBpdHMgQ29udHJpYnV0aW9uIGFsb25lIG9yIHdoZW4gY29tYmluZWQgd2l0aCB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O1Byb2dyYW0mcXVvdDsgbWVhbnMgdGhlIENvbnRyaWJ1dGlvbnMKLWRpc3RyaWJ1dGVkIGluIGFjY29yZGFuY2Ugd2l0aCB0aGlzIEFncmVlbWVudC48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O1JlY2lwaWVudCZxdW90OyBtZWFucyBhbnlvbmUgd2hvCi1yZWNlaXZlcyB0aGUgUHJvZ3JhbSB1bmRlciB0aGlzIEFncmVlbWVudCwgaW5jbHVkaW5nIGFsbCBDb250cmlidXRvcnMuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4yLiBHUkFOVCBPRiBSSUdIVFM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1TdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudAotYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsIHJveWFsdHktZnJlZSBjb3B5cmlnaHQgbGljZW5zZSB0bzxzcGFuCi1zdHlsZT0nY29sb3I6cmVkJz4gPC9zcGFuPnJlcHJvZHVjZSwgcHJlcGFyZSBkZXJpdmF0aXZlIHdvcmtzIG9mLCBwdWJsaWNseQotZGlzcGxheSwgcHVibGljbHkgcGVyZm9ybSwgZGlzdHJpYnV0ZSBhbmQgc3VibGljZW5zZSB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2gKLUNvbnRyaWJ1dG9yLCBpZiBhbnksIGFuZCBzdWNoIGRlcml2YXRpdmUgd29ya3MsIGluIHNvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZQotZm9ybS48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKQotU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cwotUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLDxzcGFuIHN0eWxlPSdjb2xvcjpncmVlbic+IDwvc3Bhbj5yb3lhbHR5LWZyZWUKLXBhdGVudCBsaWNlbnNlIHVuZGVyIExpY2Vuc2VkIFBhdGVudHMgdG8gbWFrZSwgdXNlLCBzZWxsLCBvZmZlciB0byBzZWxsLCBpbXBvcnQKLWFuZCBvdGhlcndpc2UgdHJhbnNmZXIgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoIENvbnRyaWJ1dG9yLCBpZiBhbnksIGluIHNvdXJjZQotY29kZSBhbmQgb2JqZWN0IGNvZGUgZm9ybS4gVGhpcyBwYXRlbnQgbGljZW5zZSBzaGFsbCBhcHBseSB0byB0aGUgY29tYmluYXRpb24KLW9mIHRoZSBDb250cmlidXRpb24gYW5kIHRoZSBQcm9ncmFtIGlmLCBhdCB0aGUgdGltZSB0aGUgQ29udHJpYnV0aW9uIGlzIGFkZGVkCi1ieSB0aGUgQ29udHJpYnV0b3IsIHN1Y2ggYWRkaXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBjYXVzZXMgc3VjaCBjb21iaW5hdGlvbgotdG8gYmUgY292ZXJlZCBieSB0aGUgTGljZW5zZWQgUGF0ZW50cy4gVGhlIHBhdGVudCBsaWNlbnNlIHNoYWxsIG5vdCBhcHBseSB0bwotYW55IG90aGVyIGNvbWJpbmF0aW9ucyB3aGljaCBpbmNsdWRlIHRoZSBDb250cmlidXRpb24uIE5vIGhhcmR3YXJlIHBlciBzZSBpcwotbGljZW5zZWQgaGVyZXVuZGVyLiA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5jKQotUmVjaXBpZW50IHVuZGVyc3RhbmRzIHRoYXQgYWx0aG91Z2ggZWFjaCBDb250cmlidXRvciBncmFudHMgdGhlIGxpY2Vuc2VzIHRvIGl0cwotQ29udHJpYnV0aW9ucyBzZXQgZm9ydGggaGVyZWluLCBubyBhc3N1cmFuY2VzIGFyZSBwcm92aWRlZCBieSBhbnkgQ29udHJpYnV0b3IKLXRoYXQgdGhlIFByb2dyYW0gZG9lcyBub3QgaW5mcmluZ2UgdGhlIHBhdGVudCBvciBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkKLXJpZ2h0cyBvZiBhbnkgb3RoZXIgZW50aXR5LiBFYWNoIENvbnRyaWJ1dG9yIGRpc2NsYWltcyBhbnkgbGlhYmlsaXR5IHRvIFJlY2lwaWVudAotZm9yIGNsYWltcyBicm91Z2h0IGJ5IGFueSBvdGhlciBlbnRpdHkgYmFzZWQgb24gaW5mcmluZ2VtZW50IG9mIGludGVsbGVjdHVhbAotcHJvcGVydHkgcmlnaHRzIG9yIG90aGVyd2lzZS4gQXMgYSBjb25kaXRpb24gdG8gZXhlcmNpc2luZyB0aGUgcmlnaHRzIGFuZAotbGljZW5zZXMgZ3JhbnRlZCBoZXJldW5kZXIsIGVhY2ggUmVjaXBpZW50IGhlcmVieSBhc3N1bWVzIHNvbGUgcmVzcG9uc2liaWxpdHkKLXRvIHNlY3VyZSBhbnkgb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5IHJpZ2h0cyBuZWVkZWQsIGlmIGFueS4gRm9yIGV4YW1wbGUsCi1pZiBhIHRoaXJkIHBhcnR5IHBhdGVudCBsaWNlbnNlIGlzIHJlcXVpcmVkIHRvIGFsbG93IFJlY2lwaWVudCB0byBkaXN0cmlidXRlCi10aGUgUHJvZ3JhbSwgaXQgaXMgUmVjaXBpZW50J3MgcmVzcG9uc2liaWxpdHkgdG8gYWNxdWlyZSB0aGF0IGxpY2Vuc2UgYmVmb3JlCi1kaXN0cmlidXRpbmcgdGhlIFByb2dyYW0uPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+ZCkKLUVhY2ggQ29udHJpYnV0b3IgcmVwcmVzZW50cyB0aGF0IHRvIGl0cyBrbm93bGVkZ2UgaXQgaGFzIHN1ZmZpY2llbnQgY29weXJpZ2h0Ci1yaWdodHMgaW4gaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCB0byBncmFudCB0aGUgY29weXJpZ2h0IGxpY2Vuc2Ugc2V0IGZvcnRoIGluCi10aGlzIEFncmVlbWVudC4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjMuIFJFUVVJUkVNRU5UUzwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkEgQ29udHJpYnV0b3IgbWF5IGNob29zZSB0byBkaXN0cmlidXRlIHRoZQotUHJvZ3JhbSBpbiBvYmplY3QgY29kZSBmb3JtIHVuZGVyIGl0cyBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIHByb3ZpZGVkIHRoYXQ6PC9zcGFuPgotPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaXQgY29tcGxpZXMgd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQ7IGFuZDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpCi1pdHMgbGljZW5zZSBhZ3JlZW1lbnQ6PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aSkKLWVmZmVjdGl2ZWx5IGRpc2NsYWltcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgd2FycmFudGllcyBhbmQKLWNvbmRpdGlvbnMsIGV4cHJlc3MgYW5kIGltcGxpZWQsIGluY2x1ZGluZyB3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgdGl0bGUKLWFuZCBub24taW5mcmluZ2VtZW50LCBhbmQgaW1wbGllZCB3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgbWVyY2hhbnRhYmlsaXR5Ci1hbmQgZml0bmVzcyBmb3IgYSBwYXJ0aWN1bGFyIHB1cnBvc2U7IDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpKQotZWZmZWN0aXZlbHkgZXhjbHVkZXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIGxpYWJpbGl0eSBmb3IgZGFtYWdlcywKLWluY2x1ZGluZyBkaXJlY3QsIGluZGlyZWN0LCBzcGVjaWFsLCBpbmNpZGVudGFsIGFuZCBjb25zZXF1ZW50aWFsIGRhbWFnZXMsIHN1Y2gKLWFzIGxvc3QgcHJvZml0czsgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWlpKQotc3RhdGVzIHRoYXQgYW55IHByb3Zpc2lvbnMgd2hpY2ggZGlmZmVyIGZyb20gdGhpcyBBZ3JlZW1lbnQgYXJlIG9mZmVyZWQgYnkgdGhhdAotQ29udHJpYnV0b3IgYWxvbmUgYW5kIG5vdCBieSBhbnkgb3RoZXIgcGFydHk7IGFuZDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPml2KQotc3RhdGVzIHRoYXQgc291cmNlIGNvZGUgZm9yIHRoZSBQcm9ncmFtIGlzIGF2YWlsYWJsZSBmcm9tIHN1Y2ggQ29udHJpYnV0b3IsIGFuZAotaW5mb3JtcyBsaWNlbnNlZXMgaG93IHRvIG9idGFpbiBpdCBpbiBhIHJlYXNvbmFibGUgbWFubmVyIG9uIG9yIHRocm91Z2ggYQotbWVkaXVtIGN1c3RvbWFyaWx5IHVzZWQgZm9yIHNvZnR3YXJlIGV4Y2hhbmdlLjxzcGFuIHN0eWxlPSdjb2xvcjpibHVlJz4gPC9zcGFuPjwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5XaGVuIHRoZSBQcm9ncmFtIGlzIG1hZGUgYXZhaWxhYmxlIGluIHNvdXJjZQotY29kZSBmb3JtOjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaXQgbXVzdCBiZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGlzIEFncmVlbWVudDsgYW5kIDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpIGEKLWNvcHkgb2YgdGhpcyBBZ3JlZW1lbnQgbXVzdCBiZSBpbmNsdWRlZCB3aXRoIGVhY2ggY29weSBvZiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkNvbnRyaWJ1dG9ycyBtYXkgbm90IHJlbW92ZSBvciBhbHRlciBhbnkKLWNvcHlyaWdodCBub3RpY2VzIGNvbnRhaW5lZCB3aXRoaW4gdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FYWNoIENvbnRyaWJ1dG9yIG11c3QgaWRlbnRpZnkgaXRzZWxmIGFzIHRoZQotb3JpZ2luYXRvciBvZiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIGluIGEgbWFubmVyIHRoYXQgcmVhc29uYWJseSBhbGxvd3MKLXN1YnNlcXVlbnQgUmVjaXBpZW50cyB0byBpZGVudGlmeSB0aGUgb3JpZ2luYXRvciBvZiB0aGUgQ29udHJpYnV0aW9uLiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+NC4gQ09NTUVSQ0lBTCBESVNUUklCVVRJT048L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Db21tZXJjaWFsIGRpc3RyaWJ1dG9ycyBvZiBzb2Z0d2FyZSBtYXkKLWFjY2VwdCBjZXJ0YWluIHJlc3BvbnNpYmlsaXRpZXMgd2l0aCByZXNwZWN0IHRvIGVuZCB1c2VycywgYnVzaW5lc3MgcGFydG5lcnMKLWFuZCB0aGUgbGlrZS4gV2hpbGUgdGhpcyBsaWNlbnNlIGlzIGludGVuZGVkIHRvIGZhY2lsaXRhdGUgdGhlIGNvbW1lcmNpYWwgdXNlCi1vZiB0aGUgUHJvZ3JhbSwgdGhlIENvbnRyaWJ1dG9yIHdobyBpbmNsdWRlcyB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwKLXByb2R1Y3Qgb2ZmZXJpbmcgc2hvdWxkIGRvIHNvIGluIGEgbWFubmVyIHdoaWNoIGRvZXMgbm90IGNyZWF0ZSBwb3RlbnRpYWwKLWxpYWJpbGl0eSBmb3Igb3RoZXIgQ29udHJpYnV0b3JzLiBUaGVyZWZvcmUsIGlmIGEgQ29udHJpYnV0b3IgaW5jbHVkZXMgdGhlCi1Qcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBzdWNoIENvbnRyaWJ1dG9yICgmcXVvdDtDb21tZXJjaWFsCi1Db250cmlidXRvciZxdW90OykgaGVyZWJ5IGFncmVlcyB0byBkZWZlbmQgYW5kIGluZGVtbmlmeSBldmVyeSBvdGhlcgotQ29udHJpYnV0b3IgKCZxdW90O0luZGVtbmlmaWVkIENvbnRyaWJ1dG9yJnF1b3Q7KSBhZ2FpbnN0IGFueSBsb3NzZXMsIGRhbWFnZXMgYW5kCi1jb3N0cyAoY29sbGVjdGl2ZWx5ICZxdW90O0xvc3NlcyZxdW90OykgYXJpc2luZyBmcm9tIGNsYWltcywgbGF3c3VpdHMgYW5kIG90aGVyCi1sZWdhbCBhY3Rpb25zIGJyb3VnaHQgYnkgYSB0aGlyZCBwYXJ0eSBhZ2FpbnN0IHRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciB0bwotdGhlIGV4dGVudCBjYXVzZWQgYnkgdGhlIGFjdHMgb3Igb21pc3Npb25zIG9mIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvciBpbgotY29ubmVjdGlvbiB3aXRoIGl0cyBkaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3QKLW9mZmVyaW5nLiBUaGUgb2JsaWdhdGlvbnMgaW4gdGhpcyBzZWN0aW9uIGRvIG5vdCBhcHBseSB0byBhbnkgY2xhaW1zIG9yIExvc3NlcwotcmVsYXRpbmcgdG8gYW55IGFjdHVhbCBvciBhbGxlZ2VkIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBpbmZyaW5nZW1lbnQuIEluIG9yZGVyCi10byBxdWFsaWZ5LCBhbiBJbmRlbW5pZmllZCBDb250cmlidXRvciBtdXN0OiBhKSBwcm9tcHRseSBub3RpZnkgdGhlIENvbW1lcmNpYWwKLUNvbnRyaWJ1dG9yIGluIHdyaXRpbmcgb2Ygc3VjaCBjbGFpbSwgYW5kIGIpIGFsbG93IHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yCi10byBjb250cm9sLCBhbmQgY29vcGVyYXRlIHdpdGggdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4sIHRoZSBkZWZlbnNlIGFuZAotYW55IHJlbGF0ZWQgc2V0dGxlbWVudCBuZWdvdGlhdGlvbnMuIFRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciBtYXkgcGFydGljaXBhdGUKLWluIGFueSBzdWNoIGNsYWltIGF0IGl0cyBvd24gZXhwZW5zZS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkZvciBleGFtcGxlLCBhIENvbnRyaWJ1dG9yIG1pZ2h0IGluY2x1ZGUgdGhlCi1Qcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBQcm9kdWN0IFguIFRoYXQgQ29udHJpYnV0b3IgaXMgdGhlbiBhCi1Db21tZXJjaWFsIENvbnRyaWJ1dG9yLiBJZiB0aGF0IENvbW1lcmNpYWwgQ29udHJpYnV0b3IgdGhlbiBtYWtlcyBwZXJmb3JtYW5jZQotY2xhaW1zLCBvciBvZmZlcnMgd2FycmFudGllcyByZWxhdGVkIHRvIFByb2R1Y3QgWCwgdGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZAotd2FycmFudGllcyBhcmUgc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yJ3MgcmVzcG9uc2liaWxpdHkgYWxvbmUuIFVuZGVyIHRoaXMKLXNlY3Rpb24sIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHdvdWxkIGhhdmUgdG8gZGVmZW5kIGNsYWltcyBhZ2FpbnN0IHRoZQotb3RoZXIgQ29udHJpYnV0b3JzIHJlbGF0ZWQgdG8gdGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZCB3YXJyYW50aWVzLCBhbmQgaWYgYQotY291cnQgcmVxdWlyZXMgYW55IG90aGVyIENvbnRyaWJ1dG9yIHRvIHBheSBhbnkgZGFtYWdlcyBhcyBhIHJlc3VsdCwgdGhlCi1Db21tZXJjaWFsIENvbnRyaWJ1dG9yIG11c3QgcGF5IHRob3NlIGRhbWFnZXMuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz41LiBOTyBXQVJSQU5UWTwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMKLUFHUkVFTUVOVCwgVEhFIFBST0dSQU0gSVMgUFJPVklERUQgT04gQU4gJnF1b3Q7QVMgSVMmcXVvdDsgQkFTSVMsIFdJVEhPVVQKLVdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgRUlUSEVSIEVYUFJFU1MgT1IgSU1QTElFRCBJTkNMVURJTkcsCi1XSVRIT1VUIExJTUlUQVRJT04sIEFOWSBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgVElUTEUsIE5PTi1JTkZSSU5HRU1FTlQsCi1NRVJDSEFOVEFCSUxJVFkgT1IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIEVhY2ggUmVjaXBpZW50IGlzIHNvbGVseQotcmVzcG9uc2libGUgZm9yIGRldGVybWluaW5nIHRoZSBhcHByb3ByaWF0ZW5lc3Mgb2YgdXNpbmcgYW5kIGRpc3RyaWJ1dGluZyB0aGUKLVByb2dyYW0gYW5kIGFzc3VtZXMgYWxsIHJpc2tzIGFzc29jaWF0ZWQgd2l0aCBpdHMgZXhlcmNpc2Ugb2YgcmlnaHRzIHVuZGVyIHRoaXMKLUFncmVlbWVudCAsIGluY2x1ZGluZyBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIHJpc2tzIGFuZCBjb3N0cyBvZiBwcm9ncmFtIGVycm9ycywKLWNvbXBsaWFuY2Ugd2l0aCBhcHBsaWNhYmxlIGxhd3MsIGRhbWFnZSB0byBvciBsb3NzIG9mIGRhdGEsIHByb2dyYW1zIG9yCi1lcXVpcG1lbnQsIGFuZCB1bmF2YWlsYWJpbGl0eSBvciBpbnRlcnJ1cHRpb24gb2Ygb3BlcmF0aW9ucy4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjYuIERJU0NMQUlNRVIgT0YgTElBQklMSVRZPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUwotQUdSRUVNRU5ULCBORUlUSEVSIFJFQ0lQSUVOVCBOT1IgQU5ZIENPTlRSSUJVVE9SUyBTSEFMTCBIQVZFIEFOWSBMSUFCSUxJVFkgRk9SCi1BTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLShJTkNMVURJTkcgV0lUSE9VVCBMSU1JVEFUSU9OIExPU1QgUFJPRklUUyksIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCi1PRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORwotTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPUiBESVNUUklCVVRJT04gT0YKLVRIRSBQUk9HUkFNIE9SIFRIRSBFWEVSQ0lTRSBPRiBBTlkgUklHSFRTIEdSQU5URUQgSEVSRVVOREVSLCBFVkVOIElGIEFEVklTRUQgT0YKLVRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRVMuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz43LiBHRU5FUkFMPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+SWYgYW55IHByb3Zpc2lvbiBvZiB0aGlzIEFncmVlbWVudCBpcyBpbnZhbGlkCi1vciB1bmVuZm9yY2VhYmxlIHVuZGVyIGFwcGxpY2FibGUgbGF3LCBpdCBzaGFsbCBub3QgYWZmZWN0IHRoZSB2YWxpZGl0eSBvcgotZW5mb3JjZWFiaWxpdHkgb2YgdGhlIHJlbWFpbmRlciBvZiB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGFuZCB3aXRob3V0Ci1mdXJ0aGVyIGFjdGlvbiBieSB0aGUgcGFydGllcyBoZXJldG8sIHN1Y2ggcHJvdmlzaW9uIHNoYWxsIGJlIHJlZm9ybWVkIHRvIHRoZQotbWluaW11bSBleHRlbnQgbmVjZXNzYXJ5IHRvIG1ha2Ugc3VjaCBwcm92aXNpb24gdmFsaWQgYW5kIGVuZm9yY2VhYmxlLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+SWYgUmVjaXBpZW50IGluc3RpdHV0ZXMgcGF0ZW50IGxpdGlnYXRpb24KLWFnYWluc3QgYW55IGVudGl0eSAoaW5jbHVkaW5nIGEgY3Jvc3MtY2xhaW0gb3IgY291bnRlcmNsYWltIGluIGEgbGF3c3VpdCkKLWFsbGVnaW5nIHRoYXQgdGhlIFByb2dyYW0gaXRzZWxmIChleGNsdWRpbmcgY29tYmluYXRpb25zIG9mIHRoZSBQcm9ncmFtIHdpdGgKLW90aGVyIHNvZnR3YXJlIG9yIGhhcmR3YXJlKSBpbmZyaW5nZXMgc3VjaCBSZWNpcGllbnQncyBwYXRlbnQocyksIHRoZW4gc3VjaAotUmVjaXBpZW50J3MgcmlnaHRzIGdyYW50ZWQgdW5kZXIgU2VjdGlvbiAyKGIpIHNoYWxsIHRlcm1pbmF0ZSBhcyBvZiB0aGUgZGF0ZQotc3VjaCBsaXRpZ2F0aW9uIGlzIGZpbGVkLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+QWxsIFJlY2lwaWVudCdzIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudAotc2hhbGwgdGVybWluYXRlIGlmIGl0IGZhaWxzIHRvIGNvbXBseSB3aXRoIGFueSBvZiB0aGUgbWF0ZXJpYWwgdGVybXMgb3IKLWNvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQgYW5kIGRvZXMgbm90IGN1cmUgc3VjaCBmYWlsdXJlIGluIGEgcmVhc29uYWJsZQotcGVyaW9kIG9mIHRpbWUgYWZ0ZXIgYmVjb21pbmcgYXdhcmUgb2Ygc3VjaCBub25jb21wbGlhbmNlLiBJZiBhbGwgUmVjaXBpZW50J3MKLXJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCB0ZXJtaW5hdGUsIFJlY2lwaWVudCBhZ3JlZXMgdG8gY2Vhc2UgdXNlIGFuZAotZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGFzIHNvb24gYXMgcmVhc29uYWJseSBwcmFjdGljYWJsZS4gSG93ZXZlciwKLVJlY2lwaWVudCdzIG9ibGlnYXRpb25zIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFuZCBhbnkgbGljZW5zZXMgZ3JhbnRlZCBieQotUmVjaXBpZW50IHJlbGF0aW5nIHRvIHRoZSBQcm9ncmFtIHNoYWxsIGNvbnRpbnVlIGFuZCBzdXJ2aXZlLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RXZlcnlvbmUgaXMgcGVybWl0dGVkIHRvIGNvcHkgYW5kIGRpc3RyaWJ1dGUKLWNvcGllcyBvZiB0aGlzIEFncmVlbWVudCwgYnV0IGluIG9yZGVyIHRvIGF2b2lkIGluY29uc2lzdGVuY3kgdGhlIEFncmVlbWVudCBpcwotY29weXJpZ2h0ZWQgYW5kIG1heSBvbmx5IGJlIG1vZGlmaWVkIGluIHRoZSBmb2xsb3dpbmcgbWFubmVyLiBUaGUgQWdyZWVtZW50Ci1TdGV3YXJkIHJlc2VydmVzIHRoZSByaWdodCB0byBwdWJsaXNoIG5ldyB2ZXJzaW9ucyAoaW5jbHVkaW5nIHJldmlzaW9ucykgb2YKLXRoaXMgQWdyZWVtZW50IGZyb20gdGltZSB0byB0aW1lLiBObyBvbmUgb3RoZXIgdGhhbiB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgaGFzCi10aGUgcmlnaHQgdG8gbW9kaWZ5IHRoaXMgQWdyZWVtZW50LiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIHRoZSBpbml0aWFsCi1BZ3JlZW1lbnQgU3Rld2FyZC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYXkgYXNzaWduIHRoZSByZXNwb25zaWJpbGl0eSB0bwotc2VydmUgYXMgdGhlIEFncmVlbWVudCBTdGV3YXJkIHRvIGEgc3VpdGFibGUgc2VwYXJhdGUgZW50aXR5LiBFYWNoIG5ldyB2ZXJzaW9uCi1vZiB0aGUgQWdyZWVtZW50IHdpbGwgYmUgZ2l2ZW4gYSBkaXN0aW5ndWlzaGluZyB2ZXJzaW9uIG51bWJlci4gVGhlIFByb2dyYW0KLShpbmNsdWRpbmcgQ29udHJpYnV0aW9ucykgbWF5IGFsd2F5cyBiZSBkaXN0cmlidXRlZCBzdWJqZWN0IHRvIHRoZSB2ZXJzaW9uIG9mCi10aGUgQWdyZWVtZW50IHVuZGVyIHdoaWNoIGl0IHdhcyByZWNlaXZlZC4gSW4gYWRkaXRpb24sIGFmdGVyIGEgbmV3IHZlcnNpb24gb2YKLXRoZSBBZ3JlZW1lbnQgaXMgcHVibGlzaGVkLCBDb250cmlidXRvciBtYXkgZWxlY3QgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbQotKGluY2x1ZGluZyBpdHMgQ29udHJpYnV0aW9ucykgdW5kZXIgdGhlIG5ldyB2ZXJzaW9uLiBFeGNlcHQgYXMgZXhwcmVzc2x5IHN0YXRlZAotaW4gU2VjdGlvbnMgMihhKSBhbmQgMihiKSBhYm92ZSwgUmVjaXBpZW50IHJlY2VpdmVzIG5vIHJpZ2h0cyBvciBsaWNlbnNlcyB0bwotdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBvZiBhbnkgQ29udHJpYnV0b3IgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIHdoZXRoZXIKLWV4cHJlc3NseSwgYnkgaW1wbGljYXRpb24sIGVzdG9wcGVsIG9yIG90aGVyd2lzZS4gQWxsIHJpZ2h0cyBpbiB0aGUgUHJvZ3JhbSBub3QKLWV4cHJlc3NseSBncmFudGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFyZSByZXNlcnZlZC48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPlRoaXMgQWdyZWVtZW50IGlzIGdvdmVybmVkIGJ5IHRoZSBsYXdzIG9mIHRoZQotU3RhdGUgb2YgTmV3IFlvcmsgYW5kIHRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgbGF3cyBvZiB0aGUgVW5pdGVkIFN0YXRlcyBvZgotQW1lcmljYS4gTm8gcGFydHkgdG8gdGhpcyBBZ3JlZW1lbnQgd2lsbCBicmluZyBhIGxlZ2FsIGFjdGlvbiB1bmRlciB0aGlzCi1BZ3JlZW1lbnQgbW9yZSB0aGFuIG9uZSB5ZWFyIGFmdGVyIHRoZSBjYXVzZSBvZiBhY3Rpb24gYXJvc2UuIEVhY2ggcGFydHkgd2FpdmVzCi1pdHMgcmlnaHRzIHRvIGEganVyeSB0cmlhbCBpbiBhbnkgcmVzdWx0aW5nIGxpdGlnYXRpb24uPC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48IVtpZiAhc3VwcG9ydEVtcHR5UGFyYXNdPiZuYnNwOzwhW2VuZGlmXT48bzpwPjwvbzpwPjwvcD4KLQotPC9kaXY+Ci0KLTwvYm9keT4KLQotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlRmVhdHVyZS9mZWF0dXJlLnByb3BlcnRpZXMgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVGZWF0dXJlL2ZlYXR1cmUucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTU2NjQwNi4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVGZWF0dXJlL2ZlYXR1cmUucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDE0NSArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgZmVhdHVyZS5wcm9wZXJ0aWVzCi0jIGNvbnRhaW5zIGV4dGVybmFsaXplZCBzdHJpbmdzIGZvciBmZWF0dXJlLnhtbAotIyAiJWZvbyIgaW4gZmVhdHVyZS54bWwgY29ycmVzcG9uZHMgdG8gdGhlIGtleSAiZm9vIiBpbiB0aGlzIGZpbGUKLSMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKLSMgVGhpcyBmaWxlIHNob3VsZCBiZSB0cmFuc2xhdGVkLgotCi0jICJmZWF0dXJlTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBmZWF0dXJlCi1mZWF0dXJlTmFtZT1KYXZhIFBlcnNpc3RlbmNlIEFQSSBUb29scyAtIEVjbGlwc2VMaW5rIFN1cHBvcnQgKE9wdGlvbmFsKQotCi0jICJwcm92aWRlck5hbWUiIHByb3BlcnR5IC0gbmFtZSBvZiB0aGUgY29tcGFueSB0aGF0IHByb3ZpZGVzIHRoZSBmZWF0dXJlCi1wcm92aWRlck5hbWU9RWNsaXBzZS5vcmcKLQotIyAidXBkYXRlU2l0ZU5hbWUiIHByb3BlcnR5IC0gbGFiZWwgZm9yIHRoZSB1cGRhdGUgc2l0ZQotdXBkYXRlU2l0ZU5hbWU9VGhlIEVjbGlwc2UgV2ViIFRvb2xzIFBsYXRmb3JtIChXVFApIFByb2plY3QgdXBkYXRlIHNpdGUKLQotIyAiZGVzY3JpcHRpb24iIHByb3BlcnR5IC0gZGVzY3JpcHRpb24gb2YgdGhlIGZlYXR1cmUKLWRlc2NyaXB0aW9uPVNvdXJjZSBjb2RlIHppcHMgZm9yIEpQQSBFY2xpcHNlTGluayBTdXBwb3J0Ci0KLSMgImNvcHlyaWdodCIgcHJvcGVydHkgLSB0ZXh0IG9mIHRoZSAiRmVhdHVyZSBVcGRhdGUgQ29weXJpZ2h0IgotY29weXJpZ2h0PVwKLUNvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUgQ29ycG9yYXRpb24uXG5cCi1BbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzXG5cCi1hcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjBcblwKLXdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0XG5cCi1odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbFxuXAotXG5cCi1Db250cmlidXRvcnM6XG5cCi0gICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uXG4KLSMjIyMjIyMjIyMjIyMjIyMgZW5kIG9mIGNvcHlyaWdodCBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotIyAibGljZW5zZVVSTCIgcHJvcGVydHkgLSBVUkwgb2YgdGhlICJGZWF0dXJlIExpY2Vuc2UiCi0jIGRvIG5vdCB0cmFuc2xhdGUgdmFsdWUgLSBqdXN0IGNoYW5nZSB0byBwb2ludCB0byBhIGxvY2FsZS1zcGVjaWZpYyBIVE1MIHBhZ2UKLWxpY2Vuc2VVUkw9bGljZW5zZS5odG1sCi0KLSMgImxpY2Vuc2UiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIExpY2Vuc2UiCi0jIHNob3VsZCBiZSBwbGFpbiB0ZXh0IHZlcnNpb24gb2YgbGljZW5zZSBhZ3JlZW1lbnQgcG9pbnRlZCB0byBiZSAibGljZW5zZVVSTCIKLWxpY2Vuc2U9XAotRUNMSVBTRSBGT1VOREFUSU9OIFNPRlRXQVJFIFVTRVIgQUdSRUVNRU5UXG5cCi1KdW5lIDA2LCAyMDA3XG5cCi1cblwKLVVzYWdlIE9mIENvbnRlbnRcblwKLVxuXAotVEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUlxuXAotT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUyAoQ09MTEVDVElWRUxZICJDT05URU5UIikuXG5cCi1VU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVNcblwKLUFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUlxuXAotTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVVxuXAotQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVFxuXAotQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFNcblwKLU9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFXG5cCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TXG5cCi1PRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRFxuXAotQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULlxuXAotXG5cCi1BcHBsaWNhYmxlIExpY2Vuc2VzXG5cCi1cblwKLVVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uXG5cCi1pcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpY1xuXAotTGljZW5zZSBWZXJzaW9uIDEuMCAoIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXNcblwKLUNvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLlxuXAotRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuXG5cCi1cblwKLUNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLFxuXAotZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZS5vcmcgQ1ZTXG5cCi1yZXBvc2l0b3J5ICgiUmVwb3NpdG9yeSIpIGluIENWUyBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIGF2YWlsYWJsZVxuXAotYXMgZG93bmxvYWRhYmxlIGFyY2hpdmVzICgiRG93bmxvYWRzIikuXG5cCi1cblwKLSAgIC0gQ29udGVudCBtYXkgYmUgc3RydWN0dXJlZCBhbmQgcGFja2FnZWQgaW50byBtb2R1bGVzIHRvIGZhY2lsaXRhdGUgZGVsaXZlcmluZyxcblwKLSAgICAgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiBUeXBpY2FsIG1vZHVsZXMgbWF5IGluY2x1ZGUgcGx1Zy1pbnMgKCJQbHVnLWlucyIpLFxuXAotICAgICBwbHVnLWluIGZyYWdtZW50cyAoIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLlxuXAotICAgLSBFYWNoIFBsdWctaW4gb3IgRnJhZ21lbnQgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBvciBKQVIgKEphdmE/IEFSY2hpdmUpXG5cCi0gICAgIGluIGEgZGlyZWN0b3J5IG5hbWVkICJwbHVnaW5zIi5cblwKLSAgIC0gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuXG5cCi0gICAgIEVhY2ggRmVhdHVyZSBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IGluIGEgZGlyZWN0b3J5IG5hbWVkICJmZWF0dXJlcyIuXG5cCi0gICAgIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvblxuXAotICAgICBudW1iZXJzIG9mIHRoZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuXG5cCi0gICAtIEZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlc1xuXAotICAgICBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy5cblwKLVxuXAotRmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIEZpbGVzIG5hbWVkXG5cCi0iZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZlxuXAotSW5jbHVkZWQgRmVhdHVyZXMuXG5cCi1cblwKLVRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmVcblwKLWNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZFxuXAotY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kIEluY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWRcblwKLWluIGZpbGVzIG5hbWVkICJsaWNlbnNlLmh0bWwiICgiRmVhdHVyZSBMaWNlbnNlcyIpLiBBYm91dHMgYW5kIEZlYXR1cmVcblwKLUxpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSBkaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGVcblwKLWluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOlxuXAotXG5cCi0gICAtIFRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeVxuXAotICAgLSBQbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3Rvcmllc1xuXAotICAgLSBJbnNpZGUgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBwYWNrYWdlZCBhcyBKQVJzXG5cCi0gICAtIFN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnNcblwKLSAgIC0gRmVhdHVyZSBkaXJlY3Rvcmllc1xuXAotXG5cCi1Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlXG5cCi1FY2xpcHNlIFVwZGF0ZSBNYW5hZ2VyLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFVwZGF0ZVxuXAotTGljZW5zZSIpIGR1cmluZyB0aGUgaW5zdGFsbGF0aW9uIHByb2Nlc3MuIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zXG5cCi1JbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdVxuXAotd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvciBpbmZvcm1cblwKLXlvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW5cblwKLXRoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIuIFN1Y2ggQWJvdXRzLFxuXAotRmVhdHVyZSBMaWNlbnNlcyBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kXG5cCi1jb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXJcblwKLXVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluIHRoYXQgZGlyZWN0b3J5LlxuXAotXG5cCi1USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVJcblwKLVRPIFRIRSBFUEwgT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLlxuXAotU09NRSBPRiBUSEVTRSBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOlxuXAotXG5cCi0gICAgLSBDb21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbClcblwKLSAgICAtIEFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFKVxuXAotICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wKVxuXAotICAgIC0gSUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sKVxuXAotICAgIC0gTWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwpXG5cCi0gICAgLSBNb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sKVxuXAotICAgIC0gQ29tbW9uIERldmVsb3BtZW50IGFuZCBEaXN0cmlidXRpb24gTGljZW5zZSAoQ0RETCkgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwpXG5cCi1cblwKLUlUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1JcblwKLVRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlXG5cCi1pcyBwcm92aWRlZCwgcGxlYXNlIGNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9uc1xuXAotZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LlxuXAotXG5cCi1DcnlwdG9ncmFwaHlcblwKLVxuXAotQ29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlXG5cCi1jdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsXG5cCi1hbmQvb3IgcmUtZXhwb3J0IHRvIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFXG5cCi11c2luZyBhbnkgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cyxcblwKLXJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIG9yIHVzZSxcblwKLWFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLlxuXAotXG5cCi1KYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIFN1biBNaWNyb3N5c3RlbXMsIEluYy4gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC5cbgotIyMjIyMjIyMjIyMgZW5kIG9mIGxpY2Vuc2UgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVGZWF0dXJlL2xpY2Vuc2UuaHRtbCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvbGljZW5zZS5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmZWM0YTQ4Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvbGljZW5zZS5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsODIgKzAsMCBAQAotPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMC8vRU4iPgotPGh0bWw+Ci08aGVhZD4KLTxtZXRhIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4KLTx0aXRsZT5FY2xpcHNlLm9yZyBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvdGl0bGU+Ci08L2hlYWQ+Ci0KLTxib2R5IGxhbmc9IkVOLVVTIiBsaW5rPWJsdWUgdmxpbms9cHVycGxlPgotPGgyPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvaDI+Ci08cD5KdW5lIDA2LCAyMDA3PC9wPgotCi08aDM+VXNhZ2UgT2YgQ29udGVudDwvaDM+Ci0KLTxwPlRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiBBTkQvT1IgT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUwotICAgKENPTExFQ1RJVkVMWSAmcXVvdDtDT05URU5UJnF1b3Q7KS4gIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQKLSAgIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VIEFHUkVFIFRIQVQgWU9VUiBVU0UKLSAgIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SCi0gICBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQKLSAgIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULjwvcD4KLSAgIAotPGgzPkFwcGxpY2FibGUgTGljZW5zZXM8L2gzPiAgIAotICAgCi08cD5Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wCi0gICAoJnF1b3Q7RVBMJnF1b3Q7KS4gIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpcyBDb250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L2E+LgotICAgRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICZxdW90O1Byb2dyYW0mcXVvdDsgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvcD4KLQotPHA+Q29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsIGRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2Uub3JnIENWUyByZXBvc2l0b3J5ICgmcXVvdDtSZXBvc2l0b3J5JnF1b3Q7KSBpbiBDVlMKLSAgIG1vZHVsZXMgKCZxdW90O01vZHVsZXMmcXVvdDspIGFuZCBtYWRlIGF2YWlsYWJsZSBhcyBkb3dubG9hZGFibGUgYXJjaGl2ZXMgKCZxdW90O0Rvd25sb2FkcyZxdW90OykuPC9wPgotICAgCi08dWw+Ci0JPGxpPkNvbnRlbnQgbWF5IGJlIHN0cnVjdHVyZWQgYW5kIHBhY2thZ2VkIGludG8gbW9kdWxlcyB0byBmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsIGV4dGVuZGluZywgYW5kIHVwZ3JhZGluZyB0aGUgQ29udGVudC4gIFR5cGljYWwgbW9kdWxlcyBtYXkgaW5jbHVkZSBwbHVnLWlucyAoJnF1b3Q7UGx1Zy1pbnMmcXVvdDspLCBwbHVnLWluIGZyYWdtZW50cyAoJnF1b3Q7RnJhZ21lbnRzJnF1b3Q7KSwgYW5kIGZlYXR1cmVzICgmcXVvdDtGZWF0dXJlcyZxdW90OykuPC9saT4KLQk8bGk+RWFjaCBQbHVnLWluIG9yIEZyYWdtZW50IG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3Rvcnkgb3IgSkFSIChKYXZhJnRyYWRlOyBBUmNoaXZlKSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtwbHVnaW5zJnF1b3Q7LjwvbGk+Ci0JPGxpPkEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLiAgRWFjaCBGZWF0dXJlIG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3RvcnkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgJnF1b3Q7ZmVhdHVyZXMmcXVvdDsuICBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnhtbCZxdW90OyBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgdGhlIFBsdWctaW5zCi0gICAgICBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuPC9saT4KLQk8bGk+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoJnF1b3Q7SW5jbHVkZWQgRmVhdHVyZXMmcXVvdDspLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnhtbCZxdW90OyBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgRmVhdHVyZXMuPC9saT4KLTwvdWw+ICAgCi0gCi08cD5UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAmcXVvdDthYm91dC5odG1sJnF1b3Q7ICgmcXVvdDtBYm91dHMmcXVvdDspLiBUaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIEZlYXR1cmVzIGFuZAotSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAmcXVvdDtsaWNlbnNlLmh0bWwmcXVvdDsgKCZxdW90O0ZlYXR1cmUgTGljZW5zZXMmcXVvdDspLiAgQWJvdXRzIGFuZCBGZWF0dXJlIExpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSBkaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGUKLWluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOjwvcD4KLQotPHVsPgotCTxsaT5UaGUgdG9wLWxldmVsIChyb290KSBkaXJlY3Rvcnk8L2xpPgotCTxsaT5QbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3RvcmllczwvbGk+Ci0JPGxpPkluc2lkZSBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHBhY2thZ2VkIGFzIEpBUnM8L2xpPgotCTxsaT5TdWItZGlyZWN0b3JpZXMgb2YgdGhlIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtzcmMmcXVvdDsgb2YgY2VydGFpbiBQbHVnLWluczwvbGk+Ci0JPGxpPkZlYXR1cmUgZGlyZWN0b3JpZXM8L2xpPgotPC91bD4KLQkJCi08cD5Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlIEVjbGlwc2UgVXBkYXRlIE1hbmFnZXIsIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoJnF1b3Q7RmVhdHVyZSBVcGRhdGUgTGljZW5zZSZxdW90OykgZHVyaW5nIHRoZQotaW5zdGFsbGF0aW9uIHByb2Nlc3MuICBJZiB0aGUgRmVhdHVyZSBjb250YWlucyBJbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdSB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgdGhlIEluY2x1ZGVkIEZlYXR1cmVzIG9yCi1pbmZvcm0geW91IHdoZXJlIHlvdSBjYW4gbG9jYXRlIHRoZW0uICBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW4gdGhlICZxdW90O2xpY2Vuc2UmcXVvdDsgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgJnF1b3Q7ZmVhdHVyZS5wcm9wZXJ0aWVzJnF1b3Q7IGZvdW5kIHdpdGhpbiBhIEZlYXR1cmUuCi1TdWNoIEFib3V0cywgRmVhdHVyZSBMaWNlbnNlcywgYW5kIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXIgdXNlIG9mIHRoZSBhc3NvY2lhdGVkIENvbnRlbnQgaW4KLXRoYXQgZGlyZWN0b3J5LjwvcD4KLQotPHA+VEhFIEFCT1VUUywgRkVBVFVSRSBMSUNFTlNFUywgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUiBUTyBUSEUgRVBMIE9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy4gIFNPTUUgT0YgVEhFU0UKLU9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6PC9wPgotCi08dWw+Ci0JPGxpPkNvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbDwvYT4pPC9saT4KLQk8bGk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFPC9hPik8L2xpPgotCTxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMDwvYT4pPC9saT4KLQk8bGk+SUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sIj5odHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vZGV2ZWxvcGVyd29ya3Mvb3BlbnNvdXJjZS9saWNlbnNlMTAuaHRtbDwvYT4pPC9saT4JCi0JPGxpPk1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sIj5odHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbDwvYT4pPC9saT4KLQk8bGk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbCI+aHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sPC9hPik8L2xpPgotICA8TEk+Q29tbW9uIERldmVsb3BtZW50IGFuZCBEaXN0cmlidXRpb24gTGljZW5zZSAoQ0RETCkgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sIj5odHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwpPC9BPgotICA8L0xJPgotPC9VTD4KLQotPHA+SVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgQ09ORElUSU9OUyBQUklPUiBUTyBVU0UgT0YgVEhFIENPTlRFTlQuICBJZiBubyBBYm91dCwgRmVhdHVyZSBMaWNlbnNlLCBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIGlzIHByb3ZpZGVkLCBwbGVhc2UKLWNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuPC9wPgotCi08aDM+Q3J5cHRvZ3JhcGh5PC9oMz4KLQotPHA+Q29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlIGN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSwgYW5kL29yIHJlLWV4cG9ydCB0bwotICAgYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkUgdXNpbmcgYW55IGVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsIHJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsCi0gICBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLjwvcD4KLSAgIAotPHNtYWxsPkphdmEgYW5kIGFsbCBKYXZhLWJhc2VkIHRyYWRlbWFya3MgYXJlIHRyYWRlbWFya3Mgb2YgU3VuIE1pY3Jvc3lzdGVtcywgSW5jLiBpbiB0aGUgVW5pdGVkIFN0YXRlcywgb3RoZXIgY291bnRyaWVzLCBvciBib3RoLjwvc21hbGw+ICAgCi08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vYWJvdXQuaHRtbCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9hYm91dC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkNDkxNmRmLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9hYm91dC5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsMjcgKzAsMCBAQAotPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMC8vRU4iPgotPGh0bWw+Ci08aGVhZD4KLTx0aXRsZT5BYm91dDwvdGl0bGU+Ci08bWV0YSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9SVNPLTg4NTktMSI+Ci08L2hlYWQ+Ci08Ym9keSBsYW5nPSJFTi1VUyI+Ci08aDI+QWJvdXQgVGhpcyBDb250ZW50PC9oMj4KLQotPHA+SnVuZSAwNiwgMjAwNzwvcD4JCi08aDM+TGljZW5zZTwvaDM+Ci0KLTxwPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIGFsbCBjb250ZW50IGluIHRoaXMgcGx1Zy1pbiAoJnF1b3Q7Q29udGVudCZxdW90OykuICBVbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCBiZWxvdywgdGhlIENvbnRlbnQgaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUKLUVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKCZxdW90O0VQTCZxdW90OykuICBBIGNvcHkgb2YgdGhlIEVQTCBpcyBhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sPC9hPi4KLUZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAmcXVvdDtQcm9ncmFtJnF1b3Q7IHdpbGwgbWVhbiB0aGUgQ29udGVudC48L3A+Ci0KLTxwPklmIHlvdSBkaWQgbm90IHJlY2VpdmUgdGhpcyBDb250ZW50IGRpcmVjdGx5IGZyb20gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiwgdGhlIENvbnRlbnQgaXMgYmVpbmcgcmVkaXN0cmlidXRlZCBieSBhbm90aGVyIHBhcnR5ICgmcXVvdDtSZWRpc3RyaWJ1dG9yJnF1b3Q7KSBhbmQgZGlmZmVyZW50IHRlcm1zIGFuZCBjb25kaXRpb25zIG1heQotYXBwbHkgdG8geW91ciB1c2Ugb2YgYW55IG9iamVjdCBjb2RlIGluIHRoZSBDb250ZW50LiAgQ2hlY2sgdGhlIFJlZGlzdHJpYnV0b3IncyBsaWNlbnNlIHRoYXQgd2FzIHByb3ZpZGVkIHdpdGggdGhlIENvbnRlbnQuICBJZiBubyBzdWNoIGxpY2Vuc2UgZXhpc3RzLCBjb250YWN0IHRoZSBSZWRpc3RyaWJ1dG9yLiAgVW5sZXNzIG90aGVyd2lzZQotaW5kaWNhdGVkIGJlbG93LCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVQTCBzdGlsbCBhcHBseSB0byBhbnkgc291cmNlIGNvZGUgaW4gdGhlIENvbnRlbnQuPC9wPgotCi08aDM+U291cmNlIENvZGU8L2gzPgotPHA+VGhpcyBwbHVnLWluIGNvbnRhaW5zIHNvdXJjZSBjb2RlIHppcCBmaWxlcyAoJnF1b3Q7U291cmNlIFppcHMmcXVvdDspIHRoYXQgY29ycmVzcG9uZCB0byBiaW5hcnkgY29udGVudCBpbiBvdGhlciBwbHVnLWlucy4gVGhlc2UgU291cmNlIFppcHMgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIGRpZmZlcmVudCBsaWNlbnNlCi1hZ3JlZW1lbnRzIGFuZC9vciBub3RpY2VzLiBEZXRhaWxzIGFib3V0IHRoZXNlIGxpY2Vuc2UgYWdyZWVtZW50cyBhbmQgbm90aWNlcyBhcmUgY29udGFpbmVkIGluICZxdW90O2Fib3V0Lmh0bWwmcXVvdDsgZmlsZXMgKCZxdW90O0Fib3V0cyZxdW90OykgbG9jYXRlZCBpbiBzdWItZGlyZWN0b3JpZXMgaW4gdGhlCi1zcmMvIGRpcmVjdG9yeSBvZiB0aGlzIHBsdWctaW4uIFN1Y2ggQWJvdXRzIGdvdmVybiB5b3VyIHVzZSBvZiB0aGUgU291cmNlIFppcHMgaW4gdGhhdCBkaXJlY3RvcnksIG5vdCB0aGUgRVBMLjwvcD4KLQotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2Fib3V0LmluaSBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9hYm91dC5pbmkKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDJkZWUzNmEuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2Fib3V0LmluaQorKysgL2Rldi9udWxsCkBAIC0xLDMxICswLDAgQEAKLSMgYWJvdXQuaW5pCi0jIGNvbnRhaW5zIGluZm9ybWF0aW9uIGFib3V0IGEgZmVhdHVyZQotIyBqYXZhLmlvLlByb3BlcnRpZXMgZmlsZSAoSVNPIDg4NTktMSB3aXRoICJcIiBlc2NhcGVzKQotIyAiJWtleSIgYXJlIGV4dGVybmFsaXplZCBzdHJpbmdzIGRlZmluZWQgaW4gYWJvdXQucHJvcGVydGllcwotIyBUaGlzIGZpbGUgZG9lcyBub3QgbmVlZCB0byBiZSB0cmFuc2xhdGVkLgotCi0jIFByb3BlcnR5ICJhYm91dFRleHQiIGNvbnRhaW5zIGJsdXJiIGZvciAiQWJvdXQiIGRpYWxvZyAodHJhbnNsYXRlZCkKLWFib3V0VGV4dD0lYmx1cmIKLQotIyBQcm9wZXJ0eSAid2luZG93SW1hZ2UiIGNvbnRhaW5zIHBhdGggdG8gd2luZG93IGljb24gKDE2eDE2KQotIyBuZWVkZWQgZm9yIHByaW1hcnkgZmVhdHVyZXMgb25seQotCi0jIFByb3BlcnR5ICJmZWF0dXJlSW1hZ2UiIGNvbnRhaW5zIHBhdGggdG8gZmVhdHVyZSBpbWFnZSAoMzJ4MzIpCi1mZWF0dXJlSW1hZ2U9ZWNsaXBzZTMyLmdpZgotCi0jIFByb3BlcnR5ICJhYm91dEltYWdlIiBjb250YWlucyBwYXRoIHRvIHByb2R1Y3QgaW1hZ2UgKDUwMHgzMzAgb3IgMTE1eDE2NCkKLSMgbmVlZGVkIGZvciBwcmltYXJ5IGZlYXR1cmVzIG9ubHkKLQotIyBQcm9wZXJ0eSAiYXBwTmFtZSIgY29udGFpbnMgbmFtZSBvZiB0aGUgYXBwbGljYXRpb24gKG5vdCB0cmFuc2xhdGVkKQotIyBuZWVkZWQgZm9yIHByaW1hcnkgZmVhdHVyZXMgb25seQotCi0jIFByb3BlcnR5ICJ3ZWxjb21lUGFnZSIgY29udGFpbnMgcGF0aCB0byB3ZWxjb21lIHBhZ2UgKHNwZWNpYWwgWE1MLWJhc2VkIGZvcm1hdCkKLSMgb3B0aW9uYWwKLQotIyBQcm9wZXJ0eSAid2VsY29tZVBlcnNwZWN0aXZlIiBjb250YWlucyB0aGUgaWQgb2YgdGhlIHBlcnNwZWN0aXZlIGluIHdoaWNoIHRoZQotIyB3ZWxjb21lIHBhZ2UgaXMgdG8gYmUgb3BlbmVkLgotIyBvcHRpb25hbAotCi0KLQotCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vYWJvdXQubWFwcGluZ3MgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vYWJvdXQubWFwcGluZ3MKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGEyODM5MGEuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2Fib3V0Lm1hcHBpbmdzCisrKyAvZGV2L251bGwKQEAgLTEsNiArMCwwIEBACi0jIGFib3V0Lm1hcHBpbmdzCi0jIGNvbnRhaW5zIGZpbGwtaW5zIGZvciBhYm91dC5wcm9wZXJ0aWVzCi0jIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCi0jIFRoaXMgZmlsZSBkb2VzIG5vdCBuZWVkIHRvIGJlIHRyYW5zbGF0ZWQuCi0KLTA9QGJ1aWxkQApkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2Fib3V0LnByb3BlcnRpZXMgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vYWJvdXQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNTBjMGE5ZS4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vYWJvdXQucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDI2ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBhYm91dC5wcm9wZXJ0aWVzCi0jIGNvbnRhaW5zIGV4dGVybmFsaXplZCBzdHJpbmdzIGZvciBhYm91dC5pbmkKLSMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKLSMgZmlsbC1pbnMgYXJlIHN1cHBsaWVkIGJ5IGFib3V0Lm1hcHBpbmdzCi0jIFRoaXMgZmlsZSBzaG91bGQgYmUgdHJhbnNsYXRlZC4KLSMKLSMgRG8gbm90IHRyYW5zbGF0ZSBhbnkgdmFsdWVzIHN1cnJvdW5kZWQgYnkge30KLQotYmx1cmI9SmF2YSBQZXJzaXN0ZW5jZSBBUEkgVG9vbHMgLSBFY2xpcHNlTGluayBTdXBwb3J0IFNvdXJjZVxuXAotXG5cCi1WZXJzaW9uOiB7ZmVhdHVyZVZlcnNpb259XG5cCi1CdWlsZCBpZDogezB9XG5cCi1cblwKLShjKSBDb3B5cmlnaHQgRWNsaXBzZSBjb250cmlidXRvcnMgYW5kIG90aGVycyAyMDA1LiAgQWxsIHJpZ2h0cyByZXNlcnZlZC5cblwKLVZpc2l0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvd2VidG9vbHMKLQpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2J1aWxkLnByb3BlcnRpZXMgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmRjZmNkNi4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vYnVpbGQucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDIxICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotYmluLmluY2x1ZGVzID0gXAotICAgICAgICAgICAgICAgYWJvdXQuaHRtbCxcCi0gICAgICAgICAgICAgICBhYm91dC5pbmksXAotICAgICAgICAgICAgICAgYWJvdXQubWFwcGluZ3MsXAotICAgICAgICAgICAgICAgYWJvdXQucHJvcGVydGllcyxcCi0gICAgICAgICAgICAgICBlY2xpcHNlMzIuZ2lmLFwKLSAgICAgICAgICAgICAgIHBsdWdpbi5wcm9wZXJ0aWVzLFwKLSAgICAgICAgICAgICAgIHBsdWdpbi54bWwsXAotICAgICAgICAgICAgICAgc3JjLyoqLFwKLSAgICAgICAgICAgICAgIE1FVEEtSU5GLwotc291cmNlUGx1Z2luID0gdHJ1ZQpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2VjbGlwc2UzMi5naWYgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vZWNsaXBzZTMyLmdpZgpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTZhZDdjYy4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vZWNsaXBzZTMyLmdpZgorKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9lY2xpcHNlMzIucG5nIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2VjbGlwc2UzMi5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDUwYWU0OWQuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2VjbGlwc2UzMi5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vZWNsaXBzZV91cGRhdGVfMTIwLmpwZyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiZmRmNzA4Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2VwbC12MTAuaHRtbCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9lcGwtdjEwLmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAyMmFkMjkuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2VwbC12MTAuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDMyOCArMCwwIEBACi08aHRtbCB4bWxuczpvPSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTpvZmZpY2UiCi14bWxuczp3PSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTp3b3JkIgoteG1sbnM9Imh0dHA6Ly93d3cudzMub3JnL1RSL1JFQy1odG1sNDAiPgotCi08aGVhZD4KLTxtZXRhIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD13aW5kb3dzLTEyNTIiPgotPG1ldGEgbmFtZT1Qcm9nSWQgY29udGVudD1Xb3JkLkRvY3VtZW50PgotPG1ldGEgbmFtZT1HZW5lcmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgOSI+Ci08bWV0YSBuYW1lPU9yaWdpbmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgOSI+Ci08bGluayByZWw9RmlsZS1MaXN0Ci1ocmVmPSIuL0VjbGlwc2UlMjBFUEwlMjAyMDAzXzExXzEwJTIwRmluYWxfZmlsZXMvZmlsZWxpc3QueG1sIj4KLTx0aXRsZT5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gVmVyc2lvbiAxLjA8L3RpdGxlPgotPCEtLVtpZiBndGUgbXNvIDldPjx4bWw+Ci0gPG86RG9jdW1lbnRQcm9wZXJ0aWVzPgotICA8bzpSZXZpc2lvbj4yPC9vOlJldmlzaW9uPgotICA8bzpUb3RhbFRpbWU+MzwvbzpUb3RhbFRpbWU+Ci0gIDxvOkNyZWF0ZWQ+MjAwNC0wMy0wNVQyMzowMzowMFo8L286Q3JlYXRlZD4KLSAgPG86TGFzdFNhdmVkPjIwMDQtMDMtMDVUMjM6MDM6MDBaPC9vOkxhc3RTYXZlZD4KLSAgPG86UGFnZXM+NDwvbzpQYWdlcz4KLSAgPG86V29yZHM+MTYyNjwvbzpXb3Jkcz4KLSAgPG86Q2hhcmFjdGVycz45MjcwPC9vOkNoYXJhY3RlcnM+Ci0gICA8bzpMaW5lcz43NzwvbzpMaW5lcz4KLSAgPG86UGFyYWdyYXBocz4xODwvbzpQYXJhZ3JhcGhzPgotICA8bzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4xMTM4NDwvbzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4KLSAgPG86VmVyc2lvbj45LjQ0MDI8L286VmVyc2lvbj4KLSA8L286RG9jdW1lbnRQcm9wZXJ0aWVzPgotPC94bWw+PCFbZW5kaWZdLS0+PCEtLVtpZiBndGUgbXNvIDldPjx4bWw+Ci0gPHc6V29yZERvY3VtZW50PgotICA8dzpUcmFja1JldmlzaW9ucy8+Ci0gPC93OldvcmREb2N1bWVudD4KLTwveG1sPjwhW2VuZGlmXS0tPgotPHN0eWxlPgotPCEtLQotIC8qIEZvbnQgRGVmaW5pdGlvbnMgKi8KLUBmb250LWZhY2UKLQl7Zm9udC1mYW1pbHk6VGFob21hOwotCXBhbm9zZS0xOjIgMTEgNiA0IDMgNSA0IDQgMiA0OwotCW1zby1mb250LWNoYXJzZXQ6MDsKLQltc28tZ2VuZXJpYy1mb250LWZhbWlseTpzd2lzczsKLQltc28tZm9udC1waXRjaDp2YXJpYWJsZTsKLQltc28tZm9udC1zaWduYXR1cmU6NTUzNjc5NDk1IC0yMTQ3NDgzNjQ4IDggMCA2NjA0NyAwO30KLSAvKiBTdHlsZSBEZWZpbml0aW9ucyAqLwotcC5Nc29Ob3JtYWwsIGxpLk1zb05vcm1hbCwgZGl2Lk1zb05vcm1hbAotCXttc28tc3R5bGUtcGFyZW50OiIiOwotCW1hcmdpbjowaW47Ci0JbWFyZ2luLWJvdHRvbTouMDAwMXB0OwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXAKLQl7bWFyZ2luLXJpZ2h0OjBpbjsKLQltc28tbWFyZ2luLXRvcC1hbHQ6YXV0bzsKLQltc28tbWFyZ2luLWJvdHRvbS1hbHQ6YXV0bzsKLQltYXJnaW4tbGVmdDowaW47Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZToxMi4wcHQ7Ci0JZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotcC5CYWxsb29uVGV4dCwgbGkuQmFsbG9vblRleHQsIGRpdi5CYWxsb29uVGV4dAotCXttc28tc3R5bGUtbmFtZToiQmFsbG9vbiBUZXh0IjsKLQltYXJnaW46MGluOwotCW1hcmdpbi1ib3R0b206LjAwMDFwdDsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjguMHB0OwotCWZvbnQtZmFtaWx5OlRhaG9tYTsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1AcGFnZSBTZWN0aW9uMQotCXtzaXplOjguNWluIDExLjBpbjsKLQltYXJnaW46MS4waW4gMS4yNWluIDEuMGluIDEuMjVpbjsKLQltc28taGVhZGVyLW1hcmdpbjouNWluOwotCW1zby1mb290ZXItbWFyZ2luOi41aW47Ci0JbXNvLXBhcGVyLXNvdXJjZTowO30KLWRpdi5TZWN0aW9uMQotCXtwYWdlOlNlY3Rpb24xO30KLS0tPgotPC9zdHlsZT4KLTwvaGVhZD4KLQotPGJvZHkgbGFuZz1FTi1VUyBzdHlsZT0ndGFiLWludGVydmFsOi41aW4nPgotCi08ZGl2IGNsYXNzPVNlY3Rpb24xPgotCi08cCBhbGlnbj1jZW50ZXIgc3R5bGU9J3RleHQtYWxpZ246Y2VudGVyJz48Yj5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gdiAxLjA8L2I+Ci08L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5USEUgQUNDT01QQU5ZSU5HIFBST0dSQU0gSVMgUFJPVklERUQgVU5ERVIKLVRIRSBURVJNUyBPRiBUSElTIEVDTElQU0UgUFVCTElDIExJQ0VOU0UgKCZxdW90O0FHUkVFTUVOVCZxdW90OykuIEFOWSBVU0UsCi1SRVBST0RVQ1RJT04gT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIENPTlNUSVRVVEVTIFJFQ0lQSUVOVCdTIEFDQ0VQVEFOQ0UKLU9GIFRISVMgQUdSRUVNRU5ULjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+MS4gREVGSU5JVElPTlM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtDb250cmlidXRpb24mcXVvdDsgbWVhbnM6PC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pbiB0aGUgY2FzZSBvZiB0aGUgaW5pdGlhbCBDb250cmlidXRvciwgdGhlIGluaXRpYWwgY29kZSBhbmQgZG9jdW1lbnRhdGlvbgotZGlzdHJpYnV0ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGFuZDxiciBjbGVhcj1sZWZ0PgotYikgaW4gdGhlIGNhc2Ugb2YgZWFjaCBzdWJzZXF1ZW50IENvbnRyaWJ1dG9yOjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmkpCi1jaGFuZ2VzIHRvIHRoZSBQcm9ncmFtLCBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paSkKLWFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbTs8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz53aGVyZQotc3VjaCBjaGFuZ2VzIGFuZC9vciBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gb3JpZ2luYXRlIGZyb20gYW5kIGFyZSBkaXN0cmlidXRlZAotYnkgdGhhdCBwYXJ0aWN1bGFyIENvbnRyaWJ1dG9yLiBBIENvbnRyaWJ1dGlvbiAnb3JpZ2luYXRlcycgZnJvbSBhIENvbnRyaWJ1dG9yCi1pZiBpdCB3YXMgYWRkZWQgdG8gdGhlIFByb2dyYW0gYnkgc3VjaCBDb250cmlidXRvciBpdHNlbGYgb3IgYW55b25lIGFjdGluZyBvbgotc3VjaCBDb250cmlidXRvcidzIGJlaGFsZi4gQ29udHJpYnV0aW9ucyBkbyBub3QgaW5jbHVkZSBhZGRpdGlvbnMgdG8gdGhlCi1Qcm9ncmFtIHdoaWNoOiAoaSkgYXJlIHNlcGFyYXRlIG1vZHVsZXMgb2Ygc29mdHdhcmUgZGlzdHJpYnV0ZWQgaW4gY29uanVuY3Rpb24KLXdpdGggdGhlIFByb2dyYW0gdW5kZXIgdGhlaXIgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBhbmQgKGlpKSBhcmUgbm90IGRlcml2YXRpdmUKLXdvcmtzIG9mIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7Q29udHJpYnV0b3ImcXVvdDsgbWVhbnMgYW55IHBlcnNvbiBvcgotZW50aXR5IHRoYXQgZGlzdHJpYnV0ZXMgdGhlIFByb2dyYW0uPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtMaWNlbnNlZCBQYXRlbnRzICZxdW90OyBtZWFuIHBhdGVudAotY2xhaW1zIGxpY2Vuc2FibGUgYnkgYSBDb250cmlidXRvciB3aGljaCBhcmUgbmVjZXNzYXJpbHkgaW5mcmluZ2VkIGJ5IHRoZSB1c2UKLW9yIHNhbGUgb2YgaXRzIENvbnRyaWJ1dGlvbiBhbG9uZSBvciB3aGVuIGNvbWJpbmVkIHdpdGggdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtQcm9ncmFtJnF1b3Q7IG1lYW5zIHRoZSBDb250cmlidXRpb25zCi1kaXN0cmlidXRlZCBpbiBhY2NvcmRhbmNlIHdpdGggdGhpcyBBZ3JlZW1lbnQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtSZWNpcGllbnQmcXVvdDsgbWVhbnMgYW55b25lIHdobwotcmVjZWl2ZXMgdGhlIFByb2dyYW0gdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGluY2x1ZGluZyBhbGwgQ29udHJpYnV0b3JzLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Mi4gR1JBTlQgT0YgUklHSFRTPC9zcGFuPjwvYj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQKLWEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLCByb3lhbHR5LWZyZWUgY29weXJpZ2h0IGxpY2Vuc2UgdG88c3Bhbgotc3R5bGU9J2NvbG9yOnJlZCc+IDwvc3Bhbj5yZXByb2R1Y2UsIHByZXBhcmUgZGVyaXZhdGl2ZSB3b3JrcyBvZiwgcHVibGljbHkKLWRpc3BsYXksIHB1YmxpY2x5IHBlcmZvcm0sIGRpc3RyaWJ1dGUgYW5kIHN1YmxpY2Vuc2UgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoCi1Db250cmlidXRvciwgaWYgYW55LCBhbmQgc3VjaCBkZXJpdmF0aXZlIHdvcmtzLCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUKLWZvcm0uPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikKLVN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMKLVJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSw8c3BhbiBzdHlsZT0nY29sb3I6Z3JlZW4nPiA8L3NwYW4+cm95YWx0eS1mcmVlCi1wYXRlbnQgbGljZW5zZSB1bmRlciBMaWNlbnNlZCBQYXRlbnRzIHRvIG1ha2UsIHVzZSwgc2VsbCwgb2ZmZXIgdG8gc2VsbCwgaW1wb3J0Ci1hbmQgb3RoZXJ3aXNlIHRyYW5zZmVyIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBpbiBzb3VyY2UKLWNvZGUgYW5kIG9iamVjdCBjb2RlIGZvcm0uIFRoaXMgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgYXBwbHkgdG8gdGhlIGNvbWJpbmF0aW9uCi1vZiB0aGUgQ29udHJpYnV0aW9uIGFuZCB0aGUgUHJvZ3JhbSBpZiwgYXQgdGhlIHRpbWUgdGhlIENvbnRyaWJ1dGlvbiBpcyBhZGRlZAotYnkgdGhlIENvbnRyaWJ1dG9yLCBzdWNoIGFkZGl0aW9uIG9mIHRoZSBDb250cmlidXRpb24gY2F1c2VzIHN1Y2ggY29tYmluYXRpb24KLXRvIGJlIGNvdmVyZWQgYnkgdGhlIExpY2Vuc2VkIFBhdGVudHMuIFRoZSBwYXRlbnQgbGljZW5zZSBzaGFsbCBub3QgYXBwbHkgdG8KLWFueSBvdGhlciBjb21iaW5hdGlvbnMgd2hpY2ggaW5jbHVkZSB0aGUgQ29udHJpYnV0aW9uLiBObyBoYXJkd2FyZSBwZXIgc2UgaXMKLWxpY2Vuc2VkIGhlcmV1bmRlci4gPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YykKLVJlY2lwaWVudCB1bmRlcnN0YW5kcyB0aGF0IGFsdGhvdWdoIGVhY2ggQ29udHJpYnV0b3IgZ3JhbnRzIHRoZSBsaWNlbnNlcyB0byBpdHMKLUNvbnRyaWJ1dGlvbnMgc2V0IGZvcnRoIGhlcmVpbiwgbm8gYXNzdXJhbmNlcyBhcmUgcHJvdmlkZWQgYnkgYW55IENvbnRyaWJ1dG9yCi10aGF0IHRoZSBQcm9ncmFtIGRvZXMgbm90IGluZnJpbmdlIHRoZSBwYXRlbnQgb3Igb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5Ci1yaWdodHMgb2YgYW55IG90aGVyIGVudGl0eS4gRWFjaCBDb250cmlidXRvciBkaXNjbGFpbXMgYW55IGxpYWJpbGl0eSB0byBSZWNpcGllbnQKLWZvciBjbGFpbXMgYnJvdWdodCBieSBhbnkgb3RoZXIgZW50aXR5IGJhc2VkIG9uIGluZnJpbmdlbWVudCBvZiBpbnRlbGxlY3R1YWwKLXByb3BlcnR5IHJpZ2h0cyBvciBvdGhlcndpc2UuIEFzIGEgY29uZGl0aW9uIHRvIGV4ZXJjaXNpbmcgdGhlIHJpZ2h0cyBhbmQKLWxpY2Vuc2VzIGdyYW50ZWQgaGVyZXVuZGVyLCBlYWNoIFJlY2lwaWVudCBoZXJlYnkgYXNzdW1lcyBzb2xlIHJlc3BvbnNpYmlsaXR5Ci10byBzZWN1cmUgYW55IG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgbmVlZGVkLCBpZiBhbnkuIEZvciBleGFtcGxlLAotaWYgYSB0aGlyZCBwYXJ0eSBwYXRlbnQgbGljZW5zZSBpcyByZXF1aXJlZCB0byBhbGxvdyBSZWNpcGllbnQgdG8gZGlzdHJpYnV0ZQotdGhlIFByb2dyYW0sIGl0IGlzIFJlY2lwaWVudCdzIHJlc3BvbnNpYmlsaXR5IHRvIGFjcXVpcmUgdGhhdCBsaWNlbnNlIGJlZm9yZQotZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtLjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmQpCi1FYWNoIENvbnRyaWJ1dG9yIHJlcHJlc2VudHMgdGhhdCB0byBpdHMga25vd2xlZGdlIGl0IGhhcyBzdWZmaWNpZW50IGNvcHlyaWdodAotcmlnaHRzIGluIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgdG8gZ3JhbnQgdGhlIGNvcHlyaWdodCBsaWNlbnNlIHNldCBmb3J0aCBpbgotdGhpcyBBZ3JlZW1lbnQuIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4zLiBSRVFVSVJFTUVOVFM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5BIENvbnRyaWJ1dG9yIG1heSBjaG9vc2UgdG8gZGlzdHJpYnV0ZSB0aGUKLVByb2dyYW0gaW4gb2JqZWN0IGNvZGUgZm9ybSB1bmRlciBpdHMgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBwcm92aWRlZCB0aGF0Ojwvc3Bhbj4KLTwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWl0IGNvbXBsaWVzIHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50OyBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKQotaXRzIGxpY2Vuc2UgYWdyZWVtZW50Ojwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmkpCi1lZmZlY3RpdmVseSBkaXNjbGFpbXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIHdhcnJhbnRpZXMgYW5kCi1jb25kaXRpb25zLCBleHByZXNzIGFuZCBpbXBsaWVkLCBpbmNsdWRpbmcgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIHRpdGxlCi1hbmQgbm9uLWluZnJpbmdlbWVudCwgYW5kIGltcGxpZWQgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIG1lcmNoYW50YWJpbGl0eQotYW5kIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlOyA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paSkKLWVmZmVjdGl2ZWx5IGV4Y2x1ZGVzIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCBsaWFiaWxpdHkgZm9yIGRhbWFnZXMsCi1pbmNsdWRpbmcgZGlyZWN0LCBpbmRpcmVjdCwgc3BlY2lhbCwgaW5jaWRlbnRhbCBhbmQgY29uc2VxdWVudGlhbCBkYW1hZ2VzLCBzdWNoCi1hcyBsb3N0IHByb2ZpdHM7IDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpaSkKLXN0YXRlcyB0aGF0IGFueSBwcm92aXNpb25zIHdoaWNoIGRpZmZlciBmcm9tIHRoaXMgQWdyZWVtZW50IGFyZSBvZmZlcmVkIGJ5IHRoYXQKLUNvbnRyaWJ1dG9yIGFsb25lIGFuZCBub3QgYnkgYW55IG90aGVyIHBhcnR5OyBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pdikKLXN0YXRlcyB0aGF0IHNvdXJjZSBjb2RlIGZvciB0aGUgUHJvZ3JhbSBpcyBhdmFpbGFibGUgZnJvbSBzdWNoIENvbnRyaWJ1dG9yLCBhbmQKLWluZm9ybXMgbGljZW5zZWVzIGhvdyB0byBvYnRhaW4gaXQgaW4gYSByZWFzb25hYmxlIG1hbm5lciBvbiBvciB0aHJvdWdoIGEKLW1lZGl1bSBjdXN0b21hcmlseSB1c2VkIGZvciBzb2Z0d2FyZSBleGNoYW5nZS48c3BhbiBzdHlsZT0nY29sb3I6Ymx1ZSc+IDwvc3Bhbj48L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+V2hlbiB0aGUgUHJvZ3JhbSBpcyBtYWRlIGF2YWlsYWJsZSBpbiBzb3VyY2UKLWNvZGUgZm9ybTo8L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWl0IG11c3QgYmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhpcyBBZ3JlZW1lbnQ7IGFuZCA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKSBhCi1jb3B5IG9mIHRoaXMgQWdyZWVtZW50IG11c3QgYmUgaW5jbHVkZWQgd2l0aCBlYWNoIGNvcHkgb2YgdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Db250cmlidXRvcnMgbWF5IG5vdCByZW1vdmUgb3IgYWx0ZXIgYW55Ci1jb3B5cmlnaHQgbm90aWNlcyBjb250YWluZWQgd2l0aGluIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RWFjaCBDb250cmlidXRvciBtdXN0IGlkZW50aWZ5IGl0c2VsZiBhcyB0aGUKLW9yaWdpbmF0b3Igb2YgaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCBpbiBhIG1hbm5lciB0aGF0IHJlYXNvbmFibHkgYWxsb3dzCi1zdWJzZXF1ZW50IFJlY2lwaWVudHMgdG8gaWRlbnRpZnkgdGhlIG9yaWdpbmF0b3Igb2YgdGhlIENvbnRyaWJ1dGlvbi4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjQuIENPTU1FUkNJQUwgRElTVFJJQlVUSU9OPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Q29tbWVyY2lhbCBkaXN0cmlidXRvcnMgb2Ygc29mdHdhcmUgbWF5Ci1hY2NlcHQgY2VydGFpbiByZXNwb25zaWJpbGl0aWVzIHdpdGggcmVzcGVjdCB0byBlbmQgdXNlcnMsIGJ1c2luZXNzIHBhcnRuZXJzCi1hbmQgdGhlIGxpa2UuIFdoaWxlIHRoaXMgbGljZW5zZSBpcyBpbnRlbmRlZCB0byBmYWNpbGl0YXRlIHRoZSBjb21tZXJjaWFsIHVzZQotb2YgdGhlIFByb2dyYW0sIHRoZSBDb250cmlidXRvciB3aG8gaW5jbHVkZXMgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsCi1wcm9kdWN0IG9mZmVyaW5nIHNob3VsZCBkbyBzbyBpbiBhIG1hbm5lciB3aGljaCBkb2VzIG5vdCBjcmVhdGUgcG90ZW50aWFsCi1saWFiaWxpdHkgZm9yIG90aGVyIENvbnRyaWJ1dG9ycy4gVGhlcmVmb3JlLCBpZiBhIENvbnRyaWJ1dG9yIGluY2x1ZGVzIHRoZQotUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgc3VjaCBDb250cmlidXRvciAoJnF1b3Q7Q29tbWVyY2lhbAotQ29udHJpYnV0b3ImcXVvdDspIGhlcmVieSBhZ3JlZXMgdG8gZGVmZW5kIGFuZCBpbmRlbW5pZnkgZXZlcnkgb3RoZXIKLUNvbnRyaWJ1dG9yICgmcXVvdDtJbmRlbW5pZmllZCBDb250cmlidXRvciZxdW90OykgYWdhaW5zdCBhbnkgbG9zc2VzLCBkYW1hZ2VzIGFuZAotY29zdHMgKGNvbGxlY3RpdmVseSAmcXVvdDtMb3NzZXMmcXVvdDspIGFyaXNpbmcgZnJvbSBjbGFpbXMsIGxhd3N1aXRzIGFuZCBvdGhlcgotbGVnYWwgYWN0aW9ucyBicm91Z2h0IGJ5IGEgdGhpcmQgcGFydHkgYWdhaW5zdCB0aGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgdG8KLXRoZSBleHRlbnQgY2F1c2VkIGJ5IHRoZSBhY3RzIG9yIG9taXNzaW9ucyBvZiBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4KLWNvbm5lY3Rpb24gd2l0aCBpdHMgZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0Ci1vZmZlcmluZy4gVGhlIG9ibGlnYXRpb25zIGluIHRoaXMgc2VjdGlvbiBkbyBub3QgYXBwbHkgdG8gYW55IGNsYWltcyBvciBMb3NzZXMKLXJlbGF0aW5nIHRvIGFueSBhY3R1YWwgb3IgYWxsZWdlZCBpbnRlbGxlY3R1YWwgcHJvcGVydHkgaW5mcmluZ2VtZW50LiBJbiBvcmRlcgotdG8gcXVhbGlmeSwgYW4gSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbXVzdDogYSkgcHJvbXB0bHkgbm90aWZ5IHRoZSBDb21tZXJjaWFsCi1Db250cmlidXRvciBpbiB3cml0aW5nIG9mIHN1Y2ggY2xhaW0sIGFuZCBiKSBhbGxvdyB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvcgotdG8gY29udHJvbCwgYW5kIGNvb3BlcmF0ZSB3aXRoIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluLCB0aGUgZGVmZW5zZSBhbmQKLWFueSByZWxhdGVkIHNldHRsZW1lbnQgbmVnb3RpYXRpb25zLiBUaGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbWF5IHBhcnRpY2lwYXRlCi1pbiBhbnkgc3VjaCBjbGFpbSBhdCBpdHMgb3duIGV4cGVuc2UuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Gb3IgZXhhbXBsZSwgYSBDb250cmlidXRvciBtaWdodCBpbmNsdWRlIHRoZQotUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgUHJvZHVjdCBYLiBUaGF0IENvbnRyaWJ1dG9yIGlzIHRoZW4gYQotQ29tbWVyY2lhbCBDb250cmlidXRvci4gSWYgdGhhdCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRoZW4gbWFrZXMgcGVyZm9ybWFuY2UKLWNsYWltcywgb3Igb2ZmZXJzIHdhcnJhbnRpZXMgcmVsYXRlZCB0byBQcm9kdWN0IFgsIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQKLXdhcnJhbnRpZXMgYXJlIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvcidzIHJlc3BvbnNpYmlsaXR5IGFsb25lLiBVbmRlciB0aGlzCi1zZWN0aW9uLCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB3b3VsZCBoYXZlIHRvIGRlZmVuZCBjbGFpbXMgYWdhaW5zdCB0aGUKLW90aGVyIENvbnRyaWJ1dG9ycyByZWxhdGVkIHRvIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcywgYW5kIGlmIGEKLWNvdXJ0IHJlcXVpcmVzIGFueSBvdGhlciBDb250cmlidXRvciB0byBwYXkgYW55IGRhbWFnZXMgYXMgYSByZXN1bHQsIHRoZQotQ29tbWVyY2lhbCBDb250cmlidXRvciBtdXN0IHBheSB0aG9zZSBkYW1hZ2VzLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+NS4gTk8gV0FSUkFOVFk8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTCi1BR1JFRU1FTlQsIFRIRSBQUk9HUkFNIElTIFBST1ZJREVEIE9OIEFOICZxdW90O0FTIElTJnF1b3Q7IEJBU0lTLCBXSVRIT1VUCi1XQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIEVJVEhFUiBFWFBSRVNTIE9SIElNUExJRUQgSU5DTFVESU5HLAotV0lUSE9VVCBMSU1JVEFUSU9OLCBBTlkgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIFRJVExFLCBOT04tSU5GUklOR0VNRU5ULAotTUVSQ0hBTlRBQklMSVRZIE9SIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBFYWNoIFJlY2lwaWVudCBpcyBzb2xlbHkKLXJlc3BvbnNpYmxlIGZvciBkZXRlcm1pbmluZyB0aGUgYXBwcm9wcmlhdGVuZXNzIG9mIHVzaW5nIGFuZCBkaXN0cmlidXRpbmcgdGhlCi1Qcm9ncmFtIGFuZCBhc3N1bWVzIGFsbCByaXNrcyBhc3NvY2lhdGVkIHdpdGggaXRzIGV4ZXJjaXNlIG9mIHJpZ2h0cyB1bmRlciB0aGlzCi1BZ3JlZW1lbnQgLCBpbmNsdWRpbmcgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSByaXNrcyBhbmQgY29zdHMgb2YgcHJvZ3JhbSBlcnJvcnMsCi1jb21wbGlhbmNlIHdpdGggYXBwbGljYWJsZSBsYXdzLCBkYW1hZ2UgdG8gb3IgbG9zcyBvZiBkYXRhLCBwcm9ncmFtcyBvcgotZXF1aXBtZW50LCBhbmQgdW5hdmFpbGFiaWxpdHkgb3IgaW50ZXJydXB0aW9uIG9mIG9wZXJhdGlvbnMuIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz42LiBESVNDTEFJTUVSIE9GIExJQUJJTElUWTwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMKLUFHUkVFTUVOVCwgTkVJVEhFUiBSRUNJUElFTlQgTk9SIEFOWSBDT05UUklCVVRPUlMgU0hBTEwgSEFWRSBBTlkgTElBQklMSVRZIEZPUgotQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0oSU5DTFVESU5HIFdJVEhPVVQgTElNSVRBVElPTiBMT1NUIFBST0ZJVFMpLCBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQotT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcKLU5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT1IgRElTVFJJQlVUSU9OIE9GCi1USEUgUFJPR1JBTSBPUiBUSEUgRVhFUkNJU0UgT0YgQU5ZIFJJR0hUUyBHUkFOVEVEIEhFUkVVTkRFUiwgRVZFTiBJRiBBRFZJU0VEIE9GCi1USEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0VTLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Ny4gR0VORVJBTDwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPklmIGFueSBwcm92aXNpb24gb2YgdGhpcyBBZ3JlZW1lbnQgaXMgaW52YWxpZAotb3IgdW5lbmZvcmNlYWJsZSB1bmRlciBhcHBsaWNhYmxlIGxhdywgaXQgc2hhbGwgbm90IGFmZmVjdCB0aGUgdmFsaWRpdHkgb3IKLWVuZm9yY2VhYmlsaXR5IG9mIHRoZSByZW1haW5kZXIgb2YgdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBhbmQgd2l0aG91dAotZnVydGhlciBhY3Rpb24gYnkgdGhlIHBhcnRpZXMgaGVyZXRvLCBzdWNoIHByb3Zpc2lvbiBzaGFsbCBiZSByZWZvcm1lZCB0byB0aGUKLW1pbmltdW0gZXh0ZW50IG5lY2Vzc2FyeSB0byBtYWtlIHN1Y2ggcHJvdmlzaW9uIHZhbGlkIGFuZCBlbmZvcmNlYWJsZS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPklmIFJlY2lwaWVudCBpbnN0aXR1dGVzIHBhdGVudCBsaXRpZ2F0aW9uCi1hZ2FpbnN0IGFueSBlbnRpdHkgKGluY2x1ZGluZyBhIGNyb3NzLWNsYWltIG9yIGNvdW50ZXJjbGFpbSBpbiBhIGxhd3N1aXQpCi1hbGxlZ2luZyB0aGF0IHRoZSBQcm9ncmFtIGl0c2VsZiAoZXhjbHVkaW5nIGNvbWJpbmF0aW9ucyBvZiB0aGUgUHJvZ3JhbSB3aXRoCi1vdGhlciBzb2Z0d2FyZSBvciBoYXJkd2FyZSkgaW5mcmluZ2VzIHN1Y2ggUmVjaXBpZW50J3MgcGF0ZW50KHMpLCB0aGVuIHN1Y2gKLVJlY2lwaWVudCdzIHJpZ2h0cyBncmFudGVkIHVuZGVyIFNlY3Rpb24gMihiKSBzaGFsbCB0ZXJtaW5hdGUgYXMgb2YgdGhlIGRhdGUKLXN1Y2ggbGl0aWdhdGlvbiBpcyBmaWxlZC4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkFsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQKLXNoYWxsIHRlcm1pbmF0ZSBpZiBpdCBmYWlscyB0byBjb21wbHkgd2l0aCBhbnkgb2YgdGhlIG1hdGVyaWFsIHRlcm1zIG9yCi1jb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50IGFuZCBkb2VzIG5vdCBjdXJlIHN1Y2ggZmFpbHVyZSBpbiBhIHJlYXNvbmFibGUKLXBlcmlvZCBvZiB0aW1lIGFmdGVyIGJlY29taW5nIGF3YXJlIG9mIHN1Y2ggbm9uY29tcGxpYW5jZS4gSWYgYWxsIFJlY2lwaWVudCdzCi1yaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgdGVybWluYXRlLCBSZWNpcGllbnQgYWdyZWVzIHRvIGNlYXNlIHVzZSBhbmQKLWRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBhcyBzb29uIGFzIHJlYXNvbmFibHkgcHJhY3RpY2FibGUuIEhvd2V2ZXIsCi1SZWNpcGllbnQncyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIEFncmVlbWVudCBhbmQgYW55IGxpY2Vuc2VzIGdyYW50ZWQgYnkKLVJlY2lwaWVudCByZWxhdGluZyB0byB0aGUgUHJvZ3JhbSBzaGFsbCBjb250aW51ZSBhbmQgc3Vydml2ZS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkV2ZXJ5b25lIGlzIHBlcm1pdHRlZCB0byBjb3B5IGFuZCBkaXN0cmlidXRlCi1jb3BpZXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGJ1dCBpbiBvcmRlciB0byBhdm9pZCBpbmNvbnNpc3RlbmN5IHRoZSBBZ3JlZW1lbnQgaXMKLWNvcHlyaWdodGVkIGFuZCBtYXkgb25seSBiZSBtb2RpZmllZCBpbiB0aGUgZm9sbG93aW5nIG1hbm5lci4gVGhlIEFncmVlbWVudAotU3Rld2FyZCByZXNlcnZlcyB0aGUgcmlnaHQgdG8gcHVibGlzaCBuZXcgdmVyc2lvbnMgKGluY2x1ZGluZyByZXZpc2lvbnMpIG9mCi10aGlzIEFncmVlbWVudCBmcm9tIHRpbWUgdG8gdGltZS4gTm8gb25lIG90aGVyIHRoYW4gdGhlIEFncmVlbWVudCBTdGV3YXJkIGhhcwotdGhlIHJpZ2h0IHRvIG1vZGlmeSB0aGlzIEFncmVlbWVudC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyB0aGUgaW5pdGlhbAotQWdyZWVtZW50IFN0ZXdhcmQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWF5IGFzc2lnbiB0aGUgcmVzcG9uc2liaWxpdHkgdG8KLXNlcnZlIGFzIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCB0byBhIHN1aXRhYmxlIHNlcGFyYXRlIGVudGl0eS4gRWFjaCBuZXcgdmVyc2lvbgotb2YgdGhlIEFncmVlbWVudCB3aWxsIGJlIGdpdmVuIGEgZGlzdGluZ3Vpc2hpbmcgdmVyc2lvbiBudW1iZXIuIFRoZSBQcm9ncmFtCi0oaW5jbHVkaW5nIENvbnRyaWJ1dGlvbnMpIG1heSBhbHdheXMgYmUgZGlzdHJpYnV0ZWQgc3ViamVjdCB0byB0aGUgdmVyc2lvbiBvZgotdGhlIEFncmVlbWVudCB1bmRlciB3aGljaCBpdCB3YXMgcmVjZWl2ZWQuIEluIGFkZGl0aW9uLCBhZnRlciBhIG5ldyB2ZXJzaW9uIG9mCi10aGUgQWdyZWVtZW50IGlzIHB1Ymxpc2hlZCwgQ29udHJpYnV0b3IgbWF5IGVsZWN0IHRvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0KLShpbmNsdWRpbmcgaXRzIENvbnRyaWJ1dGlvbnMpIHVuZGVyIHRoZSBuZXcgdmVyc2lvbi4gRXhjZXB0IGFzIGV4cHJlc3NseSBzdGF0ZWQKLWluIFNlY3Rpb25zIDIoYSkgYW5kIDIoYikgYWJvdmUsIFJlY2lwaWVudCByZWNlaXZlcyBubyByaWdodHMgb3IgbGljZW5zZXMgdG8KLXRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgb2YgYW55IENvbnRyaWJ1dG9yIHVuZGVyIHRoaXMgQWdyZWVtZW50LCB3aGV0aGVyCi1leHByZXNzbHksIGJ5IGltcGxpY2F0aW9uLCBlc3RvcHBlbCBvciBvdGhlcndpc2UuIEFsbCByaWdodHMgaW4gdGhlIFByb2dyYW0gbm90Ci1leHByZXNzbHkgZ3JhbnRlZCB1bmRlciB0aGlzIEFncmVlbWVudCBhcmUgcmVzZXJ2ZWQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5UaGlzIEFncmVlbWVudCBpcyBnb3Zlcm5lZCBieSB0aGUgbGF3cyBvZiB0aGUKLVN0YXRlIG9mIE5ldyBZb3JrIGFuZCB0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGxhd3Mgb2YgdGhlIFVuaXRlZCBTdGF0ZXMgb2YKLUFtZXJpY2EuIE5vIHBhcnR5IHRvIHRoaXMgQWdyZWVtZW50IHdpbGwgYnJpbmcgYSBsZWdhbCBhY3Rpb24gdW5kZXIgdGhpcwotQWdyZWVtZW50IG1vcmUgdGhhbiBvbmUgeWVhciBhZnRlciB0aGUgY2F1c2Ugb2YgYWN0aW9uIGFyb3NlLiBFYWNoIHBhcnR5IHdhaXZlcwotaXRzIHJpZ2h0cyB0byBhIGp1cnkgdHJpYWwgaW4gYW55IHJlc3VsdGluZyBsaXRpZ2F0aW9uLjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PCFbaWYgIXN1cHBvcnRFbXB0eVBhcmFzXT4mbmJzcDs8IVtlbmRpZl0+PG86cD48L286cD48L3A+Ci0KLTwvZGl2PgotCi08L2JvZHk+Ci0KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9saWNlbnNlLmh0bWwgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vbGljZW5zZS5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxNGIxZDUwLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9saWNlbnNlLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSw4MyArMCwwIEBACi08IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wLy9FTiI+Ci08aHRtbD4KLTxoZWFkPgotPG1ldGEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PWlzby04ODU5LTEiPgotPHRpdGxlPkVjbGlwc2Uub3JnIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC90aXRsZT4KLTwvaGVhZD4KLQotPGJvZHkgbGFuZz0iRU4tVVMiIGxpbms9Ymx1ZSB2bGluaz1wdXJwbGU+Ci08aDI+RWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9oMj4KLTxwPkp1bmUgMDYsIDIwMDc8L3A+Ci0KLTxoMz5Vc2FnZSBPZiBDb250ZW50PC9oMz4KLQotPHA+VEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUiBPVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTCi0gICAoQ09MTEVDVElWRUxZICZxdW90O0NPTlRFTlQmcXVvdDspLiAgVVNFIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORAotICAgQ09ORElUSU9OUyBPRiBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gIEJZIFVTSU5HIFRIRSBDT05URU5ULCBZT1UgQUdSRUUgVEhBVCBZT1VSIFVTRQotICAgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IKLSAgIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBJRiBZT1UgRE8gTk9UIEFHUkVFIFRPIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORAotICAgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVywgVEhFTiBZT1UgTUFZIE5PVCBVU0UgVEhFIENPTlRFTlQuPC9wPgotICAgCi08aDM+QXBwbGljYWJsZSBMaWNlbnNlczwvaDM+ICAgCi0gICAKLTxwPlVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAKLSAgICgmcXVvdDtFUEwmcXVvdDspLiAgQSBjb3B5IG9mIHRoZSBFUEwgaXMgcHJvdmlkZWQgd2l0aCB0aGlzIENvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT4uCi0gICBGb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgJnF1b3Q7UHJvZ3JhbSZxdW90OyB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9wPgotCi08cD5Db250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSwgZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZS5vcmcgQ1ZTIHJlcG9zaXRvcnkgKCZxdW90O1JlcG9zaXRvcnkmcXVvdDspIGluIENWUwotICAgbW9kdWxlcyAoJnF1b3Q7TW9kdWxlcyZxdW90OykgYW5kIG1hZGUgYXZhaWxhYmxlIGFzIGRvd25sb2FkYWJsZSBhcmNoaXZlcyAoJnF1b3Q7RG93bmxvYWRzJnF1b3Q7KS48L3A+Ci0gICAKLTx1bD4KLQk8bGk+Q29udGVudCBtYXkgYmUgc3RydWN0dXJlZCBhbmQgcGFja2FnZWQgaW50byBtb2R1bGVzIHRvIGZhY2lsaXRhdGUgZGVsaXZlcmluZywgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiAgVHlwaWNhbCBtb2R1bGVzIG1heSBpbmNsdWRlIHBsdWctaW5zICgmcXVvdDtQbHVnLWlucyZxdW90OyksIHBsdWctaW4gZnJhZ21lbnRzICgmcXVvdDtGcmFnbWVudHMmcXVvdDspLCBhbmQgZmVhdHVyZXMgKCZxdW90O0ZlYXR1cmVzJnF1b3Q7KS48L2xpPgotCTxsaT5FYWNoIFBsdWctaW4gb3IgRnJhZ21lbnQgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBvciBKQVIgKEphdmEmdHJhZGU7IEFSY2hpdmUpIGluIGEgZGlyZWN0b3J5IG5hbWVkICZxdW90O3BsdWdpbnMmcXVvdDsuPC9saT4KLQk8bGk+QSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuICBFYWNoIEZlYXR1cmUgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtmZWF0dXJlcyZxdW90Oy4gIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUueG1sJnF1b3Q7IG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMKLSAgICAgIGFuZC9vciBGcmFnbWVudHMgYXNzb2NpYXRlZCB3aXRoIHRoYXQgRmVhdHVyZS48L2xpPgotCTxsaT5GZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgmcXVvdDtJbmNsdWRlZCBGZWF0dXJlcyZxdW90OykuIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUueG1sJnF1b3Q7IG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy48L2xpPgotPC91bD4gICAKLSAKLTxwPlRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICZxdW90O2Fib3V0Lmh0bWwmcXVvdDsgKCZxdW90O0Fib3V0cyZxdW90OykuIFRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kCi1JbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICZxdW90O2xpY2Vuc2UuaHRtbCZxdW90OyAoJnF1b3Q7RmVhdHVyZSBMaWNlbnNlcyZxdW90OykuICBBYm91dHMgYW5kIEZlYXR1cmUgTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55IGRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZQotaW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyBsb2NhdGlvbnM6PC9wPgotCi08dWw+Ci0JPGxpPlRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeTwvbGk+Ci0JPGxpPlBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzPC9saT4KLQk8bGk+SW5zaWRlIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgcGFja2FnZWQgYXMgSkFSczwvbGk+Ci0JPGxpPlN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICZxdW90O3NyYyZxdW90OyBvZiBjZXJ0YWluIFBsdWctaW5zPC9saT4KLQk8bGk+RmVhdHVyZSBkaXJlY3RvcmllczwvbGk+Ci08L3VsPgotCQkKLTxwPk5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIGluc3RhbGxlZCB1c2luZyB0aGUgRWNsaXBzZSBVcGRhdGUgTWFuYWdlciwgeW91IG11c3QgYWdyZWUgdG8gYSBsaWNlbnNlICgmcXVvdDtGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlJnF1b3Q7KSBkdXJpbmcgdGhlCi1pbnN0YWxsYXRpb24gcHJvY2Vzcy4gIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zIEluY2x1ZGVkIEZlYXR1cmVzLCB0aGUgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBzaG91bGQgZWl0aGVyIHByb3ZpZGUgeW91IHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IKLWluZm9ybSB5b3Ugd2hlcmUgeW91IGNhbiBsb2NhdGUgdGhlbS4gIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSBmb3VuZCBpbiB0aGUgJnF1b3Q7bGljZW5zZSZxdW90OyBwcm9wZXJ0eSBvZiBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnByb3BlcnRpZXMmcXVvdDsgZm91bmQgd2l0aGluIGEgRmVhdHVyZS4KLVN1Y2ggQWJvdXRzLCBGZWF0dXJlIExpY2Vuc2VzLCBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgKG9yIHJlZmVyZW5jZXMgdG8gc3VjaCB0ZXJtcyBhbmQgY29uZGl0aW9ucykgdGhhdCBnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbgotdGhhdCBkaXJlY3RvcnkuPC9wPgotCi08cD5USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTLCBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSIFRPIFRIRSBFUEwgT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLiAgU09NRSBPRiBUSEVTRQotT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTo8L3A+Ci0KLTx1bD4KLQk8bGk+Q29tbW9uIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sPC9hPik8L2xpPgotCTxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAxLjEgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRSI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0U8L2E+KTwvbGk+Ci0JPGxpPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDIuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMCI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wPC9hPik8L2xpPgotCTxsaT5JQk0gUHVibGljIExpY2Vuc2UgMS4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2RldmVsb3BlcndvcmtzL29wZW5zb3VyY2UvbGljZW5zZTEwLmh0bWwiPmh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sPC9hPik8L2xpPgkKLQk8bGk+TWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwiPmh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sPC9hPik8L2xpPgotCTxsaT5Nb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sIj5odHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWw8L2E+KTwvbGk+Ci0gIAotICA8TEk+Q29tbW9uIERldmVsb3BtZW50IGFuZCBEaXN0cmlidXRpb24gTGljZW5zZSAoQ0RETCkgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sIj5odHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwpPC9BPgotICA8L0xJPgotPC9VTD4KLQotPHA+SVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgQ09ORElUSU9OUyBQUklPUiBUTyBVU0UgT0YgVEhFIENPTlRFTlQuICBJZiBubyBBYm91dCwgRmVhdHVyZSBMaWNlbnNlLCBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIGlzIHByb3ZpZGVkLCBwbGVhc2UKLWNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuPC9wPgotCi08aDM+Q3J5cHRvZ3JhcGh5PC9oMz4KLQotPHA+Q29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlIGN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSwgYW5kL29yIHJlLWV4cG9ydCB0bwotICAgYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkUgdXNpbmcgYW55IGVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsIHJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsCi0gICBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLjwvcD4KLSAgIAotPHNtYWxsPkphdmEgYW5kIGFsbCBKYXZhLWJhc2VkIHRyYWRlbWFya3MgYXJlIHRyYWRlbWFya3Mgb2YgU3VuIE1pY3Jvc3lzdGVtcywgSW5jLiBpbiB0aGUgVW5pdGVkIFN0YXRlcywgb3RoZXIgY291bnRyaWVzLCBvciBib3RoLjwvc21hbGw+ICAgCi08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vcGx1Z2luLnByb3BlcnRpZXMgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vcGx1Z2luLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQwZDVmMWMuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL3BsdWdpbi5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTMgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLgotIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCi0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAotIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAotIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlLiAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotCi1wbHVnaW5OYW1lID0gSmF2YSBQZXJzaXN0ZW5jZSBBUEkgVG9vbHMgLSBFY2xpcHNlTGluayBTdXBwb3J0Ci1wcm92aWRlck5hbWUgPSBFY2xpcHNlLm9yZwpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGlua19zZGsuZmVhdHVyZS8uY3ZzaWdub3JlIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGlua19zZGsuZmVhdHVyZS8uY3ZzaWdub3JlCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2MzY1ZDNkLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmtfc2RrLmZlYXR1cmUvLmN2c2lnbm9yZQorKysgL2Rldi9udWxsCkBAIC0xLDMgKzAsMCBAQAotZmVhdHVyZS50ZW1wLmZvbGRlcgotYnVpbGQueG1sCi1vcmcuZWNsaXBzZS5qcHRfc2RrLmZlYXR1cmVfMS4wLjEuKgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGlua19zZGsuZmVhdHVyZS8ucHJvamVjdCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmtfc2RrLmZlYXR1cmUvLnByb2plY3QKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDE1ZjkxNTcuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGlua19zZGsuZmVhdHVyZS8ucHJvamVjdAorKysgL2Rldi9udWxsCkBAIC0xLDE3ICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08cHJvamVjdERlc2NyaXB0aW9uPgotCTxuYW1lPm9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGlua19zZGsuZmVhdHVyZTwvbmFtZT4KLQk8Y29tbWVudD48L2NvbW1lbnQ+Ci0JPHByb2plY3RzPgotCTwvcHJvamVjdHM+Ci0JPGJ1aWxkU3BlYz4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5GZWF0dXJlQnVpbGRlcjwvbmFtZT4KLQkJCTxhcmd1bWVudHM+Ci0JCQk8L2FyZ3VtZW50cz4KLQkJPC9idWlsZENvbW1hbmQ+Ci0JPC9idWlsZFNwZWM+Ci0JPG5hdHVyZXM+Ci0JCTxuYXR1cmU+b3JnLmVjbGlwc2UucGRlLkZlYXR1cmVOYXR1cmU8L25hdHVyZT4KLQk8L25hdHVyZXM+Ci08L3Byb2plY3REZXNjcmlwdGlvbj4KZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmtfc2RrLmZlYXR1cmUvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGlua19zZGsuZmVhdHVyZS8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDZjYzdkNGIuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGlua19zZGsuZmVhdHVyZS8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMKKysrIC9kZXYvbnVsbApAQCAtMSwzICswLDAgQEAKLSNTdW4gTWF5IDI3IDE1OjA5OjU5IEVEVCAyMDA3Ci1lY2xpcHNlLnByZWZlcmVuY2VzLnZlcnNpb249MQotZW5jb2RpbmcvPHByb2plY3Q+PUlTTy04ODU5LTEKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmtfc2RrLmZlYXR1cmUvYnVpbGQucHJvcGVydGllcyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmtfc2RrLmZlYXR1cmUvYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYjQ3OWNjYi4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rX3Nkay5mZWF0dXJlL2J1aWxkLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSw3ICswLDAgQEAKLWJpbi5pbmNsdWRlcyA9IGZlYXR1cmUueG1sLFwKLSAgICAgICAgICAgICAgIGxpY2Vuc2UuaHRtbCxcCi0gICAgICAgICAgICAgICBmZWF0dXJlLnByb3BlcnRpZXMsXAotICAgICAgICAgICAgICAgZXBsLXYxMC5odG1sLFwKLSAgICAgICAgICAgICAgIGVjbGlwc2VfdXBkYXRlXzEyMC5qcGcKLQotZ2VuZXJhdGUuZmVhdHVyZUBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuZmVhdHVyZS5zb3VyY2U9b3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmtfc2RrLmZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmtfc2RrLmZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmZkZjcwOC4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rX3Nkay5mZWF0dXJlL2VjbGlwc2VfdXBkYXRlXzEyMC5qcGcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rX3Nkay5mZWF0dXJlL2VwbC12MTAuaHRtbCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmtfc2RrLmZlYXR1cmUvZXBsLXYxMC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlZDRiMTk2Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmtfc2RrLmZlYXR1cmUvZXBsLXYxMC5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsMzI4ICswLDAgQEAKLTxodG1sIHhtbG5zOm89InVybjpzY2hlbWFzLW1pY3Jvc29mdC1jb206b2ZmaWNlOm9mZmljZSIKLXhtbG5zOnc9InVybjpzY2hlbWFzLW1pY3Jvc29mdC1jb206b2ZmaWNlOndvcmQiCi14bWxucz0iaHR0cDovL3d3dy53My5vcmcvVFIvUkVDLWh0bWw0MCI+Ci0KLTxoZWFkPgotPG1ldGEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXdpbmRvd3MtMTI1MiI+Ci08bWV0YSBuYW1lPVByb2dJZCBjb250ZW50PVdvcmQuRG9jdW1lbnQ+Ci08bWV0YSBuYW1lPUdlbmVyYXRvciBjb250ZW50PSJNaWNyb3NvZnQgV29yZCA5Ij4KLTxtZXRhIG5hbWU9T3JpZ2luYXRvciBjb250ZW50PSJNaWNyb3NvZnQgV29yZCA5Ij4KLTxsaW5rIHJlbD1GaWxlLUxpc3QKLWhyZWY9Ii4vRWNsaXBzZSUyMEVQTCUyMDIwMDNfMTFfMTAlMjBGaW5hbF9maWxlcy9maWxlbGlzdC54bWwiPgotPHRpdGxlPkVjbGlwc2UgUHVibGljIExpY2Vuc2UgLSBWZXJzaW9uIDEuMDwvdGl0bGU+Ci08IS0tW2lmIGd0ZSBtc28gOV0+PHhtbD4KLSA8bzpEb2N1bWVudFByb3BlcnRpZXM+Ci0gIDxvOlJldmlzaW9uPjI8L286UmV2aXNpb24+Ci0gIDxvOlRvdGFsVGltZT4zPC9vOlRvdGFsVGltZT4KLSAgPG86Q3JlYXRlZD4yMDA0LTAzLTA1VDIzOjAzOjAwWjwvbzpDcmVhdGVkPgotICA8bzpMYXN0U2F2ZWQ+MjAwNC0wMy0wNVQyMzowMzowMFo8L286TGFzdFNhdmVkPgotICA8bzpQYWdlcz40PC9vOlBhZ2VzPgotICA8bzpXb3Jkcz4xNjI2PC9vOldvcmRzPgotICA8bzpDaGFyYWN0ZXJzPjkyNzA8L286Q2hhcmFjdGVycz4KLSAgIDxvOkxpbmVzPjc3PC9vOkxpbmVzPgotICA8bzpQYXJhZ3JhcGhzPjE4PC9vOlBhcmFncmFwaHM+Ci0gIDxvOkNoYXJhY3RlcnNXaXRoU3BhY2VzPjExMzg0PC9vOkNoYXJhY3RlcnNXaXRoU3BhY2VzPgotICA8bzpWZXJzaW9uPjkuNDQwMjwvbzpWZXJzaW9uPgotIDwvbzpEb2N1bWVudFByb3BlcnRpZXM+Ci08L3htbD48IVtlbmRpZl0tLT48IS0tW2lmIGd0ZSBtc28gOV0+PHhtbD4KLSA8dzpXb3JkRG9jdW1lbnQ+Ci0gIDx3OlRyYWNrUmV2aXNpb25zLz4KLSA8L3c6V29yZERvY3VtZW50PgotPC94bWw+PCFbZW5kaWZdLS0+Ci08c3R5bGU+Ci08IS0tCi0gLyogRm9udCBEZWZpbml0aW9ucyAqLwotQGZvbnQtZmFjZQotCXtmb250LWZhbWlseTpUYWhvbWE7Ci0JcGFub3NlLTE6MiAxMSA2IDQgMyA1IDQgNCAyIDQ7Ci0JbXNvLWZvbnQtY2hhcnNldDowOwotCW1zby1nZW5lcmljLWZvbnQtZmFtaWx5OnN3aXNzOwotCW1zby1mb250LXBpdGNoOnZhcmlhYmxlOwotCW1zby1mb250LXNpZ25hdHVyZTo1NTM2Nzk0OTUgLTIxNDc0ODM2NDggOCAwIDY2MDQ3IDA7fQotIC8qIFN0eWxlIERlZmluaXRpb25zICovCi1wLk1zb05vcm1hbCwgbGkuTXNvTm9ybWFsLCBkaXYuTXNvTm9ybWFsCi0Je21zby1zdHlsZS1wYXJlbnQ6IiI7Ci0JbWFyZ2luOjBpbjsKLQltYXJnaW4tYm90dG9tOi4wMDAxcHQ7Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZToxMi4wcHQ7Ci0JZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotcAotCXttYXJnaW4tcmlnaHQ6MGluOwotCW1zby1tYXJnaW4tdG9wLWFsdDphdXRvOwotCW1zby1tYXJnaW4tYm90dG9tLWFsdDphdXRvOwotCW1hcmdpbi1sZWZ0OjBpbjsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjEyLjBwdDsKLQlmb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1wLkJhbGxvb25UZXh0LCBsaS5CYWxsb29uVGV4dCwgZGl2LkJhbGxvb25UZXh0Ci0Je21zby1zdHlsZS1uYW1lOiJCYWxsb29uIFRleHQiOwotCW1hcmdpbjowaW47Ci0JbWFyZ2luLWJvdHRvbTouMDAwMXB0OwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6OC4wcHQ7Ci0JZm9udC1mYW1pbHk6VGFob21hOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLUBwYWdlIFNlY3Rpb24xCi0Je3NpemU6OC41aW4gMTEuMGluOwotCW1hcmdpbjoxLjBpbiAxLjI1aW4gMS4waW4gMS4yNWluOwotCW1zby1oZWFkZXItbWFyZ2luOi41aW47Ci0JbXNvLWZvb3Rlci1tYXJnaW46LjVpbjsKLQltc28tcGFwZXItc291cmNlOjA7fQotZGl2LlNlY3Rpb24xCi0Je3BhZ2U6U2VjdGlvbjE7fQotLS0+Ci08L3N0eWxlPgotPC9oZWFkPgotCi08Ym9keSBsYW5nPUVOLVVTIHN0eWxlPSd0YWItaW50ZXJ2YWw6LjVpbic+Ci0KLTxkaXYgY2xhc3M9U2VjdGlvbjE+Ci0KLTxwIGFsaWduPWNlbnRlciBzdHlsZT0ndGV4dC1hbGlnbjpjZW50ZXInPjxiPkVjbGlwc2UgUHVibGljIExpY2Vuc2UgLSB2IDEuMDwvYj4KLTwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPlRIRSBBQ0NPTVBBTllJTkcgUFJPR1JBTSBJUyBQUk9WSURFRCBVTkRFUgotVEhFIFRFUk1TIE9GIFRISVMgRUNMSVBTRSBQVUJMSUMgTElDRU5TRSAoJnF1b3Q7QUdSRUVNRU5UJnF1b3Q7KS4gQU5ZIFVTRSwKLVJFUFJPRFVDVElPTiBPUiBESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gQ09OU1RJVFVURVMgUkVDSVBJRU5UJ1MgQUNDRVBUQU5DRQotT0YgVEhJUyBBR1JFRU1FTlQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4xLiBERUZJTklUSU9OUzwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0NvbnRyaWJ1dGlvbiZxdW90OyBtZWFuczo8L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWluIHRoZSBjYXNlIG9mIHRoZSBpbml0aWFsIENvbnRyaWJ1dG9yLCB0aGUgaW5pdGlhbCBjb2RlIGFuZCBkb2N1bWVudGF0aW9uCi1kaXN0cmlidXRlZCB1bmRlciB0aGlzIEFncmVlbWVudCwgYW5kPGJyIGNsZWFyPWxlZnQ+Ci1iKSBpbiB0aGUgY2FzZSBvZiBlYWNoIHN1YnNlcXVlbnQgQ29udHJpYnV0b3I6PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aSkKLWNoYW5nZXMgdG8gdGhlIFByb2dyYW0sIGFuZDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpKQotYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtOzwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPndoZXJlCi1zdWNoIGNoYW5nZXMgYW5kL29yIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbSBvcmlnaW5hdGUgZnJvbSBhbmQgYXJlIGRpc3RyaWJ1dGVkCi1ieSB0aGF0IHBhcnRpY3VsYXIgQ29udHJpYnV0b3IuIEEgQ29udHJpYnV0aW9uICdvcmlnaW5hdGVzJyBmcm9tIGEgQ29udHJpYnV0b3IKLWlmIGl0IHdhcyBhZGRlZCB0byB0aGUgUHJvZ3JhbSBieSBzdWNoIENvbnRyaWJ1dG9yIGl0c2VsZiBvciBhbnlvbmUgYWN0aW5nIG9uCi1zdWNoIENvbnRyaWJ1dG9yJ3MgYmVoYWxmLiBDb250cmlidXRpb25zIGRvIG5vdCBpbmNsdWRlIGFkZGl0aW9ucyB0byB0aGUKLVByb2dyYW0gd2hpY2g6IChpKSBhcmUgc2VwYXJhdGUgbW9kdWxlcyBvZiBzb2Z0d2FyZSBkaXN0cmlidXRlZCBpbiBjb25qdW5jdGlvbgotd2l0aCB0aGUgUHJvZ3JhbSB1bmRlciB0aGVpciBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIGFuZCAoaWkpIGFyZSBub3QgZGVyaXZhdGl2ZQotd29ya3Mgb2YgdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtDb250cmlidXRvciZxdW90OyBtZWFucyBhbnkgcGVyc29uIG9yCi1lbnRpdHkgdGhhdCBkaXN0cmlidXRlcyB0aGUgUHJvZ3JhbS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0xpY2Vuc2VkIFBhdGVudHMgJnF1b3Q7IG1lYW4gcGF0ZW50Ci1jbGFpbXMgbGljZW5zYWJsZSBieSBhIENvbnRyaWJ1dG9yIHdoaWNoIGFyZSBuZWNlc3NhcmlseSBpbmZyaW5nZWQgYnkgdGhlIHVzZQotb3Igc2FsZSBvZiBpdHMgQ29udHJpYnV0aW9uIGFsb25lIG9yIHdoZW4gY29tYmluZWQgd2l0aCB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O1Byb2dyYW0mcXVvdDsgbWVhbnMgdGhlIENvbnRyaWJ1dGlvbnMKLWRpc3RyaWJ1dGVkIGluIGFjY29yZGFuY2Ugd2l0aCB0aGlzIEFncmVlbWVudC48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O1JlY2lwaWVudCZxdW90OyBtZWFucyBhbnlvbmUgd2hvCi1yZWNlaXZlcyB0aGUgUHJvZ3JhbSB1bmRlciB0aGlzIEFncmVlbWVudCwgaW5jbHVkaW5nIGFsbCBDb250cmlidXRvcnMuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4yLiBHUkFOVCBPRiBSSUdIVFM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1TdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudAotYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsIHJveWFsdHktZnJlZSBjb3B5cmlnaHQgbGljZW5zZSB0bzxzcGFuCi1zdHlsZT0nY29sb3I6cmVkJz4gPC9zcGFuPnJlcHJvZHVjZSwgcHJlcGFyZSBkZXJpdmF0aXZlIHdvcmtzIG9mLCBwdWJsaWNseQotZGlzcGxheSwgcHVibGljbHkgcGVyZm9ybSwgZGlzdHJpYnV0ZSBhbmQgc3VibGljZW5zZSB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2gKLUNvbnRyaWJ1dG9yLCBpZiBhbnksIGFuZCBzdWNoIGRlcml2YXRpdmUgd29ya3MsIGluIHNvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZQotZm9ybS48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKQotU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cwotUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLDxzcGFuIHN0eWxlPSdjb2xvcjpncmVlbic+IDwvc3Bhbj5yb3lhbHR5LWZyZWUKLXBhdGVudCBsaWNlbnNlIHVuZGVyIExpY2Vuc2VkIFBhdGVudHMgdG8gbWFrZSwgdXNlLCBzZWxsLCBvZmZlciB0byBzZWxsLCBpbXBvcnQKLWFuZCBvdGhlcndpc2UgdHJhbnNmZXIgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoIENvbnRyaWJ1dG9yLCBpZiBhbnksIGluIHNvdXJjZQotY29kZSBhbmQgb2JqZWN0IGNvZGUgZm9ybS4gVGhpcyBwYXRlbnQgbGljZW5zZSBzaGFsbCBhcHBseSB0byB0aGUgY29tYmluYXRpb24KLW9mIHRoZSBDb250cmlidXRpb24gYW5kIHRoZSBQcm9ncmFtIGlmLCBhdCB0aGUgdGltZSB0aGUgQ29udHJpYnV0aW9uIGlzIGFkZGVkCi1ieSB0aGUgQ29udHJpYnV0b3IsIHN1Y2ggYWRkaXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBjYXVzZXMgc3VjaCBjb21iaW5hdGlvbgotdG8gYmUgY292ZXJlZCBieSB0aGUgTGljZW5zZWQgUGF0ZW50cy4gVGhlIHBhdGVudCBsaWNlbnNlIHNoYWxsIG5vdCBhcHBseSB0bwotYW55IG90aGVyIGNvbWJpbmF0aW9ucyB3aGljaCBpbmNsdWRlIHRoZSBDb250cmlidXRpb24uIE5vIGhhcmR3YXJlIHBlciBzZSBpcwotbGljZW5zZWQgaGVyZXVuZGVyLiA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5jKQotUmVjaXBpZW50IHVuZGVyc3RhbmRzIHRoYXQgYWx0aG91Z2ggZWFjaCBDb250cmlidXRvciBncmFudHMgdGhlIGxpY2Vuc2VzIHRvIGl0cwotQ29udHJpYnV0aW9ucyBzZXQgZm9ydGggaGVyZWluLCBubyBhc3N1cmFuY2VzIGFyZSBwcm92aWRlZCBieSBhbnkgQ29udHJpYnV0b3IKLXRoYXQgdGhlIFByb2dyYW0gZG9lcyBub3QgaW5mcmluZ2UgdGhlIHBhdGVudCBvciBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkKLXJpZ2h0cyBvZiBhbnkgb3RoZXIgZW50aXR5LiBFYWNoIENvbnRyaWJ1dG9yIGRpc2NsYWltcyBhbnkgbGlhYmlsaXR5IHRvIFJlY2lwaWVudAotZm9yIGNsYWltcyBicm91Z2h0IGJ5IGFueSBvdGhlciBlbnRpdHkgYmFzZWQgb24gaW5mcmluZ2VtZW50IG9mIGludGVsbGVjdHVhbAotcHJvcGVydHkgcmlnaHRzIG9yIG90aGVyd2lzZS4gQXMgYSBjb25kaXRpb24gdG8gZXhlcmNpc2luZyB0aGUgcmlnaHRzIGFuZAotbGljZW5zZXMgZ3JhbnRlZCBoZXJldW5kZXIsIGVhY2ggUmVjaXBpZW50IGhlcmVieSBhc3N1bWVzIHNvbGUgcmVzcG9uc2liaWxpdHkKLXRvIHNlY3VyZSBhbnkgb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5IHJpZ2h0cyBuZWVkZWQsIGlmIGFueS4gRm9yIGV4YW1wbGUsCi1pZiBhIHRoaXJkIHBhcnR5IHBhdGVudCBsaWNlbnNlIGlzIHJlcXVpcmVkIHRvIGFsbG93IFJlY2lwaWVudCB0byBkaXN0cmlidXRlCi10aGUgUHJvZ3JhbSwgaXQgaXMgUmVjaXBpZW50J3MgcmVzcG9uc2liaWxpdHkgdG8gYWNxdWlyZSB0aGF0IGxpY2Vuc2UgYmVmb3JlCi1kaXN0cmlidXRpbmcgdGhlIFByb2dyYW0uPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+ZCkKLUVhY2ggQ29udHJpYnV0b3IgcmVwcmVzZW50cyB0aGF0IHRvIGl0cyBrbm93bGVkZ2UgaXQgaGFzIHN1ZmZpY2llbnQgY29weXJpZ2h0Ci1yaWdodHMgaW4gaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCB0byBncmFudCB0aGUgY29weXJpZ2h0IGxpY2Vuc2Ugc2V0IGZvcnRoIGluCi10aGlzIEFncmVlbWVudC4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjMuIFJFUVVJUkVNRU5UUzwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkEgQ29udHJpYnV0b3IgbWF5IGNob29zZSB0byBkaXN0cmlidXRlIHRoZQotUHJvZ3JhbSBpbiBvYmplY3QgY29kZSBmb3JtIHVuZGVyIGl0cyBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIHByb3ZpZGVkIHRoYXQ6PC9zcGFuPgotPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaXQgY29tcGxpZXMgd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQ7IGFuZDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpCi1pdHMgbGljZW5zZSBhZ3JlZW1lbnQ6PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aSkKLWVmZmVjdGl2ZWx5IGRpc2NsYWltcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgd2FycmFudGllcyBhbmQKLWNvbmRpdGlvbnMsIGV4cHJlc3MgYW5kIGltcGxpZWQsIGluY2x1ZGluZyB3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgdGl0bGUKLWFuZCBub24taW5mcmluZ2VtZW50LCBhbmQgaW1wbGllZCB3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgbWVyY2hhbnRhYmlsaXR5Ci1hbmQgZml0bmVzcyBmb3IgYSBwYXJ0aWN1bGFyIHB1cnBvc2U7IDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpKQotZWZmZWN0aXZlbHkgZXhjbHVkZXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIGxpYWJpbGl0eSBmb3IgZGFtYWdlcywKLWluY2x1ZGluZyBkaXJlY3QsIGluZGlyZWN0LCBzcGVjaWFsLCBpbmNpZGVudGFsIGFuZCBjb25zZXF1ZW50aWFsIGRhbWFnZXMsIHN1Y2gKLWFzIGxvc3QgcHJvZml0czsgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWlpKQotc3RhdGVzIHRoYXQgYW55IHByb3Zpc2lvbnMgd2hpY2ggZGlmZmVyIGZyb20gdGhpcyBBZ3JlZW1lbnQgYXJlIG9mZmVyZWQgYnkgdGhhdAotQ29udHJpYnV0b3IgYWxvbmUgYW5kIG5vdCBieSBhbnkgb3RoZXIgcGFydHk7IGFuZDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPml2KQotc3RhdGVzIHRoYXQgc291cmNlIGNvZGUgZm9yIHRoZSBQcm9ncmFtIGlzIGF2YWlsYWJsZSBmcm9tIHN1Y2ggQ29udHJpYnV0b3IsIGFuZAotaW5mb3JtcyBsaWNlbnNlZXMgaG93IHRvIG9idGFpbiBpdCBpbiBhIHJlYXNvbmFibGUgbWFubmVyIG9uIG9yIHRocm91Z2ggYQotbWVkaXVtIGN1c3RvbWFyaWx5IHVzZWQgZm9yIHNvZnR3YXJlIGV4Y2hhbmdlLjxzcGFuIHN0eWxlPSdjb2xvcjpibHVlJz4gPC9zcGFuPjwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5XaGVuIHRoZSBQcm9ncmFtIGlzIG1hZGUgYXZhaWxhYmxlIGluIHNvdXJjZQotY29kZSBmb3JtOjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaXQgbXVzdCBiZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGlzIEFncmVlbWVudDsgYW5kIDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpIGEKLWNvcHkgb2YgdGhpcyBBZ3JlZW1lbnQgbXVzdCBiZSBpbmNsdWRlZCB3aXRoIGVhY2ggY29weSBvZiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkNvbnRyaWJ1dG9ycyBtYXkgbm90IHJlbW92ZSBvciBhbHRlciBhbnkKLWNvcHlyaWdodCBub3RpY2VzIGNvbnRhaW5lZCB3aXRoaW4gdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FYWNoIENvbnRyaWJ1dG9yIG11c3QgaWRlbnRpZnkgaXRzZWxmIGFzIHRoZQotb3JpZ2luYXRvciBvZiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIGluIGEgbWFubmVyIHRoYXQgcmVhc29uYWJseSBhbGxvd3MKLXN1YnNlcXVlbnQgUmVjaXBpZW50cyB0byBpZGVudGlmeSB0aGUgb3JpZ2luYXRvciBvZiB0aGUgQ29udHJpYnV0aW9uLiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+NC4gQ09NTUVSQ0lBTCBESVNUUklCVVRJT048L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Db21tZXJjaWFsIGRpc3RyaWJ1dG9ycyBvZiBzb2Z0d2FyZSBtYXkKLWFjY2VwdCBjZXJ0YWluIHJlc3BvbnNpYmlsaXRpZXMgd2l0aCByZXNwZWN0IHRvIGVuZCB1c2VycywgYnVzaW5lc3MgcGFydG5lcnMKLWFuZCB0aGUgbGlrZS4gV2hpbGUgdGhpcyBsaWNlbnNlIGlzIGludGVuZGVkIHRvIGZhY2lsaXRhdGUgdGhlIGNvbW1lcmNpYWwgdXNlCi1vZiB0aGUgUHJvZ3JhbSwgdGhlIENvbnRyaWJ1dG9yIHdobyBpbmNsdWRlcyB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwKLXByb2R1Y3Qgb2ZmZXJpbmcgc2hvdWxkIGRvIHNvIGluIGEgbWFubmVyIHdoaWNoIGRvZXMgbm90IGNyZWF0ZSBwb3RlbnRpYWwKLWxpYWJpbGl0eSBmb3Igb3RoZXIgQ29udHJpYnV0b3JzLiBUaGVyZWZvcmUsIGlmIGEgQ29udHJpYnV0b3IgaW5jbHVkZXMgdGhlCi1Qcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBzdWNoIENvbnRyaWJ1dG9yICgmcXVvdDtDb21tZXJjaWFsCi1Db250cmlidXRvciZxdW90OykgaGVyZWJ5IGFncmVlcyB0byBkZWZlbmQgYW5kIGluZGVtbmlmeSBldmVyeSBvdGhlcgotQ29udHJpYnV0b3IgKCZxdW90O0luZGVtbmlmaWVkIENvbnRyaWJ1dG9yJnF1b3Q7KSBhZ2FpbnN0IGFueSBsb3NzZXMsIGRhbWFnZXMgYW5kCi1jb3N0cyAoY29sbGVjdGl2ZWx5ICZxdW90O0xvc3NlcyZxdW90OykgYXJpc2luZyBmcm9tIGNsYWltcywgbGF3c3VpdHMgYW5kIG90aGVyCi1sZWdhbCBhY3Rpb25zIGJyb3VnaHQgYnkgYSB0aGlyZCBwYXJ0eSBhZ2FpbnN0IHRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciB0bwotdGhlIGV4dGVudCBjYXVzZWQgYnkgdGhlIGFjdHMgb3Igb21pc3Npb25zIG9mIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvciBpbgotY29ubmVjdGlvbiB3aXRoIGl0cyBkaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3QKLW9mZmVyaW5nLiBUaGUgb2JsaWdhdGlvbnMgaW4gdGhpcyBzZWN0aW9uIGRvIG5vdCBhcHBseSB0byBhbnkgY2xhaW1zIG9yIExvc3NlcwotcmVsYXRpbmcgdG8gYW55IGFjdHVhbCBvciBhbGxlZ2VkIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBpbmZyaW5nZW1lbnQuIEluIG9yZGVyCi10byBxdWFsaWZ5LCBhbiBJbmRlbW5pZmllZCBDb250cmlidXRvciBtdXN0OiBhKSBwcm9tcHRseSBub3RpZnkgdGhlIENvbW1lcmNpYWwKLUNvbnRyaWJ1dG9yIGluIHdyaXRpbmcgb2Ygc3VjaCBjbGFpbSwgYW5kIGIpIGFsbG93IHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yCi10byBjb250cm9sLCBhbmQgY29vcGVyYXRlIHdpdGggdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4sIHRoZSBkZWZlbnNlIGFuZAotYW55IHJlbGF0ZWQgc2V0dGxlbWVudCBuZWdvdGlhdGlvbnMuIFRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciBtYXkgcGFydGljaXBhdGUKLWluIGFueSBzdWNoIGNsYWltIGF0IGl0cyBvd24gZXhwZW5zZS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkZvciBleGFtcGxlLCBhIENvbnRyaWJ1dG9yIG1pZ2h0IGluY2x1ZGUgdGhlCi1Qcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBQcm9kdWN0IFguIFRoYXQgQ29udHJpYnV0b3IgaXMgdGhlbiBhCi1Db21tZXJjaWFsIENvbnRyaWJ1dG9yLiBJZiB0aGF0IENvbW1lcmNpYWwgQ29udHJpYnV0b3IgdGhlbiBtYWtlcyBwZXJmb3JtYW5jZQotY2xhaW1zLCBvciBvZmZlcnMgd2FycmFudGllcyByZWxhdGVkIHRvIFByb2R1Y3QgWCwgdGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZAotd2FycmFudGllcyBhcmUgc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yJ3MgcmVzcG9uc2liaWxpdHkgYWxvbmUuIFVuZGVyIHRoaXMKLXNlY3Rpb24sIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHdvdWxkIGhhdmUgdG8gZGVmZW5kIGNsYWltcyBhZ2FpbnN0IHRoZQotb3RoZXIgQ29udHJpYnV0b3JzIHJlbGF0ZWQgdG8gdGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZCB3YXJyYW50aWVzLCBhbmQgaWYgYQotY291cnQgcmVxdWlyZXMgYW55IG90aGVyIENvbnRyaWJ1dG9yIHRvIHBheSBhbnkgZGFtYWdlcyBhcyBhIHJlc3VsdCwgdGhlCi1Db21tZXJjaWFsIENvbnRyaWJ1dG9yIG11c3QgcGF5IHRob3NlIGRhbWFnZXMuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz41LiBOTyBXQVJSQU5UWTwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMKLUFHUkVFTUVOVCwgVEhFIFBST0dSQU0gSVMgUFJPVklERUQgT04gQU4gJnF1b3Q7QVMgSVMmcXVvdDsgQkFTSVMsIFdJVEhPVVQKLVdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgRUlUSEVSIEVYUFJFU1MgT1IgSU1QTElFRCBJTkNMVURJTkcsCi1XSVRIT1VUIExJTUlUQVRJT04sIEFOWSBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgVElUTEUsIE5PTi1JTkZSSU5HRU1FTlQsCi1NRVJDSEFOVEFCSUxJVFkgT1IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIEVhY2ggUmVjaXBpZW50IGlzIHNvbGVseQotcmVzcG9uc2libGUgZm9yIGRldGVybWluaW5nIHRoZSBhcHByb3ByaWF0ZW5lc3Mgb2YgdXNpbmcgYW5kIGRpc3RyaWJ1dGluZyB0aGUKLVByb2dyYW0gYW5kIGFzc3VtZXMgYWxsIHJpc2tzIGFzc29jaWF0ZWQgd2l0aCBpdHMgZXhlcmNpc2Ugb2YgcmlnaHRzIHVuZGVyIHRoaXMKLUFncmVlbWVudCAsIGluY2x1ZGluZyBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIHJpc2tzIGFuZCBjb3N0cyBvZiBwcm9ncmFtIGVycm9ycywKLWNvbXBsaWFuY2Ugd2l0aCBhcHBsaWNhYmxlIGxhd3MsIGRhbWFnZSB0byBvciBsb3NzIG9mIGRhdGEsIHByb2dyYW1zIG9yCi1lcXVpcG1lbnQsIGFuZCB1bmF2YWlsYWJpbGl0eSBvciBpbnRlcnJ1cHRpb24gb2Ygb3BlcmF0aW9ucy4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjYuIERJU0NMQUlNRVIgT0YgTElBQklMSVRZPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUwotQUdSRUVNRU5ULCBORUlUSEVSIFJFQ0lQSUVOVCBOT1IgQU5ZIENPTlRSSUJVVE9SUyBTSEFMTCBIQVZFIEFOWSBMSUFCSUxJVFkgRk9SCi1BTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLShJTkNMVURJTkcgV0lUSE9VVCBMSU1JVEFUSU9OIExPU1QgUFJPRklUUyksIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCi1PRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORwotTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPUiBESVNUUklCVVRJT04gT0YKLVRIRSBQUk9HUkFNIE9SIFRIRSBFWEVSQ0lTRSBPRiBBTlkgUklHSFRTIEdSQU5URUQgSEVSRVVOREVSLCBFVkVOIElGIEFEVklTRUQgT0YKLVRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRVMuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz43LiBHRU5FUkFMPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+SWYgYW55IHByb3Zpc2lvbiBvZiB0aGlzIEFncmVlbWVudCBpcyBpbnZhbGlkCi1vciB1bmVuZm9yY2VhYmxlIHVuZGVyIGFwcGxpY2FibGUgbGF3LCBpdCBzaGFsbCBub3QgYWZmZWN0IHRoZSB2YWxpZGl0eSBvcgotZW5mb3JjZWFiaWxpdHkgb2YgdGhlIHJlbWFpbmRlciBvZiB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGFuZCB3aXRob3V0Ci1mdXJ0aGVyIGFjdGlvbiBieSB0aGUgcGFydGllcyBoZXJldG8sIHN1Y2ggcHJvdmlzaW9uIHNoYWxsIGJlIHJlZm9ybWVkIHRvIHRoZQotbWluaW11bSBleHRlbnQgbmVjZXNzYXJ5IHRvIG1ha2Ugc3VjaCBwcm92aXNpb24gdmFsaWQgYW5kIGVuZm9yY2VhYmxlLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+SWYgUmVjaXBpZW50IGluc3RpdHV0ZXMgcGF0ZW50IGxpdGlnYXRpb24KLWFnYWluc3QgYW55IGVudGl0eSAoaW5jbHVkaW5nIGEgY3Jvc3MtY2xhaW0gb3IgY291bnRlcmNsYWltIGluIGEgbGF3c3VpdCkKLWFsbGVnaW5nIHRoYXQgdGhlIFByb2dyYW0gaXRzZWxmIChleGNsdWRpbmcgY29tYmluYXRpb25zIG9mIHRoZSBQcm9ncmFtIHdpdGgKLW90aGVyIHNvZnR3YXJlIG9yIGhhcmR3YXJlKSBpbmZyaW5nZXMgc3VjaCBSZWNpcGllbnQncyBwYXRlbnQocyksIHRoZW4gc3VjaAotUmVjaXBpZW50J3MgcmlnaHRzIGdyYW50ZWQgdW5kZXIgU2VjdGlvbiAyKGIpIHNoYWxsIHRlcm1pbmF0ZSBhcyBvZiB0aGUgZGF0ZQotc3VjaCBsaXRpZ2F0aW9uIGlzIGZpbGVkLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+QWxsIFJlY2lwaWVudCdzIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudAotc2hhbGwgdGVybWluYXRlIGlmIGl0IGZhaWxzIHRvIGNvbXBseSB3aXRoIGFueSBvZiB0aGUgbWF0ZXJpYWwgdGVybXMgb3IKLWNvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQgYW5kIGRvZXMgbm90IGN1cmUgc3VjaCBmYWlsdXJlIGluIGEgcmVhc29uYWJsZQotcGVyaW9kIG9mIHRpbWUgYWZ0ZXIgYmVjb21pbmcgYXdhcmUgb2Ygc3VjaCBub25jb21wbGlhbmNlLiBJZiBhbGwgUmVjaXBpZW50J3MKLXJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCB0ZXJtaW5hdGUsIFJlY2lwaWVudCBhZ3JlZXMgdG8gY2Vhc2UgdXNlIGFuZAotZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGFzIHNvb24gYXMgcmVhc29uYWJseSBwcmFjdGljYWJsZS4gSG93ZXZlciwKLVJlY2lwaWVudCdzIG9ibGlnYXRpb25zIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFuZCBhbnkgbGljZW5zZXMgZ3JhbnRlZCBieQotUmVjaXBpZW50IHJlbGF0aW5nIHRvIHRoZSBQcm9ncmFtIHNoYWxsIGNvbnRpbnVlIGFuZCBzdXJ2aXZlLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RXZlcnlvbmUgaXMgcGVybWl0dGVkIHRvIGNvcHkgYW5kIGRpc3RyaWJ1dGUKLWNvcGllcyBvZiB0aGlzIEFncmVlbWVudCwgYnV0IGluIG9yZGVyIHRvIGF2b2lkIGluY29uc2lzdGVuY3kgdGhlIEFncmVlbWVudCBpcwotY29weXJpZ2h0ZWQgYW5kIG1heSBvbmx5IGJlIG1vZGlmaWVkIGluIHRoZSBmb2xsb3dpbmcgbWFubmVyLiBUaGUgQWdyZWVtZW50Ci1TdGV3YXJkIHJlc2VydmVzIHRoZSByaWdodCB0byBwdWJsaXNoIG5ldyB2ZXJzaW9ucyAoaW5jbHVkaW5nIHJldmlzaW9ucykgb2YKLXRoaXMgQWdyZWVtZW50IGZyb20gdGltZSB0byB0aW1lLiBObyBvbmUgb3RoZXIgdGhhbiB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgaGFzCi10aGUgcmlnaHQgdG8gbW9kaWZ5IHRoaXMgQWdyZWVtZW50LiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIHRoZSBpbml0aWFsCi1BZ3JlZW1lbnQgU3Rld2FyZC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYXkgYXNzaWduIHRoZSByZXNwb25zaWJpbGl0eSB0bwotc2VydmUgYXMgdGhlIEFncmVlbWVudCBTdGV3YXJkIHRvIGEgc3VpdGFibGUgc2VwYXJhdGUgZW50aXR5LiBFYWNoIG5ldyB2ZXJzaW9uCi1vZiB0aGUgQWdyZWVtZW50IHdpbGwgYmUgZ2l2ZW4gYSBkaXN0aW5ndWlzaGluZyB2ZXJzaW9uIG51bWJlci4gVGhlIFByb2dyYW0KLShpbmNsdWRpbmcgQ29udHJpYnV0aW9ucykgbWF5IGFsd2F5cyBiZSBkaXN0cmlidXRlZCBzdWJqZWN0IHRvIHRoZSB2ZXJzaW9uIG9mCi10aGUgQWdyZWVtZW50IHVuZGVyIHdoaWNoIGl0IHdhcyByZWNlaXZlZC4gSW4gYWRkaXRpb24sIGFmdGVyIGEgbmV3IHZlcnNpb24gb2YKLXRoZSBBZ3JlZW1lbnQgaXMgcHVibGlzaGVkLCBDb250cmlidXRvciBtYXkgZWxlY3QgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbQotKGluY2x1ZGluZyBpdHMgQ29udHJpYnV0aW9ucykgdW5kZXIgdGhlIG5ldyB2ZXJzaW9uLiBFeGNlcHQgYXMgZXhwcmVzc2x5IHN0YXRlZAotaW4gU2VjdGlvbnMgMihhKSBhbmQgMihiKSBhYm92ZSwgUmVjaXBpZW50IHJlY2VpdmVzIG5vIHJpZ2h0cyBvciBsaWNlbnNlcyB0bwotdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBvZiBhbnkgQ29udHJpYnV0b3IgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIHdoZXRoZXIKLWV4cHJlc3NseSwgYnkgaW1wbGljYXRpb24sIGVzdG9wcGVsIG9yIG90aGVyd2lzZS4gQWxsIHJpZ2h0cyBpbiB0aGUgUHJvZ3JhbSBub3QKLWV4cHJlc3NseSBncmFudGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFyZSByZXNlcnZlZC48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPlRoaXMgQWdyZWVtZW50IGlzIGdvdmVybmVkIGJ5IHRoZSBsYXdzIG9mIHRoZQotU3RhdGUgb2YgTmV3IFlvcmsgYW5kIHRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgbGF3cyBvZiB0aGUgVW5pdGVkIFN0YXRlcyBvZgotQW1lcmljYS4gTm8gcGFydHkgdG8gdGhpcyBBZ3JlZW1lbnQgd2lsbCBicmluZyBhIGxlZ2FsIGFjdGlvbiB1bmRlciB0aGlzCi1BZ3JlZW1lbnQgbW9yZSB0aGFuIG9uZSB5ZWFyIGFmdGVyIHRoZSBjYXVzZSBvZiBhY3Rpb24gYXJvc2UuIEVhY2ggcGFydHkgd2FpdmVzCi1pdHMgcmlnaHRzIHRvIGEganVyeSB0cmlhbCBpbiBhbnkgcmVzdWx0aW5nIGxpdGlnYXRpb24uPC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48IVtpZiAhc3VwcG9ydEVtcHR5UGFyYXNdPiZuYnNwOzwhW2VuZGlmXT48bzpwPjwvbzpwPjwvcD4KLQotPC9kaXY+Ci0KLTwvYm9keT4KLQotPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmtfc2RrLmZlYXR1cmUvZmVhdHVyZS5wcm9wZXJ0aWVzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGlua19zZGsuZmVhdHVyZS9mZWF0dXJlLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGU4ZDQ3ZDcuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGlua19zZGsuZmVhdHVyZS9mZWF0dXJlLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwxNDAgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDggT3JhY2xlLgotIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCi0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAotIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAotIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlLiAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotCi0jICJmZWF0dXJlTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBmZWF0dXJlCi1mZWF0dXJlTmFtZT1KYXZhIFBlcnNpc3RlbmNlIEFQSSBUb29scyAtIEVjbGlwc2VMaW5rIFN1cHBvcnQgU0RLIChPcHRpb25hbCkKLQotIyAicHJvdmlkZXJOYW1lIiBwcm9wZXJ0eSAtIG5hbWUgb2YgdGhlIGNvbXBhbnkgdGhhdCBwcm92aWRlcyB0aGUgZmVhdHVyZQotcHJvdmlkZXJOYW1lPUVjbGlwc2Uub3JnCi0KLSMgInVwZGF0ZVNpdGVOYW1lIiBwcm9wZXJ0eSAtIGxhYmVsIGZvciB0aGUgdXBkYXRlIHNpdGUKLXVwZGF0ZVNpdGVOYW1lPVRoZSBFY2xpcHNlIFdlYiBUb29scyBQbGF0Zm9ybSAoV1RQKSBQcm9qZWN0IHVwZGF0ZSBzaXRlCi0KLSMgImRlc2NyaXB0aW9uIiBwcm9wZXJ0eSAtIGRlc2NyaXB0aW9uIG9mIHRoZSBmZWF0dXJlCi1kZXNjcmlwdGlvbj1Tb3VyY2UgY29kZSB6aXBzIGZvciBKUEEgRWNsaXBzZUxpbmsgU3VwcG9ydAotCi0jICJjb3B5cmlnaHQiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIENvcHlyaWdodCIKLWNvcHlyaWdodD1cCi1Db3B5cmlnaHQgKGMpIDIwMDYtMDggT3JhY2xlIENvcnBvcmF0aW9uLlxuXAotQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFsc1xuXAotYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wXG5cCi13aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdFxuXAotaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWxcblwKLVxuXAotQ29udHJpYnV0b3JzOlxuXAotICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvblxuCi0jIyMjIyMjIyMjIyMjIyMjIGVuZCBvZiBjb3B5cmlnaHQgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0KLSMgImxpY2Vuc2VVUkwiIHByb3BlcnR5IC0gVVJMIG9mIHRoZSAiRmVhdHVyZSBMaWNlbnNlIgotIyBkbyBub3QgdHJhbnNsYXRlIHZhbHVlIC0ganVzdCBjaGFuZ2UgdG8gcG9pbnQgdG8gYSBsb2NhbGUtc3BlY2lmaWMgSFRNTCBwYWdlCi1saWNlbnNlVVJMPWxpY2Vuc2UuaHRtbAotCi0jICJsaWNlbnNlIiBwcm9wZXJ0eSAtIHRleHQgb2YgdGhlICJGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIgotIyBzaG91bGQgYmUgcGxhaW4gdGV4dCB2ZXJzaW9uIG9mIGxpY2Vuc2UgYWdyZWVtZW50IHBvaW50ZWQgdG8gYmUgImxpY2Vuc2VVUkwiCi1saWNlbnNlPVwKLUVDTElQU0UgRk9VTkRBVElPTiBTT0ZUV0FSRSBVU0VSIEFHUkVFTUVOVFxuXAotSnVuZSAwNiwgMjAwN1xuXAotXG5cCi1Vc2FnZSBPZiBDb250ZW50XG5cCi1cblwKLVRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiBBTkQvT1JcblwKLU9USEVSIE1BVEVSSUFMUyBGT1IgT1BFTiBTT1VSQ0UgUFJPSkVDVFMgKENPTExFQ1RJVkVMWSAiQ09OVEVOVCIpLlxuXAotVVNFIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTXG5cCi1BR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBMSUNFTlNFIEFHUkVFTUVOVFMgT1JcblwKLU5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIEJZIFVTSU5HIFRIRSBDT05URU5ULCBZT1VcblwKLUFHUkVFIFRIQVQgWU9VUiBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhJUyBBR1JFRU1FTlRcblwKLUFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTXG5cCi1PUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiBJRiBZT1UgRE8gTk9UIEFHUkVFIFRPIFRIRVxuXAotVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OU1xuXAotT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRURcblwKLUJFTE9XLCBUSEVOIFlPVSBNQVkgTk9UIFVTRSBUSEUgQ09OVEVOVC5cblwKLVxuXAotQXBwbGljYWJsZSBMaWNlbnNlc1xuXAotXG5cCi1Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvblxuXAotaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRWNsaXBzZSBQdWJsaWNcblwKLUxpY2Vuc2UgVmVyc2lvbiAxLjAgKCJFUEwiKS4gQSBjb3B5IG9mIHRoZSBFUEwgaXMgcHJvdmlkZWQgd2l0aCB0aGlzXG5cCi1Db250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC5cblwKLUZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAiUHJvZ3JhbSIgd2lsbCBtZWFuIHRoZSBDb250ZW50LlxuXAotXG5cCi1Db250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSxcblwKLWRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2Uub3JnIENWU1xuXAotcmVwb3NpdG9yeSAoIlJlcG9zaXRvcnkiKSBpbiBDVlMgbW9kdWxlcyAoIk1vZHVsZXMiKSBhbmQgbWFkZSBhdmFpbGFibGVcblwKLWFzIGRvd25sb2FkYWJsZSBhcmNoaXZlcyAoIkRvd25sb2FkcyIpLlxuXAotXG5cCi0gICAtIENvbnRlbnQgbWF5IGJlIHN0cnVjdHVyZWQgYW5kIHBhY2thZ2VkIGludG8gbW9kdWxlcyB0byBmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsXG5cCi0gICAgIGV4dGVuZGluZywgYW5kIHVwZ3JhZGluZyB0aGUgQ29udGVudC4gVHlwaWNhbCBtb2R1bGVzIG1heSBpbmNsdWRlIHBsdWctaW5zICgiUGx1Zy1pbnMiKSxcblwKLSAgICAgcGx1Zy1pbiBmcmFnbWVudHMgKCJGcmFnbWVudHMiKSwgYW5kIGZlYXR1cmVzICgiRmVhdHVyZXMiKS5cblwKLSAgIC0gRWFjaCBQbHVnLWluIG9yIEZyYWdtZW50IG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3Rvcnkgb3IgSkFSIChKYXZhPyBBUmNoaXZlKVxuXAotICAgICBpbiBhIGRpcmVjdG9yeSBuYW1lZCAicGx1Z2lucyIuXG5cCi0gICAtIEEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLlxuXAotICAgICBFYWNoIEZlYXR1cmUgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAiZmVhdHVyZXMiLlxuXAotICAgICBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb25cblwKLSAgICAgbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhc3NvY2lhdGVkIHdpdGggdGhhdCBGZWF0dXJlLlxuXAotICAgLSBGZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgiSW5jbHVkZWQgRmVhdHVyZXMiKS4gV2l0aGluIGEgRmVhdHVyZSwgZmlsZXNcblwKLSAgICAgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgRmVhdHVyZXMuXG5cCi1cblwKLUZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBGaWxlcyBuYW1lZFxuXAotImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2ZcblwKLUluY2x1ZGVkIEZlYXR1cmVzLlxuXAotXG5cCi1UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlXG5cCi1jb250YWluZWQgaW4gZmlsZXMgbmFtZWQgImFib3V0Lmh0bWwiICgiQWJvdXRzIikuIFRoZSB0ZXJtcyBhbmRcblwKLWNvbmRpdGlvbnMgZ292ZXJuaW5nIEZlYXR1cmVzIGFuZCBJbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkXG5cCi1pbiBmaWxlcyBuYW1lZCAibGljZW5zZS5odG1sIiAoIkZlYXR1cmUgTGljZW5zZXMiKS4gQWJvdXRzIGFuZCBGZWF0dXJlXG5cCi1MaWNlbnNlcyBtYXkgYmUgbG9jYXRlZCBpbiBhbnkgZGlyZWN0b3J5IG9mIGEgRG93bmxvYWQgb3IgTW9kdWxlXG5cCi1pbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIGxvY2F0aW9uczpcblwKLVxuXAotICAgLSBUaGUgdG9wLWxldmVsIChyb290KSBkaXJlY3RvcnlcblwKLSAgIC0gUGx1Zy1pbiBhbmQgRnJhZ21lbnQgZGlyZWN0b3JpZXNcblwKLSAgIC0gSW5zaWRlIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgcGFja2FnZWQgYXMgSkFSc1xuXAotICAgLSBTdWItZGlyZWN0b3JpZXMgb2YgdGhlIGRpcmVjdG9yeSBuYW1lZCAic3JjIiBvZiBjZXJ0YWluIFBsdWctaW5zXG5cCi0gICAtIEZlYXR1cmUgZGlyZWN0b3JpZXNcblwKLVxuXAotTm90ZTogaWYgYSBGZWF0dXJlIG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgaW5zdGFsbGVkIHVzaW5nIHRoZVxuXAotRWNsaXBzZSBVcGRhdGUgTWFuYWdlciwgeW91IG11c3QgYWdyZWUgdG8gYSBsaWNlbnNlICgiRmVhdHVyZSBVcGRhdGVcblwKLUxpY2Vuc2UiKSBkdXJpbmcgdGhlIGluc3RhbGxhdGlvbiBwcm9jZXNzLiBJZiB0aGUgRmVhdHVyZSBjb250YWluc1xuXAotSW5jbHVkZWQgRmVhdHVyZXMsIHRoZSBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIHNob3VsZCBlaXRoZXIgcHJvdmlkZSB5b3VcblwKLXdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IgaW5mb3JtXG5cCi15b3Ugd2hlcmUgeW91IGNhbiBsb2NhdGUgdGhlbS4gRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgbWF5IGJlIGZvdW5kIGluXG5cCi10aGUgImxpY2Vuc2UiIHByb3BlcnR5IG9mIGZpbGVzIG5hbWVkICJmZWF0dXJlLnByb3BlcnRpZXMiLiBTdWNoIEFib3V0cyxcblwKLUZlYXR1cmUgTGljZW5zZXMgYW5kIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIHRlcm1zIGFuZFxuXAotY29uZGl0aW9ucyAob3IgcmVmZXJlbmNlcyB0byBzdWNoIHRlcm1zIGFuZCBjb25kaXRpb25zKSB0aGF0IGdvdmVybiB5b3VyXG5cCi11c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbiB0aGF0IGRpcmVjdG9yeS5cblwKLVxuXAotVEhFIEFCT1VUUywgRkVBVFVSRSBMSUNFTlNFUyBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSXG5cCi1UTyBUSEUgRVBMIE9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy5cblwKLVNPTUUgT0YgVEhFU0UgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTpcblwKLVxuXAotICAgIC0gQ29tbW9uIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwpXG5cCi0gICAgLSBBcGFjaGUgU29mdHdhcmUgTGljZW5zZSAxLjEgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRSlcblwKLSAgICAtIEFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDIuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMClcblwKLSAgICAtIElCTSBQdWJsaWMgTGljZW5zZSAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vZGV2ZWxvcGVyd29ya3Mvb3BlbnNvdXJjZS9saWNlbnNlMTAuaHRtbClcblwKLSAgICAtIE1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sKVxuXAotICAgIC0gTW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbClcblwKLSAgICAtIENvbW1vbiBEZXZlbG9wbWVudCBhbmQgRGlzdHJpYnV0aW9uIExpY2Vuc2UgKENEREwpIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sKVxuXAotXG5cCi1JVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCBDT05ESVRJT05TIFBSSU9SXG5cCi1UTyBVU0UgT0YgVEhFIENPTlRFTlQuIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2Ugb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZVxuXAotaXMgcHJvdmlkZWQsIHBsZWFzZSBjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIGNvbmRpdGlvbnNcblwKLWdvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC5cblwKLVxuXAotQ3J5cHRvZ3JhcGh5XG5cCi1cblwKLUNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZVxuXAotY3VycmVudGx5IG1heSBoYXZlIHJlc3RyaWN0aW9ucyBvbiB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBhbmQgdXNlLFxuXAotYW5kL29yIHJlLWV4cG9ydCB0byBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRVxuXAotdXNpbmcgYW55IGVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsXG5cCi1yZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgY29uY2VybmluZyB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBvciB1c2UsXG5cCi1hbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIHRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC5cblwKLVxuXAotSmF2YSBhbmQgYWxsIEphdmEtYmFzZWQgdHJhZGVtYXJrcyBhcmUgdHJhZGVtYXJrcyBvZiBTdW4gTWljcm9zeXN0ZW1zLCBJbmMuIGluIHRoZSBVbml0ZWQgU3RhdGVzLCBvdGhlciBjb3VudHJpZXMsIG9yIGJvdGguXG4KLSMjIyMjIyMjIyMjIGVuZCBvZiBsaWNlbnNlIHByb3BlcnR5ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGlua19zZGsuZmVhdHVyZS9mZWF0dXJlLnhtbCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmtfc2RrLmZlYXR1cmUvZmVhdHVyZS54bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGMzNTA1MDUuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGlua19zZGsuZmVhdHVyZS9mZWF0dXJlLnhtbAorKysgL2Rldi9udWxsCkBAIC0xLDI4ICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08ZmVhdHVyZQotICAgICAgaWQ9Im9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGlua19zZGsuZmVhdHVyZSIKLSAgICAgIGxhYmVsPSIlZmVhdHVyZU5hbWUiCi0gICAgICB2ZXJzaW9uPSIyLjIuMC5xdWFsaWZpZXIiCi0gICAgICBwcm92aWRlci1uYW1lPSIlcHJvdmlkZXJOYW1lIj4KLQotICAgPGRlc2NyaXB0aW9uPgotICAgICAgJWRlc2NyaXB0aW9uCi0gICA8L2Rlc2NyaXB0aW9uPgotCi0gICA8Y29weXJpZ2h0PgotICAgICAgJWNvcHlyaWdodAotICAgPC9jb3B5cmlnaHQ+Ci0KLSAgIDxsaWNlbnNlIHVybD0ibGljZW5zZS5odG1sIj4KLSAgICAgICVsaWNlbnNlCi0gICA8L2xpY2Vuc2U+Ci0KLSAgIDxpbmNsdWRlcwotICAgICAgICAgaWQ9Im9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5mZWF0dXJlIgotICAgICAgICAgdmVyc2lvbj0iMC4wLjAiLz4KLQotICAgPGluY2x1ZGVzCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmZlYXR1cmUuc291cmNlIgotICAgICAgICAgdmVyc2lvbj0iMC4wLjAiLz4KLQotPC9mZWF0dXJlPgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGlua19zZGsuZmVhdHVyZS9saWNlbnNlLmh0bWwgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rX3Nkay5mZWF0dXJlL2xpY2Vuc2UuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZmM3NzM3Mi4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rX3Nkay5mZWF0dXJlL2xpY2Vuc2UuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDk4ICswLDAgQEAKLTwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAxIFRyYW5zaXRpb25hbC8vRU4iICJodHRwOi8vd3d3LnczYy5vcmcvVFIvMTk5OS9SRUMtaHRtbDQwMS0xOTk5MTIyNC9sb29zZS5kdGQiPgotPCEtLSBzYXZlZCBmcm9tIHVybD0oMDA0NClodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC9ub3RpY2UuaHRtbCAtLT4KLTxIVE1MPjxIRUFEPjxUSVRMRT5FY2xpcHNlLm9yZyBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvVElUTEU+Ci08TUVUQSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9aXNvLTg4NTktMSI+Ci08TUVUQSBjb250ZW50PSJNU0hUTUwgNi4wMC4yODAwLjE0NzkiIG5hbWU9R0VORVJBVE9SPjwvSEVBRD4KLTxCT0RZIGxhbmc9RU4tVVMgdkxpbms9cHVycGxlIGxpbms9Ymx1ZT4KLTxIMj5FY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L0gyPgotPFA+SnVuZSAwNiwgMjAwNzwvUD4KLTxIMz5Vc2FnZSBPZiBDb250ZW50PC9IMz4KLTxQPlRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiAKLUFORC9PUiBPVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTIChDT0xMRUNUSVZFTFkgIkNPTlRFTlQiKS4gVVNFIE9GIAotVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCAKLUJFTE9XLiBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VIEFHUkVFIFRIQVQgWU9VUiBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgCi1CWSBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgCi1BR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFIAotVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgCi1BUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLCBUSEVOIFlPVSAKLU1BWSBOT1QgVVNFIFRIRSBDT05URU5ULjwvUD4KLTxIMz5BcHBsaWNhYmxlIExpY2Vuc2VzPC9IMz4KLTxQPlVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSAKLUZvdW5kYXRpb24gaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRWNsaXBzZSAKLVB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wICgiRVBMIikuIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpcyAKLUNvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IDxBIAotaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sPC9BPi4gCi1Gb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC48L1A+Ci08UD5Db250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSwgCi1kb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlLm9yZyBDVlMgcmVwb3NpdG9yeSAKLSgiUmVwb3NpdG9yeSIpIGluIENWUyBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIGF2YWlsYWJsZSBhcyBkb3dubG9hZGFibGUgCi1hcmNoaXZlcyAoIkRvd25sb2FkcyIpLjwvUD4KLTxQPkNvbnRlbnQgbWF5IGJlIGFwcG9ydGlvbmVkIGludG8gcGx1Zy1pbnMgKCJQbHVnLWlucyIpLCBwbHVnLWluIGZyYWdtZW50cyAKLSgiRnJhZ21lbnRzIiksIGFuZCBmZWF0dXJlcyAoIkZlYXR1cmVzIikuIEEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSAKLVBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuIEZpbGVzIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IAotY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgdGhlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgCi1hc3NvY2lhdGVkIHdpdGggYSBGZWF0dXJlLiBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIGFyZSBsb2NhdGVkIGluIGRpcmVjdG9yaWVzIAotbmFtZWQgInBsdWdpbnMiIGFuZCBGZWF0dXJlcyBhcmUgbG9jYXRlZCBpbiBkaXJlY3RvcmllcyBuYW1lZCAiZmVhdHVyZXMiLjwvUD4KLTxQPkZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBGaWxlcyBuYW1lZCAKLSJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIEluY2x1ZGVkIAotRmVhdHVyZXMuPC9QPgotPFA+VGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZSBjb250YWluZWQgCi1pbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyAKLUZlYXR1cmVzIGFuZCBJbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICJsaWNlbnNlLmh0bWwiIAotKCJGZWF0dXJlIExpY2Vuc2VzIikuIEFib3V0cyBhbmQgRmVhdHVyZSBMaWNlbnNlcyBtYXkgYmUgbG9jYXRlZCBpbiBhbnkgCi1kaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGUgaW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyAKLWxvY2F0aW9uczo8L1A+Ci08VUw+Ci0gIDxMST5UaGUgdG9wLWxldmVsIChyb290KSBkaXJlY3RvcnkgCi0gIDxMST5QbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3RvcmllcyAKLSAgPExJPlN1YmRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgInNyYyIgb2YgY2VydGFpbiBQbHVnLWlucyAKLSAgPExJPkZlYXR1cmUgZGlyZWN0b3JpZXMgPC9MST48L1VMPgotPFA+Tm90ZTogaWYgYSBGZWF0dXJlIG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgaW5zdGFsbGVkIAotdXNpbmcgdGhlIEVjbGlwc2UgVXBkYXRlIE1hbmFnZXIsIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoIkZlYXR1cmUgVXBkYXRlIAotTGljZW5zZSIpIGR1cmluZyB0aGUgaW5zdGFsbGF0aW9uIHByb2Nlc3MuIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zIEluY2x1ZGVkIAotRmVhdHVyZXMsIHRoZSBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIHNob3VsZCBlaXRoZXIgcHJvdmlkZSB5b3Ugd2l0aCB0aGUgdGVybXMgCi1hbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgdGhlIEluY2x1ZGVkIEZlYXR1cmVzIG9yIGluZm9ybSB5b3Ugd2hlcmUgeW91IGNhbiAKLWxvY2F0ZSB0aGVtLiBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW4gdGhlICJsaWNlbnNlIiBwcm9wZXJ0eSBvZiAKLWZpbGVzIG5hbWVkICJmZWF0dXJlLnByb3BlcnRpZXMiLiBTdWNoIEFib3V0cywgRmVhdHVyZSBMaWNlbnNlcyBhbmQgRmVhdHVyZSAKLVVwZGF0ZSBMaWNlbnNlcyBjb250YWluIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyAob3IgcmVmZXJlbmNlcyB0byBzdWNoIHRlcm1zIAotYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXIgdXNlIG9mIHRoZSBhc3NvY2lhdGVkIENvbnRlbnQgaW4gdGhhdCAKLWRpcmVjdG9yeS48L1A+Ci08UD5USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVIgVE8gVEhFIEVQTCAKLU9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy4gU09NRSBPRiBUSEVTRSAKLU9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6PC9QPgotPFVMPgotICA8TEk+Q29tbW9uIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbDwvQT4pIAotCi0gIDxMST5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAxLjEgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFPC9BPikgCi0KLSAgPExJPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDIuMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMDwvQT4pIAotCi0gIDxMST5JQk0gUHVibGljIExpY2Vuc2UgMS4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sIj5odHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vZGV2ZWxvcGVyd29ya3Mvb3BlbnNvdXJjZS9saWNlbnNlMTAuaHRtbDwvQT4pIAotCi0gIDxMST5NZXRybyBMaW5rIFB1YmxpYyBMaWNlbnNlIDEuMDAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwiPmh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sPC9BPikgCi0KLSAgPExJPk1vemlsbGEgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjEgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sIj5odHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWw8L0E+KSAKLSAgPC9MST4KLSAgCi0gIDxMST5Db21tb24gRGV2ZWxvcG1lbnQgYW5kIERpc3RyaWJ1dGlvbiBMaWNlbnNlIChDRERMKSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwiPmh0dHA6Ly93d3cuc3VuLmNvbS9jZGRsL2NkZGwuaHRtbCk8L0E+Ci0gIDwvTEk+Ci08L1VMPgotPFA+SVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgQ09ORElUSU9OUyBQUklPUiAKLVRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIGlzIAotcHJvdmlkZWQsIHBsZWFzZSBjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIAotY29uZGl0aW9ucyBnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuPC9QPgotPEgzPkNyeXB0b2dyYXBoeTwvSDM+Ci08UD5Db250ZW50IG1heSBjb250YWluIGVuY3J5cHRpb24gc29mdHdhcmUuIFRoZSBjb3VudHJ5IGluIHdoaWNoIHlvdSBhcmUgCi1jdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsIGFuZC9vciAKLXJlLWV4cG9ydCB0byBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRSB1c2luZyBhbnkgCi1lbmNyeXB0aW9uIHNvZnR3YXJlLCBwbGVhc2UgY2hlY2sgdGhlIGNvdW50cnkncyBsYXdzLCByZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgCi1jb25jZXJuaW5nIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIG9yIHVzZSwgYW5kIHJlLWV4cG9ydCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLCAKLXRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC48L1A+PC9CT0RZPjwvSFRNTD4KZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS8uY3ZzaWdub3JlIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlLy5jdnNpZ25vcmUKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGMxNDQ4N2MuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlLy5jdnNpZ25vcmUKKysrIC9kZXYvbnVsbApAQCAtMSArMCwwIEBACi1idWlsZC54bWwKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS8ucHJvamVjdCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS8ucHJvamVjdApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzhlYjJmMC4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvLnByb2plY3QKKysrIC9kZXYvbnVsbApAQCAtMSwxNyArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPHByb2plY3REZXNjcmlwdGlvbj4KLQk8bmFtZT5vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZTwvbmFtZT4KLQk8Y29tbWVudD48L2NvbW1lbnQ+Ci0JPHByb2plY3RzPgotCTwvcHJvamVjdHM+Ci0JPGJ1aWxkU3BlYz4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5GZWF0dXJlQnVpbGRlcjwvbmFtZT4KLQkJCTxhcmd1bWVudHM+Ci0JCQk8L2FyZ3VtZW50cz4KLQkJPC9idWlsZENvbW1hbmQ+Ci0JPC9idWlsZFNwZWM+Ci0JPG5hdHVyZXM+Ci0JCTxuYXR1cmU+b3JnLmVjbGlwc2UucGRlLkZlYXR1cmVOYXR1cmU8L25hdHVyZT4KLQk8L25hdHVyZXM+Ci08L3Byb2plY3REZXNjcmlwdGlvbj4KZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkYWI1ODM3Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMKKysrIC9kZXYvbnVsbApAQCAtMSwzICswLDAgQEAKLSNTdW4gTWF5IDI3IDE1OjEwOjQ3IEVEVCAyMDA3Ci1lY2xpcHNlLnByZWZlcmVuY2VzLnZlcnNpb249MQotZW5jb2RpbmcvPHByb2plY3Q+PUlTTy04ODU5LTEKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9idWlsZC5wcm9wZXJ0aWVzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL2J1aWxkLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDcyMDA5MzkuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL2J1aWxkLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwxNSArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi1iaW4uaW5jbHVkZXMgPSBmZWF0dXJlLnhtbCxcCi0gICAgICAgICAgICAgICBlY2xpcHNlX3VwZGF0ZV8xMjAuanBnLFwKLSAgICAgICAgICAgICAgIGVwbC12MTAuaHRtbCxcCi0gICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwsXAotICAgICAgICAgICAgICAgZmVhdHVyZS5wcm9wZXJ0aWVzCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiZmRmNzA4Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL2VwbC12MTAuaHRtbCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9lcGwtdjEwLmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVkNGIxOTYuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL2VwbC12MTAuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDMyOCArMCwwIEBACi08aHRtbCB4bWxuczpvPSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTpvZmZpY2UiCi14bWxuczp3PSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTp3b3JkIgoteG1sbnM9Imh0dHA6Ly93d3cudzMub3JnL1RSL1JFQy1odG1sNDAiPgotCi08aGVhZD4KLTxtZXRhIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD13aW5kb3dzLTEyNTIiPgotPG1ldGEgbmFtZT1Qcm9nSWQgY29udGVudD1Xb3JkLkRvY3VtZW50PgotPG1ldGEgbmFtZT1HZW5lcmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgOSI+Ci08bWV0YSBuYW1lPU9yaWdpbmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgOSI+Ci08bGluayByZWw9RmlsZS1MaXN0Ci1ocmVmPSIuL0VjbGlwc2UlMjBFUEwlMjAyMDAzXzExXzEwJTIwRmluYWxfZmlsZXMvZmlsZWxpc3QueG1sIj4KLTx0aXRsZT5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gVmVyc2lvbiAxLjA8L3RpdGxlPgotPCEtLVtpZiBndGUgbXNvIDldPjx4bWw+Ci0gPG86RG9jdW1lbnRQcm9wZXJ0aWVzPgotICA8bzpSZXZpc2lvbj4yPC9vOlJldmlzaW9uPgotICA8bzpUb3RhbFRpbWU+MzwvbzpUb3RhbFRpbWU+Ci0gIDxvOkNyZWF0ZWQ+MjAwNC0wMy0wNVQyMzowMzowMFo8L286Q3JlYXRlZD4KLSAgPG86TGFzdFNhdmVkPjIwMDQtMDMtMDVUMjM6MDM6MDBaPC9vOkxhc3RTYXZlZD4KLSAgPG86UGFnZXM+NDwvbzpQYWdlcz4KLSAgPG86V29yZHM+MTYyNjwvbzpXb3Jkcz4KLSAgPG86Q2hhcmFjdGVycz45MjcwPC9vOkNoYXJhY3RlcnM+Ci0gICA8bzpMaW5lcz43NzwvbzpMaW5lcz4KLSAgPG86UGFyYWdyYXBocz4xODwvbzpQYXJhZ3JhcGhzPgotICA8bzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4xMTM4NDwvbzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4KLSAgPG86VmVyc2lvbj45LjQ0MDI8L286VmVyc2lvbj4KLSA8L286RG9jdW1lbnRQcm9wZXJ0aWVzPgotPC94bWw+PCFbZW5kaWZdLS0+PCEtLVtpZiBndGUgbXNvIDldPjx4bWw+Ci0gPHc6V29yZERvY3VtZW50PgotICA8dzpUcmFja1JldmlzaW9ucy8+Ci0gPC93OldvcmREb2N1bWVudD4KLTwveG1sPjwhW2VuZGlmXS0tPgotPHN0eWxlPgotPCEtLQotIC8qIEZvbnQgRGVmaW5pdGlvbnMgKi8KLUBmb250LWZhY2UKLQl7Zm9udC1mYW1pbHk6VGFob21hOwotCXBhbm9zZS0xOjIgMTEgNiA0IDMgNSA0IDQgMiA0OwotCW1zby1mb250LWNoYXJzZXQ6MDsKLQltc28tZ2VuZXJpYy1mb250LWZhbWlseTpzd2lzczsKLQltc28tZm9udC1waXRjaDp2YXJpYWJsZTsKLQltc28tZm9udC1zaWduYXR1cmU6NTUzNjc5NDk1IC0yMTQ3NDgzNjQ4IDggMCA2NjA0NyAwO30KLSAvKiBTdHlsZSBEZWZpbml0aW9ucyAqLwotcC5Nc29Ob3JtYWwsIGxpLk1zb05vcm1hbCwgZGl2Lk1zb05vcm1hbAotCXttc28tc3R5bGUtcGFyZW50OiIiOwotCW1hcmdpbjowaW47Ci0JbWFyZ2luLWJvdHRvbTouMDAwMXB0OwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXAKLQl7bWFyZ2luLXJpZ2h0OjBpbjsKLQltc28tbWFyZ2luLXRvcC1hbHQ6YXV0bzsKLQltc28tbWFyZ2luLWJvdHRvbS1hbHQ6YXV0bzsKLQltYXJnaW4tbGVmdDowaW47Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZToxMi4wcHQ7Ci0JZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotcC5CYWxsb29uVGV4dCwgbGkuQmFsbG9vblRleHQsIGRpdi5CYWxsb29uVGV4dAotCXttc28tc3R5bGUtbmFtZToiQmFsbG9vbiBUZXh0IjsKLQltYXJnaW46MGluOwotCW1hcmdpbi1ib3R0b206LjAwMDFwdDsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjguMHB0OwotCWZvbnQtZmFtaWx5OlRhaG9tYTsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1AcGFnZSBTZWN0aW9uMQotCXtzaXplOjguNWluIDExLjBpbjsKLQltYXJnaW46MS4waW4gMS4yNWluIDEuMGluIDEuMjVpbjsKLQltc28taGVhZGVyLW1hcmdpbjouNWluOwotCW1zby1mb290ZXItbWFyZ2luOi41aW47Ci0JbXNvLXBhcGVyLXNvdXJjZTowO30KLWRpdi5TZWN0aW9uMQotCXtwYWdlOlNlY3Rpb24xO30KLS0tPgotPC9zdHlsZT4KLTwvaGVhZD4KLQotPGJvZHkgbGFuZz1FTi1VUyBzdHlsZT0ndGFiLWludGVydmFsOi41aW4nPgotCi08ZGl2IGNsYXNzPVNlY3Rpb24xPgotCi08cCBhbGlnbj1jZW50ZXIgc3R5bGU9J3RleHQtYWxpZ246Y2VudGVyJz48Yj5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gdiAxLjA8L2I+Ci08L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5USEUgQUNDT01QQU5ZSU5HIFBST0dSQU0gSVMgUFJPVklERUQgVU5ERVIKLVRIRSBURVJNUyBPRiBUSElTIEVDTElQU0UgUFVCTElDIExJQ0VOU0UgKCZxdW90O0FHUkVFTUVOVCZxdW90OykuIEFOWSBVU0UsCi1SRVBST0RVQ1RJT04gT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIENPTlNUSVRVVEVTIFJFQ0lQSUVOVCdTIEFDQ0VQVEFOQ0UKLU9GIFRISVMgQUdSRUVNRU5ULjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+MS4gREVGSU5JVElPTlM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtDb250cmlidXRpb24mcXVvdDsgbWVhbnM6PC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pbiB0aGUgY2FzZSBvZiB0aGUgaW5pdGlhbCBDb250cmlidXRvciwgdGhlIGluaXRpYWwgY29kZSBhbmQgZG9jdW1lbnRhdGlvbgotZGlzdHJpYnV0ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGFuZDxiciBjbGVhcj1sZWZ0PgotYikgaW4gdGhlIGNhc2Ugb2YgZWFjaCBzdWJzZXF1ZW50IENvbnRyaWJ1dG9yOjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmkpCi1jaGFuZ2VzIHRvIHRoZSBQcm9ncmFtLCBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paSkKLWFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbTs8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz53aGVyZQotc3VjaCBjaGFuZ2VzIGFuZC9vciBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gb3JpZ2luYXRlIGZyb20gYW5kIGFyZSBkaXN0cmlidXRlZAotYnkgdGhhdCBwYXJ0aWN1bGFyIENvbnRyaWJ1dG9yLiBBIENvbnRyaWJ1dGlvbiAnb3JpZ2luYXRlcycgZnJvbSBhIENvbnRyaWJ1dG9yCi1pZiBpdCB3YXMgYWRkZWQgdG8gdGhlIFByb2dyYW0gYnkgc3VjaCBDb250cmlidXRvciBpdHNlbGYgb3IgYW55b25lIGFjdGluZyBvbgotc3VjaCBDb250cmlidXRvcidzIGJlaGFsZi4gQ29udHJpYnV0aW9ucyBkbyBub3QgaW5jbHVkZSBhZGRpdGlvbnMgdG8gdGhlCi1Qcm9ncmFtIHdoaWNoOiAoaSkgYXJlIHNlcGFyYXRlIG1vZHVsZXMgb2Ygc29mdHdhcmUgZGlzdHJpYnV0ZWQgaW4gY29uanVuY3Rpb24KLXdpdGggdGhlIFByb2dyYW0gdW5kZXIgdGhlaXIgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBhbmQgKGlpKSBhcmUgbm90IGRlcml2YXRpdmUKLXdvcmtzIG9mIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7Q29udHJpYnV0b3ImcXVvdDsgbWVhbnMgYW55IHBlcnNvbiBvcgotZW50aXR5IHRoYXQgZGlzdHJpYnV0ZXMgdGhlIFByb2dyYW0uPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtMaWNlbnNlZCBQYXRlbnRzICZxdW90OyBtZWFuIHBhdGVudAotY2xhaW1zIGxpY2Vuc2FibGUgYnkgYSBDb250cmlidXRvciB3aGljaCBhcmUgbmVjZXNzYXJpbHkgaW5mcmluZ2VkIGJ5IHRoZSB1c2UKLW9yIHNhbGUgb2YgaXRzIENvbnRyaWJ1dGlvbiBhbG9uZSBvciB3aGVuIGNvbWJpbmVkIHdpdGggdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtQcm9ncmFtJnF1b3Q7IG1lYW5zIHRoZSBDb250cmlidXRpb25zCi1kaXN0cmlidXRlZCBpbiBhY2NvcmRhbmNlIHdpdGggdGhpcyBBZ3JlZW1lbnQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtSZWNpcGllbnQmcXVvdDsgbWVhbnMgYW55b25lIHdobwotcmVjZWl2ZXMgdGhlIFByb2dyYW0gdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGluY2x1ZGluZyBhbGwgQ29udHJpYnV0b3JzLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Mi4gR1JBTlQgT0YgUklHSFRTPC9zcGFuPjwvYj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQKLWEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLCByb3lhbHR5LWZyZWUgY29weXJpZ2h0IGxpY2Vuc2UgdG88c3Bhbgotc3R5bGU9J2NvbG9yOnJlZCc+IDwvc3Bhbj5yZXByb2R1Y2UsIHByZXBhcmUgZGVyaXZhdGl2ZSB3b3JrcyBvZiwgcHVibGljbHkKLWRpc3BsYXksIHB1YmxpY2x5IHBlcmZvcm0sIGRpc3RyaWJ1dGUgYW5kIHN1YmxpY2Vuc2UgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoCi1Db250cmlidXRvciwgaWYgYW55LCBhbmQgc3VjaCBkZXJpdmF0aXZlIHdvcmtzLCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUKLWZvcm0uPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikKLVN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMKLVJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSw8c3BhbiBzdHlsZT0nY29sb3I6Z3JlZW4nPiA8L3NwYW4+cm95YWx0eS1mcmVlCi1wYXRlbnQgbGljZW5zZSB1bmRlciBMaWNlbnNlZCBQYXRlbnRzIHRvIG1ha2UsIHVzZSwgc2VsbCwgb2ZmZXIgdG8gc2VsbCwgaW1wb3J0Ci1hbmQgb3RoZXJ3aXNlIHRyYW5zZmVyIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBpbiBzb3VyY2UKLWNvZGUgYW5kIG9iamVjdCBjb2RlIGZvcm0uIFRoaXMgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgYXBwbHkgdG8gdGhlIGNvbWJpbmF0aW9uCi1vZiB0aGUgQ29udHJpYnV0aW9uIGFuZCB0aGUgUHJvZ3JhbSBpZiwgYXQgdGhlIHRpbWUgdGhlIENvbnRyaWJ1dGlvbiBpcyBhZGRlZAotYnkgdGhlIENvbnRyaWJ1dG9yLCBzdWNoIGFkZGl0aW9uIG9mIHRoZSBDb250cmlidXRpb24gY2F1c2VzIHN1Y2ggY29tYmluYXRpb24KLXRvIGJlIGNvdmVyZWQgYnkgdGhlIExpY2Vuc2VkIFBhdGVudHMuIFRoZSBwYXRlbnQgbGljZW5zZSBzaGFsbCBub3QgYXBwbHkgdG8KLWFueSBvdGhlciBjb21iaW5hdGlvbnMgd2hpY2ggaW5jbHVkZSB0aGUgQ29udHJpYnV0aW9uLiBObyBoYXJkd2FyZSBwZXIgc2UgaXMKLWxpY2Vuc2VkIGhlcmV1bmRlci4gPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YykKLVJlY2lwaWVudCB1bmRlcnN0YW5kcyB0aGF0IGFsdGhvdWdoIGVhY2ggQ29udHJpYnV0b3IgZ3JhbnRzIHRoZSBsaWNlbnNlcyB0byBpdHMKLUNvbnRyaWJ1dGlvbnMgc2V0IGZvcnRoIGhlcmVpbiwgbm8gYXNzdXJhbmNlcyBhcmUgcHJvdmlkZWQgYnkgYW55IENvbnRyaWJ1dG9yCi10aGF0IHRoZSBQcm9ncmFtIGRvZXMgbm90IGluZnJpbmdlIHRoZSBwYXRlbnQgb3Igb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5Ci1yaWdodHMgb2YgYW55IG90aGVyIGVudGl0eS4gRWFjaCBDb250cmlidXRvciBkaXNjbGFpbXMgYW55IGxpYWJpbGl0eSB0byBSZWNpcGllbnQKLWZvciBjbGFpbXMgYnJvdWdodCBieSBhbnkgb3RoZXIgZW50aXR5IGJhc2VkIG9uIGluZnJpbmdlbWVudCBvZiBpbnRlbGxlY3R1YWwKLXByb3BlcnR5IHJpZ2h0cyBvciBvdGhlcndpc2UuIEFzIGEgY29uZGl0aW9uIHRvIGV4ZXJjaXNpbmcgdGhlIHJpZ2h0cyBhbmQKLWxpY2Vuc2VzIGdyYW50ZWQgaGVyZXVuZGVyLCBlYWNoIFJlY2lwaWVudCBoZXJlYnkgYXNzdW1lcyBzb2xlIHJlc3BvbnNpYmlsaXR5Ci10byBzZWN1cmUgYW55IG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgbmVlZGVkLCBpZiBhbnkuIEZvciBleGFtcGxlLAotaWYgYSB0aGlyZCBwYXJ0eSBwYXRlbnQgbGljZW5zZSBpcyByZXF1aXJlZCB0byBhbGxvdyBSZWNpcGllbnQgdG8gZGlzdHJpYnV0ZQotdGhlIFByb2dyYW0sIGl0IGlzIFJlY2lwaWVudCdzIHJlc3BvbnNpYmlsaXR5IHRvIGFjcXVpcmUgdGhhdCBsaWNlbnNlIGJlZm9yZQotZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtLjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmQpCi1FYWNoIENvbnRyaWJ1dG9yIHJlcHJlc2VudHMgdGhhdCB0byBpdHMga25vd2xlZGdlIGl0IGhhcyBzdWZmaWNpZW50IGNvcHlyaWdodAotcmlnaHRzIGluIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgdG8gZ3JhbnQgdGhlIGNvcHlyaWdodCBsaWNlbnNlIHNldCBmb3J0aCBpbgotdGhpcyBBZ3JlZW1lbnQuIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4zLiBSRVFVSVJFTUVOVFM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5BIENvbnRyaWJ1dG9yIG1heSBjaG9vc2UgdG8gZGlzdHJpYnV0ZSB0aGUKLVByb2dyYW0gaW4gb2JqZWN0IGNvZGUgZm9ybSB1bmRlciBpdHMgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBwcm92aWRlZCB0aGF0Ojwvc3Bhbj4KLTwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWl0IGNvbXBsaWVzIHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50OyBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKQotaXRzIGxpY2Vuc2UgYWdyZWVtZW50Ojwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmkpCi1lZmZlY3RpdmVseSBkaXNjbGFpbXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIHdhcnJhbnRpZXMgYW5kCi1jb25kaXRpb25zLCBleHByZXNzIGFuZCBpbXBsaWVkLCBpbmNsdWRpbmcgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIHRpdGxlCi1hbmQgbm9uLWluZnJpbmdlbWVudCwgYW5kIGltcGxpZWQgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIG1lcmNoYW50YWJpbGl0eQotYW5kIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlOyA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paSkKLWVmZmVjdGl2ZWx5IGV4Y2x1ZGVzIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCBsaWFiaWxpdHkgZm9yIGRhbWFnZXMsCi1pbmNsdWRpbmcgZGlyZWN0LCBpbmRpcmVjdCwgc3BlY2lhbCwgaW5jaWRlbnRhbCBhbmQgY29uc2VxdWVudGlhbCBkYW1hZ2VzLCBzdWNoCi1hcyBsb3N0IHByb2ZpdHM7IDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpaSkKLXN0YXRlcyB0aGF0IGFueSBwcm92aXNpb25zIHdoaWNoIGRpZmZlciBmcm9tIHRoaXMgQWdyZWVtZW50IGFyZSBvZmZlcmVkIGJ5IHRoYXQKLUNvbnRyaWJ1dG9yIGFsb25lIGFuZCBub3QgYnkgYW55IG90aGVyIHBhcnR5OyBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pdikKLXN0YXRlcyB0aGF0IHNvdXJjZSBjb2RlIGZvciB0aGUgUHJvZ3JhbSBpcyBhdmFpbGFibGUgZnJvbSBzdWNoIENvbnRyaWJ1dG9yLCBhbmQKLWluZm9ybXMgbGljZW5zZWVzIGhvdyB0byBvYnRhaW4gaXQgaW4gYSByZWFzb25hYmxlIG1hbm5lciBvbiBvciB0aHJvdWdoIGEKLW1lZGl1bSBjdXN0b21hcmlseSB1c2VkIGZvciBzb2Z0d2FyZSBleGNoYW5nZS48c3BhbiBzdHlsZT0nY29sb3I6Ymx1ZSc+IDwvc3Bhbj48L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+V2hlbiB0aGUgUHJvZ3JhbSBpcyBtYWRlIGF2YWlsYWJsZSBpbiBzb3VyY2UKLWNvZGUgZm9ybTo8L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWl0IG11c3QgYmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhpcyBBZ3JlZW1lbnQ7IGFuZCA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKSBhCi1jb3B5IG9mIHRoaXMgQWdyZWVtZW50IG11c3QgYmUgaW5jbHVkZWQgd2l0aCBlYWNoIGNvcHkgb2YgdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Db250cmlidXRvcnMgbWF5IG5vdCByZW1vdmUgb3IgYWx0ZXIgYW55Ci1jb3B5cmlnaHQgbm90aWNlcyBjb250YWluZWQgd2l0aGluIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RWFjaCBDb250cmlidXRvciBtdXN0IGlkZW50aWZ5IGl0c2VsZiBhcyB0aGUKLW9yaWdpbmF0b3Igb2YgaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCBpbiBhIG1hbm5lciB0aGF0IHJlYXNvbmFibHkgYWxsb3dzCi1zdWJzZXF1ZW50IFJlY2lwaWVudHMgdG8gaWRlbnRpZnkgdGhlIG9yaWdpbmF0b3Igb2YgdGhlIENvbnRyaWJ1dGlvbi4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjQuIENPTU1FUkNJQUwgRElTVFJJQlVUSU9OPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Q29tbWVyY2lhbCBkaXN0cmlidXRvcnMgb2Ygc29mdHdhcmUgbWF5Ci1hY2NlcHQgY2VydGFpbiByZXNwb25zaWJpbGl0aWVzIHdpdGggcmVzcGVjdCB0byBlbmQgdXNlcnMsIGJ1c2luZXNzIHBhcnRuZXJzCi1hbmQgdGhlIGxpa2UuIFdoaWxlIHRoaXMgbGljZW5zZSBpcyBpbnRlbmRlZCB0byBmYWNpbGl0YXRlIHRoZSBjb21tZXJjaWFsIHVzZQotb2YgdGhlIFByb2dyYW0sIHRoZSBDb250cmlidXRvciB3aG8gaW5jbHVkZXMgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsCi1wcm9kdWN0IG9mZmVyaW5nIHNob3VsZCBkbyBzbyBpbiBhIG1hbm5lciB3aGljaCBkb2VzIG5vdCBjcmVhdGUgcG90ZW50aWFsCi1saWFiaWxpdHkgZm9yIG90aGVyIENvbnRyaWJ1dG9ycy4gVGhlcmVmb3JlLCBpZiBhIENvbnRyaWJ1dG9yIGluY2x1ZGVzIHRoZQotUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgc3VjaCBDb250cmlidXRvciAoJnF1b3Q7Q29tbWVyY2lhbAotQ29udHJpYnV0b3ImcXVvdDspIGhlcmVieSBhZ3JlZXMgdG8gZGVmZW5kIGFuZCBpbmRlbW5pZnkgZXZlcnkgb3RoZXIKLUNvbnRyaWJ1dG9yICgmcXVvdDtJbmRlbW5pZmllZCBDb250cmlidXRvciZxdW90OykgYWdhaW5zdCBhbnkgbG9zc2VzLCBkYW1hZ2VzIGFuZAotY29zdHMgKGNvbGxlY3RpdmVseSAmcXVvdDtMb3NzZXMmcXVvdDspIGFyaXNpbmcgZnJvbSBjbGFpbXMsIGxhd3N1aXRzIGFuZCBvdGhlcgotbGVnYWwgYWN0aW9ucyBicm91Z2h0IGJ5IGEgdGhpcmQgcGFydHkgYWdhaW5zdCB0aGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgdG8KLXRoZSBleHRlbnQgY2F1c2VkIGJ5IHRoZSBhY3RzIG9yIG9taXNzaW9ucyBvZiBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4KLWNvbm5lY3Rpb24gd2l0aCBpdHMgZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0Ci1vZmZlcmluZy4gVGhlIG9ibGlnYXRpb25zIGluIHRoaXMgc2VjdGlvbiBkbyBub3QgYXBwbHkgdG8gYW55IGNsYWltcyBvciBMb3NzZXMKLXJlbGF0aW5nIHRvIGFueSBhY3R1YWwgb3IgYWxsZWdlZCBpbnRlbGxlY3R1YWwgcHJvcGVydHkgaW5mcmluZ2VtZW50LiBJbiBvcmRlcgotdG8gcXVhbGlmeSwgYW4gSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbXVzdDogYSkgcHJvbXB0bHkgbm90aWZ5IHRoZSBDb21tZXJjaWFsCi1Db250cmlidXRvciBpbiB3cml0aW5nIG9mIHN1Y2ggY2xhaW0sIGFuZCBiKSBhbGxvdyB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvcgotdG8gY29udHJvbCwgYW5kIGNvb3BlcmF0ZSB3aXRoIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluLCB0aGUgZGVmZW5zZSBhbmQKLWFueSByZWxhdGVkIHNldHRsZW1lbnQgbmVnb3RpYXRpb25zLiBUaGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbWF5IHBhcnRpY2lwYXRlCi1pbiBhbnkgc3VjaCBjbGFpbSBhdCBpdHMgb3duIGV4cGVuc2UuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Gb3IgZXhhbXBsZSwgYSBDb250cmlidXRvciBtaWdodCBpbmNsdWRlIHRoZQotUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgUHJvZHVjdCBYLiBUaGF0IENvbnRyaWJ1dG9yIGlzIHRoZW4gYQotQ29tbWVyY2lhbCBDb250cmlidXRvci4gSWYgdGhhdCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRoZW4gbWFrZXMgcGVyZm9ybWFuY2UKLWNsYWltcywgb3Igb2ZmZXJzIHdhcnJhbnRpZXMgcmVsYXRlZCB0byBQcm9kdWN0IFgsIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQKLXdhcnJhbnRpZXMgYXJlIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvcidzIHJlc3BvbnNpYmlsaXR5IGFsb25lLiBVbmRlciB0aGlzCi1zZWN0aW9uLCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB3b3VsZCBoYXZlIHRvIGRlZmVuZCBjbGFpbXMgYWdhaW5zdCB0aGUKLW90aGVyIENvbnRyaWJ1dG9ycyByZWxhdGVkIHRvIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcywgYW5kIGlmIGEKLWNvdXJ0IHJlcXVpcmVzIGFueSBvdGhlciBDb250cmlidXRvciB0byBwYXkgYW55IGRhbWFnZXMgYXMgYSByZXN1bHQsIHRoZQotQ29tbWVyY2lhbCBDb250cmlidXRvciBtdXN0IHBheSB0aG9zZSBkYW1hZ2VzLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+NS4gTk8gV0FSUkFOVFk8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTCi1BR1JFRU1FTlQsIFRIRSBQUk9HUkFNIElTIFBST1ZJREVEIE9OIEFOICZxdW90O0FTIElTJnF1b3Q7IEJBU0lTLCBXSVRIT1VUCi1XQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIEVJVEhFUiBFWFBSRVNTIE9SIElNUExJRUQgSU5DTFVESU5HLAotV0lUSE9VVCBMSU1JVEFUSU9OLCBBTlkgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIFRJVExFLCBOT04tSU5GUklOR0VNRU5ULAotTUVSQ0hBTlRBQklMSVRZIE9SIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBFYWNoIFJlY2lwaWVudCBpcyBzb2xlbHkKLXJlc3BvbnNpYmxlIGZvciBkZXRlcm1pbmluZyB0aGUgYXBwcm9wcmlhdGVuZXNzIG9mIHVzaW5nIGFuZCBkaXN0cmlidXRpbmcgdGhlCi1Qcm9ncmFtIGFuZCBhc3N1bWVzIGFsbCByaXNrcyBhc3NvY2lhdGVkIHdpdGggaXRzIGV4ZXJjaXNlIG9mIHJpZ2h0cyB1bmRlciB0aGlzCi1BZ3JlZW1lbnQgLCBpbmNsdWRpbmcgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSByaXNrcyBhbmQgY29zdHMgb2YgcHJvZ3JhbSBlcnJvcnMsCi1jb21wbGlhbmNlIHdpdGggYXBwbGljYWJsZSBsYXdzLCBkYW1hZ2UgdG8gb3IgbG9zcyBvZiBkYXRhLCBwcm9ncmFtcyBvcgotZXF1aXBtZW50LCBhbmQgdW5hdmFpbGFiaWxpdHkgb3IgaW50ZXJydXB0aW9uIG9mIG9wZXJhdGlvbnMuIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz42LiBESVNDTEFJTUVSIE9GIExJQUJJTElUWTwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMKLUFHUkVFTUVOVCwgTkVJVEhFUiBSRUNJUElFTlQgTk9SIEFOWSBDT05UUklCVVRPUlMgU0hBTEwgSEFWRSBBTlkgTElBQklMSVRZIEZPUgotQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0oSU5DTFVESU5HIFdJVEhPVVQgTElNSVRBVElPTiBMT1NUIFBST0ZJVFMpLCBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQotT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcKLU5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT1IgRElTVFJJQlVUSU9OIE9GCi1USEUgUFJPR1JBTSBPUiBUSEUgRVhFUkNJU0UgT0YgQU5ZIFJJR0hUUyBHUkFOVEVEIEhFUkVVTkRFUiwgRVZFTiBJRiBBRFZJU0VEIE9GCi1USEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0VTLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Ny4gR0VORVJBTDwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPklmIGFueSBwcm92aXNpb24gb2YgdGhpcyBBZ3JlZW1lbnQgaXMgaW52YWxpZAotb3IgdW5lbmZvcmNlYWJsZSB1bmRlciBhcHBsaWNhYmxlIGxhdywgaXQgc2hhbGwgbm90IGFmZmVjdCB0aGUgdmFsaWRpdHkgb3IKLWVuZm9yY2VhYmlsaXR5IG9mIHRoZSByZW1haW5kZXIgb2YgdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBhbmQgd2l0aG91dAotZnVydGhlciBhY3Rpb24gYnkgdGhlIHBhcnRpZXMgaGVyZXRvLCBzdWNoIHByb3Zpc2lvbiBzaGFsbCBiZSByZWZvcm1lZCB0byB0aGUKLW1pbmltdW0gZXh0ZW50IG5lY2Vzc2FyeSB0byBtYWtlIHN1Y2ggcHJvdmlzaW9uIHZhbGlkIGFuZCBlbmZvcmNlYWJsZS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPklmIFJlY2lwaWVudCBpbnN0aXR1dGVzIHBhdGVudCBsaXRpZ2F0aW9uCi1hZ2FpbnN0IGFueSBlbnRpdHkgKGluY2x1ZGluZyBhIGNyb3NzLWNsYWltIG9yIGNvdW50ZXJjbGFpbSBpbiBhIGxhd3N1aXQpCi1hbGxlZ2luZyB0aGF0IHRoZSBQcm9ncmFtIGl0c2VsZiAoZXhjbHVkaW5nIGNvbWJpbmF0aW9ucyBvZiB0aGUgUHJvZ3JhbSB3aXRoCi1vdGhlciBzb2Z0d2FyZSBvciBoYXJkd2FyZSkgaW5mcmluZ2VzIHN1Y2ggUmVjaXBpZW50J3MgcGF0ZW50KHMpLCB0aGVuIHN1Y2gKLVJlY2lwaWVudCdzIHJpZ2h0cyBncmFudGVkIHVuZGVyIFNlY3Rpb24gMihiKSBzaGFsbCB0ZXJtaW5hdGUgYXMgb2YgdGhlIGRhdGUKLXN1Y2ggbGl0aWdhdGlvbiBpcyBmaWxlZC4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkFsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQKLXNoYWxsIHRlcm1pbmF0ZSBpZiBpdCBmYWlscyB0byBjb21wbHkgd2l0aCBhbnkgb2YgdGhlIG1hdGVyaWFsIHRlcm1zIG9yCi1jb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50IGFuZCBkb2VzIG5vdCBjdXJlIHN1Y2ggZmFpbHVyZSBpbiBhIHJlYXNvbmFibGUKLXBlcmlvZCBvZiB0aW1lIGFmdGVyIGJlY29taW5nIGF3YXJlIG9mIHN1Y2ggbm9uY29tcGxpYW5jZS4gSWYgYWxsIFJlY2lwaWVudCdzCi1yaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgdGVybWluYXRlLCBSZWNpcGllbnQgYWdyZWVzIHRvIGNlYXNlIHVzZSBhbmQKLWRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBhcyBzb29uIGFzIHJlYXNvbmFibHkgcHJhY3RpY2FibGUuIEhvd2V2ZXIsCi1SZWNpcGllbnQncyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIEFncmVlbWVudCBhbmQgYW55IGxpY2Vuc2VzIGdyYW50ZWQgYnkKLVJlY2lwaWVudCByZWxhdGluZyB0byB0aGUgUHJvZ3JhbSBzaGFsbCBjb250aW51ZSBhbmQgc3Vydml2ZS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkV2ZXJ5b25lIGlzIHBlcm1pdHRlZCB0byBjb3B5IGFuZCBkaXN0cmlidXRlCi1jb3BpZXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGJ1dCBpbiBvcmRlciB0byBhdm9pZCBpbmNvbnNpc3RlbmN5IHRoZSBBZ3JlZW1lbnQgaXMKLWNvcHlyaWdodGVkIGFuZCBtYXkgb25seSBiZSBtb2RpZmllZCBpbiB0aGUgZm9sbG93aW5nIG1hbm5lci4gVGhlIEFncmVlbWVudAotU3Rld2FyZCByZXNlcnZlcyB0aGUgcmlnaHQgdG8gcHVibGlzaCBuZXcgdmVyc2lvbnMgKGluY2x1ZGluZyByZXZpc2lvbnMpIG9mCi10aGlzIEFncmVlbWVudCBmcm9tIHRpbWUgdG8gdGltZS4gTm8gb25lIG90aGVyIHRoYW4gdGhlIEFncmVlbWVudCBTdGV3YXJkIGhhcwotdGhlIHJpZ2h0IHRvIG1vZGlmeSB0aGlzIEFncmVlbWVudC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyB0aGUgaW5pdGlhbAotQWdyZWVtZW50IFN0ZXdhcmQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWF5IGFzc2lnbiB0aGUgcmVzcG9uc2liaWxpdHkgdG8KLXNlcnZlIGFzIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCB0byBhIHN1aXRhYmxlIHNlcGFyYXRlIGVudGl0eS4gRWFjaCBuZXcgdmVyc2lvbgotb2YgdGhlIEFncmVlbWVudCB3aWxsIGJlIGdpdmVuIGEgZGlzdGluZ3Vpc2hpbmcgdmVyc2lvbiBudW1iZXIuIFRoZSBQcm9ncmFtCi0oaW5jbHVkaW5nIENvbnRyaWJ1dGlvbnMpIG1heSBhbHdheXMgYmUgZGlzdHJpYnV0ZWQgc3ViamVjdCB0byB0aGUgdmVyc2lvbiBvZgotdGhlIEFncmVlbWVudCB1bmRlciB3aGljaCBpdCB3YXMgcmVjZWl2ZWQuIEluIGFkZGl0aW9uLCBhZnRlciBhIG5ldyB2ZXJzaW9uIG9mCi10aGUgQWdyZWVtZW50IGlzIHB1Ymxpc2hlZCwgQ29udHJpYnV0b3IgbWF5IGVsZWN0IHRvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0KLShpbmNsdWRpbmcgaXRzIENvbnRyaWJ1dGlvbnMpIHVuZGVyIHRoZSBuZXcgdmVyc2lvbi4gRXhjZXB0IGFzIGV4cHJlc3NseSBzdGF0ZWQKLWluIFNlY3Rpb25zIDIoYSkgYW5kIDIoYikgYWJvdmUsIFJlY2lwaWVudCByZWNlaXZlcyBubyByaWdodHMgb3IgbGljZW5zZXMgdG8KLXRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgb2YgYW55IENvbnRyaWJ1dG9yIHVuZGVyIHRoaXMgQWdyZWVtZW50LCB3aGV0aGVyCi1leHByZXNzbHksIGJ5IGltcGxpY2F0aW9uLCBlc3RvcHBlbCBvciBvdGhlcndpc2UuIEFsbCByaWdodHMgaW4gdGhlIFByb2dyYW0gbm90Ci1leHByZXNzbHkgZ3JhbnRlZCB1bmRlciB0aGlzIEFncmVlbWVudCBhcmUgcmVzZXJ2ZWQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5UaGlzIEFncmVlbWVudCBpcyBnb3Zlcm5lZCBieSB0aGUgbGF3cyBvZiB0aGUKLVN0YXRlIG9mIE5ldyBZb3JrIGFuZCB0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGxhd3Mgb2YgdGhlIFVuaXRlZCBTdGF0ZXMgb2YKLUFtZXJpY2EuIE5vIHBhcnR5IHRvIHRoaXMgQWdyZWVtZW50IHdpbGwgYnJpbmcgYSBsZWdhbCBhY3Rpb24gdW5kZXIgdGhpcwotQWdyZWVtZW50IG1vcmUgdGhhbiBvbmUgeWVhciBhZnRlciB0aGUgY2F1c2Ugb2YgYWN0aW9uIGFyb3NlLiBFYWNoIHBhcnR5IHdhaXZlcwotaXRzIHJpZ2h0cyB0byBhIGp1cnkgdHJpYWwgaW4gYW55IHJlc3VsdGluZyBsaXRpZ2F0aW9uLjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PCFbaWYgIXN1cHBvcnRFbXB0eVBhcmFzXT4mbmJzcDs8IVtlbmRpZl0+PG86cD48L286cD48L3A+Ci0KLTwvZGl2PgotCi08L2JvZHk+Ci0KLTwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvZmVhdHVyZS5wcm9wZXJ0aWVzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL2ZlYXR1cmUucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYTJiMzlmMy4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvZmVhdHVyZS5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTQwICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotCi0jICJmZWF0dXJlTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBmZWF0dXJlCi1mZWF0dXJlTmFtZT1KYXZhIFBlcnNpc3RlbmNlIEFQSSBUb29scwotCi0jICJwcm92aWRlck5hbWUiIHByb3BlcnR5IC0gbmFtZSBvZiB0aGUgY29tcGFueSB0aGF0IHByb3ZpZGVzIHRoZSBmZWF0dXJlCi1wcm92aWRlck5hbWU9RWNsaXBzZS5vcmcKLQotIyAidXBkYXRlU2l0ZU5hbWUiIHByb3BlcnR5IC0gbGFiZWwgZm9yIHRoZSB1cGRhdGUgc2l0ZQotdXBkYXRlU2l0ZU5hbWU9VGhlIEVjbGlwc2UgV2ViIFRvb2xzIFBsYXRmb3JtIChXVFApIFByb2plY3QgdXBkYXRlIHNpdGUKLQotIyAiZGVzY3JpcHRpb24iIHByb3BlcnR5IC0gZGVzY3JpcHRpb24gb2YgdGhlIGZlYXR1cmUKLWRlc2NyaXB0aW9uPUphdmEgUGVyc2lzdGVuY2UgQVBJIChKUEEpIFRvb2xzCi0KLSMgImNvcHlyaWdodCIgcHJvcGVydHkgLSB0ZXh0IG9mIHRoZSAiRmVhdHVyZSBVcGRhdGUgQ29weXJpZ2h0IgotY29weXJpZ2h0PVwKLUNvcHlyaWdodCAoYykgMjAwNi0wNyBPcmFjbGUgQ29ycG9yYXRpb24uXG5cCi1BbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzXG5cCi1hcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjBcblwKLXdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0XG5cCi1odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbFxuXAotXG5cCi1Db250cmlidXRvcnM6XG5cCi0gICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uXG4KLSMjIyMjIyMjIyMjIyMjIyMgZW5kIG9mIGNvcHlyaWdodCBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotIyAibGljZW5zZVVSTCIgcHJvcGVydHkgLSBVUkwgb2YgdGhlICJGZWF0dXJlIExpY2Vuc2UiCi0jIGRvIG5vdCB0cmFuc2xhdGUgdmFsdWUgLSBqdXN0IGNoYW5nZSB0byBwb2ludCB0byBhIGxvY2FsZS1zcGVjaWZpYyBIVE1MIHBhZ2UKLWxpY2Vuc2VVUkw9bGljZW5zZS5odG1sCi0KLSMgImxpY2Vuc2UiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIExpY2Vuc2UiCi0jIHNob3VsZCBiZSBwbGFpbiB0ZXh0IHZlcnNpb24gb2YgbGljZW5zZSBhZ3JlZW1lbnQgcG9pbnRlZCB0byBiZSAibGljZW5zZVVSTCIKLWxpY2Vuc2U9XAotRUNMSVBTRSBGT1VOREFUSU9OIFNPRlRXQVJFIFVTRVIgQUdSRUVNRU5UXG5cCi1KdW5lIDA2LCAyMDA3XG5cCi1cblwKLVVzYWdlIE9mIENvbnRlbnRcblwKLVxuXAotVEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUlxuXAotT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUyAoQ09MTEVDVElWRUxZICJDT05URU5UIikuXG5cCi1VU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVNcblwKLUFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUlxuXAotTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVVxuXAotQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVFxuXAotQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFNcblwKLU9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFXG5cCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TXG5cCi1PRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRFxuXAotQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULlxuXAotXG5cCi1BcHBsaWNhYmxlIExpY2Vuc2VzXG5cCi1cblwKLVVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uXG5cCi1pcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpY1xuXAotTGljZW5zZSBWZXJzaW9uIDEuMCAoIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXNcblwKLUNvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLlxuXAotRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuXG5cCi1cblwKLUNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLFxuXAotZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZS5vcmcgQ1ZTXG5cCi1yZXBvc2l0b3J5ICgiUmVwb3NpdG9yeSIpIGluIENWUyBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIGF2YWlsYWJsZVxuXAotYXMgZG93bmxvYWRhYmxlIGFyY2hpdmVzICgiRG93bmxvYWRzIikuXG5cCi1cblwKLSAgIC0gQ29udGVudCBtYXkgYmUgc3RydWN0dXJlZCBhbmQgcGFja2FnZWQgaW50byBtb2R1bGVzIHRvIGZhY2lsaXRhdGUgZGVsaXZlcmluZyxcblwKLSAgICAgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiBUeXBpY2FsIG1vZHVsZXMgbWF5IGluY2x1ZGUgcGx1Zy1pbnMgKCJQbHVnLWlucyIpLFxuXAotICAgICBwbHVnLWluIGZyYWdtZW50cyAoIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLlxuXAotICAgLSBFYWNoIFBsdWctaW4gb3IgRnJhZ21lbnQgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBvciBKQVIgKEphdmE/IEFSY2hpdmUpXG5cCi0gICAgIGluIGEgZGlyZWN0b3J5IG5hbWVkICJwbHVnaW5zIi5cblwKLSAgIC0gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuXG5cCi0gICAgIEVhY2ggRmVhdHVyZSBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IGluIGEgZGlyZWN0b3J5IG5hbWVkICJmZWF0dXJlcyIuXG5cCi0gICAgIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvblxuXAotICAgICBudW1iZXJzIG9mIHRoZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuXG5cCi0gICAtIEZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlc1xuXAotICAgICBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy5cblwKLVxuXAotRmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIEZpbGVzIG5hbWVkXG5cCi0iZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZlxuXAotSW5jbHVkZWQgRmVhdHVyZXMuXG5cCi1cblwKLVRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmVcblwKLWNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZFxuXAotY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kIEluY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWRcblwKLWluIGZpbGVzIG5hbWVkICJsaWNlbnNlLmh0bWwiICgiRmVhdHVyZSBMaWNlbnNlcyIpLiBBYm91dHMgYW5kIEZlYXR1cmVcblwKLUxpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSBkaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGVcblwKLWluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOlxuXAotXG5cCi0gICAtIFRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeVxuXAotICAgLSBQbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3Rvcmllc1xuXAotICAgLSBJbnNpZGUgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBwYWNrYWdlZCBhcyBKQVJzXG5cCi0gICAtIFN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnNcblwKLSAgIC0gRmVhdHVyZSBkaXJlY3Rvcmllc1xuXAotXG5cCi1Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlXG5cCi1FY2xpcHNlIFVwZGF0ZSBNYW5hZ2VyLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFVwZGF0ZVxuXAotTGljZW5zZSIpIGR1cmluZyB0aGUgaW5zdGFsbGF0aW9uIHByb2Nlc3MuIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zXG5cCi1JbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdVxuXAotd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvciBpbmZvcm1cblwKLXlvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW5cblwKLXRoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIuIFN1Y2ggQWJvdXRzLFxuXAotRmVhdHVyZSBMaWNlbnNlcyBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kXG5cCi1jb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXJcblwKLXVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluIHRoYXQgZGlyZWN0b3J5LlxuXAotXG5cCi1USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVJcblwKLVRPIFRIRSBFUEwgT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLlxuXAotU09NRSBPRiBUSEVTRSBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOlxuXAotXG5cCi0gICAgLSBDb21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbClcblwKLSAgICAtIEFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFKVxuXAotICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wKVxuXAotICAgIC0gSUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sKVxuXAotICAgIC0gTWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwpXG5cCi0gICAgLSBNb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sKVxuXAotICAgIC0gQ29tbW9uIERldmVsb3BtZW50IGFuZCBEaXN0cmlidXRpb24gTGljZW5zZSAoQ0RETCkgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwpXG5cCi1cblwKLUlUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1JcblwKLVRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlXG5cCi1pcyBwcm92aWRlZCwgcGxlYXNlIGNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9uc1xuXAotZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LlxuXAotXG5cCi1DcnlwdG9ncmFwaHlcblwKLVxuXAotQ29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlXG5cCi1jdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsXG5cCi1hbmQvb3IgcmUtZXhwb3J0IHRvIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFXG5cCi11c2luZyBhbnkgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cyxcblwKLXJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIG9yIHVzZSxcblwKLWFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLlxuXAotXG5cCi1KYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIFN1biBNaWNyb3N5c3RlbXMsIEluYy4gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC5cbgotIyMjIyMjIyMjIyMgZW5kIG9mIGxpY2Vuc2UgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvZmVhdHVyZS54bWwgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvZmVhdHVyZS54bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDUwOWY3NjQuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL2ZlYXR1cmUueG1sCisrKyAvZGV2L251bGwKQEAgLTEsOTcgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxmZWF0dXJlCi0gICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LmZlYXR1cmUiCi0gICAgICBsYWJlbD0iJWZlYXR1cmVOYW1lIgotICAgICAgdmVyc2lvbj0iMi4yLjAucXVhbGlmaWVyIgotICAgICAgcHJvdmlkZXItbmFtZT0iJXByb3ZpZGVyTmFtZSIKLSAgICAgIGltYWdlPSJlY2xpcHNlX3VwZGF0ZV8xMjAuanBnIj4KLQotICAgPGRlc2NyaXB0aW9uPgotICAgICAgJWRlc2NyaXB0aW9uCi0gICA8L2Rlc2NyaXB0aW9uPgotCi0gICA8Y29weXJpZ2h0PgotICAgICAgJWNvcHlyaWdodAotICAgPC9jb3B5cmlnaHQ+Ci0KLSAgIDxsaWNlbnNlIHVybD0ibGljZW5zZS5odG1sIj4KLSAgICAgICVsaWNlbnNlCi0gICA8L2xpY2Vuc2U+Ci0KLSAgIDx1cmw+Ci0gICAgICA8dXBkYXRlIGxhYmVsPSJXZWIgVG9vbHMgUGxhdGZvcm0gKFdUUCkgVXBkYXRlcyIgdXJsPSJodHRwOi8vZG93bmxvYWQuZWNsaXBzZS5vcmcvd2VidG9vbHMvdXBkYXRlcyIvPgotICAgICAgPGRpc2NvdmVyeSBsYWJlbD0iV2ViIFRvb2xzIFBsYXRmb3JtIChXVFApIFVwZGF0ZXMiIHVybD0iaHR0cDovL2Rvd25sb2FkLmVjbGlwc2Uub3JnL3dlYnRvb2xzL3VwZGF0ZXMiLz4KLSAgICAgIDxkaXNjb3ZlcnkgbGFiZWw9IkRhbGkgSmF2YSBQZXJzaXN0ZW5jZSBBUEkgVG9vbHMgKEpQQSkgVXBkYXRlcyIgdXJsPSJodHRwOi8vZG93bmxvYWQuZWNsaXBzZS5vcmcvd2VidG9vbHMvdXBkYXRlcy8iLz4KLSAgIDwvdXJsPgotCi0gICA8cGx1Z2luCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LnV0aWxpdHkiCi0gICAgICAgICBkb3dubG9hZC1zaXplPSIwIgotICAgICAgICAgaW5zdGFsbC1zaXplPSIwIgotICAgICAgICAgdmVyc2lvbj0iMC4wLjAiCi0gICAgICAgICB1bnBhY2s9ImZhbHNlIi8+Ci0KLSAgIDxwbHVnaW4KLSAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHQuZGIiCi0gICAgICAgICBkb3dubG9hZC1zaXplPSIwIgotICAgICAgICAgaW5zdGFsbC1zaXplPSIwIgotICAgICAgICAgdmVyc2lvbj0iMC4wLjAiCi0gICAgICAgICB1bnBhY2s9ImZhbHNlIi8+Ci0KLSAgIDxwbHVnaW4KLSAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHQuZGIudWkiCi0gICAgICAgICBkb3dubG9hZC1zaXplPSIwIgotICAgICAgICAgaW5zdGFsbC1zaXplPSIwIgotICAgICAgICAgdmVyc2lvbj0iMC4wLjAiCi0gICAgICAgICB1bnBhY2s9ImZhbHNlIi8+Ci0KLSAgIDxwbHVnaW4KLSAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHQuZ2VuIgotICAgICAgICAgZG93bmxvYWQtc2l6ZT0iMCIKLSAgICAgICAgIGluc3RhbGwtc2l6ZT0iMCIKLSAgICAgICAgIHZlcnNpb249IjAuMC4wIgotICAgICAgICAgdW5wYWNrPSJmYWxzZSIvPgotCi0gICA8cGx1Z2luCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LmNvcmUiCi0gICAgICAgICBkb3dubG9hZC1zaXplPSIwIgotICAgICAgICAgaW5zdGFsbC1zaXplPSIwIgotICAgICAgICAgdmVyc2lvbj0iMC4wLjAiCi0gICAgICAgICB1bnBhY2s9ImZhbHNlIi8+Ci0KLSAgIDxwbHVnaW4KLSAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHQudWkiCi0gICAgICAgICBkb3dubG9hZC1zaXplPSIwIgotICAgICAgICAgaW5zdGFsbC1zaXplPSIwIgotICAgICAgICAgdmVyc2lvbj0iMC4wLjAiCi0gICAgICAgICB1bnBhY2s9ImZhbHNlIi8+Ci0KLSAgIDxwbHVnaW4KLSAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIiCi0gICAgICAgICBkb3dubG9hZC1zaXplPSIwIgotICAgICAgICAgaW5zdGFsbC1zaXplPSIwIgotICAgICAgICAgdmVyc2lvbj0iMC4wLjAiCi0gICAgICAgICB1bnBhY2s9ImZhbHNlIi8+Ci0KLSAgIDxwbHVnaW4KLSAgICAgICAgIGlkPSJvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMiCi0gICAgICAgICBkb3dubG9hZC1zaXplPSIwIgotICAgICAgICAgaW5zdGFsbC1zaXplPSIwIgotICAgICAgICAgdmVyc2lvbj0iMC4wLjAiCi0gICAgICAgICB1bnBhY2s9ImZhbHNlIi8+Ci0KLSAgIDxwbHVnaW4KLSAgICAgICAgIGlkPSJvcmcuYXBhY2hlLmNvbW1vbnMubGFuZyIKLSAgICAgICAgIGRvd25sb2FkLXNpemU9IjAiCi0gICAgICAgICBpbnN0YWxsLXNpemU9IjAiCi0gICAgICAgICB2ZXJzaW9uPSIwLjAuMCIKLSAgICAgICAgIHVucGFjaz0iZmFsc2UiLz4KLQotICAgPHBsdWdpbgotICAgICAgICAgaWQ9Im9yZy5hcGFjaGUub3JvIgotICAgICAgICAgZG93bmxvYWQtc2l6ZT0iMCIKLSAgICAgICAgIGluc3RhbGwtc2l6ZT0iMCIKLSAgICAgICAgIHZlcnNpb249IjAuMC4wIgotICAgICAgICAgdW5wYWNrPSJmYWxzZSIvPgotCi08L2ZlYXR1cmU+CmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvbGljZW5zZS5odG1sIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL2xpY2Vuc2UuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZmM3NzM3Mi4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvbGljZW5zZS5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsOTggKzAsMCBAQAotPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEgVHJhbnNpdGlvbmFsLy9FTiIgImh0dHA6Ly93d3cudzNjLm9yZy9UUi8xOTk5L1JFQy1odG1sNDAxLTE5OTkxMjI0L2xvb3NlLmR0ZCI+Ci08IS0tIHNhdmVkIGZyb20gdXJsPSgwMDQ0KWh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsL25vdGljZS5odG1sIC0tPgotPEhUTUw+PEhFQUQ+PFRJVExFPkVjbGlwc2Uub3JnIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9USVRMRT4KLTxNRVRBIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4KLTxNRVRBIGNvbnRlbnQ9Ik1TSFRNTCA2LjAwLjI4MDAuMTQ3OSIgbmFtZT1HRU5FUkFUT1I+PC9IRUFEPgotPEJPRFkgbGFuZz1FTi1VUyB2TGluaz1wdXJwbGUgbGluaz1ibHVlPgotPEgyPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvSDI+Ci08UD5KdW5lIDA2LCAyMDA3PC9QPgotPEgzPlVzYWdlIE9mIENvbnRlbnQ8L0gzPgotPFA+VEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIAotQU5EL09SIE9USEVSIE1BVEVSSUFMUyBGT1IgT1BFTiBTT1VSQ0UgUFJPSkVDVFMgKENPTExFQ1RJVkVMWSAiQ09OVEVOVCIpLiBVU0UgT0YgCi1USEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSAKLVRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIAotQkVMT1cuIEJZIFVTSU5HIFRIRSBDT05URU5ULCBZT1UgQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCAKLUJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSAKLUFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSAKLUFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIAotTUFZIE5PVCBVU0UgVEhFIENPTlRFTlQuPC9QPgotPEgzPkFwcGxpY2FibGUgTGljZW5zZXM8L0gzPgotPFA+VW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIAotRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIAotUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKCJFUEwiKS4gQSBjb3B5IG9mIHRoZSBFUEwgaXMgcHJvdmlkZWQgd2l0aCB0aGlzIAotQ29udGVudCBhbmQgaXMgYWxzbyBhdmFpbGFibGUgYXQgPEEgCi1ocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L0E+LiAKLUZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAiUHJvZ3JhbSIgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvUD4KLTxQPkNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLCAKLWRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2Uub3JnIENWUyByZXBvc2l0b3J5IAotKCJSZXBvc2l0b3J5IikgaW4gQ1ZTIG1vZHVsZXMgKCJNb2R1bGVzIikgYW5kIG1hZGUgYXZhaWxhYmxlIGFzIGRvd25sb2FkYWJsZSAKLWFyY2hpdmVzICgiRG93bmxvYWRzIikuPC9QPgotPFA+Q29udGVudCBtYXkgYmUgYXBwb3J0aW9uZWQgaW50byBwbHVnLWlucyAoIlBsdWctaW5zIiksIHBsdWctaW4gZnJhZ21lbnRzIAotKCJGcmFnbWVudHMiKSwgYW5kIGZlYXR1cmVzICgiRmVhdHVyZXMiKS4gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIAotUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhbmQgYXNzb2NpYXRlZCBtYXRlcmlhbC4gRmlsZXMgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgCi1jb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyAKLWFzc29jaWF0ZWQgd2l0aCBhIEZlYXR1cmUuIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgYXJlIGxvY2F0ZWQgaW4gZGlyZWN0b3JpZXMgCi1uYW1lZCAicGx1Z2lucyIgYW5kIEZlYXR1cmVzIGFyZSBsb2NhdGVkIGluIGRpcmVjdG9yaWVzIG5hbWVkICJmZWF0dXJlcyIuPC9QPgotPFA+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIEZpbGVzIG5hbWVkIAotImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgCi1GZWF0dXJlcy48L1A+Ci08UD5UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlIGNvbnRhaW5lZCAKLWluIGZpbGVzIG5hbWVkICJhYm91dC5odG1sIiAoIkFib3V0cyIpLiBUaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIAotRmVhdHVyZXMgYW5kIEluY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgImxpY2Vuc2UuaHRtbCIgCi0oIkZlYXR1cmUgTGljZW5zZXMiKS4gQWJvdXRzIGFuZCBGZWF0dXJlIExpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSAKLWRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZSBpbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIAotbG9jYXRpb25zOjwvUD4KLTxVTD4KLSAgPExJPlRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeSAKLSAgPExJPlBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzIAotICA8TEk+U3ViZGlyZWN0b3JpZXMgb2YgdGhlIGRpcmVjdG9yeSBuYW1lZCAic3JjIiBvZiBjZXJ0YWluIFBsdWctaW5zIAotICA8TEk+RmVhdHVyZSBkaXJlY3RvcmllcyA8L0xJPjwvVUw+Ci08UD5Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgCi11c2luZyB0aGUgRWNsaXBzZSBVcGRhdGUgTWFuYWdlciwgeW91IG11c3QgYWdyZWUgdG8gYSBsaWNlbnNlICgiRmVhdHVyZSBVcGRhdGUgCi1MaWNlbnNlIikgZHVyaW5nIHRoZSBpbnN0YWxsYXRpb24gcHJvY2Vzcy4gSWYgdGhlIEZlYXR1cmUgY29udGFpbnMgSW5jbHVkZWQgCi1GZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdSB3aXRoIHRoZSB0ZXJtcyAKLWFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IgaW5mb3JtIHlvdSB3aGVyZSB5b3UgY2FuIAotbG9jYXRlIHRoZW0uIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSBmb3VuZCBpbiB0aGUgImxpY2Vuc2UiIHByb3BlcnR5IG9mIAotZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIuIFN1Y2ggQWJvdXRzLCBGZWF0dXJlIExpY2Vuc2VzIGFuZCBGZWF0dXJlIAotVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgCi1hbmQgY29uZGl0aW9ucykgdGhhdCBnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbiB0aGF0IAotZGlyZWN0b3J5LjwvUD4KLTxQPlRIRSBBQk9VVFMsIEZFQVRVUkUgTElDRU5TRVMgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUiBUTyBUSEUgRVBMIAotT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLiBTT01FIE9GIFRIRVNFIAotT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTo8L1A+Ci08VUw+Ci0gIDxMST5Db21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sPC9BPikgCi0KLSAgPExJPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRSI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0U8L0E+KSAKLQotICA8TEk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMCI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wPC9BPikgCi0KLSAgPExJPklCTSBQdWJsaWMgTGljZW5zZSAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2RldmVsb3BlcndvcmtzL29wZW5zb3VyY2UvbGljZW5zZTEwLmh0bWwiPmh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sPC9BPikgCi0KLSAgPExJPk1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbCI+aHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWw8L0E+KSAKLQotICA8TEk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWwiPmh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbDwvQT4pIAotICA8L0xJPgotICAKLSAgPExJPkNvbW1vbiBEZXZlbG9wbWVudCBhbmQgRGlzdHJpYnV0aW9uIExpY2Vuc2UgKENEREwpIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuc3VuLmNvbS9jZGRsL2NkZGwuaHRtbCI+aHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sKTwvQT4KLSAgPC9MST4KLTwvVUw+Ci08UD5JVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCBDT05ESVRJT05TIFBSSU9SIAotVE8gVVNFIE9GIFRIRSBDT05URU5ULiBJZiBubyBBYm91dCwgRmVhdHVyZSBMaWNlbnNlIG9yIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2UgaXMgCi1wcm92aWRlZCwgcGxlYXNlIGNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgCi1jb25kaXRpb25zIGdvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC48L1A+Ci08SDM+Q3J5cHRvZ3JhcGh5PC9IMz4KLTxQPkNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZSAKLWN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSwgYW5kL29yIAotcmUtZXhwb3J0IHRvIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFIHVzaW5nIGFueSAKLWVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsIHJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyAKLWNvbmNlcm5pbmcgdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgb3IgdXNlLCBhbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIAotdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLjwvUD48L0JPRFk+PC9IVE1MPgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2Fib3V0Lmh0bWwgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvYWJvdXQuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDQ5MTZkZi4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvYWJvdXQuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDI3ICswLDAgQEAKLTwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAvL0VOIj4KLTxodG1sPgotPGhlYWQ+Ci08dGl0bGU+QWJvdXQ8L3RpdGxlPgotPG1ldGEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiPgotPC9oZWFkPgotPGJvZHkgbGFuZz0iRU4tVVMiPgotPGgyPkFib3V0IFRoaXMgQ29udGVudDwvaDI+Ci0KLTxwPkp1bmUgMDYsIDIwMDc8L3A+CQotPGgzPkxpY2Vuc2U8L2gzPgotCi08cD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBhbGwgY29udGVudCBpbiB0aGlzIHBsdWctaW4gKCZxdW90O0NvbnRlbnQmcXVvdDspLiAgVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQgYmVsb3csIHRoZSBDb250ZW50IGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlCi1FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wICgmcXVvdDtFUEwmcXVvdDspLiAgQSBjb3B5IG9mIHRoZSBFUEwgaXMgYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT4uCi1Gb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgJnF1b3Q7UHJvZ3JhbSZxdW90OyB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9wPgotCi08cD5JZiB5b3UgZGlkIG5vdCByZWNlaXZlIHRoaXMgQ29udGVudCBkaXJlY3RseSBmcm9tIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24sIHRoZSBDb250ZW50IGlzIGJlaW5nIHJlZGlzdHJpYnV0ZWQgYnkgYW5vdGhlciBwYXJ0eSAoJnF1b3Q7UmVkaXN0cmlidXRvciZxdW90OykgYW5kIGRpZmZlcmVudCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBtYXkKLWFwcGx5IHRvIHlvdXIgdXNlIG9mIGFueSBvYmplY3QgY29kZSBpbiB0aGUgQ29udGVudC4gIENoZWNrIHRoZSBSZWRpc3RyaWJ1dG9yJ3MgbGljZW5zZSB0aGF0IHdhcyBwcm92aWRlZCB3aXRoIHRoZSBDb250ZW50LiAgSWYgbm8gc3VjaCBsaWNlbnNlIGV4aXN0cywgY29udGFjdCB0aGUgUmVkaXN0cmlidXRvci4gIFVubGVzcyBvdGhlcndpc2UKLWluZGljYXRlZCBiZWxvdywgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFUEwgc3RpbGwgYXBwbHkgdG8gYW55IHNvdXJjZSBjb2RlIGluIHRoZSBDb250ZW50LjwvcD4KLQotPGgzPlNvdXJjZSBDb2RlPC9oMz4KLTxwPlRoaXMgcGx1Zy1pbiBjb250YWlucyBzb3VyY2UgY29kZSB6aXAgZmlsZXMgKCZxdW90O1NvdXJjZSBaaXBzJnF1b3Q7KSB0aGF0IGNvcnJlc3BvbmQgdG8gYmluYXJ5IGNvbnRlbnQgaW4gb3RoZXIgcGx1Zy1pbnMuIFRoZXNlIFNvdXJjZSBaaXBzIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciBkaWZmZXJlbnQgbGljZW5zZQotYWdyZWVtZW50cyBhbmQvb3Igbm90aWNlcy4gRGV0YWlscyBhYm91dCB0aGVzZSBsaWNlbnNlIGFncmVlbWVudHMgYW5kIG5vdGljZXMgYXJlIGNvbnRhaW5lZCBpbiAmcXVvdDthYm91dC5odG1sJnF1b3Q7IGZpbGVzICgmcXVvdDtBYm91dHMmcXVvdDspIGxvY2F0ZWQgaW4gc3ViLWRpcmVjdG9yaWVzIGluIHRoZQotc3JjLyBkaXJlY3Rvcnkgb2YgdGhpcyBwbHVnLWluLiBTdWNoIEFib3V0cyBnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIFNvdXJjZSBaaXBzIGluIHRoYXQgZGlyZWN0b3J5LCBub3QgdGhlIEVQTC48L3A+Ci0KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9hYm91dC5pbmkgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvYWJvdXQuaW5pCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyZGVlMzZhLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9hYm91dC5pbmkKKysrIC9kZXYvbnVsbApAQCAtMSwzMSArMCwwIEBACi0jIGFib3V0LmluaQotIyBjb250YWlucyBpbmZvcm1hdGlvbiBhYm91dCBhIGZlYXR1cmUKLSMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKLSMgIiVrZXkiIGFyZSBleHRlcm5hbGl6ZWQgc3RyaW5ncyBkZWZpbmVkIGluIGFib3V0LnByb3BlcnRpZXMKLSMgVGhpcyBmaWxlIGRvZXMgbm90IG5lZWQgdG8gYmUgdHJhbnNsYXRlZC4KLQotIyBQcm9wZXJ0eSAiYWJvdXRUZXh0IiBjb250YWlucyBibHVyYiBmb3IgIkFib3V0IiBkaWFsb2cgKHRyYW5zbGF0ZWQpCi1hYm91dFRleHQ9JWJsdXJiCi0KLSMgUHJvcGVydHkgIndpbmRvd0ltYWdlIiBjb250YWlucyBwYXRoIHRvIHdpbmRvdyBpY29uICgxNngxNikKLSMgbmVlZGVkIGZvciBwcmltYXJ5IGZlYXR1cmVzIG9ubHkKLQotIyBQcm9wZXJ0eSAiZmVhdHVyZUltYWdlIiBjb250YWlucyBwYXRoIHRvIGZlYXR1cmUgaW1hZ2UgKDMyeDMyKQotZmVhdHVyZUltYWdlPWVjbGlwc2UzMi5naWYKLQotIyBQcm9wZXJ0eSAiYWJvdXRJbWFnZSIgY29udGFpbnMgcGF0aCB0byBwcm9kdWN0IGltYWdlICg1MDB4MzMwIG9yIDExNXgxNjQpCi0jIG5lZWRlZCBmb3IgcHJpbWFyeSBmZWF0dXJlcyBvbmx5Ci0KLSMgUHJvcGVydHkgImFwcE5hbWUiIGNvbnRhaW5zIG5hbWUgb2YgdGhlIGFwcGxpY2F0aW9uIChub3QgdHJhbnNsYXRlZCkKLSMgbmVlZGVkIGZvciBwcmltYXJ5IGZlYXR1cmVzIG9ubHkKLQotIyBQcm9wZXJ0eSAid2VsY29tZVBhZ2UiIGNvbnRhaW5zIHBhdGggdG8gd2VsY29tZSBwYWdlIChzcGVjaWFsIFhNTC1iYXNlZCBmb3JtYXQpCi0jIG9wdGlvbmFsCi0KLSMgUHJvcGVydHkgIndlbGNvbWVQZXJzcGVjdGl2ZSIgY29udGFpbnMgdGhlIGlkIG9mIHRoZSBwZXJzcGVjdGl2ZSBpbiB3aGljaCB0aGUKLSMgd2VsY29tZSBwYWdlIGlzIHRvIGJlIG9wZW5lZC4KLSMgb3B0aW9uYWwKLQotCi0KLQpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2Fib3V0Lm1hcHBpbmdzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2Fib3V0Lm1hcHBpbmdzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhMjgzOTBhLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9hYm91dC5tYXBwaW5ncworKysgL2Rldi9udWxsCkBAIC0xLDYgKzAsMCBAQAotIyBhYm91dC5tYXBwaW5ncwotIyBjb250YWlucyBmaWxsLWlucyBmb3IgYWJvdXQucHJvcGVydGllcwotIyBqYXZhLmlvLlByb3BlcnRpZXMgZmlsZSAoSVNPIDg4NTktMSB3aXRoICJcIiBlc2NhcGVzKQotIyBUaGlzIGZpbGUgZG9lcyBub3QgbmVlZCB0byBiZSB0cmFuc2xhdGVkLgotCi0wPUBidWlsZEAKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9hYm91dC5wcm9wZXJ0aWVzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2Fib3V0LnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDE1NDE3ZmYuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2Fib3V0LnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwyNiArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgYWJvdXQucHJvcGVydGllcwotIyBjb250YWlucyBleHRlcm5hbGl6ZWQgc3RyaW5ncyBmb3IgYWJvdXQuaW5pCi0jIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCi0jIGZpbGwtaW5zIGFyZSBzdXBwbGllZCBieSBhYm91dC5tYXBwaW5ncwotIyBUaGlzIGZpbGUgc2hvdWxkIGJlIHRyYW5zbGF0ZWQuCi0jCi0jIERvIG5vdCB0cmFuc2xhdGUgYW55IHZhbHVlcyBzdXJyb3VuZGVkIGJ5IHt9Ci0KLWJsdXJiPURhbGkgSmF2YSBQZXJzaXN0ZW5jZSBBUEkgKEpQQSkgVG9vbHMgU291cmNlXG5cCi1cblwKLVZlcnNpb246IHtmZWF0dXJlVmVyc2lvbn1cblwKLUJ1aWxkIGlkOiB7MH1cblwKLVxuXAotKGMpIENvcHlyaWdodCBFY2xpcHNlIGNvbnRyaWJ1dG9ycyBhbmQgb3RoZXJzIDIwMDguICBBbGwgcmlnaHRzIHJlc2VydmVkLlxuXAotVmlzaXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy93ZWJ0b29scwotCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvYnVpbGQucHJvcGVydGllcyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9idWlsZC5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjZTk1MjliLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9idWlsZC5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTIgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDggT3JhY2xlLgotIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCi0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAotIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAotIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi1iaW4uaW5jbHVkZXMgPSBhYm91dC5odG1sLCBhYm91dC5pbmksIGFib3V0Lm1hcHBpbmdzLCBhYm91dC5wcm9wZXJ0aWVzLCBlY2xpcHNlMzIuZ2lmLCBwbHVnaW4ucHJvcGVydGllcywgcGx1Z2luLnhtbCwgc3JjLyoqLCBNRVRBLUlORi8KLXNvdXJjZVBsdWdpbiA9IHRydWUKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9lY2xpcHNlMzIuZ2lmIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2VjbGlwc2UzMi5naWYKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGU2YWQ3Y2MuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2VjbGlwc2UzMi5naWYKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvZWNsaXBzZTMyLnBuZyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9lY2xpcHNlMzIucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1MGFlNDlkLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9lY2xpcHNlMzIucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2VjbGlwc2VfdXBkYXRlXzEyMC5qcGcgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmZkZjcwOC4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9lcGwtdjEwLmh0bWwgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvZXBsLXYxMC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMjJhZDI5Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9lcGwtdjEwLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSwzMjggKzAsMCBAQAotPGh0bWwgeG1sbnM6bz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6b2ZmaWNlIgoteG1sbnM6dz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6d29yZCIKLXhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy9UUi9SRUMtaHRtbDQwIj4KLQotPGhlYWQ+Ci08bWV0YSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9d2luZG93cy0xMjUyIj4KLTxtZXRhIG5hbWU9UHJvZ0lkIGNvbnRlbnQ9V29yZC5Eb2N1bWVudD4KLTxtZXRhIG5hbWU9R2VuZXJhdG9yIGNvbnRlbnQ9Ik1pY3Jvc29mdCBXb3JkIDkiPgotPG1ldGEgbmFtZT1PcmlnaW5hdG9yIGNvbnRlbnQ9Ik1pY3Jvc29mdCBXb3JkIDkiPgotPGxpbmsgcmVsPUZpbGUtTGlzdAotaHJlZj0iLi9FY2xpcHNlJTIwRVBMJTIwMjAwM18xMV8xMCUyMEZpbmFsX2ZpbGVzL2ZpbGVsaXN0LnhtbCI+Ci08dGl0bGU+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIFZlcnNpb24gMS4wPC90aXRsZT4KLTwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDxvOkRvY3VtZW50UHJvcGVydGllcz4KLSAgPG86UmV2aXNpb24+MjwvbzpSZXZpc2lvbj4KLSAgPG86VG90YWxUaW1lPjM8L286VG90YWxUaW1lPgotICA8bzpDcmVhdGVkPjIwMDQtMDMtMDVUMjM6MDM6MDBaPC9vOkNyZWF0ZWQ+Ci0gIDxvOkxhc3RTYXZlZD4yMDA0LTAzLTA1VDIzOjAzOjAwWjwvbzpMYXN0U2F2ZWQ+Ci0gIDxvOlBhZ2VzPjQ8L286UGFnZXM+Ci0gIDxvOldvcmRzPjE2MjY8L286V29yZHM+Ci0gIDxvOkNoYXJhY3RlcnM+OTI3MDwvbzpDaGFyYWN0ZXJzPgotICAgPG86TGluZXM+Nzc8L286TGluZXM+Ci0gIDxvOlBhcmFncmFwaHM+MTg8L286UGFyYWdyYXBocz4KLSAgPG86Q2hhcmFjdGVyc1dpdGhTcGFjZXM+MTEzODQ8L286Q2hhcmFjdGVyc1dpdGhTcGFjZXM+Ci0gIDxvOlZlcnNpb24+OS40NDAyPC9vOlZlcnNpb24+Ci0gPC9vOkRvY3VtZW50UHJvcGVydGllcz4KLTwveG1sPjwhW2VuZGlmXS0tPjwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDx3OldvcmREb2N1bWVudD4KLSAgPHc6VHJhY2tSZXZpc2lvbnMvPgotIDwvdzpXb3JkRG9jdW1lbnQ+Ci08L3htbD48IVtlbmRpZl0tLT4KLTxzdHlsZT4KLTwhLS0KLSAvKiBGb250IERlZmluaXRpb25zICovCi1AZm9udC1mYWNlCi0Je2ZvbnQtZmFtaWx5OlRhaG9tYTsKLQlwYW5vc2UtMToyIDExIDYgNCAzIDUgNCA0IDIgNDsKLQltc28tZm9udC1jaGFyc2V0OjA7Ci0JbXNvLWdlbmVyaWMtZm9udC1mYW1pbHk6c3dpc3M7Ci0JbXNvLWZvbnQtcGl0Y2g6dmFyaWFibGU7Ci0JbXNvLWZvbnQtc2lnbmF0dXJlOjU1MzY3OTQ5NSAtMjE0NzQ4MzY0OCA4IDAgNjYwNDcgMDt9Ci0gLyogU3R5bGUgRGVmaW5pdGlvbnMgKi8KLXAuTXNvTm9ybWFsLCBsaS5Nc29Ob3JtYWwsIGRpdi5Nc29Ob3JtYWwKLQl7bXNvLXN0eWxlLXBhcmVudDoiIjsKLQltYXJnaW46MGluOwotCW1hcmdpbi1ib3R0b206LjAwMDFwdDsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjEyLjBwdDsKLQlmb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1wCi0Je21hcmdpbi1yaWdodDowaW47Ci0JbXNvLW1hcmdpbi10b3AtYWx0OmF1dG87Ci0JbXNvLW1hcmdpbi1ib3R0b20tYWx0OmF1dG87Ci0JbWFyZ2luLWxlZnQ6MGluOwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXAuQmFsbG9vblRleHQsIGxpLkJhbGxvb25UZXh0LCBkaXYuQmFsbG9vblRleHQKLQl7bXNvLXN0eWxlLW5hbWU6IkJhbGxvb24gVGV4dCI7Ci0JbWFyZ2luOjBpbjsKLQltYXJnaW4tYm90dG9tOi4wMDAxcHQ7Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZTo4LjBwdDsKLQlmb250LWZhbWlseTpUYWhvbWE7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotQHBhZ2UgU2VjdGlvbjEKLQl7c2l6ZTo4LjVpbiAxMS4waW47Ci0JbWFyZ2luOjEuMGluIDEuMjVpbiAxLjBpbiAxLjI1aW47Ci0JbXNvLWhlYWRlci1tYXJnaW46LjVpbjsKLQltc28tZm9vdGVyLW1hcmdpbjouNWluOwotCW1zby1wYXBlci1zb3VyY2U6MDt9Ci1kaXYuU2VjdGlvbjEKLQl7cGFnZTpTZWN0aW9uMTt9Ci0tLT4KLTwvc3R5bGU+Ci08L2hlYWQ+Ci0KLTxib2R5IGxhbmc9RU4tVVMgc3R5bGU9J3RhYi1pbnRlcnZhbDouNWluJz4KLQotPGRpdiBjbGFzcz1TZWN0aW9uMT4KLQotPHAgYWxpZ249Y2VudGVyIHN0eWxlPSd0ZXh0LWFsaWduOmNlbnRlcic+PGI+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIHYgMS4wPC9iPgotPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+VEhFIEFDQ09NUEFOWUlORyBQUk9HUkFNIElTIFBST1ZJREVEIFVOREVSCi1USEUgVEVSTVMgT0YgVEhJUyBFQ0xJUFNFIFBVQkxJQyBMSUNFTlNFICgmcXVvdDtBR1JFRU1FTlQmcXVvdDspLiBBTlkgVVNFLAotUkVQUk9EVUNUSU9OIE9SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBDT05TVElUVVRFUyBSRUNJUElFTlQnUyBBQ0NFUFRBTkNFCi1PRiBUSElTIEFHUkVFTUVOVC48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjEuIERFRklOSVRJT05TPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7Q29udHJpYnV0aW9uJnF1b3Q7IG1lYW5zOjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaW4gdGhlIGNhc2Ugb2YgdGhlIGluaXRpYWwgQ29udHJpYnV0b3IsIHRoZSBpbml0aWFsIGNvZGUgYW5kIGRvY3VtZW50YXRpb24KLWRpc3RyaWJ1dGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBhbmQ8YnIgY2xlYXI9bGVmdD4KLWIpIGluIHRoZSBjYXNlIG9mIGVhY2ggc3Vic2VxdWVudCBDb250cmlidXRvcjo8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pKQotY2hhbmdlcyB0byB0aGUgUHJvZ3JhbSwgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWkpCi1hZGRpdGlvbnMgdG8gdGhlIFByb2dyYW07PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+d2hlcmUKLXN1Y2ggY2hhbmdlcyBhbmQvb3IgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIG9yaWdpbmF0ZSBmcm9tIGFuZCBhcmUgZGlzdHJpYnV0ZWQKLWJ5IHRoYXQgcGFydGljdWxhciBDb250cmlidXRvci4gQSBDb250cmlidXRpb24gJ29yaWdpbmF0ZXMnIGZyb20gYSBDb250cmlidXRvcgotaWYgaXQgd2FzIGFkZGVkIHRvIHRoZSBQcm9ncmFtIGJ5IHN1Y2ggQ29udHJpYnV0b3IgaXRzZWxmIG9yIGFueW9uZSBhY3Rpbmcgb24KLXN1Y2ggQ29udHJpYnV0b3IncyBiZWhhbGYuIENvbnRyaWJ1dGlvbnMgZG8gbm90IGluY2x1ZGUgYWRkaXRpb25zIHRvIHRoZQotUHJvZ3JhbSB3aGljaDogKGkpIGFyZSBzZXBhcmF0ZSBtb2R1bGVzIG9mIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIGluIGNvbmp1bmN0aW9uCi13aXRoIHRoZSBQcm9ncmFtIHVuZGVyIHRoZWlyIG93biBsaWNlbnNlIGFncmVlbWVudCwgYW5kIChpaSkgYXJlIG5vdCBkZXJpdmF0aXZlCi13b3JrcyBvZiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0NvbnRyaWJ1dG9yJnF1b3Q7IG1lYW5zIGFueSBwZXJzb24gb3IKLWVudGl0eSB0aGF0IGRpc3RyaWJ1dGVzIHRoZSBQcm9ncmFtLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7TGljZW5zZWQgUGF0ZW50cyAmcXVvdDsgbWVhbiBwYXRlbnQKLWNsYWltcyBsaWNlbnNhYmxlIGJ5IGEgQ29udHJpYnV0b3Igd2hpY2ggYXJlIG5lY2Vzc2FyaWx5IGluZnJpbmdlZCBieSB0aGUgdXNlCi1vciBzYWxlIG9mIGl0cyBDb250cmlidXRpb24gYWxvbmUgb3Igd2hlbiBjb21iaW5lZCB3aXRoIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7UHJvZ3JhbSZxdW90OyBtZWFucyB0aGUgQ29udHJpYnV0aW9ucwotZGlzdHJpYnV0ZWQgaW4gYWNjb3JkYW5jZSB3aXRoIHRoaXMgQWdyZWVtZW50Ljwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7UmVjaXBpZW50JnF1b3Q7IG1lYW5zIGFueW9uZSB3aG8KLXJlY2VpdmVzIHRoZSBQcm9ncmFtIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBpbmNsdWRpbmcgYWxsIENvbnRyaWJ1dG9ycy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjIuIEdSQU5UIE9GIFJJR0hUUzwvc3Bhbj48L2I+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLVN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50Ci1hIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwgcm95YWx0eS1mcmVlIGNvcHlyaWdodCBsaWNlbnNlIHRvPHNwYW4KLXN0eWxlPSdjb2xvcjpyZWQnPiA8L3NwYW4+cmVwcm9kdWNlLCBwcmVwYXJlIGRlcml2YXRpdmUgd29ya3Mgb2YsIHB1YmxpY2x5Ci1kaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBkaXN0cmlidXRlIGFuZCBzdWJsaWNlbnNlIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaAotQ29udHJpYnV0b3IsIGlmIGFueSwgYW5kIHN1Y2ggZGVyaXZhdGl2ZSB3b3JrcywgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlCi1mb3JtLjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpCi1TdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzCi1SZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsPHNwYW4gc3R5bGU9J2NvbG9yOmdyZWVuJz4gPC9zcGFuPnJveWFsdHktZnJlZQotcGF0ZW50IGxpY2Vuc2UgdW5kZXIgTGljZW5zZWQgUGF0ZW50cyB0byBtYWtlLCB1c2UsIHNlbGwsIG9mZmVyIHRvIHNlbGwsIGltcG9ydAotYW5kIG90aGVyd2lzZSB0cmFuc2ZlciB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgaW4gc291cmNlCi1jb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLiBUaGlzIHBhdGVudCBsaWNlbnNlIHNoYWxsIGFwcGx5IHRvIHRoZSBjb21iaW5hdGlvbgotb2YgdGhlIENvbnRyaWJ1dGlvbiBhbmQgdGhlIFByb2dyYW0gaWYsIGF0IHRoZSB0aW1lIHRoZSBDb250cmlidXRpb24gaXMgYWRkZWQKLWJ5IHRoZSBDb250cmlidXRvciwgc3VjaCBhZGRpdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGNhdXNlcyBzdWNoIGNvbWJpbmF0aW9uCi10byBiZSBjb3ZlcmVkIGJ5IHRoZSBMaWNlbnNlZCBQYXRlbnRzLiBUaGUgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgbm90IGFwcGx5IHRvCi1hbnkgb3RoZXIgY29tYmluYXRpb25zIHdoaWNoIGluY2x1ZGUgdGhlIENvbnRyaWJ1dGlvbi4gTm8gaGFyZHdhcmUgcGVyIHNlIGlzCi1saWNlbnNlZCBoZXJldW5kZXIuIDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmMpCi1SZWNpcGllbnQgdW5kZXJzdGFuZHMgdGhhdCBhbHRob3VnaCBlYWNoIENvbnRyaWJ1dG9yIGdyYW50cyB0aGUgbGljZW5zZXMgdG8gaXRzCi1Db250cmlidXRpb25zIHNldCBmb3J0aCBoZXJlaW4sIG5vIGFzc3VyYW5jZXMgYXJlIHByb3ZpZGVkIGJ5IGFueSBDb250cmlidXRvcgotdGhhdCB0aGUgUHJvZ3JhbSBkb2VzIG5vdCBpbmZyaW5nZSB0aGUgcGF0ZW50IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQotcmlnaHRzIG9mIGFueSBvdGhlciBlbnRpdHkuIEVhY2ggQ29udHJpYnV0b3IgZGlzY2xhaW1zIGFueSBsaWFiaWxpdHkgdG8gUmVjaXBpZW50Ci1mb3IgY2xhaW1zIGJyb3VnaHQgYnkgYW55IG90aGVyIGVudGl0eSBiYXNlZCBvbiBpbmZyaW5nZW1lbnQgb2YgaW50ZWxsZWN0dWFsCi1wcm9wZXJ0eSByaWdodHMgb3Igb3RoZXJ3aXNlLiBBcyBhIGNvbmRpdGlvbiB0byBleGVyY2lzaW5nIHRoZSByaWdodHMgYW5kCi1saWNlbnNlcyBncmFudGVkIGhlcmV1bmRlciwgZWFjaCBSZWNpcGllbnQgaGVyZWJ5IGFzc3VtZXMgc29sZSByZXNwb25zaWJpbGl0eQotdG8gc2VjdXJlIGFueSBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG5lZWRlZCwgaWYgYW55LiBGb3IgZXhhbXBsZSwKLWlmIGEgdGhpcmQgcGFydHkgcGF0ZW50IGxpY2Vuc2UgaXMgcmVxdWlyZWQgdG8gYWxsb3cgUmVjaXBpZW50IHRvIGRpc3RyaWJ1dGUKLXRoZSBQcm9ncmFtLCBpdCBpcyBSZWNpcGllbnQncyByZXNwb25zaWJpbGl0eSB0byBhY3F1aXJlIHRoYXQgbGljZW5zZSBiZWZvcmUKLWRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbS48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5kKQotRWFjaCBDb250cmlidXRvciByZXByZXNlbnRzIHRoYXQgdG8gaXRzIGtub3dsZWRnZSBpdCBoYXMgc3VmZmljaWVudCBjb3B5cmlnaHQKLXJpZ2h0cyBpbiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIHRvIGdyYW50IHRoZSBjb3B5cmlnaHQgbGljZW5zZSBzZXQgZm9ydGggaW4KLXRoaXMgQWdyZWVtZW50LiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+My4gUkVRVUlSRU1FTlRTPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+QSBDb250cmlidXRvciBtYXkgY2hvb3NlIHRvIGRpc3RyaWJ1dGUgdGhlCi1Qcm9ncmFtIGluIG9iamVjdCBjb2RlIGZvcm0gdW5kZXIgaXRzIG93biBsaWNlbnNlIGFncmVlbWVudCwgcHJvdmlkZWQgdGhhdDo8L3NwYW4+Ci08L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pdCBjb21wbGllcyB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudDsgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikKLWl0cyBsaWNlbnNlIGFncmVlbWVudDo8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pKQotZWZmZWN0aXZlbHkgZGlzY2xhaW1zIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCB3YXJyYW50aWVzIGFuZAotY29uZGl0aW9ucywgZXhwcmVzcyBhbmQgaW1wbGllZCwgaW5jbHVkaW5nIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiB0aXRsZQotYW5kIG5vbi1pbmZyaW5nZW1lbnQsIGFuZCBpbXBsaWVkIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiBtZXJjaGFudGFiaWxpdHkKLWFuZCBmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZTsgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWkpCi1lZmZlY3RpdmVseSBleGNsdWRlcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgbGlhYmlsaXR5IGZvciBkYW1hZ2VzLAotaW5jbHVkaW5nIGRpcmVjdCwgaW5kaXJlY3QsIHNwZWNpYWwsIGluY2lkZW50YWwgYW5kIGNvbnNlcXVlbnRpYWwgZGFtYWdlcywgc3VjaAotYXMgbG9zdCBwcm9maXRzOyA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paWkpCi1zdGF0ZXMgdGhhdCBhbnkgcHJvdmlzaW9ucyB3aGljaCBkaWZmZXIgZnJvbSB0aGlzIEFncmVlbWVudCBhcmUgb2ZmZXJlZCBieSB0aGF0Ci1Db250cmlidXRvciBhbG9uZSBhbmQgbm90IGJ5IGFueSBvdGhlciBwYXJ0eTsgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aXYpCi1zdGF0ZXMgdGhhdCBzb3VyY2UgY29kZSBmb3IgdGhlIFByb2dyYW0gaXMgYXZhaWxhYmxlIGZyb20gc3VjaCBDb250cmlidXRvciwgYW5kCi1pbmZvcm1zIGxpY2Vuc2VlcyBob3cgdG8gb2J0YWluIGl0IGluIGEgcmVhc29uYWJsZSBtYW5uZXIgb24gb3IgdGhyb3VnaCBhCi1tZWRpdW0gY3VzdG9tYXJpbHkgdXNlZCBmb3Igc29mdHdhcmUgZXhjaGFuZ2UuPHNwYW4gc3R5bGU9J2NvbG9yOmJsdWUnPiA8L3NwYW4+PC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPldoZW4gdGhlIFByb2dyYW0gaXMgbWFkZSBhdmFpbGFibGUgaW4gc291cmNlCi1jb2RlIGZvcm06PC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pdCBtdXN0IGJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoaXMgQWdyZWVtZW50OyBhbmQgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikgYQotY29weSBvZiB0aGlzIEFncmVlbWVudCBtdXN0IGJlIGluY2x1ZGVkIHdpdGggZWFjaCBjb3B5IG9mIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Q29udHJpYnV0b3JzIG1heSBub3QgcmVtb3ZlIG9yIGFsdGVyIGFueQotY29weXJpZ2h0IG5vdGljZXMgY29udGFpbmVkIHdpdGhpbiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVhY2ggQ29udHJpYnV0b3IgbXVzdCBpZGVudGlmeSBpdHNlbGYgYXMgdGhlCi1vcmlnaW5hdG9yIG9mIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgaW4gYSBtYW5uZXIgdGhhdCByZWFzb25hYmx5IGFsbG93cwotc3Vic2VxdWVudCBSZWNpcGllbnRzIHRvIGlkZW50aWZ5IHRoZSBvcmlnaW5hdG9yIG9mIHRoZSBDb250cmlidXRpb24uIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz40LiBDT01NRVJDSUFMIERJU1RSSUJVVElPTjwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkNvbW1lcmNpYWwgZGlzdHJpYnV0b3JzIG9mIHNvZnR3YXJlIG1heQotYWNjZXB0IGNlcnRhaW4gcmVzcG9uc2liaWxpdGllcyB3aXRoIHJlc3BlY3QgdG8gZW5kIHVzZXJzLCBidXNpbmVzcyBwYXJ0bmVycwotYW5kIHRoZSBsaWtlLiBXaGlsZSB0aGlzIGxpY2Vuc2UgaXMgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY29tbWVyY2lhbCB1c2UKLW9mIHRoZSBQcm9ncmFtLCB0aGUgQ29udHJpYnV0b3Igd2hvIGluY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbAotcHJvZHVjdCBvZmZlcmluZyBzaG91bGQgZG8gc28gaW4gYSBtYW5uZXIgd2hpY2ggZG9lcyBub3QgY3JlYXRlIHBvdGVudGlhbAotbGlhYmlsaXR5IGZvciBvdGhlciBDb250cmlidXRvcnMuIFRoZXJlZm9yZSwgaWYgYSBDb250cmlidXRvciBpbmNsdWRlcyB0aGUKLVByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIHN1Y2ggQ29udHJpYnV0b3IgKCZxdW90O0NvbW1lcmNpYWwKLUNvbnRyaWJ1dG9yJnF1b3Q7KSBoZXJlYnkgYWdyZWVzIHRvIGRlZmVuZCBhbmQgaW5kZW1uaWZ5IGV2ZXJ5IG90aGVyCi1Db250cmlidXRvciAoJnF1b3Q7SW5kZW1uaWZpZWQgQ29udHJpYnV0b3ImcXVvdDspIGFnYWluc3QgYW55IGxvc3NlcywgZGFtYWdlcyBhbmQKLWNvc3RzIChjb2xsZWN0aXZlbHkgJnF1b3Q7TG9zc2VzJnF1b3Q7KSBhcmlzaW5nIGZyb20gY2xhaW1zLCBsYXdzdWl0cyBhbmQgb3RoZXIKLWxlZ2FsIGFjdGlvbnMgYnJvdWdodCBieSBhIHRoaXJkIHBhcnR5IGFnYWluc3QgdGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIHRvCi10aGUgZXh0ZW50IGNhdXNlZCBieSB0aGUgYWN0cyBvciBvbWlzc2lvbnMgb2Ygc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluCi1jb25uZWN0aW9uIHdpdGggaXRzIGRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdAotb2ZmZXJpbmcuIFRoZSBvYmxpZ2F0aW9ucyBpbiB0aGlzIHNlY3Rpb24gZG8gbm90IGFwcGx5IHRvIGFueSBjbGFpbXMgb3IgTG9zc2VzCi1yZWxhdGluZyB0byBhbnkgYWN0dWFsIG9yIGFsbGVnZWQgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGluZnJpbmdlbWVudC4gSW4gb3JkZXIKLXRvIHF1YWxpZnksIGFuIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG11c3Q6IGEpIHByb21wdGx5IG5vdGlmeSB0aGUgQ29tbWVyY2lhbAotQ29udHJpYnV0b3IgaW4gd3JpdGluZyBvZiBzdWNoIGNsYWltLCBhbmQgYikgYWxsb3cgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IKLXRvIGNvbnRyb2wsIGFuZCBjb29wZXJhdGUgd2l0aCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiwgdGhlIGRlZmVuc2UgYW5kCi1hbnkgcmVsYXRlZCBzZXR0bGVtZW50IG5lZ290aWF0aW9ucy4gVGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG1heSBwYXJ0aWNpcGF0ZQotaW4gYW55IHN1Y2ggY2xhaW0gYXQgaXRzIG93biBleHBlbnNlLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Rm9yIGV4YW1wbGUsIGEgQ29udHJpYnV0b3IgbWlnaHQgaW5jbHVkZSB0aGUKLVByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIFByb2R1Y3QgWC4gVGhhdCBDb250cmlidXRvciBpcyB0aGVuIGEKLUNvbW1lcmNpYWwgQ29udHJpYnV0b3IuIElmIHRoYXQgQ29tbWVyY2lhbCBDb250cmlidXRvciB0aGVuIG1ha2VzIHBlcmZvcm1hbmNlCi1jbGFpbXMsIG9yIG9mZmVycyB3YXJyYW50aWVzIHJlbGF0ZWQgdG8gUHJvZHVjdCBYLCB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kCi13YXJyYW50aWVzIGFyZSBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IncyByZXNwb25zaWJpbGl0eSBhbG9uZS4gVW5kZXIgdGhpcwotc2VjdGlvbiwgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3Igd291bGQgaGF2ZSB0byBkZWZlbmQgY2xhaW1zIGFnYWluc3QgdGhlCi1vdGhlciBDb250cmlidXRvcnMgcmVsYXRlZCB0byB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMsIGFuZCBpZiBhCi1jb3VydCByZXF1aXJlcyBhbnkgb3RoZXIgQ29udHJpYnV0b3IgdG8gcGF5IGFueSBkYW1hZ2VzIGFzIGEgcmVzdWx0LCB0aGUKLUNvbW1lcmNpYWwgQ29udHJpYnV0b3IgbXVzdCBwYXkgdGhvc2UgZGFtYWdlcy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjUuIE5PIFdBUlJBTlRZPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUwotQUdSRUVNRU5ULCBUSEUgUFJPR1JBTSBJUyBQUk9WSURFRCBPTiBBTiAmcXVvdDtBUyBJUyZxdW90OyBCQVNJUywgV0lUSE9VVAotV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBFSVRIRVIgRVhQUkVTUyBPUiBJTVBMSUVEIElOQ0xVRElORywKLVdJVEhPVVQgTElNSVRBVElPTiwgQU5ZIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBUSVRMRSwgTk9OLUlORlJJTkdFTUVOVCwKLU1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gRWFjaCBSZWNpcGllbnQgaXMgc29sZWx5Ci1yZXNwb25zaWJsZSBmb3IgZGV0ZXJtaW5pbmcgdGhlIGFwcHJvcHJpYXRlbmVzcyBvZiB1c2luZyBhbmQgZGlzdHJpYnV0aW5nIHRoZQotUHJvZ3JhbSBhbmQgYXNzdW1lcyBhbGwgcmlza3MgYXNzb2NpYXRlZCB3aXRoIGl0cyBleGVyY2lzZSBvZiByaWdodHMgdW5kZXIgdGhpcwotQWdyZWVtZW50ICwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgcmlza3MgYW5kIGNvc3RzIG9mIHByb2dyYW0gZXJyb3JzLAotY29tcGxpYW5jZSB3aXRoIGFwcGxpY2FibGUgbGF3cywgZGFtYWdlIHRvIG9yIGxvc3Mgb2YgZGF0YSwgcHJvZ3JhbXMgb3IKLWVxdWlwbWVudCwgYW5kIHVuYXZhaWxhYmlsaXR5IG9yIGludGVycnVwdGlvbiBvZiBvcGVyYXRpb25zLiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Ni4gRElTQ0xBSU1FUiBPRiBMSUFCSUxJVFk8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTCi1BR1JFRU1FTlQsIE5FSVRIRVIgUkVDSVBJRU5UIE5PUiBBTlkgQ09OVFJJQlVUT1JTIFNIQUxMIEhBVkUgQU5ZIExJQUJJTElUWSBGT1IKLUFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwotKElOQ0xVRElORyBXSVRIT1VUIExJTUlUQVRJT04gTE9TVCBQUk9GSVRTKSwgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKLU9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HCi1ORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9SIERJU1RSSUJVVElPTiBPRgotVEhFIFBST0dSQU0gT1IgVEhFIEVYRVJDSVNFIE9GIEFOWSBSSUdIVFMgR1JBTlRFRCBIRVJFVU5ERVIsIEVWRU4gSUYgQURWSVNFRCBPRgotVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFUy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjcuIEdFTkVSQUw8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5JZiBhbnkgcHJvdmlzaW9uIG9mIHRoaXMgQWdyZWVtZW50IGlzIGludmFsaWQKLW9yIHVuZW5mb3JjZWFibGUgdW5kZXIgYXBwbGljYWJsZSBsYXcsIGl0IHNoYWxsIG5vdCBhZmZlY3QgdGhlIHZhbGlkaXR5IG9yCi1lbmZvcmNlYWJpbGl0eSBvZiB0aGUgcmVtYWluZGVyIG9mIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgYW5kIHdpdGhvdXQKLWZ1cnRoZXIgYWN0aW9uIGJ5IHRoZSBwYXJ0aWVzIGhlcmV0bywgc3VjaCBwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlCi1taW5pbXVtIGV4dGVudCBuZWNlc3NhcnkgdG8gbWFrZSBzdWNoIHByb3Zpc2lvbiB2YWxpZCBhbmQgZW5mb3JjZWFibGUuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5JZiBSZWNpcGllbnQgaW5zdGl0dXRlcyBwYXRlbnQgbGl0aWdhdGlvbgotYWdhaW5zdCBhbnkgZW50aXR5IChpbmNsdWRpbmcgYSBjcm9zcy1jbGFpbSBvciBjb3VudGVyY2xhaW0gaW4gYSBsYXdzdWl0KQotYWxsZWdpbmcgdGhhdCB0aGUgUHJvZ3JhbSBpdHNlbGYgKGV4Y2x1ZGluZyBjb21iaW5hdGlvbnMgb2YgdGhlIFByb2dyYW0gd2l0aAotb3RoZXIgc29mdHdhcmUgb3IgaGFyZHdhcmUpIGluZnJpbmdlcyBzdWNoIFJlY2lwaWVudCdzIHBhdGVudChzKSwgdGhlbiBzdWNoCi1SZWNpcGllbnQncyByaWdodHMgZ3JhbnRlZCB1bmRlciBTZWN0aW9uIDIoYikgc2hhbGwgdGVybWluYXRlIGFzIG9mIHRoZSBkYXRlCi1zdWNoIGxpdGlnYXRpb24gaXMgZmlsZWQuIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5BbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50Ci1zaGFsbCB0ZXJtaW5hdGUgaWYgaXQgZmFpbHMgdG8gY29tcGx5IHdpdGggYW55IG9mIHRoZSBtYXRlcmlhbCB0ZXJtcyBvcgotY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudCBhbmQgZG9lcyBub3QgY3VyZSBzdWNoIGZhaWx1cmUgaW4gYSByZWFzb25hYmxlCi1wZXJpb2Qgb2YgdGltZSBhZnRlciBiZWNvbWluZyBhd2FyZSBvZiBzdWNoIG5vbmNvbXBsaWFuY2UuIElmIGFsbCBSZWNpcGllbnQncwotcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHRlcm1pbmF0ZSwgUmVjaXBpZW50IGFncmVlcyB0byBjZWFzZSB1c2UgYW5kCi1kaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gYXMgc29vbiBhcyByZWFzb25hYmx5IHByYWN0aWNhYmxlLiBIb3dldmVyLAotUmVjaXBpZW50J3Mgb2JsaWdhdGlvbnMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYW5kIGFueSBsaWNlbnNlcyBncmFudGVkIGJ5Ci1SZWNpcGllbnQgcmVsYXRpbmcgdG8gdGhlIFByb2dyYW0gc2hhbGwgY29udGludWUgYW5kIHN1cnZpdmUuIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FdmVyeW9uZSBpcyBwZXJtaXR0ZWQgdG8gY29weSBhbmQgZGlzdHJpYnV0ZQotY29waWVzIG9mIHRoaXMgQWdyZWVtZW50LCBidXQgaW4gb3JkZXIgdG8gYXZvaWQgaW5jb25zaXN0ZW5jeSB0aGUgQWdyZWVtZW50IGlzCi1jb3B5cmlnaHRlZCBhbmQgbWF5IG9ubHkgYmUgbW9kaWZpZWQgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXIuIFRoZSBBZ3JlZW1lbnQKLVN0ZXdhcmQgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHB1Ymxpc2ggbmV3IHZlcnNpb25zIChpbmNsdWRpbmcgcmV2aXNpb25zKSBvZgotdGhpcyBBZ3JlZW1lbnQgZnJvbSB0aW1lIHRvIHRpbWUuIE5vIG9uZSBvdGhlciB0aGFuIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCBoYXMKLXRoZSByaWdodCB0byBtb2RpZnkgdGhpcyBBZ3JlZW1lbnQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgdGhlIGluaXRpYWwKLUFncmVlbWVudCBTdGV3YXJkLiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1heSBhc3NpZ24gdGhlIHJlc3BvbnNpYmlsaXR5IHRvCi1zZXJ2ZSBhcyB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgdG8gYSBzdWl0YWJsZSBzZXBhcmF0ZSBlbnRpdHkuIEVhY2ggbmV3IHZlcnNpb24KLW9mIHRoZSBBZ3JlZW1lbnQgd2lsbCBiZSBnaXZlbiBhIGRpc3Rpbmd1aXNoaW5nIHZlcnNpb24gbnVtYmVyLiBUaGUgUHJvZ3JhbQotKGluY2x1ZGluZyBDb250cmlidXRpb25zKSBtYXkgYWx3YXlzIGJlIGRpc3RyaWJ1dGVkIHN1YmplY3QgdG8gdGhlIHZlcnNpb24gb2YKLXRoZSBBZ3JlZW1lbnQgdW5kZXIgd2hpY2ggaXQgd2FzIHJlY2VpdmVkLiBJbiBhZGRpdGlvbiwgYWZ0ZXIgYSBuZXcgdmVyc2lvbiBvZgotdGhlIEFncmVlbWVudCBpcyBwdWJsaXNoZWQsIENvbnRyaWJ1dG9yIG1heSBlbGVjdCB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtCi0oaW5jbHVkaW5nIGl0cyBDb250cmlidXRpb25zKSB1bmRlciB0aGUgbmV3IHZlcnNpb24uIEV4Y2VwdCBhcyBleHByZXNzbHkgc3RhdGVkCi1pbiBTZWN0aW9ucyAyKGEpIGFuZCAyKGIpIGFib3ZlLCBSZWNpcGllbnQgcmVjZWl2ZXMgbm8gcmlnaHRzIG9yIGxpY2Vuc2VzIHRvCi10aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IG9mIGFueSBDb250cmlidXRvciB1bmRlciB0aGlzIEFncmVlbWVudCwgd2hldGhlcgotZXhwcmVzc2x5LCBieSBpbXBsaWNhdGlvbiwgZXN0b3BwZWwgb3Igb3RoZXJ3aXNlLiBBbGwgcmlnaHRzIGluIHRoZSBQcm9ncmFtIG5vdAotZXhwcmVzc2x5IGdyYW50ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYXJlIHJlc2VydmVkLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+VGhpcyBBZ3JlZW1lbnQgaXMgZ292ZXJuZWQgYnkgdGhlIGxhd3Mgb2YgdGhlCi1TdGF0ZSBvZiBOZXcgWW9yayBhbmQgdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBsYXdzIG9mIHRoZSBVbml0ZWQgU3RhdGVzIG9mCi1BbWVyaWNhLiBObyBwYXJ0eSB0byB0aGlzIEFncmVlbWVudCB3aWxsIGJyaW5nIGEgbGVnYWwgYWN0aW9uIHVuZGVyIHRoaXMKLUFncmVlbWVudCBtb3JlIHRoYW4gb25lIHllYXIgYWZ0ZXIgdGhlIGNhdXNlIG9mIGFjdGlvbiBhcm9zZS4gRWFjaCBwYXJ0eSB3YWl2ZXMKLWl0cyByaWdodHMgdG8gYSBqdXJ5IHRyaWFsIGluIGFueSByZXN1bHRpbmcgbGl0aWdhdGlvbi48L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjwhW2lmICFzdXBwb3J0RW1wdHlQYXJhc10+Jm5ic3A7PCFbZW5kaWZdPjxvOnA+PC9vOnA+PC9wPgotCi08L2Rpdj4KLQotPC9ib2R5PgotCi08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvbGljZW5zZS5odG1sIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL2xpY2Vuc2UuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMTRiMWQ1MC4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVCdW5kbGUvbGljZW5zZS5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsODMgKzAsMCBAQAotPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMC8vRU4iPgotPGh0bWw+Ci08aGVhZD4KLTxtZXRhIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4KLTx0aXRsZT5FY2xpcHNlLm9yZyBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvdGl0bGU+Ci08L2hlYWQ+Ci0KLTxib2R5IGxhbmc9IkVOLVVTIiBsaW5rPWJsdWUgdmxpbms9cHVycGxlPgotPGgyPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvaDI+Ci08cD5KdW5lIDA2LCAyMDA3PC9wPgotCi08aDM+VXNhZ2UgT2YgQ29udGVudDwvaDM+Ci0KLTxwPlRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiBBTkQvT1IgT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUwotICAgKENPTExFQ1RJVkVMWSAmcXVvdDtDT05URU5UJnF1b3Q7KS4gIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQKLSAgIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VIEFHUkVFIFRIQVQgWU9VUiBVU0UKLSAgIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SCi0gICBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQKLSAgIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULjwvcD4KLSAgIAotPGgzPkFwcGxpY2FibGUgTGljZW5zZXM8L2gzPiAgIAotICAgCi08cD5Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wCi0gICAoJnF1b3Q7RVBMJnF1b3Q7KS4gIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpcyBDb250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L2E+LgotICAgRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICZxdW90O1Byb2dyYW0mcXVvdDsgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvcD4KLQotPHA+Q29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsIGRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2Uub3JnIENWUyByZXBvc2l0b3J5ICgmcXVvdDtSZXBvc2l0b3J5JnF1b3Q7KSBpbiBDVlMKLSAgIG1vZHVsZXMgKCZxdW90O01vZHVsZXMmcXVvdDspIGFuZCBtYWRlIGF2YWlsYWJsZSBhcyBkb3dubG9hZGFibGUgYXJjaGl2ZXMgKCZxdW90O0Rvd25sb2FkcyZxdW90OykuPC9wPgotICAgCi08dWw+Ci0JPGxpPkNvbnRlbnQgbWF5IGJlIHN0cnVjdHVyZWQgYW5kIHBhY2thZ2VkIGludG8gbW9kdWxlcyB0byBmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsIGV4dGVuZGluZywgYW5kIHVwZ3JhZGluZyB0aGUgQ29udGVudC4gIFR5cGljYWwgbW9kdWxlcyBtYXkgaW5jbHVkZSBwbHVnLWlucyAoJnF1b3Q7UGx1Zy1pbnMmcXVvdDspLCBwbHVnLWluIGZyYWdtZW50cyAoJnF1b3Q7RnJhZ21lbnRzJnF1b3Q7KSwgYW5kIGZlYXR1cmVzICgmcXVvdDtGZWF0dXJlcyZxdW90OykuPC9saT4KLQk8bGk+RWFjaCBQbHVnLWluIG9yIEZyYWdtZW50IG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3Rvcnkgb3IgSkFSIChKYXZhJnRyYWRlOyBBUmNoaXZlKSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtwbHVnaW5zJnF1b3Q7LjwvbGk+Ci0JPGxpPkEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLiAgRWFjaCBGZWF0dXJlIG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3RvcnkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgJnF1b3Q7ZmVhdHVyZXMmcXVvdDsuICBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnhtbCZxdW90OyBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgdGhlIFBsdWctaW5zCi0gICAgICBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuPC9saT4KLQk8bGk+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoJnF1b3Q7SW5jbHVkZWQgRmVhdHVyZXMmcXVvdDspLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnhtbCZxdW90OyBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgRmVhdHVyZXMuPC9saT4KLTwvdWw+ICAgCi0gCi08cD5UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAmcXVvdDthYm91dC5odG1sJnF1b3Q7ICgmcXVvdDtBYm91dHMmcXVvdDspLiBUaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIEZlYXR1cmVzIGFuZAotSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAmcXVvdDtsaWNlbnNlLmh0bWwmcXVvdDsgKCZxdW90O0ZlYXR1cmUgTGljZW5zZXMmcXVvdDspLiAgQWJvdXRzIGFuZCBGZWF0dXJlIExpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSBkaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGUKLWluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOjwvcD4KLQotPHVsPgotCTxsaT5UaGUgdG9wLWxldmVsIChyb290KSBkaXJlY3Rvcnk8L2xpPgotCTxsaT5QbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3RvcmllczwvbGk+Ci0JPGxpPkluc2lkZSBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHBhY2thZ2VkIGFzIEpBUnM8L2xpPgotCTxsaT5TdWItZGlyZWN0b3JpZXMgb2YgdGhlIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtzcmMmcXVvdDsgb2YgY2VydGFpbiBQbHVnLWluczwvbGk+Ci0JPGxpPkZlYXR1cmUgZGlyZWN0b3JpZXM8L2xpPgotPC91bD4KLQkJCi08cD5Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlIEVjbGlwc2UgVXBkYXRlIE1hbmFnZXIsIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoJnF1b3Q7RmVhdHVyZSBVcGRhdGUgTGljZW5zZSZxdW90OykgZHVyaW5nIHRoZQotaW5zdGFsbGF0aW9uIHByb2Nlc3MuICBJZiB0aGUgRmVhdHVyZSBjb250YWlucyBJbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdSB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgdGhlIEluY2x1ZGVkIEZlYXR1cmVzIG9yCi1pbmZvcm0geW91IHdoZXJlIHlvdSBjYW4gbG9jYXRlIHRoZW0uICBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW4gdGhlICZxdW90O2xpY2Vuc2UmcXVvdDsgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgJnF1b3Q7ZmVhdHVyZS5wcm9wZXJ0aWVzJnF1b3Q7IGZvdW5kIHdpdGhpbiBhIEZlYXR1cmUuCi1TdWNoIEFib3V0cywgRmVhdHVyZSBMaWNlbnNlcywgYW5kIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXIgdXNlIG9mIHRoZSBhc3NvY2lhdGVkIENvbnRlbnQgaW4KLXRoYXQgZGlyZWN0b3J5LjwvcD4KLQotPHA+VEhFIEFCT1VUUywgRkVBVFVSRSBMSUNFTlNFUywgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUiBUTyBUSEUgRVBMIE9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy4gIFNPTUUgT0YgVEhFU0UKLU9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6PC9wPgotCi08dWw+Ci0JPGxpPkNvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbDwvYT4pPC9saT4KLQk8bGk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFPC9hPik8L2xpPgotCTxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMDwvYT4pPC9saT4KLQk8bGk+SUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sIj5odHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vZGV2ZWxvcGVyd29ya3Mvb3BlbnNvdXJjZS9saWNlbnNlMTAuaHRtbDwvYT4pPC9saT4JCi0JPGxpPk1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sIj5odHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbDwvYT4pPC9saT4KLQk8bGk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbCI+aHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sPC9hPik8L2xpPgotICAKLSAgPExJPkNvbW1vbiBEZXZlbG9wbWVudCBhbmQgRGlzdHJpYnV0aW9uIExpY2Vuc2UgKENEREwpIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuc3VuLmNvbS9jZGRsL2NkZGwuaHRtbCI+aHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sKTwvQT4KLSAgPC9MST4KLTwvVUw+Ci0KLTxwPklUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1IgVE8gVVNFIE9GIFRIRSBDT05URU5ULiAgSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSwgb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBpcyBwcm92aWRlZCwgcGxlYXNlCi1jb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LjwvcD4KLQotPGgzPkNyeXB0b2dyYXBoeTwvaDM+Ci0KLTxwPkNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZSBjdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsIGFuZC9vciByZS1leHBvcnQgdG8KLSAgIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFIHVzaW5nIGFueSBlbmNyeXB0aW9uIHNvZnR3YXJlLCBwbGVhc2UgY2hlY2sgdGhlIGNvdW50cnkncyBsYXdzLCByZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgY29uY2VybmluZyB0aGUgaW1wb3J0LAotICAgcG9zc2Vzc2lvbiwgb3IgdXNlLCBhbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIHRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC48L3A+Ci0gICAKLTxzbWFsbD5KYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIFN1biBNaWNyb3N5c3RlbXMsIEluYy4gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC48L3NtYWxsPiAgIAotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL3BsdWdpbi5wcm9wZXJ0aWVzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlQnVuZGxlL3BsdWdpbi5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmOTQ4NTQ3Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUJ1bmRsZS9wbHVnaW4ucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDEzICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA4IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotCi1wbHVnaW5OYW1lID0gRGFsaSBKYXZhIFBlcnNpc3RlbmNlIEFQSSAoSlBBKSBUb29scwotcHJvdmlkZXJOYW1lID0gRWNsaXBzZS5vcmcKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvYnVpbGQucHJvcGVydGllcyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjYwZGFkMy4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVGZWF0dXJlL2J1aWxkLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwxNiArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLWJpbi5pbmNsdWRlcyA9IFwKLSAgICAgICAgICAgICAgIGVwbC12MTAuaHRtbCxcCi0gICAgICAgICAgICAgICBlY2xpcHNlX3VwZGF0ZV8xMjAuanBnLFwKLSAgICAgICAgICAgICAgIGZlYXR1cmUueG1sLFwKLSAgICAgICAgICAgICAgIGZlYXR1cmUucHJvcGVydGllcyxcCi0gICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmZkZjcwOC4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVGZWF0dXJlL2VjbGlwc2VfdXBkYXRlXzEyMC5qcGcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVGZWF0dXJlL2VwbC12MTAuaHRtbCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvZXBsLXYxMC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMjJhZDI5Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvZXBsLXYxMC5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsMzI4ICswLDAgQEAKLTxodG1sIHhtbG5zOm89InVybjpzY2hlbWFzLW1pY3Jvc29mdC1jb206b2ZmaWNlOm9mZmljZSIKLXhtbG5zOnc9InVybjpzY2hlbWFzLW1pY3Jvc29mdC1jb206b2ZmaWNlOndvcmQiCi14bWxucz0iaHR0cDovL3d3dy53My5vcmcvVFIvUkVDLWh0bWw0MCI+Ci0KLTxoZWFkPgotPG1ldGEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXdpbmRvd3MtMTI1MiI+Ci08bWV0YSBuYW1lPVByb2dJZCBjb250ZW50PVdvcmQuRG9jdW1lbnQ+Ci08bWV0YSBuYW1lPUdlbmVyYXRvciBjb250ZW50PSJNaWNyb3NvZnQgV29yZCA5Ij4KLTxtZXRhIG5hbWU9T3JpZ2luYXRvciBjb250ZW50PSJNaWNyb3NvZnQgV29yZCA5Ij4KLTxsaW5rIHJlbD1GaWxlLUxpc3QKLWhyZWY9Ii4vRWNsaXBzZSUyMEVQTCUyMDIwMDNfMTFfMTAlMjBGaW5hbF9maWxlcy9maWxlbGlzdC54bWwiPgotPHRpdGxlPkVjbGlwc2UgUHVibGljIExpY2Vuc2UgLSBWZXJzaW9uIDEuMDwvdGl0bGU+Ci08IS0tW2lmIGd0ZSBtc28gOV0+PHhtbD4KLSA8bzpEb2N1bWVudFByb3BlcnRpZXM+Ci0gIDxvOlJldmlzaW9uPjI8L286UmV2aXNpb24+Ci0gIDxvOlRvdGFsVGltZT4zPC9vOlRvdGFsVGltZT4KLSAgPG86Q3JlYXRlZD4yMDA0LTAzLTA1VDIzOjAzOjAwWjwvbzpDcmVhdGVkPgotICA8bzpMYXN0U2F2ZWQ+MjAwNC0wMy0wNVQyMzowMzowMFo8L286TGFzdFNhdmVkPgotICA8bzpQYWdlcz40PC9vOlBhZ2VzPgotICA8bzpXb3Jkcz4xNjI2PC9vOldvcmRzPgotICA8bzpDaGFyYWN0ZXJzPjkyNzA8L286Q2hhcmFjdGVycz4KLSAgIDxvOkxpbmVzPjc3PC9vOkxpbmVzPgotICA8bzpQYXJhZ3JhcGhzPjE4PC9vOlBhcmFncmFwaHM+Ci0gIDxvOkNoYXJhY3RlcnNXaXRoU3BhY2VzPjExMzg0PC9vOkNoYXJhY3RlcnNXaXRoU3BhY2VzPgotICA8bzpWZXJzaW9uPjkuNDQwMjwvbzpWZXJzaW9uPgotIDwvbzpEb2N1bWVudFByb3BlcnRpZXM+Ci08L3htbD48IVtlbmRpZl0tLT48IS0tW2lmIGd0ZSBtc28gOV0+PHhtbD4KLSA8dzpXb3JkRG9jdW1lbnQ+Ci0gIDx3OlRyYWNrUmV2aXNpb25zLz4KLSA8L3c6V29yZERvY3VtZW50PgotPC94bWw+PCFbZW5kaWZdLS0+Ci08c3R5bGU+Ci08IS0tCi0gLyogRm9udCBEZWZpbml0aW9ucyAqLwotQGZvbnQtZmFjZQotCXtmb250LWZhbWlseTpUYWhvbWE7Ci0JcGFub3NlLTE6MiAxMSA2IDQgMyA1IDQgNCAyIDQ7Ci0JbXNvLWZvbnQtY2hhcnNldDowOwotCW1zby1nZW5lcmljLWZvbnQtZmFtaWx5OnN3aXNzOwotCW1zby1mb250LXBpdGNoOnZhcmlhYmxlOwotCW1zby1mb250LXNpZ25hdHVyZTo1NTM2Nzk0OTUgLTIxNDc0ODM2NDggOCAwIDY2MDQ3IDA7fQotIC8qIFN0eWxlIERlZmluaXRpb25zICovCi1wLk1zb05vcm1hbCwgbGkuTXNvTm9ybWFsLCBkaXYuTXNvTm9ybWFsCi0Je21zby1zdHlsZS1wYXJlbnQ6IiI7Ci0JbWFyZ2luOjBpbjsKLQltYXJnaW4tYm90dG9tOi4wMDAxcHQ7Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZToxMi4wcHQ7Ci0JZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotcAotCXttYXJnaW4tcmlnaHQ6MGluOwotCW1zby1tYXJnaW4tdG9wLWFsdDphdXRvOwotCW1zby1tYXJnaW4tYm90dG9tLWFsdDphdXRvOwotCW1hcmdpbi1sZWZ0OjBpbjsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjEyLjBwdDsKLQlmb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1wLkJhbGxvb25UZXh0LCBsaS5CYWxsb29uVGV4dCwgZGl2LkJhbGxvb25UZXh0Ci0Je21zby1zdHlsZS1uYW1lOiJCYWxsb29uIFRleHQiOwotCW1hcmdpbjowaW47Ci0JbWFyZ2luLWJvdHRvbTouMDAwMXB0OwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6OC4wcHQ7Ci0JZm9udC1mYW1pbHk6VGFob21hOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLUBwYWdlIFNlY3Rpb24xCi0Je3NpemU6OC41aW4gMTEuMGluOwotCW1hcmdpbjoxLjBpbiAxLjI1aW4gMS4waW4gMS4yNWluOwotCW1zby1oZWFkZXItbWFyZ2luOi41aW47Ci0JbXNvLWZvb3Rlci1tYXJnaW46LjVpbjsKLQltc28tcGFwZXItc291cmNlOjA7fQotZGl2LlNlY3Rpb24xCi0Je3BhZ2U6U2VjdGlvbjE7fQotLS0+Ci08L3N0eWxlPgotPC9oZWFkPgotCi08Ym9keSBsYW5nPUVOLVVTIHN0eWxlPSd0YWItaW50ZXJ2YWw6LjVpbic+Ci0KLTxkaXYgY2xhc3M9U2VjdGlvbjE+Ci0KLTxwIGFsaWduPWNlbnRlciBzdHlsZT0ndGV4dC1hbGlnbjpjZW50ZXInPjxiPkVjbGlwc2UgUHVibGljIExpY2Vuc2UgLSB2IDEuMDwvYj4KLTwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPlRIRSBBQ0NPTVBBTllJTkcgUFJPR1JBTSBJUyBQUk9WSURFRCBVTkRFUgotVEhFIFRFUk1TIE9GIFRISVMgRUNMSVBTRSBQVUJMSUMgTElDRU5TRSAoJnF1b3Q7QUdSRUVNRU5UJnF1b3Q7KS4gQU5ZIFVTRSwKLVJFUFJPRFVDVElPTiBPUiBESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gQ09OU1RJVFVURVMgUkVDSVBJRU5UJ1MgQUNDRVBUQU5DRQotT0YgVEhJUyBBR1JFRU1FTlQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4xLiBERUZJTklUSU9OUzwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0NvbnRyaWJ1dGlvbiZxdW90OyBtZWFuczo8L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWluIHRoZSBjYXNlIG9mIHRoZSBpbml0aWFsIENvbnRyaWJ1dG9yLCB0aGUgaW5pdGlhbCBjb2RlIGFuZCBkb2N1bWVudGF0aW9uCi1kaXN0cmlidXRlZCB1bmRlciB0aGlzIEFncmVlbWVudCwgYW5kPGJyIGNsZWFyPWxlZnQ+Ci1iKSBpbiB0aGUgY2FzZSBvZiBlYWNoIHN1YnNlcXVlbnQgQ29udHJpYnV0b3I6PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aSkKLWNoYW5nZXMgdG8gdGhlIFByb2dyYW0sIGFuZDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpKQotYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtOzwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPndoZXJlCi1zdWNoIGNoYW5nZXMgYW5kL29yIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbSBvcmlnaW5hdGUgZnJvbSBhbmQgYXJlIGRpc3RyaWJ1dGVkCi1ieSB0aGF0IHBhcnRpY3VsYXIgQ29udHJpYnV0b3IuIEEgQ29udHJpYnV0aW9uICdvcmlnaW5hdGVzJyBmcm9tIGEgQ29udHJpYnV0b3IKLWlmIGl0IHdhcyBhZGRlZCB0byB0aGUgUHJvZ3JhbSBieSBzdWNoIENvbnRyaWJ1dG9yIGl0c2VsZiBvciBhbnlvbmUgYWN0aW5nIG9uCi1zdWNoIENvbnRyaWJ1dG9yJ3MgYmVoYWxmLiBDb250cmlidXRpb25zIGRvIG5vdCBpbmNsdWRlIGFkZGl0aW9ucyB0byB0aGUKLVByb2dyYW0gd2hpY2g6IChpKSBhcmUgc2VwYXJhdGUgbW9kdWxlcyBvZiBzb2Z0d2FyZSBkaXN0cmlidXRlZCBpbiBjb25qdW5jdGlvbgotd2l0aCB0aGUgUHJvZ3JhbSB1bmRlciB0aGVpciBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIGFuZCAoaWkpIGFyZSBub3QgZGVyaXZhdGl2ZQotd29ya3Mgb2YgdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtDb250cmlidXRvciZxdW90OyBtZWFucyBhbnkgcGVyc29uIG9yCi1lbnRpdHkgdGhhdCBkaXN0cmlidXRlcyB0aGUgUHJvZ3JhbS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0xpY2Vuc2VkIFBhdGVudHMgJnF1b3Q7IG1lYW4gcGF0ZW50Ci1jbGFpbXMgbGljZW5zYWJsZSBieSBhIENvbnRyaWJ1dG9yIHdoaWNoIGFyZSBuZWNlc3NhcmlseSBpbmZyaW5nZWQgYnkgdGhlIHVzZQotb3Igc2FsZSBvZiBpdHMgQ29udHJpYnV0aW9uIGFsb25lIG9yIHdoZW4gY29tYmluZWQgd2l0aCB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O1Byb2dyYW0mcXVvdDsgbWVhbnMgdGhlIENvbnRyaWJ1dGlvbnMKLWRpc3RyaWJ1dGVkIGluIGFjY29yZGFuY2Ugd2l0aCB0aGlzIEFncmVlbWVudC48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O1JlY2lwaWVudCZxdW90OyBtZWFucyBhbnlvbmUgd2hvCi1yZWNlaXZlcyB0aGUgUHJvZ3JhbSB1bmRlciB0aGlzIEFncmVlbWVudCwgaW5jbHVkaW5nIGFsbCBDb250cmlidXRvcnMuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4yLiBHUkFOVCBPRiBSSUdIVFM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1TdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudAotYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsIHJveWFsdHktZnJlZSBjb3B5cmlnaHQgbGljZW5zZSB0bzxzcGFuCi1zdHlsZT0nY29sb3I6cmVkJz4gPC9zcGFuPnJlcHJvZHVjZSwgcHJlcGFyZSBkZXJpdmF0aXZlIHdvcmtzIG9mLCBwdWJsaWNseQotZGlzcGxheSwgcHVibGljbHkgcGVyZm9ybSwgZGlzdHJpYnV0ZSBhbmQgc3VibGljZW5zZSB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2gKLUNvbnRyaWJ1dG9yLCBpZiBhbnksIGFuZCBzdWNoIGRlcml2YXRpdmUgd29ya3MsIGluIHNvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZQotZm9ybS48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKQotU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cwotUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLDxzcGFuIHN0eWxlPSdjb2xvcjpncmVlbic+IDwvc3Bhbj5yb3lhbHR5LWZyZWUKLXBhdGVudCBsaWNlbnNlIHVuZGVyIExpY2Vuc2VkIFBhdGVudHMgdG8gbWFrZSwgdXNlLCBzZWxsLCBvZmZlciB0byBzZWxsLCBpbXBvcnQKLWFuZCBvdGhlcndpc2UgdHJhbnNmZXIgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoIENvbnRyaWJ1dG9yLCBpZiBhbnksIGluIHNvdXJjZQotY29kZSBhbmQgb2JqZWN0IGNvZGUgZm9ybS4gVGhpcyBwYXRlbnQgbGljZW5zZSBzaGFsbCBhcHBseSB0byB0aGUgY29tYmluYXRpb24KLW9mIHRoZSBDb250cmlidXRpb24gYW5kIHRoZSBQcm9ncmFtIGlmLCBhdCB0aGUgdGltZSB0aGUgQ29udHJpYnV0aW9uIGlzIGFkZGVkCi1ieSB0aGUgQ29udHJpYnV0b3IsIHN1Y2ggYWRkaXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBjYXVzZXMgc3VjaCBjb21iaW5hdGlvbgotdG8gYmUgY292ZXJlZCBieSB0aGUgTGljZW5zZWQgUGF0ZW50cy4gVGhlIHBhdGVudCBsaWNlbnNlIHNoYWxsIG5vdCBhcHBseSB0bwotYW55IG90aGVyIGNvbWJpbmF0aW9ucyB3aGljaCBpbmNsdWRlIHRoZSBDb250cmlidXRpb24uIE5vIGhhcmR3YXJlIHBlciBzZSBpcwotbGljZW5zZWQgaGVyZXVuZGVyLiA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5jKQotUmVjaXBpZW50IHVuZGVyc3RhbmRzIHRoYXQgYWx0aG91Z2ggZWFjaCBDb250cmlidXRvciBncmFudHMgdGhlIGxpY2Vuc2VzIHRvIGl0cwotQ29udHJpYnV0aW9ucyBzZXQgZm9ydGggaGVyZWluLCBubyBhc3N1cmFuY2VzIGFyZSBwcm92aWRlZCBieSBhbnkgQ29udHJpYnV0b3IKLXRoYXQgdGhlIFByb2dyYW0gZG9lcyBub3QgaW5mcmluZ2UgdGhlIHBhdGVudCBvciBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkKLXJpZ2h0cyBvZiBhbnkgb3RoZXIgZW50aXR5LiBFYWNoIENvbnRyaWJ1dG9yIGRpc2NsYWltcyBhbnkgbGlhYmlsaXR5IHRvIFJlY2lwaWVudAotZm9yIGNsYWltcyBicm91Z2h0IGJ5IGFueSBvdGhlciBlbnRpdHkgYmFzZWQgb24gaW5mcmluZ2VtZW50IG9mIGludGVsbGVjdHVhbAotcHJvcGVydHkgcmlnaHRzIG9yIG90aGVyd2lzZS4gQXMgYSBjb25kaXRpb24gdG8gZXhlcmNpc2luZyB0aGUgcmlnaHRzIGFuZAotbGljZW5zZXMgZ3JhbnRlZCBoZXJldW5kZXIsIGVhY2ggUmVjaXBpZW50IGhlcmVieSBhc3N1bWVzIHNvbGUgcmVzcG9uc2liaWxpdHkKLXRvIHNlY3VyZSBhbnkgb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5IHJpZ2h0cyBuZWVkZWQsIGlmIGFueS4gRm9yIGV4YW1wbGUsCi1pZiBhIHRoaXJkIHBhcnR5IHBhdGVudCBsaWNlbnNlIGlzIHJlcXVpcmVkIHRvIGFsbG93IFJlY2lwaWVudCB0byBkaXN0cmlidXRlCi10aGUgUHJvZ3JhbSwgaXQgaXMgUmVjaXBpZW50J3MgcmVzcG9uc2liaWxpdHkgdG8gYWNxdWlyZSB0aGF0IGxpY2Vuc2UgYmVmb3JlCi1kaXN0cmlidXRpbmcgdGhlIFByb2dyYW0uPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+ZCkKLUVhY2ggQ29udHJpYnV0b3IgcmVwcmVzZW50cyB0aGF0IHRvIGl0cyBrbm93bGVkZ2UgaXQgaGFzIHN1ZmZpY2llbnQgY29weXJpZ2h0Ci1yaWdodHMgaW4gaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCB0byBncmFudCB0aGUgY29weXJpZ2h0IGxpY2Vuc2Ugc2V0IGZvcnRoIGluCi10aGlzIEFncmVlbWVudC4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjMuIFJFUVVJUkVNRU5UUzwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkEgQ29udHJpYnV0b3IgbWF5IGNob29zZSB0byBkaXN0cmlidXRlIHRoZQotUHJvZ3JhbSBpbiBvYmplY3QgY29kZSBmb3JtIHVuZGVyIGl0cyBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIHByb3ZpZGVkIHRoYXQ6PC9zcGFuPgotPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaXQgY29tcGxpZXMgd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQ7IGFuZDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpCi1pdHMgbGljZW5zZSBhZ3JlZW1lbnQ6PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aSkKLWVmZmVjdGl2ZWx5IGRpc2NsYWltcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgd2FycmFudGllcyBhbmQKLWNvbmRpdGlvbnMsIGV4cHJlc3MgYW5kIGltcGxpZWQsIGluY2x1ZGluZyB3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgdGl0bGUKLWFuZCBub24taW5mcmluZ2VtZW50LCBhbmQgaW1wbGllZCB3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgbWVyY2hhbnRhYmlsaXR5Ci1hbmQgZml0bmVzcyBmb3IgYSBwYXJ0aWN1bGFyIHB1cnBvc2U7IDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpKQotZWZmZWN0aXZlbHkgZXhjbHVkZXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIGxpYWJpbGl0eSBmb3IgZGFtYWdlcywKLWluY2x1ZGluZyBkaXJlY3QsIGluZGlyZWN0LCBzcGVjaWFsLCBpbmNpZGVudGFsIGFuZCBjb25zZXF1ZW50aWFsIGRhbWFnZXMsIHN1Y2gKLWFzIGxvc3QgcHJvZml0czsgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWlpKQotc3RhdGVzIHRoYXQgYW55IHByb3Zpc2lvbnMgd2hpY2ggZGlmZmVyIGZyb20gdGhpcyBBZ3JlZW1lbnQgYXJlIG9mZmVyZWQgYnkgdGhhdAotQ29udHJpYnV0b3IgYWxvbmUgYW5kIG5vdCBieSBhbnkgb3RoZXIgcGFydHk7IGFuZDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPml2KQotc3RhdGVzIHRoYXQgc291cmNlIGNvZGUgZm9yIHRoZSBQcm9ncmFtIGlzIGF2YWlsYWJsZSBmcm9tIHN1Y2ggQ29udHJpYnV0b3IsIGFuZAotaW5mb3JtcyBsaWNlbnNlZXMgaG93IHRvIG9idGFpbiBpdCBpbiBhIHJlYXNvbmFibGUgbWFubmVyIG9uIG9yIHRocm91Z2ggYQotbWVkaXVtIGN1c3RvbWFyaWx5IHVzZWQgZm9yIHNvZnR3YXJlIGV4Y2hhbmdlLjxzcGFuIHN0eWxlPSdjb2xvcjpibHVlJz4gPC9zcGFuPjwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5XaGVuIHRoZSBQcm9ncmFtIGlzIG1hZGUgYXZhaWxhYmxlIGluIHNvdXJjZQotY29kZSBmb3JtOjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaXQgbXVzdCBiZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGlzIEFncmVlbWVudDsgYW5kIDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpIGEKLWNvcHkgb2YgdGhpcyBBZ3JlZW1lbnQgbXVzdCBiZSBpbmNsdWRlZCB3aXRoIGVhY2ggY29weSBvZiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkNvbnRyaWJ1dG9ycyBtYXkgbm90IHJlbW92ZSBvciBhbHRlciBhbnkKLWNvcHlyaWdodCBub3RpY2VzIGNvbnRhaW5lZCB3aXRoaW4gdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FYWNoIENvbnRyaWJ1dG9yIG11c3QgaWRlbnRpZnkgaXRzZWxmIGFzIHRoZQotb3JpZ2luYXRvciBvZiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIGluIGEgbWFubmVyIHRoYXQgcmVhc29uYWJseSBhbGxvd3MKLXN1YnNlcXVlbnQgUmVjaXBpZW50cyB0byBpZGVudGlmeSB0aGUgb3JpZ2luYXRvciBvZiB0aGUgQ29udHJpYnV0aW9uLiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+NC4gQ09NTUVSQ0lBTCBESVNUUklCVVRJT048L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Db21tZXJjaWFsIGRpc3RyaWJ1dG9ycyBvZiBzb2Z0d2FyZSBtYXkKLWFjY2VwdCBjZXJ0YWluIHJlc3BvbnNpYmlsaXRpZXMgd2l0aCByZXNwZWN0IHRvIGVuZCB1c2VycywgYnVzaW5lc3MgcGFydG5lcnMKLWFuZCB0aGUgbGlrZS4gV2hpbGUgdGhpcyBsaWNlbnNlIGlzIGludGVuZGVkIHRvIGZhY2lsaXRhdGUgdGhlIGNvbW1lcmNpYWwgdXNlCi1vZiB0aGUgUHJvZ3JhbSwgdGhlIENvbnRyaWJ1dG9yIHdobyBpbmNsdWRlcyB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwKLXByb2R1Y3Qgb2ZmZXJpbmcgc2hvdWxkIGRvIHNvIGluIGEgbWFubmVyIHdoaWNoIGRvZXMgbm90IGNyZWF0ZSBwb3RlbnRpYWwKLWxpYWJpbGl0eSBmb3Igb3RoZXIgQ29udHJpYnV0b3JzLiBUaGVyZWZvcmUsIGlmIGEgQ29udHJpYnV0b3IgaW5jbHVkZXMgdGhlCi1Qcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBzdWNoIENvbnRyaWJ1dG9yICgmcXVvdDtDb21tZXJjaWFsCi1Db250cmlidXRvciZxdW90OykgaGVyZWJ5IGFncmVlcyB0byBkZWZlbmQgYW5kIGluZGVtbmlmeSBldmVyeSBvdGhlcgotQ29udHJpYnV0b3IgKCZxdW90O0luZGVtbmlmaWVkIENvbnRyaWJ1dG9yJnF1b3Q7KSBhZ2FpbnN0IGFueSBsb3NzZXMsIGRhbWFnZXMgYW5kCi1jb3N0cyAoY29sbGVjdGl2ZWx5ICZxdW90O0xvc3NlcyZxdW90OykgYXJpc2luZyBmcm9tIGNsYWltcywgbGF3c3VpdHMgYW5kIG90aGVyCi1sZWdhbCBhY3Rpb25zIGJyb3VnaHQgYnkgYSB0aGlyZCBwYXJ0eSBhZ2FpbnN0IHRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciB0bwotdGhlIGV4dGVudCBjYXVzZWQgYnkgdGhlIGFjdHMgb3Igb21pc3Npb25zIG9mIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvciBpbgotY29ubmVjdGlvbiB3aXRoIGl0cyBkaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3QKLW9mZmVyaW5nLiBUaGUgb2JsaWdhdGlvbnMgaW4gdGhpcyBzZWN0aW9uIGRvIG5vdCBhcHBseSB0byBhbnkgY2xhaW1zIG9yIExvc3NlcwotcmVsYXRpbmcgdG8gYW55IGFjdHVhbCBvciBhbGxlZ2VkIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBpbmZyaW5nZW1lbnQuIEluIG9yZGVyCi10byBxdWFsaWZ5LCBhbiBJbmRlbW5pZmllZCBDb250cmlidXRvciBtdXN0OiBhKSBwcm9tcHRseSBub3RpZnkgdGhlIENvbW1lcmNpYWwKLUNvbnRyaWJ1dG9yIGluIHdyaXRpbmcgb2Ygc3VjaCBjbGFpbSwgYW5kIGIpIGFsbG93IHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yCi10byBjb250cm9sLCBhbmQgY29vcGVyYXRlIHdpdGggdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4sIHRoZSBkZWZlbnNlIGFuZAotYW55IHJlbGF0ZWQgc2V0dGxlbWVudCBuZWdvdGlhdGlvbnMuIFRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciBtYXkgcGFydGljaXBhdGUKLWluIGFueSBzdWNoIGNsYWltIGF0IGl0cyBvd24gZXhwZW5zZS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkZvciBleGFtcGxlLCBhIENvbnRyaWJ1dG9yIG1pZ2h0IGluY2x1ZGUgdGhlCi1Qcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBQcm9kdWN0IFguIFRoYXQgQ29udHJpYnV0b3IgaXMgdGhlbiBhCi1Db21tZXJjaWFsIENvbnRyaWJ1dG9yLiBJZiB0aGF0IENvbW1lcmNpYWwgQ29udHJpYnV0b3IgdGhlbiBtYWtlcyBwZXJmb3JtYW5jZQotY2xhaW1zLCBvciBvZmZlcnMgd2FycmFudGllcyByZWxhdGVkIHRvIFByb2R1Y3QgWCwgdGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZAotd2FycmFudGllcyBhcmUgc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yJ3MgcmVzcG9uc2liaWxpdHkgYWxvbmUuIFVuZGVyIHRoaXMKLXNlY3Rpb24sIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHdvdWxkIGhhdmUgdG8gZGVmZW5kIGNsYWltcyBhZ2FpbnN0IHRoZQotb3RoZXIgQ29udHJpYnV0b3JzIHJlbGF0ZWQgdG8gdGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZCB3YXJyYW50aWVzLCBhbmQgaWYgYQotY291cnQgcmVxdWlyZXMgYW55IG90aGVyIENvbnRyaWJ1dG9yIHRvIHBheSBhbnkgZGFtYWdlcyBhcyBhIHJlc3VsdCwgdGhlCi1Db21tZXJjaWFsIENvbnRyaWJ1dG9yIG11c3QgcGF5IHRob3NlIGRhbWFnZXMuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz41LiBOTyBXQVJSQU5UWTwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMKLUFHUkVFTUVOVCwgVEhFIFBST0dSQU0gSVMgUFJPVklERUQgT04gQU4gJnF1b3Q7QVMgSVMmcXVvdDsgQkFTSVMsIFdJVEhPVVQKLVdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgRUlUSEVSIEVYUFJFU1MgT1IgSU1QTElFRCBJTkNMVURJTkcsCi1XSVRIT1VUIExJTUlUQVRJT04sIEFOWSBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgVElUTEUsIE5PTi1JTkZSSU5HRU1FTlQsCi1NRVJDSEFOVEFCSUxJVFkgT1IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIEVhY2ggUmVjaXBpZW50IGlzIHNvbGVseQotcmVzcG9uc2libGUgZm9yIGRldGVybWluaW5nIHRoZSBhcHByb3ByaWF0ZW5lc3Mgb2YgdXNpbmcgYW5kIGRpc3RyaWJ1dGluZyB0aGUKLVByb2dyYW0gYW5kIGFzc3VtZXMgYWxsIHJpc2tzIGFzc29jaWF0ZWQgd2l0aCBpdHMgZXhlcmNpc2Ugb2YgcmlnaHRzIHVuZGVyIHRoaXMKLUFncmVlbWVudCAsIGluY2x1ZGluZyBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIHJpc2tzIGFuZCBjb3N0cyBvZiBwcm9ncmFtIGVycm9ycywKLWNvbXBsaWFuY2Ugd2l0aCBhcHBsaWNhYmxlIGxhd3MsIGRhbWFnZSB0byBvciBsb3NzIG9mIGRhdGEsIHByb2dyYW1zIG9yCi1lcXVpcG1lbnQsIGFuZCB1bmF2YWlsYWJpbGl0eSBvciBpbnRlcnJ1cHRpb24gb2Ygb3BlcmF0aW9ucy4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjYuIERJU0NMQUlNRVIgT0YgTElBQklMSVRZPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUwotQUdSRUVNRU5ULCBORUlUSEVSIFJFQ0lQSUVOVCBOT1IgQU5ZIENPTlRSSUJVVE9SUyBTSEFMTCBIQVZFIEFOWSBMSUFCSUxJVFkgRk9SCi1BTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLShJTkNMVURJTkcgV0lUSE9VVCBMSU1JVEFUSU9OIExPU1QgUFJPRklUUyksIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCi1PRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORwotTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPUiBESVNUUklCVVRJT04gT0YKLVRIRSBQUk9HUkFNIE9SIFRIRSBFWEVSQ0lTRSBPRiBBTlkgUklHSFRTIEdSQU5URUQgSEVSRVVOREVSLCBFVkVOIElGIEFEVklTRUQgT0YKLVRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRVMuPC9zcGFuPiA8L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz43LiBHRU5FUkFMPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+SWYgYW55IHByb3Zpc2lvbiBvZiB0aGlzIEFncmVlbWVudCBpcyBpbnZhbGlkCi1vciB1bmVuZm9yY2VhYmxlIHVuZGVyIGFwcGxpY2FibGUgbGF3LCBpdCBzaGFsbCBub3QgYWZmZWN0IHRoZSB2YWxpZGl0eSBvcgotZW5mb3JjZWFiaWxpdHkgb2YgdGhlIHJlbWFpbmRlciBvZiB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGFuZCB3aXRob3V0Ci1mdXJ0aGVyIGFjdGlvbiBieSB0aGUgcGFydGllcyBoZXJldG8sIHN1Y2ggcHJvdmlzaW9uIHNoYWxsIGJlIHJlZm9ybWVkIHRvIHRoZQotbWluaW11bSBleHRlbnQgbmVjZXNzYXJ5IHRvIG1ha2Ugc3VjaCBwcm92aXNpb24gdmFsaWQgYW5kIGVuZm9yY2VhYmxlLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+SWYgUmVjaXBpZW50IGluc3RpdHV0ZXMgcGF0ZW50IGxpdGlnYXRpb24KLWFnYWluc3QgYW55IGVudGl0eSAoaW5jbHVkaW5nIGEgY3Jvc3MtY2xhaW0gb3IgY291bnRlcmNsYWltIGluIGEgbGF3c3VpdCkKLWFsbGVnaW5nIHRoYXQgdGhlIFByb2dyYW0gaXRzZWxmIChleGNsdWRpbmcgY29tYmluYXRpb25zIG9mIHRoZSBQcm9ncmFtIHdpdGgKLW90aGVyIHNvZnR3YXJlIG9yIGhhcmR3YXJlKSBpbmZyaW5nZXMgc3VjaCBSZWNpcGllbnQncyBwYXRlbnQocyksIHRoZW4gc3VjaAotUmVjaXBpZW50J3MgcmlnaHRzIGdyYW50ZWQgdW5kZXIgU2VjdGlvbiAyKGIpIHNoYWxsIHRlcm1pbmF0ZSBhcyBvZiB0aGUgZGF0ZQotc3VjaCBsaXRpZ2F0aW9uIGlzIGZpbGVkLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+QWxsIFJlY2lwaWVudCdzIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudAotc2hhbGwgdGVybWluYXRlIGlmIGl0IGZhaWxzIHRvIGNvbXBseSB3aXRoIGFueSBvZiB0aGUgbWF0ZXJpYWwgdGVybXMgb3IKLWNvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQgYW5kIGRvZXMgbm90IGN1cmUgc3VjaCBmYWlsdXJlIGluIGEgcmVhc29uYWJsZQotcGVyaW9kIG9mIHRpbWUgYWZ0ZXIgYmVjb21pbmcgYXdhcmUgb2Ygc3VjaCBub25jb21wbGlhbmNlLiBJZiBhbGwgUmVjaXBpZW50J3MKLXJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCB0ZXJtaW5hdGUsIFJlY2lwaWVudCBhZ3JlZXMgdG8gY2Vhc2UgdXNlIGFuZAotZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGFzIHNvb24gYXMgcmVhc29uYWJseSBwcmFjdGljYWJsZS4gSG93ZXZlciwKLVJlY2lwaWVudCdzIG9ibGlnYXRpb25zIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFuZCBhbnkgbGljZW5zZXMgZ3JhbnRlZCBieQotUmVjaXBpZW50IHJlbGF0aW5nIHRvIHRoZSBQcm9ncmFtIHNoYWxsIGNvbnRpbnVlIGFuZCBzdXJ2aXZlLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RXZlcnlvbmUgaXMgcGVybWl0dGVkIHRvIGNvcHkgYW5kIGRpc3RyaWJ1dGUKLWNvcGllcyBvZiB0aGlzIEFncmVlbWVudCwgYnV0IGluIG9yZGVyIHRvIGF2b2lkIGluY29uc2lzdGVuY3kgdGhlIEFncmVlbWVudCBpcwotY29weXJpZ2h0ZWQgYW5kIG1heSBvbmx5IGJlIG1vZGlmaWVkIGluIHRoZSBmb2xsb3dpbmcgbWFubmVyLiBUaGUgQWdyZWVtZW50Ci1TdGV3YXJkIHJlc2VydmVzIHRoZSByaWdodCB0byBwdWJsaXNoIG5ldyB2ZXJzaW9ucyAoaW5jbHVkaW5nIHJldmlzaW9ucykgb2YKLXRoaXMgQWdyZWVtZW50IGZyb20gdGltZSB0byB0aW1lLiBObyBvbmUgb3RoZXIgdGhhbiB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgaGFzCi10aGUgcmlnaHQgdG8gbW9kaWZ5IHRoaXMgQWdyZWVtZW50LiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIHRoZSBpbml0aWFsCi1BZ3JlZW1lbnQgU3Rld2FyZC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYXkgYXNzaWduIHRoZSByZXNwb25zaWJpbGl0eSB0bwotc2VydmUgYXMgdGhlIEFncmVlbWVudCBTdGV3YXJkIHRvIGEgc3VpdGFibGUgc2VwYXJhdGUgZW50aXR5LiBFYWNoIG5ldyB2ZXJzaW9uCi1vZiB0aGUgQWdyZWVtZW50IHdpbGwgYmUgZ2l2ZW4gYSBkaXN0aW5ndWlzaGluZyB2ZXJzaW9uIG51bWJlci4gVGhlIFByb2dyYW0KLShpbmNsdWRpbmcgQ29udHJpYnV0aW9ucykgbWF5IGFsd2F5cyBiZSBkaXN0cmlidXRlZCBzdWJqZWN0IHRvIHRoZSB2ZXJzaW9uIG9mCi10aGUgQWdyZWVtZW50IHVuZGVyIHdoaWNoIGl0IHdhcyByZWNlaXZlZC4gSW4gYWRkaXRpb24sIGFmdGVyIGEgbmV3IHZlcnNpb24gb2YKLXRoZSBBZ3JlZW1lbnQgaXMgcHVibGlzaGVkLCBDb250cmlidXRvciBtYXkgZWxlY3QgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbQotKGluY2x1ZGluZyBpdHMgQ29udHJpYnV0aW9ucykgdW5kZXIgdGhlIG5ldyB2ZXJzaW9uLiBFeGNlcHQgYXMgZXhwcmVzc2x5IHN0YXRlZAotaW4gU2VjdGlvbnMgMihhKSBhbmQgMihiKSBhYm92ZSwgUmVjaXBpZW50IHJlY2VpdmVzIG5vIHJpZ2h0cyBvciBsaWNlbnNlcyB0bwotdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBvZiBhbnkgQ29udHJpYnV0b3IgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIHdoZXRoZXIKLWV4cHJlc3NseSwgYnkgaW1wbGljYXRpb24sIGVzdG9wcGVsIG9yIG90aGVyd2lzZS4gQWxsIHJpZ2h0cyBpbiB0aGUgUHJvZ3JhbSBub3QKLWV4cHJlc3NseSBncmFudGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFyZSByZXNlcnZlZC48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPlRoaXMgQWdyZWVtZW50IGlzIGdvdmVybmVkIGJ5IHRoZSBsYXdzIG9mIHRoZQotU3RhdGUgb2YgTmV3IFlvcmsgYW5kIHRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgbGF3cyBvZiB0aGUgVW5pdGVkIFN0YXRlcyBvZgotQW1lcmljYS4gTm8gcGFydHkgdG8gdGhpcyBBZ3JlZW1lbnQgd2lsbCBicmluZyBhIGxlZ2FsIGFjdGlvbiB1bmRlciB0aGlzCi1BZ3JlZW1lbnQgbW9yZSB0aGFuIG9uZSB5ZWFyIGFmdGVyIHRoZSBjYXVzZSBvZiBhY3Rpb24gYXJvc2UuIEVhY2ggcGFydHkgd2FpdmVzCi1pdHMgcmlnaHRzIHRvIGEganVyeSB0cmlhbCBpbiBhbnkgcmVzdWx0aW5nIGxpdGlnYXRpb24uPC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48IVtpZiAhc3VwcG9ydEVtcHR5UGFyYXNdPiZuYnNwOzwhW2VuZGlmXT48bzpwPjwvbzpwPjwvcD4KLQotPC9kaXY+Ci0KLTwvYm9keT4KLQotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlRmVhdHVyZS9mZWF0dXJlLnByb3BlcnRpZXMgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVGZWF0dXJlL2ZlYXR1cmUucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjY3ZjUzNC4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVGZWF0dXJlL2ZlYXR1cmUucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDE0NSArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgZmVhdHVyZS5wcm9wZXJ0aWVzCi0jIGNvbnRhaW5zIGV4dGVybmFsaXplZCBzdHJpbmdzIGZvciBmZWF0dXJlLnhtbAotIyAiJWZvbyIgaW4gZmVhdHVyZS54bWwgY29ycmVzcG9uZHMgdG8gdGhlIGtleSAiZm9vIiBpbiB0aGlzIGZpbGUKLSMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKLSMgVGhpcyBmaWxlIHNob3VsZCBiZSB0cmFuc2xhdGVkLgotCi0jICJmZWF0dXJlTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBmZWF0dXJlCi1mZWF0dXJlTmFtZT1EYWxpIEphdmEgUGVyc2lzdGVuY2UgQVBJIChKUEEpIFRvb2xzCi0KLSMgInByb3ZpZGVyTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBjb21wYW55IHRoYXQgcHJvdmlkZXMgdGhlIGZlYXR1cmUKLXByb3ZpZGVyTmFtZT1FY2xpcHNlLm9yZwotCi0jICJ1cGRhdGVTaXRlTmFtZSIgcHJvcGVydHkgLSBsYWJlbCBmb3IgdGhlIHVwZGF0ZSBzaXRlCi11cGRhdGVTaXRlTmFtZT1UaGUgRWNsaXBzZSBXZWIgVG9vbHMgUGxhdGZvcm0gKFdUUCkgUHJvamVjdCB1cGRhdGUgc2l0ZQotCi0jICJkZXNjcmlwdGlvbiIgcHJvcGVydHkgLSBkZXNjcmlwdGlvbiBvZiB0aGUgZmVhdHVyZQotZGVzY3JpcHRpb249RGFsaSBKYXZhIFBlcnNpc3RlbmNlIEFQSSAoSlBBKSBUb29scwotCi0jICJjb3B5cmlnaHQiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIENvcHlyaWdodCIKLWNvcHlyaWdodD1cCi1Db3B5cmlnaHQgKGMpIDIwMDYgMjAwOCBPcmFjbGUgQ29ycG9yYXRpb24uXG5cCi1BbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzXG5cCi1hcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjBcblwKLXdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0XG5cCi1odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbFxuXAotXG5cCi1Db250cmlidXRvcnM6XG5cCi0gICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uXG4KLSMjIyMjIyMjIyMjIyMjIyMgZW5kIG9mIGNvcHlyaWdodCBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotIyAibGljZW5zZVVSTCIgcHJvcGVydHkgLSBVUkwgb2YgdGhlICJGZWF0dXJlIExpY2Vuc2UiCi0jIGRvIG5vdCB0cmFuc2xhdGUgdmFsdWUgLSBqdXN0IGNoYW5nZSB0byBwb2ludCB0byBhIGxvY2FsZS1zcGVjaWZpYyBIVE1MIHBhZ2UKLWxpY2Vuc2VVUkw9bGljZW5zZS5odG1sCi0KLSMgImxpY2Vuc2UiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIExpY2Vuc2UiCi0jIHNob3VsZCBiZSBwbGFpbiB0ZXh0IHZlcnNpb24gb2YgbGljZW5zZSBhZ3JlZW1lbnQgcG9pbnRlZCB0byBiZSAibGljZW5zZVVSTCIKLWxpY2Vuc2U9XAotRUNMSVBTRSBGT1VOREFUSU9OIFNPRlRXQVJFIFVTRVIgQUdSRUVNRU5UXG5cCi1KdW5lIDA2LCAyMDA3XG5cCi1cblwKLVVzYWdlIE9mIENvbnRlbnRcblwKLVxuXAotVEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUlxuXAotT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUyAoQ09MTEVDVElWRUxZICJDT05URU5UIikuXG5cCi1VU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVNcblwKLUFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUlxuXAotTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVVxuXAotQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVFxuXAotQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFNcblwKLU9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFXG5cCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TXG5cCi1PRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRFxuXAotQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULlxuXAotXG5cCi1BcHBsaWNhYmxlIExpY2Vuc2VzXG5cCi1cblwKLVVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uXG5cCi1pcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpY1xuXAotTGljZW5zZSBWZXJzaW9uIDEuMCAoIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXNcblwKLUNvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLlxuXAotRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuXG5cCi1cblwKLUNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLFxuXAotZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZS5vcmcgQ1ZTXG5cCi1yZXBvc2l0b3J5ICgiUmVwb3NpdG9yeSIpIGluIENWUyBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIGF2YWlsYWJsZVxuXAotYXMgZG93bmxvYWRhYmxlIGFyY2hpdmVzICgiRG93bmxvYWRzIikuXG5cCi1cblwKLSAgIC0gQ29udGVudCBtYXkgYmUgc3RydWN0dXJlZCBhbmQgcGFja2FnZWQgaW50byBtb2R1bGVzIHRvIGZhY2lsaXRhdGUgZGVsaXZlcmluZyxcblwKLSAgICAgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiBUeXBpY2FsIG1vZHVsZXMgbWF5IGluY2x1ZGUgcGx1Zy1pbnMgKCJQbHVnLWlucyIpLFxuXAotICAgICBwbHVnLWluIGZyYWdtZW50cyAoIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLlxuXAotICAgLSBFYWNoIFBsdWctaW4gb3IgRnJhZ21lbnQgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBvciBKQVIgKEphdmE/IEFSY2hpdmUpXG5cCi0gICAgIGluIGEgZGlyZWN0b3J5IG5hbWVkICJwbHVnaW5zIi5cblwKLSAgIC0gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuXG5cCi0gICAgIEVhY2ggRmVhdHVyZSBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IGluIGEgZGlyZWN0b3J5IG5hbWVkICJmZWF0dXJlcyIuXG5cCi0gICAgIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvblxuXAotICAgICBudW1iZXJzIG9mIHRoZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuXG5cCi0gICAtIEZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlc1xuXAotICAgICBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy5cblwKLVxuXAotRmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIEZpbGVzIG5hbWVkXG5cCi0iZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZlxuXAotSW5jbHVkZWQgRmVhdHVyZXMuXG5cCi1cblwKLVRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmVcblwKLWNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZFxuXAotY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kIEluY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWRcblwKLWluIGZpbGVzIG5hbWVkICJsaWNlbnNlLmh0bWwiICgiRmVhdHVyZSBMaWNlbnNlcyIpLiBBYm91dHMgYW5kIEZlYXR1cmVcblwKLUxpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSBkaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGVcblwKLWluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOlxuXAotXG5cCi0gICAtIFRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeVxuXAotICAgLSBQbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3Rvcmllc1xuXAotICAgLSBJbnNpZGUgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBwYWNrYWdlZCBhcyBKQVJzXG5cCi0gICAtIFN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnNcblwKLSAgIC0gRmVhdHVyZSBkaXJlY3Rvcmllc1xuXAotXG5cCi1Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlXG5cCi1FY2xpcHNlIFVwZGF0ZSBNYW5hZ2VyLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFVwZGF0ZVxuXAotTGljZW5zZSIpIGR1cmluZyB0aGUgaW5zdGFsbGF0aW9uIHByb2Nlc3MuIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zXG5cCi1JbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdVxuXAotd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvciBpbmZvcm1cblwKLXlvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW5cblwKLXRoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIuIFN1Y2ggQWJvdXRzLFxuXAotRmVhdHVyZSBMaWNlbnNlcyBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kXG5cCi1jb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXJcblwKLXVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluIHRoYXQgZGlyZWN0b3J5LlxuXAotXG5cCi1USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVJcblwKLVRPIFRIRSBFUEwgT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLlxuXAotU09NRSBPRiBUSEVTRSBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOlxuXAotXG5cCi0gICAgLSBDb21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbClcblwKLSAgICAtIEFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFKVxuXAotICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wKVxuXAotICAgIC0gSUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sKVxuXAotICAgIC0gTWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwpXG5cCi0gICAgLSBNb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sKVxuXAotICAgIC0gQ29tbW9uIERldmVsb3BtZW50IGFuZCBEaXN0cmlidXRpb24gTGljZW5zZSAoQ0RETCkgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwpXG5cCi1cblwKLUlUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1JcblwKLVRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlXG5cCi1pcyBwcm92aWRlZCwgcGxlYXNlIGNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9uc1xuXAotZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LlxuXAotXG5cCi1DcnlwdG9ncmFwaHlcblwKLVxuXAotQ29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlXG5cCi1jdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsXG5cCi1hbmQvb3IgcmUtZXhwb3J0IHRvIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFXG5cCi11c2luZyBhbnkgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cyxcblwKLXJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIG9yIHVzZSxcblwKLWFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLlxuXAotXG5cCi1KYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIFN1biBNaWNyb3N5c3RlbXMsIEluYy4gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC5cbgotIyMjIyMjIyMjIyMgZW5kIG9mIGxpY2Vuc2UgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVGZWF0dXJlL2xpY2Vuc2UuaHRtbCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvbGljZW5zZS5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmZWM0YTQ4Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZUZlYXR1cmUvbGljZW5zZS5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsODIgKzAsMCBAQAotPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMC8vRU4iPgotPGh0bWw+Ci08aGVhZD4KLTxtZXRhIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4KLTx0aXRsZT5FY2xpcHNlLm9yZyBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvdGl0bGU+Ci08L2hlYWQ+Ci0KLTxib2R5IGxhbmc9IkVOLVVTIiBsaW5rPWJsdWUgdmxpbms9cHVycGxlPgotPGgyPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvaDI+Ci08cD5KdW5lIDA2LCAyMDA3PC9wPgotCi08aDM+VXNhZ2UgT2YgQ29udGVudDwvaDM+Ci0KLTxwPlRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiBBTkQvT1IgT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUwotICAgKENPTExFQ1RJVkVMWSAmcXVvdDtDT05URU5UJnF1b3Q7KS4gIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQKLSAgIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VIEFHUkVFIFRIQVQgWU9VUiBVU0UKLSAgIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SCi0gICBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQKLSAgIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULjwvcD4KLSAgIAotPGgzPkFwcGxpY2FibGUgTGljZW5zZXM8L2gzPiAgIAotICAgCi08cD5Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wCi0gICAoJnF1b3Q7RVBMJnF1b3Q7KS4gIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpcyBDb250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L2E+LgotICAgRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICZxdW90O1Byb2dyYW0mcXVvdDsgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvcD4KLQotPHA+Q29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsIGRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2Uub3JnIENWUyByZXBvc2l0b3J5ICgmcXVvdDtSZXBvc2l0b3J5JnF1b3Q7KSBpbiBDVlMKLSAgIG1vZHVsZXMgKCZxdW90O01vZHVsZXMmcXVvdDspIGFuZCBtYWRlIGF2YWlsYWJsZSBhcyBkb3dubG9hZGFibGUgYXJjaGl2ZXMgKCZxdW90O0Rvd25sb2FkcyZxdW90OykuPC9wPgotICAgCi08dWw+Ci0JPGxpPkNvbnRlbnQgbWF5IGJlIHN0cnVjdHVyZWQgYW5kIHBhY2thZ2VkIGludG8gbW9kdWxlcyB0byBmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsIGV4dGVuZGluZywgYW5kIHVwZ3JhZGluZyB0aGUgQ29udGVudC4gIFR5cGljYWwgbW9kdWxlcyBtYXkgaW5jbHVkZSBwbHVnLWlucyAoJnF1b3Q7UGx1Zy1pbnMmcXVvdDspLCBwbHVnLWluIGZyYWdtZW50cyAoJnF1b3Q7RnJhZ21lbnRzJnF1b3Q7KSwgYW5kIGZlYXR1cmVzICgmcXVvdDtGZWF0dXJlcyZxdW90OykuPC9saT4KLQk8bGk+RWFjaCBQbHVnLWluIG9yIEZyYWdtZW50IG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3Rvcnkgb3IgSkFSIChKYXZhJnRyYWRlOyBBUmNoaXZlKSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtwbHVnaW5zJnF1b3Q7LjwvbGk+Ci0JPGxpPkEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLiAgRWFjaCBGZWF0dXJlIG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3RvcnkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgJnF1b3Q7ZmVhdHVyZXMmcXVvdDsuICBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnhtbCZxdW90OyBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgdGhlIFBsdWctaW5zCi0gICAgICBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuPC9saT4KLQk8bGk+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoJnF1b3Q7SW5jbHVkZWQgRmVhdHVyZXMmcXVvdDspLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnhtbCZxdW90OyBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgRmVhdHVyZXMuPC9saT4KLTwvdWw+ICAgCi0gCi08cD5UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAmcXVvdDthYm91dC5odG1sJnF1b3Q7ICgmcXVvdDtBYm91dHMmcXVvdDspLiBUaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIEZlYXR1cmVzIGFuZAotSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAmcXVvdDtsaWNlbnNlLmh0bWwmcXVvdDsgKCZxdW90O0ZlYXR1cmUgTGljZW5zZXMmcXVvdDspLiAgQWJvdXRzIGFuZCBGZWF0dXJlIExpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSBkaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGUKLWluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOjwvcD4KLQotPHVsPgotCTxsaT5UaGUgdG9wLWxldmVsIChyb290KSBkaXJlY3Rvcnk8L2xpPgotCTxsaT5QbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3RvcmllczwvbGk+Ci0JPGxpPkluc2lkZSBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHBhY2thZ2VkIGFzIEpBUnM8L2xpPgotCTxsaT5TdWItZGlyZWN0b3JpZXMgb2YgdGhlIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtzcmMmcXVvdDsgb2YgY2VydGFpbiBQbHVnLWluczwvbGk+Ci0JPGxpPkZlYXR1cmUgZGlyZWN0b3JpZXM8L2xpPgotPC91bD4KLQkJCi08cD5Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlIEVjbGlwc2UgVXBkYXRlIE1hbmFnZXIsIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoJnF1b3Q7RmVhdHVyZSBVcGRhdGUgTGljZW5zZSZxdW90OykgZHVyaW5nIHRoZQotaW5zdGFsbGF0aW9uIHByb2Nlc3MuICBJZiB0aGUgRmVhdHVyZSBjb250YWlucyBJbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdSB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgdGhlIEluY2x1ZGVkIEZlYXR1cmVzIG9yCi1pbmZvcm0geW91IHdoZXJlIHlvdSBjYW4gbG9jYXRlIHRoZW0uICBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW4gdGhlICZxdW90O2xpY2Vuc2UmcXVvdDsgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgJnF1b3Q7ZmVhdHVyZS5wcm9wZXJ0aWVzJnF1b3Q7IGZvdW5kIHdpdGhpbiBhIEZlYXR1cmUuCi1TdWNoIEFib3V0cywgRmVhdHVyZSBMaWNlbnNlcywgYW5kIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXIgdXNlIG9mIHRoZSBhc3NvY2lhdGVkIENvbnRlbnQgaW4KLXRoYXQgZGlyZWN0b3J5LjwvcD4KLQotPHA+VEhFIEFCT1VUUywgRkVBVFVSRSBMSUNFTlNFUywgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUiBUTyBUSEUgRVBMIE9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy4gIFNPTUUgT0YgVEhFU0UKLU9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6PC9wPgotCi08dWw+Ci0JPGxpPkNvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbDwvYT4pPC9saT4KLQk8bGk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFPC9hPik8L2xpPgotCTxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMDwvYT4pPC9saT4KLQk8bGk+SUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sIj5odHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vZGV2ZWxvcGVyd29ya3Mvb3BlbnNvdXJjZS9saWNlbnNlMTAuaHRtbDwvYT4pPC9saT4JCi0JPGxpPk1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sIj5odHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbDwvYT4pPC9saT4KLQk8bGk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbCI+aHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sPC9hPik8L2xpPgotICA8TEk+Q29tbW9uIERldmVsb3BtZW50IGFuZCBEaXN0cmlidXRpb24gTGljZW5zZSAoQ0RETCkgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sIj5odHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwpPC9BPgotICA8L0xJPgotPC9VTD4KLQotPHA+SVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgQ09ORElUSU9OUyBQUklPUiBUTyBVU0UgT0YgVEhFIENPTlRFTlQuICBJZiBubyBBYm91dCwgRmVhdHVyZSBMaWNlbnNlLCBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIGlzIHByb3ZpZGVkLCBwbGVhc2UKLWNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuPC9wPgotCi08aDM+Q3J5cHRvZ3JhcGh5PC9oMz4KLQotPHA+Q29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlIGN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSwgYW5kL29yIHJlLWV4cG9ydCB0bwotICAgYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkUgdXNpbmcgYW55IGVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsIHJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsCi0gICBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLjwvcD4KLSAgIAotPHNtYWxsPkphdmEgYW5kIGFsbCBKYXZhLWJhc2VkIHRyYWRlbWFya3MgYXJlIHRyYWRlbWFya3Mgb2YgU3VuIE1pY3Jvc3lzdGVtcywgSW5jLiBpbiB0aGUgVW5pdGVkIFN0YXRlcywgb3RoZXIgY291bnRyaWVzLCBvciBib3RoLjwvc21hbGw+ICAgCi08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vYWJvdXQuaHRtbCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9hYm91dC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkNDkxNmRmLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9hYm91dC5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsMjcgKzAsMCBAQAotPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMC8vRU4iPgotPGh0bWw+Ci08aGVhZD4KLTx0aXRsZT5BYm91dDwvdGl0bGU+Ci08bWV0YSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9SVNPLTg4NTktMSI+Ci08L2hlYWQ+Ci08Ym9keSBsYW5nPSJFTi1VUyI+Ci08aDI+QWJvdXQgVGhpcyBDb250ZW50PC9oMj4KLQotPHA+SnVuZSAwNiwgMjAwNzwvcD4JCi08aDM+TGljZW5zZTwvaDM+Ci0KLTxwPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIGFsbCBjb250ZW50IGluIHRoaXMgcGx1Zy1pbiAoJnF1b3Q7Q29udGVudCZxdW90OykuICBVbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCBiZWxvdywgdGhlIENvbnRlbnQgaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUKLUVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKCZxdW90O0VQTCZxdW90OykuICBBIGNvcHkgb2YgdGhlIEVQTCBpcyBhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sPC9hPi4KLUZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAmcXVvdDtQcm9ncmFtJnF1b3Q7IHdpbGwgbWVhbiB0aGUgQ29udGVudC48L3A+Ci0KLTxwPklmIHlvdSBkaWQgbm90IHJlY2VpdmUgdGhpcyBDb250ZW50IGRpcmVjdGx5IGZyb20gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiwgdGhlIENvbnRlbnQgaXMgYmVpbmcgcmVkaXN0cmlidXRlZCBieSBhbm90aGVyIHBhcnR5ICgmcXVvdDtSZWRpc3RyaWJ1dG9yJnF1b3Q7KSBhbmQgZGlmZmVyZW50IHRlcm1zIGFuZCBjb25kaXRpb25zIG1heQotYXBwbHkgdG8geW91ciB1c2Ugb2YgYW55IG9iamVjdCBjb2RlIGluIHRoZSBDb250ZW50LiAgQ2hlY2sgdGhlIFJlZGlzdHJpYnV0b3IncyBsaWNlbnNlIHRoYXQgd2FzIHByb3ZpZGVkIHdpdGggdGhlIENvbnRlbnQuICBJZiBubyBzdWNoIGxpY2Vuc2UgZXhpc3RzLCBjb250YWN0IHRoZSBSZWRpc3RyaWJ1dG9yLiAgVW5sZXNzIG90aGVyd2lzZQotaW5kaWNhdGVkIGJlbG93LCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVQTCBzdGlsbCBhcHBseSB0byBhbnkgc291cmNlIGNvZGUgaW4gdGhlIENvbnRlbnQuPC9wPgotCi08aDM+U291cmNlIENvZGU8L2gzPgotPHA+VGhpcyBwbHVnLWluIGNvbnRhaW5zIHNvdXJjZSBjb2RlIHppcCBmaWxlcyAoJnF1b3Q7U291cmNlIFppcHMmcXVvdDspIHRoYXQgY29ycmVzcG9uZCB0byBiaW5hcnkgY29udGVudCBpbiBvdGhlciBwbHVnLWlucy4gVGhlc2UgU291cmNlIFppcHMgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIGRpZmZlcmVudCBsaWNlbnNlCi1hZ3JlZW1lbnRzIGFuZC9vciBub3RpY2VzLiBEZXRhaWxzIGFib3V0IHRoZXNlIGxpY2Vuc2UgYWdyZWVtZW50cyBhbmQgbm90aWNlcyBhcmUgY29udGFpbmVkIGluICZxdW90O2Fib3V0Lmh0bWwmcXVvdDsgZmlsZXMgKCZxdW90O0Fib3V0cyZxdW90OykgbG9jYXRlZCBpbiBzdWItZGlyZWN0b3JpZXMgaW4gdGhlCi1zcmMvIGRpcmVjdG9yeSBvZiB0aGlzIHBsdWctaW4uIFN1Y2ggQWJvdXRzIGdvdmVybiB5b3VyIHVzZSBvZiB0aGUgU291cmNlIFppcHMgaW4gdGhhdCBkaXJlY3RvcnksIG5vdCB0aGUgRVBMLjwvcD4KLQotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2Fib3V0LmluaSBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9hYm91dC5pbmkKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDJkZWUzNmEuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2Fib3V0LmluaQorKysgL2Rldi9udWxsCkBAIC0xLDMxICswLDAgQEAKLSMgYWJvdXQuaW5pCi0jIGNvbnRhaW5zIGluZm9ybWF0aW9uIGFib3V0IGEgZmVhdHVyZQotIyBqYXZhLmlvLlByb3BlcnRpZXMgZmlsZSAoSVNPIDg4NTktMSB3aXRoICJcIiBlc2NhcGVzKQotIyAiJWtleSIgYXJlIGV4dGVybmFsaXplZCBzdHJpbmdzIGRlZmluZWQgaW4gYWJvdXQucHJvcGVydGllcwotIyBUaGlzIGZpbGUgZG9lcyBub3QgbmVlZCB0byBiZSB0cmFuc2xhdGVkLgotCi0jIFByb3BlcnR5ICJhYm91dFRleHQiIGNvbnRhaW5zIGJsdXJiIGZvciAiQWJvdXQiIGRpYWxvZyAodHJhbnNsYXRlZCkKLWFib3V0VGV4dD0lYmx1cmIKLQotIyBQcm9wZXJ0eSAid2luZG93SW1hZ2UiIGNvbnRhaW5zIHBhdGggdG8gd2luZG93IGljb24gKDE2eDE2KQotIyBuZWVkZWQgZm9yIHByaW1hcnkgZmVhdHVyZXMgb25seQotCi0jIFByb3BlcnR5ICJmZWF0dXJlSW1hZ2UiIGNvbnRhaW5zIHBhdGggdG8gZmVhdHVyZSBpbWFnZSAoMzJ4MzIpCi1mZWF0dXJlSW1hZ2U9ZWNsaXBzZTMyLmdpZgotCi0jIFByb3BlcnR5ICJhYm91dEltYWdlIiBjb250YWlucyBwYXRoIHRvIHByb2R1Y3QgaW1hZ2UgKDUwMHgzMzAgb3IgMTE1eDE2NCkKLSMgbmVlZGVkIGZvciBwcmltYXJ5IGZlYXR1cmVzIG9ubHkKLQotIyBQcm9wZXJ0eSAiYXBwTmFtZSIgY29udGFpbnMgbmFtZSBvZiB0aGUgYXBwbGljYXRpb24gKG5vdCB0cmFuc2xhdGVkKQotIyBuZWVkZWQgZm9yIHByaW1hcnkgZmVhdHVyZXMgb25seQotCi0jIFByb3BlcnR5ICJ3ZWxjb21lUGFnZSIgY29udGFpbnMgcGF0aCB0byB3ZWxjb21lIHBhZ2UgKHNwZWNpYWwgWE1MLWJhc2VkIGZvcm1hdCkKLSMgb3B0aW9uYWwKLQotIyBQcm9wZXJ0eSAid2VsY29tZVBlcnNwZWN0aXZlIiBjb250YWlucyB0aGUgaWQgb2YgdGhlIHBlcnNwZWN0aXZlIGluIHdoaWNoIHRoZQotIyB3ZWxjb21lIHBhZ2UgaXMgdG8gYmUgb3BlbmVkLgotIyBvcHRpb25hbAotCi0KLQotCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vYWJvdXQubWFwcGluZ3MgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vYWJvdXQubWFwcGluZ3MKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGEyODM5MGEuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2Fib3V0Lm1hcHBpbmdzCisrKyAvZGV2L251bGwKQEAgLTEsNiArMCwwIEBACi0jIGFib3V0Lm1hcHBpbmdzCi0jIGNvbnRhaW5zIGZpbGwtaW5zIGZvciBhYm91dC5wcm9wZXJ0aWVzCi0jIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCi0jIFRoaXMgZmlsZSBkb2VzIG5vdCBuZWVkIHRvIGJlIHRyYW5zbGF0ZWQuCi0KLTA9QGJ1aWxkQApkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2Fib3V0LnByb3BlcnRpZXMgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vYWJvdXQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMTU0MTdmZi4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vYWJvdXQucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDI2ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA4IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBhYm91dC5wcm9wZXJ0aWVzCi0jIGNvbnRhaW5zIGV4dGVybmFsaXplZCBzdHJpbmdzIGZvciBhYm91dC5pbmkKLSMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKLSMgZmlsbC1pbnMgYXJlIHN1cHBsaWVkIGJ5IGFib3V0Lm1hcHBpbmdzCi0jIFRoaXMgZmlsZSBzaG91bGQgYmUgdHJhbnNsYXRlZC4KLSMKLSMgRG8gbm90IHRyYW5zbGF0ZSBhbnkgdmFsdWVzIHN1cnJvdW5kZWQgYnkge30KLQotYmx1cmI9RGFsaSBKYXZhIFBlcnNpc3RlbmNlIEFQSSAoSlBBKSBUb29scyBTb3VyY2VcblwKLVxuXAotVmVyc2lvbjoge2ZlYXR1cmVWZXJzaW9ufVxuXAotQnVpbGQgaWQ6IHswfVxuXAotXG5cCi0oYykgQ29weXJpZ2h0IEVjbGlwc2UgY29udHJpYnV0b3JzIGFuZCBvdGhlcnMgMjAwOC4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG5cCi1WaXNpdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL3dlYnRvb2xzCi0KZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9idWlsZC5wcm9wZXJ0aWVzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2J1aWxkLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGNlOTUyOWIuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2J1aWxkLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwxMiArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLWJpbi5pbmNsdWRlcyA9IGFib3V0Lmh0bWwsIGFib3V0LmluaSwgYWJvdXQubWFwcGluZ3MsIGFib3V0LnByb3BlcnRpZXMsIGVjbGlwc2UzMi5naWYsIHBsdWdpbi5wcm9wZXJ0aWVzLCBwbHVnaW4ueG1sLCBzcmMvKiosIE1FVEEtSU5GLwotc291cmNlUGx1Z2luID0gdHJ1ZQpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2VjbGlwc2UzMi5naWYgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vZWNsaXBzZTMyLmdpZgpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTZhZDdjYy4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vZWNsaXBzZTMyLmdpZgorKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9lY2xpcHNlMzIucG5nIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2VjbGlwc2UzMi5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDUwYWU0OWQuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2VjbGlwc2UzMi5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vZWNsaXBzZV91cGRhdGVfMTIwLmpwZyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiZmRmNzA4Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2VwbC12MTAuaHRtbCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9lcGwtdjEwLmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAyMmFkMjkuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL2VwbC12MTAuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDMyOCArMCwwIEBACi08aHRtbCB4bWxuczpvPSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTpvZmZpY2UiCi14bWxuczp3PSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTp3b3JkIgoteG1sbnM9Imh0dHA6Ly93d3cudzMub3JnL1RSL1JFQy1odG1sNDAiPgotCi08aGVhZD4KLTxtZXRhIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD13aW5kb3dzLTEyNTIiPgotPG1ldGEgbmFtZT1Qcm9nSWQgY29udGVudD1Xb3JkLkRvY3VtZW50PgotPG1ldGEgbmFtZT1HZW5lcmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgOSI+Ci08bWV0YSBuYW1lPU9yaWdpbmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgOSI+Ci08bGluayByZWw9RmlsZS1MaXN0Ci1ocmVmPSIuL0VjbGlwc2UlMjBFUEwlMjAyMDAzXzExXzEwJTIwRmluYWxfZmlsZXMvZmlsZWxpc3QueG1sIj4KLTx0aXRsZT5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gVmVyc2lvbiAxLjA8L3RpdGxlPgotPCEtLVtpZiBndGUgbXNvIDldPjx4bWw+Ci0gPG86RG9jdW1lbnRQcm9wZXJ0aWVzPgotICA8bzpSZXZpc2lvbj4yPC9vOlJldmlzaW9uPgotICA8bzpUb3RhbFRpbWU+MzwvbzpUb3RhbFRpbWU+Ci0gIDxvOkNyZWF0ZWQ+MjAwNC0wMy0wNVQyMzowMzowMFo8L286Q3JlYXRlZD4KLSAgPG86TGFzdFNhdmVkPjIwMDQtMDMtMDVUMjM6MDM6MDBaPC9vOkxhc3RTYXZlZD4KLSAgPG86UGFnZXM+NDwvbzpQYWdlcz4KLSAgPG86V29yZHM+MTYyNjwvbzpXb3Jkcz4KLSAgPG86Q2hhcmFjdGVycz45MjcwPC9vOkNoYXJhY3RlcnM+Ci0gICA8bzpMaW5lcz43NzwvbzpMaW5lcz4KLSAgPG86UGFyYWdyYXBocz4xODwvbzpQYXJhZ3JhcGhzPgotICA8bzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4xMTM4NDwvbzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4KLSAgPG86VmVyc2lvbj45LjQ0MDI8L286VmVyc2lvbj4KLSA8L286RG9jdW1lbnRQcm9wZXJ0aWVzPgotPC94bWw+PCFbZW5kaWZdLS0+PCEtLVtpZiBndGUgbXNvIDldPjx4bWw+Ci0gPHc6V29yZERvY3VtZW50PgotICA8dzpUcmFja1JldmlzaW9ucy8+Ci0gPC93OldvcmREb2N1bWVudD4KLTwveG1sPjwhW2VuZGlmXS0tPgotPHN0eWxlPgotPCEtLQotIC8qIEZvbnQgRGVmaW5pdGlvbnMgKi8KLUBmb250LWZhY2UKLQl7Zm9udC1mYW1pbHk6VGFob21hOwotCXBhbm9zZS0xOjIgMTEgNiA0IDMgNSA0IDQgMiA0OwotCW1zby1mb250LWNoYXJzZXQ6MDsKLQltc28tZ2VuZXJpYy1mb250LWZhbWlseTpzd2lzczsKLQltc28tZm9udC1waXRjaDp2YXJpYWJsZTsKLQltc28tZm9udC1zaWduYXR1cmU6NTUzNjc5NDk1IC0yMTQ3NDgzNjQ4IDggMCA2NjA0NyAwO30KLSAvKiBTdHlsZSBEZWZpbml0aW9ucyAqLwotcC5Nc29Ob3JtYWwsIGxpLk1zb05vcm1hbCwgZGl2Lk1zb05vcm1hbAotCXttc28tc3R5bGUtcGFyZW50OiIiOwotCW1hcmdpbjowaW47Ci0JbWFyZ2luLWJvdHRvbTouMDAwMXB0OwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXAKLQl7bWFyZ2luLXJpZ2h0OjBpbjsKLQltc28tbWFyZ2luLXRvcC1hbHQ6YXV0bzsKLQltc28tbWFyZ2luLWJvdHRvbS1hbHQ6YXV0bzsKLQltYXJnaW4tbGVmdDowaW47Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZToxMi4wcHQ7Ci0JZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotcC5CYWxsb29uVGV4dCwgbGkuQmFsbG9vblRleHQsIGRpdi5CYWxsb29uVGV4dAotCXttc28tc3R5bGUtbmFtZToiQmFsbG9vbiBUZXh0IjsKLQltYXJnaW46MGluOwotCW1hcmdpbi1ib3R0b206LjAwMDFwdDsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjguMHB0OwotCWZvbnQtZmFtaWx5OlRhaG9tYTsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1AcGFnZSBTZWN0aW9uMQotCXtzaXplOjguNWluIDExLjBpbjsKLQltYXJnaW46MS4waW4gMS4yNWluIDEuMGluIDEuMjVpbjsKLQltc28taGVhZGVyLW1hcmdpbjouNWluOwotCW1zby1mb290ZXItbWFyZ2luOi41aW47Ci0JbXNvLXBhcGVyLXNvdXJjZTowO30KLWRpdi5TZWN0aW9uMQotCXtwYWdlOlNlY3Rpb24xO30KLS0tPgotPC9zdHlsZT4KLTwvaGVhZD4KLQotPGJvZHkgbGFuZz1FTi1VUyBzdHlsZT0ndGFiLWludGVydmFsOi41aW4nPgotCi08ZGl2IGNsYXNzPVNlY3Rpb24xPgotCi08cCBhbGlnbj1jZW50ZXIgc3R5bGU9J3RleHQtYWxpZ246Y2VudGVyJz48Yj5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gdiAxLjA8L2I+Ci08L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5USEUgQUNDT01QQU5ZSU5HIFBST0dSQU0gSVMgUFJPVklERUQgVU5ERVIKLVRIRSBURVJNUyBPRiBUSElTIEVDTElQU0UgUFVCTElDIExJQ0VOU0UgKCZxdW90O0FHUkVFTUVOVCZxdW90OykuIEFOWSBVU0UsCi1SRVBST0RVQ1RJT04gT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIENPTlNUSVRVVEVTIFJFQ0lQSUVOVCdTIEFDQ0VQVEFOQ0UKLU9GIFRISVMgQUdSRUVNRU5ULjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+MS4gREVGSU5JVElPTlM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtDb250cmlidXRpb24mcXVvdDsgbWVhbnM6PC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pbiB0aGUgY2FzZSBvZiB0aGUgaW5pdGlhbCBDb250cmlidXRvciwgdGhlIGluaXRpYWwgY29kZSBhbmQgZG9jdW1lbnRhdGlvbgotZGlzdHJpYnV0ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGFuZDxiciBjbGVhcj1sZWZ0PgotYikgaW4gdGhlIGNhc2Ugb2YgZWFjaCBzdWJzZXF1ZW50IENvbnRyaWJ1dG9yOjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmkpCi1jaGFuZ2VzIHRvIHRoZSBQcm9ncmFtLCBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paSkKLWFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbTs8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz53aGVyZQotc3VjaCBjaGFuZ2VzIGFuZC9vciBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gb3JpZ2luYXRlIGZyb20gYW5kIGFyZSBkaXN0cmlidXRlZAotYnkgdGhhdCBwYXJ0aWN1bGFyIENvbnRyaWJ1dG9yLiBBIENvbnRyaWJ1dGlvbiAnb3JpZ2luYXRlcycgZnJvbSBhIENvbnRyaWJ1dG9yCi1pZiBpdCB3YXMgYWRkZWQgdG8gdGhlIFByb2dyYW0gYnkgc3VjaCBDb250cmlidXRvciBpdHNlbGYgb3IgYW55b25lIGFjdGluZyBvbgotc3VjaCBDb250cmlidXRvcidzIGJlaGFsZi4gQ29udHJpYnV0aW9ucyBkbyBub3QgaW5jbHVkZSBhZGRpdGlvbnMgdG8gdGhlCi1Qcm9ncmFtIHdoaWNoOiAoaSkgYXJlIHNlcGFyYXRlIG1vZHVsZXMgb2Ygc29mdHdhcmUgZGlzdHJpYnV0ZWQgaW4gY29uanVuY3Rpb24KLXdpdGggdGhlIFByb2dyYW0gdW5kZXIgdGhlaXIgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBhbmQgKGlpKSBhcmUgbm90IGRlcml2YXRpdmUKLXdvcmtzIG9mIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7Q29udHJpYnV0b3ImcXVvdDsgbWVhbnMgYW55IHBlcnNvbiBvcgotZW50aXR5IHRoYXQgZGlzdHJpYnV0ZXMgdGhlIFByb2dyYW0uPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtMaWNlbnNlZCBQYXRlbnRzICZxdW90OyBtZWFuIHBhdGVudAotY2xhaW1zIGxpY2Vuc2FibGUgYnkgYSBDb250cmlidXRvciB3aGljaCBhcmUgbmVjZXNzYXJpbHkgaW5mcmluZ2VkIGJ5IHRoZSB1c2UKLW9yIHNhbGUgb2YgaXRzIENvbnRyaWJ1dGlvbiBhbG9uZSBvciB3aGVuIGNvbWJpbmVkIHdpdGggdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtQcm9ncmFtJnF1b3Q7IG1lYW5zIHRoZSBDb250cmlidXRpb25zCi1kaXN0cmlidXRlZCBpbiBhY2NvcmRhbmNlIHdpdGggdGhpcyBBZ3JlZW1lbnQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtSZWNpcGllbnQmcXVvdDsgbWVhbnMgYW55b25lIHdobwotcmVjZWl2ZXMgdGhlIFByb2dyYW0gdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGluY2x1ZGluZyBhbGwgQ29udHJpYnV0b3JzLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Mi4gR1JBTlQgT0YgUklHSFRTPC9zcGFuPjwvYj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQKLWEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLCByb3lhbHR5LWZyZWUgY29weXJpZ2h0IGxpY2Vuc2UgdG88c3Bhbgotc3R5bGU9J2NvbG9yOnJlZCc+IDwvc3Bhbj5yZXByb2R1Y2UsIHByZXBhcmUgZGVyaXZhdGl2ZSB3b3JrcyBvZiwgcHVibGljbHkKLWRpc3BsYXksIHB1YmxpY2x5IHBlcmZvcm0sIGRpc3RyaWJ1dGUgYW5kIHN1YmxpY2Vuc2UgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoCi1Db250cmlidXRvciwgaWYgYW55LCBhbmQgc3VjaCBkZXJpdmF0aXZlIHdvcmtzLCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUKLWZvcm0uPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikKLVN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMKLVJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSw8c3BhbiBzdHlsZT0nY29sb3I6Z3JlZW4nPiA8L3NwYW4+cm95YWx0eS1mcmVlCi1wYXRlbnQgbGljZW5zZSB1bmRlciBMaWNlbnNlZCBQYXRlbnRzIHRvIG1ha2UsIHVzZSwgc2VsbCwgb2ZmZXIgdG8gc2VsbCwgaW1wb3J0Ci1hbmQgb3RoZXJ3aXNlIHRyYW5zZmVyIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBpbiBzb3VyY2UKLWNvZGUgYW5kIG9iamVjdCBjb2RlIGZvcm0uIFRoaXMgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgYXBwbHkgdG8gdGhlIGNvbWJpbmF0aW9uCi1vZiB0aGUgQ29udHJpYnV0aW9uIGFuZCB0aGUgUHJvZ3JhbSBpZiwgYXQgdGhlIHRpbWUgdGhlIENvbnRyaWJ1dGlvbiBpcyBhZGRlZAotYnkgdGhlIENvbnRyaWJ1dG9yLCBzdWNoIGFkZGl0aW9uIG9mIHRoZSBDb250cmlidXRpb24gY2F1c2VzIHN1Y2ggY29tYmluYXRpb24KLXRvIGJlIGNvdmVyZWQgYnkgdGhlIExpY2Vuc2VkIFBhdGVudHMuIFRoZSBwYXRlbnQgbGljZW5zZSBzaGFsbCBub3QgYXBwbHkgdG8KLWFueSBvdGhlciBjb21iaW5hdGlvbnMgd2hpY2ggaW5jbHVkZSB0aGUgQ29udHJpYnV0aW9uLiBObyBoYXJkd2FyZSBwZXIgc2UgaXMKLWxpY2Vuc2VkIGhlcmV1bmRlci4gPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YykKLVJlY2lwaWVudCB1bmRlcnN0YW5kcyB0aGF0IGFsdGhvdWdoIGVhY2ggQ29udHJpYnV0b3IgZ3JhbnRzIHRoZSBsaWNlbnNlcyB0byBpdHMKLUNvbnRyaWJ1dGlvbnMgc2V0IGZvcnRoIGhlcmVpbiwgbm8gYXNzdXJhbmNlcyBhcmUgcHJvdmlkZWQgYnkgYW55IENvbnRyaWJ1dG9yCi10aGF0IHRoZSBQcm9ncmFtIGRvZXMgbm90IGluZnJpbmdlIHRoZSBwYXRlbnQgb3Igb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5Ci1yaWdodHMgb2YgYW55IG90aGVyIGVudGl0eS4gRWFjaCBDb250cmlidXRvciBkaXNjbGFpbXMgYW55IGxpYWJpbGl0eSB0byBSZWNpcGllbnQKLWZvciBjbGFpbXMgYnJvdWdodCBieSBhbnkgb3RoZXIgZW50aXR5IGJhc2VkIG9uIGluZnJpbmdlbWVudCBvZiBpbnRlbGxlY3R1YWwKLXByb3BlcnR5IHJpZ2h0cyBvciBvdGhlcndpc2UuIEFzIGEgY29uZGl0aW9uIHRvIGV4ZXJjaXNpbmcgdGhlIHJpZ2h0cyBhbmQKLWxpY2Vuc2VzIGdyYW50ZWQgaGVyZXVuZGVyLCBlYWNoIFJlY2lwaWVudCBoZXJlYnkgYXNzdW1lcyBzb2xlIHJlc3BvbnNpYmlsaXR5Ci10byBzZWN1cmUgYW55IG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgbmVlZGVkLCBpZiBhbnkuIEZvciBleGFtcGxlLAotaWYgYSB0aGlyZCBwYXJ0eSBwYXRlbnQgbGljZW5zZSBpcyByZXF1aXJlZCB0byBhbGxvdyBSZWNpcGllbnQgdG8gZGlzdHJpYnV0ZQotdGhlIFByb2dyYW0sIGl0IGlzIFJlY2lwaWVudCdzIHJlc3BvbnNpYmlsaXR5IHRvIGFjcXVpcmUgdGhhdCBsaWNlbnNlIGJlZm9yZQotZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtLjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmQpCi1FYWNoIENvbnRyaWJ1dG9yIHJlcHJlc2VudHMgdGhhdCB0byBpdHMga25vd2xlZGdlIGl0IGhhcyBzdWZmaWNpZW50IGNvcHlyaWdodAotcmlnaHRzIGluIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgdG8gZ3JhbnQgdGhlIGNvcHlyaWdodCBsaWNlbnNlIHNldCBmb3J0aCBpbgotdGhpcyBBZ3JlZW1lbnQuIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4zLiBSRVFVSVJFTUVOVFM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5BIENvbnRyaWJ1dG9yIG1heSBjaG9vc2UgdG8gZGlzdHJpYnV0ZSB0aGUKLVByb2dyYW0gaW4gb2JqZWN0IGNvZGUgZm9ybSB1bmRlciBpdHMgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBwcm92aWRlZCB0aGF0Ojwvc3Bhbj4KLTwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWl0IGNvbXBsaWVzIHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50OyBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKQotaXRzIGxpY2Vuc2UgYWdyZWVtZW50Ojwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmkpCi1lZmZlY3RpdmVseSBkaXNjbGFpbXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIHdhcnJhbnRpZXMgYW5kCi1jb25kaXRpb25zLCBleHByZXNzIGFuZCBpbXBsaWVkLCBpbmNsdWRpbmcgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIHRpdGxlCi1hbmQgbm9uLWluZnJpbmdlbWVudCwgYW5kIGltcGxpZWQgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIG1lcmNoYW50YWJpbGl0eQotYW5kIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlOyA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paSkKLWVmZmVjdGl2ZWx5IGV4Y2x1ZGVzIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCBsaWFiaWxpdHkgZm9yIGRhbWFnZXMsCi1pbmNsdWRpbmcgZGlyZWN0LCBpbmRpcmVjdCwgc3BlY2lhbCwgaW5jaWRlbnRhbCBhbmQgY29uc2VxdWVudGlhbCBkYW1hZ2VzLCBzdWNoCi1hcyBsb3N0IHByb2ZpdHM7IDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpaSkKLXN0YXRlcyB0aGF0IGFueSBwcm92aXNpb25zIHdoaWNoIGRpZmZlciBmcm9tIHRoaXMgQWdyZWVtZW50IGFyZSBvZmZlcmVkIGJ5IHRoYXQKLUNvbnRyaWJ1dG9yIGFsb25lIGFuZCBub3QgYnkgYW55IG90aGVyIHBhcnR5OyBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pdikKLXN0YXRlcyB0aGF0IHNvdXJjZSBjb2RlIGZvciB0aGUgUHJvZ3JhbSBpcyBhdmFpbGFibGUgZnJvbSBzdWNoIENvbnRyaWJ1dG9yLCBhbmQKLWluZm9ybXMgbGljZW5zZWVzIGhvdyB0byBvYnRhaW4gaXQgaW4gYSByZWFzb25hYmxlIG1hbm5lciBvbiBvciB0aHJvdWdoIGEKLW1lZGl1bSBjdXN0b21hcmlseSB1c2VkIGZvciBzb2Z0d2FyZSBleGNoYW5nZS48c3BhbiBzdHlsZT0nY29sb3I6Ymx1ZSc+IDwvc3Bhbj48L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+V2hlbiB0aGUgUHJvZ3JhbSBpcyBtYWRlIGF2YWlsYWJsZSBpbiBzb3VyY2UKLWNvZGUgZm9ybTo8L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWl0IG11c3QgYmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhpcyBBZ3JlZW1lbnQ7IGFuZCA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKSBhCi1jb3B5IG9mIHRoaXMgQWdyZWVtZW50IG11c3QgYmUgaW5jbHVkZWQgd2l0aCBlYWNoIGNvcHkgb2YgdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Db250cmlidXRvcnMgbWF5IG5vdCByZW1vdmUgb3IgYWx0ZXIgYW55Ci1jb3B5cmlnaHQgbm90aWNlcyBjb250YWluZWQgd2l0aGluIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RWFjaCBDb250cmlidXRvciBtdXN0IGlkZW50aWZ5IGl0c2VsZiBhcyB0aGUKLW9yaWdpbmF0b3Igb2YgaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCBpbiBhIG1hbm5lciB0aGF0IHJlYXNvbmFibHkgYWxsb3dzCi1zdWJzZXF1ZW50IFJlY2lwaWVudHMgdG8gaWRlbnRpZnkgdGhlIG9yaWdpbmF0b3Igb2YgdGhlIENvbnRyaWJ1dGlvbi4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjQuIENPTU1FUkNJQUwgRElTVFJJQlVUSU9OPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Q29tbWVyY2lhbCBkaXN0cmlidXRvcnMgb2Ygc29mdHdhcmUgbWF5Ci1hY2NlcHQgY2VydGFpbiByZXNwb25zaWJpbGl0aWVzIHdpdGggcmVzcGVjdCB0byBlbmQgdXNlcnMsIGJ1c2luZXNzIHBhcnRuZXJzCi1hbmQgdGhlIGxpa2UuIFdoaWxlIHRoaXMgbGljZW5zZSBpcyBpbnRlbmRlZCB0byBmYWNpbGl0YXRlIHRoZSBjb21tZXJjaWFsIHVzZQotb2YgdGhlIFByb2dyYW0sIHRoZSBDb250cmlidXRvciB3aG8gaW5jbHVkZXMgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsCi1wcm9kdWN0IG9mZmVyaW5nIHNob3VsZCBkbyBzbyBpbiBhIG1hbm5lciB3aGljaCBkb2VzIG5vdCBjcmVhdGUgcG90ZW50aWFsCi1saWFiaWxpdHkgZm9yIG90aGVyIENvbnRyaWJ1dG9ycy4gVGhlcmVmb3JlLCBpZiBhIENvbnRyaWJ1dG9yIGluY2x1ZGVzIHRoZQotUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgc3VjaCBDb250cmlidXRvciAoJnF1b3Q7Q29tbWVyY2lhbAotQ29udHJpYnV0b3ImcXVvdDspIGhlcmVieSBhZ3JlZXMgdG8gZGVmZW5kIGFuZCBpbmRlbW5pZnkgZXZlcnkgb3RoZXIKLUNvbnRyaWJ1dG9yICgmcXVvdDtJbmRlbW5pZmllZCBDb250cmlidXRvciZxdW90OykgYWdhaW5zdCBhbnkgbG9zc2VzLCBkYW1hZ2VzIGFuZAotY29zdHMgKGNvbGxlY3RpdmVseSAmcXVvdDtMb3NzZXMmcXVvdDspIGFyaXNpbmcgZnJvbSBjbGFpbXMsIGxhd3N1aXRzIGFuZCBvdGhlcgotbGVnYWwgYWN0aW9ucyBicm91Z2h0IGJ5IGEgdGhpcmQgcGFydHkgYWdhaW5zdCB0aGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgdG8KLXRoZSBleHRlbnQgY2F1c2VkIGJ5IHRoZSBhY3RzIG9yIG9taXNzaW9ucyBvZiBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4KLWNvbm5lY3Rpb24gd2l0aCBpdHMgZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0Ci1vZmZlcmluZy4gVGhlIG9ibGlnYXRpb25zIGluIHRoaXMgc2VjdGlvbiBkbyBub3QgYXBwbHkgdG8gYW55IGNsYWltcyBvciBMb3NzZXMKLXJlbGF0aW5nIHRvIGFueSBhY3R1YWwgb3IgYWxsZWdlZCBpbnRlbGxlY3R1YWwgcHJvcGVydHkgaW5mcmluZ2VtZW50LiBJbiBvcmRlcgotdG8gcXVhbGlmeSwgYW4gSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbXVzdDogYSkgcHJvbXB0bHkgbm90aWZ5IHRoZSBDb21tZXJjaWFsCi1Db250cmlidXRvciBpbiB3cml0aW5nIG9mIHN1Y2ggY2xhaW0sIGFuZCBiKSBhbGxvdyB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvcgotdG8gY29udHJvbCwgYW5kIGNvb3BlcmF0ZSB3aXRoIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluLCB0aGUgZGVmZW5zZSBhbmQKLWFueSByZWxhdGVkIHNldHRsZW1lbnQgbmVnb3RpYXRpb25zLiBUaGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbWF5IHBhcnRpY2lwYXRlCi1pbiBhbnkgc3VjaCBjbGFpbSBhdCBpdHMgb3duIGV4cGVuc2UuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Gb3IgZXhhbXBsZSwgYSBDb250cmlidXRvciBtaWdodCBpbmNsdWRlIHRoZQotUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgUHJvZHVjdCBYLiBUaGF0IENvbnRyaWJ1dG9yIGlzIHRoZW4gYQotQ29tbWVyY2lhbCBDb250cmlidXRvci4gSWYgdGhhdCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRoZW4gbWFrZXMgcGVyZm9ybWFuY2UKLWNsYWltcywgb3Igb2ZmZXJzIHdhcnJhbnRpZXMgcmVsYXRlZCB0byBQcm9kdWN0IFgsIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQKLXdhcnJhbnRpZXMgYXJlIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvcidzIHJlc3BvbnNpYmlsaXR5IGFsb25lLiBVbmRlciB0aGlzCi1zZWN0aW9uLCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB3b3VsZCBoYXZlIHRvIGRlZmVuZCBjbGFpbXMgYWdhaW5zdCB0aGUKLW90aGVyIENvbnRyaWJ1dG9ycyByZWxhdGVkIHRvIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcywgYW5kIGlmIGEKLWNvdXJ0IHJlcXVpcmVzIGFueSBvdGhlciBDb250cmlidXRvciB0byBwYXkgYW55IGRhbWFnZXMgYXMgYSByZXN1bHQsIHRoZQotQ29tbWVyY2lhbCBDb250cmlidXRvciBtdXN0IHBheSB0aG9zZSBkYW1hZ2VzLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+NS4gTk8gV0FSUkFOVFk8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTCi1BR1JFRU1FTlQsIFRIRSBQUk9HUkFNIElTIFBST1ZJREVEIE9OIEFOICZxdW90O0FTIElTJnF1b3Q7IEJBU0lTLCBXSVRIT1VUCi1XQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIEVJVEhFUiBFWFBSRVNTIE9SIElNUExJRUQgSU5DTFVESU5HLAotV0lUSE9VVCBMSU1JVEFUSU9OLCBBTlkgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIFRJVExFLCBOT04tSU5GUklOR0VNRU5ULAotTUVSQ0hBTlRBQklMSVRZIE9SIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBFYWNoIFJlY2lwaWVudCBpcyBzb2xlbHkKLXJlc3BvbnNpYmxlIGZvciBkZXRlcm1pbmluZyB0aGUgYXBwcm9wcmlhdGVuZXNzIG9mIHVzaW5nIGFuZCBkaXN0cmlidXRpbmcgdGhlCi1Qcm9ncmFtIGFuZCBhc3N1bWVzIGFsbCByaXNrcyBhc3NvY2lhdGVkIHdpdGggaXRzIGV4ZXJjaXNlIG9mIHJpZ2h0cyB1bmRlciB0aGlzCi1BZ3JlZW1lbnQgLCBpbmNsdWRpbmcgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSByaXNrcyBhbmQgY29zdHMgb2YgcHJvZ3JhbSBlcnJvcnMsCi1jb21wbGlhbmNlIHdpdGggYXBwbGljYWJsZSBsYXdzLCBkYW1hZ2UgdG8gb3IgbG9zcyBvZiBkYXRhLCBwcm9ncmFtcyBvcgotZXF1aXBtZW50LCBhbmQgdW5hdmFpbGFiaWxpdHkgb3IgaW50ZXJydXB0aW9uIG9mIG9wZXJhdGlvbnMuIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz42LiBESVNDTEFJTUVSIE9GIExJQUJJTElUWTwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMKLUFHUkVFTUVOVCwgTkVJVEhFUiBSRUNJUElFTlQgTk9SIEFOWSBDT05UUklCVVRPUlMgU0hBTEwgSEFWRSBBTlkgTElBQklMSVRZIEZPUgotQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0oSU5DTFVESU5HIFdJVEhPVVQgTElNSVRBVElPTiBMT1NUIFBST0ZJVFMpLCBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQotT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcKLU5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT1IgRElTVFJJQlVUSU9OIE9GCi1USEUgUFJPR1JBTSBPUiBUSEUgRVhFUkNJU0UgT0YgQU5ZIFJJR0hUUyBHUkFOVEVEIEhFUkVVTkRFUiwgRVZFTiBJRiBBRFZJU0VEIE9GCi1USEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0VTLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Ny4gR0VORVJBTDwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPklmIGFueSBwcm92aXNpb24gb2YgdGhpcyBBZ3JlZW1lbnQgaXMgaW52YWxpZAotb3IgdW5lbmZvcmNlYWJsZSB1bmRlciBhcHBsaWNhYmxlIGxhdywgaXQgc2hhbGwgbm90IGFmZmVjdCB0aGUgdmFsaWRpdHkgb3IKLWVuZm9yY2VhYmlsaXR5IG9mIHRoZSByZW1haW5kZXIgb2YgdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBhbmQgd2l0aG91dAotZnVydGhlciBhY3Rpb24gYnkgdGhlIHBhcnRpZXMgaGVyZXRvLCBzdWNoIHByb3Zpc2lvbiBzaGFsbCBiZSByZWZvcm1lZCB0byB0aGUKLW1pbmltdW0gZXh0ZW50IG5lY2Vzc2FyeSB0byBtYWtlIHN1Y2ggcHJvdmlzaW9uIHZhbGlkIGFuZCBlbmZvcmNlYWJsZS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPklmIFJlY2lwaWVudCBpbnN0aXR1dGVzIHBhdGVudCBsaXRpZ2F0aW9uCi1hZ2FpbnN0IGFueSBlbnRpdHkgKGluY2x1ZGluZyBhIGNyb3NzLWNsYWltIG9yIGNvdW50ZXJjbGFpbSBpbiBhIGxhd3N1aXQpCi1hbGxlZ2luZyB0aGF0IHRoZSBQcm9ncmFtIGl0c2VsZiAoZXhjbHVkaW5nIGNvbWJpbmF0aW9ucyBvZiB0aGUgUHJvZ3JhbSB3aXRoCi1vdGhlciBzb2Z0d2FyZSBvciBoYXJkd2FyZSkgaW5mcmluZ2VzIHN1Y2ggUmVjaXBpZW50J3MgcGF0ZW50KHMpLCB0aGVuIHN1Y2gKLVJlY2lwaWVudCdzIHJpZ2h0cyBncmFudGVkIHVuZGVyIFNlY3Rpb24gMihiKSBzaGFsbCB0ZXJtaW5hdGUgYXMgb2YgdGhlIGRhdGUKLXN1Y2ggbGl0aWdhdGlvbiBpcyBmaWxlZC4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkFsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQKLXNoYWxsIHRlcm1pbmF0ZSBpZiBpdCBmYWlscyB0byBjb21wbHkgd2l0aCBhbnkgb2YgdGhlIG1hdGVyaWFsIHRlcm1zIG9yCi1jb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50IGFuZCBkb2VzIG5vdCBjdXJlIHN1Y2ggZmFpbHVyZSBpbiBhIHJlYXNvbmFibGUKLXBlcmlvZCBvZiB0aW1lIGFmdGVyIGJlY29taW5nIGF3YXJlIG9mIHN1Y2ggbm9uY29tcGxpYW5jZS4gSWYgYWxsIFJlY2lwaWVudCdzCi1yaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgdGVybWluYXRlLCBSZWNpcGllbnQgYWdyZWVzIHRvIGNlYXNlIHVzZSBhbmQKLWRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBhcyBzb29uIGFzIHJlYXNvbmFibHkgcHJhY3RpY2FibGUuIEhvd2V2ZXIsCi1SZWNpcGllbnQncyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIEFncmVlbWVudCBhbmQgYW55IGxpY2Vuc2VzIGdyYW50ZWQgYnkKLVJlY2lwaWVudCByZWxhdGluZyB0byB0aGUgUHJvZ3JhbSBzaGFsbCBjb250aW51ZSBhbmQgc3Vydml2ZS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkV2ZXJ5b25lIGlzIHBlcm1pdHRlZCB0byBjb3B5IGFuZCBkaXN0cmlidXRlCi1jb3BpZXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGJ1dCBpbiBvcmRlciB0byBhdm9pZCBpbmNvbnNpc3RlbmN5IHRoZSBBZ3JlZW1lbnQgaXMKLWNvcHlyaWdodGVkIGFuZCBtYXkgb25seSBiZSBtb2RpZmllZCBpbiB0aGUgZm9sbG93aW5nIG1hbm5lci4gVGhlIEFncmVlbWVudAotU3Rld2FyZCByZXNlcnZlcyB0aGUgcmlnaHQgdG8gcHVibGlzaCBuZXcgdmVyc2lvbnMgKGluY2x1ZGluZyByZXZpc2lvbnMpIG9mCi10aGlzIEFncmVlbWVudCBmcm9tIHRpbWUgdG8gdGltZS4gTm8gb25lIG90aGVyIHRoYW4gdGhlIEFncmVlbWVudCBTdGV3YXJkIGhhcwotdGhlIHJpZ2h0IHRvIG1vZGlmeSB0aGlzIEFncmVlbWVudC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyB0aGUgaW5pdGlhbAotQWdyZWVtZW50IFN0ZXdhcmQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWF5IGFzc2lnbiB0aGUgcmVzcG9uc2liaWxpdHkgdG8KLXNlcnZlIGFzIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCB0byBhIHN1aXRhYmxlIHNlcGFyYXRlIGVudGl0eS4gRWFjaCBuZXcgdmVyc2lvbgotb2YgdGhlIEFncmVlbWVudCB3aWxsIGJlIGdpdmVuIGEgZGlzdGluZ3Vpc2hpbmcgdmVyc2lvbiBudW1iZXIuIFRoZSBQcm9ncmFtCi0oaW5jbHVkaW5nIENvbnRyaWJ1dGlvbnMpIG1heSBhbHdheXMgYmUgZGlzdHJpYnV0ZWQgc3ViamVjdCB0byB0aGUgdmVyc2lvbiBvZgotdGhlIEFncmVlbWVudCB1bmRlciB3aGljaCBpdCB3YXMgcmVjZWl2ZWQuIEluIGFkZGl0aW9uLCBhZnRlciBhIG5ldyB2ZXJzaW9uIG9mCi10aGUgQWdyZWVtZW50IGlzIHB1Ymxpc2hlZCwgQ29udHJpYnV0b3IgbWF5IGVsZWN0IHRvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0KLShpbmNsdWRpbmcgaXRzIENvbnRyaWJ1dGlvbnMpIHVuZGVyIHRoZSBuZXcgdmVyc2lvbi4gRXhjZXB0IGFzIGV4cHJlc3NseSBzdGF0ZWQKLWluIFNlY3Rpb25zIDIoYSkgYW5kIDIoYikgYWJvdmUsIFJlY2lwaWVudCByZWNlaXZlcyBubyByaWdodHMgb3IgbGljZW5zZXMgdG8KLXRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgb2YgYW55IENvbnRyaWJ1dG9yIHVuZGVyIHRoaXMgQWdyZWVtZW50LCB3aGV0aGVyCi1leHByZXNzbHksIGJ5IGltcGxpY2F0aW9uLCBlc3RvcHBlbCBvciBvdGhlcndpc2UuIEFsbCByaWdodHMgaW4gdGhlIFByb2dyYW0gbm90Ci1leHByZXNzbHkgZ3JhbnRlZCB1bmRlciB0aGlzIEFncmVlbWVudCBhcmUgcmVzZXJ2ZWQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5UaGlzIEFncmVlbWVudCBpcyBnb3Zlcm5lZCBieSB0aGUgbGF3cyBvZiB0aGUKLVN0YXRlIG9mIE5ldyBZb3JrIGFuZCB0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGxhd3Mgb2YgdGhlIFVuaXRlZCBTdGF0ZXMgb2YKLUFtZXJpY2EuIE5vIHBhcnR5IHRvIHRoaXMgQWdyZWVtZW50IHdpbGwgYnJpbmcgYSBsZWdhbCBhY3Rpb24gdW5kZXIgdGhpcwotQWdyZWVtZW50IG1vcmUgdGhhbiBvbmUgeWVhciBhZnRlciB0aGUgY2F1c2Ugb2YgYWN0aW9uIGFyb3NlLiBFYWNoIHBhcnR5IHdhaXZlcwotaXRzIHJpZ2h0cyB0byBhIGp1cnkgdHJpYWwgaW4gYW55IHJlc3VsdGluZyBsaXRpZ2F0aW9uLjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PCFbaWYgIXN1cHBvcnRFbXB0eVBhcmFzXT4mbmJzcDs8IVtlbmRpZl0+PG86cD48L286cD48L3A+Ci0KLTwvZGl2PgotCi08L2JvZHk+Ci0KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9saWNlbnNlLmh0bWwgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vbGljZW5zZS5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxNGIxZDUwLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS9zb3VyY2VUZW1wbGF0ZVBsdWdpbi9saWNlbnNlLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSw4MyArMCwwIEBACi08IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wLy9FTiI+Ci08aHRtbD4KLTxoZWFkPgotPG1ldGEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PWlzby04ODU5LTEiPgotPHRpdGxlPkVjbGlwc2Uub3JnIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC90aXRsZT4KLTwvaGVhZD4KLQotPGJvZHkgbGFuZz0iRU4tVVMiIGxpbms9Ymx1ZSB2bGluaz1wdXJwbGU+Ci08aDI+RWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9oMj4KLTxwPkp1bmUgMDYsIDIwMDc8L3A+Ci0KLTxoMz5Vc2FnZSBPZiBDb250ZW50PC9oMz4KLQotPHA+VEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUiBPVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTCi0gICAoQ09MTEVDVElWRUxZICZxdW90O0NPTlRFTlQmcXVvdDspLiAgVVNFIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORAotICAgQ09ORElUSU9OUyBPRiBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gIEJZIFVTSU5HIFRIRSBDT05URU5ULCBZT1UgQUdSRUUgVEhBVCBZT1VSIFVTRQotICAgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IKLSAgIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBJRiBZT1UgRE8gTk9UIEFHUkVFIFRPIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORAotICAgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVywgVEhFTiBZT1UgTUFZIE5PVCBVU0UgVEhFIENPTlRFTlQuPC9wPgotICAgCi08aDM+QXBwbGljYWJsZSBMaWNlbnNlczwvaDM+ICAgCi0gICAKLTxwPlVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAKLSAgICgmcXVvdDtFUEwmcXVvdDspLiAgQSBjb3B5IG9mIHRoZSBFUEwgaXMgcHJvdmlkZWQgd2l0aCB0aGlzIENvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT4uCi0gICBGb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgJnF1b3Q7UHJvZ3JhbSZxdW90OyB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9wPgotCi08cD5Db250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSwgZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZS5vcmcgQ1ZTIHJlcG9zaXRvcnkgKCZxdW90O1JlcG9zaXRvcnkmcXVvdDspIGluIENWUwotICAgbW9kdWxlcyAoJnF1b3Q7TW9kdWxlcyZxdW90OykgYW5kIG1hZGUgYXZhaWxhYmxlIGFzIGRvd25sb2FkYWJsZSBhcmNoaXZlcyAoJnF1b3Q7RG93bmxvYWRzJnF1b3Q7KS48L3A+Ci0gICAKLTx1bD4KLQk8bGk+Q29udGVudCBtYXkgYmUgc3RydWN0dXJlZCBhbmQgcGFja2FnZWQgaW50byBtb2R1bGVzIHRvIGZhY2lsaXRhdGUgZGVsaXZlcmluZywgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiAgVHlwaWNhbCBtb2R1bGVzIG1heSBpbmNsdWRlIHBsdWctaW5zICgmcXVvdDtQbHVnLWlucyZxdW90OyksIHBsdWctaW4gZnJhZ21lbnRzICgmcXVvdDtGcmFnbWVudHMmcXVvdDspLCBhbmQgZmVhdHVyZXMgKCZxdW90O0ZlYXR1cmVzJnF1b3Q7KS48L2xpPgotCTxsaT5FYWNoIFBsdWctaW4gb3IgRnJhZ21lbnQgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBvciBKQVIgKEphdmEmdHJhZGU7IEFSY2hpdmUpIGluIGEgZGlyZWN0b3J5IG5hbWVkICZxdW90O3BsdWdpbnMmcXVvdDsuPC9saT4KLQk8bGk+QSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuICBFYWNoIEZlYXR1cmUgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtmZWF0dXJlcyZxdW90Oy4gIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUueG1sJnF1b3Q7IG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMKLSAgICAgIGFuZC9vciBGcmFnbWVudHMgYXNzb2NpYXRlZCB3aXRoIHRoYXQgRmVhdHVyZS48L2xpPgotCTxsaT5GZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgmcXVvdDtJbmNsdWRlZCBGZWF0dXJlcyZxdW90OykuIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUueG1sJnF1b3Q7IG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy48L2xpPgotPC91bD4gICAKLSAKLTxwPlRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICZxdW90O2Fib3V0Lmh0bWwmcXVvdDsgKCZxdW90O0Fib3V0cyZxdW90OykuIFRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kCi1JbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICZxdW90O2xpY2Vuc2UuaHRtbCZxdW90OyAoJnF1b3Q7RmVhdHVyZSBMaWNlbnNlcyZxdW90OykuICBBYm91dHMgYW5kIEZlYXR1cmUgTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55IGRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZQotaW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyBsb2NhdGlvbnM6PC9wPgotCi08dWw+Ci0JPGxpPlRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeTwvbGk+Ci0JPGxpPlBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzPC9saT4KLQk8bGk+SW5zaWRlIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgcGFja2FnZWQgYXMgSkFSczwvbGk+Ci0JPGxpPlN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICZxdW90O3NyYyZxdW90OyBvZiBjZXJ0YWluIFBsdWctaW5zPC9saT4KLQk8bGk+RmVhdHVyZSBkaXJlY3RvcmllczwvbGk+Ci08L3VsPgotCQkKLTxwPk5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIGluc3RhbGxlZCB1c2luZyB0aGUgRWNsaXBzZSBVcGRhdGUgTWFuYWdlciwgeW91IG11c3QgYWdyZWUgdG8gYSBsaWNlbnNlICgmcXVvdDtGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlJnF1b3Q7KSBkdXJpbmcgdGhlCi1pbnN0YWxsYXRpb24gcHJvY2Vzcy4gIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zIEluY2x1ZGVkIEZlYXR1cmVzLCB0aGUgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBzaG91bGQgZWl0aGVyIHByb3ZpZGUgeW91IHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IKLWluZm9ybSB5b3Ugd2hlcmUgeW91IGNhbiBsb2NhdGUgdGhlbS4gIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSBmb3VuZCBpbiB0aGUgJnF1b3Q7bGljZW5zZSZxdW90OyBwcm9wZXJ0eSBvZiBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnByb3BlcnRpZXMmcXVvdDsgZm91bmQgd2l0aGluIGEgRmVhdHVyZS4KLVN1Y2ggQWJvdXRzLCBGZWF0dXJlIExpY2Vuc2VzLCBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgKG9yIHJlZmVyZW5jZXMgdG8gc3VjaCB0ZXJtcyBhbmQgY29uZGl0aW9ucykgdGhhdCBnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbgotdGhhdCBkaXJlY3RvcnkuPC9wPgotCi08cD5USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTLCBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSIFRPIFRIRSBFUEwgT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLiAgU09NRSBPRiBUSEVTRQotT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTo8L3A+Ci0KLTx1bD4KLQk8bGk+Q29tbW9uIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sPC9hPik8L2xpPgotCTxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAxLjEgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRSI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0U8L2E+KTwvbGk+Ci0JPGxpPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDIuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMCI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wPC9hPik8L2xpPgotCTxsaT5JQk0gUHVibGljIExpY2Vuc2UgMS4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2RldmVsb3BlcndvcmtzL29wZW5zb3VyY2UvbGljZW5zZTEwLmh0bWwiPmh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sPC9hPik8L2xpPgkKLQk8bGk+TWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwiPmh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sPC9hPik8L2xpPgotCTxsaT5Nb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sIj5odHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWw8L2E+KTwvbGk+Ci0gIAotICA8TEk+Q29tbW9uIERldmVsb3BtZW50IGFuZCBEaXN0cmlidXRpb24gTGljZW5zZSAoQ0RETCkgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sIj5odHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwpPC9BPgotICA8L0xJPgotPC9VTD4KLQotPHA+SVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgQ09ORElUSU9OUyBQUklPUiBUTyBVU0UgT0YgVEhFIENPTlRFTlQuICBJZiBubyBBYm91dCwgRmVhdHVyZSBMaWNlbnNlLCBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIGlzIHByb3ZpZGVkLCBwbGVhc2UKLWNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuPC9wPgotCi08aDM+Q3J5cHRvZ3JhcGh5PC9oMz4KLQotPHA+Q29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlIGN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSwgYW5kL29yIHJlLWV4cG9ydCB0bwotICAgYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkUgdXNpbmcgYW55IGVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsIHJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsCi0gICBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLjwvcD4KLSAgIAotPHNtYWxsPkphdmEgYW5kIGFsbCBKYXZhLWJhc2VkIHRyYWRlbWFya3MgYXJlIHRyYWRlbWFya3Mgb2YgU3VuIE1pY3Jvc3lzdGVtcywgSW5jLiBpbiB0aGUgVW5pdGVkIFN0YXRlcywgb3RoZXIgY291bnRyaWVzLCBvciBib3RoLjwvc21hbGw+ICAgCi08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vcGx1Z2luLnByb3BlcnRpZXMgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LmZlYXR1cmUvc291cmNlVGVtcGxhdGVQbHVnaW4vcGx1Z2luLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGY5NDg1NDcuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC5mZWF0dXJlL3NvdXJjZVRlbXBsYXRlUGx1Z2luL3BsdWdpbi5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTMgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDggT3JhY2xlLgotIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCi0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAotIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAotIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0KLXBsdWdpbk5hbWUgPSBEYWxpIEphdmEgUGVyc2lzdGVuY2UgQVBJIChKUEEpIFRvb2xzCi1wcm92aWRlck5hbWUgPSBFY2xpcHNlLm9yZwpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5mZWF0dXJlLy5jdnNpZ25vcmUgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmZlYXR1cmUvLmN2c2lnbm9yZQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzE0NDg3Yy4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmZlYXR1cmUvLmN2c2lnbm9yZQorKysgL2Rldi9udWxsCkBAIC0xICswLDAgQEAKLWJ1aWxkLnhtbApkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5mZWF0dXJlLy5wcm9qZWN0IGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5mZWF0dXJlLy5wcm9qZWN0CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5MTc2MGYyLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMuZmVhdHVyZS8ucHJvamVjdAorKysgL2Rldi9udWxsCkBAIC0xLDE3ICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08cHJvamVjdERlc2NyaXB0aW9uPgotCTxuYW1lPm9yZy5lY2xpcHNlLmpwdC50ZXN0cy5mZWF0dXJlPC9uYW1lPgotCTxjb21tZW50PjwvY29tbWVudD4KLQk8cHJvamVjdHM+Ci0JPC9wcm9qZWN0cz4KLQk8YnVpbGRTcGVjPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLkZlYXR1cmVCdWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQk8L2J1aWxkU3BlYz4KLQk8bmF0dXJlcz4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5wZGUuRmVhdHVyZU5hdHVyZTwvbmF0dXJlPgotCTwvbmF0dXJlcz4KLTwvcHJvamVjdERlc2NyaXB0aW9uPgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5mZWF0dXJlLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMuZmVhdHVyZS8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDIzNWI4NGEuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5mZWF0dXJlLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcworKysgL2Rldi9udWxsCkBAIC0xLDMgKzAsMCBAQAotI1N1biBNYXkgMjcgMTU6MTE6MTcgRURUIDIwMDcKLWVjbGlwc2UucHJlZmVyZW5jZXMudmVyc2lvbj0xCi1lbmNvZGluZy88cHJvamVjdD49SVNPLTg4NTktMQpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5mZWF0dXJlL2J1aWxkLnByb3BlcnRpZXMgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmZlYXR1cmUvYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDZhNGRjZS4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmZlYXR1cmUvYnVpbGQucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDEwICswLDAgQEAKLWJpbi5pbmNsdWRlcyA9IGZlYXR1cmUueG1sLFwKLSAgICAgICAgICAgICAgIGVjbGlwc2VfdXBkYXRlXzEyMC5qcGcsXAotICAgICAgICAgICAgICAgZXBsLXYxMC5odG1sLFwKLSAgICAgICAgICAgICAgIGxpY2Vuc2UuaHRtbCxcCi0gICAgICAgICAgICAgICBmZWF0dXJlLnByb3BlcnRpZXMKLXNyYy5pbmNsdWRlcyA9IGxpY2Vuc2UuaHRtbCxcCi0gICAgICAgICAgICAgICBmZWF0dXJlLnhtbCxcCi0gICAgICAgICAgICAgICBlcGwtdjEwLmh0bWwsXAotICAgICAgICAgICAgICAgZWNsaXBzZV91cGRhdGVfMTIwLmpwZyxcCi0gICAgICAgICAgICAgICBidWlsZC5wcm9wZXJ0aWVzCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZyBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMuZmVhdHVyZS9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiZmRmNzA4Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMuZmVhdHVyZS9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5mZWF0dXJlL2VwbC12MTAuaHRtbCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMuZmVhdHVyZS9lcGwtdjEwLmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVkNGIxOTYuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5mZWF0dXJlL2VwbC12MTAuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDMyOCArMCwwIEBACi08aHRtbCB4bWxuczpvPSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTpvZmZpY2UiCi14bWxuczp3PSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTp3b3JkIgoteG1sbnM9Imh0dHA6Ly93d3cudzMub3JnL1RSL1JFQy1odG1sNDAiPgotCi08aGVhZD4KLTxtZXRhIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD13aW5kb3dzLTEyNTIiPgotPG1ldGEgbmFtZT1Qcm9nSWQgY29udGVudD1Xb3JkLkRvY3VtZW50PgotPG1ldGEgbmFtZT1HZW5lcmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgOSI+Ci08bWV0YSBuYW1lPU9yaWdpbmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgOSI+Ci08bGluayByZWw9RmlsZS1MaXN0Ci1ocmVmPSIuL0VjbGlwc2UlMjBFUEwlMjAyMDAzXzExXzEwJTIwRmluYWxfZmlsZXMvZmlsZWxpc3QueG1sIj4KLTx0aXRsZT5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gVmVyc2lvbiAxLjA8L3RpdGxlPgotPCEtLVtpZiBndGUgbXNvIDldPjx4bWw+Ci0gPG86RG9jdW1lbnRQcm9wZXJ0aWVzPgotICA8bzpSZXZpc2lvbj4yPC9vOlJldmlzaW9uPgotICA8bzpUb3RhbFRpbWU+MzwvbzpUb3RhbFRpbWU+Ci0gIDxvOkNyZWF0ZWQ+MjAwNC0wMy0wNVQyMzowMzowMFo8L286Q3JlYXRlZD4KLSAgPG86TGFzdFNhdmVkPjIwMDQtMDMtMDVUMjM6MDM6MDBaPC9vOkxhc3RTYXZlZD4KLSAgPG86UGFnZXM+NDwvbzpQYWdlcz4KLSAgPG86V29yZHM+MTYyNjwvbzpXb3Jkcz4KLSAgPG86Q2hhcmFjdGVycz45MjcwPC9vOkNoYXJhY3RlcnM+Ci0gICA8bzpMaW5lcz43NzwvbzpMaW5lcz4KLSAgPG86UGFyYWdyYXBocz4xODwvbzpQYXJhZ3JhcGhzPgotICA8bzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4xMTM4NDwvbzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4KLSAgPG86VmVyc2lvbj45LjQ0MDI8L286VmVyc2lvbj4KLSA8L286RG9jdW1lbnRQcm9wZXJ0aWVzPgotPC94bWw+PCFbZW5kaWZdLS0+PCEtLVtpZiBndGUgbXNvIDldPjx4bWw+Ci0gPHc6V29yZERvY3VtZW50PgotICA8dzpUcmFja1JldmlzaW9ucy8+Ci0gPC93OldvcmREb2N1bWVudD4KLTwveG1sPjwhW2VuZGlmXS0tPgotPHN0eWxlPgotPCEtLQotIC8qIEZvbnQgRGVmaW5pdGlvbnMgKi8KLUBmb250LWZhY2UKLQl7Zm9udC1mYW1pbHk6VGFob21hOwotCXBhbm9zZS0xOjIgMTEgNiA0IDMgNSA0IDQgMiA0OwotCW1zby1mb250LWNoYXJzZXQ6MDsKLQltc28tZ2VuZXJpYy1mb250LWZhbWlseTpzd2lzczsKLQltc28tZm9udC1waXRjaDp2YXJpYWJsZTsKLQltc28tZm9udC1zaWduYXR1cmU6NTUzNjc5NDk1IC0yMTQ3NDgzNjQ4IDggMCA2NjA0NyAwO30KLSAvKiBTdHlsZSBEZWZpbml0aW9ucyAqLwotcC5Nc29Ob3JtYWwsIGxpLk1zb05vcm1hbCwgZGl2Lk1zb05vcm1hbAotCXttc28tc3R5bGUtcGFyZW50OiIiOwotCW1hcmdpbjowaW47Ci0JbWFyZ2luLWJvdHRvbTouMDAwMXB0OwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXAKLQl7bWFyZ2luLXJpZ2h0OjBpbjsKLQltc28tbWFyZ2luLXRvcC1hbHQ6YXV0bzsKLQltc28tbWFyZ2luLWJvdHRvbS1hbHQ6YXV0bzsKLQltYXJnaW4tbGVmdDowaW47Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZToxMi4wcHQ7Ci0JZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotcC5CYWxsb29uVGV4dCwgbGkuQmFsbG9vblRleHQsIGRpdi5CYWxsb29uVGV4dAotCXttc28tc3R5bGUtbmFtZToiQmFsbG9vbiBUZXh0IjsKLQltYXJnaW46MGluOwotCW1hcmdpbi1ib3R0b206LjAwMDFwdDsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjguMHB0OwotCWZvbnQtZmFtaWx5OlRhaG9tYTsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1AcGFnZSBTZWN0aW9uMQotCXtzaXplOjguNWluIDExLjBpbjsKLQltYXJnaW46MS4waW4gMS4yNWluIDEuMGluIDEuMjVpbjsKLQltc28taGVhZGVyLW1hcmdpbjouNWluOwotCW1zby1mb290ZXItbWFyZ2luOi41aW47Ci0JbXNvLXBhcGVyLXNvdXJjZTowO30KLWRpdi5TZWN0aW9uMQotCXtwYWdlOlNlY3Rpb24xO30KLS0tPgotPC9zdHlsZT4KLTwvaGVhZD4KLQotPGJvZHkgbGFuZz1FTi1VUyBzdHlsZT0ndGFiLWludGVydmFsOi41aW4nPgotCi08ZGl2IGNsYXNzPVNlY3Rpb24xPgotCi08cCBhbGlnbj1jZW50ZXIgc3R5bGU9J3RleHQtYWxpZ246Y2VudGVyJz48Yj5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gdiAxLjA8L2I+Ci08L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5USEUgQUNDT01QQU5ZSU5HIFBST0dSQU0gSVMgUFJPVklERUQgVU5ERVIKLVRIRSBURVJNUyBPRiBUSElTIEVDTElQU0UgUFVCTElDIExJQ0VOU0UgKCZxdW90O0FHUkVFTUVOVCZxdW90OykuIEFOWSBVU0UsCi1SRVBST0RVQ1RJT04gT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIENPTlNUSVRVVEVTIFJFQ0lQSUVOVCdTIEFDQ0VQVEFOQ0UKLU9GIFRISVMgQUdSRUVNRU5ULjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+MS4gREVGSU5JVElPTlM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtDb250cmlidXRpb24mcXVvdDsgbWVhbnM6PC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pbiB0aGUgY2FzZSBvZiB0aGUgaW5pdGlhbCBDb250cmlidXRvciwgdGhlIGluaXRpYWwgY29kZSBhbmQgZG9jdW1lbnRhdGlvbgotZGlzdHJpYnV0ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGFuZDxiciBjbGVhcj1sZWZ0PgotYikgaW4gdGhlIGNhc2Ugb2YgZWFjaCBzdWJzZXF1ZW50IENvbnRyaWJ1dG9yOjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmkpCi1jaGFuZ2VzIHRvIHRoZSBQcm9ncmFtLCBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paSkKLWFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbTs8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz53aGVyZQotc3VjaCBjaGFuZ2VzIGFuZC9vciBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gb3JpZ2luYXRlIGZyb20gYW5kIGFyZSBkaXN0cmlidXRlZAotYnkgdGhhdCBwYXJ0aWN1bGFyIENvbnRyaWJ1dG9yLiBBIENvbnRyaWJ1dGlvbiAnb3JpZ2luYXRlcycgZnJvbSBhIENvbnRyaWJ1dG9yCi1pZiBpdCB3YXMgYWRkZWQgdG8gdGhlIFByb2dyYW0gYnkgc3VjaCBDb250cmlidXRvciBpdHNlbGYgb3IgYW55b25lIGFjdGluZyBvbgotc3VjaCBDb250cmlidXRvcidzIGJlaGFsZi4gQ29udHJpYnV0aW9ucyBkbyBub3QgaW5jbHVkZSBhZGRpdGlvbnMgdG8gdGhlCi1Qcm9ncmFtIHdoaWNoOiAoaSkgYXJlIHNlcGFyYXRlIG1vZHVsZXMgb2Ygc29mdHdhcmUgZGlzdHJpYnV0ZWQgaW4gY29uanVuY3Rpb24KLXdpdGggdGhlIFByb2dyYW0gdW5kZXIgdGhlaXIgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBhbmQgKGlpKSBhcmUgbm90IGRlcml2YXRpdmUKLXdvcmtzIG9mIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7Q29udHJpYnV0b3ImcXVvdDsgbWVhbnMgYW55IHBlcnNvbiBvcgotZW50aXR5IHRoYXQgZGlzdHJpYnV0ZXMgdGhlIFByb2dyYW0uPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtMaWNlbnNlZCBQYXRlbnRzICZxdW90OyBtZWFuIHBhdGVudAotY2xhaW1zIGxpY2Vuc2FibGUgYnkgYSBDb250cmlidXRvciB3aGljaCBhcmUgbmVjZXNzYXJpbHkgaW5mcmluZ2VkIGJ5IHRoZSB1c2UKLW9yIHNhbGUgb2YgaXRzIENvbnRyaWJ1dGlvbiBhbG9uZSBvciB3aGVuIGNvbWJpbmVkIHdpdGggdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtQcm9ncmFtJnF1b3Q7IG1lYW5zIHRoZSBDb250cmlidXRpb25zCi1kaXN0cmlidXRlZCBpbiBhY2NvcmRhbmNlIHdpdGggdGhpcyBBZ3JlZW1lbnQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4mcXVvdDtSZWNpcGllbnQmcXVvdDsgbWVhbnMgYW55b25lIHdobwotcmVjZWl2ZXMgdGhlIFByb2dyYW0gdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGluY2x1ZGluZyBhbGwgQ29udHJpYnV0b3JzLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Mi4gR1JBTlQgT0YgUklHSFRTPC9zcGFuPjwvYj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQKLWEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLCByb3lhbHR5LWZyZWUgY29weXJpZ2h0IGxpY2Vuc2UgdG88c3Bhbgotc3R5bGU9J2NvbG9yOnJlZCc+IDwvc3Bhbj5yZXByb2R1Y2UsIHByZXBhcmUgZGVyaXZhdGl2ZSB3b3JrcyBvZiwgcHVibGljbHkKLWRpc3BsYXksIHB1YmxpY2x5IHBlcmZvcm0sIGRpc3RyaWJ1dGUgYW5kIHN1YmxpY2Vuc2UgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoCi1Db250cmlidXRvciwgaWYgYW55LCBhbmQgc3VjaCBkZXJpdmF0aXZlIHdvcmtzLCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUKLWZvcm0uPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikKLVN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMKLVJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSw8c3BhbiBzdHlsZT0nY29sb3I6Z3JlZW4nPiA8L3NwYW4+cm95YWx0eS1mcmVlCi1wYXRlbnQgbGljZW5zZSB1bmRlciBMaWNlbnNlZCBQYXRlbnRzIHRvIG1ha2UsIHVzZSwgc2VsbCwgb2ZmZXIgdG8gc2VsbCwgaW1wb3J0Ci1hbmQgb3RoZXJ3aXNlIHRyYW5zZmVyIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBpbiBzb3VyY2UKLWNvZGUgYW5kIG9iamVjdCBjb2RlIGZvcm0uIFRoaXMgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgYXBwbHkgdG8gdGhlIGNvbWJpbmF0aW9uCi1vZiB0aGUgQ29udHJpYnV0aW9uIGFuZCB0aGUgUHJvZ3JhbSBpZiwgYXQgdGhlIHRpbWUgdGhlIENvbnRyaWJ1dGlvbiBpcyBhZGRlZAotYnkgdGhlIENvbnRyaWJ1dG9yLCBzdWNoIGFkZGl0aW9uIG9mIHRoZSBDb250cmlidXRpb24gY2F1c2VzIHN1Y2ggY29tYmluYXRpb24KLXRvIGJlIGNvdmVyZWQgYnkgdGhlIExpY2Vuc2VkIFBhdGVudHMuIFRoZSBwYXRlbnQgbGljZW5zZSBzaGFsbCBub3QgYXBwbHkgdG8KLWFueSBvdGhlciBjb21iaW5hdGlvbnMgd2hpY2ggaW5jbHVkZSB0aGUgQ29udHJpYnV0aW9uLiBObyBoYXJkd2FyZSBwZXIgc2UgaXMKLWxpY2Vuc2VkIGhlcmV1bmRlci4gPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YykKLVJlY2lwaWVudCB1bmRlcnN0YW5kcyB0aGF0IGFsdGhvdWdoIGVhY2ggQ29udHJpYnV0b3IgZ3JhbnRzIHRoZSBsaWNlbnNlcyB0byBpdHMKLUNvbnRyaWJ1dGlvbnMgc2V0IGZvcnRoIGhlcmVpbiwgbm8gYXNzdXJhbmNlcyBhcmUgcHJvdmlkZWQgYnkgYW55IENvbnRyaWJ1dG9yCi10aGF0IHRoZSBQcm9ncmFtIGRvZXMgbm90IGluZnJpbmdlIHRoZSBwYXRlbnQgb3Igb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5Ci1yaWdodHMgb2YgYW55IG90aGVyIGVudGl0eS4gRWFjaCBDb250cmlidXRvciBkaXNjbGFpbXMgYW55IGxpYWJpbGl0eSB0byBSZWNpcGllbnQKLWZvciBjbGFpbXMgYnJvdWdodCBieSBhbnkgb3RoZXIgZW50aXR5IGJhc2VkIG9uIGluZnJpbmdlbWVudCBvZiBpbnRlbGxlY3R1YWwKLXByb3BlcnR5IHJpZ2h0cyBvciBvdGhlcndpc2UuIEFzIGEgY29uZGl0aW9uIHRvIGV4ZXJjaXNpbmcgdGhlIHJpZ2h0cyBhbmQKLWxpY2Vuc2VzIGdyYW50ZWQgaGVyZXVuZGVyLCBlYWNoIFJlY2lwaWVudCBoZXJlYnkgYXNzdW1lcyBzb2xlIHJlc3BvbnNpYmlsaXR5Ci10byBzZWN1cmUgYW55IG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgbmVlZGVkLCBpZiBhbnkuIEZvciBleGFtcGxlLAotaWYgYSB0aGlyZCBwYXJ0eSBwYXRlbnQgbGljZW5zZSBpcyByZXF1aXJlZCB0byBhbGxvdyBSZWNpcGllbnQgdG8gZGlzdHJpYnV0ZQotdGhlIFByb2dyYW0sIGl0IGlzIFJlY2lwaWVudCdzIHJlc3BvbnNpYmlsaXR5IHRvIGFjcXVpcmUgdGhhdCBsaWNlbnNlIGJlZm9yZQotZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtLjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmQpCi1FYWNoIENvbnRyaWJ1dG9yIHJlcHJlc2VudHMgdGhhdCB0byBpdHMga25vd2xlZGdlIGl0IGhhcyBzdWZmaWNpZW50IGNvcHlyaWdodAotcmlnaHRzIGluIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgdG8gZ3JhbnQgdGhlIGNvcHlyaWdodCBsaWNlbnNlIHNldCBmb3J0aCBpbgotdGhpcyBBZ3JlZW1lbnQuIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz4zLiBSRVFVSVJFTUVOVFM8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5BIENvbnRyaWJ1dG9yIG1heSBjaG9vc2UgdG8gZGlzdHJpYnV0ZSB0aGUKLVByb2dyYW0gaW4gb2JqZWN0IGNvZGUgZm9ybSB1bmRlciBpdHMgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBwcm92aWRlZCB0aGF0Ojwvc3Bhbj4KLTwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWl0IGNvbXBsaWVzIHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50OyBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKQotaXRzIGxpY2Vuc2UgYWdyZWVtZW50Ojwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmkpCi1lZmZlY3RpdmVseSBkaXNjbGFpbXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIHdhcnJhbnRpZXMgYW5kCi1jb25kaXRpb25zLCBleHByZXNzIGFuZCBpbXBsaWVkLCBpbmNsdWRpbmcgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIHRpdGxlCi1hbmQgbm9uLWluZnJpbmdlbWVudCwgYW5kIGltcGxpZWQgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIG1lcmNoYW50YWJpbGl0eQotYW5kIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlOyA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paSkKLWVmZmVjdGl2ZWx5IGV4Y2x1ZGVzIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCBsaWFiaWxpdHkgZm9yIGRhbWFnZXMsCi1pbmNsdWRpbmcgZGlyZWN0LCBpbmRpcmVjdCwgc3BlY2lhbCwgaW5jaWRlbnRhbCBhbmQgY29uc2VxdWVudGlhbCBkYW1hZ2VzLCBzdWNoCi1hcyBsb3N0IHByb2ZpdHM7IDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmlpaSkKLXN0YXRlcyB0aGF0IGFueSBwcm92aXNpb25zIHdoaWNoIGRpZmZlciBmcm9tIHRoaXMgQWdyZWVtZW50IGFyZSBvZmZlcmVkIGJ5IHRoYXQKLUNvbnRyaWJ1dG9yIGFsb25lIGFuZCBub3QgYnkgYW55IG90aGVyIHBhcnR5OyBhbmQ8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pdikKLXN0YXRlcyB0aGF0IHNvdXJjZSBjb2RlIGZvciB0aGUgUHJvZ3JhbSBpcyBhdmFpbGFibGUgZnJvbSBzdWNoIENvbnRyaWJ1dG9yLCBhbmQKLWluZm9ybXMgbGljZW5zZWVzIGhvdyB0byBvYnRhaW4gaXQgaW4gYSByZWFzb25hYmxlIG1hbm5lciBvbiBvciB0aHJvdWdoIGEKLW1lZGl1bSBjdXN0b21hcmlseSB1c2VkIGZvciBzb2Z0d2FyZSBleGNoYW5nZS48c3BhbiBzdHlsZT0nY29sb3I6Ymx1ZSc+IDwvc3Bhbj48L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+V2hlbiB0aGUgUHJvZ3JhbSBpcyBtYWRlIGF2YWlsYWJsZSBpbiBzb3VyY2UKLWNvZGUgZm9ybTo8L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLWl0IG11c3QgYmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhpcyBBZ3JlZW1lbnQ7IGFuZCA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5iKSBhCi1jb3B5IG9mIHRoaXMgQWdyZWVtZW50IG11c3QgYmUgaW5jbHVkZWQgd2l0aCBlYWNoIGNvcHkgb2YgdGhlIFByb2dyYW0uIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Db250cmlidXRvcnMgbWF5IG5vdCByZW1vdmUgb3IgYWx0ZXIgYW55Ci1jb3B5cmlnaHQgbm90aWNlcyBjb250YWluZWQgd2l0aGluIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RWFjaCBDb250cmlidXRvciBtdXN0IGlkZW50aWZ5IGl0c2VsZiBhcyB0aGUKLW9yaWdpbmF0b3Igb2YgaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCBpbiBhIG1hbm5lciB0aGF0IHJlYXNvbmFibHkgYWxsb3dzCi1zdWJzZXF1ZW50IFJlY2lwaWVudHMgdG8gaWRlbnRpZnkgdGhlIG9yaWdpbmF0b3Igb2YgdGhlIENvbnRyaWJ1dGlvbi4gPC9zcGFuPjwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjQuIENPTU1FUkNJQUwgRElTVFJJQlVUSU9OPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Q29tbWVyY2lhbCBkaXN0cmlidXRvcnMgb2Ygc29mdHdhcmUgbWF5Ci1hY2NlcHQgY2VydGFpbiByZXNwb25zaWJpbGl0aWVzIHdpdGggcmVzcGVjdCB0byBlbmQgdXNlcnMsIGJ1c2luZXNzIHBhcnRuZXJzCi1hbmQgdGhlIGxpa2UuIFdoaWxlIHRoaXMgbGljZW5zZSBpcyBpbnRlbmRlZCB0byBmYWNpbGl0YXRlIHRoZSBjb21tZXJjaWFsIHVzZQotb2YgdGhlIFByb2dyYW0sIHRoZSBDb250cmlidXRvciB3aG8gaW5jbHVkZXMgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsCi1wcm9kdWN0IG9mZmVyaW5nIHNob3VsZCBkbyBzbyBpbiBhIG1hbm5lciB3aGljaCBkb2VzIG5vdCBjcmVhdGUgcG90ZW50aWFsCi1saWFiaWxpdHkgZm9yIG90aGVyIENvbnRyaWJ1dG9ycy4gVGhlcmVmb3JlLCBpZiBhIENvbnRyaWJ1dG9yIGluY2x1ZGVzIHRoZQotUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgc3VjaCBDb250cmlidXRvciAoJnF1b3Q7Q29tbWVyY2lhbAotQ29udHJpYnV0b3ImcXVvdDspIGhlcmVieSBhZ3JlZXMgdG8gZGVmZW5kIGFuZCBpbmRlbW5pZnkgZXZlcnkgb3RoZXIKLUNvbnRyaWJ1dG9yICgmcXVvdDtJbmRlbW5pZmllZCBDb250cmlidXRvciZxdW90OykgYWdhaW5zdCBhbnkgbG9zc2VzLCBkYW1hZ2VzIGFuZAotY29zdHMgKGNvbGxlY3RpdmVseSAmcXVvdDtMb3NzZXMmcXVvdDspIGFyaXNpbmcgZnJvbSBjbGFpbXMsIGxhd3N1aXRzIGFuZCBvdGhlcgotbGVnYWwgYWN0aW9ucyBicm91Z2h0IGJ5IGEgdGhpcmQgcGFydHkgYWdhaW5zdCB0aGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgdG8KLXRoZSBleHRlbnQgY2F1c2VkIGJ5IHRoZSBhY3RzIG9yIG9taXNzaW9ucyBvZiBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4KLWNvbm5lY3Rpb24gd2l0aCBpdHMgZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0Ci1vZmZlcmluZy4gVGhlIG9ibGlnYXRpb25zIGluIHRoaXMgc2VjdGlvbiBkbyBub3QgYXBwbHkgdG8gYW55IGNsYWltcyBvciBMb3NzZXMKLXJlbGF0aW5nIHRvIGFueSBhY3R1YWwgb3IgYWxsZWdlZCBpbnRlbGxlY3R1YWwgcHJvcGVydHkgaW5mcmluZ2VtZW50LiBJbiBvcmRlcgotdG8gcXVhbGlmeSwgYW4gSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbXVzdDogYSkgcHJvbXB0bHkgbm90aWZ5IHRoZSBDb21tZXJjaWFsCi1Db250cmlidXRvciBpbiB3cml0aW5nIG9mIHN1Y2ggY2xhaW0sIGFuZCBiKSBhbGxvdyB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvcgotdG8gY29udHJvbCwgYW5kIGNvb3BlcmF0ZSB3aXRoIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluLCB0aGUgZGVmZW5zZSBhbmQKLWFueSByZWxhdGVkIHNldHRsZW1lbnQgbmVnb3RpYXRpb25zLiBUaGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbWF5IHBhcnRpY2lwYXRlCi1pbiBhbnkgc3VjaCBjbGFpbSBhdCBpdHMgb3duIGV4cGVuc2UuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5Gb3IgZXhhbXBsZSwgYSBDb250cmlidXRvciBtaWdodCBpbmNsdWRlIHRoZQotUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgUHJvZHVjdCBYLiBUaGF0IENvbnRyaWJ1dG9yIGlzIHRoZW4gYQotQ29tbWVyY2lhbCBDb250cmlidXRvci4gSWYgdGhhdCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRoZW4gbWFrZXMgcGVyZm9ybWFuY2UKLWNsYWltcywgb3Igb2ZmZXJzIHdhcnJhbnRpZXMgcmVsYXRlZCB0byBQcm9kdWN0IFgsIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQKLXdhcnJhbnRpZXMgYXJlIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvcidzIHJlc3BvbnNpYmlsaXR5IGFsb25lLiBVbmRlciB0aGlzCi1zZWN0aW9uLCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB3b3VsZCBoYXZlIHRvIGRlZmVuZCBjbGFpbXMgYWdhaW5zdCB0aGUKLW90aGVyIENvbnRyaWJ1dG9ycyByZWxhdGVkIHRvIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcywgYW5kIGlmIGEKLWNvdXJ0IHJlcXVpcmVzIGFueSBvdGhlciBDb250cmlidXRvciB0byBwYXkgYW55IGRhbWFnZXMgYXMgYSByZXN1bHQsIHRoZQotQ29tbWVyY2lhbCBDb250cmlidXRvciBtdXN0IHBheSB0aG9zZSBkYW1hZ2VzLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+NS4gTk8gV0FSUkFOVFk8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTCi1BR1JFRU1FTlQsIFRIRSBQUk9HUkFNIElTIFBST1ZJREVEIE9OIEFOICZxdW90O0FTIElTJnF1b3Q7IEJBU0lTLCBXSVRIT1VUCi1XQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIEVJVEhFUiBFWFBSRVNTIE9SIElNUExJRUQgSU5DTFVESU5HLAotV0lUSE9VVCBMSU1JVEFUSU9OLCBBTlkgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIFRJVExFLCBOT04tSU5GUklOR0VNRU5ULAotTUVSQ0hBTlRBQklMSVRZIE9SIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBFYWNoIFJlY2lwaWVudCBpcyBzb2xlbHkKLXJlc3BvbnNpYmxlIGZvciBkZXRlcm1pbmluZyB0aGUgYXBwcm9wcmlhdGVuZXNzIG9mIHVzaW5nIGFuZCBkaXN0cmlidXRpbmcgdGhlCi1Qcm9ncmFtIGFuZCBhc3N1bWVzIGFsbCByaXNrcyBhc3NvY2lhdGVkIHdpdGggaXRzIGV4ZXJjaXNlIG9mIHJpZ2h0cyB1bmRlciB0aGlzCi1BZ3JlZW1lbnQgLCBpbmNsdWRpbmcgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSByaXNrcyBhbmQgY29zdHMgb2YgcHJvZ3JhbSBlcnJvcnMsCi1jb21wbGlhbmNlIHdpdGggYXBwbGljYWJsZSBsYXdzLCBkYW1hZ2UgdG8gb3IgbG9zcyBvZiBkYXRhLCBwcm9ncmFtcyBvcgotZXF1aXBtZW50LCBhbmQgdW5hdmFpbGFiaWxpdHkgb3IgaW50ZXJydXB0aW9uIG9mIG9wZXJhdGlvbnMuIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz42LiBESVNDTEFJTUVSIE9GIExJQUJJTElUWTwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMKLUFHUkVFTUVOVCwgTkVJVEhFUiBSRUNJUElFTlQgTk9SIEFOWSBDT05UUklCVVRPUlMgU0hBTEwgSEFWRSBBTlkgTElBQklMSVRZIEZPUgotQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0oSU5DTFVESU5HIFdJVEhPVVQgTElNSVRBVElPTiBMT1NUIFBST0ZJVFMpLCBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQotT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcKLU5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT1IgRElTVFJJQlVUSU9OIE9GCi1USEUgUFJPR1JBTSBPUiBUSEUgRVhFUkNJU0UgT0YgQU5ZIFJJR0hUUyBHUkFOVEVEIEhFUkVVTkRFUiwgRVZFTiBJRiBBRFZJU0VEIE9GCi1USEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0VTLjwvc3Bhbj4gPC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Ny4gR0VORVJBTDwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPklmIGFueSBwcm92aXNpb24gb2YgdGhpcyBBZ3JlZW1lbnQgaXMgaW52YWxpZAotb3IgdW5lbmZvcmNlYWJsZSB1bmRlciBhcHBsaWNhYmxlIGxhdywgaXQgc2hhbGwgbm90IGFmZmVjdCB0aGUgdmFsaWRpdHkgb3IKLWVuZm9yY2VhYmlsaXR5IG9mIHRoZSByZW1haW5kZXIgb2YgdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBhbmQgd2l0aG91dAotZnVydGhlciBhY3Rpb24gYnkgdGhlIHBhcnRpZXMgaGVyZXRvLCBzdWNoIHByb3Zpc2lvbiBzaGFsbCBiZSByZWZvcm1lZCB0byB0aGUKLW1pbmltdW0gZXh0ZW50IG5lY2Vzc2FyeSB0byBtYWtlIHN1Y2ggcHJvdmlzaW9uIHZhbGlkIGFuZCBlbmZvcmNlYWJsZS48L3NwYW4+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPklmIFJlY2lwaWVudCBpbnN0aXR1dGVzIHBhdGVudCBsaXRpZ2F0aW9uCi1hZ2FpbnN0IGFueSBlbnRpdHkgKGluY2x1ZGluZyBhIGNyb3NzLWNsYWltIG9yIGNvdW50ZXJjbGFpbSBpbiBhIGxhd3N1aXQpCi1hbGxlZ2luZyB0aGF0IHRoZSBQcm9ncmFtIGl0c2VsZiAoZXhjbHVkaW5nIGNvbWJpbmF0aW9ucyBvZiB0aGUgUHJvZ3JhbSB3aXRoCi1vdGhlciBzb2Z0d2FyZSBvciBoYXJkd2FyZSkgaW5mcmluZ2VzIHN1Y2ggUmVjaXBpZW50J3MgcGF0ZW50KHMpLCB0aGVuIHN1Y2gKLVJlY2lwaWVudCdzIHJpZ2h0cyBncmFudGVkIHVuZGVyIFNlY3Rpb24gMihiKSBzaGFsbCB0ZXJtaW5hdGUgYXMgb2YgdGhlIGRhdGUKLXN1Y2ggbGl0aWdhdGlvbiBpcyBmaWxlZC4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkFsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQKLXNoYWxsIHRlcm1pbmF0ZSBpZiBpdCBmYWlscyB0byBjb21wbHkgd2l0aCBhbnkgb2YgdGhlIG1hdGVyaWFsIHRlcm1zIG9yCi1jb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50IGFuZCBkb2VzIG5vdCBjdXJlIHN1Y2ggZmFpbHVyZSBpbiBhIHJlYXNvbmFibGUKLXBlcmlvZCBvZiB0aW1lIGFmdGVyIGJlY29taW5nIGF3YXJlIG9mIHN1Y2ggbm9uY29tcGxpYW5jZS4gSWYgYWxsIFJlY2lwaWVudCdzCi1yaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgdGVybWluYXRlLCBSZWNpcGllbnQgYWdyZWVzIHRvIGNlYXNlIHVzZSBhbmQKLWRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBhcyBzb29uIGFzIHJlYXNvbmFibHkgcHJhY3RpY2FibGUuIEhvd2V2ZXIsCi1SZWNpcGllbnQncyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIEFncmVlbWVudCBhbmQgYW55IGxpY2Vuc2VzIGdyYW50ZWQgYnkKLVJlY2lwaWVudCByZWxhdGluZyB0byB0aGUgUHJvZ3JhbSBzaGFsbCBjb250aW51ZSBhbmQgc3Vydml2ZS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkV2ZXJ5b25lIGlzIHBlcm1pdHRlZCB0byBjb3B5IGFuZCBkaXN0cmlidXRlCi1jb3BpZXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGJ1dCBpbiBvcmRlciB0byBhdm9pZCBpbmNvbnNpc3RlbmN5IHRoZSBBZ3JlZW1lbnQgaXMKLWNvcHlyaWdodGVkIGFuZCBtYXkgb25seSBiZSBtb2RpZmllZCBpbiB0aGUgZm9sbG93aW5nIG1hbm5lci4gVGhlIEFncmVlbWVudAotU3Rld2FyZCByZXNlcnZlcyB0aGUgcmlnaHQgdG8gcHVibGlzaCBuZXcgdmVyc2lvbnMgKGluY2x1ZGluZyByZXZpc2lvbnMpIG9mCi10aGlzIEFncmVlbWVudCBmcm9tIHRpbWUgdG8gdGltZS4gTm8gb25lIG90aGVyIHRoYW4gdGhlIEFncmVlbWVudCBTdGV3YXJkIGhhcwotdGhlIHJpZ2h0IHRvIG1vZGlmeSB0aGlzIEFncmVlbWVudC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyB0aGUgaW5pdGlhbAotQWdyZWVtZW50IFN0ZXdhcmQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWF5IGFzc2lnbiB0aGUgcmVzcG9uc2liaWxpdHkgdG8KLXNlcnZlIGFzIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCB0byBhIHN1aXRhYmxlIHNlcGFyYXRlIGVudGl0eS4gRWFjaCBuZXcgdmVyc2lvbgotb2YgdGhlIEFncmVlbWVudCB3aWxsIGJlIGdpdmVuIGEgZGlzdGluZ3Vpc2hpbmcgdmVyc2lvbiBudW1iZXIuIFRoZSBQcm9ncmFtCi0oaW5jbHVkaW5nIENvbnRyaWJ1dGlvbnMpIG1heSBhbHdheXMgYmUgZGlzdHJpYnV0ZWQgc3ViamVjdCB0byB0aGUgdmVyc2lvbiBvZgotdGhlIEFncmVlbWVudCB1bmRlciB3aGljaCBpdCB3YXMgcmVjZWl2ZWQuIEluIGFkZGl0aW9uLCBhZnRlciBhIG5ldyB2ZXJzaW9uIG9mCi10aGUgQWdyZWVtZW50IGlzIHB1Ymxpc2hlZCwgQ29udHJpYnV0b3IgbWF5IGVsZWN0IHRvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0KLShpbmNsdWRpbmcgaXRzIENvbnRyaWJ1dGlvbnMpIHVuZGVyIHRoZSBuZXcgdmVyc2lvbi4gRXhjZXB0IGFzIGV4cHJlc3NseSBzdGF0ZWQKLWluIFNlY3Rpb25zIDIoYSkgYW5kIDIoYikgYWJvdmUsIFJlY2lwaWVudCByZWNlaXZlcyBubyByaWdodHMgb3IgbGljZW5zZXMgdG8KLXRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgb2YgYW55IENvbnRyaWJ1dG9yIHVuZGVyIHRoaXMgQWdyZWVtZW50LCB3aGV0aGVyCi1leHByZXNzbHksIGJ5IGltcGxpY2F0aW9uLCBlc3RvcHBlbCBvciBvdGhlcndpc2UuIEFsbCByaWdodHMgaW4gdGhlIFByb2dyYW0gbm90Ci1leHByZXNzbHkgZ3JhbnRlZCB1bmRlciB0aGlzIEFncmVlbWVudCBhcmUgcmVzZXJ2ZWQuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5UaGlzIEFncmVlbWVudCBpcyBnb3Zlcm5lZCBieSB0aGUgbGF3cyBvZiB0aGUKLVN0YXRlIG9mIE5ldyBZb3JrIGFuZCB0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGxhd3Mgb2YgdGhlIFVuaXRlZCBTdGF0ZXMgb2YKLUFtZXJpY2EuIE5vIHBhcnR5IHRvIHRoaXMgQWdyZWVtZW50IHdpbGwgYnJpbmcgYSBsZWdhbCBhY3Rpb24gdW5kZXIgdGhpcwotQWdyZWVtZW50IG1vcmUgdGhhbiBvbmUgeWVhciBhZnRlciB0aGUgY2F1c2Ugb2YgYWN0aW9uIGFyb3NlLiBFYWNoIHBhcnR5IHdhaXZlcwotaXRzIHJpZ2h0cyB0byBhIGp1cnkgdHJpYWwgaW4gYW55IHJlc3VsdGluZyBsaXRpZ2F0aW9uLjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PCFbaWYgIXN1cHBvcnRFbXB0eVBhcmFzXT4mbmJzcDs8IVtlbmRpZl0+PG86cD48L286cD48L3A+Ci0KLTwvZGl2PgotCi08L2JvZHk+Ci0KLTwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmZlYXR1cmUvZmVhdHVyZS5wcm9wZXJ0aWVzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5mZWF0dXJlL2ZlYXR1cmUucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzNlYzUzNi4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmZlYXR1cmUvZmVhdHVyZS5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTQ1ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBmZWF0dXJlLnByb3BlcnRpZXMKLSMgY29udGFpbnMgZXh0ZXJuYWxpemVkIHN0cmluZ3MgZm9yIGZlYXR1cmUueG1sCi0jICIlZm9vIiBpbiBmZWF0dXJlLnhtbCBjb3JyZXNwb25kcyB0byB0aGUga2V5ICJmb28iIGluIHRoaXMgZmlsZQotIyBqYXZhLmlvLlByb3BlcnRpZXMgZmlsZSAoSVNPIDg4NTktMSB3aXRoICJcIiBlc2NhcGVzKQotIyBUaGlzIGZpbGUgc2hvdWxkIGJlIHRyYW5zbGF0ZWQuCi0KLSMgImZlYXR1cmVOYW1lIiBwcm9wZXJ0eSAtIG5hbWUgb2YgdGhlIGZlYXR1cmUKLQotIyAicHJvdmlkZXJOYW1lIiBwcm9wZXJ0eSAtIG5hbWUgb2YgdGhlIGNvbXBhbnkgdGhhdCBwcm92aWRlcyB0aGUgZmVhdHVyZQotcHJvdmlkZXJOYW1lPUVjbGlwc2Uub3JnCi0KLSMgInVwZGF0ZVNpdGVOYW1lIiBwcm9wZXJ0eSAtIGxhYmVsIGZvciB0aGUgdXBkYXRlIHNpdGUKLSMgVE9SRVZJRVcgLSB1cGRhdGVTaXRlTmFtZQotdXBkYXRlU2l0ZU5hbWU9V2ViIFRvb2xzIFBsYXRmb3JtIChXVFApIFVwZGF0ZXMKLQotIyAiZGVzY3JpcHRpb24iIHByb3BlcnR5IC0gZGVzY3JpcHRpb24gb2YgdGhlIGZlYXR1cmUKLWRlc2NyaXB0aW9uPURhbGkgSmF2YSBQZXJzaXN0ZW5jZSBBUEkgKEpQQSkgVG9vbHMKLQotIyAiY29weXJpZ2h0IiBwcm9wZXJ0eSAtIHRleHQgb2YgdGhlICJGZWF0dXJlIFVwZGF0ZSBDb3B5cmlnaHQiCi1jb3B5cmlnaHQ9XAotQ29weXJpZ2h0IChjKSAyMDA2IE9yYWNsZSBDb3Jwb3JhdGlvbi5cblwKLUFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHNcblwKLWFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMFxuXAotd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXRcblwKLWh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sXG5cCi1cblwKLUNvbnRyaWJ1dG9yczpcblwKLSAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb25cbgotIyMjIyMjIyMjIyMjIyMjIyBlbmQgb2YgY29weXJpZ2h0IHByb3BlcnR5ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotCi0jICJsaWNlbnNlVVJMIiBwcm9wZXJ0eSAtIFVSTCBvZiB0aGUgIkZlYXR1cmUgTGljZW5zZSIKLSMgZG8gbm90IHRyYW5zbGF0ZSB2YWx1ZSAtIGp1c3QgY2hhbmdlIHRvIHBvaW50IHRvIGEgbG9jYWxlLXNwZWNpZmljIEhUTUwgcGFnZQotbGljZW5zZVVSTD1saWNlbnNlLmh0bWwKLQotIyAibGljZW5zZSIgcHJvcGVydHkgLSB0ZXh0IG9mIHRoZSAiRmVhdHVyZSBVcGRhdGUgTGljZW5zZSIKLSMgc2hvdWxkIGJlIHBsYWluIHRleHQgdmVyc2lvbiBvZiBsaWNlbnNlIGFncmVlbWVudCBwb2ludGVkIHRvIGJlICJsaWNlbnNlVVJMIgotbGljZW5zZT1cCi1FQ0xJUFNFIEZPVU5EQVRJT04gU09GVFdBUkUgVVNFUiBBR1JFRU1FTlRcblwKLUp1bmUgMDYsIDIwMDdcblwKLVxuXAotVXNhZ2UgT2YgQ29udGVudFxuXAotXG5cCi1USEUgRUNMSVBTRSBGT1VOREFUSU9OIE1BS0VTIEFWQUlMQUJMRSBTT0ZUV0FSRSwgRE9DVU1FTlRBVElPTiwgSU5GT1JNQVRJT04gQU5EL09SXG5cCi1PVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTIChDT0xMRUNUSVZFTFkgIkNPTlRFTlQiKS5cblwKLVVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJU1xuXAotQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SXG5cCi1OT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VXG5cCi1BR1JFRSBUSEFUIFlPVVIgVVNFIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRISVMgQUdSRUVNRU5UXG5cCi1BTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UU1xuXAotT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEVcblwKLVRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORCBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlNcblwKLU9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEXG5cCi1CRUxPVywgVEhFTiBZT1UgTUFZIE5PVCBVU0UgVEhFIENPTlRFTlQuXG5cCi1cblwKLUFwcGxpY2FibGUgTGljZW5zZXNcblwKLVxuXAotVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb25cblwKLWlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgUHVibGljXG5cCi1MaWNlbnNlIFZlcnNpb24gMS4wICgiRVBMIikuIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpc1xuXAotQ29udGVudCBhbmQgaXMgYWxzbyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuXG5cCi1Gb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC5cblwKLVxuXAotQ29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsXG5cCi1kb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlLm9yZyBDVlNcblwKLXJlcG9zaXRvcnkgKCJSZXBvc2l0b3J5IikgaW4gQ1ZTIG1vZHVsZXMgKCJNb2R1bGVzIikgYW5kIG1hZGUgYXZhaWxhYmxlXG5cCi1hcyBkb3dubG9hZGFibGUgYXJjaGl2ZXMgKCJEb3dubG9hZHMiKS5cblwKLVxuXAotICAgLSBDb250ZW50IG1heSBiZSBzdHJ1Y3R1cmVkIGFuZCBwYWNrYWdlZCBpbnRvIG1vZHVsZXMgdG8gZmFjaWxpdGF0ZSBkZWxpdmVyaW5nLFxuXAotICAgICBleHRlbmRpbmcsIGFuZCB1cGdyYWRpbmcgdGhlIENvbnRlbnQuIFR5cGljYWwgbW9kdWxlcyBtYXkgaW5jbHVkZSBwbHVnLWlucyAoIlBsdWctaW5zIiksXG5cCi0gICAgIHBsdWctaW4gZnJhZ21lbnRzICgiRnJhZ21lbnRzIiksIGFuZCBmZWF0dXJlcyAoIkZlYXR1cmVzIikuXG5cCi0gICAtIEVhY2ggUGx1Zy1pbiBvciBGcmFnbWVudCBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IG9yIEpBUiAoSmF2YT8gQVJjaGl2ZSlcblwKLSAgICAgaW4gYSBkaXJlY3RvcnkgbmFtZWQgInBsdWdpbnMiLlxuXAotICAgLSBBIEZlYXR1cmUgaXMgYSBidW5kbGUgb2Ygb25lIG9yIG1vcmUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhbmQgYXNzb2NpYXRlZCBtYXRlcmlhbC5cblwKLSAgICAgRWFjaCBGZWF0dXJlIG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3RvcnkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgImZlYXR1cmVzIi5cblwKLSAgICAgV2l0aGluIGEgRmVhdHVyZSwgZmlsZXMgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uXG5cCi0gICAgIG51bWJlcnMgb2YgdGhlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYXNzb2NpYXRlZCB3aXRoIHRoYXQgRmVhdHVyZS5cblwKLSAgIC0gRmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzXG5cCi0gICAgIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIEluY2x1ZGVkIEZlYXR1cmVzLlxuXAotXG5cCi1GZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgiSW5jbHVkZWQgRmVhdHVyZXMiKS4gRmlsZXMgbmFtZWRcblwKLSJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mXG5cCi1JbmNsdWRlZCBGZWF0dXJlcy5cblwKLVxuXAotVGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZVxuXAotY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICJhYm91dC5odG1sIiAoIkFib3V0cyIpLiBUaGUgdGVybXMgYW5kXG5cCi1jb25kaXRpb25zIGdvdmVybmluZyBGZWF0dXJlcyBhbmQgSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZFxuXAotaW4gZmlsZXMgbmFtZWQgImxpY2Vuc2UuaHRtbCIgKCJGZWF0dXJlIExpY2Vuc2VzIikuIEFib3V0cyBhbmQgRmVhdHVyZVxuXAotTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55IGRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZVxuXAotaW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyBsb2NhdGlvbnM6XG5cCi1cblwKLSAgIC0gVGhlIHRvcC1sZXZlbCAocm9vdCkgZGlyZWN0b3J5XG5cCi0gICAtIFBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzXG5cCi0gICAtIEluc2lkZSBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHBhY2thZ2VkIGFzIEpBUnNcblwKLSAgIC0gU3ViLWRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgInNyYyIgb2YgY2VydGFpbiBQbHVnLWluc1xuXAotICAgLSBGZWF0dXJlIGRpcmVjdG9yaWVzXG5cCi1cblwKLU5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIGluc3RhbGxlZCB1c2luZyB0aGVcblwKLUVjbGlwc2UgVXBkYXRlIE1hbmFnZXIsIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoIkZlYXR1cmUgVXBkYXRlXG5cCi1MaWNlbnNlIikgZHVyaW5nIHRoZSBpbnN0YWxsYXRpb24gcHJvY2Vzcy4gSWYgdGhlIEZlYXR1cmUgY29udGFpbnNcblwKLUluY2x1ZGVkIEZlYXR1cmVzLCB0aGUgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBzaG91bGQgZWl0aGVyIHByb3ZpZGUgeW91XG5cCi13aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgdGhlIEluY2x1ZGVkIEZlYXR1cmVzIG9yIGluZm9ybVxuXAoteW91IHdoZXJlIHlvdSBjYW4gbG9jYXRlIHRoZW0uIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSBmb3VuZCBpblxuXAotdGhlICJsaWNlbnNlIiBwcm9wZXJ0eSBvZiBmaWxlcyBuYW1lZCAiZmVhdHVyZS5wcm9wZXJ0aWVzIi4gU3VjaCBBYm91dHMsXG5cCi1GZWF0dXJlIExpY2Vuc2VzIGFuZCBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBjb250YWluIHRoZSB0ZXJtcyBhbmRcblwKLWNvbmRpdGlvbnMgKG9yIHJlZmVyZW5jZXMgdG8gc3VjaCB0ZXJtcyBhbmQgY29uZGl0aW9ucykgdGhhdCBnb3Zlcm4geW91clxuXAotdXNlIG9mIHRoZSBhc3NvY2lhdGVkIENvbnRlbnQgaW4gdGhhdCBkaXJlY3RvcnkuXG5cCi1cblwKLVRIRSBBQk9VVFMsIEZFQVRVUkUgTElDRU5TRVMgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUlxuXAotVE8gVEhFIEVQTCBPUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuXG5cCi1TT01FIE9GIFRIRVNFIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6XG5cCi1cblwKLSAgICAtIENvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sKVxuXAotICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UpXG5cCi0gICAgLSBBcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjApXG5cCi0gICAgLSBJQk0gUHVibGljIExpY2Vuc2UgMS4wIChhdmFpbGFibGUgYXQgaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2RldmVsb3BlcndvcmtzL29wZW5zb3VyY2UvbGljZW5zZTEwLmh0bWwpXG5cCi0gICAgLSBNZXRybyBMaW5rIFB1YmxpYyBMaWNlbnNlIDEuMDAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbClcblwKLSAgICAtIE1vemlsbGEgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjEgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWwpXG5cCi0gICAgLSBDb21tb24gRGV2ZWxvcG1lbnQgYW5kIERpc3RyaWJ1dGlvbiBMaWNlbnNlIChDRERMKSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuc3VuLmNvbS9jZGRsL2NkZGwuaHRtbClcblwKLVxuXAotSVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgQ09ORElUSU9OUyBQUklPUlxuXAotVE8gVVNFIE9GIFRIRSBDT05URU5ULiBJZiBubyBBYm91dCwgRmVhdHVyZSBMaWNlbnNlIG9yIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VcblwKLWlzIHByb3ZpZGVkLCBwbGVhc2UgY29udGFjdCB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHRvIGRldGVybWluZSB3aGF0IHRlcm1zIGFuZCBjb25kaXRpb25zXG5cCi1nb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuXG5cCi1cblwKLUNyeXB0b2dyYXBoeVxuXAotXG5cCi1Db250ZW50IG1heSBjb250YWluIGVuY3J5cHRpb24gc29mdHdhcmUuIFRoZSBjb3VudHJ5IGluIHdoaWNoIHlvdSBhcmVcblwKLWN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSxcblwKLWFuZC9vciByZS1leHBvcnQgdG8gYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkVcblwKLXVzaW5nIGFueSBlbmNyeXB0aW9uIHNvZnR3YXJlLCBwbGVhc2UgY2hlY2sgdGhlIGNvdW50cnkncyBsYXdzLFxuXAotcmVndWxhdGlvbnMgYW5kIHBvbGljaWVzIGNvbmNlcm5pbmcgdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgb3IgdXNlLFxuXAotYW5kIHJlLWV4cG9ydCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLCB0byBzZWUgaWYgdGhpcyBpcyBwZXJtaXR0ZWQuXG5cCi1cblwKLUphdmEgYW5kIGFsbCBKYXZhLWJhc2VkIHRyYWRlbWFya3MgYXJlIHRyYWRlbWFya3Mgb2YgU3VuIE1pY3Jvc3lzdGVtcywgSW5jLiBpbiB0aGUgVW5pdGVkIFN0YXRlcywgb3RoZXIgY291bnRyaWVzLCBvciBib3RoLlxuCi0jIyMjIyMjIyMjIyBlbmQgb2YgbGljZW5zZSBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMuZmVhdHVyZS9mZWF0dXJlLnhtbCBiL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHQudGVzdHMuZmVhdHVyZS9mZWF0dXJlLnhtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzIxMjg2NS4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmZlYXR1cmUvZmVhdHVyZS54bWwKKysrIC9kZXYvbnVsbApAQCAtMSw0NCArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPGZlYXR1cmUKLSAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHQudGVzdHMuZmVhdHVyZSIKLSAgICAgIGxhYmVsPSJEYWxpIEphdmEgUGVyc2lzdGVuY2UgQVBJIFRvb2xzIChKUEEpIEpVbml0IFRlc3RzIgotICAgICAgdmVyc2lvbj0iMi4yLjAucXVhbGlmaWVyIgotICAgICAgcHJvdmlkZXItbmFtZT0iRWNsaXBzZS5vcmciPgotCi0gICA8ZGVzY3JpcHRpb24+Ci0gICAgICAlZGVzY3JpcHRpb24KLSAgIDwvZGVzY3JpcHRpb24+Ci0KLSAgIDxjb3B5cmlnaHQ+Ci0gICAgICAlY29weXJpZ2h0Ci0gICA8L2NvcHlyaWdodD4KLQotICAgPGxpY2Vuc2UgdXJsPSJsaWNlbnNlLmh0bWwiPgotICAgICAgJWxpY2Vuc2UKLSAgIDwvbGljZW5zZT4KLQotICAgPHBsdWdpbgotICAgICAgICAgaWQ9Im9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzIgotICAgICAgICAgZG93bmxvYWQtc2l6ZT0iMCIKLSAgICAgICAgIGluc3RhbGwtc2l6ZT0iMCIKLSAgICAgICAgIHZlcnNpb249IjAuMC4wIi8+Ci0KLSAgIDxwbHVnaW4KLSAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cyIKLSAgICAgICAgIGRvd25sb2FkLXNpemU9IjAiCi0gICAgICAgICBpbnN0YWxsLXNpemU9IjAiCi0gICAgICAgICB2ZXJzaW9uPSIwLjAuMCIvPgotCi0gICA8cGx1Z2luCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlIgotICAgICAgICAgZG93bmxvYWQtc2l6ZT0iMCIKLSAgICAgICAgIGluc3RhbGwtc2l6ZT0iMCIKLSAgICAgICAgIHZlcnNpb249IjAuMC4wIi8+Ci0KLSAgIDxwbHVnaW4KLSAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS50ZXN0cyIKLSAgICAgICAgIGRvd25sb2FkLXNpemU9IjAiCi0gICAgICAgICBpbnN0YWxsLXNpemU9IjAiCi0gICAgICAgICB2ZXJzaW9uPSIwLjAuMCIvPgotCi08L2ZlYXR1cmU+CmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmZlYXR1cmUvbGljZW5zZS5odG1sIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdC50ZXN0cy5mZWF0dXJlL2xpY2Vuc2UuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNTY0NDU5OC4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0LnRlc3RzLmZlYXR1cmUvbGljZW5zZS5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsOTggKzAsMCBAQAotPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEgVHJhbnNpdGlvbmFsLy9FTiIgImh0dHA6Ly93d3cudzNjLm9yZy9UUi8xOTk5L1JFQy1odG1sNDAxLTE5OTkxMjI0L2xvb3NlLmR0ZCI+Ci08IS0tIHNhdmVkIGZyb20gdXJsPSgwMDQ0KWh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsL25vdGljZS5odG1sIC0tPgotPEhUTUw+PEhFQUQ+PFRJVExFPkVjbGlwc2Uub3JnIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9USVRMRT4KLTxNRVRBIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4KLTxNRVRBIGNvbnRlbnQ9Ik1TSFRNTCA2LjAwLjI4MDAuMTQ3OSIgbmFtZT1HRU5FUkFUT1I+PC9IRUFEPgotPEJPRFkgbGFuZz1FTi1VUyB2TGluaz1wdXJwbGUgbGluaz1ibHVlPgotPEgyPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvSDI+Ci08UD5KdW5lIDA2LCAyMDA3PC9QPgotPEgzPlVzYWdlIE9mIENvbnRlbnQ8L0gzPgotPFA+VEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIAotQU5EL09SIE9USEVSIE1BVEVSSUFMUyBGT1IgT1BFTiBTT1VSQ0UgUFJPSkVDVFMgKENPTExFQ1RJVkVMWSAiQ09OVEVOVCIpLiBVU0UgT0YgCi1USEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSAKLVRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIAotQkVMT1cuIEJZIFVTSU5HIFRIRSBDT05URU5ULCBZT1UgQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCAKLUJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSAKLUFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSAKLUFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIAotTUFZIE5PVCBVU0UgVEhFIENPTlRFTlQuPC9QPgotPEgzPkFwcGxpY2FibGUgTGljZW5zZXM8L0gzPgotPFA+VW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIAotRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIAotUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKCJFUEwiKS4gQSBjb3B5IG9mIHRoZSBFUEwgaXMgcHJvdmlkZWQgd2l0aCB0aGlzIAotQ29udGVudCBhbmQgaXMgYWxzbyBhdmFpbGFibGUgYXQgPEEgCi1ocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L0E+LiAKLUZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAiUHJvZ3JhbSIgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvUD4KLTxQPkNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLCAKLWRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2Uub3JnIENWUyByZXBvc2l0b3J5IAotKCJSZXBvc2l0b3J5IikgaW4gQ1ZTIG1vZHVsZXMgKCJNb2R1bGVzIikgYW5kIG1hZGUgYXZhaWxhYmxlIGFzIGRvd25sb2FkYWJsZSAKLWFyY2hpdmVzICgiRG93bmxvYWRzIikuPC9QPgotPFA+Q29udGVudCBtYXkgYmUgYXBwb3J0aW9uZWQgaW50byBwbHVnLWlucyAoIlBsdWctaW5zIiksIHBsdWctaW4gZnJhZ21lbnRzIAotKCJGcmFnbWVudHMiKSwgYW5kIGZlYXR1cmVzICgiRmVhdHVyZXMiKS4gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIAotUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhbmQgYXNzb2NpYXRlZCBtYXRlcmlhbC4gRmlsZXMgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgCi1jb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyAKLWFzc29jaWF0ZWQgd2l0aCBhIEZlYXR1cmUuIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgYXJlIGxvY2F0ZWQgaW4gZGlyZWN0b3JpZXMgCi1uYW1lZCAicGx1Z2lucyIgYW5kIEZlYXR1cmVzIGFyZSBsb2NhdGVkIGluIGRpcmVjdG9yaWVzIG5hbWVkICJmZWF0dXJlcyIuPC9QPgotPFA+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIEZpbGVzIG5hbWVkIAotImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgCi1GZWF0dXJlcy48L1A+Ci08UD5UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlIGNvbnRhaW5lZCAKLWluIGZpbGVzIG5hbWVkICJhYm91dC5odG1sIiAoIkFib3V0cyIpLiBUaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIAotRmVhdHVyZXMgYW5kIEluY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgImxpY2Vuc2UuaHRtbCIgCi0oIkZlYXR1cmUgTGljZW5zZXMiKS4gQWJvdXRzIGFuZCBGZWF0dXJlIExpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSAKLWRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZSBpbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIAotbG9jYXRpb25zOjwvUD4KLTxVTD4KLSAgPExJPlRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeSAKLSAgPExJPlBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzIAotICA8TEk+U3ViZGlyZWN0b3JpZXMgb2YgdGhlIGRpcmVjdG9yeSBuYW1lZCAic3JjIiBvZiBjZXJ0YWluIFBsdWctaW5zIAotICA8TEk+RmVhdHVyZSBkaXJlY3RvcmllcyA8L0xJPjwvVUw+Ci08UD5Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgCi11c2luZyB0aGUgRWNsaXBzZSBVcGRhdGUgTWFuYWdlciwgeW91IG11c3QgYWdyZWUgdG8gYSBsaWNlbnNlICgiRmVhdHVyZSBVcGRhdGUgCi1MaWNlbnNlIikgZHVyaW5nIHRoZSBpbnN0YWxsYXRpb24gcHJvY2Vzcy4gSWYgdGhlIEZlYXR1cmUgY29udGFpbnMgSW5jbHVkZWQgCi1GZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdSB3aXRoIHRoZSB0ZXJtcyAKLWFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IgaW5mb3JtIHlvdSB3aGVyZSB5b3UgY2FuIAotbG9jYXRlIHRoZW0uIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSBmb3VuZCBpbiB0aGUgImxpY2Vuc2UiIHByb3BlcnR5IG9mIAotZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIuIFN1Y2ggQWJvdXRzLCBGZWF0dXJlIExpY2Vuc2VzIGFuZCBGZWF0dXJlIAotVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgCi1hbmQgY29uZGl0aW9ucykgdGhhdCBnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbiB0aGF0IAotZGlyZWN0b3J5LjwvUD4KLTxQPlRIRSBBQk9VVFMsIEZFQVRVUkUgTElDRU5TRVMgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUiBUTyBUSEUgRVBMIAotT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLiBTT01FIE9GIFRIRVNFIAotT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTo8L1A+Ci08VUw+Ci0gIDxMST5Db21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sPC9BPikgCi0KLSAgPExJPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRSI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0U8L0E+KSAKLQotICA8TEk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMCI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wPC9BPikgCi0KLSAgPExJPklCTSBQdWJsaWMgTGljZW5zZSAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2RldmVsb3BlcndvcmtzL29wZW5zb3VyY2UvbGljZW5zZTEwLmh0bWwiPmh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sPC9BPikgCi0KLSAgPExJPk1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbCI+aHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWw8L0E+KSAKLQotICA8TEk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWwiPmh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbDwvQT4pIAotICA8L0xJPgotICAgIAotICA8TEk+Q29tbW9uIERldmVsb3BtZW50IGFuZCBEaXN0cmlidXRpb24gTGljZW5zZSAoQ0RETCkgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sIj5odHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwpPC9BPgotICA8L0xJPgotPC9VTD4KLTxQPklUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1IgCi1UTyBVU0UgT0YgVEhFIENPTlRFTlQuIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2Ugb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBpcyAKLXByb3ZpZGVkLCBwbGVhc2UgY29udGFjdCB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHRvIGRldGVybWluZSB3aGF0IHRlcm1zIGFuZCAKLWNvbmRpdGlvbnMgZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LjwvUD4KLTxIMz5DcnlwdG9ncmFwaHk8L0gzPgotPFA+Q29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlIAotY3VycmVudGx5IG1heSBoYXZlIHJlc3RyaWN0aW9ucyBvbiB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBhbmQgdXNlLCBhbmQvb3IgCi1yZS1leHBvcnQgdG8gYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkUgdXNpbmcgYW55IAotZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cywgcmVndWxhdGlvbnMgYW5kIHBvbGljaWVzIAotY29uY2VybmluZyB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgCi10byBzZWUgaWYgdGhpcyBpcyBwZXJtaXR0ZWQuPC9QPjwvQk9EWT48L0hUTUw+CmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5mZWF0dXJlLy5jdnNpZ25vcmUgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5mZWF0dXJlLy5jdnNpZ25vcmUKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDYzNjVkM2QuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuZmVhdHVyZS8uY3ZzaWdub3JlCisrKyAvZGV2L251bGwKQEAgLTEsMyArMCwwIEBACi1mZWF0dXJlLnRlbXAuZm9sZGVyCi1idWlsZC54bWwKLW9yZy5lY2xpcHNlLmpwdF9zZGsuZmVhdHVyZV8xLjAuMS4qCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5mZWF0dXJlLy5wcm9qZWN0IGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuZmVhdHVyZS8ucHJvamVjdApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzNkYTc1MC4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5mZWF0dXJlLy5wcm9qZWN0CisrKyAvZGV2L251bGwKQEAgLTEsMTcgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxwcm9qZWN0RGVzY3JpcHRpb24+Ci0JPG5hbWU+b3JnLmVjbGlwc2UuanB0X3Nkay5mZWF0dXJlPC9uYW1lPgotCTxjb21tZW50PjwvY29tbWVudD4KLQk8cHJvamVjdHM+Ci0JPC9wcm9qZWN0cz4KLQk8YnVpbGRTcGVjPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLkZlYXR1cmVCdWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQk8L2J1aWxkU3BlYz4KLQk8bmF0dXJlcz4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5wZGUuRmVhdHVyZU5hdHVyZTwvbmF0dXJlPgotCTwvbmF0dXJlcz4KLTwvcHJvamVjdERlc2NyaXB0aW9uPgpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuZmVhdHVyZS8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5mZWF0dXJlLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmNjN2Q0Yi4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5mZWF0dXJlLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcworKysgL2Rldi9udWxsCkBAIC0xLDMgKzAsMCBAQAotI1N1biBNYXkgMjcgMTU6MDk6NTkgRURUIDIwMDcKLWVjbGlwc2UucHJlZmVyZW5jZXMudmVyc2lvbj0xCi1lbmNvZGluZy88cHJvamVjdD49SVNPLTg4NTktMQpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuZmVhdHVyZS9idWlsZC5wcm9wZXJ0aWVzIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuZmVhdHVyZS9idWlsZC5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyZDdhYjhkLi4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHRfc2RrLmZlYXR1cmUvYnVpbGQucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDcgKzAsMCBAQAotYmluLmluY2x1ZGVzID0gZmVhdHVyZS54bWwsXAotICAgICAgICAgICAgICAgbGljZW5zZS5odG1sLFwKLSAgICAgICAgICAgICAgIGZlYXR1cmUucHJvcGVydGllcyxcCi0gICAgICAgICAgICAgICBlcGwtdjEwLmh0bWwsXAotICAgICAgICAgICAgICAgZWNsaXBzZV91cGRhdGVfMTIwLmpwZwotCi1nZW5lcmF0ZS5mZWF0dXJlQG9yZy5lY2xpcHNlLmpwdC5mZWF0dXJlLnNvdXJjZT1vcmcuZWNsaXBzZS5qcHQuZmVhdHVyZQpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuZmVhdHVyZS9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuZmVhdHVyZS9lY2xpcHNlX3VwZGF0ZV8xMjAuanBnCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiZmRmNzA4Li4wMDAwMDAwCi0tLSBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHRfc2RrLmZlYXR1cmUvZWNsaXBzZV91cGRhdGVfMTIwLmpwZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHRfc2RrLmZlYXR1cmUvZXBsLXYxMC5odG1sIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuZmVhdHVyZS9lcGwtdjEwLmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVkNGIxOTYuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuZmVhdHVyZS9lcGwtdjEwLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSwzMjggKzAsMCBAQAotPGh0bWwgeG1sbnM6bz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6b2ZmaWNlIgoteG1sbnM6dz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6d29yZCIKLXhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy9UUi9SRUMtaHRtbDQwIj4KLQotPGhlYWQ+Ci08bWV0YSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9d2luZG93cy0xMjUyIj4KLTxtZXRhIG5hbWU9UHJvZ0lkIGNvbnRlbnQ9V29yZC5Eb2N1bWVudD4KLTxtZXRhIG5hbWU9R2VuZXJhdG9yIGNvbnRlbnQ9Ik1pY3Jvc29mdCBXb3JkIDkiPgotPG1ldGEgbmFtZT1PcmlnaW5hdG9yIGNvbnRlbnQ9Ik1pY3Jvc29mdCBXb3JkIDkiPgotPGxpbmsgcmVsPUZpbGUtTGlzdAotaHJlZj0iLi9FY2xpcHNlJTIwRVBMJTIwMjAwM18xMV8xMCUyMEZpbmFsX2ZpbGVzL2ZpbGVsaXN0LnhtbCI+Ci08dGl0bGU+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIFZlcnNpb24gMS4wPC90aXRsZT4KLTwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDxvOkRvY3VtZW50UHJvcGVydGllcz4KLSAgPG86UmV2aXNpb24+MjwvbzpSZXZpc2lvbj4KLSAgPG86VG90YWxUaW1lPjM8L286VG90YWxUaW1lPgotICA8bzpDcmVhdGVkPjIwMDQtMDMtMDVUMjM6MDM6MDBaPC9vOkNyZWF0ZWQ+Ci0gIDxvOkxhc3RTYXZlZD4yMDA0LTAzLTA1VDIzOjAzOjAwWjwvbzpMYXN0U2F2ZWQ+Ci0gIDxvOlBhZ2VzPjQ8L286UGFnZXM+Ci0gIDxvOldvcmRzPjE2MjY8L286V29yZHM+Ci0gIDxvOkNoYXJhY3RlcnM+OTI3MDwvbzpDaGFyYWN0ZXJzPgotICAgPG86TGluZXM+Nzc8L286TGluZXM+Ci0gIDxvOlBhcmFncmFwaHM+MTg8L286UGFyYWdyYXBocz4KLSAgPG86Q2hhcmFjdGVyc1dpdGhTcGFjZXM+MTEzODQ8L286Q2hhcmFjdGVyc1dpdGhTcGFjZXM+Ci0gIDxvOlZlcnNpb24+OS40NDAyPC9vOlZlcnNpb24+Ci0gPC9vOkRvY3VtZW50UHJvcGVydGllcz4KLTwveG1sPjwhW2VuZGlmXS0tPjwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDx3OldvcmREb2N1bWVudD4KLSAgPHc6VHJhY2tSZXZpc2lvbnMvPgotIDwvdzpXb3JkRG9jdW1lbnQ+Ci08L3htbD48IVtlbmRpZl0tLT4KLTxzdHlsZT4KLTwhLS0KLSAvKiBGb250IERlZmluaXRpb25zICovCi1AZm9udC1mYWNlCi0Je2ZvbnQtZmFtaWx5OlRhaG9tYTsKLQlwYW5vc2UtMToyIDExIDYgNCAzIDUgNCA0IDIgNDsKLQltc28tZm9udC1jaGFyc2V0OjA7Ci0JbXNvLWdlbmVyaWMtZm9udC1mYW1pbHk6c3dpc3M7Ci0JbXNvLWZvbnQtcGl0Y2g6dmFyaWFibGU7Ci0JbXNvLWZvbnQtc2lnbmF0dXJlOjU1MzY3OTQ5NSAtMjE0NzQ4MzY0OCA4IDAgNjYwNDcgMDt9Ci0gLyogU3R5bGUgRGVmaW5pdGlvbnMgKi8KLXAuTXNvTm9ybWFsLCBsaS5Nc29Ob3JtYWwsIGRpdi5Nc29Ob3JtYWwKLQl7bXNvLXN0eWxlLXBhcmVudDoiIjsKLQltYXJnaW46MGluOwotCW1hcmdpbi1ib3R0b206LjAwMDFwdDsKLQltc28tcGFnaW5hdGlvbjp3aWRvdy1vcnBoYW47Ci0JZm9udC1zaXplOjEyLjBwdDsKLQlmb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1wCi0Je21hcmdpbi1yaWdodDowaW47Ci0JbXNvLW1hcmdpbi10b3AtYWx0OmF1dG87Ci0JbXNvLW1hcmdpbi1ib3R0b20tYWx0OmF1dG87Ci0JbWFyZ2luLWxlZnQ6MGluOwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXAuQmFsbG9vblRleHQsIGxpLkJhbGxvb25UZXh0LCBkaXYuQmFsbG9vblRleHQKLQl7bXNvLXN0eWxlLW5hbWU6IkJhbGxvb24gVGV4dCI7Ci0JbWFyZ2luOjBpbjsKLQltYXJnaW4tYm90dG9tOi4wMDAxcHQ7Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZTo4LjBwdDsKLQlmb250LWZhbWlseTpUYWhvbWE7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotQHBhZ2UgU2VjdGlvbjEKLQl7c2l6ZTo4LjVpbiAxMS4waW47Ci0JbWFyZ2luOjEuMGluIDEuMjVpbiAxLjBpbiAxLjI1aW47Ci0JbXNvLWhlYWRlci1tYXJnaW46LjVpbjsKLQltc28tZm9vdGVyLW1hcmdpbjouNWluOwotCW1zby1wYXBlci1zb3VyY2U6MDt9Ci1kaXYuU2VjdGlvbjEKLQl7cGFnZTpTZWN0aW9uMTt9Ci0tLT4KLTwvc3R5bGU+Ci08L2hlYWQ+Ci0KLTxib2R5IGxhbmc9RU4tVVMgc3R5bGU9J3RhYi1pbnRlcnZhbDouNWluJz4KLQotPGRpdiBjbGFzcz1TZWN0aW9uMT4KLQotPHAgYWxpZ249Y2VudGVyIHN0eWxlPSd0ZXh0LWFsaWduOmNlbnRlcic+PGI+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIHYgMS4wPC9iPgotPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+VEhFIEFDQ09NUEFOWUlORyBQUk9HUkFNIElTIFBST1ZJREVEIFVOREVSCi1USEUgVEVSTVMgT0YgVEhJUyBFQ0xJUFNFIFBVQkxJQyBMSUNFTlNFICgmcXVvdDtBR1JFRU1FTlQmcXVvdDspLiBBTlkgVVNFLAotUkVQUk9EVUNUSU9OIE9SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBDT05TVElUVVRFUyBSRUNJUElFTlQnUyBBQ0NFUFRBTkNFCi1PRiBUSElTIEFHUkVFTUVOVC48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjEuIERFRklOSVRJT05TPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7Q29udHJpYnV0aW9uJnF1b3Q7IG1lYW5zOjwvc3Bhbj4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5hKQotaW4gdGhlIGNhc2Ugb2YgdGhlIGluaXRpYWwgQ29udHJpYnV0b3IsIHRoZSBpbml0aWFsIGNvZGUgYW5kIGRvY3VtZW50YXRpb24KLWRpc3RyaWJ1dGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBhbmQ8YnIgY2xlYXI9bGVmdD4KLWIpIGluIHRoZSBjYXNlIG9mIGVhY2ggc3Vic2VxdWVudCBDb250cmlidXRvcjo8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pKQotY2hhbmdlcyB0byB0aGUgUHJvZ3JhbSwgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWkpCi1hZGRpdGlvbnMgdG8gdGhlIFByb2dyYW07PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+d2hlcmUKLXN1Y2ggY2hhbmdlcyBhbmQvb3IgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIG9yaWdpbmF0ZSBmcm9tIGFuZCBhcmUgZGlzdHJpYnV0ZWQKLWJ5IHRoYXQgcGFydGljdWxhciBDb250cmlidXRvci4gQSBDb250cmlidXRpb24gJ29yaWdpbmF0ZXMnIGZyb20gYSBDb250cmlidXRvcgotaWYgaXQgd2FzIGFkZGVkIHRvIHRoZSBQcm9ncmFtIGJ5IHN1Y2ggQ29udHJpYnV0b3IgaXRzZWxmIG9yIGFueW9uZSBhY3Rpbmcgb24KLXN1Y2ggQ29udHJpYnV0b3IncyBiZWhhbGYuIENvbnRyaWJ1dGlvbnMgZG8gbm90IGluY2x1ZGUgYWRkaXRpb25zIHRvIHRoZQotUHJvZ3JhbSB3aGljaDogKGkpIGFyZSBzZXBhcmF0ZSBtb2R1bGVzIG9mIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIGluIGNvbmp1bmN0aW9uCi13aXRoIHRoZSBQcm9ncmFtIHVuZGVyIHRoZWlyIG93biBsaWNlbnNlIGFncmVlbWVudCwgYW5kIChpaSkgYXJlIG5vdCBkZXJpdmF0aXZlCi13b3JrcyBvZiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPiZxdW90O0NvbnRyaWJ1dG9yJnF1b3Q7IG1lYW5zIGFueSBwZXJzb24gb3IKLWVudGl0eSB0aGF0IGRpc3RyaWJ1dGVzIHRoZSBQcm9ncmFtLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7TGljZW5zZWQgUGF0ZW50cyAmcXVvdDsgbWVhbiBwYXRlbnQKLWNsYWltcyBsaWNlbnNhYmxlIGJ5IGEgQ29udHJpYnV0b3Igd2hpY2ggYXJlIG5lY2Vzc2FyaWx5IGluZnJpbmdlZCBieSB0aGUgdXNlCi1vciBzYWxlIG9mIGl0cyBDb250cmlidXRpb24gYWxvbmUgb3Igd2hlbiBjb21iaW5lZCB3aXRoIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7UHJvZ3JhbSZxdW90OyBtZWFucyB0aGUgQ29udHJpYnV0aW9ucwotZGlzdHJpYnV0ZWQgaW4gYWNjb3JkYW5jZSB3aXRoIHRoaXMgQWdyZWVtZW50Ljwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+JnF1b3Q7UmVjaXBpZW50JnF1b3Q7IG1lYW5zIGFueW9uZSB3aG8KLXJlY2VpdmVzIHRoZSBQcm9ncmFtIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBpbmNsdWRpbmcgYWxsIENvbnRyaWJ1dG9ycy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjIuIEdSQU5UIE9GIFJJR0hUUzwvc3Bhbj48L2I+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YSkKLVN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50Ci1hIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwgcm95YWx0eS1mcmVlIGNvcHlyaWdodCBsaWNlbnNlIHRvPHNwYW4KLXN0eWxlPSdjb2xvcjpyZWQnPiA8L3NwYW4+cmVwcm9kdWNlLCBwcmVwYXJlIGRlcml2YXRpdmUgd29ya3Mgb2YsIHB1YmxpY2x5Ci1kaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBkaXN0cmlidXRlIGFuZCBzdWJsaWNlbnNlIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaAotQ29udHJpYnV0b3IsIGlmIGFueSwgYW5kIHN1Y2ggZGVyaXZhdGl2ZSB3b3JrcywgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlCi1mb3JtLjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmIpCi1TdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzCi1SZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsPHNwYW4gc3R5bGU9J2NvbG9yOmdyZWVuJz4gPC9zcGFuPnJveWFsdHktZnJlZQotcGF0ZW50IGxpY2Vuc2UgdW5kZXIgTGljZW5zZWQgUGF0ZW50cyB0byBtYWtlLCB1c2UsIHNlbGwsIG9mZmVyIHRvIHNlbGwsIGltcG9ydAotYW5kIG90aGVyd2lzZSB0cmFuc2ZlciB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgaW4gc291cmNlCi1jb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLiBUaGlzIHBhdGVudCBsaWNlbnNlIHNoYWxsIGFwcGx5IHRvIHRoZSBjb21iaW5hdGlvbgotb2YgdGhlIENvbnRyaWJ1dGlvbiBhbmQgdGhlIFByb2dyYW0gaWYsIGF0IHRoZSB0aW1lIHRoZSBDb250cmlidXRpb24gaXMgYWRkZWQKLWJ5IHRoZSBDb250cmlidXRvciwgc3VjaCBhZGRpdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGNhdXNlcyBzdWNoIGNvbWJpbmF0aW9uCi10byBiZSBjb3ZlcmVkIGJ5IHRoZSBMaWNlbnNlZCBQYXRlbnRzLiBUaGUgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgbm90IGFwcGx5IHRvCi1hbnkgb3RoZXIgY29tYmluYXRpb25zIHdoaWNoIGluY2x1ZGUgdGhlIENvbnRyaWJ1dGlvbi4gTm8gaGFyZHdhcmUgcGVyIHNlIGlzCi1saWNlbnNlZCBoZXJldW5kZXIuIDwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmMpCi1SZWNpcGllbnQgdW5kZXJzdGFuZHMgdGhhdCBhbHRob3VnaCBlYWNoIENvbnRyaWJ1dG9yIGdyYW50cyB0aGUgbGljZW5zZXMgdG8gaXRzCi1Db250cmlidXRpb25zIHNldCBmb3J0aCBoZXJlaW4sIG5vIGFzc3VyYW5jZXMgYXJlIHByb3ZpZGVkIGJ5IGFueSBDb250cmlidXRvcgotdGhhdCB0aGUgUHJvZ3JhbSBkb2VzIG5vdCBpbmZyaW5nZSB0aGUgcGF0ZW50IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQotcmlnaHRzIG9mIGFueSBvdGhlciBlbnRpdHkuIEVhY2ggQ29udHJpYnV0b3IgZGlzY2xhaW1zIGFueSBsaWFiaWxpdHkgdG8gUmVjaXBpZW50Ci1mb3IgY2xhaW1zIGJyb3VnaHQgYnkgYW55IG90aGVyIGVudGl0eSBiYXNlZCBvbiBpbmZyaW5nZW1lbnQgb2YgaW50ZWxsZWN0dWFsCi1wcm9wZXJ0eSByaWdodHMgb3Igb3RoZXJ3aXNlLiBBcyBhIGNvbmRpdGlvbiB0byBleGVyY2lzaW5nIHRoZSByaWdodHMgYW5kCi1saWNlbnNlcyBncmFudGVkIGhlcmV1bmRlciwgZWFjaCBSZWNpcGllbnQgaGVyZWJ5IGFzc3VtZXMgc29sZSByZXNwb25zaWJpbGl0eQotdG8gc2VjdXJlIGFueSBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG5lZWRlZCwgaWYgYW55LiBGb3IgZXhhbXBsZSwKLWlmIGEgdGhpcmQgcGFydHkgcGF0ZW50IGxpY2Vuc2UgaXMgcmVxdWlyZWQgdG8gYWxsb3cgUmVjaXBpZW50IHRvIGRpc3RyaWJ1dGUKLXRoZSBQcm9ncmFtLCBpdCBpcyBSZWNpcGllbnQncyByZXNwb25zaWJpbGl0eSB0byBhY3F1aXJlIHRoYXQgbGljZW5zZSBiZWZvcmUKLWRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbS48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5kKQotRWFjaCBDb250cmlidXRvciByZXByZXNlbnRzIHRoYXQgdG8gaXRzIGtub3dsZWRnZSBpdCBoYXMgc3VmZmljaWVudCBjb3B5cmlnaHQKLXJpZ2h0cyBpbiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIHRvIGdyYW50IHRoZSBjb3B5cmlnaHQgbGljZW5zZSBzZXQgZm9ydGggaW4KLXRoaXMgQWdyZWVtZW50LiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+My4gUkVRVUlSRU1FTlRTPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+QSBDb250cmlidXRvciBtYXkgY2hvb3NlIHRvIGRpc3RyaWJ1dGUgdGhlCi1Qcm9ncmFtIGluIG9iamVjdCBjb2RlIGZvcm0gdW5kZXIgaXRzIG93biBsaWNlbnNlIGFncmVlbWVudCwgcHJvdmlkZWQgdGhhdDo8L3NwYW4+Ci08L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pdCBjb21wbGllcyB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudDsgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikKLWl0cyBsaWNlbnNlIGFncmVlbWVudDo8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5pKQotZWZmZWN0aXZlbHkgZGlzY2xhaW1zIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCB3YXJyYW50aWVzIGFuZAotY29uZGl0aW9ucywgZXhwcmVzcyBhbmQgaW1wbGllZCwgaW5jbHVkaW5nIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiB0aXRsZQotYW5kIG5vbi1pbmZyaW5nZW1lbnQsIGFuZCBpbXBsaWVkIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiBtZXJjaGFudGFiaWxpdHkKLWFuZCBmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZTsgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aWkpCi1lZmZlY3RpdmVseSBleGNsdWRlcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgbGlhYmlsaXR5IGZvciBkYW1hZ2VzLAotaW5jbHVkaW5nIGRpcmVjdCwgaW5kaXJlY3QsIHNwZWNpYWwsIGluY2lkZW50YWwgYW5kIGNvbnNlcXVlbnRpYWwgZGFtYWdlcywgc3VjaAotYXMgbG9zdCBwcm9maXRzOyA8L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0Oi41aW4nPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5paWkpCi1zdGF0ZXMgdGhhdCBhbnkgcHJvdmlzaW9ucyB3aGljaCBkaWZmZXIgZnJvbSB0aGlzIEFncmVlbWVudCBhcmUgb2ZmZXJlZCBieSB0aGF0Ci1Db250cmlidXRvciBhbG9uZSBhbmQgbm90IGJ5IGFueSBvdGhlciBwYXJ0eTsgYW5kPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+aXYpCi1zdGF0ZXMgdGhhdCBzb3VyY2UgY29kZSBmb3IgdGhlIFByb2dyYW0gaXMgYXZhaWxhYmxlIGZyb20gc3VjaCBDb250cmlidXRvciwgYW5kCi1pbmZvcm1zIGxpY2Vuc2VlcyBob3cgdG8gb2J0YWluIGl0IGluIGEgcmVhc29uYWJsZSBtYW5uZXIgb24gb3IgdGhyb3VnaCBhCi1tZWRpdW0gY3VzdG9tYXJpbHkgdXNlZCBmb3Igc29mdHdhcmUgZXhjaGFuZ2UuPHNwYW4gc3R5bGU9J2NvbG9yOmJsdWUnPiA8L3NwYW4+PC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPldoZW4gdGhlIFByb2dyYW0gaXMgbWFkZSBhdmFpbGFibGUgaW4gc291cmNlCi1jb2RlIGZvcm06PC9zcGFuPiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjVpbic+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPmEpCi1pdCBtdXN0IGJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoaXMgQWdyZWVtZW50OyBhbmQgPC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDouNWluJz48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+YikgYQotY29weSBvZiB0aGlzIEFncmVlbWVudCBtdXN0IGJlIGluY2x1ZGVkIHdpdGggZWFjaCBjb3B5IG9mIHRoZSBQcm9ncmFtLiA8L3NwYW4+PC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Q29udHJpYnV0b3JzIG1heSBub3QgcmVtb3ZlIG9yIGFsdGVyIGFueQotY29weXJpZ2h0IG5vdGljZXMgY29udGFpbmVkIHdpdGhpbiB0aGUgUHJvZ3JhbS4gPC9zcGFuPjwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkVhY2ggQ29udHJpYnV0b3IgbXVzdCBpZGVudGlmeSBpdHNlbGYgYXMgdGhlCi1vcmlnaW5hdG9yIG9mIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgaW4gYSBtYW5uZXIgdGhhdCByZWFzb25hYmx5IGFsbG93cwotc3Vic2VxdWVudCBSZWNpcGllbnRzIHRvIGlkZW50aWZ5IHRoZSBvcmlnaW5hdG9yIG9mIHRoZSBDb250cmlidXRpb24uIDwvc3Bhbj48L3A+Ci0KLTxwPjxiPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz40LiBDT01NRVJDSUFMIERJU1RSSUJVVElPTjwvc3Bhbj48L2I+IDwvcD4KLQotPHA+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPkNvbW1lcmNpYWwgZGlzdHJpYnV0b3JzIG9mIHNvZnR3YXJlIG1heQotYWNjZXB0IGNlcnRhaW4gcmVzcG9uc2liaWxpdGllcyB3aXRoIHJlc3BlY3QgdG8gZW5kIHVzZXJzLCBidXNpbmVzcyBwYXJ0bmVycwotYW5kIHRoZSBsaWtlLiBXaGlsZSB0aGlzIGxpY2Vuc2UgaXMgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY29tbWVyY2lhbCB1c2UKLW9mIHRoZSBQcm9ncmFtLCB0aGUgQ29udHJpYnV0b3Igd2hvIGluY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbAotcHJvZHVjdCBvZmZlcmluZyBzaG91bGQgZG8gc28gaW4gYSBtYW5uZXIgd2hpY2ggZG9lcyBub3QgY3JlYXRlIHBvdGVudGlhbAotbGlhYmlsaXR5IGZvciBvdGhlciBDb250cmlidXRvcnMuIFRoZXJlZm9yZSwgaWYgYSBDb250cmlidXRvciBpbmNsdWRlcyB0aGUKLVByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIHN1Y2ggQ29udHJpYnV0b3IgKCZxdW90O0NvbW1lcmNpYWwKLUNvbnRyaWJ1dG9yJnF1b3Q7KSBoZXJlYnkgYWdyZWVzIHRvIGRlZmVuZCBhbmQgaW5kZW1uaWZ5IGV2ZXJ5IG90aGVyCi1Db250cmlidXRvciAoJnF1b3Q7SW5kZW1uaWZpZWQgQ29udHJpYnV0b3ImcXVvdDspIGFnYWluc3QgYW55IGxvc3NlcywgZGFtYWdlcyBhbmQKLWNvc3RzIChjb2xsZWN0aXZlbHkgJnF1b3Q7TG9zc2VzJnF1b3Q7KSBhcmlzaW5nIGZyb20gY2xhaW1zLCBsYXdzdWl0cyBhbmQgb3RoZXIKLWxlZ2FsIGFjdGlvbnMgYnJvdWdodCBieSBhIHRoaXJkIHBhcnR5IGFnYWluc3QgdGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIHRvCi10aGUgZXh0ZW50IGNhdXNlZCBieSB0aGUgYWN0cyBvciBvbWlzc2lvbnMgb2Ygc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluCi1jb25uZWN0aW9uIHdpdGggaXRzIGRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdAotb2ZmZXJpbmcuIFRoZSBvYmxpZ2F0aW9ucyBpbiB0aGlzIHNlY3Rpb24gZG8gbm90IGFwcGx5IHRvIGFueSBjbGFpbXMgb3IgTG9zc2VzCi1yZWxhdGluZyB0byBhbnkgYWN0dWFsIG9yIGFsbGVnZWQgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGluZnJpbmdlbWVudC4gSW4gb3JkZXIKLXRvIHF1YWxpZnksIGFuIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG11c3Q6IGEpIHByb21wdGx5IG5vdGlmeSB0aGUgQ29tbWVyY2lhbAotQ29udHJpYnV0b3IgaW4gd3JpdGluZyBvZiBzdWNoIGNsYWltLCBhbmQgYikgYWxsb3cgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IKLXRvIGNvbnRyb2wsIGFuZCBjb29wZXJhdGUgd2l0aCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiwgdGhlIGRlZmVuc2UgYW5kCi1hbnkgcmVsYXRlZCBzZXR0bGVtZW50IG5lZ290aWF0aW9ucy4gVGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG1heSBwYXJ0aWNpcGF0ZQotaW4gYW55IHN1Y2ggY2xhaW0gYXQgaXRzIG93biBleHBlbnNlLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Rm9yIGV4YW1wbGUsIGEgQ29udHJpYnV0b3IgbWlnaHQgaW5jbHVkZSB0aGUKLVByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIFByb2R1Y3QgWC4gVGhhdCBDb250cmlidXRvciBpcyB0aGVuIGEKLUNvbW1lcmNpYWwgQ29udHJpYnV0b3IuIElmIHRoYXQgQ29tbWVyY2lhbCBDb250cmlidXRvciB0aGVuIG1ha2VzIHBlcmZvcm1hbmNlCi1jbGFpbXMsIG9yIG9mZmVycyB3YXJyYW50aWVzIHJlbGF0ZWQgdG8gUHJvZHVjdCBYLCB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kCi13YXJyYW50aWVzIGFyZSBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IncyByZXNwb25zaWJpbGl0eSBhbG9uZS4gVW5kZXIgdGhpcwotc2VjdGlvbiwgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3Igd291bGQgaGF2ZSB0byBkZWZlbmQgY2xhaW1zIGFnYWluc3QgdGhlCi1vdGhlciBDb250cmlidXRvcnMgcmVsYXRlZCB0byB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMsIGFuZCBpZiBhCi1jb3VydCByZXF1aXJlcyBhbnkgb3RoZXIgQ29udHJpYnV0b3IgdG8gcGF5IGFueSBkYW1hZ2VzIGFzIGEgcmVzdWx0LCB0aGUKLUNvbW1lcmNpYWwgQ29udHJpYnV0b3IgbXVzdCBwYXkgdGhvc2UgZGFtYWdlcy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjUuIE5PIFdBUlJBTlRZPC9zcGFuPjwvYj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUwotQUdSRUVNRU5ULCBUSEUgUFJPR1JBTSBJUyBQUk9WSURFRCBPTiBBTiAmcXVvdDtBUyBJUyZxdW90OyBCQVNJUywgV0lUSE9VVAotV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBFSVRIRVIgRVhQUkVTUyBPUiBJTVBMSUVEIElOQ0xVRElORywKLVdJVEhPVVQgTElNSVRBVElPTiwgQU5ZIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBUSVRMRSwgTk9OLUlORlJJTkdFTUVOVCwKLU1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gRWFjaCBSZWNpcGllbnQgaXMgc29sZWx5Ci1yZXNwb25zaWJsZSBmb3IgZGV0ZXJtaW5pbmcgdGhlIGFwcHJvcHJpYXRlbmVzcyBvZiB1c2luZyBhbmQgZGlzdHJpYnV0aW5nIHRoZQotUHJvZ3JhbSBhbmQgYXNzdW1lcyBhbGwgcmlza3MgYXNzb2NpYXRlZCB3aXRoIGl0cyBleGVyY2lzZSBvZiByaWdodHMgdW5kZXIgdGhpcwotQWdyZWVtZW50ICwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgcmlza3MgYW5kIGNvc3RzIG9mIHByb2dyYW0gZXJyb3JzLAotY29tcGxpYW5jZSB3aXRoIGFwcGxpY2FibGUgbGF3cywgZGFtYWdlIHRvIG9yIGxvc3Mgb2YgZGF0YSwgcHJvZ3JhbXMgb3IKLWVxdWlwbWVudCwgYW5kIHVuYXZhaWxhYmlsaXR5IG9yIGludGVycnVwdGlvbiBvZiBvcGVyYXRpb25zLiA8L3NwYW4+PC9wPgotCi08cD48Yj48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+Ni4gRElTQ0xBSU1FUiBPRiBMSUFCSUxJVFk8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTCi1BR1JFRU1FTlQsIE5FSVRIRVIgUkVDSVBJRU5UIE5PUiBBTlkgQ09OVFJJQlVUT1JTIFNIQUxMIEhBVkUgQU5ZIExJQUJJTElUWSBGT1IKLUFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwotKElOQ0xVRElORyBXSVRIT1VUIExJTUlUQVRJT04gTE9TVCBQUk9GSVRTKSwgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKLU9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HCi1ORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9SIERJU1RSSUJVVElPTiBPRgotVEhFIFBST0dSQU0gT1IgVEhFIEVYRVJDSVNFIE9GIEFOWSBSSUdIVFMgR1JBTlRFRCBIRVJFVU5ERVIsIEVWRU4gSUYgQURWSVNFRCBPRgotVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFUy48L3NwYW4+IDwvcD4KLQotPHA+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxMC4wcHQnPjcuIEdFTkVSQUw8L3NwYW4+PC9iPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5JZiBhbnkgcHJvdmlzaW9uIG9mIHRoaXMgQWdyZWVtZW50IGlzIGludmFsaWQKLW9yIHVuZW5mb3JjZWFibGUgdW5kZXIgYXBwbGljYWJsZSBsYXcsIGl0IHNoYWxsIG5vdCBhZmZlY3QgdGhlIHZhbGlkaXR5IG9yCi1lbmZvcmNlYWJpbGl0eSBvZiB0aGUgcmVtYWluZGVyIG9mIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgYW5kIHdpdGhvdXQKLWZ1cnRoZXIgYWN0aW9uIGJ5IHRoZSBwYXJ0aWVzIGhlcmV0bywgc3VjaCBwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlCi1taW5pbXVtIGV4dGVudCBuZWNlc3NhcnkgdG8gbWFrZSBzdWNoIHByb3Zpc2lvbiB2YWxpZCBhbmQgZW5mb3JjZWFibGUuPC9zcGFuPiA8L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5JZiBSZWNpcGllbnQgaW5zdGl0dXRlcyBwYXRlbnQgbGl0aWdhdGlvbgotYWdhaW5zdCBhbnkgZW50aXR5IChpbmNsdWRpbmcgYSBjcm9zcy1jbGFpbSBvciBjb3VudGVyY2xhaW0gaW4gYSBsYXdzdWl0KQotYWxsZWdpbmcgdGhhdCB0aGUgUHJvZ3JhbSBpdHNlbGYgKGV4Y2x1ZGluZyBjb21iaW5hdGlvbnMgb2YgdGhlIFByb2dyYW0gd2l0aAotb3RoZXIgc29mdHdhcmUgb3IgaGFyZHdhcmUpIGluZnJpbmdlcyBzdWNoIFJlY2lwaWVudCdzIHBhdGVudChzKSwgdGhlbiBzdWNoCi1SZWNpcGllbnQncyByaWdodHMgZ3JhbnRlZCB1bmRlciBTZWN0aW9uIDIoYikgc2hhbGwgdGVybWluYXRlIGFzIG9mIHRoZSBkYXRlCi1zdWNoIGxpdGlnYXRpb24gaXMgZmlsZWQuIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5BbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50Ci1zaGFsbCB0ZXJtaW5hdGUgaWYgaXQgZmFpbHMgdG8gY29tcGx5IHdpdGggYW55IG9mIHRoZSBtYXRlcmlhbCB0ZXJtcyBvcgotY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudCBhbmQgZG9lcyBub3QgY3VyZSBzdWNoIGZhaWx1cmUgaW4gYSByZWFzb25hYmxlCi1wZXJpb2Qgb2YgdGltZSBhZnRlciBiZWNvbWluZyBhd2FyZSBvZiBzdWNoIG5vbmNvbXBsaWFuY2UuIElmIGFsbCBSZWNpcGllbnQncwotcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHRlcm1pbmF0ZSwgUmVjaXBpZW50IGFncmVlcyB0byBjZWFzZSB1c2UgYW5kCi1kaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gYXMgc29vbiBhcyByZWFzb25hYmx5IHByYWN0aWNhYmxlLiBIb3dldmVyLAotUmVjaXBpZW50J3Mgb2JsaWdhdGlvbnMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYW5kIGFueSBsaWNlbnNlcyBncmFudGVkIGJ5Ci1SZWNpcGllbnQgcmVsYXRpbmcgdG8gdGhlIFByb2dyYW0gc2hhbGwgY29udGludWUgYW5kIHN1cnZpdmUuIDwvc3Bhbj48L3A+Ci0KLTxwPjxzcGFuIHN0eWxlPSdmb250LXNpemU6MTAuMHB0Jz5FdmVyeW9uZSBpcyBwZXJtaXR0ZWQgdG8gY29weSBhbmQgZGlzdHJpYnV0ZQotY29waWVzIG9mIHRoaXMgQWdyZWVtZW50LCBidXQgaW4gb3JkZXIgdG8gYXZvaWQgaW5jb25zaXN0ZW5jeSB0aGUgQWdyZWVtZW50IGlzCi1jb3B5cmlnaHRlZCBhbmQgbWF5IG9ubHkgYmUgbW9kaWZpZWQgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXIuIFRoZSBBZ3JlZW1lbnQKLVN0ZXdhcmQgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHB1Ymxpc2ggbmV3IHZlcnNpb25zIChpbmNsdWRpbmcgcmV2aXNpb25zKSBvZgotdGhpcyBBZ3JlZW1lbnQgZnJvbSB0aW1lIHRvIHRpbWUuIE5vIG9uZSBvdGhlciB0aGFuIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCBoYXMKLXRoZSByaWdodCB0byBtb2RpZnkgdGhpcyBBZ3JlZW1lbnQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgdGhlIGluaXRpYWwKLUFncmVlbWVudCBTdGV3YXJkLiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1heSBhc3NpZ24gdGhlIHJlc3BvbnNpYmlsaXR5IHRvCi1zZXJ2ZSBhcyB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgdG8gYSBzdWl0YWJsZSBzZXBhcmF0ZSBlbnRpdHkuIEVhY2ggbmV3IHZlcnNpb24KLW9mIHRoZSBBZ3JlZW1lbnQgd2lsbCBiZSBnaXZlbiBhIGRpc3Rpbmd1aXNoaW5nIHZlcnNpb24gbnVtYmVyLiBUaGUgUHJvZ3JhbQotKGluY2x1ZGluZyBDb250cmlidXRpb25zKSBtYXkgYWx3YXlzIGJlIGRpc3RyaWJ1dGVkIHN1YmplY3QgdG8gdGhlIHZlcnNpb24gb2YKLXRoZSBBZ3JlZW1lbnQgdW5kZXIgd2hpY2ggaXQgd2FzIHJlY2VpdmVkLiBJbiBhZGRpdGlvbiwgYWZ0ZXIgYSBuZXcgdmVyc2lvbiBvZgotdGhlIEFncmVlbWVudCBpcyBwdWJsaXNoZWQsIENvbnRyaWJ1dG9yIG1heSBlbGVjdCB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtCi0oaW5jbHVkaW5nIGl0cyBDb250cmlidXRpb25zKSB1bmRlciB0aGUgbmV3IHZlcnNpb24uIEV4Y2VwdCBhcyBleHByZXNzbHkgc3RhdGVkCi1pbiBTZWN0aW9ucyAyKGEpIGFuZCAyKGIpIGFib3ZlLCBSZWNpcGllbnQgcmVjZWl2ZXMgbm8gcmlnaHRzIG9yIGxpY2Vuc2VzIHRvCi10aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IG9mIGFueSBDb250cmlidXRvciB1bmRlciB0aGlzIEFncmVlbWVudCwgd2hldGhlcgotZXhwcmVzc2x5LCBieSBpbXBsaWNhdGlvbiwgZXN0b3BwZWwgb3Igb3RoZXJ3aXNlLiBBbGwgcmlnaHRzIGluIHRoZSBQcm9ncmFtIG5vdAotZXhwcmVzc2x5IGdyYW50ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYXJlIHJlc2VydmVkLjwvc3Bhbj4gPC9wPgotCi08cD48c3BhbiBzdHlsZT0nZm9udC1zaXplOjEwLjBwdCc+VGhpcyBBZ3JlZW1lbnQgaXMgZ292ZXJuZWQgYnkgdGhlIGxhd3Mgb2YgdGhlCi1TdGF0ZSBvZiBOZXcgWW9yayBhbmQgdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBsYXdzIG9mIHRoZSBVbml0ZWQgU3RhdGVzIG9mCi1BbWVyaWNhLiBObyBwYXJ0eSB0byB0aGlzIEFncmVlbWVudCB3aWxsIGJyaW5nIGEgbGVnYWwgYWN0aW9uIHVuZGVyIHRoaXMKLUFncmVlbWVudCBtb3JlIHRoYW4gb25lIHllYXIgYWZ0ZXIgdGhlIGNhdXNlIG9mIGFjdGlvbiBhcm9zZS4gRWFjaCBwYXJ0eSB3YWl2ZXMKLWl0cyByaWdodHMgdG8gYSBqdXJ5IHRyaWFsIGluIGFueSByZXN1bHRpbmcgbGl0aWdhdGlvbi48L3NwYW4+IDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjwhW2lmICFzdXBwb3J0RW1wdHlQYXJhc10+Jm5ic3A7PCFbZW5kaWZdPjxvOnA+PC9vOnA+PC9wPgotCi08L2Rpdj4KLQotPC9ib2R5PgotCi08L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuZmVhdHVyZS9mZWF0dXJlLnByb3BlcnRpZXMgYi9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5mZWF0dXJlL2ZlYXR1cmUucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYTE0MjA0YS4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5mZWF0dXJlL2ZlYXR1cmUucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDE0MCArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0KLSMgImZlYXR1cmVOYW1lIiBwcm9wZXJ0eSAtIG5hbWUgb2YgdGhlIGZlYXR1cmUKLWZlYXR1cmVOYW1lPUphdmEgUGVyc2lzdGVuY2UgQVBJIFRvb2xzIFBsdWctaW4gU0RLCi0KLSMgInByb3ZpZGVyTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBjb21wYW55IHRoYXQgcHJvdmlkZXMgdGhlIGZlYXR1cmUKLXByb3ZpZGVyTmFtZT1FY2xpcHNlLm9yZwotCi0jICJ1cGRhdGVTaXRlTmFtZSIgcHJvcGVydHkgLSBsYWJlbCBmb3IgdGhlIHVwZGF0ZSBzaXRlCi11cGRhdGVTaXRlTmFtZT1UaGUgRWNsaXBzZSBXZWIgVG9vbHMgUGxhdGZvcm0gKFdUUCkgUHJvamVjdCB1cGRhdGUgc2l0ZQotCi0jICJkZXNjcmlwdGlvbiIgcHJvcGVydHkgLSBkZXNjcmlwdGlvbiBvZiB0aGUgZmVhdHVyZQotZGVzY3JpcHRpb249U291cmNlIGNvZGUgemlwcyBmb3IgSlBBIFRvb2xzCi0KLSMgImNvcHlyaWdodCIgcHJvcGVydHkgLSB0ZXh0IG9mIHRoZSAiRmVhdHVyZSBVcGRhdGUgQ29weXJpZ2h0IgotY29weXJpZ2h0PVwKLUNvcHlyaWdodCAoYykgMjAwNi0wNyBPcmFjbGUgQ29ycG9yYXRpb24uXG5cCi1BbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzXG5cCi1hcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjBcblwKLXdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0XG5cCi1odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbFxuXAotXG5cCi1Db250cmlidXRvcnM6XG5cCi0gICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uXG4KLSMjIyMjIyMjIyMjIyMjIyMgZW5kIG9mIGNvcHlyaWdodCBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotIyAibGljZW5zZVVSTCIgcHJvcGVydHkgLSBVUkwgb2YgdGhlICJGZWF0dXJlIExpY2Vuc2UiCi0jIGRvIG5vdCB0cmFuc2xhdGUgdmFsdWUgLSBqdXN0IGNoYW5nZSB0byBwb2ludCB0byBhIGxvY2FsZS1zcGVjaWZpYyBIVE1MIHBhZ2UKLWxpY2Vuc2VVUkw9bGljZW5zZS5odG1sCi0KLSMgImxpY2Vuc2UiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIExpY2Vuc2UiCi0jIHNob3VsZCBiZSBwbGFpbiB0ZXh0IHZlcnNpb24gb2YgbGljZW5zZSBhZ3JlZW1lbnQgcG9pbnRlZCB0byBiZSAibGljZW5zZVVSTCIKLWxpY2Vuc2U9XAotRUNMSVBTRSBGT1VOREFUSU9OIFNPRlRXQVJFIFVTRVIgQUdSRUVNRU5UXG5cCi1KdW5lIDA2LCAyMDA3XG5cCi1cblwKLVVzYWdlIE9mIENvbnRlbnRcblwKLVxuXAotVEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUlxuXAotT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUyAoQ09MTEVDVElWRUxZICJDT05URU5UIikuXG5cCi1VU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVNcblwKLUFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUlxuXAotTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVVxuXAotQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVFxuXAotQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFNcblwKLU9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFXG5cCi1URVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TXG5cCi1PRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRFxuXAotQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULlxuXAotXG5cCi1BcHBsaWNhYmxlIExpY2Vuc2VzXG5cCi1cblwKLVVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uXG5cCi1pcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpY1xuXAotTGljZW5zZSBWZXJzaW9uIDEuMCAoIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXNcblwKLUNvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLlxuXAotRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuXG5cCi1cblwKLUNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLFxuXAotZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZS5vcmcgQ1ZTXG5cCi1yZXBvc2l0b3J5ICgiUmVwb3NpdG9yeSIpIGluIENWUyBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIGF2YWlsYWJsZVxuXAotYXMgZG93bmxvYWRhYmxlIGFyY2hpdmVzICgiRG93bmxvYWRzIikuXG5cCi1cblwKLSAgIC0gQ29udGVudCBtYXkgYmUgc3RydWN0dXJlZCBhbmQgcGFja2FnZWQgaW50byBtb2R1bGVzIHRvIGZhY2lsaXRhdGUgZGVsaXZlcmluZyxcblwKLSAgICAgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiBUeXBpY2FsIG1vZHVsZXMgbWF5IGluY2x1ZGUgcGx1Zy1pbnMgKCJQbHVnLWlucyIpLFxuXAotICAgICBwbHVnLWluIGZyYWdtZW50cyAoIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLlxuXAotICAgLSBFYWNoIFBsdWctaW4gb3IgRnJhZ21lbnQgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBvciBKQVIgKEphdmE/IEFSY2hpdmUpXG5cCi0gICAgIGluIGEgZGlyZWN0b3J5IG5hbWVkICJwbHVnaW5zIi5cblwKLSAgIC0gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuXG5cCi0gICAgIEVhY2ggRmVhdHVyZSBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IGluIGEgZGlyZWN0b3J5IG5hbWVkICJmZWF0dXJlcyIuXG5cCi0gICAgIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvblxuXAotICAgICBudW1iZXJzIG9mIHRoZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuXG5cCi0gICAtIEZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCJJbmNsdWRlZCBGZWF0dXJlcyIpLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlc1xuXAotICAgICBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy5cblwKLVxuXAotRmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIEZpbGVzIG5hbWVkXG5cCi0iZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZlxuXAotSW5jbHVkZWQgRmVhdHVyZXMuXG5cCi1cblwKLVRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmVcblwKLWNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZFxuXAotY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kIEluY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWRcblwKLWluIGZpbGVzIG5hbWVkICJsaWNlbnNlLmh0bWwiICgiRmVhdHVyZSBMaWNlbnNlcyIpLiBBYm91dHMgYW5kIEZlYXR1cmVcblwKLUxpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSBkaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGVcblwKLWluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOlxuXAotXG5cCi0gICAtIFRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeVxuXAotICAgLSBQbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3Rvcmllc1xuXAotICAgLSBJbnNpZGUgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBwYWNrYWdlZCBhcyBKQVJzXG5cCi0gICAtIFN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnNcblwKLSAgIC0gRmVhdHVyZSBkaXJlY3Rvcmllc1xuXAotXG5cCi1Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlXG5cCi1FY2xpcHNlIFVwZGF0ZSBNYW5hZ2VyLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFVwZGF0ZVxuXAotTGljZW5zZSIpIGR1cmluZyB0aGUgaW5zdGFsbGF0aW9uIHByb2Nlc3MuIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zXG5cCi1JbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdVxuXAotd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvciBpbmZvcm1cblwKLXlvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW5cblwKLXRoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIuIFN1Y2ggQWJvdXRzLFxuXAotRmVhdHVyZSBMaWNlbnNlcyBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kXG5cCi1jb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXJcblwKLXVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluIHRoYXQgZGlyZWN0b3J5LlxuXAotXG5cCi1USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVJcblwKLVRPIFRIRSBFUEwgT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLlxuXAotU09NRSBPRiBUSEVTRSBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOlxuXAotXG5cCi0gICAgLSBDb21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbClcblwKLSAgICAtIEFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFKVxuXAotICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wKVxuXAotICAgIC0gSUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9kZXZlbG9wZXJ3b3Jrcy9vcGVuc291cmNlL2xpY2Vuc2UxMC5odG1sKVxuXAotICAgIC0gTWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwpXG5cCi0gICAgLSBNb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sKVxuXAotICAgIC0gQ29tbW9uIERldmVsb3BtZW50IGFuZCBEaXN0cmlidXRpb24gTGljZW5zZSAoQ0RETCkgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwpXG5cCi1cblwKLUlUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1JcblwKLVRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlXG5cCi1pcyBwcm92aWRlZCwgcGxlYXNlIGNvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9uc1xuXAotZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LlxuXAotXG5cCi1DcnlwdG9ncmFwaHlcblwKLVxuXAotQ29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlXG5cCi1jdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsXG5cCi1hbmQvb3IgcmUtZXhwb3J0IHRvIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFXG5cCi11c2luZyBhbnkgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cyxcblwKLXJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIG9yIHVzZSxcblwKLWFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLlxuXAotXG5cCi1KYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIFN1biBNaWNyb3N5c3RlbXMsIEluYy4gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC5cbgotIyMjIyMjIyMjIyMgZW5kIG9mIGxpY2Vuc2UgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCmRpZmYgLS1naXQgYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5mZWF0dXJlL2ZlYXR1cmUueG1sIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuZmVhdHVyZS9mZWF0dXJlLnhtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzIwZDQzMS4uMDAwMDAwMAotLS0gYS9qcGEvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanB0X3Nkay5mZWF0dXJlL2ZlYXR1cmUueG1sCisrKyAvZGV2L251bGwKQEAgLTEsMzUgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxmZWF0dXJlCi0gICAgICBpZD0ib3JnLmVjbGlwc2UuanB0X3Nkay5mZWF0dXJlIgotICAgICAgbGFiZWw9IiVmZWF0dXJlTmFtZSIKLSAgICAgIHZlcnNpb249IjIuMi4wLnF1YWxpZmllciIKLSAgICAgIHByb3ZpZGVyLW5hbWU9IiVwcm92aWRlck5hbWUiPgotCi0gICA8ZGVzY3JpcHRpb24+Ci0gICAgICAlZGVzY3JpcHRpb24KLSAgIDwvZGVzY3JpcHRpb24+Ci0KLSAgIDxjb3B5cmlnaHQ+Ci0gICAgICAlY29weXJpZ2h0Ci0gICA8L2NvcHlyaWdodD4KLQotICAgPGxpY2Vuc2UgdXJsPSJsaWNlbnNlLmh0bWwiPgotICAgICAgJWxpY2Vuc2UKLSAgIDwvbGljZW5zZT4KLQotICAgPGluY2x1ZGVzCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LmZlYXR1cmUiCi0gICAgICAgICB2ZXJzaW9uPSIwLjAuMCIvPgotCi0gICA8aW5jbHVkZXMKLSAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHQuZmVhdHVyZS5zb3VyY2UiCi0gICAgICAgICB2ZXJzaW9uPSIwLjAuMCIvPgotCi0gICA8cGx1Z2luCi0gICAgICAgICBpZD0ib3JnLmVjbGlwc2UuanB0LmRvYy5pc3YiCi0gICAgICAgICBkb3dubG9hZC1zaXplPSIwIgotICAgICAgICAgaW5zdGFsbC1zaXplPSIwIgotICAgICAgICAgdmVyc2lvbj0iMC4wLjAiCi0gICAgICAgICB1bnBhY2s9ImZhbHNlIi8+Ci0KLTwvZmVhdHVyZT4KZGlmZiAtLWdpdCBhL2pwYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qcHRfc2RrLmZlYXR1cmUvbGljZW5zZS5odG1sIGIvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuZmVhdHVyZS9saWNlbnNlLmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZjNzczNzIuLjAwMDAwMDAKLS0tIGEvanBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpwdF9zZGsuZmVhdHVyZS9saWNlbnNlLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSw5OCArMCwwIEBACi08IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wMSBUcmFuc2l0aW9uYWwvL0VOIiAiaHR0cDovL3d3dy53M2Mub3JnL1RSLzE5OTkvUkVDLWh0bWw0MDEtMTk5OTEyMjQvbG9vc2UuZHRkIj4KLTwhLS0gc2F2ZWQgZnJvbSB1cmw9KDAwNDQpaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwvbm90aWNlLmh0bWwgLS0+Ci08SFRNTD48SEVBRD48VElUTEU+RWNsaXBzZS5vcmcgU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L1RJVExFPgotPE1FVEEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PWlzby04ODU5LTEiPgotPE1FVEEgY29udGVudD0iTVNIVE1MIDYuMDAuMjgwMC4xNDc5IiBuYW1lPUdFTkVSQVRPUj48L0hFQUQ+Ci08Qk9EWSBsYW5nPUVOLVVTIHZMaW5rPXB1cnBsZSBsaW5rPWJsdWU+Ci08SDI+RWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9IMj4KLTxQPkp1bmUgMDYsIDIwMDc8L1A+Ci08SDM+VXNhZ2UgT2YgQ29udGVudDwvSDM+Ci08UD5USEUgRUNMSVBTRSBGT1VOREFUSU9OIE1BS0VTIEFWQUlMQUJMRSBTT0ZUV0FSRSwgRE9DVU1FTlRBVElPTiwgSU5GT1JNQVRJT04gCi1BTkQvT1IgT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUyAoQ09MTEVDVElWRUxZICJDT05URU5UIikuIFVTRSBPRiAKLVRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIAotVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgCi1CRUxPVy4gQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVSBBR1JFRSBUSEFUIFlPVVIgVVNFIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIAotQlkgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIAotQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiBJRiBZT1UgRE8gTk9UIEFHUkVFIFRPIFRIRSAKLVRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORCBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIAotQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVywgVEhFTiBZT1UgCi1NQVkgTk9UIFVTRSBUSEUgQ09OVEVOVC48L1A+Ci08SDM+QXBwbGljYWJsZSBMaWNlbnNlczwvSDM+Ci08UD5Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgCi1Gb3VuZGF0aW9uIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgCi1QdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXMgCi1Db250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCA8QSAKLWhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvQT4uIAotRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9QPgotPFA+Q29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsIAotZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZS5vcmcgQ1ZTIHJlcG9zaXRvcnkgCi0oIlJlcG9zaXRvcnkiKSBpbiBDVlMgbW9kdWxlcyAoIk1vZHVsZXMiKSBhbmQgbWFkZSBhdmFpbGFibGUgYXMgZG93bmxvYWRhYmxlIAotYXJjaGl2ZXMgKCJEb3dubG9hZHMiKS48L1A+Ci08UD5Db250ZW50IG1heSBiZSBhcHBvcnRpb25lZCBpbnRvIHBsdWctaW5zICgiUGx1Zy1pbnMiKSwgcGx1Zy1pbiBmcmFnbWVudHMgCi0oIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLiBBIEZlYXR1cmUgaXMgYSBidW5kbGUgb2Ygb25lIG9yIG1vcmUgCi1QbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLiBGaWxlcyBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSAKLWNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIHRoZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIAotYXNzb2NpYXRlZCB3aXRoIGEgRmVhdHVyZS4gUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBhcmUgbG9jYXRlZCBpbiBkaXJlY3RvcmllcyAKLW5hbWVkICJwbHVnaW5zIiBhbmQgRmVhdHVyZXMgYXJlIGxvY2F0ZWQgaW4gZGlyZWN0b3JpZXMgbmFtZWQgImZlYXR1cmVzIi48L1A+Ci08UD5GZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgiSW5jbHVkZWQgRmVhdHVyZXMiKS4gRmlsZXMgbmFtZWQgCi0iZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCAKLUZlYXR1cmVzLjwvUD4KLTxQPlRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmUgY29udGFpbmVkIAotaW4gZmlsZXMgbmFtZWQgImFib3V0Lmh0bWwiICgiQWJvdXRzIikuIFRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgCi1GZWF0dXJlcyBhbmQgSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAibGljZW5zZS5odG1sIiAKLSgiRmVhdHVyZSBMaWNlbnNlcyIpLiBBYm91dHMgYW5kIEZlYXR1cmUgTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55IAotZGlyZWN0b3J5IG9mIGEgRG93bmxvYWQgb3IgTW9kdWxlIGluY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgCi1sb2NhdGlvbnM6PC9QPgotPFVMPgotICA8TEk+VGhlIHRvcC1sZXZlbCAocm9vdCkgZGlyZWN0b3J5IAotICA8TEk+UGx1Zy1pbiBhbmQgRnJhZ21lbnQgZGlyZWN0b3JpZXMgCi0gIDxMST5TdWJkaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnMgCi0gIDxMST5GZWF0dXJlIGRpcmVjdG9yaWVzIDwvTEk+PC9VTD4KLTxQPk5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIGluc3RhbGxlZCAKLXVzaW5nIHRoZSBFY2xpcHNlIFVwZGF0ZSBNYW5hZ2VyLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFVwZGF0ZSAKLUxpY2Vuc2UiKSBkdXJpbmcgdGhlIGluc3RhbGxhdGlvbiBwcm9jZXNzLiBJZiB0aGUgRmVhdHVyZSBjb250YWlucyBJbmNsdWRlZCAKLUZlYXR1cmVzLCB0aGUgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBzaG91bGQgZWl0aGVyIHByb3ZpZGUgeW91IHdpdGggdGhlIHRlcm1zIAotYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvciBpbmZvcm0geW91IHdoZXJlIHlvdSBjYW4gCi1sb2NhdGUgdGhlbS4gRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgbWF5IGJlIGZvdW5kIGluIHRoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgCi1maWxlcyBuYW1lZCAiZmVhdHVyZS5wcm9wZXJ0aWVzIi4gU3VjaCBBYm91dHMsIEZlYXR1cmUgTGljZW5zZXMgYW5kIEZlYXR1cmUgCi1VcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgKG9yIHJlZmVyZW5jZXMgdG8gc3VjaCB0ZXJtcyAKLWFuZCBjb25kaXRpb25zKSB0aGF0IGdvdmVybiB5b3VyIHVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluIHRoYXQgCi1kaXJlY3RvcnkuPC9QPgotPFA+VEhFIEFCT1VUUywgRkVBVFVSRSBMSUNFTlNFUyBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSIFRPIFRIRSBFUEwgCi1PUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuIFNPTUUgT0YgVEhFU0UgCi1PVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOjwvUD4KLTxVTD4KLSAgPExJPkNvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWw8L0E+KSAKLQotICA8TEk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRTwvQT4pIAotCi0gIDxMST5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjA8L0E+KSAKLQotICA8TEk+SUJNIFB1YmxpYyBMaWNlbnNlIDEuMCAoYXZhaWxhYmxlIGF0IDxBIAotICBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vZGV2ZWxvcGVyd29ya3Mvb3BlbnNvdXJjZS9saWNlbnNlMTAuaHRtbCI+aHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2RldmVsb3BlcndvcmtzL29wZW5zb3VyY2UvbGljZW5zZTEwLmh0bWw8L0E+KSAKLQotICA8TEk+TWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sIj5odHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbDwvQT4pIAotCi0gIDxMST5Nb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgPEEgCi0gIGhyZWY9Imh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbCI+aHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sPC9BPikgCi0gIDwvTEk+Ci0gIAotICA8TEk+Q29tbW9uIERldmVsb3BtZW50IGFuZCBEaXN0cmlidXRpb24gTGljZW5zZSAoQ0RETCkgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8QSAKLSAgaHJlZj0iaHR0cDovL3d3dy5zdW4uY29tL2NkZGwvY2RkbC5odG1sIj5odHRwOi8vd3d3LnN1bi5jb20vY2RkbC9jZGRsLmh0bWwpPC9BPgotICA8L0xJPgotPC9VTD4KLTxQPklUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1IgCi1UTyBVU0UgT0YgVEhFIENPTlRFTlQuIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2Ugb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBpcyAKLXByb3ZpZGVkLCBwbGVhc2UgY29udGFjdCB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHRvIGRldGVybWluZSB3aGF0IHRlcm1zIGFuZCAKLWNvbmRpdGlvbnMgZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LjwvUD4KLTxIMz5DcnlwdG9ncmFwaHk8L0gzPgotPFA+Q29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlIAotY3VycmVudGx5IG1heSBoYXZlIHJlc3RyaWN0aW9ucyBvbiB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBhbmQgdXNlLCBhbmQvb3IgCi1yZS1leHBvcnQgdG8gYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkUgdXNpbmcgYW55IAotZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cywgcmVndWxhdGlvbnMgYW5kIHBvbGljaWVzIAotY29uY2VybmluZyB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgCi10byBzZWUgaWYgdGhpcyBpcyBwZXJtaXR0ZWQuPC9QPjwvQk9EWT48L0hUTUw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIudWkvLmNsYXNzcGF0aCBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi51aS8uY2xhc3NwYXRoCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzMDRlODYxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi51aS8uY2xhc3NwYXRoCisrKyAvZGV2L251bGwKQEAgLTEsNyArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPGNsYXNzcGF0aD4KLQk8Y2xhc3NwYXRoZW50cnkga2luZD0ic3JjIiBwYXRoPSJzcmMiLz4KLQk8Y2xhc3NwYXRoZW50cnkga2luZD0iY29uIiBwYXRoPSJvcmcuZWNsaXBzZS5qZHQubGF1bmNoaW5nLkpSRV9DT05UQUlORVIvb3JnLmVjbGlwc2UuamR0LmludGVybmFsLmRlYnVnLnVpLmxhdW5jaGVyLlN0YW5kYXJkVk1UeXBlL0oyU0UtMS41Ii8+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9ImNvbiIgcGF0aD0ib3JnLmVjbGlwc2UucGRlLmNvcmUucmVxdWlyZWRQbHVnaW5zIi8+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9Im91dHB1dCIgcGF0aD0iYmluIi8+Ci08L2NsYXNzcGF0aD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi51aS8uY3ZzaWdub3JlIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLnVpLy5jdnNpZ25vcmUKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGExOTZkZDcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLnVpLy5jdnNpZ25vcmUKKysrIC9kZXYvbnVsbApAQCAtMSw2ICswLDAgQEAKLWJpbgotQGRvdAotdGVtcC5mb2xkZXIKLWJ1aWxkLnhtbAotamF2YUNvbXBpbGVyLi4uYXJncwotamF2YUNvbXBpbGVyLi4uYXJncy4qClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLnVpLy5wcm9qZWN0IGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLnVpLy5wcm9qZWN0CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4OGVhNWRhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi51aS8ucHJvamVjdAorKysgL2Rldi9udWxsCkBAIC0xLDI4ICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08cHJvamVjdERlc2NyaXB0aW9uPgotCTxuYW1lPm9yZy5lY2xpcHNlLmpwdC5kYi51aTwvbmFtZT4KLQk8Y29tbWVudD48L2NvbW1lbnQ+Ci0JPHByb2plY3RzPgotCTwvcHJvamVjdHM+Ci0JPGJ1aWxkU3BlYz4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLmpkdC5jb3JlLmphdmFidWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5NYW5pZmVzdEJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLlNjaGVtYUJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCTwvYnVpbGRTcGVjPgotCTxuYXR1cmVzPgotCQk8bmF0dXJlPm9yZy5lY2xpcHNlLnBkZS5QbHVnaW5OYXR1cmU8L25hdHVyZT4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5qZHQuY29yZS5qYXZhbmF0dXJlPC9uYXR1cmU+Ci0JPC9uYXR1cmVzPgotPC9wcm9qZWN0RGVzY3JpcHRpb24+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIudWkvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLnVpLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOGZhN2RiMS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIudWkvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzCisrKyAvZGV2L251bGwKQEAgLTEsMyArMCwwIEBACi0jVHVlIEphbiAxNSAxMToxMToyMiBFU1QgMjAwOAotZWNsaXBzZS5wcmVmZXJlbmNlcy52ZXJzaW9uPTEKLWVuY29kaW5nLzxwcm9qZWN0Pj1JU08tODg1OS0xCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIudWkvLnNldHRpbmdzL29yZy5lY2xpcHNlLmpkdC5jb3JlLnByZWZzIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLnVpLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5qZHQuY29yZS5wcmVmcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODQyYzI4Ni4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIudWkvLnNldHRpbmdzL29yZy5lY2xpcHNlLmpkdC5jb3JlLnByZWZzCisrKyAvZGV2L251bGwKQEAgLTEsNyArMCwwIEBACi0jU3VuIE1heSAyNyAxNDo1OTo0MiBFRFQgMjAwNwotZWNsaXBzZS5wcmVmZXJlbmNlcy52ZXJzaW9uPTEKLW9yZy5lY2xpcHNlLmpkdC5jb3JlLmNvbXBpbGVyLmNvZGVnZW4udGFyZ2V0UGxhdGZvcm09MS41Ci1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5jb21wbGlhbmNlPTEuNQotb3JnLmVjbGlwc2UuamR0LmNvcmUuY29tcGlsZXIucHJvYmxlbS5hc3NlcnRJZGVudGlmaWVyPWVycm9yCi1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5wcm9ibGVtLmVudW1JZGVudGlmaWVyPWVycm9yCi1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5zb3VyY2U9MS41CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIudWkvTUVUQS1JTkYvTUFOSUZFU1QuTUYgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIudWkvTUVUQS1JTkYvTUFOSUZFU1QuTUYKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGUzZTdkMTMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLnVpL01FVEEtSU5GL01BTklGRVNULk1GCisrKyAvZGV2L251bGwKQEAgLTEsMTUgKzAsMCBAQAotTWFuaWZlc3QtVmVyc2lvbjogMS4wCi1CdW5kbGUtTWFuaWZlc3RWZXJzaW9uOiAyCi1CdW5kbGUtTmFtZTogJXBsdWdpbk5hbWUKLUJ1bmRsZS1WZW5kb3I6ICVwcm92aWRlck5hbWUKLUJ1bmRsZS1TeW1ib2xpY05hbWU6IG9yZy5lY2xpcHNlLmpwdC5kYi51aQotQnVuZGxlLVZlcnNpb246IDEuMS4wLnF1YWxpZmllcgotQnVuZGxlLUNsYXNzUGF0aDogLgotQnVuZGxlLUxvY2FsaXphdGlvbjogcGx1Z2luCi1FeHBvcnQtUGFja2FnZTogb3JnLmVjbGlwc2UuanB0LmRiLnVpLmludGVybmFsOyB4LWZyaWVuZHM6PSJvcmcuZWNsaXBzZS5qcHQudWkiCi1SZXF1aXJlLUJ1bmRsZTogb3JnLmVjbGlwc2UudWk7YnVuZGxlLXZlcnNpb249IlszLjQuMCw0LjAuMCkiLAotIG9yZy5lY2xpcHNlLmpwdC5kYjtidW5kbGUtdmVyc2lvbj0iWzEuMi4wLDIuMC4wKSIsCi0gb3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS51aTtidW5kbGUtdmVyc2lvbj0iWzEuMS4wLDEuMi4wKSIsCi0gb3JnLmVjbGlwc2UuZGF0YXRvb2xzLnNxbHRvb2xzLmVkaXRvci5jb3JlO2J1bmRsZS12ZXJzaW9uPSJbMS4wLjAsMi4wLjApIiwKLSBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LmRiLmdlbmVyaWMudWk7YnVuZGxlLXZlcnNpb249IlsxLjAuMSwyLjAuMCkiCi1CdW5kbGUtUmVxdWlyZWRFeGVjdXRpb25FbnZpcm9ubWVudDogSjJTRS0xLjUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi51aS9hYm91dC5odG1sIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLnVpL2Fib3V0Lmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJlNTM0YmEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLnVpL2Fib3V0Lmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSwzNCArMCwwIEBACi08IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wLy9FTiI+Ci08SFRNTD4KLQotPGhlYWQ+Ci08dGl0bGU+QWJvdXQ8L3RpdGxlPgotPG1ldGEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiPgotPC9oZWFkPgotCi08Qk9EWSBsYW5nPSJFTi1VUyI+Ci0KLTxIMz5BYm91dCBUaGlzIENvbnRlbnQ8L0gzPgotCi08UD5NYXkgMDIsIDIwMDg8L1A+Ci0KLTxIMz5MaWNlbnNlPC9IMz4KLQotPFA+VGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYWtlcyBhdmFpbGFibGUgYWxsIGNvbnRlbnQgaW4gdGhpcyBwbHVnLWluIAotKCJDb250ZW50IikuIFVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkIGJlbG93LCB0aGUgQ29udGVudCBpcyBwcm92aWRlZCB0byB5b3UgCi11bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgCi0oIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBhdmFpbGFibGUgYXQKLTxBIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvb3JnL2RvY3VtZW50cy9lcGwtdjEwLnBocCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9vcmcvZG9jdW1lbnRzL2VwbC12MTAucGhwPC9BPi4gCi1Gb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC48L1A+Ci0KLTxQPklmIHlvdSBkaWQgbm90IHJlY2VpdmUgdGhpcyBDb250ZW50IGRpcmVjdGx5IGZyb20gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiwgdGhlIAotQ29udGVudCBpcyBiZWluZyByZWRpc3RyaWJ1dGVkIGJ5IGFub3RoZXIgcGFydHkgKCJSZWRpc3RyaWJ1dG9yIikgYW5kIGRpZmZlcmVudCAKLXRlcm1zIGFuZCBjb25kaXRpb25zIG1heSBhcHBseSB0byB5b3VyIHVzZSBvZiBhbnkgb2JqZWN0IGNvZGUgaW4gdGhlIENvbnRlbnQuIAotQ2hlY2sgdGhlIFJlZGlzdHJpYnV0b3IncyBsaWNlbnNlIHRoYXQgd2FzIHByb3ZpZGVkIHdpdGggdGhlIENvbnRlbnQuIElmIG5vIHN1Y2ggCi1saWNlbnNlIGV4aXN0cywgY29udGFjdCB0aGUgUmVkaXN0cmlidXRvci4gVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQgYmVsb3csIHRoZSAKLXRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFUEwgc3RpbGwgYXBwbHkgdG8gYW55IHNvdXJjZSBjb2RlIGluIHRoZSBDb250ZW50IAotYW5kIHN1Y2ggc291cmNlIGNvZGUgbWF5IGJlIG9idGFpbmVkIGF0Ci08QSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnLyI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy88L0E+LjwvUD4KLQotPC9CT0RZPgotPC9IVE1MPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLnVpL2J1aWxkLnByb3BlcnRpZXMgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIudWkvYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMGQ1Njk4MS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIudWkvYnVpbGQucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDE3ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA3IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLXNvdXJjZS4uID0gc3JjLwotb3V0cHV0Li4gPSBiaW4vCi1iaW4uaW5jbHVkZXMgPSAuLFwKLSAgICAgICAgICAgICAgIE1FVEEtSU5GLyxcCi0gICAgICAgICAgICAgICBhYm91dC5odG1sLFwKLSAgICAgICAgICAgICAgIHBsdWdpbi5wcm9wZXJ0aWVzCi1qYXJzLmNvbXBpbGUub3JkZXIgPSAuCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIudWkvY29tcG9uZW50LnhtbCBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi51aS9jb21wb25lbnQueG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiZjY0OGFhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi51aS9jb21wb25lbnQueG1sCisrKyAvZGV2L251bGwKQEAgLTEgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz48Y29tcG9uZW50ICB4bWxucz0iaHR0cDovL2VjbGlwc2Uub3JnL3d0cC9yZWxlbmcvdG9vbHMvY29tcG9uZW50LW1vZGVsIiBuYW1lPSJvcmcuZWNsaXBzZS5qcHQuZGIudWkiPjxkZXNjcmlwdGlvbiB1cmw9IiI+PC9kZXNjcmlwdGlvbj48Y29tcG9uZW50LWRlcGVuZHMgdW5yZXN0cmljdGVkPSJ0cnVlIj48L2NvbXBvbmVudC1kZXBlbmRzPjxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLmpwdC5kYi51aSIgZnJhZ21lbnQ9ImZhbHNlIi8+PC9jb21wb25lbnQ+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLnVpL3BsdWdpbi5wcm9wZXJ0aWVzIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLnVpL3BsdWdpbi5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyYjBlNTgzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi51aS9wbHVnaW4ucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDI1ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLSMgVG8gY29kZSBkZXZlbG9wZXI6Ci0jICAgRG8gTk9UIGNoYW5nZSB0aGUgcHJvcGVydGllcyBiZXR3ZWVuIHRoaXMgbGluZSBhbmQgdGhlCi0jICAgIiUlJSBFTkQgT0YgVFJBTlNMQVRFRCBQUk9QRVJUSUVTICUlJSIgbGluZS4KLSMgICBNYWtlIGEgbmV3IHByb3BlcnR5IG5hbWUsIGFwcGVuZCB0byB0aGUgZW5kIG9mIHRoZSBmaWxlIGFuZCBjaGFuZ2UKLSMgICB0aGUgY29kZSB0byB1c2UgdGhlIG5ldyBwcm9wZXJ0eS4KLSMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLQotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotIyAlJSUgRU5EIE9GIFRSQU5TTEFURUQgUFJPUEVSVElFUyAlJSUKLSMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLQotcGx1Z2luTmFtZSA9IEphdmEgUGVyc2lzdGVuY2UgQVBJIFRvb2xzIC0gREIgVUkKLXByb3ZpZGVyTmFtZSA9IEVjbGlwc2Uub3JnCi0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3VpL2ludGVybmFsL0RUUFVpVG9vbHMuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3VpL2ludGVybmFsL0RUUFVpVG9vbHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOWEyYjgxZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi91aS9pbnRlcm5hbC9EVFBVaVRvb2xzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMDYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0qIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0qIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0qIAotKiBDb250cmlidXRvcnM6Ci0qICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYi51aS5pbnRlcm5hbDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuSUNvbm5lY3Rpb25Qcm9maWxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuSVByb2ZpbGVMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LlByb2ZpbGVNYW5hZ2VyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuZGIuZ2VuZXJpYy51aS53aXphcmQuTmV3SkRCQ0ZpbHRlcmVkQ1BXaXphcmQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uud2luZG93LldpbmRvdzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS53aXphcmQuV2l6YXJkRGlhbG9nOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkRpc3BsYXk7Ci0KLS8qKgotICogRFRQIFVJIHRvb2xzCi0gKi8KLXB1YmxpYyBjbGFzcyBEVFBVaVRvb2xzIHsKLQotCS8qKgotCSAqIExhdW5jaCB0aGUgRFRQIE5ldyBDb25uZWN0aW9uIFByb2ZpbGUgd2l6YXJkIHRvIGNyZWF0ZSBhIG5ldyBkYXRhYmFzZSBjb25uZWN0aW9uIHByb2ZpbGUuCi0JICogCi0JICogUmV0dXJucyB0aGUgbmFtZSBvZiB0aGUgYWRkZWQgcHJvZmlsZSwgb3IgbnVsbCBpZiB0aGUgd2l6YXJkIHdhcyBjYW5jZWxsZWQuCi0JICogVGhlIG5hbWUgY2FuIGJlIHVzZWQgdG8gYnVpbGQgYSBEYWxpIGNvbm5lY3Rpb24gcHJvZmlsZSBmcm9tCi0JICogSnB0RGJQbHVnaW4uZ2V0Q29ubmVjdGlvblByb2ZpbGVGYWN0b3J5KCkuYnVpbGRDb25uZWN0aW9uUHJvZmlsZShTdHJpbmcpLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGNyZWF0ZU5ld0Nvbm5lY3Rpb25Qcm9maWxlKCkgewotCQkvLyBGaWx0ZXIgZGF0YXNvdXJjZSBjYXRlZ29yeQotCQlOZXdKREJDRmlsdGVyZWRDUFdpemFyZCAgd2l6YXJkID0gbmV3IE5ld0pEQkNGaWx0ZXJlZENQV2l6YXJkKCk7Ci0JCVdpemFyZERpYWxvZyB3aXphcmREaWFsb2cgPSBuZXcgV2l6YXJkRGlhbG9nKERpc3BsYXkuZ2V0Q3VycmVudCgpLmdldEFjdGl2ZVNoZWxsKCksIHdpemFyZCk7Ci0JCXdpemFyZERpYWxvZy5zZXRCbG9ja09uT3Blbih0cnVlKTsKLQotCQlMb2NhbFByb2ZpbGVMaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBMb2NhbFByb2ZpbGVMaXN0ZW5lcigpOwotCQlQcm9maWxlTWFuYWdlci5nZXRJbnN0YW5jZSgpLmFkZFByb2ZpbGVMaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJU3RyaW5nIG5ld0NQTmFtZSA9IG51bGw7Ci0JCWlmICh3aXphcmREaWFsb2cub3BlbigpID09IFdpbmRvdy5PSykgewotCQkJLy8gYXNzdW1lIHRoZSBsYXN0IGFkZGVkIHByb2ZpbGUgaXMgdGhlIG9uZSB3ZSB3YW50Ci0JCQluZXdDUE5hbWUgPSBsaXN0ZW5lci5hZGRlZFByb2ZpbGUuZ2V0TmFtZSgpOwotCQl9Ci0JCVByb2ZpbGVNYW5hZ2VyLmdldEluc3RhbmNlKCkucmVtb3ZlUHJvZmlsZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQotCQlyZXR1cm4gbmV3Q1BOYW1lOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBEVFAgcHJvZmlsZSBsaXN0ZW5lciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBUaGlzIGxpc3RlbmVyIHNpbXBseSBob2xkcyBvbiB0byB0aGUgbW9zdCByZWNlbnRseSBhZGRlZCBjb25uZWN0aW9uCi0JICogcHJvZmlsZS4KLQkgKi8KLQlzdGF0aWMgY2xhc3MgTG9jYWxQcm9maWxlTGlzdGVuZXIgaW1wbGVtZW50cyBJUHJvZmlsZUxpc3RlbmVyIHsKLQkJSUNvbm5lY3Rpb25Qcm9maWxlIGFkZGVkUHJvZmlsZTsKLQkJCi0JCXB1YmxpYyB2b2lkIHByb2ZpbGVBZGRlZChJQ29ubmVjdGlvblByb2ZpbGUgcHJvZmlsZSkgewotCQkJdGhpcy5hZGRlZFByb2ZpbGUgPSBwcm9maWxlOwotCQl9Ci0JCi0JCXB1YmxpYyB2b2lkIHByb2ZpbGVDaGFuZ2VkKElDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlKSB7Ci0JCQkvLyBkbyBub3RoaW5nCi0JCX0KLQkKLQkJcHVibGljIHZvaWQgcHJvZmlsZURlbGV0ZWQoSUNvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUpIHsKLQkJCS8vIGRvIG5vdGhpbmcKLQkJfQotCX0KLQotCi0vLwkvLyAqKioqKioqKioqIHZpZXdlciBmaWx0ZXIgKioqKioqKioqKgotLy8KLS8vCXN0YXRpYyBjbGFzcyBMb2NhbFZpZXdlckZpbHRlciBleHRlbmRzIFZpZXdlckZpbHRlciB7Ci0vLwotLy8JCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBEQVRBQkFTRV9DQVRFR09SWV9JRCA9ICJvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LmRiLmNhdGVnb3J5IjsgLy8kTk9OLU5MUy0xJAotLy8KLS8vCQlMb2NhbFZpZXdlckZpbHRlcigpIHsKLS8vCQkJc3VwZXIoKTsKLS8vCQl9Ci0vLwotLy8JCUBPdmVycmlkZQotLy8JCXB1YmxpYyBib29sZWFuIHNlbGVjdChWaWV3ZXIgdmlld2VyLCBPYmplY3QgcGFyZW50RWxlbWVudCwgT2JqZWN0IGVsZW1lbnQpIHsKLS8vCQkJQ1BXaXphcmROb2RlIHdpemFyZE5vZGUgPSAoQ1BXaXphcmROb2RlKSBlbGVtZW50OwotLy8JCQlJUHJvZmlsZVdpemFyZFByb3ZpZGVyIHdpemFyZFByb3ZpZGVyID0gd2l6YXJkTm9kZS5nZXRQcm92aWRlcigpOwotLy8JCQlpZiAod2l6YXJkUHJvdmlkZXIgaW5zdGFuY2VvZiBJV2l6YXJkQ2F0ZWdvcnlQcm92aWRlcikgewotLy8JCQkJcmV0dXJuIGZhbHNlOwotLy8JCQl9Ci0vLwkJCUlDYXRlZ29yeSBjYXRlZ29yeSA9IENvbm5lY3Rpb25Qcm9maWxlTWFuYWdlci5nZXRJbnN0YW5jZSgpLmdldFByb3ZpZGVyKAotLy8JCQkJCQkJKChQcm9maWxlV2l6YXJkUHJvdmlkZXIpIHdpemFyZFByb3ZpZGVyKS5nZXRQcm9maWxlKCkpLmdldENhdGVnb3J5KCk7Ci0vLwkJCQotLy8JCQkvLyBPbmx5IGRpc3BsYXkgd2l6YXJkcyBiZWxvbmcgdG8gZGF0YWJhc2UgY2F0ZWdvcnkKLS8vCQkJd2hpbGUgKGNhdGVnb3J5ICE9IG51bGwpIHsKLS8vCQkJCWlmIChjYXRlZ29yeS5nZXRJZCgpLmVxdWFscyhEQVRBQkFTRV9DQVRFR09SWV9JRCkpIHsKLS8vCQkJCQlyZXR1cm4gdHJ1ZTsKLS8vCQkJCX0KLS8vCQkJCWNhdGVnb3J5ID0gY2F0ZWdvcnkuZ2V0UGFyZW50KCk7Ci0vLwkJCX0KLS8vCQkJcmV0dXJuIGZhbHNlOwotLy8JCX0KLS8vCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLy5jbGFzc3BhdGggYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvLmNsYXNzcGF0aApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzA0ZTg2MS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvLmNsYXNzcGF0aAorKysgL2Rldi9udWxsCkBAIC0xLDcgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxjbGFzc3BhdGg+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9InNyYyIgcGF0aD0ic3JjIi8+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9ImNvbiIgcGF0aD0ib3JnLmVjbGlwc2UuamR0LmxhdW5jaGluZy5KUkVfQ09OVEFJTkVSL29yZy5lY2xpcHNlLmpkdC5pbnRlcm5hbC5kZWJ1Zy51aS5sYXVuY2hlci5TdGFuZGFyZFZNVHlwZS9KMlNFLTEuNSIvPgotCTxjbGFzc3BhdGhlbnRyeSBraW5kPSJjb24iIHBhdGg9Im9yZy5lY2xpcHNlLnBkZS5jb3JlLnJlcXVpcmVkUGx1Z2lucyIvPgotCTxjbGFzc3BhdGhlbnRyeSBraW5kPSJvdXRwdXQiIHBhdGg9ImJpbiIvPgotPC9jbGFzc3BhdGg+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvLmN2c2lnbm9yZSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi8uY3ZzaWdub3JlCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhMTk2ZGQ3Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi8uY3ZzaWdub3JlCisrKyAvZGV2L251bGwKQEAgLTEsNiArMCwwIEBACi1iaW4KLUBkb3QKLXRlbXAuZm9sZGVyCi1idWlsZC54bWwKLWphdmFDb21waWxlci4uLmFyZ3MKLWphdmFDb21waWxlci4uLmFyZ3MuKgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi8ucHJvamVjdCBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi8ucHJvamVjdApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNTY3NWE0OC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvLnByb2plY3QKKysrIC9kZXYvbnVsbApAQCAtMSwyOCArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPHByb2plY3REZXNjcmlwdGlvbj4KLQk8bmFtZT5vcmcuZWNsaXBzZS5qcHQuZGI8L25hbWU+Ci0JPGNvbW1lbnQ+PC9jb21tZW50PgotCTxwcm9qZWN0cz4KLQk8L3Byb2plY3RzPgotCTxidWlsZFNwZWM+Ci0JCTxidWlsZENvbW1hbmQ+Ci0JCQk8bmFtZT5vcmcuZWNsaXBzZS5qZHQuY29yZS5qYXZhYnVpbGRlcjwvbmFtZT4KLQkJCTxhcmd1bWVudHM+Ci0JCQk8L2FyZ3VtZW50cz4KLQkJPC9idWlsZENvbW1hbmQ+Ci0JCTxidWlsZENvbW1hbmQ+Ci0JCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuTWFuaWZlc3RCdWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5TY2hlbWFCdWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQk8L2J1aWxkU3BlYz4KLQk8bmF0dXJlcz4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5wZGUuUGx1Z2luTmF0dXJlPC9uYXR1cmU+Ci0JCTxuYXR1cmU+b3JnLmVjbGlwc2UuamR0LmNvcmUuamF2YW5hdHVyZTwvbmF0dXJlPgotCTwvbmF0dXJlcz4KLTwvcHJvamVjdERlc2NyaXB0aW9uPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDg0ZWJiNWMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcworKysgL2Rldi9udWxsCkBAIC0xLDMgKzAsMCBAQAotI1R1ZSBKYW4gMTUgMTE6MTE6MDIgRVNUIDIwMDgKLWVjbGlwc2UucHJlZmVyZW5jZXMudmVyc2lvbj0xCi1lbmNvZGluZy88cHJvamVjdD49SVNPLTg4NTktMQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5qZHQuY29yZS5wcmVmcyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuamR0LmNvcmUucHJlZnMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDkyOWQ1NDUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5qZHQuY29yZS5wcmVmcworKysgL2Rldi9udWxsCkBAIC0xLDcgKzAsMCBAQAotI1N1biBNYXkgMjcgMTQ6NTk6MTggRURUIDIwMDcKLWVjbGlwc2UucHJlZmVyZW5jZXMudmVyc2lvbj0xCi1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5jb2RlZ2VuLnRhcmdldFBsYXRmb3JtPTEuNQotb3JnLmVjbGlwc2UuamR0LmNvcmUuY29tcGlsZXIuY29tcGxpYW5jZT0xLjUKLW9yZy5lY2xpcHNlLmpkdC5jb3JlLmNvbXBpbGVyLnByb2JsZW0uYXNzZXJ0SWRlbnRpZmllcj1lcnJvcgotb3JnLmVjbGlwc2UuamR0LmNvcmUuY29tcGlsZXIucHJvYmxlbS5lbnVtSWRlbnRpZmllcj1lcnJvcgotb3JnLmVjbGlwc2UuamR0LmNvcmUuY29tcGlsZXIuc291cmNlPTEuNQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL01FVEEtSU5GL01BTklGRVNULk1GIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL01FVEEtSU5GL01BTklGRVNULk1GCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyZTU0MGU2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9NRVRBLUlORi9NQU5JRkVTVC5NRgorKysgL2Rldi9udWxsCkBAIC0xLDE5ICswLDAgQEAKLU1hbmlmZXN0LVZlcnNpb246IDEuMAotQnVuZGxlLU1hbmlmZXN0VmVyc2lvbjogMgotQnVuZGxlLU5hbWU6ICVwbHVnaW5OYW1lCi1CdW5kbGUtVmVuZG9yOiAlcHJvdmlkZXJOYW1lCi1CdW5kbGUtU3ltYm9saWNOYW1lOiBvcmcuZWNsaXBzZS5qcHQuZGIKLUJ1bmRsZS1WZXJzaW9uOiAxLjIuMTAwLnF1YWxpZmllcgotQnVuZGxlLUFjdGl2YXRvcjogb3JnLmVjbGlwc2UuanB0LmRiLkpwdERiUGx1Z2luCi1CdW5kbGUtQWN0aXZhdGlvblBvbGljeTogbGF6eQotQnVuZGxlLUNsYXNzUGF0aDogLgotQnVuZGxlLUxvY2FsaXphdGlvbjogcGx1Z2luCi1CdW5kbGUtUmVxdWlyZWRFeGVjdXRpb25FbnZpcm9ubWVudDogSjJTRS0xLjUKLVJlcXVpcmUtQnVuZGxlOiBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWU7YnVuZGxlLXZlcnNpb249IlszLjQuMCw0LjAuMCkiLAotIG9yZy5lY2xpcHNlLmRhdGF0b29scy5lbmFibGVtZW50LmpkdC5jbGFzc3BhdGg7YnVuZGxlLXZlcnNpb249IlsxLjAuMSwyLjAuMCkiLAotIG9yZy5lY2xpcHNlLmRhdGF0b29scy5zcWx0b29scy5lZGl0b3IuY29yZTtidW5kbGUtdmVyc2lvbj0iWzEuMC4wLDIuMC4wKSIsCi0gb3JnLmVjbGlwc2UuamR0LmNvcmU7YnVuZGxlLXZlcnNpb249IlszLjQuMCw0LjAuMCkiLAotIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5O2J1bmRsZS12ZXJzaW9uPSJbMS4yLjAsMi4wLjApIgotRXhwb3J0LVBhY2thZ2U6IG9yZy5lY2xpcHNlLmpwdC5kYiwKLSBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWw7eC1pbnRlcm5hbDo9dHJ1ZSwKLSBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWwudmVuZG9yO3gtaW50ZXJuYWw6PXRydWUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9hYm91dC5odG1sIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL2Fib3V0Lmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJlNTM0YmEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL2Fib3V0Lmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSwzNCArMCwwIEBACi08IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wLy9FTiI+Ci08SFRNTD4KLQotPGhlYWQ+Ci08dGl0bGU+QWJvdXQ8L3RpdGxlPgotPG1ldGEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiPgotPC9oZWFkPgotCi08Qk9EWSBsYW5nPSJFTi1VUyI+Ci0KLTxIMz5BYm91dCBUaGlzIENvbnRlbnQ8L0gzPgotCi08UD5NYXkgMDIsIDIwMDg8L1A+Ci0KLTxIMz5MaWNlbnNlPC9IMz4KLQotPFA+VGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYWtlcyBhdmFpbGFibGUgYWxsIGNvbnRlbnQgaW4gdGhpcyBwbHVnLWluIAotKCJDb250ZW50IikuIFVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkIGJlbG93LCB0aGUgQ29udGVudCBpcyBwcm92aWRlZCB0byB5b3UgCi11bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgCi0oIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBhdmFpbGFibGUgYXQKLTxBIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvb3JnL2RvY3VtZW50cy9lcGwtdjEwLnBocCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9vcmcvZG9jdW1lbnRzL2VwbC12MTAucGhwPC9BPi4gCi1Gb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC48L1A+Ci0KLTxQPklmIHlvdSBkaWQgbm90IHJlY2VpdmUgdGhpcyBDb250ZW50IGRpcmVjdGx5IGZyb20gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiwgdGhlIAotQ29udGVudCBpcyBiZWluZyByZWRpc3RyaWJ1dGVkIGJ5IGFub3RoZXIgcGFydHkgKCJSZWRpc3RyaWJ1dG9yIikgYW5kIGRpZmZlcmVudCAKLXRlcm1zIGFuZCBjb25kaXRpb25zIG1heSBhcHBseSB0byB5b3VyIHVzZSBvZiBhbnkgb2JqZWN0IGNvZGUgaW4gdGhlIENvbnRlbnQuIAotQ2hlY2sgdGhlIFJlZGlzdHJpYnV0b3IncyBsaWNlbnNlIHRoYXQgd2FzIHByb3ZpZGVkIHdpdGggdGhlIENvbnRlbnQuIElmIG5vIHN1Y2ggCi1saWNlbnNlIGV4aXN0cywgY29udGFjdCB0aGUgUmVkaXN0cmlidXRvci4gVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQgYmVsb3csIHRoZSAKLXRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFUEwgc3RpbGwgYXBwbHkgdG8gYW55IHNvdXJjZSBjb2RlIGluIHRoZSBDb250ZW50IAotYW5kIHN1Y2ggc291cmNlIGNvZGUgbWF5IGJlIG9idGFpbmVkIGF0Ci08QSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnLyI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy88L0E+LjwvUD4KLQotPC9CT0RZPgotPC9IVE1MPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL2J1aWxkLnByb3BlcnRpZXMgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTc0ZWFkYS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvYnVpbGQucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDE5ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA3IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLWphdmFjU291cmNlPTEuNQotamF2YWNUYXJnZXQ9MS41Ci1zb3VyY2UuLiA9IHNyYy8KLW91dHB1dC4uID0gYmluLwotYmluLmluY2x1ZGVzID0gLixcCi0gICAgICAgICAgICAgICBNRVRBLUlORi8sXAotICAgICAgICAgICAgICAgYWJvdXQuaHRtbCxcCi0gICAgICAgICAgICAgICBwbHVnaW4ucHJvcGVydGllcwotamFycy5jb21waWxlLm9yZGVyID0gLgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL2NvbXBvbmVudC54bWwgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvY29tcG9uZW50LnhtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjQ0YzM5Ni4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvY29tcG9uZW50LnhtbAorKysgL2Rldi9udWxsCkBAIC0xICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+PGNvbXBvbmVudCAgeG1sbnM9Imh0dHA6Ly9lY2xpcHNlLm9yZy93dHAvcmVsZW5nL3Rvb2xzL2NvbXBvbmVudC1tb2RlbCIgbmFtZT0ib3JnLmVjbGlwc2UuanB0LmRiIj48ZGVzY3JpcHRpb24gdXJsPSIiPjwvZGVzY3JpcHRpb24+PGNvbXBvbmVudC1kZXBlbmRzIHVucmVzdHJpY3RlZD0idHJ1ZSI+PC9jb21wb25lbnQtZGVwZW5kcz48cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5qcHQuZGIiIGZyYWdtZW50PSJmYWxzZSIvPjwvY29tcG9uZW50PgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9wbHVnaW4ucHJvcGVydGllcyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9wbHVnaW4ucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTg3YTJkMy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvcGx1Z2luLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwyNSArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0jIFRvIGNvZGUgZGV2ZWxvcGVyOgotIyAgIERvIE5PVCBjaGFuZ2UgdGhlIHByb3BlcnRpZXMgYmV0d2VlbiB0aGlzIGxpbmUgYW5kIHRoZQotIyAgICIlJSUgRU5EIE9GIFRSQU5TTEFURUQgUFJPUEVSVElFUyAlJSUiIGxpbmUuCi0jICAgTWFrZSBhIG5ldyBwcm9wZXJ0eSBuYW1lLCBhcHBlbmQgdG8gdGhlIGVuZCBvZiB0aGUgZmlsZSBhbmQgY2hhbmdlCi0jICAgdGhlIGNvZGUgdG8gdXNlIHRoZSBuZXcgcHJvcGVydHkuCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0KLSMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLSMgJSUlIEVORCBPRiBUUkFOU0xBVEVEIFBST1BFUlRJRVMgJSUlCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0KLXBsdWdpbk5hbWUgPSBKYXZhIFBlcnNpc3RlbmNlIEFQSSBUb29scyAtIERCCi1wcm92aWRlck5hbWUgPSBFY2xpcHNlLm9yZwotCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9DYXRhbG9nLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9DYXRhbG9nLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDVjNmRhNzAuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvQ2F0YWxvZy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGI7Ci0KLS8qKgotICogRGF0YWJhc2UgY2F0YWxvZwotICogCi0gKiBQcm92aXNpb25hbCBBUEk6IFRoaXMgaW50ZXJmYWNlIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbAotICogdW5kZXIgZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZwotICogc3RhYmlsaXR5LiBJdCBpcyBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20KLSAqIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgdGhpcyBBUEkKLSAqIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KLSAqIAotICogVGhpcyBpbnRlcmZhY2UgaXMgbm90IGludGVuZGVkIHRvIGJlIGltcGxlbWVudGVkIGJ5IGNsaWVudHMuCi0gKi8KLXB1YmxpYyBpbnRlcmZhY2UgQ2F0YWxvZwotCWV4dGVuZHMgU2NoZW1hQ29udGFpbmVyLCBDb21wYXJhYmxlPENhdGFsb2c+Ci17Ci0JLy8gbm90aGluZyB5ZXQKLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL0NvbHVtbi5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvQ29sdW1uLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGI1MDJmNjEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvQ29sdW1uLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMjMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGI7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5KYXZhVHlwZTsKLQotLyoqCi0gKiBEYXRhYmFzZSBjb2x1bW4KLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKiAKLSAqIFRoaXMgaW50ZXJmYWNlIGlzIG5vdCBpbnRlbmRlZCB0byBiZSBpbXBsZW1lbnRlZCBieSBjbGllbnRzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIENvbHVtbgotCWV4dGVuZHMgRGF0YWJhc2VPYmplY3QsIENvbXBhcmFibGU8Q29sdW1uPgotewotCS8qKgotCSAqIFJldHVybiB0aGUgY29sdW1uJ3MgdGFibGUuCi0JICovCi0JVGFibGUgZ2V0VGFibGUoKTsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJhaW50cyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgY29sdW1uIGlzIHBhcnQgb2YgaXQncyB0YWJsZSdzIHByaW1hcnkga2V5LgotCSAqLwotCWJvb2xlYW4gaXNQYXJ0T2ZQcmltYXJ5S2V5KCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgY29sdW1uIGlzIHBhcnQgb2Ygb25lIG9mIGl0J3MgdGFibGUncyBmb3JlaWduIGtleXMuCi0JICovCi0JYm9vbGVhbiBpc1BhcnRPZkZvcmVpZ25LZXkoKTsKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjb2x1bW4gaXMgcGFydCBvZiBhIHVuaXF1ZSBjb25zdHJhaW50IGRlZmluZWQgZm9yIGl0cwotCSAqIHRhYmxlLgotCSAqLwotCWJvb2xlYW4gaXNQYXJ0T2ZVbmlxdWVDb25zdHJhaW50KCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgY29sdW1uIGlzIG51bGxhYmxlLgotCSAqLwotCWJvb2xlYW4gaXNOdWxsYWJsZSgpOwotCi0KLQkvLyAqKioqKioqKioqIGRhdGEgdHlwZSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG5hbWUgb2YgdGhlIGNvbHVtbidzIGRhdGF0eXBlLgotCSAqLwotCVN0cmluZyBnZXREYXRhVHlwZU5hbWUoKTsKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjb2x1bW4ncyB0eXBlIGlzIG51bWVyaWMuCi0JICovCi0JYm9vbGVhbiBpc051bWVyaWMoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgY29sdW1uJ3MgcHJlY2lzaW9uIGlmIGl0IGlzIGEgTnVtZXJpY2FsRGF0YVR5cGU7Ci0JICogb3RoZXJ3aXNlLCByZXR1cm4gLTEuCi0JICovCi0JcHVibGljIGludCBnZXRQcmVjaXNpb24oKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgY29sdW1uJ3Mgc2NhbGUgaWYgaXQgaXMgYW4gRXhhY3ROdW1lcmljRGF0YVR5cGU7Ci0JICogb3RoZXJ3aXNlLCByZXR1cm4gLTEuCi0JICovCi0JcHVibGljIGludCBnZXRTY2FsZSgpOwotCi0JLyoqCi0JICogSWYgdGhlIGNvbHVtbiBpcyBhIENoYXJhY3RlclN0cmluZ0RhdGFUeXBlLCByZXR1cm4gaXRzIGxlbmd0aDsKLQkgKiBvdGhlcndpc2UsIHJldHVybiAtMS4KLQkgKi8KLQlwdWJsaWMgaW50IGdldExlbmd0aCgpOwotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGNvbHVtbidzIGRhdGF0eXBlIGlzIGEgTE9CIHR5cGUKLQkgKiAoaS5lLiBCTE9CLCBDTE9CLCBvciBOQ0xPQikuCi0JICovCi0JYm9vbGVhbiBpc0xPQigpOwotCi0KLQkvLyAqKioqKioqKioqIEphdmEgdHlwZSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gYSBKYXZhIHR5cGUgZGVjbGFyYXRpb24gdGhhdCBpcyByZWFzb25hYmx5Ci0JICogc2ltaWxhciB0byB0aGUgY29sdW1uJ3MgZGF0YSB0eXBlLgotCSAqLwotCVN0cmluZyBnZXRKYXZhVHlwZURlY2xhcmF0aW9uKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBKYXZhIHR5cGUgdGhhdCBpcyByZWFzb25hYmx5Ci0JICogc2ltaWxhciB0byB0aGUgY29sdW1uJ3MgZGF0YSB0eXBlLgotCSAqLwotCUphdmFUeXBlIGdldEphdmFUeXBlKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBKYXZhIHR5cGUgZGVjbGFyYXRpb24gdGhhdCBpcyByZWFzb25hYmx5Ci0JICogc2ltaWxhciB0byB0aGUgY29sdW1uJ3MgZGF0YSB0eXBlIGFuZCBzdWl0YWJsZSBmb3IgdXNlIGFzIGEKLQkgKiBwcmltYXJ5IGtleSBmaWVsZC4KLQkgKi8KLQlTdHJpbmcgZ2V0UHJpbWFyeUtleUphdmFUeXBlRGVjbGFyYXRpb24oKTsKLQotCS8qKgotCSAqIFJldHVybiBhIEphdmEgdHlwZSB0aGF0IGlzIHJlYXNvbmFibHkKLQkgKiBzaW1pbGFyIHRvIHRoZSBjb2x1bW4ncyBkYXRhIHR5cGUgYW5kIHN1aXRhYmxlIGZvciB1c2UgYXMgYQotCSAqIHByaW1hcnkga2V5IGZpZWxkLgotCSAqLwotCUphdmFUeXBlIGdldFByaW1hcnlLZXlKYXZhVHlwZSgpOwotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9Db25uZWN0aW9uQWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvQ29ubmVjdGlvbkFkYXB0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTcyODQ4OS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9Db25uZWN0aW9uQWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGI7Ci0KLQotLyoqCi0gKiBBbiBlbXB0eSBpbXBsZW1lbnRhdGlvbiBvZiBDb25uZWN0aW9uTGlzdGVuZXIuCi0gKiAKLSAqIFByb3Zpc2lvbmFsIEFQSTogVGhpcyBjbGFzcyBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKi8KLXB1YmxpYyBjbGFzcyBDb25uZWN0aW9uQWRhcHRlciBpbXBsZW1lbnRzIENvbm5lY3Rpb25MaXN0ZW5lciB7Ci0KLQlwdWJsaWMgdm9pZCBhYm91dFRvQ2xvc2UoQ29ubmVjdGlvblByb2ZpbGUgcHJvZmlsZSkgewotCQkvLyBkbyBub3RoaW5nCi0JfQotCi0JcHVibGljIHZvaWQgY2xvc2VkKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUpIHsKLQkJLy8gZG8gbm90aGluZwotCX0KLQotCXB1YmxpYyB2b2lkIGRhdGFiYXNlQ2hhbmdlZChDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlLCBEYXRhYmFzZSBkYXRhYmFzZSkgewotCQkvLyBkbyBub3RoaW5nCi0JfQotCi0JcHVibGljIHZvaWQgbW9kaWZpZWQoQ29ubmVjdGlvblByb2ZpbGUgcHJvZmlsZSkgewotCQkvLyBkbyBub3RoaW5nCi0JfQotCi0JcHVibGljIGJvb2xlYW4gb2tUb0Nsb3NlKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUpIHsKLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JcHVibGljIHZvaWQgb3BlbmVkKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUpIHsKLQkJLy8gZG8gbm90aGluZwotCX0KLQotCXB1YmxpYyB2b2lkIGNhdGFsb2dDaGFuZ2VkKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUsIENhdGFsb2cgY2F0YWxvZykgewotCQkvLyBkbyBub3RoaW5nCi0JfQotCi0JcHVibGljIHZvaWQgc2NoZW1hQ2hhbmdlZChDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlLCBTY2hlbWEgc2NoZW1hKSB7Ci0JCS8vIGRvIG5vdGhpbmcKLQl9Ci0KLQlwdWJsaWMgdm9pZCBzZXF1ZW5jZUNoYW5nZWQoQ29ubmVjdGlvblByb2ZpbGUgcHJvZmlsZSwgU2VxdWVuY2Ugc2VxdWVuY2UpIHsKLQkJLy8gZG8gbm90aGluZwotCX0KLQotCXB1YmxpYyB2b2lkIHRhYmxlQ2hhbmdlZChDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlLCBUYWJsZSB0YWJsZSkgewotCQkvLyBkbyBub3RoaW5nCi0JfQotCi0JcHVibGljIHZvaWQgY29sdW1uQ2hhbmdlZChDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlLCBDb2x1bW4gY29sdW1uKSB7Ci0JCS8vIGRvIG5vdGhpbmcKLQl9Ci0KLQlwdWJsaWMgdm9pZCBmb3JlaWduS2V5Q2hhbmdlZChDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlLCBGb3JlaWduS2V5IGZvcmVpZ25LZXkpIHsKLQkJLy8gZG8gbm90aGluZwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvQ29ubmVjdGlvbkxpc3RlbmVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9Db25uZWN0aW9uTGlzdGVuZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNGYzYjA5Yi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9Db25uZWN0aW9uTGlzdGVuZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiOwotCi1pbXBvcnQgamF2YS51dGlsLkV2ZW50TGlzdGVuZXI7Ci0KLQotLyoqCi0gKiBBIENvbm5lY3Rpb25MaXN0ZW5lciBpcyBub3RpZmllZCBvZiBhbnkgY2hhbmdlcyB0byBhIGNvbm5lY3Rpb24uCi0gKiAKLSAqIEBzZWUgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5JTWFuYWdlZENvbm5lY3Rpb25MaXN0ZW5lcgotICogCi0gKiBQcm92aXNpb25hbCBBUEk6IFRoaXMgaW50ZXJmYWNlIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbAotICogdW5kZXIgZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZwotICogc3RhYmlsaXR5LiBJdCBpcyBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20KLSAqIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgdGhpcyBBUEkKLSAqIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KLSAqLwotcHVibGljIGludGVyZmFjZSBDb25uZWN0aW9uTGlzdGVuZXIgZXh0ZW5kcyBFdmVudExpc3RlbmVyIHsKLQotCXB1YmxpYyB2b2lkIG9wZW5lZChDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlKTsKLQlwdWJsaWMgdm9pZCBtb2RpZmllZChDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlKTsKLQlwdWJsaWMgYm9vbGVhbiBva1RvQ2xvc2UoQ29ubmVjdGlvblByb2ZpbGUgcHJvZmlsZSk7Ci0JcHVibGljIHZvaWQgYWJvdXRUb0Nsb3NlKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUpOwotCXB1YmxpYyB2b2lkIGNsb3NlZChDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlKTsKLQotCXB1YmxpYyB2b2lkIGRhdGFiYXNlQ2hhbmdlZChDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlLCBEYXRhYmFzZSBkYXRhYmFzZSk7Ci0JcHVibGljIHZvaWQgY2F0YWxvZ0NoYW5nZWQoQ29ubmVjdGlvblByb2ZpbGUgcHJvZmlsZSwgQ2F0YWxvZyBjYXRhbG9nKTsKLQlwdWJsaWMgdm9pZCBzY2hlbWFDaGFuZ2VkKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUsIFNjaGVtYSBzY2hlbWEpOwotCXB1YmxpYyB2b2lkIHNlcXVlbmNlQ2hhbmdlZChDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlLCBTZXF1ZW5jZSBzZXF1ZW5jZSk7Ci0JcHVibGljIHZvaWQgdGFibGVDaGFuZ2VkKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUsIFRhYmxlIHRhYmxlKTsKLQlwdWJsaWMgdm9pZCBjb2x1bW5DaGFuZ2VkKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUsIENvbHVtbiBjb2x1bW4pOwotCXB1YmxpYyB2b2lkIGZvcmVpZ25LZXlDaGFuZ2VkKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUsIEZvcmVpZ25LZXkgZm9yZWlnbktleSk7Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL0Nvbm5lY3Rpb25Qcm9maWxlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9Db25uZWN0aW9uUHJvZmlsZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjMTVkYjdhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL0Nvbm5lY3Rpb25Qcm9maWxlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyMDYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGI7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuSVN0YXR1czsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LmRyaXZlcnMuamRiYy5JSkRCQ0RyaXZlckRlZmluaXRpb25Db25zdGFudHM7Ci0KLS8qKgotICogRGF0YWJhc2UgY29ubmVjdGlvbiBwcm9maWxlCi0gKiAKLSAqIFByb3Zpc2lvbmFsIEFQSTogVGhpcyBpbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsCi0gKiB1bmRlciBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nCi0gKiBzdGFiaWxpdHkuIEl0IGlzIGF2YWlsYWJsZSBhdCB0aGlzIGVhcmx5IHN0YWdlIHRvIHNvbGljaXQgZmVlZGJhY2sgZnJvbQotICogcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyB0aGlzIEFQSQotICogd2lsbCBhbG1vc3QgY2VydGFpbmx5IGJlIGJyb2tlbiAocmVwZWF0ZWRseSkgYXMgdGhlIEFQSSBldm9sdmVzLgotICogCi0gKiBUaGlzIGludGVyZmFjZSBpcyBub3QgaW50ZW5kZWQgdG8gYmUgaW1wbGVtZW50ZWQgYnkgY2xpZW50cy4KLSAqLwotcHVibGljIGludGVyZmFjZSBDb25uZWN0aW9uUHJvZmlsZQotCWV4dGVuZHMgRGF0YWJhc2VPYmplY3QsIENvbXBhcmFibGU8Q29ubmVjdGlvblByb2ZpbGU+Ci17Ci0KLQkvLyAqKioqKioqKioqIHByb3BlcnRpZXMgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjb25uZWN0aW9uIHByb2ZpbGUncyBkYXRhYmFzZS4KLQkgKiBSZXR1cm4gbnVsbCBpZiB0aGUgY29ubmVjdGlvbiBwcm9maWxlIGlzIGluYWN0aXZlLgotCSAqLwotCURhdGFiYXNlIGdldERhdGFiYXNlKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gSUQgb2YgdGhlIHByb3ZpZGVyIG1hbmFnaW5nIHRoZSBEVFAgcHJvZmlsZS4KLQkgKi8KLQlTdHJpbmcgZ2V0UHJvdmlkZXJJRCgpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjb25uZWN0aW9uIHByb2ZpbGUncyBzdGF0aWMgSUQuCi0JICovCi0JU3RyaW5nIGdldEluc3RhbmNlSUQoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgZGVmYXVsdCBkYXRhYmFzZSBuYW1lLgotCSAqLwotCVN0cmluZyBnZXREYXRhYmFzZU5hbWUoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgZGF0YWJhc2UgcHJvZHVjdCBuYW1lLgotCSAqLwotCVN0cmluZyBnZXREYXRhYmFzZVByb2R1Y3QoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgZGF0YWJhc2UgdmVuZG9yLgotCSAqLwotCVN0cmluZyBnZXREYXRhYmFzZVZlbmRvcigpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBkYXRhYmFzZSB2ZXJzaW9uLgotCSAqLwotCVN0cmluZyBnZXREYXRhYmFzZVZlcnNpb24oKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgZHJpdmVyIGNsYXNzIG5hbWUuCi0JICovCi0JU3RyaW5nIGdldERyaXZlckNsYXNzTmFtZSgpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBkZWZhdWx0IGNvbm5lY3Rpb24gVVJMLgotCSAqLwotCVN0cmluZyBnZXRVUkwoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgZGVmYXVsdCB1c2VyIG5hbWUuCi0JICovCi0JU3RyaW5nIGdldFVzZXJOYW1lKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGRlZmF1bHQgdXNlciBwYXNzd29yZC4KLQkgKi8KLQlTdHJpbmcgZ2V0VXNlclBhc3N3b3JkKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIElEIG9mIHRoZSBhc3NvY2lhdGVkIERyaXZlciBkZWZpbml0aW9uLgotCSAqLwotCVN0cmluZyBnZXREcml2ZXJEZWZpbml0aW9uSUQoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgamFyIGxpc3QgZm9yIHRoZSBhc3NvY2lhdGVkIERyaXZlciBhcyBhIAotCSAqIGNvbW1hLWRlbGltaXRlZCBzdHJpbmcuCi0JICovCi0JU3RyaW5nIGdldERyaXZlckphckxpc3QoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgbmFtZSBvZiB0aGUgYXNzb2NpYXRlZCBEcml2ZXIgZGVmaW5pdGlvbi4KLQkgKi8KLQlTdHJpbmcgZ2V0RHJpdmVyTmFtZSgpOwotCi0JLy8gKioqKioqKioqKiBjb25uZWN0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBwcm9maWxlIGlzIGVpdGhlciBjb25uZWN0ZWQgdG8gYSBsaXZlIGRhdGFiYXNlCi0JICogc2Vzc2lvbiBvciB3b3JraW5nIG9mZi1saW5lIChpLmUuIGl0IGhhcyBhY2Nlc3MgdG8gbWV0YS1kYXRhKS4KLQkgKiBAc2VlIGlzQ29ubmVjdGVkKCkKLQkgKiBAc2VlIGlzV29ya2luZ09mZmxpbmUoKQotCSAqLwotCWJvb2xlYW4gaXNBY3RpdmUoKTsKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBwcm9maWxlIGlzIG5laXRoZXIgY29ubmVjdGVkIHRvIGEgbGl2ZSBkYXRhYmFzZQotCSAqIHNlc3Npb24gbm9yIHdvcmtpbmcgb2ZmLWxpbmUgKGkuZS4gaXQgaGFzIGFjY2VzcyB0byBtZXRhLWRhdGEpLgotCSAqIEBzZWUgaXNBY3RpdmUoKQotCSAqLwotCWJvb2xlYW4gaXNJbmFjdGl2ZSgpOwotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHByb2ZpbGUgaXMgY29ubmVjdGVkIHRvIGEgbGl2ZSBkYXRhYmFzZSBzZXNzaW9uCi0JICogKGkuZS4gdGhlIG1ldGEtZGF0YSBjb21lcyBmcm9tIHRoZSBkYXRhYmFzZSksIGFzIG9wcG9zZWQgdG8gd29ya2luZwotCSAqIG9mZi1saW5lLgotCSAqIEBzZWUgI2lzQWN0aXZlKCkKLQkgKi8KLQlib29sZWFuIGlzQ29ubmVjdGVkKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgcHJvZmlsZSBpcyBub3QgY29ubmVjdGVkIHRvIGEgbGl2ZSBkYXRhYmFzZSBzZXNzaW9uCi0JICogKGkuZS4gdGhlIG1ldGEtZGF0YSBjb21lcyBmcm9tIHRoZSBkYXRhYmFzZSksIGFzIG9wcG9zZWQgdG8gd29ya2luZwotCSAqIG9mZi1saW5lLgotCSAqIEBzZWUgI2lzQ29ubmVjdGVkKCkKLQkgKi8KLQlib29sZWFuIGlzRGlzY29ubmVjdGVkKCk7Ci0KLQkvKioKLQkgKiBDb25uZWN0IHRvIHRoZSBkYXRhYmFzZS4KLQkgKiBAc2VlICNkaXNjb25uZWN0KCkKLQkgKi8KLQl2b2lkIGNvbm5lY3QoKTsKLQotCS8qKgotCSAqIERpc2Nvbm5lY3QgZnJvbSB0aGUgZGF0YWJhc2UuCi0JICogQHNlZSAjY29ubmVjdCgpCi0JICovCi0Jdm9pZCBkaXNjb25uZWN0KCk7Ci0KLQotCS8vICoqKioqKioqKiogb2ZmLWxpbmUgc3VwcG9ydCAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgcHJvZmlsZSBpcyB3b3JraW5nIG9mZi1saW5lIChpLmUuIHRoZSBtZXRhLWRhdGEKLQkgKiBjb21lcyBmcm9tIGEgbG9jYWwgY2FjaGUpLCBhcyBvcHBvc2VkIHRvIGNvbm5lY3RlZCB0byBhIGxpdmUKLQkgKiBkYXRhYmFzZSBzZXNzaW9uLgotCSAqIEBzZWUgI2lzQWN0aXZlKCkKLQkgKi8KLQlib29sZWFuIGlzV29ya2luZ09mZmxpbmUoKTsKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjb25uZWN0aW9uIGZhY3RvcmllcyBhc3NvY2lhdGVkIHdpdGggdGhlCi0JICogY29ubmVjdGlvbiBwcm9maWxlJ3MgcHJvdmlkZXIgc3VwcG9ydCB3b3JraW5nIG9mZmxpbmUuCi0JICovCi0JYm9vbGVhbiBzdXBwb3J0c1dvcmtPZmZsaW5lTW9kZSgpOwotCi0JLyoqCi0JICogU2F2ZSB0aGUgc3RhdGUgb2YgdGhlIGNvbm5lY3Rpb24gcHJvZmlsZSBmb3Igd29ya2luZyBpbiBhbiBvZmZsaW5lIG1vZGUuCi0JICogSWYgdGhlIGNvbm5lY3Rpb24gcHJvZmlsZSBkb2VzIG5vdCBzdXBwb3J0IHdvcmtpbmcgaW4gYW4gb2ZmbGluZSBtb2RlLCBubwotCSAqIGV4Y2VwdGlvbiBpcyB0aHJvd24gYW5kIHRoZSBtZXRob2Qgd2lsbCByZXR1cm4gaW1tZWRpYXRlbHkuCi0JICovCi0JSVN0YXR1cyBzYXZlV29ya09mZmxpbmVEYXRhKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgY29ubmVjdGlvbiBwcm9maWxlIHN1cHBvcnRzIHdvcmtpbmcgb2ZmbGluZSBhbmQgZGF0YQotCSAqIGhhcyBiZWVuIHNhdmVkIGZvciB3b3JraW5nIG9mZmxpbmUuCi0JICovCi0JYm9vbGVhbiBjYW5Xb3JrT2ZmbGluZSgpOwotCi0JLyoqCi0JICogQmVnaW4gd29ya2luZyBvZmYtbGluZS4KLQkgKi8KLQlJU3RhdHVzIHdvcmtPZmZsaW5lKCk7Ci0KLQotCS8vICoqKioqKioqKiogbGlzdGVuZXJzICoqKioqKioqKioKLQotCS8qKgotCSAqIEFkZCB0aGUgc3BlY2lmaWVkIGNvbm5lY3Rpb24gbGlzdGVuZXIgdG8gdGhlIGNvbm5lY3Rpb24gcHJvZmlsZS4KLQkgKi8KLQl2b2lkIGFkZENvbm5lY3Rpb25MaXN0ZW5lcihDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIpOwotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgY29ubmVjdGlvbiBsaXN0ZW5lciBmcm9tIHRoZSBjb25uZWN0aW9uIHByb2ZpbGUuCi0JICovCi0Jdm9pZCByZW1vdmVDb25uZWN0aW9uTGlzdGVuZXIoQ29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyKTsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdGFudHMgKioqKioqKioqKgotCi0JU3RyaW5nIENPTk5FQ1RJT05fUFJPRklMRV9UWVBFID0gIm9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuZGIuZ2VuZXJpYy5jb25uZWN0aW9uUHJvZmlsZSI7ICAvLyROT04tTkxTLTEkCi0JU3RyaW5nIERSSVZFUl9ERUZJTklUSU9OX1BST1BfSUQgPSAib3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5kcml2ZXJEZWZpbml0aW9uSUQiOyAgLy8kTk9OLU5MUy0xJAotCVN0cmluZyBEUklWRVJfREVGSU5JVElPTl9UWVBFX1BST1BfSUQgPSAib3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5kcml2ZXJzLmRlZm5UeXBlIjsgIC8vJE5PTi1OTFMtMSQKLQlTdHJpbmcgRFJJVkVSX0pBUl9MSVNUX1BST1BfSUQgPSAiamFyTGlzdCI7ICAvLyROT04tTkxTLTEkCi0JU3RyaW5nIERBVEFCQVNFX1NBVkVfUFdEX1BST1BfSUQgPSBJSkRCQ0RyaXZlckRlZmluaXRpb25Db25zdGFudHMuUFJPUF9QUkVGSVggKyAic2F2ZVBXRCI7ICAvLyROT04tTkxTLTEkCi0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL0Nvbm5lY3Rpb25Qcm9maWxlQWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvQ29ubmVjdGlvblByb2ZpbGVBZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDY0OGRhYTUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvQ29ubmVjdGlvblByb2ZpbGVBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYjsKLQotLyoqCi0gKiBBbiBlbXB0eSBpbXBsZW1lbnRhdGlvbiBvZiBQcm9maWxlTGlzdGVuZXIuCi0gKiAKLSAqIFByb3Zpc2lvbmFsIEFQSTogVGhpcyBjbGFzcyBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKi8KLXB1YmxpYyBjbGFzcyBDb25uZWN0aW9uUHJvZmlsZUFkYXB0ZXIgaW1wbGVtZW50cyBDb25uZWN0aW9uUHJvZmlsZUxpc3RlbmVyIHsKLQotCXB1YmxpYyB2b2lkIGNvbm5lY3Rpb25Qcm9maWxlQWRkZWQoU3RyaW5nIG5hbWUpIHsKLQkJLy8gZG8gbm90aGluZwotCX0KLQotCXB1YmxpYyB2b2lkIGNvbm5lY3Rpb25Qcm9maWxlUmVtb3ZlZChTdHJpbmcgbmFtZSkgewotCQkvLyBkbyBub3RoaW5nCi0JfQotCi0JcHVibGljIHZvaWQgY29ubmVjdGlvblByb2ZpbGVSZW5hbWVkKFN0cmluZyBvbGROYW1lLCBTdHJpbmcgbmV3TmFtZSkgewotCQkvLyBkbyBub3RoaW5nCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9Db25uZWN0aW9uUHJvZmlsZUZhY3RvcnkuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL0Nvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlNDQ3NzM5Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL0Nvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNjcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGI7Ci0KLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci0KLS8qKgotICogRGF0YWJhc2UgY29ubmVjdGlvbiBwcm9maWxlIGZhY3RvcnkKLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKiAKLSAqIFRoaXMgaW50ZXJmYWNlIGlzIG5vdCBpbnRlbmRlZCB0byBiZSBpbXBsZW1lbnRlZCBieSBjbGllbnRzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIENvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeSB7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG5hbWVzIG9mIHRoZSBEVFAgY29ubmVjdGlvbiBwcm9maWxlcyB0aGUgZmFjdG9yeSBjYW4gd3JhcCB3aXRoCi0JICogbmV3IGNvbm5lY3Rpb24gcHJvZmlsZXMuCi0JICovCi0JSXRlcmF0b3I8U3RyaW5nPiBjb25uZWN0aW9uUHJvZmlsZU5hbWVzKCk7Ci0KLQkvKioKLQkgKiBCdWlsZCBhbmQgcmV0dXJuIGEgY29ubmVjdGlvbiBwcm9maWxlIHRoYXQgd3JhcHMgdGhlIERUUCBjb25uZWN0aW9uCi0JICogcHJvZmlsZSB3aXRoIHRoZSBzcGVjaWZpZWQgbmFtZS4KLQkgKiBSZXR1cm4gbnVsbCBpZiB0aGVyZSBpcyBubyBEVFAgY29ubmVjdGlvbiBwcm9maWxlIHdpdGggdGhlIHNwZWNpZmllZAotCSAqIG5hbWUuCi0JICogVXNlIHRoZSBzcGVjaWZpZWQgZGF0YWJhc2UgZmluZGVyIHRvIGFsbG93IGNsaWVudHMgdG8gY29udHJvbCBob3cKLQkgKiBkYXRhYmFzZSBvYmplY3RzIGFyZSBmb3VuZCBiYXNlZCBvbiB0aGVpciBuYW1lcy4KLQkgKi8KLQlDb25uZWN0aW9uUHJvZmlsZSBidWlsZENvbm5lY3Rpb25Qcm9maWxlKFN0cmluZyBuYW1lLCBEYXRhYmFzZUZpbmRlciBmaW5kZXIpOwotCi0JLyoqCi0JICogQnVpbGQgYW5kIHJldHVybiBhIGNvbm5lY3Rpb24gcHJvZmlsZSB0aGF0IHdyYXBzIHRoZSBEVFAgY29ubmVjdGlvbgotCSAqIHByb2ZpbGUgd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUuCi0JICogUmV0dXJuIG51bGwgaWYgdGhlcmUgaXMgbm8gRFRQIGNvbm5lY3Rpb24gcHJvZmlsZSB3aXRoIHRoZSBzcGVjaWZpZWQKLQkgKiBuYW1lLgotCSAqIENsaWVudHMgc2hvdWxkIHVzZSB0aGlzIG1ldGhvZCB3aGVuIGEgSlBBIHBsYXRmb3JtIGlzIHVuYXZhaWxhYmxlCi0JICogKGUuZy4gZHVyaW5nIHByb2plY3QgY3JlYXRpb24pLiBUaGUgcmV0dXJuZWQgY29ubmVjdGlvbiBwcm9maWxlIHdpbGwKLQkgKiBub3QgYmUgYWJsZSB0byBzZWFyY2ggZm9yIGRhdGFiYXNlIG9iamVjdHMgYnkgYW55IG5hbWVzIG90aGVyIHRoYW4KLQkgKiB0aG9zZSBzdXBwbGllZCBieSB0aGUgZmFjdG9yeSAoaS5lLiBsb29rdXBzIGNhbm5vdCBiZSBwZXJmb3JtZWQgd2l0aAotCSAqICJpZGVudGlmaWVycyIpLgotCSAqLwotCUNvbm5lY3Rpb25Qcm9maWxlIGJ1aWxkQ29ubmVjdGlvblByb2ZpbGUoU3RyaW5nIG5hbWUpOwotCi0JLyoqCi0JICogQWRkIGEgbGlzdGVuZXIgdGhhdCB3aWxsIGJlIG5vdGlmaWVkIG9mIGNoYW5nZXMgdG8gdGhlIERUUAotCSAqIGNvbm5lY3Rpb24gcHJvZmlsZXMuCi0JICovCi0Jdm9pZCBhZGRDb25uZWN0aW9uUHJvZmlsZUxpc3RlbmVyKENvbm5lY3Rpb25Qcm9maWxlTGlzdGVuZXIgbGlzdGVuZXIpOwotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgbGlzdGVuZXIuCi0JICovCi0Jdm9pZCByZW1vdmVDb25uZWN0aW9uUHJvZmlsZUxpc3RlbmVyKENvbm5lY3Rpb25Qcm9maWxlTGlzdGVuZXIgbGlzdGVuZXIpOwotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9Db25uZWN0aW9uUHJvZmlsZUxpc3RlbmVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9Db25uZWN0aW9uUHJvZmlsZUxpc3RlbmVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGYwMjBjNTUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvQ29ubmVjdGlvblByb2ZpbGVMaXN0ZW5lci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGI7Ci0KLWltcG9ydCBqYXZhLnV0aWwuRXZlbnRMaXN0ZW5lcjsKLQotLyoqCi0gKiBBIFByb2ZpbGVMaXN0ZW5lciBpcyBub3RpZmllZCBvZiBhbnkgY2hhbmdlcyB0byB0aGUgRFRQIGNvbm5lY3Rpb24gcHJvZmlsZXMuCi0gKiAKLSAqIEBzZWUgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5JUHJvZmlsZUxpc3RlbmVyCi0gKiAKLSAqIFByb3Zpc2lvbmFsIEFQSTogVGhpcyBpbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsCi0gKiB1bmRlciBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nCi0gKiBzdGFiaWxpdHkuIEl0IGlzIGF2YWlsYWJsZSBhdCB0aGlzIGVhcmx5IHN0YWdlIHRvIHNvbGljaXQgZmVlZGJhY2sgZnJvbQotICogcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyB0aGlzIEFQSQotICogd2lsbCBhbG1vc3QgY2VydGFpbmx5IGJlIGJyb2tlbiAocmVwZWF0ZWRseSkgYXMgdGhlIEFQSSBldm9sdmVzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIENvbm5lY3Rpb25Qcm9maWxlTGlzdGVuZXIKLQlleHRlbmRzIEV2ZW50TGlzdGVuZXIKLXsKLQotCS8qKgotCSAqIFRoZSBzcGVjaWZpZWQgcHJvZmlsZSBoYXMgYmVlbiBhZGRlZC4KLQkgKi8KLQlwdWJsaWMgdm9pZCBjb25uZWN0aW9uUHJvZmlsZUFkZGVkKFN0cmluZyBuYW1lKTsKLQotCS8qKgotCSAqIFRoZSBzcGVjaWZpZWQgcHJvZmlsZSBoYXMgYmVlbiByZW1vdmVkLgotCSAqLwotCXB1YmxpYyB2b2lkIGNvbm5lY3Rpb25Qcm9maWxlUmVtb3ZlZChTdHJpbmcgbmFtZSk7Ci0KLQkvKioKLQkgKiBUaGUgc3BlY2lmaWVkIHByb2ZpbGUgaGFzIGJlZW4gcmVuYW1lZC4KLQkgKi8KLQlwdWJsaWMgdm9pZCBjb25uZWN0aW9uUHJvZmlsZVJlbmFtZWQoU3RyaW5nIG9sZE5hbWUsIFN0cmluZyBuZXdOYW1lKTsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvRGF0YWJhc2UuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL0RhdGFiYXNlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGFjNWVkMDkuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvRGF0YWJhc2UuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEyNyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYjsKLQotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLQotLyoqCi0gKiBEYXRhYmFzZQotICogCi0gKiBQcm92aXNpb25hbCBBUEk6IFRoaXMgaW50ZXJmYWNlIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbAotICogdW5kZXIgZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZwotICogc3RhYmlsaXR5LiBJdCBpcyBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20KLSAqIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgdGhpcyBBUEkKLSAqIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KLSAqIAotICogVGhpcyBpbnRlcmZhY2UgaXMgbm90IGludGVuZGVkIHRvIGJlIGltcGxlbWVudGVkIGJ5IGNsaWVudHMuCi0gKi8KLXB1YmxpYyBpbnRlcmZhY2UgRGF0YWJhc2UKLQlleHRlbmRzIFNjaGVtYUNvbnRhaW5lciwgQ29tcGFyYWJsZTxEYXRhYmFzZT4KLXsKLQotCS8vICoqKioqKioqKiogcHJvcGVydGllcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG5hbWUgb2YgdGhlIGRhdGFiYXNlJ3MgdmVuZG9yLgotCSAqLwotCVN0cmluZyBnZXRWZW5kb3JOYW1lKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGRhdGFiYXNlJ3MgdmVyc2lvbi4KLQkgKi8KLQlTdHJpbmcgZ2V0VmVyc2lvbigpOwotCi0KLQkvLyAqKioqKioqKioqIGNhdGFsb2dzICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBkYXRhYmFzZSBzdXBwb3J0cyBjYXRhbG9ncy4gSWYgaXQgZG9lcywgYWxsIGRhdGFiYXNlCi0JICogb2JqZWN0cyBhcmUgY29udGFpbmVkIGJ5IHRoZSBkYXRhYmFzZSdzIGNhdGFsb2dzOyBvdGhlcndpc2UgYWxsIGRhdGFiYXNlCi0JICogb2JqZWN0cyBhcmUgY29udGFpbmVkIGJ5IHRoZSBkYXRhYmFzZSdzIHNjaGVtYXRhLgotCSAqIAotCSAqIFByYWN0aWNhbGx5IHNwZWFraW5nOgotCSAqICAgICBpZiAjc3VwcG9ydHNDYXRhbG9ncygpIHJldHVybnMgJ3RydWUnCi0JICogICAgICAgICAjY2F0YWxvZ3MoKSByZXR1cm5zIGNhdGFsb2dzIHRoYXQgY29udGFpbiB0aGUgZGF0YWJhc2UncyBzY2hlbWF0YQotCSAqICAgICAgICAgI3NjaGVtYXRhKCkgcmV0dXJucyBhbiBlbXB0eSBpdGVyYXRvcgotCSAqICAgICBlbHNlCi0JICogICAgICAgICAjY2F0YWxvZ3MoKSByZXR1cm5zIGFuIGVtcHR5IGl0ZXJhdG9yCi0JICogICAgICAgICAjc2NoZW1hdGEoKSByZXR1cm5zIHRoZSBkYXRhYmFzZSdzIHNjaGVtYXRhCi0JICogVGhpcyBpcyBjb21wbGljYXRlZCBieSB0aGUgcHJlc2VuY2Ugb2YgYSAiZGVmYXVsdCIgY2F0YWxvZyB0aGF0IGNsaWVudHMgY2FuCi0JICogdXNlIHRvIGFsbG93IHRoZSBzcGVjaWZpY2F0aW9uIG9mIGEgY2F0YWxvZyB0byBiZSBvcHRpb25hbDsgYnV0IGNsaWVudHMKLQkgKiBtdXN0IG1hbmFnZSB0aGlzIGV4cGxpY2l0bHkuCi0JICogCi0JICogQHNlZSAjY2F0YWxvZ3MoKQotCSAqIEBzZWUgI3NjaGVtYXRhKCkKLQkgKi8KLQlib29sZWFuIHN1cHBvcnRzQ2F0YWxvZ3MoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgZGF0YWJhc2UncyBjYXRhbG9ncy4KLQkgKiBSZXR1cm4gYW4gZW1wdHkgaXRlcmF0b3IgaWYgdGhlIGRhdGFiYXNlIGRvZXMgbm90IHN1cHBvcnQgY2F0YWxvZ3MuCi0JICogQHNlZSAjc3VwcG9ydHNDYXRhbG9ncygpCi0JICovCi0JSXRlcmF0b3I8Q2F0YWxvZz4gY2F0YWxvZ3MoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgbnVtYmVyIG9mIGNhdGFsb2dzIHRoZSBkYXRhYmFzZSBjb250YWlucy4KLQkgKiBSZXR1cm4gemVybyBpZiB0aGUgZGF0YWJhc2UgZG9lcyBub3Qgc3VwcG9ydCBjYXRhbG9ncy4KLQkgKiBAc2VlICNzdXBwb3J0c0NhdGFsb2dzKCkKLQkgKi8KLQlpbnQgY2F0YWxvZ3NTaXplKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNhdGFsb2cgd2l0aCBzcGVjaWZpZWQgbmFtZS4gVGhlIG5hbWUgbXVzdCBiZSBhbiBleGFjdCBtYXRjaAotCSAqIG9mIHRoZSBjYXRhbG9nJ3MgbmFtZS4KLQkgKiBSZXR1cm4gbnVsbCBpZiB0aGUgZGF0YWJhc2UgZG9lcyBub3Qgc3VwcG9ydCBjYXRhbG9ncy4KLQkgKiBAc2VlICNzdXBwb3J0c0NhdGFsb2dzKCkKLQkgKiBAc2VlICNnZXRDYXRhbG9nRm9ySWRlbnRpZmllcihTdHJpbmcpCi0JICovCi0JQ2F0YWxvZyBnZXRDYXRhbG9nTmFtZWQoU3RyaW5nIG5hbWUpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBkYXRhYmFzZSdzIGNhdGFsb2cgaWRlbnRpZmllcnMsIHNvcnRlZCBieSBuYW1lLgotCSAqIFJldHVybiBhbiBlbXB0eSBpdGVyYXRvciBpZiB0aGUgZGF0YWJhc2UgZG9lcyBub3Qgc3VwcG9ydCBjYXRhbG9ncy4KLQkgKi8KLQlJdGVyYXRvcjxTdHJpbmc+IHNvcnRlZENhdGFsb2dJZGVudGlmaWVycygpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjYXRhbG9nIGZvciB0aGUgc3BlY2lmaWVkIGlkZW50aWZpZXIuIFRoZSBpZGVudGlmaWVyIHNob3VsZAotCSAqIGJlIGFuIFNRTCBpZGVudGlmaWVyIChpLmUuIHF1b3RlZCB3aGVuIGNhc2Utc2Vuc2l0aXZlIG9yIGNvbnRhaW5pbmcKLQkgKiBzcGVjaWFsIGNoYXJhY3RlcnMsIHVucXVvdGVkIG90aGVyd2lzZSkuCi0JICogUmV0dXJuIG51bGwgaWYgdGhlIGRhdGFiYXNlIGRvZXMgbm90IHN1cHBvcnQgY2F0YWxvZ3MuCi0JICogQHNlZSAjc3VwcG9ydHNDYXRhbG9ncygpCi0JICogQHNlZSAjZ2V0Q2F0YWxvZ05hbWVkKFN0cmluZykKLQkgKi8KLQlDYXRhbG9nIGdldENhdGFsb2dGb3JJZGVudGlmaWVyKFN0cmluZyBpZGVudGlmaWVyKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgZGF0YWJhc2UncyAiZGVmYXVsdCIgY2F0YWxvZy4KLQkgKiBSZXR1cm4gbnVsbCBpZiB0aGUgZGF0YWJhc2UgZG9lcyBub3Qgc3VwcG9ydCBjYXRhbG9ncy4KLQkgKiBAc2VlICNzdXBwb3J0c0NhdGFsb2dzKCkKLQkgKi8KLQlDYXRhbG9nIGdldERlZmF1bHRDYXRhbG9nKCk7Ci0KLQotCS8vICoqKioqKioqKiogdXRpbGl0eSBtZXRob2RzICoqKioqKioqKioKLQotCS8qKgotCSAqIFNlbGVjdCBhbmQgcmV0dXJuIGZyb20gdGhlIHNwZWNpZmllZCBsaXN0IG9mIGRhdGFiYXNlIG9iamVjdHMgdGhlCi0JICogZGF0YWJhc2Ugb2JqZWN0IGlkZW50aWZpZWQgYnkgdGhlIHNwZWNpZmllZCBpZGVudGlmaWVyLgotCSAqIFRoZSBpZGVudGlmaWVyIHNob3VsZCBiZSBhbiBTUUwgaWRlbnRpZmllciAoaS5lLiBkZWxpbWl0ZWQgd2hlbgotCSAqIG5vbi0ibm9ybWFsIikuCi0JICovCi0JPFQgZXh0ZW5kcyBEYXRhYmFzZU9iamVjdD4gVCBzZWxlY3REYXRhYmFzZU9iamVjdEZvcklkZW50aWZpZXIoVFtdIGRhdGFiYXNlT2JqZWN0cywgU3RyaW5nIGlkZW50aWZpZXIpOwotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkIG5hbWUgdG8gYSBkYXRhYmFzZS1hcHByb3ByaWF0ZSBTUUwgaWRlbnRpZmllci4KLQkgKi8KLQlTdHJpbmcgY29udmVydE5hbWVUb0lkZW50aWZpZXIoU3RyaW5nIG5hbWUpOwotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9EYXRhYmFzZUZpbmRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvRGF0YWJhc2VGaW5kZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTc4MDZlNy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9EYXRhYmFzZUZpbmRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsOTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGI7Ci0KLS8qKgotICogVGhpcyBpbnRlcmZhY2UgYWxsb3dzIGNsaWVudHMgb2YgdGhlIERhbGkgZGIgcGFja2FnZSB0byBwbHVnIGluIGEgY3VzdG9tCi0gKiBzdHJhdGVneSBmb3IgY29tcGFyaW5nIGFuIGlkZW50aWZpZXIgdG8gdGhlIG5hbWVzIG9mIGEgY29sbGVjdGlvbiBvZgotICogZGF0YWJhc2Ugb2JqZWN0cy4KLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKiAKLSAqIFRoaXMgaW50ZXJmYWNlIGlzIG5vdCBpbnRlbmRlZCB0byBiZSBpbXBsZW1lbnRlZCBieSBjbGllbnRzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIERhdGFiYXNlRmluZGVyIHsKLQotCS8qKgotCSAqIFNlbGVjdCBhbmQgcmV0dXJuIGZyb20gdGhlIHNwZWNpZmllZCBsaXN0IG9mIGRhdGFiYXNlIG9iamVjdHMgdGhlCi0JICogZGF0YWJhc2Ugb2JqZWN0IGlkZW50aWZpZWQgYnkgdGhlIHNwZWNpZmllZCBpZGVudGlmaWVyLgotCSAqLwotCTxUIGV4dGVuZHMgRGF0YWJhc2VPYmplY3Q+IFQgc2VsZWN0RGF0YWJhc2VPYmplY3RGb3JJZGVudGlmaWVyKFRbXSBkYXRhYmFzZU9iamVjdHMsIFN0cmluZyBpZGVudGlmaWVyLCBEZWZhdWx0Q2FsbGJhY2sgZGVmYXVsdENhbGxiYWNrKTsKLQotCS8qKgotCSAqIFRoZSBwbGF0Zm9ybS1wcm92aWRlZCBmaW5kZXIgaXMgcGFzc2VkIGEgImRlZmF1bHQiIGNhbGxiYWNrIHRoYXQgY2FuIGJlCi0JICogdXNlZCBpZiBhcHByb3ByaWF0ZS4KLQkgKi8KLQlpbnRlcmZhY2UgRGVmYXVsdENhbGxiYWNrIHsKLQotCQkvKioKLQkJICogU2VsZWN0IGFuZCByZXR1cm4gZnJvbSB0aGUgc3BlY2lmaWVkIGxpc3Qgb2YgZGF0YWJhc2Ugb2JqZWN0cyB0aGUKLQkJICogZGF0YWJhc2Ugb2JqZWN0IGlkZW50aWZpZWQgYnkgdGhlIHNwZWNpZmllZCBpZGVudGlmaWVyLgotCQkgKi8KLQkJPFQgZXh0ZW5kcyBEYXRhYmFzZU9iamVjdD4gVCBzZWxlY3REYXRhYmFzZU9iamVjdEZvcklkZW50aWZpZXIoVFtdIGRhdGFiYXNlT2JqZWN0cywgU3RyaW5nIGlkZW50aWZpZXIpOwotCi0JfQotCi0JLyoqCi0JICogVGhpcyBmaW5kZXIgc2VhcmNoZXMgZm9yIGFuIGV4YWN0IG1hdGNoLgotCSAqLwotCWZpbmFsIGNsYXNzIFNpbXBsZSBpbXBsZW1lbnRzIERhdGFiYXNlRmluZGVyIHsKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBEYXRhYmFzZUZpbmRlciBJTlNUQU5DRSA9IG5ldyBTaW1wbGUoKTsKLQkJcHVibGljIHN0YXRpYyBEYXRhYmFzZUZpbmRlciBpbnN0YW5jZSgpIHsKLQkJCXJldHVybiBJTlNUQU5DRTsKLQkJfQotCQkvLyBlbnN1cmUgc2luZ2xlIGluc3RhbmNlCi0JCXByaXZhdGUgU2ltcGxlKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQkvLyBzZWFyY2ggZm9yIGFuIGV4YWN0IG1hdGNoIG9uIHRoZSBuYW1lCi0JCXB1YmxpYyA8VCBleHRlbmRzIERhdGFiYXNlT2JqZWN0PiBUIHNlbGVjdERhdGFiYXNlT2JqZWN0Rm9ySWRlbnRpZmllcihUW10gZGF0YWJhc2VPYmplY3RzLCBTdHJpbmcgaWRlbnRpZmllciwgRGVmYXVsdENhbGxiYWNrIGRlZmF1bHRDYWxsYmFjaykgewotCQkJZm9yIChUIGRhdGFiYXNlT2JqZWN0IDogZGF0YWJhc2VPYmplY3RzKSB7Ci0JCQkJaWYgKGRhdGFiYXNlT2JqZWN0LmdldE5hbWUoKS5lcXVhbHMoaWRlbnRpZmllcikpIHsKLQkJCQkJcmV0dXJuIGRhdGFiYXNlT2JqZWN0OwotCQkJCX0KLQkJCX0KLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuICJEYXRhYmFzZUZpbmRlci5EZWZhdWx0IjsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JfQotCi0JLyoqCi0JICogVGhpcyBmaW5kZXIgdXNlcyB0aGUgcGFzc2VkIGluIGNhbGxiYWNrIHRvIHNlYXJjaCB0aGUgbGlzdCBvZiBkYXRhYmFzZSBvYmplY3RzLgotCSAqLwotCWZpbmFsIGNsYXNzIERlZmF1bHQgaW1wbGVtZW50cyBEYXRhYmFzZUZpbmRlciB7Ci0JCXB1YmxpYyBzdGF0aWMgZmluYWwgRGF0YWJhc2VGaW5kZXIgSU5TVEFOQ0UgPSBuZXcgRGVmYXVsdCgpOwotCQlwdWJsaWMgc3RhdGljIERhdGFiYXNlRmluZGVyIGluc3RhbmNlKCkgewotCQkJcmV0dXJuIElOU1RBTkNFOwotCQl9Ci0JCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJcHJpdmF0ZSBEZWZhdWx0KCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQkvLyBzaW1wbHkgdXNlIHRoZSBjYWxsYmFjawotCQlwdWJsaWMgPFQgZXh0ZW5kcyBEYXRhYmFzZU9iamVjdD4gVCBzZWxlY3REYXRhYmFzZU9iamVjdEZvcklkZW50aWZpZXIoVFtdIGRhdGFiYXNlT2JqZWN0cywgU3RyaW5nIGlkZW50aWZpZXIsIERlZmF1bHRDYWxsYmFjayBkZWZhdWx0Q2FsbGJhY2spIHsKLQkJCXJldHVybiBkZWZhdWx0Q2FsbGJhY2suc2VsZWN0RGF0YWJhc2VPYmplY3RGb3JJZGVudGlmaWVyKGRhdGFiYXNlT2JqZWN0cywgaWRlbnRpZmllcik7Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gIkRhdGFiYXNlRmluZGVyLkRlZmF1bHQiOyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL0RhdGFiYXNlT2JqZWN0LmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9EYXRhYmFzZU9iamVjdC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlOWY3NTVkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL0RhdGFiYXNlT2JqZWN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1OCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYjsKLQotLyoqCi0gKiBDb21tb24gYmVoYXZpb3IgdG8gYWxsIGRhdGFiYXNlIG9iamVjdHMKLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKiAKLSAqIFRoaXMgaW50ZXJmYWNlIGlzIG5vdCBpbnRlbmRlZCB0byBiZSBpbXBsZW1lbnRlZCBieSBjbGllbnRzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIERhdGFiYXNlT2JqZWN0IHsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgZGF0YWJhc2Ugb2JqZWN0J3MgbmFtZS4KLQkgKi8KLQlTdHJpbmcgZ2V0TmFtZSgpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBkYXRhYmFzZSBvYmplY3QncyAiaWRlbnRpZmllciIsIHdoaWNoIGlzIHRoZSBvYmplY3QncyBuYW1lCi0JICogbW9kaWZpZWQgc28gaXQgY2FuIGJlIHVzZWQgaW4gYW4gU1FMIHN0YXRlbWVudCAoZS5nLiBpZiB0aGUgbmFtZSBjb250YWlucwotCSAqIHNwZWNpYWwgY2hhcmFjdGVycyBvciBpcyBtaXhlZCBjYXNlLCBpdCB3aWxsIGJlIGRlbGltaXRlZCwgdHlwaWNhbGx5IGJ5Ci0JICogZG91YmxlLXF1b3RlcykuCi0JICogUmV0dXJuIG51bGwgaWYgdGhlIGRhdGFiYXNlIG9iamVjdCdzIGlkZW50aWZpZXIgbWF0Y2hlcyB0aGUgc3BlY2lmaWVkCi0JICogImRlZmF1bHQgbmFtZSIuCi0JICovCi0JU3RyaW5nIGdldElkZW50aWZpZXIoU3RyaW5nIGRlZmF1bHROYW1lKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgZGF0YWJhc2Ugb2JqZWN0J3MgImlkZW50aWZpZXIiLCB3aGljaCBpcyB0aGUgb2JqZWN0J3MgbmFtZQotCSAqIG1vZGlmaWVkIHNvIGl0IGNhbiBiZSB1c2VkIGluIGFuIFNRTCBzdGF0ZW1lbnQgKGUuZy4gaWYgdGhlIG5hbWUgY29udGFpbnMKLQkgKiBzcGVjaWFsIGNoYXJhY3RlcnMgb3IgaXMgbWl4ZWQgY2FzZSwgaXQgd2lsbCBiZSBkZWxpbWl0ZWQsIHR5cGljYWxseSBieQotCSAqIGRvdWJsZS1xdW90ZXMpLgotCSAqLwotCVN0cmluZyBnZXRJZGVudGlmaWVyKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGRhdGFiYXNlIG9iamVjdCdzIGRhdGFiYXNlLgotCSAqLwotCURhdGFiYXNlIGdldERhdGFiYXNlKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGRhdGFiYXNlIG9iamVjdCdzIGNvbm5lY3Rpb24gcHJvZmlsZS4KLQkgKi8KLQlDb25uZWN0aW9uUHJvZmlsZSBnZXRDb25uZWN0aW9uUHJvZmlsZSgpOwotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9Gb3JlaWduS2V5LmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9Gb3JlaWduS2V5LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDA0MDZiNDIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvRm9yZWlnbktleS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTM5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotCi0vKioKLSAqIERhdGFiYXNlIGZvcmVpZ24ga2V5Ci0gKiAKLSAqIFByb3Zpc2lvbmFsIEFQSTogVGhpcyBpbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsCi0gKiB1bmRlciBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nCi0gKiBzdGFiaWxpdHkuIEl0IGlzIGF2YWlsYWJsZSBhdCB0aGlzIGVhcmx5IHN0YWdlIHRvIHNvbGljaXQgZmVlZGJhY2sgZnJvbQotICogcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyB0aGlzIEFQSQotICogd2lsbCBhbG1vc3QgY2VydGFpbmx5IGJlIGJyb2tlbiAocmVwZWF0ZWRseSkgYXMgdGhlIEFQSSBldm9sdmVzLgotICogCi0gKiBUaGlzIGludGVyZmFjZSBpcyBub3QgaW50ZW5kZWQgdG8gYmUgaW1wbGVtZW50ZWQgYnkgY2xpZW50cy4KLSAqLwotcHVibGljIGludGVyZmFjZSBGb3JlaWduS2V5Ci0JZXh0ZW5kcyBEYXRhYmFzZU9iamVjdCwgQ29tcGFyYWJsZTxGb3JlaWduS2V5PgotewotCi0JLy8gKioqKioqKioqKiB0YWJsZXMgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBmb3JlaWduIGtleSdzICJiYXNlIiB0YWJsZS4KLQkgKi8KLQlUYWJsZSBnZXRCYXNlVGFibGUoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgZm9yZWlnbiBrZXkncyAicmVmZXJlbmNlZCIgdGFibGUuCi0JICovCi0JVGFibGUgZ2V0UmVmZXJlbmNlZFRhYmxlKCk7Ci0KLQotCS8vICoqKioqKioqKiogY29sdW1uIHBhaXJzICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB0aGUgZm9yZWlnbiBrZXkncyBjb2x1bW4gcGFpcnMuCi0JICovCi0JSXRlcmF0b3I8Q29sdW1uUGFpcj4gY29sdW1uUGFpcnMoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2l6ZSBvZiB0aGUgZm9yZWlnbiBrZXkncyBjb2x1bW4gcGFpcnMuCi0JICovCi0JaW50IGNvbHVtblBhaXJzU2l6ZSgpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBmb3JlaWduIGtleSdzIHNpbmdsZSBjb2x1bW4gcGFpci4gVGhyb3cgYW4KLQkgKiBJbGxlZ2FsU3RhdGVFeGNlcHRpb24gaWYgdGhlIGZvcmVpZ24ga2V5IGhhcyBtb3JlIHRoYW4gb25lIGNvbHVtbiBwYWlyLgotCSAqLwotCUNvbHVtblBhaXIgZ2V0Q29sdW1uUGFpcigpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBmb3JlaWduIGtleSdzICJiYXNlIiBjb2x1bW5zLgotCSAqLwotCUl0ZXJhdG9yPENvbHVtbj4gYmFzZUNvbHVtbnMoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgZm9yZWlnbiBrZXkncyAiYmFzZSIgY29sdW1ucyB0aGF0IGFyZSBub3QgcGFydCBvZiB0aGUgYmFzZQotCSAqIHRhYmxlJ3MgcHJpbWFyeSBrZXkuIChUaGUgbm9uLXByaW1hcnkga2V5IGJhc2UgY29sdW1ucyBhcmUgbm90IHVzZWQgdG8KLQkgKiBnZW5lcmF0ZSBiYXNpYyBhdHRyaWJ1dGVzIGR1cmluZyBlbnRpdHkgZ2VuZXJhdGlvbi4pCi0JICovCi0JSXRlcmF0b3I8Q29sdW1uPiBub25QcmltYXJ5S2V5QmFzZUNvbHVtbnMoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgZm9yZWlnbiBrZXkncyAicmVmZXJlbmNlZCIgY29sdW1ucy4KLQkgKi8KLQlJdGVyYXRvcjxDb2x1bW4+IHJlZmVyZW5jZWRDb2x1bW5zKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgZm9yZWlnbiBrZXkgcmVmZXJlbmNlcyB0aGUgcHJpbWFyeSBrZXkgb2YgdGhlCi0JICogInJlZmVyZW5jZWQiIHRhYmxlIGFuZCB0aGF0IHByaW1hcnkga2V5IGhhcyBvbmx5IGEgc2luZ2xlIGNvbHVtbi4KLQkgKiBUaGlzIGNhbiBiZSB1c2VkIHdoZW4gZGV0ZXJtaW5pbmcgSlBBIGRlZmF1bHRzLgotCSAqLwotCWJvb2xlYW4gcmVmZXJlbmNlc1NpbmdsZUNvbHVtblByaW1hcnlLZXkoKTsKLQotCi0JLy8gKioqKioqKioqKiBKUEEgc3VwcG9ydCAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gYW4gYXBwcm9wcmlhdGUgbmFtZSBmb3IgYW4gYXR0cmlidXRlIHRoYXQgaG9sZHMgdGhlIGVudGl0eQotCSAqIG1hcHBlZCB0byB0aGUgZm9yZWlnbiBrZXkncyAicmVmZXJlbmNlZCIgdGFibGUuCi0JICovCi0JU3RyaW5nIGdldEF0dHJpYnV0ZU5hbWUoKTsKLQotCS8qKgotCSAqIElmIHRoZSBuYW1lIG9mIHRoZSAiYmFzZSIgY29sdW1uIGFkaGVyZXMgdG8gdGhlIEpQQSBzcGVjIGZvciBhCi0JICogZGVmYXVsdCBtYXBwaW5nIChpLmUuIGl0IGVuZHMgd2l0aCBhbiB1bmRlcnNjb3JlIGZvbGxvd2VkIGJ5IHRoZSBuYW1lCi0JICogb2YgdGhlICJyZWZlcmVuY2VkIiBjb2x1bW4sIGFuZCB0aGUgInJlZmVyZW5jZWQiIGNvbHVtbiBpcyB0aGUgc2luZ2xlCi0JICogcHJpbWFyeSBrZXkgY29sdW1uIG9mIHRoZSAicmVmZXJlbmNlZCIgdGFibGUpLCByZXR1cm4gdGhlIGNvcnJlc3BvbmRpbmcKLQkgKiBkZWZhdWx0IGF0dHJpYnV0ZSBuYW1lOgotCSAqICAgICBGb3JlaWduS2V5KEVNUC5DVUJJQ0xFX0lEID0+IENVQklDTEUuSUQpID0+ICJDVUJJQ0xFIgotCSAqIFJldHVybiBhIG51bGwgaWYgaXQgZG9lcyBub3QgYWRoZXJlIHRvIHRoZSBKUEEgc3BlYzoKLQkgKiAgICAgRm9yZWlnbktleShFTVAuQ1VCSUNMRV9JRCA9PiBDVUJJQ0xFLkNVQklDTEVfSUQpID0+IG51bGwKLQkgKiAgICAgRm9yZWlnbktleShFTVAuQ1VCSUNMRSA9PiBDVUJJQ0xFLklEKSA9PiBudWxsCi0JICovCi0JU3RyaW5nIGdldERlZmF1bHRBdHRyaWJ1dGVOYW1lKCk7Ci0KLQkvKioKLQkgKiBHaXZlbiB0aGUgbmFtZSBvZiBhbiBhdHRyaWJ1dGUgKGZpZWxkIG9yIHByb3BlcnR5KSB0aGF0IGlzIG1hcHBlZCB0byB0aGUKLQkgKiBmb3JlaWduIGtleSwKLQkgKiBidWlsZCBhbmQgcmV0dXJuIGEgc3RyaW5nIHRvIGJlIHVzZWQgYXMgdGhlIHZhbHVlIGZvciB0aGUgYXR0cmlidXRlJ3MKLQkgKiBKb2luQ29sdW1uIGFubm90YXRpb24ncyAnbmFtZScgZWxlbWVudC4gUmV0dXJuIG51bGwgaWYgdGhlIGF0dHJpYnV0ZQotCSAqIG1hcHMgdG8gdGhlIGpvaW4gY29sdW1uIGJ5IGRlZmF1bHQuCi0JICogUHJlY29uZGl0aW9uOiBUaGUgZm9yZWlnbiBrZXkgY29uc2lzdHMgb2YgYSBzaW5nbGUgY29sdW1uIHBhaXIgd2hvc2UKLQkgKiByZWZlcmVuY2VkIGNvbHVtbiBpcyB0aGUgc2luZ2xlLWNvbHVtbiBwcmltYXJ5IGtleSBvZiB0aGUgZm9yZWlnbgotCSAqIGtleSdzIHJlZmVyZW5jZWQgdGFibGUuCi0JICovCi0JU3RyaW5nIGdldEpvaW5Db2x1bW5Bbm5vdGF0aW9uSWRlbnRpZmllcihTdHJpbmcgYXR0cmlidXRlTmFtZSk7Ci0KLQkvLyAqKioqKioqKioqIGNvbHVtbiBwYWlyIGludGVyZmFjZSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBQYWlyIHVwIHRoZSBmb3JlaWduIGtleSdzIGNvbHVtbiBwYWlycywgbWF0Y2hpbmcgZWFjaCAiYmFzZSIgY29sdW1uIHdpdGgKLQkgKiB0aGUgYXBwcm9wcmlhdGUgInJlZmVyZW5jZWQiIGNvbHVtbi4KLQkgKiBAc2VlICNjb2x1bW5QYWlycygpCi0JICovCi0JaW50ZXJmYWNlIENvbHVtblBhaXIgZXh0ZW5kcyBDb21wYXJhYmxlPENvbHVtblBhaXI+IHsKLQotCQkvKioKLQkJICogUmV0dXJuIHRoZSBjb2x1bW4gcGFpcidzICJiYXNlIiBjb2x1bW4uCi0JCSAqLwotCQlDb2x1bW4gZ2V0QmFzZUNvbHVtbigpOwotCi0JCS8qKgotCQkgKiBSZXR1cm4gdGhlIGNvbHVtbiBwYWlyJ3MgInJlZmVyZW5jZWQiIGNvbHVtbi4KLQkJICovCi0JCUNvbHVtbiBnZXRSZWZlcmVuY2VkQ29sdW1uKCk7Ci0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL0pwdERiUGx1Z2luLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9KcHREYlBsdWdpbi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwNDFhYzhkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL0pwdERiUGx1Z2luLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw4MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5QbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLmVuYWJsZW1lbnQuamR0LmNsYXNzcGF0aC5Ecml2ZXJDbGFzc3BhdGhDb250YWluZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSUNsYXNzcGF0aENvbnRhaW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWwuRFRQQ29ubmVjdGlvblByb2ZpbGVGYWN0b3J5OwotaW1wb3J0IG9yZy5vc2dpLmZyYW1ld29yay5CdW5kbGVDb250ZXh0OwotCi0vKioKLSAqIFRoZSBKUFQgREIgcGx1Zy1pbiBsaWZlY3ljbGUgaW1wbGVtZW50YXRpb24uCi0gKiBHbG9iYWxseSBhdmFpbGFibGUgY29ubmVjdGlvbiBwcm9maWxlIGZhY3RvcnkuCi0gKiAKLSAqIFByb3Zpc2lvbmFsIEFQSTogVGhpcyBjbGFzcyBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKi8KLXB1YmxpYyBjbGFzcyBKcHREYlBsdWdpbiBleHRlbmRzIFBsdWdpbiB7Ci0JcHJpdmF0ZSBEVFBDb25uZWN0aW9uUHJvZmlsZUZhY3RvcnkgY29ubmVjdGlvblByb2ZpbGVGYWN0b3J5OwotCi0JcHJpdmF0ZSBzdGF0aWMgSnB0RGJQbHVnaW4gSU5TVEFOQ0U7ICAvLyBzb3J0YS1maW5hbAotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24gSlBUIERCIHBsdWctaW4uCi0JICovCi0JcHVibGljIHN0YXRpYyBKcHREYlBsdWdpbiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQotCS8qKgotCSAqIFRoZSBjb25zdHJ1Y3RvcgotCSAqLwotCXB1YmxpYyBKcHREYlBsdWdpbigpIHsKLQkJc3VwZXIoKTsKLQkJSU5TVEFOQ0UgPSB0aGlzOwotCX0KLQotCS8qKgotCSAqIFRoaXMgbWV0aG9kIGlzIGNhbGxlZCB1cG9uIHBsdWctaW4gYWN0aXZhdGlvbgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHN0YXJ0KEJ1bmRsZUNvbnRleHQgY29udGV4dCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnN0YXJ0KGNvbnRleHQpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeSA9IERUUENvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeS5pbnN0YW5jZSgpOwotICAgICAgICB0aGlzLmNvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeS5zdGFydCgpOwotCX0KLQotCS8qKgotCSAqIFRoaXMgbWV0aG9kIGlzIGNhbGxlZCB3aGVuIHRoZSBwbHVnLWluIGlzIHN0b3BwZWQKLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBzdG9wKEJ1bmRsZUNvbnRleHQgY29udGV4dCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGVGYWN0b3J5LnN0b3AoKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZUZhY3RvcnkgPSBudWxsOwotCQlJTlNUQU5DRSA9IG51bGw7Ci0JCXN1cGVyLnN0b3AoY29udGV4dCk7Ci0JfQotCi0JcHVibGljIENvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeSBnZXRDb25uZWN0aW9uUHJvZmlsZUZhY3RvcnkoKSB7Ci0JCXJldHVybiB0aGlzLmNvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeTsKLQl9Ci0KLQkvKioKLQkgKiBDcmVhdGVzIGEgamFyIGxpc3QgY29udGFpbmVyIGZvciB0aGUgZ2l2ZW4gRFRQIGRyaXZlci4KLQkgKi8KLQlwdWJsaWMgSUNsYXNzcGF0aENvbnRhaW5lciBidWlsZERyaXZlckNsYXNzcGF0aENvbnRhaW5lckZvcihTdHJpbmcgZHJpdmVyTmFtZSkgewotCQlyZXR1cm4gbmV3IERyaXZlckNsYXNzcGF0aENvbnRhaW5lcihkcml2ZXJOYW1lKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL1NjaGVtYS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvU2NoZW1hLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDk4NGRmYjUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvU2NoZW1hLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMDAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGI7Ci0KLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci0KLQotLyoqCi0gKiBEYXRhYmFzZSBzY2hlbWEKLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKiAKLSAqIFRoaXMgaW50ZXJmYWNlIGlzIG5vdCBpbnRlbmRlZCB0byBiZSBpbXBsZW1lbnRlZCBieSBjbGllbnRzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIFNjaGVtYQotCWV4dGVuZHMgRGF0YWJhc2VPYmplY3QsIENvbXBhcmFibGU8U2NoZW1hPgotewotCS8qKgotCSAqIFJldHVybiB0aGUgc2NoZW1hJ3MgY29udGFpbmVyOyBlaXRoZXIgYSBjYXRhbG9nIG9yIGEgZGF0YWJhc2UuCi0JICovCi0JU2NoZW1hQ29udGFpbmVyIGdldENvbnRhaW5lcigpOwotCi0KLQkvLyAqKioqKioqKioqIHRhYmxlcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNjaGVtYSdzIHRhYmxlcy4KLQkgKi8KLQlJdGVyYXRvcjxUYWJsZT4gdGFibGVzKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG51bWJlciBvZiB0YWJsZXMgdGhlIHNjaGVtYSBjb250YWlucy4KLQkgKi8KLQlpbnQgdGFibGVzU2l6ZSgpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSB0YWJsZSB3aXRoIHNwZWNpZmllZCBuYW1lLiBUaGUgbmFtZSBtdXN0IGJlIGFuIGV4YWN0IG1hdGNoCi0JICogb2YgdGhlIHRhYmxlJ3MgbmFtZS4KLQkgKiBAc2VlICNnZXRUYWJsZUZvcklkZW50aWZpZXIoU3RyaW5nKQotCSAqLwotCSBUYWJsZSBnZXRUYWJsZU5hbWVkKFN0cmluZyBuYW1lKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2NoZW1hJ3MgdGFibGUgaWRlbnRpZmllcnMsIHNvcnRlZCBieSBuYW1lLgotCSAqLwotCUl0ZXJhdG9yPFN0cmluZz4gc29ydGVkVGFibGVJZGVudGlmaWVycygpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSB0YWJsZSBmb3IgdGhlIHNwZWNpZmllZCBpZGVudGlmaWVyLiBUaGUgaWRlbnRpZmllciBzaG91bGQKLQkgKiBiZSBhbiBTUUwgaWRlbnRpZmllciAoaS5lLiBxdW90ZWQgd2hlbiBjYXNlLXNlbnNpdGl2ZSBvciBjb250YWluaW5nCi0JICogc3BlY2lhbCBjaGFyYWN0ZXJzLCB1bnF1b3RlZCBvdGhlcndpc2UpLgotCSAqIEBzZWUgI2dldFRhYmxlTmFtZWQoU3RyaW5nKQotCSAqLwotCVRhYmxlIGdldFRhYmxlRm9ySWRlbnRpZmllcihTdHJpbmcgaWRlbnRpZmllcik7Ci0KLQotCS8vICoqKioqKioqKiogc2VxdWVuY2VzICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2NoZW1hJ3Mgc2VxdWVuY2VzLgotCSAqLwotCUl0ZXJhdG9yPFNlcXVlbmNlPiBzZXF1ZW5jZXMoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgbnVtYmVyIG9mIHNlcXVlbmNlcyB0aGUgc2NoZW1hIGNvbnRhaW5zLgotCSAqLwotCWludCBzZXF1ZW5jZXNTaXplKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNlcXVlbmNlIHdpdGggc3BlY2lmaWVkIG5hbWUuIFRoZSBuYW1lIG11c3QgYmUgYW4gZXhhY3QgbWF0Y2gKLQkgKiBvZiB0aGUgc2VxdWVuY2UncyBuYW1lLgotCSAqIEBzZWUgI2dldFNlcXVlbmNlRm9ySWRlbnRpZmllcihTdHJpbmcpCi0JICovCi0JU2VxdWVuY2UgZ2V0U2VxdWVuY2VOYW1lZChTdHJpbmcgbmFtZSk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNjaGVtYSdzIHNlcXVlbmNlIGlkZW50aWZlcnMsIHNvcnRlZCBieSBuYW1lLgotCSAqLwotCUl0ZXJhdG9yPFN0cmluZz4gc29ydGVkU2VxdWVuY2VJZGVudGlmaWVycygpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzZXF1ZW5jZSBmb3IgdGhlIHNwZWNpZmllZCBpZGVudGlmaWVyLiBUaGUgaWRlbnRpZmllciBzaG91bGQKLQkgKiBiZSBhbiBTUUwgaWRlbnRpZmllciAoaS5lLiBxdW90ZWQgd2hlbiBjYXNlLXNlbnNpdGl2ZSBvciBjb250YWluaW5nCi0JICogc3BlY2lhbCBjaGFyYWN0ZXJzLCB1bnF1b3RlZCBvdGhlcndpc2UpLgotCSAqIEBzZWUgI2dldFNlcXVlbmNlTmFtZWQoU3RyaW5nKQotCSAqLwotCVNlcXVlbmNlIGdldFNlcXVlbmNlRm9ySWRlbnRpZmllcihTdHJpbmcgaWRlbnRpZmllcik7Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL1NjaGVtYUNvbnRhaW5lci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvU2NoZW1hQ29udGFpbmVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDI2MzcyZjQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvU2NoZW1hQ29udGFpbmVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw2NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYjsKLQotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLQotLyoqCi0gKiBTY2hlbWEgImNvbnRhaW5lciIgKGkuZS4gRGF0YWJhc2Ugb3IgQ2F0YWxvZykKLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKiAKLSAqIFRoaXMgaW50ZXJmYWNlIGlzIG5vdCBpbnRlbmRlZCB0byBiZSBpbXBsZW1lbnRlZCBieSBjbGllbnRzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIFNjaGVtYUNvbnRhaW5lcgotCWV4dGVuZHMgRGF0YWJhc2VPYmplY3QKLXsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgY29udGFpbmVyJ3Mgc2NoZW1hdGEuCi0JICovCi0JSXRlcmF0b3I8U2NoZW1hPiBzY2hlbWF0YSgpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBudW1iZXIgb2Ygc2NoZW1hdGEgaW4gdGhlIGNvbnRhaW5lci4KLQkgKi8KLQlpbnQgc2NoZW1hdGFTaXplKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNjaGVtYSB3aXRoIHNwZWNpZmllZCBuYW1lLiBUaGUgbmFtZSBtdXN0IGJlIGFuIGV4YWN0IG1hdGNoCi0JICogb2YgdGhlIHNjaGVtYSdzIG5hbWUuCi0JICogQHNlZSAjc2NoZW1hTmFtZXMoKQotCSAqIEBzZWUgI2dldFNjaGVtYUZvcklkZW50aWZpZXIoU3RyaW5nKQotCSAqLwotCVNjaGVtYSBnZXRTY2hlbWFOYW1lZChTdHJpbmcgbmFtZSk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNvbnRhaW5lcidzIHNjaGVtYSBpZGVudGlmaWVycywgc29ydGVkIGJ5IG5hbWUuCi0JICovCi0JSXRlcmF0b3I8U3RyaW5nPiBzb3J0ZWRTY2hlbWFJZGVudGlmaWVycygpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzY2hlbWEgZm9yIHRoZSBzcGVjaWZpZWQgaWRlbnRpZmllci4gVGhlIGlkZW50aWZpZXIgc2hvdWxkCi0JICogYmUgYW4gU1FMIGlkZW50aWZpZXIgKGkuZS4gcXVvdGVkIHdoZW4gY2FzZS1zZW5zaXRpdmUgb3IgY29udGFpbmluZwotCSAqIHNwZWNpYWwgY2hhcmFjdGVycywgdW5xdW90ZWQgb3RoZXJ3aXNlKS4KLQkgKiBAc2VlICNzY2hlbWFJZGVudGlmaWVycygpCi0JICogQHNlZSAjZ2V0U2NoZW1hTmFtZWQoU3RyaW5nKQotCSAqLwotCVNjaGVtYSBnZXRTY2hlbWFGb3JJZGVudGlmaWVyKFN0cmluZyBpZGVudGlmaWVyKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgY29udGFpbmVyJ3MgZGVmYXVsdCBzY2hlbWEsIGFzIGRlZmluZWQgYnkgdGhlIGRhdGFiYXNlIHZlbmRvci4KLQkgKiBJbiBtb3N0IGNhc2VzIHRoZSBkZWZhdWx0IHNjaGVtYSdzIG5hbWUgd2lsbCBtYXRjaCB0aGUgdXNlciBuYW1lLgotCSAqLwotCVNjaGVtYSBnZXREZWZhdWx0U2NoZW1hKCk7Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL1NlcXVlbmNlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9TZXF1ZW5jZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmNGNjYWE3Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL1NlcXVlbmNlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzMiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYjsKLQotLyoqCi0gKiBEYXRhYmFzZSBzZXF1ZW5jZQotICogCi0gKiBQcm92aXNpb25hbCBBUEk6IFRoaXMgaW50ZXJmYWNlIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbAotICogdW5kZXIgZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZwotICogc3RhYmlsaXR5LiBJdCBpcyBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20KLSAqIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgdGhpcyBBUEkKLSAqIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KLSAqIAotICogVGhpcyBpbnRlcmZhY2UgaXMgbm90IGludGVuZGVkIHRvIGJlIGltcGxlbWVudGVkIGJ5IGNsaWVudHMuCi0gKi8KLXB1YmxpYyBpbnRlcmZhY2UgU2VxdWVuY2UKLQlleHRlbmRzIERhdGFiYXNlT2JqZWN0LCBDb21wYXJhYmxlPFNlcXVlbmNlPgotewotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzZXF1ZW5jZSdzIHNjaGVtYS4KLQkgKi8KLQlTY2hlbWEgZ2V0U2NoZW1hKCk7Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL1RhYmxlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9UYWJsZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlZjRkMzM0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL1RhYmxlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMzAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGI7Ci0KLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci0KLS8qKgotICogRGF0YWJhc2UgdGFibGUKLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKiAKLSAqIFRoaXMgaW50ZXJmYWNlIGlzIG5vdCBpbnRlbmRlZCB0byBiZSBpbXBsZW1lbnRlZCBieSBjbGllbnRzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIFRhYmxlCi0JZXh0ZW5kcyBEYXRhYmFzZU9iamVjdCwgQ29tcGFyYWJsZTxUYWJsZT4KLXsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgdGFibGUncyBzY2hlbWEuCi0JICovCi0JU2NoZW1hIGdldFNjaGVtYSgpOwotCi0KLQkvLyAqKioqKioqKioqIGNvbHVtbnMgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSB0YWJsZSdzIGNvbHVtbnMuCi0JICovCi0JSXRlcmF0b3I8Q29sdW1uPiBjb2x1bW5zKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG51bWJlciBvZiBjb2x1bW5zIHRoZSB0YWJsZSBjb250YWlucy4KLQkgKi8KLQlpbnQgY29sdW1uc1NpemUoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgY29sdW1uIHdpdGggc3BlY2lmaWVkIG5hbWUuIFRoZSBuYW1lIG11c3QgYmUgYW4gZXhhY3QgbWF0Y2gKLQkgKiBvZiB0aGUgY29sdW1uJ3MgbmFtZS4KLQkgKiBAc2VlICNnZXRDb2x1bW5Gb3JJZGVudGlmaWVyKFN0cmluZykKLQkgKi8KLQlDb2x1bW4gZ2V0Q29sdW1uTmFtZWQoU3RyaW5nIG5hbWUpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSB0YWJsZSdzIGNvbHVtbiBpZGVudGlmZXJzLCBzb3J0ZWQgYnkgbmFtZS4KLQkgKi8KLQlJdGVyYXRvcjxTdHJpbmc+IHNvcnRlZENvbHVtbklkZW50aWZpZXJzKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNvbHVtbiBmb3IgdGhlIHNwZWNpZmllZCBpZGVudGlmaWVyLiBUaGUgaWRlbnRpZmllciBzaG91bGQKLQkgKiBiZSBhbiBTUUwgaWRlbnRpZmllciAoaS5lLiBxdW90ZWQgd2hlbiBjYXNlLXNlbnNpdGl2ZSBvciBjb250YWluaW5nCi0JICogc3BlY2lhbCBjaGFyYWN0ZXJzLCB1bnF1b3RlZCBvdGhlcndpc2UpLgotCSAqIEBzZWUgI2dldENvbHVtbk5hbWVkKFN0cmluZykKLQkgKi8KLQlDb2x1bW4gZ2V0Q29sdW1uRm9ySWRlbnRpZmllcihTdHJpbmcgaWRlbnRpZmllcik7Ci0KLQotCS8vICoqKioqKioqKiogcHJpbWFyeSBrZXkgY29sdW1ucyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHRhYmxlJ3MgcHJpbWFyeSBrZXkgY29sdW1ucy4KLQkgKi8KLQlJdGVyYXRvcjxDb2x1bW4+IHByaW1hcnlLZXlDb2x1bW5zKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG51bWJlciBvZiBwcmltYXJ5IGtleSBjb2x1bW5zIHRoZSB0YWJsZSBjb250YWlucy4KLQkgKi8KLQlpbnQgcHJpbWFyeUtleUNvbHVtbnNTaXplKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHRhYmxlJ3Mgc2luZ2xlIHByaW1hcnkga2V5IGNvbHVtbi4gVGhyb3cgYW4KLQkgKiBJbGxlZ2FsU3RhdGVFeGNlcHRpb24gaWYgdGhlIHRhYmxlIGhhcyBtb3JlIHRoYW4gb25lIHByaW1hcnkga2V5IGNvbHVtbi4KLQkgKi8KLQlDb2x1bW4gZ2V0UHJpbWFyeUtleUNvbHVtbigpOwotCi0KLQkvLyAqKioqKioqKioqIGZvcmVpZ24ga2V5cyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHRhYmxlJ3MgZm9yZWlnbiBrZXlzLgotCSAqLwotCUl0ZXJhdG9yPEZvcmVpZ25LZXk+IGZvcmVpZ25LZXlzKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG51bWJlciBvZiBmb3JlaWduIGtleXMgdGhlIHRhYmxlIGNvbnRhaW5zLgotCSAqLwotCWludCBmb3JlaWduS2V5c1NpemUoKTsKLQotCi0JLy8gKioqKioqKioqKiBqb2luIHRhYmxlIHN1cHBvcnQgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHRhYmxlIGlzIHBvc3NpYmx5IGEgImpvaW4iIHRhYmxlCi0JICogKGkuZS4gaXQgY29udGFpbnMgb25seSAyIGZvcmVpZ24ga2V5cykuIFdoZXRoZXIgdGhlIHRhYmxlICphY3R1YWxseSogaXMKLQkgKiBhICJqb2luIiB0YWJsZSBpcyBkZXRlcm1pbmVkIGJ5IHRoZSBzZW1hbnRpY3Mgb2YgdGhlIGRhdGFiYXNlIGRlc2lnbi4KLQkgKi8KLQlib29sZWFuIGlzUG9zc2libGVKb2luVGFibGUoKTsKLQotCS8qKgotCSAqIEFzc3VtaW5nIHRoZSB0YWJsZSBpcyBhICJqb2luIiB0YWJsZSwgcmV0dXJuIHRoZSBmb3JlaWduIGtleSB0byB0aGUKLQkgKiAib3duaW5nIiB0YWJsZS4KLQkgKiBAc2VlICNpc1Bvc3NpYmxlSm9pblRhYmxlKCkKLQkgKi8KLQlGb3JlaWduS2V5IGdldEpvaW5UYWJsZU93bmluZ0ZvcmVpZ25LZXkoKTsKLQotCS8qKgotCSAqIEFzc3VtaW5nIHRoZSB0YWJsZSBpcyBhICJqb2luIiB0YWJsZSwgcmV0dXJuIHRoZSBmb3JlaWduIGtleSB0byB0aGUKLQkgKiAibm9uLW93bmluZyIgdGFibGUuCi0JICogQHNlZSAjaXNQb3NzaWJsZUpvaW5UYWJsZSgpCi0JICovCi0JRm9yZWlnbktleSBnZXRKb2luVGFibGVOb25Pd25pbmdGb3JlaWduS2V5KCk7Ci0KLQkvKioKLQkgKiBBc3N1bWluZyB0aGUgdGFibGUgaXMgYSAiam9pbiIgdGFibGUsIHJldHVybiB3aGV0aGVyIGl0cyBuYW1lIG1hdGNoZXMKLQkgKiB0aGUgSlBBIGRlZmF1bHQgKGkuZS4gIk9XTklOR1RBQkxFX05PTk9XTklOR1RBQkxFIikuCi0JICogQHNlZSAjaXNQb3NzaWJsZUpvaW5UYWJsZSgpCi0JICovCi0JYm9vbGVhbiBqb2luVGFibGVOYW1lSXNEZWZhdWx0KCk7Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL0RUUENhdGFsb2dXcmFwcGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC9EVFBDYXRhbG9nV3JhcHBlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0NDViYjRkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL0RUUENhdGFsb2dXcmFwcGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMDAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLnRleHQuQ29sbGF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkNhdGFsb2c7Ci0KLS8qKgotICogV3JhcCBhIERUUCBDYXRhbG9nCi0gKi8KLWZpbmFsIGNsYXNzIERUUENhdGFsb2dXcmFwcGVyCi0JZXh0ZW5kcyBEVFBTY2hlbWFDb250YWluZXJXcmFwcGVyCi0JaW1wbGVtZW50cyBDYXRhbG9nCi17Ci0JLy8gdGhlIHdyYXBwZWQgRFRQIGNhdGFsb2cKLQlwcml2YXRlIGZpbmFsIG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5DYXRhbG9nIGR0cENhdGFsb2c7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3IgKioqKioqKioqKgotCi0JRFRQQ2F0YWxvZ1dyYXBwZXIoRFRQRGF0YWJhc2VXcmFwcGVyIGRhdGFiYXNlLCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuQ2F0YWxvZyBkdHBDYXRhbG9nKSB7Ci0JCXN1cGVyKGRhdGFiYXNlLCBkdHBDYXRhbG9nKTsKLQkJdGhpcy5kdHBDYXRhbG9nID0gZHRwQ2F0YWxvZzsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogRFRQV3JhcHBlciBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlzeW5jaHJvbml6ZWQgdm9pZCBjYXRhbG9nT2JqZWN0Q2hhbmdlZCgpIHsKLQkJc3VwZXIuY2F0YWxvZ09iamVjdENoYW5nZWQoKTsKLQkJdGhpcy5nZXRDb25uZWN0aW9uUHJvZmlsZSgpLmNhdGFsb2dDaGFuZ2VkKHRoaXMpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBEVFBTY2hlbWFDb250YWluZXJXcmFwcGVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCUxpc3Q8b3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLlNjaGVtYT4gZ2V0RFRQU2NoZW1hdGEoKSB7Ci0JCXJldHVybiB0aGlzLmR0cENhdGFsb2cuZ2V0U2NoZW1hcygpOwotCX0KLQotCUBPdmVycmlkZQotCURUUFNjaGVtYVdyYXBwZXIgZ2V0U2NoZW1hKG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5TY2hlbWEgZHRwU2NoZW1hKSB7Ci0JCS8vIHRyeSB0byBzaG9ydC1jaXJjdWl0IHRoZSBzZWFyY2gKLQkJcmV0dXJuIHRoaXMud3JhcHMoZHRwU2NoZW1hLmdldENhdGFsb2coKSkgPwotCQkJCQkJdGhpcy5nZXRTY2hlbWFfKGR0cFNjaGVtYSkKLQkJCQkJOgotCQkJCQkJdGhpcy5nZXREYXRhYmFzZSgpLmdldFNjaGVtYUZyb21DYXRhbG9ncyhkdHBTY2hlbWEpOwotCX0KLQotCUBPdmVycmlkZQotCURUUFRhYmxlV3JhcHBlciBnZXRUYWJsZShvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC50YWJsZXMuVGFibGUgZHRwVGFibGUpIHsKLQkJLy8gdHJ5IHRvIHNob3J0LWNpcmN1aXQgdGhlIHNlYXJjaAotCQlyZXR1cm4gdGhpcy53cmFwcyhkdHBUYWJsZS5nZXRTY2hlbWEoKS5nZXRDYXRhbG9nKCkpID8KLQkJCQkJCXRoaXMuZ2V0VGFibGVfKGR0cFRhYmxlKQotCQkJCQk6Ci0JCQkJCQl0aGlzLmdldERhdGFiYXNlKCkuZ2V0VGFibGVGcm9tQ2F0YWxvZ3MoZHRwVGFibGUpOwotCX0KLQotCUBPdmVycmlkZQotCURUUENvbHVtbldyYXBwZXIgZ2V0Q29sdW1uKG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnRhYmxlcy5Db2x1bW4gZHRwQ29sdW1uKSB7Ci0JCS8vIHRyeSB0byBzaG9ydC1jaXJjdWl0IHRoZSBzZWFyY2gKLQkJcmV0dXJuIHRoaXMud3JhcHMoZHRwQ29sdW1uLmdldFRhYmxlKCkuZ2V0U2NoZW1hKCkuZ2V0Q2F0YWxvZygpKSA/Ci0JCQkJCQl0aGlzLmdldENvbHVtbl8oZHRwQ29sdW1uKQotCQkJCQk6Ci0JCQkJCQl0aGlzLmdldERhdGFiYXNlKCkuZ2V0Q29sdW1uRnJvbUNhdGFsb2dzKGR0cENvbHVtbik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIERhdGFiYXNlT2JqZWN0IGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBTdHJpbmcgZ2V0TmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMuZHRwQ2F0YWxvZy5nZXROYW1lKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIENvbXBhcmFibGUgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIGludCBjb21wYXJlVG8oQ2F0YWxvZyBjYXRhbG9nKSB7Ci0JCXJldHVybiBDb2xsYXRvci5nZXRJbnN0YW5jZSgpLmNvbXBhcmUodGhpcy5nZXROYW1lKCksIGNhdGFsb2cuZ2V0TmFtZSgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW50ZXJuYWwgbWV0aG9kcyAqKioqKioqKioqCi0KLQlib29sZWFuIHdyYXBzKG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5DYXRhbG9nIGNhdGFsb2cpIHsKLQkJcmV0dXJuIHRoaXMuZHRwQ2F0YWxvZyA9PSBjYXRhbG9nOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvRFRQQ29sdW1uV3JhcHBlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvRFRQQ29sdW1uV3JhcHBlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3NzYwODAzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL0RUUENvbHVtbldyYXBwZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI0MSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYi5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEudGV4dC5Db2xsYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLmRiZGVmaW5pdGlvbi5QcmVkZWZpbmVkRGF0YVR5cGVEZWZpbml0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLmRhdGF0eXBlcy5DaGFyYWN0ZXJTdHJpbmdEYXRhVHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5kYXRhdHlwZXMuRGF0YVR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuZGF0YXR5cGVzLkV4YWN0TnVtZXJpY0RhdGFUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLmRhdGF0eXBlcy5OdW1lcmljYWxEYXRhVHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5kYXRhdHlwZXMuUHJlZGVmaW5lZERhdGFUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLmRhdGF0eXBlcy5QcmltaXRpdmVUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5Db2x1bW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuSmF2YVR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TaW1wbGVKYXZhVHlwZTsKLQotLyoqCi0gKiAgV3JhcCBhIERUUCBDb2x1bW4KLSAqLwotZmluYWwgY2xhc3MgRFRQQ29sdW1uV3JhcHBlcgotCWV4dGVuZHMgRFRQRGF0YWJhc2VPYmplY3RXcmFwcGVyCi0JaW1wbGVtZW50cyBDb2x1bW4KLXsKLQkvLyB0aGUgd3JhcHBlZCBEVFAgY29sdW1uCi0JcHJpdmF0ZSBmaW5hbCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC50YWJsZXMuQ29sdW1uIGR0cENvbHVtbjsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvciAqKioqKioqKioqCi0KLQlEVFBDb2x1bW5XcmFwcGVyKERUUFRhYmxlV3JhcHBlciB0YWJsZSwgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLkNvbHVtbiBkdHBDb2x1bW4pIHsKLQkJc3VwZXIodGFibGUsIGR0cENvbHVtbik7Ci0JCXRoaXMuZHRwQ29sdW1uID0gZHRwQ29sdW1uOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBEVFBXcmFwcGVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXN5bmNocm9uaXplZCB2b2lkIGNhdGFsb2dPYmplY3RDaGFuZ2VkKCkgewotCQlzdXBlci5jYXRhbG9nT2JqZWN0Q2hhbmdlZCgpOwotCQl0aGlzLmdldENvbm5lY3Rpb25Qcm9maWxlKCkuY29sdW1uQ2hhbmdlZCh0aGlzKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogQ29sdW1uIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBTdHJpbmcgZ2V0TmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMuZHRwQ29sdW1uLmdldE5hbWUoKTsKLQl9Ci0KLQlwdWJsaWMgRFRQVGFibGVXcmFwcGVyIGdldFRhYmxlKCkgewotCQlyZXR1cm4gKERUUFRhYmxlV3JhcHBlcikgdGhpcy5nZXRQYXJlbnQoKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBpc1BhcnRPZlByaW1hcnlLZXkoKSB7Ci0JCXJldHVybiB0aGlzLmdldFRhYmxlKCkucHJpbWFyeUtleUNvbHVtbnNDb250YWlucyh0aGlzKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBpc1BhcnRPZkZvcmVpZ25LZXkoKSB7Ci0JCXJldHVybiB0aGlzLmdldFRhYmxlKCkuZm9yZWlnbktleUJhc2VDb2x1bW5zQ29udGFpbnModGhpcyk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaXNQYXJ0T2ZVbmlxdWVDb25zdHJhaW50KCkgewotCQlyZXR1cm4gdGhpcy5kdHBDb2x1bW4uaXNQYXJ0T2ZVbmlxdWVDb25zdHJhaW50KCk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaXNOdWxsYWJsZSgpIHsKLQkJcmV0dXJuIHRoaXMuZHRwQ29sdW1uLmlzTnVsbGFibGUoKTsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGdldERhdGFUeXBlTmFtZSgpIHsKLQkJRGF0YVR5cGUgZGF0YVR5cGUgPSB0aGlzLmR0cENvbHVtbi5nZXREYXRhVHlwZSgpOwotCQlyZXR1cm4gKGRhdGFUeXBlID09IG51bGwpID8gbnVsbCA6IGRhdGFUeXBlLmdldE5hbWUoKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBpc051bWVyaWMoKSB7Ci0JCXJldHVybiB0aGlzLmR0cENvbHVtbi5nZXREYXRhVHlwZSgpIGluc3RhbmNlb2YgTnVtZXJpY2FsRGF0YVR5cGU7Ci0JfQkKLQotCXB1YmxpYyBpbnQgZ2V0UHJlY2lzaW9uKCkgewotCQlEYXRhVHlwZSBkYXRhVHlwZSA9IHRoaXMuZHRwQ29sdW1uLmdldERhdGFUeXBlKCk7Ci0JCXJldHVybiAoZGF0YVR5cGUgaW5zdGFuY2VvZiBOdW1lcmljYWxEYXRhVHlwZSkgPwotCQkJCQkJKChOdW1lcmljYWxEYXRhVHlwZSkgZGF0YVR5cGUpLmdldFByZWNpc2lvbigpCi0JCQkJCToKLQkJCQkJCS0xOwotCX0KLQotCXB1YmxpYyBpbnQgZ2V0U2NhbGUoKXsKLQkJRGF0YVR5cGUgZGF0YVR5cGUgPSB0aGlzLmR0cENvbHVtbi5nZXREYXRhVHlwZSgpOwotCQlyZXR1cm4gKGRhdGFUeXBlIGluc3RhbmNlb2YgRXhhY3ROdW1lcmljRGF0YVR5cGUpID8KLQkJCQkJCSgoRXhhY3ROdW1lcmljRGF0YVR5cGUpIGRhdGFUeXBlKS5nZXRTY2FsZSgpCi0JCQkJCToKLQkJCQkJCS0xOwotCX0KLQotCXB1YmxpYyBpbnQgZ2V0TGVuZ3RoKCkgewotCQlEYXRhVHlwZSBkYXRhVHlwZSA9IHRoaXMuZHRwQ29sdW1uLmdldERhdGFUeXBlKCk7Ci0JCXJldHVybiAoZGF0YVR5cGUgaW5zdGFuY2VvZiBDaGFyYWN0ZXJTdHJpbmdEYXRhVHlwZSkgPwotCQkJCQkJKChDaGFyYWN0ZXJTdHJpbmdEYXRhVHlwZSkgZGF0YVR5cGUpLmdldExlbmd0aCgpCi0JCQkJCToKLQkJCQkJCS0xOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGlzTE9CKCkgewotCQlEYXRhVHlwZSBkYXRhVHlwZSA9IHRoaXMuZHRwQ29sdW1uLmdldERhdGFUeXBlKCk7Ci0JCXJldHVybiAoZGF0YVR5cGUgaW5zdGFuY2VvZiBQcmVkZWZpbmVkRGF0YVR5cGUpID8KLQkJCQkJCXByaW1pdGl2ZVR5cGVJc0xvYigoKFByZWRlZmluZWREYXRhVHlwZSkgZGF0YVR5cGUpLmdldFByaW1pdGl2ZVR5cGUoKSkKLQkJCQkJOgotCQkJCQkJZmFsc2U7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXRKYXZhVHlwZURlY2xhcmF0aW9uKCkgewotCQlyZXR1cm4gdGhpcy5nZXRKYXZhVHlwZSgpLmRlY2xhcmF0aW9uKCk7Ci0JfQotCi0JcHVibGljIEphdmFUeXBlIGdldEphdmFUeXBlKCkgewotCQlEYXRhVHlwZSBkYXRhVHlwZSA9IHRoaXMuZHRwQ29sdW1uLmdldERhdGFUeXBlKCk7Ci0JCXJldHVybiAoZGF0YVR5cGUgaW5zdGFuY2VvZiBQcmVkZWZpbmVkRGF0YVR5cGUpID8KLQkJCWNvbnZlcnRUb0pQQUphdmFUeXBlKHRoaXMuZ2V0SmF2YVR5cGUoKFByZWRlZmluZWREYXRhVHlwZSkgZGF0YVR5cGUpKQotCQk6Ci0JCQlERUZBVUxUX0pBVkFfVFlQRTsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGdldFByaW1hcnlLZXlKYXZhVHlwZURlY2xhcmF0aW9uKCkgewotCQlyZXR1cm4gdGhpcy5nZXRQcmltYXJ5S2V5SmF2YVR5cGUoKS5kZWNsYXJhdGlvbigpOwotCX0KLQotCXB1YmxpYyBKYXZhVHlwZSBnZXRQcmltYXJ5S2V5SmF2YVR5cGUoKSB7Ci0JCXJldHVybiBjb252ZXJ0VG9KUEFQcmltYXJ5S2V5SmF2YVR5cGUodGhpcy5nZXRKYXZhVHlwZSgpKTsKLQl9Ci0KLQlwcml2YXRlIEphdmFUeXBlIGdldEphdmFUeXBlKFByZWRlZmluZWREYXRhVHlwZSBkYXRhVHlwZSkgewotCQkvLyB0aGlzIGlzIGp1c3QgYSBiaXQgaGFja3k6IG1vdmluZyBmcm9tIGEgdHlwZSBkZWNsYXJhdGlvbiB0byBhIGNsYXNzIG5hbWUgdG8gYSB0eXBlIGRlY2xhcmF0aW9uLi4uCi0JCVN0cmluZyBkdHBKYXZhQ2xhc3NOYW1lID0gdGhpcy5nZXREZWZpbml0aW9uKGRhdGFUeXBlKS5nZXRKYXZhQ2xhc3NOYW1lKCk7Ci0JCXJldHVybiBuZXcgU2ltcGxlSmF2YVR5cGUoQ2xhc3NUb29scy5jbGFzc05hbWVGb3JUeXBlRGVjbGFyYXRpb24oZHRwSmF2YUNsYXNzTmFtZSkpOwotCX0KLQotCXByaXZhdGUgUHJlZGVmaW5lZERhdGFUeXBlRGVmaW5pdGlvbiBnZXREZWZpbml0aW9uKFByZWRlZmluZWREYXRhVHlwZSBkYXRhVHlwZSkgewotCQlyZXR1cm4gdGhpcy5nZXREYXRhYmFzZSgpLmdldERUUERlZmluaXRpb24oKS5nZXRQcmVkZWZpbmVkRGF0YVR5cGVEZWZpbml0aW9uKGRhdGFUeXBlLmdldE5hbWUoKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIENvbXBhcmFibGUgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIGludCBjb21wYXJlVG8oQ29sdW1uIGNvbHVtbikgewotCQlyZXR1cm4gQ29sbGF0b3IuZ2V0SW5zdGFuY2UoKS5jb21wYXJlKHRoaXMuZ2V0TmFtZSgpLCBjb2x1bW4uZ2V0TmFtZSgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW50ZXJuYWwgbWV0aG9kcyAqKioqKioqKioqCi0KLQlib29sZWFuIHdyYXBzKG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnRhYmxlcy5Db2x1bW4gY29sdW1uKSB7Ci0JCXJldHVybiB0aGlzLmR0cENvbHVtbiA9PSBjb2x1bW47Ci0JfQotCi0JQE92ZXJyaWRlCi0Jdm9pZCBjbGVhcigpIHsKLQkJLy8gbm8gc3RhdGUgdG8gY2xlYXIKLQl9Ci0KLQotCS8vICoqKioqKioqKiogc3RhdGljIG1ldGhvZHMgKioqKioqKioqKgotCi0JLyoqCi0JICogVGhlIEpEQkMgc3BlYyBzYXlzIEpEQkMgZHJpdmVycyBzaG91bGQgYmUgYWJsZSB0byBtYXAgQkxPQnMgYW5kIENMT0JzCi0JICogZGlyZWN0bHksIGJ1dCB0aGUgSlBBIHNwZWMgZG9lcyBub3QgYWxsb3cgdGhlbS4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBKYXZhVHlwZSBjb252ZXJ0VG9KUEFKYXZhVHlwZShKYXZhVHlwZSBqYXZhVHlwZSkgewotCQlpZiAoamF2YVR5cGUuZXF1YWxzKEJMT0JfSkFWQV9UWVBFKSkgewotCQkJcmV0dXJuIEJZVEVfQVJSQVlfSkFWQV9UWVBFOwotCQl9Ci0JCWlmIChqYXZhVHlwZS5lcXVhbHMoQ0xPQl9KQVZBX1RZUEUpKSB7Ci0JCQlyZXR1cm4gU1RSSU5HX0pBVkFfVFlQRTsKLQkJfQotCQlyZXR1cm4gamF2YVR5cGU7Ci0JfQotCi0JLyoqCi0JICogVGhlIEpQQSBzcGVjIFsyLjEuNF0gc2F5cyBvbmx5IHRoZSBmb2xsb3dpbmcgdHlwZXMgYXJlIGFsbG93ZWQgaW4KLQkgKiBwcmltYXJ5IGtleSBmaWVsZHM6Ci0JICogICAgIFt2YXJpYWJsZV0gcHJpbWl0aXZlcwotCSAqICAgICBbdmFyaWFibGVdIHByaW1pdGl2ZSB3cmFwcGVycwotCSAqICAgICBqYXZhLmxhbmcuU3RyaW5nCi0JICogICAgIGphdmEudXRpbC5EYXRlCi0JICogICAgIGphdmEuc3FsLkRhdGUKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBKYXZhVHlwZSBjb252ZXJ0VG9KUEFQcmltYXJ5S2V5SmF2YVR5cGUoSmF2YVR5cGUgamF2YVR5cGUpIHsKLQkJaWYgKGphdmFUeXBlLmlzVmFyaWFibGVQcmltaXRpdmUoKQotCQkJCXx8IGphdmFUeXBlLmlzVmFyaWFibGVQcmltaXRpdmVXcmFwcGVyKCkKLQkJCQl8fCBqYXZhVHlwZS5lcXVhbHMoU1RSSU5HX0pBVkFfVFlQRSkKLQkJCQl8fCBqYXZhVHlwZS5lcXVhbHMoVVRJTF9EQVRFX0pBVkFfVFlQRSkKLQkJCQl8fCBqYXZhVHlwZS5lcXVhbHMoU1FMX0RBVEVfSkFWQV9UWVBFKSkgewotCQkJcmV0dXJuIGphdmFUeXBlOwotCQl9Ci0JCWlmIChqYXZhVHlwZS5lcXVhbHMoQklHX0RFQ0lNQUxfSkFWQV9UWVBFKSkgewotCQkJcmV0dXJuIExPTkdfSkFWQV9UWVBFOyAgLy8gPz8KLQkJfQotCQlpZiAoamF2YVR5cGUuZXF1YWxzKFNRTF9USU1FX0pBVkFfVFlQRSkpIHsKLQkJCXJldHVybiBVVElMX0RBVEVfSkFWQV9UWVBFOyAgLy8gPz8/Ci0JCX0KLQkJaWYgKGphdmFUeXBlLmVxdWFscyhTUUxfVElNRVNUQU1QX0pBVkFfVFlQRSkpIHsKLQkJCXJldHVybiBVVElMX0RBVEVfSkFWQV9UWVBFOyAgLy8gPz8/Ci0JCX0KLQkJLy8gYWxsIHRoZSBvdGhlciB0eXBpY2FsIHR5cGVzIGFyZSBwcmV0dHkgbXVjaCB1bi1tYXBwYWJsZSAtIHJldHVybiBTdHJpbmcoPykKLQkJcmV0dXJuIFNUUklOR19KQVZBX1RZUEU7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgYm9vbGVhbiBwcmltaXRpdmVUeXBlSXNMb2IoUHJpbWl0aXZlVHlwZSBwcmltaXRpdmVUeXBlKSB7Ci0JCXJldHVybiAocHJpbWl0aXZlVHlwZSA9PSBQcmltaXRpdmVUeXBlLkJJTkFSWV9MQVJHRV9PQkpFQ1RfTElURVJBTCkKLQkJCQl8fCAocHJpbWl0aXZlVHlwZSA9PSBQcmltaXRpdmVUeXBlLkNIQVJBQ1RFUl9MQVJHRV9PQkpFQ1RfTElURVJBTCkKLQkJCQl8fCAocHJpbWl0aXZlVHlwZSA9PSBQcmltaXRpdmVUeXBlLk5BVElPTkFMX0NIQVJBQ1RFUl9MQVJHRV9PQkpFQ1RfTElURVJBTCk7Ci0JfQotCi0KLQkvLyAqKioqKiBzb21lIGNvbnN0YW50cyB1c2VkIHdoZW4gY29udmVydGluZyB0aGUgY29sdW1uIHRvIGEgSmF2YSBhdHRyaWJ1dGUKLQkvLyBUT0RPIE9iamVjdCBpcyB0aGUgZGVmYXVsdD8KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBKYXZhVHlwZSBERUZBVUxUX0pBVkFfVFlQRSA9IG5ldyBTaW1wbGVKYXZhVHlwZShqYXZhLmxhbmcuT2JqZWN0LmNsYXNzKTsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIEphdmFUeXBlIEJMT0JfSkFWQV9UWVBFID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEuc3FsLkJsb2IuY2xhc3MpOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIEphdmFUeXBlIEJZVEVfQVJSQVlfSkFWQV9UWVBFID0gbmV3IFNpbXBsZUphdmFUeXBlKGJ5dGVbXS5jbGFzcyk7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBKYXZhVHlwZSBDTE9CX0pBVkFfVFlQRSA9IG5ldyBTaW1wbGVKYXZhVHlwZShqYXZhLnNxbC5DbG9iLmNsYXNzKTsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBKYXZhVHlwZSBTVFJJTkdfSkFWQV9UWVBFID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEubGFuZy5TdHJpbmcuY2xhc3MpOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgSmF2YVR5cGUgVVRJTF9EQVRFX0pBVkFfVFlQRSA9IG5ldyBTaW1wbGVKYXZhVHlwZShqYXZhLnV0aWwuRGF0ZS5jbGFzcyk7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgSmF2YVR5cGUgU1FMX0RBVEVfSkFWQV9UWVBFID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEuc3FsLkRhdGUuY2xhc3MpOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIEphdmFUeXBlIFNRTF9USU1FX0pBVkFfVFlQRSA9IG5ldyBTaW1wbGVKYXZhVHlwZShqYXZhLnNxbC5UaW1lLmNsYXNzKTsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBKYXZhVHlwZSBTUUxfVElNRVNUQU1QX0pBVkFfVFlQRSA9IG5ldyBTaW1wbGVKYXZhVHlwZShqYXZhLnNxbC5UaW1lc3RhbXAuY2xhc3MpOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgSmF2YVR5cGUgQklHX0RFQ0lNQUxfSkFWQV9UWVBFID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEubWF0aC5CaWdEZWNpbWFsLmNsYXNzKTsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBKYXZhVHlwZSBMT05HX0pBVkFfVFlQRSA9IG5ldyBTaW1wbGVKYXZhVHlwZShsb25nLmNsYXNzKTsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvRFRQQ29ubmVjdGlvblByb2ZpbGVGYWN0b3J5LmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC9EVFBDb25uZWN0aW9uUHJvZmlsZUZhY3RvcnkuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmU1ZGYyOC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC9EVFBDb25uZWN0aW9uUHJvZmlsZUZhY3RvcnkuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE2NSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYi5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuSUNvbm5lY3Rpb25Qcm9maWxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuSVByb2ZpbGVMaXN0ZW5lcjE7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5Qcm9maWxlTWFuYWdlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuQ29ubmVjdGlvblByb2ZpbGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkNvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuQ29ubmVjdGlvblByb2ZpbGVMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuRGF0YWJhc2VGaW5kZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuTGlzdGVuZXJMaXN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5BcnJheUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5UcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yOwotCi0vKioKLSAqIFdyYXAgdGhlIERUUCBQcm9maWxlTWFuYWdlciBpbiB5ZXQgYW5vdGhlciBzaW5nbGV0b24uCi0gKi8KLXB1YmxpYyBmaW5hbCBjbGFzcyBEVFBDb25uZWN0aW9uUHJvZmlsZUZhY3RvcnkKLQlpbXBsZW1lbnRzIENvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeQotewotCXByaXZhdGUgUHJvZmlsZU1hbmFnZXIgZHRwUHJvZmlsZU1hbmFnZXI7Ci0KLQlwcml2YXRlIExvY2FsUHJvZmlsZUxpc3RlbmVyIHByb2ZpbGVMaXN0ZW5lcjsKLQotCi0JLy8gKioqKioqKioqKiBzaW5nbGV0b24gKioqKioqKioqKgotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgRFRQQ29ubmVjdGlvblByb2ZpbGVGYWN0b3J5IElOU1RBTkNFID0gbmV3IERUUENvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeSgpOwotCi0JcHVibGljIHN0YXRpYyBEVFBDb25uZWN0aW9uUHJvZmlsZUZhY3RvcnkgaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0KLQkvKioKLQkgKiAncHJpdmF0ZScgdG8gZW5zdXJlIHNpbmdsZXRvbgotCSAqLwotCXByaXZhdGUgRFRQQ29ubmVjdGlvblByb2ZpbGVGYWN0b3J5KCkgewotCQlzdXBlcigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBsaWZlY3ljbGUgKioqKioqKioqKgotCi0JLyoqCi0JICogY2FsbGVkIGJ5IHBsdWctaW4KLQkgKi8KLQlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgc3RhcnQoKSB7Ci0JCXRoaXMuZHRwUHJvZmlsZU1hbmFnZXIgPSBQcm9maWxlTWFuYWdlci5nZXRJbnN0YW5jZSgpOwotCQl0aGlzLnByb2ZpbGVMaXN0ZW5lciA9IG5ldyBMb2NhbFByb2ZpbGVMaXN0ZW5lcigpOwotCQl0aGlzLmR0cFByb2ZpbGVNYW5hZ2VyLmFkZFByb2ZpbGVMaXN0ZW5lcih0aGlzLnByb2ZpbGVMaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogY2FsbGVkIGJ5IHBsdWctaW4KLQkgKi8KLQlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgc3RvcCgpIHsKLQkJdGhpcy5kdHBQcm9maWxlTWFuYWdlci5yZW1vdmVQcm9maWxlTGlzdGVuZXIodGhpcy5wcm9maWxlTGlzdGVuZXIpOwotCQl0aGlzLnByb2ZpbGVMaXN0ZW5lciA9IG51bGw7Ci0JCXRoaXMuZHRwUHJvZmlsZU1hbmFnZXIgPSBudWxsOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBjb25uZWN0aW9uIHByb2ZpbGVzICoqKioqKioqKioKLQotCXB1YmxpYyBDb25uZWN0aW9uUHJvZmlsZSBidWlsZENvbm5lY3Rpb25Qcm9maWxlKFN0cmluZyBuYW1lLCBEYXRhYmFzZUZpbmRlciBmaW5kZXIpIHsKLQkJZm9yIChJQ29ubmVjdGlvblByb2ZpbGUgZHRwUHJvZmlsZSA6IHRoaXMuZHRwUHJvZmlsZU1hbmFnZXIuZ2V0UHJvZmlsZXMoKSkgewotCQkJaWYgKGR0cFByb2ZpbGUuZ2V0TmFtZSgpLmVxdWFscyhuYW1lKSkgewotCQkJCXJldHVybiBuZXcgRFRQQ29ubmVjdGlvblByb2ZpbGVXcmFwcGVyKGR0cFByb2ZpbGUsIGZpbmRlcik7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIG51bGw7Ci0JfQotCi0JcHVibGljIENvbm5lY3Rpb25Qcm9maWxlIGJ1aWxkQ29ubmVjdGlvblByb2ZpbGUoU3RyaW5nIG5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRDb25uZWN0aW9uUHJvZmlsZShuYW1lLCBEYXRhYmFzZUZpbmRlci5TaW1wbGUuaW5zdGFuY2UoKSk7Ci0JfQotCi0JcHVibGljIEl0ZXJhdG9yPFN0cmluZz4gY29ubmVjdGlvblByb2ZpbGVOYW1lcygpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yPElDb25uZWN0aW9uUHJvZmlsZSwgU3RyaW5nPih0aGlzLmR0cENvbm5lY3Rpb25Qcm9maWxlcygpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKElDb25uZWN0aW9uUHJvZmlsZSBkdHBQcm9maWxlKSB7Ci0JCQkJIHJldHVybiBkdHBQcm9maWxlLmdldE5hbWUoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPElDb25uZWN0aW9uUHJvZmlsZT4gZHRwQ29ubmVjdGlvblByb2ZpbGVzKCkgewotCQlyZXR1cm4gbmV3IEFycmF5SXRlcmF0b3I8SUNvbm5lY3Rpb25Qcm9maWxlPih0aGlzLmR0cFByb2ZpbGVNYW5hZ2VyLmdldFByb2ZpbGVzKCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBsaXN0ZW5lcnMgKioqKioqKioqKgotCi0JcHVibGljIHZvaWQgYWRkQ29ubmVjdGlvblByb2ZpbGVMaXN0ZW5lcihDb25uZWN0aW9uUHJvZmlsZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMucHJvZmlsZUxpc3RlbmVyLmFkZENvbm5lY3Rpb25Qcm9maWxlTGlzdGVuZXIobGlzdGVuZXIpOwotCX0KLQotCXB1YmxpYyB2b2lkIHJlbW92ZUNvbm5lY3Rpb25Qcm9maWxlTGlzdGVuZXIoQ29ubmVjdGlvblByb2ZpbGVMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLnByb2ZpbGVMaXN0ZW5lci5yZW1vdmVDb25uZWN0aW9uUHJvZmlsZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogbGlzdGVuZXIgKioqKioqKioqKgotCi0JLyoqCi0JICogRm9yd2FyZCBldmVudHMgdG8gdGhlIGZhY3RvcnkncyBsaXN0ZW5lcnMuCi0JICovCi0JcHJpdmF0ZSBjbGFzcyBMb2NhbFByb2ZpbGVMaXN0ZW5lciBpbXBsZW1lbnRzIElQcm9maWxlTGlzdGVuZXIxIHsKLQkJcHJpdmF0ZSBMaXN0ZW5lckxpc3Q8Q29ubmVjdGlvblByb2ZpbGVMaXN0ZW5lcj4gbGlzdGVuZXJMaXN0ID0gbmV3IExpc3RlbmVyTGlzdDxDb25uZWN0aW9uUHJvZmlsZUxpc3RlbmVyPihDb25uZWN0aW9uUHJvZmlsZUxpc3RlbmVyLmNsYXNzKTsKLQotCQlMb2NhbFByb2ZpbGVMaXN0ZW5lcigpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQotCQl2b2lkIGFkZENvbm5lY3Rpb25Qcm9maWxlTGlzdGVuZXIoQ29ubmVjdGlvblByb2ZpbGVMaXN0ZW5lciBsaXN0ZW5lcikgewotCQkJdGhpcy5saXN0ZW5lckxpc3QuYWRkKGxpc3RlbmVyKTsKLQkJfQotCi0JCXZvaWQgcmVtb3ZlQ29ubmVjdGlvblByb2ZpbGVMaXN0ZW5lcihDb25uZWN0aW9uUHJvZmlsZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCQl0aGlzLmxpc3RlbmVyTGlzdC5yZW1vdmUobGlzdGVuZXIpOwotCQl9Ci0KLQkJLy8gKioqKioqKioqKiBJUHJvZmlsZUxpc3RlbmVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCQlwdWJsaWMgdm9pZCBwcm9maWxlQWRkZWQoSUNvbm5lY3Rpb25Qcm9maWxlIGR0cFByb2ZpbGUpIHsKLQkJCVN0cmluZyBuYW1lID0gZHRwUHJvZmlsZS5nZXROYW1lKCk7Ci0JCQlmb3IgKENvbm5lY3Rpb25Qcm9maWxlTGlzdGVuZXIgbGlzdGVuZXIgOiB0aGlzLmxpc3RlbmVyTGlzdC5nZXRMaXN0ZW5lcnMoKSkgewotCQkJCWxpc3RlbmVyLmNvbm5lY3Rpb25Qcm9maWxlQWRkZWQobmFtZSk7Ci0JCQl9Ci0JCX0KLQotCQlwdWJsaWMgdm9pZCBwcm9maWxlQ2hhbmdlZChJQ29ubmVjdGlvblByb2ZpbGUgZHRwUHJvZmlsZSwgU3RyaW5nIG9sZE5hbWUsIFN0cmluZyBvbGREZXNjcmlwdGlvbiwgQm9vbGVhbiBvbGRBdXRvQ29ubmVjdCkgewotCQkJU3RyaW5nIG5ld05hbWUgPSBkdHBQcm9maWxlLmdldE5hbWUoKTsKLQkJCWlmICggISBuZXdOYW1lLmVxdWFscyhvbGROYW1lKSkgewotCQkJCWZvciAoQ29ubmVjdGlvblByb2ZpbGVMaXN0ZW5lciBsaXN0ZW5lciA6IHRoaXMubGlzdGVuZXJMaXN0LmdldExpc3RlbmVycygpKSB7Ci0JCQkJCWxpc3RlbmVyLmNvbm5lY3Rpb25Qcm9maWxlUmVuYW1lZChvbGROYW1lLCBuZXdOYW1lKTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQotCQlwdWJsaWMgdm9pZCBwcm9maWxlQ2hhbmdlZChJQ29ubmVjdGlvblByb2ZpbGUgZHRwUHJvZmlsZSkgewotCQkJLy8gdGhpcyBtZXRob2Qgc2hvdWxkbid0IGJlIGNhbGxlZCBvbiBJUHJvZmlsZUxpc3RlbmVyMQotCQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JCX0KLQotCQlwdWJsaWMgdm9pZCBwcm9maWxlRGVsZXRlZChJQ29ubmVjdGlvblByb2ZpbGUgZHRwUHJvZmlsZSkgewotCQkJU3RyaW5nIG5hbWUgPSBkdHBQcm9maWxlLmdldE5hbWUoKTsKLQkJCWZvciAoQ29ubmVjdGlvblByb2ZpbGVMaXN0ZW5lciBsaXN0ZW5lciA6IHRoaXMubGlzdGVuZXJMaXN0LmdldExpc3RlbmVycygpKSB7Ci0JCQkJbGlzdGVuZXIuY29ubmVjdGlvblByb2ZpbGVSZW1vdmVkKG5hbWUpOwotCQkJfQotCQl9Ci0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL0RUUENvbm5lY3Rpb25Qcm9maWxlV3JhcHBlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvRFRQQ29ubmVjdGlvblByb2ZpbGVXcmFwcGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDU1YWZhYmYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvRFRQQ29ubmVjdGlvblByb2ZpbGVXcmFwcGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NTcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLnRleHQuQ29sbGF0b3I7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuSVN0YXR1czsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LkNvbm5lY3RFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LklDb25uZWN0aW9uUHJvZmlsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LklNYW5hZ2VkQ29ubmVjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LklNYW5hZ2VkQ29ubmVjdGlvbk9mZmxpbmVMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LmRyaXZlcnMuRHJpdmVyTWFuYWdlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LmRyaXZlcnMuamRiYy5JSkRCQ0RyaXZlckRlZmluaXRpb25Db25zdGFudHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5zcW0uY29yZS5jb25uZWN0aW9uLkNvbm5lY3Rpb25JbmZvOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5zcWx0b29scy5jb3JlLkRhdGFiYXNlSWRlbnRpZmllcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuc3FsdG9vbHMuY29yZS5wcm9maWxlLlByb2ZpbGVVdGlsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5Db25uZWN0aW9uTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkNvbm5lY3Rpb25Qcm9maWxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5EYXRhYmFzZUZpbmRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuRGF0YWJhc2VPYmplY3Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuTGlzdGVuZXJMaXN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotCi0vKioKLSAqICBXcmFwIGEgRFRQIENvbm5lY3Rpb25Qcm9maWxlCi0gKi8KLWZpbmFsIGNsYXNzIERUUENvbm5lY3Rpb25Qcm9maWxlV3JhcHBlcgotCWltcGxlbWVudHMgRFRQRGF0YWJhc2VPYmplY3QsIENvbm5lY3Rpb25Qcm9maWxlCi17Ci0JLy8gdGhlIHdyYXBwZWQgRFRQIGNvbm5lY3Rpb24gcHJvZmlsZQotCXByaXZhdGUgZmluYWwgSUNvbm5lY3Rpb25Qcm9maWxlIGR0cENvbm5lY3Rpb25Qcm9maWxlOwotCi0JLy8gZmluZGVyIHN1cHBsaWVkIGJ5IHRoZSBKUEEgcGxhdGZvcm0gKGRldGVybWluZXMgY2FzZS1zZW5zaXRpdml0eSwgZXRjLikKLQlwcml2YXRlIGZpbmFsIERhdGFiYXNlRmluZGVyIGZpbmRlcjsKLQotCS8vIGNhbGxiYWNrIHBhc3NlZCB0byB0aGUgZmluZGVyCi0JcHJpdmF0ZSBmaW5hbCBEYXRhYmFzZUZpbmRlci5EZWZhdWx0Q2FsbGJhY2sgZGF0YWJhc2VGaW5kZXJDYWxsYmFjazsKLQotCS8vIHRoZSBEVFAgbWFuYWdlZCBjb25uZWN0aW9uIHdlIGxpc3RlbiB0bwotCXByaXZhdGUgZmluYWwgSU1hbmFnZWRDb25uZWN0aW9uIGR0cE1hbmFnZWRDb25uZWN0aW9uOwotCi0JLy8gZm9yd2FyZCBldmVudHMgZnJvbSB0aGUgRFRQIG1hbmFnZWQgY29ubmVjdGlvbiBhYm92ZTsKLQkvLyB3ZSBsaXN0ZW4gYW5kIHByb3BhZ2F0ZSBldmVudHMgaWZmIHdlIGhhdmUgbGlzdGVuZXJzIG91cnNlbHZlcwotCXByaXZhdGUgZmluYWwgTG9jYWxDb25uZWN0aW9uTGlzdGVuZXIgY29ubmVjdGlvbkxpc3RlbmVyOwotCi0JLy8gbGF6eS1pbml0aWFsaXplZCwgYW5kIGRlbGV0ZWQgYXQgZGlzY29ubmVjdAotCXByaXZhdGUgRFRQRGF0YWJhc2VXcmFwcGVyIGRhdGFiYXNlOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0YW50cyAqKioqKioqKioqCi0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgTElWRV9EVFBfQ09OTkVDVElPTl9UWVBFID0gImphdmEuc3FsLkNvbm5lY3Rpb24iOyAgLy8kTk9OLU5MUy0xJAotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIE9GRkxJTkVfRFRQX0NPTk5FQ1RJT05fVFlQRSA9IENvbm5lY3Rpb25JbmZvLmNsYXNzLmdldE5hbWUoKTsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBEQVRBQkFTRV9QUk9EVUNUX1BST1BfSUQgPSAib3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5zZXJ2ZXIudmVyc2lvbiI7ICAvLyROT04tTkxTLTEkCi0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3IgKioqKioqKioqKgotCi0JRFRQQ29ubmVjdGlvblByb2ZpbGVXcmFwcGVyKElDb25uZWN0aW9uUHJvZmlsZSBkdHBDb25uZWN0aW9uUHJvZmlsZSwgRGF0YWJhc2VGaW5kZXIgZmluZGVyKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuZHRwQ29ubmVjdGlvblByb2ZpbGUgPSBkdHBDb25uZWN0aW9uUHJvZmlsZTsKLQkJdGhpcy5maW5kZXIgPSBmaW5kZXI7Ci0JCXRoaXMuZGF0YWJhc2VGaW5kZXJDYWxsYmFjayA9IG5ldyBEYXRhYmFzZUZpbmRlckNhbGxiYWNrKCk7Ci0JCXRoaXMuZHRwTWFuYWdlZENvbm5lY3Rpb24gPSB0aGlzLmJ1aWxkRFRQTWFuYWdlZENvbm5lY3Rpb24oKTsKLQkJdGhpcy5jb25uZWN0aW9uTGlzdGVuZXIgPSBuZXcgTG9jYWxDb25uZWN0aW9uTGlzdGVuZXIoKTsKLQkJLy8gZG9uJ3QgbGlzdGVuIHRvIHRoZSBtYW5hZ2VkIGNvbm5lY3Rpb24geWV0Ci0JfQotCi0JcHJpdmF0ZSBJTWFuYWdlZENvbm5lY3Rpb24gYnVpbGREVFBNYW5hZ2VkQ29ubmVjdGlvbigpIHsKLQkJU3RyaW5nIGNvbm5lY3Rpb25UeXBlID0gdGhpcy5kdHBDb25uZWN0aW9uUHJvZmlsZS5zdXBwb3J0c1dvcmtPZmZsaW5lTW9kZSgpID8KLQkJCQlPRkZMSU5FX0RUUF9DT05ORUNUSU9OX1RZUEUgOiBMSVZFX0RUUF9DT05ORUNUSU9OX1RZUEU7Ci0JCXJldHVybiB0aGlzLmR0cENvbm5lY3Rpb25Qcm9maWxlLmdldE1hbmFnZWRDb25uZWN0aW9uKGNvbm5lY3Rpb25UeXBlKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogRGF0YWJhc2VPYmplY3QgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIFN0cmluZyBnZXROYW1lKCkgewotCQlyZXR1cm4gdGhpcy5kdHBDb25uZWN0aW9uUHJvZmlsZS5nZXROYW1lKCk7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXRJZGVudGlmaWVyKFN0cmluZyBqYXZhSWRlbnRpZmllcikgewotCQkvLyBjb25uZWN0aW9uIHByb2ZpbGVzIGRvIG5vdCBoYXZlICJpZGVudGlmaWVycyIKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXRJZGVudGlmaWVyKCkgewotCQkvLyBjb25uZWN0aW9uIHByb2ZpbGVzIGRvIG5vdCBoYXZlICJpZGVudGlmaWVycyIKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIERUUERhdGFiYXNlT2JqZWN0IGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBEVFBDb25uZWN0aW9uUHJvZmlsZVdyYXBwZXIgZ2V0Q29ubmVjdGlvblByb2ZpbGUoKSB7Ci0JCXJldHVybiB0aGlzOwotCX0KLQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgRFRQRGF0YWJhc2VXcmFwcGVyIGdldERhdGFiYXNlKCkgewotCQlpZiAodGhpcy5kYXRhYmFzZSA9PSBudWxsKSB7Ci0JCQl0aGlzLmRhdGFiYXNlID0gdGhpcy5idWlsZERhdGFiYXNlKCk7Ci0JCX0KLQkJcmV0dXJuIHRoaXMuZGF0YWJhc2U7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIENvbm5lY3Rpb25Qcm9maWxlIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCS8vICoqKioqIHByb3BlcnRpZXMKLQlwdWJsaWMgU3RyaW5nIGdldFByb3ZpZGVySUQoKSB7Ci0JCXJldHVybiB0aGlzLmR0cENvbm5lY3Rpb25Qcm9maWxlLmdldFByb3ZpZGVySWQoKTsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGdldEluc3RhbmNlSUQoKSB7Ci0JCXJldHVybiB0aGlzLmR0cENvbm5lY3Rpb25Qcm9maWxlLmdldEluc3RhbmNlSUQoKTsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGdldERhdGFiYXNlTmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0UHJvcGVydHkoSUpEQkNEcml2ZXJEZWZpbml0aW9uQ29uc3RhbnRzLkRBVEFCQVNFX05BTUVfUFJPUF9JRCk7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXREYXRhYmFzZVByb2R1Y3QoKSB7Ci0JCXJldHVybiB0aGlzLmdldFByb3BlcnR5KERBVEFCQVNFX1BST0RVQ1RfUFJPUF9JRCk7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXREYXRhYmFzZVZlbmRvcigpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0UHJvcGVydHkoSUpEQkNEcml2ZXJEZWZpbml0aW9uQ29uc3RhbnRzLkRBVEFCQVNFX1ZFTkRPUl9QUk9QX0lEKTsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGdldERhdGFiYXNlVmVyc2lvbigpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0UHJvcGVydHkoSUpEQkNEcml2ZXJEZWZpbml0aW9uQ29uc3RhbnRzLkRBVEFCQVNFX1ZFUlNJT05fUFJPUF9JRCk7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXREcml2ZXJDbGFzc05hbWUoKSB7Ci0JCXJldHVybiB0aGlzLmdldFByb3BlcnR5KElKREJDRHJpdmVyRGVmaW5pdGlvbkNvbnN0YW50cy5EUklWRVJfQ0xBU1NfUFJPUF9JRCk7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXRVUkwoKSB7Ci0JCXJldHVybiB0aGlzLmdldFByb3BlcnR5KElKREJDRHJpdmVyRGVmaW5pdGlvbkNvbnN0YW50cy5VUkxfUFJPUF9JRCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0aGUgdXNlciBuYW1lLgotCSAqIEFsbG93cyB1c2VyIG5hbWUgY29tcG9zZWQgYnkgbW9yZSB0aGFuIG9uZSB3b3JkLgotCSAqIElmIHRoZSB1c2VyIG5hbWUgY29udGFpbnMgYSBrZXl3b3JkLCBpdCByZXR1cm5zIHRoZSBmaXJzdCB3b3JkIG9ubHkuCi0JICovCi0JcHVibGljIFN0cmluZyBnZXRVc2VyTmFtZSgpIHsKLQkJU3RyaW5nIHVzZXJOYW1lID0gdGhpcy5nZXRQcm9wZXJ0eShJSkRCQ0RyaXZlckRlZmluaXRpb25Db25zdGFudHMuVVNFUk5BTUVfUFJPUF9JRCk7Ci0JCXVzZXJOYW1lID0gdXNlck5hbWUudHJpbSgpOyAKLQkJU3RyaW5nW10gbmFtZXMgPSAgdXNlck5hbWUuc3BsaXQoIlxccysiKTsJLy8kTk9OLU5MUy0xJAotCQlpZihuYW1lcy5sZW5ndGggPT0gMykgeyAvLyAyMDg5NDYgaGFuZGxlIHVzZXJuYW1lIGxpa2UgInN5cyBhcyBzeXNkYmEiIG9uIE9yYWNsZQotCQkgICAgaWYodGhpcy5uYW1lSXNLZXl3b3JkKG5hbWVzWzFdKSkgewotCQkgICAgCXJldHVybiBuYW1lc1swXTsKLQkJICAgIH0KLQkJfQotCQlyZXR1cm4gdXNlck5hbWU7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXRVc2VyUGFzc3dvcmQoKSB7Ci0JCXJldHVybiB0aGlzLmdldFByb3BlcnR5KElKREJDRHJpdmVyRGVmaW5pdGlvbkNvbnN0YW50cy5QQVNTV09SRF9QUk9QX0lEKTsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGdldERyaXZlckRlZmluaXRpb25JRCgpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0UHJvcGVydHkoRFJJVkVSX0RFRklOSVRJT05fUFJPUF9JRCk7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXREcml2ZXJKYXJMaXN0KCkgewotCQlyZXR1cm4gRHJpdmVyTWFuYWdlci5nZXRJbnN0YW5jZSgpLmdldERyaXZlckluc3RhbmNlQnlJRCh0aGlzLmdldERyaXZlckRlZmluaXRpb25JRCgpKS5nZXRKYXJMaXN0KCk7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXREcml2ZXJOYW1lKCkgewotCQlyZXR1cm4gRHJpdmVyTWFuYWdlci5nZXRJbnN0YW5jZSgpLmdldERyaXZlckluc3RhbmNlQnlJRCh0aGlzLmdldERyaXZlckRlZmluaXRpb25JRCgpKS5nZXROYW1lKCk7Ci0JfQotCi0JLy8gKioqKiogY29ubmVjdGlvbgotCXB1YmxpYyBib29sZWFuIGlzQWN0aXZlKCkgewotCQlyZXR1cm4gdGhpcy5pc0Nvbm5lY3RlZCgpIHx8IHRoaXMuaXNXb3JraW5nT2ZmbGluZSgpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGlzSW5hY3RpdmUoKSB7Ci0JCXJldHVybiAhIHRoaXMuaXNBY3RpdmUoKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBpc0Nvbm5lY3RlZCgpIHsKLQkJcmV0dXJuIHRoaXMuZHRwTWFuYWdlZENvbm5lY3Rpb24uaXNDb25uZWN0ZWQoKQotCQkJCSYmICEgdGhpcy5kdHBNYW5hZ2VkQ29ubmVjdGlvbi5pc1dvcmtpbmdPZmZsaW5lKCk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaXNEaXNjb25uZWN0ZWQoKSB7Ci0JCXJldHVybiAhIHRoaXMuaXNDb25uZWN0ZWQoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBjb25uZWN0KCkgewotCQlpZiAodGhpcy5pc0Rpc2Nvbm5lY3RlZCgpKSB7Ci0JCQl0aGlzLmNoZWNrU3RhdHVzKHRoaXMuZHRwQ29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpKTsKLQkJfQotCX0KLQkKLQlwdWJsaWMgdm9pZCBkaXNjb25uZWN0KCkgewotCQl0aGlzLmNoZWNrU3RhdHVzKHRoaXMuZHRwQ29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpKTsKLQl9Ci0KLQkvLyAqKioqKiBvZmYtbGluZSBzdXBwb3J0Ci0JcHVibGljIGJvb2xlYW4gaXNXb3JraW5nT2ZmbGluZSgpIHsKLQkJcmV0dXJuIHRoaXMuZHRwTWFuYWdlZENvbm5lY3Rpb24uaXNXb3JraW5nT2ZmbGluZSgpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIHN1cHBvcnRzV29ya09mZmxpbmVNb2RlKCkgewotCQlyZXR1cm4gdGhpcy5kdHBDb25uZWN0aW9uUHJvZmlsZS5zdXBwb3J0c1dvcmtPZmZsaW5lTW9kZSgpOwotCX0KLQotCXB1YmxpYyBJU3RhdHVzIHNhdmVXb3JrT2ZmbGluZURhdGEoKSB7Ci0JCXJldHVybiB0aGlzLmR0cENvbm5lY3Rpb25Qcm9maWxlLnNhdmVXb3JrT2ZmbGluZURhdGEoKTsKLQl9Ci0JCi0JcHVibGljIGJvb2xlYW4gY2FuV29ya09mZmxpbmUoKSB7Ci0JCXJldHVybiB0aGlzLmR0cENvbm5lY3Rpb25Qcm9maWxlLmNhbldvcmtPZmZsaW5lKCk7Ci0JfQotCi0JcHVibGljIElTdGF0dXMgd29ya09mZmxpbmUoKSB7Ci0JCXJldHVybiB0aGlzLmR0cENvbm5lY3Rpb25Qcm9maWxlLndvcmtPZmZsaW5lKCk7Ci0JfQotCQotCS8vICoqKioqIGxpc3RlbmVycwotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCBhZGRDb25uZWN0aW9uTGlzdGVuZXIoQ29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCWlmICh0aGlzLmhhc05vTGlzdGVuZXJzKCkpIHsgIC8vIGZpcnN0IGxpc3RlbmVyIGFkZGVkCi0JCQl0aGlzLnN0YXJ0TGlzdGVuaW5nKCk7Ci0JCX0KLQkJdGhpcy5jb25uZWN0aW9uTGlzdGVuZXIuYWRkQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgc3RhcnRMaXN0ZW5pbmcoKSB7Ci0JCXRoaXMuZHRwTWFuYWdlZENvbm5lY3Rpb24uYWRkQ29ubmVjdGlvbkxpc3RlbmVyKHRoaXMuY29ubmVjdGlvbkxpc3RlbmVyKTsKLQkJaWYgKHRoaXMuZGF0YWJhc2UgIT0gbnVsbCkgeyAgLy8gZG9uJ3QgdHJpZ2dlciBkYXRhYmFzZSBjcmVhdGlvbgotCQkJaWYgKHRoaXMuaXNDb25uZWN0ZWQoKSkgeyAgLy8gRFRQIGRvZXMgbm90IGNoYW5nZSB3aGVuIG9mZi1saW5lCi0JCQkJdGhpcy5kYXRhYmFzZS5zdGFydExpc3RlbmluZygpOwotCQkJfQotCQl9Ci0JfQotCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIHJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJdGhpcy5jb25uZWN0aW9uTGlzdGVuZXIucmVtb3ZlQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJaWYgKHRoaXMuaGFzTm9MaXN0ZW5lcnMoKSkgeyAgLy8gbGFzdCBsaXN0ZW5lciByZW1vdmVkCi0JCQl0aGlzLnN0b3BMaXN0ZW5pbmcoKTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBzdG9wTGlzdGVuaW5nKCkgewotCQlpZiAodGhpcy5kYXRhYmFzZSAhPSBudWxsKSB7ICAvLyBkb24ndCB0cmlnZ2VyIGRhdGFiYXNlIGNyZWF0aW9uCi0JCQlpZiAodGhpcy5pc0Nvbm5lY3RlZCgpKSB7ICAvLyBEVFAgZG9lcyBub3QgY2hhbmdlIHdoZW4gb2ZmLWxpbmUKLQkJCQl0aGlzLmRhdGFiYXNlLnN0b3BMaXN0ZW5pbmcoKTsKLQkJCX0KLQkJfQotCQl0aGlzLmR0cE1hbmFnZWRDb25uZWN0aW9uLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcih0aGlzLmNvbm5lY3Rpb25MaXN0ZW5lcik7Ci0JfQotCi0JYm9vbGVhbiBoYXNOb0xpc3RlbmVycygpIHsKLQkJcmV0dXJuIHRoaXMuY29ubmVjdGlvbkxpc3RlbmVyLmhhc05vTGlzdGVuZXJzKCk7Ci0JfQotCi0JYm9vbGVhbiBoYXNBbnlMaXN0ZW5lcnMoKSB7Ci0JCXJldHVybiB0aGlzLmNvbm5lY3Rpb25MaXN0ZW5lci5oYXNBbnlMaXN0ZW5lcnMoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW50ZXJuYWwgbWV0aG9kcyAqKioqKioqKioqCi0KLQlwcml2YXRlIHZvaWQgY2hlY2tTdGF0dXMoSVN0YXR1cyBzdGF0dXMpIHsKLQkJaWYgKHN0YXR1cy5pc09LKCkpIHsKLQkJCXJldHVybjsKLQkJfQotCQlpZiAoc3RhdHVzLmlzTXVsdGlTdGF0dXMoKSkgewotCQkJZm9yIChJU3RhdHVzIGNoaWxkIDogc3RhdHVzLmdldENoaWxkcmVuKCkpIHsKLQkJCQl0aGlzLmNoZWNrU3RhdHVzKGNoaWxkKTsgIC8vIHJlY3Vyc2UsIGxvb2tpbmcgZm9yIHRoZSBmaXJzdCBlcnJvcgotCQkJfQotCQl9Ci0JCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKHN0YXR1cy5nZXRNZXNzYWdlKCksIHN0YXR1cy5nZXRFeGNlcHRpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBEVFBEYXRhYmFzZVdyYXBwZXIgYnVpbGREYXRhYmFzZSgpIHsKLQkJaWYgKHRoaXMuaXNJbmFjdGl2ZSgpKSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCi0JCWlmICh0aGlzLmlzV29ya2luZ09mZmxpbmUoKSkgewotCQkJQ29ubmVjdGlvbkluZm8gY29ubmVjdGlvbkluZm8gPSAoQ29ubmVjdGlvbkluZm8pIHRoaXMuZHRwTWFuYWdlZENvbm5lY3Rpb24uZ2V0Q29ubmVjdGlvbigpLmdldFJhd0Nvbm5lY3Rpb24oKTsKLQkJCXJldHVybiBuZXcgRFRQRGF0YWJhc2VXcmFwcGVyKHRoaXMsIGNvbm5lY3Rpb25JbmZvLmdldFNoYXJlZERhdGFiYXNlKCkpOwotCQl9Ci0KLQkJLy8gVE9ETyBzZWUgRFRQIGJ1ZyAyMDIzMDYKLQkJLy8gcGFzcyBjb25uZWN0PXRydWUgaW4gdG8gUHJvZmlsZVV0aWwuZ2V0RGF0YWJhc2UoKQotCQkvLyB0aGVyZSBpcyBhIGJ1ZyBtZW50aW9uZWQgaW4gYSBjb21tZW50OiAKLQkJLy8gICAgICJkdXJpbmcgdGhlIHByb2ZpbGUgY29ubmVjdGVkIGV2ZW50IG5vdGlmaWNhdGlvbiwgCi0JCS8vICAgICBJTWFuYWdlZENvbm5lY3Rpb24gaXMgY29ubmVjdGVkIHdoaWxlIElDb25uZWN0aW9uUHJvZmlsZSBpcyBub3QiCi0JCS8vIHNvLCBzb21lIGhhY2tlcnkgaGVyZSB0byBoYW5kbGUgaGFja2VyeSB0aGVyZQotCQlyZXR1cm4gbmV3IERUUERhdGFiYXNlV3JhcHBlcih0aGlzLCBQcm9maWxlVXRpbC5nZXREYXRhYmFzZShuZXcgRGF0YWJhc2VJZGVudGlmaWVyKHRoaXMuZ2V0TmFtZSgpLCB0aGlzLmdldERhdGFiYXNlTmFtZSgpKSwgdHJ1ZSkpOwotCX0KLQotCXN5bmNocm9uaXplZCB2b2lkIGNsZWFyRGF0YWJhc2UoKSB7Ci0JCWlmICh0aGlzLmRhdGFiYXNlICE9IG51bGwpIHsKLQkJCWlmICh0aGlzLmlzQ29ubmVjdGVkKCkpIHsgIC8vIERUUCBkb2VzIG5vdCBjaGFuZ2Ugd2hlbiBvZmYtbGluZQotCQkJCXRoaXMuZGF0YWJhc2Uuc3RvcExpc3RlbmluZygpOwotCQkJfQotCQkJdGhpcy5kYXRhYmFzZSA9IG51bGw7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBUaGlzIGlzIGNhbGxlZCB3aGVuZXZlciB3ZSBuZWVkIHRvIGZpbmQgYSBjb21wb25lbnQgYnkgaWRlbnRpZmllcgotCSAqIChlLmcuIFRhYmxlLmdldENvbHVtbkZvcklkZW50aWZpZXIoU3RyaW5nKSkuIFdlIGNoYW5uZWwgYWxsIHRoZSBjYWxscyB0byBoZXJlCi0JICogYW5kIHRoZW4gd2UgZGVsZWdhdGUgdG8gdGhlIEpQQSBwbGF0Zm9ybS1zdXBwbGllZCAiZGF0YWJhc2UgZmluZGVyIi4KLQkgKi8KLQk8VCBleHRlbmRzIERhdGFiYXNlT2JqZWN0PiBUIHNlbGVjdERhdGFiYXNlT2JqZWN0Rm9ySWRlbnRpZmllcihUW10gZGF0YWJhc2VPYmplY3RzLCBTdHJpbmcgaWRlbnRpZmllcikgewotCQlyZXR1cm4gdGhpcy5maW5kZXIuc2VsZWN0RGF0YWJhc2VPYmplY3RGb3JJZGVudGlmaWVyKGRhdGFiYXNlT2JqZWN0cywgaWRlbnRpZmllciwgdGhpcy5kYXRhYmFzZUZpbmRlckNhbGxiYWNrKTsKLQl9Ci0KLQkvKioKLQkgKiBUaGUgZGVmYXVsdCAiZGF0YWJhc2UgZmluZGVyIiBjYWxscyBiYWNrIHRvIGhlcmUgc28gd2UgY2FuIGRlbGVnYXRlIHRvCi0JICogdGhlIGRhdGFiYXNlLCB3aGljaCBjb250YWlucyBhbGwgdGhlIGluZm9ybWF0aW9uIG5lY2Vzc2FyeSB0byBwcm9wZXJseQotCSAqIG1hdGNoIGlkZW50aWZpZXJzLgotCSAqLwotCTxUIGV4dGVuZHMgRGF0YWJhc2VPYmplY3Q+IFQgc2VsZWN0RGF0YWJhc2VPYmplY3RGb3JJZGVudGlmaWVyXyhUW10gZGF0YWJhc2VPYmplY3RzLCBTdHJpbmcgaWRlbnRpZmllcikgewotCQkvLyB0aGUgZGF0YWJhc2Ugc2hvdWxkIG5vdCBiZSBudWxsIGhlcmUgLSBjYWxsIGl0cyBpbnRlcm5hbCBtZXRob2QKLQkJcmV0dXJuIHRoaXMuZGF0YWJhc2Uuc2VsZWN0RGF0YWJhc2VPYmplY3RGb3JJZGVudGlmaWVyXyhkYXRhYmFzZU9iamVjdHMsIGlkZW50aWZpZXIpOwotCX0KLQotCXZvaWQgZGF0YWJhc2VDaGFuZ2VkKERUUERhdGFiYXNlV3JhcHBlciBkYikgewotCQl0aGlzLmNvbm5lY3Rpb25MaXN0ZW5lci5kYXRhYmFzZUNoYW5nZWQoZGIpOwotCX0KLQotCXZvaWQgY2F0YWxvZ0NoYW5nZWQoRFRQQ2F0YWxvZ1dyYXBwZXIgY2F0YWxvZykgewotCQl0aGlzLmNvbm5lY3Rpb25MaXN0ZW5lci5jYXRhbG9nQ2hhbmdlZChjYXRhbG9nKTsKLQl9Ci0KLQl2b2lkIHNjaGVtYUNoYW5nZWQoRFRQU2NoZW1hV3JhcHBlciBzY2hlbWEpIHsKLQkJdGhpcy5jb25uZWN0aW9uTGlzdGVuZXIuc2NoZW1hQ2hhbmdlZChzY2hlbWEpOwotCX0KLQotCXZvaWQgc2VxdWVuY2VDaGFuZ2VkKERUUFNlcXVlbmNlV3JhcHBlciBzZXF1ZW5jZSkgewotCQl0aGlzLmNvbm5lY3Rpb25MaXN0ZW5lci5zZXF1ZW5jZUNoYW5nZWQoc2VxdWVuY2UpOwotCX0KLQotCXZvaWQgdGFibGVDaGFuZ2VkKERUUFRhYmxlV3JhcHBlciB0YWJsZSkgewotCQl0aGlzLmNvbm5lY3Rpb25MaXN0ZW5lci50YWJsZUNoYW5nZWQodGFibGUpOwotCX0KLQotCXZvaWQgY29sdW1uQ2hhbmdlZChEVFBDb2x1bW5XcmFwcGVyIGNvbHVtbikgewotCQl0aGlzLmNvbm5lY3Rpb25MaXN0ZW5lci5jb2x1bW5DaGFuZ2VkKGNvbHVtbik7Ci0JfQotCi0Jdm9pZCBmb3JlaWduS2V5Q2hhbmdlZChEVFBGb3JlaWduS2V5V3JhcHBlciBmb3JlaWduS2V5KSB7Ci0JCXRoaXMuY29ubmVjdGlvbkxpc3RlbmVyLmZvcmVpZ25LZXlDaGFuZ2VkKGZvcmVpZ25LZXkpOwotCX0KLQotCXByaXZhdGUgU3RyaW5nIGdldFByb3BlcnR5KFN0cmluZyBwcm9wZXJ0eU5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZHRwQ29ubmVjdGlvblByb2ZpbGUuZ2V0QmFzZVByb3BlcnRpZXMoKS5nZXRQcm9wZXJ0eShwcm9wZXJ0eU5hbWUpOwotCX0KLQotCXByaXZhdGUgYm9vbGVhbiBuYW1lSXNLZXl3b3JkKFN0cmluZyBuYW1lKSB7Ci0JCXJldHVybiBuYW1lLmVxdWFsc0lnbm9yZUNhc2UoImFzIik7ICAvLyROT04tTkxTLTEkCi0JfQotCi0KLQkvLyAqKioqKioqKioqIENvbXBhcmFibGUgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIGludCBjb21wYXJlVG8oQ29ubmVjdGlvblByb2ZpbGUgY29ubmVjdGlvblByb2ZpbGUpIHsKLQkJcmV0dXJuIENvbGxhdG9yLmdldEluc3RhbmNlKCkuY29tcGFyZSh0aGlzLmdldE5hbWUoKSwgY29ubmVjdGlvblByb2ZpbGUuZ2V0TmFtZSgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogb3ZlcnJpZGVzICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuZ2V0TmFtZSgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogRFRQIGNvbm5lY3Rpb24gbGlzdGVuZXIgKioqKioqKioqKgotCi0JLyoqCi0JICogVGhpcyBsaXN0ZW5lciB0cmFuc2xhdGVzIGFuZCBmb3J3YXJkcyBJTWFuYWdlZENvbm5lY3Rpb25MaXN0ZW5lciBhbmQKLQkgKiBJTWFuYWdlZENvbm5lY3Rpb25PZmZsaW5lTGlzdGVuZXIgZXZlbnRzIHRvIENvbm5lY3Rpb25MaXN0ZW5lcnMuCi0JICovCi0JY2xhc3MgTG9jYWxDb25uZWN0aW9uTGlzdGVuZXIgaW1wbGVtZW50cyBJTWFuYWdlZENvbm5lY3Rpb25PZmZsaW5lTGlzdGVuZXIgewotCQlwcml2YXRlIExpc3RlbmVyTGlzdDxDb25uZWN0aW9uTGlzdGVuZXI+IGxpc3RlbmVyTGlzdCA9IG5ldyBMaXN0ZW5lckxpc3Q8Q29ubmVjdGlvbkxpc3RlbmVyPihDb25uZWN0aW9uTGlzdGVuZXIuY2xhc3MpOwotCi0JCUxvY2FsQ29ubmVjdGlvbkxpc3RlbmVyKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCi0JCXZvaWQgYWRkQ29ubmVjdGlvbkxpc3RlbmVyKENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lcikgewotCQkJdGhpcy5saXN0ZW5lckxpc3QuYWRkKGxpc3RlbmVyKTsKLQkJfQotCi0JCXZvaWQgcmVtb3ZlQ29ubmVjdGlvbkxpc3RlbmVyKENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lcikgewotCQkJdGhpcy5saXN0ZW5lckxpc3QucmVtb3ZlKGxpc3RlbmVyKTsKLQkJfQotCi0JCWJvb2xlYW4gaGFzTm9MaXN0ZW5lcnMoKSB7Ci0JCQlyZXR1cm4gdGhpcy5saXN0ZW5lckxpc3QuaXNFbXB0eSgpOwotCQl9Ci0KLQkJYm9vbGVhbiBoYXNBbnlMaXN0ZW5lcnMoKSB7Ci0JCQlyZXR1cm4gISB0aGlzLmxpc3RlbmVyTGlzdC5pc0VtcHR5KCk7Ci0JCX0KLQotCi0JCS8vICoqKioqKioqKiogSU1hbmFnZWRDb25uZWN0aW9uTGlzdGVuZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JCS8vIG9mZi1saW5lIG9yIGluYWN0aXZlID0+IGxpdmUKLQkJcHVibGljIHZvaWQgb3BlbmVkKENvbm5lY3RFdmVudCBldmVudCkgewotCQkJLy8gZG8gbm90IGJ1aWxkIHRoZSBkYXRhYmFzZSBoZXJlIC0gaXQgaXMgYnVpbHQgb24tZGVtYW5kCi0JCQkvLyBmb3J3YXJkIGV2ZW50IHRvIGxpc3RlbmVycwotCQkJZm9yIChDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgOiB0aGlzLmxpc3RlbmVyTGlzdC5nZXRMaXN0ZW5lcnMoKSkgewotCQkJCWxpc3RlbmVyLm9wZW5lZChEVFBDb25uZWN0aW9uUHJvZmlsZVdyYXBwZXIudGhpcyk7Ci0JCQl9Ci0JCX0KLQotCQkvKioKLQkJICogVGhpcyBtZXRob2QgaXMgbmV2ZXIgY2FsbGVkIGZyb20gdGhlIGJhc2UgRFRQIGNvZGUuCi0JCSAqIFBlcmhhcHMgRFRQIGV4dGVuZGVycyBjYWxsIGl0Li4uLgotCQkgKiBAc2VlIE1hbmFnZWRDb25uZWN0aW9uI2ZpcmVNb2RpZmllZEV2ZW50KE9iamVjdCkKLQkJICogICAgIHdoaWNoIGlzIG5ldmVyIGNhbGxlZC4uLgotCQkgKi8KLQkJcHVibGljIHZvaWQgbW9kaWZpZWQoQ29ubmVjdEV2ZW50IGV2ZW50KSB7Ci0JCQkvLyBmb3J3YXJkIGV2ZW50IHRvIGxpc3RlbmVycwotCQkJZm9yIChDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgOiB0aGlzLmxpc3RlbmVyTGlzdC5nZXRMaXN0ZW5lcnMoKSkgewotCQkJCWxpc3RlbmVyLm1vZGlmaWVkKERUUENvbm5lY3Rpb25Qcm9maWxlV3JhcHBlci50aGlzKTsKLQkJCX0KLQkJfQotCi0JCXB1YmxpYyBib29sZWFuIG9rVG9DbG9zZShDb25uZWN0RXZlbnQgZXZlbnQpIHsKLQkJCS8vIGZvcndhcmQgZXZlbnQgdG8gbGlzdGVuZXJzCi0JCQlmb3IgKENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lciA6IHRoaXMubGlzdGVuZXJMaXN0LmdldExpc3RlbmVycygpKSB7Ci0JCQkJaWYgKCAhIGxpc3RlbmVyLm9rVG9DbG9zZShEVFBDb25uZWN0aW9uUHJvZmlsZVdyYXBwZXIudGhpcykpIHsKLQkJCQkJcmV0dXJuIGZhbHNlOwotCQkJCX0KLQkJCX0KLQkJCXJldHVybiB0cnVlOwotCQl9Ci0KLQkJcHVibGljIHZvaWQgYWJvdXRUb0Nsb3NlKENvbm5lY3RFdmVudCBldmVudCkgewotCQkJLy8gZm9yd2FyZCBldmVudCB0byBsaXN0ZW5lcnMKLQkJCWZvciAoQ29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyIDogdGhpcy5saXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJzKCkpIHsKLQkJCQlsaXN0ZW5lci5hYm91dFRvQ2xvc2UoRFRQQ29ubmVjdGlvblByb2ZpbGVXcmFwcGVyLnRoaXMpOwotCQkJfQotCQl9Ci0KLQkJLy8gbGl2ZSBvciBvZmYtbGluZSA9PiBpbmFjdGl2ZQotCQlwdWJsaWMgdm9pZCBjbG9zZWQoQ29ubmVjdEV2ZW50IGV2ZW50KSB7Ci0JCQkvLyBjbGVhciB0aGUgZGF0YWJhc2UKLQkJCURUUENvbm5lY3Rpb25Qcm9maWxlV3JhcHBlci50aGlzLmNsZWFyRGF0YWJhc2UoKTsKLQkJCS8vIGZvcndhcmQgZXZlbnQgdG8gbGlzdGVuZXJzCi0JCQlmb3IgKENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lciA6IHRoaXMubGlzdGVuZXJMaXN0LmdldExpc3RlbmVycygpKSB7Ci0JCQkJbGlzdGVuZXIuY2xvc2VkKERUUENvbm5lY3Rpb25Qcm9maWxlV3JhcHBlci50aGlzKTsKLQkJCX0KLQkJfQotCi0KLQkJLy8gKioqKioqKioqKiBJTWFuYWdlZENvbm5lY3Rpb25PZmZsaW5lTGlzdGVuZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JCS8vIGxpdmUgPT4gb2ZmLWxpbmUKLQkJcHVibGljIGJvb2xlYW4gb2tUb0RldGFjaChDb25uZWN0RXZlbnQgZXZlbnQpIHsKLQkJCS8vIGNvbnZlcnQgdGhlIGV2ZW50IHRvIGFuICJvayB0byBjbG9zZSIgZXZlbnQ7Ci0JCQkvLyB3ZSBhcmUgImNsb3NpbmciIHRoZSBsaXZlIGNvbm5lY3Rpb24KLQkJCXJldHVybiB0aGlzLm9rVG9DbG9zZShldmVudCk7Ci0JCX0KLQkJCi0JCS8vIGxpdmUgPT4gb2ZmLWxpbmUKLQkJcHVibGljIHZvaWQgYWJvdXRUb0RldGFjaChDb25uZWN0RXZlbnQgZXZlbnQpIHsKLQkJCS8vIGNvbnZlcnQgdGhlIGV2ZW50IHRvIGEgImNsb3NlIiBldmVudDsKLQkJCS8vIHdlIGFyZSAiY2xvc2luZyIgdGhlIGxpdmUgY29ubmVjdGlvbgotCQkJdGhpcy5jbG9zZWQoZXZlbnQpOwotCQl9Ci0KLQkJLy8gaW5hY3RpdmUgb3IgbGl2ZSA9PiBvZmYtbGluZQotCQlwdWJsaWMgdm9pZCB3b3JraW5nT2ZmbGluZShDb25uZWN0RXZlbnQgZXZlbnQpIHsKLQkJCS8vIGNvbnZlcnQgdGhlIGV2ZW50IHRvIGFuICJvcGVuIiBldmVudDsKLQkJCS8vIHdlIGFyZSAib3BlbmluZyIgdGhlIG9mZi1saW5lIGNvbm5lY3Rpb24KLQkJCXRoaXMub3BlbmVkKGV2ZW50KTsKLQkJfQotCi0JCS8vIG9mZi1saW5lID0+IGxpdmUKLQkJcHVibGljIHZvaWQgYWJvdXRUb0F0dGFjaChDb25uZWN0RXZlbnQgZXZlbnQpIHsKLQkJCS8vIGNvbnZlcnQgdGhlIGV2ZW50IHRvIGFuICJjbG9zZSIgZXZlbnQ7Ci0JCQkvLyB3ZSBhcmUgImNsb3NpbmciIHRoZSBvZmYtbGluZSBjb25uZWN0aW9uCi0JCQl0aGlzLmNsb3NlZChldmVudCk7Ci0JCX0KLQotCi0JCS8vICoqKioqKioqKiogaW50ZXJuYWwgbWV0aG9kcyAqKioqKioqKioqCi0KLQkJdm9pZCBkYXRhYmFzZUNoYW5nZWQoRFRQRGF0YWJhc2VXcmFwcGVyIGRiKSB7Ci0JCQlmb3IgKENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lciA6IHRoaXMubGlzdGVuZXJMaXN0LmdldExpc3RlbmVycygpKSB7Ci0JCQkJbGlzdGVuZXIuZGF0YWJhc2VDaGFuZ2VkKERUUENvbm5lY3Rpb25Qcm9maWxlV3JhcHBlci50aGlzLCBkYik7Ci0JCQl9Ci0JCX0KLQotCQl2b2lkIGNhdGFsb2dDaGFuZ2VkKERUUENhdGFsb2dXcmFwcGVyIGNhdGFsb2cpIHsKLQkJCWZvciAoQ29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyIDogdGhpcy5saXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJzKCkpIHsKLQkJCQlsaXN0ZW5lci5jYXRhbG9nQ2hhbmdlZChEVFBDb25uZWN0aW9uUHJvZmlsZVdyYXBwZXIudGhpcywgY2F0YWxvZyk7Ci0JCQl9Ci0JCX0KLQotCQl2b2lkIHNjaGVtYUNoYW5nZWQoRFRQU2NoZW1hV3JhcHBlciBzY2hlbWEpIHsKLQkJCWZvciAoQ29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyIDogdGhpcy5saXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJzKCkpIHsKLQkJCQlsaXN0ZW5lci5zY2hlbWFDaGFuZ2VkKERUUENvbm5lY3Rpb25Qcm9maWxlV3JhcHBlci50aGlzLCBzY2hlbWEpOwotCQkJfQotCQl9Ci0KLQkJdm9pZCBzZXF1ZW5jZUNoYW5nZWQoRFRQU2VxdWVuY2VXcmFwcGVyIHNlcXVlbmNlKSB7Ci0JCQlmb3IgKENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lciA6IHRoaXMubGlzdGVuZXJMaXN0LmdldExpc3RlbmVycygpKSB7Ci0JCQkJbGlzdGVuZXIuc2VxdWVuY2VDaGFuZ2VkKERUUENvbm5lY3Rpb25Qcm9maWxlV3JhcHBlci50aGlzLCBzZXF1ZW5jZSk7Ci0JCQl9Ci0JCX0KLQotCQl2b2lkIHRhYmxlQ2hhbmdlZChEVFBUYWJsZVdyYXBwZXIgdGFibGUpIHsKLQkJCWZvciAoQ29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyIDogdGhpcy5saXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJzKCkpIHsKLQkJCQlsaXN0ZW5lci50YWJsZUNoYW5nZWQoRFRQQ29ubmVjdGlvblByb2ZpbGVXcmFwcGVyLnRoaXMsIHRhYmxlKTsKLQkJCX0KLQkJfQotCi0JCXZvaWQgY29sdW1uQ2hhbmdlZChEVFBDb2x1bW5XcmFwcGVyIGNvbHVtbikgewotCQkJZm9yIChDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgOiB0aGlzLmxpc3RlbmVyTGlzdC5nZXRMaXN0ZW5lcnMoKSkgewotCQkJCWxpc3RlbmVyLmNvbHVtbkNoYW5nZWQoRFRQQ29ubmVjdGlvblByb2ZpbGVXcmFwcGVyLnRoaXMsIGNvbHVtbik7Ci0JCQl9Ci0JCX0KLQotCQl2b2lkIGZvcmVpZ25LZXlDaGFuZ2VkKERUUEZvcmVpZ25LZXlXcmFwcGVyIGZvcmVpZ25LZXkpIHsKLQkJCWZvciAoQ29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyIDogdGhpcy5saXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJzKCkpIHsKLQkJCQlsaXN0ZW5lci5mb3JlaWduS2V5Q2hhbmdlZChEVFBDb25uZWN0aW9uUHJvZmlsZVdyYXBwZXIudGhpcywgZm9yZWlnbktleSk7Ci0JCQl9Ci0JCX0KLQotCX0KLQotCi0JLy8gKioqKioqKioqKiBkZWZhdWx0IERhdGFiYXNlRmluZGVyICoqKioqKioqKioKLQotCWNsYXNzIERhdGFiYXNlRmluZGVyQ2FsbGJhY2sgaW1wbGVtZW50cyBEYXRhYmFzZUZpbmRlci5EZWZhdWx0Q2FsbGJhY2sgewotCQlwdWJsaWMgPFQgZXh0ZW5kcyBEYXRhYmFzZU9iamVjdD4gVCBzZWxlY3REYXRhYmFzZU9iamVjdEZvcklkZW50aWZpZXIoVFtdIGRhdGFiYXNlT2JqZWN0cywgU3RyaW5nIGlkZW50aWZpZXIpIHsKLQkJCS8vIGNhbGwgYmFjayB0byB0aGUgaW50ZXJuYWwgbWV0aG9kCi0JCQlyZXR1cm4gRFRQQ29ubmVjdGlvblByb2ZpbGVXcmFwcGVyLnRoaXMuc2VsZWN0RGF0YWJhc2VPYmplY3RGb3JJZGVudGlmaWVyXyhkYXRhYmFzZU9iamVjdHMsIGlkZW50aWZpZXIpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC9EVFBEYXRhYmFzZU9iamVjdC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvRFRQRGF0YWJhc2VPYmplY3QuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzk3NmZlNC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC9EVFBEYXRhYmFzZU9iamVjdC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWw7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuRGF0YWJhc2VPYmplY3Q7Ci0KLS8qKgotICogRFRQIGRhdGFiYXNlIG9iamVjdAotICovCi1wdWJsaWMgaW50ZXJmYWNlIERUUERhdGFiYXNlT2JqZWN0IGV4dGVuZHMgRGF0YWJhc2VPYmplY3QgewotCi0JLyoqCi0JICogY292YXJpYW50IG92ZXJyaWRlCi0JICovCi0JRFRQQ29ubmVjdGlvblByb2ZpbGVXcmFwcGVyIGdldENvbm5lY3Rpb25Qcm9maWxlKCk7Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL0RUUERhdGFiYXNlT2JqZWN0V3JhcHBlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvRFRQRGF0YWJhc2VPYmplY3RXcmFwcGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDg2ZDJkMmMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvRFRQRGF0YWJhc2VPYmplY3RXcmFwcGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxOTAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWw7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LnNxbS5jb3JlLnJ0ZS5JQ2F0YWxvZ09iamVjdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LnNxbS5jb3JlLnJ0ZS5JQ2F0YWxvZ09iamVjdExpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuc3FtLmNvcmUucnRlLlJlZnJlc2hNYW5hZ2VyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5EYXRhYmFzZU9iamVjdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotLyoqCi0gKiAgRFRQIENhdGFsb2cgT2JqZWN0IFdyYXBwZXIgYmFzZSBjbGFzcwotICovCi1hYnN0cmFjdCBjbGFzcyBEVFBEYXRhYmFzZU9iamVjdFdyYXBwZXIKLQlpbXBsZW1lbnRzIERUUERhdGFiYXNlT2JqZWN0Ci17Ci0JLy8gd2UgbmVlZCBhIHdheSB0byBnZXQgdG8gdGhlIGNvbm5lY3Rpb24gcHJvZmlsZQotCXByaXZhdGUgZmluYWwgRFRQRGF0YWJhc2VPYmplY3QgcGFyZW50OwotCi0JLy8gbGlzdGVuIGZvciB0aGUgImNhdGFsb2cgb2JqZWN0IiBiZWluZyByZWZyZXNoZWQKLQlwcml2YXRlIGZpbmFsIElDYXRhbG9nT2JqZWN0TGlzdGVuZXIgY2F0YWxvZ09iamVjdExpc3RlbmVyOwotCi0JLy8gbGlzdGVuIGZvciB0aGlzIERUUCBjYXRhbG9nIG9iamVjdCB0byByZWZyZXNoCi0JZmluYWwgSUNhdGFsb2dPYmplY3QgY2F0YWxvZ09iamVjdDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3Rpb24vaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JRFRQRGF0YWJhc2VPYmplY3RXcmFwcGVyKERUUERhdGFiYXNlT2JqZWN0IHBhcmVudCwgT2JqZWN0IGR0cE9iamVjdCkgewotCQlzdXBlcigpOwotCQl0aGlzLnBhcmVudCA9IHBhcmVudDsKLQkJaWYgKHRoaXMuZ2V0Q29ubmVjdGlvblByb2ZpbGUoKS5pc0Nvbm5lY3RlZCgpKSB7Ci0JCQkvLyB3ZSBvbmx5IGxpc3RlbiB0byAibGl2ZSIgY29ubmVjdGlvbnMgKGFzIG9wcG9zZWQgdG8gIm9mZi1saW5lIiBjb25uZWN0aW9ucyk7Ci0JCQkvLyBhbmQgdGhlIG1vZGVsIGlzIHJlYnVpbHQgd2hlbiB0aGUgY29ubmVjdGlvbiBjb25uZWN0cyBvciBkaXNjb25uZWN0cwotCQkJdGhpcy5jYXRhbG9nT2JqZWN0ID0gKElDYXRhbG9nT2JqZWN0KSBkdHBPYmplY3Q7Ci0JCQl0aGlzLmNhdGFsb2dPYmplY3RMaXN0ZW5lciA9IHRoaXMuYnVpbGRDYXRhbG9nT2JqZWN0TGlzdGVuZXIoKTsKLQkJCWlmICh0aGlzLmdldENvbm5lY3Rpb25Qcm9maWxlKCkuaGFzQW55TGlzdGVuZXJzKCkpIHsKLQkJCQl0aGlzLnN0YXJ0TGlzdGVuaW5nKCk7Ci0JCQl9Ci0JCX0gZWxzZSB7Ci0JCQl0aGlzLmNhdGFsb2dPYmplY3QgPSBudWxsOwotCQkJdGhpcy5jYXRhbG9nT2JqZWN0TGlzdGVuZXIgPSBudWxsOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBJQ2F0YWxvZ09iamVjdExpc3RlbmVyIGJ1aWxkQ2F0YWxvZ09iamVjdExpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IElDYXRhbG9nT2JqZWN0TGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBub3RpZnlDaGFuZ2VkKElDYXRhbG9nT2JqZWN0IGRtRWxlbWVudCwgaW50IGV2ZW50VHlwZSkgewotCQkJCWlmIChkbUVsZW1lbnQgPT0gRFRQRGF0YWJhc2VPYmplY3RXcmFwcGVyLnRoaXMuY2F0YWxvZ09iamVjdCkgewotCQkJCQkvLyAnZXZlbnRUeXBlJyBkb2Vzbid0IHNlZW0gdG8gYmUgdmVyeSB1c2VmdWwsIHNvIGRyb3AgaXQKLQkJCQkJRFRQRGF0YWJhc2VPYmplY3RXcmFwcGVyLnRoaXMuY2F0YWxvZ09iamVjdENoYW5nZWQoKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCi0JLy8gdHlwaWNhbGx5LCBub3RpZnkgdGhlIGNvbm5lY3Rpb24gcHJvZmlsZSBzb21ldGhpbmcgaGFzIGNoYW5nZWQKLQl2b2lkIGNhdGFsb2dPYmplY3RDaGFuZ2VkKCkgewotCQl0aGlzLmNsZWFyKCk7Ci0JfQotCi0JLyoqCi0JICogVGhlIERUUCBvYmplY3QgaGFzIGNoYW5nZWQsIGNsZWFyIHRoZSB3cmFwcGVyJ3Mgc3RhdGUgc28gaXQgd2lsbCBiZQotCSAqIHN5bmNocm9uaXplZCBvbi1kZW1hbmQuCi0JICovCi0JYWJzdHJhY3Qgdm9pZCBjbGVhcigpOwotCi0KLQotCS8vICoqKioqKioqKiogcXVlcmllcyAqKioqKioqKioqCi0KLQlEVFBEYXRhYmFzZU9iamVjdCBnZXRQYXJlbnQoKSB7Ci0JCXJldHVybiB0aGlzLnBhcmVudDsKLQl9Ci0KLQlwdWJsaWMgRFRQQ29ubmVjdGlvblByb2ZpbGVXcmFwcGVyIGdldENvbm5lY3Rpb25Qcm9maWxlKCkgewotCQlyZXR1cm4gdGhpcy5wYXJlbnQuZ2V0Q29ubmVjdGlvblByb2ZpbGUoKTsKLQl9Ci0KLQlwdWJsaWMgRFRQRGF0YWJhc2VXcmFwcGVyIGdldERhdGFiYXNlKCkgewotCQlyZXR1cm4gdGhpcy5nZXRDb25uZWN0aW9uUHJvZmlsZSgpLmdldERhdGFiYXNlKCk7Ci0JfQotCi0JLyoqCi0JICogVGhpcyBpcyBjYWxsZWQgYnkgd2hlbmV2ZXIgd2UgbmVlZCB0byBmaW5kIGEgY29tcG9uZW50IGJ5IGlkZW50aWZpZXIKLQkgKiAoZS5nLiBUYWJsZS5nZXRDb2x1bW5Gb3JJZGVudGlmaWVyKFN0cmluZykpLiBXZSBjaGFubmVsIGFsbCB0aGUgY2FsbHMgdG8gdGhlCi0JICogY29ubmVjdGlvbiBwcm9maWxlLCB3aGljaCB0aGVuIGRlbGVnYXRlcyB0byB0aGUgSlBBIHBsYXRmb3JtLXN1cHBsaWVkCi0JICogImRhdGFiYXNlIGZpbmRlciIuCi0JICovCi0JPFQgZXh0ZW5kcyBEYXRhYmFzZU9iamVjdD4gVCBzZWxlY3REYXRhYmFzZU9iamVjdEZvcklkZW50aWZpZXIoVFtdIGRhdGFiYXNlT2JqZWN0cywgU3RyaW5nIGlkZW50aWZpZXIpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q29ubmVjdGlvblByb2ZpbGUoKS5zZWxlY3REYXRhYmFzZU9iamVjdEZvcklkZW50aWZpZXIoZGF0YWJhc2VPYmplY3RzLCBpZGVudGlmaWVyKTsKLQl9Ci0KLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICovCi0JPFQgZXh0ZW5kcyBEYXRhYmFzZU9iamVjdD4gVCBzZWxlY3REYXRhYmFzZU9iamVjdE5hbWVkKFRbXSBkYXRhYmFzZU9iamVjdHMsIFN0cmluZyBuYW1lKSB7Ci0JCWZvciAoVCBkYk9iamVjdCA6IGRhdGFiYXNlT2JqZWN0cykgewotCQkJaWYgKGRiT2JqZWN0LmdldE5hbWUoKS5lcXVhbHMobmFtZSkpIHsKLQkJCQlyZXR1cm4gZGJPYmplY3Q7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIG51bGw7Ci0JfQotCi0JLyoqCi0JICogRXhhbXBsZXM6Ci0JICogT3JhY2xlIGV0Yy4KLQkgKiAgICAgVGFibGUoRk9PKSB2cy4gIkZvbyIgPT4gbnVsbAotCSAqICAgICBUYWJsZShCQVIpIHZzLiAiRm9vIiA9PiAiQkFSIgotCSAqICAgICBUYWJsZShGb28pIHZzLiAiRm9vIiA9PiAiXCJGb29cIiIKLQkgKiAgICAgVGFibGUoQmFyKSB2cy4gIkZvbyIgPT4gIlwiQmFyXCIiCi0JICogICAgIAotCSAqIFBvc3RncmVTUUwgZXRjLgotCSAqICAgICBUYWJsZShmb28pIHZzLiAiRm9vIiA9PiBudWxsCi0JICogICAgIFRhYmxlKGJhcikgdnMuICJGb28iID0+ICJiYXIiCi0JICogICAgIFRhYmxlKEZvbykgdnMuICJGb28iID0+ICJcIkZvb1wiIgotCSAqICAgICBUYWJsZShCYXIpIHZzLiAiRm9vIiA9PiAiXCJCYXJcIiIKLQkgKiAgICAgCi0JICogU1FMIFNlcnZlciBldGMuCi0JICogICAgIFRhYmxlKEZvbykgdnMuICJGb28iID0+IG51bGwKLQkgKiAgICAgVGFibGUoZm9vKSB2cy4gIkZvbyIgPT4gImZvbyIKLQkgKiAgICAgVGFibGUoYmFyKSB2cy4gIkZvbyIgPT4gImJhciIKLQkgKiAgICAgVGFibGUoQmFyKSB2cy4gIkZvbyIgPT4gIkJhciIKLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdldElkZW50aWZpZXIoU3RyaW5nIGRlZmF1bHROYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldERhdGFiYXNlKCkuY29udmVydE5hbWVUb0lkZW50aWZpZXIodGhpcy5nZXROYW1lKCksIGRlZmF1bHROYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBFeGFtcGxlczoKLQkgKiBPcmFjbGUgZXRjLgotCSAqICAgICBUYWJsZShGT08pID0+ICJGT08iCi0JICogICAgIFRhYmxlKEZvbykgPT4gIlwiRm9vXCIiCi0JICogICAgIFRhYmxlKGZvbykgPT4gIlwiZm9vXCIiCi0JICogICAgIFRhYmxlKGZvbysrKSA9PiAiXCJmb28rK1wiIgotCSAqICAgICBUYWJsZShmIm8pID0+ICJcImZcIlwibysrXCIiIChpLmUuICJmIiJvIikKLQkgKiAgICAgCi0JICogUG9zdGdyZVNRTCBldGMuCi0JICogICAgIFRhYmxlKEZPTykgPT4gIlwiRk9PXCIiCi0JICogICAgIFRhYmxlKEZvbykgPT4gIlwiRm9vXCIiCi0JICogICAgIFRhYmxlKGZvbykgPT4gImZvbyIKLQkgKiAgICAgVGFibGUoZm9vKyspID0+ICJcImZvbysrXCIiCi0JICogICAgIFRhYmxlKGYibykgPT4gIlwiZlwiXCJvKytcIiIgKGkuZS4gImYiIm8iKQotCSAqICAgICAKLQkgKiBTUUwgU2VydmVyIGV0Yy4KLQkgKiAgICAgVGFibGUoRk9PKSA9PiAiRk9PIgotCSAqICAgICBUYWJsZShGb28pID0+ICJGb28iCi0JICogICAgIFRhYmxlKGZvbykgPT4gImZvbyIKLQkgKiAgICAgVGFibGUoZm9vKyspID0+ICJcImZvbysrXCIiCi0JICogICAgIFRhYmxlKGYibykgPT4gIlwiZlwiXCJvKytcIiIgKGkuZS4gImYiIm8iKQotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0SWRlbnRpZmllcigpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0RGF0YWJhc2UoKS5jb252ZXJ0TmFtZVRvSWRlbnRpZmllcih0aGlzLmdldE5hbWUoKSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5nZXROYW1lKCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBsaXN0ZW5pbmcgdG8gRFRQIGRhdGFiYXNlIG9iamVjdCAqKioqKioqKioqCi0KLQkvLyB0aGlzIHNob3VsZCBvbmx5IGJlIGNhbGxlZCB3aGVuIHRoZSBjb25uZWN0aW9uIHByb2ZpbGUgaXMgImxpdmUiIGFuZCBoYXMgbGlzdGVuZXJzCi0Jdm9pZCBzdGFydExpc3RlbmluZygpIHsKLQkJdGhpcy5jaGVja0xpc3RlbmVyKCk7Ci0JCVJlZnJlc2hNYW5hZ2VyLmdldEluc3RhbmNlKCkuQWRkTGlzdGVuZXIodGhpcy5jYXRhbG9nT2JqZWN0LCB0aGlzLmNhdGFsb2dPYmplY3RMaXN0ZW5lcik7Ci0JfQotCi0JLy8gdGhpcyBzaG91bGQgb25seSBiZSBjYWxsZWQgd2hlbiB0aGUgY29ubmVjdGlvbiBwcm9maWxlIGlzICJsaXZlIiBhbmQgaGFzIG5vIGxpc3RlbmVycwotCXZvaWQgc3RvcExpc3RlbmluZygpIHsKLQkJdGhpcy5jaGVja0xpc3RlbmVyKCk7Ci0gICAgICAgIFJlZnJlc2hNYW5hZ2VyLmdldEluc3RhbmNlKCkucmVtb3ZlTGlzdGVuZXIodGhpcy5jYXRhbG9nT2JqZWN0LCB0aGlzLmNhdGFsb2dPYmplY3RMaXN0ZW5lcik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGNoZWNrTGlzdGVuZXIoKSB7Ci0JCWlmICh0aGlzLmNhdGFsb2dPYmplY3RMaXN0ZW5lciA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJ0aGUgY2F0YWxvZyBsaXN0ZW5lciBpcyBudWxsIik7ICAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL0RUUERhdGFiYXNlV3JhcHBlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvRFRQRGF0YWJhc2VXcmFwcGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDcxZjdkYzQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvRFRQRGF0YWJhc2VXcmFwcGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNzIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLnRleHQuQ29sbGF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5zcW0uY29yZS5kZWZpbml0aW9uLkRhdGFiYXNlRGVmaW5pdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LnNxbS5pbnRlcm5hbC5jb3JlLlJEQkNvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkNhdGFsb2c7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkRhdGFiYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5EYXRhYmFzZU9iamVjdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWwudmVuZG9yLlZlbmRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWwudmVuZG9yLlZlbmRvclJlcG9zaXRvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5BcnJheUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5UcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yOwotCi0vKioKLSAqIFdyYXAgYSBEVFAgRGF0YWJhc2UuCi0gKiAKLSAqIENhdGFsb2dzIHZzLiBTY2hlbWF0YToKLSAqIFR5cGljYWxseSwgaWYgYSBEVFAgZGF0YWJhc2UgZG9lcyBub3Qgc3VwcG9ydCAiY2F0YWxvZ3MiLAotICogby5lLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5EYXRhYmFzZSNnZXRDYXRhbG9ncygpIHdpbGwgcmV0dXJuIGEKLSAqIHNpbmdsZSBjYXRhbG9nIHdpdGhvdXQgYSBuYW1lIChhY3R1YWxseSwgaXQncyBhbiBlbXB0eSBzdHJpbmcpLiBUaGlzIGNhdGFsb2cKLSAqIHdpbGwgY29udGFpbiBhbGwgdGhlIGRhdGFiYXNlJ3Mgc2NoZW1hdGEuIFdlIHRyeSB0byBpZ25vcmUgdGhpcyBjYXRhbG9nIGFuZAotICogcmV0dXJuIHRoZSBzY2hlbWF0YSBmcm9tIHRoZSBkYXRhYmFzZSBkaXJlY3RseS4KLSAqIAotICogQ2F0YWxvZyBOb3RlIDE6Ci0gKiBBcyBvZiBKYW4gMjAwOSwgdGhlIERUUCBNeVNRTCBkcml2ZXIgaXMgbm90IGNvbnNpc3RlbnQgd2l0aCB0aGlzIHBhdHRlcm4uCi0gKiBBIERUUCBNeVNRTCBkYXRhYmFzZSBoYXMgKm5vKiBjYXRhbG9nczsgaXQgaG9sZHMgYSBzaW5nbGUgc2NoZW1hCi0gKiBkaXJlY3RseSwgYW5kIHRoYXQgc2NoZW1hIGhhcyB0aGUgc2FtZSBuYW1lIGFzIHRoZSBkYXRhYmFzZS4gU2VlIGJ1ZyAyNDkwMTMuCi0gKiAKLSAqIENhdGFsb2cgTm90ZSAyOgotICogQXMgb2YgSmFuIDIwMDksIHRoZSBQb3N0Z3JlU1FMIEpEQkMgZHJpdmVyIGNvbXBsaWNhdGVzIHRoaXMgcGF0dGVybiBhIGJpdC4KLSAqIEV2ZW4gdGhvdWdoIFBvc3RncmVTUUwgZG9lcyBub3Qgc3VwcG9ydCAiY2F0YWxvZ3MiLCBpdHMgSkRCQyBkcml2ZXIKLSAqIHJldHVybnMgYSBzaW5nbGUgY2F0YWxvZyB0aGF0IGhhcyB0aGUgc2FtZSBuYW1lIGFzIHRoZSBkYXRhYmFzZSBzcGVjaWZpZWQKLSAqIGluIHRoZSBKREJDIGNvbm5lY3Rpb24gVVJMLiBUaGUgRFRQIFBvc3RncmVTUUwgZHJpdmVyIHNpbXBseSByZXBsaWNhdGVzIHRoaXMKLSAqIGJlaGF2aW9yLiBVbmZvcnR1bmF0ZWx5LCB0aGlzIGNhdGFsb2cgY2FuIGJlIHVubmFtZWQ7IGkuZS4gaXRzIG5hbWUgaXMgYW4KLSAqIGVtcHR5IHN0cmluZy4uLi4KLSAqIAotICogKFlldCBBbm90aGVyKSBOb3RlOgotICogV2UgdXNlICJuYW1lIiB3aGVuIGRlYWxpbmcgd2l0aCB0aGUgdW5tb2RpZmllZCBuYW1lIG9mIGEgZGF0YWJhc2Ugb2JqZWN0Ci0gKiBhcyBzdXBwbGllZCBieSB0aGUgZGF0YWJhc2UgaXRzZWxmIChpLmUuIGl0IGlzIG5vdCBkZWxpbWl0ZWQgYW5kIGl0IGlzIGFsd2F5cwotICogY2FzZS1zZW5zaXRpdmUpLgotICogV2UgdXNlICJpZGVudGlmaWVyIiB3aGVuIGRlYWxpbmcgd2l0aCBhIHN0cmluZyByZXByZXNlbnRhdGlvbiBvZiBhIGRhdGFiYXNlCi0gKiBvYmplY3QgbmFtZSAoaS5lLiBpdCBtYXkgYmUgZGVsaW1pdGVkIGFuZCwgZGVwZW5kaW5nIG9uIHRoZSB2ZW5kb3IsIGl0IG1heQotICogYmUgY2FzZS1pbnNlbnNpdGl2ZSkuCi0gKi8KLWZpbmFsIGNsYXNzIERUUERhdGFiYXNlV3JhcHBlcgotCWV4dGVuZHMgRFRQU2NoZW1hQ29udGFpbmVyV3JhcHBlcgotCWltcGxlbWVudHMgRGF0YWJhc2UKLXsKLQkvLyB0aGUgd3JhcHBlZCBEVFAgZGF0YWJhc2UKLQlwcml2YXRlIGZpbmFsIG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5EYXRhYmFzZSBkdHBEYXRhYmFzZTsKLQotCS8vIHZlbmRvci1zcGVjaWZpYyBiZWhhdmlvcgotCXByaXZhdGUgZmluYWwgVmVuZG9yIHZlbmRvcjsKLQotCS8vIGxhenktaW5pdGlhbGl6ZWQsIHNvcnRlZAotCXByaXZhdGUgRFRQQ2F0YWxvZ1dyYXBwZXJbXSBjYXRhbG9nczsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvciAqKioqKioqKioqCi0KLQlEVFBEYXRhYmFzZVdyYXBwZXIoRFRQQ29ubmVjdGlvblByb2ZpbGVXcmFwcGVyIGNvbm5lY3Rpb25Qcm9maWxlLCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuRGF0YWJhc2UgZHRwRGF0YWJhc2UpIHsKLQkJc3VwZXIoY29ubmVjdGlvblByb2ZpbGUsIGR0cERhdGFiYXNlKTsKLQkJdGhpcy5kdHBEYXRhYmFzZSA9IGR0cERhdGFiYXNlOwotCQl0aGlzLnZlbmRvciA9IFZlbmRvclJlcG9zaXRvcnkuaW5zdGFuY2UoKS5nZXRWZW5kb3IodGhpcy5nZXRWZW5kb3JOYW1lKCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBEVFBXcmFwcGVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCS8qIFRPRE8KLQkgKiBXZSBtaWdodCB3YW50IHRvIGxpc3RlbiB0byB0aGUgInZpcnR1YWwiIGNhdGFsb2c7IGJ1dCB0aGF0J3MgcHJvYmFibHkKLQkgKiBub3QgbmVjZXNzYXJ5IHNpbmNlIHRoZXJlIGlzIG5vdCBlYXN5IHdheSBmb3IgdGhlIHVzZXIgdG8gcmVmcmVzaCBpdAotCSAqIChpLmUuIGl0IGlzIG5vdCBkaXNwbGF5ZWQgaW4gdGhlIERUUCBVSSkuCi0JICovCi0JQE92ZXJyaWRlCi0Jc3luY2hyb25pemVkIHZvaWQgY2F0YWxvZ09iamVjdENoYW5nZWQoKSB7Ci0JCXN1cGVyLmNhdGFsb2dPYmplY3RDaGFuZ2VkKCk7Ci0JCXRoaXMuZ2V0Q29ubmVjdGlvblByb2ZpbGUoKS5kYXRhYmFzZUNoYW5nZWQodGhpcyk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIERUUERhdGFiYXNlV3JhcHBlciBnZXREYXRhYmFzZSgpIHsKLQkJcmV0dXJuIHRoaXM7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIERUUFNjaGVtYUNvbnRhaW5lcldyYXBwZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JTGlzdDxvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuU2NoZW1hPiBnZXREVFBTY2hlbWF0YSgpIHsKLQkJcmV0dXJuIHRoaXMudmVuZG9yLmdldFNjaGVtYXModGhpcy5kdHBEYXRhYmFzZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JRFRQU2NoZW1hV3JhcHBlciBnZXRTY2hlbWEob3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLlNjaGVtYSBkdHBTY2hlbWEpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0U2NoZW1hXyhkdHBTY2hlbWEpOwotCX0KLQotCURUUFNjaGVtYVdyYXBwZXIgZ2V0U2NoZW1hRnJvbUNhdGFsb2dzKG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5TY2hlbWEgZHRwU2NoZW1hKSB7Ci0JCXJldHVybiB0aGlzLmdldENhdGFsb2coZHRwU2NoZW1hLmdldENhdGFsb2coKSkuZ2V0U2NoZW1hXyhkdHBTY2hlbWEpOwotCX0KLQotCS8qKgotCSAqIHRoaXMgaXMgb25seSBjYWxsZWQgZnJvbSBhIHNjaGVtYSB3aGVuIHRoZSBkYXRhYmFzZSBpcyB0aGUgc2NoZW1hCi0JICogY29udGFpbmVyLCBzbyB3ZSBrbm93IHdlIGRvbid0IGhhdmUgYW55IGNhdGFsb2dzCi0JICovCi0JQE92ZXJyaWRlCi0JRFRQVGFibGVXcmFwcGVyIGdldFRhYmxlKG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnRhYmxlcy5UYWJsZSBkdHBUYWJsZSkgewotCQlyZXR1cm4gdGhpcy5nZXRUYWJsZV8oZHRwVGFibGUpOwotCX0KLQotCS8qKgotCSAqIHRoaXMgaXMgb25seSBjYWxsZWQgZnJvbSBhIGNhdGFsb2csIHNvIHdlIGtub3cgd2UgaGF2ZSBjYXRhbG9nczsKLQkgKiBpLmUuIHRoZSBzZWFyY2ggaGFzIHRvIGRlc2NlbmQgdGhyb3VnaCBjYXRhbG9ncywgdGhlbiB0byBzY2hlbWF0YQotCSAqLwotCURUUFRhYmxlV3JhcHBlciBnZXRUYWJsZUZyb21DYXRhbG9ncyhvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC50YWJsZXMuVGFibGUgZHRwVGFibGUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2F0YWxvZyhkdHBUYWJsZS5nZXRTY2hlbWEoKS5nZXRDYXRhbG9nKCkpLmdldFRhYmxlXyhkdHBUYWJsZSk7Ci0JfQotCi0JLyoqCi0JICogdGhpcyBpcyBvbmx5IGNhbGxlZCBmcm9tIGEgc2NoZW1hIHdoZW4gdGhlIGRhdGFiYXNlIGlzIHRoZSBzY2hlbWEKLQkgKiBjb250YWluZXIsIHNvIHdlIGtub3cgd2UgZG9uJ3QgaGF2ZSBhbnkgY2F0YWxvZ3MKLQkgKi8KLQlAT3ZlcnJpZGUKLQlEVFBDb2x1bW5XcmFwcGVyIGdldENvbHVtbihvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC50YWJsZXMuQ29sdW1uIGR0cENvbHVtbikgewotCQlyZXR1cm4gdGhpcy5nZXRDb2x1bW5fKGR0cENvbHVtbik7Ci0JfQotCi0JLyoqCi0JICogdGhpcyBpcyBvbmx5IGNhbGxlZCBmcm9tIGEgY2F0YWxvZywgc28gd2Uga25vdyB3ZSBoYXZlIGNhdGFsb2dzOwotCSAqIGkuZS4gdGhlIHNlYXJjaCBoYXMgdG8gZGVzY2VuZCB0aHJvdWdoIGNhdGFsb2dzLCB0aGVuIHRvIHNjaGVtYXRhCi0JICovCi0JRFRQQ29sdW1uV3JhcHBlciBnZXRDb2x1bW5Gcm9tQ2F0YWxvZ3Mob3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLkNvbHVtbiBkdHBDb2x1bW4pIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2F0YWxvZyhkdHBDb2x1bW4uZ2V0VGFibGUoKS5nZXRTY2hlbWEoKS5nZXRDYXRhbG9nKCkpLmdldENvbHVtbl8oZHRwQ29sdW1uKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogRGF0YWJhc2VPYmplY3QgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIFN0cmluZyBnZXROYW1lKCkgewotCQlyZXR1cm4gdGhpcy5kdHBEYXRhYmFzZS5nZXROYW1lKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIERhdGFiYXNlIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBTdHJpbmcgZ2V0VmVuZG9yTmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMuZHRwRGF0YWJhc2UuZ2V0VmVuZG9yKCk7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXRWZXJzaW9uKCkgewotCQlyZXR1cm4gdGhpcy5kdHBEYXRhYmFzZS5nZXRWZXJzaW9uKCk7Ci0JfQotCi0JLy8gb3ZlcnJpZGUgdG8gbWFrZSBtZXRob2QgcHVibGljIHNpbmNlIGl0J3MgaW4gdGhlIERhdGFiYXNlIGludGVyZmFjZQotCUBPdmVycmlkZQotCXB1YmxpYyA8VCBleHRlbmRzIERhdGFiYXNlT2JqZWN0PiBUIHNlbGVjdERhdGFiYXNlT2JqZWN0Rm9ySWRlbnRpZmllcihUW10gZGF0YWJhc2VPYmplY3RzLCBTdHJpbmcgaWRlbnRpZmllcikgewotCQlyZXR1cm4gc3VwZXIuc2VsZWN0RGF0YWJhc2VPYmplY3RGb3JJZGVudGlmaWVyKGRhdGFiYXNlT2JqZWN0cywgaWRlbnRpZmllcik7Ci0JfQotCi0JLy8gKioqKiogY2F0YWxvZ3MKLQotCXB1YmxpYyBib29sZWFuIHN1cHBvcnRzQ2F0YWxvZ3MoKSB7Ci0JCXJldHVybiB0aGlzLnZlbmRvci5zdXBwb3J0c0NhdGFsb2dzKHRoaXMuZHRwRGF0YWJhc2UpOwotCX0KLQotCXB1YmxpYyBJdGVyYXRvcjxDYXRhbG9nPiBjYXRhbG9ncygpIHsKLQkJcmV0dXJuIG5ldyBBcnJheUl0ZXJhdG9yPENhdGFsb2c+KHRoaXMuZ2V0Q2F0YWxvZ3MoKSk7Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxEVFBDYXRhbG9nV3JhcHBlcj4gY2F0YWxvZ1dyYXBwZXJzKCkgewotCQlyZXR1cm4gbmV3IEFycmF5SXRlcmF0b3I8RFRQQ2F0YWxvZ1dyYXBwZXI+KHRoaXMuZ2V0Q2F0YWxvZ3MoKSk7Ci0JfQotCi0JcHJpdmF0ZSBzeW5jaHJvbml6ZWQgRFRQQ2F0YWxvZ1dyYXBwZXJbXSBnZXRDYXRhbG9ncygpIHsKLQkJaWYgKHRoaXMuY2F0YWxvZ3MgPT0gbnVsbCkgewotCQkJdGhpcy5jYXRhbG9ncyA9IHRoaXMuYnVpbGRDYXRhbG9ncygpOwotCQl9Ci0JCXJldHVybiB0aGlzLmNhdGFsb2dzOwotCX0KLQotCXByaXZhdGUgRFRQQ2F0YWxvZ1dyYXBwZXJbXSBidWlsZENhdGFsb2dzKCkgewotCQlMaXN0PG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5DYXRhbG9nPiBkdHBDYXRhbG9ncyA9IHRoaXMuZ2V0RFRQQ2F0YWxvZ3MoKTsKLQkJRFRQQ2F0YWxvZ1dyYXBwZXJbXSByZXN1bHQgPSBuZXcgRFRQQ2F0YWxvZ1dyYXBwZXJbZHRwQ2F0YWxvZ3Muc2l6ZSgpXTsKLQkJZm9yIChpbnQgaSA9IHJlc3VsdC5sZW5ndGg7IGktLSA+IDA7KSB7Ci0JCQlyZXN1bHRbaV0gPSBuZXcgRFRQQ2F0YWxvZ1dyYXBwZXIodGhpcywgZHRwQ2F0YWxvZ3MuZ2V0KGkpKTsKLQkJfQotCQlyZXR1cm4gQ29sbGVjdGlvblRvb2xzLnNvcnQocmVzdWx0KTsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8b3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLkNhdGFsb2c+IGdldERUUENhdGFsb2dzKCkgewotCQlyZXR1cm4gdGhpcy52ZW5kb3IuZ2V0Q2F0YWxvZ3ModGhpcy5kdHBEYXRhYmFzZSk7Ci0JfQotCi0JcHVibGljIGludCBjYXRhbG9nc1NpemUoKSB7Ci0JCXJldHVybiB0aGlzLmdldENhdGFsb2dzKCkubGVuZ3RoOwotCX0KLQotCS8qKgotCSAqIHJldHVybiB0aGUgY2F0YWxvZyBmb3IgdGhlIHNwZWNpZmllZCBEVFAgY2F0YWxvZwotCSAqLwotCURUUENhdGFsb2dXcmFwcGVyIGdldENhdGFsb2cob3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLkNhdGFsb2cgZHRwQ2F0YWxvZykgewotCQlmb3IgKERUUENhdGFsb2dXcmFwcGVyIGNhdGFsb2cgOiB0aGlzLmdldENhdGFsb2dzKCkpIHsKLQkJCWlmIChjYXRhbG9nLndyYXBzKGR0cENhdGFsb2cpKSB7Ci0JCQkJcmV0dXJuIGNhdGFsb2c7Ci0JCQl9Ci0JCX0KLQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiaW52YWxpZCBEVFAgY2F0YWxvZzogIiArIGR0cENhdGFsb2cpOyAgLy8kTk9OLU5MUy0xJAotCX0KLQotCXB1YmxpYyBEVFBDYXRhbG9nV3JhcHBlciBnZXRDYXRhbG9nTmFtZWQoU3RyaW5nIG5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuc2VsZWN0RGF0YWJhc2VPYmplY3ROYW1lZCh0aGlzLmdldENhdGFsb2dzKCksIG5hbWUpOwotCX0KLQotCXB1YmxpYyBJdGVyYXRvcjxTdHJpbmc+IHNvcnRlZENhdGFsb2dJZGVudGlmaWVycygpIHsKLQkJLy8gdGhlIGNhdGFsb2dzIGFyZSBhbHJlYWR5IHNvcnRlZAotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8RFRQQ2F0YWxvZ1dyYXBwZXIsIFN0cmluZz4odGhpcy5jYXRhbG9nV3JhcHBlcnMoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShEVFBDYXRhbG9nV3JhcHBlciBuZXh0KSB7Ci0JCQkJIHJldHVybiBuZXh0LmdldElkZW50aWZpZXIoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwdWJsaWMgRFRQQ2F0YWxvZ1dyYXBwZXIgZ2V0Q2F0YWxvZ0ZvcklkZW50aWZpZXIoU3RyaW5nIGlkZW50aWZpZXIpIHsKLQkJcmV0dXJuIHRoaXMuc2VsZWN0RGF0YWJhc2VPYmplY3RGb3JJZGVudGlmaWVyKHRoaXMuZ2V0Q2F0YWxvZ3MoKSwgaWRlbnRpZmllcik7Ci0JfQotCi0JcHVibGljIHN5bmNocm9uaXplZCBEVFBDYXRhbG9nV3JhcHBlciBnZXREZWZhdWx0Q2F0YWxvZygpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2F0YWxvZ0ZvcklkZW50aWZpZXJzKHRoaXMuZ2V0RGVmYXVsdENhdGFsb2dJZGVudGlmaWVycygpKTsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBnZXREZWZhdWx0Q2F0YWxvZ0lkZW50aWZpZXJzKCkgewotCQlyZXR1cm4gdGhpcy52ZW5kb3IuZ2V0RGVmYXVsdENhdGFsb2dJZGVudGlmaWVycyh0aGlzLmR0cERhdGFiYXNlLCB0aGlzLmdldENvbm5lY3Rpb25Qcm9maWxlKCkuZ2V0VXNlck5hbWUoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBmaXJzdCBjYXRhbG9nIGZvdW5kLgotCSAqLwotCXByaXZhdGUgRFRQQ2F0YWxvZ1dyYXBwZXIgZ2V0Q2F0YWxvZ0ZvcklkZW50aWZpZXJzKExpc3Q8U3RyaW5nPiBpZGVudGlmaWVycykgewotCQlmb3IgKFN0cmluZyBpZGVudGlmaWVyIDogaWRlbnRpZmllcnMpIHsKLQkJCURUUENhdGFsb2dXcmFwcGVyIGNhdGFsb2cgPSB0aGlzLmdldENhdGFsb2dGb3JJZGVudGlmaWVyKGlkZW50aWZpZXIpOwotCQkJaWYgKGNhdGFsb2cgIT0gbnVsbCkgewotCQkJCXJldHVybiBjYXRhbG9nOwotCQkJfQotCQl9Ci0JCXJldHVybiBudWxsOwotCX0KLQotCS8vICoqKioqIHNjaGVtYXRhCi0KLQlMaXN0PFN0cmluZz4gZ2V0RGVmYXVsdFNjaGVtYUlkZW50aWZpZXJzKCkgewotCQlyZXR1cm4gdGhpcy52ZW5kb3IuZ2V0RGVmYXVsdFNjaGVtYUlkZW50aWZpZXJzKHRoaXMuZHRwRGF0YWJhc2UsIHRoaXMuZ2V0Q29ubmVjdGlvblByb2ZpbGUoKS5nZXRVc2VyTmFtZSgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogbmFtZXMgdnMuIGlkZW50aWZpZXJzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnZlcnQgdGhlIHNwZWNpZmllZCBuYW1lIHRvIGFuIGlkZW50aWZpZXIuIFJldHVybiBudWxsIGlmIHRoZSByZXN1bHRpbmcKLQkgKiBpZGVudGlmaWVyIG1hdGNoZXMgdGhlIHNwZWNpZmllZCBkZWZhdWx0IG5hbWUuCi0JICovCi0JU3RyaW5nIGNvbnZlcnROYW1lVG9JZGVudGlmaWVyKFN0cmluZyBuYW1lLCBTdHJpbmcgZGVmYXVsdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMudmVuZG9yLmNvbnZlcnROYW1lVG9JZGVudGlmaWVyKG5hbWUsIGRlZmF1bHROYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgbmFtZSB0byBhbiBpZGVudGlmaWVyLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgY29udmVydE5hbWVUb0lkZW50aWZpZXIoU3RyaW5nIG5hbWUpIHsKLQkJcmV0dXJuIHRoaXMudmVuZG9yLmNvbnZlcnROYW1lVG9JZGVudGlmaWVyKG5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgZGF0YWJhc2Ugb2JqZWN0IGlkZW50aWZpZWQgYnkgdGhlIHNwZWNpZmllZCBpZGVudGlmaWVyLiBJZgotCSAqIHRoZSBpZGVudGlmaWVyIGlzICJkZWxpbWl0ZWQiICh0eXBpY2FsbHkgd2l0aCBkb3VibGUtcXVvdGVzKSwgaXQgd2lsbCBiZQotCSAqIHVzZWQgd2l0aG91dCBhbnkgZm9sZGluZy4gSWYgdGhlIG5hbWUgaXMgIm5vcm1hbCIgKGkuZS4gbm90IGRlbGltaXRlZCksCi0JICogaXQgd2lsbCBiZSBmb2xkZWQgdG8gdGhlIGFwcHJvcHJpYXRlIGNhc2UgKHR5cGljYWxseSB1cHBlcmNhc2UpLgotCSAqIAotCSAqIFNpbmNlIHRoZSBkYXRhYmFzZSBoYXMgdGhlIGFwcHJvcHJpYXRlIHN0YXRlIHRvIGNvbXBhcmUgaWRlbnRpZmllcnMgYW5kCi0JICogbmFtZXMsIHRoZSBjb25uZWN0aW9uIHByb2ZpbGUgZGVsZWdhdGVzIHRvIGhlcmUgd2hlbiB1c2luZyB0aGUgZGVmYXVsdAotCSAqICJkYXRhYmFzZSBmaW5kZXIiLgotCSAqLwotCTxUIGV4dGVuZHMgRGF0YWJhc2VPYmplY3Q+IFQgc2VsZWN0RGF0YWJhc2VPYmplY3RGb3JJZGVudGlmaWVyXyhUW10gZGF0YWJhc2VPYmplY3RzLCBTdHJpbmcgaWRlbnRpZmllcikgewotCQlyZXR1cm4gdGhpcy5zZWxlY3REYXRhYmFzZU9iamVjdE5hbWVkKGRhdGFiYXNlT2JqZWN0cywgdGhpcy5jb252ZXJ0SWRlbnRpZmllclRvTmFtZShpZGVudGlmaWVyKSk7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkIGlkZW50aWZpZXIgdG8gYSBuYW1lLgotCSAqLwotCVN0cmluZyBjb252ZXJ0SWRlbnRpZmllclRvTmFtZShTdHJpbmcgaWRlbnRpZmllcikgewotCQlyZXR1cm4gdGhpcy52ZW5kb3IuY29udmVydElkZW50aWZpZXJUb05hbWUoaWRlbnRpZmllcik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIENvbXBhcmFibGUgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIGludCBjb21wYXJlVG8oRGF0YWJhc2UgZGF0YWJhc2UpIHsKLQkJcmV0dXJuIENvbGxhdG9yLmdldEluc3RhbmNlKCkuY29tcGFyZSh0aGlzLmdldE5hbWUoKSwgZGF0YWJhc2UuZ2V0TmFtZSgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW50ZXJuYWwgbWV0aG9kcyAqKioqKioqKioqCi0KLQlEYXRhYmFzZURlZmluaXRpb24gZ2V0RFRQRGVmaW5pdGlvbigpIHsKLQkJcmV0dXJuIFJEQkNvcmVQbHVnaW4uZ2V0RGVmYXVsdCgpLmdldERhdGFiYXNlRGVmaW5pdGlvblJlZ2lzdHJ5KCkuZ2V0RGVmaW5pdGlvbih0aGlzLmR0cERhdGFiYXNlKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogbGlzdGVuaW5nICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXN5bmNocm9uaXplZCB2b2lkIHN0YXJ0TGlzdGVuaW5nKCkgewotCQlpZiAodGhpcy5jYXRhbG9ncyAhPSBudWxsKSB7Ci0JCQl0aGlzLnN0YXJ0Q2F0YWxvZ3MoKTsKLQkJfQotCQlzdXBlci5zdGFydExpc3RlbmluZygpOwotCX0KLQotCXByaXZhdGUgdm9pZCBzdGFydENhdGFsb2dzKCkgewotCQlmb3IgKERUUENhdGFsb2dXcmFwcGVyIGNhdGFsb2cgOiB0aGlzLmNhdGFsb2dzKSB7Ci0JCQljYXRhbG9nLnN0YXJ0TGlzdGVuaW5nKCk7Ci0JCX0KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlzeW5jaHJvbml6ZWQgdm9pZCBzdG9wTGlzdGVuaW5nKCkgewotCQlpZiAodGhpcy5jYXRhbG9ncyAhPSBudWxsKSB7Ci0JCQl0aGlzLnN0b3BDYXRhbG9ncygpOwotCQl9Ci0JCXN1cGVyLnN0b3BMaXN0ZW5pbmcoKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgc3RvcENhdGFsb2dzKCkgewotCQlmb3IgKERUUENhdGFsb2dXcmFwcGVyIGNhdGFsb2cgOiB0aGlzLmNhdGFsb2dzKSB7Ci0JCQljYXRhbG9nLnN0b3BMaXN0ZW5pbmcoKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBjbGVhciAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQl2b2lkIGNsZWFyKCkgewotCQlpZiAodGhpcy5jYXRhbG9ncyAhPSBudWxsKSB7Ci0JCQl0aGlzLmNsZWFyQ2F0YWxvZ3MoKTsKLQkJfQotCQlzdXBlci5jbGVhcigpOwotCX0KLQotCXByaXZhdGUgdm9pZCBjbGVhckNhdGFsb2dzKCkgewotCQl0aGlzLnN0b3BDYXRhbG9ncygpOwotCQlmb3IgKERUUENhdGFsb2dXcmFwcGVyIGNhdGFsb2cgOiB0aGlzLmNhdGFsb2dzKSB7Ci0JCQljYXRhbG9nLmNsZWFyKCk7Ci0JCX0KLQkJdGhpcy5jYXRhbG9ncyA9IG51bGw7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC9EVFBGb3JlaWduS2V5V3JhcHBlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvRFRQRm9yZWlnbktleVdyYXBwZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMTBlOWRmNi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC9EVFBGb3JlaWduS2V5V3JhcHBlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzM5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsOwotCi1pbXBvcnQgamF2YS50ZXh0LkNvbGxhdG9yOwotaW1wb3J0IGphdmEudXRpbC5BcnJheXM7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5Db2x1bW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkZvcmVpZ25LZXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5BcnJheUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5GaWx0ZXJpbmdJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuVHJhbnNmb3JtYXRpb25JdGVyYXRvcjsKLQotLyoqCi0gKiAgV3JhcCBhIERUUCBGb3JlaWduS2V5Ci0gKi8KLWZpbmFsIGNsYXNzIERUUEZvcmVpZ25LZXlXcmFwcGVyCi0JZXh0ZW5kcyBEVFBEYXRhYmFzZU9iamVjdFdyYXBwZXIKLQlpbXBsZW1lbnRzIEZvcmVpZ25LZXkKLXsKLQkvLyB0aGUgd3JhcHBlZCBEVFAgZm9yZWlnbiBrZXkKLQlwcml2YXRlIGZpbmFsIG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLmNvbnN0cmFpbnRzLkZvcmVpZ25LZXkgZHRwRm9yZWlnbktleTsKLQotCS8vIGxhenktaW5pdGlhbGl6ZWQKLQlwcml2YXRlIERUUFRhYmxlV3JhcHBlciByZWZlcmVuY2VkVGFibGU7Ci0KLQkvLyBsYXp5LWluaXRpYWxpemVkCi0JcHJpdmF0ZSBMb2NhbENvbHVtblBhaXJbXSBjb2x1bW5QYWlyczsKLQotCS8vIGxhenktaW5pdGlhbGl6ZWQgLSBidXQgaXQgY2FuIGJlICdudWxsJyBzbyB3ZSB1c2UgYSBmbGFnCi0JcHJpdmF0ZSBTdHJpbmcgZGVmYXVsdEF0dHJpYnV0ZU5hbWU7Ci0JcHJpdmF0ZSBib29sZWFuIGRlZmF1bHRBdHRyaWJ1dGVOYW1lQ2FsY3VsYXRlZCA9IGZhbHNlOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9yICoqKioqKioqKioKLQotCURUUEZvcmVpZ25LZXlXcmFwcGVyKERUUFRhYmxlV3JhcHBlciBiYXNlVGFibGUsIG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLmNvbnN0cmFpbnRzLkZvcmVpZ25LZXkgZHRwRm9yZWlnbktleSkgewotCQlzdXBlcihiYXNlVGFibGUsIGR0cEZvcmVpZ25LZXkpOwotCQl0aGlzLmR0cEZvcmVpZ25LZXkgPSBkdHBGb3JlaWduS2V5OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBEVFBXcmFwcGVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXN5bmNocm9uaXplZCB2b2lkIGNhdGFsb2dPYmplY3RDaGFuZ2VkKCkgewotCQlzdXBlci5jYXRhbG9nT2JqZWN0Q2hhbmdlZCgpOwotCQl0aGlzLmdldENvbm5lY3Rpb25Qcm9maWxlKCkuZm9yZWlnbktleUNoYW5nZWQodGhpcyk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5nZXROYW1lKCkgKyAiOiAiICsgQXJyYXlzLmFzTGlzdCh0aGlzLmdldENvbHVtblBhaXJzKCkpKTsgIC8vJE5PTi1OTFMtMSQKLQl9Ci0KLQotCS8vICoqKioqKioqKiogRm9yZWlnbktleSBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgU3RyaW5nIGdldE5hbWUoKSB7Ci0JCXJldHVybiB0aGlzLmR0cEZvcmVpZ25LZXkuZ2V0TmFtZSgpOwotCX0KLQotCXB1YmxpYyBEVFBUYWJsZVdyYXBwZXIgZ2V0QmFzZVRhYmxlKCkgewotCQlyZXR1cm4gKERUUFRhYmxlV3JhcHBlcikgdGhpcy5nZXRQYXJlbnQoKTsKLQl9Ci0KLQlwdWJsaWMgc3luY2hyb25pemVkIERUUFRhYmxlV3JhcHBlciBnZXRSZWZlcmVuY2VkVGFibGUoKSB7Ci0JCWlmICh0aGlzLnJlZmVyZW5jZWRUYWJsZSA9PSBudWxsKSB7Ci0JCQl0aGlzLnJlZmVyZW5jZWRUYWJsZSA9IHRoaXMuZ2V0QmFzZVRhYmxlKCkuZ2V0VGFibGUodGhpcy5kdHBGb3JlaWduS2V5LmdldFVuaXF1ZUNvbnN0cmFpbnQoKS5nZXRCYXNlVGFibGUoKSk7Ci0JCX0KLQkJcmV0dXJuIHRoaXMucmVmZXJlbmNlZFRhYmxlOwotCX0KLQotCXB1YmxpYyBib29sZWFuIHJlZmVyZW5jZXNTaW5nbGVDb2x1bW5QcmltYXJ5S2V5KCkgewotCQlpZiAodGhpcy5jb2x1bW5QYWlyc1NpemUoKSAhPSAxKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJaWYgKHRoaXMuZ2V0UmVmZXJlbmNlZFRhYmxlKCkucHJpbWFyeUtleUNvbHVtbnNTaXplKCkgIT0gMSkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCXJldHVybiB0aGlzLmdldENvbHVtblBhaXIoKS5nZXRSZWZlcmVuY2VkQ29sdW1uKCkgPT0gdGhpcy5nZXRSZWZlcmVuY2VkVGFibGUoKS5nZXRQcmltYXJ5S2V5Q29sdW1uKCk7Ci0JfQotCi0JLy8gKioqKiogY29sdW1uIHBhaXJzCi0KLQlwdWJsaWMgSXRlcmF0b3I8Q29sdW1uUGFpcj4gY29sdW1uUGFpcnMoKSB7Ci0JCXJldHVybiBuZXcgQXJyYXlJdGVyYXRvcjxDb2x1bW5QYWlyPih0aGlzLmdldENvbHVtblBhaXJzKCkpOwotCX0KLQotCXB1YmxpYyBMb2NhbENvbHVtblBhaXIgZ2V0Q29sdW1uUGFpcigpIHsKLQkJTG9jYWxDb2x1bW5QYWlyW10gcGFpcnMgPSB0aGlzLmdldENvbHVtblBhaXJzKCk7Ci0JCWlmIChwYWlycy5sZW5ndGggIT0gMSkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigibXVsdGlwbGUgY29sdW1uIHBhaXJzOiAiICsgcGFpcnMubGVuZ3RoKTsgIC8vJE5PTi1OTFMtMSQKLQkJfQotCQlyZXR1cm4gcGFpcnNbMF07Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxMb2NhbENvbHVtblBhaXI+IGxvY2FsQ29sdW1uUGFpcnMoKSB7Ci0JCXJldHVybiBuZXcgQXJyYXlJdGVyYXRvcjxMb2NhbENvbHVtblBhaXI+KHRoaXMuZ2V0Q29sdW1uUGFpcnMoKSk7Ci0JfQotCi0JcHJpdmF0ZSBzeW5jaHJvbml6ZWQgTG9jYWxDb2x1bW5QYWlyW10gZ2V0Q29sdW1uUGFpcnMoKSB7Ci0JCWlmICh0aGlzLmNvbHVtblBhaXJzID09IG51bGwpIHsKLQkJCXRoaXMuY29sdW1uUGFpcnMgPSB0aGlzLmJ1aWxkQ29sdW1uUGFpcnMoKTsKLQkJfQotCQlyZXR1cm4gdGhpcy5jb2x1bW5QYWlyczsKLQl9Ci0KLQlwcml2YXRlIExvY2FsQ29sdW1uUGFpcltdIGJ1aWxkQ29sdW1uUGFpcnMoKSB7Ci0JCUxpc3Q8b3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLkNvbHVtbj4gYmFzZUNvbHVtbnMgPSB0aGlzLmdldERUUEJhc2VDb2x1bW5zKCk7Ci0JCWludCBzaXplID0gYmFzZUNvbHVtbnMuc2l6ZSgpOwotCQlMaXN0PG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnRhYmxlcy5Db2x1bW4+IHJlZkNvbHVtbnMgPSB0aGlzLmdldERUUFJlZmVyZW5jZUNvbHVtbnMoKTsKLQkJaWYgKHJlZkNvbHVtbnMuc2l6ZSgpICE9IHNpemUpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24odGhpcy5nZXRCYXNlVGFibGUoKS5nZXROYW1lKCkgKyAnLicgKyB0aGlzLmdldE5hbWUoKSArCi0JCQkJCQkJCSIgLSBtaXNtYXRjaGVkIHNpemVzOiAiICsgc2l6ZSArICIgdnMuICIgKyByZWZDb2x1bW5zLnNpemUoKSk7ICAvLyROT04tTkxTLTEkICAvLyROT04tTkxTLTIkCi0JCX0KLQkJTG9jYWxDb2x1bW5QYWlyW10gcmVzdWx0ID0gbmV3IExvY2FsQ29sdW1uUGFpcltiYXNlQ29sdW1ucy5zaXplKCldOwotCQlmb3IgKGludCBpID0gYmFzZUNvbHVtbnMuc2l6ZSgpOyBpLS0gPiAwOyApIHsKLQkJCXJlc3VsdFtpXSA9IG5ldyBMb2NhbENvbHVtblBhaXIoCi0JCQkJCQkJCXRoaXMuZ2V0QmFzZVRhYmxlKCkuZ2V0Q29sdW1uKGJhc2VDb2x1bW5zLmdldChpKSksCi0JCQkJCQkJCXRoaXMuZ2V0QmFzZVRhYmxlKCkuZ2V0Q29sdW1uKHJlZkNvbHVtbnMuZ2V0KGkpKQotCQkJCQkJKTsKLQkJfQotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8vIG1pbmltaXplIHNjb3BlIG9mIHN1cHByZXNzZWQgd2FybmluZ3MKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcml2YXRlIExpc3Q8b3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLkNvbHVtbj4gZ2V0RFRQQmFzZUNvbHVtbnMoKSB7Ci0JCXJldHVybiB0aGlzLmR0cEZvcmVpZ25LZXkuZ2V0TWVtYmVycygpOwotCX0KLQotCS8vIG1pbmltaXplIHNjb3BlIG9mIHN1cHByZXNzZWQgd2FybmluZ3MKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcml2YXRlIExpc3Q8b3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLkNvbHVtbj4gZ2V0RFRQUmVmZXJlbmNlQ29sdW1ucygpIHsKLQkJcmV0dXJuIHRoaXMuZHRwRm9yZWlnbktleS5nZXRVbmlxdWVDb25zdHJhaW50KCkuZ2V0TWVtYmVycygpOwotCX0KLQotCXB1YmxpYyBpbnQgY29sdW1uUGFpcnNTaXplKCkgewotCQlyZXR1cm4gdGhpcy5nZXRDb2x1bW5QYWlycygpLmxlbmd0aDsKLQl9Ci0KLQlwdWJsaWMgSXRlcmF0b3I8Q29sdW1uPiBiYXNlQ29sdW1ucygpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yPExvY2FsQ29sdW1uUGFpciwgQ29sdW1uPih0aGlzLmxvY2FsQ29sdW1uUGFpcnMoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ29sdW1uIHRyYW5zZm9ybShMb2NhbENvbHVtblBhaXIgcGFpcikgewotCQkJCXJldHVybiBwYWlyLmdldEJhc2VDb2x1bW4oKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlib29sZWFuIGJhc2VDb2x1bW5zQ29udGFpbnMoQ29sdW1uIGNvbHVtbikgewotCQlyZXR1cm4gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuYmFzZUNvbHVtbnMoKSwgY29sdW1uKTsKLQl9Ci0KLQlwdWJsaWMgSXRlcmF0b3I8Q29sdW1uPiBub25QcmltYXJ5S2V5QmFzZUNvbHVtbnMoKSB7Ci0JCXJldHVybiBuZXcgRmlsdGVyaW5nSXRlcmF0b3I8Q29sdW1uLCBDb2x1bW4+KHRoaXMuYmFzZUNvbHVtbnMoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgYm9vbGVhbiBhY2NlcHQoQ29sdW1uIGNvbHVtbikgewotCQkJCXJldHVybiAhIGNvbHVtbi5pc1BhcnRPZlByaW1hcnlLZXkoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwdWJsaWMgSXRlcmF0b3I8Q29sdW1uPiByZWZlcmVuY2VkQ29sdW1ucygpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yPExvY2FsQ29sdW1uUGFpciwgQ29sdW1uPih0aGlzLmxvY2FsQ29sdW1uUGFpcnMoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ29sdW1uIHRyYW5zZm9ybShMb2NhbENvbHVtblBhaXIgY29sdW1uUGFpcikgewotCQkJCXJldHVybiBjb2x1bW5QYWlyLmdldFJlZmVyZW5jZWRDb2x1bW4oKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQkvLyAqKioqKiBhdHRyaWJ1dGUgbmFtZQotCi0JcHVibGljIFN0cmluZyBnZXRBdHRyaWJ1dGVOYW1lKCkgewotCQlTdHJpbmcgZGVmYXVsdE5hbWUgPSB0aGlzLmdldERlZmF1bHRBdHRyaWJ1dGVOYW1lKCk7Ci0JCXJldHVybiAoZGVmYXVsdE5hbWUgIT0gbnVsbCkgPyBkZWZhdWx0TmFtZSA6IHRoaXMuZ2V0Tm9uRGVmYXVsdEF0dHJpYnV0ZU5hbWUoKTsKLQl9Ci0KLQlwdWJsaWMgc3luY2hyb25pemVkIFN0cmluZyBnZXREZWZhdWx0QXR0cmlidXRlTmFtZSgpIHsKLQkJaWYgKCAhIHRoaXMuZGVmYXVsdEF0dHJpYnV0ZU5hbWVDYWxjdWxhdGVkKSB7Ci0JCQl0aGlzLmRlZmF1bHRBdHRyaWJ1dGVOYW1lQ2FsY3VsYXRlZCA9IHRydWU7Ci0JCQl0aGlzLmRlZmF1bHRBdHRyaWJ1dGVOYW1lID0gdGhpcy5idWlsZERlZmF1bHRBdHRyaWJ1dGVOYW1lKCk7Ci0JCX0KLQkJcmV0dXJuIHRoaXMuZGVmYXVsdEF0dHJpYnV0ZU5hbWU7Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmcgYnVpbGREZWZhdWx0QXR0cmlidXRlTmFtZSgpIHsKLQkJaWYgKCAhIHRoaXMucmVmZXJlbmNlc1NpbmdsZUNvbHVtblByaW1hcnlLZXkoKSkgewotCQkJcmV0dXJuIG51bGw7Ci0JCX0KLQkJTG9jYWxDb2x1bW5QYWlyIGNvbHVtblBhaXIgPSB0aGlzLmdldENvbHVtblBhaXIoKTsKLQkJU3RyaW5nIGJhc2VDb2xOYW1lID0gY29sdW1uUGFpci5nZXRCYXNlQ29sdW1uKCkuZ2V0TmFtZSgpOwotCQlTdHJpbmcgcmVmQ29sTmFtZSA9IGNvbHVtblBhaXIuZ2V0UmVmZXJlbmNlZENvbHVtbigpLmdldE5hbWUoKTsKLQkJaWYgKGJhc2VDb2xOYW1lLmxlbmd0aCgpIDw9IChyZWZDb2xOYW1lLmxlbmd0aCgpICsgMSkpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCWlmICggISBiYXNlQ29sTmFtZS5lbmRzV2l0aChyZWZDb2xOYW1lKSkgewotCQkJcmV0dXJuIG51bGw7Ci0JCX0KLQkJaW50IF9pbmRleCA9IGJhc2VDb2xOYW1lLmxlbmd0aCgpIC0gcmVmQ29sTmFtZS5sZW5ndGgoKSAtIDE7Ci0JCWlmIChiYXNlQ29sTmFtZS5jaGFyQXQoX2luZGV4KSAhPSAnXycpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCXJldHVybiBiYXNlQ29sTmFtZS5zdWJzdHJpbmcoMCwgX2luZGV4KTsKLQl9Ci0KLQkvKioKLQkgKiBJZiB0aGlzIGlzIGEgc2ltcGxlIChzaW5nbGUtY29sdW1uKSBmb3JlaWduIGtleSwgdXNlIHRoZSBuYW1lIG9mIHRoZQotCSAqIHNpbmdsZSBiYXNlIGNvbHVtbiB0byBidWlsZCBhIG5hbWUuIElmIHRoaXMgaXMgYSBjb21wb3VuZCBmb3JlaWduIGtleSwKLQkgKiByZXR1cm4gdGhlIG5hbWUgb2YgdGhlIHJlZmVyZW5jZWQgdGFibGUuCi0JICovCi0JLy8gVE9ETyBpZiB0aGVyZSBpcyBvbmx5IG9uZSBGSyB0byBhIGdpdmVuIHRhYmxlLCB1c2UgdGhlIHRhYmxlJ3MgbmFtZSBpbnN0ZWFkIG9mIHRoZSBjb2x1bW4ncyBuYW1lPwotCXByaXZhdGUgU3RyaW5nIGdldE5vbkRlZmF1bHRBdHRyaWJ1dGVOYW1lKCkgewotCQlyZXR1cm4gKHRoaXMuY29sdW1uUGFpcnNTaXplKCkgPT0gMSkgPwotCQkJCQkJdGhpcy5nZXROb25EZWZhdWx0QXR0cmlidXRlTmFtZUZyb21CYXNlQ29sdW1uKCkKLQkJCQkJOgotCQkJCQkJdGhpcy5nZXRSZWZlcmVuY2VkVGFibGUoKS5nZXROYW1lKCk7Ci0JfQotCi0JLyoqCi0JICogVGhlIHVuZGVyc2NvcmUgY2hlY2sgaXMgaGVscGZ1bCB3aGVuIHRoZSByZWZlcmVuY2VkIGNvbHVtbiBpcyBOT1QgdGhlCi0JICogcHJpbWFyeSBrZXkgb2YgdGhlIHJlZmVyZW5jZWQgdGFibGUgKGkuZS4gaXQgaGFzIG9ubHkgYSBVTklRVUUgY29uc3RyYWludCkuCi0JICogICAgIEZvcmVpZ25LZXkoRU1QLkNVQklDTEVfSUQgPT4gQ1VCSUNMRS5JRCkgPT4gIkNVQklDTEUiCi0JICogICAgIEZvcmVpZ25LZXkoRU1QLkNVQklDTEVJRCA9PiBDVUJJQ0xFLklEKSA9PiAiQ1VCSUNMRSIKLQkgKiAgICAgRm9yZWlnbktleShFTVAuQ1VCSUNMRV9QSyA9PiBDVUJJQ0xFLklEKSA9PiAiQ1VCSUNMRV9QSyIKLQkgKi8KLQlwcml2YXRlIFN0cmluZyBnZXROb25EZWZhdWx0QXR0cmlidXRlTmFtZUZyb21CYXNlQ29sdW1uKCkgewotCQlMb2NhbENvbHVtblBhaXIgY29sdW1uUGFpciA9IHRoaXMuZ2V0Q29sdW1uUGFpcigpOwotCQlTdHJpbmcgYmFzZUNvbE5hbWUgPSBjb2x1bW5QYWlyLmdldEJhc2VDb2x1bW4oKS5nZXROYW1lKCk7Ci0JCVN0cmluZyByZWZDb2xOYW1lID0gY29sdW1uUGFpci5nZXRSZWZlcmVuY2VkQ29sdW1uKCkuZ2V0TmFtZSgpOwotCQlpbnQgbGVuID0gYmFzZUNvbE5hbWUubGVuZ3RoKCk7Ci0JCWludCByZWZMZW4gPSByZWZDb2xOYW1lLmxlbmd0aCgpOwotCQlpZiAoKGxlbiA+IHJlZkxlbikgJiYgYmFzZUNvbE5hbWUuZW5kc1dpdGgocmVmQ29sTmFtZSkpIHsKLQkJCWxlbiA9IGxlbiAtIHJlZkxlbjsKLQkJCWlmICgobGVuID4gMSkgJiYgYmFzZUNvbE5hbWUuY2hhckF0KGxlbiAtIDEpID09ICdfJykgewotCQkJCWxlbiA9IGxlbiAtIDE7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGJhc2VDb2xOYW1lLnN1YnN0cmluZygwLCBsZW4pOwotCX0KLQotCS8qKgotCSAqIEV4YW1wbGVzOgotCSAqIE9yYWNsZSBldGMuCi0JICogICAgIEZvcmVpZ25LZXkoRk9PX0lEID0+IElEKSB2cy4gImZvbyIgPT4gbnVsbAotCSAqICAgICBGb3JlaWduS2V5KEZPT19JRCA9PiBGT09fSUQpIHZzLiAiZm9vIiA9PiAiRk9PX0lEIgotCSAqICAgICBGb3JlaWduS2V5KEZPTyA9PiBJRCkgdnMuICJmb28iID0+ICJGT08iCi0JICogICAgIEZvcmVpZ25LZXkoRm9vX0lEID0+IElEKSB2cy4gImZvbyIgPT4gIlwiRm9vX0lEXCIiCi0JICogICAgIAotCSAqIFBvc3RncmVTUUwgZXRjLgotCSAqICAgICBGb3JlaWduS2V5KGZvb19pZCA9PiBpZCkgdnMuICJmb28iID0+IG51bGwKLQkgKiAgICAgRm9yZWlnbktleShmb29faWQgPT4gZm9vX2lkKSB2cy4gImZvbyIgPT4gImZvb19pZCIKLQkgKiAgICAgRm9yZWlnbktleShmb28gPT4gaWQpIHZzLiAiZm9vIiA9PiAiZm9vIgotCSAqICAgICBGb3JlaWduS2V5KEZvb19JRCA9PiBJRCkgdnMuICJmb28iID0+ICJcIkZvb19JRFwiIgotCSAqICAgICAKLQkgKiBTUUwgU2VydmVyIGV0Yy4KLQkgKiAgICAgRm9yZWlnbktleShmb29fSUQgPT4gSUQpIHZzLiAiZm9vIiA9PiBudWxsCi0JICogICAgIEZvcmVpZ25LZXkoRk9PX0lEID0+IEZPT19JRCkgdnMuICJmb28iID0+ICJGT09fSUQiCi0JICogICAgIEZvcmVpZ25LZXkoRk9PID0+IElEKSB2cy4gImZvbyIgPT4gIkZPTyIKLQkgKiAgICAgRm9yZWlnbktleShGb29fSUQgPT4gSUQpIHZzLiAiZm9vIiA9PiAiRm9vX0lEIgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0Sm9pbkNvbHVtbkFubm90YXRpb25JZGVudGlmaWVyKFN0cmluZyBhdHRyaWJ1dGVOYW1lKSB7Ci0JCVN0cmluZyBiYXNlQ29sdW1uTmFtZSA9IHRoaXMuZ2V0Q29sdW1uUGFpcigpLmdldEJhc2VDb2x1bW4oKS5nZXROYW1lKCk7Ci0JCVN0cmluZyBkZWZhdWx0QmFzZUNvbHVtbk5hbWUgPSBhdHRyaWJ1dGVOYW1lICsgJ18nICsgdGhpcy5nZXRSZWZlcmVuY2VkVGFibGUoKS5nZXRQcmltYXJ5S2V5Q29sdW1uKCkuZ2V0TmFtZSgpOwotCQlyZXR1cm4gdGhpcy5nZXREYXRhYmFzZSgpLmNvbnZlcnROYW1lVG9JZGVudGlmaWVyKGJhc2VDb2x1bW5OYW1lLCBkZWZhdWx0QmFzZUNvbHVtbk5hbWUpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBDb21wYXJhYmxlIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBpbnQgY29tcGFyZVRvKEZvcmVpZ25LZXkgZm9yZWlnbktleSkgewotCQlyZXR1cm4gQ29sbGF0b3IuZ2V0SW5zdGFuY2UoKS5jb21wYXJlKHRoaXMuZ2V0TmFtZSgpLCBmb3JlaWduS2V5LmdldE5hbWUoKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGludGVybmFsIG1ldGhvZHMgKioqKioqKioqKgotCi0JYm9vbGVhbiB3cmFwcyhvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5jb25zdHJhaW50cy5Gb3JlaWduS2V5IGZvcmVpZ25LZXkpIHsKLQkJcmV0dXJuIHRoaXMuZHRwRm9yZWlnbktleSA9PSBmb3JlaWduS2V5OwotCX0KLQotCUBPdmVycmlkZQotCXZvaWQgY2xlYXIoKSB7Ci0JCS8vIHRoZSBmb3JlaWduIGtleSBkb2VzIG5vdCAiY29udGFpbiIgYW55IG90aGVyIG9iamVjdHMsCi0JCS8vIHNvIHdlIGRvbid0IG5lZWQgdG8gZm9yd2FyZCB0aGUgI2NsZWFyKCkKLQkJdGhpcy5kZWZhdWx0QXR0cmlidXRlTmFtZUNhbGN1bGF0ZWQgPSBmYWxzZTsKLQkJdGhpcy5kZWZhdWx0QXR0cmlidXRlTmFtZSA9IG51bGw7Ci0JCXRoaXMuY29sdW1uUGFpcnMgPSAgbnVsbDsKLQkJdGhpcy5yZWZlcmVuY2VkVGFibGUgPSBudWxsOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBjb2x1bW4gcGFpciBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBMb2NhbENvbHVtblBhaXIgaW1wbGVtZW50cyBDb2x1bW5QYWlyIHsKLQkJcHJpdmF0ZSBmaW5hbCBEVFBDb2x1bW5XcmFwcGVyIGJhc2VDb2x1bW47Ci0JCXByaXZhdGUgZmluYWwgRFRQQ29sdW1uV3JhcHBlciByZWZlcmVuY2VkQ29sdW1uOwotCi0JCUxvY2FsQ29sdW1uUGFpcihEVFBDb2x1bW5XcmFwcGVyIGJhc2VDb2x1bW4sIERUUENvbHVtbldyYXBwZXIgcmVmZXJlbmNlZENvbHVtbikgewotCQkJc3VwZXIoKTsKLQkJCWlmICgoYmFzZUNvbHVtbiA9PSBudWxsKSB8fCAocmVmZXJlbmNlZENvbHVtbiA9PSBudWxsKSkgewotCQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigpOwotCQkJfQotCQkJdGhpcy5iYXNlQ29sdW1uID0gYmFzZUNvbHVtbjsKLQkJCXRoaXMucmVmZXJlbmNlZENvbHVtbiA9IHJlZmVyZW5jZWRDb2x1bW47Ci0JCX0KLQotCQlwdWJsaWMgRFRQQ29sdW1uV3JhcHBlciBnZXRCYXNlQ29sdW1uKCkgewotCQkJcmV0dXJuIHRoaXMuYmFzZUNvbHVtbjsKLQkJfQotCi0JCXB1YmxpYyBEVFBDb2x1bW5XcmFwcGVyIGdldFJlZmVyZW5jZWRDb2x1bW4oKSB7Ci0JCQlyZXR1cm4gdGhpcy5yZWZlcmVuY2VkQ29sdW1uOwotCQl9Ci0KLQkJcHVibGljIGludCBjb21wYXJlVG8oQ29sdW1uUGFpciBjb2x1bW5QYWlyKSB7Ci0JCQlyZXR1cm4gQ29sbGF0b3IuZ2V0SW5zdGFuY2UoKS5jb21wYXJlKHRoaXMuZ2V0QmFzZUNvbHVtbigpLmdldE5hbWUoKSwgY29sdW1uUGFpci5nZXRCYXNlQ29sdW1uKCkuZ2V0TmFtZSgpKTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5iYXNlQ29sdW1uLmdldE5hbWUoKSArICI9PiIgKyB0aGlzLnJlZmVyZW5jZWRDb2x1bW4uZ2V0TmFtZSgpKTsgIC8vJE5PTi1OTFMtMSQKLQkJfQotCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC9EVFBTY2hlbWFDb250YWluZXJXcmFwcGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC9EVFBTY2hlbWFDb250YWluZXJXcmFwcGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGE4ZGFiZWEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvRFRQU2NoZW1hQ29udGFpbmVyV3JhcHBlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjEyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5TY2hlbWE7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLlNjaGVtYUNvbnRhaW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkFycmF5SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlRyYW5zZm9ybWF0aW9uSXRlcmF0b3I7Ci0KLS8qKgotICogQ29hbGVzY2UgYmVoYXZpb3IgZm9yIGEgc2NoZW1hIGNvbnRhaW5lciAoaS5lLiBkYXRhYmFzZSBvciBjYXRhbG9nKS4KLSAqLwotYWJzdHJhY3QgY2xhc3MgRFRQU2NoZW1hQ29udGFpbmVyV3JhcHBlcgotCWV4dGVuZHMgRFRQRGF0YWJhc2VPYmplY3RXcmFwcGVyCi0JaW1wbGVtZW50cyBTY2hlbWFDb250YWluZXIKLXsKLQkvLyBsYXp5LWluaXRpYWxpemVkCi0JcHJpdmF0ZSBEVFBTY2hlbWFXcmFwcGVyW10gc2NoZW1hdGE7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3IgKioqKioqKioqKgotCi0JRFRQU2NoZW1hQ29udGFpbmVyV3JhcHBlcihEVFBEYXRhYmFzZU9iamVjdCBwYXJlbnQsIE9iamVjdCBkdHBTY2hlbWFDb250YWluZXIpIHsKLQkJc3VwZXIocGFyZW50LCBkdHBTY2hlbWFDb250YWluZXIpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBEVFBXcmFwcGVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXN5bmNocm9uaXplZCB2b2lkIGNhdGFsb2dPYmplY3RDaGFuZ2VkKCkgewotCQlzdXBlci5jYXRhbG9nT2JqZWN0Q2hhbmdlZCgpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBhYnN0cmFjdCBtZXRob2RzICoqKioqKioqKioKLQotCS8qKgotCSAqIHJldHVybiB0aGUgc2NoZW1hIGNvbnRhaW5lcidzIERUUCBzY2hlbWF0YQotCSAqLwotCWFic3RyYWN0IExpc3Q8b3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLlNjaGVtYT4gZ2V0RFRQU2NoZW1hdGEoKTsKLQotCS8qKgotCSAqIHJldHVybiB0aGUgc2NoZW1hIGZvciB0aGUgc3BlY2lmaWVkIERUUCBzY2hlbWEKLQkgKi8KLQlhYnN0cmFjdCBEVFBTY2hlbWFXcmFwcGVyIGdldFNjaGVtYShvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuU2NoZW1hIGR0cFNjaGVtYSk7Ci0KLQkvKioKLQkgKiBhc3N1bWUgdGhlIHNjaGVtYSBjb250YWluZXIgKGRhdGFiYXNlIG9yIGNhdGFsb2cpIGNvbnRhaW5zCi0JICogdGhlIHNwZWNpZmllZCBzY2hlbWEKLQkgKi8KLQlEVFBTY2hlbWFXcmFwcGVyIGdldFNjaGVtYV8ob3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLlNjaGVtYSBkdHBTY2hlbWEpIHsKLQkJZm9yIChEVFBTY2hlbWFXcmFwcGVyIHNjaGVtYSA6IHRoaXMuZ2V0U2NoZW1hdGEoKSkgewotCQkJaWYgKHNjaGVtYS53cmFwcyhkdHBTY2hlbWEpKSB7Ci0JCQkJcmV0dXJuIHNjaGVtYTsKLQkJCX0KLQkJfQotCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJpbnZhbGlkIERUUCBzY2hlbWE6ICIgKyBkdHBTY2hlbWEpOyAgLy8kTk9OLU5MUy0xJAotCX0KLQotCS8qKgotCSAqIHJldHVybiB0aGUgdGFibGUgZm9yIHRoZSBzcGVjaWZpZWQgRFRQIHRhYmxlOwotCSAqIHRoaXMgaXMgb25seSBjYWxsZWQgZnJvbSBhIHNjaGVtYSAodG8gaXRzIGNvbnRhaW5lcikKLQkgKi8KLQlhYnN0cmFjdCBEVFBUYWJsZVdyYXBwZXIgZ2V0VGFibGUob3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLlRhYmxlIGR0cFRhYmxlKTsKLQotCS8qKgotCSAqIGFzc3VtZSB0aGUgc2NoZW1hIGNvbnRhaW5lciBjb250YWlucyB0aGUgc3BlY2lmaWVkIHRhYmxlCi0JICovCi0JRFRQVGFibGVXcmFwcGVyIGdldFRhYmxlXyhvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC50YWJsZXMuVGFibGUgZHRwVGFibGUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0U2NoZW1hXyhkdHBUYWJsZS5nZXRTY2hlbWEoKSkuZ2V0VGFibGVfKGR0cFRhYmxlKTsKLQl9Ci0KLQkvKioKLQkgKiByZXR1cm4gdGhlIGNvbHVtbiBmb3IgdGhlIHNwZWNpZmllZCBEVFAgY29sdW1uOwotCSAqIHRoaXMgaXMgb25seSBjYWxsZWQgZnJvbSBhIHNjaGVtYSAodG8gaXRzIGNvbnRhaW5lcikKLQkgKi8KLQlhYnN0cmFjdCBEVFBDb2x1bW5XcmFwcGVyIGdldENvbHVtbihvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC50YWJsZXMuQ29sdW1uIGR0cENvbHVtbik7Ci0KLQkvKioKLQkgKiBhc3N1bWUgdGhlIHNjaGVtYSBjb250YWluZXIgY29udGFpbnMgdGhlIHNwZWNpZmllZCBjb2x1bW4KLQkgKi8KLQlEVFBDb2x1bW5XcmFwcGVyIGdldENvbHVtbl8ob3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLkNvbHVtbiBkdHBDb2x1bW4pIHsKLQkJcmV0dXJuIHRoaXMuZ2V0VGFibGVfKGR0cENvbHVtbi5nZXRUYWJsZSgpKS5nZXRDb2x1bW5fKGR0cENvbHVtbik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHNjaGVtYXRhICoqKioqKioqKioKLQotCXB1YmxpYyBJdGVyYXRvcjxTY2hlbWE+IHNjaGVtYXRhKCkgewotCQlyZXR1cm4gbmV3IEFycmF5SXRlcmF0b3I8U2NoZW1hPih0aGlzLmdldFNjaGVtYXRhKCkpOwotCX0KLQotCUl0ZXJhdG9yPERUUFNjaGVtYVdyYXBwZXI+IHNjaGVtYVdyYXBwZXJzKCkgewotCQlyZXR1cm4gbmV3IEFycmF5SXRlcmF0b3I8RFRQU2NoZW1hV3JhcHBlcj4odGhpcy5nZXRTY2hlbWF0YSgpKTsKLQl9Ci0KLQlzeW5jaHJvbml6ZWQgRFRQU2NoZW1hV3JhcHBlcltdIGdldFNjaGVtYXRhKCkgewotCQlpZiAodGhpcy5zY2hlbWF0YSA9PSBudWxsKSB7Ci0JCQl0aGlzLnNjaGVtYXRhID0gdGhpcy5idWlsZFNjaGVtYXRhKCk7Ci0JCX0KLQkJcmV0dXJuIHRoaXMuc2NoZW1hdGE7Ci0JfQotCi0JcHJpdmF0ZSBEVFBTY2hlbWFXcmFwcGVyW10gYnVpbGRTY2hlbWF0YSgpIHsKLQkJTGlzdDxvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuU2NoZW1hPiBkdHBTY2hlbWF0YSA9IHRoaXMuZ2V0RFRQU2NoZW1hdGEoKTsKLQkJRFRQU2NoZW1hV3JhcHBlcltdIHJlc3VsdCA9IG5ldyBEVFBTY2hlbWFXcmFwcGVyW2R0cFNjaGVtYXRhLnNpemUoKV07Ci0JCWZvciAoaW50IGkgPSByZXN1bHQubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCXJlc3VsdFtpXSA9IG5ldyBEVFBTY2hlbWFXcmFwcGVyKHRoaXMsIGR0cFNjaGVtYXRhLmdldChpKSk7Ci0JCX0KLQkJcmV0dXJuIENvbGxlY3Rpb25Ub29scy5zb3J0KHJlc3VsdCk7Ci0JfQotCi0JcHVibGljIGludCBzY2hlbWF0YVNpemUoKSB7Ci0JCXJldHVybiB0aGlzLmdldFNjaGVtYXRhKCkubGVuZ3RoOwotCX0KLQotCXB1YmxpYyBEVFBTY2hlbWFXcmFwcGVyIGdldFNjaGVtYU5hbWVkKFN0cmluZyBuYW1lKSB7Ci0JCXJldHVybiB0aGlzLnNlbGVjdERhdGFiYXNlT2JqZWN0TmFtZWQodGhpcy5nZXRTY2hlbWF0YSgpLCBuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgSXRlcmF0b3I8U3RyaW5nPiBzb3J0ZWRTY2hlbWFJZGVudGlmaWVycygpIHsKLQkJLy8gdGhlIHNjaGVtYXRhIGFyZSBhbHJlYWR5IHNvcnRlZAotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8RFRQU2NoZW1hV3JhcHBlciwgU3RyaW5nPih0aGlzLnNjaGVtYVdyYXBwZXJzKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oRFRQU2NoZW1hV3JhcHBlciBuZXh0KSB7Ci0JCQkJIHJldHVybiBuZXh0LmdldElkZW50aWZpZXIoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwdWJsaWMgRFRQU2NoZW1hV3JhcHBlciBnZXRTY2hlbWFGb3JJZGVudGlmaWVyKFN0cmluZyBpZGVudGlmaWVyKSB7Ci0JCXJldHVybiB0aGlzLnNlbGVjdERhdGFiYXNlT2JqZWN0Rm9ySWRlbnRpZmllcih0aGlzLmdldFNjaGVtYXRhKCksIGlkZW50aWZpZXIpOwotCX0KLQotCXB1YmxpYyBEVFBTY2hlbWFXcmFwcGVyIGdldERlZmF1bHRTY2hlbWEoKSB7Ci0JCXJldHVybiB0aGlzLmdldFNjaGVtYUZvcklkZW50aWZpZXJzKHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXREZWZhdWx0U2NoZW1hSWRlbnRpZmllcnMoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBmaXJzdCBzY2hlbWEgZm91bmQuCi0JICovCi0JRFRQU2NoZW1hV3JhcHBlciBnZXRTY2hlbWFGb3JJZGVudGlmaWVycyhMaXN0PFN0cmluZz4gaWRlbnRpZmllcnMpIHsKLQkJZm9yIChTdHJpbmcgaWRlbnRpZmllciA6IGlkZW50aWZpZXJzKSB7Ci0JCQlEVFBTY2hlbWFXcmFwcGVyIHNjaGVtYSA9IHRoaXMuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcihpZGVudGlmaWVyKTsKLQkJCWlmIChzY2hlbWEgIT0gbnVsbCkgewotCQkJCXJldHVybiBzY2hlbWE7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIG51bGw7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGxpc3RlbmluZyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlzeW5jaHJvbml6ZWQgdm9pZCBzdGFydExpc3RlbmluZygpIHsKLQkJaWYgKHRoaXMuc2NoZW1hdGEgIT0gbnVsbCkgewotCQkJdGhpcy5zdGFydFNjaGVtYXRhKCk7Ci0JCX0KLQkJc3VwZXIuc3RhcnRMaXN0ZW5pbmcoKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgc3RhcnRTY2hlbWF0YSgpIHsKLQkJZm9yIChEVFBTY2hlbWFXcmFwcGVyIHNjaGVtYSA6IHRoaXMuc2NoZW1hdGEpIHsKLQkJCXNjaGVtYS5zdGFydExpc3RlbmluZygpOwotCQl9Ci0JfQotCi0JQE92ZXJyaWRlCi0Jc3luY2hyb25pemVkIHZvaWQgc3RvcExpc3RlbmluZygpIHsKLQkJaWYgKHRoaXMuc2NoZW1hdGEgIT0gbnVsbCkgewotCQkJdGhpcy5zdG9wU2NoZW1hdGEoKTsKLQkJfQotCQlzdXBlci5zdG9wTGlzdGVuaW5nKCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHN0b3BTY2hlbWF0YSgpIHsKLQkJZm9yIChEVFBTY2hlbWFXcmFwcGVyIHNjaGVtYSA6IHRoaXMuc2NoZW1hdGEpIHsKLQkJCXNjaGVtYS5zdG9wTGlzdGVuaW5nKCk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogY2xlYXIgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0Jc3luY2hyb25pemVkIHZvaWQgY2xlYXIoKSB7Ci0JCWlmICh0aGlzLnNjaGVtYXRhICE9IG51bGwpIHsKLQkJCXRoaXMuY2xlYXJTY2hlbWF0YSgpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGNsZWFyU2NoZW1hdGEoKSB7Ci0JCXRoaXMuc3RvcFNjaGVtYXRhKCk7Ci0JCWZvciAoRFRQU2NoZW1hV3JhcHBlciBzY2hlbWEgOiB0aGlzLnNjaGVtYXRhKSB7Ci0JCQlzY2hlbWEuY2xlYXIoKTsKLQkJfQotCQl0aGlzLnNjaGVtYXRhID0gbnVsbDsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL0RUUFNjaGVtYVdyYXBwZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL0RUUFNjaGVtYVdyYXBwZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMGVkMzEzZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC9EVFBTY2hlbWFXcmFwcGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzMDcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLnRleHQuQ29sbGF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5TY2hlbWE7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLlNlcXVlbmNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5UYWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkFycmF5SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlRyYW5zZm9ybWF0aW9uSXRlcmF0b3I7Ci0KLS8qKgotICogIFdyYXAgYSBEVFAgU2NoZW1hCi0gKi8KLWZpbmFsIGNsYXNzIERUUFNjaGVtYVdyYXBwZXIKLQlleHRlbmRzIERUUERhdGFiYXNlT2JqZWN0V3JhcHBlcgotCWltcGxlbWVudHMgU2NoZW1hCi17Ci0JLy8gdGhlIHdyYXBwZWQgRFRQIHNjaGVtYQotCXByaXZhdGUgZmluYWwgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLlNjaGVtYSBkdHBTY2hlbWE7Ci0KLQkvLyBsYXp5LWluaXRpYWxpemVkCi0JcHJpdmF0ZSBEVFBUYWJsZVdyYXBwZXJbXSB0YWJsZXM7Ci0KLQkvLyBsYXp5LWluaXRpYWxpemVkCi0JcHJpdmF0ZSBEVFBTZXF1ZW5jZVdyYXBwZXJbXSBzZXF1ZW5jZXM7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3IgKioqKioqKioqKgotCi0JRFRQU2NoZW1hV3JhcHBlcihEVFBTY2hlbWFDb250YWluZXJXcmFwcGVyIGNvbnRhaW5lciwgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLlNjaGVtYSBkdHBTY2hlbWEpIHsKLQkJc3VwZXIoY29udGFpbmVyLCBkdHBTY2hlbWEpOwotCQl0aGlzLmR0cFNjaGVtYSA9IGR0cFNjaGVtYTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogRFRQV3JhcHBlciBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlzeW5jaHJvbml6ZWQgdm9pZCBjYXRhbG9nT2JqZWN0Q2hhbmdlZCgpIHsKLQkJc3VwZXIuY2F0YWxvZ09iamVjdENoYW5nZWQoKTsKLQkJdGhpcy5nZXRDb25uZWN0aW9uUHJvZmlsZSgpLnNjaGVtYUNoYW5nZWQodGhpcyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIFNjaGVtYSBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgU3RyaW5nIGdldE5hbWUoKSB7Ci0JCXJldHVybiB0aGlzLmR0cFNjaGVtYS5nZXROYW1lKCk7Ci0JfQotCi0JcHVibGljIERUUFNjaGVtYUNvbnRhaW5lcldyYXBwZXIgZ2V0Q29udGFpbmVyKCkgewotCQlyZXR1cm4gKERUUFNjaGVtYUNvbnRhaW5lcldyYXBwZXIpIHRoaXMuZ2V0UGFyZW50KCk7Ci0JfQotCi0JLy8gKioqKiogdGFibGVzCi0KLQlwdWJsaWMgSXRlcmF0b3I8VGFibGU+IHRhYmxlcygpIHsKLQkJcmV0dXJuIG5ldyBBcnJheUl0ZXJhdG9yPFRhYmxlPih0aGlzLmdldFRhYmxlcygpKTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPERUUFRhYmxlV3JhcHBlcj4gdGFibGVXcmFwcGVycygpIHsKLQkJcmV0dXJuIG5ldyBBcnJheUl0ZXJhdG9yPERUUFRhYmxlV3JhcHBlcj4odGhpcy5nZXRUYWJsZXMoKSk7Ci0JfQotCi0JcHJpdmF0ZSBzeW5jaHJvbml6ZWQgRFRQVGFibGVXcmFwcGVyW10gZ2V0VGFibGVzKCkgewotCQlpZiAodGhpcy50YWJsZXMgPT0gbnVsbCkgewotCQkJdGhpcy50YWJsZXMgPSB0aGlzLmJ1aWxkVGFibGVzKCk7Ci0JCX0KLQkJcmV0dXJuIHRoaXMudGFibGVzOwotCX0KLQotCXByaXZhdGUgRFRQVGFibGVXcmFwcGVyW10gYnVpbGRUYWJsZXMoKSB7Ci0JCUxpc3Q8b3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLlRhYmxlPiBkdHBUYWJsZXMgPSB0aGlzLmdldERUUFRhYmxlcygpOwotCQlEVFBUYWJsZVdyYXBwZXJbXSByZXN1bHQgPSBuZXcgRFRQVGFibGVXcmFwcGVyW2R0cFRhYmxlcy5zaXplKCldOwotCQlmb3IgKGludCBpID0gcmVzdWx0Lmxlbmd0aDsgaS0tID4gMDspIHsKLQkJCXJlc3VsdFtpXSA9IG5ldyBEVFBUYWJsZVdyYXBwZXIodGhpcywgZHRwVGFibGVzLmdldChpKSk7Ci0JCX0KLQkJcmV0dXJuIENvbGxlY3Rpb25Ub29scy5zb3J0KHJlc3VsdCk7Ci0JfQotCi0JLy8gbWluaW1pemUgc2NvcGUgb2Ygc3VwcHJlc3NlZCB3YXJuaW5ncwotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByaXZhdGUgTGlzdDxvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC50YWJsZXMuVGFibGU+IGdldERUUFRhYmxlcygpIHsKLQkJcmV0dXJuIHRoaXMuZHRwU2NoZW1hLmdldFRhYmxlcygpOwotCX0KLQotCXB1YmxpYyBpbnQgdGFibGVzU2l6ZSgpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0VGFibGVzKCkubGVuZ3RoOwotCX0KLQotCS8qKgotCSAqIHJldHVybiB0aGUgdGFibGUgZm9yIHRoZSBzcGVjaWZpZWQgRFRQIHRhYmxlCi0JICovCi0JRFRQVGFibGVXcmFwcGVyIGdldFRhYmxlKG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnRhYmxlcy5UYWJsZSBkdHBUYWJsZSkgewotCQkvLyB0cnkgdG8gc2hvcnQtY2lyY3VpdCB0aGUgc2VhcmNoCi0JCXJldHVybiB0aGlzLndyYXBzKGR0cFRhYmxlLmdldFNjaGVtYSgpKSA/Ci0JCQkJCQl0aGlzLmdldFRhYmxlXyhkdHBUYWJsZSkKLQkJCQkJOgotCQkJCQkJdGhpcy5nZXRDb250YWluZXIoKS5nZXRUYWJsZShkdHBUYWJsZSk7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIHRoZSBzY2hlbWEgY29udGFpbnMgdGhlIHNwZWNpZmllZCB0YWJsZQotCSAqLwotCURUUFRhYmxlV3JhcHBlciBnZXRUYWJsZV8ob3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLlRhYmxlIGR0cFRhYmxlKSB7Ci0JCWZvciAoRFRQVGFibGVXcmFwcGVyIHRhYmxlIDogdGhpcy5nZXRUYWJsZXMoKSkgewotCQkJaWYgKHRhYmxlLndyYXBzKGR0cFRhYmxlKSkgewotCQkJCXJldHVybiB0YWJsZTsKLQkJCX0KLQkJfQotCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJpbnZhbGlkIERUUCB0YWJsZTogIiArIGR0cFRhYmxlKTsgIC8vJE5PTi1OTFMtMSQKLQl9Ci0KLQlwdWJsaWMgRFRQVGFibGVXcmFwcGVyIGdldFRhYmxlTmFtZWQoU3RyaW5nIG5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuc2VsZWN0RGF0YWJhc2VPYmplY3ROYW1lZCh0aGlzLmdldFRhYmxlcygpLCBuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgSXRlcmF0b3I8U3RyaW5nPiBzb3J0ZWRUYWJsZUlkZW50aWZpZXJzKCkgewotCQkvLyB0aGUgdGFibGVzIGFyZSBhbHJlYWR5IHNvcnRlZAotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8RFRQVGFibGVXcmFwcGVyLCBTdHJpbmc+KHRoaXMudGFibGVXcmFwcGVycygpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKERUUFRhYmxlV3JhcHBlciB0YWJsZSkgewotCQkJCSByZXR1cm4gdGFibGUuZ2V0SWRlbnRpZmllcigpOwotCQkJfQotCQl9OwotCX0KLQotCXB1YmxpYyBEVFBUYWJsZVdyYXBwZXIgZ2V0VGFibGVGb3JJZGVudGlmaWVyKFN0cmluZyBpZGVudGlmaWVyKSB7Ci0JCXJldHVybiB0aGlzLnNlbGVjdERhdGFiYXNlT2JqZWN0Rm9ySWRlbnRpZmllcih0aGlzLmdldFRhYmxlcygpLCBpZGVudGlmaWVyKTsKLQl9Ci0KLQkvLyAqKioqKiBzZXF1ZW5jZXMKLQotCXB1YmxpYyBJdGVyYXRvcjxTZXF1ZW5jZT4gc2VxdWVuY2VzKCkgewotCQlyZXR1cm4gbmV3IEFycmF5SXRlcmF0b3I8U2VxdWVuY2U+KHRoaXMuZ2V0U2VxdWVuY2VzKCkpOwotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8RFRQU2VxdWVuY2VXcmFwcGVyPiBzZXF1ZW5jZVdyYXBwZXJzKCkgewotCQlyZXR1cm4gbmV3IEFycmF5SXRlcmF0b3I8RFRQU2VxdWVuY2VXcmFwcGVyPih0aGlzLmdldFNlcXVlbmNlcygpKTsKLQl9Ci0KLQlwcml2YXRlIHN5bmNocm9uaXplZCBEVFBTZXF1ZW5jZVdyYXBwZXJbXSBnZXRTZXF1ZW5jZXMoKSB7Ci0JCWlmICh0aGlzLnNlcXVlbmNlcyA9PSBudWxsKSB7Ci0JCQl0aGlzLnNlcXVlbmNlcyA9IHRoaXMuYnVpbGRTZXF1ZW5jZXMoKTsKLQkJfQotCQlyZXR1cm4gdGhpcy5zZXF1ZW5jZXM7Ci0JfQotCi0JcHJpdmF0ZSBEVFBTZXF1ZW5jZVdyYXBwZXJbXSBidWlsZFNlcXVlbmNlcygpIHsKLQkJTGlzdDxvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuU2VxdWVuY2U+IGR0cFNlcXVlbmNlcyA9IHRoaXMuZ2V0RFRQU2VxdWVuY2VzKCk7Ci0JCURUUFNlcXVlbmNlV3JhcHBlcltdIHJlc3VsdCA9IG5ldyBEVFBTZXF1ZW5jZVdyYXBwZXJbZHRwU2VxdWVuY2VzLnNpemUoKV07Ci0JCWZvciAoaW50IGkgPSByZXN1bHQubGVuZ3RoOyBpLS0gPiAwOykgewotCQkJcmVzdWx0W2ldID0gbmV3IERUUFNlcXVlbmNlV3JhcHBlcih0aGlzLCBkdHBTZXF1ZW5jZXMuZ2V0KGkpKTsKLQkJfQotCQlyZXR1cm4gQ29sbGVjdGlvblRvb2xzLnNvcnQocmVzdWx0KTsKLQl9Ci0KLQkvLyBtaW5pbWl6ZSBzY29wZSBvZiBzdXBwcmVzc2VkIHdhcm5pbmdzCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJpdmF0ZSBMaXN0PG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5TZXF1ZW5jZT4gZ2V0RFRQU2VxdWVuY2VzKCkgewotCQlyZXR1cm4gdGhpcy5kdHBTY2hlbWEuZ2V0U2VxdWVuY2VzKCk7Ci0JfQotCi0JcHVibGljIGludCBzZXF1ZW5jZXNTaXplKCkgewotCQlyZXR1cm4gdGhpcy5nZXRTZXF1ZW5jZXMoKS5sZW5ndGg7Ci0JfQotCi0JcHVibGljIERUUFNlcXVlbmNlV3JhcHBlciBnZXRTZXF1ZW5jZU5hbWVkKFN0cmluZyBuYW1lKSB7Ci0JCXJldHVybiB0aGlzLnNlbGVjdERhdGFiYXNlT2JqZWN0TmFtZWQodGhpcy5nZXRTZXF1ZW5jZXMoKSwgbmFtZSk7Ci0JfQotCi0JcHVibGljIEl0ZXJhdG9yPFN0cmluZz4gc29ydGVkU2VxdWVuY2VJZGVudGlmaWVycygpIHsKLQkJLy8gdGhlIHNlcXVlbmNlcyBhcmUgYWxyZWFkeSBzb3J0ZWQKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yPERUUFNlcXVlbmNlV3JhcHBlciwgU3RyaW5nPih0aGlzLnNlcXVlbmNlV3JhcHBlcnMoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShEVFBTZXF1ZW5jZVdyYXBwZXIgc2VxdWVuY2UpIHsKLQkJCQkgcmV0dXJuIHNlcXVlbmNlLmdldElkZW50aWZpZXIoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwdWJsaWMgRFRQU2VxdWVuY2VXcmFwcGVyIGdldFNlcXVlbmNlRm9ySWRlbnRpZmllcihTdHJpbmcgaWRlbnRpZmllcikgewotCQlyZXR1cm4gdGhpcy5zZWxlY3REYXRhYmFzZU9iamVjdEZvcklkZW50aWZpZXIodGhpcy5nZXRTZXF1ZW5jZXMoKSwgaWRlbnRpZmllcik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIENvbXBhcmFibGUgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIGludCBjb21wYXJlVG8oU2NoZW1hIHNjaGVtYSkgewotCQlyZXR1cm4gQ29sbGF0b3IuZ2V0SW5zdGFuY2UoKS5jb21wYXJlKHRoaXMuZ2V0TmFtZSgpLCBzY2hlbWEuZ2V0TmFtZSgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW50ZXJuYWwgbWV0aG9kcyAqKioqKioqKioqCi0KLQlib29sZWFuIHdyYXBzKG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5TY2hlbWEgc2NoZW1hKSB7Ci0JCXJldHVybiB0aGlzLmR0cFNjaGVtYSA9PSBzY2hlbWE7Ci0JfQotCi0JLyoqCi0JICogcmV0dXJuIHRoZSBjb2x1bW4gZm9yIHRoZSBzcGVjaWZpZWQgRFRQIGNvbHVtbgotCSAqLwotCURUUENvbHVtbldyYXBwZXIgZ2V0Q29sdW1uKG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnRhYmxlcy5Db2x1bW4gZHRwQ29sdW1uKSB7Ci0JCS8vIHRyeSB0byBzaG9ydC1jaXJjdWl0IHRoZSBzZWFyY2gKLQkJcmV0dXJuIHRoaXMud3JhcHMoZHRwQ29sdW1uLmdldFRhYmxlKCkuZ2V0U2NoZW1hKCkpID8KLQkJCQkJCXRoaXMuZ2V0Q29sdW1uXyhkdHBDb2x1bW4pCi0JCQkJCToKLQkJCQkJCXRoaXMuZ2V0Q29udGFpbmVyKCkuZ2V0Q29sdW1uKGR0cENvbHVtbik7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIHRoZSBzY2hlbWEgY29udGFpbnMgdGhlIHNwZWNpZmllZCBjb2x1bW4KLQkgKi8KLQlEVFBDb2x1bW5XcmFwcGVyIGdldENvbHVtbl8ob3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLkNvbHVtbiBkdHBDb2x1bW4pIHsKLQkJcmV0dXJuIHRoaXMuZ2V0VGFibGVfKGR0cENvbHVtbi5nZXRUYWJsZSgpKS5nZXRDb2x1bW5fKGR0cENvbHVtbik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGxpc3RlbmluZyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlzeW5jaHJvbml6ZWQgdm9pZCBzdGFydExpc3RlbmluZygpIHsKLQkJaWYgKHRoaXMuc2VxdWVuY2VzICE9IG51bGwpIHsKLQkJCXRoaXMuc3RhcnRTZXF1ZW5jZXMoKTsKLQkJfQotCQlpZiAodGhpcy50YWJsZXMgIT0gbnVsbCkgewotCQkJdGhpcy5zdGFydFRhYmxlcygpOwotCQl9Ci0JCXN1cGVyLnN0YXJ0TGlzdGVuaW5nKCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHN0YXJ0U2VxdWVuY2VzKCkgewotCQlmb3IgKERUUFNlcXVlbmNlV3JhcHBlciBzZXF1ZW5jZSA6IHRoaXMuc2VxdWVuY2VzKSB7Ci0JCQlzZXF1ZW5jZS5zdGFydExpc3RlbmluZygpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHN0YXJ0VGFibGVzKCkgewotCQlmb3IgKERUUFRhYmxlV3JhcHBlciB0YWJsZSA6IHRoaXMudGFibGVzKSB7Ci0JCQl0YWJsZS5zdGFydExpc3RlbmluZygpOwotCQl9Ci0JfQotCi0JQE92ZXJyaWRlCi0Jc3luY2hyb25pemVkIHZvaWQgc3RvcExpc3RlbmluZygpIHsKLQkJaWYgKHRoaXMuc2VxdWVuY2VzICE9IG51bGwpIHsKLQkJCXRoaXMuc3RvcFNlcXVlbmNlcygpOwotCQl9Ci0JCWlmICh0aGlzLnRhYmxlcyAhPSBudWxsKSB7Ci0JCQl0aGlzLnN0b3BUYWJsZXMoKTsKLQkJfQotCQlzdXBlci5zdG9wTGlzdGVuaW5nKCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHN0b3BTZXF1ZW5jZXMoKSB7Ci0JCWZvciAoRFRQU2VxdWVuY2VXcmFwcGVyIHNlcXVlbmNlIDogdGhpcy5zZXF1ZW5jZXMpIHsKLQkJCXNlcXVlbmNlLnN0b3BMaXN0ZW5pbmcoKTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBzdG9wVGFibGVzKCkgewotCQlmb3IgKERUUFRhYmxlV3JhcHBlciB0YWJsZSA6IHRoaXMudGFibGVzKSB7Ci0JCQl0YWJsZS5zdG9wTGlzdGVuaW5nKCk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogY2xlYXIgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0Jc3luY2hyb25pemVkIHZvaWQgY2xlYXIoKSB7Ci0JCWlmICh0aGlzLnNlcXVlbmNlcyAhPSBudWxsKSB7Ci0JCQl0aGlzLmNsZWFyU2VxdWVuY2VzKCk7Ci0JCX0KLQkJaWYgKHRoaXMudGFibGVzICE9IG51bGwpIHsKLQkJCXRoaXMuY2xlYXJUYWJsZXMoKTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBjbGVhclNlcXVlbmNlcygpIHsKLQkJdGhpcy5zdG9wU2VxdWVuY2VzKCk7Ci0JCWZvciAoRFRQU2VxdWVuY2VXcmFwcGVyIHNlcXVlbmNlIDogdGhpcy5zZXF1ZW5jZXMpIHsKLQkJCXNlcXVlbmNlLmNsZWFyKCk7Ci0JCX0KLQkJdGhpcy5zZXF1ZW5jZXMgPSBudWxsOwotCX0KLQotCXByaXZhdGUgdm9pZCBjbGVhclRhYmxlcygpIHsKLQkJdGhpcy5zdG9wVGFibGVzKCk7Ci0JCWZvciAoRFRQVGFibGVXcmFwcGVyIHRhYmxlIDogdGhpcy50YWJsZXMpIHsKLQkJCXRhYmxlLmNsZWFyKCk7Ci0JCX0KLQkJdGhpcy50YWJsZXMgPSBudWxsOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvRFRQU2VxdWVuY2VXcmFwcGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC9EVFBTZXF1ZW5jZVdyYXBwZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmIwYjc2YS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC9EVFBTZXF1ZW5jZVdyYXBwZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDcyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsOwotCi1pbXBvcnQgamF2YS50ZXh0LkNvbGxhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5TZXF1ZW5jZTsKLQotLyoqCi0gKiAgV3JhcCBhIERUUCBTZXF1ZW5jZQotICovCi1maW5hbCBjbGFzcyBEVFBTZXF1ZW5jZVdyYXBwZXIKLQlleHRlbmRzIERUUERhdGFiYXNlT2JqZWN0V3JhcHBlcgotCWltcGxlbWVudHMgU2VxdWVuY2UKLXsKLQkvLyB0aGUgd3JhcHBlZCBEVFAgc2VxdWVuY2UKLQlwcml2YXRlIGZpbmFsIG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5TZXF1ZW5jZSBkdHBTZXF1ZW5jZTsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvciAqKioqKioqKioqCi0KLQlEVFBTZXF1ZW5jZVdyYXBwZXIoRFRQU2NoZW1hV3JhcHBlciBzY2hlbWEsIG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5TZXF1ZW5jZSBkdHBTZXF1ZW5jZSkgewotCQlzdXBlcihzY2hlbWEsIGR0cFNlcXVlbmNlKTsKLQkJdGhpcy5kdHBTZXF1ZW5jZSA9IGR0cFNlcXVlbmNlOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBEVFBXcmFwcGVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXN5bmNocm9uaXplZCB2b2lkIGNhdGFsb2dPYmplY3RDaGFuZ2VkKCkgewotCQlzdXBlci5jYXRhbG9nT2JqZWN0Q2hhbmdlZCgpOwotCQl0aGlzLmdldENvbm5lY3Rpb25Qcm9maWxlKCkuc2VxdWVuY2VDaGFuZ2VkKHRoaXMpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBTZXF1ZW5jZSBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgU3RyaW5nIGdldE5hbWUoKSB7Ci0JCXJldHVybiB0aGlzLmR0cFNlcXVlbmNlLmdldE5hbWUoKTsKLQl9Ci0KLQlwdWJsaWMgRFRQU2NoZW1hV3JhcHBlciBnZXRTY2hlbWEoKSB7Ci0JCXJldHVybiAoRFRQU2NoZW1hV3JhcHBlcikgdGhpcy5nZXRQYXJlbnQoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogQ29tcGFyYWJsZSBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgaW50IGNvbXBhcmVUbyhTZXF1ZW5jZSBzZXF1ZW5jZSkgewotCQlyZXR1cm4gQ29sbGF0b3IuZ2V0SW5zdGFuY2UoKS5jb21wYXJlKHRoaXMuZ2V0TmFtZSgpLCBzZXF1ZW5jZS5nZXROYW1lKCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbnRlcm5hbCBtZXRob2RzICoqKioqKioqKioKLQotCWJvb2xlYW4gd3JhcHMob3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLlNlcXVlbmNlIHNlcXVlbmNlKSB7Ci0JCXJldHVybiB0aGlzLmR0cFNlcXVlbmNlID09IHNlcXVlbmNlOwotCX0KLQotCUBPdmVycmlkZQotCXZvaWQgY2xlYXIoKSB7Ci0JCS8vIG5vIHN0YXRlIHRvIGNsZWFyCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC9EVFBUYWJsZVdyYXBwZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL0RUUFRhYmxlV3JhcHBlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkYThmMzMzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL0RUUFRhYmxlV3JhcHBlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDIwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsOwotCi1pbXBvcnQgamF2YS50ZXh0LkNvbGxhdG9yOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5jb25zdHJhaW50cy5QcmltYXJ5S2V5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnRhYmxlcy5CYXNlVGFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkNvbHVtbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuRm9yZWlnbktleTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuVGFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5BcnJheUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5UcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yOwotCi0vKioKLSAqICBXcmFwIGEgRFRQIFRhYmxlCi0gKi8KLWZpbmFsIGNsYXNzIERUUFRhYmxlV3JhcHBlcgotCWV4dGVuZHMgRFRQRGF0YWJhc2VPYmplY3RXcmFwcGVyCi0JaW1wbGVtZW50cyBUYWJsZQotewotCS8vIHRoZSB3cmFwcGVkIERUUCB0YWJsZQotCXByaXZhdGUgZmluYWwgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLlRhYmxlIGR0cFRhYmxlOwotCi0JLy8gbGF6eS1pbml0aWFsaXplZAotCXByaXZhdGUgRFRQQ29sdW1uV3JhcHBlcltdIGNvbHVtbnM7Ci0KLQkvLyBsYXp5LWluaXRpYWxpemVkCi0JcHJpdmF0ZSBEVFBDb2x1bW5XcmFwcGVyW10gcHJpbWFyeUtleUNvbHVtbnM7Ci0KLQkvLyBsYXp5LWluaXRpYWxpemVkCi0JcHJpdmF0ZSBEVFBGb3JlaWduS2V5V3JhcHBlcltdIGZvcmVpZ25LZXlzOwotCi0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBEVFBDb2x1bW5XcmFwcGVyW10gRU1QVFlfQ09MVU1OUyA9IG5ldyBEVFBDb2x1bW5XcmFwcGVyWzBdOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIERUUEZvcmVpZ25LZXlXcmFwcGVyW10gRU1QVFlfRk9SRUlHTl9LRVlTID0gbmV3IERUUEZvcmVpZ25LZXlXcmFwcGVyWzBdOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9yICoqKioqKioqKioKLQotCURUUFRhYmxlV3JhcHBlcihEVFBTY2hlbWFXcmFwcGVyIHNjaGVtYSwgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLlRhYmxlIGR0cFRhYmxlKSB7Ci0JCXN1cGVyKHNjaGVtYSwgZHRwVGFibGUpOwotCQl0aGlzLmR0cFRhYmxlID0gZHRwVGFibGU7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIERUUFdyYXBwZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0Jc3luY2hyb25pemVkIHZvaWQgY2F0YWxvZ09iamVjdENoYW5nZWQoKSB7Ci0JCXN1cGVyLmNhdGFsb2dPYmplY3RDaGFuZ2VkKCk7Ci0JCXRoaXMuZ2V0Q29ubmVjdGlvblByb2ZpbGUoKS50YWJsZUNoYW5nZWQodGhpcyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIFRhYmxlIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBTdHJpbmcgZ2V0TmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMuZHRwVGFibGUuZ2V0TmFtZSgpOwotCX0KLQotCXB1YmxpYyBEVFBTY2hlbWFXcmFwcGVyIGdldFNjaGVtYSgpIHsKLQkJcmV0dXJuIChEVFBTY2hlbWFXcmFwcGVyKSB0aGlzLmdldFBhcmVudCgpOwotCX0KLQotCS8vICoqKioqIGNvbHVtbnMKLQotCXB1YmxpYyBJdGVyYXRvcjxDb2x1bW4+IGNvbHVtbnMoKSB7Ci0JCXJldHVybiBuZXcgQXJyYXlJdGVyYXRvcjxDb2x1bW4+KHRoaXMuZ2V0Q29sdW1ucygpKTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPERUUENvbHVtbldyYXBwZXI+IGNvbHVtbldyYXBwZXJzKCkgewotCQlyZXR1cm4gbmV3IEFycmF5SXRlcmF0b3I8RFRQQ29sdW1uV3JhcHBlcj4odGhpcy5nZXRDb2x1bW5zKCkpOwotCX0KLQotCXByaXZhdGUgc3luY2hyb25pemVkIERUUENvbHVtbldyYXBwZXJbXSBnZXRDb2x1bW5zKCkgewotCQlpZiAodGhpcy5jb2x1bW5zID09IG51bGwpIHsKLQkJCXRoaXMuY29sdW1ucyA9IHRoaXMuYnVpbGRDb2x1bW5zKCk7Ci0JCX0KLQkJcmV0dXJuIHRoaXMuY29sdW1uczsKLQl9Ci0KLQlwcml2YXRlIERUUENvbHVtbldyYXBwZXJbXSBidWlsZENvbHVtbnMoKSB7Ci0JCUxpc3Q8b3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLkNvbHVtbj4gZHRwQ29sdW1ucyA9IHRoaXMuZ2V0RFRQQ29sdW1ucygpOwotCQlEVFBDb2x1bW5XcmFwcGVyW10gcmVzdWx0ID0gbmV3IERUUENvbHVtbldyYXBwZXJbZHRwQ29sdW1ucy5zaXplKCldOwotCQlmb3IgKGludCBpID0gcmVzdWx0Lmxlbmd0aDsgaS0tID4gMDspIHsKLQkJCXJlc3VsdFtpXSA9IG5ldyBEVFBDb2x1bW5XcmFwcGVyKHRoaXMsIGR0cENvbHVtbnMuZ2V0KGkpKTsKLQkJfQotCQlyZXR1cm4gQ29sbGVjdGlvblRvb2xzLnNvcnQocmVzdWx0KTsKLQl9Ci0KLQkvLyBtaW5pbWl6ZSBzY29wZSBvZiBzdXBwcmVzc2VkIHdhcm5pbmdzCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJpdmF0ZSBMaXN0PG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnRhYmxlcy5Db2x1bW4+IGdldERUUENvbHVtbnMoKSB7Ci0JCXJldHVybiB0aGlzLmR0cFRhYmxlLmdldENvbHVtbnMoKTsKLQl9Ci0KLQlwdWJsaWMgaW50IGNvbHVtbnNTaXplKCkgewotCQlyZXR1cm4gdGhpcy5nZXRDb2x1bW5zKCkubGVuZ3RoOwotCX0KLQotCXB1YmxpYyBEVFBDb2x1bW5XcmFwcGVyIGdldENvbHVtbk5hbWVkKFN0cmluZyBuYW1lKSB7Ci0JCXJldHVybiB0aGlzLnNlbGVjdERhdGFiYXNlT2JqZWN0TmFtZWQodGhpcy5nZXRDb2x1bW5zKCksIG5hbWUpOwotCX0KLQotCS8qKgotCSAqIHJldHVybiB0aGUgY29sdW1uIGZvciB0aGUgc3BlY2lmaWVkIERUUCBjb2x1bW4KLQkgKi8KLQlEVFBDb2x1bW5XcmFwcGVyIGdldENvbHVtbihvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC50YWJsZXMuQ29sdW1uIGR0cENvbHVtbikgewotCQkvLyB0cnkgdG8gc2hvcnQtY2lyY3VpdCB0aGUgc2VhcmNoCi0JCXJldHVybiB0aGlzLndyYXBzKGR0cENvbHVtbi5nZXRUYWJsZSgpKSA/Ci0JCQkJCQl0aGlzLmdldENvbHVtbl8oZHRwQ29sdW1uKQotCQkJCQk6Ci0JCQkJCQl0aGlzLmdldFNjaGVtYSgpLmdldENvbHVtbihkdHBDb2x1bW4pOwotCX0KLQotCS8qKgotCSAqIGFzc3VtZSB0aGUgdGFibGUgY29udGFpbnMgdGhlIHNwZWNpZmllZCBjb2x1bW4KLQkgKi8KLQlEVFBDb2x1bW5XcmFwcGVyIGdldENvbHVtbl8ob3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLkNvbHVtbiBkdHBDb2x1bW4pIHsKLQkJZm9yIChEVFBDb2x1bW5XcmFwcGVyIGNvbHVtbiA6IHRoaXMuZ2V0Q29sdW1ucygpKSB7Ci0JCQlpZiAoY29sdW1uLndyYXBzKGR0cENvbHVtbikpIHsKLQkJCQlyZXR1cm4gY29sdW1uOwotCQkJfQotCQl9Ci0JCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oImludmFsaWQgRFRQIGNvbHVtbjogIiArIGR0cENvbHVtbik7ICAvLyROT04tTkxTLTEkCi0JfQotCi0JcHVibGljIEl0ZXJhdG9yPFN0cmluZz4gc29ydGVkQ29sdW1uSWRlbnRpZmllcnMoKSB7Ci0JCS8vIHRoZSBjb2x1bW5zIGFyZSBhbHJlYWR5IHNvcnRlZAotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8RFRQQ29sdW1uV3JhcHBlciwgU3RyaW5nPih0aGlzLmNvbHVtbldyYXBwZXJzKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oRFRQQ29sdW1uV3JhcHBlciBuZXh0KSB7Ci0JCQkJIHJldHVybiBuZXh0LmdldElkZW50aWZpZXIoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwdWJsaWMgRFRQQ29sdW1uV3JhcHBlciBnZXRDb2x1bW5Gb3JJZGVudGlmaWVyKFN0cmluZyBpZGVudGlmaWVyKSB7Ci0JCXJldHVybiB0aGlzLnNlbGVjdERhdGFiYXNlT2JqZWN0Rm9ySWRlbnRpZmllcih0aGlzLmdldENvbHVtbnMoKSwgaWRlbnRpZmllcik7Ci0JfQotCi0JLy8gKioqKiogcHJpbWFyeUtleUNvbHVtbnMKLQotCXB1YmxpYyBJdGVyYXRvcjxDb2x1bW4+IHByaW1hcnlLZXlDb2x1bW5zKCkgewotCQlyZXR1cm4gbmV3IEFycmF5SXRlcmF0b3I8Q29sdW1uPih0aGlzLmdldFByaW1hcnlLZXlDb2x1bW5zKCkpOwotCX0KLQotCXB1YmxpYyBEVFBDb2x1bW5XcmFwcGVyIGdldFByaW1hcnlLZXlDb2x1bW4oKSB7Ci0JCURUUENvbHVtbldyYXBwZXJbXSBwa0NvbHVtbnMgPSB0aGlzLmdldFByaW1hcnlLZXlDb2x1bW5zKCk7Ci0JCWlmIChwa0NvbHVtbnMubGVuZ3RoICE9IDEpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oIm11bHRpcGxlIHByaW1hcnkga2V5IGNvbHVtbnM6ICIgKyBwa0NvbHVtbnMubGVuZ3RoKTsgIC8vJE5PTi1OTFMtMSQKLQkJfQotCQlyZXR1cm4gcGtDb2x1bW5zWzBdOwotCX0KLQotCXByaXZhdGUgc3luY2hyb25pemVkIERUUENvbHVtbldyYXBwZXJbXSBnZXRQcmltYXJ5S2V5Q29sdW1ucygpIHsKLQkJaWYgKHRoaXMucHJpbWFyeUtleUNvbHVtbnMgPT0gbnVsbCkgewotCQkJdGhpcy5wcmltYXJ5S2V5Q29sdW1ucyA9IHRoaXMuYnVpbGRQcmltYXJ5S2V5Q29sdW1ucygpOwotCQl9Ci0JCXJldHVybiB0aGlzLnByaW1hcnlLZXlDb2x1bW5zOwotCX0KLQotCXByaXZhdGUgRFRQQ29sdW1uV3JhcHBlcltdIGJ1aWxkUHJpbWFyeUtleUNvbHVtbnMoKSB7Ci0JCWlmICggISAodGhpcy5kdHBUYWJsZSBpbnN0YW5jZW9mIEJhc2VUYWJsZSkpIHsKLQkJCXJldHVybiBFTVBUWV9DT0xVTU5TOwotCQl9Ci0JCVByaW1hcnlLZXkgcGsgPSAoKEJhc2VUYWJsZSkgdGhpcy5kdHBUYWJsZSkuZ2V0UHJpbWFyeUtleSgpOwotCQlpZiAocGsgPT0gbnVsbCkgewotCQkJLy8gbm8gUEsgd2FzIGRlZmluZWQKLQkJCXJldHVybiBFTVBUWV9DT0xVTU5TOwotCQl9Ci0JCUxpc3Q8b3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLkNvbHVtbj4gcGtDb2x1bW5zID0gdGhpcy5nZXRDb2x1bW5zKHBrKTsKLQkJRFRQQ29sdW1uV3JhcHBlcltdIHJlc3VsdCA9IG5ldyBEVFBDb2x1bW5XcmFwcGVyW3BrQ29sdW1ucy5zaXplKCldOwotCQlmb3IgKGludCBpID0gcmVzdWx0Lmxlbmd0aDsgaS0tID4gMDspIHsKLQkJCXJlc3VsdFtpXSA9IHRoaXMuZ2V0Q29sdW1uKHBrQ29sdW1ucy5nZXQoaSkpOwotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLy8gbWluaW1pemUgc2NvcGUgb2Ygc3VwcHJlc3NlZCB3YXJuaW5ncwotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByaXZhdGUgTGlzdDxvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC50YWJsZXMuQ29sdW1uPiBnZXRDb2x1bW5zKFByaW1hcnlLZXkgcGspIHsKLQkJcmV0dXJuIHBrLmdldE1lbWJlcnMoKTsKLQl9Ci0KLQlwdWJsaWMgaW50IHByaW1hcnlLZXlDb2x1bW5zU2l6ZSgpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0UHJpbWFyeUtleUNvbHVtbnMoKS5sZW5ndGg7Ci0JfQotCi0JYm9vbGVhbiBwcmltYXJ5S2V5Q29sdW1uc0NvbnRhaW5zKENvbHVtbiBjb2x1bW4pIHsKLQkJcmV0dXJuIENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmdldFByaW1hcnlLZXlDb2x1bW5zKCksIGNvbHVtbik7Ci0JfQotCi0JLy8gKioqKiogZm9yZWlnbktleXMKLQotCXB1YmxpYyBJdGVyYXRvcjxGb3JlaWduS2V5PiBmb3JlaWduS2V5cygpIHsKLQkJcmV0dXJuIG5ldyBBcnJheUl0ZXJhdG9yPEZvcmVpZ25LZXk+KHRoaXMuZ2V0Rm9yZWlnbktleXMoKSk7Ci0JfQotCi0JcHJpdmF0ZSBzeW5jaHJvbml6ZWQgRFRQRm9yZWlnbktleVdyYXBwZXJbXSBnZXRGb3JlaWduS2V5cygpIHsKLQkJaWYgKHRoaXMuZm9yZWlnbktleXMgPT0gbnVsbCkgewotCQkJdGhpcy5mb3JlaWduS2V5cyA9IHRoaXMuYnVpbGRGb3JlaWduS2V5cygpOwotCQl9Ci0JCXJldHVybiB0aGlzLmZvcmVpZ25LZXlzOwotCX0KLQotCXByaXZhdGUgRFRQRm9yZWlnbktleVdyYXBwZXJbXSBidWlsZEZvcmVpZ25LZXlzKCkgewotCQlpZiAoICEgKHRoaXMuZHRwVGFibGUgaW5zdGFuY2VvZiBCYXNlVGFibGUpKSB7Ci0JCQlyZXR1cm4gRU1QVFlfRk9SRUlHTl9LRVlTOwotCQl9Ci0JCUxpc3Q8b3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuY29uc3RyYWludHMuRm9yZWlnbktleT4gZHRwRm9yZWlnbktleXMgPSB0aGlzLmdldERUUEZvcmVpZ25LZXlzKCk7Ci0JCURUUEZvcmVpZ25LZXlXcmFwcGVyW10gcmVzdWx0ID0gbmV3IERUUEZvcmVpZ25LZXlXcmFwcGVyW2R0cEZvcmVpZ25LZXlzLnNpemUoKV07Ci0JCWZvciAoaW50IGkgPSByZXN1bHQubGVuZ3RoOyBpLS0gPiAwOykgewotCQkJcmVzdWx0W2ldID0gbmV3IERUUEZvcmVpZ25LZXlXcmFwcGVyKHRoaXMsIGR0cEZvcmVpZ25LZXlzLmdldChpKSk7Ci0JCX0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcml2YXRlIExpc3Q8b3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuY29uc3RyYWludHMuRm9yZWlnbktleT4gZ2V0RFRQRm9yZWlnbktleXMoKSB7Ci0JCXJldHVybiAoKEJhc2VUYWJsZSkgdGhpcy5kdHBUYWJsZSkuZ2V0Rm9yZWlnbktleXMoKTsKLQl9Ci0KLQlwdWJsaWMgaW50IGZvcmVpZ25LZXlzU2l6ZSgpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Rm9yZWlnbktleXMoKS5sZW5ndGg7Ci0JfQotCi0JLyoqCi0JICogcmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBjb2x1bW4gaXMgYSBiYXNlIGNvbHVtbiBmb3IgYXQgbGVhc3Qgb25lCi0JICogb2YgdGhlIHRoZSB0YWJsZSdzIGZvcmVpZ24ga2V5cwotCSAqLwotCWJvb2xlYW4gZm9yZWlnbktleUJhc2VDb2x1bW5zQ29udGFpbnMoQ29sdW1uIGNvbHVtbikgewotCQlmb3IgKERUUEZvcmVpZ25LZXlXcmFwcGVyIGZrV3JhcHBlciA6IHRoaXMuZ2V0Rm9yZWlnbktleXMoKSkgewotCQkJaWYgKGZrV3JhcHBlci5iYXNlQ29sdW1uc0NvbnRhaW5zKGNvbHVtbikpIHsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JLy8gKioqKiogam9pbiB0YWJsZQotCi0JcHVibGljIGJvb2xlYW4gaXNQb3NzaWJsZUpvaW5UYWJsZSgpIHsKLQkJaWYgKHRoaXMuZ2V0Rm9yZWlnbktleXMoKS5sZW5ndGggIT0gMikgewotCQkJcmV0dXJuIGZhbHNlOyAgLy8gdGhlIHRhYmxlIG11c3QgaGF2ZSBleGFjdGx5IDIgZm9yZWlnbiBrZXlzCi0JCX0KLQkJZm9yIChDb2x1bW4gY29sdW1uIDogdGhpcy5nZXRDb2x1bW5zKCkpIHsKLQkJCWlmICggISB0aGlzLmZvcmVpZ25LZXlCYXNlQ29sdW1uc0NvbnRhaW5zKGNvbHVtbikpIHsKLQkJCQlyZXR1cm4gZmFsc2U7ICAvLyBhbGwgdGhlIHRhYmxlJ3MgY29sdW1ucyBtdXN0IGJlbG9uZyB0byBvbmUgKG9yIGJvdGgpIG9mIHRoZSAyIGZvcmVpZ24ga2V5cwotCQkJfQotCQl9Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCS8qKgotCSAqIElmIHRoZSB0YWJsZSBuYW1lIGlzIEZPT19CQVIgYW5kIGl0IGpvaW5zIHRhYmxlcyBGT08gYW5kIEJBUiwKLQkgKiByZXR1cm4gdGhlIGZvcmVpZ24ga2V5IHRvIEZPTzsKLQkgKiBpZiB0aGUgdGFibGUgbmFtZSBpcyBCQVJfRk9PIGFuZCBpdCBqb2lucyB0YWJsZXMgRk9PIGFuZCBCQVIsCi0JICogcmV0dXJuIHRoZSBmb3JlaWduIGtleSB0byBCQVI7Ci0JICogb3RoZXJ3aXNlIHNpbXBseSByZXR1cm4gdGhlIGZpcnN0IGZvcmVpZ24ga2V5IGluIHRoZSBhcnJheS4KLQkgKi8KLQlwdWJsaWMgRm9yZWlnbktleSBnZXRKb2luVGFibGVPd25pbmdGb3JlaWduS2V5KCkgewotCQlGb3JlaWduS2V5IGZrMCA9IHRoaXMuZ2V0Rm9yZWlnbktleXMoKVswXTsKLQkJU3RyaW5nIG5hbWUwID0gZmswLmdldFJlZmVyZW5jZWRUYWJsZSgpLmdldE5hbWUoKTsKLQotCQlGb3JlaWduS2V5IGZrMSA9IHRoaXMuZ2V0Rm9yZWlnbktleXMoKVsxXTsKLQkJU3RyaW5nIG5hbWUxID0gZmsxLmdldFJlZmVyZW5jZWRUYWJsZSgpLmdldE5hbWUoKTsKLQotCQlyZXR1cm4gdGhpcy5nZXROYW1lKCkuZXF1YWxzKG5hbWUxICsgJ18nICsgbmFtZTApID8gZmsxIDogZmswOwotCX0KLQotCXB1YmxpYyBGb3JlaWduS2V5IGdldEpvaW5UYWJsZU5vbk93bmluZ0ZvcmVpZ25LZXkoKSB7Ci0JCUZvcmVpZ25LZXkgZmswID0gdGhpcy5nZXRGb3JlaWduS2V5cygpWzBdOwotCQlGb3JlaWduS2V5IGZrMSA9IHRoaXMuZ2V0Rm9yZWlnbktleXMoKVsxXTsKLQkJRm9yZWlnbktleSBvZmsgPSB0aGlzLmdldEpvaW5UYWJsZU93bmluZ0ZvcmVpZ25LZXkoKTsKLQkJcmV0dXJuIChvZmsgPT0gZmswKSA/IGZrMSA6IGZrMDsKLQl9Ci0KLQkvKioKLQkgKiBIbW1tLi4uLgotCSAqIFdlIG1pZ2h0IHdhbnQgdG8gZ28gdG8gdGhlIHBsYXRmb3JtIHRvIGFsbG93IGEgdmVuZG9yLXNwZWNpZmljCi0JICogY29tcGFyaXNvbiBoZXJlOwotCSAqIGJ1dCwgc2luY2UgYWxsIHRoZSBuYW1lcyBhcmUgY29taW5nIGRpcmVjdGx5IGZyb20gdGhlIGRhdGFiYXNlCi0JICogKGkuZS4gdGhlcmUgYXJlIG5vIGNvbnZlcnNpb25zIHRvIEphdmEgaWRlbnRpZmllcnMgZXRjLiksIGl0IHNlZW1zCi0JICogbGlrZSB3ZSBjYW4ganVzdCBjb21wYXJlIHRoZW0gZGlyZWN0bHkgYW5kIGlnbm9yZSBjYXNlLXNlbnNpdGl2aXR5Ci0JICogaXNzdWVzLi4uLiAgfmJqdgotCSAqLwotCXB1YmxpYyBib29sZWFuIGpvaW5UYWJsZU5hbWVJc0RlZmF1bHQoKSB7Ci0JCXJldHVybiB0aGlzLmdldE5hbWUoKS5lcXVhbHModGhpcy5idWlsZERlZmF1bHRKb2luVGFibGVOYW1lKCkpOwotCX0KLQotCXByaXZhdGUgU3RyaW5nIGJ1aWxkRGVmYXVsdEpvaW5UYWJsZU5hbWUoKSB7Ci0JCXJldHVybiB0aGlzLmdldEpvaW5UYWJsZU93bmluZ1RhYmxlKCkuZ2V0TmFtZSgpCi0JCQkJCSsgJ18nCi0JCQkJCSsgdGhpcy5nZXRKb2luVGFibGVOb25Pd25pbmdUYWJsZSgpLmdldE5hbWUoKTsKLQl9Ci0KLQlwcml2YXRlIFRhYmxlIGdldEpvaW5UYWJsZU93bmluZ1RhYmxlKCkgewotCQlyZXR1cm4gdGhpcy5nZXRKb2luVGFibGVPd25pbmdGb3JlaWduS2V5KCkuZ2V0UmVmZXJlbmNlZFRhYmxlKCk7Ci0JfQotCi0JcHJpdmF0ZSBUYWJsZSBnZXRKb2luVGFibGVOb25Pd25pbmdUYWJsZSgpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Sm9pblRhYmxlTm9uT3duaW5nRm9yZWlnbktleSgpLmdldFJlZmVyZW5jZWRUYWJsZSgpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBDb21wYXJhYmxlIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBpbnQgY29tcGFyZVRvKFRhYmxlIHRhYmxlKSB7Ci0JCXJldHVybiBDb2xsYXRvci5nZXRJbnN0YW5jZSgpLmNvbXBhcmUodGhpcy5nZXROYW1lKCksIHRhYmxlLmdldE5hbWUoKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGludGVybmFsIG1ldGhvZHMgKioqKioqKioqKgotCi0JYm9vbGVhbiB3cmFwcyhvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC50YWJsZXMuVGFibGUgdGFibGUpIHsKLQkJcmV0dXJuIHRoaXMuZHRwVGFibGUgPT0gdGFibGU7Ci0JfQotCi0JLyoqCi0JICogcmV0dXJuIHRoZSB0YWJsZSBmb3IgdGhlIHNwZWNpZmllZCBEVFAgdGFibGUKLQkgKi8KLQlEVFBUYWJsZVdyYXBwZXIgZ2V0VGFibGUob3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwudGFibGVzLlRhYmxlIHRhYmxlKSB7Ci0JCS8vIHRyeSB0byBzaG9ydC1jaXJjdWl0IHRoZSBzZWFyY2gKLQkJcmV0dXJuIHRoaXMud3JhcHModGFibGUpID8gdGhpcyA6IHRoaXMuZ2V0U2NoZW1hKCkuZ2V0VGFibGUodGFibGUpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBsaXN0ZW5pbmcgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0Jc3luY2hyb25pemVkIHZvaWQgc3RhcnRMaXN0ZW5pbmcoKSB7Ci0JCWlmICh0aGlzLmZvcmVpZ25LZXlzICE9IG51bGwpIHsKLQkJCXRoaXMuc3RhcnRGb3JlaWduS2V5cygpOwotCQl9Ci0JCWlmICh0aGlzLmNvbHVtbnMgIT0gbnVsbCkgewotCQkJdGhpcy5zdGFydENvbHVtbnMoKTsKLQkJfQotCQlzdXBlci5zdGFydExpc3RlbmluZygpOwotCX0KLQotCXByaXZhdGUgdm9pZCBzdGFydEZvcmVpZ25LZXlzKCkgewotCQlmb3IgKERUUEZvcmVpZ25LZXlXcmFwcGVyIGZvcmVpZ25LZXkgOiB0aGlzLmZvcmVpZ25LZXlzKSB7Ci0JCQlmb3JlaWduS2V5LnN0YXJ0TGlzdGVuaW5nKCk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgc3RhcnRDb2x1bW5zKCkgewotCQlmb3IgKERUUENvbHVtbldyYXBwZXIgY29sdW1uIDogdGhpcy5jb2x1bW5zKSB7Ci0JCQljb2x1bW4uc3RhcnRMaXN0ZW5pbmcoKTsKLQkJfQotCX0KLQotCUBPdmVycmlkZQotCXN5bmNocm9uaXplZCB2b2lkIHN0b3BMaXN0ZW5pbmcoKSB7Ci0JCWlmICh0aGlzLmZvcmVpZ25LZXlzICE9IG51bGwpIHsKLQkJCXRoaXMuc3RvcEZvcmVpZ25LZXlzKCk7Ci0JCX0KLQkJaWYgKHRoaXMuY29sdW1ucyAhPSBudWxsKSB7Ci0JCQl0aGlzLnN0b3BDb2x1bW5zKCk7Ci0JCX0KLQkJc3VwZXIuc3RvcExpc3RlbmluZygpOwotCX0KLQotCXByaXZhdGUgdm9pZCBzdG9wRm9yZWlnbktleXMoKSB7Ci0JCWZvciAoRFRQRm9yZWlnbktleVdyYXBwZXIgZm9yZWlnbktleSA6IHRoaXMuZm9yZWlnbktleXMpIHsKLQkJCWZvcmVpZ25LZXkuc3RvcExpc3RlbmluZygpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHN0b3BDb2x1bW5zKCkgewotCQlmb3IgKERUUENvbHVtbldyYXBwZXIgY29sdW1uIDogdGhpcy5jb2x1bW5zKSB7Ci0JCQljb2x1bW4uc3RvcExpc3RlbmluZygpOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNsZWFyICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXZvaWQgY2xlYXIoKSB7Ci0JCWlmICh0aGlzLmZvcmVpZ25LZXlzICE9IG51bGwpIHsKLQkJCXRoaXMuY2xlYXJGb3JlaWduS2V5cygpOwotCQl9Ci0KLQkJLy8gdGhlIHRhYmxlIGRvZXMgbm90ICJjb250YWluIiB0aGUgcGsgY29sdW1ucywgc28gbm8gbmVlZCB0byBmb3J3YXJkICNjbGVhcigpCi0JCXRoaXMucHJpbWFyeUtleUNvbHVtbnMgPSBudWxsOwotCi0JCWlmICh0aGlzLmNvbHVtbnMgIT0gbnVsbCkgewotCQkJdGhpcy5jbGVhckNvbHVtbnMoKTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBjbGVhckZvcmVpZ25LZXlzKCkgewotCQl0aGlzLnN0b3BGb3JlaWduS2V5cygpOwotCQlmb3IgKERUUEZvcmVpZ25LZXlXcmFwcGVyIGZvcmVpZ25LZXkgOiB0aGlzLmZvcmVpZ25LZXlzKSB7Ci0JCQlmb3JlaWduS2V5LmNsZWFyKCk7Ci0JCX0KLSAgICAJdGhpcy5mb3JlaWduS2V5cyA9IG51bGw7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGNsZWFyQ29sdW1ucygpIHsKLQkJdGhpcy5zdG9wQ29sdW1ucygpOwotCQlmb3IgKERUUENvbHVtbldyYXBwZXIgY29sdW1uIDogdGhpcy5jb2x1bW5zKSB7Ci0JCQljb2x1bW4uY2xlYXIoKTsKLQkJfQotICAgIAl0aGlzLmNvbHVtbnMgPSBudWxsOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL0Fic3RyYWN0VmVuZG9yLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvQWJzdHJhY3RWZW5kb3IuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZGJiMWE3OC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvQWJzdHJhY3RWZW5kb3IuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI4MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYi5pbnRlcm5hbC52ZW5kb3I7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLkNhdGFsb2c7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLkRhdGFiYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5TY2hlbWE7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotCi0vKioKLSAqIENvbnNvbGlkYXRlIHRoZSBiZWhhdmlvciBjb21tb24gdG8gdGhlIHR5cGljYWwgdmVuZG9ycy4KLSAqLwotYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3RWZW5kb3IKLQlpbXBsZW1lbnRzIFZlbmRvcgotewotCi0JQWJzdHJhY3RWZW5kb3IoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JcHVibGljIGFic3RyYWN0IFN0cmluZyBnZXREVFBWZW5kb3JOYW1lKCk7Ci0KLQotCS8vICoqKioqKioqKiogY2F0YWxvZyBhbmQgc2NoZW1hIHN1cHBvcnQgKioqKioqKioqKgotCi0JYWJzdHJhY3QgQ2F0YWxvZ1N0cmF0ZWd5IGdldENhdGFsb2dTdHJhdGVneSgpOwotCi0JcHVibGljIGJvb2xlYW4gc3VwcG9ydHNDYXRhbG9ncyhEYXRhYmFzZSBkYXRhYmFzZSkgewotCQlyZXR1cm4gdGhpcy5nZXRDYXRhbG9nU3RyYXRlZ3koKS5zdXBwb3J0c0NhdGFsb2dzKGRhdGFiYXNlKTsKLQl9Ci0KLQlwdWJsaWMgTGlzdDxDYXRhbG9nPiBnZXRDYXRhbG9ncyhEYXRhYmFzZSBkYXRhYmFzZSkgewotCQlyZXR1cm4gdGhpcy5nZXRDYXRhbG9nU3RyYXRlZ3koKS5nZXRDYXRhbG9ncyhkYXRhYmFzZSk7Ci0JfQotCi0JcHVibGljIExpc3Q8U2NoZW1hPiBnZXRTY2hlbWFzKERhdGFiYXNlIGRhdGFiYXNlKSB7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gdGhpcy5nZXRDYXRhbG9nU3RyYXRlZ3koKS5nZXRTY2hlbWFzKGRhdGFiYXNlKTsKLQkJfSBjYXRjaCAoRXhjZXB0aW9uIGV4KSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbigidmVuZG9yOiAiICsgdGhpcywgZXgpOyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLQkvKioKLQkgKiBUeXBpY2FsbHksIHRoZSBuYW1lIG9mIHRoZSBkZWZhdWx0IGNhdGFsb2cgaXMgdGhlIHVzZXIgbmFtZS4KLQkgKi8KLQlwdWJsaWMgTGlzdDxTdHJpbmc+IGdldERlZmF1bHRDYXRhbG9nSWRlbnRpZmllcnMoRGF0YWJhc2UgZGF0YWJhc2UsIFN0cmluZyB1c2VyTmFtZSkgewotCQlBcnJheUxpc3Q8U3RyaW5nPiBpZGVudGlmaWVycyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQl0aGlzLmFkZERlZmF1bHRDYXRhbG9nSWRlbnRpZmllcnNUbyhkYXRhYmFzZSwgdXNlck5hbWUsIGlkZW50aWZpZXJzKTsKLQkJcmV0dXJuIGlkZW50aWZpZXJzOwotCX0KLQotCXZvaWQgYWRkRGVmYXVsdENhdGFsb2dJZGVudGlmaWVyc1RvKEBTdXBwcmVzc1dhcm5pbmdzKCJ1bnVzZWQiKSBEYXRhYmFzZSBkYXRhYmFzZSwgU3RyaW5nIHVzZXJOYW1lLCBBcnJheUxpc3Q8U3RyaW5nPiBpZGVudGlmaWVycykgewotCQlpZGVudGlmaWVycy5hZGQodXNlck5hbWUpOwotCX0KLQotCS8qKgotCSAqIFR5cGljYWxseSwgdGhlIG5hbWUgb2YgdGhlIGRlZmF1bHQgc2NoZW1hIGlzIHRoZSB1c2VyIG5hbWUuCi0JICovCi0JcHVibGljIExpc3Q8U3RyaW5nPiBnZXREZWZhdWx0U2NoZW1hSWRlbnRpZmllcnMoRGF0YWJhc2UgZGF0YWJhc2UsIFN0cmluZyB1c2VyTmFtZSkgewotCQlBcnJheUxpc3Q8U3RyaW5nPiBpZGVudGlmaWVycyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQl0aGlzLmFkZERlZmF1bHRTY2hlbWFJZGVudGlmaWVyc1RvKGRhdGFiYXNlLCB1c2VyTmFtZSwgaWRlbnRpZmllcnMpOwotCQlyZXR1cm4gaWRlbnRpZmllcnM7Ci0JfQotCi0Jdm9pZCBhZGREZWZhdWx0U2NoZW1hSWRlbnRpZmllcnNUbyhAU3VwcHJlc3NXYXJuaW5ncygidW51c2VkIikgRGF0YWJhc2UgZGF0YWJhc2UsIFN0cmluZyB1c2VyTmFtZSwgQXJyYXlMaXN0PFN0cmluZz4gaWRlbnRpZmllcnMpIHsKLQkJaWRlbnRpZmllcnMuYWRkKHVzZXJOYW1lKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogZm9sZGluZyBzdHJhdGVneSB1c2VkIHRvIGNvbnZlcnQgbmFtZXMgYW5kIGlkZW50aWZpZXJzICoqKioqKioqKioKLQotCS8qKgotCSAqIFRoZSBTUUwgc3BlYyBzYXlzIGEgIm5vcm1hbCIgKG5vbi1kZWxpbWl0ZWQpIGlkZW50aWZpZXIgc2hvdWxkIGJlCi0JICogZm9sZGVkIHRvIHVwcGVyY2FzZTsgYnV0IHNvbWUgZGF0YWJhc2VzIGRvIG90aGVyd2lzZSAoZS5nLiBTeWJhc2UpLgotCSAqLwotCWFic3RyYWN0IEZvbGRpbmdTdHJhdGVneSBnZXRGb2xkaW5nU3RyYXRlZ3koKTsKLQotCi0JLy8gKioqKioqKioqKiBuYW1lIC0+IGlkZW50aWZpZXIgKioqKioqKioqKgotCi0JcHVibGljIFN0cmluZyBjb252ZXJ0TmFtZVRvSWRlbnRpZmllcihTdHJpbmcgbmFtZSwgU3RyaW5nIGRlZmF1bHROYW1lKSB7Ci0JCXJldHVybiB0aGlzLm5hbWVSZXF1aXJlc0RlbGltaXRlcnMobmFtZSkgPyB0aGlzLmRlbGltaXROYW1lKG5hbWUpCi0JCQkJCQk6IHRoaXMubm9ybWFsTmFtZXNNYXRjaChuYW1lLCBkZWZhdWx0TmFtZSkgPyBudWxsIDogbmFtZTsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGNvbnZlcnROYW1lVG9JZGVudGlmaWVyKFN0cmluZyBuYW1lKSB7Ci0JCXJldHVybiB0aGlzLm5hbWVSZXF1aXJlc0RlbGltaXRlcnMobmFtZSkgPyB0aGlzLmRlbGltaXROYW1lKG5hbWUpIDogbmFtZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGRhdGFiYXNlIG9iamVjdCBuYW1lIG11c3QgYmUgZGVsaW1pdGVkCi0JICogd2hlbiB1c2VkIGluIGFuIFNRTCBzdGF0ZW1lbnQuCi0JICogSWYgdGhlIG5hbWUgaGFzIGFueSAic3BlY2lhbCIgY2hhcmFjdGVycyAoYXMgb3Bwb3NlZCB0byBsZXR0ZXJzLAotCSAqIGRpZ2l0cywgYW5kIG90aGVyIGFsbG93ZWQgY2hhcmFjdGVycyBbZS5nLiB1bmRlcnNjb3Jlc10pLCBpdCByZXF1aXJlcwotCSAqIGRlbGltaXRlcnMuCi0JICogSWYgdGhlIG5hbWUgaXMgbWl4ZWQgY2FzZSBhbmQgdGhlIGRhdGFiYXNlIGZvbGRzIHVuZGVsaW1pdGVkIG5hbWVzCi0JICogKHRvIGVpdGhlciB1cHBlcmNhc2Ugb3IgbG93ZXJjYXNlKSwgaXQgcmVxdWlyZXMgZGVsaW1pdGVycy4KLQkgKi8KLQlib29sZWFuIG5hbWVSZXF1aXJlc0RlbGltaXRlcnMoU3RyaW5nIG5hbWUpIHsKLQkJcmV0dXJuIChuYW1lLmxlbmd0aCgpID09IDApICAvLyAgYW4gZW1wdHkgc3RyaW5nIG11c3QgYmUgZGVsaW1pdGVkKD8pCi0JCQkJCXx8IHRoaXMubmFtZUNvbnRhaW5zQW55Tm9uTm9ybWFsQ2hhcmFjdGVycyhuYW1lKQotCQkJCQl8fCB0aGlzLm5hbWVJc05vdEZvbGRlZChuYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIG5hbWUgY29udGFpbnMgYW55ICJub24tbm9ybWFsIiBjaGFyYWN0ZXJzCi0JICogdGhhdCByZXF1aXJlIHRoZSBuYW1lIHRvIGJlIGRlbGltaXRlZC4KLQkgKiBQcmUtY29uZGl0aW9uOiB0aGUgc3BlY2lmaWVkIG5hbWUgaXMgbm90IGVtcHR5Ci0JICovCi0JYm9vbGVhbiBuYW1lQ29udGFpbnNBbnlOb25Ob3JtYWxDaGFyYWN0ZXJzKFN0cmluZyBuYW1lKSB7Ci0JCWNoYXJbXSBzdHJpbmcgPSBuYW1lLnRvQ2hhckFycmF5KCk7Ci0JCWlmICh0aGlzLmNoYXJhY3RlcklzTm9uTm9ybWFsTmFtZVN0YXJ0KHN0cmluZ1swXSkpIHsKLQkJCXJldHVybiB0cnVlOwotCQl9Ci0JCWZvciAoaW50IGkgPSBzdHJpbmcubGVuZ3RoOyBpLS0gPiAxOyApIHsgIC8vIG5vdGU6IHN0b3AgYXQgMQotCQkJaWYgKHRoaXMuY2hhcmFjdGVySXNOb25Ob3JtYWxOYW1lUGFydChzdHJpbmdbaV0pKSB7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgY2hhcmFjdGVyIGlzICJub24tbm9ybWFsIiBmb3IgdGhlIGZpcnN0Ci0JICogY2hhcmFjdGVyIG9mIGEgbmFtZS4KLQkgKiBUeXBpY2FsbHksIGRhdGFiYXNlcyBhcmUgbW9yZSByZXN0cmljdGl2ZSBhYm91dCB3aGF0IGNoYXJhY3RlcnMgY2FuCi0JICogYmUgdXNlZCB0byAqc3RhcnQqIGFuIGlkZW50aWZpZXIgKGFzIG9wcG9zZWQgdG8gdGhlIGNoYXJhY3RlcnMKLQkgKiBhbGxvd2VkIGZvciB0aGUgcmVtYWluZGVyIG9mIHRoZSBpZGVudGlmaWVyKS4KLQkgKi8KLQlib29sZWFuIGNoYXJhY3RlcklzTm9uTm9ybWFsTmFtZVN0YXJ0KGNoYXIgYykgewotCQlyZXR1cm4gISB0aGlzLmNoYXJhY3RlcklzTm9ybWFsTmFtZVN0YXJ0KGMpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgY2hhcmFjdGVyIGlzICJub3JtYWwiIGZvciB0aGUgZmlyc3QKLQkgKiBjaGFyYWN0ZXIgb2YgYSBuYW1lLgotCSAqIFRoZSBmaXJzdCBjaGFyYWN0ZXIgb2YgYW4gaWRlbnRpZmllciBjYW4gYmU6Ci0JICogICAtIGEgbGV0dGVyCi0JICogICAtIGFueSBvZiB0aGUgZXh0ZW5kZWQsIHZlbmRvci1zcGVjaWZpYywgIm5vcm1hbCIgc3RhcnQgY2hhcmFjdGVycwotCSAqLwotCWJvb2xlYW4gY2hhcmFjdGVySXNOb3JtYWxOYW1lU3RhcnQoY2hhciBjKSB7Ci0JCS8vIGFsbCB2ZW5kb3JzIGFsbG93IGEgbGV0dGVyCi0JCXJldHVybiBDaGFyYWN0ZXIuaXNMZXR0ZXIoYykKLQkJCQl8fCB0aGlzLmNoYXJhY3RlcklzRXh0ZW5kZWROb3JtYWxOYW1lU3RhcnQoYyk7Ci0JfQotCi0JYm9vbGVhbiBjaGFyYWN0ZXJJc0V4dGVuZGVkTm9ybWFsTmFtZVN0YXJ0KGNoYXIgYykgewotCQlyZXR1cm4gYXJyYXlDb250YWlucyh0aGlzLmdldEV4dGVuZGVkTm9ybWFsTmFtZVN0YXJ0Q2hhcmFjdGVycygpLCBjKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlICJub3JtYWwiIGNoYXJhY3RlcnMsIGJleW9uZCBsZXR0ZXJzLCBmb3IgdGhlCi0JICogZmlyc3QgY2hhcmFjdGVyIG9mIGEgbmFtZS4KLQkgKiBSZXR1cm4gbnVsbCBpZiB0aGVyZSBhcmUgbm8gImV4dGVuZGVkIiBjaGFyYWN0ZXJzLgotCSAqLwotCWNoYXJbXSBnZXRFeHRlbmRlZE5vcm1hbE5hbWVTdGFydENoYXJhY3RlcnMoKSB7Ci0JCXJldHVybiBudWxsOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgY2hhcmFjdGVyIGlzICJub24tbm9ybWFsIiBmb3IgdGhlIHNlY29uZAotCSAqIGFuZCBzdWJzZXF1ZW50IGNoYXJhY3RlcnMgb2YgYSBuYW1lLgotCSAqLwotCWJvb2xlYW4gY2hhcmFjdGVySXNOb25Ob3JtYWxOYW1lUGFydChjaGFyIGMpIHsKLQkJcmV0dXJuICEgdGhpcy5jaGFyYWN0ZXJJc05vcm1hbE5hbWVQYXJ0KGMpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgY2hhcmFjdGVyIGlzICJub3JtYWwiIGZvciB0aGUgc2Vjb25kIGFuZAotCSAqIHN1YnNlcXVlbnQgY2hhcmFjdGVycyBvZiBhIG5hbWUuCi0JICogVGhlIHNlY29uZCBhbmQgc3Vic2VxdWVudCBjaGFyYWN0ZXJzIG9mIGEgIm5vcm1hbCIgbmFtZSBjYW4gYmU6Ci0JICogICAtIGEgbGV0dGVyCi0JICogICAtIGEgZGlnaXQKLQkgKiAgIC0gYW55IG9mIHRoZSBleHRlbmRlZCwgdmVuZG9yLXNwZWNpZmljLCAibm9ybWFsIiBzdGFydCBjaGFyYWN0ZXJzCi0JICogICAtIGFueSBvZiB0aGUgZXh0ZW5kZWQsIHZlbmRvci1zcGVjaWZpYywgIm5vcm1hbCIgcGFydCBjaGFyYWN0ZXJzCi0JICovCi0JYm9vbGVhbiBjaGFyYWN0ZXJJc05vcm1hbE5hbWVQYXJ0KGNoYXIgYykgewotCQkvLyBhbGwgdmVuZG9ycyBhbGxvdyBhIGxldHRlciBvciBkaWdpdAotCQlyZXR1cm4gQ2hhcmFjdGVyLmlzTGV0dGVyT3JEaWdpdChjKQotCQkJCXx8IHRoaXMuY2hhcmFjdGVySXNFeHRlbmRlZE5vcm1hbE5hbWVTdGFydChjKQotCQkJCXx8IHRoaXMuY2hhcmFjdGVySXNFeHRlbmRlZE5vcm1hbE5hbWVQYXJ0KGMpOwotCX0KLQotCWJvb2xlYW4gY2hhcmFjdGVySXNFeHRlbmRlZE5vcm1hbE5hbWVQYXJ0KGNoYXIgYykgewotCQlyZXR1cm4gYXJyYXlDb250YWlucyh0aGlzLmdldEV4dGVuZGVkTm9ybWFsTmFtZVBhcnRDaGFyYWN0ZXJzKCksIGMpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgIm5vcm1hbCIgY2hhcmFjdGVycywgYmV5b25kIGxldHRlcnMgYW5kIGRpZ2l0cyBhbmQgdGhlCi0JICogIm5vcm1hbCIgZmlyc3QgY2hhcmFjdGVycywgZm9yIHRoZSBzZWNvbmQgYW5kIHN1YnNlcXVlbnQgY2hhcmFjdGVycwotCSAqIG9mIGFuIGlkZW50aWZpZXIuIFJldHVybiBudWxsIGlmIHRoZXJlIGFyZSBubyBhZGRpdGlvbmFsIGNoYXJhY3RlcnMuCi0JICovCi0JY2hhcltdIGdldEV4dGVuZGVkTm9ybWFsTmFtZVBhcnRDaGFyYWN0ZXJzKCkgewotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIG5hbWUgaXMgbm90IGZvbGRlZCB0byB0aGUgZGF0YWJhc2UncwotCSAqIGNhc2UsIHJlcXVpcmluZyBpdCB0byBiZSBkZWxpbWl0ZWQuCi0JICovCi0JYm9vbGVhbiBuYW1lSXNOb3RGb2xkZWQoU3RyaW5nIG5hbWUpIHsKLQkJcmV0dXJuICEgdGhpcy5nZXRGb2xkaW5nU3RyYXRlZ3koKS5uYW1lSXNGb2xkZWQobmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCAibm9ybWFsIiBuYW1lcyBtYXRjaC4KLQkgKi8KLQlib29sZWFuIG5vcm1hbE5hbWVzTWF0Y2goU3RyaW5nIG5hbWUxLCBTdHJpbmcgbmFtZTIpIHsKLQkJcmV0dXJuIHRoaXMubm9ybWFsSWRlbnRpZmllcnNBcmVDYXNlU2Vuc2l0aXZlKCkgPwotCQkJCQkJbmFtZTEuZXF1YWxzKG5hbWUyKQotCQkJCQk6Ci0JCQkJCQluYW1lMS5lcXVhbHNJZ25vcmVDYXNlKG5hbWUyKTsKLQl9Ci0KLQkvKioKLQkgKiBUeXBpY2FsbHksICJub3JtYWwiIGlkZW50aWZpZXJzIGFyZSBjYXNlLWluc2Vuc2l0aXZlLgotCSAqLwotCWJvb2xlYW4gbm9ybWFsSWRlbnRpZmllcnNBcmVDYXNlU2Vuc2l0aXZlKCkgewotCQlyZXR1cm4gdGhpcy5nZXRGb2xkaW5nU3RyYXRlZ3koKS5ub3JtYWxJZGVudGlmaWVyc0FyZUNhc2VTZW5zaXRpdmUoKTsKLQl9Ci0KLQkvKioKLQkgKiBXcmFwIHRoZSBzcGVjaWZpZWQgbmFtZSBpbiBkZWxpbWl0ZXJzICh0eXBpY2FsbHkgZG91YmxlLXF1b3RlcyksCi0JICogY29udmVydGluZyBpdCB0byBhbiBpZGVudGlmaWVyLgotCSAqLwotCVN0cmluZyBkZWxpbWl0TmFtZShTdHJpbmcgbmFtZSkgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMucXVvdGUobmFtZSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGlkZW50aWZpZXIgLT4gbmFtZSAqKioqKioqKioqCi0KLQkvLyBub3Qgc3VyZSBob3cgdG8gaGFuZGxlIGFuIGVtcHR5IHN0cmluZzoKLQkvLyBib3RoICIiIGFuZCAiXCJcIiIgYXJlIGNvbnZlcnRlZCB0byAiIiAuLi4KLQkvLyBjb252ZXJ0ICIiIHRvICdudWxsJyBzaW5jZSBlbXB0eSBzdHJpbmdzIG11c3QgYmUgZGVsaW1pdGVkPwotCXB1YmxpYyBTdHJpbmcgY29udmVydElkZW50aWZpZXJUb05hbWUoU3RyaW5nIGlkZW50aWZpZXIpIHsKLQkJcmV0dXJuIChpZGVudGlmaWVyID09IG51bGwpID8gbnVsbCA6Ci0JCQkJCXRoaXMuaWRlbnRpZmllcklzRGVsaW1pdGVkKGlkZW50aWZpZXIpID8KLQkJCQkJCVN0cmluZ1Rvb2xzLnVuZGVsaW1pdChpZGVudGlmaWVyKQotCQkJCQk6Ci0JCQkJCQl0aGlzLmdldEZvbGRpbmdTdHJhdGVneSgpLmZvbGQoaWRlbnRpZmllcik7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBpZGVudGlmaWVyIGlzICJkZWxpbWl0ZWQiLgotCSAqIFRoZSBTUUwtOTIgc3BlYyBzYXlzIGlkZW50aWZpZXJzIHNob3VsZCBiZSBkZWxpbWl0ZWQgYnkKLQkgKiBkb3VibGUtcXVvdGVzOyBidXQgc29tZSBkYXRhYmFzZXMgYWxsb3cgb3RoZXJ3aXNlIChlLmcuIFN5YmFzZSkuCi0JICovCi0JYm9vbGVhbiBpZGVudGlmaWVySXNEZWxpbWl0ZWQoU3RyaW5nIGlkZW50aWZpZXIpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLnN0cmluZ0lzUXVvdGVkKGlkZW50aWZpZXIpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBtaXNjICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiB0aGlzLmdldERUUFZlbmRvck5hbWUoKTsKLQl9Ci0KLQkvKioKLQkgKiBzdGF0aWMgY29udmVuaWVuY2UgbWV0aG9kIC0gYXJyYXkgbnVsbCBjaGVjawotCSAqLwotCXN0YXRpYyBib29sZWFuIGFycmF5Q29udGFpbnMoY2hhcltdIGFycmF5LCBjaGFyIGMpIHsKLQkJcmV0dXJuIChhcnJheSAhPSBudWxsKSAmJiBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYXJyYXksIGMpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL0NhdGFsb2dTdHJhdGVneS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL0NhdGFsb2dTdHJhdGVneS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5YzdhNGI1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9DYXRhbG9nU3RyYXRlZ3kuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDM4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsLnZlbmRvcjsKLQotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLkNhdGFsb2c7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLkRhdGFiYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5TY2hlbWE7Ci0KLS8qKgotICogSGFuZGxlIHRoZSB2YXJpZXR5IG9mIGNhdGFsb2cgKGFuZCBzY2hlbWEpIGNvbmZpZ3VyYXRpb25zIGdlbmVyYXRlZCBieSBEVFAuCi0gKi8KLWludGVyZmFjZSBDYXRhbG9nU3RyYXRlZ3kgewotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIERUUCBkYXRhYmFzZSBoYXMgcmVhbCBjYXRhbG9ncy4KLQkgKi8KLQlib29sZWFuIHN1cHBvcnRzQ2F0YWxvZ3MoRGF0YWJhc2UgZGF0YWJhc2UpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzcGVjaWZpZWQgZGF0YWJhc2UncyBjYXRhbG9ncy4KLQkgKi8KLQlMaXN0PENhdGFsb2c+IGdldENhdGFsb2dzKERhdGFiYXNlIGRhdGFiYXNlKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc3BlY2lmaWVkIGRhdGFiYXNlJ3Mgc2NoZW1hcy4KLQkgKi8KLQlMaXN0PFNjaGVtYT4gZ2V0U2NoZW1hcyhEYXRhYmFzZSBkYXRhYmFzZSk7Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9EQjIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9EQjIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjU5ZDAzOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvREIyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw2MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYi5pbnRlcm5hbC52ZW5kb3I7Ci0KLWNsYXNzIERCMgotCWV4dGVuZHMgQWJzdHJhY3RWZW5kb3IKLXsKLQlwcml2YXRlIGZpbmFsIFN0cmluZyBkdHBWZW5kb3JOYW1lOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgVmVuZG9yIFVEQiA9IG5ldyBEQjIoIkRCMiBVREIiKTsgLy8kTk9OLU5MUy0xJAotCXByaXZhdGUgc3RhdGljIGZpbmFsIFZlbmRvciBVREJfSV9TRVJJRVMgPSBuZXcgREIyKCJEQjIgVURCIGlTZXJpZXMiKTsgLy8kTk9OLU5MUy0xJAotCXByaXZhdGUgc3RhdGljIGZpbmFsIFZlbmRvciBVREJfWl9TRVJJRVMgPSBuZXcgREIyKCJEQjIgVURCIHpTZXJpZXMiKTsgLy8kTk9OLU5MUy0xJAotCi0Jc3RhdGljIFZlbmRvciB1ZGIoKSB7Ci0JCXJldHVybiBVREI7Ci0JfQotCi0Jc3RhdGljIFZlbmRvciB1ZGJJU2VyaWVzKCkgewotCQlyZXR1cm4gVURCX0lfU0VSSUVTOwotCX0KLQotCXN0YXRpYyBWZW5kb3IgdWRiWlNlcmllcygpIHsKLQkJcmV0dXJuIFVEQl9aX1NFUklFUzsKLQl9Ci0KLQkvKioKLQkgKiBFbnN1cmUgb25seSBzdGF0aWMgaW5zdGFuY2VzLgotCSAqLwotCXByaXZhdGUgREIyKFN0cmluZyBkdHBWZW5kb3JOYW1lKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuZHRwVmVuZG9yTmFtZSA9IGR0cFZlbmRvck5hbWU7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyBnZXREVFBWZW5kb3JOYW1lKCkgewotCQlyZXR1cm4gdGhpcy5kdHBWZW5kb3JOYW1lOwotCX0KLQotCUBPdmVycmlkZQotCUNhdGFsb2dTdHJhdGVneSBnZXRDYXRhbG9nU3RyYXRlZ3koKSB7Ci0JCXJldHVybiBVbmtub3duQ2F0YWxvZ1N0cmF0ZWd5Lmluc3RhbmNlKCk7ICAvLyBub3QgdmVyaWZpZWQgeWV0Li4uCi0JfQotCi0JQE92ZXJyaWRlCi0JRm9sZGluZ1N0cmF0ZWd5IGdldEZvbGRpbmdTdHJhdGVneSgpIHsKLQkJcmV0dXJuIFVwcGVyQ2FzZUZvbGRpbmdTdHJhdGVneS5pbnN0YW5jZSgpOwotCX0KLQotCUBPdmVycmlkZQotCWNoYXJbXSBnZXRFeHRlbmRlZE5vcm1hbE5hbWVQYXJ0Q2hhcmFjdGVycygpIHsKLQkJcmV0dXJuIEVYVEVOREVEX05PUk1BTF9OQU1FX1BBUlRfQ0hBUkFDVEVSUzsKLQl9Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgY2hhcltdIEVYVEVOREVEX05PUk1BTF9OQU1FX1BBUlRfQ0hBUkFDVEVSUyA9IG5ldyBjaGFyW10geyAnXycgfTsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL0RlcmJ5LmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvRGVyYnkuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZGUzNDIxZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvRGVyYnkuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDcwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsLnZlbmRvcjsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuRGF0YWJhc2U7Ci0KLWNsYXNzIERlcmJ5Ci0JZXh0ZW5kcyBBYnN0cmFjdFZlbmRvcgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIFZlbmRvciBJTlNUQU5DRSA9IG5ldyBEZXJieSgpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0Jc3RhdGljIFZlbmRvciBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBEZXJieSgpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIGdldERUUFZlbmRvck5hbWUoKSB7Ci0JCXJldHVybiAiRGVyYnkiOyAvLyROT04tTkxTLTEkCi0JfQotCi0JQE92ZXJyaWRlCi0JQ2F0YWxvZ1N0cmF0ZWd5IGdldENhdGFsb2dTdHJhdGVneSgpIHsKLQkJcmV0dXJuIEZhdXhDYXRhbG9nU3RyYXRlZ3kuaW5zdGFuY2UoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlGb2xkaW5nU3RyYXRlZ3kgZ2V0Rm9sZGluZ1N0cmF0ZWd5KCkgewotCQlyZXR1cm4gVXBwZXJDYXNlRm9sZGluZ1N0cmF0ZWd5Lmluc3RhbmNlKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0Jdm9pZCBhZGREZWZhdWx0U2NoZW1hSWRlbnRpZmllcnNUbyhEYXRhYmFzZSBkYXRhYmFzZSwgU3RyaW5nIHVzZXJOYW1lLCBBcnJheUxpc3Q8U3RyaW5nPiBpZGVudGlmaWVycykgewotCQlpZGVudGlmaWVycy5hZGQodGhpcy5idWlsZERlZmF1bHRTY2hlbWFJZGVudGlmaWVyKHVzZXJOYW1lKSk7Ci0JfQotCi0JLyoqCi0JICogVGhlIGRlZmF1bHQgdXNlciBuYW1lIG9uIERlcmJ5IGlzICJBUFAiLgotCSAqLwotCXByaXZhdGUgU3RyaW5nIGJ1aWxkRGVmYXVsdFNjaGVtYUlkZW50aWZpZXIoU3RyaW5nIHVzZXJOYW1lKSB7Ci0JCXJldHVybiAoKHVzZXJOYW1lICE9IG51bGwpICYmICh1c2VyTmFtZS5sZW5ndGgoKSAhPSAwKSkgPyB1c2VyTmFtZSA6IERFRkFVTFRfVVNFUl9OQU1FOwotCX0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgREVGQVVMVF9VU0VSX05BTUUgPSAiQVBQIjsgIC8vJE5PTi1OTFMtMSQKLQotCUBPdmVycmlkZQotCWNoYXJbXSBnZXRFeHRlbmRlZE5vcm1hbE5hbWVQYXJ0Q2hhcmFjdGVycygpIHsKLQkJcmV0dXJuIEVYVEVOREVEX05PUk1BTF9OQU1FX1BBUlRfQ0hBUkFDVEVSUzsKLQl9Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgY2hhcltdIEVYVEVOREVEX05PUk1BTF9OQU1FX1BBUlRfQ0hBUkFDVEVSUyA9IG5ldyBjaGFyW10geyAnXycgfTsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL0ZhdXhDYXRhbG9nU3RyYXRlZ3kuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9GYXV4Q2F0YWxvZ1N0cmF0ZWd5LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGI1YjViNDIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL0ZhdXhDYXRhbG9nU3RyYXRlZ3kuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDczICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsLnZlbmRvcjsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uczsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5DYXRhbG9nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5EYXRhYmFzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuU2NoZW1hOwotCi0vKioKLSAqIENhdGFsb2cgc3RyYXRlZ3kgZm9yIERUUCBkYXRhYmFzZXMgdGhhdCBidWlsZCBhICJ2aXJ0dWFsIiBjYXRhbG9nICh0aGF0IGhhcwotICogbm8gbmFtZSkgYmVjYXVzZSB0aGUgdW5kZXJseWluZyBKREJDIGRyaXZlciBkb2VzIG5vdCByZXR1cm4gYW55IGNhdGFsb2dzCi0gKiAoZS5nLiBPcmFjbGUpLgotICogQHNlZSBqYXZhLnNxbC5EYXRhYmFzZU1ldGFEYXRhI2dldENhdGFsb2dzKCkKLSAqLwotY2xhc3MgRmF1eENhdGFsb2dTdHJhdGVneQotCWltcGxlbWVudHMgQ2F0YWxvZ1N0cmF0ZWd5Ci17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgQ2F0YWxvZ1N0cmF0ZWd5IElOU1RBTkNFID0gbmV3IEZhdXhDYXRhbG9nU3RyYXRlZ3koKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXN0YXRpYyBDYXRhbG9nU3RyYXRlZ3kgaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0KLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRmF1eENhdGFsb2dTdHJhdGVneSgpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBzdXBwb3J0c0NhdGFsb2dzKERhdGFiYXNlIGRhdGFiYXNlKSB7Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQlwdWJsaWMgTGlzdDxDYXRhbG9nPiBnZXRDYXRhbG9ncyhEYXRhYmFzZSBkYXRhYmFzZSkgewotCQlyZXR1cm4gQ29sbGVjdGlvbnMuZW1wdHlMaXN0KCk7Ci0JfQotCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHVibGljIExpc3Q8U2NoZW1hPiBnZXRTY2hlbWFzKERhdGFiYXNlIGRhdGFiYXNlKSB7Ci0JCXJldHVybiB0aGlzLmdldEZhdXhDYXRhbG9nKGRhdGFiYXNlLmdldENhdGFsb2dzKCkpLmdldFNjaGVtYXMoKTsKLQl9Ci0KLQlwcml2YXRlIENhdGFsb2cgZ2V0RmF1eENhdGFsb2coTGlzdDxDYXRhbG9nPiBjYXRhbG9ncykgewotCQlpZiAoY2F0YWxvZ3MgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigpOwotCQl9Ci0JCWlmIChjYXRhbG9ncy5zaXplKCkgIT0gMSkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigibm90IGEgc2luZ2xlIGNhdGFsb2c6ICIgKyBjYXRhbG9ncy5zaXplKCkpOyAvLyROT04tTkxTLTEkCi0JCX0KLQotCQlDYXRhbG9nIGNhdGFsb2cgPSBjYXRhbG9ncy5nZXQoMCk7Ci0JCWlmIChjYXRhbG9nLmdldE5hbWUoKS5sZW5ndGgoKSAhPSAwKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJpbGxlZ2FsIG5hbWU6ICIgKyBjYXRhbG9nLmdldE5hbWUoKSk7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQlyZXR1cm4gY2F0YWxvZzsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9Gb2xkaW5nU3RyYXRlZ3kuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9Gb2xkaW5nU3RyYXRlZ3kuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTUyN2Y1Ni4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvRm9sZGluZ1N0cmF0ZWd5LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYi5pbnRlcm5hbC52ZW5kb3I7Ci0KLS8qKgotICogSGFuZGxlIGRhdGFiYXNlLXNwZWNpZmljIGlkZW50aWZpZXItZm9sZGluZyBpc3N1ZXMuCi0gKi8KLWludGVyZmFjZSBGb2xkaW5nU3RyYXRlZ3kgewotCi0JLyoqCi0JICogRm9sZCB0aGUgc3BlY2lmaWVkIG5hbWUuCi0JICovCi0JU3RyaW5nIGZvbGQoU3RyaW5nIG5hbWUpOwotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBkYXRhYmFzZSBvYmplY3QgbmFtZSBpcyBhbHJlYWR5IGZvbGRlZCwKLQkgKiBtZWFuaW5nLCBpZiBpdCBoYXMgbm8gc3BlY2lhbCBjaGFyYWN0ZXJzLCBpdCByZXF1aXJlcyBubyBkZWxpbWl0ZXJzLgotCSAqLwotCWJvb2xlYW4gbmFtZUlzRm9sZGVkKFN0cmluZyBuYW1lKTsKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBkYXRhYmFzZSBpcyBjYXNlLXNlbnNpdGl2ZSB3aGVuIHVzaW5nICJub3JtYWwiCi0JICogKGkuZS4gbm9uLWRlbGltaXRlZCkgaWRlbnRpZmllcnMuCi0JICovCi0JYm9vbGVhbiBub3JtYWxJZGVudGlmaWVyc0FyZUNhc2VTZW5zaXRpdmUoKTsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL0hTUUxEQi5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL0hTUUxEQi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxYjQzYmY4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9IU1FMREIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsLnZlbmRvcjsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuRGF0YWJhc2U7Ci0KLWNsYXNzIEhTUUxEQgotCWV4dGVuZHMgQWJzdHJhY3RWZW5kb3IKLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBWZW5kb3IgSU5TVEFOQ0UgPSBuZXcgSFNRTERCKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlzdGF0aWMgVmVuZG9yIGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEhTUUxEQigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIGdldERUUFZlbmRvck5hbWUoKSB7Ci0JCXJldHVybiAiSFNRTERCIjsgLy8kTk9OLU5MUy0xJAotCX0KLQotCUBPdmVycmlkZQotCUNhdGFsb2dTdHJhdGVneSBnZXRDYXRhbG9nU3RyYXRlZ3koKSB7Ci0JCXJldHVybiBVbmtub3duQ2F0YWxvZ1N0cmF0ZWd5Lmluc3RhbmNlKCk7ICAvLyBub3QgdmVyaWZpZWQgeWV0Li4uCi0JfQotCi0JQE92ZXJyaWRlCi0JRm9sZGluZ1N0cmF0ZWd5IGdldEZvbGRpbmdTdHJhdGVneSgpIHsKLQkJcmV0dXJuIFVwcGVyQ2FzZUZvbGRpbmdTdHJhdGVneS5pbnN0YW5jZSgpOwotCX0KLQotCUBPdmVycmlkZQotCXZvaWQgYWRkRGVmYXVsdFNjaGVtYUlkZW50aWZpZXJzVG8oRGF0YWJhc2UgZGF0YWJhc2UsIFN0cmluZyB1c2VyTmFtZSwgQXJyYXlMaXN0PFN0cmluZz4gaWRlbnRpZmllcnMpIHsKLQkJaWRlbnRpZmllcnMuYWRkKFBVQkxJQ19TQ0hFTUFfTkFNRSk7Ci0JfQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBQVUJMSUNfU0NIRU1BX05BTUUgPSAiUFVCTElDIjsgIC8vJE5PTi1OTFMtMSQKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL0luZm9ybWl4LmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvSW5mb3JtaXguamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjAwYzRiMi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvSW5mb3JtaXguamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsLnZlbmRvcjsKLQotY2xhc3MgSW5mb3JtaXgKLQlleHRlbmRzIEFic3RyYWN0VmVuZG9yCi17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgVmVuZG9yIElOU1RBTkNFID0gbmV3IEluZm9ybWl4KCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlzdGF0aWMgVmVuZG9yIGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEluZm9ybWl4KCkgewotCQlzdXBlcigpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgZ2V0RFRQVmVuZG9yTmFtZSgpIHsKLQkJcmV0dXJuICJJbmZvcm1peCI7IC8vJE5PTi1OTFMtMSQKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlDYXRhbG9nU3RyYXRlZ3kgZ2V0Q2F0YWxvZ1N0cmF0ZWd5KCkgewotCQlyZXR1cm4gVW5rbm93bkNhdGFsb2dTdHJhdGVneS5pbnN0YW5jZSgpOyAgLy8gbm90IHZlcmlmaWVkIHlldC4uLgotCX0KLQotCUBPdmVycmlkZQotCUZvbGRpbmdTdHJhdGVneSBnZXRGb2xkaW5nU3RyYXRlZ3koKSB7Ci0JCXJldHVybiBMb3dlckNhc2VGb2xkaW5nU3RyYXRlZ3kuaW5zdGFuY2UoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQljaGFyW10gZ2V0RXh0ZW5kZWROb3JtYWxOYW1lU3RhcnRDaGFyYWN0ZXJzKCkgewotCQlyZXR1cm4gRVhURU5ERURfTk9STUFMX05BTUVfU1RBUlRfQ0hBUkFDVEVSUzsKLQl9Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgY2hhcltdIEVYVEVOREVEX05PUk1BTF9OQU1FX1NUQVJUX0NIQVJBQ1RFUlMgPSBuZXcgY2hhcltdIHsgJ18nIH07Ci0KLQlAT3ZlcnJpZGUKLQljaGFyW10gZ2V0RXh0ZW5kZWROb3JtYWxOYW1lUGFydENoYXJhY3RlcnMoKSB7Ci0JCXJldHVybiBFWFRFTkRFRF9OT1JNQUxfTkFNRV9QQVJUX0NIQVJBQ1RFUlM7Ci0JfQotCXByaXZhdGUgc3RhdGljIGZpbmFsIGNoYXJbXSBFWFRFTkRFRF9OT1JNQUxfTkFNRV9QQVJUX0NIQVJBQ1RFUlMgPSBuZXcgY2hhcltdIHsgJyQnIH07Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9Mb3dlckNhc2VGb2xkaW5nU3RyYXRlZ3kuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9Mb3dlckNhc2VGb2xkaW5nU3RyYXRlZ3kuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODMzYzcwZi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvTG93ZXJDYXNlRm9sZGluZ1N0cmF0ZWd5LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYi5pbnRlcm5hbC52ZW5kb3I7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5DbGFzc1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotCi0vKioKLSAqIEZvbGQgIm5vcm1hbCIgaWRlbnRpZmllcnMgdG8gbG93ZXIgY2FzZS4KLSAqIElnbm9yZSB0aGUgY2FzZSBvZiAibm9ybWFsIiBpZGVudGlmaWVycy4KLSAqLwotY2xhc3MgTG93ZXJDYXNlRm9sZGluZ1N0cmF0ZWd5Ci0JaW1wbGVtZW50cyBGb2xkaW5nU3RyYXRlZ3kKLXsKLQotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEZvbGRpbmdTdHJhdGVneSBJTlNUQU5DRSA9IG5ldyBMb3dlckNhc2VGb2xkaW5nU3RyYXRlZ3koKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXN0YXRpYyBGb2xkaW5nU3RyYXRlZ3kgaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0KLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgTG93ZXJDYXNlRm9sZGluZ1N0cmF0ZWd5KCkgewotCQlzdXBlcigpOwotCX0KLQotCXB1YmxpYyBTdHJpbmcgZm9sZChTdHJpbmcgbmFtZSkgewotCQlyZXR1cm4gbmFtZS50b0xvd2VyQ2FzZSgpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIG5hbWVJc0ZvbGRlZChTdHJpbmcgbmFtZSkgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuc3RyaW5nSXNMb3dlcmNhc2UobmFtZSk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gbm9ybWFsSWRlbnRpZmllcnNBcmVDYXNlU2Vuc2l0aXZlKCkgewotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIENsYXNzVG9vbHMudG9TdHJpbmdDbGFzc05hbWVGb3JPYmplY3QodGhpcyk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvTWF4REIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9NYXhEQi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3ZDA4MThjLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9NYXhEQi5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWwudmVuZG9yOwotCi1jbGFzcyBNYXhEQgotCWV4dGVuZHMgQWJzdHJhY3RWZW5kb3IKLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBWZW5kb3IgSU5TVEFOQ0UgPSBuZXcgTWF4REIoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXN0YXRpYyBWZW5kb3IgaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0KLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgTWF4REIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyBnZXREVFBWZW5kb3JOYW1lKCkgewotCQlyZXR1cm4gIk1heERCIjsgLy8kTk9OLU5MUy0xJAotCX0KLQotCUBPdmVycmlkZQotCUNhdGFsb2dTdHJhdGVneSBnZXRDYXRhbG9nU3RyYXRlZ3koKSB7Ci0JCXJldHVybiBVbmtub3duQ2F0YWxvZ1N0cmF0ZWd5Lmluc3RhbmNlKCk7ICAvLyBub3QgdmVyaWZpZWQgeWV0Li4uCi0JfQotCi0JQE92ZXJyaWRlCi0JRm9sZGluZ1N0cmF0ZWd5IGdldEZvbGRpbmdTdHJhdGVneSgpIHsKLQkJcmV0dXJuIFVwcGVyQ2FzZUZvbGRpbmdTdHJhdGVneS5pbnN0YW5jZSgpOwotCX0KLQotCUBPdmVycmlkZQotCWNoYXJbXSBnZXRFeHRlbmRlZE5vcm1hbE5hbWVTdGFydENoYXJhY3RlcnMoKSB7Ci0JCXJldHVybiBFWFRFTkRFRF9OT1JNQUxfTkFNRV9TVEFSVF9DSEFSQUNURVJTOwotCX0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBjaGFyW10gRVhURU5ERURfTk9STUFMX05BTUVfU1RBUlRfQ0hBUkFDVEVSUyA9IG5ldyBjaGFyW10geyAnIycsICdAJywgJyQnIH07Ci0KLQlAT3ZlcnJpZGUKLQljaGFyW10gZ2V0RXh0ZW5kZWROb3JtYWxOYW1lUGFydENoYXJhY3RlcnMoKSB7Ci0JCXJldHVybiBFWFRFTkRFRF9OT1JNQUxfTkFNRV9QQVJUX0NIQVJBQ1RFUlM7Ci0JfQotCXByaXZhdGUgc3RhdGljIGZpbmFsIGNoYXJbXSBFWFRFTkRFRF9OT1JNQUxfTkFNRV9QQVJUX0NIQVJBQ1RFUlMgPSBuZXcgY2hhcltdIHsgJ18nIH07Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9NeVNRTC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL015U1FMLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGEwODQ3ZjAuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL015U1FMLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMDkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWwudmVuZG9yOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5EYXRhYmFzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotY2xhc3MgTXlTUUwKLQlleHRlbmRzIEFic3RyYWN0VmVuZG9yCi17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgVmVuZG9yIElOU1RBTkNFID0gbmV3IE15U1FMKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlzdGF0aWMgVmVuZG9yIGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIE15U1FMKCkgewotCQlzdXBlcigpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgZ2V0RFRQVmVuZG9yTmFtZSgpIHsKLQkJcmV0dXJuICJNeVNxbCI7IC8vJE5PTi1OTFMtMSQKLQl9Ci0KLQkvKioKLQkgKiBUaGUgRFRQIG1vZGVsIGZvciBNeVNRTCBoYXMgYSBkYXRhYmFzZSB0aGF0IGNvbnRhaW5zIG5vIGNhdGFsb2dzOwotCSAqIGJ1dCwgaW5zdGVhZCwgZGlyZWN0bHkgaG9sZHMgYSBzaW5nbGUgc2NoZW1hIHdpdGggdGhlIHNhbWUgbmFtZSBhcwotCSAqIHRoZSBkYXRhYmFzZS4gKFRoaXMgaXMgaGFyZC1jb2RlZCBpbiBNeVNxbENhdGFsb2dEYXRhYmFzZS5nZXRTY2hlbWFzKCkuKQotCSAqIEFsdGhvdWdoIHlvdSBjYW4gcXVhbGlmeSBpZGVudGlmaWVycyB3aXRoIGEgZGF0YWJhc2UgbmFtZQotCSAqIGluIE15U1FMLCBvbmx5IHRoZSBkYXRhYmFzZSBzcGVjaWZpZWQgYXQgbG9naW4gc2VlbXMgdG8gYmUgYXZhaWxhYmxlCi0JICogaW4gdGhlIERUUCBtb2RlbC4uLi4KLQkgKiAKLQkgKiBOQjogSW4gTXlTUUwgRERMLCBTQ0hFTUEgaXMgYSBzeW5vbnltIGZvciBEQVRBQkFTRTsgYnV0IHRoZSBKREJDCi0JICogbWV0aG9kIERhdGFiYXNlTWV0YURhdGEuZ2V0U2NoZW1hcygpIHJldHVybnMgYW4gZW1wdHkgbGlzdCwKLQkgKiB3aGlsZSBnZXRDYXRhbG9ncygpIHJldHVybnMgYSBsaXN0IG9mIHRoZSBhdmFpbGFibGUgZGF0YWJhc2VzLgotCSAqIFlvdSBjYW4gYWxzbyB1c2UgdGhlIEpEQkMgbWV0aG9kIENvbm5lY3Rpb24uc2V0Q2F0YWxvZyhTdHJpbmcpIHRvCi0JICogc2V0IHRoZSBkZWZhdWx0IGRhdGFiYXNlLgotCSAqLwotCUBPdmVycmlkZQotCUNhdGFsb2dTdHJhdGVneSBnZXRDYXRhbG9nU3RyYXRlZ3koKSB7Ci0JCXJldHVybiBOb0NhdGFsb2dTdHJhdGVneS5pbnN0YW5jZSgpOwotCX0KLQotCS8qKgotCSAqIE15U1FMIGlzIGEgYml0IHVudXN1YWwsIHNvIHdlIGZvcmNlIGV4YWN0IG1hdGNoZXMuCi0JICogKGUuZy4gTXlTUUwgZm9sZHMgZGF0YWJhc2UgYW5kIHRhYmxlIG5hbWVzIHRvIGxvd2VyY2FzZSBvbiBXaW5kb3dzCi0JICogYnkgZGVmYXVsdDsgYnV0IHRoYXQgZGVmYXVsdCBjYW4gYmUgY2hhbmdlZCBieSB0aGUKLQkgKiAnbG93ZXJfY2FzZV90YWJsZV9uYW1lcycgc3lzdGVtIHZhcmlhYmxlLiBUaGlzIGlzIGJlY2F1c2UgZGF0YWJhc2VzIGFyZQotCSAqIHN0b3JlZCBhcyBkaXJlY3RvcmllcyBhbmQgdGFibGVzIGFyZSBzdG9yZWQgYXMgZmlsZXMgaW4gdGhlIHVuZGVybHlpbmcKLQkgKiBPL1M7IGFuZCB0aGUgY2FzZS1zZW5zaXRpdml0eSBvZiB0aGUgbmFtZXMgaXMgZGV0ZXJtaW5lZCBieSB0aGUgYmVoYXZpb3IKLQkgKiBvZiBmaWxlbmFtZXMgb24gdGhlIE8vUy4gVGhlbiwgdG8gY29tcGxpY2F0ZSB0aGluZ3MsCi0JICogbm9uZSBvZiB0aGUgb3RoZXIgaWRlbnRpZmllcnMsIGxpa2UgdGFibGUgYW5kIGNvbHVtbiBuYW1lcywgYXJlIGZvbGRlZDsKLQkgKiBidXQgdGhleSBhcmUgY2FzZS1pbnNlbnNpdGl2ZSwgdW5sZXNzIGRlbGltaXRlZC4gU2VlCi0JICogaHR0cDovL2Rldi5teXNxbC5jb20vZG9jL3JlZm1hbi82LjAvZW4vaWRlbnRpZmllci1jYXNlLXNlbnNpdGl2aXR5Lmh0bWwuKQotCSAqLwotCUBPdmVycmlkZQotCUZvbGRpbmdTdHJhdGVneSBnZXRGb2xkaW5nU3RyYXRlZ3koKSB7Ci0JCXJldHVybiBOb25Gb2xkaW5nU3RyYXRlZ3kuaW5zdGFuY2UoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQl2b2lkIGFkZERlZmF1bHRTY2hlbWFJZGVudGlmaWVyc1RvKERhdGFiYXNlIGRhdGFiYXNlLCBTdHJpbmcgdXNlck5hbWUsIEFycmF5TGlzdDxTdHJpbmc+IGlkZW50aWZpZXJzKSB7Ci0JCWlkZW50aWZpZXJzLmFkZChkYXRhYmFzZS5nZXROYW1lKCkpOyAgLy8gaG1tbS4uLiB+Ymp2Ci0JfQotCi0JLyoqCi0JICogTXlTUUwgaXMgdGhlIG9ubHkgdmVuZG9yIHRoYXQgYWxsb3dzIGEgZGlnaXQuCi0JICogQWx0aG91Z2gsIHRoZSBuYW1lIGNhbm5ub3QgYmUgKmFsbCogZGlnaXRzLgotCSAqLwotCUBPdmVycmlkZQotCWJvb2xlYW4gY2hhcmFjdGVySXNOb3JtYWxOYW1lU3RhcnQoY2hhciBjKSB7Ci0JCXJldHVybiBDaGFyYWN0ZXIuaXNEaWdpdChjKSB8fCBzdXBlci5jaGFyYWN0ZXJJc05vcm1hbE5hbWVTdGFydChjKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQljaGFyW10gZ2V0RXh0ZW5kZWROb3JtYWxOYW1lU3RhcnRDaGFyYWN0ZXJzKCkgewotCQlyZXR1cm4gRVhURU5ERURfTk9STUFMX05BTUVfU1RBUlRfQ0hBUkFDVEVSUzsKLQl9Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgY2hhcltdIEVYVEVOREVEX05PUk1BTF9OQU1FX1NUQVJUX0NIQVJBQ1RFUlMgPSBuZXcgY2hhcltdIHsgJ18nLCAnJCcgfTsKLQotCS8qKgotCSAqIEJ5IGRlZmF1bHQsIE15U1FMIGRlbGltaXRzIGlkZW50aWZpZXJzIHdpdGggYmFja3RpY2tzIChgKTsgYnV0IGl0Ci0JICogY2FuIGFsc28gYmUgY29uZmlndXJlZCB0byB1c2UgZG91YmxlLXF1b3Rlcy4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlib29sZWFuIGlkZW50aWZpZXJJc0RlbGltaXRlZChTdHJpbmcgaWRlbnRpZmllcikgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuc3RyaW5nSXNEZWxpbWl0ZWQoaWRlbnRpZmllciwgQkFDS1RJQ0spCi0JCQkJCXx8IHN1cGVyLmlkZW50aWZpZXJJc0RlbGltaXRlZChpZGVudGlmaWVyKTsKLQl9Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgY2hhciBCQUNLVElDSyA9ICdgJzsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL05vQ2F0YWxvZ1N0cmF0ZWd5LmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvTm9DYXRhbG9nU3RyYXRlZ3kuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYTdmYjc5ZC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvTm9DYXRhbG9nU3RyYXRlZ3kuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsLnZlbmRvcjsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uczsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5DYXRhbG9nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5EYXRhYmFzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuU2NoZW1hOwotCi0vKioKLSAqIENhdGFsb2cgc3RyYXRlZ3kgZm9yIERUUCBkYXRhYmFzZXMgdGhhdCBkbyBub3QgaGF2ZSBjYXRhbG9ncwotICogKGUuZy4gTXlTUUwgc2VlIGJ1ZyAyNDkwMTMpLgotICovCi1jbGFzcyBOb0NhdGFsb2dTdHJhdGVneQotCWltcGxlbWVudHMgQ2F0YWxvZ1N0cmF0ZWd5Ci17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgQ2F0YWxvZ1N0cmF0ZWd5IElOU1RBTkNFID0gbmV3IE5vQ2F0YWxvZ1N0cmF0ZWd5KCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlzdGF0aWMgQ2F0YWxvZ1N0cmF0ZWd5IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIE5vQ2F0YWxvZ1N0cmF0ZWd5KCkgewotCQlzdXBlcigpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIHN1cHBvcnRzQ2F0YWxvZ3MoRGF0YWJhc2UgZGF0YWJhc2UpIHsKLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCXB1YmxpYyBMaXN0PENhdGFsb2c+IGdldENhdGFsb2dzKERhdGFiYXNlIGRhdGFiYXNlKSB7Ci0JCXJldHVybiBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsKLQl9Ci0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwdWJsaWMgTGlzdDxTY2hlbWE+IGdldFNjaGVtYXMoRGF0YWJhc2UgZGF0YWJhc2UpIHsKLQkJcmV0dXJuIGRhdGFiYXNlLmdldFNjaGVtYXMoKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9Ob25Gb2xkaW5nU3RyYXRlZ3kuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9Ob25Gb2xkaW5nU3RyYXRlZ3kuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTYzYzFhZC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvTm9uRm9sZGluZ1N0cmF0ZWd5LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw2NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYi5pbnRlcm5hbC52ZW5kb3I7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5DbGFzc1Rvb2xzOwotCi0vKioKLSAqIERvIG5vdCBmb2xkICJub3JtYWwiIGlkZW50aWZpZXJzLgotICogUmVzcGVjdCB0aGUgY2FzZSBvZiAibm9ybWFsIiBpZGVudGlmaWVycy4KLSAqLwotY2xhc3MgTm9uRm9sZGluZ1N0cmF0ZWd5Ci0JaW1wbGVtZW50cyBGb2xkaW5nU3RyYXRlZ3kKLXsKLQotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEZvbGRpbmdTdHJhdGVneSBJTlNUQU5DRSA9IG5ldyBOb25Gb2xkaW5nU3RyYXRlZ3koKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXN0YXRpYyBGb2xkaW5nU3RyYXRlZ3kgaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0KLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgTm9uRm9sZGluZ1N0cmF0ZWd5KCkgewotCQlzdXBlcigpOwotCX0KLQotCS8qKgotCSAqIFNpbmNlIGlkZW50aWZpZXJzIGFyZSBub3QgZm9sZGVkIHRvIHVwcGVyLSBvciBsb3dlci1jYXNlLCB0aGUgbmFtZSBpcwotCSAqIGFscmVhZHkgImZvbGRlZCIuCi0JICovCi0JcHVibGljIFN0cmluZyBmb2xkKFN0cmluZyBuYW1lKSB7Ci0JCXJldHVybiBuYW1lOwotCX0KLQotCS8qKgotCSAqIFNpbmNlIGlkZW50aWZpZXJzIGFyZSBub3QgZm9sZGVkIHRvIHVwcGVyLSBvciBsb3dlci1jYXNlLCB0aGUgbmFtZSBpcwotCSAqIGFscmVhZHkgImZvbGRlZCIuCi0JICogKE5vbi1mb2xkaW5nIGRhdGFiYXNlcyBkbyBub3QgcmVxdWlyZSBkZWxpbWl0ZXJzIGFyb3VuZCBtaXhlZC1jYXNlCi0JICogIm5vcm1hbCIgaWRlbnRpZmllcnMuKQotCSAqLwotCXB1YmxpYyBib29sZWFuIG5hbWVJc0ZvbGRlZChTdHJpbmcgbmFtZSkgewotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBub3JtYWxJZGVudGlmaWVyc0FyZUNhc2VTZW5zaXRpdmUoKSB7Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBDbGFzc1Rvb2xzLnRvU3RyaW5nQ2xhc3NOYW1lRm9yT2JqZWN0KHRoaXMpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL09yYWNsZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL09yYWNsZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjYjA0ZjlmLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9PcmFjbGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDUzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsLnZlbmRvcjsKLQotY2xhc3MgT3JhY2xlCi0JZXh0ZW5kcyBBYnN0cmFjdFZlbmRvcgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIFZlbmRvciBJTlNUQU5DRSA9IG5ldyBPcmFjbGUoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXN0YXRpYyBWZW5kb3IgaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0KLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgT3JhY2xlKCkgewotCQlzdXBlcigpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgZ2V0RFRQVmVuZG9yTmFtZSgpIHsKLQkJcmV0dXJuICJPcmFjbGUiOyAvLyROT04tTkxTLTEkCi0JfQotCi0JQE92ZXJyaWRlCi0JQ2F0YWxvZ1N0cmF0ZWd5IGdldENhdGFsb2dTdHJhdGVneSgpIHsKLQkJcmV0dXJuIEZhdXhDYXRhbG9nU3RyYXRlZ3kuaW5zdGFuY2UoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlGb2xkaW5nU3RyYXRlZ3kgZ2V0Rm9sZGluZ1N0cmF0ZWd5KCkgewotCQlyZXR1cm4gVXBwZXJDYXNlRm9sZGluZ1N0cmF0ZWd5Lmluc3RhbmNlKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JY2hhcltdIGdldEV4dGVuZGVkTm9ybWFsTmFtZVBhcnRDaGFyYWN0ZXJzKCkgewotCQlyZXR1cm4gRVhURU5ERURfTk9STUFMX05BTUVfUEFSVF9DSEFSQUNURVJTOwotCX0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBjaGFyW10gRVhURU5ERURfTk9STUFMX05BTUVfUEFSVF9DSEFSQUNURVJTID0gbmV3IGNoYXJbXSB7ICdfJywgJyQnLCAnIycgfTsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL1Bvc3RncmVTUUwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9Qb3N0Z3JlU1FMLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhlNmEyZGIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL1Bvc3RncmVTUUwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDkzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsLnZlbmRvcjsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuQ2F0YWxvZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuRGF0YWJhc2U7Ci0KLWNsYXNzIFBvc3RncmVTUUwKLQlleHRlbmRzIEFic3RyYWN0VmVuZG9yCi17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgVmVuZG9yIElOU1RBTkNFID0gbmV3IFBvc3RncmVTUUwoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXN0YXRpYyBWZW5kb3IgaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0KLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgUG9zdGdyZVNRTCgpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIGdldERUUFZlbmRvck5hbWUoKSB7Ci0JCXJldHVybiAicG9zdGdyZXMiOyAvLyROT04tTkxTLTEkCi0JfQotCi0JLyoqCi0JICogVGhlIFBvc3RncmVTUUwgSkRCQyBkcml2ZXIgcmV0dXJucyBhIHNpbmdsZSBjYXRhbG9nIGZyb20gdGhlIGNhbGwgdG8KLQkgKiBEYXRhYmFzZU1ldGFEYXRhLmdldENhdGFsb2dzKCkgdGhhdCBoYXMgdGhlIHNhbWUgbmFtZSBhcyB0aGUKLQkgKiBkYXRhYmFzZSBpbml0aWFsbHkgc3BlY2lmaWVkIGJ5IHRoZSBjb25uZWN0aW9uIChpbiB0aGUgSkRCQyBVUkwpLgotCSAqIERUUCB1c2VzIHRoaXMgY29uZmlndXJhdGlvbiB1bm1vZGlmaWVkLiBVbmZvcnR1bmF0ZWx5LCB0aGUgRFRQCi0JICogZGF0YWJhc2UncyBuYW1lIGlzIG5vdCB0aGUgc2FtZSBhcyB0aGUgUG9zdGdyZVNRTCBkYXRhYmFzZSdzCi0JICogbmFtZS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlDYXRhbG9nU3RyYXRlZ3kgZ2V0Q2F0YWxvZ1N0cmF0ZWd5KCkgewotCQlyZXR1cm4gU2ltcGxlQ2F0YWxvZ1N0cmF0ZWd5Lmluc3RhbmNlKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JRm9sZGluZ1N0cmF0ZWd5IGdldEZvbGRpbmdTdHJhdGVneSgpIHsKLQkJcmV0dXJuIExvd2VyQ2FzZUZvbGRpbmdTdHJhdGVneS5pbnN0YW5jZSgpOwotCX0KLQotCS8qKgotCSAqIFRoZSBQb3N0Z3JlU1FMIGRhdGFiYXNlIGhvbGRzIGEgc2luZ2xlIGNhdGFsb2cgdGhhdCBoYXMgdGhlIHNhbWUgbmFtZSBhcwotCSAqIHRoZSBkYXRhYmFzZS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQl2b2lkIGFkZERlZmF1bHRDYXRhbG9nSWRlbnRpZmllcnNUbyhEYXRhYmFzZSBkYXRhYmFzZSwgU3RyaW5nIHVzZXJOYW1lLCBBcnJheUxpc3Q8U3RyaW5nPiBpZGVudGlmaWVycykgewotCQlpZGVudGlmaWVycy5hZGQoKChDYXRhbG9nKSBkYXRhYmFzZS5nZXRDYXRhbG9ncygpLmdldCgwKSkuZ2V0TmFtZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBQb3N0Z3JlU1FMIGhhcyBhICJzY2hlbWEgc2VhcmNoIHBhdGgiLiBUaGUgZGVmYXVsdCBpczoKLQkgKiAgICAgIiR1c2VyIixwdWJsaWMKLQkgKiBJZiAiJHVzZXIiIGlzIG5vdCBmb3VuZCwgcmV0dXJuICJwdWJsaWMiLgotCSAqLwotCUBPdmVycmlkZQotCXZvaWQgYWRkRGVmYXVsdFNjaGVtYUlkZW50aWZpZXJzVG8oRGF0YWJhc2UgZGF0YWJhc2UsIFN0cmluZyB1c2VyTmFtZSwgQXJyYXlMaXN0PFN0cmluZz4gaWRlbnRpZmllcnMpIHsKLQkJc3VwZXIuYWRkRGVmYXVsdFNjaGVtYUlkZW50aWZpZXJzVG8oZGF0YWJhc2UsIHVzZXJOYW1lLCBpZGVudGlmaWVycyk7Ci0JCWlkZW50aWZpZXJzLmFkZChQVUJMSUNfU0NIRU1BX05BTUUpOwotCX0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgUFVCTElDX1NDSEVNQV9OQU1FID0gInB1YmxpYyI7ICAvLyROT04tTkxTLTEkCi0KLQlAT3ZlcnJpZGUKLQljaGFyW10gZ2V0RXh0ZW5kZWROb3JtYWxOYW1lU3RhcnRDaGFyYWN0ZXJzKCkgewotCQlyZXR1cm4gRVhURU5ERURfTk9STUFMX05BTUVfU1RBUlRfQ0hBUkFDVEVSUzsKLQl9Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgY2hhcltdIEVYVEVOREVEX05PUk1BTF9OQU1FX1NUQVJUX0NIQVJBQ1RFUlMgPSBuZXcgY2hhcltdIHsgJ18nIH07Ci0KLQlAT3ZlcnJpZGUKLQljaGFyW10gZ2V0RXh0ZW5kZWROb3JtYWxOYW1lUGFydENoYXJhY3RlcnMoKSB7Ci0JCXJldHVybiBFWFRFTkRFRF9OT1JNQUxfTkFNRV9QQVJUX0NIQVJBQ1RFUlM7Ci0JfQotCXByaXZhdGUgc3RhdGljIGZpbmFsIGNoYXJbXSBFWFRFTkRFRF9OT1JNQUxfTkFNRV9QQVJUX0NIQVJBQ1RFUlMgPSBuZXcgY2hhcltdIHsgJyQnIH07Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9TUUxTZXJ2ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9TUUxTZXJ2ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOWRlNmI3Ni4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvU1FMU2VydmVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw4NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYi5pbnRlcm5hbC52ZW5kb3I7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLkRhdGFiYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotCi1jbGFzcyBTUUxTZXJ2ZXIKLQlleHRlbmRzIEFic3RyYWN0VmVuZG9yCi17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgVmVuZG9yIElOU1RBTkNFID0gbmV3IFNRTFNlcnZlcigpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0Jc3RhdGljIFZlbmRvciBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBTUUxTZXJ2ZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyBnZXREVFBWZW5kb3JOYW1lKCkgewotCQlyZXR1cm4gIlNRTCBTZXJ2ZXIiOyAvLyROT04tTkxTLTEkCi0JfQotCi0JQE92ZXJyaWRlCi0JQ2F0YWxvZ1N0cmF0ZWd5IGdldENhdGFsb2dTdHJhdGVneSgpIHsKLQkJcmV0dXJuIFNpbXBsZUNhdGFsb2dTdHJhdGVneS5pbnN0YW5jZSgpOwotCX0KLQotCS8qKgotCSAqIEJ5IGRlZmF1bHQsIFNRTCBTZXJ2ZXIgaWRlbnRpZmllcnMgYXJlIGNhc2Utc2Vuc2l0aXZlLCBldmVuIHdpdGhvdXQKLQkgKiBkZWxpbWl0ZXJzLiBUaGlzIGNhbiBkZXBlbmQgb24gdGhlIGNvbGxhdGlvbiBzZXR0aW5nLi4uLgotCSAqLwotCUBPdmVycmlkZQotCUZvbGRpbmdTdHJhdGVneSBnZXRGb2xkaW5nU3RyYXRlZ3koKSB7Ci0JCXJldHVybiBOb25Gb2xkaW5nU3RyYXRlZ3kuaW5zdGFuY2UoKTsKLQl9Ci0KLQkvKioKLQkgKiBUaGUgZGVmYXVsdCBzY2hlbWEgb24gU1FMIFNlcnZlciBmb3IgYW55IGRhdGFiYXNlIChjYXRhbG9nKSBpcyAnZGJvJy4KLQkgKi8KLQlAT3ZlcnJpZGUKLQl2b2lkIGFkZERlZmF1bHRTY2hlbWFJZGVudGlmaWVyc1RvKERhdGFiYXNlIGRhdGFiYXNlLCBTdHJpbmcgdXNlck5hbWUsIEFycmF5TGlzdDxTdHJpbmc+IGlkZW50aWZpZXJzKSB7Ci0JCWlkZW50aWZpZXJzLmFkZChERUZBVUxUX1NDSEVNQV9OQU1FKTsKLQl9Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIERFRkFVTFRfU0NIRU1BX05BTUUgPSAiZGJvIjsgIC8vJE5PTi1OTFMtMSQKLQotCUBPdmVycmlkZQotCWNoYXJbXSBnZXRFeHRlbmRlZE5vcm1hbE5hbWVTdGFydENoYXJhY3RlcnMoKSB7Ci0JCXJldHVybiBFWFRFTkRFRF9OT1JNQUxfTkFNRV9TVEFSVF9DSEFSQUNURVJTOwotCX0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBjaGFyW10gRVhURU5ERURfTk9STUFMX05BTUVfU1RBUlRfQ0hBUkFDVEVSUyA9IG5ldyBjaGFyW10geyAnXycsICdAJywgJyMnIH07Ci0KLQlAT3ZlcnJpZGUKLQljaGFyW10gZ2V0RXh0ZW5kZWROb3JtYWxOYW1lUGFydENoYXJhY3RlcnMoKSB7Ci0JCXJldHVybiBFWFRFTkRFRF9OT1JNQUxfTkFNRV9QQVJUX0NIQVJBQ1RFUlM7Ci0JfQotCXByaXZhdGUgc3RhdGljIGZpbmFsIGNoYXJbXSBFWFRFTkRFRF9OT1JNQUxfTkFNRV9QQVJUX0NIQVJBQ1RFUlMgPSBuZXcgY2hhcltdIHsgJyQnIH07Ci0KLQkvKioKLQkgKiBCeSBkZWZhdWx0LCBTUUwgU2VydmVyIGRlbGltaXRzIGlkZW50aWZpZXJzIHdpdGggYnJhY2tldHMgKFtdKTsgYnV0IGl0Ci0JICogY2FuIGFsc28gYmUgY29uZmlndXJlZCB0byB1c2UgZG91YmxlLXF1b3Rlcy4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlib29sZWFuIGlkZW50aWZpZXJJc0RlbGltaXRlZChTdHJpbmcgaWRlbnRpZmllcikgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuc3RyaW5nSXNCcmFja2V0ZWQoaWRlbnRpZmllcikKLQkJCQkJfHwgc3VwZXIuaWRlbnRpZmllcklzRGVsaW1pdGVkKGlkZW50aWZpZXIpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL1NpbXBsZUNhdGFsb2dTdHJhdGVneS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL1NpbXBsZUNhdGFsb2dTdHJhdGVneS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4YTFhMDQxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9TaW1wbGVDYXRhbG9nU3RyYXRlZ3kuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsLnZlbmRvcjsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uczsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5DYXRhbG9nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5EYXRhYmFzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuU2NoZW1hOwotCi0vKioKLSAqIENhdGFsb2cgc3RyYXRlZ3kgZm9yIERUUCBkYXRhYmFzZXMgdGhhdCBzaW1wbHkgbW9kZWwgdGhlIGNhdGFsb2dzIHJldHVybmVkCi0gKiBieSB0aGUgdW5kZXJseWluZyBKREJDIGRyaXZlciAoZS5nLiBTeWJhc2UpLgotICogQHNlZSBqYXZhLnNxbC5EYXRhYmFzZU1ldGFEYXRhI2dldENhdGFsb2dzKCkKLSAqLwotY2xhc3MgU2ltcGxlQ2F0YWxvZ1N0cmF0ZWd5Ci0JaW1wbGVtZW50cyBDYXRhbG9nU3RyYXRlZ3kKLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBDYXRhbG9nU3RyYXRlZ3kgSU5TVEFOQ0UgPSBuZXcgU2ltcGxlQ2F0YWxvZ1N0cmF0ZWd5KCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlzdGF0aWMgQ2F0YWxvZ1N0cmF0ZWd5IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIFNpbXBsZUNhdGFsb2dTdHJhdGVneSgpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBzdXBwb3J0c0NhdGFsb2dzKERhdGFiYXNlIGRhdGFiYXNlKSB7Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXB1YmxpYyBMaXN0PENhdGFsb2c+IGdldENhdGFsb2dzKERhdGFiYXNlIGRhdGFiYXNlKSB7Ci0JCXJldHVybiBkYXRhYmFzZS5nZXRDYXRhbG9ncygpOwotCX0KLQotCXB1YmxpYyBMaXN0PFNjaGVtYT4gZ2V0U2NoZW1hcyhEYXRhYmFzZSBkYXRhYmFzZSkgewotCQlyZXR1cm4gQ29sbGVjdGlvbnMuZW1wdHlMaXN0KCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvU3liYXNlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvU3liYXNlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhkY2ZjYmEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL1N5YmFzZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTAzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsLnZlbmRvcjsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuRGF0YWJhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci0KLWNsYXNzIFN5YmFzZQotCWV4dGVuZHMgQWJzdHJhY3RWZW5kb3IKLXsKLQlwcml2YXRlIGZpbmFsIFN0cmluZyBkdHBWZW5kb3JOYW1lOwotCi0Jc3RhdGljIGZpbmFsIFZlbmRvciBBU0EgPSBuZXcgU3liYXNlKCJTeWJhc2VfQVNBIik7IC8vJE5PTi1OTFMtMSQKLQlzdGF0aWMgZmluYWwgVmVuZG9yIEFTRSA9IG5ldyBTeWJhc2UoIlN5YmFzZV9BU0UiKTsgLy8kTk9OLU5MUy0xJAotCi0Jc3RhdGljIFZlbmRvciBhc2EoKSB7Ci0JCXJldHVybiBBU0E7Ci0JfQotCi0Jc3RhdGljIFZlbmRvciBhc2UoKSB7Ci0JCXJldHVybiBBU0U7Ci0JfQotCi0JLyoqCi0JICogRW5zdXJlIG9ubHkgc3RhdGljIGluc3RhbmNlcy4KLQkgKi8KLQlwcml2YXRlIFN5YmFzZShTdHJpbmcgZHRwVmVuZG9yTmFtZSkgewotCQlzdXBlcigpOwotCQl0aGlzLmR0cFZlbmRvck5hbWUgPSBkdHBWZW5kb3JOYW1lOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgZ2V0RFRQVmVuZG9yTmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMuZHRwVmVuZG9yTmFtZTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlDYXRhbG9nU3RyYXRlZ3kgZ2V0Q2F0YWxvZ1N0cmF0ZWd5KCkgewotCQlyZXR1cm4gU2ltcGxlQ2F0YWxvZ1N0cmF0ZWd5Lmluc3RhbmNlKCk7Ci0JfQotCi0JLyoqCi0JICogQnkgZGVmYXVsdCwgU3liYXNlIGlkZW50aWZpZXJzIGFyZSBjYXNlLXNlbnNpdGl2ZSwgZXZlbiB3aXRob3V0Ci0JICogZGVsaW1pdGVycy4gVGhpcyBjYW4gZGVwZW5kIG9uIHRoZSBjb2xsYXRpb24gc2V0dGluZy4uLi4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlGb2xkaW5nU3RyYXRlZ3kgZ2V0Rm9sZGluZ1N0cmF0ZWd5KCkgewotCQlyZXR1cm4gTm9uRm9sZGluZ1N0cmF0ZWd5Lmluc3RhbmNlKCk7Ci0JfQotCi0JLyoqCi0JICogVGhlIHR5cGljYWwgZGVmYXVsdCBzY2hlbWEgb24gU3liYXNlIGZvciBhbnkgZGF0YWJhc2UgKGNhdGFsb2cpIGlzCi0JICogJ2RibycuCi0JICogCi0JICogQWN0dWFsbHksIHRoZSBkZWZhdWx0IHNjaGVtYSBpcyBtb3JlIGxpa2UgYSBzZWFyY2ggcGF0aDoKLQkgKiBUaGUgc2VydmVyIGxvb2tzIGZvciBhIHNjaGVtYSBvYmplY3QgKGUuZyB0YWJsZSkgZmlyc3QgaW4gdGhlIHVzZXIncwotCSAqIHNjaGVtYSwgdGhlIGl0IGxvb2sgZm9yIHRoZSBzY2hlbWEgb2JqZWN0IGluIHRoZSBkYXRhYmFzZSBvd25lcidzCi0JICogc2NoZW1hIChkYm8pLiBBcyBhIHJlc3VsdCwgaXQncyByZWFsbHkgbm90IHBvc3NpYmxlIHRvIHNwZWNpZnkKLQkgKiB0aGUgImRlZmF1bHQiIHNjaGVtYSB3aXRob3V0IGtub3dpbmcgdGhlIHNjaGVtYSBvYmplY3Qgd2UgYXJlCi0JICogbG9va2luZyBmb3IuCi0JICogCi0JICogKE5vdGU6IHRoZSBjdXJyZW50ICd1c2VyJyBpcyBub3QgdGhlIHNhbWUgdGhpbmcgYXMgdGhlIGN1cnJlbnQKLQkgKiAnbG9naW4nIC0gc2VlIHNwX2FkZHVzZXIgYW5kIHNwX2FkZGxvZ2luOyBzbyB3ZSBwcm9iYWJseSBjYW4ndAotCSAqIHVzZSBDb25uZWN0aW9uUHJvZmlsZSNnZXRVc2VyTmFtZSgpLikKLQkgKi8KLQlAT3ZlcnJpZGUKLQl2b2lkIGFkZERlZmF1bHRTY2hlbWFJZGVudGlmaWVyc1RvKERhdGFiYXNlIGRhdGFiYXNlLCBTdHJpbmcgdXNlck5hbWUsIEFycmF5TGlzdDxTdHJpbmc+IGlkZW50aWZpZXJzKSB7Ci0JCWlkZW50aWZpZXJzLmFkZChERUZBVUxUX1NDSEVNQV9OQU1FKTsKLQl9Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIERFRkFVTFRfU0NIRU1BX05BTUUgPSAiZGJvIjsgIC8vJE5PTi1OTFMtMSQKLQotCUBPdmVycmlkZQotCWNoYXJbXSBnZXRFeHRlbmRlZE5vcm1hbE5hbWVTdGFydENoYXJhY3RlcnMoKSB7Ci0JCXJldHVybiBFWFRFTkRFRF9OT1JNQUxfTkFNRV9TVEFSVF9DSEFSQUNURVJTOwotCX0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBjaGFyW10gRVhURU5ERURfTk9STUFMX05BTUVfU1RBUlRfQ0hBUkFDVEVSUyA9IG5ldyBjaGFyW10geyAnXycsICdAJyB9OwotCi0JQE92ZXJyaWRlCi0JY2hhcltdIGdldEV4dGVuZGVkTm9ybWFsTmFtZVBhcnRDaGFyYWN0ZXJzKCkgewotCQlyZXR1cm4gRVhURU5ERURfTk9STUFMX05BTUVfUEFSVF9DSEFSQUNURVJTOwotCX0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBjaGFyW10gRVhURU5ERURfTk9STUFMX05BTUVfUEFSVF9DSEFSQUNURVJTID0gbmV3IGNoYXJbXSB7ICckJywgJ6UnLCAnoycsICcjJyB9OwotCi0JLyoqCi0JICogQnkgZGVmYXVsdCwgU3liYXNlIGRlbGltaXRzIGlkZW50aWZpZXJzIHdpdGggYnJhY2tldHMgKFtdKTsgYnV0IGl0Ci0JICogY2FuIGFsc28gYmUgY29uZmlndXJlZCB0byB1c2UgZG91YmxlLXF1b3Rlcy4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlib29sZWFuIGlkZW50aWZpZXJJc0RlbGltaXRlZChTdHJpbmcgaWRlbnRpZmllcikgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuc3RyaW5nSXNCcmFja2V0ZWQoaWRlbnRpZmllcikKLQkJCQkJfHwgc3VwZXIuaWRlbnRpZmllcklzRGVsaW1pdGVkKGlkZW50aWZpZXIpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL1Vua25vd25DYXRhbG9nU3RyYXRlZ3kuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9Vbmtub3duQ2F0YWxvZ1N0cmF0ZWd5LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVhOWE3MjkuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL1Vua25vd25DYXRhbG9nU3RyYXRlZ3kuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDg3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsLnZlbmRvcjsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uczsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5DYXRhbG9nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5EYXRhYmFzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuU2NoZW1hOwotCi0vKioKLSAqIENhdGFsb2cgc3RyYXRlZ3kgZm9yIHVua25vd24gRFRQIGRhdGFiYXNlcy4KLSAqIEBzZWUgamF2YS5zcWwuRGF0YWJhc2VNZXRhRGF0YSNnZXRDYXRhbG9ncygpCi0gKi8KLWNsYXNzIFVua25vd25DYXRhbG9nU3RyYXRlZ3kKLQlpbXBsZW1lbnRzIENhdGFsb2dTdHJhdGVneQotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIENhdGFsb2dTdHJhdGVneSBJTlNUQU5DRSA9IG5ldyBVbmtub3duQ2F0YWxvZ1N0cmF0ZWd5KCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlzdGF0aWMgQ2F0YWxvZ1N0cmF0ZWd5IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIFVua25vd25DYXRhbG9nU3RyYXRlZ3koKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHVibGljIGJvb2xlYW4gc3VwcG9ydHNDYXRhbG9ncyhEYXRhYmFzZSBkYXRhYmFzZSkgewotCQlMaXN0PENhdGFsb2c+IGNhdGFsb2dzID0gZGF0YWJhc2UuZ2V0Q2F0YWxvZ3MoKTsKLQkJaWYgKChjYXRhbG9ncyA9PSBudWxsKSB8fCBjYXRhbG9ncy5pc0VtcHR5KCkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCi0JCXJldHVybiB0aGlzLmdldEZhdXhDYXRhbG9nKGNhdGFsb2dzKSA9PSBudWxsOwotCX0KLQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXB1YmxpYyBMaXN0PENhdGFsb2c+IGdldENhdGFsb2dzKERhdGFiYXNlIGRhdGFiYXNlKSB7Ci0JCUxpc3Q8Q2F0YWxvZz4gY2F0YWxvZ3MgPSBkYXRhYmFzZS5nZXRDYXRhbG9ncygpOwotCQkvLyBpZiB0aGVyZSBhcmUgbm8gY2F0YWxvZ3MsIHRoZSBkYXRhYmFzZSBtdXN0IGhvbGQgdGhlIHNjaGVtYXRhIGRpcmVjdGx5Ci0JCWlmICgoY2F0YWxvZ3MgPT0gbnVsbCkgfHwgY2F0YWxvZ3MuaXNFbXB0eSgpKSB7Ci0JCQlyZXR1cm4gQ29sbGVjdGlvbnMuZW1wdHlMaXN0KCk7Ci0JCX0KLQotCQlDYXRhbG9nIGZhdXhDYXRhbG9nID0gdGhpcy5nZXRGYXV4Q2F0YWxvZyhjYXRhbG9ncyk7Ci0JCXJldHVybiAoZmF1eENhdGFsb2cgPT0gbnVsbCkgPyBjYXRhbG9ncyA6IENvbGxlY3Rpb25zLjxDYXRhbG9nPmVtcHR5TGlzdCgpOwotCX0KLQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXB1YmxpYyBMaXN0PFNjaGVtYT4gZ2V0U2NoZW1hcyhEYXRhYmFzZSBkYXRhYmFzZSkgewotCQlMaXN0PENhdGFsb2c+IGNhdGFsb2dzID0gZGF0YWJhc2UuZ2V0Q2F0YWxvZ3MoKTsKLQkJLy8gaWYgdGhlcmUgYXJlIG5vIGNhdGFsb2dzLCB0aGUgZGF0YWJhc2UgbXVzdCBob2xkIHRoZSBzY2hlbWF0YSBkaXJlY3RseQotCQlpZiAoKGNhdGFsb2dzID09IG51bGwpIHx8IGNhdGFsb2dzLmlzRW1wdHkoKSkgewotCQkJcmV0dXJuIGRhdGFiYXNlLmdldFNjaGVtYXMoKTsKLQkJfQotCi0JCUNhdGFsb2cgZmF1eENhdGFsb2cgPSB0aGlzLmdldEZhdXhDYXRhbG9nKGNhdGFsb2dzKTsKLQkJcmV0dXJuIChmYXV4Q2F0YWxvZyAhPSBudWxsKSA/IGZhdXhDYXRhbG9nLmdldFNjaGVtYXMoKSA6IENvbGxlY3Rpb25zLmVtcHR5TGlzdCgpOwotCX0KLQotCXByaXZhdGUgQ2F0YWxvZyBnZXRGYXV4Q2F0YWxvZyhMaXN0PENhdGFsb2c+IGNhdGFsb2dzKSB7Ci0JCWlmIChjYXRhbG9ncy5zaXplKCkgPT0gMSkgewotCQkJQ2F0YWxvZyBjYXRhbG9nID0gY2F0YWxvZ3MuZ2V0KDApOwotCQkJaWYgKGNhdGFsb2cuZ2V0TmFtZSgpLmVxdWFscygiIikpIHsgLy8kTk9OLU5MUy0xJAotCQkJCXJldHVybiBjYXRhbG9nOwotCQkJfQotCQl9Ci0JCXJldHVybiBudWxsOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL1VucmVjb2duaXplZFZlbmRvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL1VucmVjb2duaXplZFZlbmRvci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmNTc1MTIzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9VbnJlY29nbml6ZWRWZW5kb3IuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsLnZlbmRvcjsKLQotLyoqCi0gKiAKLSAqLwotY2xhc3MgVW5yZWNvZ25pemVkVmVuZG9yCi0JZXh0ZW5kcyBBYnN0cmFjdFZlbmRvcgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIFZlbmRvciBJTlNUQU5DRSA9IG5ldyBVbnJlY29nbml6ZWRWZW5kb3IoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXN0YXRpYyBWZW5kb3IgaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0KLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgVW5yZWNvZ25pemVkVmVuZG9yKCkgewotCQlzdXBlcigpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgZ2V0RFRQVmVuZG9yTmFtZSgpIHsKLQkJcmV0dXJuICJVbnJlY29nbml6ZWQgVmVuZG9yIjsgLy8kTk9OLU5MUy0xJAotCX0KLQotCS8qKgotCSAqIE5vdCBzdXJlIHdoYXQgdG8gZG8gaGVyZS4uLi4KLQkgKiBBc3N1bWUgdGhlIERUUCBkYXRhYmFzZSBpcyBvcmdhbml6ZWQgaW50byBvbmUgb3IgbW9yZSBjYXRhbG9ncyBhbmQKLQkgKiB0aGUgc2NoZW1hdGEgYXJlIGNvbnRhaW5lZCBieSB0aG9zZSBjYXRhbG9ncy4gVGhpcyBhcHBlYXJzIHRvIGJlIHRoZQotCSAqIGRlZmF1bHQgd2F5IERUUCBidWlsZHMgbW9kZWxzIHRoZXNlIGRheXMgKGkuZS4gYSBkYXRhYmFzZSB3aXRoIGF0Ci0JICogbGVhc3Qgb25lIGNhdGFsb2csIGluc3RlYWQgb2YgdGhlIGRhdGFiYXNlIGhvbGRpbmcgc2NoZW1hdGEKLQkgKiBkaXJlY3RseSkuCi0JICovCi0JQE92ZXJyaWRlCi0JQ2F0YWxvZ1N0cmF0ZWd5IGdldENhdGFsb2dTdHJhdGVneSgpIHsKLQkJcmV0dXJuIFVua25vd25DYXRhbG9nU3RyYXRlZ3kuaW5zdGFuY2UoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlGb2xkaW5nU3RyYXRlZ3kgZ2V0Rm9sZGluZ1N0cmF0ZWd5KCkgewotCQlyZXR1cm4gVXBwZXJDYXNlRm9sZGluZ1N0cmF0ZWd5Lmluc3RhbmNlKCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvVXBwZXJDYXNlRm9sZGluZ1N0cmF0ZWd5LmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvVXBwZXJDYXNlRm9sZGluZ1N0cmF0ZWd5LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDc0OGQ0ZGQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL1VwcGVyQ2FzZUZvbGRpbmdTdHJhdGVneS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWwudmVuZG9yOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotLyoqCi0gKiBGb2xkICJub3JtYWwiIGlkZW50aWZpZXJzIHRvIHVwcGVyIGNhc2UuCi0gKiBJZ25vcmUgdGhlIGNhc2Ugb2YgIm5vcm1hbCIgaWRlbnRpZmllcnMuCi0gKi8KLWNsYXNzIFVwcGVyQ2FzZUZvbGRpbmdTdHJhdGVneQotCWltcGxlbWVudHMgRm9sZGluZ1N0cmF0ZWd5Ci17Ci0KLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBGb2xkaW5nU3RyYXRlZ3kgSU5TVEFOQ0UgPSBuZXcgVXBwZXJDYXNlRm9sZGluZ1N0cmF0ZWd5KCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlzdGF0aWMgRm9sZGluZ1N0cmF0ZWd5IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIFVwcGVyQ2FzZUZvbGRpbmdTdHJhdGVneSgpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGZvbGQoU3RyaW5nIG5hbWUpIHsKLQkJcmV0dXJuIG5hbWUudG9VcHBlckNhc2UoKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBuYW1lSXNGb2xkZWQoU3RyaW5nIG5hbWUpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLnN0cmluZ0lzVXBwZXJjYXNlKG5hbWUpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIG5vcm1hbElkZW50aWZpZXJzQXJlQ2FzZVNlbnNpdGl2ZSgpIHsKLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBDbGFzc1Rvb2xzLnRvU3RyaW5nQ2xhc3NOYW1lRm9yT2JqZWN0KHRoaXMpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL1ZlbmRvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL1ZlbmRvci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjNzNkNzc0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kYi9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL2ludGVybmFsL3ZlbmRvci9WZW5kb3IuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDgzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLmludGVybmFsLnZlbmRvcjsKLQotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLkNhdGFsb2c7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLkRhdGFiYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5TY2hlbWE7Ci0KLS8qKgotICogRGVsZWdhdGUgdmVuZG9yLXNwZWNpZmljIGJlaGF2aW9yIHRvIGltcGxlbWVudGF0aW9ucyBvZiB0aGlzIGludGVyZmFjZToKLSAqICAgLSBjYXRhbG9nIHN1cHBvcnQKLSAqICAgLSBkZWZhdWx0IGNhdGFsb2cgYW5kIHNjaGVtYQotICogICAtIGNvbnZlcnRpbmcgbmFtZXMgdG8gaWRlbnRpZmllcnMgYW5kIHZpY2UtdmVyc2EKLSAqIAotICogTm90ZToKLSAqIFdlIHVzZSAibmFtZSIgd2hlbiBkZWFsaW5nIHdpdGggdGhlIHVubW9kaWZpZWQgbmFtZSBvZiBhIGRhdGFiYXNlIG9iamVjdAotICogYXMgc3VwcGxpZWQgYnkgdGhlIGRhdGFiYXNlIGl0c2VsZiAoaS5lLiBpdCBpcyBub3QgZGVsaW1pdGVkIGFuZCBpdCBpcyBhbHdheXMKLSAqIGNhc2Utc2Vuc2l0aXZlKS4KLSAqIFdlIHVzZSAiaWRlbnRpZmllciIgd2hlbiBkZWFsaW5nIHdpdGggYSBzdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgYSBkYXRhYmFzZQotICogb2JqZWN0IG5hbWUgKGkuZS4gaXQgbWF5IGJlIGRlbGltaXRlZCBhbmQsIGRlcGVuZGluZyBvbiB0aGUgdmVuZG9yLCBpdCBtYXkKLSAqIGJlIGNhc2UtaW5zZW5zaXRpdmUpLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIFZlbmRvciB7Ci0KLQkvKioKLQkgKiBUaGlzIG11c3QgbWF0Y2ggdGhlIERUUCB2ZW5kb3IgbmFtZS4KLQkgKiBAc2VlIG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5EYXRhYmFzZSNnZXRWZW5kb3IoKQotCSAqLwotCVN0cmluZyBnZXREVFBWZW5kb3JOYW1lKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgdmVuZG9yIHN1cHBvcnRzICJyZWFsIiBjYXRhbG9ncyAoZS5nLiBTeWJhc2UpLgotCSAqLwotCWJvb2xlYW4gc3VwcG9ydHNDYXRhbG9ncyhEYXRhYmFzZSBkYXRhYmFzZSk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNwZWNpZmllZCBkYXRhYmFzZSdzIGNhdGFsb2dzLgotCSAqLwotCUxpc3Q8Q2F0YWxvZz4gZ2V0Q2F0YWxvZ3MoRGF0YWJhc2UgZGF0YWJhc2UpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzcGVjaWZpZWQgZGF0YWJhc2UncyBkZWZhdWx0IGNhdGFsb2cgaWRlbnRpZmllcnMgZm9yIHRoZQotCSAqIHNwZWNpZmllZCB1c2VyLgotCSAqLwotCUxpc3Q8U3RyaW5nPiBnZXREZWZhdWx0Q2F0YWxvZ0lkZW50aWZpZXJzKERhdGFiYXNlIGRhdGFiYXNlLCBTdHJpbmcgdXNlck5hbWUpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzcGVjaWZpZWQgZGF0YWJhc2UncyBzY2hlbWFzLgotCSAqLwotCUxpc3Q8U2NoZW1hPiBnZXRTY2hlbWFzKERhdGFiYXNlIGRhdGFiYXNlKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc3BlY2lmaWVkIGRhdGFiYXNlJ3MgZGVmYXVsdCBzY2hlbWEgaWRlbnRpZmllcnMgZm9yIHRoZQotCSAqIHNwZWNpZmllZCB1c2VyLgotCSAqLwotCUxpc3Q8U3RyaW5nPiBnZXREZWZhdWx0U2NoZW1hSWRlbnRpZmllcnMoRGF0YWJhc2UgZGF0YWJhc2UsIFN0cmluZyB1c2VyTmFtZSk7Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgZGF0YWJhc2Ugb2JqZWN0IG5hbWUgdG8gYSB2ZW5kb3IgaWRlbnRpZmllci4KLQkgKiBSZXR1cm4gbnVsbCBpZiB0aGUgaWRlbnRpZmllciBtYXRjaGVzIHRoZSBzcGVjaWZpZWQgZGVmYXVsdCBuYW1lLgotCSAqLwotCVN0cmluZyBjb252ZXJ0TmFtZVRvSWRlbnRpZmllcihTdHJpbmcgbmFtZSwgU3RyaW5nIGRlZmF1bHROYW1lKTsKLQotCS8qKgotCSAqIENvbnZlcnQgdGhlIHNwZWNpZmllZCBkYXRhYmFzZSBvYmplY3QgbmFtZSB0byBhIHZlbmRvciBpZGVudGlmaWVyLgotCSAqLwotCVN0cmluZyBjb252ZXJ0TmFtZVRvSWRlbnRpZmllcihTdHJpbmcgbmFtZSk7Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgZGF0YWJhc2Ugb2JqZWN0IGlkZW50aWZpZXIgdG8gYSB2ZW5kb3IgbmFtZS4KLQkgKi8KLQlTdHJpbmcgY29udmVydElkZW50aWZpZXJUb05hbWUoU3RyaW5nIGlkZW50aWZpZXIpOwotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvVmVuZG9yUmVwb3NpdG9yeS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRiL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvaW50ZXJuYWwvdmVuZG9yL1ZlbmRvclJlcG9zaXRvcnkuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDY4ZjA5ZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZGIvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi9pbnRlcm5hbC92ZW5kb3IvVmVuZG9yUmVwb3NpdG9yeS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGIuaW50ZXJuYWwudmVuZG9yOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci0KLXB1YmxpYyBjbGFzcyBWZW5kb3JSZXBvc2l0b3J5IHsKLQlwcml2YXRlIGZpbmFsIFZlbmRvcltdIHZlbmRvcnM7Ci0KLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBWZW5kb3JSZXBvc2l0b3J5IElOU1RBTkNFID0gbmV3IFZlbmRvclJlcG9zaXRvcnkoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgVmVuZG9yUmVwb3NpdG9yeSBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBWZW5kb3JSZXBvc2l0b3J5KCkgewotCQlzdXBlcigpOwotCQl0aGlzLnZlbmRvcnMgPSB0aGlzLmJ1aWxkVmVuZG9ycygpOwotCX0KLQotCXByaXZhdGUgVmVuZG9yW10gYnVpbGRWZW5kb3JzKCkgewotCQlBcnJheUxpc3Q8VmVuZG9yPiBsaXN0ID0gbmV3IEFycmF5TGlzdDxWZW5kb3I+KCk7Ci0JCXRoaXMuYWRkVmVuZG9yc1RvKGxpc3QpOwotCQlyZXR1cm4gbGlzdC50b0FycmF5KG5ldyBWZW5kb3JbbGlzdC5zaXplKCldKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYWRkVmVuZG9yc1RvKEFycmF5TGlzdDxWZW5kb3I+IGxpc3QpIHsKLQkJdGhpcy5hZGRWZW5kb3JUbyhEQjIudWRiKCksIGxpc3QpOwotCQl0aGlzLmFkZFZlbmRvclRvKERCMi51ZGJJU2VyaWVzKCksIGxpc3QpOwotCQl0aGlzLmFkZFZlbmRvclRvKERCMi51ZGJaU2VyaWVzKCksIGxpc3QpOwotCQl0aGlzLmFkZFZlbmRvclRvKERlcmJ5Lmluc3RhbmNlKCksIGxpc3QpOwotCQl0aGlzLmFkZFZlbmRvclRvKEhTUUxEQi5pbnN0YW5jZSgpLCBsaXN0KTsKLQkJdGhpcy5hZGRWZW5kb3JUbyhJbmZvcm1peC5pbnN0YW5jZSgpLCBsaXN0KTsKLQkJdGhpcy5hZGRWZW5kb3JUbyhNYXhEQi5pbnN0YW5jZSgpLCBsaXN0KTsKLQkJdGhpcy5hZGRWZW5kb3JUbyhNeVNRTC5pbnN0YW5jZSgpLCBsaXN0KTsKLQkJdGhpcy5hZGRWZW5kb3JUbyhPcmFjbGUuaW5zdGFuY2UoKSwgbGlzdCk7Ci0JCXRoaXMuYWRkVmVuZG9yVG8oUG9zdGdyZVNRTC5pbnN0YW5jZSgpLCBsaXN0KTsKLQkJdGhpcy5hZGRWZW5kb3JUbyhTUUxTZXJ2ZXIuaW5zdGFuY2UoKSwgbGlzdCk7Ci0JCXRoaXMuYWRkVmVuZG9yVG8oU3liYXNlLmFzYSgpLCBsaXN0KTsKLQkJdGhpcy5hZGRWZW5kb3JUbyhTeWJhc2UuYXNlKCksIGxpc3QpOwotCX0KLQotCXByaXZhdGUgdm9pZCBhZGRWZW5kb3JUbyhWZW5kb3IgdmVuZG9yLCBBcnJheUxpc3Q8VmVuZG9yPiBsaXN0KSB7Ci0JCVN0cmluZyBuYW1lID0gdmVuZG9yLmdldERUUFZlbmRvck5hbWUoKTsKLQkJZm9yIChJdGVyYXRvcjxWZW5kb3I+IHN0cmVhbSA9IGxpc3QuaXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQlpZiAoc3RyZWFtLm5leHQoKS5nZXREVFBWZW5kb3JOYW1lKCkuZXF1YWxzKG5hbWUpKSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiRHVwbGljYXRlIHZlbmRvcjogIiArIG5hbWUpOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCX0KLQkJbGlzdC5hZGQodmVuZG9yKTsKLQl9Ci0KLQlwdWJsaWMgVmVuZG9yIGdldFZlbmRvcihTdHJpbmcgZHRwVmVuZG9yTmFtZSkgewotCQlmb3IgKGludCBpID0gdGhpcy52ZW5kb3JzLmxlbmd0aDsgaS0tID4gMDspIHsKLQkJCVZlbmRvciB2ZW5kb3IgPSB0aGlzLnZlbmRvcnNbaV07Ci0JCQlpZiAodmVuZG9yLmdldERUUFZlbmRvck5hbWUoKS5lcXVhbHMoZHRwVmVuZG9yTmFtZSkpIHsKLQkJCQlyZXR1cm4gdmVuZG9yOwotCQkJfQotCQl9Ci0JCXJldHVybiBVbnJlY29nbml6ZWRWZW5kb3IuaW5zdGFuY2UoKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci8ucHJvamVjdCBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci8ucHJvamVjdApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjE2NzBmZi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvLnByb2plY3QKKysrIC9kZXYvbnVsbApAQCAtMSwyMiArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPHByb2plY3REZXNjcmlwdGlvbj4KLQk8bmFtZT5vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXI8L25hbWU+Ci0JPGNvbW1lbnQ+PC9jb21tZW50PgotCTxwcm9qZWN0cz4KLQk8L3Byb2plY3RzPgotCTxidWlsZFNwZWM+Ci0JCTxidWlsZENvbW1hbmQ+Ci0JCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuTWFuaWZlc3RCdWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5TY2hlbWFCdWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQk8L2J1aWxkU3BlYz4KLQk8bmF0dXJlcz4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5wZGUuUGx1Z2luTmF0dXJlPC9uYXR1cmU+Ci0JPC9uYXR1cmVzPgotPC9wcm9qZWN0RGVzY3JpcHRpb24+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvTUVUQS1JTkYvTUFOSUZFU1QuTUYgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvTUVUQS1JTkYvTUFOSUZFU1QuTUYKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDdmMzI3ZjAuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL01FVEEtSU5GL01BTklGRVNULk1GCisrKyAvZGV2L251bGwKQEAgLTEsOSArMCwwIEBACi1NYW5pZmVzdC1WZXJzaW9uOiAxLjAKLUJ1bmRsZS1NYW5pZmVzdFZlcnNpb246IDIKLUJ1bmRsZS1OYW1lOiAlcGx1Z2luTmFtZQotQnVuZGxlLVZlbmRvcjogJXByb3ZpZGVyTmFtZQotQnVuZGxlLVN5bWJvbGljTmFtZTogb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyO3NpbmdsZXRvbjo9dHJ1ZQotQnVuZGxlLVZlcnNpb246IDEuMC4zMDAucXVhbGlmaWVyCi1CdW5kbGUtTG9jYWxpemF0aW9uOiBwbHVnaW4KLVJlcXVpcmUtQnVuZGxlOiBvcmcuZWNsaXBzZS5oZWxwO2J1bmRsZS12ZXJzaW9uPSJbMy4zLjEwMCw0LjAuMCkiLAotIG9yZy5lY2xpcHNlLnVpLmNoZWF0c2hlZXRzO2J1bmRsZS12ZXJzaW9uPSJbMy4zLjEwMCw0LjAuMCkiCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvYWJvdXQuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2Fib3V0Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmMzYWY2ZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvYWJvdXQuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNDIgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTUgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5BYm91dCB0aGlzIGNvbnRlbnQ8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJBYm91dCB0aGlzIGNvbnRlbnQiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxkaXYgY2xhc3M9InNlY3QxIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+PGEgaWQ9InN0aHJlZjI1NyIgbmFtZT0ic3RocmVmMjU3Ij48L2E+Ci08aDE+QWJvdXQgdGhpcyBjb250ZW50PC9oMT4KLTxwPkphbnVhcnksIDIwMDg8L3A+Ci08YSBpZD0ic3RocmVmMjU4IiBuYW1lPSJzdGhyZWYyNTgiPjwvYT4KLTxwIGNsYXNzPSJzdWJoZWFkMiI+TGljZW5zZTwvcD4KLTxwPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIGFsbCBjb250ZW50IGluIHRoaXMgcGx1Zy1pbiAoIkNvbnRlbnQiKS4gVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQgYmVsb3csIHRoZSBDb250ZW50IGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKCJFUEwiKS4gQSBjb3B5IG9mIHRoZSBFUEwgaXMgYXZhaWxhYmxlIGF0IDxjb2RlPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT48L2NvZGU+LiBGb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC48L3A+Ci08cD5JZiB5b3UgZGlkIG5vdCByZWNlaXZlIHRoaXMgQ29udGVudCBkaXJlY3RseSBmcm9tIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24sIHRoZSBDb250ZW50IGlzIGJlaW5nIHJlZGlzdHJpYnV0ZWQgYnkgYW5vdGhlciBwYXJ0eSAoIlJlZGlzdHJpYnV0b3IiKSBhbmQgZGlmZmVyZW50IHRlcm1zIGFuZCBjb25kaXRpb25zIG1heSBhcHBseSB0byB5b3VyIHVzZSBvZiBhbnkgb2JqZWN0IGNvZGUgaW4gdGhlIENvbnRlbnQuIENoZWNrIHRoZSBSZWRpc3RyaWJ1dG9yJ3MgbGljZW5zZSB0aGF0IHdhcyBwcm92aWRlZCB3aXRoIHRoZSBDb250ZW50LiBJZiBubyBzdWNoIGxpY2Vuc2UgZXhpc3RzLCBjb250YWN0IHRoZSBSZWRpc3RyaWJ1dG9yLiBVbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCBiZWxvdywgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFUEwgc3RpbGwgYXBwbHkgdG8gYW55IHNvdXJjZSBjb2RlIGluIHRoZSBDb250ZW50IGFuZCBzdWNoIHNvdXJjZSBjb2RlIG1heSBiZSBvYnRhaW5lZCBhdCA8Y29kZT48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnPC9hPjwvY29kZT4uPC9wPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MSIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvYWJvdXQuaHRtbCBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9hYm91dC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2YzNhZjZlLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9hYm91dC5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsNDIgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTUgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5BYm91dCB0aGlzIGNvbnRlbnQ8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJBYm91dCB0aGlzIGNvbnRlbnQiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxkaXYgY2xhc3M9InNlY3QxIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+PGEgaWQ9InN0aHJlZjI1NyIgbmFtZT0ic3RocmVmMjU3Ij48L2E+Ci08aDE+QWJvdXQgdGhpcyBjb250ZW50PC9oMT4KLTxwPkphbnVhcnksIDIwMDg8L3A+Ci08YSBpZD0ic3RocmVmMjU4IiBuYW1lPSJzdGhyZWYyNTgiPjwvYT4KLTxwIGNsYXNzPSJzdWJoZWFkMiI+TGljZW5zZTwvcD4KLTxwPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIGFsbCBjb250ZW50IGluIHRoaXMgcGx1Zy1pbiAoIkNvbnRlbnQiKS4gVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQgYmVsb3csIHRoZSBDb250ZW50IGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKCJFUEwiKS4gQSBjb3B5IG9mIHRoZSBFUEwgaXMgYXZhaWxhYmxlIGF0IDxjb2RlPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT48L2NvZGU+LiBGb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC48L3A+Ci08cD5JZiB5b3UgZGlkIG5vdCByZWNlaXZlIHRoaXMgQ29udGVudCBkaXJlY3RseSBmcm9tIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24sIHRoZSBDb250ZW50IGlzIGJlaW5nIHJlZGlzdHJpYnV0ZWQgYnkgYW5vdGhlciBwYXJ0eSAoIlJlZGlzdHJpYnV0b3IiKSBhbmQgZGlmZmVyZW50IHRlcm1zIGFuZCBjb25kaXRpb25zIG1heSBhcHBseSB0byB5b3VyIHVzZSBvZiBhbnkgb2JqZWN0IGNvZGUgaW4gdGhlIENvbnRlbnQuIENoZWNrIHRoZSBSZWRpc3RyaWJ1dG9yJ3MgbGljZW5zZSB0aGF0IHdhcyBwcm92aWRlZCB3aXRoIHRoZSBDb250ZW50LiBJZiBubyBzdWNoIGxpY2Vuc2UgZXhpc3RzLCBjb250YWN0IHRoZSBSZWRpc3RyaWJ1dG9yLiBVbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCBiZWxvdywgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFUEwgc3RpbGwgYXBwbHkgdG8gYW55IHNvdXJjZSBjb2RlIGluIHRoZSBDb250ZW50IGFuZCBzdWNoIHNvdXJjZSBjb2RlIG1heSBiZSBvYnRhaW5lZCBhdCA8Y29kZT48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnPC9hPjwvY29kZT4uPC9wPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MSIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvYnVpbGQucHJvcGVydGllcyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9idWlsZC5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0ZWNkNzUyLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9idWlsZC5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTE1ICswLDAgQEAKLWJpbi5pbmNsdWRlcyA9IGNoZWF0c2hlZXRzLyxcCi0gICAgICAgICAgICAgICBkY29tbW9uLyxcCi0gICAgICAgICAgICAgICBpbWcvLFwKLSAgICAgICAgICAgICAgIE1FVEEtSU5GLyxcCi0gICAgICAgICAgICAgICBhYm91dC5odG1sLFwKLSAgICAgICAgICAgICAgIGJ1aWxkLnByb3BlcnRpZXMsXAotICAgICAgICAgICAgICAgY29uY2VwdF9tYXBwaW5nLmh0bSxcCi0gICAgICAgICAgICAgICBjb25jZXB0X3BlcnNpc3RlbmNlLmh0bSxcCi0gICAgICAgICAgICAgICBjb25jZXB0cy5odG0sXAotICAgICAgICAgICAgICAgY29uY2VwdHMwMDEuaHRtLFwKLSAgICAgICAgICAgICAgIGNvbmNlcHRzMDAyLmh0bSxcCi0gICAgICAgICAgICAgICBjb25jZXB0czAwMy5odG0sXAotICAgICAgICAgICAgICAgY29udGV4dHMueG1sLFwKLSAgICAgICAgICAgICAgIGdldHRpbmdfc3RhcnRlZC5odG0sXAotICAgICAgICAgICAgICAgZ2V0dGluZ19zdGFydGVkMDAxLmh0bSxcCi0gICAgICAgICAgICAgICBnZXR0aW5nX3N0YXJ0ZWQwMDIuaHRtLFwKLSAgICAgICAgICAgICAgIGdldHRpbmdfc3RhcnRlZDAwMy5odG0sXAotICAgICAgICAgICAgICAgZ2V0dGluZ19zdGFydGVkMDA0Lmh0bSxcCi0gICAgICAgICAgICAgICBpbmRleC54bWwsXAotICAgICAgICAgICAgICAgbGVnYWwuaHRtLFwKLSAgICAgICAgICAgICAgIHBsdWdpbi5wcm9wZXJ0aWVzLFwKLSAgICAgICAgICAgICAgIHBsdWdpbi54bWwsXAotICAgICAgICAgICAgICAgcmVmX2RldGFpbHNfb3JtLmh0bSxcCi0gICAgICAgICAgICAgICByZWZfanBhX2ZhY2V0Lmh0bSxcCi0gICAgICAgICAgICAgICByZWZfbWFwcGluZ19nZW5lcmFsLmh0bSxcCi0gICAgICAgICAgICAgICByZWZfbmV3X2pwYV9wcm9qZWN0Lmh0bSxcCi0gICAgICAgICAgICAgICByZWZfbmV3X2pwYV9wcm9qZWN0X3dpemFyZC5odG0sXAotICAgICAgICAgICAgICAgcmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSxcCi0gICAgICAgICAgICAgICByZWZfcGVyc2lzdGVuY2Vfb3V0bGluZS5odG0sXAotICAgICAgICAgICAgICAgcmVmX3BlcnNpc3RlbmNlX3BlcnNwZWN0aXZlLmh0bSxcCi0gICAgICAgICAgICAgICByZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSxcCi0gICAgICAgICAgICAgICByZWZfcHJpbWFyeV9rZXkuaHRtLFwKLSAgICAgICAgICAgICAgIHJlZl9wcm9qZWN0X3Byb3BlcnRpZXMuaHRtLFwKLSAgICAgICAgICAgICAgIHJlZmVyZW5jZS5odG0sXAotICAgICAgICAgICAgICAgcmVmZXJlbmNlMDAxLmh0bSxcCi0gICAgICAgICAgICAgICByZWZlcmVuY2UwMDIuaHRtLFwKLSAgICAgICAgICAgICAgIHJlZmVyZW5jZTAwMy5odG0sXAotICAgICAgICAgICAgICAgcmVmZXJlbmNlMDA0Lmh0bSxcCi0gICAgICAgICAgICAgICByZWZlcmVuY2UwMDUuaHRtLFwKLSAgICAgICAgICAgICAgIHJlZmVyZW5jZTAwNi5odG0sXAotICAgICAgICAgICAgICAgcmVmZXJlbmNlMDA3Lmh0bSxcCi0gICAgICAgICAgICAgICByZWZlcmVuY2UwMDguaHRtLFwKLSAgICAgICAgICAgICAgIHJlZmVyZW5jZTAwOS5odG0sXAotICAgICAgICAgICAgICAgcmVmZXJlbmNlMDEwLmh0bSxcCi0gICAgICAgICAgICAgICByZWZlcmVuY2UwMTEuaHRtLFwKLSAgICAgICAgICAgICAgIHJlZmVyZW5jZTAxMi5odG0sXAotICAgICAgICAgICAgICAgcmVmZXJlbmNlMDEzLmh0bSxcCi0gICAgICAgICAgICAgICByZWZlcmVuY2UwMTQuaHRtLFwKLSAgICAgICAgICAgICAgIHJlZmVyZW5jZTAxNS5odG0sXAotICAgICAgICAgICAgICAgcmVmZXJlbmNlMDE2Lmh0bSxcCi0gICAgICAgICAgICAgICByZWZlcmVuY2UwMTcuaHRtLFwKLSAgICAgICAgICAgICAgIHJlZmVyZW5jZTAxOC5odG0sXAotICAgICAgICAgICAgICAgdGFza19hZGRfcGVyc2lzdGVuY2UuaHRtLFwKLSAgICAgICAgICAgICAgIHRhc2tfYWRkaXRvbmFsX3RhYmxlcy5odG0sXAotICAgICAgICAgICAgICAgdGFza19jcmVhdGVfbmV3X3Byb2plY3QuaHRtLFwKLSAgICAgICAgICAgICAgIHRhc2tfZ2VuZXJhdGVfZW50aXRpZXMuaHRtLFwKLSAgICAgICAgICAgICAgIHRhc2tfaW5oZXJpdGFuY2UuaHRtLFwKLSAgICAgICAgICAgICAgIHRhc2tfbWFuYWdlX29ybS5odG0sXAotICAgICAgICAgICAgICAgdGFza19tYW5hZ2VfcGVyc2lzdGVuY2UuaHRtLFwKLSAgICAgICAgICAgICAgIHRhc2tfbWFwcGluZy5odG0sXAotICAgICAgICAgICAgICAgdGFza3MuaHRtLFwKLSAgICAgICAgICAgICAgIHRhc2tzMDAxLmh0bSxcCi0gICAgICAgICAgICAgICB0YXNrczAwMi5odG0sXAotICAgICAgICAgICAgICAgdGFza3MwMDMuaHRtLFwKLSAgICAgICAgICAgICAgIHRhc2tzMDA0Lmh0bSxcCi0gICAgICAgICAgICAgICB0YXNrczAwNS5odG0sXAotICAgICAgICAgICAgICAgdGFza3MwMDYuaHRtLFwKLSAgICAgICAgICAgICAgIHRhc2tzMDA3Lmh0bSxcCi0gICAgICAgICAgICAgICB0YXNrczAwOC5odG0sXAotICAgICAgICAgICAgICAgdGFza3MwMDkuaHRtLFwKLSAgICAgICAgICAgICAgIHRhc2tzMDEwLmh0bSxcCi0gICAgICAgICAgICAgICB0YXNrczAxMS5odG0sXAotICAgICAgICAgICAgICAgdGFza3MwMTIuaHRtLFwKLSAgICAgICAgICAgICAgIHRhc2tzMDEzLmh0bSxcCi0gICAgICAgICAgICAgICB0YXNrczAxNC5odG0sXAotICAgICAgICAgICAgICAgdGFza3MwMTUuaHRtLFwKLSAgICAgICAgICAgICAgIHRhc2tzMDE2Lmh0bSxcCi0gICAgICAgICAgICAgICB0YXNrczAxNy5odG0sXAotICAgICAgICAgICAgICAgdGFza3MwMTguaHRtLFwKLSAgICAgICAgICAgICAgIHRhc2tzMDE5Lmh0bSxcCi0gICAgICAgICAgICAgICB0YXNrczAyMC5odG0sXAotICAgICAgICAgICAgICAgdGFza3MwMjEuaHRtLFwKLSAgICAgICAgICAgICAgIHRhc2tzMDIyLmh0bSxcCi0gICAgICAgICAgICAgICB0aXBzX2FuZF90cmlja3MuaHRtLFwKLSAgICAgICAgICAgICAgIHRvYy54bWwsXAotICAgICAgICAgICAgICAgd2hhdHNfbmV3Lmh0bSxcCi0gICAgICAgICAgICAgICB3aGF0c19uZXcwMDEuaHRtLFwKLSAgICAgICAgICAgICAgIHdoYXRzX25ldzAwMi5odG0sXAotICAgICAgICAgICAgICAgd2hhdHNfbmV3MDAzLmh0bSxcCi0gICAgICAgICAgICAgICBhYm91dC5odG0sXAotICAgICAgICAgICAgICAgcmVmZXJlbmNlMDE5Lmh0bSxcCi0gICAgICAgICAgICAgICByZWZlcmVuY2UwMjAuaHRtLFwKLSAgICAgICAgICAgICAgIHJlZmVyZW5jZTAyMS5odG0sXAotICAgICAgICAgICAgICAgcmVmZXJlbmNlMDIyLmh0bSxcCi0gICAgICAgICAgICAgICByZWZlcmVuY2UwMjMuaHRtLFwKLSAgICAgICAgICAgICAgIHJlZmVyZW5jZTAyNC5odG0sXAotICAgICAgICAgICAgICAgcmVmZXJlbmNlMDI1Lmh0bSxcCi0gICAgICAgICAgICAgICByZWZlcmVuY2UwMjYuaHRtLFwKLSAgICAgICAgICAgICAgIHJlZmVyZW5jZTAyNy5odG0sXAotICAgICAgICAgICAgICAgcmVmZXJlbmNlMDI4Lmh0bSxcCi0gICAgICAgICAgICAgICByZWZlcmVuY2UwMzAuaHRtLFwKLSAgICAgICAgICAgICAgIHJlZmVyZW5jZTAyOS5odG0sXAotICAgICAgICAgICAgICAgcmVmZXJlbmNlMDMxLmh0bSxcCi0gICAgICAgICAgICAgICByZWZlcmVuY2UwMzIuaHRtLFwKLSAgICAgICAgICAgICAgIHJlZmVyZW5jZTAzMy5odG0sXAotICAgICAgICAgICAgICAgcmVmZXJlbmNlMDM0Lmh0bSxcCi0gICAgICAgICAgICAgICB0YXNrczAyMy5odG0sXAotICAgICAgICAgICAgICAgdGFza3MwMjQuaHRtLFwKLSAgICAgICAgICAgICAgIHRhc2tzMDI1Lmh0bSxcCi0gICAgICAgICAgICAgICB3aGF0c19uZXcwMDQuaHRtLFwKLSAgICAgICAgICAgICAgIHdoYXRzX25ldzAwNS5odG0sXAotICAgICAgICAgICAgICAgd2hhdHNfbmV3MDA2Lmh0bSxcCi0gICAgICAgICAgICAgICB3aGF0c19uZXcwMDcuaHRtLFwKLSAgICAgICAgICAgICAgIHdoYXRzX25ldzAwOC5odG0KLWdlbmVyYXRlU291cmNlQnVuZGxlPWZhbHNlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvY2hlYXRzaGVldHMvYWRkX3BlcnNpc3RlbmNlLnhtbCBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9jaGVhdHNoZWV0cy9hZGRfcGVyc2lzdGVuY2UueG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2ZGJlZWRiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9jaGVhdHNoZWV0cy9hZGRfcGVyc2lzdGVuY2UueG1sCisrKyAvZGV2L251bGwKQEAgLTEsNjMgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxjaGVhdHNoZWV0IHRpdGxlPSJDcmVhdGUgYSBKUEEgUHJvamVjdCI+Ci0gICA8aW50cm8gaHJlZj0iL29yZy5lY2xpcHNlLnBsYXRmb3JtLmRvYy51c2VyL3JlZmVyZW5jZS9yZWYtY2hlYXRzaGVldHMuaHRtIj4KLSAgICAgIDxkZXNjcmlwdGlvbj4KLSAgICAgICAgIFRoaXMgY2hlYXQgc2hlZXQgd2lsbCBhdXRvbWF0aWNhbGx5IGxhdW5jaCB3aXphcmRzLCBwZXJmb3JtIGFjdGlvbnMsIGFuZCBndWlkZSB5b3UgdGhyb3VnaCB0aGUgc3RlcHMgdG8gY3JlYXRlIGEgSlBBIHByb2plY3QuIAotCi1UbyBsZWFybiBtb3JlIGFib3V0IHVzaW5nIGNoZWF0IHNoZWV0cywgb3IgdG8gc2VlIGEgbGlzdCBvZiBhdmFpbGFibGUgY2hlYXQgc2hlZXRzLCBjbGljayBIZWxwICg/KS4gCi1UbyBzdGFydCB3b3JrIHdvcmtpbmcgb24gdGhpcyBjaGVhdCBzaGVldCBjbGljayB0aGUgJnF1b3Q7Q2xpY2sgdG8gQmVnaW4mcXVvdDsgYnV0dG9uIGJlbG93LiAKLQotTGV0JmFwb3M7cyBnZXQgc3RhcnRlZCEKLSAgICAgIDwvZGVzY3JpcHRpb24+Ci0gICA8L2ludHJvPgotICAgPGl0ZW0gdGl0bGU9IlNldHVwIHRoZSBFbnZpcm9ubWVudCIgZGlhbG9nPSJmYWxzZSIgc2tpcD0idHJ1ZSIgaHJlZj0iL29yZy5lY2xpcHNlLmRhdGF0b29scy5kb2MudXNlci9jX2RhdGFiYXNlX2RldmVsb3BtZW50X3NldHVwLmh0bWwiPgotICAgICAgPGRlc2NyaXB0aW9uPgotICAgICAgICAgWW91ciBlbnZpcm9ubWVudCBtdXN0IGJlIHNldCB1cCBiZWZvcmUgeW91IGNhbiBwZXJmb3JtIHRoZSBzdGVwcyBpbiB0aGlzIGNoZWF0IHNoZWV0LiAKLQotQ3JlYXRlIGEgZGF0YWJhc2UgcHJvZmlsZSBhbmQgY29ubmVjdCB0byB0aGUgZGF0YWJhc2UuCi0KLVRoZSBEYXRhYmFzZSBDb25uZWN0aW9uIGRpYWxvZyBhdXRvbWF0aWNhbGx5IGFwcGVhcnMgd2hlbiB5b3UgY2xpY2sgdGhlICZxdW90O0NsaWNrIHRvIFBlcmZvcm0mcXVvdDsgYnV0dG9uLgotICAgICAgPC9kZXNjcmlwdGlvbj4KLSAgICAgIDxjb21tYW5kIHNlcmlhbGl6YXRpb249Im9yZy5lY2xpcHNlLmRhdGF0b29scy5zcWx0b29scy5zcWxlZGl0b3IuYXR0YWNoUHJvZmlsZUFjdGlvbiIgY29uZmlybT0iZmFsc2UiPgotICAgICAgPC9jb21tYW5kPgotICAgPC9pdGVtPgotICAgPGl0ZW0gdGl0bGU9IkNyZWF0ZSBhIEpQQSBQcm9qZWN0IiBkaWFsb2c9ImZhbHNlIiBza2lwPSJmYWxzZSIgaHJlZj0iL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrX2NyZWF0ZV9uZXdfcHJvamVjdC5odG0iPgotICAgICAgPGRlc2NyaXB0aW9uPgotICAgICAgICAgVXNlIHRoZSBOZXcgUHJvamVjdCBXaXphcmQgdG8gY3JlYXRlIGEgSlBBIHByb2plY3QuIAotU2VsZWN0IDxiPkZpbGUtJmd0O05ldy0mZ3Q7UHJvamVjdC4uLjwvYj4gYW5kIGNob29zZSA8Yj5KUEEtJmd0O0pQQSBQcm9qZWN0PC9iPiBpbiB0aGUgbGlzdC4gCi0KLU9uIHRoZSBmaXJzdCBwYWdlIG9mIHRoZSB3aXphcmQsIGVudGVyIGEgcHJvamVjdCBuYW1lIGFuZCBsb2NhdGlvbiwgc2VsZWN0IHlvdXIgdGFyZ2V0IHJ1bnRpbWUsIGFuZCBzZWxlY3QgYSBwcmVkZWZpbmVkIHByb2plY3QgY29uZmlndXJhdGlvbi4KLQotQ2xpY2sgPGI+TmV4dDwvYj4gdG8gZGlzcGxheSB0aGUgbmV4dCBwYWdlIG9mIHRoZSB3aXphcmQuCi0KLVRoZSAmcXVvdDtOZXcgSlBBIFByb2plY3QmcXVvdDsgd2l6YXJkIGlzIGF1dG9tYXRpY2FsbHkgZGlzcGxheWVkIHdoZW4geW91IGNsaWNrIHRoZSAmcXVvdDtDbGljayB0byBQZXJmb3JtJnF1b3Q7IGJ1dHRvbi4KLSAgICAgIDwvZGVzY3JpcHRpb24+Ci0gICAgICA8YWN0aW9uIGNsYXNzPSJvcmcuZWNsaXBzZS5qZHQuaW50ZXJuYWwudWkud2l6YXJkcy5PcGVuUHJvamVjdFdpemFyZEFjdGlvbiIgcGx1Z2luSWQ9Im9yZy5lY2xpcHNlLmpkdC51aSIgY29uZmlybT0iZmFsc2UiPgotICAgICAgPC9hY3Rpb24+Ci0gICA8L2l0ZW0+Ci0gICA8aXRlbSB0aXRsZT0iU2VsZWN0IFByb2plY3QgRmFjZXQiIGRpYWxvZz0iZmFsc2UiIHNraXA9ImZhbHNlIiBocmVmPSIvb3JnLmVjbGlwc2UuanN0LmoyZWUuZG9jLnVzZXIvdG9waWNzL3BoLXByb2plY3RzLmh0bWwiPgotICAgICAgPGRlc2NyaXB0aW9uPgotICAgICAgICAgVXNlIHRoZSBQcm9qZWN0IEZhY2V0IHBhZ2UgdG8gc2VsZWN0IGEgcHJlZGVmaW5lZCBwcm9qZWN0IGNvbmZpZ3VyYXRpb24gb3Igc3BlY2lmaWMgc3BlY2lmaWMgZmFjZXRzIHRvIGluY2x1ZGUgaW4gdGhlIHByb2plY3QuIAotCi1DbGljayAmcXVvdDtOZXh0JnF1b3Q7IHRvIGRpc3BsYXkgdGhlIG5leHQgcGFnZSBvZiB0aGUgd2l6YXJkLgotICAgICAgPC9kZXNjcmlwdGlvbj4KLSAgIDwvaXRlbT4KLSAgIDxpdGVtIHRpdGxlPSJTcGVjaWZ5IHRoZSBKUEEgRmFjZXQiIGRpYWxvZz0iZmFsc2UiIHNraXA9ImZhbHNlIiBocmVmPSIvb3JnLmVjbGlwc2UuamR0LmRvYy51c2VyL3JlZl9qcGFfZmFjZXQuaHRtIj4KLSAgICAgIDxkZXNjcmlwdGlvbj4KLSAgICAgICAgIFVzZSB0aGUgSlBBIEZhY2V0IHBhZ2UgdG8gc3BlY2lmeSB0aGUgdGhlIHZlbmRvci1zcGVjaWZpYyBKUEEgcGxhdGZvcm0sIHRoZSBkYXRhYmFzZSBjb25uZWN0aW9uIHRvIHVzZSwgYW5kIHRoZSBzcGVjaWZpYyBKUEEgaW1wbGVtZW50YXRpb24gbGlicmFyeS4gCi0KLVlvdSBjYW4gYWxzbyBzcGVjaWZ5IGlmIERhbGkgc2hvdWxkIGNyZWF0ZSBhbiBvcm0ueG1sIGZpbGUuCi0KLUlmIHlvdSBkbyBub3QgaGF2ZSBhbiBhY3RpdmUgZGF0YWJhc2UgY29ubmVjdGlvbiwgY2xpY2sgPGI+QWRkIENvbm5lY3Rpb25zPC9iPiB0byBjcmVhdGUgb25lLiAKLQotSWYgeW91IGRvIG5vdCBoYXZlIGEgZGVmaW5lZCBKUEEgaW1wbGVtZW50YXRpb24gbGlicmFyeSwgY2xpY2sgPGI+Q29uZmlndXJlIGRlZmF1bHQgSlBBIGltcGxlbWVudGF0aW9uIGxpYnJhcnk8L2I+IG9yIDxiPkNvbmZpZ3VyZSB1c2VyIGxpYnJhcmllczwvYj4gdG8gZGVmaW5lIG9uZS4gCi0KLUNsaWNrIDxiPkZpbmlzaDwvYj4gdG8gY29tcGxldGUgdGhlIHdpemFyZCBhbmQgb3BlbiB0aGUgb3BlbiB0aGUgcHJvamVjdC4KLSAgICAgIDwvZGVzY3JpcHRpb24+Ci0gICA8L2l0ZW0+Ci0gICA8aXRlbSB0aXRsZT0iRmluaXNoIiBkaWFsb2c9ImZhbHNlIiBza2lwPSJmYWxzZSI+Ci0gICAgICA8ZGVzY3JpcHRpb24+Ci0gICAgICAgICBDb25ncmF0dWxhdGlvbnMhIFlvdSBoYXZlIHN1Y2Nlc3NmdWxseSBjcmVhdGVkIGEgSlBBIHByb2plY3QuIENvbXBsZXRlIHRoZSBhZGRpdGlvbmFsIGNoZWF0IHNoZWV0cyB0byBhZGQgSmF2YSBwZXJzaXN0ZW50IGVudGl0aWVzIGFuZCBtYXAgdGhvc2UgZW50aXRpZXMgdG8gZGF0YWJhc2UgdGFibGVzLgotICAgICAgPC9kZXNjcmlwdGlvbj4KLSAgIDwvaXRlbT4KLTwvY2hlYXRzaGVldD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9jaGVhdHNoZWV0cy9jcmVhdGVfZW50aXR5LnhtbCBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9jaGVhdHNoZWV0cy9jcmVhdGVfZW50aXR5LnhtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYjY0ZThhZi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvY2hlYXRzaGVldHMvY3JlYXRlX2VudGl0eS54bWwKKysrIC9kZXYvbnVsbApAQCAtMSw0NCArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPGNoZWF0c2hlZXQgdGl0bGU9IkNyZWF0ZSBhIFBlcnNpc3RlbnQgRW50aXR5Ij4KLQk8aW50cm8gaHJlZj0iL29yZy5lY2xpcHNlLnBsYXRmb3JtLmRvYy51c2VyL3JlZmVyZW5jZS9yZWYtY2hlYXRzaGVldHMuaHRtIj4KLQkJPGRlc2NyaXB0aW9uPgotVGhpcyBjaGVhdCBzaGVldCB3aWxsIGF1dG9tYXRpY2FsbHkgbGF1bmNoIHdpemFyZHMsIHBlcmZvcm0gYWN0aW9ucywgYW5kIGd1aWRlIHlvdSB0aHJvdWdoIHRoZSBzdGVwcyB0byBhZGQgYSBKYXZhIHBlcnNpc3RlbnQgZW50aXR5IHRvIHlvdXIgSmF2YSBwcm9qZWN0LiAKLVRvIGxlYXJuIG1vcmUgYWJvdXQgdXNpbmcgY2hlYXQgc2hlZXRzIG9yIHRvIHNlZSBhIGxpc3Qgb2YgYXZhaWxhYmxlIGNoZWF0IHNoZWV0cywgY2xpY2sgSGVscCAoPykuIAotVG8gc3RhcnQgd29yayB3b3JraW5nIG9uIHRoaXMgY2hlYXQgc2hlZXQsIGNsaWNrIHRoZSA8Yj5DbGljayB0byBCZWdpbjwvYj4gYnV0dG9uIGJlbG93LiAKLUxldCdzIGdldCBzdGFydGVkIQotICA8L2Rlc2NyaXB0aW9uPgotCTwvaW50cm8+Ci0JPGl0ZW0gdGl0bGU9IkNyZWF0ZSBhIEpQQSBQcm9qZWN0IiBza2lwPSJ0cnVlIj4KLQkJPGRlc2NyaXB0aW9uPgotVG8gY3JlYXRlIGEgUGVyc2lzdGVudCBlbnRpdHksIHlvdSBtdXN0IGNyZWF0ZSBhIEpQQSBwcm9qZWN0LiBJZiB5b3UgYWxyZWFkeSBoYXZlIGEgSlBBIHByb2plY3QsIHlvdSBtYXkgc2tpcCB0aGlzIHN0ZXAgYnkgY2xpY2tpbmcgdGhlICJDbGljayB0byBTa2lwIiBidXR0b24uCi1JZiBub3QsIHNlbGVjdCA8Yj5GaWxlLT5OZXctPlByb2plY3QuLi48L2I+IGFuZCBjaG9vc2UgPGI+SlBBLT5KUEEgUHJvamVjdDwvYj4gaW4gdGhlIGxpc3QuIENvbXBsZXRlIGVhY2ggcGFnZSBvZiB0aGUgQ3JlYXRlIEpQQSBQcm9qZWN0IHdpemFyZCB0byBjcmVhdGUgYSBuZXcgSlBBIHByb2plY3QuCi0gICAgICA8L2Rlc2NyaXB0aW9uPgotCTwvaXRlbT4KLQk8aXRlbSB0aXRsZT0iT3BlbiB0aGUgSlBBIERldmVsb3BtZW50IFBlcnNwZWN0aXZlIiBza2lwPSJ0cnVlIiBocmVmPSIvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZl9wZXJzaXN0ZW5jZV9wZXJzcGVjdGl2ZS5odG0iPgotCQk8YWN0aW9uIHBsdWdpbklkPSJvcmcuZWNsaXBzZS51aS5jaGVhdHNoZWV0cyIgY2xhc3M9Im9yZy5lY2xpcHNlLnVpLmludGVybmFsLmNoZWF0c2hlZXRzLmFjdGlvbnMuT3BlblBlcnNwZWN0aXZlIiBwYXJhbTE9Im9yZy5lY2xpcHNlLmpwdC51aS5QZXJzaXN0ZW5jZVBlcnNwZWN0aXZlIi8+Ci0JCTxkZXNjcmlwdGlvbj4KLVdoZW4gd29ya2luZyB3aXRoIEpQQSAgcGVyc2lzdGVuY2UsIHlvdSBzaG91bGQgdXNlIHRoZSBQZXJzaXN0ZW5jZSBwZXJzcGVjdGl2ZS4gSWYgeW91IGFscmVhZHkgaGF2ZSB0aGUgUGVyc2lzdGVuY2UgcGVyc3BlY3RpdmUgYWN0aXZlLCB5b3UgbWF5IHNraXAgdGhpcyBzdGVwIGJ5IGNsaWNraW5nIHRoZSAiQ2xpY2sgdG8gU2tpcCIgYnV0dG9uLiAKLUlmIG5vdCwgc2VsZWN0IDxiPldpbmRvdy0+T3BlbiBQZXJzcGVjdGl2ZS0+T3RoZXI8L2I+IGluIHRoZSBtZW51YmFyIGF0IHRoZSB0b3Agb2YgdGhlIHdvcmtiZW5jaC4gSW4gdGhlIFNlbGVjdCBQZXJzcGVjdGl2ZXMgZGlhbG9nLCBzZWxlY3QgPGI+SlBBIERldmVsb3BtZW50PC9iPiBhbmQgY2xpY2sgT0suIFRoaXMgc3RlcCBjaGFuZ2VzIHRoZSBwZXJzcGVjdGl2ZSB0byBzZXQgdXAgdGhlIEVjbGlwc2Ugd29ya2JlbmNoIGZvciBKUEEgZGV2ZWxvcG1lbnQuCi1Zb3UgY2FuIGNsaWNrIHRoZSAiQ2xpY2sgdG8gUGVyZm9ybSIgYnV0dG9uIHRvIGhhdmUgdGhlICJQZXJzaXN0ZW5jZSIgcGVyc3BlY3RpdmUgb3BlbmVkIGF1dG9tYXRpY2FsbHkuCi0gICA8L2Rlc2NyaXB0aW9uPgotCTwvaXRlbT4KLQk8aXRlbSB0aXRsZT0iQ3JlYXRlIGEgSmF2YSBDbGFzcyI+Ci0JCTxkZXNjcmlwdGlvbj4KLVRoZSBuZXh0IHN0ZXAgaXMgdG8gY3JlYXRlIGEgbmV3IEphdmEgY2xhc3MuIEluIHRoZSBtYWluIHRvb2xiYXIgYWdhaW4sIGNsaWNrIG9uIDxiPk5ldyBKYXZhIENsYXNzPC9iPiBidXR0b24gKG9yIHRoZSBsaW5rIGJlbG93KS4KLVRoZSBKYXZhIGVkaXRvciB3aWxsIGF1dG9tYXRpY2FsbHkgb3BlbiBzaG93aW5nIHlvdXIgbmV3IGNsYXNzLiAgICAgIAotICAgICA8L2Rlc2NyaXB0aW9uPgotCTwvaXRlbT4KLQk8aXRlbSB0aXRsZT0iQ3JlYXRlIGEgUGVyc2lzdGVudCBFbnRpdHkiPgotCQk8ZGVzY3JpcHRpb24+Ci1GaW5hbGx5IHdlIHdpbGwgbWFrZSB0aGUgSmF2YSBjbGFzcyBhIHBlcnNpc3RlbnQgZW50aXR5LgotSW4gdGhlIEpQQSBTdHJ1Y3R1cmUgdmlldyBzZWxlY3QgdGhlIEphdmEgY2xhc3MuIAotSW4gdGhlIEpQQSBEZXRhaWxzIHZpZXcsIHVzZSB0aGUgIk1hcCBBcyIgZmllbGQgdG8gc2VsZWN0IDxiPkVudGl0eTwvYj4uIERhbGkgYXV0b21hdGljYWxseSBhZGRzIHRoZSBARW50aXR5IGFubm90YXRpb24gdG8gdGhlIGNsYXNzIGluIHRoZSBKYXZhIGVkaXRvci4gCi1Vc2UgdGhlIFRhYmxlLCBDYXRhbG9nLCBhbmQgU2NoZW1hIGZpZWxkcyB0byBhc3NvY2lhdGUgdGhlIGVudGl0eSB3aXRoIGEgc3BlY2lmaWMgdGFibGUgaW4gdGhlIGRhdGFiYXNlLgotICAgICA8L2Rlc2NyaXB0aW9uPgotCTwvaXRlbT4KLQk8aXRlbSB0aXRsZT0iRmluaXNoIj4KLQkJPGRlc2NyaXB0aW9uPgotQ29uZ3JhdHVsYXRpb25zISBZb3UgaGF2ZSBzdWNjZXNzZnVsbHkgYWRkZWQgYSBKUEEgZW50aXR5IHRvIHlvdXIgSlBBIHByb2plY3QuIENvbXBsZXRlIHRoZSBhZGRpdGlvbmFsIGNoZWF0IHNoZWV0cyB0byBtYXAgdGhlIGVudGl0eSdzIGZpZWxkcyB0byBkYXRhYmFzZSB0YWJsZXMuCi0gIDwvZGVzY3JpcHRpb24+Ci0JPC9pdGVtPgotPC9jaGVhdHNoZWV0PgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2NoZWF0c2hlZXRzL21hcF9lbnRpdHkueG1sIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2NoZWF0c2hlZXRzL21hcF9lbnRpdHkueG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2MzMwN2YyLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9jaGVhdHNoZWV0cy9tYXBfZW50aXR5LnhtbAorKysgL2Rldi9udWxsCkBAIC0xLDg4ICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08Y2hlYXRzaGVldCB0aXRsZT0iTWFwIGEgSmF2YSBQZXJzaXN0ZW50IEVudGl0eSI+Ci0gICA8aW50cm8gaHJlZj0iL29yZy5lY2xpcHNlLnBsYXRmb3JtLmRvYy51c2VyL3JlZmVyZW5jZS9yZWYtY2hlYXRzaGVldHMuaHRtIj4KLSAgICAgIDxkZXNjcmlwdGlvbj4KLSAgICAgICAgIFRoaXMgY2hlYXQgc2hlZXQgd2lsbCBhdXRvbWF0aWNhbGx5IGxhdW5jaCB3aXphcmRzLCBwZXJmb3JtIGFjdGlvbnMsIGFuZCBndWlkZSB5b3UgdGhyb3VnaCB0aGUgc3RlcHMgdG8gbWFwIHRoZSBmaWVsZHMgb2YgYSBKUEEgZW50aXR5IGVudGl0eSB0byB5b3VyIGRhdGFiYXNlLgotCi1UbyBsZWFybiBtb3JlIGFib3V0IHVzaW5nIGNoZWF0IHNoZWV0cyBvciB0byBzZWUgYSBsaXN0IG9mIGF2YWlsYWJsZSBjaGVhdCBzaGVldHMsIGNsaWNrIEhlbHAgKD8pLiAKLVRvIHN0YXJ0IHdvcmsgd29ya2luZyBvbiB0aGlzIGNoZWF0IHNoZWV0LCBjbGljayB0aGUgJnF1b3Q7Q2xpY2sgdG8gQmVnaW4mcXVvdDsgYnV0dG9uIGJlbG93LiAKLQotTGV0JmFwb3M7cyBnZXQgc3RhcnRlZCEKLSAgICAgIDwvZGVzY3JpcHRpb24+Ci0gICA8L2ludHJvPgotICAgPGl0ZW0gdGl0bGU9IlNldHVwIHRoZSBFbnZpcm9ubWVudCIgZGlhbG9nPSJmYWxzZSIgc2tpcD0idHJ1ZSIgaHJlZj0iL29yZy5lY2xpcHNlLmRhdGF0b29scy5kb2MudXNlci9jX2RhdGFiYXNlX2RldmVsb3BtZW50X3NldHVwLmh0bWwiPgotICAgICAgPGRlc2NyaXB0aW9uPgotICAgICAgICAgWW91ciBlbnZpcm9ubWVudCBtdXN0IGJlIHNldCB1cCBiZWZvcmUgeW91IGNhbiBwZXJmb3JtIHRoZSBzdGVwcyBpbiB0aGlzIGNoZWF0IHNoZWV0LiAKLQotQ3JlYXRlIGEgZGF0YWJhc2UgcHJvZmlsZSBhbmQgY29ubmVjdCB0byB0aGUgZGF0YWJhc2UuCi0KLUlmIHlvdSBhbHJlYWR5IGhhdmUgKGFuZCBhcmUgY29ubmVjdGVkIHRvKSBhIGRhdGFiYXNlIGNvbm5lY3Rpb24sIHlvdSAgbWF5IHNraXAgdGhpcyBzdGVwIGJ5IGNsaWNraW5nIHRoZSAmcXVvdDtDbGljayB0byBTa2lwJnF1b3Q7IGJ1dHRvbi4KLQotVGhlIERhdGFiYXNlIENvbm5lY3Rpb24gZGlhbG9nIGF1dG9tYXRpY2FsbHkgYXBwZWFycyB3aGVuIHlvdSBjbGljayB0aGUgJnF1b3Q7Q2xpY2sgdG8gUGVyZm9ybSZxdW90OyBidXR0b24uCi0gICAgICA8L2Rlc2NyaXB0aW9uPgotICAgICAgPGNvbW1hbmQgc2VyaWFsaXphdGlvbj0ib3JnLmVjbGlwc2UuZGF0YXRvb2xzLnNxbHRvb2xzLnNxbGVkaXRvci5hdHRhY2hQcm9maWxlQWN0aW9uIiBjb25maXJtPSJmYWxzZSI+Ci0gICAgICA8L2NvbW1hbmQ+Ci0gICA8L2l0ZW0+Ci0gICA8aXRlbSB0aXRsZT0iQ3JlYXRlIGEgSlBBIFByb2plY3QiIGRpYWxvZz0iZmFsc2UiIHNraXA9InRydWUiIGhyZWY9Ii9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza19jcmVhdGVfbmV3X3Byb2plY3QuaHRtIj4KLSAgICAgIDxkZXNjcmlwdGlvbj4KLSAgICAgICAgIFVzZSB0aGUgTmV3IFByb2plY3QgV2l6YXJkIHRvIGNyZWF0ZSBhIEpQQSBwcm9qZWN0LiAKLVNlbGVjdCA8Yj5GaWxlLSZndDtOZXctJmd0O1Byb2plY3QuLi48L2I+IGFuZCBjaG9vc2UgPGI+SlBBLSZndDtKUEEgUHJvamVjdDwvYj4gaW4gdGhlIGxpc3QuIAotCi1Db21wbGV0ZSBlYWNoIHBhZ2Ugb2YgdGhlIHdpemFyZCB0byBjcmVhdGUgYSBuZXcgSlBBIHByb2plY3QuCi0KLVRoZSAmcXVvdDtOZXcgSlBBIFByb2plY3QmcXVvdDsgd2l6YXJkIGlzIGF1dG9tYXRpY2FsbHkgZGlzcGxheWVkIHdoZW4geW91IGNsaWNrIHRoZSAmcXVvdDtDbGljayB0byBQZXJmb3JtJnF1b3Q7IGJ1dHRvbi4KLQotSWYgeW91IGFscmVhZHkgaGF2ZSBhIEpQQSBwcm9qZWN0LCB5b3UgIG1heSBza2lwIHRoaXMgc3RlcCBieSBjbGlja2luZyB0aGUgJnF1b3Q7Q2xpY2sgdG8gU2tpcCZxdW90OyBidXR0b24uCi0gICAgICA8L2Rlc2NyaXB0aW9uPgotICAgICAgPGFjdGlvbiBjbGFzcz0ib3JnLmVjbGlwc2UuamR0LmludGVybmFsLnVpLndpemFyZHMuT3BlblByb2plY3RXaXphcmRBY3Rpb24iIHBsdWdpbklkPSJvcmcuZWNsaXBzZS5qZHQudWkiIGNvbmZpcm09ImZhbHNlIj4KLSAgICAgIDwvYWN0aW9uPgotICAgPC9pdGVtPgotICAgPGl0ZW0gdGl0bGU9Ik9wZW4gdGhlIEpQQSBEZXZlbG9wbWVudCBQZXJzcGVjdGl2ZSIgZGlhbG9nPSJmYWxzZSIgc2tpcD0idHJ1ZSIgaHJlZj0iL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZfcGVyc2lzdGVuY2VfcGVyc3BlY3RpdmUuaHRtIj4KLSAgICAgIDxkZXNjcmlwdGlvbj4KLSAgICAgICAgIFdoZW4gd29ya2luZyB3aXRoIEpQQSAgcGVyc2lzdGVuY2UsIHlvdSBzaG91bGQgdXNlIHRoZSBQZXJzaXN0ZW5jZSBwZXJzcGVjdGl2ZS4gSWYgeW91IGFscmVhZHkgaGF2ZSB0aGUgUGVyc2lzdGVuY2UgcGVyc3BlY3RpdmUgYWN0aXZlLCB5b3UgbWF5IHNraXAgdGhpcyBzdGVwIGJ5IGNsaWNraW5nIHRoZSAmcXVvdDtDbGljayB0byBTa2lwJnF1b3Q7IGJ1dHRvbi4gCi1JZiBub3QsIHNlbGVjdCA8Yj5XaW5kb3ctJmd0O09wZW4gUGVyc3BlY3RpdmUtJmd0O090aGVyPC9iPiBpbiB0aGUgbWVudWJhciBhdCB0aGUgdG9wIG9mIHRoZSB3b3JrYmVuY2guIEluIHRoZSBTZWxlY3QgUGVyc3BlY3RpdmVzIGRpYWxvZywgc2VsZWN0IDxiPkpQQSBEZXZlbG9wbWVudDwvYj4gYW5kIGNsaWNrIE9LLiBUaGlzIHN0ZXAgY2hhbmdlcyB0aGUgcGVyc3BlY3RpdmUgdG8gc2V0IHVwIHRoZSBFY2xpcHNlIHdvcmtiZW5jaCBmb3IgSlBBIGRldmVsb3BtZW50LgotWW91IGNhbiBjbGljayB0aGUgJnF1b3Q7Q2xpY2sgdG8gUGVyZm9ybSZxdW90OyBidXR0b24gdG8gaGF2ZSB0aGUgJnF1b3Q7UGVyc2lzdGVuY2UmcXVvdDsgcGVyc3BlY3RpdmUgb3BlbmVkIGF1dG9tYXRpY2FsbHkuCi0gICAgICA8L2Rlc2NyaXB0aW9uPgotICAgICAgPGFjdGlvbiBjbGFzcz0ib3JnLmVjbGlwc2UudWkuaW50ZXJuYWwuY2hlYXRzaGVldHMuYWN0aW9ucy5PcGVuUGVyc3BlY3RpdmUiIHBsdWdpbklkPSJvcmcuZWNsaXBzZS51aS5jaGVhdHNoZWV0cyIgY29uZmlybT0iZmFsc2UiIHBhcmFtMT0ib3JnLmVjbGlwc2UuanB0LnVpLlBlcnNpc3RlbmNlUGVyc3BlY3RpdmUiPgotICAgICAgPC9hY3Rpb24+Ci0gICA8L2l0ZW0+Ci0gICA8aXRlbSB0aXRsZT0iQ3JlYXRlIGEgSmF2YSBDbGFzcyIgZGlhbG9nPSJmYWxzZSIgc2tpcD0iZmFsc2UiPgotICAgICAgPGRlc2NyaXB0aW9uPgotICAgICAgICAgVGhlIG5leHQgc3RlcCBpcyB0byBjcmVhdGUgYSBuZXcgSmF2YSBjbGFzcy4gSW4gdGhlIG1haW4gdG9vbGJhciBhZ2FpbiwgY2xpY2sgb24gPGI+TmV3IEphdmEgQ2xhc3M8L2I+IGJ1dHRvbiAob3IgdGhlIGxpbmsgYmVsb3cpLgotVGhlIEphdmEgZWRpdG9yIHdpbGwgYXV0b21hdGljYWxseSBvcGVuIHNob3dpbmcgeW91ciBuZXcgY2xhc3MuCi0gICAgICA8L2Rlc2NyaXB0aW9uPgotICAgPC9pdGVtPgotICAgPGl0ZW0gdGl0bGU9IkNyZWF0ZSBhIFBlcnNpc3RlbnQgRW50aXR5IiBkaWFsb2c9ImZhbHNlIiBza2lwPSJmYWxzZSI+Ci0gICAgICA8ZGVzY3JpcHRpb24+Ci0gICAgICAgICBGaW5hbGx5IHdlIHdpbGwgbWFrZSB0aGUgSmF2YSBjbGFzcyBhIHBlcnNpc3RlbnQgZW50aXR5LgotSW4gdGhlIEpQQSBTdHJ1Y3R1cmUgdmlldyBzZWxlY3QgdGhlIEphdmEgY2xhc3MuIAotSW4gdGhlIEpQQSBEZXRhaWxzIHZpZXcsIHVzZSB0aGUgJnF1b3Q7TWFwIEFzJnF1b3Q7IGZpZWxkIHRvIHNlbGVjdCA8Yj5FbnRpdHk8L2I+LiBEYWxpIGF1dG9tYXRpY2FsbHkgYWRkcyB0aGUgQEVudGl0eSBhbm5vdGF0aW9uIHRvIHRoZSBjbGFzcyBpbiB0aGUgSmF2YSBlZGl0b3IuIAotVXNlIHRoZSBUYWJsZSwgQ2F0YWxvZywgYW5kIFNjaGVtYSBmaWVsZHMgdG8gYXNzb2NpYXRlIHRoZSBlbnRpdHkgd2l0aCBhIHNwZWNpZmljIHRhYmxlIGluIHRoZSBkYXRhYmFzZS4KLSAgICAgIDwvZGVzY3JpcHRpb24+Ci0gICA8L2l0ZW0+Ci0gICA8aXRlbSB0aXRsZT0iQWRkIEZpZWxkcyB0byB0aGUgQ2xhc3MiIGRpYWxvZz0iZmFsc2UiIHNraXA9InRydWUiPgotICAgICAgPGRlc2NyaXB0aW9uPgotICAgICAgICAgTm93IHlvdSB3aWxsIGFkZCBzb21lIGZpZWxkcyB0byB0aGUgZW50aXR5IHRvIG1hcCB0byByb3dzIGluIHRoZSBkYXRhYmFzZSB0YWJsZS4gICAKLQotSWYgeW91ciBwZXJzaXN0ZW50IGVudGl0eSBhbHJlYWR5IGhhcyBmaWVsZHMgdG8gbWFwLCB5b3UgbWF5IHNraXAgdGhpcyBzdGVwIGJ5IGNsaWNraW5nIHRoZSAmcXVvdDtDbGljayB0byBTa2lwJnF1b3Q7IGJ1dHRvbi4gSWYgbm90LCB1c2UgdGhlIEphdmEgZWRpdG9yIHRvIGFkZCBmaWVsZHMgdG8gdGhlIGVudGl0eS4KLSAgICAgIDwvZGVzY3JpcHRpb24+Ci0gICAgICA8YWN0aW9uIGNsYXNzPSJvcmcuZWNsaXBzZS51aS5pbnRlcm5hbC5jaGVhdHNoZWV0cy5hY3Rpb25zLk9wZW5QZXJzcGVjdGl2ZSIgcGx1Z2luSWQ9Im9yZy5lY2xpcHNlLnVpLmNoZWF0c2hlZXRzIiBjb25maXJtPSJmYWxzZSIgcGFyYW0xPSJvcmcuZWNsaXBzZS5kYWxpLnVpLlBlcnNpc3RlbmNlUGVyc3BlY3RpdmUiPgotICAgICAgPC9hY3Rpb24+Ci0gICA8L2l0ZW0+Ci0gICA8aXRlbSB0aXRsZT0iQ3JlYXRlIHRoZSBNYXBwaW5nIiBkaWFsb2c9ImZhbHNlIiBza2lwPSJmYWxzZSIgaHJlZj0iL29yZy5lY2xpcHNlLmRhbGkuZG9jLnVzZXIvcmVmX2VudGl0eV9wYWdlLmh0bSI+Ci0gICAgICA8ZGVzY3JpcHRpb24+Ci0gICAgICAgICBOb3cgeW91IGFyZSByZWFkeSB0byBtYXAgdGhlIGVudGl0eSBmaWVsZHMgdG8gY29sdW1ucyBpbiB0aGUgZGF0YWJhc2UgdGFibGUuIEluIHRoZSBQYWNrYWdlIEV4cGxvcmVyLCBzZWxlY3QgdGhlIEphdmEgY2xhc3MuIAotCi1JbiB0aGUgSlBBIFN0cnVjdHVyZSB2aWV3LCBleHBhbmQgdGhlIHBlcnNpc3RlbnQgZW50aXR5IHRvIGRpc3BsYXkgdGhlIGZpZWxkcy4gU2VsZWN0IGEgZmllbGQuIAotCi1UaGUgSlBBIERldGFpbHMgdmlldyBkaXNwbGF5cyB0aGUgaW5mb3JtYXRpb24gZm9yIHRoZSBmaWVsZC4gVXNlIHRoZSBNYXAgQXMgZmllbGQgdG8gc2VsZWN0IHRoZSBCYXNpYyBtYXBwaW5nLiBVc2UgdGhlIENvbHVtbiBmaWVsZCB0byBzZWxlY3QgYSBjb2x1bW4gZnJvbSB0aGUgZGF0YWJhc2UgdGFibGUuCi0gICAgICA8L2Rlc2NyaXB0aW9uPgotICAgICAgPGFjdGlvbiBjbGFzcz0ib3JnLmVjbGlwc2UudWkuaW50ZXJuYWwuY2hlYXRzaGVldHMuYWN0aW9ucy5PcGVuUGVyc3BlY3RpdmUiIHBsdWdpbklkPSJvcmcuZWNsaXBzZS51aS5jaGVhdHNoZWV0cyIgY29uZmlybT0iZmFsc2UiIHBhcmFtMT0ib3JnLmVjbGlwc2UuZGFsaS51aS5QZXJzaXN0ZW5jZVBlcnNwZWN0aXZlIj4KLSAgICAgIDwvYWN0aW9uPgotICAgPC9pdGVtPgotICAgPGl0ZW0gdGl0bGU9IkZpbmlzaCIgZGlhbG9nPSJmYWxzZSIgc2tpcD0iZmFsc2UiPgotICAgICAgPGRlc2NyaXB0aW9uPgotICAgICAgICAgQ29uZ3JhdHVsYXRpb25zISBZb3UgaGF2ZSBzdWNjZXNzZnVsbHkgbWFwcGVkIHRoZSBmaWVsZHMgZnJvbSBhIEphdmEgcGVyc2lzdGVudCBlbnRpdHkgdG8gYSBjb2x1bW4gaW4gYSBkYXRhYmFzZSB0YWJsZS4KLSAgICAgIDwvZGVzY3JpcHRpb24+Ci0gICA8L2l0ZW0+Ci08L2NoZWF0c2hlZXQ+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvY29uY2VwdF9tYXBwaW5nLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9jb25jZXB0X21hcHBpbmcuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0MDYzNTI3Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9jb25jZXB0X21hcHBpbmcuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNDUgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDEgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5VbmRlcnN0YW5kaW5nIE9SIG1hcHBpbmdzPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iVW5kZXJzdGFuZGluZyBPUiBtYXBwaW5ncyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkJBQkJESkZJIiBuYW1lPSJCQUJCREpGSSI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QxIj4KLTxoMT5VbmRlcnN0YW5kaW5nIE9SIG1hcHBpbmdzPC9oMT4KLTxwPjxhIGlkPSJzdGhyZWYyMCIgbmFtZT0ic3RocmVmMjAiPjwvYT48YSBpZD0ic3RocmVmMjEiIG5hbWU9InN0aHJlZjIxIj48L2E+VGhlIERhbGkgT1IgKG9iamVjdC1yZWxhdGlvbmFsKSBNYXBwaW5nIFRvb2wgYWxsb3dzIHlvdSB0byBkZXNjcmliZSBob3cgeW91ciBlbnRpdHkgb2JqZWN0cyA8c3BhbiBjbGFzcz0iaXRhbGljIj5tYXA8L3NwYW4+IHRvIHRoZSBkYXRhIHNvdXJjZSAob3Igb3RoZXIgb2JqZWN0cykuIFRoaXMgYXBwcm9hY2ggaXNvbGF0ZXMgcGVyc2lzdGVuY2UgaW5mb3JtYXRpb24gZnJvbSB0aGUgb2JqZWN0IG1vZGVsJm5kYXNoO2RldmVsb3BlcnMgYXJlIGZyZWUgdG8gZGVzaWduIHRoZWlyIGlkZWFsIG9iamVjdCBtb2RlbCwgYW5kIERCQXMgYXJlIGZyZWUgdG8gZGVzaWduIHRoZWlyIGlkZWFsIHNjaGVtYS48L3A+Ci08cD5UaGVzZSBtYXBwaW5ncyB0cmFuc2Zvcm0gYW4gb2JqZWN0IGRhdGEgbWVtYmVyIHR5cGUgdG8gYSBjb3JyZXNwb25kaW5nIHJlbGF0aW9uYWwgZGF0YWJhc2UgZGF0YSBzb3VyY2UgcmVwcmVzZW50YXRpb24uIFRoZXNlIE9SIG1hcHBpbmdzIGNhbiBhbHNvIHRyYW5zZm9ybSBvYmplY3QgZGF0YSBtZW1iZXJzIHRoYXQgcmVmZXJlbmNlIG90aGVyIGRvbWFpbiBvYmplY3RzIHN0b3JlZCBpbiBvdGhlciB0YWJsZXMgaW4gdGhlIGRhdGFiYXNlIGFuZCBhcmUgcmVsYXRlZCB0aHJvdWdoIGZvcmVpZ24ga2V5cy48L3A+Ci08cD5Zb3UgY2FuIHVzZSB0aGVzZSBtYXBwaW5ncyB0byBtYXAgc2ltcGxlIGRhdGEgdHlwZXMgaW5jbHVkaW5nIHByaW1pdGl2ZXMgKHN1Y2ggYXMgPGNvZGU+aW50PC9jb2RlPiksIEpESyBjbGFzc2VzIChzdWNoIGFzIDxjb2RlPlN0cmluZzwvY29kZT4pLCBhbmQgbGFyZ2Ugb2JqZWN0IChMT0IpIHZhbHVlcy4gWW91IGNhbiBhbHNvIHVzZSB0aGVtIHRvIHRyYW5zZm9ybSBvYmplY3QgZGF0YSBtZW1iZXJzIHRoYXQgcmVmZXJlbmNlIG90aGVyIGRvbWFpbiBvYmplY3RzIGJ5IHdheSBvZiBhc3NvY2lhdGlvbiB3aGVyZSBkYXRhIHNvdXJjZSByZXByZXNlbnRhdGlvbnMgcmVxdWlyZSBvYmplY3QgaWRlbnRpdHkgbWFpbnRlbmFuY2UgKHN1Y2ggYXMgc2VxdWVuY2luZyBhbmQgYmFjayByZWZlcmVuY2VzKSBhbmQgcG9zc2VzcyB2YXJpb3VzIHR5cGVzIG9mIG11bHRpcGxpY2l0eSBhbmQgbmF2aWdhYmlsaXR5LiBUaGUgYXBwcm9wcmlhdGUgbWFwcGluZyBjbGFzcyBpcyBjaG9zZW4gcHJpbWFyaWx5IGJ5IHRoZSBjYXJkaW5hbGl0eSBvZiB0aGUgcmVsYXRpb25zaGlwLjwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWx0LnBuZyIgYWx0PSJSZWxhdGVkIHRhc2siIHRpdGxlPSJSZWxhdGVkIHRhc2siIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InRhc2tfbWFwcGluZy5odG0jQkFCREdCSUoiPk1hcHBpbmcgYW4gZW50aXR5PC9hPgotPHA+Jm5ic3A7PC9wPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MSIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvY29uY2VwdF9wZXJzaXN0ZW5jZS5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvY29uY2VwdF9wZXJzaXN0ZW5jZS5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQxZmM0Y2QuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2NvbmNlcHRfcGVyc2lzdGVuY2UuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNDAgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDEgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5VbmRlcnN0YW5kaW5nIEphdmEgcGVyc2lzdGVuY2U8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJVbmRlcnN0YW5kaW5nIEphdmEgcGVyc2lzdGVuY2UiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJCQUJDQUhJQyIgbmFtZT0iQkFCQ0FISUMiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MSI+Ci08aDE+VW5kZXJzdGFuZGluZyBKYXZhIHBlcnNpc3RlbmNlPC9oMT4KLTxwPjxhIGlkPSJzdGhyZWYxOCIgbmFtZT0ic3RocmVmMTgiPjwvYT48c3BhbiBjbGFzcz0iaXRhbGljIj5QZXJzaXN0ZW5jZTwvc3Bhbj4gcmVmZXJzIHRvIHRoZSBhYmlsaXR5IHRvIHN0b3JlIG9iamVjdHMgaW4gYSBkYXRhYmFzZSBhbmQgdXNlIHRob3NlIG9iamVjdHMgd2l0aCB0cmFuc2FjdGlvbmFsIGludGVncml0eS4gSW4gYSBKMkVFIGFwcGxpY2F0aW9uLCBkYXRhIGlzIHR5cGljYWxseSBzdG9yZWQgYW5kIHBlcnNpc3RlZCBpbiB0aGUgZGF0YSB0aWVyLCBpbiBhIHJlbGF0aW9uYWwgZGF0YWJhc2UuPC9wPgotPHA+PGEgaWQ9InN0aHJlZjE5IiBuYW1lPSJzdGhyZWYxOSI+PC9hPjxzcGFuIGNsYXNzPSJpdGFsaWMiPkVudGl0eSBiZWFuczwvc3Bhbj4gYXJlIGVudGVycHJpc2UgYmVhbnMgdGhhdCBjb250YWluIHBlcnNpc3RlbnQgZGF0YSBhbmQgdGhhdCBjYW4gYmUgc2F2ZWQgaW4gdmFyaW91cyBwZXJzaXN0ZW50IGRhdGEgc3RvcmVzLiBUaGUgZW50aXR5IGJlYW5zIHJlcHJlc2VudCBkYXRhIGZyb20gYSBkYXRhYmFzZTsgZWFjaCBlbnRpdHkgYmVhbiBjYXJyaWVzIGl0cyBvd24gaWRlbnRpdHkuIEVudGl0eSBiZWFucyBjYW4gYmUgZGVwbG95ZWQgdXNpbmcgPHNwYW4gY2xhc3M9Iml0YWxpYyI+YXBwbGljYXRpb24tbWFuYWdlZCBwZXJzaXN0ZW5jZTwvc3Bhbj4gb3IgPHNwYW4gY2xhc3M9Iml0YWxpYyI+Y29udGFpbmVyLW1hbmFnZWQgcGVyc2lzdGVuY2U8L3NwYW4+LjwvcD4KLTwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDEiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2NvbmNlcHRzLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9jb25jZXB0cy5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDM2NjNkNjMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2NvbmNlcHRzLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDU5ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQxIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+Q29uY2VwdHM8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSIgQ29uY2VwdHMiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJzdGhyZWYxNyIgbmFtZT0ic3RocmVmMTciPjwvYT48L3A+Ci08aDE+Q29uY2VwdHM8L2gxPgotPHA+VGhpcyBzZWN0aW9uIGNvbnRhaW5zIGFuIG92ZXJ2aWV3IG9mIGNvbmNlcHRzIHlvdSBzaG91bGQgYmUgZmFtaWxpYXIgd2l0aCB3aGVuIHVzaW5nIERhbGkgdG8gY3JlYXRlIG1hcHBpbmdzIGZvciBKYXZhIHBlcnNpc3RlbnQgZW50aXRpZXMuPC9wPgotPHVsPgotPGxpPgotPHA+PGEgaHJlZj0iY29uY2VwdF9wZXJzaXN0ZW5jZS5odG0jQkFCQ0FISUMiPlVuZGVyc3RhbmRpbmcgSmF2YSBwZXJzaXN0ZW5jZTwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0iY29uY2VwdF9tYXBwaW5nLmh0bSNCQUJCREpGSSI+VW5kZXJzdGFuZGluZyBPUiBtYXBwaW5nczwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0iY29uY2VwdHMwMDEuaHRtI0JBQkJHRkpHIj5VbmRlcnN0YW5kaW5nIEVKQiAzLjAgSmF2YSBQZXJzaXN0ZW5jZSBBUEk8L2E+PC9wPgotPC9saT4KLTwvdWw+Ci08cD5JbiBhZGRpdGlvbiB0byB0aGVzZSBzZWN0aW9ucywgeW91IHNob3VsZCByZXZpZXcgdGhlIGZvbGxvd2luZyByZXNvdXJjZXMgZm9yIGFkZGl0aW9uYWwgaW5mb3JtYXRpb246PC9wPgotPHVsPgotPGxpPgotPHA+RWNsaXBzZSBEYWxpIHByb2plY3Q6IDxjb2RlPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvd2VidG9vbHMvZGFsaSI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy93ZWJ0b29scy9kYWxpPC9hPjwvY29kZT48L3A+Ci08L2xpPgotPGxpPgotPHA+RWNsaXBzZSBXZWIgVG9vbHMgUGxhdGZvcm0gcHJvamVjdDogPGNvZGU+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy93ZWJ0b29scyI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy93ZWJ0b29sczwvYT48L2NvZGU+PC9wPgotPC9saT4KLTxsaT4KLTxwPkpTUiAyMjAgRUpCIDMuMCBzcGVjaWZpY2F0aW9uOiA8Y29kZT48YSBocmVmPSJodHRwOi8vd3d3LmpjcC5vcmcvZW4vanNyL2RldGFpbD9pZD0yMjAiPmh0dHA6Ly93d3cuamNwLm9yZy9lbi9qc3IvZGV0YWlsP2lkPTIyMDwvYT48L2NvZGU+PC9wPgotPC9saT4KLTwvdWw+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvY29uY2VwdHMwMDEuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2NvbmNlcHRzMDAxLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmE0MTE1MC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvY29uY2VwdHMwMDEuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNDIgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDEgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5VbmRlcnN0YW5kaW5nIEVKQiAzLjAgSmF2YSBQZXJzaXN0ZW5jZSBBUEk8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJVbmRlcnN0YW5kaW5nIEVKQiAzLjAgSmF2YSBQZXJzaXN0ZW5jZSBBUEkiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJCQUJCR0ZKRyIgbmFtZT0iQkFCQkdGSkciPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MSI+Ci08aDE+VW5kZXJzdGFuZGluZyBFSkIgMy4wIEphdmEgUGVyc2lzdGVuY2UgQVBJPC9oMT4KLTxwPlRoZSBKYXZhIDIgRW50ZXJwcmlzZSBFZGl0aW9uKEoyRUUpIEVudGVycHJpc2UgSmF2YUJlYW5zIChFSkIpIGFyZSBhIGNvbXBvbmVudCBhcmNoaXRlY3R1cmUgdGhhdCB5b3UgdXNlIHRvIGRldmVsb3AgYW5kIGRlcGxveSBvYmplY3Qtb3JpZW50ZWQsIGRpc3RyaWJ1dGVkLCBlbnRlcnByaXNlLXNjYWxlIGFwcGxpY2F0aW9ucy4gQW4gYXBwbGljYXRpb24gd3JpdHRlbiBhY2NvcmRpbmcgdG8gdGhlIEVudGVycHJpc2UgSmF2YUJlYW5zIGFyY2hpdGVjdHVyZSBpcyBzY2FsYWJsZSwgdHJhbnNhY3Rpb25hbCwgYW5kIHNlY3VyZS48L3A+Ci08cD5UaGUgRUpCIDMuMCBKYXZhIFBlcnNpc3RlbmNlIEFQSSAoSlBBKSBpbXByb3ZlcyB0aGUgRUpCIGFyY2hpdGVjdHVyZSBieSByZWR1Y2luZyBpdHMgY29tcGxleGl0eSB0aHJvdWdoIHRoZSB1c2Ugb2YgbWV0YWRhdGEgKGFubm90YXRpb25zKSBhbmQgc3BlY2lmeWluZyBwcm9ncmFtbWF0aWMgZGVmYXVsdHMgb2YgdGhhdCBtZXRhZGF0YS48L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrX21hcHBpbmcuaHRtI0JBQkRHQklKIj5NYXBwaW5nIGFuIGVudGl0eTwvYT4KLTxwPiZuYnNwOzwvcD4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT48L2Rpdj4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9jb25jZXB0czAwMi5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvY29uY2VwdHMwMDIuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmNDc1MTYwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9jb25jZXB0czAwMi5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw1NyArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0MSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPlRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZTwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IlRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZSIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNIREhBR0lIIiBuYW1lPSJDSERIQUdJSCI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QyIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+PGEgaWQ9InN0aHJlZjIyIiBuYW1lPSJzdGhyZWYyMiI+PC9hPlRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZTwvaDE+Ci08cD5UaGUgSlBBIHNwZWNpZmljYXRpb24gcmVxdWlyZXMgdGhlIHVzZSBvZiBhIDxjb2RlPnBlcnNpc3RlbmNlLnhtbDwvY29kZT4gZmlsZSBmb3IgZGVwbG95bWVudC4gVGhpcyBmaWxlIGRlZmluZXMgdGhlIGRhdGFiYXNlIGFuZCBlbnRpdHkgbWFuYWdlciBvcHRpb25zLCBhbmQgbWF5IGNvbnRhaW4gbW9yZSB0aGFuIG9uZSBwZXJzaXN0ZW5jZSB1bml0LiBUbyBlbmFibGUgeW91IHRvIGVhc2lseSBlZGl0IHRoaXMgaW5mb3JtYXRpb24sIERhbGkgcHJvdmlkZXMgdGhlIDxhIGhyZWY9InJlZmVyZW5jZTAxOC5odG0jQ0lBQ0NISUQiPnBlcnNpc3RlbmNlLnhtbCBFZGl0b3I8L2E+LiBBbHRlcm5hdGl2ZWx5LCB5b3UgY2FuIHVzZSB0aGUgRWNsaXBzZSBYTUwgRWRpdG9yIHRvIGNyZWF0ZSBhbmQgbWFpbnRhaW4gdGhpcyBpbmZvcm1hdGlvbi4gU2VlIDxhIGhyZWY9InRhc2tfbWFuYWdlX3BlcnNpc3RlbmNlLmh0bSNDSUhEQUpJRCI+Ik1hbmFnaW5nIHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZSI8L2E+IGZvciBtb3JlIGluZm9ybWF0aW9uLjwvcD4KLTxkaXYgYWxpZ249ImNlbnRlciI+Ci08ZGl2IGNsYXNzPSJpbmZ0Ymxub3RlYWxzbyI+PGJyIC8+Ci08dGFibGUgY2xhc3M9Ik5vdGVBbHNvIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGJvZHk+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiPgotPHAgY2xhc3M9Im5vdGVwMSI+VGlwOjwvcD4KLVRvIHdvcmsgd2l0aCBtdWx0aXBsZSBwZXJzaXN0ZW5jZSB1bml0cywgY29tbWVudCBvdXQgYWxsIGJ1dCBvbmUgcGVyc2lzdGVuY2UgdW5pdCBpbiA8Y29kZT5wZXJzaXN0ZW5jZS54bWw8L2NvZGU+LjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibG5vdGVhbHNvIiAtLT48L2Rpdj4KLTxpbWcgc3JjPSJpbWcvbmdyZWx0LnBuZyIgYWx0PSJSZWxhdGVkIHRhc2siIHRpdGxlPSJSZWxhdGVkIHRhc2siIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InRhc2tfbWFuYWdlX3BlcnNpc3RlbmNlLmh0bSNDSUhEQUpJRCI+TWFuYWdpbmcgdGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlPC9hPjxiciAvPgotPGEgaHJlZj0idGFza19jcmVhdGVfbmV3X3Byb2plY3QuaHRtI0NJSEhFSkNKIj5DcmVhdGluZyBhIG5ldyBKUEEgcHJvamVjdDwvYT4KLTxwPiZuYnNwOzwvcD4KLTwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDIiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2NvbmNlcHRzMDAzLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9jb25jZXB0czAwMy5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQzZmZmOWEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2NvbmNlcHRzMDAzLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDcyICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQyIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+VGhlIG9ybS54bWwgZmlsZTwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IlRoZSBvcm0ueG1sIGZpbGUiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJDSERCSUpBQyIgbmFtZT0iQ0hEQklKQUMiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MiI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPjxhIGlkPSJzdGhyZWYyMyIgbmFtZT0ic3RocmVmMjMiPjwvYT5UaGUgb3JtLnhtbCBmaWxlPC9oMT4KLTxwPkFsdGhvdWdoIHRoZSBKUEEgc3BlY2lmaWNhdGlvbiBlbXBoYXNpemVzIHRoZSB1c2Ugb2YgYW5ub3RhdGlvbnMgdG8gc3BlY2lmeSBwZXJzaXN0ZW5jZSwgeW91IGNhbiBhbHNvIHVzZSB0aGUgPGNvZGU+b3JtLnhtbDwvY29kZT4gZmlsZSB0byBzdG9yZSB0aGlzIG1ldGFkYXRhLiBEYWxpIGVuYWJsZXMgeW91IHRvIGNyZWF0ZSBhIHN0dWIgPGNvZGU+b3JtLnhtbDwvY29kZT4gZmlsZSBmb3IgYSBKUEEgcHJvamVjdCB1c2luZyB0aGUgPGEgaHJlZj0icmVmZXJlbmNlMDA1Lmh0bSNDSUFJSkNDRSI+TWFwcGluZyBGaWxlIFdpemFyZDwvYT4uIFNlZSA8YSBocmVmPSJ0YXNrX21hbmFnZV9vcm0uaHRtI0NJSERHRENEIj4iTWFuYWdpbmcgdGhlIG9ybS54bWwgZmlsZSI8L2E+IGZvciBtb3JlIGluZm9ybWF0aW9uLjwvcD4KLTxkaXYgYWxpZ249ImNlbnRlciI+Ci08ZGl2IGNsYXNzPSJpbmZ0Ymxub3RlIj48YnIgLz4KLTx0YWJsZSBjbGFzcz0iTm90ZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRib2R5PgotPHRyPgotPHRkIGFsaWduPSJsZWZ0Ij4KLTxwIGNsYXNzPSJub3RlcDEiPk5vdGU6PC9wPgotVGhlIG1ldGFkYXRhIG11c3QgbWF0Y2ggdGhlIFhTRCBzcGVjaWZpY2F0aW9uIG9mIHlvdXIgc2VsZWN0ZWQgSlBBIGltcGxlbWVudGF0aW9uLjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibG5vdGUiIC0tPjwvZGl2PgotPHA+RGFsaSBwcm92aWRlcyBjb21wcmVoZW5zaXZlIHN1cHBvcnQgZm9yIGNvbmZpZ3VyaW5nIFhNTCBtYXBwaW5nIGZpbGVzIHRocm91Z2ggdGhlIDxhIGhyZWY9InJlZl9kZXRhaWxzX29ybS5odG0jQ0FDR0RHSEMiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBvcm0ueG1sKTwvYT4gdGhhdCBpcyBuZWFybHkgaWRlbnRpY2FsIHRvIHRoZSBhbm5vdGF0aW9uLWJhc2VkIGNvbmZpZ3VyYXRpb24gaW4gdGhlIEphdmEgc291cmNlLiBBbHRlcm5hdGl2ZWx5LCB5b3UgY2FuIGFsc28gdXNlIHRoZSBFY2xpcHNlIFhNTCBFZGl0b3IgdG8gY3JlYXRlIGFuZCBtYWludGFpbiB0aGUgbWV0YWRhdGEgaW5mb3JtYXRpb24gaW4gPGNvZGU+b3JtLnhtbDwvY29kZT4uPC9wPgotPGRpdiBhbGlnbj0iY2VudGVyIj4KLTxkaXYgY2xhc3M9ImluZnRibG5vdGUiPjxiciAvPgotPHRhYmxlIGNsYXNzPSJOb3RlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGJvZHk+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiPgotPHAgY2xhc3M9Im5vdGVwMSI+Tm90ZTo8L3A+Ci1EYWxpIHdvcmtzIGV4Y2x1c2l2ZWx5IHdpdGggWE1MIG1hcHBpbmcgZmlsZXMgbmFtZWQgPGNvZGU+b3JtLnhtbDwvY29kZT4uPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJsbm90ZSIgLS0+PC9kaXY+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrX21hbmFnZV9vcm0uaHRtI0NJSERHRENEIj5NYW5hZ2luZyB0aGUgb3JtLnhtbCBmaWxlPC9hPjxiciAvPgotPGEgaHJlZj0idGFza19jcmVhdGVfbmV3X3Byb2plY3QuaHRtI0NJSEhFSkNKIj5DcmVhdGluZyBhIG5ldyBKUEEgcHJvamVjdDwvYT48YnIgLz4KLTxwPiZuYnNwOzwvcD4KLTwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDIiIC0tPgotPCEtLSBjbGFzcz0ic2VjdDEiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2NvbnRleHRzLnhtbCBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9jb250ZXh0cy54bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDM0ZGUwZWYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2NvbnRleHRzLnhtbAorKysgL2Rldi9udWxsCkBAIC0xLDQyMiArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPD9OTFMgVFlQRT0ib3JnLmVjbGlwc2UuaGVscC5jb250ZXh0cyI/PgotPGNvbnRleHRzPgotCTxjb250ZXh0IGlkPSJlbnRpdHlfYWNjZXNzVHlwZSI+Ci0JCTxkZXNjcmlwdGlvbj5TcGVjaWZ5IGhvdyB0aGUgdmFyaWFibGUgaXMgYWNjZXNzZWQ6IFByb3BlcnR5IChkZWZhdWx0KSBvciBGaWVsZC48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IkFkZGluZyBwZXJzaXN0ZW5jZSB0byBhIGNsYXNzIiBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJVbmRlcnN0YW5kaW5nIHBlcnNpc3RlbmNlIiBocmVmPSJjb25jZXB0X3BlcnNpc3RlbmNlLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0iZW50aXR5X25hbWUiPgotCQk8ZGVzY3JpcHRpb24+VGhlIG5hbWUgb2YgdGhpcyBlbnRpdHkuIEJ5IGRlZmF1bHQsIHRoZSBjbGFzcyBuYW1lIGlzIHVzZWQgYXMgdGhlIGVudGl0eSBuYW1lLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wcm9wX3ZpZXcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iQWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3MiIGhyZWY9InRhc2tfYWRkX3BlcnNpc3RlbmNlLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IlVuZGVyc3RhbmRpbmcgcGVyc2lzdGVuY2UiIGhyZWY9ImNvbmNlcHRfcGVyc2lzdGVuY2UuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJlbnRpdHlfdGFibGUiPgotCQk8ZGVzY3JpcHRpb24+VGhlIGRhdGFiYXNlIHRhYmxlIGFzc2lnbmVkIHRvIHRoaXMgZW50aXR5LiBCeSBkZWZhdWx0LCB0aGUgY2xhc3MgbmFtZSBpcyB1c2VkIGFzIHRoZSBkYXRhYmFzZSB0YWJsZSBuYW1lLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wcm9wX3ZpZXcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iQWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3MiIGhyZWY9InRhc2tfYWRkX3BlcnNpc3RlbmNlLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IkFkZGluZyBwZXJzaXN0ZW5jZSB0byBhIGNsYXNzIiBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJVbmRlcnN0YW5kaW5nIHBlcnNpc3RlbmNlIiBocmVmPSJjb25jZXB0X3BlcnNpc3RlbmNlLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0iZW50aXR5X2F0dHJpYnV0ZU92ZXJyaWRlcyI+Ci0JCTxkZXNjcmlwdGlvbj5TcGVjaWZ5IGEgcHJvcGVydHkgb3IgZmllbGQgdG8gYmUgb3ZlcnJpZGRlbiAoZnJvbSB0aGUgZGVmYXVsdCBtYXBwaW5ncykuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3Byb3Bfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJBZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBjbGFzcyIgaHJlZj0idGFza19hZGRfcGVyc2lzdGVuY2UuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iVW5kZXJzdGFuZGluZyBwZXJzaXN0ZW5jZSIgaHJlZj0iY29uY2VwdF9wZXJzaXN0ZW5jZS5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9ImVudGl0eV9hdHRyaWJ1dGVPdmVycmlkZXNOYW1lIj4KLQkJPGRlc2NyaXB0aW9uPk5hbWUgb2YgdGhlIGRhdGFiYXNlIGNvbHVtbi48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IkFkZGluZyBwZXJzaXN0ZW5jZSB0byBhIGNsYXNzIiBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJVbmRlcnN0YW5kaW5nIHBlcnNpc3RlbmNlIiBocmVmPSJjb25jZXB0X3BlcnNpc3RlbmNlLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0iZW50aXR5X2F0dHJpYnV0ZU92ZXJyaWRlc0NvbHVtbiI+Ci0JCTxkZXNjcmlwdGlvbj5UaGUgZGF0YWJhc2UgY29sdW1uIHRoYXQgb3ZlcnJpZGVzIGEgcHJvcGVydHkgb3IgZmllbGQuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3Byb3Bfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJBZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBjbGFzcyIgaHJlZj0idGFza19hZGRfcGVyc2lzdGVuY2UuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iVW5kZXJzdGFuZGluZyBwZXJzaXN0ZW5jZSIgaHJlZj0iY29uY2VwdF9wZXJzaXN0ZW5jZS5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9ImVudGl0eV9hdHRyaWJ1dGVPdmVycmlkZXNJbnNlcnRhYmxlIj4KLQkJPGRlc2NyaXB0aW9uPlNwZWNpZmllcyBpZiB0aGUgY29sdW1uIGlzIGFsd2F5cyBpbmNsdWRlZCBpbiBTUUwgSU5TRVJUIHN0YXRlbWVudHMuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3Byb3Bfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJBZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBjbGFzcyIgaHJlZj0idGFza19hZGRfcGVyc2lzdGVuY2UuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iVW5kZXJzdGFuZGluZyBwZXJzaXN0ZW5jZSIgaHJlZj0iY29uY2VwdF9wZXJzaXN0ZW5jZS5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9ImVudGl0eV9hdHRyaWJ1dGVPdmVycmlkZXNVcGRhdGFibGUiPgotCQk8ZGVzY3JpcHRpb24+U3BlY2lmaWVzIGlmIHRoZSBjb2x1bW4gaXMgYWx3YXlzIGluY2x1ZGVkIGluIFNRTCBVUERBVEUgc3RhdGVtZW50cy48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IkFkZGluZyBwZXJzaXN0ZW5jZSB0byBhIGNsYXNzIiBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJVbmRlcnN0YW5kaW5nIHBlcnNpc3RlbmNlIiBocmVmPSJjb25jZXB0X3BlcnNpc3RlbmNlLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0ibWFwcGluZ19tYXBBcyI+Ci0JCTxkZXNjcmlwdGlvbj5TcGVjaWZ5IGhvdyB0aGlzIGF0dHJpYnV0ZSBtYXBzIHRvIHRoZSBkYXRhYmFzZS48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iTWFwcGluZyBhbiBlbnRpdHkiIGhyZWY9InRhc2tfbWFwcGluZy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJVbmRlcnN0YW5kaW5nIE9SIG1hcHBpbmdzIiBocmVmPSJjb25jZXB0X21hcHBpbmcuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJtYXBwaW5nX2NvbHVtbiI+Ci0JCTxkZXNjcmlwdGlvbj5UaGUgZGF0YWJhc2UgY29sdW1uIHRoYXQgY29udGFpbnMgdGhlIHZhbHVlIGZvciB0aGUgYXR0cmlidXRlLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJNYXBwaW5nIGFuIGVudGl0eSIgaHJlZj0idGFza19tYXBwaW5nLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IlVuZGVyc3RhbmRpbmcgT1IgbWFwcGluZ3MiIGhyZWY9ImNvbmNlcHRfbWFwcGluZy5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9Im1hcHBpbmdfY29sdW1uVGFibGUiPgotCQk8ZGVzY3JpcHRpb24+TmFtZSBvZiB0aGUgZGF0YWJhc2UgdGFibGUgdGhhdCBjb250YWlucyB0aGUgc2VsZWN0ZWQgY29sdW1uLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJNYXBwaW5nIGFuIGVudGl0eSIgaHJlZj0idGFza19tYXBwaW5nLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IlVuZGVyc3RhbmRpbmcgT1IgbWFwcGluZ3MiIGhyZWY9ImNvbmNlcHRfbWFwcGluZy5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9Im1hcHBpbmdfY29sdW1uSW5zZXJ0YWJsZSI+Ci0JCTxkZXNjcmlwdGlvbj5TcGVjaWZpZXMgaWYgdGhlIGNvbHVtbiBpcyBhbHdheXMgaW5jbHVkZWQgaW4gU1FMIElOU0VSVCBzdGF0ZW1lbnRzLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJNYXBwaW5nIGFuIGVudGl0eSIgaHJlZj0idGFza19tYXBwaW5nLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IlVuZGVyc3RhbmRpbmcgT1IgbWFwcGluZ3MiIGhyZWY9ImNvbmNlcHRfbWFwcGluZy5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9Im1hcHBpbmdfY29sdW1uVXBkYXRhYmxlIj4KLQkJPGRlc2NyaXB0aW9uPlNwZWNpZmllcyBpZiB0aGUgY29sdW1uIGlzIGFsd2F5cyBpbmNsdWRlZCBpbiBTUUwgVVBEQVRFIHN0YXRlbWVudHMuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9Ik1hcHBpbmcgYW4gZW50aXR5IiBocmVmPSJ0YXNrX21hcHBpbmcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iVW5kZXJzdGFuZGluZyBPUiBtYXBwaW5ncyIgaHJlZj0iY29uY2VwdF9tYXBwaW5nLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0ibWFwcGluZ19mZXRjaFR5cGUiPgotCQk8ZGVzY3JpcHRpb24+RGVmaW5lcyBob3cgZGF0YSBpcyBsb2FkZWQgZnJvbSB0aGUgZGF0YWJhc2U6IEVhZ2VyIChkZWZhdWx0KSBvciBMYXp5PC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9Ik1hcHBpbmcgYW4gZW50aXR5IiBocmVmPSJ0YXNrX21hcHBpbmcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iVW5kZXJzdGFuZGluZyBPUiBtYXBwaW5ncyIgaHJlZj0iY29uY2VwdF9tYXBwaW5nLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0ibWFwcGluZ19vcHRpb25hbCI+Ci0JCTxkZXNjcmlwdGlvbj5TcGVjaWZpZXMgaWYgdGhpcyBmaWVsZCBpcyBjYW4gYmUgbnVsbC48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iTWFwcGluZyBhbiBlbnRpdHkiIGhyZWY9InRhc2tfbWFwcGluZy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJVbmRlcnN0YW5kaW5nIE9SIG1hcHBpbmdzIiBocmVmPSJjb25jZXB0X21hcHBpbmcuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJtYXBwaW5nX2dlbmVyYXRlZFZhbHVlU3RyYXRlZ3kiPgotCQk8ZGVzY3JpcHRpb24+RGV0ZXJtaW5lcyBob3cgdGhlIHByaW1hcnkga2V5IGlzIGdlbmVyYXRlZDogQXV0byAoZGVmYXVsdCksIFNlcXVlbmNlLCBJZGVudGl0eSwgb3IgVGFibGUuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9Ik1hcHBpbmcgYW4gZW50aXR5IiBocmVmPSJ0YXNrX21hcHBpbmcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iVW5kZXJzdGFuZGluZyBPUiBtYXBwaW5ncyIgaHJlZj0iY29uY2VwdF9tYXBwaW5nLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0ibWFwcGluZ19nZW5lcmF0ZWRWYWx1ZUdlbmVyYXRvck5hbWUiPgotCQk8ZGVzY3JpcHRpb24+VW5pcXVlIG5hbWUgb2YgdGhlIGdlbmVyYXRvci48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iTWFwcGluZyBhbiBlbnRpdHkiIGhyZWY9InRhc2tfbWFwcGluZy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJVbmRlcnN0YW5kaW5nIE9SIG1hcHBpbmdzIiBocmVmPSJjb25jZXB0X21hcHBpbmcuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJtYXBwaW5nX3RhcmdldEVudGl0eSI+Ci0JCTxkZXNjcmlwdGlvbj5UaGUgZW50aXR5IHRvIHdoaWNoIHRoaXMgYXR0cmlidXRlIGlzIG1hcHBlZC4gPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9Ik1hcHBpbmcgYW4gZW50aXR5IiBocmVmPSJ0YXNrX21hcHBpbmcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iVW5kZXJzdGFuZGluZyBPUiBtYXBwaW5ncyIgaHJlZj0iY29uY2VwdF9tYXBwaW5nLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0ibWFwcGluZ19jYXNjYWRlVHlwZSI+Ci0JCTxkZXNjcmlwdGlvbj5TcGVjaWZ5IHdoaWNoIG9wZXJhdGlvbnMgYXJlIHByb3BhZ2F0ZWQgdGhyb3VnaG91dCB0aGUgZW50aXR5OiBBbGwsIFBlcnNpc3QsIE1lcmdlLCBvciBNb3ZlLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJNYXBwaW5nIGFuIGVudGl0eSIgaHJlZj0idGFza19tYXBwaW5nLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IlVuZGVyc3RhbmRpbmcgT1IgbWFwcGluZ3MiIGhyZWY9ImNvbmNlcHRfbWFwcGluZy5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9Im1hcHBpbmdfbWFwcGVkQnkiPgotCQk8ZGVzY3JpcHRpb24+VGhlIGZpZWxkIGluIHRoZSBkYXRhYmFzZSB0YWJsZSB0aGF0IG93bnMgdGhlIHJlbGF0aW9uc2hpcC48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iTWFwcGluZyBhbiBlbnRpdHkiIGhyZWY9InRhc2tfbWFwcGluZy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJVbmRlcnN0YW5kaW5nIE9SIG1hcHBpbmdzIiBocmVmPSJjb25jZXB0X21hcHBpbmcuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJtYXBwaW5nX2pvaW5Db2x1bW5OYW1lIj4KLQkJPGRlc2NyaXB0aW9uPlRoZSBuYW1lIG9mIHRoZSBkYXRhYmFzZSBjb2x1bW4gdGhhdCBjb250YWlucyB0aGUgZm9yZWlnbiBrZXkgcmVmZXJlbmNlIGZvciB0aGUgZW50aXR5IGFzc29jaWF0aW9uLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJNYXBwaW5nIGFuIGVudGl0eSIgaHJlZj0idGFza19tYXBwaW5nLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IlVuZGVyc3RhbmRpbmcgT1IgbWFwcGluZ3MiIGhyZWY9ImNvbmNlcHRfbWFwcGluZy5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9Im1hcHBpbmdfam9pblJlZmVyZW5jZWRDb2x1bW4iPgotCQk8ZGVzY3JpcHRpb24+TmFtZSBvZiB0aGUgam9pbiB0YWJsZSB0aGF0IGNvbnRhaW5zIHRoZSBmb3JlaWduIGtleSBjb2x1bW4uPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9Ik1hcHBpbmcgYW4gZW50aXR5IiBocmVmPSJ0YXNrX21hcHBpbmcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iVW5kZXJzdGFuZGluZyBPUiBtYXBwaW5ncyIgaHJlZj0iY29uY2VwdF9tYXBwaW5nLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0ibWFwcGluZ19lbWJlZGRlZEF0dHJpYnV0ZU92ZXJyaWRlcyI+Ci0JCTxkZXNjcmlwdGlvbj5TcGVjaWZ5IHRvIG92ZXJyaWRlIHRoZSBkZWZhdWx0ICBtYXBwaW5nIG9mIGFuIGVudGl0eeKAmXMgYXR0cmlidXRlLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJNYXBwaW5nIGFuIGVudGl0eSIgaHJlZj0idGFza19tYXBwaW5nLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IlVuZGVyc3RhbmRpbmcgT1IgbWFwcGluZ3MiIGhyZWY9ImNvbmNlcHRfbWFwcGluZy5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9Im1hcHBpbmdfZW1iZWRkZWRBdHRyaWJ1dGVPdmVycmlkZXNDb2x1bW4iPgotCQk8ZGVzY3JpcHRpb24+VGhlIGRhdGFiYXNlIGNvbHVtbiB0aGF0IGlzIGJlaW5nIG1hcHBlZCB0byB0aGUgZW50aXR54oCZcyBhdHRyaWJ1dGUuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9Ik1hcHBpbmcgYW4gZW50aXR5IiBocmVmPSJ0YXNrX21hcHBpbmcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iVW5kZXJzdGFuZGluZyBPUiBtYXBwaW5ncyIgaHJlZj0iY29uY2VwdF9tYXBwaW5nLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0iZW50aXR5X21hcEFzIj4KLQkJPGRlc2NyaXB0aW9uPlNwZWNpZnkgdGhlIHR5cGUgb2YgcGVyc2lzdGVudCBkb21haW4gb2JqZWN0IGZvciB0aGUgSmF2YSBjbGFzczogUGVyc2lzdGVudCwgRW1iZWRkZWQsIG9yIE1hcHBlZCBTdXBlcmNsYXNzLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iQWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3MiIGhyZWY9InRhc2tfYWRkX3BlcnNpc3RlbmNlLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IlVuZGVyc3RhbmRpbmcgcGVyc2lzdGVuY2UiIGhyZWY9ImNvbmNlcHRfcGVyc2lzdGVuY2UuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJlbnRpdHlfaW5oZXJpdGFuY2VTdHJhdGVneSI+Ci0JCTxkZXNjcmlwdGlvbj5TcGVjaWZ5IGhvdyBhbiBlbnRpdHkgbWF5IGluaGVyaXQgcHJvcGVydGllcyBmcm9tIG90aGVyIGVudGl0aWVzOiBTaW5nbGUgdGFibGUsIE9uZSB0YWJsZSBwZXIgY2xhc3MsIG9yIEpvaW5lZCB0YWJsZXMuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJTcGVjaWZ5aW5nIGluaGVyaXRhbmNlIiBocmVmPSJ0YXNrX2luaGVyaXRhbmNlLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0iZW50aXR5X2luaGVyaXRhbmNlRGlzY3JpbWluYXRvckNvbHVtbiI+Ci0JCTxkZXNjcmlwdGlvbj5Vc2UgdG8gc3BlY2lmeSB0aGUgbmFtZSBvZiB0aGUgZGlzY3JpbWluYXRvciBjb2x1bW4gd2hlbiB1c2luZyBhIFNpbmdsZSBvciBKb2luZWQgaW5oZXJpdGFuY2Ugc3RyYXRlZ3kuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJTcGVjaWZ5aW5nIGluaGVyaXRhbmNlIiBocmVmPSJ0YXNrX2luaGVyaXRhbmNlLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0iZW50aXR5X2luaGVyaXRhbmNlRGlzY3JpbWluYXRvclR5cGUiPgotCQk8ZGVzY3JpcHRpb24+VXNlIHRoaXMgZmllbGQgdG8gc2V0IHRoZSBkaXNjcmltaW5hdG9yIHR5cGUgdG8gQ0hBUiBvciBJTlRFR0VSIChpbnN0ZWFkIG9mIGl0cyBkZWZhdWx0OiBTdHJpbmcpLiBUaGUgZGlzY3JpbWluYXRvciB2YWx1ZSBtdXN0IGNvbmZvcm0gdG8gdGhpcyB0eXBlLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iU3BlY2lmeWluZyBpbmhlcml0YW5jZSIgaHJlZj0idGFza19pbmhlcml0YW5jZS5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3Byb3Bfdmlldy5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9ImVudGl0eV9pbmhlcml0YW5jZURpc2NyaW1pbmF0b3JWYWx1ZSI+Ci0JCTxkZXNjcmlwdGlvbj5TcGVjaWZ5IHRoZSBkaXNjcmltaW5hdG9yIHZhbHVlIHVzZWQgdG8gZGlmZmVyZW50aWF0ZSBhbiBlbnRpdHkgaW4gdGhpcyBpbmhlcml0YW5jZSBoaWVyYXJjaHkuIFRoZSB2YWx1ZSBtdXN0IGNvbmZvcm0gdG8gdGhlIHNwZWNpZmllZCBkaXNjcmltaW5hdG9yIHR5cGUuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJTcGVjaWZ5aW5nIGluaGVyaXRhbmNlIiBocmVmPSJ0YXNrX2luaGVyaXRhbmNlLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0ibWFwcGluZ19vcmRlckJ5Ij4KLQkJPGRlc2NyaXB0aW9uPlNwZWNpZnkgdGhlIGRlZmF1bHQgb3JkZXIgZm9yIG9iamVjdHMgcmV0dXJuZWQgZnJvbSBhIHF1ZXJ5LjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wcm9wX3ZpZXcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iTWFwcGluZyBhbiBFbnRpdHkiIGhyZWY9InRhc2tfbWFwcGluZy5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9Im1hcHBpbmdfam9pblRhYmxlTmFtZSI+Ci0JCTxkZXNjcmlwdGlvbj5TcGVjaWZ5IHRoZSAgbmFtZSBvZiB0aGUgZGF0YWJhc2UgdGFibGUgdGhhdCBkZWZpbmVzIHRoZSBmb3JlaWduIGtleSBmb3IgYSBtYW55LXRvLW1hbnkgb3IgYSB1bmlkaXJlY3Rpb25hbCBvbmUtdG8tbWFueSBhc3NvY2lhdGlvbi4gWW91IGNhbiBjb25maWd1cmUgdGhlIGpvaW4gdGFibGUgd2l0aCBhIHNwZWNpZmljIGNhdGFsb2cgb3Igc2NoZW1hLCBjb25maWd1cmUgb25lIG9yIG1vcmUgam9pbiB0YWJsZSBjb2x1bW5zIHdpdGggYSB1bmlxdWUgY29uc3RyYWludCwgYW5kIHVzZSBtdWx0aXBsZSBqb2luIGNvbHVtbnMgcGVyIGVudGl0eS48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9Ik1hcHBpbmcgYW4gZW50aXR5IiBocmVmPSJ0YXNrX21hcHBpbmcuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJtYXBwaW5nX2pvaW5UYWJsZUpvaW5Db2x1bW5zIj4KLQkJPGRlc2NyaXB0aW9uPlNwZWNpZnkgIHR3byBvciBtb3JlIGpvaW4gY29sdW1ucyAodGhhdCBpcywgYSBjb21wb3NpdGUgcHJpbWFyeSBrZXkpLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wcm9wX3ZpZXcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iTWFwcGluZyBhbiBlbnRpdHkiIGhyZWY9InRhc2tfbWFwcGluZy5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9Im1hcHBpbmdfam9pblRhYmxlSW52ZXJzZUpvaW5Db2x1bW5zIj4KLQkJPGRlc2NyaXB0aW9uPlNwZWNpZnkgdGhlIGpvaW4gY29sdW1uIG9uIHRoZSBvd25lZCAob3IgaW52ZXJzZSBzaWRlKSBvZiB0aGUgYXNzb2NpYXRpb246IHRoZSBvd25lZCBlbnRpdHkncyBwcmltYXJ5IGtleSBjb2x1bW4uIDwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wcm9wX3ZpZXcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iTWFwcGluZyBhbiBlbnRpdHkiIGhyZWY9InRhc2tfbWFwcGluZy5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9InByb3BlcnRpZXNfamF2YVBlcnNpc3RlbmNlIj4KLQkJPGRlc2NyaXB0aW9uPlVzZSB0aGUgSmF2YSBQZXJzaXN0ZW5jZSBvcHRpb25zIG9uIHRoZSBQcm9wZXJ0aWVzIHBhZ2UgdG8gc2VsZWN0IHRoZSBkYXRhYmFzZSBjb25uZWN0aW9uIHRvIHVzZSB3aXRoIHRoZSBwcm9qZWN0LjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iUHJvamVjdCBwcm9wZXJ0aWVzIiBocmVmPSJyZWZfcHJvamVjdF9wcm9wZXJ0aWVzIi8+Ci0JCTx0b3BpYyBsYWJlbD0iQWRkaW5nIHBlcnNpc3RlbmNlIiBocmVmPSJyZWZfYWRkX3BlcnNpc3RlbmNlLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IlVuZGVyc3RhbmRpbmcgcGVyc2lzdGVuY2UiIGhyZWY9ImNvbmNlcHRfcGVyc2lzdGVuY2UuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJwcm9wZXJ0aWVzX2phdmFQZXJzaXN0ZW5jZUNvbm5lY3Rpb24iPgotCQk8ZGVzY3JpcHRpb24+VGhlIGRhdGFiYXNlIGNvbm5lY3Rpb24gdXNlZCB0byBtYXAgdGhlIHBlcnNpc3RlbnQgZW50aXRpZXMuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJQcm9qZWN0IHByb3BlcnRpZXMiIGhyZWY9InJlZl9wcm9qZWN0X3Byb3BlcnRpZXMiLz4KLQkJPHRvcGljIGxhYmVsPSJVbmRlcnN0YW5kaW5nIHBlcnNpc3RlbmNlIiBocmVmPSJjb25jZXB0X3BlcnNpc3RlbmNlLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0icHJvcGVydGllc19qYXZhUGVyc2lzdGVuY2VTY2hlbWEiPgotCQk8ZGVzY3JpcHRpb24+VGhlIGRhdGFiYXNlIHNjaGVtYSB1c2VkIHRvIG1hcCB0aGUgcGVyc2lzdGVudCBlbnRpdGllcy48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IlByb2plY3QgcHJvcGVydGllcyIgaHJlZj0icmVmX3Byb2plY3RfcHJvcGVydGllcyIvPgotCQk8dG9waWMgbGFiZWw9IlVuZGVyc3RhbmRpbmcgcGVyc2lzdGVuY2UiIGhyZWY9ImNvbmNlcHRfcGVyc2lzdGVuY2UuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJkaWFsb2dfYWRkUGVyc2lzdGVuY2UiPgotCQk8ZGVzY3JpcHRpb24+VXNlIHRoZSBBZGQgUGVyc2lzdGVuY2UgZGlhbG9nIHRvIGRlZmluZSB0aGUgZGF0YWJhc2UgY29ubmVjdGlvbiB1c2UgdG8gc3RvcmUgdGhlIHBlcnNpc3RlbmNlIGVudGl0aWVzLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iQWRkaW5nIHBlcnNpc3RlbmNlIiBocmVmPSJyZWZfYWRkX3BlcnNpc3RlbmNlLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IlVuZGVyc3RhbmRpbmcgcGVyc2lzdGVuY2UiIGhyZWY9ImNvbmNlcHRfcGVyc2lzdGVuY2UuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJwZXJzaXN0ZW5jZU91dGxpbmUiPgotCQk8ZGVzY3JpcHRpb24+VGhlIEpQQSBTdHJ1Y3R1cmUgdmlldyBkaXNwbGF5cyBhbiBvdXRsaW5lIG9mIHRoZSBzdHJ1Y3R1cmUgKGl0cyBhdHRyaWJ1dGVzIGFuZCBtYXBwaW5ncykgb2YgdGhlIGVudGl0eSB0aGF0IGlzIGN1cnJlbnRseSBzZWxlY3RlZCBvciBvcGVuZWQgaW4gdGhlIGVkaXRvci48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IkpQQSBTdHJ1Y3R1cmUgdmlldyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX291dGxpbmUuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iTWFwcGluZyBhbiBlbnRpdHkiIGhyZWY9InRhc2tfbWFwcGluZy5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9ImRpYWxvZ19nZW5lcmF0ZUVudGl0aWVzIj4KLQkJPGRlc2NyaXB0aW9uPlVzZSB0aGUgR2VuZXJhdGUgRW50aXRpZXMgZGlhbG9nIHRvIGNyZWF0ZSBKYXZhIHBlcnNpc3RlbnQgZW50aXRpZXMgYmFzZWQgb24geW91ciBkYXRhYmFzZSB0YWJsZXMuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJHZW5lcmF0aW5nIGVudGl0aWVzIGZyb20gdGFibGVzIiBocmVmPSJ0YXNrX2dlbmVyYXRlX2VudGl0aWVzLmh0bS5odG0iIC8+Ci0JCTx0b3BpYyBsYWJlbD0iUHJvamVjdCBwcm9wZXJ0aWVzIiBocmVmPSJyZWZfcHJvamVjdF9wcm9wZXJ0aWVzIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJkaWFsb2dfZ2VuZXJhdGVFbnRpdGllc19zb3VyY2UiPgotCQk8ZGVzY3JpcHRpb24+VGhlIHByb2plY3QgZm9sZGVyIG5hbWUgaW4gd2hpY2ggdG8gZ2VuZXJhdGUgdGhlIEphdmEgcGVyc2lzdGVudCBlbnRpdGllcy4gQ2xpY2sgQnJvd3NlIHRvIHNlbGVjdCBhbiBleGlzdGluZyBmb2xkZXIuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJHZW5lcmF0aW5nIGVudGl0aWVzIGZyb20gdGFibGVzIiBocmVmPSJ0YXNrX2dlbmVyYXRlX2VudGl0aWVzLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0iZGlhbG9nX2dlbmVyYXRlRW50aXRpZXNfcGFja2FnZSI+Ci0JCTxkZXNjcmlwdGlvbj5UaGUgcGFja2FnZSBpbiB3aGljaCB0byBnZW5lcmF0ZSB0aGUgSmF2YSBwZXJzaXN0ZW50IGVudGl0aWVzLCBvciBjbGljayBCcm93c2UgdG8gc2VsZWN0IGFuIGV4aXN0aW5nIHBhY2thZ2UuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJHZW5lcmF0aW5nIGVudGl0aWVzIGZyb20gdGFibGVzIiBocmVmPSJ0YXNrX2dlbmVyYXRlX2VudGl0aWVzLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0iZGlhbG9nX2dlbmVyYXRlRW50aXRpZXNfdGFibGVzIj4KLQkJPGRlc2NyaXB0aW9uPlNlbGVjdCB0aGUgdGFibGVzIGZyb20gd2hpY2ggdG8gY3JlYXRlIEphdmEgcGVyc2lzdGVudCBlbnRpdGllcy48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IkdlbmVyYXRpbmcgZW50aXRpZXMgZnJvbSB0YWJsZXMiIGhyZWY9InRhc2tfZ2VuZXJhdGVfZW50aXRpZXMuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iUHJvamVjdCBwcm9wZXJ0aWVzIiBocmVmPSJyZWZfcHJvamVjdF9wcm9wZXJ0aWVzIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJkaWFsb2dfYWRkSmF2YVBlcnNpc3RlbmNlIj4KLQkJPGRlc2NyaXB0aW9uPlVzZSB0aGlzIGRpYWxvZyB0byBkZWZpbmUgdGhlIGRhdGFiYXNlIGNvbm5lY3Rpb24gdXNlZCB0byBzdG9yZSB0aGUgcGVyc2lzdGVuY2UgZW50aXRpZXMgYW5kIHRvIGNyZWF0ZSB0aGUgcGVyc2lzdGVuY2UueG1sIGZpbGUuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJBZGQgUGVyc2lzdGVuY2UgZGlhbG9nIiBocmVmPSJyZWZfYWRkX3BlcnNpc3RlbmNlLmh0bSIgLz4KLQkJPHRvcGljIGxhYmVsPSJBZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBwcm9qZWN0IiBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZSIgLz4KLQkJPHRvcGljIGxhYmVsPSJNYW5hZ2luZyB0aGUgcGVyc2lzdGVuY2UueG1sIGZpbGUiIGhyZWY9InRhc2tfbWFuYWdlX3BlcnNpc3RlbmNlLmh0bSIgLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9ImRpYWxvZ19uZXdKUEFQcm9qZWN0Ij4KLQkJPGRlc2NyaXB0aW9uPlVzZSB0aGlzIGRpYWxvZyB0byBkZWZpbmUgdGhlIG5ldyBKUEEgcHJvamVjdCBuYW1lLCBpdHMgbG9jYXRpb24sIHRhcmdldCBydW50aW1lLCBhbmQgb3RoZXIgY29uZmlndXJhdGlvbiBzZXR0aW5ncy48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9Ik5ldyBKUEEgUHJvamVjdCBwYWdlIiBocmVmPSJyZWZfbmV3X2pwYV9wcm9qZWN0Lmh0bSIgLz4KLQkJPHRvcGljIGxhYmVsPSJOZXcgSlBBIFByb2plY3Qgd2l6YXJkIiBocmVmPSJyZWZfbmV3X2pwYV9wcm9qZWN0X3dpemFyZCIgLz4KLQkJPHRvcGljIGxhYmVsPSJBZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBwcm9qZWN0IiBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZSIgLz4KLQkJPHRvcGljIGxhYmVsPSJDcmVhdGluZyBhIG5ldyBKUEEgcHJvamVjdCIgaHJlZj0idGFza19jcmVhdGVfbmV3X3Byb2plY3QuaHRtIiAvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0iZGlhbG9nX2FkZEphdmFQZXJzaXN0ZW5jZV9kYXRhYmFzZSI+Ci0JCTxkZXNjcmlwdGlvbj5Vc2UgdGhlc2UgZmllbGRzIHRvIGRlZmluZSB0aGUgZGF0YWJhc2UgY29ubmVjdGlvbiB1c2VkIHRvIHN0b3JlIHRoZSBwZXJzaXN0ZW50IGVudGl0aWVzLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iQWRkIFBlcnNpc3RlbmNlIGRpYWxvZyIgaHJlZj0icmVmX2FkZF9wZXJzaXN0ZW5jZS5odG0iIC8+Ci0JCTx0b3BpYyBsYWJlbD0iQWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgcHJvamVjdCIgaHJlZj0idGFza19hZGRfcGVyc2lzdGVuY2UiIC8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJkaWFsb2dfYWRkSmF2YVBlcnNpc3RlbmNlX2NsYXNzcGF0aCI+Ci0JCTxkZXNjcmlwdGlvbj5Vc2UgdGhpcyBvcHRpb24gdG8gYWRkIGxpYnJhcmllcyBvciBKQVJzIHRoYXQgY29udGFpbiB0aGUgSmF2YSBQZXJzaXN0ZW5jZSBBUEkgKEpQQSkgYW5kIGVudGl0aWVzIHRvIHRoZSBwcm9qZWN04oCZcyBKYXZhIEJ1aWxkIFBhdGguPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJBZGQgUGVyc2lzdGVuY2UgZGlhbG9nIiBocmVmPSJyZWZfYWRkX3BlcnNpc3RlbmNlLmh0bSIgLz4KLQkJPHRvcGljIGxhYmVsPSJBZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBwcm9qZWN0IiBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZSIgLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9ImRpYWxvZ19hZGRKYXZhUGVyc2lzdGVuY2VfcGFja2FnaW5nIj4KLQkJPGRlc2NyaXB0aW9uPlVzZSB0aGVzZSBmaWVsZHMgdG8gY3JlYXRlIHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZS4gU2VsZWN0IHRoZSBwZXJzaXN0ZW5jZSB2ZXJzaW9uLCB0aGUgbmFtZSBvZiB0aGUgSlBBIHByb3ZpZGVyLCBhbmQgYSB1bmlxdWUgbmFtZSB0byBpZGVudGlmeSB0aGUgcGVyc2lzdGVuY2UgdW5pdC48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IkFkZCBQZXJzaXN0ZW5jZSBkaWFsb2ciIGhyZWY9InJlZl9hZGRfcGVyc2lzdGVuY2UuaHRtIiAvPgotCQk8dG9waWMgbGFiZWw9Ik1hbmFnaW5nIHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZSIgaHJlZj0idGFza19tYW5hZ2VfcGVyc2lzdGVuY2UuaHRtIiAvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0id2l6YXJkX2dlbmVyYXRlRERMX29wdGlvbnMgIj4KLQkJPGRlc2NyaXB0aW9uPlVzZSB0aGlzIHBhZ2UgdG8gc2VsZWN0IHdoaWNoIHNjcmlwdCBvcHRpb25zIHdpbGwgYmUgaW5jbHVkZWQgaW4gdGhlIGdlbmVyYXRlZCBzY3JpcHQuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJHZW5lcmF0aW5nIHRhYmxlcyAoRERMKSBmcm9tIGVudGl0aWVzICIgaHJlZj0idGFza19nZW5lcmF0ZV9kZGwuaHRtIiAvPgotCQk8dG9waWMgbGFiZWw9Ik9wdGlvbnMgcGFnZSAiIGhyZWY9InJlZl9vcHRpb25zLmh0bSIgLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9IndpemFyZF9nZW5lcmF0ZURETF9vYmplY3RzICI+Ci0JCTxkZXNjcmlwdGlvbj5Vc2UgdGhpcyBwYWdlIHRvIHNlbGVjdCB3aGljaCBlbGVtZW50cyB3aWxsIGJlIGluY2x1ZGVkIGluIHRoZSBnZW5lcmF0ZWQgc2NyaXB0LjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iR2VuZXJhdGluZyB0YWJsZXMgKERETCkgZnJvbSBlbnRpdGllcyAiIGhyZWY9InRhc2tfZ2VuZXJhdGVfZGRsLmh0bSIgLz4KLQkJPHRvcGljIGxhYmVsPSJPYmplY3RzIHBhZ2UgIiBocmVmPSJyZWZfb2JqZWN0cy5odG0iIC8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJ3aXphcmRfZ2VuZXJhdGVERExfc2F2ZSAiPgotCQk8ZGVzY3JpcHRpb24+VXNlIHRoaXMgcGFnZSB0byBzZWxlY3QgdGhlIGZpbGVuYW1lIGFuZCBsb2NhdGlvbiBvZiB0aGUgZ2VuZXJhdGVkIHNjcmlwdC4gWW91IGNhbiBhbHNvIHByZXZpZXcgdGhlIHNjcmlwdCBhbmQgc3BlY2lmeSB0byBydW4gb3IgY29udGludWUgZWRpdGluZyB0aGUgc2NyaXB0IGFmdGVyIGdlbmVyYXRpb24uPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJHZW5lcmF0aW5nIHRhYmxlcyAoRERMKSBmcm9tIGVudGl0aWVzICIgaHJlZj0idGFza19nZW5lcmF0ZV9kZGwuaHRtIiAvPgotCQk8dG9waWMgbGFiZWw9IlNhdmUgYW5kIFJ1biBEREwgcGFnZSAiIGhyZWY9InJlZl9zYXZlX2FuZF9ydW4uaHRtIiAvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0id2l6YXJkX2dlbmVyYXRlRERMX3N1bW1hcnkgIj4KLQkJPGRlc2NyaXB0aW9uPlRoaXMgcGFnZSBzaG93cyB0aGUgc2V0dGluZ3MgdGhhdCB5b3Ugc2VsZWN0ZWQgZm9yIHRoZSBnZW5lcmF0ZWQgRERMLiBUbyBjaGFuZ2UgYW55IG9wdGlvbiBjbGljayAiQmFjayIgb3IgY2xpY2sgIkZpbmlzaCIgdG8gY29udGludWUuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJHZW5lcmF0aW5nIHRhYmxlcyAoRERMKSBmcm9tIGVudGl0aWVzICIgaHJlZj0idGFza19nZW5lcmF0ZV9kZGwuaHRtIiAvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0ibWFwcGluZ190YWJsZUdlbmVyYXRvck5hbWUiPgotCQk8ZGVzY3JpcHRpb24+VGhlIG5hbWUgb2YgdGhlIHRhYmxlIHNlcXVlbmNlIGdlbmVyYXRvci4gVGhpcyBuYW1lIGlzIGdsb2JhbCB0byB0byB0aGUgcGVyc2lzdGVuY2UgdW5pdCAoYWNyb3NzIGFsbCBnZW5lcmF0b3IgdHlwZXMpLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJNYXBwaW5nIGFuIGVudGl0eSIgaHJlZj0idGFza19tYXBwaW5nLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0ibWFwcGluZ190YWJsZUdlbmVyYXRvclRhYmxlIj4KLQkJPGRlc2NyaXB0aW9uPlRoZSBkYXRhYmFzZSB0YWJsZSB0aGF0IHN0b3JlcyB0aGUgZ2VuZXJhdGVkIElEIHZhbHVlcy4gPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9Ik1hcHBpbmcgYW4gZW50aXR5IiBocmVmPSJ0YXNrX21hcHBpbmcuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJtYXBwaW5nX3RhYmxlR2VuZXJhdG9yUHJpbWFyeUtleUNvbHVtbiI+Ci0JCTxkZXNjcmlwdGlvbj5UaGUgZGF0YWJhc2UgY29sdW1uIG9mIHRoZSBnZW5lcmF0b3IgdGFibGUgdGhhdCBzdG9yZXMgdGhlIGdlbmVyYXRlZCBJRCB2YWx1ZXMuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9Ik1hcHBpbmcgYW4gZW50aXR5IiBocmVmPSJ0YXNrX21hcHBpbmcuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJtYXBwaW5nX3RhYmxlR2VuZXJhdG9yVmFsdWVDb2x1bW4iPgotCQk8ZGVzY3JpcHRpb24+VGhlIG5hbWUgZm9yIHRoZSBjb2x1bW4gdGhhdCBzdG9yZXMgdGhlIGdlbmVyYXRlZCBJRCB2YWx1ZXMuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9Ik1hcHBpbmcgYW4gZW50aXR5IiBocmVmPSJ0YXNrX21hcHBpbmcuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJtYXBwaW5nX3RhYmxlR2VuZXJhdG9yUHJpbWFyeUtleUNvbHVtblZhbHVlIj4KLQkJPGRlc2NyaXB0aW9uPlRoZSBkYXRhYmFzZSBjb2x1bW4gb2YgdGhlIGdlbmVyYXRvciB0YWJsZSB0aGF0IGRlZmluZXMgdGhlIHByaW1hcnkga2V5IHZhbHVlLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJNYXBwaW5nIGFuIGVudGl0eSIgaHJlZj0idGFza19tYXBwaW5nLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0iZGlhbG9nX2RhdGFiYXNlQXV0aG9yaXphdGlvbiI+Ci0JCTxkZXNjcmlwdGlvbj5Vc2UgdG8gY29ubmVjdCAobG9nIGluKSB0byBhIGRhdGFiYXNlIGNvbm5lY3Rpb24gdG8gdXNlIHdpdGggeW91ciBKYXZhIHBlcnNpc3RlbnQgZW50aXRpZXMuIAotCQlZb3UgbXVzdCBoYXZlIGEgZGVmaW5lZCBkYXRhYmFzZSBjb25uZWN0aW9uIChhbmQgYmUgY29ubmVjdGVkKSB0byBhZGQgcGVyc2lzdGVuY2UuIDwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iQWRkIHBlcnNpc3RlbmNlIHRvIGEgSmF2YSBwcm9qZWN0IiBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZV9wcm9qZWN0Lmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0ibWFwcGluZ190ZW1wb3JhbCI+Ci0JCTxkZXNjcmlwdGlvbj5TcGVjaWZ5IGlmIHRoZSBtYXBwZWQgZmllbGQgY29udGFpbnMgYSBEYXRlIChqYXZhLnNxbC5EYXRlKSwgVGltZSAoamF2YS5zcWwuVGltZSksIG9yIFRpbWVzdGFtcCAoamF2YS5zcWwuVGltZXN0YW1wKSB2YWx1ZS48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iTWFwcGluZyBhbiBlbnRpdHkiIGhyZWY9InRhc2tfbWFwcGluZy5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9Im1hcHBpbmdfcHJpbWFyeUtleUdlbmVyYXRpb24iPgotCQk8ZGVzY3JpcHRpb24+RGVmaW5lIGhvdyB0aGUgcHJpbWFyeSBrZXkgaXMgZ2VuZXJhdGVkPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJQcmltYXJ5IEtleSBHZW5lcmF0aW9uIGluZm9ybWF0aW9uIiBocmVmPSJyZWZfcHJpbWFyeV9rZXkuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJNYXBwaW5nIGFuIGVudGl0eSIgaHJlZj0idGFza19tYXBwaW5nLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0ibWFwcGluZ190YWJsZUdlbmVyYXRvciI+Ci0JCTxkZXNjcmlwdGlvbj5TcGVjaWZ5IHRvIHVzZSBhIHNwZWNpZmljIGRhdGFiYXNlIHRhYmxlIGZvciBnZW5lcmF0aW5nIHRoZSBwcmltYXJ5IGtleS48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IlByaW1hcnkgS2V5IEdlbmVyYXRpb24gaW5mb3JtYXRpb24iIGhyZWY9InJlZl9wcmltYXJ5X2tleS5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9Ik1hcHBpbmcgYW4gZW50aXR5IiBocmVmPSJ0YXNrX21hcHBpbmcuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJtYXBwaW5nX3NlcXVlbmNlR2VuZXJhdG9yIj4KLQkJPGRlc2NyaXB0aW9uPlNwZWNpZnkgdG8gdXNlIGEgc3BlY2lmaWMgc2VxdWVuY2UgZm9yIGdlbmVyYXRpbmcgdGhlIHByaW1hcnkga2V5LjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iUHJpbWFyeSBLZXkgR2VuZXJhdGlvbiBpbmZvcm1hdGlvbiIgaHJlZj0icmVmX3ByaW1hcnlfa2V5Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iTWFwcGluZyBhbiBlbnRpdHkiIGhyZWY9InRhc2tfbWFwcGluZy5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9Im1hcHBpbmdfc2VxdWVuY2VHZW5lcmF0b3JOYW1lIj4KLQkJPGRlc2NyaXB0aW9uPk5hbWUgb2YgdGhlIHNlcXVlbmNlLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iUHJpbWFyeSBLZXkgR2VuZXJhdGlvbiBpbmZvcm1hdGlvbiIgaHJlZj0icmVmX3ByaW1hcnlfa2V5Lmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iTWFwcGluZyBhbiBlbnRpdHkiIGhyZWY9InRhc2tfbWFwcGluZy5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9Im1hcHBpbmdfc2VxdWVuY2VHZW5lcmF0b3JTZXF1ZW5jZSI+Ci0JCTxkZXNjcmlwdGlvbj4gPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJQcmltYXJ5IEtleSBHZW5lcmF0aW9uIGluZm9ybWF0aW9uIiBocmVmPSJyZWZfcHJpbWFyeV9rZXkuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJNYXBwaW5nIGFuIGVudGl0eSIgaHJlZj0idGFza19tYXBwaW5nLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0ibWFwcGluZ19sb2IiPgotCQk8ZGVzY3JpcHRpb24+U3BlY2lmeSBpZiB0aGUgZmllbGQgaXMgbWFwcGVkIHRvIGphdmEuc3FsLkNsb2Igb3IgamF2YS5zcWwuQmxvYi48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IkdlbmVyYWwgaW5mb3JtYXRpb24iIGhyZWY9InJlZl9tYXBwaW5nX2dlbmVyYWwuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJNYXBwaW5nIGFuIGVudGl0eSIgaHJlZj0idGFza19tYXBwaW5nLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0ibWFwcGluZ19lbnVtZXJhdGVkIj4KLQkJPGRlc2NyaXB0aW9uPlNwZWNpZnkgaG93IHRvIHBlcnNpc3QgZW51bWVyYXRlZCBjb25zdHJhaW50cyBpZiB0aGUgU3RyaW5nIHZhbHVlIHN1aXRzIHlvdXIgYXBwbGljYXRpb24gcmVxdWlyZW1lbnRzIG9yIHRvIG1hdGNoIGFuIGV4aXN0aW5nIGRhdGFiYXNlIHNjaGVtYS48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9IkdlbmVyYWwgaW5mb3JtYXRpb24iIGhyZWY9InJlZl9tYXBwaW5nX2dlbmVyYWwuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJNYXBwaW5nIGFuIGVudGl0eSIgaHJlZj0idGFza19tYXBwaW5nLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0iZGlhbG9nX2VkaXRJbnZlcnNlSm9pbkNvbHVtbiI+Ci0JCTxkZXNjcmlwdGlvbj4uPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJNYXBwaW5nIGFuIGVudGl0eSIgaHJlZj0idGFza19tYXBwaW5nLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0iZW50aXR5X2NhdGFsb2ciPgotCQk8ZGVzY3JpcHRpb24+VGhlIGRhdGFiYXNlIGNhdGFsb2cgdGhhdCBjb250YWlucyB0aGUgVGFibGUuIFRoaXMgZmllbGQgb3ZlcnJpZGVzIHRoZSBkZWZhdWx0cyBpbiB0aGUgb3JtLnhtbCBmaWxlLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wcm9wX3ZpZXcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iQWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3MiIGhyZWY9InRhc2tfYWRkX3BlcnNpc3RlbmNlLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IlVuZGVyc3RhbmRpbmcgcGVyc2lzdGVuY2UiIGhyZWY9ImNvbmNlcHRfcGVyc2lzdGVuY2UuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJlbnRpdHlfc2NoZW1hIj4KLQkJPGRlc2NyaXB0aW9uPlRoZSBkYXRhYmFzZSBzY2hlbWEgdGhhdCBjb250YWlucyB0aGUgVGFibGUuIFRoaXMgZmllbGQgb3ZlcnJpZGVzIHRoZSBkZWZhdWx0cyBpbiB0aGUgb3JtLnhtbCBmaWxlLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wcm9wX3ZpZXcuaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iQWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3MiIGhyZWY9InRhc2tfYWRkX3BlcnNpc3RlbmNlLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IlVuZGVyc3RhbmRpbmcgcGVyc2lzdGVuY2UiIGhyZWY9ImNvbmNlcHRfcGVyc2lzdGVuY2UuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJvcm1fcGFja2FnZSI+Ci0JCTxkZXNjcmlwdGlvbj5UaGUgSmF2YSBwYWNrYWdlIHRoYXQgY29udGFpbnMgdGhlIHBlcnNpc3RlbnQgZW50aXRpZXMgdG8gd2hpY2ggdGhlIG9ybS54bWwgZmlsZSBhcHBsaWVzLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iTWFuYWdpbmcgdGhlIG9ybS54bWwgZmlsZSIgaHJlZj0idGFza19tYW5hZ2Vfb3JtLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfZGV0YWlsc19vcm0uaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJvcm1fc2NoZW1hIj4KLQkJPGRlc2NyaXB0aW9uPlRoZSBkYXRhYmFzZSBzY2hlbWEgdG8gdXNlIGFzIHRoZSBkZWZhdWx0IGZvciBhbGwgZW50aXRpZXMgbWFuYWdlZCBieSB0aGlzIHBlcnNpc3RlbmNlIHVuaXQuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJNYW5hZ2luZyB0aGUgb3JtLnhtbCBmaWxlIiBocmVmPSJ0YXNrX21hbmFnZV9vcm0uaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIERldGFpbHMiIGhyZWY9InJlZl9kZXRhaWxzX29ybS5odG0iLz4KLQk8L2NvbnRleHQ+Ci0JPGNvbnRleHQgaWQ9Im9ybV9jYXRhbG9nIj4KLQkJPGRlc2NyaXB0aW9uPlRoZSBkYXRhYmFzZSBjYXRhbG9nIHRvIHVzZSBhcyB0aGUgZGVmYXVsdCBmb3IgYWxsIGVudGl0aWVzIG1hbmFnZWQgYnkgdGhpcyBwZXJzaXN0ZW5jZSB1bml0LjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iTWFuYWdpbmcgdGhlIG9ybS54bWwgZmlsZSIgaHJlZj0idGFza19tYW5hZ2Vfb3JtLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfZGV0YWlsc19vcm0uaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJvcm1fYWNjZXNzIj4KLQkJPGRlc2NyaXB0aW9uPlRoZSBkZWZhdWx0IGFjY2VzcyBtZXRob2QgZm9yIHZhcmlhYmxlcyBpbiB0aGlzIHByb2plY3Q6IFByb3BlcnR5IG9yIEZpZWxkLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iTWFuYWdpbmcgdGhlIG9ybS54bWwgZmlsZSIgaHJlZj0idGFza19tYW5hZ2Vfb3JtLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfZGV0YWlsc19vcm0uaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJvcm1fY2FzY2FkZSI+Ci0JCTxkZXNjcmlwdGlvbj5BZGRzIGNhc2NhZGUtcGVyc2lzdCB0byB0aGUgc2V0IG9mIGNhc2NhZGUgb3B0aW9ucyBpbiBlbnRpdHkgcmVsYXRpb25zaGlwcyBvZiB0aGUgcGVyc2lzdGVuY2UgdW5pdC48L2Rlc2NyaXB0aW9uPgotCQk8dG9waWMgbGFiZWw9Ik1hbmFnaW5nIHRoZSBvcm0ueG1sIGZpbGUiIGhyZWY9InRhc2tfbWFuYWdlX29ybS5odG0iLz4KLQkJPHRvcGljIGxhYmVsPSJKUEEgRGV0YWlscyIgaHJlZj0icmVmX2RldGFpbHNfb3JtLmh0bSIvPgotCTwvY29udGV4dD4KLQk8Y29udGV4dCBpZD0ib3JtX3htbCI+Ci0JCTxkZXNjcmlwdGlvbj5TcGVjaWZpZXMgdGhhdCB0aGUgSmF2YSBjbGFzc2VzIGluIHRoaXMgcGVyc2lzdGVuY2UgdW5pdCBhcmUgZnVsbHkgc3BlY2lmaWVkIGJ5IHRoZWlyIG1ldGFkYXRhLiBBbnkgYW5ub3RhdGlvbnMgd2lsbCBiZSBpZ25vcmVkLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iTWFuYWdpbmcgdGhlIG9ybS54bWwgZmlsZSIgaHJlZj0idGFza19tYW5hZ2Vfb3JtLmh0bSIvPgotCQk8dG9waWMgbGFiZWw9IkpQQSBEZXRhaWxzIiBocmVmPSJyZWZfZGV0YWlsc19vcm0uaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJkaWFsb2dfSlBBUGxhdGZvcm0iPgotCQk8ZGVzY3JpcHRpb24+U3BlY2lmeSB0aGUgdmVuZG9yLXNwZWNpZmljIEpQQSBpbXBsZW1lbnRhdGlvbi5EZWZhdWx0IGlzIEdlbmVyaWMuLjwvZGVzY3JpcHRpb24+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIEZhY2V0IHBhZ2UiIGhyZWY9InJlZl9qcGFfZmFjZXQuaHRtIi8+Ci0JPC9jb250ZXh0PgotCTxjb250ZXh0IGlkPSJkaWFsb2dfY3JlYXRlT1JNIj4KLQkJPGRlc2NyaXB0aW9uPkNyZWF0ZSBhbiBpbml0aWFsIG9ybS54bWwgZmlsZS4gVXNlIHRoaXMgZmlsZSB0byBzcGVjaWZ5IHByb2plY3QgYW5kIHBlcnNpc3RlbmNlIHVuaXQgZGVmYXVsdHMuPC9kZXNjcmlwdGlvbj4KLQkJPHRvcGljIGxhYmVsPSJNYW5hZ2luZyB0aGUgb3JtLnhtbCBmaWxlIiBocmVmPSJ0YXNrX21hbmFnZV9vcm0uaHRtIi8+Ci0JCTx0b3BpYyBsYWJlbD0iSlBBIEZhY2V0IHBhZ2UiIGhyZWY9InJlZl9qcGFfZmFjZXQuaHRtIi8+Ci0JPC9jb250ZXh0PgotCi0KLQotCi08L2NvbnRleHRzPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2Rjb21tb24vY3NzL2JsYWZkb2MuY3NzIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2Rjb21tb24vY3NzL2JsYWZkb2MuY3NzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiYWY2MTI3Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9kY29tbW9uL2Nzcy9ibGFmZG9jLmNzcworKysgL2Rldi9udWxsCkBAIC0xLDIxICswLDAgQEAKLUBpbXBvcnQgIi4uLy4uLy4uL1BST0RVQ1RfUExVR0lOL2Jvb2suY3NzIjsKLQotc3Bhbi5jb250cm9sLCBzcGFuLmd1aS1vYmplY3QtYWN0aW9uLCBwLnN1YmhlYWQyLCBzcGFuLmJvbGQsIHAubm90ZXAxIHsKLSAgZm9udC13ZWlnaHQ6IGJvbGQ7Ci19Ci0KLXNwYW4ubmFtZSwgcC50aXRsZWluZmlndXJlLCBzcGFuLml0YWxpYyB7Ci0gIGZvbnQtc3R5bGU6IGl0YWxpYzsKLX0KLQotcC50aXRsZWluZmlndXJlLCBwLnN1YmhlYWQyIHsKLSAgcGFkZGluZy10b3A6IDEwcHg7Ci19Ci0KLXNwYW4uY29kZSB7Ci0gIGZvbnQtZmFtaWx5OiBtb25vc3BhY2U7Ci19Ci0KLXNwYW4uY29weXJpZ2h0bG9nbyB7Zm9udC1zaXplOiAwLjhlbX0KLQotLmZvb3RlciB7bWFyZ2luLXRvcDogMmVtO2JvcmRlci10b3A6MXB4IHNvbGlkICNjY2NjY2M7cGFkZGluZy10b3A6MWVtO30KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvZGNvbW1vbi9odG1sL2NweXIuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2Rjb21tb24vaHRtbC9jcHlyLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzgyZWM2Ny4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvZGNvbW1vbi9odG1sL2NweXIuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsMTEgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLQotPGhlYWQ+Ci08IS0tICA8bWV0YSBodHRwLWVxdWl2PSJyZWZyZXNoIiBjb250ZW50PSIwO3VybD0uLi8uLi9sZWdhbC5odG0iPiAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaHJlZj0iLi4vLi4vbGVnYWwuaHRtIj5MaWNlbnNlIEluZm9ybWF0aW9uPC9hPjwvcD4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9nZXR0aW5nX3N0YXJ0ZWQuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2dldHRpbmdfc3RhcnRlZC5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGM1NmM4YzAuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2dldHRpbmdfc3RhcnRlZC5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw0NiArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0MSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPkdldHRpbmcgc3RhcnRlZDwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IiBHZXR0aW5nIHN0YXJ0ZWQiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJzdGhyZWYyIiBuYW1lPSJzdGhyZWYyIj48L2E+PC9wPgotPGgxPkdldHRpbmcgc3RhcnRlZDwvaDE+Ci08cD5UaGlzIHNlY3Rpb24gcHJvdmlkZXMgaW5mb3JtYXRpb24gb24gZ2V0dGluZyBzdGFydGVkIHdpdGggdGhlIEphdmEgUGVyc2lzdGVuY2UgVG9vbHMuPC9wPgotPHVsPgotPGxpPgotPHA+PGEgaHJlZj0iZ2V0dGluZ19zdGFydGVkMDAxLmh0bSNCQUJFRkhDRCI+UmVxdWlyZW1lbnRzIGFuZCBpbnN0YWxsYXRpb248L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9ImdldHRpbmdfc3RhcnRlZDAwMi5odG0jQkFCSUdDSkEiPkRhbGkgcXVpY2sgc3RhcnQ8L2E+PC9wPgotPC9saT4KLTwvdWw+Ci08cD5Gb3IgYWRkaXRpb25hbCBpbmZvcm1hdGlvbiwgcGxlYXNlIHZpc2l0IHRoZSBEYWxpIGhvbWUgcGFnZSBhdDo8L3A+Ci08cD48Y29kZT48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL3dlYnRvb2xzL2RhbGkvbWFpbi5waHAiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvd2VidG9vbHMvZGFsaS9tYWluLnBocDwvYT48L2NvZGU+LjwvcD4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9nZXR0aW5nX3N0YXJ0ZWQwMDEuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2dldHRpbmdfc3RhcnRlZDAwMS5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAyMzZmMjYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2dldHRpbmdfc3RhcnRlZDAwMS5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw4MiArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0MSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPlJlcXVpcmVtZW50cyBhbmQgaW5zdGFsbGF0aW9uPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iUmVxdWlyZW1lbnRzIGFuZCBpbnN0YWxsYXRpb24iIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJCQUJFRkhDRCIgbmFtZT0iQkFCRUZIQ0QiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MSI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPlJlcXVpcmVtZW50cyBhbmQgaW5zdGFsbGF0aW9uPGEgaWQ9InN0aHJlZjMiIG5hbWU9InN0aHJlZjMiPjwvYT48YSBpZD0ic3RocmVmNCIgbmFtZT0ic3RocmVmNCI+PC9hPjwvaDE+Ci08cD5CZWZvcmUgaW5zdGFsbGluZyBEYWxpLCBlbnN1cmUgdGhhdCB5b3VyIGVudmlyb25tZW50IG1lZXRzIHRoZSBmb2xsb3dpbmcgPHNwYW4gY2xhc3M9Iml0YWxpYyI+bWluaW11bTwvc3Bhbj4gcmVxdWlyZW1lbnRzOjwvcD4KLTx1bD4KLTxsaT4KLTxwPkVjbGlwc2UgMy40ICg8Y29kZT48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2Rvd25sb2FkcyI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9kb3dubG9hZHM8L2E+PC9jb2RlPik8L3A+Ci08L2xpPgotPGxpPgotPHA+SmF2YSBSdW50aW1lIEVudmlyb25tZW50IChKUkUpIDEuNSAoPGNvZGU+PGEgaHJlZj0iaHR0cDovL2phdmEuY29tIj5odHRwOi8vamF2YS5jb208L2E+PC9jb2RlPik8L3A+Ci08L2xpPgotPGxpPgotPHA+RWNsaXBzZSBXZWIgVG9vbHMgUGxhdGZvcm0gKFdUUCkgMy4wICg8Y29kZT48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL3dlYnRvb2xzIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL3dlYnRvb2xzPC9hPjwvY29kZT4pPC9wPgotPC9saT4KLTxsaT4KLTxwPkphdmEgUGVyc2lzdGVuY2UgQVBJIChKUEEpIGZvciBKYXZhIEVFIDUuIFRoZSByZWZlcmVuY2UgaW1wbGVtZW50YXRpb24gY2FuIGJlIG9idGFpbmVkIGZyb206PC9wPgotPC9saT4KLTwvdWw+Ci08cHJlIHhtbDpzcGFjZT0icHJlc2VydmUiIGNsYXNzPSJvYWNfbm9fd2FybiI+Ci08Y29kZT48YSBocmVmPSJodHRwczovL2dsYXNzZmlzaC5kZXYuamF2YS5uZXQvZG93bmxvYWRzL3BlcnNpc3RlbmNlL0phdmFQZXJzaXN0ZW5jZS5odG1sIj5odHRwczovL2dsYXNzZmlzaC5kZXYuamF2YS5uZXQvZG93bmxvYWRzL3BlcnNpc3RlbmNlL0phdmFQZXJzaXN0ZW5jZS5odG1sPC9hPjwvY29kZT4KLTwvcHJlPgotPHA+UmVmZXIgdG8gPGNvZGU+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy93ZWJ0b29scy9kYWxpL2dldHRpbmdzdGFydGVkX21haW4uaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy93ZWJ0b29scy9kYWxpL2dldHRpbmdzdGFydGVkX21haW4uaHRtbDwvYT48L2NvZGU+IGZvciBhZGRpdGlvbmFsIGluc3RhbGxhdGlvbiBpbmZvcm1hdGlvbi48L3A+Ci08cD5EYWxpIGlzIGluY2x1ZGVkIGFzIHBhcnQgb2YgV1RQIDIuMC4gTm8gYWRkaXRpb25hbCBpbnN0YWxsYXRpb24gb3IgY29uZmlndXJhdGlvbiBpcyByZXF1aXJlZC48L3A+Ci08YSBpZD0ic3RocmVmNSIgbmFtZT0ic3RocmVmNSI+PC9hPgotPHAgY2xhc3M9InN1YmhlYWQyIj5BY2Nlc3NpYmlsaXR5IEZlYXR1cmVzPC9wPgotPHA+RGFsaSBzdXBwb3J0cyB0aGUgc3RhbmRhcmQgYWNjZXNzaWJpbGl0eSBmZWF0dXJlcyBpbiBFY2xpcHNlLCBpbmNsdWRpbmcgdGhlIGZvbGxvd2luZzo8L3A+Ci08dWw+Ci08bGk+Ci08cD5OYXZpZ2F0aW5nIHRoZSB1c2VyIGludGVyZmFjZSB1c2luZyB0aGUga2V5Ym9hcmQuPC9wPgotPC9saT4KLTxsaT4KLTxwPlNwZWNpZnlpbmcgZ2VuZXJhbCBhY2Nlc3NpYmlsaXR5IHByZWZlcmVuY2VzIGZvciB0aGUgZWRpdG9yLjwvcD4KLTwvbGk+Ci08L3VsPgotPHA+U2VlIDxhIGhyZWY9Ii4uL29yZy5lY2xpcHNlLnBsYXRmb3JtLmRvYy51c2VyL2NvbmNlcHRzL2FjY2Vzc2liaWxpdHkvYWNjZXNzbWFpbi5odG0iPkFjY2Vzc2liaWxpdHkgRmVhdHVyZXMgaW4gRWNsaXBzZTwvYT4gaW4gdGhlIDxzcGFuIGNsYXNzPSJpdGFsaWMiPldvcmtiZW5jaCBVc2VyIEd1aWRlPC9zcGFuPiBmb3IgZGV0YWlscy48L3A+Ci08YSBpZD0ic3RocmVmNiIgbmFtZT0ic3RocmVmNiI+PC9hPgotPHAgY2xhc3M9InN1YmhlYWQyIj5IZWxwIEFjY2Vzc2liaWxpdHk8L3A+Ci08cD5UaGUgZG9jdW1lbnRhdGlvbiBhbmQgaGVscCBjb250YWlucyBtYXJrdXAgdG8gZmFjaWxpdGF0ZSBhY2Nlc3MgYnkgdGhlIGRpc2FibGVkIGNvbW11bml0eS4gU2VlIDxhIGhyZWY9Ii4uL29yZy5lY2xpcHNlLnBsYXRmb3JtLmRvYy51c2VyL3Rhc2tzL2hlbHBfYWNjZXNzaWJpbGl0eS5odG0iPkhlbHAgQWNjZXNzaWJpbGl0eTwvYT4gaW4gdGhlIDxzcGFuIGNsYXNzPSJpdGFsaWMiPldvcmtiZW5jaCBVc2VyIEd1aWRlPC9zcGFuPiBmb3IgZGV0YWlscy48L3A+Ci08cD5XaGVuIHVzaW5nIHRoZSBoZWxwLCBiZSBhd2FyZSBvZiB0aGUgZm9sbG93aW5nOjwvcD4KLTx1bD4KLTxsaT4KLTxwPlNjcmVlbiByZWFkZXJzIG1heSBub3QgYWx3YXlzIGNvcnJlY3RseSByZWFkIHRoZSBjb2RlIGV4YW1wbGVzIGluIHRoaXMgZG9jdW1lbnQuIFRoZSBjb252ZW50aW9ucyBmb3Igd3JpdGluZyBjb2RlIHJlcXVpcmUgdGhhdCBjbG9zaW5nIGJyYWNlcyBzaG91bGQgYXBwZWFyIG9uIGFuIG90aGVyd2lzZSBlbXB0eSBsaW5lOyBob3dldmVyLCBzb21lIHNjcmVlbiByZWFkZXJzIG1heSBub3QgYWx3YXlzIHJlYWQgYSBsaW5lIG9mIHRleHQgdGhhdCBjb25zaXN0cyBzb2xlbHkgb2YgYSBicmFja2V0IG9yIGJyYWNlLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5UaGlzIGRvY3VtZW50YXRpb24gbWF5IGNvbnRhaW4gbGlua3MgdG8gV2ViIHNpdGVzIG9mIG90aGVyIGNvbXBhbmllcyBvciBvcmdhbml6YXRpb25zIHRoYXQgd2UgZG8gbm90IGNvbnRyb2wuIFdlIG5laXRoZXIgZXZhbHVhdGUgbm9yIG1ha2UgYW55IHJlcHJlc2VudGF0aW9ucyByZWdhcmRpbmcgdGhlIGFjY2Vzc2liaWxpdHkgb2YgdGhlc2UgV2ViIHNpdGVzLjwvcD4KLTwvbGk+Ci08L3VsPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MSIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvZ2V0dGluZ19zdGFydGVkMDAyLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9nZXR0aW5nX3N0YXJ0ZWQwMDIuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5ZDdmNTRjLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9nZXR0aW5nX3N0YXJ0ZWQwMDIuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNDggKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDEgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5EYWxpIHF1aWNrIHN0YXJ0PC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iRGFsaSBxdWljayBzdGFydCIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkJBQklHQ0pBIiBuYW1lPSJCQUJJR0NKQSI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QxIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+RGFsaSBxdWljayBzdGFydDwvaDE+Ci08cD48YSBpZD0ic3RocmVmNyIgbmFtZT0ic3RocmVmNyI+PC9hPlRoaXMgc2VjdGlvbiBpbmNsdWRlcyBpbmZvcm1hdGlvbiB0byBoZWxwIHlvdSBxdWlja2x5IHN0YXJ0IHVzaW5nIERhbGkgdG8gY3JlYXRlIHJlbGF0aW9uYWwgbWFwcGluZ3MgYmV0d2VlbiBKYXZhIHBlcnNpc3RlbnQgZW50aXRpZXMgYW5kIGRhdGFiYXNlIHRhYmxlcy48L3A+Ci08dWw+Ci08bGk+Ci08cD48YSBocmVmPSJnZXR0aW5nX3N0YXJ0ZWQwMDMuaHRtI0JBQkRGSERBIj5DcmVhdGluZyBhIG5ldyBKUEEgcHJvamVjdDwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0iZ2V0dGluZ19zdGFydGVkMDA0Lmh0bSNCQUJGR0RERyI+Q3JlYXRpbmcgYSBKYXZhIHBlcnNpc3RlbnQgZW50aXR5IHdpdGggcGVyc2lzdGVudCBmaWVsZHM8L2E+PC9wPgotPC9saT4KLTwvdWw+Ci08aW1nIHNyYz0iaW1nL25ncmVsci5wbmciIGFsdD0iUmVsYXRlZCByZWZlcmVuY2UiIHRpdGxlPSJSZWxhdGVkIHJlZmVyZW5jZSIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGlwc19hbmRfdHJpY2tzLmh0bSNDSERIR0hCRiI+VGlwcyBhbmQgdHJpY2tzPC9hPjxiciAvPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPjwvZGl2PgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2dldHRpbmdfc3RhcnRlZDAwMy5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvZ2V0dGluZ19zdGFydGVkMDAzLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDE5MDdjMS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvZ2V0dGluZ19zdGFydGVkMDAzLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDEwMSArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0MSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPkNyZWF0aW5nIGEgbmV3IEpQQSBwcm9qZWN0PC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iQ3JlYXRpbmcgYSBuZXcgSlBBIHByb2plY3QiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJCQUJERkhEQSIgbmFtZT0iQkFCREZIREEiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MiI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPkNyZWF0aW5nIGEgbmV3IEpQQSBwcm9qZWN0PC9oMT4KLTxwPjxhIGlkPSJzdGhyZWY4IiBuYW1lPSJzdGhyZWY4Ij48L2E+VGhpcyBxdWljayBzdGFydCBzaG93cyBob3cgdG8gY3JlYXRlIGEgbmV3IEpQQSBwcm9qZWN0LjwvcD4KLTxvbCBzdGFydD0iMSI+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+U2VsZWN0IEZpbGUgJmd0OyBOZXcgJmd0OyBQcm9qZWN0PC9zcGFuPi4gVGhlIFNlbGVjdCBhIFdpemFyZCBkaWFsb2cgYXBwZWFycy48L3A+Ci08ZGl2IGFsaWduPSJjZW50ZXIiPgotPGRpdiBjbGFzcz0iaW5mdGJsbm90ZWFsc28iPjxiciAvPgotPHRhYmxlIGNsYXNzPSJOb3RlQWxzbyBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRib2R5PgotPHRyPgotPHRkIGFsaWduPSJsZWZ0Ij4KLTxwIGNsYXNzPSJub3RlcDEiPlRpcDo8L3A+Ci1Zb3UgY2FuIGFsc28gc2VsZWN0IHRoZSBKUEEgcGVyc3BlY3RpdmUgYW5kIHRoZW4gc2VsZWN0IDxzcGFuIGNsYXNzPSJib2xkIj5GaWxlICZndDsgTmV3ICZndDsgSlBBIFByb2plY3Q8L3NwYW4+LjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibG5vdGVhbHNvIiAtLT48L2Rpdj4KLTwvbGk+Ci08bGk+Ci08cD5TZWxlY3QgPHNwYW4gY2xhc3M9ImJvbGQiPkpQQSBQcm9qZWN0PC9zcGFuPiBhbmQgdGhlbiBjbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+TmV4dDwvc3Bhbj4uIFRoZSA8YSBocmVmPSJyZWZfbmV3X2pwYV9wcm9qZWN0Lmh0bSNDQUNCSkFHQyI+TmV3IEpQQSBQcm9qZWN0IHBhZ2U8L2E+IGFwcGVhcnMuPC9wPgotPC9saT4KLTxsaT4KLTxwPkVudGVyIGEgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtYWN0aW9uIj5Qcm9qZWN0IG5hbWU8L3NwYW4+IChzdWNoIGFzIDxjb2RlPlF1aWNrU3RhcnQ8L2NvZGU+KS48L3A+Ci08L2xpPgotPGxpPgotPHA+SWYgbmVlZGVkLCBzZWxlY3QgdGhlIDxzcGFuIGNsYXNzPSJib2xkIj5UYXJnZXQgUnVudGltZTwvc3Bhbj4gKHN1Y2ggYXMgPGNvZGU+QXBhY2hlIFRvbWNhdDwvY29kZT4pIGFuZCBjb25maWd1cmF0aW9uLCBzdWNoIGFzIDxzcGFuIGNsYXNzPSJib2xkIj5VdGlsaXR5IEpQQSBQcm9qZWN0IHdpdGggSmF2YSA1LjA8L3NwYW4+IGFuZCB0aGVuIGNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5OZXh0PC9zcGFuPi4gVGhlIDxhIGhyZWY9InJlZl9qcGFfZmFjZXQuaHRtI0NBQ0lGRElGIj5KUEEgRmFjZXQgcGFnZTwvYT4gYXBwZWFycy48L3A+Ci08ZGl2IGFsaWduPSJjZW50ZXIiPgotPGRpdiBjbGFzcz0iaW5mdGJsbm90ZSI+PGJyIC8+Ci08dGFibGUgY2xhc3M9Ik5vdGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0Ym9keT4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCI+Ci08cCBjbGFzcz0ibm90ZXAxIj5Ob3RlOjwvcD4KLVRoZSBUYXJnZXQgUnVudGltZSBpcyBub3QgcmVxdWlyZWQgZm9yIEphdmEgU0UgZGV2ZWxvcG1lbnQuPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJsbm90ZSIgLS0+PC9kaXY+Ci08L2xpPgotPGxpPgotPHA+T24gdGhlIEpQQSBGYWNldCBkaWFsb2csIHNlbGVjdCB5b3VyIHZlbmRvci1zcGVjaWZpYyBKUEEgcGxhdGZvcm0gKG9yIHNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+R2VuZXJpYzwvc3Bhbj4pLCBkYXRhYmFzZSBjb25uZWN0aW9uIChvciBjcmVhdGUgYSBuZXcgY29ubmVjdGlvbiksIEpQQSBpbXBsZW1lbnRhdGlvbiBsaWJyYXJ5IChzdWNoIGFzIEVjbGlwc2VMaW5rKSwgZGVmaW5lIGhvdyBEYWxpIHNob3VsZCBtYW5hZ2UgcGVyc2lzdGVudCBjbGFzc2VzLCBhbmQgdGhlbiBjbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+RmluaXNoPC9zcGFuPi48L3A+Ci08ZGl2IGFsaWduPSJjZW50ZXIiPgotPGRpdiBjbGFzcz0iaW5mdGJsbm90ZWFsc28iPjxiciAvPgotPHRhYmxlIGNsYXNzPSJOb3RlQWxzbyBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRib2R5PgotPHRyPgotPHRkIGFsaWduPSJsZWZ0Ij4KLTxwIGNsYXNzPSJub3RlcDEiPlRpcDo8L3A+Ci1TZWxlY3QgPHNwYW4gY2xhc3M9ImJvbGQiPk92ZXJyaWRlIHRoZSBEZWZhdWx0IFNjaGVtYSBmb3IgQ29ubmVjdGlvbjwvc3Bhbj4gaWYgeW91IHJlcXVpcmUgYSBzY2hlbWEgb3RoZXIgdGhhbiB0aGUgb25lIHRoYXQgRGFsaSBkZXJpdmVzIGZyb20gdGhlIGNvbm5lY3Rpb24gaW5mb3JtYXRpb24sIHdoaWNoIG1heSBiZSBpbmNvcnJlY3QgaW4gc29tZSBjYXNlcy4gVXNpbmcgdGhpcyBvcHRpb24sIHlvdSBjYW4gc2VsZWN0IGEgZGV2ZWxvcG1lbnQgdGltZSBzY2hlbWEgZm9yIGRlZmF1bHRzIGFuZCB2YWxpZGF0aW9uLjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibG5vdGVhbHNvIiAtLT48L2Rpdj4KLTwvbGk+Ci08L29sPgotPHA+RWNsaXBzZSBhZGRzIHRoZSBwcm9qZWN0IHRvIHRoZSB3b3JrYmVuY2ggYW5kIG9wZW5zIHRoZSBKUEEgcGVyc3BlY3RpdmUuPC9wPgotPGRpdiBjbGFzcz0iZmlndXJlIj48YSBpZD0ic3RocmVmOSIgbmFtZT0ic3RocmVmOSI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPlByb2plY3QgaW4gUGFja2FnZSBFeHBsb3JlcjwvcD4KLTxpbWcgc3JjPSJpbWcvcXVpY2tzdGFydF9wcm9qZWN0LnBuZyIgYWx0PSJQYWNrYWdlIEV4cGxvcmVyIHNob3dpbmcgdGhlIEpQQSBwcm9qZWN0LiIgdGl0bGU9IlBhY2thZ2UgRXhwbG9yZXIgc2hvd2luZyB0aGUgSlBBIHByb2plY3QuIiAvPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iZmlndXJlIiAtLT4KLTxwPk5vdyB0aGF0IHlvdSBoYXZlIGNyZWF0ZWQgYSBwcm9qZWN0IHdpdGggcGVyc2lzdGVuY2UsIHlvdSBjYW4gY29udGludWUgd2l0aCA8YSBocmVmPSJnZXR0aW5nX3N0YXJ0ZWQwMDQuaHRtI0JBQkZHRERHIj5DcmVhdGluZyBhIEphdmEgcGVyc2lzdGVudCBlbnRpdHkgd2l0aCBwZXJzaXN0ZW50IGZpZWxkczwvYT4uPC9wPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MiIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvZ2V0dGluZ19zdGFydGVkMDA0Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9nZXR0aW5nX3N0YXJ0ZWQwMDQuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlNWMyZjE5Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9nZXR0aW5nX3N0YXJ0ZWQwMDQuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsMjAwICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQxIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+Q3JlYXRpbmcgYSBKYXZhIHBlcnNpc3RlbnQgZW50aXR5IHdpdGggcGVyc2lzdGVudCBmaWVsZHM8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJDcmVhdGluZyBhIEphdmEgcGVyc2lzdGVudCBlbnRpdHkgd2l0aCBwZXJzaXN0ZW50IGZpZWxkcyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkJBQkZHRERHIiBuYW1lPSJCQUJGR0RERyI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QyIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+Q3JlYXRpbmcgYSBKYXZhIHBlcnNpc3RlbnQgZW50aXR5IHdpdGggcGVyc2lzdGVudCBmaWVsZHM8L2gxPgotPHA+PGEgaWQ9InN0aHJlZjEwIiBuYW1lPSJzdGhyZWYxMCI+PC9hPlRoaXMgcXVpY2sgc3RhcnQgc2hvd3MgaG93IHRvIGNyZWF0ZSBhIG5ldyBwZXJzaXN0ZW50IEphdmEgZW50aXR5LiBXZSB3aWxsIGNyZWF0ZSBhbiBlbnRpdHkgdG8gYXNzb2NpYXRlIHdpdGggYSBkYXRhYmFzZSB0YWJsZS4gWW91IHdpbGwgYWxzbyBuZWVkIHRvIGFkZCB0aGUgQUREUkVTUyB0YWJsZSB0byB5b3VyIGRhdGFiYXNlLjwvcD4KLTxvbCBzdGFydD0iMSI+Ci08bGk+Ci08cD5TZWxlY3QgdGhlIEpQQSBwcm9qZWN0IGluIHRoZSBOYXZpZ2F0b3Igb3IgUGFja2FnZSBFeHBsb3JlciBhbmQgdGhlbiBjbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+TmV3ICZndDsgT3RoZXI8L3NwYW4+LiBUaGUgU2VsZWN0IGEgV2l6YXJkIGRpYWxvZyBhcHBlYXJzLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5TZWxlY3QgPHNwYW4gY2xhc3M9ImJvbGQiPkVudGl0eTwvc3Bhbj4gYW5kIHRoZW4gY2xpY2sgPHNwYW4gY2xhc3M9ImJvbGQiPk5leHQ8L3NwYW4+LiBUaGUgRW50aXR5IENsYXNzIHBhZ2UgYXBwZWFycy48L3A+Ci08L2xpPgotPGxpPgotPHA+RW50ZXIgdGhlIHBhY2thZ2UgbmFtZSAoc3VjaCBhcyA8Y29kZT5xdWlja3N0YXJ0LmRlbW8ubW9kZWw8L2NvZGU+KSwgdGhlIGNsYXNzIG5hbWUgKHN1Y2ggYXMgPGNvZGU+QWRkcmVzczwvY29kZT4pIGFuZCB0aGVuIGNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5OZXh0PC9zcGFuPi4gVGhlIDxhIGhyZWY9InJlZmVyZW5jZTAwNC5odG0jQ0lBREVDSUEiPkVudGl0eSBQcm9wZXJ0aWVzIHBhZ2U8L2E+IGFwcGVhcnMsIHdoaWNoIGVuYWJsZXMgeW91IHRvIGRlZmluZSB0aGUgcGVyc2lzdGVuY2UgZmllbGRzLCB3aGljaCB5b3Ugd2lsbCBtYXAgdG8gdGhlIGNvbHVtbnMgb2YgYSBkYXRhYmFzZSB0YWJsZS48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaWQ9InN0aHJlZjExIiBuYW1lPSJzdGhyZWYxMSI+PC9hPjxhIGlkPSJzdGhyZWYxMiIgbmFtZT0ic3RocmVmMTIiPjwvYT5Vc2UgdGhlIEVudGl0eSBGaWVsZHMgZGlhbG9nIChpbnZva2VkIGJ5IGNsaWNraW5nIDxzcGFuIGNsYXNzPSJib2xkIj5BZGQ8L3NwYW4+KSB0byBhZGQgcGVyc2lzdGVuY2UgZmllbGRzIHRvIHRoZSBBZGRyZXNzIGNsYXNzOjwvcD4KLTxwcmUgeG1sOnNwYWNlPSJwcmVzZXJ2ZSIgY2xhc3M9Im9hY19ub193YXJuIj4KLXByaXZhdGUgTG9uZyBpZDsKLXByaXZhdGUgU3RyaW5nIGNpdHk7Ci1wcml2YXRlIFN0cmluZyBjb3VudHJ5OwotcHJpdmF0ZSBTdHJpbmcgc3RhdGVPclByb3ZpbmNlOwotcHJpdmF0ZSBTdHJpbmcgcG9zdGFsQ29kZTsKLXByaXZhdGUgU3RyaW5nIHN0cmVldDsKLTwvcHJlPgotPGRpdiBhbGlnbj0iY2VudGVyIj4KLTxkaXYgY2xhc3M9ImluZnRibG5vdGUiPjxiciAvPgotPHRhYmxlIGNsYXNzPSJOb3RlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGJvZHk+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiPgotPHAgY2xhc3M9Im5vdGVwMSI+Tm90ZTo8L3A+Ci1Zb3Ugd2lsbCBhbHNvIG5lZWQgdG8gYWRkIHRoZSBmb2xsb3dpbmcgY29sdW1ucyB0byB0aGUgQUREUkVTUyBkYXRhYmFzZSB0YWJsZToKLTxwcmUgeG1sOnNwYWNlPSJwcmVzZXJ2ZSIgY2xhc3M9Im9hY19ub193YXJuIj4KLU5VTUJFUigxMCwwKSBBRERSRVNTX0lEIChwcmltYXJ5IGtleSkKLVZBUkNIQVIyKDgwKSBQUk9WSU5DRQotVkFSQ0hBUjIoODApIENPVU5UUlkKLVZBUkNIQVIyKDIwKSBQX0NPREUKLVZBUkNIQVIyKDgwKSBTVFJFRVQKLVZBUkNIQVIyKDgwKSBDSVRZCi08L3ByZT4KLTxwcmUgeG1sOnNwYWNlPSJwcmVzZXJ2ZSIgY2xhc3M9Im9hY19ub193YXJuIj4KLTwvcHJlPjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibG5vdGUiIC0tPjwvZGl2PgotPC9saT4KLTxsaT4KLTxwPkNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5GaW5pc2g8L3NwYW4+LiBXaXRoIHRoZSBDcmVhdGUgSlBBIEVudGl0eSBjb21wbGV0ZWQsIEVjbGlwc2UgZGlzcGxheXMgdGhlIDxzcGFuIGNsYXNzPSJib2xkIj5BZGRyZXNzPC9zcGFuPiBlbnRpdHkgaW4gdGhlIEpQQSBTdHJ1Y3R1cmUgdmlldy48L3A+Ci08cD5BZGRyZXNzLmphdmEgaW5jbHVkZXMgdGhlIDxjb2RlPkBFbnRpdHk8L2NvZGU+IGFubm90YXRpb24sIHRoZSBwZXJzaXN0ZW5jZSBmaWVsZHMsIGFzIHdlbGwgYXMgPGNvZGU+Z2V0dGVyPC9jb2RlPiBhbmQgPGNvZGU+c2V0dGVyPC9jb2RlPiBtZXRob2RzIGZvciBlYWNoIG9mIHRoZSBmaWVsZHMuPC9wPgotPC9saT4KLTwvb2w+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWYxMyIgbmFtZT0ic3RocmVmMTMiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWluZmlndXJlIj5BZGRyZXNzIEVudGl0eSBpbiBBZGRyZXNzLmphdmE8L3A+Ci08aW1nIHNyYz0iaW1nL2phdmFfZWRpdG9yX2FkZHJlc3MucG5nIiBhbHQ9IkphdmEgZWRpdG9yIHdpdGggdGhlIEFkZHJlc3MgZW50aXR5LiIgdGl0bGU9IkphdmEgZWRpdG9yIHdpdGggdGhlIEFkZHJlc3MgZW50aXR5LiIgLz48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImZpZ3VyZSIgLS0+Ci08cD5FY2xpcHNlIGFsc28gZGlzcGxheXMgdGhlIDxzcGFuIGNsYXNzPSJib2xkIj5BZGRyZXNzPC9zcGFuPiBlbnRpdHkgaW4gdGhlIEpQQSBTdHJ1Y3R1cmUgdmlldzo8L3A+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWYxNCIgbmFtZT0ic3RocmVmMTQiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWluZmlndXJlIj5BZGRyZXNzIEVudGl0eSBpbiB0aGUgSlBBIFN0cnVjdHVyZSBWaWV3PC9wPgotPGltZyBzcmM9ImltZy9hZGRyZXNzX2phdmFfSlBBX3N0cnVjdHVyZV9xdWlja3N0YXJ0LnBuZyIgYWx0PSJBZGRyZXNzLmphdmEgaW4gdGhlIEpQQSBTdHJ1Y3R1cmUgVmlldy4iIHRpdGxlPSJBZGRyZXNzLmphdmEgaW4gdGhlIEpQQSBTdHJ1Y3R1cmUgVmlldy4iIC8+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJmaWd1cmUiIC0tPgotPG9sIHN0YXJ0PSIxIj4KLTxsaT4KLTxwPlNlbGVjdCB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtYWN0aW9uIj5BZGRyZXNzPC9zcGFuPiBjbGFzcyBpbiB0aGUgUGFja2FnZSBFeHBsb3JlciB2aWV3LjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5JbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpQQSBEZXRhaWxzPC9zcGFuPiB2aWV3LCBub3RpY2UgdGhhdCBEYWxpIGhhcyBhdXRvbWF0aWNhbGx5IGFzc29jaWF0ZWQgdGhlIEFERFJFU1MgZGF0YWJhc2UgdGFibGUgd2l0aCB0aGUgZW50aXR5IGJlY2F1c2UgdGhleSBhcmUgbmFtZWQgaWRlbnRpY2FsbHkuPC9wPgotPGRpdiBhbGlnbj0iY2VudGVyIj4KLTxkaXYgY2xhc3M9ImluZnRibG5vdGUiPjxiciAvPgotPHRhYmxlIGNsYXNzPSJOb3RlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGJvZHk+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiPgotPHAgY2xhc3M9Im5vdGVwMSI+Tm90ZTo8L3A+Ci1EZXBlbmRpbmcgb24geW91ciBkYXRhYmFzZSBjb25uZWN0aW9uIHR5cGUsIHlvdSBtYXkgbmVlZCB0byBzcGVjaWZ5IHRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+U2NoZW1hPC9zcGFuPi48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0Ymxub3RlIiAtLT48L2Rpdj4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9InN0aHJlZjE1IiBuYW1lPSJzdGhyZWYxNSI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPkpQQSBEZXRhaWxzIFZpZXcgZm9yIEFkZHJlc3MgRW50aXR5PC9wPgotPGltZyBzcmM9ImltZy9hZGRyZXNzLmphdmFfanBhX2RldGFpbHMucG5nIiBhbHQ9IkFkZHJlc3MuamF2YSBpbiB0aGUgSlBBIERldGFpbHMgdmlldy4iIHRpdGxlPSJBZGRyZXNzLmphdmEgaW4gdGhlIEpQQSBEZXRhaWxzIHZpZXcuIiAvPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iZmlndXJlIiAtLT48L2xpPgotPC9vbD4KLTxkaXYgYWxpZ249ImNlbnRlciI+Ci08ZGl2IGNsYXNzPSJpbmZ0Ymxub3RlYWxzbyI+PGJyIC8+Ci08dGFibGUgY2xhc3M9Ik5vdGVBbHNvIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGJvZHk+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiPgotPHAgY2xhc3M9Im5vdGVwMSI+VGlwOjwvcD4KLUFmdGVyIGFzc29jaWF0aW5nIHRoZSBlbnRpdHkgd2l0aCB0aGUgZGF0YWJhc2UgdGFibGUsIHlvdSBzaG91bGQgdXBkYXRlIHRoZSA8Y29kZT5wZXJzaXN0ZW5jZS54bWw8L2NvZGU+IGZpbGUgdG8gaW5jbHVkZSB0aGlzIEpQQSBlbnRpdHkuCi08cD5SaWdodC1jbGljayB0aGUgPGNvZGU+cGVyc2lzdGVuY2UueG1sPC9jb2RlPiBmaWxlIGluIHRoZSBQYWNrYWdlIEV4cGxvcmVyIGFuZCBzZWxlY3QgPHNwYW4gY2xhc3M9ImJvbGQiPkpQQSBUb29scyAmZ3Q7IFN5bmNocm9uaXplIENsYXNzZXM8L3NwYW4+LiBEYWxpIGFkZHMgdGhlIGZvbGxvd2luZyB0byB0aGUgPGNvZGU+cGVyc2lzdGVuY2UueG1sPC9jb2RlPiBmaWxlOjwvcD4KLTxwPjxjb2RlPiZsdDtjbGFzcyZndDtxdWlja3N0YXJ0LmRlbW8ubW9kZWwuQWRkcmVzcyZsdDsvY2xhc3MmZ3Q7PC9jb2RlPjwvcD4KLTwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibG5vdGVhbHNvIiAtLT48L2Rpdj4KLTxwPk5vdyB3ZSBhcmUgcmVhZHkgdG8gbWFwIGVhY2ggZmllbGRzIGluIHRoZSBBZGRyZXNzIGNsYXNzIHRvIGEgY29sdW1uIGluIHRoZSBkYXRhYmFzZSB0YWJsZS48L3A+Ci08b2wgc3RhcnQ9IjEiPgotPGxpPgotPHA+U2VsZWN0IHRoZSA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC1hY3Rpb24iPmlkPC9zcGFuPiBmaWVsZCBpbiB0aGUgSlBBIERldGFpbHMgdmlldy48L3A+Ci08L2xpPgotPGxpPgotPHA+UmlnaHQgY2xpY2sgaWQgYW5kIHRoZW4gc2VsZWN0IDxzcGFuIGNsYXNzPSJib2xkIj5NYXAgQXMgJmd0OyBpZDwvc3Bhbj4uPC9wPgotPC9saT4KLTxsaT4KLTxwPkluIHRoZSBKUEEgRGV0YWlscyB2aWV3LCBzZWxlY3QgPHNwYW4gY2xhc3M9ImJvbGQiPkFERFJFU1NfSUQ8L3NwYW4+IGluIHRoZSBOYW1lIGZpZWxkOjwvcD4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9InN0aHJlZjE2IiBuYW1lPSJzdGhyZWYxNiI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPkpQQSBEZXRhaWxzIFZpZXcgZm9yIHRoZSBhZGRyZXNzSWQgRmllbGQ8L3A+Ci08aW1nIHNyYz0iaW1nL2FkZHJlc3NfaWRfZGV0YWlsc19xdWlja3N0YXJ0LnBuZyIgYWx0PSJUaGUgSlBBIERldGFpbHMgdmlldyBmb3IgdGhlIEFkZHJlc3MgZW50aXR5JnJzcXVvO3MgaWQgYXR0cmlidXRlLiIgdGl0bGU9IlRoZSBKUEEgRGV0YWlscyB2aWV3IGZvciB0aGUgQWRkcmVzcyBlbnRpdHkmcnNxdW87cyBpZCBhdHRyaWJ1dGUuIiAvPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iZmlndXJlIiAtLT4KLTxwPkVjbGlwc2UgYWRkcyB0aGUgZm9sbG93aW5nIGFubm90YXRpb25zIHRvIHRoZSBBZGRyZXNzIGVudGl0eTo8L3A+Ci08cHJlIHhtbDpzcGFjZT0icHJlc2VydmUiIGNsYXNzPSJvYWNfbm9fd2FybiI+Ci1ASWQKLUBDb2x1bW4obmFtZT0iQUREUkVTU19JRCIpCi08L3ByZT48L2xpPgotPGxpPgotPHA+TWFwIGVhY2ggb2YgdGhlIGZvbGxvd2luZyBmaWVsZHMgKGFzIDxzcGFuIGNsYXNzPSJib2xkIj5CYXNpYzwvc3Bhbj4gbWFwcGluZ3MpIHRvIHRoZSBhcHByb3ByaWF0ZSBkYXRhYmFzZSBjb2x1bW46PC9wPgotPGRpdiBjbGFzcz0iaW5mdGJsaHJ1bGVpbmZvcm1hbCI+Ci08dGFibGUgY2xhc3M9IkhSdWxlSW5mb3JtYWwiIHRpdGxlPSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgbWFwcGluZ3MgZm9yIGVhY2ggb2YgdGhlIGZpZWxkcyBpbiB0aGUgQWRkcmVzcyBlbnRpdHkuIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgbWFwcGluZ3MgZm9yIGVhY2ggb2YgdGhlIGZpZWxkcyBpbiB0aGUgQWRkcmVzcyBlbnRpdHkuIiBkaXI9Imx0ciIgYm9yZGVyPSIxIiB3aWR0aD0iMTAwJSIgZnJhbWU9ImJvcmRlciIgcnVsZXM9ImFsbCIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0aGVhZD4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzEtdDgiPkZpZWxkPC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMyLXQ4Ij5NYXAgQXM8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzMtdDgiPkRhdGFiYXNlIENvbHVtbjwvdGg+Ci08L3RyPgotPC90aGVhZD4KLTx0Ym9keT4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjJjMS10OCIgaGVhZGVycz0icjFjMS10OCI+Y2l0eTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDggcjFjMi10OCI+QmFzaWM8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQ4IHIxYzMtdDgiPkNJVFk8L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10OCIgaGVhZGVycz0icjFjMS10OCI+Y291bnRyeTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDggcjFjMi10OCI+QmFzaWM8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQ4IHIxYzMtdDgiPkNPVU5UUlk8L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjRjMS10OCIgaGVhZGVycz0icjFjMS10OCI+cG9zdGFsQ29kZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDggcjFjMi10OCI+QmFzaWM8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQ4IHIxYzMtdDgiPlBfQ09ERTwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNWMxLXQ4IiBoZWFkZXJzPSJyMWMxLXQ4Ij5wcm92aW5jZU9yU3RhdGU8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQ4IHIxYzItdDgiPkJhc2ljPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10OCByMWMzLXQ4Ij5QUk9WSU5DRTwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNmMxLXQ4IiBoZWFkZXJzPSJyMWMxLXQ4Ij5zdHJlZXQ8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQ4IHIxYzItdDgiPkJhc2ljPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10OCByMWMzLXQ4Ij5TVFJFRVQ8L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0YmxocnVsZWluZm9ybWFsIiAtLT48L2xpPgotPC9vbD4KLTxwPkRhbGkgYXV0b21hdGljYWxseSBtYXBzIHNvbWUgZmllbGRzIHRvIHRoZSBjb3JyZWN0IGRhdGFiYXNlIGNvbHVtbiAoc3VjaCBhcyB0aGUgY2l0eSBmaWVsZCB0byB0aGUgQ2l0eSBjb2x1bW4pIGlmIHRoZSBuYW1lcyBhcmUgaWRlbnRpY2FsLjwvcD4KLTwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDIiIC0tPgotPCEtLSBjbGFzcz0ic2VjdDEiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9hZGRyZXNzLmphdmFfanBhX2RldGFpbHMucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9hZGRyZXNzLmphdmFfanBhX2RldGFpbHMucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlZDI3YTVjLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvYWRkcmVzcy5qYXZhX2pwYV9kZXRhaWxzLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvYWRkcmVzc19pZF9kZXRhaWxzX3F1aWNrc3RhcnQucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9hZGRyZXNzX2lkX2RldGFpbHNfcXVpY2tzdGFydC5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDdlZjQwY2YuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9hZGRyZXNzX2lkX2RldGFpbHNfcXVpY2tzdGFydC5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2FkZHJlc3NfamF2YV9KUEFfc3RydWN0dXJlX3F1aWNrc3RhcnQucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9hZGRyZXNzX2phdmFfSlBBX3N0cnVjdHVyZV9xdWlja3N0YXJ0LnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMWFmNTFhOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2FkZHJlc3NfamF2YV9KUEFfc3RydWN0dXJlX3F1aWNrc3RhcnQucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9jaGFuZ2VfY29ubmVjdGlvbl9wcm9maWxlLnBuZyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvY2hhbmdlX2Nvbm5lY3Rpb25fcHJvZmlsZS5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQ2YWIwNWUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9jaGFuZ2VfY29ubmVjdGlvbl9wcm9maWxlLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvY29sdW1uX3N1cHBvcnRfbmV3LnBuZyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvY29sdW1uX3N1cHBvcnRfbmV3LnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODcxNmU4Yi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2NvbHVtbl9zdXBwb3J0X25ldy5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2NvbnZlcnRfamF2YV9wcm9qZWN0X25ldy5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2NvbnZlcnRfamF2YV9wcm9qZWN0X25ldy5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDkxY2RhNmUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9jb252ZXJ0X2phdmFfcHJvamVjdF9uZXcucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9jcmVhdGVfanBhX2VudGl0eV9uZXcucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9jcmVhdGVfanBhX2VudGl0eV9uZXcucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2OWM3OGE1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvY3JlYXRlX2pwYV9lbnRpdHlfbmV3LnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvY3JlYXRlX2pwYV9lbnRpdHlfd2l6YXJkLnBuZyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvY3JlYXRlX2pwYV9lbnRpdHlfd2l6YXJkLnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjJjMGE2Yy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2NyZWF0ZV9qcGFfZW50aXR5X3dpemFyZC5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2NyZWF0ZV9qcGFfZmllbGRzLnBuZyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvY3JlYXRlX2pwYV9maWVsZHMucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1MmE3ZmFiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvY3JlYXRlX2pwYV9maWVsZHMucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9kZXRhaWxzX2VudGl0eW1hcHBpbmdzLnBuZyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvZGV0YWlsc19lbnRpdHltYXBwaW5ncy5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDViZDQ4ODUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9kZXRhaWxzX2VudGl0eW1hcHBpbmdzLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvZW50ZXJpbmdfcXVlcnlfbmV3LnBuZyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvZW50ZXJpbmdfcXVlcnlfbmV3LnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOThlYzBhYy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2VudGVyaW5nX3F1ZXJ5X25ldy5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2Vycm9yX3NhbXBsZS5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2Vycm9yX3NhbXBsZS5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDNhNDk2NDYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9lcnJvcl9zYW1wbGUucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9nZW5lcmF0ZV9lbnRpdGllcy5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2dlbmVyYXRlX2VudGl0aWVzLnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTNjYjIyYi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2dlbmVyYXRlX2VudGl0aWVzLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvaW5oZXJpdGFuY2Vfam9pbi5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2luaGVyaXRhbmNlX2pvaW4ucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyMmI2ODc1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvaW5oZXJpdGFuY2Vfam9pbi5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2luaGVyaXRhbmNlX3NpbmdsZS5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2luaGVyaXRhbmNlX3NpbmdsZS5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDMxNDY0ODIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9pbmhlcml0YW5jZV9zaW5nbGUucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9pbmhlcml0YW5jZV90YWIucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9pbmhlcml0YW5jZV90YWIucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhOWQ3MjFmLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvaW5oZXJpdGFuY2VfdGFiLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvamF2YV9lZGl0b3JfYWRkcmVzcy5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2phdmFfZWRpdG9yX2FkZHJlc3MucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmZjdlYWE2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvamF2YV9lZGl0b3JfYWRkcmVzcy5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2pwYV93aXphcmRfY3JlYXRlX2ZpZWxkcy5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL2pwYV93aXphcmRfY3JlYXRlX2ZpZWxkcy5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDMwNTUwZWEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9qcGFfd2l6YXJkX2NyZWF0ZV9maWVsZHMucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9tYXBwZWRfZW50aXR5X3R5cGVfbGluay5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL21hcHBlZF9lbnRpdHlfdHlwZV9saW5rLnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDI2NGQwOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL21hcHBlZF9lbnRpdHlfdHlwZV9saW5rLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbWFwcGluZ19maWxlX25ldy5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL21hcHBpbmdfZmlsZV9uZXcucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzMzU1NzQxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbWFwcGluZ19maWxlX25ldy5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL21hcHBpbmdfdHlwZV9zZWxlY3Rpb25fZW1iZWQucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9tYXBwaW5nX3R5cGVfc2VsZWN0aW9uX2VtYmVkLnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZmIzZDFiMi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL21hcHBpbmdfdHlwZV9zZWxlY3Rpb25fZW1iZWQucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9tYXBwaW5nX3R5cGVfc2VsZWN0aW9uX2VudGl0eS5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL21hcHBpbmdfdHlwZV9zZWxlY3Rpb25fZW50aXR5LnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggN2E2NTNkYi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL21hcHBpbmdfdHlwZV9zZWxlY3Rpb25fZW50aXR5LnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbWFwcGluZ190eXBlX3NlbGVjdGlvbl9zdXBlcmNsYXNzLnBuZyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbWFwcGluZ190eXBlX3NlbGVjdGlvbl9zdXBlcmNsYXNzLnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmVmNTQzNy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL21hcHBpbmdfdHlwZV9zZWxlY3Rpb25fc3VwZXJjbGFzcy5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ld19pY29uX2Jhc2ljbWFwcGluZ3MucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9iYXNpY21hcHBpbmdzLnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMWIwYjdmZi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ld19pY29uX2Jhc2ljbWFwcGluZ3MucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9lbWJlZGRhYmxlZW50aXR5bWFwcGluZy5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ld19pY29uX2VtYmVkZGFibGVlbnRpdHltYXBwaW5nLnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDgyOTRlZC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ld19pY29uX2VtYmVkZGFibGVlbnRpdHltYXBwaW5nLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2ljb25fZW1iZWRkZWRpZG1hcHBpbmcucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9lbWJlZGRlZGlkbWFwcGluZy5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGFiZTlkYzguLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9lbWJlZGRlZGlkbWFwcGluZy5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ld19pY29uX2VtYmVkZGVkbWFwcGluZy5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ld19pY29uX2VtYmVkZGVkbWFwcGluZy5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQ0ZDUyYjguLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9lbWJlZGRlZG1hcHBpbmcucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9pZG1hcHBpbmcucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9pZG1hcHBpbmcucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmZGVmYjVkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2ljb25faWRtYXBwaW5nLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2ljb25fbWFueXRvbWFueW1hcHBpbmcucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9tYW55dG9tYW55bWFwcGluZy5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGViODAyMmUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9tYW55dG9tYW55bWFwcGluZy5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ld19pY29uX21hbnl0b29uZW1hcHBpbmcucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9tYW55dG9vbmVtYXBwaW5nLnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggY2NhY2MxOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ld19pY29uX21hbnl0b29uZW1hcHBpbmcucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9tYXBwZWRlbnRpdHkucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9tYXBwZWRlbnRpdHkucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzOThlYTJjLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2ljb25fbWFwcGVkZW50aXR5LnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2ljb25fbWFwcGVkc3VwZXJjbGFzcy5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ld19pY29uX21hcHBlZHN1cGVyY2xhc3MucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmYzk3Y2ViLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2ljb25fbWFwcGVkc3VwZXJjbGFzcy5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ld19pY29uX29uZXRvbWFueW1hcHBpbmcucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9vbmV0b21hbnltYXBwaW5nLnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNWRkYzk4OS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ld19pY29uX29uZXRvbWFueW1hcHBpbmcucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9vbmV0b29uZW1hcHBpbmcucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfaWNvbl9vbmV0b29uZW1hcHBpbmcucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3NGQ5YmJkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2ljb25fb25ldG9vbmVtYXBwaW5nLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2ljb25fdHJhbnNpZW50bWFwcGluZy5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ld19pY29uX3RyYW5zaWVudG1hcHBpbmcucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3NTA0ODhmLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2ljb25fdHJhbnNpZW50bWFwcGluZy5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ld19pY29uX3ZlcnNpb25tYXBwaW5nLnBuZyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2ljb25fdmVyc2lvbm1hcHBpbmcucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhODczNzEyLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2ljb25fdmVyc2lvbm1hcHBpbmcucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfanBhX2ZhY2V0X3Rhc2sucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfanBhX2ZhY2V0X3Rhc2sucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkN2ZmY2RjLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2pwYV9mYWNldF90YXNrLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2pwYV9wZXJzcGVjdGl2ZV9idXR0b24ucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfanBhX3BlcnNwZWN0aXZlX2J1dHRvbi5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDA3NDI1YWQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZXdfanBhX3BlcnNwZWN0aXZlX2J1dHRvbi5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ld19qcGFfcHJvamVjdF90YXNrLnBuZyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2pwYV9wcm9qZWN0X3Rhc2sucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2MWU3MWJkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmV3X2pwYV9wcm9qZWN0X3Rhc2sucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZ3JlbGMucG5nIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZ3JlbGMucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4ODM4MWE1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmdyZWxjLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmdyZWxyLnBuZyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvbmdyZWxyLnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNGJiYzc0NC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ncmVsci5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ncmVsdC5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL25ncmVsdC5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDYwYWYyMWYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9uZ3JlbHQucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9vcGVuX3BlcnNpc3RlbmNlX2VkaXRvci5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL29wZW5fcGVyc2lzdGVuY2VfZWRpdG9yLnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNTY5MTFmZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL29wZW5fcGVyc2lzdGVuY2VfZWRpdG9yLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvcGVyc2lzdGVuY2VfZWRpdG9yX25ldy5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL3BlcnNpc3RlbmNlX2VkaXRvcl9uZXcucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2YWVmYWU0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvcGVyc2lzdGVuY2VfZWRpdG9yX25ldy5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL3BlcnNpc3RlbmNlX291dGxpbmVfdmlldy5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL3BlcnNpc3RlbmNlX291dGxpbmVfdmlldy5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDc2OWFhODIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9wZXJzaXN0ZW5jZV9vdXRsaW5lX3ZpZXcucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9wZXJzaXN0ZW5jZV94bWxfZWRpdG9yLnBuZyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvcGVyc2lzdGVuY2VfeG1sX2VkaXRvci5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGIxNGRjMTUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9wZXJzaXN0ZW5jZV94bWxfZWRpdG9yLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvcHJvamVjdF9wcm9wZXJ0aWVzX3Rhc2tzLnBuZyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvcHJvamVjdF9wcm9wZXJ0aWVzX3Rhc2tzLnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOGY2MzEwYy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL3Byb2plY3RfcHJvcGVydGllc190YXNrcy5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL3F1aWNrc3RhcnRfcHJvamVjdC5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL3F1aWNrc3RhcnRfcHJvamVjdC5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGM3YzA2NjQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9xdWlja3N0YXJ0X3Byb2plY3QucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9zZWNvbmRhcnlfdGFibGVzLnBuZyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvc2Vjb25kYXJ5X3RhYmxlcy5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGU2YTkxNTkuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9zZWNvbmRhcnlfdGFibGVzLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvc2VsZWN0X2Ffd2l6YXJkX2VudGl0eS5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL3NlbGVjdF9hX3dpemFyZF9lbnRpdHkucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyY2ViZTkwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvc2VsZWN0X2Ffd2l6YXJkX2VudGl0eS5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL3NlbGVjdF9hX3dpemFyZF9qcGFfcHJvamVjdC5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL3NlbGVjdF9hX3dpemFyZF9qcGFfcHJvamVjdC5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDE4MjM1MDIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9zZWxlY3RfYV93aXphcmRfanBhX3Byb2plY3QucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy9zZWxlY3RfYV93aXphcmRfbWFwcGluZy5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL3NlbGVjdF9hX3dpemFyZF9tYXBwaW5nLnBuZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODg2Mjc3MC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL3NlbGVjdF9hX3dpemFyZF9tYXBwaW5nLnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvc3luY2hvcm5pemVfY2xhc3Nlcy5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL3N5bmNob3JuaXplX2NsYXNzZXMucG5nCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiZWRlNjNiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvc3luY2hvcm5pemVfY2xhc3Nlcy5wbmcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL3RhYmxlX2VudGl0eS5wbmcgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW1nL3RhYmxlX2VudGl0eS5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDFhYTFkYmUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy90YWJsZV9lbnRpdHkucG5nCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy90YXNrX2VudGVyaW5nX3F1ZXJ5LnBuZyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbWcvdGFza19lbnRlcmluZ19xdWVyeS5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDk4ZWMwYWMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2ltZy90YXNrX2VudGVyaW5nX3F1ZXJ5LnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbmRleC54bWwgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvaW5kZXgueG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMjNjNDliLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9pbmRleC54bWwKKysrIC9kZXYvbnVsbApAQCAtMSw1NDQgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0nMS4wJyBlbmNvZGluZz0naXNvLTg4NTktMSc/PgotPGluZGV4IHZlcnNpb249IjEuMCI+Ci0gIDxlbnRyeSBrZXl3b3JkPSJAQmFzaWMiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJCYXNpYyBtYXBwaW5nIj48dG9waWMgaHJlZj0idGFza3MwMTAuaHRtI3N0aHJlZjk5IiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJAQ29sdW1uIj4KLSAgICA8ZW50cnkga2V5d29yZD0iR2VuZXJhbCBpbmZvcm1hdGlvbiI+PHRvcGljIGhyZWY9InJlZl9tYXBwaW5nX2dlbmVyYWwuaHRtI3N0aHJlZjE5MyIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iQERpc2NyaW1pbmF0b3JDb2x1bW4iPgotICAgIDxlbnRyeSBrZXl3b3JkPSJTcGVjaWZ5aW5nIGVudGl0eSBpbmhlcml0YW5jZSI+PHRvcGljIGhyZWY9InRhc2tfaW5oZXJpdGFuY2UuaHRtI3N0aHJlZjgzIiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJARGlzY3JpbWluYXRvclZhbHVlIj4KLSAgICA8ZW50cnkga2V5d29yZD0iU3BlY2lmeWluZyBlbnRpdHkgaW5oZXJpdGFuY2UiPjx0b3BpYyBocmVmPSJ0YXNrX2luaGVyaXRhbmNlLmh0bSNzdGhyZWY4NSIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iQEVtYmVkZGFibGUiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJFbWJlZGRhYmxlIj48dG9waWMgaHJlZj0idGFza3MwMDcuaHRtI3N0aHJlZjY4IiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJARW1iZWRkZWQiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJFbWJlZGRlZCBtYXBwaW5nIj48dG9waWMgaHJlZj0idGFza3MwMTEuaHRtI3N0aHJlZjEwMyIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iQEVtYmVkZGVkSWQiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJFbWJlZGRlZCBJRCBtYXBwaW5nIj48dG9waWMgaHJlZj0idGFza3MwMTIuaHRtI3N0aHJlZjEwNyIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iQEVudGl0eSI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkVudGl0eSI+PHRvcGljIGhyZWY9InRhc2tzMDA2Lmh0bSNzdGhyZWY2MSIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iQEVudW1lcmF0ZWQiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJHZW5lcmFsIGluZm9ybWF0aW9uIj48dG9waWMgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jc3RocmVmMjAzIiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJAR2VuZXJhdGVkVmFsdWUiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJQcmltYXJ5IEtleSBHZW5lcmF0aW9uIGluZm9ybWF0aW9uIj48dG9waWMgaHJlZj0icmVmX3ByaW1hcnlfa2V5Lmh0bSNzdGhyZWYyMTEiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9IkBJZCI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IklEIG1hcHBpbmciPjx0b3BpYyBocmVmPSJ0YXNrczAxMy5odG0jc3RocmVmMTExIiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJASW5oZXJpdGFuY2UiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJTcGVjaWZ5aW5nIGVudGl0eSBpbmhlcml0YW5jZSI+PHRvcGljIGhyZWY9InRhc2tfaW5oZXJpdGFuY2UuaHRtI3N0aHJlZjgxIiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJASm9pbkNvbHVtbiI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9Ik1hbnktdG8tb25lIG1hcHBpbmciPjx0b3BpYyBocmVmPSJ0YXNrczAxNS5odG0jc3RocmVmMTIyIiAvPjwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9Ik9uZS10by1vbmUgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDE3Lmh0bSNzdGhyZWYxMzIiIC8+PC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0iSm9pbiBUYWJsZSBJbmZvcm1hdGlvbiI+PHRvcGljIGhyZWY9InJlZmVyZW5jZTAxNC5odG0jc3RocmVmMjA4IiAvPjwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkpvaW4gQ29sdW1ucyBJbmZvcm1hdGlvbiI+PHRvcGljIGhyZWY9InJlZmVyZW5jZTAxNS5odG0jc3RocmVmMjEwIiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJATG9iIj4KLSAgICA8ZW50cnkga2V5d29yZD0iR2VuZXJhbCBpbmZvcm1hdGlvbiI+PHRvcGljIGhyZWY9InJlZl9tYXBwaW5nX2dlbmVyYWwuaHRtI3N0aHJlZjE5OCIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iQE1hbnlUb01hbnkiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJNYW55LXRvLW1hbnkgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDE0Lmh0bSNzdGhyZWYxMTUiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9IkBNYW55VG9PbmUiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJNYW55LXRvLW9uZSBtYXBwaW5nIj48dG9waWMgaHJlZj0idGFza3MwMTUuaHRtI3N0aHJlZjEyMCIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iQE1hcHBlZFN1cGVyY2xhc3MiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJNYXBwZWQgc3VwZXJjbGFzcyI+PHRvcGljIGhyZWY9InRhc2tzMDA4Lmh0bSNzdGhyZWY3NSIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iQE5hbWVkUXVlcnkiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJDcmVhdGluZyBOYW1lZCBRdWVyaWVzIj48dG9waWMgaHJlZj0idGFza3MwMDkuaHRtI3N0aHJlZjk1IiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJAT25lVG9NYW55Ij4KLSAgICA8ZW50cnkga2V5d29yZD0iT25lLXRvLW1hbnkgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDE2Lmh0bSNzdGhyZWYxMjUiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9IkBPbmVUb09uZSI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9Ik9uZS10by1vbmUgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDE3Lmh0bSNzdGhyZWYxMjkiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9IkBPcmRlckJ5Ij4KLSAgICA8ZW50cnkga2V5d29yZD0iR2VuZXJhbCBpbmZvcm1hdGlvbiI+PHRvcGljIGhyZWY9InJlZl9tYXBwaW5nX2dlbmVyYWwuaHRtI3N0aHJlZjIwNiIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iQFNlcXVlbmNlR2VuZXJhdG9yIj4KLSAgICA8ZW50cnkga2V5d29yZD0iUHJpbWFyeSBLZXkgR2VuZXJhdGlvbiBpbmZvcm1hdGlvbiI+PHRvcGljIGhyZWY9InJlZl9wcmltYXJ5X2tleS5odG0jc3RocmVmMjEzIiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJAVGVtcG9yYWwiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJHZW5lcmFsIGluZm9ybWF0aW9uIj48dG9waWMgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jc3RocmVmMjAwIiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJAVHJhbnNpZW50Ij4KLSAgICA8ZW50cnkga2V5d29yZD0iVHJhbnNpZW50IG1hcHBpbmciPjx0b3BpYyBocmVmPSJ0YXNrczAxOC5odG0jc3RocmVmMTM1IiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJAVmVyc2lvbiI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IlZlcnNpb24gbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDE5Lmh0bSNzdGhyZWYxMzkiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9ImFyY2hpdGVjdHVyZSBvZiBEYWxpIGZlYXR1cmUiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJEYWxpIERldmVsb3BlciBEb2N1bWVudGF0aW9uIj48dG9waWMgaHJlZj0icmVmZXJlbmNlMDM0Lmh0bSNzdGhyZWYyNDciIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9ImF0dHJpYnV0ZSBvdmVycmlkZXMiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJBdHRyaWJ1dGUgb3ZlcnJpZGVzIj48dG9waWMgaHJlZj0icmVmZXJlbmNlMDEwLmh0bSNzdGhyZWYxODAiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9IkF0dHJpYnV0ZSBPdmVycmlkZXMgLSBpbiBKYXZhIERldGFpbHMgdmlldyI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkF0dHJpYnV0ZSBvdmVycmlkZXMiPjx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMTAuaHRtI3N0aHJlZjE4MiIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iYXR0cmlidXRlcyI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkpQQSBEZXRhaWxzIHZpZXciPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IkpQQSBEZXRhaWxzIHZpZXcgKGZvciBhdHRyaWJ1dGVzKSI+PHRvcGljIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0jc3RocmVmMTkyIiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0ibWFwcGluZyI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iVW5kZXJzdGFuZGluZyBPUiBtYXBwaW5ncyI+PHRvcGljIGhyZWY9ImNvbmNlcHRfbWFwcGluZy5odG0jc3RocmVmMjAiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iYmFzaWMgbWFwcGluZyI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkBCYXNpYyI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iQmFzaWMgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDEwLmh0bSNzdGhyZWYxMDAiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJhYm91dCI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iQmFzaWMgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDEwLmh0bSNzdGhyZWY5OCIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IihTZWUgYWxzbyBtYXBwaW5ncykiPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJjbGFzc2VzIj4KLSAgICA8ZW50cnkga2V5d29yZD0iYWRkaW5nIHBlcnNpc3RlbmNlIHRvIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJBZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBjbGFzcyI+PHRvcGljIGhyZWY9InRhc2tfYWRkX3BlcnNpc3RlbmNlLmh0bSNzdGhyZWY1NiIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImVtYmVkZGFibGUiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IkVtYmVkZGFibGUiPjx0b3BpYyBocmVmPSJ0YXNrczAwNy5odG0jc3RocmVmNjciIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJlbnRpdHkiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IkVudGl0eSI+PHRvcGljIGhyZWY9InRhc2tzMDA2Lmh0bSNzdGhyZWY1OSIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9Im1hcHBlZCBzdXBlcmNsYXNzIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJNYXBwZWQgc3VwZXJjbGFzcyI+PHRvcGljIGhyZWY9InRhc2tzMDA4Lmh0bSNzdGhyZWY3MyIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9InN5bmNocm9uaXppbmciPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IlN5bmNocm9uaXppbmcgY2xhc3NlcyI+PHRvcGljIGhyZWY9InRhc2tzMDAzLmh0bSNzdGhyZWY0MyIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJjb2x1bW5zIj4KLSAgICA8ZW50cnkga2V5d29yZD0iZGlzY3JpbWluYXRvciI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iU3BlY2lmeWluZyBlbnRpdHkgaW5oZXJpdGFuY2UiPjx0b3BpYyBocmVmPSJ0YXNrX2luaGVyaXRhbmNlLmh0bSNzdGhyZWY4NCIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImpvaW4iPgotICAgICAgPGVudHJ5IGtleXdvcmQ9Ik1hbnktdG8tb25lIG1hcHBpbmciPjx0b3BpYyBocmVmPSJ0YXNrczAxNS5odG0jc3RocmVmMTIxIiAvPjwvZW50cnk+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iT25lLXRvLW9uZSBtYXBwaW5nIj48dG9waWMgaHJlZj0idGFza3MwMTcuaHRtI3N0aHJlZjEzMSIgLz48L2VudHJ5PgotICAgICAgPGVudHJ5IGtleXdvcmQ9IkpvaW4gVGFibGUgSW5mb3JtYXRpb24iPjx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMTQuaHRtI3N0aHJlZjIwNyIgLz48L2VudHJ5PgotICAgICAgPGVudHJ5IGtleXdvcmQ9IkpvaW4gQ29sdW1ucyBJbmZvcm1hdGlvbiI+PHRvcGljIGhyZWY9InJlZmVyZW5jZTAxNS5odG0jc3RocmVmMjA5IiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0ibWFwcGluZyB0byI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iR2VuZXJhbCBpbmZvcm1hdGlvbiI+PHRvcGljIGhyZWY9InJlZl9tYXBwaW5nX2dlbmVyYWwuaHRtI3N0aHJlZjE5NCIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9InZhbHVlIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJTcGVjaWZ5aW5nIGVudGl0eSBpbmhlcml0YW5jZSI+PHRvcGljIGhyZWY9InRhc2tfaW5oZXJpdGFuY2UuaHRtI3N0aHJlZjg2IiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9ImRhdGFiYXNlIHRhYmxlcyI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImdlbmVyYXRpbmcgZW50aXRpZXMgZnJvbSI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iR2VuZXJhdGluZyBlbnRpdGllcyBmcm9tIHRhYmxlcyI+PHRvcGljIGhyZWY9InRhc2tzMDIwLmh0bSNzdGhyZWYxNDUiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iZGF0YWJhc2UgLSBwZXJzaXN0ZW5jZSI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImNvbm5lY3Rpb24iPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IlByb2plY3QgUHJvcGVydGllcyBwYWdlIC0gSlBBIE9wdGlvbnMiPjx0b3BpYyBocmVmPSJyZWZfcHJvamVjdF9wcm9wZXJ0aWVzLmh0bSNzdGhyZWYyMzYiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJzY2hlbWEiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IlByb2plY3QgUHJvcGVydGllcyBwYWdlIC0gSlBBIE9wdGlvbnMiPjx0b3BpYyBocmVmPSJyZWZfcHJvamVjdF9wcm9wZXJ0aWVzLmh0bSNzdGhyZWYyMzgiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iZGV2ZWxvcGVyIGRvY3VtZW50YXRpb24gLSBEYWxpIj4KLSAgICA8ZW50cnkga2V5d29yZD0iRGFsaSBEZXZlbG9wZXIgRG9jdW1lbnRhdGlvbiI+PHRvcGljIGhyZWY9InJlZmVyZW5jZTAzNC5odG0jc3RocmVmMjQ2IiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJlYWdlciBmZXRjaCI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkdlbmVyYWwgaW5mb3JtYXRpb24iPjx0b3BpYyBocmVmPSJyZWZfbWFwcGluZ19nZW5lcmFsLmh0bSNzdGhyZWYxOTYiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9ImVtYmVkZGFibGUgY2xhc3MiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJARW1iZWRkYWJsZSI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iRW1iZWRkYWJsZSI+PHRvcGljIGhyZWY9InRhc2tzMDA3Lmh0bSNzdGhyZWY2OSIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImFib3V0Ij4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJFbWJlZGRhYmxlIj48dG9waWMgaHJlZj0idGFza3MwMDcuaHRtI3N0aHJlZjY2IiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9ImVtYmVkZGVkIElEIG1hcHBpbmciPgotICAgIDxlbnRyeSBrZXl3b3JkPSJARW1iZWRkZWRJZCI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iRW1iZWRkZWQgSUQgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDEyLmh0bSNzdGhyZWYxMDgiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJhYm91dCI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iRW1iZWRkZWQgSUQgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDEyLmh0bSNzdGhyZWYxMDYiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iZW1iZWRkZWQgbWFwcGluZyI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkBFbWJlZGRlZCI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iRW1iZWRkZWQgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDExLmh0bSNzdGhyZWYxMDQiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJhYm91dCI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iRW1iZWRkZWQgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDExLmh0bSNzdGhyZWYxMDIiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iZW50aXRpZXMiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJARW50aXR5IGFubm90YXRpb24iPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IkVudGl0eSI+PHRvcGljIGhyZWY9InRhc2tzMDA2Lmh0bSNzdGhyZWY2MiIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImFib3V0Ij4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJVbmRlcnN0YW5kaW5nIEphdmEgcGVyc2lzdGVuY2UiPjx0b3BpYyBocmVmPSJjb25jZXB0X3BlcnNpc3RlbmNlLmh0bSNzdGhyZWYxOSIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImNyZWF0aW5nIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJDcmVhdGluZyBhIEpQQSBFbnRpdHkiPjx0b3BpYyBocmVmPSJ0YXNrczAwMS5odG0jc3RocmVmMzAiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJlbWJlZGRhYmxlIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJFbWJlZGRhYmxlIj48dG9waWMgaHJlZj0idGFza3MwMDcuaHRtI3N0aHJlZjcwIiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0iZnJvbSB0YWJsZXMiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IkdlbmVyYXRpbmcgZW50aXRpZXMgZnJvbSB0YWJsZXMiPjx0b3BpYyBocmVmPSJ0YXNrczAyMC5odG0jc3RocmVmMTQxIiAvPjwvZW50cnk+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iR2VuZXJhdGUgRW50aXRpZXMgZnJvbSBUYWJsZXMgZGlhbG9nIj48dG9waWMgaHJlZj0idGFza19nZW5lcmF0ZV9lbnRpdGllcy5odG0jc3RocmVmMjQyIiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0iSlBBIERldGFpbHMgdmlldyI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iSlBBIERldGFpbHMgdmlldyAoZm9yIGVudGl0aWVzKSI+PHRvcGljIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wcm9wX3ZpZXcuaHRtI3N0aHJlZjE3OSIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9Im1hcHBlZCBzdXBlcmNsYXNzIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJNYXBwZWQgc3VwZXJjbGFzcyI+PHRvcGljIGhyZWY9InRhc2tzMDA4Lmh0bSNzdGhyZWY3NiIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9Im1hcHBpbmciPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IkNyZWF0aW5nIGEgSmF2YSBwZXJzaXN0ZW50IGVudGl0eSB3aXRoIHBlcnNpc3RlbnQgZmllbGRzIj48dG9waWMgaHJlZj0iZ2V0dGluZ19zdGFydGVkMDA0Lmh0bSNzdGhyZWYxMiIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9InBlcnNpc3RlbmNlIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJDcmVhdGluZyBhIEphdmEgcGVyc2lzdGVudCBlbnRpdHkgd2l0aCBwZXJzaXN0ZW50IGZpZWxkcyI+PHRvcGljIGhyZWY9ImdldHRpbmdfc3RhcnRlZDAwNC5odG0jc3RocmVmMTAiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJwZXJzaXN0ZW50Ij4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJFbnRpdHkiPjx0b3BpYyBocmVmPSJ0YXNrczAwNi5odG0jc3RocmVmNTciIC8+PC9lbnRyeT4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJFbnRpdHkiPjx0b3BpYyBocmVmPSJ0YXNrczAwNi5odG0jc3RocmVmNjMiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJzZWNvbmRhcnkgdGFibGVzIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJTZWNvbmRhcnkgdGFibGUgaW5mb3JtYXRpb24iPjx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMTEuaHRtI3N0aHJlZjE4NSIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJlbnVtZXJhdGVkIj4KLSAgICA8ZW50cnkga2V5d29yZD0iR2VuZXJhbCBpbmZvcm1hdGlvbiI+PHRvcGljIGhyZWY9InJlZl9tYXBwaW5nX2dlbmVyYWwuaHRtI3N0aHJlZjIwMiIgLz48L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJHZW5lcmFsIGluZm9ybWF0aW9uIj48dG9waWMgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jc3RocmVmMjA0IiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJlcnJvciBtZXNzYWdlcyAtIERhbGkiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJWYWxpZGF0aW5nIG1hcHBpbmdzIGFuZCByZXBvcnRpbmcgcHJvYmxlbXMiPjx0b3BpYyBocmVmPSJ0YXNrczAyMi5odG0jc3RocmVmMTQ2IiAvPjwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkVycm9yIG1lc3NhZ2VzIj48dG9waWMgaHJlZj0idGFza3MwMjMuaHRtI3N0aHJlZjE1MSIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iZXh0ZW5zaW9uIHBvaW50cyAtIERhbGkgZmVhdHVyZSI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkRhbGkgRGV2ZWxvcGVyIERvY3VtZW50YXRpb24iPjx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMzQuaHRtI3N0aHJlZjI0OCIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iZmV0Y2ggdHlwZSI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkdlbmVyYWwgaW5mb3JtYXRpb24iPjx0b3BpYyBocmVmPSJyZWZfbWFwcGluZ19nZW5lcmFsLmh0bSNzdGhyZWYxOTUiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9IkdlbmVyYXRlIEVudGl0aWVzIGZyb20gVGFibGVzIGRpYWxvZyI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkdlbmVyYXRpbmcgZW50aXRpZXMgZnJvbSB0YWJsZXMiPjx0b3BpYyBocmVmPSJ0YXNrczAyMC5odG0jc3RocmVmMTQ0IiAvPjwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkdlbmVyYXRlIEVudGl0aWVzIGZyb20gVGFibGVzIGRpYWxvZyI+PHRvcGljIGhyZWY9InRhc2tfZ2VuZXJhdGVfZW50aXRpZXMuaHRtI3N0aHJlZjI0MSIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iZ2VuZXJhdGVkIHZhbHVlcyI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IklEIG1hcHBpbmdzIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJQcmltYXJ5IEtleSBHZW5lcmF0aW9uIGluZm9ybWF0aW9uIj48dG9waWMgaHJlZj0icmVmX3ByaW1hcnlfa2V5Lmh0bSNzdGhyZWYyMTIiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJzZXF1ZW5jZSI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iUHJpbWFyeSBLZXkgR2VuZXJhdGlvbiBpbmZvcm1hdGlvbiI+PHRvcGljIGhyZWY9InJlZl9wcmltYXJ5X2tleS5odG0jc3RocmVmMjE0IiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9IklEIG1hcHBpbmciPgotICAgIDxlbnRyeSBrZXl3b3JkPSJASWQiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IklEIG1hcHBpbmciPjx0b3BpYyBocmVmPSJ0YXNrczAxMy5odG0jc3RocmVmMTEyIiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0iYWJvdXQiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IklEIG1hcHBpbmciPjx0b3BpYyBocmVmPSJ0YXNrczAxMy5odG0jc3RocmVmMTEwIiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9ImluaGVyaXRhbmNlIj4KLSAgICA8ZW50cnkga2V5d29yZD0iZW50aXR5Ij4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJTcGVjaWZ5aW5nIGVudGl0eSBpbmhlcml0YW5jZSI+PHRvcGljIGhyZWY9InRhc2tfaW5oZXJpdGFuY2UuaHRtI3N0aHJlZjgwIiAvPjwvZW50cnk+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iSW5oZXJpdGFuY2UgaW5mb3JtYXRpb24iPjx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMTIuaHRtI3N0aHJlZjE4OCIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImpvaW5lZCB0YWJsZXMiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IlNwZWNpZnlpbmcgZW50aXR5IGluaGVyaXRhbmNlIj48dG9waWMgaHJlZj0idGFza19pbmhlcml0YW5jZS5odG0jc3RocmVmOTIiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJzaW5nbGUgdGFibGUiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IlNwZWNpZnlpbmcgZW50aXR5IGluaGVyaXRhbmNlIj48dG9waWMgaHJlZj0idGFza19pbmhlcml0YW5jZS5odG0jc3RocmVmODciIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iSW5oZXJpdGFuY2UgLSBpbiBKYXZhIERldGFpbHMgdmlldyI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkluaGVyaXRhbmNlIGluZm9ybWF0aW9uIj48dG9waWMgaHJlZj0icmVmZXJlbmNlMDEyLmh0bSNzdGhyZWYxODciIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9Imluc3RhbGxhdGlvbiAtIERhbGkiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJSZXF1aXJlbWVudHMgYW5kIGluc3RhbGxhdGlvbiI+PHRvcGljIGhyZWY9ImdldHRpbmdfc3RhcnRlZDAwMS5odG0jc3RocmVmMyIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iam9pbmVkIHRhYmxlcyAtIGluaGVyaXRhbmNlIj4KLSAgICA8ZW50cnkga2V5d29yZD0iU3BlY2lmeWluZyBlbnRpdHkgaW5oZXJpdGFuY2UiPjx0b3BpYyBocmVmPSJ0YXNrX2luaGVyaXRhbmNlLmh0bSNzdGhyZWY5MyIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iSlBBIERldGFpbHMgdmlldyI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImF0dHJpYnV0ZXMiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IkpQQSBEZXRhaWxzIHZpZXcgKGZvciBhdHRyaWJ1dGVzKSI+PHRvcGljIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0jc3RocmVmMTkwIiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0iZW50aXRpZXMiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IkpQQSBEZXRhaWxzIHZpZXcgKGZvciBlbnRpdGllcykiPjx0b3BpYyBocmVmPSJyZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSNzdGhyZWYxNzciIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iSlBBIERldmVsb3BtZW50IHBlcnNwZWN0aXZlIj4KLSAgICA8ZW50cnkga2V5d29yZD0iSlBBIERldmVsb3BtZW50IHBlcnNwZWN0aXZlIj48dG9waWMgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3BlcnNwZWN0aXZlLmh0bSNzdGhyZWYyNDQiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9IkpQQSBwcm9qZWN0Ij4KLSAgICA8ZW50cnkga2V5d29yZD0iY3JlYXRpbmcgbmV3Ij4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJDcmVhdGluZyBhIG5ldyBKUEEgcHJvamVjdCI+PHRvcGljIGhyZWY9InRhc2tfY3JlYXRlX25ld19wcm9qZWN0Lmh0bSNzdGhyZWYyNiIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9InBsYXRmb3JtIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJQcm9qZWN0IFByb3BlcnRpZXMgcGFnZSAtIEpQQSBPcHRpb25zIj48dG9waWMgaHJlZj0icmVmX3Byb2plY3RfcHJvcGVydGllcy5odG0jc3RocmVmMjM1IiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9IkpQQSBTdHJ1Y3R1cmUgdmlldyI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkpQQSBTdHJ1Y3R1cmUgdmlldyI+PHRvcGljIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9vdXRsaW5lLmh0bSNzdGhyZWYyMTYiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9ImxhenkgZmV0Y2giPgotICAgIDxlbnRyeSBrZXl3b3JkPSJHZW5lcmFsIGluZm9ybWF0aW9uIj48dG9waWMgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jc3RocmVmMTk3IiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJtYW55LXRvLW1hbnkgbWFwcGluZyI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkBNYW55VG9NYW55Ij4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJNYW55LXRvLW1hbnkgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDE0Lmh0bSNzdGhyZWYxMTYiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJhYm91dCI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iTWFueS10by1tYW55IG1hcHBpbmciPjx0b3BpYyBocmVmPSJ0YXNrczAxNC5odG0jc3RocmVmMTE0IiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9Im1hbnktdG8tb25lIG1hcHBpbmciPgotICAgIDxlbnRyeSBrZXl3b3JkPSJATWFueVRvT25lIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJNYW55LXRvLW9uZSBtYXBwaW5nIj48dG9waWMgaHJlZj0idGFza3MwMTUuaHRtI3N0aHJlZjExOSIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImFib3V0Ij4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJNYW55LXRvLW9uZSBtYXBwaW5nIj48dG9waWMgaHJlZj0idGFza3MwMTUuaHRtI3N0aHJlZjExOCIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJtYXBwZWQgc3VwZXJjbGFzcyI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkBNYXBwZWRTdXBlcmNsYXNzIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJNYXBwZWQgc3VwZXJjbGFzcyI+PHRvcGljIGhyZWY9InRhc2tzMDA4Lmh0bSNzdGhyZWY3NCIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImFib3V0Ij4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJNYXBwZWQgc3VwZXJjbGFzcyI+PHRvcGljIGhyZWY9InRhc2tzMDA4Lmh0bSNzdGhyZWY3MiIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJtYXBwaW5nIGVudGl0aWVzIj4KLSAgICA8ZW50cnkga2V5d29yZD0iQ3JlYXRpbmcgYSBKYXZhIHBlcnNpc3RlbnQgZW50aXR5IHdpdGggcGVyc2lzdGVudCBmaWVsZHMiPjx0b3BpYyBocmVmPSJnZXR0aW5nX3N0YXJ0ZWQwMDQuaHRtI3N0aHJlZjExIiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJtYXBwaW5ncyI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImFib3V0Ij4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJVbmRlcnN0YW5kaW5nIE9SIG1hcHBpbmdzIj48dG9waWMgaHJlZj0iY29uY2VwdF9tYXBwaW5nLmh0bSNzdGhyZWYyMSIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImJhc2ljIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJCYXNpYyBtYXBwaW5nIj48dG9waWMgaHJlZj0idGFza3MwMTAuaHRtI3N0aHJlZjk3IiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0iZW1iZWRkZWQiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IkVtYmVkZGVkIG1hcHBpbmciPjx0b3BpYyBocmVmPSJ0YXNrczAxMS5odG0jc3RocmVmMTAxIiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0iZW1iZWRkZWQgSUQiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IkVtYmVkZGVkIElEIG1hcHBpbmciPjx0b3BpYyBocmVmPSJ0YXNrczAxMi5odG0jc3RocmVmMTA1IiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0iSUQiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IklEIG1hcHBpbmciPjx0b3BpYyBocmVmPSJ0YXNrczAxMy5odG0jc3RocmVmMTA5IiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0ibWFueS10by1tYW55Ij4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJNYW55LXRvLW1hbnkgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDE0Lmh0bSNzdGhyZWYxMTMiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJtYW55LXRvLW9uZSI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iTWFueS10by1vbmUgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDE1Lmh0bSNzdGhyZWYxMTciIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJvbmUtdG8tbWFueSI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iT25lLXRvLW1hbnkgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDE2Lmh0bSNzdGhyZWYxMjMiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJvbmUtdG8tb25lIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJPbmUtdG8tb25lIG1hcHBpbmciPjx0b3BpYyBocmVmPSJ0YXNrczAxNy5odG0jc3RocmVmMTI3IiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0icHJvYmxlbXMiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IlZhbGlkYXRpbmcgbWFwcGluZ3MgYW5kIHJlcG9ydGluZyBwcm9ibGVtcyI+PHRvcGljIGhyZWY9InRhc2tzMDIyLmh0bSNzdGhyZWYxNDkiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJ0cmFuc2llbnQiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IlRyYW5zaWVudCBtYXBwaW5nIj48dG9waWMgaHJlZj0idGFza3MwMTguaHRtI3N0aHJlZjEzMyIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9InZlcnNpb24iPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IlZlcnNpb24gbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDE5Lmh0bSNzdGhyZWYxMzciIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0ibmFtZWQgcXVlcmllcyI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImVudGl0eSI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iQ3JlYXRpbmcgTmFtZWQgUXVlcmllcyI+PHRvcGljIGhyZWY9InRhc2tzMDA5Lmh0bSNzdGhyZWY5NCIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJub25wZXJzaXN0ZW50Ij4KLSAgICA8ZW50cnkga2V5d29yZD0iY2xhc3NlcyI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iQWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3MiPjx0b3BpYyBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0jc3RocmVmNTUiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJmaWVsZHMuIFNlZSB0cmFuc2llbnQiPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJvbmUtdG8tbWFueSBtYXBwaW5nIj4KLSAgICA8ZW50cnkga2V5d29yZD0iQE9uZVRvTWFueSI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iT25lLXRvLW1hbnkgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDE2Lmh0bSNzdGhyZWYxMjYiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJhYm91dCI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iT25lLXRvLW1hbnkgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDE2Lmh0bSNzdGhyZWYxMjQiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0ib25lLXRvLW9uZSBtYXBwaW5nIj4KLSAgICA8ZW50cnkga2V5d29yZD0iQE9uZVRvT25lIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJPbmUtdG8tb25lIG1hcHBpbmciPjx0b3BpYyBocmVmPSJ0YXNrczAxNy5odG0jc3RocmVmMTMwIiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0iYWJvdXQiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9Ik9uZS10by1vbmUgbWFwcGluZyI+PHRvcGljIGhyZWY9InRhc2tzMDE3Lmh0bSNzdGhyZWYxMjgiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0ib3JkZXJpbmciPgotICAgIDxlbnRyeSBrZXl3b3JkPSJHZW5lcmFsIGluZm9ybWF0aW9uIj48dG9waWMgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jc3RocmVmMjA1IiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJvcm0ueG1sIGZpbGUiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJhYm91dCI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iVGhlIG9ybS54bWwgZmlsZSI+PHRvcGljIGhyZWY9ImNvbmNlcHRzMDAzLmh0bSNzdGhyZWYyMyIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9Im1hbmFnaW5nIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJNYW5hZ2luZyB0aGUgb3JtLnhtbCBmaWxlIj48dG9waWMgaHJlZj0idGFza19tYW5hZ2Vfb3JtLmh0bSNzdGhyZWY0NiIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9InNhbXBsZSI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iTWFuYWdpbmcgdGhlIG9ybS54bWwgZmlsZSI+PHRvcGljIGhyZWY9InRhc2tfbWFuYWdlX29ybS5odG0jc3RocmVmNDciIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0ib3ZlcnJpZGVzIC0gSlBBIGF0dHJpYnV0ZXMiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJBdHRyaWJ1dGUgb3ZlcnJpZGVzIj48dG9waWMgaHJlZj0icmVmZXJlbmNlMDEwLmh0bSNzdGhyZWYxODEiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9InBlcnNpc3RlbmNlIj4KLSAgICA8ZW50cnkga2V5d29yZD0iYWJvdXQiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IlVuZGVyc3RhbmRpbmcgSmF2YSBwZXJzaXN0ZW5jZSI+PHRvcGljIGhyZWY9ImNvbmNlcHRfcGVyc2lzdGVuY2UuaHRtI3N0aHJlZjE4IiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0iZGF0YWJhc2UgY29ubmVjdGlvbiI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iUHJvamVjdCBQcm9wZXJ0aWVzIHBhZ2UgLSBKUEEgT3B0aW9ucyI+PHRvcGljIGhyZWY9InJlZl9wcm9qZWN0X3Byb3BlcnRpZXMuaHRtI3N0aHJlZjIzNyIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImRhdGFiYXNlIHNjaGVtYSI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iUHJvamVjdCBQcm9wZXJ0aWVzIHBhZ2UgLSBKUEEgT3B0aW9ucyI+PHRvcGljIGhyZWY9InJlZl9wcm9qZWN0X3Byb3BlcnRpZXMuaHRtI3N0aHJlZjI0MCIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImVudGl0eSBjbGFzcyI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iQWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3MiPjx0b3BpYyBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0jc3RocmVmNTQiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJvcHRpb25zIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJQcm9qZWN0IFByb3BlcnRpZXMgcGFnZSAtIEpQQSBPcHRpb25zIj48dG9waWMgaHJlZj0icmVmX3Byb2plY3RfcHJvcGVydGllcy5odG0jc3RocmVmMjMyIiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9IlBlcnNpc3RlbmNlIFhNTCBFZGl0b3IiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJVc2luZyB0aGUgWE1MIEVkaXRvciB0byBlZGl0IHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZSI+PHRvcGljIGhyZWY9InRhc2tzMDAyLmh0bSNzdGhyZWY0MCIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0icGVyc2lzdGVuY2UueG1sIGZpbGUiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJhYm91dCI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iVGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlIj48dG9waWMgaHJlZj0iY29uY2VwdHMwMDIuaHRtI3N0aHJlZjIyIiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0iZWRpdG9yIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJVc2luZyB0aGUgWE1MIEVkaXRvciB0byBlZGl0IHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZSI+PHRvcGljIGhyZWY9InRhc2tzMDAyLmh0bSNzdGhyZWY0MSIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9Im1hbmFnaW5nIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJNYW5hZ2luZyB0aGUgcGVyc2lzdGVuY2UueG1sIGZpbGUiPjx0b3BpYyBocmVmPSJ0YXNrX21hbmFnZV9wZXJzaXN0ZW5jZS5odG0jc3RocmVmMzUiIC8+PC9lbnRyeT4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJVc2luZyB0aGUgWE1MIEVkaXRvciB0byBlZGl0IHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZSI+PHRvcGljIGhyZWY9InRhc2tzMDAyLmh0bSNzdGhyZWYzOCIgLz48L2VudHJ5PgotICAgICAgPGVudHJ5IGtleXdvcmQ9Ildvcmtpbmcgd2l0aCBvcm0ueG1sIGZpbGUiPjx0b3BpYyBocmVmPSJ0YXNrczAwNS5odG0jc3RocmVmNTIiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJzYW1wbGUiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9Ik1hbmFnaW5nIHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZSI+PHRvcGljIGhyZWY9InRhc2tfbWFuYWdlX3BlcnNpc3RlbmNlLmh0bSNzdGhyZWYzNiIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9InN5bmNocm9uaXppbmcgd2l0aCBjbGFzc2VzIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJTeW5jaHJvbml6aW5nIGNsYXNzZXMiPjx0b3BpYyBocmVmPSJ0YXNrczAwMy5odG0jc3RocmVmNDQiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0icGVyc2lzdGVudCBlbnRpdHkiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJFbnRpdHkiPjx0b3BpYyBocmVmPSJ0YXNrczAwNi5odG0jc3RocmVmNTgiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9InBlcnNwZWN0aXZlIC0gSlBBIERldmVsb3BtZW50Ij4KLSAgICA8ZW50cnkga2V5d29yZD0iSlBBIERldmVsb3BtZW50IHBlcnNwZWN0aXZlIj48dG9waWMgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3BlcnNwZWN0aXZlLmh0bSNzdGhyZWYyNDUiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9InBsYXRmb3JtIC0gSlBBIj4KLSAgICA8ZW50cnkga2V5d29yZD0iUHJvamVjdCBQcm9wZXJ0aWVzIHBhZ2UgLSBKUEEgT3B0aW9ucyI+PHRvcGljIGhyZWY9InJlZl9wcm9qZWN0X3Byb3BlcnRpZXMuaHRtI3N0aHJlZjIzNCIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0icHJvYmxlbXMiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJWYWxpZGF0aW5nIG1hcHBpbmdzIGFuZCByZXBvcnRpbmcgcHJvYmxlbXMiPjx0b3BpYyBocmVmPSJ0YXNrczAyMi5odG0jc3RocmVmMTQ4IiAvPjwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJwcm9qZWN0cyAtIEpQQSI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImNyZWF0aW5nIG5ldyI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iQ3JlYXRpbmcgYSBuZXcgSlBBIHByb2plY3QiPjx0b3BpYyBocmVmPSJnZXR0aW5nX3N0YXJ0ZWQwMDMuaHRtI3N0aHJlZjgiIC8+PC9lbnRyeT4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJDcmVhdGluZyBhIG5ldyBKUEEgcHJvamVjdCI+PHRvcGljIGhyZWY9InRhc2tfY3JlYXRlX25ld19wcm9qZWN0Lmh0bSNzdGhyZWYyNSIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9Im9wdGlvbnMiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IlByb2plY3QgUHJvcGVydGllcyBwYWdlIC0gSlBBIE9wdGlvbnMiPjx0b3BpYyBocmVmPSJyZWZfcHJvamVjdF9wcm9wZXJ0aWVzLmh0bSNzdGhyZWYyMzMiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0icXVpY2sgc3RhcnQgLSBEYWxpIj4KLSAgICA8ZW50cnkga2V5d29yZD0iRGFsaSBxdWljayBzdGFydCI+PHRvcGljIGhyZWY9ImdldHRpbmdfc3RhcnRlZDAwMi5odG0jc3RocmVmNyIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0icmVxdWlyZW1lbnRzIj4KLSAgICA8ZW50cnkga2V5d29yZD0iRGFsaSBKYXZhIFBlcnNpc3RlbmNlIFRvb2xzIj4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJSZXF1aXJlbWVudHMgYW5kIGluc3RhbGxhdGlvbiI+PHRvcGljIGhyZWY9ImdldHRpbmdfc3RhcnRlZDAwMS5odG0jc3RocmVmNCIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9InBlcnNpc3RlbnQgZW50aXRpZXMiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IkVudGl0eSI+PHRvcGljIGhyZWY9InRhc2tzMDA2Lmh0bSNzdGhyZWY2MCIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJzY2hlbWEgLSBkYXRhYmFzZSI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IlByb2plY3QgUHJvcGVydGllcyBwYWdlIC0gSlBBIE9wdGlvbnMiPjx0b3BpYyBocmVmPSJyZWZfcHJvamVjdF9wcm9wZXJ0aWVzLmh0bSNzdGhyZWYyMzkiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9InNlY29uZGFyeSB0YWJsZXMiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJTZWNvbmRhcnkgdGFibGUgaW5mb3JtYXRpb24iPjx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMTEuaHRtI3N0aHJlZjE4MyIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iU2Vjb25kYXJ5IFRhYmxlcyAtIGluIEphdmEgRGV0YWlscyB2aWV3Ij4KLSAgICA8ZW50cnkga2V5d29yZD0iU2Vjb25kYXJ5IHRhYmxlIGluZm9ybWF0aW9uIj48dG9waWMgaHJlZj0icmVmZXJlbmNlMDExLmh0bSNzdGhyZWYxODYiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9InNpbmdsZSB0YWJsZSBpbmhlcml0YW5jZSI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IlNwZWNpZnlpbmcgZW50aXR5IGluaGVyaXRhbmNlIj48dG9waWMgaHJlZj0idGFza19pbmhlcml0YW5jZS5odG0jc3RocmVmODgiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9InN1cGVyY2xhc3MiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJNYXBwZWQgc3VwZXJjbGFzcyI+PHRvcGljIGhyZWY9InRhc2tzMDA4Lmh0bSNzdGhyZWY3NyIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0idGFibGVzIj4KLSAgICA8ZW50cnkga2V5d29yZD0iY3JlYXRpbmcgZW50aXRpZXMgZnJvbSI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iR2VuZXJhdGluZyBlbnRpdGllcyBmcm9tIHRhYmxlcyI+PHRvcGljIGhyZWY9InRhc2tzMDIwLmh0bSNzdGhyZWYxNDIiIC8+PC9lbnRyeT4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJHZW5lcmF0ZSBFbnRpdGllcyBmcm9tIFRhYmxlcyBkaWFsb2ciPjx0b3BpYyBocmVmPSJ0YXNrX2dlbmVyYXRlX2VudGl0aWVzLmh0bSNzdGhyZWYyNDMiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICAgIDxlbnRyeSBrZXl3b3JkPSJpbmhlcml0YW5jZSI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iU3BlY2lmeWluZyBlbnRpdHkgaW5oZXJpdGFuY2UiPjx0b3BpYyBocmVmPSJ0YXNrX2luaGVyaXRhbmNlLmh0bSNzdGhyZWY4OSIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9InNlY29uZGFyeSI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iU2Vjb25kYXJ5IHRhYmxlIGluZm9ybWF0aW9uIj48dG9waWMgaHJlZj0icmVmZXJlbmNlMDExLmh0bSNzdGhyZWYxODQiIC8+PC9lbnRyeT4KLSAgICA8L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0idGVtcG9yYWwiPgotICAgIDxlbnRyeSBrZXl3b3JkPSJHZW5lcmFsIGluZm9ybWF0aW9uIj48dG9waWMgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jc3RocmVmMTk5IiAvPjwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IkdlbmVyYWwgaW5mb3JtYXRpb24iPjx0b3BpYyBocmVmPSJyZWZfbWFwcGluZ19nZW5lcmFsLmh0bSNzdGhyZWYyMDEiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9InRyYW5zaWVudCBtYXBwaW5nIj4KLSAgICA8ZW50cnkga2V5d29yZD0iQFRyYW5zaWVudCI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iVHJhbnNpZW50IG1hcHBpbmciPjx0b3BpYyBocmVmPSJ0YXNrczAxOC5odG0jc3RocmVmMTM2IiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0iYWJvdXQiPgotICAgICAgPGVudHJ5IGtleXdvcmQ9IlRyYW5zaWVudCBtYXBwaW5nIj48dG9waWMgaHJlZj0idGFza3MwMTguaHRtI3N0aHJlZjEzNCIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gIDwvZW50cnk+Ci0gIDxlbnRyeSBrZXl3b3JkPSJ2ZXJzaW9uIG1hcHBpbmciPgotICAgIDxlbnRyeSBrZXl3b3JkPSJAVmVyc2lvbiI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iVmVyc2lvbiBtYXBwaW5nIj48dG9waWMgaHJlZj0idGFza3MwMTkuaHRtI3N0aHJlZjE0MCIgLz48L2VudHJ5PgotICAgIDwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9ImFib3V0Ij4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJWZXJzaW9uIG1hcHBpbmciPjx0b3BpYyBocmVmPSJ0YXNrczAxOS5odG0jc3RocmVmMTM4IiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9InZpZXdzIj4KLSAgICA8ZW50cnkga2V5d29yZD0iSlBBIERldGFpbHMgdmlldyI+Ci0gICAgICA8ZW50cnkga2V5d29yZD0iSlBBIERldGFpbHMgdmlldyAoZm9yIGVudGl0aWVzKSI+PHRvcGljIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wcm9wX3ZpZXcuaHRtI3N0aHJlZjE3OCIgLz48L2VudHJ5PgotICAgICAgPGVudHJ5IGtleXdvcmQ9IkpQQSBEZXRhaWxzIHZpZXcgKGZvciBhdHRyaWJ1dGVzKSI+PHRvcGljIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0jc3RocmVmMTkxIiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgICA8ZW50cnkga2V5d29yZD0iSlBBIFN0cnVjdHVyZSB2aWV3Ij4KLSAgICAgIDxlbnRyeSBrZXl3b3JkPSJKUEEgU3RydWN0dXJlIHZpZXciPjx0b3BpYyBocmVmPSJyZWZfcGVyc2lzdGVuY2Vfb3V0bGluZS5odG0jc3RocmVmMjE1IiAvPjwvZW50cnk+Ci0gICAgPC9lbnRyeT4KLSAgPC9lbnRyeT4KLSAgPGVudHJ5IGtleXdvcmQ9Indhcm5pbmcgbWVzc2FnZXMgLSBEYWxpIj4KLSAgICA8ZW50cnkga2V5d29yZD0iVmFsaWRhdGluZyBtYXBwaW5ncyBhbmQgcmVwb3J0aW5nIHByb2JsZW1zIj48dG9waWMgaHJlZj0idGFza3MwMjIuaHRtI3N0aHJlZjE0NyIgLz48L2VudHJ5PgotICA8L2VudHJ5PgotICA8ZW50cnkga2V5d29yZD0iWE1MIGVkaXRvciI+Ci0gICAgPGVudHJ5IGtleXdvcmQ9IlVzaW5nIHRoZSBYTUwgRWRpdG9yIHRvIGVkaXQgdGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlIj48dG9waWMgaHJlZj0idGFza3MwMDIuaHRtI3N0aHJlZjM3IiAvPjwvZW50cnk+Ci0gICAgPGVudHJ5IGtleXdvcmQ9Ildvcmtpbmcgd2l0aCBvcm0ueG1sIGZpbGUiPjx0b3BpYyBocmVmPSJ0YXNrczAwNS5odG0jc3RocmVmNTEiIC8+PC9lbnRyeT4KLSAgPC9lbnRyeT4KLTwvaW5kZXg+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvbGVnYWwuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL2xlZ2FsLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjVhOTllNC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvbGVnYWwuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsMzkgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTUgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5MZWdhbDwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IiBMZWdhbCIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9InN0aHJlZjI1NiIgbmFtZT0ic3RocmVmMjU2Ij48L2E+PC9wPgotPGgxPkxlZ2FsPC9oMT4KLTxwPkNvcHlyaWdodCAmY29weTsgMjAwNiwgMjAwOCwgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLjwvcD4KLTxwPlRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0OjwvcD4KLTxwPjxjb2RlPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT48L2NvZGU+PC9wPgotPHA+PGEgaHJlZj0iYWJvdXQuaHRtIj5UZXJtcyBhbmQgY29uZGl0aW9ucyByZWdhcmRpbmcgdGhlIHVzZSBvZiB0aGlzIGd1aWRlLjwvYT48L3A+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcGx1Z2luLnByb3BlcnRpZXMgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcGx1Z2luLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDg2NWMwODIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3BsdWdpbi5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMzIgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBDb3B5cmlnaHQgKGMpIDIwMDcgT3JhY2xlLgotIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCi0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAotIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAotIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlLiAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotIyBUbyBjb2RlIGRldmVsb3BlcjoKLSMgICBEbyBOT1QgY2hhbmdlIHRoZSBwcm9wZXJ0aWVzIGJldHdlZW4gdGhpcyBsaW5lIGFuZCB0aGUKLSMgICAiJSUlIEVORCBPRiBUUkFOU0xBVEVEIFBST1BFUlRJRVMgJSUlIiBsaW5lLgotIyAgIE1ha2UgYSBuZXcgcHJvcGVydHkgbmFtZSwgYXBwZW5kIHRvIHRoZSBlbmQgb2YgdGhlIGZpbGUgYW5kIGNoYW5nZQotIyAgIHRoZSBjb2RlIHRvIHVzZSB0aGUgbmV3IHByb3BlcnR5LgotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0jICUlJSBFTkQgT0YgVFJBTlNMQVRFRCBQUk9QRVJUSUVTICUlJQotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotCi1wbHVnaW5OYW1lID0gSmF2YSBQZXJzaXN0ZW5jZSBEb2N1bWVudGF0aW9uIC0gRG9jCi1wcm92aWRlck5hbWUgPSBFY2xpcHNlLm9yZwotCi1qcGFEZXZlbG9wbWVudD1KUEEgRGV2ZWxvcG1lbnQKLWNyZWF0ZUFKcGFQcm9qZWN0PUNyZWF0ZSBhIEpQQSBwcm9qZWN0Ci1jcmVhdGVBSnBhUHJvamVjdERlc2NyaXB0aW9uPVRoaXMgY2hlYXQgc2hlZXQgaGVscHMgeW91IGNyZWF0ZSBhIEpQQSBwcm9qZWN0LgotY3JlYXRlQVBlcnNpc3RlbnRFbnRpdHk9Q3JlYXRlIGEgcGVyc2lzdGVudCBlbnRpdHkKLWNyZWF0ZUFQZXJzaXN0ZW50RW50aXR5RGVzY3JpcHRpb249VGhpcyBjaGVhdCBzaGVldCBoZWxwcyB5b3UgY3JlYXRlIGEgSmF2YSBwZXJzaXN0ZW50IGVudGl0eS4KLU1hcEFQZXJzaXN0ZW50RW50aXR5PU1hcCBhIHBlcnNpc3RlbnQgZW50aXR5Ci1NYXBBUGVyc2lzdGVudEVudGl0eURlc2NyaXB0aW9uPVRoaXMgY2hlYXQgc2hlZXQgaGVscHMgeW91IG1hcCB0aGUgYSBKYXZhIHBlcnNpc3RlbnQgZW50aXR5IHRvIGEgZGF0YWJhc2UgdGFibGUuCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcGx1Z2luLnhtbCBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9wbHVnaW4ueG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyZjMwOGYzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9wbHVnaW4ueG1sCisrKyAvZGV2L251bGwKQEAgLTEsMzcgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTw/ZWNsaXBzZSB2ZXJzaW9uPSIzLjAiPz4KLTxwbHVnaW4gbmFtZT0iSlBBIERvY3VtZW50YXRpb24gUGx1Zy1pbiIgaWQ9Im9yZy5lY2xpcHNlLmpwdC5kb2MudXNlciIgdmVyc2lvbj0iMi4wLjAiIHByb3ZpZGVyLW5hbWU9Ik9yYWNsZSI+Ci0JPCEtLSA9PT09PT09PT09PSAtLT4KLQk8IS0tIERlZmluZSBUT0MgIC0tPgotCTwhLS0gPT09PT09PT09PT0gLS0+Ci0JPGV4dGVuc2lvbiBwb2ludD0ib3JnLmVjbGlwc2UuaGVscC50b2MiPgotCQk8dG9jIGZpbGU9InRvYy54bWwiIHByaW1hcnk9InRydWUiLz4KLQk8L2V4dGVuc2lvbj4KLQk8IS0tID09PT09PT09PT09IC0tPgotCTwhLS0gRGVmaW5lIEYxICAgLS0+Ci0JPCEtLSA9PT09PT09PT09PSAtLT4KLQk8ZXh0ZW5zaW9uIHBvaW50PSJvcmcuZWNsaXBzZS5oZWxwLmNvbnRleHRzIj4KLQkJPGNvbnRleHRzIGZpbGU9ImNvbnRleHRzLnhtbCIgcGx1Z2luPSJvcmcuZWNsaXBzZS5qcHQudWkiLz4KLQk8L2V4dGVuc2lvbj4KLQk8IS0tID09PT09PT09PT09PT09PT09PT09IC0tPgotCTwhLS0gRGVmaW5lIEtleXdvcmQgSW5kZXggLS0+Ci0JPCEtLSA9PT09PT09PT09PT09PT09PT09PSAtLT4KLQk8ZXh0ZW5zaW9uIHBvaW50PSJvcmcuZWNsaXBzZS5oZWxwLmluZGV4Ij4KLQkJPGluZGV4IGZpbGU9ImluZGV4LnhtbCIvPgotCTwvZXh0ZW5zaW9uPgotCTwhLS0gPT09PT09PT09PT0gLS0+Ci0JPCEtLSBDaGVhdHNoZWV0cyAtLT4KLQk8IS0tID09PT09PT09PT09IC0tPgotCTxleHRlbnNpb24gcG9pbnQ9Im9yZy5lY2xpcHNlLnVpLmNoZWF0c2hlZXRzLmNoZWF0U2hlZXRDb250ZW50Ij4KLQkJPGNhdGVnb3J5IG5hbWU9IiVqcGFEZXZlbG9wbWVudCIgaWQ9ImNvbS5qcGEuY2F0ZWdvcnkiLz4KLQkJPGNoZWF0c2hlZXQgbmFtZT0iJWNyZWF0ZUFKcGFQcm9qZWN0IiBjYXRlZ29yeT0iY29tLmpwYS5jYXRlZ29yeSIgY29udGVudEZpbGU9IiRubCQvY2hlYXRzaGVldHMvYWRkX3BlcnNpc3RlbmNlLnhtbCIgaWQ9Im9yZy5lY2xpcHNlLmpwYS5jaGVhdHNoZWV0LmNyZWF0ZXByb2plY3QxIj4KLQkJCTxkZXNjcmlwdGlvbj4lY3JlYXRlQUpwYVByb2plY3REZXNjcmlwdGlvbjwvZGVzY3JpcHRpb24+Ci0JCTwvY2hlYXRzaGVldD4KLQkJPGNoZWF0c2hlZXQgbmFtZT0iJWNyZWF0ZUFQZXJzaXN0ZW50RW50aXR5IiBjYXRlZ29yeT0iY29tLmpwYS5jYXRlZ29yeSIgY29udGVudEZpbGU9IiRubCQvY2hlYXRzaGVldHMvY3JlYXRlX2VudGl0eS54bWwiIGlkPSJvcmcuZWNsaXBzZS5qcGEuY2hlYXRzaGVldC5hZGRlbnRpdHkiPgotCQkJPGRlc2NyaXB0aW9uPiVjcmVhdGVBUGVyc2lzdGVudEVudGl0eURlc2NyaXB0aW9uPC9kZXNjcmlwdGlvbj4KLQkJPC9jaGVhdHNoZWV0PgotCQk8Y2hlYXRzaGVldCBuYW1lPSIlTWFwQVBlcnNpc3RlbnRFbnRpdHkiIGNhdGVnb3J5PSJjb20uanBhLmNhdGVnb3J5IiBjb250ZW50RmlsZT0iJG5sJC9jaGVhdHNoZWV0cy9tYXBfZW50aXR5LnhtbCIgaWQ9Im9yZy5lY2xpcHNlLmpwYS5jaGVhdHNoZWV0Lm1hcGVudGl0eSI+Ci0JCQk8ZGVzY3JpcHRpb24+JU1hcEFQZXJzaXN0ZW50RW50aXR5RGVzY3JpcHRpb248L2Rlc2NyaXB0aW9uPgotCQk8L2NoZWF0c2hlZXQ+Ci0JPC9leHRlbnNpb24+Ci08L3BsdWdpbj4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZfZGV0YWlsc19vcm0uaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZl9kZXRhaWxzX29ybS5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGNkZGE0NmIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZl9kZXRhaWxzX29ybS5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw0NiArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo1MSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBvcm0ueG1sKTwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IkpQQSBEZXRhaWxzIHZpZXcgKGZvciBvcm0ueG1sKSIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNBQ0dER0hDIiBuYW1lPSJDQUNHREdIQyI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QyIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+SlBBIERldGFpbHMgdmlldyAoZm9yIG9ybS54bWwpPC9oMT4KLTxwPlRoZSA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC10aXRsZSI+SlBBIERldGFpbHM8L3NwYW4+IHZpZXcgZGlzcGxheXMgdGhlIGRlZmF1bHQgbWFwcGluZyBhbmQgcGVyc2lzdGVuY2UgaW5mb3JtYXRpb24gZm9yIHRoZSBwcm9qZWN0IGFuZCBjb250YWlucyB0aGUgZm9sbG93aW5nIGFyZWFzOjwvcD4KLTx1bD4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAxNi5odG0jQ0FDQ0FDR0giPkdlbmVyYWwgaW5mb3JtYXRpb248L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAxNy5odG0jQ0FDRUFHQkciPlBlcnNpc3RlbmNlIFVuaXQgaW5mb3JtYXRpb248L2E+PC9wPgotPC9saT4KLTwvdWw+Ci08cD5UaGVzZSBkZWZhdWx0cyBjYW4gYmUgb3ZlcnJpZGRlbiBieSB0aGUgc2V0dGluZ3Mgb24gYSBzcGVjaWZpYyBlbnRpdHkgb3IgbWFwcGluZy48L3A+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+PC9kaXY+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX2pwYV9mYWNldC5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX2pwYV9mYWNldC5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDg4YzU1OTUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZl9qcGFfZmFjZXQuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsODkgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDkgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5KUEEgRmFjZXQgcGFnZTwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IkpQQSBGYWNldCBwYWdlIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0FDSUZESUYiIG5hbWU9IkNBQ0lGRElGIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDMiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5KUEEgRmFjZXQgcGFnZTwvaDE+Ci08cD5UaGlzIHRhYmxlIGxpc3RzIHRoZSBwcm9wZXJ0aWVzIGF2YWlsYWJsZSBvbiB0aGUgSlBBIEZhY2V0IHBhZ2Ugb2YgdGhlIDxhIGhyZWY9InJlZl9uZXdfanBhX3Byb2plY3Rfd2l6YXJkLmh0bSNDQUNCSkdCRyI+Q3JlYXRlIE5ldyBKUEEgUHJvamVjdCB3aXphcmQ8L2E+LjwvcD4KLTxkaXYgY2xhc3M9ImluZnRibGluZm9ybWFsIj4KLTx0YWJsZSBjbGFzcz0iSW5mb3JtYWwiIHRpdGxlPSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgb3B0aW9ucyBvbiB0aGUgR2VuZXJhdGUgRERMIC0gT2JqZWN0cyBwYWdlLiIgc3VtbWFyeT0iVGhpcyB0YWJsZSBkZXNjcmliZXMgdGhlIG9wdGlvbnMgb24gdGhlIEdlbmVyYXRlIERETCAtIE9iamVjdHMgcGFnZS4iIGRpcj0ibHRyIiBib3JkZXI9IjEiIHdpZHRoPSIxMDAlIiBmcmFtZT0iYm9yZGVyIiBydWxlcz0iYWxsIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRoZWFkPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMS10MyI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDMiPkRlc2NyaXB0aW9uPC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMzLXQzIj5EZWZhdWx0PC90aD4KLTwvdHI+Ci08L3RoZWFkPgotPHRib2R5PgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMmMxLXQzIiBoZWFkZXJzPSJyMWMxLXQzIj5QbGF0Zm9ybTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDMgcjFjMi10MyI+VmVuZG9yLXNwZWNpZmljIEpQQSBpbXBsZW1lbnRhdGlvbi48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQzIHIxYzMtdDMiPkVjbGlwc2VMaW5rPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDMiIGhlYWRlcnM9InIxYzEtdDMiPkNvbm5lY3Rpb248L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQzIHIxYzItdDMiPlNlbGVjdCB0aGUgZGF0YWJhc2UgY29ubmVjdGlvbiB0byB1c2Ugd2l0aCB0aGUgcHJvamVjdC4gRGFsaSByZXF1aXJlcyBhbiBhY3RpdmUgZGF0YWJhc2UgY29ubmVjdGlvbiB0byB1c2UgYW5kIHZhbGlkYXRlIHRoZSBwZXJzaXN0ZW50IGVudGl0aWVzIGFuZCBtYXBwaW5ncy4KLTxwPkNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5BZGQgY29ubmVjdGlvbjwvc3Bhbj4gdG8gY3JlYXRlIGEgbmV3IGRhdGFiYXNlIGNvbm5lY3Rpb24uPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MyByMWMzLXQzIj48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjRjMS10MyIgaGVhZGVycz0icjFjMS10MyI+Jm5ic3A7Jm5ic3A7T3ZlcnJpZGUgZGVmYXVsdCBzY2hlbWEgZnJvbSBjb25uZWN0aW9uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MyByMWMyLXQzIj5TZWxlY3QgYSBzY2hlbWEgb3RoZXIgdGhhbiB0aGUgZGVmYXVsdCBvbmUgdGhhdCBpcyBkZXJpdmVkIGZyb20gdGhlIGNvbm5lY3Rpb24gaW5mb3JtYXRpb24uIFVzZSB0aGlzIG9wdGlvbiBpZiB0aGUgZGVmYXVsdCBzY2hlbWEgY2Fubm90IGJlIHVzZWQuIEZvciBleGFtcGxlLCB1c2UgdGhpcyBvcHRpb24gd2hlbiB0aGUgZGVwbG95bWVudCBsb2dpbiBkaWZmZXJzIGZyb20gdGhlIGRlc2lnbi10aW1lIGxvZ2luLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDMgcjFjMy10MyI+VGhlIHZhbHVlIGNhbGN1bGF0ZWQgYnkgRGFsaS48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjVjMS10MyIgaGVhZGVycz0icjFjMS10MyI+SlBBIEltcGxlbWVudGF0aW9uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MyByMWMyLXQzIj5TZWxlY3QgdG8gdXNlIHRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+SlBBIGltcGxlbWVudGF0aW9uIHByb3ZpZGVkIGJ5IHRoZSBzZXJ2ZXIgYXQgcnVudGltZTwvc3Bhbj4sIG9yIHNlbGVjdCBhIHNwZWNpZmljIDxzcGFuIGNsYXNzPSJib2xkIj5pbXBsZW1lbnRhdGlvbiBsaWJyYXJ5PC9zcGFuPiB0aGF0IGNvbnRhaW4gdGhlIEphdmEgUGVyc2lzdGVuY2UgQVBJIChKUEEpIGFuZCBlbnRpdGllcyB0byBiZSBhZGRlZCB0byB0aGUgcHJvamVjdCdzIEphdmEgQnVpbGQgUGF0aC4KLTxwPkNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5Db25maWd1cmUgZGVmYXVsdCBKUEEgaW1wbGVtZW50YXRpb24gbGlicmFyeTwvc3Bhbj4gdG8gY3JlYXRlIGEgZGVmYXVsdCBsaWJyYXJ5IGZvciB0aGUgcHJvamVjdCBvciBjbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+Q29uZmlndXJlIHVzZXIgbGlicmFyaWVzPC9zcGFuPiB0byBkZWZpbmUgYWRkaXRpb25hbCBsaWJyYXJpZXMuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MyByMWMzLXQzIj5EZXRlcm1pbmVkIGJ5IHNlcnZlci48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjZjMS10MyIgaGVhZGVycz0icjFjMS10MyI+UGVyc2lzdGVudCBjbGFzcyBtYW5hZ2VtZW50PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10MyByMWMyLXQzIj5TcGVjaWZ5IGlmIERhbGkgd2lsbCA8c3BhbiBjbGFzcz0iYm9sZCI+ZGlzY292ZXIgYW5ub3RhdGVkIGNsYXNzZXMgYXV0b21hdGljYWxseTwvc3Bhbj4sIG9yIGlmIHRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+YW5ub3RhdGVkIGNsYXNzZXMgbXVzdCBiZSBsaXN0ZWQgaW4gdGhlIHBlcnNpc3RlbmNlLnhtbDwvc3Bhbj4gZmlsZS4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5Ob3RlPC9zcGFuPjogVG8gaW5zdXJlIGFwcGxpY2F0aW9uIHBvcnRhYmlsaXR5LCB5b3Ugc2hvdWxkIGV4cGxpY2l0bHkgbGlzdCB0aGUgbWFuYWdlZCBwZXJzaXN0ZW5jZSBjbGFzc2VzIHRoYXQgYXJlIGluY2x1ZGVkIGluIHRoZSBwZXJzaXN0ZW5jZSB1bml0LjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI2YzEtdDMgcjFjMy10MyI+RGV0ZXJtaW5lZCBieSBzZXJ2ZXIuPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI3YzEtdDMiIGhlYWRlcnM9InIxYzEtdDMiPkNyZWF0ZSBvcm0ueG1sPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjdjMS10MyByMWMyLXQzIj5TcGVjaWZ5IGlmIERhbGkgc2hvdWxkIGNyZWF0ZSBhIGRlZmF1bHQgPGNvZGU+b3JtLnhtbDwvY29kZT4gZmlsZSBmb3IgeW91ciBlbnRpdHkgbWFwcGluZ3MgYW5kIHBlcnNpc3RlbmNlIHVuaXQgZGVmYXVsdHMuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjdjMS10MyByMWMzLXQzIj5TZWxlY3RlZDwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibGluZm9ybWFsIiAtLT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gY2xhc3M9InNlY3QyIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZfbWFwcGluZ19nZW5lcmFsLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZfbWFwcGluZ19nZW5lcmFsLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZGY4ODM0Yy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX21hcHBpbmdfZ2VuZXJhbC5odG0KKysrIC9kZXYvbnVsbApAQCAtMSwyNjEgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTAgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5HZW5lcmFsIGluZm9ybWF0aW9uPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iR2VuZXJhbCBpbmZvcm1hdGlvbiIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNBQ0JIRklKIiBuYW1lPSJDQUNCSEZJSiI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QzIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+R2VuZXJhbCBpbmZvcm1hdGlvbjwvaDE+Ci08cD5UaGlzIHRhYmxlIGxpc3RzIHRoZSBHZW5lcmFsIHByb3BlcnRpZXMgYXZhaWxhYmxlIGluIHRoZSA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC10aXRsZSI+SmF2YSBEZXRhaWxzIHZpZXc8L3NwYW4+IGZvciBlYWNoIG1hcHBpbmcgdHlwZS48L3A+Ci08ZGl2IGNsYXNzPSJpbmZ0YmxydWxlaW5mb3JtYWwiPgotPHRhYmxlIGNsYXNzPSJSdWxlSW5mb3JtYWwiIHRpdGxlPSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgb3B0aW9ucyBvbiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyB2aWV3LiIgc3VtbWFyeT0iVGhpcyB0YWJsZSBkZXNjcmliZXMgdGhlIG9wdGlvbnMgb24gdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldy4iIGRpcj0ibHRyIiBib3JkZXI9IjEiIHdpZHRoPSIxMDAlIiBmcmFtZT0iYm9yZGVyIiBydWxlcz0iYWxsIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRoZWFkPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMS10MTAiPlByb3BlcnR5PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMyLXQxMCI+RGVzY3JpcHRpb248L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzMtdDEwIj5EZWZhdWx0PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWM0LXQxMCI+QXZhaWxhYmxlIGZvciBNYXBwaW5nIFR5cGU8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDEwIiBoZWFkZXJzPSJyMWMxLXQxMCI+TWFwcGluZyBUeXBlIEh5cGVybGluazwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDEwIHIxYzItdDEwIj5DbGlja2luZyB0aGUgbmFtZSBvZiB0aGUgbWFwcGluZyB0eXBlLCB3aGljaCBpcyByZXByZXNlbnRlZCBhcyBhIGh5cGVybGluaywgaW52b2tlcyB0aGUgTWFwcGluZyBUeXBlIFNlbGVjdGlvbiBkaWFsb2cuIFVzZSB0aGlzIGRpYWxvZyB0byBzcGVjaWZ5IHRoZSB0eXBlIG9mIGF0dHJpYnV0ZS48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQxMCByMWMzLXQxMCI+QmFzaWM8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQxMCByMWM0LXQxMCI+QWxsIG1hcHBpbmcgdHlwZXM8L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10MTAiIGhlYWRlcnM9InIxYzEtdDEwIj48YSBpZD0iQ0FDR0NCSEIiIG5hbWU9IkNBQ0dDQkhCIj48L2E+Q29sdW1uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MTAgcjFjMi10MTAiPjxhIGlkPSJzdGhyZWYxOTMiIG5hbWU9InN0aHJlZjE5MyI+PC9hPjxhIGlkPSJzdGhyZWYxOTQiIG5hbWU9InN0aHJlZjE5NCI+PC9hPlRoZSBkYXRhYmFzZSBjb2x1bW4gdGhhdCBjb250YWlucyB0aGUgdmFsdWUgZm9yIHRoZSBhdHRyaWJ1dGUuIFRoaXMgZmllbGQgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPkBDb2x1bW48L2NvZGU+IGFubm90YXRpb24uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MTAgcjFjMy10MTAiPkJ5IGRlZmF1bHQsIHRoZSBDb2x1bW4gaXMgYXNzdW1lZCB0byBiZSBuYW1lZCBpZGVudGljYWxseSB0byB0aGUgYXR0cmlidXRlLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDEwIHIxYzQtdDEwIj48YSBocmVmPSJ0YXNrczAxMC5odG0jQkFCQkFCQ0UiPkJhc2ljIG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxMS5odG0jQkFCQ0JIREYiPkVtYmVkZGVkIG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxMy5odG0jQkFCR0NCSEciPklEIG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxOS5odG0jQkFCSElCSUkiPlZlcnNpb24gbWFwcGluZzwvYT48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjRjMS10MTAiIGhlYWRlcnM9InIxYzEtdDEwIj4mbmJzcDsmbmJzcDtOYW1lPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MTAgcjFjMi10MTAiPk5hbWUgb2YgdGhlIGRhdGFiYXNlIGNvbHVtbi4KLTxwPlRoaXMgZmllbGQgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPkBDb2x1bW48L2NvZGU+IGFubm90YXRpb24uPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MTAgcjFjMy10MTAiPjxiciAvPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDEwIHIxYzQtdDEwIj48YSBocmVmPSJ0YXNrczAxMC5odG0jQkFCQkFCQ0UiPkJhc2ljIG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxMS5odG0jQkFCQ0JIREYiPkVtYmVkZGVkIG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxMy5odG0jQkFCR0NCSEciPklEIG1hcHBpbmc8L2E+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI1YzEtdDEwIiBoZWFkZXJzPSJyMWMxLXQxMCI+Jm5ic3A7Jm5ic3A7VGFibGU8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQxMCByMWMyLXQxMCI+TmFtZSBvZiB0aGUgZGF0YWJhc2UgdGFibGUgdGhhdCBjb250YWlucyB0aGUgc2VsZWN0ZWQgY29sdW1uLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDEwIHIxYzMtdDEwIj48YnIgLz48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQxMCByMWM0LXQxMCI+PGEgaHJlZj0idGFza3MwMTAuaHRtI0JBQkJBQkNFIj5CYXNpYyBtYXBwaW5nPC9hPiwgPGEgaHJlZj0idGFza3MwMTEuaHRtI0JBQkNCSERGIj5FbWJlZGRlZCBtYXBwaW5nPC9hPiwgPGEgaHJlZj0idGFza3MwMTMuaHRtI0JBQkdDQkhHIj5JRCBtYXBwaW5nPC9hPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNmMxLXQxMCIgaGVhZGVycz0icjFjMS10MTAiPiZuYnNwOyZuYnNwO0luc2VydGFibGU8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQxMCByMWMyLXQxMCI+U3BlY2lmaWVzIGlmIHRoZSBjb2x1bW4gaXMgYWx3YXlzIGluY2x1ZGVkIGluIDxjb2RlPlNRTCBJTlNFUlQ8L2NvZGU+IHN0YXRlbWVudHMuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10MTAgcjFjMy10MTAiPlRydWU8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQxMCByMWM0LXQxMCI+PGEgaHJlZj0idGFza3MwMTAuaHRtI0JBQkJBQkNFIj5CYXNpYyBtYXBwaW5nPC9hPiwgPGEgaHJlZj0idGFza3MwMTEuaHRtI0JBQkNCSERGIj5FbWJlZGRlZCBtYXBwaW5nPC9hPiwgPGEgaHJlZj0idGFza3MwMTMuaHRtI0JBQkdDQkhHIj5JRCBtYXBwaW5nPC9hPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyN2MxLXQxMCIgaGVhZGVycz0icjFjMS10MTAiPiZuYnNwOyZuYnNwO1VwZGF0YWJsZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI3YzEtdDEwIHIxYzItdDEwIj5TcGVjaWZpZXMgaWYgdGhpcyBjb2x1bW4gaXMgYWx3YXlzIGluY2x1ZGVkIGluIDxjb2RlPlNRTCBVUERBVEU8L2NvZGU+IHN0YXRlbWVudHMuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjdjMS10MTAgcjFjMy10MTAiPlRydWU8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyN2MxLXQxMCByMWM0LXQxMCI+PGEgaHJlZj0idGFza3MwMTAuaHRtI0JBQkJBQkNFIj5CYXNpYyBtYXBwaW5nPC9hPiwgPGEgaHJlZj0idGFza3MwMTEuaHRtI0JBQkNCSERGIj5FbWJlZGRlZCBtYXBwaW5nPC9hPiwgPGEgaHJlZj0idGFza3MwMTMuaHRtI0JBQkdDQkhHIj5JRCBtYXBwaW5nPC9hPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyOGMxLXQxMCIgaGVhZGVycz0icjFjMS10MTAiPiZuYnNwOyZuYnNwO1VuaXF1ZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI4YzEtdDEwIHIxYzItdDEwIj5TZXRzIHRoZSA8Y29kZT5VTklRVUU8L2NvZGU+IGNvbnN0cmFpbnQgZm9yIHRoZSBjb2x1bW4uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjhjMS10MTAgcjFjMy10MTAiPkZhbHNlPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjhjMS10MTAgcjFjNC10MTAiPjxhIGhyZWY9InRhc2tzMDEwLmh0bSNCQUJCQUJDRSI+QmFzaWMgbWFwcGluZzwvYT4sIDxhIGhyZWY9InRhc2tzMDExLmh0bSNCQUJDQkhERiI+RW1iZWRkZWQgbWFwcGluZzwvYT4sIDxhIGhyZWY9InRhc2tzMDEzLmh0bSNCQUJHQ0JIRyI+SUQgbWFwcGluZzwvYT48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjljMS10MTAiIGhlYWRlcnM9InIxYzEtdDEwIj4mbmJzcDsmbmJzcDtOdWxsYWJsZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI5YzEtdDEwIHIxYzItdDEwIj5TcGVjaWZpZXMgaWYgdGhlIGNvbHVtbiBhbGxvd3MgbnVsbCB2YWx1ZXMuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjljMS10MTAgcjFjMy10MTAiPlRydWU8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyOWMxLXQxMCByMWM0LXQxMCI+PGEgaHJlZj0idGFza3MwMTAuaHRtI0JBQkJBQkNFIj5CYXNpYyBtYXBwaW5nPC9hPiwgPGEgaHJlZj0idGFza3MwMTEuaHRtI0JBQkNCSERGIj5FbWJlZGRlZCBtYXBwaW5nPC9hPiwgPGEgaHJlZj0idGFza3MwMTMuaHRtI0JBQkdDQkhHIj5JRCBtYXBwaW5nPC9hPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMTBjMS10MTAiIGhlYWRlcnM9InIxYzEtdDEwIj4mbmJzcDsmbmJzcDtMZW5ndGg8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMTBjMS10MTAgcjFjMi10MTAiPlNldHMgdGhlIGNvbHVtbiBsZW5ndGguPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjEwYzEtdDEwIHIxYzMtdDEwIj4yNTU8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMTBjMS10MTAgcjFjNC10MTAiPjxhIGhyZWY9InRhc2tzMDEwLmh0bSNCQUJCQUJDRSI+QmFzaWMgbWFwcGluZzwvYT4sIDxhIGhyZWY9InRhc2tzMDExLmh0bSNCQUJDQkhERiI+RW1iZWRkZWQgbWFwcGluZzwvYT4sIDxhIGhyZWY9InRhc2tzMDEzLmh0bSNCQUJHQ0JIRyI+SUQgbWFwcGluZzwvYT48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjExYzEtdDEwIiBoZWFkZXJzPSJyMWMxLXQxMCI+Jm5ic3A7Jm5ic3A7UHJlY2lzaW9uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjExYzEtdDEwIHIxYzItdDEwIj5TZXRzIHRoZSBwcmVjaXNpb24gZm9yIHRoZSBjb2x1bW4gdmFsdWVzLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIxMWMxLXQxMCByMWMzLXQxMCI+MDwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIxMWMxLXQxMCByMWM0LXQxMCI+PGEgaHJlZj0idGFza3MwMTAuaHRtI0JBQkJBQkNFIj5CYXNpYyBtYXBwaW5nPC9hPiwgPGEgaHJlZj0idGFza3MwMTEuaHRtI0JBQkNCSERGIj5FbWJlZGRlZCBtYXBwaW5nPC9hPiwgPGEgaHJlZj0idGFza3MwMTMuaHRtI0JBQkdDQkhHIj5JRCBtYXBwaW5nPC9hPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMTJjMS10MTAiIGhlYWRlcnM9InIxYzEtdDEwIj4mbmJzcDsmbmJzcDtTY2FsZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIxMmMxLXQxMCByMWMyLXQxMCI+U2V0cyB0aGUgbnVtYmVyIG9mIGRpZ2l0cyB0aGF0IGFwcGVhciB0byB0aGUgcmlnaHQgb2YgdGhlIGRlY2ltYWwgcG9pbnQuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjEyYzEtdDEwIHIxYzMtdDEwIj4wPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjEyYzEtdDEwIHIxYzQtdDEwIj48YSBocmVmPSJ0YXNrczAxMC5odG0jQkFCQkFCQ0UiPkJhc2ljIG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxMS5odG0jQkFCQ0JIREYiPkVtYmVkZGVkIG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxMy5odG0jQkFCR0NCSEciPklEIG1hcHBpbmc8L2E+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIxM2MxLXQxMCIgaGVhZGVycz0icjFjMS10MTAiPiZuYnNwOyZuYnNwO0NvbHVtbiBEZWZpbml0aW9uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjEzYzEtdDEwIHIxYzItdDEwIj5EZWZpbmUgdGhlIERETCBmb3IgYSBjb2x1bW4uIFRoaXMgaXMgdXNlZCB3aGVuIGEgdGFibGUgaXMgYmVpbmcgZ2VuZXJhdGVkLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIxM2MxLXQxMCByMWMzLXQxMCI+PGJyIC8+PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjEzYzEtdDEwIHIxYzQtdDEwIj48YSBocmVmPSJ0YXNrczAxMC5odG0jQkFCQkFCQ0UiPkJhc2ljIG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxMS5odG0jQkFCQ0JIREYiPkVtYmVkZGVkIG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxMy5odG0jQkFCR0NCSEciPklEIG1hcHBpbmc8L2E+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIxNGMxLXQxMCIgaGVhZGVycz0icjFjMS10MTAiPjxhIGlkPSJDQUNHR0dIQiIgbmFtZT0iQ0FDR0dHSEIiPjwvYT48YSBpZD0ic3RocmVmMTk1IiBuYW1lPSJzdGhyZWYxOTUiPjwvYT48YSBpZD0ic3RocmVmMTk2IiBuYW1lPSJzdGhyZWYxOTYiPjwvYT48YSBpZD0ic3RocmVmMTk3IiBuYW1lPSJzdGhyZWYxOTciPjwvYT5GZXRjaCBUeXBlPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjE0YzEtdDEwIHIxYzItdDEwIj5EZWZpbmVzIGhvdyBkYXRhIGlzIGxvYWRlZCBmcm9tIHRoZSBkYXRhYmFzZToKLTx1bD4KLTxsaT4KLTxwPkVhZ2VyICZuZGFzaDsgRGF0YSBpcyBsb2FkZWQgaW4gYmVmb3JlIGl0IGlzIGFjdHVhbGx5IG5lZWRlZC48L3A+Ci08L2xpPgotPGxpPgotPHA+TGF6eSAmbmRhc2g7IERhdGEgaXMgbG9hZGVkIG9ubHkgd2hlbiByZXF1aXJlZCBieSB0aGUgdHJhbnNhY3Rpb24uPC9wPgotPC9saT4KLTwvdWw+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMTRjMS10MTAgcjFjMy10MTAiPkVhZ2VyPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjE0YzEtdDEwIHIxYzQtdDEwIj48YSBocmVmPSJ0YXNrczAxMC5odG0jQkFCQkFCQ0UiPkJhc2ljIG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxNy5odG0jQkFCRkhCQ0oiPk9uZS10by1vbmUgbWFwcGluZzwvYT4sIDxhIGhyZWY9InRhc2tzMDE0Lmh0bSNCQUJFSUVHRCI+TWFueS10by1tYW55IG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxNS5odG0jQkFCSEZBRkoiPk1hbnktdG8tb25lIG1hcHBpbmc8L2E+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIxNWMxLXQxMCIgaGVhZGVycz0icjFjMS10MTAiPk9wdGlvbmFsPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjE1YzEtdDEwIHIxYzItdDEwIj5TcGVjaWZpZXMgaWYgdGhpcyBmaWVsZCBpcyBjYW4gYmUgbnVsbC48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMTVjMS10MTAgcjFjMy10MTAiPlllczwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIxNWMxLXQxMCByMWM0LXQxMCI+PGEgaHJlZj0idGFza3MwMTAuaHRtI0JBQkJBQkNFIj5CYXNpYyBtYXBwaW5nPC9hPiwgPGEgaHJlZj0idGFza3MwMTcuaHRtI0JBQkZIQkNKIj5PbmUtdG8tb25lIG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxNS5odG0jQkFCSEZBRkoiPk1hbnktdG8tb25lIG1hcHBpbmc8L2E+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIxNmMxLXQxMCIgaGVhZGVycz0icjFjMS10MTAiPjxhIGlkPSJDQUNCQklCSSIgbmFtZT0iQ0FDQkJJQkkiPjwvYT48YSBpZD0ic3RocmVmMTk4IiBuYW1lPSJzdGhyZWYxOTgiPjwvYT5Mb2I8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMTZjMS10MTAgcjFjMi10MTAiPlNwZWNpZnkgaWYgdGhlIGZpZWxkIGlzIG1hcHBlZCB0byA8Y29kZT5qYXZhLnNxbC5DbG9iPC9jb2RlPiBvciA8Y29kZT5qYXZhLnNxbC5CbG9iPC9jb2RlPi4KLTxwPlRoaXMgZmllbGQgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPkBMb2I8L2NvZGU+IGFubm90YXRpb24uPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjE2YzEtdDEwIHIxYzMtdDEwIj48YnIgLz48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMTZjMS10MTAgcjFjNC10MTAiPjxhIGhyZWY9InRhc2tzMDEwLmh0bSNCQUJCQUJDRSI+QmFzaWMgbWFwcGluZzwvYT48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjE3YzEtdDEwIiBoZWFkZXJzPSJyMWMxLXQxMCI+PGEgaWQ9IkNBQ0VBSkdEIiBuYW1lPSJDQUNFQUpHRCI+PC9hPjxhIGlkPSJzdGhyZWYxOTkiIG5hbWU9InN0aHJlZjE5OSI+PC9hPjxhIGlkPSJzdGhyZWYyMDAiIG5hbWU9InN0aHJlZjIwMCI+PC9hPjxhIGlkPSJzdGhyZWYyMDEiIG5hbWU9InN0aHJlZjIwMSI+PC9hPlRlbXBvcmFsPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjE3YzEtdDEwIHIxYzItdDEwIj5TcGVjaWZpZXMgaWYgdGhpcyBmaWVsZCBpcyBvbmUgb2YgdGhlIGZvbGxvd2luZzoKLTx1bD4KLTxsaT4KLTxwPkRhdGUgJm5kYXNoOyA8Y29kZT5qYXZhLnNxbC5EYXRlPC9jb2RlPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5UaW1lICZuZGFzaDsgPGNvZGU+amF2YS5zcWwuVGltZTwvY29kZT48L3A+Ci08L2xpPgotPGxpPgotPHA+VGltZXN0YW1wICZuZGFzaDsgPGNvZGU+amF2YS5zcWwuVGltZXN0YW1wPC9jb2RlPjwvcD4KLTwvbGk+Ci08L3VsPgotPHA+VGhpcyBmaWVsZCBjb3JyZXNwb25kcyB0byB0aGUgPGNvZGU+QFRlbXBvcmFsPC9jb2RlPiBhbm5vdGF0aW9uLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIxN2MxLXQxMCByMWMzLXQxMCI+PGJyIC8+PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjE3YzEtdDEwIHIxYzQtdDEwIj48YSBocmVmPSJ0YXNrczAxMC5odG0jQkFCQkFCQ0UiPkJhc2ljIG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxMy5odG0jQkFCR0NCSEciPklEIG1hcHBpbmc8L2E+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIxOGMxLXQxMCIgaGVhZGVycz0icjFjMS10MTAiPjxhIGlkPSJzdGhyZWYyMDIiIG5hbWU9InN0aHJlZjIwMiI+PC9hPjxhIGlkPSJzdGhyZWYyMDMiIG5hbWU9InN0aHJlZjIwMyI+PC9hPjxhIGlkPSJzdGhyZWYyMDQiIG5hbWU9InN0aHJlZjIwNCI+PC9hPkVudW1lcmF0ZWQ8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMThjMS10MTAgcjFjMi10MTAiPlNwZWNpZnkgaG93IHRvIHBlcnNpc3QgZW51bWVyYXRlZCBjb25zdHJhaW50cyBpZiB0aGUgPGNvZGU+U3RyaW5nPC9jb2RlPiB2YWx1ZSBzdWl0cyB5b3VyIGFwcGxpY2F0aW9uIHJlcXVpcmVtZW50cyBvciB0byBtYXRjaCBhbiBleGlzdGluZyBkYXRhYmFzZSBzY2hlbWEuCi08dWw+Ci08bGk+Ci08cD5vcmRpbmFsPC9wPgotPC9saT4KLTxsaT4KLTxwPjxjb2RlPlN0cmluZzwvY29kZT48L3A+Ci08L2xpPgotPC91bD4KLTxwPlRoaXMgZmllbGQgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPkBFbnVtZXJhdGVkPC9jb2RlPiBhbm5vdGF0aW9uLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIxOGMxLXQxMCByMWMzLXQxMCI+T3JkaW5hbDwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIxOGMxLXQxMCByMWM0LXQxMCI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIxOWMxLXQxMCIgaGVhZGVycz0icjFjMS10MTAiPlRhcmdldCBFbnRpdHk8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMTljMS10MTAgcjFjMi10MTAiPlRoZSBwZXJzaXN0ZW50IGVudGl0eSB0byB3aGljaCB0aGUgYXR0cmlidXRlIGlzIG1hcHBlZC48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMTljMS10MTAgcjFjMy10MTAiPjxiciAvPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIxOWMxLXQxMCByMWM0LXQxMCI+PGEgaHJlZj0idGFza3MwMTcuaHRtI0JBQkZIQkNKIj5PbmUtdG8tb25lIG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxNi5odG0jQkFCSEdFQkQiPk9uZS10by1tYW55IG1hcHBpbmc8L2E+IDxhIGhyZWY9InRhc2tzMDE0Lmh0bSNCQUJFSUVHRCI+TWFueS10by1tYW55IG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxNS5odG0jQkFCSEZBRkoiPk1hbnktdG8tb25lIG1hcHBpbmc8L2E+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyMGMxLXQxMCIgaGVhZGVycz0icjFjMS10MTAiPjxhIGlkPSJDQUNKQUlIQiIgbmFtZT0iQ0FDSkFJSEIiPjwvYT5DYXNjYWRlIFR5cGU8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMjBjMS10MTAgcjFjMi10MTAiPlNwZWNpZnkgd2hpY2ggb3BlcmF0aW9ucyBhcmUgcHJvcGFnYXRlZCB0aHJvdWdob3V0IHRoZSBlbnRpdHkuCi08dWw+Ci08bGk+Ci08cD5BbGwgJm5kYXNoOyBBbGwgb3BlcmF0aW9uczwvcD4KLTwvbGk+Ci08bGk+Ci08cD5QZXJzaXN0PC9wPgotPC9saT4KLTxsaT4KLTxwPk1lcmdlPC9wPgotPC9saT4KLTxsaT4KLTxwPk1vdmU8L3A+Ci08L2xpPgotPGxpPgotPHA+UmVtb3ZlPC9wPgotPC9saT4KLTxsaT4KLTxwPlJlZnJlc2g8L3A+Ci08L2xpPgotPC91bD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyMGMxLXQxMCByMWMzLXQxMCI+PGJyIC8+PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjIwYzEtdDEwIHIxYzQtdDEwIj48YSBocmVmPSJ0YXNrczAxNy5odG0jQkFCRkhCQ0oiPk9uZS10by1vbmUgbWFwcGluZzwvYT4sIDxhIGhyZWY9InRhc2tzMDE2Lmh0bSNCQUJIR0VCRCI+T25lLXRvLW1hbnkgbWFwcGluZzwvYT4sIDxhIGhyZWY9InRhc2tzMDE0Lmh0bSNCQUJFSUVHRCI+TWFueS10by1tYW55IG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxNS5odG0jQkFCSEZBRkoiPk1hbnktdG8tb25lIG1hcHBpbmc8L2E+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyMWMxLXQxMCIgaGVhZGVycz0icjFjMS10MTAiPjxhIGlkPSJDQUNKREpKQSIgbmFtZT0iQ0FDSkRKSkEiPjwvYT5NYXBwZWQgQnk8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMjFjMS10MTAgcjFjMi10MTAiPlRoZSBmaWVsZCBpbiB0aGUgZGF0YWJhc2UgdGFibGUgdGhhdCAib3ducyIgdGhlIHJlbGF0aW9uc2hpcC4gVGhpcyBmaWVsZCBpcyByZXF1aXJlZCBvbmx5IG9uIHRoZSBub24tb3duaW5nIHNpZGUgb2YgdGhlIHJlbGF0aW9uc2hpcC48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMjFjMS10MTAgcjFjMy10MTAiPjxiciAvPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyMWMxLXQxMCByMWM0LXQxMCI+PGEgaHJlZj0idGFza3MwMTcuaHRtI0JBQkZIQkNKIj5PbmUtdG8tb25lIG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxNi5odG0jQkFCSEdFQkQiPk9uZS10by1tYW55IG1hcHBpbmc8L2E+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyMmMxLXQxMCIgaGVhZGVycz0icjFjMS10MTAiPjxhIGlkPSJDQUNEQURJSCIgbmFtZT0iQ0FDREFESUgiPjwvYT48YSBpZD0ic3RocmVmMjA1IiBuYW1lPSJzdGhyZWYyMDUiPjwvYT48YSBpZD0ic3RocmVmMjA2IiBuYW1lPSJzdGhyZWYyMDYiPjwvYT5PcmRlciBCeTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyMmMxLXQxMCByMWMyLXQxMCI+U3BlY2lmeSB0aGUgZGVmYXVsdCBvcmRlciBmb3Igb2JqZWN0cyByZXR1cm5lZCBmcm9tIGEgcXVlcnk6Ci08dWw+Ci08bGk+Ci08cD5ObyBvcmRlcmluZzwvcD4KLTwvbGk+Ci08bGk+Ci08cD5QcmltYXJ5IGtleTwvcD4KLTwvbGk+Ci08bGk+Ci08cD5DdXN0b20gb3JkZXJpbmc8L3A+Ci08L2xpPgotPC91bD4KLTxwPlRoaXMgZmllbGQgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPkBPcmRlckJ5PC9jb2RlPiBhbm5vdGF0aW9uLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyMmMxLXQxMCByMWMzLXQxMCI+UHJpbWFyeSBrZXk8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMjJjMS10MTAgcjFjNC10MTAiPjxhIGhyZWY9InRhc2tzMDE2Lmh0bSNCQUJIR0VCRCI+T25lLXRvLW1hbnkgbWFwcGluZzwvYT4uIDxhIGhyZWY9InRhc2tzMDE0Lmh0bSNCQUJFSUVHRCI+TWFueS10by1tYW55IG1hcHBpbmc8L2E+LCA8YSBocmVmPSJ0YXNrczAxNS5odG0jQkFCSEZBRkoiPk1hbnktdG8tb25lIG1hcHBpbmc8L2E+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyM2MxLXQxMCIgaGVhZGVycz0icjFjMS10MTAiPkF0dHJpYnV0ZSBPdmVycmlkZXM8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMjNjMS10MTAgcjFjMi10MTAiPk92ZXJyaWRlcyA8c3BhbiBjbGFzcz0iYm9sZCI+QmFzaWM8L3NwYW4+IG1hcHBpbmdzIG9mIGEgbWFwcGVkIHN1cGVyY2xhc3MgKGZvciBleGFtcGxlLCBpZiB0aGUgaW5oZXJpdGVkIGNvbHVtbiBuYW1lIGlzIGluY29tcGF0aWJsZSB3aXRoIGEgcHJlLWV4aXN0aW5nIGRhdGEgbW9kZWwsIG9yIGludmFsaWQgYXMgYSBjb2x1bW4gbmFtZSBpbiB5b3VyIGRhdGFiYXNlKS48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMjNjMS10MTAgcjFjMy10MTAiPjxiciAvPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyM2MxLXQxMCByMWM0LXQxMCI+PGEgaHJlZj0idGFza3MwMTEuaHRtI0JBQkNCSERGIj5FbWJlZGRlZCBtYXBwaW5nPC9hPgotPHA+PGEgaHJlZj0idGFza3MwMTEuaHRtI0JBQkNCSERGIj5FbWJlZGRlZCBtYXBwaW5nPC9hPjwvcD4KLTxiciAvPjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCIgLS0+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrX21hcHBpbmcuaHRtI0JBQkRHQklKIj5NYXBwaW5nIGFuIGVudGl0eTwvYT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZfbmV3X2pwYV9wcm9qZWN0Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZfbmV3X2pwYV9wcm9qZWN0Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzZlNmY1My4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX25ld19qcGFfcHJvamVjdC5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw4NSArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0OSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPk5ldyBKUEEgUHJvamVjdCBwYWdlPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iTmV3IEpQQSBQcm9qZWN0IHBhZ2UiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJDQUNCSkFHQyIgbmFtZT0iQ0FDQkpBR0MiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MyI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPk5ldyBKUEEgUHJvamVjdCBwYWdlPC9oMT4KLTxwPlRoaXMgdGFibGUgbGlzdHMgdGhlIHByb3BlcnRpZXMgYXZhaWxhYmxlIG9uIHRoZSBOZXcgSlBBIFByb2plY3QgcGFnZSBvZiB0aGUgPGEgaHJlZj0icmVmX25ld19qcGFfcHJvamVjdF93aXphcmQuaHRtI0NBQ0JKR0JHIj5DcmVhdGUgTmV3IEpQQSBQcm9qZWN0IHdpemFyZDwvYT4uPC9wPgotPGRpdiBjbGFzcz0iaW5mdGJsaW5mb3JtYWwiPgotPHRhYmxlIGNsYXNzPSJJbmZvcm1hbCIgdGl0bGU9IlRoaXMgdGFibGUgZGVzY3JpYmVzIHRoZSBvcHRpb25zIG9uIHRoZSBHZW5lcmF0ZSBEREwgLSBPYmplY3RzIHBhZ2UuIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgb3B0aW9ucyBvbiB0aGUgR2VuZXJhdGUgRERMIC0gT2JqZWN0cyBwYWdlLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQyIj5Qcm9wZXJ0eTwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMi10MiI+RGVzY3JpcHRpb248L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzMtdDIiPkRlZmF1bHQ8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDIiIGhlYWRlcnM9InIxYzEtdDIiPlByb2plY3QgbmFtZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDIgcjFjMi10MiI+TmFtZSBvZiB0aGUgRWNsaXBzZSBKUEEgcHJvamVjdC48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQyIHIxYzMtdDIiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyM2MxLXQyIiBoZWFkZXJzPSJyMWMxLXQyIj5Qcm9qZWN0IGNvbnRlbnRzPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MiByMWMyLXQyIj5Mb2NhdGlvbiBvZiB0aGUgd29ya3NwYWNlIGluIHdoaWNoIHRvIHNhdmUgdGhlIHByb2plY3QuCi08cD5VbnNlbGVjdCBUaGUgPHNwYW4gY2xhc3M9ImJvbGQiPlVzZSBEZWZhdWx0PC9zcGFuPiBvcHRpb24gYW5kIGNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5Ccm93c2U8L3NwYW4+IHRvIHNlbGVjdCBhIG5ldyBsb2NhdGlvbi48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQyIHIxYzMtdDIiPkN1cnJlbnQgd29ya3NwYWNlPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI0YzEtdDIiIGhlYWRlcnM9InIxYzEtdDIiPlRhcmdldCBydW50aW1lPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MiByMWMyLXQyIj5TZWxlY3QgYSBwcmUtZGVmaW5lZCB0YXJnZXQgZm9yIHRoZSBwcm9qZWN0LgotPHA+Q2xpY2sgPHNwYW4gY2xhc3M9ImJvbGQiPk5ldzwvc3Bhbj4gdG8gY3JlYXRlIGEgbmV3IGVudmlyb25tZW50IHdpdGggdGhlIE5ldyBTZXJ2ZXIgUnVudGltZSB3aXphcmQuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MiByMWMzLXQyIj48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjVjMS10MiIgaGVhZGVycz0icjFjMS10MiI+Q29uZmlndXJhdGlvbnM8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQyIHIxYzItdDIiPlNlbGVjdCBhIHByb2plY3QgY29uZmlndXJhdGlvbiB3aXRoIHByZS1kZWZpbmVkIGZhY2V0cy4KLTxwPlNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+Jmx0O2N1c3RvbSZndDs8L3NwYW4+IHRvIG1hbnVhbGx5IHNlbGVjdCB0aGUgZmFjZXRzIGZvciB0aGlzIHByb2plY3QuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MiByMWMzLXQyIj5VdGlsaXR5IEpQQSBwcm9qZWN0IHdpdGggSmF2YSA1LjA8L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjZjMS10MiIgaGVhZGVycz0icjFjMS10MiI+RUFSIG1lbWJlcnNoaXA8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQyIHIxYzItdDIiPlNwZWNpZnkgaWYgdGhpcyBwcm9qZWN0IHNob3VsZCBiZSBpbmNsdWRlZCBpbiBhbiBFQVIgZmlsZSBmb3IgZGVwbG95bWVudC4KLTxwPlNlbGVjdCB0aGUgPHNwYW4gY2xhc3M9ImJvbGQiPkVBUiBQcm9qZWN0IE5hbWU8L3NwYW4+LCBvciBjbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+TmV3PC9zcGFuPiB0byBjcmVhdGUgYSBuZXcgRUFSIHByb2plY3QuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10MiByMWMzLXQyIj48YnIgLz48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0YmxpbmZvcm1hbCIgLS0+PC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MyIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX25ld19qcGFfcHJvamVjdF93aXphcmQuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZl9uZXdfanBhX3Byb2plY3Rfd2l6YXJkLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmZiMDE0ZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX25ld19qcGFfcHJvamVjdF93aXphcmQuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNDUgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDkgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5DcmVhdGUgTmV3IEpQQSBQcm9qZWN0IHdpemFyZDwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IkNyZWF0ZSBOZXcgSlBBIFByb2plY3Qgd2l6YXJkIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0FDQkpHQkciIG5hbWU9IkNBQ0JKR0JHIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5DcmVhdGUgTmV3IEpQQSBQcm9qZWN0IHdpemFyZDwvaDE+Ci08cD5UaGUgQ3JlYXRlIE5ldyBKUEEgUHJvamVjdCB3aXphcmQgYWxsb3dzIHlvdSB0byBjcmVhdGUgYSBuZXcgSmF2YSBwcm9qZWN0IHVzaW5nIEpQQS4gVGhlIHdpemFyZCBjb25zaXN0cyBvZiB0aGUgZm9sbG93aW5nIHBhZ2VzOjwvcD4KLTx1bD4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZl9uZXdfanBhX3Byb2plY3QuaHRtI0NBQ0JKQUdDIj5OZXcgSlBBIFByb2plY3QgcGFnZTwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0icmVmX2pwYV9mYWNldC5odG0jQ0FDSUZESUYiPkpQQSBGYWNldCBwYWdlPC9hPjwvcD4KLTwvbGk+Ci08L3VsPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPjwvZGl2PgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYWJhNzYwMC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDUxICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjUwIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+SlBBIERldGFpbHMgdmlldyAoZm9yIGF0dHJpYnV0ZXMpPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iSlBBIERldGFpbHMgdmlldyAoZm9yIGF0dHJpYnV0ZXMpIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkFCSUZCQUYiIG5hbWU9IkJBQklGQkFGIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5KUEEgRGV0YWlscyB2aWV3IChmb3IgYXR0cmlidXRlcyk8L2gxPgotPHA+PGEgaWQ9InN0aHJlZjE5MCIgbmFtZT0ic3RocmVmMTkwIj48L2E+PGEgaWQ9InN0aHJlZjE5MSIgbmFtZT0ic3RocmVmMTkxIj48L2E+PGEgaWQ9InN0aHJlZjE5MiIgbmFtZT0ic3RocmVmMTkyIj48L2E+VGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5KUEEgRGV0YWlsczwvc3Bhbj4gdmlldyBkaXNwbGF5cyB0aGUgcGVyc2lzdGVuY2UgaW5mb3JtYXRpb24gZm9yIHRoZSBjdXJyZW50bHkgc2VsZWN0ZWQgbWFwcGVkIGF0dHJpYnV0ZSBhbmQgY29udGFpbnMgdGhlIGZvbGxvd2luZyBhcmVhczo8L3A+Ci08dWw+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZfbWFwcGluZ19nZW5lcmFsLmh0bSNDQUNCSEZJSiI+R2VuZXJhbCBpbmZvcm1hdGlvbjwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0icmVmZXJlbmNlMDE0Lmh0bSNDQUNCQUVCQyI+Sm9pbiBUYWJsZSBJbmZvcm1hdGlvbjwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0icmVmZXJlbmNlMDE1Lmh0bSNDQUNGQ0VKQyI+Sm9pbiBDb2x1bW5zIEluZm9ybWF0aW9uPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZfcHJpbWFyeV9rZXkuaHRtI0NBQ0ZDQ0FCIj5QcmltYXJ5IEtleSBHZW5lcmF0aW9uIGluZm9ybWF0aW9uPC9hPjwvcD4KLTwvbGk+Ci08L3VsPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPjwvZGl2PgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZl9wZXJzaXN0ZW5jZV9vdXRsaW5lLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZfcGVyc2lzdGVuY2Vfb3V0bGluZS5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDExZmE2YjIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZl9wZXJzaXN0ZW5jZV9vdXRsaW5lLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDQ4ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjUxIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+SlBBIFN0cnVjdHVyZSB2aWV3PC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iSlBBIFN0cnVjdHVyZSB2aWV3IiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkFCRUdHRkUiIG5hbWU9IkJBQkVHR0ZFIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5KUEEgU3RydWN0dXJlIHZpZXc8L2gxPgotPHA+PGEgaWQ9InN0aHJlZjIxNSIgbmFtZT0ic3RocmVmMjE1Ij48L2E+PGEgaWQ9InN0aHJlZjIxNiIgbmFtZT0ic3RocmVmMjE2Ij48L2E+VGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5KUEEgU3RydWN0dXJlPC9zcGFuPiB2aWV3IGRpc3BsYXlzIGFuIG91dGxpbmUgb2YgdGhlIHN0cnVjdHVyZSAoaXRzIGF0dHJpYnV0ZXMgYW5kIG1hcHBpbmdzKSBvZiB0aGUgZW50aXR5IHRoYXQgaXMgY3VycmVudGx5IHNlbGVjdGVkIG9yIG9wZW5lZCBpbiB0aGUgZWRpdG9yLiBUaGUgc3RydWN0dXJhbCBlbGVtZW50cyBzaG93biBpbiB0aGUgb3V0bGluZSBhcmUgdGhlIGVudGl0eSBhbmQgaXRzIGZpZWxkcy48L3A+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWYyMTciIG5hbWU9InN0aHJlZjIxNyI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPlNhbXBsZSBKUEEgU3RydWN0dXJlIFZpZXc8L3A+Ci08aW1nIHNyYz0iaW1nL3BlcnNpc3RlbmNlX291dGxpbmVfdmlldy5wbmciIGFsdD0iU2FtcGxlIEpQQSBTdHJ1Y3R1cmUgdmlldyBmb3IgYW4gZW50aXR5LiIgdGl0bGU9IlNhbXBsZSBKUEEgU3RydWN0dXJlIHZpZXcgZm9yIGFuIGVudGl0eS4iIC8+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJmaWd1cmUiIC0tPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHIucG5nIiBhbHQ9IlJlbGF0ZWQgcmVmZXJlbmNlIiB0aXRsZT0iUmVsYXRlZCByZWZlcmVuY2UiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wZXJzcGVjdGl2ZS5odG0jQkFCSUZCREIiPkpQQSBEZXZlbG9wbWVudCBwZXJzcGVjdGl2ZTwvYT4KLTxwPiZuYnNwOzwvcD4KLTwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDIiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZl9wZXJzaXN0ZW5jZV9wZXJzcGVjdGl2ZS5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX3BlcnNpc3RlbmNlX3BlcnNwZWN0aXZlLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzA5OTA4Ny4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX3BlcnNpc3RlbmNlX3BlcnNwZWN0aXZlLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDU1ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjUyIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+SlBBIERldmVsb3BtZW50IHBlcnNwZWN0aXZlPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iSlBBIERldmVsb3BtZW50IHBlcnNwZWN0aXZlIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkFCSUZCREIiIG5hbWU9IkJBQklGQkRCIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDEiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5KUEEgRGV2ZWxvcG1lbnQgcGVyc3BlY3RpdmU8L2gxPgotPHA+PGEgaWQ9InN0aHJlZjI0NCIgbmFtZT0ic3RocmVmMjQ0Ij48L2E+PGEgaWQ9InN0aHJlZjI0NSIgbmFtZT0ic3RocmVmMjQ1Ij48L2E+VGhlIDxzcGFuIGNsYXNzPSJib2xkIj5KUEEgRGV2ZWxvcG1lbnQgcGVyc3BlY3RpdmU8L3NwYW4+IGRlZmluZXMgdGhlIGluaXRpYWwgc2V0IGFuZCBsYXlvdXQgb2Ygdmlld3MgaW4gdGhlIFdvcmtiZW5jaCB3aW5kb3cgd2hlbiB1c2luZyBEYWxpLiBCeSBkZWZhdWx0LCB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpQQSBEZXZlbG9wbWVudCBwZXJzcGVjdGl2ZTwvc3Bhbj4gaW5jbHVkZXMgdGhlIGZvbGxvd2luZyB2aWV3czo8L3A+Ci08dWw+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZfcGVyc2lzdGVuY2Vfb3V0bGluZS5odG0jQkFCRUdHRkUiPkpQQSBTdHJ1Y3R1cmUgdmlldzwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3Byb3Bfdmlldy5odG0jQkFCRkFFQkIiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBlbnRpdGllcyk8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0jQkFCSUZCQUYiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBhdHRyaWJ1dGVzKTwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0icmVmX2RldGFpbHNfb3JtLmh0bSNDQUNHREdIQyI+SlBBIERldGFpbHMgdmlldyAoZm9yIG9ybS54bWwpPC9hPjwvcD4KLTwvbGk+Ci08L3VsPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxwPjxhIGhyZWY9Ii4uL29yZy5lY2xpcHNlLnBsYXRmb3JtLmRvYy51c2VyL2NvbmNlcHRzL2NvbmNlcHRzLTQuaHRtIj5QZXJzcGVjdGl2ZXM8L2E+PC9wPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MSIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX3BlcnNpc3RlbmNlX3Byb3Bfdmlldy5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX3BlcnNpc3RlbmNlX3Byb3Bfdmlldy5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQ3YTA3YzguLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZl9wZXJzaXN0ZW5jZV9wcm9wX3ZpZXcuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNTEgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDkgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5KUEEgRGV0YWlscyB2aWV3IChmb3IgZW50aXRpZXMpPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iSlBBIERldGFpbHMgdmlldyAoZm9yIGVudGl0aWVzKSIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkJBQkZBRUJCIiBuYW1lPSJCQUJGQUVCQiI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QyIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+SlBBIERldGFpbHMgdmlldyAoZm9yIGVudGl0aWVzKTwvaDE+Ci08cD48YSBpZD0ic3RocmVmMTc3IiBuYW1lPSJzdGhyZWYxNzciPjwvYT48YSBpZD0ic3RocmVmMTc4IiBuYW1lPSJzdGhyZWYxNzgiPjwvYT48YSBpZD0ic3RocmVmMTc5IiBuYW1lPSJzdGhyZWYxNzkiPjwvYT5UaGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpQQSBEZXRhaWxzPC9zcGFuPiB2aWV3IGRpc3BsYXlzIHRoZSBwZXJzaXN0ZW5jZSBpbmZvcm1hdGlvbiBmb3IgdGhlIGN1cnJlbnRseSBzZWxlY3RlZCBlbnRpdHkgYW5kIGNvbnRhaW5zIHRoZSBmb2xsb3dpbmcgdGFiczo8L3A+Ci08dWw+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZlcmVuY2UwMDkuaHRtI0NBQ0NBR0dDIj5HZW5lcmFsIGluZm9ybWF0aW9uPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZlcmVuY2UwMTAuaHRtI0NBQ0lKQkdIIj5BdHRyaWJ1dGUgb3ZlcnJpZGVzPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZlcmVuY2UwMTEuaHRtI0NBQ0JISURBIj5TZWNvbmRhcnkgdGFibGUgaW5mb3JtYXRpb248L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAxMi5odG0jQ0FDRkhHSEUiPkluaGVyaXRhbmNlIGluZm9ybWF0aW9uPC9hPjwvcD4KLTwvbGk+Ci08L3VsPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPjwvZGl2PgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZl9wcmltYXJ5X2tleS5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX3ByaW1hcnlfa2V5Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzk4YTU0OC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX3ByaW1hcnlfa2V5Lmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDEzOCArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo1MSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPlByaW1hcnkgS2V5IEdlbmVyYXRpb24gaW5mb3JtYXRpb248L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJQcmltYXJ5IEtleSBHZW5lcmF0aW9uIGluZm9ybWF0aW9uIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0FDRkNDQUIiIG5hbWU9IkNBQ0ZDQ0FCIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDMiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5QcmltYXJ5IEtleSBHZW5lcmF0aW9uIGluZm9ybWF0aW9uPC9oMT4KLTxwPlRoaXMgdGFibGUgbGlzdHMgdGhlIGZpZWxkcyBhdmFpbGFibGUgaW4gdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5QcmltYXJ5IEtleSBHZW5lcmF0aW9uPC9zcGFuPiBhcmVhIGluIEpQQSBEZXRhaWxzIHZpZXcgZm9yIDxhIGhyZWY9InRhc2tzMDEzLmh0bSNCQUJHQ0JIRyI+SUQgbWFwcGluZzwvYT4gdHlwZXMuPC9wPgotPGRpdiBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIj4KLTx0YWJsZSBjbGFzcz0iUnVsZUluZm9ybWFsIiB0aXRsZT0iVGhpcyB0YWJsZSBkZXNjcmliZXMgdGhlIG9wdGlvbnMgb24gdGhlIEpvaW4gQ29sdW1ucyB0YWIuIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgb3B0aW9ucyBvbiB0aGUgSm9pbiBDb2x1bW5zIHRhYi4iIGRpcj0ibHRyIiBib3JkZXI9IjEiIHdpZHRoPSIxMDAlIiBmcmFtZT0iYm9yZGVyIiBydWxlcz0iYWxsIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRoZWFkPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMS10MTMiPlByb3BlcnR5PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMyLXQxMyI+RGVzY3JpcHRpb248L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzMtdDEzIj5EZWZhdWx0PC90aD4KLTwvdHI+Ci08L3RoZWFkPgotPHRib2R5PgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMmMxLXQxMyIgaGVhZGVycz0icjFjMS10MTMiPjxhIGlkPSJDQUNCQUpCQyIgbmFtZT0iQ0FDQkFKQkMiPjwvYT5QcmltYXJ5IEtleSBHZW5lcmF0aW9uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MTMgcjFjMi10MTMiPjxhIGlkPSJzdGhyZWYyMTEiIG5hbWU9InN0aHJlZjIxMSI+PC9hPjxhIGlkPSJzdGhyZWYyMTIiIG5hbWU9InN0aHJlZjIxMiI+PC9hPlRoZXNlIGZpZWxkcyBkZWZpbmUgaG93IHRoZSBwcmltYXJ5IGtleSBpcyBnZW5lcmF0ZWQuIFRoZXNlIGZpZWxkcyBjb3JyZXNwb25kIHRvIHRoZSA8Y29kZT5AR2VuZXJhdGVkVmFsdWU8L2NvZGU+IGFubm90YXRpb24uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MTMgcjFjMy10MTMiPkdlbmVyYXRlZCBWYWx1ZTwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyM2MxLXQxMyIgaGVhZGVycz0icjFjMS10MTMiPjxhIGlkPSJDQUNKRUVFQyIgbmFtZT0iQ0FDSkVFRUMiPjwvYT4mbmJzcDsmbmJzcDsmbmJzcDtTdHJhdGVneTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDEzIHIxYzItdDEzIj4KLTx1bD4KLTxsaT5BdXRvPC9saT4KLTxsaT4KLTxwPklkZW50aXR5ICZuZGFzaDsgVmFsdWVzIGFyZSBhc3NpZ25lZCBieSB0aGUgZGF0YWJhc2UncyA8c3BhbiBjbGFzcz0iYm9sZCI+SWRlbnRpdHk8L3NwYW4+IGNvbHVtbi48L3A+Ci08L2xpPgotPGxpPgotPHA+U2VxdWVuY2UgJm5kYXNoOyBWYWx1ZXMgYXJlIGFzc2lnbmVkIGJ5IGEgc2VxdWVuY2UgdGFibGUgKHNlZSA8YSBocmVmPSIjQ0FDRkZIRUgiPlNlcXVlbmNlJm5ic3A7R2VuZXJhdG9yPC9hPikuPC9wPgotPC9saT4KLTxsaT4KLTxwPlRhYmxlICZuZGFzaDsgVmFsdWVzIGFyZSBhc3NpZ25lZCBieSBhIGRhdGFiYXNlIHRhYmxlIChzZWUgPGEgaHJlZj0iI0NBQ0dGRUFIIj5UYWJsZSBHZW5lcmF0b3I8L2E+KS48L3A+Ci08L2xpPgotPC91bD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDEzIHIxYzMtdDEzIj5BdXRvPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI0YzEtdDEzIiBoZWFkZXJzPSJyMWMxLXQxMyI+PGEgaWQ9IkJBQkVFQUhKIiBuYW1lPSJCQUJFRUFISiI+PC9hPiZuYnNwOyZuYnNwO0dlbmVyYXRvciBOYW1lPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MTMgcjFjMi10MTMiPlVuaXF1ZSBuYW1lIG9mIHRoZSBnZW5lcmF0ZWQgdmFsdWUuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MTMgcjFjMy10MTMiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNWMxLXQxMyIgaGVhZGVycz0icjFjMS10MTMiPjxhIGlkPSJDQUNHRkVBSCIgbmFtZT0iQ0FDR0ZFQUgiPjwvYT5UYWJsZSBHZW5lcmF0b3I8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQxMyByMWMyLXQxMyI+VGhlc2UgZmllbGRzIGRlZmluZSB0aGUgZGF0YWJhc2UgdGFibGUgdXNlZCBmb3IgZ2VuZXJhdGluZyB0aGUgcHJpbWFyeSBrZXkgYW5kIGNvcnJlc3BvbmQgdG8gdGhlIDxjb2RlPkBUYWJsZUdlbmVyYXRvcjwvY29kZT4gYW5ub3RhdGlvbi4KLTxwPlRoZXNlIGZpZWxkcyBhcHBseSBvbmx5IHdoZW4gPHNwYW4gY2xhc3M9ImJvbGQiPlN0cmF0ZWd5PC9zcGFuPiZuYnNwOz0mbmJzcDs8c3BhbiBjbGFzcz0iYm9sZCI+VGFibGU8L3NwYW4+LjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDEzIHIxYzMtdDEzIj48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjZjMS10MTMiIGhlYWRlcnM9InIxYzEtdDEzIj4mbmJzcDsmbmJzcDtOYW1lPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10MTMgcjFjMi10MTMiPlVuaXF1ZSBuYW1lIG9mIHRoZSBnZW5lcmF0b3IuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10MTMgcjFjMy10MTMiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyN2MxLXQxMyIgaGVhZGVycz0icjFjMS10MTMiPiZuYnNwOyZuYnNwO1RhYmxlPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjdjMS10MTMgcjFjMi10MTMiPkRhdGFiYXNlIHRhYmxlIHRoYXQgc3RvcmVzIHRoZSBnZW5lcmF0ZWQgSUQgdmFsdWVzLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI3YzEtdDEzIHIxYzMtdDEzIj48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjhjMS10MTMiIGhlYWRlcnM9InIxYzEtdDEzIj4mbmJzcDsmbmJzcDtQcmltYXJ5IEtleSBDb2x1bW48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyOGMxLXQxMyByMWMyLXQxMyI+VGhlIGNvbHVtbiBpbiB0aGUgdGFibGUgZ2VuZXJhdG9yJ3MgPHNwYW4gY2xhc3M9ImJvbGQiPlRhYmxlPC9zcGFuPiB0aGF0IGNvbnRhaW5zIHRoZSBwcmltYXJ5IGtleS48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyOGMxLXQxMyByMWMzLXQxMyI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI5YzEtdDEzIiBoZWFkZXJzPSJyMWMxLXQxMyI+Jm5ic3A7Jm5ic3A7VmFsdWUgQ29sdW1uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjljMS10MTMgcjFjMi10MTMiPlRoZSBjb2x1bW4gdGhhdCBzdG9yZXMgdGhlIGdlbmVyYXRlZCBJRCB2YWx1ZXMuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjljMS10MTMgcjFjMy10MTMiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMTBjMS10MTMiIGhlYWRlcnM9InIxYzEtdDEzIj4mbmJzcDsmbmJzcDtQcmltYXJ5IEtleSBDb2x1bW4gVmFsdWU8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMTBjMS10MTMgcjFjMi10MTMiPlRoZSB2YWx1ZSBmb3IgdGhlIDxzcGFuIGNsYXNzPSJib2xkIj5QcmltYXJ5IEtleSBDb2x1bW48L3NwYW4+IGluIHRoZSBnZW5lcmF0b3IgdGFibGUuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjEwYzEtdDEzIHIxYzMtdDEzIj48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjExYzEtdDEzIiBoZWFkZXJzPSJyMWMxLXQxMyI+PGEgaWQ9IkNBQ0ZGSEVIIiBuYW1lPSJDQUNGRkhFSCI+PC9hPlNlcXVlbmNlJm5ic3A7R2VuZXJhdG9yPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjExYzEtdDEzIHIxYzItdDEzIj48YSBpZD0ic3RocmVmMjEzIiBuYW1lPSJzdGhyZWYyMTMiPjwvYT48YSBpZD0ic3RocmVmMjE0IiBuYW1lPSJzdGhyZWYyMTQiPjwvYT5UaGVzZSBmaWVsZHMgZGVmaW5lIHRoZSBzcGVjaWZpYyBzZXF1ZW5jZSB1c2VkIGZvciBnZW5lcmF0aW5nIHRoZSBwcmltYXJ5IGtleSBhbmQgY29ycmVzcG9uZCB0byB0aGUgPGNvZGU+QFNlcXVlbmNlR2VuZXJhdG9yPC9jb2RlPiBhbm5vdGF0aW9uLgotPHA+VGhlc2UgZmllbGRzIGFwcGx5IG9ubHkgd2hlbiA8c3BhbiBjbGFzcz0iYm9sZCI+U3RyYXRlZ3k8L3NwYW4+ID0gPHNwYW4gY2xhc3M9ImJvbGQiPlNlcXVlbmNlPC9zcGFuPi48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMTFjMS10MTMgcjFjMy10MTMiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMTJjMS10MTMiIGhlYWRlcnM9InIxYzEtdDEzIj4mbmJzcDsmbmJzcDtOYW1lPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjEyYzEtdDEzIHIxYzItdDEzIj5OYW1lIG9mIHRoZSBzZXF1ZW5jZSB0YWJsZSB0byB1c2UgZm9yIGRlZmluaW5nIHByaW1hcnkga2V5IHZhbHVlcy48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMTJjMS10MTMgcjFjMy10MTMiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMTNjMS10MTMiIGhlYWRlcnM9InIxYzEtdDEzIj4mbmJzcDsmbmJzcDtTZXF1ZW5jZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIxM2MxLXQxMyByMWMyLXQxMyI+VW5pcXVlIG5hbWUgb2YgdGhlIHNlcXVlbmNlLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIxM2MxLXQxMyByMWMzLXQxMyI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIiAtLT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWx0LnBuZyIgYWx0PSJSZWxhdGVkIHRhc2siIHRpdGxlPSJSZWxhdGVkIHRhc2siIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InRhc2tzMDEzLmh0bSNCQUJHQ0JIRyI+SUQgbWFwcGluZzwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxyLnBuZyIgYWx0PSJSZWxhdGVkIHRhc2siIHRpdGxlPSJSZWxhdGVkIHRhc2siIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0jQkFCSUZCQUYiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBhdHRyaWJ1dGVzKTwvYT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gY2xhc3M9InNlY3QyIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZfcHJvamVjdF9wcm9wZXJ0aWVzLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZfcHJvamVjdF9wcm9wZXJ0aWVzLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMGZkNDczZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmX3Byb2plY3RfcHJvcGVydGllcy5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw4NCArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo1MiAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPlByb2plY3QgUHJvcGVydGllcyBwYWdlIC0gSlBBIE9wdGlvbnM8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJQcm9qZWN0IFByb3BlcnRpZXMgcGFnZSAtIEpQQSBPcHRpb25zIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkFCSkhCQ0kiIG5hbWU9IkJBQkpIQkNJIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5Qcm9qZWN0IFByb3BlcnRpZXMgcGFnZSAmbmRhc2g7IEpQQSBPcHRpb25zPC9oMT4KLTxwPjxhIGlkPSJzdGhyZWYyMzIiIG5hbWU9InN0aHJlZjIzMiI+PC9hPjxhIGlkPSJzdGhyZWYyMzMiIG5hbWU9InN0aHJlZjIzMyI+PC9hPlVzZSB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpQQTwvc3Bhbj4gb3B0aW9ucyBvbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPlByb3BlcnRpZXM8L3NwYW4+IHBhZ2UgdG8gc2VsZWN0IHRoZSBkYXRhYmFzZSBjb25uZWN0aW9uIHRvIHVzZSB3aXRoIHRoZSBwcm9qZWN0LjwvcD4KLTxwPlRoaXMgdGFibGUgbGlzdHMgdGhlIHByb3BlcnRpZXMgYXZhaWxhYmxlIGluIHRoZSA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC10aXRsZSI+SlBBIERldGFpbHMgcGFnZTwvc3Bhbj4uPC9wPgotPGRpdiBjbGFzcz0iaW5mdGJsaW5mb3JtYWwiPgotPHRhYmxlIGNsYXNzPSJJbmZvcm1hbCIgdGl0bGU9IlRoaXMgdGFibGUgZGVzY3JpYmVzIHRoZSBvcHRpb25zIG9uIHRoZSBQZXJzaXN0ZW5jZSBQcm9wZXJ0aWVzIHBhZ2UuIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgb3B0aW9ucyBvbiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyBwYWdlLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQyOCI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDI4Ij5EZXNjcmlwdGlvbjwvdGg+Ci08L3RyPgotPC90aGVhZD4KLTx0Ym9keT4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjJjMS10MjgiIGhlYWRlcnM9InIxYzEtdDI4Ij48YSBpZD0ic3RocmVmMjM0IiBuYW1lPSJzdGhyZWYyMzQiPjwvYT48YSBpZD0ic3RocmVmMjM1IiBuYW1lPSJzdGhyZWYyMzUiPjwvYT48YSBpZD0ic3RocmVmMjM2IiBuYW1lPSJzdGhyZWYyMzYiPjwvYT48YSBpZD0ic3RocmVmMjM3IiBuYW1lPSJzdGhyZWYyMzciPjwvYT5QbGF0Zm9ybTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDI4IHIxYzItdDI4Ij5TZWxlY3QgdGhlIHZlbmRvci1zcGVjaWZpYyBwbGF0Zm9ybS48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10MjgiIGhlYWRlcnM9InIxYzEtdDI4Ij48YSBpZD0ic3RocmVmMjM4IiBuYW1lPSJzdGhyZWYyMzgiPjwvYT48YSBpZD0ic3RocmVmMjM5IiBuYW1lPSJzdGhyZWYyMzkiPjwvYT48YSBpZD0ic3RocmVmMjQwIiBuYW1lPSJzdGhyZWYyNDAiPjwvYT5Db25uZWN0aW9uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MjggcjFjMi10MjgiPlRoZSBkYXRhYmFzZSBjb25uZWN0aW9uIHVzZWQgdG8gbWFwIHRoZSBwZXJzaXN0ZW50IGVudGl0aWVzLgotPHVsPgotPGxpPgotPHA+VG8gY3JlYXRlIGEgbmV3IGNvbm5lY3Rpb24sIGNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5BZGQgQ29ubmVjdGlvbnM8L3NwYW4+LjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5UbyByZWNvbm5lY3QgdG8gYW4gZXhpc3RpbmcgY29ubmVjdGlvbiwgY2xpY2sgPHNwYW4gY2xhc3M9ImJvbGQiPlJlY29ubmVjdDwvc3Bhbj4uPC9wPgotPC9saT4KLTwvdWw+Ci08L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjRjMS10MjgiIGhlYWRlcnM9InIxYzEtdDI4Ij4mbmJzcDsmbmJzcDtPdmVycmlkZSBkZWZhdWx0IHNjaGVtYSBmcm9tIGNvbm5lY3Rpb248L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQyOCByMWMyLXQyOCI+U2VsZWN0IGEgc2NoZW1hIG90aGVyIHRoYW4gdGhlIGRlZmF1bHQgb25lIGRlcml2ZWQgZnJvbSB0aGUgY29ubmVjdGlvbiBpbmZvcm1hdGlvbi4gVXNlIHRoaXMgb3B0aW9uIGlmIHRoZSBkZWZhdWx0IHNjaGVtYSBpcyBpbmNvcnJlY3Qgb3IgY2Fubm90IGJlIHVzZWQuIEZvciBleGFtcGxlLCB1c2UgdGhpcyBvcHRpb24gd2hlbiB0aGUgZGVwbG95bWVudCBsb2dpbiBkaWZmZXJzIGZyb20gdGhlIGRlc2lnbi10aW1lIGxvZ2luLjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNWMxLXQyOCIgaGVhZGVycz0icjFjMS10MjgiPlBlcnNpc3RlbnQgQ2xhc3MgTWFuYWdlbWVudDwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDI4IHIxYzItdDI4Ij5TcGVjaWZ5IGlmIERhbGkgd2lsbCA8c3BhbiBjbGFzcz0iYm9sZCI+ZGlzY292ZXIgYW5ub3RhdGVkIGNsYXNzZXMgYXV0b21hdGljYWxseTwvc3Bhbj4sIG9yIGlmIHRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+YW5ub3RhdGVkIGNsYXNzZXMgbXVzdCBiZSBsaXN0ZWQgaW4gdGhlIHBlcnNpc3RlbmNlLnhtbDwvc3Bhbj4gZmlsZS4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5Ob3RlPC9zcGFuPjogVG8gaW5zdXJlIGFwcGxpY2F0aW9uIHBvcnRhYmlsaXR5LCB5b3Ugc2hvdWxkIGV4cGxpY2l0bHkgbGlzdCB0aGUgbWFuYWdlZCBwZXJzaXN0ZW5jZSBjbGFzc2VzIHRoYXQgYXJlIGluY2x1ZGVkIGluIHRoZSBwZXJzaXN0ZW5jZSB1bml0LjwvcD4KLTwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibGluZm9ybWFsIiAtLT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWx0LnBuZyIgYWx0PSJSZWxhdGVkIHRhc2siIHRpdGxlPSJSZWxhdGVkIHRhc2siIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InRhc2tzMDI1Lmh0bSNCQUJEQkNCSSI+TW9kaWZ5aW5nIHBlcnNpc3RlbnQgcHJvamVjdCBwcm9wZXJ0aWVzPC9hPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDIiIC0tPgotPCEtLSBjbGFzcz0ic2VjdDEiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZS5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggY2NmNDA1Mi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDU5ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQ5IC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+UmVmZXJlbmNlPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iIFJlZmVyZW5jZSIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9InN0aHJlZjE2OCIgbmFtZT0ic3RocmVmMTY4Ij48L2E+PC9wPgotPGgxPlJlZmVyZW5jZTwvaDE+Ci08cD5UaGlzIHNlY3Rpb24gaW5jbHVkZXMgZGV0YWlsZWQgaGVscCBpbmZvcm1hdGlvbiBmb3IgZWFjaCBvZiB0aGUgZm9sbG93aW5nIGVsZW1lbnRzIGluIHRoZSBEYWxpIE9SIE1hcHBpbmcgVG9vbDo8L3A+Ci08dWw+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZlcmVuY2UwMDEuaHRtI0NBQ0pKSkpIIj5XaXphcmRzPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZlcmVuY2UwMDguaHRtI0NBQ0RKSUlHIj5Qcm9wZXJ0eSBwYWdlczwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0icmVmZXJlbmNlMDI4Lmh0bSNDQUNERUlFRSI+UHJlZmVyZW5jZXM8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAyOS5odG0jQ0FDR0VKREEiPkRpYWxvZ3M8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wZXJzcGVjdGl2ZS5odG0jQkFCSUZCREIiPkpQQSBEZXZlbG9wbWVudCBwZXJzcGVjdGl2ZTwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0icmVmZXJlbmNlMDMxLmh0bSNDQUNESENJQSI+SWNvbnMgYW5kIGJ1dHRvbnM8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAzNC5odG0jQ0FDQkJESUIiPkRhbGkgRGV2ZWxvcGVyIERvY3VtZW50YXRpb248L2E+PC9wPgotPC9saT4KLTwvdWw+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDAxLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMDEuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwYzMyNmQxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMDEuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNDUgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDkgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5XaXphcmRzPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iV2l6YXJkcyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNBQ0pKSkpIIiBuYW1lPSJDQUNKSkpKSCI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QxIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+V2l6YXJkczwvaDE+Ci08cD5UaGlzIHNlY3Rpb24gaW5jbHVkZXMgaW5mb3JtYXRpb24gb24gdGhlIGZvbGxvd2luZyB3aXphcmRzOjwvcD4KLTx1bD4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZl9uZXdfanBhX3Byb2plY3Rfd2l6YXJkLmh0bSNDQUNCSkdCRyI+Q3JlYXRlIE5ldyBKUEEgUHJvamVjdCB3aXphcmQ8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAwMi5odG0jQ0lBR0dHREYiPkNyZWF0ZSBKUEEgRW50aXR5IHdpemFyZDwvYT48L3A+Ci08L2xpPgotPC91bD4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT48L2Rpdj4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMDIuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAwMi5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDU1MzIyZTMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAwMi5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw0NSArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0OSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPkNyZWF0ZSBKUEEgRW50aXR5IHdpemFyZDwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IkNyZWF0ZSBKUEEgRW50aXR5IHdpemFyZCIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNJQUdHR0RGIiBuYW1lPSJDSUFHR0dERiI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QyIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+Q3JlYXRlIEpQQSBFbnRpdHkgd2l6YXJkPC9oMT4KLTxwPlRoZSBDcmVhdGUgSlBBIHdpemFyZCBlbmFibGVzIHlvdSB0byBxdWlja2x5IGFkZCBhbiBlbnRpdHkgYW5kIGFsc28gYWRkIHBlcnNpc3RlbmNlIGZpZWxkcyB0byB0aGF0IGVudGl0eS4gSW4gYWRkaXRpb24sIHRoaXMgd2l6YXJkIGFkZHMgdGhlIGFjY2Vzc29yIG1ldGhvZHMgKDxjb2RlPmdldHRlcjwvY29kZT4gYW5kIDxjb2RlPnNldHRlcjwvY29kZT4pIGluIHRoZSBjbGFzcyBmaWxlLiBUaGUgd2l6YXJkIGNvbnNpc3RzIG9mIHRoZSBmb2xsb3dpbmcgcGFnZXM6PC9wPgotPHVsPgotPGxpPgotPHA+PGEgaHJlZj0icmVmZXJlbmNlMDAzLmh0bSNDSUFGRUlHRiI+RW50aXR5IENsYXNzIHBhZ2U8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAwNC5odG0jQ0lBREVDSUEiPkVudGl0eSBQcm9wZXJ0aWVzIHBhZ2U8L2E+PC9wPgotPC9saT4KLTwvdWw+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+PC9kaXY+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDAzLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMDMuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyY2IwOGQ4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMDMuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsMTMxICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQ5IC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+RW50aXR5IENsYXNzIHBhZ2U8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJFbnRpdHkgQ2xhc3MgcGFnZSIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNJQUZFSUdGIiBuYW1lPSJDSUFGRUlHRiI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QzIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+RW50aXR5IENsYXNzIHBhZ2U8L2gxPgotPHA+VGhpcyB0YWJsZSBsaXN0cyB0aGUgcHJvcGVydGllcyBvZiB0aGUgRW50aXR5IENsYXNzIHBhZ2Ugb2YgdGhlIDxhIGhyZWY9InJlZmVyZW5jZTAwMi5odG0jQ0lBR0dHREYiPkNyZWF0ZSBKUEEgRW50aXR5IHdpemFyZDwvYT4uPC9wPgotPGRpdiBjbGFzcz0idGJsZm9ybWFsIj48YSBpZD0ic3RocmVmMTY5IiBuYW1lPSJzdGhyZWYxNjkiPjwvYT48YSBpZD0ic3RocmVmMTcwIiBuYW1lPSJzdGhyZWYxNzAiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWludGFibGUiPiZuYnNwOzwvcD4KLTx0YWJsZSBjbGFzcz0iRm9ybWFsIiB0aXRsZT0iIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgRW50aXR5IENsYXNzIHBhZ2Ugb2YgdGhlIENyZWF0ZSBKUEEgRW50aXRpZXMgd2l6YXJkLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJoc2lkZXMiIHJ1bGVzPSJncm91cHMiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQ0Ij5Qcm9wZXJ0eTwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMi10NCI+RGVzY3JpcHRpb248L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzMtdDQiPkRlZmF1bHQ8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDQiIGhlYWRlcnM9InIxYzEtdDQiPgotPHA+UHJvamVjdDwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDQgcjFjMi10NCI+Ci08cD5UaGUgbmFtZSBvZiB0IGhlIEpQQSBwcm9qZWN0LjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDQgcjFjMy10NCI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDQiIGhlYWRlcnM9InIxYzEtdDQiPgotPHA+U291cmNlIEZvbGRlcjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDQgcjFjMi10NCI+Ci08cD5UaGUgbG9jYXRpb24gb2YgdGhlIEpQQSBwcm9qZWN0J3Mgc3JjIGZvbGRlci48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQ0IHIxYzMtdDQiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNGMxLXQ0IiBoZWFkZXJzPSJyMWMxLXQ0Ij4KLTxwPkphdmEgUGFja2FnZTwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDQgcjFjMi10NCI+Ci08cD5UaGUgbmFtZSBvZiB0aGUgY2xhc3MgcGFja2FnZS48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQ0IHIxYzMtdDQiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNWMxLXQ0IiBoZWFkZXJzPSJyMWMxLXQ0Ij4KLTxwPkNsYXNzIG5hbWU8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQ0IHIxYzItdDQiPgotPHA+VGhlIG5hbWUgb2YgdGhlIEphdmEgY2xhc3MuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10NCByMWMzLXQ0Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjZjMS10NCIgaGVhZGVycz0icjFjMS10NCI+Ci08cD5TdXBlcmNsYXNzPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10NCByMWMyLXQ0Ij4KLTxwPlNlbGVjdCB0aGUgc3VwZXJjbGFzcy48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQ0IHIxYzMtdDQiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyN2MxLXQ0IiBoZWFkZXJzPSJyMWMxLXQ0Ij4KLTxwPkluaGVyaXRhbmNlPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjdjMS10NCByMWMyLXQ0Ij4KLTxwPkJlY2F1c2UgdGhlIHdpemFyZCBjcmVhdGVzIGEgSmF2YSBjbGFzcyB3aXRoIGFuIDxjb2RlPkBFbnRpdHk8L2NvZGU+IG5vdGF0aW9uLCB0aGUgPHNwYW4gY2xhc3M9ImJvbGQiPkVudGl0eTwvc3Bhbj4gb3B0aW9uIGlzIHNlbGVjdGVkIGJ5IGRlZmF1bHQuPC9wPgotPHA+U2VsZWN0IDxzcGFuIGNsYXNzPSJib2xkIj5NYXBwZWQgU3VwZXJjbGFzczwvc3Bhbj4gaWYgeW91IGRlZmluZWQgYSBzdXBlcmNsYXNzLjwvcD4KLTxwPlRvIGFkZCBhbiA8Y29kZT5ASW5oZXJpdGFuY2U8L2NvZGU+IG5vdGF0aW9uIHRvIHRoZSBlbnRpdHksIHNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+SW5oZXJpdGFuY2U8L3NwYW4+IGFuZCB0aGVuIHNlbGVjdCBvbmUgb2YgdGhlIGluaGVyaXRhbmNlIG1hcHBpbmcgc3RyYXRlZ2llcyAoZGVzY3JpYmVkIGluIEpTUiAyMjApOjwvcD4KLTx1bD4KLTxsaT4KLTxwPlNJTkdMRV9UQUJMRSAtLSBBbGwgY2xhc3NlcyBpbiBhIGhpZXJhcmNoeSBhcyBtYXBwZWQgdG8gYSBzaW5nbGUgdGFibGUuIFRoaXMgYW5ub3RhdGlvbiBpcyB3aXRob3V0IGFuIGF0dHJpYnV0ZSBmb3IgdGhlIGluaGVyaXRhbmNlIHN0cmF0ZWd5LjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5UQUJMRV9QRVJfQ0xBU1MgLS0gRWFjaCBjbGFzcyBpcyBtYXBwZWQgdG8gYSBzZXBhcmF0ZSB0YWJsZS48L3A+Ci08L2xpPgotPGxpPgotPHA+Sk9JTkVEIC0tIFRoZSByb290IG9mIHRoZSBjbGFzcyBoaWVyYXJjaHkgaXMgcmVwcmVzZW50ZWQgYnkgYSBzaW5nbGUgdGFibGUuIEVhY2ggc3ViY2xhc3MgaXMgcmVwcmVzZW50ZWQgYnkgYSBzZXBhcmF0ZSB0YWJsZSB0aGF0IGNvbnRhaW5zIHRob3NlIGZpZWxkcyB0aGF0IGFyZSBzcGVjaWZpYyB0byB0aGUgc3ViY2xhc3MgKG5vdCBpbmhlcml0ZWQgZnJvbSBpdHMgc3VwZXJjbGFzcyksIGFzIHdlbGwgYXMgdGhlIGNvbHVtbihzKSB0aGF0IHJlcHJlc2VudCBpdHMgcHJpbWFyeSBrZXkuIFRoZSBwcmltYXJ5IGtleSBjb2x1bW4ocykgb2YgdGhlIHN1YmNsYXNzIHRhYmxlIHNlcnZlcyBhcyBhIGZvcmVpZ24ga2V5IHRvIHRoZSBwcmltYXJ5IGtleSBvZiB0aGUgc3VwZXJjbGFzcyB0YWJsZS48L3A+Ci08L2xpPgotPC91bD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI3YzEtdDQgcjFjMy10NCI+Ci08cD5FbnRpdHk8L3A+Ci08L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjhjMS10NCIgaGVhZGVycz0icjFjMS10NCI+Ci08cD5YTUwgRW50aXR5IE1hcHBpbmdzPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjhjMS10NCByMWMyLXQ0Ij4KLTxwPlNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+QWRkIHRvIGVudGl0eSBtYXBwaW5ncyBpbiBYTUw8L3NwYW4+IHRvIGNyZWF0ZSBYTUwgbWFwcGluZ3MgaW4gPGNvZGU+b3JtLnhtbDwvY29kZT4sIHJhdGhlciB0aGFuIGFubm90YXRpb25zLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI4YzEtdDQgcjFjMy10NCI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0idGJsZm9ybWFsIiAtLT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMDQuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAwNC5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZkMWI5OTkuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAwNC5odG0KKysrIC9kZXYvbnVsbApAQCAtMSwxMTMgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDkgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5FbnRpdHkgUHJvcGVydGllcyBwYWdlPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iRW50aXR5IFByb3BlcnRpZXMgcGFnZSIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNJQURFQ0lBIiBuYW1lPSJDSUFERUNJQSI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QzIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+RW50aXR5IFByb3BlcnRpZXMgcGFnZTwvaDE+Ci08cD5UaGlzIHRhYmxlIGxpc3RzIHRoZSBwcm9wZXJ0aWVzIG9mIHRoZSBFbnRpdHkgUHJvcGVydGllcyBwYWdlIG9mIHRoZSA8YSBocmVmPSJyZWZlcmVuY2UwMDIuaHRtI0NJQUdHR0RGIj5DcmVhdGUgSlBBIEVudGl0eSB3aXphcmQ8L2E+LjwvcD4KLTxkaXYgY2xhc3M9InRibGZvcm1hbCI+PGEgaWQ9InN0aHJlZjE3MSIgbmFtZT0ic3RocmVmMTcxIj48L2E+PGEgaWQ9InN0aHJlZjE3MiIgbmFtZT0ic3RocmVmMTcyIj48L2E+Ci08cCBjbGFzcz0idGl0bGVpbnRhYmxlIj4mbmJzcDs8L3A+Ci08dGFibGUgY2xhc3M9IkZvcm1hbCIgdGl0bGU9IiIgc3VtbWFyeT0iVGhpcyB0YWJsZSB0byBiZSBjb252ZXJ0ZWQgdG8gaW5mb3JtYWwuIiBkaXI9Imx0ciIgYm9yZGVyPSIxIiB3aWR0aD0iMTAwJSIgZnJhbWU9ImhzaWRlcyIgcnVsZXM9Imdyb3VwcyIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0aGVhZD4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzEtdDUiPlByb3BlcnR5PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMyLXQ1Ij5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10NSI+RGVmYXVsdDwvdGg+Ci08L3RyPgotPC90aGVhZD4KLTx0Ym9keT4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjJjMS10NSIgaGVhZGVycz0icjFjMS10NSI+Ci08cD5FbnRpdHkgTmFtZTwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDUgcjFjMi10NSI+Ci08cD5UaGUgbmFtZSBvZiB0aGUgZW50aXR5LiBCeSBkZWZhdWx0LCB0aGlzIHZhbHVlIGlzIHRoZSBzYW1lIGFzIHRoZSBvbmUgZW50ZXJlZCBhcyB0aGUgY2xhc3MgbmFtZS4gSWYgdGhlIGVudGl0eSBuYW1lIGRpZmZlcnMgZnJvbSB0aGUgY2xhc3MgbmFtZSwgdGhlbiB0aGUgZW50aXR5IG5hbWUgaXMgYWRkZWQgYXMgYW4gYXR0cmlidXRlLiBGb3IgZXhhbXBsZTogPGNvZGU+QEVudGl0eShuYW1lPSJFbnRpdHlOYW1lIik8L2NvZGU+LjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDUgcjFjMy10NSI+Ci08cD5EZXRlcm1pbmVkIGJ5IHNlcnZlci48L3A+Ci08L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10NSIgaGVhZGVycz0icjFjMS10NSI+Ci08cD5UYWJsZSBOYW1lPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10NSByMWMyLXQ1Ij4KLTxwPlNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+VXNlIGRlZmF1bHQ8L3NwYW4+IHRvIG1hdGNoIHRoZSBuYW1lIG9mIHRoZSBtYXBwZWQgdGFibGUgbmFtZSB0byB0aGUgZW50aXR5IG5hbWUuIE90aGVyd2lzZSwgY2xlYXIgdGhlIDxzcGFuIGNsYXNzPSJib2xkIj5Vc2UgZGVmYXVsdDwvc3Bhbj4gb3B0aW9uIGFuZCBlbnRlciB0aGUgbmFtZSBpbiB0aGUgPHNwYW4gY2xhc3M9Iml0YWxpYyI+VGFibGUgTmFtZTwvc3Bhbj4gZmllbGQuIFRoZXNlIG9wdGlvbnMgcmVzdWx0IGluIHRoZSBhZGRpdGlvbiBvZiB0aGUgPGNvZGU+QFRhYmxlPC9jb2RlPiBvcHRpb24gdG8gdGhlIEphdmEgY2xhc3MgZmlsZS48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQ1IHIxYzMtdDUiPgotPHA+VXNlIGRlZmF1bHQuPC9wPgotPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI0YzEtdDUiIGhlYWRlcnM9InIxYzEtdDUiPgotPHA+RW50aXR5IEZpZWxkczwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDUgcjFjMi10NSI+Ci08cD5DbGljayB0aGUgPHNwYW4gY2xhc3M9ImJvbGQiPkFkZDwvc3Bhbj4gYnV0dG9uIHRvIGFkZCBwZXJzaXN0ZW5jZSBmaWVsZHMgdXNpbmcgdGhlIEVudGl0eSBGaWVsZHMgZGlhbG9nLiBUaGlzIGRpYWxvZyBlbmFibGUgeW91IHRvIGJ1aWxkIGEgZmllbGQgYnkgZW50ZXJpbmcgYSBmaWVsZCBuYW1lIGFuZCBzZWxlY3RpbmcgYW1vbmcgcGVyc2lzdGVuY2UgdHlwZXMuIFRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+S2V5PC9zcGFuPiBvcHRpb24gZW5hYmxlcyB5b3UgdG8gbWFyayBhIGZpZWxkIGFzIGEgcHJpbWFyeSBrZXkuIFRoZSBkaWFsb2cncyA8c3BhbiBjbGFzcz0iYm9sZCI+QnJvd3NlPC9zcGFuPiBmdW5jdGlvbiBlbmFibGVzIHlvdSB0byBhZGQgb3RoZXIgcGVyc2lzdGVuY2UgdHlwZXMgZGVzY3JpYmVkIGluIHRoZSBKUEEgc3BlY2lmaWNhdGlvbi4gVGhlIDxzcGFuIGNsYXNzPSJib2xkIj5FZGl0PC9zcGFuPiBidXR0b24gZW5hYmxlcyB5b3UgdG8gY2hhbmdlIHRoZSBuYW1lIG9yIHR5cGUgc2V0IGZvciBhIHBlcnNpc3RlbnQgZmllbGQuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10NSByMWMzLXQ1Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjVjMS10NSIgaGVhZGVycz0icjFjMS10NSI+Ci08cD5BY2Nlc3MgVHlwZTwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDUgcjFjMi10NSI+Ci08cD5TZWxlY3Qgd2hldGhlciB0aGUgZW50aXR5J3MgYWNjZXNzIHRvIGluc3RhbmNlIHZhcmlhYmxlcyBpcyBmaWVsZC1iYXNlZCBvciBwcm9wZXJ0eS1iYXNlZCwgYXMgZGVmaW5lZCBpbiB0aGUgSlBBIHNwZWNpZmljYXRpb24uPC9wPgotPHVsPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPkZpZWxkLWJhc2VkPC9zcGFuPiAmbmRhc2g7IEluc3RhbmNlIHZhcmlhYmxlcyBhcmUgYWNjZXNzZWQgZGlyZWN0bHkuIEFsbCBub24tdHJhbnNpZW50IGluc3RhbmNlIHZhcmlhYmxlcyBhcmUgcGVyc2lzdGVudC48L3A+Ci08L2xpPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPlByb3BlcnR5LWJhc2VkPC9zcGFuPiAmbmRhc2g7IFBlcnNpc3RlbnQgc3RhdGUgYWNjZXNzZWQgdGhyb3VnaCB0aGUgcHJvcGVydHkgYWNjZXNzb3IgbWV0aG9kcy4gVGhlIHByb3BlcnR5IGFjY2Vzc29yIG1ldGhvZHMgbXVzdCBiZSA8c3BhbiBjbGFzcz0iYm9sZCI+cHVibGljPC9zcGFuPiBvciA8c3BhbiBjbGFzcz0iYm9sZCI+cHJpdmF0ZTwvc3Bhbj4uPC9wPgotPC9saT4KLTwvdWw+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQ1IHIxYzMtdDUiPgotPHA+RmllbGQtYmFzZWQ8L3A+Ci08L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJ0Ymxmb3JtYWwiIC0tPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza3MwMDEuaHRtI0JBQkZCSkJHIj5DcmVhdGluZyBhIEpQQSBFbnRpdHk8L2E+PGJyIC8+Ci08YSBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0jQkFCSElDQUkiPkFkZGluZyBwZXJzaXN0ZW5jZSB0byBhIGNsYXNzPC9hPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHIucG5nIiBhbHQ9IlJlbGF0ZWQgcmVmZXJlbmNlIiB0aXRsZT0iUmVsYXRlZCByZWZlcmVuY2UiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wcm9wX3ZpZXcuaHRtI0JBQkZBRUJCIj5KUEEgRGV0YWlscyB2aWV3IChmb3IgZW50aXRpZXMpPC9hPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDMiIC0tPgotPCEtLSBjbGFzcz0ic2VjdDIiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAwNS5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDA1Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmJkNDA0My4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDA1Lmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDM4ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQ5IC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+TWFwcGluZyBGaWxlIFdpemFyZDwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9Ik1hcHBpbmcgRmlsZSBXaXphcmQiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJDSUFJSkNDRSIgbmFtZT0iQ0lBSUpDQ0UiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MiI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPk1hcHBpbmcgRmlsZSBXaXphcmQ8L2gxPgotPHA+VGhlIE1hcHBpbmcgRmlsZSB3aXphcmQgZW5hYmxlcyB5b3UgdG8gYWRkIGFuIDxjb2RlPm9ybS54bWw8L2NvZGU+IGZpbGUgdG8gYSBKUEEgcHJvamVjdCBpZiBubyBvYmplY3QgbWFwIGV4aXN0cyBhdCB0aGUgbG9jYXRpb24gc3BlY2lmaWVkLiBGb3IgZXhhbXBsZSwgaWYgeW91IGNsZWFyZWQgdGhlIDxzcGFuIGNsYXNzPSJib2xkIj5DcmVhdGUgb3JtLnhtbDwvc3Bhbj4gb3B0aW9uIG9uIHRoZSA8YSBocmVmPSJyZWZfanBhX2ZhY2V0Lmh0bSNDQUNJRkRJRiI+SlBBIEZhY2V0IHBhZ2U8L2E+LCB5b3UgY2FuIGxhdGVyIGFkZCB0aGUgPGNvZGU+b3JtLnhtbDwvY29kZT4gZmlsZSB0byB0aGUgc3JjIGZpbGUgb2YgdGhlIHByb2plY3QgdXNpbmcgdGhpcyB3aXphcmQuPC9wPgotPHA+VGhlIDxhIGhyZWY9IiNDSUFJSkNDRSI+TWFwcGluZyBGaWxlIFdpemFyZDwvYT4gY29uc2lzdHMgb2YgdGhlIE1hcHBpbmcgRmlsZSBwYWdlLjwvcD4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT48L2Rpdj4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMDYuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAwNi5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDIwMjhjMjMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAwNi5odG0KKysrIC9kZXYvbnVsbApAQCAtMSwxMTkgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDkgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5NYXBwaW5nIEZpbGUgV2l6YXJkPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iTWFwcGluZyBGaWxlIFdpemFyZCIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPGRpdiBjbGFzcz0ic2VjdDMiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT48YSBpZD0ic3RocmVmMTczIiBuYW1lPSJzdGhyZWYxNzMiPjwvYT4KLTxoMT5NYXBwaW5nIEZpbGU8L2gxPgotPHA+VGhpcyB0YWJsZSBsaXN0cyB0aGUgcHJvcGVydGllcyBvZiB0aGUgPGEgaHJlZj0icmVmZXJlbmNlMDA1Lmh0bSNDSUFJSkNDRSI+TWFwcGluZyBGaWxlIFdpemFyZDwvYT4uPC9wPgotPGRpdiBjbGFzcz0idGJsZm9ybWFsIj48YSBpZD0ic3RocmVmMTc0IiBuYW1lPSJzdGhyZWYxNzQiPjwvYT48YSBpZD0ic3RocmVmMTc1IiBuYW1lPSJzdGhyZWYxNzUiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWludGFibGUiPk1hcHBpbmcgRmlsZSBXaXphcmQgUHJvcGVydGllczwvcD4KLTx0YWJsZSBjbGFzcz0iRm9ybWFsIiB0aXRsZT0iTWFwcGluZyBGaWxlIFdpemFyZCBQcm9wZXJ0aWVzIiBzdW1tYXJ5PSIiIGRpcj0ibHRyIiBib3JkZXI9IjEiIHdpZHRoPSIxMDAlIiBmcmFtZT0iaHNpZGVzIiBydWxlcz0iZ3JvdXBzIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRoZWFkPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMS10NiI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDYiPkRlc2NyaXB0aW9uPC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMzLXQ2Ij5EZWZhdWx0PC90aD4KLTwvdHI+Ci08L3RoZWFkPgotPHRib2R5PgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMmMxLXQ2IiBoZWFkZXJzPSJyMWMxLXQ2Ij4KLTxwPlByb2plY3Q8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQ2IHIxYzItdDYiPgotPHA+VGhlIG5hbWUgb2YgdGhlIEpQQSBwcm9qZWN0LjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDYgcjFjMy10NiI+Ci08cD5TZWxlY3RlZC48L3A+Ci08L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10NiIgaGVhZGVycz0icjFjMS10NiI+Ci08cD5Tb3VyY2UgZm9sZGVyPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10NiByMWMyLXQ2Ij4KLTxwPlRoZSBsb2NhdGlvbiBvZiB0aGUgcHJvamVjdCdzIHNyYyBmb2xkZXIuIElmIG5lZWRlZCwgY2xpY2sgPHNwYW4gY2xhc3M9ImJvbGQiPkJyb3dzZTwvc3Bhbj4gdG8gcG9pbnQgdGhlIHdpemFyZCB0byB0aGUgc3JjIGZpbGUncyBsb2NhdGlvbi48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQ2IHIxYzMtdDYiPgotPHA+U2VsZWN0ZWQuPC9wPgotPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI0YzEtdDYiIGhlYWRlcnM9InIxYzEtdDYiPgotPHA+RmlsZSBQYXRoPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10NiByMWMyLXQ2Ij4KLTxwPlRoZSBsb2NhdGlvbiBmb3IgdGhlIG5ldyA8Y29kZT5vcm0ueG1sPC9jb2RlPiBmaWxlLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDYgcjFjMy10NiI+Ci08cD5TZWxlY3RlZC48L3A+Ci08L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjVjMS10NiIgaGVhZGVycz0icjFjMS10NiI+Ci08cD5EZWZhdWx0IEFjY2VzczwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDYgcjFjMi10NiI+Ci08cD5TZWxlY3Qgd2hldGhlciB0aGUgYWNjZXNzIHRvIHRoZSBlbnRpdHkgaXMgZmllbGQtYmFzZWQgb3IgcHJvcGVydHktYmFzZWQsIGFzIGRlZmluZWQgaW4gSlBBIHNwZWNpZmljYXRpb24uPC9wPgotPHVsPgotPGxpPgotPHA+Tm9uZSAmbmRhc2g7IE5vIGFjY2VzcyB0eXBlIHNwZWNpZmllZC48L3A+Ci08L2xpPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPlByb3BlcnR5LWJhc2VkPC9zcGFuPiAmbmRhc2g7IFBlcnNpc3RlbnQgc3RhdGUgYWNjZXNzZWQgdGhyb3VnaCB0aGUgcHJvcGVydHkgYWNjZXNzb3IgbWV0aG9kcy4gVGhlIHByb3BlcnR5IGFjY2Vzc29yIG1ldGhvZHMgbXVzdCBiZSA8c3BhbiBjbGFzcz0iYm9sZCI+cHVibGljPC9zcGFuPiBvciA8c3BhbiBjbGFzcz0iYm9sZCI+cHJpdmF0ZTwvc3Bhbj4uPC9wPgotPC9saT4KLTxsaT4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5GaWVsZC1iYXNlZDwvc3Bhbj4gJm5kYXNoOyBJbnN0YW5jZSB2YXJpYWJsZXMgYXJlIGFjY2Vzc2VkIGRpcmVjdGx5LiBBbGwgbm9uLXRyYW5zaWVudCBpbnN0YW5jZSB2YXJpYWJsZXMgYXJlIHBlcnNpc3RlbnQuPC9wPgotPC9saT4KLTwvdWw+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQ2IHIxYzMtdDYiPgotPHA+Tm9uZTwvcD4KLTwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNmMxLXQ2IiBoZWFkZXJzPSJyMWMxLXQ2Ij4KLTxwPkFkZCB0byBwZXJzaXN0ZW5jZSB1bml0PC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10NiByMWMyLXQ2Ij4KLTxwPkRlc2lnbmF0ZXMgdGhlIHBlcnNpc3RlbmNlIHVuaXQgZm9yIHRoaXMgb2JqZWN0IG1hcCBmaWxlLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI2YzEtdDYgcjFjMy10NiI+Ci08cD5TZWxlY3RlZC48L3A+Ci08L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJ0Ymxmb3JtYWwiIC0tPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDMiIC0tPgotPCEtLSBjbGFzcz0ic2VjdDIiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAwNy5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDA3Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZGU4YTAzYS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDA3Lmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDM5ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQ5IC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+TWFwcGluZyBGaWxlIFdpemFyZCBQcm9wZXJ0aWVzPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iTWFwcGluZyBGaWxlIFdpemFyZCBQcm9wZXJ0aWVzIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08ZGl2IGNsYXNzPSJzZWN0MiI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPjxhIGlkPSJzdGhyZWYxNzYiIG5hbWU9InN0aHJlZjE3NiI+PC9hPgotPGgxPkdlbmVyYXRlIERETCBmcm9tIEVudGl0aWVzIFdpemFyZDwvaDE+Ci08cD5UaGUgR2VuZXJhdGUgRERMIGZyb20gRW50aXRpZXMgV2l6YXJkIHRvIHF1aWNrbHkgY3JlYXRlIERETCBzY3JpcHRzIGZyb20geW91ciBwZXJzaXN0ZW50IGVudGl0aWVzLiBEYWxpIGF1dG9tYXRpY2FsbHkgY3JlYXRlcyB0aGUgbmVjZXNzYXJ5IHByaW1hcnkgYW5kIGZvcmVpZ24ga2V5cywgYmFzZWQgb24gdGhlIGVudGl0eSBtYXBwaW5ncy48L3A+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QyIiAtLT4KLTwhLS0gY2xhc3M9InNlY3QxIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMDguaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAwOC5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGUxYTM2ZDAuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAwOC5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw1MSArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0OSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPlByb3BlcnR5IHBhZ2VzPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iUHJvcGVydHkgcGFnZXMiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJDQUNESklJRyIgbmFtZT0iQ0FDREpJSUciPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MSI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPlByb3BlcnR5IHBhZ2VzPC9oMT4KLTxwPlRoaXMgc2VjdGlvbiBpbmNsdWRlcyBpbmZvcm1hdGlvbiBvbiB0aGUgZm9sbG93aW5nOjwvcD4KLTx1bD4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wcm9wX3ZpZXcuaHRtI0JBQkZBRUJCIj5KUEEgRGV0YWlscyB2aWV3IChmb3IgZW50aXRpZXMpPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtI0JBQklGQkFGIj5KUEEgRGV0YWlscyB2aWV3IChmb3IgYXR0cmlidXRlcyk8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZl9kZXRhaWxzX29ybS5odG0jQ0FDR0RHSEMiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBvcm0ueG1sKTwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX291dGxpbmUuaHRtI0JBQkVHR0ZFIj5KUEEgU3RydWN0dXJlIHZpZXc8L2E+PC9wPgotPC9saT4KLTwvdWw+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+PC9kaXY+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDA5Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMDkuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmMWI5YjI0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMDkuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsOTcgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDkgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5HZW5lcmFsIGluZm9ybWF0aW9uPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iR2VuZXJhbCBpbmZvcm1hdGlvbiIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNBQ0NBR0dDIiBuYW1lPSJDQUNDQUdHQyI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QzIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+R2VuZXJhbCBpbmZvcm1hdGlvbjwvaDE+Ci08cD5UaGlzIHRhYmxlIGxpc3RzIHRoZSBHZW5lcmFsIGluZm9ybWF0aW9uIGZpZWxkcyBhdmFpbGFibGUgaW4gdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5KUEEgRGV0YWlsczwvc3Bhbj4gdmlldyBmb3IgZWFjaCBlbnRpdHkgdHlwZS48L3A+Ci08ZGl2IGNsYXNzPSJpbmZ0YmxpbmZvcm1hbCI+Ci08dGFibGUgY2xhc3M9IkluZm9ybWFsIiB0aXRsZT0iVGhpcyB0YWJsZSBkZXNjcmliZXMgdGhlIG9wdGlvbnMgb24gdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldywgR2VuZXJhbCB0YWIuIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgb3B0aW9ucyBvbiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyB2aWV3LCBHZW5lcmFsIHRhYi4iIGRpcj0ibHRyIiBib3JkZXI9IjEiIHdpZHRoPSIxMDAlIiBmcmFtZT0iYm9yZGVyIiBydWxlcz0iYWxsIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRoZWFkPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMS10NyI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDciPkRlc2NyaXB0aW9uPC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMzLXQ3Ij5EZWZhdWx0PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWM0LXQ3Ij5BdmFpbGFibGUgZm9yIEVudGl0eSZuYnNwO1R5cGU8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDciIGhlYWRlcnM9InIxYzEtdDciPk1hcHBpbmcgVHlwZSBIeXBlcmxpbms8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQ3IHIxYzItdDciPkNsaWNraW5nIHRoZSBuYW1lIG9mIHRoZSBtYXBwaW5nIHR5cGUsIHdoaWNoIGlzIHJlcHJlc2VudGVkIGFzIGEgaHlwZXJsaW5rLCBpbnZva2VzIHRoZSBNYXBwaW5nIFR5cGUgU2VsZWN0aW9uIGRpYWxvZy4gVXNlIHRoaXMgZGlhbG9nIHRvIHNwZWNpZnkgdGhlIHR5cGUgb2YgZW50aXR5OiBNYXBwZWQgU3VwZXJjbGFzcywgRW1iZWRkYWJsZSBvciB0aGUgZGVmYXVsdCBtYXBwaW5nIHR5cGUuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10NyByMWMzLXQ3Ij5FbnRpdHk8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQ3IHIxYzQtdDciPjxhIGhyZWY9InRhc2tzMDA2Lmh0bSNCQUJHQklFRSI+RW50aXR5PC9hPiwgPGEgaHJlZj0idGFza3MwMDcuaHRtI0JBQkZFSUNFIj5FbWJlZGRhYmxlPC9hPiwgYW5kIDxhIGhyZWY9InRhc2tzMDA4Lmh0bSNCQUJEQUdDSSI+TWFwcGVkIHN1cGVyY2xhc3M8L2E+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDciIGhlYWRlcnM9InIxYzEtdDciPk5hbWU8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQ3IHIxYzItdDciPlRoZSBuYW1lIG9mIHRoaXMgZW50aXR5LiBCeSBkZWZhdWx0LCB0aGUgY2xhc3MgbmFtZSBpcyB1c2VkIGFzIHRoZSBlbnRpdHkgbmFtZS48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQ3IHIxYzMtdDciPjxiciAvPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDcgcjFjNC10NyI+PGEgaHJlZj0idGFza3MwMDYuaHRtI0JBQkdCSUVFIj5FbnRpdHk8L2E+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI0YzEtdDciIGhlYWRlcnM9InIxYzEtdDciPlRhYmxlPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10NyByMWMyLXQ3Ij5UaGUgZGVmYXVsdCBkYXRhYmFzZSB0YWJsZSBpbmZvcm1hdGlvbiBmb3IgdGhpcyBlbnRpdHkuIFRoZXNlIGZpZWxkcyBjYW4gYmUgb3ZlcnJpZGRlbiBieSB0aGUgaW5mb3JtYXRpb24gaW4gdGhlIDxhIGhyZWY9InJlZmVyZW5jZTAxMC5odG0jQ0FDSUpCR0giPkF0dHJpYnV0ZSBvdmVycmlkZXM8L2E+IGFyZWEuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10NyByMWMzLXQ3Ij48YnIgLz48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQ3IHIxYzQtdDciPjxhIGhyZWY9InRhc2tzMDA2Lmh0bSNCQUJHQklFRSI+RW50aXR5PC9hPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNWMxLXQ3IiBoZWFkZXJzPSJyMWMxLXQ3Ij4mbmJzcDsmbmJzcDtOYW1lPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10NyByMWMyLXQ3Ij5UaGUgbmFtZSBvZiB0aGUgcHJpbWFyeSBkYXRhYmFzZSB0YWJsZSBhc3NvY2lhdGVkIHdpdGggdGhlIGVudGl0eS48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQ3IHIxYzMtdDciPjxiciAvPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDcgcjFjNC10NyI+PGEgaHJlZj0idGFza3MwMDYuaHRtI0JBQkdCSUVFIj5FbnRpdHk8L2E+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI2YzEtdDciIGhlYWRlcnM9InIxYzEtdDciPiZuYnNwOyZuYnNwO0NhdGFsb2c8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQ3IHIxYzItdDciPlRoZSBkYXRhYmFzZSBjYXRhbG9nIHRoYXQgY29udGFpbnMgdGhlIDxzcGFuIGNsYXNzPSJib2xkIj5UYWJsZTwvc3Bhbj4uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10NyByMWMzLXQ3Ij5BcyBkZWZpbmVkIGluIDxjb2RlPm9ybS54bWw8L2NvZGU+LjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI2YzEtdDcgcjFjNC10NyI+PGEgaHJlZj0idGFza3MwMDYuaHRtI0JBQkdCSUVFIj5FbnRpdHk8L2E+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI3YzEtdDciIGhlYWRlcnM9InIxYzEtdDciPiZuYnNwOyZuYnNwO1NjaGVtYTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI3YzEtdDcgcjFjMi10NyI+VGhlIGRhdGFiYXNlIHNjaGVtYSB0aGF0IGNvbnRhaW5zIHRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+VGFibGU8L3NwYW4+LjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI3YzEtdDcgcjFjMy10NyI+QXMgZGVmaW5lZCBpbiA8Y29kZT5vcm0ueG1sPC9jb2RlPi48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyN2MxLXQ3IHIxYzQtdDciPjxhIGhyZWY9InRhc2tzMDA2Lmh0bSNCQUJHQklFRSI+RW50aXR5PC9hPjxiciAvPjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibGluZm9ybWFsIiAtLT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWx0LnBuZyIgYWx0PSJSZWxhdGVkIHRhc2siIHRpdGxlPSJSZWxhdGVkIHRhc2siIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InRhc2tfYWRkX3BlcnNpc3RlbmNlLmh0bSNCQUJISUNBSSI+QWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3M8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsci5wbmciIGFsdD0iUmVsYXRlZCByZWZlcmVuY2UiIHRpdGxlPSJSZWxhdGVkIHJlZmVyZW5jZSIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3Byb3Bfdmlldy5odG0jQkFCRkFFQkIiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBlbnRpdGllcyk8L2E+PC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MyIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDEwLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMTAuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyMWJkYWQwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMTAuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNzUgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDkgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5BdHRyaWJ1dGUgb3ZlcnJpZGVzPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iQXR0cmlidXRlIG92ZXJyaWRlcyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNBQ0lKQkdIIiBuYW1lPSJDQUNJSkJHSCI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QzIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+QXR0cmlidXRlIG92ZXJyaWRlczwvaDE+Ci08cD48YSBpZD0ic3RocmVmMTgwIiBuYW1lPSJzdGhyZWYxODAiPjwvYT48YSBpZD0ic3RocmVmMTgxIiBuYW1lPSJzdGhyZWYxODEiPjwvYT48YSBpZD0ic3RocmVmMTgyIiBuYW1lPSJzdGhyZWYxODIiPjwvYT5Vc2UgdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5BdHRyaWJ1dGUgT3ZlcnJpZGVzPC9zcGFuPiBhcmVhIGluIHRoZSA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC10aXRsZSI+SlBBIERldGFpbHM8L3NwYW4+IHZpZXcgdG8gb3ZlcnJpZGUgdGhlIGRlZmF1bHQgc2V0dGluZ3Mgc3BlY2lmaWVkIGluIHRoZSA8YSBocmVmPSJyZWZlcmVuY2UwMDkuaHRtI0NBQ0NBR0dDIj5HZW5lcmFsIGluZm9ybWF0aW9uPC9hPiBhcmVhIG9mIGFuIGF0dHJpYnV0ZS4gQXR0cmlidXRlIG92ZXJyaWRlcyBnZW5lcmFsbHkgb3ZlcnJpZGUvY29uZmlndXJlIGF0dHJpYnR1ZXMgdGhhdCBhcmUgaW5oZXJpdGVkIG9yIGVtYmVkZGVkLjwvcD4KLTxwPlRoaXMgdGFibGUgbGlzdHMgdGhlIEF0dHJpYnV0ZSBvdmVycmlkZSBmaWVsZHMgYXZhaWxhYmxlIGluIHRoZSA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC10aXRsZSI+SlBBIERldGFpbHM8L3NwYW4+IHZpZXcgZm9yIGVhY2ggZW50aXR5IHR5cGUuPC9wPgotPGRpdiBjbGFzcz0iaW5mdGJsaW5mb3JtYWwiPgotPHRhYmxlIGNsYXNzPSJJbmZvcm1hbCIgdGl0bGU9IlRoaXMgdGFibGUgZGVzY3JpYmVzIHRoZSBvcHRpb25zIG9uIHRoZSBQZXJzaXN0ZW5jZSBQcm9wZXJ0aWVzIHZpZXcsIEdlbmVyYWwgdGFiLiIgc3VtbWFyeT0iVGhpcyB0YWJsZSBkZXNjcmliZXMgdGhlIG9wdGlvbnMgb24gdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldywgR2VuZXJhbCB0YWIuIiBkaXI9Imx0ciIgYm9yZGVyPSIxIiB3aWR0aD0iMTAwJSIgZnJhbWU9ImJvcmRlciIgcnVsZXM9ImFsbCIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0aGVhZD4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzEtdDgiPlByb3BlcnR5PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMyLXQ4Ij5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10OCI+RGVmYXVsdDwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjNC10OCI+QXZhaWxhYmxlIGZvciBFbnRpdHkmbmJzcDtUeXBlPC90aD4KLTwvdHI+Ci08L3RoZWFkPgotPHRib2R5PgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMmMxLXQ4IiBoZWFkZXJzPSJyMWMxLXQ4Ij5BdHRyaWJ1dGUgT3ZlcnJpZGVzPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10OCByMWMyLXQ4Ij5TcGVjaWZ5IGEgcHJvcGVydHkgb3IgZmllbGQgdG8gYmUgb3ZlcnJpZGRlbiAoZnJvbSB0aGUgZGVmYXVsdCBtYXBwaW5ncykuIFNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+T3ZlcnJpZGUgRGVmYXVsdDwvc3Bhbj4uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10OCByMWMzLXQ4Ij48YnIgLz48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQ4IHIxYzQtdDgiPjxhIGhyZWY9InRhc2tzMDA2Lmh0bSNCQUJHQklFRSI+RW50aXR5PC9hPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyM2MxLXQ4IiBoZWFkZXJzPSJyMWMxLXQ4Ij5Kb2luIENvbHVtbnM8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQ4IHIxYzItdDgiPjxiciAvPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDggcjFjMy10OCI+PGJyIC8+PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10OCByMWM0LXQ4Ij48YSBocmVmPSJ0YXNrczAwNi5odG0jQkFCR0JJRUUiPkVudGl0eTwvYT48YnIgLz48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0YmxpbmZvcm1hbCIgLS0+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJyZWZlcmVuY2UwMDkuaHRtI0NBQ0NBR0dDIj5HZW5lcmFsIGluZm9ybWF0aW9uPC9hPjxiciAvPgotPGEgaHJlZj0idGFza19hZGRfcGVyc2lzdGVuY2UuaHRtI0JBQkhJQ0FJIj5BZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBjbGFzczwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxyLnBuZyIgYWx0PSJSZWxhdGVkIHJlZmVyZW5jZSIgdGl0bGU9IlJlbGF0ZWQgcmVmZXJlbmNlIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSNCQUJGQUVCQiI+SlBBIERldGFpbHMgdmlldyAoZm9yIGVudGl0aWVzKTwvYT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMTEuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAxMS5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVkNWUzNjguLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAxMS5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw0NyArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo1MCAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPlNlY29uZGFyeSB0YWJsZSBpbmZvcm1hdGlvbjwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IlNlY29uZGFyeSB0YWJsZSBpbmZvcm1hdGlvbiIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNBQ0JISURBIiBuYW1lPSJDQUNCSElEQSI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QzIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+U2Vjb25kYXJ5IHRhYmxlIGluZm9ybWF0aW9uPC9oMT4KLTxwPjxhIGlkPSJzdGhyZWYxODMiIG5hbWU9InN0aHJlZjE4MyI+PC9hPjxhIGlkPSJzdGhyZWYxODQiIG5hbWU9InN0aHJlZjE4NCI+PC9hPjxhIGlkPSJzdGhyZWYxODUiIG5hbWU9InN0aHJlZjE4NSI+PC9hPjxhIGlkPSJzdGhyZWYxODYiIG5hbWU9InN0aHJlZjE4NiI+PC9hPlVzZSB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPlNlY29uZGFyeSBUYWJsZXM8L3NwYW4+IGFyZWEgaW4gdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5KUEEgRGV0YWlsczwvc3Bhbj4gdmlldyB0byBhc3NvY2lhdGUgYWRkaXRpb25hbCB0YWJsZXMgd2l0aCBhbiBlbnRpdHkuIFVzZSB0aGlzIGFyZWEgaWYgdGhlIGRhdGEgYXNzb2NpYXRlZCB3aXRoIGFuIGVudGl0eSBpcyBzcHJlYWQgYWNyb3NzIG11bHRpcGxlIHRhYmxlcy48L3A+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrX2FkZGl0b25hbF90YWJsZXMuaHRtI0NJSEdCSUVJIj5TcGVjaWZ5aW5nIGFkZGl0aW9uYWwgdGFibGVzPC9hPjxiciAvPgotPGEgaHJlZj0idGFza19hZGRfcGVyc2lzdGVuY2UuaHRtI0JBQkhJQ0FJIj5BZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBjbGFzczwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxyLnBuZyIgYWx0PSJSZWxhdGVkIHJlZmVyZW5jZSIgdGl0bGU9IlJlbGF0ZWQgcmVmZXJlbmNlIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSNCQUJGQUVCQiI+SlBBIERldGFpbHMgdmlldyAoZm9yIGVudGl0aWVzKTwvYT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMTIuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAxMi5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDU0NDYwNGQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAxMi5odG0KKysrIC9kZXYvbnVsbApAQCAtMSwxMDAgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTAgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5Jbmhlcml0YW5jZSBpbmZvcm1hdGlvbjwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IkluaGVyaXRhbmNlIGluZm9ybWF0aW9uIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0FDRkhHSEUiIG5hbWU9IkNBQ0ZIR0hFIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDMiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5Jbmhlcml0YW5jZSBpbmZvcm1hdGlvbjwvaDE+Ci08cD48YSBpZD0ic3RocmVmMTg3IiBuYW1lPSJzdGhyZWYxODciPjwvYT48YSBpZD0ic3RocmVmMTg4IiBuYW1lPSJzdGhyZWYxODgiPjwvYT5UaGlzIHRhYmxlIGxpc3RzIHRoZSBmaWVsZHMgYXZhaWxhYmxlIG9uIHRoZSA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC10aXRsZSI+SW5oZXJpdGFuY2U8L3NwYW4+IGFyZWEgaW4gdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5KUEEgRGV0YWlsczwvc3Bhbj4gdmlldyBmb3IgZWFjaCBlbnRpdHkgdHlwZS48L3A+Ci08ZGl2IGNsYXNzPSJpbmZ0YmxydWxlaW5mb3JtYWwiPgotPHRhYmxlIGNsYXNzPSJSdWxlSW5mb3JtYWwiIHRpdGxlPSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgb3B0aW9ucyBvbiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyB2aWV3LCBJbmhlcml0YW5jZSB0YWIuIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgb3B0aW9ucyBvbiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyB2aWV3LCBJbmhlcml0YW5jZSB0YWIuIiBkaXI9Imx0ciIgYm9yZGVyPSIxIiB3aWR0aD0iMTAwJSIgZnJhbWU9ImJvcmRlciIgcnVsZXM9ImFsbCIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0aGVhZD4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzEtdDkiPlByb3BlcnR5PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMyLXQ5Ij5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10OSI+RGVmYXVsdDwvdGg+Ci08L3RyPgotPC90aGVhZD4KLTx0Ym9keT4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjJjMS10OSIgaGVhZGVycz0icjFjMS10OSI+U3RyYXRlZ3k8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQ5IHIxYzItdDkiPlNwZWNpZnkgdGhlIHN0cmF0ZWd5IHRvIHVzZSB3aGVuIG1hcHBpbmcgYSBjbGFzcyBvciBjbGFzcyBoaWVyYXJjaHk6Ci08dWw+Ci08bGk+Ci08cD5TaW5nbGUgdGFibGUgJm5kYXNoOyBBbGwgY2xhc3NlcyBpbiB0aGUgaGllcmFyY2h5IGFyZSBtYXBwZWQgdG8gYSBzaW5nbGUgdGFibGUuPC9wPgotPC9saT4KLTxsaT4KLTxwPkpvaW5lZCAmbmRhc2g7IFRoZSByb290IG9mIHRoZSBoaWVyYXJjaHkgaXMgbWFwcGVkIHRvIGEgc2luZ2xlIHRhYmxlOyBlYWNoIGNoaWxkIG1hcHMgdG8gaXRzIG93biB0YWJsZS48L3A+Ci08L2xpPgotPGxpPgotPHA+VGFibGUgcGVyIGNsYXNzICZuZGFzaDsgRWFjaCBjbGFzcyBpcyBtYXBwZWQgdG8gYSBzZXBhcmF0ZSB0YWJsZS48L3A+Ci08L2xpPgotPC91bD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDkgcjFjMy10OSI+U2luZ2xlIHRhYmxlPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDkiIGhlYWRlcnM9InIxYzEtdDkiPkRpc2NyaW1pbmF0b3IgQ29sdW1uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10OSByMWMyLXQ5Ij5Vc2UgdG8gc3BlY2lmeSB0aGUgbmFtZSBvZiB0aGUgZGlzY3JpbWluYXRvciBjb2x1bW4gd2hlbiB1c2luZyBhIDxzcGFuIGNsYXNzPSJib2xkIj5TaW5nbGU8L3NwYW4+IG9yIDxzcGFuIGNsYXNzPSJib2xkIj5Kb2luZWQ8L3NwYW4+IGluaGVyaXRhbmNlIHN0cmF0ZWd5LjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDkgcjFjMy10OSI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI0YzEtdDkiIGhlYWRlcnM9InIxYzEtdDkiPkRpc2NyaW1pbmF0b3IgVHlwZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDkgcjFjMi10OSI+U2V0IHRoaXMgZmllbGQgdG8gc2V0IHRoZSBkaXNjcmltaW5hdG9yIHR5cGUgdG8gPGNvZGU+Q2hhcjwvY29kZT4gb3IgPGNvZGU+SW50ZWdlcjwvY29kZT4gKGluc3RlYWQgb2YgaXRzIGRlZmF1bHQ6IDxjb2RlPlN0cmluZzwvY29kZT4pLiBUaGUgPHNwYW4gY2xhc3M9ImJvbGQiPkRpc2NyaW1pbmF0b3IgVmFsdWU8L3NwYW4+IG11c3QgY29uZm9ybSB0byB0aGlzIHR5cGUuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10OSByMWMzLXQ5Ij5TdHJpbmc8L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjVjMS10OSIgaGVhZGVycz0icjFjMS10OSI+RGlzY3JpbWluYXRvciBWYWx1ZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDkgcjFjMi10OSI+U3BlY2lmeSB0aGUgZGlzY3JpbWluYXRvciB2YWx1ZSB1c2VkIHRvIGRpZmZlcmVudGlhdGUgYW4gZW50aXR5IGluIHRoaXMgaW5oZXJpdGFuY2UgaGllcmFyY2h5LiBUaGUgdmFsdWUgbXVzdCBjb25mb3JtIHRvIHRoZSBzcGVjaWZpZWQgPHNwYW4gY2xhc3M9ImJvbGQiPkRpc2NyaW1pbmF0b3IgVHlwZTwvc3Bhbj4uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10OSByMWMzLXQ5Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjZjMS10OSIgaGVhZGVycz0icjFjMS10OSI+UHJpbWFyeSBLZXkgSm9pbiBDb2x1bW5zPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10OSByMWMyLXQ5Ij5Vc2UgdG8gb3ZlcnJpZGUgdGhlIGRlZmF1bHQgcHJpbWFyeSBrZXkgam9pbiBjb2x1bW5zLiBTZWxlY3QgPHNwYW4gY2xhc3M9ImJvbGQiPk92ZXJyaWRlIERlZmF1bHQ8L3NwYW4+LCB0aGVuIGNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5BZGQ8L3NwYW4+IHRvIHNlbGVjdCBuZXcgSm9pbiBDb2x1bW4uCi08cD5UaGlzIGZpZWxkIGNvcnJlc3BvbmRzIHdpdGggQFByaW1hcnlLZXlKb2luQ29sdW1uIGFubm90YXRpb24uPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10OSByMWMzLXQ5Ij48YnIgLz48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0YmxydWxlaW5mb3JtYWwiIC0tPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza19pbmhlcml0YW5jZS5odG0jQ0lIQ0NDSkQiPlNwZWNpZnlpbmcgZW50aXR5IGluaGVyaXRhbmNlPC9hPjxiciAvPgotPGEgaHJlZj0idGFza19hZGRfcGVyc2lzdGVuY2UuaHRtI0JBQkhJQ0FJIj5BZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBjbGFzczwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxyLnBuZyIgYWx0PSJSZWxhdGVkIHJlZmVyZW5jZSIgdGl0bGU9IlJlbGF0ZWQgcmVmZXJlbmNlIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSNCQUJGQUVCQiI+SlBBIERldGFpbHMgdmlldyAoZm9yIGVudGl0aWVzKTwvYT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMTMuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAxMy5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGRkNDk1ODIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAxMy5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw0NiArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo1MCAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPkluaGVyaXRhbmNlIGluZm9ybWF0aW9uPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iSW5oZXJpdGFuY2UgaW5mb3JtYXRpb24iIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxkaXYgY2xhc3M9InNlY3QzIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+PGEgaWQ9InN0aHJlZjE4OSIgbmFtZT0ic3RocmVmMTg5Ij48L2E+Ci08aDE+UXVlcmllczwvaDE+Ci08cD5Vc2UgdGhlIHF1ZXJpZXMgYXJlYSBvZiB0aGUgSlBBIERldGFpbHMgdmlldyB0byBjcmVhdGUgbmFtZWQgcXVlcmllcyBhbmQgbmFtZWQgbmF0aXZlIHF1ZXJpZXMuIFJlZmVyIHRvIDxhIGhyZWY9InRhc2tzMDA5Lmh0bSNCQUJJR0JHRyI+IkNyZWF0aW5nIE5hbWVkIFF1ZXJpZXMiPC9hPiBmb3IgYWRkaXRpb25hbCBpbmZvcm1hdGlvbi48L3A+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrczAwOS5odG0jQkFCSUdCR0ciPkNyZWF0aW5nIE5hbWVkIFF1ZXJpZXM8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsci5wbmciIGFsdD0iUmVsYXRlZCByZWZlcmVuY2UiIHRpdGxlPSJSZWxhdGVkIHJlZmVyZW5jZSIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3Byb3Bfdmlldy5odG0jQkFCRkFFQkIiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBlbnRpdGllcyk8L2E+PC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MyIgLS0+Ci08IS0tIGNsYXNzPSJzZWN0MiIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDE0Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMTQuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkMTk5NzgxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMTQuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNzggKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTAgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5Kb2luIFRhYmxlIEluZm9ybWF0aW9uPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iSm9pbiBUYWJsZSBJbmZvcm1hdGlvbiIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNBQ0JBRUJDIiBuYW1lPSJDQUNCQUVCQyI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QzIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+Sm9pbiBUYWJsZSBJbmZvcm1hdGlvbjwvaDE+Ci08cD5Vc2UgYXJlYSB0byBzcGVjaWZ5IGEgbWFwcGVkIGNvbHVtbiBmb3Igam9pbmluZyBhbiBlbnRpdHkgYXNzb2NpYXRpb24uIEJ5IGRlZmF1bHQsIHRoZSBtYXBwaW5nIGlzIGFzc3VtZWQgdG8gaGF2ZSBhIHNpbmdsZSBqb2luLjwvcD4KLTxwPlRoaXMgdGFibGUgbGlzdHMgdGhlIGZpZWxkcyBhdmFpbGFibGUgb24gdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5Kb2luIFRhYmxlPC9zcGFuPiBhcmVhIGluIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj50aGUgSlBBIERldGFpbHM8L3NwYW4+IHZpZXcgZm9yIDxhIGhyZWY9InRhc2tzMDE2Lmh0bSNCQUJIR0VCRCI+T25lLXRvLW1hbnkgbWFwcGluZzwvYT4gYW5kIDxhIGhyZWY9InRhc2tzMDE0Lmh0bSNCQUJFSUVHRCI+TWFueS10by1tYW55IG1hcHBpbmc8L2E+IG1hcHBpbmcgdHlwZXMuPC9wPgotPGRpdiBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIj4KLTx0YWJsZSBjbGFzcz0iUnVsZUluZm9ybWFsIiB0aXRsZT0iVGhpcyB0YWJsZSBkZXNjcmliZXMgdGhlIG9wdGlvbnMgb24gdGhlIEpvaW4gVGFibGUgdGFiLiIgc3VtbWFyeT0iVGhpcyB0YWJsZSBkZXNjcmliZXMgdGhlIG9wdGlvbnMgb24gdGhlIEpvaW4gVGFibGUgdGFiLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQxMSI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDExIj5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10MTEiPkRlZmF1bHQ8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDExIiBoZWFkZXJzPSJyMWMxLXQxMSI+TmFtZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDExIHIxYzItdDExIj5OYW1lIG9mIHRoZSBqb2luIHRhYmxlIHRoYXQgY29udGFpbnMgdGhlIGZvcmVpZ24ga2V5IGNvbHVtbi48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQxMSByMWMzLXQxMSI+QnkgZGVmYXVsdCwgdGhlIG5hbWUgaXMgYXNzdW1lZCB0byBiZSB0aGUgcHJpbWFyeSB0YWJsZXMgYXNzb2NpYXRlZCB3aXRoIHRoZSBlbnRpdGllcyBjb25jYXRlbmF0ZWQgd2l0aCBhbiB1bmRlcnNjb3JlLjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyM2MxLXQxMSIgaGVhZGVycz0icjFjMS10MTEiPjxhIGlkPSJDQUNCQkRGRyIgbmFtZT0iQ0FDQkJERkciPjwvYT5Kb2luIENvbHVtbnM8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQxMSByMWMyLXQxMSI+PGEgaWQ9InN0aHJlZjIwNyIgbmFtZT0ic3RocmVmMjA3Ij48L2E+PGEgaWQ9InN0aHJlZjIwOCIgbmFtZT0ic3RocmVmMjA4Ij48L2E+U3BlY2lmeSBhIG1hcHBlZCBjb2x1bW4gZm9yIGpvaW5pbmcgYW4gZW50aXR5IGFzc29jaWF0aW9uLiBUaGlzIGZpZWxkIGNvcnJlc3BvbmRzIHRvIHRoZSA8Y29kZT5ASm9pbkNvbHVtPC9jb2RlPiBhdHRyaWJ1dGUuCi08cD5TZWxlY3QgPHNwYW4gY2xhc3M9ImJvbGQiPk92ZXJyaWRlIERlZmF1bHQ8L3NwYW4+LCB0aGVuIEFkZCwgRWRpdCwgb3IgUmVtb3ZlIHRoZSBqb2luIGNvbHVtbnMuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MTEgcjFjMy10MTEiPkJ5IGRlZmF1bHQsIHRoZSBtYXBwaW5nIGlzIGFzc3VtZWQgdG8gaGF2ZSBhIHNpbmdsZSBqb2luLjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNGMxLXQxMSIgaGVhZGVycz0icjFjMS10MTEiPkludmVyc2UgSm9pbiBDb2x1bW5zPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MTEgcjFjMi10MTEiPlNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+T3ZlcnJpZGUgRGVmYXVsdDwvc3Bhbj4sIHRoZW4gQWRkLCBFZGl0LCBvciBSZW1vdmUgdGhlIGpvaW4gY29sdW1ucy48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQxMSByMWMzLXQxMSI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIiAtLT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWx0LnBuZyIgYWx0PSJSZWxhdGVkIHRhc2siIHRpdGxlPSJSZWxhdGVkIHRhc2siIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InRhc2tfbWFwcGluZy5odG0jQkFCREdCSUoiPk1hcHBpbmcgYW4gZW50aXR5PC9hPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHIucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0icmVmZXJlbmNlMDMwLmh0bSNDQUNDR0VIQyI+RWRpdCBKb2luIENvbHVtbnMgRGlhbG9nPC9hPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDMiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAxNS5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDE1Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMTFlMzVmYS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDE1Lmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDY3ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjUwIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+Sm9pbiBDb2x1bW5zIEluZm9ybWF0aW9uPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iSm9pbiBDb2x1bW5zIEluZm9ybWF0aW9uIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0FDRkNFSkMiIG5hbWU9IkNBQ0ZDRUpDIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDMiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5Kb2luIENvbHVtbnMgSW5mb3JtYXRpb248L2gxPgotPHA+VGhpcyB0YWJsZSBsaXN0cyB0aGUgZmllbGRzIGF2YWlsYWJsZSBpbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpvaW4gVGFibGU8L3NwYW4+IGFyZWEgaW4gPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpQQSBEZXRhaWxzPC9zcGFuPiB2aWV3IGZvciA8YSBocmVmPSJ0YXNrczAxNS5odG0jQkFCSEZBRkoiPk1hbnktdG8tb25lIG1hcHBpbmc8L2E+IGFuZCA8YSBocmVmPSJ0YXNrczAxNy5odG0jQkFCRkhCQ0oiPk9uZS10by1vbmUgbWFwcGluZzwvYT4gbWFwcGluZyB0eXBlcy48L3A+Ci08ZGl2IGNsYXNzPSJpbmZ0YmxydWxlaW5mb3JtYWwiPgotPHRhYmxlIGNsYXNzPSJSdWxlSW5mb3JtYWwiIHRpdGxlPSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgb3B0aW9ucyBvbiB0aGUgSm9pbiBDb2x1bW5zIHRhYi4iIHN1bW1hcnk9IlRoaXMgdGFibGUgZGVzY3JpYmVzIHRoZSBvcHRpb25zIG9uIHRoZSBKb2luIENvbHVtbnMgdGFiLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQxMiI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDEyIj5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10MTIiPkRlZmF1bHQ8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDEyIiBoZWFkZXJzPSJyMWMxLXQxMiI+Sm9pbiBDb2x1bW48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQxMiByMWMyLXQxMiI+PGEgaWQ9InN0aHJlZjIwOSIgbmFtZT0ic3RocmVmMjA5Ij48L2E+PGEgaWQ9InN0aHJlZjIxMCIgbmFtZT0ic3RocmVmMjEwIj48L2E+U3BlY2lmeSBhIG1hcHBlZCBjb2x1bW4gZm9yIGpvaW5pbmcgYW4gZW50aXR5IGFzc29jaWF0aW9uLiBUaGlzIGZpZWxkIGNvcnJlc3BvbmRzIHRvIHRoZSA8Y29kZT5ASm9pbkNvbHVtPC9jb2RlPiBhdHRyaWJ1dGUuCi08cD5TZWxlY3QgPHNwYW4gY2xhc3M9ImJvbGQiPk92ZXJyaWRlIERlZmF1bHQ8L3NwYW4+LCB0aGVuIEFkZCwgRWRpdCwgb3IgUmVtb3ZlIHRoZSBqb2luIGNvbHVtbnMuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MTIgcjFjMy10MTIiPkJ5IGRlZmF1bHQsIHRoZSBtYXBwaW5nIGlzIGFzc3VtZWQgdG8gaGF2ZSBhIHNpbmdsZSBqb2luLjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCIgLS0+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrX21hcHBpbmcuaHRtI0JBQkRHQklKIj5NYXBwaW5nIGFuIGVudGl0eTwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxyLnBuZyIgYWx0PSJSZWxhdGVkIHRhc2siIHRpdGxlPSJSZWxhdGVkIHRhc2siIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InJlZmVyZW5jZTAzMC5odG0jQ0FDQ0dFSEMiPkVkaXQgSm9pbiBDb2x1bW5zIERpYWxvZzwvYT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMTYuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAxNi5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGI5MzhhNDcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAxNi5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw5NCArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo1MSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPkdlbmVyYWwgaW5mb3JtYXRpb248L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJHZW5lcmFsIGluZm9ybWF0aW9uIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0FDQ0FDR0giIG5hbWU9IkNBQ0NBQ0dIIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDMiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5HZW5lcmFsIGluZm9ybWF0aW9uPC9oMT4KLTxwPlRoaXMgdGFibGUgbGlzdHMgdGhlIEdlbmVyYWwgaW5mb3JtYXRpb24gZmllbGRzIGF2YWlsYWJsZSBpbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpQQSBEZXRhaWxzPC9zcGFuPiB2aWV3IGZvciBlYWNoIGVudGl0eSB0eXBlLjwvcD4KLTxkaXYgY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCI+Ci08dGFibGUgY2xhc3M9IlJ1bGVJbmZvcm1hbCIgdGl0bGU9IlRoaXMgdGFibGUgZGVzY3JpYmVzIHRoZSBvcHRpb25zIG9uIHRoZSBQZXJzaXN0ZW5jZSBQcm9wZXJ0aWVzIHZpZXcsIEdlbmVyYWwgdGFiLiIgc3VtbWFyeT0iVGhpcyB0YWJsZSBkZXNjcmliZXMgdGhlIG9wdGlvbnMgb24gdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldywgR2VuZXJhbCB0YWIuIiBkaXI9Imx0ciIgYm9yZGVyPSIxIiB3aWR0aD0iMTAwJSIgZnJhbWU9ImJvcmRlciIgcnVsZXM9ImFsbCIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0aGVhZD4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzEtdDE0Ij5Qcm9wZXJ0eTwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMi10MTQiPkRlc2NyaXB0aW9uPC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMzLXQxNCI+RGVmYXVsdDwvdGg+Ci08L3RyPgotPC90aGVhZD4KLTx0Ym9keT4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjJjMS10MTQiIGhlYWRlcnM9InIxYzEtdDE0Ij5QYWNrYWdlPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MTQgcjFjMi10MTQiPlRoZSBKYXZhIHBhY2thZ2UgdGhhdCBjb250YWlucyB0aGUgcGVyc2lzdGVudCBlbnRpdGllcy4gQ2xpY2sgPHNwYW4gY2xhc3M9ImJvbGQiPkJyb3dzZTwvc3Bhbj4gYW5kIHNlbGVjdCB0aGUgcGFja2FnZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDE0IHIxYzMtdDE0Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10MTQiIGhlYWRlcnM9InIxYzEtdDE0Ij5TY2hlbWE8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQxNCByMWMyLXQxNCI+VGhlIGRhdGFiYXNlIHNjaGVtYSB0aGF0IGNvbnRhaW5zIHRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+VGFibGU8L3NwYW4+LgotPHA+VGhpcyBmaWVsZCBjb3JyZXNwb25kcyB0byB0aGUgPGNvZGU+Jmx0O3NjaGVtYSZndDs8L2NvZGU+IGVsZW1lbnQgaW4gdGhlIDxjb2RlPm9ybS54bWw8L2NvZGU+IGZpbGUuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MTQgcjFjMy10MTQiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNGMxLXQxNCIgaGVhZGVycz0icjFjMS10MTQiPkNhdGFsb2c8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQxNCByMWMyLXQxNCI+VGhlIGRhdGFiYXNlIGNhdGFsb2cgdGhhdCBjb250YWlucyB0aGUgPHNwYW4gY2xhc3M9ImJvbGQiPlRhYmxlPC9zcGFuPi4KLTxwPlRoaXMgZmllbGQgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPiZsdDtjYXRhbG9nJmd0OzwvY29kZT4gZWxlbWVudCBpbiB0aGUgPGNvZGU+b3JtLnhtbDwvY29kZT4gZmlsZS48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQxNCByMWMzLXQxNCI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI1YzEtdDE0IiBoZWFkZXJzPSJyMWMxLXQxNCI+QWNjZXNzPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MTQgcjFjMi10MTQiPlNwZWNpZnkgdGhlIGRlZmF1bHQgYWNjZXNzIG1ldGhvZCBmb3IgdGhlIHZhcmlhYmxlcyBpbiB0aGUgcHJvamVjdDoKLTx1bD4KLTxsaT4KLTxwPlByb3BlcnR5PC9wPgotPC9saT4KLTxsaT4KLTxwPkZpZWxkPC9wPgotPC9saT4KLTwvdWw+Ci08cD5UaGlzIGZpZWxkIGNvcnJlc3BvbmRzIHRvIHRoZSA8Y29kZT4mbHQ7YWNjZXNzJmd0OzwvY29kZT4gZWxlbWVudCBpbiB0aGUgPGNvZGU+b3JtLnhtbDwvY29kZT4gZmlsZS48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQxNCByMWMzLXQxNCI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIiAtLT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWx0LnBuZyIgYWx0PSJSZWxhdGVkIHRhc2siIHRpdGxlPSJSZWxhdGVkIHRhc2siIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InRhc2tfYWRkX3BlcnNpc3RlbmNlLmh0bSNCQUJISUNBSSI+QWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3M8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsci5wbmciIGFsdD0iUmVsYXRlZCByZWZlcmVuY2UiIHRpdGxlPSJSZWxhdGVkIHJlZmVyZW5jZSIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3Byb3Bfdmlldy5odG0jQkFCRkFFQkIiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBlbnRpdGllcyk8L2E+PC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MyIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDE3Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMTcuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlMTgzMTcyLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMTcuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsMTAzICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjUxIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+UGVyc2lzdGVuY2UgVW5pdCBpbmZvcm1hdGlvbjwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IlBlcnNpc3RlbmNlIFVuaXQgaW5mb3JtYXRpb24iIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJDQUNFQUdCRyIgbmFtZT0iQ0FDRUFHQkciPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MyI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPlBlcnNpc3RlbmNlIFVuaXQgaW5mb3JtYXRpb248L2gxPgotPHA+VGhpcyB0YWJsZSBsaXN0cyB0aGUgUGVyc2lzdGVuY2UgVW5pdCBpbmZvcm1hdGlvbiBmaWVsZHMgYXZhaWxhYmxlIGluIHRoZSA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC10aXRsZSI+SlBBIERldGFpbHM8L3NwYW4+IHZpZXcgZm9yIGVhY2ggZW50aXR5IHR5cGUuIFRoZXNlIGZpZWxkcyBhcmUgY29udGFpbmVkIGluIHRoZSA8Y29kZT4mbHQ7cGVyc2lzdGVuY2UtdW5pdC1tZXRhZGF0YSZndDs8L2NvZGU+IGVsZW1lbnQgaW4gdGhlIDxjb2RlPm9ybS54bWw8L2NvZGU+IGZpbGUuPC9wPgotPGRpdiBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIj4KLTx0YWJsZSBjbGFzcz0iUnVsZUluZm9ybWFsIiB0aXRsZT0iVGhpcyB0YWJsZSBkZXNjcmliZXMgdGhlIG9wdGlvbnMgb24gdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldywgR2VuZXJhbCB0YWIuIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgb3B0aW9ucyBvbiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyB2aWV3LCBHZW5lcmFsIHRhYi4iIGRpcj0ibHRyIiBib3JkZXI9IjEiIHdpZHRoPSIxMDAlIiBmcmFtZT0iYm9yZGVyIiBydWxlcz0iYWxsIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRoZWFkPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMS10MTUiPlByb3BlcnR5PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMyLXQxNSI+RGVzY3JpcHRpb248L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzMtdDE1Ij5EZWZhdWx0PC90aD4KLTwvdHI+Ci08L3RoZWFkPgotPHRib2R5PgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMmMxLXQxNSIgaGVhZGVycz0icjFjMS10MTUiPlhNTCBNYXBwaW5nIERhdGEgQ29tcGxldGU8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQxNSByMWMyLXQxNSI+U3BlY2lmaWVzIHRoYXQgdGhlIEphdmEgY2xhc3NlcyBpbiB0aGlzIHBlcnNpc3RlbmNlIHVuaXQgYXJlIGZ1bGx5IHNwZWNpZmllZCBieSB0aGVpciBtZXRhZGF0YS4gQW55IGFubm90YXRpb25zIHdpbGwgYmUgaWdub3JlZC4KLTxwPlRoaXMgZmllbGQgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPiZsdDt4bWwtbWFwcGluZy1tZXRhZGF0YS1jb21wbGV0ZSZndDs8L2NvZGU+IGVsZW1lbnQgaW4gdGhlIDxjb2RlPm9ybS54bWw8L2NvZGU+IGZpbGUuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MTUgcjFjMy10MTUiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyM2MxLXQxNSIgaGVhZGVycz0icjFjMS10MTUiPlNjaGVtYTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDE1IHIxYzItdDE1Ij5UaGUgZGF0YWJhc2Ugc2NoZW1hIHRoYXQgY29udGFpbnMgdGhlIDxzcGFuIGNsYXNzPSJib2xkIj5UYWJsZTwvc3Bhbj4uCi08cD5UaGlzIGZpZWxkIGNvcnJlc3BvbmRzIHRvIHRoZSA8Y29kZT4mbHQ7c2NoZW1hJmd0OzwvY29kZT4gZWxlbWVudCBpbiB0aGUgPGNvZGU+b3JtLnhtbDwvY29kZT4gZmlsZS48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQxNSByMWMzLXQxNSI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI0YzEtdDE1IiBoZWFkZXJzPSJyMWMxLXQxNSI+Q2F0YWxvZzwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDE1IHIxYzItdDE1Ij5UaGUgZGF0YWJhc2UgY2F0YWxvZyB0aGF0IGNvbnRhaW5zIHRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+VGFibGU8L3NwYW4+LgotPHA+VGhpcyBmaWVsZCBjb3JyZXNwb25kcyB0byB0aGUgPGNvZGU+Jmx0O2NhdGFsb2cmZ3Q7PC9jb2RlPiBlbGVtZW50IGluIHRoZSA8Y29kZT5vcm0ueG1sPC9jb2RlPiBmaWxlLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDE1IHIxYzMtdDE1Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjVjMS10MTUiIGhlYWRlcnM9InIxYzEtdDE1Ij5BY2Nlc3MgVHlwZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDE1IHIxYzItdDE1Ij5TcGVjaWZ5IGhvdyB0aGUgZW50aXR5IGl0cyBhY2Nlc3MgaW5zdGFuY2UgdmFyaWFibGVzLgotPHVsPgotPGxpPgotPHA+UHJvcGVydHkgJm5kYXNoOyBQZXJzaXN0ZW50IHN0YXRlIGFjY2Vzc2VkIHRocm91Z2ggdGhlIHByb3BlcnR5IGFjY2Vzc29yIG1ldGhvZHMuIFRoZSBwcm9wZXJ0eSBhY2Nlc3NvciBtZXRob2RzIG11c3QgYmUgPHNwYW4gY2xhc3M9ImJvbGQiPnB1YmxpYzwvc3Bhbj4gb3IgPHNwYW4gY2xhc3M9ImJvbGQiPnByaXZhdGU8L3NwYW4+LjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5GaWVsZCAmbmRhc2g7IEluc3RhbmNlIHZhcmlhYmxlcyBhcmUgYWNjZXNzZWQgZGlyZWN0bHkuIEFsbCBub24tdHJhbnNpZW50IGluc3RhbmNlIHZhcmlhYmxlcyBhcmUgcGVyc2lzdGVudC48L3A+Ci08L2xpPgotPC91bD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDE1IHIxYzMtdDE1Ij5Qcm9wZXJ0eTwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNmMxLXQxNSIgaGVhZGVycz0icjFjMS10MTUiPkNhc2NhZGUgUGVyc2lzdDwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI2YzEtdDE1IHIxYzItdDE1Ij5BZGRzIGNhc2NhZGUtcGVyc2lzdCB0byB0aGUgc2V0IG9mIGNhc2NhZGUgb3B0aW9ucyBpbiBlbnRpdHkgcmVsYXRpb25zaGlwcyBvZiB0aGUgcGVyc2lzdGVuY2UgdW5pdC4KLTxwPlRoaXMgZmllbGQgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPiZsdDtjYXNjYWRlLXBlcnNpc3QmZ3Q7PC9jb2RlPiBlbGVtZW50IGluIHRoZSA8Y29kZT5vcm0ueG1sPC9jb2RlPiBmaWxlLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI2YzEtdDE1IHIxYzMtdDE1Ij48YnIgLz48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0YmxydWxlaW5mb3JtYWwiIC0tPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza19hZGRfcGVyc2lzdGVuY2UuaHRtI0JBQkhJQ0FJIj5BZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBjbGFzczwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxyLnBuZyIgYWx0PSJSZWxhdGVkIHJlZmVyZW5jZSIgdGl0bGU9IlJlbGF0ZWQgcmVmZXJlbmNlIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSNCQUJGQUVCQiI+SlBBIERldGFpbHMgdmlldyAoZm9yIGVudGl0aWVzKTwvYT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gY2xhc3M9InNlY3QyIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMTguaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAxOC5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZiZGJjNDYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAxOC5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw4MSArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo1MSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPnBlcnNpc3RlbmNlLnhtbCBFZGl0b3I8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJwZXJzaXN0ZW5jZS54bWwgRWRpdG9yIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0lBQ0NISUQiIG5hbWU9IkNJQUNDSElEIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5wZXJzaXN0ZW5jZS54bWwgRWRpdG9yPC9oMT4KLTxwPlRoZSBwZXJzaXN0ZW5jZS54bWwgRWRpdG9yIHByb3ZpZGVzIGFuIGludGVyZmFjZSB0aGF0IGVuYWJsZXMgeW91IHRvIHVwZGF0ZSB0aGUgcGVyc2lzdGVuY2UueG1sIGZpbGUuIEZvciBwcm9qZWN0cyB1c2luZyB0aGUgRWNsaXBzZUxpbmsgcGxhdGZvcm0sIHRoZSBwZXJpc2lzdGVuY2UueG1sIEVkaXRvciBjb25zaXN0cyBvZiB0aGUgZm9sbG93aW5nIHBhZ2VzOjwvcD4KLTx1bD4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAxOS5odG0jQ0lBQ0lGR0oiPkdlbmVyYWw8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAyMC5odG0jQ0lBRkZKSUUiPkNvbm5lY3Rpb248L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAyMS5odG0jQ0lBSkFGRUciPkN1c3RvbWl6YXRpb248L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAyMi5odG0jQ0lBQkVEQ0giPkNhY2hpbmc8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAyMy5odG0jQ0lBQkdISEkiPkxvZ2dpbmc8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAyNC5odG0jQ0lBRkpDSEUiPk9wdGlvbnM8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAyNS5odG0jQ0lBQ0NGQ0IiPlNjaGVtYSBHZW5lcmF0aW9uPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZlcmVuY2UwMjYuaHRtI0NJQUhKREZGIj5Qcm9wZXJ0aWVzPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZlcmVuY2UwMjcuaHRtI0NJQUhDSkFIIj5Tb3VyY2U8L2E+PC9wPgotPC9saT4KLTwvdWw+Ci08cD5Gb3IgcHJvamVjdHMgdXNpbmcgdGhlIEdlbmVyaWMgcGxhdGZvcm0sIHRoZSBmb2xsb3dpbmcgc3Vic2V0IG9mIHRoZXNlIHBhZ2VzIGlzIGF2YWlsYWJsZTo8L3A+Ci08dWw+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZlcmVuY2UwMTkuaHRtI0NJQUNJRkdKIj5HZW5lcmFsPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZlcmVuY2UwMjAuaHRtI0NJQUZGSklFIj5Db25uZWN0aW9uPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZlcmVuY2UwMjYuaHRtI0NJQUhKREZGIj5Qcm9wZXJ0aWVzPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZlcmVuY2UwMjcuaHRtI0NJQUhDSkFIIj5Tb3VyY2U8L2E+PC9wPgotPC9saT4KLTwvdWw+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+PC9kaXY+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDE5Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMTkuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2OTY2MGM2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMTkuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsMTE1ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjUxIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+R2VuZXJhbDwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IkdlbmVyYWwiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJDSUFDSUZHSiIgbmFtZT0iQ0lBQ0lGR0oiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MyI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPkdlbmVyYWw8L2gxPgotPHA+VGhlIGZvbGxvd2luZyB0YWJsZSBsaXN0cyBwcm9wZXJ0aWVzIGF2YWlsYWJsZSBpbiB0aGUgR2VuZXJhbCBwYWdlIG9mIHRoZSA8YSBocmVmPSJyZWZlcmVuY2UwMTguaHRtI0NJQUNDSElEIj5wZXJzaXN0ZW5jZS54bWwgRWRpdG9yPC9hPi48L3A+Ci08ZGl2IGNsYXNzPSJ0Ymxmb3JtYWwiPjxhIGlkPSJzdGhyZWYyMTgiIG5hbWU9InN0aHJlZjIxOCI+PC9hPjxhIGlkPSJzdGhyZWYyMTkiIG5hbWU9InN0aHJlZjIxOSI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW50YWJsZSI+UHJvcGVydGllcyBvZiB0aGUgR2VuZXJhbCBQYWdlPC9wPgotPHRhYmxlIGNsYXNzPSJGb3JtYWwiIHRpdGxlPSJQcm9wZXJ0aWVzIG9mIHRoZSBHZW5lcmFsIFBhZ2UiIHN1bW1hcnk9IlRoaXMgdGFibGUgZGVzY3JpYmVzIHRoZSBwcm9wZXJ0aWVzIG9mIHRoZSBwZXJzaXN0ZW5jZS54bWwmcnNxdW87cyBHZW5lcmFsIHBhZ2UuIiBkaXI9Imx0ciIgYm9yZGVyPSIxIiB3aWR0aD0iMTAwJSIgZnJhbWU9ImhzaWRlcyIgcnVsZXM9Imdyb3VwcyIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0aGVhZD4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzEtdDE2Ij5Qcm9wZXJ0eTwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMi10MTYiPkRlc2NyaXB0aW9uPC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMzLXQxNiI+RGVmYXVsdDwvdGg+Ci08L3RyPgotPC90aGVhZD4KLTx0Ym9keT4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjJjMS10MTYiIGhlYWRlcnM9InIxYzEtdDE2Ij4KLTxwPk5hbWU8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQxNiByMWMyLXQxNiI+Ci08cD5FbnRlciB0aGUgbmFtZSBvZiB0aGUgcGVyc2lzdGVuY2UgdW5pdC48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQxNiByMWMzLXQxNiI+Ci08cD5UaGUgcHJvamVjdCBuYW1lLjwvcD4KLTwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyM2MxLXQxNiIgaGVhZGVycz0icjFjMS10MTYiPgotPHA+UGVyc2lzdGVuY2UgUHJvdmlkZXI8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQxNiByMWMyLXQxNiI+Ci08cD5FbnRlciB0aGUgbmFtZSBvZiB0aGUgcGVyc2lzdGVuY2UgcHJvdmlkZXIuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MTYgcjFjMy10MTYiPgotPHA+RGV0ZXJtaW5lZCBieSB0aGUgc2VydmVyLjwvcD4KLTwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNGMxLXQxNiIgaGVhZGVycz0icjFjMS10MTYiPgotPHA+RGVzY3JpcHRpb248L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQxNiByMWMyLXQxNiI+Ci08cD5FbnRlciBhIGRlc2NyaXB0aW9uIGZvciB0aGlzIHBlcnNpc3RlbmNlIHVuaXQuIFRoaXMgaXMgYW4gb3B0aW9uYWwgcHJvcGVydHkuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MTYgcjFjMy10MTYiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNWMxLXQxNiIgaGVhZGVycz0icjFjMS10MTYiPgotPHA+TWFuYWdlZCBDbGFzc2VzPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MTYgcjFjMi10MTYiPgotPHA+QWRkIG9yIHJlbW92ZSB0aGUgY2xhc3NlcyBtYW5hZ2VkIHRocm91Z2ggdGhlIHBlcnNpc3RlbmNlIHVuaXQuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MTYgcjFjMy10MTYiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNmMxLXQxNiIgaGVhZGVycz0icjFjMS10MTYiPgotPHA+RXhjbHVkZSBVbmxpc3RlZCBDbGFzc2VzPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10MTYgcjFjMi10MTYiPgotPHA+U2VsZWN0IHRvIGluY2x1ZGUgYWxsIGFubm90YXRlZCBlbnRpdHkgY2xhc3NlcyBpbiB0aGUgcm9vdCBvZiB0aGUgcGVyc2lzdGVuY2UgdW5pdC48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQxNiByMWMzLXQxNiI+Ci08cD5GYWxzZTwvcD4KLTwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyN2MxLXQxNiIgaGVhZGVycz0icjFjMS10MTYiPgotPHA+WE1MIE1hcHBpbmcgRmlsZXM8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyN2MxLXQxNiByMWMyLXQxNiI+Ci08cD5BZGQgb3IgcmVtb3ZlIHRoZSBvYmplY3QvcmVsYXRpb25hbCBtYXBwaW5nIFhNTCBmaWxlcyB0aGF0IGRlZmluZSB0aGUgY2xhc3NlcyB0byBiZSBtYW5hZ2VkIGJ5IHRoZSBwZXJzaXN0ZW5jZSB1bml0LjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI3YzEtdDE2IHIxYzMtdDE2Ij4KLTxwPk1ldGEtSU5GXG9ybS54bWw8L3A+Ci08L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJ0Ymxmb3JtYWwiIC0tPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDMiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAyMC5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDIwLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjcyYjQ3My4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDIwLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDE2MyArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo1MSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPkNvbm5lY3Rpb248L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJDb25uZWN0aW9uIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0lBRkZKSUUiIG5hbWU9IkNJQUZGSklFIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDMiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5Db25uZWN0aW9uPC9oMT4KLTxwPlRoZSBmb2xsb3dpbmcgdGFibGUgbGlzdHMgdGhlIHByb3BlcnRpZXMgYXZhaWxhYmxlIGluIHRoZSBDb25uZWN0aW9uIHBhZ2Ugb2YgdGhlIDxhIGhyZWY9InJlZmVyZW5jZTAxOC5odG0jQ0lBQ0NISUQiPnBlcnNpc3RlbmNlLnhtbCBFZGl0b3I8L2E+LjwvcD4KLTxkaXYgY2xhc3M9InRibGZvcm1hbCI+PGEgaWQ9InN0aHJlZjIyMCIgbmFtZT0ic3RocmVmMjIwIj48L2E+PGEgaWQ9InN0aHJlZjIyMSIgbmFtZT0ic3RocmVmMjIxIj48L2E+Ci08cCBjbGFzcz0idGl0bGVpbnRhYmxlIj5Qcm9wZXJ0aWVzIG9mIHRoZSBDb25uZWN0aW9uIFBhZ2U8L3A+Ci08dGFibGUgY2xhc3M9IkZvcm1hbCIgdGl0bGU9IlByb3BlcnRpZXMgb2YgdGhlIENvbm5lY3Rpb24gUGFnZSIgc3VtbWFyeT0iVGhpcyB0YWJsZSBsaXN0cyB0aGUgcHJvcGVydGllcyBmb3IgdGhlIHBlcnNpc3RlbmNlLnhtbCBlZGl0b3ImcnNxdW87cyBjb25uZWN0aW9uIHBhZ2UuIiBkaXI9Imx0ciIgYm9yZGVyPSIxIiB3aWR0aD0iMTAwJSIgZnJhbWU9ImhzaWRlcyIgcnVsZXM9Imdyb3VwcyIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0aGVhZD4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzEtdDE3Ij5Qcm9wZXJ0eTwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMi10MTciPkRlc2NyaXB0aW9uPC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMzLXQxNyI+RGVmYXVsdDwvdGg+Ci08L3RyPgotPC90aGVhZD4KLTx0Ym9keT4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjJjMS10MTciIGhlYWRlcnM9InIxYzEtdDE3Ij4KLTxwPlRyYW5zYWN0aW9uIFR5cGU8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQxNyByMWMyLXQxNyI+Ci08cD5TcGVjaWZ5IGlmIHRoZSBjb25uZWN0aW9uIGZvciB0aGlzIHBlcnNpc3RlbmNlIHVuaXQgdXNlcyBvbmUgb2YgdGhlIGZvbGxvd2luZyB0cmFuc2FjdGlvbiB0eXBlczo8L3A+Ci08dWw+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+RGVmYXVsdDwvc3Bhbj4gLS0gU2VsZWN0IHRvIHVzZSB0aGUgY29udGFpbmVyIHVzZWQgYnkgdGhlIGNvbnRhaW5lci48L3A+Ci08L2xpPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPkpUQTwvc3Bhbj4gKEphdmEgVHJhbnNhY3Rpb24gQVBJKSAtLSBUcmFuc2FjdGlvbnMgb2YgdGhlIEphdmEgRUUgc2VydmVyLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+UmVzb3VyY2UgTG9jYWw8L3NwYW4+IC0tIE5hdGl2ZSBhY3Rpb25zIG9mIGEgSkRCQyBkcml2ZXIgdGhhdCBhcmUgcmVmZXJlbmNlZCBieSBhIHBlcnNpc3RlbmNlIHVuaXQuPC9wPgotPC9saT4KLTwvdWw+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQxNyByMWMzLXQxNyI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDE3IiBoZWFkZXJzPSJyMWMxLXQxNyI+Ci08cD5CYXRjaCBXcml0aW5nPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MTcgcjFjMi10MTciPgotPHA+U3BlY2lmeSB0aGUgdXNlIG9mIGJhdGNoIHdyaXRpbmcgdG8gb3B0aW1pemUgdHJhbnNhY3Rpb25zIHdpdGggbXVsdGlwbGUgd3JpdGUgb3BlcmF0aW9ucy48L3A+Ci08cD5TZXQgdGhlIHZhbHVlIG9mIHRoaXMgcHJvcGVydHkgaW50byB0aGUgc2Vzc2lvbiBhdCBkZXBsb3ltZW50IHRpbWUuPC9wPgotPHA+Tm90ZTogVGhpcyBwcm9wZXJ0eSBhcHBsaWVzIHdoZW4gdXNlZCBib3RoIGluIGEgSmF2YSBTRSBhbmQgSmF2YSBFRSBlbnZpcm9ubWVudC48L3A+Ci08cD5UaGUgZm9sbG93aW5nIGFyZSB0aGUgdmFsaWQgdmFsdWVzIGZvciBvcmFjbGUudG9wbGluay5jb25maWcuQmF0Y2hXcml0aW5nOjwvcD4KLTx1bD4KLTxsaT4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5KREJDPC9zcGFuPiZuZGFzaDtVc2UgSkRCQyBiYXRjaCB3cml0aW5nLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+QnVmZmVyZWQ8L3NwYW4+Jm5kYXNoO0RvIG5vdCB1c2UgZWl0aGVyIEpEQkMgYmF0Y2ggd3JpdGluZyBub3IgbmF0aXZlIHBsYXRmb3JtIGJhdGNoIHdyaXRpbmcuPC9wPgotPC9saT4KLTxsaT4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5PcmFjbGVKREJDPC9zcGFuPiZuZGFzaDtVc2UgYm90aCBKREJDIGJhdGNoIHdyaXRpbmcgYW5kIE9yYWNsZSBuYXRpdmUgcGxhdGZvcm0gYmF0Y2ggd3JpdGluZy48L3A+Ci08L2xpPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPk5vbmU8L3NwYW4+Jm5kYXNoO0RvIG5vdCB1c2UgYmF0Y2ggd3JpdGluZyAodHVybiBpdCBvZmYpLjwvcD4KLTwvbGk+Ci08L3VsPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MTcgcjFjMy10MTciPgotPHA+Tm9uZTwvcD4KLTwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNGMxLXQxNyIgaGVhZGVycz0icjFjMS10MTciPgotPHA+SlRBIERhdGEgU291cmNlIE5hbWU8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQxNyByMWMyLXQxNyI+Ci08cD5JZiB5b3Ugc2VsZWN0ZWQgPHNwYW4gY2xhc3M9ImJvbGQiPkpUQTwvc3Bhbj4gYXMgdGhlIHRyYW5zYWN0aW9uIHR5cGUsIHRoZW4gZW50ZXIgdGhlIG5hbWUgb2YgdGhlIGRlZmF1bHQgSlRBIGRhdGEgc291cmNlIGZvciB0aGUgcGVyc2lzdGVuY2UgdW5pdC48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQxNyByMWMzLXQxNyI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI1YzEtdDE3IiBoZWFkZXJzPSJyMWMxLXQxNyI+Ci08cD5Ob24tSlRBIERhdGEgU291cmNlIE5hbWU8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQxNyByMWMyLXQxNyI+Ci08cD5JZiB5b3Ugc2VsZWN0ZWQgPHNwYW4gY2xhc3M9ImJvbGQiPlJlc291cmNlIExvY2FsPC9zcGFuPiBhcyB0aGUgdHJhbnNhY3Rpb24gdHlwZSwgdGhlbiBlbnRlciB0aGUgbmFtZSBvZiB0aGUgbm9uLUpUQSBkYXRhIHNvdXJjZS48L3A+Ci08cD5UaGlzIHByb3BlcnR5IGlzIG5vdCBhdmFpbGFibGUgZm9yIHByb2plY3RzIHVzaW5nIHRoZSBHZW5lcmljIHBsYXRmb3JtLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDE3IHIxYzMtdDE3Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjZjMS10MTciIGhlYWRlcnM9InIxYzEtdDE3Ij4KLTxwPiZuYnNwOyZuYnNwO0JpbmQgUGFyYW1ldGVyczwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI2YzEtdDE3IHIxYzItdDE3Ij4KLTxwPkNvbnRyb2wgd2hldGhlciBvciBub3QgdGhlIHF1ZXJ5IHVzZXMgcGFyYW1ldGVyIGJpbmRpbmcuPC9wPgotPHA+Tm90ZTogVGhpcyBwcm9wZXJ0eSBhcHBsaWVzIHdoZW4gdXNlZCBpbiBhIEphdmEgU0UgZW52aXJvbm1lbnQuPC9wPgotPHA+VGhpcyBwcm9wZXJ0eSBpcyBub3QgYXZhaWxhYmxlIGZvciBwcm9qZWN0cyB1c2luZyB0aGUgR2VuZXJpYyBwbGF0Zm9ybS48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQxNyByMWMzLXQxNyI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI3YzEtdDE3IiBoZWFkZXJzPSJyMWMxLXQxNyI+Ci08cD5FY2xpcHNlTGluayBDb25uZWN0aW9uIFBvb2w8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyN2MxLXQxNyByMWMyLXQxNyI+Ci08cD5EZWZpbmUgdGhlIGNvbm5lY3Rpb24gcG9vbCBkcml2ZXIsIFVSTCwgdXNlciBuYW1lIGFuZCBwYXNzd29yZC48L3A+Ci08cD5UaGVzZSBwcm9wZXJ0aWVzIGFyZSBub3RlIGF2YWlsYWJsZSBmb3IgcHJvamVjdHMgdXNpbmcgdGhlIEdlbmVyaWMgcGxhdGZvcm0uPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjdjMS10MTcgcjFjMy10MTciPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyOGMxLXQxNyIgaGVhZGVycz0icjFjMS10MTciPgotPHA+Jm5ic3A7Jm5ic3A7UmVhZCBDb25uZWN0aW9uPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjhjMS10MTcgcjFjMi10MTciPgotPHA+VGhlIG1heGltdW0gYW5kIG1pbmltdW0gbnVtYmVyIG9mIGNvbm5lY3Rpb25zIGFsbG93ZWQgaW4gdGhlIEpEQkMgcmVhZCBjb25uZWN0aW9uIHBvb2wuPC9wPgotPHA+Tm90ZTogVGhlc2UgcHJvcGVydGllcyBhcHBseSB3aGVuIHVzZWQgaW4gYSBKYXZhIFNFIGVudmlyb25tZW50LjwvcD4KLTxwPlRoZXNlIHByb3BlcnRpZXMgYXJlIG5vdCBhdmFpbGFibGUgZm9yIHByb2plY3RzIHVzaW5nIHRoZSBHZW5lcmljIHBsYXRmb3JtPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjhjMS10MTcgcjFjMy10MTciPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyOWMxLXQxNyIgaGVhZGVycz0icjFjMS10MTciPgotPHA+Jm5ic3A7Jm5ic3A7V3JpdGUgQ29ubmVjdGlvbjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI5YzEtdDE3IHIxYzItdDE3Ij4KLTxwPlRoZSBtYXhpbXVtIGFuZCBtaW5pbXVtIG51bWJlciBvZiBjb25uZWN0aW9ucyBhbGxvd2VkIGluIHRoZSBKREJDIHdyaXRlIGNvbm5lY3Rpb24gcG9vbC48L3A+Ci08cD5Ob3RlOiBUaGVzZSBwcm9wZXJ0aWVzIGFwcGx5IHdoZW4gdXNlZCBpbiBhIEphdmEgU0UgZW52aXJvbm1lbnQuPC9wPgotPHA+VGhlc2UgcHJvcGVydGllcyBhcmUgbm90IGF2YWlsYWJsZSBmb3IgcHJvamVjdHMgdXNpbmcgdGhlIEdlbmVyaWMgcGxhdGZvcm08L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyOWMxLXQxNyByMWMzLXQxNyI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0idGJsZm9ybWFsIiAtLT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMjEuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAyMS5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDM5NWIxNWEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAyMS5odG0KKysrIC9kZXYvbnVsbApAQCAtMSwxNTMgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTEgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5DdXN0b21pemF0aW9uPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iQ3VzdG9taXphdGlvbiIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNJQUpBRkVHIiBuYW1lPSJDSUFKQUZFRyI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QzIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+Q3VzdG9taXphdGlvbjwvaDE+Ci08cD5UaGUgZm9sbG93aW5nIHRhYmxlIGxpc3RzIHRoZSBwcm9wZXJ0aWVzIGF2YWlsYWJsZSBpbiB0aGUgQ3VzdG9taXphdGlvbiBwYWdlIG9mIHRoZSA8YSBocmVmPSJyZWZlcmVuY2UwMTguaHRtI0NJQUNDSElEIj5wZXJzaXN0ZW5jZS54bWwgRWRpdG9yPC9hPi48L3A+Ci08ZGl2IGNsYXNzPSJ0Ymxmb3JtYWwiPjxhIGlkPSJzdGhyZWYyMjIiIG5hbWU9InN0aHJlZjIyMiI+PC9hPjxhIGlkPSJzdGhyZWYyMjMiIG5hbWU9InN0aHJlZjIyMyI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW50YWJsZSI+UHJvcGVydGllcyBvZiB0aGUgQ3VzdG9taXphdGlvbiBQYWdlPC9wPgotPHRhYmxlIGNsYXNzPSJGb3JtYWwiIHRpdGxlPSJQcm9wZXJ0aWVzIG9mIHRoZSBDdXN0b21pemF0aW9uIFBhZ2UiIHN1bW1hcnk9IlRoaXMgdGFibGUgbGlzdHMgdGhlIHByb3BlcnRpZXMgb2YgdGhlIHBlcnNpc3RlbmNlLnhtbCBFZGl0b3ImcnNxdW87cyBDdXN0b21pemF0aW9uIHBhZ2UuIiBkaXI9Imx0ciIgYm9yZGVyPSIxIiB3aWR0aD0iMTAwJSIgZnJhbWU9ImhzaWRlcyIgcnVsZXM9Imdyb3VwcyIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0aGVhZD4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzEtdDE4Ij5Qcm9wZXJ0eTwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMi10MTgiPkRlc2NyaXB0aW9uPC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMzLXQxOCI+RGVmYXVsdDwvdGg+Ci08L3RyPgotPC90aGVhZD4KLTx0Ym9keT4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjJjMS10MTgiIGhlYWRlcnM9InIxYzEtdDE4Ij4KLTxwPldlYXZpbmc8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQxOCByMWMyLXQxOCI+Ci08cD5TcGVjaWZpZXMgaWYgd2VhdmluZyBvZiB0aGUgZW50aXR5IGNsYXNzZXMgaXMgcGVyZm9ybWVkLiBUaGUgRWNsaXBzZUxpbmsgSlBBIHBlcnNpc3RlbmNlIHByb3ZpZGVyIHVzZXMgd2VhdmluZyB0byBlbmhhbmNlIEpQQSBlbnRpdGllcyBmb3Igc3VjaCBwcm9wZXJ0aWVzIGFzIGxhenkgbG9hZGluZywgY2hhbmdlIHRyYWNraW5nLCBmZXRjaCBncm91cHMsIGFuZCBpbnRlcm5hbCBvcHRpbWl6YXRpb25zLiBTZWxlY3QgZnJvbSB0aGUgZm9sbG93aW5nIG9wdGlvbnM6PC9wPgotPHVsPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPk5vIFdlYXZpbmc8L3NwYW4+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5XZWF2ZSBEeW5hbWljYWxseTwvc3Bhbj48L3A+Ci08L2xpPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPldlYXZlIFN0YXRpY2FsbHk8L3NwYW4+IC0tIFVzZSB0aGlzIG9wdGlvbiBpZiB5b3UgcGxhbiB0byBleGVjdXRlIHlvdXIgYXBwbGljYXRpb24gb3V0c2lkZSBvZiBhIEphdmEgRUUgNSBjb250YWluZXIgaW4gYW4gZW52aXJvbm1lbnQgdGhhdCBkb2VzIG5vdCBwZXJtaXQgdGhlIHVzZSBvZiA8Y29kZT4tamF2YWFnZW50OmVjbGlwc2VsaW5rLmphcjwvY29kZT4gb24gdGhlIEpWTSBjb21tYW5kIGxpbmUuIFRoaXMgYXNzdW1lcyB0aGF0IGNsYXNzZXMgaGF2ZSBhbHJlYWR5IGJlZW4gc3RhdGljYWxseSB3b3Zlbi4gUnVuIHRoZSBzdGF0aWMgd2VhdmVyIG9uIHRoZSBjbGFzc2VzIGJlZm9yZSBkZXBsb3lpbmcgdGhlbS48L3A+Ci08L2xpPgotPC91bD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDE4IHIxYzMtdDE4Ij4KLTxwPldlYXZlIER5bmFtaWNhbGx5PC9wPgotPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDE4IiBoZWFkZXJzPSJyMWMxLXQxOCI+Ci08cD4mbmJzcDsmbmJzcDtXZWF2aW5nIExhenk8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQxOCByMWMyLXQxOCI+Ci08cD5TZWxlY3QgdGhpcyBvcHRvaW4gdG8gZW5hYmxlIGxhenkgd2VhdmluZy48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQxOCByMWMzLXQxOCI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI0YzEtdDE4IiBoZWFkZXJzPSJyMWMxLXQxOCI+Ci08cD4mbmJzcDsmbmJzcDtXZWF2aW5nIEZldGNoIEdyb3VwczwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDE4IHIxYzItdDE4Ij4KLTxwPlNlbGVjdCB0aGlzIG9wdGlvbiB0byBlbmFibGUgZmV0Y2ggZ3JvdXBzIHRocm91Z2ggd2VhdmluZy4gU2V0IHRoaXMgb3B0aW9uIHRvIGZhbHNlIGlmOjwvcD4KLTx1bD4KLTxsaT4KLTxwPlRoZXJlIGlzIG5vIHdlYXZpbmcuPC9wPgotPC9saT4KLTxsaT4KLTxwPkNsYXNzZXMgc2hvdWxkIG5vdCBiZSBjaGFuZ2VkIGR1cmluZyB3ZWF2aW5nIChmb3IgZXhhbXBsZSwgd2hlbiBkZWJ1Z2dpbmcpLjwvcD4KLTwvbGk+Ci08L3VsPgotPHA+U2V0IHRoaXMgcHJvcGVydHkgdG8gZmFsc2UgZm9yIHBsYXRmb3JtcyB3aGVyZSBpdCBpcyBub3Qgc3VwcG9ydGVkLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDE4IHIxYzMtdDE4Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjVjMS10MTgiIGhlYWRlcnM9InIxYzEtdDE4Ij4KLTxwPiZuYnNwOyZuYnNwO1dlYXZpbmcgQ2hhbmdlIFRyYWNraW5nPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MTggcjFjMi10MTgiPgotPHA+U2VsZWN0IHRoaXMgb3B0aW9uIHRvIHVzZSB3ZWF2aW5nIHRvIGRldGVjdCB3aGljaCBmaWVsZHMgb3IgcHJvcGVydGllcyBvZiB0aGUgb2JqZWN0IGNoYW5nZS48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQxOCByMWMzLXQxOCI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI2YzEtdDE4IiBoZWFkZXJzPSJyMWMxLXQxOCI+Ci08cD4mbmJzcDsmbmJzcDtUaHJvdyBFeGNlcHRpb25zPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10MTggcjFjMi10MTgiPgotPHA+U2VsZWN0IHRoaXMgb3B0aW9uIHRvIHNldCBFY2xpcHNlTGluayB0byB0aHJvdyBhbiBleGNlcHRpb24gb3IgbG9nIGEgd2FybmluZyB3aGVuIGl0IGVuY291bnRlcnMgYSBwcm9ibGVtIHdpdGggYW55IG9mIHRoZSBmaWxlcyBsaXN0ZWQgaW4gYSA8c3BhbiBjbGFzcz0iYm9sZCI+cGVyc2lzdGVuY2UueG1sPC9zcGFuPiBmaWxlIDxjb2RlPiZsdDttYXBwaW5nLWZpbGUmZ3Q7PC9jb2RlPiBlbGVtZW50LjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI2YzEtdDE4IHIxYzMtdDE4Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjdjMS10MTgiIGhlYWRlcnM9InIxYzEtdDE4Ij4KLTxwPlNlc3Npb24gQ3VzdG9taXplcjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI3YzEtdDE4IHIxYzItdDE4Ij4KLTxwPlNlbGVjdCBhIHNlc3Npb24gY3VzdG9taXplciBjbGFzczogYSBKYXZhIGNsYXNzIHRoYXQgaW1wbGVtZW50cyB0aGUgPGNvZGU+ZWNsaXBzZWxpbmsudG9vbHMuc2Vzc2lvbmNvbmZpZ3VyYXRpb24uU2Vzc2lvbkN1c3RvbWl6ZXI8L2NvZGU+IGludGVyZmFjZSBhbmQgcHJvdmlkZXMgYSBkZWZhdWx0ICh6ZXJvLWFyZ3VtZW50KSBjb25zdHJ1Y3Rvci4gVXNlIHRoaXMgY2xhc3MnIDxjb2RlPmN1c3RvbWl6ZTwvY29kZT4gbWV0aG9kLCB3aGljaCB0YWtlcyBhbiA8Y29kZT5lY2xpcHNlbGluay5zZXNzaW9ucy5TZXNzaW9uPC9jb2RlPiwgdG8gcHJvZ3JhbW1hdGljYWxseSBhY2Nlc3MgYWR2YW5jZWQgRWNsaXBzZUxpbmsgc2Vzc2lvbiBBUEkuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjdjMS10MTggcjFjMy10MTgiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyOGMxLXQxOCIgaGVhZGVycz0icjFjMS10MTgiPgotPHA+RGVzY3JpcHRvciBDdXN0b21pemVyPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjhjMS10MTggcjFjMi10MTgiPgotPHA+U2VsZWN0IGFuIEVjbGlwc2VMaW5rIGRlc2NyaXB0b3IgY3VzdG9taXplciBjbGFzcyZuZGFzaDthIEphdmEgY2xhc3MgdGhhdCBpbXBsZW1lbnRzIHRoZSA8Y29kZT5lY2xpcHNlbGluay50b29scy5zZXNzaW9uY29uZmlndXJhdGlvbi5EZXNjcmlwdG9yQ3VzdG9taXplcjwvY29kZT4gaW50ZXJmYWNlIGFuZCBwcm92aWRlcyBhIGRlZmF1bHQgKHplcm8tYXJndW1lbnQpIGNvbnN0cnVjdG9yLiBVc2UgdGhpcyBjbGFzcydzIDxjb2RlPmN1c3RvbWl6ZTwvY29kZT4gbWV0aG9kLCB3aGljaCB0YWtlcyBhbiA8Y29kZT5lY2xpcHNlbGluay5kZXNjcmlwdG9ycy5DbGFzc0Rlc2NyaXB0b3I8L2NvZGU+LCB0byBwcm9ncmFtbWF0aWNhbGx5IGFjY2VzcyBhZHZhbmNlZCBFY2xpcHNlTGluayBkZXNjcmlwdG9yIGFuZCBtYXBwaW5nIEFQSSBmb3IgdGhlIGRlc2NyaXB0b3IgYXNzb2NpYXRlZCB3aXRoIHRoZSBKUEEgZW50aXR5IG5hbWVkIDxjb2RlPiZsdDtFTlRJVFkmZ3Q7PC9jb2RlPi48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyOGMxLXQxOCByMWMzLXQxOCI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0idGJsZm9ybWFsIiAtLT4KLTxwPlRoZSBmb2xsb3dpbmcgdGFibGUgbGlzdHMgdGhlIHByb3BlcnRpZXMgb2YgdGhlIDxhIGhyZWY9InJlZmVyZW5jZTAxOC5odG0jQ0lBQ0NISUQiPnBlcnNpc3RlbmNlLnhtbCBFZGl0b3I8L2E+LjwvcD4KLTxkaXYgYWxpZ249ImNlbnRlciI+Ci08ZGl2IGNsYXNzPSJpbmZ0Ymxub3RlIj48YnIgLz4KLTx0YWJsZSBjbGFzcz0iTm90ZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRib2R5PgotPHRyPgotPHRkIGFsaWduPSJsZWZ0Ij4KLTxwIGNsYXNzPSJub3RlcDEiPk5vdGU6PC9wPgotVGhpcyBwYWdlIGlzIG5vdCBhdmFpbGFibGUgZm9yIHByb2plY3RzIHVzaW5nIHRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+R2VuZXJpYzwvc3Bhbj4gcGxhdGZvcm0uPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJsbm90ZSIgLS0+PC9kaXY+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMjIuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAyMi5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDM5MWQ5MTMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAyMi5odG0KKysrIC9kZXYvbnVsbApAQCAtMSwxNTcgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTEgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5DYWNoaW5nPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iQ2FjaGluZyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNJQUJFRENIIiBuYW1lPSJDSUFCRURDSCI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QzIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+Q2FjaGluZzwvaDE+Ci08cD5UaGlzIHRhYmxlIGxpc3RzIHRoZSBwcm9wZXJ0aWVzIG9mIHRoZSBDYWNoaW5nIHBhZ2Ugb2YgdGhlIDxhIGhyZWY9InJlZmVyZW5jZTAxOC5odG0jQ0lBQ0NISUQiPnBlcnNpc3RlbmNlLnhtbCBFZGl0b3I8L2E+LjwvcD4KLTxkaXYgY2xhc3M9InRibGZvcm1hbCI+PGEgaWQ9InN0aHJlZjIyNCIgbmFtZT0ic3RocmVmMjI0Ij48L2E+PGEgaWQ9InN0aHJlZjIyNSIgbmFtZT0ic3RocmVmMjI1Ij48L2E+Ci08cCBjbGFzcz0idGl0bGVpbnRhYmxlIj5Qcm9wZXJ0aWVzIG9mIHRoZSBDYWNoaW5nIFBhZ2U8L3A+Ci08dGFibGUgY2xhc3M9IkZvcm1hbCIgdGl0bGU9IlByb3BlcnRpZXMgb2YgdGhlIENhY2hpbmcgUGFnZSIgc3VtbWFyeT0iVGhpcyB0YWJsZSBsaXN0cyB0aGUgcHJvcGVydGllcyBvZiB0aGUgcGVyc2lzdGVuY2UueG1sJnJzcXVvO3MgQ2FjaGluZyBwYWdlLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJoc2lkZXMiIHJ1bGVzPSJncm91cHMiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQyMCI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDIwIj5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10MjAiPkRlZmF1bHQ8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDIwIiBoZWFkZXJzPSJyMWMxLXQyMCI+Ci08cD5EZWZhdWx0IENhY2hlIFR5cGU8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQyMCByMWMyLXQyMCI+Ci08cD5TZWxlY3Qgb25lIG9mIHRoZSBmb2xsb3dpbmcgYXMgdGhlIERlZmF1bHQgQ2FjaGUgVHlwZTo8L3A+Ci08dWw+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+U29mdCB3aXRoIFdlYWsgU3ViY2FjaGU8L3NwYW4+Jm5kYXNoO1RoaXMgb3B0aW9uIGlzIHNpbWlsYXIgdG8gPHNwYW4gY2xhc3M9ImJvbGQiPldlYWsgd2l0aCBIYXJkIFN1YmNhY2hlPC9zcGFuPiBleGNlcHQgdGhhdCBpdCBtYWludGFpbnMgYSBtb3N0IGZyZXF1ZW50bHkgdXNlZCBzdWJjYWNoZSB0aGF0IHVzZXMgc29mdCByZWZlcmVuY2VzLiBUaGUgc2l6ZSBvZiB0aGUgc3ViY2FjaGUgaXMgcHJvcG9ydGlvbmFsIHRvIHRoZSBzaXplIG9mIHRoZSBpZGVudGl0eSBtYXAuIFRoZSBzdWJjYWNoZSB1c2VzIHNvZnQgcmVmZXJlbmNlcyB0byBlbnN1cmUgdGhhdCB0aGVzZSBvYmplY3RzIGFyZSBnYXJiYWdlLWNvbGxlY3RlZCBvbmx5IGlmIHRoZSBzeXN0ZW0gaXMgbG93IG9uIG1lbW9yeS48L3A+Ci08cD5Vc2UgdGhpcyBpZGVudGl0eSBtYXAgaW4gbW9zdCBjaXJjdW1zdGFuY2VzIGFzIGEgbWVhbnMgdG8gY29udHJvbCBtZW1vcnkgdXNlZCBieSB0aGUgY2FjaGUuPC9wPgotPC9saT4KLTxsaT4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5XZWVrIHdpdGggSGFyZCBTdWJjYWNoZTwvc3Bhbj4mbmRhc2g7VGhpcyBvcHRpb24gaXMgc2ltaWxhciB0byA8c3BhbiBjbGFzcz0iYm9sZCI+U29mdCB3aXRoIFdlYWs8L3NwYW4+IHN1YmNhY2hlIGV4Y2VwdCB0aGF0IGl0IG1haW50YWlucyBhIG1vc3QgZnJlcXVlbnRseSB1c2VkIHN1YmNhY2hlIHRoYXQgdXNlcyBoYXJkIHJlZmVyZW5jZXMuIFVzZSB0aGlzIGlkZW50aXR5IG1hcCBpZiBzb2Z0IHJlZmVyZW5jZXMgYXJlIG5vdCBzdWl0YWJsZSBmb3IgeW91ciBwbGF0Zm9ybS48L3A+Ci08L2xpPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPldlYWs8L3NwYW4+Jm5kYXNoO1RoaXMgb3B0aW9uIGlzIHNpbWlsYXIgdG8gPHNwYW4gY2xhc3M9ImJvbGQiPkZ1bGw8L3NwYW4+LCBleGNlcHQgdGhhdCBvYmplY3RzIGFyZSByZWZlcmVuY2VkIHVzaW5nIHdlYWsgcmVmZXJlbmNlcy4gVGhpcyBvcHRpb24gdXNlcyBsZXNzIG1lbW9yeSB0aGFuIDxzcGFuIGNsYXNzPSJib2xkIj5GdWxsPC9zcGFuPiwgYWxsb3dzIGNvbXBsZXRlIGdhcmJhZ2UgY29sbGVjdGlvbiBhbmQgcHJvdmlkZXMgZnVsbCBjYWNoaW5nIGFuZCBndWFyYW50ZWVkIGlkZW50aXR5LjwvcD4KLTxwPlVzZSB0aGlzIGlkZW50aXR5IG1hcCBmb3IgdHJhbnNhY3Rpb25zIHRoYXQsIG9uY2Ugc3RhcnRlZCwgc3RheSBvbiB0aGUgc2VydmVyIHNpZGUuPC9wPgotPC9saT4KLTxsaT4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5Tb2Z0PC9zcGFuPiZuZGFzaDtUaGlzIG9wdGlvbiBpcyBzaW1pbGFyIHRvIDxzcGFuIGNsYXNzPSJib2xkIj5XZWFrPC9zcGFuPiBleGNlcHQgdGhhdCB0aGUgbWFwIGhvbGRzIHRoZSBvYmplY3RzIHVzaW5nIHNvZnQgcmVmZXJlbmNlcy4gVGhpcyBpZGVudGl0eSBtYXAgZW5hYmxlcyBmdWxsIGdhcmJhZ2UgY29sbGVjdGlvbiB3aGVuIG1lbW9yeSBpcyBsb3cuIEl0IHByb3ZpZGVzIGZ1bGwgY2FjaGluZyBhbmQgZ3VhcmFudGVlZCBpZGVudGl0eS48L3A+Ci08L2xpPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPkZ1bGw8L3NwYW4+Jm5kYXNoO1RoaXMgb3B0aW9uIHByb3ZpZGVzIGZ1bGwgY2FjaGluZyBhbmQgZ3VhcmFudGVlZCBpZGVudGl0eTogYWxsIG9iamVjdHMgYXJlIGNhY2hlZCBhbmQgbm90IHJlbW92ZWQuPC9wPgotPHA+Tm90ZTogVGhpcyBwcm9jZXNzIG1heSBiZSBtZW1vcnktaW50ZW5zaXZlIHdoZW4gbWFueSBvYmplY3RzIGFyZSByZWFkLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+Tm9uZTwvc3Bhbj4mbmRhc2g7VGhpcyBvcHRpb24gZG9lcyBub3QgcHJlc2VydmUgb2JqZWN0IGlkZW50aXR5IGFuZCBkb2VzIG5vdCBjYWNoZSBvYmplY3RzLlRoaXMgb3B0aW9uIGlzIG5vdCByZWNvbW1lbmRlZC48L3A+Ci08L2xpPgotPC91bD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDIwIHIxYzMtdDIwIj4KLTxwPldlYWsgd2l0aCBoYXJkIHN1YmNhY2hlPC9wPgotPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDIwIiBoZWFkZXJzPSJyMWMxLXQyMCI+Ci08cD5EZWZhdWx0IENhY2hlIFNpemU8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQyMCByMWMyLXQyMCI+Ci08cD5TZXQgdGhlIHNpemUgb2YgdGhlIGNhY2hlLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDIwIHIxYzMtdDIwIj4KLTxwPjEwMDA8L3A+Ci08L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjRjMS10MjAiIGhlYWRlcnM9InIxYzEtdDIwIj4KLTxwPkRlZmF1bHQgU2hhcmVkIENhY2hlPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MjAgcjFjMi10MjAiPgotPHA+U3BlY2ZpZXMgaWYgY2FjaGVkIGluc3RhbmNlcyBzaG91bGQgYmUgaW4gdGhlIHNoYXJlZCBjYWNoZSBvciBpbiBhIGNsaWVudCBpc29sYXRlZCBjYWNoZS48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQyMCByMWMzLXQyMCI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI1YzEtdDIwIiBoZWFkZXJzPSJyMWMxLXQyMCI+Ci08cD5FbnRpdHkgQ2FjaGluZzwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDIwIHIxYzItdDIwIj4KLTxwPlNwZWNpZnkgdGhlIGVudGl0eS48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQyMCByMWMzLXQyMCI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI2YzEtdDIwIiBoZWFkZXJzPSJyMWMxLXQyMCI+Ci08cD4mbmJzcDsmbmJzcDtDYWNoZSBUeXBlPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10MjAgcjFjMi10MjAiPgotPHA+U2VsZWN0IGEgY2FjaGUgdHlwZS4gU2VlIDxzcGFuIGNsYXNzPSJpdGFsaWMiPkRlZmF1bHQgQ2FjaGU8L3NwYW4+PC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10MjAgcjFjMy10MjAiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyN2MxLXQyMCIgaGVhZGVycz0icjFjMS10MjAiPgotPHA+Jm5ic3A7Jm5ic3A7Q2FjaGUgU2l6ZTwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI3YzEtdDIwIHIxYzItdDIwIj4KLTxwPlNldCB0aGUgc2l6ZSBvZiB0aGUgY2FjaGUuPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjdjMS10MjAgcjFjMy10MjAiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyOGMxLXQyMCIgaGVhZGVycz0icjFjMS10MjAiPgotPHA+Jm5ic3A7Jm5ic3A7U2hhcmVkIENhY2hlPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjhjMS10MjAgcjFjMi10MjAiPgotPHA+U2VlIDxzcGFuIGNsYXNzPSJpdGFsaWMiPkRlZmF1bHQgU2hhcmVkIENhY2hlPC9zcGFuPi48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyOGMxLXQyMCByMWMzLXQyMCI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0idGJsZm9ybWFsIiAtLT4KLTxkaXYgYWxpZ249ImNlbnRlciI+Ci08ZGl2IGNsYXNzPSJpbmZ0Ymxub3RlIj48YnIgLz4KLTx0YWJsZSBjbGFzcz0iTm90ZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRib2R5PgotPHRyPgotPHRkIGFsaWduPSJsZWZ0Ij4KLTxwIGNsYXNzPSJub3RlcDEiPk5vdGU6PC9wPgotVGhpcyBwYWdlIGlzIG5vdCBhdmFpbGFibGUgZm9yIHByb2plY3RzIHVzaW5nIHRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+R2VuZXJpYzwvc3Bhbj4gcGxhdGZvcm0uPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJsbm90ZSIgLS0+PC9kaXY+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMjMuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAyMy5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDY5M2FkMWQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAyMy5odG0KKysrIC9kZXYvbnVsbApAQCAtMSwyMTcgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTEgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5Mb2dnaW5nPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iTG9nZ2luZyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNJQUJHSEhJIiBuYW1lPSJDSUFCR0hISSI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QzIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+TG9nZ2luZzwvaDE+Ci08cD5UaGlzIHRhYmxlIGxpc3RzIHRoZSBwcm9wZXJ0aWVzIG9mIHRoZSBMb2dnaW5nIHBhZ2Ugb2YgdGhlIDxhIGhyZWY9InJlZmVyZW5jZTAxOC5odG0jQ0lBQ0NISUQiPnBlcnNpc3RlbmNlLnhtbCBFZGl0b3I8L2E+LjwvcD4KLTxkaXYgYWxpZ249ImNlbnRlciI+Ci08ZGl2IGNsYXNzPSJpbmZ0Ymxub3RlIj48YnIgLz4KLTx0YWJsZSBjbGFzcz0iTm90ZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRib2R5PgotPHRyPgotPHRkIGFsaWduPSJsZWZ0Ij4KLTxwIGNsYXNzPSJub3RlcDEiPk5vdGU6PC9wPgotVGhpcyBwYWdlIGlzIG5vdCBhdmFpbGFibGUgZm9yIHByb2plY3RzIHVzaW5nIHRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+R2VuZXJpYzwvc3Bhbj4gcGxhdGZvcm0uPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJsbm90ZSIgLS0+PC9kaXY+Ci08ZGl2IGNsYXNzPSJ0Ymxmb3JtYWwiPjxhIGlkPSJzdGhyZWYyMjYiIG5hbWU9InN0aHJlZjIyNiI+PC9hPjxhIGlkPSJzdGhyZWYyMjciIG5hbWU9InN0aHJlZjIyNyI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW50YWJsZSI+UHJvcGVydGllcyBvZiB0aGUgTG9nZ2luZyBQYWdlPC9wPgotPHRhYmxlIGNsYXNzPSJGb3JtYWwiIHRpdGxlPSJQcm9wZXJ0aWVzIG9mIHRoZSBMb2dnaW5nIFBhZ2UiIHN1bW1hcnk9IlRoaXMgdGFibGUgbGlzdHMgdGhlIHByb3BlcnRpZXMgb2YgdGhlIExvZ2dpbmcgcGFnZSBvZiB0aGUgcGVyc2lzdGVuY2UueG1sIEVkaXRvci4iIGRpcj0ibHRyIiBib3JkZXI9IjEiIHdpZHRoPSIxMDAlIiBmcmFtZT0iaHNpZGVzIiBydWxlcz0iZ3JvdXBzIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRoZWFkPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMS10MjMiPlByb3BlcnR5PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMyLXQyMyI+RGVzY3JpcHRpb248L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzMtdDIzIj5EZWZhdWx0PC90aD4KLTwvdHI+Ci08L3RoZWFkPgotPHRib2R5PgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMmMxLXQyMyIgaGVhZGVycz0icjFjMS10MjMiPgotPHA+TG9nZ2luZyBMZXZlbDwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDIzIHIxYzItdDIzIj4KLTxwPlNwZWNpZmllcyB0aGUgYW1vdW50IGFuZCBkZXRhaWwgb2YgbG9nIG91dHB1dCBieSBzZWxlY3RpbmcgdGhlIGxvZyBsZXZlbCAoaW4gYXNjZW5kaW5nIG9yZGVyIG9mIGluZm9ybWF0aW9uKTo8L3A+Ci08cD5UaGUgZm9sbG93aW5nIGFyZSB0aGUgdmFsaWQgdmFsdWVzIGZvciB0aGUgPGNvZGU+amF2YS51dGlsLmxvZ2dpbmcuTGV2ZWw8L2NvZGU+OjwvcD4KLTx1bD4KLTxsaT4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5PRkY8L3NwYW4+Jm5kYXNoO2Rpc2FibGVzIGxvZ2dpbmc8L3A+Ci08L2xpPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPlNFVkVSRTwvc3Bhbj4mbmRhc2g7bG9ncyBleGNlcHRpb25zIGluZGljYXRpbmcgVG9wTGluayBjYW5ub3QgY29udGludWUsIGFzIHdlbGwgYXMgYW55IGV4Y2VwdGlvbnMgZ2VuZXJhdGVkIGR1cmluZyBsb2dpbi4gVGhpcyBpbmNsdWRlcyBhIHN0YWNrIHRyYWNlLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+V0FSTklORzwvc3Bhbj4mbmRhc2g7bG9ncyBleGNlcHRpb25zIHRoYXQgZG8gbm90IGZvcmNlIFRvcExpbmsgdG8gc3RvcCwgaW5jbHVkaW5nIGFsbCBleGNlcHRpb25zIG5vdCBsb2dnZWQgd2l0aCBzZXZlcmUgbGV2ZWwuIFRoaXMgZG9lcyBub3QgaW5jbHVkZSBhIHN0YWNrIHRyYWNlLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+SU5GTzwvc3Bhbj4mbmRhc2g7bG9ncyB0aGUgbG9naW4vbG9nb3V0IHBlciBzZXZlciBzZXNzaW9uLCBpbmNsdWRpbmcgdGhlIHVzZXIgbmFtZS4gQWZ0ZXIgYWNxdWlyaW5nIHRoZSBzZXNzaW9uLCBkZXRhaWxlZCBpbmZvcm1hdGlvbiBpcyBsb2dnZWQuPC9wPgotPC9saT4KLTxsaT4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5DT05GSUc8L3NwYW4+Jm5kYXNoO2xvZ3Mgb25seSBsb2dpbiwgSkRCQyBjb25uZWN0aW9uLCBhbmQgZGF0YWJhc2UgaW5mb3JtYXRpb24uPC9wPgotPC9saT4KLTxsaT4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5GSU5FPC9zcGFuPiZuZGFzaDtsb2dzIFNRTC48L3A+Ci08L2xpPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPkZJTkVSPC9zcGFuPiZuZGFzaDtzaW1pbGFyIHRvIHdhcm5pbmcuIEluY2x1ZGVzIHN0YWNrIHRyYWNlLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+RklORVNUPC9zcGFuPiZuZGFzaDtpbmNsdWRlcyBhZGRpdGlvbmFsIGxvdyBsZXZlbCBpbmZvcm1hdGlvbi48L3A+Ci08L2xpPgotPC91bD4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5FeGFtcGxlPC9zcGFuPjogPGNvZGU+cGVyc2lzdGVuY2UueG1sPC9jb2RlPiBmaWxlPC9wPgotPHByZSB4bWw6c3BhY2U9InByZXNlcnZlIiBjbGFzcz0ib2FjX25vX3dhcm4iPgotJmx0O3Byb3BlcnR5IG5hbWU9ImVjbGlwc2VsaW5rLmxvZ2dpbmcubGV2ZWwiIHZhbHVlPSJJTkZPIi8mZ3Q7Ci08L3ByZT48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQyMyByMWMzLXQyMyI+Ci08cD5JbmZvPC9wPgotPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDIzIiBoZWFkZXJzPSJyMWMxLXQyMyI+Ci08cD4mbmJzcDsmbmJzcDtUaW1lU3RhbXA8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQyMyByMWMyLXQyMyI+Ci08cD5Db250cm9sIHdoZXRoZXIgdGhlIHRpbWVzdGFtcCBpcyBsb2dnZWQgaW4gZWFjaCBsb2cgZW50cnkuPC9wPgotPHA+VGhlIGZvbGxvd2luZyBhcmUgdGhlIHZhbGlkIHZhbHVlczo8L3A+Ci08dWw+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+dHJ1ZTwvc3Bhbj4mbmRhc2g7bG9nIGEgdGltZXN0YW1wLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+ZmFsc2U8L3NwYW4+Jm5kYXNoO2RvIG5vdCBsb2cgYSB0aW1lc3RhbXAuPC9wPgotPC9saT4KLTwvdWw+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+RXhhbXBsZTwvc3Bhbj46IDxjb2RlPnBlcnNpc3RlbmNlLnhtbDwvY29kZT4gZmlsZTwvcD4KLTxwcmUgeG1sOnNwYWNlPSJwcmVzZXJ2ZSIgY2xhc3M9Im9hY19ub193YXJuIj4KLSZsdDtwcm9wZXJ0eSBuYW1lPSJlY2xpcHNlbGluay5sb2dnaW5nLnRpbWVzdGFtcCIgdmFsdWU9ImZhbHNlIi8mZ3Q7Ci08L3ByZT48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQyMyByMWMzLXQyMyI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI0YzEtdDIzIiBoZWFkZXJzPSJyMWMxLXQyMyI+Ci08cD4mbmJzcDsmbmJzcDtUaHJlYWQ8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQyMyByMWMyLXQyMyI+Ci08cD5Db250cm9sIHdoZXRoZXIgYSB0aHJlYWQgaWRlbnRpZmllciBpcyBsb2dnZWQgaW4gZWFjaCBsb2cgZW50cnkuPC9wPgotPHA+VGhlIGZvbGxvd2luZyBhcmUgdGhlIHZhbGlkIHZhbHVlczo8L3A+Ci08dWw+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+dHJ1ZTwvc3Bhbj4mbmRhc2g7bG9nIGEgdGhyZWFkIGlkZW50aWZpZXIuPC9wPgotPC9saT4KLTxsaT4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5mYWxzZTwvc3Bhbj4mbmRhc2g7ZG8gbm90IGxvZyBhIHRocmVhZCBpZGVudGlmaWVyLjwvcD4KLTwvbGk+Ci08L3VsPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MjMgcjFjMy10MjMiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNWMxLXQyMyIgaGVhZGVycz0icjFjMS10MjMiPgotPHA+Jm5ic3A7Jm5ic3A7U2Vzc2lvbjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDIzIHIxYzItdDIzIj4KLTxwPkNvbnRyb2wgd2hldGhlciBhbiBFY2xpcHNlTGluayBzZXNzaW9uIGlkZW50aWZpZXIgaXMgbG9nZ2VkIGluIGVhY2ggbG9nIGVudHJ5LjwvcD4KLTxwPlRoZSBmb2xsb3dpbmcgYXJlIHRoZSB2YWxpZCB2YWx1ZXM6PC9wPgotPHVsPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPnRydWU8L3NwYW4+Jm5kYXNoO2xvZyBhIEVjbGlwc2VMaW5rIHNlc3Npb24gaWRlbnRpZmllci48L3A+Ci08L2xpPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPmZhbHNlPC9zcGFuPiZuZGFzaDtkbyBub3QgbG9nIGEgRWNsaXBzZUxpbmsgc2Vzc2lvbiBpZGVudGlmaWVyLjwvcD4KLTwvbGk+Ci08L3VsPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPkV4YW1wbGU8L3NwYW4+OiA8Y29kZT5wZXJzaXN0ZW5jZS54bWw8L2NvZGU+IGZpbGU8L3A+Ci08cHJlIHhtbDpzcGFjZT0icHJlc2VydmUiIGNsYXNzPSJvYWNfbm9fd2FybiI+Ci0mbHQ7cHJvcGVydHkgbmFtZT0iZWNsaXBzZWxpbmsubG9nZ2luZy5zZXNzaW9uIiB2YWx1ZT0iZmFsc2UiLyZndDsKLTwvcHJlPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDIzIHIxYzMtdDIzIj48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjZjMS10MjMiIGhlYWRlcnM9InIxYzEtdDIzIj4KLTxwPiZuYnNwOyZuYnNwO0V4Y2VwdGlvbnM8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQyMyByMWMyLXQyMyI+Ci08cD5Db250cm9sIHdoZXRoZXIgdGhlIGV4Y2VwdGlvbnMgdGhyb3duIGZyb20gd2l0aGluIHRoZSBUb3BMaW5rIGNvZGUgYXJlIGxvZ2dlZCBwcmlvciB0byByZXR1cm5pbmcgdGhlIGV4Y2VwdGlvbiB0byB0aGUgY2FsbGluZyBhcHBsaWNhdGlvbi4gRW5zdXJlcyB0aGF0IGFsbCBleGNlcHRpb25zIGFyZSBsb2dnZWQgYW5kIG5vdCBtYXNrZWQgYnkgdGhlIGFwcGxpY2F0aW9uIGNvZGUuPC9wPgotPHA+VGhlIGZvbGxvd2luZyBhcmUgdGhlIHZhbGlkIHZhbHVlczo8L3A+Ci08dWw+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+dHJ1ZTwvc3Bhbj4mbmRhc2g7bG9nIGFsbCBleGNlcHRpb25zLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+ZmFsc2U8L3NwYW4+Jm5kYXNoO2RvIG5vdCBsb2cgZXhjZXB0aW9ucy48L3A+Ci08L2xpPgotPC91bD4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5FeGFtcGxlPC9zcGFuPjogPGNvZGU+cGVyc2lzdGVuY2UueG1sPC9jb2RlPiBmaWxlPC9wPgotPHByZSB4bWw6c3BhY2U9InByZXNlcnZlIiBjbGFzcz0ib2FjX25vX3dhcm4iPgotJmx0O3Byb3BlcnR5IG5hbWU9ImVjbGlwc2VsaW5rLmxvZ2dpbmcuZXhjZXB0aW9ucyIgdmFsdWU9InRydWUiLyZndDsKLTwvcHJlPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI2YzEtdDIzIHIxYzMtdDIzIj48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjdjMS10MjMiIGhlYWRlcnM9InIxYzEtdDIzIj4KLTxwPkxvZ2dlcjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI3YzEtdDIzIHIxYzItdDIzIj4KLTxwPlNlbGVjdCB0aGUgdHlwZSBvZiBsb2dnZXIgdG8gdXNlOjwvcD4KLTxwPlRoZSBmb2xsb3dpbmcgYXJlIHRoZSB2YWxpZCB2YWx1ZXM6PC9wPgotPHVsPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPkRlZmF1bHRMb2dnZXI8L3NwYW4+Jm5kYXNoO3RoZSBFY2xpcHNlTGluayBuYXRpdmUgbG9nZ2VyIDxjb2RlPmVjbGlwc2VsaW5rLmxvZ2dpbmcuRGVmYXVsdFNlc3Npb25Mb2c8L2NvZGU+LjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+SmF2YUxvZ2dlcjwvc3Bhbj4mbmRhc2g7dGhlIDxjb2RlPmphdmEudXRpbC5sb2dnaW5nPC9jb2RlPiBsb2dnZXIgPGNvZGU+ZWNsaXBzZWxpbmsubG9nZ2luZy5KYXZhTG9nPC9jb2RlPi48L3A+Ci08L2xpPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPlNlcnZlckxvZ2dlcjwvc3Bhbj4mbmRhc2g7dGhlIDxjb2RlPmphdmEudXRpbC5sb2dnaW5nPC9jb2RlPiBsb2dnZXIgPGNvZGU+ZWNsaXBzZWxpbmsucGxhdGZvcm0uc2VydmVyLlNlcnZlckxvZzwvY29kZT4uIEludGVncmF0ZXMgd2l0aCB0aGUgYXBwbGljYXRpb24gc2VydmVyJ3MgbG9nZ2luZyBhcyBkZWZpbmUgaW4gdGhlIDxjb2RlPmVjbGlwc2VsaW5rLnBsYXRmb3JtLnNlcnZlci5TZXJ2ZXJQbGF0Zm9ybS48L2NvZGU+PC9wPgotPC9saT4KLTxsaT4KLTxwPkZ1bGx5IHF1YWxpZmllZCBjbGFzcyBuYW1lIG9mIGEgY3VzdG9tIGxvZ2dlci4gVGhlIGN1c3RvbSBsb2dnZXIgbXVzdCBpbXBsZW1lbnQgdGhlIDxjb2RlPmVjbGlwc2VsaW5rLmxvZ2dpbmcuU2Vzc2lvbkxvZzwvY29kZT4gaW50ZXJmYWNlLjwvcD4KLTwvbGk+Ci08L3VsPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPkV4YW1wbGU8L3NwYW4+OiA8Y29kZT5wZXJzaXN0ZW5jZS54bWw8L2NvZGU+IGZpbGU8L3A+Ci08cHJlIHhtbDpzcGFjZT0icHJlc2VydmUiIGNsYXNzPSJvYWNfbm9fd2FybiI+Ci0mbHQ7cHJvcGVydHkgbmFtZT0iZWNsaXBzZWxpbmsubG9nZ2luZy5sb2dnZXIiIHZhbHVlPSJhY21lLmxvZ2dlcnMuTXlDdXN0b21Mb2dnZXIiIC8mZ3Q7Ci08L3ByZT48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyN2MxLXQyMyByMWMzLXQyMyI+Ci08cD5EZWZhdWx0TG9nZ2VyPC9wPgotPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0idGJsZm9ybWFsIiAtLT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMjQuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAyNC5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDA3NmUzOGQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAyNC5odG0KKysrIC9kZXYvbnVsbApAQCAtMSwxMjQgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTEgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5PcHRpb25zPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iT3B0aW9ucyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNJQUZKQ0hFIiBuYW1lPSJDSUFGSkNIRSI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QzIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+T3B0aW9uczwvaDE+Ci08cD5UaGlzIHRhYmxlIGxpc3RzIHRoZSBwcm9wZXJ0aWVzIG9mIHRoZSBPcHRpb25zIHBhZ2Ugb2YgdGhlIDxhIGhyZWY9InJlZmVyZW5jZTAxOC5odG0jQ0lBQ0NISUQiPnBlcnNpc3RlbmNlLnhtbCBFZGl0b3I8L2E+LjwvcD4KLTxkaXYgYWxpZ249ImNlbnRlciI+Ci08ZGl2IGNsYXNzPSJpbmZ0Ymxub3RlIj48YnIgLz4KLTx0YWJsZSBjbGFzcz0iTm90ZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRib2R5PgotPHRyPgotPHRkIGFsaWduPSJsZWZ0Ij4KLTxwIGNsYXNzPSJub3RlcDEiPk5vdGU6PC9wPgotVGhpcyBwYWdlIGlzIG5vdCBhdmFpbGFibGUgZm9yIHByb2plY3RzIHVzaW5nIHRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+R2VuZXJpYzwvc3Bhbj4gcGxhdGZvcm0uPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJsbm90ZSIgLS0+PC9kaXY+Ci08ZGl2IGNsYXNzPSJ0Ymxmb3JtYWwiPjxhIGlkPSJzdGhyZWYyMjgiIG5hbWU9InN0aHJlZjIyOCI+PC9hPjxhIGlkPSJzdGhyZWYyMjkiIG5hbWU9InN0aHJlZjIyOSI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW50YWJsZSI+UHJvcGVydGllcyBvZiB0aGUgT3B0aW9ucyBQYWdlPC9wPgotPHRhYmxlIGNsYXNzPSJGb3JtYWwiIHRpdGxlPSJQcm9wZXJ0aWVzIG9mIHRoZSBPcHRpb25zIFBhZ2UiIHN1bW1hcnk9IiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJoc2lkZXMiIHJ1bGVzPSJncm91cHMiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQyNSI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDI1Ij5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10MjUiPkRlZmF1bHQ8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDI1IiBoZWFkZXJzPSJyMWMxLXQyNSI+Ci08cD5TZXNzaW9uIE5hbWU8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQyNSByMWMyLXQyNSI+Ci08cD5TcGVjaWZ5IHRoZSBuYW1lIGJ5IHdoaWNoIHRoZSBFY2xpcHNlTGluayBzZXNzaW9uIGlzIHN0b3JlZCBpbiB0aGUgc3RhdGljIHNlc3Npb24gbWFuYWdlci4gVXNlIHRoaXMgb3B0aW9uIGlmIHlvdSBuZWVkIHRvIGFjY2VzcyB0aGUgRWNsaXBzZUxpbmsgc2hhcmVkIHNlc3Npb24gb3V0c2lkZSBvZiB0aGUgY29udGV4dCBvZiB0aGUgSlBBIG9yIHRvIHVzZSBhIHByZS1leGlzdGluZyBFY2xpcHNlTGluayBzZXNzaW9uIGNvbmZpZ3VyZWQgdGhyb3VnaCBhIEVjbGlwc2VMaW5rIDxjb2RlPnNlc3Npb25zLnhtbDwvY29kZT4gZmlsZTwvcD4KLTxwPlZhbGlkIHZhbHVlczogYSB2YWxpZCBFY2xpcHNlTGluayBzZXNzaW9uIG5hbWUgdGhhdCBpcyB1bmlxdWUgaW4gYSBzZXJ2ZXIgZGVwbG95bWVudC48L3A+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+RXhhbXBsZTwvc3Bhbj46IDxjb2RlPnBlcnNpc3RlbmNlLnhtbDwvY29kZT4gZmlsZTwvcD4KLTxwcmUgeG1sOnNwYWNlPSJwcmVzZXJ2ZSIgY2xhc3M9Im9hY19ub193YXJuIj4KLSZsdDtwcm9wZXJ0eSBuYW1lPSJlY2xpcHNlbGluay5zZXNzaW9uLW5hbWUiIHZhbHVlPSJNeVNlc3Npb24iLyZndDsKLTwvcHJlPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDI1IHIxYzMtdDI1Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10MjUiIGhlYWRlcnM9InIxYzEtdDI1Ij4KLTxwPlNlc3Npb25zIFhNTDwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDI1IHIxYzItdDI1Ij4KLTxwPlNwZWNpZnkgcGVyc2lzdGVuY2UgaW5mb3JtYXRpb24gbG9hZGVkIGZyb20gdGhlIEVjbGlwc2VMaW5rIHNlc3Npb24gY29uZmlndXJhdGlvbiBmaWxlICg8Y29kZT5zZXNzaW9ucy54bWw8L2NvZGU+KS48L3A+Ci08cD5Zb3UgY2FuIHVzZSB0aGlzIG9wdGlvbiBhcyBhbiBhbHRlcm5hdGl2ZSB0byBhbm5vdGF0aW9ucyBhbmQgZGVwbG95bWVudCBYTUwuIElmIHlvdSBzcGVjaWZ5IHRoaXMgcHJvcGVydHksIFRvcExpbmsgd2lsbCBvdmVycmlkZSBhbGwgY2xhc3MgYW5ub3RhdGlvbiBhbmQgdGhlIG9iamVjdCByZWxhdGlvbmFsIG1hcHBpbmcgZnJvbSB0aGUgPGNvZGU+cGVyc2lzdGVuY2UueG1sPC9jb2RlPiwgYXMgd2VsbCBhcyA8Y29kZT5PUk0ueG1sPC9jb2RlPiBhbmQgb3RoZXIgbWFwcGluZyBmaWxlcywgaWYgcHJlc2VudC4gLjwvcD4KLTxwPkluZGljYXRlIHRoZSBzZXNzaW9uIGJ5IHNldHRpbmcgdGhlIDxjb2RlPmVjbGlwc2VsaW5rLnNlc3Npb24tbmFtZTwvY29kZT4gcHJvcGVydHkuPC9wPgotPHA+Tm90ZTogSWYgeW91IGRvIG5vdCBzcGVjaWZ5IHRoZSB2YWx1ZSBmb3IgdGhpcyBwcm9wZXJ0eSwgPGNvZGU+c2Vzc2lvbnMueG1sPC9jb2RlPiBmaWxlIHdpbGwgbm90IGJlIHVzZWQuPC9wPgotPHA+VmFsaWQgdmFsdWVzOiB0aGUgcmVzb3VyY2UgbmFtZSBvZiB0aGUgc2Vzc2lvbnMgWE1MIGZpbGUuPC9wPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPkV4YW1wbGU8L3NwYW4+OiA8Y29kZT5wZXJzaXN0ZW5jZS54bWw8L2NvZGU+IGZpbGU8L3A+Ci08cHJlIHhtbDpzcGFjZT0icHJlc2VydmUiIGNsYXNzPSJvYWNfbm9fd2FybiI+Ci0mbHQ7cHJvcGVydHkgbmFtZT0idG9wbGluay5zZXNzaW9uLXhtbCIgdmFsdWU9Im15c2Vzc2lvbi54bWwiLyZndDsKLTwvcHJlPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDI1IHIxYzMtdDI1Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjRjMS10MjUiIGhlYWRlcnM9InIxYzEtdDI1Ij4KLTxwPlRhcmdldCBEYXRhYmFzZTwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDI1IHIxYzItdDI1Ij48YnIgLz48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQyNSByMWMzLXQyNSI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI1YzEtdDI1IiBoZWFkZXJzPSJyMWMxLXQyNSI+Ci08cD5FdmVudCBMaXN0ZW5lcjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDI1IHIxYzItdDI1Ij4KLTxwPlNwZWNpZnkgYSBkZXNjcmlwdG9yIGV2ZW50IGxpc3RlbmVyIHRvIGJlIGFkZGVkIGR1cmluZyBib290c3RyYXBwaW5nLjwvcD4KLTxwPlZhbGlkIHZhbHVlczogcXVhbGlmaWVkIGNsYXNzIG5hbWUgZm9yIGEgY2xhc3MgdGhhdCBpbXBsZW1lbnRzIHRoZSA8Y29kZT5lY2xpcHNlbGluay5zZXNzaW9ucy5TZXNzaW9uRXZlbnRMaXN0ZW5lcjwvY29kZT4gaW50ZXJmYWNlLjwvcD4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5FeGFtcGxlPC9zcGFuPjogPGNvZGU+cGVyc2lzdGVuY2UueG1sPC9jb2RlPiBmaWxlPC9wPgotPHByZSB4bWw6c3BhY2U9InByZXNlcnZlIiBjbGFzcz0ib2FjX25vX3dhcm4iPgotJmx0O3Byb3BlcnR5IG5hbWU9ImVjbGlwc2VsaW5rLnNlc3Npb24tZXZlbnQtbGlzdGVuZXIiIHZhbHVlPSJteXBhY2thZ2UuTXlDbGFzcy5jbGFzcyIvJmd0OwotPC9wcmU+PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MjUgcjFjMy10MjUiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNmMxLXQyNSIgaGVhZGVycz0icjFjMS10MjUiPgotPHA+SW5jbHVkZSBEZXNjcmlwdG9yIFF1ZXJpZXM8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQyNSByMWMyLXQyNSI+Ci08cD5FbmFibGUgb3IgZGlzYWJsZSB0aGUgZGVmYXVsdCBjb3B5aW5nIG9mIGFsbCBuYW1lZCBxdWVyaWVzIGZyb20gdGhlIGRlc2NyaXB0b3JzIHRvIHRoZSBzZXNzaW9uLiBUaGVzZSBxdWVyaWVzIGluY2x1ZGUgdGhlIG9uZXMgZGVmaW5lZCB1c2luZyBFY2xpcHNlTGluayBBUEksIGRlc2NyaXB0b3IgYW1lbmRtZW50IG1ldGhvZHMsIGFuZCBzbyBvbi48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQyNSByMWMzLXQyNSI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0idGJsZm9ybWFsIiAtLT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMjUuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAyNS5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDE4M2UzMTcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAyNS5odG0KKysrIC9kZXYvbnVsbApAQCAtMSwxMzkgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTEgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5TY2hlbWEgR2VuZXJhdGlvbjwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IlNjaGVtYSBHZW5lcmF0aW9uIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0lBQ0NGQ0IiIG5hbWU9IkNJQUNDRkNCIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDMiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5TY2hlbWEgR2VuZXJhdGlvbjwvaDE+Ci08cD5UaGlzIHRhYmxlIGxpc3RzIHRoZSBwcm9wZXJ0aWVzIG9mIHRoZSBTY2hlbWEgR2VuZXJhdGlvbiBwYWdlIG9mIHRoZSA8YSBocmVmPSJyZWZlcmVuY2UwMTguaHRtI0NJQUNDSElEIj5wZXJzaXN0ZW5jZS54bWwgRWRpdG9yPC9hPi48L3A+Ci08ZGl2IGFsaWduPSJjZW50ZXIiPgotPGRpdiBjbGFzcz0iaW5mdGJsbm90ZSI+PGJyIC8+Ci08dGFibGUgY2xhc3M9Ik5vdGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0Ym9keT4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCI+Ci08cCBjbGFzcz0ibm90ZXAxIj5Ob3RlOjwvcD4KLVRoaXMgcGFnZSBpcyBub3QgYXZhaWxhYmxlIGZvciBwcm9qZWN0cyB1c2luZyB0aGUgPHNwYW4gY2xhc3M9ImJvbGQiPkdlbmVyaWM8L3NwYW4+IHBsYXRmb3JtLjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibG5vdGUiIC0tPjwvZGl2PgotPGRpdiBjbGFzcz0idGJsZm9ybWFsIj48YSBpZD0ic3RocmVmMjMwIiBuYW1lPSJzdGhyZWYyMzAiPjwvYT48YSBpZD0ic3RocmVmMjMxIiBuYW1lPSJzdGhyZWYyMzEiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWludGFibGUiPiZuYnNwOzwvcD4KLTx0YWJsZSBjbGFzcz0iRm9ybWFsIiB0aXRsZT0iIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGxpc3RzIHRoZSBwcm9wZXJ0aWVzIG9mIHRoZSBwZXJzaXN0ZW5jZS54bWwgRWRpdG9yJnJzcXVvO3MgU2NoZW1hIEdlbmVyYXRpb24gcGFnZS4iIGRpcj0ibHRyIiBib3JkZXI9IjEiIHdpZHRoPSIxMDAlIiBmcmFtZT0iaHNpZGVzIiBydWxlcz0iZ3JvdXBzIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRoZWFkPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMS10MjciPlByb3BlcnR5PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMyLXQyNyI+RGVzY3JpcHRpb248L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzMtdDI3Ij5EZWZhdWx0PC90aD4KLTwvdHI+Ci08L3RoZWFkPgotPHRib2R5PgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMmMxLXQyNyIgaGVhZGVycz0icjFjMS10MjciPgotPHA+RERMIEdlbmVyYXRpb24gVHlwZTwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDI3IHIxYzItdDI3Ij4KLTxwPlNlbGVjdCB0aGUgdHlwZSBvZiBEREwgZ2VuZXJhdGlvbjo8L3A+Ci08dWw+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+Tm9uZTwvc3Bhbj4gLS0gRG8gbm90IGdlbmVyYXRlIERETDsgbm8gc2NoZW1hIGlzIGdlbmVyYXRlZC48L3A+Ci08L2xpPgotPGxpPgotPHA+PHNwYW4gY2xhc3M9ImJvbGQiPkNyZWF0ZSBUYWJsZXM8L3NwYW4+IC0tIENyZWF0ZSBEREwgZm9yIG5vbi1leGlzdGVudCB0YWJsZXM7IGxlYXZlIGV4aXN0aW5nIHRhYmxlcyB1bmNoYW5nZWQuPC9wPgotPC9saT4KLTxsaT4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5Ecm9wIGFuZCBDcmVhdGUgVGFibGVzPC9zcGFuPiAtLSBDcmVhdGUgRERMIGZvciBhbGwgdGFibGVzOyBkcm9wIGFsbCBleGlzdGluZyB0YWJsZXMuPC9wPgotPC9saT4KLTwvdWw+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQyNyByMWMzLXQyNyI+Ci08cD5Ob25lPC9wPgotPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDI3IiBoZWFkZXJzPSJyMWMxLXQyNyI+Ci08cD5PdXRwdXQgTW9kZTwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDI3IHIxYzItdDI3Ij4KLTxwPlNlbGVjdCB0aGUgRERMIGdlbmVyYXRpb24gdGFyZ2V0OjwvcD4KLTx1bD4KLTxsaT4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5Cb3RoPC9zcGFuPiAtLSBHZW5lcmF0ZSBTUUwgZmlsZXMgYW5kIGV4ZWN1dGUgdGhlbSBvbiB0aGUgZGF0YWJhc2UuPC9wPgotPC9saT4KLTxsaT4KLTxwPjxzcGFuIGNsYXNzPSJib2xkIj5EYXRhYmFzZTwvc3Bhbj4gLS0gRXhlY3V0ZSBTUUwgb24gdGhlIGRhdGFiYXNlIG9ubHkgKGRvIG5vdCBnZW5lcmF0ZSBTUUwgZmlsZXMpLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48c3BhbiBjbGFzcz0iYm9sZCI+U1FMIFNjcmlwdDwvc3Bhbj4gLS0gR2VuZXJhdGUgU1FMIGZpbGVzIG9ubHkgKGRvIG5vdCBleGVjdXRlIHRoZW0gb24gdGhlIGRhdGFiYXNlKS48L3A+Ci08L2xpPgotPC91bD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDI3IHIxYzMtdDI3Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjRjMS10MjciIGhlYWRlcnM9InIxYzEtdDI3Ij4KLTxwPkRETCBHZW5lcmF0aW9uIExvY2F0aW9uPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MjcgcjFjMi10MjciPgotPHA+U3BlY2lmeSB3aGVyZSBFY2xpcHNlTGluayB3cml0ZXMgRERMIG91dHB1dC4gU3BlY2lmeSBhIGZpbGUgc3BlY2lmaWNhdGlvbiB0byBhIGRpcmVjdG9yeSBpbiB3aGljaCB5b3UgaGF2ZSB3cml0ZSBhY2Nlc3MuIFRoZSBmaWxlIHNwZWNpZmljYXRpb24gbWF5IGJlIHJlbGF0aXZlIHRvIHlvdXIgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSBvciBhYnNvbHV0ZS4gSWYgaXQgZG9lcyBub3QgZW5kIGluIGEgZmlsZSBzZXBhcmF0b3IsIHRoZW4gRWNsaXBzZUxpbmsgYXBwZW5kcyBvbmUgdGhhdCBpcyB2YWxpZCBmb3IgeW91ciBvcGVyYXRpbmcgc3lzdGVtLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDI3IHIxYzMtdDI3Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjVjMS10MjciIGhlYWRlcnM9InIxYzEtdDI3Ij4KLTxwPkNyZWF0ZSBEREwgRmlsZSBOYW1lPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MjcgcjFjMi10MjciPgotPHA+U3BlY2lmeSB0aGUgZmlsZSBuYW1lIG9mIHRoZSBEREwgZmlsZSB0aGF0IEVjbGlwc2VMaW5rIGdlbmVyYXRlcyB0aGF0IGNvbnRhaW5zIFNRTCBzdGF0ZW1lbnRzIGZvciBjcmVhdGluZyB0YWJsZXMgZm9yIEpQQSBlbnRpdGllcy4gU3BlY2lmeSBhIGZpbGUgbmFtZSB2YWxpZCBmb3IgeW91ciBvcGVyYXRpbmcgc3lzdGVtLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDI3IHIxYzMtdDI3Ij4KLTxwPmNyZWF0ZURETC5qZGJjPC9wPgotPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI2YzEtdDI3IiBoZWFkZXJzPSJyMWMxLXQyNyI+Ci08cD5Ecm9wIERETCBGaWxlIE5hbWU8L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQyNyByMWMyLXQyNyI+Ci08cD5TcGVjaWZ5IHRoZSBmaWxlIG5hbWUgb2YgdGhlIERETCBmaWxlIHRoYXQgRWNsaXBzZUxpbmsgZ2VuZXJhdGVzIHRoYXQgY29udGFpbnMgU1FMIHN0YXRlbWVudHMgZm9yIGRyb3BwaW5nIHRhYmxlcyBmb3IgSlBBIGVudGl0aWVzLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI2YzEtdDI3IHIxYzMtdDI3Ij4KLTxwPmRyb3BEREwuamRiYzwvcD4KLTwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9InRibGZvcm1hbCIgLS0+PC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MyIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDI2Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMjYuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDBjNDE0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMjYuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsMzkgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTEgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5Qcm9wZXJ0aWVzPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iUHJvcGVydGllcyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNJQUhKREZGIiBuYW1lPSJDSUFISkRGRiI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QzIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+UHJvcGVydGllczwvaDE+Ci08cD5UaGlzIHBhZ2UgZW5hYmxlcyB5b3UgdG8gYWRkIG9yIHJlbW92ZSB0aGUgdmVuZG9yLXNwZWNpZmljIDxjb2RlPiZsdDtwcm9wZXJ0aWVzJmd0OzwvY29kZT4gZWxlbWVudHMgb2YgcGVyc2lzdGVuY2UueG1sLjwvcD4KLTwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDMiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAyNy5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDI3Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjU2OWVjOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDI3Lmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDQ1ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjUxIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+U291cmNlPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iU291cmNlIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0lBSENKQUgiIG5hbWU9IkNJQUhDSkFIIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDMiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5Tb3VyY2U8L2gxPgotPHA+VXNpbmcgdGhpcyBwYWdlLCB5b3UgY2FuIG1hbnVhbGx5IGVkaXQgdGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlLjwvcD4KLTxwPlNlZSA8YSBocmVmPSJ0YXNrX21hbmFnZV9wZXJzaXN0ZW5jZS5odG0jQ0lIREFKSUQiPiJNYW5hZ2luZyB0aGUgcGVyc2lzdGVuY2UueG1sIGZpbGUiPC9hPiBmb3IgYWRkaXRpb25hbCBpbmZvcm1hdGlvbi48L3A+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrX21hbmFnZV9wZXJzaXN0ZW5jZS5odG0jQ0lIREFKSUQiPk1hbmFnaW5nIHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZTwvYT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QzIiAtLT4KLTwhLS0gY2xhc3M9InNlY3QyIiAtLT4KLTwhLS0gY2xhc3M9InNlY3QxIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMjguaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAyOC5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDcyYmZjMzkuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAyOC5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw0MiArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo1MiAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPlByZWZlcmVuY2VzPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iUHJlZmVyZW5jZXMiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJDQUNERUlFRSIgbmFtZT0iQ0FDREVJRUUiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MSI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPlByZWZlcmVuY2VzPC9oMT4KLTxwPlRoaXMgc2VjdGlvbiBpbmNsdWRlcyBpbmZvcm1hdGlvbiBvbiB0aGUgZm9sbG93aW5nIHByZWZlcmVuY2UgcGFnZXM6PC9wPgotPHVsPgotPGxpPgotPHA+PGEgaHJlZj0icmVmX3Byb2plY3RfcHJvcGVydGllcy5odG0jQkFCSkhCQ0kiPlByb2plY3QgUHJvcGVydGllcyBwYWdlICZuZGFzaDsgSlBBIE9wdGlvbnM8L2E+PC9wPgotPC9saT4KLTwvdWw+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+PC9kaXY+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDI5Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMjkuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwOWQ5NDk4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMjkuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNDUgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTIgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5EaWFsb2dzPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iRGlhbG9ncyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNBQ0dFSkRBIiBuYW1lPSJDQUNHRUpEQSI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QxIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+RGlhbG9nczwvaDE+Ci08cD5UaGlzIHNlY3Rpb24gaW5jbHVkZXMgaW5mb3JtYXRpb24gb24gdGhlIGZvbGxvd2luZyBwcmVmZXJlbmNlIHBhZ2VzOjwvcD4KLTx1bD4KLTxsaT4KLTxwPjxhIGhyZWY9InRhc2tfZ2VuZXJhdGVfZW50aXRpZXMuaHRtI0NBQ0RBRkpEIj5HZW5lcmF0ZSBFbnRpdGllcyBmcm9tIFRhYmxlcyBkaWFsb2c8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAzMC5odG0jQ0FDQ0dFSEMiPkVkaXQgSm9pbiBDb2x1bW5zIERpYWxvZzwvYT48L3A+Ci08L2xpPgotPC91bD4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT48L2Rpdj4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMzAuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAzMC5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAxMjNkZTMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAzMC5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw2NSArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo1MiAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPkVkaXQgSm9pbiBDb2x1bW5zIERpYWxvZzwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IkVkaXQgSm9pbiBDb2x1bW5zIERpYWxvZyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNBQ0NHRUhDIiBuYW1lPSJDQUNDR0VIQyI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QyIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+RWRpdCBKb2luIENvbHVtbnMgRGlhbG9nPC9oMT4KLTxwPlVzZSB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpvaW4gQ29sdW1uczwvc3Bhbj4gZGlhbG9nIHRvIGNyZWF0ZSBvciBtb2RpZnkgdGhlIGpvaW4gdGFibGVzIGFuZCBjb2x1bW5zIGluIHJlbGF0aW9uc2hpcCBtYXBwaW5ncy48L3A+Ci08cD5UaGlzIHRhYmxlIGxpc3RzIHRoZSBwcm9wZXJ0aWVzIGF2YWlsYWJsZSBpbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpvaW4gQ29sdW1uczwvc3Bhbj4gZGlhbG9nLjwvcD4KLTxkaXYgY2xhc3M9ImluZnRibGluZm9ybWFsIj4KLTx0YWJsZSBjbGFzcz0iSW5mb3JtYWwiIHRpdGxlPSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgb3B0aW9ucyBvbiB0aGUgSm9pbiBDb2x1bW5zIGRpYWxvZy4iIHN1bW1hcnk9IlRoaXMgdGFibGUgZGVzY3JpYmVzIHRoZSBvcHRpb25zIG9uIHRoZSBKb2luIENvbHVtbnMgZGlhbG9nLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQzMCI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDMwIj5EZXNjcmlwdGlvbjwvdGg+Ci08L3RyPgotPC90aGVhZD4KLTx0Ym9keT4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjJjMS10MzAiIGhlYWRlcnM9InIxYzEtdDMwIj5OYW1lPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MzAgcjFjMi10MzAiPk5hbWUgb2YgdGhlIGpvaW50IHRhYmxlIGNvbHVtbiB0aGF0IGNvbnRhaW5zIHRoZSBmb3JlaWduIGtleSBjb2x1bW4uPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDMwIiBoZWFkZXJzPSJyMWMxLXQzMCI+UmVmZXJlbmNlZCBDb2x1bW4gTmFtZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDMwIHIxYzItdDMwIj5OYW1lIG9mIHRoZSBkYXRhYmFzZSBjb2x1bW4gdGhhdCBjb250YWlucyB0aGUgZm9yZWlnbiBrZXkgcmVmZXJlbmNlIGZvciB0aGUgZW50aXR5IHJlbGF0aW9uc2hpcC48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0YmxpbmZvcm1hbCIgLS0+Ci08aW1nIHNyYz0iaW1nL25ncmVsci5wbmciIGFsdD0iUmVsYXRlZCByZWZlcmVuY2UiIHRpdGxlPSJSZWxhdGVkIHJlZmVyZW5jZSIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0icmVmZXJlbmNlMDE0Lmh0bSNDQUNCQUVCQyI+Sm9pbiBUYWJsZSBJbmZvcm1hdGlvbjwvYT48YnIgLz4KLTxhIGhyZWY9InJlZmVyZW5jZTAxNS5odG0jQ0FDRkNFSkMiPkpvaW4gQ29sdW1ucyBJbmZvcm1hdGlvbjwvYT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QyIiAtLT4KLTwhLS0gY2xhc3M9InNlY3QxIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMzEuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAzMS5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGM5ZDFlM2UuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAzMS5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw0NSArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo1MiAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPkljb25zIGFuZCBidXR0b25zPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iSWNvbnMgYW5kIGJ1dHRvbnMiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJDQUNESENJQSIgbmFtZT0iQ0FDREhDSUEiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MSI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPkljb25zIGFuZCBidXR0b25zPC9oMT4KLTxwPlRoaXMgc2VjdGlvbiBpbmNsdWRlcyBpbmZvcm1hdGlvbiBvbiBlYWNoIG9mIHRoZSBpY29ucyBhbmQgYnV0dG9ucyB1c2VkIGluIHRoZSBEYWxpIE9SIE1hcHBpbmcgVG9vbC48L3A+Ci08dWw+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZlcmVuY2UwMzIuaHRtI0NBQ0dFQUNHIj5JY29uczwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0icmVmZXJlbmNlMDMzLmh0bSNDQUNESkNFSSI+QnV0dG9uczwvYT48L3A+Ci08L2xpPgotPC91bD4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT48L2Rpdj4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMzIuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAzMi5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZjMWNkODQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAzMi5odG0KKysrIC9kZXYvbnVsbApAQCAtMSwxMDYgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTIgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5JY29uczwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9Ikljb25zIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0FDR0VBQ0ciIG5hbWU9IkNBQ0dFQUNHIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5JY29uczwvaDE+Ci08cD5UaGUgZm9sbG93aW5nIGljb25zIGFyZSB1c2VkIHRocm91Z2hvdXQgdGhlIERhbGkgT1IgTWFwcGluZyBUb29sLjwvcD4KLTxkaXYgY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCI+Ci08dGFibGUgY2xhc3M9IlJ1bGVJbmZvcm1hbCIgdGl0bGU9IlRoaXMgdGFibGUgZGVzY3JpYmVzIHRoZSBpY29ucyB1c2VkIGluIHRoZSBEYWxpIHBsdWctaW4uIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgaWNvbnMgdXNlZCBpbiB0aGUgRGFsaSBwbHVnLWluLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQzMSI+SWNvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMi10MzEiPkRlc2NyaXB0aW9uPC90aD4KLTwvdHI+Ci08L3RoZWFkPgotPHRib2R5PgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMmMxLXQzMSIgaGVhZGVycz0icjFjMS10MzEiPjxpbWcgc3JjPSJpbWcvbmV3X2ljb25fbWFwcGVkZW50aXR5LnBuZyIgYWx0PSIiIHRpdGxlPSIiIC8+PGJyIC8+PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MzEgcjFjMi10MzEiPjxhIGhyZWY9InRhc2tzMDA2Lmh0bSNCQUJHQklFRSI+RW50aXR5PC9hPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyM2MxLXQzMSIgaGVhZGVycz0icjFjMS10MzEiPjxpbWcgc3JjPSJpbWcvbmV3X2ljb25fZW1iZWRkYWJsZWVudGl0eW1hcHBpbmcucG5nIiBhbHQ9IkVtYmVkZGFibGUgZW50aXR5IGljb24iIHRpdGxlPSJFbWJlZGRhYmxlIGVudGl0eSBpY29uIiAvPjxiciAvPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDMxIHIxYzItdDMxIj48YSBocmVmPSJ0YXNrczAwNy5odG0jQkFCRkVJQ0UiPkVtYmVkZGFibGU8L2E+IGVudGl0eTwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNGMxLXQzMSIgaGVhZGVycz0icjFjMS10MzEiPjxpbWcgc3JjPSJpbWcvbmV3X2ljb25fbWFwcGVkc3VwZXJjbGFzcy5wbmciIGFsdD0iTWFwcGVkIHN1cGVyY2xhc3MgaWNvbiIgdGl0bGU9Ik1hcHBlZCBzdXBlcmNsYXNzIGljb24iIC8+PGJyIC8+PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MzEgcjFjMi10MzEiPjxhIGhyZWY9InRhc2tzMDA4Lmh0bSNCQUJEQUdDSSI+TWFwcGVkIHN1cGVyY2xhc3M8L2E+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI1YzEtdDMxIiBoZWFkZXJzPSJyMWMxLXQzMSI+PGltZyBzcmM9ImltZy9uZXdfaWNvbl9iYXNpY21hcHBpbmdzLnBuZyIgYWx0PSJCYXNpYyBtYXBwaW5nIGljb24iIHRpdGxlPSJCYXNpYyBtYXBwaW5nIGljb24iIC8+PGJyIC8+PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MzEgcjFjMi10MzEiPjxhIGhyZWY9InRhc2tzMDEwLmh0bSNCQUJCQUJDRSI+QmFzaWMgbWFwcGluZzwvYT48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjZjMS10MzEiIGhlYWRlcnM9InIxYzEtdDMxIj48aW1nIHNyYz0iaW1nL25ld19pY29uX2VtYmVkZGVkaWRtYXBwaW5nLnBuZyIgYWx0PSJFbWJlZGRlZCBtYXBwaW5nIGljb24iIHRpdGxlPSJFbWJlZGRlZCBtYXBwaW5nIGljb24iIC8+PGJyIC8+PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10MzEgcjFjMi10MzEiPjxhIGhyZWY9InRhc2tzMDExLmh0bSNCQUJDQkhERiI+RW1iZWRkZWQgbWFwcGluZzwvYT48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjdjMS10MzEiIGhlYWRlcnM9InIxYzEtdDMxIj48aW1nIHNyYz0iaW1nL25ld19pY29uX2VtYmVkZGVkbWFwcGluZy5wbmciIGFsdD0iRW1iZWRkZWQgSUQgbWFwcGluZyBpY29uIiB0aXRsZT0iRW1iZWRkZWQgSUQgbWFwcGluZyBpY29uIiAvPjxiciAvPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI3YzEtdDMxIHIxYzItdDMxIj48YSBocmVmPSJ0YXNrczAxMi5odG0jQ0lIRElBRUUiPkVtYmVkZGVkIElEIG1hcHBpbmc8L2E+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI4YzEtdDMxIiBoZWFkZXJzPSJyMWMxLXQzMSI+PGltZyBzcmM9ImltZy9uZXdfaWNvbl9pZG1hcHBpbmcucG5nIiBhbHQ9IklEIG1hcHBpbmcgaWNvbiIgdGl0bGU9IklEIG1hcHBpbmcgaWNvbiIgLz48YnIgLz48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyOGMxLXQzMSByMWMyLXQzMSI+PGEgaHJlZj0idGFza3MwMTMuaHRtI0JBQkdDQkhHIj5JRCBtYXBwaW5nPC9hPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyOWMxLXQzMSIgaGVhZGVycz0icjFjMS10MzEiPjxpbWcgc3JjPSJpbWcvbmV3X2ljb25fbWFueXRvbWFueW1hcHBpbmcucG5nIiBhbHQ9Ik1hbnktdG8tbWFueSBtYXBwaW5nIGljb24iIHRpdGxlPSJNYW55LXRvLW1hbnkgbWFwcGluZyBpY29uIiAvPjxiciAvPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI5YzEtdDMxIHIxYzItdDMxIj48YSBocmVmPSJ0YXNrczAxNC5odG0jQkFCRUlFR0QiPk1hbnktdG8tbWFueSBtYXBwaW5nPC9hPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMTBjMS10MzEiIGhlYWRlcnM9InIxYzEtdDMxIj48aW1nIHNyYz0iaW1nL25ld19pY29uX21hbnl0b29uZW1hcHBpbmcucG5nIiBhbHQ9Ik1hbnktdG8tb25lIG1hcHBpbmcgaWNvbi4iIHRpdGxlPSJNYW55LXRvLW9uZSBtYXBwaW5nIGljb24uIiAvPjxiciAvPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIxMGMxLXQzMSByMWMyLXQzMSI+PGEgaHJlZj0idGFza3MwMTUuaHRtI0JBQkhGQUZKIj5NYW55LXRvLW9uZSBtYXBwaW5nPC9hPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMTFjMS10MzEiIGhlYWRlcnM9InIxYzEtdDMxIj48aW1nIHNyYz0iaW1nL25ld19pY29uX29uZXRvbWFueW1hcHBpbmcucG5nIiBhbHQ9Ik9uZS10by1tYW55IG1hcHBpbmcgaWNvbiIgdGl0bGU9Ik9uZS10by1tYW55IG1hcHBpbmcgaWNvbiIgLz48YnIgLz48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMTFjMS10MzEgcjFjMi10MzEiPjxhIGhyZWY9InRhc2tzMDE2Lmh0bSNCQUJIR0VCRCI+T25lLXRvLW1hbnkgbWFwcGluZzwvYT48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjEyYzEtdDMxIiBoZWFkZXJzPSJyMWMxLXQzMSI+PGltZyBzcmM9ImltZy9uZXdfaWNvbl9vbmV0b29uZW1hcHBpbmcucG5nIiBhbHQ9Ik9uZS10by1vbmUgbWFwcGluZyBpY29uLiIgdGl0bGU9Ik9uZS10by1vbmUgbWFwcGluZyBpY29uLiIgLz48YnIgLz48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMTJjMS10MzEgcjFjMi10MzEiPjxhIGhyZWY9InRhc2tzMDE3Lmh0bSNCQUJGSEJDSiI+T25lLXRvLW9uZSBtYXBwaW5nPC9hPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMTNjMS10MzEiIGhlYWRlcnM9InIxYzEtdDMxIj48aW1nIHNyYz0iaW1nL25ld19pY29uX3RyYW5zaWVudG1hcHBpbmcucG5nIiBhbHQ9IlRyYW5zaWVudCBtYXBwaW5nIGljb24uIiB0aXRsZT0iVHJhbnNpZW50IG1hcHBpbmcgaWNvbi4iIC8+PGJyIC8+PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjEzYzEtdDMxIHIxYzItdDMxIj48YSBocmVmPSJ0YXNrczAxOC5odG0jQkFCSEZIRUkiPlRyYW5zaWVudCBtYXBwaW5nPC9hPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMTRjMS10MzEiIGhlYWRlcnM9InIxYzEtdDMxIj48aW1nIHNyYz0iaW1nL25ld19pY29uX3ZlcnNpb25tYXBwaW5nLnBuZyIgYWx0PSJWZXJzaW9uIG1hcHBpbmcgaWNvbi4iIHRpdGxlPSJWZXJzaW9uIG1hcHBpbmcgaWNvbi4iIC8+PGJyIC8+PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjE0YzEtdDMxIHIxYzItdDMxIj48YSBocmVmPSJ0YXNrczAxOS5odG0jQkFCSElCSUkiPlZlcnNpb24gbWFwcGluZzwvYT48YnIgLz48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0YmxydWxlaW5mb3JtYWwiIC0tPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAzMS5odG0jQ0FDREhDSUEiPkljb25zIGFuZCBidXR0b25zPC9hPjwvcD4KLTwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDIiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3JlZmVyZW5jZTAzMy5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDMzLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTEyZTQ4Ni4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDMzLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDU5ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjUzIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+QnV0dG9uczwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IkJ1dHRvbnMiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJDQUNESkNFSSIgbmFtZT0iQ0FDREpDRUkiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MiI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPkJ1dHRvbnM8L2gxPgotPHA+VGhlIGZvbGxvd2luZyBidXR0b25zIGFyZSB1c2VkIHRocm91Z2hvdXQgdGhlIERhbGkgT1IgTWFwcGluZyBUb29sLjwvcD4KLTxkaXYgY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCI+Ci08dGFibGUgY2xhc3M9IlJ1bGVJbmZvcm1hbCIgdGl0bGU9IlRoaXMgdGFibGUgZGVzY3JpYmVzIHRoZSBidXR0b25zIHVzZWQgaW4gdGhlIERhbGkgcGx1Zy1pbi4iIHN1bW1hcnk9IlRoaXMgdGFibGUgZGVzY3JpYmVzIHRoZSBidXR0b25zIHVzZWQgaW4gdGhlIERhbGkgcGx1Zy1pbi4iIGRpcj0ibHRyIiBib3JkZXI9IjEiIHdpZHRoPSIxMDAlIiBmcmFtZT0iYm9yZGVyIiBydWxlcz0iYWxsIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRoZWFkPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMS10MzIiPkljb248L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDMyIj5EZXNjcmlwdGlvbjwvdGg+Ci08L3RyPgotPC90aGVhZD4KLTx0Ym9keT4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjJjMS10MzIiIGhlYWRlcnM9InIxYzEtdDMyIj48aW1nIHNyYz0iaW1nL25ld19qcGFfcGVyc3BlY3RpdmVfYnV0dG9uLnBuZyIgYWx0PSJUaGUgSlBBIFBlcnNwZWN0aXZlIGljb24iIHRpdGxlPSJUaGUgSlBBIFBlcnNwZWN0aXZlIGljb24iIC8+PGJyIC8+PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MzIgcjFjMi10MzIiPkpQQSBEZXZlbG9wbWVudCBwZXJzcGVjdGl2ZTwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCIgLS0+Ci08aW1nIHNyYz0iaW1nL25ncmVsYy5wbmciIGFsdD0iUmVsYXRlZCBjb25jZXB0IiB0aXRsZT0iUmVsYXRlZCBjb25jZXB0IiAvPjxiciAvPgotPHA+PGEgaHJlZj0icmVmZXJlbmNlMDMxLmh0bSNDQUNESENJQSI+SWNvbnMgYW5kIGJ1dHRvbnM8L2E+PC9wPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MiIgLS0+Ci08IS0tIGNsYXNzPSJzZWN0MSIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvcmVmZXJlbmNlMDM0Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMzQuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjZjY3N2UzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci9yZWZlcmVuY2UwMzQuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNTIgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTMgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5EYWxpIERldmVsb3BlciBEb2N1bWVudGF0aW9uPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iRGFsaSBEZXZlbG9wZXIgRG9jdW1lbnRhdGlvbiIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNBQ0JCRElCIiBuYW1lPSJDQUNCQkRJQiI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QxIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+RGFsaSBEZXZlbG9wZXIgRG9jdW1lbnRhdGlvbjwvaDE+Ci08cD48YSBpZD0ic3RocmVmMjQ2IiBuYW1lPSJzdGhyZWYyNDYiPjwvYT48YSBpZD0ic3RocmVmMjQ3IiBuYW1lPSJzdGhyZWYyNDciPjwvYT48YSBpZD0ic3RocmVmMjQ4IiBuYW1lPSJzdGhyZWYyNDgiPjwvYT5BZGRpdGlvbmFsIERhbGkgZG9jdW1lbnRhdGlvbiBpcyBhdmFpbGFibGUgb25saW5lIGF0OjwvcD4KLTxwPjxjb2RlPjxhIGhyZWY9Imh0dHA6Ly93aWtpLmVjbGlwc2Uub3JnL2luZGV4LnBocC9EYWxpX0RldmVsb3Blcl9Eb2N1bWVudGF0aW9uIj5odHRwOi8vd2lraS5lY2xpcHNlLm9yZy9pbmRleC5waHAvRGFsaV9EZXZlbG9wZXJfRG9jdW1lbnRhdGlvbjwvYT48L2NvZGU+PC9wPgotPHA+VGhpcyBkZXZlbG9wZXIgZG9jdW1lbnRhdGlvbiBpbmNsdWRlcyBpbmZvcm1hdGlvbiBhYm91dDo8L3A+Ci08dWw+Ci08bGk+Ci08cD5EYWxpIGFyY2hpdGVjdHVyZTwvcD4KLTwvbGk+Ci08bGk+Ci08cD5QbHVnaW5zIHRoYXQgY29tcHJpc2UgdGhlIERhbGkgSlBBIEVjbGlwc2UgZmVhdHVyZTwvcD4KLTwvbGk+Ci08bGk+Ci08cD5FeHRlbnNpb24gcG9pbnRzPC9wPgotPC9saT4KLTwvdWw+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QxIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza19hZGRfcGVyc2lzdGVuY2UuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyZmRlMWUyLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw1OSArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0NCAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPkFkZGluZyBwZXJzaXN0ZW5jZSB0byBhIGNsYXNzPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iQWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3MiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJCQUJISUNBSSIgbmFtZT0iQkFCSElDQUkiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MSI+Ci08aDE+QWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3M8L2gxPgotPHA+PGEgaWQ9InN0aHJlZjU0IiBuYW1lPSJzdGhyZWY1NCI+PC9hPjxhIGlkPSJzdGhyZWY1NSIgbmFtZT0ic3RocmVmNTUiPjwvYT48YSBpZD0ic3RocmVmNTYiIG5hbWU9InN0aHJlZjU2Ij48L2E+WW91IGNhbiBtYWtlIGEgSmF2YSBjbGFzcyBpbnRvIG9uZSBvZiB0aGUgZm9sbG93aW5nIHBlcnNpc3RlbnQgdHlwZXM6PC9wPgotPHVsPgotPGxpPgotPHA+PGEgaHJlZj0idGFza3MwMDYuaHRtI0JBQkdCSUVFIj5FbnRpdHk8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InRhc2tzMDA3Lmh0bSNCQUJGRUlDRSI+RW1iZWRkYWJsZTwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0idGFza3MwMDguaHRtI0JBQkRBR0NJIj5NYXBwZWQgc3VwZXJjbGFzczwvYT48L3A+Ci08L2xpPgotPC91bD4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWx0LnBuZyIgYWx0PSJSZWxhdGVkIHRhc2tzIiB0aXRsZT0iUmVsYXRlZCB0YXNrcyIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza19hZGRpdG9uYWxfdGFibGVzLmh0bSNDSUhHQklFSSI+U3BlY2lmeWluZyBhZGRpdGlvbmFsIHRhYmxlczwvYT48YnIgLz4KLTxhIGhyZWY9InRhc2tfaW5oZXJpdGFuY2UuaHRtI0NJSENDQ0pEIj5TcGVjaWZ5aW5nIGVudGl0eSBpbmhlcml0YW5jZTwvYT48YnIgLz4KLTxhIGhyZWY9InRhc2tfbWFwcGluZy5odG0jQkFCREdCSUoiPk1hcHBpbmcgYW4gZW50aXR5PC9hPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0iY29uY2VwdF9wZXJzaXN0ZW5jZS5odG0jQkFCQ0FISUMiPlVuZGVyc3RhbmRpbmcgSmF2YSBwZXJzaXN0ZW5jZTwvYT48YnIgLz4KLTxhIGhyZWY9ImNvbmNlcHRzMDAzLmh0bSNDSERCSUpBQyI+VGhlIG9ybS54bWwgZmlsZTwvYT48YnIgLz4KLTxhIGhyZWY9ImNvbmNlcHRzMDAyLmh0bSNDSERIQUdJSCI+VGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlPC9hPiA8IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+PC9kaXY+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza19hZGRpdG9uYWxfdGFibGVzLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrX2FkZGl0b25hbF90YWJsZXMuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiYTc2MGY2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrX2FkZGl0b25hbF90YWJsZXMuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNzAgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDUgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5TcGVjaWZ5aW5nIGFkZGl0aW9uYWwgdGFibGVzPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iU3BlY2lmeWluZyBhZGRpdGlvbmFsIHRhYmxlcyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNJSEdCSUVJIiBuYW1lPSJDSUhHQklFSSI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QxIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+U3BlY2lmeWluZyBhZGRpdGlvbmFsIHRhYmxlczwvaDE+Ci08cD5BZGQgYSBzZWNvbmRhcnkgdGFibGUgYW5ub3RhdGlvbiB0byBhbiBlbnRpdHkgaWYgaXRzIGRhdGEgaXMgc3BsaXQgYWNyb3NzIG1vcmUgbW9yZSB0aGFuIG9uZSB0YWJsZS48L3A+Ci08cD5UbyBhZGQgYSBzZWNvbmRhcnkgdGFibGUgdG8gdGhlIGVudGl0eSw8L3A+Ci08b2wgc3RhcnQ9IjEiPgotPGxpPgotPHA+U2VsZWN0IHRoZSBlbnRpdHkgaW4gdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5QYWNrYWdlIEV4cGxvcmVyPC9zcGFuPi48L3A+Ci08L2xpPgotPGxpPgotPHA+SW4gdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5KUEEgRGV0YWlsczwvc3Bhbj4gdmlldywgc2VsZWN0IHRoZSA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC1hY3Rpb24iPlNlY29uZGFyeSBUYWJsZXM8L3NwYW4+IGluZm9ybWF0aW9uLjwvcD4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9InN0aHJlZjc5IiBuYW1lPSJzdGhyZWY3OSI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPlNwZWNpZnlpbmcgU2Vjb25kYXJ5IFRhYmxlczwvcD4KLTxpbWcgc3JjPSJpbWcvc2Vjb25kYXJ5X3RhYmxlcy5wbmciIGFsdD0iU2Vjb25kYXJ5IFRhYmxlcyBhcmVhIG9uIHRoZSBKUEEgRGV0YWlscyB2aWV3LiIgdGl0bGU9IlNlY29uZGFyeSBUYWJsZXMgYXJlYSBvbiB0aGUgSlBBIERldGFpbHMgdmlldy4iIC8+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJmaWd1cmUiIC0tPjwvbGk+Ci08bGk+Ci08cD5DbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+QWRkPC9zcGFuPiB0byBhc3NvY2lhdGUgYW4gYWRkaXRpb25hbCB0YWJsZSB3aXRoIHRoZSBlbnRpdHkuIFRoZSBFZGl0IFNlY29uZGFyeSBUYWJsZSBkaWFsb2cgYXBwZWFyczwvcD4KLTwvbGk+Ci08bGk+Ci08cD5TZWxlY3QgdGhlIDxzcGFuIGNsYXNzPSJib2xkIj5OYW1lPC9zcGFuPiwgPHNwYW4gY2xhc3M9ImJvbGQiPkNhdGFsb2c8L3NwYW4+LCBhbmQgPHNwYW4gY2xhc3M9ImJvbGQiPlNjaGVtYTwvc3Bhbj4gb2YgdGhlIGFkZGl0aW9uYWwgdGFibGUgdG8gYXNzb2NpYXRlIHdpdGggdGhlIGVudGl0eS48L3A+Ci08L2xpPgotPC9vbD4KLTxwPkVjbGlwc2UgYWRkcyB0aGUgZm9sbG93aW5nIGFubm90YXRpb25zIHRoZSBlbnRpdHk6PC9wPgotPHByZSB4bWw6c3BhY2U9InByZXNlcnZlIiBjbGFzcz0ib2FjX25vX3dhcm4iPgotQFNlY29uZGFyeVRhYmxlKG5hbWU9Ik5BTUUiLCBjYXRhbG9nID0gIkNBVEFMT0ciLCBzY2hlbWEgPSAiU0NIRU1BIgotCi08L3ByZT4KLTxiciAvPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza19hZGRfcGVyc2lzdGVuY2UuaHRtI0JBQkhJQ0FJIj5BZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBjbGFzczwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxjLnBuZyIgYWx0PSJSZWxhdGVkIGNvbmNlcHQiIHRpdGxlPSJSZWxhdGVkIGNvbmNlcHQiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9ImNvbmNlcHRfcGVyc2lzdGVuY2UuaHRtI0JBQkNBSElDIj5VbmRlcnN0YW5kaW5nIEphdmEgcGVyc2lzdGVuY2U8L2E+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MSIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza19jcmVhdGVfbmV3X3Byb2plY3QuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tfY3JlYXRlX25ld19wcm9qZWN0Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMWE3YWQ0YS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza19jcmVhdGVfbmV3X3Byb2plY3QuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsMTI4ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQyIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+Q3JlYXRpbmcgYSBuZXcgSlBBIHByb2plY3Q8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJDcmVhdGluZyBhIG5ldyBKUEEgcHJvamVjdCIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNJSEhFSkNKIiBuYW1lPSJDSUhIRUpDSiI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QxIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+Q3JlYXRpbmcgYSBuZXcgSlBBIHByb2plY3Q8L2gxPgotPHA+PGEgaWQ9InN0aHJlZjI1IiBuYW1lPSJzdGhyZWYyNSI+PC9hPjxhIGlkPSJzdGhyZWYyNiIgbmFtZT0ic3RocmVmMjYiPjwvYT5Vc2UgdGhpcyBwcm9jZWR1cmUgdG8gY3JlYXRlIGEgbmV3IEpQQSBwcm9qZWN0LjwvcD4KLTxvbCBzdGFydD0iMSI+Ci08bGk+Ci08cD5Gcm9tIHRoZSBOYXZpZ2F0b3Igb3IgUGFja2FnZSBFeHBsb3Jlciwgc2VsZWN0IDxzcGFuIGNsYXNzPSJib2xkIj5GaWxlICZndDsgTmV3ICZndDsgUHJvamVjdDwvc3Bhbj4uIFRoZSBTZWxlY3QgYSB3aXphcmQgZGlhbG9nIGFwcGVhcnMuPC9wPgotPGRpdiBhbGlnbj0iY2VudGVyIj4KLTxkaXYgY2xhc3M9ImluZnRibG5vdGVhbHNvIj48YnIgLz4KLTx0YWJsZSBjbGFzcz0iTm90ZUFsc28gb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0Ym9keT4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCI+Ci08cCBjbGFzcz0ibm90ZXAxIj5UaXA6PC9wPgotWW91IGNhbiBhbHNvIHNlbGVjdCB0aGUgSlBBIHBlcnNwZWN0aXZlIGFuZCB0aGVuIHNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+RmlsZSAmZ3Q7IE5ldyAmZ3Q7IEpQQSBQcm9qZWN0PC9zcGFuPi48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0Ymxub3RlYWxzbyIgLS0+PC9kaXY+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWYyNyIgbmFtZT0ic3RocmVmMjciPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWluZmlndXJlIj5TZWxlY3RpbmcgdGhlIENyZWF0ZSBhIEpQQSBQcm9qZWN0IHdpemFyZDwvcD4KLTxpbWcgc3JjPSJpbWcvc2VsZWN0X2Ffd2l6YXJkX2pwYV9wcm9qZWN0LnBuZyIgYWx0PSJUaGUgU2VsZWN0IGEgV2l6YXJkIGRpYWxvZyB3aXRoIEpQQSBwcm9qZWN0IHNlbGVjdGVkLiIgdGl0bGU9IlRoZSBTZWxlY3QgYSBXaXphcmQgZGlhbG9nIHdpdGggSlBBIHByb2plY3Qgc2VsZWN0ZWQuIiAvPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iZmlndXJlIiAtLT48L2xpPgotPGxpPgotPHA+U2VsZWN0IDxzcGFuIGNsYXNzPSJib2xkIj5KUEEgUHJvamVjdDwvc3Bhbj4gYW5kIHRoZW4gY2xpY2sgPHNwYW4gY2xhc3M9ImJvbGQiPk5leHQ8L3NwYW4+LiBUaGUgPGEgaHJlZj0icmVmX25ld19qcGFfcHJvamVjdC5odG0jQ0FDQkpBR0MiPk5ldyBKUEEgUHJvamVjdCBwYWdlPC9hPiBhcHBlYXJzLjwvcD4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9InN0aHJlZjI4IiBuYW1lPSJzdGhyZWYyOCI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPlRoZSBKUEEgUHJvamVjdCBQYWdlPC9wPgotPGltZyBzcmM9ImltZy9uZXdfanBhX3Byb2plY3RfdGFzay5wbmciIGFsdD0iVGhlIEpQQSBQcm9qZWN0IHBhZ2Ugb2YgdGhlIENyZWF0ZSBhIEpQQSBQcm9qZWN0IHdpemFyZC4iIHRpdGxlPSJUaGUgSlBBIFByb2plY3QgcGFnZSBvZiB0aGUgQ3JlYXRlIGEgSlBBIFByb2plY3Qgd2l6YXJkLiIgLz48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImZpZ3VyZSIgLS0+PC9saT4KLTxsaT4KLTxwPkNvbXBsZXRlIHRoZSBmaWVsZHMgb24gdGhlIDxhIGhyZWY9InJlZl9uZXdfanBhX3Byb2plY3QuaHRtI0NBQ0JKQUdDIj5OZXcgSlBBIFByb2plY3QgcGFnZTwvYT4gdG8gc3BlY2lmeSB0aGUgcHJvamVjdCBuYW1lIGFuZCBsb2NhdGlvbiwgdGFyZ2V0IHJ1bnRpbWUsIGFuZCBwcmUtZGVmaW5lZCBjb25maWd1cmF0aW9uLjwvcD4KLTxkaXYgYWxpZ249ImNlbnRlciI+Ci08ZGl2IGNsYXNzPSJpbmZ0Ymxub3RlIj48YnIgLz4KLTx0YWJsZSBjbGFzcz0iTm90ZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRib2R5PgotPHRyPgotPHRkIGFsaWduPSJsZWZ0Ij4KLTxwIGNsYXNzPSJub3RlcDEiPk5vdGU6PC9wPgotVGhlIFRhcmdldCBSdW50aW1lIGlzIG5vdCByZXF1aXJlZCBmb3IgSmF2YSBTRSBkZXZlbG9wbWVudC48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0Ymxub3RlIiAtLT48L2Rpdj4KLTwvbGk+Ci08bGk+Ci08cD5DbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+TmV4dDwvc3Bhbj4uIDxhIGhyZWY9InJlZl9qcGFfZmFjZXQuaHRtI0NBQ0lGRElGIj5KUEEgRmFjZXQgcGFnZTwvYT4gYXBwZWFycy48L3A+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWYyOSIgbmFtZT0ic3RocmVmMjkiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWluZmlndXJlIj5UaGUgSlBBIEZhY2V0IFBhZ2U8L3A+Ci08aW1nIHNyYz0iaW1nL25ld19qcGFfZmFjZXRfdGFzay5wbmciIGFsdD0iVGhlIEpQQSBGYWNldCBwYWdlIG9mIHRoZSBDcmVhdGUgYSBKUEEgUHJvamVjdCB3aXphcmQuIiB0aXRsZT0iVGhlIEpQQSBGYWNldCBwYWdlIG9mIHRoZSBDcmVhdGUgYSBKUEEgUHJvamVjdCB3aXphcmQuIiAvPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iZmlndXJlIiAtLT48L2xpPgotPGxpPgotPHA+Q29tcGxldGUgdGhlIGZpZWxkcyBvbiB0aGUgPGEgaHJlZj0icmVmX2pwYV9mYWNldC5odG0jQ0FDSUZESUYiPkpQQSBGYWNldCBwYWdlPC9hPiB0byBzcGVjaWZ5IHlvdXIgdmVuZGVyLXNwZWNpZmljIHBsYXRmb3JtLCBkYXRhYmFzZSBjb25uZWN0aW9uLCBhbmQgSlBBIGltcGxlbWVudGF0aW9uIGxpYnJhcnkuPC9wPgotPHA+SWYgRGFsaSBkZXJpdmVzIHRoZSBpbmNvcnJlY3Qgc2NoZW1hLCBzZWxlY3QgPHNwYW4gY2xhc3M9ImJvbGQiPk92ZXJyaWRlIHRoZSBEZWZhdWx0IFNjaGVtYSBmb3IgQ29ubmVjdGlvbjwvc3Bhbj4uIFVzaW5nIHRoaXMgb3B0aW9uLCB5b3UgY2FuIHNlbGVjdCBhIGRldmVsb3BtZW50IHRpbWUgc2NoZW1hIGZvciBkZWZhdWx0cyBhbmQgdmFsaWRhdGlvbi48L3A+Ci08cD5JZiB5b3UgY2xlYXIgdGhlIDxzcGFuIGNsYXNzPSJib2xkIj5DcmVhdGUgb3JtLnhtbDwvc3Bhbj4gb3B0aW9uICh3aGljaCBpcyBzZWxlY3RlZCBieSBkZWZhdWx0KSwgeW91IGNhbiBsYXRlciBhZGQgYSBtYXBwaW5nIGZpbGUgdG8gdGhlIHByb2plY3QgdXNpbmcgdGhlIDxhIGhyZWY9InJlZmVyZW5jZTAwNS5odG0jQ0lBSUpDQ0UiPk1hcHBpbmcgRmlsZSBXaXphcmQ8L2E+LjwvcD4KLTxkaXYgYWxpZ249ImNlbnRlciI+Ci08ZGl2IGNsYXNzPSJpbmZ0Ymxub3RlIj48YnIgLz4KLTx0YWJsZSBjbGFzcz0iTm90ZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRib2R5PgotPHRyPgotPHRkIGFsaWduPSJsZWZ0Ij4KLTxwIGNsYXNzPSJub3RlcDEiPk5vdGU6PC9wPgotSWYgdGhlIHNlcnZlciBydW50aW1lIGRvZXMgbm90IHByb3ZpZGUgYSBKUEEgaW1wbGVtZW50YXRpb24sIHlvdSBtdXN0IGV4cGxpY2l0bHkgc2VsZWN0IGEgSlBBIGltcGxlbWVudGF0aW9uIGxpYnJhcnkuCi08cD5UbyBpbnN1cmUgdGhlIHBvcnRhYmlsaXR5IG9mIHlvdXIgYXBwbGljYXRpb24sIHlvdSBtdXN0IGV4cGxpY2l0bHkgbGlzdCB0aGUgbWFuYWdlZCBwZXJzaXN0ZW5jZSBjbGFzc2VzIHRoYXQgYXJlIGluY2x1ZGVkIGluIHRoZSBwZXJzaXN0ZW5jZSB1bml0LiBJZiB0aGUgc2VydmVyIHN1cHBvcnRzIEVKQiAzLjAsIHRoZSBwZXJzaXN0ZW50IGNsYXNzZXMgd2lsbCBiZSBkaXNjb3ZlcmVkIGF1dG9tYXRpY2FsbHkuPC9wPgotPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJsbm90ZSIgLS0+PC9kaXY+Ci08L2xpPgotPGxpPgotPHA+Q2xpY2sgPHNwYW4gY2xhc3M9ImJvbGQiPkZpbmlzaDwvc3Bhbj4uIFlvdSBzaG91bGQgbm93IG9wZW4gdGhlIDxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wZXJzcGVjdGl2ZS5odG0jQkFCSUZCREIiPkpQQSBEZXZlbG9wbWVudCBwZXJzcGVjdGl2ZTwvYT4uPC9wPgotPC9saT4KLTwvb2w+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsci5wbmciIGFsdD0iUmVsYXRlZCByZWZlcmVuY2UiIHRpdGxlPSJSZWxhdGVkIHJlZmVyZW5jZSIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0icmVmX25ld19qcGFfcHJvamVjdF93aXphcmQuaHRtI0NBQ0JKR0JHIj5DcmVhdGUgTmV3IEpQQSBQcm9qZWN0IHdpemFyZDwvYT48YnIgLz4KLTxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wZXJzcGVjdGl2ZS5odG0jQkFCSUZCREIiPkpQQSBEZXZlbG9wbWVudCBwZXJzcGVjdGl2ZTwvYT48YnIgLz4KLTxhIGhyZWY9InJlZmVyZW5jZTAwNS5odG0jQ0lBSUpDQ0UiPk1hcHBpbmcgRmlsZSBXaXphcmQ8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrcyIgdGl0bGU9IlJlbGF0ZWQgdGFza3MiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InRhc2tfbWFuYWdlX3BlcnNpc3RlbmNlLmh0bSNDSUhEQUpJRCI+TWFuYWdpbmcgdGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlPC9hPjxiciAvPgotPGEgaHJlZj0idGFza19hZGRfcGVyc2lzdGVuY2UuaHRtI0JBQkhJQ0FJIj5BZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBjbGFzczwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxjLnBuZyIgYWx0PSJSZWxhdGVkIGNvbmNlcHQiIHRpdGxlPSJSZWxhdGVkIGNvbmNlcHQiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9ImNvbmNlcHRfcGVyc2lzdGVuY2UuaHRtI0JBQkNBSElDIj5VbmRlcnN0YW5kaW5nIEphdmEgcGVyc2lzdGVuY2U8L2E+PGJyIC8+Ci08YSBocmVmPSJjb25jZXB0czAwMi5odG0jQ0hESEFHSUgiPlRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZTwvYT4KLTxwPiZuYnNwOzwvcD4KLTwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDEiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tfZ2VuZXJhdGVfZW50aXRpZXMuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tfZ2VuZXJhdGVfZW50aXRpZXMuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyOTlhZWRkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrX2dlbmVyYXRlX2VudGl0aWVzLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDcyICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjUyIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+R2VuZXJhdGUgRW50aXRpZXMgZnJvbSBUYWJsZXMgZGlhbG9nPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iR2VuZXJhdGUgRW50aXRpZXMgZnJvbSBUYWJsZXMgZGlhbG9nIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0FDREFGSkQiIG5hbWU9IkNBQ0RBRkpEIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5HZW5lcmF0ZSBFbnRpdGllcyBmcm9tIFRhYmxlcyBkaWFsb2c8L2gxPgotPHA+PGEgaWQ9InN0aHJlZjI0MSIgbmFtZT0ic3RocmVmMjQxIj48L2E+PGEgaWQ9InN0aHJlZjI0MiIgbmFtZT0ic3RocmVmMjQyIj48L2E+PGEgaWQ9InN0aHJlZjI0MyIgbmFtZT0ic3RocmVmMjQzIj48L2E+VXNlIHRoZSA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC10aXRsZSI+R2VuZXJhdGUgRW50aXRpZXM8L3NwYW4+IGRpYWxvZyB0byBjcmVhdGUgSmF2YSBwZXJzaXN0ZW50IGVudGl0aWVzIGZyb20geW91ciBkYXRhYmFzZSB0YWJsZXMgYW5kIGNvbHVtbnMuPC9wPgotPHA+VGhpcyB0YWJsZSBsaXN0cyB0aGUgcHJvcGVydGllcyBhdmFpbGFibGUgaW4gdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5HZW5lcmF0ZSBFbnRpdGllcyBkaWFsb2c8L3NwYW4+LjwvcD4KLTxkaXYgY2xhc3M9ImluZnRibGluZm9ybWFsIj4KLTx0YWJsZSBjbGFzcz0iSW5mb3JtYWwiIHRpdGxlPSJUaGlzIHRhYmxlIGRlc2NyaWJlcyB0aGUgb3B0aW9ucyBvbiB0aGUgR2VuZXJhdGUgRW50aXRpZXMgZGlhbG9nLiIgc3VtbWFyeT0iVGhpcyB0YWJsZSBkZXNjcmliZXMgdGhlIG9wdGlvbnMgb24gdGhlIEdlbmVyYXRlIEVudGl0aWVzIGRpYWxvZy4iIGRpcj0ibHRyIiBib3JkZXI9IjEiIHdpZHRoPSIxMDAlIiBmcmFtZT0iYm9yZGVyIiBydWxlcz0iYWxsIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRoZWFkPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMS10MjkiPlByb3BlcnR5PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMyLXQyOSI+RGVzY3JpcHRpb248L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDI5IiBoZWFkZXJzPSJyMWMxLXQyOSI+U291cmNlIEZvbGRlcjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDI5IHIxYzItdDI5Ij5FbnRlciBhIHByb2plY3QgZm9sZGVyIG5hbWUgaW4gd2hpY2ggdG8gZ2VuZXJhdGUgdGhlIEphdmEgcGVyc2lzdGVudCBlbnRpdGllcywgb3IgY2xpY2sgPHNwYW4gY2xhc3M9ImJvbGQiPkJyb3dzZTwvc3Bhbj4gdG8gc2VsZWN0IGFuIGV4aXN0aW5nIGZvbGRlci48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10MjkiIGhlYWRlcnM9InIxYzEtdDI5Ij5QYWNrYWdlPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MjkgcjFjMi10MjkiPkVudGVyIGEgcGFja2FnZSBuYW1lIGluIHdoaWNoIHRvIGdlbmVyYXRlIHRoZSBKYXZhIHBlcnNpc3RlbnQgZW50aXRpZXMsIG9yIGNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5Ccm93c2U8L3NwYW4+IHRvIHNlbGVjdCBhbiBleGlzdGluZyBwYWNrYWdlLjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNGMxLXQyOSIgaGVhZGVycz0icjFjMS10MjkiPlN5bmNocm9uaXplIENsYXNzZXMgaW4gcGVyc2lzdGVuY2UueG1sPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MjkgcjFjMi10MjkiPlNwZWNpZnkgaWYgRGFsaSBzaG91bGQgdXBkYXRlIHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZSB0byBpbmNsdWRlIHRoZSBnZW5lcmF0ZWQgY2xhc3Nlcy48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjVjMS10MjkiIGhlYWRlcnM9InIxYzEtdDI5Ij5UYWJsZXM8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQyOSByMWMyLXQyOSI+U2VsZWN0IHRoZSB0YWJsZXMgZnJvbSB3aGljaCB0byBjcmVhdGUgSmF2YSBwZXJzaXN0ZW50IGVudGl0aWVzLiBUaGUgdGFibGVzIHNob3duIGFyZSBkZXRlcm1pbmVkIGJ5IHRoZSBkYXRhYmFzZSBjb25uZWN0aW9uIHRoYXQgeW91IGRlZmluZWQgaW4gdGhlIDxhIGhyZWY9InJlZl9wcm9qZWN0X3Byb3BlcnRpZXMuaHRtI0JBQkpIQkNJIj5Qcm9qZWN0IFByb3BlcnRpZXMgcGFnZSAmbmRhc2g7IEpQQSBPcHRpb25zPC9hPi48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0YmxpbmZvcm1hbCIgLS0+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPHA+PGEgaHJlZj0idGFza3MwMjAuaHRtI0JBQkJBR0ZJIj5HZW5lcmF0aW5nIGVudGl0aWVzIGZyb20gdGFibGVzPC9hPjwvcD4KLTxwPiZuYnNwOzwvcD4KLTwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDIiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tfaW5oZXJpdGFuY2UuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tfaW5oZXJpdGFuY2UuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkNGUxMjRiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrX2luaGVyaXRhbmNlLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDEzNCArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0NSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPlNwZWNpZnlpbmcgZW50aXR5IGluaGVyaXRhbmNlPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iU3BlY2lmeWluZyBlbnRpdHkgaW5oZXJpdGFuY2UiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJDSUhDQ0NKRCIgbmFtZT0iQ0lIQ0NDSkQiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MSI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPlNwZWNpZnlpbmcgZW50aXR5IGluaGVyaXRhbmNlPC9oMT4KLTxwPjxhIGlkPSJzdGhyZWY4MCIgbmFtZT0ic3RocmVmODAiPjwvYT48YSBpZD0ic3RocmVmODEiIG5hbWU9InN0aHJlZjgxIj48L2E+QW4gZW50aXR5IG1heSBpbmhlcml0IHByb3BlcnRpZXMgZnJvbSBvdGhlciBlbnRpdGllcy4gWW91IGNhbiBzcGVjaWZ5IGEgc3BlY2lmaWMgc3RyYXRlZ3kgdG8gdXNlIGZvciBpbmhlcml0YW5jZS48L3A+Ci08cD5Vc2UgdGhpcyBwcm9jZWR1cmUgdG8gc3BlY2lmeSBpbmhlcml0YW5jZSAoPGNvZGU+QEluaGVyaXRhbmNlKTwvY29kZT4gZm9yIGFuIGV4aXN0aW5nIGVudGl0eSAoPGNvZGU+QEVudGl0eTwvY29kZT4pOjwvcD4KLTxvbCBzdGFydD0iMSI+Ci08bGk+Ci08cD5TZWxlY3QgdGhlIGVudGl0eSBpbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPlBhY2thZ2UgRXhwbG9yZXI8L3NwYW4+LjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5JbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpQQSBEZXRhaWxzPC9zcGFuPiB2aWV3LCBzZWxlY3QgdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LWFjdGlvbiI+SW5oZXJpdGFuY2U8L3NwYW4+IGluZm9ybWF0aW9uLjwvcD4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9InN0aHJlZjgyIiBuYW1lPSJzdGhyZWY4MiI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPlNwZWNpZnlpbmcgSW5oZXJpdGFuY2U8L3A+Ci08aW1nIHNyYz0iaW1nL2luaGVyaXRhbmNlX3RhYi5wbmciIGFsdD0iU2VsZWN0aW5nIHRoZSBJbmhlcml0YW5jZSBhcmVhIG9uIHRoZSBKUEEgRGV0YWlscyB2aWV3LiIgdGl0bGU9IlNlbGVjdGluZyB0aGUgSW5oZXJpdGFuY2UgYXJlYSBvbiB0aGUgSlBBIERldGFpbHMgdmlldy4iIC8+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJmaWd1cmUiIC0tPjwvbGk+Ci08bGk+Ci08cD5JbiB0aGUgPHNwYW4gY2xhc3M9ImJvbGQiPlN0cmF0ZWd5PC9zcGFuPiBsaXN0LCBzZWxlY3Qgb25lIG9mIHRoZSBmb2xsb3dpbmcgdGhlIGluaGVyaXRhbmNlIHN0cmF0ZWdpZXM6PC9wPgotPHVsPgotPGxpPgotPHA+QSBzaW5nbGUgdGFibGUgKGRlZmF1bHQpPC9wPgotPC9saT4KLTxsaT4KLTxwPkpvaW5lZCB0YWJsZTwvcD4KLTwvbGk+Ci08bGk+Ci08cD5PbmUgdGFibGUgcGVyIGNsYXNzPC9wPgotPC9saT4KLTwvdWw+Ci08L2xpPgotPGxpPgotPHA+VXNlIHRoZSBmb2xsb3dpbmcgdGFibGUgdG8gY29tcGxldGUgdGhlIHJlbWFpbmluZyBmaWVsZHMgb24gdGhlIHRhYi4gU2VlIDxhIGhyZWY9InJlZmVyZW5jZTAxMi5odG0jQ0FDRkhHSEUiPiJJbmhlcml0YW5jZSBpbmZvcm1hdGlvbiI8L2E+IGZvciBhZGRpdGlvbmFsIGRldGFpbHMuPC9wPgotPGRpdiBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIj4KLTx0YWJsZSBjbGFzcz0iUnVsZUluZm9ybWFsIiB0aXRsZT0iVGhpcyB0YWJsZSBkZXNjcmliZXMgdGhlIG9wdGlvbnMgb24gdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldywgSW5oZXJpdGFuY2UgdGFiLiIgc3VtbWFyeT0iVGhpcyB0YWJsZSBkZXNjcmliZXMgdGhlIG9wdGlvbnMgb24gdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldywgSW5oZXJpdGFuY2UgdGFiLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQxNCI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDE0Ij5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10MTQiPkRlZmF1bHQ8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDE0IiBoZWFkZXJzPSJyMWMxLXQxNCI+PGEgaWQ9InN0aHJlZjgzIiBuYW1lPSJzdGhyZWY4MyI+PC9hPjxhIGlkPSJzdGhyZWY4NCIgbmFtZT0ic3RocmVmODQiPjwvYT5EaXNjcmltaW5hdG9yIENvbHVtbjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDE0IHIxYzItdDE0Ij5OYW1lIG9mIHRoZSBkaXNjcmltaW5hdG9yIGNvbHVtbiB3aGVuIHVzaW5nIGEgPHNwYW4gY2xhc3M9ImJvbGQiPlNpbmdsZTwvc3Bhbj4gb3IgPHNwYW4gY2xhc3M9ImJvbGQiPkpvaW5lZDwvc3Bhbj4gaW5oZXJpdGFuY2Ugc3RyYXRlZ3kuCi08cD5UaGlzIGZpZWxkIGNvcnJlc3BvbmRzIHRvIHRoZSA8Y29kZT5ARGlzY3JpbWluYXRvckNvbHVtbjwvY29kZT4gYW5ub3RhdGlvbi48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQxNCByMWMzLXQxNCI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDE0IiBoZWFkZXJzPSJyMWMxLXQxNCI+RGlzY3JpbWluYXRvciBUeXBlPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MTQgcjFjMi10MTQiPlNldCB0aGUgZGlzY3JpbWluYXRvciB0eXBlIHRvIDxjb2RlPkNoYXI8L2NvZGU+IG9yIDxjb2RlPkludGVnZXI8L2NvZGU+IChpbnN0ZWFkIG9mIGl0cyBkZWZhdWx0OiA8Y29kZT5TdHJpbmc8L2NvZGU+KS4gVGhlIDxzcGFuIGNsYXNzPSJib2xkIj5EaXNjcmltaW5hdG9yIFZhbHVlPC9zcGFuPiBtdXN0IGNvbmZvcm0gdG8gdGhpcyB0eXBlLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDE0IHIxYzMtdDE0Ij5TdHJpbmc8L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjRjMS10MTQiIGhlYWRlcnM9InIxYzEtdDE0Ij48YSBpZD0ic3RocmVmODUiIG5hbWU9InN0aHJlZjg1Ij48L2E+PGEgaWQ9InN0aHJlZjg2IiBuYW1lPSJzdGhyZWY4NiI+PC9hPkRpc2NyaW1pbmF0b3IgVmFsdWU8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQxNCByMWMyLXQxNCI+U3BlY2lmeSB0aGUgZGlzY3JpbWluYXRvciB2YWx1ZSB1c2VkIHRvIGRpZmZlcmVudGlhdGUgYW4gZW50aXR5IGluIHRoaXMgaW5oZXJpdGFuY2UgaGllcmFyY2h5LiBUaGUgdmFsdWUgbXVzdCBjb25mb3JtIHRvIHRoZSBzcGVjaWZpZWQgPHNwYW4gY2xhc3M9ImJvbGQiPkRpc2NyaW1pbmF0b3IgVHlwZTwvc3Bhbj4uCi08cD5UaGlzIGZpZWxkIGNvcnJlc3BvbmRzIHRvIHRoZSA8Y29kZT5ARGlzY3JpbWluYXRvclZhbHVlPC9jb2RlPiBhbm5vdGF0aW9uLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDE0IHIxYzMtdDE0Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjVjMS10MTQiIGhlYWRlcnM9InIxYzEtdDE0Ij5PdmVycmlkZSBEZWZhdWx0PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MTQgcjFjMi10MTQiPlVzZSB0aGlzIGZpZWxkIHRvIHNwZWNpZnkgY3VzdG9tIHByaW1hcnkga2V5IGpvaW4gY29sdW1ucy4KLTxwPlRoaXMgZmllbGQgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPkBQcmltYXJ5S2V5Sm9pbkNsdW1uPC9jb2RlPiBhbm5vdGF0aW9uLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDE0IHIxYzMtdDE0Ij48YnIgLz48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0YmxydWxlaW5mb3JtYWwiIC0tPjwvbGk+Ci08L29sPgotPHA+RWNsaXBzZSBhZGRzIHRoZSBmb2xsb3dpbmcgYW5ub3RhdGlvbnMgdGhlIGVudGl0eSBmaWVsZDo8L3A+Ci08cHJlIHhtbDpzcGFjZT0icHJlc2VydmUiIGNsYXNzPSJvYWNfbm9fd2FybiI+Ci1ASW5oZXJpdGFuY2Uoc3RyYXRlZ3k9SW5oZXJpdGFuY2VUeXBlLjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtJTkhFUklUQU5DRV9TVFJBVEVHWSZndDs8L3NwYW4+KQotQERpc2NyaW1pbmF0b3JDb2x1bW4obmFtZT0iPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O0RJU0NSSU1JTkFUT1JfQ09MVU1OJmd0Ozwvc3Bhbj4iLAotICAgIGRpc2NyaW1pbmF0b3JUeXBlPTxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtESVNDUklNSU5BVE9SX1RZUEUmZ3Q7PC9zcGFuPikKLUBEaXNjcmltaW5hdG9yVmFsdWUodmFsdWUtIjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtESVNDUklNSU5BVE9SX1ZBTFVFJmd0Ozwvc3Bhbj4iKQotQFByaW1hcnlLZXlKb2luQ29sdW1uKG5hbWU9IjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtKT0lOX0NPTFVNTl9OQU1FJmd0Ozwvc3Bhbj4iLCAKLSAgICByZWZlcmVuY2VkQ29sdW1uTmFtZSA9ICI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7UkVGRVJFTkNFRF9DT0xVTU5fTkFNRSZndDs8L3NwYW4+IikKLQotPC9wcmU+Ci08cD48YSBpZD0ic3RocmVmODciIG5hbWU9InN0aHJlZjg3Ij48L2E+PGEgaWQ9InN0aHJlZjg4IiBuYW1lPSJzdGhyZWY4OCI+PC9hPjxhIGlkPSJzdGhyZWY4OSIgbmFtZT0ic3RocmVmODkiPjwvYT5UaGUgZm9sbG93aW5nIGZpZ3VyZXMgaWxsdXN0cmF0ZXMgdGhlIGRpZmZlcmVudCBpbmhlcml0YW5jZSBzdHJhdGVnaWVzLjwvcD4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9InN0aHJlZjkwIiBuYW1lPSJzdGhyZWY5MCI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPlNpbmdsZSBUYWJsZSBJbmhlcml0YW5jZTwvcD4KLTxpbWcgc3JjPSJpbWcvaW5oZXJpdGFuY2Vfc2luZ2xlLnBuZyIgYWx0PSJUaGlzIGZpZ3VyZSBpbGx1c3RyYXRlcyBlbnRpdHkgaW5oZXJpdGFuY2UgaW4gYSBzaW5nbGUgdGFibGUuIiB0aXRsZT0iVGhpcyBmaWd1cmUgaWxsdXN0cmF0ZXMgZW50aXR5IGluaGVyaXRhbmNlIGluIGEgc2luZ2xlIHRhYmxlLiIgLz48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImZpZ3VyZSIgLS0+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWY5MSIgbmFtZT0ic3RocmVmOTEiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWluZmlndXJlIj48YSBpZD0ic3RocmVmOTIiIG5hbWU9InN0aHJlZjkyIj48L2E+PGEgaWQ9InN0aHJlZjkzIiBuYW1lPSJzdGhyZWY5MyI+PC9hPkpvaW5lZCBUYWJsZSBJbmhlcml0YW5jZTwvcD4KLTxpbWcgc3JjPSJpbWcvaW5oZXJpdGFuY2Vfam9pbi5wbmciIGFsdD0iVGhpcyBmaWd1cmUgaWxsdXN0cmF0ZXMgYSBqb2luZWQgc3ViY2xhc3MgaW5oZXJpdGFuY2Ugc3RyYXRlZ3kuIiB0aXRsZT0iVGhpcyBmaWd1cmUgaWxsdXN0cmF0ZXMgYSBqb2luZWQgc3ViY2xhc3MgaW5oZXJpdGFuY2Ugc3RyYXRlZ3kuIiAvPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iZmlndXJlIiAtLT4KLTxiciAvPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza19hZGRfcGVyc2lzdGVuY2UuaHRtI0JBQkhJQ0FJIj5BZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBjbGFzczwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxjLnBuZyIgYWx0PSJSZWxhdGVkIGNvbmNlcHQiIHRpdGxlPSJSZWxhdGVkIGNvbmNlcHQiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9ImNvbmNlcHRfcGVyc2lzdGVuY2UuaHRtI0JBQkNBSElDIj5VbmRlcnN0YW5kaW5nIEphdmEgcGVyc2lzdGVuY2U8L2E+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MSIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza19tYW5hZ2Vfb3JtLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrX21hbmFnZV9vcm0uaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3Njc4MGU2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrX21hbmFnZV9vcm0uaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNjIgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDMgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5NYW5hZ2luZyB0aGUgb3JtLnhtbCBmaWxlPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iTWFuYWdpbmcgdGhlIG9ybS54bWwgZmlsZSIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNJSERHRENEIiBuYW1lPSJDSUhER0RDRCI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QxIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+PGEgaWQ9InN0aHJlZjQ2IiBuYW1lPSJzdGhyZWY0NiI+PC9hPk1hbmFnaW5nIHRoZSBvcm0ueG1sIGZpbGU8L2gxPgotPHA+V2hlbiBjcmVhdGluZyBhIEpQQSBwcm9qZWN0LCAoc2VlIDxhIGhyZWY9InRhc2tfY3JlYXRlX25ld19wcm9qZWN0Lmh0bSNDSUhIRUpDSiI+IkNyZWF0aW5nIGEgbmV3IEpQQSBwcm9qZWN0IjwvYT4pIHlvdSBjYW4gYWxzbyBjcmVhdGUgdGhlIDxjb2RlPm9ybS54bWw8L2NvZGU+IGZpbGUgdGhhdCBkZWZpbmVzIHRoZSBtYXBwaW5nIG1ldGFkYXRhIGFuZCBkZWZhdWx0cy48L3A+Ci08cD48YSBpZD0ic3RocmVmNDciIG5hbWU9InN0aHJlZjQ3Ij48L2E+RWNsaXBzZSBjcmVhdGVzIHRoZSA8Y29kZT5NRVRBLUlORlxvcm0ueG1sPC9jb2RlPiBmaWxlIGluIHlvdXIgcHJvamVjdCdzIGRpcmVjdG9yeTo8L3A+Ci08cHJlIHhtbDpzcGFjZT0icHJlc2VydmUiIGNsYXNzPSJvYWNfbm9fd2FybiI+Ci0mbHQ7P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/Jmd0OwotJmx0O3BlcnNpc3RlbmNlIHZlcnNpb249IjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtQRVJTSVNURU5DRV9WRVJTSU9OJmd0Ozwvc3Bhbj4iCi0gICAgICB4bWxucz0iaHR0cDovL2phdmEuc3VuLmNvbS94bWwvbnMvcGVyc2lzdGVuY2UiCi0gICAgICB4bWxuczp4c2k9Imh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hLWluc3RhbmNlIgotICAgICAgeHNpOnNjaGVtYUxvY2F0aW9uPSJodHRwOi8vamF2YS5zdW4uY29tL3htbC9ucy9wZXJzaXN0ZW5jZQotICAgICAgaHR0cDovL2phdmEuc3VuLmNvbS94bWwvbnMvcGVyc2lzdGVuY2UvcGVyc2lzdGVuY2VfMV8wLnhzZCImZ3Q7Ci0gICZsdDtwZXJzaXN0ZW5jZS11bml0IG5hbWU9IjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtQRVJTSVNURU5DRV9VTklUX05BTUUmZ3Q7PC9zcGFuPiImZ3Q7Ci0gICAgJmx0O3Byb3ZpZGVyPSI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7UEVSU0lTVEVOQ0VfUFJPVklERVImZ3Q7PC9zcGFuPiIgLyZndDsKLSAgJmx0Oy9wZXJzaXN0ZW5jZS11bml0Jmd0OwotJmx0Oy9wZXJzaXN0ZW5jZSZndDsKLTwvcHJlPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHIucG5nIiBhbHQ9IlJlbGF0ZWQgcmVmZXJlbmNlIiB0aXRsZT0iUmVsYXRlZCByZWZlcmVuY2UiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InJlZl9uZXdfanBhX3Byb2plY3Rfd2l6YXJkLmh0bSNDQUNCSkdCRyI+Q3JlYXRlIE5ldyBKUEEgUHJvamVjdCB3aXphcmQ8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrczAwNS5odG0jQ0lIQkNEQ0UiPldvcmtpbmcgd2l0aCBvcm0ueG1sIGZpbGU8L2E+PGJyIC8+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsYy5wbmciIGFsdD0iUmVsYXRlZCBjb25jZXB0IiB0aXRsZT0iUmVsYXRlZCBjb25jZXB0IiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJjb25jZXB0czAwMy5odG0jQ0hEQklKQUMiPlRoZSBvcm0ueG1sIGZpbGU8L2E+PGJyIC8+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+PC9kaXY+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza19tYW5hZ2VfcGVyc2lzdGVuY2UuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tfbWFuYWdlX3BlcnNpc3RlbmNlLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOGJlOTBhMi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza19tYW5hZ2VfcGVyc2lzdGVuY2UuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsMjEyICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQzIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+TWFuYWdpbmcgdGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iTWFuYWdpbmcgdGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0lIREFKSUQiIG5hbWU9IkNJSERBSklEIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDEiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT48YSBpZD0ic3RocmVmMzUiIG5hbWU9InN0aHJlZjM1Ij48L2E+TWFuYWdpbmcgdGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlPC9oMT4KLTxwPjxhIGlkPSJzdGhyZWYzNiIgbmFtZT0ic3RocmVmMzYiPjwvYT5XaGVuIHlvdSBjcmVhdGUgYSBwcm9qZWN0LCBFY2xpcHNlIGNyZWF0ZXMgdGhlIDxjb2RlPk1FVEEtSU5GXHBlcnNpc3RlbmNlLnhtbDwvY29kZT4gZmlsZSBpbiB0aGUgcHJvamVjdCdzIGRpcmVjdG9yeS48L3A+Ci08cD5Zb3UgY2FuIGNyZWF0ZSBhIHN0dWIgPGNvZGU+cGVyc2lzdGVuY2UueG1sPC9jb2RlPiBmaWxlIGluIHRoZSBNRVRBLUlORiBkaXJlY3Rvcnkgd2hlbiB5b3UgY3JlYXRlIGEgSlBBIHByb2plY3QgKHNlZSA8YSBocmVmPSJ0YXNrX2NyZWF0ZV9uZXdfcHJvamVjdC5odG0jQ0lISEVKQ0oiPiJDcmVhdGluZyBhIG5ldyBKUEEgcHJvamVjdCI8L2E+KS4gWW91IGNhbiBtYW5hZ2UgdGhpcyBmaWxlIGVpdGhlciB0aHJvdWdoIHRoZSBYTUwgZWRpdG9yIChzZWUgPGEgaHJlZj0idGFza3MwMDIuaHRtI0NJSEVKQUlFIj4iVXNpbmcgdGhlIFhNTCBFZGl0b3IgdG8gZWRpdCB0aGUgcGVyc2lzdGVuY2UueG1sIGZpbGUiPC9hPikgb3IgdGhyb3VnaCB0aGUgPGEgaHJlZj0icmVmZXJlbmNlMDE4Lmh0bSNDSUFDQ0hJRCI+cGVyc2lzdGVuY2UueG1sIEVkaXRvcjwvYT4uPC9wPgotPGRpdiBhbGlnbj0iY2VudGVyIj4KLTxkaXYgY2xhc3M9ImluZnRibG5vdGUiPjxiciAvPgotPHRhYmxlIGNsYXNzPSJOb3RlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGJvZHk+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiPgotPHAgY2xhc3M9Im5vdGVwMSI+Tm90ZTo8L3A+Ci1JbiBhZGRpdG9uIHRvIHRoZSBHZW5lcmFsLCBDb25uZWN0aW9uLCBQcm9wZXJ0aWVzIGFuZCBTb3VyY2UgcGFnZXMsIHRoZSBwZXJzaXN0ZW5jZS54bWwgRWRpdG9yIHBhZ2VzIGZvciBwcm9qZWN0cyB0aGF0IHVzZSB0aGUgRWNsaXBzZUxpbmsgcGxhdGZvcm0gaW5jbHVkZSB0aGUgZm9sbG93aW5nOgotPHVsPgotPGxpPgotPHA+PGEgaHJlZj0icmVmZXJlbmNlMDIxLmh0bSNDSUFKQUZFRyI+Q3VzdG9taXphdGlvbjwvYT48L3A+Ci08cD5Vc2UgdGhpcyBwYWdlIHRvIGRlZmluZSBjaGFuZ2UtdHJhY2tpbmcgYW5kIHNlc3Npb24gY3VzdG9taXplci1yZWxhdGVkIHByb3BlcnRpZXMuPC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InJlZmVyZW5jZTAyMi5odG0jQ0lBQkVEQ0giPkNhY2hpbmc8L2E+PC9wPgotPHA+VXNlIHRoaXMgcGFnZSB0byBkZWZpbmUgY2FjaGluZyBwcm9wZXJ0aWVzLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJyZWZlcmVuY2UwMjMuaHRtI0NJQUJHSEhJIj5Mb2dnaW5nPC9hPjwvcD4KLTxwPlVzZSB0aGlzIHBhZ2UgdG8gZGVmaW5lIGxvZ2dpbmcgcHJvcGVydGllcy48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0icmVmZXJlbmNlMDI0Lmh0bSNDSUFGSkNIRSI+T3B0aW9uczwvYT48L3A+Ci08cD5Vc2UgdGhpcyBwYWdlIHRvIGRlZmluZSBzZXNzaW9uIGFuZCB0YXJnZXQgZGF0YWJhc2UgcHJvcGVydGllcy48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0icmVmZXJlbmNlMDI1Lmh0bSNDSUFDQ0ZDQiI+U2NoZW1hIEdlbmVyYXRpb248L2E+PC9wPgotPHA+VXNlIHRoaXMgcGFnZSB0byBkZWZpbmUgRERMLXJlbGF0ZWQgcHJvcGVydGllcy48L3A+Ci08L2xpPgotPC91bD4KLTxwPkZvciBwcm9qZWN0cyB1c2luZyB0aGUgRWNsaXBzZUxpbmsgcGxhdGZvcm0sIHRoZSBDb25uZWN0aW9ucyBwYWdlIGFsc28gaW5jbHVkZXMgSkRCQyBjb25uZWN0aW9uIHBvb2wgcHJvcGVydGllcy48L3A+Ci08cD5JZiB0aGUgcHJvamVjdCB1c2VzIHRoZSBHZW5lcmljIHBsYXRmb3JtLCB0aGVuIG9ubHkgdGhlIEdlbmVyYWwsIENvbm5lY3Rpb24sIFByb3BlcnRpZXMgYW5kIFNvdXJjZSBwYWdlcyBhcmUgYXZhaWxhYmxlLjwvcD4KLTwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibG5vdGUiIC0tPjwvZGl2PgotPHA+VG8gdXNlIHRoZSA8Y29kZT5wZXJzaXN0ZW5jZS54bWw8L2NvZGU+IEVkaXRvcjo8L3A+Ci08b2wgc3RhcnQ9IjEiPgotPGxpPgotPHA+T3BlbiB0aGUgPGNvZGU+cGVyaXN0ZW5jZS54bWw8L2NvZGU+IGZpbGUuIFRoZSA8YSBocmVmPSJyZWZlcmVuY2UwMTkuaHRtI0NJQUNJRkdKIj5HZW5lcmFsPC9hPiBwYWdlIG9mIHRoZSBlZGl0b3IgYXBwZWFycy48L3A+Ci08L2xpPgotPGxpPgotPHA+VXNlIHRoZSBHZW5lcmFsIHBhZ2UgdG8gZGVmaW5lIHRoZSA8Y29kZT5wZXJzaXN0ZW5jZS54bWw8L2NvZGU+IGZpbGVzIDxjb2RlPiZsdDtwZXJzaXN0ZW50LXVuaXQmZ3Q7PC9jb2RlPi1yZWxhdGVkIGF0dHJpYnV0ZXMgYXMgd2VsbCBhcyB0aGUgPGNvZGU+Jmx0O3Byb3ZpZGVyJmd0OzwvY29kZT4sIGFuZCA8Y29kZT4mbHQ7Y2xhc3MmZ3Q7PC9jb2RlPiBlbGVtZW50cyAoZGVzY3JpYmVkIGluIHRoZSBmb2xsb3dpbmcgdGFibGUpLjwvcD4KLTxkaXYgYWxpZ249ImNlbnRlciI+Ci08ZGl2IGNsYXNzPSJpbmZ0Ymxub3RlYWxzbyI+PGJyIC8+Ci08dGFibGUgY2xhc3M9Ik5vdGVBbHNvIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGJvZHk+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiPgotPHAgY2xhc3M9Im5vdGVwMSI+VGlwOjwvcD4KLVRoZSBwZXJzaXN0ZW5jZS54bWwgRWRpdG9yJ3MgU291cmNlIHBhZ2UgZW5hYmxlcyB5b3UgdG8gdmlldyBhbmQgZWRpdCB0aGUgcmF3IFhNTCBmaWxlLjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibG5vdGVhbHNvIiAtLT48L2Rpdj4KLTxkaXYgY2xhc3M9ImluZnRibGluZm9ybWFsIj4KLTx0YWJsZSBjbGFzcz0iSW5mb3JtYWwiIHN1bW1hcnk9IlRoaXMgdGFibGUgbGlzdHMgdGhlIHByb3BlcnRpZXMgb2YgdGhlIHBlcnNpc3RlbmNlLnhtbCBlZGl0b3IuIiBkaXI9Imx0ciIgYm9yZGVyPSIxIiB3aWR0aD0iMTAwJSIgZnJhbWU9ImhzaWRlcyIgcnVsZXM9Imdyb3VwcyIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0aGVhZD4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzEtdDgiPlByb3BlcnR5PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMyLXQ4Ij5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10OCI+RWxlbWVudCBEZWZpbmVkPC90aD4KLTwvdHI+Ci08L3RoZWFkPgotPHRib2R5PgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMmMxLXQ4IiBoZWFkZXJzPSJyMWMxLXQ4Ij5OYW1lPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10OCByMWMyLXQ4Ij5FbnRlciB0aGUgbmFtZSBvZiB0aGUgcGVyc2lzdGVuY2UgdW5pdC48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQ4IHIxYzMtdDgiPjxjb2RlPiZsdDtwZXJzaXN0ZW5jZS11bml0IG5hbWUgPSAiJmx0O05hbWUmZ3Q7IiZndDs8L2NvZGU+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDgiIGhlYWRlcnM9InIxYzEtdDgiPlBlcnNpc3RlbmNlIFByb3ZpZGVyPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10OCByMWMyLXQ4Ij5FbnRlciB0aGUgbmFtZSBvZiB0aGUgcGVyc2lzdGVuY2UgcHJvdmlkZXIuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10OCByMWMzLXQ4Ij48Y29kZT4mbHQ7cHJvdmlkZXImZ3Q7PC9jb2RlPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNGMxLXQ4IiBoZWFkZXJzPSJyMWMxLXQ4Ij5EZXNjcmlwdGlvbjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDggcjFjMi10OCI+RW50ZXIgYSBkZXNjcmlwdGlvbiBmb3IgdGhpcyBwZXJzaXN0ZW5jZSB1bml0LiBUaGlzIGlzIGFuIG9wdGlvbmFsIHByb3BlcnR5LjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDggcjFjMy10OCI+PGNvZGU+Jmx0O2Rlc2NyaXB0aW9uJmd0OzwvY29kZT48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjVjMS10OCIgaGVhZGVycz0icjFjMS10OCI+TWFuYWdlZCBDbGFzc2VzPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10OCByMWMyLXQ4Ij5BZGQgb3IgcmVtb3ZlIHRoZSBjbGFzc2VzIG1hbmFnZWQgdGhyb3VnaCB0aGUgcGVyc2lzdGVuY2UgdW5pdC48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQ4IHIxYzMtdDgiPjxjb2RlPiZsdDtjbGFzcyZndDs8L2NvZGU+PC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI2YzEtdDgiIGhlYWRlcnM9InIxYzEtdDgiPiZuYnNwOyZuYnNwO0V4Y2x1ZGUgVW5saXN0ZWQgQ2xhc3NlczwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI2YzEtdDggcjFjMi10OCI+U2VsZWN0IHRvIGluY2x1ZGUgYWxsIGFubm90YXRlZCBlbnRpdHkgY2xhc3NlcyBpbiB0aGUgcm9vdCBvZiB0aGUgcGVyc2lzdGVuY2UgdW5pdC48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQ4IHIxYzMtdDgiPjxjb2RlPiZsdDtleGNsdWRlLXVubGlzdGVkLWNsYXNzZXMmZ3Q7PC9jb2RlPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyN2MxLXQ4IiBoZWFkZXJzPSJyMWMxLXQ4Ij5YTUwgTWFwcGluZyBGaWxlczwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI3YzEtdDggcjFjMi10OCI+QWRkIG9yIHJlbW92ZSB0aGUgb2JqZWN0L3JlbGF0aW9uYWwgbWFwcGluZyBYTUwgZmlsZXMgZGVmaW5lIHRoZSBjbGFzc2VzIG1hbmFnZWQgdGhyb3VnaCB0aGUgcGVyc2lzdGVuY2UgdW5pdC48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyN2MxLXQ4IHIxYzMtdDgiPjxjb2RlPiZsdDttYXBwaW5nLWZpbGUmZ3Q7PC9jb2RlPjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibGluZm9ybWFsIiAtLT48L2xpPgotPGxpPgotPHA+VXNlIHRoZSA8YSBocmVmPSJyZWZlcmVuY2UwMjAuaHRtI0NJQUZGSklFIj5Db25uZWN0aW9uPC9hPiBwYWdlIHRvIGRlZmluZSB0aGUgPGNvZGU+Jmx0O2p0YS1kYXRhLXNvdXJjZSZndDs8L2NvZGU+IGFuZCA8Y29kZT4mbHQ7bm9uLWp0YS1kYXRhLXNvdXJjZSZndDs8L2NvZGU+IGVsZW1lbnRzIGFzIGZvbGxvd3M6PC9wPgotPHA+VG8gY29uZmlndXJlIHRoZSBKVEEgKEphdmEgVHJhbnNhY3Rpb24gQVBJKSBzb3VyY2UgdXNlZCBieSB0aGUgcGVyc2lzdGVuY2UgcHJvdmlkZXI6PC9wPgotPG9sIHN0YXJ0PSIxIj4KLTxsaT4KLTxwPlNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+SlRBPC9zcGFuPiBmcm9tIHRoZSBUcmFuc2FjdGlvbiBUeXBlIGxpc3QuPC9wPgotPC9saT4KLTxsaT4KLTxwPkVudGVyIHRoZSBnbG9iYWwgSk5ESSBuYW1lIG9mIHRoZSBkYXRhIHNvdXJjZS48L3A+Ci08L2xpPgotPC9vbD4KLTxwPlRvIGNvbmZpZ3VyZSBhIG5vbi1KVEEgZGF0YSBzb3VyY2U6PC9wPgotPG9sIHN0YXJ0PSIxIj4KLTxsaT4KLTxwPlNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+UmVzb3VyY2UgTG9jYWw8L3NwYW4+IGZyb20gdGhlIFRyYW5zYWN0aW9uIFR5cGUgbGlzdC48L3A+Ci08L2xpPgotPGxpPgotPHA+RW50ZXIgdGhlIGdsb2JhbCBKTkRJIG5hbWUgb2YgdGhlIGRhdGEgc291cmNlLjwvcD4KLTxkaXYgYWxpZ249ImNlbnRlciI+Ci08ZGl2IGNsYXNzPSJpbmZ0Ymxub3RlIj48YnIgLz4KLTx0YWJsZSBjbGFzcz0iTm90ZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRib2R5PgotPHRyPgotPHRkIGFsaWduPSJsZWZ0Ij4KLTxwIGNsYXNzPSJub3RlcDEiPk5vdGU6PC9wPgotU2VsZWN0IDxzcGFuIGNsYXNzPSJib2xkIj5EZWZhdWx0KCk8L3NwYW4+IHRvIHVzZSB0aGUgZGF0YSBzb3VyY2UgcHJvdmlkZWQgYnkgdGhlIGNvbnRhaW5lci48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0Ymxub3RlIiAtLT48L2Rpdj4KLTwvbGk+Ci08L29sPgotPC9saT4KLTxsaT4KLTxwPlVzZSB0aGUgdGFibGUgaW4gdGhlIFByb3BlcnRpZXMgcGFnZSB0byBzZXQgdGhlIHZlbmRvci1zcGVjaWZpYyA8Y29kZT4mbHQ7cHJvcGVydGllcyZndDs8L2NvZGU+IGVsZW1lbnQuPC9wPgotPHA+VG8gYWRkIDxjb2RlPiZsdDtwcm9wZXJ0eSZndDs8L2NvZGU+IGVsZW1lbnRzOjwvcD4KLTxvbCBzdGFydD0iMSI+Ci08bGk+Ci08cD5DbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+QWRkPC9zcGFuPi48L3A+Ci08L2xpPgotPGxpPgotPHA+RW50ZXIgdGhlIDxjb2RlPiZsdDtuYW1lJmd0OzwvY29kZT4gYW5kIDxjb2RlPiZsdDt2YWx1ZSZndDs8L2NvZGU+IGF0dHJpYnV0ZXMgZm9yIHRoZSA8Y29kZT4mbHQ7cHJvcGVydHkmZ3Q7PC9jb2RlPiBlbGVtZW50IHVzaW5nIHRoZSB0YWJsZSdzIE5hbWUgYW5kIFZhbHVlIGZpZWxkcy48L3A+Ci08L2xpPgotPC9vbD4KLTxwPlRvIHJlbW92ZSBhIDxjb2RlPiZsdDtwcm9wZXJ0eSZndDs8L2NvZGU+IGVsZW1lbnQsIHNlbGVjdCBhIGRlZmluZWQgcHJvcGVydHkgaW4gdGhlIHRhYmxlIGFuZCB0aGVuIGNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5SZW1vdmU8L3NwYW4+LjwvcD4KLTxkaXYgYWxpZ249ImNlbnRlciI+Ci08ZGl2IGNsYXNzPSJpbmZ0Ymxub3RlIj48YnIgLz4KLTx0YWJsZSBjbGFzcz0iTm90ZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRib2R5PgotPHRyPgotPHRkIGFsaWduPSJsZWZ0Ij4KLTxwIGNsYXNzPSJub3RlcDEiPk5vdGU6PC9wPgotSWYgdGhlIHByb2plY3QgdXNlcyB0aGUgRWNsaXBzZUxpbmsgcGxhdGZvcm0sIHRoZSBjb25uZWN0aW9uIHBhZ2UgYWxzbyBpbmNsdWRlcyBwYXJhbWV0ZXJzIGZvciBKREJDIGNvbm5lY3Rpb24gcG9vbGluZy48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0Ymxub3RlIiAtLT48L2Rpdj4KLTwvbGk+Ci08L29sPgotPGltZyBzcmM9ImltZy9uZ3JlbHIucG5nIiBhbHQ9IlJlbGF0ZWQgcmVmZXJlbmNlIiB0aXRsZT0iUmVsYXRlZCByZWZlcmVuY2UiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InJlZmVyZW5jZTAxOC5odG0jQ0lBQ0NISUQiPnBlcnNpc3RlbmNlLnhtbCBFZGl0b3I8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrczAwMi5odG0jQ0lIRUpBSUUiPlVzaW5nIHRoZSBYTUwgRWRpdG9yIHRvIGVkaXQgdGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlPC9hPjxiciAvPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0iY29uY2VwdHMwMDIuaHRtI0NIREhBR0lIIj5UaGUgcGVyc2lzdGVuY2UueG1sIGZpbGU8L2E+PGJyIC8+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+PC9kaXY+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza19tYXBwaW5nLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrX21hcHBpbmcuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4ZGM3ODVkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrX21hcHBpbmcuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNzIgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDUgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5NYXBwaW5nIGFuIGVudGl0eTwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9Ik1hcHBpbmcgYW4gZW50aXR5IiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkFCREdCSUoiIG5hbWU9IkJBQkRHQklKIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDEiPgotPGgxPk1hcHBpbmcgYW4gZW50aXR5PC9oMT4KLTxwPkRhbGkgc3VwcG9ydHMgdGhlIGZvbGxvd2luZyBtYXBwaW5nIHR5cGVzIGZvciBKYXZhIHBlcnNpc3RlbnQgZW50aXRpZXM6PC9wPgotPHVsPgotPGxpPgotPHA+PGEgaHJlZj0idGFza3MwMTAuaHRtI0JBQkJBQkNFIj5CYXNpYyBtYXBwaW5nPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJ0YXNrczAxMS5odG0jQkFCQ0JIREYiPkVtYmVkZGVkIG1hcHBpbmc8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InRhc2tzMDEyLmh0bSNDSUhESUFFRSI+RW1iZWRkZWQgSUQgbWFwcGluZzwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0idGFza3MwMTMuaHRtI0JBQkdDQkhHIj5JRCBtYXBwaW5nPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJ0YXNrczAxNC5odG0jQkFCRUlFR0QiPk1hbnktdG8tbWFueSBtYXBwaW5nPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJ0YXNrczAxNS5odG0jQkFCSEZBRkoiPk1hbnktdG8tb25lIG1hcHBpbmc8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InRhc2tzMDE2Lmh0bSNCQUJIR0VCRCI+T25lLXRvLW1hbnkgbWFwcGluZzwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0idGFza3MwMTcuaHRtI0JBQkZIQkNKIj5PbmUtdG8tb25lIG1hcHBpbmc8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InRhc2tzMDE4Lmh0bSNCQUJIRkhFSSI+VHJhbnNpZW50IG1hcHBpbmc8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InRhc2tzMDE5Lmh0bSNCQUJISUJJSSI+VmVyc2lvbiBtYXBwaW5nPC9hPjwvcD4KLTwvbGk+Ci08L3VsPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0iY29uY2VwdF9tYXBwaW5nLmh0bSNCQUJCREpGSSI+VW5kZXJzdGFuZGluZyBPUiBtYXBwaW5nczwvYT4gPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPjwvZGl2PgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrcy5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDMxZDRkZDIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDcxICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQyIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+VGFza3M8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSIgVGFza3MiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJzdGhyZWYyNCIgbmFtZT0ic3RocmVmMjQiPjwvYT48L3A+Ci08aDE+VGFza3M8L2gxPgotPHA+VGhpcyBzZWN0aW9uIGluY2x1ZGVzIGRldGFpbGVkIHN0ZXAtYnktc3RlcCBwcm9jZWR1cmVzIGZvciBhY2Nlc3NpbmcgdGhlIERhbGkgT1IgbWFwcGluZyB0b29sIGZ1bmN0aW9uYWxpdHkuPC9wPgotPHVsPgotPGxpPgotPHA+PGEgaHJlZj0idGFza19jcmVhdGVfbmV3X3Byb2plY3QuaHRtI0NJSEhFSkNKIj5DcmVhdGluZyBhIG5ldyBKUEEgcHJvamVjdDwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0idGFza3MwMDEuaHRtI0JBQkZCSkJHIj5DcmVhdGluZyBhIEpQQSBFbnRpdHk8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InRhc2tfbWFuYWdlX3BlcnNpc3RlbmNlLmh0bSNDSUhEQUpJRCI+TWFuYWdpbmcgdGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJ0YXNrX21hbmFnZV9vcm0uaHRtI0NJSERHRENEIj5NYW5hZ2luZyB0aGUgb3JtLnhtbCBmaWxlPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0jQkFCSElDQUkiPkFkZGluZyBwZXJzaXN0ZW5jZSB0byBhIGNsYXNzPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJ0YXNrX2FkZGl0b25hbF90YWJsZXMuaHRtI0NJSEdCSUVJIj5TcGVjaWZ5aW5nIGFkZGl0aW9uYWwgdGFibGVzPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJ0YXNrX2luaGVyaXRhbmNlLmh0bSNDSUhDQ0NKRCI+U3BlY2lmeWluZyBlbnRpdHkgaW5oZXJpdGFuY2U8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InRhc2tfbWFwcGluZy5odG0jQkFCREdCSUoiPk1hcHBpbmcgYW4gZW50aXR5PC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJ0YXNrczAyMC5odG0jQkFCQkFHRkkiPkdlbmVyYXRpbmcgZW50aXRpZXMgZnJvbSB0YWJsZXM8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9InRhc2tzMDIyLmh0bSNCQUJGQUlCQSI+VmFsaWRhdGluZyBtYXBwaW5ncyBhbmQgcmVwb3J0aW5nIHByb2JsZW1zPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJ0YXNrczAyNS5odG0jQkFCREJDQkkiPk1vZGlmeWluZyBwZXJzaXN0ZW50IHByb2plY3QgcHJvcGVydGllczwvYT48L3A+Ci08L2xpPgotPC91bD4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAwMS5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMDEuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1MzBiZjkxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAwMS5odG0KKysrIC9kZXYvbnVsbApAQCAtMSwxNTYgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDIgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5DcmVhdGluZyBhIEpQQSBFbnRpdHk8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJDcmVhdGluZyBhIEpQQSBFbnRpdHkiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJCQUJGQkpCRyIgbmFtZT0iQkFCRkJKQkciPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MSI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPjxhIGlkPSJzdGhyZWYzMCIgbmFtZT0ic3RocmVmMzAiPjwvYT5DcmVhdGluZyBhIEpQQSBFbnRpdHk8L2gxPgotPHA+VXNlIHRoaXMgcHJvY2VkdXJlIHRvIGNyZWF0ZSBhIEpQQSBlbnRpdHk6PC9wPgotPG9sIHN0YXJ0PSIxIj4KLTxsaT4KLTxwPkZyb20gdGhlIE5hdmlnYXRvciBvciBQYWNrYWdlIEV4cGxvcmVyLCBzZWxlY3QgdGhlIEpQQSBwcm9qZWN0IGFuZCB0aGVuIDxzcGFuIGNsYXNzPSJib2xkIj5GaWxlICZndDsgTmV3ICZndDsgT3RoZXI8L3NwYW4+LiBUaGUgU2VsZWN0IGEgV2l6YXJkIGRpYWxvZyBhcHBlYXJzLjwvcD4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9InN0aHJlZjMxIiBuYW1lPSJzdGhyZWYzMSI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPlNlbGVjdGluZyB0aGUgQ3JlYXRlIGEgSlBBIEVudGl0eSBXaXphcmQ8L3A+Ci08aW1nIHNyYz0iaW1nL3NlbGVjdF9hX3dpemFyZF9lbnRpdHkucG5nIiBhbHQ9IlRoZSBTZWxlY3QgYSBXaXphcmQgZGlhbG9nIHdpdGggRW50aXR5IHNlbGVjdGVkLiIgdGl0bGU9IlRoZSBTZWxlY3QgYSBXaXphcmQgZGlhbG9nIHdpdGggRW50aXR5IHNlbGVjdGVkLiIgLz48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImZpZ3VyZSIgLS0+PC9saT4KLTxsaT4KLTxwPlNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+RW50aXR5PC9zcGFuPiBhbmQgdGhlbiBjbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+TmV4dDwvc3Bhbj4uIFRoZSA8YSBocmVmPSJyZWZlcmVuY2UwMDMuaHRtI0NJQUZFSUdGIj5FbnRpdHkgQ2xhc3MgcGFnZTwvYT4gYXBwZWFycy48L3A+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWYzMiIgbmFtZT0ic3RocmVmMzIiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWluZmlndXJlIj5UaGUgRW50aXR5IENsYXNzIFBhZ2U8L3A+Ci08aW1nIHNyYz0iaW1nL2NyZWF0ZV9qcGFfZW50aXR5X3dpemFyZC5wbmciIGFsdD0iVGhlIEVudGl0eSBDbGFzcyBwYWdlIG9mIHRoZSBDcmVhdGUgYSBKUEEgRW50aXR5IHdpemFyZC4iIHRpdGxlPSJUaGUgRW50aXR5IENsYXNzIHBhZ2Ugb2YgdGhlIENyZWF0ZSBhIEpQQSBFbnRpdHkgd2l6YXJkLiIgLz48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImZpZ3VyZSIgLS0+Ci08cD5Db21wbGV0ZSB0aGlzIHBhZ2UgYXMgZm9sbG93czo8L3A+Ci08dWw+Ci08bGk+Ci08cD5TZWxlY3QgdGhlIEpQQSBwcm9qZWN0IGluIHRoZSBQcm9qZWN0IGZpZWxkLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5JbiB0aGUgU291cmNlIEZvbGRlciBmaWVsZCwgc2VsZWN0LCBvciBlbnRlciwgdGhlIGxvY2F0aW9uIG9mIHRoZSBKUEEgcHJvamVjdCdzIHNyYyBmb2xkZXIuPC9wPgotPC9saT4KLTxsaT4KLTxwPlNlbGVjdCwgb3IgZW50ZXIsIHRoZSBuYW1lIG9mIHRoZSBjbGFzcyBwYWNrYWdlIGZvciB0aGlzIGVudGl0eSBpbiB0aGUgSmF2YSBQYWNrYWdlIGZpZWxkLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5FbnRlciB0aGUgbmFtZSBvZiB0aGUgSmF2YSBjbGFzcyBpbiB0aGUgQ2xhc3MgbmFtZSBmaWVsZC48L3A+Ci08L2xpPgotPGxpPgotPHA+SWYgbmVlZGVkLCBlbnRlciwgb3Igc2VsZWN0IGEgc3VwZXJjbGFzcy48L3A+Ci08L2xpPgotPGxpPgotPHA+SWYgbmVlZGVkLCBjb21wbGV0ZSB0aGUgSW5oZXJpdGFuY2Ugc2VjdGlvbiBhcyBmb2xsb3dzICh0aGVzZSBwcm9wZXJ0aWVzIGFyZSBvcHRpb25hbCk6PC9wPgotPHVsPgotPGxpPgotPHA+QWNjZXB0IHRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+RW50aXR5PC9zcGFuPiBvcHRpb24gKHRoZSBkZWZhdWx0KSB0byBjcmVhdGUgYSBKYXZhIGNsYXNzIHdpdGggdGhlIDxjb2RlPkBFbnRpdHk8L2NvZGU+IG9wdGlvbi48L3A+Ci08L2xpPgotPGxpPgotPHA+QWx0ZXJuYXRpdmVseSwgc2VsZWN0IDxhIGhyZWY9InRhc2tzMDA4Lmh0bSNCQUJEQUdDSSI+TWFwcGVkIHN1cGVyY2xhc3M8L2E+IChpZiB5b3UgZGVmaW5lZCBhIHN1cGVyIGNsYXNzKS48L3A+Ci08L2xpPgotPGxpPgotPHA+U2VsZWN0IDxzcGFuIGNsYXNzPSJib2xkIj5Jbmhlcml0YW5jZTwvc3Bhbj4gYW5kIHRoZW4gc2VsZWN0IG9uZSBvZiB0aGUgSlNSIDIyMCBpbmhlcml0YW5jZSBtYXBwaW5nIHN0cmF0ZWdpZXMgKFNJTkdMRV9UQUJMRSwgVEFCTEVfUEVSX0NMQVNTLCBKT0lORUQpLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5TZWxlY3QgPHNwYW4gY2xhc3M9ImJvbGQiPkFkZDwvc3Bhbj4gdG8gZW50aXR5IG1hcHBpbmdzIGluIFhNTCB0byBjcmVhdGUgWE1MIG1hcHBpbmdzIGluIDxjb2RlPm9ybS54bWw8L2NvZGU+LCByYXRoZXIgdGhhbiBhbm5vdGF0aW9ucy48L3A+Ci08L2xpPgotPC91bD4KLTwvbGk+Ci08L3VsPgotPC9saT4KLTxsaT4KLTxwPkNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5OZXh0PC9zcGFuPiB0byBwcm9jZWVkIHRvIHRoZSA8YSBocmVmPSJyZWZlcmVuY2UwMDQuaHRtI0NJQURFQ0lBIj5FbnRpdHkgUHJvcGVydGllcyBwYWdlPC9hPiB3aGVyZSB5b3UgZGVmaW5lIHRoZSBwZXJzaXN0ZW50IGZpZWxkcyBmb3IgdGhlIGVudGl0eS48L3A+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWYzMyIgbmFtZT0ic3RocmVmMzMiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWluZmlndXJlIj5UaGUgRW50aXR5IFByb3BlcnRpZXMgUGFnZTwvcD4KLTxpbWcgc3JjPSJpbWcvY3JlYXRlX2pwYV9maWVsZHMucG5nIiBhbHQ9IlRoZSBFbnRpdHkgUHJvcGVydGllcyBwYWdlIG9mIHRoZSBDcmVhdGUgSlBBIEVudGl0eSB3aXphcmQuIiB0aXRsZT0iVGhlIEVudGl0eSBQcm9wZXJ0aWVzIHBhZ2Ugb2YgdGhlIENyZWF0ZSBKUEEgRW50aXR5IHdpemFyZC4iIC8+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJmaWd1cmUiIC0tPgotPHA+QWx0ZXJuYXRpdmVseSwgY2xpY2sgPHNwYW4gY2xhc3M9ImJvbGQiPkZpbmlzaDwvc3Bhbj4gdG8gY29tcGxldGUgdGhlIGVudGl0eS48L3A+Ci08L2xpPgotPGxpPgotPHA+Q29tcGxldGUgdGhlIHBhZ2UgYXMgZm9sbG93czo8L3A+Ci08b2wgc3RhcnQ9IjEiPgotPGxpPgotPHA+SWYgbmVlZGVkLCBlbnRlciBhIG5ldyBuYW1lIGZvciB0aGUgZW50aXR5LiBEb2luZyBzbyByZXN1bHRzIGluIGFkZGluZyBhIDxjb2RlPm5hbWU8L2NvZGU+IGF0dHJpYnV0ZSB0byB0aGUgPGNvZGU+QEVudGl0eTwvY29kZT4gbm90YXRpb24gKDxjb2RlPkBFbnRpdHkobmFtZT0iRW50aXR5TmFtZSIpPC9jb2RlPikuPC9wPgotPC9saT4KLTxsaT4KLTxwPkFjY2VwdCA8c3BhbiBjbGFzcz0iYm9sZCI+VXNlIGRlZmF1bHQ8L3NwYW4+ICh0aGUgZGVmYXVsdCBzZXR0aW5nKSB0byB1c2UgdGhlIGRlZmF1bHQgdmFsdWUgZm9yIHRoZSBuYW1lIG9mIHRoZSBtYXBwZWQgdGFibGUuIEVudGVyaW5nIGEgZGlmZmVyZW50IG5hbWUgcmVzdWx0cyBpbiBhZGRpbmcgdGhlIDxjb2RlPkBUYWJsZTwvY29kZT4gbm90YXRpb24gd2l0aCBpdHMgPGNvZGU+bmFtZTwvY29kZT4gYXR0cmlidXRlIGRlZmluZWQgYXMgdGhlIG5ldyB0YWJsZSAoPGNvZGU+QFRhYmxlKG5hbWU9IlRhYmxlTmFtZSIpPC9jb2RlPikuPC9wPgotPGRpdiBhbGlnbj0iY2VudGVyIj4KLTxkaXYgY2xhc3M9ImluZnRibG5vdGUiPjxiciAvPgotPHRhYmxlIGNsYXNzPSJOb3RlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGJvZHk+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiPgotPHAgY2xhc3M9Im5vdGVwMSI+Tm90ZTo8L3A+Ci1UaGUgRW50aXR5IE5hbWUtcmVsYXRlZCBvcHRpb25zIGFyZSBub3QgYXZhaWxhYmxlIGlmIHlvdSBzZWxlY3RlZCA8YSBocmVmPSJ0YXNrczAwOC5odG0jQkFCREFHQ0kiPk1hcHBlZCBzdXBlcmNsYXNzPC9hPiBvbiB0aGUgPGEgaHJlZj0icmVmZXJlbmNlMDAzLmh0bSNDSUFGRUlHRiI+RW50aXR5IENsYXNzIHBhZ2U8L2E+PC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJsbm90ZSIgLS0+PC9kaXY+Ci08L2xpPgotPGxpPgotPHA+QWRkIHBlcnNpc3RlbmNlIGZpZWxkcyB0byB0aGUgZW50aXR5IGJ5IGNsaWNraW5nIDxzcGFuIGNsYXNzPSJib2xkIj5BZGQ8L3NwYW4+LiBUaGUgRW50aXR5IEZpZWxkcyBkaWFsb2cgYXBwZWFycy48L3A+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWYzNCIgbmFtZT0ic3RocmVmMzQiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWluZmlndXJlIj5UaGUgRW50aXR5IEZpZWxkcyBEaWFsb2c8L3A+Ci08aW1nIHNyYz0iaW1nL2pwYV93aXphcmRfY3JlYXRlX2ZpZWxkcy5wbmciIGFsdD0iVGhlIEVudGl0eSBGaWVsZHMgZGlhbG9nLiIgdGl0bGU9IlRoZSBFbnRpdHkgRmllbGRzIGRpYWxvZy4iIC8+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJmaWd1cmUiIC0tPjwvbGk+Ci08bGk+Ci08cD5TZWxlY3QgYSBwZXJzaXN0ZW5jZSB0eXBlIGZyb20gdGhlIFR5cGUgbGlzdC4gWW91IGNhbiByZXRyaWV2ZSBhZGRpdGlvbmFsIHR5cGVzIHVzaW5nIHRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+QnJvd3NlPC9zcGFuPiBmdW5jdGlvbi48L3A+Ci08L2xpPgotPGxpPgotPHA+RW50ZXIgdGhlIGZpZWxkIG5hbWUgYW5kIHRoZW4gY2xpY2sgPHNwYW4gY2xhc3M9ImJvbGQiPk9LPC9zcGFuPi4gUmVwZWF0IHRoaXMgcHJvY2VkdXJlIGZvciBlYWNoIGZpZWxkLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5JZiBuZWVkZWQsIHNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+S2V5PC9zcGFuPiB0byBkZXNpZ25hdGUgdGhlIGZpZWxkIGFzIGEgcHJpbWFyeSBrZXkuPC9wPgotPC9saT4KLTxsaT4KLTxwPlNlbGVjdCBlaXRoZXIgdGhlIDxzcGFuIGNsYXNzPSJib2xkIj5GaWVsZC1iYXNlZDwvc3Bhbj4gYWNjZXNzIHR5cGUgKHRoZSBkZWZhdWx0KSBvciA8c3BhbiBjbGFzcz0iYm9sZCI+UHJvcGVydHktYmFzZWQ8L3NwYW4+IGFjY2VzcyB0eXBlLjwvcD4KLTwvbGk+Ci08L29sPgotPC9saT4KLTwvb2w+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsci5wbmciIGFsdD0iUmVsYXRlZCByZWZlcmVuY2UiIHRpdGxlPSJSZWxhdGVkIHJlZmVyZW5jZSIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0icmVmZXJlbmNlMDAyLmh0bSNDSUFHR0dERiI+Q3JlYXRlIEpQQSBFbnRpdHkgd2l6YXJkPC9hPjxiciAvPgotPGEgaHJlZj0icmVmX25ld19qcGFfcHJvamVjdF93aXphcmQuaHRtI0NBQ0JKR0JHIj5DcmVhdGUgTmV3IEpQQSBQcm9qZWN0IHdpemFyZDwvYT48YnIgLz4KLTxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9wZXJzcGVjdGl2ZS5odG0jQkFCSUZCREIiPkpQQSBEZXZlbG9wbWVudCBwZXJzcGVjdGl2ZTwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWx0LnBuZyIgYWx0PSJSZWxhdGVkIHRhc2tzIiB0aXRsZT0iUmVsYXRlZCB0YXNrcyIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza19tYW5hZ2VfcGVyc2lzdGVuY2UuaHRtI0NJSERBSklEIj5NYW5hZ2luZyB0aGUgcGVyc2lzdGVuY2UueG1sIGZpbGU8L2E+PGJyIC8+Ci08YSBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0jQkFCSElDQUkiPkFkZGluZyBwZXJzaXN0ZW5jZSB0byBhIGNsYXNzPC9hPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0iY29uY2VwdF9wZXJzaXN0ZW5jZS5odG0jQkFCQ0FISUMiPlVuZGVyc3RhbmRpbmcgSmF2YSBwZXJzaXN0ZW5jZTwvYT48YnIgLz4KLTxhIGhyZWY9ImNvbmNlcHRzMDAyLmh0bSNDSERIQUdJSCI+VGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlPC9hPjxiciAvPgotPHA+Jm5ic3A7PC9wPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MSIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMDIuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDAyLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDE0YzgyNS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMDIuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNjEgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDMgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5Vc2luZyB0aGUgWE1MIEVkaXRvciB0byBlZGl0IHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZTwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IlVzaW5nIHRoZSBYTUwgRWRpdG9yIHRvIGVkaXQgdGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0lIRUpBSUUiIG5hbWU9IkNJSEVKQUlFIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5Vc2luZyB0aGUgWE1MIEVkaXRvciB0byBlZGl0IHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZTwvaDE+Ci08cD48YSBpZD0ic3RocmVmMzciIG5hbWU9InN0aHJlZjM3Ij48L2E+PGEgaWQ9InN0aHJlZjM4IiBuYW1lPSJzdGhyZWYzOCI+PC9hPllvdSBjYW4gd29yayB3aXRoIHRoZSA8Y29kZT5wZXJzaXN0ZW5jZS54bWw8L2NvZGU+IGJ5IHVzaW5nIHRoZSBYTUwgRWRpdG9yLjwvcD4KLTxwPlVzZSB0aGlzIHByb2NlZHVyZSB0byB3b3JrIHdpdGggdGhlIDxjb2RlPnBlcnNpc3RlbmNlLnhtbDwvY29kZT4gZmlsZTo8L3A+Ci08b2wgc3RhcnQ9IjEiPgotPGxpPgotPHA+UmlnaHQtY2xpY2sgdGhlIDxjb2RlPnBlcnNpc3RlbmNlLnhtbDwvY29kZT4gZmlsZSBpbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPlBhY2thZ2UgRXhwbG9yZXI8L3NwYW4+IGFuZCBzZWxlY3QgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtYWN0aW9uIj5PcGVuIFdpdGggJmd0OyBYTUwgRWRpdG9yPC9zcGFuPi48L3A+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWYzOSIgbmFtZT0ic3RocmVmMzkiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWluZmlndXJlIj5PcGVuaW5nIHRoZSBYTUwgRWRpdG9yPC9wPgotPGltZyBzcmM9ImltZy9vcGVuX3BlcnNpc3RlbmNlX2VkaXRvci5wbmciIGFsdD0iVGhpcyBmaWd1cmUgc2hvd3MgdGhlIE9wZW4gJmd0OyBYTUwgRWRpdG9yIG9wdGlvbiBmb3IgdGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlLiIgdGl0bGU9IlRoaXMgZmlndXJlIHNob3dzIHRoZSBPcGVuICZndDsgWE1MIEVkaXRvciBvcHRpb24gZm9yIHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZS4iIC8+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJmaWd1cmUiIC0tPjwvbGk+Ci08bGk+Ci08cD48YSBpZD0ic3RocmVmNDAiIG5hbWU9InN0aHJlZjQwIj48L2E+PGEgaWQ9InN0aHJlZjQxIiBuYW1lPSJzdGhyZWY0MSI+PC9hPlVzZSB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPlhNTCBFZGl0b3I8L3NwYW4+IHRvIGVkaXQgdGhlIDxjb2RlPnBlcnNpc3RlbmNlLnhtbDwvY29kZT4gZmlsZS48L3A+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWY0MiIgbmFtZT0ic3RocmVmNDIiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWluZmlndXJlIj5YTUwgRWRpdG9yPC9wPgotPGltZyBzcmM9ImltZy9wZXJzaXN0ZW5jZV94bWxfZWRpdG9yLnBuZyIgYWx0PSJUaGlzIGZpZ3VyZSBzaG93cyB0aGUgWE1MIEVkaXRvci4iIHRpdGxlPSJUaGlzIGZpZ3VyZSBzaG93cyB0aGUgWE1MIEVkaXRvci4iIC8+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJmaWd1cmUiIC0tPjwvbGk+Ci08L29sPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0iI0NJSEVKQUlFIj5Vc2luZyB0aGUgWE1MIEVkaXRvciB0byBlZGl0IHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZTwvYT48YnIgLz4KLTxhIGhyZWY9Ii4uL29yZy5lY2xpcHNlLndzdC54bWxlZGl0b3IuZG9jLnVzZXIvdG9waWNzL2N3b3JrWE1MLmh0bWwiPldvcmtpbmcgd2l0aCBYTUwgRmlsZXM8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsYy5wbmciIGFsdD0iUmVsYXRlZCBjb25jZXB0IiB0aXRsZT0iUmVsYXRlZCBjb25jZXB0IiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJjb25jZXB0czAwMi5odG0jQ0hESEFHSUgiPlRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZTwvYT48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QyIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAwMy5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMDMuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjZjgwZmY0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAwMy5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw3NCArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0MyAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPlN5bmNocm9uaXppbmcgY2xhc3NlczwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IlN5bmNocm9uaXppbmcgY2xhc3NlcyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNJSEZFQkFJIiBuYW1lPSJDSUhGRUJBSSI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QyIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+U3luY2hyb25pemluZyBjbGFzc2VzPC9oMT4KLTxwPkFzIHlvdSB3b3JrIHdpdGggdGhlIGNsYXNzZXMgaW4geW91ciBKYXZhIHByb2plY3QsIHlvdSB3aWxsIG5lZWQgdG8gdXBkYXRlIHRoZSA8Y29kZT5wZXJzaXN0ZW5jZS54bWw8L2NvZGU+IGZpbGUgdG8gcmVmbGVjdCB0aGUgY2hhbmdlcy4gPGEgaWQ9InN0aHJlZjQzIiBuYW1lPSJzdGhyZWY0MyI+PC9hPjxhIGlkPSJzdGhyZWY0NCIgbmFtZT0ic3RocmVmNDQiPjwvYT48L3A+Ci08cD5Vc2UgdGhpcyBwcm9jZWR1cmUgdG8gc3luY2hyb25pemUgdGhlIDxjb2RlPnBlcnNpc3RlbmNlLnhtbDwvY29kZT4gZmlsZTo8L3A+Ci08b2wgc3RhcnQ9IjEiPgotPGxpPgotPHA+UmlnaHQtY2xpY2sgdGhlIDxjb2RlPnBlcnNpc3RlbmNlLnhtbDwvY29kZT4gZmlsZSBpbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPlBhY2thZ2UgRXhwbG9yZXI8L3NwYW4+IGFuZCBzZWxlY3QgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtYWN0aW9uIj5KUEEgVG9vbHMgJmd0OyBTeW5jaHJvbml6ZSBDbGFzc2VzPC9zcGFuPi48L3A+Ci08ZGl2IGFsaWduPSJjZW50ZXIiPgotPGRpdiBjbGFzcz0iaW5mdGJsbm90ZSI+PGJyIC8+Ci08dGFibGUgY2xhc3M9Ik5vdGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0Ym9keT4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCI+Ci08cCBjbGFzcz0ibm90ZXAxIj5Ob3RlOjwvcD4KLVVzZSB0aGlzIGZ1bmN0aW9uIGlmIHlvdSBzZWxlY3RlZCA8c3BhbiBjbGFzcz0iYm9sZCI+QW5ub3RhdGVkIGNsYXNzZXMgbXVzdCBiZSBsaXN0ZWQgaW4gdGhlIHBlcnNpc3RlbmNlLnhtbCBvcHRpb248L3NwYW4+IGluIHRoZSA8YSBocmVmPSJyZWZfanBhX2ZhY2V0Lmh0bSNDQUNJRkRJRiI+SlBBIEZhY2V0IHBhZ2U8L2E+LiBJbiBnZW5lcmFsLCB5b3UgZG8gbm90IGhhdmUgdG8gdXNlIHRoaXMgZnVuY3Rpb24gd2l0aGluIHRoZSBjb250YWluZXIuPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJsbm90ZSIgLS0+PC9kaXY+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWY0NSIgbmFtZT0ic3RocmVmNDUiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWluZmlndXJlIj5TeW5jaHJvbml6aW5nIHRoZSBwZXJzaXN0ZW5jZS54bWwgRmlsZTwvcD4KLTxpbWcgc3JjPSJpbWcvc3luY2hvcm5pemVfY2xhc3Nlcy5wbmciIGFsdD0iVGhpcyBmaWd1cmUgc2hvd3MgdGhlIEpQQSBUb29scyAmZ3Q7IFN5bmNocm9uaXplIENsYXNzZXMgb3B0aW9uLiIgdGl0bGU9IlRoaXMgZmlndXJlIHNob3dzIHRoZSBKUEEgVG9vbHMgJmd0OyBTeW5jaHJvbml6ZSBDbGFzc2VzIG9wdGlvbi4iIC8+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJmaWd1cmUiIC0tPgotPHA+RGFsaSBhZGRzIHRoZSBuZWNlc3NhcnkgPGNvZGU+Jmx0O2NsYXNzJmd0OzwvY29kZT4gZWxlbWVudHMgdG8gdGhlIDxjb2RlPnBlcnNpc3RlbmNlLnhtbDwvY29kZT4gZmlsZS48L3A+Ci08L2xpPgotPGxpPgotPHA+VXNlIHRoZSA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC10aXRsZSI+UGVyc2lzdGVuY2UgWE1MIEVkaXRvcjwvc3Bhbj4gdG8gY29udGludWUgZWRpdGluZyB0aGUgPGNvZGU+cGVyc2lzdGVuY2UueG1sPC9jb2RlPiBmaWxlLjwvcD4KLTwvbGk+Ci08L29sPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza3MwMDIuaHRtI0NJSEVKQUlFIj5Vc2luZyB0aGUgWE1MIEVkaXRvciB0byBlZGl0IHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZTwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxjLnBuZyIgYWx0PSJSZWxhdGVkIGNvbmNlcHQiIHRpdGxlPSJSZWxhdGVkIGNvbmNlcHQiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9ImNvbmNlcHRzMDAyLmh0bSNDSERIQUdJSCI+VGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlPC9hPjxiciAvPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MiIgLS0+Ci08IS0tIGNsYXNzPSJzZWN0MSIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMDQuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDA0Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOThjODMyNy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMDQuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNjkgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDMgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5NYW5hZ2luZyB0aGUgb3JtLnhtbCBmaWxlPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iTWFuYWdpbmcgdGhlIG9ybS54bWwgZmlsZSIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT48YSBpZD0ic3RocmVmNDgiIG5hbWU9InN0aHJlZjQ4Ij48L2E+Ci08aDE+Q3JlYXRpbmcgYW4gb3JtLnhtbCBmaWxlPC9oMT4KLTxwPklmIHlvdSBvcHQgbm90IHRvIGNyZWF0ZSBhbiA8Y29kZT5vcm0ueG1sPC9jb2RlPiBmaWxlIHdoZW4geW91IGNyZWF0ZSBhIEpQQSBwcm9qZWN0LCB5b3UgY2FuIGNyZWF0ZSBvbmUgdXNpbmcgdGhlIDxhIGhyZWY9InJlZmVyZW5jZTAwNS5odG0jQ0lBSUpDQ0UiPk1hcHBpbmcgRmlsZSBXaXphcmQ8L2E+LjwvcD4KLTxwPlVzZSB0aGlzIHByb2NlZHVyZSB0byBjcmVhdGUgYW4gPGNvZGU+b3JtLnhtbDwvY29kZT4gZmlsZTo8L3A+Ci08b2wgc3RhcnQ9IjEiPgotPGxpPgotPHA+RnJvbSB0aGUgTmF2aWdhdG9yIG9yIFBhY2thZ2UgRXhwbG9yZXIsIHNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+RmlsZSAmZ3Q7IE5ldyAmZ3Q7IE90aGVyPC9zcGFuPi4gVGhlIFNlbGVjdCBhIFdpemFyZCBkaWFsb2cgYXBwZWFycy48L3A+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWY0OSIgbmFtZT0ic3RocmVmNDkiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWluZmlndXJlIj5UaGUgU2VsZWN0IGEgV2l6YXJkIERpYWxvZzwvcD4KLTxpbWcgc3JjPSJpbWcvc2VsZWN0X2Ffd2l6YXJkX21hcHBpbmcucG5nIiBhbHQ9IlRoZSBTZWxlY3QgYSBXaXphcmQgZGlhbG9nIHdpdGggTWFwcGluZyBmaWxlIHNlbGVjdGVkLiIgdGl0bGU9IlRoZSBTZWxlY3QgYSBXaXphcmQgZGlhbG9nIHdpdGggTWFwcGluZyBmaWxlIHNlbGVjdGVkLiIgLz48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImZpZ3VyZSIgLS0+PC9saT4KLTxsaT4KLTxwPlNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+TWFwcGluZyBGaWxlPC9zcGFuPiBhbmQgdGhlbiBjbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+TmV4dDwvc3Bhbj4uIFRoZSBNYXBwaW5nIEZpbGUgcGFnZSBhcHBlYXJzLjwvcD4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9InN0aHJlZjUwIiBuYW1lPSJzdGhyZWY1MCI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPlRoZSBNYXBwaW5nIEZpbGUgUGFnZTwvcD4KLTxpbWcgc3JjPSJpbWcvbWFwcGluZ19maWxlX25ldy5wbmciIGFsdD0iVGhlIE1hcHBpbmcgRmlsZSBwYWdlLiIgdGl0bGU9IlRoZSBNYXBwaW5nIEZpbGUgcGFnZS4iIC8+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJmaWd1cmUiIC0tPjwvbGk+Ci08bGk+Ci08cD5EZWZpbmUgdGhlIHByb3BlcnRpZXMgaW4gdGhlIHBhZ2UgYW5kIGNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5GaW5pc2g8L3NwYW4+LiBUaGUgPGNvZGU+b3JtLnhtbDwvY29kZT4gZmlsZSBhcHBlYXJzIGluIHRoZSBzcmMgZGlyZWN0b3J5IG9mIHRoZSBzZWxlY3RlZCBKUEEgcHJvamVjdC4gWW91IGNhbiBtYW5hZ2UgdGhlIG9ybS54bWwgZmlsZSB1c2luZyB0aGUgSlBBIERldGFpbHMgdmlldyBvciB0aHJvdWdoIHRoZSBYTUwgRWRpdG9yLiBTZWUgYWxzbyA8YSBocmVmPSJyZWZfZGV0YWlsc19vcm0uaHRtI0NBQ0dER0hDIj5KUEEgRGV0YWlscyB2aWV3IChmb3Igb3JtLnhtbCk8L2E+LjwvcD4KLTxkaXYgYWxpZ249ImNlbnRlciI+Ci08ZGl2IGNsYXNzPSJpbmZ0Ymxub3RlIj48YnIgLz4KLTx0YWJsZSBjbGFzcz0iTm90ZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRib2R5PgotPHRyPgotPHRkIGFsaWduPSJsZWZ0Ij4KLTxwIGNsYXNzPSJub3RlcDEiPk5vdGU6PC9wPgotVGhlIE1hcHBpbmcgRmlsZSBXaXphcmQgd2lsbCBub3QgYWxsb3cgeW91IHRvIHByb2NlZWQgaWYgeW91IHNlbGVjdCBhIEpQQSBwcm9qZWN0IHRoYXQgYWxyZWFkeSBpbmNsdWRlcyBhbiA8Y29kZT5vcm0ueG1sPC9jb2RlPiBmaWxlLjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibG5vdGUiIC0tPjwvZGl2PgotPC9saT4KLTwvb2w+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QyIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAwNS5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMDUuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlYTVkMWRkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAwNS5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw2MiArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0NCAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPldvcmtpbmcgd2l0aCBvcm0ueG1sIGZpbGU8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJXb3JraW5nIHdpdGggb3JtLnhtbCBmaWxlIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0lIQkNEQ0UiIG5hbWU9IkNJSEJDRENFIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5Xb3JraW5nIHdpdGggb3JtLnhtbCBmaWxlPC9oMT4KLTxwPjxhIGlkPSJzdGhyZWY1MSIgbmFtZT0ic3RocmVmNTEiPjwvYT48YSBpZD0ic3RocmVmNTIiIG5hbWU9InN0aHJlZjUyIj48L2E+WW91IGNhbiB3b3JrIHdpdGggdGhlIDxjb2RlPm9ybS54bWw8L2NvZGU+IGJ5IHVzaW5nIHRoZSBKUEEgRGV0YWlscyB2aWV3LjwvcD4KLTxwPlVzZSB0aGlzIHByb2NlZHVyZSB0byB3b3JrIHdpdGggdGhlIDxjb2RlPm9ybS54bWw8L2NvZGU+IGZpbGU6PC9wPgotPG9sIHN0YXJ0PSIxIj4KLTxsaT4KLTxwPlJpZ2h0LWNsaWNrIHRoZSA8Y29kZT5vcm0ueG1sPC9jb2RlPiBmaWxlIGluIHRoZSA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC10aXRsZSI+UGFja2FnZSBFeHBsb3Jlcjwvc3Bhbj4gYW5kIHNlbGVjdCA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC1hY3Rpb24iPk9wZW48L3NwYW4+LjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5JbiB0aGUgSlBBIFN0cnVjdHVyZSB2aWV3LCBzZWxlY3QgPHNwYW4gY2xhc3M9ImJvbGQiPkVudGl0eU1hcHBpbmdzPC9zcGFuPi48L3A+Ci08L2xpPgotPGxpPgotPHA+VXNlIHRoZSBKUEEgRGV0YWlscyB2aWV3IHRvIGNvbmZpZ3VyZSB0aGUgZW50aXR5IG1hcHBpbmcgYW5kIHBlcnNpc3RlbmNlIHVuaXQgZGVmYXVsdHMuPC9wPgotPGRpdiBjbGFzcz0iZmlndXJlIj48YSBpZD0ic3RocmVmNTMiIG5hbWU9InN0aHJlZjUzIj48L2E+Ci08cCBjbGFzcz0idGl0bGVpbmZpZ3VyZSI+SlBBIERldGFpbHMgdmlldyBmb3IgRW50aXR5TWFwcGluZ3MgKG9ybS54bWwpPC9wPgotPGltZyBzcmM9ImltZy9kZXRhaWxzX2VudGl0eW1hcHBpbmdzLnBuZyIgYWx0PSJKUEEgRGV0YWlscyB2aWV3IGZvciBvcm0ueG1sIGZpbGUuIiB0aXRsZT0iSlBBIERldGFpbHMgdmlldyBmb3Igb3JtLnhtbCBmaWxlLiIgLz48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImZpZ3VyZSIgLS0+PC9saT4KLTwvb2w+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSIjQ0lIQkNEQ0UiPldvcmtpbmcgd2l0aCBvcm0ueG1sIGZpbGU8L2E+PGJyIC8+Ci08YSBocmVmPSIuLi9vcmcuZWNsaXBzZS53c3QueG1sZWRpdG9yLmRvYy51c2VyL3RvcGljcy9jd29ya1hNTC5odG1sIj5Xb3JraW5nIHdpdGggWE1MIEZpbGVzPC9hPjxiciAvPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0iY29uY2VwdHMwMDMuaHRtI0NIREJJSkFDIj5UaGUgb3JtLnhtbCBmaWxlPC9hPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDIiIC0tPgotPCEtLSBjbGFzcz0ic2VjdDEiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDA2Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAwNi5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDdhZWY2OTUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDA2Lmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDk1ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQ0IC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+RW50aXR5PC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iRW50aXR5IiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkFCR0JJRUUiIG5hbWU9IkJBQkdCSUVFIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5FbnRpdHk8L2gxPgotPHA+PGEgaWQ9InN0aHJlZjU3IiBuYW1lPSJzdGhyZWY1NyI+PC9hPjxhIGlkPSJzdGhyZWY1OCIgbmFtZT0ic3RocmVmNTgiPjwvYT48YSBpZD0ic3RocmVmNTkiIG5hbWU9InN0aHJlZjU5Ij48L2E+PGEgaWQ9InN0aHJlZjYwIiBuYW1lPSJzdGhyZWY2MCI+PC9hPkFuIDxzcGFuIGNsYXNzPSJib2xkIj5FbnRpdHk8L3NwYW4+IGlzIGEgcGVyc2lzdGVudCBkb21haW4gb2JqZWN0LjwvcD4KLTxwPkFuIGVudGl0eSA8c3BhbiBjbGFzcz0iaXRhbGljIj5jYW4gYmU8L3NwYW4+OjwvcD4KLTx1bD4KLTxsaT4KLTxwPkFic3RyYWN0IG9yIGNvbmNyZXRlIGNsYXNzZXMuIEVudGl0aWVzIG1heSBhbHNvIGV4dGVuZCBub24tZW50aXR5IGNsYXNzZXMgYXMgd2VsbCBhcyBlbnRpdHkgY2xhc3NlcywgYW5kIG5vbi1lbnRpdHkgY2xhc3NlcyBtYXkgZXh0ZW5kIGVudGl0eSBjbGFzc2VzLjwvcD4KLTwvbGk+Ci08L3VsPgotPHA+QW4gZW50aXR5IDxzcGFuIGNsYXNzPSJpdGFsaWMiPm11c3QgaGF2ZTwvc3Bhbj46PC9wPgotPHVsPgotPGxpPgotPHA+QSBuby1hcmcgY29uc3RydWN0b3IgKHB1YmxpYyBvciBwcm90ZWN0ZWQpOyB0aGUgZW50aXR5IGNsYXNzIG1heSBoYXZlIG90aGVyIGNvbnN0cnVjdG9ycyBhcyB3ZWxsLjwvcD4KLTwvbGk+Ci08L3VsPgotPHA+PGEgaWQ9InN0aHJlZjYxIiBuYW1lPSJzdGhyZWY2MSI+PC9hPjxhIGlkPSJzdGhyZWY2MiIgbmFtZT0ic3RocmVmNjIiPjwvYT48YSBpZD0ic3RocmVmNjMiIG5hbWU9InN0aHJlZjYzIj48L2E+RWFjaCBwZXJzaXN0ZW50IGVudGl0eSBtdXN0IGJlIG1hcHBlZCB0byBhIGRhdGFiYXNlIHRhYmxlIGFuZCBjb250YWluIGEgcHJpbWFyeSBrZXkuIFBlcnNpc3RlbnQgZW50aXRpZXMgYXJlIGlkZW50aWZpZWQgYnkgdGhlIDxjb2RlPkBFbnRpdHk8L2NvZGU+IGFubm90YXRpb24uPC9wPgotPHA+VXNlIHRoaXMgcHJvY2VkdXJlIHRvIGFkZCBwZXJzaXN0ZW5jZSB0byBhbiBleGlzdGluZyBlbnRpdHk6PC9wPgotPG9sIHN0YXJ0PSIxIj4KLTxsaT4KLTxwPk9wZW4gdGhlIEphdmEgY2xhc3MgaW4gdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5QYWNrYWdlIEV4cGxvcmVyLjwvc3Bhbj48L3A+Ci08L2xpPgotPGxpPgotPHA+U2VsZWN0IHRoZSBjbGFzcyBpbiB0aGUgSlBBIFN0cnVjdHVyZSB2aWV3LjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5JbiB0aGUgSlBBIERldGFpbHMgdmlldywgY2xpY2sgdGhlIG1hcHBpbmcgdHlwZSBoeXBlcmxpbmsgdG8gYWNjZXNzIHRoZSBNYXBwaW5nIFR5cGUgU2VsZWN0aW9uIGRpYWxvZy4gSW4gdGhlIGZvbGxvd2luZyBmaWd1cmUsIGNsaWNraW5nIDxzcGFuIGNsYXNzPSJpdGFsaWMiPmVudGl0eTwvc3Bhbj4gaW52b2tlcyB0aGUgZGlhbG9nIGZyb20gdGhlIEpQQSBEZXRhaWxzIFZpZXcuPC9wPgotPGRpdiBjbGFzcz0iZmlndXJlIj48YSBpZD0ic3RocmVmNjQiIG5hbWU9InN0aHJlZjY0Ij48L2E+Ci08cCBjbGFzcz0idGl0bGVpbmZpZ3VyZSI+VGhlIE1hcHBpbmcgVHlwZSBIeXBlcmxpbms8L3A+Ci08aW1nIHNyYz0iaW1nL21hcHBlZF9lbnRpdHlfdHlwZV9saW5rLnBuZyIgYWx0PSJUaGUgSlBBIERldGFpbHMgdmlldyBmb3IgYW4gZW50aXR5IHNob3dpbmcgdGhlIG1hcHBpbmcgdHlwZSBoeXBlcmxpbmsuIiB0aXRsZT0iVGhlIEpQQSBEZXRhaWxzIHZpZXcgZm9yIGFuIGVudGl0eSBzaG93aW5nIHRoZSBtYXBwaW5nIHR5cGUgaHlwZXJsaW5rLiIgLz48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImZpZ3VyZSIgLS0+Ci08ZGl2IGFsaWduPSJjZW50ZXIiPgotPGRpdiBjbGFzcz0iaW5mdGJsbm90ZWFsc28iPjxiciAvPgotPHRhYmxlIGNsYXNzPSJOb3RlQWxzbyBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRib2R5PgotPHRyPgotPHRkIGFsaWduPSJsZWZ0Ij4KLTxwIGNsYXNzPSJub3RlcDEiPlRpcDo8L3A+Ci1Zb3UgY2FuIGFsc28gY2hhbmdlIChvciBhZGQpIHBlcnNpc3RlbmNlIGZvciBhbiBlbnRpdHkgYnkgcmlnaHQtY2xpY2tpbmcgdGhlIGNsYXNzIGluIHRoZSBKUEEgU3RydWN0dXJlIFZpZXcgYW5kIHRoZW4gY2xpY2tpbmcgPHNwYW4gY2xhc3M9ImJvbGQiPk1hcCBBcyAmZ3Q7IEVudGl0eTwvc3Bhbj4uPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJsbm90ZWFsc28iIC0tPjwvZGl2PgotPC9saT4KLTxsaT4KLTxwPlNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+RW50aXR5PC9zcGFuPiBmcm9tIHRoZSBNYXBwaW5nIFR5cGUgU2VsZWN0aW9uIGRpYWxvZyBhbmQgdGhlbiBjbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+T0s8L3NwYW4+LjwvcD4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9InN0aHJlZjY1IiBuYW1lPSJzdGhyZWY2NSI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPlRoZSBNYXBwaW5nIFR5cGUgU2VsZWN0aW9uIERpYWxvZzwvcD4KLTxpbWcgc3JjPSJpbWcvbWFwcGluZ190eXBlX3NlbGVjdGlvbl9lbnRpdHkucG5nIiBhbHQ9IlRoZSBNYXBwaW5nIFR5cGUgc2VsZWN0aW9uIGRpYWxvZyB3aXRoIEVuaXR5IHNlbGVjdGVkLiIgdGl0bGU9IlRoZSBNYXBwaW5nIFR5cGUgc2VsZWN0aW9uIGRpYWxvZyB3aXRoIEVuaXR5IHNlbGVjdGVkLiIgLz48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImZpZ3VyZSIgLS0+PC9saT4KLTxsaT4KLTxwPkNvbXBsZXRlIHRoZSByZW1haW5pbmcgPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3Byb3Bfdmlldy5odG0jQkFCRkFFQkIiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBlbnRpdGllcyk8L2E+LjwvcD4KLTwvbGk+Ci08L29sPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFza3MiIHRpdGxlPSJSZWxhdGVkIHRhc2tzIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0jQkFCSElDQUkiPkFkZGluZyBwZXJzaXN0ZW5jZSB0byBhIGNsYXNzPC9hPjxiciAvPgotPGEgaHJlZj0idGFza19hZGRpdG9uYWxfdGFibGVzLmh0bSNDSUhHQklFSSI+U3BlY2lmeWluZyBhZGRpdGlvbmFsIHRhYmxlczwvYT48YnIgLz4KLTxhIGhyZWY9InRhc2tfaW5oZXJpdGFuY2UuaHRtI0NJSENDQ0pEIj5TcGVjaWZ5aW5nIGVudGl0eSBpbmhlcml0YW5jZTwvYT48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QyIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAwNy5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMDcuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlZmQxMDlhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAwNy5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw2OSArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0NCAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPkVtYmVkZGFibGU8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJFbWJlZGRhYmxlIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkFCRkVJQ0UiIG5hbWU9IkJBQkZFSUNFIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5FbWJlZGRhYmxlPC9oMT4KLTxwPjxhIGlkPSJzdGhyZWY2NiIgbmFtZT0ic3RocmVmNjYiPjwvYT48YSBpZD0ic3RocmVmNjciIG5hbWU9InN0aHJlZjY3Ij48L2E+QW4gPHNwYW4gY2xhc3M9ImJvbGQiPkVtYmVkZGVkPC9zcGFuPiBjbGFzcyBpcyBhIGNsYXNzIHdob3NlIGluc3RhbmNlcyBhcmUgc3RvcmVkIGFzIHBhcnQgb2YgYW4gb3duaW5nIGVudGl0eTsgaXQgc2hhcmVzIHRoZSBpZGVudGl0eSBvZiB0aGUgb3duaW5nIGVudGl0eS4gRWFjaCBmaWVsZCBvZiB0aGUgZW1iZWRkZWQgY2xhc3MgaXMgbWFwcGVkIHRvIHRoZSBkYXRhYmFzZSB0YWJsZSBhc3NvY2lhdGVkIHdpdGggdGhlIG93bmluZyBlbnRpdHkuPC9wPgotPHA+VG8gb3ZlcnJpZGUgdGhlIG1hcHBpbmcgaW5mb3JtYXRpb24gZm9yIGEgc3BlY2lmaWMgc3ViY2xhc3MsIHVzZSB0aGUgPGNvZGU+QEF0dHJpYnV0ZU92ZXJyaWRlPC9jb2RlPiBhbm5vdGF0aW9uIGZvciB0aGF0IHNwZWNpZmljIGNsYXNzLjwvcD4KLTxwPjxhIGlkPSJzdGhyZWY2OCIgbmFtZT0ic3RocmVmNjgiPjwvYT48YSBpZD0ic3RocmVmNjkiIG5hbWU9InN0aHJlZjY5Ij48L2E+PGEgaWQ9InN0aHJlZjcwIiBuYW1lPSJzdGhyZWY3MCI+PC9hPkFuIGVtYmVkZGFibGUgZW50aXR5IGlzIGlkZW50aWZpZWQgYnkgdGhlIDxjb2RlPkBFbWJlZGRhYmxlPC9jb2RlPiBhbm5vdGF0aW9uLjwvcD4KLTxwPlVzZSB0aGlzIHByb2NlZHVyZSB0byBhZGQgZW1iZWRkYWJsZSBwZXJzaXN0ZW5jZSB0byBhbiBleGlzdGluZyBlbnRpdHk6PC9wPgotPG9sIHN0YXJ0PSIxIj4KLTxsaT4KLTxwPk9wZW4gdGhlIEphdmEgY2xhc3MgaW4gdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5QYWNrYWdlIEV4cGxvcmVyPC9zcGFuPi48L3A+Ci08L2xpPgotPGxpPgotPHA+U2VsZWN0IHRoZSBjbGFzcyBpbiB0aGUgSlBBIFN0cnVjdHVyZSB2aWV3LjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5DbGljayB0aGUgbWFwcGluZyB0eXBlIGh5cGVybGluayB0byBvcGVuIHRoZSBNYXBwaW5nIFR5cGUgU2VsZWN0aW9uIGRpYWxvZy48L3A+Ci08L2xpPgotPGxpPgotPHA+U2VsZWN0IDxzcGFuIGNsYXNzPSJib2xkIj5FbWJlZGRhYmxlPC9zcGFuPiBhbmQgdGhlbiBjbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+T0s8L3NwYW4+LjwvcD4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9InN0aHJlZjcxIiBuYW1lPSJzdGhyZWY3MSI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPk1hcHBpbmcgVHlwZSBTZWxlY3Rpb24gRGlhbG9nIChFbWJlZGRhYmxlKTwvcD4KLTxpbWcgc3JjPSJpbWcvbWFwcGluZ190eXBlX3NlbGVjdGlvbl9lbWJlZC5wbmciIGFsdD0iVGhlIE1hcHBpbmcgVHlwZSBTZWxlY3Rpb24gZGlhbG9nIHdpdGggRW1iZWRkYWJsZSBzZWxlY3RlZC4iIHRpdGxlPSJUaGUgTWFwcGluZyBUeXBlIFNlbGVjdGlvbiBkaWFsb2cgd2l0aCBFbWJlZGRhYmxlIHNlbGVjdGVkLiIgLz48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImZpZ3VyZSIgLS0+PC9saT4KLTxsaT4KLTxwPkNvbXBsZXRlIHRoZSByZW1haW5pbmcgPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3Byb3Bfdmlldy5odG0jQkFCRkFFQkIiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBlbnRpdGllcyk8L2E+LjwvcD4KLTwvbGk+Ci08L29sPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFza3MiIHRpdGxlPSJSZWxhdGVkIHRhc2tzIiAvPjxiciAvPgotPGRsPgotPGRkPjxhIGhyZWY9InRhc2tfYWRkX3BlcnNpc3RlbmNlLmh0bSNCQUJISUNBSSI+QWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3M8L2E+PC9kZD4KLTxkZD48YSBocmVmPSJ0YXNrX2FkZGl0b25hbF90YWJsZXMuaHRtI0NJSEdCSUVJIj5TcGVjaWZ5aW5nIGFkZGl0aW9uYWwgdGFibGVzPC9hPjwvZGQ+Ci08ZGQ+PGEgaHJlZj0idGFza19pbmhlcml0YW5jZS5odG0jQ0lIQ0NDSkQiPlNwZWNpZnlpbmcgZW50aXR5IGluaGVyaXRhbmNlPC9hPjwvZGQ+Ci08L2RsPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MiIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMDguaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDA4Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTAzZDNkMC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMDguaHRtCisrKyAvZGV2L251bGwKQEAgLTEsODMgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDQgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5NYXBwZWQgc3VwZXJjbGFzczwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9Ik1hcHBlZCBzdXBlcmNsYXNzIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkFCREFHQ0kiIG5hbWU9IkJBQkRBR0NJIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5NYXBwZWQgc3VwZXJjbGFzczwvaDE+Ci08cD48YSBpZD0ic3RocmVmNzIiIG5hbWU9InN0aHJlZjcyIj48L2E+PGEgaWQ9InN0aHJlZjczIiBuYW1lPSJzdGhyZWY3MyI+PC9hPkFuIGVudGl0eSB0aGF0IGV4dGVuZHMgYSA8c3BhbiBjbGFzcz0iYm9sZCI+TWFwcGVkIFN1cGVyY2xhc3M8L3NwYW4+IGNsYXNzIGluaGVyaXRzIHRoZSBwZXJzaXN0ZW50IHN0YXRlIGFuZCBtYXBwaW5nIGluZm9ybWF0aW9uIGZyb20gYSBzdXBlcmNsYXNzLiBZb3Ugc2hvdWxkIHVzZSBhIG1hcHBlZCBzdXBlcmNsYXNzIHRvIGRlZmluZSBtYXBwaW5nIGluZm9ybWF0aW9uIHRoYXQgaXMgY29tbW9uIHRvIG11bHRpcGxlIGVudGl0eSBjbGFzc2VzLjwvcD4KLTxwPkEgbWFwcGVkIHN1cGVyY2xhc3MgPHNwYW4gY2xhc3M9Iml0YWxpYyI+Y2FuIGJlPC9zcGFuPjo8L3A+Ci08dWw+Ci08bGk+Ci08cD5BYnN0cmFjdCBvciBjb25jcmV0ZSBjbGFzc2VzPC9wPgotPC9saT4KLTwvdWw+Ci08cD5BIG1hcHBlZCBzdXBlcmNsYXNzIDxzcGFuIGNsYXNzPSJpdGFsaWMiPmNhbm5vdCBiZTwvc3Bhbj46PC9wPgotPHVsPgotPGxpPgotPHA+QmUgcXVlcmllZCBvciBwYXNzZWQgYXMgYW4gYXJndW1lbnQgdG8gRW50aXR5LU1hbmFnZXIgb3IgUXVlcnkgb3BlcmF0aW9uczwvcD4KLTwvbGk+Ci08bGk+Ci08cD5CZSB0aGUgdGFyZ2V0IG9mIGEgcGVyc2lzdGVudCByZWxhdGlvbnNoaXA8L3A+Ci08L2xpPgotPC91bD4KLTxwPkEgbWFwcGVkIHN1cGVyY2xhc3MgZG9lcyBub3QgaGF2ZSBhIGRlZmluZWQgZGF0YWJhc2UgdGFibGUuIEluc3RlYWQsIGl0cyBtYXBwaW5nIGluZm9ybWF0aW9uIGlzIGRlcml2ZWQgZnJvbSBpdHMgc3VwZXJjbGFzcy4gVG8gb3ZlcnJpZGUgdGhlIG1hcHBpbmcgaW5mb3JtYXRpb24gZm9yIGEgc3BlY2lmaWMgc3ViY2xhc3MsIHVzZSB0aGUgPGNvZGU+QEF0dHJpYnV0ZU92ZXJyaWRlPC9jb2RlPiBhbm5vdGF0aW9uIGZvciB0aGF0IHNwZWNpZmljIGNsYXNzLjwvcD4KLTxwPjxhIGlkPSJzdGhyZWY3NCIgbmFtZT0ic3RocmVmNzQiPjwvYT48YSBpZD0ic3RocmVmNzUiIG5hbWU9InN0aHJlZjc1Ij48L2E+PGEgaWQ9InN0aHJlZjc2IiBuYW1lPSJzdGhyZWY3NiI+PC9hPjxhIGlkPSJzdGhyZWY3NyIgbmFtZT0ic3RocmVmNzciPjwvYT5BIG1hcHBlZCBzdXBlcmNsYXNzIGlzIGlkZW50aWZpZWQgYnkgdGhlIDxjb2RlPkBNYXBwZWRTdXBlcmNsYXNzPC9jb2RlPiBhbm5vdGF0aW9uLjwvcD4KLTxwPlVzZSB0aGlzIHByb2NlZHVyZSB0byBhZGQgTWFwcGVkIFN1cGVyY2xhc3MgcGVyc2lzdGVuY2UgdG8gYW4gZXhpc3RpbmcgZW50aXR5OjwvcD4KLTxvbCBzdGFydD0iMSI+Ci08bGk+Ci08cD5PcGVuIHRoZSBKYXZhIGNsYXNzIGluIHRoZSA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC10aXRsZSI+UGFja2FnZSBFeHBsb3Jlcjwvc3Bhbj4uPC9wPgotPC9saT4KLTxsaT4KLTxwPlNlbGVjdCB0aGUgY2xhc3MgaW4gdGhlIEpQQSBTdHJ1Y3R1cmUgdmlldy48L3A+Ci08L2xpPgotPGxpPgotPHA+SW4gdGhlIEpQQSBEZXRhaWxzIHZpZXcsIGNsaWNrIHRoZSBtYXBwaW5nIHR5cGUgaHlwZXJsaW5rIHRvIG9wZW4gdGhlIE1hcHBpbmcgVHlwZSBTZWxlY3Rpb24gZGlhbG9nLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5TZWxlY3QgPHNwYW4gY2xhc3M9ImJvbGQiPk1hcHBlZCBTdXBlcmNsYXNzPC9zcGFuPiBhbmQgdGhlbiA8c3BhbiBjbGFzcz0iYm9sZCI+T0s8L3NwYW4+LjwvcD4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9InN0aHJlZjc4IiBuYW1lPSJzdGhyZWY3OCI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPk1hcHBpbmcgVHlwZSBTZWxlY3Rpb24gRGlhbG9nIChNYXBwZWQgU3VwZXJjbGFzcyk8L3A+Ci08aW1nIHNyYz0iaW1nL21hcHBpbmdfdHlwZV9zZWxlY3Rpb25fc3VwZXJjbGFzcy5wbmciIGFsdD0iVGhlIE1hcHBpbmcgVHlwZSBTZWxlY3Rpb24gZGlhbG9nIHdpdGggTWFwcGVkIFN1cGVyY2xhc3Mgc2VsZWN0ZWQuIiB0aXRsZT0iVGhlIE1hcHBpbmcgVHlwZSBTZWxlY3Rpb24gZGlhbG9nIHdpdGggTWFwcGVkIFN1cGVyY2xhc3Mgc2VsZWN0ZWQuIiAvPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iZmlndXJlIiAtLT48L2xpPgotPGxpPgotPHA+Q29tcGxldGUgdGhlIHJlbWFpbmluZyA8YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfcHJvcF92aWV3Lmh0bSNCQUJGQUVCQiI+SlBBIERldGFpbHMgdmlldyAoZm9yIGVudGl0aWVzKTwvYT4uPC9wPgotPC9saT4KLTwvb2w+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrcyIgdGl0bGU9IlJlbGF0ZWQgdGFza3MiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InRhc2tfYWRkX3BlcnNpc3RlbmNlLmh0bSNCQUJISUNBSSI+QWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3M8L2E+PGJyIC8+Ci08YSBocmVmPSJ0YXNrX2FkZGl0b25hbF90YWJsZXMuaHRtI0NJSEdCSUVJIj5TcGVjaWZ5aW5nIGFkZGl0aW9uYWwgdGFibGVzPC9hPjxiciAvPgotPGEgaHJlZj0idGFza19pbmhlcml0YW5jZS5odG0jQ0lIQ0NDSkQiPlNwZWNpZnlpbmcgZW50aXR5IGluaGVyaXRhbmNlPC9hPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDIiIC0tPgotPCEtLSBjbGFzcz0ic2VjdDEiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDA5Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAwOS5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGY4OGE2ZDcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDA5Lmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDYxICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQ1IC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+Q3JlYXRpbmcgTmFtZWQgUXVlcmllczwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IkNyZWF0aW5nIE5hbWVkIFF1ZXJpZXMiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJCQUJJR0JHRyIgbmFtZT0iQkFCSUdCR0ciPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MSI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPkNyZWF0aW5nIE5hbWVkIFF1ZXJpZXM8L2gxPgotPHA+PGEgaWQ9InN0aHJlZjk0IiBuYW1lPSJzdGhyZWY5NCI+PC9hPjxhIGlkPSJzdGhyZWY5NSIgbmFtZT0ic3RocmVmOTUiPjwvYT5OYW1lZCBxdWVyaWVzIGltcHJvdmUgYXBwbGljYXRpb24gcGVyZm9ybWFuY2UgYmVjYXVzZSB0aGV5IGFyZSBwcmVwYXJlZCBvbmNlIGFuZCB0aGV5IChhbmQgYWxsIG9mIHRoZWlyIGFzc29jaWF0ZWQgc3VwcG9ydGluZyBvYmplY3RzKSBjYW4gYmUgZWZmaWNpZW50bHkgcmV1c2VkIHRoZXJlYWZ0ZXIsIG1ha2luZyB0aGVtIHdlbGwgc3VpdGVkIGZvciBjb21wbGV4IGFuZCBmcmVxdWVudGx5IGV4ZWN1dGVkIG9wZXJhdGlvbnMuIE5hbWVkIHF1ZXJpZXMgdXNlIHRoZSBKUEEgcXVlcnkgbGFuZ3VhZ2UgZm9yIHBvcnRhYmxlIGV4ZWN1dGlvbiBvbiBhbnkgdW5kZXJseWluZyBkYXRhYmFzZTsgbmFtZWQgbmF0aXZlIHF1ZXJpZXMgdXNlIHRoZSBTUUwgbGFuZ3VhZ2UgbmF0aXZlIHRvIHRoZSB1bmRlcmx5aW5nIGRhdGFiYXNlLjwvcD4KLTxwPlVzZSB0aGlzIHByb2NlZHVyZSB0byBhZGQgPGNvZGU+QE5hbWVkUXVlcnk8L2NvZGU+IGFuZCA8Y29kZT5ATmFtZWROYXRpdmVRdWVyeTwvY29kZT4gYW5ub3RhdGlvbnMgdG8gdGhlIGVudGl0eS48L3A+Ci08cD5UbyBjcmVhdGUgYSBuYW1lZCBxdWVyeTo8L3A+Ci08b2wgc3RhcnQ9IjEiPgotPGxpPgotPHA+U2VsZWN0IHRoZSBlbnRpdHkgaW4gdGhlIFBhY2thZ2UgRXhwbG9yZXIuPC9wPgotPC9saT4KLTxsaT4KLTxwPkluIHRoZSBKUEEgRGV0YWlscyB2aWV3LCBleHBhbmQgUXVlcmllcy48L3A+Ci08L2xpPgotPGxpPgotPHA+Q2xpY2sgPHNwYW4gY2xhc3M9ImJvbGQiPkFkZDwvc3Bhbj4gZm9yIGEgbmFtZWQgcXVlcnksIG9yIDxzcGFuIGNsYXNzPSJib2xkIj5BZGQgTmF0aXZlPC9zcGFuPiBmb3IgYSBuYXRpdmUgcXVlcnkuPC9wPgotPC9saT4KLTxsaT4KLTxwPkluIHRoZSBkaWFsb2cgdGhhdCBhcHBlYXJzLCBlbnRlciB0aGUgbmFtZSBvZiB0aGUgcXVlcnkgaW4gdGhlIE5hbWUgZmllbGQgYW5kIHRoZW4gY2xpY2sgT0suPC9wPgotPC9saT4KLTxsaT4KLTxwPkVudGVyIHRoZSBxdWVyeSBpbiB0aGUgUXVlcnkgZmllbGQuPC9wPgotPGRpdiBjbGFzcz0iZmlndXJlIj48YSBpZD0ic3RocmVmOTYiIG5hbWU9InN0aHJlZjk2Ij48L2E+Ci08cCBjbGFzcz0idGl0bGVpbmZpZ3VyZSI+RW50ZXJpbmcgYSBOYW1lZCBRdWVyeTwvcD4KLTxpbWcgc3JjPSJpbWcvdGFza19lbnRlcmluZ19xdWVyeS5wbmciIGFsdD0iVGhlIFF1ZXJpZXMgc2VjdGlvbiBvZiB0aGUgSlBBIERldGFpbHMgdmlldy4iIHRpdGxlPSJUaGUgUXVlcmllcyBzZWN0aW9uIG9mIHRoZSBKUEEgRGV0YWlscyB2aWV3LiIgLz48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImZpZ3VyZSIgLS0+PC9saT4KLTwvb2w+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QxIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAxMC5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMTAuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkN2M5M2Y3Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAxMC5odG0KKysrIC9kZXYvbnVsbApAQCAtMSwxODEgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDYgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5CYXNpYyBtYXBwaW5nPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iQmFzaWMgbWFwcGluZyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkJBQkJBQkNFIiBuYW1lPSJCQUJCQUJDRSI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QyIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+QmFzaWMgbWFwcGluZzwvaDE+Ci08cD48YSBpZD0ic3RocmVmOTciIG5hbWU9InN0aHJlZjk3Ij48L2E+PGEgaWQ9InN0aHJlZjk4IiBuYW1lPSJzdGhyZWY5OCI+PC9hPjxhIGlkPSJzdGhyZWY5OSIgbmFtZT0ic3RocmVmOTkiPjwvYT48YSBpZD0ic3RocmVmMTAwIiBuYW1lPSJzdGhyZWYxMDAiPjwvYT5Vc2UgYSA8c3BhbiBjbGFzcz0iYm9sZCI+QmFzaWMgTWFwcGluZzwvc3Bhbj4gdG8gbWFwIGFuIGF0dHJpYnV0ZSBkaXJlY3RseSB0byBhIGRhdGFiYXNlIGNvbHVtbi4gQmFzaWMgbWFwcGluZ3MgbWF5IGJlIHVzZWQgb25seSB3aXRoIHRoZSBmb2xsb3dpbmcgYXR0cmlidXRlIHR5cGVzOjwvcD4KLTx1bD4KLTxsaT4KLTxwPkphdmEgcHJpbWl0aXZlIHR5cGVzIGFuZCB3cmFwcGVycyBvZiB0aGUgcHJpbWl0aXZlIHR5cGVzPC9wPgotPC9saT4KLTxsaT4KLTxwPjxjb2RlPmphdmEubGFuZy5TdHJpbmcsIGphdmEubWF0aC5CaWdJbnRlZ2VyPC9jb2RlPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48Y29kZT5qYXZhLm1hdGguQmlnRGVjaW1hbDwvY29kZT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGNvZGU+amF2YS51dGlsLkRhdGU8L2NvZGU+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxjb2RlPmphdmEudXRpbC5DYWxlbmRhciwgamF2YS5zcWwuRGF0ZTwvY29kZT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGNvZGU+amF2YS5zcWwuVGltZTwvY29kZT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGNvZGU+amF2YS5zcWwuVGltZXN0YW1wPC9jb2RlPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48Y29kZT5ieXRlW108L2NvZGU+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxjb2RlPkJ5dGVbXTwvY29kZT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGNvZGU+Y2hhcltdPC9jb2RlPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48Y29kZT5DaGFyYWN0ZXJbXTwvY29kZT48L3A+Ci08L2xpPgotPGxpPgotPHA+ZW51bXM8L3A+Ci08L2xpPgotPGxpPgotPHA+YW55IG90aGVyIHR5cGUgdGhhdCBpbXBsZW1lbnRzIDxjb2RlPlNlcmlhbGl6YWJsZTwvY29kZT48L3A+Ci08L2xpPgotPC91bD4KLTxwPlRvIGNyZWF0ZSBhIGJhc2ljIG1hcHBpbmc6PC9wPgotPG9sIHN0YXJ0PSIxIj4KLTxsaT4KLTxwPkluIHRoZSA8YSBocmVmPSJyZWZfcGVyc2lzdGVuY2Vfb3V0bGluZS5odG0jQkFCRUdHRkUiPkpQQSBTdHJ1Y3R1cmUgdmlldzwvYT4sIHJpZ2h0LWNsaWNrIHRoZSBmaWVsZCB0byBtYXAuIFNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+TWFwIEFzICZndDsgQmFzaWM8L3NwYW4+LiBUaGUgPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSNCQUJJRkJBRiI+SlBBIERldGFpbHMgdmlldyAoZm9yIGF0dHJpYnV0ZXMpPC9hPiBkaXNwbGF5cyB0aGUgcHJvcGVydGllcyBmb3IgdGhlIHNlbGVjdGVkIGZpZWxkLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5Vc2UgdGhpcyB0YWJsZSB0byBjb21wbGV0ZSB0aGUgcmVtYWluaW5nIGZpZWxkcyBvbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpQQSBEZXRhaWxzPC9zcGFuPiB2aWV3LjwvcD4KLTxkaXYgY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCI+Ci08dGFibGUgY2xhc3M9IlJ1bGVJbmZvcm1hbCIgdGl0bGU9IlRoaXMgdGFibGUgbGlzdHMgdGhlIGZpZWxkcyBpbiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyB2aWV3IGZvciB0aGlzIG1hcHBpbmcuIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGxpc3RzIHRoZSBmaWVsZHMgaW4gdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldyBmb3IgdGhpcyBtYXBwaW5nLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQxNSI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDE1Ij5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10MTUiPkRlZmF1bHQ8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDE1IiBoZWFkZXJzPSJyMWMxLXQxNSI+RW50aXR5IE1hcCBIeXBlcmxpbms8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQxNSByMWMyLXQxNSI+RGVmaW5lcyB0aGlzIG1hcHBpbmcgYXMgYSA8c3BhbiBjbGFzcz0iYm9sZCI+QmFzaWMgTWFwcGluZzwvc3Bhbj4uCi08cD5UaGlzIGNvcnJlc3BvbmRzIHRvIHRoZSA8Y29kZT5AQmFzaWM8L2NvZGU+IGFubm90YXRpb24uPC9wPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MTUgcjFjMy10MTUiPkJhc2ljPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDE1IiBoZWFkZXJzPSJyMWMxLXQxNSI+Q29sdW1uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MTUgcjFjMi10MTUiPlRoZSBkYXRhYmFzZSBjb2x1bW4gbWFwcGVkIHRvIHRoZSBlbnRpdHkgYXR0cmlidXRlLiBTZWUgPGEgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jQ0FDR0NCSEIiPiJDb2x1bW4iPC9hPiBmb3IgZGV0YWlscy48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQxNSByMWMzLXQxNSI+QnkgZGVmYXVsdCwgdGhlIENvbHVtbiBpcyBhc3N1bWVkIHRvIGJlIG5hbWVkIGlkZW50aWNhbGx5IHRvIHRoZSBhdHRyaWJ1dGUgYW5kIGFsd2F5cyBpbmNsdWRlZCBpbiB0aGUgPGNvZGU+SU5TRVJUPC9jb2RlPiBhbmQgPGNvZGU+VVBEQVRFPC9jb2RlPiBzdGF0ZW1lbnRzLjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNGMxLXQxNSIgaGVhZGVycz0icjFjMS10MTUiPlRhYmxlPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MTUgcjFjMi10MTUiPk5hbWUgb2YgdGhlIGRhdGFiYXNlIHRhYmxlLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDE1IHIxYzMtdDE1Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjVjMS10MTUiIGhlYWRlcnM9InIxYzEtdDE1Ij5GZXRjaDwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDE1IHIxYzItdDE1Ij5EZWZpbmVzIGhvdyBkYXRhIGlzIGxvYWRlZCBmcm9tIHRoZSBkYXRhYmFzZS4gU2VlIDxhIGhyZWY9InJlZl9tYXBwaW5nX2dlbmVyYWwuaHRtI0NBQ0dHR0hCIj4iRmV0Y2ggVHlwZSI8L2E+IGZvciBkZXRhaWxzLgotPHVsPgotPGxpPgotPHA+RWFnZXI8L3A+Ci08L2xpPgotPGxpPgotPHA+TGF6eTwvcD4KLTwvbGk+Ci08L3VsPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MTUgcjFjMy10MTUiPkVhZ2VyPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI2YzEtdDE1IiBoZWFkZXJzPSJyMWMxLXQxNSI+T3B0aW9uYWw8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQxNSByMWMyLXQxNSI+U3BlY2lmaWVzIGlmIHRoaXMgZmllbGQgaXMgY2FuIGJlIG51bGwuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10MTUgcjFjMy10MTUiPlllczwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyN2MxLXQxNSIgaGVhZGVycz0icjFjMS10MTUiPlRlbXBvcmFsPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjdjMS10MTUgcjFjMi10MTUiPlNwZWNpZmllcyB0aGUgdHlwZSBvZiBkYXRhLiBTZWUgPGEgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jQ0FDRUFKR0QiPiJUZW1wb3JhbCI8L2E+IGZvciBkZXRhaWxzLgotPHVsPgotPGxpPgotPHA+RGF0ZTwvcD4KLTwvbGk+Ci08bGk+Ci08cD5UaW1lPC9wPgotPC9saT4KLTxsaT4KLTxwPlRpbWVzdGFtcDwvcD4KLTwvbGk+Ci08L3VsPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjdjMS10MTUgcjFjMy10MTUiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyOGMxLXQxNSIgaGVhZGVycz0icjFjMS10MTUiPkxvYjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI4YzEtdDE1IHIxYzItdDE1Ij5TcGVjaWZpZXMgaWYgdGhpcyBpcyBhIGxhcmdlIG9iamVjdHMgKEJMT0Igb3IgQ0xPQikuIFNlZSA8YSBocmVmPSJyZWZfbWFwcGluZ19nZW5lcmFsLmh0bSNDQUNCQklCSSI+IkxvYiI8L2E+IGZvciBkZXRhaWxzLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI4YzEtdDE1IHIxYzMtdDE1Ij48YnIgLz48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0YmxydWxlaW5mb3JtYWwiIC0tPjwvbGk+Ci08L29sPgotPHA+RWNsaXBzZSBhZGRzIHRoZSBmb2xsb3dpbmcgYW5ub3RhdGlvbnMgdG8gdGhlIGZpZWxkOjwvcD4KLTxwcmUgeG1sOnNwYWNlPSJwcmVzZXJ2ZSIgY2xhc3M9Im9hY19ub193YXJuIj4KLUBDb2x1bW4obmFtZT0iPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O0NPTFVNTl9OQU1FJmd0Ozwvc3Bhbj4iLCB0YWJsZT0iPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O0NPTFVNTl9UQUJMRSZndDs8L3NwYW4+IiwgCi0gICAgaW5zZXJ0YWJsZT08c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7SU5TRVJUQUJMRSZndDs8L3NwYW4+LCB1cGRhdGFibGU9PHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O1VQREFUQUJMRSZndDs8L3NwYW4+KQotQEJhc2ljKGZldGNoPUZldGNoVHlwZS48c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7RkVUQ0hfVFlQRSZndDs8L3NwYW4+LCBvcHRpb25hbCA9IDxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtPUFRJT05BTCZndDs8L3NwYW4+KQotQFRlbXBvcmFsKFRlbXBvcmFsVHlwZS48c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7VEVNUE9SQUwmZ3Q7PC9zcGFuPikKLQotPC9wcmU+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrX21hcHBpbmcuaHRtI0JBQkRHQklKIj5NYXBwaW5nIGFuIGVudGl0eTwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxyLnBuZyIgYWx0PSJSZWxhdGVkIHJlZmVyZW5jZSIgdGl0bGU9IlJlbGF0ZWQgcmVmZXJlbmNlIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJyZWZfcGVyc2lzdGVuY2Vfb3V0bGluZS5odG0jQkFCRUdHRkUiPkpQQSBTdHJ1Y3R1cmUgdmlldzwvYT48YnIgLz4KLTxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0jQkFCSUZCQUYiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBhdHRyaWJ1dGVzKTwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxjLnBuZyIgYWx0PSJSZWxhdGVkIGNvbmNlcHQiIHRpdGxlPSJSZWxhdGVkIGNvbmNlcHQiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9ImNvbmNlcHRfbWFwcGluZy5odG0jQkFCQkRKRkkiPlVuZGVyc3RhbmRpbmcgT1IgbWFwcGluZ3M8L2E+PGJyIC8+Ci08YSBocmVmPSJjb25jZXB0czAwMS5odG0jQkFCQkdGSkciPlVuZGVyc3RhbmRpbmcgRUpCIDMuMCBKYXZhIFBlcnNpc3RlbmNlIEFQSTwvYT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QyIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAxMS5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMTEuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkMGQ4MzhkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAxMS5odG0KKysrIC9kZXYvbnVsbApAQCAtMSwxMDcgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDYgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5FbWJlZGRlZCBtYXBwaW5nPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iRW1iZWRkZWQgbWFwcGluZyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkJBQkNCSERGIiBuYW1lPSJCQUJDQkhERiI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QyIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+RW1iZWRkZWQgbWFwcGluZzwvaDE+Ci08cD48YSBpZD0ic3RocmVmMTAxIiBuYW1lPSJzdGhyZWYxMDEiPjwvYT48YSBpZD0ic3RocmVmMTAyIiBuYW1lPSJzdGhyZWYxMDIiPjwvYT48YSBpZD0ic3RocmVmMTAzIiBuYW1lPSJzdGhyZWYxMDMiPjwvYT48YSBpZD0ic3RocmVmMTA0IiBuYW1lPSJzdGhyZWYxMDQiPjwvYT5Vc2UgYW4gPHNwYW4gY2xhc3M9ImJvbGQiPkVtYmVkZGVkIE1hcHBpbmc8L3NwYW4+IHRvIHNwZWNpZnkgYSBwZXJzaXN0ZW50IGZpZWxkIG9yIHByb3BlcnR5IG9mIGFuIGVudGl0eSB3aG9zZSB2YWx1ZSBpcyBhbiBpbnN0YW5jZSBvZiBhbiBlbWJlZGRhYmxlIGNsYXNzLjwvcD4KLTxvbCBzdGFydD0iMSI+Ci08bGk+Ci08cD5JbiB0aGUgPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX291dGxpbmUuaHRtI0JBQkVHR0ZFIj5KUEEgU3RydWN0dXJlIHZpZXc8L2E+LCByaWdodC1jbGljayB0aGUgZmllbGQgdG8gbWFwLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5TZWxlY3QgPHNwYW4gY2xhc3M9ImJvbGQiPk1hcCBhcyAmZ3Q7IEVtYmVkZGVkPC9zcGFuPi4gVGhlIDxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0jQkFCSUZCQUYiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBhdHRyaWJ1dGVzKTwvYT4gZGlzcGxheXMgdGhlIHByb3BlcnRpZXMgZm9yIHRoZSBzZWxlY3RlZCBmaWVsZC48L3A+Ci08L2xpPgotPGxpPgotPHA+VXNlIHRoaXMgdGFibGUgdG8gY29tcGxldGUgdGhlIHJlbWFpbmluZyBmaWVsZHMgb24gdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5KUEEgRGV0YWlsczwvc3Bhbj4gdmlldy48L3A+Ci08ZGl2IGNsYXNzPSJpbmZ0YmxydWxlaW5mb3JtYWwiPgotPHRhYmxlIGNsYXNzPSJSdWxlSW5mb3JtYWwiIHRpdGxlPSJUaGlzIHRhYmxlIGxpc3RzIHRoZSBmaWVsZHMgaW4gdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldyBmb3IgdGhpcyBtYXBwaW5nLiIgc3VtbWFyeT0iVGhpcyB0YWJsZSBsaXN0cyB0aGUgZmllbGRzIGluIHRoZSBQZXJzaXN0ZW5jZSBQcm9wZXJ0aWVzIHZpZXcgZm9yIHRoaXMgbWFwcGluZy4iIGRpcj0ibHRyIiBib3JkZXI9IjEiIHdpZHRoPSIxMDAlIiBmcmFtZT0iYm9yZGVyIiBydWxlcz0iYWxsIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRoZWFkPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMS10MTYiPlByb3BlcnR5PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMyLXQxNiI+RGVzY3JpcHRpb248L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzMtdDE2Ij5EZWZhdWx0PC90aD4KLTwvdHI+Ci08L3RoZWFkPgotPHRib2R5PgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMmMxLXQxNiIgaGVhZGVycz0icjFjMS10MTYiPkVudGl0eSBNYXBwaW5nIEh5cGVybG5rPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MTYgcjFjMi10MTYiPkRlZmluZXMgdGhpcyBtYXBwaW5nIGFzIGEgPHNwYW4gY2xhc3M9ImJvbGQiPkVtYmVkZGVkPC9zcGFuPi4KLTxwPlRoaXMgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPkBFbWJlZGRlZDwvY29kZT4gYW5ub3RhdGlvbi48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQxNiByMWMzLXQxNiI+RW1iZWRkZWQ8L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10MTYiIGhlYWRlcnM9InIxYzEtdDE2Ij5BdHRyaWJ1dGUgT3ZlcnJpZGVzPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MTYgcjFjMi10MTYiPlNwZWNpZnkgdG8gb3ZlcnJpZGUgdGhlIGRlZmF1bHQgbWFwcGluZyBvZiBhbiBlbnRpdHkncyBhdHRyaWJ1dGUuIFNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+T3ZlcnJpZGUgRGVmYXVsdDwvc3Bhbj4uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MTYgcjFjMy10MTYiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNGMxLXQxNiIgaGVhZGVycz0icjFjMS10MTYiPkNvbHVtbnM8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQxNiByMWMyLXQxNiI+VGhlIGRhdGFiYXNlIGNvbHVtbiAoYW5kIGl0cyB0YWJsZSkgbWFwcGVkIHRvIHRoZSBlbnRpdHkgYXR0cmlidXRlLiBTZWUgPGEgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jQ0FDR0NCSEIiPiJDb2x1bW4iPC9hPiBmb3IgZGV0YWlscy4KLTx1bD4KLTxsaT4KLTxwPk5hbWUgJm5kYXNoOyBOYW1lIG9mIHRoZSBkYXRhYmFzZSBjb2x1bW4uPC9wPgotPC9saT4KLTxsaT4KLTxwPlRhYmxlICZuZGFzaDsgTmFtZSBvZiB0aGUgZGF0YWJhc2UgdGFibGUuPC9wPgotPC9saT4KLTwvdWw+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQxNiByMWMzLXQxNiI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIiAtLT48L2xpPgotPC9vbD4KLTxwPkVjbGlwc2UgYWRkcyB0aGUgZm9sbG93aW5nIGFubm90YXRpb25zIHRvIHRoZSBmaWVsZDo8L3A+Ci08cHJlIHhtbDpzcGFjZT0icHJlc2VydmUiIGNsYXNzPSJvYWNfbm9fd2FybiI+Ci1ARW1iZWRkZWQKLUBBdHRyaWJ1dGVPdmVycmlkZShjb2x1bW49QENvbHVtbih0YWJsZT0iPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O0NPTFVNTl9UQUJMRSZndDs8L3NwYW4+IiwgbmFtZSA9ICI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7Q09MVU1OX05BTUUmZ3Q7PC9zcGFuPiIpKQotPC9wcmU+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrX21hcHBpbmcuaHRtI0JBQkRHQklKIj5NYXBwaW5nIGFuIGVudGl0eTwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxyLnBuZyIgYWx0PSJSZWxhdGVkIHJlZmVyZW5jZSIgdGl0bGU9IlJlbGF0ZWQgcmVmZXJlbmNlIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJyZWZfcGVyc2lzdGVuY2Vfb3V0bGluZS5odG0jQkFCRUdHRkUiPkpQQSBTdHJ1Y3R1cmUgdmlldzwvYT48YnIgLz4KLTxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0jQkFCSUZCQUYiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBhdHRyaWJ1dGVzKTwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxjLnBuZyIgYWx0PSJSZWxhdGVkIGNvbmNlcHQiIHRpdGxlPSJSZWxhdGVkIGNvbmNlcHQiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9ImNvbmNlcHRfbWFwcGluZy5odG0jQkFCQkRKRkkiPlVuZGVyc3RhbmRpbmcgT1IgbWFwcGluZ3M8L2E+PGJyIC8+Ci08YSBocmVmPSJjb25jZXB0czAwMS5odG0jQkFCQkdGSkciPlVuZGVyc3RhbmRpbmcgRUpCIDMuMCBKYXZhIFBlcnNpc3RlbmNlIEFQSTwvYT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QyIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAxMi5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMTIuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2YjM1ZDljLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAxMi5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw4NyArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0NiAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPkVtYmVkZGVkIElEIG1hcHBpbmc8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJFbWJlZGRlZCBJRCBtYXBwaW5nIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQ0lIRElBRUUiIG5hbWU9IkNJSERJQUVFIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5FbWJlZGRlZCBJRCBtYXBwaW5nPC9oMT4KLTxwPjxhIGlkPSJzdGhyZWYxMDUiIG5hbWU9InN0aHJlZjEwNSI+PC9hPjxhIGlkPSJzdGhyZWYxMDYiIG5hbWU9InN0aHJlZjEwNiI+PC9hPjxhIGlkPSJzdGhyZWYxMDciIG5hbWU9InN0aHJlZjEwNyI+PC9hPjxhIGlkPSJzdGhyZWYxMDgiIG5hbWU9InN0aHJlZjEwOCI+PC9hPlVzZSBhbiA8c3BhbiBjbGFzcz0iYm9sZCI+RW1iZWRkZWQgSUQgTWFwcGluZzwvc3Bhbj4gdG8gc3BlY2lmeSB0aGUgcHJpbWFyeSBrZXkgb2YgYW4gZW1iZWRkZWQgSUQuIFRoZXNlIG1hcHBpbmdzIG1heSBiZSB1c2VkIHdpdGggYSA8YSBocmVmPSJ0YXNrczAwNy5odG0jQkFCRkVJQ0UiPkVtYmVkZGFibGU8L2E+IGVudGl0aWVzLjwvcD4KLTxvbCBzdGFydD0iMSI+Ci08bGk+Ci08cD5JbiB0aGUgPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX291dGxpbmUuaHRtI0JBQkVHR0ZFIj5KUEEgU3RydWN0dXJlIHZpZXc8L2E+LCBzZWxlY3QgdGhlIGZpZWxkIHRvIG1hcC48L3A+Ci08L2xpPgotPGxpPgotPHA+UmlnaHQtY2xpY2sgdGhlIGZpZWxkIGFuZCB0aGVuIHNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+TWFwIEFzICZndDsgRW1iZWRkZWQgSWQ8L3NwYW4+LiBUaGUgPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSNCQUJJRkJBRiI+SlBBIERldGFpbHMgdmlldyAoZm9yIGF0dHJpYnV0ZXMpPC9hPiBkaXNwbGF5cyB0aGUgcHJvcGVydGllcyBmb3IgdGhlIHNlbGVjdGVkIGZpZWxkLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5Vc2UgdGhpcyB0YWJsZSB0byBjb21wbGV0ZSB0aGUgcmVtYWluaW5nIGZpZWxkcyBvbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpQQSBEZXRhaWxzPC9zcGFuPiB2aWV3LjwvcD4KLTxkaXYgY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCI+Ci08dGFibGUgY2xhc3M9IlJ1bGVJbmZvcm1hbCIgdGl0bGU9IlRoaXMgdGFibGUgbGlzdHMgdGhlIGZpZWxkcyBpbiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyB2aWV3IGZvciB0aGlzIG1hcHBpbmcuIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGxpc3RzIHRoZSBmaWVsZHMgaW4gdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldyBmb3IgdGhpcyBtYXBwaW5nLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQxNyI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDE3Ij5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10MTciPkRlZmF1bHQ8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDE3IiBoZWFkZXJzPSJyMWMxLXQxNyI+RW50aXR5IE1hcHBpbmcgSHlwZXJsaW5rPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MTcgcjFjMi10MTciPkRlZmluZXMgdGhpcyBtYXBwaW5nIGFzIGEgPHNwYW4gY2xhc3M9ImJvbGQiPkVtYmVkZGVkIElkPC9zcGFuPi4KLTxwPlRoaXMgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPkBFbWJlZGRlZElkPC9jb2RlPiBhbm5vdGF0aW9uLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDE3IHIxYzMtdDE3Ij5FbWJlZGRlZCBJZDwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCIgLS0+PC9saT4KLTwvb2w+Ci08cD5FY2xpcHNlIGFkZHMgdGhlIGZvbGxvd2luZyBhbm5vdGF0aW9ucyB0byB0aGUgZmllbGQ6PC9wPgotPHByZSB4bWw6c3BhY2U9InByZXNlcnZlIiBjbGFzcz0ib2FjX25vX3dhcm4iPgotQEVtYmVkZGVkSWQKLTwvcHJlPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza19tYXBwaW5nLmh0bSNCQUJER0JJSiI+TWFwcGluZyBhbiBlbnRpdHk8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsci5wbmciIGFsdD0iUmVsYXRlZCByZWZlcmVuY2UiIHRpdGxlPSJSZWxhdGVkIHJlZmVyZW5jZSIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX291dGxpbmUuaHRtI0JBQkVHR0ZFIj5KUEEgU3RydWN0dXJlIHZpZXc8L2E+PGJyIC8+Ci08YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtI0JBQklGQkFGIj5KUEEgRGV0YWlscyB2aWV3IChmb3IgYXR0cmlidXRlcyk8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsYy5wbmciIGFsdD0iUmVsYXRlZCBjb25jZXB0IiB0aXRsZT0iUmVsYXRlZCBjb25jZXB0IiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJjb25jZXB0X21hcHBpbmcuaHRtI0JBQkJESkZJIj5VbmRlcnN0YW5kaW5nIE9SIG1hcHBpbmdzPC9hPjxiciAvPgotPGEgaHJlZj0iY29uY2VwdHMwMDEuaHRtI0JBQkJHRkpHIj5VbmRlcnN0YW5kaW5nIEVKQiAzLjAgSmF2YSBQZXJzaXN0ZW5jZSBBUEk8L2E+PC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MiIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMTMuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDEzLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYjg1OTJkOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMTMuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsMTY5ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQ2IC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+SUQgbWFwcGluZzwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IklEIG1hcHBpbmciIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJCQUJHQ0JIRyIgbmFtZT0iQkFCR0NCSEciPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MiI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPklEIG1hcHBpbmc8L2gxPgotPHA+PGEgaWQ9InN0aHJlZjEwOSIgbmFtZT0ic3RocmVmMTA5Ij48L2E+PGEgaWQ9InN0aHJlZjExMCIgbmFtZT0ic3RocmVmMTEwIj48L2E+PGEgaWQ9InN0aHJlZjExMSIgbmFtZT0ic3RocmVmMTExIj48L2E+PGEgaWQ9InN0aHJlZjExMiIgbmFtZT0ic3RocmVmMTEyIj48L2E+VXNlIGFuIDxzcGFuIGNsYXNzPSJib2xkIj5JRCBNYXBwaW5nPC9zcGFuPiB0byBzcGVjaWZ5IHRoZSBwcmltYXJ5IGtleSBvZiBhbiBlbnRpdHkuIElEIG1hcHBpbmdzIG1heSBiZSB1c2VkIHdpdGggYSA8YSBocmVmPSJ0YXNrczAwNi5odG0jQkFCR0JJRUUiPkVudGl0eTwvYT4gb3IgPGEgaHJlZj0idGFza3MwMDguaHRtI0JBQkRBR0NJIj5NYXBwZWQgc3VwZXJjbGFzczwvYT4uIEVhY2ggPGEgaHJlZj0idGFza3MwMDYuaHRtI0JBQkdCSUVFIj5FbnRpdHk8L2E+IG11c3QgaGF2ZSBhbiBJRCBtYXBwaW5nLjwvcD4KLTxvbCBzdGFydD0iMSI+Ci08bGk+Ci08cD5JbiB0aGUgPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX291dGxpbmUuaHRtI0JBQkVHR0ZFIj5KUEEgU3RydWN0dXJlIHZpZXc8L2E+LCBzZWxlY3QgdGhlIGZpZWxkIHRvIG1hcC48L3A+Ci08L2xpPgotPGxpPgotPHA+UmlnaHQgY2xpY2sgdGhlIGZpbGVkIGFuZCB0aGVuIHNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+TWFwIGFzICZndDsgSUQ8L3NwYW4+LiBUaGUgPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSNCQUJJRkJBRiI+SlBBIERldGFpbHMgdmlldyAoZm9yIGF0dHJpYnV0ZXMpPC9hPiBkaXNwbGF5cyB0aGUgcHJvcGVydGllcyBmb3IgdGhlIHNlbGVjdGVkLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5Vc2UgdGhpcyB0YWJsZSB0byBjb21wbGV0ZSB0aGUgPGEgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jQ0FDQkhGSUoiPkdlbmVyYWwgaW5mb3JtYXRpb248L2E+IGZpZWxkcyBpbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpQQSBEZXRhaWxzPC9zcGFuPiB2aWV3LjwvcD4KLTxkaXYgY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCI+Ci08dGFibGUgY2xhc3M9IlJ1bGVJbmZvcm1hbCIgdGl0bGU9IlRoaXMgdGFibGUgbGlzdHMgdGhlIGZpZWxkcyBpbiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyB2aWV3IGZvciB0aGlzIG1hcHBpbmcuIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGxpc3RzIHRoZSBmaWVsZHMgaW4gdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldyBmb3IgdGhpcyBtYXBwaW5nLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQxOCI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDE4Ij5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10MTgiPkRlZmF1bHQ8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDE4IiBoZWFkZXJzPSJyMWMxLXQxOCI+RW50aXR5IE1hcHBpbmcgSHlwZXJsaW5rPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MTggcjFjMi10MTgiPkRlZmluZXMgdGhpcyBtYXBwaW5nIGFzIGFuIDxzcGFuIGNsYXNzPSJib2xkIj5JRCBNYXBwaW5nPC9zcGFuPi4KLTxwPlRoaXMgZmllbGQgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPkBJZDwvY29kZT4gYW5ub3RhdGlvbi48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQxOCByMWMzLXQxOCI+SUQ8L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10MTgiIGhlYWRlcnM9InIxYzEtdDE4Ij5Db2x1bW48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQxOCByMWMyLXQxOCI+VGhlIGRhdGFiYXNlIGNvbHVtbiBtYXBwZWQgdG8gdGhlIGVudGl0eSBhdHRyaWJ1dGUuIFNlZSA8YSBocmVmPSJyZWZfbWFwcGluZ19nZW5lcmFsLmh0bSNDQUNHQ0JIQiI+IkNvbHVtbiI8L2E+IGZvciBkZXRhaWxzLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDE4IHIxYzMtdDE4Ij5CeSBkZWZhdWx0LCB0aGUgQ29sdW1uIGlzIGFzc3VtZWQgdG8gYmUgbmFtZWQgaWRlbnRpY2FsbHkgdG8gdGhlIGF0dHJpYnV0ZS48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjRjMS10MTgiIGhlYWRlcnM9InIxYzEtdDE4Ij5UYWJsZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDE4IHIxYzItdDE4Ij5UaGUgZGF0YWJhc2UgdGFibGUgbWFwcGVkIHRvIHRoZSBlbnRpdHkgYXR0cmlidXRlLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDE4IHIxYzMtdDE4Ij5CeSBkZWZhdWx0LCB0aGUgVGFibGUgaXMgYXNzdW1lZCB0byBiZSBpZGVudGljYWwgdG8gdGhlIHRhYmxlIGFzc29jaWF0ZWQgd2l0aCB0aGUgZW50aXR5LjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNWMxLXQxOCIgaGVhZGVycz0icjFjMS10MTgiPlRlbXBvcmFsPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MTggcjFjMi10MTgiPlNwZWNpZmllcyB0aGUgdHlwZSBvZiBkYXRhLiBTZWUgPGEgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jQ0FDRUFKR0QiPiJUZW1wb3JhbCI8L2E+IGZvciBkZXRhaWxzLgotPHVsPgotPGxpPgotPHA+RGF0ZTwvcD4KLTwvbGk+Ci08bGk+Ci08cD5UaW1lPC9wPgotPC9saT4KLTxsaT4KLTxwPlRpbWVzdGFtcDwvcD4KLTwvbGk+Ci08L3VsPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MTggcjFjMy10MTgiPjxiciAvPjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCIgLS0+PC9saT4KLTxsaT4KLTxwPlVzZSB0aGlzIHRhYmxlIHRvIGNvbXBsZXRlIHRoZSBmaWVsZHMgaW4gPGEgaHJlZj0icmVmX3ByaW1hcnlfa2V5Lmh0bSNDQUNGQ0NBQiI+UHJpbWFyeSBLZXkgR2VuZXJhdGlvbiBpbmZvcm1hdGlvbjwvYT4gYXJlYSBpbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpQQSBEZXRhaWxzPC9zcGFuPiB2aWV3LjwvcD4KLTxkaXYgY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCI+Ci08dGFibGUgY2xhc3M9IlJ1bGVJbmZvcm1hbCIgdGl0bGU9IlRoaXMgdGFibGUgbGlzdHMgdGhlIGZpZWxkcyBpbiB0aGUgUEsgR2VuZXJhdGlvbiB0YWIuIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGxpc3RzIHRoZSBmaWVsZHMgaW4gdGhlIFBLIEdlbmVyYXRpb24gdGFiLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQxOSI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDE5Ij5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10MTkiPkRlZmF1bHQ8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDE5IiBoZWFkZXJzPSJyMWMxLXQxOSI+UHJpbWFyeSBLZXkgR2VuZXJhdGlvbjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDE5IHIxYzItdDE5Ij5UaGVzZSBmaWVsZHMgZGVmaW5lIGhvdyB0aGUgcHJpbWFyeSBrZXkgaXMgZ2VuZXJhdGVkLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDE5IHIxYzMtdDE5Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10MTkiIGhlYWRlcnM9InIxYzEtdDE5Ij4mbmJzcDsmbmJzcDtTdHJhdGVneTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDE5IHIxYzItdDE5Ij5TZWUgPGEgaHJlZj0icmVmX3ByaW1hcnlfa2V5Lmh0bSNDQUNCQUpCQyI+IlByaW1hcnkgS2V5IEdlbmVyYXRpb24iPC9hPiBmb3IgZGV0YWlscy4KLTx1bD4KLTxsaT4KLTxwPkF1dG88L3A+Ci08L2xpPgotPGxpPgotPHA+U2VxdWVuY2U8L3A+Ci08L2xpPgotPGxpPgotPHA+SWRlbnRpdHk8L3A+Ci08L2xpPgotPGxpPgotPHA+VGFibGU8L3A+Ci08L2xpPgotPC91bD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDE5IHIxYzMtdDE5Ij5BdXRvPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI0YzEtdDE5IiBoZWFkZXJzPSJyMWMxLXQxOSI+Jm5ic3A7Jm5ic3A7R2VuZXJhdG9yJm5ic3A7TmFtZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDE5IHIxYzItdDE5Ij5OYW1lIG9mIHRoZSBwcmltYXJ5IGtleSBnZW5lcmF0b3Igc3BlY2lmaWVkIGluIHRoZSA8c3BhbiBjbGFzcz0iYm9sZCI+U3RyYXRlZ3k8L3NwYW4+PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MTkgcjFjMy10MTkiPjxiciAvPjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCIgLS0+PC9saT4KLTwvb2w+Ci08cD5BZGRpdGlvbmFsIGZpZWxkcyB3aWxsIGFwcGVhciBpbiB0aGUgPGEgaHJlZj0icmVmX3ByaW1hcnlfa2V5Lmh0bSNDQUNGQ0NBQiI+UHJpbWFyeSBLZXkgR2VuZXJhdGlvbiBpbmZvcm1hdGlvbjwvYT4gYXJlYSwgZGVwZW5kaW5nIG9uIHRoZSBzZWxlY3RlZCBTdHJhdGVneS4gU2VlIDxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0jQkFCSUZCQUYiPiJKUEEgRGV0YWlscyB2aWV3IChmb3IgYXR0cmlidXRlcykiPC9hPiBmb3IgYWRkaXRpb25hbCBpbmZvcm1hdGlvbi48L3A+Ci08cD5FY2xpcHNlIGFkZHMgdGhlIGZvbGxvd2luZyBhbm5vdGF0aW9ucyB0byB0aGUgZmllbGQ6PC9wPgotPHByZSB4bWw6c3BhY2U9InByZXNlcnZlIiBjbGFzcz0ib2FjX25vX3dhcm4iPgotQElkCi1AQ29sdW1uKG5hbWU9IjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtDT0xVTU5fTkFNRSZndDs8L3NwYW4+IiwgdGFibGU9IjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtUQUJMRV9OQU1FJmd0Ozwvc3Bhbj4iLCBpbnNlcnRhYmxlPTxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtJTlNFUlRBQkxFJmd0Ozwvc3Bhbj4sCi0gICAgdXBkYXRhYmxlPTxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtVUERBVEFCTEUmZ3Q7PC9zcGFuPikKLUBUZW1wb3JhbCg8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7VEVNUE9SQUwmZ3Q7PC9zcGFuPikKLUBHZW5lcmF0ZWRWYWx1ZShzdHJhdGVneT1HZW5lcmF0b3JUeXBlLjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtTVFJBVEVHWSZndDs8L3NwYW4+LCBnZW5lcmF0b3I9IjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtHRU5FUkFUT1JfTkFNRSZndDs8L3NwYW4+IilAVGFibGVHZW5lcmF0b3IobmFtZT0iPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O1RBQkxFX0dFTkVSQVRPUl9OQU1FJmd0Ozwvc3Bhbj4iLCB0YWJsZSA9ICI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7VEFCTEVfR0VORVJBVE9SX1RBQkxFJmd0Ozwvc3Bhbj4iLCAKLSAgICBwa0NvbHVtbk5hbWUgPSAiPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O1RBQkxFX0dFTkVSQVRPUl9QSyZndDs8L3NwYW4+IiwgCi0gICAgdmFsdWVDb2x1bW5OYW1lID0gIjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtUQUJMRV9HRU5FUkFUT1JfVkFMVUVfQ09MVU1OJmd0Ozwvc3Bhbj4iLCAKLSAgICBwa0NvbHVtblZhbHVlID0gIjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtUQUJMRV9HRU5FUkFUT1JfUEtfQ09MVU1OX1ZBTFVFJmd0Ozwvc3Bhbj4iKUBTZXF1ZW5jZUdlbmVyYXRvcihuYW1lPSI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7U0VRVUVOQ0VfR0VORVJBVE9SX05BTUUmZ3Q7PC9zcGFuPiIsIAotICAgIHNlcXVlbmNlTmFtZT0iPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O1NFUVVFTkNFX0dFTkVSQVRPUl9TRVFVRU5DRSZndDs8L3NwYW4+IikKLTwvcHJlPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza19tYXBwaW5nLmh0bSNCQUJER0JJSiI+TWFwcGluZyBhbiBlbnRpdHk8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsci5wbmciIGFsdD0iUmVsYXRlZCByZWZlcmVuY2UiIHRpdGxlPSJSZWxhdGVkIHJlZmVyZW5jZSIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX291dGxpbmUuaHRtI0JBQkVHR0ZFIj5KUEEgU3RydWN0dXJlIHZpZXc8L2E+PGJyIC8+Ci08YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtI0JBQklGQkFGIj5KUEEgRGV0YWlscyB2aWV3IChmb3IgYXR0cmlidXRlcyk8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsYy5wbmciIGFsdD0iUmVsYXRlZCBjb25jZXB0IiB0aXRsZT0iUmVsYXRlZCBjb25jZXB0IiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJjb25jZXB0X21hcHBpbmcuaHRtI0JBQkJESkZJIj5VbmRlcnN0YW5kaW5nIE9SIG1hcHBpbmdzPC9hPjxiciAvPgotPGEgaHJlZj0iY29uY2VwdHMwMDEuaHRtI0JBQkJHRkpHIj5VbmRlcnN0YW5kaW5nIEVKQiAzLjAgSmF2YSBQZXJzaXN0ZW5jZSBBUEk8L2E+PC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MiIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMTQuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDE0Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTFiNmFlOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMTQuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsMTcyICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQ3IC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+TWFueS10by1tYW55IG1hcHBpbmc8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJNYW55LXRvLW1hbnkgbWFwcGluZyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkJBQkVJRUdEIiBuYW1lPSJCQUJFSUVHRCI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QyIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+TWFueS10by1tYW55IG1hcHBpbmc8L2gxPgotPHA+PGEgaWQ9InN0aHJlZjExMyIgbmFtZT0ic3RocmVmMTEzIj48L2E+PGEgaWQ9InN0aHJlZjExNCIgbmFtZT0ic3RocmVmMTE0Ij48L2E+PGEgaWQ9InN0aHJlZjExNSIgbmFtZT0ic3RocmVmMTE1Ij48L2E+PGEgaWQ9InN0aHJlZjExNiIgbmFtZT0ic3RocmVmMTE2Ij48L2E+VXNlIGEgPHNwYW4gY2xhc3M9ImJvbGQiPk1hbnktdG8tTWFueSBNYXBwaW5nPC9zcGFuPiB0byBkZWZpbmUgYSBtYW55LXZhbHVlZCBhc3NvY2lhdGlvbiB3aXRoIG1hbnktdG8tbWFueSBtdWx0aXBsaWNpdHkuIEEgbWFueS10by1tYW55IG1hcHBpbmcgaGFzIHR3byBzaWRlczogdGhlIDxzcGFuIGNsYXNzPSJpdGFsaWMiPm93bmluZyBzaWRlPC9zcGFuPiBhbmQgPHNwYW4gY2xhc3M9Iml0YWxpYyI+bm9uLW93bmluZyBzaWRlPC9zcGFuPi4gWW91IG11c3Qgc3BlY2lmeSB0aGUgam9pbiB0YWJsZSBvbiB0aGUgb3duaW5nIHNpZGUuIEZvciBiaWRpcmVjdGlvbmFsIG1hcHBpbmdzLCBlaXRoZXIgc2lkZSBtYXkgYmUgdGhlIG93bmluZyBzaWRlLjwvcD4KLTxvbCBzdGFydD0iMSI+Ci08bGk+Ci08cD5JbiB0aGUgPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX291dGxpbmUuaHRtI0JBQkVHR0ZFIj5KUEEgU3RydWN0dXJlIHZpZXc8L2E+LCBzZWxlY3QgdGhlIGZpZWxkIHRvIG1hcC48L3A+Ci08L2xpPgotPGxpPgotPHA+UmlnaHQtY2xpY2sgdGhlIGZpZWxkIGFuZCB0aGVuIHNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+TWFwIEFzICZndDsgTWFueS10b01hbnk8L3NwYW4+LiBUaGUgPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSNCQUJJRkJBRiI+SlBBIERldGFpbHMgdmlldyAoZm9yIGF0dHJpYnV0ZXMpPC9hPiBkaXNwbGF5cyB0aGUgcHJvcGVydGllcyBmb3IgdGhlIHNlbGVjdGVkIGZpZWxkLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5Vc2UgdGhpcyB0YWJsZSB0byBjb21wbGV0ZSB0aGUgPGEgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jQ0FDQkhGSUoiPkdlbmVyYWwgaW5mb3JtYXRpb248L2E+IGZpZWxkcyBvZiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpQQSBEZXRhaWxzPC9zcGFuPiB2aWV3LjwvcD4KLTxkaXYgY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCI+Ci08dGFibGUgY2xhc3M9IlJ1bGVJbmZvcm1hbCIgdGl0bGU9IlRoaXMgdGFibGUgbGlzdHMgdGhlIGZpZWxkcyBpbiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyB2aWV3IGZvciB0aGlzIG1hcHBpbmcuIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGxpc3RzIHRoZSBmaWVsZHMgaW4gdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldyBmb3IgdGhpcyBtYXBwaW5nLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQyMCI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDIwIj5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10MjAiPkRlZmF1bHQ8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDIwIiBoZWFkZXJzPSJyMWMxLXQyMCI+TWFwcGluZyBFbnRpdHkgSHlwZXJsaW5rPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MjAgcjFjMi10MjAiPkRlZmluZXMgdGhpcyBtYXBwaW5nIGFzIGEgPHNwYW4gY2xhc3M9ImJvbGQiPk1hbnkgdG8gTWFueSBNYXBwaW5nPC9zcGFuPi4KLTxwPlRoaXMgZmllbGQgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPkBNYW55VG9NYW55PC9jb2RlPiBhbm5vdGF0aW9uLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDIwIHIxYzMtdDIwIj5NYW55IHRvIE1hbnk8L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10MjAiIGhlYWRlcnM9InIxYzEtdDIwIj5UYXJnZXQgRW50aXR5PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MjAgcjFjMi10MjAiPlRoZSBlbnRpdHkgdG8gd2hpY2ggdGhpcyBhdHRyaWJ1dGUgaXMgbWFwcGVkLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDIwIHIxYzMtdDIwIj5udWxsCi08cD5Zb3UgZG8gbm90IG5lZWQgdG8gZXhwbGljaXRseSBzcGVjaWZ5IHRoZSB0YXJnZXQgZW50aXR5LCBzaW5jZSBpdCBjYW4gYmUgaW5mZXJyZWQgZnJvbSB0aGUgdHlwZSBvZiBvYmplY3QgYmVpbmcgcmVmZXJlbmNlZC48L3A+Ci08L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjRjMS10MjAiIGhlYWRlcnM9InIxYzEtdDIwIj5GZXRjaDwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDIwIHIxYzItdDIwIj5EZWZpbmVzIGhvdyBkYXRhIGlzIGxvYWRlZCBmcm9tIHRoZSBkYXRhYmFzZS4gU2VlIDxhIGhyZWY9InJlZl9tYXBwaW5nX2dlbmVyYWwuaHRtI0NBQ0dHR0hCIj4iRmV0Y2ggVHlwZSI8L2E+IGZvciBkZXRhaWxzLgotPHVsPgotPGxpPgotPHA+RWFnZXI8L3A+Ci08L2xpPgotPGxpPgotPHA+TGF6eTwvcD4KLTwvbGk+Ci08L3VsPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MjAgcjFjMy10MjAiPkxhenk8L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjVjMS10MjAiIGhlYWRlcnM9InIxYzEtdDIwIj5NYXBwZWQgQnk8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQyMCByMWMyLXQyMCI+VGhlIGRhdGFiYXNlIGZpZWxkIHRoYXQgb3ducyB0aGUgcmVsYXRpb25zaGlwLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI1YzEtdDIwIHIxYzMtdDIwIj48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjZjMS10MjAiIGhlYWRlcnM9InIxYzEtdDIwIj5PcmRlciBCeTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI2YzEtdDIwIHIxYzItdDIwIj5TcGVjaWZ5IHRoZSBkZWZhdWx0IG9yZGVyIGZvciBvYmplY3RzIHJldHVybmVkIGZyb20gYSBxdWVyeS4gU2VlIDxhIGhyZWY9InJlZl9tYXBwaW5nX2dlbmVyYWwuaHRtI0NBQ0RBRElIIj4iT3JkZXIgQnkiPC9hPiBmb3IgZGV0YWlscy4KLTx1bD4KLTxsaT4KLTxwPk5vIG9yZGVyaW5nPC9wPgotPC9saT4KLTxsaT4KLTxwPlByaW1hcnkga2V5PC9wPgotPC9saT4KLTxsaT4KLTxwPkN1c3RvbTwvcD4KLTwvbGk+Ci08L3VsPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjZjMS10MjAgcjFjMy10MjAiPk5vIG9yZGVyaW5nPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIiAtLT48L2xpPgotPGxpPgotPHA+VXNlIHRoaXMgdGFibGUgdG8gY29tcGxldGUgdGhlIGZpZWxkcyBpbiB0aGUgPGEgaHJlZj0icmVmZXJlbmNlMDE0Lmh0bSNDQUNCQUVCQyI+Sm9pbiBUYWJsZSBJbmZvcm1hdGlvbjwvYT4gYXJlYSBpbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkpQQSBEZXRhaWxzPC9zcGFuPiB2aWV3LjwvcD4KLTxkaXYgY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCI+Ci08dGFibGUgY2xhc3M9IlJ1bGVJbmZvcm1hbCIgdGl0bGU9IlRoaXMgdGFibGUgbGlzdHMgdGhlIGZpZWxkcyBpbiB0aGUgSm9pbiBUYWJsZSB0YWIgb2YgdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldyBmb3IgdGhpcyBtYXBwaW5nLiIgc3VtbWFyeT0iVGhpcyB0YWJsZSBsaXN0cyB0aGUgZmllbGRzIGluIHRoZSBKb2luIFRhYmxlIHRhYiBvZiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyB2aWV3IGZvciB0aGlzIG1hcHBpbmcuIiBkaXI9Imx0ciIgYm9yZGVyPSIxIiB3aWR0aD0iMTAwJSIgZnJhbWU9ImJvcmRlciIgcnVsZXM9ImFsbCIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0aGVhZD4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzEtdDIxIj5Qcm9wZXJ0eTwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMi10MjEiPkRlc2NyaXB0aW9uPC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMzLXQyMSI+RGVmYXVsdDwvdGg+Ci08L3RyPgotPC90aGVhZD4KLTx0Ym9keT4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjJjMS10MjEiIGhlYWRlcnM9InIxYzEtdDIxIj5OYW1lPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MjEgcjFjMi10MjEiPk5hbWUgb2YgdGhlIGpvaW4gdGFibGUgdGhhdCBjb250YWlucyB0aGUgZm9yZWlnbiBrZXkgY29sdW1uLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDIxIHIxYzMtdDIxIj5Zb3UgbXVzdCBzcGVjaWZ5IHRoZSBqb2luIHRhYmxlIG9uIHRoZSBvd25pbmcgc2lkZS4KLTxwPkJ5IGRlZmF1bHQsIHRoZSBuYW1lIGlzIGFzc3VtZWQgdG8gYmUgdGhlIHByaW1hcnkgdGFibGVzIGFzc29jaWF0ZWQgd2l0aCB0aGUgZW50aXRpZXMgY29uY2F0ZW5hdGVkIHdpdGggYW4gdW5kZXJzY29yZS48L3A+Ci08L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10MjEiIGhlYWRlcnM9InIxYzEtdDIxIj5Kb2luIENvbHVtbnM8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQyMSByMWMyLXQyMSI+U2VsZWN0IDxzcGFuIGNsYXNzPSJib2xkIj5PdmVycmlkZSBEZWZhdWx0PC9zcGFuPiwgdGhlbiBBZGQsIEVkaXQsIG9yIFJlbW92ZSB0aGUgam9pbiBjb2x1bW5zLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDIxIHIxYzMtdDIxIj5CeSBkZWZhdWx0LCB0aGUgbmFtZSBpcyBhc3N1bWVkIHRvIGJlIHRoZSBwcmltYXJ5IHRhYmxlcyBhc3NvY2lhdGVkIHdpdGggdGhlIGVudGl0aWVzIGNvbmNhdGVuYXRlZCB3aXRoIGFuIHVuZGVyc2NvcmUuPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI0YzEtdDIxIiBoZWFkZXJzPSJyMWMxLXQyMSI+SW52ZXJzZSBKb2luIENvbHVtbnM8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQyMSByMWMyLXQyMSI+U2VsZWN0IDxzcGFuIGNsYXNzPSJib2xkIj5PdmVycmlkZSBEZWZhdWx0PC9zcGFuPiwgdGhlbiBBZGQsIEVkaXQsIG9yIFJlbW92ZSB0aGUgam9pbiBjb2x1bW5zLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDIxIHIxYzMtdDIxIj5CeSBkZWZhdWx0LCB0aGUgbWFwcGluZyBpcyBhc3N1bWVkIHRvIGhhdmUgYSBzaW5nbGUgam9pbi48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0YmxydWxlaW5mb3JtYWwiIC0tPjwvbGk+Ci08bGk+Ci08cD5UbyBhZGQgYSBuZXcgSm9pbiBvciBJbnZlcnNlIEpvaW4gQ29sdW1uLCBjbGljayA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC1hY3Rpb24iPkFkZDwvc3Bhbj4uPC9wPgotPHA+VG8gZWRpdCBhbiBleGlzdGluZyBKb2luIG9yIEludmVyc2UgSm9pbiBDb2x1bW4sIHNlbGVjdCB0aGUgZmllbGQgdG8gYW5kIGNsaWNrIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LWFjdGlvbiI+RWRpdDwvc3Bhbj4uPC9wPgotPC9saT4KLTwvb2w+Ci08cD5FY2xpcHNlIGFkZHMgdGhlIGZvbGxvd2luZyBhbm5vdGF0aW9ucyB0byB0aGUgZmllbGQ6PC9wPgotPHByZSB4bWw6c3BhY2U9InByZXNlcnZlIiBjbGFzcz0ib2FjX25vX3dhcm4iPgotQEpvaW5UYWJsZShqb2luQ29sdW1ucz1ASm9pbkNvbHVtbihuYW1lPSI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7Sk9JTl9DT0xVTU4mZ3Q7PC9zcGFuPiIpLCAKLSAgICBuYW1lID0gIjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtKT0lOX1RBQkxFX05BTUUmZ3Q7PC9zcGFuPiIpCi1ATWFueVRvTWFueShjYXNjYWRlPUNhc2NhZGVUeXBlLjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtDQVNDQURFX1RZUEUmZ3Q7PC9zcGFuPiwgZmV0Y2g9RmV0Y2hUeXBlLjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtGRVRDSF9UWVBFJmd0Ozwvc3Bhbj4sCi0gICAgdGFyZ2V0RW50aXR5PTxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtUQVJHRVRfRU5USVRZJmd0Ozwvc3Bhbj4sIG1hcHBlZEJ5ID0gIjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtNQVBQRURfQlkmZ3Q7PC9zcGFuPiIpCi1AT3JkZXJCeSgiPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O09SREVSX0JZJmd0Ozwvc3Bhbj4iKQotCi08L3ByZT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWx0LnBuZyIgYWx0PSJSZWxhdGVkIHRhc2siIHRpdGxlPSJSZWxhdGVkIHRhc2siIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InRhc2tfbWFwcGluZy5odG0jQkFCREdCSUoiPk1hcHBpbmcgYW4gZW50aXR5PC9hPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHIucG5nIiBhbHQ9IlJlbGF0ZWQgcmVmZXJlbmNlIiB0aXRsZT0iUmVsYXRlZCByZWZlcmVuY2UiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9vdXRsaW5lLmh0bSNCQUJFR0dGRSI+SlBBIFN0cnVjdHVyZSB2aWV3PC9hPjxiciAvPgotPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSNCQUJJRkJBRiI+SlBBIERldGFpbHMgdmlldyAoZm9yIGF0dHJpYnV0ZXMpPC9hPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0iY29uY2VwdF9tYXBwaW5nLmh0bSNCQUJCREpGSSI+VW5kZXJzdGFuZGluZyBPUiBtYXBwaW5nczwvYT48YnIgLz4KLTxhIGhyZWY9ImNvbmNlcHRzMDAxLmh0bSNCQUJCR0ZKRyI+VW5kZXJzdGFuZGluZyBFSkIgMy4wIEphdmEgUGVyc2lzdGVuY2UgQVBJPC9hPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDIiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDE1Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAxNS5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGI3OTQzYWEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDE1Lmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDE2MCArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0NyAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPk1hbnktdG8tb25lIG1hcHBpbmc8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJNYW55LXRvLW9uZSBtYXBwaW5nIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkFCSEZBRkoiIG5hbWU9IkJBQkhGQUZKIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5NYW55LXRvLW9uZSBtYXBwaW5nPC9oMT4KLTxwPjxhIGlkPSJzdGhyZWYxMTciIG5hbWU9InN0aHJlZjExNyI+PC9hPjxhIGlkPSJzdGhyZWYxMTgiIG5hbWU9InN0aHJlZjExOCI+PC9hPjxhIGlkPSJzdGhyZWYxMTkiIG5hbWU9InN0aHJlZjExOSI+PC9hPjxhIGlkPSJzdGhyZWYxMjAiIG5hbWU9InN0aHJlZjEyMCI+PC9hPlVzZSBhIDxzcGFuIGNsYXNzPSJib2xkIj5NYW55LXRvLU9uZTwvc3Bhbj4gbWFwcGluZyB0byBkZWZpbmVzIGEgc2luZ2xlLXZhbHVlZCBhc3NvY2lhdGlvbiB0byBhbm90aGVyIGVudGl0eSBjbGFzcyB0aGF0IGhhcyBtYW55LXRvLW9uZSBtdWx0aXBsaWNpdHkuPC9wPgotPG9sIHN0YXJ0PSIxIj4KLTxsaT4KLTxwPkluIHRoZSA8YSBocmVmPSJyZWZfcGVyc2lzdGVuY2Vfb3V0bGluZS5odG0jQkFCRUdHRkUiPkpQQSBTdHJ1Y3R1cmUgdmlldzwvYT4sIHNlbGVjdCB0aGUgZmllbGQgdG8gbWFwLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5SaWdodCBjbGljayB0aGUgZmllbGQgYW5kIHRoZW4gc2VsZWN0IDxzcGFuIGNsYXNzPSJib2xkIj5NYXAgQXMgJmd0OyBNYW55LXRvLU9uZTwvc3Bhbj4uIFRoZSA8YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtI0JBQklGQkFGIj5KUEEgRGV0YWlscyB2aWV3IChmb3IgYXR0cmlidXRlcyk8L2E+IGRpc3BsYXlzIHRoZSBwcm9wZXJ0aWVzIGZvciB0aGUgc2VsZWN0ZWQuPC9wPgotPC9saT4KLTxsaT4KLTxwPlVzZSB0aGlzIHRhYmxlIHRvIGNvbXBsZXRlIHRoZSA8YSBocmVmPSJyZWZfbWFwcGluZ19nZW5lcmFsLmh0bSNDQUNCSEZJSiI+R2VuZXJhbCBpbmZvcm1hdGlvbjwvYT4gZmllbGRzIEpQQSBEZXRhaWxzIHZpZXcuPC9wPgotPGRpdiBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIj4KLTx0YWJsZSBjbGFzcz0iUnVsZUluZm9ybWFsIiB0aXRsZT0iVGhpcyB0YWJsZSBsaXN0cyB0aGUgZmllbGRzIGlvbiB0aGUgR2VuZXJhbCB0YWIgZm9yIHRoaXMgbWFwcGluZy4iIHN1bW1hcnk9IlRoaXMgdGFibGUgbGlzdHMgdGhlIGZpZWxkcyBpb24gdGhlIEdlbmVyYWwgdGFiIGZvciB0aGlzIG1hcHBpbmcuIiBkaXI9Imx0ciIgYm9yZGVyPSIxIiB3aWR0aD0iMTAwJSIgZnJhbWU9ImJvcmRlciIgcnVsZXM9ImFsbCIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0aGVhZD4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzEtdDIyIj5Qcm9wZXJ0eTwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMi10MjIiPkRlc2NyaXB0aW9uPC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMzLXQyMiI+RGVmYXVsdDwvdGg+Ci08L3RyPgotPC90aGVhZD4KLTx0Ym9keT4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjJjMS10MjIiIGhlYWRlcnM9InIxYzEtdDIyIj5NYXBwaW5nIEVudGl0eSBIeXBlcmxpbms8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQyMiByMWMyLXQyMiI+RGVmaW5lcyBtYXBwaW5nIGFzIDxzcGFuIGNsYXNzPSJib2xkIj5NYW55LXRvLU9uZTwvc3Bhbj4uIFRoaXMgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPkBNYW55VG9PbmU8L2NvZGU+IGFubm90YXRpb24uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MjIgcjFjMy10MjIiPk1hbnktdG8tT25lPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDIyIiBoZWFkZXJzPSJyMWMxLXQyMiI+VGFyZ2V0IEVudGl0eTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDIyIHIxYzItdDIyIj5UaGUgZW50aXR5IHRvIHdoaWNoIHRoaXMgYXR0cmlidXRlIGlzIG1hcHBlZC48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQyMiByMWMzLXQyMiI+bnVsbAotPHA+WW91IGRvIG5vdCBuZWVkIHRvIGV4cGxpY2l0bHkgc3BlY2lmeSB0aGUgdGFyZ2V0IGVudGl0eSwgc2luY2UgaXQgY2FuIGJlIGluZmVycmVkIGZyb20gdGhlIHR5cGUgb2Ygb2JqZWN0IGJlaW5nIHJlZmVyZW5jZWQuPC9wPgotPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI0YzEtdDIyIiBoZWFkZXJzPSJyMWMxLXQyMiI+RmV0Y2g8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQyMiByMWMyLXQyMiI+RGVmaW5lcyBob3cgZGF0YSBpcyBsb2FkZWQgZnJvbSB0aGUgZGF0YWJhc2UuIFNlZSA8YSBocmVmPSJyZWZfbWFwcGluZ19nZW5lcmFsLmh0bSNDQUNHR0dIQiI+IkZldGNoIFR5cGUiPC9hPiBmb3IgZGV0YWlscy4KLTx1bD4KLTxsaT4KLTxwPkVhZ2VyPC9wPgotPC9saT4KLTxsaT4KLTxwPkxhenk8L3A+Ci08L2xpPgotPC91bD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDIyIHIxYzMtdDIyIj5FYWdlcjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNWMxLXQyMiIgaGVhZGVycz0icjFjMS10MjIiPkNhc2NhZGU8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQyMiByMWMyLXQyMiI+U2VlIDxhIGhyZWY9InJlZl9tYXBwaW5nX2dlbmVyYWwuaHRtI0NBQ0pBSUhCIj4iQ2FzY2FkZSBUeXBlIjwvYT4gZm9yIGRldGFpbHMuCi08dWw+Ci08bGk+Ci08cD5EZWZhdWx0PC9wPgotPC9saT4KLTxsaT4KLTxwPkFsbDwvcD4KLTwvbGk+Ci08bGk+Ci08cD5QZXJzaXN0PC9wPgotPC9saT4KLTxsaT4KLTxwPk1lcmdlPC9wPgotPC9saT4KLTxsaT4KLTxwPlJlbW92ZTwvcD4KLTwvbGk+Ci08L3VsPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MjIgcjFjMy10MjIiPkRlZmF1bHQ8L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjZjMS10MjIiIGhlYWRlcnM9InIxYzEtdDIyIj5PcHRpb25hbDwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI2YzEtdDIyIHIxYzItdDIyIj5TcGVjaWZpZXMgaWYgdGhpcyBmaWVsZCBpcyBjYW4gYmUgbnVsbC48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQyMiByMWMzLXQyMiI+WWVzPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIiAtLT48L2xpPgotPGxpPgotPHA+VXNlIHRoaXMgdGFibGUgdG8gY29tcGxldGUgdGhlIGZpZWxkcyBvbiB0aGUgPGEgaHJlZj0icmVmZXJlbmNlMDE1Lmh0bSNDQUNGQ0VKQyI+Sm9pbiBDb2x1bW5zIEluZm9ybWF0aW9uPC9hPiB0YWIgaW4gdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5KUEEgRGV0YWlsczwvc3Bhbj4gdmlldy48L3A+Ci08ZGl2IGNsYXNzPSJpbmZ0YmxydWxlaW5mb3JtYWwiPgotPHRhYmxlIGNsYXNzPSJSdWxlSW5mb3JtYWwiIHRpdGxlPSJUaGlzIHRhYmxlIGxpc3RzIHRoZSBmaWVsZHMgaW4gdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldyBmb3IgdGhpcyBtYXBwaW5nLiIgc3VtbWFyeT0iVGhpcyB0YWJsZSBsaXN0cyB0aGUgZmllbGRzIGluIHRoZSBQZXJzaXN0ZW5jZSBQcm9wZXJ0aWVzIHZpZXcgZm9yIHRoaXMgbWFwcGluZy4iIGRpcj0ibHRyIiBib3JkZXI9IjEiIHdpZHRoPSIxMDAlIiBmcmFtZT0iYm9yZGVyIiBydWxlcz0iYWxsIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRoZWFkPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMS10MjMiPlByb3BlcnR5PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMyLXQyMyI+RGVzY3JpcHRpb248L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzMtdDIzIj5EZWZhdWx0PC90aD4KLTwvdHI+Ci08L3RoZWFkPgotPHRib2R5PgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMmMxLXQyMyIgaGVhZGVycz0icjFjMS10MjMiPkpvaW4gQ29sdW1uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MjMgcjFjMi10MjMiPjxhIGlkPSJzdGhyZWYxMjEiIG5hbWU9InN0aHJlZjEyMSI+PC9hPjxhIGlkPSJzdGhyZWYxMjIiIG5hbWU9InN0aHJlZjEyMiI+PC9hPlNwZWNpZnkgYSBtYXBwZWQgY29sdW1uIGZvciBqb2luaW5nIGFuIGVudGl0eSBhc3NvY2lhdGlvbi4gVGhpcyBmaWVsZCBjb3JyZXNwb25kcyB0byB0aGUgPGNvZGU+QEpvaW5Db2x1bTwvY29kZT4gYXR0cmlidXRlLgotPHA+U2VsZWN0IDxzcGFuIGNsYXNzPSJib2xkIj5PdmVycmlkZSBEZWZhdWx0PC9zcGFuPiwgdGhlbiBBZGQsIEVkaXQsIG9yIFJlbW92ZSB0aGUgam9pbiBjb2x1bW5zLjwvcD4KLTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDIzIHIxYzMtdDIzIj5CeSBkZWZhdWx0LCB0aGUgbWFwcGluZyBpcyBhc3N1bWVkIHRvIGhhdmUgYSBzaW5nbGUgam9pbi48L3RkPgotPC90cj4KLTwvdGJvZHk+Ci08L3RhYmxlPgotPGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJpbmZ0YmxydWxlaW5mb3JtYWwiIC0tPjwvbGk+Ci08L29sPgotPHA+RWNsaXBzZSBhZGRzIHRoZSBmb2xsb3dpbmcgYW5ub3RhdGlvbnMgdG8gdGhlIGZpZWxkOjwvcD4KLTxwcmUgeG1sOnNwYWNlPSJwcmVzZXJ2ZSIgY2xhc3M9Im9hY19ub193YXJuIj4KLUBKb2luVGFibGUoam9pbkNvbHVtbnM9QEpvaW5Db2x1bW4obmFtZT0iPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O0pPSU5fQ09MVU1OJmd0Ozwvc3Bhbj4iKSwgCi0gICAgbmFtZSA9ICI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7Sk9JTl9UQUJMRV9OQU1FJmd0Ozwvc3Bhbj4iKQotQE1hbnlUb09uZSh0YXJnZXRFbnRpdHk9PHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O1RBUkdFVF9FTlRJVFkmZ3Q7PC9zcGFuPiwgZmV0Y2g9PHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O0ZFVENIX1RZUEUmZ3Q7PC9zcGFuPiwgCi0gICAgY2FzY2FkZT08c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7Q0FTQ0FERV9UWVBFJmd0Ozwvc3Bhbj4pCi08L3ByZT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWx0LnBuZyIgYWx0PSJSZWxhdGVkIHRhc2siIHRpdGxlPSJSZWxhdGVkIHRhc2siIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InRhc2tfbWFwcGluZy5odG0jQkFCREdCSUoiPk1hcHBpbmcgYW4gZW50aXR5PC9hPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHIucG5nIiBhbHQ9IlJlbGF0ZWQgcmVmZXJlbmNlIiB0aXRsZT0iUmVsYXRlZCByZWZlcmVuY2UiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9vdXRsaW5lLmh0bSNCQUJFR0dGRSI+SlBBIFN0cnVjdHVyZSB2aWV3PC9hPjxiciAvPgotPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSNCQUJJRkJBRiI+SlBBIERldGFpbHMgdmlldyAoZm9yIGF0dHJpYnV0ZXMpPC9hPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0iY29uY2VwdF9tYXBwaW5nLmh0bSNCQUJCREpGSSI+VW5kZXJzdGFuZGluZyBPUiBtYXBwaW5nczwvYT48YnIgLz4KLTxhIGhyZWY9ImNvbmNlcHRzMDAxLmh0bSNCQUJCR0ZKRyI+VW5kZXJzdGFuZGluZyBFSkIgMy4wIEphdmEgUGVyc2lzdGVuY2UgQVBJPC9hPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDIiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDE2Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAxNi5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGMyNDExN2IuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDE2Lmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDE5MCArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0NyAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPk9uZS10by1tYW55IG1hcHBpbmc8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJPbmUtdG8tbWFueSBtYXBwaW5nIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkFCSEdFQkQiIG5hbWU9IkJBQkhHRUJEIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5PbmUtdG8tbWFueSBtYXBwaW5nPC9oMT4KLTxwPjxhIGlkPSJzdGhyZWYxMjMiIG5hbWU9InN0aHJlZjEyMyI+PC9hPjxhIGlkPSJzdGhyZWYxMjQiIG5hbWU9InN0aHJlZjEyNCI+PC9hPjxhIGlkPSJzdGhyZWYxMjUiIG5hbWU9InN0aHJlZjEyNSI+PC9hPjxhIGlkPSJzdGhyZWYxMjYiIG5hbWU9InN0aHJlZjEyNiI+PC9hPlVzZSBhIDxzcGFuIGNsYXNzPSJib2xkIj5PbmUtdG8tTWFueSBNYXBwaW5nPC9zcGFuPiB0byBkZWZpbmUgYSByZWxhdGlvbnNoaXAgd2l0aCBvbmUtdG8tbWFueSBtdWx0aXBsaWNpdHkuPC9wPgotPG9sIHN0YXJ0PSIxIj4KLTxsaT4KLTxwPkluIHRoZSA8YSBocmVmPSJyZWZfcGVyc2lzdGVuY2Vfb3V0bGluZS5odG0jQkFCRUdHRkUiPkpQQSBTdHJ1Y3R1cmUgdmlldzwvYT4sIHNlbGVjdCB0aGUgZmllbGQgdG8gbWFwLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5SaWdodC1jbGljayB0aGUgZmllbGQgYW5kIHRoZW4gc2VsZWN0IDxzcGFuIGNsYXNzPSJib2xkIj5NYXAgQXMgJmd0OyBPbmUtdG8tbWFueTwvc3Bhbj4uIFRoZSA8YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtI0JBQklGQkFGIj5KUEEgRGV0YWlscyB2aWV3IChmb3IgYXR0cmlidXRlcyk8L2E+IGRpc3BsYXlzIHRoZSBwcm9wZXJ0aWVzIGZvciB0aGUgc2VsZWN0ZWQuPC9wPgotPC9saT4KLTxsaT4KLTxwPlVzZSB0aGlzIHRhYmxlIHRvIGNvbXBsZXRlIHRoZSA8YSBocmVmPSJyZWZfbWFwcGluZ19nZW5lcmFsLmh0bSNDQUNCSEZJSiI+R2VuZXJhbCBpbmZvcm1hdGlvbjwvYT4gZmllbGRzIEpQQSBEZXRhaWxzIHZpZXcuPC9wPgotPGRpdiBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIj4KLTx0YWJsZSBjbGFzcz0iUnVsZUluZm9ybWFsIiB0aXRsZT0iVGhpcyB0YWJsZSBsaXN0cyB0aGUgZmllbGRzIGluIHRoZSBHZW5lcmFsIHRhYiBvZiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyB2aWV3IGZvciB0aGlzIG1hcHBpbmcuIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGxpc3RzIHRoZSBmaWVsZHMgaW4gdGhlIEdlbmVyYWwgdGFiIG9mIHRoZSBQZXJzaXN0ZW5jZSBQcm9wZXJ0aWVzIHZpZXcgZm9yIHRoaXMgbWFwcGluZy4iIGRpcj0ibHRyIiBib3JkZXI9IjEiIHdpZHRoPSIxMDAlIiBmcmFtZT0iYm9yZGVyIiBydWxlcz0iYWxsIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjAiPgotPHRoZWFkPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMS10MjQiPlByb3BlcnR5PC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMyLXQyNCI+RGVzY3JpcHRpb248L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzMtdDI0Ij5EZWZhdWx0PC90aD4KLTwvdHI+Ci08L3RoZWFkPgotPHRib2R5PgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMmMxLXQyNCIgaGVhZGVycz0icjFjMS10MjQiPk1hcHBpbmcgRW50aXR5IFR5cGUgSHlwZXJsaW5rPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MjQgcjFjMi10MjQiPkRlZmluZXMgbWFwcGluZyBhcyA8c3BhbiBjbGFzcz0iYm9sZCI+T25lLXRvLU1hbnk8L3NwYW4+LiBUaGlzIGNvcnJlc3BvbmRzIHRvIHRoZSA8Y29kZT5AT25lVG9NYW55PC9jb2RlPiBhbm5vdGF0aW9uLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDI0IHIxYzMtdDI0Ij5PbmUtdG8tTWFueTwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyM2MxLXQyNCIgaGVhZGVycz0icjFjMS10MjQiPlRhcmdldCBFbnRpdHk8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQyNCByMWMyLXQyNCI+VGhlIGVudGl0eSB0byB3aGljaCB0aGlzIGF0dHJpYnV0ZSBpcyBtYXBwZWQuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MjQgcjFjMy10MjQiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNGMxLXQyNCIgaGVhZGVycz0icjFjMS10MjQiPkNhc2NhZGU8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQyNCByMWMyLXQyNCI+U2VlIDxhIGhyZWY9InJlZl9tYXBwaW5nX2dlbmVyYWwuaHRtI0NBQ0pBSUhCIj4iQ2FzY2FkZSBUeXBlIjwvYT4gZm9yIGRldGFpbHMuCi08dWw+Ci08bGk+Ci08cD5EZWZhdWx0PC9wPgotPC9saT4KLTxsaT4KLTxwPkFsbDwvcD4KLTwvbGk+Ci08bGk+Ci08cD5QZXJzaXN0PC9wPgotPC9saT4KLTxsaT4KLTxwPk1lcmdlPC9wPgotPC9saT4KLTxsaT4KLTxwPlJlbW92ZTwvcD4KLTwvbGk+Ci08L3VsPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MjQgcjFjMy10MjQiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNWMxLXQyNCIgaGVhZGVycz0icjFjMS10MjQiPkZldGNoPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MjQgcjFjMi10MjQiPkRlZmluZXMgaG93IGRhdGEgaXMgbG9hZGVkIGZyb20gdGhlIGRhdGFiYXNlLiBTZWUgPGEgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jQ0FDR0dHSEIiPiJGZXRjaCBUeXBlIjwvYT4gZm9yIGRldGFpbHMuCi08dWw+Ci08bGk+Ci08cD5FYWdlcjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5MYXp5PC9wPgotPC9saT4KLTwvdWw+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQyNCByMWMzLXQyNCI+RWFnZXI8L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjZjMS10MjQiIGhlYWRlcnM9InIxYzEtdDI0Ij5NYXBwZWQgQnk8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNmMxLXQyNCByMWMyLXQyNCI+VGhlIGRhdGFiYXNlIGZpZWxkIHRoYXQgb3ducyB0aGUgcmVsYXRpb25zaGlwLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI2YzEtdDI0IHIxYzMtdDI0Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjdjMS10MjQiIGhlYWRlcnM9InIxYzEtdDI0Ij5PcmRlciBCeTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI3YzEtdDI0IHIxYzItdDI0Ij5TcGVjaWZ5IHRoZSBkZWZhdWx0IG9yZGVyIGZvciBvYmplY3RzIHJldHVybmVkIGZyb20gYSBxdWVyeS4gU2VlIDxhIGhyZWY9InJlZl9tYXBwaW5nX2dlbmVyYWwuaHRtI0NBQ0RBRElIIj4iT3JkZXIgQnkiPC9hPiBmb3IgZGV0YWlscy4KLTx1bD4KLTxsaT4KLTxwPk5vIG9yZGVyaW5nPC9wPgotPC9saT4KLTxsaT4KLTxwPlByaW1hcnkga2V5PC9wPgotPC9saT4KLTxsaT4KLTxwPkN1c3RvbTwvcD4KLTwvbGk+Ci08L3VsPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjdjMS10MjQgcjFjMy10MjQiPk5vIG9yZGVyaW5nPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIiAtLT48L2xpPgotPGxpPgotPHA+VXNlIHRoaXMgdGFibGUgdG8gY29tcGxldGUgdGhlIDxhIGhyZWY9InJlZmVyZW5jZTAxNC5odG0jQ0FDQkFFQkMiPkpvaW4gVGFibGUgSW5mb3JtYXRpb248L2E+IGZpZWxkcyBpbiB0aGUgSlBBIERldGFpbHMgdmlldy48L3A+Ci08ZGl2IGNsYXNzPSJpbmZ0YmxydWxlaW5mb3JtYWwiPgotPHRhYmxlIGNsYXNzPSJSdWxlSW5mb3JtYWwiIHRpdGxlPSJUaGlzIHRhYmxlIGxpc3RzIHRoZSBmaWVsZHMgaW4gdGhlIEpvaW4gVGFibGUgdGFiIG9mIHRoZSBQZXJzaXN0ZW5jZSBQcm9wZXJ0aWVzIHZpZXcgZm9yIHRoaXMgbWFwcGluZy4iIHN1bW1hcnk9IlRoaXMgdGFibGUgbGlzdHMgdGhlIGZpZWxkcyBpbiB0aGUgSm9pbiBUYWJsZSB0YWIgb2YgdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldyBmb3IgdGhpcyBtYXBwaW5nLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQyNSI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDI1Ij5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10MjUiPkRlZmF1bHQ8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDI1IiBoZWFkZXJzPSJyMWMxLXQyNSI+TmFtZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDI1IHIxYzItdDI1Ij5OYW1lIG9mIHRoZSBqb2luIHRhYmxlPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MjUgcjFjMy10MjUiPkJ5IGRlZmF1bHQsIHRoZSBuYW1lIGlzIGFzc3VtZWQgdG8gYmUgdGhlIHByaW1hcnkgdGFibGVzIGFzc29jaWF0ZWQgd2l0aCB0aGUgZW50aXRpZXMgY29uY2F0ZW5hdGVkIHdpdGggYW4gdW5kZXJzY29yZS48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10MjUiIGhlYWRlcnM9InIxYzEtdDI1Ij5Kb2luIENvbHVtbnM8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQyNSByMWMyLXQyNSI+U3BlY2lmeSB0d28gb3IgbW9yZSBqb2luIGNvbHVtbnMgKHRoYXQgaXMsIGEgcHJpbWFyeSBrZXkpLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDI1IHIxYzMtdDI1Ij48YnIgLz48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjRjMS10MjUiIGhlYWRlcnM9InIxYzEtdDI1Ij5JbnZlcnNlIEpvaW4gQ29sdW1uczwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDI1IHIxYzItdDI1Ij5UaGUgam9pbiBjb2x1bW4gb24gdGhlIG93bmVkIChvciBpbnZlcnNlKSBzaWRlIG9mIHRoZSBhc3NvY2lhdGlvbjogdGhlIG93bmVkIGVudGl0eSdzIHByaW1hcnkga2V5IGNvbHVtbi48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNGMxLXQyNSByMWMzLXQyNSI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIiAtLT48L2xpPgotPC9vbD4KLTxwPkVjbGlwc2UgYWRkcyB0aGUgZm9sbG93aW5nIGFubm90YXRpb25zIHRvIHRoZSBmaWVsZDo8L3A+Ci08cHJlIHhtbDpzcGFjZT0icHJlc2VydmUiIGNsYXNzPSJvYWNfbm9fd2FybiI+Ci1AT25lVG9NYW55KHRhcmdldEVudGl0eT08c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7VEFSR0VUX0VOVElUWSZndDs8L3NwYW4+KQotQENvbHVtbihuYW1lPSI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7Q09MVU1OJmd0Ozwvc3Bhbj4iKQotCi0KLUBPbmVUb01hbnkodGFyZ2V0RW50aXR5PTxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtUQVJHRVRfRU5USVRZJmd0Ozwvc3Bhbj4uY2xhc3MsIGNhc2NhZGU9Q2FzY2FkZVR5cGUuPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O0NBU0NBREVfVFlQRSZndDs8L3NwYW4+LCAKLSAgICBmZXRjaCA9IEZldGNoVHlwZS48c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7RkVUQ0hfVFlQRSZndDs8L3NwYW4+LCBtYXBwZWRCeSA9ICI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7TUFQUEVEX0JZJmd0Ozwvc3Bhbj4iKUBPcmRlckJ5KCI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7T1JERVJfQlkmZ3Q7PC9zcGFuPiIpCi1ASm9pblRhYmxlKG5hbWU9IjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtKT0lOX1RBQkxFX05BTUUmZ3Q7PC9zcGFuPiIsIGpvaW5Db2x1bW5zPUBKb2luQ29sdW1uKG5hbWU9Ci0gICAgIjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtKT0lOX0NPTFVNTl9OQU1FJmd0Ozwvc3Bhbj4iLCByZWZlcmVuY2VkQ29sdW1uTmFtZT0iPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O0pPSU5fQ09MVU1OX1JFRkVSRU5DRURfQ09MVU1OJmd0Ozwvc3Bhbj4iKSwgCi0gICAgaW52ZXJzZUpvaW5Db2x1bW5zPUBKb2luQ29sdW1uKG5hbWU9IjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtJTlZFUlNFX0pPSU5fQ09MVU1OX05BTUUmZ3Q7PC9zcGFuPiIsIAotICAgIHJlZmVyZW5jZWRDb2x1bW5OYW1lPSI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7SU5WRVJTRV9KT0lOX0NPTFVNTl9SRUZFUkVOQ0VEX0NPTFVNTiZndDs8L3NwYW4+IikpCi0KLTwvcHJlPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza19tYXBwaW5nLmh0bSNCQUJER0JJSiI+TWFwcGluZyBhbiBlbnRpdHk8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsci5wbmciIGFsdD0iUmVsYXRlZCByZWZlcmVuY2UiIHRpdGxlPSJSZWxhdGVkIHJlZmVyZW5jZSIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX291dGxpbmUuaHRtI0JBQkVHR0ZFIj5KUEEgU3RydWN0dXJlIHZpZXc8L2E+PGJyIC8+Ci08YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtI0JBQklGQkFGIj5KUEEgRGV0YWlscyB2aWV3IChmb3IgYXR0cmlidXRlcyk8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsYy5wbmciIGFsdD0iUmVsYXRlZCBjb25jZXB0IiB0aXRsZT0iUmVsYXRlZCBjb25jZXB0IiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJjb25jZXB0X21hcHBpbmcuaHRtI0JBQkJESkZJIj5VbmRlcnN0YW5kaW5nIE9SIG1hcHBpbmdzPC9hPjxiciAvPgotPGEgaHJlZj0iY29uY2VwdHMwMDEuaHRtI0JBQkJHRkpHIj5VbmRlcnN0YW5kaW5nIEVKQiAzLjAgSmF2YSBQZXJzaXN0ZW5jZSBBUEk8L2E+PC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MiIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMTcuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDE3Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzUwMjMwMy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMTcuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsMTM5ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQ3IC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+T25lLXRvLW9uZSBtYXBwaW5nPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iT25lLXRvLW9uZSBtYXBwaW5nIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkFCRkhCQ0oiIG5hbWU9IkJBQkZIQkNKIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5PbmUtdG8tb25lIG1hcHBpbmc8L2gxPgotPHA+PGEgaWQ9InN0aHJlZjEyNyIgbmFtZT0ic3RocmVmMTI3Ij48L2E+PGEgaWQ9InN0aHJlZjEyOCIgbmFtZT0ic3RocmVmMTI4Ij48L2E+PGEgaWQ9InN0aHJlZjEyOSIgbmFtZT0ic3RocmVmMTI5Ij48L2E+PGEgaWQ9InN0aHJlZjEzMCIgbmFtZT0ic3RocmVmMTMwIj48L2E+VXNlIGEgPHNwYW4gY2xhc3M9ImJvbGQiPk9uZS10by1PbmUgTWFwcGluZzwvc3Bhbj4gdG8gZGVmaW5lIGEgcmVsYXRpb25zaGlwIHdpdGggb25lLXRvLW1hbnkgbXVsdGlwbGljaXR5LjwvcD4KLTxvbCBzdGFydD0iMSI+Ci08bGk+Ci08cD5JbiB0aGUgPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX291dGxpbmUuaHRtI0JBQkVHR0ZFIj5KUEEgU3RydWN0dXJlIHZpZXc8L2E+LCBzZWxlY3QgdGhlIGZpZWxkIHRvIG1hcC48L3A+Ci08L2xpPgotPGxpPgotPHA+UmlnaHQtY2xpY2sgdGhlIGZpZWxkIGFuZCB0aGVuIHNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+TWFwIEFzICZndDsgT25lLXRvLU9uZTwvc3Bhbj4uIFRoZSA8YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtI0JBQklGQkFGIj5KUEEgRGV0YWlscyB2aWV3IChmb3IgYXR0cmlidXRlcyk8L2E+IGRpc3BsYXlzIHRoZSBwcm9wZXJ0aWVzIGZvciB0aGUgc2VsZWN0ZWQuPC9wPgotPC9saT4KLTxsaT4KLTxwPlVzZSB0aGlzIHRhYmxlIHRvIGNvbXBsZXRlIHRoZSA8YSBocmVmPSJyZWZfbWFwcGluZ19nZW5lcmFsLmh0bSNDQUNCSEZJSiI+R2VuZXJhbCBpbmZvcm1hdGlvbjwvYT4gZmllbGRzIGluIHRoZSBKUEEgRGV0YWlscyB2aWV3LjwvcD4KLTxkaXYgY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCI+Ci08dGFibGUgY2xhc3M9IlJ1bGVJbmZvcm1hbCIgdGl0bGU9IlRoaXMgdGFibGUgbGlzdHMgdGhlIGZpZWxkcyBpbiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyB2aWV3IGZvciB0aGlzIG1hcHBpbmcuIiBzdW1tYXJ5PSJUaGlzIHRhYmxlIGxpc3RzIHRoZSBmaWVsZHMgaW4gdGhlIFBlcnNpc3RlbmNlIFByb3BlcnRpZXMgdmlldyBmb3IgdGhpcyBtYXBwaW5nLiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQyNiI+UHJvcGVydHk8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDI2Ij5EZXNjcmlwdGlvbjwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMy10MjYiPkRlZmF1bHQ8L3RoPgotPC90cj4KLTwvdGhlYWQ+Ci08dGJvZHk+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIyYzEtdDI2IiBoZWFkZXJzPSJyMWMxLXQyNiI+TWFwcGVkIEVudGl0eSBIeXBlcmxpbms8L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQyNiByMWMyLXQyNiI+RGVmaW5lcyBtYXBwaW5nIGFzIDxzcGFuIGNsYXNzPSJib2xkIj5PbmUtdG8tT25lPC9zcGFuPi4gVGhpcyBjb3JyZXNwb25kcyB0byB0aGUgPGNvZGU+QE9uZVRvT25lPC9jb2RlPiBhbm5vdGF0aW9uLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDI2IHIxYzMtdDI2Ij5PbmUtdG8tT25lPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDI2IiBoZWFkZXJzPSJyMWMxLXQyNiI+VGFyZ2V0IEVudGl0eTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDI2IHIxYzItdDI2Ij5UaGUgZW50aXR5IHRvIHdoaWNoIHRoaXMgYXR0cmlidXRlIGlzIG1hcHBlZC48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQyNiByMWMzLXQyNiI+bnVsbAotPHA+WW91IGRvIG5vdCBuZWVkIHRvIGV4cGxpY2l0bHkgc3BlY2lmeSB0aGUgdGFyZ2V0IGVudGl0eSwgc2luY2UgaXQgY2FuIGJlIGluZmVycmVkIGZyb20gdGhlIHR5cGUgb2Ygb2JqZWN0IGJlaW5nIHJlZmVyZW5jZWQuPC9wPgotPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI0YzEtdDI2IiBoZWFkZXJzPSJyMWMxLXQyNiI+RmV0Y2ggVHlwZTwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDI2IHIxYzItdDI2Ij5EZWZpbmVzIGhvdyBkYXRhIGlzIGxvYWRlZCBmcm9tIHRoZSBkYXRhYmFzZS4gU2VlIDxhIGhyZWY9InJlZl9tYXBwaW5nX2dlbmVyYWwuaHRtI0NBQ0dHR0hCIj4iRmV0Y2ggVHlwZSI8L2E+IGZvciBkZXRhaWxzLgotPHVsPgotPGxpPgotPHA+RWFnZXI8L3A+Ci08L2xpPgotPGxpPgotPHA+TGF6eTwvcD4KLTwvbGk+Ci08L3VsPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MjYgcjFjMy10MjYiPkVhZ2VyPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InI1YzEtdDI2IiBoZWFkZXJzPSJyMWMxLXQyNiI+TWFwcGVkIEJ5PC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MjYgcjFjMi10MjYiPlRoZSBkYXRhYmFzZSBmaWVsZCB0aGF0IG93bnMgdGhlIHJlbGF0aW9uc2hpcC48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyNWMxLXQyNiByMWMzLXQyNiI+PGJyIC8+PC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIiAtLT48L2xpPgotPGxpPgotPHA+VXNlIHRoaXMgdGFibGUgdG8gY29tcGxldGUgdGhlIDxhIGhyZWY9InJlZmVyZW5jZTAxNS5odG0jQ0FDRkNFSkMiPkpvaW4gQ29sdW1ucyBJbmZvcm1hdGlvbjwvYT4gZmllbGRzIGluIHRoZSA8c3BhbiBjbGFzcz0iZ3VpLW9iamVjdC10aXRsZSI+SlBBIERldGFpbHM8L3NwYW4+IHZpZXcuPC9wPgotPGRpdiBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIj4KLTx0YWJsZSBjbGFzcz0iUnVsZUluZm9ybWFsIiB0aXRsZT0iVGhpcyB0YWJsZSBsaXN0cyB0aGUgZmllbGRzIGluIHRoZSBQZXJzaXN0ZW5jZSBQcm9wZXJ0aWVzIHZpZXcgZm9yIHRoaXMgbWFwcGluZy4iIHN1bW1hcnk9IlRoaXMgdGFibGUgbGlzdHMgdGhlIGZpZWxkcyBpbiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyB2aWV3IGZvciB0aGlzIG1hcHBpbmcuIiBkaXI9Imx0ciIgYm9yZGVyPSIxIiB3aWR0aD0iMTAwJSIgZnJhbWU9ImJvcmRlciIgcnVsZXM9ImFsbCIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0aGVhZD4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzEtdDI3Ij5Qcm9wZXJ0eTwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMi10MjciPkRlc2NyaXB0aW9uPC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMzLXQyNyI+RGVmYXVsdDwvdGg+Ci08L3RyPgotPC90aGVhZD4KLTx0Ym9keT4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjJjMS10MjciIGhlYWRlcnM9InIxYzEtdDI3Ij5Kb2luIENvbHVtbjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDI3IHIxYzItdDI3Ij48YSBpZD0ic3RocmVmMTMxIiBuYW1lPSJzdGhyZWYxMzEiPjwvYT48YSBpZD0ic3RocmVmMTMyIiBuYW1lPSJzdGhyZWYxMzIiPjwvYT5TcGVjaWZ5IGEgbWFwcGVkIGNvbHVtbiBmb3Igam9pbmluZyBhbiBlbnRpdHkgYXNzb2NpYXRpb24uIFRoaXMgZmllbGQgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPkBKb2luQ29sdW08L2NvZGU+IGF0dHJpYnV0ZS4KLTxwPlNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+T3ZlcnJpZGUgRGVmYXVsdDwvc3Bhbj4sIHRoZW4gQWRkLCBFZGl0LCBvciBSZW1vdmUgdGhlIGpvaW4gY29sdW1ucy48L3A+Ci08L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyMmMxLXQyNyByMWMzLXQyNyI+QnkgZGVmYXVsdCwgdGhlIG1hcHBpbmcgaXMgYXNzdW1lZCB0byBoYXZlIGEgc2luZ2xlIGpvaW4uPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIiAtLT48L2xpPgotPC9vbD4KLTxwPkVjbGlwc2UgYWRkcyB0aGUgZm9sbG93aW5nIGFubm90YXRpb25zIHRvIHRoZSBmaWVsZDo8L3A+Ci08cHJlIHhtbDpzcGFjZT0icHJlc2VydmUiIGNsYXNzPSJvYWNfbm9fd2FybiI+Ci1AT25lVG9PbmUodGFyZ2V0RW50aXR5PTxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtUQVJHRVRfRU5USVRZJmd0Ozwvc3Bhbj4sIGNhc2NhZGU9Q2FzY2FkZVR5cGUuPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O0NBU0NBREVfVFlQRSZndDs8L3NwYW4+LCAKLSAgICBmZXRjaCA9IEZldGNoVHlwZS48c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7RkVUQ0hfVFlQRSZndDs8L3NwYW4+LCBtYXBwZWRCeSA9ICI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7TUFQUEVEX0JZJmd0Ozwvc3Bhbj4iKQotQEpvaW5Db2x1bW4obmFtZT0iPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O0pPSU5fQ09MVU1OX05BTUUmZ3Q7PC9zcGFuPiIsIHJlZmVyZW5jZWRDb2x1bW5OYW1lPQotICAgICI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7Sk9JTl9DT0xVTU5fUkVGRVJFTkNFRF9DT0xVTU4mZ3Q7PC9zcGFuPiIsIGluc2VydGFibGUgPSA8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7SU5TRVJUQUJMRSZndDs8L3NwYW4+LCAKLSAgICB1cGRhdGFibGUgPSA8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7VVBEQVRBQkxFJmd0Ozwvc3Bhbj4pCi0KLTwvcHJlPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza19tYXBwaW5nLmh0bSNCQUJER0JJSiI+TWFwcGluZyBhbiBlbnRpdHk8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsci5wbmciIGFsdD0iUmVsYXRlZCByZWZlcmVuY2UiIHRpdGxlPSJSZWxhdGVkIHJlZmVyZW5jZSIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX291dGxpbmUuaHRtI0JBQkVHR0ZFIj5KUEEgU3RydWN0dXJlIHZpZXc8L2E+PGJyIC8+Ci08YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtI0JBQklGQkFGIj5KUEEgRGV0YWlscyB2aWV3IChmb3IgYXR0cmlidXRlcyk8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsYy5wbmciIGFsdD0iUmVsYXRlZCBjb25jZXB0IiB0aXRsZT0iUmVsYXRlZCBjb25jZXB0IiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJjb25jZXB0X21hcHBpbmcuaHRtI0JBQkJESkZJIj5VbmRlcnN0YW5kaW5nIE9SIG1hcHBpbmdzPC9hPjxiciAvPgotPGEgaHJlZj0iY29uY2VwdHMwMDEuaHRtI0JBQkJHRkpHIj5VbmRlcnN0YW5kaW5nIEVKQiAzLjAgSmF2YSBQZXJzaXN0ZW5jZSBBUEk8L2E+PC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MiIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMTguaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDE4Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNTliYmIzNS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMTguaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNjUgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDggLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5UcmFuc2llbnQgbWFwcGluZzwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IlRyYW5zaWVudCBtYXBwaW5nIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkFCSEZIRUkiIG5hbWU9IkJBQkhGSEVJIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDIiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5UcmFuc2llbnQgbWFwcGluZzwvaDE+Ci08cD48YSBpZD0ic3RocmVmMTMzIiBuYW1lPSJzdGhyZWYxMzMiPjwvYT48YSBpZD0ic3RocmVmMTM0IiBuYW1lPSJzdGhyZWYxMzQiPjwvYT48YSBpZD0ic3RocmVmMTM1IiBuYW1lPSJzdGhyZWYxMzUiPjwvYT48YSBpZD0ic3RocmVmMTM2IiBuYW1lPSJzdGhyZWYxMzYiPjwvYT5Vc2UgdGhlIFRyYW5zaWVudCBNYXBwaW5nIHRvIHNwZWNpZnkgYSBmaWVsZCBvZiB0aGUgZW50aXR5IGNsYXNzIHRoYXQgPHNwYW4gY2xhc3M9Iml0YWxpYyI+aXMgbm90PC9zcGFuPiBwZXJzaXN0ZW50LjwvcD4KLTxwPlRvIGNyZWF0ZSBhIHRyYW5zaWVudCBtYXBwaW5nOjwvcD4KLTxvbCBzdGFydD0iMSI+Ci08bGk+Ci08cD5JbiB0aGUgPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX291dGxpbmUuaHRtI0JBQkVHR0ZFIj5KUEEgU3RydWN0dXJlIHZpZXc8L2E+LCBzZWxlY3QgdGhlIGZpZWxkIHRvIG1hcC48L3A+Ci08L2xpPgotPGxpPgotPHA+UmlnaHQtY2xpY2sgdGhlIGZpZWxkIGFuZCB0aGVuIHNlbGVjdCA8c3BhbiBjbGFzcz0iYm9sZCI+TWFwIEFzIFRyYW5zaWVudDwvc3Bhbj4uIFRoZSA8YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtI0JBQklGQkFGIj5KUEEgRGV0YWlscyB2aWV3IChmb3IgYXR0cmlidXRlcyk8L2E+IGRpc3BsYXlzIHRoZSBwcm9wZXJ0aWVzIGZvciB0aGUgc2VsZWN0ZWQuPC9wPgotPC9saT4KLTwvb2w+Ci08cD5FY2xpcHNlIGFkZHMgdGhlIGZvbGxvd2luZyBhbm5vdGF0aW9uIHRvIHRoZSBmaWVsZDo8L3A+Ci08cHJlIHhtbDpzcGFjZT0icHJlc2VydmUiIGNsYXNzPSJvYWNfbm9fd2FybiI+Ci1AVHJhbnNpZW50Ci08L3ByZT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWx0LnBuZyIgYWx0PSJSZWxhdGVkIHRhc2siIHRpdGxlPSJSZWxhdGVkIHRhc2siIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InRhc2tfbWFwcGluZy5odG0jQkFCREdCSUoiPk1hcHBpbmcgYW4gZW50aXR5PC9hPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHIucG5nIiBhbHQ9IlJlbGF0ZWQgcmVmZXJlbmNlIiB0aXRsZT0iUmVsYXRlZCByZWZlcmVuY2UiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9vdXRsaW5lLmh0bSNCQUJFR0dGRSI+SlBBIFN0cnVjdHVyZSB2aWV3PC9hPjxiciAvPgotPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSNCQUJJRkJBRiI+SlBBIERldGFpbHMgdmlldyAoZm9yIGF0dHJpYnV0ZXMpPC9hPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0iY29uY2VwdF9tYXBwaW5nLmh0bSNCQUJCREpGSSI+VW5kZXJzdGFuZGluZyBPUiBtYXBwaW5nczwvYT48YnIgLz4KLTxhIGhyZWY9ImNvbmNlcHRzMDAxLmh0bSNCQUJCR0ZKRyI+VW5kZXJzdGFuZGluZyBFSkIgMy4wIEphdmEgUGVyc2lzdGVuY2UgQVBJPC9hPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDIiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDE5Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAxOS5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDlkZGUyOTMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDE5Lmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDEzMyArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0OCAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPlZlcnNpb24gbWFwcGluZzwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IlZlcnNpb24gbWFwcGluZyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkJBQkhJQklJIiBuYW1lPSJCQUJISUJJSSI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QyIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+VmVyc2lvbiBtYXBwaW5nPC9oMT4KLTxwPjxhIGlkPSJzdGhyZWYxMzciIG5hbWU9InN0aHJlZjEzNyI+PC9hPjxhIGlkPSJzdGhyZWYxMzgiIG5hbWU9InN0aHJlZjEzOCI+PC9hPjxhIGlkPSJzdGhyZWYxMzkiIG5hbWU9InN0aHJlZjEzOSI+PC9hPjxhIGlkPSJzdGhyZWYxNDAiIG5hbWU9InN0aHJlZjE0MCI+PC9hPlVzZSBhIDxzcGFuIGNsYXNzPSJib2xkIj5WZXJzaW9uIE1hcHBpbmc8L3NwYW4+IHRvIHNwZWNpZnkgdGhlIGZpZWxkIHVzZWQgZm9yIG9wdGltaXN0aWMgbG9ja2luZy4gSWYgdGhlIGVudGl0eSBpcyBhc3NvY2lhdGVkIHdpdGggbXVsdGlwbGUgdGFibGVzLCB5b3Ugc2hvdWxkIHVzZSBhIHZlcnNpb24gbWFwcGluZyBvbmx5IHdpdGggdGhlIHByaW1hcnkgdGFibGUuIFlvdSBzaG91bGQgaGF2ZSBvbmx5IGEgc2luZ2xlIHZlcnNpb24gbWFwcGluZyBwZXIgcGVyc2lzdGVudCBlbnRpdHkuIFZlcnNpb24gbWFwcGluZ3MgbWF5IGJlIHVzZWQgb25seSB3aXRoIHRoZSBmb2xsb3dpbmcgYXR0cmlidXRlIHR5cGVzOjwvcD4KLTx1bD4KLTxsaT4KLTxwPjxjb2RlPmludDwvY29kZT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGNvZGU+SW50ZWdlcjwvY29kZT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGNvZGU+c2hvcnQsIFNob3J0PC9jb2RlPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48Y29kZT5sb25nLCBMb25nPC9jb2RlPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48Y29kZT5UaW1lc3RhbXA8L2NvZGU+PC9wPgotPC9saT4KLTwvdWw+Ci08cD5UbyBjcmVhdGUgYSB2ZXJzaW9uIG1hcHBpbmc6PC9wPgotPG9sIHN0YXJ0PSIxIj4KLTxsaT4KLTxwPkluIHRoZSA8YSBocmVmPSJyZWZfcGVyc2lzdGVuY2Vfb3V0bGluZS5odG0jQkFCRUdHRkUiPkpQQSBTdHJ1Y3R1cmUgdmlldzwvYT4sIHNlbGVjdCB0aGUgZmllbGQgdG8gbWFwLjwvcD4KLTwvbGk+Ci08bGk+Ci08cD5SaWdodC1jbGljayB0aGUgZmllbGQgYW5kIHRoZW4gc2VsZWN0IDxzcGFuIGNsYXNzPSJib2xkIj5NYXAgQXMgJmd0OyBWZXJzaW9uPC9zcGFuPi4gVGhlIDxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0jQkFCSUZCQUYiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBhdHRyaWJ1dGVzKTwvYT4gZGlzcGxheXMgdGhlIHByb3BlcnRpZXMgZm9yIHRoZSBzZWxlY3RlZC48L3A+Ci08L2xpPgotPGxpPgotPHA+VXNlIHRoaXMgdGFibGUgdG8gY29tcGxldGUgdGhlIHJlbWFpbmluZyBmaWVsZHMgaW4gdGhlIEpQQSBEZXRhaWxzIHZpZXcuPC9wPgotPGRpdiBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIj4KLTx0YWJsZSBjbGFzcz0iUnVsZUluZm9ybWFsIiB0aXRsZT0iVGhpcyB0YWJsZSBsaXN0cyB0aGUgZmllbGRzIGluIHRoZSBQZXJzaXN0ZW5jZSBQcm9wZXJ0aWVzIHZpZXcgZm9yIHRoaXMgbWFwcGluZy4iIHN1bW1hcnk9IlRoaXMgdGFibGUgbGlzdHMgdGhlIGZpZWxkcyBpbiB0aGUgUGVyc2lzdGVuY2UgUHJvcGVydGllcyB2aWV3IGZvciB0aGlzIG1hcHBpbmcuIiBkaXI9Imx0ciIgYm9yZGVyPSIxIiB3aWR0aD0iMTAwJSIgZnJhbWU9ImJvcmRlciIgcnVsZXM9ImFsbCIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0aGVhZD4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzEtdDI4Ij5Qcm9wZXJ0eTwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMi10MjgiPkRlc2NyaXB0aW9uPC90aD4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMzLXQyOCI+RGVmYXVsdDwvdGg+Ci08L3RyPgotPC90aGVhZD4KLTx0Ym9keT4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjJjMS10MjgiIGhlYWRlcnM9InIxYzEtdDI4Ij5NYXBwZWQgRW50aXR5IEh5cGVybGluazwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDI4IHIxYzItdDI4Ij5EZWZpbmVzIHRoZSBtYXBwaW5nIGFzIFZlcnNpb24uIFRoaXMgY29ycmVzcG9uZHMgdG8gdGhlIDxjb2RlPkBWZXJzaW9uPC9jb2RlPiBhbm5vdGF0aW9uLjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDI4IHIxYzMtdDI4Ij5WZXJzaW9uPC90ZD4KLTwvdHI+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0ZCBhbGlnbj0ibGVmdCIgaWQ9InIzYzEtdDI4IiBoZWFkZXJzPSJyMWMxLXQyOCI+Q29sdW1uPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjNjMS10MjggcjFjMi10MjgiPlRoZSBkYXRhYmFzZSBjb2x1bW4gbWFwcGVkIHRvIHRoZSBlbnRpdHkgYXR0cmlidXRlLiBTZWUgPGEgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jQ0FDR0NCSEIiPiJDb2x1bW4iPC9hPiBmb3IgZGV0YWlscy48L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQyOCByMWMzLXQyOCI+QnkgZGVmYXVsdCwgdGhlIENvbHVtbiBpcyBhc3N1bWVkIHRvIGJlIG5hbWVkIGlkZW50aWNhbGx5IHRvIHRoZSBhdHRyaWJ1dGUgYW5kIGFsd2F5cyBpbmNsdWRlZCBpbiB0aGUgPGNvZGU+SU5TRVJUPC9jb2RlPiBhbmQgPGNvZGU+VVBEQVRFPC9jb2RlPiBzdGF0ZW1lbnRzLjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNGMxLXQyOCIgaGVhZGVycz0icjFjMS10MjgiPlRhYmxlPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MjggcjFjMi10MjgiPk5hbWUgb2YgdGhlIGRhdGFiYXNlIHRhYmxlLiBUaGlzIG11c3QgYmUgdGhlIHByaW1hcnkgdGFibGUgYXNzb2NpYXRlZCB3aXRoIHRoZSBhdHRyaWJ1dGUncyBlbnRpdHkuPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjRjMS10MjggcjFjMy10MjgiPjxiciAvPjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNWMxLXQyOCIgaGVhZGVycz0icjFjMS10MjgiPlRlbXBvcmFsPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MjggcjFjMi10MjgiPlNwZWNpZmllcyB0aGUgdHlwZSBvZiBkYXRhLiBTZWUgPGEgaHJlZj0icmVmX21hcHBpbmdfZ2VuZXJhbC5odG0jQ0FDRUFKR0QiPiJUZW1wb3JhbCI8L2E+IGZvciBkZXRhaWxzLgotPHVsPgotPGxpPgotPHA+RGF0ZTwvcD4KLTwvbGk+Ci08bGk+Ci08cD5UaW1lPC9wPgotPC9saT4KLTxsaT4KLTxwPlRpbWVzdGFtcDwvcD4KLTwvbGk+Ci08L3VsPgotPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjVjMS10MjggcjFjMy10MjgiPjxiciAvPjwvdGQ+Ci08L3RyPgotPC90Ym9keT4KLTwvdGFibGU+Ci08YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCIgLS0+PC9saT4KLTwvb2w+Ci08cD5FY2xpcHNlIGFkZHMgdGhlIGZvbGxvd2luZyBhbm5vdGF0aW9ucyB0byB0aGUgZmllbGQ6PC9wPgotPHByZSB4bWw6c3BhY2U9InByZXNlcnZlIiBjbGFzcz0ib2FjX25vX3dhcm4iPgotQFZlcnNpb24KLUBDb2x1bW4odGFibGU9IjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtDT0xVTU5fVEFCTEUmZ3Q7PC9zcGFuPiIsIG5hbWU9IiZsdDs8c3BhbiBjbGFzcz0iaXRhbGljIj5DT0xVTU5fTkFNRTwvc3Bhbj4mZ3Q7IikKLQotPC9wcmU+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrX21hcHBpbmcuaHRtI0JBQkRHQklKIj5NYXBwaW5nIGFuIGVudGl0eTwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxyLnBuZyIgYWx0PSJSZWxhdGVkIHJlZmVyZW5jZSIgdGl0bGU9IlJlbGF0ZWQgcmVmZXJlbmNlIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJyZWZfcGVyc2lzdGVuY2Vfb3V0bGluZS5odG0jQkFCRUdHRkUiPkpQQSBTdHJ1Y3R1cmUgdmlldzwvYT48YnIgLz4KLTxhIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0jQkFCSUZCQUYiPkpQQSBEZXRhaWxzIHZpZXcgKGZvciBhdHRyaWJ1dGVzKTwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxjLnBuZyIgYWx0PSJSZWxhdGVkIGNvbmNlcHQiIHRpdGxlPSJSZWxhdGVkIGNvbmNlcHQiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9ImNvbmNlcHRfbWFwcGluZy5odG0jQkFCQkRKRkkiPlVuZGVyc3RhbmRpbmcgT1IgbWFwcGluZ3M8L2E+PGJyIC8+Ci08YSBocmVmPSJjb25jZXB0czAwMS5odG0jQkFCQkdGSkciPlVuZGVyc3RhbmRpbmcgRUpCIDMuMCBKYXZhIFBlcnNpc3RlbmNlIEFQSTwvYT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QyIiAtLT4KLTwhLS0gY2xhc3M9InNlY3QxIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAyMC5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMjAuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxNWI3YTdkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAyMC5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw2NiArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0OCAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPkdlbmVyYXRpbmcgZW50aXRpZXMgZnJvbSB0YWJsZXM8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJHZW5lcmF0aW5nIGVudGl0aWVzIGZyb20gdGFibGVzIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkFCQkFHRkkiIG5hbWU9IkJBQkJBR0ZJIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDEiPgotPGgxPkdlbmVyYXRpbmcgZW50aXRpZXMgZnJvbSB0YWJsZXM8L2gxPgotPHA+PGEgaWQ9InN0aHJlZjE0MSIgbmFtZT0ic3RocmVmMTQxIj48L2E+PGEgaWQ9InN0aHJlZjE0MiIgbmFtZT0ic3RocmVmMTQyIj48L2E+VXNlIHRoaXMgcHJvY2VkdXJlIHRvIGdlbmVyYXRlIEphdmEgcGVyc2lzdGVudCBlbnRpdGllcyBmcm9tIGRhdGFiYXNlIHRhYmxlcy4gWW91IG11c3QgY3JlYXRlIGEgSlBBIHByb2plY3QgYW5kIGVzdGFibGlzaCBhIGRhdGFiYXNlIGNvbm5lY3Rpb24gPHNwYW4gY2xhc3M9Iml0YWxpYyI+YmVmb3JlPC9zcGFuPiBnZW5lcmF0aW5nIHBlcnNpc3RlbnQgZW50aXRpZXMuIFNlZSA8YSBocmVmPSJ0YXNrX2NyZWF0ZV9uZXdfcHJvamVjdC5odG0jQ0lISEVKQ0oiPiJDcmVhdGluZyBhIG5ldyBKUEEgcHJvamVjdCI8L2E+IGZvciBtb3JlIGluZm9ybWF0aW9uLjwvcD4KLTxvbCBzdGFydD0iMSI+Ci08bGk+Ci08cD5SaWdodC1jbGljayB0aGUgSlBBIHByb2plY3QgaW4gdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5QYWNrYWdlIEV4cGxvcmVyPC9zcGFuPiBhbmQgc2VsZWN0IDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LWFjdGlvbiI+SlBBIFRvb2xzICZndDsgR2VuZXJhdGUgRW50aXRpZXM8L3NwYW4+LjwvcD4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9InN0aHJlZjE0MyIgbmFtZT0ic3RocmVmMTQzIj48L2E+Ci08cCBjbGFzcz0idGl0bGVpbmZpZ3VyZSI+R2VuZXJhdGluZyBFbnRpdGllczwvcD4KLTxpbWcgc3JjPSJpbWcvZ2VuZXJhdGVfZW50aXRpZXMucG5nIiBhbHQ9IlVzaW5nIHRoZSBKUEEgVG9vbHMgJmd0OyBHZW5lcmF0ZSBFbnRpdGllcyBtZW51IG9wdGlvbi4iIHRpdGxlPSJVc2luZyB0aGUgSlBBIFRvb2xzICZndDsgR2VuZXJhdGUgRW50aXRpZXMgbWVudSBvcHRpb24uIiAvPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iZmlndXJlIiAtLT48L2xpPgotPGxpPgotPHA+SWYgeW91IGFyZSBub3QgY3VycmVudGx5IGNvbm5lY3RlZCB0byB0aGUgZGF0YWJhc2UsIHRoZSBEYXRhYmFzZSBDb25uZWN0aW9uIHBhZ2UgYXBwZWFycy4gU2VsZWN0IHlvdXIgZGF0YWJhc2UgY29ubmVjdGlvbiBhbmQgc2NoZW1hLCBhbmQgY2xpY2sgPHNwYW4gY2xhc3M9ImJvbGQiPlJlY29ubmVjdDwvc3Bhbj4uPC9wPgotPHA+VG8gY3JlYXRlIGEgbmV3IGRhdGFiYXNlIGNvbm5lY3Rpb24sIGNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5BZGQgY29ubmVjdGlvbjwvc3Bhbj4uPC9wPgotPHA+QWZ0ZXIgY29ubmVjdGluZyB0byB0aGUgZGF0YWJhc2UsIGNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5OZXh0PC9zcGFuPi48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaWQ9InN0aHJlZjE0NCIgbmFtZT0ic3RocmVmMTQ0Ij48L2E+PGEgaWQ9InN0aHJlZjE0NSIgbmFtZT0ic3RocmVmMTQ1Ij48L2E+T24gdGhlIDxhIGhyZWY9InRhc2tfZ2VuZXJhdGVfZW50aXRpZXMuaHRtI0NBQ0RBRkpEIj5HZW5lcmF0ZSBFbnRpdGllcyBmcm9tIFRhYmxlcyBkaWFsb2c8L2E+IGRpYWxvZywgc2VsZWN0IHRoZSB0YWJsZXMgZnJvbSB3aGljaCB0byBnZW5lcmF0ZSBKYXZhIHBlcnNpc3RlbnQgZW50aXRpZXMgYW5kIGNsaWNrIDxzcGFuIGNsYXNzPSJib2xkIj5GaW5pc2g8L3NwYW4+LjwvcD4KLTwvbGk+Ci08L29sPgotPHA+RWNsaXBzZSBjcmVhdGVzIGEgSmF2YSBwZXJzaXN0ZW50IGVudGl0eSBmb3IgZWFjaCBkYXRhYmFzZSB0YWJsZS4gRWFjaCBlbnRpdHkgY29udGFpbnMgZmllbGRzIGJhc2VkIG9uIHRoZSB0YWJsZSdzIGNvbHVtbnMuIEVjbGlwc2Ugd2lsbCBhbHNvIGdlbmVyYXRlIGVudGl0eSByZWxhdGlvbnNoaXBzIChzdWNoIGFzIG9uZS10by1vbmUpIGJhc2VkIG9uIHRoZSB0YWJsZSBjb25zdHJhaW50cy4gPGEgaHJlZj0iI0NJSEpJSkpDIj5GaWd1cmU6IEdlbmVyYXRpbmcgRW50aXRpZXMgZnJvbSBUYWJsZXM8L2E+IGlsbHVzdHJhdGVzIGhvdyBFY2xpcHNlIGdlbmVyYXRlcyBlbnRpdGllcyBmcm9tIHRhYmxlcy48L3A+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJDSUhKSUpKQyIgbmFtZT0iQ0lISklKSkMiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWluZmlndXJlIj5HZW5lcmF0aW5nIEVudGl0aWVzIGZyb20gVGFibGVzPC9wPgotPGltZyBzcmM9ImltZy90YWJsZV9lbnRpdHkucG5nIiBhbHQ9IlRoaXMgZmlndXJlIHNob3dzIHRoZSBFTVBMT1lFRSBhbmQgQUREUkVTUyBlbnRpdGllcyBnZW5lcmF0ZWQgZnJvbSBkYXRhYmFzZSB0YWJsZXMuIiB0aXRsZT0iVGhpcyBmaWd1cmUgc2hvd3MgdGhlIEVNUExPWUVFIGFuZCBBRERSRVNTIGVudGl0aWVzIGdlbmVyYXRlZCBmcm9tIGRhdGFiYXNlIHRhYmxlcy4iIC8+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJmaWd1cmUiIC0tPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxwPjxhIGhyZWY9InRhc2tfY3JlYXRlX25ld19wcm9qZWN0Lmh0bSNDSUhIRUpDSiI+Q3JlYXRpbmcgYSBuZXcgSlBBIHByb2plY3Q8L2E+PC9wPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHIucG5nIiBhbHQ9IlJlbGF0ZWQgcmVmZXJlbmNlIiB0aXRsZT0iUmVsYXRlZCByZWZlcmVuY2UiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InJlZl9wcm9qZWN0X3Byb3BlcnRpZXMuaHRtI0JBQkpIQkNJIj5Qcm9qZWN0IFByb3BlcnRpZXMgcGFnZSAmbmRhc2g7IEpQQSBPcHRpb25zPC9hPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDEiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDIxLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAyMS5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDI0NmYxZTQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDIxLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDQ3ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQ4IC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+R2VuZXJhdGluZyBEREwgZnJvbSBFbnRpdGllczwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IkdlbmVyYXRpbmcgRERMIGZyb20gRW50aXRpZXMiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJDSUhKSUdCRSIgbmFtZT0iQ0lISklHQkUiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MSI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPkdlbmVyYXRpbmcgRERMIGZyb20gRW50aXRpZXM8L2gxPgotPHA+V2hlbiB1c2luZyBhIHZlbmRvci1zcGVjaWZpYyBwbGF0Zm9ybSwgeW91IGNhbiBjcmVhdGUgYSBEREwgc2NyaXB0IGZyb20geW91ciBwZXJzaXN0ZW50IGVudGl0aWVzLjwvcD4KLTxwPlRvIGdlbmVyYXRlIGEgRERMIHNjcmlwdDo8L3A+Ci08cD5SaWdodC1jbGljayB0aGUgSlBBIHByb2plY3QgaW4gdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5QYWNrYWdlIEV4cGxvcmVyPC9zcGFuPiBhbmQgc2VsZWN0IDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LWFjdGlvbiI+SlBBIFRvb2xzICZndDsgR2VuZXJhdGUgRERMPC9zcGFuPi48L3A+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPHA+PGEgaHJlZj0idGFza3MwMDEuaHRtI0JBQkZCSkJHIj5DcmVhdGluZyBhIEpQQSBFbnRpdHk8L2E+PC9wPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHIucG5nIiBhbHQ9IlJlbGF0ZWQgcmVmZXJlbmNlIiB0aXRsZT0iUmVsYXRlZCByZWZlcmVuY2UiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InJlZl9wcm9qZWN0X3Byb3BlcnRpZXMuaHRtI0JBQkpIQkNJIj5Qcm9qZWN0IFByb3BlcnRpZXMgcGFnZSAmbmRhc2g7IEpQQSBPcHRpb25zPC9hPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDEiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDIyLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAyMi5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDg5Mjg1NWYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDIyLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDUzICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjQ4IC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+VmFsaWRhdGluZyBtYXBwaW5ncyBhbmQgcmVwb3J0aW5nIHByb2JsZW1zPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iVmFsaWRhdGluZyBtYXBwaW5ncyBhbmQgcmVwb3J0aW5nIHByb2JsZW1zIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkFCRkFJQkEiIG5hbWU9IkJBQkZBSUJBIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDEiPgotPGgxPlZhbGlkYXRpbmcgbWFwcGluZ3MgYW5kIHJlcG9ydGluZyBwcm9ibGVtczwvaDE+Ci08cD48YSBpZD0ic3RocmVmMTQ2IiBuYW1lPSJzdGhyZWYxNDYiPjwvYT48YSBpZD0ic3RocmVmMTQ3IiBuYW1lPSJzdGhyZWYxNDciPjwvYT48YSBpZD0ic3RocmVmMTQ4IiBuYW1lPSJzdGhyZWYxNDgiPjwvYT48YSBpZD0ic3RocmVmMTQ5IiBuYW1lPSJzdGhyZWYxNDkiPjwvYT5FcnJvcnMgYW5kIHdhcm5pbmdzIG9uIHBlcnNpc3RlbnQgZW50aXRpZXMgYW5kIG1hcHBpbmdzIGFyZSBpbmRpY2F0ZWQgd2l0aCBhIHJlZCBlcnJvciBvciB5ZWxsb3cgd2FybmluZyBuZXh0IHRvIHRoZSByZXNvdXJjZSB3aXRoIHRoZSBlcnJvciwgYXMgd2VsbCBhcyB0aGUgcGFyZW50IGNvbnRhaW5lcnMgdXAgdG8gdGhlIHByb2plY3QuPC9wPgotPGRpdiBjbGFzcz0iZmlndXJlIj48YSBpZD0ic3RocmVmMTUwIiBuYW1lPSJzdGhyZWYxNTAiPjwvYT4KLTxwIGNsYXNzPSJ0aXRsZWluZmlndXJlIj5TYW1wbGUgRXJyb3JzIGFuZCBXYXJuaW5nczwvcD4KLTxpbWcgc3JjPSJpbWcvZXJyb3Jfc2FtcGxlLnBuZyIgYWx0PSJUaGlzIGZpZ3VyZSBzaG93cyBzYW1wbGUgZXJyb3IgYW5kIHdhcm5pbmcgaWNvbnMgaW4gdGhlIEV4cGxvcmVyIHZpZXcuIiB0aXRsZT0iVGhpcyBmaWd1cmUgc2hvd3Mgc2FtcGxlIGVycm9yIGFuZCB3YXJuaW5nIGljb25zIGluIHRoZSBFeHBsb3JlciB2aWV3LiIgLz48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9ImZpZ3VyZSIgLS0+Ci08cD5UaGlzIHNlY3Rpb24gY29udGFpbnMgaW5mb3JtYXRpb24gb24gdGhlIGZvbGxvd2luZzo8L3A+Ci08dWw+Ci08bGk+Ci08cD48YSBocmVmPSJ0YXNrczAyMy5odG0jQ0lIRkVERUkiPkVycm9yIG1lc3NhZ2VzPC9hPjwvcD4KLTwvbGk+Ci08bGk+Ci08cD48YSBocmVmPSJ0YXNrczAyNC5odG0jQ0lIR0VBSUoiPldhcm5pbmcgbWVzc2FnZXM8L2E+PC9wPgotPC9saT4KLTwvdWw+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsYy5wbmciIGFsdD0iUmVsYXRlZCBjb25jZXB0IiB0aXRsZT0iUmVsYXRlZCBjb25jZXB0IiAvPjxiciAvPgotPHA+PGEgaHJlZj0iLi4vb3JnLmVjbGlwc2UucGxhdGZvcm0uZG9jLnVzZXIvY29uY2VwdHMvY3ByYnZpZXcuaHRtIj5Qcm9ibGVtcyB2aWV3PC9hPjwvcD4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT48L2Rpdj4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAyMy5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMjMuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhZjI1NDFiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAyMy5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw5MSArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0OSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPkVycm9yIG1lc3NhZ2VzPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iRXJyb3IgbWVzc2FnZXMiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJDSUhGRURFSSIgbmFtZT0iQ0lIRkVERUkiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MiI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPkVycm9yIG1lc3NhZ2VzPGEgaWQ9InN0aHJlZjE1MSIgbmFtZT0ic3RocmVmMTUxIj48L2E+PC9oMT4KLTxwPlRoaXMgc2VjdGlvbiBjb250YWlucyBpbmZvcm1hdGlvbiBvbiBlcnJvciBtZXNzYWdlcyAoaW5jbHVkaW5nIGhvdyB0byByZXNvbHZlIHRoZSBpc3N1ZSkgeW91IG1heSBlbmNvdW50ZXIgd2hpbGUgd29ya2luZyB3aXRoIERhbGkuPC9wPgotPGEgaWQ9InN0aHJlZjE1MiIgbmFtZT0ic3RocmVmMTUyIj48L2E+Ci08cCBjbGFzcz0ic3ViaGVhZDIiPkF0dHJpYnV0ZSAiPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O0FUVFJJQlVURV9fTkFNRSZndDs8L3NwYW4+IiBoYXMgaW52YWxpZCBtYXBwaW5nIHR5cGUgaW4gdGhpcyBjb250ZXh0PC9wPgotPHA+VGhlIG1hcHBlZCBhdHRyaWJ1dGUgaXMgaW52YWxpZC4gRWl0aGVyIGNoYW5nZSB0aGUgbWFwcGluZyB0eXBlIG9yIGNoYW5nZSB0aGUgZW50aXR5IHR5cGUuPC9wPgotPHA+U2VlIDxhIGhyZWY9InRhc2tfbWFwcGluZy5odG0jQkFCREdCSUoiPiJNYXBwaW5nIGFuIGVudGl0eSI8L2E+IGZvciBtb3JlIGluZm9ybWF0aW9uLjwvcD4KLTxhIGlkPSJzdGhyZWYxNTMiIG5hbWU9InN0aHJlZjE1MyI+PC9hPgotPHAgY2xhc3M9InN1YmhlYWQyIj5BdHRyaWJ1dGUgIjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtBVFRSSUJVVEVfTkFNRSZndDs8L3NwYW4+IiBjYW5ub3QgYmUgcmVzb2x2ZWQuPC9wPgotPHA+RGFsaSBjYW5ub3QgbWFwIHRoZSBhdHRyaWJ1dGUgdG8gYSBkYXRhYmFzZSB0YWJsZSBhbmQgY29sdW1uLiBWZXJpZnkgdGhhdCB5b3UgZGF0YWJhc2UgY29ubmVjdGlvbiBpbmZvcm1hdGlvbiBpcyBjb3JyZWN0LjwvcD4KLTxwPlNlZSA8YSBocmVmPSJ0YXNrX2NyZWF0ZV9uZXdfcHJvamVjdC5odG0jQ0lISEVKQ0oiPiJDcmVhdGluZyBhIG5ldyBKUEEgcHJvamVjdCI8L2E+IGZvciBtb3JlIGluZm9ybWF0aW9uLjwvcD4KLTxhIGlkPSJzdGhyZWYxNTQiIG5hbWU9InN0aHJlZjE1NCI+PC9hPgotPHAgY2xhc3M9InN1YmhlYWQyIj5DbGFzcyAiPHNwYW4gY2xhc3M9Iml0YWxpYyI+Jmx0O0NMQVNTX05BTUUmZ3Q7PC9zcGFuPiIgaXMgbm90IGFubm90YXRlZCBhcyBhIHBlcnNpc3RlbnQgY2xhc3MuPC9wPgotPHA+VGhlIGNsYXNzIGhhcyBub3QgYmVlbiBpZGVudGlmaWVkIGFzIGEgcGVyc2lzdGVudCBjbGFzcy4gQ29uZmlndXJlIHRoZSBjbGFzcyBhcyBhbiBFbnRpdHksIE1hcHBlZCBTdXBlcmNsYXNzLCBvciBFbWJlZGRhYmxlIHBlcnNpc3RlbnQgZW50aXR5LjwvcD4KLTxwPlNlZSA8YSBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0jQkFCSElDQUkiPiJBZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBjbGFzcyI8L2E+LjwvcD4KLTxhIGlkPSJzdGhyZWYxNTUiIG5hbWU9InN0aHJlZjE1NSI+PC9hPgotPHAgY2xhc3M9InN1YmhlYWQyIj5Db2x1bW4gIjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtDT0xVTU5fTkFNRSZndDs8L3NwYW4+IiBjYW5ub3QgYmUgcmVzb2x2ZWQuPC9wPgotPHA+WW91IG1hcHBlZCBhbiBlbnRpdHkncyBmaWVsZCB0byBhbiBpbmNvcnJlY3Qgb3IgaW52YWxpZCBjb2x1bW4gaW4gdGhlIGRhdGFiYXNlIHRhYmxlLiBCeSBkZWZhdWx0LCBEYWxpIHdpbGwgYXR0ZW1wdCB0byBtYXAgZWFjaCBmaWVsZCBpbiB0aGUgZW50aXR5IHdpdGggYW4gaWRlbnRpY2FsbHkgbmFtZWQgcm93IGluIHRoZSBkYXRhYmFzZSB0YWJsZS4gSWYgdGhlIGZpZWxkJ3MgbmFtZSBkaWZmZXJzIGZyb20gdGhlIHJvdydzIG5hbWUsIHlvdSBtdXN0IGV4cGxpY2l0bHkgY3JlYXRlIHRoZSBtYXBwaW5nLjwvcD4KLTxwPk1hcCB0aGUgZmllbGQgdG8gYSB2YWxpZCByb3cgaW4gdGhlIGRhdGFiYXNlIHRhYmxlIGFzIHNob3duIGluIDxhIGhyZWY9InRhc2tfbWFwcGluZy5odG0jQkFCREdCSUoiPiJNYXBwaW5nIGFuIGVudGl0eSI8L2E+LjwvcD4KLTxhIGlkPSJzdGhyZWYxNTYiIG5hbWU9InN0aHJlZjE1NiI+PC9hPgotPHAgY2xhc3M9InN1YmhlYWQyIj5EdXBsaWNhdGUgY2xhc3MgIjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtDTEFTU19OQU1FJmd0Ozwvc3Bhbj4iLjwvcD4KLTxwPllvdSBjcmVhdGVkIHRvIHBlcnNpc3RlbmNlIGNsYXNzZXMgd2l0aCB0aGUgc2FtZSBuYW1lLiBFYWNoIEphdmEgY2xhc3MgbXVzdCBoYXZlIGEgdW5pcXVlIG5hbWUuIFNlZSA8YSBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0jQkFCSElDQUkiPiJBZGRpbmcgcGVyc2lzdGVuY2UgdG8gYSBjbGFzcyI8L2E+IGZvciBtb3JlIGluZm9ybWF0aW9uLjwvcD4KLTxhIGlkPSJzdGhyZWYxNTciIG5hbWU9InN0aHJlZjE1NyI+PC9hPgotPHAgY2xhc3M9InN1YmhlYWQyIj5FbnRpdHkgZG9lcyBub3QgaGF2ZSBhbiBJZCBvciBFbWJlZGRlZCBJZC48L3A+Ci08cD5Zb3UgY3JlYXRlZCBhIHBlcnNpc3RlbnQgZW50aXR5IHdpdGhvdXQgaWRlbnRpZnlpbmcgaXRzIHByaW1hcnkga2V5LiBBIHBlcnNpc3RlbnQgZW50aXR5IG11c3QgaGF2ZSBhIHByaW1hcnkga2V5IGZpZWxkIGRlc2lnbmF0ZWQgd2l0aCBhbiA8Y29kZT5ASWQ8L2NvZGU+IG9yIDxjb2RlPkBFbWJlZGRlZElkPC9jb2RlPiBhbm5vdGF0aW9uLjwvcD4KLTxwPkFkZCBhbiBJRCBtYXBwaW5nIHRvIHRoZSBlbnRpdHkgYXMgc2hvd24gaW4gPGEgaHJlZj0idGFza3MwMTMuaHRtI0JBQkdDQkhHIj4iSUQgbWFwcGluZyI8L2E+IG9yIDxhIGhyZWY9InRhc2tzMDEyLmh0bSNDSUhESUFFRSI+IkVtYmVkZGVkIElEIG1hcHBpbmciPC9hPi48L3A+Ci08YSBpZD0ic3RocmVmMTU4IiBuYW1lPSJzdGhyZWYxNTgiPjwvYT4KLTxwIGNsYXNzPSJzdWJoZWFkMiI+TXVsdGlwbGUgcGVyc2lzdGVuY2UueG1sIGZpbGVzIGluIHByb2plY3QuPC9wPgotPHA+WW91IGNyZWF0ZWQgYSBKUEEgcHJvamVjdCB3aXRoIG1vcmUgdGhhbiBvbmUgPGNvZGU+cGVyc2lzdGVuY2UueG1sPC9jb2RlPiBmaWxlLiBFYWNoIEpQQSBwcm9qZWN0IG11c3QgY29udGFpbiBhIDxzcGFuIGNsYXNzPSJpdGFsaWMiPnNpbmdsZTwvc3Bhbj4gPGNvZGU+cGVyc2lzdGVuY2UueG1sPC9jb2RlPiBmaWxlLjwvcD4KLTxwPlNlZSA8YSBocmVmPSJ0YXNrX21hbmFnZV9wZXJzaXN0ZW5jZS5odG0jQ0lIREFKSUQiPiJNYW5hZ2luZyB0aGUgcGVyc2lzdGVuY2UueG1sIGZpbGUiPC9hPiBmb3IgbW9yZSBpbmZvcm1hdGlvbi48L3A+Ci08YSBpZD0ic3RocmVmMTU5IiBuYW1lPSJzdGhyZWYxNTkiPjwvYT4KLTxwIGNsYXNzPSJzdWJoZWFkMiI+Tm8gcGVyc2lzdGVuY2UgdW5pdCBkZWZpbmVkLjwvcD4KLTxwPlRoZXJlIGlzIG5vIHBlcnNpc3RlbmNlIHVuaXQgZGVmaW5lZCBpbiB0aGUgPGNvZGU+cGVyc2lzdGVuY2UueG1sPC9jb2RlPiBmaWxlLiBVc2UgdGhlICZsdDtwZXJzaXN0ZW5jZS11bml0IG5hbWU9IjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtQRVJTSVNURU5DRV9VTklUX05BTUUmZ3Q7PC9zcGFuPiIgdGFnIHRvIGRlZmluZSB0aGUgcGVyc2lzdGVudCB1bml0LjwvcD4KLTxwPlNlZSA8YSBocmVmPSJ0YXNrX21hbmFnZV9vcm0uaHRtI0NJSERHRENEIj4iTWFuYWdpbmcgdGhlIG9ybS54bWwgZmlsZSI8L2E+IGZvciBtb3JlIGluZm9ybWF0aW9uLjwvcD4KLTxhIGlkPSJzdGhyZWYxNjAiIG5hbWU9InN0aHJlZjE2MCI+PC9hPgotPHAgY2xhc3M9InN1YmhlYWQyIj5ObyBwZXJzaXN0ZW5jZS54bWwgZmlsZSBpbiBwcm9qZWN0LjwvcD4KLTxwPllvdSBjcmVhdGVkIGEgSlBBIHByb2plY3Qgd2l0aG91dCBhIDxjb2RlPnBlcnNpc3RlbmNlLnhtbDwvY29kZT4gZmlsZS4gRWFjaCBKUEEgcHJvamVjdCBtdXN0IGNvbnRhaW4gYSA8c3BhbiBjbGFzcz0iaXRhbGljIj5zaW5nbGU8L3NwYW4+IDxjb2RlPnBlcnNpc3RlbmNlLnhtbDwvY29kZT4gZmlsZS48L3A+Ci08cD5TZWUgPGEgaHJlZj0idGFza19tYW5hZ2VfcGVyc2lzdGVuY2UuaHRtI0NJSERBSklEIj4iTWFuYWdpbmcgdGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlIjwvYT4gZm9yIG1vcmUgaW5mb3JtYXRpb24uPC9wPgotPGEgaWQ9InN0aHJlZjE2MSIgbmFtZT0ic3RocmVmMTYxIj48L2E+Ci08cCBjbGFzcz0ic3ViaGVhZDIiPlJlZmVyZW5jZWQgY29sdW1uICI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7Q09MVU1OX05BTUUmZ3Q7PC9zcGFuPiIgaW4gam9pbiBjb2x1bW4gIjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtDT0xVTU5fTkFNRSZndDs8L3NwYW4+IiBjYW5ub3QgYmUgcmVzb2x2ZWQuPC9wPgotPHA+VGhlIGNvbHVtbiB0aGF0IHlvdSBzZWxlY3RlZCB0byBqb2luIGEgcmVsYXRpb25zaGlwIG1hcHBpbmcgZG9lcyBub3QgZXhpc3Qgb24gdGhlIGRhdGFiYXNlIHRhYmxlLiBFaXRoZXIgc2VsZWN0IGEgZGlmZmVyZW50IGNvbHVtbiBvbiB0aGUgPGEgaHJlZj0icmVmZXJlbmNlMDE0Lmh0bSNDQUNCQUVCQyI+Sm9pbiBUYWJsZSBJbmZvcm1hdGlvbjwvYT4gb3IgY3JlYXRlIHRoZSBuZWNlc3NhcnkgY29sdW1uIG9uIHRoZSBkYXRhYmFzZSB0YWJsZS48L3A+Ci08cD5TZWUgPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX21hcF92aWV3Lmh0bSNCQUJJRkJBRiI+IkpQQSBEZXRhaWxzIHZpZXcgKGZvciBhdHRyaWJ1dGVzKSI8L2E+IGZvciBtb3JlIGluZm9ybWF0aW9uLjwvcD4KLTxhIGlkPSJzdGhyZWYxNjIiIG5hbWU9InN0aHJlZjE2MiI+PC9hPgotPHAgY2xhc3M9InN1YmhlYWQyIj5TY2hlbWEgIiZsdDs8c3BhbiBjbGFzcz0iaXRhbGljIj5TQ0hFTUFfTkFNRTwvc3Bhbj4mZ3Q7IiBjYW5ub3QgYmUgcmVzb2x2ZWQgZm9yIHRhYmxlL2pvaW4gdGFibGUgIiZsdDs8c3BhbiBjbGFzcz0iaXRhbGljIj5UQUJMRV9OQU1FPC9zcGFuPiZndDsiLjwvcD4KLTxwPkRlZmluZSB0aGUgZGVmYXVsdCBkYXRhYmFzZSBzY2hlbWEgaW5mb3JtYXRpb24gaW4gdGhlIHBlcnNpc3RlbmNlIHVuaXQuPC9wPgotPHA+U2VlIDxhIGhyZWY9InRhc2tfbWFuYWdlX29ybS5odG0jQ0lIREdEQ0QiPiJNYW5hZ2luZyB0aGUgb3JtLnhtbCBmaWxlIjwvYT4gZm9yIG1vcmUgaW5mb3JtYXRpb24uPC9wPgotPGEgaWQ9InN0aHJlZjE2MyIgbmFtZT0ic3RocmVmMTYzIj48L2E+Ci08cCBjbGFzcz0ic3ViaGVhZDIiPlRhYmxlICI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7VEFCTEVfTkFNRSZndDs8L3NwYW4+IiBjYW5ub3QgYmUgcmVzb2x2ZWQuPC9wPgotPHA+WW91IGFzc29jaWF0ZWQgYSBwZXJzaXN0ZW50IGVudGl0eSB0byBhbiBpbmNvcnJlY3Qgb3IgaW52YWxpZCBkYXRhYmFzZSB0YWJsZS4gQnkgZGVmYXVsdCwgRGFsaSB3aWxsIGF0dGVtcHQgdG8gYXNzb2NpYXRlIGVhY2ggcGVyc2lzdGVudCBlbnRpdHkgd2l0aCBhbiBpZGVudGljYWxseSBuYW1lZCBkYXRhYmFzZSB0YWJsZS4gSWYgdGhlIGVudGl0eSdzIG5hbWUgZGlmZmVycyBmcm9tIHRoZSB0YWJsZSdzIG5hbWUsIHlvdSBtdXN0IGV4cGxpY2l0bHkgY3JlYXRlIHRoZSBhc3NvY2lhdGlvbi48L3A+Ci08cD5Bc3NvY2lhdGUgdGhlIGVudGl0eSB3aXRoIGEgdmFsaWQgZGF0YWJhc2UgdGFibGUgYXMgc2hvd24gaW4gPGEgaHJlZj0idGFza19hZGRfcGVyc2lzdGVuY2UuaHRtI0JBQkhJQ0FJIj4iQWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3MiPC9hPi48L3A+Ci08YSBpZD0ic3RocmVmMTY0IiBuYW1lPSJzdGhyZWYxNjQiPjwvYT4KLTxwIGNsYXNzPSJzdWJoZWFkMiI+VW5yZXNvdmx2ZWQgZ2VuZXJhdG9yICI8c3BhbiBjbGFzcz0iaXRhbGljIj4mbHQ7R0VORVJBVE9SX05BTUUmZ3Q7PC9zcGFuPiIgaXMgZGVmaW5lZCBpbiBwZXJzaXN0ZW5jZSB1bml0LjwvcD4KLTxwPllvdSBjcmVhdGVkIGEgcGVyc2lzdGVuY2UgZW50aXR5IHRoYXQgdXNlcyBzZXF1ZW5jaW5nIG9yIGEgdGFibGUgZ2VuZXJhdG9yLCBidXQgZGlkIG5vdCBkZWZpbmUgdGhlIGdlbmVyYXRvciBpbiB0aGUgcGVyc2lzdGVuY2UgdW5pdC4gRWl0aGVyIGRlZmluZSB0aGUgZ2VuZXJhdG9yIGJ5IHVzaW5nIGFuIGFubm90YXRpb24gb3IgaW5jbHVkaW5nIGl0IGluIHRoZSBYTUwgbWFwcGluZyBmaWxlLjwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxjLnBuZyIgYWx0PSJSZWxhdGVkIGNvbmNlcHQiIHRpdGxlPSJSZWxhdGVkIGNvbmNlcHQiIC8+PGJyIC8+Ci08cD48YSBocmVmPSIuLi9vcmcuZWNsaXBzZS5wbGF0Zm9ybS5kb2MudXNlci9jb25jZXB0cy9jcHJidmlldy5odG0iPlByb2JsZW1zIHZpZXc8L2E+PC9wPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MiIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMjQuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3Rhc2tzMDI0Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZmJjZGVjMy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMjQuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNDkgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NDkgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5XYXJuaW5nIG1lc3NhZ2VzPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iV2FybmluZyBtZXNzYWdlcyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkNJSEdFQUlKIiBuYW1lPSJDSUhHRUFJSiI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QyIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+V2FybmluZyBtZXNzYWdlczwvaDE+Ci08cD5UaGlzIHNlY3Rpb24gY29udGFpbnMgaW5mb3JtYXRpb24gb24gd2FybmluZyBtZXNzYWdlcyAoaW5jbHVkaW5nIGhvdyB0byByZXNvbHZlIHRoZSBpc3N1ZSkgeW91IG1heSBlbmNvdW50ZXIgd2hpbGUgd29ya2luZyB3aXRoIERhbGkuPC9wPgotPGEgaWQ9InN0aHJlZjE2NSIgbmFtZT0ic3RocmVmMTY1Ij48L2E+Ci08cCBjbGFzcz0ic3ViaGVhZDIiPkNvbm5lY3Rpb24gIjxzcGFuIGNsYXNzPSJpdGFsaWMiPiZsdDtDT05ORUNUSU9OX05BTUUmZ3Q7PC9zcGFuPiIgaXMgbm90IGFjdGl2ZS4gTm8gdmFsaWRhdGlvbiB3aWxsIGJlIGRvbmUgYWdhaW5zdCB0aGUgZGF0YSBzb3VyY2UuPC9wPgotPHA+VGhlIGRhdGFiYXNlIGNvbm5lY3Rpb24geW91IHNwZWNpZmllZCB0byB1c2Ugd2l0aCB0aGUgSlBBIHByb2plY3QgaXMgbm90IGFjdGl2ZS4gVGhlIEpQQSBwcm9qZWN0IHJlcXVpcmVzIGFuIGFjdGl2ZSBjb25uZWN0aW9uLjwvcD4KLTxhIGlkPSJzdGhyZWYxNjYiIG5hbWU9InN0aHJlZjE2NiI+PC9hPgotPHAgY2xhc3M9InN1YmhlYWQyIj5ObyBjb25uZWN0aW9uIHNwZWNpZmllZCBmb3IgdGhlIHByb2plY3QuIE5vIGRhdGEtc3BlY2lmaWMgdmFsaWRhdGlvbiB3aWxsIGJlIHBlcmZvcm1lZC48L3A+Ci08cD5Zb3UgY3JlYXRlZCBhIEpQQSBwcm9qZWN0IHdpdGhvdXQgc3BlY2lmeWluZyBhIGRhdGFiYXNlIGNvbm5lY3Rpb24uIFRoZSBKUEEgcHJvamVjdCByZXF1aXJlcyBhbiBhY3RpdmUgY29ubmVjdGlvbi48L3A+Ci08cD5TZWUgPGEgaHJlZj0idGFza19jcmVhdGVfbmV3X3Byb2plY3QuaHRtI0NJSEhFSkNKIj4iQ3JlYXRpbmcgYSBuZXcgSlBBIHByb2plY3QiPC9hPiBvciA8YSBocmVmPSJ0YXNrczAyNS5odG0jQkFCREJDQkkiPiJNb2RpZnlpbmcgcGVyc2lzdGVudCBwcm9qZWN0IHByb3BlcnRpZXMiPC9hPiBmb3IgaW5mb3JtYXRpb24gb24gc3BlY2lmeWluZyBhIGRhdGFiYXNlIGNvbm5lY3Rpb24uPC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxwPjxhIGhyZWY9Ii4uL29yZy5lY2xpcHNlLnBsYXRmb3JtLmRvYy51c2VyL2NvbmNlcHRzL2NwcmJ2aWV3Lmh0bSI+UHJvYmxlbXMgdmlldzwvYT48L3A+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QyIiAtLT4KLTwhLS0gY2xhc3M9InNlY3QxIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAyNS5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvdGFza3MwMjUuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhZTVmODAwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90YXNrczAyNS5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw4NyArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo0OSAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPk1vZGlmeWluZyBwZXJzaXN0ZW50IHByb2plY3QgcHJvcGVydGllczwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9Ik1vZGlmeWluZyBwZXJzaXN0ZW50IHByb2plY3QgcHJvcGVydGllcyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkJBQkRCQ0JJIiBuYW1lPSJCQUJEQkNCSSI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QxIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+TW9kaWZ5aW5nIHBlcnNpc3RlbnQgcHJvamVjdCBwcm9wZXJ0aWVzPC9oMT4KLTxwPkVhY2ggcGVyc2lzdGVudCBwcm9qZWN0IG11c3QgYmUgYXNzb2NpYXRlZCB3aXRoIGEgZGF0YWJhc2UgY29ubmVjdGlvbi4gVG8gY3JlYXRlIGEgbmV3IGRhdGFiYXNlIGNvbm5lY3Rpb24sIGNsaWNrIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LWFjdGlvbiI+RGF0YWJhc2UgQ29ubmVjdGlvbjwvc3Bhbj4gdXNlIHRoZSBOZXcgQ29ubmVjdGlvbiB3aXphcmQuPC9wPgotPHA+VXNlIHRoaXMgcHJvY2VkdXJlIHRvIG1vZGlmeSB0aGUgdmVuZGVyLXNwZWNpZmljIHBsYXRmb3JtIGFuZCBkYXRhYmFzZSBjb25uZWN0aW9uIGFzc29jaWF0ZWQgd2l0aCB5b3VyIEpQQSBwcm9qZWN0LjwvcD4KLTxvbCBzdGFydD0iMSI+Ci08bGk+Ci08cD5SaWdodC1jbGljayB0aGUgcHJvamVjdCBpbiB0aGUgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtdGl0bGUiPkV4cGxvcmVyPC9zcGFuPiB2aWV3IGFuZCBzZWxlY3QgPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtYWN0aW9uIj5Qcm9wZXJ0aWVzPC9zcGFuPi4gVGhlIFByb3BlcnRpZXMgcGFnZSBhcHBlYXJzLjwvcD4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9InN0aHJlZjE2NyIgbmFtZT0ic3RocmVmMTY3Ij48L2E+Ci08cCBjbGFzcz0idGl0bGVpbmZpZ3VyZSI+VGhlIFByb3BlcnRpZXMgUGFnZTwvcD4KLTxpbWcgc3JjPSJpbWcvcHJvamVjdF9wcm9wZXJ0aWVzX3Rhc2tzLnBuZyIgYWx0PSJUaGUgUGVyc2lzdGVuY2UgcGFnZS4iIHRpdGxlPSJUaGUgUGVyc2lzdGVuY2UgcGFnZS4iIC8+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJmaWd1cmUiIC0tPjwvbGk+Ci08bGk+Ci08cD5Vc2UgdGhpcyB0YWJsZSB0byBjb21wbGV0ZSB0aGUgcmVtYWluaW5nIGZpZWxkcyBvbiB0aGUgUHJvcGVydGllcyAmbmRhc2g7IEpQQSBwYWdlIGFuZCBjbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+T0s8L3NwYW4+LjwvcD4KLTxkaXYgY2xhc3M9ImluZnRibHJ1bGVpbmZvcm1hbCI+Ci08dGFibGUgY2xhc3M9IlJ1bGVJbmZvcm1hbCIgdGl0bGU9IlRoaXMgdGFibGUgbGlzdHMgdGhlIGZpZWxkcyBpbiB0aGUgUHJvcGVydGllcyAtIEphdmEgUGVyc2lzdGVuY2UgZGlhbG9nLiIgc3VtbWFyeT0iVGhpcyB0YWJsZSBsaXN0cyB0aGUgZmllbGRzIGluIHRoZSBQcm9wZXJ0aWVzIC0gSmF2YSBQZXJzaXN0ZW5jZSBkaWFsb2cuIiBkaXI9Imx0ciIgYm9yZGVyPSIxIiB3aWR0aD0iMTAwJSIgZnJhbWU9ImJvcmRlciIgcnVsZXM9ImFsbCIgY2VsbHBhZGRpbmc9IjMiIGNlbGxzcGFjaW5nPSIwIj4KLTx0aGVhZD4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzEtdDI5Ij5Qcm9wZXJ0eTwvdGg+Ci08dGggYWxpZ249ImxlZnQiIHZhbGlnbj0iYm90dG9tIiBpZD0icjFjMi10MjkiPkRlc2NyaXB0aW9uPC90aD4KLTwvdHI+Ci08L3RoZWFkPgotPHRib2R5PgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMmMxLXQyOSIgaGVhZGVycz0icjFjMS10MjkiPlBsYXRmb3JtPC90ZD4KLTx0ZCBhbGlnbj0ibGVmdCIgaGVhZGVycz0icjJjMS10MjkgcjFjMi10MjkiPlNlbGVjdCB0aGUgdmVuZG9yLXNwZWNpZmljIHBsYXRmb3JtIGZvciB0aGUgSlBBIGltcGxlbWVudGF0aW9uLjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyM2MxLXQyOSIgaGVhZGVycz0icjFjMS10MjkiPkRhdGFiYXNlIENvbm5lY3Rpb248L3RkPgotPHRkIGFsaWduPSJsZWZ0IiBoZWFkZXJzPSJyM2MxLXQyOSByMWMyLXQyOSI+RGF0YWJhc2UgY29ubmVjdGlvbiB0byB1c2UgdG8gc3RvcmUgdGhlIHBlcnNpc3RlbnQgZW50aXRpZXMuIFRvIGNyZWF0ZSBhIG5ldyBjb25uZWN0aW9uLCBjbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+QWRkIENvbm5lY3Rpb248L3NwYW4+LjwvdGQ+Ci08L3RyPgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyNGMxLXQyOSIgaGVhZGVycz0icjFjMS10MjkiPiZuYnNwOyZuYnNwO092ZXJyaWRlIGRlZmF1bHQgc2NoZW1hIGZyb20gY29ubmVjdGlvbjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InI0YzEtdDI5IHIxYzItdDI5Ij5TZWxlY3QgYSBzY2hlbWEgb3RoZXIgdGhhbiB0aGUgZGVmYXVsdCBvbmUgZGVyaXZlZCBmcm9tIHRoZSBjb25uZWN0aW9uIGluZm9ybWF0aW9uLiBVc2UgdGhpcyBvcHRpb24gaWYgdGhlIGRlZmF1bHQgc2NoZW1hIGNhbm5vdCBiZSB1c2VkLiBGb3IgZXhhbXBsZSwgdXNlIHRoaXMgb3B0aW9uIGluIGNhc2VzIHdoZXJlIHRoZSBkZXBsb3ltZW50IGxvZ2luIGRpZmZlcnMgZnJvbSB0aGUgZGVzaWduLXRpbWUgbG9naW4uPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIiAtLT48L2xpPgotPC9vbD4KLTxwPlRvIGNyZWF0ZSBhIG5ldyBjb25uZWN0aW9uLCBjbGljayA8c3BhbiBjbGFzcz0iYm9sZCI+QWRkIGNvbm5lY3Rpb25zPC9zcGFuPi48L3A+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrX2NyZWF0ZV9uZXdfcHJvamVjdC5odG0jQ0lISEVKQ0oiPkNyZWF0aW5nIGEgbmV3IEpQQSBwcm9qZWN0PC9hPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHIucG5nIiBhbHQ9IlJlbGF0ZWQgcmVmZXJlbmNlIiB0aXRsZT0iUmVsYXRlZCByZWZlcmVuY2UiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InJlZl9wcm9qZWN0X3Byb3BlcnRpZXMuaHRtI0JBQkpIQkNJIj5Qcm9qZWN0IFByb3BlcnRpZXMgcGFnZSAmbmRhc2g7IEpQQSBPcHRpb25zPC9hPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0iY29uY2VwdF9wZXJzaXN0ZW5jZS5odG0jQkFCQ0FISUMiPlVuZGVyc3RhbmRpbmcgSmF2YSBwZXJzaXN0ZW5jZTwvYT48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QxIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90aXBzX2FuZF90cmlja3MuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3RpcHNfYW5kX3RyaWNrcy5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDRiMzExMTEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3RpcHNfYW5kX3RyaWNrcy5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw2NSArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo1MyAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPlRpcHMgYW5kIHRyaWNrczwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IiBUaXBzIGFuZCB0cmlja3MiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJDSERIR0hCRiIgbmFtZT0iQ0hESEdIQkYiPjwvYT48L3A+Ci08aDE+VGlwcyBhbmQgdHJpY2tzPC9oMT4KLTxwPlRoZSBmb2xsb3dpbmcgdGlwcyBhbmQgdHJpY2tzIGdpdmUgc29tZSBoZWxwZnVsIGlkZWFzIGZvciBpbmNyZWFzaW5nIHlvdXIgcHJvZHVjdGl2aXR5LjwvcD4KLTx1bD4KLTxsaT4KLTxwPjxhIGhyZWY9IiNCQUJGSUlIQSI+PHNwYW4gY2xhc3M9ImJvbGQiPkRhdGFiYXNlIENvbm5lY3Rpb25zPC9zcGFuPjwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0iI0JBQkNIQUhGIj48c3BhbiBjbGFzcz0iYm9sZCI+U2NoZW1hLWJhc2VkIHBlcnNpc3RlbmNlLnhtbDwvc3Bhbj48L2E+PC9wPgotPC9saT4KLTwvdWw+Ci08ZGl2IGNsYXNzPSJpbmZ0YmxydWxlaW5mb3JtYWwiPgotPHRhYmxlIGNsYXNzPSJSdWxlSW5mb3JtYWwiIHRpdGxlPSJUaGlzIHRhYmxlIGxpc3RzIHRoZSB0aXBzIGFuZCB0cmlja3MgaW4gdGhpcyBjYXRlZ29yeS4iIHN1bW1hcnk9IlRoaXMgdGFibGUgbGlzdHMgdGhlIHRpcHMgYW5kIHRyaWNrcyBpbiB0aGlzIGNhdGVnb3J5LiIgZGlyPSJsdHIiIGJvcmRlcj0iMSIgd2lkdGg9IjEwMCUiIGZyYW1lPSJib3JkZXIiIHJ1bGVzPSJhbGwiIGNlbGxwYWRkaW5nPSIzIiBjZWxsc3BhY2luZz0iMCI+Ci08dGhlYWQ+Ci08dHIgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIj4KLTx0aCBhbGlnbj0ibGVmdCIgdmFsaWduPSJib3R0b20iIGlkPSJyMWMxLXQyIj5UaXA8L3RoPgotPHRoIGFsaWduPSJsZWZ0IiB2YWxpZ249ImJvdHRvbSIgaWQ9InIxYzItdDIiPkRlc2NyaXB0aW9uPC90aD4KLTwvdHI+Ci08L3RoZWFkPgotPHRib2R5PgotPHRyIGFsaWduPSJsZWZ0IiB2YWxpZ249InRvcCI+Ci08dGQgYWxpZ249ImxlZnQiIGlkPSJyMmMxLXQyIiBoZWFkZXJzPSJyMWMxLXQyIj48YSBpZD0iQkFCRklJSEEiIG5hbWU9IkJBQkZJSUhBIj48L2E+PHNwYW4gY2xhc3M9ImJvbGQiPkRhdGFiYXNlIENvbm5lY3Rpb25zPC9zcGFuPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIyYzEtdDIgcjFjMi10MiI+V2hlbiBzdGFydGluZyBhIG5ldyB3b3JrYmVuY2ggc2Vzc2lvbiwgYmUgc3VyZSB0byByZWNvbm5lY3QgdG8geW91ciBkYXRhYmFzZSAoaWYgeW91IGFyZSB3b3JraW5nIG9ubGluZSkuIFRoaXMgYWxsb3dzIERhbGkgdG8gcHJvdmlkZSBkYXRhYmFzZS1yZWxhdGVkIG1hcHBpbmcgYXNzaXN0YW5jZSBhbmQgdmFsaWRhdGlvbi48L3RkPgotPC90cj4KLTx0ciBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiPgotPHRkIGFsaWduPSJsZWZ0IiBpZD0icjNjMS10MiIgaGVhZGVycz0icjFjMS10MiI+PGEgaWQ9IkJBQkNIQUhGIiBuYW1lPSJCQUJDSEFIRiI+PC9hPjxzcGFuIGNsYXNzPSJib2xkIj5TY2hlbWEtYmFzZWQgcGVyc2lzdGVuY2UueG1sPC9zcGFuPjwvdGQ+Ci08dGQgYWxpZ249ImxlZnQiIGhlYWRlcnM9InIzYzEtdDIgcjFjMi10MiI+SWYgeW91IGFyZSBiZWhpbmQgYSBmaXJld2FsbCwgeW91IG1heSBuZWVkIHRvIGNvbmZpZ3VyZSB5b3VyIEVjbGlwc2Ugd29ya3NwYWNlIHByb3h5IGluIHRoZSA8YSBocmVmPSIuLi9vcmcuZWNsaXBzZS5wbGF0Zm9ybS5kb2MudXNlci9yZWZlcmVuY2UvcmVmLTcyLmh0bSI+UHJlZmVyZW5jZXMgZGlhbG9nPC9hPiAoPHNwYW4gY2xhc3M9Imd1aS1vYmplY3QtYWN0aW9uIj5QcmVmZXJlbmNlcyAmZ3Q7IEludGVybmV0ICZndDsgUHJveHkgU2V0dGluZ3M8L3NwYW4+KSB0byBwcm9wZXJseSB2YWxpZGF0ZSBhIHNjaGVtYS1iYXNlZCA8Y29kZT5wZXJzaXN0ZW5jZS54bWw8L2NvZGU+IGZpbGUuPC90ZD4KLTwvdHI+Ci08L3Rib2R5PgotPC90YWJsZT4KLTxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iaW5mdGJscnVsZWluZm9ybWFsIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci90b2MueG1sIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3RvYy54bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGM3ZDk5OTguLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3RvYy54bWwKKysrIC9kZXYvbnVsbApAQCAtMSwxMzAgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0nMS4wJyBlbmNvZGluZz0naXNvLTg4NTktMSc/PgotPCEtLSBVc2VyIEd1aWRlIC0tPgotICA8dG9jIGxhYmVsPSJEYWxpIEphdmEgUGVyc2lzdGVuY2UgVG9vbHMgVXNlciBHdWlkZSI+Ci0gICAgPHRvcGljIGhyZWY9ImdldHRpbmdfc3RhcnRlZC5odG0iIGxhYmVsPSJHZXR0aW5nIHN0YXJ0ZWQiPgotICAgICAgPHRvcGljIGhyZWY9ImdldHRpbmdfc3RhcnRlZDAwMS5odG0iIGxhYmVsPSJSZXF1aXJlbWVudHMgYW5kIGluc3RhbGxhdGlvbiIgLz4KLSAgICAgIDx0b3BpYyBocmVmPSJnZXR0aW5nX3N0YXJ0ZWQwMDIuaHRtIiBsYWJlbD0iRGFsaSBxdWljayBzdGFydCI+Ci0gICAgICAgIDx0b3BpYyBocmVmPSJnZXR0aW5nX3N0YXJ0ZWQwMDMuaHRtIiBsYWJlbD0iQ3JlYXRpbmcgYSBuZXcgSlBBIHByb2plY3QiIC8+Ci0gICAgICAgIDx0b3BpYyBocmVmPSJnZXR0aW5nX3N0YXJ0ZWQwMDQuaHRtIiBsYWJlbD0iQ3JlYXRpbmcgYSBKYXZhIHBlcnNpc3RlbnQgZW50aXR5IHdpdGggcGVyc2lzdGVudCBmaWVsZHMiIC8+Ci0gICAgICA8L3RvcGljPgotICAgIDwvdG9waWM+Ci0gICAgPHRvcGljIGhyZWY9ImNvbmNlcHRzLmh0bSIgbGFiZWw9IiBDb25jZXB0cyI+Ci0gICAgICA8dG9waWMgaHJlZj0iY29uY2VwdF9wZXJzaXN0ZW5jZS5odG0iIGxhYmVsPSJVbmRlcnN0YW5kaW5nIEphdmEgcGVyc2lzdGVuY2UiIC8+Ci0gICAgICA8dG9waWMgaHJlZj0iY29uY2VwdF9tYXBwaW5nLmh0bSIgbGFiZWw9IlVuZGVyc3RhbmRpbmcgT1IgbWFwcGluZ3MiIC8+Ci0gICAgICA8dG9waWMgaHJlZj0iY29uY2VwdHMwMDEuaHRtIiBsYWJlbD0iVW5kZXJzdGFuZGluZyBFSkIgMy4wIEphdmEgUGVyc2lzdGVuY2UgQVBJIj4KLSAgICAgICAgPHRvcGljIGhyZWY9ImNvbmNlcHRzMDAyLmh0bSIgbGFiZWw9IlRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZSIgLz4KLSAgICAgICAgPHRvcGljIGhyZWY9ImNvbmNlcHRzMDAzLmh0bSIgbGFiZWw9IlRoZSBvcm0ueG1sIGZpbGUiIC8+Ci0gICAgICA8L3RvcGljPgotICAgIDwvdG9waWM+Ci0gICAgPHRvcGljIGhyZWY9InRhc2tzLmh0bSIgbGFiZWw9IiBUYXNrcyI+Ci0gICAgICA8dG9waWMgaHJlZj0idGFza19jcmVhdGVfbmV3X3Byb2plY3QuaHRtIiBsYWJlbD0iQ3JlYXRpbmcgYSBuZXcgSlBBIHByb2plY3QiIC8+Ci0gICAgICA8dG9waWMgaHJlZj0idGFza3MwMDEuaHRtIiBsYWJlbD0iQ3JlYXRpbmcgYSBKUEEgRW50aXR5IiAvPgotICAgICAgPHRvcGljIGhyZWY9InRhc2tfbWFuYWdlX3BlcnNpc3RlbmNlLmh0bSIgbGFiZWw9Ik1hbmFnaW5nIHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZSI+Ci0gICAgICAgIDx0b3BpYyBocmVmPSJ0YXNrczAwMi5odG0iIGxhYmVsPSJVc2luZyB0aGUgWE1MIEVkaXRvciB0byBlZGl0IHRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZSIgLz4KLSAgICAgICAgPHRvcGljIGhyZWY9InRhc2tzMDAzLmh0bSIgbGFiZWw9IlN5bmNocm9uaXppbmcgY2xhc3NlcyIgLz4KLSAgICAgIDwvdG9waWM+Ci0gICAgICA8dG9waWMgaHJlZj0idGFza19tYW5hZ2Vfb3JtLmh0bSIgbGFiZWw9Ik1hbmFnaW5nIHRoZSBvcm0ueG1sIGZpbGUiPgotICAgICAgICA8dG9waWMgaHJlZj0idGFza3MwMDQuaHRtIiBsYWJlbD0iQ3JlYXRpbmcgYW4gb3JtLnhtbCBmaWxlIiAvPgotICAgICAgICA8dG9waWMgaHJlZj0idGFza3MwMDUuaHRtIiBsYWJlbD0iV29ya2luZyB3aXRoIG9ybS54bWwgZmlsZSIgLz4KLSAgICAgIDwvdG9waWM+Ci0gICAgICA8dG9waWMgaHJlZj0idGFza19hZGRfcGVyc2lzdGVuY2UuaHRtIiBsYWJlbD0iQWRkaW5nIHBlcnNpc3RlbmNlIHRvIGEgY2xhc3MiPgotICAgICAgICA8dG9waWMgaHJlZj0idGFza3MwMDYuaHRtIiBsYWJlbD0iRW50aXR5IiAvPgotICAgICAgICA8dG9waWMgaHJlZj0idGFza3MwMDcuaHRtIiBsYWJlbD0iRW1iZWRkYWJsZSIgLz4KLSAgICAgICAgPHRvcGljIGhyZWY9InRhc2tzMDA4Lmh0bSIgbGFiZWw9Ik1hcHBlZCBzdXBlcmNsYXNzIiAvPgotICAgICAgPC90b3BpYz4KLSAgICAgIDx0b3BpYyBocmVmPSJ0YXNrX2FkZGl0b25hbF90YWJsZXMuaHRtIiBsYWJlbD0iU3BlY2lmeWluZyBhZGRpdGlvbmFsIHRhYmxlcyIgLz4KLSAgICAgIDx0b3BpYyBocmVmPSJ0YXNrX2luaGVyaXRhbmNlLmh0bSIgbGFiZWw9IlNwZWNpZnlpbmcgZW50aXR5IGluaGVyaXRhbmNlIiAvPgotICAgICAgPHRvcGljIGhyZWY9InRhc2tzMDA5Lmh0bSIgbGFiZWw9IkNyZWF0aW5nIE5hbWVkIFF1ZXJpZXMiIC8+Ci0gICAgICA8dG9waWMgaHJlZj0idGFza19tYXBwaW5nLmh0bSIgbGFiZWw9Ik1hcHBpbmcgYW4gZW50aXR5Ij4KLSAgICAgICAgPHRvcGljIGhyZWY9InRhc2tzMDEwLmh0bSIgbGFiZWw9IkJhc2ljIG1hcHBpbmciIC8+Ci0gICAgICAgIDx0b3BpYyBocmVmPSJ0YXNrczAxMS5odG0iIGxhYmVsPSJFbWJlZGRlZCBtYXBwaW5nIiAvPgotICAgICAgICA8dG9waWMgaHJlZj0idGFza3MwMTIuaHRtIiBsYWJlbD0iRW1iZWRkZWQgSUQgbWFwcGluZyIgLz4KLSAgICAgICAgPHRvcGljIGhyZWY9InRhc2tzMDEzLmh0bSIgbGFiZWw9IklEIG1hcHBpbmciIC8+Ci0gICAgICAgIDx0b3BpYyBocmVmPSJ0YXNrczAxNC5odG0iIGxhYmVsPSJNYW55LXRvLW1hbnkgbWFwcGluZyIgLz4KLSAgICAgICAgPHRvcGljIGhyZWY9InRhc2tzMDE1Lmh0bSIgbGFiZWw9Ik1hbnktdG8tb25lIG1hcHBpbmciIC8+Ci0gICAgICAgIDx0b3BpYyBocmVmPSJ0YXNrczAxNi5odG0iIGxhYmVsPSJPbmUtdG8tbWFueSBtYXBwaW5nIiAvPgotICAgICAgICA8dG9waWMgaHJlZj0idGFza3MwMTcuaHRtIiBsYWJlbD0iT25lLXRvLW9uZSBtYXBwaW5nIiAvPgotICAgICAgICA8dG9waWMgaHJlZj0idGFza3MwMTguaHRtIiBsYWJlbD0iVHJhbnNpZW50IG1hcHBpbmciIC8+Ci0gICAgICAgIDx0b3BpYyBocmVmPSJ0YXNrczAxOS5odG0iIGxhYmVsPSJWZXJzaW9uIG1hcHBpbmciIC8+Ci0gICAgICA8L3RvcGljPgotICAgICAgPHRvcGljIGhyZWY9InRhc2tzMDIwLmh0bSIgbGFiZWw9IkdlbmVyYXRpbmcgZW50aXRpZXMgZnJvbSB0YWJsZXMiIC8+Ci0gICAgICA8dG9waWMgaHJlZj0idGFza3MwMjEuaHRtIiBsYWJlbD0iR2VuZXJhdGluZyBEREwgZnJvbSBFbnRpdGllcyIgLz4KLSAgICAgIDx0b3BpYyBocmVmPSJ0YXNrczAyMi5odG0iIGxhYmVsPSJWYWxpZGF0aW5nIG1hcHBpbmdzIGFuZCByZXBvcnRpbmcgcHJvYmxlbXMiPgotICAgICAgICA8dG9waWMgaHJlZj0idGFza3MwMjMuaHRtIiBsYWJlbD0iRXJyb3IgbWVzc2FnZXMiIC8+Ci0gICAgICAgIDx0b3BpYyBocmVmPSJ0YXNrczAyNC5odG0iIGxhYmVsPSJXYXJuaW5nIG1lc3NhZ2VzIiAvPgotICAgICAgPC90b3BpYz4KLSAgICAgIDx0b3BpYyBocmVmPSJ0YXNrczAyNS5odG0iIGxhYmVsPSJNb2RpZnlpbmcgcGVyc2lzdGVudCBwcm9qZWN0IHByb3BlcnRpZXMiIC8+Ci0gICAgPC90b3BpYz4KLSAgICA8dG9waWMgbGFiZWw9IiBSZWZlcmVuY2UiPgotICAgICAgPHRvcGljIGxhYmVsPSJXaXphcmRzIj4KLSAgICAgICAgPHRvcGljIGhyZWY9InJlZl9uZXdfanBhX3Byb2plY3Rfd2l6YXJkLmh0bSIgbGFiZWw9IkNyZWF0ZSBOZXcgSlBBIFByb2plY3Qgd2l6YXJkIj4KLSAgICAgICAgICA8dG9waWMgaHJlZj0icmVmX25ld19qcGFfcHJvamVjdC5odG0iIGxhYmVsPSJOZXcgSlBBIFByb2plY3QgcGFnZSIgLz4KLSAgICAgICAgICA8dG9waWMgaHJlZj0icmVmX2pwYV9mYWNldC5odG0iIGxhYmVsPSJKUEEgRmFjZXQgcGFnZSIgLz4KLSAgICAgICAgPC90b3BpYz4KLSAgICAgICAgPHRvcGljIGhyZWY9InJlZmVyZW5jZTAwMi5odG0iIGxhYmVsPSJDcmVhdGUgSlBBIEVudGl0eSB3aXphcmQiPgotICAgICAgICAgIDx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMDMuaHRtIiBsYWJlbD0iRW50aXR5IENsYXNzIHBhZ2UiIC8+Ci0gICAgICAgICAgPHRvcGljIGhyZWY9InJlZmVyZW5jZTAwNC5odG0iIGxhYmVsPSJFbnRpdHkgUHJvcGVydGllcyBwYWdlIiAvPgotICAgICAgICA8L3RvcGljPgotICAgICAgICA8dG9waWMgaHJlZj0icmVmZXJlbmNlMDA1Lmh0bSIgbGFiZWw9Ik1hcHBpbmcgRmlsZSBXaXphcmQiPgotICAgICAgICAgIDx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMDYuaHRtI3N0aHJlZjE3MSIgbGFiZWw9Ik1hcHBpbmcgRmlsZSIgLz4KLSAgICAgICAgPC90b3BpYz4KLSAgICAgICAgPHRvcGljIGhyZWY9InJlZmVyZW5jZTAwNy5odG0jc3RocmVmMTc0IiBsYWJlbD0iR2VuZXJhdGUgRERMIGZyb20gRW50aXRpZXMgV2l6YXJkIiAvPgotICAgICAgPC90b3BpYz4KLSAgICAgIDx0b3BpYyBsYWJlbD0iUHJvcGVydHkgcGFnZXMiPgotICAgICAgICA8dG9waWMgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3Byb3Bfdmlldy5odG0iIGxhYmVsPSJKUEEgRGV0YWlscyB2aWV3IChmb3IgZW50aXRpZXMpIj4KLSAgICAgICAgICA8dG9waWMgaHJlZj0icmVmZXJlbmNlMDA5Lmh0bSIgbGFiZWw9IkdlbmVyYWwgaW5mb3JtYXRpb24iIC8+Ci0gICAgICAgICAgPHRvcGljIGhyZWY9InJlZmVyZW5jZTAxMC5odG0iIGxhYmVsPSJBdHRyaWJ1dGUgb3ZlcnJpZGVzIiAvPgotICAgICAgICAgIDx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMTEuaHRtIiBsYWJlbD0iU2Vjb25kYXJ5IHRhYmxlIGluZm9ybWF0aW9uIiAvPgotICAgICAgICAgIDx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMTIuaHRtIiBsYWJlbD0iSW5oZXJpdGFuY2UgaW5mb3JtYXRpb24iIC8+Ci0gICAgICAgICAgPHRvcGljIGhyZWY9InJlZmVyZW5jZTAxMy5odG0jc3RocmVmMTg3IiBsYWJlbD0iUXVlcmllcyIgLz4KLSAgICAgICAgPC90b3BpYz4KLSAgICAgICAgPHRvcGljIGhyZWY9InJlZl9wZXJzaXN0ZW5jZV9tYXBfdmlldy5odG0iIGxhYmVsPSJKUEEgRGV0YWlscyB2aWV3IChmb3IgYXR0cmlidXRlcykiPgotICAgICAgICAgIDx0b3BpYyBocmVmPSJyZWZfbWFwcGluZ19nZW5lcmFsLmh0bSIgbGFiZWw9IkdlbmVyYWwgaW5mb3JtYXRpb24iIC8+Ci0gICAgICAgICAgPHRvcGljIGhyZWY9InJlZmVyZW5jZTAxNC5odG0iIGxhYmVsPSJKb2luIFRhYmxlIEluZm9ybWF0aW9uIiAvPgotICAgICAgICAgIDx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMTUuaHRtIiBsYWJlbD0iSm9pbiBDb2x1bW5zIEluZm9ybWF0aW9uIiAvPgotICAgICAgICAgIDx0b3BpYyBocmVmPSJyZWZfcHJpbWFyeV9rZXkuaHRtIiBsYWJlbD0iUHJpbWFyeSBLZXkgR2VuZXJhdGlvbiBpbmZvcm1hdGlvbiIgLz4KLSAgICAgICAgPC90b3BpYz4KLSAgICAgICAgPHRvcGljIGhyZWY9InJlZl9kZXRhaWxzX29ybS5odG0iIGxhYmVsPSJKUEEgRGV0YWlscyB2aWV3IChmb3Igb3JtLnhtbCkiPgotICAgICAgICAgIDx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMTYuaHRtIiBsYWJlbD0iR2VuZXJhbCBpbmZvcm1hdGlvbiIgLz4KLSAgICAgICAgICA8dG9waWMgaHJlZj0icmVmZXJlbmNlMDE3Lmh0bSIgbGFiZWw9IlBlcnNpc3RlbmNlIFVuaXQgaW5mb3JtYXRpb24iIC8+Ci0gICAgICAgIDwvdG9waWM+Ci0gICAgICAgIDx0b3BpYyBocmVmPSJyZWZfcGVyc2lzdGVuY2Vfb3V0bGluZS5odG0iIGxhYmVsPSJKUEEgU3RydWN0dXJlIHZpZXciIC8+Ci0gICAgICAgIDx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMTguaHRtIiBsYWJlbD0icGVyc2lzdGVuY2UueG1sIEVkaXRvciI+Ci0gICAgICAgICAgPHRvcGljIGhyZWY9InJlZmVyZW5jZTAxOS5odG0iIGxhYmVsPSJHZW5lcmFsIiAvPgotICAgICAgICAgIDx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMjAuaHRtIiBsYWJlbD0iQ29ubmVjdGlvbiIgLz4KLSAgICAgICAgICA8dG9waWMgaHJlZj0icmVmZXJlbmNlMDIxLmh0bSIgbGFiZWw9IkN1c3RvbWl6YXRpb24iIC8+Ci0gICAgICAgICAgPHRvcGljIGhyZWY9InJlZmVyZW5jZTAyMi5odG0iIGxhYmVsPSJDYWNoaW5nIiAvPgotICAgICAgICAgIDx0b3BpYyBocmVmPSJyZWZlcmVuY2UwMjMuaHRtIiBsYWJlbD0iTG9nZ2luZyIgLz4KLSAgICAgICAgICA8dG9waWMgaHJlZj0icmVmZXJlbmNlMDI0Lmh0bSIgbGFiZWw9Ik9wdGlvbnMiIC8+Ci0gICAgICAgICAgPHRvcGljIGhyZWY9InJlZmVyZW5jZTAyNS5odG0iIGxhYmVsPSJTY2hlbWEgR2VuZXJhdGlvbiIgLz4KLSAgICAgICAgICA8dG9waWMgaHJlZj0icmVmZXJlbmNlMDI2Lmh0bSIgbGFiZWw9IlByb3BlcnRpZXMiIC8+Ci0gICAgICAgICAgPHRvcGljIGhyZWY9InJlZmVyZW5jZTAyNy5odG0iIGxhYmVsPSJTb3VyY2UiIC8+Ci0gICAgICAgIDwvdG9waWM+Ci0gICAgICA8L3RvcGljPgotICAgICAgPHRvcGljIGxhYmVsPSJQcmVmZXJlbmNlcyI+Ci0gICAgICAgIDx0b3BpYyBocmVmPSJyZWZfcHJvamVjdF9wcm9wZXJ0aWVzLmh0bSIgbGFiZWw9IlByb2plY3QgUHJvcGVydGllcyBwYWdlIC0gSlBBIE9wdGlvbnMiIC8+Ci0gICAgICA8L3RvcGljPgotICAgICAgPHRvcGljIGxhYmVsPSJEaWFsb2dzIj4KLSAgICAgICAgPHRvcGljIGhyZWY9InRhc2tfZ2VuZXJhdGVfZW50aXRpZXMuaHRtIiBsYWJlbD0iR2VuZXJhdGUgRW50aXRpZXMgZnJvbSBUYWJsZXMgZGlhbG9nIiAvPgotICAgICAgICA8dG9waWMgaHJlZj0icmVmZXJlbmNlMDMwLmh0bSIgbGFiZWw9IkVkaXQgSm9pbiBDb2x1bW5zIERpYWxvZyIgLz4KLSAgICAgIDwvdG9waWM+Ci0gICAgICA8dG9waWMgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3BlcnNwZWN0aXZlLmh0bSIgbGFiZWw9IkpQQSBEZXZlbG9wbWVudCBwZXJzcGVjdGl2ZSIgLz4KLSAgICAgIDx0b3BpYyBsYWJlbD0iSWNvbnMgYW5kIGJ1dHRvbnMiPgotICAgICAgICA8dG9waWMgaHJlZj0icmVmZXJlbmNlMDMyLmh0bSIgbGFiZWw9Ikljb25zIiAvPgotICAgICAgICA8dG9waWMgaHJlZj0icmVmZXJlbmNlMDMzLmh0bSIgbGFiZWw9IkJ1dHRvbnMiIC8+Ci0gICAgICA8L3RvcGljPgotICAgICAgPHRvcGljIGhyZWY9InJlZmVyZW5jZTAzNC5odG0iIGxhYmVsPSJEYWxpIERldmVsb3BlciBEb2N1bWVudGF0aW9uIiAvPgotICAgIDwvdG9waWM+Ci0gICAgPHRvcGljIGhyZWY9InRpcHNfYW5kX3RyaWNrcy5odG0iIGxhYmVsPSJUaXBzIGFuZCB0cmlja3MiPgotICAgICAgPHRvcGljIGhyZWY9IndoYXRzX25ldzAwMS5odG0iIGxhYmVsPSJDcmVhdGUgSlBBIEVudGl0eSBXaXphcmQiIC8+Ci0gICAgICA8dG9waWMgaHJlZj0id2hhdHNfbmV3MDAyLmh0bSIgbGFiZWw9Ik5hbWVkIFF1ZXJ5IFN1cHBvcnQiIC8+Ci0gICAgICA8dG9waWMgaHJlZj0id2hhdHNfbmV3MDAzLmh0bSIgbGFiZWw9InBlcnNpc3RlbmNlLnhtbCBFZGl0b3IiIC8+Ci0gICAgICA8dG9waWMgaHJlZj0id2hhdHNfbmV3MDA0Lmh0bSIgbGFiZWw9Ik92ZXJyaWRlIHRoZSBEZWZhdWx0IFNjaGVtYSBmb3IgQ29ubmVjdGlvbiIgLz4KLSAgICAgIDx0b3BpYyBocmVmPSJ3aGF0c19uZXcwMDUuaHRtIiBsYWJlbD0iTmV3IE1hcHBpbmcgRmlsZSBXaXphcmQiIC8+Ci0gICAgICA8dG9waWMgaHJlZj0id2hhdHNfbmV3MDA2Lmh0bSIgbGFiZWw9IkNvbnZlcnQgdG8gSmF2YSBQcm9qZWN0IiAvPgotICAgICAgPHRvcGljIGhyZWY9IndoYXRzX25ldzAwNy5odG0iIGxhYmVsPSJDb2x1bW4gRGVmaW5pdGlvbiBTdXBwb3J0IiAvPgotICAgIDwvdG9waWM+Ci0gICAgPHRvcGljIGhyZWY9ImxlZ2FsLmh0bSIgbGFiZWw9IiBMZWdhbCI+Ci0gICAgICA8dG9waWMgaHJlZj0iYWJvdXQuaHRtIiBsYWJlbD0iQWJvdXQgdGhpcyBjb250ZW50IiAvPgotICAgIDwvdG9waWM+Ci08L3RvYz4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci93aGF0c19uZXcuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3doYXRzX25ldy5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGIwN2YwN2UuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3doYXRzX25ldy5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw1OSArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo1MyAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPldoYXQncyBuZXc8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSIgV2hhdCdzIG5ldyIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9InN0aHJlZjI0OSIgbmFtZT0ic3RocmVmMjQ5Ij48L2E+IFdoYXQncyBuZXc8L3A+Ci08cD5UaGlzIHNlY3Rpb24gY29udGFpbnMgZGVzY3JpcHRpb25zIG9mIHRoZSBmb2xsb3dpbmcgbmV3IGZlYXR1cmVzIGFuZCBzaWduaWZpY2FudCBjaGFuZ2VzIG1hZGUgdG8gdGhlIERhbGkgT1IgTWFwcGluZyBUb29sIGZvciBSZWxlYXNlIDIuMDo8L3A+Ci08dWw+Ci08bGk+Ci08cD48YSBocmVmPSJ3aGF0c19uZXcwMDEuaHRtI0JHR0NKSEFHIj5DcmVhdGUgSlBBIEVudGl0eSBXaXphcmQ8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9IndoYXRzX25ldzAwMi5odG0jQkdHSUhKQ0oiPk5hbWVkIFF1ZXJ5IFN1cHBvcnQ8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9IndoYXRzX25ldzAwMy5odG0jQkdHR0FDQ0QiPnBlcnNpc3RlbmNlLnhtbCBFZGl0b3I8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9IndoYXRzX25ldzAwNC5odG0jQkdHSUlDRUYiPk92ZXJyaWRlIHRoZSBEZWZhdWx0IFNjaGVtYSBmb3IgQ29ubmVjdGlvbjwvYT48L3A+Ci08L2xpPgotPGxpPgotPHA+PGEgaHJlZj0id2hhdHNfbmV3MDA1Lmh0bSNCR0dHREdJRSI+TmV3IE1hcHBpbmcgRmlsZSBXaXphcmQ8L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9IndoYXRzX25ldzAwNi5odG0jQkdHQ0dESkciPlRoZSBDb252ZXJ0IHRvIEphdmEgUHJvamVjdCBPcHRpb248L2E+PC9wPgotPC9saT4KLTxsaT4KLTxwPjxhIGhyZWY9IndoYXRzX25ldzAwNy5odG0jQkdHRkdCSEoiPkRlZmluaW5nIENvbHVtbnMgaW4gSlBBIERldGFpbHMgVmlldyBmb3IgRW50aXR5IEF0dHJpYnV0ZXM8L2E+PC9wPgotPC9saT4KLTxsaSBzdHlsZT0ibGlzdC1zdHlsZTogbm9uZSI+PGEgaHJlZj0id2hhdHNfbmV3MDA4Lmh0bSNDRUdJRENDRSI+R2VuZXJhdGUgRERMIGZyb20gRW50aXRpZXMgd2l6YXJkPC9hPjwvbGk+Ci08L3VsPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3doYXRzX25ldzAwMS5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvd2hhdHNfbmV3MDAxLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYTU0NzIwNi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvd2hhdHNfbmV3MDAxLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDU4ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjUzIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+Q3JlYXRlIEpQQSBFbnRpdHkgV2l6YXJkPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0iQ3JlYXRlIEpQQSBFbnRpdHkgV2l6YXJkIiAvPgotPG1ldGEgbmFtZT0icmVsbnVtIiBjb250ZW50PSJSZWxlYXNlIDIuMCIgLz4KLTxtZXRhIG5hbWU9ImNvcHlyaWdodCIgY29udGVudD0iQ29weXJpZ2h0IChjKSAyMDAwLCAyMDA4IG9yYWNsZSAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLiBDb250cmlidXRvcnM6IE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiIgLz4KLTxsaW5rIHJlbD0iY29weXJpZ2h0IiBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iIHRpdGxlPSJDb3B5cmlnaHQiIHR5cGU9InRleHQvaHRtbCIgLz4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iZGNvbW1vbi9jc3MvYmxhZmRvYy5jc3MiIHRpdGxlPSJPcmFjbGUgQkxBRkRvYyIgdHlwZT0idGV4dC9jc3MiIC8+Ci08IS0tIHN0YXJ0LS0+Ci08IS0tIGNvbnRlbnRzIC0tPgotPC9oZWFkPgotPGJvZHk+Ci08cD48YSBpZD0iQkdHQ0pIQUciIG5hbWU9IkJHR0NKSEFHIj48L2E+PC9wPgotPGRpdiBjbGFzcz0ic2VjdDEiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT4KLTxoMT5DcmVhdGUgSlBBIEVudGl0eSBXaXphcmQ8L2gxPgotPHA+VXNlIHRoZSBDcmVhdGUgSlBBIEVudGl0eSB3aXphcmQgdG8gcXVpY2tseSBjcmVhdGUgYW4gZW50aXR5LiBUaGlzIHdpemFyZCBhdXRvbWF0aWNhbGx5IGNyZWF0ZXMgYSBKYXZhIGNsYXNzIGFubm90YXRlZCB3aXRoIDxjb2RlPkBFbnRpdHk8L2NvZGU+IGFuZCBlbmFibGVzIHVzZXJzIHRvIGFkZCBwZXJzaXN0ZW5jZSBmaWVsZHMgdG8gdGhlIGVudGl0eS48L3A+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWYyNTAiIG5hbWU9InN0aHJlZjI1MCI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPlRoZSBDcmVhdGUgTmV3IEpQQSBFbnRpdHkgV2l6YXJkPC9wPgotPGltZyBzcmM9ImltZy9jcmVhdGVfanBhX2VudGl0eV9uZXcucG5nIiBhbHQ9IlRoZSBFbnRpdHkgQ2xhc3MgcGFnZSBvZiB0aGUgQ3JlYXRlIE5ldyBKUEEgRW50aXR5IHdpemFyZC4iIHRpdGxlPSJUaGUgRW50aXR5IENsYXNzIHBhZ2Ugb2YgdGhlIENyZWF0ZSBOZXcgSlBBIEVudGl0eSB3aXphcmQuIiAvPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iZmlndXJlIiAtLT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxyLnBuZyIgYWx0PSJSZWxhdGVkIHJlZmVyZW5jZSIgdGl0bGU9IlJlbGF0ZWQgcmVmZXJlbmNlIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJyZWZfbmV3X2pwYV9wcm9qZWN0X3dpemFyZC5odG0jQ0FDQkpHQkciPkNyZWF0ZSBOZXcgSlBBIFByb2plY3Qgd2l6YXJkPC9hPjxiciAvPgotPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3BlcnNwZWN0aXZlLmh0bSNCQUJJRkJEQiI+SlBBIERldmVsb3BtZW50IHBlcnNwZWN0aXZlPC9hPjxiciAvPgotPGEgaHJlZj0icmVmZXJlbmNlMDA1Lmh0bSNDSUFJSkNDRSI+TWFwcGluZyBGaWxlIFdpemFyZDwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWx0LnBuZyIgYWx0PSJSZWxhdGVkIHRhc2tzIiB0aXRsZT0iUmVsYXRlZCB0YXNrcyIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza19tYW5hZ2VfcGVyc2lzdGVuY2UuaHRtI0NJSERBSklEIj5NYW5hZ2luZyB0aGUgcGVyc2lzdGVuY2UueG1sIGZpbGU8L2E+PGJyIC8+Ci08YSBocmVmPSJ0YXNrX2FkZF9wZXJzaXN0ZW5jZS5odG0jQkFCSElDQUkiPkFkZGluZyBwZXJzaXN0ZW5jZSB0byBhIGNsYXNzPC9hPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0iY29uY2VwdF9wZXJzaXN0ZW5jZS5odG0jQkFCQ0FISUMiPlVuZGVyc3RhbmRpbmcgSmF2YSBwZXJzaXN0ZW5jZTwvYT48YnIgLz4KLTxhIGhyZWY9ImNvbmNlcHRzMDAyLmh0bSNDSERIQUdJSCI+VGhlIHBlcnNpc3RlbmNlLnhtbCBmaWxlPC9hPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDEiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3doYXRzX25ldzAwMi5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvd2hhdHNfbmV3MDAyLmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZmMxOTEyYy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvd2hhdHNfbmV3MDAyLmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDU1ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjUzIC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+TmFtZWQgUXVlcnkgU3VwcG9ydDwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9Ik5hbWVkIFF1ZXJ5IFN1cHBvcnQiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJCR0dJSEpDSiIgbmFtZT0iQkdHSUhKQ0oiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MSI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPk5hbWVkIFF1ZXJ5IFN1cHBvcnQ8L2gxPgotPHA+VGhlIEpQQSBEZXRhaWxzIHZpZXcgZm9yIGFuIGVudGl0eSBpbmNsdWRlcyBmdW5jdGlvbnMgZm9yIGFkZGluZyBuYW1lZCBhbmQgbmFtZWQgbmF0aXZlIHF1ZXJpZXMgdG8gYW4gZW50aXR5LjwvcD4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9InN0aHJlZjI1MSIgbmFtZT0ic3RocmVmMjUxIj48L2E+Ci08cCBjbGFzcz0idGl0bGVpbmZpZ3VyZSI+RW50ZXJpbmcgYSBOYW1lZCBRdWVyeTwvcD4KLTxpbWcgc3JjPSJpbWcvZW50ZXJpbmdfcXVlcnlfbmV3LnBuZyIgYWx0PSJUaGUgUXVlcmllcyBzZWN0aW9uIG9mIHRoZSBKUEEgRGV0YWlscyB2aWV3LiIgdGl0bGU9IlRoZSBRdWVyaWVzIHNlY3Rpb24gb2YgdGhlIEpQQSBEZXRhaWxzIHZpZXcuIiAvPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iZmlndXJlIiAtLT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWx0LnBuZyIgYWx0PSJSZWxhdGVkIHRhc2siIHRpdGxlPSJSZWxhdGVkIHRhc2siIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InRhc2tzMDA5Lmh0bSNCQUJJR0JHRyI+Q3JlYXRpbmcgTmFtZWQgUXVlcmllczwvYT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxyLnBuZyIgYWx0PSJSZWxhdGVkIHJlZmVyZW5jZSIgdGl0bGU9IlJlbGF0ZWQgcmVmZXJlbmNlIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJyZWZfcGVyc2lzdGVuY2VfbWFwX3ZpZXcuaHRtI0JBQklGQkFGIj5KUEEgRGV0YWlscyB2aWV3IChmb3IgYXR0cmlidXRlcyk8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsYy5wbmciIGFsdD0iUmVsYXRlZCBjb25jZXB0IiB0aXRsZT0iUmVsYXRlZCBjb25jZXB0IiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJjb25jZXB0X21hcHBpbmcuaHRtI0JBQkJESkZJIj5VbmRlcnN0YW5kaW5nIE9SIG1hcHBpbmdzPC9hPjxiciAvPgotPGEgaHJlZj0iY29uY2VwdHMwMDEuaHRtI0JBQkJHRkpHIj5VbmRlcnN0YW5kaW5nIEVKQiAzLjAgSmF2YSBQZXJzaXN0ZW5jZSBBUEk8L2E+PC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MSIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvd2hhdHNfbmV3MDAzLmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci93aGF0c19uZXcwMDMuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiY2QxMzRjLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci93aGF0c19uZXcwMDMuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNTMgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTQgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5wZXJzaXN0ZW5jZS54bWwgRWRpdG9yPC90aXRsZT4KLSAKLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiIC8+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiIC8+Ci08bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9Ik9yYWNsZSBEQVJCIFhIVE1MIENvbnZlcnRlciAoTW9kZSA9IG9oai9vaHcpIC0gVmVyc2lvbiA1LjAiIC8+Ci08bWV0YSBuYW1lPSJkYXRlIiBjb250ZW50PSIyMDA1LTA3LTEwVDEyOjU3OjIwKzA4OjAwIiAvPgotPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJub2FyY2hpdmUiIC8+Ci08bWV0YSBuYW1lPSJkb2N0aXRsZSIgY29udGVudD0icGVyc2lzdGVuY2UueG1sIEVkaXRvciIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkJHR0dBQ0NEIiBuYW1lPSJCR0dHQUNDRCI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QxIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+cGVyc2lzdGVuY2UueG1sIEVkaXRvcjwvaDE+Ci08cD5SYXRoZXIgdGhhbiBlZGl0IHRoZSBYTUwgZm9yIDxjb2RlPnBlcnNpc3RlbmNlLnhtbDwvY29kZT4sIHRoaXMgcmVsZWFzZSBvZiBEYWxpIHByb3ZpZGVzIGFuIGVkaXRvciB0aGF0IGF1dG9tYXRpY2FsbHkgcG9wdWxhdGVzIHRoZSBmaWxlJ3MgPGNvZGU+Jmx0O3BlcnNpc3RlbmNlLXVuaXQmZ3Q7PC9jb2RlPiBlbGVtZW50LCBpdHMgPGNvZGU+dHJhbnNhY3Rpb24gdHlwZTwvY29kZT4gYXR0cmlidXRlIGFzIHdlbGwgYXMgaXRzIDxjb2RlPiZsdDtwcm92aWRlciZndDs8L2NvZGU+LCA8Y29kZT4mbHQ7Y2xhc3MmZ3Q7PC9jb2RlPiwgZGF0YSBzb3VyY2UgYW5kIDxjb2RlPiZsdDtwcm9wZXJ0aWVzJmd0OzwvY29kZT4gc3ViLWVsZW1lbnRzLiBUaGUgZWR0aW9yIGFsc28gZW5hYmxlcyB5b3UgdG8gZWRpdCB0aGUgZmlsZSBkaXJlY3RseS48L3A+Ci08ZGl2IGNsYXNzPSJmaWd1cmUiPjxhIGlkPSJzdGhyZWYyNTIiIG5hbWU9InN0aHJlZjI1MiI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPlRoZSBwZXJzaXN0ZW5jZS54bWwgRWRpdG9yPC9wPgotPGltZyBzcmM9ImltZy9wZXJzaXN0ZW5jZV9lZGl0b3JfbmV3LnBuZyIgYWx0PSJUaGUgR2VuZXJhbCBwYWdlIG9mIHRoZSBwZXJzaXN0ZW5jZS54bWwgRWRpdG9yLiIgdGl0bGU9IlRoZSBHZW5lcmFsIHBhZ2Ugb2YgdGhlIHBlcnNpc3RlbmNlLnhtbCBFZGl0b3IuIiAvPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iZmlndXJlIiAtLT4KLTxpbWcgc3JjPSJpbWcvbmdyZWxyLnBuZyIgYWx0PSJSZWxhdGVkIHJlZmVyZW5jZSIgdGl0bGU9IlJlbGF0ZWQgcmVmZXJlbmNlIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJyZWZlcmVuY2UwMTguaHRtI0NJQUNDSElEIj5wZXJzaXN0ZW5jZS54bWwgRWRpdG9yPC9hPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza19tYW5hZ2VfcGVyc2lzdGVuY2UuaHRtI0NJSERBSklEIj5NYW5hZ2luZyB0aGUgcGVyc2lzdGVuY2UueG1sIGZpbGU8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsYy5wbmciIGFsdD0iUmVsYXRlZCBjb25jZXB0IiB0aXRsZT0iUmVsYXRlZCBjb25jZXB0IiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJjb25jZXB0czAwMi5odG0jQ0hESEFHSUgiPlRoZSBwZXJzaXN0ZW5jZS54bWwgZmlsZTwvYT48YnIgLz48L2Rpdj4KLTwhLS0gY2xhc3M9InNlY3QxIiAtLT4KLTwhLS0gU3RhcnQgRm9vdGVyIC0tPgotPGRpdiBjbGFzcz0iZm9vdGVyIj4KLTx0YWJsZSBjbGFzcz0ic2ltcGxlIG9hY19ub193YXJuIiBzdW1tYXJ5PSIiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgd2lkdGg9IjEwMCUiPgotPHRyPgotPHRkIGFsaWduPSJsZWZ0IiB3aWR0aD0iODYlIj48YSBocmVmPSJkY29tbW9uL2h0bWwvY3B5ci5odG0iPjxzcGFuIGNsYXNzPSJjb3B5cmlnaHRsb2dvIj5Db3B5cmlnaHQmbmJzcDsmY29weTsmbmJzcDsyMDA2LCAyMDA4LCZuYnNwO09yYWNsZS4mbmJzcDtBbGwmbmJzcDtyaWdodHMmbmJzcDtyZXNlcnZlZC48L3NwYW4+PC9hPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLTwvZGl2PgotPCEtLSBjbGFzcz0iZm9vdGVyIiAtLT4KLTwvYm9keT4KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci93aGF0c19uZXcwMDQuaHRtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3doYXRzX25ldzAwNC5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDdkOGFjZjMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3doYXRzX25ldzAwNC5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw0NyArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIgotICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KLTxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIj4KLTxoZWFkPgotPCEtLSBSdW4gZGF0ZSA9IEp1bHkgMjMsIDIwMDggODo1OTo1NCAtLT4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXVzLWFzY2lpIiAvPgotPHRpdGxlPk92ZXJyaWRlIHRoZSBEZWZhdWx0IFNjaGVtYSBmb3IgQ29ubmVjdGlvbjwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9Ik92ZXJyaWRlIHRoZSBEZWZhdWx0IFNjaGVtYSBmb3IgQ29ubmVjdGlvbiIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPHA+PGEgaWQ9IkJHR0lJQ0VGIiBuYW1lPSJCR0dJSUNFRiI+PC9hPjwvcD4KLTxkaXYgY2xhc3M9InNlY3QxIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+Ci08aDE+T3ZlcnJpZGUgdGhlIERlZmF1bHQgU2NoZW1hIGZvciBDb25uZWN0aW9uPC9oMT4KLTxwPkluIHNvbWUgY2FzZXMsIERhbGkgY2Fubm90IGNhbGN1bGF0ZSB0aGUgY29ycmVjdCBzY2hlbWEgZm9yIGEgcHJvamVjdC4gSWYgc3VjaCBhbiBpbnN0YW5jZSBhcmlzZXMsIHlvdSBjYW4gb3ZlcnJpZGUgdGhlIGRlZmF1bHQgc2NoZW1hIGRlcml2ZWQgZnJvbSB0aGUgY29ubmVjdGlvbiBpbmZvcm1hdGlvbiB1c2luZyB0aGUgPHNwYW4gY2xhc3M9ImJvbGQiPk92ZXJyaWRlIHRoZSBEZWZhdWx0IFNjaGVtYSBmb3IgQ29ubmVjdGlvbjwvc3Bhbj4gb3B0aW9uIGluIHRoZSBKUEEgRmFjZXQgcGFnZSBvZiB0aGUgQ3JlYXRlIE5ldyBKUEEgRW50aXR5IHdpemFyZCAoaWxsdXN0cmF0ZWQgaW4gPGEgaHJlZj0iI0JHR0pGRkNEIj5GaWd1cmU6IENoYW5naW5nIHRoZSBTY2hlbWEgZm9yIGEgUHJvamVjdDwvYT4pIG9yIHRocm91Z2ggdGhlIHByb3BlcnRpZXMgZm9yIHRoZSBKUEEgcHJvamVjdCAoYWNjZXNzZWQgYnkgc2VsZWN0aW5nIHRoZSBKUEEgcHJvamVjdCBhbmQgdGhlbiA8c3BhbiBjbGFzcz0iYm9sZCI+UHJvcGVydGllcyAmZ3Q7IEpQQTwvc3Bhbj4pLiBVc2UgdGhpcyBvcHRpb24gd2hlbiB0aGUgZGVmYXVsdCBsb2dpbiBpbmZvcm1hdGlvbiBjYW5ub3QgYmUgdXNlZCwgc3VjaCBhcyB3aGVuIHRoZSBkZXBsb3ltZW50IGxvZ2luIGRpZmZlcnMgZnJvbSB0aGUgZGVzaWduLXRpbWUgbG9naW4uPC9wPgotPGRpdiBjbGFzcz0iZmlndXJlIj48YSBpZD0iQkdHSkZGQ0QiIG5hbWU9IkJHR0pGRkNEIj48L2E+Ci08cCBjbGFzcz0idGl0bGVpbmZpZ3VyZSI+Q2hhbmdpbmcgdGhlIFNjaGVtYSBmb3IgYSBQcm9qZWN0PC9wPgotPGltZyBzcmM9ImltZy9jaGFuZ2VfY29ubmVjdGlvbl9wcm9maWxlLnBuZyIgYWx0PSJUaGUgSlBBIEZhY2V0IHBhZ2Ugb2YgdGhlIENyZWF0ZSBOZXcgSlBBIFByb2plY3Qgd2l6YXJkIHdpdGggdGhlIE92ZXJyaWRlIGRlZnVhbHQgc2NoZW1hIHNlbGVjdGVkLiIgdGl0bGU9IlRoZSBKUEEgRmFjZXQgcGFnZSBvZiB0aGUgQ3JlYXRlIE5ldyBKUEEgUHJvamVjdCB3aXphcmQgd2l0aCB0aGUgT3ZlcnJpZGUgZGVmdWFsdCBzY2hlbWEgc2VsZWN0ZWQuIiAvPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iZmlndXJlIiAtLT4KLTxpbWcgc3JjPSJpbWcvbmdyZWxyLnBuZyIgYWx0PSJSZWxhdGVkIHJlZmVyZW5jZSIgdGl0bGU9IlJlbGF0ZWQgcmVmZXJlbmNlIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJyZWZfbmV3X2pwYV9wcm9qZWN0X3dpemFyZC5odG0jQ0FDQkpHQkciPkNyZWF0ZSBOZXcgSlBBIFByb2plY3Qgd2l6YXJkPC9hPgotPHA+Jm5ic3A7PC9wPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MSIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvd2hhdHNfbmV3MDA1Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci93aGF0c19uZXcwMDUuaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjY2QwOGVlLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci93aGF0c19uZXcwMDUuaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNTMgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTQgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5DaGFuZ2luZyB0aGUgU2NoZW1hIGZvciBhIFByb2plY3Q8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJDaGFuZ2luZyB0aGUgU2NoZW1hIGZvciBhIFByb2plY3QiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxkaXYgY2xhc3M9InNlY3QxIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+PGEgaWQ9InN0aHJlZjI1MyIgbmFtZT0ic3RocmVmMjUzIj48L2E+Ci08aDE+TmV3IE1hcHBpbmcgRmlsZSBXaXphcmQ8L2gxPgotPHA+VGhlIE1hcHBpbmcgRmlsZSB3aXphcmQgZW5hYmxlcyB5b3UgdG8gYWRkIGFuIG9iamVjdCBtYXAgKG9ybS54bWwpIHRvIGEgSlBBIHByb2plY3QgaWYgbm8gb2JqZWN0IG1hcCBleGlzdHMgYXQgdGhlIGxvY2F0aW9uIHNwZWNpZmllZC4gQ29tcGxldGluZyB0aGUgd2l6YXJkIHJlc3VsdHMgaW4gYSBzdHViIDxjb2RlPm9ybS54bWw8L2NvZGU+IGZpbGUuPC9wPgotPGRpdiBjbGFzcz0iZmlndXJlIj48YSBpZD0iQkdHR0RHSUUiIG5hbWU9IkJHR0dER0lFIj48L2E+Ci08cCBjbGFzcz0idGl0bGVpbmZpZ3VyZSI+TmV3IE1hcHBpbmcgRmlsZSBXaXphcmQ8L3A+Ci08aW1nIHNyYz0iaW1nL21hcHBpbmdfZmlsZV9uZXcucG5nIiBhbHQ9IlRoZSBNYXBwaW5nIEZpbGUgcGFnZSBvZiB0aGUgTmV3IE1hcHBpbmcgRmlsZSB3aXphcmQuIiB0aXRsZT0iVGhlIE1hcHBpbmcgRmlsZSBwYWdlIG9mIHRoZSBOZXcgTWFwcGluZyBGaWxlIHdpemFyZC4iIC8+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJmaWd1cmUiIC0tPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbHIucG5nIiBhbHQ9IlJlbGF0ZWQgcmVmZXJlbmNlIiB0aXRsZT0iUmVsYXRlZCByZWZlcmVuY2UiIC8+PGJyIC8+Ci08YnIgLz4KLTxhIGhyZWY9InJlZmVyZW5jZTAwNS5odG0jQ0lBSUpDQ0UiPk1hcHBpbmcgRmlsZSBXaXphcmQ8L2E+Ci08cD4mbmJzcDs8L3A+Ci08aW1nIHNyYz0iaW1nL25ncmVsdC5wbmciIGFsdD0iUmVsYXRlZCB0YXNrIiB0aXRsZT0iUmVsYXRlZCB0YXNrIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJ0YXNrX21hbmFnZV9vcm0uaHRtI0NJSERHRENEIj5NYW5hZ2luZyB0aGUgb3JtLnhtbCBmaWxlPC9hPjxiciAvPgotPHA+Jm5ic3A7PC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0iY29uY2VwdHMwMDMuaHRtI0NIREJJSkFDIj5UaGUgb3JtLnhtbCBmaWxlPC9hPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDEiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3doYXRzX25ldzAwNi5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvd2hhdHNfbmV3MDA2Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTA2ZGZkZi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvd2hhdHNfbmV3MDA2Lmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDQxICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjU0IC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+TmV3IE1hcHBpbmcgRmlsZSBXaXphcmQ8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJOZXcgTWFwcGluZyBGaWxlIFdpemFyZCIgLz4KLTxtZXRhIG5hbWU9InJlbG51bSIgY29udGVudD0iUmVsZWFzZSAyLjAiIC8+Ci08bWV0YSBuYW1lPSJjb3B5cmlnaHQiIGNvbnRlbnQ9IkNvcHlyaWdodCAoYykgMjAwMCwgMjAwOCBvcmFjbGUgLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4gQ29udHJpYnV0b3JzOiBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24iIC8+Ci08bGluayByZWw9ImNvcHlyaWdodCIgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIiB0aXRsZT0iQ29weXJpZ2h0IiB0eXBlPSJ0ZXh0L2h0bWwiIC8+Ci08bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImRjb21tb24vY3NzL2JsYWZkb2MuY3NzIiB0aXRsZT0iT3JhY2xlIEJMQUZEb2MiIHR5cGU9InRleHQvY3NzIiAvPgotPCEtLSBzdGFydC0tPgotPCEtLSBjb250ZW50cyAtLT4KLTwvaGVhZD4KLTxib2R5PgotPGRpdiBjbGFzcz0ic2VjdDEiPjwhLS0gaW5mb2xldmVsPSJhbGwiIGluZm90eXBlPSJHZW5lcmFsIiAtLT48YSBpZD0ic3RocmVmMjU0IiBuYW1lPSJzdGhyZWYyNTQiPjwvYT4KLTxoMT5Db252ZXJ0IHRvIEphdmEgUHJvamVjdDwvaDE+Ci08cD5UaGUgQ29udmVydCB0byBKUEEgUHJvamVjdCBvcHRpb24gKGFjY2Vzc2VkIGJ5IHNlbGVjdGluZyBhIEphdmEgcHJvamVjdCBhbmQgdGhlbiBjbGlja2luZyA8c3BhbiBjbGFzcz0iYm9sZCI+TmV3ICZndDsgSlBBIFRvb2xzICZndDsgQ29udmVydCB0byBKUEEgUHJvamVjdDwvc3Bhbj4pIGVuYWJsZXMgeW91IHRvIGNvbnZlcnQgYSBub24tZmFjZXRlZCBKYXZhIHByb2plY3QgaW50byBhIGZhY2V0ZWQgSmF2YSBwcm9qZWN0LiBTZWxlY3RpbmcgdGhpcyBvcHRpb24gaW52b2tlcyB0aGUgTW9kaWZ5IEZhY2V0ZWQgUHJvamVjdCB3aXphcmQsIHdoaWNoIHByb21wdHMgeW91IHRvIGFkZCB0aGUgSlBBIGZhY2V0LjwvcD4KLTxkaXYgY2xhc3M9ImZpZ3VyZSI+PGEgaWQ9IkJHR0NHREpHIiBuYW1lPSJCR0dDR0RKRyI+PC9hPgotPHAgY2xhc3M9InRpdGxlaW5maWd1cmUiPlRoZSBDb252ZXJ0IHRvIEphdmEgUHJvamVjdCBPcHRpb248L3A+Ci08aW1nIHNyYz0iaW1nL2NvbnZlcnRfamF2YV9wcm9qZWN0X25ldy5wbmciIGFsdD0iQSBKYXZhIHByb2plY3QgaW4gdGhlIE5hdmlnYXRvciB3aXRoIHRoZSBKUEEgVG9vbHMgJmd0OyBDb252ZXJ0IHRvIEphdmEgb3B0aW9uIHNlbGVjdGVkLiIgdGl0bGU9IkEgSmF2YSBwcm9qZWN0IGluIHRoZSBOYXZpZ2F0b3Igd2l0aCB0aGUgSlBBIFRvb2xzICZndDsgQ29udmVydCB0byBKYXZhIG9wdGlvbiBzZWxlY3RlZC4iIC8+PGJyIC8+PC9kaXY+Ci08IS0tIGNsYXNzPSJmaWd1cmUiIC0tPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDEiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmRvYy51c2VyL3doYXRzX25ldzAwNy5odG0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvd2hhdHNfbmV3MDA3Lmh0bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggM2ZmZDQyMi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvd2hhdHNfbmV3MDA3Lmh0bQorKysgL2Rldi9udWxsCkBAIC0xLDQ4ICswLDAgQEAKLTwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iCi0gICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgotPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iPgotPGhlYWQ+Ci08IS0tIFJ1biBkYXRlID0gSnVseSAyMywgMjAwOCA4OjU5OjU0IC0tPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXMtYXNjaWkiIC8+Ci08dGl0bGU+VGhlIENvbnZlcnQgdG8gSmF2YSBQcm9qZWN0IE9wdGlvbjwvdGl0bGU+Ci0gCi08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIiAvPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0IiAvPgotPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJPcmFjbGUgREFSQiBYSFRNTCBDb252ZXJ0ZXIgKE1vZGUgPSBvaGovb2h3KSAtIFZlcnNpb24gNS4wIiAvPgotPG1ldGEgbmFtZT0iZGF0ZSIgY29udGVudD0iMjAwNS0wNy0xMFQxMjo1NzoyMCswODowMCIgLz4KLTxtZXRhIG5hbWU9InJvYm90cyIgY29udGVudD0ibm9hcmNoaXZlIiAvPgotPG1ldGEgbmFtZT0iZG9jdGl0bGUiIGNvbnRlbnQ9IlRoZSBDb252ZXJ0IHRvIEphdmEgUHJvamVjdCBPcHRpb24iIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxkaXYgY2xhc3M9InNlY3QxIj48IS0tIGluZm9sZXZlbD0iYWxsIiBpbmZvdHlwZT0iR2VuZXJhbCIgLS0+PGEgaWQ9InN0aHJlZjI1NSIgbmFtZT0ic3RocmVmMjU1Ij48L2E+Ci08aDE+Q29sdW1uIERlZmluaXRpb24gU3VwcG9ydDwvaDE+Ci08cD5UaGUgSlBBIERldGFpbHMgdmlldyBmb3IgYXR0cmlidXRlcyBlbmFibGVzIHlvdSB0byBtb2RpZnkgdGhlIG51bGxhYmxlIGFuZCB1bmlxdWUgY29sdW1uIGNvbnN0cmFpbnRzIGFuZCBzdWNoIGNvbHVtbiBwcm9wZXJ0aWVzIGFzIGxlbmd0aCwgc2NhbGUsIGFuZCBwcmVjaXNpb24uPC9wPgotPGRpdiBjbGFzcz0iZmlndXJlIj48YSBpZD0iQkdHRkdCSEoiIG5hbWU9IkJHR0ZHQkhKIj48L2E+Ci08cCBjbGFzcz0idGl0bGVpbmZpZ3VyZSI+RGVmaW5pbmcgQ29sdW1ucyBpbiBKUEEgRGV0YWlscyBWaWV3IGZvciBFbnRpdHkgQXR0cmlidXRlczwvcD4KLTxpbWcgc3JjPSJpbWcvY29sdW1uX3N1cHBvcnRfbmV3LnBuZyIgYWx0PSJUaGUgSlBBIERldGFpbHMgVmlldyBmb3IgYW4gZW50aXR5IHdpdGggaXRzIERldGFpbHMgc2VjdGlvbiBleHBhbmRlZCB0byBzaG93IHRoZSBjb2x1bW4gY29uZmlndXJhdGlvbiBwYXJhbWV0ZXJzLiIgdGl0bGU9IlRoZSBKUEEgRGV0YWlscyBWaWV3IGZvciBhbiBlbnRpdHkgd2l0aCBpdHMgRGV0YWlscyBzZWN0aW9uIGV4cGFuZGVkIHRvIHNob3cgdGhlIGNvbHVtbiBjb25maWd1cmF0aW9uIHBhcmFtZXRlcnMuIiAvPjxiciAvPjwvZGl2PgotPCEtLSBjbGFzcz0iZmlndXJlIiAtLT4KLTxwPiZuYnNwOzwvcD4KLTxpbWcgc3JjPSJpbWcvbmdyZWxyLnBuZyIgYWx0PSJSZWxhdGVkIHJlZmVyZW5jZSIgdGl0bGU9IlJlbGF0ZWQgcmVmZXJlbmNlIiAvPjxiciAvPgotPGJyIC8+Ci08YSBocmVmPSJyZWZfbmV3X2pwYV9wcm9qZWN0X3dpemFyZC5odG0jQ0FDQkpHQkciPkNyZWF0ZSBOZXcgSlBBIFByb2plY3Qgd2l6YXJkPC9hPjxiciAvPgotPGEgaHJlZj0icmVmX3BlcnNpc3RlbmNlX3BlcnNwZWN0aXZlLmh0bSNCQUJJRkJEQiI+SlBBIERldmVsb3BtZW50IHBlcnNwZWN0aXZlPC9hPgotPHA+Jm5ic3A7PC9wPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJzZWN0MSIgLS0+Ci08IS0tIFN0YXJ0IEZvb3RlciAtLT4KLTxkaXYgY2xhc3M9ImZvb3RlciI+Ci08dGFibGUgY2xhc3M9InNpbXBsZSBvYWNfbm9fd2FybiIgc3VtbWFyeT0iIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIHdpZHRoPSIxMDAlIj4KLTx0cj4KLTx0ZCBhbGlnbj0ibGVmdCIgd2lkdGg9Ijg2JSI+PGEgaHJlZj0iZGNvbW1vbi9odG1sL2NweXIuaHRtIj48c3BhbiBjbGFzcz0iY29weXJpZ2h0bG9nbyI+Q29weXJpZ2h0Jm5ic3A7JmNvcHk7Jm5ic3A7MjAwNiwgMjAwOCwmbmJzcDtPcmFjbGUuJm5ic3A7QWxsJm5ic3A7cmlnaHRzJm5ic3A7cmVzZXJ2ZWQuPC9zcGFuPjwvYT48L3RkPgotPC90cj4KLTwvdGFibGU+Ci08L2Rpdj4KLTwhLS0gY2xhc3M9ImZvb3RlciIgLS0+Ci08L2JvZHk+Ci08L2h0bWw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZG9jLnVzZXIvd2hhdHNfbmV3MDA4Lmh0bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci93aGF0c19uZXcwMDguaHRtCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwOThlMmVhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5kb2MudXNlci93aGF0c19uZXcwMDguaHRtCisrKyAvZGV2L251bGwKQEAgLTEsNDMgKzAsMCBAQAotPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIKLSAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Ci08aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiI+Ci08aGVhZD4KLTwhLS0gUnVuIGRhdGUgPSBKdWx5IDIzLCAyMDA4IDg6NTk6NTQgLS0+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11cy1hc2NpaSIgLz4KLTx0aXRsZT5HZW5lcmF0ZSBEREwgZnJvbSBFbnRpdGllcyB3aXphcmQ8L3RpdGxlPgotIAotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyIgLz4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCIgLz4KLTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iT3JhY2xlIERBUkIgWEhUTUwgQ29udmVydGVyIChNb2RlID0gb2hqL29odykgLSBWZXJzaW9uIDUuMCIgLz4KLTxtZXRhIG5hbWU9ImRhdGUiIGNvbnRlbnQ9IjIwMDUtMDctMTBUMTI6NTc6MjArMDg6MDAiIC8+Ci08bWV0YSBuYW1lPSJyb2JvdHMiIGNvbnRlbnQ9Im5vYXJjaGl2ZSIgLz4KLTxtZXRhIG5hbWU9ImRvY3RpdGxlIiBjb250ZW50PSJHZW5lcmF0ZSBEREwgZnJvbSBFbnRpdGllcyB3aXphcmQiIC8+Ci08bWV0YSBuYW1lPSJyZWxudW0iIGNvbnRlbnQ9IlJlbGVhc2UgMi4wIiAvPgotPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDAsIDIwMDggb3JhY2xlIC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuIENvbnRyaWJ1dG9yczogT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIiAvPgotPGxpbmsgcmVsPSJjb3B5cmlnaHQiIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSIgdGl0bGU9IkNvcHlyaWdodCIgdHlwZT0idGV4dC9odG1sIiAvPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkY29tbW9uL2Nzcy9ibGFmZG9jLmNzcyIgdGl0bGU9Ik9yYWNsZSBCTEFGRG9jIiB0eXBlPSJ0ZXh0L2NzcyIgLz4KLTwhLS0gc3RhcnQtLT4KLTwhLS0gY29udGVudHMgLS0+Ci08L2hlYWQ+Ci08Ym9keT4KLTxwPjxhIGlkPSJDRUdJRENDRSIgbmFtZT0iQ0VHSURDQ0UiPjwvYT48L3A+Ci08ZGl2IGNsYXNzPSJzZWN0MSI+PCEtLSBpbmZvbGV2ZWw9ImFsbCIgaW5mb3R5cGU9IkdlbmVyYWwiIC0tPgotPGgxPkdlbmVyYXRlIERETCBmcm9tIEVudGl0aWVzIHdpemFyZDwvaDE+Ci08cD5Vc2UgdGhlIDxzcGFuIGNsYXNzPSJndWktb2JqZWN0LXRpdGxlIj5HZW5lcmF0ZSBEREw8L3NwYW4+IHdpemFyZCB0byBxdWlja2x5IGNyZWF0ZSBEREwgc2NyaXB0cyBmcm9tIHlvdXIgcGVyc2lzdGVudCBlbnRpdGllcy4gRGFsaSBhdXRvbWF0aWNhbGx5IGNyZWF0ZXMgdGhlIG5lY2Vzc2FyeSBwcmltYXJ5IGFuZCBmb3JlaWduIGtleXMsIGJhc2VkIG9uIHRoZSBlbnRpdHkgbWFwcGluZ3MuPC9wPgotPGltZyBzcmM9ImltZy9uZ3JlbGMucG5nIiBhbHQ9IlJlbGF0ZWQgY29uY2VwdCIgdGl0bGU9IlJlbGF0ZWQgY29uY2VwdCIgLz48YnIgLz4KLTxiciAvPgotPGltZyBzcmM9ImltZy9uZ3JlbHQucG5nIiBhbHQ9IlJlbGF0ZWQgdGFzayIgdGl0bGU9IlJlbGF0ZWQgdGFzayIgLz48YnIgLz4KLTxiciAvPgotPGEgaHJlZj0idGFza3MwMjEuaHRtI0NJSEpJR0JFIj5HZW5lcmF0aW5nIERETCBmcm9tIEVudGl0aWVzPC9hPjwvZGl2PgotPCEtLSBjbGFzcz0ic2VjdDEiIC0tPgotPCEtLSBTdGFydCBGb290ZXIgLS0+Ci08ZGl2IGNsYXNzPSJmb290ZXIiPgotPHRhYmxlIGNsYXNzPSJzaW1wbGUgb2FjX25vX3dhcm4iIHN1bW1hcnk9IiIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiB3aWR0aD0iMTAwJSI+Ci08dHI+Ci08dGQgYWxpZ249ImxlZnQiIHdpZHRoPSI4NiUiPjxhIGhyZWY9ImRjb21tb24vaHRtbC9jcHlyLmh0bSI+PHNwYW4gY2xhc3M9ImNvcHlyaWdodGxvZ28iPkNvcHlyaWdodCZuYnNwOyZjb3B5OyZuYnNwOzIwMDYsIDIwMDgsJm5ic3A7T3JhY2xlLiZuYnNwO0FsbCZuYnNwO3JpZ2h0cyZuYnNwO3Jlc2VydmVkLjwvc3Bhbj48L2E+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotPC9kaXY+Ci08IS0tIGNsYXNzPSJmb290ZXIiIC0tPgotPC9ib2R5PgotPC9odG1sPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuLy5jbGFzc3BhdGggYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5kZGxnZW4vLmNsYXNzcGF0aApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTYwMGNlOC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5kZGxnZW4vLmNsYXNzcGF0aAorKysgL2Rldi9udWxsCkBAIC0xLDggKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxjbGFzc3BhdGg+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9ImNvbiIgcGF0aD0ib3JnLmVjbGlwc2UuamR0LmxhdW5jaGluZy5KUkVfQ09OVEFJTkVSL29yZy5lY2xpcHNlLmpkdC5pbnRlcm5hbC5kZWJ1Zy51aS5sYXVuY2hlci5TdGFuZGFyZFZNVHlwZS9KMlNFLTEuNSIvPgotCTxjbGFzc3BhdGhlbnRyeSBraW5kPSJjb24iIHBhdGg9Im9yZy5lY2xpcHNlLnBkZS5jb3JlLnJlcXVpcmVkUGx1Z2lucyIvPgotCTxjbGFzc3BhdGhlbnRyeSBraW5kPSJzcmMiIHBhdGg9InNyYyIvPgotCTxjbGFzc3BhdGhlbnRyeSBleHBvcnRlZD0idHJ1ZSIga2luZD0ibGliIiBwYXRoPSJsaWIvcGVyc2lzdGVuY2UuamFyIiBzb3VyY2VwYXRoPSJvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5kZGxnZW5zcmMuemlwIi8+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9Im91dHB1dCIgcGF0aD0iYmluIi8+Ci08L2NsYXNzcGF0aD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmRkbGdlbi8uY3ZzaWdub3JlIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuLy5jdnNpZ25vcmUKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGM1ZTgyZDcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuLy5jdnNpZ25vcmUKKysrIC9kZXYvbnVsbApAQCAtMSArMCwwIEBACi1iaW4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5kZGxnZW4vLnByb2plY3QgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5kZGxnZW4vLnByb2plY3QKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDM3NjMxMWYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuLy5wcm9qZWN0CisrKyAvZGV2L251bGwKQEAgLTEsMjggKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxwcm9qZWN0RGVzY3JpcHRpb24+Ci0JPG5hbWU+b3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuPC9uYW1lPgotCTxjb21tZW50PjwvY29tbWVudD4KLQk8cHJvamVjdHM+Ci0JPC9wcm9qZWN0cz4KLQk8YnVpbGRTcGVjPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UuamR0LmNvcmUuamF2YWJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLk1hbmlmZXN0QnVpbGRlcjwvbmFtZT4KLQkJCTxhcmd1bWVudHM+Ci0JCQk8L2FyZ3VtZW50cz4KLQkJPC9idWlsZENvbW1hbmQ+Ci0JCTxidWlsZENvbW1hbmQ+Ci0JCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuU2NoZW1hQnVpbGRlcjwvbmFtZT4KLQkJCTxhcmd1bWVudHM+Ci0JCQk8L2FyZ3VtZW50cz4KLQkJPC9idWlsZENvbW1hbmQ+Ci0JPC9idWlsZFNwZWM+Ci0JPG5hdHVyZXM+Ci0JCTxuYXR1cmU+b3JnLmVjbGlwc2UuamR0LmNvcmUuamF2YW5hdHVyZTwvbmF0dXJlPgotCQk8bmF0dXJlPm9yZy5lY2xpcHNlLnBkZS5QbHVnaW5OYXR1cmU8L25hdHVyZT4KLQk8L25hdHVyZXM+Ci08L3Byb2plY3REZXNjcmlwdGlvbj4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmRkbGdlbi8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuamR0LmNvcmUucHJlZnMgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5kZGxnZW4vLnNldHRpbmdzL29yZy5lY2xpcHNlLmpkdC5jb3JlLnByZWZzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4MDQxYmMyLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmRkbGdlbi8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuamR0LmNvcmUucHJlZnMKKysrIC9kZXYvbnVsbApAQCAtMSw3ICswLDAgQEAKLSNXZWQgQXByIDMwIDE3OjI0OjQxIEVEVCAyMDA4Ci1lY2xpcHNlLnByZWZlcmVuY2VzLnZlcnNpb249MQotb3JnLmVjbGlwc2UuamR0LmNvcmUuY29tcGlsZXIuY29kZWdlbi50YXJnZXRQbGF0Zm9ybT0xLjUKLW9yZy5lY2xpcHNlLmpkdC5jb3JlLmNvbXBpbGVyLmNvbXBsaWFuY2U9MS41Ci1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5wcm9ibGVtLmFzc2VydElkZW50aWZpZXI9ZXJyb3IKLW9yZy5lY2xpcHNlLmpkdC5jb3JlLmNvbXBpbGVyLnByb2JsZW0uZW51bUlkZW50aWZpZXI9ZXJyb3IKLW9yZy5lY2xpcHNlLmpkdC5jb3JlLmNvbXBpbGVyLnNvdXJjZT0xLjUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmRkbGdlbi9NRVRBLUlORi9NQU5JRkVTVC5NRiBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmRkbGdlbi9NRVRBLUlORi9NQU5JRkVTVC5NRgpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZGIyYjQ1MC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5kZGxnZW4vTUVUQS1JTkYvTUFOSUZFU1QuTUYKKysrIC9kZXYvbnVsbApAQCAtMSwxMyArMCwwIEBACi1NYW5pZmVzdC1WZXJzaW9uOiAxLjAKLUJ1bmRsZS1NYW5pZmVzdFZlcnNpb246IDIKLUJ1bmRsZS1OYW1lOiAlcGx1Z2luTmFtZQotQnVuZGxlLVZlbmRvcjogJXByb3ZpZGVyTmFtZQotQnVuZGxlLVN5bWJvbGljTmFtZTogb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuO3NpbmdsZXRvbjo9dHJ1ZQotQnVuZGxlLVZlcnNpb246IDEuMC4xMDAucXVhbGlmaWVyCi1CdW5kbGUtQ2xhc3NQYXRoOiBsaWIvcGVyc2lzdGVuY2UuamFyCi1CdW5kbGUtTG9jYWxpemF0aW9uOiBwbHVnaW4KLVJlcXVpcmUtQnVuZGxlOiBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZTtidW5kbGUtdmVyc2lvbj0iWzEuMC4wLDIuMC4wKSIKLUV4cG9ydC1QYWNrYWdlOiBqYXZheC5wZXJzaXN0ZW5jZSwKLSBqYXZheC5wZXJzaXN0ZW5jZS5zcGksCi0gb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuCi1CdW5kbGUtUmVxdWlyZWRFeGVjdXRpb25FbnZpcm9ubWVudDogSjJTRS0xLjUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmRkbGdlbi9hYm91dC5odG1sIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuL2Fib3V0Lmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDA3MWY1ODYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuL2Fib3V0Lmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSw0NyArMCwwIEBACi08IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wLy9FTiI+Ci08SFRNTD4KLQotPGhlYWQ+Ci08dGl0bGU+QWJvdXQ8L3RpdGxlPgotPG1ldGEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiPgotPC9oZWFkPgotCi08Qk9EWSBsYW5nPSJFTi1VUyI+Ci0KLTxIMj5BYm91dCBUaGlzIENvbnRlbnQ8L0gyPgotCi08UD5NYXkgMDIsIDIwMDg8L1A+Ci0KLTxIMz5MaWNlbnNlPC9IMz4KLQotPFA+VGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYWtlcyBhdmFpbGFibGUgYWxsIGNvbnRlbnQgaW4gdGhpcyBwbHVnLWluIAotKCJDb250ZW50IikuIFVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkIGJlbG93LCB0aGUgQ29udGVudCBpcyBwcm92aWRlZCB0byB5b3UgCi11bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgCi0oIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBhdmFpbGFibGUgYXQKLTxBIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvb3JnL2RvY3VtZW50cy9lcGwtdjEwLnBocCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9vcmcvZG9jdW1lbnRzL2VwbC12MTAucGhwPC9BPi4gCi1Gb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC48L1A+Ci0KLTxQPklmIHlvdSBkaWQgbm90IHJlY2VpdmUgdGhpcyBDb250ZW50IGRpcmVjdGx5IGZyb20gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiwgdGhlIAotQ29udGVudCBpcyBiZWluZyByZWRpc3RyaWJ1dGVkIGJ5IGFub3RoZXIgcGFydHkgKCJSZWRpc3RyaWJ1dG9yIikgYW5kIGRpZmZlcmVudCAKLXRlcm1zIGFuZCBjb25kaXRpb25zIG1heSBhcHBseSB0byB5b3VyIHVzZSBvZiBhbnkgb2JqZWN0IGNvZGUgaW4gdGhlIENvbnRlbnQuIAotQ2hlY2sgdGhlIFJlZGlzdHJpYnV0b3IncyBsaWNlbnNlIHRoYXQgd2FzIHByb3ZpZGVkIHdpdGggdGhlIENvbnRlbnQuIElmIG5vIHN1Y2ggCi1saWNlbnNlIGV4aXN0cywgY29udGFjdCB0aGUgUmVkaXN0cmlidXRvci4gVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQgYmVsb3csIHRoZSAKLXRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFUEwgc3RpbGwgYXBwbHkgdG8gYW55IHNvdXJjZSBjb2RlIGluIHRoZSBDb250ZW50IAotYW5kIHN1Y2ggc291cmNlIGNvZGUgbWF5IGJlIG9idGFpbmVkIGF0Ci08QSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnLyI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy88L0E+LjwvUD4KLQotPGgzPlRoaXJkIFBhcnR5IENvbnRlbnQ8L2gzPgotPHA+VGhlIENvbnRlbnQgaW5jbHVkZXMgaXRlbXMgdGhhdCBoYXZlIGJlZW4gc291cmNlZCBmcm9tIHRoaXJkIHBhcnRpZXMgYXMgc2V0IAotICBvdXQgYmVsb3cuIElmIHlvdSBkaWQgbm90IHJlY2VpdmUgdGhpcyBDb250ZW50IGRpcmVjdGx5IGZyb20gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiwgCi0gIHRoZSBmb2xsb3dpbmcgaXMgcHJvdmlkZWQgZm9yIGluZm9ybWF0aW9uYWwgcHVycG9zZXMgb25seSwgYW5kIHlvdSBzaG91bGQgbG9vayAKLSAgdG8gdGhlIFJlZGlzdHJpYnV0b3ImIzgyMTc7cyBsaWNlbnNlIGZvciB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB1c2UuPC9wPgotCi08aDQ+PGEgbmFtZT0iSlBBIiBpZD0iSlBBIj48L2E+SmF2YSBQZXJzaXN0ZW5jZSBBUEkgKEpQQSkgdjEuMDwvaDQ+Ci0KLTxibG9ja3F1b3RlPgotICA8cD5UaGUgSmF2YSBQZXJzaXN0ZW5jZSBBUEkgKEpQQSkgd2hpY2ggaXMgZGlzdHJpYnV0ZWQgdW5kZXIgPGEgaHJlZj0iaHR0cHM6Ly9nbGFzc2Zpc2guZGV2LmphdmEubmV0L3B1YmxpYy9DRERMdjEuMC5odG1sIj5DRERMIAotICAgIHYxLjA8L2E+IGlzIHJlcXVpcmVkIGJ5IHRoZSBEYWxpIEphdmEgUGVyc2lzdGVuY2UgVG9vbHMgUHJvamVjdCBpbiBvcmRlciAKLSAgICB0byBzdXBwb3J0IHRoaXMgc3RhbmRhcmQuPC9wPgotPC9ibG9ja3F1b3RlPgotPC9CT0RZPgotPC9IVE1MPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuL2J1aWxkLnByb3BlcnRpZXMgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5kZGxnZW4vYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMGY3YmNlMy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5kZGxnZW4vYnVpbGQucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDIwICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA4IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLWphdmFjU291cmNlPTEuNQotamF2YWNUYXJnZXQ9MS41Ci1zb3VyY2UuLiA9IHNyYy8KLW91dHB1dC4uID0gYmluLwotYmluLmluY2x1ZGVzID0gLixcCi0gICAgICAgICAgICAgICBNRVRBLUlORi8sXAotICAgICAgICAgICAgICAgbGliL3BlcnNpc3RlbmNlLmphcixcCi0gICAgICAgICAgICAgICBhYm91dC5odG1sLFwKLSAgICAgICAgICAgICAgIHBsdWdpbi5wcm9wZXJ0aWVzCi1qYXJzLmNvbXBpbGUub3JkZXIgPSAuCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5kZGxnZW4vbGliL3BlcnNpc3RlbmNlLmphciBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmRkbGdlbi9saWIvcGVyc2lzdGVuY2UuamFyCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxYTFiMjMyLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmRkbGdlbi9saWIvcGVyc2lzdGVuY2UuamFyCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuL3BsdWdpbi5wcm9wZXJ0aWVzIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuL3BsdWdpbi5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwZTMxMTIyLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmRkbGdlbi9wbHVnaW4ucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDI0ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA4IE9yYWNsZS4KLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscwotIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLSMgVG8gY29kZSBkZXZlbG9wZXI6Ci0jICAgRG8gTk9UIGNoYW5nZSB0aGUgcHJvcGVydGllcyBiZXR3ZWVuIHRoaXMgbGluZSBhbmQgdGhlCi0jICAgIiUlJSBFTkQgT0YgVFJBTlNMQVRFRCBQUk9QRVJUSUVTICUlJSIgbGluZS4KLSMgICBNYWtlIGEgbmV3IHByb3BlcnR5IG5hbWUsIGFwcGVuZCB0byB0aGUgZW5kIG9mIHRoZSBmaWxlIGFuZCBjaGFuZ2UKLSMgICB0aGUgY29kZSB0byB1c2UgdGhlIG5ldyBwcm9wZXJ0eS4KLSMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLQotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotIyAlJSUgRU5EIE9GIFRSQU5TTEFURUQgUFJPUEVSVElFUyAlJSUKLSMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLQotcGx1Z2luTmFtZSA9IEphdmEgUGVyc2lzdGVuY2UgQVBJIFRvb2xzIC0gRWNsaXBzZUxpbmsgU3VwcG9ydCAtIERETCBHZW5lcmF0aW9uCi1wcm92aWRlck5hbWUgPSBFY2xpcHNlLm9yZwpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvY29yZS9kZGxnZW4vTWFpbi5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvY29yZS9kZGxnZW4vTWFpbi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjMWI5MWMzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmRkbGdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL2NvcmUvZGRsZ2VuL01haW4uamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDIxNyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSogCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuZGRsZ2VuOwotCi1pbXBvcnQgamF2YS5pby5GaWxlOwotaW1wb3J0IGphdmEuaW8uRmlsZUlucHV0U3RyZWFtOwotaW1wb3J0IGphdmEuaW8uSU9FeGNlcHRpb247Ci1pbXBvcnQgamF2YS51dGlsLkhhc2hNYXA7Ci1pbXBvcnQgamF2YS51dGlsLk1hcDsKLWltcG9ydCBqYXZhLnV0aWwuUHJvcGVydGllczsKLWltcG9ydCBqYXZhLnV0aWwuU2V0OwotaW1wb3J0IGphdmEudXRpbC5NYXAuRW50cnk7Ci1pbXBvcnQgamF2YXgucGVyc2lzdGVuY2UuRW50aXR5TWFuYWdlckZhY3Rvcnk7Ci1pbXBvcnQgamF2YXgucGVyc2lzdGVuY2UuUGVyc2lzdGVuY2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5zY2hlbWEuZ2VuZXJhdGlvbi5TY2hlbWFHZW5lcmF0aW9uOwotCi0vKiogCi0gKiBUaGlzIGNsYXNzIGNyZWF0ZXMgYSBFY2xpcHNlTGluayA8Y29kZT5FbnRpdHlNYW5hZ2VyRmFjdG9yeTwvY29kZT4sIAotICogYW5kIGV4ZWN1dGVzIHRoZSBEREwgZ2VuZXJhdG9yIHdpdGggdGhlIGNvbW1hbmQgc2V0IGluIHRoZSBwcm9wZXJ0aWVzOiAKLSAqICAgICA8Y29kZT5lY2xpcHNlbGluay5kZGwtZ2VuZXJhdGlvbi5vdXRwdXQtbW9kZTwvY29kZT4gCi0gKiAgICAgPGNvZGU+ZWNsaXBzZWxpbmsuYXBwbGljYXRpb24tbG9jYXRpb248L2NvZGU+Ci0gKiAKLSAqIEN1cnJlbnQgY29tbWFuZC1saW5lIGFyZ3VtZW50czoKLSAqICAgICBbLXB1IHB1TmFtZV0gLSBwZXJzaXN0ZW5jZSB1bml0IG5hbWUKLSAqICAgICBbLXAgcHJvcGVydGllc0ZpbGVQYXRoXSAtIHByb3BlcnRpZXMgZm9yIEVjbGlwc2VMaW5rIEVudGl0eU1hbmFnZXIKLSAqICAKLSAqICBFeGFtcGxlIG9mIGEgcHJvcGVydGllcyBmaWxlOgotICogIAllY2xpcHNlbGluay5qZGJjLmJpbmQtcGFyYW1ldGVycz1mYWxzZQotICogIAllY2xpcHNlbGluay5qZGJjLmRyaXZlcj1vcmcuYXBhY2hlLmRlcmJ5LmpkYmMuRW1iZWRkZWREcml2ZXIKLSAqICAJZWNsaXBzZWxpbmsuamRiYy51cmw9amRiY1w6ZGVyYnlcOmNcOi9kZXJieWRiL3Rlc3RkYjtjcmVhdGVcPXRydWUKLSAqICAJZWNsaXBzZWxpbmsuamRiYy51c2VyPXRyYW4KLSAqICAJZWNsaXBzZWxpbmsuamRiYy5wYXNzd29yZD0KLSAqICAJZWNsaXBzZWxpbmsubG9nZ2luZy5sZXZlbD1GSU5FU1QKLSAqICAJZWNsaXBzZWxpbmsubG9nZ2luZy50aW1lc3RhbXA9ZmFsc2UKLSAqICAJZWNsaXBzZWxpbmsubG9nZ2luZy50aHJlYWQ9ZmFsc2UKLSAqICAJZWNsaXBzZWxpbmsubG9nZ2luZy5zZXNzaW9uPWZhbHNlCi0gKiAgCWVjbGlwc2VsaW5rLmxvZ2dpbmcuZXhjZXB0aW9ucz10cnVlCi0gKiAgCWVjbGlwc2VsaW5rLm9ybS50aHJvdy5leGNlcHRpb25zPXRydWUKLSAqICAJZWNsaXBzZWxpbmsuZGRsLWdlbmVyYXRpb24ub3V0cHV0LW1vZGU9ZGF0YWJhc2UKLSAqICAJZWNsaXBzZWxpbmsuZGRsLWdlbmVyYXRpb249ZHJvcC1hbmQtY3JlYXRlLXRhYmxlcwotICogIAllY2xpcHNlbGluay5hcHBsaWNhdGlvbi1sb2NhdGlvbj1jXDovX1Byb2plY3RzXy9FeGFtcGxlRERMCi0gKi8KLXB1YmxpYyBjbGFzcyBNYWluCi17Ci0JcHJvdGVjdGVkIEVudGl0eU1hbmFnZXJGYWN0b3J5IGVtZjsKLQlwcml2YXRlIE1hcDxTdHJpbmcsIFN0cmluZz4gZWNsaXBzZUxpbmtQcm9wZXJ0aWVzOwotCXByaXZhdGUgU3RyaW5nIGNyZWF0ZURETEZpbGVOYW1lOwotCXByaXZhdGUgU3RyaW5nIGRyb3BERExGaWxlTmFtZTsKLQlwcml2YXRlIFN0cmluZyBhcHBMb2NhdGlvbjsKLQlwcml2YXRlIFN0cmluZyBlY2xpcHNlTGlua1Byb3BlcnRpZXNQYXRoOwotCXByaXZhdGUgYm9vbGVhbiBpc0RlYnVnTW9kZTsKLQkKLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0JCi0JcHVibGljIHN0YXRpYyB2b2lkIG1haW4oU3RyaW5nW10gYXJncykgewotCQluZXcgTWFpbigpLmV4ZWN1dGUoYXJncyk7Ci0JfQotCi0JcHJpdmF0ZSBNYWluKCkgewotCQlzdXBlcigpOwotCX0KLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCQotCXByb3RlY3RlZCB2b2lkIGV4ZWN1dGUoU3RyaW5nW10gYXJncykgewotCQl0aGlzLmluaXRpYWxpemVXaXRoKGFyZ3MpOwotCQkKLQkJdGhpcy5lbWYgPSBQZXJzaXN0ZW5jZS5jcmVhdGVFbnRpdHlNYW5hZ2VyRmFjdG9yeSh0aGlzLmdldFBVTmFtZShhcmdzKSwgdGhpcy5lY2xpcHNlTGlua1Byb3BlcnRpZXMpOwotCQl0aGlzLnBlcmZvcm0oKTsKLQkJdGhpcy5jbG9zZUVudGl0eU1hbmFnZXJGYWN0b3J5KCk7Ci0JCQotCQl0aGlzLmRpc3Bvc2UoKTsKLQkJcmV0dXJuOwotCX0KLQkKLQlwcm90ZWN0ZWQgdm9pZCBwZXJmb3JtKCkgewotCQkvLyBjcmVhdGUgYW4gRU0gdG8gZ2VuZXJhdGUgc2NoZW1hLgotCQl0aGlzLmVtZi5jcmVhdGVFbnRpdHlNYW5hZ2VyKCkuY2xvc2UoKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIHZvaWQgY2xvc2VFbnRpdHlNYW5hZ2VyRmFjdG9yeSgpIHsKLQkJdGhpcy5lbWYuY2xvc2UoKTsKLQl9Ci0JCi0JcHJpdmF0ZSB2b2lkIGluaXRpYWxpemVXaXRoKFN0cmluZ1tdIGFyZ3MpIHsKLQotCQl0aGlzLmVjbGlwc2VMaW5rUHJvcGVydGllc1BhdGggPSB0aGlzLmdldEVjbGlwc2VMaW5rUHJvcGVydGllc1BhdGgoYXJncyk7Ci0JCXRoaXMuZWNsaXBzZUxpbmtQcm9wZXJ0aWVzID0gdGhpcy5nZXRQcm9wZXJ0aWVzKHRoaXMuZWNsaXBzZUxpbmtQcm9wZXJ0aWVzUGF0aCk7Ci0JCQotCQl0aGlzLmNyZWF0ZURETEZpbGVOYW1lID0gdGhpcy5nZXRDb25maWdQcm9wZXJ0eUFzU3RyaW5nKCAKLQkJCQkJCVNjaGVtYUdlbmVyYXRpb24uRUNMSVBTRUxJTktfQ1JFQVRFX0ZJTEVfTkFNRSwgCi0JCQkJCQl0aGlzLmVjbGlwc2VMaW5rUHJvcGVydGllcywgIAotCQkJCQkJU2NoZW1hR2VuZXJhdGlvbi5ERUZBVUxUX1NDSEVNQV9HRU5FUkFUSU9OX0NSRUFURV9GSUxFX05BTUUpOwotCi0JCXRoaXMuZHJvcERETEZpbGVOYW1lID0gdGhpcy5nZXRDb25maWdQcm9wZXJ0eUFzU3RyaW5nKAotCQkJCQkJU2NoZW1hR2VuZXJhdGlvbi5FQ0xJUFNFTElOS19EUk9QX0ZJTEVfTkFNRSwgCi0JCQkJCQl0aGlzLmVjbGlwc2VMaW5rUHJvcGVydGllcywgIAotCQkJCQkJU2NoZW1hR2VuZXJhdGlvbi5ERUZBVUxUX1NDSEVNQV9HRU5FUkFUSU9OX0RST1BfRklMRV9OQU1FKTsgCi0JCQotCQl0aGlzLmFwcExvY2F0aW9uID0gdGhpcy5lY2xpcHNlTGlua1Byb3BlcnRpZXMuZ2V0KAotCQkJCQkJU2NoZW1hR2VuZXJhdGlvbi5FQ0xJUFNFTElOS19BUFBMSUNBVElPTl9MT0NBVElPTik7Ci0KLQkJdGhpcy5pc0RlYnVnTW9kZSA9IHRoaXMuZ2V0RGVidWdNb2RlKGFyZ3MpOwotCX0KLQkKLQlwcml2YXRlIHZvaWQgZGlzcG9zZSgpIHsKLQotCQlpZiggISB0aGlzLmlzRGVidWdNb2RlKSB7Ci0JCQluZXcgRmlsZSh0aGlzLmFwcExvY2F0aW9uICsgIi8iICsgdGhpcy5jcmVhdGVERExGaWxlTmFtZSkuZGVsZXRlKCk7Ci0JCQluZXcgRmlsZSh0aGlzLmFwcExvY2F0aW9uICsgIi8iICsgdGhpcy5kcm9wRERMRmlsZU5hbWUpLmRlbGV0ZSgpOwotCQkJbmV3IEZpbGUodGhpcy5lY2xpcHNlTGlua1Byb3BlcnRpZXNQYXRoKS5kZWxldGUoKTsKLQkJfQotCX0KLQkKLQlwcml2YXRlIE1hcDxTdHJpbmcsIFN0cmluZz4gZ2V0UHJvcGVydGllcyhTdHJpbmcgZWNsaXBzZUxpbmtQcm9wZXJ0aWVzUGF0aCkgewotCQkKLQkJU2V0PEVudHJ5PE9iamVjdCwgT2JqZWN0Pj4gcHJvcGVydGllc1NldCA9IG51bGw7Ci0JCXRyeSB7Ci0JCQlwcm9wZXJ0aWVzU2V0ID0gdGhpcy5sb2FkRWNsaXBzZUxpbmtQcm9wZXJ0aWVzKGVjbGlwc2VMaW5rUHJvcGVydGllc1BhdGgpOwotCQl9Ci0JCWNhdGNoIChJT0V4Y2VwdGlvbiBlKSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbigiTWlzc2luZzogIiArIGVjbGlwc2VMaW5rUHJvcGVydGllc1BhdGgsIGUpOwotCQl9Ci0JCQotCQlNYXA8U3RyaW5nLCBTdHJpbmc+IHByb3BlcnRpZXMgPSBuZXcgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4oKTsKLQkJZm9yKEVudHJ5PE9iamVjdCwgT2JqZWN0PiBwcm9wZXJ0eSA6IHByb3BlcnRpZXNTZXQpIHsKLQkJCXByb3BlcnRpZXMucHV0KChTdHJpbmcpcHJvcGVydHkuZ2V0S2V5KCksIChTdHJpbmcpcHJvcGVydHkuZ2V0VmFsdWUoKSk7Ci0JCX0KLQkJcmV0dXJuIHByb3BlcnRpZXM7Ci0JfQotCi0gICAgcHJpdmF0ZSBTZXQ8RW50cnk8T2JqZWN0LCBPYmplY3Q+PiBsb2FkRWNsaXBzZUxpbmtQcm9wZXJ0aWVzKFN0cmluZyBlY2xpcHNlTGlua1Byb3BlcnRpZXNQYXRoKSB0aHJvd3MgSU9FeGNlcHRpb24gewotCQkKLSAgICAgICAgRmlsZUlucHV0U3RyZWFtIHN0cmVhbSA9IG5ldyBGaWxlSW5wdXRTdHJlYW0oZWNsaXBzZUxpbmtQcm9wZXJ0aWVzUGF0aCk7Ci0gICAgICAgIAotICAgICAgICBQcm9wZXJ0aWVzIHByb3BlcnRpZXMgPSBuZXcgUHJvcGVydGllcygpOwotICAgICAgICBwcm9wZXJ0aWVzLmxvYWQoc3RyZWFtKTsKLSAgICAgICAgCi0gICAgICAgIHJldHVybiBwcm9wZXJ0aWVzLmVudHJ5U2V0KCk7Ci0JfQotCi0JLy8gKioqKioqKioqKiBhcmd1bWVudCBxdWVyaWVzICoqKioqKioqKioKLSAgICAKLQlwcml2YXRlIFN0cmluZyBnZXRQVU5hbWUoU3RyaW5nW10gYXJncykgewotCi0JCXJldHVybiB0aGlzLmdldEFyZ3VtZW50VmFsdWUoIi1wdSIsIGFyZ3MpOwotCX0KLQkKLQlwcml2YXRlIFN0cmluZyBnZXRFY2xpcHNlTGlua1Byb3BlcnRpZXNQYXRoKFN0cmluZ1tdIGFyZ3MpIHsKLQotCQlyZXR1cm4gdGhpcy5nZXRBcmd1bWVudFZhbHVlKCItcCIsIGFyZ3MpOwotCX0KLQotCXByaXZhdGUgYm9vbGVhbiBnZXREZWJ1Z01vZGUoU3RyaW5nW10gYXJncykgewotCi0JCXJldHVybiB0aGlzLmFyZ3VtZW50RXhpc3RzKCItZGVidWciLCBhcmdzKTsKLQl9Ci0JCi0JcHJpdmF0ZSBTdHJpbmcgZ2V0QXJndW1lbnRWYWx1ZShTdHJpbmcgYXJndW1lbnQsIFN0cmluZ1tdIGFyZ3MpIHsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBhcmdzLmxlbmd0aDsgaSsrKSB7Ci0JCQlTdHJpbmcgYXJnID0gYXJnc1tpXTsKLQkJCWlmIChhcmcudG9Mb3dlckNhc2UoKS5lcXVhbHMoYXJndW1lbnQpKSB7Ci0JCQkJaW50IGogPSBpICsgMTsKLQkJCQlpZiAoaiA8IGFyZ3MubGVuZ3RoKSB7Ci0JCQkJCXJldHVybiBhcmdzW2pdOwotCQkJCX0KLQkJCX0KLQkJfQotCQlyZXR1cm4gbnVsbDsKLQl9Ci0JCi0JcHJpdmF0ZSBib29sZWFuIGFyZ3VtZW50RXhpc3RzKFN0cmluZyBhcmd1bWVudCwgU3RyaW5nW10gYXJncykgewotCQlmb3IgKGludCBpID0gMDsgaSA8IGFyZ3MubGVuZ3RoOyBpKyspIHsKLQkJCVN0cmluZyBhcmcgPSBhcmdzW2ldOwotCQkJaWYgKGFyZy50b0xvd2VyQ2FzZSgpLmVxdWFscyhhcmd1bWVudCkpIHsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JLy8gKioqKioqIHV0aWxpdHkgbWV0aG9kcyAqKioqKioqCi0JCi0gICAgLyoqCi0gICAgICogQ2hlY2sgdGhlIHByb3ZpZGVkIG1hcCBmb3IgYW4gb2JqZWN0IHdpdGggdGhlIGdpdmVuIGtleS4gIElmIHRoYXQgb2JqZWN0IGlzIG5vdCBhdmFpbGFibGUsIGNoZWNrIHRoZQotICAgICAqIFN5c3RlbSBwcm9wZXJ0aWVzLiAgSWYgaXQgaXMgbm90IGF2YWlsYWJsZSBmcm9tIGVpdGhlciBsb2NhdGlvbiwgcmV0dXJuIHRoZSBkZWZhdWx0IHZhbHVlLgotICAgICAqIEBwYXJhbSBwcm9wZXJ0eUtleSAKLSAgICAgKiBAcGFyYW0gbWFwIAotICAgICAqIEBwYXJhbSBkZWZhdWx0VmFsdWUgCi0gICAgICogQHJldHVybiAKLSAgICAgKi8KLSAgICBwcm90ZWN0ZWQgU3RyaW5nIGdldENvbmZpZ1Byb3BlcnR5QXNTdHJpbmcoU3RyaW5nIHByb3BlcnR5S2V5LCBNYXA8U3RyaW5nLCBTdHJpbmc+IG92ZXJyaWRlcywgU3RyaW5nIGRlZmF1bHRWYWx1ZSl7Ci0gICAgCVN0cmluZyB2YWx1ZSA9IHRoaXMuZ2V0Q29uZmlnUHJvcGVydHlBc1N0cmluZyhwcm9wZXJ0eUtleSwgb3ZlcnJpZGVzKTsKLSAgICAgICAgaWYgKHZhbHVlID09IG51bGwpewotICAgICAgICAgICAgdmFsdWUgPSBkZWZhdWx0VmFsdWU7Ci0gICAgICAgIH0KLSAgICAgICAgcmV0dXJuIHZhbHVlOwotICAgIH0KLSAgICAKLSAgICBwcm90ZWN0ZWQgU3RyaW5nIGdldENvbmZpZ1Byb3BlcnR5QXNTdHJpbmcoU3RyaW5nIHByb3BlcnR5S2V5LCBNYXA8U3RyaW5nLCBTdHJpbmc+IG92ZXJyaWRlcyl7Ci0gICAgICAgIFN0cmluZyB2YWx1ZSA9IG51bGw7Ci0gICAgICAgIGlmIChvdmVycmlkZXMgIT0gbnVsbCl7Ci0gICAgICAgICAgICB2YWx1ZSA9IChTdHJpbmcpb3ZlcnJpZGVzLmdldChwcm9wZXJ0eUtleSk7Ci0gICAgICAgIH0KLSAgICAgICAgaWYgKHZhbHVlID09IG51bGwpewotICAgICAgICAgICAgdmFsdWUgPSBTeXN0ZW0uZ2V0UHJvcGVydHkocHJvcGVydHlLZXkpOwotICAgICAgICB9Ci0gICAgICAgIHJldHVybiB2YWx1ZTsKLSAgICB9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvLmNsYXNzcGF0aCBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS8uY2xhc3NwYXRoCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmY2YwNzk4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS8uY2xhc3NwYXRoCisrKyAvZGV2L251bGwKQEAgLTEsMTUgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxjbGFzc3BhdGg+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9InNyYyIgcGF0aD0ic3JjIi8+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9InNyYyIgcGF0aD0icHJvcGVydHlfZmlsZXMiLz4KLQk8Y2xhc3NwYXRoZW50cnkga2luZD0iY29uIiBwYXRoPSJvcmcuZWNsaXBzZS5qZHQubGF1bmNoaW5nLkpSRV9DT05UQUlORVIvb3JnLmVjbGlwc2UuamR0LmludGVybmFsLmRlYnVnLnVpLmxhdW5jaGVyLlN0YW5kYXJkVk1UeXBlL0oyU0UtMS41Ii8+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9ImNvbiIgcGF0aD0ib3JnLmVjbGlwc2UucGRlLmNvcmUucmVxdWlyZWRQbHVnaW5zIj4KLQkJPGFjY2Vzc3J1bGVzPgotCQkJPGFjY2Vzc3J1bGUga2luZD0iYWNjZXNzaWJsZSIgcGF0dGVybj0ib3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvKioiLz4KLQkJCTxhY2Nlc3NydWxlIGtpbmQ9ImFjY2Vzc2libGUiIHBhdHRlcm49Im9yZy9lY2xpcHNlL2pwdC9jb3JlLyoqIi8+Ci0JCQk8YWNjZXNzcnVsZSBraW5kPSJhY2Nlc3NpYmxlIiBwYXR0ZXJuPSJvcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvY29yZS8qKiIvPgotCQkJPGFjY2Vzc3J1bGUga2luZD0iYWNjZXNzaWJsZSIgcGF0dGVybj0ib3JnL2VjbGlwc2UvanB0L3VpLyoqIi8+Ci0JCTwvYWNjZXNzcnVsZXM+Ci0JPC9jbGFzc3BhdGhlbnRyeT4KLQk8Y2xhc3NwYXRoZW50cnkga2luZD0ib3V0cHV0IiBwYXRoPSJiaW4iLz4KLTwvY2xhc3NwYXRoPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLy5jdnNpZ25vcmUgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvLmN2c2lnbm9yZQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzZlNjQ0Mi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvLmN2c2lnbm9yZQorKysgL2Rldi9udWxsCkBAIC0xLDMgKzAsMCBAQAotYmluCi1AZG90Ci10ZW1wLmZvbGRlcgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLy5wcm9qZWN0IGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLy5wcm9qZWN0CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlNTcyYmUxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS8ucHJvamVjdAorKysgL2Rldi9udWxsCkBAIC0xLDI4ICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08cHJvamVjdERlc2NyaXB0aW9uPgotCTxuYW1lPm9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aTwvbmFtZT4KLQk8Y29tbWVudD48L2NvbW1lbnQ+Ci0JPHByb2plY3RzPgotCTwvcHJvamVjdHM+Ci0JPGJ1aWxkU3BlYz4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLmpkdC5jb3JlLmphdmFidWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5NYW5pZmVzdEJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLlNjaGVtYUJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCTwvYnVpbGRTcGVjPgotCTxuYXR1cmVzPgotCQk8bmF0dXJlPm9yZy5lY2xpcHNlLnBkZS5QbHVnaW5OYXR1cmU8L25hdHVyZT4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5qZHQuY29yZS5qYXZhbmF0dXJlPC9uYXR1cmU+Ci0JPC9uYXR1cmVzPgotPC9wcm9qZWN0RGVzY3JpcHRpb24+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMmZkYjJiMS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzCisrKyAvZGV2L251bGwKQEAgLTEsMyArMCwwIEBACi0jTW9uIEFwciAwNyAxNDoyNjo1OSBFRFQgMjAwOAotZWNsaXBzZS5wcmVmZXJlbmNlcy52ZXJzaW9uPTEKLWVuY29kaW5nLzxwcm9qZWN0Pj1JU08tODg1OS0xCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvLnNldHRpbmdzL29yZy5lY2xpcHNlLmpkdC5jb3JlLnByZWZzIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5qZHQuY29yZS5wcmVmcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOWRkNGMzNi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvLnNldHRpbmdzL29yZy5lY2xpcHNlLmpkdC5jb3JlLnByZWZzCisrKyAvZGV2L251bGwKQEAgLTEsNyArMCwwIEBACi0jU3VuIEZlYiAyNCAyMToyNzowMSBFU1QgMjAwOAotZWNsaXBzZS5wcmVmZXJlbmNlcy52ZXJzaW9uPTEKLW9yZy5lY2xpcHNlLmpkdC5jb3JlLmNvbXBpbGVyLmNvZGVnZW4udGFyZ2V0UGxhdGZvcm09MS41Ci1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5jb21wbGlhbmNlPTEuNQotb3JnLmVjbGlwc2UuamR0LmNvcmUuY29tcGlsZXIucHJvYmxlbS5hc3NlcnRJZGVudGlmaWVyPWVycm9yCi1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5wcm9ibGVtLmVudW1JZGVudGlmaWVyPWVycm9yCi1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5zb3VyY2U9MS41CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvTUVUQS1JTkYvTUFOSUZFU1QuTUYgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvTUVUQS1JTkYvTUFOSUZFU1QuTUYKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDVjODNlN2EuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL01FVEEtSU5GL01BTklGRVNULk1GCisrKyAvZGV2L251bGwKQEAgLTEsNDkgKzAsMCBAQAotTWFuaWZlc3QtVmVyc2lvbjogMS4wCi1CdW5kbGUtTWFuaWZlc3RWZXJzaW9uOiAyCi1CdW5kbGUtTmFtZTogJXBsdWdpbk5hbWUKLUJ1bmRsZS1WZW5kb3I6ICVwcm92aWRlck5hbWUKLUJ1bmRsZS1TeW1ib2xpY05hbWU6IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aTtzaW5nbGV0b246PXRydWUKLUJ1bmRsZS1WZXJzaW9uOiAxLjIuMC5xdWFsaWZpZXIKLUJ1bmRsZS1BY3RpdmF0b3I6IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5KcHRFY2xpcHNlTGlua1VpUGx1Z2luCi1CdW5kbGUtQWN0aXZhdGlvblBvbGljeTogbGF6eQotQnVuZGxlLUNsYXNzUGF0aDogLgotQnVuZGxlLUxvY2FsaXphdGlvbjogcGx1Z2luCi1SZXF1aXJlLUJ1bmRsZTogb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXM7YnVuZGxlLXZlcnNpb249IlszLjQuMCw0LjAuMCkiLAotIG9yZy5lY2xpcHNlLmNvcmUucnVudGltZTtidW5kbGUtdmVyc2lvbj0iWzMuNC4wLDQuMC4wKSIsCi0gb3JnLmVjbGlwc2UuZW1mLmVjb3JlLnhtaTtidW5kbGUtdmVyc2lvbj0iMi40LjEiLAotIG9yZy5lY2xpcHNlLmVtZi5lZGl0LnVpO2J1bmRsZS12ZXJzaW9uPSJbMi40LjAsMy4wLjApIiwKLSBvcmcuZWNsaXBzZS5qZHQuY29yZTtidW5kbGUtdmVyc2lvbj0iWzMuNC4wLDQuMC4wKSIsCi0gb3JnLmVjbGlwc2UuamR0LnVpO2J1bmRsZS12ZXJzaW9uPSJbMy40LjAsNC4wLjApIiwKLSBvcmcuZWNsaXBzZS5qZmFjZS50ZXh0O2J1bmRsZS12ZXJzaW9uPSJbMy40LjAsNC4wLjApIiwKLSBvcmcuZWNsaXBzZS5qcHQuY29yZTtidW5kbGUtdmVyc2lvbj0iWzIuMC4wLDMuMC4wKSIsCi0gb3JnLmVjbGlwc2UuanB0LmRiO2J1bmRsZS12ZXJzaW9uPSJbMS4yLjAsMi4wLjApIiwKLSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZTtidW5kbGUtdmVyc2lvbj0iWzEuMC4wLDIuMC4wKSIsCi0gb3JnLmVjbGlwc2UuanB0LnVpO2J1bmRsZS12ZXJzaW9uPSJbMi4wLjAsMy4wLjApIiwKLSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eTtidW5kbGUtdmVyc2lvbj0iWzEuMi4wLDIuMC4wKSIsCi0gb3JnLmVjbGlwc2UudWk7YnVuZGxlLXZlcnNpb249IlszLjQuMCw0LjAuMCkiLAotIG9yZy5lY2xpcHNlLnVpLmlkZTtidW5kbGUtdmVyc2lvbj0iWzMuNC4wLDQuMC4wKSIsCi0gb3JnLmVjbGlwc2UudWkubmF2aWdhdG9yO2J1bmRsZS12ZXJzaW9uPSJbMy4zLjEwMCw0LjAuMCkiLAotIG9yZy5lY2xpcHNlLnVpLnZpZXdzLnByb3BlcnRpZXMudGFiYmVkO2J1bmRsZS12ZXJzaW9uPSJbMy40LjAsNC4wLjApIiwKLSBvcmcuZWNsaXBzZS53c3QuY29tbW9uLmVtZjtidW5kbGUtdmVyc2lvbj0iMS4xLjIwMiIsCi0gb3JnLmVjbGlwc2Uud3N0LmNvbW1vbi5mcmFtZXdvcmtzO2J1bmRsZS12ZXJzaW9uPSJbMS4xLjIwMCwyLjAuMCkiLAotIG9yZy5lY2xpcHNlLndzdC5jb21tb24uZnJhbWV3b3Jrcy51aTtidW5kbGUtdmVyc2lvbj0iWzEuMS4yMDAsMi4wLjApIgotRXhwb3J0LVBhY2thZ2U6IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aTt4LWludGVybmFsOj10cnVlLAotIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbDt4LWludGVybmFsOj10cnVlLAotIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5kZGxnZW47eC1pbnRlcm5hbDo9dHJ1ZSwKLSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuZGRsZ2VuLndpemFyZHM7eC1pbnRlcm5hbDo9dHJ1ZSwKLSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuamF2YS5kZXRhaWxzO3gtaW50ZXJuYWw6PXRydWUsCi0gb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzO3gtaW50ZXJuYWw6PXRydWUsCi0gb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7eC1pbnRlcm5hbDo9dHJ1ZSwKLSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7eC1pbnRlcm5hbDo9dHJ1ZSwKLSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY2FjaGluZzt4LWludGVybmFsOj10cnVlLAotIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jb25uZWN0aW9uO3gtaW50ZXJuYWw6PXRydWUsCi0gb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb247eC1pbnRlcm5hbDo9dHJ1ZSwKLSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuZ2VuZXJhbDt4LWludGVybmFsOj10cnVlLAotIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5sb2dnaW5nO3gtaW50ZXJuYWw6PXRydWUsCi0gb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLm9wdGlvbnM7eC1pbnRlcm5hbDo9dHJ1ZSwKLSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2Uuc2NoZW1hLmdlbmVyYXRpb247eC1pbnRlcm5hbDo9dHJ1ZSwKLSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2V4bWwuZGV0YWlsczt4LWludGVybmFsOj10cnVlLAotIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wbGF0Zm9ybTt4LWludGVybmFsOj10cnVlLAotIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5zdHJ1Y3R1cmU7eC1pbnRlcm5hbDo9dHJ1ZSwKLSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwud2l6YXJkczt4LWludGVybmFsOj10cnVlCi1CdW5kbGUtUmVxdWlyZWRFeGVjdXRpb25FbnZpcm9ubWVudDogSjJTRS0xLjUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9hYm91dC5odG1sIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL2Fib3V0Lmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJlNTM0YmEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL2Fib3V0Lmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSwzNCArMCwwIEBACi08IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wLy9FTiI+Ci08SFRNTD4KLQotPGhlYWQ+Ci08dGl0bGU+QWJvdXQ8L3RpdGxlPgotPG1ldGEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiPgotPC9oZWFkPgotCi08Qk9EWSBsYW5nPSJFTi1VUyI+Ci0KLTxIMz5BYm91dCBUaGlzIENvbnRlbnQ8L0gzPgotCi08UD5NYXkgMDIsIDIwMDg8L1A+Ci0KLTxIMz5MaWNlbnNlPC9IMz4KLQotPFA+VGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYWtlcyBhdmFpbGFibGUgYWxsIGNvbnRlbnQgaW4gdGhpcyBwbHVnLWluIAotKCJDb250ZW50IikuIFVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkIGJlbG93LCB0aGUgQ29udGVudCBpcyBwcm92aWRlZCB0byB5b3UgCi11bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgCi0oIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBhdmFpbGFibGUgYXQKLTxBIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvb3JnL2RvY3VtZW50cy9lcGwtdjEwLnBocCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9vcmcvZG9jdW1lbnRzL2VwbC12MTAucGhwPC9BPi4gCi1Gb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC48L1A+Ci0KLTxQPklmIHlvdSBkaWQgbm90IHJlY2VpdmUgdGhpcyBDb250ZW50IGRpcmVjdGx5IGZyb20gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiwgdGhlIAotQ29udGVudCBpcyBiZWluZyByZWRpc3RyaWJ1dGVkIGJ5IGFub3RoZXIgcGFydHkgKCJSZWRpc3RyaWJ1dG9yIikgYW5kIGRpZmZlcmVudCAKLXRlcm1zIGFuZCBjb25kaXRpb25zIG1heSBhcHBseSB0byB5b3VyIHVzZSBvZiBhbnkgb2JqZWN0IGNvZGUgaW4gdGhlIENvbnRlbnQuIAotQ2hlY2sgdGhlIFJlZGlzdHJpYnV0b3IncyBsaWNlbnNlIHRoYXQgd2FzIHByb3ZpZGVkIHdpdGggdGhlIENvbnRlbnQuIElmIG5vIHN1Y2ggCi1saWNlbnNlIGV4aXN0cywgY29udGFjdCB0aGUgUmVkaXN0cmlidXRvci4gVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQgYmVsb3csIHRoZSAKLXRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFUEwgc3RpbGwgYXBwbHkgdG8gYW55IHNvdXJjZSBjb2RlIGluIHRoZSBDb250ZW50IAotYW5kIHN1Y2ggc291cmNlIGNvZGUgbWF5IGJlIG9idGFpbmVkIGF0Ci08QSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnLyI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy88L0E+LjwvUD4KLQotPC9CT0RZPgotPC9IVE1MPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL2J1aWxkLnByb3BlcnRpZXMgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjEzYTJlMi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvYnVpbGQucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDIwICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0jIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotIyB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotIyBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotamF2YWNTb3VyY2UgPSAxLjUKLWphdmFjVGFyZ2V0ID0gMS41Ci1zb3VyY2UuLiA9IHNyYy8sXAotICAgICAgICAgICAgICAgcHJvcGVydHlfZmlsZXMvCi1vdXRwdXQuLiA9IGJpbi8KLWJpbi5pbmNsdWRlcyA9IC4sXAotICAgICAgICAgICAgICAgTUVUQS1JTkYvLFwKLSAgICAgICAgICAgICAgIGFib3V0Lmh0bWwsXAotICAgICAgICAgICAgICAgcGx1Z2luLnhtbCxcCi0gICAgICAgICAgICAgICBwbHVnaW4ucHJvcGVydGllcwotamFycy5jb21waWxlLm9yZGVyID0gLgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3BsdWdpbi5wcm9wZXJ0aWVzIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3BsdWdpbi5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwNmU3N2IwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9wbHVnaW4ucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDMwICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSMgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0jIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0jIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotIyBUbyBjb2RlIGRldmVsb3BlcjoKLSMgICBEbyBOT1QgY2hhbmdlIHRoZSBwcm9wZXJ0aWVzIGJldHdlZW4gdGhpcyBsaW5lIGFuZCB0aGUKLSMgICAiJSUlIEVORCBPRiBUUkFOU0xBVEVEIFBST1BFUlRJRVMgJSUlIiBsaW5lLgotIyAgIE1ha2UgYSBuZXcgcHJvcGVydHkgbmFtZSwgYXBwZW5kIHRvIHRoZSBlbmQgb2YgdGhlIGZpbGUgYW5kIGNoYW5nZQotIyAgIHRoZSBjb2RlIHRvIHVzZSB0aGUgbmV3IHByb3BlcnR5LgotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0jICUlJSBFTkQgT0YgVFJBTlNMQVRFRCBQUk9QRVJUSUVTICUlJQotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotcGx1Z2luTmFtZT0gSmF2YSBQZXJzaXN0ZW5jZSBBUEkgVG9vbHMgLSBFY2xpcHNlTGluayBTdXBwb3J0IC0gVUkKLXByb3ZpZGVyTmFtZT1FY2xpcHNlLm9yZwotCi1lY2xpcHNlTGlua1dpemFyZENhdGVnb3J5TmFtZT1FY2xpcHNlTGluawotbmV3RWNsaXBzZUxpbmtNYXBwaW5nRmlsZVdpemFyZE5hbWU9RWNsaXBzZUxpbmsgTWFwcGluZyBGaWxlCi1uZXdFY2xpcHNlTGlua0pwYU1hcHBpbmdGaWxlV2l6YXJkRGVzYz1DcmVhdGUgYW4gRWNsaXBzZUxpbmsgc3BlY2lmaWMgbWFwcGluZyBmaWxlCi0KLW5ld0VjbGlwc2VMaW5rMV8xTWFwcGluZ0ZpbGVXaXphcmROYW1lPUVjbGlwc2VMaW5rIDEuMSBNYXBwaW5nIEZpbGUKLW5ld0VjbGlwc2VMaW5rMV8xSnBhTWFwcGluZ0ZpbGVXaXphcmREZXNjPUNyZWF0ZSBhbiBFY2xpcHNlTGluayAxLjEgc3BlY2lmaWMgbWFwcGluZyBmaWxlClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3BsdWdpbi54bWwgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvcGx1Z2luLnhtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjVjOTlmMy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvcGx1Z2luLnhtbAorKysgL2Rldi9udWxsCkBAIC0xLDE1NCArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPD9lY2xpcHNlIHZlcnNpb249IjMuMiI/PgotPHBsdWdpbj4KLQotCTxleHRlbnNpb24KLQkJcG9pbnQ9Im9yZy5lY2xpcHNlLmpwdC51aS5qcGFQbGF0Zm9ybVVpcyI+Ci0JCSAKLQkJPGpwYVBsYXRmb3JtVWkKLQkJCWlkPSJvcmcuZWNsaXBzZS5lY2xpcHNlbGluay5wbGF0Zm9ybS51aSIKLQkJCWpwYVBsYXRmb3JtPSJvcmcuZWNsaXBzZS5lY2xpcHNlbGluay5wbGF0Zm9ybSIKLQkJCWZhY3RvcnlDbGFzcz0ib3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBsYXRmb3JtLkVjbGlwc2VMaW5rSnBhUGxhdGZvcm1VaUZhY3RvcnkiLz4KLQkJCQotCQk8anBhUGxhdGZvcm1VaQotCQkJaWQ9ImVjbGlwc2VsaW5rMV8xLnVpIgotCQkJanBhUGxhdGZvcm09ImVjbGlwc2VsaW5rMV8xIgotCQkJZmFjdG9yeUNsYXNzPSJvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGxhdGZvcm0uRWNsaXBzZUxpbmsxXzFKcGFQbGF0Zm9ybVVpRmFjdG9yeSIvPgotCQkKLQk8L2V4dGVuc2lvbj4KLSAgIAotICAgCi0gICA8ZXh0ZW5zaW9uCi0JCXBvaW50PSJvcmcuZWNsaXBzZS51aS5uZXdXaXphcmRzIj4KLQkJCi0JCTxjYXRlZ29yeQotCQkJaWQ9Im9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluayIKLQkJCW5hbWU9IiVlY2xpcHNlTGlua1dpemFyZENhdGVnb3J5TmFtZSIKLQkJCXBhcmVudENhdGVnb3J5PSJvcmcuZWNsaXBzZS5qcHQiLz4KLQkJCi0JCTx3aXphcmQKLSAgICAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkud2l6YXJkLm5ld0VjbGlwc2VMaW5rTWFwcGluZ0ZpbGUiCi0JCQluYW1lPSIlbmV3RWNsaXBzZUxpbmtNYXBwaW5nRmlsZVdpemFyZE5hbWUiCi0JCQlpY29uPSJwbGF0Zm9ybTovcGx1Z2luL29yZy5lY2xpcHNlLmpwdC51aS9pY29ucy9mdWxsL2V0b29sMTYvbmV3X2pwYV9maWxlX3dpei5naWYiCi0JCQljYXRlZ29yeT0ib3JnLmVjbGlwc2UuanB0L29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluayI+Ci0JCQk8ZGVzY3JpcHRpb24+JW5ld0VjbGlwc2VMaW5rSnBhTWFwcGluZ0ZpbGVXaXphcmREZXNjPC9kZXNjcmlwdGlvbj4KLQkJCTxjbGFzcyBjbGFzcz0ib3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLndpemFyZHMuRWNsaXBzZUxpbmtNYXBwaW5nRmlsZVdpemFyZCI+IAotCQkJCTxwYXJhbWV0ZXIgbmFtZT0iamF2YWVlYXJ0aWZhY3QiIHZhbHVlPSJ0cnVlIi8+IAotCQkJCTxwYXJhbWV0ZXIgbmFtZT0ibWVudUluZGV4IiB2YWx1ZT0iNDAiIC8+IAotCQkJCTxwYXJhbWV0ZXIgbmFtZT0ianB0YXJ0aWZhY3QiIHZhbHVlPSJ0cnVlIi8+IAotCQkJPC9jbGFzcz4gCi0JCTwvd2l6YXJkPgotICA8d2l6YXJkCi0gICAgICAgIGNhdGVnb3J5PSJvcmcuZWNsaXBzZS5qcHQvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rIgotICAgICAgICBpY29uPSJwbGF0Zm9ybTovcGx1Z2luL29yZy5lY2xpcHNlLmpwdC51aS9pY29ucy9mdWxsL2V0b29sMTYvbmV3X2pwYV9maWxlX3dpei5naWYiCi0gICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkud2l6YXJkLm5ld0VjbGlwc2VMaW5rMV8xTWFwcGluZ0ZpbGUiCi0gICAgICAgIG5hbWU9IiVuZXdFY2xpcHNlTGluazFfMU1hcHBpbmdGaWxlV2l6YXJkTmFtZSI+Ci0gICAgIDxkZXNjcmlwdGlvbj4KLSAgICAgICAgJW5ld0VjbGlwc2VMaW5rMV8xSnBhTWFwcGluZ0ZpbGVXaXphcmREZXNjCi0gICAgIDwvZGVzY3JpcHRpb24+Ci0gICAgIDxjbGFzcwotICAgICAgICAgICBjbGFzcz0ib3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLndpemFyZHMuRWNsaXBzZUxpbmsxXzFNYXBwaW5nRmlsZVdpemFyZCI+Ci0gICAgICAgIDxwYXJhbWV0ZXIKLSAgICAgICAgICAgICAgbmFtZT0iamF2YWVlYXJ0aWZhY3QiCi0gICAgICAgICAgICAgIHZhbHVlPSJ0cnVlIj4KLSAgICAgICAgPC9wYXJhbWV0ZXI+Ci0gICAgICAgIDxwYXJhbWV0ZXIKLSAgICAgICAgICAgICAgbmFtZT0ibWVudUluZGV4IgotICAgICAgICAgICAgICB2YWx1ZT0iNDAiPgotICAgICAgICA8L3BhcmFtZXRlcj4KLSAgICAgICAgPHBhcmFtZXRlcgotICAgICAgICAgICAgICBuYW1lPSJqcHRhcnRpZmFjdCIKLSAgICAgICAgICAgICAgdmFsdWU9InRydWUiPgotICAgICAgICA8L3BhcmFtZXRlcj4KLSAgICAgPC9jbGFzcz4KLSAgPC93aXphcmQ+Ci0gICAgICAKLQk8L2V4dGVuc2lvbj4KLQotCi0JPGV4dGVuc2lvbgotCQlwb2ludD0ib3JnLmVjbGlwc2UudWkubmF2aWdhdG9yLm5hdmlnYXRvckNvbnRlbnQiPgotCQkKLQkJPGNvbW1vbldpemFyZAotCQkJbWVudUdyb3VwSWQ9Im9yZy5lY2xpcHNlLmpwdC51aSIKLQkJCXR5cGU9Im5ldyIKLQkJCXdpemFyZElkPSJvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkud2l6YXJkLm5ld0VjbGlwc2VMaW5rTWFwcGluZ0ZpbGUiPgotCQkJPGVuYWJsZW1lbnQ+Ci0JCQkJPGFuZD4KLQkJCQkJPG9yPgotCQkJCQkJPGluc3RhbmNlb2YgdmFsdWU9Im9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklQcm9qZWN0Ii8+Ci0gICAgICAgICAgICAgICAgICAgIAk8aW5zdGFuY2VvZiB2YWx1ZT0ib3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSUZvbGRlciIvPgotCQkJCQkJPGluc3RhbmNlb2YgdmFsdWU9Im9yZy5lY2xpcHNlLmpkdC5jb3JlLklQYWNrYWdlRnJhZ21lbnRSb290Ii8+Ci0JCQkJCQk8aW5zdGFuY2VvZiB2YWx1ZT0ib3JnLmVjbGlwc2UuamR0LmNvcmUuSVBhY2thZ2VGcmFnbWVudCIvPgotCQkJCQk8L29yPgotCQkJCQk8YWRhcHQgdHlwZT0ib3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVJlc291cmNlIj4KLQkJCQkJCTx0ZXN0IAotCQkJCQkJCWZvcmNlUGx1Z2luQWN0aXZhdGlvbj0idHJ1ZSIKLQkJCQkJCQlwcm9wZXJ0eT0ib3JnLmVjbGlwc2Uud3N0LmNvbW1vbi5wcm9qZWN0LmZhY2V0LmNvcmUucHJvamVjdEZhY2V0IgotCQkJCQkJCXZhbHVlPSJqcHQuanBhIiAvPgotCQkJCQk8L2FkYXB0PgotICAgICA8b3I+Ci0gICAgICAgIDx0ZXN0Ci0gICAgICAgICAgICAgIHByb3BlcnR5PSJvcmcuZWNsaXBzZS5qcHQuY29yZS5qcGFQbGF0Zm9ybSIKLSAgICAgICAgICAgICAgdmFsdWU9Im9yZy5lY2xpcHNlLmVjbGlwc2VsaW5rLnBsYXRmb3JtIj4KLSAgICAgICAgPC90ZXN0PgotICAgICAgICA8dGVzdAotICAgICAgICAgICAgICBwcm9wZXJ0eT0ib3JnLmVjbGlwc2UuanB0LmNvcmUuanBhUGxhdGZvcm0iCi0gICAgICAgICAgICAgIHZhbHVlPSJlY2xpcHNlbGluazFfMSI+Ci0gICAgICAgIDwvdGVzdD4KLSAgICAgPC9vcj4KLQkJCQk8L2FuZD4KLQkJCTwvZW5hYmxlbWVudD4KLQkJPC9jb21tb25XaXphcmQ+Ci0gIDxjb21tb25XaXphcmQKLSAgICAgICAgbWVudUdyb3VwSWQ9Im9yZy5lY2xpcHNlLmpwdC51aSIKLSAgICAgICAgdHlwZT0ibmV3IgotICAgICAgICB3aXphcmRJZD0ib3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLndpemFyZC5uZXdFY2xpcHNlTGluazFfMU1hcHBpbmdGaWxlIj4KLSAgICAgPGVuYWJsZW1lbnQ+Ci0gICAgICAgIDxhbmQ+Ci0gICAgICAgICAgIDxvcj4KLSAgICAgICAgICAgICAgPGluc3RhbmNlb2YKLSAgICAgICAgICAgICAgICAgICAgdmFsdWU9Im9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklQcm9qZWN0Ij4KLSAgICAgICAgICAgICAgPC9pbnN0YW5jZW9mPgotICAgICAgICAgICAgICA8aW5zdGFuY2VvZgotICAgICAgICAgICAgICAgICAgICB2YWx1ZT0ib3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSUZvbGRlciI+Ci0gICAgICAgICAgICAgIDwvaW5zdGFuY2VvZj4KLSAgICAgICAgICAgICAgPGluc3RhbmNlb2YKLSAgICAgICAgICAgICAgICAgICAgdmFsdWU9Im9yZy5lY2xpcHNlLmpkdC5jb3JlLklQYWNrYWdlRnJhZ21lbnRSb290Ij4KLSAgICAgICAgICAgICAgPC9pbnN0YW5jZW9mPgotICAgICAgICAgICAgICA8aW5zdGFuY2VvZgotICAgICAgICAgICAgICAgICAgICB2YWx1ZT0ib3JnLmVjbGlwc2UuamR0LmNvcmUuSVBhY2thZ2VGcmFnbWVudCI+Ci0gICAgICAgICAgICAgIDwvaW5zdGFuY2VvZj4KLSAgICAgICAgICAgPC9vcj4KLSAgICAgICAgICAgPGFkYXB0Ci0gICAgICAgICAgICAgICAgIHR5cGU9Im9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklSZXNvdXJjZSI+Ci0gICAgICAgICAgICAgIDx0ZXN0Ci0gICAgICAgICAgICAgICAgICAgIGZvcmNlUGx1Z2luQWN0aXZhdGlvbj0idHJ1ZSIKLSAgICAgICAgICAgICAgICAgICAgcHJvcGVydHk9Im9yZy5lY2xpcHNlLndzdC5jb21tb24ucHJvamVjdC5mYWNldC5jb3JlLnByb2plY3RGYWNldCIKLSAgICAgICAgICAgICAgICAgICAgdmFsdWU9ImpwdC5qcGEiPgotICAgICAgICAgICAgICA8L3Rlc3Q+Ci0gICAgICAgICAgIDwvYWRhcHQ+Ci0gICAgICAgICAgIDx0ZXN0Ci0gICAgICAgICAgICAgICAgIHByb3BlcnR5PSJvcmcuZWNsaXBzZS5qcHQuY29yZS5qcGFQbGF0Zm9ybSIKLSAgICAgICAgICAgICAgICAgdmFsdWU9ImVjbGlwc2VsaW5rMV8xIj4KLSAgICAgICAgICAgPC90ZXN0PgotICAgICAgICA8L2FuZD4KLSAgICAgPC9lbmFibGVtZW50PgotICA8L2NvbW1vbldpemFyZD4KLQkJCi0JPC9leHRlbnNpb24+Ci0JCi0JCi0JPGV4dGVuc2lvbgotCQlwb2ludD0ib3JnLmVjbGlwc2UudWkucGVyc3BlY3RpdmVFeHRlbnNpb25zIj4KLQkJCi0JCTxwZXJzcGVjdGl2ZUV4dGVuc2lvbgotCQkJdGFyZ2V0SUQ9Im9yZy5lY2xpcHNlLmpwdC51aS5qcGFQZXJzcGVjdGl2ZSI+Ci0JCQk8bmV3V2l6YXJkU2hvcnRjdXQKLQkJCQlpZD0ib3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLndpemFyZC5uZXdFY2xpcHNlTGlua01hcHBpbmdGaWxlIj4KLQkJCTwvbmV3V2l6YXJkU2hvcnRjdXQ+Ci0JCTwvcGVyc3BlY3RpdmVFeHRlbnNpb24+Ci0JCQotCTwvZXh0ZW5zaW9uPgotCQotPC9wbHVnaW4+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvcHJvcGVydHlfZmlsZXMvZWNsaXBzZWxpbmtfdWkucHJvcGVydGllcyBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9wcm9wZXJ0eV9maWxlcy9lY2xpcHNlbGlua191aS5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjZDJhOTg0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9wcm9wZXJ0eV9maWxlcy9lY2xpcHNlbGlua191aS5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMzM0ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0jIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotIyB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotIyBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotCi1NYXBwaW5nRmlsZVdpemFyZF90aXRsZT1OZXcgRWNsaXBzZUxpbmsgTWFwcGluZyBGaWxlCi1NYXBwaW5nRmlsZVdpemFyZFBhZ2VfdGl0bGU9RWNsaXBzZUxpbmsgbWFwcGluZyBmaWxlCi1NYXBwaW5nRmlsZVdpemFyZFBhZ2VfZGVzYz1TcGVjaWZ5IEVjbGlwc2VMaW5rIG1hcHBpbmcgZmlsZSBsb2NhdGlvbiBhbmQgcHJvcGVydGllcwotCi1FY2xpcHNlTGluazFfMU1hcHBpbmdGaWxlV2l6YXJkX3RpdGxlPU5ldyBFY2xpcHNlTGluayAxLjEgTWFwcGluZyBGaWxlCi1FY2xpcHNlTGluazFfMU1hcHBpbmdGaWxlV2l6YXJkUGFnZV90aXRsZT1FY2xpcHNlTGluayAxLjEgbWFwcGluZyBmaWxlCi1FY2xpcHNlTGluazFfMU1hcHBpbmdGaWxlV2l6YXJkUGFnZV9kZXNjPVNwZWNpZnkgRWNsaXBzZUxpbmsgMS4xIG1hcHBpbmcgZmlsZSBsb2NhdGlvbiBhbmQgcHJvcGVydGllcwotCi1Cb29sZWFuX1RydWUgPSBUcnVlCi1Cb29sZWFuX0ZhbHNlID0gRmFsc2UKLQotRGVmYXVsdFdpdGhvdXRWYWx1ZT1EZWZhdWx0ICgpCi1EZWZhdWx0V2l0aFZhbHVlPURlZmF1bHQgKHswfSkKLQkKLVBlcnNpc3RlbmNlWG1sVGFiRm9sZGVyX2RlZmF1bHRFbXB0eSA9IERlZmF1bHQgKCkKLVBlcnNpc3RlbmNlWG1sVGFiRm9sZGVyX2RlZmF1bHRXaXRoT25lUGFyYW0gPSBEZWZhdWx0ICh7MH0pCi0KLVBlcnNpc3RlbmNlWG1sR2VuZXJhbFRhYl9uYW1lID0gTmFtZToKLVBlcnNpc3RlbmNlWG1sR2VuZXJhbFRhYl9wcm92aWRlciA9IFByb3ZpZGVyOgotUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX2Jyb3dzZSA9IEJyb3dzZS4uLgotUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX2Rlc2NyaXB0aW9uID0gRGVzY3JpcHRpb246Ci0KLSMgR2VuZXJhbAotUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX3RpdGxlID0gR2VuZXJhbAotUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX2dlbmVyYWxTZWN0aW9uVGl0bGUgPSBHZW5lcmFsCi1QZXJzaXN0ZW5jZVhtbEdlbmVyYWxUYWJfbWFwcGVkQ2xhc3Nlc1NlY3Rpb25UaXRsZSA9IE1hbmFnZWQgQ2xhc3NlcwotUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX21hcHBlZENsYXNzZXNTZWN0aW9uRGVzY3JpcHRpb249U3BlY2lmeSB0aGUgbGlzdCBvZiBjbGFzc2VzIHRvIGJlIG1hbmFnZWQgaW4gdGhpcyBwZXJzaXN0ZW5jZSB1bml0LgotUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX3htbE1hcHBpbmdGaWxlc1NlY3Rpb25UaXRsZSA9IFhNTCBNYXBwaW5nIEZpbGVzCi1QZXJzaXN0ZW5jZVhtbEdlbmVyYWxUYWJfeG1sTWFwcGluZ0ZpbGVzU2VjdGlvbkRlc2NyaXB0aW9uPVNwZWNpZnkgdGhlIFhNTCBtYXBwaW5nIGZpbGVzIGZvciB0aGlzIHBlcnNpc3RlbmNlIHVuaXQuCi0KLVBlcnNpc3RlbmNlWG1sR2VuZXJhbFRhYl9uYW1lTGFiZWwgPSBOYW1lOgotUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX3BlcnNpc3RlbmNlUHJvdmlkZXJMYWJlbCA9IFBlcnNpc3RlbmNlIFByb3ZpZGVyOgotUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX2Rlc2NyaXB0aW9uTGFiZWwgPSBEZXNjcmlwdGlvbjoKLQotUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX2V4Y2x1ZGVVbmxpc3RlZE1hcHBlZENsYXNzZXM9RXhjbHVkZSB1bmxpc3RlZCBjbGFzc2VzCi1QZXJzaXN0ZW5jZVhtbEdlbmVyYWxUYWJfZXhjbHVkZVVubGlzdGVkTWFwcGVkQ2xhc3Nlc1dpdGhEZWZhdWx0PUV4Y2x1ZGUgdW5saXN0ZWQgY2xhc3NlcyAoezB9KQotUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX21hcHBlZENsYXNzZXNOb05hbWU9PG5hbWUgbm90IHNldD4KLVBlcnNpc3RlbmNlWG1sR2VuZXJhbFRhYl9vcGVuPU9wZW4KLQotUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX3htbE1hcHBpbmdGaWxlc0RpYWxvZ190aXRsZT1KUEEgWE1MIE1hcHBpbmcgRmlsZSBTZWxlY3Rpb24KLVBlcnNpc3RlbmNlWG1sR2VuZXJhbFRhYl94bWxNYXBwaW5nRmlsZXNEaWFsb2dfbWVzc2FnZT1DaG9vc2UgdGhlIFhNTCBtYXBwaW5nIGZpbGVzIHRvIGJlIGFkZGVkIHRvIHRoZSBwZXJzaXN0ZW5jZSB1bml0LgotUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX29ybU5vTmFtZT08bmFtZSBub3Qgc2V0PgotUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX2V4Y2x1ZGVFY2xpcHNlbGlua09ybT1FeGNsdWRlIHVubGlzdGVkIEVjbGlwc2VMaW5rIFhNTCBtYXBwaW5nIGZpbGUKLVBlcnNpc3RlbmNlWG1sR2VuZXJhbFRhYl9leGNsdWRlRWNsaXBzZWxpbmtPcm1XaXRoRGVmYXVsdD1FeGNsdWRlIHVubGlzdGVkIEVjbGlwc2VMaW5rIFhNTCBtYXBwaW5nIGZpbGUgKHswfSkKLQotIyBDb25uZWN0aW9uCi1QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfdGl0bGUgPSBDb25uZWN0aW9uCi1QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfc2VjdGlvblRpdGxlID0gUGVyc2lzdGVuY2UgVW5pdCBDb25uZWN0aW9uCi1QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfc2VjdGlvbkRlc2NyaXB0aW9uID0gQ29uZmlndXJlIHRoZSBkYXRhIHNvdXJjZSBvciBKREJDIGNvbm5lY3Rpb24gcHJvcGVydGllcy4KLVBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9kZWZhdWx0V2l0aE9uZVBhcmFtID0gRGVmYXVsdCAoezB9KQotUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX2RlZmF1bHRFbXB0eSA9IERlZmF1bHQgKCkKLQotUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3RyYW5zYWN0aW9uVHlwZUxhYmVsID0gVHJhbnNhY3Rpb24gdHlwZToKLQotVHJhbnNhY3Rpb25UeXBlQ29tcG9zaXRlX2p0YSA9IEpUQQotVHJhbnNhY3Rpb25UeXBlQ29tcG9zaXRlX3Jlc291cmNlX2xvY2FsID0gUmVzb3VyY2UgTG9jYWwKLQotUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX25hdGl2ZVNxbExhYmVsID0gTmF0aXZlIFNRTAotUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX25hdGl2ZVNxbExhYmVsRGVmYXVsdCA9IE5hdGl2ZSBTUUwgKHswfSkKLQotUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX2JhdGNoV3JpdGluZ0xhYmVsID0gQmF0Y2ggd3JpdGluZzoKLQotQmF0Y2hXcml0aW5nQ29tcG9zaXRlX25vbmUgPSBOb25lCi1CYXRjaFdyaXRpbmdDb21wb3NpdGVfamRiYyA9IEpEQkMKLUJhdGNoV3JpdGluZ0NvbXBvc2l0ZV9idWZmZXJlZCA9IEJ1ZmZlcmVkCi1CYXRjaFdyaXRpbmdDb21wb3NpdGVfb3JhY2xlX2pkYmMgPSBPcmFjbGUgSkRCQwotCi1QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfY2FjaGVTdGF0ZW1lbnRzTGFiZWwgPSBTdGF0ZW1lbnQgY2FjaGluZzoKLQotUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX2p0YURhdGFTb3VyY2VMYWJlbCA9IEpUQSBkYXRhIHNvdXJjZToKLVBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9ub25KdGFEYXRhU291cmNlTGFiZWwgPSBOb24tSlRBIGRhdGEgc291cmNlOgotCi1QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfZHJpdmVyTGFiZWwgPSBEcml2ZXI6Ci1QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfdXJsTGFiZWwgPSBVUkw6Ci1QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfdXNlckxhYmVsID0gVXNlcjoKLVBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9wYXNzd29yZExhYmVsID0gUGFzc3dvcmQ6Ci1QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfYmluZFBhcmFtZXRlcnNMYWJlbCA9IEJpbmQgcGFyYW1ldGVycwotUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX2JpbmRQYXJhbWV0ZXJzTGFiZWxEZWZhdWx0ID0gQmluZCBwYXJhbWV0ZXJzICh7MH0pCi0KLVBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9yZWFkQ29ubmVjdGlvbnNTaGFyZWRMYWJlbCA9IFNoYXJlZAotUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3JlYWRDb25uZWN0aW9uc1NoYXJlZExhYmVsRGVmYXVsdCA9IFNoYXJlZCAoezB9KQotUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3JlYWRDb25uZWN0aW9uc1NlY3Rpb25UaXRsZSA9IFJlYWQgQ29ubmVjdGlvbgotUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3JlYWRDb25uZWN0aW9uc01pbkxhYmVsID0gTWluaW11bToKLVBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9yZWFkQ29ubmVjdGlvbnNNYXhMYWJlbCA9IE1heGltdW06Ci1QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfd3JpdGVDb25uZWN0aW9uc1NlY3Rpb25UaXRsZSA9IFdyaXRlIENvbm5lY3Rpb24KLVBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl93cml0ZUNvbm5lY3Rpb25zTWluTGFiZWwgPSBNaW5pbXVtOgotUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3dyaXRlQ29ubmVjdGlvbnNNYXhMYWJlbCA9IE1heGltdW06Ci0KLUNvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlX0RhdGFiYXNlX0dyb3VwQm94PURhdGFiYXNlCi0KLUpkYmNQcm9wZXJ0aWVzQ29tcG9zaXRlX0VjbGlwc2VMaW5rQ29ubmVjdGlvblBvb2xfR3JvdXBCb3g9RWNsaXBzZUxpbmsgQ29ubmVjdGlvbiBQb29sCi0KLUpkYmNDb25uZWN0aW9uUHJvcGVydGllc0NvbXBvc2l0ZV9Db25uZWN0aW9uRGlhbG9nX01lc3NhZ2U9JkVudGVyIGNvbm5lY3Rpb24gbmFtZSBvciBwYXR0ZXJuICgqLCA/LCBvciBjYW1lbCBjYXNlKToKLUpkYmNDb25uZWN0aW9uUHJvcGVydGllc0NvbXBvc2l0ZV9Db25uZWN0aW9uRGlhbG9nX1RpdGxlPUNvbm5lY3Rpb24gU2VsZWN0aW9uCi0KLSMgU2NoZW1hR2VuZXJhdGlvbgotUGVyc2lzdGVuY2VYbWxTY2hlbWFHZW5lcmF0aW9uVGFiX3RpdGxlID0gU2NoZW1hIEdlbmVyYXRpb24KLVBlcnNpc3RlbmNlWG1sU2NoZW1hR2VuZXJhdGlvblRhYl9zZWN0aW9uVGl0bGUgPSBQZXJzaXN0ZW5jZSBVbml0IFNjaGVtYSBHZW5lcmF0aW9uCi1QZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWJfc2VjdGlvbkRlc2NyaXB0aW9uID0gQ29uZmlndXJlIHRoZSBFY2xpcHNlTGluayBzY2hlbWEgZ2VuZXJhdGlvbiBwcm9wZXJ0aWVzLgotUGVyc2lzdGVuY2VYbWxTY2hlbWFHZW5lcmF0aW9uVGFiX2RlZmF1bHRXaXRoT25lUGFyYW0gPSBEZWZhdWx0ICh7MH0pCi1QZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWJfZGVmYXVsdEVtcHR5ID0gRGVmYXVsdCAoKQotCi1QZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWJfZGRsR2VuZXJhdGlvblR5cGVMYWJlbCA9IERETCBnZW5lcmF0aW9uIHR5cGU6Ci1QZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWJfb3V0cHV0TW9kZUxhYmVsID0gT3V0cHV0IG1vZGU6Ci1QZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWJfY3JlYXRlRGRsRmlsZU5hbWVMYWJlbCA9IENyZWF0ZSBEREwgZmlsZSBuYW1lOgotUGVyc2lzdGVuY2VYbWxTY2hlbWFHZW5lcmF0aW9uVGFiX2Ryb3BEZGxGaWxlTmFtZUxhYmVsID0gRHJvcCBEREwgZmlsZSBuYW1lOgotCi1PdXRwdXRNb2RlQ29tcG9zaXRlX2JvdGggPSBCb3RoCi1PdXRwdXRNb2RlQ29tcG9zaXRlX3NxbF9zY3JpcHQgPSBTcWwtc2NyaXB0Ci1PdXRwdXRNb2RlQ29tcG9zaXRlX2RhdGFiYXNlID0gRGF0YWJhc2UKLQotRGRsR2VuZXJhdGlvblR5cGVDb21wb3NpdGVfbm9uZSA9IE5vbmUKLURkbEdlbmVyYXRpb25UeXBlQ29tcG9zaXRlX2NyZWF0ZV90YWJsZXMgPSBDcmVhdGUgVGFibGVzCi1EZGxHZW5lcmF0aW9uVHlwZUNvbXBvc2l0ZV9kcm9wX2FuZF9jcmVhdGVfdGFibGVzID0gRHJvcCBhbmQgQ3JlYXRlIFRhYmxlcwotCi1QZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWJfZGRsR2VuZXJhdGlvbkxvY2F0aW9uTGFiZWwgPSBEREwgZ2VuZXJhdGlvbiBsb2NhdGlvbjoKLQkKLURkbEdlbmVyYXRpb25Mb2NhdGlvbkNvbXBvc2l0ZV9kaWFsb2dUaXRsZSA9IEdlbmVyYXRpb24gTG9jYXRpb24KLURkbEdlbmVyYXRpb25Mb2NhdGlvbkNvbXBvc2l0ZV9kaWFsb2dNZXNzYWdlID0gQ2hvb3NlIGEgZm9sZGVyIGZvciB0aGUgZ2VuZXJhdGVkIERETCBmaWxlczoKLQotIyBDYWNoaW5nCi1QZXJzaXN0ZW5jZVhtbENhY2hpbmdUYWJfdGl0bGUgPSBDYWNoaW5nCi1QZXJzaXN0ZW5jZVhtbENhY2hpbmdUYWJfc2VjdGlvblRpdGxlID0gUGVyc2lzdGVuY2UgVW5pdCBDYWNoaW5nCi1QZXJzaXN0ZW5jZVhtbENhY2hpbmdUYWJfc2VjdGlvbkRlc2NyaXB0aW9uID0gQ29uZmlndXJlIHRoZSBzZXNzaW9uIG9yIGVudGl0eSBzcGVjaWZpYyBFY2xpcHNlTGluayBjYWNoaW5nIHByb3BlcnRpZXMuCi0KLVBlcnNpc3RlbmNlWG1sQ2FjaGluZ1RhYl9kZWZhdWx0Q2FjaGVUeXBlTGFiZWwgPSBEZWZhdWx0IGNhY2hlIHR5cGU6Ci1QZXJzaXN0ZW5jZVhtbENhY2hpbmdUYWJfY2FjaGVUeXBlTGFiZWwgPSBDYWNoZSB0eXBlOgotCi1QZXJzaXN0ZW5jZVhtbENhY2hpbmdUYWJfZGVmYXVsdFNoYXJlZENhY2hlTGFiZWwgPSBTaGFyZWQgY2FjaGUgKHswfSkKLVBlcnNpc3RlbmNlWG1sQ2FjaGluZ1RhYl9zaGFyZWRDYWNoZUxhYmVsID0gU2hhcmVkIGNhY2hlCi0KLVBlcnNpc3RlbmNlWG1sQ2FjaGluZ1RhYl9kZWZhdWx0U2hhcmVkQ2FjaGVEZWZhdWx0TGFiZWwgPSBEZWZhdWx0IHNoYXJlZCBjYWNoZSAoezB9KQotUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiX3NoYXJlZENhY2hlRGVmYXVsdExhYmVsID0gRGVmYXVsdCBzaGFyZWQgY2FjaGUKLQotQ2FjaGVTaXplQ29tcG9zaXRlX2NhY2hlU2l6ZT1DYWNoZSBzaXplOgotCi1DYWNoZVR5cGVDb21wb3NpdGVfZnVsbCA9IEZ1bGwKLUNhY2hlVHlwZUNvbXBvc2l0ZV9oYXJkX3dlYWsgPSBXZWFrIHdpdGggSGFyZCBTdWJjYWNoZQotQ2FjaGVUeXBlQ29tcG9zaXRlX25vbmUgPSBOb25lCi1DYWNoZVR5cGVDb21wb3NpdGVfc29mdCA9IFNvZnQKLUNhY2hlVHlwZUNvbXBvc2l0ZV9zb2Z0X3dlYWsgPSBXZWFrIHdpdGggU29mdCBTdWJjYWNoZQotQ2FjaGVUeXBlQ29tcG9zaXRlX3dlYWsgPSBXZWFrCi0KLURlZmF1bHRDYWNoZVNpemVDb21wb3NpdGVfZGVmYXVsdENhY2hlU2l6ZT1EZWZhdWx0IGNhY2hlIHNpemU6Ci0KLURlZmF1bHRDYWNoZVR5cGVDb21wb3NpdGVfZnVsbCA9IEZ1bGwKLURlZmF1bHRDYWNoZVR5cGVDb21wb3NpdGVfaGFyZF93ZWFrID0gV2VhayBXaXRoIEhhcmQgU3ViY2FjaGUKLURlZmF1bHRDYWNoZVR5cGVDb21wb3NpdGVfbm9uZSA9IE5vbmUKLURlZmF1bHRDYWNoZVR5cGVDb21wb3NpdGVfc29mdCA9IFNvZnQKLURlZmF1bHRDYWNoZVR5cGVDb21wb3NpdGVfc29mdF93ZWFrID0gV2VhayB3aXRoIFNvZnQgU3ViY2FjaGUKLURlZmF1bHRDYWNoZVR5cGVDb21wb3NpdGVfd2VhayA9IFdlYWsKLQotRW50aXR5RGlhbG9nX3NlbGVjdEVudGl0eSA9IFNlbGVjdCBhbiBFbnRpdHkKLUVudGl0eURpYWxvZ19uYW1lID0gTmFtZToKLQotQ2FjaGluZ0VudGl0eUxpc3RDb21wb3NpdGVfZ3JvdXBUaXRsZSA9IEVudGl0eSBjYWNoaW5nCi1DYWNoaW5nRW50aXR5TGlzdENvbXBvc2l0ZV9lZGl0QnV0dG9uID0gRWRpdC4uLgotCi1DYWNoaW5nRW50aXR5TGlzdENvbXBvc2l0ZV9kaWFsb2dNZXNzYWdlPSZFbnRlciB0eXBlIG5hbWUgcHJlZml4IG9yIHBhdHRlcm4gKCosID8sIG9yIGNhbWVsIGNhc2UpOgotQ2FjaGluZ0VudGl0eUxpc3RDb21wb3NpdGVfZGlhbG9nVGl0bGU9RW50aXR5IFNlbGVjdGlvbgotCi1QZXJzaXN0ZW5jZVhtbENhY2hpbmdUYWJfRmx1c2hDbGVhckNhY2hlTGFiZWwgPSBGbHVzaCBjbGVhciBjYWNoZToKLQotRmx1c2hDbGVhckNhY2hlQ29tcG9zaXRlX2Ryb3AgPSBEcm9wCi1GbHVzaENsZWFyQ2FjaGVDb21wb3NpdGVfZHJvcF9pbnZhbGlkYXRlID0gRHJvcCBJbnZhbGlkYXRlCi1GbHVzaENsZWFyQ2FjaGVDb21wb3NpdGVfbWVyZ2UgPSBNZXJnZQotCi0jIEN1c3RvbWl6YXRpb24KLVBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl90aXRsZSA9IEN1c3RvbWl6YXRpb24KLVBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl9zZWN0aW9uVGl0bGUgPSBQZXJzaXN0ZW5jZSBVbml0IEN1c3RvbWl6YXRpb24KLVBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl9zZWN0aW9uRGVzY3JpcHRpb24gPSBTZXQgZGVmYXVsdCBvciBlbnRpdHkgc3BlY2lmaWMgRWNsaXBzZUxpbmsgY3VzdG9taXphdGlvbiBhbmQgdmFsaWRhdGlvbiBwcm9wZXJ0aWVzLgotUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX2RlZmF1bHRXaXRoT25lUGFyYW0gPSBEZWZhdWx0ICh7MH0pCi1QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfZGVmYXVsdEVtcHR5ID0gRGVmYXVsdCAoKQotCi1QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0xhYmVsID0gV2VhdmluZzoKLQotUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3dlYXZpbmdMYXp5TGFiZWxEZWZhdWx0ID0gV2VhdmluZyBsYXp5ICh7MH0pCi1QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0xhenlMYWJlbCA9IFdlYXZpbmcgbGF6eQotCQotUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3dlYXZpbmdDaGFuZ2VUcmFja2luZ0xhYmVsRGVmYXVsdCA9IFdlYXZpbmcgY2hhbmdlIHRyYWNraW5nICh7MH0pCi1QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0NoYW5nZVRyYWNraW5nTGFiZWwgPSBXZWF2aW5nIGNoYW5nZSB0cmFja2luZwotCi1QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0ZldGNoR3JvdXBzTGFiZWxEZWZhdWx0ID0gV2VhdmluZyBmZXRjaCBncm91cHMgKHswfSkKLVBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl93ZWF2aW5nRmV0Y2hHcm91cHNMYWJlbCA9IFdlYXZpbmcgZmV0Y2ggZ3JvdXBzCi0KLVBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl93ZWF2aW5nSW50ZXJuYWxMYWJlbCA9IFdlYXZpbmcgaW50ZXJuYWwKLVBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl93ZWF2aW5nSW50ZXJuYWxMYWJlbERlZmF1bHQgPSBXZWF2aW5nIGludGVybmFsICh7MH0pCi0KLVBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl93ZWF2aW5nRWFnZXJMYWJlbCA9IFdlYXZpbmcgZWFnZXIKLVBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl93ZWF2aW5nRWFnZXJMYWJlbERlZmF1bHQgPSBXZWF2aW5nIGVhZ2VyICh7MH0pCi0KLVBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl90aHJvd0V4Y2VwdGlvbnNMYWJlbERlZmF1bHQgPSBUaHJvdyBleGNlcHRpb25zICh7MH0pCi1QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfdGhyb3dFeGNlcHRpb25zTGFiZWwgPSBUaHJvdyBleGNlcHRpb25zCi0KLVBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl9leGNlcHRpb25IYW5kbGVyTGFiZWwgPSBFeGNlcHRpb24gaGFuZGxlcjoKLQotV2VhdmluZ0NvbXBvc2l0ZV90cnVlXyA9IFdlYXZlIER5bmFtaWNhbGx5Ci1XZWF2aW5nQ29tcG9zaXRlX2ZhbHNlXyA9IE5vIFdlYXZpbmcKLVdlYXZpbmdDb21wb3NpdGVfc3RhdGljXyA9IFdlYXZlIFN0YXRpY2FsbHkKLQotQ3VzdG9taXphdGlvbkVudGl0eUxpc3RDb21wb3NpdGVfZ3JvdXBUaXRsZSA9IERlc2NyaXB0b3IgY3VzdG9taXplcnMKLUN1c3RvbWl6YXRpb25FbnRpdHlMaXN0Q29tcG9zaXRlX2VkaXRCdXR0b24gPSBFZGl0Li4uCi0KLUN1c3RvbWl6YXRpb25FbnRpdHlMaXN0Q29tcG9zaXRlX2RpYWxvZ01lc3NhZ2U9JkVudGVyIHR5cGUgbmFtZSBwcmVmaXggb3IgcGF0dGVybiAoKiwgPywgb3IgY2FtZWwgY2FzZSk6Ci1DdXN0b21pemF0aW9uRW50aXR5TGlzdENvbXBvc2l0ZV9kaWFsb2dUaXRsZT1FbnRpdHkgU2VsZWN0aW9uCi0KLVBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl9jdXN0b21pemVyTGFiZWwgPSBDdXN0b21pemVyOgotUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3Nlc3Npb25DdXN0b21pemVyTGFiZWwgPSBTZXNzaW9uIGN1c3RvbWl6ZXJzCi0KLVBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl9ub05hbWU9PG5hbWUgbm90IHNldD4KLQotUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3ZhbGlkYXRpb25Pbmx5TGFiZWwgPSBWYWxpZGF0aW9uIG9ubHkKLVBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl92YWxpZGF0aW9uT25seUxhYmVsRGVmYXVsdCA9IFZhbGlkYXRpb24gb25seSAoezB9KQotCi1QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfcHJvZmlsZXJMYWJlbCA9IFByb2ZpbGVyOgotUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX2Jyb3dzZSA9IEJyb3dzZS4uLgotCi1Qcm9maWxlckNvbXBvc2l0ZV9wZXJmb3JtYW5jZV9wcm9maWxlciA9IFBlcmZvcm1hbmNlIFByb2ZpbGVyCi1Qcm9maWxlckNvbXBvc2l0ZV9xdWVyeV9tb25pdG9yID0gUXVlcnkgTW9uaXRvciAKLVByb2ZpbGVyQ29tcG9zaXRlX25vX3Byb2ZpbGVyID0gTm8gUHJvZmlsZXIKLQotIyBMb2dnaW5nCi1QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfdGl0bGUgPSBMb2dnaW5nCi1QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfc2VjdGlvblRpdGxlID0gUGVyc2lzdGVuY2UgVW5pdCBMb2dnaW5nCi1QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfc2VjdGlvbkRlc2NyaXB0aW9uID0gQ29uZmlndXJlIHRoZSBFY2xpcHNlTGluayBsb2dnaW5nIHByb3BlcnRpZXMuCi1QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfZGVmYXVsdFdpdGhPbmVQYXJhbSA9IERlZmF1bHQgKHswfSkKLVBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl9kZWZhdWx0RW1wdHkgPSBEZWZhdWx0ICgpCi0KLVBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl9sb2dnaW5nTGV2ZWxMYWJlbCA9IExvZ2dpbmcgbGV2ZWw6Ci0KLUxvZ2dpbmdMZXZlbENvbXBvc2l0ZV9vZmYgPSBPZmYKLUxvZ2dpbmdMZXZlbENvbXBvc2l0ZV9zZXZlcmUgPSBTZXZlcmUKLUxvZ2dpbmdMZXZlbENvbXBvc2l0ZV93YXJuaW5nID0gV2FybmluZwotTG9nZ2luZ0xldmVsQ29tcG9zaXRlX2luZm8gPSBJbmZvCi1Mb2dnaW5nTGV2ZWxDb21wb3NpdGVfY29uZmlnID0gQ29uZmlnCi1Mb2dnaW5nTGV2ZWxDb21wb3NpdGVfZmluZSA9IEZpbmUKLUxvZ2dpbmdMZXZlbENvbXBvc2l0ZV9maW5lciA9IEZpbmVyCi1Mb2dnaW5nTGV2ZWxDb21wb3NpdGVfZmluZXN0ID0gRmluZXN0Ci1Mb2dnaW5nTGV2ZWxDb21wb3NpdGVfYWxsID0gQWxsCi0KLVBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl9sb2dnZXJMYWJlbCA9IExvZ2dlcjoKLVBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl9icm93c2UgPSBCcm93c2UuLi4KLUxvZ2dlckNvbXBvc2l0ZV9kZWZhdWx0X2xvZ2dlciA9IERlZmF1bHQgTG9nZ2VyCi1Mb2dnZXJDb21wb3NpdGVfamF2YV9sb2dnZXIgPSBKYXZhIExvZ2dlcgotTG9nZ2VyQ29tcG9zaXRlX3NlcnZlcl9sb2dnZXIgPSBTZXJ2ZXIgTG9nZ2VyCi0KLVBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl90aW1lc3RhbXBMYWJlbCA9IFRpbWVzdGFtcAotUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiX3RpbWVzdGFtcExhYmVsRGVmYXVsdCA9IFRpbWVzdGFtcCAoezB9KQotUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiX3RocmVhZExhYmVsID0gVGhyZWFkCi1QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfdGhyZWFkTGFiZWxEZWZhdWx0ID0gVGhyZWFkICh7MH0pCi1QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfc2Vzc2lvbkxhYmVsID0gU2Vzc2lvbgotUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiX3Nlc3Npb25MYWJlbERlZmF1bHQgPSBTZXNzaW9uICh7MH0pCi1QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfZXhjZXB0aW9uc0xhYmVsID0gRXhjZXB0aW9ucwotUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiX2V4Y2VwdGlvbnNMYWJlbERlZmF1bHQgPSBFeGNlcHRpb25zICh7MH0pCi0KLVBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl9sb2dnZXJzTGFiZWwgPSBMb2dnZXJzOgotCi1QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfbG9nZ2luZ0ZpbGVMYWJlbCA9IExvZyBmaWxlOgotCi1Mb2dnaW5nRmlsZUxvY2F0aW9uQ29tcG9zaXRlX2RpYWxvZ1RpdGxlID0gTG9nIEZpbGUgTG9jYXRpb24KLUxvZ2dpbmdGaWxlTG9jYXRpb25Db21wb3NpdGVfZGlhbG9nTWVzc2FnZSA9IENob29zZSBhIGZvbGRlciBmb3IgdGhlIGxvZyBmaWxlOgotCi0jIE9wdGlvbnMKLVBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl90aXRsZSA9IE9wdGlvbnMKLVBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl9zZXNzaW9uU2VjdGlvblRpdGxlID0gRWNsaXBzZUxpbmsgU2Vzc2lvbiBPcHRpb25zCi1QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfc2Vzc2lvblNlY3Rpb25EZXNjcmlwdGlvbiA9IENvbmZpZ3VyZSB0aGUgRWNsaXBzZUxpbmsgc2Vzc2lvbiBvcHRpb25zLgotUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX2RlZmF1bHRXaXRoT25lUGFyYW0gPSBEZWZhdWx0ICh7MH0pCi1QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfZGVmYXVsdEVtcHR5ID0gRGVmYXVsdCAoKQotCi1QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfc2Vzc2lvbk5hbWUgPSBTZXNzaW9uIG5hbWU6Ci1QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfc2Vzc2lvbnNYbWwgPSBTZXNzaW9ucyBYTUw6Ci0KLVBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl9pbmNsdWRlRGVzY3JpcHRvclF1ZXJpZXNMYWJlbCA9IEluY2x1ZGUgZGVzY3JpcHRvciBxdWVyaWVzCi1QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfaW5jbHVkZURlc2NyaXB0b3JRdWVyaWVzTGFiZWxEZWZhdWx0ID0gSW5jbHVkZSBkZXNjcmlwdG9yIHF1ZXJpZXMgKHswfSkKLQotUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX2V2ZW50TGlzdGVuZXJMYWJlbCA9IEV2ZW50IGxpc3RlbmVyOgotUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX3RhcmdldERhdGFiYXNlTGFiZWwgPSBUYXJnZXQgZGF0YWJhc2U6Ci0KLVBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl9taXNjZWxsYW5lb3VzU2VjdGlvblRpdGxlID0gTWlzY2VsbGFuZW91cyBPcHRpb25zCi1QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfbWlzY2VsbGFuZW91c1NlY3Rpb25EZXNjcmlwdGlvbiA9IENvbmZpZ3VyZSB0aGUgbWlzY2VsbGFuZW91cyBvcHRpb25zLgotCi1QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfdGVtcG9yYWxNdXRhYmxlTGFiZWwgPSBUZW1wb3JhbCBtdXRhYmxlCi1QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfdGVtcG9yYWxNdXRhYmxlTGFiZWxEZWZhdWx0ID0gVGVtcG9yYWwgbXV0YWJsZSAoezB9KQotCi1UYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9hdHR1bml0eSA9IEF0dHVuaXR5Ci1UYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9hdXRvID0gQXV0bwotVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGVfY2xvdWRzY2FwZSA9IENsb3Vkc2NhcGUKLVRhcmdldERhdGFiYXNlQ29tcG9zaXRlX2RhdGFiYXNlID0gRGF0YWJhc2UKLVRhcmdldERhdGFiYXNlQ29tcG9zaXRlX2RiMiA9IERCMgotVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGVfZGIybWFpbmZyYW1lID0gREIyTWFpbmZyYW1lCi1UYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9kYmFzZSA9IERCYXNlCi1UYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9kZXJieSA9IERlcmJ5Ci1UYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9oc3FsID0gSFNRTAotVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGVfaW5mb3JtaXggPSBJbmZvcm1peAotVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGVfamF2YWRiID0gSmF2YURCCi1UYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9teXNxbCA9IE15U1FMCi1UYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9vcmFjbGUgPSBPcmFjbGUKLVRhcmdldERhdGFiYXNlQ29tcG9zaXRlX29yYWNsZTExID0gT3JhY2xlMTEKLVRhcmdldERhdGFiYXNlQ29tcG9zaXRlX29yYWNsZTEwID0gT3JhY2xlMTBnCi1UYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9vcmFjbGU5ID0gT3JhY2xlOWkKLVRhcmdldERhdGFiYXNlQ29tcG9zaXRlX29yYWNsZTggPSBPcmFjbGU4aQotVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGVfcG9pbnRiYXNlID0gUG9pbnRCYXNlCi1UYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9wb3N0Z3Jlc3FsID0gUG9zdGdyZVNRTAotVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGVfc3FsYW55d2hlcmUgPSBTUUxBbnl3aGVyZQotVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGVfc3Fsc2VydmVyID0gU1FMU2VydmVyCi1UYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9zeWJhc2UgPSBTeWJhc2UKLVRhcmdldERhdGFiYXNlQ29tcG9zaXRlX3RpbWVzdGVuID0gVGltZXNUZW4KLQotUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX3RhcmdldFNlcnZlckxhYmVsID0gVGFyZ2V0IHNlcnZlcjoKLQotVGFyZ2V0U2VydmVyQ29tcG9zaXRlX25vbmUgPSBOb25lCi1UYXJnZXRTZXJ2ZXJDb21wb3NpdGVfb2M0aiA9IE9DNEoKLVRhcmdldFNlcnZlckNvbXBvc2l0ZV9zdW5hczkgPSBTdW5BUzkKLVRhcmdldFNlcnZlckNvbXBvc2l0ZV93ZWJzcGhlcmUgPSBXZWJTcGhlcmUKLVRhcmdldFNlcnZlckNvbXBvc2l0ZV93ZWJzcGhlcmVfNl8xID0gV2ViU3BoZXJlIDYuMQotVGFyZ2V0U2VydmVyQ29tcG9zaXRlX3dlYmxvZ2ljID0gV2ViTG9naWMKLVRhcmdldFNlcnZlckNvbXBvc2l0ZV93ZWJsb2dpY185ID0gV2ViTG9naWMgOQotVGFyZ2V0U2VydmVyQ29tcG9zaXRlX3dlYmxvZ2ljXzEwID0gV2ViTG9naWMgMTAKLVRhcmdldFNlcnZlckNvbXBvc2l0ZV9qYm9zcyA9IEpCb3NzCi0KLSMgRERMR2VuZXJhdGlvbgotRWNsaXBzZUxpbmtERExHZW5lcmF0b3JVaV9nZW5lcmF0aW5nRERMV2FybmluZ1RpdGxlID0gR2VuZXJhdGluZyBEREwKLUVjbGlwc2VMaW5rRERMR2VuZXJhdG9yVWlfZ2VuZXJhdGluZ0RETFdhcm5pbmdNZXNzYWdlID0gV2FybmluZzogIEdlbmVyYXRpbmcgRERMIHdpbGwgRFJPUCBleGlzdGluZyB0YWJsZXMgYW5kezB9Q1JFQVRFIG5ldyB0YWJsZXMgYmFzZWQgb24gdGhlIEVudGl0aWVzIGluIHlvdXIgcHJvamVjdC57MX1BcmUgeW91IHN1cmUgeW91IHdhbnQgdG8gY29udGludWU/Ci1FY2xpcHNlTGlua0RETEdlbmVyYXRvclVpX2Vycm9yID0gRXJyb3IKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9wcm9wZXJ0eV9maWxlcy9lY2xpcHNlbGlua191aV9tYXBwaW5ncy5wcm9wZXJ0aWVzIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3Byb3BlcnR5X2ZpbGVzL2VjbGlwc2VsaW5rX3VpX21hcHBpbmdzLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDkyZDFlNDcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3Byb3BlcnR5X2ZpbGVzL2VjbGlwc2VsaW5rX3VpX21hcHBpbmdzLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwxNTMgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSMgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0jIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0jIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0KLUJhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyX2xhYmVsID0gQmFzaWMgQ29sbGVjdGlvbgotQmFzaWNDb2xsZWN0aW9uTWFwcGluZ1VpUHJvdmlkZXJfbGlua0xhYmVsID0gYmFzaWMgY29sbGVjdGlvbgotCi1CYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyX2xhYmVsID0gQmFzaWMgTWFwCi1CYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyX2xpbmtMYWJlbCA9IGJhc2ljIG1hcAotCi1UcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyX2xhYmVsID0gVHJhbnNmb3JtYXRpb24KLVRyYW5zZm9ybWF0aW9uTWFwcGluZ1VpUHJvdmlkZXJfbGlua0xhYmVsID0gdHJhbnNmb3JtYXRpb24KLQotVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyX2xhYmVsID0gVmFyaWFibGUgT25lIHRvIE9uZQotVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyX2xpbmtMYWJlbCA9IHZhcmlhYmxlIG9uZSB0byBvbmUKLQotQ2FjaGVUeXBlQ29tcG9zaXRlX2xhYmVsID0gVHlwZToJCi1DYWNoZVR5cGVDb21wb3NpdGVfZnVsbCA9IEZ1bGwKLUNhY2hlVHlwZUNvbXBvc2l0ZV93ZWFrID0gV2VhawotQ2FjaGVUeXBlQ29tcG9zaXRlX3NvZnQgPSBTb2Z0Ci1DYWNoZVR5cGVDb21wb3NpdGVfc29mdF93ZWFrID0gV2VhayB3aXRoIFNvZnQgU3ViY2FjaGUKLUNhY2hlVHlwZUNvbXBvc2l0ZV9oYXJkX3dlYWsgPSBXZWFrIHdpdGggSGFyZCBTdWJjYWNoZQotQ2FjaGVUeXBlQ29tcG9zaXRlX2NhY2hlID0gQ2FjaGUKLUNhY2hlVHlwZUNvbXBvc2l0ZV9ub25lID0gIE5vbmUKLQotQ2FjaGVTaXplQ29tcG9zaXRlX3NpemUgPSBTaXplOgotCi1DYWNoZUNvb3JkaW5hdGlvblR5cGVDb21wb3NpdGVfbGFiZWwgPSBDb29yZGluYXRpb24gdHlwZToKLUNhY2hlQ29vcmRpbmF0aW9uVHlwZUNvbXBvc2l0ZV9zZW5kX29iamVjdF9jaGFuZ2VzID0gU2VuZCBPYmplY3QgQ2hhbmdlcwotQ2FjaGVDb29yZGluYXRpb25UeXBlQ29tcG9zaXRlX2ludmFsaWRhdGVfY2hhbmdlZF9vYmplY3RzID0gSW52YWxpZGF0ZSBDaGFuZ2VkIE9iamVjdHMKLUNhY2hlQ29vcmRpbmF0aW9uVHlwZUNvbXBvc2l0ZV9zZW5kX25ld19vYmplY3RzX3dpdGhfY2hhbmdlcyA9IFNlbmQgTmV3IE9iamVjdHMgd2l0aCBDaGFuZ2VzCi1DYWNoZUNvb3JkaW5hdGlvblR5cGVDb21wb3NpdGVfbm9uZSA9IE5vbmUKLQotQ2FjaGluZ0NvbXBvc2l0ZV9zaGFyZWRMYWJlbERlZmF1bHQgPSBTaGFyZWQgKHswfSkKLUNhY2hpbmdDb21wb3NpdGVfc2hhcmVkTGFiZWwgPSBTaGFyZWQKLUNhY2hpbmdDb21wb3NpdGVfYWR2YW5jZWQgPSBBZHZhbmNlZAotCi1DaGFuZ2VUcmFja2luZ0NvbXBvc2l0ZV9sYWJlbCA9IENoYW5nZSB0cmFja2luZzoKLUNoYW5nZVRyYWNraW5nQ29tcG9zaXRlX2F0dHJpYnV0ZSA9IEF0dHJpYnV0ZQotQ2hhbmdlVHJhY2tpbmdDb21wb3NpdGVfb2JqZWN0ID0gT2JqZWN0Ci1DaGFuZ2VUcmFja2luZ0NvbXBvc2l0ZV9kZWZlcnJlZCA9IERlZmVycmVkCi1DaGFuZ2VUcmFja2luZ0NvbXBvc2l0ZV9hdXRvID0gQXV0bwotCi1Db252ZXJ0Q29tcG9zaXRlX2NvbnZlcnRlck5hbWVMYWJlbCA9IENvbnZlcnRlciBuYW1lOgotQ29udmVydENvbXBvc2l0ZV9kZWZpbmVDb252ZXJ0ZXJTZWN0aW9uID0gRGVmaW5lIENvbnZlcnRlcgotQ29udmVydENvbXBvc2l0ZV9kZWZhdWx0ID0gRGVmYXVsdAotQ29udmVydENvbXBvc2l0ZV9jdXN0b20gPSBDdXN0b20KLUNvbnZlcnRDb21wb3NpdGVfdHlwZSA9IFR5cGUKLUNvbnZlcnRDb21wb3NpdGVfb2JqZWN0VHlwZSA9IE9iamVjdCB0eXBlCi1Db252ZXJ0Q29tcG9zaXRlX3N0cnVjdCA9IFN0cnVjdAotCi1Db252ZXJ0ZXJDb21wb3NpdGVfbmFtZVRleHRMYWJlbCA9IE5hbWU6Ci1Db252ZXJ0ZXJDb21wb3NpdGVfY2xhc3NMYWJlbCA9IENsYXNzOgotCi1DdXN0b21pemVyQ29tcG9zaXRlX2NsYXNzTGFiZWwgPSBDdXN0b21pemVyIGNsYXNzOgotCi1Db252ZXJ0ZXJzQ29tcG9zaXRlX2N1c3RvbUNvbnZlcnRlciA9IEN1c3RvbQotQ29udmVydGVyc0NvbXBvc2l0ZV9vYmplY3RUeXBlQ29udmVydGVyID0gT2JqZWN0IHR5cGUKLUNvbnZlcnRlcnNDb21wb3NpdGVfc3RydWN0Q29udmVydGVyID0gU3RydWN0Ci1Db252ZXJ0ZXJzQ29tcG9zaXRlX3R5cGVDb252ZXJ0ZXIgPSBUeXBlCi0KLUFsd2F5c1JlZnJlc2hDb21wb3NpdGVfYWx3YXlzUmVmcmVzaERlZmF1bHQgPSBBbHdheXMgcmVmcmVzaCAoezB9KQotQWx3YXlzUmVmcmVzaENvbXBvc2l0ZV9hbHdheXNSZWZyZXNoTGFiZWwgPSBBbHdheXMgcmVmcmVzaAotUmVmcmVzaE9ubHlJZk5ld2VyQ29tcG9zaXRlX3JlZnJlc2hPbmx5SWZOZXdlckRlZmF1bHQgPSBSZWZyZXNoIG9ubHkgaWYgbmV3ZXIgKHswfSkKLVJlZnJlc2hPbmx5SWZOZXdlckNvbXBvc2l0ZV9yZWZyZXNoT25seUlmTmV3ZXJMYWJlbCA9IFJlZnJlc2ggb25seSBpZiBuZXdlcgotRGlzYWJsZUhpdHNDb21wb3NpdGVfZGlzYWJsZUhpdHNEZWZhdWx0ID0gRGlzYWJsZSBoaXRzICh7MH0pCi1EaXNhYmxlSGl0c0NvbXBvc2l0ZV9kaXNhYmxlSGl0c0xhYmVsID0gRGlzYWJsZSBoaXRzCi0KLVR5cGVTZWN0aW9uX2NvbnZlcnRlZCA9IENvbnZlcnRlZAotCi1FY2xpcHNlTGlua1R5cGVNYXBwaW5nQ29tcG9zaXRlX2FkdmFuY2VkID0gQWR2YW5jZWQKLUVjbGlwc2VMaW5rVHlwZU1hcHBpbmdDb21wb3NpdGVfY2FjaGluZyA9IENhY2hpbmcKLUVjbGlwc2VMaW5rVHlwZU1hcHBpbmdDb21wb3NpdGVfY29udmVydGVycyA9IENvbnZlcnRlcnMKLQotRXhpc3RlbmNlQ2hlY2tpbmdDb21wb3NpdGVfbGFiZWwgPSBFeGlzdGVuY2UgY2hlY2tpbmc6Ci1KYXZhRXhpc3RlbmNlQ2hlY2tpbmdDb21wb3NpdGVfY2hlY2tfY2FjaGUgPSBDaGVjayBDYWNoZQotSmF2YUV4aXN0ZW5jZUNoZWNraW5nQ29tcG9zaXRlX2NoZWNrX2RhdGFiYXNlID0gQ2hlY2sgQ2FjaGUgdGhlbiBEYXRhYmFzZQotSmF2YUV4aXN0ZW5jZUNoZWNraW5nQ29tcG9zaXRlX2Fzc3VtZV9leGlzdGVuY2UgPSBBc3N1bWUgRXhpc3RlbmNlCi1KYXZhRXhpc3RlbmNlQ2hlY2tpbmdDb21wb3NpdGVfYXNzdW1lX25vbl9leGlzdGVuY2UgPSBBc3N1bWUgTm9uLUV4aXN0ZW5jZQotT3JtRXhpc3RlbmNlQ2hlY2tpbmdDb21wb3NpdGVfY2hlY2tfY2FjaGUgPSBDaGVjayBDYWNoZQotT3JtRXhpc3RlbmNlQ2hlY2tpbmdDb21wb3NpdGVfY2hlY2tfZGF0YWJhc2UgPSBDaGVjayBDYWNoZSB0aGVuIERhdGFiYXNlCi1Pcm1FeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZV9hc3N1bWVfZXhpc3RlbmNlID0gQXNzdW1lIEV4aXN0ZW5jZQotT3JtRXhpc3RlbmNlQ2hlY2tpbmdDb21wb3NpdGVfYXNzdW1lX25vbl9leGlzdGVuY2UgPSBBc3N1bWUgTm9uLUV4aXN0ZW5jZQotCi1FeHBpcnlDb21wb3NpdGVfZXhwaXJ5U2VjdGlvbiA9IEV4cGlyeQotCi1FeHBpcnlDb21wb3NpdGVfbm9FeHBpcnkgPSBObyBleHBpcnkKLUV4cGlyeUNvbXBvc2l0ZV90aW1lVG9MaXZlRXhwaXJ5ID0gVGltZSB0byBsaXZlIGV4cGlyeQotRXhwaXJ5Q29tcG9zaXRlX3RpbWVUb0xpdmVFeHBpcnlFeHBpcmVBZnRlciA9IEV4cGlyZSBhZnRlcgotRXhwaXJ5Q29tcG9zaXRlX3RpbWVUb0xpdmVFeHBpcnlNaWxsaXNlY29uZHMgPSBtaWxsaXNlY29uZHMKLUV4cGlyeUNvbXBvc2l0ZV9kYWlseUV4cGlyeSA9IERhaWx5IGV4cGlyeQotRXhwaXJ5Q29tcG9zaXRlX3RpbWVPZkRheUV4cGlyeUV4cGlyZUF0ID0gRXhwaXJlIGF0Ci0KLQotSm9pbkZldGNoQ29tcG9zaXRlX2xhYmVsID0gSm9pbiBmZXRjaDoKLUpvaW5GZXRjaENvbXBvc2l0ZV9pbm5lciA9IElubmVyCi1Kb2luRmV0Y2hDb21wb3NpdGVfb3V0ZXIgPSBPdXRlcgotCi1NdXRhYmxlQ29tcG9zaXRlX211dGFibGVMYWJlbD1NdXRhYmxlCi1NdXRhYmxlQ29tcG9zaXRlX211dGFibGVMYWJlbERlZmF1bHQ9TXV0YWJsZSAoezB9KQotTXV0YWJsZUNvbXBvc2l0ZV90cnVlPVRydWUKLU11dGFibGVDb21wb3NpdGVfZmFsc2U9RmFsc2UKLQotT2JqZWN0VHlwZUNvbnZlcnRlckNvbXBvc2l0ZV9kYXRhVHlwZUxhYmVsID0gRGF0YSB0eXBlOgotT2JqZWN0VHlwZUNvbnZlcnRlckNvbXBvc2l0ZV9vYmplY3RUeXBlTGFiZWwgPSBPYmplY3QgdHlwZToKLU9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGVfY29udmVyc2lvblZhbHVlRWRpdCA9IEVkaXQuLi4KLU9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGVfY29udmVyc2lvblZhbHVlc0RhdGFWYWx1ZUNvbHVtbiA9IERhdGEgVmFsdWUKLU9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGVfY29udmVyc2lvblZhbHVlc09iamVjdFZhbHVlQ29sdW1uID0gT2JqZWN0IFZhbHVlCi1PYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlX2RlZmF1bHRPYmplY3RWYWx1ZUxhYmVsID0gRGVmYXVsdCBvYmplY3QgdmFsdWU6Ci1PYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlX2NvbnZlcnNpb25WYWx1ZXNHcm91cFRpdGxlID0gQ29udmVyc2lvbiB2YWx1ZXMKLUNvbnZlcnNpb25WYWx1ZURpYWxvZ19hZGRDb252ZXJzaW9uVmFsdWUgPSBBZGQgQ29udmVyc2lvbiBWYWx1ZQotQ29udmVyc2lvblZhbHVlRGlhbG9nX2VkaXRDb252ZXJzaW9uVmFsdWUgPSBFZGl0IENvbnZlcnNpb24gVmFsdWUKLUNvbnZlcnNpb25WYWx1ZURpYWxvZ19hZGRDb252ZXJzaW9uVmFsdWVEZXNjcmlwdGlvblRpdGxlID0gQ3JlYXRlIG5ldyBjb252ZXJzaW9uIHZhbHVlCi1Db252ZXJzaW9uVmFsdWVEaWFsb2dfYWRkQ29udmVyc2lvblZhbHVlRGVzY3JpcHRpb24gPSBDcmVhdGUgYSBuZXcgY29udmVyc2lvbiB2YWx1ZSBzZXR0aW5nIGJvdGggdGhlICdkYXRhIHZhbHVlJyBhbmQgdGhlICdvYmplY3QgdmFsdWUnCi1Db252ZXJzaW9uVmFsdWVEaWFsb2dfZWRpdENvbnZlcnNpb25WYWx1ZURlc2NyaXB0aW9uVGl0bGUgPSBFZGl0IGNvbnZlcnNpb24gdmFsdWUKLUNvbnZlcnNpb25WYWx1ZURpYWxvZ19lZGl0Q29udmVyc2lvblZhbHVlRGVzY3JpcHRpb24gPSBFZGl0IHRoZSBjb252ZXJzaW9uIHZhbHVlLCBjaGFuZ2luZyB0aGUgJ2RhdGEgdmFsdWUnIG9yICdvYmplY3QgdmFsdWUnCi0KLUNvbnZlcnNpb25WYWx1ZURpYWxvZ19kYXRhVmFsdWUgPSBEYXRhIHZhbHVlOgotQ29udmVyc2lvblZhbHVlRGlhbG9nX29iamVjdFZhbHVlID0gT2JqZWN0IHZhbHVlOgotQ29udmVyc2lvblZhbHVlU3RhdGVPYmplY3RfZGF0YVZhbHVlTXVzdEJlU3BlY2lmaWVkID0gQSBkYXRhIHZhbHVlIG11c3QgYmUgc3BlY2lmaWVkLgotQ29udmVyc2lvblZhbHVlU3RhdGVPYmplY3Rfb2JqZWN0VmFsdWVNdXN0QmVTcGVjaWZpZWQgPSBBbiBvYmplY3QgdmFsdWUgbXVzdCBiZSBzcGVjaWZpZWQuCi1Db252ZXJzaW9uVmFsdWVTdGF0ZU9iamVjdF9kYXRhVmFsdWVBbHJlYWR5RXhpc3RzID0gVGhpcyBkYXRhIHZhbHVlIGlzIGFscmVhZHkgc3BlY2lmaWVkLCBjYW5ub3QgbWFwIG11bHRpcGxlIG9iamVjdCB2YWx1ZXMgdG8gdGhlIHNhbWUgZGF0YSB2YWx1ZS4KLQotCi1Qcml2YXRlT3duZWRDb21wb3NpdGVfcHJpdmF0ZU93bmVkTGFiZWwgPSBQcml2YXRlIG93bmVkCi1SZWFkT25seUNvbXBvc2l0ZV9yZWFkT25seUxhYmVsID0gUmVhZC1vbmx5Ci1SZWFkT25seUNvbXBvc2l0ZV9yZWFkT25seVdpdGhEZWZhdWx0ID0gUmVhZC1vbmx5ICh7MH0pCi1UeXBlQ29udmVydGVyQ29tcG9zaXRlX2RhdGFUeXBlTGFiZWwgPSBEYXRhIHR5cGU6Ci1UeXBlQ29udmVydGVyQ29tcG9zaXRlX29iamVjdFR5cGVMYWJlbCA9IE9iamVjdCB0eXBlOgotCi1EZWZhdWx0T25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcl9sYWJlbD1EZWZhdWx0IChPbmUgdG8gT25lKQotRGVmYXVsdFZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcl9sYWJlbD1EZWZhdWx0IChWYXJpYWJsZSBPbmUgdG8gT25lKQotRGVmYXVsdE9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyX2xhYmVsPURlZmF1bHQgKE9uZSB0byBNYW55KQotRGVmYXVsdE9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXJfbGlua0xhYmVsPWRlZmF1bHQgKG9uZSB0byBvbmUpCi1EZWZhdWx0VmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyX2xpbmtMYWJlbD1kZWZhdWx0ICh2YXJpYWJsZSBvbmUgdG8gb25lKQotRGVmYXVsdE9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyX2xpbmtMYWJlbD1kZWZhdWx0IChvbmUgdG8gbWFueSkKLQotQ29udmVydGVyc0NvbXBvc2l0ZV9MYWJlbD1Db252ZXJ0ZXJzCi0JCi1FY2xpcHNlTGlua0NvbnZlcnRlckRpYWxvZ19uYW1lPU5hbWU6Ci1FY2xpcHNlTGlua0NvbnZlcnRlckRpYWxvZ19jb252ZXJ0ZXJUeXBlPVR5cGU6Ci1FY2xpcHNlTGlua0NvbnZlcnRlckRpYWxvZ19hZGRDb252ZXJ0ZXI9QWRkIENvbnZlcnRlcgotRWNsaXBzZUxpbmtDb252ZXJ0ZXJEaWFsb2dfYWRkQ29udmVydGVyRGVzY3JpcHRpb25UaXRsZT1DcmVhdGUgbmV3IGNvbnZlcnRlcgotRWNsaXBzZUxpbmtDb252ZXJ0ZXJEaWFsb2dfYWRkQ29udmVydGVyRGVzY3JpcHRpb249Q3JlYXRlIGEgbmV3IGNvbnZlcnRlciBzZXR0aW5nIGJvdGggdGhlICduYW1lJyBhbmQgdGhlICd0eXBlJwotRWNsaXBzZUxpbmtDb252ZXJ0ZXJTdGF0ZU9iamVjdF9uYW1lTXVzdEJlU3BlY2lmaWVkID0gQSBuYW1lIG11c3QgYmUgc3BlY2lmaWVkLgotRWNsaXBzZUxpbmtDb252ZXJ0ZXJTdGF0ZU9iamVjdF90eXBlTXVzdEJlU3BlY2lmaWVkID0gQSBjb252ZXJ0ZXIgdHlwZSBtdXN0IGJlIHNwZWNpZmllZC4KLQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvSnB0RWNsaXBzZUxpbmtVaVBsdWdpbi5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvSnB0RWNsaXBzZUxpbmtVaVBsdWdpbi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkOWI0ODAyLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL0pwdEVjbGlwc2VMaW5rVWlQbHVnaW4uamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDk4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDgsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5JU3RhdHVzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5TdGF0dXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2UucmVzb3VyY2UuSW1hZ2VEZXNjcmlwdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5ncmFwaGljcy5JbWFnZTsKLWltcG9ydCBvcmcuZWNsaXBzZS51aS5wbHVnaW4uQWJzdHJhY3RVSVBsdWdpbjsKLWltcG9ydCBvcmcub3NnaS5mcmFtZXdvcmsuQnVuZGxlQ29udGV4dDsKLQotLyoqCi0gKiBUaGUgYWN0aXZhdG9yIGNsYXNzIGNvbnRyb2xzIHRoZSBwbHVnLWluIGxpZmUgY3ljbGUKLSAqIAotICogCi0gKiBQcm92aXNpb25hbCBBUEk6IFRoaXMgaW50ZXJmYWNlIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbAotICogdW5kZXIgZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZwotICogc3RhYmlsaXR5LiBJdCBpcyBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20KLSAqIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgdGhpcyBBUEkKLSAqIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KLSAqLwotcHVibGljIGNsYXNzIEpwdEVjbGlwc2VMaW5rVWlQbHVnaW4gZXh0ZW5kcyBBYnN0cmFjdFVJUGx1Z2luCi17Ci0KLQkvLyBUaGUgcGx1Zy1pbiBJRAotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFBMVUdJTl9JRCA9ICJvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkiOyAvLyROT04tTkxTLTEkCi0KLQkKLQkvLyAqKioqKioqKioqIHNpbmdsZXRvbiAqKioqKioqKioqCi0JcHJpdmF0ZSBzdGF0aWMgSnB0RWNsaXBzZUxpbmtVaVBsdWdpbiBJTlNUQU5DRTsKLQotCS8qKgotCSAqIFJldHVybnMgdGhlIHNpbmdsZXRvbiBQbHVnaW4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEpwdEVjbGlwc2VMaW5rVWlQbHVnaW4gaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0KLQlwdWJsaWMgc3RhdGljIHZvaWQgbG9nKElTdGF0dXMgc3RhdHVzKSB7Ci0gICAgICAgIElOU1RBTkNFLmdldExvZygpLmxvZyhzdGF0dXMpOwotICAgIH0KLQotCXB1YmxpYyBzdGF0aWMgdm9pZCBsb2coU3RyaW5nIG1zZykgewotICAgICAgICBsb2cobmV3IFN0YXR1cyhJU3RhdHVzLkVSUk9SLCBQTFVHSU5fSUQsIElTdGF0dXMuT0ssIG1zZywgbnVsbCkpOwotICAgIH0KLQotCXB1YmxpYyBzdGF0aWMgdm9pZCBsb2coVGhyb3dhYmxlIHRocm93YWJsZSkgewotCQlsb2cobmV3IFN0YXR1cyhJU3RhdHVzLkVSUk9SLCBQTFVHSU5fSUQsIElTdGF0dXMuT0ssIHRocm93YWJsZS5nZXRMb2NhbGl6ZWRNZXNzYWdlKCksIHRocm93YWJsZSkpOwotCX0KLQotCS8vICoqKioqKioqKiogSW1hZ2UgQVBJICoqKioqKioqKioKLQkvKioKLQkgKiBUaGlzIGdldHMgYSAuZ2lmIGZyb20gdGhlIGljb25zIGZvbGRlci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEltYWdlRGVzY3JpcHRvciBnZXRJbWFnZURlc2NyaXB0b3IoU3RyaW5nIGtleSkgewotCQlpZiAoISBrZXkuc3RhcnRzV2l0aCgiaWNvbnMvIikpIHsKLQkJCWtleSA9ICJpY29ucy8iICsga2V5OwotCQl9Ci0JCWlmICghIGtleS5lbmRzV2l0aCgiLmdpZiIpKSB7Ci0JCQlrZXkgPSBrZXkgKyAiLmdpZiI7Ci0JCX0KLQkJcmV0dXJuIGltYWdlRGVzY3JpcHRvckZyb21QbHVnaW4oUExVR0lOX0lELCBrZXkpOwotCX0KLQotCS8qKgotCSAqIFRoaXMgcmV0dXJucyBhbiBpbWFnZSBmb3IgYSAuZ2lmIGZyb20gdGhlIGljb25zIGZvbGRlcgotCSAqLwotCXB1YmxpYyBzdGF0aWMgSW1hZ2UgZ2V0SW1hZ2UoU3RyaW5nIGtleSkgewotCQlJbWFnZURlc2NyaXB0b3IgZGVzYyA9IGdldEltYWdlRGVzY3JpcHRvcihrZXkpOwotCQlyZXR1cm4gKGRlc2MgPT0gbnVsbCkgPyBudWxsIDogZGVzYy5jcmVhdGVJbWFnZSgpOwotCX0KLQotCi0JCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCXB1YmxpYyBKcHRFY2xpcHNlTGlua1VpUGx1Z2luKCkgewotCQlzdXBlcigpOwotCQlJTlNUQU5DRSA9IHRoaXM7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgc3RhcnQoQnVuZGxlQ29udGV4dCBjb250ZXh0KSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc3RhcnQoY29udGV4dCk7Ci0JCUlOU1RBTkNFID0gdGhpczsKLQl9Ci0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgc3RvcChCdW5kbGVDb250ZXh0IGNvbnRleHQpIHRocm93cyBFeGNlcHRpb24gewotCQlJTlNUQU5DRSA9IG51bGw7Ci0JCXN1cGVyLnN0b3AoY29udGV4dCk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvRWNsaXBzZUxpbmsxXzFKcGFVaUZhY3RvcnkuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL0VjbGlwc2VMaW5rMV8xSnBhVWlGYWN0b3J5LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDBhYjUwM2EuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvRWNsaXBzZUxpbmsxXzFKcGFVaUZhY3RvcnkuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDUzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5KYXZhRW1iZWRkYWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LmphdmEuSmF2YUVudGl0eTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LmphdmEuSmF2YU1hcHBlZFN1cGVyY2xhc3M7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLmphdmEuZGV0YWlscy5FY2xpcHNlTGluazFfMUphdmFFbWJlZGRhYmxlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5qYXZhLmRldGFpbHMuRWNsaXBzZUxpbmsxXzFKYXZhRW50aXR5Q29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5qYXZhLmRldGFpbHMuRWNsaXBzZUxpbmsxXzFKYXZhTWFwcGVkU3VwZXJjbGFzc0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rMV8xSnBhVWlGYWN0b3J5IGV4dGVuZHMgRWNsaXBzZUxpbmtKcGFVaUZhY3RvcnkgLy9UT0RPIGp1c3QgZXh0ZW5kIGZvciBub3csIGJ1dCB3ZSBuZWVkIHRvIGNoYW5nZSB0aGlzIHRvIG1hdGNoIHRoZSBKcGFQbGF0Zm9ybQotewotCXB1YmxpYyBFY2xpcHNlTGluazFfMUpwYVVpRmFjdG9yeSgpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JCi0JCi0JLy8gKioqKioqKioqKioqKioqKiBqYXZhIHR5cGUgbWFwcGluZyBjb21wb3NpdGVzICoqKioqKioqKioqKioqKioqKioqKioqKioqKgotCQotCUBPdmVycmlkZQotCXB1YmxpYyBKcGFDb21wb3NpdGUgY3JlYXRlSmF2YU1hcHBlZFN1cGVyY2xhc3NDb21wb3NpdGUoCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8SmF2YU1hcHBlZFN1cGVyY2xhc3M+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LCBXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGluazFfMUphdmFNYXBwZWRTdXBlcmNsYXNzQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCQotCUBPdmVycmlkZQotCXB1YmxpYyBKcGFDb21wb3NpdGUgY3JlYXRlSmF2YUVudGl0eUNvbXBvc2l0ZSgKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxKYXZhRW50aXR5PiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmsxXzFKYXZhRW50aXR5Q29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCQotCUBPdmVycmlkZQotCXB1YmxpYyBKcGFDb21wb3NpdGUgY3JlYXRlSmF2YUVtYmVkZGFibGVDb21wb3NpdGUoCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8SmF2YUVtYmVkZGFibGU+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LCBXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGluazFfMUphdmFFbWJlZGRhYmxlQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL0VjbGlwc2VMaW5rSGVscENvbnRleHRJZHMuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL0VjbGlwc2VMaW5rSGVscENvbnRleHRJZHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggM2YwMTRkYi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9FY2xpcHNlTGlua0hlbHBDb250ZXh0SWRzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZgotICogdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24gYW5kIGlzIGF2YWlsYWJsZSBhdAotICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLkpwdEVjbGlwc2VMaW5rVWlQbHVnaW47Ci0KLS8qKgotICogSGVscCBjb250ZXh0IGlkcyBmb3IgdGhlIERhbGkgRWNsaXBzZUxpbmsgVUkuCi0gKiA8cD4KLSAqIFRoaXMgaW50ZXJmYWNlIGNvbnRhaW5zIGNvbnN0YW50cyBvbmx5OyBpdCBpcyBub3QgaW50ZW5kZWQgdG8gYmUKLSAqIGltcGxlbWVudGVkLgotICogPC9wPgotICovCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBpbnRlcmZhY2UgRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcyB7Ci0KLQkvL0NvbnRleHRJRCBwcmVmaXgKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBQUkVGSVggPSBKcHRFY2xpcHNlTGlua1VpUGx1Z2luLlBMVUdJTl9JRCArICIuIjsKLQotCS8vUGVyc2lzdGVudCBUeXBlIGNvbXBvc2l0ZXMKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBDQUNISU5HX0NBQ0hFX1RZUEUgPSBQUkVGSVggKyAiY2FjaGluZ19jYWNoZVR5cGUiOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIENBQ0hJTkdfU0hBUkVEID0gUFJFRklYICsgImNhY2hpbmdfc2hhcmVkIjsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBDQUNISU5HX0FMV0FZU19SRUZSRVNIID0gUFJFRklYICsgImNhY2hpbmdfYWx3YXlzUmVmcmVzaCI7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgQ0FDSElOR19SRUZSRVNIX09OTFlfSUZfTkVXRVIgPSBQUkVGSVggKyAiY2FjaGluZ19yZWZyZXNoT25seUlmTmV3ZXIiOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIENBQ0hJTkdfRElTQUJMRV9ISVRTID0gUFJFRklYICsgImNhY2hpbmdfZGlzYWJsZUhpdHMiOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIENBQ0hJTkdfQ0FDSEVfQ09PUkRJTkFUSU9OX1RZUEUgPSBQUkVGSVggKyAiY2FjaGluZ19jYWNoZUNvb3JkaW5hdGlvblR5cGUiOwotCQotCQkKLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL0VjbGlwc2VMaW5rSnBhVWlGYWN0b3J5LmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9FY2xpcHNlTGlua0pwYVVpRmFjdG9yeS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmNjYwMGYwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL0VjbGlwc2VMaW5rSnBhVWlGYWN0b3J5LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyNjIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5KYXZhQmFzaWNNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5KYXZhRW1iZWRkYWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LmphdmEuSmF2YUVudGl0eTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LmphdmEuSmF2YUlkTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LmphdmEuSmF2YU1hbnlUb01hbnlNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5KYXZhTWFueVRvT25lTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LmphdmEuSmF2YU1hcHBlZFN1cGVyY2xhc3M7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5qYXZhLkphdmFPbmVUb01hbnlNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5KYXZhT25lVG9PbmVNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5KYXZhVmVyc2lvbk1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5wZXJzaXN0ZW5jZS5QZXJzaXN0ZW5jZVVuaXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5qYXZhLkVjbGlwc2VMaW5rSmF2YU9uZVRvTWFueU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5FY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNhY2hpbmcuQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNvbm5lY3Rpb24uQ29ubmVjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb24uQ3VzdG9taXphdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmxvZ2dpbmcuTG9nZ2luZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLm9wdGlvbnMuT3B0aW9uczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLnNjaGVtYS5nZW5lcmF0aW9uLlNjaGVtYUdlbmVyYXRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLmphdmEuZGV0YWlscy5FY2xpcHNlTGlua0phdmFFbWJlZGRhYmxlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5qYXZhLmRldGFpbHMuRWNsaXBzZUxpbmtKYXZhRW50aXR5Q29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5qYXZhLmRldGFpbHMuRWNsaXBzZUxpbmtKYXZhTWFwcGVkU3VwZXJjbGFzc0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua0Jhc2ljTWFwcGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua0lkTWFwcGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua01hbnlUb01hbnlNYXBwaW5nQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkVjbGlwc2VMaW5rTWFueVRvT25lTWFwcGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua09uZVRvTWFueU1hcHBpbmdDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtPbmVUb09uZU1hcHBpbmdDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtWZXJzaW9uTWFwcGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY2FjaGluZy5QZXJzaXN0ZW5jZVhtbENhY2hpbmdUYWI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmNvbm5lY3Rpb24uUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jdXN0b21pemF0aW9uLlBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuZ2VuZXJhbC5FY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdEdlbmVyYWxDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmxvZ2dpbmcuUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5vcHRpb25zLlBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2Uuc2NoZW1hLmdlbmVyYXRpb24uUGVyc2lzdGVuY2VYbWxTY2hlbWFHZW5lcmF0aW9uVGFiOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFQYWdlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5CYXNlSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5kZXRhaWxzLlBlcnNpc3RlbmNlVW5pdFByb3BlcnRpZXNDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rSnBhVWlGYWN0b3J5IGV4dGVuZHMgQmFzZUpwYVVpRmFjdG9yeQotewotCXB1YmxpYyBFY2xpcHNlTGlua0pwYVVpRmFjdG9yeSgpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JCi0JLy8gKioqKioqKioqKioqKioqKiBwZXJzaXN0ZW5jZSB1bml0IGNvbXBvc2l0ZXMgKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotCQotCUBPdmVycmlkZQotCXB1YmxpYyBMaXN0SXRlcmF0b3I8SnBhUGFnZUNvbXBvc2l0ZT4gY3JlYXRlUGVyc2lzdGVuY2VVbml0Q29tcG9zaXRlcygKLQkJCQkJCVByb3BlcnR5VmFsdWVNb2RlbDxQZXJzaXN0ZW5jZVVuaXQ+IHN1YmplY3RIb2xkZXIsCi0JCQkJCQlDb21wb3NpdGUgcGFyZW50LAotCQkJCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCQotCQlQcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQ+IGVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0SG9sZGVyID0gCi0JCQl0aGlzLmJ1aWxkRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXRIb2xkZXIoc3ViamVjdEhvbGRlcik7Ci0JCUFycmF5TGlzdDxKcGFQYWdlQ29tcG9zaXRlPiBwYWdlcyA9IAotCQkJbmV3IEFycmF5TGlzdDxKcGFQYWdlQ29tcG9zaXRlPig4KTsKLQotCQlwYWdlcy5hZGQobmV3IEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0R2VuZXJhbENvbXBvc2l0ZShlY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KSk7Ci0JCQotCQlQcm9wZXJ0eVZhbHVlTW9kZWw8Q29ubmVjdGlvbj4gY29ubmVjdGlvbkhvbGRlciA9IAotCQkJdGhpcy5idWlsZENvbm5lY3Rpb25Ib2xkZXIoZWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXRIb2xkZXIpOwotCQlwYWdlcy5hZGQobmV3IFBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYihjb25uZWN0aW9uSG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpKTsKLQkJCi0JCVByb3BlcnR5VmFsdWVNb2RlbDxDdXN0b21pemF0aW9uPiBjdXN0b21pemF0aW9uSG9sZGVyID0gCi0JCQl0aGlzLmJ1aWxkQ3VzdG9taXphdGlvbkhvbGRlcihlY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdEhvbGRlcik7Ci0JCXBhZ2VzLmFkZChuZXcgUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiKGN1c3RvbWl6YXRpb25Ib2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSkpOwotCQkKLQkJUHJvcGVydHlWYWx1ZU1vZGVsPENhY2hpbmc+IGNhY2hpbmdIb2xkZXIgPSAKLQkJCXRoaXMuYnVpbGRDYWNoaW5nSG9sZGVyKGVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0SG9sZGVyKTsKLQkJcGFnZXMuYWRkKG5ldyBQZXJzaXN0ZW5jZVhtbENhY2hpbmdUYWIoY2FjaGluZ0hvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KSk7Ci0JCQotCQlQcm9wZXJ0eVZhbHVlTW9kZWw8TG9nZ2luZz4gbG9nZ2luZ0hvbGRlciA9IAotCQkJdGhpcy5idWlsZExvZ2dpbmdIb2xkZXIoZWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXRIb2xkZXIpOwotCQlwYWdlcy5hZGQobmV3IFBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYihsb2dnaW5nSG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpKTsKLQotCQlQcm9wZXJ0eVZhbHVlTW9kZWw8T3B0aW9ucz4gb3B0aW9uc0hvbGRlciA9IAotCQkJdGhpcy5idWlsZE9wdGlvbnNIb2xkZXIoZWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXRIb2xkZXIpOwotCQlwYWdlcy5hZGQobmV3IFBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYihvcHRpb25zSG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpKTsKLQkJCi0JCVByb3BlcnR5VmFsdWVNb2RlbDxTY2hlbWFHZW5lcmF0aW9uPiBzY2hlbWFHZW5Ib2xkZXIgPSAKLQkJCXRoaXMuYnVpbGRTY2hlbWFHZW5lcmF0aW9uSG9sZGVyKGVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0SG9sZGVyKTsKLQkJcGFnZXMuYWRkKG5ldyBQZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWIoc2NoZW1hR2VuSG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpKTsKLQkJCi0JCXBhZ2VzLmFkZChuZXcgUGVyc2lzdGVuY2VVbml0UHJvcGVydGllc0NvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpKTsKLQkJCi0JCXJldHVybiBwYWdlcy5saXN0SXRlcmF0b3IoKTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQ+IGJ1aWxkRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXRIb2xkZXIoCi0JCQkJUHJvcGVydHlWYWx1ZU1vZGVsPFBlcnNpc3RlbmNlVW5pdD4gc3ViamVjdEhvbGRlcikgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPFBlcnNpc3RlbmNlVW5pdCwgRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQ+KHN1YmplY3RIb2xkZXIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0IHRyYW5zZm9ybV8oUGVyc2lzdGVuY2VVbml0IHZhbHVlKSB7Ci0JCQkJcmV0dXJuIChFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdCkgdmFsdWU7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPENvbm5lY3Rpb24+IGJ1aWxkQ29ubmVjdGlvbkhvbGRlcigKLQkJCQlQcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQ+IHN1YmplY3RIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdCwgQ29ubmVjdGlvbj4oc3ViamVjdEhvbGRlcikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ29ubmVjdGlvbiB0cmFuc2Zvcm1fKEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0IHZhbHVlKSB7Ci0JCQkJcmV0dXJuIHZhbHVlLmdldENvbm5lY3Rpb24oKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8Q3VzdG9taXphdGlvbj4gYnVpbGRDdXN0b21pemF0aW9uSG9sZGVyKAotCQkJCVByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdD4gc3ViamVjdEhvbGRlcikgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0LCBDdXN0b21pemF0aW9uPihzdWJqZWN0SG9sZGVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDdXN0b21pemF0aW9uIHRyYW5zZm9ybV8oRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQgdmFsdWUpIHsKLQkJCQlyZXR1cm4gdmFsdWUuZ2V0Q3VzdG9taXphdGlvbigpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxDYWNoaW5nPiBidWlsZENhY2hpbmdIb2xkZXIoCi0JCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0PiBzdWJqZWN0SG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQsIENhY2hpbmc+KHN1YmplY3RIb2xkZXIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENhY2hpbmcgdHJhbnNmb3JtXyhFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdCB2YWx1ZSkgewotCQkJCXJldHVybiB2YWx1ZS5nZXRDYWNoaW5nKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPExvZ2dpbmc+IGJ1aWxkTG9nZ2luZ0hvbGRlcigKLQkJCQlQcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQ+IHN1YmplY3RIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdCwgTG9nZ2luZz4oc3ViamVjdEhvbGRlcikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgTG9nZ2luZyB0cmFuc2Zvcm1fKEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0IHZhbHVlKSB7Ci0JCQkJcmV0dXJuIHZhbHVlLmdldExvZ2dpbmcoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8T3B0aW9ucz4gYnVpbGRPcHRpb25zSG9sZGVyKAotCQkJCVByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdD4gc3ViamVjdEhvbGRlcikgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0LCBPcHRpb25zPihzdWJqZWN0SG9sZGVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBPcHRpb25zIHRyYW5zZm9ybV8oRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQgdmFsdWUpIHsKLQkJCQlyZXR1cm4gdmFsdWUuZ2V0T3B0aW9ucygpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTY2hlbWFHZW5lcmF0aW9uPiBidWlsZFNjaGVtYUdlbmVyYXRpb25Ib2xkZXIoCi0JCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0PiBzdWJqZWN0SG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQsIFNjaGVtYUdlbmVyYXRpb24+KHN1YmplY3RIb2xkZXIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFNjaGVtYUdlbmVyYXRpb24gdHJhbnNmb3JtXyhFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdCB2YWx1ZSkgewotCQkJCXJldHVybiB2YWx1ZS5nZXRTY2hlbWFHZW5lcmF0aW9uKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCQotCS8vICoqKioqKioqKioqKioqKiogamF2YSB0eXBlIG1hcHBpbmcgY29tcG9zaXRlcyAqKioqKioqKioqKioqKioqKioqKioqKioqKioKLQkKLQlAT3ZlcnJpZGUKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGNyZWF0ZUphdmFNYXBwZWRTdXBlcmNsYXNzQ29tcG9zaXRlKAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEphdmFNYXBwZWRTdXBlcmNsYXNzPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmtKYXZhTWFwcGVkU3VwZXJjbGFzc0NvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGNyZWF0ZUphdmFFbnRpdHlDb21wb3NpdGUoCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8SmF2YUVudGl0eT4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rSmF2YUVudGl0eUNvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGNyZWF0ZUphdmFFbWJlZGRhYmxlQ29tcG9zaXRlKAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEphdmFFbWJlZGRhYmxlPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmtKYXZhRW1iZWRkYWJsZUNvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQkKLQkKLQkvLyAqKioqKioqKioqKioqKioqIGphdmEgYXR0cmlidXRlIG1hcHBpbmcgY29tcG9zaXRlcyAqKioqKioqKioqKioqKioqKioqKioqCi0JCi0JQE92ZXJyaWRlCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBjcmVhdGVKYXZhSWRNYXBwaW5nQ29tcG9zaXRlKAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEphdmFJZE1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmtJZE1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBjcmVhdGVKYXZhQmFzaWNNYXBwaW5nQ29tcG9zaXRlKAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEphdmFCYXNpY01hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmtCYXNpY01hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBjcmVhdGVKYXZhVmVyc2lvbk1hcHBpbmdDb21wb3NpdGUoCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8SmF2YVZlcnNpb25NYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rVmVyc2lvbk1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBjcmVhdGVKYXZhTWFueVRvT25lTWFwcGluZ0NvbXBvc2l0ZSgKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxKYXZhTWFueVRvT25lTWFwcGluZz4gc3ViamVjdEhvbGRlciwgCi0JCQlDb21wb3NpdGUgcGFyZW50LCAKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rTWFueVRvT25lTWFwcGluZ0NvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGNyZWF0ZUphdmFPbmVUb01hbnlNYXBwaW5nQ29tcG9zaXRlKAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBKYXZhT25lVG9NYW55TWFwcGluZz4gc3ViamVjdEhvbGRlciwgCi0JCQlDb21wb3NpdGUgcGFyZW50LCAKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rT25lVG9NYW55TWFwcGluZ0NvbXBvc2l0ZSgoUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rSmF2YU9uZVRvTWFueU1hcHBpbmc+KSBzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGNyZWF0ZUphdmFPbmVUb09uZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8SmF2YU9uZVRvT25lTWFwcGluZz4gc3ViamVjdEhvbGRlciwgCi0JCQlDb21wb3NpdGUgcGFyZW50LCAKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rT25lVG9PbmVNYXBwaW5nQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCQotCUBPdmVycmlkZQotCXB1YmxpYyBKcGFDb21wb3NpdGUgY3JlYXRlSmF2YU1hbnlUb01hbnlNYXBwaW5nQ29tcG9zaXRlKAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEphdmFNYW55VG9NYW55TWFwcGluZz4gc3ViamVjdEhvbGRlciwgCi0JCQlDb21wb3NpdGUgcGFyZW50LCAKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rTWFueVRvTWFueU1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9CQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL0VjbGlwc2VMaW5rVWlNZXNzYWdlcy5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDc2YmE5M2EuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNTQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0qIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0qIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0qCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsOwotCi1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLQotLyoqCi0gKiBMb2NhbGl6ZWQgbWVzc2FnZXMgdXNlZCBieSBFbGlwc2VMaW5rIFVJLgotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtVaU1lc3NhZ2VzIHsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIE1hcHBpbmdGaWxlV2l6YXJkX3RpdGxlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIE1hcHBpbmdGaWxlV2l6YXJkUGFnZV90aXRsZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBNYXBwaW5nRmlsZVdpemFyZFBhZ2VfZGVzYzsKLQkKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBFY2xpcHNlTGluazFfMU1hcHBpbmdGaWxlV2l6YXJkX3RpdGxlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEVjbGlwc2VMaW5rMV8xTWFwcGluZ0ZpbGVXaXphcmRQYWdlX3RpdGxlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEVjbGlwc2VMaW5rMV8xTWFwcGluZ0ZpbGVXaXphcmRQYWdlX2Rlc2M7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBCb29sZWFuX1RydWU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgQm9vbGVhbl9GYWxzZTsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIERlZmF1bHRXaXRob3V0VmFsdWU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRGVmYXVsdFdpdGhWYWx1ZTsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sVGFiRm9sZGVyX2RlZmF1bHRFbXB0eTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbFRhYkZvbGRlcl9kZWZhdWx0V2l0aE9uZVBhcmFtOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX25hbWU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX3Byb3ZpZGVyOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sR2VuZXJhbFRhYl9icm93c2U7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX2Rlc2NyaXB0aW9uOwotCi0JLy8gR2VuZXJhbAotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sR2VuZXJhbFRhYl90aXRsZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEdlbmVyYWxUYWJfZ2VuZXJhbFNlY3Rpb25UaXRsZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEdlbmVyYWxUYWJfbWFwcGVkQ2xhc3Nlc1NlY3Rpb25UaXRsZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEdlbmVyYWxUYWJfbWFwcGVkQ2xhc3Nlc1NlY3Rpb25EZXNjcmlwdGlvbjsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEdlbmVyYWxUYWJfeG1sTWFwcGluZ0ZpbGVzU2VjdGlvblRpdGxlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sR2VuZXJhbFRhYl94bWxNYXBwaW5nRmlsZXNTZWN0aW9uRGVzY3JpcHRpb247Ci0JCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX25hbWVMYWJlbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEdlbmVyYWxUYWJfcGVyc2lzdGVuY2VQcm92aWRlckxhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sR2VuZXJhbFRhYl9kZXNjcmlwdGlvbkxhYmVsOwotCQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sR2VuZXJhbFRhYl9leGNsdWRlVW5saXN0ZWRNYXBwZWRDbGFzc2VzOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sR2VuZXJhbFRhYl9leGNsdWRlVW5saXN0ZWRNYXBwZWRDbGFzc2VzV2l0aERlZmF1bHQ7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX21hcHBlZENsYXNzZXNOb05hbWU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX29wZW47Ci0JCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX3htbE1hcHBpbmdGaWxlc0RpYWxvZ190aXRsZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEdlbmVyYWxUYWJfeG1sTWFwcGluZ0ZpbGVzRGlhbG9nX21lc3NhZ2U7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX29ybU5vTmFtZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEdlbmVyYWxUYWJfZXhjbHVkZUVjbGlwc2VsaW5rT3JtOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sR2VuZXJhbFRhYl9leGNsdWRlRWNsaXBzZWxpbmtPcm1XaXRoRGVmYXVsdDsKLQotCS8vIENvbm5lY3Rpb24KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfdGl0bGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3NlY3Rpb25UaXRsZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfc2VjdGlvbkRlc2NyaXB0aW9uOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9kZWZhdWx0V2l0aE9uZVBhcmFtOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9kZWZhdWx0RW1wdHk7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfdHJhbnNhY3Rpb25UeXBlTGFiZWw7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDb25uZWN0aW9uUHJvcGVydGllc0NvbXBvc2l0ZV9EYXRhYmFzZV9Hcm91cEJveDsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEpkYmNQcm9wZXJ0aWVzQ29tcG9zaXRlX0VjbGlwc2VMaW5rQ29ubmVjdGlvblBvb2xfR3JvdXBCb3g7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBKZGJjQ29ubmVjdGlvblByb3BlcnRpZXNDb21wb3NpdGVfQ29ubmVjdGlvbkRpYWxvZ19NZXNzYWdlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEpkYmNDb25uZWN0aW9uUHJvcGVydGllc0NvbXBvc2l0ZV9Db25uZWN0aW9uRGlhbG9nX1RpdGxlOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgVHJhbnNhY3Rpb25UeXBlQ29tcG9zaXRlX2p0YTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUcmFuc2FjdGlvblR5cGVDb21wb3NpdGVfcmVzb3VyY2VfbG9jYWw7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfbmF0aXZlU3FsTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX25hdGl2ZVNxbExhYmVsRGVmYXVsdDsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9iYXRjaFdyaXRpbmdMYWJlbDsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEJhdGNoV3JpdGluZ0NvbXBvc2l0ZV9ub25lOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEJhdGNoV3JpdGluZ0NvbXBvc2l0ZV9qZGJjOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEJhdGNoV3JpdGluZ0NvbXBvc2l0ZV9idWZmZXJlZDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBCYXRjaFdyaXRpbmdDb21wb3NpdGVfb3JhY2xlX2pkYmM7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfY2FjaGVTdGF0ZW1lbnRzTGFiZWw7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfanRhRGF0YVNvdXJjZUxhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9ub25KdGFEYXRhU291cmNlTGFiZWw7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfZHJpdmVyTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3VybExhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl91c2VyTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3Bhc3N3b3JkTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX2JpbmRQYXJhbWV0ZXJzTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX2JpbmRQYXJhbWV0ZXJzTGFiZWxEZWZhdWx0OwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3JlYWRDb25uZWN0aW9uc1NoYXJlZExhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9yZWFkQ29ubmVjdGlvbnNTaGFyZWRMYWJlbERlZmF1bHQ7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3JlYWRDb25uZWN0aW9uc1NlY3Rpb25UaXRsZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfcmVhZENvbm5lY3Rpb25zTWluTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3JlYWRDb25uZWN0aW9uc01heExhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl93cml0ZUNvbm5lY3Rpb25zU2VjdGlvblRpdGxlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl93cml0ZUNvbm5lY3Rpb25zTWluTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3dyaXRlQ29ubmVjdGlvbnNNYXhMYWJlbDsKLQotCS8vIFNjaGVtYUdlbmVyYXRpb24KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWJfdGl0bGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxTY2hlbWFHZW5lcmF0aW9uVGFiX3NlY3Rpb25UaXRsZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWJfc2VjdGlvbkRlc2NyaXB0aW9uOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sU2NoZW1hR2VuZXJhdGlvblRhYl9kZWZhdWx0V2l0aE9uZVBhcmFtOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sU2NoZW1hR2VuZXJhdGlvblRhYl9kZWZhdWx0RW1wdHk7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWJfZGRsR2VuZXJhdGlvblR5cGVMYWJlbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWJfb3V0cHV0TW9kZUxhYmVsOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxTY2hlbWFHZW5lcmF0aW9uVGFiX2NyZWF0ZURkbEZpbGVOYW1lTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxTY2hlbWFHZW5lcmF0aW9uVGFiX2Ryb3BEZGxGaWxlTmFtZUxhYmVsOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgT3V0cHV0TW9kZUNvbXBvc2l0ZV9ib3RoOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIE91dHB1dE1vZGVDb21wb3NpdGVfc3FsX3NjcmlwdDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBPdXRwdXRNb2RlQ29tcG9zaXRlX2RhdGFiYXNlOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgRGRsR2VuZXJhdGlvblR5cGVDb21wb3NpdGVfbm9uZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBEZGxHZW5lcmF0aW9uVHlwZUNvbXBvc2l0ZV9jcmVhdGVfdGFibGVzOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIERkbEdlbmVyYXRpb25UeXBlQ29tcG9zaXRlX2Ryb3BfYW5kX2NyZWF0ZV90YWJsZXM7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWJfZGRsR2VuZXJhdGlvbkxvY2F0aW9uTGFiZWw7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBEZGxHZW5lcmF0aW9uTG9jYXRpb25Db21wb3NpdGVfZGlhbG9nVGl0bGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRGRsR2VuZXJhdGlvbkxvY2F0aW9uQ29tcG9zaXRlX2RpYWxvZ01lc3NhZ2U7Ci0KLQkvLyBDYWNoaW5nCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiX3RpdGxlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ2FjaGluZ1RhYl9zZWN0aW9uVGl0bGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiX3NlY3Rpb25EZXNjcmlwdGlvbjsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ2FjaGluZ1RhYl9kZWZhdWx0Q2FjaGVUeXBlTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiX2NhY2hlVHlwZUxhYmVsOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiX2RlZmF1bHRTaGFyZWRDYWNoZUxhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ2FjaGluZ1RhYl9zaGFyZWRDYWNoZUxhYmVsOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiX2RlZmF1bHRTaGFyZWRDYWNoZURlZmF1bHRMYWJlbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbENhY2hpbmdUYWJfc2hhcmVkQ2FjaGVEZWZhdWx0TGFiZWw7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDYWNoZVNpemVDb21wb3NpdGVfY2FjaGVTaXplOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ2FjaGVUeXBlQ29tcG9zaXRlX2Z1bGw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ2FjaGVUeXBlQ29tcG9zaXRlX2hhcmRfd2VhazsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDYWNoZVR5cGVDb21wb3NpdGVfbm9uZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDYWNoZVR5cGVDb21wb3NpdGVfc29mdDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDYWNoZVR5cGVDb21wb3NpdGVfc29mdF93ZWFrOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENhY2hlVHlwZUNvbXBvc2l0ZV93ZWFrOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgRGVmYXVsdENhY2hlU2l6ZUNvbXBvc2l0ZV9kZWZhdWx0Q2FjaGVTaXplOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgRGVmYXVsdENhY2hlVHlwZUNvbXBvc2l0ZV9mdWxsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIERlZmF1bHRDYWNoZVR5cGVDb21wb3NpdGVfaGFyZF93ZWFrOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIERlZmF1bHRDYWNoZVR5cGVDb21wb3NpdGVfbm9uZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBEZWZhdWx0Q2FjaGVUeXBlQ29tcG9zaXRlX3NvZnQ7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRGVmYXVsdENhY2hlVHlwZUNvbXBvc2l0ZV9zb2Z0X3dlYWs7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRGVmYXVsdENhY2hlVHlwZUNvbXBvc2l0ZV93ZWFrOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgRW50aXR5RGlhbG9nX3NlbGVjdEVudGl0eTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBFbnRpdHlEaWFsb2dfbmFtZTsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENhY2hpbmdFbnRpdHlMaXN0Q29tcG9zaXRlX2dyb3VwVGl0bGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ2FjaGluZ0VudGl0eUxpc3RDb21wb3NpdGVfZWRpdEJ1dHRvbjsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENhY2hpbmdFbnRpdHlMaXN0Q29tcG9zaXRlX2RpYWxvZ01lc3NhZ2U7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ2FjaGluZ0VudGl0eUxpc3RDb21wb3NpdGVfZGlhbG9nVGl0bGU7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbENhY2hpbmdUYWJfRmx1c2hDbGVhckNhY2hlTGFiZWw7Ci0JCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgRmx1c2hDbGVhckNhY2hlQ29tcG9zaXRlX2Ryb3A7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRmx1c2hDbGVhckNhY2hlQ29tcG9zaXRlX2Ryb3BfaW52YWxpZGF0ZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBGbHVzaENsZWFyQ2FjaGVDb21wb3NpdGVfbWVyZ2U7Ci0JCi0JLy8gQ3VzdG9taXphdGlvbgotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl90aXRsZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfc2VjdGlvblRpdGxlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl9zZWN0aW9uRGVzY3JpcHRpb247Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX2RlZmF1bHRXaXRoT25lUGFyYW07Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0xhYmVsOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3dlYXZpbmdMYXp5TGFiZWxEZWZhdWx0OwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl93ZWF2aW5nTGF6eUxhYmVsOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3dlYXZpbmdDaGFuZ2VUcmFja2luZ0xhYmVsRGVmYXVsdDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0NoYW5nZVRyYWNraW5nTGFiZWw7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0ZldGNoR3JvdXBzTGFiZWxEZWZhdWx0OwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl93ZWF2aW5nRmV0Y2hHcm91cHNMYWJlbDsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl93ZWF2aW5nSW50ZXJuYWxMYWJlbERlZmF1bHQ7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3dlYXZpbmdJbnRlcm5hbExhYmVsOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3dlYXZpbmdFYWdlckxhYmVsRGVmYXVsdDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0VhZ2VyTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX2RlZmF1bHRFbXB0eTsKLQkKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfdGhyb3dFeGNlcHRpb25zTGFiZWxEZWZhdWx0OwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl90aHJvd0V4Y2VwdGlvbnNMYWJlbDsKLQkKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfZXhjZXB0aW9uSGFuZGxlckxhYmVsOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgV2VhdmluZ0NvbXBvc2l0ZV90cnVlXzsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBXZWF2aW5nQ29tcG9zaXRlX2ZhbHNlXzsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBXZWF2aW5nQ29tcG9zaXRlX3N0YXRpY187Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDdXN0b21pemF0aW9uRW50aXR5TGlzdENvbXBvc2l0ZV9ncm91cFRpdGxlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEN1c3RvbWl6YXRpb25FbnRpdHlMaXN0Q29tcG9zaXRlX2VkaXRCdXR0b247Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDdXN0b21pemF0aW9uRW50aXR5TGlzdENvbXBvc2l0ZV9kaWFsb2dNZXNzYWdlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEN1c3RvbWl6YXRpb25FbnRpdHlMaXN0Q29tcG9zaXRlX2RpYWxvZ1RpdGxlOwotCQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl9jdXN0b21pemVyTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3Nlc3Npb25DdXN0b21pemVyTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX25vTmFtZTsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl92YWxpZGF0aW9uT25seUxhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl92YWxpZGF0aW9uT25seUxhYmVsRGVmYXVsdDsKLQkKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfcHJvZmlsZXJMYWJlbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfYnJvd3NlOwotCQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFByb2ZpbGVyQ29tcG9zaXRlX3BlcmZvcm1hbmNlX3Byb2ZpbGVyOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFByb2ZpbGVyQ29tcG9zaXRlX3F1ZXJ5X21vbml0b3I7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUHJvZmlsZXJDb21wb3NpdGVfbm9fcHJvZmlsZXI7Ci0KLQkvLyBMb2dnaW5nCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiX3RpdGxlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl9zZWN0aW9uVGl0bGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiX3NlY3Rpb25EZXNjcmlwdGlvbjsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfZGVmYXVsdFdpdGhPbmVQYXJhbTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfZGVmYXVsdEVtcHR5OwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiX2xvZ2dpbmdMZXZlbExhYmVsOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgTG9nZ2luZ0xldmVsQ29tcG9zaXRlX29mZjsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBMb2dnaW5nTGV2ZWxDb21wb3NpdGVfc2V2ZXJlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIExvZ2dpbmdMZXZlbENvbXBvc2l0ZV93YXJuaW5nOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIExvZ2dpbmdMZXZlbENvbXBvc2l0ZV9pbmZvOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIExvZ2dpbmdMZXZlbENvbXBvc2l0ZV9jb25maWc7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgTG9nZ2luZ0xldmVsQ29tcG9zaXRlX2ZpbmU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgTG9nZ2luZ0xldmVsQ29tcG9zaXRlX2ZpbmVyOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIExvZ2dpbmdMZXZlbENvbXBvc2l0ZV9maW5lc3Q7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgTG9nZ2luZ0xldmVsQ29tcG9zaXRlX2FsbDsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl9sb2dnZXJMYWJlbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfYnJvd3NlOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgTG9nZ2VyQ29tcG9zaXRlX2RlZmF1bHRfbG9nZ2VyOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIExvZ2dlckNvbXBvc2l0ZV9qYXZhX2xvZ2dlcjsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBMb2dnZXJDb21wb3NpdGVfc2VydmVyX2xvZ2dlcjsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl90aW1lc3RhbXBMYWJlbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfdGltZXN0YW1wTGFiZWxEZWZhdWx0OwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl90aHJlYWRMYWJlbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfdGhyZWFkTGFiZWxEZWZhdWx0OwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl9zZXNzaW9uTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiX3Nlc3Npb25MYWJlbERlZmF1bHQ7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiX2V4Y2VwdGlvbnNMYWJlbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfZXhjZXB0aW9uc0xhYmVsRGVmYXVsdDsKLQkKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfbG9nZ2Vyc0xhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl9sb2dnaW5nRmlsZUxhYmVsOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgTG9nZ2luZ0ZpbGVMb2NhdGlvbkNvbXBvc2l0ZV9kaWFsb2dUaXRsZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBMb2dnaW5nRmlsZUxvY2F0aW9uQ29tcG9zaXRlX2RpYWxvZ01lc3NhZ2U7Ci0KLQkvLyBTZXNzaW9uIE9wdGlvbnMKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfdGl0bGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX3Nlc3Npb25TZWN0aW9uVGl0bGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX3Nlc3Npb25TZWN0aW9uRGVzY3JpcHRpb247Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX2RlZmF1bHRXaXRoT25lUGFyYW07Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX2RlZmF1bHRFbXB0eTsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl9zZXNzaW9uTmFtZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfc2Vzc2lvbnNYbWw7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfaW5jbHVkZURlc2NyaXB0b3JRdWVyaWVzTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX2luY2x1ZGVEZXNjcmlwdG9yUXVlcmllc0xhYmVsRGVmYXVsdDsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl9ldmVudExpc3RlbmVyTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX3RhcmdldERhdGFiYXNlTGFiZWw7Ci0JCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX21pc2NlbGxhbmVvdXNTZWN0aW9uVGl0bGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX21pc2NlbGxhbmVvdXNTZWN0aW9uRGVzY3JpcHRpb247Ci0JCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX3RlbXBvcmFsTXV0YWJsZUxhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl90ZW1wb3JhbE11dGFibGVMYWJlbERlZmF1bHQ7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9hdHR1bml0eTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9hdXRvOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFRhcmdldERhdGFiYXNlQ29tcG9zaXRlX2Nsb3Vkc2NhcGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGVfZGF0YWJhc2U7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGVfZGIyOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFRhcmdldERhdGFiYXNlQ29tcG9zaXRlX2RiMm1haW5mcmFtZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9kYmFzZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9kZXJieTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9oc3FsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFRhcmdldERhdGFiYXNlQ29tcG9zaXRlX2luZm9ybWl4OwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFRhcmdldERhdGFiYXNlQ29tcG9zaXRlX2phdmFkYjsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9teXNxbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9vcmFjbGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGVfb3JhY2xlMTE7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGVfb3JhY2xlMTA7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGVfb3JhY2xlOTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9vcmFjbGU4OwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFRhcmdldERhdGFiYXNlQ29tcG9zaXRlX3BvaW50YmFzZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9wb3N0Z3Jlc3FsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFRhcmdldERhdGFiYXNlQ29tcG9zaXRlX3NxbGFueXdoZXJlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFRhcmdldERhdGFiYXNlQ29tcG9zaXRlX3NxbHNlcnZlcjsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUYXJnZXREYXRhYmFzZUNvbXBvc2l0ZV9zeWJhc2U7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGVfdGltZXN0ZW47Ci0JICAgCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX3RhcmdldFNlcnZlckxhYmVsOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgVGFyZ2V0U2VydmVyQ29tcG9zaXRlX25vbmU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgVGFyZ2V0U2VydmVyQ29tcG9zaXRlX29jNGo7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgVGFyZ2V0U2VydmVyQ29tcG9zaXRlX3N1bmFzOTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUYXJnZXRTZXJ2ZXJDb21wb3NpdGVfd2Vic3BoZXJlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFRhcmdldFNlcnZlckNvbXBvc2l0ZV93ZWJzcGhlcmVfNl8xOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFRhcmdldFNlcnZlckNvbXBvc2l0ZV93ZWJsb2dpYzsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUYXJnZXRTZXJ2ZXJDb21wb3NpdGVfd2VibG9naWNfOTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUYXJnZXRTZXJ2ZXJDb21wb3NpdGVfd2VibG9naWNfMTA7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgVGFyZ2V0U2VydmVyQ29tcG9zaXRlX2pib3NzOwotCi0JLy8gRERMIEdlbmVyYXRpb24KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBFY2xpcHNlTGlua0RETEdlbmVyYXRvclVpX2dlbmVyYXRpbmdERExXYXJuaW5nVGl0bGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRWNsaXBzZUxpbmtERExHZW5lcmF0b3JVaV9nZW5lcmF0aW5nRERMV2FybmluZ01lc3NhZ2U7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRWNsaXBzZUxpbmtERExHZW5lcmF0b3JVaV9lcnJvcjsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBCVU5ETEVfTkFNRSA9ICJlY2xpcHNlbGlua191aSI7IC8vJE5PTi1OTFMtMSQKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBDbGFzczw/PiBCVU5ETEVfQ0xBU1MgPSBFY2xpcHNlTGlua1VpTWVzc2FnZXMuY2xhc3M7Ci0Jc3RhdGljIHsKLQkJTkxTLmluaXRpYWxpemVNZXNzYWdlcyhCVU5ETEVfTkFNRSwgQlVORExFX0NMQVNTKTsKLQl9Ci0JCi0JcHJpdmF0ZSBFY2xpcHNlTGlua1VpTWVzc2FnZXMoKSB7Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvZGRsZ2VuL0VjbGlwc2VMaW5rRERMR2VuZXJhdG9yVWkuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2RkbGdlbi9FY2xpcHNlTGlua0RETEdlbmVyYXRvclVpLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGU4YjI1Y2IuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvZGRsZ2VuL0VjbGlwc2VMaW5rRERMR2VuZXJhdG9yVWkuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE2NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSogCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLmRkbGdlbjsKLQotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklXb3Jrc3BhY2VSdW5uYWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5SZXNvdXJjZXNQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkNvcmVFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklQcm9ncmVzc01vbml0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLk51bGxQcm9ncmVzc01vbml0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLk9wZXJhdGlvbkNhbmNlbGVkRXhjZXB0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLmRpYWxvZ3MuTWVzc2FnZURpYWxvZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS53aW5kb3cuV2luZG93OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLndpemFyZC5XaXphcmREaWFsb2c7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuSnBhUGxhdGZvcm07Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuSnBhUHJvamVjdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LnBlcnNpc3RlbmNlLlBlcnNpc3RlbmNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQucGVyc2lzdGVuY2UuUGVyc2lzdGVuY2VVbml0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmRkbGdlbi5FY2xpcHNlTGlua0RETEdlbmVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5kZGxnZW4ud2l6YXJkcy5HZW5lcmF0ZURETFdpemFyZDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5EaXNwbGF5OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLlNoZWxsOwotCi0vKioKLSAqICBFY2xpcHNlTGlua0RMTEdlbmVyYXRvclVpIGlzIHVzZWQgYnkgdGhlIEVjbGlwc2VMaW5rUGxhdGZvcm1VaSB0byBpbml0aWF0ZSAKLSAqICB0aGUgZXhlY3V0aW9uIG9mIEVjbGlwc2VMaW5rIERETCBnZW5lcmF0b3IuCi0gKi8KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua0RETEdlbmVyYXRvclVpCi17Ci0JcHJpdmF0ZSBmaW5hbCBKcGFQcm9qZWN0IHByb2plY3Q7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIENSID0gU3RyaW5nVG9vbHMuQ1I7Ci0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0JCi0JcHVibGljIHN0YXRpYyB2b2lkIGdlbmVyYXRlKEpwYVByb2plY3QgcHJvamVjdCkgewotCQluZXcgRWNsaXBzZUxpbmtERExHZW5lcmF0b3JVaShwcm9qZWN0KS5nZW5lcmF0ZSgpOwotCX0KLQotCXByaXZhdGUgRWNsaXBzZUxpbmtERExHZW5lcmF0b3JVaShKcGFQcm9qZWN0IHByb2plY3QpIHsKLQkJc3VwZXIoKTsKLQkJaWYgKHByb2plY3QgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy5wcm9qZWN0ID0gcHJvamVjdDsKLQl9Ci0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQkKLQlwcm90ZWN0ZWQgdm9pZCBnZW5lcmF0ZSgpIHsKLQkJCi0JCVBlcnNpc3RlbmNlVW5pdCBwZXJzaXN0ZW5jZVVuaXQgPSB0aGlzLmdldFBlcnNpc3RlbmNlVW5pdHMoKS5uZXh0KCk7IC8vIFRha2UgdGhlIGZpcnN0IHBlcnNpc3RlbmNlVW5pdAotCQlTdHJpbmcgcHVOYW1lID0gcGVyc2lzdGVuY2VVbml0LmdldE5hbWUoKTsKLQkJaWYoICEgdGhpcy5kaXNwbGF5R2VuZXJhdGluZ0RETFdhcm5pbmcoKSkgewotCQkJcmV0dXJuOwotCQl9Ci0JCQotCQlHZW5lcmF0ZURETFdpemFyZCB3aXphcmQgPSBuZXcgR2VuZXJhdGVERExXaXphcmQodGhpcy5wcm9qZWN0KTsKLQkJV2l6YXJkRGlhbG9nIGRpYWxvZyA9IG5ldyBXaXphcmREaWFsb2codGhpcy5nZXRDdXJyZW50U2hlbGwoKSwgd2l6YXJkKTsKLQkJZGlhbG9nLmNyZWF0ZSgpOwotCQlpZih3aXphcmQuZ2V0UGFnZUNvdW50KCkgPiAwKSB7Ci0JCQlpbnQgcmV0dXJuQ29kZSA9IGRpYWxvZy5vcGVuKCk7Ci0JCQlpZiAocmV0dXJuQ29kZSA9PSBXaW5kb3cuQ0FOQ0VMKSB7Ci0JCQkJcmV0dXJuOwotCQkJfQotCQl9Ci0JCUlXb3Jrc3BhY2VSdW5uYWJsZSBydW5uYWJsZSA9IG5ldyBHZW5lcmF0ZURETFJ1bm5hYmxlKHB1TmFtZSwgdGhpcy5wcm9qZWN0KTsKLQkJdHJ5IHsKLQkJCVJlc291cmNlc1BsdWdpbi5nZXRXb3Jrc3BhY2UoKS5ydW4ocnVubmFibGUsIG5ldyBOdWxsUHJvZ3Jlc3NNb25pdG9yKCkpOwotCQl9IAotCQljYXRjaCAoQ29yZUV4Y2VwdGlvbiBleCkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oZXgpOwotCQl9Ci0JfQotCQotCXByaXZhdGUgU2hlbGwgZ2V0Q3VycmVudFNoZWxsKCkgewotCSAgICByZXR1cm4gRGlzcGxheS5nZXRDdXJyZW50KCkuZ2V0QWN0aXZlU2hlbGwoKTsKLQl9Ci0KLQlwcml2YXRlIGJvb2xlYW4gZGlzcGxheUdlbmVyYXRpbmdERExXYXJuaW5nKCkgewotCQlTdHJpbmcgbWVzc2FnZSA9IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFMuYmluZCgKLQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5FY2xpcHNlTGlua0RETEdlbmVyYXRvclVpX2dlbmVyYXRpbmdERExXYXJuaW5nTWVzc2FnZSwKLQkJCUNSLCAgQ1IgKyBDUik7Ci0JCQkKLQkJcmV0dXJuIE1lc3NhZ2VEaWFsb2cub3BlblF1ZXN0aW9uKAotCQkJdGhpcy5nZXRDdXJyZW50U2hlbGwoKSwgCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuRWNsaXBzZUxpbmtERExHZW5lcmF0b3JVaV9nZW5lcmF0aW5nRERMV2FybmluZ1RpdGxlLCAKLQkJCW1lc3NhZ2UpOwotCX0KLQotCS8vICoqKioqKioqKiogUGVyc2lzdGVuY2UgVW5pdCAqKioqKioqKioqCi0KLQlwcm90ZWN0ZWQgSnBhUGxhdGZvcm0gZ2V0UGxhdGZvcm0oKSB7Ci0JCXJldHVybiB0aGlzLnByb2plY3QuZ2V0SnBhUGxhdGZvcm0oKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIEl0ZXJhdG9yPFBlcnNpc3RlbmNlVW5pdD4gZ2V0UGVyc2lzdGVuY2VVbml0cygpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0UGVyc2lzdGVuY2UoKS5wZXJzaXN0ZW5jZVVuaXRzKCk7Ci0JfQotCi0JcHJvdGVjdGVkIFBlcnNpc3RlbmNlIGdldFBlcnNpc3RlbmNlKCkgewotCQlyZXR1cm4gdGhpcy5wcm9qZWN0LmdldFJvb3RDb250ZXh0Tm9kZSgpLmdldFBlcnNpc3RlbmNlWG1sKCkuZ2V0UGVyc2lzdGVuY2UoKTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIHJ1bm5hYmxlICoqKioqKioqKioKLQotCXN0YXRpYyBjbGFzcyBHZW5lcmF0ZURETFJ1bm5hYmxlIGltcGxlbWVudHMgSVdvcmtzcGFjZVJ1bm5hYmxlIHsKLQkJcHJpdmF0ZSBmaW5hbCBTdHJpbmcgcHVOYW1lOwotCQlwcml2YXRlIGZpbmFsIEpwYVByb2plY3QgcHJvamVjdDsKLQotCQlHZW5lcmF0ZURETFJ1bm5hYmxlKFN0cmluZyBwdU5hbWUsIEpwYVByb2plY3QgcHJvamVjdCkgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMucHVOYW1lID0gcHVOYW1lOwotCQkJdGhpcy5wcm9qZWN0ID0gcHJvamVjdDsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIHJ1bihJUHJvZ3Jlc3NNb25pdG9yIG1vbml0b3IpIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKLQkJCVN0cmluZyBwcm9qZWN0TG9jYXRpb24gPSB0aGlzLnByb2plY3QuZ2V0UHJvamVjdCgpLmdldExvY2F0aW9uKCkudG9TdHJpbmcoKTsKLQkJCXRyeSB7Ci0JCQkJRWNsaXBzZUxpbmtERExHZW5lcmF0b3IuZ2VuZXJhdGUodGhpcy5wdU5hbWUsIHRoaXMucHJvamVjdCwgcHJvamVjdExvY2F0aW9uLCBtb25pdG9yKTsKLQkJCX0gCi0JCQljYXRjaCAoT3BlcmF0aW9uQ2FuY2VsZWRFeGNlcHRpb24gZSkgewotCQkJCXJldHVybjsKLQkJCQkvLyBmYWxsIHRocm91Z2ggYW5kIHRlbGwgbW9uaXRvciB3ZSBhcmUgZG9uZQotCQkJfQotCQkJY2F0Y2ggKFJ1bnRpbWVFeGNlcHRpb24gcmUpIHsKLQkJCQlTdHJpbmcgbXNnID0gcmUuZ2V0TWVzc2FnZSgpOwotCQkJCVN0cmluZyBtZXNzYWdlID0gKG1zZyA9PSBudWxsKSA/IHJlLnRvU3RyaW5nKCkgOiBtc2c7Ci0JCQkJCi0JCQkJdGhpcy5sb2dFcnJvcihtZXNzYWdlKTsKLQkJCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihyZSk7Ci0JCQl9Ci0JCX0KLQotCQlwcm90ZWN0ZWQgdm9pZCBsb2dFcnJvcihTdHJpbmcgbWVzc2FnZSkgewotCQkJCXRoaXMuZGlzcGxheUVycm9yKG1lc3NhZ2UpOwotCQl9Ci0JCQotCQlwcml2YXRlIHZvaWQgZGlzcGxheUVycm9yKFN0cmluZyBtZXNzYWdlKSB7Ci0JCQlNZXNzYWdlRGlhbG9nLm9wZW5FcnJvcigKLQkJCQkJZ2V0U2hlbGwoKSwKLQkJCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkVjbGlwc2VMaW5rRERMR2VuZXJhdG9yVWlfZXJyb3IsCi0JCQkJCW1lc3NhZ2UKLQkJCQkpOwotCQl9Ci0KLQkJcHJpdmF0ZSBTaGVsbCBnZXRTaGVsbCgpIHsKLQkJCURpc3BsYXkgZGlzcGxheSA9IERpc3BsYXkuZ2V0Q3VycmVudCgpOwotCQkJU2hlbGwgc2hlbGwgPSAoZGlzcGxheSA9PSBudWxsKSA/IG51bGwgOiBkaXNwbGF5LmdldEFjdGl2ZVNoZWxsKCk7Ci0JCQlpZiAoc2hlbGwgPT0gbnVsbCAmJiBkaXNwbGF5ICE9IG51bGwpIHsKLQkJCQlTaGVsbFtdIHNoZWxscyA9IGRpc3BsYXkuZ2V0U2hlbGxzKCk7Ci0JCQkJaWYgKHNoZWxscy5sZW5ndGggPiAwKQotCQkJCQlzaGVsbCA9IHNoZWxsc1swXTsKLQkJCX0KLQkJCXJldHVybiBzaGVsbDsKLQkJfQotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2RkbGdlbi93aXphcmRzL0dlbmVyYXRlRERMV2l6YXJkLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9kZGxnZW4vd2l6YXJkcy9HZW5lcmF0ZURETFdpemFyZC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzNjRlNWIyLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2RkbGdlbi93aXphcmRzL0dlbmVyYXRlRERMV2l6YXJkLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSogCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLmRkbGdlbi53aXphcmRzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uud2l6YXJkLldpemFyZDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcGFQcm9qZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5Db25uZWN0aW9uUHJvZmlsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuSnB0VWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2l6YXJkcy5EYXRhYmFzZVNjaGVtYVdpemFyZFBhZ2U7Ci0KLS8qKgotICogIEdlbmVyYXRlRERMV2l6YXJkCi0gKi8KLXB1YmxpYyBjbGFzcyBHZW5lcmF0ZURETFdpemFyZCBleHRlbmRzIFdpemFyZCB7CQotCi0JcHJpdmF0ZSBKcGFQcm9qZWN0IGpwYVByb2plY3Q7Ci0KLQlwcml2YXRlIERhdGFiYXNlU2NoZW1hV2l6YXJkUGFnZSBkYlNldHRpbmdzUGFnZTsKLQotCXB1YmxpYyBHZW5lcmF0ZURETFdpemFyZChKcGFQcm9qZWN0IGpwYVByb2plY3QpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5qcGFQcm9qZWN0ID0ganBhUHJvamVjdDsKLQkJdGhpcy5zZXRXaW5kb3dUaXRsZShKcHRVaU1lc3NhZ2VzLkdlbmVyYXRlRERMV2l6YXJkX3RpdGxlKTsgCi0JfQotCQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGFkZFBhZ2VzKCkgewotCQlzdXBlci5hZGRQYWdlcygpOwotCQlpZiAodGhpcy5nZXRKcGFQcm9qZWN0Q29ubmVjdGlvblByb2ZpbGUoKSA9PSBudWxsKSB7Ci0JCQl0aGlzLmRiU2V0dGluZ3NQYWdlID0gbmV3IERhdGFiYXNlU2NoZW1hV2l6YXJkUGFnZSh0aGlzLmpwYVByb2plY3QpOwotCQkJdGhpcy5hZGRQYWdlKHRoaXMuZGJTZXR0aW5nc1BhZ2UpOwotCQl9Ci0JfQotCQotCUBPdmVycmlkZQotCXB1YmxpYyBib29sZWFuIHBlcmZvcm1GaW5pc2goKSB7Ci0JCXJldHVybiAodGhpcy5nZXRKcGFQcm9qZWN0Q29ubmVjdGlvblByb2ZpbGUoKSAhPSBudWxsKTsKLQl9Ci0gICAgCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIGJvb2xlYW4gY2FuRmluaXNoKCkgewotICAgICAgICByZXR1cm4gdGhpcy5kYlNldHRpbmdzUGFnZS5pc1BhZ2VDb21wbGV0ZSgpOwotICAgIH0KLSAgICAKLQlwcml2YXRlIENvbm5lY3Rpb25Qcm9maWxlIGdldEpwYVByb2plY3RDb25uZWN0aW9uUHJvZmlsZSgpIHsKLQkJcmV0dXJuIHRoaXMuanBhUHJvamVjdC5nZXRDb25uZWN0aW9uUHJvZmlsZSgpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0NvbnZlcnRlcnNDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2phdmEvZGV0YWlscy9Db252ZXJ0ZXJzQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGIxMTQxMTYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0NvbnZlcnRlcnNDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI3MSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLmphdmEuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQ3VzdG9tQ29udmVydGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuT2JqZWN0VHlwZUNvbnZlcnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LlN0cnVjdENvbnZlcnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LlR5cGVDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5qYXZhLkphdmFDb252ZXJ0ZXJIb2xkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLkVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkN1c3RvbUNvbnZlcnRlckNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5PYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLlN0cnVjdENvbnZlcnRlckNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5UeXBlQ29udmVydGVyQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLlBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5CdXR0b247Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIEhlcmUgdGhlIGxheW91dCBvZiB0aGlzIHBhbmU6Ci0gKiA8cHJlPgotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLSAqIHwgWCBDdXN0b21Db252ZXJ0ZXIgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0gKiB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogfCAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgICB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8ICAgfCBDdXN0b21Db252ZXJ0ZXJDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogfCBYIFR5cGUgQ29udmVydGVyICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0gKiB8ICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgICB8IFR5cGVDb252ZXJ0ZXJDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8ICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0gKiB8IFggT2plY3QgVHlwZSBDb252ZXJ0ZXIgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIHwgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8ICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAgIHwgT2JqZWN0VHlwZUNvbnZlcnRlckNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgICB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8ICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIHwgWCBTdHJ1Y3QgQ29udmVydGVyICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0gKiB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogfCAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgICB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8ICAgfCBTdHJ1Y3RDb252ZXJ0ZXJDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLTwvcHJlPgotICoKLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIENvbnZlcnRlcnNDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPEphdmFDb252ZXJ0ZXJIb2xkZXI+Ci17Ci0KLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkNvbnZlcnNpb25Db21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudFBhbmUgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIENvbnZlcnRlcnNDb21wb3NpdGUoUGFuZTw/PiBwYXJlbnRQYW5lLAotCQkJCQkJCQlQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIEphdmFDb252ZXJ0ZXJIb2xkZXI+IHN1YmplY3RIb2xkZXIsCi0JCQkJCQkJCUNvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRQYW5lLCBzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIGZhbHNlKTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJaW5pdGlhbGl6ZUNvbnZlcnRlclBhbmUoY29udGFpbmVyKTsKLQl9Ci0JCi0JcHJpdmF0ZSB2b2lkIGluaXRpYWxpemVDb252ZXJ0ZXJQYW5lKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJLy8gQ3VzdG9tIENvbnZlcnRlciBjaGVjayBib3gKLQkJQnV0dG9uIGN1c3RvbUNvbnZlcnRlckNoZWNrQm94ID0gYWRkQ2hlY2tCb3goCi0JCQlhZGRTdWJQYW5lKGNvbnRhaW5lciwgNSksCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJ0ZXJzQ29tcG9zaXRlX2N1c3RvbUNvbnZlcnRlciwKLQkJCWJ1aWxkQ3VzdG9tQ29udmVydGVyQm9vbGVhbkhvbGRlcigpLAotCQkJbnVsbAotCQkpOwotCi0JCS8vIEN1c3RvbSBDb252ZXJ0ZXIgcGFuZQotCQlDdXN0b21Db252ZXJ0ZXJDb21wb3NpdGUgY3VzdG9tQ29udmVydGVyQ29tcG9zaXRlID0gbmV3IEN1c3RvbUNvbnZlcnRlckNvbXBvc2l0ZSgKLQkJCWJ1aWxkQ3VzdG9tQ29udmVydGVySG9sZGVyKCksCi0JCQlhZGRTdWJQYW5lKGNvbnRhaW5lciwgMCwgY3VzdG9tQ29udmVydGVyQ2hlY2tCb3guZ2V0Qm9yZGVyV2lkdGgoKSArIDE2KSwKLQkJCWdldFdpZGdldEZhY3RvcnkoKQotCQkpOwotCQlyZWdpc3RlclN1YlBhbmUoY3VzdG9tQ29udmVydGVyQ29tcG9zaXRlKTsKLQkKLQkJCi0JCS8vIFR5cGUgQ29udmVydGVyIGNoZWNrIGJveAotCQlCdXR0b24gdHlwZUNvbnZlcnRlckNoZWNrQm94ID0gYWRkQ2hlY2tCb3goCi0JCQlhZGRTdWJQYW5lKGNvbnRhaW5lciwgNSksCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJ0ZXJzQ29tcG9zaXRlX3R5cGVDb252ZXJ0ZXIsCi0JCQlidWlsZFR5cGVDb252ZXJ0ZXJCb29sZWFuSG9sZGVyKCksCi0JCQludWxsCi0JCSk7Ci0KLQkJLy8gVHlwZSBDb252ZXJ0ZXIgcGFuZQotCQlUeXBlQ29udmVydGVyQ29tcG9zaXRlIHR5cGVDb252ZXJ0ZXJDb21wb3NpdGUgPSBuZXcgVHlwZUNvbnZlcnRlckNvbXBvc2l0ZSgKLQkJCWJ1aWxkVHlwZUNvbnZlcnRlckhvbGRlcigpLAotCQkJYWRkU3ViUGFuZShjb250YWluZXIsIDAsIHR5cGVDb252ZXJ0ZXJDaGVja0JveC5nZXRCb3JkZXJXaWR0aCgpICsgMTYpLAotCQkJZ2V0V2lkZ2V0RmFjdG9yeSgpCi0JCSk7Ci0JCXJlZ2lzdGVyU3ViUGFuZSh0eXBlQ29udmVydGVyQ29tcG9zaXRlKTsKLQkJCi0JCS8vIE9iamVjdCBUeXBlIENvbnZlcnRlciBjaGVjayBib3gKLQkJQnV0dG9uIG9iamVjdFR5cGVDb252ZXJ0ZXJDaGVja0JveCA9IGFkZENoZWNrQm94KAotCQkJYWRkU3ViUGFuZShjb250YWluZXIsIDUpLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQ29udmVydGVyc0NvbXBvc2l0ZV9vYmplY3RUeXBlQ29udmVydGVyLAotCQkJYnVpbGRPYmplY3RUeXBlQ29udmVydGVyQm9vbGVhbkhvbGRlcigpLAotCQkJbnVsbAotCQkpOwotCi0JCS8vIE9iamVjdCBUeXBlIENvbnZlcnRlciBwYW5lCi0JCU9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGUgb2JqZWN0VHlwZUNvbnZlcnRlckNvbXBvc2l0ZSA9IG5ldyBPYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlKAotCQkJYnVpbGRPYmplY3RUeXBlQ29udmVydGVySG9sZGVyKCksCi0JCQlhZGRTdWJQYW5lKGNvbnRhaW5lciwgMCwgb2JqZWN0VHlwZUNvbnZlcnRlckNoZWNrQm94LmdldEJvcmRlcldpZHRoKCkgKyAxNiksCi0JCQlnZXRXaWRnZXRGYWN0b3J5KCkKLQkJKTsKLQkJcmVnaXN0ZXJTdWJQYW5lKG9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGUpOwotCQkKLQkJLy8gU3RydWN0IENvbnZlcnRlciBjaGVjayBib3gKLQkJQnV0dG9uIHN0cnVjdENvbnZlcnRlckNoZWNrQm94ID0gYWRkQ2hlY2tCb3goCi0JCQlhZGRTdWJQYW5lKGNvbnRhaW5lciwgNSksCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJ0ZXJzQ29tcG9zaXRlX3N0cnVjdENvbnZlcnRlciwKLQkJCWJ1aWxkU3RydWN0Q29udmVydGVyQm9vbGVhbkhvbGRlcigpLAotCQkJbnVsbAotCQkpOwotCi0JCS8vIFN0cnVjdCBDb252ZXJ0ZXIgcGFuZQotCQlTdHJ1Y3RDb252ZXJ0ZXJDb21wb3NpdGUgc3RydWN0Q29udmVydGVyQ29tcG9zaXRlID0gbmV3IFN0cnVjdENvbnZlcnRlckNvbXBvc2l0ZSgKLQkJCWJ1aWxkU3RydWN0Q29udmVydGVySG9sZGVyKCksCi0JCQlhZGRTdWJQYW5lKGNvbnRhaW5lciwgMCwgc3RydWN0Q29udmVydGVyQ2hlY2tCb3guZ2V0Qm9yZGVyV2lkdGgoKSArIDE2KSwKLQkJCWdldFdpZGdldEZhY3RvcnkoKQotCQkpOwotCQlyZWdpc3RlclN1YlBhbmUoc3RydWN0Q29udmVydGVyQ29tcG9zaXRlKTsKLQl9Ci0JCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZEN1c3RvbUNvbnZlcnRlckJvb2xlYW5Ib2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEphdmFDb252ZXJ0ZXJIb2xkZXIsIEJvb2xlYW4+KGdldFN1YmplY3RIb2xkZXIoKSwgSmF2YUNvbnZlcnRlckhvbGRlci5DVVNUT01fQ09OVkVSVEVSX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBCb29sZWFuLnZhbHVlT2YodGhpcy5zdWJqZWN0LmdldEN1c3RvbUNvbnZlcnRlcigpICE9IG51bGwpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJaWYgKHZhbHVlLmJvb2xlYW5WYWx1ZSgpICYmICh0aGlzLnN1YmplY3QuZ2V0Q3VzdG9tQ29udmVydGVyKCkgPT0gbnVsbCkpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LmFkZEN1c3RvbUNvbnZlcnRlcigpOwotCQkJCX0KLQkJCQllbHNlIGlmICghdmFsdWUuYm9vbGVhblZhbHVlKCkgJiYgKHRoaXMuc3ViamVjdC5nZXRDdXN0b21Db252ZXJ0ZXIoKSAhPSBudWxsKSkgewotCQkJCQl0aGlzLnN1YmplY3QucmVtb3ZlQ3VzdG9tQ29udmVydGVyKCk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQkKLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxDdXN0b21Db252ZXJ0ZXI+IGJ1aWxkQ3VzdG9tQ29udmVydGVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxKYXZhQ29udmVydGVySG9sZGVyLCBDdXN0b21Db252ZXJ0ZXI+KGdldFN1YmplY3RIb2xkZXIoKSwgSmF2YUNvbnZlcnRlckhvbGRlci5DVVNUT01fQ09OVkVSVEVSX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDdXN0b21Db252ZXJ0ZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRDdXN0b21Db252ZXJ0ZXIoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZFR5cGVDb252ZXJ0ZXJCb29sZWFuSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxKYXZhQ29udmVydGVySG9sZGVyLCBCb29sZWFuPihnZXRTdWJqZWN0SG9sZGVyKCksIEphdmFDb252ZXJ0ZXJIb2xkZXIuVFlQRV9DT05WRVJURVJfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIEJvb2xlYW4udmFsdWVPZih0aGlzLnN1YmplY3QuZ2V0VHlwZUNvbnZlcnRlcigpICE9IG51bGwpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJaWYgKHZhbHVlLmJvb2xlYW5WYWx1ZSgpICYmICh0aGlzLnN1YmplY3QuZ2V0VHlwZUNvbnZlcnRlcigpID09IG51bGwpKSB7Ci0JCQkJCXRoaXMuc3ViamVjdC5hZGRUeXBlQ29udmVydGVyKCk7Ci0JCQkJfQotCQkJCWVsc2UgaWYgKCF2YWx1ZS5ib29sZWFuVmFsdWUoKSAmJiAodGhpcy5zdWJqZWN0LmdldFR5cGVDb252ZXJ0ZXIoKSAhPSBudWxsKSkgewotCQkJCQl0aGlzLnN1YmplY3QucmVtb3ZlVHlwZUNvbnZlcnRlcigpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8VHlwZUNvbnZlcnRlcj4gYnVpbGRUeXBlQ29udmVydGVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxKYXZhQ29udmVydGVySG9sZGVyLCBUeXBlQ29udmVydGVyPihnZXRTdWJqZWN0SG9sZGVyKCksIEphdmFDb252ZXJ0ZXJIb2xkZXIuVFlQRV9DT05WRVJURVJfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFR5cGVDb252ZXJ0ZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRUeXBlQ29udmVydGVyKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRPYmplY3RUeXBlQ29udmVydGVyQm9vbGVhbkhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8SmF2YUNvbnZlcnRlckhvbGRlciwgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBKYXZhQ29udmVydGVySG9sZGVyLk9CSkVDVF9UWVBFX0NPTlZFUlRFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gQm9vbGVhbi52YWx1ZU9mKHRoaXMuc3ViamVjdC5nZXRPYmplY3RUeXBlQ29udmVydGVyKCkgIT0gbnVsbCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlpZiAodmFsdWUuYm9vbGVhblZhbHVlKCkgJiYgKHRoaXMuc3ViamVjdC5nZXRPYmplY3RUeXBlQ29udmVydGVyKCkgPT0gbnVsbCkpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LmFkZE9iamVjdFR5cGVDb252ZXJ0ZXIoKTsKLQkJCQl9Ci0JCQkJZWxzZSBpZiAoIXZhbHVlLmJvb2xlYW5WYWx1ZSgpICYmICh0aGlzLnN1YmplY3QuZ2V0T2JqZWN0VHlwZUNvbnZlcnRlcigpICE9IG51bGwpKSB7Ci0JCQkJCXRoaXMuc3ViamVjdC5yZW1vdmVPYmplY3RUeXBlQ29udmVydGVyKCk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQkKLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3RUeXBlQ29udmVydGVyPiBidWlsZE9iamVjdFR5cGVDb252ZXJ0ZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEphdmFDb252ZXJ0ZXJIb2xkZXIsIE9iamVjdFR5cGVDb252ZXJ0ZXI+KGdldFN1YmplY3RIb2xkZXIoKSwgSmF2YUNvbnZlcnRlckhvbGRlci5PQkpFQ1RfVFlQRV9DT05WRVJURVJfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIE9iamVjdFR5cGVDb252ZXJ0ZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRPYmplY3RUeXBlQ29udmVydGVyKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRTdHJ1Y3RDb252ZXJ0ZXJCb29sZWFuSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxKYXZhQ29udmVydGVySG9sZGVyLCBCb29sZWFuPihnZXRTdWJqZWN0SG9sZGVyKCksIEphdmFDb252ZXJ0ZXJIb2xkZXIuU1RSVUNUX0NPTlZFUlRFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gQm9vbGVhbi52YWx1ZU9mKHRoaXMuc3ViamVjdC5nZXRTdHJ1Y3RDb252ZXJ0ZXIoKSAhPSBudWxsKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZS5ib29sZWFuVmFsdWUoKSAmJiAodGhpcy5zdWJqZWN0LmdldFN0cnVjdENvbnZlcnRlcigpID09IG51bGwpKSB7Ci0JCQkJCXRoaXMuc3ViamVjdC5hZGRTdHJ1Y3RDb252ZXJ0ZXIoKTsKLQkJCQl9Ci0JCQkJZWxzZSBpZiAoIXZhbHVlLmJvb2xlYW5WYWx1ZSgpICYmICh0aGlzLnN1YmplY3QuZ2V0U3RydWN0Q29udmVydGVyKCkgIT0gbnVsbCkpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LnJlbW92ZVN0cnVjdENvbnZlcnRlcigpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8U3RydWN0Q29udmVydGVyPiBidWlsZFN0cnVjdENvbnZlcnRlckhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8SmF2YUNvbnZlcnRlckhvbGRlciwgU3RydWN0Q29udmVydGVyPihnZXRTdWJqZWN0SG9sZGVyKCksIEphdmFDb252ZXJ0ZXJIb2xkZXIuU1RSVUNUX0NPTlZFUlRFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RydWN0Q29udmVydGVyIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0U3RydWN0Q29udmVydGVyKCk7Ci0JCQl9Ci0JCX07Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0RlZmF1bHRPbmVUb01hbnlNYXBwaW5nVWlQcm92aWRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0RlZmF1bHRPbmVUb01hbnlNYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiYmY2Y2MwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2phdmEvZGV0YWlscy9EZWZhdWx0T25lVG9NYW55TWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDg1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuamF2YS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLmNvbnRlbnQuSUNvbnRlbnRUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLkpwdENvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuTWFwcGluZ0tleXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5qYXZhLkphdmFPbmVUb01hbnlNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkRlZmF1bHRBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLkpwYU1hcHBpbmdJbWFnZUhlbHBlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuZGV0YWlscy5BYnN0cmFjdE9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuZ3JhcGhpY3MuSW1hZ2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRGVmYXVsdE9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyCi0JZXh0ZW5kcyBBYnN0cmFjdE9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyPEphdmFPbmVUb01hbnlNYXBwaW5nPgotCWltcGxlbWVudHMgRGVmYXVsdEF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyPEphdmFPbmVUb01hbnlNYXBwaW5nPgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIERlZmF1bHRPbmVUb01hbnlNYXBwaW5nVWlQcm92aWRlciBJTlNUQU5DRSA9IAotCQluZXcgRGVmYXVsdE9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBEZWZhdWx0QXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8SmF2YU9uZVRvTWFueU1hcHBpbmc+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBEZWZhdWx0T25lVG9NYW55TWFwcGluZ1VpUHJvdmlkZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0Q29yZVBsdWdpbi5KQVZBX1NPVVJDRV9DT05URU5UX1RZUEU7Ci0JfQotCQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgZ2V0S2V5KCkgewotCQlyZXR1cm4gbnVsbDsKLQl9Ci0JCi0JcHVibGljIFN0cmluZyBnZXREZWZhdWx0S2V5KCkgewotCQlyZXR1cm4gTWFwcGluZ0tleXMuT05FX1RPX01BTllfQVRUUklCVVRFX01BUFBJTkdfS0VZOwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIGdldExhYmVsKCkgewotCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRGVmYXVsdE9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyX2xhYmVsOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgZ2V0TGlua0xhYmVsKCkgewotCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRGVmYXVsdE9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyX2xpbmtMYWJlbDsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgSW1hZ2UgZ2V0SW1hZ2UoKSB7Ci0JCXJldHVybiBKcGFNYXBwaW5nSW1hZ2VIZWxwZXIuaW1hZ2VGb3JBdHRyaWJ1dGVNYXBwaW5nKGdldERlZmF1bHRLZXkoKSk7Ci0JfQotCQotCXB1YmxpYyBKcGFDb21wb3NpdGUgYnVpbGRBdHRyaWJ1dGVNYXBwaW5nQ29tcG9zaXRlKAotCQkJSnBhVWlGYWN0b3J5IGZhY3RvcnksCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8SmF2YU9uZVRvTWFueU1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBmYWN0b3J5LmNyZWF0ZUphdmFPbmVUb01hbnlNYXBwaW5nQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0RlZmF1bHRPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9qYXZhL2RldGFpbHMvRGVmYXVsdE9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODBmMjE0MC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9qYXZhL2RldGFpbHMvRGVmYXVsdE9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDg1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuamF2YS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLmNvbnRlbnQuSUNvbnRlbnRUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLkpwdENvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuTWFwcGluZ0tleXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5qYXZhLkphdmFPbmVUb09uZU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLkVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuRGVmYXVsdEF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuSnBhTWFwcGluZ0ltYWdlSGVscGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFic3RyYWN0T25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLkltYWdlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIERlZmF1bHRPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyCi0JZXh0ZW5kcyBBYnN0cmFjdE9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXI8SmF2YU9uZVRvT25lTWFwcGluZz4KLQlpbXBsZW1lbnRzIERlZmF1bHRBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxKYXZhT25lVG9PbmVNYXBwaW5nPgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIERlZmF1bHRPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBEZWZhdWx0T25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcigpOwotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgRGVmYXVsdEF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyPEphdmFPbmVUb09uZU1hcHBpbmc+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBEZWZhdWx0T25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCQotCXB1YmxpYyBJQ29udGVudFR5cGUgZ2V0Q29udGVudFR5cGUoKSB7Ci0JCXJldHVybiBKcHRDb3JlUGx1Z2luLkpBVkFfU09VUkNFX0NPTlRFTlRfVFlQRTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyBnZXRLZXkoKSB7Ci0JCXJldHVybiBudWxsOwotCX0KLQkKLQlwdWJsaWMgU3RyaW5nIGdldERlZmF1bHRLZXkoKSB7Ci0JCXJldHVybiBNYXBwaW5nS2V5cy5PTkVfVE9fT05FX0FUVFJJQlVURV9NQVBQSU5HX0tFWTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyBnZXRMYWJlbCgpIHsKLQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkRlZmF1bHRPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyX2xhYmVsOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgZ2V0TGlua0xhYmVsKCkgewotCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRGVmYXVsdE9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXJfbGlua0xhYmVsOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBJbWFnZSBnZXRJbWFnZSgpIHsKLQkJcmV0dXJuIEpwYU1hcHBpbmdJbWFnZUhlbHBlci5pbWFnZUZvckF0dHJpYnV0ZU1hcHBpbmcoZ2V0RGVmYXVsdEtleSgpKTsKLQl9Ci0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxKYXZhT25lVG9PbmVNYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gZmFjdG9yeS5jcmVhdGVKYXZhT25lVG9PbmVNYXBwaW5nQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0RlZmF1bHRWYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2phdmEvZGV0YWlscy9EZWZhdWx0VmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhmMDhiYTIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0RlZmF1bHRWYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDgxICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuamF2YS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLmNvbnRlbnQuSUNvbnRlbnRUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLkpwdENvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuRWNsaXBzZUxpbmtNYXBwaW5nS2V5czsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LmphdmEuSmF2YVZhcmlhYmxlT25lVG9PbmVNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5WYXJpYWJsZU9uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcHRVaVBsdWdpbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5EZWZhdWx0QXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5KcHRVaUljb25zOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuZ3JhcGhpY3MuSW1hZ2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRGVmYXVsdFZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcgotCWltcGxlbWVudHMgRGVmYXVsdEF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyPEphdmFWYXJpYWJsZU9uZVRvT25lTWFwcGluZz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBEZWZhdWx0VmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBEZWZhdWx0VmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBEZWZhdWx0QXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8SmF2YVZhcmlhYmxlT25lVG9PbmVNYXBwaW5nPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRGVmYXVsdFZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JcHVibGljIElDb250ZW50VHlwZSBnZXRDb250ZW50VHlwZSgpIHsKLQkJcmV0dXJuIEpwdENvcmVQbHVnaW4uSkFWQV9TT1VSQ0VfQ09OVEVOVF9UWVBFOwotCX0KLQkKLQlwdWJsaWMgU3RyaW5nIGdldEtleSgpIHsKLQkJcmV0dXJuIG51bGw7Ci0JfQotCQotCXB1YmxpYyBTdHJpbmcgZ2V0RGVmYXVsdEtleSgpIHsKLQkJcmV0dXJuIEVjbGlwc2VMaW5rTWFwcGluZ0tleXMuVkFSSUFCTEVfT05FX1RPX09ORV9BVFRSSUJVVEVfTUFQUElOR19LRVk7Ci0JfQkKLQkKLQlwdWJsaWMgSW1hZ2UgZ2V0SW1hZ2UoKSB7Ci0JCXJldHVybiBKcHRVaVBsdWdpbi5nZXRJbWFnZShKcHRVaUljb25zLkpQQV9DT05URU5UKTsKLQl9Ci0JCi0JcHVibGljIFN0cmluZyBnZXRMYWJlbCgpIHsKLQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkRlZmF1bHRWYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXJfbGFiZWw7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXRMaW5rTGFiZWwoKSB7Ci0JCXJldHVybiBFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5EZWZhdWx0VmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyX2xpbmtMYWJlbDsKLQl9Ci0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxKYXZhVmFyaWFibGVPbmVUb09uZU1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgVmFyaWFibGVPbmVUb09uZU1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9CQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xSmF2YUVtYmVkZGFibGVDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2phdmEvZGV0YWlscy9FY2xpcHNlTGluazFfMUphdmFFbWJlZGRhYmxlQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDE1OTc2N2MuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xSmF2YUVtYmVkZGFibGVDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDk3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuamF2YS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5BY2Nlc3NIb2xkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5qYXZhLkphdmFFbWJlZGRhYmxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuamF2YS5FY2xpcHNlTGlua0phdmFFbWJlZGRhYmxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuamF2YS5KYXZhQ29udmVydGVySG9sZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua0VtYmVkZGFibGVBZHZhbmNlZENvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmRldGFpbHMuQWNjZXNzVHlwZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBUaGlzIHBhbmUgZG9lcyBub3QgaGF2ZSBhbnkgd2lkZ2V0cy4KLSAqCi0gKiBAc2VlIEVtYmVkZGFibGUKLSAqIEBzZWUgQmFzZUpwYVVpRmFjdG9yeSAtIFRoZSBmYWN0b3J5IGNyZWF0aW5nIHRoaXMgcGFuZQotICogQHNlZSBFbWJlZGRhYmxlVWlQcm92aWRlcgotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmsxXzFKYXZhRW1iZWRkYWJsZUNvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPEphdmFFbWJlZGRhYmxlPgotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW1wbGVtZW50cyBKcGFDb21wb3NpdGUKLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkVtYmVkZGFibGVDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHN1YmplY3RIb2xkZXIgVGhlIGhvbGRlciBvZiB0aGlzIHBhbmUncyBzdWJqZWN0Ci0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqIEBwYXJhbSB3aWRnZXRGYWN0b3J5IFRoZSBmYWN0b3J5IHVzZWQgdG8gY3JlYXRlIHZhcmlvdXMgY29tbW9uIHdpZGdldHMKLQkgKi8KLQlwdWJsaWMgRWNsaXBzZUxpbmsxXzFKYXZhRW1iZWRkYWJsZUNvbXBvc2l0ZShQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIEphdmFFbWJlZGRhYmxlPiBzdWJqZWN0SG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJaW5pdGlhbGl6ZUdlbmVyYWxQYW5lKGNvbnRhaW5lcik7Ci0JCWluaXRpYWxpemVDb252ZXJ0ZXJzUGFuZShjb250YWluZXIpOwotCQlpbml0aWFsaXplQWR2YW5jZWRQYW5lKGNvbnRhaW5lcik7Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVHZW5lcmFsUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCW5ldyBBY2Nlc3NUeXBlQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQWNjZXNzSG9sZGVyKCksIGNvbnRhaW5lcik7CQotCX0KLQkKLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPEFjY2Vzc0hvbGRlcj4gYnVpbGRBY2Nlc3NIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEphdmFFbWJlZGRhYmxlLCBBY2Nlc3NIb2xkZXI+KAotCQkJZ2V0U3ViamVjdEhvbGRlcigpKQotCQl7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBBY2Nlc3NIb2xkZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRQZXJzaXN0ZW50VHlwZSgpOwotCQkJfQotCQl9OwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVDb252ZXJ0ZXJzUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJY29udGFpbmVyID0gYWRkQ29sbGFwc2FibGVTZWN0aW9uKAotCQkJYWRkU3ViUGFuZShjb250YWluZXIsIDUpLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRWNsaXBzZUxpbmtUeXBlTWFwcGluZ0NvbXBvc2l0ZV9jb252ZXJ0ZXJzCi0JCSk7Ci0KLQkJbmV3IENvbnZlcnRlcnNDb21wb3NpdGUodGhpcywgYnVpbGRDb252ZXJ0ZXJIb2xkZXJWYWx1ZU1vZGVsKCksIGNvbnRhaW5lcik7Ci0JfQotCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxKYXZhQ29udmVydGVySG9sZGVyPiBidWlsZENvbnZlcnRlckhvbGRlclZhbHVlTW9kZWwoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEphdmFFbWJlZGRhYmxlLCBKYXZhQ29udmVydGVySG9sZGVyPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEphdmFDb252ZXJ0ZXJIb2xkZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuICgoRWNsaXBzZUxpbmtKYXZhRW1iZWRkYWJsZSkgdGhpcy5zdWJqZWN0KS5nZXRDb252ZXJ0ZXJIb2xkZXIoKTsKLQkJCX0JCi0JCX07Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVBZHZhbmNlZFBhbmUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQluZXcgRWNsaXBzZUxpbmtFbWJlZGRhYmxlQWR2YW5jZWRDb21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xSmF2YUVudGl0eUNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xSmF2YUVudGl0eUNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkODY4MDY2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2phdmEvZGV0YWlscy9FY2xpcHNlTGluazFfMUphdmFFbnRpdHlDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE0NSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLmphdmEuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuQWNjZXNzSG9sZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5KYXZhRW50aXR5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuamF2YS5FY2xpcHNlTGlua0phdmFFbnRpdHk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5qYXZhLkphdmFDYWNoaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuamF2YS5KYXZhQ29udmVydGVySG9sZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua0VudGl0eUFkdmFuY2VkQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFjY2Vzc1R5cGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmphdmEuZGV0YWlscy5KYXZhSW5oZXJpdGFuY2VDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmphdmEuZGV0YWlscy5KYXZhU2Vjb25kYXJ5VGFibGVzQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkFic3RyYWN0RW50aXR5Q29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkVudGl0eU5hbWVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuSWRDbGFzc0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5UYWJsZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBUaGUgcGFuZSB1c2VkIGZvciBhbiBFY2xpcHNlTGluazEuMSBKYXZhIGVudGl0eS4KLSAqCi0gKiBAc2VlIEVjbGlwc2VMaW5rSmF2YUVudGl0eQotICogQHNlZSBFY2xpcHNlbGlua0pwYVVpRmFjdG9yeSAtIFRoZSBmYWN0b3J5IGNyZWF0aW5nIHRoaXMgcGFuZQotICoKLSAqIEB2ZXJzaW9uIDIuMgotICogQHNpbmNlIDIuMgotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmsxXzFKYXZhRW50aXR5Q29tcG9zaXRlIGV4dGVuZHMgQWJzdHJhY3RFbnRpdHlDb21wb3NpdGU8SmF2YUVudGl0eT4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkVjbGlwc2VMaW5rSmF2YUVudGl0eUNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gc3ViamVjdEhvbGRlciBUaGUgaG9sZGVyIG9mIHRoZSBzdWJqZWN0IDxjb2RlPkphdmFFbnRpdHk8L2NvZGU+Ci0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqIEBwYXJhbSB3aWRnZXRGYWN0b3J5IFRoZSBmYWN0b3J5IHVzZWQgdG8gY3JlYXRlIHZhcmlvdXMgY29tbW9uIHdpZGdldHMKLQkgKi8KLQlwdWJsaWMgRWNsaXBzZUxpbmsxXzFKYXZhRW50aXR5Q29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgSmF2YUVudGl0eT4gc3ViamVjdEhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50LAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCWluaXRpYWxpemVHZW5lcmFsUGFuZShjb250YWluZXIpOwotCQlpbml0aWFsaXplQ2FjaGluZ1BhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZVF1ZXJpZXNQYW5lKGNvbnRhaW5lcik7Ci0JCWluaXRpYWxpemVJbmhlcml0YW5jZVBhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZUF0dHJpYnV0ZU92ZXJyaWRlc1BhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZUdlbmVyYXRvcnNQYW5lKGNvbnRhaW5lcik7Ci0JCWluaXRpYWxpemVDb252ZXJ0ZXJzUGFuZShjb250YWluZXIpOwotCQlpbml0aWFsaXplU2Vjb25kYXJ5VGFibGVzUGFuZShjb250YWluZXIpOwotCQlpbml0aWFsaXplQWR2YW5jZWRQYW5lKGNvbnRhaW5lcik7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVHZW5lcmFsUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCWludCBncm91cEJveE1hcmdpbiA9IGdldEdyb3VwQm94TWFyZ2luKCk7Ci0KLQkJbmV3IFRhYmxlQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JCW5ldyBFbnRpdHlOYW1lQ29tcG9zaXRlKHRoaXMsIGFkZFN1YlBhbmUoY29udGFpbmVyLCAwLCBncm91cEJveE1hcmdpbiwgMCwgZ3JvdXBCb3hNYXJnaW4pKTsJCi0JCW5ldyBBY2Nlc3NUeXBlQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQWNjZXNzSG9sZGVyKCksIGFkZFN1YlBhbmUoY29udGFpbmVyLCAwLCBncm91cEJveE1hcmdpbiwgMCwgZ3JvdXBCb3hNYXJnaW4pKTsJCi0JCW5ldyBJZENsYXNzQ29tcG9zaXRlKHRoaXMsIGFkZFN1YlBhbmUoY29udGFpbmVyLCAwLCBncm91cEJveE1hcmdpbiwgMCwgZ3JvdXBCb3hNYXJnaW4pLCBmYWxzZSk7Ci0JfQotCQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8QWNjZXNzSG9sZGVyPiBidWlsZEFjY2Vzc0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8SmF2YUVudGl0eSwgQWNjZXNzSG9sZGVyPigKLQkJCWdldFN1YmplY3RIb2xkZXIoKSkKLQkJewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQWNjZXNzSG9sZGVyIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0UGVyc2lzdGVudFR5cGUoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUNhY2hpbmdQYW5lKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQljb250YWluZXIgPSBhZGRDb2xsYXBzYWJsZVNlY3Rpb24oCi0JCQlhZGRTdWJQYW5lKGNvbnRhaW5lciwgNSksCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5FY2xpcHNlTGlua1R5cGVNYXBwaW5nQ29tcG9zaXRlX2NhY2hpbmcKLQkJKTsKLQotCQluZXcgSmF2YUNhY2hpbmdDb21wb3NpdGUodGhpcywgYnVpbGRDYWNoaW5nSG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8SmF2YUVudGl0eSwgSmF2YUNhY2hpbmc+IGJ1aWxkQ2FjaGluZ0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8SmF2YUVudGl0eSwgSmF2YUNhY2hpbmc+KAotCQkJZ2V0U3ViamVjdEhvbGRlcigpKQotCQl7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBKYXZhQ2FjaGluZyBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gKChFY2xpcHNlTGlua0phdmFFbnRpdHkpIHRoaXMuc3ViamVjdCkuZ2V0Q2FjaGluZygpOwotCQkJfQotCQl9OwotCQkKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplQ29udmVydGVyc1BhbmUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCWNvbnRhaW5lciA9IGFkZENvbGxhcHNhYmxlU2VjdGlvbigKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkVjbGlwc2VMaW5rVHlwZU1hcHBpbmdDb21wb3NpdGVfY29udmVydGVycwotCQkpOwotCi0JCW5ldyBDb252ZXJ0ZXJzQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQ29udmVydGVySG9sZGVyVmFsdWVNb2RlbCgpLCBjb250YWluZXIpOwotCX0KLQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8SmF2YUNvbnZlcnRlckhvbGRlcj4gYnVpbGRDb252ZXJ0ZXJIb2xkZXJWYWx1ZU1vZGVsKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxKYXZhRW50aXR5LCBKYXZhQ29udmVydGVySG9sZGVyPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEphdmFDb252ZXJ0ZXJIb2xkZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuICgoRWNsaXBzZUxpbmtKYXZhRW50aXR5KSB0aGlzLnN1YmplY3QpLmdldENvbnZlcnRlckhvbGRlcigpOwotCQkJfQkKLQkJfTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgYWRkU2Vjb25kYXJ5VGFibGVzQ29tcG9zaXRlKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJbmV3IEphdmFTZWNvbmRhcnlUYWJsZXNDb21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgYWRkSW5oZXJpdGFuY2VDb21wb3NpdGUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQluZXcgSmF2YUluaGVyaXRhbmNlQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVBZHZhbmNlZFBhbmUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQluZXcgRWNsaXBzZUxpbmtFbnRpdHlBZHZhbmNlZENvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9qYXZhL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFKYXZhTWFwcGVkU3VwZXJjbGFzc0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xSmF2YU1hcHBlZFN1cGVyY2xhc3NDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTNjMTZjYy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9qYXZhL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFKYXZhTWFwcGVkU3VwZXJjbGFzc0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTIxICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuamF2YS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5BY2Nlc3NIb2xkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5qYXZhLkphdmFNYXBwZWRTdXBlcmNsYXNzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuamF2YS5FY2xpcHNlTGlua0phdmFNYXBwZWRTdXBlcmNsYXNzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuamF2YS5KYXZhQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LmphdmEuSmF2YUNvbnZlcnRlckhvbGRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtNYXBwZWRTdXBlcmNsYXNzQWR2YW5jZWRDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFjY2Vzc1R5cGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuSWRDbGFzc0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBUaGUgcGFuZSB1c2VkIGZvciBhbiBFY2xpcHNlTGluayBKYXZhIE1hcHBlZCBTdXBlcmNsYXNzLgotICoKLSAqIEBzZWUgRWNsaXBzZUxpbmtNYXBwZWRTdXBlcmNsYXNzCi0gKiBAc2VlIEVjbGlwc2VsaW5rSnBhVWlGYWN0b3J5IC0gVGhlIGZhY3RvcnkgY3JlYXRpbmcgdGhpcyBwYW5lCi0gKgotICogQHZlcnNpb24gMi4xCi0gKiBAc2luY2UgMi4xCi0gKi8KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMUphdmFNYXBwZWRTdXBlcmNsYXNzQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8SmF2YU1hcHBlZFN1cGVyY2xhc3M+Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbXBsZW1lbnRzIEpwYUNvbXBvc2l0ZQotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+TWFwcGVkU3VwZXJjbGFzc0NvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gc3ViamVjdEhvbGRlciBUaGUgaG9sZGVyIG9mIHRoaXMgcGFuZSdzIHN1YmplY3QKLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICogQHBhcmFtIHdpZGdldEZhY3RvcnkgVGhlIGZhY3RvcnkgdXNlZCB0byBjcmVhdGUgdmFyaW91cyBjb21tb24gd2lkZ2V0cwotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGluazFfMUphdmFNYXBwZWRTdXBlcmNsYXNzQ29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgSmF2YU1hcHBlZFN1cGVyY2xhc3M+IHN1YmplY3RIb2xkZXIsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlpbml0aWFsaXplR2VuZXJhbFBhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZUNhY2hpbmdQYW5lKGNvbnRhaW5lcik7Ci0JCWluaXRpYWxpemVDb252ZXJ0ZXJzUGFuZShjb250YWluZXIpOwotCQlpbml0aWFsaXplQWR2YW5jZWRQYW5lKGNvbnRhaW5lcik7Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVHZW5lcmFsUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCW5ldyBBY2Nlc3NUeXBlQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQWNjZXNzSG9sZGVyKCksIGNvbnRhaW5lcik7CQotCQluZXcgSWRDbGFzc0NvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCX0KLQkKLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPEFjY2Vzc0hvbGRlcj4gYnVpbGRBY2Nlc3NIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEphdmFNYXBwZWRTdXBlcmNsYXNzLCBBY2Nlc3NIb2xkZXI+KAotCQkJZ2V0U3ViamVjdEhvbGRlcigpKQotCQl7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBBY2Nlc3NIb2xkZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRQZXJzaXN0ZW50VHlwZSgpOwotCQkJfQotCQl9OwotCX0KLQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVDYWNoaW5nUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJY29udGFpbmVyID0gYWRkQ29sbGFwc2FibGVTZWN0aW9uKAotCQkJYWRkU3ViUGFuZShjb250YWluZXIsIDUpLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRWNsaXBzZUxpbmtUeXBlTWFwcGluZ0NvbXBvc2l0ZV9jYWNoaW5nCi0JCSk7Ci0KLQkJbmV3IEphdmFDYWNoaW5nQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQ2FjaGluZ0hvbGRlcigpLCBjb250YWluZXIpOwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEphdmFNYXBwZWRTdXBlcmNsYXNzLCBKYXZhQ2FjaGluZz4gYnVpbGRDYWNoaW5nSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxKYXZhTWFwcGVkU3VwZXJjbGFzcywgSmF2YUNhY2hpbmc+KAotCQkJZ2V0U3ViamVjdEhvbGRlcigpKQotCQl7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBKYXZhQ2FjaGluZyBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gKChFY2xpcHNlTGlua0phdmFNYXBwZWRTdXBlcmNsYXNzKSB0aGlzLnN1YmplY3QpLmdldENhY2hpbmcoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUNvbnZlcnRlcnNQYW5lKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJY29udGFpbmVyID0gYWRkQ29sbGFwc2FibGVTZWN0aW9uKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRWNsaXBzZUxpbmtUeXBlTWFwcGluZ0NvbXBvc2l0ZV9jb252ZXJ0ZXJzCi0JCSk7Ci0KLQkJbmV3IENvbnZlcnRlcnNDb21wb3NpdGUodGhpcywgYnVpbGRDb252ZXJ0ZXJIb2xkZXJWYWx1ZU1vZGVsKCksIGNvbnRhaW5lcik7Ci0JfQotCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxKYXZhQ29udmVydGVySG9sZGVyPiBidWlsZENvbnZlcnRlckhvbGRlclZhbHVlTW9kZWwoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEphdmFNYXBwZWRTdXBlcmNsYXNzLCBKYXZhQ29udmVydGVySG9sZGVyPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEphdmFDb252ZXJ0ZXJIb2xkZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuICgoRWNsaXBzZUxpbmtKYXZhTWFwcGVkU3VwZXJjbGFzcykgdGhpcy5zdWJqZWN0KS5nZXRDb252ZXJ0ZXJIb2xkZXIoKTsKLQkJCX0JCi0JCX07Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVBZHZhbmNlZFBhbmUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQluZXcgRWNsaXBzZUxpbmtNYXBwZWRTdXBlcmNsYXNzQWR2YW5jZWRDb21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0VjbGlwc2VMaW5rSmF2YUJhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9qYXZhL2RldGFpbHMvRWNsaXBzZUxpbmtKYXZhQmFzaWNDb2xsZWN0aW9uTWFwcGluZ1VpUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDk1MjMyMS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9qYXZhL2RldGFpbHMvRWNsaXBzZUxpbmtKYXZhQmFzaWNDb2xsZWN0aW9uTWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuamF2YS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLmNvbnRlbnQuSUNvbnRlbnRUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLkpwdENvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5CYXNpY0NvbGxlY3Rpb25NYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkJhc2ljQ29sbGVjdGlvbk1hcHBpbmdDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtCYXNpY0NvbGxlY3Rpb25NYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtKYXZhQmFzaWNDb2xsZWN0aW9uTWFwcGluZ1VpUHJvdmlkZXIgZXh0ZW5kcyBFY2xpcHNlTGlua0Jhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyPEJhc2ljQ29sbGVjdGlvbk1hcHBpbmc+Ci17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgRWNsaXBzZUxpbmtKYXZhQmFzaWNDb2xsZWN0aW9uTWFwcGluZ1VpUHJvdmlkZXIgSU5TVEFOQ0UgPSAKLQkJbmV3IEVjbGlwc2VMaW5rSmF2YUJhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxCYXNpY0NvbGxlY3Rpb25NYXBwaW5nPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmtKYXZhQmFzaWNDb2xsZWN0aW9uTWFwcGluZ1VpUHJvdmlkZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQotCXB1YmxpYyBJQ29udGVudFR5cGUgZ2V0Q29udGVudFR5cGUoKSB7Ci0JCXJldHVybiBKcHRDb3JlUGx1Z2luLkpBVkFfU09VUkNFX0NPTlRFTlRfVFlQRTsKLQl9Ci0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxCYXNpY0NvbGxlY3Rpb25NYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEJhc2ljQ29sbGVjdGlvbk1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9qYXZhL2RldGFpbHMvRWNsaXBzZUxpbmtKYXZhQmFzaWNNYXBNYXBwaW5nVWlQcm92aWRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0VjbGlwc2VMaW5rSmF2YUJhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggM2MzYzAwNC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9qYXZhL2RldGFpbHMvRWNsaXBzZUxpbmtKYXZhQmFzaWNNYXBNYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5qYXZhLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuSnB0Q29yZVBsdWdpbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkJhc2ljTWFwTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5CYXNpY01hcE1hcHBpbmdDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtCYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua0phdmFCYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyIGV4dGVuZHMgRWNsaXBzZUxpbmtCYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyPEJhc2ljTWFwTWFwcGluZz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGlua0phdmFCYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGlua0phdmFCYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxCYXNpY01hcE1hcHBpbmc+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGlua0phdmFCYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0Q29yZVBsdWdpbi5KQVZBX1NPVVJDRV9DT05URU5UX1RZUEU7Ci0JfQotCQotCXB1YmxpYyBKcGFDb21wb3NpdGUgYnVpbGRBdHRyaWJ1dGVNYXBwaW5nQ29tcG9zaXRlKAotCQkJSnBhVWlGYWN0b3J5IGZhY3RvcnksCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8QmFzaWNNYXBNYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEJhc2ljTWFwTWFwcGluZ0NvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2phdmEvZGV0YWlscy9FY2xpcHNlTGlua0phdmFFbWJlZGRhYmxlQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9qYXZhL2RldGFpbHMvRWNsaXBzZUxpbmtKYXZhRW1iZWRkYWJsZUNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjNDBkZTIwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2phdmEvZGV0YWlscy9FY2xpcHNlTGlua0phdmFFbWJlZGRhYmxlQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw3OSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLmphdmEuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5KYXZhRW1iZWRkYWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LmphdmEuRWNsaXBzZUxpbmtKYXZhRW1iZWRkYWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LmphdmEuSmF2YUNvbnZlcnRlckhvbGRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtFbWJlZGRhYmxlQWR2YW5jZWRDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFRoaXMgcGFuZSBkb2VzIG5vdCBoYXZlIGFueSB3aWRnZXRzLgotICoKLSAqIEBzZWUgRW1iZWRkYWJsZQotICogQHNlZSBCYXNlSnBhVWlGYWN0b3J5IC0gVGhlIGZhY3RvcnkgY3JlYXRpbmcgdGhpcyBwYW5lCi0gKiBAc2VlIEVtYmVkZGFibGVVaVByb3ZpZGVyCi0gKgotICogQHZlcnNpb24gMi4xCi0gKiBAc2luY2UgMi4xCi0gKi8KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua0phdmFFbWJlZGRhYmxlQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8SmF2YUVtYmVkZGFibGU+Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbXBsZW1lbnRzIEpwYUNvbXBvc2l0ZQotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+RW1iZWRkYWJsZUNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gc3ViamVjdEhvbGRlciBUaGUgaG9sZGVyIG9mIHRoaXMgcGFuZSdzIHN1YmplY3QKLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICogQHBhcmFtIHdpZGdldEZhY3RvcnkgVGhlIGZhY3RvcnkgdXNlZCB0byBjcmVhdGUgdmFyaW91cyBjb21tb24gd2lkZ2V0cwotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGlua0phdmFFbWJlZGRhYmxlQ29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgSmF2YUVtYmVkZGFibGU+IHN1YmplY3RIb2xkZXIsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICBXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlpbml0aWFsaXplQ29udmVydGVyc1BhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZUFkdmFuY2VkUGFuZShjb250YWluZXIpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVDb252ZXJ0ZXJzUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJY29udGFpbmVyID0gYWRkQ29sbGFwc2FibGVTZWN0aW9uKAotCQkJYWRkU3ViUGFuZShjb250YWluZXIsIDUpLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRWNsaXBzZUxpbmtUeXBlTWFwcGluZ0NvbXBvc2l0ZV9jb252ZXJ0ZXJzCi0JCSk7Ci0KLQkJbmV3IENvbnZlcnRlcnNDb21wb3NpdGUodGhpcywgYnVpbGRDb252ZXJ0ZXJIb2xkZXJWYWx1ZU1vZGVsKCksIGNvbnRhaW5lcik7Ci0JfQotCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxKYXZhQ29udmVydGVySG9sZGVyPiBidWlsZENvbnZlcnRlckhvbGRlclZhbHVlTW9kZWwoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEphdmFFbWJlZGRhYmxlLCBKYXZhQ29udmVydGVySG9sZGVyPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEphdmFDb252ZXJ0ZXJIb2xkZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuICgoRWNsaXBzZUxpbmtKYXZhRW1iZWRkYWJsZSkgdGhpcy5zdWJqZWN0KS5nZXRDb252ZXJ0ZXJIb2xkZXIoKTsKLQkJCX0JCi0JCX07Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVBZHZhbmNlZFBhbmUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQluZXcgRWNsaXBzZUxpbmtFbWJlZGRhYmxlQWR2YW5jZWRDb21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0VjbGlwc2VMaW5rSmF2YUVudGl0eUNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0VjbGlwc2VMaW5rSmF2YUVudGl0eUNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyYjE2ODI2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2phdmEvZGV0YWlscy9FY2xpcHNlTGlua0phdmFFbnRpdHlDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDExOSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLmphdmEuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5KYXZhRW50aXR5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuamF2YS5FY2xpcHNlTGlua0phdmFFbnRpdHk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5qYXZhLkphdmFDYWNoaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuamF2YS5KYXZhQ29udmVydGVySG9sZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua0VudGl0eUFkdmFuY2VkQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5qYXZhLmRldGFpbHMuSmF2YUluaGVyaXRhbmNlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5qYXZhLmRldGFpbHMuSmF2YVNlY29uZGFyeVRhYmxlc0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5BYnN0cmFjdEVudGl0eUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBUaGUgcGFuZSB1c2VkIGZvciBhbiBFY2xpcHNlTGluayBKYXZhIGVudGl0eS4KLSAqCi0gKiBAc2VlIEVjbGlwc2VMaW5rSmF2YUVudGl0eQotICogQHNlZSBFY2xpcHNlbGlua0pwYVVpRmFjdG9yeSAtIFRoZSBmYWN0b3J5IGNyZWF0aW5nIHRoaXMgcGFuZQotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtKYXZhRW50aXR5Q29tcG9zaXRlIGV4dGVuZHMgQWJzdHJhY3RFbnRpdHlDb21wb3NpdGU8SmF2YUVudGl0eT4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkVjbGlwc2VMaW5rSmF2YUVudGl0eUNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gc3ViamVjdEhvbGRlciBUaGUgaG9sZGVyIG9mIHRoZSBzdWJqZWN0IDxjb2RlPkphdmFFbnRpdHk8L2NvZGU+Ci0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqIEBwYXJhbSB3aWRnZXRGYWN0b3J5IFRoZSBmYWN0b3J5IHVzZWQgdG8gY3JlYXRlIHZhcmlvdXMgY29tbW9uIHdpZGdldHMKLQkgKi8KLQlwdWJsaWMgRWNsaXBzZUxpbmtKYXZhRW50aXR5Q29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgSmF2YUVudGl0eT4gc3ViamVjdEhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50LAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCWluaXRpYWxpemVHZW5lcmFsUGFuZShjb250YWluZXIpOwotCQlpbml0aWFsaXplQ2FjaGluZ1BhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZVF1ZXJpZXNQYW5lKGNvbnRhaW5lcik7Ci0JCWluaXRpYWxpemVJbmhlcml0YW5jZVBhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZUF0dHJpYnV0ZU92ZXJyaWRlc1BhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZUdlbmVyYXRvcnNQYW5lKGNvbnRhaW5lcik7Ci0JCWluaXRpYWxpemVDb252ZXJ0ZXJzUGFuZShjb250YWluZXIpOwotCQlpbml0aWFsaXplU2Vjb25kYXJ5VGFibGVzUGFuZShjb250YWluZXIpOwotCQlpbml0aWFsaXplQWR2YW5jZWRQYW5lKGNvbnRhaW5lcik7Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVDYWNoaW5nUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJY29udGFpbmVyID0gYWRkQ29sbGFwc2FibGVTZWN0aW9uKAotCQkJYWRkU3ViUGFuZShjb250YWluZXIsIDUpLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRWNsaXBzZUxpbmtUeXBlTWFwcGluZ0NvbXBvc2l0ZV9jYWNoaW5nCi0JCSk7Ci0KLQkJbmV3IEphdmFDYWNoaW5nQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQ2FjaGluZ0hvbGRlcigpLCBjb250YWluZXIpOwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEphdmFFbnRpdHksIEphdmFDYWNoaW5nPiBidWlsZENhY2hpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEphdmFFbnRpdHksIEphdmFDYWNoaW5nPigKLQkJCWdldFN1YmplY3RIb2xkZXIoKSkKLQkJewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSmF2YUNhY2hpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuICgoRWNsaXBzZUxpbmtKYXZhRW50aXR5KSB0aGlzLnN1YmplY3QpLmdldENhY2hpbmcoKTsKLQkJCX0KLQkJfTsKLQkJCi0JfQotCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUNvbnZlcnRlcnNQYW5lKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQljb250YWluZXIgPSBhZGRDb2xsYXBzYWJsZVNlY3Rpb24oCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5FY2xpcHNlTGlua1R5cGVNYXBwaW5nQ29tcG9zaXRlX2NvbnZlcnRlcnMKLQkJKTsKLQotCQluZXcgQ29udmVydGVyc0NvbXBvc2l0ZSh0aGlzLCBidWlsZENvbnZlcnRlckhvbGRlclZhbHVlTW9kZWwoKSwgY29udGFpbmVyKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPEphdmFDb252ZXJ0ZXJIb2xkZXI+IGJ1aWxkQ29udmVydGVySG9sZGVyVmFsdWVNb2RlbCgpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8SmF2YUVudGl0eSwgSmF2YUNvbnZlcnRlckhvbGRlcj4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBKYXZhQ29udmVydGVySG9sZGVyIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiAoKEVjbGlwc2VMaW5rSmF2YUVudGl0eSkgdGhpcy5zdWJqZWN0KS5nZXRDb252ZXJ0ZXJIb2xkZXIoKTsKLQkJCX0JCi0JCX07Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGFkZFNlY29uZGFyeVRhYmxlc0NvbXBvc2l0ZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCW5ldyBKYXZhU2Vjb25kYXJ5VGFibGVzQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGFkZEluaGVyaXRhbmNlQ29tcG9zaXRlKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJbmV3IEphdmFJbmhlcml0YW5jZUNvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCX0KLQkKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplQWR2YW5jZWRQYW5lKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJbmV3IEVjbGlwc2VMaW5rRW50aXR5QWR2YW5jZWRDb21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0VjbGlwc2VMaW5rSmF2YU1hcHBlZFN1cGVyY2xhc3NDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2phdmEvZGV0YWlscy9FY2xpcHNlTGlua0phdmFNYXBwZWRTdXBlcmNsYXNzQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGUwODc5MzYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0VjbGlwc2VMaW5rSmF2YU1hcHBlZFN1cGVyY2xhc3NDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEwMyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLmphdmEuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5KYXZhTWFwcGVkU3VwZXJjbGFzczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LmphdmEuRWNsaXBzZUxpbmtKYXZhTWFwcGVkU3VwZXJjbGFzczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LmphdmEuSmF2YUNhY2hpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5qYXZhLkphdmFDb252ZXJ0ZXJIb2xkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLkVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkVjbGlwc2VMaW5rTWFwcGVkU3VwZXJjbGFzc0FkdmFuY2VkQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5JZENsYXNzQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFRoZSBwYW5lIHVzZWQgZm9yIGFuIEVjbGlwc2VMaW5rIEphdmEgTWFwcGVkIFN1cGVyY2xhc3MuCi0gKgotICogQHNlZSBFY2xpcHNlTGlua01hcHBlZFN1cGVyY2xhc3MKLSAqIEBzZWUgRWNsaXBzZWxpbmtKcGFVaUZhY3RvcnkgLSBUaGUgZmFjdG9yeSBjcmVhdGluZyB0aGlzIHBhbmUKLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rSmF2YU1hcHBlZFN1cGVyY2xhc3NDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxKYXZhTWFwcGVkU3VwZXJjbGFzcz4KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGltcGxlbWVudHMgSnBhQ29tcG9zaXRlCi17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5NYXBwZWRTdXBlcmNsYXNzQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBzdWJqZWN0SG9sZGVyIFRoZSBob2xkZXIgb2YgdGhpcyBwYW5lJ3Mgc3ViamVjdAotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKiBAcGFyYW0gd2lkZ2V0RmFjdG9yeSBUaGUgZmFjdG9yeSB1c2VkIHRvIGNyZWF0ZSB2YXJpb3VzIGNvbW1vbiB3aWRnZXRzCi0JICovCi0JcHVibGljIEVjbGlwc2VMaW5rSmF2YU1hcHBlZFN1cGVyY2xhc3NDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBKYXZhTWFwcGVkU3VwZXJjbGFzcz4gc3ViamVjdEhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50LAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCW5ldyBJZENsYXNzQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JCQotCQlpbml0aWFsaXplQ2FjaGluZ1BhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZUNvbnZlcnRlcnNQYW5lKGNvbnRhaW5lcik7Ci0JCWluaXRpYWxpemVBZHZhbmNlZFBhbmUoY29udGFpbmVyKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUNhY2hpbmdQYW5lKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQljb250YWluZXIgPSBhZGRDb2xsYXBzYWJsZVNlY3Rpb24oCi0JCQlhZGRTdWJQYW5lKGNvbnRhaW5lciwgNSksCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5FY2xpcHNlTGlua1R5cGVNYXBwaW5nQ29tcG9zaXRlX2NhY2hpbmcKLQkJKTsKLQotCQluZXcgSmF2YUNhY2hpbmdDb21wb3NpdGUodGhpcywgYnVpbGRDYWNoaW5nSG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8SmF2YU1hcHBlZFN1cGVyY2xhc3MsIEphdmFDYWNoaW5nPiBidWlsZENhY2hpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEphdmFNYXBwZWRTdXBlcmNsYXNzLCBKYXZhQ2FjaGluZz4oCi0JCQlnZXRTdWJqZWN0SG9sZGVyKCkpCi0JCXsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEphdmFDYWNoaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiAoKEVjbGlwc2VMaW5rSmF2YU1hcHBlZFN1cGVyY2xhc3MpIHRoaXMuc3ViamVjdCkuZ2V0Q2FjaGluZygpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplQ29udmVydGVyc1BhbmUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQljb250YWluZXIgPSBhZGRDb2xsYXBzYWJsZVNlY3Rpb24oCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5FY2xpcHNlTGlua1R5cGVNYXBwaW5nQ29tcG9zaXRlX2NvbnZlcnRlcnMKLQkJKTsKLQotCQluZXcgQ29udmVydGVyc0NvbXBvc2l0ZSh0aGlzLCBidWlsZENvbnZlcnRlckhvbGRlclZhbHVlTW9kZWwoKSwgY29udGFpbmVyKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPEphdmFDb252ZXJ0ZXJIb2xkZXI+IGJ1aWxkQ29udmVydGVySG9sZGVyVmFsdWVNb2RlbCgpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8SmF2YU1hcHBlZFN1cGVyY2xhc3MsIEphdmFDb252ZXJ0ZXJIb2xkZXI+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSmF2YUNvbnZlcnRlckhvbGRlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gKChFY2xpcHNlTGlua0phdmFNYXBwZWRTdXBlcmNsYXNzKSB0aGlzLnN1YmplY3QpLmdldENvbnZlcnRlckhvbGRlcigpOwotCQkJfQkKLQkJfTsKLQl9Ci0JCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUFkdmFuY2VkUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCW5ldyBFY2xpcHNlTGlua01hcHBlZFN1cGVyY2xhc3NBZHZhbmNlZENvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9qYXZhL2RldGFpbHMvRWNsaXBzZUxpbmtKYXZhVHJhbnNmb3JtYXRpb25NYXBwaW5nVWlQcm92aWRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0VjbGlwc2VMaW5rSmF2YVRyYW5zZm9ybWF0aW9uTWFwcGluZ1VpUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmZhN2FkMC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9qYXZhL2RldGFpbHMvRWNsaXBzZUxpbmtKYXZhVHJhbnNmb3JtYXRpb25NYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5qYXZhLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuSnB0Q29yZVBsdWdpbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LlRyYW5zZm9ybWF0aW9uTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua1RyYW5zZm9ybWF0aW9uTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuVHJhbnNmb3JtYXRpb25NYXBwaW5nQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua0phdmFUcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyIGV4dGVuZHMgRWNsaXBzZUxpbmtUcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyPFRyYW5zZm9ybWF0aW9uTWFwcGluZz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGlua0phdmFUcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGlua0phdmFUcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxUcmFuc2Zvcm1hdGlvbk1hcHBpbmc+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGlua0phdmFUcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0Q29yZVBsdWdpbi5KQVZBX1NPVVJDRV9DT05URU5UX1RZUEU7Ci0JfQotCQotCXB1YmxpYyBKcGFDb21wb3NpdGUgYnVpbGRBdHRyaWJ1dGVNYXBwaW5nQ29tcG9zaXRlKAotCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJUHJvcGVydHlWYWx1ZU1vZGVsPFRyYW5zZm9ybWF0aW9uTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkJQ29tcG9zaXRlIHBhcmVudCwKLQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCQotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uTWFwcGluZ0NvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2phdmEvZGV0YWlscy9FY2xpcHNlTGlua0phdmFWYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2phdmEvZGV0YWlscy9FY2xpcHNlTGlua0phdmFWYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzJkZTM4ZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9qYXZhL2RldGFpbHMvRWNsaXBzZUxpbmtKYXZhVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLmphdmEuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcHRDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuVmFyaWFibGVPbmVUb09uZU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtWYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuVmFyaWFibGVPbmVUb09uZU1hcHBpbmdDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVVpRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5BdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rSmF2YVZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlciBleHRlbmRzIEVjbGlwc2VMaW5rVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyPFZhcmlhYmxlT25lVG9PbmVNYXBwaW5nPgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEVjbGlwc2VMaW5rSmF2YVZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlciBJTlNUQU5DRSA9IAotCQluZXcgRWNsaXBzZUxpbmtKYXZhVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxWYXJpYWJsZU9uZVRvT25lTWFwcGluZz4gaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0JCi0JCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEVjbGlwc2VMaW5rSmF2YVZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JcHVibGljIElDb250ZW50VHlwZSBnZXRDb250ZW50VHlwZSgpIHsKLQkJcmV0dXJuIEpwdENvcmVQbHVnaW4uSkFWQV9TT1VSQ0VfQ09OVEVOVF9UWVBFOwotCX0KLQotCXB1YmxpYyBKcGFDb21wb3NpdGUgYnVpbGRBdHRyaWJ1dGVNYXBwaW5nQ29tcG9zaXRlKAotCQkJSnBhVWlGYWN0b3J5IGZhY3RvcnksCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8VmFyaWFibGVPbmVUb09uZU1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgVmFyaWFibGVPbmVUb09uZU1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9qYXZhL2RldGFpbHMvSmF2YUNhY2hpbmdDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2phdmEvZGV0YWlscy9KYXZhQ2FjaGluZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4ZmQ5ZTU0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2phdmEvZGV0YWlscy9KYXZhQ2FjaGluZ0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNjIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5qYXZhLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LmphdmEuSmF2YUNhY2hpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuQ2FjaGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFRoaXMgcGFuZSBzaG93cyB0aGUgY2FjaGluZyBvcHRpb25zLgotICogPHA+Ci0gKiBIZXJlIHRoZSBsYXlvdXQgb2YgdGhpcyBwYW5lOgotICogPHByZT4KLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gKiB8IHggU2hhcmVkICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogfCAgICBDYWNoZVR5cGVDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIHwgICAgQ2FjaGVTaXplQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0gKiB8ICAgID4gQWR2YW5jZWQgICAJICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIHwgICAgCUV4cGlyeUNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0gKiB8ICAgIAlBbHdheXNSZWZyZXNoQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogfCAgIAkJUmVmcmVzaE9ubHlJZk5ld2VyQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIHwgICAgCURpc2FibGVIaXRzQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0gKiB8ICAgIAlDYWNoZUNvb3JkaW5hdGlvbkNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogfCBFeGlzdGVuY2VUeXBlQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSBFbnRpdHkKLSAqIEBzZWUgRWNsaXBzZUxpbmtDYWNoaW5nCi0gKiBAc2VlIEVjbGlwc2VMaW5rSmF2YUVudGl0eUNvbXBvc2l0ZSAtIFRoZSBwYXJlbnQgY29udGFpbmVyCi0gKiBAc2VlIENhY2hlVHlwZUNvbXBvc2l0ZQotICogQHNlZSBDYWNoZVNpemVDb21wb3NpdGUKLSAqIEBzZWUgQWx3YXlzUmVmcmVzaENvbXBvc2l0ZQotICogQHNlZSBSZWZyZXNoT25seUlmTmV3ZXJDb21wb3NpdGUKLSAqIEBzZWUgRGlzYWJsZUhpdHNDb21wb3NpdGUKLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIEphdmFDYWNoaW5nQ29tcG9zaXRlIGV4dGVuZHMgQ2FjaGluZ0NvbXBvc2l0ZTxKYXZhQ2FjaGluZz4KLXsKLQotCXB1YmxpYyBKYXZhQ2FjaGluZ0NvbXBvc2l0ZShGb3JtUGFuZTw/PiBwYXJlbnRQYW5lLAotICAgICAgICBQcm9wZXJ0eVZhbHVlTW9kZWw8SmF2YUNhY2hpbmc+IHN1YmplY3RIb2xkZXIsCi0gICAgICAgIENvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRQYW5lLCBzdWJqZWN0SG9sZGVyLCBwYXJlbnQpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVFeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZShDb21wb3NpdGUgcGFyZW50KSB7Ci0JCW5ldyBKYXZhRXhpc3RlbmNlQ2hlY2tpbmdDb21wb3NpdGUodGhpcywgcGFyZW50KTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0phdmFFeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvamF2YS9kZXRhaWxzL0phdmFFeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlMjMwMzIxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL2phdmEvZGV0YWlscy9KYXZhRXhpc3RlbmNlQ2hlY2tpbmdDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEyOCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMKLSAqICBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mCi0gKiAgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzCi0gKiAgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0gKgotICogIENvbnRyaWJ1dG9yczogT3JhY2xlLiAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5qYXZhLmRldGFpbHM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkNhY2hpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5FeGlzdGVuY2VUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuamF2YS5KYXZhQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRW51bUZvcm1Db21ib1ZpZXdlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIEhlcmUgaXMgdGhlIGxheW91dCBvZiB0aGlzIHBhbmU6Ci0gKiA8cHJlPgotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotICogfCAgICAgICAJCQkgIAkJLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHggRXhpc3RlbmNlIENoZWNraW5nOiAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHx2fCB8Ci0gKiB8ICAgICAgIAkJCQkJLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSBFY2xpcHNlTGlua0NhY2hpbmcKLSAqIEBzZWUgQ2FjaGluZ0NvbXBvc2l0ZSAtIEEgY29udGFpbmVyIG9mIHRoaXMgd2lkZ2V0Ci0gKgotICogQHZlcnNpb24gMi4xCi0gKiBAc2luY2UgMi4xCi0gKi8KLXB1YmxpYyBjbGFzcyBKYXZhRXhpc3RlbmNlQ2hlY2tpbmdDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxKYXZhQ2FjaGluZz4gewotCi0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5FeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgSmF2YUV4aXN0ZW5jZUNoZWNraW5nQ29tcG9zaXRlKEZvcm1QYW5lPD8gZXh0ZW5kcyBKYXZhQ2FjaGluZz4gcGFyZW50UGFuZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRQYW5lLCBwYXJlbnQsIGZhbHNlKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlhZGRMYWJlbGVkQ29tcG9zaXRlKCAKLSAgICAgICAgICAgIGNvbnRhaW5lciwgCi0gICAgICAgICAgICBhZGRDaGVja0JveCggCi0gICAgICAgICAgICAgICAgIGNvbnRhaW5lciwgCi0gICAgICAgICAgICAgICAgIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkV4aXN0ZW5jZUNoZWNraW5nQ29tcG9zaXRlX2xhYmVsLCAKLSAgICAgICAgICAgICAgICAgYnVpbGRFeGlzdGVuY2VDaGVja2luZ0hvbGRlcigpLCAKLSAgICAgICAgICAgICAgICAgbnVsbCAKLSAgICAgICAgICAgICksIAotICAgICAgICAgICAgYWRkRXhpc3RlbmNlQ2hlY2tpbmdUeXBlQ29tYm8oY29udGFpbmVyKS5nZXRDb250cm9sKCksIAotICAgICAgICAgICAgbnVsbCAKLSAgICAgICApOwotCX0KLQotCXByaXZhdGUgRW51bUZvcm1Db21ib1ZpZXdlcjxDYWNoaW5nLCBFeGlzdGVuY2VUeXBlPiBhZGRFeGlzdGVuY2VDaGVja2luZ1R5cGVDb21ibyhDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJcmV0dXJuIG5ldyBFbnVtRm9ybUNvbWJvVmlld2VyPENhY2hpbmcsIEV4aXN0ZW5jZVR5cGU+KHRoaXMsIGNvbnRhaW5lcikgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIGFkZFByb3BlcnR5TmFtZXMoQ29sbGVjdGlvbjxTdHJpbmc+IHByb3BlcnR5TmFtZXMpIHsKLQkJCQlzdXBlci5hZGRQcm9wZXJ0eU5hbWVzKHByb3BlcnR5TmFtZXMpOwotCQkJCXByb3BlcnR5TmFtZXMuYWRkKENhY2hpbmcuREVGQVVMVF9FWElTVEVOQ0VfVFlQRV9QUk9QRVJUWSk7Ci0JCQkJcHJvcGVydHlOYW1lcy5hZGQoQ2FjaGluZy5TUEVDSUZJRURfRVhJU1RFTkNFX1RZUEVfUFJPUEVSVFkpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBFeGlzdGVuY2VUeXBlW10gZ2V0Q2hvaWNlcygpIHsKLQkJCQlyZXR1cm4gRXhpc3RlbmNlVHlwZS52YWx1ZXMoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgRXhpc3RlbmNlVHlwZSBnZXREZWZhdWx0VmFsdWUoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXREZWZhdWx0RXhpc3RlbmNlVHlwZSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZGlzcGxheVN0cmluZyhFeGlzdGVuY2VUeXBlIHZhbHVlKSB7Ci0JCQkJcmV0dXJuIGJ1aWxkRGlzcGxheVN0cmluZygKLQkJCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuY2xhc3MsCi0JCQkJCUphdmFFeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZS50aGlzLAotCQkJCQl2YWx1ZQotCQkJCSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEV4aXN0ZW5jZVR5cGUgZ2V0VmFsdWUoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXRTcGVjaWZpZWRFeGlzdGVuY2VUeXBlKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWUoRXhpc3RlbmNlVHlwZSB2YWx1ZSkgewotCQkJCWdldFN1YmplY3QoKS5zZXRTcGVjaWZpZWRFeGlzdGVuY2VUeXBlKHZhbHVlKTsKLQkJCX0KLQkJCQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgYm9vbGVhbiBzb3J0Q2hvaWNlcygpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRFeGlzdGVuY2VDaGVja2luZ0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8SmF2YUNhY2hpbmcsIEJvb2xlYW4+KGdldFN1YmplY3RIb2xkZXIoKSwgSmF2YUNhY2hpbmcuRVhJU1RFTkNFX0NIRUNLSU5HX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBCb29sZWFuLnZhbHVlT2YodGhpcy5zdWJqZWN0Lmhhc0V4aXN0ZW5jZUNoZWNraW5nKCkpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldEV4aXN0ZW5jZUNoZWNraW5nKHZhbHVlLmJvb2xlYW5WYWx1ZSgpKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL0VjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlNDQxMTUxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL0VjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNjkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YKLSAqIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uIGFuZCBpcyBhdmFpbGFibGUgYXQKLSAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5nczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci0KLS8qKgotICogVGhlIGxvY2FsaXplZCBzdHJpbmdzIHVzZWQgYnkgdGhlIG1hcHBpbmcgcGFuZXMuCi0gKgotICogQHZlcnNpb24gMi4yCi0gKiBAc2luY2UgMS4wCi0gKi8KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzIGV4dGVuZHMgTkxTIHsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEJhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyX2xhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEJhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyX2xpbmtMYWJlbDsKLQkKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBCYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyX2xhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEJhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXJfbGlua0xhYmVsOwotCQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFRyYW5zZm9ybWF0aW9uTWFwcGluZ1VpUHJvdmlkZXJfbGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgVHJhbnNmb3JtYXRpb25NYXBwaW5nVWlQcm92aWRlcl9saW5rTGFiZWw7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBWYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXJfbGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyX2xpbmtMYWJlbDsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENhY2hlVHlwZUNvbXBvc2l0ZV9sYWJlbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDYWNoZVR5cGVDb21wb3NpdGVfZnVsbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDYWNoZVR5cGVDb21wb3NpdGVfd2VhazsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDYWNoZVR5cGVDb21wb3NpdGVfc29mdDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDYWNoZVR5cGVDb21wb3NpdGVfc29mdF93ZWFrOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENhY2hlVHlwZUNvbXBvc2l0ZV9oYXJkX3dlYWs7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ2FjaGVUeXBlQ29tcG9zaXRlX2NhY2hlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENhY2hlVHlwZUNvbXBvc2l0ZV9ub25lOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEVjbGlwc2VMaW5rVHlwZU1hcHBpbmdDb21wb3NpdGVfYWR2YW5jZWQ7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRWNsaXBzZUxpbmtUeXBlTWFwcGluZ0NvbXBvc2l0ZV9jYWNoaW5nOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEVjbGlwc2VMaW5rVHlwZU1hcHBpbmdDb21wb3NpdGVfY29udmVydGVyczsKLQkKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDYWNoZVNpemVDb21wb3NpdGVfc2l6ZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDYWNoZUNvb3JkaW5hdGlvblR5cGVDb21wb3NpdGVfbGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ2FjaGVDb29yZGluYXRpb25UeXBlQ29tcG9zaXRlX3NlbmRfb2JqZWN0X2NoYW5nZXM7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ2FjaGVDb29yZGluYXRpb25UeXBlQ29tcG9zaXRlX2ludmFsaWRhdGVfY2hhbmdlZF9vYmplY3RzOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENhY2hlQ29vcmRpbmF0aW9uVHlwZUNvbXBvc2l0ZV9zZW5kX25ld19vYmplY3RzX3dpdGhfY2hhbmdlczsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDYWNoZUNvb3JkaW5hdGlvblR5cGVDb21wb3NpdGVfbm9uZTsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENhY2hpbmdDb21wb3NpdGVfc2hhcmVkTGFiZWxEZWZhdWx0OwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENhY2hpbmdDb21wb3NpdGVfc2hhcmVkTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ2FjaGluZ0NvbXBvc2l0ZV9hZHZhbmNlZDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBBbHdheXNSZWZyZXNoQ29tcG9zaXRlX2Fsd2F5c1JlZnJlc2hEZWZhdWx0OwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEFsd2F5c1JlZnJlc2hDb21wb3NpdGVfYWx3YXlzUmVmcmVzaExhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFJlZnJlc2hPbmx5SWZOZXdlckNvbXBvc2l0ZV9yZWZyZXNoT25seUlmTmV3ZXJEZWZhdWx0OwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFJlZnJlc2hPbmx5SWZOZXdlckNvbXBvc2l0ZV9yZWZyZXNoT25seUlmTmV3ZXJMYWJlbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBEaXNhYmxlSGl0c0NvbXBvc2l0ZV9kaXNhYmxlSGl0c0RlZmF1bHQ7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRGlzYWJsZUhpdHNDb21wb3NpdGVfZGlzYWJsZUhpdHNMYWJlbDsKLQkKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDaGFuZ2VUcmFja2luZ0NvbXBvc2l0ZV9sYWJlbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDaGFuZ2VUcmFja2luZ0NvbXBvc2l0ZV9hdHRyaWJ1dGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ2hhbmdlVHJhY2tpbmdDb21wb3NpdGVfb2JqZWN0OwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENoYW5nZVRyYWNraW5nQ29tcG9zaXRlX2RlZmVycmVkOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENoYW5nZVRyYWNraW5nQ29tcG9zaXRlX2F1dG87Ci0JCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ29udmVydENvbXBvc2l0ZV9jb252ZXJ0ZXJOYW1lTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ29udmVydENvbXBvc2l0ZV9kZWZpbmVDb252ZXJ0ZXJTZWN0aW9uOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENvbnZlcnRDb21wb3NpdGVfZGVmYXVsdDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDb252ZXJ0Q29tcG9zaXRlX2N1c3RvbTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDb252ZXJ0Q29tcG9zaXRlX3R5cGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ29udmVydENvbXBvc2l0ZV9vYmplY3RUeXBlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENvbnZlcnRDb21wb3NpdGVfc3RydWN0OwotCQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENvbnZlcnRlckNvbXBvc2l0ZV9uYW1lVGV4dExhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENvbnZlcnRlckNvbXBvc2l0ZV9jbGFzc0xhYmVsOwotCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ29udmVydGVyc0NvbXBvc2l0ZV9jdXN0b21Db252ZXJ0ZXI7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ29udmVydGVyc0NvbXBvc2l0ZV9vYmplY3RUeXBlQ29udmVydGVyOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENvbnZlcnRlcnNDb21wb3NpdGVfc3RydWN0Q29udmVydGVyOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENvbnZlcnRlcnNDb21wb3NpdGVfdHlwZUNvbnZlcnRlcjsKLQkKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDdXN0b21pemVyQ29tcG9zaXRlX2NsYXNzTGFiZWw7Ci0JCQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFR5cGVTZWN0aW9uX2NvbnZlcnRlZDsKLQkKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBFeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZV9sYWJlbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBKYXZhRXhpc3RlbmNlQ2hlY2tpbmdDb21wb3NpdGVfY2hlY2tfY2FjaGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgSmF2YUV4aXN0ZW5jZUNoZWNraW5nQ29tcG9zaXRlX2NoZWNrX2RhdGFiYXNlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEphdmFFeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZV9hc3N1bWVfZXhpc3RlbmNlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEphdmFFeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZV9hc3N1bWVfbm9uX2V4aXN0ZW5jZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBPcm1FeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZV9jaGVja19jYWNoZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBPcm1FeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZV9jaGVja19kYXRhYmFzZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBPcm1FeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZV9hc3N1bWVfZXhpc3RlbmNlOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIE9ybUV4aXN0ZW5jZUNoZWNraW5nQ29tcG9zaXRlX2Fzc3VtZV9ub25fZXhpc3RlbmNlOwotCQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEV4cGlyeUNvbXBvc2l0ZV9leHBpcnlTZWN0aW9uOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEV4cGlyeUNvbXBvc2l0ZV9ub0V4cGlyeTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBFeHBpcnlDb21wb3NpdGVfdGltZVRvTGl2ZUV4cGlyeTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBFeHBpcnlDb21wb3NpdGVfdGltZVRvTGl2ZUV4cGlyeUV4cGlyZUFmdGVyOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEV4cGlyeUNvbXBvc2l0ZV90aW1lVG9MaXZlRXhwaXJ5TWlsbGlzZWNvbmRzOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEV4cGlyeUNvbXBvc2l0ZV9kYWlseUV4cGlyeTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBFeHBpcnlDb21wb3NpdGVfdGltZU9mRGF5RXhwaXJ5RXhwaXJlQXQ7Ci0JCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgSm9pbkZldGNoQ29tcG9zaXRlX2xhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEpvaW5GZXRjaENvbXBvc2l0ZV9pbm5lcjsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBKb2luRmV0Y2hDb21wb3NpdGVfb3V0ZXI7CQotCQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIE11dGFibGVDb21wb3NpdGVfbXV0YWJsZUxhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIE11dGFibGVDb21wb3NpdGVfbXV0YWJsZUxhYmVsRGVmYXVsdDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBNdXRhYmxlQ29tcG9zaXRlX3RydWU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgTXV0YWJsZUNvbXBvc2l0ZV9mYWxzZTsKLQkKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBPYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlX2RhdGFUeXBlTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgT2JqZWN0VHlwZUNvbnZlcnRlckNvbXBvc2l0ZV9vYmplY3RUeXBlTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgT2JqZWN0VHlwZUNvbnZlcnRlckNvbXBvc2l0ZV9jb252ZXJzaW9uVmFsdWVFZGl0OwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIE9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGVfY29udmVyc2lvblZhbHVlc0RhdGFWYWx1ZUNvbHVtbjsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBPYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlX2NvbnZlcnNpb25WYWx1ZXNPYmplY3RWYWx1ZUNvbHVtbjsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBPYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlX2RlZmF1bHRPYmplY3RWYWx1ZUxhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIE9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGVfY29udmVyc2lvblZhbHVlc0dyb3VwVGl0bGU7Ci0JCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ29udmVyc2lvblZhbHVlRGlhbG9nX2FkZENvbnZlcnNpb25WYWx1ZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDb252ZXJzaW9uVmFsdWVEaWFsb2dfZWRpdENvbnZlcnNpb25WYWx1ZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDb252ZXJzaW9uVmFsdWVEaWFsb2dfYWRkQ29udmVyc2lvblZhbHVlRGVzY3JpcHRpb25UaXRsZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDb252ZXJzaW9uVmFsdWVEaWFsb2dfZWRpdENvbnZlcnNpb25WYWx1ZURlc2NyaXB0aW9uVGl0bGU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ29udmVyc2lvblZhbHVlRGlhbG9nX2FkZENvbnZlcnNpb25WYWx1ZURlc2NyaXB0aW9uOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENvbnZlcnNpb25WYWx1ZURpYWxvZ19lZGl0Q29udmVyc2lvblZhbHVlRGVzY3JpcHRpb247Ci0JCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ29udmVyc2lvblZhbHVlRGlhbG9nX2RhdGFWYWx1ZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDb252ZXJzaW9uVmFsdWVEaWFsb2dfb2JqZWN0VmFsdWU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgQ29udmVyc2lvblZhbHVlU3RhdGVPYmplY3RfZGF0YVZhbHVlTXVzdEJlU3BlY2lmaWVkOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENvbnZlcnNpb25WYWx1ZVN0YXRlT2JqZWN0X29iamVjdFZhbHVlTXVzdEJlU3BlY2lmaWVkOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIENvbnZlcnNpb25WYWx1ZVN0YXRlT2JqZWN0X2RhdGFWYWx1ZUFscmVhZHlFeGlzdHM7Ci0JCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgUHJpdmF0ZU93bmVkQ29tcG9zaXRlX3ByaXZhdGVPd25lZExhYmVsOwotCQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIFJlYWRPbmx5Q29tcG9zaXRlX3JlYWRPbmx5TGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgUmVhZE9ubHlDb21wb3NpdGVfcmVhZE9ubHlXaXRoRGVmYXVsdDsKLQkKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUeXBlQ29udmVydGVyQ29tcG9zaXRlX2RhdGFUeXBlTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgVHlwZUNvbnZlcnRlckNvbXBvc2l0ZV9vYmplY3RUeXBlTGFiZWw7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBEZWZhdWx0T25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcl9sYWJlbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBEZWZhdWx0VmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyX2xhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIERlZmF1bHRPbmVUb01hbnlNYXBwaW5nVWlQcm92aWRlcl9sYWJlbDsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBEZWZhdWx0T25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcl9saW5rTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRGVmYXVsdFZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcl9saW5rTGFiZWw7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRGVmYXVsdE9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyX2xpbmtMYWJlbDsKLQkKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBDb252ZXJ0ZXJzQ29tcG9zaXRlX0xhYmVsOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEVjbGlwc2VMaW5rQ29udmVydGVyRGlhbG9nX25hbWU7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRWNsaXBzZUxpbmtDb252ZXJ0ZXJEaWFsb2dfY29udmVydGVyVHlwZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBFY2xpcHNlTGlua0NvbnZlcnRlckRpYWxvZ19hZGRDb252ZXJ0ZXI7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRWNsaXBzZUxpbmtDb252ZXJ0ZXJEaWFsb2dfYWRkQ29udmVydGVyRGVzY3JpcHRpb25UaXRsZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBFY2xpcHNlTGlua0NvbnZlcnRlckRpYWxvZ19hZGRDb252ZXJ0ZXJEZXNjcmlwdGlvbjsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBFY2xpcHNlTGlua0NvbnZlcnRlclN0YXRlT2JqZWN0X25hbWVNdXN0QmVTcGVjaWZpZWQ7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRWNsaXBzZUxpbmtDb252ZXJ0ZXJTdGF0ZU9iamVjdF90eXBlTXVzdEJlU3BlY2lmaWVkOwotCQotCXN0YXRpYyB7Ci0JCU5MUy5pbml0aWFsaXplTWVzc2FnZXMoImVjbGlwc2VsaW5rX3VpX21hcHBpbmdzIiwgRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuY2xhc3MpOwotCX0KLQotCXByaXZhdGUgRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMoKSB7Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0Fsd2F5c1JlZnJlc2hDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQWx3YXlzUmVmcmVzaENvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzZDNiY2Y5Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQWx3YXlzUmVmcmVzaENvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTEzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLkpwdFVpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0KLS8qKgotICogVGhpcyBjb21wb3NpdGUgc2ltcGx5IHNob3dzIGEgdHJpLXN0YXRlIGNoZWNrIGJveCBmb3IgdGhlIEFsd2F5cyBSZWZyZXNoIG9wdGlvbi4KLSAqIAotICogQHNlZSBFY2xpcHNlTGlua0NhY2hpbmcKLSAqIEBzZWUgQ2FjaGluZ0NvbXBvc2l0ZSAtIEEgY29udGFpbmVyIG9mIHRoaXMgd2lkZ2V0Ci0gKgotICogQHZlcnNpb24gMi4xCi0gKiBAc2luY2UgMi4xCi0gKi8KLXB1YmxpYyBjbGFzcyBBbHdheXNSZWZyZXNoQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8Q2FjaGluZz4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPk9wdGlvbmFsQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRQYW5lIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBBbHdheXNSZWZyZXNoQ29tcG9zaXRlKEZvcm1QYW5lPD8gZXh0ZW5kcyBDYWNoaW5nPiBwYXJlbnRQYW5lLAotCSAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KQotCXsKLQkJc3VwZXIocGFyZW50UGFuZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkQWx3YXlzUmVmcmVzaEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q2FjaGluZywgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDYWNoaW5nLlNQRUNJRklFRF9BTFdBWVNfUkVGUkVTSF9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldFNwZWNpZmllZEFsd2F5c1JlZnJlc2goKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCXRoaXMuc3ViamVjdC5zZXRTcGVjaWZpZWRBbHdheXNSZWZyZXNoKHZhbHVlKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzdWJqZWN0Q2hhbmdlZCgpIHsKLQkJCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0JCQkJc3VwZXIuc3ViamVjdENoYW5nZWQoKTsKLQkJCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0KLQkJCQkvLyBNYWtlIHN1cmUgdGhlIGRlZmF1bHQgdmFsdWUgaXMgYXBwZW5kZWQgdG8gdGhlIHRleHQKLQkJCQlpZiAob2xkVmFsdWUgPT0gbmV3VmFsdWUgJiYgbmV3VmFsdWUgPT0gbnVsbCkgewotCQkJCQl0aGlzLmZpcmVBc3BlY3RDaGFuZ2UoQm9vbGVhbi5UUlVFLCBuZXdWYWx1ZSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRBbHdheXNSZWZyZXNoU3RyaW5nSG9sZGVyKCkgewotCi0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbiwgU3RyaW5nPihidWlsZEFsd2F5c1JlZnJlc2hIb2xkZXIoKSkgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKEJvb2xlYW4gdmFsdWUpIHsKLQotCQkJCWlmICgoZ2V0U3ViamVjdCgpICE9IG51bGwpICYmICh2YWx1ZSA9PSBudWxsKSkgewotCi0JCQkJCUJvb2xlYW4gZGVmYXVsdFZhbHVlID0gZ2V0U3ViamVjdCgpLmlzRGVmYXVsdEFsd2F5c1JlZnJlc2goKTsKLQotCQkJCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQotCQkJCQkJU3RyaW5nIGRlZmF1bHRTdHJpbmdWYWx1ZSA9IGRlZmF1bHRWYWx1ZSA/IEpwdFVpTWFwcGluZ3NNZXNzYWdlcy5Cb29sZWFuX1RydWUgOgotCQkJCQkJICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEpwdFVpTWFwcGluZ3NNZXNzYWdlcy5Cb29sZWFuX0ZhbHNlOwotCi0JCQkJCQlyZXR1cm4gTkxTLmJpbmQoCi0JCQkJCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQWx3YXlzUmVmcmVzaENvbXBvc2l0ZV9hbHdheXNSZWZyZXNoRGVmYXVsdCwKLQkJCQkJCQlkZWZhdWx0U3RyaW5nVmFsdWUKLQkJCQkJCSk7Ci0JCQkJCX0KLQkJCQl9Ci0KLQkJCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQWx3YXlzUmVmcmVzaENvbXBvc2l0ZV9hbHdheXNSZWZyZXNoTGFiZWw7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCWFkZFRyaVN0YXRlQ2hlY2tCb3hXaXRoRGVmYXVsdCgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkFsd2F5c1JlZnJlc2hDb21wb3NpdGVfYWx3YXlzUmVmcmVzaExhYmVsLAotCQkJYnVpbGRBbHdheXNSZWZyZXNoSG9sZGVyKCksCi0JCQlidWlsZEFsd2F5c1JlZnJlc2hTdHJpbmdIb2xkZXIoKSwKLQkJCUVjbGlwc2VMaW5rSGVscENvbnRleHRJZHMuQ0FDSElOR19BTFdBWVNfUkVGUkVTSAotCQkpOwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0Jhc2ljQ29sbGVjdGlvbk1hcHBpbmdDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQmFzaWNDb2xsZWN0aW9uTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzMmU0OGM2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQmFzaWNDb2xsZWN0aW9uTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5CYXNpY0NvbGxlY3Rpb25NYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIEJhc2ljQ29sbGVjdGlvbk1hcHBpbmdDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxCYXNpY0NvbGxlY3Rpb25NYXBwaW5nPgotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW1wbGVtZW50cyBKcGFDb21wb3NpdGUKLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkVjbGlwc2VMaW5rQmFzaWNDb2xsZWN0aW9uTWFwcGluZ0NvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gc3ViamVjdEhvbGRlciBUaGUgaG9sZGVyIG9mIHRoZSBzdWJqZWN0IDxjb2RlPklNYW55VG9PbmVNYXBwaW5nPC9jb2RlPgotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKiBAcGFyYW0gd2lkZ2V0RmFjdG9yeSBUaGUgZmFjdG9yeSB1c2VkIHRvIGNyZWF0ZSB2YXJpb3VzIGNvbW1vbiB3aWRnZXRzCi0JICovCi0JcHVibGljIEJhc2ljQ29sbGVjdGlvbk1hcHBpbmdDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBCYXNpY0NvbGxlY3Rpb25NYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQmFzaWNNYXBNYXBwaW5nQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0Jhc2ljTWFwTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAzNDA0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQmFzaWNNYXBNYXBwaW5nQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0NSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkJhc2ljTWFwTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKgotICogQHZlcnNpb24gMi4xCi0gKiBAc2luY2UgMi4xCi0gKi8KLXB1YmxpYyBjbGFzcyBCYXNpY01hcE1hcHBpbmdDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxCYXNpY01hcE1hcHBpbmc+Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbXBsZW1lbnRzIEpwYUNvbXBvc2l0ZQotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+RWNsaXBzZUxpbmtCYXNpY0NvbGxlY3Rpb25NYXBwaW5nQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBzdWJqZWN0SG9sZGVyIFRoZSBob2xkZXIgb2YgdGhlIHN1YmplY3QgPGNvZGU+SU1hbnlUb09uZU1hcHBpbmc8L2NvZGU+Ci0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqIEBwYXJhbSB3aWRnZXRGYWN0b3J5IFRoZSBmYWN0b3J5IHVzZWQgdG8gY3JlYXRlIHZhcmlvdXMgY29tbW9uIHdpZGdldHMKLQkgKi8KLQlwdWJsaWMgQmFzaWNNYXBNYXBwaW5nQ29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgQmFzaWNNYXBNYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQ2FjaGVDb29yZGluYXRpb25UeXBlQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0NhY2hlQ29vcmRpbmF0aW9uVHlwZUNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiNTIxN2Y5Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQ2FjaGVDb29yZGluYXRpb25UeXBlQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMDYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzCi0gKiAgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZgotICogIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcwotICogIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotICoKLSAqICBDb250cmlidXRvcnM6IE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQ2FjaGVDb29yZGluYXRpb25UeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRW51bUZvcm1Db21ib1ZpZXdlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogSGVyZSBpcyB0aGUgbGF5b3V0IG9mIHRoaXMgcGFuZToKLSAqIDxwcmU+Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gKiB8ICAgICAgICAgICAgICAgICAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IENvb3JkaW5hdGlvbiBUeXBlOiB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHx2fCB8Ci0gKiB8ICAgICAgICAgICAgICAgICAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSBFY2xpcHNlTGlua0NhY2hpbmcKLSAqIEBzZWUgQ2FjaGluZ0NvbXBvc2l0ZSAtIEEgY29udGFpbmVyIG9mIHRoaXMgd2lkZ2V0Ci0gKgotICogQHZlcnNpb24gMi4xCi0gKiBAc2luY2UgMi4xCi0gKi8KLXB1YmxpYyBjbGFzcyBDYWNoZUNvb3JkaW5hdGlvblR5cGVDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxDYWNoaW5nPiB7Ci0KLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkNhY2hlVHlwZUNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgQ2FjaGVDb29yZGluYXRpb25UeXBlQ29tcG9zaXRlKEZvcm1QYW5lPD8gZXh0ZW5kcyBDYWNoaW5nPiBwYXJlbnRQYW5lLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudFBhbmUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBFbnVtRm9ybUNvbWJvVmlld2VyPENhY2hpbmcsIENhY2hlQ29vcmRpbmF0aW9uVHlwZT4gYWRkQ2FjaGVDb29yZGluYXRpb25UeXBlQ29tYm8oQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXJldHVybiBuZXcgRW51bUZvcm1Db21ib1ZpZXdlcjxDYWNoaW5nLCBDYWNoZUNvb3JkaW5hdGlvblR5cGU+KHRoaXMsIGNvbnRhaW5lcikgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIGFkZFByb3BlcnR5TmFtZXMoQ29sbGVjdGlvbjxTdHJpbmc+IHByb3BlcnR5TmFtZXMpIHsKLQkJCQlzdXBlci5hZGRQcm9wZXJ0eU5hbWVzKHByb3BlcnR5TmFtZXMpOwotCQkJCXByb3BlcnR5TmFtZXMuYWRkKENhY2hpbmcuREVGQVVMVF9DT09SRElOQVRJT05fVFlQRV9QUk9QRVJUWSk7Ci0JCQkJcHJvcGVydHlOYW1lcy5hZGQoQ2FjaGluZy5TUEVDSUZJRURfQ09PUkRJTkFUSU9OX1RZUEVfUFJPUEVSVFkpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDYWNoZUNvb3JkaW5hdGlvblR5cGVbXSBnZXRDaG9pY2VzKCkgewotCQkJCXJldHVybiBDYWNoZUNvb3JkaW5hdGlvblR5cGUudmFsdWVzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENhY2hlQ29vcmRpbmF0aW9uVHlwZSBnZXREZWZhdWx0VmFsdWUoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXREZWZhdWx0Q29vcmRpbmF0aW9uVHlwZSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZGlzcGxheVN0cmluZyhDYWNoZUNvb3JkaW5hdGlvblR5cGUgdmFsdWUpIHsKLQkJCQlyZXR1cm4gYnVpbGREaXNwbGF5U3RyaW5nKAotCQkJCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5jbGFzcywKLQkJCQkJQ2FjaGVDb29yZGluYXRpb25UeXBlQ29tcG9zaXRlLnRoaXMsCi0JCQkJCXZhbHVlCi0JCQkJKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ2FjaGVDb29yZGluYXRpb25UeXBlIGdldFZhbHVlKCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0U3BlY2lmaWVkQ29vcmRpbmF0aW9uVHlwZSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlKENhY2hlQ29vcmRpbmF0aW9uVHlwZSB2YWx1ZSkgewotCQkJCWdldFN1YmplY3QoKS5zZXRTcGVjaWZpZWRDb29yZGluYXRpb25UeXBlKHZhbHVlKTsKLQkJCX0KLQkJCQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgYm9vbGVhbiBzb3J0Q2hvaWNlcygpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJYWRkTGFiZWxlZENvbXBvc2l0ZSgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkNhY2hlQ29vcmRpbmF0aW9uVHlwZUNvbXBvc2l0ZV9sYWJlbCwKLQkJCWFkZENhY2hlQ29vcmRpbmF0aW9uVHlwZUNvbWJvKGNvbnRhaW5lciksCi0JCQlFY2xpcHNlTGlua0hlbHBDb250ZXh0SWRzLkNBQ0hJTkdfQ0FDSEVfQ09PUkRJTkFUSU9OX1RZUEUKLQkJKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0NhY2hlU2l6ZUNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9DYWNoZVNpemVDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggY2E0NjQ2Ni4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0NhY2hlU2l6ZUNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTc2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiAgQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcwotICogIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YKLSAqICB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMKLSAqICBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSAqCi0gKiAgQ29udHJpYnV0b3JzOiBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkNhY2hpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLkVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5KcHRVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuTGFiZWxlZENvbnRyb2xVcGRhdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLkxhYmVsZWRMYWJlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkRGF0YTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29udHJvbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5MYWJlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5TcGlubmVyOwotCi0vKioKLSAqIEhlcmUgaXMgdGhlIGxheW91dCBvZiB0aGlzIHBhbmU6Ci0gKiA8cHJlPgotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotICogfCAgICAgICAgICAgICAgICAgICAgICAtLS0tLS0tLS0tLS0tLS0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIHwgICBTaXplOiAgICAgICAgICAgICAgfCBJICAgICAgICAgfEl8ICBEZWZhdWx0IChYWFgpICAgICAgICAgICAgICAgICAgICAgICB8Ci0gKiB8ICAgICAgICAgICAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLTwvcHJlPgotICoKLSAqIEBzZWUgRWNsaXBzZUxpbmtDYWNoaW5nCi0gKiBAc2VlIENhY2hpbmdDb21wb3NpdGUgLSBBIGNvbnRhaW5lciBvZiB0aGlzIHdpZGdldAotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgQ2FjaGVTaXplQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8Q2FjaGluZz4gewotCi0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5DYWNoZVNpemVDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudFBhbmUgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIENhY2hlU2l6ZUNvbXBvc2l0ZShGb3JtUGFuZTw/IGV4dGVuZHMgQ2FjaGluZz4gcGFyZW50UGFuZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRQYW5lLCBwYXJlbnQpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCS8vIFNpemUgd2lkZ2V0cwotCQlTcGlubmVyIHNpemVTcGlubmVyID0gYWRkTGFiZWxlZFNwaW5uZXIoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5DYWNoZVNpemVDb21wb3NpdGVfc2l6ZSwKLQkJCWJ1aWxkU2l6ZUhvbGRlcigpLAotCQkJLTEsCi0JCQktMSwKLQkJCUludGVnZXIuTUFYX1ZBTFVFLAotCQkJYWRkRGVmYXVsdFNpemVMYWJlbChjb250YWluZXIpLAotCQkJbnVsbC8vVE9ETyBKcGFIZWxwQ29udGV4dElkcy5NQVBQSU5HX0NPTFVNTl9MRU5HVEgKLQkJKTsKLQotCQl1cGRhdGVHcmlkRGF0YShjb250YWluZXIsIHNpemVTcGlubmVyKTsKLQl9Ci0JCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyPiBidWlsZFNpemVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENhY2hpbmcsIEludGVnZXI+KGdldFN1YmplY3RIb2xkZXIoKSwgQ2FjaGluZy5TUEVDSUZJRURfU0laRV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSW50ZWdlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRTcGVjaWZpZWRTaXplKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEludGVnZXIgdmFsdWUpIHsKLQkJCQlpZiAodmFsdWUgPT0gLTEpIHsKLQkJCQkJdmFsdWUgPSBudWxsOwotCQkJCX0KLQkJCQlzdWJqZWN0LnNldFNwZWNpZmllZFNpemUodmFsdWUpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4gYnVpbGREZWZhdWx0U2l6ZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q2FjaGluZywgSW50ZWdlcj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDYWNoaW5nLkRFRkFVTFRfU0laRV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSW50ZWdlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXREZWZhdWx0U2l6ZSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHN1YmplY3RDaGFuZ2VkKCkgewotCQkJCU9iamVjdCBvbGRWYWx1ZSA9IHRoaXMuZ2V0VmFsdWUoKTsKLQkJCQlzdXBlci5zdWJqZWN0Q2hhbmdlZCgpOwotCQkJCU9iamVjdCBuZXdWYWx1ZSA9IHRoaXMuZ2V0VmFsdWUoKTsKLQotCQkJCS8vIE1ha2Ugc3VyZSB0aGUgZGVmYXVsdCB2YWx1ZSBpcyBhcHBlbmRlZCB0byB0aGUgdGV4dAotCQkJCWlmIChvbGRWYWx1ZSA9PSBuZXdWYWx1ZSAmJiBuZXdWYWx1ZSA9PSBudWxsKSB7Ci0JCQkJCXRoaXMuZmlyZUFzcGVjdENoYW5nZShJbnRlZ2VyLk1JTl9WQUxVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbnRyb2wgYWRkRGVmYXVsdFNpemVMYWJlbChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJTGFiZWwgbGFiZWwgPSBhZGRMYWJlbCgKLQkJCWNvbnRhaW5lciwKLQkJCUpwdFVpTWFwcGluZ3NNZXNzYWdlcy5EZWZhdWx0RW1wdHkKLQkJKTsKLQotCQluZXcgTGFiZWxlZENvbnRyb2xVcGRhdGVyKAotCQkJbmV3IExhYmVsZWRMYWJlbChsYWJlbCksCi0JCQlidWlsZERlZmF1bHRTaXplTGFiZWxIb2xkZXIoKQotCQkpOwotCi0JCXJldHVybiBsYWJlbDsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdFNpemVMYWJlbEhvbGRlcigpIHsKLQotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXIsIFN0cmluZz4oYnVpbGREZWZhdWx0U2l6ZUhvbGRlcigpKSB7Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oSW50ZWdlciB2YWx1ZSkgewotCi0JCQkJSW50ZWdlciBkZWZhdWx0VmFsdWUgPSAoZ2V0U3ViamVjdCgpICE9IG51bGwpID8gZ2V0U3ViamVjdCgpLmdldERlZmF1bHRTaXplKCkgOgotCQkJCQkJCQlDYWNoaW5nLkRFRkFVTFRfU0laRTsKLQotCQkJCXJldHVybiBOTFMuYmluZCgKLQkJCQkJSnB0VWlNYXBwaW5nc01lc3NhZ2VzLkRlZmF1bHRXaXRoT25lUGFyYW0sCi0JCQkJCWRlZmF1bHRWYWx1ZQotCQkJCSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JLyoqCi0JICogQ2hhbmdlcyB0aGUgbGF5b3V0IG9mIHRoZSBnaXZlbiBjb250YWluZXIgYnkgY2hhbmdpbmcgd2hpY2ggd2lkZ2V0IHdpbGwKLQkgKiBncmFiIHRoZSBleGNlc3Mgb2YgaG9yaXpvbnRhbCBzcGFjZS4gQnkgZGVmYXVsdCwgdGhlIGNlbnRlciBjb250cm9sIGdyYWJzCi0JICogdGhlIGV4Y2VzcyBzcGFjZSwgd2UgY2hhbmdlIGl0IHRvIGJlIHRoZSByaWdodCBjb250cm9sLgotCSAqCi0JICogQHBhcmFtIGNvbnRhaW5lciBUaGUgY29udGFpbmVyIGNvbnRhaW5pbmcgdGhlIGNvbnRyb2xzIG5lZWRpbmcgdGhlaXIKLQkgKiA8Y29kZT5HcmlkRGF0YTwvY29kZT4gdG8gYmUgbW9kaWZpZWQgZnJvbSB0aGUgZGVmYXVsdCB2YWx1ZXMKLQkgKiBAcGFyYW0gc3Bpbm5lciBUaGUgc3Bpbm5lciB0aGF0IGdvdCBjcmVhdGVkCi0JICovCi0JcHJpdmF0ZSB2b2lkIHVwZGF0ZUdyaWREYXRhKENvbXBvc2l0ZSBjb250YWluZXIsIFNwaW5uZXIgc3Bpbm5lcikgewotCi0JCS8vIEl0IGlzIHBvc3NpYmxlIHRoZSBzcGlubmVyJ3MgcGFyZW50IGlzIG5vdCB0aGUgY29udGFpbmVyIG9mIHRoZQotCQkvLyBsYWJlbCwgc3Bpbm5lciBhbmQgcmlnaHQgY29udHJvbCAoYSBwYW5lIGlzIHNvbWV0aW1lcyByZXF1aXJlZCBmb3IKLQkJLy8gcGFpbnRpbmcgdGhlIHNwaW5uZXIncyBib3JkZXIpCi0JCUNvbXBvc2l0ZSBwYW5lQ29udGFpbmVyID0gc3Bpbm5lci5nZXRQYXJlbnQoKTsKLQotCQl3aGlsZSAoY29udGFpbmVyICE9IHBhbmVDb250YWluZXIuZ2V0UGFyZW50KCkpIHsKLQkJCXBhbmVDb250YWluZXIgPSBwYW5lQ29udGFpbmVyLmdldFBhcmVudCgpOwotCQl9Ci0KLQkJQ29udHJvbFtdIGNvbnRyb2xzID0gcGFuZUNvbnRhaW5lci5nZXRDaGlsZHJlbigpOwotCi0JCUdyaWREYXRhIGdyaWREYXRhID0gbmV3IEdyaWREYXRhKCk7Ci0JCWdyaWREYXRhLmdyYWJFeGNlc3NIb3Jpem9udGFsU3BhY2UgPSBmYWxzZTsKLQkJZ3JpZERhdGEuaG9yaXpvbnRhbEFsaWdubWVudCAgICAgICA9IEdyaWREYXRhLkJFR0lOTklORzsKLQkJY29udHJvbHNbMV0uc2V0TGF5b3V0RGF0YShncmlkRGF0YSk7Ci0KLQkJY29udHJvbHNbMl0uc2V0TGF5b3V0RGF0YShuZXcgR3JpZERhdGEoR3JpZERhdGEuRklMTF9IT1JJWk9OVEFMKSk7Ci0JCXJlbW92ZUFsaWduUmlnaHQoY29udHJvbHNbMl0pOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQ2FjaGVUeXBlQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0NhY2hlVHlwZUNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkNjk4MWUwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQ2FjaGVUeXBlQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMDYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzCi0gKiAgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZgotICogIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcwotICogIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotICoKLSAqICBDb250cmlidXRvcnM6IE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQ2FjaGVUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRW51bUZvcm1Db21ib1ZpZXdlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogSGVyZSBpcyB0aGUgbGF5b3V0IG9mIHRoaXMgcGFuZToKLSAqIDxwcmU+Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gKiB8ICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IFR5cGU6IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHx2fCB8Ci0gKiB8ICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSBFY2xpcHNlTGlua0NhY2hpbmcKLSAqIEBzZWUgQ2FjaGluZ0NvbXBvc2l0ZSAtIEEgY29udGFpbmVyIG9mIHRoaXMgd2lkZ2V0Ci0gKgotICogQHZlcnNpb24gMi4xCi0gKiBAc2luY2UgMi4xCi0gKi8KLXB1YmxpYyBjbGFzcyBDYWNoZVR5cGVDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxDYWNoaW5nPiB7Ci0KLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkNhY2hlVHlwZUNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgQ2FjaGVUeXBlQ29tcG9zaXRlKEZvcm1QYW5lPD8gZXh0ZW5kcyBDYWNoaW5nPiBwYXJlbnRQYW5lLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudFBhbmUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBFbnVtRm9ybUNvbWJvVmlld2VyPENhY2hpbmcsIENhY2hlVHlwZT4gYWRkQ2FjaGVUeXBlQ29tYm8oQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXJldHVybiBuZXcgRW51bUZvcm1Db21ib1ZpZXdlcjxDYWNoaW5nLCBDYWNoZVR5cGU+KHRoaXMsIGNvbnRhaW5lcikgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIGFkZFByb3BlcnR5TmFtZXMoQ29sbGVjdGlvbjxTdHJpbmc+IHByb3BlcnR5TmFtZXMpIHsKLQkJCQlzdXBlci5hZGRQcm9wZXJ0eU5hbWVzKHByb3BlcnR5TmFtZXMpOwotCQkJCXByb3BlcnR5TmFtZXMuYWRkKENhY2hpbmcuREVGQVVMVF9UWVBFX1BST1BFUlRZKTsKLQkJCQlwcm9wZXJ0eU5hbWVzLmFkZChDYWNoaW5nLlNQRUNJRklFRF9UWVBFX1BST1BFUlRZKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ2FjaGVUeXBlW10gZ2V0Q2hvaWNlcygpIHsKLQkJCQlyZXR1cm4gQ2FjaGVUeXBlLnZhbHVlcygpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDYWNoZVR5cGUgZ2V0RGVmYXVsdFZhbHVlKCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0RGVmYXVsdFR5cGUoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGRpc3BsYXlTdHJpbmcoQ2FjaGVUeXBlIHZhbHVlKSB7Ci0JCQkJcmV0dXJuIGJ1aWxkRGlzcGxheVN0cmluZygKLQkJCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuY2xhc3MsCi0JCQkJCUNhY2hlVHlwZUNvbXBvc2l0ZS50aGlzLAotCQkJCQl2YWx1ZQotCQkJCSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENhY2hlVHlwZSBnZXRWYWx1ZSgpIHsKLQkJCQlyZXR1cm4gZ2V0U3ViamVjdCgpLmdldFNwZWNpZmllZFR5cGUoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZShDYWNoZVR5cGUgdmFsdWUpIHsKLQkJCQlnZXRTdWJqZWN0KCkuc2V0U3BlY2lmaWVkVHlwZSh2YWx1ZSk7Ci0JCQl9Ci0JCQkKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGJvb2xlYW4gc29ydENob2ljZXMoKSB7Ci0JCQkJcmV0dXJuIGZhbHNlOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCWFkZExhYmVsZWRDb21wb3NpdGUoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5DYWNoZVR5cGVDb21wb3NpdGVfbGFiZWwsCi0JCQlhZGRDYWNoZVR5cGVDb21ibyhjb250YWluZXIpLAotCQkJRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcy5DQUNISU5HX0NBQ0hFX1RZUEUKLQkJKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0NhY2hpbmdDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQ2FjaGluZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3YzY0YTgyLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQ2FjaGluZ0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTc4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5DYWNoaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua0hlbHBDb250ZXh0SWRzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5BbHdheXNSZWZyZXNoQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkNhY2hlQ29vcmRpbmF0aW9uVHlwZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5DYWNoZVNpemVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuQ2FjaGVUeXBlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkRpc2FibGVIaXRzQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkV4cGlyeUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5SZWZyZXNoT25seUlmTmV3ZXJDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLkpwdFVpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwudXRpbC5QYW5lRW5hYmxlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFRoaXMgcGFuZSBzaG93cyB0aGUgY2FjaGluZyBvcHRpb25zLgotICogPHA+Ci0gKiBIZXJlIHRoZSBsYXlvdXQgb2YgdGhpcyBwYW5lOgotICogPHByZT4KLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gKiB8IHggU2hhcmVkICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogfCAgICBDYWNoZVR5cGVDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIHwgICAgQ2FjaGVTaXplQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0gKiB8ICAgID4gQWR2YW5jZWQgICAJICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIHwgICAgCUV4cGlyeUNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0gKiB8ICAgIAlBbHdheXNSZWZyZXNoQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogfCAgIAkJUmVmcmVzaE9ubHlJZk5ld2VyQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIHwgICAgCURpc2FibGVIaXRzQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0gKiB8ICAgIAlDYWNoZUNvb3JkaW5hdGlvbkNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogfCBFeGlzdGVuY2VUeXBlQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSBFbnRpdHkKLSAqIEBzZWUgRWNsaXBzZUxpbmtDYWNoaW5nCi0gKiBAc2VlIEVjbGlwc2VMaW5rSmF2YUVudGl0eUNvbXBvc2l0ZSAtIFRoZSBwYXJlbnQgY29udGFpbmVyCi0gKiBAc2VlIENhY2hlVHlwZUNvbXBvc2l0ZQotICogQHNlZSBDYWNoZVNpemVDb21wb3NpdGUKLSAqIEBzZWUgQWx3YXlzUmVmcmVzaENvbXBvc2l0ZQotICogQHNlZSBSZWZyZXNoT25seUlmTmV3ZXJDb21wb3NpdGUKLSAqIEBzZWUgRGlzYWJsZUhpdHNDb21wb3NpdGUKLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGFic3RyYWN0IGNsYXNzIENhY2hpbmdDb21wb3NpdGU8VCBleHRlbmRzIENhY2hpbmc+IGV4dGVuZHMgRm9ybVBhbmU8VD4KLXsKLQotCXByb3RlY3RlZCBDYWNoaW5nQ29tcG9zaXRlKEZvcm1QYW5lPD8+IHBhcmVudFBhbmUsCi0gICAgICAgIFByb3BlcnR5VmFsdWVNb2RlbDxUPiBzdWJqZWN0SG9sZGVyLAotICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50UGFuZSwgc3ViamVjdEhvbGRlciwgcGFyZW50LCBmYWxzZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJLy9TaGFyZWQgQ2hlY2sgYm94LCB1bmNoZWNrIHRoaXMgYW5kIHRoZSByZXN0IG9mIHRoZSBwYW5lbCBpcyBkaXNhYmxlZAotCQlhZGRUcmlTdGF0ZUNoZWNrQm94V2l0aERlZmF1bHQoCi0JCQlhZGRTdWJQYW5lKGNvbnRhaW5lciwgOCksCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5DYWNoaW5nQ29tcG9zaXRlX3NoYXJlZExhYmVsLAotCQkJYnVpbGRTaGFyZWRIb2xkZXIoKSwKLQkJCWJ1aWxkU2hhcmVkU3RyaW5nSG9sZGVyKCksCi0JCQlFY2xpcHNlTGlua0hlbHBDb250ZXh0SWRzLkNBQ0hJTkdfU0hBUkVECi0JCSk7Ci0KLQkJQ29tcG9zaXRlIHN1YlBhbmUgPSBhZGRTdWJQYW5lKGNvbnRhaW5lciwgMCwgMTYpOwotCi0JCUNvbGxlY3Rpb248UGFuZTw/Pj4gcGFuZXMgPSBuZXcgQXJyYXlMaXN0PFBhbmU8Pz4+KCk7Ci0JCQotCQlwYW5lcy5hZGQobmV3IENhY2hlVHlwZUNvbXBvc2l0ZSh0aGlzLCBzdWJQYW5lKSk7Ci0JCXBhbmVzLmFkZChuZXcgQ2FjaGVTaXplQ29tcG9zaXRlKHRoaXMsIHN1YlBhbmUpKTsKLQkJCi0JCS8vIEFkdmFuY2VkIHN1Yi1wYW5lCi0JCUNvbXBvc2l0ZSBhZHZhbmNlZFNlY3Rpb24gPSBhZGRDb2xsYXBzYWJsZVN1YlNlY3Rpb24oCi0JCQlzdWJQYW5lLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQ2FjaGluZ0NvbXBvc2l0ZV9hZHZhbmNlZCwKLQkJCW5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4oQm9vbGVhbi5GQUxTRSkKLQkJKTsKLQotCQlpbml0aWFsaXplQWR2YW5jZWRQYW5lKGFkZFN1YlBhbmUoYWR2YW5jZWRTZWN0aW9uLCAwLCAxNiksIHBhbmVzKTsKLQkJCQotCQluZXcgUGFuZUVuYWJsZXIoYnVpbGRTaGFyZWRDYWNoZUVuYWJsZXIoKSwgcGFuZXMpOwotCQkKLQkJaW5pdGlhbGl6ZUV4aXN0ZW5jZUNoZWNraW5nQ29tcG9zaXRlKGFkZFN1YlBhbmUoY29udGFpbmVyLCA4KSk7Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVBZHZhbmNlZFBhbmUoQ29tcG9zaXRlIGNvbnRhaW5lciwgQ29sbGVjdGlvbjxQYW5lPD8+PiBwYW5lcykgewotCQlwYW5lcy5hZGQobmV3IEV4cGlyeUNvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpKTsKLQkJcGFuZXMuYWRkKG5ldyBBbHdheXNSZWZyZXNoQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcikpOwotCQlwYW5lcy5hZGQobmV3IFJlZnJlc2hPbmx5SWZOZXdlckNvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpKTsKLQkJcGFuZXMuYWRkKG5ldyBEaXNhYmxlSGl0c0NvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpKTsKLQkJcGFuZXMuYWRkKG5ldyBDYWNoZUNvb3JkaW5hdGlvblR5cGVDb21wb3NpdGUodGhpcywgY29udGFpbmVyKSk7Ci0JfQotCQotCXByb3RlY3RlZCBhYnN0cmFjdCB2b2lkIGluaXRpYWxpemVFeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZShDb21wb3NpdGUgcGFyZW50KTsKLQkKLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZFNoYXJlZENhY2hlRW5hYmxlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q2FjaGluZywgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDYWNoaW5nLlNQRUNJRklFRF9TSEFSRURfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIEJvb2xlYW4udmFsdWVPZih0aGlzLnN1YmplY3QuaXNTaGFyZWQoKSk7Ci0JCQl9Ci0JCX07Ci0JfQkKLQkKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkU2hhcmVkSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDYWNoaW5nLCBCb29sZWFuPihnZXRTdWJqZWN0SG9sZGVyKCksIENhY2hpbmcuU1BFQ0lGSUVEX1NIQVJFRF9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldFNwZWNpZmllZFNoYXJlZCgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldFNwZWNpZmllZFNoYXJlZCh2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc3ViamVjdENoYW5nZWQoKSB7Ci0JCQkJT2JqZWN0IG9sZFZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCQkJCXN1cGVyLnN1YmplY3RDaGFuZ2VkKCk7Ci0JCQkJT2JqZWN0IG5ld1ZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCi0JCQkJLy8gTWFrZSBzdXJlIHRoZSBkZWZhdWx0IHZhbHVlIGlzIGFwcGVuZGVkIHRvIHRoZSB0ZXh0Ci0JCQkJaWYgKG9sZFZhbHVlID09IG5ld1ZhbHVlICYmIG5ld1ZhbHVlID09IG51bGwpIHsKLQkJCQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKEJvb2xlYW4uVFJVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkU2hhcmVkU3RyaW5nSG9sZGVyKCkgewotCi0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbiwgU3RyaW5nPihidWlsZFNoYXJlZEhvbGRlcigpKSB7Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oQm9vbGVhbiB2YWx1ZSkgewotCi0JCQkJaWYgKChnZXRTdWJqZWN0KCkgIT0gbnVsbCkgJiYgKHZhbHVlID09IG51bGwpKSB7Ci0JCQkJCWJvb2xlYW4gZGVmYXVsdFZhbHVlID0gZ2V0U3ViamVjdCgpLmlzRGVmYXVsdFNoYXJlZCgpOwotCi0JCQkJCVN0cmluZyBkZWZhdWx0U3RyaW5nVmFsdWUgPSBkZWZhdWx0VmFsdWUgPyBKcHRVaU1hcHBpbmdzTWVzc2FnZXMuQm9vbGVhbl9UcnVlIDoKLQkJCQkJICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEpwdFVpTWFwcGluZ3NNZXNzYWdlcy5Cb29sZWFuX0ZhbHNlOwotCi0JCQkJCXJldHVybiBOTFMuYmluZCgKLQkJCQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkNhY2hpbmdDb21wb3NpdGVfc2hhcmVkTGFiZWxEZWZhdWx0LAotCQkJCQkJZGVmYXVsdFN0cmluZ1ZhbHVlCi0JCQkJCSk7Ci0JCQkJfQotCi0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkNhY2hpbmdDb21wb3NpdGVfc2hhcmVkTGFiZWw7Ci0JCQl9Ci0JCX07Ci0JfQotCi19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9DaGFuZ2VUcmFja2luZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9DaGFuZ2VUcmFja2luZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3MDQ1N2QwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQ2hhbmdlVHJhY2tpbmdDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEwOCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMKLSAqICBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mCi0gKiAgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzCi0gKiAgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0gKgotICogIENvbnRyaWJ1dG9yczogT3JhY2xlLiAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzOwotCi1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5DaGFuZ2VUcmFja2luZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkNoYW5nZVRyYWNraW5nVHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRW51bUZvcm1Db21ib1ZpZXdlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIEhlcmUgaXMgdGhlIGxheW91dCBvZiB0aGlzIHBhbmU6Ci0gKiA8cHJlPgotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotICogfCAgICAgICAJCQkgIAkJLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IENoYW5nZSBUcmFja2luZyA6ICAgICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHx2fCB8Ci0gKiB8ICAgICAgIAkJCQkJLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSBDaGFuZ2VUcmFja2luZwotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgQ2hhbmdlVHJhY2tpbmdDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxDaGFuZ2VUcmFja2luZz4gewotCi0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5DaGFuZ2VUcmFja2luZ0NvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgQ2hhbmdlVHJhY2tpbmdDb21wb3NpdGUoRm9ybVBhbmU8Pz4gcGFyZW50UGFuZSwgCi0JCQkJCQkJCVByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgQ2hhbmdlVHJhY2tpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQkJCQkJCUNvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRQYW5lLCBzdWJqZWN0SG9sZGVyLCBwYXJlbnQpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCWFkZExhYmVsZWRDb21wb3NpdGUoIAotICAgICAgICAgICAgY29udGFpbmVyLAotICAgICAgICAgICAgYWRkTGFiZWwoIAotICAgICAgICAgICAgICAgICBjb250YWluZXIsIAotICAgICAgICAgICAgICAgICBFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5DaGFuZ2VUcmFja2luZ0NvbXBvc2l0ZV9sYWJlbCksIAotICAgICAgICAgICAgYWRkQ2hhbmdlVHJhY2tpbmdUeXBlQ29tYm8oY29udGFpbmVyKS5nZXRDb250cm9sKCksIAotICAgICAgICAgICAgbnVsbCAKLSAgICAgICApOwotCX0KLQotCXByaXZhdGUgRW51bUZvcm1Db21ib1ZpZXdlcjxDaGFuZ2VUcmFja2luZywgQ2hhbmdlVHJhY2tpbmdUeXBlPiBhZGRDaGFuZ2VUcmFja2luZ1R5cGVDb21ibyhDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJcmV0dXJuIG5ldyBFbnVtRm9ybUNvbWJvVmlld2VyPENoYW5nZVRyYWNraW5nLCBDaGFuZ2VUcmFja2luZ1R5cGU+KHRoaXMsIGNvbnRhaW5lcikgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIGFkZFByb3BlcnR5TmFtZXMoQ29sbGVjdGlvbjxTdHJpbmc+IHByb3BlcnR5TmFtZXMpIHsKLQkJCQlzdXBlci5hZGRQcm9wZXJ0eU5hbWVzKHByb3BlcnR5TmFtZXMpOwotCQkJCXByb3BlcnR5TmFtZXMuYWRkKENoYW5nZVRyYWNraW5nLkRFRkFVTFRfVFlQRV9QUk9QRVJUWSk7Ci0JCQkJcHJvcGVydHlOYW1lcy5hZGQoQ2hhbmdlVHJhY2tpbmcuU1BFQ0lGSUVEX1RZUEVfUFJPUEVSVFkpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDaGFuZ2VUcmFja2luZ1R5cGVbXSBnZXRDaG9pY2VzKCkgewotCQkJCXJldHVybiBDaGFuZ2VUcmFja2luZ1R5cGUudmFsdWVzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENoYW5nZVRyYWNraW5nVHlwZSBnZXREZWZhdWx0VmFsdWUoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXREZWZhdWx0VHlwZSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZGlzcGxheVN0cmluZyhDaGFuZ2VUcmFja2luZ1R5cGUgdmFsdWUpIHsKLQkJCQlyZXR1cm4gYnVpbGREaXNwbGF5U3RyaW5nKAotCQkJCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5jbGFzcywKLQkJCQkJQ2hhbmdlVHJhY2tpbmdDb21wb3NpdGUudGhpcywKLQkJCQkJdmFsdWUKLQkJCQkpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDaGFuZ2VUcmFja2luZ1R5cGUgZ2V0VmFsdWUoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXRTcGVjaWZpZWRUeXBlKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWUoQ2hhbmdlVHJhY2tpbmdUeXBlIHZhbHVlKSB7Ci0JCQkJZ2V0U3ViamVjdCgpLnNldFNwZWNpZmllZFR5cGUodmFsdWUpOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBib29sZWFuIHNvcnRDaG9pY2VzKCkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJfTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0NvbnZlcnNpb25WYWx1ZURpYWxvZy5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9Db252ZXJzaW9uVmFsdWVEaWFsb2cuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTg4NGRhOC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0NvbnZlcnNpb25WYWx1ZURpYWxvZy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjEwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IGphdmEudXRpbC5TZXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5Db252ZXJzaW9uVmFsdWU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5PYmplY3RUeXBlQ29udmVydGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5EaWFsb2dQYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLlZhbGlkYXRpbmdEaWFsb2c7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuU2hlbGw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuVGV4dDsKLQotLyoqCi0gKiBDbGllbnRzIGNhbiB1c2UgdGhpcyBkaWFsb2cgdG8gcHJvbXB0IHRoZSB1c2VyIGZvciBTZWNvbmRhcnlUYWJsZSBzZXR0aW5ncy4KLSAqIFVzZSB0aGUgZm9sbG93aW5nIG9uY2UgdGhlIGRpYWxvZyBpcyBjbG9zZWQ6Ci0gKiAgICAgQHNlZSAjZ2V0U2VsZWN0ZWRUYWJsZSgpCi0gKiAgICAgQHNlZSAjZ2V0U2VsZWN0ZWRDYXRhbG9nKCkKLSAqICAgICBAc2VlICNnZXRTZWxlY3RlZFNjaGVtYSgpCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIENvbnZlcnNpb25WYWx1ZURpYWxvZyBleHRlbmRzIFZhbGlkYXRpbmdEaWFsb2c8Q29udmVyc2lvblZhbHVlU3RhdGVPYmplY3Q+IHsKLQotCS8qKgotCSAqIHdoZW4gY3JlYXRpbmcgYSBuZXcgRWNsaXBzZUxpbmtDb252ZXJzaW9uVmFsdWUsICdjb252ZXJzaW9uVmFsdWUnIHdpbGwgYmUgbnVsbAotCSAqLwotCXByaXZhdGUgZmluYWwgQ29udmVyc2lvblZhbHVlIGNvbnZlcnNpb25WYWx1ZTsKLQotCXByaXZhdGUgT2JqZWN0VHlwZUNvbnZlcnRlciBvYmplY3RUeXBlQ29udmVydGVyOwotCQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIFVzZSB0aGlzIGNvbnN0cnVjdG9yIHRvIGNyZWF0ZSBhIG5ldyBjb252ZXJzaW9uIHZhbHVlCi0JICovCi0JcHVibGljIENvbnZlcnNpb25WYWx1ZURpYWxvZyhTaGVsbCBwYXJlbnQsIE9iamVjdFR5cGVDb252ZXJ0ZXIgb2JqZWN0VHlwZUNvbnZlcnRlcikgewotCQl0aGlzKHBhcmVudCxvYmplY3RUeXBlQ29udmVydGVyLCBudWxsKTsKLQl9Ci0KLQkvKioKLQkgKiBVc2UgdGhpcyBjb25zdHJ1Y3RvciB0byBlZGl0IGFuIGV4aXN0aW5nIGNvbnZlcnNpb24gdmFsdWUKLQkgKi8KLQlwdWJsaWMgQ29udmVyc2lvblZhbHVlRGlhbG9nKFNoZWxsIHBhcmVudCwgT2JqZWN0VHlwZUNvbnZlcnRlciBvYmplY3RUeXBlQ29udmVydGVyLCBDb252ZXJzaW9uVmFsdWUgY29udmVyc2lvblZhbHVlKSB7Ci0JCXN1cGVyKHBhcmVudCk7Ci0JCXRoaXMub2JqZWN0VHlwZUNvbnZlcnRlciA9IG9iamVjdFR5cGVDb252ZXJ0ZXI7Ci0JCXRoaXMuY29udmVyc2lvblZhbHVlID0gY29udmVyc2lvblZhbHVlOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBDb252ZXJzaW9uVmFsdWVTdGF0ZU9iamVjdCBidWlsZFN0YXRlT2JqZWN0KCkgewotCQlTdHJpbmcgZGF0YVZhbHVlID0gbnVsbDsKLQkJU3RyaW5nIG9iamVjdFZhbHVlID0gbnVsbDsKLQkJU2V0PFN0cmluZz4gZGF0YVZhbHVlcyA9IENvbGxlY3Rpb25Ub29scy5zZXQodGhpcy5vYmplY3RUeXBlQ29udmVydGVyLmRhdGFWYWx1ZXMoKSk7Ci0JCWlmIChpc0VkaXREaWFsb2coKSkgewotCQkJZGF0YVZhbHVlID0gdGhpcy5jb252ZXJzaW9uVmFsdWUuZ2V0RGF0YVZhbHVlKCk7Ci0JCQlvYmplY3RWYWx1ZSA9IHRoaXMuY29udmVyc2lvblZhbHVlLmdldE9iamVjdFZhbHVlKCk7Ci0JCQkvL3JlbW92ZSAqdGhpcyogZGF0YVZhbHVlLCBkb24ndCB3YW50IGEgZHVwbGljYXRlIGRhdGEgdmFsdWUgZXJyb3IKLQkJCWRhdGFWYWx1ZXMucmVtb3ZlKGRhdGFWYWx1ZSk7Ci0JCX0KLQkJcmV0dXJuIG5ldyBDb252ZXJzaW9uVmFsdWVTdGF0ZU9iamVjdCgKLQkJCWRhdGFWYWx1ZSwgCi0JCQlvYmplY3RWYWx1ZSwgCi0JCQlkYXRhVmFsdWVzKTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIG9wZW4gKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgY29uZmlndXJlU2hlbGwoU2hlbGwgc2hlbGwpIHsKLQkJc3VwZXIuY29uZmlndXJlU2hlbGwoc2hlbGwpOwotCQlzaGVsbC5zZXRUZXh0KHRoaXMuZ2V0VGl0bGUoKSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXRUaXRsZSgpIHsKLQkJcmV0dXJuICh0aGlzLmlzQWRkRGlhbG9nKCkpID8KLQkJCQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkNvbnZlcnNpb25WYWx1ZURpYWxvZ19hZGRDb252ZXJzaW9uVmFsdWUKLQkJCQkJOgotCQkJCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQ29udmVyc2lvblZhbHVlRGlhbG9nX2VkaXRDb252ZXJzaW9uVmFsdWU7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXREZXNjcmlwdGlvblRpdGxlKCkgewotCQlyZXR1cm4gKHRoaXMuaXNBZGREaWFsb2coKSkgPwotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQ29udmVyc2lvblZhbHVlRGlhbG9nX2FkZENvbnZlcnNpb25WYWx1ZURlc2NyaXB0aW9uVGl0bGUKLQkJOgotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQ29udmVyc2lvblZhbHVlRGlhbG9nX2VkaXRDb252ZXJzaW9uVmFsdWVEZXNjcmlwdGlvblRpdGxlOwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERlc2NyaXB0aW9uKCkgewotCQlyZXR1cm4gKHRoaXMuaXNBZGREaWFsb2coKSkgPwotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQ29udmVyc2lvblZhbHVlRGlhbG9nX2FkZENvbnZlcnNpb25WYWx1ZURlc2NyaXB0aW9uCi0JCToKLQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkNvbnZlcnNpb25WYWx1ZURpYWxvZ19lZGl0Q29udmVyc2lvblZhbHVlRGVzY3JpcHRpb247Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBEaWFsb2dQYW5lPENvbnZlcnNpb25WYWx1ZVN0YXRlT2JqZWN0PiBidWlsZExheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCXJldHVybiBuZXcgQ29udmVyc2lvblZhbHVlRGlhbG9nUGFuZShjb250YWluZXIpOwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBjcmVhdGUoKSB7Ci0JCXN1cGVyLmNyZWF0ZSgpOwotCi0JCUNvbnZlcnNpb25WYWx1ZURpYWxvZ1BhbmUgcGFuZSA9IChDb252ZXJzaW9uVmFsdWVEaWFsb2dQYW5lKSBnZXRQYW5lKCk7Ci0JCXBhbmUuc2VsZWN0QWxsKCk7Ci0KLQkJZ2V0QnV0dG9uKE9LKS5zZXRFbmFibGVkKGZhbHNlKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY29udmVuaWVuY2UgbWV0aG9kcyAqKioqKioqKioqCi0KLQlwcm90ZWN0ZWQgYm9vbGVhbiBpc0FkZERpYWxvZygpIHsKLQkJcmV0dXJuIHRoaXMuY29udmVyc2lvblZhbHVlID09IG51bGw7Ci0JfQotCi0JcHJvdGVjdGVkIGJvb2xlYW4gaXNFZGl0RGlhbG9nKCkgewotCQlyZXR1cm4gISB0aGlzLmlzQWRkRGlhbG9nKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHB1YmxpYyBBUEkgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBkYXRhIHZhbHVlIHNldCBpbiB0aGUgdGV4dCB3aWRnZXQuCi0JICovCi0JcHVibGljIFN0cmluZyBnZXREYXRhVmFsdWUoKSB7Ci0JCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0RGF0YVZhbHVlKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBvYmplY3QgdmFsdWUgc2V0IGluIHRoZSB0ZXh0IHdpZGdldC4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdldE9iamVjdFZhbHVlKCkgewotCQlyZXR1cm4gZ2V0U3ViamVjdCgpLmdldE9iamVjdFZhbHVlKCk7Ci0JfQotCQotCXByaXZhdGUgY2xhc3MgQ29udmVyc2lvblZhbHVlRGlhbG9nUGFuZSBleHRlbmRzIERpYWxvZ1BhbmU8Q29udmVyc2lvblZhbHVlU3RhdGVPYmplY3Q+IHsKLQotCQlwcml2YXRlIFRleHQgZGF0YVZhbHVlVGV4dDsKLQkJcHJpdmF0ZSBUZXh0IG9iamVjdFZhbHVlVGV4dDsKLQotCQlDb252ZXJzaW9uVmFsdWVEaWFsb2dQYW5lKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJCXN1cGVyKENvbnZlcnNpb25WYWx1ZURpYWxvZy50aGlzLmdldFN1YmplY3RIb2xkZXIoKSwgcGFyZW50KTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJCXRoaXMuZGF0YVZhbHVlVGV4dCA9IGFkZExhYmVsZWRUZXh0KAotCQkJCWNvbnRhaW5lciwKLQkJCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJzaW9uVmFsdWVEaWFsb2dfZGF0YVZhbHVlLAotCQkJCWJ1aWxkRGF0YVZhbHVlSG9sZGVyKCkKLQkJCSk7Ci0JCQkKLQkJCXRoaXMub2JqZWN0VmFsdWVUZXh0ID0gYWRkTGFiZWxlZFRleHQoCi0JCQkJY29udGFpbmVyLAotCQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkNvbnZlcnNpb25WYWx1ZURpYWxvZ19vYmplY3RWYWx1ZSwKLQkJCQlidWlsZE9iamVjdFZhbHVlSG9sZGVyKCkKLQkJCSk7Ci0JCX0KLQotCQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGREYXRhVmFsdWVIb2xkZXIoKSB7Ci0JCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDb252ZXJzaW9uVmFsdWVTdGF0ZU9iamVjdCwgU3RyaW5nPihnZXRTdWJqZWN0SG9sZGVyKCksIENvbnZlcnNpb25WYWx1ZVN0YXRlT2JqZWN0LkRBVEFfVkFMVUVfUFJPUEVSVFkpIHsKLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldERhdGFWYWx1ZSgpOwotCQkJCX0KLQotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhTdHJpbmcgdmFsdWUpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LnNldERhdGFWYWx1ZSh2YWx1ZSk7Ci0JCQkJfQotCQkJfTsKLQkJfQotCi0JCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZE9iamVjdFZhbHVlSG9sZGVyKCkgewotCQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29udmVyc2lvblZhbHVlU3RhdGVPYmplY3QsIFN0cmluZz4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb252ZXJzaW9uVmFsdWVTdGF0ZU9iamVjdC5PQkpFQ1RfVkFMVUVfUFJPUEVSVFkpIHsKLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldE9iamVjdFZhbHVlKCk7Ci0JCQkJfQotCi0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCQkJCQl0aGlzLnN1YmplY3Quc2V0T2JqZWN0VmFsdWUodmFsdWUpOwotCQkJCX0KLQkJCX07Ci0JCX0KLQotCQl2b2lkIHNlbGVjdEFsbCgpIHsKLQkJCXRoaXMuZGF0YVZhbHVlVGV4dC5zZWxlY3RBbGwoKTsKLQkJCXRoaXMub2JqZWN0VmFsdWVUZXh0LnNlbGVjdEFsbCgpOwotCQl9Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9Db252ZXJzaW9uVmFsdWVTdGF0ZU9iamVjdC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9Db252ZXJzaW9uVmFsdWVTdGF0ZU9iamVjdC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzYmJjZjQ4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQ29udmVyc2lvblZhbHVlU3RhdGVPYmplY3QuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEzOCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubm9kZS5BYnN0cmFjdE5vZGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubm9kZS5Ob2RlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm5vZGUuUHJvYmxlbTsKLQotLyoqCi0gKiBUaGlzIGlzIHRoZSBzdGF0ZSBvYmplY3QgdXNlZCBieSB0aGUgPGNvZGU+TmV3TmFtZURpYWxvZzwvY29kZT4sIHdoaWNoIHN0b3JlcwotICogdGhlIGN1cnJlbnQgbmFtZSBhbmQgdmFsaWRhdGVzIGl0IHdoZW4gaXQgaXMgbW9kaWZpZWQuCi0gKgotICogQHNlZSBOZXdOYW1lRGlhbG9nCi0gKgotICogQHZlcnNpb24gMi4xCi0gKiBAc2luY2UgMi4xCi0gKi8KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotZmluYWwgY2xhc3MgQ29udmVyc2lvblZhbHVlU3RhdGVPYmplY3QgZXh0ZW5kcyBBYnN0cmFjdE5vZGUKLXsKLQkvKioKLQkgKiBUaGUgaW5pdGlhbCBkYXRhVmFsdWUgb3IgPGNvZGU+bnVsbDwvY29kZT4KLQkgKi8KLQlwcml2YXRlIFN0cmluZyBkYXRhVmFsdWU7Ci0JCi0JLyoqCi0JICogVGhlIGNvbGxlY3Rpb24gb2YgZGF0YSB2YWx1ZXMgdGhhdCBjYW4ndCBiZSB1c2VkIG9yIGFuIGVtcHR5IGNvbGxlY3Rpb24KLQkgKi8KLQlwcml2YXRlIENvbGxlY3Rpb248U3RyaW5nPiBkYXRhVmFsdWVzOwotCi0JLyoqCi0JICogVGhlIGluaXRpYWwgb2JqZWN0VmFsdWUgb3IgPGNvZGU+bnVsbDwvY29kZT4KLQkgKi8KLQlwcml2YXRlIFN0cmluZyBvYmplY3RWYWx1ZTsKLQotCS8qKgotCSAqIFRoZSA8Y29kZT5WYWxpZGF0b3I8L2NvZGU+IHVzZWQgdG8gdmFsaWRhdGUgdGhpcyBzdGF0ZSBvYmplY3QuCi0JICovCi0JcHJpdmF0ZSBWYWxpZGF0b3IgdmFsaWRhdG9yOwotCi0JLyoqCi0JICogTm90aWZpZXMgYSBjaGFuZ2UgaW4gdGhlIGRhdGEgdmFsdWUgcHJvcGVydHkuCi0JICovCi0Jc3RhdGljIGZpbmFsIFN0cmluZyBEQVRBX1ZBTFVFX1BST1BFUlRZID0gImRhdGFWYWx1ZSI7Ci0JCi0JLyoqCi0JICogTm90aWZpZXMgYSBjaGFuZ2UgaW4gdGhlIG9iamVjdCB2YWx1ZSBwcm9wZXJ0eS4KLQkgKi8KLQlzdGF0aWMgZmluYWwgU3RyaW5nIE9CSkVDVF9WQUxVRV9QUk9QRVJUWSA9ICJvYmplY3RWYWx1ZSI7Ci0KLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPk5ld05hbWVTdGF0ZU9iamVjdDwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gbmFtZSBUaGUgaW5pdGlhbCBpbnB1dCBvciA8Y29kZT5udWxsPC9jb2RlPiBpZiBubyBpbml0aWFsIHZhbHVlIGNhbgotCSAqIGJlIHNwZWNpZmllZAotCSAqIEBwYXJhbSBuYW1lcyBUaGUgY29sbGVjdGlvbiBvZiBuYW1lcyB0aGF0IGNhbid0IGJlIHVzZWQgb3IgYW4gZW1wdHkKLQkgKiBjb2xsZWN0aW9uIGlmIG5vbmUgYXJlIGF2YWlsYWJsZQotCSAqLwotCUNvbnZlcnNpb25WYWx1ZVN0YXRlT2JqZWN0KFN0cmluZyBkYXRhVmFsdWUsIFN0cmluZyBvYmplY3RWYWx1ZSwgQ29sbGVjdGlvbjxTdHJpbmc+IGRhdGFWYWx1ZXMpIHsKLQkJc3VwZXIobnVsbCk7Ci0KLQkJdGhpcy5kYXRhVmFsdWUgID0gZGF0YVZhbHVlOwotCQl0aGlzLm9iamVjdFZhbHVlID0gb2JqZWN0VmFsdWU7Ci0JCXRoaXMuZGF0YVZhbHVlcyA9IGRhdGFWYWx1ZXM7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGFkZERhdGFWYWx1ZVByb2JsZW1zVG8oTGlzdDxQcm9ibGVtPiBjdXJyZW50UHJvYmxlbXMpIHsKLQkJaWYgKFN0cmluZ1Rvb2xzLnN0cmluZ0lzRW1wdHkodGhpcy5kYXRhVmFsdWUpKSB7Ci0JCQljdXJyZW50UHJvYmxlbXMuYWRkKGJ1aWxkUHJvYmxlbShFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJzaW9uVmFsdWVTdGF0ZU9iamVjdF9kYXRhVmFsdWVNdXN0QmVTcGVjaWZpZWQpKTsKLQkJfQotCQllbHNlIGlmICh0aGlzLmRhdGFWYWx1ZXMuY29udGFpbnModGhpcy5kYXRhVmFsdWUpKSB7Ci0JCQljdXJyZW50UHJvYmxlbXMuYWRkKGJ1aWxkUHJvYmxlbShFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJzaW9uVmFsdWVTdGF0ZU9iamVjdF9kYXRhVmFsdWVBbHJlYWR5RXhpc3RzKSk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgYWRkT2JqZWN0VmFsdWVQcm9ibGVtc1RvKExpc3Q8UHJvYmxlbT4gY3VycmVudFByb2JsZW1zKSB7Ci0JCWlmIChTdHJpbmdUb29scy5zdHJpbmdJc0VtcHR5KHRoaXMub2JqZWN0VmFsdWUpKSB7Ci0JCQljdXJyZW50UHJvYmxlbXMuYWRkKGJ1aWxkUHJvYmxlbShFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJzaW9uVmFsdWVTdGF0ZU9iamVjdF9vYmplY3RWYWx1ZU11c3RCZVNwZWNpZmllZCkpOwotCQl9Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgYWRkUHJvYmxlbXNUbyhMaXN0PFByb2JsZW0+IGN1cnJlbnRQcm9ibGVtcykgewotCQlzdXBlci5hZGRQcm9ibGVtc1RvKGN1cnJlbnRQcm9ibGVtcyk7Ci0JCWFkZERhdGFWYWx1ZVByb2JsZW1zVG8oY3VycmVudFByb2JsZW1zKTsKLQkJYWRkT2JqZWN0VmFsdWVQcm9ibGVtc1RvKGN1cnJlbnRQcm9ibGVtcyk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgY2hlY2tQYXJlbnQoTm9kZSBwYXJlbnROb2RlKSB7Ci0JCS8vbm90IHBhcmVudAotCX0KLQotCXB1YmxpYyBTdHJpbmcgZGlzcGxheVN0cmluZygpIHsKLQkJcmV0dXJuIG51bGw7Ci0JfQotCi0JU3RyaW5nIGdldERhdGFWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMuZGF0YVZhbHVlOwotCX0KLQotCVN0cmluZyBnZXRPYmplY3RWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMub2JqZWN0VmFsdWU7Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0RGF0YVZhbHVlKFN0cmluZyBkYXRhVmFsdWUpIHsKLQkJU3RyaW5nIG9sZERhdGFWYWx1ZSA9IHRoaXMuZGF0YVZhbHVlOwotCQl0aGlzLmRhdGFWYWx1ZSA9IGRhdGFWYWx1ZTsKLQkJZmlyZVByb3BlcnR5Q2hhbmdlZChEQVRBX1ZBTFVFX1BST1BFUlRZLCBvbGREYXRhVmFsdWUsIGRhdGFWYWx1ZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0T2JqZWN0VmFsdWUoU3RyaW5nIG9iamVjdFZhbHVlKSB7Ci0JCVN0cmluZyBvbGRPYmplY3RWYWx1ZSA9IHRoaXMub2JqZWN0VmFsdWU7Ci0JCXRoaXMub2JqZWN0VmFsdWUgPSBvYmplY3RWYWx1ZTsKLQkJZmlyZVByb3BlcnR5Q2hhbmdlZChPQkpFQ1RfVkFMVUVfUFJPUEVSVFksIG9sZE9iamVjdFZhbHVlLCBvYmplY3RWYWx1ZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgc2V0VmFsaWRhdG9yKFZhbGlkYXRvciB2YWxpZGF0b3IpIHsKLQkJdGhpcy52YWxpZGF0b3IgPSB2YWxpZGF0b3I7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFZhbGlkYXRvciBnZXRWYWxpZGF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLnZhbGlkYXRvcjsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0NvbnZlcnRDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQ29udmVydENvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxYTNlYTMzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQ29udmVydENvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzYxICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiAgQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcwotICogIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YKLSAqICB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMKLSAqICBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSAqCi0gKiAgQ29udHJpYnV0b3JzOiBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5Db252ZXJ0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQ3VzdG9tQ29udmVydGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuRWNsaXBzZUxpbmtDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5PYmplY3RUeXBlQ29udmVydGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuU3RydWN0Q29udmVydGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuVHlwZUNvbnZlcnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLkVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuSnB0VWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLlBhbmVFbmFibGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLlNXVFV0aWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ0NvbnZlcnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Db21wb3NpdGVMaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5MaXN0QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlN0YXRpY0xpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5vc2dpLnV0aWwuTkxTOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5jdXN0b20uQ0NvbWJvOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuR3JpZERhdGE7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIEhlcmUgdGhlIGxheW91dCBvZiB0aGlzIHBhbmU6Ci0gKiA8cHJlPgotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLSAqIHwgICAgICAgICAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IEVudW0gVHlwZTogfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8dnwgfAotICogfCAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSBFY2xpcHNlTGlua0NvbnZlcnQKLSAqIEBzZWUgRWNsaXBzZUxpbmtCYXNpY01hcHBpbmdDb21wb3NpdGUgLSBBIGNvbnRhaW5lciBvZiB0aGlzIHdpZGdldAotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgQ29udmVydENvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPENvbnZlcnQ+Ci17Ci0KLQkvKioKLQkgKiBBIGtleSB1c2VkIHRvIHJlcHJlc2VudCB0aGUgZGVmYXVsdCB2YWx1ZSwgdGhpcyBpcyByZXF1aXJlZCB0byBjb252ZXJ0Ci0JICogdGhlIHNlbGVjdGVkIGl0ZW0gZnJvbSBhIGNvbWJvIHRvIDxjb2RlPm51bGw8L2NvZGU+LiBUaGlzIGtleSBpcyBtb3N0Ci0JICogbGlrZWx5IG5ldmVyIHR5cGVkIHRoZSB1c2VyIGFuZCBpdCB3aWxsIGhlbHAgdG8gY29udmVydCB0aGUgdmFsdWUgdG8KLQkgKiA8Y29kZT5udWxsPC9jb2RlPiB3aGVuIGl0J3MgdGltZSB0byBzZXQgdGhlIG5ldyBzZWxlY3RlZCB2YWx1ZSBpbnRvIHRoZQotCSAqIG1vZGVsLgotCSAqLwotCXByb3RlY3RlZCBzdGF0aWMgU3RyaW5nIERFRkFVTFRfS0VZID0gIj8hIyE/Iz8jP2RlZmF1bHQ/Iz8hIz8hIz8iOyAvLyROT04tTkxTLTEkCi0JCi0JCi0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5FbnVtVHlwZUNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgQ29udmVydENvbXBvc2l0ZShQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIENvbnZlcnQ+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJQ0NvbWJvIGNvbWJvID0gYWRkTGFiZWxlZEVkaXRhYmxlQ0NvbWJvKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQ29udmVydENvbXBvc2l0ZV9jb252ZXJ0ZXJOYW1lTGFiZWwsCi0JCQlidWlsZENvbnZlcnROYW1lTGlzdEhvbGRlcigpLAotCQkJYnVpbGRDb252ZXJ0TmFtZUhvbGRlcigpLAotCQkJYnVpbGROYW1lQ29udmVydGVyKCksCi0JCQludWxsCi0JCSk7Ci0JCVNXVFV0aWwuYXR0YWNoRGVmYXVsdFZhbHVlSGFuZGxlcihjb21ibyk7Ci0JCQotCQlDb21wb3NpdGUgc3ViU2VjdGlvbiA9IGFkZENvbGxhcHNhYmxlU3ViU2VjdGlvbigKLQkJCWNvbnRhaW5lciwgCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJ0Q29tcG9zaXRlX2RlZmluZUNvbnZlcnRlclNlY3Rpb24sIAotCQkJbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPihCb29sZWFuLkZBTFNFKSk7Ci0JCQotCQkvLyBObyBDb252ZXJ0ZXIKLQkJYWRkUmFkaW9CdXR0b24oCi0JCQlzdWJTZWN0aW9uLCAKLQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkNvbnZlcnRDb21wb3NpdGVfZGVmYXVsdCwgCi0JCQlidWlsZE5vQ29udmVydGVySG9sZGVyKCksIAotCQkJbnVsbCk7Ci0JCVByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua0NvbnZlcnRlcj4gY29udmVydGVySG9sZGVyID0gYnVpbGRDb252ZXJ0ZXJIb2xkZXIoKTsKLQkJLy8gQ3VzdG9tQ29udmVydGVyCi0JCWFkZFJhZGlvQnV0dG9uKAotCQkJc3ViU2VjdGlvbiwgCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJ0Q29tcG9zaXRlX2N1c3RvbSwgCi0JCQlidWlsZENvbnZlcnRlckhvbGRlcihFY2xpcHNlTGlua0NvbnZlcnRlci5DVVNUT01fQ09OVkVSVEVSKSwgCi0JCQludWxsKTsKLQkJQ3VzdG9tQ29udmVydGVyQ29tcG9zaXRlIGNvbnZlcnRlckNvbXBvc2l0ZSA9IG5ldyBDdXN0b21Db252ZXJ0ZXJDb21wb3NpdGUoYnVpbGRDdXN0b21Db252ZXJ0ZXJIb2xkZXIoY29udmVydGVySG9sZGVyKSwgc3ViU2VjdGlvbiwgZ2V0V2lkZ2V0RmFjdG9yeSgpKTsKLQkJR3JpZERhdGEgZ3JpZERhdGEgPSAoR3JpZERhdGEpIGNvbnZlcnRlckNvbXBvc2l0ZS5nZXRDb250cm9sKCkuZ2V0TGF5b3V0RGF0YSgpOwotCQlncmlkRGF0YS5ob3Jpem9udGFsSW5kZW50ID0gMjA7Ci0JCXJlZ2lzdGVyU3ViUGFuZShjb252ZXJ0ZXJDb21wb3NpdGUpOwotCQkKLQkJLy8gVHlwZSBDb252ZXJ0ZXIKLQkJYWRkUmFkaW9CdXR0b24oCi0JCQlzdWJTZWN0aW9uLCAKLQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkNvbnZlcnRDb21wb3NpdGVfdHlwZSwgCi0JCQlidWlsZENvbnZlcnRlckhvbGRlcihFY2xpcHNlTGlua0NvbnZlcnRlci5UWVBFX0NPTlZFUlRFUiksIAotCQkJbnVsbCk7Ci0JCVR5cGVDb252ZXJ0ZXJDb21wb3NpdGUgdHlwZUNvbnZlcnRlckNvbXBvc2l0ZSA9IG5ldyBUeXBlQ29udmVydGVyQ29tcG9zaXRlKGJ1aWxkVHlwZUNvbnZlcnRlckhvbGRlcihjb252ZXJ0ZXJIb2xkZXIpLCBzdWJTZWN0aW9uLCBnZXRXaWRnZXRGYWN0b3J5KCkpOwotCQlncmlkRGF0YSA9IChHcmlkRGF0YSkgdHlwZUNvbnZlcnRlckNvbXBvc2l0ZS5nZXRDb250cm9sKCkuZ2V0TGF5b3V0RGF0YSgpOwotCQlncmlkRGF0YS5ob3Jpem9udGFsSW5kZW50ID0gMjA7Ci0JCXJlZ2lzdGVyU3ViUGFuZSh0eXBlQ29udmVydGVyQ29tcG9zaXRlKTsKLQotCQkvLyBPYmplY3QgVHlwZSBDb252ZXJ0ZXIKLQkJYWRkUmFkaW9CdXR0b24oCi0JCQlzdWJTZWN0aW9uLCAKLQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkNvbnZlcnRDb21wb3NpdGVfb2JqZWN0VHlwZSwgCi0JCQlidWlsZENvbnZlcnRlckhvbGRlcihFY2xpcHNlTGlua0NvbnZlcnRlci5PQkpFQ1RfVFlQRV9DT05WRVJURVIpLCAKLQkJCW51bGwpOwotCQlPYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlIG9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGUgPSBuZXcgT2JqZWN0VHlwZUNvbnZlcnRlckNvbXBvc2l0ZShidWlsZE9iamVjdFR5cGVDb252ZXJ0ZXJIb2xkZXIoY29udmVydGVySG9sZGVyKSwgc3ViU2VjdGlvbiwgZ2V0V2lkZ2V0RmFjdG9yeSgpKTsKLQkJZ3JpZERhdGEgPSAoR3JpZERhdGEpIG9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGUuZ2V0Q29udHJvbCgpLmdldExheW91dERhdGEoKTsKLQkJZ3JpZERhdGEuaG9yaXpvbnRhbEluZGVudCA9IDIwOwotCQlyZWdpc3RlclN1YlBhbmUob2JqZWN0VHlwZUNvbnZlcnRlckNvbXBvc2l0ZSk7Ci0KLQkJLy8gU3RydWN0IENvbnZlcnRlcgotCQlhZGRSYWRpb0J1dHRvbigKLQkJCXN1YlNlY3Rpb24sIAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQ29udmVydENvbXBvc2l0ZV9zdHJ1Y3QsIAotCQkJYnVpbGRDb252ZXJ0ZXJIb2xkZXIoRWNsaXBzZUxpbmtDb252ZXJ0ZXIuU1RSVUNUX0NPTlZFUlRFUiksIAotCQkJbnVsbCk7Ci0JCVN0cnVjdENvbnZlcnRlckNvbXBvc2l0ZSBzdHJ1Y3RDb252ZXJ0ZXJDb21wb3NpdGUgPSBuZXcgU3RydWN0Q29udmVydGVyQ29tcG9zaXRlKGJ1aWxkU3RydWN0Q29udmVydGVySG9sZGVyKGNvbnZlcnRlckhvbGRlciksIHN1YlNlY3Rpb24sIGdldFdpZGdldEZhY3RvcnkoKSk7Ci0JCWdyaWREYXRhID0gKEdyaWREYXRhKSBzdHJ1Y3RDb252ZXJ0ZXJDb21wb3NpdGUuZ2V0Q29udHJvbCgpLmdldExheW91dERhdGEoKTsKLQkJZ3JpZERhdGEuaG9yaXpvbnRhbEluZGVudCA9IDIwOwotCQlyZWdpc3RlclN1YlBhbmUoc3RydWN0Q29udmVydGVyQ29tcG9zaXRlKTsKLQkJCi0JCW5ldyBQYW5lRW5hYmxlcihidWlsZEJvb2xlYW5Ib2xkZXIoKSwgdGhpcyk7Ci0JfQotCQotCXByb3RlY3RlZCBmaW5hbCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkQ29udmVydE5hbWVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENvbnZlcnQsIFN0cmluZz4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb252ZXJ0LlNQRUNJRklFRF9DT05WRVJURVJfTkFNRV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0U3BlY2lmaWVkQ29udmVydGVyTmFtZSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhTdHJpbmcgdmFsdWUpIHsKLQkJCQkvLyBDb252ZXJ0IHRoZSBkZWZhdWx0IHZhbHVlIG9yIGFuIGVtcHR5IHN0cmluZyB0byBudWxsCi0JCQkJaWYgKCh2YWx1ZSAhPSBudWxsKSAmJgotCQkJCSAgICgodmFsdWUubGVuZ3RoKCkgPT0gMCkgfHwgdmFsdWUuc3RhcnRzV2l0aChERUZBVUxUX0tFWSkpKSB7Ci0KLQkJCQkJdmFsdWUgPSBudWxsOwotCQkJCX0KLQkJCQl0aGlzLnN1YmplY3Quc2V0U3BlY2lmaWVkQ29udmVydGVyTmFtZSh2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZENvbnZlcnROYW1lTGlzdEhvbGRlcigpIHsKLQkJamF2YS51dGlsLkxpc3Q8TGlzdFZhbHVlTW9kZWw8U3RyaW5nPj4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8TGlzdFZhbHVlTW9kZWw8U3RyaW5nPj4oKTsKLQkJbGlzdC5hZGQoYnVpbGREZWZhdWx0TmFtZUxpc3RIb2xkZXIoKSk7Ci0JCWxpc3QuYWRkKGJ1aWxkUmVzZXJ2ZWRDb252ZXJ0ZXJOYW1lTGlzdEhvbGRlcigpKTsKLQkJbGlzdC5hZGQoYnVpbGRDb252ZXJ0ZXJOYW1lTGlzdEhvbGRlcigpKTsKLQkJcmV0dXJuIG5ldyBDb21wb3NpdGVMaXN0VmFsdWVNb2RlbDxMaXN0VmFsdWVNb2RlbDxTdHJpbmc+LCBTdHJpbmc+KGxpc3QpOwotCX0KLQkKLQlwcm90ZWN0ZWQgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZERlZmF1bHROYW1lTGlzdEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxTdHJpbmc+KAotCQkJYnVpbGREZWZhdWx0TmFtZUhvbGRlcigpCi0JCSk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdE5hbWVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENvbnZlcnQsIFN0cmluZz4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb252ZXJ0LkRFRkFVTFRfQ09OVkVSVEVSX05BTUVfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQlTdHJpbmcgbmFtZSA9IHRoaXMuc3ViamVjdC5nZXREZWZhdWx0Q29udmVydGVyTmFtZSgpOwotCi0JCQkJaWYgKG5hbWUgPT0gbnVsbCkgewotCQkJCQluYW1lID0gREVGQVVMVF9LRVk7Ci0JCQkJfQotCQkJCWVsc2UgewotCQkJCQluYW1lID0gREVGQVVMVF9LRVkgKyBuYW1lOwotCQkJCX0KLQotCQkJCXJldHVybiBuYW1lOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgU3RyaW5nQ29udmVydGVyPFN0cmluZz4gYnVpbGROYW1lQ29udmVydGVyKCkgewotCQlyZXR1cm4gbmV3IFN0cmluZ0NvbnZlcnRlcjxTdHJpbmc+KCkgewotCQkJcHVibGljIFN0cmluZyBjb252ZXJ0VG9TdHJpbmcoU3RyaW5nIHZhbHVlKSB7Ci0KLQkJCQlpZiAoZ2V0U3ViamVjdCgpID09IG51bGwpIHsKLQkJCQkJcmV0dXJuIHZhbHVlOwotCQkJCX0KLQotCQkJCWlmICh2YWx1ZSA9PSBudWxsKSB7Ci0JCQkJCXZhbHVlID0gZ2V0U3ViamVjdCgpLmdldERlZmF1bHRDb252ZXJ0ZXJOYW1lKCk7Ci0KLQkJCQkJaWYgKHZhbHVlICE9IG51bGwpIHsKLQkJCQkJCXZhbHVlID0gREVGQVVMVF9LRVkgKyB2YWx1ZTsKLQkJCQkJfQotCQkJCQllbHNlIHsKLQkJCQkJCXZhbHVlID0gREVGQVVMVF9LRVk7Ci0JCQkJCX0KLQkJCQl9Ci0KLQkJCQlpZiAodmFsdWUuc3RhcnRzV2l0aChERUZBVUxUX0tFWSkpIHsKLQkJCQkJU3RyaW5nIGRlZmF1bHROYW1lID0gdmFsdWUuc3Vic3RyaW5nKERFRkFVTFRfS0VZLmxlbmd0aCgpKTsKLQotCQkJCQlpZiAoZGVmYXVsdE5hbWUubGVuZ3RoKCkgPiAwKSB7Ci0JCQkJCQl2YWx1ZSA9IE5MUy5iaW5kKAotCQkJCQkJCUpwdFVpTWFwcGluZ3NNZXNzYWdlcy5EZWZhdWx0V2l0aE9uZVBhcmFtLAotCQkJCQkJCWRlZmF1bHROYW1lCi0JCQkJCQkpOwotCQkJCQl9Ci0JCQkJCWVsc2UgewotCQkJCQkJdmFsdWUgPSBKcHRVaU1hcHBpbmdzTWVzc2FnZXMuRGVmYXVsdEVtcHR5OwotCQkJCQl9Ci0JCQkJfQotCi0JCQkJcmV0dXJuIHZhbHVlOwotCQkJfQotCQl9OwotCX0KLQotCXByb3RlY3RlZCBMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkUmVzZXJ2ZWRDb252ZXJ0ZXJOYW1lTGlzdEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBTdGF0aWNMaXN0VmFsdWVNb2RlbDxTdHJpbmc+KENvbnZlcnQuUkVTRVJWRURfQ09OVkVSVEVSX05BTUVTKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRDb252ZXJ0ZXJOYW1lTGlzdEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBMaXN0QXNwZWN0QWRhcHRlcjxFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdCwgU3RyaW5nPigKLQkJCWJ1aWxkUGVyc2lzdGVuY2VVbml0SG9sZGVyKCksCi0JCQlFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdC5DT05WRVJURVJTX0xJU1QpLy9UT0RPIG5lZWQgRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQgaW50ZXJmYWNlCi0JCXsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIExpc3RJdGVyYXRvcjxTdHJpbmc+IGxpc3RJdGVyYXRvcl8oKSB7Ci0JCQkJcmV0dXJuIENvbGxlY3Rpb25Ub29scy5saXN0SXRlcmF0b3IoQ29sbGVjdGlvblRvb2xzLnNvcnQodGhpcy5zdWJqZWN0LnVuaXF1ZUNvbnZlcnRlck5hbWVzKCkpKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdD4gYnVpbGRQZXJzaXN0ZW5jZVVuaXRIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENvbnZlcnQsIEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0PihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0IGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiAoRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQpIGdldFN1YmplY3QoKS5nZXRQZXJzaXN0ZW5jZVVuaXQoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZE5vQ29udmVydGVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDb252ZXJ0LCBCb29sZWFuPihnZXRTdWJqZWN0SG9sZGVyKCksIENvbnZlcnQuQ09OVkVSVEVSX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBCb29sZWFuLnZhbHVlT2YodGhpcy5zdWJqZWN0LmdldENvbnZlcnRlcigpID09IG51bGwpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJaWYgKHZhbHVlLmJvb2xlYW5WYWx1ZSgpKSB7Ci0JCQkJCXRoaXMuc3ViamVjdC5zZXRDb252ZXJ0ZXIoRWNsaXBzZUxpbmtDb252ZXJ0ZXIuTk9fQ09OVkVSVEVSKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRDb252ZXJ0ZXJIb2xkZXIoZmluYWwgU3RyaW5nIGNvbnZlcnRlclR5cGUpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29udmVydCwgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb252ZXJ0LkNPTlZFUlRFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlFY2xpcHNlTGlua0NvbnZlcnRlciBjb252ZXJ0ZXIgPSB0aGlzLnN1YmplY3QuZ2V0Q29udmVydGVyKCk7Ci0JCQkJaWYgKGNvbnZlcnRlciA9PSBudWxsKSB7Ci0JCQkJCXJldHVybiBCb29sZWFuLkZBTFNFOwotCQkJCX0KLQkJCQlyZXR1cm4gQm9vbGVhbi52YWx1ZU9mKGNvbnZlcnRlci5nZXRUeXBlKCkgPT0gY29udmVydGVyVHlwZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlpZiAodmFsdWUuYm9vbGVhblZhbHVlKCkpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LnNldENvbnZlcnRlcihjb252ZXJ0ZXJUeXBlKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rQ29udmVydGVyPiBidWlsZENvbnZlcnRlckhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29udmVydCwgRWNsaXBzZUxpbmtDb252ZXJ0ZXI+KGdldFN1YmplY3RIb2xkZXIoKSwgQ29udmVydC5DT05WRVJURVJfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEVjbGlwc2VMaW5rQ29udmVydGVyIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0Q29udmVydGVyKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPEN1c3RvbUNvbnZlcnRlcj4gYnVpbGRDdXN0b21Db252ZXJ0ZXJIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rQ29udmVydGVyPiBjb252ZXJ0ZXJIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua0NvbnZlcnRlciwgQ3VzdG9tQ29udmVydGVyPihjb252ZXJ0ZXJIb2xkZXIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEN1c3RvbUNvbnZlcnRlciB0cmFuc2Zvcm1fKEVjbGlwc2VMaW5rQ29udmVydGVyIGNvbnZlcnRlcikgewotCQkJCXJldHVybiAoY29udmVydGVyICE9IG51bGwgJiYgY29udmVydGVyLmdldFR5cGUoKSA9PSBFY2xpcHNlTGlua0NvbnZlcnRlci5DVVNUT01fQ09OVkVSVEVSKSA/IChDdXN0b21Db252ZXJ0ZXIpIGNvbnZlcnRlciA6IG51bGw7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFR5cGVDb252ZXJ0ZXI+IGJ1aWxkVHlwZUNvbnZlcnRlckhvbGRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtDb252ZXJ0ZXI+IGNvbnZlcnRlckhvbGRlcikgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rQ29udmVydGVyLCBUeXBlQ29udmVydGVyPihjb252ZXJ0ZXJIb2xkZXIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFR5cGVDb252ZXJ0ZXIgdHJhbnNmb3JtXyhFY2xpcHNlTGlua0NvbnZlcnRlciBjb252ZXJ0ZXIpIHsKLQkJCQlyZXR1cm4gKGNvbnZlcnRlciAhPSBudWxsICYmIGNvbnZlcnRlci5nZXRUeXBlKCkgPT0gRWNsaXBzZUxpbmtDb252ZXJ0ZXIuVFlQRV9DT05WRVJURVIpID8gKFR5cGVDb252ZXJ0ZXIpIGNvbnZlcnRlciA6IG51bGw7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdFR5cGVDb252ZXJ0ZXI+IGJ1aWxkT2JqZWN0VHlwZUNvbnZlcnRlckhvbGRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtDb252ZXJ0ZXI+IGNvbnZlcnRlckhvbGRlcikgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rQ29udmVydGVyLCBPYmplY3RUeXBlQ29udmVydGVyPihjb252ZXJ0ZXJIb2xkZXIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIE9iamVjdFR5cGVDb252ZXJ0ZXIgdHJhbnNmb3JtXyhFY2xpcHNlTGlua0NvbnZlcnRlciBjb252ZXJ0ZXIpIHsKLQkJCQlyZXR1cm4gKGNvbnZlcnRlciAhPSBudWxsICYmIGNvbnZlcnRlci5nZXRUeXBlKCkgPT0gRWNsaXBzZUxpbmtDb252ZXJ0ZXIuT0JKRUNUX1RZUEVfQ09OVkVSVEVSKSA/IChPYmplY3RUeXBlQ29udmVydGVyKSBjb252ZXJ0ZXIgOiBudWxsOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJ1Y3RDb252ZXJ0ZXI+IGJ1aWxkU3RydWN0Q29udmVydGVySG9sZGVyKFByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua0NvbnZlcnRlcj4gY29udmVydGVySG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtDb252ZXJ0ZXIsIFN0cnVjdENvbnZlcnRlcj4oY29udmVydGVySG9sZGVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJ1Y3RDb252ZXJ0ZXIgdHJhbnNmb3JtXyhFY2xpcHNlTGlua0NvbnZlcnRlciBjb252ZXJ0ZXIpIHsKLQkJCQlyZXR1cm4gKGNvbnZlcnRlciAhPSBudWxsICYmIGNvbnZlcnRlci5nZXRUeXBlKCkgPT0gRWNsaXBzZUxpbmtDb252ZXJ0ZXIuU1RSVUNUX0NPTlZFUlRFUikgPyAoU3RydWN0Q29udmVydGVyKSBjb252ZXJ0ZXIgOiBudWxsOwotCQkJfQotCQl9OwotCX0KLQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRCb29sZWFuSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnQsIEJvb2xlYW4+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiB0cmFuc2Zvcm0oQ29udmVydCB2YWx1ZSkgewotCQkJCWlmIChnZXRTdWJqZWN0KCkgIT0gbnVsbCAmJiBnZXRTdWJqZWN0KCkuZ2V0UGFyZW50KCkuZ2V0UGVyc2lzdGVudEF0dHJpYnV0ZSgpLmlzVmlydHVhbCgpKSB7Ci0JCQkJCXJldHVybiBCb29sZWFuLkZBTFNFOwotCQkJCX0KLQkJCQlyZXR1cm4gQm9vbGVhbi52YWx1ZU9mKHZhbHVlICE9IG51bGwpOwotCQkJfQotCQl9OwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQ3VzdG9tQ29udmVydGVyQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0N1c3RvbUNvbnZlcnRlckNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0Y2YyNDBhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvQ3VzdG9tQ29udmVydGVyQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzCi0gKiAgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZgotICogIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcwotICogIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotICoKLSAqICBDb250cmlidXRvcnM6IE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLkpwYVByb2plY3Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5DdXN0b21Db252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5FY2xpcHNlTGlua0NvbnZlcnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuUGFuZUVuYWJsZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuQ2xhc3NDaG9vc2VyUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBIZXJlIHRoZSBsYXlvdXQgb2YgdGhpcyBwYW5lOgotICogPHByZT4KLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gKiB8ICAgICAgICAgICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCBOYW1lOiAgICAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfHwKLSAqIHwgICAgICAgICAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLTwvcHJlPgotICoKLSAqIEBzZWUgRWNsaXBzZUxpbmtDb252ZXJ0ZXIKLSAqIEBzZWUgQ29udmVydENvbXBvc2l0ZSAtIEEgY29udGFpbmVyIG9mIHRoaXMgd2lkZ2V0Ci0gKgotICogQHZlcnNpb24gMi4xCi0gKiBAc2luY2UgMi4xCi0gKi8KLXB1YmxpYyBjbGFzcyBDdXN0b21Db252ZXJ0ZXJDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxDdXN0b21Db252ZXJ0ZXI+Ci17Ci0KLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkNvbnZlcnRlckNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgQ3VzdG9tQ29udmVydGVyQ29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgQ3VzdG9tQ29udmVydGVyPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCQotCQlhZGRMYWJlbGVkVGV4dCgKLQkJCWNvbnRhaW5lciwgCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJ0ZXJDb21wb3NpdGVfbmFtZVRleHRMYWJlbCwgCi0JCQlidWlsZE5hbWVUZXh0SG9sZGVyKCkpOwotCQkKLQkJYWRkQ2xhc3NDaG9vc2VyKGNvbnRhaW5lcik7Ci0JCQotCQluZXcgUGFuZUVuYWJsZXIoYnVpbGRCb29sZWFuSG9sZGVyKCksIHRoaXMpOwotCX0KLQkKLQlwcm90ZWN0ZWQgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZE5hbWVUZXh0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDdXN0b21Db252ZXJ0ZXIsIFN0cmluZz4oCi0JCQkJZ2V0U3ViamVjdEhvbGRlcigpLCBFY2xpcHNlTGlua0NvbnZlcnRlci5OQU1FX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXROYW1lKCk7Ci0JCQl9Ci0JCQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0JCQkJaWYgKHZhbHVlLmxlbmd0aCgpID09IDApIHsKLQkJCQkJdmFsdWUgPSBudWxsOwotCQkJCX0KLQkJCQl0aGlzLnN1YmplY3Quc2V0TmFtZSh2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JCi0JcHJpdmF0ZSBDbGFzc0Nob29zZXJQYW5lPEN1c3RvbUNvbnZlcnRlcj4gYWRkQ2xhc3NDaG9vc2VyKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlyZXR1cm4gbmV3IENsYXNzQ2hvb3NlclBhbmU8Q3VzdG9tQ29udmVydGVyPih0aGlzLCBjb250YWluZXIpIHsKLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFRleHRIb2xkZXIoKSB7Ci0JCQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q3VzdG9tQ29udmVydGVyLCBTdHJpbmc+KGdldFN1YmplY3RIb2xkZXIoKSwgQ3VzdG9tQ29udmVydGVyLkNPTlZFUlRFUl9DTEFTU19QUk9QRVJUWSkgewotCQkJCQlAT3ZlcnJpZGUKLQkJCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0Q29udmVydGVyQ2xhc3MoKTsKLQkJCQkJfQotCi0JCQkJCUBPdmVycmlkZQotCQkJCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0KLQkJCQkJCWlmICh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQkJCQkJdmFsdWUgPSBudWxsOwotCQkJCQkJfQotCi0JCQkJCQl0aGlzLnN1YmplY3Quc2V0Q29udmVydGVyQ2xhc3ModmFsdWUpOwotCQkJCQl9Ci0JCQkJfTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGdldENsYXNzTmFtZSgpIHsKLQkJCQlyZXR1cm4gZ2V0U3ViamVjdCgpLmdldENvbnZlcnRlckNsYXNzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBnZXRMYWJlbFRleHQoKSB7Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkNvbnZlcnRlckNvbXBvc2l0ZV9jbGFzc0xhYmVsOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBKcGFQcm9qZWN0IGdldEpwYVByb2plY3QoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXRKcGFQcm9qZWN0KCk7Ci0JCQl9Ci0JCQkKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0Q2xhc3NOYW1lKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJCQlnZXRTdWJqZWN0KCkuc2V0Q29udmVydGVyQ2xhc3MoY2xhc3NOYW1lKTsKLQkJCX0KLQkJCQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGdldFN1cGVySW50ZXJmYWNlTmFtZSgpIHsKLQkJCQlyZXR1cm4gQ3VzdG9tQ29udmVydGVyLkVDTElQU0VMSU5LX0NPTlZFUlRFUl9DTEFTU19OQU1FOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBjaGFyIGdldEVuY2xvc2luZ1R5cGVTZXBhcmF0b3IoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXRFbmNsb3NpbmdUeXBlU2VwYXJhdG9yKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkQm9vbGVhbkhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxDdXN0b21Db252ZXJ0ZXIsIEJvb2xlYW4+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiB0cmFuc2Zvcm0oQ3VzdG9tQ29udmVydGVyIHZhbHVlKSB7Ci0vLwkJCQlpZiAoZ2V0U3ViamVjdCgpICE9IG51bGwgJiYgZ2V0U3ViamVjdCgpLmdldFBhcmVudCgpLmdldFBlcnNpc3RlbnRBdHRyaWJ1dGUoKS5pc1ZpcnR1YWwoKSkgewotLy8JCQkJCXJldHVybiBCb29sZWFuLkZBTFNFOwotLy8JCQkJfQotCQkJCXJldHVybiBCb29sZWFuLnZhbHVlT2YodmFsdWUgIT0gbnVsbCk7Ci0JCQl9Ci0JCX07Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9DdXN0b21pemVyQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0N1c3RvbWl6ZXJDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDVlNmE5ZC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0N1c3RvbWl6ZXJDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEwNSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuSnBhUHJvamVjdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkN1c3RvbWl6ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLkVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkNsYXNzQ2hvb3NlclBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICoKLSAqIEBzZWUgQ3VzdG9taXplcgotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgQ3VzdG9taXplckNvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPEN1c3RvbWl6ZXI+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5DdXN0b21pemVyQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRQYW5lIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBDdXN0b21pemVyQ29tcG9zaXRlKEZvcm1QYW5lPD8+IHBhcmVudFBhbmUsIAotCQlQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIEN1c3RvbWl6ZXI+IHN1YmplY3RIb2xkZXIsCi0JCUNvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQkJc3VwZXIocGFyZW50UGFuZSwgc3ViamVjdEhvbGRlciwgcGFyZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJYWRkQ3VzdG9taXplckNsYXNzQ2hvb3Nlcihjb250YWluZXIpOwotCX0KLQkKLQlwcml2YXRlIENsYXNzQ2hvb3NlclBhbmU8Q3VzdG9taXplcj4gYWRkQ3VzdG9taXplckNsYXNzQ2hvb3NlcihDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJcmV0dXJuIG5ldyBDbGFzc0Nob29zZXJQYW5lPEN1c3RvbWl6ZXI+KHRoaXMsIGNvbnRhaW5lcikgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkVGV4dEhvbGRlcigpIHsKLQkJCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDdXN0b21pemVyLCBTdHJpbmc+KGdldFN1YmplY3RIb2xkZXIoKSwgQ3VzdG9taXplci5TUEVDSUZJRURfQ1VTVE9NSVpFUl9DTEFTU19QUk9QRVJUWSkgewotCQkJCQlAT3ZlcnJpZGUKLQkJCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0U3BlY2lmaWVkQ3VzdG9taXplckNsYXNzKCk7Ci0JCQkJCX0KLQotCQkJCQlAT3ZlcnJpZGUKLQkJCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCi0JCQkJCQlpZiAodmFsdWUubGVuZ3RoKCkgPT0gMCkgewotCQkJCQkJCXZhbHVlID0gbnVsbDsKLQkJCQkJCX0KLQotCQkJCQkJdGhpcy5zdWJqZWN0LnNldFNwZWNpZmllZEN1c3RvbWl6ZXJDbGFzcyh2YWx1ZSk7Ci0JCQkJCX0KLQkJCQl9OwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZ2V0Q2xhc3NOYW1lKCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0U3BlY2lmaWVkQ3VzdG9taXplckNsYXNzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBnZXRMYWJlbFRleHQoKSB7Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkN1c3RvbWl6ZXJDb21wb3NpdGVfY2xhc3NMYWJlbDsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSnBhUHJvamVjdCBnZXRKcGFQcm9qZWN0KCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0SnBhUHJvamVjdCgpOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldENsYXNzTmFtZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCQkJZ2V0U3ViamVjdCgpLnNldFNwZWNpZmllZEN1c3RvbWl6ZXJDbGFzcyhjbGFzc05hbWUpOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZ2V0U3VwZXJJbnRlcmZhY2VOYW1lKCkgewotCQkJCXJldHVybiBDdXN0b21pemVyLkVDTElQU0VMSU5LX0RFU0NSSVBUT1JfQ1VTVE9NSVpFUl9DTEFTU19OQU1FOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBjaGFyIGdldEVuY2xvc2luZ1R5cGVTZXBhcmF0b3IoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXRDdXN0b21pemVyQ2xhc3NFbmNsb3NpbmdUeXBlU2VwYXJhdG9yKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0Rpc2FibGVIaXRzQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0Rpc2FibGVIaXRzQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJhM2NlZjUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9EaXNhYmxlSGl0c0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTEyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLkpwdFVpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFRoaXMgY29tcG9zaXRlIHNpbXBseSBzaG93cyBhIHRyaS1zdGF0ZSBjaGVjayBib3ggZm9yIHRoZSBEaXNhYmxlIEhpdHMgb3B0aW9uLgotICogCi0gKiBAc2VlIEVjbGlwc2VMaW5rQ2FjaGluZwotICogQHNlZSBDYWNoaW5nQ29tcG9zaXRlIC0gQSBjb250YWluZXIgb2YgdGhpcyB3aWRnZXQKLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIERpc2FibGVIaXRzQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8Q2FjaGluZz4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPk9wdGlvbmFsQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRQYW5lIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBEaXNhYmxlSGl0c0NvbXBvc2l0ZShGb3JtUGFuZTw/IGV4dGVuZHMgQ2FjaGluZz4gcGFyZW50UGFuZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCkKLQl7Ci0JCXN1cGVyKHBhcmVudFBhbmUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZERpc2FibGVIaXRzSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDYWNoaW5nLCBCb29sZWFuPihnZXRTdWJqZWN0SG9sZGVyKCksIENhY2hpbmcuU1BFQ0lGSUVEX0RJU0FCTEVfSElUU19QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldFNwZWNpZmllZERpc2FibGVIaXRzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQl0aGlzLnN1YmplY3Quc2V0U3BlY2lmaWVkRGlzYWJsZUhpdHModmFsdWUpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHN1YmplY3RDaGFuZ2VkKCkgewotCQkJCU9iamVjdCBvbGRWYWx1ZSA9IHRoaXMuZ2V0VmFsdWUoKTsKLQkJCQlzdXBlci5zdWJqZWN0Q2hhbmdlZCgpOwotCQkJCU9iamVjdCBuZXdWYWx1ZSA9IHRoaXMuZ2V0VmFsdWUoKTsKLQotCQkJCS8vIE1ha2Ugc3VyZSB0aGUgZGVmYXVsdCB2YWx1ZSBpcyBhcHBlbmRlZCB0byB0aGUgdGV4dAotCQkJCWlmIChvbGRWYWx1ZSA9PSBuZXdWYWx1ZSAmJiBuZXdWYWx1ZSA9PSBudWxsKSB7Ci0JCQkJCXRoaXMuZmlyZUFzcGVjdENoYW5nZShCb29sZWFuLlRSVUUsIG5ld1ZhbHVlKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZERpc2FibGVIaXRzU3RyaW5nSG9sZGVyKCkgewotCi0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbiwgU3RyaW5nPihidWlsZERpc2FibGVIaXRzSG9sZGVyKCkpIHsKLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShCb29sZWFuIHZhbHVlKSB7Ci0KLQkJCQlpZiAoKGdldFN1YmplY3QoKSAhPSBudWxsKSAmJiAodmFsdWUgPT0gbnVsbCkpIHsKLQotCQkJCQlCb29sZWFuIGRlZmF1bHRWYWx1ZSA9IGdldFN1YmplY3QoKS5pc0RlZmF1bHREaXNhYmxlSGl0cygpOwotCi0JCQkJCWlmIChkZWZhdWx0VmFsdWUgIT0gbnVsbCkgewotCi0JCQkJCQlTdHJpbmcgZGVmYXVsdFN0cmluZ1ZhbHVlID0gZGVmYXVsdFZhbHVlID8gSnB0VWlNYXBwaW5nc01lc3NhZ2VzLkJvb2xlYW5fVHJ1ZSA6Ci0JCQkJCQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSnB0VWlNYXBwaW5nc01lc3NhZ2VzLkJvb2xlYW5fRmFsc2U7Ci0KLQkJCQkJCXJldHVybiBOTFMuYmluZCgKLQkJCQkJCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5EaXNhYmxlSGl0c0NvbXBvc2l0ZV9kaXNhYmxlSGl0c0RlZmF1bHQsCi0JCQkJCQkJZGVmYXVsdFN0cmluZ1ZhbHVlCi0JCQkJCQkpOwotCQkJCQl9Ci0JCQkJfQotCi0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkRpc2FibGVIaXRzQ29tcG9zaXRlX2Rpc2FibGVIaXRzTGFiZWw7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCWFkZFRyaVN0YXRlQ2hlY2tCb3hXaXRoRGVmYXVsdCgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkRpc2FibGVIaXRzQ29tcG9zaXRlX2Rpc2FibGVIaXRzTGFiZWwsCi0JCQlidWlsZERpc2FibGVIaXRzSG9sZGVyKCksCi0JCQlidWlsZERpc2FibGVIaXRzU3RyaW5nSG9sZGVyKCksCi0JCQlFY2xpcHNlTGlua0hlbHBDb250ZXh0SWRzLkNBQ0hJTkdfRElTQUJMRV9ISVRTCi0JCSk7Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvRWNsaXBzZUxpbmtCYXNpY0NvbGxlY3Rpb25NYXBwaW5nVWlQcm92aWRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua0Jhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDRiZjlmOWYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua0Jhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5FY2xpcHNlTGlua01hcHBpbmdLZXlzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQmFzaWNDb2xsZWN0aW9uTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwdFVpUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5KcHRVaUljb25zOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5ncmFwaGljcy5JbWFnZTsKLQotcHVibGljIGFic3RyYWN0IGNsYXNzIEVjbGlwc2VMaW5rQmFzaWNDb2xsZWN0aW9uTWFwcGluZ1VpUHJvdmlkZXI8VCBleHRlbmRzIEJhc2ljQ29sbGVjdGlvbk1hcHBpbmc+Ci0JaW1wbGVtZW50cyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxUPgotewotCQkKLQlwcm90ZWN0ZWQgRWNsaXBzZUxpbmtCYXNpY0NvbGxlY3Rpb25NYXBwaW5nVWlQcm92aWRlcigpIHt9Ci0JCQotCXB1YmxpYyBJbWFnZSBnZXRJbWFnZSgpIHsKLQkJcmV0dXJuIEpwdFVpUGx1Z2luLmdldEltYWdlKEpwdFVpSWNvbnMuSlBBX0NPTlRFTlQpOwotCX0KLQkKLQlwdWJsaWMgU3RyaW5nIGdldExhYmVsKCkgewotCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQmFzaWNDb2xsZWN0aW9uTWFwcGluZ1VpUHJvdmlkZXJfbGFiZWw7Ci0JfQotCQotCXB1YmxpYyBTdHJpbmcgZ2V0TGlua0xhYmVsKCkgewotCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQmFzaWNDb2xsZWN0aW9uTWFwcGluZ1VpUHJvdmlkZXJfbGlua0xhYmVsOwotCX0KLQkKLQlwdWJsaWMgU3RyaW5nIGdldEtleSgpIHsKLQkJcmV0dXJuIEVjbGlwc2VMaW5rTWFwcGluZ0tleXMuQkFTSUNfQ09MTEVDVElPTl9BVFRSSUJVVEVfTUFQUElOR19LRVk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0VjbGlwc2VMaW5rQmFzaWNNYXBNYXBwaW5nVWlQcm92aWRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua0Jhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTA4OTBmNy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0VjbGlwc2VMaW5rQmFzaWNNYXBNYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuRWNsaXBzZUxpbmtNYXBwaW5nS2V5czsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkJhc2ljTWFwTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwdFVpUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5KcHRVaUljb25zOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5ncmFwaGljcy5JbWFnZTsKLQotcHVibGljIGFic3RyYWN0IGNsYXNzIEVjbGlwc2VMaW5rQmFzaWNNYXBNYXBwaW5nVWlQcm92aWRlcjxUIGV4dGVuZHMgQmFzaWNNYXBNYXBwaW5nPgotCWltcGxlbWVudHMgQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8VD4KLXsKLQkKLQlwcm90ZWN0ZWQgRWNsaXBzZUxpbmtCYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSW1hZ2UgZ2V0SW1hZ2UoKSB7Ci0JCXJldHVybiBKcHRVaVBsdWdpbi5nZXRJbWFnZShKcHRVaUljb25zLkpQQV9DT05URU5UKTsKLQl9Ci0JCi0JcHVibGljIFN0cmluZyBnZXRMYWJlbCgpIHsKLQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkJhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXJfbGFiZWw7Ci0JfQotCQotCXB1YmxpYyBTdHJpbmcgZ2V0TGlua0xhYmVsKCkgewotCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQmFzaWNNYXBNYXBwaW5nVWlQcm92aWRlcl9saW5rTGFiZWw7Ci0JfQotCQotCXB1YmxpYyBTdHJpbmcgZ2V0S2V5KCkgewotCQlyZXR1cm4gRWNsaXBzZUxpbmtNYXBwaW5nS2V5cy5CQVNJQ19NQVBfQVRUUklCVVRFX01BUFBJTkdfS0VZOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua0Jhc2ljTWFwcGluZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua0Jhc2ljTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmNWNjYzY1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvRWNsaXBzZUxpbmtCYXNpY01hcHBpbmdDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI4MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkJhc2ljTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkNvbHVtbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkNvbnZlcnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkNvbnZlcnRpYmxlTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkVudW1lcmF0ZWRDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5UZW1wb3JhbENvbnZlcnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkNvbnZlcnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5FY2xpcHNlTGlua0Jhc2ljTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0Lk11dGFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLkVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuSnB0VWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkNvbHVtbkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FbnVtVHlwZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5GZXRjaFR5cGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuT3B0aW9uYWxDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuVGVtcG9yYWxUeXBlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLlBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWREYXRhOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuR3JpZExheW91dDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5CdXR0b247Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIEhlcmUgdGhlIGxheW91dCBvZiB0aGlzIHBhbmU6Ci0gKiA8cHJlPgotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IENvbHVtbkNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgRmV0Y2hUeXBlQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBUZW1wb3JhbFR5cGVDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IEVudW1UeXBlQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgT3B0aW9uYWxDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBNdXRhYmxlQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IExvYkNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS08L3ByZT4KLSAqCi0gKiBAc2VlIEJhc2ljTWFwcGluZwotICogQHNlZSBCYXNlSnBhVWlGYWN0b3J5IC0gVGhlIGZhY3RvcnkgY3JlYXRpbmcgdGhpcyBwYW5lCi0gKiBAc2VlIENvbHVtbkNvbXBvc2l0ZQotICogQHNlZSBFbnVtVHlwZUNvbXBvc2l0ZQotICogQHNlZSBGZXRjaFR5cGVDb21wb3NpdGUKLSAqIEBzZWUgTG9iQ29tcG9zaXRlCi0gKiBAc2VlIE9wdGlvbmFsQ29tcG9zaXRlCi0gKiBAc2VlIFRlbXBvcmFsVHlwZUNvbXBvc2l0ZQotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtCYXNpY01hcHBpbmdDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxCYXNpY01hcHBpbmc+Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGltcGxlbWVudHMgSnBhQ29tcG9zaXRlCi17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5CYXNpY01hcHBpbmdDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHN1YmplY3RIb2xkZXIgVGhlIGhvbGRlciBvZiB0aGUgc3ViamVjdCA8Y29kZT5JQmFzaWNNYXBwaW5nPC9jb2RlPgotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKiBAcGFyYW0gd2lkZ2V0RmFjdG9yeSBUaGUgZmFjdG9yeSB1c2VkIHRvIGNyZWF0ZSB2YXJpb3VzIGNvbW1vbiB3aWRnZXRzCi0JICovCi0JcHVibGljIEVjbGlwc2VMaW5rQmFzaWNNYXBwaW5nQ29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgQmFzaWNNYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCWluaXRpYWxpemVHZW5lcmFsUGFuZShjb250YWluZXIpOwotCQlpbml0aWFsaXplVHlwZVBhbmUoY29udGFpbmVyKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUdlbmVyYWxQYW5lKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJaW50IGdyb3VwQm94TWFyZ2luID0gZ2V0R3JvdXBCb3hNYXJnaW4oKTsKLQotCQluZXcgQ29sdW1uQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQ29sdW1uSG9sZGVyKCksIGNvbnRhaW5lcik7Ci0KLQkJLy8gQWxpZ24gdGhlIHdpZGdldHMgdW5kZXIgdGhlIENvbHVtbkNvbXBvc2l0ZQotCQljb250YWluZXIgPSBhZGRTdWJQYW5lKGNvbnRhaW5lciwgMCwgZ3JvdXBCb3hNYXJnaW4sIDAsIGdyb3VwQm94TWFyZ2luKTsKLQotCQluZXcgRmV0Y2hUeXBlQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JCW5ldyBPcHRpb25hbENvbXBvc2l0ZSh0aGlzLCBhZGRTdWJQYW5lKGNvbnRhaW5lciwgNCkpOwotCQkKLQkJLy8gTXV0YWJsZSB3aWRnZXRzCi0JCW5ldyBNdXRhYmxlQ29tcG9zaXRlKHRoaXMsIGJ1aWxkTXV0YWJsZUhvbGRlcigpLCBjb250YWluZXIpOwotCX0KLQkKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplVHlwZVBhbmUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCWNvbnRhaW5lciA9IGFkZENvbGxhcHNhYmxlU2VjdGlvbigKLQkJCWNvbnRhaW5lciwKLQkJCUpwdFVpTWFwcGluZ3NNZXNzYWdlcy5UeXBlU2VjdGlvbl90eXBlCi0JCSk7Ci0JCSgoR3JpZExheW91dCkgY29udGFpbmVyLmdldExheW91dCgpKS5udW1Db2x1bW5zID0gMjsKLQotCQkvLyBObyBjb252ZXJ0ZXIKLQkJQnV0dG9uIG5vQ29udmVydGVyQnV0dG9uID0gYWRkUmFkaW9CdXR0b24oCi0JCQljb250YWluZXIsIAotCQkJSnB0VWlNYXBwaW5nc01lc3NhZ2VzLlR5cGVTZWN0aW9uX2RlZmF1bHQsIAotCQkJYnVpbGROb0NvbnZlcnRlckhvbGRlcigpLCAKLQkJCW51bGwpOwotCQkoKEdyaWREYXRhKSBub0NvbnZlcnRlckJ1dHRvbi5nZXRMYXlvdXREYXRhKCkpLmhvcml6b250YWxTcGFuID0gMjsKLQkJCi0JCS8vIExvYgotCQlCdXR0b24gbG9iQnV0dG9uID0gYWRkUmFkaW9CdXR0b24oCi0JCQljb250YWluZXIsIAotCQkJSnB0VWlNYXBwaW5nc01lc3NhZ2VzLlR5cGVTZWN0aW9uX2xvYiwgCi0JCQlidWlsZENvbnZlcnRlckJvb2xlYW5Ib2xkZXIoQ29udmVydGVyLkxPQl9DT05WRVJURVIpLCAKLQkJCW51bGwpOwotCQkoKEdyaWREYXRhKSBsb2JCdXR0b24uZ2V0TGF5b3V0RGF0YSgpKS5ob3Jpem9udGFsU3BhbiA9IDI7Ci0JCQotCQlQcm9wZXJ0eVZhbHVlTW9kZWw8Q29udmVydGVyPiBzcGVjaWZpZWRDb252ZXJ0ZXJIb2xkZXIgPSBidWlsZFNwZWNpZmllZENvbnZlcnRlckhvbGRlcigpOwotCQkvLyBUZW1wb3JhbAotCQlhZGRSYWRpb0J1dHRvbigKLQkJCWNvbnRhaW5lciwgCi0JCQlKcHRVaU1hcHBpbmdzTWVzc2FnZXMuVHlwZVNlY3Rpb25fdGVtcG9yYWwsIAotCQkJYnVpbGRDb252ZXJ0ZXJCb29sZWFuSG9sZGVyKENvbnZlcnRlci5URU1QT1JBTF9DT05WRVJURVIpLCAKLQkJCW51bGwpOwotCQlyZWdpc3RlclN1YlBhbmUobmV3IFRlbXBvcmFsVHlwZUNvbXBvc2l0ZShidWlsZFRlbXBvcmFsQ29udmVydGVySG9sZGVyKHNwZWNpZmllZENvbnZlcnRlckhvbGRlciksIGNvbnRhaW5lciwgZ2V0V2lkZ2V0RmFjdG9yeSgpKSk7Ci0JCQotCQkKLQkJLy8gRW51bWVyYXRlZAotCQlhZGRSYWRpb0J1dHRvbigKLQkJCWNvbnRhaW5lciwgCi0JCQlKcHRVaU1hcHBpbmdzTWVzc2FnZXMuVHlwZVNlY3Rpb25fZW51bWVyYXRlZCwgCi0JCQlidWlsZENvbnZlcnRlckJvb2xlYW5Ib2xkZXIoQ29udmVydGVyLkVOVU1FUkFURURfQ09OVkVSVEVSKSwgCi0JCQludWxsKTsKLQkJcmVnaXN0ZXJTdWJQYW5lKG5ldyBFbnVtVHlwZUNvbXBvc2l0ZShidWlsZEVudW1lcmF0ZWRDb252ZXJ0ZXJIb2xkZXIoc3BlY2lmaWVkQ29udmVydGVySG9sZGVyKSwgY29udGFpbmVyLCBnZXRXaWRnZXRGYWN0b3J5KCkpKTsKLQotCQkvLyBFY2xpcHNlTGluayBDb252ZXJ0ZXIKLQkJQnV0dG9uIGVsQ29udmVydGVyQnV0dG9uID0gYWRkUmFkaW9CdXR0b24oCi0JCQljb250YWluZXIsIAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuVHlwZVNlY3Rpb25fY29udmVydGVkLCAKLQkJCWJ1aWxkQ29udmVydGVyQm9vbGVhbkhvbGRlcihDb252ZXJ0LkVDTElQU0VfTElOS19DT05WRVJURVIpLCAKLQkJCW51bGwpOwotCQkoKEdyaWREYXRhKSBlbENvbnZlcnRlckJ1dHRvbi5nZXRMYXlvdXREYXRhKCkpLmhvcml6b250YWxTcGFuID0gMjsKLQotCQlQYW5lPENvbnZlcnQ+IGNvbnZlcnRDb21wb3NpdGUgPSBidWlsZENvbnZlcnRDb21wb3NpdGUoYnVpbGRFY2xpcHNlTGlua0NvbnZlcnRlckhvbGRlcihzcGVjaWZpZWRDb252ZXJ0ZXJIb2xkZXIpLCBjb250YWluZXIpOwotCQlHcmlkRGF0YSBncmlkRGF0YSA9IChHcmlkRGF0YSkgY29udmVydENvbXBvc2l0ZS5nZXRDb250cm9sKCkuZ2V0TGF5b3V0RGF0YSgpOwotCQlncmlkRGF0YS5ob3Jpem9udGFsU3BhbiA9IDI7Ci0JCWdyaWREYXRhLmhvcml6b250YWxJbmRlbnQgPSAyMDsKLQkJcmVnaXN0ZXJTdWJQYW5lKGNvbnZlcnRDb21wb3NpdGUpOwotCX0KLQotCXByb3RlY3RlZCBQYW5lPENvbnZlcnQ+IGJ1aWxkQ29udmVydENvbXBvc2l0ZShQcm9wZXJ0eVZhbHVlTW9kZWw8Q29udmVydD4gY29udmVydEhvbGRlciwgQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlyZXR1cm4gbmV3IENvbnZlcnRDb21wb3NpdGUoY29udmVydEhvbGRlciwgY29udGFpbmVyLCBnZXRXaWRnZXRGYWN0b3J5KCkpOwotCX0KLQkKLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPENvbHVtbj4gYnVpbGRDb2x1bW5Ib2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8QmFzaWNNYXBwaW5nLCBDb2x1bW4+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ29sdW1uIHRyYW5zZm9ybV8oQmFzaWNNYXBwaW5nIHZhbHVlKSB7Ci0JCQkJcmV0dXJuIHZhbHVlLmdldENvbHVtbigpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPE11dGFibGU+IGJ1aWxkTXV0YWJsZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8QmFzaWNNYXBwaW5nLCBNdXRhYmxlPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIE11dGFibGUgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuICgoRWNsaXBzZUxpbmtCYXNpY01hcHBpbmcpIHRoaXMuc3ViamVjdCkuZ2V0TXV0YWJsZSgpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnRlcj4gYnVpbGRTcGVjaWZpZWRDb252ZXJ0ZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEJhc2ljTWFwcGluZywgQ29udmVydGVyPihnZXRTdWJqZWN0SG9sZGVyKCksIENvbnZlcnRpYmxlTWFwcGluZy5TUEVDSUZJRURfQ09OVkVSVEVSX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDb252ZXJ0ZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRTcGVjaWZpZWRDb252ZXJ0ZXIoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxUZW1wb3JhbENvbnZlcnRlcj4gYnVpbGRUZW1wb3JhbENvbnZlcnRlckhvbGRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8Q29udmVydGVyPiBjb252ZXJ0ZXJIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxDb252ZXJ0ZXIsIFRlbXBvcmFsQ29udmVydGVyPihjb252ZXJ0ZXJIb2xkZXIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFRlbXBvcmFsQ29udmVydGVyIHRyYW5zZm9ybV8oQ29udmVydGVyIGNvbnZlcnRlcikgewotCQkJCXJldHVybiAoY29udmVydGVyICE9IG51bGwgJiYgY29udmVydGVyLmdldFR5cGUoKSA9PSBDb252ZXJ0ZXIuVEVNUE9SQUxfQ09OVkVSVEVSKSA/IChUZW1wb3JhbENvbnZlcnRlcikgY29udmVydGVyIDogbnVsbDsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxFbnVtZXJhdGVkQ29udmVydGVyPiBidWlsZEVudW1lcmF0ZWRDb252ZXJ0ZXJIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnRlcj4gY29udmVydGVySG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Q29udmVydGVyLCBFbnVtZXJhdGVkQ29udmVydGVyPihjb252ZXJ0ZXJIb2xkZXIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEVudW1lcmF0ZWRDb252ZXJ0ZXIgdHJhbnNmb3JtXyhDb252ZXJ0ZXIgY29udmVydGVyKSB7Ci0JCQkJcmV0dXJuIChjb252ZXJ0ZXIgIT0gbnVsbCAmJiBjb252ZXJ0ZXIuZ2V0VHlwZSgpID09IENvbnZlcnRlci5FTlVNRVJBVEVEX0NPTlZFUlRFUikgPyAoRW51bWVyYXRlZENvbnZlcnRlcikgY29udmVydGVyIDogbnVsbDsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxDb252ZXJ0PiBidWlsZEVjbGlwc2VMaW5rQ29udmVydGVySG9sZGVyKFByb3BlcnR5VmFsdWVNb2RlbDxDb252ZXJ0ZXI+IGNvbnZlcnRlckhvbGRlcikgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnRlciwgQ29udmVydD4oY29udmVydGVySG9sZGVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDb252ZXJ0IHRyYW5zZm9ybV8oQ29udmVydGVyIGNvbnZlcnRlcikgewotCQkJCXJldHVybiAoY29udmVydGVyICE9IG51bGwgJiYgY29udmVydGVyLmdldFR5cGUoKSA9PSBDb252ZXJ0LkVDTElQU0VfTElOS19DT05WRVJURVIpID8gKENvbnZlcnQpIGNvbnZlcnRlciA6IG51bGw7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByb3RlY3RlZCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZE5vQ29udmVydGVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxCYXNpY01hcHBpbmcsIEJvb2xlYW4+KGdldFN1YmplY3RIb2xkZXIoKSwgQ29udmVydGlibGVNYXBwaW5nLlNQRUNJRklFRF9DT05WRVJURVJfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIEJvb2xlYW4udmFsdWVPZih0aGlzLnN1YmplY3QuZ2V0U3BlY2lmaWVkQ29udmVydGVyKCkgPT0gbnVsbCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlpZiAodmFsdWUuYm9vbGVhblZhbHVlKCkpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LnNldFNwZWNpZmllZENvbnZlcnRlcihDb252ZXJ0ZXIuTk9fQ09OVkVSVEVSKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByb3RlY3RlZCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZENvbnZlcnRlckJvb2xlYW5Ib2xkZXIoZmluYWwgU3RyaW5nIGNvbnZlcnRlclR5cGUpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8QmFzaWNNYXBwaW5nLCBCb29sZWFuPihnZXRTdWJqZWN0SG9sZGVyKCksIENvbnZlcnRpYmxlTWFwcGluZy5TUEVDSUZJRURfQ09OVkVSVEVSX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCUNvbnZlcnRlciBjb252ZXJ0ZXIgPSB0aGlzLnN1YmplY3QuZ2V0U3BlY2lmaWVkQ29udmVydGVyKCk7Ci0JCQkJaWYgKGNvbnZlcnRlciA9PSBudWxsKSB7Ci0JCQkJCXJldHVybiBCb29sZWFuLkZBTFNFOwotCQkJCX0KLQkJCQlyZXR1cm4gQm9vbGVhbi52YWx1ZU9mKGNvbnZlcnRlci5nZXRUeXBlKCkgPT0gY29udmVydGVyVHlwZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlpZiAodmFsdWUuYm9vbGVhblZhbHVlKCkpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LnNldFNwZWNpZmllZENvbnZlcnRlcihjb252ZXJ0ZXJUeXBlKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvRWNsaXBzZUxpbmtFbWJlZGRhYmxlQWR2YW5jZWRDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvRWNsaXBzZUxpbmtFbWJlZGRhYmxlQWR2YW5jZWRDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTVjN2M4Ny4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0VjbGlwc2VMaW5rRW1iZWRkYWJsZUFkdmFuY2VkQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1OSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkVtYmVkZGFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5DaGFuZ2VUcmFja2luZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkN1c3RvbWl6ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5FY2xpcHNlTGlua0VtYmVkZGFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLkVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtFbWJlZGRhYmxlQWR2YW5jZWRDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxFbWJlZGRhYmxlPiB7Ci0JCi0JcHVibGljIEVjbGlwc2VMaW5rRW1iZWRkYWJsZUFkdmFuY2VkQ29tcG9zaXRlKAotCQkJRm9ybVBhbmU8PyBleHRlbmRzIEVtYmVkZGFibGU+IHBhcmVudFBhbmUsCi0JCQlDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50UGFuZSwgcGFyZW50LCBmYWxzZSk7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQljb250YWluZXIgPSBhZGRDb2xsYXBzYWJsZVNlY3Rpb24oCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5FY2xpcHNlTGlua1R5cGVNYXBwaW5nQ29tcG9zaXRlX2FkdmFuY2VkCi0JCSk7Ci0JCQotCQluZXcgQ3VzdG9taXplckNvbXBvc2l0ZSh0aGlzLCBidWlsZEN1c3RvbWl6ZXJIb2xkZXIoKSwgY29udGFpbmVyKTsKLQkJbmV3IENoYW5nZVRyYWNraW5nQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQ2hhbmdlVHJhY2tpbmdIb2xkZXIoKSwgY29udGFpbmVyKTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8Q3VzdG9taXplcj4gYnVpbGRDdXN0b21pemVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxFbWJlZGRhYmxlLCBDdXN0b21pemVyPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEN1c3RvbWl6ZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuICgoRWNsaXBzZUxpbmtFbWJlZGRhYmxlKSB0aGlzLnN1YmplY3QpLmdldEN1c3RvbWl6ZXIoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8Q2hhbmdlVHJhY2tpbmc+IGJ1aWxkQ2hhbmdlVHJhY2tpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEVtYmVkZGFibGUsIENoYW5nZVRyYWNraW5nPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENoYW5nZVRyYWNraW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiAoKEVjbGlwc2VMaW5rRW1iZWRkYWJsZSkgdGhpcy5zdWJqZWN0KS5nZXRDaGFuZ2VUcmFja2luZygpOwotCQkJfQotCQl9OwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvRWNsaXBzZUxpbmtFbnRpdHlBZHZhbmNlZENvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua0VudGl0eUFkdmFuY2VkQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGRhNzM0NjUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua0VudGl0eUFkdmFuY2VkQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw3MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkVudGl0eTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkNoYW5nZVRyYWNraW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQ3VzdG9taXplcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkVjbGlwc2VMaW5rRW50aXR5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuUmVhZE9ubHk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLkVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtFbnRpdHlBZHZhbmNlZENvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPEVudGl0eT4gewotCQotCXB1YmxpYyBFY2xpcHNlTGlua0VudGl0eUFkdmFuY2VkQ29tcG9zaXRlKAotCQkJRm9ybVBhbmU8PyBleHRlbmRzIEVudGl0eT4gcGFyZW50UGFuZSwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRQYW5lLCBwYXJlbnQsIGZhbHNlKTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCWNvbnRhaW5lciA9IGFkZENvbGxhcHNhYmxlU2VjdGlvbigKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkVjbGlwc2VMaW5rVHlwZU1hcHBpbmdDb21wb3NpdGVfYWR2YW5jZWQKLQkJKTsKLQkJCi0JCW5ldyBSZWFkT25seUNvbXBvc2l0ZSh0aGlzLCBidWlsZFJlYWRPbmx5SG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JCW5ldyBDdXN0b21pemVyQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQ3VzdG9taXplckhvbGRlcigpLCBjb250YWluZXIpOwotCQluZXcgQ2hhbmdlVHJhY2tpbmdDb21wb3NpdGUodGhpcywgYnVpbGRDaGFuZ2VUcmFja2luZ0hvbGRlcigpLCBjb250YWluZXIpOwotCX0KLQkKLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxSZWFkT25seT4gYnVpbGRSZWFkT25seUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8RW50aXR5LCBSZWFkT25seT4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBSZWFkT25seSBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gKChFY2xpcHNlTGlua0VudGl0eSkgdGhpcy5zdWJqZWN0KS5nZXRSZWFkT25seSgpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxDdXN0b21pemVyPiBidWlsZEN1c3RvbWl6ZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEVudGl0eSwgQ3VzdG9taXplcj4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDdXN0b21pemVyIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiAoKEVjbGlwc2VMaW5rRW50aXR5KSB0aGlzLnN1YmplY3QpLmdldEN1c3RvbWl6ZXIoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8Q2hhbmdlVHJhY2tpbmc+IGJ1aWxkQ2hhbmdlVHJhY2tpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEVudGl0eSwgQ2hhbmdlVHJhY2tpbmc+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ2hhbmdlVHJhY2tpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuICgoRWNsaXBzZUxpbmtFbnRpdHkpIHRoaXMuc3ViamVjdCkuZ2V0Q2hhbmdlVHJhY2tpbmcoKTsKLQkJCX0KLQkJfTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0VjbGlwc2VMaW5rSWRNYXBwaW5nQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0VjbGlwc2VMaW5rSWRNYXBwaW5nQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDRjYmM4NzUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua0lkTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjUyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuQ29sdW1uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuQ29udmVydGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuQ29udmVydGlibGVNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuSWRNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuVGVtcG9yYWxDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5Db252ZXJ0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuRWNsaXBzZUxpbmtJZE1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5NdXRhYmxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLkpwdFVpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5Db2x1bW5Db21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuR2VuZXJhdGlvbkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5UZW1wb3JhbFR5cGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuR3JpZERhdGE7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkTGF5b3V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkJ1dHRvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogSGVyZSB0aGUgbGF5b3V0IG9mIHRoaXMgcGFuZToKLSAqIDxwcmU+Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgQ29sdW1uQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBUZW1wb3JhbFR5cGVDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IEdlbmVyYXRpb25Db21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS08L3ByZT4KLSAqCi0gKiBAc2VlIElkTWFwcGluZwotICogQHNlZSBCYXNlSnBhVWlGYWN0b3J5IC0gVGhlIGZhY3RvcnkgY3JlYXRpbmcgdGhpcyBwYW5lCi0gKiBAc2VlIENvbHVtbkNvbXBvc2l0ZQotICogQHNlZSBUZW1wb3JhbFR5cGVDb21wb3NpdGUKLSAqIEBzZWUgR2VuZXJhdGlvbkNvbXBvc2l0ZQotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtJZE1hcHBpbmdDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxJZE1hcHBpbmc+Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGltcGxlbWVudHMgSnBhQ29tcG9zaXRlCi17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5JZE1hcHBpbmdDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHN1YmplY3RIb2xkZXIgVGhlIGhvbGRlciBvZiB0aGUgc3ViamVjdCA8Y29kZT5JSWRNYXBwaW5nPC9jb2RlPgotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKiBAcGFyYW0gd2lkZ2V0RmFjdG9yeSBUaGUgZmFjdG9yeSB1c2VkIHRvIGNyZWF0ZSB2YXJpb3VzIGNvbW1vbiB3aWRnZXRzCi0JICovCi0JcHVibGljIEVjbGlwc2VMaW5rSWRNYXBwaW5nQ29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgSWRNYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgQ29sdW1uPiBidWlsZENvbHVtbkhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxJZE1hcHBpbmcsIENvbHVtbj4oZ2V0U3ViamVjdEhvbGRlcigpKSAgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ29sdW1uIHRyYW5zZm9ybV8oSWRNYXBwaW5nIHZhbHVlKSB7Ci0JCQkJcmV0dXJuIHZhbHVlLmdldENvbHVtbigpOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlpbml0aWFsaXplR2VuZXJhbFBhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZVR5cGVQYW5lKGNvbnRhaW5lcik7Ci0KLQkJLy8gR2VuZXJhdGlvbiBwYW5lCi0JCW5ldyBHZW5lcmF0aW9uQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVHZW5lcmFsUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCWludCBncm91cEJveE1hcmdpbiA9IGdldEdyb3VwQm94TWFyZ2luKCk7Ci0JCQotCQkvLyBDb2x1bW4gd2lkZ2V0cwotCQluZXcgQ29sdW1uQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQ29sdW1uSG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JCQotCQkvLyBBbGlnbiB0aGUgd2lkZ2V0cyB1bmRlciB0aGUgQ29sdW1uQ29tcG9zaXRlCi0JCWNvbnRhaW5lciA9IGFkZFN1YlBhbmUoY29udGFpbmVyLCAwLCBncm91cEJveE1hcmdpbiwgMCwgZ3JvdXBCb3hNYXJnaW4pOwotCi0JCS8vIE11dGFibGUgd2lkZ2V0cwotCQluZXcgTXV0YWJsZUNvbXBvc2l0ZSh0aGlzLCBidWlsZE11dGFibGVIb2xkZXIoKSwgY29udGFpbmVyKTsKLQl9CQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVUeXBlUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJY29udGFpbmVyID0gYWRkQ29sbGFwc2FibGVTZWN0aW9uKAotCQkJYWRkU3ViUGFuZShjb250YWluZXIsIDUpLAotCQkJSnB0VWlNYXBwaW5nc01lc3NhZ2VzLlR5cGVTZWN0aW9uX3R5cGUKLQkJKTsKLQkJKChHcmlkTGF5b3V0KSBjb250YWluZXIuZ2V0TGF5b3V0KCkpLm51bUNvbHVtbnMgPSAyOwotCi0JCS8vIE5vIGNvbnZlcnRlcgotCQlCdXR0b24gbm9Db252ZXJ0ZXJCdXR0b24gPSBhZGRSYWRpb0J1dHRvbigKLQkJCWNvbnRhaW5lciwgCi0JCQlKcHRVaU1hcHBpbmdzTWVzc2FnZXMuVHlwZVNlY3Rpb25fZGVmYXVsdCwgCi0JCQlidWlsZE5vQ29udmVydGVySG9sZGVyKCksIAotCQkJbnVsbCk7Ci0JCSgoR3JpZERhdGEpIG5vQ29udmVydGVyQnV0dG9uLmdldExheW91dERhdGEoKSkuaG9yaXpvbnRhbFNwYW4gPSAyOwotCQkJCQotCQlQcm9wZXJ0eVZhbHVlTW9kZWw8Q29udmVydGVyPiBzcGVjaWZpZWRDb252ZXJ0ZXJIb2xkZXIgPSBidWlsZFNwZWNpZmllZENvbnZlcnRlckhvbGRlcigpOwotCQkvLyBUZW1wb3JhbAotCQlhZGRSYWRpb0J1dHRvbigKLQkJCWNvbnRhaW5lciwgCi0JCQlKcHRVaU1hcHBpbmdzTWVzc2FnZXMuVHlwZVNlY3Rpb25fdGVtcG9yYWwsIAotCQkJYnVpbGRUZW1wb3JhbEJvb2xlYW5Ib2xkZXIoKSwgCi0JCQludWxsKTsKLQkJcmVnaXN0ZXJTdWJQYW5lKG5ldyBUZW1wb3JhbFR5cGVDb21wb3NpdGUoYnVpbGRUZW1wb3JhbENvbnZlcnRlckhvbGRlcihzcGVjaWZpZWRDb252ZXJ0ZXJIb2xkZXIpLCBjb250YWluZXIsIGdldFdpZGdldEZhY3RvcnkoKSkpOwotCi0JCS8vIEVjbGlwc2VMaW5rIENvbnZlcnRlcgotCQlCdXR0b24gZWxDb252ZXJ0ZXJCdXR0b24gPSBhZGRSYWRpb0J1dHRvbigKLQkJCWNvbnRhaW5lciwgCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5UeXBlU2VjdGlvbl9jb252ZXJ0ZWQsIAotCQkJYnVpbGRFY2xpcHNlTGlua0NvbnZlcnRlckJvb2xlYW5Ib2xkZXIoKSwgCi0JCQludWxsKTsKLQkJKChHcmlkRGF0YSkgZWxDb252ZXJ0ZXJCdXR0b24uZ2V0TGF5b3V0RGF0YSgpKS5ob3Jpem9udGFsU3BhbiA9IDI7Ci0KLQkJUGFuZTxDb252ZXJ0PiBjb252ZXJ0Q29tcG9zaXRlID0gYnVpbGRDb252ZXJ0Q29tcG9zaXRlKGJ1aWxkRWNsaXBzZUxpbmtDb252ZXJ0ZXJIb2xkZXIoc3BlY2lmaWVkQ29udmVydGVySG9sZGVyKSwgY29udGFpbmVyKTsKLQkJR3JpZERhdGEgZ3JpZERhdGEgPSAoR3JpZERhdGEpIGNvbnZlcnRDb21wb3NpdGUuZ2V0Q29udHJvbCgpLmdldExheW91dERhdGEoKTsKLQkJZ3JpZERhdGEuaG9yaXpvbnRhbFNwYW4gPSAyOwotCQlncmlkRGF0YS5ob3Jpem9udGFsSW5kZW50ID0gMjA7Ci0JCXJlZ2lzdGVyU3ViUGFuZShjb252ZXJ0Q29tcG9zaXRlKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFBhbmU8Q29udmVydD4gYnVpbGRDb252ZXJ0Q29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDxDb252ZXJ0PiBjb252ZXJ0SG9sZGVyLCBDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCXJldHVybiBuZXcgQ29udmVydENvbXBvc2l0ZShjb252ZXJ0SG9sZGVyLCBjb250YWluZXIsIGdldFdpZGdldEZhY3RvcnkoKSk7Ci0JfQotCi0JcHJvdGVjdGVkIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkTm9Db252ZXJ0ZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPElkTWFwcGluZywgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb252ZXJ0aWJsZU1hcHBpbmcuU1BFQ0lGSUVEX0NPTlZFUlRFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gQm9vbGVhbi52YWx1ZU9mKHRoaXMuc3ViamVjdC5nZXRTcGVjaWZpZWRDb252ZXJ0ZXIoKSA9PSBudWxsKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZS5ib29sZWFuVmFsdWUoKSkgewotCQkJCQl0aGlzLnN1YmplY3Quc2V0U3BlY2lmaWVkQ29udmVydGVyKENvbnZlcnRlci5OT19DT05WRVJURVIpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnQ+IGJ1aWxkRWNsaXBzZUxpbmtDb252ZXJ0ZXJIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnRlcj4gY29udmVydGVySG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Q29udmVydGVyLCBDb252ZXJ0Pihjb252ZXJ0ZXJIb2xkZXIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENvbnZlcnQgdHJhbnNmb3JtXyhDb252ZXJ0ZXIgY29udmVydGVyKSB7Ci0JCQkJcmV0dXJuIChjb252ZXJ0ZXIgIT0gbnVsbCAmJiBjb252ZXJ0ZXIuZ2V0VHlwZSgpID09IENvbnZlcnQuRUNMSVBTRV9MSU5LX0NPTlZFUlRFUikgPyAoQ29udmVydCkgY29udmVydGVyIDogbnVsbDsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcm90ZWN0ZWQgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRUZW1wb3JhbEJvb2xlYW5Ib2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPElkTWFwcGluZywgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb252ZXJ0aWJsZU1hcHBpbmcuU1BFQ0lGSUVEX0NPTlZFUlRFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlDb252ZXJ0ZXIgY29udmVydGVyID0gdGhpcy5zdWJqZWN0LmdldFNwZWNpZmllZENvbnZlcnRlcigpOwotCQkJCWlmIChjb252ZXJ0ZXIgPT0gbnVsbCkgewotCQkJCQlyZXR1cm4gQm9vbGVhbi5GQUxTRTsKLQkJCQl9Ci0JCQkJcmV0dXJuIEJvb2xlYW4udmFsdWVPZihjb252ZXJ0ZXIuZ2V0VHlwZSgpID09IENvbnZlcnRlci5URU1QT1JBTF9DT05WRVJURVIpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJaWYgKHZhbHVlLmJvb2xlYW5WYWx1ZSgpKSB7Ci0JCQkJCXRoaXMuc3ViamVjdC5zZXRTcGVjaWZpZWRDb252ZXJ0ZXIoQ29udmVydGVyLlRFTVBPUkFMX0NPTlZFUlRFUik7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQkKLQlwcm90ZWN0ZWQgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRFY2xpcHNlTGlua0NvbnZlcnRlckJvb2xlYW5Ib2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPElkTWFwcGluZywgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb252ZXJ0aWJsZU1hcHBpbmcuU1BFQ0lGSUVEX0NPTlZFUlRFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlDb252ZXJ0ZXIgY29udmVydGVyID0gdGhpcy5zdWJqZWN0LmdldFNwZWNpZmllZENvbnZlcnRlcigpOwotCQkJCWlmIChjb252ZXJ0ZXIgPT0gbnVsbCkgewotCQkJCQlyZXR1cm4gQm9vbGVhbi5GQUxTRTsKLQkJCQl9Ci0JCQkJcmV0dXJuIEJvb2xlYW4udmFsdWVPZihjb252ZXJ0ZXIuZ2V0VHlwZSgpID09IENvbnZlcnQuRUNMSVBTRV9MSU5LX0NPTlZFUlRFUik7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlpZiAodmFsdWUuYm9vbGVhblZhbHVlKCkpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LnNldFNwZWNpZmllZENvbnZlcnRlcihDb252ZXJ0LkVDTElQU0VfTElOS19DT05WRVJURVIpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxDb252ZXJ0ZXI+IGJ1aWxkU3BlY2lmaWVkQ29udmVydGVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxJZE1hcHBpbmcsIENvbnZlcnRlcj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb252ZXJ0aWJsZU1hcHBpbmcuU1BFQ0lGSUVEX0NPTlZFUlRFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ29udmVydGVyIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0U3BlY2lmaWVkQ29udmVydGVyKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8VGVtcG9yYWxDb252ZXJ0ZXI+IGJ1aWxkVGVtcG9yYWxDb252ZXJ0ZXJIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnRlcj4gY29udmVydGVySG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Q29udmVydGVyLCBUZW1wb3JhbENvbnZlcnRlcj4oY29udmVydGVySG9sZGVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBUZW1wb3JhbENvbnZlcnRlciB0cmFuc2Zvcm1fKENvbnZlcnRlciBjb252ZXJ0ZXIpIHsKLQkJCQlyZXR1cm4gKGNvbnZlcnRlciAhPSBudWxsICYmIGNvbnZlcnRlci5nZXRUeXBlKCkgPT0gQ29udmVydGVyLlRFTVBPUkFMX0NPTlZFUlRFUikgPyAoVGVtcG9yYWxDb252ZXJ0ZXIpIGNvbnZlcnRlciA6IG51bGw7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8TXV0YWJsZT4gYnVpbGRNdXRhYmxlSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxJZE1hcHBpbmcsIE11dGFibGU+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgTXV0YWJsZSBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gKChFY2xpcHNlTGlua0lkTWFwcGluZykgdGhpcy5zdWJqZWN0KS5nZXRNdXRhYmxlKCk7Ci0JCQl9Ci0JCX07Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvRWNsaXBzZUxpbmtNYW55VG9NYW55TWFwcGluZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua01hbnlUb01hbnlNYXBwaW5nQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDc5Y2ZmNzYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua01hbnlUb01hbnlNYXBwaW5nQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMzMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5DYXNjYWRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuTWFueVRvTWFueU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5NYW55VG9NYW55UmVsYXRpb25zaGlwUmVmZXJlbmNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuRWNsaXBzZUxpbmtSZWxhdGlvbnNoaXBNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuSm9pbkZldGNoOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5DYXNjYWRlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkZldGNoVHlwZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5NYW55VG9NYW55Sm9pbmluZ1N0cmF0ZWd5UGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5PcmRlcmluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5UYXJnZXRFbnRpdHlDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogSGVyZSB0aGUgbGF5b3V0IG9mIHRoaXMgcGFuZToKLSAqIDxwcmU+Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgVGFyZ2V0RW50aXR5Q29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBKb2luaW5nU3RyYXRlZ3lDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IEZldGNoVHlwZUNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgQ2FzY2FkZUNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBPcmRlcmluZ0NvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSB7QGxpbmsgTWFueVRvTWFueU1hcHBpbmd9Ci0gKiBAc2VlIHtAbGluayBCYXNlSnBhVWlGYWN0b3J5fSAtIFRoZSBmYWN0b3J5IGNyZWF0aW5nIHRoaXMgcGFuZQotICogQHNlZSB7QGxpbmsgVGFyZ2V0RW50aXR5Q29tcG9zaXRlfQotICogQHNlZSB7QGxpbmsgTWFueVRvTWFueUpvaW5pbmdTdHJhdGVneVBhbmV9Ci0gKiBAc2VlIHtAbGluayBGZXRjaFR5cGVDb21wb3NpdGV9Ci0gKiBAc2VlIHtAbGluayBDYXNjYWRlQ29tcG9zaXRlfQotICogQHNlZSB7QGxpbmsgT3JkZXJpbmdDb21wb3NpdGV9Ci0gKgotICogQHZlcnNpb24gMi4xCi0gKiBAc2luY2UgMi4xCi0gKi8KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua01hbnlUb01hbnlNYXBwaW5nQ29tcG9zaXRlIAotCWV4dGVuZHMgRm9ybVBhbmU8TWFueVRvTWFueU1hcHBpbmc+Ci0JaW1wbGVtZW50cyBKcGFDb21wb3NpdGUKLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPk1hbnlUb01hbnlNYXBwaW5nQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBzdWJqZWN0SG9sZGVyIFRoZSBob2xkZXIgb2YgdGhlIHN1YmplY3QgPGNvZGU+SU1hbnlUb01hbnlNYXBwaW5nPC9jb2RlPgotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKiBAcGFyYW0gd2lkZ2V0RmFjdG9yeSBUaGUgZmFjdG9yeSB1c2VkIHRvIGNyZWF0ZSB2YXJpb3VzIGNvbW1vbiB3aWRnZXRzCi0JICovCi0JcHVibGljIEVjbGlwc2VMaW5rTWFueVRvTWFueU1hcHBpbmdDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBNYW55VG9NYW55TWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJaW50IGdyb3VwQm94TWFyZ2luID0gZ2V0R3JvdXBCb3hNYXJnaW4oKTsKLQkJCi0JCW5ldyBUYXJnZXRFbnRpdHlDb21wb3NpdGUodGhpcywgYWRkUGFuZShjb250YWluZXIsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBNYW55VG9NYW55Sm9pbmluZ1N0cmF0ZWd5UGFuZSh0aGlzLCBidWlsZEpvaW5pbmdIb2xkZXIoKSwgY29udGFpbmVyKTsKLQkJbmV3IEZldGNoVHlwZUNvbXBvc2l0ZSh0aGlzLCBhZGRQYW5lKGNvbnRhaW5lciwgZ3JvdXBCb3hNYXJnaW4pKTsKLQkJbmV3IEpvaW5GZXRjaENvbXBvc2l0ZSh0aGlzLCBidWlsZEpvaW5GZXRjaGFibGVIb2xkZXIoKSwgYWRkUGFuZShjb250YWluZXIsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBDYXNjYWRlQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQ2FzY2FkZUhvbGRlcigpLCBhZGRTdWJQYW5lKGNvbnRhaW5lciwgNSkpOwotCQluZXcgT3JkZXJpbmdDb21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgQ29tcG9zaXRlIGFkZFBhbmUoQ29tcG9zaXRlIGNvbnRhaW5lciwgaW50IGdyb3VwQm94TWFyZ2luKSB7Ci0JCXJldHVybiBhZGRTdWJQYW5lKGNvbnRhaW5lciwgMCwgZ3JvdXBCb3hNYXJnaW4sIDAsIGdyb3VwQm94TWFyZ2luKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPE1hbnlUb01hbnlSZWxhdGlvbnNoaXBSZWZlcmVuY2U+IGJ1aWxkSm9pbmluZ0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxNYW55VG9NYW55TWFwcGluZywgTWFueVRvTWFueVJlbGF0aW9uc2hpcFJlZmVyZW5jZT4oCi0JCQkJZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBNYW55VG9NYW55UmVsYXRpb25zaGlwUmVmZXJlbmNlIHRyYW5zZm9ybV8oTWFueVRvTWFueU1hcHBpbmcgdmFsdWUpIHsKLQkJCQlyZXR1cm4gdmFsdWUuZ2V0UmVsYXRpb25zaGlwUmVmZXJlbmNlKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8Q2FzY2FkZT4gYnVpbGRDYXNjYWRlSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPE1hbnlUb01hbnlNYXBwaW5nLCBDYXNjYWRlPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENhc2NhZGUgdHJhbnNmb3JtXyhNYW55VG9NYW55TWFwcGluZyB2YWx1ZSkgewotCQkJCXJldHVybiB2YWx1ZS5nZXRDYXNjYWRlKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxKb2luRmV0Y2g+IGJ1aWxkSm9pbkZldGNoYWJsZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8TWFueVRvTWFueU1hcHBpbmcsIEpvaW5GZXRjaD4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBKb2luRmV0Y2ggYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuICgoRWNsaXBzZUxpbmtSZWxhdGlvbnNoaXBNYXBwaW5nKSB0aGlzLnN1YmplY3QpLmdldEpvaW5GZXRjaCgpOwotCQkJfQotCQl9OwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0VjbGlwc2VMaW5rTWFueVRvT25lTWFwcGluZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua01hbnlUb09uZU1hcHBpbmdDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzc2MzFlOC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0VjbGlwc2VMaW5rTWFueVRvT25lTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTMyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuQ2FzY2FkZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0Lk1hbnlUb09uZU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5NYW55VG9PbmVSZWxhdGlvbnNoaXBSZWZlcmVuY2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5FY2xpcHNlTGlua1JlbGF0aW9uc2hpcE1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5Kb2luRmV0Y2g7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkNhc2NhZGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRmV0Y2hUeXBlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLk1hbnlUb09uZUpvaW5pbmdTdHJhdGVneVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuT3B0aW9uYWxDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuVGFyZ2V0RW50aXR5Q29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIEhlcmUgdGhlIGxheW91dCBvZiB0aGlzIHBhbmU6Ci0gKiA8cHJlPgotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IFRhcmdldEVudGl0eUNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgSm9pbmluZ1N0cmF0ZWd5Q29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBGZXRjaFR5cGVDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IE9wdGlvbmFsQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgQ2FzY2FkZUNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLTwvcHJlPgotICoKLSAqIEBzZWUge0BsaW5rIE1hbnlUb09uZU1hcHBpbmd9Ci0gKiBAc2VlIHtAbGluayBCYXNlSnBhVWlGYWN0b3J5fSAtIFRoZSBmYWN0b3J5IGNyZWF0aW5nIHRoaXMgcGFuZQotICogQHNlZSB7QGxpbmsgVGFyZ2V0RW50aXR5Q29tcG9zaXRlfQotICogQHNlZSB7QGxpbmsgTWFueVRvT25lSm9pbmluZ1N0cmF0ZWd5UGFuZX0KLSAqIEBzZWUge0BsaW5rIEZldGNoVHlwZUNvbXBvc2l0ZX0KLSAqIEBzZWUge0BsaW5rIE9wdGlvbmFsQ29tcG9zaXRlfQotICogQHNlZSB7QGxpbmsgQ2FzY2FkZUNvbXBvc2l0ZX0KLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rTWFueVRvT25lTWFwcGluZ0NvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPE1hbnlUb09uZU1hcHBpbmc+Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbXBsZW1lbnRzIEpwYUNvbXBvc2l0ZQotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+RWNsaXBzZUxpbmtNYW55VG9PbmVNYXBwaW5nQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBzdWJqZWN0SG9sZGVyIFRoZSBob2xkZXIgb2YgdGhlIHN1YmplY3QgPGNvZGU+TWFueVRvT25lTWFwcGluZzwvY29kZT4KLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICogQHBhcmFtIHdpZGdldEZhY3RvcnkgVGhlIGZhY3RvcnkgdXNlZCB0byBjcmVhdGUgdmFyaW91cyBjb21tb24gd2lkZ2V0cwotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGlua01hbnlUb09uZU1hcHBpbmdDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBNYW55VG9PbmVNYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJaW50IGdyb3VwQm94TWFyZ2luID0gZ2V0R3JvdXBCb3hNYXJnaW4oKTsKLQkJCi0JCW5ldyBUYXJnZXRFbnRpdHlDb21wb3NpdGUodGhpcywgYWRkUGFuZShjb250YWluZXIsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBNYW55VG9PbmVKb2luaW5nU3RyYXRlZ3lQYW5lKHRoaXMsIGJ1aWxkSm9pbmluZ0hvbGRlcigpLCBjb250YWluZXIpOwotCQluZXcgRmV0Y2hUeXBlQ29tcG9zaXRlKHRoaXMsIGFkZFBhbmUoY29udGFpbmVyLCBncm91cEJveE1hcmdpbikpOwotCQluZXcgSm9pbkZldGNoQ29tcG9zaXRlKHRoaXMsIGJ1aWxkSm9pbkZldGNoYWJsZUhvbGRlcigpLCBhZGRQYW5lKGNvbnRhaW5lciwgZ3JvdXBCb3hNYXJnaW4pKTsKLQkJbmV3IE9wdGlvbmFsQ29tcG9zaXRlKHRoaXMsIGFkZFBhbmUoY29udGFpbmVyLCBncm91cEJveE1hcmdpbikpOwotCQluZXcgQ2FzY2FkZUNvbXBvc2l0ZSh0aGlzLCBidWlsZENhc2NhZGVIb2xkZXIoKSwgYWRkU3ViUGFuZShjb250YWluZXIsIDUpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgQ29tcG9zaXRlIGFkZFBhbmUoQ29tcG9zaXRlIGNvbnRhaW5lciwgaW50IGdyb3VwQm94TWFyZ2luKSB7Ci0JCXJldHVybiBhZGRTdWJQYW5lKGNvbnRhaW5lciwgMCwgZ3JvdXBCb3hNYXJnaW4sIDAsIGdyb3VwQm94TWFyZ2luKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxNYW55VG9PbmVSZWxhdGlvbnNoaXBSZWZlcmVuY2U+IGJ1aWxkSm9pbmluZ0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxNYW55VG9PbmVNYXBwaW5nLCBNYW55VG9PbmVSZWxhdGlvbnNoaXBSZWZlcmVuY2U+KAotCQkJCWdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgTWFueVRvT25lUmVsYXRpb25zaGlwUmVmZXJlbmNlIHRyYW5zZm9ybV8oTWFueVRvT25lTWFwcGluZyB2YWx1ZSkgewotCQkJCXJldHVybiB2YWx1ZS5nZXRSZWxhdGlvbnNoaXBSZWZlcmVuY2UoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxKb2luRmV0Y2g+IGJ1aWxkSm9pbkZldGNoYWJsZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8TWFueVRvT25lTWFwcGluZywgSm9pbkZldGNoPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEpvaW5GZXRjaCBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gKChFY2xpcHNlTGlua1JlbGF0aW9uc2hpcE1hcHBpbmcpIHRoaXMuc3ViamVjdCkuZ2V0Sm9pbkZldGNoKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxDYXNjYWRlPiBidWlsZENhc2NhZGVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8TWFueVRvT25lTWFwcGluZywgQ2FzY2FkZT4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDYXNjYWRlIHRyYW5zZm9ybV8oTWFueVRvT25lTWFwcGluZyB2YWx1ZSkgewotCQkJCXJldHVybiB2YWx1ZS5nZXRDYXNjYWRlKCk7Ci0JCQl9Ci0JCX07Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua01hcHBlZFN1cGVyY2xhc3NBZHZhbmNlZENvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua01hcHBlZFN1cGVyY2xhc3NBZHZhbmNlZENvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDdiOGYwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvRWNsaXBzZUxpbmtNYXBwZWRTdXBlcmNsYXNzQWR2YW5jZWRDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDcwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuTWFwcGVkU3VwZXJjbGFzczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkNoYW5nZVRyYWNraW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQ3VzdG9taXplcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkVjbGlwc2VMaW5rTWFwcGVkU3VwZXJjbGFzczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LlJlYWRPbmx5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rTWFwcGVkU3VwZXJjbGFzc0FkdmFuY2VkQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8TWFwcGVkU3VwZXJjbGFzcz4gewotCQotCXB1YmxpYyBFY2xpcHNlTGlua01hcHBlZFN1cGVyY2xhc3NBZHZhbmNlZENvbXBvc2l0ZSgKLQkJCUZvcm1QYW5lPD8gZXh0ZW5kcyBNYXBwZWRTdXBlcmNsYXNzPiBwYXJlbnRQYW5lLAotCQkJQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudFBhbmUsIHBhcmVudCwgZmFsc2UpOwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJY29udGFpbmVyID0gYWRkQ29sbGFwc2FibGVTZWN0aW9uKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRWNsaXBzZUxpbmtUeXBlTWFwcGluZ0NvbXBvc2l0ZV9hZHZhbmNlZAotCQkpOwotCQkKLQkJbmV3IFJlYWRPbmx5Q29tcG9zaXRlKHRoaXMsIGJ1aWxkUmVhZE9ubHlIb2xkZXIoKSwgY29udGFpbmVyKTsKLQkJbmV3IEN1c3RvbWl6ZXJDb21wb3NpdGUodGhpcywgYnVpbGRDdXN0b21pemVySG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JCW5ldyBDaGFuZ2VUcmFja2luZ0NvbXBvc2l0ZSh0aGlzLCBidWlsZENoYW5nZVRyYWNraW5nSG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFJlYWRPbmx5PiBidWlsZFJlYWRPbmx5SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxNYXBwZWRTdXBlcmNsYXNzLCBSZWFkT25seT4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBSZWFkT25seSBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gKChFY2xpcHNlTGlua01hcHBlZFN1cGVyY2xhc3MpIHRoaXMuc3ViamVjdCkuZ2V0UmVhZE9ubHkoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8Q3VzdG9taXplcj4gYnVpbGRDdXN0b21pemVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxNYXBwZWRTdXBlcmNsYXNzLCBDdXN0b21pemVyPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEN1c3RvbWl6ZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuICgoRWNsaXBzZUxpbmtNYXBwZWRTdXBlcmNsYXNzKSB0aGlzLnN1YmplY3QpLmdldEN1c3RvbWl6ZXIoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8Q2hhbmdlVHJhY2tpbmc+IGJ1aWxkQ2hhbmdlVHJhY2tpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPE1hcHBlZFN1cGVyY2xhc3MsIENoYW5nZVRyYWNraW5nPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENoYW5nZVRyYWNraW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiAoKEVjbGlwc2VMaW5rTWFwcGVkU3VwZXJjbGFzcykgdGhpcy5zdWJqZWN0KS5nZXRDaGFuZ2VUcmFja2luZygpOwotCQkJfQotCQl9OwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvRWNsaXBzZUxpbmtPbmVUb01hbnlKb2luaW5nU3RyYXRlZ3lQYW5lLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0VjbGlwc2VMaW5rT25lVG9NYW55Sm9pbmluZ1N0cmF0ZWd5UGFuZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjMjY4OWNkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvRWNsaXBzZUxpbmtPbmVUb01hbnlKb2luaW5nU3RyYXRlZ3lQYW5lLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0OCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogIENvcHlyaWdodCAoYykgMjAwOSAgT3JhY2xlLiAKLSAqICBBbGwgcmlnaHRzIHJlc2VydmVkLiAgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgCi0gKiAgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggCi0gKiAgYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgCi0gKiAgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSAqICAKLSAqICBDb250cmlidXRvcnM6IAotICogIAlPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuRWNsaXBzZUxpbmtPbmVUb01hbnlSZWxhdGlvbnNoaXBSZWZlcmVuY2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLkpwdFVpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5Kb2luQ29sdW1uSm9pbmluZ1N0cmF0ZWd5UGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5Kb2luVGFibGVKb2luaW5nU3RyYXRlZ3lQYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLk1hcHBlZEJ5Sm9pbmluZ1N0cmF0ZWd5UGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkdyb3VwOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtPbmVUb01hbnlKb2luaW5nU3RyYXRlZ3lQYW5lIAotCWV4dGVuZHMgRm9ybVBhbmU8RWNsaXBzZUxpbmtPbmVUb01hbnlSZWxhdGlvbnNoaXBSZWZlcmVuY2U+Ci17Ci0JcHVibGljIEVjbGlwc2VMaW5rT25lVG9NYW55Sm9pbmluZ1N0cmF0ZWd5UGFuZSgKLQkJCUZvcm1QYW5lPD8+IHBhcmVudFBhbmUsIAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rT25lVG9NYW55UmVsYXRpb25zaGlwUmVmZXJlbmNlPiBzdWJqZWN0SG9sZGVyLCAKLQkJCUNvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJc3VwZXIocGFyZW50UGFuZSwgc3ViamVjdEhvbGRlciwgcGFyZW50KTsKLQl9Ci0JCi0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCS8vIGpvaW5pbmcgc3RyYXRlZ3kgZ3JvdXAgcGFuZQotCQlHcm91cCBncm91cFBhbmUgPSBhZGRUaXRsZWRHcm91cCgKLQkJCWNvbnRhaW5lciwKLQkJCUpwdFVpTWFwcGluZ3NNZXNzYWdlcy5Kb2luaW5nX3RpdGxlCi0JCSk7Ci0JCQotCQluZXcgTWFwcGVkQnlKb2luaW5nU3RyYXRlZ3lQYW5lKHRoaXMsIGdyb3VwUGFuZSk7Ci0JCQotCQluZXcgSm9pbkNvbHVtbkpvaW5pbmdTdHJhdGVneVBhbmUodGhpcywgZ3JvdXBQYW5lKTsKLQkJCi0JCW5ldyBKb2luVGFibGVKb2luaW5nU3RyYXRlZ3lQYW5lKHRoaXMsIGdyb3VwUGFuZSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua09uZVRvTWFueU1hcHBpbmdDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvRWNsaXBzZUxpbmtPbmVUb01hbnlNYXBwaW5nQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVhZmMwZDAuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua09uZVRvTWFueU1hcHBpbmdDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE0OCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkNhc2NhZGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5PbmVUb01hbnlNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuRWNsaXBzZUxpbmtPbmVUb01hbnlNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuRWNsaXBzZUxpbmtPbmVUb01hbnlSZWxhdGlvbnNoaXBSZWZlcmVuY2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5Kb2luRmV0Y2g7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5Qcml2YXRlT3duZWQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkNhc2NhZGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRmV0Y2hUeXBlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLk9yZGVyaW5nQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLlRhcmdldEVudGl0eUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBIZXJlIHRoZSBsYXlvdXQgb2YgdGhpcyBwYW5lOgotICogPHByZT4KLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBUYXJnZXRFbnRpdHlDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IEZldGNoVHlwZUNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgTWFwcGVkQnlQYW5lICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgT3B0aW9uYWxDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBDYXNjYWRlQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IEpvaW5Db2x1bW5Db21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS08L3ByZT4KLSAqCi0gKiBAc2VlIE9uZVRvT25lTWFwcGluZwotICogQHNlZSBCYXNlSnBhVWlGYWN0b3J5IC0gVGhlIGZhY3RvcnkgY3JlYXRpbmcgdGhpcyBwYW5lCi0gKiBAc2VlIENhc2NhZGVDb21wb3NpdGUKLSAqIEBzZWUgRmV0Y2hUeXBlQ29tcG9zaXRlCi0gKiBAc2VlIEpvaW5Db2x1bW5Db21wb3NpdGUKLSAqIEBzZWUgTWFwcGVkQnlQYW5lCi0gKiBAc2VlIE9wdGlvbmFsQ29tcG9zaXRlCi0gKiBAc2VlIFRhcmdldEVudGl0eUNvbXBvc2l0ZQotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtPbmVUb01hbnlNYXBwaW5nQ29tcG9zaXRlIAotCWV4dGVuZHMgRm9ybVBhbmU8RWNsaXBzZUxpbmtPbmVUb01hbnlNYXBwaW5nPgotICAgIGltcGxlbWVudHMgSnBhQ29tcG9zaXRlCi17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5FY2xpcHNlbGlua09uZVRvTWFueU1hcHBpbmdDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHN1YmplY3RIb2xkZXIgVGhlIGhvbGRlciBvZiB0aGUgc3ViamVjdCA8Y29kZT5JT25lVG9NYW55TWFwcGluZzwvY29kZT4KLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICogQHBhcmFtIHdpZGdldEZhY3RvcnkgVGhlIGZhY3RvcnkgdXNlZCB0byBjcmVhdGUgdmFyaW91cyBjb21tb24gd2lkZ2V0cwotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGlua09uZVRvTWFueU1hcHBpbmdDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBFY2xpcHNlTGlua09uZVRvTWFueU1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlpbnQgZ3JvdXBCb3hNYXJnaW4gPSBnZXRHcm91cEJveE1hcmdpbigpOwotCQkKLQkJbmV3IFRhcmdldEVudGl0eUNvbXBvc2l0ZSh0aGlzLCBhZGRQYW5lKGNvbnRhaW5lciwgZ3JvdXBCb3hNYXJnaW4pKTsKLQkJbmV3IEVjbGlwc2VMaW5rT25lVG9NYW55Sm9pbmluZ1N0cmF0ZWd5UGFuZSh0aGlzLCBidWlsZEpvaW5pbmdIb2xkZXIoKSwgY29udGFpbmVyKTsKLQkJbmV3IEZldGNoVHlwZUNvbXBvc2l0ZSh0aGlzLCBhZGRQYW5lKGNvbnRhaW5lciwgZ3JvdXBCb3hNYXJnaW4pKTsKLQkJbmV3IEpvaW5GZXRjaENvbXBvc2l0ZSh0aGlzLCBidWlsZEpvaW5GZXRjaGFibGVIb2xkZXIoKSwgYWRkUGFuZShjb250YWluZXIsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBQcml2YXRlT3duZWRDb21wb3NpdGUodGhpcywgYnVpbGRQcml2YXRlT3duYWJsZUhvbGRlcigpLCBhZGRQYW5lKGNvbnRhaW5lciwgZ3JvdXBCb3hNYXJnaW4pKTsKLQkJbmV3IENhc2NhZGVDb21wb3NpdGUodGhpcywgYnVpbGRDYXNjYWRlSG9sZGVyKCksIGFkZFN1YlBhbmUoY29udGFpbmVyLCA1KSk7Ci0JCW5ldyBPcmRlcmluZ0NvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCX0KLQkKLQlwcm90ZWN0ZWQgQ29tcG9zaXRlIGFkZFBhbmUoQ29tcG9zaXRlIGNvbnRhaW5lciwgaW50IGdyb3VwQm94TWFyZ2luKSB7Ci0JCXJldHVybiBhZGRTdWJQYW5lKGNvbnRhaW5lciwgMCwgZ3JvdXBCb3hNYXJnaW4sIDAsIGdyb3VwQm94TWFyZ2luKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rT25lVG9NYW55UmVsYXRpb25zaGlwUmVmZXJlbmNlPiBidWlsZEpvaW5pbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtPbmVUb01hbnlNYXBwaW5nLCBFY2xpcHNlTGlua09uZVRvTWFueVJlbGF0aW9uc2hpcFJlZmVyZW5jZT4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBFY2xpcHNlTGlua09uZVRvTWFueVJlbGF0aW9uc2hpcFJlZmVyZW5jZSB0cmFuc2Zvcm1fKEVjbGlwc2VMaW5rT25lVG9NYW55TWFwcGluZyB2YWx1ZSkgewotCQkJCXJldHVybiB2YWx1ZS5nZXRSZWxhdGlvbnNoaXBSZWZlcmVuY2UoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxQcml2YXRlT3duZWQ+IGJ1aWxkUHJpdmF0ZU93bmFibGVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPE9uZVRvTWFueU1hcHBpbmcsIFByaXZhdGVPd25lZD4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBQcml2YXRlT3duZWQgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuICgoRWNsaXBzZUxpbmtPbmVUb01hbnlNYXBwaW5nKSB0aGlzLnN1YmplY3QpLmdldFByaXZhdGVPd25lZCgpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPEpvaW5GZXRjaD4gYnVpbGRKb2luRmV0Y2hhYmxlSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxPbmVUb01hbnlNYXBwaW5nLCBKb2luRmV0Y2g+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSm9pbkZldGNoIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiAoKEVjbGlwc2VMaW5rT25lVG9NYW55TWFwcGluZykgdGhpcy5zdWJqZWN0KS5nZXRKb2luRmV0Y2goKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPENhc2NhZGU+IGJ1aWxkQ2FzY2FkZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxPbmVUb01hbnlNYXBwaW5nLCBDYXNjYWRlPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENhc2NhZGUgdHJhbnNmb3JtXyhPbmVUb01hbnlNYXBwaW5nIHZhbHVlKSB7Ci0JCQkJcmV0dXJuIHZhbHVlLmdldENhc2NhZGUoKTsKLQkJCX0KLQkJfTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua09uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua09uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1MmE0NzU3Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvRWNsaXBzZUxpbmtPbmVUb09uZU1hcHBpbmdDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEwMyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkNhc2NhZGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5PbmVUb09uZU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5PbmVUb09uZVJlbGF0aW9uc2hpcFJlZmVyZW5jZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkVjbGlwc2VMaW5rT25lVG9PbmVNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuSm9pbkZldGNoOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuUHJpdmF0ZU93bmVkOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5DYXNjYWRlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkZldGNoVHlwZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5PbmVUb09uZUpvaW5pbmdTdHJhdGVneVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuT3B0aW9uYWxDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuVGFyZ2V0RW50aXR5Q29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua09uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPE9uZVRvT25lTWFwcGluZz4KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW1wbGVtZW50cyBKcGFDb21wb3NpdGUKLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkVjbGlwc2VsaW5rT25lVG9PbmVNYXBwaW5nQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBzdWJqZWN0SG9sZGVyIFRoZSBob2xkZXIgb2YgdGhlIHN1YmplY3QgPGNvZGU+SU9uZVRvT25lTWFwcGluZzwvY29kZT4KLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICogQHBhcmFtIHdpZGdldEZhY3RvcnkgVGhlIGZhY3RvcnkgdXNlZCB0byBjcmVhdGUgdmFyaW91cyBjb21tb24gd2lkZ2V0cwotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGlua09uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZShQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIE9uZVRvT25lTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlpbnQgZ3JvdXBCb3hNYXJnaW4gPSBnZXRHcm91cEJveE1hcmdpbigpOwotCi0JCW5ldyBUYXJnZXRFbnRpdHlDb21wb3NpdGUodGhpcywgYWRkUGFuZShjb250YWluZXIsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBPbmVUb09uZUpvaW5pbmdTdHJhdGVneVBhbmUodGhpcywgYnVpbGRKb2luaW5nSG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JCW5ldyBGZXRjaFR5cGVDb21wb3NpdGUodGhpcywgYWRkUGFuZShjb250YWluZXIsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBKb2luRmV0Y2hDb21wb3NpdGUodGhpcywgYnVpbGRKb2luRmV0Y2hhYmxlSG9sZGVyKCksIGFkZFBhbmUoY29udGFpbmVyLCBncm91cEJveE1hcmdpbikpOwotCQluZXcgT3B0aW9uYWxDb21wb3NpdGUodGhpcywgYWRkUGFuZShjb250YWluZXIsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBQcml2YXRlT3duZWRDb21wb3NpdGUodGhpcywgYnVpbGRQcml2YXRlT3duYWJsZUhvbGRlcigpLCBhZGRQYW5lKGNvbnRhaW5lciwgZ3JvdXBCb3hNYXJnaW4pKTsKLQkJbmV3IENhc2NhZGVDb21wb3NpdGUodGhpcywgYnVpbGRDYXNjYWRlSG9sZGVyKCksIGFkZFN1YlBhbmUoY29udGFpbmVyLCA1KSk7Ci0JfQotCQotCXByb3RlY3RlZCBDb21wb3NpdGUgYWRkUGFuZShDb21wb3NpdGUgY29udGFpbmVyLCBpbnQgZ3JvdXBCb3hNYXJnaW4pIHsKLQkJcmV0dXJuIGFkZFN1YlBhbmUoY29udGFpbmVyLCAwLCBncm91cEJveE1hcmdpbiwgMCwgZ3JvdXBCb3hNYXJnaW4pOwotCX0KLQkKLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPE9uZVRvT25lUmVsYXRpb25zaGlwUmVmZXJlbmNlPiBidWlsZEpvaW5pbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8T25lVG9PbmVNYXBwaW5nLCBPbmVUb09uZVJlbGF0aW9uc2hpcFJlZmVyZW5jZT4oCi0JCQkJZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBPbmVUb09uZVJlbGF0aW9uc2hpcFJlZmVyZW5jZSB0cmFuc2Zvcm1fKE9uZVRvT25lTWFwcGluZyB2YWx1ZSkgewotCQkJCXJldHVybiB2YWx1ZS5nZXRSZWxhdGlvbnNoaXBSZWZlcmVuY2UoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxKb2luRmV0Y2g+IGJ1aWxkSm9pbkZldGNoYWJsZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8T25lVG9PbmVNYXBwaW5nLCBKb2luRmV0Y2g+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSm9pbkZldGNoIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiAoKEVjbGlwc2VMaW5rT25lVG9PbmVNYXBwaW5nKSB0aGlzLnN1YmplY3QpLmdldEpvaW5GZXRjaCgpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPFByaXZhdGVPd25lZD4gYnVpbGRQcml2YXRlT3duYWJsZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8T25lVG9PbmVNYXBwaW5nLCBQcml2YXRlT3duZWQ+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgUHJpdmF0ZU93bmVkIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiAoKEVjbGlwc2VMaW5rT25lVG9PbmVNYXBwaW5nKSB0aGlzLnN1YmplY3QpLmdldFByaXZhdGVPd25lZCgpOwotCQkJfQotCQl9OwotCX0KLQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8Q2FzY2FkZT4gYnVpbGRDYXNjYWRlSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPE9uZVRvT25lTWFwcGluZywgQ2FzY2FkZT4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ2FzY2FkZSB0cmFuc2Zvcm1fKE9uZVRvT25lTWFwcGluZyB2YWx1ZSkgewotCQkJCXJldHVybiB2YWx1ZS5nZXRDYXNjYWRlKCk7Ci0JCQl9Ci0JCX07Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvRWNsaXBzZUxpbmtUcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0VjbGlwc2VMaW5rVHJhbnNmb3JtYXRpb25NYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwZDc2OGRhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvRWNsaXBzZUxpbmtUcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0MyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5FY2xpcHNlTGlua01hcHBpbmdLZXlzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuVHJhbnNmb3JtYXRpb25NYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnB0VWlQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLkpwdFVpSWNvbnM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLkltYWdlOwotCi1wdWJsaWMgYWJzdHJhY3QgY2xhc3MgRWNsaXBzZUxpbmtUcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyPFQgZXh0ZW5kcyBUcmFuc2Zvcm1hdGlvbk1hcHBpbmc+Ci0JaW1wbGVtZW50cyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxUPgotewotCQotCXByb3RlY3RlZCBFY2xpcHNlTGlua1RyYW5zZm9ybWF0aW9uTWFwcGluZ1VpUHJvdmlkZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQotCXB1YmxpYyBJbWFnZSBnZXRJbWFnZSgpIHsKLQkJcmV0dXJuIEpwdFVpUGx1Z2luLmdldEltYWdlKEpwdFVpSWNvbnMuSlBBX0NPTlRFTlQpOwotCX0KLQkKLQlwdWJsaWMgU3RyaW5nIGdldExhYmVsKCkgewotCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuVHJhbnNmb3JtYXRpb25NYXBwaW5nVWlQcm92aWRlcl9sYWJlbDsKLQl9Ci0JCi0JcHVibGljIFN0cmluZyBnZXRMaW5rTGFiZWwoKSB7Ci0JCXJldHVybiBFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5UcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyX2xpbmtMYWJlbDsKLQl9Ci0JCi0JcHVibGljIFN0cmluZyBnZXRLZXkoKSB7Ci0JCXJldHVybiBFY2xpcHNlTGlua01hcHBpbmdLZXlzLlRSQU5TRk9STUFUSU9OX0FUVFJJQlVURV9NQVBQSU5HX0tFWTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0VjbGlwc2VMaW5rVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0VjbGlwc2VMaW5rVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDU4Y2UxOTYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua1ZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuRWNsaXBzZUxpbmtNYXBwaW5nS2V5czsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LlZhcmlhYmxlT25lVG9PbmVNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnB0VWlQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLkpwdFVpSWNvbnM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLkltYWdlOwotCi1wdWJsaWMgYWJzdHJhY3QgY2xhc3MgRWNsaXBzZUxpbmtWYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXI8VCBleHRlbmRzIFZhcmlhYmxlT25lVG9PbmVNYXBwaW5nPgotCWltcGxlbWVudHMgQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8VD4KLXsJCi0JcHJvdGVjdGVkIEVjbGlwc2VMaW5rVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkJCi0JcHVibGljIEltYWdlIGdldEltYWdlKCkgewotCQlyZXR1cm4gSnB0VWlQbHVnaW4uZ2V0SW1hZ2UoSnB0VWlJY29ucy5KUEFfQ09OVEVOVCk7Ci0JfQotCQotCXB1YmxpYyBTdHJpbmcgZ2V0TGFiZWwoKSB7Ci0JCXJldHVybiBFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5WYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXJfbGFiZWw7Ci0JfQotCQotCXB1YmxpYyBTdHJpbmcgZ2V0TGlua0xhYmVsKCkgewotCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyX2xpbmtMYWJlbDsKLQl9Ci0JCi0JcHVibGljIFN0cmluZyBnZXRLZXkoKSB7Ci0JCXJldHVybiBFY2xpcHNlTGlua01hcHBpbmdLZXlzLlZBUklBQkxFX09ORV9UT19PTkVfQVRUUklCVVRFX01BUFBJTkdfS0VZOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvRWNsaXBzZUxpbmtWZXJzaW9uTWFwcGluZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua1ZlcnNpb25NYXBwaW5nQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGIyM2JmZWYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FY2xpcHNlTGlua1ZlcnNpb25NYXBwaW5nQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyNDYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5Db2x1bW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5Db252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5Db252ZXJ0aWJsZU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5UZW1wb3JhbENvbnZlcnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LlZlcnNpb25NYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQ29udmVydDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkVjbGlwc2VMaW5rVmVyc2lvbk1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5NdXRhYmxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLkpwdFVpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5Db2x1bW5Db21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuVGVtcG9yYWxUeXBlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLlBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWREYXRhOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuR3JpZExheW91dDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5CdXR0b247Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIEhlcmUgdGhlIGxheW91dCBvZiB0aGlzIHBhbmU6Ci0gKiA8cHJlPgotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IENvbHVtbkNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgTXV0YWJsZUNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBUZW1wb3JhbFR5cGVDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSBWZXJzaW9uTWFwcGluZwotICogQHNlZSBCYXNlSnBhVWlGYWN0b3J5IC0gVGhlIGZhY3RvcnkgY3JlYXRpbmcgdGhpcyBwYW5lCi0gKiBAc2VlIENvbHVtbkNvbXBvc2l0ZQotICogQHNlZSBUZW1wb3JhbFR5cGVDb21wb3NpdGUKLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rVmVyc2lvbk1hcHBpbmdDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxWZXJzaW9uTWFwcGluZz4KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbXBsZW1lbnRzIEpwYUNvbXBvc2l0ZQotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+VmVyc2lvbk1hcHBpbmdDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHN1YmplY3RIb2xkZXIgVGhlIGhvbGRlciBvZiB0aGUgc3ViamVjdCA8Y29kZT5JVmVyc2lvbk1hcHBpbmc8L2NvZGU+Ci0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqIEBwYXJhbSB3aWRnZXRGYWN0b3J5IFRoZSBmYWN0b3J5IHVzZWQgdG8gY3JlYXRlIHZhcmlvdXMgY29tbW9uIHdpZGdldHMKLQkgKi8KLQlwdWJsaWMgRWNsaXBzZUxpbmtWZXJzaW9uTWFwcGluZ0NvbXBvc2l0ZShQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFZlcnNpb25NYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50LAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8Q29sdW1uPiBidWlsZENvbHVtbkhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxWZXJzaW9uTWFwcGluZywgQ29sdW1uPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENvbHVtbiB0cmFuc2Zvcm1fKFZlcnNpb25NYXBwaW5nIHZhbHVlKSB7Ci0JCQkJcmV0dXJuIHZhbHVlLmdldENvbHVtbigpOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlpbml0aWFsaXplR2VuZXJhbFBhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZVR5cGVQYW5lKGNvbnRhaW5lcik7Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVHZW5lcmFsUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCWludCBncm91cEJveE1hcmdpbiA9IGdldEdyb3VwQm94TWFyZ2luKCk7Ci0KLQkJLy8gQ29sdW1uIHdpZGdldHMKLQkJbmV3IENvbHVtbkNvbXBvc2l0ZSh0aGlzLCBidWlsZENvbHVtbkhvbGRlcigpLCBjb250YWluZXIpOwotCQkKLQkJLy8gQWxpZ24gdGhlIHdpZGdldHMgdW5kZXIgdGhlIENvbHVtbkNvbXBvc2l0ZQotCQljb250YWluZXIgPSBhZGRTdWJQYW5lKGNvbnRhaW5lciwgMCwgZ3JvdXBCb3hNYXJnaW4sIDAsIGdyb3VwQm94TWFyZ2luKTsKLQkJCi0JCS8vIE11dGFibGUgd2lkZ2V0cwotCQluZXcgTXV0YWJsZUNvbXBvc2l0ZSh0aGlzLCBidWlsZE11dGFibGVIb2xkZXIoKSwgY29udGFpbmVyKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZVR5cGVQYW5lKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQljb250YWluZXIgPSBhZGRDb2xsYXBzYWJsZVNlY3Rpb24oCi0JCQljb250YWluZXIsCi0JCQlKcHRVaU1hcHBpbmdzTWVzc2FnZXMuVHlwZVNlY3Rpb25fdHlwZQotCQkpOwotCQkoKEdyaWRMYXlvdXQpIGNvbnRhaW5lci5nZXRMYXlvdXQoKSkubnVtQ29sdW1ucyA9IDI7Ci0KLQkJLy8gTm8gY29udmVydGVyCi0JCUJ1dHRvbiBub0NvbnZlcnRlckJ1dHRvbiA9IGFkZFJhZGlvQnV0dG9uKAotCQkJY29udGFpbmVyLCAKLQkJCUpwdFVpTWFwcGluZ3NNZXNzYWdlcy5UeXBlU2VjdGlvbl9kZWZhdWx0LCAKLQkJCWJ1aWxkTm9Db252ZXJ0ZXJIb2xkZXIoKSwgCi0JCQludWxsKTsKLQkJKChHcmlkRGF0YSkgbm9Db252ZXJ0ZXJCdXR0b24uZ2V0TGF5b3V0RGF0YSgpKS5ob3Jpem9udGFsU3BhbiA9IDI7Ci0JCQkJCi0JCVByb3BlcnR5VmFsdWVNb2RlbDxDb252ZXJ0ZXI+IHNwZWNpZmllZENvbnZlcnRlckhvbGRlciA9IGJ1aWxkU3BlY2lmaWVkQ29udmVydGVySG9sZGVyKCk7Ci0JCS8vIFRlbXBvcmFsCi0JCWFkZFJhZGlvQnV0dG9uKAotCQkJY29udGFpbmVyLCAKLQkJCUpwdFVpTWFwcGluZ3NNZXNzYWdlcy5UeXBlU2VjdGlvbl90ZW1wb3JhbCwgCi0JCQlidWlsZFRlbXBvcmFsQm9vbGVhbkhvbGRlcigpLCAKLQkJCW51bGwpOwotCQlyZWdpc3RlclN1YlBhbmUobmV3IFRlbXBvcmFsVHlwZUNvbXBvc2l0ZShidWlsZFRlbXBvcmFsQ29udmVydGVySG9sZGVyKHNwZWNpZmllZENvbnZlcnRlckhvbGRlciksIGNvbnRhaW5lciwgZ2V0V2lkZ2V0RmFjdG9yeSgpKSk7Ci0KLQkJLy8gRWNsaXBzZUxpbmsgQ29udmVydGVyCi0JCUJ1dHRvbiBlbENvbnZlcnRlckJ1dHRvbiA9IGFkZFJhZGlvQnV0dG9uKAotCQkJY29udGFpbmVyLCAKLQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLlR5cGVTZWN0aW9uX2NvbnZlcnRlZCwgCi0JCQlidWlsZEVjbGlwc2VMaW5rQ29udmVydGVyQm9vbGVhbkhvbGRlcigpLCAKLQkJCW51bGwpOwotCQkoKEdyaWREYXRhKSBlbENvbnZlcnRlckJ1dHRvbi5nZXRMYXlvdXREYXRhKCkpLmhvcml6b250YWxTcGFuID0gMjsKLQotCQlQYW5lPENvbnZlcnQ+IGNvbnZlcnRDb21wb3NpdGUgPSBidWlsZENvbnZlcnRDb21wb3NpdGUoYnVpbGRFY2xpcHNlTGlua0NvbnZlcnRlckhvbGRlcihzcGVjaWZpZWRDb252ZXJ0ZXJIb2xkZXIpLCBjb250YWluZXIpOwotCQlHcmlkRGF0YSBncmlkRGF0YSA9IChHcmlkRGF0YSkgY29udmVydENvbXBvc2l0ZS5nZXRDb250cm9sKCkuZ2V0TGF5b3V0RGF0YSgpOwotCQlncmlkRGF0YS5ob3Jpem9udGFsU3BhbiA9IDI7Ci0JCWdyaWREYXRhLmhvcml6b250YWxJbmRlbnQgPSAyMDsKLQkJcmVnaXN0ZXJTdWJQYW5lKGNvbnZlcnRDb21wb3NpdGUpOwotCX0KLQkKLQlwcm90ZWN0ZWQgUGFuZTxDb252ZXJ0PiBidWlsZENvbnZlcnRDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnQ+IGNvbnZlcnRIb2xkZXIsIENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJcmV0dXJuIG5ldyBDb252ZXJ0Q29tcG9zaXRlKGNvbnZlcnRIb2xkZXIsIGNvbnRhaW5lciwgZ2V0V2lkZ2V0RmFjdG9yeSgpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGROb0NvbnZlcnRlckhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VmVyc2lvbk1hcHBpbmcsIEJvb2xlYW4+KGdldFN1YmplY3RIb2xkZXIoKSwgQ29udmVydGlibGVNYXBwaW5nLlNQRUNJRklFRF9DT05WRVJURVJfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIEJvb2xlYW4udmFsdWVPZih0aGlzLnN1YmplY3QuZ2V0U3BlY2lmaWVkQ29udmVydGVyKCkgPT0gbnVsbCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlpZiAodmFsdWUuYm9vbGVhblZhbHVlKCkpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LnNldFNwZWNpZmllZENvbnZlcnRlcihDb252ZXJ0ZXIuTk9fQ09OVkVSVEVSKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxDb252ZXJ0PiBidWlsZEVjbGlwc2VMaW5rQ29udmVydGVySG9sZGVyKFByb3BlcnR5VmFsdWVNb2RlbDxDb252ZXJ0ZXI+IGNvbnZlcnRlckhvbGRlcikgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnRlciwgQ29udmVydD4oY29udmVydGVySG9sZGVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDb252ZXJ0IHRyYW5zZm9ybV8oQ29udmVydGVyIGNvbnZlcnRlcikgewotCQkJCXJldHVybiAoY29udmVydGVyICE9IG51bGwgJiYgY29udmVydGVyLmdldFR5cGUoKSA9PSBDb252ZXJ0LkVDTElQU0VfTElOS19DT05WRVJURVIpID8gKENvbnZlcnQpIGNvbnZlcnRlciA6IG51bGw7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJvdGVjdGVkIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkVGVtcG9yYWxCb29sZWFuSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxWZXJzaW9uTWFwcGluZywgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb252ZXJ0aWJsZU1hcHBpbmcuU1BFQ0lGSUVEX0NPTlZFUlRFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlDb252ZXJ0ZXIgY29udmVydGVyID0gdGhpcy5zdWJqZWN0LmdldFNwZWNpZmllZENvbnZlcnRlcigpOwotCQkJCWlmIChjb252ZXJ0ZXIgPT0gbnVsbCkgewotCQkJCQlyZXR1cm4gQm9vbGVhbi5GQUxTRTsKLQkJCQl9Ci0JCQkJcmV0dXJuIEJvb2xlYW4udmFsdWVPZihjb252ZXJ0ZXIuZ2V0VHlwZSgpID09IENvbnZlcnRlci5URU1QT1JBTF9DT05WRVJURVIpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJaWYgKHZhbHVlLmJvb2xlYW5WYWx1ZSgpKSB7Ci0JCQkJCXRoaXMuc3ViamVjdC5zZXRTcGVjaWZpZWRDb252ZXJ0ZXIoQ29udmVydGVyLlRFTVBPUkFMX0NPTlZFUlRFUik7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQkKLQlwcm90ZWN0ZWQgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRFY2xpcHNlTGlua0NvbnZlcnRlckJvb2xlYW5Ib2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFZlcnNpb25NYXBwaW5nLCBCb29sZWFuPihnZXRTdWJqZWN0SG9sZGVyKCksIENvbnZlcnRpYmxlTWFwcGluZy5TUEVDSUZJRURfQ09OVkVSVEVSX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCUNvbnZlcnRlciBjb252ZXJ0ZXIgPSB0aGlzLnN1YmplY3QuZ2V0U3BlY2lmaWVkQ29udmVydGVyKCk7Ci0JCQkJaWYgKGNvbnZlcnRlciA9PSBudWxsKSB7Ci0JCQkJCXJldHVybiBCb29sZWFuLkZBTFNFOwotCQkJCX0KLQkJCQlyZXR1cm4gQm9vbGVhbi52YWx1ZU9mKGNvbnZlcnRlci5nZXRUeXBlKCkgPT0gQ29udmVydC5FQ0xJUFNFX0xJTktfQ09OVkVSVEVSKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZS5ib29sZWFuVmFsdWUoKSkgewotCQkJCQl0aGlzLnN1YmplY3Quc2V0U3BlY2lmaWVkQ29udmVydGVyKENvbnZlcnQuRUNMSVBTRV9MSU5LX0NPTlZFUlRFUik7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8Q29udmVydGVyPiBidWlsZFNwZWNpZmllZENvbnZlcnRlckhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VmVyc2lvbk1hcHBpbmcsIENvbnZlcnRlcj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb252ZXJ0aWJsZU1hcHBpbmcuU1BFQ0lGSUVEX0NPTlZFUlRFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ29udmVydGVyIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0U3BlY2lmaWVkQ29udmVydGVyKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8VGVtcG9yYWxDb252ZXJ0ZXI+IGJ1aWxkVGVtcG9yYWxDb252ZXJ0ZXJIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnRlcj4gY29udmVydGVySG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Q29udmVydGVyLCBUZW1wb3JhbENvbnZlcnRlcj4oY29udmVydGVySG9sZGVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBUZW1wb3JhbENvbnZlcnRlciB0cmFuc2Zvcm1fKENvbnZlcnRlciBjb252ZXJ0ZXIpIHsKLQkJCQlyZXR1cm4gKGNvbnZlcnRlciAhPSBudWxsICYmIGNvbnZlcnRlci5nZXRUeXBlKCkgPT0gQ29udmVydGVyLlRFTVBPUkFMX0NPTlZFUlRFUikgPyAoVGVtcG9yYWxDb252ZXJ0ZXIpIGNvbnZlcnRlciA6IG51bGw7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8TXV0YWJsZT4gYnVpbGRNdXRhYmxlSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxWZXJzaW9uTWFwcGluZywgTXV0YWJsZT4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBNdXRhYmxlIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiAoKEVjbGlwc2VMaW5rVmVyc2lvbk1hcHBpbmcpIHRoaXMuc3ViamVjdCkuZ2V0TXV0YWJsZSgpOwotCQkJfQotCQl9OwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0V4cGlyeUNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9FeHBpcnlDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzhmYzc1Mi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL0V4cGlyeUNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzAyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiAgQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcwotICogIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YKLSAqICB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMKLSAqICBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSAqCi0gKiAgQ29udHJpYnV0b3JzOiBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkNhY2hpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5FeHBpcnlUaW1lT2ZEYXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLkVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLkNvbnRyb2xFbmFibGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkRGF0YTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5CdXR0b247Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbnRyb2w7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuRGF0ZVRpbWU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuR3JvdXA7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuU3Bpbm5lcjsKLQotLyoqCi0gKiBIZXJlIGlzIHRoZSBsYXlvdXQgb2YgdGhpcyBwYW5lOgotICogPHByZT4KLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gKiB8IC0gRXhwaXJ5IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBvIE5vIGV4cGlyeSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAJCQkJCS0tLS0tLS0tLS0tLS0tLS0gICAgICAgICAgICAgICAgIHwgfAotICogfCB8IG8gVGltZSB0byBsaXZlIGV4cGlyeSAgIEV4cGlyZSBhZnRlciB8IEkgICAgICAgICAgfEl8IG1pbGxpc2Vjb25kcyAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLS0tLS0tLS0tLS0tLS0tLSAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAJCQkJICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tICAgICAgICAgICAgIHwgfAotICogfCB8IG8gRGFpbHkgZXhwaXJ5ICAgICAgICAgIEV4cGlyZSBhdCAgICB8IEhIOk1NOlNTOkFNL1BNIHxJfCAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0gICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS08L3ByZT4KLSAqCi0gKiBAc2VlIEVjbGlwc2VMaW5rQ2FjaGluZwotICogQHNlZSBFY2xpcHNlTGlua0V4cGlyeVRpbWVPZkRheQotICogQHNlZSBDYWNoaW5nQ29tcG9zaXRlIC0gQSBjb250YWluZXIgb2YgdGhpcyB3aWRnZXQKLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIEV4cGlyeUNvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPENhY2hpbmc+IHsKLQotCXB1YmxpYyBFeHBpcnlDb21wb3NpdGUoRm9ybVBhbmU8PyBleHRlbmRzIENhY2hpbmc+IHBhcmVudFBhbmUsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50UGFuZSwgcGFyZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJLy8gRXhwaXJ5IGdyb3VwIHBhbmUKLQkJR3JvdXAgZXhwaXJ5R3JvdXBQYW5lID0gYWRkVGl0bGVkR3JvdXAoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5FeHBpcnlDb21wb3NpdGVfZXhwaXJ5U2VjdGlvbiwKLQkJCTIsCi0JCQludWxsCi0JCSk7Ci0JCQkJCi0JCS8vIE5vIEV4cGlyeSByYWRpbyBidXR0b24KLQkJQnV0dG9uIGJ1dHRvbiA9IGFkZFJhZGlvQnV0dG9uKAotCQkJZXhwaXJ5R3JvdXBQYW5lLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRXhwaXJ5Q29tcG9zaXRlX25vRXhwaXJ5LAotCQkJYnVpbGROb0V4cGlyeUhvbGRlcigpLAotCQkJbnVsbAotCQkpOwotCQlHcmlkRGF0YSBncmlkRGF0YSA9IG5ldyBHcmlkRGF0YSgpOwotCQlncmlkRGF0YS5ob3Jpem9udGFsU3BhbiA9IDI7Ci0JCWJ1dHRvbi5zZXRMYXlvdXREYXRhKGdyaWREYXRhKTsKLQotCQkKLQkJLy8gVGltZSBUbyBMaXZlIEV4cGlyeSByYWRpbyBidXR0b24KLQkJYWRkUmFkaW9CdXR0b24oCi0JCQlleHBpcnlHcm91cFBhbmUsCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5FeHBpcnlDb21wb3NpdGVfdGltZVRvTGl2ZUV4cGlyeSwKLQkJCWJ1aWxkRXhwaXJ5SG9sZGVyKCksCi0JCQludWxsCi0JCSk7Ci0JCQotCQlhZGRUaW1lVG9MaXZlQ29tcG9zaXRlKGV4cGlyeUdyb3VwUGFuZSk7Ci0JCQotCQkvLyBEYWlseSBFeHBpcnkgcmFkaW8gYnV0dG9uCi0JCWFkZFJhZGlvQnV0dG9uKAotCQkJZXhwaXJ5R3JvdXBQYW5lLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRXhwaXJ5Q29tcG9zaXRlX2RhaWx5RXhwaXJ5LAotCQkJYnVpbGRUaW1lT2ZEYXlFeHBpcnlCb29sZWFuSG9sZGVyKCksCi0JCQludWxsCi0JCSk7Ci0JCQotCQlhZGRUaW1lT2ZEYXlDb21wb3NpdGUoZXhwaXJ5R3JvdXBQYW5lKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIHZvaWQgYWRkVGltZVRvTGl2ZUNvbXBvc2l0ZShDb21wb3NpdGUgcGFyZW50KSB7Ci0JCUNvbXBvc2l0ZSBjb250YWluZXIgPSB0aGlzLmFkZFN1YlBhbmUocGFyZW50LCAzLCAwLCAxMCwgMCwgMCk7Ci0KLQotCQlDb250cm9sIGV4cGlyZUFmdGVyTGFiZWwgPSBhZGRVbm1hbmFnZWRMYWJlbCgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkV4cGlyeUNvbXBvc2l0ZV90aW1lVG9MaXZlRXhwaXJ5RXhwaXJlQWZ0ZXIKLQkJKTsKLQkKLQkJU3Bpbm5lciBleHBpcnlTcGlubmVyID0gYWRkVW5tYW5hZ2VkU3Bpbm5lcigKLQkJCWNvbnRhaW5lciwKLQkJCWJ1aWxkVGltZVRvTGl2ZUV4cGlyeUhvbGRlcigpLAotCQkJLTEsCi0JCQktMSwKLQkJCUludGVnZXIuTUFYX1ZBTFVFLAotCQkJbnVsbAotCQkpOwotCQkvL2EgYm9yZGVyIENvbnRhaW5lciBpcyBjcmVhdGVkIGluIEZvcm1XaWRnZXRGYWN0b3J5LmNyZWF0ZVNwaW5uZXIKLQkJaWYgKGV4cGlyeVNwaW5uZXIuZ2V0UGFyZW50KCkgIT0gY29udGFpbmVyKSB7Ci0JCQkoKEdyaWREYXRhKSBleHBpcnlTcGlubmVyLmdldFBhcmVudCgpLmdldExheW91dERhdGEoKSkuZ3JhYkV4Y2Vzc0hvcml6b250YWxTcGFjZSA9IGZhbHNlOwotCQl9Ci0JCWVsc2UgewotCQkJKChHcmlkRGF0YSkgZXhwaXJ5U3Bpbm5lci5nZXRMYXlvdXREYXRhKCkpLmdyYWJFeGNlc3NIb3Jpem9udGFsU3BhY2UgPSBmYWxzZTsKLQkJfQotCQkKLQkJQ29udHJvbCBtaWxsaXNlY29uZHNMYWJlbCA9CWFkZFVubWFuYWdlZExhYmVsKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRXhwaXJ5Q29tcG9zaXRlX3RpbWVUb0xpdmVFeHBpcnlNaWxsaXNlY29uZHMKLQkJKTsKLQkJCi0JCW5ldyBDb250cm9sRW5hYmxlcihidWlsZFRpbWVUb0xpdmVFeHBpcnlFbmFibGVyKCksIGV4cGlyZUFmdGVyTGFiZWwsIGV4cGlyeVNwaW5uZXIsIG1pbGxpc2Vjb25kc0xhYmVsKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIHZvaWQgYWRkVGltZU9mRGF5Q29tcG9zaXRlKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJQ29tcG9zaXRlIGNvbnRhaW5lciA9IHRoaXMuYWRkU3ViUGFuZShwYXJlbnQsIDIsIDAsIDEwLCAwLCAwKTsKLQotCi0JCUNvbnRyb2wgZXhwaXJlQXRMYWJlbCA9IGFkZFVubWFuYWdlZExhYmVsKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRXhwaXJ5Q29tcG9zaXRlX3RpbWVPZkRheUV4cGlyeUV4cGlyZUF0Ci0JCSk7Ci0JCQotCQlQcm9wZXJ0eVZhbHVlTW9kZWw8RXhwaXJ5VGltZU9mRGF5PiB0aW1lT2ZEYXlFeHBpcnlIb2xkZXIgPSBidWlsZFRpbWVPZkRheUV4cGlyeUhvbGRlcigpOwotCQlEYXRlVGltZSBkYXRlVGltZSA9IGFkZFVubWFuYWdlZERhdGVUaW1lKAotCQkJY29udGFpbmVyLCAKLQkJCWJ1aWxkVGltZU9mRGF5RXhwaXJ5SG91ckhvbGRlcih0aW1lT2ZEYXlFeHBpcnlIb2xkZXIpLCAKLQkJCWJ1aWxkVGltZU9mRGF5RXhwaXJ5TWludXRlSG9sZGVyKHRpbWVPZkRheUV4cGlyeUhvbGRlciksCi0JCQlidWlsZFRpbWVPZkRheUV4cGlyeVNlY29uZEhvbGRlcih0aW1lT2ZEYXlFeHBpcnlIb2xkZXIpLAotCQkJbnVsbCk7Ci0KLQkJbmV3IENvbnRyb2xFbmFibGVyKGJ1aWxkVGltZU9mRGF5RXhwaXJ5RW5hYmxlcigpLCBleHBpcmVBdExhYmVsLCBkYXRlVGltZSk7Ci0JfQotCQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGROb0V4cGlyeUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q2FjaGluZywgQm9vbGVhbj4oCi0JCQkJCWdldFN1YmplY3RIb2xkZXIoKSwgCi0JCQkJCUNhY2hpbmcuRVhQSVJZX1BST1BFUlRZLCAKLQkJCQkJQ2FjaGluZy5FWFBJUllfVElNRV9PRl9EQVlfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIEJvb2xlYW4udmFsdWVPZih0aGlzLnN1YmplY3QuZ2V0RXhwaXJ5KCkgPT0gbnVsbCAmJiB0aGlzLnN1YmplY3QuZ2V0RXhwaXJ5VGltZU9mRGF5KCkgPT0gbnVsbCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQl0aGlzLnN1YmplY3Quc2V0RXhwaXJ5KG51bGwpOwotCQkJCWlmICh0aGlzLnN1YmplY3QuZ2V0RXhwaXJ5VGltZU9mRGF5KCkgIT0gbnVsbCkgewotCQkJCQl0aGlzLnN1YmplY3QucmVtb3ZlRXhwaXJ5VGltZU9mRGF5KCk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRFeHBpcnlIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENhY2hpbmcsIEJvb2xlYW4+KAotCQkJCQlnZXRTdWJqZWN0SG9sZGVyKCksIAotCQkJCQlDYWNoaW5nLkVYUElSWV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gQm9vbGVhbi52YWx1ZU9mKHRoaXMuc3ViamVjdC5nZXRFeHBpcnkoKSAhPSBudWxsKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZSA9PSBCb29sZWFuLlRSVUUpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LnNldEV4cGlyeSgwKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRUaW1lT2ZEYXlFeHBpcnlCb29sZWFuSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDYWNoaW5nLCBCb29sZWFuPigKLQkJCQkJZ2V0U3ViamVjdEhvbGRlcigpLCAKLQkJCQkJQ2FjaGluZy5FWFBJUllfVElNRV9PRl9EQVlfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIEJvb2xlYW4udmFsdWVPZih0aGlzLnN1YmplY3QuZ2V0RXhwaXJ5VGltZU9mRGF5KCkgIT0gbnVsbCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlpZiAodmFsdWUgPT0gQm9vbGVhbi5UUlVFKSB7Ci0JCQkJCXRoaXMuc3ViamVjdC5hZGRFeHBpcnlUaW1lT2ZEYXkoKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyPiBidWlsZFRpbWVUb0xpdmVFeHBpcnlIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENhY2hpbmcsIEludGVnZXI+KGdldFN1YmplY3RIb2xkZXIoKSwgQ2FjaGluZy5FWFBJUllfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEludGVnZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRFeHBpcnkoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oSW50ZWdlciB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZSA9PSAtMSkgewotCQkJCQl2YWx1ZSA9IG51bGw7Ci0JCQkJfQotCQkJCXN1YmplY3Quc2V0RXhwaXJ5KHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRUaW1lVG9MaXZlRXhwaXJ5RW5hYmxlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q2FjaGluZywgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDYWNoaW5nLkVYUElSWV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gQm9vbGVhbi52YWx1ZU9mKHRoaXMuc3ViamVjdC5nZXRFeHBpcnkoKSAhPSBudWxsKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRUaW1lT2ZEYXlFeHBpcnlFbmFibGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDYWNoaW5nLCBCb29sZWFuPihnZXRTdWJqZWN0SG9sZGVyKCksIENhY2hpbmcuRVhQSVJZX1RJTUVfT0ZfREFZX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBCb29sZWFuLnZhbHVlT2YodGhpcy5zdWJqZWN0LmdldEV4cGlyeVRpbWVPZkRheSgpICE9IG51bGwpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxFeHBpcnlUaW1lT2ZEYXk+IGJ1aWxkVGltZU9mRGF5RXhwaXJ5SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDYWNoaW5nLCBFeHBpcnlUaW1lT2ZEYXk+KGdldFN1YmplY3RIb2xkZXIoKSwgQ2FjaGluZy5FWFBJUllfVElNRV9PRl9EQVlfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEV4cGlyeVRpbWVPZkRheSBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldEV4cGlyeVRpbWVPZkRheSgpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4gYnVpbGRUaW1lT2ZEYXlFeHBpcnlIb3VySG9sZGVyKFByb3BlcnR5VmFsdWVNb2RlbDxFeHBpcnlUaW1lT2ZEYXk+IHRpbWVPZkRheUV4cGlyeUhvbGRlcikgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxFeHBpcnlUaW1lT2ZEYXksIEludGVnZXI+KAotCQkJCQl0aW1lT2ZEYXlFeHBpcnlIb2xkZXIsIAotCQkJCQlFeHBpcnlUaW1lT2ZEYXkuSE9VUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSW50ZWdlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldEhvdXIoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oSW50ZWdlciBob3VyKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldEhvdXIoaG91cik7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyPiBidWlsZFRpbWVPZkRheUV4cGlyeU1pbnV0ZUhvbGRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8RXhwaXJ5VGltZU9mRGF5PiB0aW1lT2ZEYXlFeHBpcnlIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8RXhwaXJ5VGltZU9mRGF5LCBJbnRlZ2VyPigKLQkJCQkJdGltZU9mRGF5RXhwaXJ5SG9sZGVyLCAKLQkJCQkJRXhwaXJ5VGltZU9mRGF5Lk1JTlVURV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSW50ZWdlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldE1pbnV0ZSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhJbnRlZ2VyIG1pbnV0ZSkgewotCQkJCXRoaXMuc3ViamVjdC5zZXRNaW51dGUobWludXRlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXI+IGJ1aWxkVGltZU9mRGF5RXhwaXJ5U2Vjb25kSG9sZGVyKFByb3BlcnR5VmFsdWVNb2RlbDxFeHBpcnlUaW1lT2ZEYXk+IHRpbWVPZkRheUV4cGlyeUhvbGRlcikgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxFeHBpcnlUaW1lT2ZEYXksIEludGVnZXI+KAotCQkJCQl0aW1lT2ZEYXlFeHBpcnlIb2xkZXIsIAotCQkJCQlFeHBpcnlUaW1lT2ZEYXkuU0VDT05EX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBJbnRlZ2VyIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0U2Vjb25kKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEludGVnZXIgc2Vjb25kKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldFNlY29uZChzZWNvbmQpOwotCQkJfQotCQl9OwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9Kb2luRmV0Y2hDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvSm9pbkZldGNoQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJkNDkyMjcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9Kb2luRmV0Y2hDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDExMyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMKLSAqICBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mCi0gKiAgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzCi0gKiAgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0gKgotICogIENvbnRyaWJ1dG9yczogT3JhY2xlLiAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzOwotCi1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuaW50ZXJuYWwuSnB0Q29yZU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuSm9pbkZldGNoOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuSm9pbkZldGNoVHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRW51bUZvcm1Db21ib1ZpZXdlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIEhlcmUgdGhlIGxheW91dCBvZiB0aGlzIHBhbmU6Ci0gKiA8cHJlPgotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLSAqIHwgICAgICAgICAgICAgICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IEpvaW4gRmV0Y2g6ICAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8dnwgfAotICogfCAgICAgICAgICAgICAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSBGZXRjaGFibGUKLSAqIEBzZWUgQmFzaWNNYXBwaW5nQ29tcG9zaXRlIC0gQSBjb250YWluZXIgb2YgdGhpcyB3aWRnZXQKLSAqIEBzZWUgTWFueVRvTWFueU1hcHBpbmdDb21wb3NpdGUgLSBBIGNvbnRhaW5lciBvZiB0aGlzIHdpZGdldAotICogQHNlZSBNYW55VG9PbmVNYXBwaW5nQ29tcG9zaXRlIC0gQSBjb250YWluZXIgb2YgdGhpcyB3aWRnZXQKLSAqIEBzZWUgT25lVG9NYW55TWFwcGluZ0NvbXBvc2l0ZSAtIEEgY29udGFpbmVyIG9mIHRoaXMgd2lkZ2V0Ci0gKiBAc2VlIE9uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZSAtIEEgY29udGFpbmVyIG9mIHRoaXMgd2lkZ2V0Ci0gKgotICogQHZlcnNpb24gMi4xCi0gKiBAc2luY2UgMi4xCi0gKi8KLXB1YmxpYyBjbGFzcyBKb2luRmV0Y2hDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxKb2luRmV0Y2g+IHsKLQotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+Sm9pbkZldGNoQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRQYW5lIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBKb2luRmV0Y2hDb21wb3NpdGUoRm9ybVBhbmU8Pz4gcGFyZW50UGFuZSwgCi0JCQkJCQkJCVByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgSm9pbkZldGNoPiBzdWJqZWN0SG9sZGVyLAotCQkJCQkJCQlDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50UGFuZSwgc3ViamVjdEhvbGRlciwgcGFyZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJYWRkTGFiZWxlZENvbXBvc2l0ZSggCi0gICAgICAgICAgICBjb250YWluZXIsIAotICAgICAgICAgICAgYWRkTGFiZWwoIAotICAgICAgICAgICAgICAgICBjb250YWluZXIsIAotICAgICAgICAgICAgICAgICBFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Kb2luRmV0Y2hDb21wb3NpdGVfbGFiZWwpLCAKLSAgICAgICAgICAgIGFkZEpvaW5GZXRjaFR5cGVDb21ibyhjb250YWluZXIpLmdldENvbnRyb2woKSwKLSAgICAgICAgICAgIG51bGwgCi0gICAgICAgKTsKLQl9Ci0JCi0KLQlwcml2YXRlIEVudW1Gb3JtQ29tYm9WaWV3ZXI8Sm9pbkZldGNoLCBKb2luRmV0Y2hUeXBlPiBhZGRKb2luRmV0Y2hUeXBlQ29tYm8oQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXJldHVybiBuZXcgRW51bUZvcm1Db21ib1ZpZXdlcjxKb2luRmV0Y2gsIEpvaW5GZXRjaFR5cGU+KHRoaXMsIGNvbnRhaW5lcikgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIGFkZFByb3BlcnR5TmFtZXMoQ29sbGVjdGlvbjxTdHJpbmc+IHByb3BlcnR5TmFtZXMpIHsKLQkJCQlzdXBlci5hZGRQcm9wZXJ0eU5hbWVzKHByb3BlcnR5TmFtZXMpOwotCQkJCXByb3BlcnR5TmFtZXMuYWRkKEpvaW5GZXRjaC5WQUxVRV9QUk9QRVJUWSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEpvaW5GZXRjaFR5cGVbXSBnZXRDaG9pY2VzKCkgewotCQkJCXJldHVybiBKb2luRmV0Y2hUeXBlLnZhbHVlcygpOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBKb2luRmV0Y2hUeXBlIGdldERlZmF1bHRWYWx1ZSgpIHsKLQkJCQlyZXR1cm4gbnVsbDsKLQkJCX0KLQkJCQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGRpc3BsYXlTdHJpbmcoSm9pbkZldGNoVHlwZSB2YWx1ZSkgewotCQkJCXJldHVybiBidWlsZERpc3BsYXlTdHJpbmcoCi0JCQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLmNsYXNzLAotCQkJCQlKb2luRmV0Y2hDb21wb3NpdGUudGhpcywKLQkJCQkJdmFsdWUKLQkJCQkpOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgbnVsbERpc3BsYXlTdHJpbmcoKSB7Ci0JCQkJcmV0dXJuIEpwdENvcmVNZXNzYWdlcy5OT05FOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBKb2luRmV0Y2hUeXBlIGdldFZhbHVlKCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0VmFsdWUoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZShKb2luRmV0Y2hUeXBlIHZhbHVlKSB7Ci0JCQkJZ2V0U3ViamVjdCgpLnNldFZhbHVlKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL011dGFibGVDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvTXV0YWJsZUNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlOWZjNzMwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvTXV0YWJsZUNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTA3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuTXV0YWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLkpwdFVpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFRoaXMgY29tcG9zaXRlIHNpbXBseSBzaG93cyBhIHRyaS1zdGF0ZSBjaGVjayBib3ggZm9yIHRoZSBNdXRhYmxlIG9wdGlvbi4KLSAqCi0gKiBAc2VlIE11dGFibGUKLSAqIEBzZWUgRWNsaXBzZUxpbmtCYXNpY01hcHBpbmdDb21wb3NpdGUgLSBBIGNvbnRhaW5lciBvZiB0aGlzIHBhbmUKLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIE11dGFibGVDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxNdXRhYmxlPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+TXV0YWJsZUNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgTXV0YWJsZUNvbXBvc2l0ZShGb3JtUGFuZTw/PiBwYXJlbnRQYW5lLCAKLQkJUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBNdXRhYmxlPiBzdWJqZWN0SG9sZGVyLAotCQlDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJCXN1cGVyKHBhcmVudFBhbmUsIHN1YmplY3RIb2xkZXIsIHBhcmVudCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCWFkZFRyaVN0YXRlQ2hlY2tCb3hXaXRoRGVmYXVsdCgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLk11dGFibGVDb21wb3NpdGVfbXV0YWJsZUxhYmVsLAotCQkJYnVpbGRNdXRhYmxlSG9sZGVyKCksCi0JCQlidWlsZE11dGFibGVTdHJpbmdIb2xkZXIoKSwKLQkJCW51bGwKLQkJKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkTXV0YWJsZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8TXV0YWJsZSwgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBNdXRhYmxlLlNQRUNJRklFRF9NVVRBQkxFX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0U3BlY2lmaWVkTXV0YWJsZSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldFNwZWNpZmllZE11dGFibGUodmFsdWUpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHN1YmplY3RDaGFuZ2VkKCkgewotCQkJCU9iamVjdCBvbGRWYWx1ZSA9IHRoaXMuZ2V0VmFsdWUoKTsKLQkJCQlzdXBlci5zdWJqZWN0Q2hhbmdlZCgpOwotCQkJCU9iamVjdCBuZXdWYWx1ZSA9IHRoaXMuZ2V0VmFsdWUoKTsKLQotCQkJCS8vIE1ha2Ugc3VyZSB0aGUgZGVmYXVsdCB2YWx1ZSBpcyBhcHBlbmRlZCB0byB0aGUgdGV4dAotCQkJCWlmIChvbGRWYWx1ZSA9PSBuZXdWYWx1ZSAmJiBuZXdWYWx1ZSA9PSBudWxsKSB7Ci0JCQkJCXRoaXMuZmlyZUFzcGVjdENoYW5nZShCb29sZWFuLlRSVUUsIG5ld1ZhbHVlKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZE11dGFibGVTdHJpbmdIb2xkZXIoKSB7Ci0KLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuLCBTdHJpbmc+KGJ1aWxkTXV0YWJsZUhvbGRlcigpKSB7Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oQm9vbGVhbiB2YWx1ZSkgewotCi0JCQkJaWYgKChnZXRTdWJqZWN0KCkgIT0gbnVsbCkgJiYgKHZhbHVlID09IG51bGwpKSB7Ci0JCQkJCWJvb2xlYW4gZGVmYXVsdFZhbHVlID0gZ2V0U3ViamVjdCgpLmlzRGVmYXVsdE11dGFibGUoKTsKLQkJCQkJU3RyaW5nIGRlZmF1bHRTdHJpbmdWYWx1ZSA9IGRlZmF1bHRWYWx1ZSA/IEpwdFVpTWFwcGluZ3NNZXNzYWdlcy5Cb29sZWFuX1RydWUgOgotCQkJCQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSnB0VWlNYXBwaW5nc01lc3NhZ2VzLkJvb2xlYW5fRmFsc2U7Ci0KLQkJCQkJcmV0dXJuIE5MUy5iaW5kKAotCQkJCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuTXV0YWJsZUNvbXBvc2l0ZV9tdXRhYmxlTGFiZWxEZWZhdWx0LAotCQkJCQkJZGVmYXVsdFN0cmluZ1ZhbHVlCi0JCQkJCSk7Ci0JCQkJfQotCi0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLk11dGFibGVDb21wb3NpdGVfbXV0YWJsZUxhYmVsOwotCQkJfQotCQl9OwotCX0KLQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvT2JqZWN0VHlwZUNvbnZlcnRlckNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9PYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGI4ZTQyOWUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9PYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0ODIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzCi0gKiAgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZgotICogIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcwotICogIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotICoKLSAqICBDb250cmlidXRvcnM6IE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LnVpLklKYXZhRWxlbWVudFNlYXJjaENvbnN0YW50czsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLklUYWJsZUxhYmVsUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5MYWJlbFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLndpbmRvdy5XaW5kb3c7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuSnBhUHJvamVjdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkNvbnZlcnNpb25WYWx1ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkVjbGlwc2VMaW5rQ29udmVydGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuT2JqZWN0VHlwZUNvbnZlcnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnN3dC5Db2x1bW5BZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLlBhbmVFbmFibGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkFkZFJlbW92ZUxpc3RQYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkFkZFJlbW92ZVRhYmxlUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5DbGFzc0Nob29zZXJQYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ0NvbnZlcnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5JdGVtUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuTGlzdEFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5PYmplY3RMaXN0U2VsZWN0aW9uTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5ncmFwaGljcy5JbWFnZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuR3JvdXA7Ci0KLS8qKgotICogSGVyZSB0aGUgbGF5b3V0IG9mIHRoaXMgcGFuZToKLSAqIDxwcmU+Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotICogfCAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgTmFtZTogICAgICB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHx8Ci0gKiB8ICAgICAgICAgICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS08L3ByZT4KLSAqCi0gKiBAc2VlIEVjbGlwc2VMaW5rQ29udmVydGVyCi0gKiBAc2VlIENvbnZlcnRDb21wb3NpdGUgLSBBIGNvbnRhaW5lciBvZiB0aGlzIHdpZGdldAotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgT2JqZWN0VHlwZUNvbnZlcnRlckNvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPE9iamVjdFR5cGVDb252ZXJ0ZXI+Ci17Ci0KLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPk9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudFBhbmUgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIE9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBPYmplY3RUeXBlQ29udmVydGVyPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCQotCQlhZGRMYWJlbGVkVGV4dCgKLQkJCWNvbnRhaW5lciwgCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJ0ZXJDb21wb3NpdGVfbmFtZVRleHRMYWJlbCwgCi0JCQlidWlsZE5hbWVUZXh0SG9sZGVyKCkpOwotCQkKLQkJYWRkRGF0YVR5cGVDaG9vc2VyKGNvbnRhaW5lcik7Ci0JCWFkZE9iamVjdFR5cGVDaG9vc2VyKGNvbnRhaW5lcik7Ci0JCQotCQlhZGRDb252ZXJzaW9uVmFsdWVzVGFibGUoY29udGFpbmVyKTsKLQotCQlhZGRMYWJlbGVkRWRpdGFibGVDQ29tYm8oCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5PYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlX2RlZmF1bHRPYmplY3RWYWx1ZUxhYmVsLAotCQkJYnVpbGREZWZhdWx0T2JqZWN0VmFsdWVMaXN0SG9sZGVyKCksCi0JCQlidWlsZERlZmF1bHRPYmplY3RWYWx1ZUhvbGRlcigpLAotCQkJYnVpbGRTdHJpbmdDb252ZXJ0ZXIoKSwKLQkJCW51bGwKLQkJKTsKLQotCQluZXcgUGFuZUVuYWJsZXIoYnVpbGRCb29sZWFuSG9sZGVyKCksIHRoaXMpOwotCX0KLQkKLQlwcm90ZWN0ZWQgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZE5hbWVUZXh0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxPYmplY3RUeXBlQ29udmVydGVyLCBTdHJpbmc+KAotCQkJCWdldFN1YmplY3RIb2xkZXIoKSwgRWNsaXBzZUxpbmtDb252ZXJ0ZXIuTkFNRV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0TmFtZSgpOwotCQkJfQotCQkKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQkJCXZhbHVlID0gbnVsbDsKLQkJCQl9Ci0JCQkJdGhpcy5zdWJqZWN0LnNldE5hbWUodmFsdWUpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcml2YXRlIENsYXNzQ2hvb3NlclBhbmU8T2JqZWN0VHlwZUNvbnZlcnRlcj4gYWRkRGF0YVR5cGVDaG9vc2VyKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlyZXR1cm4gbmV3IENsYXNzQ2hvb3NlclBhbmU8T2JqZWN0VHlwZUNvbnZlcnRlcj4odGhpcywgY29udGFpbmVyKSB7Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRUZXh0SG9sZGVyKCkgewotCQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPE9iamVjdFR5cGVDb252ZXJ0ZXIsIFN0cmluZz4oZ2V0U3ViamVjdEhvbGRlcigpLCBPYmplY3RUeXBlQ29udmVydGVyLkRBVEFfVFlQRV9QUk9QRVJUWSkgewotCQkJCQlAT3ZlcnJpZGUKLQkJCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0RGF0YVR5cGUoKTsKLQkJCQkJfQotCi0JCQkJCUBPdmVycmlkZQotCQkJCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0KLQkJCQkJCWlmICh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQkJCQkJdmFsdWUgPSBudWxsOwotCQkJCQkJfQotCi0JCQkJCQl0aGlzLnN1YmplY3Quc2V0RGF0YVR5cGUodmFsdWUpOwotCQkJCQl9Ci0JCQkJfTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGdldENsYXNzTmFtZSgpIHsKLQkJCQlyZXR1cm4gZ2V0U3ViamVjdCgpLmdldERhdGFUeXBlKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBnZXRMYWJlbFRleHQoKSB7Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLk9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGVfZGF0YVR5cGVMYWJlbDsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSnBhUHJvamVjdCBnZXRKcGFQcm9qZWN0KCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0SnBhUHJvamVjdCgpOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldENsYXNzTmFtZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCQkJZ2V0U3ViamVjdCgpLnNldERhdGFUeXBlKGNsYXNzTmFtZSk7Ci0JCQl9Ci0JCQkKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGNoYXIgZ2V0RW5jbG9zaW5nVHlwZVNlcGFyYXRvcigpIHsKLQkJCQlyZXR1cm4gZ2V0U3ViamVjdCgpLmdldEVuY2xvc2luZ1R5cGVTZXBhcmF0b3IoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENsYXNzQ2hvb3NlclBhbmU8T2JqZWN0VHlwZUNvbnZlcnRlcj4gYWRkT2JqZWN0VHlwZUNob29zZXIoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXJldHVybiBuZXcgQ2xhc3NDaG9vc2VyUGFuZTxPYmplY3RUeXBlQ29udmVydGVyPih0aGlzLCBjb250YWluZXIpIHsKLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFRleHRIb2xkZXIoKSB7Ci0JCQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8T2JqZWN0VHlwZUNvbnZlcnRlciwgU3RyaW5nPihnZXRTdWJqZWN0SG9sZGVyKCksIE9iamVjdFR5cGVDb252ZXJ0ZXIuT0JKRUNUX1RZUEVfUFJPUEVSVFkpIHsKLQkJCQkJQE92ZXJyaWRlCi0JCQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldE9iamVjdFR5cGUoKTsKLQkJCQkJfQotCi0JCQkJCUBPdmVycmlkZQotCQkJCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0KLQkJCQkJCWlmICh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQkJCQkJdmFsdWUgPSBudWxsOwotCQkJCQkJfQotCi0JCQkJCQl0aGlzLnN1YmplY3Quc2V0T2JqZWN0VHlwZSh2YWx1ZSk7Ci0JCQkJCX0KLQkJCQl9OwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZ2V0Q2xhc3NOYW1lKCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0T2JqZWN0VHlwZSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZ2V0TGFiZWxUZXh0KCkgewotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5PYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlX29iamVjdFR5cGVMYWJlbDsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSnBhUHJvamVjdCBnZXRKcGFQcm9qZWN0KCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0SnBhUHJvamVjdCgpOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldENsYXNzTmFtZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCQkJZ2V0U3ViamVjdCgpLnNldE9iamVjdFR5cGUoY2xhc3NOYW1lKTsKLQkJCX0KLQkJCQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgaW50IGdldFR5cGVEaWFsb2dTdHlsZSgpIHsKLQkJCQlyZXR1cm4gSUphdmFFbGVtZW50U2VhcmNoQ29uc3RhbnRzLkNPTlNJREVSX0NMQVNTRVNfQU5EX0VOVU1TOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBjaGFyIGdldEVuY2xvc2luZ1R5cGVTZXBhcmF0b3IoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXRFbmNsb3NpbmdUeXBlU2VwYXJhdG9yKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGFkZENvbnZlcnNpb25WYWx1ZXNUYWJsZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCQotCQkvLyBKb2luIENvbHVtbnMgZ3JvdXAgcGFuZQotCQlHcm91cCBjb252ZXJzaW9uVmFsdWVzR3JvdXBQYW5lID0gYWRkVGl0bGVkR3JvdXAoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5PYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlX2NvbnZlcnNpb25WYWx1ZXNHcm91cFRpdGxlCi0JCSk7Ci0KLQkJV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Q29udmVyc2lvblZhbHVlPiBjb252ZXJzaW9uVmFsdWVIb2xkZXIgPQotCQkJYnVpbGRDb252ZXJzaW9uVmFsdWVIb2xkZXIoKTsKLQkJLy8gQ29udmVyc2lvbiBWYWx1ZXMgYWRkL3JlbW92ZSBsaXN0IHBhbmUKLQkJbmV3IEFkZFJlbW92ZVRhYmxlUGFuZTxPYmplY3RUeXBlQ29udmVydGVyPigKLQkJCXRoaXMsCi0JCQljb252ZXJzaW9uVmFsdWVzR3JvdXBQYW5lLAotCQkJYnVpbGRDb252ZXJzaW9uVmFsdWVzQWRhcHRlcigpLAotCQkJYnVpbGRDb252ZXJzaW9uVmFsdWVzTGlzdE1vZGVsKCksCi0JCQljb252ZXJzaW9uVmFsdWVIb2xkZXIsCi0JCQlidWlsZENvbnZlcnNpb25WYWx1ZXNMYWJlbFByb3ZpZGVyKCksCi0JCQludWxsLy9UT0RPIG5lZWQgYSBoZWxwIGNvbnRleHQgaWQgZm9yIHRoaXMKLQkJKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDb2x1bW5BZGFwdGVyPENvbnZlcnNpb25WYWx1ZT4gYnVpbGRDb2x1bW5BZGFwdGVyKCkgewotCQkJCXJldHVybiBuZXcgQ29udmVyc2lvblZhbHVlQ29sdW1uQWRhcHRlcigpOwotCQkJfQotCQl9OwotCi0JfQotCi0JcHJvdGVjdGVkIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnNpb25WYWx1ZT4gYnVpbGRDb252ZXJzaW9uVmFsdWVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnNpb25WYWx1ZT4oKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgQWRkUmVtb3ZlTGlzdFBhbmUuQWRhcHRlciBidWlsZENvbnZlcnNpb25WYWx1ZXNBZGFwdGVyKCkgewotCQlyZXR1cm4gbmV3IEFkZFJlbW92ZUxpc3RQYW5lLkFic3RyYWN0QWRhcHRlcigpIHsKLQotCQkJcHVibGljIHZvaWQgYWRkTmV3SXRlbShPYmplY3RMaXN0U2VsZWN0aW9uTW9kZWwgbGlzdFNlbGVjdGlvbk1vZGVsKSB7Ci0JCQkJQ29udmVyc2lvblZhbHVlRGlhbG9nIGRpYWxvZyA9IGJ1aWxkQ29udmVyc2lvblZhbHVlRGlhbG9nRm9yQWRkKCk7Ci0JCQkJYWRkQ29udmVyc2lvblZhbHVlRnJvbURpYWxvZyhkaWFsb2csIGxpc3RTZWxlY3Rpb25Nb2RlbCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIGJvb2xlYW4gaGFzT3B0aW9uYWxCdXR0b24oKSB7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyBvcHRpb25hbEJ1dHRvblRleHQoKSB7Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLk9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGVfY29udmVyc2lvblZhbHVlRWRpdDsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBvcHRpb25PblNlbGVjdGlvbihPYmplY3RMaXN0U2VsZWN0aW9uTW9kZWwgbGlzdFNlbGVjdGlvbk1vZGVsKSB7Ci0JCQkJQ29udmVyc2lvblZhbHVlIGNvbnZlcnNpb25WYWx1ZSA9IChDb252ZXJzaW9uVmFsdWUpIGxpc3RTZWxlY3Rpb25Nb2RlbC5zZWxlY3RlZFZhbHVlKCk7Ci0JCQkJQ29udmVyc2lvblZhbHVlRGlhbG9nIGRpYWxvZyA9IG5ldyBDb252ZXJzaW9uVmFsdWVEaWFsb2coZ2V0Q29udHJvbCgpLmdldFNoZWxsKCksIGdldFN1YmplY3QoKSwgY29udmVyc2lvblZhbHVlKTsKLQkJCQllZGl0Q29udmVyc2lvblZhbHVlRnJvbURpYWxvZyhkaWFsb2csIGNvbnZlcnNpb25WYWx1ZSk7Ci0JCQl9Ci0KLQkJCXB1YmxpYyB2b2lkIHJlbW92ZVNlbGVjdGVkSXRlbXMoT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsIGxpc3RTZWxlY3Rpb25Nb2RlbCkgewotCQkJCU9iamVjdFR5cGVDb252ZXJ0ZXIgY29udmVydGVyID0gZ2V0U3ViamVjdCgpOwotCQkJCWludFtdIHNlbGVjdGVkSW5kaWNlcyA9IGxpc3RTZWxlY3Rpb25Nb2RlbC5zZWxlY3RlZEluZGljZXMoKTsKLQotCQkJCWZvciAoaW50IGluZGV4ID0gc2VsZWN0ZWRJbmRpY2VzLmxlbmd0aDsgLS1pbmRleCA+PSAwOyApIHsKLQkJCQkJY29udmVydGVyLnJlbW92ZUNvbnZlcnNpb25WYWx1ZShzZWxlY3RlZEluZGljZXNbaW5kZXhdKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQlwcm90ZWN0ZWQgQ29udmVyc2lvblZhbHVlRGlhbG9nIGJ1aWxkQ29udmVyc2lvblZhbHVlRGlhbG9nRm9yQWRkKCkgewotCQlyZXR1cm4gbmV3IENvbnZlcnNpb25WYWx1ZURpYWxvZyhnZXRDb250cm9sKCkuZ2V0U2hlbGwoKSwgZ2V0U3ViamVjdCgpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBhZGRDb252ZXJzaW9uVmFsdWVGcm9tRGlhbG9nKENvbnZlcnNpb25WYWx1ZURpYWxvZyBkaWFsb2csIE9iamVjdExpc3RTZWxlY3Rpb25Nb2RlbCBsaXN0U2VsZWN0aW9uTW9kZWwpIHsKLQkJaWYgKGRpYWxvZy5vcGVuKCkgIT0gV2luZG93Lk9LKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQotCQlDb252ZXJzaW9uVmFsdWUgY29udmVyc2lvblZhbHVlID0gdGhpcy5nZXRTdWJqZWN0KCkuYWRkQ29udmVyc2lvblZhbHVlKCk7Ci0JCWNvbnZlcnNpb25WYWx1ZS5zZXREYXRhVmFsdWUoZGlhbG9nLmdldERhdGFWYWx1ZSgpKTsKLQkJY29udmVyc2lvblZhbHVlLnNldE9iamVjdFZhbHVlKGRpYWxvZy5nZXRPYmplY3RWYWx1ZSgpKTsKLQotCQlsaXN0U2VsZWN0aW9uTW9kZWwuc2V0U2VsZWN0ZWRWYWx1ZShjb252ZXJzaW9uVmFsdWUpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGVkaXRDb252ZXJzaW9uVmFsdWVGcm9tRGlhbG9nKENvbnZlcnNpb25WYWx1ZURpYWxvZyBkaWFsb2csIENvbnZlcnNpb25WYWx1ZSBjb252ZXJzaW9uVmFsdWUpIHsKLQkJaWYgKGRpYWxvZy5vcGVuKCkgIT0gV2luZG93Lk9LKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQotCQljb252ZXJzaW9uVmFsdWUuc2V0RGF0YVZhbHVlKGRpYWxvZy5nZXREYXRhVmFsdWUoKSk7Ci0JCWNvbnZlcnNpb25WYWx1ZS5zZXRPYmplY3RWYWx1ZShkaWFsb2cuZ2V0T2JqZWN0VmFsdWUoKSk7Ci0JfQotCQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8Q29udmVyc2lvblZhbHVlPiBidWlsZENvbnZlcnNpb25WYWx1ZXNMaXN0TW9kZWwoKSB7Ci0JCXJldHVybiBuZXcgSXRlbVByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyPENvbnZlcnNpb25WYWx1ZT4oYnVpbGRDb252ZXJzaW9uVmFsdWVzTGlzdEhvbGRlcigpLCAKLQkJCUNvbnZlcnNpb25WYWx1ZS5EQVRBX1ZBTFVFX1BST1BFUlRZLAotCQkJQ29udmVyc2lvblZhbHVlLk9CSkVDVF9WQUxVRV9QUk9QRVJUWSk7Ci0JfQkKLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8Q29udmVyc2lvblZhbHVlPiBidWlsZENvbnZlcnNpb25WYWx1ZXNMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IExpc3RBc3BlY3RBZGFwdGVyPE9iamVjdFR5cGVDb252ZXJ0ZXIsIENvbnZlcnNpb25WYWx1ZT4oZ2V0U3ViamVjdEhvbGRlcigpLCBPYmplY3RUeXBlQ29udmVydGVyLkNPTlZFUlNJT05fVkFMVUVTX0xJU1QpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIExpc3RJdGVyYXRvcjxDb252ZXJzaW9uVmFsdWU+IGxpc3RJdGVyYXRvcl8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5jb252ZXJzaW9uVmFsdWVzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGludCBzaXplXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmNvbnZlcnNpb25WYWx1ZXNTaXplKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBJVGFibGVMYWJlbFByb3ZpZGVyIGJ1aWxkQ29udmVyc2lvblZhbHVlc0xhYmVsUHJvdmlkZXIoKSB7Ci0JCXJldHVybiBuZXcgVGFibGVMYWJlbFByb3ZpZGVyKCk7Ci0JfQotCQotCXByb3RlY3RlZCBMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdE9iamVjdFZhbHVlTGlzdEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxDb252ZXJzaW9uVmFsdWUsIFN0cmluZz4oYnVpbGRDb252ZXJzaW9uVmFsdWVzTGlzdE1vZGVsKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm1JdGVtKENvbnZlcnNpb25WYWx1ZSBjb252ZXJzaW9uVmFsdWUpIHsKLQkJCQlyZXR1cm4gY29udmVyc2lvblZhbHVlLmdldE9iamVjdFZhbHVlKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByb3RlY3RlZCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdE9iamVjdFZhbHVlSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxPYmplY3RUeXBlQ29udmVydGVyLCBTdHJpbmc+KAotCQkJCWdldFN1YmplY3RIb2xkZXIoKSwgT2JqZWN0VHlwZUNvbnZlcnRlci5ERUZBVUxUX09CSkVDVF9WQUxVRV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0RGVmYXVsdE9iamVjdFZhbHVlKCk7Ci0JCQl9Ci0JCQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0JCQkJaWYgKHZhbHVlICE9IG51bGwgJiYgdmFsdWUubGVuZ3RoKCkgPT0gMCkgewotCQkJCQl2YWx1ZSA9IG51bGw7Ci0JCQkJfQotCQkJCXRoaXMuc3ViamVjdC5zZXREZWZhdWx0T2JqZWN0VmFsdWUodmFsdWUpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcm90ZWN0ZWQgZmluYWwgU3RyaW5nQ29udmVydGVyPFN0cmluZz4gYnVpbGRTdHJpbmdDb252ZXJ0ZXIoKSB7Ci0JCXJldHVybiBuZXcgU3RyaW5nQ29udmVydGVyPFN0cmluZz4oKSB7Ci0JCQlwdWJsaWMgU3RyaW5nIGNvbnZlcnRUb1N0cmluZyhTdHJpbmcgdmFsdWUpIHsKLQkJCQlyZXR1cm4gKHZhbHVlID09IG51bGwpID8gIiIgOiB2YWx1ZTsgLy8kTk9OLU5MUy0xJAotCQkJfQotCQl9OwotCX0KLQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRCb29sZWFuSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdFR5cGVDb252ZXJ0ZXIsIEJvb2xlYW4+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiB0cmFuc2Zvcm0oT2JqZWN0VHlwZUNvbnZlcnRlciB2YWx1ZSkgewotCQkJCXJldHVybiBCb29sZWFuLnZhbHVlT2YodmFsdWUgIT0gbnVsbCk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgY2xhc3MgVGFibGVMYWJlbFByb3ZpZGVyIGV4dGVuZHMgTGFiZWxQcm92aWRlcgotCQlpbXBsZW1lbnRzIElUYWJsZUxhYmVsUHJvdmlkZXIgewotCi0JCXB1YmxpYyBJbWFnZSBnZXRDb2x1bW5JbWFnZShPYmplY3QgZWxlbWVudCwgaW50IGNvbHVtbkluZGV4KSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQkKLQkJcHVibGljIFN0cmluZyBnZXRDb2x1bW5UZXh0KE9iamVjdCBlbGVtZW50LCBpbnQgY29sdW1uSW5kZXgpIHsKLQkJCi0JCQlDb252ZXJzaW9uVmFsdWUgY29udmVyc2lvblZhbHVlID0gKENvbnZlcnNpb25WYWx1ZSkgZWxlbWVudDsKLQkJCVN0cmluZyB2YWx1ZSA9IG51bGw7Ci0JCQkKLQkJCXN3aXRjaCAoY29sdW1uSW5kZXgpIHsKLQkJCQljYXNlIENvbnZlcnNpb25WYWx1ZUNvbHVtbkFkYXB0ZXIuREFUQV9WQUxVRV9DT0xVTU46IHsKLQkJCQkJdmFsdWUgPSBjb252ZXJzaW9uVmFsdWUuZ2V0RGF0YVZhbHVlKCk7Ci0JCQkJCWJyZWFrOwotCQkJCX0KLQkJCQotCQkJCWNhc2UgQ29udmVyc2lvblZhbHVlQ29sdW1uQWRhcHRlci5PQkpFQ1RfVkFMVUVfQ09MVU1OOiB7Ci0JCQkJCXZhbHVlID0gY29udmVyc2lvblZhbHVlLmdldE9iamVjdFZhbHVlKCk7Ci0JCQkJCWJyZWFrOwotCQkJCX0KLQkJCX0KLQkJCQotCQkJaWYgKHZhbHVlID09IG51bGwpIHsKLQkJCQl2YWx1ZSA9ICIiOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCQotCQkJcmV0dXJuIHZhbHVlOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgY2xhc3MgQ29udmVyc2lvblZhbHVlQ29sdW1uQWRhcHRlciBpbXBsZW1lbnRzIENvbHVtbkFkYXB0ZXI8Q29udmVyc2lvblZhbHVlPiB7Ci0KLQkJcHVibGljIHN0YXRpYyBmaW5hbCBpbnQgQ09MVU1OX0NPVU5UID0gMjsKLQkJLy9wdWJsaWMgc3RhdGljIGZpbmFsIGludCBTRUxFQ1RJT05fQ09MVU1OID0gMDsKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBpbnQgREFUQV9WQUxVRV9DT0xVTU4gPSAwOwotCQlwdWJsaWMgc3RhdGljIGZpbmFsIGludCBPQkpFQ1RfVkFMVUVfQ09MVU1OID0gMTsKLQotCQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGREYXRhVmFsdWVIb2xkZXIoQ29udmVyc2lvblZhbHVlIHN1YmplY3QpIHsKLQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENvbnZlcnNpb25WYWx1ZSwgU3RyaW5nPihDb252ZXJzaW9uVmFsdWUuREFUQV9WQUxVRV9QUk9QRVJUWSwgc3ViamVjdCkgewotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0RGF0YVZhbHVlKCk7Ci0JCQkJfQotCi0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCQkJCQl0aGlzLnN1YmplY3Quc2V0RGF0YVZhbHVlKHZhbHVlKTsKLQkJCQl9Ci0JCQl9OwotCQl9Ci0KLQkJcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkT2JqZWN0VmFsdWVIb2xkZXIoQ29udmVyc2lvblZhbHVlIHN1YmplY3QpIHsKLQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENvbnZlcnNpb25WYWx1ZSwgU3RyaW5nPihDb252ZXJzaW9uVmFsdWUuT0JKRUNUX1ZBTFVFX1BST1BFUlRZLCBzdWJqZWN0KSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRPYmplY3RWYWx1ZSgpOwotCQkJCX0KLQotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhTdHJpbmcgdmFsdWUpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LnNldE9iamVjdFZhbHVlKHZhbHVlKTsKLQkJCQl9Ci0JCQl9OwotCQl9Ci0KLQkJcHVibGljIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPD8+W10gY2VsbE1vZGVscyhDb252ZXJzaW9uVmFsdWUgc3ViamVjdCkgewotCQkJV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Pz5bXSBob2xkZXJzID0gbmV3IFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPD8+W0NPTFVNTl9DT1VOVF07Ci0JCQkvL2hvbGRlcnNbU0VMRUNUSU9OX0NPTFVNTl0gPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4oKTsKLQkJCWhvbGRlcnNbREFUQV9WQUxVRV9DT0xVTU5dICAgICAgPSBidWlsZERhdGFWYWx1ZUhvbGRlcihzdWJqZWN0KTsKLQkJCWhvbGRlcnNbT0JKRUNUX1ZBTFVFX0NPTFVNTl0gICAgID0gYnVpbGRPYmplY3RWYWx1ZUhvbGRlcihzdWJqZWN0KTsKLQkJCXJldHVybiBob2xkZXJzOwotCQl9Ci0KLQkJcHVibGljIGludCBjb2x1bW5Db3VudCgpIHsKLQkJCXJldHVybiBDT0xVTU5fQ09VTlQ7Ci0JCX0KLQotCQlwdWJsaWMgU3RyaW5nIGNvbHVtbk5hbWUoaW50IGNvbHVtbkluZGV4KSB7Ci0KLQkJCXN3aXRjaCAoY29sdW1uSW5kZXgpIHsKLQkJCQljYXNlIENvbnZlcnNpb25WYWx1ZUNvbHVtbkFkYXB0ZXIuREFUQV9WQUxVRV9DT0xVTU46IHsKLQkJCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLk9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGVfY29udmVyc2lvblZhbHVlc0RhdGFWYWx1ZUNvbHVtbjsKLQkJCQl9Ci0KLQkJCQljYXNlIENvbnZlcnNpb25WYWx1ZUNvbHVtbkFkYXB0ZXIuT0JKRUNUX1ZBTFVFX0NPTFVNTjogewotCQkJCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuT2JqZWN0VHlwZUNvbnZlcnRlckNvbXBvc2l0ZV9jb252ZXJzaW9uVmFsdWVzT2JqZWN0VmFsdWVDb2x1bW47Ci0JCQkJfQotCi0JCQkJZGVmYXVsdDogewotCQkJCQlyZXR1cm4gbnVsbDsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL1ByaXZhdGVPd25lZENvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9Qcml2YXRlT3duZWRDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTI1MjAyMy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL1ByaXZhdGVPd25lZENvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNjcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuUHJpdmF0ZU93bmVkOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBUaGlzIGNvbXBvc2l0ZSBzaW1wbHkgc2hvd3MgdGhlIExvYiBjaGVjayBib3guCi0gKgotICogQHNlZSBCYXNpY01hcHBpbmcKLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIFByaXZhdGVPd25lZENvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPFByaXZhdGVPd25lZD4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPlByaXZhdGVPd25lZENvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgUHJpdmF0ZU93bmVkQ29tcG9zaXRlKEZvcm1QYW5lPD8+IHBhcmVudFBhbmUsIAotCQlQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFByaXZhdGVPd25lZD4gc3ViamVjdEhvbGRlciwKLQkJQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCQlzdXBlcihwYXJlbnRQYW5lLCBzdWJqZWN0SG9sZGVyLCBwYXJlbnQpOwotCX0KLQkKLQlwcml2YXRlIFByb3BlcnR5QXNwZWN0QWRhcHRlcjxQcml2YXRlT3duZWQsIEJvb2xlYW4+IGJ1aWxkUHJpdmF0ZU93bmVkSG9sZGVyKCkgewotCi0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFByaXZhdGVPd25lZCwgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBQcml2YXRlT3duZWQuUFJJVkFURV9PV05FRF9QUk9QRVJUWSkgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBCb29sZWFuLnZhbHVlT2YodGhpcy5zdWJqZWN0LmlzUHJpdmF0ZU93bmVkKCkpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldFByaXZhdGVPd25lZCh2YWx1ZS5ib29sZWFuVmFsdWUoKSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCWFkZENoZWNrQm94KAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuUHJpdmF0ZU93bmVkQ29tcG9zaXRlX3ByaXZhdGVPd25lZExhYmVsLAotCQkJYnVpbGRQcml2YXRlT3duZWRIb2xkZXIoKSwKLQkJCW51bGwKLQkJKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL1JlYWRPbmx5Q29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL1JlYWRPbmx5Q29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDVkMzdlZDAuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9SZWFkT25seUNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTEzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LlJlYWRPbmx5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuSnB0VWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogVGhpcyBjb21wb3NpdGUgc2ltcGx5IHNob3dzIHRoZSBSZWFkIE9ubHkgY2hlY2sgYm94LgotICoKLSAqIEBzZWUgUmVhZE9ubHkKLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIFJlYWRPbmx5Q29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8UmVhZE9ubHk+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5SZWFkT25seUNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgUmVhZE9ubHlDb21wb3NpdGUoRm9ybVBhbmU8Pz4gcGFyZW50UGFuZSwgCi0JCVByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgUmVhZE9ubHk+IHN1YmplY3RIb2xkZXIsCi0JCUNvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQkJc3VwZXIocGFyZW50UGFuZSwgc3ViamVjdEhvbGRlciwgcGFyZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJLy8gVW5pcXVlIHRyaS1zdGF0ZSBjaGVjayBib3gKLQkJYWRkVHJpU3RhdGVDaGVja0JveFdpdGhEZWZhdWx0KAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuUmVhZE9ubHlDb21wb3NpdGVfcmVhZE9ubHlMYWJlbCwKLQkJCWJ1aWxkUmVhZE9ubHlIb2xkZXIoKSwKLQkJCWJ1aWxkUmVhZE9ubHlTdHJpbmdIb2xkZXIoKSwKLQkJCW51bGwKLQkJKTsKLQl9Ci0JCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZFJlYWRPbmx5SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxSZWFkT25seSwgQm9vbGVhbj4oCi0JCQlnZXRTdWJqZWN0SG9sZGVyKCksCi0JCQlSZWFkT25seS5ERUZBVUxUX1JFQURfT05MWV9QUk9QRVJUWSwKLQkJCVJlYWRPbmx5LlNQRUNJRklFRF9SRUFEX09OTFlfUFJPUEVSVFkpCi0JCXsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRTcGVjaWZpZWRSZWFkT25seSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldFNwZWNpZmllZFJlYWRPbmx5KHZhbHVlKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzdWJqZWN0Q2hhbmdlZCgpIHsKLQkJCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0JCQkJc3VwZXIuc3ViamVjdENoYW5nZWQoKTsKLQkJCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0KLQkJCQkvLyBNYWtlIHN1cmUgdGhlIGRlZmF1bHQgdmFsdWUgaXMgYXBwZW5kZWQgdG8gdGhlIHRleHQKLQkJCQlpZiAob2xkVmFsdWUgPT0gbmV3VmFsdWUgJiYgbmV3VmFsdWUgPT0gbnVsbCkgewotCQkJCQl0aGlzLmZpcmVBc3BlY3RDaGFuZ2UoQm9vbGVhbi5UUlVFLCBuZXdWYWx1ZSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRSZWFkT25seVN0cmluZ0hvbGRlcigpIHsKLQotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4sIFN0cmluZz4oYnVpbGRSZWFkT25seUhvbGRlcigpKSB7Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oQm9vbGVhbiB2YWx1ZSkgewotCi0JCQkJaWYgKChnZXRTdWJqZWN0KCkgIT0gbnVsbCkgJiYgKHZhbHVlID09IG51bGwpKSB7Ci0KLQkJCQkJYm9vbGVhbiBkZWZhdWx0VmFsdWUgPSBnZXRTdWJqZWN0KCkuaXNEZWZhdWx0UmVhZE9ubHkoKTsKLQotCQkJCQlTdHJpbmcgZGVmYXVsdFN0cmluZ1ZhbHVlID0gZGVmYXVsdFZhbHVlID8gSnB0VWlNYXBwaW5nc01lc3NhZ2VzLkJvb2xlYW5fVHJ1ZSA6Ci0JCQkJCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBKcHRVaU1hcHBpbmdzTWVzc2FnZXMuQm9vbGVhbl9GYWxzZTsKLQotCQkJCQlyZXR1cm4gTkxTLmJpbmQoCi0JCQkJCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5SZWFkT25seUNvbXBvc2l0ZV9yZWFkT25seVdpdGhEZWZhdWx0LAotCQkJCQkJZGVmYXVsdFN0cmluZ1ZhbHVlCi0JCQkJCSk7Ci0JCQkJfQotCi0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLlJlYWRPbmx5Q29tcG9zaXRlX3JlYWRPbmx5TGFiZWw7Ci0JCQl9Ci0JCX07Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL1JlZnJlc2hPbmx5SWZOZXdlckNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9SZWZyZXNoT25seUlmTmV3ZXJDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjg3MDlmZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL1JlZnJlc2hPbmx5SWZOZXdlckNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTEyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLkpwdFVpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFRoaXMgY29tcG9zaXRlIHNpbXBseSBzaG93cyBhIHRyaS1zdGF0ZSBjaGVjayBib3ggZm9yIHRoZSBSZWZyZXNoIE9ubHkgSWYgTmV3ZXIgb3B0aW9uLgotICogCi0gKiBAc2VlIEVjbGlwc2VMaW5rQ2FjaGluZwotICogQHNlZSBDYWNoaW5nQ29tcG9zaXRlIC0gQSBjb250YWluZXIgb2YgdGhpcyB3aWRnZXQKLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIFJlZnJlc2hPbmx5SWZOZXdlckNvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPENhY2hpbmc+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5PcHRpb25hbENvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgUmVmcmVzaE9ubHlJZk5ld2VyQ29tcG9zaXRlKEZvcm1QYW5lPD8gZXh0ZW5kcyBDYWNoaW5nPiBwYXJlbnRQYW5lLAotCSAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KQotCXsKLQkJc3VwZXIocGFyZW50UGFuZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkUmVmcmVzaE9ubHlJZk5ld2VySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDYWNoaW5nLCBCb29sZWFuPihnZXRTdWJqZWN0SG9sZGVyKCksIENhY2hpbmcuU1BFQ0lGSUVEX1JFRlJFU0hfT05MWV9JRl9ORVdFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldFNwZWNpZmllZFJlZnJlc2hPbmx5SWZOZXdlcigpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldFNwZWNpZmllZFJlZnJlc2hPbmx5SWZOZXdlcih2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc3ViamVjdENoYW5nZWQoKSB7Ci0JCQkJT2JqZWN0IG9sZFZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCQkJCXN1cGVyLnN1YmplY3RDaGFuZ2VkKCk7Ci0JCQkJT2JqZWN0IG5ld1ZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCi0JCQkJLy8gTWFrZSBzdXJlIHRoZSBkZWZhdWx0IHZhbHVlIGlzIGFwcGVuZGVkIHRvIHRoZSB0ZXh0Ci0JCQkJaWYgKG9sZFZhbHVlID09IG5ld1ZhbHVlICYmIG5ld1ZhbHVlID09IG51bGwpIHsKLQkJCQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKEJvb2xlYW4uVFJVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkUmVmcmVzaE9ubHlJZk5ld2VyU3RyaW5nSG9sZGVyKCkgewotCi0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbiwgU3RyaW5nPihidWlsZFJlZnJlc2hPbmx5SWZOZXdlckhvbGRlcigpKSB7Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oQm9vbGVhbiB2YWx1ZSkgewotCi0JCQkJaWYgKChnZXRTdWJqZWN0KCkgIT0gbnVsbCkgJiYgKHZhbHVlID09IG51bGwpKSB7Ci0KLQkJCQkJQm9vbGVhbiBkZWZhdWx0VmFsdWUgPSBnZXRTdWJqZWN0KCkuaXNEZWZhdWx0UmVmcmVzaE9ubHlJZk5ld2VyKCk7Ci0KLQkJCQkJaWYgKGRlZmF1bHRWYWx1ZSAhPSBudWxsKSB7Ci0KLQkJCQkJCVN0cmluZyBkZWZhdWx0U3RyaW5nVmFsdWUgPSBkZWZhdWx0VmFsdWUgPyBKcHRVaU1hcHBpbmdzTWVzc2FnZXMuQm9vbGVhbl9UcnVlIDoKLQkJCQkJCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBKcHRVaU1hcHBpbmdzTWVzc2FnZXMuQm9vbGVhbl9GYWxzZTsKLQotCQkJCQkJcmV0dXJuIE5MUy5iaW5kKAotCQkJCQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLlJlZnJlc2hPbmx5SWZOZXdlckNvbXBvc2l0ZV9yZWZyZXNoT25seUlmTmV3ZXJEZWZhdWx0LAotCQkJCQkJCWRlZmF1bHRTdHJpbmdWYWx1ZQotCQkJCQkJKTsKLQkJCQkJfQotCQkJCX0KLQotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5SZWZyZXNoT25seUlmTmV3ZXJDb21wb3NpdGVfcmVmcmVzaE9ubHlJZk5ld2VyTGFiZWw7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCWFkZFRyaVN0YXRlQ2hlY2tCb3hXaXRoRGVmYXVsdCgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLlJlZnJlc2hPbmx5SWZOZXdlckNvbXBvc2l0ZV9yZWZyZXNoT25seUlmTmV3ZXJMYWJlbCwKLQkJCWJ1aWxkUmVmcmVzaE9ubHlJZk5ld2VySG9sZGVyKCksCi0JCQlidWlsZFJlZnJlc2hPbmx5SWZOZXdlclN0cmluZ0hvbGRlcigpLAotCQkJRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcy5DQUNISU5HX1JFRlJFU0hfT05MWV9JRl9ORVdFUgotCQkpOwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL1N0cnVjdENvbnZlcnRlckNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9TdHJ1Y3RDb252ZXJ0ZXJDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODE3MDA5NC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL1N0cnVjdENvbnZlcnRlckNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTUyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiAgQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcwotICogIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YKLSAqICB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMKLSAqICBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSAqCi0gKiAgQ29udHJpYnV0b3JzOiBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcGFQcm9qZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuRWNsaXBzZUxpbmtDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5TdHJ1Y3RDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLkVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLlBhbmVFbmFibGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkNsYXNzQ2hvb3NlclBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogSGVyZSB0aGUgbGF5b3V0IG9mIHRoaXMgcGFuZToKLSAqIDxwcmU+Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotICogfCAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgTmFtZTogICAgICB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHx8Ci0gKiB8ICAgICAgICAgICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS08L3ByZT4KLSAqCi0gKiBAc2VlIEVjbGlwc2VMaW5rQ29udmVydGVyCi0gKiBAc2VlIENvbnZlcnRDb21wb3NpdGUgLSBBIGNvbnRhaW5lciBvZiB0aGlzIHdpZGdldAotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgU3RydWN0Q29udmVydGVyQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8U3RydWN0Q29udmVydGVyPgotewotCi0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5TdHJ1Y3RDb252ZXJ0ZXJDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudFBhbmUgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIFN0cnVjdENvbnZlcnRlckNvbXBvc2l0ZShQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFN0cnVjdENvbnZlcnRlcj4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQkKLQkJYWRkTGFiZWxlZFRleHQoCi0JCQljb250YWluZXIsIAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQ29udmVydGVyQ29tcG9zaXRlX25hbWVUZXh0TGFiZWwsIAotCQkJYnVpbGROYW1lVGV4dEhvbGRlcigpKTsKLQkJCi0JCWFkZENsYXNzQ2hvb3Nlcihjb250YWluZXIpOwotCQkKLQkJbmV3IFBhbmVFbmFibGVyKGJ1aWxkQm9vbGVhbkhvbGRlcigpLCB0aGlzKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGROYW1lVGV4dEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8U3RydWN0Q29udmVydGVyLCBTdHJpbmc+KAotCQkJCWdldFN1YmplY3RIb2xkZXIoKSwgRWNsaXBzZUxpbmtDb252ZXJ0ZXIuTkFNRV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0TmFtZSgpOwotCQkJfQotCQkKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQkJCXZhbHVlID0gbnVsbDsKLQkJCQl9Ci0JCQkJdGhpcy5zdWJqZWN0LnNldE5hbWUodmFsdWUpOwotCQkJfQotCQl9OwotCX0KLQotCQotCXByaXZhdGUgQ2xhc3NDaG9vc2VyUGFuZTxTdHJ1Y3RDb252ZXJ0ZXI+IGFkZENsYXNzQ2hvb3NlcihDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJcmV0dXJuIG5ldyBDbGFzc0Nob29zZXJQYW5lPFN0cnVjdENvbnZlcnRlcj4odGhpcywgY29udGFpbmVyKSB7Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRUZXh0SG9sZGVyKCkgewotCQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFN0cnVjdENvbnZlcnRlciwgU3RyaW5nPihnZXRTdWJqZWN0SG9sZGVyKCksIFN0cnVjdENvbnZlcnRlci5DT05WRVJURVJfQ0xBU1NfUFJPUEVSVFkpIHsKLQkJCQkJQE92ZXJyaWRlCi0JCQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldENvbnZlcnRlckNsYXNzKCk7Ci0JCQkJCX0KLQotCQkJCQlAT3ZlcnJpZGUKLQkJCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCi0JCQkJCQlpZiAodmFsdWUubGVuZ3RoKCkgPT0gMCkgewotCQkJCQkJCXZhbHVlID0gbnVsbDsKLQkJCQkJCX0KLQotCQkJCQkJdGhpcy5zdWJqZWN0LnNldENvbnZlcnRlckNsYXNzKHZhbHVlKTsKLQkJCQkJfQotCQkJCX07Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBnZXRDbGFzc05hbWUoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXRDb252ZXJ0ZXJDbGFzcygpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZ2V0TGFiZWxUZXh0KCkgewotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJ0ZXJDb21wb3NpdGVfY2xhc3NMYWJlbDsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSnBhUHJvamVjdCBnZXRKcGFQcm9qZWN0KCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0SnBhUHJvamVjdCgpOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldENsYXNzTmFtZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCQkJZ2V0U3ViamVjdCgpLnNldENvbnZlcnRlckNsYXNzKGNsYXNzTmFtZSk7Ci0JCQl9Ci0JCQkKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBnZXRTdXBlckludGVyZmFjZU5hbWUoKSB7Ci0JCQkJcmV0dXJuIFN0cnVjdENvbnZlcnRlci5FQ0xJUFNFTElOS19TVFJVQ1RfQ09OVkVSVEVSX0NMQVNTX05BTUU7Ci0JCQl9Ci0JCQkKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGNoYXIgZ2V0RW5jbG9zaW5nVHlwZVNlcGFyYXRvcigpIHsKLQkJCQlyZXR1cm4gZ2V0U3ViamVjdCgpLmdldEVuY2xvc2luZ1R5cGVTZXBhcmF0b3IoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkQm9vbGVhbkhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxTdHJ1Y3RDb252ZXJ0ZXIsIEJvb2xlYW4+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiB0cmFuc2Zvcm0oU3RydWN0Q29udmVydGVyIHZhbHVlKSB7Ci0JCQkJcmV0dXJuIEJvb2xlYW4udmFsdWVPZih2YWx1ZSAhPSBudWxsKTsKLQkJCX0KLQkJfTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL1RyYW5zZm9ybWF0aW9uTWFwcGluZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9UcmFuc2Zvcm1hdGlvbk1hcHBpbmdDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMmQ3MGIyMy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL1RyYW5zZm9ybWF0aW9uTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5UcmFuc2Zvcm1hdGlvbk1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgVHJhbnNmb3JtYXRpb25NYXBwaW5nQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8VHJhbnNmb3JtYXRpb25NYXBwaW5nPgotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW1wbGVtZW50cyBKcGFDb21wb3NpdGUKLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkVjbGlwc2VMaW5rQmFzaWNDb2xsZWN0aW9uTWFwcGluZ0NvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gc3ViamVjdEhvbGRlciBUaGUgaG9sZGVyIG9mIHRoZSBzdWJqZWN0IDxjb2RlPklNYW55VG9PbmVNYXBwaW5nPC9jb2RlPgotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKiBAcGFyYW0gd2lkZ2V0RmFjdG9yeSBUaGUgZmFjdG9yeSB1c2VkIHRvIGNyZWF0ZSB2YXJpb3VzIGNvbW1vbiB3aWRnZXRzCi0JICovCi0JcHVibGljIFRyYW5zZm9ybWF0aW9uTWFwcGluZ0NvbXBvc2l0ZShQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFRyYW5zZm9ybWF0aW9uTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50LAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9tYXBwaW5ncy9kZXRhaWxzL1R5cGVDb252ZXJ0ZXJDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvVHlwZUNvbnZlcnRlckNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2MDA5YmViLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvVHlwZUNvbnZlcnRlckNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTk5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiAgQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcwotICogIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YKLSAqICB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMKLSAqICBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSAqCi0gKiAgQ29udHJpYnV0b3JzOiBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcGFQcm9qZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuRWNsaXBzZUxpbmtDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5UeXBlQ29udmVydGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwudXRpbC5QYW5lRW5hYmxlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5DbGFzc0Nob29zZXJQYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIEhlcmUgdGhlIGxheW91dCBvZiB0aGlzIHBhbmU6Ci0gKiA8cHJlPgotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLSAqIHwgICAgICAgICAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IE5hbWU6ICAgICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8fAotICogfCAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSBFY2xpcHNlTGlua0NvbnZlcnRlcgotICogQHNlZSBDb252ZXJ0Q29tcG9zaXRlIC0gQSBjb250YWluZXIgb2YgdGhpcyB3aWRnZXQKLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIFR5cGVDb252ZXJ0ZXJDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxUeXBlQ29udmVydGVyPgotewotCi0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5UeXBlQ29udmVydGVyQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRQYW5lIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBUeXBlQ29udmVydGVyQ29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgVHlwZUNvbnZlcnRlcj4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQkKLQkJYWRkTGFiZWxlZFRleHQoCi0JCQljb250YWluZXIsIAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQ29udmVydGVyQ29tcG9zaXRlX25hbWVUZXh0TGFiZWwsIAotCQkJYnVpbGROYW1lVGV4dEhvbGRlcigpKTsKLQkJCi0JCWFkZERhdGFUeXBlQ2hvb3Nlcihjb250YWluZXIpOwotCQlhZGRPYmplY3RUeXBlQ2hvb3Nlcihjb250YWluZXIpOwotCQkKLQkJbmV3IFBhbmVFbmFibGVyKGJ1aWxkQm9vbGVhbkhvbGRlcigpLCB0aGlzKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGROYW1lVGV4dEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VHlwZUNvbnZlcnRlciwgU3RyaW5nPigKLQkJCQlnZXRTdWJqZWN0SG9sZGVyKCksIEVjbGlwc2VMaW5rQ29udmVydGVyLk5BTUVfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldE5hbWUoKTsKLQkJCX0KLQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhTdHJpbmcgdmFsdWUpIHsKLQkJCQlpZiAodmFsdWUubGVuZ3RoKCkgPT0gMCkgewotCQkJCQl2YWx1ZSA9IG51bGw7Ci0JCQkJfQotCQkJCXRoaXMuc3ViamVjdC5zZXROYW1lKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQkKLQlwcml2YXRlIENsYXNzQ2hvb3NlclBhbmU8VHlwZUNvbnZlcnRlcj4gYWRkRGF0YVR5cGVDaG9vc2VyKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlyZXR1cm4gbmV3IENsYXNzQ2hvb3NlclBhbmU8VHlwZUNvbnZlcnRlcj4odGhpcywgY29udGFpbmVyKSB7Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRUZXh0SG9sZGVyKCkgewotCQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFR5cGVDb252ZXJ0ZXIsIFN0cmluZz4oZ2V0U3ViamVjdEhvbGRlcigpLCBUeXBlQ29udmVydGVyLkRBVEFfVFlQRV9QUk9QRVJUWSkgewotCQkJCQlAT3ZlcnJpZGUKLQkJCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0RGF0YVR5cGUoKTsKLQkJCQkJfQotCi0JCQkJCUBPdmVycmlkZQotCQkJCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0KLQkJCQkJCWlmICh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQkJCQkJdmFsdWUgPSBudWxsOwotCQkJCQkJfQotCi0JCQkJCQl0aGlzLnN1YmplY3Quc2V0RGF0YVR5cGUodmFsdWUpOwotCQkJCQl9Ci0JCQkJfTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGdldENsYXNzTmFtZSgpIHsKLQkJCQlyZXR1cm4gZ2V0U3ViamVjdCgpLmdldERhdGFUeXBlKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBnZXRMYWJlbFRleHQoKSB7Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLlR5cGVDb252ZXJ0ZXJDb21wb3NpdGVfZGF0YVR5cGVMYWJlbDsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSnBhUHJvamVjdCBnZXRKcGFQcm9qZWN0KCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0SnBhUHJvamVjdCgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldENsYXNzTmFtZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCQkJZ2V0U3ViamVjdCgpLnNldERhdGFUeXBlKGNsYXNzTmFtZSk7Ci0JCQl9Ci0JCQkKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGNoYXIgZ2V0RW5jbG9zaW5nVHlwZVNlcGFyYXRvcigpIHsKLQkJCQlyZXR1cm4gZ2V0U3ViamVjdCgpLmdldEVuY2xvc2luZ1R5cGVTZXBhcmF0b3IoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENsYXNzQ2hvb3NlclBhbmU8VHlwZUNvbnZlcnRlcj4gYWRkT2JqZWN0VHlwZUNob29zZXIoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXJldHVybiBuZXcgQ2xhc3NDaG9vc2VyUGFuZTxUeXBlQ29udmVydGVyPih0aGlzLCBjb250YWluZXIpIHsKLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFRleHRIb2xkZXIoKSB7Ci0JCQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VHlwZUNvbnZlcnRlciwgU3RyaW5nPihnZXRTdWJqZWN0SG9sZGVyKCksIFR5cGVDb252ZXJ0ZXIuT0JKRUNUX1RZUEVfUFJPUEVSVFkpIHsKLQkJCQkJQE92ZXJyaWRlCi0JCQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldE9iamVjdFR5cGUoKTsKLQkJCQkJfQotCi0JCQkJCUBPdmVycmlkZQotCQkJCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0KLQkJCQkJCWlmICh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQkJCQkJdmFsdWUgPSBudWxsOwotCQkJCQkJfQotCi0JCQkJCQl0aGlzLnN1YmplY3Quc2V0T2JqZWN0VHlwZSh2YWx1ZSk7Ci0JCQkJCX0KLQkJCQl9OwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZ2V0Q2xhc3NOYW1lKCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0T2JqZWN0VHlwZSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZ2V0TGFiZWxUZXh0KCkgewotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5UeXBlQ29udmVydGVyQ29tcG9zaXRlX29iamVjdFR5cGVMYWJlbDsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSnBhUHJvamVjdCBnZXRKcGFQcm9qZWN0KCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0SnBhUHJvamVjdCgpOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldENsYXNzTmFtZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCQkJZ2V0U3ViamVjdCgpLnNldE9iamVjdFR5cGUoY2xhc3NOYW1lKTsKLQkJCX0KLQkJCQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgY2hhciBnZXRFbmNsb3NpbmdUeXBlU2VwYXJhdG9yKCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0RW5jbG9zaW5nVHlwZVNlcGFyYXRvcigpOwotCQkJfQotCQl9OwotCX0KLQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRCb29sZWFuSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPFR5cGVDb252ZXJ0ZXIsIEJvb2xlYW4+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiB0cmFuc2Zvcm0oVHlwZUNvbnZlcnRlciB2YWx1ZSkgewotCQkJCXJldHVybiBCb29sZWFuLnZhbHVlT2YodmFsdWUgIT0gbnVsbCk7Ci0JCQl9Ci0JCX07Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9WYXJpYWJsZU9uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvbWFwcGluZ3MvZGV0YWlscy9WYXJpYWJsZU9uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhZTY0NzVhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL21hcHBpbmdzL2RldGFpbHMvVmFyaWFibGVPbmVUb09uZU1hcHBpbmdDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQ1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuVmFyaWFibGVPbmVUb09uZU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICoKLSAqIEB2ZXJzaW9uIDIuMgotICogQHNpbmNlIDIuMgotICovCi1wdWJsaWMgY2xhc3MgVmFyaWFibGVPbmVUb09uZU1hcHBpbmdDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxWYXJpYWJsZU9uZVRvT25lTWFwcGluZz4KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGltcGxlbWVudHMgSnBhQ29tcG9zaXRlCi17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5FY2xpcHNlTGlua0Jhc2ljQ29sbGVjdGlvbk1hcHBpbmdDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHN1YmplY3RIb2xkZXIgVGhlIGhvbGRlciBvZiB0aGUgc3ViamVjdCA8Y29kZT5JTWFueVRvT25lTWFwcGluZzwvY29kZT4KLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICogQHBhcmFtIHdpZGdldEZhY3RvcnkgVGhlIGZhY3RvcnkgdXNlZCB0byBjcmVhdGUgdmFyaW91cyBjb21tb24gd2lkZ2V0cwotCSAqLwotCXB1YmxpYyBWYXJpYWJsZU9uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZShQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFZhcmlhYmxlT25lVG9PbmVNYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0NvbnZlcnRlcnNDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0NvbnZlcnRlcnNDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTk3N2ZlOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9Db252ZXJ0ZXJzQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0MDcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5JTGFiZWxQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLkxhYmVsUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uud2luZG93LldpbmRvdzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkN1c3RvbUNvbnZlcnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkVjbGlwc2VMaW5rQ29udmVydGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuT2JqZWN0VHlwZUNvbnZlcnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LlN0cnVjdENvbnZlcnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LlR5cGVDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5vcm0uQ29udmVydGVySG9sZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkN1c3RvbUNvbnZlcnRlckNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5PYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLlN0cnVjdENvbnZlcnRlckNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5UeXBlQ29udmVydGVyQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLkNvbnRyb2xTd2l0Y2hlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5BZGRSZW1vdmVMaXN0UGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkFkZFJlbW92ZVBhbmUuQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5UcmFuc2Zvcm1lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuVHJhbnNmb3JtYXRpb25JdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Db21wb3NpdGVMaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5JdGVtUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuTGlzdEFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLk9iamVjdExpc3RTZWxlY3Rpb25Nb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LlNXVDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWREYXRhOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db250cm9sOwotaW1wb3J0IG9yZy5lY2xpcHNlLnVpLnBhcnQuUGFnZUJvb2s7Ci0KLS8qKgotICogVGhpcyBwYW5lIHNob3dzIHRoZSBsaXN0IG9mIG5hbWVkIHF1ZXJpZXMgYW5kIG5hbWVkIG5hdGl2ZSBxdWVyaWVzLgotICogPHA+Ci0gKiBIZXJlIHRoZSBsYXlvdXQgb2YgdGhpcyBwYW5lOgotICogPHByZT4KLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBBZGRSZW1vdmVMaXN0UGFuZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IENvbnZlcnRlckNvbXBvc2l0ZSBvciBPYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBvciBTdHJ1Y3RDb252ZXJ0ZXJDb21wb3NpdGUgb3IgVHlwZUNvbnZlcnRlckNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSBFbnRpdHkKLSAqIEBzZWUgUXVlcnkKLSAqIEBzZWUgTmFtZWROYXRpdmVRdWVyeQotICogQHNlZSBOYW1lZFF1ZXJ5Ci0gKiBAc2VlIEFic3RyYWN0RW50aXR5Q29tcG9zaXRlIC0gVGhlIHBhcmVudCBjb250YWluZXIKLSAqIEBzZWUgTmFtZWROYXRpdmVRdWVyeVByb3BlcnR5Q29tcG9zaXRlCi0gKiBAc2VlIE5hbWVkUXVlcnlQcm9wZXJ0eUNvbXBvc2l0ZQotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgQ29udmVydGVyc0NvbXBvc2l0ZSBleHRlbmRzIFBhbmU8Q29udmVydGVySG9sZGVyPgotewotCXByaXZhdGUgQWRkUmVtb3ZlTGlzdFBhbmU8Q29udmVydGVySG9sZGVyPiBsaXN0UGFuZTsKLQlwcml2YXRlIEN1c3RvbUNvbnZlcnRlckNvbXBvc2l0ZSBjb252ZXJ0ZXJDb21wb3NpdGU7Ci0JcHJpdmF0ZSBPYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlIG9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGU7Ci0JcHJpdmF0ZSBTdHJ1Y3RDb252ZXJ0ZXJDb21wb3NpdGUgc3RydWN0Q29udmVydGVyQ29tcG9zaXRlOwotCXByaXZhdGUgVHlwZUNvbnZlcnRlckNvbXBvc2l0ZSB0eXBlQ29udmVydGVyQ29tcG9zaXRlOwotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtDb252ZXJ0ZXI+IHNlbGVjdGVkQ29udmVydGVySG9sZGVyOwotCi0JcHVibGljIENvbnZlcnRlcnNDb21wb3NpdGUoCi0JCUZvcm1QYW5lPD8+IHBhcmVudFBhbmUsIAotCQlQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIENvbnZlcnRlckhvbGRlcj4gc3ViamVjdEhvbGRlciwKLQkJQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCQlzdXBlcihwYXJlbnRQYW5lLCBzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIGZhbHNlKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplKCkgewotCQlzdXBlci5pbml0aWFsaXplKCk7Ci0JCXRoaXMuc2VsZWN0ZWRDb252ZXJ0ZXJIb2xkZXIgPSBidWlsZFNlbGVjdGVkQ29udmVydGVySG9sZGVyKCk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua0NvbnZlcnRlcj4gYnVpbGRTZWxlY3RlZENvbnZlcnRlckhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtDb252ZXJ0ZXI+KCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJLy8gTGlzdCBwYW5lCi0JCXRoaXMubGlzdFBhbmUgPSBhZGRMaXN0UGFuZShjb250YWluZXIpOwotCi0JCS8vIFByb3BlcnR5IHBhbmUKLQkJUGFnZUJvb2sgcGFnZUJvb2sgPSBuZXcgUGFnZUJvb2soY29udGFpbmVyLCBTV1QuTlVMTCk7Ci0JCXBhZ2VCb29rLnNldExheW91dERhdGEobmV3IEdyaWREYXRhKEdyaWREYXRhLkZJTExfSE9SSVpPTlRBTCkpOwotCi0JCXRoaXMuY29udmVydGVyQ29tcG9zaXRlID0gbmV3IEN1c3RvbUNvbnZlcnRlckNvbXBvc2l0ZSgKLQkJCWJ1aWxkQ3VzdG9tQ29udmVydGVySG9sZGVyKCksCi0JCQlwYWdlQm9vaywKLQkJCWdldFdpZGdldEZhY3RvcnkoKQotCQkpOwotCQlyZWdpc3RlclN1YlBhbmUodGhpcy5jb252ZXJ0ZXJDb21wb3NpdGUpOwotCQkKLQkJdGhpcy5vYmplY3RUeXBlQ29udmVydGVyQ29tcG9zaXRlID0gbmV3IE9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGUoCi0JCQlidWlsZE9iamVjdFR5cGVDb252ZXJ0ZXJIb2xkZXIoKSwKLQkJCXBhZ2VCb29rLAotCQkJZ2V0V2lkZ2V0RmFjdG9yeSgpCi0JCSk7Ci0JCXJlZ2lzdGVyU3ViUGFuZSh0aGlzLm9iamVjdFR5cGVDb252ZXJ0ZXJDb21wb3NpdGUpOwotCQkKLQkJdGhpcy5zdHJ1Y3RDb252ZXJ0ZXJDb21wb3NpdGUgPSBuZXcgU3RydWN0Q29udmVydGVyQ29tcG9zaXRlKAotCQkJYnVpbGRTdHJ1Y3RDb252ZXJ0ZXJIb2xkZXIoKSwKLQkJCXBhZ2VCb29rLAotCQkJZ2V0V2lkZ2V0RmFjdG9yeSgpCi0JCSk7Ci0JCXJlZ2lzdGVyU3ViUGFuZSh0aGlzLnN0cnVjdENvbnZlcnRlckNvbXBvc2l0ZSk7Ci0JCQotCQl0aGlzLnR5cGVDb252ZXJ0ZXJDb21wb3NpdGUgPSBuZXcgVHlwZUNvbnZlcnRlckNvbXBvc2l0ZSgKLQkJCWJ1aWxkVHlwZUNvbnZlcnRlckhvbGRlcigpLAotCQkJcGFnZUJvb2ssCi0JCQlnZXRXaWRnZXRGYWN0b3J5KCkKLQkJKTsKLQkJcmVnaXN0ZXJTdWJQYW5lKHRoaXMudHlwZUNvbnZlcnRlckNvbXBvc2l0ZSk7Ci0KLQkJaW5zdGFsbFBhbmVTd2l0Y2hlcihwYWdlQm9vayk7Ci0JfQotCi0JcHJpdmF0ZSBBZGRSZW1vdmVMaXN0UGFuZTxDb252ZXJ0ZXJIb2xkZXI+IGFkZExpc3RQYW5lKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlyZXR1cm4gbmV3IEFkZFJlbW92ZUxpc3RQYW5lPENvbnZlcnRlckhvbGRlcj4oCi0JCQl0aGlzLAotCQkJY29udGFpbmVyLAotCQkJYnVpbGRDb252ZXJ0ZXJzQWRhcHRlcigpLAotCQkJYnVpbGREaXNwbGF5YWJsZUNvbnZlcnRlcnNMaXN0SG9sZGVyKCksCi0JCQl0aGlzLnNlbGVjdGVkQ29udmVydGVySG9sZGVyLAotCQkJYnVpbGRDb252ZXJ0ZXJzTGlzdExhYmVsUHJvdmlkZXIoKSwKLQkJCW51bGwvL0pwYUhlbHBDb250ZXh0SWRzLk1BUFBJTkdfTkFNRURfUVVFUklFUwotCQkpIHsKLQkJCS8vVE9ETyB5ZWFoLCB0aGlzIGlzIHdlaXJkLCBidXQgaSBkb24ndCB3YW50IHRoaXMgdG8gYmUgZGlzYWJsZWQganVzdAotCQkJLy9iZWNhdXNlIHRoZSBzdWJqZWN0IGlzIG51bGwuIGkgaGF2ZSBubyBuZWVkIGZvciB0aGF0IGFuZCB0aGF0IGlzCi0JCQkvL2N1cnJlbnRseSBob3cgQWRkUmVtb3ZlUGFuZSB3b3Jrcy4gIFNlZSBPcm1RdWVyaWVzQ29tcG9zaXRlIHdoZXJlCi0JCQkvL3RoZSB3b3JrIGFyb3VuZCB0aGVyZSBpcyB5ZXQgYW5vdGhlciBwYW5lIGVuYWJsZXIuICBJIHdhbnQgdG8gY2hhbmdlCi0JCQkvL2hvdyB0aGlzIHdvcmtzIGluIDIuMgotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBlbmFibGVXaWRnZXRzKGJvb2xlYW4gZW5hYmxlZCkgewotCQkJCXN1cGVyLmVuYWJsZVdpZGdldHModHJ1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGluc3RhbGxQYW5lU3dpdGNoZXIoUGFnZUJvb2sgcGFnZUJvb2spIHsKLQkJbmV3IENvbnRyb2xTd2l0Y2hlcih0aGlzLnNlbGVjdGVkQ29udmVydGVySG9sZGVyLCBidWlsZFBhbmVUcmFuc2Zvcm1lcigpLCBwYWdlQm9vayk7Ci0JfQotCQotCXByaXZhdGUgQWRhcHRlciBidWlsZENvbnZlcnRlcnNBZGFwdGVyKCkgewotCi0JCXJldHVybiBuZXcgQWRkUmVtb3ZlTGlzdFBhbmUuQWJzdHJhY3RBZGFwdGVyKCkgewotCi0JCQlwdWJsaWMgdm9pZCBhZGROZXdJdGVtKE9iamVjdExpc3RTZWxlY3Rpb25Nb2RlbCBsaXN0U2VsZWN0aW9uTW9kZWwpIHsKLQkJCQlhZGRDb252ZXJ0ZXIoKTsKLQkJCX0KLQotCQkJcHVibGljIHZvaWQgcmVtb3ZlU2VsZWN0ZWRJdGVtcyhPYmplY3RMaXN0U2VsZWN0aW9uTW9kZWwgbGlzdFNlbGVjdGlvbk1vZGVsKSB7Ci0JCQkJZm9yIChPYmplY3QgaXRlbSA6IGxpc3RTZWxlY3Rpb25Nb2RlbC5zZWxlY3RlZFZhbHVlcygpKSB7Ci0JCQkJCWlmICgoKEVjbGlwc2VMaW5rQ29udmVydGVyKSBpdGVtKS5nZXRUeXBlKCkgPT0gRWNsaXBzZUxpbmtDb252ZXJ0ZXIuQ1VTVE9NX0NPTlZFUlRFUikgewotCQkJCQkJZ2V0U3ViamVjdCgpLnJlbW92ZUN1c3RvbUNvbnZlcnRlcigoQ3VzdG9tQ29udmVydGVyKSBpdGVtKTsKLQkJCQkJfQotCQkJCQllbHNlIGlmICgoKEVjbGlwc2VMaW5rQ29udmVydGVyKSBpdGVtKS5nZXRUeXBlKCkgPT0gRWNsaXBzZUxpbmtDb252ZXJ0ZXIuT0JKRUNUX1RZUEVfQ09OVkVSVEVSKSB7Ci0JCQkJCQlnZXRTdWJqZWN0KCkucmVtb3ZlT2JqZWN0VHlwZUNvbnZlcnRlcigoT2JqZWN0VHlwZUNvbnZlcnRlcikgaXRlbSk7Ci0JCQkJCX0KLQkJCQkJZWxzZSBpZiAoKChFY2xpcHNlTGlua0NvbnZlcnRlcikgaXRlbSkuZ2V0VHlwZSgpID09IEVjbGlwc2VMaW5rQ29udmVydGVyLlNUUlVDVF9DT05WRVJURVIpIHsKLQkJCQkJCWdldFN1YmplY3QoKS5yZW1vdmVTdHJ1Y3RDb252ZXJ0ZXIoKFN0cnVjdENvbnZlcnRlcikgaXRlbSk7Ci0JCQkJCX0KLQkJCQkJZWxzZSBpZiAoKChFY2xpcHNlTGlua0NvbnZlcnRlcikgaXRlbSkuZ2V0VHlwZSgpID09IEVjbGlwc2VMaW5rQ29udmVydGVyLlRZUEVfQ09OVkVSVEVSKSB7Ci0JCQkJCQlnZXRTdWJqZWN0KCkucmVtb3ZlVHlwZUNvbnZlcnRlcigoVHlwZUNvbnZlcnRlcikgaXRlbSk7Ci0JCQkJCX0KLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGFkZENvbnZlcnRlcigpIHsKLQkJYWRkRWNsaXBzZUxpbmtDb252ZXJ0ZXJGcm9tRGlhbG9nKGJ1aWxkRWNsaXBzZUxpbmtDb252ZXJ0ZXJEaWFsb2coKSk7Ci0JfQotCQotCXByb3RlY3RlZCBFY2xpcHNlTGlua0NvbnZlcnRlckRpYWxvZyBidWlsZEVjbGlwc2VMaW5rQ29udmVydGVyRGlhbG9nKCkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rQ29udmVydGVyRGlhbG9nKGdldENvbnRyb2woKS5nZXRTaGVsbCgpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBhZGRFY2xpcHNlTGlua0NvbnZlcnRlckZyb21EaWFsb2coRWNsaXBzZUxpbmtDb252ZXJ0ZXJEaWFsb2cgZGlhbG9nKSB7Ci0JCWlmIChkaWFsb2cub3BlbigpICE9IFdpbmRvdy5PSykgewotCQkJcmV0dXJuOwotCQl9Ci0JCVN0cmluZyBjb252ZXJ0ZXJUeXBlID0gZGlhbG9nLmdldENvbnZlcnRlclR5cGUoKTsKLQkJRWNsaXBzZUxpbmtDb252ZXJ0ZXIgY29udmVydGVyOwotCQlpZiAoY29udmVydGVyVHlwZSA9PSBFY2xpcHNlTGlua0NvbnZlcnRlci5DVVNUT01fQ09OVkVSVEVSKSB7Ci0JCQljb252ZXJ0ZXIgPSB0aGlzLmdldFN1YmplY3QoKS5hZGRDdXN0b21Db252ZXJ0ZXIoZ2V0U3ViamVjdCgpLmN1c3RvbUNvbnZlcnRlcnNTaXplKCkpOwotCQl9Ci0JCWVsc2UgaWYgKGNvbnZlcnRlclR5cGUgPT0gRWNsaXBzZUxpbmtDb252ZXJ0ZXIuT0JKRUNUX1RZUEVfQ09OVkVSVEVSKSB7Ci0JCQljb252ZXJ0ZXIgPSB0aGlzLmdldFN1YmplY3QoKS5hZGRPYmplY3RUeXBlQ29udmVydGVyKGdldFN1YmplY3QoKS5vYmplY3RUeXBlQ29udmVydGVyc1NpemUoKSk7Ci0JCX0KLQkJZWxzZSBpZiAoY29udmVydGVyVHlwZSA9PSBFY2xpcHNlTGlua0NvbnZlcnRlci5TVFJVQ1RfQ09OVkVSVEVSKSB7Ci0JCQljb252ZXJ0ZXIgPSB0aGlzLmdldFN1YmplY3QoKS5hZGRTdHJ1Y3RDb252ZXJ0ZXIoZ2V0U3ViamVjdCgpLnN0cnVjdENvbnZlcnRlcnNTaXplKCkpOwotCQl9Ci0JCWVsc2UgaWYgKGNvbnZlcnRlclR5cGUgPT0gRWNsaXBzZUxpbmtDb252ZXJ0ZXIuVFlQRV9DT05WRVJURVIpIHsKLQkJCWNvbnZlcnRlciA9IHRoaXMuZ2V0U3ViamVjdCgpLmFkZFR5cGVDb252ZXJ0ZXIoZ2V0U3ViamVjdCgpLnR5cGVDb252ZXJ0ZXJzU2l6ZSgpKTsKLQkJfQotCQllbHNlIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oKTsKLQkJfQotCQljb252ZXJ0ZXIuc2V0TmFtZShkaWFsb2cuZ2V0TmFtZSgpKTsKLQkJdGhpcy5zZWxlY3RlZENvbnZlcnRlckhvbGRlci5zZXRWYWx1ZShjb252ZXJ0ZXIpOy8vc28gdGhhdCBpdCBnZXRzIHNlbGVjdGVkIGluIHRoZSBMaXN0IGZvciB0aGUgdXNlciB0byBlZGl0Ci0JfQotCi0JcHJpdmF0ZSBUcmFuc2Zvcm1lcjxFY2xpcHNlTGlua0NvbnZlcnRlciwgQ29udHJvbD4gYnVpbGRQYW5lVHJhbnNmb3JtZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtZXI8RWNsaXBzZUxpbmtDb252ZXJ0ZXIsIENvbnRyb2w+KCkgewotCQkJcHVibGljIENvbnRyb2wgdHJhbnNmb3JtKEVjbGlwc2VMaW5rQ29udmVydGVyIGNvbnZlcnRlcikgewotCQkJCWlmIChjb252ZXJ0ZXIgPT0gbnVsbCkgewotCQkJCQlyZXR1cm4gbnVsbDsKLQkJCQl9Ci0KLQkJCQlpZiAoY29udmVydGVyLmdldFR5cGUoKSA9PSBFY2xpcHNlTGlua0NvbnZlcnRlci5DVVNUT01fQ09OVkVSVEVSKSB7Ci0JCQkJCXJldHVybiBDb252ZXJ0ZXJzQ29tcG9zaXRlLnRoaXMuY29udmVydGVyQ29tcG9zaXRlLmdldENvbnRyb2woKTsKLQkJCQl9Ci0JCQkJaWYgKGNvbnZlcnRlci5nZXRUeXBlKCkgPT0gRWNsaXBzZUxpbmtDb252ZXJ0ZXIuT0JKRUNUX1RZUEVfQ09OVkVSVEVSKSB7Ci0JCQkJCXJldHVybiBDb252ZXJ0ZXJzQ29tcG9zaXRlLnRoaXMub2JqZWN0VHlwZUNvbnZlcnRlckNvbXBvc2l0ZS5nZXRDb250cm9sKCk7Ci0JCQkJfQotCQkJCWlmIChjb252ZXJ0ZXIuZ2V0VHlwZSgpID09IEVjbGlwc2VMaW5rQ29udmVydGVyLlNUUlVDVF9DT05WRVJURVIpIHsKLQkJCQkJcmV0dXJuIENvbnZlcnRlcnNDb21wb3NpdGUudGhpcy5zdHJ1Y3RDb252ZXJ0ZXJDb21wb3NpdGUuZ2V0Q29udHJvbCgpOwotCQkJCX0KLQkJCQlpZiAoY29udmVydGVyLmdldFR5cGUoKSA9PSBFY2xpcHNlTGlua0NvbnZlcnRlci5UWVBFX0NPTlZFUlRFUikgewotCQkJCQlyZXR1cm4gQ29udmVydGVyc0NvbXBvc2l0ZS50aGlzLnR5cGVDb252ZXJ0ZXJDb21wb3NpdGUuZ2V0Q29udHJvbCgpOwotCQkJCX0KLQotCQkJCXJldHVybiBudWxsOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8RWNsaXBzZUxpbmtDb252ZXJ0ZXI+IGJ1aWxkRGlzcGxheWFibGVDb252ZXJ0ZXJzTGlzdEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBJdGVtUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8RWNsaXBzZUxpbmtDb252ZXJ0ZXI+KAotCQkJYnVpbGRFY2xpcHNlTGlua0NvbnZlcnRlcnNIb2xkZXIoKSwKLQkJCUVjbGlwc2VMaW5rQ29udmVydGVyLk5BTUVfUFJPUEVSVFkKLQkJKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rQ29udmVydGVyPiBidWlsZEVjbGlwc2VMaW5rQ29udmVydGVyc0hvbGRlcigpIHsKLQkJTGlzdDxMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRWNsaXBzZUxpbmtDb252ZXJ0ZXI+PiBsaXN0ID0gbmV3IEFycmF5TGlzdDxMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRWNsaXBzZUxpbmtDb252ZXJ0ZXI+PigpOwotCQlsaXN0LmFkZChidWlsZEN1c3RvbUNvbnZlcnRlcnNMaXN0SG9sZGVyKCkpOwotCQlsaXN0LmFkZChidWlsZE9iamVjdFR5cGVDb252ZXJ0ZXJzTGlzdEhvbGRlcigpKTsKLQkJbGlzdC5hZGQoYnVpbGRTdHJ1Y3RDb252ZXJ0ZXJzTGlzdEhvbGRlcigpKTsKLQkJbGlzdC5hZGQoYnVpbGRUeXBlQ29udmVydGVyc0xpc3RIb2xkZXIoKSk7Ci0JCXJldHVybiBuZXcgQ29tcG9zaXRlTGlzdFZhbHVlTW9kZWw8TGlzdFZhbHVlTW9kZWw8PyBleHRlbmRzIEVjbGlwc2VMaW5rQ29udmVydGVyPiwgRWNsaXBzZUxpbmtDb252ZXJ0ZXI+KGxpc3QpOwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8Q3VzdG9tQ29udmVydGVyPiBidWlsZEN1c3RvbUNvbnZlcnRlcnNMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IExpc3RBc3BlY3RBZGFwdGVyPENvbnZlcnRlckhvbGRlciwgQ3VzdG9tQ29udmVydGVyPigKLQkJCWdldFN1YmplY3RIb2xkZXIoKSwKLQkJCUNvbnZlcnRlckhvbGRlci5DVVNUT01fQ09OVkVSVEVSU19MSVNUKQotCQl7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBMaXN0SXRlcmF0b3I8Q3VzdG9tQ29udmVydGVyPiBsaXN0SXRlcmF0b3JfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuY3VzdG9tQ29udmVydGVycygpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBpbnQgc2l6ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5jdXN0b21Db252ZXJ0ZXJzU2l6ZSgpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8T2JqZWN0VHlwZUNvbnZlcnRlcj4gYnVpbGRPYmplY3RUeXBlQ29udmVydGVyc0xpc3RIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgTGlzdEFzcGVjdEFkYXB0ZXI8Q29udmVydGVySG9sZGVyLCBPYmplY3RUeXBlQ29udmVydGVyPigKLQkJCWdldFN1YmplY3RIb2xkZXIoKSwKLQkJCUNvbnZlcnRlckhvbGRlci5PQkpFQ1RfVFlQRV9DT05WRVJURVJTX0xJU1QpCi0JCXsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIExpc3RJdGVyYXRvcjxPYmplY3RUeXBlQ29udmVydGVyPiBsaXN0SXRlcmF0b3JfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3Qub2JqZWN0VHlwZUNvbnZlcnRlcnMoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgaW50IHNpemVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3Qub2JqZWN0VHlwZUNvbnZlcnRlcnNTaXplKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxTdHJ1Y3RDb252ZXJ0ZXI+IGJ1aWxkU3RydWN0Q29udmVydGVyc0xpc3RIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgTGlzdEFzcGVjdEFkYXB0ZXI8Q29udmVydGVySG9sZGVyLCBTdHJ1Y3RDb252ZXJ0ZXI+KAotCQkJZ2V0U3ViamVjdEhvbGRlcigpLAotCQkJQ29udmVydGVySG9sZGVyLlNUUlVDVF9DT05WRVJURVJTX0xJU1QpCi0JCXsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIExpc3RJdGVyYXRvcjxTdHJ1Y3RDb252ZXJ0ZXI+IGxpc3RJdGVyYXRvcl8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5zdHJ1Y3RDb252ZXJ0ZXJzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGludCBzaXplXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LnN0cnVjdENvbnZlcnRlcnNTaXplKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxUeXBlQ29udmVydGVyPiBidWlsZFR5cGVDb252ZXJ0ZXJzTGlzdEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBMaXN0QXNwZWN0QWRhcHRlcjxDb252ZXJ0ZXJIb2xkZXIsIFR5cGVDb252ZXJ0ZXI+KAotCQkJZ2V0U3ViamVjdEhvbGRlcigpLAotCQkJQ29udmVydGVySG9sZGVyLlRZUEVfQ09OVkVSVEVSU19MSVNUKQotCQl7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBMaXN0SXRlcmF0b3I8VHlwZUNvbnZlcnRlcj4gbGlzdEl0ZXJhdG9yXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LnR5cGVDb252ZXJ0ZXJzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGludCBzaXplXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LnR5cGVDb252ZXJ0ZXJzU2l6ZSgpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPEN1c3RvbUNvbnZlcnRlcj4gYnVpbGRDdXN0b21Db252ZXJ0ZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtDb252ZXJ0ZXIsIEN1c3RvbUNvbnZlcnRlcj4odGhpcy5zZWxlY3RlZENvbnZlcnRlckhvbGRlcikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ3VzdG9tQ29udmVydGVyIHRyYW5zZm9ybV8oRWNsaXBzZUxpbmtDb252ZXJ0ZXIgdmFsdWUpIHsKLQkJCQlyZXR1cm4gdmFsdWUuZ2V0VHlwZSgpID09IEVjbGlwc2VMaW5rQ29udmVydGVyLkNVU1RPTV9DT05WRVJURVIgPyAoQ3VzdG9tQ29udmVydGVyKSB2YWx1ZSA6IG51bGw7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0VHlwZUNvbnZlcnRlcj4gYnVpbGRPYmplY3RUeXBlQ29udmVydGVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rQ29udmVydGVyLCBPYmplY3RUeXBlQ29udmVydGVyPih0aGlzLnNlbGVjdGVkQ29udmVydGVySG9sZGVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBPYmplY3RUeXBlQ29udmVydGVyIHRyYW5zZm9ybV8oRWNsaXBzZUxpbmtDb252ZXJ0ZXIgdmFsdWUpIHsKLQkJCQlyZXR1cm4gdmFsdWUuZ2V0VHlwZSgpID09IEVjbGlwc2VMaW5rQ29udmVydGVyLk9CSkVDVF9UWVBFX0NPTlZFUlRFUiA/IChPYmplY3RUeXBlQ29udmVydGVyKSB2YWx1ZSA6IG51bGw7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8U3RydWN0Q29udmVydGVyPiBidWlsZFN0cnVjdENvbnZlcnRlckhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua0NvbnZlcnRlciwgU3RydWN0Q29udmVydGVyPih0aGlzLnNlbGVjdGVkQ29udmVydGVySG9sZGVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJ1Y3RDb252ZXJ0ZXIgdHJhbnNmb3JtXyhFY2xpcHNlTGlua0NvbnZlcnRlciB2YWx1ZSkgewotCQkJCXJldHVybiB2YWx1ZS5nZXRUeXBlKCkgPT0gRWNsaXBzZUxpbmtDb252ZXJ0ZXIuU1RSVUNUX0NPTlZFUlRFUiA/IChTdHJ1Y3RDb252ZXJ0ZXIpIHZhbHVlIDogbnVsbDsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxUeXBlQ29udmVydGVyPiBidWlsZFR5cGVDb252ZXJ0ZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtDb252ZXJ0ZXIsIFR5cGVDb252ZXJ0ZXI+KHRoaXMuc2VsZWN0ZWRDb252ZXJ0ZXJIb2xkZXIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFR5cGVDb252ZXJ0ZXIgdHJhbnNmb3JtXyhFY2xpcHNlTGlua0NvbnZlcnRlciB2YWx1ZSkgewotCQkJCXJldHVybiB2YWx1ZS5nZXRUeXBlKCkgPT0gRWNsaXBzZUxpbmtDb252ZXJ0ZXIuVFlQRV9DT05WRVJURVIgPyAoVHlwZUNvbnZlcnRlcikgdmFsdWUgOiBudWxsOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgSUxhYmVsUHJvdmlkZXIgYnVpbGRDb252ZXJ0ZXJzTGlzdExhYmVsUHJvdmlkZXIoKSB7Ci0JCXJldHVybiBuZXcgTGFiZWxQcm92aWRlcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyBnZXRUZXh0KE9iamVjdCBlbGVtZW50KSB7Ci0JCQkJcmV0dXJuICgoRWNsaXBzZUxpbmtDb252ZXJ0ZXIpIGVsZW1lbnQpLmdldE5hbWUoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBlbmFibGVXaWRnZXRzKGJvb2xlYW4gZW5hYmxlZCkgewotCQlzdXBlci5lbmFibGVXaWRnZXRzKGVuYWJsZWQpOwotCQl0aGlzLmxpc3RQYW5lLmVuYWJsZVdpZGdldHMoZW5hYmxlZCk7Ci0JfQotCi0JLy9UT0RPIG5lZWQgdG8gY2hlY2sgdGhlIGNvbnZlcnRlciByZXBvc2l0b3J5IGZvciB0aGlzLCBzaG91bGQgY2hlY2sgYWxsIGNvbnZlcnRlcnMsIGV4Y2VwdCBmb3IgdGhlIG92ZXJyaWRlIGNhc2UsIGhtbQotCS8vd2UgYXQgbGVhc3QgbmVlZCB0byBjaGVjayB0eXBlY29udmVydGVycywgY29udmVydGVycywgc3RydWN0Y29udmVydGVycywgYW5kIG9iamVjdHlwZWNvbnZlcnRlcnMsIG9uIHRoaXMgcGFydGljdWxhcgotCS8vb2JqZWN0LiAgb3Igd2UgbmVlZCB0byBnaXZlIGEgd2FybmluZyBhYm91dCB0aGUgY2FzZSB3aGVyZSB5b3UgYXJlIG92ZXJyaWRpbmcgb3IgYW4gZXJyb3IgaWYgaXQncyBub3QgYW4gb3ZlcnJpZGU/Ci0JcHJpdmF0ZSBJdGVyYXRvcjxTdHJpbmc+IGNvbnZlcnRlck5hbWVzKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8Q3VzdG9tQ29udmVydGVyLCBTdHJpbmc+KGdldFN1YmplY3QoKS5jdXN0b21Db252ZXJ0ZXJzKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oQ3VzdG9tQ29udmVydGVyIG5leHQpIHsKLQkJCQlyZXR1cm4gbmV4dC5nZXROYW1lKCk7Ci0JCQl9Ci0JCX07Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtQmFzaWNDb2xsZWN0aW9uTWFwcGluZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1CYXNpY0NvbGxlY3Rpb25NYXBwaW5nQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGY0NWVlZTkuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1CYXNpY0NvbGxlY3Rpb25NYXBwaW5nQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5BY2Nlc3NIb2xkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5CYXNpY0NvbGxlY3Rpb25NYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuZGV0YWlscy5BY2Nlc3NUeXBlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqCi0gKiBAdmVyc2lvbiAyLjIKLSAqIEBzaW5jZSAyLjIKLSAqLwotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rMV8xT3JtQmFzaWNDb2xsZWN0aW9uTWFwcGluZ0NvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPEJhc2ljQ29sbGVjdGlvbk1hcHBpbmc+Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbXBsZW1lbnRzIEpwYUNvbXBvc2l0ZQotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+RWNsaXBzZUxpbmtCYXNpY0NvbGxlY3Rpb25NYXBwaW5nQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBzdWJqZWN0SG9sZGVyIFRoZSBob2xkZXIgb2YgdGhlIHN1YmplY3QgPGNvZGU+SU1hbnlUb09uZU1hcHBpbmc8L2NvZGU+Ci0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqIEBwYXJhbSB3aWRnZXRGYWN0b3J5IFRoZSBmYWN0b3J5IHVzZWQgdG8gY3JlYXRlIHZhcmlvdXMgY29tbW9uIHdpZGdldHMKLQkgKi8KLQlwdWJsaWMgRWNsaXBzZUxpbmsxXzFPcm1CYXNpY0NvbGxlY3Rpb25NYXBwaW5nQ29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgQmFzaWNDb2xsZWN0aW9uTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50LAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCW5ldyBBY2Nlc3NUeXBlQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQWNjZXNzSG9sZGVySG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JfQkKLQkKLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPEFjY2Vzc0hvbGRlcj4gYnVpbGRBY2Nlc3NIb2xkZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEJhc2ljQ29sbGVjdGlvbk1hcHBpbmcsIEFjY2Vzc0hvbGRlcj4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBBY2Nlc3NIb2xkZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRQZXJzaXN0ZW50QXR0cmlidXRlKCk7Ci0JCQl9Ci0JCX07Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1CYXNpY0NvbGxlY3Rpb25NYXBwaW5nVWlQcm92aWRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1CYXNpY0NvbGxlY3Rpb25NYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlYTEwZmFmLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtQmFzaWNDb2xsZWN0aW9uTWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5CYXNpY0NvbGxlY3Rpb25NYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLkpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua0Jhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU9ybUJhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyIGV4dGVuZHMgRWNsaXBzZUxpbmtCYXNpY0NvbGxlY3Rpb25NYXBwaW5nVWlQcm92aWRlcjxCYXNpY0NvbGxlY3Rpb25NYXBwaW5nPgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEVjbGlwc2VMaW5rMV8xT3JtQmFzaWNDb2xsZWN0aW9uTWFwcGluZ1VpUHJvdmlkZXIgSU5TVEFOQ0UgPSAKLQkJbmV3IEVjbGlwc2VMaW5rMV8xT3JtQmFzaWNDb2xsZWN0aW9uTWFwcGluZ1VpUHJvdmlkZXIoKTsKLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyPEJhc2ljQ29sbGVjdGlvbk1hcHBpbmc+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGluazFfMU9ybUJhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LMV8xX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0KLQkKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGJ1aWxkQXR0cmlidXRlTWFwcGluZ0NvbXBvc2l0ZSgKLQkJCUpwYVVpRmFjdG9yeSBmYWN0b3J5LAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEJhc2ljQ29sbGVjdGlvbk1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmsxXzFPcm1CYXNpY0NvbGxlY3Rpb25NYXBwaW5nQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1CYXNpY01hcE1hcHBpbmdDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtQmFzaWNNYXBNYXBwaW5nQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDIzMWRmYWIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1CYXNpY01hcE1hcHBpbmdDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkFjY2Vzc0hvbGRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkJhc2ljTWFwTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmRldGFpbHMuQWNjZXNzVHlwZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKgotICogQHZlcnNpb24gMi4yCi0gKiBAc2luY2UgMi4yCi0gKi8KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwTWFwcGluZ0NvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPEJhc2ljTWFwTWFwcGluZz4KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGltcGxlbWVudHMgSnBhQ29tcG9zaXRlCi17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5FY2xpcHNlTGlua0Jhc2ljQ29sbGVjdGlvbk1hcHBpbmdDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHN1YmplY3RIb2xkZXIgVGhlIGhvbGRlciBvZiB0aGUgc3ViamVjdCA8Y29kZT5JTWFueVRvT25lTWFwcGluZzwvY29kZT4KLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICogQHBhcmFtIHdpZGdldEZhY3RvcnkgVGhlIGZhY3RvcnkgdXNlZCB0byBjcmVhdGUgdmFyaW91cyBjb21tb24gd2lkZ2V0cwotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwTWFwcGluZ0NvbXBvc2l0ZShQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIEJhc2ljTWFwTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50LAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCW5ldyBBY2Nlc3NUeXBlQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQWNjZXNzSG9sZGVySG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JfQkKLQkKLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPEFjY2Vzc0hvbGRlcj4gYnVpbGRBY2Nlc3NIb2xkZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEJhc2ljTWFwTWFwcGluZywgQWNjZXNzSG9sZGVyPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEFjY2Vzc0hvbGRlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldFBlcnNpc3RlbnRBdHRyaWJ1dGUoKTsKLQkJCX0KLQkJfTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtQmFzaWNNYXBNYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxYTBmMmM0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtQmFzaWNNYXBNYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkJhc2ljTWFwTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5KcHRFY2xpcHNlTGlua0NvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtCYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXIgZXh0ZW5kcyBFY2xpcHNlTGlua0Jhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXI8QmFzaWNNYXBNYXBwaW5nPgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEVjbGlwc2VMaW5rMV8xT3JtQmFzaWNNYXBNYXBwaW5nVWlQcm92aWRlciBJTlNUQU5DRSA9IAotCQluZXcgRWNsaXBzZUxpbmsxXzFPcm1CYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxCYXNpY01hcE1hcHBpbmc+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQotCXB1YmxpYyBJQ29udGVudFR5cGUgZ2V0Q29udGVudFR5cGUoKSB7Ci0JCXJldHVybiBKcHRFY2xpcHNlTGlua0NvcmVQbHVnaW4uRUNMSVBTRUxJTksxXzFfT1JNX1hNTF9DT05URU5UX1RZUEU7Ci0JfQotCQkKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGJ1aWxkQXR0cmlidXRlTWFwcGluZ0NvbXBvc2l0ZSgKLQkJCUpwYVVpRmFjdG9yeSBmYWN0b3J5LAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEJhc2ljTWFwTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwTWFwcGluZ0NvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtQmFzaWNNYXBwaW5nQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3MWU3NmEwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtQmFzaWNNYXBwaW5nQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw2NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5BY2Nlc3NIb2xkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5CYXNpY01hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtCYXNpY01hcHBpbmdDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuTXV0YWJsZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuZGV0YWlscy5BY2Nlc3NUeXBlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkNvbHVtbkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5GZXRjaFR5cGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuT3B0aW9uYWxDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwcGluZ0NvbXBvc2l0ZSBleHRlbmRzIEVjbGlwc2VMaW5rQmFzaWNNYXBwaW5nQ29tcG9zaXRlCi17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5FY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwcGluZ0NvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gc3ViamVjdEhvbGRlciBUaGUgaG9sZGVyIG9mIHRoZSBzdWJqZWN0IDxjb2RlPkJhc2ljTWFwcGluZzwvY29kZT4KLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICogQHBhcmFtIHdpZGdldEZhY3RvcnkgVGhlIGZhY3RvcnkgdXNlZCB0byBjcmVhdGUgdmFyaW91cyBjb21tb24gd2lkZ2V0cwotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwcGluZ0NvbXBvc2l0ZShQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIEJhc2ljTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplR2VuZXJhbFBhbmUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlpbnQgZ3JvdXBCb3hNYXJnaW4gPSBnZXRHcm91cEJveE1hcmdpbigpOwotCi0JCW5ldyBDb2x1bW5Db21wb3NpdGUodGhpcywgYnVpbGRDb2x1bW5Ib2xkZXIoKSwgY29udGFpbmVyKTsKLQotCQkvLyBBbGlnbiB0aGUgd2lkZ2V0cyB1bmRlciB0aGUgQ29sdW1uQ29tcG9zaXRlCi0JCWNvbnRhaW5lciA9IGFkZFN1YlBhbmUoY29udGFpbmVyLCAwLCBncm91cEJveE1hcmdpbiwgMCwgZ3JvdXBCb3hNYXJnaW4pOwotCQkKLQkJbmV3IEFjY2Vzc1R5cGVDb21wb3NpdGUodGhpcywgYnVpbGRBY2Nlc3NIb2xkZXJIb2xkZXIoKSwgY29udGFpbmVyKTsKLQkJbmV3IEZldGNoVHlwZUNvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCQluZXcgT3B0aW9uYWxDb21wb3NpdGUodGhpcywgYWRkU3ViUGFuZShjb250YWluZXIsIDQpKTsKLQkJCi0JCS8vIE11dGFibGUgd2lkZ2V0cwotCQluZXcgTXV0YWJsZUNvbXBvc2l0ZSh0aGlzLCBidWlsZE11dGFibGVIb2xkZXIoKSwgY29udGFpbmVyKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxBY2Nlc3NIb2xkZXI+IGJ1aWxkQWNjZXNzSG9sZGVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxCYXNpY01hcHBpbmcsIEFjY2Vzc0hvbGRlcj4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBBY2Nlc3NIb2xkZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRQZXJzaXN0ZW50QXR0cmlidXRlKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1CYXNpY01hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwcGluZ1VpUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjk3YmY1Yy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQub3JtLkVjbGlwc2VMaW5rT3JtQmFzaWNNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFic3RyYWN0QmFzaWNNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmsxXzFPcm1CYXNpY01hcHBpbmdVaVByb3ZpZGVyCi0JZXh0ZW5kcyBBYnN0cmFjdEJhc2ljTWFwcGluZ1VpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1CYXNpY01hcHBpbmc+Ci17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgRWNsaXBzZUxpbmsxXzFPcm1CYXNpY01hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwcGluZ1VpUHJvdmlkZXIoKTsKLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyPEVjbGlwc2VMaW5rT3JtQmFzaWNNYXBwaW5nPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmsxXzFPcm1CYXNpY01hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LMV8xX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0JCi0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua09ybUJhc2ljTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJCi0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmsxXzFPcm1CYXNpY01hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybUVtYmVkZGFibGVDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtRW1iZWRkYWJsZUNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhODk0ZDUzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtRW1iZWRkYWJsZUNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTAwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkFjY2Vzc0hvbGRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0Lm9ybS5Db252ZXJ0ZXJIb2xkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5vcm0uRWNsaXBzZUxpbmtPcm1FbWJlZGRhYmxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua0VtYmVkZGFibGVBZHZhbmNlZENvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmRldGFpbHMuQWNjZXNzVHlwZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuTWV0YWRhdGFDb21wbGV0ZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuT3JtSmF2YUNsYXNzQ2hvb3NlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBUaGlzIHBhbmUgZG9lcyBub3QgaGF2ZSBhbnkgd2lkZ2V0cy4KLSAqCi0gKiBAc2VlIEVtYmVkZGFibGUKLSAqIEBzZWUgQmFzZUpwYVVpRmFjdG9yeSAtIFRoZSBmYWN0b3J5IGNyZWF0aW5nIHRoaXMgcGFuZQotICogQHNlZSBFbWJlZGRhYmxlVWlQcm92aWRlcgotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRhYmxlQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8RWNsaXBzZUxpbmtPcm1FbWJlZGRhYmxlPgotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW1wbGVtZW50cyBKcGFDb21wb3NpdGUKLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkVtYmVkZGFibGVDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHN1YmplY3RIb2xkZXIgVGhlIGhvbGRlciBvZiB0aGlzIHBhbmUncyBzdWJqZWN0Ci0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqIEBwYXJhbSB3aWRnZXRGYWN0b3J5IFRoZSBmYWN0b3J5IHVzZWQgdG8gY3JlYXRlIHZhcmlvdXMgY29tbW9uIHdpZGdldHMKLQkgKi8KLQlwdWJsaWMgRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRhYmxlQ29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgRWNsaXBzZUxpbmtPcm1FbWJlZGRhYmxlPiBzdWJqZWN0SG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJaW5pdGlhbGl6ZUdlbmVyYWxQYW5lKGNvbnRhaW5lcik7Ci0JCWluaXRpYWxpemVDb252ZXJ0ZXJzUGFuZShjb250YWluZXIpOwotCQlpbml0aWFsaXplQWR2YW5jZWRQYW5lKGNvbnRhaW5lcik7Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVHZW5lcmFsUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCW5ldyBPcm1KYXZhQ2xhc3NDaG9vc2VyKHRoaXMsIGdldFN1YmplY3RIb2xkZXIoKSwgY29udGFpbmVyKTsKLQkJbmV3IEFjY2Vzc1R5cGVDb21wb3NpdGUodGhpcywgYnVpbGRBY2Nlc3NIb2xkZXIoKSwgY29udGFpbmVyKTsKLQkJbmV3IE1ldGFkYXRhQ29tcGxldGVDb21wb3NpdGUodGhpcywgZ2V0U3ViamVjdEhvbGRlcigpLCBjb250YWluZXIpOwotCX0KLQkKLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPEFjY2Vzc0hvbGRlcj4gYnVpbGRBY2Nlc3NIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEVjbGlwc2VMaW5rT3JtRW1iZWRkYWJsZSwgQWNjZXNzSG9sZGVyPigKLQkJCWdldFN1YmplY3RIb2xkZXIoKSkKLQkJewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQWNjZXNzSG9sZGVyIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0UGVyc2lzdGVudFR5cGUoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplQ29udmVydGVyc1BhbmUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCWNvbnRhaW5lciA9IGFkZENvbGxhcHNhYmxlU2VjdGlvbigKLQkJCWFkZFN1YlBhbmUoY29udGFpbmVyLCA1KSwKLQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkNvbnZlcnRlcnNDb21wb3NpdGVfTGFiZWwKLQkJKTsKLQotCQluZXcgQ29udmVydGVyc0NvbXBvc2l0ZSh0aGlzLCBidWlsZENvbnZlcnRlckhvbGRlcigpLCBjb250YWluZXIpOwotCX0KLQkKLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxDb252ZXJ0ZXJIb2xkZXI+IGJ1aWxkQ29udmVydGVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxFY2xpcHNlTGlua09ybUVtYmVkZGFibGUsIENvbnZlcnRlckhvbGRlcj4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDb252ZXJ0ZXJIb2xkZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRDb252ZXJ0ZXJIb2xkZXIoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUFkdmFuY2VkUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCW5ldyBFY2xpcHNlTGlua0VtYmVkZGFibGVBZHZhbmNlZENvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybUVtYmVkZGFibGVVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybUVtYmVkZGFibGVVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZlNzM5ODMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRhYmxlVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICBDb3B5cmlnaHQgKGMpIDIwMDkgIE9yYWNsZS4gCi0gKiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4gIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIAotICogIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIAotICogIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IAotICogIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0gKiAgCi0gKiAgQ29udHJpYnV0b3JzOiAKLSAqICAJT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLmNvbnRlbnQuSUNvbnRlbnRUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLkpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0Lm9ybS5FY2xpcHNlTGlua09ybUVtYmVkZGFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVVpRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuVHlwZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFic3RyYWN0RW1iZWRkYWJsZVVpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rMV8xT3JtRW1iZWRkYWJsZVVpUHJvdmlkZXIgCi0JZXh0ZW5kcyBBYnN0cmFjdEVtYmVkZGFibGVVaVByb3ZpZGVyPEVjbGlwc2VMaW5rT3JtRW1iZWRkYWJsZT4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGluazFfMU9ybUVtYmVkZGFibGVVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGluazFfMU9ybUVtYmVkZGFibGVVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBUeXBlTWFwcGluZ1VpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1FbWJlZGRhYmxlPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRhYmxlVWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JcHVibGljIElDb250ZW50VHlwZSBnZXRDb250ZW50VHlwZSgpIHsKLQkJcmV0dXJuIEpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbi5FQ0xJUFNFTElOSzFfMV9PUk1fWE1MX0NPTlRFTlRfVFlQRTsKLQl9Ci0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZFBlcnNpc3RlbnRUeXBlTWFwcGluZ0NvbXBvc2l0ZSgKLQkJCUpwYVVpRmFjdG9yeSBmYWN0b3J5LCAKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua09ybUVtYmVkZGFibGU+IHN1YmplY3RIb2xkZXIsIAotCQkJQ29tcG9zaXRlIHBhcmVudCwgCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGlua09ybUVtYmVkZGFibGVDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybUVtYmVkZGVkSWRNYXBwaW5nQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybUVtYmVkZGVkSWRNYXBwaW5nQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDBkNmQzNzQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRlZElkTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuQWNjZXNzSG9sZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuRW1iZWRkZWRJZE1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFjY2Vzc1R5cGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuQWJzdHJhY3RFbWJlZGRlZE1hcHBpbmdDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRW1iZWRkZWRBdHRyaWJ1dGVPdmVycmlkZXNDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogSGVyZSdzIHRoZSBsYXlvdXQgb2YgdGhpcyBwYW5lOgotICogPHByZT4KLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBFbWJlZGRlZEF0dHJpYnV0ZU92ZXJyaWRlc0NvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSBFbWJlZGRlZElkTWFwcGluZwotICogQHNlZSBCYXNlSnBhVWlGYWN0b3J5IC0gVGhlIGZhY3RvcnkgY3JlYXRpbmcgdGhpcyBwYW5lCi0gKgotICogQHZlcnNpb24gMi4yCi0gKiBAc2luY2UgMi4yCi0gKi8KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU9ybUVtYmVkZGVkSWRNYXBwaW5nQ29tcG9zaXRlIGV4dGVuZHMgQWJzdHJhY3RFbWJlZGRlZE1hcHBpbmdDb21wb3NpdGU8RW1iZWRkZWRJZE1hcHBpbmc+Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW1wbGVtZW50cyBKcGFDb21wb3NpdGUKLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkVjbGlwc2VMaW5rMV8xT3JtRW1iZWRkZWRJZE1hcHBpbmdDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHN1YmplY3RIb2xkZXIgVGhlIGhvbGRlciBvZiB0aGUgc3ViamVjdCA8Y29kZT5FbWJlZGRlZElkTWFwcGluZzwvY29kZT4KLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICogQHBhcmFtIHdpZGdldEZhY3RvcnkgVGhlIGZhY3RvcnkgdXNlZCB0byBjcmVhdGUgdmFyaW91cyBjb21tb24gd2lkZ2V0cwotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGluazFfMU9ybUVtYmVkZGVkSWRNYXBwaW5nQ29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgRW1iZWRkZWRJZE1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQluZXcgQWNjZXNzVHlwZUNvbXBvc2l0ZSh0aGlzLCBidWlsZEFjY2Vzc0hvbGRlckhvbGRlcigpLCBjb250YWluZXIpOwotCi0JCW5ldyBFbWJlZGRlZEF0dHJpYnV0ZU92ZXJyaWRlc0NvbXBvc2l0ZSgKLQkJCXRoaXMsCi0JCQljb250YWluZXIKLQkJKTsKLQl9CQotCQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8QWNjZXNzSG9sZGVyPiBidWlsZEFjY2Vzc0hvbGRlckhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8RW1iZWRkZWRJZE1hcHBpbmcsIEFjY2Vzc0hvbGRlcj4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBBY2Nlc3NIb2xkZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRQZXJzaXN0ZW50QXR0cmlidXRlKCk7Ci0JCQl9Ci0JCX07Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtRW1iZWRkZWRJZE1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybUVtYmVkZGVkSWRNYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmOTc5NTlhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtRW1iZWRkZWRJZE1hcHBpbmdVaVByb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogIENvcHlyaWdodCAoYykgMjAwOSAgT3JhY2xlLiAKLSAqICBBbGwgcmlnaHRzIHJlc2VydmVkLiAgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgCi0gKiAgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggCi0gKiAgYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgCi0gKiAgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSAqICAKLSAqICBDb250cmlidXRvcnM6IAotICogIAlPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5vcm0uT3JtRW1iZWRkZWRJZE1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFic3RyYWN0RW1iZWRkZWRJZE1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU9ybUVtYmVkZGVkSWRNYXBwaW5nVWlQcm92aWRlcgotCWV4dGVuZHMgQWJzdHJhY3RFbWJlZGRlZElkTWFwcGluZ1VpUHJvdmlkZXI8T3JtRW1iZWRkZWRJZE1hcHBpbmc+Ci17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRlZElkTWFwcGluZ1VpUHJvdmlkZXIgSU5TVEFOQ0UgPSAKLQkJbmV3IEVjbGlwc2VMaW5rMV8xT3JtRW1iZWRkZWRJZE1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxPcm1FbWJlZGRlZElkTWFwcGluZz4gaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0JCi0JCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEVjbGlwc2VMaW5rMV8xT3JtRW1iZWRkZWRJZE1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LMV8xX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0JCi0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxPcm1FbWJlZGRlZElkTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGluazFfMU9ybUVtYmVkZGVkSWRNYXBwaW5nQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRlZE1hcHBpbmdDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtRW1iZWRkZWRNYXBwaW5nQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGFlN2YyNWIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRlZE1hcHBpbmdDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDc2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkFjY2Vzc0hvbGRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkVtYmVkZGVkTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmRldGFpbHMuQWNjZXNzVHlwZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5BYnN0cmFjdEVtYmVkZGVkTWFwcGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FbWJlZGRlZEF0dHJpYnV0ZU92ZXJyaWRlc0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBIZXJlIHRoZSBsYXlvdXQgb2YgdGhpcyBwYW5lOgotICogPHByZT4KLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBFbWJlZGRlZEF0dHJpYnV0ZU92ZXJyaWRlc0NvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSBFbWJlZGRlZE1hcHBpbmcKLSAqIEBzZWUgQmFzZUpwYVVpRmFjdG9yeSAtIFRoZSBmYWN0b3J5IGNyZWF0aW5nIHRoaXMgcGFuZQotICoKLSAqIEB2ZXJzaW9uIDIuMgotICogQHNpbmNlIDIuMgotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRlZE1hcHBpbmdDb21wb3NpdGUgZXh0ZW5kcyBBYnN0cmFjdEVtYmVkZGVkTWFwcGluZ0NvbXBvc2l0ZTxFbWJlZGRlZE1hcHBpbmc+Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGltcGxlbWVudHMgSnBhQ29tcG9zaXRlCi17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5FbWJlZGRlZE1hcHBpbmdDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHN1YmplY3RIb2xkZXIgVGhlIGhvbGRlciBvZiB0aGUgc3ViamVjdCA8Y29kZT5FbWJlZGRlZE1hcHBpbmc8L2NvZGU+Ci0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqIEBwYXJhbSB3aWRnZXRGYWN0b3J5IFRoZSBmYWN0b3J5IHVzZWQgdG8gY3JlYXRlIHZhcmlvdXMgY29tbW9uIHdpZGdldHMKLQkgKi8KLQlwdWJsaWMgRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRlZE1hcHBpbmdDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBFbWJlZGRlZE1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50LAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0JCi0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCW5ldyBBY2Nlc3NUeXBlQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQWNjZXNzSG9sZGVySG9sZGVyKCksIGNvbnRhaW5lcik7Ci0KLQkJbmV3IEVtYmVkZGVkQXR0cmlidXRlT3ZlcnJpZGVzQ29tcG9zaXRlKAotCQkJdGhpcywKLQkJCWNvbnRhaW5lcgotCQkpOwotCX0JCi0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxBY2Nlc3NIb2xkZXI+IGJ1aWxkQWNjZXNzSG9sZGVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxFbWJlZGRlZE1hcHBpbmcsIEFjY2Vzc0hvbGRlcj4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBBY2Nlc3NIb2xkZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRQZXJzaXN0ZW50QXR0cmlidXRlKCk7Ci0JCQl9Ci0JCX07Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtRW1iZWRkZWRNYXBwaW5nVWlQcm92aWRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRlZE1hcHBpbmdVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDdlMGE0NzAuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRlZE1hcHBpbmdVaVByb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogIENvcHlyaWdodCAoYykgMjAwOSAgT3JhY2xlLiAKLSAqICBBbGwgcmlnaHRzIHJlc2VydmVkLiAgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgCi0gKiAgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggCi0gKiAgYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgCi0gKiAgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSAqICAKLSAqICBDb250cmlidXRvcnM6IAotICogIAlPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5vcm0uT3JtRW1iZWRkZWRNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLkpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuZGV0YWlscy5BYnN0cmFjdEVtYmVkZGVkTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rMV8xT3JtRW1iZWRkZWRNYXBwaW5nVWlQcm92aWRlcgotCWV4dGVuZHMgQWJzdHJhY3RFbWJlZGRlZE1hcHBpbmdVaVByb3ZpZGVyPE9ybUVtYmVkZGVkTWFwcGluZz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGluazFfMU9ybUVtYmVkZGVkTWFwcGluZ1VpUHJvdmlkZXIgSU5TVEFOQ0UgPSAKLQkJbmV3IEVjbGlwc2VMaW5rMV8xT3JtRW1iZWRkZWRNYXBwaW5nVWlQcm92aWRlcigpOwotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8T3JtRW1iZWRkZWRNYXBwaW5nPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRlZE1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LMV8xX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0JCi0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxPcm1FbWJlZGRlZE1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRlZE1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybUVudGl0eVVpUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtRW50aXR5VWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5ZDQ3OTAzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtRW50aXR5VWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICBDb3B5cmlnaHQgKGMpIDIwMDkgIE9yYWNsZS4gCi0gKiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4gIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIAotICogIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIAotICogIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IAotICogIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0gKiAgCi0gKiAgQ29udHJpYnV0b3JzOiAKLSAqICAJT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLmNvbnRlbnQuSUNvbnRlbnRUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLkpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0Lm9ybS5FY2xpcHNlTGlua09ybUVudGl0eTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5UeXBlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmRldGFpbHMuQWJzdHJhY3RFbnRpdHlVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU9ybUVudGl0eVVpUHJvdmlkZXIgCi0JZXh0ZW5kcyBBYnN0cmFjdEVudGl0eVVpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1FbnRpdHk+Ci17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgRWNsaXBzZUxpbmsxXzFPcm1FbnRpdHlVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGluazFfMU9ybUVudGl0eVVpUHJvdmlkZXIoKTsKLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFR5cGVNYXBwaW5nVWlQcm92aWRlcjxFY2xpcHNlTGlua09ybUVudGl0eT4gaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0JCi0JcHVibGljIElDb250ZW50VHlwZSBnZXRDb250ZW50VHlwZSgpIHsKLQkJcmV0dXJuIEpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbi5FQ0xJUFNFTElOSzFfMV9PUk1fWE1MX0NPTlRFTlRfVFlQRTsKLQl9Ci0JCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEVjbGlwc2VMaW5rMV8xT3JtRW50aXR5VWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZFBlcnNpc3RlbnRUeXBlTWFwcGluZ0NvbXBvc2l0ZSgKLQkJCUpwYVVpRmFjdG9yeSBmYWN0b3J5LCAKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua09ybUVudGl0eT4gc3ViamVjdEhvbGRlciwgCi0JCQlDb21wb3NpdGUgcGFyZW50LCAKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rT3JtRW50aXR5Q29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1JZE1hcHBpbmdDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtSWRNYXBwaW5nQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhkMTdlZGEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1JZE1hcHBpbmdDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDYyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkFjY2Vzc0hvbGRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LklkTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua0lkTWFwcGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5NdXRhYmxlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFjY2Vzc1R5cGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuQ29sdW1uQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmsxXzFPcm1JZE1hcHBpbmdDb21wb3NpdGUgZXh0ZW5kcyBFY2xpcHNlTGlua0lkTWFwcGluZ0NvbXBvc2l0ZQotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+Ci1wdWJsaWM8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHN1YmplY3RIb2xkZXIgVGhlIGhvbGRlciBvZiB0aGUgc3ViamVjdCA8Y29kZT5JZE1hcHBpbmc8L2NvZGU+Ci0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqIEBwYXJhbSB3aWRnZXRGYWN0b3J5IFRoZSBmYWN0b3J5IHVzZWQgdG8gY3JlYXRlIHZhcmlvdXMgY29tbW9uIHdpZGdldHMKLQkgKi8KLQlwdWJsaWMgRWNsaXBzZUxpbmsxXzFPcm1JZE1hcHBpbmdDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBJZE1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUdlbmVyYWxQYW5lKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJaW50IGdyb3VwQm94TWFyZ2luID0gZ2V0R3JvdXBCb3hNYXJnaW4oKTsKLQkJCi0JCS8vIENvbHVtbiB3aWRnZXRzCi0JCW5ldyBDb2x1bW5Db21wb3NpdGUodGhpcywgYnVpbGRDb2x1bW5Ib2xkZXIoKSwgY29udGFpbmVyKTsKLQkJCi0JCS8vIEFsaWduIHRoZSB3aWRnZXRzIHVuZGVyIHRoZSBDb2x1bW5Db21wb3NpdGUKLQkJY29udGFpbmVyID0gYWRkU3ViUGFuZShjb250YWluZXIsIDAsIGdyb3VwQm94TWFyZ2luLCAwLCBncm91cEJveE1hcmdpbik7Ci0KLQkJbmV3IEFjY2Vzc1R5cGVDb21wb3NpdGUodGhpcywgYnVpbGRBY2Nlc3NIb2xkZXJIb2xkZXIoKSwgY29udGFpbmVyKTsKLQkJbmV3IE11dGFibGVDb21wb3NpdGUodGhpcywgYnVpbGRNdXRhYmxlSG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JfQotCQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8QWNjZXNzSG9sZGVyPiBidWlsZEFjY2Vzc0hvbGRlckhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8SWRNYXBwaW5nLCBBY2Nlc3NIb2xkZXI+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQWNjZXNzSG9sZGVyIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0UGVyc2lzdGVudEF0dHJpYnV0ZSgpOwotCQkJfQotCQl9OwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybUlkTWFwcGluZ1VpUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtSWRNYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMjlhMWJkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtSWRNYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5KcHRFY2xpcHNlTGlua0NvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5vcm0uRWNsaXBzZUxpbmtPcm1JZE1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVVpRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5BdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmRldGFpbHMuQWJzdHJhY3RJZE1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU9ybUlkTWFwcGluZ1VpUHJvdmlkZXIKLQlleHRlbmRzIEFic3RyYWN0SWRNYXBwaW5nVWlQcm92aWRlcjxFY2xpcHNlTGlua09ybUlkTWFwcGluZz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGluazFfMU9ybUlkTWFwcGluZ1VpUHJvdmlkZXIgSU5TVEFOQ0UgPSAKLQkJbmV3IEVjbGlwc2VMaW5rMV8xT3JtSWRNYXBwaW5nVWlQcm92aWRlcigpOwotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1JZE1hcHBpbmc+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGluazFfMU9ybUlkTWFwcGluZ1VpUHJvdmlkZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQotCXB1YmxpYyBJQ29udGVudFR5cGUgZ2V0Q29udGVudFR5cGUoKSB7Ci0JCXJldHVybiBKcHRFY2xpcHNlTGlua0NvcmVQbHVnaW4uRUNMSVBTRUxJTksxXzFfT1JNX1hNTF9DT05URU5UX1RZUEU7Ci0JfQkKLQkKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGJ1aWxkQXR0cmlidXRlTWFwcGluZ0NvbXBvc2l0ZSgKLQkJCUpwYVVpRmFjdG9yeSBmYWN0b3J5LAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rT3JtSWRNYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rMV8xT3JtSWRNYXBwaW5nQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1NYW55VG9NYW55TWFwcGluZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1NYW55VG9NYW55TWFwcGluZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlYzJhY2FhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtTWFueVRvTWFueU1hcHBpbmdDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEwNiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5BY2Nlc3NIb2xkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5NYW55VG9NYW55TWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua01hbnlUb01hbnlNYXBwaW5nQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkpvaW5GZXRjaENvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuZGV0YWlscy5BY2Nlc3NUeXBlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkNhc2NhZGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRmV0Y2hUeXBlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLk1hbnlUb01hbnlKb2luaW5nU3RyYXRlZ3lQYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLk9yZGVyaW5nQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLlRhcmdldEVudGl0eUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBIZXJlIHRoZSBsYXlvdXQgb2YgdGhpcyBwYW5lOgotICogPHByZT4KLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBUYXJnZXRFbnRpdHlDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IEpvaW5pbmdTdHJhdGVneUNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgRmV0Y2hUeXBlQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBDYXNjYWRlQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IE9yZGVyaW5nQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS08L3ByZT4KLSAqCi0gKiBAc2VlIHtAbGluayBNYW55VG9NYW55TWFwcGluZ30KLSAqIEBzZWUge0BsaW5rIEJhc2VKcGFVaUZhY3Rvcnl9IC0gVGhlIGZhY3RvcnkgY3JlYXRpbmcgdGhpcyBwYW5lCi0gKiBAc2VlIHtAbGluayBUYXJnZXRFbnRpdHlDb21wb3NpdGV9Ci0gKiBAc2VlIHtAbGluayBNYW55VG9NYW55Sm9pbmluZ1N0cmF0ZWd5UGFuZX0KLSAqIEBzZWUge0BsaW5rIEZldGNoVHlwZUNvbXBvc2l0ZX0KLSAqIEBzZWUge0BsaW5rIENhc2NhZGVDb21wb3NpdGV9Ci0gKiBAc2VlIHtAbGluayBPcmRlcmluZ0NvbXBvc2l0ZX0KLSAqCi0gKiBAdmVyc2lvbiAyLjIKLSAqIEBzaW5jZSAyLjIKLSAqLwotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rMV8xT3JtTWFueVRvTWFueU1hcHBpbmdDb21wb3NpdGUgZXh0ZW5kcyBFY2xpcHNlTGlua01hbnlUb01hbnlNYXBwaW5nQ29tcG9zaXRlCi17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5NYW55VG9NYW55TWFwcGluZ0NvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gc3ViamVjdEhvbGRlciBUaGUgaG9sZGVyIG9mIHRoZSBzdWJqZWN0IDxjb2RlPklNYW55VG9NYW55TWFwcGluZzwvY29kZT4KLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICogQHBhcmFtIHdpZGdldEZhY3RvcnkgVGhlIGZhY3RvcnkgdXNlZCB0byBjcmVhdGUgdmFyaW91cyBjb21tb24gd2lkZ2V0cwotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGluazFfMU9ybU1hbnlUb01hbnlNYXBwaW5nQ29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgTWFueVRvTWFueU1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlpbnQgZ3JvdXBCb3hNYXJnaW4gPSBnZXRHcm91cEJveE1hcmdpbigpOwotCQkKLQkJbmV3IFRhcmdldEVudGl0eUNvbXBvc2l0ZSh0aGlzLCBhZGRQYW5lKGNvbnRhaW5lciwgZ3JvdXBCb3hNYXJnaW4pKTsKLQkJbmV3IE1hbnlUb01hbnlKb2luaW5nU3RyYXRlZ3lQYW5lKHRoaXMsIGJ1aWxkSm9pbmluZ0hvbGRlcigpLCBjb250YWluZXIpOwotCQluZXcgQWNjZXNzVHlwZUNvbXBvc2l0ZSh0aGlzLCBidWlsZEFjY2Vzc0hvbGRlckhvbGRlcigpLCBhZGRQYW5lKGNvbnRhaW5lciwgZ3JvdXBCb3hNYXJnaW4pKTsKLQkJbmV3IEZldGNoVHlwZUNvbXBvc2l0ZSh0aGlzLCBhZGRQYW5lKGNvbnRhaW5lciwgZ3JvdXBCb3hNYXJnaW4pKTsKLQkJbmV3IEpvaW5GZXRjaENvbXBvc2l0ZSh0aGlzLCBidWlsZEpvaW5GZXRjaGFibGVIb2xkZXIoKSwgYWRkUGFuZShjb250YWluZXIsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBDYXNjYWRlQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQ2FzY2FkZUhvbGRlcigpLCBhZGRTdWJQYW5lKGNvbnRhaW5lciwgNSkpOwotCQluZXcgT3JkZXJpbmdDb21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxBY2Nlc3NIb2xkZXI+IGJ1aWxkQWNjZXNzSG9sZGVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxNYW55VG9NYW55TWFwcGluZywgQWNjZXNzSG9sZGVyPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEFjY2Vzc0hvbGRlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldFBlcnNpc3RlbnRBdHRyaWJ1dGUoKTsKLQkJCX0KLQkJfTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1NYW55VG9NYW55TWFwcGluZ1VpUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtTWFueVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJmZGUxYmQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1NYW55VG9NYW55TWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQub3JtLkVjbGlwc2VMaW5rT3JtTWFueVRvTWFueU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVVpRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5BdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmRldGFpbHMuQWJzdHJhY3RNYW55VG9NYW55TWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rMV8xT3JtTWFueVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyCi0JZXh0ZW5kcyBBYnN0cmFjdE1hbnlUb01hbnlNYXBwaW5nVWlQcm92aWRlcjxFY2xpcHNlTGlua09ybU1hbnlUb01hbnlNYXBwaW5nPgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEVjbGlwc2VMaW5rMV8xT3JtTWFueVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGluazFfMU9ybU1hbnlUb01hbnlNYXBwaW5nVWlQcm92aWRlcigpOwotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1NYW55VG9NYW55TWFwcGluZz4gaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0JCi0JCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEVjbGlwc2VMaW5rMV8xT3JtTWFueVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LMV8xX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0JCi0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua09ybU1hbnlUb01hbnlNYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rMV8xT3JtTWFueVRvTWFueU1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybU1hbnlUb09uZU1hcHBpbmdDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtTWFueVRvT25lTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0M2VhNDU0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtTWFueVRvT25lTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTA3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkFjY2Vzc0hvbGRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0Lk1hbnlUb09uZU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtNYW55VG9PbmVNYXBwaW5nQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkpvaW5GZXRjaENvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuZGV0YWlscy5BY2Nlc3NUeXBlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkNhc2NhZGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRmV0Y2hUeXBlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLk1hbnlUb09uZUpvaW5pbmdTdHJhdGVneVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuT3B0aW9uYWxDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuVGFyZ2V0RW50aXR5Q29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIEhlcmUgdGhlIGxheW91dCBvZiB0aGlzIHBhbmU6Ci0gKiA8cHJlPgotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IFRhcmdldEVudGl0eUNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgSm9pbmluZ1N0cmF0ZWd5Q29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBGZXRjaFR5cGVDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IE9wdGlvbmFsQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgQ2FzY2FkZUNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLTwvcHJlPgotICoKLSAqIEBzZWUge0BsaW5rIE1hbnlUb09uZU1hcHBpbmd9Ci0gKiBAc2VlIHtAbGluayBCYXNlSnBhVWlGYWN0b3J5fSAtIFRoZSBmYWN0b3J5IGNyZWF0aW5nIHRoaXMgcGFuZQotICogQHNlZSB7QGxpbmsgVGFyZ2V0RW50aXR5Q29tcG9zaXRlfQotICogQHNlZSB7QGxpbmsgTWFueVRvT25lSm9pbmluZ1N0cmF0ZWd5UGFuZX0KLSAqIEBzZWUge0BsaW5rIEZldGNoVHlwZUNvbXBvc2l0ZX0KLSAqIEBzZWUge0BsaW5rIE9wdGlvbmFsQ29tcG9zaXRlfQotICogQHNlZSB7QGxpbmsgQ2FzY2FkZUNvbXBvc2l0ZX0KLSAqCi0gKiBAdmVyc2lvbiAyLjIKLSAqIEBzaW5jZSAyLjIKLSAqLwotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rMV8xT3JtTWFueVRvT25lTWFwcGluZ0NvbXBvc2l0ZSBleHRlbmRzIEVjbGlwc2VMaW5rTWFueVRvT25lTWFwcGluZ0NvbXBvc2l0ZQotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+RWNsaXBzZUxpbmsxXzFNYW55VG9PbmVNYXBwaW5nQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBzdWJqZWN0SG9sZGVyIFRoZSBob2xkZXIgb2YgdGhlIHN1YmplY3QgPGNvZGU+TWFueVRvT25lTWFwcGluZzwvY29kZT4KLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICogQHBhcmFtIHdpZGdldEZhY3RvcnkgVGhlIGZhY3RvcnkgdXNlZCB0byBjcmVhdGUgdmFyaW91cyBjb21tb24gd2lkZ2V0cwotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGluazFfMU9ybU1hbnlUb09uZU1hcHBpbmdDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBNYW55VG9PbmVNYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJaW50IGdyb3VwQm94TWFyZ2luID0gZ2V0R3JvdXBCb3hNYXJnaW4oKTsKLQkJCi0JCW5ldyBUYXJnZXRFbnRpdHlDb21wb3NpdGUodGhpcywgYWRkUGFuZShjb250YWluZXIsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBNYW55VG9PbmVKb2luaW5nU3RyYXRlZ3lQYW5lKHRoaXMsIGJ1aWxkSm9pbmluZ0hvbGRlcigpLCBjb250YWluZXIpOwotCQluZXcgQWNjZXNzVHlwZUNvbXBvc2l0ZSh0aGlzLCBidWlsZEFjY2Vzc0hvbGRlckhvbGRlcigpLCBhZGRQYW5lKGNvbnRhaW5lciwgZ3JvdXBCb3hNYXJnaW4pKTsKLQkJbmV3IEZldGNoVHlwZUNvbXBvc2l0ZSh0aGlzLCBhZGRQYW5lKGNvbnRhaW5lciwgZ3JvdXBCb3hNYXJnaW4pKTsJCQotCQluZXcgSm9pbkZldGNoQ29tcG9zaXRlKHRoaXMsIGJ1aWxkSm9pbkZldGNoYWJsZUhvbGRlcigpLCBhZGRQYW5lKGNvbnRhaW5lciwgZ3JvdXBCb3hNYXJnaW4pKTsKLQkJbmV3IE9wdGlvbmFsQ29tcG9zaXRlKHRoaXMsIGFkZFBhbmUoY29udGFpbmVyLCBncm91cEJveE1hcmdpbikpOwotCQluZXcgQ2FzY2FkZUNvbXBvc2l0ZSh0aGlzLCBidWlsZENhc2NhZGVIb2xkZXIoKSwgYWRkU3ViUGFuZShjb250YWluZXIsIDUpKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxBY2Nlc3NIb2xkZXI+IGJ1aWxkQWNjZXNzSG9sZGVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxNYW55VG9PbmVNYXBwaW5nLCBBY2Nlc3NIb2xkZXI+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQWNjZXNzSG9sZGVyIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0UGVyc2lzdGVudEF0dHJpYnV0ZSgpOwotCQkJfQotCQl9OwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1NYW55VG9PbmVNYXBwaW5nVWlQcm92aWRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1NYW55VG9PbmVNYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4Y2E3NzM5Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtTWFueVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQub3JtLkVjbGlwc2VMaW5rT3JtTWFueVRvT25lTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuZGV0YWlscy5BYnN0cmFjdE1hbnlUb09uZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU9ybU1hbnlUb09uZU1hcHBpbmdVaVByb3ZpZGVyCi0JZXh0ZW5kcyBBYnN0cmFjdE1hbnlUb09uZU1hcHBpbmdVaVByb3ZpZGVyPEVjbGlwc2VMaW5rT3JtTWFueVRvT25lTWFwcGluZz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGluazFfMU9ybU1hbnlUb09uZU1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGluazFfMU9ybU1hbnlUb09uZU1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxFY2xpcHNlTGlua09ybU1hbnlUb09uZU1hcHBpbmc+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGluazFfMU9ybU1hbnlUb09uZU1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LMV8xX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0JCi0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua09ybU1hbnlUb09uZU1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmsxXzFPcm1NYW55VG9PbmVNYXBwaW5nQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1NYXBwZWRTdXBlcmNsYXNzVWlQcm92aWRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1NYXBwZWRTdXBlcmNsYXNzVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxMTUwY2M4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtTWFwcGVkU3VwZXJjbGFzc1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDUzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiAgQ29weXJpZ2h0IChjKSAyMDA5ICBPcmFjbGUuIAotICogIEFsbCByaWdodHMgcmVzZXJ2ZWQuICBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSAKLSAqICBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCAKLSAqICBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAKLSAqICBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotICogIAotICogIENvbnRyaWJ1dG9yczogCi0gKiAgCU9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5KcHRFY2xpcHNlTGlua0NvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5vcm0uRWNsaXBzZUxpbmtPcm1NYXBwZWRTdXBlcmNsYXNzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLlR5cGVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuZGV0YWlscy5BYnN0cmFjdE1hcHBlZFN1cGVyY2xhc3NVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU9ybU1hcHBlZFN1cGVyY2xhc3NVaVByb3ZpZGVyIAotCWV4dGVuZHMgQWJzdHJhY3RNYXBwZWRTdXBlcmNsYXNzVWlQcm92aWRlcjxFY2xpcHNlTGlua09ybU1hcHBlZFN1cGVyY2xhc3M+Ci17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgRWNsaXBzZUxpbmsxXzFPcm1NYXBwZWRTdXBlcmNsYXNzVWlQcm92aWRlciBJTlNUQU5DRSA9IAotCQluZXcgRWNsaXBzZUxpbmsxXzFPcm1NYXBwZWRTdXBlcmNsYXNzVWlQcm92aWRlcigpOwotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgVHlwZU1hcHBpbmdVaVByb3ZpZGVyPEVjbGlwc2VMaW5rT3JtTWFwcGVkU3VwZXJjbGFzcz4gaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0JCi0JCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEVjbGlwc2VMaW5rMV8xT3JtTWFwcGVkU3VwZXJjbGFzc1VpUHJvdmlkZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQotCXB1YmxpYyBJQ29udGVudFR5cGUgZ2V0Q29udGVudFR5cGUoKSB7Ci0JCXJldHVybiBKcHRFY2xpcHNlTGlua0NvcmVQbHVnaW4uRUNMSVBTRUxJTksxXzFfT1JNX1hNTF9DT05URU5UX1RZUEU7Ci0JfQotCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZFBlcnNpc3RlbnRUeXBlTWFwcGluZ0NvbXBvc2l0ZShKcGFVaUZhY3RvcnkgZmFjdG9yeSwgUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rT3JtTWFwcGVkU3VwZXJjbGFzcz4gc3ViamVjdEhvbGRlciwgQ29tcG9zaXRlIHBhcmVudCwgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmtPcm1NYXBwZWRTdXBlcmNsYXNzQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1PbmVUb01hbnlNYXBwaW5nQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybU9uZVRvTWFueU1hcHBpbmdDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDE3YzIxYi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybU9uZVRvTWFueU1hcHBpbmdDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDYxICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkFjY2Vzc0hvbGRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0Lk9uZVRvTWFueU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5FY2xpcHNlTGlua09uZVRvTWFueU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtPbmVUb01hbnlKb2luaW5nU3RyYXRlZ3lQYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkVjbGlwc2VMaW5rT25lVG9NYW55TWFwcGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5Kb2luRmV0Y2hDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuUHJpdmF0ZU93bmVkQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFjY2Vzc1R5cGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuQ2FzY2FkZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5GZXRjaFR5cGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuT3JkZXJpbmdDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuVGFyZ2V0RW50aXR5Q29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU9ybU9uZVRvTWFueU1hcHBpbmdDb21wb3NpdGUgZXh0ZW5kcyBFY2xpcHNlTGlua09uZVRvTWFueU1hcHBpbmdDb21wb3NpdGUKLXsKLQlwdWJsaWMgRWNsaXBzZUxpbmsxXzFPcm1PbmVUb01hbnlNYXBwaW5nQ29tcG9zaXRlKAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBFY2xpcHNlTGlua09uZVRvTWFueU1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlpbnQgZ3JvdXBCb3hNYXJnaW4gPSBnZXRHcm91cEJveE1hcmdpbigpOwotCQkKLQkJbmV3IFRhcmdldEVudGl0eUNvbXBvc2l0ZSh0aGlzLCBhZGRQYW5lKGNvbnRhaW5lciwgZ3JvdXBCb3hNYXJnaW4pKTsKLQkJbmV3IEVjbGlwc2VMaW5rT25lVG9NYW55Sm9pbmluZ1N0cmF0ZWd5UGFuZSh0aGlzLCBidWlsZEpvaW5pbmdIb2xkZXIoKSwgY29udGFpbmVyKTsKLQkJbmV3IEFjY2Vzc1R5cGVDb21wb3NpdGUodGhpcywgYnVpbGRBY2Nlc3NIb2xkZXJIb2xkZXIoKSwgYWRkUGFuZShjb250YWluZXIsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBGZXRjaFR5cGVDb21wb3NpdGUodGhpcywgYWRkUGFuZShjb250YWluZXIsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBKb2luRmV0Y2hDb21wb3NpdGUodGhpcywgYnVpbGRKb2luRmV0Y2hhYmxlSG9sZGVyKCksIGFkZFBhbmUoY29udGFpbmVyLCBncm91cEJveE1hcmdpbikpOwotCQluZXcgUHJpdmF0ZU93bmVkQ29tcG9zaXRlKHRoaXMsIGJ1aWxkUHJpdmF0ZU93bmFibGVIb2xkZXIoKSwgYWRkUGFuZShjb250YWluZXIsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBDYXNjYWRlQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQ2FzY2FkZUhvbGRlcigpLCBhZGRTdWJQYW5lKGNvbnRhaW5lciwgNSkpOwotCQluZXcgT3JkZXJpbmdDb21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxBY2Nlc3NIb2xkZXI+IGJ1aWxkQWNjZXNzSG9sZGVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxPbmVUb01hbnlNYXBwaW5nLCBBY2Nlc3NIb2xkZXI+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQWNjZXNzSG9sZGVyIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0UGVyc2lzdGVudEF0dHJpYnV0ZSgpOwotCQkJfQotCQl9OwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybU9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybU9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDg4Y2ZlZDcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1PbmVUb01hbnlNYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5KcHRFY2xpcHNlTGlua0NvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5vcm0uRWNsaXBzZUxpbmtPcm1PbmVUb01hbnlNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFic3RyYWN0T25lVG9NYW55TWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rMV8xT3JtT25lVG9NYW55TWFwcGluZ1VpUHJvdmlkZXIKLQlleHRlbmRzIEFic3RyYWN0T25lVG9NYW55TWFwcGluZ1VpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1PbmVUb01hbnlNYXBwaW5nPgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEVjbGlwc2VMaW5rMV8xT3JtT25lVG9NYW55TWFwcGluZ1VpUHJvdmlkZXIgSU5TVEFOQ0UgPSAKLQkJbmV3IEVjbGlwc2VMaW5rMV8xT3JtT25lVG9NYW55TWFwcGluZ1VpUHJvdmlkZXIoKTsKLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyPEVjbGlwc2VMaW5rT3JtT25lVG9NYW55TWFwcGluZz4gaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0JCi0JCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEVjbGlwc2VMaW5rMV8xT3JtT25lVG9NYW55TWFwcGluZ1VpUHJvdmlkZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQotCXB1YmxpYyBJQ29udGVudFR5cGUgZ2V0Q29udGVudFR5cGUoKSB7Ci0JCXJldHVybiBKcHRFY2xpcHNlTGlua0NvcmVQbHVnaW4uRUNMSVBTRUxJTksxXzFfT1JNX1hNTF9DT05URU5UX1RZUEU7Ci0JfQkKLQkKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGJ1aWxkQXR0cmlidXRlTWFwcGluZ0NvbXBvc2l0ZSgKLQkJCUpwYVVpRmFjdG9yeSBmYWN0b3J5LAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rT3JtT25lVG9NYW55TWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGluazFfMU9ybU9uZVRvTWFueU1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybU9uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1PbmVUb09uZU1hcHBpbmdDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMWI0ZWRlZC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybU9uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTE0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkFjY2Vzc0hvbGRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0Lk9uZVRvT25lTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua09uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5Kb2luRmV0Y2hDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuUHJpdmF0ZU93bmVkQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFjY2Vzc1R5cGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuQ2FzY2FkZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5GZXRjaFR5cGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuT25lVG9PbmVKb2luaW5nU3RyYXRlZ3lQYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLk9wdGlvbmFsQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLlRhcmdldEVudGl0eUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBIZXJlIHRoZSBsYXlvdXQgb2YgdGhpcyBwYW5lOgotICogPHByZT4KLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBUYXJnZXRFbnRpdHlDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IEZldGNoVHlwZUNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgTWFwcGVkQnlQYW5lICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgT3B0aW9uYWxDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBDYXNjYWRlQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IEpvaW5Db2x1bW5Db21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS08L3ByZT4KLSAqCi0gKiBAc2VlIE9uZVRvT25lTWFwcGluZwotICogQHNlZSBCYXNlSnBhVWlGYWN0b3J5IC0gVGhlIGZhY3RvcnkgY3JlYXRpbmcgdGhpcyBwYW5lCi0gKiBAc2VlIENhc2NhZGVDb21wb3NpdGUKLSAqIEBzZWUgRmV0Y2hUeXBlQ29tcG9zaXRlCi0gKiBAc2VlIEpvaW5Db2x1bW5Db21wb3NpdGUKLSAqIEBzZWUgTWFwcGVkQnlQYW5lCi0gKiBAc2VlIE9wdGlvbmFsQ29tcG9zaXRlCi0gKiBAc2VlIFRhcmdldEVudGl0eUNvbXBvc2l0ZQotICoKLSAqIEB2ZXJzaW9uIDIuMgotICogQHNpbmNlIDIuMgotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmsxXzFPcm1PbmVUb09uZU1hcHBpbmdDb21wb3NpdGUgZXh0ZW5kcyBFY2xpcHNlTGlua09uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZQotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+RWNsaXBzZWxpbmsxXzFPbmVUb09uZU1hcHBpbmdDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHN1YmplY3RIb2xkZXIgVGhlIGhvbGRlciBvZiB0aGUgc3ViamVjdCA8Y29kZT5JT25lVG9PbmVNYXBwaW5nPC9jb2RlPgotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKiBAcGFyYW0gd2lkZ2V0RmFjdG9yeSBUaGUgZmFjdG9yeSB1c2VkIHRvIGNyZWF0ZSB2YXJpb3VzIGNvbW1vbiB3aWRnZXRzCi0JICovCi0JcHVibGljIEVjbGlwc2VMaW5rMV8xT3JtT25lVG9PbmVNYXBwaW5nQ29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgT25lVG9PbmVNYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlpbnQgZ3JvdXBCb3hNYXJnaW4gPSBnZXRHcm91cEJveE1hcmdpbigpOwotCi0JCW5ldyBUYXJnZXRFbnRpdHlDb21wb3NpdGUodGhpcywgYWRkUGFuZShjb250YWluZXIsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBBY2Nlc3NUeXBlQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQWNjZXNzSG9sZGVySG9sZGVyKCksIGFkZFBhbmUoY29udGFpbmVyLCBncm91cEJveE1hcmdpbikpOwotCQluZXcgT25lVG9PbmVKb2luaW5nU3RyYXRlZ3lQYW5lKHRoaXMsIGJ1aWxkSm9pbmluZ0hvbGRlcigpLCBjb250YWluZXIpOwotCQluZXcgRmV0Y2hUeXBlQ29tcG9zaXRlKHRoaXMsIGFkZFBhbmUoY29udGFpbmVyLCBncm91cEJveE1hcmdpbikpOwotCQluZXcgSm9pbkZldGNoQ29tcG9zaXRlKHRoaXMsIGJ1aWxkSm9pbkZldGNoYWJsZUhvbGRlcigpLCBhZGRQYW5lKGNvbnRhaW5lciwgZ3JvdXBCb3hNYXJnaW4pKTsKLQkJbmV3IE9wdGlvbmFsQ29tcG9zaXRlKHRoaXMsIGFkZFBhbmUoY29udGFpbmVyLCBncm91cEJveE1hcmdpbikpOwotCQluZXcgUHJpdmF0ZU93bmVkQ29tcG9zaXRlKHRoaXMsIGJ1aWxkUHJpdmF0ZU93bmFibGVIb2xkZXIoKSwgYWRkUGFuZShjb250YWluZXIsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBDYXNjYWRlQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQ2FzY2FkZUhvbGRlcigpLCBhZGRTdWJQYW5lKGNvbnRhaW5lciwgNSkpOwotCX0KLQkJCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxBY2Nlc3NIb2xkZXI+IGJ1aWxkQWNjZXNzSG9sZGVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxPbmVUb09uZU1hcHBpbmcsIEFjY2Vzc0hvbGRlcj4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBBY2Nlc3NIb2xkZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRQZXJzaXN0ZW50QXR0cmlidXRlKCk7Ci0JCQl9Ci0JCX07Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1PbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAxMGNiNjYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1PbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLmNvbnRlbnQuSUNvbnRlbnRUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLkpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0Lm9ybS5FY2xpcHNlTGlua09ybU9uZVRvT25lTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuZGV0YWlscy5BYnN0cmFjdE9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rMV8xT3JtT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcgotCWV4dGVuZHMgQWJzdHJhY3RPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyPEVjbGlwc2VMaW5rT3JtT25lVG9PbmVNYXBwaW5nPgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEVjbGlwc2VMaW5rMV8xT3JtT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlciBJTlNUQU5DRSA9IAotCQluZXcgRWNsaXBzZUxpbmsxXzFPcm1PbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxFY2xpcHNlTGlua09ybU9uZVRvT25lTWFwcGluZz4gaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0JCi0JCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEVjbGlwc2VMaW5rMV8xT3JtT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JcHVibGljIElDb250ZW50VHlwZSBnZXRDb250ZW50VHlwZSgpIHsKLQkJcmV0dXJuIEpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbi5FQ0xJUFNFTElOSzFfMV9PUk1fWE1MX0NPTlRFTlRfVFlQRTsKLQl9CQotCQotCXB1YmxpYyBKcGFDb21wb3NpdGUgYnVpbGRBdHRyaWJ1dGVNYXBwaW5nQ29tcG9zaXRlKAotCQkJSnBhVWlGYWN0b3J5IGZhY3RvcnksCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtPcm1PbmVUb09uZU1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmsxXzFPcm1PbmVUb09uZU1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybVRyYW5zZm9ybWF0aW9uTWFwcGluZ1VpUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtVHJhbnNmb3JtYXRpb25NYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5ZDc3NmQ4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtVHJhbnNmb3JtYXRpb25NYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LlRyYW5zZm9ybWF0aW9uTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5KcHRFY2xpcHNlTGlua0NvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtUcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLlRyYW5zZm9ybWF0aW9uTWFwcGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmsxXzFPcm1UcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyIGV4dGVuZHMgRWNsaXBzZUxpbmtUcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyPFRyYW5zZm9ybWF0aW9uTWFwcGluZz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGluazFfMU9ybVRyYW5zZm9ybWF0aW9uTWFwcGluZ1VpUHJvdmlkZXIgSU5TVEFOQ0UgPSAKLQkJbmV3IEVjbGlwc2VMaW5rMV8xT3JtVHJhbnNmb3JtYXRpb25NYXBwaW5nVWlQcm92aWRlcigpOwotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8VHJhbnNmb3JtYXRpb25NYXBwaW5nPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmsxXzFPcm1UcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LMV8xX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0KLQkKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGJ1aWxkQXR0cmlidXRlTWFwcGluZ0NvbXBvc2l0ZSgKLQkJSnBhVWlGYWN0b3J5IGZhY3RvcnksCi0JCVByb3BlcnR5VmFsdWVNb2RlbDxUcmFuc2Zvcm1hdGlvbk1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQkKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbk1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybVRyYW5zaWVudE1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybVRyYW5zaWVudE1hcHBpbmdVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDY2MjczYWEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1UcmFuc2llbnRNYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICBDb3B5cmlnaHQgKGMpIDIwMDkgIE9yYWNsZS4gCi0gKiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4gIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIAotICogIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIAotICogIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IAotICogIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0gKiAgCi0gKiAgQ29udHJpYnV0b3JzOiAKLSAqICAJT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLmNvbnRlbnQuSUNvbnRlbnRUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQub3JtLk9ybVRyYW5zaWVudE1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFic3RyYWN0VHJhbnNpZW50TWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rMV8xT3JtVHJhbnNpZW50TWFwcGluZ1VpUHJvdmlkZXIKLQlleHRlbmRzIEFic3RyYWN0VHJhbnNpZW50TWFwcGluZ1VpUHJvdmlkZXI8T3JtVHJhbnNpZW50TWFwcGluZz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGluazFfMU9ybVRyYW5zaWVudE1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGluazFfMU9ybVRyYW5zaWVudE1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxPcm1UcmFuc2llbnRNYXBwaW5nPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmsxXzFPcm1UcmFuc2llbnRNYXBwaW5nVWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JcHVibGljIElDb250ZW50VHlwZSBnZXRDb250ZW50VHlwZSgpIHsKLQkJcmV0dXJuIEpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbi5FQ0xJUFNFTElOSzFfMV9PUk1fWE1MX0NPTlRFTlRfVFlQRTsKLQl9CQotCQotCXB1YmxpYyBKcGFDb21wb3NpdGUgYnVpbGRBdHRyaWJ1dGVNYXBwaW5nQ29tcG9zaXRlKAotCQkJSnBhVWlGYWN0b3J5IGZhY3RvcnksCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8T3JtVHJhbnNpZW50TWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJcmV0dXJuIGZhY3RvcnkuY3JlYXRlT3JtVHJhbnNpZW50TWFwcGluZ0NvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybVZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0ZmJhMjlkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLmNvbnRlbnQuSUNvbnRlbnRUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuVmFyaWFibGVPbmVUb09uZU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkVjbGlwc2VMaW5rVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLlZhcmlhYmxlT25lVG9PbmVNYXBwaW5nQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU9ybVZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlciBleHRlbmRzIEVjbGlwc2VMaW5rVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyPFZhcmlhYmxlT25lVG9PbmVNYXBwaW5nPgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEVjbGlwc2VMaW5rMV8xT3JtVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGluazFfMU9ybVZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcigpOwotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8VmFyaWFibGVPbmVUb09uZU1hcHBpbmc+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGluazFfMU9ybVZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JcHVibGljIElDb250ZW50VHlwZSBnZXRDb250ZW50VHlwZSgpIHsKLQkJcmV0dXJuIEpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbi5FQ0xJUFNFTElOSzFfMV9PUk1fWE1MX0NPTlRFTlRfVFlQRTsKLQl9Ci0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxWYXJpYWJsZU9uZVRvT25lTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJcmV0dXJuIG5ldyBWYXJpYWJsZU9uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtVmVyc2lvbk1hcHBpbmdDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtVmVyc2lvbk1hcHBpbmdDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNGU2N2IzZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGluazFfMU9ybVZlcnNpb25NYXBwaW5nQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw2MSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5BY2Nlc3NIb2xkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5WZXJzaW9uTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua1ZlcnNpb25NYXBwaW5nQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLk11dGFibGVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmRldGFpbHMuQWNjZXNzVHlwZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5Db2x1bW5Db21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU9ybVZlcnNpb25NYXBwaW5nQ29tcG9zaXRlIGV4dGVuZHMgRWNsaXBzZUxpbmtWZXJzaW9uTWFwcGluZ0NvbXBvc2l0ZQotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+RWNsaXBzZUxpbmtPcm1WZXJzaW9uTWFwcGluZ0NvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gc3ViamVjdEhvbGRlciBUaGUgaG9sZGVyIG9mIHRoZSBzdWJqZWN0IDxjb2RlPlZlcnNpb25NYXBwaW5nPC9jb2RlPgotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKiBAcGFyYW0gd2lkZ2V0RmFjdG9yeSBUaGUgZmFjdG9yeSB1c2VkIHRvIGNyZWF0ZSB2YXJpb3VzIGNvbW1vbiB3aWRnZXRzCi0JICovCi0JcHVibGljIEVjbGlwc2VMaW5rMV8xT3JtVmVyc2lvbk1hcHBpbmdDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBWZXJzaW9uTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplR2VuZXJhbFBhbmUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlpbnQgZ3JvdXBCb3hNYXJnaW4gPSBnZXRHcm91cEJveE1hcmdpbigpOwotCQkKLQkJLy8gQ29sdW1uIHdpZGdldHMKLQkJbmV3IENvbHVtbkNvbXBvc2l0ZSh0aGlzLCBidWlsZENvbHVtbkhvbGRlcigpLCBjb250YWluZXIpOwotCQkKLQkJLy8gQWxpZ24gdGhlIHdpZGdldHMgdW5kZXIgdGhlIENvbHVtbkNvbXBvc2l0ZQotCQljb250YWluZXIgPSBhZGRTdWJQYW5lKGNvbnRhaW5lciwgMCwgZ3JvdXBCb3hNYXJnaW4sIDAsIGdyb3VwQm94TWFyZ2luKTsKLQotCQluZXcgQWNjZXNzVHlwZUNvbXBvc2l0ZSh0aGlzLCBidWlsZEFjY2Vzc0hvbGRlckhvbGRlcigpLCBjb250YWluZXIpOwotCQluZXcgTXV0YWJsZUNvbXBvc2l0ZSh0aGlzLCBidWlsZE11dGFibGVIb2xkZXIoKSwgY29udGFpbmVyKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxBY2Nlc3NIb2xkZXI+IGJ1aWxkQWNjZXNzSG9sZGVySG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxWZXJzaW9uTWFwcGluZywgQWNjZXNzSG9sZGVyPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEFjY2Vzc0hvbGRlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldFBlcnNpc3RlbnRBdHRyaWJ1dGUoKTsKLQkJCX0KLQkJfTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1WZXJzaW9uTWFwcGluZ1VpUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rMV8xT3JtVmVyc2lvbk1hcHBpbmdVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQzY2FiNzkuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmsxXzFPcm1WZXJzaW9uTWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQub3JtLkVjbGlwc2VMaW5rT3JtVmVyc2lvbk1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVVpRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5BdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmRldGFpbHMuQWJzdHJhY3RWZXJzaW9uTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rMV8xT3JtVmVyc2lvbk1hcHBpbmdVaVByb3ZpZGVyCi0JZXh0ZW5kcyBBYnN0cmFjdFZlcnNpb25NYXBwaW5nVWlQcm92aWRlcjxFY2xpcHNlTGlua09ybVZlcnNpb25NYXBwaW5nPgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEVjbGlwc2VMaW5rMV8xT3JtVmVyc2lvbk1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGluazFfMU9ybVZlcnNpb25NYXBwaW5nVWlQcm92aWRlcigpOwotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1WZXJzaW9uTWFwcGluZz4gaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0JCi0JCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEVjbGlwc2VMaW5rMV8xT3JtVmVyc2lvbk1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LMV8xX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0JCi0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua09ybVZlcnNpb25NYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rMV8xT3JtVmVyc2lvbk1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua0NvbnZlcnRlckRpYWxvZy5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtDb252ZXJ0ZXJEaWFsb2cuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDgwZWQ1OS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua0NvbnZlcnRlckRpYWxvZy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTk1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuRWNsaXBzZUxpbmtDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLkVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkRpYWxvZ1BhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuVmFsaWRhdGluZ0RpYWxvZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlN0YXRpY0xpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5TaGVsbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5UZXh0OwotCi0vKioKLSAqIENsaWVudHMgY2FuIHVzZSB0aGlzIGRpYWxvZyB0byBwcm9tcHQgdGhlIHVzZXIgZm9yIFNlY29uZGFyeVRhYmxlIHNldHRpbmdzLgotICogVXNlIHRoZSBmb2xsb3dpbmcgb25jZSB0aGUgZGlhbG9nIGlzIGNsb3NlZDoKLSAqICAgICBAc2VlICNnZXRTZWxlY3RlZFRhYmxlKCkKLSAqICAgICBAc2VlICNnZXRTZWxlY3RlZENhdGFsb2coKQotICogICAgIEBzZWUgI2dldFNlbGVjdGVkU2NoZW1hKCkKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtDb252ZXJ0ZXJEaWFsb2cgZXh0ZW5kcyBWYWxpZGF0aW5nRGlhbG9nPEVjbGlwc2VMaW5rQ29udmVydGVyU3RhdGVPYmplY3Q+IHsKLQotCQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIFVzZSB0aGlzIGNvbnN0cnVjdG9yIHRvIGVkaXQgYW4gZXhpc3RpbmcgY29udmVyc2lvbiB2YWx1ZQotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGlua0NvbnZlcnRlckRpYWxvZyhTaGVsbCBwYXJlbnQpIHsKLQkJc3VwZXIocGFyZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgRWNsaXBzZUxpbmtDb252ZXJ0ZXJTdGF0ZU9iamVjdCBidWlsZFN0YXRlT2JqZWN0KCkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rQ29udmVydGVyU3RhdGVPYmplY3QoKTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIG9wZW4gKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgY29uZmlndXJlU2hlbGwoU2hlbGwgc2hlbGwpIHsKLQkJc3VwZXIuY29uZmlndXJlU2hlbGwoc2hlbGwpOwotCQlzaGVsbC5zZXRUZXh0KHRoaXMuZ2V0VGl0bGUoKSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXRUaXRsZSgpIHsKLQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkVjbGlwc2VMaW5rQ29udmVydGVyRGlhbG9nX2FkZENvbnZlcnRlcjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERlc2NyaXB0aW9uVGl0bGUoKSB7Ci0JCXJldHVybiBFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5FY2xpcHNlTGlua0NvbnZlcnRlckRpYWxvZ19hZGRDb252ZXJ0ZXJEZXNjcmlwdGlvblRpdGxlOwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERlc2NyaXB0aW9uKCkgewotCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRWNsaXBzZUxpbmtDb252ZXJ0ZXJEaWFsb2dfYWRkQ29udmVydGVyRGVzY3JpcHRpb247Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBEaWFsb2dQYW5lPEVjbGlwc2VMaW5rQ29udmVydGVyU3RhdGVPYmplY3Q+IGJ1aWxkTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJcmV0dXJuIG5ldyBDb252ZXJzaW9uVmFsdWVEaWFsb2dQYW5lKGNvbnRhaW5lcik7Ci0JfQotCQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGNyZWF0ZSgpIHsKLQkJc3VwZXIuY3JlYXRlKCk7Ci0KLQkJQ29udmVyc2lvblZhbHVlRGlhbG9nUGFuZSBwYW5lID0gKENvbnZlcnNpb25WYWx1ZURpYWxvZ1BhbmUpIGdldFBhbmUoKTsKLQkJcGFuZS5zZWxlY3RBbGwoKTsKLQotCQlnZXRCdXR0b24oT0spLnNldEVuYWJsZWQoZmFsc2UpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBwdWJsaWMgQVBJICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB0aGUgZGF0YSB2YWx1ZSBzZXQgaW4gdGhlIHRleHQgd2lkZ2V0LgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0TmFtZSgpIHsKLQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXROYW1lKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBvYmplY3QgdmFsdWUgc2V0IGluIHRoZSB0ZXh0IHdpZGdldC4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdldENvbnZlcnRlclR5cGUoKSB7Ci0JCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0Q29udmVydGVyVHlwZSgpOwotCX0KLQkKLQlwcml2YXRlIGNsYXNzIENvbnZlcnNpb25WYWx1ZURpYWxvZ1BhbmUgZXh0ZW5kcyBEaWFsb2dQYW5lPEVjbGlwc2VMaW5rQ29udmVydGVyU3RhdGVPYmplY3Q+IHsKLQotCQlwcml2YXRlIFRleHQgbmFtZVRleHQ7Ci0KLQkJQ29udmVyc2lvblZhbHVlRGlhbG9nUGFuZShDb21wb3NpdGUgcGFyZW50KSB7Ci0JCQlzdXBlcihFY2xpcHNlTGlua0NvbnZlcnRlckRpYWxvZy50aGlzLmdldFN1YmplY3RIb2xkZXIoKSwgcGFyZW50KTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJCXRoaXMubmFtZVRleHQgPSBhZGRMYWJlbGVkVGV4dCgKLQkJCQljb250YWluZXIsCi0JCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRWNsaXBzZUxpbmtDb252ZXJ0ZXJEaWFsb2dfbmFtZSwKLQkJCQlidWlsZE5hbWVIb2xkZXIoKQotCQkJKTsKLQkJCQotCQkJYWRkTGFiZWxlZENvbWJvKAotCQkJCWNvbnRhaW5lciwgCi0JCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRWNsaXBzZUxpbmtDb252ZXJ0ZXJEaWFsb2dfY29udmVydGVyVHlwZSwgCi0JCQkJYnVpbGRDb252ZXJ0ZXJUeXBlTGlzdEhvbGRlcigpLCAKLQkJCQlidWlsZENvbnZlcnRlclR5cGVIb2xkZXIoKSwgCi0JCQkJYnVpbGRTdHJpbmdDb252ZXJ0ZXIoKSwKLQkJCQludWxsKTsKLQkJfQotCi0JCXByb3RlY3RlZCBMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkQ29udmVydGVyVHlwZUxpc3RIb2xkZXIoKSB7Ci0JCQlMaXN0PFN0cmluZz4gY29udmVydGVyVHlwZXMgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJCWNvbnZlcnRlclR5cGVzLmFkZChFY2xpcHNlTGlua0NvbnZlcnRlci5DVVNUT01fQ09OVkVSVEVSKTsKLQkJCWNvbnZlcnRlclR5cGVzLmFkZChFY2xpcHNlTGlua0NvbnZlcnRlci5PQkpFQ1RfVFlQRV9DT05WRVJURVIpOwotCQkJY29udmVydGVyVHlwZXMuYWRkKEVjbGlwc2VMaW5rQ29udmVydGVyLlNUUlVDVF9DT05WRVJURVIpOwotCQkJY29udmVydGVyVHlwZXMuYWRkKEVjbGlwc2VMaW5rQ29udmVydGVyLlRZUEVfQ09OVkVSVEVSKTsKLQkJCQotCQkJcmV0dXJuIG5ldyBTdGF0aWNMaXN0VmFsdWVNb2RlbDxTdHJpbmc+KGNvbnZlcnRlclR5cGVzKTsKLQkJfQotCQkKLQkJcHJpdmF0ZSBTdHJpbmdDb252ZXJ0ZXI8U3RyaW5nPiBidWlsZFN0cmluZ0NvbnZlcnRlcigpIHsKLQkJCXJldHVybiBuZXcgU3RyaW5nQ29udmVydGVyPFN0cmluZz4oKSB7Ci0JCQkJcHVibGljIFN0cmluZyBjb252ZXJ0VG9TdHJpbmcoU3RyaW5nIHZhbHVlKSB7Ci0JCQkJCWlmICh2YWx1ZSA9PSBFY2xpcHNlTGlua0NvbnZlcnRlci5DVVNUT01fQ09OVkVSVEVSKSB7Ci0JCQkJCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQ29udmVydGVyc0NvbXBvc2l0ZV9jdXN0b21Db252ZXJ0ZXI7Ci0JCQkJCX0KLQkJCQkJaWYgKHZhbHVlID09IEVjbGlwc2VMaW5rQ29udmVydGVyLk9CSkVDVF9UWVBFX0NPTlZFUlRFUikgewotCQkJCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkNvbnZlcnRlcnNDb21wb3NpdGVfb2JqZWN0VHlwZUNvbnZlcnRlcjsKLQkJCQkJfQotCQkJCQlpZiAodmFsdWUgPT0gRWNsaXBzZUxpbmtDb252ZXJ0ZXIuU1RSVUNUX0NPTlZFUlRFUikgewotCQkJCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkNvbnZlcnRlcnNDb21wb3NpdGVfc3RydWN0Q29udmVydGVyOwotCQkJCQl9Ci0JCQkJCWlmICh2YWx1ZSA9PSBFY2xpcHNlTGlua0NvbnZlcnRlci5UWVBFX0NPTlZFUlRFUikgewotCQkJCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLkNvbnZlcnRlcnNDb21wb3NpdGVfdHlwZUNvbnZlcnRlcjsKLQkJCQkJfQotCQkJCQlyZXR1cm4gdmFsdWU7Ci0JCQkJfQotCQkJfTsKLQkJfQotCQkKLQkJcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkTmFtZUhvbGRlcigpIHsKLQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEVjbGlwc2VMaW5rQ29udmVydGVyU3RhdGVPYmplY3QsIFN0cmluZz4oZ2V0U3ViamVjdEhvbGRlcigpLCBFY2xpcHNlTGlua0NvbnZlcnRlclN0YXRlT2JqZWN0Lk5BTUVfUFJPUEVSVFkpIHsKLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldE5hbWUoKTsKLQkJCQl9Ci0KLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0JCQkJCXRoaXMuc3ViamVjdC5zZXROYW1lKHZhbHVlKTsKLQkJCQl9Ci0JCQl9OwotCQl9Ci0KLQkJcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkQ29udmVydGVyVHlwZUhvbGRlcigpIHsKLQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEVjbGlwc2VMaW5rQ29udmVydGVyU3RhdGVPYmplY3QsIFN0cmluZz4oZ2V0U3ViamVjdEhvbGRlcigpLCBFY2xpcHNlTGlua0NvbnZlcnRlclN0YXRlT2JqZWN0LkNPTlZFUlRFUl9UWVBFX1BST1BFUlRZKSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRDb252ZXJ0ZXJUeXBlKCk7Ci0JCQkJfQotCi0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCQkJCQl0aGlzLnN1YmplY3Quc2V0Q29udmVydGVyVHlwZSh2YWx1ZSk7Ci0JCQkJfQotCQkJfTsKLQkJfQotCi0JCXZvaWQgc2VsZWN0QWxsKCkgewotCQkJdGhpcy5uYW1lVGV4dC5zZWxlY3RBbGwoKTsKLQkJfQotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rQ29udmVydGVyU3RhdGVPYmplY3QuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rQ29udmVydGVyU3RhdGVPYmplY3QuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDcyZDExZC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua0NvbnZlcnRlclN0YXRlT2JqZWN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMjUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5ub2RlLkFic3RyYWN0Tm9kZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5ub2RlLk5vZGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubm9kZS5Qcm9ibGVtOwotCi0vKioKLSAqIFRoaXMgaXMgdGhlIHN0YXRlIG9iamVjdCB1c2VkIGJ5IHRoZSA8Y29kZT5FY2xpcHNlTGlua0NvbnZlcnRlckRpYWxvZzwvY29kZT4sIHdoaWNoIHN0b3JlcwotICogdGhlIGN1cnJlbnQgbmFtZSBhbmQgdmFsaWRhdGVzIGl0IHdoZW4gaXQgaXMgbW9kaWZpZWQuCi0gKgotICogQHNlZSBFY2xpcHNlTGlua0NvbnZlcnRlckRpYWxvZwotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1maW5hbCBjbGFzcyBFY2xpcHNlTGlua0NvbnZlcnRlclN0YXRlT2JqZWN0IGV4dGVuZHMgQWJzdHJhY3ROb2RlCi17Ci0JLyoqCi0JICogVGhlIGluaXRpYWwgbmFtZSBvciA8Y29kZT5udWxsPC9jb2RlPgotCSAqLwotCXByaXZhdGUgU3RyaW5nIG5hbWU7Ci0KLQkvKioKLQkgKiBUaGUgaW5pdGlhbCBjb252ZXJ0ZXJUeXBlIG9yIDxjb2RlPm51bGw8L2NvZGU+Ci0JICovCi0JcHJpdmF0ZSBTdHJpbmcgY29udmVydGVyVHlwZTsKLQotCS8qKgotCSAqIFRoZSA8Y29kZT5WYWxpZGF0b3I8L2NvZGU+IHVzZWQgdG8gdmFsaWRhdGUgdGhpcyBzdGF0ZSBvYmplY3QuCi0JICovCi0JcHJpdmF0ZSBWYWxpZGF0b3IgdmFsaWRhdG9yOwotCi0JLyoqCi0JICogTm90aWZpZXMgYSBjaGFuZ2UgaW4gdGhlIGRhdGEgdmFsdWUgcHJvcGVydHkuCi0JICovCi0Jc3RhdGljIGZpbmFsIFN0cmluZyBOQU1FX1BST1BFUlRZID0gIm5hbWVQcm9wZXJ0eSI7IC8vJE5PTi1OTFMtMSQKLQkKLQkvKioKLQkgKiBOb3RpZmllcyBhIGNoYW5nZSBpbiB0aGUgb2JqZWN0IHZhbHVlIHByb3BlcnR5LgotCSAqLwotCXN0YXRpYyBmaW5hbCBTdHJpbmcgQ09OVkVSVEVSX1RZUEVfUFJPUEVSVFkgPSAiY29udmVydGVyVHlwZVByb3BlcnR5IjsgLy8kTk9OLU5MUy0xJAotCi0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5OZXdOYW1lU3RhdGVPYmplY3Q8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIG5hbWUgVGhlIGluaXRpYWwgaW5wdXQgb3IgPGNvZGU+bnVsbDwvY29kZT4gaWYgbm8gaW5pdGlhbCB2YWx1ZSBjYW4KLQkgKiBiZSBzcGVjaWZpZWQKLQkgKiBAcGFyYW0gbmFtZXMgVGhlIGNvbGxlY3Rpb24gb2YgbmFtZXMgdGhhdCBjYW4ndCBiZSB1c2VkIG9yIGFuIGVtcHR5Ci0JICogY29sbGVjdGlvbiBpZiBub25lIGFyZSBhdmFpbGFibGUKLQkgKi8KLQlFY2xpcHNlTGlua0NvbnZlcnRlclN0YXRlT2JqZWN0KCkgewotCQlzdXBlcihudWxsKTsKLQotCX0KLQotCXByaXZhdGUgdm9pZCBhZGROYW1lUHJvYmxlbXNUbyhMaXN0PFByb2JsZW0+IGN1cnJlbnRQcm9ibGVtcykgewotCQlpZiAoU3RyaW5nVG9vbHMuc3RyaW5nSXNFbXB0eSh0aGlzLm5hbWUpKSB7Ci0JCQljdXJyZW50UHJvYmxlbXMuYWRkKGJ1aWxkUHJvYmxlbShFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5FY2xpcHNlTGlua0NvbnZlcnRlclN0YXRlT2JqZWN0X25hbWVNdXN0QmVTcGVjaWZpZWQpKTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBhZGRDb252ZXJ0ZXJUeXBlUHJvYmxlbXNUbyhMaXN0PFByb2JsZW0+IGN1cnJlbnRQcm9ibGVtcykgewotCQlpZiAoU3RyaW5nVG9vbHMuc3RyaW5nSXNFbXB0eSh0aGlzLmNvbnZlcnRlclR5cGUpKSB7Ci0JCQljdXJyZW50UHJvYmxlbXMuYWRkKGJ1aWxkUHJvYmxlbShFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5FY2xpcHNlTGlua0NvbnZlcnRlclN0YXRlT2JqZWN0X3R5cGVNdXN0QmVTcGVjaWZpZWQpKTsKLQkJfQotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGFkZFByb2JsZW1zVG8oTGlzdDxQcm9ibGVtPiBjdXJyZW50UHJvYmxlbXMpIHsKLQkJc3VwZXIuYWRkUHJvYmxlbXNUbyhjdXJyZW50UHJvYmxlbXMpOwotCQlhZGROYW1lUHJvYmxlbXNUbyhjdXJyZW50UHJvYmxlbXMpOwotCQlhZGRDb252ZXJ0ZXJUeXBlUHJvYmxlbXNUbyhjdXJyZW50UHJvYmxlbXMpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGNoZWNrUGFyZW50KEBTdXBwcmVzc1dhcm5pbmdzKCJ1bnVzZWQiKSBOb2RlIHBhcmVudE5vZGUpIHsKLQkJLy9ubyBwYXJlbnQKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGRpc3BsYXlTdHJpbmcoKSB7Ci0JCXJldHVybiBudWxsOwotCX0KLQotCVN0cmluZyBnZXROYW1lKCkgewotCQlyZXR1cm4gdGhpcy5uYW1lOwotCX0KLQotCVN0cmluZyBnZXRDb252ZXJ0ZXJUeXBlKCkgewotCQlyZXR1cm4gdGhpcy5jb252ZXJ0ZXJUeXBlOwotCX0KLQotCXB1YmxpYyB2b2lkIHNldE5hbWUoU3RyaW5nIG5ld05hbWUpIHsKLQkJU3RyaW5nIG9sZE5hbWUgPSB0aGlzLm5hbWU7Ci0JCXRoaXMubmFtZSA9IG5ld05hbWU7Ci0JCWZpcmVQcm9wZXJ0eUNoYW5nZWQoTkFNRV9QUk9QRVJUWSwgb2xkTmFtZSwgbmV3TmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0Q29udmVydGVyVHlwZShTdHJpbmcgbmV3Q29udmVydGVyVHlwZSkgewotCQlTdHJpbmcgb2xkQ29udmVydGVyVHlwZSA9IHRoaXMuY29udmVydGVyVHlwZTsKLQkJdGhpcy5jb252ZXJ0ZXJUeXBlID0gbmV3Q29udmVydGVyVHlwZTsKLQkJZmlyZVByb3BlcnR5Q2hhbmdlZChDT05WRVJURVJfVFlQRV9QUk9QRVJUWSwgb2xkQ29udmVydGVyVHlwZSwgbmV3Q29udmVydGVyVHlwZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgc2V0VmFsaWRhdG9yKFZhbGlkYXRvciB2YWxpZGF0b3IpIHsKLQkJdGhpcy52YWxpZGF0b3IgPSB2YWxpZGF0b3I7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFZhbGlkYXRvciBnZXRWYWxpZGF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLnZhbGlkYXRvcjsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua0VudGl0eU1hcHBpbmdzRGV0YWlsc1Byb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua0VudGl0eU1hcHBpbmdzRGV0YWlsc1Byb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDUzYTUwMTEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtFbnRpdHlNYXBwaW5nc0RldGFpbHNQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNjQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcGFTdHJ1Y3R1cmVOb2RlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQub3JtLk9ybVN0cnVjdHVyZU5vZGVzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLkpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFEZXRhaWxzUGFnZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFEZXRhaWxzUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFRoaXMgcHJvdmlkZXIgaXMgcmVzcG9uc2libGUgZm9yIGNyZWF0aW5nIHRoZSB7QGxpbmsgSnBhRGV0YWlsc1BhZ2V9Ci0gKiB3aGVuIHRoZSBpbmZvcm1hdGlvbiBjb21lcyBmcm9tIHRoZSBYTUwgZmlsZSAoZWl0aGVyIGZyb20gdGhlIHBlcnNpc3RlbmNlCi0gKiBjb25maWd1cmF0aW9uIG9yIGZyb20gdGhlIE1hcHBpbmdzIERlc2NyaXB0b3IpLgotICoKLSAqIEB2ZXJzaW9uIDIuMgotICogQHNpbmNlIDIuMgotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtFbnRpdHlNYXBwaW5nc0RldGFpbHNQcm92aWRlcgotCWltcGxlbWVudHMgSnBhRGV0YWlsc1Byb3ZpZGVyCi17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgSnBhRGV0YWlsc1Byb3ZpZGVyIElOU1RBTkNFID0gbmV3IEVjbGlwc2VMaW5rRW50aXR5TWFwcGluZ3NEZXRhaWxzUHJvdmlkZXIoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgSnBhRGV0YWlsc1Byb3ZpZGVyIGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEVjbGlwc2VMaW5rRW50aXR5TWFwcGluZ3NEZXRhaWxzUHJvdmlkZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQotCXB1YmxpYyBTdHJpbmcgZ2V0SWQoKSB7Ci0JCXJldHVybiBPcm1TdHJ1Y3R1cmVOb2Rlcy5FTlRJVFlfTUFQUElOR1NfSUQ7Ci0JfQotCQotCXB1YmxpYyBJQ29udGVudFR5cGUgZ2V0Q29udGVudFR5cGUoKSB7Ci0JCXJldHVybiBKcHRFY2xpcHNlTGlua0NvcmVQbHVnaW4uRUNMSVBTRUxJTktfT1JNX1hNTF9DT05URU5UX1RZUEU7Ci0JfQotCQotCXB1YmxpYyBKcGFEZXRhaWxzUGFnZTw/IGV4dGVuZHMgSnBhU3RydWN0dXJlTm9kZT4gYnVpbGREZXRhaWxzUGFnZSgKLQkJQ29tcG9zaXRlIHBhcmVudCwKLQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJcmV0dXJuIG5ldyBFbnRpdHlNYXBwaW5nc0RldGFpbHNQYWdlKHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUJhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUJhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGRhNTg2ZWEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1CYXNpY0NvbGxlY3Rpb25NYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkJhc2ljQ29sbGVjdGlvbk1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkJhc2ljQ29sbGVjdGlvbk1hcHBpbmdDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtCYXNpY0NvbGxlY3Rpb25NYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtPcm1CYXNpY0NvbGxlY3Rpb25NYXBwaW5nVWlQcm92aWRlciBleHRlbmRzIEVjbGlwc2VMaW5rQmFzaWNDb2xsZWN0aW9uTWFwcGluZ1VpUHJvdmlkZXI8QmFzaWNDb2xsZWN0aW9uTWFwcGluZz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGlua09ybUJhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGlua09ybUJhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxCYXNpY0NvbGxlY3Rpb25NYXBwaW5nPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmtPcm1CYXNpY0NvbGxlY3Rpb25NYXBwaW5nVWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JcHVibGljIElDb250ZW50VHlwZSBnZXRDb250ZW50VHlwZSgpIHsKLQkJcmV0dXJuIEpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbi5FQ0xJUFNFTElOS19PUk1fWE1MX0NPTlRFTlRfVFlQRTsKLQl9Ci0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxCYXNpY0NvbGxlY3Rpb25NYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEJhc2ljQ29sbGVjdGlvbk1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUJhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtQmFzaWNNYXBNYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3YTc0MzE1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtQmFzaWNNYXBNYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkJhc2ljTWFwTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5KcHRFY2xpcHNlTGlua0NvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuQmFzaWNNYXBNYXBwaW5nQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkVjbGlwc2VMaW5rQmFzaWNNYXBNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtPcm1CYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyIGV4dGVuZHMgRWNsaXBzZUxpbmtCYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyPEJhc2ljTWFwTWFwcGluZz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGlua09ybUJhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXIgSU5TVEFOQ0UgPSAKLQkJbmV3IEVjbGlwc2VMaW5rT3JtQmFzaWNNYXBNYXBwaW5nVWlQcm92aWRlcigpOwotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8QmFzaWNNYXBNYXBwaW5nPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmtPcm1CYXNpY01hcE1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0KLQkJCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxCYXNpY01hcE1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgQmFzaWNNYXBNYXBwaW5nQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1CYXNpY01hcHBpbmdDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtQmFzaWNNYXBwaW5nQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDBjMzBmM2UuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1CYXNpY01hcHBpbmdDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQ0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkJhc2ljTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkNvbnZlcnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtCYXNpY01hcHBpbmdDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vL1RlbXBvcmFyeSB0byByZW1vdmUgdGhlIENvbnZlcnRlcnMgc2VjdGlvbiBmcm9tIG9ybSBiYXNpYyBtYXBwaW5nLgotLy9UaGlzIGlzIHN1cHBvcnRlZCBpbiBFY2xpcHNlTGluayBpbiB2ZXJzaW9uIDEuMSwgYnV0IG5vdCAxLjAKLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua09ybUJhc2ljTWFwcGluZ0NvbXBvc2l0ZSBleHRlbmRzIEVjbGlwc2VMaW5rQmFzaWNNYXBwaW5nQ29tcG9zaXRlCi17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5FY2xpcHNlTGlua09ybUJhc2ljTWFwcGluZ0NvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gc3ViamVjdEhvbGRlciBUaGUgaG9sZGVyIG9mIHRoZSBzdWJqZWN0IDxjb2RlPkJhc2ljTWFwcGluZzwvY29kZT4KLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICogQHBhcmFtIHdpZGdldEZhY3RvcnkgVGhlIGZhY3RvcnkgdXNlZCB0byBjcmVhdGUgdmFyaW91cyBjb21tb24gd2lkZ2V0cwotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGlua09ybUJhc2ljTWFwcGluZ0NvbXBvc2l0ZShQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIEJhc2ljTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQkvL2V2ZXJ5dGhpbmcgYnV0IHRoZSAnRGVmYWluZSBDb252ZXJ0ZXInIHNlY3Rpb24uICBUaGlzIGlzIG5vdCBzdXBwb3J0ZWQgaW4gZWNsaXBzZWxpbmsgMS4wLCBidXQgaXMgaW4gMS4xCi0JcHJvdGVjdGVkIFBhbmU8Q29udmVydD4gYnVpbGRDb252ZXJ0Q29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDxDb252ZXJ0PiBjb252ZXJ0SG9sZGVyLCBDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCXJldHVybiBuZXcgT3JtQ29udmVydENvbXBvc2l0ZShjb252ZXJ0SG9sZGVyLCBjb250YWluZXIsIGdldFdpZGdldEZhY3RvcnkoKSk7Ci0JfQotCi19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1CYXNpY01hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUJhc2ljTWFwcGluZ1VpUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzVjYWIwZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUJhc2ljTWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQub3JtLkVjbGlwc2VMaW5rT3JtQmFzaWNNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFic3RyYWN0QmFzaWNNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtPcm1CYXNpY01hcHBpbmdVaVByb3ZpZGVyCi0JZXh0ZW5kcyBBYnN0cmFjdEJhc2ljTWFwcGluZ1VpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1CYXNpY01hcHBpbmc+Ci17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgRWNsaXBzZUxpbmtPcm1CYXNpY01hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGlua09ybUJhc2ljTWFwcGluZ1VpUHJvdmlkZXIoKTsKLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyPEVjbGlwc2VMaW5rT3JtQmFzaWNNYXBwaW5nPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmtPcm1CYXNpY01hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0KLQkKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGJ1aWxkQXR0cmlidXRlTWFwcGluZ0NvbXBvc2l0ZSgKLQkJCUpwYVVpRmFjdG9yeSBmYWN0b3J5LAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rT3JtQmFzaWNNYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQkKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGlua09ybUJhc2ljTWFwcGluZ0NvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtRW1iZWRkYWJsZUNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1FbWJlZGRhYmxlQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDRhY2Y0YzQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1FbWJlZGRhYmxlQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMDAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuQWNjZXNzSG9sZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQub3JtLkNvbnZlcnRlckhvbGRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0Lm9ybS5FY2xpcHNlTGlua09ybUVtYmVkZGFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLkVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkVjbGlwc2VMaW5rRW1iZWRkYWJsZUFkdmFuY2VkQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuZGV0YWlscy5BY2Nlc3NUeXBlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5NZXRhZGF0YUNvbXBsZXRlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5Pcm1KYXZhQ2xhc3NDaG9vc2VyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFRoaXMgcGFuZSBkb2VzIG5vdCBoYXZlIGFueSB3aWRnZXRzLgotICoKLSAqIEBzZWUgRW1iZWRkYWJsZQotICogQHNlZSBCYXNlSnBhVWlGYWN0b3J5IC0gVGhlIGZhY3RvcnkgY3JlYXRpbmcgdGhpcyBwYW5lCi0gKiBAc2VlIEVtYmVkZGFibGVVaVByb3ZpZGVyCi0gKgotICogQHZlcnNpb24gMi4xCi0gKiBAc2luY2UgMi4xCi0gKi8KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua09ybUVtYmVkZGFibGVDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxFY2xpcHNlTGlua09ybUVtYmVkZGFibGU+Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbXBsZW1lbnRzIEpwYUNvbXBvc2l0ZQotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+RW1iZWRkYWJsZUNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gc3ViamVjdEhvbGRlciBUaGUgaG9sZGVyIG9mIHRoaXMgcGFuZSdzIHN1YmplY3QKLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICogQHBhcmFtIHdpZGdldEZhY3RvcnkgVGhlIGZhY3RvcnkgdXNlZCB0byBjcmVhdGUgdmFyaW91cyBjb21tb24gd2lkZ2V0cwotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGlua09ybUVtYmVkZGFibGVDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBFY2xpcHNlTGlua09ybUVtYmVkZGFibGU+IHN1YmplY3RIb2xkZXIsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICBXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlpbml0aWFsaXplR2VuZXJhbFBhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZUNvbnZlcnRlcnNQYW5lKGNvbnRhaW5lcik7Ci0JCWluaXRpYWxpemVBZHZhbmNlZFBhbmUoY29udGFpbmVyKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUdlbmVyYWxQYW5lKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJbmV3IE9ybUphdmFDbGFzc0Nob29zZXIodGhpcywgZ2V0U3ViamVjdEhvbGRlcigpLCBjb250YWluZXIpOwotCQluZXcgQWNjZXNzVHlwZUNvbXBvc2l0ZSh0aGlzLCBidWlsZEFjY2Vzc0hvbGRlcigpLCBjb250YWluZXIpOwotCQluZXcgTWV0YWRhdGFDb21wbGV0ZUNvbXBvc2l0ZSh0aGlzLCBnZXRTdWJqZWN0SG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JfQotCQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8QWNjZXNzSG9sZGVyPiBidWlsZEFjY2Vzc0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8RWNsaXBzZUxpbmtPcm1FbWJlZGRhYmxlLCBBY2Nlc3NIb2xkZXI+KAotCQkJZ2V0U3ViamVjdEhvbGRlcigpKQotCQl7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBBY2Nlc3NIb2xkZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRQZXJzaXN0ZW50VHlwZSgpOwotCQkJfQotCQl9OwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVDb252ZXJ0ZXJzUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJY29udGFpbmVyID0gYWRkQ29sbGFwc2FibGVTZWN0aW9uKAotCQkJYWRkU3ViUGFuZShjb250YWluZXIsIDUpLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQ29udmVydGVyc0NvbXBvc2l0ZV9MYWJlbAotCQkpOwotCi0JCW5ldyBDb252ZXJ0ZXJzQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQ29udmVydGVySG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnRlckhvbGRlcj4gYnVpbGRDb252ZXJ0ZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEVjbGlwc2VMaW5rT3JtRW1iZWRkYWJsZSwgQ29udmVydGVySG9sZGVyPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENvbnZlcnRlckhvbGRlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldENvbnZlcnRlckhvbGRlcigpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplQWR2YW5jZWRQYW5lKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJbmV3IEVjbGlwc2VMaW5rRW1iZWRkYWJsZUFkdmFuY2VkQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtRW1iZWRkYWJsZVVpUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtRW1iZWRkYWJsZVVpUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDE0NTUzYS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUVtYmVkZGFibGVVaVByb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogIENvcHlyaWdodCAoYykgMjAwOCAgT3JhY2xlLiAKLSAqICBBbGwgcmlnaHRzIHJlc2VydmVkLiAgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgCi0gKiAgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggCi0gKiAgYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgCi0gKiAgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSAqICAKLSAqICBDb250cmlidXRvcnM6IAotICogIAlPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQub3JtLkVjbGlwc2VMaW5rT3JtRW1iZWRkYWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5UeXBlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmRldGFpbHMuQWJzdHJhY3RFbWJlZGRhYmxlVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtPcm1FbWJlZGRhYmxlVWlQcm92aWRlciAKLQlleHRlbmRzIEFic3RyYWN0RW1iZWRkYWJsZVVpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1FbWJlZGRhYmxlPgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEVjbGlwc2VMaW5rT3JtRW1iZWRkYWJsZVVpUHJvdmlkZXIgSU5TVEFOQ0UgPSAKLQkJbmV3IEVjbGlwc2VMaW5rT3JtRW1iZWRkYWJsZVVpUHJvdmlkZXIoKTsKLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFR5cGVNYXBwaW5nVWlQcm92aWRlcjxFY2xpcHNlTGlua09ybUVtYmVkZGFibGU+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGlua09ybUVtYmVkZGFibGVVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0KLQkKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGJ1aWxkUGVyc2lzdGVudFR5cGVNYXBwaW5nQ29tcG9zaXRlKAotCQkJSnBhVWlGYWN0b3J5IGZhY3RvcnksIAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rT3JtRW1iZWRkYWJsZT4gc3ViamVjdEhvbGRlciwgCi0JCQlDb21wb3NpdGUgcGFyZW50LCAKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rT3JtRW1iZWRkYWJsZUNvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtRW1iZWRkZWRJZE1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUVtYmVkZGVkSWRNYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjMzk1YWYxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtRW1iZWRkZWRJZE1hcHBpbmdVaVByb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogIENvcHlyaWdodCAoYykgMjAwOSAgT3JhY2xlLiAKLSAqICBBbGwgcmlnaHRzIHJlc2VydmVkLiAgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgCi0gKiAgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggCi0gKiAgYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgCi0gKiAgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSAqICAKLSAqICBDb250cmlidXRvcnM6IAotICogIAlPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5vcm0uT3JtRW1iZWRkZWRJZE1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFic3RyYWN0RW1iZWRkZWRJZE1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua09ybUVtYmVkZGVkSWRNYXBwaW5nVWlQcm92aWRlcgotCWV4dGVuZHMgQWJzdHJhY3RFbWJlZGRlZElkTWFwcGluZ1VpUHJvdmlkZXI8T3JtRW1iZWRkZWRJZE1hcHBpbmc+Ci17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgRWNsaXBzZUxpbmtPcm1FbWJlZGRlZElkTWFwcGluZ1VpUHJvdmlkZXIgSU5TVEFOQ0UgPSAKLQkJbmV3IEVjbGlwc2VMaW5rT3JtRW1iZWRkZWRJZE1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxPcm1FbWJlZGRlZElkTWFwcGluZz4gaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0JCi0JCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEVjbGlwc2VMaW5rT3JtRW1iZWRkZWRJZE1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0JCQotCQotCXB1YmxpYyBKcGFDb21wb3NpdGUgYnVpbGRBdHRyaWJ1dGVNYXBwaW5nQ29tcG9zaXRlKAotCQkJSnBhVWlGYWN0b3J5IGZhY3RvcnksCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8T3JtRW1iZWRkZWRJZE1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBmYWN0b3J5LmNyZWF0ZU9ybUVtYmVkZGVkSWRNYXBwaW5nQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1FbWJlZGRlZE1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUVtYmVkZGVkTWFwcGluZ1VpUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYTFlZWVhMC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUVtYmVkZGVkTWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiAgQ29weXJpZ2h0IChjKSAyMDA5ICBPcmFjbGUuIAotICogIEFsbCByaWdodHMgcmVzZXJ2ZWQuICBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSAKLSAqICBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCAKLSAqICBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAKLSAqICBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotICogIAotICogIENvbnRyaWJ1dG9yczogCi0gKiAgCU9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0Lm9ybS5Pcm1FbWJlZGRlZE1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFic3RyYWN0RW1iZWRkZWRNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtPcm1FbWJlZGRlZE1hcHBpbmdVaVByb3ZpZGVyCi0JZXh0ZW5kcyBBYnN0cmFjdEVtYmVkZGVkTWFwcGluZ1VpUHJvdmlkZXI8T3JtRW1iZWRkZWRNYXBwaW5nPgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEVjbGlwc2VMaW5rT3JtRW1iZWRkZWRNYXBwaW5nVWlQcm92aWRlciBJTlNUQU5DRSA9IAotCQluZXcgRWNsaXBzZUxpbmtPcm1FbWJlZGRlZE1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxPcm1FbWJlZGRlZE1hcHBpbmc+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGlua09ybUVtYmVkZGVkTWFwcGluZ1VpUHJvdmlkZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQotCXB1YmxpYyBJQ29udGVudFR5cGUgZ2V0Q29udGVudFR5cGUoKSB7Ci0JCXJldHVybiBKcHRFY2xpcHNlTGlua0NvcmVQbHVnaW4uRUNMSVBTRUxJTktfT1JNX1hNTF9DT05URU5UX1RZUEU7Ci0JfQkJCi0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxPcm1FbWJlZGRlZE1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBmYWN0b3J5LmNyZWF0ZU9ybUVtYmVkZGVkTWFwcGluZ0NvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtRW50aXR5Q29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUVudGl0eUNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmMjY2NjQwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtRW50aXR5Q29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMjcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICBDb3B5cmlnaHQgKGMpIDIwMDgsIDIwMDkgT3JhY2xlLiAKLSAqICBBbGwgcmlnaHRzIHJlc2VydmVkLiAgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgCi0gKiAgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggCi0gKiAgYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgCi0gKiAgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSAqICAKLSAqICBDb250cmlidXRvcnM6IAotICogIAlPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkFjY2Vzc0hvbGRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0Lm9ybS5Pcm1FbnRpdHk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5DYWNoaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQub3JtLkNvbnZlcnRlckhvbGRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0Lm9ybS5FY2xpcHNlTGlua09ybUVudGl0eTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtFbnRpdHlBZHZhbmNlZENvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuZGV0YWlscy5BY2Nlc3NUeXBlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkFic3RyYWN0RW50aXR5Q29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkVudGl0eU5hbWVDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuSWRDbGFzc0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5UYWJsZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuTWV0YWRhdGFDb21wbGV0ZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuT3JtSW5oZXJpdGFuY2VDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm9ybS5kZXRhaWxzLk9ybUphdmFDbGFzc0Nob29zZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm9ybS5kZXRhaWxzLk9ybVNlY29uZGFyeVRhYmxlc0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rT3JtRW50aXR5Q29tcG9zaXRlIGV4dGVuZHMgQWJzdHJhY3RFbnRpdHlDb21wb3NpdGU8T3JtRW50aXR5PgotewotCXB1YmxpYyBFY2xpcHNlTGlua09ybUVudGl0eUNvbXBvc2l0ZSgKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgT3JtRW50aXR5PiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCWluaXRpYWxpemVHZW5lcmFsUGFuZShjb250YWluZXIpOwotCQlpbml0aWFsaXplQ2FjaGluZ1BhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZVF1ZXJpZXNQYW5lKGNvbnRhaW5lcik7Ci0JCWluaXRpYWxpemVJbmhlcml0YW5jZVBhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZUF0dHJpYnV0ZU92ZXJyaWRlc1BhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZUdlbmVyYXRvcnNQYW5lKGNvbnRhaW5lcik7Ci0JCWluaXRpYWxpemVDb252ZXJ0ZXJzUGFuZShjb250YWluZXIpOwotCQlpbml0aWFsaXplU2Vjb25kYXJ5VGFibGVzUGFuZShjb250YWluZXIpOwotCQlpbml0aWFsaXplQWR2YW5jZWRQYW5lKGNvbnRhaW5lcik7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVHZW5lcmFsUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCWludCBncm91cEJveE1hcmdpbiA9IGdldEdyb3VwQm94TWFyZ2luKCk7Ci0JCQotCQluZXcgT3JtSmF2YUNsYXNzQ2hvb3Nlcih0aGlzLCBnZXRTdWJqZWN0SG9sZGVyKCksIGFkZFN1YlBhbmUoY29udGFpbmVyLCAwLCBncm91cEJveE1hcmdpbiwgMCwgZ3JvdXBCb3hNYXJnaW4pLCBmYWxzZSk7Ci0JCW5ldyBUYWJsZUNvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCQluZXcgRW50aXR5TmFtZUNvbXBvc2l0ZSh0aGlzLCBhZGRTdWJQYW5lKGNvbnRhaW5lciwgMCwgZ3JvdXBCb3hNYXJnaW4sIDAsIGdyb3VwQm94TWFyZ2luKSk7Ci0JCW5ldyBBY2Nlc3NUeXBlQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQWNjZXNzSG9sZGVyKCksIGFkZFN1YlBhbmUoY29udGFpbmVyLCAwLCBncm91cEJveE1hcmdpbiwgMCwgZ3JvdXBCb3hNYXJnaW4pKTsKLQkJbmV3IElkQ2xhc3NDb21wb3NpdGUodGhpcywgYWRkU3ViUGFuZShjb250YWluZXIsIDAsIGdyb3VwQm94TWFyZ2luLCAwLCBncm91cEJveE1hcmdpbiksIGZhbHNlKTsKLQkJbmV3IE1ldGFkYXRhQ29tcGxldGVDb21wb3NpdGUodGhpcywgZ2V0U3ViamVjdEhvbGRlcigpLCBhZGRTdWJQYW5lKGNvbnRhaW5lciwgMCwgZ3JvdXBCb3hNYXJnaW4sIDAsIGdyb3VwQm94TWFyZ2luKSk7Ci0JfQotCQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8QWNjZXNzSG9sZGVyPiBidWlsZEFjY2Vzc0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8T3JtRW50aXR5LCBBY2Nlc3NIb2xkZXI+KAotCQkJZ2V0U3ViamVjdEhvbGRlcigpKQotCQl7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBBY2Nlc3NIb2xkZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRQZXJzaXN0ZW50VHlwZSgpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplQ2FjaGluZ1BhbmUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQljb250YWluZXIgPSBhZGRDb2xsYXBzYWJsZVNlY3Rpb24oCi0JCQlhZGRTdWJQYW5lKGNvbnRhaW5lciwgNSksCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5FY2xpcHNlTGlua1R5cGVNYXBwaW5nQ29tcG9zaXRlX2NhY2hpbmcpOwotCQluZXcgT3JtQ2FjaGluZ0NvbXBvc2l0ZSh0aGlzLCBidWlsZENhY2hpbmdIb2xkZXIoKSwgY29udGFpbmVyKTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8T3JtRW50aXR5LCBDYWNoaW5nPiBidWlsZENhY2hpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPE9ybUVudGl0eSwgQ2FjaGluZz4oZ2V0U3ViamVjdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDYWNoaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiAoKEVjbGlwc2VMaW5rT3JtRW50aXR5KSB0aGlzLnN1YmplY3QpLmdldENhY2hpbmcoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgYWRkSW5oZXJpdGFuY2VDb21wb3NpdGUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQluZXcgT3JtSW5oZXJpdGFuY2VDb21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgYWRkU2Vjb25kYXJ5VGFibGVzQ29tcG9zaXRlKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJbmV3IE9ybVNlY29uZGFyeVRhYmxlc0NvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVDb252ZXJ0ZXJzUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJY29udGFpbmVyID0gYWRkQ29sbGFwc2FibGVTZWN0aW9uKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuQ29udmVydGVyc0NvbXBvc2l0ZV9MYWJlbAotCQkpOwotCi0JCW5ldyBDb252ZXJ0ZXJzQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQ29udmVydGVySG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnRlckhvbGRlcj4gYnVpbGRDb252ZXJ0ZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPE9ybUVudGl0eSwgQ29udmVydGVySG9sZGVyPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENvbnZlcnRlckhvbGRlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gKChFY2xpcHNlTGlua09ybUVudGl0eSkgdGhpcy5zdWJqZWN0KS5nZXRDb252ZXJ0ZXJIb2xkZXIoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUFkdmFuY2VkUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCW5ldyBFY2xpcHNlTGlua0VudGl0eUFkdmFuY2VkQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1FbnRpdHlVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUVudGl0eVVpUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmNkYzdmYi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUVudGl0eVVpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiAgQ29weXJpZ2h0IChjKSAyMDA4ICBPcmFjbGUuIAotICogIEFsbCByaWdodHMgcmVzZXJ2ZWQuICBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSAKLSAqICBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCAKLSAqICBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAKLSAqICBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotICogIAotICogIENvbnRyaWJ1dG9yczogCi0gKiAgCU9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5KcHRFY2xpcHNlTGlua0NvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5vcm0uRWNsaXBzZUxpbmtPcm1FbnRpdHk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVVpRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuVHlwZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFic3RyYWN0RW50aXR5VWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtPcm1FbnRpdHlVaVByb3ZpZGVyIAotCWV4dGVuZHMgQWJzdHJhY3RFbnRpdHlVaVByb3ZpZGVyPEVjbGlwc2VMaW5rT3JtRW50aXR5PgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEVjbGlwc2VMaW5rT3JtRW50aXR5VWlQcm92aWRlciBJTlNUQU5DRSA9IAotCQluZXcgRWNsaXBzZUxpbmtPcm1FbnRpdHlVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBUeXBlTWFwcGluZ1VpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1FbnRpdHk+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCXB1YmxpYyBJQ29udGVudFR5cGUgZ2V0Q29udGVudFR5cGUoKSB7Ci0JCXJldHVybiBKcHRFY2xpcHNlTGlua0NvcmVQbHVnaW4uRUNMSVBTRUxJTktfT1JNX1hNTF9DT05URU5UX1RZUEU7Ci0JfQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGlua09ybUVudGl0eVVpUHJvdmlkZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQotCQotCXB1YmxpYyBKcGFDb21wb3NpdGUgYnVpbGRQZXJzaXN0ZW50VHlwZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwgCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtPcm1FbnRpdHk+IHN1YmplY3RIb2xkZXIsIAotCQkJQ29tcG9zaXRlIHBhcmVudCwgCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGlua09ybUVudGl0eUNvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtSWRNYXBwaW5nQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUlkTWFwcGluZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0N2I3OGU0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtSWRNYXBwaW5nQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0MyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5JZE1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5Db252ZXJ0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkVjbGlwc2VMaW5rSWRNYXBwaW5nQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLlBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLy9SZW1vdmluZyB0aGUgQ29udmVydGVycyBzZWN0aW9uIGZyb20gRWNsaXBzZUxpbmsgMS4wIG9ybSBiYXNpYyBtYXBwaW5nLgotLy9UaGlzIGlzIHN1cHBvcnRlZCBpbiBFY2xpcHNlTGluayBpbiB2ZXJzaW9uIDEuMSwgYnV0IG5vdCAxLjAKLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua09ybUlkTWFwcGluZ0NvbXBvc2l0ZSBleHRlbmRzIEVjbGlwc2VMaW5rSWRNYXBwaW5nQ29tcG9zaXRlCi17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5FY2xpcHNlTGlua09ybUlkTWFwcGluZ0NvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gc3ViamVjdEhvbGRlciBUaGUgaG9sZGVyIG9mIHRoZSBzdWJqZWN0IDxjb2RlPklkTWFwcGluZzwvY29kZT4KLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICogQHBhcmFtIHdpZGdldEZhY3RvcnkgVGhlIGZhY3RvcnkgdXNlZCB0byBjcmVhdGUgdmFyaW91cyBjb21tb24gd2lkZ2V0cwotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGlua09ybUlkTWFwcGluZ0NvbXBvc2l0ZShQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIElkTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQkvL2V2ZXJ5dGhpbmcgYnV0IHRoZSAnRGVmaW5lIENvbnZlcnRlcicgc2VjdGlvbi4gIFRoaXMgaXMgbm90IHN1cHBvcnRlZCBpbiBlY2xpcHNlbGluayAxLjAsIGJ1dCBpcyBpbiAxLjEKLQlwcm90ZWN0ZWQgUGFuZTxDb252ZXJ0PiBidWlsZENvbnZlcnRDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnQ+IGNvbnZlcnRIb2xkZXIsIENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJcmV0dXJuIG5ldyBPcm1Db252ZXJ0Q29tcG9zaXRlKGNvbnZlcnRIb2xkZXIsIGNvbnRhaW5lciwgZ2V0V2lkZ2V0RmFjdG9yeSgpKTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1JZE1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUlkTWFwcGluZ1VpUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDYzZTRmNC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybUlkTWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQub3JtLkVjbGlwc2VMaW5rT3JtSWRNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFic3RyYWN0SWRNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtPcm1JZE1hcHBpbmdVaVByb3ZpZGVyCi0JZXh0ZW5kcyBBYnN0cmFjdElkTWFwcGluZ1VpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1JZE1hcHBpbmc+Ci17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgRWNsaXBzZUxpbmtPcm1JZE1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGlua09ybUlkTWFwcGluZ1VpUHJvdmlkZXIoKTsKLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyPEVjbGlwc2VMaW5rT3JtSWRNYXBwaW5nPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmtPcm1JZE1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0KLQkKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGJ1aWxkQXR0cmlidXRlTWFwcGluZ0NvbXBvc2l0ZSgKLQkJCUpwYVVpRmFjdG9yeSBmYWN0b3J5LAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rT3JtSWRNYXBwaW5nPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwKLQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rT3JtSWRNYXBwaW5nQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1NYW55VG9NYW55TWFwcGluZ1VpUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtTWFueVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDBkZDZjMjcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1NYW55VG9NYW55TWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQub3JtLkVjbGlwc2VMaW5rT3JtTWFueVRvTWFueU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtNYW55VG9NYW55TWFwcGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuZGV0YWlscy5BYnN0cmFjdE1hbnlUb01hbnlNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtPcm1NYW55VG9NYW55TWFwcGluZ1VpUHJvdmlkZXIKLQlleHRlbmRzIEFic3RyYWN0TWFueVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyPEVjbGlwc2VMaW5rT3JtTWFueVRvTWFueU1hcHBpbmc+Ci17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgRWNsaXBzZUxpbmtPcm1NYW55VG9NYW55TWFwcGluZ1VpUHJvdmlkZXIgSU5TVEFOQ0UgPSAKLQkJbmV3IEVjbGlwc2VMaW5rT3JtTWFueVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxFY2xpcHNlTGlua09ybU1hbnlUb01hbnlNYXBwaW5nPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmtPcm1NYW55VG9NYW55TWFwcGluZ1VpUHJvdmlkZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQotCXB1YmxpYyBJQ29udGVudFR5cGUgZ2V0Q29udGVudFR5cGUoKSB7Ci0JCXJldHVybiBKcHRFY2xpcHNlTGlua0NvcmVQbHVnaW4uRUNMSVBTRUxJTktfT1JNX1hNTF9DT05URU5UX1RZUEU7Ci0JfQotCQotCXB1YmxpYyBKcGFDb21wb3NpdGUgYnVpbGRBdHRyaWJ1dGVNYXBwaW5nQ29tcG9zaXRlKAotCQkJSnBhVWlGYWN0b3J5IGZhY3RvcnksCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtPcm1NYW55VG9NYW55TWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGlua01hbnlUb01hbnlNYXBwaW5nQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1NYW55VG9PbmVNYXBwaW5nVWlQcm92aWRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1NYW55VG9PbmVNYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzN2RlNWRiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtTWFueVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQub3JtLkVjbGlwc2VMaW5rT3JtTWFueVRvT25lTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua01hbnlUb09uZU1hcHBpbmdDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVVpRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5BdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmRldGFpbHMuQWJzdHJhY3RNYW55VG9PbmVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtPcm1NYW55VG9PbmVNYXBwaW5nVWlQcm92aWRlcgotCWV4dGVuZHMgQWJzdHJhY3RNYW55VG9PbmVNYXBwaW5nVWlQcm92aWRlcjxFY2xpcHNlTGlua09ybU1hbnlUb09uZU1hcHBpbmc+Ci17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgRWNsaXBzZUxpbmtPcm1NYW55VG9PbmVNYXBwaW5nVWlQcm92aWRlciBJTlNUQU5DRSA9IAotCQluZXcgRWNsaXBzZUxpbmtPcm1NYW55VG9PbmVNYXBwaW5nVWlQcm92aWRlcigpOwotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1NYW55VG9PbmVNYXBwaW5nPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmtPcm1NYW55VG9PbmVNYXBwaW5nVWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JcHVibGljIElDb250ZW50VHlwZSBnZXRDb250ZW50VHlwZSgpIHsKLQkJcmV0dXJuIEpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbi5FQ0xJUFNFTElOS19PUk1fWE1MX0NPTlRFTlRfVFlQRTsKLQl9Ci0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxFY2xpcHNlTGlua09ybU1hbnlUb09uZU1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmtNYW55VG9PbmVNYXBwaW5nQ29tcG9zaXRlKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1NYXBwZWRTdXBlcmNsYXNzQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybU1hcHBlZFN1cGVyY2xhc3NDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzljMTk3Yy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybU1hcHBlZFN1cGVyY2xhc3NDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEwOCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogIENvcHlyaWdodCAoYykgMjAwOCwgMjAwOSBPcmFjbGUuIAotICogIEFsbCByaWdodHMgcmVzZXJ2ZWQuICBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSAKLSAqICBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCAKLSAqICBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAKLSAqICBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotICogIAotICogIENvbnRyaWJ1dG9yczogCi0gKiAgCU9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuQWNjZXNzSG9sZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0Lm9ybS5Db252ZXJ0ZXJIb2xkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5vcm0uRWNsaXBzZUxpbmtPcm1NYXBwZWRTdXBlcmNsYXNzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5FY2xpcHNlTGlua01hcHBlZFN1cGVyY2xhc3NBZHZhbmNlZENvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmRldGFpbHMuQWNjZXNzVHlwZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwubWFwcGluZ3MuZGV0YWlscy5JZENsYXNzQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5NZXRhZGF0YUNvbXBsZXRlQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5Pcm1KYXZhQ2xhc3NDaG9vc2VyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtPcm1NYXBwZWRTdXBlcmNsYXNzQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8RWNsaXBzZUxpbmtPcm1NYXBwZWRTdXBlcmNsYXNzPiBpbXBsZW1lbnRzIEpwYUNvbXBvc2l0ZQotewotCXB1YmxpYyBFY2xpcHNlTGlua09ybU1hcHBlZFN1cGVyY2xhc3NDb21wb3NpdGUoCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIEVjbGlwc2VMaW5rT3JtTWFwcGVkU3VwZXJjbGFzcz4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQkKLQkKLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJaW5pdGlhbGl6ZUdlbmVyYWxQYW5lKGNvbnRhaW5lcik7Ci0JCWluaXRpYWxpemVDYWNoaW5nUGFuZShjb250YWluZXIpOwotCQlpbml0aWFsaXplQ29udmVydGVyc1BhbmUoY29udGFpbmVyKTsKLQkJaW5pdGlhbGl6ZUFkdmFuY2VkUGFuZShjb250YWluZXIpOwotCX0KLQkKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplR2VuZXJhbFBhbmUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQluZXcgT3JtSmF2YUNsYXNzQ2hvb3Nlcih0aGlzLCBnZXRTdWJqZWN0SG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JCW5ldyBBY2Nlc3NUeXBlQ29tcG9zaXRlKHRoaXMsIGJ1aWxkQWNjZXNzSG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JCW5ldyBJZENsYXNzQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JCW5ldyBNZXRhZGF0YUNvbXBsZXRlQ29tcG9zaXRlKHRoaXMsIGdldFN1YmplY3RIb2xkZXIoKSwgY29udGFpbmVyKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxBY2Nlc3NIb2xkZXI+IGJ1aWxkQWNjZXNzSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxFY2xpcHNlTGlua09ybU1hcHBlZFN1cGVyY2xhc3MsIEFjY2Vzc0hvbGRlcj4oCi0JCQlnZXRTdWJqZWN0SG9sZGVyKCkpCi0JCXsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEFjY2Vzc0hvbGRlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldFBlcnNpc3RlbnRUeXBlKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVDYWNoaW5nUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJY29udGFpbmVyID0gYWRkQ29sbGFwc2FibGVTZWN0aW9uKAotCQkJYWRkU3ViUGFuZShjb250YWluZXIsIDUpLAotCQkJRWNsaXBzZUxpbmtVaU1hcHBpbmdzTWVzc2FnZXMuRWNsaXBzZUxpbmtUeXBlTWFwcGluZ0NvbXBvc2l0ZV9jYWNoaW5nCi0JCSk7Ci0KLQkJbmV3IE9ybUNhY2hpbmdDb21wb3NpdGUodGhpcywgYnVpbGRDYWNoaW5nSG9sZGVyKCksIGNvbnRhaW5lcik7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8RWNsaXBzZUxpbmtPcm1NYXBwZWRTdXBlcmNsYXNzLCBDYWNoaW5nPiBidWlsZENhY2hpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEVjbGlwc2VMaW5rT3JtTWFwcGVkU3VwZXJjbGFzcywgQ2FjaGluZz4oCi0JCQlnZXRTdWJqZWN0SG9sZGVyKCkpCi0JCXsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENhY2hpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRDYWNoaW5nKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUNvbnZlcnRlcnNQYW5lKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQljb250YWluZXIgPSBhZGRDb2xsYXBzYWJsZVNlY3Rpb24oCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJ0ZXJzQ29tcG9zaXRlX0xhYmVsCi0JCSk7Ci0KLQkJbmV3IENvbnZlcnRlcnNDb21wb3NpdGUodGhpcywgYnVpbGRDb252ZXJ0ZXJIb2xkZXIoKSwgY29udGFpbmVyKTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8Q29udmVydGVySG9sZGVyPiBidWlsZENvbnZlcnRlckhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8RWNsaXBzZUxpbmtPcm1NYXBwZWRTdXBlcmNsYXNzLCBDb252ZXJ0ZXJIb2xkZXI+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ29udmVydGVySG9sZGVyIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0Q29udmVydGVySG9sZGVyKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVBZHZhbmNlZFBhbmUoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQluZXcgRWNsaXBzZUxpbmtNYXBwZWRTdXBlcmNsYXNzQWR2YW5jZWRDb21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybU1hcHBlZFN1cGVyY2xhc3NVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybU1hcHBlZFN1cGVyY2xhc3NVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDViZWQ2OTguLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1NYXBwZWRTdXBlcmNsYXNzVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICBDb3B5cmlnaHQgKGMpIDIwMDggIE9yYWNsZS4gCi0gKiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4gIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIAotICogIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIAotICogIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IAotICogIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0gKiAgCi0gKiAgQ29udHJpYnV0b3JzOiAKLSAqICAJT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLmNvbnRlbnQuSUNvbnRlbnRUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLkpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0Lm9ybS5FY2xpcHNlTGlua09ybU1hcHBlZFN1cGVyY2xhc3M7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVVpRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuVHlwZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFic3RyYWN0TWFwcGVkU3VwZXJjbGFzc1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rT3JtTWFwcGVkU3VwZXJjbGFzc1VpUHJvdmlkZXIgCi0JZXh0ZW5kcyBBYnN0cmFjdE1hcHBlZFN1cGVyY2xhc3NVaVByb3ZpZGVyPEVjbGlwc2VMaW5rT3JtTWFwcGVkU3VwZXJjbGFzcz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGlua09ybU1hcHBlZFN1cGVyY2xhc3NVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGlua09ybU1hcHBlZFN1cGVyY2xhc3NVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBUeXBlTWFwcGluZ1VpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1NYXBwZWRTdXBlcmNsYXNzPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmtPcm1NYXBwZWRTdXBlcmNsYXNzVWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JcHVibGljIElDb250ZW50VHlwZSBnZXRDb250ZW50VHlwZSgpIHsKLQkJcmV0dXJuIEpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbi5FQ0xJUFNFTElOS19PUk1fWE1MX0NPTlRFTlRfVFlQRTsKLQl9Ci0KLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGJ1aWxkUGVyc2lzdGVudFR5cGVNYXBwaW5nQ29tcG9zaXRlKEpwYVVpRmFjdG9yeSBmYWN0b3J5LCBQcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtPcm1NYXBwZWRTdXBlcmNsYXNzPiBzdWJqZWN0SG9sZGVyLCBDb21wb3NpdGUgcGFyZW50LCBXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGlua09ybU1hcHBlZFN1cGVyY2xhc3NDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybU9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybU9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGI1M2I0ODAuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1PbmVUb01hbnlNYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5KcHRFY2xpcHNlTGlua0NvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5vcm0uRWNsaXBzZUxpbmtPcm1PbmVUb01hbnlNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkVjbGlwc2VMaW5rT25lVG9NYW55TWFwcGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuZGV0YWlscy5BYnN0cmFjdE9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua09ybU9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyCi0JZXh0ZW5kcyBBYnN0cmFjdE9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyPEVjbGlwc2VMaW5rT3JtT25lVG9NYW55TWFwcGluZz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGlua09ybU9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGlua09ybU9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxFY2xpcHNlTGlua09ybU9uZVRvTWFueU1hcHBpbmc+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGlua09ybU9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0KLQkKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGJ1aWxkQXR0cmlidXRlTWFwcGluZ0NvbXBvc2l0ZSgKLQkJCUpwYVVpRmFjdG9yeSBmYWN0b3J5LAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rT3JtT25lVG9NYW55TWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGlua09uZVRvTWFueU1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxMTcxMTBjLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5KcHRFY2xpcHNlTGlua0NvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5vcm0uRWNsaXBzZUxpbmtPcm1PbmVUb09uZU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtPbmVUb09uZU1hcHBpbmdDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVVpRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5BdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmRldGFpbHMuQWJzdHJhY3RPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua09ybU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIKLQlleHRlbmRzIEFic3RyYWN0T25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcjxFY2xpcHNlTGlua09ybU9uZVRvT25lTWFwcGluZz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGlua09ybU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIgSU5TVEFOQ0UgPSAKLQkJbmV3IEVjbGlwc2VMaW5rT3JtT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcigpOwotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1PbmVUb09uZU1hcHBpbmc+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGlua09ybU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQotCXB1YmxpYyBJQ29udGVudFR5cGUgZ2V0Q29udGVudFR5cGUoKSB7Ci0JCXJldHVybiBKcHRFY2xpcHNlTGlua0NvcmVQbHVnaW4uRUNMSVBTRUxJTktfT1JNX1hNTF9DT05URU5UX1RZUEU7Ci0JfQotCQotCXB1YmxpYyBKcGFDb21wb3NpdGUgYnVpbGRBdHRyaWJ1dGVNYXBwaW5nQ29tcG9zaXRlKAotCQkJSnBhVWlGYWN0b3J5IGZhY3RvcnksCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8RWNsaXBzZUxpbmtPcm1PbmVUb09uZU1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmtPbmVUb09uZU1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybVRyYW5zZm9ybWF0aW9uTWFwcGluZ1VpUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtVHJhbnNmb3JtYXRpb25NYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4NTRjN2I2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtVHJhbnNmb3JtYXRpb25NYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LlRyYW5zZm9ybWF0aW9uTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5KcHRFY2xpcHNlTGlua0NvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtUcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLlRyYW5zZm9ybWF0aW9uTWFwcGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtPcm1UcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyIGV4dGVuZHMgRWNsaXBzZUxpbmtUcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyPFRyYW5zZm9ybWF0aW9uTWFwcGluZz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGlua09ybVRyYW5zZm9ybWF0aW9uTWFwcGluZ1VpUHJvdmlkZXIgSU5TVEFOQ0UgPSAKLQkJbmV3IEVjbGlwc2VMaW5rT3JtVHJhbnNmb3JtYXRpb25NYXBwaW5nVWlQcm92aWRlcigpOwotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8VHJhbnNmb3JtYXRpb25NYXBwaW5nPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmtPcm1UcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0KLQkKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGJ1aWxkQXR0cmlidXRlTWFwcGluZ0NvbXBvc2l0ZSgKLQkJSnBhVWlGYWN0b3J5IGZhY3RvcnksCi0JCVByb3BlcnR5VmFsdWVNb2RlbDxUcmFuc2Zvcm1hdGlvbk1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCQkKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbk1hcHBpbmdDb21wb3NpdGUoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybVRyYW5zaWVudE1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybVRyYW5zaWVudE1hcHBpbmdVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQ3ZGQ4MmEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1UcmFuc2llbnRNYXBwaW5nVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICBDb3B5cmlnaHQgKGMpIDIwMDkgIE9yYWNsZS4gCi0gKiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4gIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIAotICogIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIAotICogIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IAotICogIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0gKiAgCi0gKiAgQ29udHJpYnV0b3JzOiAKLSAqICAJT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLmNvbnRlbnQuSUNvbnRlbnRUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQub3JtLk9ybVRyYW5zaWVudE1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5kZXRhaWxzLkFic3RyYWN0VHJhbnNpZW50TWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rT3JtVHJhbnNpZW50TWFwcGluZ1VpUHJvdmlkZXIKLQlleHRlbmRzIEFic3RyYWN0VHJhbnNpZW50TWFwcGluZ1VpUHJvdmlkZXI8T3JtVHJhbnNpZW50TWFwcGluZz4KLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFY2xpcHNlTGlua09ybVRyYW5zaWVudE1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGlua09ybVRyYW5zaWVudE1hcHBpbmdVaVByb3ZpZGVyKCk7Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjxPcm1UcmFuc2llbnRNYXBwaW5nPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQkKLQkKLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmtPcm1UcmFuc2llbnRNYXBwaW5nVWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JcHVibGljIElDb250ZW50VHlwZSBnZXRDb250ZW50VHlwZSgpIHsKLQkJcmV0dXJuIEpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbi5FQ0xJUFNFTElOS19PUk1fWE1MX0NPTlRFTlRfVFlQRTsKLQl9CQotCQotCXB1YmxpYyBKcGFDb21wb3NpdGUgYnVpbGRBdHRyaWJ1dGVNYXBwaW5nQ29tcG9zaXRlKAotCQkJSnBhVWlGYWN0b3J5IGZhY3RvcnksCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8T3JtVHJhbnNpZW50TWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJcmV0dXJuIGZhY3RvcnkuY3JlYXRlT3JtVHJhbnNpZW50TWFwcGluZ0NvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybVZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3ZTBmMjk3Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLmNvbnRlbnQuSUNvbnRlbnRUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuVmFyaWFibGVPbmVUb09uZU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLkVjbGlwc2VMaW5rVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5kZXRhaWxzLlZhcmlhYmxlT25lVG9PbmVNYXBwaW5nQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5KcGFVaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua09ybVZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlciBleHRlbmRzIEVjbGlwc2VMaW5rVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyPFZhcmlhYmxlT25lVG9PbmVNYXBwaW5nPgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEVjbGlwc2VMaW5rT3JtVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGlua09ybVZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcigpOwotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8VmFyaWFibGVPbmVUb09uZU1hcHBpbmc+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGlua09ybVZhcmlhYmxlT25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JcHVibGljIElDb250ZW50VHlwZSBnZXRDb250ZW50VHlwZSgpIHsKLQkJcmV0dXJuIEpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbi5FQ0xJUFNFTElOS19PUk1fWE1MX0NPTlRFTlRfVFlQRTsKLQl9Ci0JCi0JcHVibGljIEpwYUNvbXBvc2l0ZSBidWlsZEF0dHJpYnV0ZU1hcHBpbmdDb21wb3NpdGUoCi0JCQlKcGFVaUZhY3RvcnkgZmFjdG9yeSwKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxWYXJpYWJsZU9uZVRvT25lTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJcmV0dXJuIG5ldyBWYXJpYWJsZU9uZVRvT25lTWFwcGluZ0NvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtVmVyc2lvbk1hcHBpbmdDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtVmVyc2lvbk1hcHBpbmdDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjMzZjdhOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FY2xpcHNlTGlua09ybVZlcnNpb25NYXBwaW5nQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0NSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5WZXJzaW9uTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkNvbnZlcnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuRWNsaXBzZUxpbmtWZXJzaW9uTWFwcGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vL1RlbXBvcmFyeSB0byByZW1vdmUgdGhlIENvbnZlcnRlcnMgc2VjdGlvbiBmcm9tIG9ybSBiYXNpYyBtYXBwaW5nLgotLy9UaGlzIGlzIHN1cHBvcnRlZCBpbiBFY2xpcHNlTGluayBpbiB2ZXJzaW9uIDEuMSwgYnV0IG5vdCAxLjAKLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua09ybVZlcnNpb25NYXBwaW5nQ29tcG9zaXRlIGV4dGVuZHMgRWNsaXBzZUxpbmtWZXJzaW9uTWFwcGluZ0NvbXBvc2l0ZSBpbXBsZW1lbnRzIEpwYUNvbXBvc2l0ZQotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+RWNsaXBzZUxpbmtPcm1WZXJzaW9uTWFwcGluZ0NvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gc3ViamVjdEhvbGRlciBUaGUgaG9sZGVyIG9mIHRoZSBzdWJqZWN0IDxjb2RlPlZlcnNpb25NYXBwaW5nPC9jb2RlPgotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKiBAcGFyYW0gd2lkZ2V0RmFjdG9yeSBUaGUgZmFjdG9yeSB1c2VkIHRvIGNyZWF0ZSB2YXJpb3VzIGNvbW1vbiB3aWRnZXRzCi0JICovCi0JcHVibGljIEVjbGlwc2VMaW5rT3JtVmVyc2lvbk1hcHBpbmdDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBWZXJzaW9uTWFwcGluZz4gc3ViamVjdEhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0KLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgcGFyZW50LCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQotCUBPdmVycmlkZQotCS8vZXZlcnl0aGluZyBidXQgdGhlICdEZWZhaW5lIENvbnZlcnRlcicgc2VjdGlvbi4gIFRoaXMgaXMgbm90IHN1cHBvcnRlZCBpbiBlY2xpcHNlbGluayAxLjAsIGJ1dCBpcyBpbiAxLjEKLQlwcm90ZWN0ZWQgUGFuZTxDb252ZXJ0PiBidWlsZENvbnZlcnRDb21wb3NpdGUoUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnQ+IGNvbnZlcnRIb2xkZXIsIENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJcmV0dXJuIG5ldyBPcm1Db252ZXJ0Q29tcG9zaXRlKGNvbnZlcnRIb2xkZXIsIGNvbnRhaW5lciwgZ2V0V2lkZ2V0RmFjdG9yeSgpKTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1WZXJzaW9uTWFwcGluZ1VpUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VjbGlwc2VMaW5rT3JtVmVyc2lvbk1hcHBpbmdVaVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDBhYTA4ZGIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvRWNsaXBzZUxpbmtPcm1WZXJzaW9uTWFwcGluZ1VpUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQub3JtLkVjbGlwc2VMaW5rT3JtVmVyc2lvbk1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVVpRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5BdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmRldGFpbHMuQWJzdHJhY3RWZXJzaW9uTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rT3JtVmVyc2lvbk1hcHBpbmdVaVByb3ZpZGVyCi0JZXh0ZW5kcyBBYnN0cmFjdFZlcnNpb25NYXBwaW5nVWlQcm92aWRlcjxFY2xpcHNlTGlua09ybVZlcnNpb25NYXBwaW5nPgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEVjbGlwc2VMaW5rT3JtVmVyc2lvbk1hcHBpbmdVaVByb3ZpZGVyIElOU1RBTkNFID0gCi0JCW5ldyBFY2xpcHNlTGlua09ybVZlcnNpb25NYXBwaW5nVWlQcm92aWRlcigpOwotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI8RWNsaXBzZUxpbmtPcm1WZXJzaW9uTWFwcGluZz4gaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0JCi0JCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEVjbGlwc2VMaW5rT3JtVmVyc2lvbk1hcHBpbmdVaVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0KLQkKLQlwdWJsaWMgSnBhQ29tcG9zaXRlIGJ1aWxkQXR0cmlidXRlTWFwcGluZ0NvbXBvc2l0ZSgKLQkJCUpwYVVpRmFjdG9yeSBmYWN0b3J5LAotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rT3JtVmVyc2lvbk1hcHBpbmc+IHN1YmplY3RIb2xkZXIsCi0JCQlDb21wb3NpdGUgcGFyZW50LAotCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmtPcm1WZXJzaW9uTWFwcGluZ0NvbXBvc2l0ZShzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VudGl0eU1hcHBpbmdzRGV0YWlsc1BhZ2UuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL0VudGl0eU1hcHBpbmdzRGV0YWlsc1BhZ2UuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmY1YWFhOC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9FbnRpdHlNYXBwaW5nc0RldGFpbHNQYWdlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNjcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlsczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQub3JtLkVudGl0eU1hcHBpbmdzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQub3JtLkNvbnZlcnRlckhvbGRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0Lm9ybS5FY2xpcHNlTGlua0VudGl0eU1hcHBpbmdzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuV2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuSnBhSGVscENvbnRleHRJZHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLm9ybS5KcHRVaU9ybU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5Pcm1HZW5lcmF0b3JzQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5Pcm1QYWNrYWdlQ2hvb3NlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuT3JtUXVlcmllc0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuUGVyc2lzdGVuY2VVbml0TWV0YWRhdGFDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogSGVyZSB0aGUgbGF5b3V0IG9mIHRoaXMgcGFuZToKLSAqIDxwcmU+Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgWG1sUGFja2FnZUNob29zZXIgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8ICAgICAgICAgICAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCBTY2hlbWE6ICAgICAgfCBTY2hlbWFDb21ibyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgICAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8ICAgICAgICAgICAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCBDYXRhbG9nOiAgICAgfCBDYXRhbG9nQ29tYm8gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgICAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8ICAgICAgICAgICAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCBBY2Nlc3MgVHlwZTogfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfHZ8IHwKLSAqIHwgICAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgUGVyc2lzdGVuY2VVbml0TWV0YWRhdGFDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCBPcm1HZW5lcmF0b3JzQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IE9ybVF1ZXJpZXNDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IHwgQ29udmVydGVyc0NvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLTwvcHJlPgotICoKLSAqIEBzZWUgRW50aXR5TWFwcGluZ3MKLSAqIEBzZWUgRW50aXR5TWFwcGluZ3NEZXRhaWxzUGFnZSAtIFRoZSBwYXJlbnQgY29udGFpbmVyCi0gKiBAc2VlIENhdGFsb2dDb21ibwotICogQHNlZSBFbnVtRm9ybUNvbWJvVmlld2VyCi0gKiBAc2VlIE9ybUdlbmVyYXRvcnNDb21wb3NpdGUKLSAqIEBzZWUgT3JtUGFja2FnZUNob29zZXIKLSAqIEBzZWUgT3JtUXVlcmllc0NvbXBvc2l0ZQotICogQHNlZSBQZXJzaXN0ZW5jZVVuaXRNZXRhZGF0YUNvbXBvc2l0ZQotICogQHNlZSBTY2hlbWFDb21ibwotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgRW50aXR5TWFwcGluZ3NEZXRhaWxzUGFnZSBleHRlbmRzIG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FbnRpdHlNYXBwaW5nc0RldGFpbHNQYWdlCi17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5YbWxFbnRpdHlNYXBwaW5nc0RldGFpbHNQYWdlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKiBAcGFyYW0gd2lkZ2V0RmFjdG9yeSBUaGUgZmFjdG9yeSB1c2VkIHRvIGNyZWF0ZSB2YXJpb3VzIGNvbW1vbiB3aWRnZXRzCi0JICovCi0JcHVibGljIEVudGl0eU1hcHBpbmdzRGV0YWlsc1BhZ2UoQ29tcG9zaXRlIHBhcmVudCwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQotCQlzdXBlcihwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJLy8gUGFja2FnZSB3aWRnZXRzCi0JCW5ldyBPcm1QYWNrYWdlQ2hvb3Nlcih0aGlzLCBjb250YWluZXIpOwotCi0JCS8vIFNjaGVtYSB3aWRnZXRzCi0JCWFkZExhYmVsZWRDb21wb3NpdGUoCi0JCQljb250YWluZXIsCi0JCQlKcHRVaU9ybU1lc3NhZ2VzLkVudGl0eU1hcHBpbmdzRGV0YWlsc1BhZ2Vfc2NoZW1hLAotCQkJYWRkU2NoZW1hQ29tYm8oY29udGFpbmVyKSwKLQkJCUpwYUhlbHBDb250ZXh0SWRzLkVOVElUWV9PUk1fU0NIRU1BCi0JCSk7Ci0KLQkJLy8gQ2F0YWxvZyB3aWRnZXRzCi0JCWFkZExhYmVsZWRDb21wb3NpdGUoCi0JCQljb250YWluZXIsCi0JCQlKcHRVaU9ybU1lc3NhZ2VzLkVudGl0eU1hcHBpbmdzRGV0YWlsc1BhZ2VfY2F0YWxvZywKLQkJCWFkZENhdGFsb2dDb21ibyhjb250YWluZXIpLAotCQkJSnBhSGVscENvbnRleHRJZHMuRU5USVRZX09STV9DQVRBTE9HCi0JCSk7Ci0KLQkJLy8gQWNjZXNzIFR5cGUgd2lkZ2V0cwotCQlhZGRMYWJlbGVkQ29tcG9zaXRlKAotCQkJY29udGFpbmVyLAotCQkJSnB0VWlPcm1NZXNzYWdlcy5FbnRpdHlNYXBwaW5nc0RldGFpbHNQYWdlX2FjY2VzcywKLQkJCWFkZEFjY2Vzc1R5cGVDb21ibyhjb250YWluZXIpLAotCQkJSnBhSGVscENvbnRleHRJZHMuRU5USVRZX09STV9BQ0NFU1MKLQkJKTsKLQotCQkvLyBQZXJzaXN0ZW5jZSBVbml0IE1ldGFkYXRhIHdpZGdldHMKLQkJbmV3IFBlcnNpc3RlbmNlVW5pdE1ldGFkYXRhQ29tcG9zaXRlKAotCQkJdGhpcywKLQkJCWJ1aWxkUGVyc2lzdGVudFVuaXRNZXRhZGF0YUhvbGRlcigpLAotCQkJYWRkU3ViUGFuZShjb250YWluZXIsIDUpCi0JCSk7Ci0KLQkJLy8gR2VuZXJhdG9ycyBwYW5lCi0JCW5ldyBPcm1HZW5lcmF0b3JzQ29tcG9zaXRlKAotCQkJdGhpcywKLQkJCWNvbnRhaW5lcgotCQkpOwotCi0JCS8vIFF1ZXJpZXMgcGFuZQotCQluZXcgT3JtUXVlcmllc0NvbXBvc2l0ZSgKLQkJCXRoaXMsCi0JCQljb250YWluZXIKLQkJKTsKLQkJCi0JCS8vIENvbnZlcnRlcnMgc2VjdGlvbgotCQljb250YWluZXIgPSBhZGRDb2xsYXBzYWJsZVNlY3Rpb24oCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJ0ZXJzQ29tcG9zaXRlX0xhYmVsCi0JCSk7Ci0JCQotCQluZXcgQ29udmVydGVyc0NvbXBvc2l0ZSgKLQkJCXRoaXMsCi0JCQlidWlsZENvbnZlcnRlckhvbGRlcigpLAotCQkJY29udGFpbmVyCi0JCSk7Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnRlckhvbGRlcj4gYnVpbGRDb252ZXJ0ZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEVudGl0eU1hcHBpbmdzLCBDb252ZXJ0ZXJIb2xkZXI+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ29udmVydGVySG9sZGVyIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiAoKEVjbGlwc2VMaW5rRW50aXR5TWFwcGluZ3MpIHRoaXMuc3ViamVjdCkuZ2V0Q29udmVydGVySG9sZGVyKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvT3JtQ2FjaGluZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvb3JtL2RldGFpbHMvT3JtQ2FjaGluZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxZDQ5ODljLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL09ybUNhY2hpbmdDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDYyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkNhY2hpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLmRldGFpbHMuQ2FjaGluZ0NvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFRoaXMgcGFuZSBzaG93cyB0aGUgY2FjaGluZyBvcHRpb25zLgotICogPHA+Ci0gKiBIZXJlIHRoZSBsYXlvdXQgb2YgdGhpcyBwYW5lOgotICogPHByZT4KLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gKiB8IHggU2hhcmVkICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogfCAgICBDYWNoZVR5cGVDb21wb3NpdGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIHwgICAgQ2FjaGVTaXplQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0gKiB8ICAgID4gQWR2YW5jZWQgICAJICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIHwgICAgCUV4cGlyeUNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0gKiB8ICAgIAlBbHdheXNSZWZyZXNoQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogfCAgIAkJUmVmcmVzaE9ubHlJZk5ld2VyQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIHwgICAgCURpc2FibGVIaXRzQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0gKiB8ICAgIAlDYWNoZUNvb3JkaW5hdGlvbkNvbXBvc2l0ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogfCBFeGlzdGVuY2VUeXBlQ29tcG9zaXRlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPC9wcmU+Ci0gKgotICogQHNlZSBFbnRpdHkKLSAqIEBzZWUgRWNsaXBzZUxpbmtDYWNoaW5nCi0gKiBAc2VlIEVjbGlwc2VMaW5rSmF2YUVudGl0eUNvbXBvc2l0ZSAtIFRoZSBwYXJlbnQgY29udGFpbmVyCi0gKiBAc2VlIENhY2hlVHlwZUNvbXBvc2l0ZQotICogQHNlZSBDYWNoZVNpemVDb21wb3NpdGUKLSAqIEBzZWUgQWx3YXlzUmVmcmVzaENvbXBvc2l0ZQotICogQHNlZSBSZWZyZXNoT25seUlmTmV3ZXJDb21wb3NpdGUKLSAqIEBzZWUgRGlzYWJsZUhpdHNDb21wb3NpdGUKLSAqCi0gKiBAdmVyc2lvbiAyLjEKLSAqIEBzaW5jZSAyLjEKLSAqLwotcHVibGljIGNsYXNzIE9ybUNhY2hpbmdDb21wb3NpdGUgZXh0ZW5kcyBDYWNoaW5nQ29tcG9zaXRlPENhY2hpbmc+Ci17Ci0KLQlwdWJsaWMgT3JtQ2FjaGluZ0NvbXBvc2l0ZShGb3JtUGFuZTw/PiBwYXJlbnRQYW5lLAotICAgICAgICBQcm9wZXJ0eVZhbHVlTW9kZWw8Q2FjaGluZz4gc3ViamVjdEhvbGRlciwKLSAgICAgICAgQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudFBhbmUsIHN1YmplY3RIb2xkZXIsIHBhcmVudCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUV4aXN0ZW5jZUNoZWNraW5nQ29tcG9zaXRlKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJbmV3IE9ybUV4aXN0ZW5jZUNoZWNraW5nQ29tcG9zaXRlKHRoaXMsIHBhcmVudCk7Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL09ybUNvbnZlcnRDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL09ybUNvbnZlcnRDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDAzZjZmMC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9Pcm1Db252ZXJ0Q29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyMjAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzCi0gKiAgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZgotICogIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcwotICogIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotICoKLSAqICBDb250cmlidXRvcnM6IE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5Db252ZXJ0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm1hcHBpbmdzLkVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5tYXBwaW5ncy5KcHRVaU1hcHBpbmdzTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuUGFuZUVuYWJsZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuU1dUVXRpbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nQ29udmVydGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkNvbXBvc2l0ZUxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkxpc3RBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TdGF0aWNMaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuY3VzdG9tLkNDb21ibzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogSGVyZSB0aGUgbGF5b3V0IG9mIHRoaXMgcGFuZToKLSAqIDxwcmU+Ci0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotICogfCAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIHwKLSAqIHwgQ29udmVydGVyOiB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHx2fCB8Ci0gKiB8ICAgICAgICAgICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS08L3ByZT4KLSAqCi0gKiBAc2VlIEVjbGlwc2VMaW5rQ29udmVydAotICogQHNlZSBFY2xpcHNlTGlua0Jhc2ljTWFwcGluZ0NvbXBvc2l0ZSAtIEEgY29udGFpbmVyIG9mIHRoaXMgd2lkZ2V0Ci0gKgotICogQHZlcnNpb24gMi4xCi0gKiBAc2luY2UgMi4xCi0gKi8KLQotLy9UZW1wb3JhcnkgdG8gcmVtb3ZlIHRoZSBEZWZpbmUgQ29udmVydGVycyBzZWN0aW9uIGZyb20gb3JtIGJhc2ljLCBpZCwgdmVyc2lvbiBtYXBwaW5nLgotLy9UaGlzIGlzIHN1cHBvcnRlZCBpbiBFY2xpcHNlTGluayBpbiB2ZXJzaW9uIDEuMSwgYnV0IG5vdCAxLjAKLXB1YmxpYyBjbGFzcyBPcm1Db252ZXJ0Q29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8Q29udmVydD4KLXsKLQotCS8qKgotCSAqIEEga2V5IHVzZWQgdG8gcmVwcmVzZW50IHRoZSBkZWZhdWx0IHZhbHVlLCB0aGlzIGlzIHJlcXVpcmVkIHRvIGNvbnZlcnQKLQkgKiB0aGUgc2VsZWN0ZWQgaXRlbSBmcm9tIGEgY29tYm8gdG8gPGNvZGU+bnVsbDwvY29kZT4uIFRoaXMga2V5IGlzIG1vc3QKLQkgKiBsaWtlbHkgbmV2ZXIgdHlwZWQgdGhlIHVzZXIgYW5kIGl0IHdpbGwgaGVscCB0byBjb252ZXJ0IHRoZSB2YWx1ZSB0bwotCSAqIDxjb2RlPm51bGw8L2NvZGU+IHdoZW4gaXQncyB0aW1lIHRvIHNldCB0aGUgbmV3IHNlbGVjdGVkIHZhbHVlIGludG8gdGhlCi0JICogbW9kZWwuCi0JICovCi0JcHJvdGVjdGVkIHN0YXRpYyBTdHJpbmcgREVGQVVMVF9LRVkgPSAiPyEjIT8jPyM/ZGVmYXVsdD8jPyEjPyEjPyI7IC8vJE5PTi1OTFMtMSQKLQkKLQkKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkVudW1UeXBlQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRQYW5lIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBPcm1Db252ZXJ0Q29tcG9zaXRlKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgQ29udmVydD4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsCi0JCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlDQ29tYm8gY29tYm8gPSBhZGRMYWJlbGVkRWRpdGFibGVDQ29tYm8oCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5Db252ZXJ0Q29tcG9zaXRlX2NvbnZlcnRlck5hbWVMYWJlbCwKLQkJCWJ1aWxkQ29udmVydE5hbWVMaXN0SG9sZGVyKCksCi0JCQlidWlsZENvbnZlcnROYW1lSG9sZGVyKCksCi0JCQlidWlsZE5hbWVDb252ZXJ0ZXIoKSwKLQkJCW51bGwKLQkJKTsKLQkJU1dUVXRpbC5hdHRhY2hEZWZhdWx0VmFsdWVIYW5kbGVyKGNvbWJvKTsKLQkJCQkKLQkJbmV3IFBhbmVFbmFibGVyKGJ1aWxkQm9vbGVhbkhvbGRlcigpLCB0aGlzKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIGZpbmFsIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRDb252ZXJ0TmFtZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29udmVydCwgU3RyaW5nPihnZXRTdWJqZWN0SG9sZGVyKCksIENvbnZlcnQuU1BFQ0lGSUVEX0NPTlZFUlRFUl9OQU1FX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRTcGVjaWZpZWRDb252ZXJ0ZXJOYW1lKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCQkJCS8vIENvbnZlcnQgdGhlIGRlZmF1bHQgdmFsdWUgb3IgYW4gZW1wdHkgc3RyaW5nIHRvIG51bGwKLQkJCQlpZiAoKHZhbHVlICE9IG51bGwpICYmCi0JCQkJICAgKCh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB8fCB2YWx1ZS5zdGFydHNXaXRoKERFRkFVTFRfS0VZKSkpIHsKLQotCQkJCQl2YWx1ZSA9IG51bGw7Ci0JCQkJfQotCQkJCXRoaXMuc3ViamVjdC5zZXRTcGVjaWZpZWRDb252ZXJ0ZXJOYW1lKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkQ29udmVydE5hbWVMaXN0SG9sZGVyKCkgewotCQlqYXZhLnV0aWwuTGlzdDxMaXN0VmFsdWVNb2RlbDxTdHJpbmc+PiBsaXN0ID0gbmV3IEFycmF5TGlzdDxMaXN0VmFsdWVNb2RlbDxTdHJpbmc+PigpOwotCQlsaXN0LmFkZChidWlsZERlZmF1bHROYW1lTGlzdEhvbGRlcigpKTsKLQkJbGlzdC5hZGQoYnVpbGRSZXNlcnZlZENvbnZlcnRlck5hbWVMaXN0SG9sZGVyKCkpOwotCQlsaXN0LmFkZChidWlsZENvbnZlcnRlck5hbWVMaXN0SG9sZGVyKCkpOwotCQlyZXR1cm4gbmV3IENvbXBvc2l0ZUxpc3RWYWx1ZU1vZGVsPExpc3RWYWx1ZU1vZGVsPFN0cmluZz4sIFN0cmluZz4obGlzdCk7Ci0JfQotCQotCXByb3RlY3RlZCBMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdE5hbWVMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyPFN0cmluZz4oCi0JCQlidWlsZERlZmF1bHROYW1lSG9sZGVyKCkKLQkJKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGREZWZhdWx0TmFtZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29udmVydCwgU3RyaW5nPihnZXRTdWJqZWN0SG9sZGVyKCksIENvbnZlcnQuREVGQVVMVF9DT05WRVJURVJfTkFNRV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCVN0cmluZyBuYW1lID0gdGhpcy5zdWJqZWN0LmdldERlZmF1bHRDb252ZXJ0ZXJOYW1lKCk7Ci0KLQkJCQlpZiAobmFtZSA9PSBudWxsKSB7Ci0JCQkJCW5hbWUgPSBERUZBVUxUX0tFWTsKLQkJCQl9Ci0JCQkJZWxzZSB7Ci0JCQkJCW5hbWUgPSBERUZBVUxUX0tFWSArIG5hbWU7Ci0JCQkJfQotCi0JCQkJcmV0dXJuIG5hbWU7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmdDb252ZXJ0ZXI8U3RyaW5nPiBidWlsZE5hbWVDb252ZXJ0ZXIoKSB7Ci0JCXJldHVybiBuZXcgU3RyaW5nQ29udmVydGVyPFN0cmluZz4oKSB7Ci0JCQlwdWJsaWMgU3RyaW5nIGNvbnZlcnRUb1N0cmluZyhTdHJpbmcgdmFsdWUpIHsKLQotCQkJCWlmIChnZXRTdWJqZWN0KCkgPT0gbnVsbCkgewotCQkJCQlyZXR1cm4gdmFsdWU7Ci0JCQkJfQotCi0JCQkJaWYgKHZhbHVlID09IG51bGwpIHsKLQkJCQkJdmFsdWUgPSBnZXRTdWJqZWN0KCkuZ2V0RGVmYXVsdENvbnZlcnRlck5hbWUoKTsKLQotCQkJCQlpZiAodmFsdWUgIT0gbnVsbCkgewotCQkJCQkJdmFsdWUgPSBERUZBVUxUX0tFWSArIHZhbHVlOwotCQkJCQl9Ci0JCQkJCWVsc2UgewotCQkJCQkJdmFsdWUgPSBERUZBVUxUX0tFWTsKLQkJCQkJfQotCQkJCX0KLQotCQkJCWlmICh2YWx1ZS5zdGFydHNXaXRoKERFRkFVTFRfS0VZKSkgewotCQkJCQlTdHJpbmcgZGVmYXVsdE5hbWUgPSB2YWx1ZS5zdWJzdHJpbmcoREVGQVVMVF9LRVkubGVuZ3RoKCkpOwotCi0JCQkJCWlmIChkZWZhdWx0TmFtZS5sZW5ndGgoKSA+IDApIHsKLQkJCQkJCXZhbHVlID0gTkxTLmJpbmQoCi0JCQkJCQkJSnB0VWlNYXBwaW5nc01lc3NhZ2VzLkRlZmF1bHRXaXRoT25lUGFyYW0sCi0JCQkJCQkJZGVmYXVsdE5hbWUKLQkJCQkJCSk7Ci0JCQkJCX0KLQkJCQkJZWxzZSB7Ci0JCQkJCQl2YWx1ZSA9IEpwdFVpTWFwcGluZ3NNZXNzYWdlcy5EZWZhdWx0RW1wdHk7Ci0JCQkJCX0KLQkJCQl9Ci0KLQkJCQlyZXR1cm4gdmFsdWU7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJvdGVjdGVkIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRSZXNlcnZlZENvbnZlcnRlck5hbWVMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFN0YXRpY0xpc3RWYWx1ZU1vZGVsPFN0cmluZz4oQ29udmVydC5SRVNFUlZFRF9DT05WRVJURVJfTkFNRVMpOwotCX0KLQkKLQlwcm90ZWN0ZWQgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZENvbnZlcnRlck5hbWVMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IExpc3RBc3BlY3RBZGFwdGVyPEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0LCBTdHJpbmc+KAotCQkJYnVpbGRQZXJzaXN0ZW5jZVVuaXRIb2xkZXIoKSwKLQkJCUVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0LkNPTlZFUlRFUlNfTElTVCkvL1RPRE8gbmVlZCBFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdCBpbnRlcmZhY2UKLQkJewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgTGlzdEl0ZXJhdG9yPFN0cmluZz4gbGlzdEl0ZXJhdG9yXygpIHsKLQkJCQlyZXR1cm4gQ29sbGVjdGlvblRvb2xzLmxpc3RJdGVyYXRvcihDb2xsZWN0aW9uVG9vbHMuc29ydCh0aGlzLnN1YmplY3QudW5pcXVlQ29udmVydGVyTmFtZXMoKSkpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0PiBidWlsZFBlcnNpc3RlbmNlVW5pdEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29udmVydCwgRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQ+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIChFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdCkgZ2V0U3ViamVjdCgpLmdldFBlcnNpc3RlbmNlVW5pdCgpOwotCQkJfQotCQl9OwotCX0KLQotCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRCb29sZWFuSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPENvbnZlcnQsIEJvb2xlYW4+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiB0cmFuc2Zvcm0oQ29udmVydCB2YWx1ZSkgewotCQkJCWlmIChnZXRTdWJqZWN0KCkgIT0gbnVsbCAmJiBnZXRTdWJqZWN0KCkuZ2V0UGFyZW50KCkuZ2V0UGVyc2lzdGVudEF0dHJpYnV0ZSgpLmlzVmlydHVhbCgpKSB7Ci0JCQkJCXJldHVybiBCb29sZWFuLkZBTFNFOwotCQkJCX0KLQkJCQlyZXR1cm4gQm9vbGVhbi52YWx1ZU9mKHZhbHVlICE9IG51bGwpOwotCQkJfQotCQl9OwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL09ybUV4aXN0ZW5jZUNoZWNraW5nQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9vcm0vZGV0YWlscy9Pcm1FeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5MTljMTEwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL29ybS9kZXRhaWxzL09ybUV4aXN0ZW5jZUNoZWNraW5nQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMDYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzCi0gKiAgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZgotICogIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcwotICogIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotICoKLSAqICBDb250cmlidXRvcnM6IE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5jb250ZXh0LkNhY2hpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuY29udGV4dC5FeGlzdGVuY2VUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5tYXBwaW5ncy5FY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5FbnVtRm9ybUNvbWJvVmlld2VyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBIZXJlIGlzIHRoZSBsYXlvdXQgb2YgdGhpcyBwYW5lOgotICogPHByZT4KLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLSAqIHwgICAgICAgCQkJICAJCS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogfCB4IEV4aXN0ZW5jZSBDaGVja2luZzogIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8dnwgfAotICogfCAgICAgICAJCQkJCS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLTwvcHJlPgotICoKLSAqIEBzZWUgRWNsaXBzZUxpbmtDYWNoaW5nCi0gKiBAc2VlIENhY2hpbmdDb21wb3NpdGUgLSBBIGNvbnRhaW5lciBvZiB0aGlzIHdpZGdldAotICoKLSAqIEB2ZXJzaW9uIDIuMQotICogQHNpbmNlIDIuMQotICovCi1wdWJsaWMgY2xhc3MgT3JtRXhpc3RlbmNlQ2hlY2tpbmdDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxDYWNoaW5nPiB7Ci0KLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkV4aXN0ZW5jZUNoZWNraW5nQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRQYW5lIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBPcm1FeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZShGb3JtUGFuZTw/IGV4dGVuZHMgQ2FjaGluZz4gcGFyZW50UGFuZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRQYW5lLCBwYXJlbnQsIGZhbHNlKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlhZGRMYWJlbGVkQ29tcG9zaXRlKCAKLSAgICAgICAgICAgIGNvbnRhaW5lciwgCi0gICAgICAgICAgICBFY2xpcHNlTGlua1VpTWFwcGluZ3NNZXNzYWdlcy5FeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZV9sYWJlbCwKLSAgICAgICAgICAgIGFkZEV4aXN0ZW5jZUNoZWNraW5nVHlwZUNvbWJvKGNvbnRhaW5lcikuZ2V0Q29udHJvbCgpLCAKLSAgICAgICAgICAgIG51bGwgCi0gICAgICAgKTsKLQl9Ci0KLQlwcml2YXRlIEVudW1Gb3JtQ29tYm9WaWV3ZXI8Q2FjaGluZywgRXhpc3RlbmNlVHlwZT4gYWRkRXhpc3RlbmNlQ2hlY2tpbmdUeXBlQ29tYm8oQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXJldHVybiBuZXcgRW51bUZvcm1Db21ib1ZpZXdlcjxDYWNoaW5nLCBFeGlzdGVuY2VUeXBlPih0aGlzLCBjb250YWluZXIpIHsKLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBhZGRQcm9wZXJ0eU5hbWVzKENvbGxlY3Rpb248U3RyaW5nPiBwcm9wZXJ0eU5hbWVzKSB7Ci0JCQkJc3VwZXIuYWRkUHJvcGVydHlOYW1lcyhwcm9wZXJ0eU5hbWVzKTsKLQkJCQlwcm9wZXJ0eU5hbWVzLmFkZChDYWNoaW5nLkRFRkFVTFRfRVhJU1RFTkNFX1RZUEVfUFJPUEVSVFkpOwotCQkJCXByb3BlcnR5TmFtZXMuYWRkKENhY2hpbmcuU1BFQ0lGSUVEX0VYSVNURU5DRV9UWVBFX1BST1BFUlRZKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgRXhpc3RlbmNlVHlwZVtdIGdldENob2ljZXMoKSB7Ci0JCQkJcmV0dXJuIEV4aXN0ZW5jZVR5cGUudmFsdWVzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEV4aXN0ZW5jZVR5cGUgZ2V0RGVmYXVsdFZhbHVlKCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0RGVmYXVsdEV4aXN0ZW5jZVR5cGUoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGRpc3BsYXlTdHJpbmcoRXhpc3RlbmNlVHlwZSB2YWx1ZSkgewotCQkJCXJldHVybiBidWlsZERpc3BsYXlTdHJpbmcoCi0JCQkJCUVjbGlwc2VMaW5rVWlNYXBwaW5nc01lc3NhZ2VzLmNsYXNzLAotCQkJCQlPcm1FeGlzdGVuY2VDaGVja2luZ0NvbXBvc2l0ZS50aGlzLAotCQkJCQl2YWx1ZQotCQkJCSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEV4aXN0ZW5jZVR5cGUgZ2V0VmFsdWUoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXRTcGVjaWZpZWRFeGlzdGVuY2VUeXBlKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWUoRXhpc3RlbmNlVHlwZSB2YWx1ZSkgewotCQkJCWdldFN1YmplY3QoKS5zZXRTcGVjaWZpZWRFeGlzdGVuY2VUeXBlKHZhbHVlKTsKLQkJCX0KLQkJCQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgYm9vbGVhbiBzb3J0Q2hvaWNlcygpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCX07Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jYWNoaW5nL0NhY2hlU2l6ZUNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9DYWNoZVNpemVDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNTAxYzVjMS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jYWNoaW5nL0NhY2hlU2l6ZUNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTY5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmNhY2hpbmc7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNhY2hpbmcuQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLkxhYmVsZWRDb250cm9sVXBkYXRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwudXRpbC5MYWJlbGVkTGFiZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkRGF0YTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29udHJvbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5MYWJlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5TcGlubmVyOwotCi0vKioKLSAqIENhY2hlU2l6ZUNvbXBvc2l0ZQotICovCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBDYWNoZVNpemVDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPEVudGl0eUNhY2hlUHJvcGVydGllcz4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkNhY2hlVHlwZUNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50Q29udHJvbGxlcgotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50Ci0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBDYWNoZVNpemVDb21wb3NpdGUoUGFuZTxFbnRpdHlDYWNoZVByb3BlcnRpZXM+IHBhcmVudENvbXBvc2l0ZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRDb21wb3NpdGUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyPiBidWlsZENhY2hlU2l6ZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8RW50aXR5Q2FjaGVQcm9wZXJ0aWVzLCBJbnRlZ2VyPihnZXRTdWJqZWN0SG9sZGVyKCksIEVudGl0eUNhY2hlUHJvcGVydGllcy5DQUNIRV9TSVpFX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBJbnRlZ2VyIGJ1aWxkVmFsdWVfKCkgewotCQkJCUludGVnZXIgdmFsdWUgPSBzdWJqZWN0LmdldENhY2hlU2l6ZSgpOwotCQkJCWlmICh2YWx1ZSA9PSBudWxsKSB7Ci0JCQkJCXZhbHVlID0gLTE7Ci0JCQkJfQotCQkJCXJldHVybiB2YWx1ZTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oSW50ZWdlciB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZSA9PSAtMSkgewotCQkJCQl2YWx1ZSA9IG51bGw7Ci0JCQkJfQotCQkJCXN1YmplY3Quc2V0Q2FjaGVTaXplKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxDYWNoaW5nPiBidWlsZENhY2hpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8RW50aXR5Q2FjaGVQcm9wZXJ0aWVzLCBDYWNoaW5nPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENhY2hpbmcgdHJhbnNmb3JtXyhFbnRpdHlDYWNoZVByb3BlcnRpZXMgdmFsdWUpIHsKLQkJCQlyZXR1cm4gdmFsdWUuZ2V0Q2FjaGluZygpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXI+IGJ1aWxkRGVmYXVsdENhY2hlU2l6ZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q2FjaGluZywgSW50ZWdlcj4oYnVpbGRDYWNoaW5nSG9sZGVyKCksIENhY2hpbmcuQ0FDSEVfU0laRV9ERUZBVUxUX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBJbnRlZ2VyIGJ1aWxkVmFsdWVfKCkgewotCQkJCUludGVnZXIgdmFsdWUgPSBzdWJqZWN0LmdldENhY2hlU2l6ZURlZmF1bHQoKTsKLQkJCQlpZiAodmFsdWUgPT0gbnVsbCkgewotCQkJCQl2YWx1ZSA9IHN1YmplY3QuZ2V0RGVmYXVsdENhY2hlU2l6ZURlZmF1bHQoKTsKLQkJCQl9Ci0JCQkJcmV0dXJuIHZhbHVlOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgQ29udHJvbCBhZGREZWZhdWx0Q2FjaGVTaXplTGFiZWwoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCUxhYmVsIGxhYmVsID0gYWRkTGFiZWwoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuRGVmYXVsdFdpdGhvdXRWYWx1ZQotCQkpOwotCi0JCW5ldyBMYWJlbGVkQ29udHJvbFVwZGF0ZXIoCi0JCQluZXcgTGFiZWxlZExhYmVsKGxhYmVsKSwKLQkJCWJ1aWxkRGVmYXVsdENhY2hlU2l6ZUxhYmVsSG9sZGVyKCkKLQkJKTsKLQotCQlyZXR1cm4gbGFiZWw7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZERlZmF1bHRDYWNoZVNpemVMYWJlbEhvbGRlcigpIHsKLQotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXIsIFN0cmluZz4oYnVpbGREZWZhdWx0Q2FjaGVTaXplSG9sZGVyKCkpIHsKLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShJbnRlZ2VyIHZhbHVlKSB7Ci0KLQkJCQlpZiAodmFsdWUgIT0gbnVsbCkgewotCQkJCQlyZXR1cm4gTkxTLmJpbmQoRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkRlZmF1bHRXaXRoVmFsdWUsIHZhbHVlKTsKLQkJCQl9Ci0KLQkJCQlyZXR1cm4gIiI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJU3Bpbm5lciBzcGlubmVyID0gdGhpcy5hZGRMYWJlbGVkU3Bpbm5lcigKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5DYWNoZVNpemVDb21wb3NpdGVfY2FjaGVTaXplLAotCQkJdGhpcy5idWlsZENhY2hlU2l6ZUhvbGRlcigpLAotCQkJLTEsCi0JCQktMSwKLQkJCUludGVnZXIuTUFYX1ZBTFVFLAotCQkJdGhpcy5hZGREZWZhdWx0Q2FjaGVTaXplTGFiZWwoY29udGFpbmVyKSwKLQkJCW51bGwKLQkJKTsKLQotCQl1cGRhdGVHcmlkRGF0YShjb250YWluZXIsIHNwaW5uZXIpOwotCX0KLQotCS8qKgotCSAqIENoYW5nZXMgdGhlIGxheW91dCBvZiB0aGUgZ2l2ZW4gY29udGFpbmVyIGJ5IGNoYW5naW5nIHdoaWNoIHdpZGdldCB3aWxsCi0JICogZ3JhYiB0aGUgZXhjZXNzIG9mIGhvcml6b250YWwgc3BhY2UuIEJ5IGRlZmF1bHQsIHRoZSBjZW50ZXIgY29udHJvbCBncmFicwotCSAqIHRoZSBleGNlc3Mgc3BhY2UsIHdlIGNoYW5nZSBpdCB0byBiZSB0aGUgcmlnaHQgY29udHJvbC4KLQkgKgotCSAqIEBwYXJhbSBjb250YWluZXIgVGhlIGNvbnRhaW5lciBjb250YWluaW5nIHRoZSBjb250cm9scyBuZWVkaW5nIHRoZWlyCi0JICogPGNvZGU+R3JpZERhdGE8L2NvZGU+IHRvIGJlIG1vZGlmaWVkIGZyb20gdGhlIGRlZmF1bHQgdmFsdWVzCi0JICogQHBhcmFtIHNwaW5uZXIgVGhlIHNwaW5uZXIgdGhhdCBnb3QgY3JlYXRlZAotCSAqLwotCXByaXZhdGUgdm9pZCB1cGRhdGVHcmlkRGF0YShDb21wb3NpdGUgY29udGFpbmVyLCBTcGlubmVyIHNwaW5uZXIpIHsKLQotCQkvLyBJdCBpcyBwb3NzaWJsZSB0aGUgc3Bpbm5lcidzIHBhcmVudCBpcyBub3QgdGhlIGNvbnRhaW5lciBvZiB0aGUKLQkJLy8gbGFiZWwsIHNwaW5uZXIgYW5kIHJpZ2h0IGNvbnRyb2wgKGEgcGFuZSBpcyBzb21ldGltZXMgcmVxdWlyZWQgZm9yCi0JCS8vIHBhaW50aW5nIHRoZSBzcGlubmVyJ3MgYm9yZGVyKQotCQlDb21wb3NpdGUgcGFuZUNvbnRhaW5lciA9IHNwaW5uZXIuZ2V0UGFyZW50KCk7Ci0KLQkJd2hpbGUgKGNvbnRhaW5lciAhPSBwYW5lQ29udGFpbmVyLmdldFBhcmVudCgpKSB7Ci0JCQlwYW5lQ29udGFpbmVyID0gcGFuZUNvbnRhaW5lci5nZXRQYXJlbnQoKTsKLQkJfQotCi0JCUNvbnRyb2xbXSBjb250cm9scyA9IHBhbmVDb250YWluZXIuZ2V0Q2hpbGRyZW4oKTsKLQotCQlHcmlkRGF0YSBncmlkRGF0YSA9IG5ldyBHcmlkRGF0YSgpOwotCQlncmlkRGF0YS5ncmFiRXhjZXNzSG9yaXpvbnRhbFNwYWNlID0gZmFsc2U7Ci0JCWdyaWREYXRhLmhvcml6b250YWxBbGlnbm1lbnQgICAgICAgPSBHcmlkRGF0YS5CRUdJTk5JTkc7Ci0JCWNvbnRyb2xzWzFdLnNldExheW91dERhdGEoZ3JpZERhdGEpOwotCi0JCWNvbnRyb2xzWzJdLnNldExheW91dERhdGEobmV3IEdyaWREYXRhKEdyaWREYXRhLkZJTExfSE9SSVpPTlRBTCkpOwotCQlyZW1vdmVBbGlnblJpZ2h0KGNvbnRyb2xzWzJdKTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9DYWNoZVR5cGVDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2NhY2hpbmcvQ2FjaGVUeXBlQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDYwNmE4OWMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9DYWNoZVR5cGVDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE2MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jYWNoaW5nOwotCi1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5jYWNoaW5nLkNhY2hlVHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNhY2hpbmcuQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5saXN0ZW5lcnMuU1dUUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcldyYXBwZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRW51bUZvcm1Db21ib1ZpZXdlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Qcm9wZXJ0eUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBDYWNoZVR5cGVDb21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIENhY2hlVHlwZUNvbXBvc2l0ZSBleHRlbmRzIFBhbmU8RW50aXR5Q2FjaGVQcm9wZXJ0aWVzPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+Q2FjaGVUeXBlQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRDb250cm9sbGVyCi0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIENhY2hlVHlwZUNvbXBvc2l0ZShQYW5lPEVudGl0eUNhY2hlUHJvcGVydGllcz4gcGFyZW50Q29tcG9zaXRlLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudENvbXBvc2l0ZSwgcGFyZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQl0aGlzLmFkZExhYmVsZWRDb21wb3NpdGUoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiX2NhY2hlVHlwZUxhYmVsLAotCQkJbmV3IENhY2hlVHlwZUNvbWJvKGNvbnRhaW5lciksCi0JCQludWxsCQkvLyBUT0RPIElKcGFIZWxwQ29udGV4dElkcy4KLQkJKTsKLQl9Ci0KLQlwcml2YXRlIGNsYXNzIENhY2hlVHlwZUNvbWJvIGV4dGVuZHMgRW51bUZvcm1Db21ib1ZpZXdlcjxFbnRpdHlDYWNoZVByb3BlcnRpZXMsIENhY2hlVHlwZT4gewotCi0JCXByaXZhdGUgQ2FjaGVUeXBlQ29tYm8oQ29tcG9zaXRlIHBhcmVudCkgewotCQkJc3VwZXIoQ2FjaGVUeXBlQ29tcG9zaXRlLnRoaXMsIHBhcmVudCk7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIHZvaWQgYWRkUHJvcGVydHlOYW1lcyhDb2xsZWN0aW9uPFN0cmluZz4gcHJvcGVydHlOYW1lcykgewotCQkJc3VwZXIuYWRkUHJvcGVydHlOYW1lcyhwcm9wZXJ0eU5hbWVzKTsKLQkJCXByb3BlcnR5TmFtZXMuYWRkKEVudGl0eUNhY2hlUHJvcGVydGllcy5DQUNIRV9UWVBFX1BST1BFUlRZKTsKLQkJfQotCi0JCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPENhY2hpbmc+IGJ1aWxkQ2FjaGluZ0hvbGRlcigpIHsKLQkJCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8RW50aXR5Q2FjaGVQcm9wZXJ0aWVzLCBDYWNoaW5nPihnZXRTdWJqZWN0SG9sZGVyKCkpIHsKLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgQ2FjaGluZyB0cmFuc2Zvcm1fKEVudGl0eUNhY2hlUHJvcGVydGllcyB2YWx1ZSkgewotCQkJCQlyZXR1cm4gdmFsdWUuZ2V0Q2FjaGluZygpOwotCQkJCX0KLQkJCX07Ci0JCX0KLQotCQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxDYWNoZVR5cGU+IGJ1aWxkRGVmYXVsdENhY2hlVHlwZUhvbGRlcigpIHsKLQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENhY2hpbmcsIENhY2hlVHlwZT4oYnVpbGRDYWNoaW5nSG9sZGVyKCksIENhY2hpbmcuQ0FDSEVfVFlQRV9ERUZBVUxUX1BST1BFUlRZKSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIENhY2hlVHlwZSBidWlsZFZhbHVlXygpIHsKLQkJCQkJQ2FjaGVUeXBlIGNhY2hlVHlwZSA9IHN1YmplY3QuZ2V0Q2FjaGVUeXBlRGVmYXVsdCgpOwotCQkJCQlpZiAoY2FjaGVUeXBlID09IG51bGwpIHsKLQkJCQkJCWNhY2hlVHlwZSA9IHN1YmplY3QuZ2V0RGVmYXVsdENhY2hlVHlwZURlZmF1bHQoKTsKLQkJCQkJfQotCQkJCQlyZXR1cm4gY2FjaGVUeXBlOwotCQkJCX0KLQkJCX07Ci0JCX0KLQotCQlwcml2YXRlIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGREZWZhdWx0Q2FjaGluZ1R5cGVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcmV0dXJuIG5ldyBTV1RQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyV3JhcHBlcigKLQkJCQlidWlsZERlZmF1bHRDYWNoaW5nVHlwZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJfKCkKLQkJCSk7Ci0JCX0KLQotCQlwcml2YXRlIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGREZWZhdWx0Q2FjaGluZ1R5cGVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyXygpIHsKLQkJCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJCWlmICgoZS5nZXROZXdWYWx1ZSgpICE9IG51bGwpICYmICFnZXRDb21ibygpLmlzRGlzcG9zZWQoKSkgewotCQkJCQkJQ2FjaGVUeXBlQ29tYm8udGhpcy5kb1BvcHVsYXRlKCk7Ci0JCQkJCX0KLQkJCQl9Ci0JCQl9OwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCBDYWNoZVR5cGVbXSBnZXRDaG9pY2VzKCkgewotCQkJcmV0dXJuIENhY2hlVHlwZS52YWx1ZXMoKTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgQ2FjaGVUeXBlIGdldERlZmF1bHRWYWx1ZSgpIHsKLQkJCXJldHVybiB0aGlzLmdldFN1YmplY3QoKS5nZXREZWZhdWx0Q2FjaGVUeXBlKCk7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIFN0cmluZyBkaXNwbGF5U3RyaW5nKENhY2hlVHlwZSB2YWx1ZSkgewotCQkJcmV0dXJuIGJ1aWxkRGlzcGxheVN0cmluZygKLQkJCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuY2xhc3MsCi0JCQkJQ2FjaGVUeXBlQ29tcG9zaXRlLnRoaXMsCi0JCQkJdmFsdWUKLQkJCSk7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIHZvaWQgZG9Qb3B1bGF0ZSgpIHsKLQkJCS8vIFRoaXMgaXMgcmVxdWlyZWQgdG8gYWxsb3cgdGhlIGNsYXNzIGxvYWRlciB0byBsZXQgdGhlIGxpc3RlbmVyCi0JCQkvLyB3cml0dGVuIGFib3ZlIHRvIGFjY2VzcyB0aGlzIG1ldGhvZAotCQkJc3VwZXIuZG9Qb3B1bGF0ZSgpOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCBDYWNoZVR5cGUgZ2V0VmFsdWUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5nZXRTdWJqZWN0KCkuZ2V0Q2FjaGVUeXBlKCk7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZSgpIHsKLQkJCXN1cGVyLmluaXRpYWxpemUoKTsKLQotCQkJUHJvcGVydHlWYWx1ZU1vZGVsPENhY2hlVHlwZT4gZGVmYXVsdENhY2hlVHlwZUhvbGRlciA9Ci0JCQkJYnVpbGREZWZhdWx0Q2FjaGVUeXBlSG9sZGVyKCk7Ci0KLQkJCWRlZmF1bHRDYWNoZVR5cGVIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigKLQkJCQlQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsCi0JCQkJYnVpbGREZWZhdWx0Q2FjaGluZ1R5cGVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkKLQkJCSk7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWUoQ2FjaGVUeXBlIHZhbHVlKSB7Ci0JCQl0aGlzLmdldFN1YmplY3QoKS5zZXRDYWNoZVR5cGUodmFsdWUpOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCBib29sZWFuIHNvcnRDaG9pY2VzKCkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2NhY2hpbmcvRGVmYXVsdENhY2hlU2l6ZUNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9EZWZhdWx0Q2FjaGVTaXplQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDY5YjYyYjMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9EZWZhdWx0Q2FjaGVTaXplQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNjkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY2FjaGluZzsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY2FjaGluZy5DYWNoaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuTGFiZWxlZENvbnRyb2xVcGRhdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLkxhYmVsZWRMYWJlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWREYXRhOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db250cm9sOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkxhYmVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLlNwaW5uZXI7Ci0KLS8qKgotICogQ2FjaGVTaXplQ29tcG9zaXRlCi0gKi8KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIERlZmF1bHRDYWNoZVNpemVDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPENhY2hpbmc+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5DYWNoZVR5cGVDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudENvbnRyb2xsZXIKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudAotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgRGVmYXVsdENhY2hlU2l6ZUNvbXBvc2l0ZShQYW5lPENhY2hpbmc+IHBhcmVudENvbXBvc2l0ZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4gYnVpbGRDYWNoZVNpemVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENhY2hpbmcsIEludGVnZXI+KGdldFN1YmplY3RIb2xkZXIoKSwgQ2FjaGluZy5DQUNIRV9TSVpFX0RFRkFVTFRfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEludGVnZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJSW50ZWdlciB2YWx1ZSA9IHN1YmplY3QuZ2V0Q2FjaGVTaXplRGVmYXVsdCgpOwotCi0JCQkJaWYgKHZhbHVlID09IG51bGwpIHsKLQkJCQkJdmFsdWUgPSAtMTsKLQkJCQl9Ci0JCQkJcmV0dXJuIHZhbHVlOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhJbnRlZ2VyIHZhbHVlKSB7Ci0JCQkJaWYgKHZhbHVlID09IC0xKSB7Ci0JCQkJCXZhbHVlID0gbnVsbDsKLQkJCQl9Ci0JCQkJc3ViamVjdC5zZXRDYWNoZVNpemVEZWZhdWx0KHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyPiBidWlsZERlZmF1bHRDYWNoZVNpemVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENhY2hpbmcsIEludGVnZXI+KGdldFN1YmplY3RIb2xkZXIoKSwgIiIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEludGVnZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3QuZ2V0RGVmYXVsdENhY2hlU2l6ZURlZmF1bHQoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzdWJqZWN0Q2hhbmdlZCgpIHsKLQkJCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0JCQkJc3VwZXIuc3ViamVjdENoYW5nZWQoKTsKLQkJCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0KLQkJCQkvLyBNYWtlIHN1cmUgdGhlIGRlZmF1bHQgdmFsdWUgaXMgYXBwZW5kZWQgdG8gdGhlIHRleHQKLQkJCQlpZiAob2xkVmFsdWUgPT0gbmV3VmFsdWUgJiYgbmV3VmFsdWUgPT0gbnVsbCkgewotCQkJCQl0aGlzLmZpcmVBc3BlY3RDaGFuZ2UoSW50ZWdlci5NSU5fVkFMVUUsIG5ld1ZhbHVlKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBDb250cm9sIGFkZERlZmF1bHRDYWNoZVNpemVMYWJlbChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJTGFiZWwgbGFiZWwgPSBhZGRMYWJlbCgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5EZWZhdWx0V2l0aG91dFZhbHVlCi0JCSk7Ci0KLQkJbmV3IExhYmVsZWRDb250cm9sVXBkYXRlcigKLQkJCW5ldyBMYWJlbGVkTGFiZWwobGFiZWwpLAotCQkJYnVpbGREZWZhdWx0Q2FjaGVTaXplTGFiZWxIb2xkZXIoKQotCQkpOwotCi0JCXJldHVybiBsYWJlbDsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdENhY2hlU2l6ZUxhYmVsSG9sZGVyKCkgewotCi0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlciwgU3RyaW5nPihidWlsZERlZmF1bHRDYWNoZVNpemVIb2xkZXIoKSkgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKEludGVnZXIgdmFsdWUpIHsKLQotCQkJCWlmICh2YWx1ZSAhPSBudWxsKSB7Ci0JCQkJCXJldHVybiBOTFMuYmluZChFY2xpcHNlTGlua1VpTWVzc2FnZXMuRGVmYXVsdFdpdGhWYWx1ZSwgdmFsdWUpOwotCQkJCX0KLQotCQkJCXJldHVybiAiIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlTcGlubmVyIHNwaW5uZXIgPSB0aGlzLmFkZExhYmVsZWRTcGlubmVyKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkRlZmF1bHRDYWNoZVNpemVDb21wb3NpdGVfZGVmYXVsdENhY2hlU2l6ZSwKLQkJCXRoaXMuYnVpbGRDYWNoZVNpemVIb2xkZXIoKSwKLQkJCS0xLAotCQkJLTEsCi0JCQlJbnRlZ2VyLk1BWF9WQUxVRSwKLQkJCXRoaXMuYWRkRGVmYXVsdENhY2hlU2l6ZUxhYmVsKGNvbnRhaW5lciksCi0JCQludWxsCi0JCSk7Ci0KLQkJdXBkYXRlR3JpZERhdGEoY29udGFpbmVyLCBzcGlubmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBDaGFuZ2VzIHRoZSBsYXlvdXQgb2YgdGhlIGdpdmVuIGNvbnRhaW5lciBieSBjaGFuZ2luZyB3aGljaCB3aWRnZXQgd2lsbAotCSAqIGdyYWIgdGhlIGV4Y2VzcyBvZiBob3Jpem9udGFsIHNwYWNlLiBCeSBkZWZhdWx0LCB0aGUgY2VudGVyIGNvbnRyb2wgZ3JhYnMKLQkgKiB0aGUgZXhjZXNzIHNwYWNlLCB3ZSBjaGFuZ2UgaXQgdG8gYmUgdGhlIHJpZ2h0IGNvbnRyb2wuCi0JICoKLQkgKiBAcGFyYW0gY29udGFpbmVyIFRoZSBjb250YWluZXIgY29udGFpbmluZyB0aGUgY29udHJvbHMgbmVlZGluZyB0aGVpcgotCSAqIDxjb2RlPkdyaWREYXRhPC9jb2RlPiB0byBiZSBtb2RpZmllZCBmcm9tIHRoZSBkZWZhdWx0IHZhbHVlcwotCSAqIEBwYXJhbSBzcGlubmVyIFRoZSBzcGlubmVyIHRoYXQgZ290IGNyZWF0ZWQKLQkgKi8KLQlwcml2YXRlIHZvaWQgdXBkYXRlR3JpZERhdGEoQ29tcG9zaXRlIGNvbnRhaW5lciwgU3Bpbm5lciBzcGlubmVyKSB7Ci0KLQkJLy8gSXQgaXMgcG9zc2libGUgdGhlIHNwaW5uZXIncyBwYXJlbnQgaXMgbm90IHRoZSBjb250YWluZXIgb2YgdGhlCi0JCS8vIGxhYmVsLCBzcGlubmVyIGFuZCByaWdodCBjb250cm9sIChhIHBhbmUgaXMgc29tZXRpbWVzIHJlcXVpcmVkIGZvcgotCQkvLyBwYWludGluZyB0aGUgc3Bpbm5lcidzIGJvcmRlcikKLQkJQ29tcG9zaXRlIHBhbmVDb250YWluZXIgPSBzcGlubmVyLmdldFBhcmVudCgpOwotCi0JCXdoaWxlIChjb250YWluZXIgIT0gcGFuZUNvbnRhaW5lci5nZXRQYXJlbnQoKSkgewotCQkJcGFuZUNvbnRhaW5lciA9IHBhbmVDb250YWluZXIuZ2V0UGFyZW50KCk7Ci0JCX0KLQotCQlDb250cm9sW10gY29udHJvbHMgPSBwYW5lQ29udGFpbmVyLmdldENoaWxkcmVuKCk7Ci0KLQkJR3JpZERhdGEgZ3JpZERhdGEgPSBuZXcgR3JpZERhdGEoKTsKLQkJZ3JpZERhdGEuZ3JhYkV4Y2Vzc0hvcml6b250YWxTcGFjZSA9IGZhbHNlOwotCQlncmlkRGF0YS5ob3Jpem9udGFsQWxpZ25tZW50ICAgICAgID0gR3JpZERhdGEuQkVHSU5OSU5HOwotCQljb250cm9sc1sxXS5zZXRMYXlvdXREYXRhKGdyaWREYXRhKTsKLQotCQljb250cm9sc1syXS5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5GSUxMX0hPUklaT05UQUwpKTsKLQkJcmVtb3ZlQWxpZ25SaWdodChjb250cm9sc1syXSk7Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2NhY2hpbmcvRGVmYXVsdENhY2hlVHlwZUNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9EZWZhdWx0Q2FjaGVUeXBlQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGM5YmU0ZDcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9EZWZhdWx0Q2FjaGVUeXBlQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw5MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY2FjaGluZzsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY2FjaGluZy5DYWNoZVR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5jYWNoaW5nLkNhY2hpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5FbnVtRm9ybUNvbWJvVmlld2VyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBEZWZhdWx0Q2FjaGVUeXBlQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBEZWZhdWx0Q2FjaGVUeXBlQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8Q2FjaGluZz4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkRlZmF1bHRDYWNoZVR5cGVDb21wb3NpdGU8L2NvZGU+LgotCSAqIAotCSAqIEBwYXJhbSBwYXJlbnRDb250cm9sbGVyCi0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIERlZmF1bHRDYWNoZVR5cGVDb21wb3NpdGUoCi0JCQkJCUZvcm1QYW5lPD8gZXh0ZW5kcyBDYWNoaW5nPiBwYXJlbnRDb21wb3NpdGUsIAotCQkJCQlDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIoIHBhcmVudENvbXBvc2l0ZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIEVudW1Gb3JtQ29tYm9WaWV3ZXI8Q2FjaGluZywgQ2FjaGVUeXBlPiBidWlsZERlZmF1bHRDYWNoZVR5cGVDb21ibyhDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCXJldHVybiBuZXcgRW51bUZvcm1Db21ib1ZpZXdlcjxDYWNoaW5nLCBDYWNoZVR5cGU+KHRoaXMsIGNvbnRhaW5lcikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBhZGRQcm9wZXJ0eU5hbWVzKENvbGxlY3Rpb248U3RyaW5nPiBwcm9wZXJ0eU5hbWVzKSB7Ci0JCQkJc3VwZXIuYWRkUHJvcGVydHlOYW1lcyhwcm9wZXJ0eU5hbWVzKTsKLQkJCQlwcm9wZXJ0eU5hbWVzLmFkZChDYWNoaW5nLkNBQ0hFX1RZUEVfREVGQVVMVF9QUk9QRVJUWSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENhY2hlVHlwZVtdIGdldENob2ljZXMoKSB7Ci0JCQkJcmV0dXJuIENhY2hlVHlwZS52YWx1ZXMoKTsKLQkJCX0KLQkJCQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgYm9vbGVhbiBzb3J0Q2hvaWNlcygpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENhY2hlVHlwZSBnZXREZWZhdWx0VmFsdWUoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXREZWZhdWx0Q2FjaGVUeXBlRGVmYXVsdCgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZGlzcGxheVN0cmluZyhDYWNoZVR5cGUgdmFsdWUpIHsKLQkJCQlyZXR1cm4gYnVpbGREaXNwbGF5U3RyaW5nKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5jbGFzcywgRGVmYXVsdENhY2hlVHlwZUNvbXBvc2l0ZS50aGlzLCB2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIENhY2hlVHlwZSBnZXRWYWx1ZSgpIHsKLQkJCQlyZXR1cm4gZ2V0U3ViamVjdCgpLmdldENhY2hlVHlwZURlZmF1bHQoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZShDYWNoZVR5cGUgdmFsdWUpIHsKLQkJCQlnZXRTdWJqZWN0KCkuc2V0Q2FjaGVUeXBlRGVmYXVsdCh2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoIENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQl0aGlzLmFkZExhYmVsZWRDb21wb3NpdGUoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiX2RlZmF1bHRDYWNoZVR5cGVMYWJlbCwKLQkJCXRoaXMuYnVpbGREZWZhdWx0Q2FjaGVUeXBlQ29tYm8oIGNvbnRhaW5lciksCi0JCQludWxsCQkvLyBUT0RPIElKcGFIZWxwQ29udGV4dElkcy4KLQkJKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jYWNoaW5nL0RlZmF1bHRTaGFyZWRDYWNoZUNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9EZWZhdWx0U2hhcmVkQ2FjaGVDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNWVlYmJiOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jYWNoaW5nL0RlZmF1bHRTaGFyZWRDYWNoZUNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsOTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY2FjaGluZzsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY2FjaGluZy5DYWNoaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5vc2dpLnV0aWwuTkxTOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBEZWZhdWx0U2hhcmVDYWNoZUNvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgRGVmYXVsdFNoYXJlZENhY2hlQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8Q2FjaGluZz4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkRlZmF1bHRTaGFyZUNhY2hlQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRDb250cm9sbGVyCi0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIERlZmF1bHRTaGFyZWRDYWNoZUNvbXBvc2l0ZSgKLQkJCQkJRm9ybVBhbmU8PyBleHRlbmRzIENhY2hpbmc+IHBhcmVudENvbXBvc2l0ZSwKLQkJCQkJQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudENvbXBvc2l0ZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkRGVmYXVsdFNoYXJlZENhY2hlSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDYWNoaW5nLCBCb29sZWFuPihnZXRTdWJqZWN0SG9sZGVyKCksIENhY2hpbmcuU0hBUkVEX0NBQ0hFX0RFRkFVTFRfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3QuZ2V0U2hhcmVkQ2FjaGVEZWZhdWx0KCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlzdWJqZWN0LnNldFNoYXJlZENhY2hlRGVmYXVsdCh2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc3ViamVjdENoYW5nZWQoKSB7Ci0JCQkJT2JqZWN0IG9sZFZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCQkJCXN1cGVyLnN1YmplY3RDaGFuZ2VkKCk7Ci0JCQkJT2JqZWN0IG5ld1ZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCi0JCQkJLy8gTWFrZSBzdXJlIHRoZSBkZWZhdWx0IHZhbHVlIGlzIGFwcGVuZGVkIHRvIHRoZSB0ZXh0Ci0JCQkJaWYgKG9sZFZhbHVlID09IG5ld1ZhbHVlICYmIG5ld1ZhbHVlID09IG51bGwpIHsKLQkJCQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKEJvb2xlYW4uVFJVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdFNoYXJlZENhY2hlU3RyaW5nSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4sIFN0cmluZz4oYnVpbGREZWZhdWx0U2hhcmVkQ2FjaGVIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShCb29sZWFuIHZhbHVlKSB7Ci0JCQkJaWYgKChnZXRTdWJqZWN0KCkgIT0gbnVsbCkgJiYgKHZhbHVlID09IG51bGwpKSB7Ci0JCQkJCUJvb2xlYW4gZGVmYXVsdFZhbHVlID0gZ2V0U3ViamVjdCgpLmdldERlZmF1bHRTaGFyZWRDYWNoZURlZmF1bHQoKTsKLQkJCQkJaWYgKGRlZmF1bHRWYWx1ZSAhPSBudWxsKSB7Ci0JCQkJCQlTdHJpbmcgZGVmYXVsdFN0cmluZ1ZhbHVlID0gZGVmYXVsdFZhbHVlID8gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fVHJ1ZSA6IEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5Cb29sZWFuX0ZhbHNlOwotCQkJCQkJcmV0dXJuIE5MUy5iaW5kKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbENhY2hpbmdUYWJfZGVmYXVsdFNoYXJlZENhY2hlRGVmYXVsdExhYmVsLCBkZWZhdWx0U3RyaW5nVmFsdWUpOwotCQkJCQl9Ci0JCQkJfQotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiX3NoYXJlZENhY2hlRGVmYXVsdExhYmVsOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXRoaXMuYWRkVHJpU3RhdGVDaGVja0JveFdpdGhEZWZhdWx0KAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ2FjaGluZ1RhYl9zaGFyZWRDYWNoZURlZmF1bHRMYWJlbCwKLQkJCXRoaXMuYnVpbGREZWZhdWx0U2hhcmVkQ2FjaGVIb2xkZXIoKSwKLQkJCXRoaXMuYnVpbGREZWZhdWx0U2hhcmVkQ2FjaGVTdHJpbmdIb2xkZXIoKSwKLQkJCW51bGwKLS8vCQkJRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcy5DQUNISU5HX1NIQVJFRF9DQUNIRV9ERUZBVUxUCi0JCSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9FY2xpcHNlTGlua0NhY2hpbmdDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2NhY2hpbmcvRWNsaXBzZUxpbmtDYWNoaW5nQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDIyNTkwOWIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9FY2xpcHNlTGlua0NhY2hpbmdDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDYwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0qIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0qIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotKgotKiBDb250cmlidXRvcnM6Ci0qICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jYWNoaW5nOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5jYWNoaW5nLkNhY2hpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogIEVjbGlwc2VMaW5rQ2FjaGluZ0NvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtDYWNoaW5nQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8Q2FjaGluZz4KLXsKLQlwdWJsaWMgRWNsaXBzZUxpbmtDYWNoaW5nQ29tcG9zaXRlKEZvcm1QYW5lPENhY2hpbmc+IHN1YmplY3RIb2xkZXIsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIGNvbnRhaW5lcik7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJY29udGFpbmVyID0gdGhpcy5hZGRTZWN0aW9uKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ2FjaGluZ1RhYl9zZWN0aW9uVGl0bGUsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiX3NlY3Rpb25EZXNjcmlwdGlvbgotCQkpOwotCi0JCS8vIERlZmF1bHQgcGFuZQotCQlpbnQgZ3JvdXBCb3hNYXJnaW4gPSB0aGlzLmdldEdyb3VwQm94TWFyZ2luKCk7Ci0KLQkJQ29tcG9zaXRlIGRlZmF1bHRQYW5lID0gdGhpcy5hZGRTdWJQYW5lKAotCQkJY29udGFpbmVyLAotCQkJMCwgZ3JvdXBCb3hNYXJnaW4sIDAsIGdyb3VwQm94TWFyZ2luCi0JCSk7Ci0KLQkJLy8gRGVmYXVsdCBDYWNoZSBUeXBlCi0JCW5ldyBEZWZhdWx0Q2FjaGVUeXBlQ29tcG9zaXRlKHRoaXMsIGRlZmF1bHRQYW5lKTsKLQotCQkvLyBEZWZhdWx0IENhY2hlIFNpemUKLQkJbmV3IERlZmF1bHRDYWNoZVNpemVDb21wb3NpdGUodGhpcywgZGVmYXVsdFBhbmUpOwotCi0JCS8vIERlZmF1bHQgU2hhcmVkIENhY2hlCi0JCW5ldyBEZWZhdWx0U2hhcmVkQ2FjaGVDb21wb3NpdGUodGhpcywgZGVmYXVsdFBhbmUpOwotCi0JCS8vIEVudGl0aWVzTGlzdAotCQluZXcgRW50aXR5TGlzdENvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCQkKLQkJLy8gRmx1c2ggQ2xlYXIgQ2FjaGUKLQkJbmV3IEZsdXNoQ2xlYXJDYWNoZUNvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jYWNoaW5nL0VudGl0eUNhY2hlUHJvcGVydGllcy5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9FbnRpdHlDYWNoZVByb3BlcnRpZXMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNGJiYTNmMC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jYWNoaW5nL0VudGl0eUNhY2hlUHJvcGVydGllcy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTk2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY2FjaGluZzsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY2FjaGluZy5DYWNoZVR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5jYWNoaW5nLkNhY2hpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlByb3BlcnR5Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci0KLS8qKgotICogRW50aXR5Q2FjaGVQcm9wZXJ0aWVzCi0gKi8KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIEVudGl0eUNhY2hlUHJvcGVydGllcyBleHRlbmRzIEFic3RyYWN0TW9kZWwgewotCi0JcHJpdmF0ZSBDYWNoaW5nIGNhY2hpbmc7Ci0JcHJpdmF0ZSBTdHJpbmcgZW50aXR5TmFtZTsKLQkKLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxDYWNoZVR5cGU+IGNhY2hlVHlwZUhvbGRlcjsKLQlwcml2YXRlIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgY2FjaGVUeXBlTGlzdGVuZXI7Ci0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4gY2FjaGVTaXplSG9sZGVyOwotCXByaXZhdGUgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBjYWNoZVNpemVMaXN0ZW5lcjsKLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBzaGFyZWRDYWNoZUhvbGRlcjsKLQlwcml2YXRlIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgc2hhcmVkQ2FjaGVMaXN0ZW5lcjsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDFMOwotCi0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgQ0FDSEVfVFlQRV9QUk9QRVJUWSA9IENhY2hpbmcuQ0FDSEVfVFlQRV9QUk9QRVJUWTsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBDQUNIRV9TSVpFX1BST1BFUlRZID0gQ2FjaGluZy5DQUNIRV9TSVpFX1BST1BFUlRZOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFNIQVJFRF9DQUNIRV9QUk9QRVJUWSA9IENhY2hpbmcuU0hBUkVEX0NBQ0hFX1BST1BFUlRZOwotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCXB1YmxpYyBFbnRpdHlDYWNoZVByb3BlcnRpZXMoQ2FjaGluZyBjYWNoaW5nLCBTdHJpbmcgZW50aXR5TmFtZSkgewotCQlzdXBlcigpOwotCQl0aGlzLmNhY2hpbmcgICAgPSBjYWNoaW5nOwotCQl0aGlzLmVudGl0eU5hbWUgPSBlbnRpdHlOYW1lOwotCQkKLQkJUHJvcGVydHlWYWx1ZU1vZGVsPENhY2hpbmc+IGNhY2hpbmdIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPENhY2hpbmc+KHRoaXMuY2FjaGluZyk7Ci0JCXRoaXMuaW5pdGlhbGl6ZShjYWNoaW5nSG9sZGVyKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZShQcm9wZXJ0eVZhbHVlTW9kZWw8Q2FjaGluZz4gY2FjaGluZ0hvbGRlcikgewotCQl0aGlzLmNhY2hlVHlwZUhvbGRlciA9IHRoaXMuYnVpbGRDYWNoZVR5cGVBQShjYWNoaW5nSG9sZGVyKTsKLQkJdGhpcy5jYWNoZVR5cGVMaXN0ZW5lciA9IHRoaXMuYnVpbGRDYWNoZVR5cGVDaGFuZ2VMaXN0ZW5lcigpOwotCQl0aGlzLmNhY2hlVHlwZUhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5jYWNoZVR5cGVMaXN0ZW5lcik7Ci0KLQkJdGhpcy5jYWNoZVNpemVIb2xkZXIgPSB0aGlzLmJ1aWxkQ2FjaGVTaXplQUEoY2FjaGluZ0hvbGRlcik7Ci0JCXRoaXMuY2FjaGVTaXplTGlzdGVuZXIgPSB0aGlzLmJ1aWxkQ2FjaGVTaXplQ2hhbmdlTGlzdGVuZXIoKTsKLQkJdGhpcy5jYWNoZVNpemVIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMuY2FjaGVTaXplTGlzdGVuZXIpOwotCi0JCXRoaXMuc2hhcmVkQ2FjaGVIb2xkZXIgPSB0aGlzLmJ1aWxkU2hhcmVkQ2FjaGVBQShjYWNoaW5nSG9sZGVyKTsKLQkJdGhpcy5zaGFyZWRDYWNoZUxpc3RlbmVyID0gdGhpcy5idWlsZFNoYXJlZENhY2hlQ2hhbmdlTGlzdGVuZXIoKTsKLQkJdGhpcy5zaGFyZWRDYWNoZUhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5zaGFyZWRDYWNoZUxpc3RlbmVyKTsKLQl9Ci0JCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0JcHVibGljIGJvb2xlYW4gZW50aXR5TmFtZUlzVmFsaWQoKSB7Ci0JCXJldHVybiAhU3RyaW5nVG9vbHMuc3RyaW5nSXNFbXB0eSh0aGlzLmVudGl0eU5hbWUpOwotCX0KLQotCXB1YmxpYyBJbnRlZ2VyIGdldENhY2hlU2l6ZSgpIHsKLQkJcmV0dXJuIHRoaXMuY2FjaGluZy5nZXRDYWNoZVNpemUodGhpcy5lbnRpdHlOYW1lKTsKLQl9Ci0KLQlwdWJsaWMgQ2FjaGVUeXBlIGdldENhY2hlVHlwZSgpIHsKLQkJcmV0dXJuIHRoaXMuY2FjaGluZy5nZXRDYWNoZVR5cGUodGhpcy5lbnRpdHlOYW1lKTsKLQl9Ci0KLQlwdWJsaWMgQ2FjaGluZyBnZXRDYWNoaW5nKCkgewotCQlyZXR1cm4gY2FjaGluZzsKLQl9Ci0KLQlwdWJsaWMgSW50ZWdlciBnZXREZWZhdWx0Q2FjaGVTaXplKCkgewotCQlyZXR1cm4gdGhpcy5jYWNoaW5nLmdldERlZmF1bHRDYWNoZVNpemUoKTsKLQl9Ci0KLQlwdWJsaWMgQ2FjaGVUeXBlIGdldERlZmF1bHRDYWNoZVR5cGUoKSB7Ci0JCXJldHVybiB0aGlzLmNhY2hpbmcuZ2V0RGVmYXVsdENhY2hlVHlwZSgpOwotCX0KLQotCXB1YmxpYyBTdHJpbmcgZ2V0RW50aXR5TmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMuZW50aXR5TmFtZTsKLQl9Ci0KLQlwdWJsaWMgQm9vbGVhbiBnZXRTaGFyZWRDYWNoZSgpIHsKLQkJcmV0dXJuIHRoaXMuY2FjaGluZy5nZXRTaGFyZWRDYWNoZSh0aGlzLmVudGl0eU5hbWUpOwotCX0KLQotCXB1YmxpYyBCb29sZWFuIGdldERlZmF1bHRTaGFyZWRDYWNoZSgpIHsKLQkJcmV0dXJuIHRoaXMuY2FjaGluZy5nZXREZWZhdWx0U2hhcmVkQ2FjaGUoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBzZXRDYWNoZVNpemUoSW50ZWdlciBjYWNoZVNpemUpIHsKLQkJSW50ZWdlciBvbGRDYWNoZVNpemUgPSB0aGlzLmdldENhY2hlU2l6ZSgpOwotCQlpZiAodGhpcy5hdHRyaWJ1dGVWYWx1ZUhhc0NoYW5nZWQob2xkQ2FjaGVTaXplLCBjYWNoZVNpemUpKSB7Ci0JCQl0aGlzLmNhY2hpbmcuc2V0Q2FjaGVTaXplKGNhY2hlU2l6ZSwgdGhpcy5lbnRpdHlOYW1lKTsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChDQUNIRV9TSVpFX1BST1BFUlRZLCBvbGRDYWNoZVNpemUsIGNhY2hlU2l6ZSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCBzZXRDYWNoZVR5cGUoQ2FjaGVUeXBlIGNhY2hlVHlwZSkgewotCQlDYWNoZVR5cGUgb2xkQ2FjaGVUeXBlID0gdGhpcy5nZXRDYWNoZVR5cGUoKTsKLQkJaWYgKHRoaXMuYXR0cmlidXRlVmFsdWVIYXNDaGFuZ2VkKG9sZENhY2hlVHlwZSwgY2FjaGVUeXBlKSkgewotCQkJdGhpcy5jYWNoaW5nLnNldENhY2hlVHlwZShjYWNoZVR5cGUsIHRoaXMuZW50aXR5TmFtZSk7Ci0JCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoQ0FDSEVfVFlQRV9QUk9QRVJUWSwgb2xkQ2FjaGVUeXBlLCBjYWNoZVR5cGUpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0U2hhcmVkQ2FjaGUoQm9vbGVhbiBzaGFyZWRDYWNoZSkgewotCQlCb29sZWFuIG9sZFNoYXJlZENhY2hlID0gdGhpcy5nZXRTaGFyZWRDYWNoZSgpOwotCQlpZiAodGhpcy5hdHRyaWJ1dGVWYWx1ZUhhc0NoYW5nZWQob2xkU2hhcmVkQ2FjaGUsIHNoYXJlZENhY2hlKSkgewotCQkJdGhpcy5jYWNoaW5nLnNldFNoYXJlZENhY2hlKHNoYXJlZENhY2hlLCB0aGlzLmVudGl0eU5hbWUpOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKFNIQVJFRF9DQUNIRV9QUk9QRVJUWSwgb2xkU2hhcmVkQ2FjaGUsIHNoYXJlZENhY2hlKTsKLQkJfQotCX0KLQkKLQkvLyAqKioqKioqKioqIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgKioqKioqKioqKgotCQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPENhY2hlVHlwZT4gYnVpbGRDYWNoZVR5cGVBQShQcm9wZXJ0eVZhbHVlTW9kZWw8Q2FjaGluZz4gc3ViamVjdEhvbGRlcikgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDYWNoaW5nLCBDYWNoZVR5cGU+KAotCQkJCQkJCQlzdWJqZWN0SG9sZGVyLCBDQUNIRV9UWVBFX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDYWNoZVR5cGUgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRDYWNoZVR5cGUoRW50aXR5Q2FjaGVQcm9wZXJ0aWVzLnRoaXMuZW50aXR5TmFtZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZENhY2hlVHlwZUNoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJRW50aXR5Q2FjaGVQcm9wZXJ0aWVzLnRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChDQUNIRV9UWVBFX1BST1BFUlRZLCBlLmdldE9sZFZhbHVlKCksIGUuZ2V0TmV3VmFsdWUoKSk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXI+IGJ1aWxkQ2FjaGVTaXplQUEoUHJvcGVydHlWYWx1ZU1vZGVsPENhY2hpbmc+IHN1YmplY3RIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q2FjaGluZywgSW50ZWdlcj4oCi0JCQkJCQkJCXN1YmplY3RIb2xkZXIsIENBQ0hFX1NJWkVfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEludGVnZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRDYWNoZVNpemUoRW50aXR5Q2FjaGVQcm9wZXJ0aWVzLnRoaXMuZW50aXR5TmFtZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZENhY2hlU2l6ZUNoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJRW50aXR5Q2FjaGVQcm9wZXJ0aWVzLnRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChDQUNIRV9TSVpFX1BST1BFUlRZLCBlLmdldE9sZFZhbHVlKCksIGUuZ2V0TmV3VmFsdWUoKSk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkU2hhcmVkQ2FjaGVBQShQcm9wZXJ0eVZhbHVlTW9kZWw8Q2FjaGluZz4gc3ViamVjdEhvbGRlcikgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDYWNoaW5nLCBCb29sZWFuPigKLQkJCQkJCQkJc3ViamVjdEhvbGRlciwgU0hBUkVEX0NBQ0hFX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0U2hhcmVkQ2FjaGUoRW50aXR5Q2FjaGVQcm9wZXJ0aWVzLnRoaXMuZW50aXR5TmFtZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZFNoYXJlZENhY2hlQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJCQlFbnRpdHlDYWNoZVByb3BlcnRpZXMudGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKFNIQVJFRF9DQUNIRV9QUk9QRVJUWSwgZS5nZXRPbGRWYWx1ZSgpLCBlLmdldE5ld1ZhbHVlKCkpOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHRvU3RyaW5nKFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJc2IuYXBwZW5kKCJuYW1lOiAiKTsKLQkJc2IuYXBwZW5kKHRoaXMuZW50aXR5TmFtZSk7Ci0JCXNiLmFwcGVuZCgiLCB0eXBlOiAiKTsKLQkJc2IuYXBwZW5kKHRoaXMuZ2V0Q2FjaGVUeXBlKCkpOwotCQlzYi5hcHBlbmQoIiwgc2l6ZTogIik7Ci0JCXNiLmFwcGVuZCh0aGlzLmdldENhY2hlU2l6ZSgpKTsKLQkJc2IuYXBwZW5kKCIsIGlzU2hhcmVkOiAiKTsKLQkJc2IuYXBwZW5kKHRoaXMuZ2V0U2hhcmVkQ2FjaGUoKSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9FbnRpdHlDYWNoaW5nUHJvcGVydHlDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2NhY2hpbmcvRW50aXR5Q2FjaGluZ1Byb3BlcnR5Q29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGYyMGVjZmMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9FbnRpdHlDYWNoaW5nUHJvcGVydHlDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDUyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY2FjaGluZzsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY2FjaGluZy5DYWNoaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLlBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBAdmVyc2lvbiAyLjAKLSAqIEBzaW5jZSAyLjAKLSAqLwotcHVibGljIGNsYXNzIEVudGl0eUNhY2hpbmdQcm9wZXJ0eUNvbXBvc2l0ZSBleHRlbmRzIFBhbmU8RW50aXR5Q2FjaGVQcm9wZXJ0aWVzPiB7Ci0KLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkVudGl0eUNhY2hpbmdQcm9wZXJ0eUNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBzdWJqZWN0SG9sZGVyIFRoZSBob2xkZXIgb2YgdGhpcyBwYW5lJ3Mgc3ViamVjdAotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgRW50aXR5Q2FjaGluZ1Byb3BlcnR5Q29tcG9zaXRlKFBhbmU8Q2FjaGluZz4gcGFyZW50Q29tcG9zaXRlLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUHJvcGVydHlWYWx1ZU1vZGVsPEVudGl0eUNhY2hlUHJvcGVydGllcz4gc3ViamVjdEhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRDb21wb3NpdGUsIHN1YmplY3RIb2xkZXIsIHBhcmVudCk7Ci0JfQotCi0JLyoKLQkgKiAobm9uLUphdmFkb2MpCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJLy8gQ2FjaGUgVHlwZQotCQluZXcgQ2FjaGVUeXBlQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0KLQkJLy8gQ2FjaGUgU2l6ZQotCQluZXcgQ2FjaGVTaXplQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0KLQkJLy8gU2hhcmUgQ2FjaGUKLQkJbmV3IFNoYXJlZENhY2hlQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9FbnRpdHlMaXN0Q29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jYWNoaW5nL0VudGl0eUxpc3RDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWUxNmJjZi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jYWNoaW5nL0VudGl0eUxpc3RDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDIyOCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSoKLSogQ29udHJpYnV0b3JzOgotKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY2FjaGluZzsKLQotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVByb2plY3Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSUphdmFFbGVtZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklKYXZhUHJvamVjdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JUGFja2FnZUZyYWdtZW50Um9vdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JVHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5KYXZhQ29yZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5KYXZhTW9kZWxFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuc2VhcmNoLklKYXZhU2VhcmNoU2NvcGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuc2VhcmNoLlNlYXJjaEVuZ2luZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQudWkuSUphdmFFbGVtZW50U2VhcmNoQ29uc3RhbnRzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC51aS5KYXZhVUk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5JTGFiZWxQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLkxhYmVsUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uud2luZG93LldpbmRvdzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkVudGl0eTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNhY2hpbmcuQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuSnB0RWNsaXBzZUxpbmtVaVBsdWdpbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLlBhbmVFbmFibGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkFkZFJlbW92ZUxpc3RQYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLlBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuTGlzdEFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLk9iamVjdExpc3RTZWxlY3Rpb25Nb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnVpLlBsYXRmb3JtVUk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UudWkuZGlhbG9ncy5TZWxlY3Rpb25EaWFsb2c7Ci1pbXBvcnQgb3JnLmVjbGlwc2UudWkucHJvZ3Jlc3MuSVByb2dyZXNzU2VydmljZTsKLQotLyoqCi0gKiAgRW50aXR5TGlzdENvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgRW50aXR5TGlzdENvbXBvc2l0ZSBleHRlbmRzIFBhbmU8Q2FjaGluZz4KLXsKLQlwdWJsaWMgRW50aXR5TGlzdENvbXBvc2l0ZShQYW5lPENhY2hpbmc+IHBhcmVudENvbXBvc2l0ZSwgQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudENvbXBvc2l0ZSwgcGFyZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQljb250YWluZXIgPSB0aGlzLmFkZFRpdGxlZEdyb3VwKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkNhY2hpbmdFbnRpdHlMaXN0Q29tcG9zaXRlX2dyb3VwVGl0bGUKLQkJKTsKLQotCQlXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxFbnRpdHlDYWNoZVByb3BlcnRpZXM+IGVudGl0eUhvbGRlciA9IHRoaXMuYnVpbGRFbnRpdHlIb2xkZXIoKTsKLQotCQkvLyBFbnRpdGllcyBhZGQvcmVtb3ZlIGxpc3QgcGFuZQotCQluZXcgQWRkUmVtb3ZlTGlzdFBhbmU8Q2FjaGluZz4oCi0JCQl0aGlzLAotCQkJY29udGFpbmVyLAotCQkJdGhpcy5idWlsZEVudGl0aWVzQWRhcHRlcigpLAotCQkJdGhpcy5idWlsZEVudGl0eUNhY2hpbmdMaXN0SG9sZGVyKCksCi0JCQllbnRpdHlIb2xkZXIsCi0JCQl0aGlzLmJ1aWxkRW50aXR5TGFiZWxQcm92aWRlcigpLAotCQkJbnVsbAkJCS8vCQlFY2xpcHNlTGlua0hlbHBDb250ZXh0SWRzLkNBQ0hJTkdfRU5USVRJRVMKLQkJKTsKLQotCQkvLyBFbnRpdHkgQ2FjaGluZyBwcm9wZXJ0eSBwYW5lCi0JCUVudGl0eUNhY2hpbmdQcm9wZXJ0eUNvbXBvc2l0ZSBwYW5lID0gbmV3IEVudGl0eUNhY2hpbmdQcm9wZXJ0eUNvbXBvc2l0ZSgKLQkJCXRoaXMsCi0JCQllbnRpdHlIb2xkZXIsCi0JCQljb250YWluZXIKLQkJKTsKLQkJdGhpcy5pbnN0YWxsUGFuZUVuYWJsZXIoZW50aXR5SG9sZGVyLCBwYW5lKTsKLQl9Ci0JCi0JcHJpdmF0ZSBBZGRSZW1vdmVMaXN0UGFuZS5BZGFwdGVyIGJ1aWxkRW50aXRpZXNBZGFwdGVyKCkgewotCQlyZXR1cm4gbmV3IEFkZFJlbW92ZUxpc3RQYW5lLkFic3RyYWN0QWRhcHRlcigpIHsKLQkJCXB1YmxpYyB2b2lkIGFkZE5ld0l0ZW0oT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsIGxpc3RTZWxlY3Rpb25Nb2RlbCkgewotCQkJCWFkZEVudGl0aWVzKGxpc3RTZWxlY3Rpb25Nb2RlbCk7Ci0JCQl9Ci0KLQkJCXB1YmxpYyB2b2lkIHJlbW92ZVNlbGVjdGVkSXRlbXMoT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsIGxpc3RTZWxlY3Rpb25Nb2RlbCkgewotCQkJCUNhY2hpbmcgY2FjaGluZyA9IGdldFN1YmplY3QoKTsKLQkJCQlmb3IgKE9iamVjdCBpdGVtIDogbGlzdFNlbGVjdGlvbk1vZGVsLnNlbGVjdGVkVmFsdWVzKCkpIHsKLQkJCQkJRW50aXR5Q2FjaGVQcm9wZXJ0aWVzIGVudGl0eUNhY2hpbmcgPSAoRW50aXR5Q2FjaGVQcm9wZXJ0aWVzKSBpdGVtOwotCQkJCQljYWNoaW5nLnJlbW92ZUVudGl0eShlbnRpdHlDYWNoaW5nLmdldEVudGl0eU5hbWUoKSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQkKLQlwcml2YXRlIHZvaWQgYWRkRW50aXRpZXMoT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsIGxpc3RTZWxlY3Rpb25Nb2RlbCkgewotCi0JCUlUeXBlIHR5cGUgPSB0aGlzLmNob29zZUVudGl0eSgpOwotCi0JCWlmICh0eXBlICE9IG51bGwpIHsKLQkJCVN0cmluZyBlbnRpdHlOYW1lID0gdGhpcy5nZXRFbnRpdHlOYW1lKHR5cGUuZ2V0RnVsbHlRdWFsaWZpZWROYW1lKCkpOwotCQkJaWYgKGVudGl0eU5hbWUgPT0gbnVsbCkgewotCQkJCWVudGl0eU5hbWUgPSB0eXBlLmdldEVsZW1lbnROYW1lKCk7Ci0JCQl9Ci0JCQkKLQkJCWlmKCAhIHRoaXMuZ2V0U3ViamVjdCgpLmVudGl0eUV4aXN0cyhlbnRpdHlOYW1lKSkgewotCQkJCVN0cmluZyBlbnRpdHkgPSB0aGlzLmdldFN1YmplY3QoKS5hZGRFbnRpdHkoZW50aXR5TmFtZSk7Ci0JCi0JCQkJbGlzdFNlbGVjdGlvbk1vZGVsLnNldFNlbGVjdGVkVmFsdWUoZW50aXR5KTsKLQkJCX0KLQkJfQotCX0KLQkKLQlwcml2YXRlIFN0cmluZyBnZXRFbnRpdHlOYW1lKFN0cmluZyBmdWxseVF1YWxpZmllZFR5cGVOYW1lKSB7Ci0KLQkJRW50aXR5IGVudGl0eSA9IGdldFN1YmplY3QoKS5nZXRQZXJzaXN0ZW5jZVVuaXQoKS5nZXRFbnRpdHkoZnVsbHlRdWFsaWZpZWRUeXBlTmFtZSk7Ci0JCXJldHVybiBlbnRpdHkgIT0gbnVsbCA/IGVudGl0eS5nZXROYW1lKCkgOiBudWxsOwotCX0KLQkKLQlwcml2YXRlIElUeXBlIGNob29zZUVudGl0eSgpIHsKLQotCQlJUGFja2FnZUZyYWdtZW50Um9vdCByb290ID0gZ2V0UGFja2FnZUZyYWdtZW50Um9vdCgpOwotCQlpZiAocm9vdCA9PSBudWxsKSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQlJSmF2YUVsZW1lbnRbXSBlbGVtZW50cyA9IG5ldyBJSmF2YUVsZW1lbnRbXSB7IHJvb3QuZ2V0SmF2YVByb2plY3QoKSB9OwotCQlJSmF2YVNlYXJjaFNjb3BlIHNjb3BlID0gU2VhcmNoRW5naW5lLmNyZWF0ZUphdmFTZWFyY2hTY29wZShlbGVtZW50cyk7Ci0JCUlQcm9ncmVzc1NlcnZpY2Ugc2VydmljZSA9IFBsYXRmb3JtVUkuZ2V0V29ya2JlbmNoKCkuZ2V0UHJvZ3Jlc3NTZXJ2aWNlKCk7Ci0JCVNlbGVjdGlvbkRpYWxvZyB0eXBlU2VsZWN0aW9uRGlhbG9nOwotCi0JCXRyeSB7Ci0JCQl0eXBlU2VsZWN0aW9uRGlhbG9nID0gSmF2YVVJLmNyZWF0ZVR5cGVEaWFsb2coCi0JCQkJZ2V0U2hlbGwoKSwKLQkJCQlzZXJ2aWNlLAotCQkJCXNjb3BlLAotCQkJCUlKYXZhRWxlbWVudFNlYXJjaENvbnN0YW50cy5DT05TSURFUl9DTEFTU0VTLAotCQkJCWZhbHNlLAotCQkJCSIiCi0JCQkpOwotCQl9Ci0JCWNhdGNoIChKYXZhTW9kZWxFeGNlcHRpb24gZSkgewotCQkJSnB0RWNsaXBzZUxpbmtVaVBsdWdpbi5sb2coZSk7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQl0eXBlU2VsZWN0aW9uRGlhbG9nLnNldFRpdGxlKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5DYWNoaW5nRW50aXR5TGlzdENvbXBvc2l0ZV9kaWFsb2dUaXRsZSk7Ci0JCXR5cGVTZWxlY3Rpb25EaWFsb2cuc2V0TWVzc2FnZShFY2xpcHNlTGlua1VpTWVzc2FnZXMuQ2FjaGluZ0VudGl0eUxpc3RDb21wb3NpdGVfZGlhbG9nTWVzc2FnZSk7Ci0KLQkJaWYgKHR5cGVTZWxlY3Rpb25EaWFsb2cub3BlbigpID09IFdpbmRvdy5PSykgewotCQkJcmV0dXJuIChJVHlwZSkgdHlwZVNlbGVjdGlvbkRpYWxvZy5nZXRSZXN1bHQoKVswXTsKLQkJfQotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQlwcml2YXRlIElQYWNrYWdlRnJhZ21lbnRSb290IGdldFBhY2thZ2VGcmFnbWVudFJvb3QoKSB7Ci0JCUlQcm9qZWN0IHByb2plY3QgPSBnZXRTdWJqZWN0KCkuZ2V0SnBhUHJvamVjdCgpLmdldFByb2plY3QoKTsKLQkJSUphdmFQcm9qZWN0IHJvb3QgPSBKYXZhQ29yZS5jcmVhdGUocHJvamVjdCk7Ci0KLQkJdHJ5IHsKLQkJCXJldHVybiByb290LmdldEFsbFBhY2thZ2VGcmFnbWVudFJvb3RzKClbMF07Ci0JCX0KLQkJY2F0Y2ggKEphdmFNb2RlbEV4Y2VwdGlvbiBlKSB7Ci0JCQlKcHRFY2xpcHNlTGlua1VpUGx1Z2luLmxvZyhlKTsKLQkJfQotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQlwcml2YXRlIElMYWJlbFByb3ZpZGVyIGJ1aWxkRW50aXR5TGFiZWxQcm92aWRlcigpIHsKLQkJcmV0dXJuIG5ldyBMYWJlbFByb3ZpZGVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIGdldFRleHQoT2JqZWN0IGVsZW1lbnQpIHsKLQkJCQlFbnRpdHlDYWNoZVByb3BlcnRpZXMgZW50aXR5Q2FjaGluZyA9IChFbnRpdHlDYWNoZVByb3BlcnRpZXMpIGVsZW1lbnQ7Ci0JCQkJcmV0dXJuIGVudGl0eUNhY2hpbmcuZ2V0RW50aXR5TmFtZSgpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8RW50aXR5Q2FjaGVQcm9wZXJ0aWVzPiBidWlsZEVudGl0eUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8RW50aXR5Q2FjaGVQcm9wZXJ0aWVzPigpOwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8RW50aXR5Q2FjaGVQcm9wZXJ0aWVzPiBidWlsZEVudGl0eUNhY2hpbmdMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyPFN0cmluZywgRW50aXR5Q2FjaGVQcm9wZXJ0aWVzPihidWlsZEVudGl0aWVzTGlzdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBFbnRpdHlDYWNoZVByb3BlcnRpZXMgdHJhbnNmb3JtSXRlbShTdHJpbmcgaXRlbSkgewotCQkJCXJldHVybiBuZXcgRW50aXR5Q2FjaGVQcm9wZXJ0aWVzKGdldFN1YmplY3QoKSwgaXRlbSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRW50aXRpZXNMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IExpc3RBc3BlY3RBZGFwdGVyPENhY2hpbmcsIFN0cmluZz4oCi0JCQkJCXRoaXMuZ2V0U3ViamVjdEhvbGRlcigpLCBDYWNoaW5nLkVOVElUSUVTX0xJU1RfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIExpc3RJdGVyYXRvcjxTdHJpbmc+IGxpc3RJdGVyYXRvcl8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5lbnRpdGllcygpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgaW50IHNpemVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZW50aXRpZXNTaXplKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGluc3RhbGxQYW5lRW5hYmxlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxFbnRpdHlDYWNoZVByb3BlcnRpZXM+IGVudGl0eUhvbGRlciwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEVudGl0eUNhY2hpbmdQcm9wZXJ0eUNvbXBvc2l0ZSBwYW5lKSB7Ci0KLQkJbmV3IFBhbmVFbmFibGVyKAotCQkJdGhpcy5idWlsZFBhbmVFbmFibGVySG9sZGVyKGVudGl0eUhvbGRlciksCi0JCQlwYW5lCi0JCSk7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRQYW5lRW5hYmxlckhvbGRlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxFbnRpdHlDYWNoZVByb3BlcnRpZXM+IGVudGl0eUhvbGRlcikgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEVudGl0eUNhY2hlUHJvcGVydGllcywgQm9vbGVhbj4oZW50aXR5SG9sZGVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIHRyYW5zZm9ybV8oRW50aXR5Q2FjaGVQcm9wZXJ0aWVzIHZhbHVlKSB7Ci0JCQkJcmV0dXJuIHZhbHVlLmVudGl0eU5hbWVJc1ZhbGlkKCk7Ci0JCQl9Ci0JCX07Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9GbHVzaENsZWFyQ2FjaGVDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2NhY2hpbmcvRmx1c2hDbGVhckNhY2hlQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGMyYTFkZGUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9GbHVzaENsZWFyQ2FjaGVDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDkwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jYWNoaW5nOwotCi1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNhY2hpbmcuQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNhY2hpbmcuRmx1c2hDbGVhckNhY2hlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRW51bUZvcm1Db21ib1ZpZXdlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogRmx1c2hDbGVhckNhY2hlQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBGbHVzaENsZWFyQ2FjaGVDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxDYWNoaW5nPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+Rmx1c2hDbGVhckNhY2hlQ29tcG9zaXRlPC9jb2RlPi4KLQkgKiAKLQkgKiBAcGFyYW0gcGFyZW50Q29udHJvbGxlcgotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50Ci0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBGbHVzaENsZWFyQ2FjaGVDb21wb3NpdGUoCi0JCQkJRm9ybVBhbmU8PyBleHRlbmRzIENhY2hpbmc+IHBhcmVudENvbXBvc2l0ZSwgCi0JCQkJQ29tcG9zaXRlIHBhcmVudCkgewotCQkKLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgRW51bUZvcm1Db21ib1ZpZXdlcjxDYWNoaW5nLCBGbHVzaENsZWFyQ2FjaGU+IGFkZEZsdXNoQ2xlYXJDYWNoZUNvbWJvKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJcmV0dXJuIG5ldyBFbnVtRm9ybUNvbWJvVmlld2VyPENhY2hpbmcsIEZsdXNoQ2xlYXJDYWNoZT4odGhpcywgY29udGFpbmVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIGFkZFByb3BlcnR5TmFtZXMoQ29sbGVjdGlvbjxTdHJpbmc+IHByb3BlcnR5TmFtZXMpIHsKLQkJCQlzdXBlci5hZGRQcm9wZXJ0eU5hbWVzKHByb3BlcnR5TmFtZXMpOwotCQkJCXByb3BlcnR5TmFtZXMuYWRkKENhY2hpbmcuRkxVU0hfQ0xFQVJfQ0FDSEVfUFJPUEVSVFkpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBGbHVzaENsZWFyQ2FjaGVbXSBnZXRDaG9pY2VzKCkgewotCQkJCXJldHVybiBGbHVzaENsZWFyQ2FjaGUudmFsdWVzKCk7Ci0JCQl9Ci0JCQkKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGJvb2xlYW4gc29ydENob2ljZXMoKSB7Ci0JCQkJcmV0dXJuIGZhbHNlOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBGbHVzaENsZWFyQ2FjaGUgZ2V0RGVmYXVsdFZhbHVlKCkgewotCQkJCXJldHVybiB0aGlzLmdldFN1YmplY3QoKS5nZXREZWZhdWx0Rmx1c2hDbGVhckNhY2hlKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBkaXNwbGF5U3RyaW5nKEZsdXNoQ2xlYXJDYWNoZSB2YWx1ZSkgewotCQkJCXJldHVybiB0aGlzLmJ1aWxkRGlzcGxheVN0cmluZyhFY2xpcHNlTGlua1VpTWVzc2FnZXMuY2xhc3MsIEZsdXNoQ2xlYXJDYWNoZUNvbXBvc2l0ZS50aGlzLCB2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEZsdXNoQ2xlYXJDYWNoZSBnZXRWYWx1ZSgpIHsKLQkJCQlyZXR1cm4gdGhpcy5nZXRTdWJqZWN0KCkuZ2V0Rmx1c2hDbGVhckNhY2hlKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWUoRmx1c2hDbGVhckNhY2hlIHZhbHVlKSB7Ci0JCQkJdGhpcy5nZXRTdWJqZWN0KCkuc2V0Rmx1c2hDbGVhckNhY2hlKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJdGhpcy5hZGRMYWJlbGVkQ29tcG9zaXRlKAotCQkJCWNvbnRhaW5lciwKLQkJCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiX0ZsdXNoQ2xlYXJDYWNoZUxhYmVsLAotCQkJCXRoaXMuYWRkRmx1c2hDbGVhckNhY2hlQ29tYm8oY29udGFpbmVyKSwKLQkJCQludWxsIC8vIFRPRE8gSUpwYUhlbHBDb250ZXh0SWRzLgotCQkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2NhY2hpbmcvUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jYWNoaW5nL1BlcnNpc3RlbmNlWG1sQ2FjaGluZ1RhYi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhY2FlMTZiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2NhY2hpbmcvUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw4NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSogCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmNhY2hpbmc7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNhY2hpbmcuQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYVBhZ2VDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5TV1Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLkltYWdlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuR3JpZERhdGE7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkTGF5b3V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiAgUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiCi0gKi8KLXB1YmxpYyBjbGFzcyBQZXJzaXN0ZW5jZVhtbENhY2hpbmdUYWIgCi0JCQkJCQkJCWV4dGVuZHMgRm9ybVBhbmU8Q2FjaGluZz4KLQkJCQkJCQkJaW1wbGVtZW50cyBKcGFQYWdlQ29tcG9zaXRlCi17Ci0JcHVibGljIFBlcnNpc3RlbmNlWG1sQ2FjaGluZ1RhYigKLQkJCVByb3BlcnR5VmFsdWVNb2RlbDxDYWNoaW5nPiBzdWJqZWN0SG9sZGVyLAotCQkJQ29tcG9zaXRlIHBhcmVudCwKLSAgICAgICAgICAgIFdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQkKLQkJbmV3IEVjbGlwc2VMaW5rQ2FjaGluZ0NvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCX0KLQotCS8vICoqKioqKioqKiogSnBhUGFnZUNvbXBvc2l0ZSBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0JCi0JcHVibGljIFN0cmluZyBnZXRIZWxwSUQoKSB7Ci0JCXJldHVybiBudWxsOwotCX0KLQotCXB1YmxpYyBJbWFnZSBnZXRQYWdlSW1hZ2UoKSB7Ci0JCXJldHVybiBudWxsOwotCX0KLQlwdWJsaWMgU3RyaW5nIGdldFBhZ2VUZXh0KCkgewotCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ2FjaGluZ1RhYl90aXRsZTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIExheW91dCAqKioqKioqKioqCi0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIENvbXBvc2l0ZSBhZGRDb250YWluZXIoQ29tcG9zaXRlIHBhcmVudCkgewotCQlHcmlkTGF5b3V0IGxheW91dCA9IG5ldyBHcmlkTGF5b3V0KDEsIHRydWUpOwotCQlsYXlvdXQubWFyZ2luSGVpZ2h0ID0gMDsKLQkJbGF5b3V0Lm1hcmdpbldpZHRoID0gMDsKLQkJbGF5b3V0Lm1hcmdpblRvcCA9IDA7Ci0JCWxheW91dC5tYXJnaW5MZWZ0ID0gMDsKLQkJbGF5b3V0Lm1hcmdpbkJvdHRvbSA9IDA7Ci0JCWxheW91dC5tYXJnaW5SaWdodCA9IDA7Ci0JCWxheW91dC52ZXJ0aWNhbFNwYWNpbmcgPSAxNTsKLQkJCi0JCUNvbXBvc2l0ZSBjb250YWluZXIgPSBhZGRQYW5lKHBhcmVudCwgbGF5b3V0KTsKLQkJdXBkYXRlR3JpZERhdGEoY29udGFpbmVyKTsKLQkJCi0JCXJldHVybiBjb250YWluZXI7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHVwZGF0ZUdyaWREYXRhKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJR3JpZERhdGEgZ3JpZERhdGEgPSBuZXcgR3JpZERhdGEoKTsKLQkJZ3JpZERhdGEuZ3JhYkV4Y2Vzc0hvcml6b250YWxTcGFjZSA9IHRydWU7Ci0JCWdyaWREYXRhLmdyYWJFeGNlc3NWZXJ0aWNhbFNwYWNlID0gdHJ1ZTsKLQkJZ3JpZERhdGEuaG9yaXpvbnRhbEFsaWdubWVudCA9IFNXVC5GSUxMOwotCQlncmlkRGF0YS52ZXJ0aWNhbEFsaWdubWVudCA9IFNXVC5GSUxMOwotCQljb250YWluZXIuc2V0TGF5b3V0RGF0YShncmlkRGF0YSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jYWNoaW5nL1NoYXJlZENhY2hlQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jYWNoaW5nL1NoYXJlZENhY2hlQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDU4MGY1NjMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY2FjaGluZy9TaGFyZWRDYWNoZUNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTU0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0qIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0qIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotKgotKiBDb250cmlidXRvcnM6Ci0qICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jYWNoaW5nOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNhY2hpbmcuQ2FjaGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLlBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuVHJpU3RhdGVDaGVja0JveDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Db21wb3NpdGVMaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5MaXN0UHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqICBTaGFyZWRDYWNoZUNvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgU2hhcmVkQ2FjaGVDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPEVudGl0eUNhY2hlUHJvcGVydGllcz4KLXsKLQlwcml2YXRlIFRyaVN0YXRlQ2hlY2tCb3ggc2hhcmVkQ2FjaGVDaGVja0JveDsKLQotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+U2hhcmVDYWNoZUNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50Q29udHJvbGxlciBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgU2hhcmVkQ2FjaGVDb21wb3NpdGUoUGFuZTxFbnRpdHlDYWNoZVByb3BlcnRpZXM+IHBhcmVudENvbXBvc2l0ZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPENhY2hpbmc+IGJ1aWxkQ2FjaGluZ0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxFbnRpdHlDYWNoZVByb3BlcnRpZXMsIENhY2hpbmc+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ2FjaGluZyB0cmFuc2Zvcm1fKEVudGl0eUNhY2hlUHJvcGVydGllcyB2YWx1ZSkgewotCQkJCXJldHVybiB2YWx1ZS5nZXRDYWNoaW5nKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGREZWZhdWx0QW5kTm9uRGVmYXVsdFNoYXJlZENhY2hlSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IExpc3RQcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyPEJvb2xlYW4+KAotCQkJYnVpbGREZWZhdWx0QW5kTm9uRGVmYXVsdFNoYXJlZENhY2hlTGlzdEhvbGRlcigpCi0JCSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlKCkgewotCQkJCS8vIElmIHRoZSBudW1iZXIgb2YgTGlzdFZhbHVlTW9kZWwgZXF1YWxzIDEsIHRoYXQgbWVhbnMgdGhlIHNoYXJlZAotCQkJCS8vIENhY2hlIHByb3BlcnRpZXMgaXMgbm90IHNldCAocGFydGlhbGx5IHNlbGVjdGVkKSwgd2hpY2ggbWVhbnMgd2UKLQkJCQkvLyB3YW50IHRvIHNlZSB0aGUgZGVmYXVsdCB2YWx1ZSBhcHBlbmRlZCB0byB0aGUgdGV4dAotCQkJCWlmIChsaXN0SG9sZGVyLnNpemUoKSA9PSAxKSB7Ci0JCQkJCXJldHVybiAoQm9vbGVhbikgbGlzdEhvbGRlci5saXN0SXRlcmF0b3IoKS5uZXh0KCk7Ci0JCQkJfQotCQkJCXJldHVybiBudWxsOwotCQkJfQotCQl9OwotCX07Ci0KLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkRGVmYXVsdEFuZE5vbkRlZmF1bHRTaGFyZWRDYWNoZUxpc3RIb2xkZXIoKSB7Ci0JCUFycmF5TGlzdDxMaXN0VmFsdWVNb2RlbDxCb29sZWFuPj4gaG9sZGVycyA9IG5ldyBBcnJheUxpc3Q8TGlzdFZhbHVlTW9kZWw8Qm9vbGVhbj4+KDIpOwotCQlob2xkZXJzLmFkZChidWlsZFNoYXJlZENhY2hlTGlzdEhvbGRlcigpKTsKLQkJaG9sZGVycy5hZGQoYnVpbGREZWZhdWx0U2hhcmVkQ2FjaGVMaXN0SG9sZGVyKCkpOwotCi0JCXJldHVybiBuZXcgQ29tcG9zaXRlTGlzdFZhbHVlTW9kZWw8TGlzdFZhbHVlTW9kZWw8Qm9vbGVhbj4sIEJvb2xlYW4+KAotCQkJaG9sZGVycwotCQkpOwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkRGVmYXVsdFNoYXJlZENhY2hlSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDYWNoaW5nLCBCb29sZWFuPihidWlsZENhY2hpbmdIb2xkZXIoKSwgQ2FjaGluZy5TSEFSRURfQ0FDSEVfREVGQVVMVF9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlCb29sZWFuIHZhbHVlID0gc3ViamVjdC5nZXRTaGFyZWRDYWNoZURlZmF1bHQoKTsKLQkJCQlpZiAodmFsdWUgPT0gbnVsbCkgewotCQkJCQl2YWx1ZSA9IHN1YmplY3QuZ2V0RGVmYXVsdFNoYXJlZENhY2hlRGVmYXVsdCgpOwotCQkJCX0KLQkJCQlyZXR1cm4gdmFsdWU7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZERlZmF1bHRTaGFyZWRDYWNoZUxpc3RIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8Qm9vbGVhbj4oCi0JCQlidWlsZERlZmF1bHRTaGFyZWRDYWNoZUhvbGRlcigpCi0JCSk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZFNoYXJlZENhY2hlSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxFbnRpdHlDYWNoZVByb3BlcnRpZXMsIEJvb2xlYW4+KAotCQkJCQlnZXRTdWJqZWN0SG9sZGVyKCksIEVudGl0eUNhY2hlUHJvcGVydGllcy5TSEFSRURfQ0FDSEVfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRTaGFyZWRDYWNoZSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldFNoYXJlZENhY2hlKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkU2hhcmVkQ2FjaGVMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyPEJvb2xlYW4+KAotCQkJYnVpbGRTaGFyZWRDYWNoZUhvbGRlcigpCi0JCSk7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFNoYXJlZENhY2hlU3RyaW5nSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4sIFN0cmluZz4oYnVpbGREZWZhdWx0QW5kTm9uRGVmYXVsdFNoYXJlZENhY2hlSG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oQm9vbGVhbiB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZSAhPSBudWxsKSB7Ci0JCQkJCVN0cmluZyBkZWZhdWx0U3RyaW5nVmFsdWUgPSB2YWx1ZSA/IEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5Cb29sZWFuX1RydWUgOiBFY2xpcHNlTGlua1VpTWVzc2FnZXMuQm9vbGVhbl9GYWxzZTsKLQkJCQkJcmV0dXJuIE5MUy5iaW5kKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbENhY2hpbmdUYWJfZGVmYXVsdFNoYXJlZENhY2hlTGFiZWwsIGRlZmF1bHRTdHJpbmdWYWx1ZSk7Ci0JCQkJfQotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiX3NoYXJlZENhY2hlTGFiZWw7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgZW5hYmxlV2lkZ2V0cyhib29sZWFuIGVuYWJsZWQpIHsKLQkJc3VwZXIuZW5hYmxlV2lkZ2V0cyhlbmFibGVkKTsKLQkJdGhpcy5zaGFyZWRDYWNoZUNoZWNrQm94LnNldEVuYWJsZWQoZW5hYmxlZCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJdGhpcy5zaGFyZWRDYWNoZUNoZWNrQm94ID0gdGhpcy5hZGRUcmlTdGF0ZUNoZWNrQm94V2l0aERlZmF1bHQoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDYWNoaW5nVGFiX3NoYXJlZENhY2hlTGFiZWwsCi0JCQl0aGlzLmJ1aWxkU2hhcmVkQ2FjaGVIb2xkZXIoKSwKLQkJCXRoaXMuYnVpbGRTaGFyZWRDYWNoZVN0cmluZ0hvbGRlcigpLAotCQkJbnVsbAotLy8JCQlFY2xpcHNlTGlua0hlbHBDb250ZXh0SWRzLkNBQ0hJTkdfU0hBUkVEX0NBQ0hFCi0JCSk7Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vQmF0Y2hXcml0aW5nQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0JhdGNoV3JpdGluZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzZTZkNzUxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vQmF0Y2hXcml0aW5nQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw4NSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY29ubmVjdGlvbjsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY29ubmVjdGlvbi5CYXRjaFdyaXRpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5jb25uZWN0aW9uLkNvbm5lY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5FbnVtRm9ybUNvbWJvVmlld2VyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBCYXRjaFdyaXRpbmdDb21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIEJhdGNoV3JpdGluZ0NvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPENvbm5lY3Rpb24+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5CYXRjaFdyaXRpbmdDb21wb3NpdGU8L2NvZGU+LgotCSAqIAotCSAqIEBwYXJhbSBwYXJlbnRDb250cm9sbGVyCi0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIEJhdGNoV3JpdGluZ0NvbXBvc2l0ZSgKLQkJCQkJRm9ybVBhbmU8PyBleHRlbmRzIENvbm5lY3Rpb24+IHBhcmVudENvbXBvc2l0ZSwgCi0JCQkJCUNvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlciggcGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgRW51bUZvcm1Db21ib1ZpZXdlcjxDb25uZWN0aW9uLCBCYXRjaFdyaXRpbmc+IGFkZEJhdGNoV3JpdGluZ0NvbWJvKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJcmV0dXJuIG5ldyBFbnVtRm9ybUNvbWJvVmlld2VyPENvbm5lY3Rpb24sIEJhdGNoV3JpdGluZz4odGhpcywgY29udGFpbmVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIGFkZFByb3BlcnR5TmFtZXMoQ29sbGVjdGlvbjxTdHJpbmc+IHByb3BlcnR5TmFtZXMpIHsKLQkJCQlzdXBlci5hZGRQcm9wZXJ0eU5hbWVzKHByb3BlcnR5TmFtZXMpOwotCQkJCXByb3BlcnR5TmFtZXMuYWRkKENvbm5lY3Rpb24uQkFUQ0hfV1JJVElOR19QUk9QRVJUWSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJhdGNoV3JpdGluZ1tdIGdldENob2ljZXMoKSB7Ci0JCQkJcmV0dXJuIEJhdGNoV3JpdGluZy52YWx1ZXMoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQmF0Y2hXcml0aW5nIGdldERlZmF1bHRWYWx1ZSgpIHsKLQkJCQlyZXR1cm4gZ2V0U3ViamVjdCgpLmdldERlZmF1bHRCYXRjaFdyaXRpbmcoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGRpc3BsYXlTdHJpbmcoQmF0Y2hXcml0aW5nIHZhbHVlKSB7Ci0JCQkJcmV0dXJuIGJ1aWxkRGlzcGxheVN0cmluZyhFY2xpcHNlTGlua1VpTWVzc2FnZXMuY2xhc3MsIEJhdGNoV3JpdGluZ0NvbXBvc2l0ZS50aGlzLCB2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJhdGNoV3JpdGluZyBnZXRWYWx1ZSgpIHsKLQkJCQlyZXR1cm4gZ2V0U3ViamVjdCgpLmdldEJhdGNoV3JpdGluZygpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlKEJhdGNoV3JpdGluZyB2YWx1ZSkgewotCQkJCWdldFN1YmplY3QoKS5zZXRCYXRjaFdyaXRpbmcodmFsdWUpOwotCQkJfQotCQl9OwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KCBDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJdGhpcy5hZGRMYWJlbGVkQ29tcG9zaXRlKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9iYXRjaFdyaXRpbmdMYWJlbCwKLQkJCXRoaXMuYWRkQmF0Y2hXcml0aW5nQ29tYm8oIGNvbnRhaW5lciksCi0JCQludWxsCQkvLyBUT0RPIElKcGFIZWxwQ29udGV4dElkcy4KLQkJKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0NhY2hlU3RhdGVtZW50c1Byb3BlcnRpZXNDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vQ2FjaGVTdGF0ZW1lbnRzUHJvcGVydGllc0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzZGM2M2RlLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vQ2FjaGVTdGF0ZW1lbnRzUHJvcGVydGllc0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjE0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0qIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0qIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotKgotKiBDb250cmlidXRvcnM6Ci0qICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jb25uZWN0aW9uOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5jb25uZWN0aW9uLkNvbm5lY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwudXRpbC5Db250cm9sRW5hYmxlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwudXRpbC5MYWJlbGVkQ29udHJvbFVwZGF0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuTGFiZWxlZExhYmVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLlBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuVHJpU3RhdGVDaGVja0JveDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkRGF0YTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29udHJvbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5MYWJlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5TcGlubmVyOwotCi0vKioKLSAqICBDYWNoZVN0YXRlbWVudHNQcm9wZXJ0aWVzQ29tcG9zaXRlCi0gKi8KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIENhY2hlU3RhdGVtZW50c1Byb3BlcnRpZXNDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPENvbm5lY3Rpb24+Ci17Ci0JcHVibGljIENhY2hlU3RhdGVtZW50c1Byb3BlcnRpZXNDb21wb3NpdGUoUGFuZTxDb25uZWN0aW9uPiBwYXJlbnRDb21wb3NpdGUsIENvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRDb21wb3NpdGUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZENhY2hlU3RhdGVtZW50c0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29ubmVjdGlvbiwgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb25uZWN0aW9uLkNBQ0hFX1NUQVRFTUVOVFNfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3QuZ2V0Q2FjaGVTdGF0ZW1lbnRzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlzdWJqZWN0LnNldENhY2hlU3RhdGVtZW50cyh2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc3ViamVjdENoYW5nZWQoKSB7Ci0JCQkJT2JqZWN0IG9sZFZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCQkJCXN1cGVyLnN1YmplY3RDaGFuZ2VkKCk7Ci0JCQkJT2JqZWN0IG5ld1ZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCi0JCQkJLy8gTWFrZSBzdXJlIHRoZSBkZWZhdWx0IHZhbHVlIGlzIGFwcGVuZGVkIHRvIHRoZSB0ZXh0Ci0JCQkJaWYgKG9sZFZhbHVlID09IG5ld1ZhbHVlICYmIG5ld1ZhbHVlID09IG51bGwpIHsKLQkJCQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKEJvb2xlYW4uVFJVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXI+IGJ1aWxkQ2FjaGVTdGF0ZW1lbnRzU2l6ZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29ubmVjdGlvbiwgSW50ZWdlcj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb25uZWN0aW9uLkNBQ0hFX1NUQVRFTUVOVFNfU0laRV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSW50ZWdlciBidWlsZFZhbHVlXygpIHsKLQkJCQlJbnRlZ2VyIHZhbHVlID0gc3ViamVjdC5nZXRDYWNoZVN0YXRlbWVudHNTaXplKCk7Ci0KLQkJCQlpZiAodmFsdWUgPT0gbnVsbCkgewotCQkJCQl2YWx1ZSA9IC0xOwotCQkJCX0KLQkJCQlyZXR1cm4gdmFsdWU7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEludGVnZXIgdmFsdWUpIHsKLQkJCQlpZiAodmFsdWUgPT0gLTEpIHsKLQkJCQkJdmFsdWUgPSBudWxsOwotCQkJCX0KLQkJCQlzdWJqZWN0LnNldENhY2hlU3RhdGVtZW50c1NpemUodmFsdWUpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXI+IGJ1aWxkRGVmYXVsdENhY2hlU3RhdGVtZW50c1NpemVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENvbm5lY3Rpb24sIEludGVnZXI+KGdldFN1YmplY3RIb2xkZXIoKSwgIiIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEludGVnZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3QuZ2V0RGVmYXVsdENhY2hlU3RhdGVtZW50c1NpemUoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzdWJqZWN0Q2hhbmdlZCgpIHsKLQkJCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0JCQkJc3VwZXIuc3ViamVjdENoYW5nZWQoKTsKLQkJCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0KLQkJCQkvLyBNYWtlIHN1cmUgdGhlIGRlZmF1bHQgdmFsdWUgaXMgYXBwZW5kZWQgdG8gdGhlIHRleHQKLQkJCQlpZiAob2xkVmFsdWUgPT0gbmV3VmFsdWUgJiYgbmV3VmFsdWUgPT0gbnVsbCkgewotCQkJCQl0aGlzLmZpcmVBc3BlY3RDaGFuZ2UoSW50ZWdlci5NSU5fVkFMVUUsIG5ld1ZhbHVlKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMYWJlbCBhZGREZWZhdWx0Q2FjaGVTdGF0ZW1lbnRzU2l6ZUxhYmVsKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlMYWJlbCBsYWJlbCA9IGFkZFVubWFuYWdlZExhYmVsKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkRlZmF1bHRXaXRob3V0VmFsdWUKLQkJKTsKLQotCQluZXcgTGFiZWxlZENvbnRyb2xVcGRhdGVyKAotCQkJbmV3IExhYmVsZWRMYWJlbChsYWJlbCksCi0JCQlidWlsZERlZmF1bHRDYWNoZVN0YXRlbWVudHNTaXplTGFiZWxIb2xkZXIoKQotCQkpOwotCi0JCXJldHVybiBsYWJlbDsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdENhY2hlU3RhdGVtZW50c1NpemVMYWJlbEhvbGRlcigpIHsKLQotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXIsIFN0cmluZz4oYnVpbGREZWZhdWx0Q2FjaGVTdGF0ZW1lbnRzU2l6ZUhvbGRlcigpKSB7Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oSW50ZWdlciB2YWx1ZSkgewotCi0JCQkJaWYgKHZhbHVlICE9IG51bGwpIHsKLQkJCQkJcmV0dXJuIE5MUy5iaW5kKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5EZWZhdWx0V2l0aFZhbHVlLCB2YWx1ZSk7Ci0JCQkJfQotCi0JCQkJcmV0dXJuICIiOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGNhY2hlU3RhdGVtZW50c0hvbGRlciA9IGJ1aWxkQ2FjaGVTdGF0ZW1lbnRzSG9sZGVyKCk7Ci0KLQkJVHJpU3RhdGVDaGVja0JveCBjaGVja0JveCA9IHRoaXMuYWRkVHJpU3RhdGVDaGVja0JveCgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfY2FjaGVTdGF0ZW1lbnRzTGFiZWwsCi0JCQljYWNoZVN0YXRlbWVudHNIb2xkZXIsCi0JCQludWxsCi0JCSk7Ci0KLQkJU3Bpbm5lciBzcGlubmVyID0gdGhpcy5hZGRVbm1hbmFnZWRTcGlubmVyKAotCQkJY29udGFpbmVyLAotCQkJdGhpcy5idWlsZENhY2hlU3RhdGVtZW50c1NpemVIb2xkZXIoKSwKLQkJCS0xLAotCQkJLTEsCi0JCQlJbnRlZ2VyLk1BWF9WQUxVRSwKLQkJCW51bGwKLQkJKTsKLQotCQlMYWJlbCBsYWJlbCA9IHRoaXMuYWRkRGVmYXVsdENhY2hlU3RhdGVtZW50c1NpemVMYWJlbChjb250YWluZXIpOwotCi0JCXRoaXMuYWRkTGFiZWxlZENvbXBvc2l0ZSgKLQkJCWNvbnRhaW5lciwKLQkJCWNoZWNrQm94LmdldENoZWNrQm94KCksCi0JCQkoc3Bpbm5lci5nZXRQYXJlbnQoKSA9PSBjb250YWluZXIpID8gc3Bpbm5lciA6IHNwaW5uZXIuZ2V0UGFyZW50KCksCi0JCQlsYWJlbCwKLQkJCW51bGwKLS8vCQkJRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcy4KLQkJKTsKLQotCQl0aGlzLmluc3RhbGxDb250cm9sRW5hYmxlcihjYWNoZVN0YXRlbWVudHNIb2xkZXIsIGxhYmVsLCBzcGlubmVyKTsKLQkJdGhpcy51cGRhdGVHcmlkRGF0YShjb250YWluZXIsIHNwaW5uZXIpOwotCX0KLQotCXByaXZhdGUgdm9pZCBpbnN0YWxsQ29udHJvbEVuYWJsZXIoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gY2FjaGVTdGF0ZW1lbnRzSG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTGFiZWwgbGFiZWwsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTcGlubmVyIHNwaW5uZXIpIHsKLQotCQluZXcgQ29udHJvbEVuYWJsZXIoY2FjaGVTdGF0ZW1lbnRzSG9sZGVyLCBsYWJlbCwgc3Bpbm5lcik7Ci0JfQotCi0JLyoqCi0JICogQ2hhbmdlcyB0aGUgbGF5b3V0IG9mIHRoZSBnaXZlbiBjb250YWluZXIgYnkgY2hhbmdpbmcgd2hpY2ggd2lkZ2V0IHdpbGwKLQkgKiBncmFiIHRoZSBleGNlc3Mgb2YgaG9yaXpvbnRhbCBzcGFjZS4gQnkgZGVmYXVsdCwgdGhlIGNlbnRlciBjb250cm9sIGdyYWJzCi0JICogdGhlIGV4Y2VzcyBzcGFjZSwgd2UgY2hhbmdlIGl0IHRvIGJlIHRoZSByaWdodCBjb250cm9sLgotCSAqCi0JICogQHBhcmFtIGNvbnRhaW5lciBUaGUgY29udGFpbmVyIGNvbnRhaW5pbmcgdGhlIGNvbnRyb2xzIG5lZWRpbmcgdGhlaXIKLQkgKiA8Y29kZT5HcmlkRGF0YTwvY29kZT4gdG8gYmUgbW9kaWZpZWQgZnJvbSB0aGUgZGVmYXVsdCB2YWx1ZXMKLQkgKiBAcGFyYW0gc3Bpbm5lciBUaGUgc3Bpbm5lciB0aGF0IGdvdCBjcmVhdGVkCi0JICovCi0JcHJpdmF0ZSB2b2lkIHVwZGF0ZUdyaWREYXRhKENvbXBvc2l0ZSBjb250YWluZXIsIFNwaW5uZXIgc3Bpbm5lcikgewotCi0JCS8vIEl0IGlzIHBvc3NpYmxlIHRoZSBzcGlubmVyJ3MgcGFyZW50IGlzIG5vdCB0aGUgY29udGFpbmVyIG9mIHRoZQotCQkvLyBsYWJlbCwgc3Bpbm5lciBhbmQgcmlnaHQgY29udHJvbCAoYSBwYW5lIGlzIHNvbWV0aW1lcyByZXF1aXJlZCBmb3IKLQkJLy8gcGFpbnRpbmcgdGhlIHNwaW5uZXIncyBib3JkZXIpCi0JCUNvbXBvc2l0ZSBwYW5lQ29udGFpbmVyID0gc3Bpbm5lci5nZXRQYXJlbnQoKTsKLQotCQl3aGlsZSAoY29udGFpbmVyICE9IHBhbmVDb250YWluZXIuZ2V0UGFyZW50KCkpIHsKLQkJCXBhbmVDb250YWluZXIgPSBwYW5lQ29udGFpbmVyLmdldFBhcmVudCgpOwotCQl9Ci0KLQkJQ29udHJvbFtdIGNvbnRyb2xzID0gcGFuZUNvbnRhaW5lci5nZXRDaGlsZHJlbigpOwotCi0JCUdyaWREYXRhIGdyaWREYXRhID0gbmV3IEdyaWREYXRhKCk7Ci0JCWdyaWREYXRhLmdyYWJFeGNlc3NIb3Jpem9udGFsU3BhY2UgPSBmYWxzZTsKLQkJZ3JpZERhdGEuaG9yaXpvbnRhbEFsaWdubWVudCAgICAgICA9IEdyaWREYXRhLkJFR0lOTklORzsKLQkJY29udHJvbHNbMV0uc2V0TGF5b3V0RGF0YShncmlkRGF0YSk7Ci0KLQkJY29udHJvbHNbMl0uc2V0TGF5b3V0RGF0YShuZXcgR3JpZERhdGEoR3JpZERhdGEuRklMTF9IT1JJWk9OVEFMKSk7Ci0JCXJlbW92ZUFsaWduUmlnaHQoY29udHJvbHNbMl0pOwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0Nvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0Nvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDBkYjQyNDAuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9Db25uZWN0aW9uUHJvcGVydGllc0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0qIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0qIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0qCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmNvbm5lY3Rpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNvbm5lY3Rpb24uQ29ubmVjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLlBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqICBDb25uZWN0aW9uUHJvcGVydGllc0NvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgQ29ubmVjdGlvblByb3BlcnRpZXNDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPENvbm5lY3Rpb24+Ci17Ci0JcHVibGljIENvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlKFBhbmU8Q29ubmVjdGlvbj4gcGFyZW50Q29tcG9zaXRlLCBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCWNvbnRhaW5lciA9IGFkZFRpdGxlZEdyb3VwKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkNvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlX0RhdGFiYXNlX0dyb3VwQm94Ci0JCSk7Ci0KLQkJbmV3IERhdGFTb3VyY2VQcm9wZXJ0aWVzQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JCW5ldyBKZGJjUHJvcGVydGllc0NvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0RhdGFTb3VyY2VQcm9wZXJ0aWVzQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0RhdGFTb3VyY2VQcm9wZXJ0aWVzQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZhN2Q5YjMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9EYXRhU291cmNlUHJvcGVydGllc0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTMzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY29ubmVjdGlvbjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQucGVyc2lzdGVuY2UuUGVyc2lzdGVuY2VVbml0VHJhbnNhY3Rpb25UeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY29ubmVjdGlvbi5Db25uZWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuQ29udHJvbEVuYWJsZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5MYWJlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5UZXh0OwotCi0vKioKLSAqIEB2ZXJzaW9uIDIuMAotICogQHNpbmNlIDIuMAotICovCi1wdWJsaWMgY2xhc3MgRGF0YVNvdXJjZVByb3BlcnRpZXNDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPENvbm5lY3Rpb24+IHsKLQotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+RGF0YVNvdXJjZVByb3BlcnRpZXNDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudFBhbmUgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIERhdGFTb3VyY2VQcm9wZXJ0aWVzQ29tcG9zaXRlKFBhbmU8Q29ubmVjdGlvbj4gcGFyZW50Q29tcG9zaXRlLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudENvbXBvc2l0ZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRKdGFEYXRhU291cmNlSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDb25uZWN0aW9uLCBTdHJpbmc+KGdldFN1YmplY3RIb2xkZXIoKSwgQ29ubmVjdGlvbi5KVEFfREFUQV9TT1VSQ0VfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRKdGFEYXRhU291cmNlKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQkJCXZhbHVlID0gbnVsbDsKLQkJCQl9Ci0JCQkJc3ViamVjdC5zZXRKdGFEYXRhU291cmNlKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZEpUQURhdGFTb3VyY2VIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8UGVyc2lzdGVuY2VVbml0VHJhbnNhY3Rpb25UeXBlLCBCb29sZWFuPihidWlsZFRyYW5zYWN0aW9uVHlwZUhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIHRyYW5zZm9ybShQZXJzaXN0ZW5jZVVuaXRUcmFuc2FjdGlvblR5cGUgdmFsdWUpIHsKLQkJCQlyZXR1cm4gdmFsdWUgPT0gbnVsbCB8fCB2YWx1ZSA9PSBQZXJzaXN0ZW5jZVVuaXRUcmFuc2FjdGlvblR5cGUuSlRBOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZE5vbkp0YURhdGFTb3VyY2VIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENvbm5lY3Rpb24sIFN0cmluZz4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb25uZWN0aW9uLk5PTl9KVEFfREFUQV9TT1VSQ0VfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXROb25KdGFEYXRhU291cmNlKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQkJCXZhbHVlID0gbnVsbDsKLQkJCQl9Ci0JCQkJc3ViamVjdC5zZXROb25KdGFEYXRhU291cmNlKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZE5vbkpUQURhdGFTb3VyY2VIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8UGVyc2lzdGVuY2VVbml0VHJhbnNhY3Rpb25UeXBlLCBCb29sZWFuPihidWlsZFRyYW5zYWN0aW9uVHlwZUhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIHRyYW5zZm9ybShQZXJzaXN0ZW5jZVVuaXRUcmFuc2FjdGlvblR5cGUgdmFsdWUpIHsKLQkJCQlyZXR1cm4gdmFsdWUgPT0gUGVyc2lzdGVuY2VVbml0VHJhbnNhY3Rpb25UeXBlLlJFU09VUkNFX0xPQ0FMOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFBlcnNpc3RlbmNlVW5pdFRyYW5zYWN0aW9uVHlwZT4gYnVpbGRUcmFuc2FjdGlvblR5cGVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENvbm5lY3Rpb24sIFBlcnNpc3RlbmNlVW5pdFRyYW5zYWN0aW9uVHlwZT4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb25uZWN0aW9uLlRSQU5TQUNUSU9OX1RZUEVfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFBlcnNpc3RlbmNlVW5pdFRyYW5zYWN0aW9uVHlwZSBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRUcmFuc2FjdGlvblR5cGUoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlpbnQgZ3JvdXBCb3hNYXJnaW4gPSBnZXRHcm91cEJveE1hcmdpbigpOwotCi0JCWNvbnRhaW5lciA9IGFkZFN1YlBhbmUoY29udGFpbmVyLCAwLCBncm91cEJveE1hcmdpbiwgMCwgZ3JvdXBCb3hNYXJnaW4pOwotCi0JCS8vIEpUQSBEYXRhIFNvdXJjZQotCQlMYWJlbCBqdGFMYWJlbCA9IGFkZFVubWFuYWdlZExhYmVsKGNvbnRhaW5lciwgRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9qdGFEYXRhU291cmNlTGFiZWwpOwotCQlUZXh0IHRleHQgPSBhZGRVbm1hbmFnZWRUZXh0KGNvbnRhaW5lciwgYnVpbGRKdGFEYXRhU291cmNlSG9sZGVyKCksIG51bGwpOwotCQl0aGlzLmFkZExhYmVsZWRDb21wb3NpdGUoY29udGFpbmVyLCBqdGFMYWJlbCwgdGV4dCwgbnVsbCk7Ci0KLQkJdGhpcy5pbnN0YWxsSlRBRGF0YVNvdXJjZUNvbnRyb2xFbmFibGVyKHRleHQsIGp0YUxhYmVsKTsKLQotCQkvLyBOb24tSlRBIERhdGEgU291cmNlCi0JCUxhYmVsIG5vbkp0YUxhYmVsID0gYWRkVW5tYW5hZ2VkTGFiZWwoY29udGFpbmVyLCBFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX25vbkp0YURhdGFTb3VyY2VMYWJlbCk7Ci0JCVRleHQgbm9uSnRhVGV4dCA9IGFkZFVubWFuYWdlZFRleHQoY29udGFpbmVyLCBidWlsZE5vbkp0YURhdGFTb3VyY2VIb2xkZXIoKSwgbnVsbCk7Ci0JCXRoaXMuYWRkTGFiZWxlZENvbXBvc2l0ZShjb250YWluZXIsIG5vbkp0YUxhYmVsLCBub25KdGFUZXh0LCBudWxsKTsKLQotCQl0aGlzLmluc3RhbGxOb25KVEFEYXRhU291cmNlQ29udHJvbEVuYWJsZXIobm9uSnRhVGV4dCwgbm9uSnRhTGFiZWwpOwotCX0KLQotCXByaXZhdGUgdm9pZCBpbnN0YWxsSlRBRGF0YVNvdXJjZUNvbnRyb2xFbmFibGVyKFRleHQgdGV4dCwgTGFiZWwgbGFiZWwpIHsKLQkJbmV3IENvbnRyb2xFbmFibGVyKGJ1aWxkSlRBRGF0YVNvdXJjZUhvbGRlcigpLCB0ZXh0LCBsYWJlbCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGluc3RhbGxOb25KVEFEYXRhU291cmNlQ29udHJvbEVuYWJsZXIoVGV4dCB0ZXh0LCBMYWJlbCBsYWJlbCkgewotCQluZXcgQ29udHJvbEVuYWJsZXIoYnVpbGROb25KVEFEYXRhU291cmNlSG9sZGVyKCksIHRleHQsIGxhYmVsKTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9FY2xpcHNlTGlua0Nvbm5lY3Rpb25Db21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vRWNsaXBzZUxpbmtDb25uZWN0aW9uQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDJmNGY3NmYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9FY2xpcHNlTGlua0Nvbm5lY3Rpb25Db21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmNvbm5lY3Rpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNvbm5lY3Rpb24uQ29ubmVjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBFY2xpcHNlTGlua0Nvbm5lY3Rpb25Db21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rQ29ubmVjdGlvbkNvbXBvc2l0ZQotCWV4dGVuZHMgRm9ybVBhbmU8Q29ubmVjdGlvbj4KLXsKLQlwdWJsaWMgRWNsaXBzZUxpbmtDb25uZWN0aW9uQ29tcG9zaXRlKAotCQkJCQlGb3JtUGFuZTxDb25uZWN0aW9uPiBzdWJqZWN0SG9sZGVyLAotCQkJCQlDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIGNvbnRhaW5lciwgZmFsc2UpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCWludCBncm91cEJveE1hcmdpbiA9IGdldEdyb3VwQm94TWFyZ2luKCkgKiAyOwotCi0JCWNvbnRhaW5lciA9IGFkZFNlY3Rpb24oCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3NlY3Rpb25UaXRsZSwKLQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfc2VjdGlvbkRlc2NyaXB0aW9uCi0JCSk7Ci0KLQkJQ29tcG9zaXRlIHN1YlBhbmUgPSBhZGRTdWJQYW5lKAotCQkJY29udGFpbmVyLAotCQkJMCwgZ3JvdXBCb3hNYXJnaW4sIDEwLCBncm91cEJveE1hcmdpbgotCQkpOwotCi0JCW5ldyBUcmFuc2FjdGlvblR5cGVDb21wb3NpdGUodGhpcywgc3ViUGFuZSk7Ci0KLQkJbmV3IEJhdGNoV3JpdGluZ0NvbXBvc2l0ZSh0aGlzLCBzdWJQYW5lKTsKLQotCQluZXcgQ2FjaGVTdGF0ZW1lbnRzUHJvcGVydGllc0NvbXBvc2l0ZSh0aGlzLCBzdWJQYW5lKTsKLQotCQluZXcgTmF0aXZlU3FsQ29tcG9zaXRlKHRoaXMsIHN1YlBhbmUpOwotCi0JCW5ldyBDb25uZWN0aW9uUHJvcGVydGllc0NvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0pkYmNCaW5kUGFyYW1ldGVyc0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9KZGJjQmluZFBhcmFtZXRlcnNDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjg5ZGZiMy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0pkYmNCaW5kUGFyYW1ldGVyc0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsOTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY29ubmVjdGlvbjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY29ubmVjdGlvbi5Db25uZWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIEpkYmNCaW5kUGFyYW1ldGVyc0NvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgSmRiY0JpbmRQYXJhbWV0ZXJzQ29tcG9zaXRlIGV4dGVuZHMgUGFuZTxDb25uZWN0aW9uPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+SmRiY0JpbmRQYXJhbWV0ZXJzQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRDb250cm9sbGVyCi0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIEpkYmNCaW5kUGFyYW1ldGVyc0NvbXBvc2l0ZSgKLQkJCQkJUGFuZTw/IGV4dGVuZHMgQ29ubmVjdGlvbj4gcGFyZW50Q29tcG9zaXRlLAotCQkJCQlDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRCaW5kUGFyYW1ldGVyc0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29ubmVjdGlvbiwgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb25uZWN0aW9uLkJJTkRfUEFSQU1FVEVSU19QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRCaW5kUGFyYW1ldGVycygpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJc3ViamVjdC5zZXRCaW5kUGFyYW1ldGVycyh2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc3ViamVjdENoYW5nZWQoKSB7Ci0JCQkJT2JqZWN0IG9sZFZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCQkJCXN1cGVyLnN1YmplY3RDaGFuZ2VkKCk7Ci0JCQkJT2JqZWN0IG5ld1ZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCi0JCQkJLy8gTWFrZSBzdXJlIHRoZSBkZWZhdWx0IHZhbHVlIGlzIGFwcGVuZGVkIHRvIHRoZSB0ZXh0Ci0JCQkJaWYgKG9sZFZhbHVlID09IG5ld1ZhbHVlICYmIG5ld1ZhbHVlID09IG51bGwpIHsKLQkJCQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKEJvb2xlYW4uVFJVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkQmluZFBhcmFtZXRlcnNTdHJpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbiwgU3RyaW5nPihidWlsZEJpbmRQYXJhbWV0ZXJzSG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oQm9vbGVhbiB2YWx1ZSkgewotCQkJCWlmICgoZ2V0U3ViamVjdCgpICE9IG51bGwpICYmICh2YWx1ZSA9PSBudWxsKSkgewotCQkJCQlCb29sZWFuIGRlZmF1bHRWYWx1ZSA9IGdldFN1YmplY3QoKS5nZXREZWZhdWx0QmluZFBhcmFtZXRlcnMoKTsKLQkJCQkJaWYgKGRlZmF1bHRWYWx1ZSAhPSBudWxsKSB7Ci0JCQkJCQlTdHJpbmcgZGVmYXVsdFN0cmluZ1ZhbHVlID0gZGVmYXVsdFZhbHVlID8gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fVHJ1ZSA6IEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5Cb29sZWFuX0ZhbHNlOwotCQkJCQkJcmV0dXJuIE5MUy5iaW5kKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfYmluZFBhcmFtZXRlcnNMYWJlbERlZmF1bHQsIGRlZmF1bHRTdHJpbmdWYWx1ZSk7Ci0JCQkJCX0KLQkJCQl9Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfYmluZFBhcmFtZXRlcnNMYWJlbDsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQl0aGlzLmFkZFRyaVN0YXRlQ2hlY2tCb3hXaXRoRGVmYXVsdCgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfYmluZFBhcmFtZXRlcnNMYWJlbCwKLQkJCXRoaXMuYnVpbGRCaW5kUGFyYW1ldGVyc0hvbGRlcigpLAotCQkJdGhpcy5idWlsZEJpbmRQYXJhbWV0ZXJzU3RyaW5nSG9sZGVyKCksCi0JCQludWxsCi0vLwkJCUVjbGlwc2VMaW5rSGVscENvbnRleHRJZHMuCi0JCSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9KZGJjQ29ubmVjdGlvblByb3BlcnRpZXNDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vSmRiY0Nvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDVjNmI5YTYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9KZGJjQ29ubmVjdGlvblByb3BlcnRpZXNDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDM0MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSoKLSogQ29udHJpYnV0b3JzOgotKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY29ubmVjdGlvbjsKLQotaW1wb3J0IGphdmEudXRpbC5Db21wYXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuQ29yZUV4Y2VwdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuSVByb2dyZXNzTW9uaXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuSVN0YXR1czsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuU3RhdHVzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLmRpYWxvZ3MuSURpYWxvZ0NvbnN0YW50czsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS5kaWFsb2dzLklEaWFsb2dTZXR0aW5nczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLklMYWJlbFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuTGFiZWxQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuQ29ubmVjdGlvblByb2ZpbGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkNvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuSnB0RGJQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5jb25uZWN0aW9uLkNvbm5lY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnB0VWlQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLkltYWdlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db250cm9sOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLlNoZWxsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnVpLmRpYWxvZ3MuRmlsdGVyZWRJdGVtc1NlbGVjdGlvbkRpYWxvZzsKLQotLyoqCi0gKiAgSmRiY0Nvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlCi0gKi8KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIEpkYmNDb25uZWN0aW9uUHJvcGVydGllc0NvbXBvc2l0ZSBleHRlbmRzIFBhbmU8Q29ubmVjdGlvbj4KLXsKLQkvKioKLQkgKiBUaGUgY29uc3RhbnQgSUQgdXNlZCB0byByZXRyaWV2ZSB0aGUgZGlhbG9nIHNldHRpbmdzLgotCSAqLwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBESUFMT0dfU0VUVElOR1MgPSAib3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmRpYWxvZ3MuQ29ubmVjdGlvbkRpYWxvZyI7Ci0KLQlwdWJsaWMgSmRiY0Nvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlKFBhbmU8Q29ubmVjdGlvbj4gcGFyZW50Q29tcG9zaXRlLCBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFBhc3N3b3JkSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDb25uZWN0aW9uLCBTdHJpbmc+KGdldFN1YmplY3RIb2xkZXIoKSwgQ29ubmVjdGlvbi5QQVNTV09SRF9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBzdWJqZWN0LmdldFBhc3N3b3JkKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQkJCXZhbHVlID0gbnVsbDsKLQkJCQl9Ci0JCQkJc3ViamVjdC5zZXRQYXNzd29yZCh2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBSdW5uYWJsZSBidWlsZFBvcHVsYXRlRnJvbUNvbm5lY3Rpb25BY3Rpb24oKSB7Ci0JCXJldHVybiBuZXcgUnVubmFibGUoKSB7Ci0JCQlwdWJsaWMgdm9pZCBydW4oKSB7Ci0JCQkJcHJvbXB0Q29ubmVjdGlvbigpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFVybEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29ubmVjdGlvbiwgU3RyaW5nPihnZXRTdWJqZWN0SG9sZGVyKCksIENvbm5lY3Rpb24uVVJMX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3QuZ2V0VXJsKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQkJCXZhbHVlID0gbnVsbDsKLQkJCQl9Ci0JCQkJc3ViamVjdC5zZXRVcmwodmFsdWUpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFVzZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENvbm5lY3Rpb24sIFN0cmluZz4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb25uZWN0aW9uLlVTRVJfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRVc2VyKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQkJCXZhbHVlID0gbnVsbDsKLQkJCQl9Ci0JCQkJc3ViamVjdC5zZXRVc2VyKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQkvLyBQb3B1bGF0ZSBmcm9tIENvbm5lY3Rpb24gaHlwZXJsaW5rCi0JCXRoaXMuYWRkSHlwZXJsaW5rKAotCQkJY29udGFpbmVyLAotCQkJIlBvcHVsYXRlIGZyb20gQ29ubmVjdGlvbi4uLiIsCi0JCQlidWlsZFBvcHVsYXRlRnJvbUNvbm5lY3Rpb25BY3Rpb24oKQotCQkpOwotCi0JCS8vIERyaXZlcgotCQluZXcgSmRiY0RyaXZlckNvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCi0JCS8vIFVybAotCQl0aGlzLmFkZExhYmVsZWRUZXh0KAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl91cmxMYWJlbCwKLQkJCWJ1aWxkVXJsSG9sZGVyKCkKLQkJKTsKLQotCQkvLyBVc2VyCi0JCXRoaXMuYWRkTGFiZWxlZFRleHQoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3VzZXJMYWJlbCwKLQkJCWJ1aWxkVXNlckhvbGRlcigpCi0JCSk7Ci0KLQkJLy8gUGFzc3dvcmQKLQkJdGhpcy5hZGRMYWJlbGVkUGFzc3dvcmRUZXh0KAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9wYXNzd29yZExhYmVsLAotCQkJYnVpbGRQYXNzd29yZEhvbGRlcigpCi0JCSk7Ci0KLQkJLy8gQmluZCBQYXJhbWV0ZXJzCi0JCW5ldyBKZGJjQmluZFBhcmFtZXRlcnNDb21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQl9Ci0KLQl2b2lkIHByb21wdENvbm5lY3Rpb24oKSB7Ci0KLQkJQ29ubmVjdGlvblNlbGVjdGlvbkRpYWxvZyBkaWFsb2cgPSBuZXcgQ29ubmVjdGlvblNlbGVjdGlvbkRpYWxvZygpOwotCi0JCWlmIChkaWFsb2cub3BlbigpICE9IElEaWFsb2dDb25zdGFudHMuT0tfSUQpIHsKLQkJCXJldHVybjsKLQkJfQotCi0JCVN0cmluZyBuYW1lID0gKFN0cmluZykgZGlhbG9nLmdldFJlc3VsdCgpWzBdOwotCQlDb25uZWN0aW9uUHJvZmlsZSBjcCA9IHRoaXMuZ2V0Q29ubmVjdGlvblByb2ZpbGVGYWN0b3J5KCkuYnVpbGRDb25uZWN0aW9uUHJvZmlsZShuYW1lKTsKLQotCQlDb25uZWN0aW9uIGNvbm5lY3Rpb24gPSBnZXRTdWJqZWN0KCk7Ci0JCWNvbm5lY3Rpb24uc2V0VXJsKChjcCA9PSBudWxsKSA/ICIiIDogY3AuZ2V0VVJMKCkpOwotCQljb25uZWN0aW9uLnNldFVzZXIoKGNwID09IG51bGwpID8gIiIgOiBjcC5nZXRVc2VyTmFtZSgpKTsKLQkJY29ubmVjdGlvbi5zZXRQYXNzd29yZCgoY3AgPT0gbnVsbCkgPyAiIiA6IGNwLmdldFVzZXJQYXNzd29yZCgpKTsKLQkJY29ubmVjdGlvbi5zZXREcml2ZXIoKGNwID09IG51bGwpID8gIiIgOiBjcC5nZXREcml2ZXJDbGFzc05hbWUoKSk7Ci0JfQotCi0JQ29ubmVjdGlvblByb2ZpbGVGYWN0b3J5IGdldENvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeSgpIHsKLQkJLy8gd2UgYWxsb3cgdGhlIHVzZXIgdG8gc2VsZWN0IGFueSBjb25uZWN0aW9uIHByb2ZpbGUgYW5kIHNpbXBseQotCQkvLyB0YWtlIHRoZSBzZXR0aW5ncyBmcm9tIGl0ICh1c2VyLCBwYXNzd29yZCwgZXRjLikgYW5kIGdpdmUgdGhlbQotCQkvLyB0byB0aGUgRWNsaXBzZUxpbmsgY29ubmVjdGlvbiwgc28gd2UgZ28KLQkJLy8gdG8gdGhlIGRiIHBsdWctaW4gZGlyZWN0bHkgdG8gZ2V0IHRoZSBmYWN0b3J5Ci0JCXJldHVybiBKcHREYlBsdWdpbi5pbnN0YW5jZSgpLmdldENvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeSgpOwotCX0KLQotCS8vIGJyb2FkZW4gYWNjZXNzIGEgYml0Ci0JU2hlbGwgZ2V0U2hlbGxfKCkgewotCQlyZXR1cm4gdGhpcy5nZXRTaGVsbCgpOwotCX0KLQotCS8qKgotCSAqIFRoaXMgZGlhbG9nIHNob3dzIHRoZSBsaXN0IG9mIHBvc3NpYmxlIGNvbm5lY3Rpb24gbmFtZXMgYW5kIGxldHMgdGhlIHVzZXIKLQkgKiB0aGUgb3B0aW9uIHRvIGZpbHRlciB0aGVtIHVzaW5nIGEgc2VhcmNoIGZpZWxkLgotCSAqLwotCXByb3RlY3RlZCBjbGFzcyBDb25uZWN0aW9uU2VsZWN0aW9uRGlhbG9nIGV4dGVuZHMgRmlsdGVyZWRJdGVtc1NlbGVjdGlvbkRpYWxvZyB7Ci0KLQkJLyoqCi0JCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+TWFwcGluZ1NlbGVjdGlvbkRpYWxvZzwvY29kZT4uCi0JCSAqLwotCQlwcm90ZWN0ZWQgQ29ubmVjdGlvblNlbGVjdGlvbkRpYWxvZygpIHsKLQkJCXN1cGVyKEpkYmNDb25uZWN0aW9uUHJvcGVydGllc0NvbXBvc2l0ZS50aGlzLmdldFNoZWxsXygpLCBmYWxzZSk7Ci0JCQlzZXRNZXNzYWdlKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5KZGJjQ29ubmVjdGlvblByb3BlcnRpZXNDb21wb3NpdGVfQ29ubmVjdGlvbkRpYWxvZ19NZXNzYWdlKTsKLQkJCXNldFRpdGxlKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5KZGJjQ29ubmVjdGlvblByb3BlcnRpZXNDb21wb3NpdGVfQ29ubmVjdGlvbkRpYWxvZ19UaXRsZSk7Ci0JCQlzZXRMaXN0TGFiZWxQcm92aWRlcihidWlsZExhYmVsUHJvdmlkZXIoKSk7Ci0JCQlzZXREZXRhaWxzTGFiZWxQcm92aWRlcihidWlsZExhYmVsUHJvdmlkZXIoKSk7Ci0JCX0KLQotCQlwcm90ZWN0ZWQgSUxhYmVsUHJvdmlkZXIgYnVpbGRMYWJlbFByb3ZpZGVyKCkgewotCQkJcmV0dXJuIG5ldyBMYWJlbFByb3ZpZGVyKCkgewotCQkJCUBPdmVycmlkZQotCQkJCXB1YmxpYyBJbWFnZSBnZXRJbWFnZShPYmplY3QgZWxlbWVudCkgewotCQkJCQlyZXR1cm4gbnVsbDsKLQkJCQl9Ci0KLQkJCQlAT3ZlcnJpZGUKLQkJCQlwdWJsaWMgU3RyaW5nIGdldFRleHQoT2JqZWN0IGVsZW1lbnQpIHsKLQkJCQkJcmV0dXJuIChlbGVtZW50ID09IG51bGwpID8gIiIgOiBlbGVtZW50LnRvU3RyaW5nKCk7Ci0JCQkJfQotCQkJfTsKLQkJfQotCi0JCS8qCi0JCSAqIChub24tSmF2YWRvYykKLQkJICovCi0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgQ29udHJvbCBjcmVhdGVFeHRlbmRlZENvbnRlbnRBcmVhKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0KLQkJLyoKLQkJICogKG5vbi1KYXZhZG9jKQotCQkgKi8KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCBJdGVtc0ZpbHRlciBjcmVhdGVGaWx0ZXIoKSB7Ci0JCQlyZXR1cm4gbmV3IENvbm5lY3Rpb25JdGVtc0ZpbHRlcigpOwotCQl9Ci0KLQkJLyoKLQkJICogKG5vbi1KYXZhZG9jKQotCQkgKi8KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCB2b2lkIGZpbGxDb250ZW50UHJvdmlkZXIoQWJzdHJhY3RDb250ZW50UHJvdmlkZXIgcHJvdmlkZXIsCi0JCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSXRlbXNGaWx0ZXIgaXRlbXNGaWx0ZXIsCi0JCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7Ci0KLQkJCW1vbml0b3IuYmVnaW5UYXNrKG51bGwsIC0xKTsKLQotCQkJdHJ5IHsKLQkJCQkvLyBBZGQgdGhlIGNvbm5lY3Rpb24gbmFtZXMgdG8gdGhlIGRpYWxvZwotCQkJCWZvciAoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmNvbm5lY3Rpb25Qcm9maWxlTmFtZXMoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQkJCXByb3ZpZGVyLmFkZChzdHJlYW0ubmV4dCgpLCBpdGVtc0ZpbHRlcik7Ci0JCQkJfQotCQkJfQotCQkJZmluYWxseSB7Ci0JCQkJbW9uaXRvci5kb25lKCk7Ci0JCQl9Ci0JCX0KLQotCQlwcml2YXRlIEl0ZXJhdG9yPFN0cmluZz4gY29ubmVjdGlvblByb2ZpbGVOYW1lcygpIHsKLQkJCXJldHVybiBKZGJjQ29ubmVjdGlvblByb3BlcnRpZXNDb21wb3NpdGUudGhpcy5nZXRDb25uZWN0aW9uUHJvZmlsZUZhY3RvcnkoKS5jb25uZWN0aW9uUHJvZmlsZU5hbWVzKCk7Ci0JCX0KLQotCQkvKgotCQkgKiAobm9uLUphdmFkb2MpCi0JCSAqLwotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIElEaWFsb2dTZXR0aW5ncyBnZXREaWFsb2dTZXR0aW5ncygpIHsKLQotCQkJSURpYWxvZ1NldHRpbmdzIGRpYWxvZ1NldHRpbmdzID0gSnB0VWlQbHVnaW4uaW5zdGFuY2UoKS5nZXREaWFsb2dTZXR0aW5ncygpOwotCQkJSURpYWxvZ1NldHRpbmdzIHNldHRpbmdzID0gZGlhbG9nU2V0dGluZ3MuZ2V0U2VjdGlvbihESUFMT0dfU0VUVElOR1MpOwotCi0JCQlpZiAoc2V0dGluZ3MgPT0gbnVsbCkgewotCQkJCXNldHRpbmdzID0gZGlhbG9nU2V0dGluZ3MuYWRkTmV3U2VjdGlvbihESUFMT0dfU0VUVElOR1MpOwotCQkJfQotCi0JCQlyZXR1cm4gc2V0dGluZ3M7Ci0JCX0KLQotCQkvKgotCQkgKiAobm9uLUphdmFkb2MpCi0JCSAqLwotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyBnZXRFbGVtZW50TmFtZShPYmplY3Qgb2JqZWN0KSB7Ci0JCQlyZXR1cm4gb2JqZWN0LnRvU3RyaW5nKCk7Ci0JCX0KLQotCQkvKgotCQkgKiAobm9uLUphdmFkb2MpCi0JCSAqLwotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIENvbXBhcmF0b3I8U3RyaW5nPiBnZXRJdGVtc0NvbXBhcmF0b3IoKSB7Ci0JCQlyZXR1cm4gbmV3IENvbXBhcmF0b3I8U3RyaW5nPigpIHsKLQkJCQlwdWJsaWMgaW50IGNvbXBhcmUoU3RyaW5nIGl0ZW0xLCBTdHJpbmcgaXRlbTIpIHsKLQkJCQkJcmV0dXJuIGl0ZW0xLmNvbXBhcmVUbyhpdGVtMik7Ci0JCQkJfQotCQkJfTsKLQkJfQotCi0JCS8qCi0JCSAqIChub24tSmF2YWRvYykKLQkJICovCi0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgSVN0YXR1cyB2YWxpZGF0ZUl0ZW0oT2JqZWN0IGl0ZW0pIHsKLQotCQkJaWYgKGl0ZW0gPT0gbnVsbCkgewotCQkJCXJldHVybiBuZXcgU3RhdHVzKElTdGF0dXMuRVJST1IsIEpwdFVpUGx1Z2luLlBMVUdJTl9JRCwgSVN0YXR1cy5FUlJPUiwgIiIsIG51bGwpOwotCQkJfQotCi0JCQlyZXR1cm4gU3RhdHVzLk9LX1NUQVRVUzsKLQkJfQotCi0JCS8qKgotCQkgKiBDcmVhdGUgdGhlIGZpbHRlciByZXNwb25zaWJsZSB0byByZW1vdmUgYW55IGNvbm5lY3Rpb24gbmFtZSBiYXNlZCBvbgotCQkgKiB0aGUgcGF0dGVybiBlbnRlcmVkIGluIHRoZSB0ZXh0IGZpZWxkLgotCQkgKi8KLQkJcHJpdmF0ZSBjbGFzcyBDb25uZWN0aW9uSXRlbXNGaWx0ZXIgZXh0ZW5kcyBJdGVtc0ZpbHRlciB7Ci0KLQkJCS8qKgotCQkJICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5Db25uZWN0aW9uSXRlbXNGaWx0ZXI8L2NvZGU+LgotCQkJICovCi0JCQlDb25uZWN0aW9uSXRlbXNGaWx0ZXIoKSB7Ci0KLQkJCQlzdXBlcigpOwotCi0JCQkJLy8gTWFrZSBzdXJlIHRoYXQgaWYgdGhlIHBhdHRlcm4gaXMgZW1wdHksIHdlIHNwZWNpZnkgKiBpbiBvcmRlcgotCQkJCS8vIHRvIHNob3cgYWxsIHRoZSBtYXBwaW5nIHR5cGVzCi0JCQkJaWYgKFN0cmluZ1Rvb2xzLnN0cmluZ0lzRW1wdHkoZ2V0UGF0dGVybigpKSkgewotCQkJCQlwYXR0ZXJuTWF0Y2hlci5zZXRQYXR0ZXJuKCIqIik7Ci0JCQkJfQotCQkJfQotCi0JCQkvKgotCQkJICogKG5vbi1KYXZhZG9jKQotCQkJICovCi0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBib29sZWFuIGlzQ29uc2lzdGVudEl0ZW0oT2JqZWN0IGl0ZW0pIHsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQotCQkJLyoKLQkJCSAqIChub24tSmF2YWRvYykKLQkJCSAqLwotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgYm9vbGVhbiBtYXRjaEl0ZW0oT2JqZWN0IGl0ZW0pIHsKLQkJCQlyZXR1cm4gbWF0Y2hlcyhpdGVtLnRvU3RyaW5nKCkpOwotCQkJfQotCQl9Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vSmRiY0RyaXZlckNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9KZGJjRHJpdmVyQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDlkN2E5NDMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9KZGJjRHJpdmVyQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw5MyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSogCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmNvbm5lY3Rpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcGFQcm9qZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY29ubmVjdGlvbi5Db25uZWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuQ2xhc3NDaG9vc2VyUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogIEpkYmNEcml2ZXJDb21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIEpkYmNEcml2ZXJDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPENvbm5lY3Rpb24+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5FdmVudExpc3RlbmVyQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRQYW5lIFRoZSBwYXJlbnQgcGFuZSBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgSmRiY0RyaXZlckNvbXBvc2l0ZShQYW5lPD8gZXh0ZW5kcyBDb25uZWN0aW9uPiBwYXJlbnRQYW5lLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudFBhbmUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBDbGFzc0Nob29zZXJQYW5lPENvbm5lY3Rpb24+IGluaXRpYWxpemVDbGFzc0Nob29zZXIoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXJldHVybiBuZXcgQ2xhc3NDaG9vc2VyUGFuZTxDb25uZWN0aW9uPih0aGlzLCBjb250YWluZXIpIHsKLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFRleHRIb2xkZXIoKSB7Ci0JCQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29ubmVjdGlvbiwgU3RyaW5nPigKLQkJCQkJCQl0aGlzLmdldFN1YmplY3RIb2xkZXIoKSwgQ29ubmVjdGlvbi5EUklWRVJfUFJPUEVSVFkpIHsKLQkJCQkJQE92ZXJyaWRlCi0JCQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldERyaXZlcigpOwotCQkJCQl9Ci0KLQkJCQkJQE92ZXJyaWRlCi0JCQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhTdHJpbmcgdmFsdWUpIHsKLQotCQkJCQkJaWYgKHZhbHVlLmxlbmd0aCgpID09IDApIHsKLQkJCQkJCQl2YWx1ZSA9IG51bGw7Ci0JCQkJCQl9Ci0JCQkJCQl0aGlzLnN1YmplY3Quc2V0RHJpdmVyKHZhbHVlKTsKLQkJCQkJfQotCQkJCX07Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBnZXRDbGFzc05hbWUoKSB7Ci0JCQkJcmV0dXJuIHRoaXMuZ2V0U3ViamVjdCgpLmdldERyaXZlcigpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZ2V0TGFiZWxUZXh0KCkgewotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX2RyaXZlckxhYmVsOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBKcGFQcm9qZWN0IGdldEpwYVByb2plY3QoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXRKcGFQcm9qZWN0KCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldENsYXNzTmFtZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCQkJdGhpcy5nZXRTdWJqZWN0KCkuc2V0RHJpdmVyKGNsYXNzTmFtZSk7CQkJCQotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBib29sZWFuIGFsbG93VHlwZUNyZWF0aW9uKCkgewotCQkJCS8vRG9lcyBub3QgbWFrZSBzZW5zZSB0byBhbGxvdyB0aGUgdXNlciB0byBjcmVhdGUgYSBuZXcgRHJpdmVyIGNsYXNzCi0JCQkJcmV0dXJuIGZhbHNlOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQl0aGlzLmluaXRpYWxpemVDbGFzc0Nob29zZXIoY29udGFpbmVyKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0pkYmNQcm9wZXJ0aWVzQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0pkYmNQcm9wZXJ0aWVzQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGFhZGU1OWEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9KZGJjUHJvcGVydGllc0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0qIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0qIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0qCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmNvbm5lY3Rpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LnBlcnNpc3RlbmNlLlBlcnNpc3RlbmNlVW5pdFRyYW5zYWN0aW9uVHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNvbm5lY3Rpb24uQ29ubmVjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLlBhbmVFbmFibGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLlBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWRMYXlvdXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqICBKZGJjUHJvcGVydGllc0NvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgSmRiY1Byb3BlcnRpZXNDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPENvbm5lY3Rpb24+Ci17Ci0JcHVibGljIEpkYmNQcm9wZXJ0aWVzQ29tcG9zaXRlKFBhbmU8Q29ubmVjdGlvbj4gcGFyZW50Q29tcG9zaXRlLCBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkUGFuZUVuYWJsZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8UGVyc2lzdGVuY2VVbml0VHJhbnNhY3Rpb25UeXBlLCBCb29sZWFuPihidWlsZFRyYW5zYWN0aW9uVHlwZUhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIHRyYW5zZm9ybShQZXJzaXN0ZW5jZVVuaXRUcmFuc2FjdGlvblR5cGUgdmFsdWUpIHsKLQkJCQlyZXR1cm4gdmFsdWUgPT0gUGVyc2lzdGVuY2VVbml0VHJhbnNhY3Rpb25UeXBlLlJFU09VUkNFX0xPQ0FMOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFBlcnNpc3RlbmNlVW5pdFRyYW5zYWN0aW9uVHlwZT4gYnVpbGRUcmFuc2FjdGlvblR5cGVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENvbm5lY3Rpb24sIFBlcnNpc3RlbmNlVW5pdFRyYW5zYWN0aW9uVHlwZT4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb25uZWN0aW9uLlRSQU5TQUNUSU9OX1RZUEVfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFBlcnNpc3RlbmNlVW5pdFRyYW5zYWN0aW9uVHlwZSBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRUcmFuc2FjdGlvblR5cGUoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQljb250YWluZXIgPSBhZGRUaXRsZWRHcm91cCgKLQkJCWFkZFN1YlBhbmUoY29udGFpbmVyLCAxMCksCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuSmRiY1Byb3BlcnRpZXNDb21wb3NpdGVfRWNsaXBzZUxpbmtDb25uZWN0aW9uUG9vbF9Hcm91cEJveAotCQkpOwotCi0JCW5ldyBKZGJjQ29ubmVjdGlvblByb3BlcnRpZXNDb21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQotCQljb250YWluZXIgPSBhZGRQYW5lKGNvbnRhaW5lciwgbmV3IEdyaWRMYXlvdXQoMiwgdHJ1ZSkpOwotCi0JCW5ldyBKZGJjUmVhZENvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JCW5ldyBKZGJjV3JpdGVDb25uZWN0aW9uUHJvcGVydGllc0NvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCi0JCXRoaXMuaW5zdGFsbFBhbmVFbmFibGVyKCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGluc3RhbGxQYW5lRW5hYmxlcigpIHsKLQkJbmV3IFBhbmVFbmFibGVyKGJ1aWxkUGFuZUVuYWJsZXJIb2xkZXIoKSwgdGhpcyk7Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vSmRiY1JlYWRDb25uZWN0aW9uUHJvcGVydGllc0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9KZGJjUmVhZENvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQxNzk2ZTMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9KZGJjUmVhZENvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSoKLSogQ29udHJpYnV0b3JzOgotKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY29ubmVjdGlvbjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY29ubmVjdGlvbi5Db25uZWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuU1dUOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuR3JpZERhdGE7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqICBKZGJjUmVhZENvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBKZGJjUmVhZENvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlIGV4dGVuZHMgUGFuZTxDb25uZWN0aW9uPgotewotCXB1YmxpYyBKZGJjUmVhZENvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlKFBhbmU8Q29ubmVjdGlvbj4gcGFyZW50Q29tcG9zaXRlLCBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQsIGZhbHNlKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQljb250YWluZXIgPSB0aGlzLmFkZFNlY3Rpb24oCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3JlYWRDb25uZWN0aW9uc1NlY3Rpb25UaXRsZQotCQkpOwotCi0JCUdyaWREYXRhIGRhdGEgPSAoR3JpZERhdGEpIGNvbnRhaW5lci5nZXRMYXlvdXREYXRhKCk7Ci0JCWRhdGEudmVydGljYWxBbGlnbm1lbnQgPSBTV1QuVE9QOwotCi0JCWRhdGEgPSAoR3JpZERhdGEpIGdldENvbnRyb2woKS5nZXRMYXlvdXREYXRhKCk7Ci0JCWRhdGEudmVydGljYWxBbGlnbm1lbnQgPSBTV1QuVE9QOwotCi0JCS8vIFJlYWQgQ29ubmVjdGlvbnMgU2hhcmVkCi0JCW5ldyBKZGJjUmVhZENvbm5lY3Rpb25zU2hhcmVkQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0KLQkJLy8gUmVhZCBDb25uZWN0aW9ucyBNaW5pbXVtCi0JCW5ldyBKZGJjUmVhZENvbm5lY3Rpb25zTWluQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0KLQkJLy8gUmVhZCBDb25uZWN0aW9ucyBNYXhpbXVtCi0JCW5ldyBKZGJjUmVhZENvbm5lY3Rpb25zTWF4Q29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vSmRiY1JlYWRDb25uZWN0aW9uc01heENvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9KZGJjUmVhZENvbm5lY3Rpb25zTWF4Q29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZjYjE0NDkuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9KZGJjUmVhZENvbm5lY3Rpb25zTWF4Q29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNjkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY29ubmVjdGlvbjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY29ubmVjdGlvbi5Db25uZWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuTGFiZWxlZENvbnRyb2xVcGRhdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLkxhYmVsZWRMYWJlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWREYXRhOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db250cm9sOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkxhYmVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLlNwaW5uZXI7Ci0KLS8qKgotICogSmRiY1JlYWRDb25uZWN0aW9uc01heENvbXBvc2l0ZQotICovCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBKZGJjUmVhZENvbm5lY3Rpb25zTWF4Q29tcG9zaXRlIGV4dGVuZHMgUGFuZTxDb25uZWN0aW9uPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+SmRiY1JlYWRDb25uZWN0aW9uc01heENvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50Q29udHJvbGxlcgotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50Ci0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBKZGJjUmVhZENvbm5lY3Rpb25zTWF4Q29tcG9zaXRlKFBhbmU8Q29ubmVjdGlvbj4gcGFyZW50Q29tcG9zaXRlLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRDb21wb3NpdGUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyPiBidWlsZFJlYWRDb25uZWN0aW9uc01heEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29ubmVjdGlvbiwgSW50ZWdlcj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb25uZWN0aW9uLlJFQURfQ09OTkVDVElPTlNfTUFYX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBJbnRlZ2VyIGJ1aWxkVmFsdWVfKCkgewotCQkJCUludGVnZXIgdmFsdWUgPSBzdWJqZWN0LmdldFJlYWRDb25uZWN0aW9uc01heCgpOwotCi0JCQkJaWYgKHZhbHVlID09IG51bGwpIHsKLQkJCQkJdmFsdWUgPSAtMTsKLQkJCQl9Ci0JCQkJcmV0dXJuIHZhbHVlOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhJbnRlZ2VyIHZhbHVlKSB7Ci0JCQkJaWYgKHZhbHVlID09IC0xKSB7Ci0JCQkJCXZhbHVlID0gbnVsbDsKLQkJCQl9Ci0JCQkJc3ViamVjdC5zZXRSZWFkQ29ubmVjdGlvbnNNYXgodmFsdWUpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXI+IGJ1aWxkRGVmYXVsdFJlYWRDb25uZWN0aW9uc01heEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29ubmVjdGlvbiwgSW50ZWdlcj4oZ2V0U3ViamVjdEhvbGRlcigpLCAiIikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSW50ZWdlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXREZWZhdWx0UmVhZENvbm5lY3Rpb25zTWF4KCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc3ViamVjdENoYW5nZWQoKSB7Ci0JCQkJT2JqZWN0IG9sZFZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCQkJCXN1cGVyLnN1YmplY3RDaGFuZ2VkKCk7Ci0JCQkJT2JqZWN0IG5ld1ZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCi0JCQkJLy8gTWFrZSBzdXJlIHRoZSBkZWZhdWx0IHZhbHVlIGlzIGFwcGVuZGVkIHRvIHRoZSB0ZXh0Ci0JCQkJaWYgKG9sZFZhbHVlID09IG5ld1ZhbHVlICYmIG5ld1ZhbHVlID09IG51bGwpIHsKLQkJCQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKEludGVnZXIuTUlOX1ZBTFVFLCBuZXdWYWx1ZSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgQ29udHJvbCBhZGREZWZhdWx0UmVhZENvbm5lY3Rpb25zTWF4TGFiZWwoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCUxhYmVsIGxhYmVsID0gYWRkTGFiZWwoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuRGVmYXVsdFdpdGhvdXRWYWx1ZQotCQkpOwotCi0JCW5ldyBMYWJlbGVkQ29udHJvbFVwZGF0ZXIoCi0JCQluZXcgTGFiZWxlZExhYmVsKGxhYmVsKSwKLQkJCWJ1aWxkRGVmYXVsdFJlYWRDb25uZWN0aW9uc01heExhYmVsSG9sZGVyKCkKLQkJKTsKLQotCQlyZXR1cm4gbGFiZWw7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZERlZmF1bHRSZWFkQ29ubmVjdGlvbnNNYXhMYWJlbEhvbGRlcigpIHsKLQotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXIsIFN0cmluZz4oYnVpbGREZWZhdWx0UmVhZENvbm5lY3Rpb25zTWF4SG9sZGVyKCkpIHsKLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShJbnRlZ2VyIHZhbHVlKSB7Ci0KLQkJCQlpZiAodmFsdWUgIT0gbnVsbCkgewotCQkJCQlyZXR1cm4gTkxTLmJpbmQoRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkRlZmF1bHRXaXRoVmFsdWUsIHZhbHVlKTsKLQkJCQl9Ci0KLQkJCQlyZXR1cm4gIiI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJU3Bpbm5lciBzcGlubmVyID0gdGhpcy5hZGRMYWJlbGVkU3Bpbm5lcigKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfcmVhZENvbm5lY3Rpb25zTWF4TGFiZWwsCi0JCQl0aGlzLmJ1aWxkUmVhZENvbm5lY3Rpb25zTWF4SG9sZGVyKCksCi0JCQktMSwKLQkJCS0xLAotCQkJSW50ZWdlci5NQVhfVkFMVUUsCi0JCQl0aGlzLmFkZERlZmF1bHRSZWFkQ29ubmVjdGlvbnNNYXhMYWJlbChjb250YWluZXIpLAotCQkJbnVsbAotCQkpOwotCi0JCXVwZGF0ZUdyaWREYXRhKGNvbnRhaW5lciwgc3Bpbm5lcik7Ci0JfQotCi0JLyoqCi0JICogQ2hhbmdlcyB0aGUgbGF5b3V0IG9mIHRoZSBnaXZlbiBjb250YWluZXIgYnkgY2hhbmdpbmcgd2hpY2ggd2lkZ2V0IHdpbGwKLQkgKiBncmFiIHRoZSBleGNlc3Mgb2YgaG9yaXpvbnRhbCBzcGFjZS4gQnkgZGVmYXVsdCwgdGhlIGNlbnRlciBjb250cm9sIGdyYWJzCi0JICogdGhlIGV4Y2VzcyBzcGFjZSwgd2UgY2hhbmdlIGl0IHRvIGJlIHRoZSByaWdodCBjb250cm9sLgotCSAqCi0JICogQHBhcmFtIGNvbnRhaW5lciBUaGUgY29udGFpbmVyIGNvbnRhaW5pbmcgdGhlIGNvbnRyb2xzIG5lZWRpbmcgdGhlaXIKLQkgKiA8Y29kZT5HcmlkRGF0YTwvY29kZT4gdG8gYmUgbW9kaWZpZWQgZnJvbSB0aGUgZGVmYXVsdCB2YWx1ZXMKLQkgKiBAcGFyYW0gc3Bpbm5lciBUaGUgc3Bpbm5lciB0aGF0IGdvdCBjcmVhdGVkCi0JICovCi0JcHJpdmF0ZSB2b2lkIHVwZGF0ZUdyaWREYXRhKENvbXBvc2l0ZSBjb250YWluZXIsIFNwaW5uZXIgc3Bpbm5lcikgewotCi0JCS8vIEl0IGlzIHBvc3NpYmxlIHRoZSBzcGlubmVyJ3MgcGFyZW50IGlzIG5vdCB0aGUgY29udGFpbmVyIG9mIHRoZQotCQkvLyBsYWJlbCwgc3Bpbm5lciBhbmQgcmlnaHQgY29udHJvbCAoYSBwYW5lIGlzIHNvbWV0aW1lcyByZXF1aXJlZCBmb3IKLQkJLy8gcGFpbnRpbmcgdGhlIHNwaW5uZXIncyBib3JkZXIpCi0JCUNvbXBvc2l0ZSBwYW5lQ29udGFpbmVyID0gc3Bpbm5lci5nZXRQYXJlbnQoKTsKLQotCQl3aGlsZSAoY29udGFpbmVyICE9IHBhbmVDb250YWluZXIuZ2V0UGFyZW50KCkpIHsKLQkJCXBhbmVDb250YWluZXIgPSBwYW5lQ29udGFpbmVyLmdldFBhcmVudCgpOwotCQl9Ci0KLQkJQ29udHJvbFtdIGNvbnRyb2xzID0gcGFuZUNvbnRhaW5lci5nZXRDaGlsZHJlbigpOwotCi0JCUdyaWREYXRhIGdyaWREYXRhID0gbmV3IEdyaWREYXRhKCk7Ci0JCWdyaWREYXRhLmdyYWJFeGNlc3NIb3Jpem9udGFsU3BhY2UgPSBmYWxzZTsKLQkJZ3JpZERhdGEuaG9yaXpvbnRhbEFsaWdubWVudCAgICAgICA9IEdyaWREYXRhLkJFR0lOTklORzsKLQkJY29udHJvbHNbMV0uc2V0TGF5b3V0RGF0YShncmlkRGF0YSk7Ci0KLQkJY29udHJvbHNbMl0uc2V0TGF5b3V0RGF0YShuZXcgR3JpZERhdGEoR3JpZERhdGEuRklMTF9IT1JJWk9OVEFMKSk7Ci0JCXJlbW92ZUFsaWduUmlnaHQoY29udHJvbHNbMl0pOwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0pkYmNSZWFkQ29ubmVjdGlvbnNNaW5Db21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vSmRiY1JlYWRDb25uZWN0aW9uc01pbkNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjMTE0ODVmLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vSmRiY1JlYWRDb25uZWN0aW9uc01pbkNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTY5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmNvbm5lY3Rpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNvbm5lY3Rpb24uQ29ubmVjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLkxhYmVsZWRDb250cm9sVXBkYXRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwudXRpbC5MYWJlbGVkTGFiZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkRGF0YTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29udHJvbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5MYWJlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5TcGlubmVyOwotCi0vKioKLSAqIEpkYmNSZWFkQ29ubmVjdGlvbnNNaW5Db21wb3NpdGUKLSAqLwotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgY2xhc3MgSmRiY1JlYWRDb25uZWN0aW9uc01pbkNvbXBvc2l0ZSBleHRlbmRzIFBhbmU8Q29ubmVjdGlvbj4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkpkYmNSZWFkQ29ubmVjdGlvbnNNaW5Db21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudENvbnRyb2xsZXIKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudAotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgSmRiY1JlYWRDb25uZWN0aW9uc01pbkNvbXBvc2l0ZShQYW5lPENvbm5lY3Rpb24+IHBhcmVudENvbXBvc2l0ZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4gYnVpbGRSZWFkQ29ubmVjdGlvbnNNaW5Ib2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENvbm5lY3Rpb24sIEludGVnZXI+KGdldFN1YmplY3RIb2xkZXIoKSwgQ29ubmVjdGlvbi5SRUFEX0NPTk5FQ1RJT05TX01JTl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSW50ZWdlciBidWlsZFZhbHVlXygpIHsKLQkJCQlJbnRlZ2VyIHZhbHVlID0gc3ViamVjdC5nZXRSZWFkQ29ubmVjdGlvbnNNaW4oKTsKLQotCQkJCWlmICh2YWx1ZSA9PSBudWxsKSB7Ci0JCQkJCXZhbHVlID0gLTE7Ci0JCQkJfQotCQkJCXJldHVybiB2YWx1ZTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oSW50ZWdlciB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZSA9PSAtMSkgewotCQkJCQl2YWx1ZSA9IG51bGw7Ci0JCQkJfQotCQkJCXN1YmplY3Quc2V0UmVhZENvbm5lY3Rpb25zTWluKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyPiBidWlsZERlZmF1bHRSZWFkQ29ubmVjdGlvbnNNaW5Ib2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENvbm5lY3Rpb24sIEludGVnZXI+KGdldFN1YmplY3RIb2xkZXIoKSwgIiIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEludGVnZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3QuZ2V0RGVmYXVsdFJlYWRDb25uZWN0aW9uc01pbigpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHN1YmplY3RDaGFuZ2VkKCkgewotCQkJCU9iamVjdCBvbGRWYWx1ZSA9IHRoaXMuZ2V0VmFsdWUoKTsKLQkJCQlzdXBlci5zdWJqZWN0Q2hhbmdlZCgpOwotCQkJCU9iamVjdCBuZXdWYWx1ZSA9IHRoaXMuZ2V0VmFsdWUoKTsKLQotCQkJCS8vIE1ha2Ugc3VyZSB0aGUgZGVmYXVsdCB2YWx1ZSBpcyBhcHBlbmRlZCB0byB0aGUgdGV4dAotCQkJCWlmIChvbGRWYWx1ZSA9PSBuZXdWYWx1ZSAmJiBuZXdWYWx1ZSA9PSBudWxsKSB7Ci0JCQkJCXRoaXMuZmlyZUFzcGVjdENoYW5nZShJbnRlZ2VyLk1JTl9WQUxVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbnRyb2wgYWRkRGVmYXVsdFJlYWRDb25uZWN0aW9uc01pbkxhYmVsKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlMYWJlbCBsYWJlbCA9IGFkZExhYmVsKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkRlZmF1bHRXaXRob3V0VmFsdWUKLQkJKTsKLQotCQluZXcgTGFiZWxlZENvbnRyb2xVcGRhdGVyKAotCQkJbmV3IExhYmVsZWRMYWJlbChsYWJlbCksCi0JCQlidWlsZERlZmF1bHRSZWFkQ29ubmVjdGlvbnNNaW5MYWJlbEhvbGRlcigpCi0JCSk7Ci0KLQkJcmV0dXJuIGxhYmVsOwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGREZWZhdWx0UmVhZENvbm5lY3Rpb25zTWluTGFiZWxIb2xkZXIoKSB7Ci0KLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyLCBTdHJpbmc+KGJ1aWxkRGVmYXVsdFJlYWRDb25uZWN0aW9uc01pbkhvbGRlcigpKSB7Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oSW50ZWdlciB2YWx1ZSkgewotCi0JCQkJaWYgKHZhbHVlICE9IG51bGwpIHsKLQkJCQkJcmV0dXJuIE5MUy5iaW5kKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5EZWZhdWx0V2l0aFZhbHVlLCB2YWx1ZSk7Ci0JCQkJfQotCi0JCQkJcmV0dXJuICIiOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCVNwaW5uZXIgc3Bpbm5lciA9IHRoaXMuYWRkTGFiZWxlZFNwaW5uZXIoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3JlYWRDb25uZWN0aW9uc01pbkxhYmVsLAotCQkJdGhpcy5idWlsZFJlYWRDb25uZWN0aW9uc01pbkhvbGRlcigpLAotCQkJLTEsCi0JCQktMSwKLQkJCUludGVnZXIuTUFYX1ZBTFVFLAotCQkJdGhpcy5hZGREZWZhdWx0UmVhZENvbm5lY3Rpb25zTWluTGFiZWwoY29udGFpbmVyKSwKLQkJCW51bGwKLQkJKTsKLQotCQl1cGRhdGVHcmlkRGF0YShjb250YWluZXIsIHNwaW5uZXIpOwotCX0KLQotCS8qKgotCSAqIENoYW5nZXMgdGhlIGxheW91dCBvZiB0aGUgZ2l2ZW4gY29udGFpbmVyIGJ5IGNoYW5naW5nIHdoaWNoIHdpZGdldCB3aWxsCi0JICogZ3JhYiB0aGUgZXhjZXNzIG9mIGhvcml6b250YWwgc3BhY2UuIEJ5IGRlZmF1bHQsIHRoZSBjZW50ZXIgY29udHJvbCBncmFicwotCSAqIHRoZSBleGNlc3Mgc3BhY2UsIHdlIGNoYW5nZSBpdCB0byBiZSB0aGUgcmlnaHQgY29udHJvbC4KLQkgKgotCSAqIEBwYXJhbSBjb250YWluZXIgVGhlIGNvbnRhaW5lciBjb250YWluaW5nIHRoZSBjb250cm9scyBuZWVkaW5nIHRoZWlyCi0JICogPGNvZGU+R3JpZERhdGE8L2NvZGU+IHRvIGJlIG1vZGlmaWVkIGZyb20gdGhlIGRlZmF1bHQgdmFsdWVzCi0JICogQHBhcmFtIHNwaW5uZXIgVGhlIHNwaW5uZXIgdGhhdCBnb3QgY3JlYXRlZAotCSAqLwotCXByaXZhdGUgdm9pZCB1cGRhdGVHcmlkRGF0YShDb21wb3NpdGUgY29udGFpbmVyLCBTcGlubmVyIHNwaW5uZXIpIHsKLQotCQkvLyBJdCBpcyBwb3NzaWJsZSB0aGUgc3Bpbm5lcidzIHBhcmVudCBpcyBub3QgdGhlIGNvbnRhaW5lciBvZiB0aGUKLQkJLy8gbGFiZWwsIHNwaW5uZXIgYW5kIHJpZ2h0IGNvbnRyb2wgKGEgcGFuZSBpcyBzb21ldGltZXMgcmVxdWlyZWQgZm9yCi0JCS8vIHBhaW50aW5nIHRoZSBzcGlubmVyJ3MgYm9yZGVyKQotCQlDb21wb3NpdGUgcGFuZUNvbnRhaW5lciA9IHNwaW5uZXIuZ2V0UGFyZW50KCk7Ci0KLQkJd2hpbGUgKGNvbnRhaW5lciAhPSBwYW5lQ29udGFpbmVyLmdldFBhcmVudCgpKSB7Ci0JCQlwYW5lQ29udGFpbmVyID0gcGFuZUNvbnRhaW5lci5nZXRQYXJlbnQoKTsKLQkJfQotCi0JCUNvbnRyb2xbXSBjb250cm9scyA9IHBhbmVDb250YWluZXIuZ2V0Q2hpbGRyZW4oKTsKLQotCQlHcmlkRGF0YSBncmlkRGF0YSA9IG5ldyBHcmlkRGF0YSgpOwotCQlncmlkRGF0YS5ncmFiRXhjZXNzSG9yaXpvbnRhbFNwYWNlID0gZmFsc2U7Ci0JCWdyaWREYXRhLmhvcml6b250YWxBbGlnbm1lbnQgICAgICAgPSBHcmlkRGF0YS5CRUdJTk5JTkc7Ci0JCWNvbnRyb2xzWzFdLnNldExheW91dERhdGEoZ3JpZERhdGEpOwotCi0JCWNvbnRyb2xzWzJdLnNldExheW91dERhdGEobmV3IEdyaWREYXRhKEdyaWREYXRhLkZJTExfSE9SSVpPTlRBTCkpOwotCQlyZW1vdmVBbGlnblJpZ2h0KGNvbnRyb2xzWzJdKTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9KZGJjUmVhZENvbm5lY3Rpb25zU2hhcmVkQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0pkYmNSZWFkQ29ubmVjdGlvbnNTaGFyZWRDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMGRiODlhNy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0pkYmNSZWFkQ29ubmVjdGlvbnNTaGFyZWRDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDk2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmNvbm5lY3Rpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNvbm5lY3Rpb24uQ29ubmVjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLlBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5vc2dpLnV0aWwuTkxTOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBSZWFkQ29ubmVjdGlvbnNTaGFyZWRDb21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIEpkYmNSZWFkQ29ubmVjdGlvbnNTaGFyZWRDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPENvbm5lY3Rpb24+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5SZWFkQ29ubmVjdGlvbnNTaGFyZWRDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudENvbnRyb2xsZXIKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudAotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgSmRiY1JlYWRDb25uZWN0aW9uc1NoYXJlZENvbXBvc2l0ZSgKLQkJCQkJUGFuZTw/IGV4dGVuZHMgQ29ubmVjdGlvbj4gcGFyZW50Q29tcG9zaXRlLAotCQkJCQlDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRSZWFkQ29ubmVjdGlvbnNTaGFyZWRIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPENvbm5lY3Rpb24sIEJvb2xlYW4+KGdldFN1YmplY3RIb2xkZXIoKSwgQ29ubmVjdGlvbi5SRUFEX0NPTk5FQ1RJT05TX1NIQVJFRF9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRSZWFkQ29ubmVjdGlvbnNTaGFyZWQoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCXN1YmplY3Quc2V0UmVhZENvbm5lY3Rpb25zU2hhcmVkKHZhbHVlKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzdWJqZWN0Q2hhbmdlZCgpIHsKLQkJCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0JCQkJc3VwZXIuc3ViamVjdENoYW5nZWQoKTsKLQkJCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0KLQkJCQkvLyBNYWtlIHN1cmUgdGhlIGRlZmF1bHQgdmFsdWUgaXMgYXBwZW5kZWQgdG8gdGhlIHRleHQKLQkJCQlpZiAob2xkVmFsdWUgPT0gbmV3VmFsdWUgJiYgbmV3VmFsdWUgPT0gbnVsbCkgewotCQkJCQl0aGlzLmZpcmVBc3BlY3RDaGFuZ2UoQm9vbGVhbi5UUlVFLCBuZXdWYWx1ZSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRSZWFkQ29ubmVjdGlvbnNTaGFyZWRTdHJpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbiwgU3RyaW5nPihidWlsZFJlYWRDb25uZWN0aW9uc1NoYXJlZEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlpZiAoKGdldFN1YmplY3QoKSAhPSBudWxsKSAmJiAodmFsdWUgPT0gbnVsbCkpIHsKLQkJCQkJQm9vbGVhbiBkZWZhdWx0VmFsdWUgPSBnZXRTdWJqZWN0KCkuZ2V0RGVmYXVsdFJlYWRDb25uZWN0aW9uc1NoYXJlZCgpOwotCQkJCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCQkJCVN0cmluZyBkZWZhdWx0U3RyaW5nVmFsdWUgPSBkZWZhdWx0VmFsdWUgPyBFY2xpcHNlTGlua1VpTWVzc2FnZXMuQm9vbGVhbl9UcnVlIDogRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fRmFsc2U7Ci0JCQkJCQlyZXR1cm4gTkxTLmJpbmQoRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9yZWFkQ29ubmVjdGlvbnNTaGFyZWRMYWJlbERlZmF1bHQsIGRlZmF1bHRTdHJpbmdWYWx1ZSk7Ci0JCQkJCX0KLQkJCQl9Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfcmVhZENvbm5lY3Rpb25zU2hhcmVkTGFiZWw7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJdGhpcy5hZGRUcmlTdGF0ZUNoZWNrQm94V2l0aERlZmF1bHQoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3JlYWRDb25uZWN0aW9uc1NoYXJlZExhYmVsLAotCQkJdGhpcy5idWlsZFJlYWRDb25uZWN0aW9uc1NoYXJlZEhvbGRlcigpLAotCQkJdGhpcy5idWlsZFJlYWRDb25uZWN0aW9uc1NoYXJlZFN0cmluZ0hvbGRlcigpLAotCQkJbnVsbAotLy8JCQlFY2xpcHNlTGlua0hlbHBDb250ZXh0SWRzLgotCQkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vSmRiY1dyaXRlQ29ubmVjdGlvblByb3BlcnRpZXNDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vSmRiY1dyaXRlQ29ubmVjdGlvblByb3BlcnRpZXNDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMmQ5OTk3Ni4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0pkYmNXcml0ZUNvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1OCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSoKLSogQ29udHJpYnV0b3JzOgotKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY29ubmVjdGlvbjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY29ubmVjdGlvbi5Db25uZWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuU1dUOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5ncmFwaGljcy5Qb2ludDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWREYXRhOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkJ1dHRvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogIEpkYmNXcml0ZUNvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlCi0gKi8KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIEpkYmNXcml0ZUNvbm5lY3Rpb25Qcm9wZXJ0aWVzQ29tcG9zaXRlIGV4dGVuZHMgUGFuZTxDb25uZWN0aW9uPgotewotCXB1YmxpYyBKZGJjV3JpdGVDb25uZWN0aW9uUHJvcGVydGllc0NvbXBvc2l0ZShQYW5lPENvbm5lY3Rpb24+IHBhcmVudENvbXBvc2l0ZSwgQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudENvbXBvc2l0ZSwgcGFyZW50LCBmYWxzZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJY29udGFpbmVyID0gdGhpcy5hZGRTZWN0aW9uKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl93cml0ZUNvbm5lY3Rpb25zU2VjdGlvblRpdGxlCi0JCSk7Ci0KLQkJR3JpZERhdGEgZGF0YSA9IChHcmlkRGF0YSkgY29udGFpbmVyLmdldExheW91dERhdGEoKTsKLQkJZGF0YS52ZXJ0aWNhbEFsaWdubWVudCA9IFNXVC5UT1A7Ci0KLQkJZGF0YSA9IChHcmlkRGF0YSkgZ2V0Q29udHJvbCgpLmdldExheW91dERhdGEoKTsKLQkJZGF0YS52ZXJ0aWNhbEFsaWdubWVudCA9IFNXVC5UT1A7Ci0KLQkJLy8gVGhpcyB3aWxsIGFkZCBzcGFjZSB0byBoYXZlIHRoZSBzYW1lIGxheW91dCB0aGFuIHJlYWQgY29ubmVjdGlvbiBwb29sCi0JCUJ1dHRvbiBzcGFjZSA9IHRoaXMuZ2V0V2lkZ2V0RmFjdG9yeSgpLmNyZWF0ZUNoZWNrQm94KGNvbnRhaW5lciwgIm0iKTsKLQkJUG9pbnQgc2l6ZSA9IHNwYWNlLmNvbXB1dGVTaXplKFNXVC5ERUZBVUxULCBTV1QuREVGQVVMVCk7Ci0JCWNvbnRhaW5lciA9IHRoaXMuYWRkU3ViUGFuZShjb250YWluZXIsIHNpemUueSArIDUpOwotCQlzcGFjZS5kaXNwb3NlKCk7Ci0KLQkJLy8gV3JpdGUgQ29ubmVjdGlvbnMgTWluaW11bQotCQluZXcgSmRiY1dyaXRlQ29ubmVjdGlvbnNNaW5Db21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQotCQkvLyBXcml0ZSBDb25uZWN0aW9ucyBNYXhpbXVtCi0JCW5ldyBKZGJjV3JpdGVDb25uZWN0aW9uc01heENvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vSmRiY1dyaXRlQ29ubmVjdGlvbnNNYXhDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vSmRiY1dyaXRlQ29ubmVjdGlvbnNNYXhDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjkyMjI0NS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0pkYmNXcml0ZUNvbm5lY3Rpb25zTWF4Q29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNjkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY29ubmVjdGlvbjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY29ubmVjdGlvbi5Db25uZWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuTGFiZWxlZENvbnRyb2xVcGRhdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLkxhYmVsZWRMYWJlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWREYXRhOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db250cm9sOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkxhYmVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLlNwaW5uZXI7Ci0KLS8qKgotICogSmRiY1dyaXRlQ29ubmVjdGlvbnNNYXhDb21wb3NpdGUKLSAqLwotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgY2xhc3MgSmRiY1dyaXRlQ29ubmVjdGlvbnNNYXhDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPENvbm5lY3Rpb24+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5KZGJjV3JpdGVDb25uZWN0aW9uc01heENvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50Q29udHJvbGxlcgotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50Ci0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBKZGJjV3JpdGVDb25uZWN0aW9uc01heENvbXBvc2l0ZShQYW5lPENvbm5lY3Rpb24+IHBhcmVudENvbXBvc2l0ZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4gYnVpbGRXcml0ZUNvbm5lY3Rpb25zTWF4SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDb25uZWN0aW9uLCBJbnRlZ2VyPihnZXRTdWJqZWN0SG9sZGVyKCksIENvbm5lY3Rpb24uV1JJVEVfQ09OTkVDVElPTlNfTUFYX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBJbnRlZ2VyIGJ1aWxkVmFsdWVfKCkgewotCQkJCUludGVnZXIgdmFsdWUgPSBzdWJqZWN0LmdldFdyaXRlQ29ubmVjdGlvbnNNYXgoKTsKLQotCQkJCWlmICh2YWx1ZSA9PSBudWxsKSB7Ci0JCQkJCXZhbHVlID0gLTE7Ci0JCQkJfQotCQkJCXJldHVybiB2YWx1ZTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oSW50ZWdlciB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZSA9PSAtMSkgewotCQkJCQl2YWx1ZSA9IG51bGw7Ci0JCQkJfQotCQkJCXN1YmplY3Quc2V0V3JpdGVDb25uZWN0aW9uc01heCh2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4gYnVpbGREZWZhdWx0V3JpdGVDb25uZWN0aW9uc01heEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29ubmVjdGlvbiwgSW50ZWdlcj4oZ2V0U3ViamVjdEhvbGRlcigpLCAiIikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSW50ZWdlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXREZWZhdWx0V3JpdGVDb25uZWN0aW9uc01heCgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHN1YmplY3RDaGFuZ2VkKCkgewotCQkJCU9iamVjdCBvbGRWYWx1ZSA9IHRoaXMuZ2V0VmFsdWUoKTsKLQkJCQlzdXBlci5zdWJqZWN0Q2hhbmdlZCgpOwotCQkJCU9iamVjdCBuZXdWYWx1ZSA9IHRoaXMuZ2V0VmFsdWUoKTsKLQotCQkJCS8vIE1ha2Ugc3VyZSB0aGUgZGVmYXVsdCB2YWx1ZSBpcyBhcHBlbmRlZCB0byB0aGUgdGV4dAotCQkJCWlmIChvbGRWYWx1ZSA9PSBuZXdWYWx1ZSAmJiBuZXdWYWx1ZSA9PSBudWxsKSB7Ci0JCQkJCXRoaXMuZmlyZUFzcGVjdENoYW5nZShJbnRlZ2VyLk1JTl9WQUxVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbnRyb2wgYWRkRGVmYXVsdFdyaXRlQ29ubmVjdGlvbnNNYXhMYWJlbChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJTGFiZWwgbGFiZWwgPSBhZGRMYWJlbCgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5EZWZhdWx0V2l0aG91dFZhbHVlCi0JCSk7Ci0KLQkJbmV3IExhYmVsZWRDb250cm9sVXBkYXRlcigKLQkJCW5ldyBMYWJlbGVkTGFiZWwobGFiZWwpLAotCQkJYnVpbGREZWZhdWx0V3JpdGVDb25uZWN0aW9uc01heExhYmVsSG9sZGVyKCkKLQkJKTsKLQotCQlyZXR1cm4gbGFiZWw7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZERlZmF1bHRXcml0ZUNvbm5lY3Rpb25zTWF4TGFiZWxIb2xkZXIoKSB7Ci0KLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyLCBTdHJpbmc+KGJ1aWxkRGVmYXVsdFdyaXRlQ29ubmVjdGlvbnNNYXhIb2xkZXIoKSkgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKEludGVnZXIgdmFsdWUpIHsKLQotCQkJCWlmICh2YWx1ZSAhPSBudWxsKSB7Ci0JCQkJCXJldHVybiBOTFMuYmluZChFY2xpcHNlTGlua1VpTWVzc2FnZXMuRGVmYXVsdFdpdGhWYWx1ZSwgdmFsdWUpOwotCQkJCX0KLQotCQkJCXJldHVybiAiIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlTcGlubmVyIHNwaW5uZXIgPSB0aGlzLmFkZExhYmVsZWRTcGlubmVyKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl93cml0ZUNvbm5lY3Rpb25zTWF4TGFiZWwsCi0JCQl0aGlzLmJ1aWxkV3JpdGVDb25uZWN0aW9uc01heEhvbGRlcigpLAotCQkJLTEsCi0JCQktMSwKLQkJCUludGVnZXIuTUFYX1ZBTFVFLAotCQkJdGhpcy5hZGREZWZhdWx0V3JpdGVDb25uZWN0aW9uc01heExhYmVsKGNvbnRhaW5lciksCi0JCQludWxsCi0JCSk7Ci0KLQkJdXBkYXRlR3JpZERhdGEoY29udGFpbmVyLCBzcGlubmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBDaGFuZ2VzIHRoZSBsYXlvdXQgb2YgdGhlIGdpdmVuIGNvbnRhaW5lciBieSBjaGFuZ2luZyB3aGljaCB3aWRnZXQgd2lsbAotCSAqIGdyYWIgdGhlIGV4Y2VzcyBvZiBob3Jpem9udGFsIHNwYWNlLiBCeSBkZWZhdWx0LCB0aGUgY2VudGVyIGNvbnRyb2wgZ3JhYnMKLQkgKiB0aGUgZXhjZXNzIHNwYWNlLCB3ZSBjaGFuZ2UgaXQgdG8gYmUgdGhlIHJpZ2h0IGNvbnRyb2wuCi0JICoKLQkgKiBAcGFyYW0gY29udGFpbmVyIFRoZSBjb250YWluZXIgY29udGFpbmluZyB0aGUgY29udHJvbHMgbmVlZGluZyB0aGVpcgotCSAqIDxjb2RlPkdyaWREYXRhPC9jb2RlPiB0byBiZSBtb2RpZmllZCBmcm9tIHRoZSBkZWZhdWx0IHZhbHVlcwotCSAqIEBwYXJhbSBzcGlubmVyIFRoZSBzcGlubmVyIHRoYXQgZ290IGNyZWF0ZWQKLQkgKi8KLQlwcml2YXRlIHZvaWQgdXBkYXRlR3JpZERhdGEoQ29tcG9zaXRlIGNvbnRhaW5lciwgU3Bpbm5lciBzcGlubmVyKSB7Ci0KLQkJLy8gSXQgaXMgcG9zc2libGUgdGhlIHNwaW5uZXIncyBwYXJlbnQgaXMgbm90IHRoZSBjb250YWluZXIgb2YgdGhlCi0JCS8vIGxhYmVsLCBzcGlubmVyIGFuZCByaWdodCBjb250cm9sIChhIHBhbmUgaXMgc29tZXRpbWVzIHJlcXVpcmVkIGZvcgotCQkvLyBwYWludGluZyB0aGUgc3Bpbm5lcidzIGJvcmRlcikKLQkJQ29tcG9zaXRlIHBhbmVDb250YWluZXIgPSBzcGlubmVyLmdldFBhcmVudCgpOwotCi0JCXdoaWxlIChjb250YWluZXIgIT0gcGFuZUNvbnRhaW5lci5nZXRQYXJlbnQoKSkgewotCQkJcGFuZUNvbnRhaW5lciA9IHBhbmVDb250YWluZXIuZ2V0UGFyZW50KCk7Ci0JCX0KLQotCQlDb250cm9sW10gY29udHJvbHMgPSBwYW5lQ29udGFpbmVyLmdldENoaWxkcmVuKCk7Ci0KLQkJR3JpZERhdGEgZ3JpZERhdGEgPSBuZXcgR3JpZERhdGEoKTsKLQkJZ3JpZERhdGEuZ3JhYkV4Y2Vzc0hvcml6b250YWxTcGFjZSA9IGZhbHNlOwotCQlncmlkRGF0YS5ob3Jpem9udGFsQWxpZ25tZW50ICAgICAgID0gR3JpZERhdGEuQkVHSU5OSU5HOwotCQljb250cm9sc1sxXS5zZXRMYXlvdXREYXRhKGdyaWREYXRhKTsKLQotCQljb250cm9sc1syXS5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5GSUxMX0hPUklaT05UQUwpKTsKLQkJcmVtb3ZlQWxpZ25SaWdodChjb250cm9sc1syXSk7Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vSmRiY1dyaXRlQ29ubmVjdGlvbnNNaW5Db21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vSmRiY1dyaXRlQ29ubmVjdGlvbnNNaW5Db21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNGY0ZDdlNC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL0pkYmNXcml0ZUNvbm5lY3Rpb25zTWluQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNjkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY29ubmVjdGlvbjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY29ubmVjdGlvbi5Db25uZWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuTGFiZWxlZENvbnRyb2xVcGRhdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLkxhYmVsZWRMYWJlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWREYXRhOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db250cm9sOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkxhYmVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLlNwaW5uZXI7Ci0KLS8qKgotICogSmRiY1dyaXRlQ29ubmVjdGlvbnNNaW5Db21wb3NpdGUKLSAqLwotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgY2xhc3MgSmRiY1dyaXRlQ29ubmVjdGlvbnNNaW5Db21wb3NpdGUgZXh0ZW5kcyBQYW5lPENvbm5lY3Rpb24+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5KZGJjV3JpdGVDb25uZWN0aW9uc01pbkNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50Q29udHJvbGxlcgotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50Ci0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBKZGJjV3JpdGVDb25uZWN0aW9uc01pbkNvbXBvc2l0ZShQYW5lPENvbm5lY3Rpb24+IHBhcmVudENvbXBvc2l0ZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4gYnVpbGRXcml0ZUNvbm5lY3Rpb25zTWluSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDb25uZWN0aW9uLCBJbnRlZ2VyPihnZXRTdWJqZWN0SG9sZGVyKCksIENvbm5lY3Rpb24uV1JJVEVfQ09OTkVDVElPTlNfTUlOX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBJbnRlZ2VyIGJ1aWxkVmFsdWVfKCkgewotCQkJCUludGVnZXIgdmFsdWUgPSBzdWJqZWN0LmdldFdyaXRlQ29ubmVjdGlvbnNNaW4oKTsKLQotCQkJCWlmICh2YWx1ZSA9PSBudWxsKSB7Ci0JCQkJCXZhbHVlID0gLTE7Ci0JCQkJfQotCQkJCXJldHVybiB2YWx1ZTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oSW50ZWdlciB2YWx1ZSkgewotCQkJCWlmICh2YWx1ZSA9PSAtMSkgewotCQkJCQl2YWx1ZSA9IG51bGw7Ci0JCQkJfQotCQkJCXN1YmplY3Quc2V0V3JpdGVDb25uZWN0aW9uc01pbih2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4gYnVpbGREZWZhdWx0V3JpdGVDb25uZWN0aW9uc01pbkhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29ubmVjdGlvbiwgSW50ZWdlcj4oZ2V0U3ViamVjdEhvbGRlcigpLCAiIikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSW50ZWdlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXREZWZhdWx0V3JpdGVDb25uZWN0aW9uc01pbigpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHN1YmplY3RDaGFuZ2VkKCkgewotCQkJCU9iamVjdCBvbGRWYWx1ZSA9IHRoaXMuZ2V0VmFsdWUoKTsKLQkJCQlzdXBlci5zdWJqZWN0Q2hhbmdlZCgpOwotCQkJCU9iamVjdCBuZXdWYWx1ZSA9IHRoaXMuZ2V0VmFsdWUoKTsKLQotCQkJCS8vIE1ha2Ugc3VyZSB0aGUgZGVmYXVsdCB2YWx1ZSBpcyBhcHBlbmRlZCB0byB0aGUgdGV4dAotCQkJCWlmIChvbGRWYWx1ZSA9PSBuZXdWYWx1ZSAmJiBuZXdWYWx1ZSA9PSBudWxsKSB7Ci0JCQkJCXRoaXMuZmlyZUFzcGVjdENoYW5nZShJbnRlZ2VyLk1JTl9WQUxVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbnRyb2wgYWRkRGVmYXVsdFdyaXRlQ29ubmVjdGlvbnNNaW5MYWJlbChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJTGFiZWwgbGFiZWwgPSBhZGRMYWJlbCgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5EZWZhdWx0V2l0aG91dFZhbHVlCi0JCSk7Ci0KLQkJbmV3IExhYmVsZWRDb250cm9sVXBkYXRlcigKLQkJCW5ldyBMYWJlbGVkTGFiZWwobGFiZWwpLAotCQkJYnVpbGREZWZhdWx0V3JpdGVDb25uZWN0aW9uc01pbkxhYmVsSG9sZGVyKCkKLQkJKTsKLQotCQlyZXR1cm4gbGFiZWw7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZERlZmF1bHRXcml0ZUNvbm5lY3Rpb25zTWluTGFiZWxIb2xkZXIoKSB7Ci0KLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyLCBTdHJpbmc+KGJ1aWxkRGVmYXVsdFdyaXRlQ29ubmVjdGlvbnNNaW5Ib2xkZXIoKSkgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKEludGVnZXIgdmFsdWUpIHsKLQotCQkJCWlmICh2YWx1ZSAhPSBudWxsKSB7Ci0JCQkJCXJldHVybiBOTFMuYmluZChFY2xpcHNlTGlua1VpTWVzc2FnZXMuRGVmYXVsdFdpdGhWYWx1ZSwgdmFsdWUpOwotCQkJCX0KLQotCQkJCXJldHVybiAiIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlTcGlubmVyIHNwaW5uZXIgPSB0aGlzLmFkZExhYmVsZWRTcGlubmVyKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl93cml0ZUNvbm5lY3Rpb25zTWluTGFiZWwsCi0JCQl0aGlzLmJ1aWxkV3JpdGVDb25uZWN0aW9uc01pbkhvbGRlcigpLAotCQkJLTEsCi0JCQktMSwKLQkJCUludGVnZXIuTUFYX1ZBTFVFLAotCQkJdGhpcy5hZGREZWZhdWx0V3JpdGVDb25uZWN0aW9uc01pbkxhYmVsKGNvbnRhaW5lciksCi0JCQludWxsCi0JCSk7Ci0KLQkJdXBkYXRlR3JpZERhdGEoY29udGFpbmVyLCBzcGlubmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBDaGFuZ2VzIHRoZSBsYXlvdXQgb2YgdGhlIGdpdmVuIGNvbnRhaW5lciBieSBjaGFuZ2luZyB3aGljaCB3aWRnZXQgd2lsbAotCSAqIGdyYWIgdGhlIGV4Y2VzcyBvZiBob3Jpem9udGFsIHNwYWNlLiBCeSBkZWZhdWx0LCB0aGUgY2VudGVyIGNvbnRyb2wgZ3JhYnMKLQkgKiB0aGUgZXhjZXNzIHNwYWNlLCB3ZSBjaGFuZ2UgaXQgdG8gYmUgdGhlIHJpZ2h0IGNvbnRyb2wuCi0JICoKLQkgKiBAcGFyYW0gY29udGFpbmVyIFRoZSBjb250YWluZXIgY29udGFpbmluZyB0aGUgY29udHJvbHMgbmVlZGluZyB0aGVpcgotCSAqIDxjb2RlPkdyaWREYXRhPC9jb2RlPiB0byBiZSBtb2RpZmllZCBmcm9tIHRoZSBkZWZhdWx0IHZhbHVlcwotCSAqIEBwYXJhbSBzcGlubmVyIFRoZSBzcGlubmVyIHRoYXQgZ290IGNyZWF0ZWQKLQkgKi8KLQlwcml2YXRlIHZvaWQgdXBkYXRlR3JpZERhdGEoQ29tcG9zaXRlIGNvbnRhaW5lciwgU3Bpbm5lciBzcGlubmVyKSB7Ci0KLQkJLy8gSXQgaXMgcG9zc2libGUgdGhlIHNwaW5uZXIncyBwYXJlbnQgaXMgbm90IHRoZSBjb250YWluZXIgb2YgdGhlCi0JCS8vIGxhYmVsLCBzcGlubmVyIGFuZCByaWdodCBjb250cm9sIChhIHBhbmUgaXMgc29tZXRpbWVzIHJlcXVpcmVkIGZvcgotCQkvLyBwYWludGluZyB0aGUgc3Bpbm5lcidzIGJvcmRlcikKLQkJQ29tcG9zaXRlIHBhbmVDb250YWluZXIgPSBzcGlubmVyLmdldFBhcmVudCgpOwotCi0JCXdoaWxlIChjb250YWluZXIgIT0gcGFuZUNvbnRhaW5lci5nZXRQYXJlbnQoKSkgewotCQkJcGFuZUNvbnRhaW5lciA9IHBhbmVDb250YWluZXIuZ2V0UGFyZW50KCk7Ci0JCX0KLQotCQlDb250cm9sW10gY29udHJvbHMgPSBwYW5lQ29udGFpbmVyLmdldENoaWxkcmVuKCk7Ci0KLQkJR3JpZERhdGEgZ3JpZERhdGEgPSBuZXcgR3JpZERhdGEoKTsKLQkJZ3JpZERhdGEuZ3JhYkV4Y2Vzc0hvcml6b250YWxTcGFjZSA9IGZhbHNlOwotCQlncmlkRGF0YS5ob3Jpem9udGFsQWxpZ25tZW50ICAgICAgID0gR3JpZERhdGEuQkVHSU5OSU5HOwotCQljb250cm9sc1sxXS5zZXRMYXlvdXREYXRhKGdyaWREYXRhKTsKLQotCQljb250cm9sc1syXS5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5GSUxMX0hPUklaT05UQUwpKTsKLQkJcmVtb3ZlQWxpZ25SaWdodChjb250cm9sc1syXSk7Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vTmF0aXZlU3FsQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL05hdGl2ZVNxbENvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2YjA5YjYxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vTmF0aXZlU3FsQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw5NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jb25uZWN0aW9uOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5jb25uZWN0aW9uLkNvbm5lY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogTmF0aXZlU3FsQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBOYXRpdmVTcWxDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPENvbm5lY3Rpb24+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5OYXRpdmVTcWxDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudENvbnRyb2xsZXIKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudAotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgTmF0aXZlU3FsQ29tcG9zaXRlKAotCQkJCQlQYW5lPD8gZXh0ZW5kcyBDb25uZWN0aW9uPiBwYXJlbnRDb21wb3NpdGUsCi0JCQkJCUNvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRDb21wb3NpdGUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZE5hdGl2ZVNxbEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q29ubmVjdGlvbiwgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDb25uZWN0aW9uLk5BVElWRV9TUUxfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3QuZ2V0TmF0aXZlU3FsKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlzdWJqZWN0LnNldE5hdGl2ZVNxbCh2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc3ViamVjdENoYW5nZWQoKSB7Ci0JCQkJT2JqZWN0IG9sZFZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCQkJCXN1cGVyLnN1YmplY3RDaGFuZ2VkKCk7Ci0JCQkJT2JqZWN0IG5ld1ZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCi0JCQkJLy8gTWFrZSBzdXJlIHRoZSBkZWZhdWx0IHZhbHVlIGlzIGFwcGVuZGVkIHRvIHRoZSB0ZXh0Ci0JCQkJaWYgKG9sZFZhbHVlID09IG5ld1ZhbHVlICYmIG5ld1ZhbHVlID09IG51bGwpIHsKLQkJCQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKEJvb2xlYW4uVFJVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkTmF0aXZlU3FsU3RyaW5nSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4sIFN0cmluZz4oYnVpbGROYXRpdmVTcWxIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShCb29sZWFuIHZhbHVlKSB7Ci0JCQkJaWYgKChnZXRTdWJqZWN0KCkgIT0gbnVsbCkgJiYgKHZhbHVlID09IG51bGwpKSB7Ci0JCQkJCUJvb2xlYW4gZGVmYXVsdFZhbHVlID0gZ2V0U3ViamVjdCgpLmdldERlZmF1bHROYXRpdmVTcWwoKTsKLQkJCQkJaWYgKGRlZmF1bHRWYWx1ZSAhPSBudWxsKSB7Ci0JCQkJCQlTdHJpbmcgZGVmYXVsdFN0cmluZ1ZhbHVlID0gZGVmYXVsdFZhbHVlID8gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fVHJ1ZSA6IEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5Cb29sZWFuX0ZhbHNlOwotCQkJCQkJcmV0dXJuIE5MUy5iaW5kKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfbmF0aXZlU3FsTGFiZWxEZWZhdWx0LCBkZWZhdWx0U3RyaW5nVmFsdWUpOwotCQkJCQl9Ci0JCQkJfQotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX25hdGl2ZVNxbExhYmVsOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXRoaXMuYWRkVHJpU3RhdGVDaGVja0JveFdpdGhEZWZhdWx0KAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYl9uYXRpdmVTcWxMYWJlbCwKLQkJCXRoaXMuYnVpbGROYXRpdmVTcWxIb2xkZXIoKSwKLQkJCXRoaXMuYnVpbGROYXRpdmVTcWxTdHJpbmdIb2xkZXIoKSwKLQkJCW51bGwKLS8vCQkJRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcy4KLQkJKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL1BlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYi5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzUzOWYxZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jb25uZWN0aW9uL1BlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYi5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmNvbm5lY3Rpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmNvbm5lY3Rpb24uQ29ubmVjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYVBhZ2VDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5TV1Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLkltYWdlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuR3JpZERhdGE7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkTGF5b3V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBQZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWIKLSAqLwotcHVibGljIGNsYXNzIFBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYgotCWV4dGVuZHMgRm9ybVBhbmU8Q29ubmVjdGlvbj4KLQlpbXBsZW1lbnRzIEpwYVBhZ2VDb21wb3NpdGUKLXsKLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycy9pbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0JcHVibGljIFBlcnNpc3RlbmNlWG1sQ29ubmVjdGlvblRhYigKLQkJCQlQcm9wZXJ0eVZhbHVlTW9kZWw8Q29ubmVjdGlvbj4gc3ViamVjdEhvbGRlciwgCi0JCQkJQ29tcG9zaXRlIHBhcmVudCwgCi0JCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCQotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQluZXcgRWNsaXBzZUxpbmtDb25uZWN0aW9uQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JfQotCi0JLy8gKioqKioqKioqKiBKcGFQYWdlQ29tcG9zaXRlIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQlwdWJsaWMgU3RyaW5nIGdldEhlbHBJRCgpIHsKLQkJcmV0dXJuIG51bGw7Ci0JfQotCi0JcHVibGljIEltYWdlIGdldFBhZ2VJbWFnZSgpIHsKLQkJcmV0dXJuIG51bGw7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXRQYWdlVGV4dCgpIHsKLQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbENvbm5lY3Rpb25UYWJfdGl0bGU7Ci0JfQotCi0JLy8gKioqKioqKioqKiBMYXlvdXQgKioqKioqKioqKgotCUBPdmVycmlkZQotCXByb3RlY3RlZCBDb21wb3NpdGUgYWRkQ29udGFpbmVyKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJR3JpZExheW91dCBsYXlvdXQgPSBuZXcgR3JpZExheW91dCgxLCB0cnVlKTsKLQkJbGF5b3V0Lm1hcmdpbkhlaWdodCA9IDA7Ci0JCWxheW91dC5tYXJnaW5XaWR0aCA9IDA7Ci0JCWxheW91dC5tYXJnaW5Ub3AgPSAwOwotCQlsYXlvdXQubWFyZ2luTGVmdCA9IDA7Ci0JCWxheW91dC5tYXJnaW5Cb3R0b20gPSAwOwotCQlsYXlvdXQubWFyZ2luUmlnaHQgPSAwOwotCQlsYXlvdXQudmVydGljYWxTcGFjaW5nID0gMTU7Ci0JCUNvbXBvc2l0ZSBjb250YWluZXIgPSB0aGlzLmFkZFBhbmUocGFyZW50LCBsYXlvdXQpOwotCQl0aGlzLnVwZGF0ZUdyaWREYXRhKGNvbnRhaW5lcik7Ci0JCXJldHVybiBjb250YWluZXI7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHVwZGF0ZUdyaWREYXRhKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJR3JpZERhdGEgZ3JpZERhdGEgPSBuZXcgR3JpZERhdGEoKTsKLQkJZ3JpZERhdGEuZ3JhYkV4Y2Vzc0hvcml6b250YWxTcGFjZSA9IHRydWU7Ci0JCWdyaWREYXRhLmdyYWJFeGNlc3NWZXJ0aWNhbFNwYWNlID0gdHJ1ZTsKLQkJZ3JpZERhdGEuaG9yaXpvbnRhbEFsaWdubWVudCA9IFNXVC5GSUxMOwotCQlncmlkRGF0YS52ZXJ0aWNhbEFsaWdubWVudCA9IFNXVC5GSUxMOwotCQljb250YWluZXIuc2V0TGF5b3V0RGF0YShncmlkRGF0YSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9UcmFuc2FjdGlvblR5cGVDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2Nvbm5lY3Rpb24vVHJhbnNhY3Rpb25UeXBlQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDM2YjY4OTIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY29ubmVjdGlvbi9UcmFuc2FjdGlvblR5cGVDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDExMSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jb25uZWN0aW9uOwotCi1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5wZXJzaXN0ZW5jZS5QZXJzaXN0ZW5jZVVuaXRUcmFuc2FjdGlvblR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5jb25uZWN0aW9uLkNvbm5lY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5FbnVtRm9ybUNvbWJvVmlld2VyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBUcmFuc2FjdGlvblR5cGVDb21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIFRyYW5zYWN0aW9uVHlwZUNvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPENvbm5lY3Rpb24+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5UcmFuc2FjdGlvblR5cGVDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudENvbnRyb2xsZXIKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudAotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgVHJhbnNhY3Rpb25UeXBlQ29tcG9zaXRlKAotCQkJCQlGb3JtUGFuZTw/IGV4dGVuZHMgQ29ubmVjdGlvbj4gcGFyZW50Q29tcG9zaXRlLAotCQkJCQlDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIoIHBhcmVudENvbXBvc2l0ZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIEVudW1Gb3JtQ29tYm9WaWV3ZXI8Q29ubmVjdGlvbiwgUGVyc2lzdGVuY2VVbml0VHJhbnNhY3Rpb25UeXBlPiBhZGRUcmFuc2FjdGlvblR5cGVDb21ibyhDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCXJldHVybiBuZXcgRW51bUZvcm1Db21ib1ZpZXdlcjxDb25uZWN0aW9uLCBQZXJzaXN0ZW5jZVVuaXRUcmFuc2FjdGlvblR5cGU+KHRoaXMsIGNvbnRhaW5lcikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBhZGRQcm9wZXJ0eU5hbWVzKENvbGxlY3Rpb248U3RyaW5nPiBwcm9wZXJ0eU5hbWVzKSB7Ci0JCQkJc3VwZXIuYWRkUHJvcGVydHlOYW1lcyhwcm9wZXJ0eU5hbWVzKTsKLQkJCQlwcm9wZXJ0eU5hbWVzLmFkZChDb25uZWN0aW9uLlRSQU5TQUNUSU9OX1RZUEVfUFJPUEVSVFkpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBQZXJzaXN0ZW5jZVVuaXRUcmFuc2FjdGlvblR5cGVbXSBnZXRDaG9pY2VzKCkgewotCQkJCXJldHVybiBQZXJzaXN0ZW5jZVVuaXRUcmFuc2FjdGlvblR5cGUudmFsdWVzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFBlcnNpc3RlbmNlVW5pdFRyYW5zYWN0aW9uVHlwZSBnZXREZWZhdWx0VmFsdWUoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXREZWZhdWx0VHJhbnNhY3Rpb25UeXBlKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBkaXNwbGF5U3RyaW5nKFBlcnNpc3RlbmNlVW5pdFRyYW5zYWN0aW9uVHlwZSB2YWx1ZSkgewotCQkJCXJldHVybiBidWlsZERpc3BsYXlTdHJpbmcoRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLmNsYXNzLCBUcmFuc2FjdGlvblR5cGVDb21wb3NpdGUudGhpcywgdmFsdWUpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBQZXJzaXN0ZW5jZVVuaXRUcmFuc2FjdGlvblR5cGUgZ2V0VmFsdWUoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXRUcmFuc2FjdGlvblR5cGUoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZShQZXJzaXN0ZW5jZVVuaXRUcmFuc2FjdGlvblR5cGUgdmFsdWUpIHsKLQkJCQlnZXRTdWJqZWN0KCkuc2V0VHJhbnNhY3Rpb25UeXBlKHZhbHVlKTsKLQotCQkJCWlmICh2YWx1ZSA9PSBQZXJzaXN0ZW5jZVVuaXRUcmFuc2FjdGlvblR5cGUuUkVTT1VSQ0VfTE9DQUwpIHsKLQkJCQkJY2xlYXJKVEFQcm9wZXJ0aWVzKCk7Ci0JCQkJfQotCQkJCWVsc2UgewotCQkJCQljbGVhclJlc291cmNlTG9jYWxQcm9wZXJ0aWVzKCk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgdm9pZCBjbGVhckpUQVByb3BlcnRpZXMoKSB7Ci0JCWdldFN1YmplY3QoKS5zZXRKdGFEYXRhU291cmNlKG51bGwpOwotCX0KLQotCXByaXZhdGUgdm9pZCBjbGVhclJlc291cmNlTG9jYWxQcm9wZXJ0aWVzKCkgewotCQlDb25uZWN0aW9uIGNvbm5lY3Rpb24gPSBnZXRTdWJqZWN0KCk7Ci0JCWNvbm5lY3Rpb24uc2V0Tm9uSnRhRGF0YVNvdXJjZShudWxsKTsKLQkJY29ubmVjdGlvbi5zZXREcml2ZXIobnVsbCk7Ci0JCWNvbm5lY3Rpb24uc2V0VXJsKG51bGwpOwotCQljb25uZWN0aW9uLnNldFVzZXIobnVsbCk7Ci0JCWNvbm5lY3Rpb24uc2V0UGFzc3dvcmQobnVsbCk7Ci0JCWNvbm5lY3Rpb24uc2V0QmluZFBhcmFtZXRlcnMobnVsbCk7Ci0JCWNvbm5lY3Rpb24uc2V0V3JpdGVDb25uZWN0aW9uc01heChudWxsKTsKLQkJY29ubmVjdGlvbi5zZXRXcml0ZUNvbm5lY3Rpb25zTWluKG51bGwpOwotCQljb25uZWN0aW9uLnNldFJlYWRDb25uZWN0aW9uc01heChudWxsKTsKLQkJY29ubmVjdGlvbi5zZXRSZWFkQ29ubmVjdGlvbnNNaW4obnVsbCk7Ci0JCWNvbm5lY3Rpb24uc2V0UmVhZENvbm5lY3Rpb25zU2hhcmVkKG51bGwpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoIENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQl0aGlzLmFkZExhYmVsZWRDb21wb3NpdGUoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDb25uZWN0aW9uVGFiX3RyYW5zYWN0aW9uVHlwZUxhYmVsLAotCQkJdGhpcy5hZGRUcmFuc2FjdGlvblR5cGVDb21ibyggY29udGFpbmVyKSwKLQkJCW51bGwJCS8vIFRPRE8gSUpwYUhlbHBDb250ZXh0SWRzLgotCQkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vQ3VzdG9taXplckNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9DdXN0b21pemVyQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDRkNzE4NmYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9DdXN0b21pemVyQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw5NCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSogCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcGFQcm9qZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmNvbnRleHQuQ3VzdG9taXplcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb24uQ3VzdG9taXphdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkNsYXNzQ2hvb3NlclBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqICBDdXN0b21pemVyQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBDdXN0b21pemVyQ29tcG9zaXRlIGV4dGVuZHMgUGFuZTxFbnRpdHlDdXN0b21pemVyUHJvcGVydGllcz4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkN1c3RvbWl6ZXJDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudFBhbmUgVGhlIHBhcmVudCBwYW5lIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBDdXN0b21pemVyQ29tcG9zaXRlKFBhbmU8PyBleHRlbmRzIEVudGl0eUN1c3RvbWl6ZXJQcm9wZXJ0aWVzPiBwYXJlbnRQYW5lLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudFBhbmUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBDbGFzc0Nob29zZXJQYW5lPEVudGl0eUN1c3RvbWl6ZXJQcm9wZXJ0aWVzPiBpbml0aWFsaXplQ2xhc3NDaG9vc2VyKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlyZXR1cm4gbmV3IENsYXNzQ2hvb3NlclBhbmU8RW50aXR5Q3VzdG9taXplclByb3BlcnRpZXM+KHRoaXMsIGNvbnRhaW5lcikgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkVGV4dEhvbGRlcigpIHsKLQkJCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxFbnRpdHlDdXN0b21pemVyUHJvcGVydGllcywgU3RyaW5nPigKLQkJCQkJCQlnZXRTdWJqZWN0SG9sZGVyKCksIEN1c3RvbWl6YXRpb24uREVTQ1JJUFRPUl9DVVNUT01JWkVSX1BST1BFUlRZKSB7Ci0JCQkJCUBPdmVycmlkZQotCQkJCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXREZXNjcmlwdG9yQ3VzdG9taXplcigpOwotCQkJCQl9Ci0KLQkJCQkJQE92ZXJyaWRlCi0JCQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhTdHJpbmcgdmFsdWUpIHsKLQotCQkJCQkJaWYgKHZhbHVlLmxlbmd0aCgpID09IDApIHsKLQkJCQkJCQl2YWx1ZSA9IG51bGw7Ci0JCQkJCQl9Ci0JCQkJCQl0aGlzLnN1YmplY3Quc2V0RGVzY3JpcHRvckN1c3RvbWl6ZXIodmFsdWUpOwotCQkJCQl9Ci0JCQkJfTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGdldENsYXNzTmFtZSgpIHsKLQkJCQlyZXR1cm4gZ2V0U3ViamVjdCgpLmdldERlc2NyaXB0b3JDdXN0b21pemVyKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBnZXRMYWJlbFRleHQoKSB7Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfY3VzdG9taXplckxhYmVsOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBKcGFQcm9qZWN0IGdldEpwYVByb2plY3QoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXRKcGFQcm9qZWN0KCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0Q2xhc3NOYW1lKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJCQlnZXRTdWJqZWN0KCkuc2V0RGVzY3JpcHRvckN1c3RvbWl6ZXIoY2xhc3NOYW1lKTsKLQkJCX0KLQkJCQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGdldFN1cGVySW50ZXJmYWNlTmFtZSgpIHsKLQkJCQlyZXR1cm4gQ3VzdG9taXplci5FQ0xJUFNFTElOS19ERVNDUklQVE9SX0NVU1RPTUlaRVJfQ0xBU1NfTkFNRTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJdGhpcy5pbml0aWFsaXplQ2xhc3NDaG9vc2VyKGNvbnRhaW5lcik7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9FY2xpcHNlTGlua0N1c3RvbWl6YXRpb25Db21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vRWNsaXBzZUxpbmtDdXN0b21pemF0aW9uQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDMzMmE3YzYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9FY2xpcHNlTGlua0N1c3RvbWl6YXRpb25Db21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDg2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0qIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0qIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotKgotKiBDb250cmlidXRvcnM6Ci0qICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jdXN0b21pemF0aW9uOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5jdXN0b21pemF0aW9uLkN1c3RvbWl6YXRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuU1dUOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuR3JpZERhdGE7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnVpLmZvcm1zLndpZGdldHMuRXhwYW5kYWJsZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS51aS5mb3Jtcy53aWRnZXRzLlNlY3Rpb247Ci0KLS8qKgotICogIFBlcnNpc3RlbmNlVW5pdEN1c3RvbWl6YXRpb25Db21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rQ3VzdG9taXphdGlvbkNvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPEN1c3RvbWl6YXRpb24+Ci17Ci0JcHVibGljIEVjbGlwc2VMaW5rQ3VzdG9taXphdGlvbkNvbXBvc2l0ZShGb3JtUGFuZTxDdXN0b21pemF0aW9uPiBzdWJqZWN0SG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBjb250YWluZXIpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIHBhcmVudCkgewotCQlTZWN0aW9uIHNlY3Rpb24gPSBnZXRXaWRnZXRGYWN0b3J5KCkuY3JlYXRlU2VjdGlvbihwYXJlbnQsIFNXVC5GTEFUIHwgRXhwYW5kYWJsZUNvbXBvc2l0ZS5USVRMRV9CQVIgfCBTZWN0aW9uLkRFU0NSSVBUSU9OKTsKLQkJc2VjdGlvbi5zZXRUZXh0KEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfc2VjdGlvblRpdGxlKTsKLQkJc2VjdGlvbi5zZXREZXNjcmlwdGlvbihFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3NlY3Rpb25EZXNjcmlwdGlvbik7Ci0JCXNlY3Rpb24uc2V0TGF5b3V0RGF0YShuZXcgR3JpZERhdGEoR3JpZERhdGEuRklMTF9CT1RIKSk7Ci0KLQkJQ29tcG9zaXRlIGNvbXBvc2l0ZSA9IHRoaXMuYWRkU3ViUGFuZShzZWN0aW9uKTsKLQkJc2VjdGlvbi5zZXRDbGllbnQoY29tcG9zaXRlKTsKLQotCQkvLyBEZWZhdWx0IHBhbmUKLQkJaW50IGdyb3VwQm94TWFyZ2luID0gdGhpcy5nZXRHcm91cEJveE1hcmdpbigpOwotCi0JCUNvbXBvc2l0ZSBkZWZhdWx0UGFuZSA9IHRoaXMuYWRkU3ViUGFuZSgKLQkJCWNvbXBvc2l0ZSwKLQkJCTAsIGdyb3VwQm94TWFyZ2luLCAwLCBncm91cEJveE1hcmdpbgotCQkpOwotCi0JCS8vIFdlYXZpbmcKLQkJbmV3IFdlYXZpbmdDb21wb3NpdGUodGhpcywgZGVmYXVsdFBhbmUpOwotCi0JCS8vIFdlYXZpbmcgTGF6eQotCQluZXcgV2VhdmluZ0xhenlDb21wb3NpdGUodGhpcywgZGVmYXVsdFBhbmUpOwotCi0JCS8vIFdlYXZpbmcgRmV0Y2ggR3JvdXBzCi0JCW5ldyBXZWF2aW5nRmV0Y2hHcm91cHNDb21wb3NpdGUodGhpcywgZGVmYXVsdFBhbmUpOwotCi0JCS8vIFdlYXZpbmcgSW50ZXJuYWwKLQkJbmV3IFdlYXZpbmdJbnRlcm5hbENvbXBvc2l0ZSh0aGlzLCBkZWZhdWx0UGFuZSk7Ci0KLQkJLy8gV2VhdmluZyBFYWdlcgotCQluZXcgV2VhdmluZ0VhZ2VyQ29tcG9zaXRlKHRoaXMsIGRlZmF1bHRQYW5lKTsKLQotCQkvLyBXZWF2aW5nIENoYW5nZSBUcmFja2luZwotCQluZXcgV2VhdmluZ0NoYW5nZVRyYWNraW5nQ29tcG9zaXRlKHRoaXMsIGRlZmF1bHRQYW5lKTsKLQotCQkvLyBUaHJvdyBFeGNlcHRpb25zCi0JCW5ldyBUaHJvd0V4Y2VwdGlvbnNDb21wb3NpdGUodGhpcywgZGVmYXVsdFBhbmUpOwotCi0JCS8vIEV4Y2VwdGlvbiBIYW5kbGVyCi0JCW5ldyBFeGNlcHRpb25IYW5kbGVyQ29tcG9zaXRlKHRoaXMsIGRlZmF1bHRQYW5lKTsKLQotCQkvLyBTZXNzaW9uIEN1c3RvbWl6ZXIKLQkJbmV3IFNlc3Npb25DdXN0b21pemVyc0NvbXBvc2l0ZSh0aGlzLCBjb21wb3NpdGUpOwotCi0JCS8vIEVudGl0aWVzTGlzdAotCQluZXcgRW50aXR5TGlzdENvbXBvc2l0ZSh0aGlzLCBjb21wb3NpdGUpOwotCi0JCS8vIFZhbGlkYXRpb24gT25seQotCQluZXcgVmFsaWRhdGlvbk9ubHlDb21wb3NpdGUodGhpcywgY29tcG9zaXRlKTsKLQotCQkvLyBQcm9maWxlcjoKLQkJbmV3IFByb2ZpbGVyQ29tcG9zaXRlKHRoaXMsIGNvbXBvc2l0ZSk7Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vRW50aXR5Q3VzdG9taXphdGlvblByb3BlcnR5Q29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jdXN0b21pemF0aW9uL0VudGl0eUN1c3RvbWl6YXRpb25Qcm9wZXJ0eUNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0N2NmODIzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vRW50aXR5Q3VzdG9taXphdGlvblByb3BlcnR5Q29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb24uQ3VzdG9taXphdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogRW50aXR5Q3VzdG9taXphdGlvblByb3BlcnR5Q29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBFbnRpdHlDdXN0b21pemF0aW9uUHJvcGVydHlDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPEVudGl0eUN1c3RvbWl6ZXJQcm9wZXJ0aWVzPiB7Ci0KLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkVudGl0eUN1c3RvbWl6YXRpb25Qcm9wZXJ0eUNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBzdWJqZWN0SG9sZGVyIFRoZSBob2xkZXIgb2YgdGhpcyBwYW5lJ3Mgc3ViamVjdAotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgRW50aXR5Q3VzdG9taXphdGlvblByb3BlcnR5Q29tcG9zaXRlKFBhbmU8Q3VzdG9taXphdGlvbj4gcGFyZW50Q29tcG9zaXRlLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUHJvcGVydHlWYWx1ZU1vZGVsPEVudGl0eUN1c3RvbWl6ZXJQcm9wZXJ0aWVzPiBzdWJqZWN0SG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudENvbXBvc2l0ZSwgc3ViamVjdEhvbGRlciwgcGFyZW50KTsKLQl9Ci0KLQkvKgotCSAqIChub24tSmF2YWRvYykKLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQkvLyBDdXN0b21pemVyCi0JCW5ldyBDdXN0b21pemVyQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JCQotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vRW50aXR5Q3VzdG9taXplclByb3BlcnRpZXMuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vRW50aXR5Q3VzdG9taXplclByb3BlcnRpZXMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjhmZmQwOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jdXN0b21pemF0aW9uL0VudGl0eUN1c3RvbWl6ZXJQcm9wZXJ0aWVzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMTQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jdXN0b21pemF0aW9uOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuSnBhUHJvamVjdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb24uQ3VzdG9taXphdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBFbnRpdHlDdXN0b21pemVyUHJvcGVydGllcwotICovCi1wdWJsaWMgY2xhc3MgRW50aXR5Q3VzdG9taXplclByb3BlcnRpZXMgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIHsKLQotCXByaXZhdGUgQ3VzdG9taXphdGlvbiBjdXN0b21pemF0aW9uOwotCQotCXByaXZhdGUgU3RyaW5nIGVudGl0eU5hbWU7Ci0KLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBERVNDUklQVE9SX0NVU1RPTUlaRVJfUFJPUEVSVFkgPSBDdXN0b21pemF0aW9uLkRFU0NSSVBUT1JfQ1VTVE9NSVpFUl9QUk9QRVJUWTsKLQkKLQlTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8Q3VzdG9taXphdGlvbj4gY3VzdG9taXphdGlvbkhvbGRlcjsKLQlQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBkZXNjcmlwdG9yQ3VzdG9taXplckhvbGRlcjsKLQlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGRlc2NyaXB0b3JDdXN0b21pemVyTGlzdGVuZXI7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQlwdWJsaWMgRW50aXR5Q3VzdG9taXplclByb3BlcnRpZXMoQ3VzdG9taXphdGlvbiBjdXN0b21pemF0aW9uLCBTdHJpbmcgZW50aXR5TmFtZSkgewotCQlzdXBlcigpOwotCQl0aGlzLmN1c3RvbWl6YXRpb24gPSBjdXN0b21pemF0aW9uOwotCQl0aGlzLmVudGl0eU5hbWUgPSBlbnRpdHlOYW1lOwotCQl0aGlzLmN1c3RvbWl6YXRpb25Ib2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPEN1c3RvbWl6YXRpb24+KHRoaXMuY3VzdG9taXphdGlvbik7Ci0KLQkJdGhpcy5kZXNjcmlwdG9yQ3VzdG9taXplckhvbGRlciA9IHRoaXMuYnVpbGREZXNjcmlwdG9yQ3VzdG9taXplckFBKHRoaXMuY3VzdG9taXphdGlvbkhvbGRlcik7Ci0JCXRoaXMuZGVzY3JpcHRvckN1c3RvbWl6ZXJMaXN0ZW5lciA9IHRoaXMuYnVpbGREZXNjcmlwdG9yQ3VzdG9taXplckNoYW5nZUxpc3RlbmVyKCk7Ci0JCXRoaXMuZGVzY3JpcHRvckN1c3RvbWl6ZXJIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMuZGVzY3JpcHRvckN1c3RvbWl6ZXJMaXN0ZW5lcik7Ci0JfQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0JcHVibGljIGJvb2xlYW4gZW50aXR5TmFtZUlzVmFsaWQoKSB7Ci0JCXJldHVybiAhU3RyaW5nVG9vbHMuc3RyaW5nSXNFbXB0eSh0aGlzLmVudGl0eU5hbWUpOwotCX0KLQotCXB1YmxpYyBTdHJpbmcgZ2V0RW50aXR5TmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMuZW50aXR5TmFtZTsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGdldERlc2NyaXB0b3JDdXN0b21pemVyKCkgewotCQlyZXR1cm4gdGhpcy5jdXN0b21pemF0aW9uLmdldERlc2NyaXB0b3JDdXN0b21pemVyKHRoaXMuZW50aXR5TmFtZSk7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXREZWZhdWx0RGVzY3JpcHRvckN1c3RvbWl6ZXIoKSB7Ci0JCXJldHVybiB0aGlzLmN1c3RvbWl6YXRpb24uZ2V0RGVmYXVsdERlc2NyaXB0b3JDdXN0b21pemVyKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0RGVzY3JpcHRvckN1c3RvbWl6ZXIoU3RyaW5nIGRlc2NyaXB0b3JDdXN0b21pemVyKSB7Ci0JCVN0cmluZyBvbGQgPSB0aGlzLmdldERlc2NyaXB0b3JDdXN0b21pemVyKCk7Ci0JCWlmICh0aGlzLmF0dHJpYnV0ZVZhbHVlSGFzQ2hhbmdlZChvbGQsIGRlc2NyaXB0b3JDdXN0b21pemVyKSkgewotCQkJdGhpcy5jdXN0b21pemF0aW9uLnNldERlc2NyaXB0b3JDdXN0b21pemVyKGRlc2NyaXB0b3JDdXN0b21pemVyLCB0aGlzLmVudGl0eU5hbWUpOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKERFU0NSSVBUT1JfQ1VTVE9NSVpFUl9QUk9QRVJUWSwgb2xkLCBkZXNjcmlwdG9yQ3VzdG9taXplcik7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgSnBhUHJvamVjdCBnZXRKcGFQcm9qZWN0KCkgewotCQlyZXR1cm4gdGhpcy5jdXN0b21pemF0aW9uLmdldEpwYVByb2plY3QoKTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgKioqKioqKioqKgotCQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGREZXNjcmlwdG9yQ3VzdG9taXplckFBKFByb3BlcnR5VmFsdWVNb2RlbDxDdXN0b21pemF0aW9uPiBzdWJqZWN0SG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEN1c3RvbWl6YXRpb24sIFN0cmluZz4oCi0JCQkJCQkJCXN1YmplY3RIb2xkZXIsIERFU0NSSVBUT1JfQ1VTVE9NSVpFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0RGVzY3JpcHRvckN1c3RvbWl6ZXIoRW50aXR5Q3VzdG9taXplclByb3BlcnRpZXMudGhpcy5lbnRpdHlOYW1lKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJpdmF0ZSBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkRGVzY3JpcHRvckN1c3RvbWl6ZXJDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZSkgewotCQkJCUVudGl0eUN1c3RvbWl6ZXJQcm9wZXJ0aWVzLnRoaXMuZGVzY3JpcHRvckN1c3RvbWl6ZXJDaGFuZ2VkKGUpOwotCQkJfQotCQl9OwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGRlc2NyaXB0b3JDdXN0b21pemVyQ2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJU3RyaW5nIG9sZCA9IChTdHJpbmcpIGUuZ2V0T2xkVmFsdWUoKTsKLQkJU3RyaW5nIG5ld0Rlc2NyaXB0b3JDdXN0b21pemVyID0gKFN0cmluZykgZS5nZXROZXdWYWx1ZSgpOwotCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoREVTQ1JJUFRPUl9DVVNUT01JWkVSX1BST1BFUlRZLCBvbGQsIG5ld0Rlc2NyaXB0b3JDdXN0b21pemVyKTsKLQkJcmV0dXJuOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHRvU3RyaW5nKFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJc2IuYXBwZW5kKCJuYW1lOiAiKTsKLQkJc2IuYXBwZW5kKHRoaXMuZW50aXR5TmFtZSk7Ci0JCXNiLmFwcGVuZCgiLCBkZXNjcmlwdG9yQ3VzdG9taXplcjogIik7Ci0JCXNiLmFwcGVuZCh0aGlzLmdldERlc2NyaXB0b3JDdXN0b21pemVyKCkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vRW50aXR5TGlzdENvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9FbnRpdHlMaXN0Q29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDVkOGM3MDcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9FbnRpdHlMaXN0Q29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyMzcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0qIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0qIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0qCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb247Ci0KLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklQcm9qZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklKYXZhRWxlbWVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JSmF2YVByb2plY3Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSVBhY2thZ2VGcmFnbWVudFJvb3Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSVR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSmF2YUNvcmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSmF2YU1vZGVsRXhjZXB0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLnNlYXJjaC5JSmF2YVNlYXJjaFNjb3BlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLnNlYXJjaC5TZWFyY2hFbmdpbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LnVpLklKYXZhRWxlbWVudFNlYXJjaENvbnN0YW50czsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQudWkuSmF2YVVJOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuSUxhYmVsUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5MYWJlbFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLndpbmRvdy5XaW5kb3c7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5FbnRpdHk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5jdXN0b21pemF0aW9uLkN1c3RvbWl6YXRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLkpwdEVjbGlwc2VMaW5rVWlQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwudXRpbC5QYW5lRW5hYmxlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5BZGRSZW1vdmVMaXN0UGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5MaXN0QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UudWkuUGxhdGZvcm1VSTsKLWltcG9ydCBvcmcuZWNsaXBzZS51aS5kaWFsb2dzLlNlbGVjdGlvbkRpYWxvZzsKLWltcG9ydCBvcmcuZWNsaXBzZS51aS5wcm9ncmVzcy5JUHJvZ3Jlc3NTZXJ2aWNlOwotCi0vKioKLSAqICBFbnRpdHlMaXN0Q29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBFbnRpdHlMaXN0Q29tcG9zaXRlIGV4dGVuZHMgUGFuZTxDdXN0b21pemF0aW9uPgotewotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8RW50aXR5Q3VzdG9taXplclByb3BlcnRpZXM+IGVudGl0eUhvbGRlcjsKLQotCXB1YmxpYyBFbnRpdHlMaXN0Q29tcG9zaXRlKFBhbmU8Q3VzdG9taXphdGlvbj4gcGFyZW50Q29tcG9zaXRlLCBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemUoKSB7Ci0JCXN1cGVyLmluaXRpYWxpemUoKTsKLQkJZW50aXR5SG9sZGVyID0gdGhpcy5idWlsZEVudGl0eUhvbGRlcigpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCWNvbnRhaW5lciA9IHRoaXMuYWRkVGl0bGVkR3JvdXAoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuQ3VzdG9taXphdGlvbkVudGl0eUxpc3RDb21wb3NpdGVfZ3JvdXBUaXRsZQotCQkpOwotCi0JCS8vIEVudGl0aWVzIGFkZC9yZW1vdmUgbGlzdCBwYW5lCi0JCW5ldyBBZGRSZW1vdmVMaXN0UGFuZTxDdXN0b21pemF0aW9uPigKLQkJCXRoaXMsCi0JCQljb250YWluZXIsCi0JCQl0aGlzLmJ1aWxkRW50aXRpZXNBZGFwdGVyKCksCi0JCQl0aGlzLmJ1aWxkRW50aXR5Q3VzdG9taXphdGlvbkxpc3RIb2xkZXIoKSwKLQkJCWVudGl0eUhvbGRlciwKLQkJCXRoaXMuYnVpbGRFbnRpdHlMYWJlbFByb3ZpZGVyKCksCi0JCQludWxsCQkJLy8JCUVjbGlwc2VMaW5rSGVscENvbnRleHRJZHMuQ1VTVE9NSVpBVElPTl9FTlRJVElFUwotCQkpOwotCi0JCS8vIEVudGl0eSBDdXN0b21pemF0aW9uIHByb3BlcnR5IHBhbmUKLQkJRW50aXR5Q3VzdG9taXphdGlvblByb3BlcnR5Q29tcG9zaXRlIHBhbmUgPSBuZXcgRW50aXR5Q3VzdG9taXphdGlvblByb3BlcnR5Q29tcG9zaXRlKAotCQkJdGhpcywKLQkJCWVudGl0eUhvbGRlciwKLQkJCWNvbnRhaW5lcgotCQkpOwotCQl0aGlzLmluc3RhbGxQYW5lRW5hYmxlcihlbnRpdHlIb2xkZXIsIHBhbmUpOwotCX0KLQotCXByaXZhdGUgQWRkUmVtb3ZlTGlzdFBhbmUuQWRhcHRlciBidWlsZEVudGl0aWVzQWRhcHRlcigpIHsKLQkJcmV0dXJuIG5ldyBBZGRSZW1vdmVMaXN0UGFuZS5BYnN0cmFjdEFkYXB0ZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBhZGROZXdJdGVtKE9iamVjdExpc3RTZWxlY3Rpb25Nb2RlbCBsaXN0U2VsZWN0aW9uTW9kZWwpIHsKLQkJCQlhZGRFbnRpdGllcyhsaXN0U2VsZWN0aW9uTW9kZWwpOwotCQkJfQotCi0JCQlwdWJsaWMgdm9pZCByZW1vdmVTZWxlY3RlZEl0ZW1zKE9iamVjdExpc3RTZWxlY3Rpb25Nb2RlbCBsaXN0U2VsZWN0aW9uTW9kZWwpIHsKLQkJCQlDdXN0b21pemF0aW9uIGN1c3RvbWl6YXRpb24gPSBnZXRTdWJqZWN0KCk7Ci0JCQkJZm9yIChPYmplY3QgaXRlbSA6IGxpc3RTZWxlY3Rpb25Nb2RlbC5zZWxlY3RlZFZhbHVlcygpKSB7Ci0JCQkJCUVudGl0eUN1c3RvbWl6ZXJQcm9wZXJ0aWVzIGVudGl0eUN1c3RvbWl6YXRpb24gPSAoRW50aXR5Q3VzdG9taXplclByb3BlcnRpZXMpIGl0ZW07Ci0JCQkJCWN1c3RvbWl6YXRpb24ucmVtb3ZlRW50aXR5KGVudGl0eUN1c3RvbWl6YXRpb24uZ2V0RW50aXR5TmFtZSgpKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCQotCXByaXZhdGUgdm9pZCBhZGRFbnRpdGllcyhPYmplY3RMaXN0U2VsZWN0aW9uTW9kZWwgbGlzdFNlbGVjdGlvbk1vZGVsKSB7Ci0KLQkJSVR5cGUgdHlwZSA9IHRoaXMuY2hvb3NlRW50aXR5KCk7Ci0KLQkJaWYgKHR5cGUgIT0gbnVsbCkgewotCQkJU3RyaW5nIGVudGl0eU5hbWUgPSB0aGlzLmdldEVudGl0eU5hbWUodHlwZS5nZXRGdWxseVF1YWxpZmllZE5hbWUoKSk7Ci0JCQlpZiAoZW50aXR5TmFtZSA9PSBudWxsKSB7Ci0JCQkJZW50aXR5TmFtZSA9IHR5cGUuZ2V0RWxlbWVudE5hbWUoKTsKLQkJCX0KLQkJCQotCQkJaWYoICEgdGhpcy5nZXRTdWJqZWN0KCkuZW50aXR5RXhpc3RzKGVudGl0eU5hbWUpKSB7Ci0JCQkJU3RyaW5nIGVudGl0eSA9IHRoaXMuZ2V0U3ViamVjdCgpLmFkZEVudGl0eShlbnRpdHlOYW1lKTsKLQotCQkJCWludCBpbmRleCA9IENvbGxlY3Rpb25Ub29scy5pbmRleE9mKHRoaXMuZ2V0U3ViamVjdCgpLmVudGl0aWVzKCksIGVudGl0eU5hbWUpOwotCQkJCUVudGl0eUN1c3RvbWl6ZXJQcm9wZXJ0aWVzIGl0ZW0gPSAoRW50aXR5Q3VzdG9taXplclByb3BlcnRpZXMpIGxpc3RTZWxlY3Rpb25Nb2RlbC5nZXRMaXN0TW9kZWwoKS5nZXRFbGVtZW50QXQoaW5kZXgpOwotCQkJCWVudGl0eUhvbGRlci5zZXRWYWx1ZShpdGVtKTsKLQkJCX0KLQkJfQotCX0KLQkKLQlwcml2YXRlIFN0cmluZyBnZXRFbnRpdHlOYW1lKFN0cmluZyBmdWxseVF1YWxpZmllZFR5cGVOYW1lKSB7Ci0KLQkJRW50aXR5IGVudGl0eSA9IGdldFN1YmplY3QoKS5nZXRQZXJzaXN0ZW5jZVVuaXQoKS5nZXRFbnRpdHkoZnVsbHlRdWFsaWZpZWRUeXBlTmFtZSk7Ci0JCXJldHVybiBlbnRpdHkgIT0gbnVsbCA/IGVudGl0eS5nZXROYW1lKCkgOiBudWxsOwotCX0KLQkKLQlwcml2YXRlIElUeXBlIGNob29zZUVudGl0eSgpIHsKLQotCQlJUGFja2FnZUZyYWdtZW50Um9vdCByb290ID0gZ2V0UGFja2FnZUZyYWdtZW50Um9vdCgpOwotCQlpZiAocm9vdCA9PSBudWxsKSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQlJSmF2YUVsZW1lbnRbXSBlbGVtZW50cyA9IG5ldyBJSmF2YUVsZW1lbnRbXSB7IHJvb3QuZ2V0SmF2YVByb2plY3QoKSB9OwotCQlJSmF2YVNlYXJjaFNjb3BlIHNjb3BlID0gU2VhcmNoRW5naW5lLmNyZWF0ZUphdmFTZWFyY2hTY29wZShlbGVtZW50cyk7Ci0JCUlQcm9ncmVzc1NlcnZpY2Ugc2VydmljZSA9IFBsYXRmb3JtVUkuZ2V0V29ya2JlbmNoKCkuZ2V0UHJvZ3Jlc3NTZXJ2aWNlKCk7Ci0JCVNlbGVjdGlvbkRpYWxvZyB0eXBlU2VsZWN0aW9uRGlhbG9nOwotCi0JCXRyeSB7Ci0JCQl0eXBlU2VsZWN0aW9uRGlhbG9nID0gSmF2YVVJLmNyZWF0ZVR5cGVEaWFsb2coCi0JCQkJZ2V0U2hlbGwoKSwKLQkJCQlzZXJ2aWNlLAotCQkJCXNjb3BlLAotCQkJCUlKYXZhRWxlbWVudFNlYXJjaENvbnN0YW50cy5DT05TSURFUl9DTEFTU0VTLAotCQkJCWZhbHNlLAotCQkJCSIiCi0JCQkpOwotCQl9Ci0JCWNhdGNoIChKYXZhTW9kZWxFeGNlcHRpb24gZSkgewotCQkJSnB0RWNsaXBzZUxpbmtVaVBsdWdpbi5sb2coZSk7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQl0eXBlU2VsZWN0aW9uRGlhbG9nLnNldFRpdGxlKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5DdXN0b21pemF0aW9uRW50aXR5TGlzdENvbXBvc2l0ZV9kaWFsb2dUaXRsZSk7Ci0JCXR5cGVTZWxlY3Rpb25EaWFsb2cuc2V0TWVzc2FnZShFY2xpcHNlTGlua1VpTWVzc2FnZXMuQ3VzdG9taXphdGlvbkVudGl0eUxpc3RDb21wb3NpdGVfZGlhbG9nTWVzc2FnZSk7Ci0KLQkJaWYgKHR5cGVTZWxlY3Rpb25EaWFsb2cub3BlbigpID09IFdpbmRvdy5PSykgewotCQkJcmV0dXJuIChJVHlwZSkgdHlwZVNlbGVjdGlvbkRpYWxvZy5nZXRSZXN1bHQoKVswXTsKLQkJfQotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQlwcml2YXRlIElQYWNrYWdlRnJhZ21lbnRSb290IGdldFBhY2thZ2VGcmFnbWVudFJvb3QoKSB7Ci0JCUlQcm9qZWN0IHByb2plY3QgPSBnZXRTdWJqZWN0KCkuZ2V0SnBhUHJvamVjdCgpLmdldFByb2plY3QoKTsKLQkJSUphdmFQcm9qZWN0IHJvb3QgPSBKYXZhQ29yZS5jcmVhdGUocHJvamVjdCk7Ci0KLQkJdHJ5IHsKLQkJCXJldHVybiByb290LmdldEFsbFBhY2thZ2VGcmFnbWVudFJvb3RzKClbMF07Ci0JCX0KLQkJY2F0Y2ggKEphdmFNb2RlbEV4Y2VwdGlvbiBlKSB7Ci0JCQlKcHRFY2xpcHNlTGlua1VpUGx1Z2luLmxvZyhlKTsKLQkJfQotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQlwcml2YXRlIElMYWJlbFByb3ZpZGVyIGJ1aWxkRW50aXR5TGFiZWxQcm92aWRlcigpIHsKLQkJcmV0dXJuIG5ldyBMYWJlbFByb3ZpZGVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIGdldFRleHQoT2JqZWN0IGVsZW1lbnQpIHsKLQkJCQlFbnRpdHlDdXN0b21pemVyUHJvcGVydGllcyBlbnRpdHlDdXN0b21pemF0aW9uID0gKEVudGl0eUN1c3RvbWl6ZXJQcm9wZXJ0aWVzKSBlbGVtZW50OwotCQkJCXJldHVybiBlbnRpdHlDdXN0b21pemF0aW9uLmdldEVudGl0eU5hbWUoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEVudGl0eUN1c3RvbWl6ZXJQcm9wZXJ0aWVzPiBidWlsZEVudGl0eUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8RW50aXR5Q3VzdG9taXplclByb3BlcnRpZXM+KCk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxFbnRpdHlDdXN0b21pemVyUHJvcGVydGllcz4gYnVpbGRFbnRpdHlDdXN0b21pemF0aW9uTGlzdEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxTdHJpbmcsIEVudGl0eUN1c3RvbWl6ZXJQcm9wZXJ0aWVzPihidWlsZEVudGl0aWVzTGlzdEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBFbnRpdHlDdXN0b21pemVyUHJvcGVydGllcyB0cmFuc2Zvcm1JdGVtKFN0cmluZyBpdGVtKSB7Ci0JCQkJcmV0dXJuIG5ldyBFbnRpdHlDdXN0b21pemVyUHJvcGVydGllcyhnZXRTdWJqZWN0KCksIGl0ZW0pOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZEVudGl0aWVzTGlzdEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBMaXN0QXNwZWN0QWRhcHRlcjxDdXN0b21pemF0aW9uLCBTdHJpbmc+KAotCQkJCXRoaXMuZ2V0U3ViamVjdEhvbGRlcigpLCBDdXN0b21pemF0aW9uLkVOVElUSUVTX0xJU1RfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIExpc3RJdGVyYXRvcjxTdHJpbmc+IGxpc3RJdGVyYXRvcl8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5lbnRpdGllcygpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgaW50IHNpemVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZW50aXRpZXNTaXplKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGluc3RhbGxQYW5lRW5hYmxlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxFbnRpdHlDdXN0b21pemVyUHJvcGVydGllcz4gZW50aXR5SG9sZGVyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgRW50aXR5Q3VzdG9taXphdGlvblByb3BlcnR5Q29tcG9zaXRlIHBhbmUpIHsKLQotCQluZXcgUGFuZUVuYWJsZXIoCi0JCQl0aGlzLmJ1aWxkUGFuZUVuYWJsZXJIb2xkZXIoZW50aXR5SG9sZGVyKSwKLQkJCXBhbmUKLQkJKTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZFBhbmVFbmFibGVySG9sZGVyKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEVudGl0eUN1c3RvbWl6ZXJQcm9wZXJ0aWVzPiBlbnRpdHlIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxFbnRpdHlDdXN0b21pemVyUHJvcGVydGllcywgQm9vbGVhbj4oZW50aXR5SG9sZGVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIHRyYW5zZm9ybV8oRW50aXR5Q3VzdG9taXplclByb3BlcnRpZXMgdmFsdWUpIHsKLQkJCQlyZXR1cm4gdmFsdWUuZW50aXR5TmFtZUlzVmFsaWQoKTsKLQkJCX0KLQkJfTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jdXN0b21pemF0aW9uL0V4Y2VwdGlvbkhhbmRsZXJDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vRXhjZXB0aW9uSGFuZGxlckNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1NzQyNzhkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vRXhjZXB0aW9uSGFuZGxlckNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsOTMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0qIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0qIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0qIAotKiBDb250cmlidXRvcnM6Ci0qICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jdXN0b21pemF0aW9uOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuSnBhUHJvamVjdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb24uQ3VzdG9taXphdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkNsYXNzQ2hvb3NlclBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqICBFeGNlcHRpb25IYW5kbGVyQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBFeGNlcHRpb25IYW5kbGVyQ29tcG9zaXRlIGV4dGVuZHMgUGFuZTxDdXN0b21pemF0aW9uPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+RXhjZXB0aW9uSGFuZGxlckNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IHBhbmUgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIEV4Y2VwdGlvbkhhbmRsZXJDb21wb3NpdGUoUGFuZTw/IGV4dGVuZHMgQ3VzdG9taXphdGlvbj4gcGFyZW50UGFuZSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRQYW5lLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgQ2xhc3NDaG9vc2VyUGFuZTxDdXN0b21pemF0aW9uPiBpbml0aWFsaXplQ2xhc3NDaG9vc2VyKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlyZXR1cm4gbmV3IENsYXNzQ2hvb3NlclBhbmU8Q3VzdG9taXphdGlvbj4odGhpcywgY29udGFpbmVyKSB7Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRUZXh0SG9sZGVyKCkgewotCQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEN1c3RvbWl6YXRpb24sIFN0cmluZz4oCi0JCQkJCQkJdGhpcy5nZXRTdWJqZWN0SG9sZGVyKCksIEN1c3RvbWl6YXRpb24uRVhDRVBUSU9OX0hBTkRMRVJfUFJPUEVSVFkpIHsKLQkJCQkJQE92ZXJyaWRlCi0JCQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldEV4Y2VwdGlvbkhhbmRsZXIoKTsKLQkJCQkJfQotCi0JCQkJCUBPdmVycmlkZQotCQkJCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0KLQkJCQkJCWlmICh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQkJCQkJdmFsdWUgPSBudWxsOwotCQkJCQkJfQotCQkJCQkJdGhpcy5zdWJqZWN0LnNldEV4Y2VwdGlvbkhhbmRsZXIodmFsdWUpOwotCQkJCQl9Ci0JCQkJfTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGdldENsYXNzTmFtZSgpIHsKLQkJCQlyZXR1cm4gdGhpcy5nZXRTdWJqZWN0KCkuZ2V0RXhjZXB0aW9uSGFuZGxlcigpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZ2V0TGFiZWxUZXh0KCkgewotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX2V4Y2VwdGlvbkhhbmRsZXJMYWJlbDsKLQkJCX0KLQkJCQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSnBhUHJvamVjdCBnZXRKcGFQcm9qZWN0KCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0SnBhUHJvamVjdCgpOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldENsYXNzTmFtZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCQkJdGhpcy5nZXRTdWJqZWN0KCkuc2V0RXhjZXB0aW9uSGFuZGxlcihjbGFzc05hbWUpOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZ2V0U3VwZXJJbnRlcmZhY2VOYW1lKCkgewotCQkJCXJldHVybiBDdXN0b21pemF0aW9uLkVDTElQU0VMSU5LX0VYQ0VQVElPTl9IQU5ETEVSX0NMQVNTX05BTUU7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCXRoaXMuaW5pdGlhbGl6ZUNsYXNzQ2hvb3Nlcihjb250YWluZXIpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jdXN0b21pemF0aW9uL1BlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0NWQ5MTc5Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw4NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSogCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb24uQ3VzdG9taXphdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYVBhZ2VDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5TV1Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLkltYWdlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuR3JpZERhdGE7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkTGF5b3V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiAgUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiSXRlbQotICovCi1wdWJsaWMgY2xhc3MgUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiIAotCQkJCQkJCQlleHRlbmRzIEZvcm1QYW5lPEN1c3RvbWl6YXRpb24+Ci0JCQkJCQkJCWltcGxlbWVudHMgSnBhUGFnZUNvbXBvc2l0ZQotewotCXB1YmxpYyBQZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWIoCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWw8Q3VzdG9taXphdGlvbj4gc3ViamVjdEhvbGRlciwKLQkJCUNvbXBvc2l0ZSBwYXJlbnQsCi0gICAgICAgICAgICBXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJCi0JCW5ldyBFY2xpcHNlTGlua0N1c3RvbWl6YXRpb25Db21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIEpwYVBhZ2VDb21wb3NpdGUgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCQotCXB1YmxpYyBTdHJpbmcgZ2V0SGVscElEKCkgewotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQlwdWJsaWMgSW1hZ2UgZ2V0UGFnZUltYWdlKCkgewotCQlyZXR1cm4gbnVsbDsKLQl9Ci0JcHVibGljIFN0cmluZyBnZXRQYWdlVGV4dCgpIHsKLQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfdGl0bGU7Ci0JfQotCi0JLy8gKioqKioqKioqKiBMYXlvdXQgKioqKioqKioqKgotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBDb21wb3NpdGUgYWRkQ29udGFpbmVyKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJR3JpZExheW91dCBsYXlvdXQgPSBuZXcgR3JpZExheW91dCgxLCB0cnVlKTsKLQkJbGF5b3V0Lm1hcmdpbkhlaWdodCA9IDA7Ci0JCWxheW91dC5tYXJnaW5XaWR0aCA9IDA7Ci0JCWxheW91dC5tYXJnaW5Ub3AgPSAwOwotCQlsYXlvdXQubWFyZ2luTGVmdCA9IDA7Ci0JCWxheW91dC5tYXJnaW5Cb3R0b20gPSAwOwotCQlsYXlvdXQubWFyZ2luUmlnaHQgPSAwOwotCQlsYXlvdXQudmVydGljYWxTcGFjaW5nID0gMTU7Ci0JCQotCQlDb21wb3NpdGUgY29udGFpbmVyID0gYWRkUGFuZShwYXJlbnQsIGxheW91dCk7Ci0JCXVwZGF0ZUdyaWREYXRhKGNvbnRhaW5lcik7Ci0JCQotCQlyZXR1cm4gY29udGFpbmVyOwotCX0KLQotCXByaXZhdGUgdm9pZCB1cGRhdGVHcmlkRGF0YShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCUdyaWREYXRhIGdyaWREYXRhID0gbmV3IEdyaWREYXRhKCk7Ci0JCWdyaWREYXRhLmdyYWJFeGNlc3NIb3Jpem9udGFsU3BhY2UgPSB0cnVlOwotCQlncmlkRGF0YS5ncmFiRXhjZXNzVmVydGljYWxTcGFjZSA9IHRydWU7Ci0JCWdyaWREYXRhLmhvcml6b250YWxBbGlnbm1lbnQgPSBTV1QuRklMTDsKLQkJZ3JpZERhdGEudmVydGljYWxBbGlnbm1lbnQgPSBTV1QuRklMTDsKLQkJY29udGFpbmVyLnNldExheW91dERhdGEoZ3JpZERhdGEpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9Qcm9maWxlckNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9Qcm9maWxlckNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3YmU5NDdkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vUHJvZmlsZXJDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDIwNyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSogCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb247Ci0KLWltcG9ydCBqYXZhLnRleHQuQ29sbGF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29tcGFyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcGFQcm9qZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY3VzdG9taXphdGlvbi5DdXN0b21pemF0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY3VzdG9taXphdGlvbi5Qcm9maWxlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkNsYXNzQ2hvb3NlckNvbWJvUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlRyYW5zZm9ybWF0aW9uSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuQ29tcG9zaXRlTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogIFByb2ZpbGVyQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBQcm9maWxlckNvbXBvc2l0ZSBleHRlbmRzIENsYXNzQ2hvb3NlckNvbWJvUGFuZTxDdXN0b21pemF0aW9uPgotewotCi0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5Qcm9maWxlckNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgUHJvZmlsZXJDb21wb3NpdGUoCi0JCQkJCQkJCVBhbmU8PyBleHRlbmRzIEN1c3RvbWl6YXRpb24+IHBhcmVudFBhbmUsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudFBhbmUsIHBhcmVudCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXRDbGFzc05hbWUoKSB7Ci0JCXJldHVybiBQcm9maWxlci5nZXRQcm9maWxlckNsYXNzTmFtZSh0aGlzLmdldFN1YmplY3QoKS5nZXRQcm9maWxlcigpKTsKLQl9Ci0KLSAgICBAT3ZlcnJpZGUKLSAgICBwcm90ZWN0ZWQgU3RyaW5nIGdldExhYmVsVGV4dCgpIHsKLSAgICAJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfcHJvZmlsZXJMYWJlbDsKLSAgICB9Ci0gICAgCi0gICAgQE92ZXJyaWRlCi0gICAgcHJvdGVjdGVkIEpwYVByb2plY3QgZ2V0SnBhUHJvamVjdCgpIHsKLSAgICAJcmV0dXJuIGdldFN1YmplY3QoKS5nZXRKcGFQcm9qZWN0KCk7Ci0gICAgfQotICAgIAotICAgIEBPdmVycmlkZQotCXByb3RlY3RlZCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkVGV4dEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q3VzdG9taXphdGlvbiwgU3RyaW5nPih0aGlzLmdldFN1YmplY3RIb2xkZXIoKSwgQ3VzdG9taXphdGlvbi5QUk9GSUxFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCi0JCQkJU3RyaW5nIG5hbWUgPSB0aGlzLnN1YmplY3QuZ2V0UHJvZmlsZXIoKTsKLQkJCQlpZiAobmFtZSA9PSBudWxsKSB7Ci0JCQkJCW5hbWUgPSBQcm9maWxlckNvbXBvc2l0ZS50aGlzLmdldERlZmF1bHRWYWx1ZSh0aGlzLnN1YmplY3QpOwotCQkJCX0KLQkJCQlyZXR1cm4gbmFtZTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0KLQkJCQlpZiAoZ2V0RGVmYXVsdFZhbHVlKHRoaXMuc3ViamVjdCkuZXF1YWxzKHZhbHVlKSkgewotCQkJCQl2YWx1ZSA9IG51bGw7Ci0JCQkJfQotCQkJCXRoaXMuc3ViamVjdC5zZXRQcm9maWxlcih2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0gICAgfQotICAgIAotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGREZWZhdWx0UHJvZmlsZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEN1c3RvbWl6YXRpb24sIFN0cmluZz4odGhpcy5nZXRTdWJqZWN0SG9sZGVyKCksIEN1c3RvbWl6YXRpb24uREVGQVVMVF9QUk9GSUxFUikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBQcm9maWxlckNvbXBvc2l0ZS50aGlzLmdldERlZmF1bHRWYWx1ZSh0aGlzLnN1YmplY3QpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZERlZmF1bHRQcm9maWxlckxpc3RIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8U3RyaW5nPigKLQkJCXRoaXMuYnVpbGREZWZhdWx0UHJvZmlsZXJIb2xkZXIoKQotCQkpOwotCX0KLQotCXByaXZhdGUgU3RyaW5nIGJ1aWxkRGlzcGxheVN0cmluZyhTdHJpbmcgcHJvZmlsZXJOYW1lKSB7Ci0KLQkJc3dpdGNoIChQcm9maWxlci52YWx1ZU9mKHByb2ZpbGVyTmFtZSkpIHsKLQkJCWNhc2Ugbm9fcHJvZmlsZXI6IHsKLQkJCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlByb2ZpbGVyQ29tcG9zaXRlX25vX3Byb2ZpbGVyOwotCQkJfQotCQkJY2FzZSBwZXJmb3JtYW5jZV9wcm9maWxlcjogewotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWVzc2FnZXMuUHJvZmlsZXJDb21wb3NpdGVfcGVyZm9ybWFuY2VfcHJvZmlsZXI7Ci0JCQl9Ci0JCQljYXNlIHF1ZXJ5X21vbml0b3I6IHsKLQkJCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlByb2ZpbGVyQ29tcG9zaXRlX3F1ZXJ5X21vbml0b3I7Ci0JCQl9Ci0JCQlkZWZhdWx0OiB7Ci0JCQkJcmV0dXJuIG51bGw7Ci0JCQl9Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIENvbXBhcmF0b3I8U3RyaW5nPiBidWlsZFByb2ZpbGVyQ29tcGFyYXRvcigpIHsKLQkJcmV0dXJuIG5ldyBDb21wYXJhdG9yPFN0cmluZz4oKSB7Ci0JCQlwdWJsaWMgaW50IGNvbXBhcmUoU3RyaW5nIHByb2ZpbGVyMSwgU3RyaW5nIHByb2ZpbGVyMikgewotCQkJCXByb2ZpbGVyMSA9IGJ1aWxkRGlzcGxheVN0cmluZyhwcm9maWxlcjEpOwotCQkJCXByb2ZpbGVyMiA9IGJ1aWxkRGlzcGxheVN0cmluZyhwcm9maWxlcjIpOwotCQkJCXJldHVybiBDb2xsYXRvci5nZXRJbnN0YW5jZSgpLmNvbXBhcmUocHJvZmlsZXIxLCBwcm9maWxlcjIpOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmdDb252ZXJ0ZXI8U3RyaW5nPiBidWlsZENsYXNzQ29udmVydGVyKCkgewotCQlyZXR1cm4gbmV3IFN0cmluZ0NvbnZlcnRlcjxTdHJpbmc+KCkgewotCQkJcHVibGljIFN0cmluZyBjb252ZXJ0VG9TdHJpbmcoU3RyaW5nIHZhbHVlKSB7Ci0JCQkJdHJ5IHsKLQkJCQkJUHJvZmlsZXIudmFsdWVPZih2YWx1ZSk7Ci0JCQkJCXZhbHVlID0gYnVpbGREaXNwbGF5U3RyaW5nKHZhbHVlKTsKLQkJCQl9Ci0JCQkJY2F0Y2ggKEV4Y2VwdGlvbiBlKSB7Ci0JCQkJCS8vIElnbm9yZSBzaW5jZSB0aGUgdmFsdWUgaXMgbm90IGEgUHJvZmlsZXIKLQkJCQl9Ci0JCQkJcmV0dXJuIHZhbHVlOwotCQkJfQotCQl9OwotCX0KLQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRDbGFzc0xpc3RIb2xkZXIoKSB7Ci0JCUFycmF5TGlzdDxMaXN0VmFsdWVNb2RlbDxTdHJpbmc+PiBob2xkZXJzID0gbmV3IEFycmF5TGlzdDxMaXN0VmFsdWVNb2RlbDxTdHJpbmc+PigyKTsKLQkJaG9sZGVycy5hZGQodGhpcy5idWlsZERlZmF1bHRQcm9maWxlckxpc3RIb2xkZXIoKSk7Ci0JCWhvbGRlcnMuYWRkKHRoaXMuYnVpbGRQcm9maWxlcnNMaXN0SG9sZGVyKCkpOwotCQlyZXR1cm4gbmV3IENvbXBvc2l0ZUxpc3RWYWx1ZU1vZGVsPExpc3RWYWx1ZU1vZGVsPFN0cmluZz4sIFN0cmluZz4oaG9sZGVycyk7Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkUHJvZmlsZXJzKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8UHJvZmlsZXIsIFN0cmluZz4oQ29sbGVjdGlvblRvb2xzLml0ZXJhdG9yKFByb2ZpbGVyLnZhbHVlcygpKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShQcm9maWxlciBuZXh0KSB7Ci0JCQkJcmV0dXJuIG5leHQubmFtZSgpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgQ29sbGVjdGlvblZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFByb2ZpbGVyc0NvbGxlY3Rpb25Ib2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8U3RyaW5nPigKLQkJCUNvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKHRoaXMuYnVpbGRQcm9maWxlcnMoKSkKLQkJKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRQcm9maWxlcnNMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxTdHJpbmc+KAotCQkJdGhpcy5idWlsZFByb2ZpbGVyc0NvbGxlY3Rpb25Ib2xkZXIoKSwKLQkJCXRoaXMuYnVpbGRQcm9maWxlckNvbXBhcmF0b3IoKQotCQkpOwotCX0KLQotCXByaXZhdGUgU3RyaW5nIGdldERlZmF1bHRWYWx1ZShDdXN0b21pemF0aW9uIHN1YmplY3QpIHsKLQkJU3RyaW5nIGRlZmF1bHRWYWx1ZSA9IHN1YmplY3QuZ2V0RGVmYXVsdFByb2ZpbGVyKCk7Ci0KLQkJaWYgKGRlZmF1bHRWYWx1ZSAhPSBudWxsKSB7Ci0JCQlyZXR1cm4gTkxTLmJpbmQoCi0JCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl9kZWZhdWx0V2l0aE9uZVBhcmFtLAotCQkJCWRlZmF1bHRWYWx1ZQotCQkJKTsKLQkJfQotCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl9kZWZhdWx0RW1wdHk7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldENsYXNzTmFtZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCXRoaXMuZ2V0U3ViamVjdCgpLnNldFByb2ZpbGVyKGNsYXNzTmFtZSk7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0U3VwZXJJbnRlcmZhY2VOYW1lKCkgewotCQlyZXR1cm4gQ3VzdG9taXphdGlvbi5FQ0xJUFNFTElOS19TRVNTSU9OX1BST0ZJTEVSX0NMQVNTX05BTUU7Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vU2Vzc2lvbkN1c3RvbWl6ZXJzQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jdXN0b21pemF0aW9uL1Nlc3Npb25DdXN0b21pemVyc0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxNWQ1ZWYwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vU2Vzc2lvbkN1c3RvbWl6ZXJzQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyMTMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0qIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0qIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0qIAotKiBDb250cmlidXRvcnM6Ci0qICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jdXN0b21pemF0aW9uOwotCi1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JUHJvamVjdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JSmF2YUVsZW1lbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSUphdmFQcm9qZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklQYWNrYWdlRnJhZ21lbnRSb290OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLkphdmFDb3JlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLkphdmFNb2RlbEV4Y2VwdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5zZWFyY2guSUphdmFTZWFyY2hTY29wZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5zZWFyY2guU2VhcmNoRW5naW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC51aS5JSmF2YUVsZW1lbnRTZWFyY2hDb25zdGFudHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LnVpLkphdmFVSTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLklMYWJlbFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuTGFiZWxQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS53aW5kb3cuV2luZG93OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY3VzdG9taXphdGlvbi5DdXN0b21pemF0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5KcHRFY2xpcHNlTGlua1VpUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLkpwdFVpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuQWRkUmVtb3ZlTGlzdFBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5BZGRSZW1vdmVQYW5lLkFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuSXRlbVByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkxpc3RBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5PYmplY3RMaXN0U2VsZWN0aW9uTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkRGF0YTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuVGFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UudWkuUGxhdGZvcm1VSTsKLWltcG9ydCBvcmcuZWNsaXBzZS51aS5kaWFsb2dzLlNlbGVjdGlvbkRpYWxvZzsKLWltcG9ydCBvcmcuZWNsaXBzZS51aS5wcm9ncmVzcy5JUHJvZ3Jlc3NTZXJ2aWNlOwotCi0vKioKLSAqICBTZXNzaW9uQ3VzdG9taXplcnNDb21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIFNlc3Npb25DdXN0b21pemVyc0NvbXBvc2l0ZSBleHRlbmRzIFBhbmU8Q3VzdG9taXphdGlvbj4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPlNlc3Npb25DdXN0b21pemVyQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRQYW5lIFRoZSBwYXJlbnQgcGFuZSBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgU2Vzc2lvbkN1c3RvbWl6ZXJzQ29tcG9zaXRlKFBhbmU8PyBleHRlbmRzIEN1c3RvbWl6YXRpb24+IHBhcmVudFBhbmUsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50UGFuZSwgcGFyZW50KTsKLQl9Ci0KLQotCXByaXZhdGUgdm9pZCBhZGRTZXNzaW9uQ3VzdG9taXplckNsYXNzKE9iamVjdExpc3RTZWxlY3Rpb25Nb2RlbCBsaXN0U2VsZWN0aW9uTW9kZWwpIHsKLQotCQlJVHlwZSB0eXBlID0gY2hvb3NlVHlwZSgpOwotCi0JCWlmICh0eXBlICE9IG51bGwpIHsKLQkJCVN0cmluZyBjbGFzc05hbWUgPSB0eXBlLmdldEZ1bGx5UXVhbGlmaWVkTmFtZSgnLicpOwotCQkJaWYoICEgdGhpcy5nZXRTdWJqZWN0KCkuc2Vzc2lvbkN1c3RvbWl6ZXJFeGlzdHMoY2xhc3NOYW1lKSkgewotCQkJCQotCQkJCVN0cmluZyBjbGFzc1JlZiA9IHRoaXMuZ2V0U3ViamVjdCgpLmFkZFNlc3Npb25DdXN0b21pemVyKGNsYXNzTmFtZSk7Ci0JCQkJbGlzdFNlbGVjdGlvbk1vZGVsLnNldFNlbGVjdGVkVmFsdWUoY2xhc3NSZWYpOwotCQkJfQotCQl9Ci0JfQotCi0JcHJpdmF0ZSBBZGFwdGVyIGJ1aWxkQWRhcHRlcigpIHsKLQkJcmV0dXJuIG5ldyBBZGRSZW1vdmVMaXN0UGFuZS5BYnN0cmFjdEFkYXB0ZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBhZGROZXdJdGVtKE9iamVjdExpc3RTZWxlY3Rpb25Nb2RlbCBsaXN0U2VsZWN0aW9uTW9kZWwpIHsKLQkJCQlhZGRTZXNzaW9uQ3VzdG9taXplckNsYXNzKGxpc3RTZWxlY3Rpb25Nb2RlbCk7Ci0JCQl9Ci0KLQkJCXB1YmxpYyB2b2lkIHJlbW92ZVNlbGVjdGVkSXRlbXMoT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsIGxpc3RTZWxlY3Rpb25Nb2RlbCkgewotCQkJCWZvciAoT2JqZWN0IGl0ZW0gOiBsaXN0U2VsZWN0aW9uTW9kZWwuc2VsZWN0ZWRWYWx1ZXMoKSkgewotCQkJCQlnZXRTdWJqZWN0KCkucmVtb3ZlU2Vzc2lvbkN1c3RvbWl6ZXIoKFN0cmluZykgaXRlbSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgSUxhYmVsUHJvdmlkZXIgYnVpbGRMYWJlbFByb3ZpZGVyKCkgewotCQlyZXR1cm4gbmV3IExhYmVsUHJvdmlkZXIoKSB7Ci0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyBnZXRUZXh0KE9iamVjdCBlbGVtZW50KSB7Ci0JCQkJU3RyaW5nIG5hbWUgPSAoU3RyaW5nKSBlbGVtZW50OwotCi0JCQkJaWYgKG5hbWUgPT0gbnVsbCkgewotCQkJCQluYW1lID0gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl9ub05hbWU7Ci0JCQkJfQotCQkJCXJldHVybiBuYW1lOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZExpc3RIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgTGlzdEFzcGVjdEFkYXB0ZXI8Q3VzdG9taXphdGlvbiwgU3RyaW5nPihnZXRTdWJqZWN0SG9sZGVyKCksIEN1c3RvbWl6YXRpb24uU0VTU0lPTl9DVVNUT01JWkVSX0xJU1RfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIExpc3RJdGVyYXRvcjxTdHJpbmc+IGxpc3RJdGVyYXRvcl8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3Quc2Vzc2lvbkN1c3RvbWl6ZXJzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGludCBzaXplXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5zZXNzaW9uQ3VzdG9taXplcnNTaXplKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkU2VsZWN0ZWRJdGVtSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+KCk7Ci0JfQotCi0JLyoqCi0JICogUHJvbXB0cyB0aGUgdXNlciB0aGUgT3BlbiBUeXBlIGRpYWxvZy4KLQkgKgotCSAqIEByZXR1cm4gRWl0aGVyIHRoZSBzZWxlY3RlZCB0eXBlIG9yIDxjb2RlPm51bGw8L2NvZGU+IGlmIHRoZSB1c2VyCi0JICogY2FuY2VsbGVkIHRoZSBkaWFsb2cKLQkgKi8KLQlwcml2YXRlIElUeXBlIGNob29zZVR5cGUoKSB7Ci0KLQkJSVBhY2thZ2VGcmFnbWVudFJvb3Qgcm9vdCA9IHBhY2thZ2VGcmFnbWVudFJvb3QoKTsKLQotCQlpZiAocm9vdCA9PSBudWxsKSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCi0JCUlKYXZhRWxlbWVudFtdIGVsZW1lbnRzID0gbmV3IElKYXZhRWxlbWVudFtdIHsgcm9vdC5nZXRKYXZhUHJvamVjdCgpIH07Ci0JCUlKYXZhU2VhcmNoU2NvcGUgc2NvcGUgPSBTZWFyY2hFbmdpbmUuY3JlYXRlSmF2YVNlYXJjaFNjb3BlKGVsZW1lbnRzKTsKLQkJSVByb2dyZXNzU2VydmljZSBzZXJ2aWNlID0gUGxhdGZvcm1VSS5nZXRXb3JrYmVuY2goKS5nZXRQcm9ncmVzc1NlcnZpY2UoKTsKLQkJU2VsZWN0aW9uRGlhbG9nIHR5cGVTZWxlY3Rpb25EaWFsb2c7Ci0KLQkJdHJ5IHsKLQkJCXR5cGVTZWxlY3Rpb25EaWFsb2cgPSBKYXZhVUkuY3JlYXRlVHlwZURpYWxvZygKLQkJCQlnZXRTaGVsbCgpLAotCQkJCXNlcnZpY2UsCi0JCQkJc2NvcGUsCi0JCQkJSUphdmFFbGVtZW50U2VhcmNoQ29uc3RhbnRzLkNPTlNJREVSX0NMQVNTRVMsCi0JCQkJZmFsc2UsCi0JCQkJIiIKLQkJCSk7Ci0JCX0KLQkJY2F0Y2ggKEphdmFNb2RlbEV4Y2VwdGlvbiBlKSB7Ci0JCQlKcHRFY2xpcHNlTGlua1VpUGx1Z2luLmxvZyhlKTsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0KLQkJdHlwZVNlbGVjdGlvbkRpYWxvZy5zZXRUaXRsZShKcHRVaU1lc3NhZ2VzLkNsYXNzQ2hvb3NlclBhbmVfZGlhbG9nVGl0bGUpOwotCQl0eXBlU2VsZWN0aW9uRGlhbG9nLnNldE1lc3NhZ2UoSnB0VWlNZXNzYWdlcy5DbGFzc0Nob29zZXJQYW5lX2RpYWxvZ01lc3NhZ2UpOwotCi0JCWlmICh0eXBlU2VsZWN0aW9uRGlhbG9nLm9wZW4oKSA9PSBXaW5kb3cuT0spIHsKLQkJCXJldHVybiAoSVR5cGUpIHR5cGVTZWxlY3Rpb25EaWFsb2cuZ2V0UmVzdWx0KClbMF07Ci0JCX0KLQotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJLy8gRGVzY3JpcHRpb24KLQkJY29udGFpbmVyID0gYWRkVGl0bGVkR3JvdXAoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3Nlc3Npb25DdXN0b21pemVyTGFiZWwKLQkJKTsKLQotCQkvLyBMaXN0IHBhbmUKLQkJbmV3IEFkZFJlbW92ZUxpc3RQYW5lPEN1c3RvbWl6YXRpb24+KAotCQkJdGhpcywKLQkJCWNvbnRhaW5lciwKLQkJCWJ1aWxkQWRhcHRlcigpLAotCQkJYnVpbGRMaXN0SG9sZGVyKCksCi0JCQlidWlsZFNlbGVjdGVkSXRlbUhvbGRlcigpLAotCQkJYnVpbGRMYWJlbFByb3ZpZGVyKCkKLQkJKQotCQl7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVUYWJsZShUYWJsZSB0YWJsZSkgewotCQkJCXN1cGVyLmluaXRpYWxpemVUYWJsZSh0YWJsZSk7Ci0KLQkJCQlDb21wb3NpdGUgY29udGFpbmVyID0gdGFibGUuZ2V0UGFyZW50KCk7Ci0JCQkJR3JpZERhdGEgZ3JpZERhdGEgICA9IChHcmlkRGF0YSkgY29udGFpbmVyLmdldExheW91dERhdGEoKTsKLQkJCQlncmlkRGF0YS5oZWlnaHRIaW50ID0gNzU7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBJUGFja2FnZUZyYWdtZW50Um9vdCBwYWNrYWdlRnJhZ21lbnRSb290KCkgewotCQlJUHJvamVjdCBwcm9qZWN0ID0gZ2V0U3ViamVjdCgpLmdldEpwYVByb2plY3QoKS5nZXRQcm9qZWN0KCk7Ci0JCUlKYXZhUHJvamVjdCByb290ID0gSmF2YUNvcmUuY3JlYXRlKHByb2plY3QpOwotCi0JCXRyeSB7Ci0JCQlyZXR1cm4gcm9vdC5nZXRBbGxQYWNrYWdlRnJhZ21lbnRSb290cygpWzBdOwotCQl9Ci0JCWNhdGNoIChKYXZhTW9kZWxFeGNlcHRpb24gZSkgewotCQkJSnB0RWNsaXBzZUxpbmtVaVBsdWdpbi5sb2coZSk7Ci0JCX0KLQotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vVGhyb3dFeGNlcHRpb25zQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jdXN0b21pemF0aW9uL1Rocm93RXhjZXB0aW9uc0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1ZTU0YTlmLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vVGhyb3dFeGNlcHRpb25zQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw5NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jdXN0b21pemF0aW9uOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5jdXN0b21pemF0aW9uLkN1c3RvbWl6YXRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFRocm93RXhjZXB0aW9uc0NvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgVGhyb3dFeGNlcHRpb25zQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8Q3VzdG9taXphdGlvbj4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPlRocm93RXhjZXB0aW9uc0NvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50Q29udHJvbGxlcgotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50Ci0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBUaHJvd0V4Y2VwdGlvbnNDb21wb3NpdGUoCi0JCQkJCUZvcm1QYW5lPD8gZXh0ZW5kcyBDdXN0b21pemF0aW9uPiBwYXJlbnRDb21wb3NpdGUsCi0JCQkJCUNvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRDb21wb3NpdGUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZFRocm93RXhjZXB0aW9uc0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q3VzdG9taXphdGlvbiwgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDdXN0b21pemF0aW9uLlRIUk9XX0VYQ0VQVElPTlNfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3QuZ2V0VGhyb3dFeGNlcHRpb25zKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlzdWJqZWN0LnNldFRocm93RXhjZXB0aW9ucyh2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc3ViamVjdENoYW5nZWQoKSB7Ci0JCQkJT2JqZWN0IG9sZFZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCQkJCXN1cGVyLnN1YmplY3RDaGFuZ2VkKCk7Ci0JCQkJT2JqZWN0IG5ld1ZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCi0JCQkJLy8gTWFrZSBzdXJlIHRoZSBkZWZhdWx0IHZhbHVlIGlzIGFwcGVuZGVkIHRvIHRoZSB0ZXh0Ci0JCQkJaWYgKG9sZFZhbHVlID09IG5ld1ZhbHVlICYmIG5ld1ZhbHVlID09IG51bGwpIHsKLQkJCQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKEJvb2xlYW4uVFJVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkVGhyb3dFeGNlcHRpb25zU3RyaW5nSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4sIFN0cmluZz4oYnVpbGRUaHJvd0V4Y2VwdGlvbnNIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShCb29sZWFuIHZhbHVlKSB7Ci0JCQkJaWYgKChnZXRTdWJqZWN0KCkgIT0gbnVsbCkgJiYgKHZhbHVlID09IG51bGwpKSB7Ci0JCQkJCUJvb2xlYW4gZGVmYXVsdFZhbHVlID0gZ2V0U3ViamVjdCgpLmdldERlZmF1bHRUaHJvd0V4Y2VwdGlvbnMoKTsKLQkJCQkJaWYgKGRlZmF1bHRWYWx1ZSAhPSBudWxsKSB7Ci0JCQkJCQlTdHJpbmcgZGVmYXVsdFN0cmluZ1ZhbHVlID0gZGVmYXVsdFZhbHVlID8gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fVHJ1ZSA6IEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5Cb29sZWFuX0ZhbHNlOwotCQkJCQkJcmV0dXJuIE5MUy5iaW5kKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfdGhyb3dFeGNlcHRpb25zTGFiZWxEZWZhdWx0LCBkZWZhdWx0U3RyaW5nVmFsdWUpOwotCQkJCQl9Ci0JCQkJfQotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3Rocm93RXhjZXB0aW9uc0xhYmVsOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXRoaXMuYWRkVHJpU3RhdGVDaGVja0JveFdpdGhEZWZhdWx0KAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl90aHJvd0V4Y2VwdGlvbnNMYWJlbCwKLQkJCXRoaXMuYnVpbGRUaHJvd0V4Y2VwdGlvbnNIb2xkZXIoKSwKLQkJCXRoaXMuYnVpbGRUaHJvd0V4Y2VwdGlvbnNTdHJpbmdIb2xkZXIoKSwKLQkJCW51bGwKLS8vCQkJRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcy5DVVNUT01JWkFUSU9OX1RIUk9XX0VYQ0VQVElPTlMKLQkJKTsKLQl9Ci0JCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jdXN0b21pemF0aW9uL1ZhbGlkYXRpb25Pbmx5Q29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jdXN0b21pemF0aW9uL1ZhbGlkYXRpb25Pbmx5Q29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDdhZjU2YmMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9WYWxpZGF0aW9uT25seUNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsOTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY3VzdG9taXphdGlvbjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY3VzdG9taXphdGlvbi5DdXN0b21pemF0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5vc2dpLnV0aWwuTkxTOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBWYWxpZGF0aW9uT25seUNvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgVmFsaWRhdGlvbk9ubHlDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxDdXN0b21pemF0aW9uPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+VmFsaWRhdGlvbk9ubHlDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudENvbnRyb2xsZXIKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudAotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgVmFsaWRhdGlvbk9ubHlDb21wb3NpdGUoCi0JCQkJCUZvcm1QYW5lPD8gZXh0ZW5kcyBDdXN0b21pemF0aW9uPiBwYXJlbnRDb21wb3NpdGUsCi0JCQkJCUNvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRDb21wb3NpdGUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZFZhbGlkYXRpb25Pbmx5SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDdXN0b21pemF0aW9uLCBCb29sZWFuPihnZXRTdWJqZWN0SG9sZGVyKCksIEN1c3RvbWl6YXRpb24uVkFMSURBVElPTl9PTkxZX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBzdWJqZWN0LmdldFZhbGlkYXRpb25Pbmx5KCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlzdWJqZWN0LnNldFZhbGlkYXRpb25Pbmx5KHZhbHVlKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzdWJqZWN0Q2hhbmdlZCgpIHsKLQkJCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0JCQkJc3VwZXIuc3ViamVjdENoYW5nZWQoKTsKLQkJCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0KLQkJCQkvLyBNYWtlIHN1cmUgdGhlIGRlZmF1bHQgdmFsdWUgaXMgYXBwZW5kZWQgdG8gdGhlIHRleHQKLQkJCQlpZiAob2xkVmFsdWUgPT0gbmV3VmFsdWUgJiYgbmV3VmFsdWUgPT0gbnVsbCkgewotCQkJCQl0aGlzLmZpcmVBc3BlY3RDaGFuZ2UoQm9vbGVhbi5UUlVFLCBuZXdWYWx1ZSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRWYWxpZGF0aW9uT25seVN0cmluZ0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuLCBTdHJpbmc+KGJ1aWxkVmFsaWRhdGlvbk9ubHlIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShCb29sZWFuIHZhbHVlKSB7Ci0JCQkJaWYgKChnZXRTdWJqZWN0KCkgIT0gbnVsbCkgJiYgKHZhbHVlID09IG51bGwpKSB7Ci0JCQkJCUJvb2xlYW4gZGVmYXVsdFZhbHVlID0gZ2V0U3ViamVjdCgpLmdldERlZmF1bHRWYWxpZGF0aW9uT25seSgpOwotCQkJCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCQkJCVN0cmluZyBkZWZhdWx0U3RyaW5nVmFsdWUgPSBkZWZhdWx0VmFsdWUgPyBFY2xpcHNlTGlua1VpTWVzc2FnZXMuQm9vbGVhbl9UcnVlIDogRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fRmFsc2U7Ci0JCQkJCQlyZXR1cm4gTkxTLmJpbmQoRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl92YWxpZGF0aW9uT25seUxhYmVsRGVmYXVsdCwgZGVmYXVsdFN0cmluZ1ZhbHVlKTsKLQkJCQkJfQotCQkJCX0KLQkJCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl92YWxpZGF0aW9uT25seUxhYmVsOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXRoaXMuYWRkVHJpU3RhdGVDaGVja0JveFdpdGhEZWZhdWx0KAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl92YWxpZGF0aW9uT25seUxhYmVsLAotCQkJdGhpcy5idWlsZFZhbGlkYXRpb25Pbmx5SG9sZGVyKCksCi0JCQl0aGlzLmJ1aWxkVmFsaWRhdGlvbk9ubHlTdHJpbmdIb2xkZXIoKSwKLQkJCW51bGwKLS8vCQkJRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcy4KLQkJKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jdXN0b21pemF0aW9uL1dlYXZpbmdDaGFuZ2VUcmFja2luZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9XZWF2aW5nQ2hhbmdlVHJhY2tpbmdDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzM5ODJhMy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jdXN0b21pemF0aW9uL1dlYXZpbmdDaGFuZ2VUcmFja2luZ0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsOTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuY3VzdG9taXphdGlvbjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuY3VzdG9taXphdGlvbi5DdXN0b21pemF0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5vc2dpLnV0aWwuTkxTOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBXZWF2aW5nQ2hhbmdlVHJhY2tpbmdDb21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIFdlYXZpbmdDaGFuZ2VUcmFja2luZ0NvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPEN1c3RvbWl6YXRpb24+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5XZWF2aW5nQ2hhbmdlVHJhY2tpbmdDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudENvbnRyb2xsZXIKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudAotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgV2VhdmluZ0NoYW5nZVRyYWNraW5nQ29tcG9zaXRlKAotCQkJCQlGb3JtUGFuZTw/IGV4dGVuZHMgQ3VzdG9taXphdGlvbj4gcGFyZW50Q29tcG9zaXRlLAotCQkJCQlDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRXZWF2aW5nQ2hhbmdlVHJhY2tpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEN1c3RvbWl6YXRpb24sIEJvb2xlYW4+KGdldFN1YmplY3RIb2xkZXIoKSwgQ3VzdG9taXphdGlvbi5XRUFWSU5HX0NIQU5HRV9UUkFDS0lOR19QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRXZWF2aW5nQ2hhbmdlVHJhY2tpbmcoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCXN1YmplY3Quc2V0V2VhdmluZ0NoYW5nZVRyYWNraW5nKHZhbHVlKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzdWJqZWN0Q2hhbmdlZCgpIHsKLQkJCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0JCQkJc3VwZXIuc3ViamVjdENoYW5nZWQoKTsKLQkJCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0KLQkJCQkvLyBNYWtlIHN1cmUgdGhlIGRlZmF1bHQgdmFsdWUgaXMgYXBwZW5kZWQgdG8gdGhlIHRleHQKLQkJCQlpZiAob2xkVmFsdWUgPT0gbmV3VmFsdWUgJiYgbmV3VmFsdWUgPT0gbnVsbCkgewotCQkJCQl0aGlzLmZpcmVBc3BlY3RDaGFuZ2UoQm9vbGVhbi5UUlVFLCBuZXdWYWx1ZSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRXZWF2aW5nQ2hhbmdlVHJhY2tpbmdTdHJpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbiwgU3RyaW5nPihidWlsZFdlYXZpbmdDaGFuZ2VUcmFja2luZ0hvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlpZiAoKGdldFN1YmplY3QoKSAhPSBudWxsKSAmJiAodmFsdWUgPT0gbnVsbCkpIHsKLQkJCQkJQm9vbGVhbiBkZWZhdWx0VmFsdWUgPSBnZXRTdWJqZWN0KCkuZ2V0RGVmYXVsdFdlYXZpbmdDaGFuZ2VUcmFja2luZygpOwotCQkJCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCQkJCVN0cmluZyBkZWZhdWx0U3RyaW5nVmFsdWUgPSBkZWZhdWx0VmFsdWUgPyBFY2xpcHNlTGlua1VpTWVzc2FnZXMuQm9vbGVhbl9UcnVlIDogRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fRmFsc2U7Ci0JCQkJCQlyZXR1cm4gTkxTLmJpbmQoRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl93ZWF2aW5nQ2hhbmdlVHJhY2tpbmdMYWJlbERlZmF1bHQsIGRlZmF1bHRTdHJpbmdWYWx1ZSk7Ci0JCQkJCX0KLQkJCQl9Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0NoYW5nZVRyYWNraW5nTGFiZWw7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJdGhpcy5hZGRUcmlTdGF0ZUNoZWNrQm94V2l0aERlZmF1bHQoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3dlYXZpbmdDaGFuZ2VUcmFja2luZ0xhYmVsLAotCQkJdGhpcy5idWlsZFdlYXZpbmdDaGFuZ2VUcmFja2luZ0hvbGRlcigpLAotCQkJdGhpcy5idWlsZFdlYXZpbmdDaGFuZ2VUcmFja2luZ1N0cmluZ0hvbGRlcigpLAotCQkJbnVsbAotLy8JCQlFY2xpcHNlTGlua0hlbHBDb250ZXh0SWRzLkNVU1RPTUlaQVRJT05fV0VBVklOR19DSEFOR0VfVFJBQ0tJTkcKLQkJKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jdXN0b21pemF0aW9uL1dlYXZpbmdDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vV2VhdmluZ0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjYTI3MGY2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vV2VhdmluZ0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb247Ci0KLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb24uQ3VzdG9taXphdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb24uV2VhdmluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkVudW1Gb3JtQ29tYm9WaWV3ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFdlYXZpbmdDb21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIFdlYXZpbmdDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxDdXN0b21pemF0aW9uPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+V2VhdmluZ0NvbXBvc2l0ZTwvY29kZT4uCi0JICogCi0JICogQHBhcmFtIHBhcmVudENvbnRyb2xsZXIKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudAotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgV2VhdmluZ0NvbXBvc2l0ZSgKLQkJCQkJRm9ybVBhbmU8PyBleHRlbmRzIEN1c3RvbWl6YXRpb24+IHBhcmVudENvbXBvc2l0ZSwgCi0JCQkJCUNvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlciggcGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgRW51bUZvcm1Db21ib1ZpZXdlcjxDdXN0b21pemF0aW9uLCBXZWF2aW5nPiBhZGRXZWF2aW5nQ29tYm8oQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlyZXR1cm4gbmV3IEVudW1Gb3JtQ29tYm9WaWV3ZXI8Q3VzdG9taXphdGlvbiwgV2VhdmluZz4odGhpcywgY29udGFpbmVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIGFkZFByb3BlcnR5TmFtZXMoQ29sbGVjdGlvbjxTdHJpbmc+IHByb3BlcnR5TmFtZXMpIHsKLQkJCQlzdXBlci5hZGRQcm9wZXJ0eU5hbWVzKHByb3BlcnR5TmFtZXMpOwotCQkJCXByb3BlcnR5TmFtZXMuYWRkKEN1c3RvbWl6YXRpb24uV0VBVklOR19QUk9QRVJUWSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFdlYXZpbmdbXSBnZXRDaG9pY2VzKCkgewotCQkJCXJldHVybiBXZWF2aW5nLnZhbHVlcygpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBXZWF2aW5nIGdldERlZmF1bHRWYWx1ZSgpIHsKLQkJCQlyZXR1cm4gZ2V0U3ViamVjdCgpLmdldERlZmF1bHRXZWF2aW5nKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBkaXNwbGF5U3RyaW5nKFdlYXZpbmcgdmFsdWUpIHsKLQkJCQlyZXR1cm4gYnVpbGREaXNwbGF5U3RyaW5nKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5jbGFzcywgV2VhdmluZ0NvbXBvc2l0ZS50aGlzLCB2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFdlYXZpbmcgZ2V0VmFsdWUoKSB7Ci0JCQkJcmV0dXJuIGdldFN1YmplY3QoKS5nZXRXZWF2aW5nKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWUoV2VhdmluZyB2YWx1ZSkgewotCQkJCWdldFN1YmplY3QoKS5zZXRXZWF2aW5nKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dCggQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXRoaXMuYWRkTGFiZWxlZENvbXBvc2l0ZSgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0xhYmVsLAotCQkJdGhpcy5hZGRXZWF2aW5nQ29tYm8oIGNvbnRhaW5lciksCi0JCQludWxsCQkvLyBUT0RPIElKcGFIZWxwQ29udGV4dElkcy4KLQkJKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vV2VhdmluZ0VhZ2VyQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9jdXN0b21pemF0aW9uL1dlYXZpbmdFYWdlckNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyNWRjOTJiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vV2VhdmluZ0VhZ2VyQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw5NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5jdXN0b21pemF0aW9uOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5jdXN0b21pemF0aW9uLkN1c3RvbWl6YXRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFdlYXZpbmdFYWdlckNvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgV2VhdmluZ0VhZ2VyQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8Q3VzdG9taXphdGlvbj4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPldlYXZpbmdFYWdlckNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50Q29udHJvbGxlcgotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50Ci0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBXZWF2aW5nRWFnZXJDb21wb3NpdGUoCi0JCQkJCUZvcm1QYW5lPD8gZXh0ZW5kcyBDdXN0b21pemF0aW9uPiBwYXJlbnRDb21wb3NpdGUsCi0JCQkJCUNvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRDb21wb3NpdGUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZFdlYXZpbmdFYWdlckhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q3VzdG9taXphdGlvbiwgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDdXN0b21pemF0aW9uLldFQVZJTkdfRUFHRVJfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3QuZ2V0V2VhdmluZ0VhZ2VyKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlzdWJqZWN0LnNldFdlYXZpbmdFYWdlcih2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc3ViamVjdENoYW5nZWQoKSB7Ci0JCQkJT2JqZWN0IG9sZFZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCQkJCXN1cGVyLnN1YmplY3RDaGFuZ2VkKCk7Ci0JCQkJT2JqZWN0IG5ld1ZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCi0JCQkJLy8gTWFrZSBzdXJlIHRoZSBkZWZhdWx0IHZhbHVlIGlzIGFwcGVuZGVkIHRvIHRoZSB0ZXh0Ci0JCQkJaWYgKG9sZFZhbHVlID09IG5ld1ZhbHVlICYmIG5ld1ZhbHVlID09IG51bGwpIHsKLQkJCQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKEJvb2xlYW4uVFJVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkV2VhdmluZ0VhZ2VyU3RyaW5nSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4sIFN0cmluZz4oYnVpbGRXZWF2aW5nRWFnZXJIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShCb29sZWFuIHZhbHVlKSB7Ci0JCQkJaWYgKChnZXRTdWJqZWN0KCkgIT0gbnVsbCkgJiYgKHZhbHVlID09IG51bGwpKSB7Ci0JCQkJCUJvb2xlYW4gZGVmYXVsdFZhbHVlID0gZ2V0U3ViamVjdCgpLmdldERlZmF1bHRXZWF2aW5nRWFnZXIoKTsKLQkJCQkJaWYgKGRlZmF1bHRWYWx1ZSAhPSBudWxsKSB7Ci0JCQkJCQlTdHJpbmcgZGVmYXVsdFN0cmluZ1ZhbHVlID0gZGVmYXVsdFZhbHVlID8gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fVHJ1ZSA6IEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5Cb29sZWFuX0ZhbHNlOwotCQkJCQkJcmV0dXJuIE5MUy5iaW5kKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0VhZ2VyTGFiZWxEZWZhdWx0LCBkZWZhdWx0U3RyaW5nVmFsdWUpOwotCQkJCQl9Ci0JCQkJfQotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3dlYXZpbmdFYWdlckxhYmVsOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXRoaXMuYWRkVHJpU3RhdGVDaGVja0JveFdpdGhEZWZhdWx0KAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl93ZWF2aW5nRWFnZXJMYWJlbCwKLQkJCXRoaXMuYnVpbGRXZWF2aW5nRWFnZXJIb2xkZXIoKSwKLQkJCXRoaXMuYnVpbGRXZWF2aW5nRWFnZXJTdHJpbmdIb2xkZXIoKSwKLQkJCW51bGwKLS8vCQkJRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcy5fCi0JCSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9XZWF2aW5nRmV0Y2hHcm91cHNDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vV2VhdmluZ0ZldGNoR3JvdXBzQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJlODY3YWQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9XZWF2aW5nRmV0Y2hHcm91cHNDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDk2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb24uQ3VzdG9taXphdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogV2VhdmluZ0ZldGNoR3JvdXBzQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBXZWF2aW5nRmV0Y2hHcm91cHNDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxDdXN0b21pemF0aW9uPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+V2VhdmluZ0ZldGNoR3JvdXBzQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRDb250cm9sbGVyCi0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIFdlYXZpbmdGZXRjaEdyb3Vwc0NvbXBvc2l0ZSgKLQkJCQkJRm9ybVBhbmU8PyBleHRlbmRzIEN1c3RvbWl6YXRpb24+IHBhcmVudENvbXBvc2l0ZSwKLQkJCQkJQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudENvbXBvc2l0ZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkV2VhdmluZ0xhenlIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEN1c3RvbWl6YXRpb24sIEJvb2xlYW4+KGdldFN1YmplY3RIb2xkZXIoKSwgQ3VzdG9taXphdGlvbi5XRUFWSU5HX0ZFVENIX0dST1VQU19QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRXZWF2aW5nRmV0Y2hHcm91cHMoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCXN1YmplY3Quc2V0V2VhdmluZ0ZldGNoR3JvdXBzKHZhbHVlKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzdWJqZWN0Q2hhbmdlZCgpIHsKLQkJCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0JCQkJc3VwZXIuc3ViamVjdENoYW5nZWQoKTsKLQkJCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0KLQkJCQkvLyBNYWtlIHN1cmUgdGhlIGRlZmF1bHQgdmFsdWUgaXMgYXBwZW5kZWQgdG8gdGhlIHRleHQKLQkJCQlpZiAob2xkVmFsdWUgPT0gbmV3VmFsdWUgJiYgbmV3VmFsdWUgPT0gbnVsbCkgewotCQkJCQl0aGlzLmZpcmVBc3BlY3RDaGFuZ2UoQm9vbGVhbi5UUlVFLCBuZXdWYWx1ZSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRXZWF2aW5nTGF6eVN0cmluZ0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuLCBTdHJpbmc+KGJ1aWxkV2VhdmluZ0xhenlIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShCb29sZWFuIHZhbHVlKSB7Ci0JCQkJaWYgKChnZXRTdWJqZWN0KCkgIT0gbnVsbCkgJiYgKHZhbHVlID09IG51bGwpKSB7Ci0JCQkJCUJvb2xlYW4gZGVmYXVsdFZhbHVlID0gZ2V0U3ViamVjdCgpLmdldERlZmF1bHRXZWF2aW5nTGF6eSgpOwotCQkJCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCQkJCVN0cmluZyBkZWZhdWx0U3RyaW5nVmFsdWUgPSBkZWZhdWx0VmFsdWUgPyBFY2xpcHNlTGlua1VpTWVzc2FnZXMuQm9vbGVhbl9UcnVlIDogRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fRmFsc2U7Ci0JCQkJCQlyZXR1cm4gTkxTLmJpbmQoRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl93ZWF2aW5nRmV0Y2hHcm91cHNMYWJlbERlZmF1bHQsIGRlZmF1bHRTdHJpbmdWYWx1ZSk7Ci0JCQkJCX0KLQkJCQl9Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0ZldGNoR3JvdXBzTGFiZWw7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJdGhpcy5hZGRUcmlTdGF0ZUNoZWNrQm94V2l0aERlZmF1bHQoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3dlYXZpbmdGZXRjaEdyb3Vwc0xhYmVsLAotCQkJdGhpcy5idWlsZFdlYXZpbmdMYXp5SG9sZGVyKCksCi0JCQl0aGlzLmJ1aWxkV2VhdmluZ0xhenlTdHJpbmdIb2xkZXIoKSwKLQkJCW51bGwKLS8vCQkJRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcy5DVVNUT01JWkFUSU9OX1dFQVZJTkdfRkVUQ0hfR1JPVVBTCi0JCSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9XZWF2aW5nSW50ZXJuYWxDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vV2VhdmluZ0ludGVybmFsQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGU3ZjdjNGEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9XZWF2aW5nSW50ZXJuYWxDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDk2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb24uQ3VzdG9taXphdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogV2VhdmluZ0ludGVybmFsQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBXZWF2aW5nSW50ZXJuYWxDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxDdXN0b21pemF0aW9uPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+V2VhdmluZ0ludGVybmFsQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRDb250cm9sbGVyCi0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIFdlYXZpbmdJbnRlcm5hbENvbXBvc2l0ZSgKLQkJCQkJRm9ybVBhbmU8PyBleHRlbmRzIEN1c3RvbWl6YXRpb24+IHBhcmVudENvbXBvc2l0ZSwKLQkJCQkJQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudENvbXBvc2l0ZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkV2VhdmluZ0ludGVybmFsSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxDdXN0b21pemF0aW9uLCBCb29sZWFuPihnZXRTdWJqZWN0SG9sZGVyKCksIEN1c3RvbWl6YXRpb24uV0VBVklOR19JTlRFUk5BTF9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRXZWF2aW5nSW50ZXJuYWwoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCXN1YmplY3Quc2V0V2VhdmluZ0ludGVybmFsKHZhbHVlKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzdWJqZWN0Q2hhbmdlZCgpIHsKLQkJCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0JCQkJc3VwZXIuc3ViamVjdENoYW5nZWQoKTsKLQkJCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0KLQkJCQkvLyBNYWtlIHN1cmUgdGhlIGRlZmF1bHQgdmFsdWUgaXMgYXBwZW5kZWQgdG8gdGhlIHRleHQKLQkJCQlpZiAob2xkVmFsdWUgPT0gbmV3VmFsdWUgJiYgbmV3VmFsdWUgPT0gbnVsbCkgewotCQkJCQl0aGlzLmZpcmVBc3BlY3RDaGFuZ2UoQm9vbGVhbi5UUlVFLCBuZXdWYWx1ZSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRXZWF2aW5nSW50ZXJuYWxTdHJpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbiwgU3RyaW5nPihidWlsZFdlYXZpbmdJbnRlcm5hbEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlpZiAoKGdldFN1YmplY3QoKSAhPSBudWxsKSAmJiAodmFsdWUgPT0gbnVsbCkpIHsKLQkJCQkJQm9vbGVhbiBkZWZhdWx0VmFsdWUgPSBnZXRTdWJqZWN0KCkuZ2V0RGVmYXVsdFdlYXZpbmdJbnRlcm5hbCgpOwotCQkJCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCQkJCVN0cmluZyBkZWZhdWx0U3RyaW5nVmFsdWUgPSBkZWZhdWx0VmFsdWUgPyBFY2xpcHNlTGlua1VpTWVzc2FnZXMuQm9vbGVhbl9UcnVlIDogRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fRmFsc2U7Ci0JCQkJCQlyZXR1cm4gTkxTLmJpbmQoRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sQ3VzdG9taXphdGlvblRhYl93ZWF2aW5nSW50ZXJuYWxMYWJlbERlZmF1bHQsIGRlZmF1bHRTdHJpbmdWYWx1ZSk7Ci0JCQkJCX0KLQkJCQl9Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0ludGVybmFsTGFiZWw7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJdGhpcy5hZGRUcmlTdGF0ZUNoZWNrQm94V2l0aERlZmF1bHQoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxDdXN0b21pemF0aW9uVGFiX3dlYXZpbmdJbnRlcm5hbExhYmVsLAotCQkJdGhpcy5idWlsZFdlYXZpbmdJbnRlcm5hbEhvbGRlcigpLAotCQkJdGhpcy5idWlsZFdlYXZpbmdJbnRlcm5hbFN0cmluZ0hvbGRlcigpLAotCQkJbnVsbAotLy8JCQlFY2xpcHNlTGlua0hlbHBDb250ZXh0SWRzLl9XRUFWSU5HX0lOVEVSTkFMCi0JCSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9XZWF2aW5nTGF6eUNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvY3VzdG9taXphdGlvbi9XZWF2aW5nTGF6eUNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkNzFmYTc4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2N1c3RvbWl6YXRpb24vV2VhdmluZ0xhenlDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDk2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmN1c3RvbWl6YXRpb24uQ3VzdG9taXphdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogV2VhdmluZ0xhenlDb21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIFdlYXZpbmdMYXp5Q29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8Q3VzdG9taXphdGlvbj4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPldlYXZpbmdMYXp5Q29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRDb250cm9sbGVyCi0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIFdlYXZpbmdMYXp5Q29tcG9zaXRlKAotCQkJCQlGb3JtUGFuZTw/IGV4dGVuZHMgQ3VzdG9taXphdGlvbj4gcGFyZW50Q29tcG9zaXRlLAotCQkJCQlDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRXZWF2aW5nTGF6eUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8Q3VzdG9taXphdGlvbiwgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBDdXN0b21pemF0aW9uLldFQVZJTkdfTEFaWV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRXZWF2aW5nTGF6eSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJc3ViamVjdC5zZXRXZWF2aW5nTGF6eSh2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc3ViamVjdENoYW5nZWQoKSB7Ci0JCQkJT2JqZWN0IG9sZFZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCQkJCXN1cGVyLnN1YmplY3RDaGFuZ2VkKCk7Ci0JCQkJT2JqZWN0IG5ld1ZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCi0JCQkJLy8gTWFrZSBzdXJlIHRoZSBkZWZhdWx0IHZhbHVlIGlzIGFwcGVuZGVkIHRvIHRoZSB0ZXh0Ci0JCQkJaWYgKG9sZFZhbHVlID09IG5ld1ZhbHVlICYmIG5ld1ZhbHVlID09IG51bGwpIHsKLQkJCQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKEJvb2xlYW4uVFJVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkV2VhdmluZ0xhenlTdHJpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbiwgU3RyaW5nPihidWlsZFdlYXZpbmdMYXp5SG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oQm9vbGVhbiB2YWx1ZSkgewotCQkJCWlmICgoZ2V0U3ViamVjdCgpICE9IG51bGwpICYmICh2YWx1ZSA9PSBudWxsKSkgewotCQkJCQlCb29sZWFuIGRlZmF1bHRWYWx1ZSA9IGdldFN1YmplY3QoKS5nZXREZWZhdWx0V2VhdmluZ0xhenkoKTsKLQkJCQkJaWYgKGRlZmF1bHRWYWx1ZSAhPSBudWxsKSB7Ci0JCQkJCQlTdHJpbmcgZGVmYXVsdFN0cmluZ1ZhbHVlID0gZGVmYXVsdFZhbHVlID8gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fVHJ1ZSA6IEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5Cb29sZWFuX0ZhbHNlOwotCQkJCQkJcmV0dXJuIE5MUy5iaW5kKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0xhenlMYWJlbERlZmF1bHQsIGRlZmF1bHRTdHJpbmdWYWx1ZSk7Ci0JCQkJCX0KLQkJCQl9Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0xhenlMYWJlbDsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQl0aGlzLmFkZFRyaVN0YXRlQ2hlY2tCb3hXaXRoRGVmYXVsdCgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbEN1c3RvbWl6YXRpb25UYWJfd2VhdmluZ0xhenlMYWJlbCwKLQkJCXRoaXMuYnVpbGRXZWF2aW5nTGF6eUhvbGRlcigpLAotCQkJdGhpcy5idWlsZFdlYXZpbmdMYXp5U3RyaW5nSG9sZGVyKCksCi0JCQludWxsCi0vLwkJCUVjbGlwc2VMaW5rSGVscENvbnRleHRJZHMuQ1VTVE9NSVpBVElPTl9XRUFWSU5HX0xBWlkKLQkJKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9nZW5lcmFsL0VjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0R2VuZXJhbENvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvZ2VuZXJhbC9FY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdEdlbmVyYWxDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDU2ZWFhMC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9nZW5lcmFsL0VjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0R2VuZXJhbENvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuZ2VuZXJhbDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnBlcnNpc3RlbmNlLkpwdFVpUGVyc2lzdGVuY2VNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuZGV0YWlscy5QZXJzaXN0ZW5jZVVuaXRHZW5lcmFsQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXRHZW5lcmFsQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdEdlbmVyYWxDb21wb3NpdGUKLQlleHRlbmRzIFBlcnNpc3RlbmNlVW5pdEdlbmVyYWxDb21wb3NpdGUKLXsKLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0JcHVibGljIEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0R2VuZXJhbENvbXBvc2l0ZSgKLQkJUHJvcGVydHlWYWx1ZU1vZGVsPEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0PiBzdWJqZWN0SG9sZGVyLAotCQkJCQlDb21wb3NpdGUgY29udGFpbmVyLAotCQkJCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgY29udGFpbmVyLCB3aWRnZXRGYWN0b3J5KTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJdGhpcy5pbml0aWFsaXplR2VuZXJhbFBhbmUoY29udGFpbmVyKTsKLQkJdGhpcy5pbml0aWFsaXplTWFwcGVkQ2xhc3Nlc1BhbmUoY29udGFpbmVyKTsKLQkJdGhpcy5pbml0aWFsaXplSlBBTWFwcGluZ0Rlc2NyaXB0b3JzUGFuZShjb250YWluZXIpOwotCX0KLQkKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplSlBBTWFwcGluZ0Rlc2NyaXB0b3JzUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJY29udGFpbmVyID0gYWRkU2VjdGlvbigKLQkJCWNvbnRhaW5lciwKLQkJCUpwdFVpUGVyc2lzdGVuY2VNZXNzYWdlcy5QZXJzaXN0ZW5jZVVuaXRHZW5lcmFsQ29tcG9zaXRlX2pwYU1hcHBpbmdEZXNjcmlwdG9ycywKLQkJCUpwdFVpUGVyc2lzdGVuY2VNZXNzYWdlcy5QZXJzaXN0ZW5jZVVuaXRHZW5lcmFsQ29tcG9zaXRlX2pwYU1hcHBpbmdEZXNjcmlwdG9yc19kZXNjcmlwdGlvbgotCQkpOwotCi0JCXVwZGF0ZUdyaWREYXRhKGNvbnRhaW5lcik7Ci0JCXVwZGF0ZUdyaWREYXRhKGNvbnRhaW5lci5nZXRQYXJlbnQoKSk7Ci0KLQkJbmV3IEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0TWFwcGluZ0ZpbGVzQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2dlbmVyYWwvRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXRNYXBwaW5nRmlsZXNDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2dlbmVyYWwvRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXRNYXBwaW5nRmlsZXNDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNWExZDY2Yy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9nZW5lcmFsL0VjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0TWFwcGluZ0ZpbGVzQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMzUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5nZW5lcmFsOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5wZXJzaXN0ZW5jZS5QZXJzaXN0ZW5jZVVuaXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5FY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmdlbmVyYWwuR2VuZXJhbFByb3BlcnRpZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UuZGV0YWlscy5QZXJzaXN0ZW5jZVVuaXRNYXBwaW5nRmlsZXNDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIEhlcmUgdGhlIGxheW91dCBvZiB0aGlzIHBhbmU6Ci0gKiA8cHJlPgotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLSAqIHwgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSB8Ci0gKiB8IHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgfAotICogfCB8IEFkZFJlbW92ZUxpc3RQYW5lICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHwKLSAqIHwgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCB8Ci0gKiB8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gfAotICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS08L3ByZT4KLSAqCi0gKiBAc2VlIFBlcnNpc3RlbmNlVW5pdAotICogQHNlZSBQZXJzaXN0ZW5jZVVuaXRHZW5lcmFsQ29tcG9zaXRlIC0gVGhlIHBhcmVudCBjb250YWluZXIKLSAqIEBzZWUgQWRkUmVtb3ZlTGlzdFBhbmUKLSAqCi0gKiBAdmVyc2lvbiAyLjAKLSAqIEBzaW5jZSAyLjAKLSAqLwotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0TWFwcGluZ0ZpbGVzQ29tcG9zaXRlIGV4dGVuZHMgUGVyc2lzdGVuY2VVbml0TWFwcGluZ0ZpbGVzQ29tcG9zaXRlCi17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5QZXJzaXN0ZW5jZVVuaXRNYXBwaW5nRmlsZXNDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudFBhbmUgVGhlIHBhcmVudCBwYW5lIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdE1hcHBpbmdGaWxlc0NvbXBvc2l0ZShQYW5lPD8gZXh0ZW5kcyBQZXJzaXN0ZW5jZVVuaXQ+IHBhcmVudFBhbmUsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50UGFuZSwgcGFyZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJYWRkTWFwcGluZ0ZpbGVzTGlzdChjb250YWluZXIpOwotCQlhZGRUcmlTdGF0ZUNoZWNrQm94V2l0aERlZmF1bHQoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxHZW5lcmFsVGFiX2V4Y2x1ZGVFY2xpcHNlbGlua09ybSwKLQkJCXRoaXMuYnVpbGRFeGNsdWRlRWNsaXBzZWxpbmtPcm1Ib2xkZXIoKSwKLQkJCXRoaXMuYnVpbGRFeGNsdWRlRWNsaXBzZWxpbmtPcm1TdHJpbmdIb2xkZXIoKSwKLQkJCW51bGwKLQkJKTsKLQotCX0KLQkKLQkKLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsPEdlbmVyYWxQcm9wZXJ0aWVzPiBidWlsZEdlbmVyYWxQcm9wZXJ0aWVzSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPFBlcnNpc3RlbmNlVW5pdCwgR2VuZXJhbFByb3BlcnRpZXM+KGdldFN1YmplY3RIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgR2VuZXJhbFByb3BlcnRpZXMgdHJhbnNmb3JtXyhQZXJzaXN0ZW5jZVVuaXQgcGVyc2lzdGVuY2VVbml0KSB7Ci0JCQkJcmV0dXJuICgoRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQpIHBlcnNpc3RlbmNlVW5pdCkuZ2V0R2VuZXJhbFByb3BlcnRpZXMoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZEV4Y2x1ZGVFY2xpcHNlbGlua09ybUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8R2VuZXJhbFByb3BlcnRpZXMsIEJvb2xlYW4+KAotCQkJYnVpbGRHZW5lcmFsUHJvcGVydGllc0hvbGRlcigpLAotCQkJR2VuZXJhbFByb3BlcnRpZXMuRVhDTFVERV9FQ0xJUFNFTElOS19PUk1fUFJPUEVSVFkpCi0JCXsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRFeGNsdWRlRWNsaXBzZWxpbmtPcm0oKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCXRoaXMuc3ViamVjdC5zZXRFeGNsdWRlRWNsaXBzZWxpbmtPcm0odmFsdWUpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHN1YmplY3RDaGFuZ2VkKCkgewotCQkJCU9iamVjdCBvbGRWYWx1ZSA9IHRoaXMuZ2V0VmFsdWUoKTsKLQkJCQlzdXBlci5zdWJqZWN0Q2hhbmdlZCgpOwotCQkJCU9iamVjdCBuZXdWYWx1ZSA9IHRoaXMuZ2V0VmFsdWUoKTsKLQotCQkJCS8vIE1ha2Ugc3VyZSB0aGUgZGVmYXVsdCB2YWx1ZSBpcyBhcHBlbmRlZCB0byB0aGUgdGV4dAotCQkJCWlmIChvbGRWYWx1ZSA9PSBuZXdWYWx1ZSAmJiBuZXdWYWx1ZSA9PSBudWxsKSB7Ci0JCQkJCXRoaXMuZmlyZUFzcGVjdENoYW5nZShCb29sZWFuLlRSVUUsIG5ld1ZhbHVlKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZEV4Y2x1ZGVFY2xpcHNlbGlua09ybVN0cmluZ0hvbGRlcigpIHsKLQotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4sIFN0cmluZz4oYnVpbGRFeGNsdWRlRWNsaXBzZWxpbmtPcm1Ib2xkZXIoKSkgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKEJvb2xlYW4gdmFsdWUpIHsKLQotCQkJCWlmICgoZ2V0U3ViamVjdCgpICE9IG51bGwpICYmICh2YWx1ZSA9PSBudWxsKSkgewotCi0JCQkJCUJvb2xlYW4gZGVmYXVsdFZhbHVlID0gKChFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdCkgZ2V0U3ViamVjdCgpKS5nZXRHZW5lcmFsUHJvcGVydGllcygpLmdldERlZmF1bHRFeGNsdWRlRWNsaXBzZWxpbmtPcm0oKTsKLQotCQkJCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQotCQkJCQkJU3RyaW5nIGRlZmF1bHRTdHJpbmdWYWx1ZSA9IGRlZmF1bHRWYWx1ZSA/IEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5Cb29sZWFuX1RydWUgOgotCQkJCQkJCQkJCQkJCQkJCQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5Cb29sZWFuX0ZhbHNlOwotCi0JCQkJCQlyZXR1cm4gTkxTLmJpbmQoCi0JCQkJCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sR2VuZXJhbFRhYl9leGNsdWRlRWNsaXBzZWxpbmtPcm1XaXRoRGVmYXVsdCwKLQkJCQkJCQlkZWZhdWx0U3RyaW5nVmFsdWUKLQkJCQkJCSk7Ci0JCQkJCX0KLQkJCQl9Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbEdlbmVyYWxUYWJfZXhjbHVkZUVjbGlwc2VsaW5rT3JtOwotCQkJfQotCQl9OwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9sb2dnaW5nL0VjbGlwc2VMaW5rTG9nZ2luZ0NvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvbG9nZ2luZy9FY2xpcHNlTGlua0xvZ2dpbmdDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmQ5M2M3ZC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9sb2dnaW5nL0VjbGlwc2VMaW5rTG9nZ2luZ0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmxvZ2dpbmc7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmxvZ2dpbmcuTG9nZ2luZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkZvcm1QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5TV1Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkRGF0YTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWRMYXlvdXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnVpLmZvcm1zLndpZGdldHMuRXhwYW5kYWJsZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS51aS5mb3Jtcy53aWRnZXRzLlNlY3Rpb247Ci0KLS8qKgotICogRWNsaXBzZUxpbmtMb2dnaW5nQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua0xvZ2dpbmdDb21wb3NpdGUKLQlleHRlbmRzIEZvcm1QYW5lPExvZ2dpbmc+Ci17Ci0JcHVibGljIEVjbGlwc2VMaW5rTG9nZ2luZ0NvbXBvc2l0ZSgKLQkJCQkJRm9ybVBhbmU8TG9nZ2luZz4gc3ViamVjdEhvbGRlciwgCi0JCQkJCUNvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJc3VwZXIoc3ViamVjdEhvbGRlciwgY29udGFpbmVyLCBmYWxzZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgcGFyZW50KSB7Ci0JCVNlY3Rpb24gc2VjdGlvbiA9IGdldFdpZGdldEZhY3RvcnkoKS5jcmVhdGVTZWN0aW9uKHBhcmVudCwgU1dULkZMQVQgfCBFeHBhbmRhYmxlQ29tcG9zaXRlLlRJVExFX0JBUiB8IFNlY3Rpb24uREVTQ1JJUFRJT04pOwotCQlzZWN0aW9uLnNldFRleHQoRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl9zZWN0aW9uVGl0bGUpOwotCQlzZWN0aW9uLnNldERlc2NyaXB0aW9uKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfc2VjdGlvbkRlc2NyaXB0aW9uKTsKLQkJQ29tcG9zaXRlIGNvbXBvc2l0ZSA9IGdldFdpZGdldEZhY3RvcnkoKS5jcmVhdGVDb21wb3NpdGUoc2VjdGlvbik7Ci0JCWNvbXBvc2l0ZS5zZXRMYXlvdXQobmV3IEdyaWRMYXlvdXQoMSwgZmFsc2UpKTsKLQkJc2VjdGlvbi5zZXRDbGllbnQoY29tcG9zaXRlKTsKLQkJdGhpcy51cGRhdGVHcmlkRGF0YShjb21wb3NpdGUpOwotCQl0aGlzLnVwZGF0ZUdyaWREYXRhKGNvbXBvc2l0ZS5nZXRQYXJlbnQoKSk7Ci0JCQotCQkvLyBMb2dnaW5nTGV2ZWw6Ci0JCW5ldyBMb2dnaW5nTGV2ZWxDb21wb3NpdGUodGhpcywgY29tcG9zaXRlKTsKLQotCQkvLyBUaW1lc3RhbXA6Ci0JCW5ldyBUaW1lc3RhbXBDb21wb3NpdGUodGhpcywgY29tcG9zaXRlKTsKLQotCQkvLyBUaHJlYWQ6Ci0JCW5ldyBUaHJlYWRDb21wb3NpdGUodGhpcywgY29tcG9zaXRlKTsKLQotCQkvLyBTZXNzaW9uOgotCQluZXcgU2Vzc2lvbkNvbXBvc2l0ZSh0aGlzLCBjb21wb3NpdGUpOwotCi0JCS8vIEV4Y2VwdGlvbnM6Ci0JCW5ldyBFeGNlcHRpb25zQ29tcG9zaXRlKHRoaXMsIGNvbXBvc2l0ZSk7Ci0KLQkJLy8gTG9nZ2luZ0ZpbGU6Ci0JCW5ldyBMb2dnaW5nRmlsZUxvY2F0aW9uQ29tcG9zaXRlKHRoaXMsIGNvbXBvc2l0ZSk7Ci0JCQotCQkvLyBMb2dnZXI6Ci0JCW5ldyBMb2dnZXJDb21wb3NpdGUodGhpcywgY29tcG9zaXRlKTsKLQkJCi0JCXJldHVybjsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdXBkYXRlR3JpZERhdGEoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlHcmlkRGF0YSBncmlkRGF0YSA9IG5ldyBHcmlkRGF0YSgpOwotCQlncmlkRGF0YS5ncmFiRXhjZXNzSG9yaXpvbnRhbFNwYWNlID0gdHJ1ZTsKLQkJZ3JpZERhdGEuZ3JhYkV4Y2Vzc1ZlcnRpY2FsU3BhY2UgPSB0cnVlOwotCQlncmlkRGF0YS5ob3Jpem9udGFsQWxpZ25tZW50ID0gU1dULkZJTEw7Ci0JCWdyaWREYXRhLnZlcnRpY2FsQWxpZ25tZW50ID0gU1dULkZJTEw7Ci0JCWNvbnRhaW5lci5zZXRMYXlvdXREYXRhKGdyaWREYXRhKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9sb2dnaW5nL0V4Y2VwdGlvbnNDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2xvZ2dpbmcvRXhjZXB0aW9uc0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDEyNmFkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2xvZ2dpbmcvRXhjZXB0aW9uc0NvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsOTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UubG9nZ2luZzsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UubG9nZ2luZy5Mb2dnaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5vc2dpLnV0aWwuTkxTOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBFeGNlcHRpb25zQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBFeGNlcHRpb25zQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8TG9nZ2luZz4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkV4Y2VwdGlvbnNDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudENvbnRyb2xsZXIKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudAotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgRXhjZXB0aW9uc0NvbXBvc2l0ZSgKLQkJCQkJRm9ybVBhbmU8PyBleHRlbmRzIExvZ2dpbmc+IHBhcmVudENvbXBvc2l0ZSwKLQkJCQkJQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudENvbXBvc2l0ZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkRXhjZXB0aW9uc0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8TG9nZ2luZywgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBMb2dnaW5nLkVYQ0VQVElPTlNfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3QuZ2V0RXhjZXB0aW9ucygpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJc3ViamVjdC5zZXRFeGNlcHRpb25zKHZhbHVlKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzdWJqZWN0Q2hhbmdlZCgpIHsKLQkJCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0JCQkJc3VwZXIuc3ViamVjdENoYW5nZWQoKTsKLQkJCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0KLQkJCQkvLyBNYWtlIHN1cmUgdGhlIGRlZmF1bHQgdmFsdWUgaXMgYXBwZW5kZWQgdG8gdGhlIHRleHQKLQkJCQlpZiAob2xkVmFsdWUgPT0gbmV3VmFsdWUgJiYgbmV3VmFsdWUgPT0gbnVsbCkgewotCQkJCQl0aGlzLmZpcmVBc3BlY3RDaGFuZ2UoQm9vbGVhbi5UUlVFLCBuZXdWYWx1ZSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRFeGNlcHRpb25zU3RyaW5nSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4sIFN0cmluZz4oYnVpbGRFeGNlcHRpb25zSG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oQm9vbGVhbiB2YWx1ZSkgewotCQkJCWlmICgoZ2V0U3ViamVjdCgpICE9IG51bGwpICYmICh2YWx1ZSA9PSBudWxsKSkgewotCQkJCQlCb29sZWFuIGRlZmF1bHRWYWx1ZSA9IGdldFN1YmplY3QoKS5nZXREZWZhdWx0RXhjZXB0aW9ucygpOwotCQkJCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCQkJCVN0cmluZyBkZWZhdWx0U3RyaW5nVmFsdWUgPSBkZWZhdWx0VmFsdWUgPyBFY2xpcHNlTGlua1VpTWVzc2FnZXMuQm9vbGVhbl9UcnVlIDogRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fRmFsc2U7Ci0JCQkJCQlyZXR1cm4gTkxTLmJpbmQoRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl9leGNlcHRpb25zTGFiZWxEZWZhdWx0LCBkZWZhdWx0U3RyaW5nVmFsdWUpOwotCQkJCQl9Ci0JCQkJfQotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiX2V4Y2VwdGlvbnNMYWJlbDsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQl0aGlzLmFkZFRyaVN0YXRlQ2hlY2tCb3hXaXRoRGVmYXVsdCgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfZXhjZXB0aW9uc0xhYmVsLAotCQkJdGhpcy5idWlsZEV4Y2VwdGlvbnNIb2xkZXIoKSwKLQkJCXRoaXMuYnVpbGRFeGNlcHRpb25zU3RyaW5nSG9sZGVyKCksCi0JCQludWxsCi0vLwkJCUVjbGlwc2VMaW5rSGVscENvbnRleHRJZHMuTE9HR0lOR18KLQkJKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9sb2dnaW5nL0xvZ2dlckNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvbG9nZ2luZy9Mb2dnZXJDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggM2U1MGJiMi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9sb2dnaW5nL0xvZ2dlckNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjA3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0qIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0qIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotKgotKiBDb250cmlidXRvcnM6Ci0qICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5sb2dnaW5nOwotCi1pbXBvcnQgamF2YS50ZXh0LkNvbGxhdG9yOwotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbXBhcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLkpwYVByb2plY3Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5sb2dnaW5nLkxvZ2dlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmxvZ2dpbmcuTG9nZ2luZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkNsYXNzQ2hvb3NlckNvbWJvUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlRyYW5zZm9ybWF0aW9uSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuQ29tcG9zaXRlTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogIExvZ2dlckNvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgTG9nZ2VyQ29tcG9zaXRlIGV4dGVuZHMgQ2xhc3NDaG9vc2VyQ29tYm9QYW5lPExvZ2dpbmc+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5Mb2dnZXJDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudFBhbmUgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIExvZ2dlckNvbXBvc2l0ZSgKLQkJCQkJCQkJUGFuZTw/IGV4dGVuZHMgTG9nZ2luZz4gcGFyZW50UGFuZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50UGFuZSwgcGFyZW50KTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXRDbGFzc05hbWUoKSB7Ci0JCWlmICh0aGlzLmdldFN1YmplY3QoKS5nZXRMb2dnZXIoKSA9PSBudWxsKSB7Ci0JCQlyZXR1cm4gTG9nZ2VyLkRFRkFVTFRfTE9HR0VSX0NMQVNTX05BTUU7Ci0JCX0KLQkJcmV0dXJuIExvZ2dlci5nZXRMb2dnZXJDbGFzc05hbWUodGhpcy5nZXRTdWJqZWN0KCkuZ2V0TG9nZ2VyKCkpOwotCX0KLQotICAgIEBPdmVycmlkZQotICAgIHByb3RlY3RlZCBTdHJpbmcgZ2V0TGFiZWxUZXh0KCkgewotICAgIAlyZXR1cm4gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl9sb2dnZXJMYWJlbDsKLSAgICB9Ci0gICAgCi0gICAgQE92ZXJyaWRlCi0gICAgcHJvdGVjdGVkIEpwYVByb2plY3QgZ2V0SnBhUHJvamVjdCgpIHsKLSAgICAJcmV0dXJuIGdldFN1YmplY3QoKS5nZXRKcGFQcm9qZWN0KCk7Ci0gICAgfQotICAgIAotICAgIEBPdmVycmlkZQotICAgIHByb3RlY3RlZCBTdHJpbmcgZ2V0U3VwZXJJbnRlcmZhY2VOYW1lKCkgewotICAgIAlyZXR1cm4gTG9nZ2luZy5FQ0xJUFNFTElOS19MT0dHRVJfQ0xBU1NfTkFNRTsKLSAgICB9Ci0gICAgCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRUZXh0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxMb2dnaW5nLCBTdHJpbmc+KHRoaXMuZ2V0U3ViamVjdEhvbGRlcigpLCBMb2dnaW5nLkxPR0dFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCi0JCQkJU3RyaW5nIG5hbWUgPSB0aGlzLnN1YmplY3QuZ2V0TG9nZ2VyKCk7Ci0JCQkJaWYgKG5hbWUgPT0gbnVsbCkgewotCQkJCQluYW1lID0gTG9nZ2VyQ29tcG9zaXRlLnRoaXMuZ2V0RGVmYXVsdFZhbHVlKHRoaXMuc3ViamVjdCk7Ci0JCQkJfQotCQkJCXJldHVybiBuYW1lOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhTdHJpbmcgdmFsdWUpIHsKLQotCQkJCWlmIChnZXREZWZhdWx0VmFsdWUodGhpcy5zdWJqZWN0KS5lcXVhbHModmFsdWUpKSB7Ci0JCQkJCXZhbHVlID0gbnVsbDsKLQkJCQl9Ci0JCQkJdGhpcy5zdWJqZWN0LnNldExvZ2dlcih2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZERlZmF1bHRMb2dnZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPExvZ2dpbmcsIFN0cmluZz4odGhpcy5nZXRTdWJqZWN0SG9sZGVyKCksIExvZ2dpbmcuREVGQVVMVF9MT0dHRVIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gTG9nZ2VyQ29tcG9zaXRlLnRoaXMuZ2V0RGVmYXVsdFZhbHVlKHRoaXMuc3ViamVjdCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdExvZ2dlckxpc3RIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8U3RyaW5nPigKLQkJCXRoaXMuYnVpbGREZWZhdWx0TG9nZ2VySG9sZGVyKCkKLQkJKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBidWlsZERpc3BsYXlTdHJpbmcoU3RyaW5nIGxvZ2dlck5hbWUpIHsKLQotCQlzd2l0Y2ggKExvZ2dlci52YWx1ZU9mKGxvZ2dlck5hbWUpKSB7Ci0JCQljYXNlIGRlZmF1bHRfbG9nZ2VyOiB7Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5Mb2dnZXJDb21wb3NpdGVfZGVmYXVsdF9sb2dnZXI7Ci0JCQl9Ci0JCQljYXNlIGphdmFfbG9nZ2VyOiB7Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5Mb2dnZXJDb21wb3NpdGVfamF2YV9sb2dnZXI7Ci0JCQl9Ci0JCQljYXNlIHNlcnZlcl9sb2dnZXI6IHsKLQkJCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkxvZ2dlckNvbXBvc2l0ZV9zZXJ2ZXJfbG9nZ2VyOwotCQkJfQotCQkJZGVmYXVsdDogewotCQkJCXJldHVybiBudWxsOwotCQkJfQotCQl9Ci0JfQotCi0JcHJpdmF0ZSBDb21wYXJhdG9yPFN0cmluZz4gYnVpbGRMb2dnZXJDb21wYXJhdG9yKCkgewotCQlyZXR1cm4gbmV3IENvbXBhcmF0b3I8U3RyaW5nPigpIHsKLQkJCXB1YmxpYyBpbnQgY29tcGFyZShTdHJpbmcgbG9nZ2VyMSwgU3RyaW5nIGxvZ2dlcjIpIHsKLQkJCQlsb2dnZXIxID0gYnVpbGREaXNwbGF5U3RyaW5nKGxvZ2dlcjEpOwotCQkJCWxvZ2dlcjIgPSBidWlsZERpc3BsYXlTdHJpbmcobG9nZ2VyMik7Ci0JCQkJcmV0dXJuIENvbGxhdG9yLmdldEluc3RhbmNlKCkuY29tcGFyZShsb2dnZXIxLCBsb2dnZXIyKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nQ29udmVydGVyPFN0cmluZz4gYnVpbGRDbGFzc0NvbnZlcnRlcigpIHsKLQkJcmV0dXJuIG5ldyBTdHJpbmdDb252ZXJ0ZXI8U3RyaW5nPigpIHsKLQkJCXB1YmxpYyBTdHJpbmcgY29udmVydFRvU3RyaW5nKFN0cmluZyB2YWx1ZSkgewotCQkJCXRyeSB7Ci0JCQkJCUxvZ2dlci52YWx1ZU9mKHZhbHVlKTsKLQkJCQkJdmFsdWUgPSBidWlsZERpc3BsYXlTdHJpbmcodmFsdWUpOwotCQkJCX0KLQkJCQljYXRjaCAoRXhjZXB0aW9uIGUpIHsKLQkJCQkJLy8gSWdub3JlIHNpbmNlIHRoZSB2YWx1ZSBpcyBub3QgYSBMb2dnZXIKLQkJCQl9Ci0JCQkJcmV0dXJuIHZhbHVlOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkQ2xhc3NMaXN0SG9sZGVyKCkgewotCQlBcnJheUxpc3Q8TGlzdFZhbHVlTW9kZWw8U3RyaW5nPj4gaG9sZGVycyA9IG5ldyBBcnJheUxpc3Q8TGlzdFZhbHVlTW9kZWw8U3RyaW5nPj4oMik7Ci0JCWhvbGRlcnMuYWRkKHRoaXMuYnVpbGREZWZhdWx0TG9nZ2VyTGlzdEhvbGRlcigpKTsKLQkJaG9sZGVycy5hZGQodGhpcy5idWlsZExvZ2dlcnNMaXN0SG9sZGVyKCkpOwotCQlyZXR1cm4gbmV3IENvbXBvc2l0ZUxpc3RWYWx1ZU1vZGVsPExpc3RWYWx1ZU1vZGVsPFN0cmluZz4sIFN0cmluZz4oaG9sZGVycyk7Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkTG9nZ2VycygpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yPExvZ2dlciwgU3RyaW5nPihDb2xsZWN0aW9uVG9vbHMuaXRlcmF0b3IoTG9nZ2VyLnZhbHVlcygpKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShMb2dnZXIgbmV4dCkgewotCQkJCXJldHVybiBuZXh0Lm5hbWUoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRMb2dnZXJzQ29sbGVjdGlvbkhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+KAotCQkJQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24odGhpcy5idWlsZExvZ2dlcnMoKSkKLQkJKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRMb2dnZXJzTGlzdEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8U3RyaW5nPigKLQkJCXRoaXMuYnVpbGRMb2dnZXJzQ29sbGVjdGlvbkhvbGRlcigpLAotCQkJdGhpcy5idWlsZExvZ2dlckNvbXBhcmF0b3IoKQotCQkpOwotCX0KLQotCXByaXZhdGUgU3RyaW5nIGdldERlZmF1bHRWYWx1ZShMb2dnaW5nIHN1YmplY3QpIHsKLQkJU3RyaW5nIGRlZmF1bHRWYWx1ZSA9IHN1YmplY3QuZ2V0RGVmYXVsdExvZ2dlcigpOwotCi0JCWlmIChkZWZhdWx0VmFsdWUgIT0gbnVsbCkgewotCQkJcmV0dXJuIE5MUy5iaW5kKAotCQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfZGVmYXVsdFdpdGhPbmVQYXJhbSwKLQkJCQlkZWZhdWx0VmFsdWUKLQkJCSk7Ci0JCX0KLQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfZGVmYXVsdEVtcHR5OwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRDbGFzc05hbWUoU3RyaW5nIGNsYXNzTmFtZSkgewotCQl0aGlzLmdldFN1YmplY3QoKS5zZXRMb2dnZXIoY2xhc3NOYW1lKTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvbG9nZ2luZy9Mb2dnaW5nRmlsZUxvY2F0aW9uQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9sb2dnaW5nL0xvZ2dpbmdGaWxlTG9jYXRpb25Db21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMWI5MjZmYi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9sb2dnaW5nL0xvZ2dpbmdGaWxlTG9jYXRpb25Db21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDkyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0qIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0qIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotKiAKLSogQ29udHJpYnV0b3JzOgotKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UubG9nZ2luZzsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UubG9nZ2luZy5Mb2dnaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9sZGVyQ2hvb3NlclBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogIExvZ2dpbmdGaWxlTG9jYXRpb25Db21wb3NpdGUgCi0gKi8KLXB1YmxpYyBjbGFzcyBMb2dnaW5nRmlsZUxvY2F0aW9uQ29tcG9zaXRlIGV4dGVuZHMgUGFuZTxMb2dnaW5nPgotewotCXB1YmxpYyBMb2dnaW5nRmlsZUxvY2F0aW9uQ29tcG9zaXRlKFBhbmU8PyBleHRlbmRzIExvZ2dpbmc+IHBhcmVudFBhbmUsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50UGFuZSwgcGFyZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJCi0JCW5ldyBGb2xkZXJDaG9vc2VyUGFuZTxMb2dnaW5nPih0aGlzLCBjb250YWluZXIpIHsKLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFRleHRIb2xkZXIoKSB7Ci0JCQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8TG9nZ2luZywgU3RyaW5nPigKLQkJCQkJCQkJCQlnZXRTdWJqZWN0SG9sZGVyKCksIExvZ2dpbmcuTE9HX0ZJTEVfTE9DQVRJT05fUFJPUEVSVFkpIHsKLQkJCQkJQE92ZXJyaWRlCi0JCQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0KLQkJCQkJCVN0cmluZyBuYW1lID0gc3ViamVjdC5nZXRMb2dGaWxlTG9jYXRpb24oKTsKLQkJCQkJCWlmIChuYW1lID09IG51bGwpIHsKLQkJCQkJCQluYW1lID0gZGVmYXVsdFZhbHVlKHN1YmplY3QpOwotCQkJCQkJfQotCQkJCQkJcmV0dXJuIG5hbWU7Ci0JCQkJCX0KLQotCQkJCQlAT3ZlcnJpZGUKLQkJCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCi0JCQkJCQlpZiAoZGVmYXVsdFZhbHVlKHN1YmplY3QpLmVxdWFscyh2YWx1ZSkpIHsKLQkJCQkJCQl2YWx1ZSA9IG51bGw7Ci0JCQkJCQl9Ci0JCQkJCQlzdWJqZWN0LnNldExvZ0ZpbGVMb2NhdGlvbih2YWx1ZSk7Ci0JCQkJCX0KLQkJCQl9OwotCQkJfQotCi0JCQlwcml2YXRlIFN0cmluZyBkZWZhdWx0VmFsdWUoTG9nZ2luZyBzdWJqZWN0KSB7Ci0JCQkJU3RyaW5nIGRlZmF1bHRWYWx1ZSA9IHN1YmplY3QuZ2V0RGVmYXVsdExvZ0ZpbGVMb2NhdGlvbigpOwotCi0JCQkJaWYgKGRlZmF1bHRWYWx1ZSAhPSBudWxsKSB7Ci0JCQkJCXJldHVybiBOTFMuYmluZCgKLQkJCQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfZGVmYXVsdFdpdGhPbmVQYXJhbSwKLQkJCQkJCWRlZmF1bHRWYWx1ZQotCQkJCQkpOwotCQkJCX0KLQkJCQllbHNlIHsKLQkJCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfZGVmYXVsdEVtcHR5OwotCQkJCX0KLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGdldERpYWxvZ01lc3NhZ2UoKSB7Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5Mb2dnaW5nRmlsZUxvY2F0aW9uQ29tcG9zaXRlX2RpYWxvZ01lc3NhZ2U7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBnZXREaWFsb2dUaXRsZSgpIHsKLQkJCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkxvZ2dpbmdGaWxlTG9jYXRpb25Db21wb3NpdGVfZGlhbG9nVGl0bGU7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBnZXRMYWJlbFRleHQoKSB7Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfbG9nZ2luZ0ZpbGVMYWJlbDsKLQkJCX0KLQkJfTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9sb2dnaW5nL0xvZ2dpbmdMZXZlbENvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvbG9nZ2luZy9Mb2dnaW5nTGV2ZWxDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzEyNTE4OC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9sb2dnaW5nL0xvZ2dpbmdMZXZlbENvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLmxvZ2dpbmc7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmxvZ2dpbmcuTG9nZ2luZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLmxvZ2dpbmcuTG9nZ2luZ0xldmVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRW51bUZvcm1Db21ib1ZpZXdlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogTG9nZ2luZ0xldmVsQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBMb2dnaW5nTGV2ZWxDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxMb2dnaW5nPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+TG9nZ2luZ0xldmVsQ29tcG9zaXRlPC9jb2RlPi4KLQkgKiAKLQkgKiBAcGFyYW0gcGFyZW50Q29udHJvbGxlcgotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50Ci0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBMb2dnaW5nTGV2ZWxDb21wb3NpdGUoCi0JCQkJRm9ybVBhbmU8PyBleHRlbmRzIExvZ2dpbmc+IHBhcmVudENvbXBvc2l0ZSwgCi0JCQkJQ29tcG9zaXRlIHBhcmVudCkgewotCQkKLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgRW51bUZvcm1Db21ib1ZpZXdlcjxMb2dnaW5nLCBMb2dnaW5nTGV2ZWw+IGFkZExvZ2dpbmdMZXZlbENvbWJvKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJcmV0dXJuIG5ldyBFbnVtRm9ybUNvbWJvVmlld2VyPExvZ2dpbmcsIExvZ2dpbmdMZXZlbD4odGhpcywgY29udGFpbmVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIGFkZFByb3BlcnR5TmFtZXMoQ29sbGVjdGlvbjxTdHJpbmc+IHByb3BlcnR5TmFtZXMpIHsKLQkJCQlzdXBlci5hZGRQcm9wZXJ0eU5hbWVzKHByb3BlcnR5TmFtZXMpOwotCQkJCXByb3BlcnR5TmFtZXMuYWRkKExvZ2dpbmcuTEVWRUxfUFJPUEVSVFkpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBMb2dnaW5nTGV2ZWxbXSBnZXRDaG9pY2VzKCkgewotCQkJCXJldHVybiBMb2dnaW5nTGV2ZWwudmFsdWVzKCk7Ci0JCQl9Ci0JCQkKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGJvb2xlYW4gc29ydENob2ljZXMoKSB7Ci0JCQkJcmV0dXJuIGZhbHNlOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBMb2dnaW5nTGV2ZWwgZ2V0RGVmYXVsdFZhbHVlKCkgewotCQkJCXJldHVybiB0aGlzLmdldFN1YmplY3QoKS5nZXREZWZhdWx0TGV2ZWwoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGRpc3BsYXlTdHJpbmcoTG9nZ2luZ0xldmVsIHZhbHVlKSB7Ci0JCQkJcmV0dXJuIHRoaXMuYnVpbGREaXNwbGF5U3RyaW5nKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5jbGFzcywgTG9nZ2luZ0xldmVsQ29tcG9zaXRlLnRoaXMsIHZhbHVlKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgTG9nZ2luZ0xldmVsIGdldFZhbHVlKCkgewotCQkJCXJldHVybiB0aGlzLmdldFN1YmplY3QoKS5nZXRMZXZlbCgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlKExvZ2dpbmdMZXZlbCB2YWx1ZSkgewotCQkJCXRoaXMuZ2V0U3ViamVjdCgpLnNldExldmVsKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJdGhpcy5hZGRMYWJlbGVkQ29tcG9zaXRlKAotCQkJCWNvbnRhaW5lciwKLQkJCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiX2xvZ2dpbmdMZXZlbExhYmVsLAotCQkJCXRoaXMuYWRkTG9nZ2luZ0xldmVsQ29tYm8oY29udGFpbmVyKSwKLQkJCQludWxsIC8vIFRPRE8gSUpwYUhlbHBDb250ZXh0SWRzLgotCQkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2xvZ2dpbmcvUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9sb2dnaW5nL1BlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhM2VkMjNlLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2xvZ2dpbmcvUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw4MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UubG9nZ2luZzsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UubG9nZ2luZy5Mb2dnaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhUGFnZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LlNXVDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuZ3JhcGhpY3MuSW1hZ2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkRGF0YTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWRMYXlvdXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYgotICovCi1wdWJsaWMgY2xhc3MgUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiCi0JZXh0ZW5kcyBGb3JtUGFuZTxMb2dnaW5nPgotCWltcGxlbWVudHMgSnBhUGFnZUNvbXBvc2l0ZQotewotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQlwdWJsaWMgUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiKAotCQkJCVByb3BlcnR5VmFsdWVNb2RlbDxMb2dnaW5nPiBzdWJqZWN0SG9sZGVyLCAKLQkJCQlDb21wb3NpdGUgcGFyZW50LCAKLQkJCQlXaWRnZXRGYWN0b3J5IHdpZGdldEZhY3RvcnkpIHsKLQkJCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCW5ldyBFY2xpcHNlTGlua0xvZ2dpbmdDb21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIEpwYVBhZ2VDb21wb3NpdGUgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCXB1YmxpYyBTdHJpbmcgZ2V0SGVscElEKCkgewotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQlwdWJsaWMgSW1hZ2UgZ2V0UGFnZUltYWdlKCkgewotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGdldFBhZ2VUZXh0KCkgewotCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl90aXRsZTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIExheW91dCAqKioqKioqKioqCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIENvbXBvc2l0ZSBhZGRDb250YWluZXIoQ29tcG9zaXRlIHBhcmVudCkgewotCQlHcmlkTGF5b3V0IGxheW91dCA9IG5ldyBHcmlkTGF5b3V0KDEsIHRydWUpOwotCQlsYXlvdXQubWFyZ2luSGVpZ2h0ID0gMDsKLQkJbGF5b3V0Lm1hcmdpbldpZHRoID0gMDsKLQkJbGF5b3V0Lm1hcmdpblRvcCA9IDA7Ci0JCWxheW91dC5tYXJnaW5MZWZ0ID0gMDsKLQkJbGF5b3V0Lm1hcmdpbkJvdHRvbSA9IDA7Ci0JCWxheW91dC5tYXJnaW5SaWdodCA9IDA7Ci0JCWxheW91dC52ZXJ0aWNhbFNwYWNpbmcgPSAxNTsKLQkJQ29tcG9zaXRlIGNvbnRhaW5lciA9IHRoaXMuYWRkUGFuZShwYXJlbnQsIGxheW91dCk7Ci0JCXRoaXMudXBkYXRlR3JpZERhdGEoY29udGFpbmVyKTsKLQkJcmV0dXJuIGNvbnRhaW5lcjsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdXBkYXRlR3JpZERhdGEoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlHcmlkRGF0YSBncmlkRGF0YSA9IG5ldyBHcmlkRGF0YSgpOwotCQlncmlkRGF0YS5ncmFiRXhjZXNzSG9yaXpvbnRhbFNwYWNlID0gdHJ1ZTsKLQkJZ3JpZERhdGEuZ3JhYkV4Y2Vzc1ZlcnRpY2FsU3BhY2UgPSB0cnVlOwotCQlncmlkRGF0YS5ob3Jpem9udGFsQWxpZ25tZW50ID0gU1dULkZJTEw7Ci0JCWdyaWREYXRhLnZlcnRpY2FsQWxpZ25tZW50ID0gU1dULkZJTEw7Ci0JCWNvbnRhaW5lci5zZXRMYXlvdXREYXRhKGdyaWREYXRhKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9sb2dnaW5nL1Nlc3Npb25Db21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2xvZ2dpbmcvU2Vzc2lvbkNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4N2VlOGIxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2xvZ2dpbmcvU2Vzc2lvbkNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsOTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UubG9nZ2luZzsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UubG9nZ2luZy5Mb2dnaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5vc2dpLnV0aWwuTkxTOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBTZXNzaW9uQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBTZXNzaW9uQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8TG9nZ2luZz4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPlNlc3Npb25Db21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudENvbnRyb2xsZXIKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudAotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgU2Vzc2lvbkNvbXBvc2l0ZSgKLQkJCQkJRm9ybVBhbmU8PyBleHRlbmRzIExvZ2dpbmc+IHBhcmVudENvbXBvc2l0ZSwKLQkJCQkJQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudENvbXBvc2l0ZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkU2Vzc2lvbkhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8TG9nZ2luZywgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBMb2dnaW5nLlNFU1NJT05fUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3QuZ2V0U2Vzc2lvbigpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJc3ViamVjdC5zZXRTZXNzaW9uKHZhbHVlKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzdWJqZWN0Q2hhbmdlZCgpIHsKLQkJCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0JCQkJc3VwZXIuc3ViamVjdENoYW5nZWQoKTsKLQkJCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0KLQkJCQkvLyBNYWtlIHN1cmUgdGhlIGRlZmF1bHQgdmFsdWUgaXMgYXBwZW5kZWQgdG8gdGhlIHRleHQKLQkJCQlpZiAob2xkVmFsdWUgPT0gbmV3VmFsdWUgJiYgbmV3VmFsdWUgPT0gbnVsbCkgewotCQkJCQl0aGlzLmZpcmVBc3BlY3RDaGFuZ2UoQm9vbGVhbi5UUlVFLCBuZXdWYWx1ZSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRTZXNzaW9uU3RyaW5nSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4sIFN0cmluZz4oYnVpbGRTZXNzaW9uSG9sZGVyKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oQm9vbGVhbiB2YWx1ZSkgewotCQkJCWlmICgoZ2V0U3ViamVjdCgpICE9IG51bGwpICYmICh2YWx1ZSA9PSBudWxsKSkgewotCQkJCQlCb29sZWFuIGRlZmF1bHRWYWx1ZSA9IGdldFN1YmplY3QoKS5nZXREZWZhdWx0U2Vzc2lvbigpOwotCQkJCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCQkJCVN0cmluZyBkZWZhdWx0U3RyaW5nVmFsdWUgPSBkZWZhdWx0VmFsdWUgPyBFY2xpcHNlTGlua1VpTWVzc2FnZXMuQm9vbGVhbl9UcnVlIDogRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fRmFsc2U7Ci0JCQkJCQlyZXR1cm4gTkxTLmJpbmQoRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl9zZXNzaW9uTGFiZWxEZWZhdWx0LCBkZWZhdWx0U3RyaW5nVmFsdWUpOwotCQkJCQl9Ci0JCQkJfQotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiX3Nlc3Npb25MYWJlbDsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQl0aGlzLmFkZFRyaVN0YXRlQ2hlY2tCb3hXaXRoRGVmYXVsdCgKLQkJCWNvbnRhaW5lciwKLQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfc2Vzc2lvbkxhYmVsLAotCQkJdGhpcy5idWlsZFNlc3Npb25Ib2xkZXIoKSwKLQkJCXRoaXMuYnVpbGRTZXNzaW9uU3RyaW5nSG9sZGVyKCksCi0JCQludWxsCi0vLwkJCUVjbGlwc2VMaW5rSGVscENvbnRleHRJZHMuTE9HR0lOR18KLQkJKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9sb2dnaW5nL1RocmVhZENvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2UvbG9nZ2luZy9UaHJlYWRDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTZmNjE5NS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9sb2dnaW5nL1RocmVhZENvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsOTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2UubG9nZ2luZzsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UubG9nZ2luZy5Mb2dnaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5vc2dpLnV0aWwuTkxTOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBUaHJlYWRDb21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIFRocmVhZENvbXBvc2l0ZSBleHRlbmRzIEZvcm1QYW5lPExvZ2dpbmc+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5UaHJlYWRDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudENvbnRyb2xsZXIKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudAotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgVGhyZWFkQ29tcG9zaXRlKAotCQkJCQlGb3JtUGFuZTw/IGV4dGVuZHMgTG9nZ2luZz4gcGFyZW50Q29tcG9zaXRlLAotCQkJCQlDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRUaHJlYWRIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPExvZ2dpbmcsIEJvb2xlYW4+KGdldFN1YmplY3RIb2xkZXIoKSwgTG9nZ2luZy5USFJFQURfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3QuZ2V0VGhyZWFkKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlzdWJqZWN0LnNldFRocmVhZCh2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc3ViamVjdENoYW5nZWQoKSB7Ci0JCQkJT2JqZWN0IG9sZFZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCQkJCXN1cGVyLnN1YmplY3RDaGFuZ2VkKCk7Ci0JCQkJT2JqZWN0IG5ld1ZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCi0JCQkJLy8gTWFrZSBzdXJlIHRoZSBkZWZhdWx0IHZhbHVlIGlzIGFwcGVuZGVkIHRvIHRoZSB0ZXh0Ci0JCQkJaWYgKG9sZFZhbHVlID09IG5ld1ZhbHVlICYmIG5ld1ZhbHVlID09IG51bGwpIHsKLQkJCQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKEJvb2xlYW4uVFJVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkVGhyZWFkU3RyaW5nSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4sIFN0cmluZz4oYnVpbGRUaHJlYWRIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShCb29sZWFuIHZhbHVlKSB7Ci0JCQkJaWYgKChnZXRTdWJqZWN0KCkgIT0gbnVsbCkgJiYgKHZhbHVlID09IG51bGwpKSB7Ci0JCQkJCUJvb2xlYW4gZGVmYXVsdFZhbHVlID0gZ2V0U3ViamVjdCgpLmdldERlZmF1bHRUaHJlYWQoKTsKLQkJCQkJaWYgKGRlZmF1bHRWYWx1ZSAhPSBudWxsKSB7Ci0JCQkJCQlTdHJpbmcgZGVmYXVsdFN0cmluZ1ZhbHVlID0gZGVmYXVsdFZhbHVlID8gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fVHJ1ZSA6IEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5Cb29sZWFuX0ZhbHNlOwotCQkJCQkJcmV0dXJuIE5MUy5iaW5kKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfdGhyZWFkTGFiZWxEZWZhdWx0LCBkZWZhdWx0U3RyaW5nVmFsdWUpOwotCQkJCQl9Ci0JCQkJfQotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiX3RocmVhZExhYmVsOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXRoaXMuYWRkVHJpU3RhdGVDaGVja0JveFdpdGhEZWZhdWx0KAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl90aHJlYWRMYWJlbCwKLQkJCXRoaXMuYnVpbGRUaHJlYWRIb2xkZXIoKSwKLQkJCXRoaXMuYnVpbGRUaHJlYWRTdHJpbmdIb2xkZXIoKSwKLQkJCW51bGwKLS8vCQkJRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcy5MT0dHSU5HXwotCQkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2xvZ2dpbmcvVGltZXN0YW1wQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9sb2dnaW5nL1RpbWVzdGFtcENvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0NGEyZDM0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL2xvZ2dpbmcvVGltZXN0YW1wQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw5NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5sb2dnaW5nOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5sb2dnaW5nLkxvZ2dpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIFRpbWVzdGFtcENvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgVGltZXN0YW1wQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8TG9nZ2luZz4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPlRpbWVzdGFtcENvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50Q29udHJvbGxlcgotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50Ci0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBUaW1lc3RhbXBDb21wb3NpdGUoCi0JCQkJCUZvcm1QYW5lPD8gZXh0ZW5kcyBMb2dnaW5nPiBwYXJlbnRDb21wb3NpdGUsCi0JCQkJCUNvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRDb21wb3NpdGUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZFRpbWVzdGFtcEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8TG9nZ2luZywgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBMb2dnaW5nLlRJTUVTVEFNUF9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRUaW1lc3RhbXAoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCXN1YmplY3Quc2V0VGltZXN0YW1wKHZhbHVlKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzdWJqZWN0Q2hhbmdlZCgpIHsKLQkJCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0JCQkJc3VwZXIuc3ViamVjdENoYW5nZWQoKTsKLQkJCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0KLQkJCQkvLyBNYWtlIHN1cmUgdGhlIGRlZmF1bHQgdmFsdWUgaXMgYXBwZW5kZWQgdG8gdGhlIHRleHQKLQkJCQlpZiAob2xkVmFsdWUgPT0gbmV3VmFsdWUgJiYgbmV3VmFsdWUgPT0gbnVsbCkgewotCQkJCQl0aGlzLmZpcmVBc3BlY3RDaGFuZ2UoQm9vbGVhbi5UUlVFLCBuZXdWYWx1ZSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRUaW1lc3RhbXBTdHJpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbiwgU3RyaW5nPihidWlsZFRpbWVzdGFtcEhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlpZiAoKGdldFN1YmplY3QoKSAhPSBudWxsKSAmJiAodmFsdWUgPT0gbnVsbCkpIHsKLQkJCQkJQm9vbGVhbiBkZWZhdWx0VmFsdWUgPSBnZXRTdWJqZWN0KCkuZ2V0RGVmYXVsdFRpbWVzdGFtcCgpOwotCQkJCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCQkJCVN0cmluZyBkZWZhdWx0U3RyaW5nVmFsdWUgPSBkZWZhdWx0VmFsdWUgPyBFY2xpcHNlTGlua1VpTWVzc2FnZXMuQm9vbGVhbl9UcnVlIDogRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fRmFsc2U7Ci0JCQkJCQlyZXR1cm4gTkxTLmJpbmQoRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sTG9nZ2luZ1RhYl90aW1lc3RhbXBMYWJlbERlZmF1bHQsIGRlZmF1bHRTdHJpbmdWYWx1ZSk7Ci0JCQkJCX0KLQkJCQl9Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbExvZ2dpbmdUYWJfdGltZXN0YW1wTGFiZWw7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJdGhpcy5hZGRUcmlTdGF0ZUNoZWNrQm94V2l0aERlZmF1bHQoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxMb2dnaW5nVGFiX3RpbWVzdGFtcExhYmVsLAotCQkJdGhpcy5idWlsZFRpbWVzdGFtcEhvbGRlcigpLAotCQkJdGhpcy5idWlsZFRpbWVzdGFtcFN0cmluZ0hvbGRlcigpLAotCQkJbnVsbAotLy8JCQlFY2xpcHNlTGlua0hlbHBDb250ZXh0SWRzLkxPR0dJTkdfCi0JCSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvb3B0aW9ucy9FY2xpcHNlTGlua09wdGlvbnNDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL29wdGlvbnMvRWNsaXBzZUxpbmtPcHRpb25zQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZlZDAyZDguLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvb3B0aW9ucy9FY2xpcHNlTGlua09wdGlvbnNDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDgzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5vcHRpb25zOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5vcHRpb25zLk9wdGlvbnM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuU1dUOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuR3JpZERhdGE7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIEVjbGlwc2VMaW5rT3B0aW9uc0NvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtPcHRpb25zQ29tcG9zaXRlCi0JZXh0ZW5kcyBGb3JtUGFuZTxPcHRpb25zPgotewotCXB1YmxpYyBFY2xpcHNlTGlua09wdGlvbnNDb21wb3NpdGUoCi0JCQkJCUZvcm1QYW5lPE9wdGlvbnM+IHN1YmplY3RIb2xkZXIsIAotCQkJCQlDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIGNvbnRhaW5lciwgZmFsc2UpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIHBhcmVudCkgewotCQl0aGlzLmluaXRpYWxpemVTZXNzaW9uT3B0aW9uc1BhbmUocGFyZW50KTsKLQkJdGhpcy5pbml0aWFsaXplTWlzY2VsbGFuZW91c1BhbmUocGFyZW50KTsKLQl9Ci0JCi0JcHJpdmF0ZSB2b2lkIGluaXRpYWxpemVTZXNzaW9uT3B0aW9uc1BhbmUoQ29tcG9zaXRlIHBhcmVudCkgewotCQlDb21wb3NpdGUgY29tcG9zaXRlID0gdGhpcy5hZGRTZWN0aW9uKHBhcmVudCwgCi0JCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl9zZXNzaW9uU2VjdGlvblRpdGxlLAotCQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfc2Vzc2lvblNlY3Rpb25EZXNjcmlwdGlvbik7Ci0JCQotCQl0aGlzLnVwZGF0ZUdyaWREYXRhKGNvbXBvc2l0ZSk7Ci0JCXRoaXMudXBkYXRlR3JpZERhdGEoY29tcG9zaXRlLmdldFBhcmVudCgpKTsKLQotCQluZXcgU2Vzc2lvbk5hbWVDb21wb3NpdGUodGhpcywgY29tcG9zaXRlKTsKLQotCQluZXcgU2Vzc2lvbnNYbWxDb21wb3NpdGUodGhpcywgY29tcG9zaXRlKTsKLQkJCi0JCW5ldyBUYXJnZXREYXRhYmFzZUNvbXBvc2l0ZSh0aGlzLCBjb21wb3NpdGUpOwotCQkKLQkJbmV3IFRhcmdldFNlcnZlckNvbXBvc2l0ZSh0aGlzLCBjb21wb3NpdGUpOwotCQkKLQkJbmV3IEV2ZW50TGlzdGVuZXJDb21wb3NpdGUodGhpcywgY29tcG9zaXRlKTsKLQkJCi0JCW5ldyBJbmNsdWRlRGVzY3JpcHRvclF1ZXJpZXNDb21wb3NpdGUodGhpcywgY29tcG9zaXRlKTsKLQkJCi0JCXJldHVybjsKLQl9Ci0JCi0JcHJpdmF0ZSB2b2lkIGluaXRpYWxpemVNaXNjZWxsYW5lb3VzUGFuZShDb21wb3NpdGUgY29udGFpbmVyKSB7CQotCQkKLQkJdGhpcy51cGRhdGVHcmlkRGF0YShjb250YWluZXIpOwotCQl0aGlzLnVwZGF0ZUdyaWREYXRhKGNvbnRhaW5lci5nZXRQYXJlbnQoKSk7Ci0JCQotCQlDb21wb3NpdGUgY29tcG9zaXRlID0gdGhpcy5hZGRTZWN0aW9uKGNvbnRhaW5lciwgCi0JCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl9taXNjZWxsYW5lb3VzU2VjdGlvblRpdGxlLAotCQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfbWlzY2VsbGFuZW91c1NlY3Rpb25EZXNjcmlwdGlvbik7Ci0JCQotCQl0aGlzLnVwZGF0ZUdyaWREYXRhKGNvbXBvc2l0ZSk7Ci0JCXRoaXMudXBkYXRlR3JpZERhdGEoY29tcG9zaXRlLmdldFBhcmVudCgpKTsKLQotCQluZXcgVGVtcG9yYWxNdXRhYmxlQ29tcG9zaXRlKHRoaXMsIGNvbXBvc2l0ZSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHVwZGF0ZUdyaWREYXRhKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJR3JpZERhdGEgZ3JpZERhdGEgPSBuZXcgR3JpZERhdGEoKTsKLQkJZ3JpZERhdGEuZ3JhYkV4Y2Vzc0hvcml6b250YWxTcGFjZSA9IHRydWU7Ci0JCWdyaWREYXRhLmdyYWJFeGNlc3NWZXJ0aWNhbFNwYWNlID0gdHJ1ZTsKLQkJZ3JpZERhdGEuaG9yaXpvbnRhbEFsaWdubWVudCA9IFNXVC5GSUxMOwotCQlncmlkRGF0YS52ZXJ0aWNhbEFsaWdubWVudCA9IFNXVC5GSUxMOwotCQljb250YWluZXIuc2V0TGF5b3V0RGF0YShncmlkRGF0YSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvb3B0aW9ucy9FdmVudExpc3RlbmVyQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9vcHRpb25zL0V2ZW50TGlzdGVuZXJDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzQ4ZGNlNy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9vcHRpb25zL0V2ZW50TGlzdGVuZXJDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDkzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0qIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0qIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotKiAKLSogQ29udHJpYnV0b3JzOgotKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2Uub3B0aW9uczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLkpwYVByb2plY3Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5vcHRpb25zLk9wdGlvbnM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5DbGFzc0Nob29zZXJQYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLlBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiAgRXZlbnRMaXN0ZW5lckNvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgRXZlbnRMaXN0ZW5lckNvbXBvc2l0ZSBleHRlbmRzIFBhbmU8T3B0aW9ucz4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkV2ZW50TGlzdGVuZXJDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudFBhbmUgVGhlIHBhcmVudCBwYW5lIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBFdmVudExpc3RlbmVyQ29tcG9zaXRlKFBhbmU8PyBleHRlbmRzIE9wdGlvbnM+IHBhcmVudFBhbmUsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50UGFuZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIENsYXNzQ2hvb3NlclBhbmU8T3B0aW9ucz4gaW5pdGlhbGl6ZUNsYXNzQ2hvb3NlcihDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJcmV0dXJuIG5ldyBDbGFzc0Nob29zZXJQYW5lPE9wdGlvbnM+KHRoaXMsIGNvbnRhaW5lcikgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkVGV4dEhvbGRlcigpIHsKLQkJCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxPcHRpb25zLCBTdHJpbmc+KAotCQkJCQkJCXRoaXMuZ2V0U3ViamVjdEhvbGRlcigpLCBPcHRpb25zLlNFU1NJT05fRVZFTlRfTElTVEVORVJfUFJPUEVSVFkpIHsKLQkJCQkJQE92ZXJyaWRlCi0JCQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldEV2ZW50TGlzdGVuZXIoKTsKLQkJCQkJfQotCi0JCQkJCUBPdmVycmlkZQotCQkJCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0KLQkJCQkJCWlmICh2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQkJCQkJdmFsdWUgPSBudWxsOwotCQkJCQkJfQotCQkJCQkJdGhpcy5zdWJqZWN0LnNldEV2ZW50TGlzdGVuZXIodmFsdWUpOwotCQkJCQl9Ci0JCQkJfTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGdldENsYXNzTmFtZSgpIHsKLQkJCQlyZXR1cm4gdGhpcy5nZXRTdWJqZWN0KCkuZ2V0RXZlbnRMaXN0ZW5lcigpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZ2V0TGFiZWxUZXh0KCkgewotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX2V2ZW50TGlzdGVuZXJMYWJlbDsKLQkJCX0KLQkJCQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSnBhUHJvamVjdCBnZXRKcGFQcm9qZWN0KCkgewotCQkJCXJldHVybiBnZXRTdWJqZWN0KCkuZ2V0SnBhUHJvamVjdCgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldENsYXNzTmFtZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCQkJdGhpcy5nZXRTdWJqZWN0KCkuc2V0RXZlbnRMaXN0ZW5lcihjbGFzc05hbWUpOwotCQkJfQotCQkJCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZ2V0U3VwZXJJbnRlcmZhY2VOYW1lKCkgewotCQkJCXJldHVybiBPcHRpb25zLkVDTElQU0VMSU5LX0VWRU5UX0xJU1RFTkVSX0NMQVNTX05BTUU7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCXRoaXMuaW5pdGlhbGl6ZUNsYXNzQ2hvb3Nlcihjb250YWluZXIpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL29wdGlvbnMvSW5jbHVkZURlc2NyaXB0b3JRdWVyaWVzQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9vcHRpb25zL0luY2x1ZGVEZXNjcmlwdG9yUXVlcmllc0NvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxZDQ5YmU1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL29wdGlvbnMvSW5jbHVkZURlc2NyaXB0b3JRdWVyaWVzQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw5NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5vcHRpb25zOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5vcHRpb25zLk9wdGlvbnM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIEluY2x1ZGVEZXNjcmlwdG9yUXVlcmllc0NvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgSW5jbHVkZURlc2NyaXB0b3JRdWVyaWVzQ29tcG9zaXRlIGV4dGVuZHMgRm9ybVBhbmU8T3B0aW9ucz4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkluY2x1ZGVEZXNjcmlwdG9yUXVlcmllc0NvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50Q29udHJvbGxlcgotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50Ci0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBJbmNsdWRlRGVzY3JpcHRvclF1ZXJpZXNDb21wb3NpdGUoCi0JCQkJCUZvcm1QYW5lPD8gZXh0ZW5kcyBPcHRpb25zPiBwYXJlbnRDb21wb3NpdGUsCi0JCQkJCUNvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRDb21wb3NpdGUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZEluY2x1ZGVEZXNjcmlwdG9yUXVlcmllc0hvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8T3B0aW9ucywgQm9vbGVhbj4oZ2V0U3ViamVjdEhvbGRlcigpLCBPcHRpb25zLlNFU1NJT05fSU5DTFVERV9ERVNDUklQVE9SX1FVRVJJRVNfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3QuZ2V0SW5jbHVkZURlc2NyaXB0b3JRdWVyaWVzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlzdWJqZWN0LnNldEluY2x1ZGVEZXNjcmlwdG9yUXVlcmllcyh2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc3ViamVjdENoYW5nZWQoKSB7Ci0JCQkJT2JqZWN0IG9sZFZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCQkJCXN1cGVyLnN1YmplY3RDaGFuZ2VkKCk7Ci0JCQkJT2JqZWN0IG5ld1ZhbHVlID0gdGhpcy5nZXRWYWx1ZSgpOwotCi0JCQkJLy8gTWFrZSBzdXJlIHRoZSBkZWZhdWx0IHZhbHVlIGlzIGFwcGVuZGVkIHRvIHRoZSB0ZXh0Ci0JCQkJaWYgKG9sZFZhbHVlID09IG5ld1ZhbHVlICYmIG5ld1ZhbHVlID09IG51bGwpIHsKLQkJCQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKEJvb2xlYW4uVFJVRSwgbmV3VmFsdWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkSW5jbHVkZURlc2NyaXB0b3JRdWVyaWVzU3RyaW5nSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4sIFN0cmluZz4oYnVpbGRJbmNsdWRlRGVzY3JpcHRvclF1ZXJpZXNIb2xkZXIoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShCb29sZWFuIHZhbHVlKSB7Ci0JCQkJaWYgKChnZXRTdWJqZWN0KCkgIT0gbnVsbCkgJiYgKHZhbHVlID09IG51bGwpKSB7Ci0JCQkJCUJvb2xlYW4gZGVmYXVsdFZhbHVlID0gZ2V0U3ViamVjdCgpLmdldERlZmF1bHRJbmNsdWRlRGVzY3JpcHRvclF1ZXJpZXMoKTsKLQkJCQkJaWYgKGRlZmF1bHRWYWx1ZSAhPSBudWxsKSB7Ci0JCQkJCQlTdHJpbmcgZGVmYXVsdFN0cmluZ1ZhbHVlID0gZGVmYXVsdFZhbHVlID8gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fVHJ1ZSA6IEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5Cb29sZWFuX0ZhbHNlOwotCQkJCQkJcmV0dXJuIE5MUy5iaW5kKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfaW5jbHVkZURlc2NyaXB0b3JRdWVyaWVzTGFiZWxEZWZhdWx0LCBkZWZhdWx0U3RyaW5nVmFsdWUpOwotCQkJCQl9Ci0JCQkJfQotCQkJCXJldHVybiBFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX2luY2x1ZGVEZXNjcmlwdG9yUXVlcmllc0xhYmVsOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCi0JCXRoaXMuYWRkVHJpU3RhdGVDaGVja0JveFdpdGhEZWZhdWx0KAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl9pbmNsdWRlRGVzY3JpcHRvclF1ZXJpZXNMYWJlbCwKLQkJCXRoaXMuYnVpbGRJbmNsdWRlRGVzY3JpcHRvclF1ZXJpZXNIb2xkZXIoKSwKLQkJCXRoaXMuYnVpbGRJbmNsdWRlRGVzY3JpcHRvclF1ZXJpZXNTdHJpbmdIb2xkZXIoKSwKLQkJCW51bGwKLS8vCQkJRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcy4KLQkJKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9vcHRpb25zL1BlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYi5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvb3B0aW9ucy9QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzQxYzRkMy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9vcHRpb25zL1BlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYi5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLm9wdGlvbnM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLm9wdGlvbnMuT3B0aW9uczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5XaWRnZXRGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5kZXRhaWxzLkpwYVBhZ2VDb21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5TV1Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLkltYWdlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuR3JpZERhdGE7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkTGF5b3V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBQZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWIKLSAqLwotcHVibGljIGNsYXNzIFBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYgotCWV4dGVuZHMgRm9ybVBhbmU8T3B0aW9ucz4KLQlpbXBsZW1lbnRzIEpwYVBhZ2VDb21wb3NpdGUKLXsKLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycy9pbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0JcHVibGljIFBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYigKLQkJCQlQcm9wZXJ0eVZhbHVlTW9kZWw8T3B0aW9ucz4gc3ViamVjdEhvbGRlciwgCi0JCQkJQ29tcG9zaXRlIHBhcmVudCwgCi0JCQkJV2lkZ2V0RmFjdG9yeSB3aWRnZXRGYWN0b3J5KSB7Ci0JCQotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBwYXJlbnQsIHdpZGdldEZhY3RvcnkpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQluZXcgRWNsaXBzZUxpbmtPcHRpb25zQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JfQotCi0JLy8gKioqKioqKioqKiBKcGFQYWdlQ29tcG9zaXRlIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQlwdWJsaWMgU3RyaW5nIGdldEhlbHBJRCgpIHsKLQkJcmV0dXJuIG51bGw7Ci0JfQotCi0JcHVibGljIEltYWdlIGdldFBhZ2VJbWFnZSgpIHsKLQkJcmV0dXJuIG51bGw7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXRQYWdlVGV4dCgpIHsKLQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfdGl0bGU7Ci0JfQotCi0JLy8gKioqKioqKioqKiBMYXlvdXQgKioqKioqKioqKgotCUBPdmVycmlkZQotCXByb3RlY3RlZCBDb21wb3NpdGUgYWRkQ29udGFpbmVyKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJR3JpZExheW91dCBsYXlvdXQgPSBuZXcgR3JpZExheW91dCgxLCB0cnVlKTsKLQkJbGF5b3V0Lm1hcmdpbkhlaWdodCA9IDA7Ci0JCWxheW91dC5tYXJnaW5XaWR0aCA9IDA7Ci0JCWxheW91dC5tYXJnaW5Ub3AgPSAwOwotCQlsYXlvdXQubWFyZ2luTGVmdCA9IDA7Ci0JCWxheW91dC5tYXJnaW5Cb3R0b20gPSAwOwotCQlsYXlvdXQubWFyZ2luUmlnaHQgPSAwOwotCQlsYXlvdXQudmVydGljYWxTcGFjaW5nID0gMTU7Ci0JCUNvbXBvc2l0ZSBjb250YWluZXIgPSB0aGlzLmFkZFBhbmUocGFyZW50LCBsYXlvdXQpOwotCQl0aGlzLnVwZGF0ZUdyaWREYXRhKGNvbnRhaW5lcik7Ci0JCXJldHVybiBjb250YWluZXI7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHVwZGF0ZUdyaWREYXRhKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJR3JpZERhdGEgZ3JpZERhdGEgPSBuZXcgR3JpZERhdGEoKTsKLQkJZ3JpZERhdGEuZ3JhYkV4Y2Vzc0hvcml6b250YWxTcGFjZSA9IHRydWU7Ci0JCWdyaWREYXRhLmdyYWJFeGNlc3NWZXJ0aWNhbFNwYWNlID0gdHJ1ZTsKLQkJZ3JpZERhdGEuaG9yaXpvbnRhbEFsaWdubWVudCA9IFNXVC5GSUxMOwotCQlncmlkRGF0YS52ZXJ0aWNhbEFsaWdubWVudCA9IFNXVC5GSUxMOwotCQljb250YWluZXIuc2V0TGF5b3V0RGF0YShncmlkRGF0YSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvb3B0aW9ucy9TZXNzaW9uTmFtZUNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvb3B0aW9ucy9TZXNzaW9uTmFtZUNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxZWIyM2M1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL29wdGlvbnMvU2Vzc2lvbk5hbWVDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDExMCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSogCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLm9wdGlvbnM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLm9wdGlvbnMuT3B0aW9uczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLlNXVFV0aWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmN1c3RvbS5DQ29tYm87Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqICBTZXNzaW9uTmFtZUNvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgU2Vzc2lvbk5hbWVDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPE9wdGlvbnM+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5TZXNzaW9uTmFtZUNvbXBvc2l0ZTwvY29kZT4uCi0JICoKLQkgKiBAcGFyYW0gcGFyZW50UGFuZSBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgU2Vzc2lvbk5hbWVDb21wb3NpdGUoCi0JCQkJCQkJCVBhbmU8PyBleHRlbmRzIE9wdGlvbnM+IHBhcmVudFBhbmUsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudFBhbmUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZERlZmF1bHRTZXNzaW9uTmFtZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8T3B0aW9ucywgU3RyaW5nPih0aGlzLmdldFN1YmplY3RIb2xkZXIoKSwgT3B0aW9ucy5ERUZBVUxUX1NFU1NJT05fTkFNRSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBTZXNzaW9uTmFtZUNvbXBvc2l0ZS50aGlzLmdldERlZmF1bHRWYWx1ZShzdWJqZWN0KTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGREZWZhdWx0U2Vzc2lvbk5hbWVMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyPFN0cmluZz4oCi0JCQl0aGlzLmJ1aWxkRGVmYXVsdFNlc3Npb25OYW1lSG9sZGVyKCkKLQkJKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRTZXNzaW9uTmFtZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8T3B0aW9ucywgU3RyaW5nPih0aGlzLmdldFN1YmplY3RIb2xkZXIoKSwgT3B0aW9ucy5TRVNTSU9OX05BTUVfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQotCQkJCVN0cmluZyBuYW1lID0gc3ViamVjdC5nZXRTZXNzaW9uTmFtZSgpOwotCQkJCWlmIChuYW1lID09IG51bGwpIHsKLQkJCQkJbmFtZSA9IFNlc3Npb25OYW1lQ29tcG9zaXRlLnRoaXMuZ2V0RGVmYXVsdFZhbHVlKHN1YmplY3QpOwotCQkJCX0KLQkJCQlyZXR1cm4gbmFtZTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0KLQkJCQlpZiAoZ2V0RGVmYXVsdFZhbHVlKHN1YmplY3QpLmVxdWFscyh2YWx1ZSkpIHsKLQkJCQkJdmFsdWUgPSBudWxsOwotCQkJCX0KLQkJCQlzdWJqZWN0LnNldFNlc3Npb25OYW1lKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBnZXREZWZhdWx0VmFsdWUoT3B0aW9ucyBzdWJqZWN0KSB7Ci0JCVN0cmluZyBkZWZhdWx0VmFsdWUgPSBzdWJqZWN0LmdldERlZmF1bHRTZXNzaW9uTmFtZSgpOwotCi0JCWlmIChkZWZhdWx0VmFsdWUgIT0gbnVsbCkgewotCQkJcmV0dXJuIE5MUy5iaW5kKAotCQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfZGVmYXVsdFdpdGhPbmVQYXJhbSwKLQkJCQlkZWZhdWx0VmFsdWUKLQkJCSk7Ci0JCX0KLQkJZWxzZSB7Ci0JCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl9kZWZhdWx0RW1wdHk7Ci0JCX0KLQl9Ci0KLQkvKgotCSAqIChub24tSmF2YWRvYykKLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQlDQ29tYm8gY29tYm8gPSBhZGRMYWJlbGVkRWRpdGFibGVDQ29tYm8oCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX3Nlc3Npb25OYW1lLAotCQkJdGhpcy5idWlsZERlZmF1bHRTZXNzaW9uTmFtZUxpc3RIb2xkZXIoKSwKLQkJCXRoaXMuYnVpbGRTZXNzaW9uTmFtZUhvbGRlcigpLAotCQkJbnVsbAkJLy8gRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcy4KLQkJKTsKLQkJU1dUVXRpbC5hdHRhY2hEZWZhdWx0VmFsdWVIYW5kbGVyKGNvbWJvKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9vcHRpb25zL1Nlc3Npb25zWG1sQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9vcHRpb25zL1Nlc3Npb25zWG1sQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJlODI2YzcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvb3B0aW9ucy9TZXNzaW9uc1htbENvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTEwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0qIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0qIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotKiAKLSogQ29udHJpYnV0b3JzOgotKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2Uub3B0aW9uczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2Uub3B0aW9ucy5PcHRpb25zOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuU1dUVXRpbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuY3VzdG9tLkNDb21ibzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogIFNlc3Npb25zWG1sQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBTZXNzaW9uc1htbENvbXBvc2l0ZSBleHRlbmRzIFBhbmU8T3B0aW9ucz4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPlNlc3Npb25zWG1sQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRQYW5lIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBTZXNzaW9uc1htbENvbXBvc2l0ZSgKLQkJCQkJCQkJUGFuZTw/IGV4dGVuZHMgT3B0aW9ucz4gcGFyZW50UGFuZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50UGFuZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdFNlc3Npb25zWG1sRmlsZU5hbWVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPE9wdGlvbnMsIFN0cmluZz4odGhpcy5nZXRTdWJqZWN0SG9sZGVyKCksIE9wdGlvbnMuREVGQVVMVF9TRVNTSU9OU19YTUwpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gU2Vzc2lvbnNYbWxDb21wb3NpdGUudGhpcy5nZXREZWZhdWx0VmFsdWUoc3ViamVjdCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdFNlc3Npb25zWG1sRmlsZU5hbWVMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyPFN0cmluZz4oCi0JCQl0aGlzLmJ1aWxkRGVmYXVsdFNlc3Npb25zWG1sRmlsZU5hbWVIb2xkZXIoKQotCQkpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFNlc3Npb25zWG1sRmlsZU5hbWVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPE9wdGlvbnMsIFN0cmluZz4odGhpcy5nZXRTdWJqZWN0SG9sZGVyKCksIE9wdGlvbnMuU0VTU0lPTlNfWE1MX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0KLQkJCQlTdHJpbmcgbmFtZSA9IHN1YmplY3QuZ2V0U2Vzc2lvbnNYbWwoKTsKLQkJCQlpZiAobmFtZSA9PSBudWxsKSB7Ci0JCQkJCW5hbWUgPSBTZXNzaW9uc1htbENvbXBvc2l0ZS50aGlzLmdldERlZmF1bHRWYWx1ZShzdWJqZWN0KTsKLQkJCQl9Ci0JCQkJcmV0dXJuIG5hbWU7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCi0JCQkJaWYgKGdldERlZmF1bHRWYWx1ZShzdWJqZWN0KS5lcXVhbHModmFsdWUpKSB7Ci0JCQkJCXZhbHVlID0gbnVsbDsKLQkJCQl9Ci0JCQkJc3ViamVjdC5zZXRTZXNzaW9uc1htbCh2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmcgZ2V0RGVmYXVsdFZhbHVlKE9wdGlvbnMgc3ViamVjdCkgewotCQlTdHJpbmcgZGVmYXVsdFZhbHVlID0gc3ViamVjdC5nZXREZWZhdWx0U2Vzc2lvbnNYbWwoKTsKLQotCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCXJldHVybiBOTFMuYmluZCgKLQkJCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX2RlZmF1bHRXaXRoT25lUGFyYW0sCi0JCQkJZGVmYXVsdFZhbHVlCi0JCQkpOwotCQl9Ci0JCWVsc2UgewotCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfZGVmYXVsdEVtcHR5OwotCQl9Ci0JfQotCi0JLyoKLQkgKiAobm9uLUphdmFkb2MpCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJQ0NvbWJvIGNvbWJvID0gYWRkTGFiZWxlZEVkaXRhYmxlQ0NvbWJvKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl9zZXNzaW9uc1htbCwKLQkJCXRoaXMuYnVpbGREZWZhdWx0U2Vzc2lvbnNYbWxGaWxlTmFtZUxpc3RIb2xkZXIoKSwKLQkJCXRoaXMuYnVpbGRTZXNzaW9uc1htbEZpbGVOYW1lSG9sZGVyKCksCi0JCQludWxsCQkvLyBFY2xpcHNlTGlua0hlbHBDb250ZXh0SWRzLgotCQkpOwotCQlTV1RVdGlsLmF0dGFjaERlZmF1bHRWYWx1ZUhhbmRsZXIoY29tYm8pOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL29wdGlvbnMvVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL29wdGlvbnMvVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODYzZjM0MS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9vcHRpb25zL1RhcmdldERhdGFiYXNlQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxODYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLm9wdGlvbnM7Ci0KLWltcG9ydCBqYXZhLnRleHQuQ29sbGF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29tcGFyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5vcHRpb25zLk9wdGlvbnM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5vcHRpb25zLlRhcmdldERhdGFiYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuU1dUVXRpbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlRyYW5zZm9ybWF0aW9uSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuQ29tcG9zaXRlTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuY3VzdG9tLkNDb21ibzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIFRhcmdldERhdGFiYXNlQ29tcG9zaXRlIGV4dGVuZHMgUGFuZTxPcHRpb25zPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+VGFyZ2V0RGF0YWJhc2VDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudFBhbmUgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIFRhcmdldERhdGFiYXNlQ29tcG9zaXRlKAotCQkJCQkJCQlQYW5lPD8gZXh0ZW5kcyBPcHRpb25zPiBwYXJlbnRQYW5lLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRQYW5lLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGREZWZhdWx0VGFyZ2V0RGF0YWJhc2VIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPE9wdGlvbnMsIFN0cmluZz4odGhpcy5nZXRTdWJqZWN0SG9sZGVyKCksIE9wdGlvbnMuREVGQVVMVF9UQVJHRVRfREFUQUJBU0UpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gVGFyZ2V0RGF0YWJhc2VDb21wb3NpdGUudGhpcy5nZXREZWZhdWx0VmFsdWUoc3ViamVjdCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdFRhcmdldERhdGFiYXNlTGlzdEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxTdHJpbmc+KAotCQkJdGhpcy5idWlsZERlZmF1bHRUYXJnZXREYXRhYmFzZUhvbGRlcigpCi0JCSk7Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmcgYnVpbGREaXNwbGF5U3RyaW5nKFN0cmluZyB0YXJnZXREYXRhYmFzZU5hbWUpIHsKLQkJCi0JCXJldHVybiBTV1RVdGlsLmJ1aWxkRGlzcGxheVN0cmluZygKLQkJCUVjbGlwc2VMaW5rVWlNZXNzYWdlcy5jbGFzcywgCi0JCQl0aGlzLmdldENsYXNzKCksIAotCQkJVGFyZ2V0RGF0YWJhc2UudmFsdWVPZih0YXJnZXREYXRhYmFzZU5hbWUpKTsKLQl9Ci0KLQlwcml2YXRlIENvbXBhcmF0b3I8U3RyaW5nPiBidWlsZFRhcmdldERhdGFiYXNlQ29tcGFyYXRvcigpIHsKLQkJcmV0dXJuIG5ldyBDb21wYXJhdG9yPFN0cmluZz4oKSB7Ci0JCQlwdWJsaWMgaW50IGNvbXBhcmUoU3RyaW5nIHRhcmdldERhdGFiYXNlMSwgU3RyaW5nIHRhcmdldERhdGFiYXNlMikgewotCQkJCXRhcmdldERhdGFiYXNlMSA9IGJ1aWxkRGlzcGxheVN0cmluZyh0YXJnZXREYXRhYmFzZTEpOwotCQkJCXRhcmdldERhdGFiYXNlMiA9IGJ1aWxkRGlzcGxheVN0cmluZyh0YXJnZXREYXRhYmFzZTIpOwotCQkJCXJldHVybiBDb2xsYXRvci5nZXRJbnN0YW5jZSgpLmNvbXBhcmUodGFyZ2V0RGF0YWJhc2UxLCB0YXJnZXREYXRhYmFzZTIpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgU3RyaW5nQ29udmVydGVyPFN0cmluZz4gYnVpbGRUYXJnZXREYXRhYmFzZUNvbnZlcnRlcigpIHsKLQkJcmV0dXJuIG5ldyBTdHJpbmdDb252ZXJ0ZXI8U3RyaW5nPigpIHsKLQkJCXB1YmxpYyBTdHJpbmcgY29udmVydFRvU3RyaW5nKFN0cmluZyB2YWx1ZSkgewotCQkJCXRyeSB7Ci0JCQkJCVRhcmdldERhdGFiYXNlLnZhbHVlT2YodmFsdWUpOwotCQkJCQl2YWx1ZSA9IGJ1aWxkRGlzcGxheVN0cmluZyh2YWx1ZSk7Ci0JCQkJfQotCQkJCWNhdGNoIChFeGNlcHRpb24gZSkgewotCQkJCQkvLyBJZ25vcmUgc2luY2UgdGhlIHZhbHVlIGlzIG5vdCBhIFRhcmdldERhdGFiYXNlCi0JCQkJfQotCQkJCXJldHVybiB2YWx1ZTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRUYXJnZXREYXRhYmFzZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8T3B0aW9ucywgU3RyaW5nPih0aGlzLmdldFN1YmplY3RIb2xkZXIoKSwgT3B0aW9ucy5UQVJHRVRfREFUQUJBU0VfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQotCQkJCVN0cmluZyBuYW1lID0gc3ViamVjdC5nZXRUYXJnZXREYXRhYmFzZSgpOwotCQkJCWlmIChuYW1lID09IG51bGwpIHsKLQkJCQkJbmFtZSA9IFRhcmdldERhdGFiYXNlQ29tcG9zaXRlLnRoaXMuZ2V0RGVmYXVsdFZhbHVlKHN1YmplY3QpOwotCQkJCX0KLQkJCQlyZXR1cm4gbmFtZTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0KLQkJCQlpZiAoZ2V0RGVmYXVsdFZhbHVlKHN1YmplY3QpLmVxdWFscyh2YWx1ZSkpIHsKLQkJCQkJdmFsdWUgPSBudWxsOwotCQkJCX0KLQkJCQlzdWJqZWN0LnNldFRhcmdldERhdGFiYXNlKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRUYXJnZXREYXRhYmFzZUxpc3RIb2xkZXIoKSB7Ci0JCUFycmF5TGlzdDxMaXN0VmFsdWVNb2RlbDxTdHJpbmc+PiBob2xkZXJzID0gbmV3IEFycmF5TGlzdDxMaXN0VmFsdWVNb2RlbDxTdHJpbmc+PigyKTsKLQkJaG9sZGVycy5hZGQoYnVpbGREZWZhdWx0VGFyZ2V0RGF0YWJhc2VMaXN0SG9sZGVyKCkpOwotCQlob2xkZXJzLmFkZChidWlsZFRhcmdldERhdGFiYXNlc0xpc3RIb2xkZXIoKSk7Ci0JCXJldHVybiBuZXcgQ29tcG9zaXRlTGlzdFZhbHVlTW9kZWw8TGlzdFZhbHVlTW9kZWw8U3RyaW5nPiwgU3RyaW5nPihob2xkZXJzKTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRUYXJnZXREYXRhYmFzZXMoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25JdGVyYXRvcjxUYXJnZXREYXRhYmFzZSwgU3RyaW5nPihDb2xsZWN0aW9uVG9vbHMuaXRlcmF0b3IoVGFyZ2V0RGF0YWJhc2UudmFsdWVzKCkpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKFRhcmdldERhdGFiYXNlIG5leHQpIHsKLQkJCQlyZXR1cm4gbmV4dC5uYW1lKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkVGFyZ2V0RGF0YWJhc2VzQ29sbGVjdGlvbkhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+KAotCQkJQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24oYnVpbGRUYXJnZXREYXRhYmFzZXMoKSkKLQkJKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRUYXJnZXREYXRhYmFzZXNMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxTdHJpbmc+KAotCQkJYnVpbGRUYXJnZXREYXRhYmFzZXNDb2xsZWN0aW9uSG9sZGVyKCksCi0JCQlidWlsZFRhcmdldERhdGFiYXNlQ29tcGFyYXRvcigpCi0JCSk7Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmcgZ2V0RGVmYXVsdFZhbHVlKE9wdGlvbnMgc3ViamVjdCkgewotCQlTdHJpbmcgZGVmYXVsdFZhbHVlID0gc3ViamVjdC5nZXREZWZhdWx0VGFyZ2V0RGF0YWJhc2UoKTsKLQotCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCXJldHVybiBOTFMuYmluZCgKLQkJCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX2RlZmF1bHRXaXRoT25lUGFyYW0sCi0JCQkJZGVmYXVsdFZhbHVlCi0JCQkpOwotCQl9Ci0JCWVsc2UgewotCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfZGVmYXVsdEVtcHR5OwotCQl9Ci0JfQotCi0JLyoKLQkgKiAobm9uLUphdmFkb2MpCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJQ0NvbWJvIGNvbWJvID0gYWRkTGFiZWxlZEVkaXRhYmxlQ0NvbWJvKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl90YXJnZXREYXRhYmFzZUxhYmVsLAotCQkJdGhpcy5idWlsZFRhcmdldERhdGFiYXNlTGlzdEhvbGRlcigpLAotCQkJdGhpcy5idWlsZFRhcmdldERhdGFiYXNlSG9sZGVyKCksCi0JCQl0aGlzLmJ1aWxkVGFyZ2V0RGF0YWJhc2VDb252ZXJ0ZXIoKSwKLQkJCW51bGwJCS8vIEVjbGlwc2VMaW5rSGVscENvbnRleHRJZHMuVEFSR0VUX0RBVEFCQVNFX05BTUUKLQkJKTsKLQotCQlTV1RVdGlsLmF0dGFjaERlZmF1bHRWYWx1ZUhhbmRsZXIoY29tYm8pOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL29wdGlvbnMvVGFyZ2V0U2VydmVyQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9vcHRpb25zL1RhcmdldFNlcnZlckNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmM2VhOWVkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL29wdGlvbnMvVGFyZ2V0U2VydmVyQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxODYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0qIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0qIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0qIAotKiBDb250cmlidXRvcnM6Ci0qICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5vcHRpb25zOwotCi1pbXBvcnQgamF2YS50ZXh0LkNvbGxhdG9yOwotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbXBhcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2Uub3B0aW9ucy5PcHRpb25zOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2Uub3B0aW9ucy5UYXJnZXRTZXJ2ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwudXRpbC5TV1RVdGlsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLlBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ0NvbnZlcnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuVHJhbnNmb3JtYXRpb25JdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Db21wb3NpdGVMaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5vc2dpLnV0aWwuTkxTOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5jdXN0b20uQ0NvbWJvOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiAgVGFyZ2V0U2VydmVyQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBUYXJnZXRTZXJ2ZXJDb21wb3NpdGUgZXh0ZW5kcyBQYW5lPE9wdGlvbnM+Ci17Ci0JLyoqCi0JICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5UYXJnZXRTZXJ2ZXJDb21wb3NpdGU8L2NvZGU+LgotCSAqCi0JICogQHBhcmFtIHBhcmVudFBhbmUgVGhlIHBhcmVudCBjb250YWluZXIgb2YgdGhpcyBvbmUKLQkgKiBAcGFyYW0gcGFyZW50IFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIFRhcmdldFNlcnZlckNvbXBvc2l0ZSgKLQkJCQkJCQkJUGFuZTw/IGV4dGVuZHMgT3B0aW9ucz4gcGFyZW50UGFuZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50UGFuZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdFRhcmdldFNlcnZlckhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8T3B0aW9ucywgU3RyaW5nPih0aGlzLmdldFN1YmplY3RIb2xkZXIoKSwgT3B0aW9ucy5ERUZBVUxUX1RBUkdFVF9TRVJWRVIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gVGFyZ2V0U2VydmVyQ29tcG9zaXRlLnRoaXMuZ2V0RGVmYXVsdFZhbHVlKHN1YmplY3QpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZERlZmF1bHRUYXJnZXRTZXJ2ZXJMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyPFN0cmluZz4oCi0JCQl0aGlzLmJ1aWxkRGVmYXVsdFRhcmdldFNlcnZlckhvbGRlcigpCi0JCSk7Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmcgYnVpbGREaXNwbGF5U3RyaW5nKFN0cmluZyB0YXJnZXRTZXJ2ZXJOYW1lKSB7Ci0JCQotCQlyZXR1cm4gU1dUVXRpbC5idWlsZERpc3BsYXlTdHJpbmcoCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuY2xhc3MsIAotCQkJdGhpcy5nZXRDbGFzcygpLCAKLQkJCVRhcmdldFNlcnZlci52YWx1ZU9mKHRhcmdldFNlcnZlck5hbWUpKTsKLQl9Ci0KLQlwcml2YXRlIENvbXBhcmF0b3I8U3RyaW5nPiBidWlsZFRhcmdldFNlcnZlckNvbXBhcmF0b3IoKSB7Ci0JCXJldHVybiBuZXcgQ29tcGFyYXRvcjxTdHJpbmc+KCkgewotCQkJcHVibGljIGludCBjb21wYXJlKFN0cmluZyB0YXJnZXRTZXJ2ZXIxLCBTdHJpbmcgdGFyZ2V0U2VydmVyMikgewotCQkJCXRhcmdldFNlcnZlcjEgPSBidWlsZERpc3BsYXlTdHJpbmcodGFyZ2V0U2VydmVyMSk7Ci0JCQkJdGFyZ2V0U2VydmVyMiA9IGJ1aWxkRGlzcGxheVN0cmluZyh0YXJnZXRTZXJ2ZXIyKTsKLQkJCQlyZXR1cm4gQ29sbGF0b3IuZ2V0SW5zdGFuY2UoKS5jb21wYXJlKHRhcmdldFNlcnZlcjEsIHRhcmdldFNlcnZlcjIpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgU3RyaW5nQ29udmVydGVyPFN0cmluZz4gYnVpbGRUYXJnZXRTZXJ2ZXJDb252ZXJ0ZXIoKSB7Ci0JCXJldHVybiBuZXcgU3RyaW5nQ29udmVydGVyPFN0cmluZz4oKSB7Ci0JCQlwdWJsaWMgU3RyaW5nIGNvbnZlcnRUb1N0cmluZyhTdHJpbmcgdmFsdWUpIHsKLQkJCQl0cnkgewotCQkJCQlUYXJnZXRTZXJ2ZXIudmFsdWVPZih2YWx1ZSk7Ci0JCQkJCXZhbHVlID0gYnVpbGREaXNwbGF5U3RyaW5nKHZhbHVlKTsKLQkJCQl9Ci0JCQkJY2F0Y2ggKEV4Y2VwdGlvbiBlKSB7Ci0JCQkJCS8vIElnbm9yZSBzaW5jZSB0aGUgdmFsdWUgaXMgbm90IGEgVGFyZ2V0U2VydmVyCi0JCQkJfQotCQkJCXJldHVybiB2YWx1ZTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRUYXJnZXRTZXJ2ZXJIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPE9wdGlvbnMsIFN0cmluZz4odGhpcy5nZXRTdWJqZWN0SG9sZGVyKCksIE9wdGlvbnMuVEFSR0VUX1NFUlZFUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCi0JCQkJU3RyaW5nIG5hbWUgPSBzdWJqZWN0LmdldFRhcmdldFNlcnZlcigpOwotCQkJCWlmIChuYW1lID09IG51bGwpIHsKLQkJCQkJbmFtZSA9IFRhcmdldFNlcnZlckNvbXBvc2l0ZS50aGlzLmdldERlZmF1bHRWYWx1ZShzdWJqZWN0KTsKLQkJCQl9Ci0JCQkJcmV0dXJuIG5hbWU7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCi0JCQkJaWYgKGdldERlZmF1bHRWYWx1ZShzdWJqZWN0KS5lcXVhbHModmFsdWUpKSB7Ci0JCQkJCXZhbHVlID0gbnVsbDsKLQkJCQl9Ci0JCQkJc3ViamVjdC5zZXRUYXJnZXRTZXJ2ZXIodmFsdWUpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFRhcmdldFNlcnZlckxpc3RIb2xkZXIoKSB7Ci0JCUFycmF5TGlzdDxMaXN0VmFsdWVNb2RlbDxTdHJpbmc+PiBob2xkZXJzID0gbmV3IEFycmF5TGlzdDxMaXN0VmFsdWVNb2RlbDxTdHJpbmc+PigyKTsKLQkJaG9sZGVycy5hZGQoYnVpbGREZWZhdWx0VGFyZ2V0U2VydmVyTGlzdEhvbGRlcigpKTsKLQkJaG9sZGVycy5hZGQoYnVpbGRUYXJnZXRTZXJ2ZXJzTGlzdEhvbGRlcigpKTsKLQkJcmV0dXJuIG5ldyBDb21wb3NpdGVMaXN0VmFsdWVNb2RlbDxMaXN0VmFsdWVNb2RlbDxTdHJpbmc+LCBTdHJpbmc+KGhvbGRlcnMpOwotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8U3RyaW5nPiBidWlsZFRhcmdldFNlcnZlcnMoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25JdGVyYXRvcjxUYXJnZXRTZXJ2ZXIsIFN0cmluZz4oQ29sbGVjdGlvblRvb2xzLml0ZXJhdG9yKFRhcmdldFNlcnZlci52YWx1ZXMoKSkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oVGFyZ2V0U2VydmVyIG5leHQpIHsKLQkJCQlyZXR1cm4gbmV4dC5uYW1lKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkVGFyZ2V0U2VydmVyc0NvbGxlY3Rpb25Ib2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8U3RyaW5nPigKLQkJCUNvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKGJ1aWxkVGFyZ2V0U2VydmVycygpKQotCQkpOwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFRhcmdldFNlcnZlcnNMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxTdHJpbmc+KAotCQkJYnVpbGRUYXJnZXRTZXJ2ZXJzQ29sbGVjdGlvbkhvbGRlcigpLAotCQkJYnVpbGRUYXJnZXRTZXJ2ZXJDb21wYXJhdG9yKCkKLQkJKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBnZXREZWZhdWx0VmFsdWUoT3B0aW9ucyBzdWJqZWN0KSB7Ci0JCVN0cmluZyBkZWZhdWx0VmFsdWUgPSBzdWJqZWN0LmdldERlZmF1bHRUYXJnZXRTZXJ2ZXIoKTsKLQotCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCXJldHVybiBOTFMuYmluZCgKLQkJCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX2RlZmF1bHRXaXRoT25lUGFyYW0sCi0JCQkJZGVmYXVsdFZhbHVlCi0JCQkpOwotCQl9Ci0JCWVsc2UgewotCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfZGVmYXVsdEVtcHR5OwotCQl9Ci0JfQotCi0JLyoKLQkgKiAobm9uLUphdmFkb2MpCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJQ0NvbWJvIGNvbWJvID0gYWRkTGFiZWxlZEVkaXRhYmxlQ0NvbWJvKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl90YXJnZXRTZXJ2ZXJMYWJlbCwKLQkJCXRoaXMuYnVpbGRUYXJnZXRTZXJ2ZXJMaXN0SG9sZGVyKCksCi0JCQl0aGlzLmJ1aWxkVGFyZ2V0U2VydmVySG9sZGVyKCksCi0JCQl0aGlzLmJ1aWxkVGFyZ2V0U2VydmVyQ29udmVydGVyKCksCi0JCQludWxsCQkvLyBFY2xpcHNlTGlua0hlbHBDb250ZXh0SWRzLlRBUkdFVF9TRVJWRVJfTkFNRQotCQkpOwotCi0JCVNXVFV0aWwuYXR0YWNoRGVmYXVsdFZhbHVlSGFuZGxlcihjb21ibyk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvb3B0aW9ucy9UZW1wb3JhbE11dGFibGVDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL29wdGlvbnMvVGVtcG9yYWxNdXRhYmxlQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGMxMjZlNGQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvb3B0aW9ucy9UZW1wb3JhbE11dGFibGVDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDk2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0qIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0qIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotKiAKLSogQ29udHJpYnV0b3JzOgotKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2Uub3B0aW9uczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2Uub3B0aW9ucy5PcHRpb25zOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5vc2dpLnV0aWwuTkxTOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiAgVGVtcG9yYWxNdXRhYmxlQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBUZW1wb3JhbE11dGFibGVDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxPcHRpb25zPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+VGVtcG9yYWxNdXRhYmxlQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRDb250cm9sbGVyCi0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIFRlbXBvcmFsTXV0YWJsZUNvbXBvc2l0ZSgKLQkJCQkJRm9ybVBhbmU8PyBleHRlbmRzIE9wdGlvbnM+IHBhcmVudENvbXBvc2l0ZSwKLQkJCQkJQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudENvbXBvc2l0ZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkVGVtcG9yYWxNdXRhYmxlSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxPcHRpb25zLCBCb29sZWFuPihnZXRTdWJqZWN0SG9sZGVyKCksIE9wdGlvbnMuVEVNUE9SQUxfTVVUQUJMRV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRUZW1wb3JhbE11dGFibGUoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCXN1YmplY3Quc2V0VGVtcG9yYWxNdXRhYmxlKHZhbHVlKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzdWJqZWN0Q2hhbmdlZCgpIHsKLQkJCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0JCQkJc3VwZXIuc3ViamVjdENoYW5nZWQoKTsKLQkJCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0KLQkJCQkvLyBNYWtlIHN1cmUgdGhlIGRlZmF1bHQgdmFsdWUgaXMgYXBwZW5kZWQgdG8gdGhlIHRleHQKLQkJCQlpZiAob2xkVmFsdWUgPT0gbmV3VmFsdWUgJiYgbmV3VmFsdWUgPT0gbnVsbCkgewotCQkJCQl0aGlzLmZpcmVBc3BlY3RDaGFuZ2UoQm9vbGVhbi5UUlVFLCBuZXdWYWx1ZSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRUZW1wb3JhbE11dGFibGVTdHJpbmdIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbiwgU3RyaW5nPihidWlsZFRlbXBvcmFsTXV0YWJsZUhvbGRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQlpZiAoKGdldFN1YmplY3QoKSAhPSBudWxsKSAmJiAodmFsdWUgPT0gbnVsbCkpIHsKLQkJCQkJQm9vbGVhbiBkZWZhdWx0VmFsdWUgPSBnZXRTdWJqZWN0KCkuZ2V0RGVmYXVsdFRlbXBvcmFsTXV0YWJsZSgpOwotCQkJCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCQkJCVN0cmluZyBkZWZhdWx0U3RyaW5nVmFsdWUgPSBkZWZhdWx0VmFsdWUgPyBFY2xpcHNlTGlua1VpTWVzc2FnZXMuQm9vbGVhbl9UcnVlIDogRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkJvb2xlYW5fRmFsc2U7Ci0JCQkJCQlyZXR1cm4gTkxTLmJpbmQoRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sT3B0aW9uc1RhYl90ZW1wb3JhbE11dGFibGVMYWJlbERlZmF1bHQsIGRlZmF1bHRTdHJpbmdWYWx1ZSk7Ci0JCQkJCX0KLQkJCQl9Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbE9wdGlvbnNUYWJfdGVtcG9yYWxNdXRhYmxlTGFiZWw7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJdGhpcy5hZGRUcmlTdGF0ZUNoZWNrQm94V2l0aERlZmF1bHQoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxPcHRpb25zVGFiX3RlbXBvcmFsTXV0YWJsZUxhYmVsLAotCQkJdGhpcy5idWlsZFRlbXBvcmFsTXV0YWJsZUhvbGRlcigpLAotCQkJdGhpcy5idWlsZFRlbXBvcmFsTXV0YWJsZVN0cmluZ0hvbGRlcigpLAotCQkJbnVsbAotLy8JCQlFY2xpcHNlTGlua0hlbHBDb250ZXh0SWRzLk9QVElPTlNfCi0JCSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvc2NoZW1hL2dlbmVyYXRpb24vQ3JlYXRlRGRsRmlsZU5hbWVDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL3NjaGVtYS9nZW5lcmF0aW9uL0NyZWF0ZURkbEZpbGVOYW1lQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQ4NTIxNWYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvc2NoZW1hL2dlbmVyYXRpb24vQ3JlYXRlRGRsRmlsZU5hbWVDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDExMCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSogCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLnNjaGVtYS5nZW5lcmF0aW9uOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5zY2hlbWEuZ2VuZXJhdGlvbi5TY2hlbWFHZW5lcmF0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuU1dUVXRpbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuY3VzdG9tLkNDb21ibzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogIENyZWF0ZURkbEZpbGVOYW1lQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBDcmVhdGVEZGxGaWxlTmFtZUNvbXBvc2l0ZSBleHRlbmRzIFBhbmU8U2NoZW1hR2VuZXJhdGlvbj4KLXsKLQkvKioKLQkgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPkNyZWF0ZURkbEZpbGVOYW1lQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRQYW5lIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBDcmVhdGVEZGxGaWxlTmFtZUNvbXBvc2l0ZSgKLQkJCQkJCQkJUGFuZTw/IGV4dGVuZHMgU2NoZW1hR2VuZXJhdGlvbj4gcGFyZW50UGFuZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGUgcGFyZW50KSB7Ci0KLQkJc3VwZXIocGFyZW50UGFuZSwgcGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdENyZWF0ZURkbEZpbGVOYW1lSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxTY2hlbWFHZW5lcmF0aW9uLCBTdHJpbmc+KHRoaXMuZ2V0U3ViamVjdEhvbGRlcigpLCBTY2hlbWFHZW5lcmF0aW9uLkRFRkFVTFRfU0NIRU1BX0dFTkVSQVRJT05fQ1JFQVRFX0ZJTEVfTkFNRSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBDcmVhdGVEZGxGaWxlTmFtZUNvbXBvc2l0ZS50aGlzLmdldERlZmF1bHRWYWx1ZShzdWJqZWN0KTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGREZWZhdWx0Q3JlYXRlRGRsRmlsZU5hbWVMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyPFN0cmluZz4oCi0JCQl0aGlzLmJ1aWxkRGVmYXVsdENyZWF0ZURkbEZpbGVOYW1lSG9sZGVyKCkKLQkJKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRDcmVhdGVEZGxGaWxlTmFtZUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8U2NoZW1hR2VuZXJhdGlvbiwgU3RyaW5nPih0aGlzLmdldFN1YmplY3RIb2xkZXIoKSwgU2NoZW1hR2VuZXJhdGlvbi5DUkVBVEVfRklMRV9OQU1FX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0KLQkJCQlTdHJpbmcgbmFtZSA9IHN1YmplY3QuZ2V0Q3JlYXRlRmlsZU5hbWUoKTsKLQkJCQlpZiAobmFtZSA9PSBudWxsKSB7Ci0JCQkJCW5hbWUgPSBDcmVhdGVEZGxGaWxlTmFtZUNvbXBvc2l0ZS50aGlzLmdldERlZmF1bHRWYWx1ZShzdWJqZWN0KTsKLQkJCQl9Ci0JCQkJcmV0dXJuIG5hbWU7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCi0JCQkJaWYgKGdldERlZmF1bHRWYWx1ZShzdWJqZWN0KS5lcXVhbHModmFsdWUpKSB7Ci0JCQkJCXZhbHVlID0gbnVsbDsKLQkJCQl9Ci0JCQkJc3ViamVjdC5zZXRDcmVhdGVGaWxlTmFtZSh2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmcgZ2V0RGVmYXVsdFZhbHVlKFNjaGVtYUdlbmVyYXRpb24gc3ViamVjdCkgewotCQlTdHJpbmcgZGVmYXVsdFZhbHVlID0gc3ViamVjdC5nZXREZWZhdWx0Q3JlYXRlRmlsZU5hbWUoKTsKLQotCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCXJldHVybiBOTFMuYmluZCgKLQkJCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxTY2hlbWFHZW5lcmF0aW9uVGFiX2RlZmF1bHRXaXRoT25lUGFyYW0sCi0JCQkJZGVmYXVsdFZhbHVlCi0JCQkpOwotCQl9Ci0JCWVsc2UgewotCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWJfZGVmYXVsdEVtcHR5OwotCQl9Ci0JfQotCi0JLyoKLQkgKiAobm9uLUphdmFkb2MpCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJQ0NvbWJvIGNvbWJvID0gYWRkTGFiZWxlZEVkaXRhYmxlQ0NvbWJvKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sU2NoZW1hR2VuZXJhdGlvblRhYl9jcmVhdGVEZGxGaWxlTmFtZUxhYmVsLAotCQkJdGhpcy5idWlsZERlZmF1bHRDcmVhdGVEZGxGaWxlTmFtZUxpc3RIb2xkZXIoKSwKLQkJCXRoaXMuYnVpbGRDcmVhdGVEZGxGaWxlTmFtZUhvbGRlcigpLAotCQkJbnVsbAkJLy8gRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcy5DUkVBVEVfRERMX0ZJTEVfTkFNRQotCQkpOwotCQlTV1RVdGlsLmF0dGFjaERlZmF1bHRWYWx1ZUhhbmRsZXIoY29tYm8pOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL3NjaGVtYS9nZW5lcmF0aW9uL0RkbEdlbmVyYXRpb25Mb2NhdGlvbkNvbXBvc2l0ZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvc2NoZW1hL2dlbmVyYXRpb24vRGRsR2VuZXJhdGlvbkxvY2F0aW9uQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDk3MDg1NWUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvc2NoZW1hL2dlbmVyYXRpb24vRGRsR2VuZXJhdGlvbkxvY2F0aW9uQ29tcG9zaXRlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw5MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLnNjaGVtYS5nZW5lcmF0aW9uOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5zY2hlbWEuZ2VuZXJhdGlvbi5TY2hlbWFHZW5lcmF0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9sZGVyQ2hvb3NlclBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogIERkbEdlbmVyYXRpb25Mb2NhdGlvbkNvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgRGRsR2VuZXJhdGlvbkxvY2F0aW9uQ29tcG9zaXRlIGV4dGVuZHMgUGFuZTxTY2hlbWFHZW5lcmF0aW9uPgotewotCXB1YmxpYyBEZGxHZW5lcmF0aW9uTG9jYXRpb25Db21wb3NpdGUoUGFuZTw/IGV4dGVuZHMgU2NoZW1hR2VuZXJhdGlvbj4gcGFyZW50UGFuZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQlzdXBlcihwYXJlbnRQYW5lLCBwYXJlbnQpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVMYXlvdXQoQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQkKLQkJbmV3IEZvbGRlckNob29zZXJQYW5lPFNjaGVtYUdlbmVyYXRpb24+KHRoaXMsIGNvbnRhaW5lcikgewotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkVGV4dEhvbGRlcigpIHsKLQkJCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxTY2hlbWFHZW5lcmF0aW9uLCBTdHJpbmc+KAotCQkJCQkJCQkJCWdldFN1YmplY3RIb2xkZXIoKSwgU2NoZW1hR2VuZXJhdGlvbi5BUFBMSUNBVElPTl9MT0NBVElPTl9QUk9QRVJUWSkgewotCQkJCQlAT3ZlcnJpZGUKLQkJCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQotCQkJCQkJU3RyaW5nIG5hbWUgPSBzdWJqZWN0LmdldEFwcGxpY2F0aW9uTG9jYXRpb24oKTsKLQkJCQkJCWlmIChuYW1lID09IG51bGwpIHsKLQkJCQkJCQluYW1lID0gZGVmYXVsdFZhbHVlKHN1YmplY3QpOwotCQkJCQkJfQotCQkJCQkJcmV0dXJuIG5hbWU7Ci0JCQkJCX0KLQotCQkJCQlAT3ZlcnJpZGUKLQkJCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCi0JCQkJCQlpZiAoZGVmYXVsdFZhbHVlKHN1YmplY3QpLmVxdWFscyh2YWx1ZSkpIHsKLQkJCQkJCQl2YWx1ZSA9IG51bGw7Ci0JCQkJCQl9Ci0JCQkJCQlzdWJqZWN0LnNldEFwcGxpY2F0aW9uTG9jYXRpb24odmFsdWUpOwotCQkJCQl9Ci0JCQkJfTsKLQkJCX0KLQotCQkJcHJpdmF0ZSBTdHJpbmcgZGVmYXVsdFZhbHVlKFNjaGVtYUdlbmVyYXRpb24gc3ViamVjdCkgewotCQkJCVN0cmluZyBkZWZhdWx0VmFsdWUgPSBzdWJqZWN0LmdldERlZmF1bHRBcHBsaWNhdGlvbkxvY2F0aW9uKCk7Ci0KLQkJCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCQkJcmV0dXJuIE5MUy5iaW5kKAotCQkJCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sU2NoZW1hR2VuZXJhdGlvblRhYl9kZWZhdWx0V2l0aE9uZVBhcmFtLAotCQkJCQkJZGVmYXVsdFZhbHVlCi0JCQkJCSk7Ci0JCQkJfQotCQkJCWVsc2UgewotCQkJCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sU2NoZW1hR2VuZXJhdGlvblRhYl9kZWZhdWx0RW1wdHk7Ci0JCQkJfQotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZ2V0RGlhbG9nTWVzc2FnZSgpIHsKLQkJCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLkRkbEdlbmVyYXRpb25Mb2NhdGlvbkNvbXBvc2l0ZV9kaWFsb2dNZXNzYWdlOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZ2V0RGlhbG9nVGl0bGUoKSB7Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5EZGxHZW5lcmF0aW9uTG9jYXRpb25Db21wb3NpdGVfZGlhbG9nVGl0bGU7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBnZXRMYWJlbFRleHQoKSB7Ci0JCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWJfZGRsR2VuZXJhdGlvbkxvY2F0aW9uTGFiZWw7Ci0JCQl9Ci0JCX07Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvc2NoZW1hL2dlbmVyYXRpb24vRGRsR2VuZXJhdGlvblR5cGVDb21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL3NjaGVtYS9nZW5lcmF0aW9uL0RkbEdlbmVyYXRpb25UeXBlQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGFjYzczN2EuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvc2NoZW1hL2dlbmVyYXRpb24vRGRsR2VuZXJhdGlvblR5cGVDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDg2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZS5zY2hlbWEuZ2VuZXJhdGlvbjsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2Uuc2NoZW1hLmdlbmVyYXRpb24uRGRsR2VuZXJhdGlvblR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5zY2hlbWEuZ2VuZXJhdGlvbi5TY2hlbWFHZW5lcmF0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRW51bUZvcm1Db21ib1ZpZXdlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogRGRsR2VuZXJhdGlvblR5cGVDb21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIERkbEdlbmVyYXRpb25UeXBlQ29tcG9zaXRlCi0JZXh0ZW5kcyBGb3JtUGFuZTxTY2hlbWFHZW5lcmF0aW9uPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+RGRsR2VuZXJhdGlvblR5cGVDb21wb3NpdGU8L2NvZGU+LgotCSAqIAotCSAqIEBwYXJhbSBwYXJlbnRDb250cm9sbGVyCi0JICogICAgICAgICAgICBUaGUgcGFyZW50IGNvbnRhaW5lciBvZiB0aGlzIG9uZQotCSAqIEBwYXJhbSBwYXJlbnQKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyCi0JICovCi0JcHVibGljIERkbEdlbmVyYXRpb25UeXBlQ29tcG9zaXRlKAotCQkJCQlGb3JtUGFuZTw/IGV4dGVuZHMgU2NoZW1hR2VuZXJhdGlvbj4gcGFyZW50Q29tcG9zaXRlLCAKLQkJCQkJQ29tcG9zaXRlIHBhcmVudCkgewotCQkKLQkJc3VwZXIocGFyZW50Q29tcG9zaXRlLCBwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgRW51bUZvcm1Db21ib1ZpZXdlcjxTY2hlbWFHZW5lcmF0aW9uLCBEZGxHZW5lcmF0aW9uVHlwZT4gYWRkRGRsR2VuZXJhdGlvblR5cGVDb21ibyhDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCXJldHVybiBuZXcgRW51bUZvcm1Db21ib1ZpZXdlcjxTY2hlbWFHZW5lcmF0aW9uLCBEZGxHZW5lcmF0aW9uVHlwZT4odGhpcywgY29udGFpbmVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIGFkZFByb3BlcnR5TmFtZXMoQ29sbGVjdGlvbjxTdHJpbmc+IHByb3BlcnR5TmFtZXMpIHsKLQkJCQlzdXBlci5hZGRQcm9wZXJ0eU5hbWVzKHByb3BlcnR5TmFtZXMpOwotCQkJCXByb3BlcnR5TmFtZXMuYWRkKFNjaGVtYUdlbmVyYXRpb24uRERMX0dFTkVSQVRJT05fVFlQRV9QUk9QRVJUWSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIERkbEdlbmVyYXRpb25UeXBlW10gZ2V0Q2hvaWNlcygpIHsKLQkJCQlyZXR1cm4gRGRsR2VuZXJhdGlvblR5cGUudmFsdWVzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIERkbEdlbmVyYXRpb25UeXBlIGdldERlZmF1bHRWYWx1ZSgpIHsKLQkJCQlyZXR1cm4gdGhpcy5nZXRTdWJqZWN0KCkuZ2V0RGVmYXVsdERkbEdlbmVyYXRpb25UeXBlKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBkaXNwbGF5U3RyaW5nKERkbEdlbmVyYXRpb25UeXBlIHZhbHVlKSB7Ci0JCQkJcmV0dXJuIHRoaXMuYnVpbGREaXNwbGF5U3RyaW5nKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5jbGFzcywgRGRsR2VuZXJhdGlvblR5cGVDb21wb3NpdGUudGhpcywgdmFsdWUpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBEZGxHZW5lcmF0aW9uVHlwZSBnZXRWYWx1ZSgpIHsKLQkJCQlyZXR1cm4gdGhpcy5nZXRTdWJqZWN0KCkuZ2V0RGRsR2VuZXJhdGlvblR5cGUoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZShEZGxHZW5lcmF0aW9uVHlwZSB2YWx1ZSkgewotCQkJCXRoaXMuZ2V0U3ViamVjdCgpLnNldERkbEdlbmVyYXRpb25UeXBlKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQl0aGlzLmFkZExhYmVsZWRDb21wb3NpdGUoCi0JCQljb250YWluZXIsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxTY2hlbWFHZW5lcmF0aW9uVGFiX2RkbEdlbmVyYXRpb25UeXBlTGFiZWwsCi0JCQlhZGREZGxHZW5lcmF0aW9uVHlwZUNvbWJvKCBjb250YWluZXIpLAotCQkJbnVsbAkJLy8gVE9ETyBJSnBhSGVscENvbnRleHRJZHMuCi0JCSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvc2NoZW1hL2dlbmVyYXRpb24vRHJvcERkbEZpbGVOYW1lQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9zY2hlbWEvZ2VuZXJhdGlvbi9Ecm9wRGRsRmlsZU5hbWVDb21wb3NpdGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDgwOTcxYS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9zY2hlbWEvZ2VuZXJhdGlvbi9Ecm9wRGRsRmlsZU5hbWVDb21wb3NpdGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDExMCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSogCi0qIENvbnRyaWJ1dG9yczoKLSogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLnNjaGVtYS5nZW5lcmF0aW9uOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5zY2hlbWEuZ2VuZXJhdGlvbi5TY2hlbWFHZW5lcmF0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuU1dUVXRpbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5QYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuY3VzdG9tLkNDb21ibzsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogIERyb3BEZGxGaWxlTmFtZUNvbXBvc2l0ZQotICovCi1wdWJsaWMgY2xhc3MgRHJvcERkbEZpbGVOYW1lQ29tcG9zaXRlIGV4dGVuZHMgUGFuZTxTY2hlbWFHZW5lcmF0aW9uPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+RHJvcERkbEZpbGVOYW1lQ29tcG9zaXRlPC9jb2RlPi4KLQkgKgotCSAqIEBwYXJhbSBwYXJlbnRQYW5lIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudCBUaGUgcGFyZW50IGNvbnRhaW5lcgotCSAqLwotCXB1YmxpYyBEcm9wRGRsRmlsZU5hbWVDb21wb3NpdGUoCi0JCQkJCQkJCVBhbmU8PyBleHRlbmRzIFNjaGVtYUdlbmVyYXRpb24+IHBhcmVudFBhbmUsCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCXN1cGVyKHBhcmVudFBhbmUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZERlZmF1bHREcm9wRGRsRmlsZU5hbWVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFNjaGVtYUdlbmVyYXRpb24sIFN0cmluZz4odGhpcy5nZXRTdWJqZWN0SG9sZGVyKCksIFNjaGVtYUdlbmVyYXRpb24uREVGQVVMVF9TQ0hFTUFfR0VORVJBVElPTl9EUk9QX0ZJTEVfTkFNRSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBEcm9wRGRsRmlsZU5hbWVDb21wb3NpdGUudGhpcy5nZXREZWZhdWx0VmFsdWUoc3ViamVjdCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkRGVmYXVsdERyb3BEZGxGaWxlTmFtZUxpc3RIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8U3RyaW5nPigKLQkJCXRoaXMuYnVpbGREZWZhdWx0RHJvcERkbEZpbGVOYW1lSG9sZGVyKCkKLQkJKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGREcm9wRGRsRmlsZU5hbWVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFNjaGVtYUdlbmVyYXRpb24sIFN0cmluZz4odGhpcy5nZXRTdWJqZWN0SG9sZGVyKCksIFNjaGVtYUdlbmVyYXRpb24uRFJPUF9GSUxFX05BTUVfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQotCQkJCVN0cmluZyBuYW1lID0gc3ViamVjdC5nZXREcm9wRmlsZU5hbWUoKTsKLQkJCQlpZiAobmFtZSA9PSBudWxsKSB7Ci0JCQkJCW5hbWUgPSBEcm9wRGRsRmlsZU5hbWVDb21wb3NpdGUudGhpcy5nZXREZWZhdWx0VmFsdWUoc3ViamVjdCk7Ci0JCQkJfQotCQkJCXJldHVybiBuYW1lOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhTdHJpbmcgdmFsdWUpIHsKLQotCQkJCWlmIChEcm9wRGRsRmlsZU5hbWVDb21wb3NpdGUudGhpcy5nZXREZWZhdWx0VmFsdWUoc3ViamVjdCkuZXF1YWxzKHZhbHVlKSkgewotCQkJCQl2YWx1ZSA9IG51bGw7Ci0JCQkJfQotCQkJCXN1YmplY3Quc2V0RHJvcEZpbGVOYW1lKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBnZXREZWZhdWx0VmFsdWUoU2NoZW1hR2VuZXJhdGlvbiBzdWJqZWN0KSB7Ci0JCVN0cmluZyBkZWZhdWx0VmFsdWUgPSBzdWJqZWN0LmdldERlZmF1bHREcm9wRmlsZU5hbWUoKTsKLQotCQlpZiAoZGVmYXVsdFZhbHVlICE9IG51bGwpIHsKLQkJCXJldHVybiBOTFMuYmluZCgKLQkJCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxTY2hlbWFHZW5lcmF0aW9uVGFiX2RlZmF1bHRXaXRoT25lUGFyYW0sCi0JCQkJZGVmYXVsdFZhbHVlCi0JCQkpOwotCQl9Ci0JCWVsc2UgewotCQkJcmV0dXJuIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5QZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWJfZGVmYXVsdEVtcHR5OwotCQl9Ci0JfQotCi0JLyoKLQkgKiAobm9uLUphdmFkb2MpCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0KLQkJQ0NvbWJvIGNvbWJvID0gYWRkTGFiZWxlZEVkaXRhYmxlQ0NvbWJvKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sU2NoZW1hR2VuZXJhdGlvblRhYl9kcm9wRGRsRmlsZU5hbWVMYWJlbCwKLQkJCXRoaXMuYnVpbGREZWZhdWx0RHJvcERkbEZpbGVOYW1lTGlzdEhvbGRlcigpLAotCQkJdGhpcy5idWlsZERyb3BEZGxGaWxlTmFtZUhvbGRlcigpLAotCQkJbnVsbAkJLy8gRWNsaXBzZUxpbmtIZWxwQ29udGV4dElkcy5EUk9QX0RETF9GSUxFX05BTUUKLQkJKTsKLQkJU1dUVXRpbC5hdHRhY2hEZWZhdWx0VmFsdWVIYW5kbGVyKGNvbWJvKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9zY2hlbWEvZ2VuZXJhdGlvbi9FY2xpcHNlTGlua1NjaGVtYUdlbmVyYXRpb25Db21wb3NpdGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL3NjaGVtYS9nZW5lcmF0aW9uL0VjbGlwc2VMaW5rU2NoZW1hR2VuZXJhdGlvbkNvbXBvc2l0ZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2ZGZhZGMxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BlcnNpc3RlbmNlL3NjaGVtYS9nZW5lcmF0aW9uL0VjbGlwc2VMaW5rU2NoZW1hR2VuZXJhdGlvbkNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGVyc2lzdGVuY2Uuc2NoZW1hLmdlbmVyYXRpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5jb250ZXh0LnBlcnNpc3RlbmNlLnNjaGVtYS5nZW5lcmF0aW9uLlNjaGVtYUdlbmVyYXRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rVWlNZXNzYWdlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci0KLS8qKgotICogRWNsaXBzZUxpbmtTY2hlbWFHZW5lcmF0aW9uQ29tcG9zaXRlCi0gKi8KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua1NjaGVtYUdlbmVyYXRpb25Db21wb3NpdGUKLQlleHRlbmRzIEZvcm1QYW5lPFNjaGVtYUdlbmVyYXRpb24+Ci17Ci0JcHVibGljIEVjbGlwc2VMaW5rU2NoZW1hR2VuZXJhdGlvbkNvbXBvc2l0ZSgKLQkJCQkJRm9ybVBhbmU8U2NoZW1hR2VuZXJhdGlvbj4gc3ViamVjdEhvbGRlciwKLQkJCQkJQ29tcG9zaXRlIGNvbnRhaW5lcikgewotCQlzdXBlcihzdWJqZWN0SG9sZGVyLCBjb250YWluZXIsIGZhbHNlKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQotCQljb250YWluZXIgPSBhZGRTZWN0aW9uKAotCQkJY29udGFpbmVyLAotCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sU2NoZW1hR2VuZXJhdGlvblRhYl9zZWN0aW9uVGl0bGUsCi0JCQlFY2xpcHNlTGlua1VpTWVzc2FnZXMuUGVyc2lzdGVuY2VYbWxTY2hlbWFHZW5lcmF0aW9uVGFiX3NlY3Rpb25EZXNjcmlwdGlvbgotCQkpOwotCi0JCS8vIERETCBHZW5lcmF0aW9uIFR5cGU6Ci0JCW5ldyBEZGxHZW5lcmF0aW9uVHlwZUNvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCQkvLyBPdXRwdXQgTW9kZToKLQkJbmV3IE91dHB1dE1vZGVDb21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQkJLy8gRERMIEdlbmVyYXRpb24gTG9jYXRpb24KLQkJbmV3IERkbEdlbmVyYXRpb25Mb2NhdGlvbkNvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCQkvLyBDcmVhdGUgRERMIEZpbGUgTmFtZToKLQkJbmV3IENyZWF0ZURkbEZpbGVOYW1lQ29tcG9zaXRlKHRoaXMsIGNvbnRhaW5lcik7Ci0JCS8vIERyb3AgRERMIEZpbGUgTmFtZToKLQkJbmV3IERyb3BEZGxGaWxlTmFtZUNvbXBvc2l0ZSh0aGlzLCBjb250YWluZXIpOwotCX0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9zY2hlbWEvZ2VuZXJhdGlvbi9PdXRwdXRNb2RlQ29tcG9zaXRlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9zY2hlbWEvZ2VuZXJhdGlvbi9PdXRwdXRNb2RlQ29tcG9zaXRlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDY2OTA0ZjUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvc2NoZW1hL2dlbmVyYXRpb24vT3V0cHV0TW9kZUNvbXBvc2l0ZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLnNjaGVtYS5nZW5lcmF0aW9uOwotCi1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5zY2hlbWEuZ2VuZXJhdGlvbi5PdXRwdXRNb2RlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2Uuc2NoZW1hLmdlbmVyYXRpb24uU2NoZW1hR2VuZXJhdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aWRnZXRzLkVudW1Gb3JtQ29tYm9WaWV3ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpZGdldHMuRm9ybVBhbmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotCi0vKioKLSAqIE91dHB1dE1vZGVDb21wb3NpdGUKLSAqLwotcHVibGljIGNsYXNzIE91dHB1dE1vZGVDb21wb3NpdGUgZXh0ZW5kcyBGb3JtUGFuZTxTY2hlbWFHZW5lcmF0aW9uPgotewotCS8qKgotCSAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+T3V0cHV0TW9kZUNvbXBvc2l0ZTwvY29kZT4uCi0JICogCi0JICogQHBhcmFtIHBhcmVudENvbnRyb2xsZXIKLQkgKiAgICAgICAgICAgIFRoZSBwYXJlbnQgY29udGFpbmVyIG9mIHRoaXMgb25lCi0JICogQHBhcmFtIHBhcmVudAotCSAqICAgICAgICAgICAgVGhlIHBhcmVudCBjb250YWluZXIKLQkgKi8KLQlwdWJsaWMgT3V0cHV0TW9kZUNvbXBvc2l0ZSgKLQkJCQlGb3JtUGFuZTw/IGV4dGVuZHMgU2NoZW1hR2VuZXJhdGlvbj4gcGFyZW50Q29tcG9zaXRlLCAKLQkJCQlDb21wb3NpdGUgcGFyZW50KSB7Ci0JCQotCQlzdXBlcihwYXJlbnRDb21wb3NpdGUsIHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBFbnVtRm9ybUNvbWJvVmlld2VyPFNjaGVtYUdlbmVyYXRpb24sIE91dHB1dE1vZGU+IGFkZEJ1aWxkT3V0cHV0TW9kZUNvbWJvKENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJcmV0dXJuIG5ldyBFbnVtRm9ybUNvbWJvVmlld2VyPFNjaGVtYUdlbmVyYXRpb24sIE91dHB1dE1vZGU+KHRoaXMsIGNvbnRhaW5lcikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBhZGRQcm9wZXJ0eU5hbWVzKENvbGxlY3Rpb248U3RyaW5nPiBwcm9wZXJ0eU5hbWVzKSB7Ci0JCQkJc3VwZXIuYWRkUHJvcGVydHlOYW1lcyhwcm9wZXJ0eU5hbWVzKTsKLQkJCQlwcm9wZXJ0eU5hbWVzLmFkZChTY2hlbWFHZW5lcmF0aW9uLk9VVFBVVF9NT0RFX1BST1BFUlRZKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgT3V0cHV0TW9kZVtdIGdldENob2ljZXMoKSB7Ci0JCQkJcmV0dXJuIE91dHB1dE1vZGUudmFsdWVzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIE91dHB1dE1vZGUgZ2V0RGVmYXVsdFZhbHVlKCkgewotCQkJCXJldHVybiB0aGlzLmdldFN1YmplY3QoKS5nZXREZWZhdWx0T3V0cHV0TW9kZSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgZGlzcGxheVN0cmluZyhPdXRwdXRNb2RlIHZhbHVlKSB7Ci0JCQkJcmV0dXJuIHRoaXMuYnVpbGREaXNwbGF5U3RyaW5nKEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5jbGFzcywgT3V0cHV0TW9kZUNvbXBvc2l0ZS50aGlzLCB2YWx1ZSk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIE91dHB1dE1vZGUgZ2V0VmFsdWUoKSB7Ci0JCQkJcmV0dXJuIHRoaXMuZ2V0U3ViamVjdCgpLmdldE91dHB1dE1vZGUoKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZShPdXRwdXRNb2RlIHZhbHVlKSB7Ci0JCQkJdGhpcy5nZXRTdWJqZWN0KCkuc2V0T3V0cHV0TW9kZSh2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCXRoaXMuYWRkTGFiZWxlZENvbXBvc2l0ZSgKLQkJCQljb250YWluZXIsCi0JCQkJRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sU2NoZW1hR2VuZXJhdGlvblRhYl9vdXRwdXRNb2RlTGFiZWwsCi0JCQkJdGhpcy5hZGRCdWlsZE91dHB1dE1vZGVDb21ibyhjb250YWluZXIpLAotCQkJCW51bGwgLy8gVE9ETyBJSnBhSGVscENvbnRleHRJZHMuCi0JCSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2Uvc2NoZW1hL2dlbmVyYXRpb24vUGVyc2lzdGVuY2VYbWxTY2hlbWFHZW5lcmF0aW9uVGFiLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9zY2hlbWEvZ2VuZXJhdGlvbi9QZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmJmZWNjYy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZS9zY2hlbWEvZ2VuZXJhdGlvbi9QZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNlLnNjaGVtYS5nZW5lcmF0aW9uOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuY29udGV4dC5wZXJzaXN0ZW5jZS5zY2hlbWEuZ2VuZXJhdGlvbi5TY2hlbWFHZW5lcmF0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLldpZGdldEZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuSnBhUGFnZUNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5Gb3JtUGFuZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLkltYWdlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLQotLyoqCi0gKiBQZXJzaXN0ZW5jZVhtbFNjaGVtYUdlbmVyYXRpb25UYWIKLSAqLwotcHVibGljIGNsYXNzIFBlcnNpc3RlbmNlWG1sU2NoZW1hR2VuZXJhdGlvblRhYgotCWV4dGVuZHMgRm9ybVBhbmU8U2NoZW1hR2VuZXJhdGlvbj4KLQlpbXBsZW1lbnRzIEpwYVBhZ2VDb21wb3NpdGUKLXsKLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycy9pbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0JcHVibGljIFBlcnNpc3RlbmNlWG1sU2NoZW1hR2VuZXJhdGlvblRhYigKLQkJCQlQcm9wZXJ0eVZhbHVlTW9kZWw8U2NoZW1hR2VuZXJhdGlvbj4gc3ViamVjdEhvbGRlciwKLQkJCQlDb21wb3NpdGUgcGFyZW50LAotCQkJCVdpZGdldEZhY3Rvcnkgd2lkZ2V0RmFjdG9yeSkgewotCi0JCXN1cGVyKHN1YmplY3RIb2xkZXIsIHBhcmVudCwgd2lkZ2V0RmFjdG9yeSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCW5ldyBFY2xpcHNlTGlua1NjaGVtYUdlbmVyYXRpb25Db21wb3NpdGUodGhpcywgY29udGFpbmVyKTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIEpwYVBhZ2VDb21wb3NpdGUgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCXB1YmxpYyBTdHJpbmcgZ2V0SGVscElEKCkgewotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQlwdWJsaWMgSW1hZ2UgZ2V0UGFnZUltYWdlKCkgewotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGdldFBhZ2VUZXh0KCkgewotCQlyZXR1cm4gRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLlBlcnNpc3RlbmNlWG1sU2NoZW1hR2VuZXJhdGlvblRhYl90aXRsZTsKLQl9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2V4bWwvZGV0YWlscy9FY2xpcHNlTGlua05hdmlnYXRvckl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5LmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZXhtbC9kZXRhaWxzL0VjbGlwc2VMaW5rTmF2aWdhdG9ySXRlbUNvbnRlbnRQcm92aWRlckZhY3RvcnkuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZGU3YWJmNy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZXhtbC9kZXRhaWxzL0VjbGlwc2VMaW5rTmF2aWdhdG9ySXRlbUNvbnRlbnRQcm92aWRlckZhY3RvcnkuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDk0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDgsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZXhtbC5kZXRhaWxzOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuSnBhQ29udGV4dE5vZGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5NYXBwaW5nRmlsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LnBlcnNpc3RlbmNlLk1hcHBpbmdGaWxlUmVmOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmpmYWNlLkRlbGVnYXRpbmdUcmVlQ29udGVudEFuZExhYmVsUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnBsYXRmb3JtLmdlbmVyaWMuR2VuZXJpY05hdmlnYXRvckl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5qZmFjZS5EZWxlZ2F0aW5nQ29udGVudEFuZExhYmVsUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmpmYWNlLlRyZWVJdGVtQ29udGVudFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5qZmFjZS5UcmVlSXRlbUNvbnRlbnRQcm92aWRlckZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuQ29tcG9zaXRlQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotCi0vKioKLSAqIEVjbGlwc2VMaW5rTmF2aWdhdG9ySXRlbUNvbnRlbnRQcm92aWRlckZhY3RvcnkKLSAqLwotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rTmF2aWdhdG9ySXRlbUNvbnRlbnRQcm92aWRlckZhY3RvcnkKLQlleHRlbmRzIEdlbmVyaWNOYXZpZ2F0b3JJdGVtQ29udGVudFByb3ZpZGVyRmFjdG9yeQotCWltcGxlbWVudHMgVHJlZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5Ci17Ci0JQE92ZXJyaWRlCi0JcHVibGljIFRyZWVJdGVtQ29udGVudFByb3ZpZGVyIGJ1aWxkSXRlbUNvbnRlbnRQcm92aWRlcigKLQkJCU9iamVjdCBpdGVtLCBEZWxlZ2F0aW5nQ29udGVudEFuZExhYmVsUHJvdmlkZXIgY29udGVudEFuZExhYmVsUHJvdmlkZXIpIHsKLQkJRGVsZWdhdGluZ1RyZWVDb250ZW50QW5kTGFiZWxQcm92aWRlciB0cmVlQ29udGVudEFuZExhYmVsUHJvdmlkZXIgPSAKLQkJCShEZWxlZ2F0aW5nVHJlZUNvbnRlbnRBbmRMYWJlbFByb3ZpZGVyKSBjb250ZW50QW5kTGFiZWxQcm92aWRlcjsKLQkJCi0JCWlmIChpdGVtIGluc3RhbmNlb2YgRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQpIHsKLQkJCXJldHVybiBuZXcgRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXRJdGVtQ29udGVudFByb3ZpZGVyKAotCQkJCShFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdCkgaXRlbSwgdHJlZUNvbnRlbnRBbmRMYWJlbFByb3ZpZGVyKTsJCi0JCX0KLQkJCi0JCXJldHVybiBzdXBlci5idWlsZEl0ZW1Db250ZW50UHJvdmlkZXIoaXRlbSwgY29udGVudEFuZExhYmVsUHJvdmlkZXIpOwotCX0KLQkKLQkKLQlwdWJsaWMgc3RhdGljIGNsYXNzIEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0SXRlbUNvbnRlbnRQcm92aWRlciAKLQkJZXh0ZW5kcyBQZXJzaXN0ZW5jZVVuaXRJdGVtQ29udGVudFByb3ZpZGVyCi0JewotCQlwdWJsaWMgRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXRJdGVtQ29udGVudFByb3ZpZGVyKAotCQkJCUVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0IHBlcnNpc3RlbmNlVW5pdCwgRGVsZWdhdGluZ1RyZWVDb250ZW50QW5kTGFiZWxQcm92aWRlciBjb250ZW50UHJvdmlkZXIpIHsKLQkJCXN1cGVyKHBlcnNpc3RlbmNlVW5pdCwgY29udGVudFByb3ZpZGVyKTsKLQkJfQotCQkKLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdCBnZXRNb2RlbCgpIHsKLQkJCXJldHVybiAoRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQpIHN1cGVyLmdldE1vZGVsKCk7Ci0JCX0KLQkJCi0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgQ29sbGVjdGlvblZhbHVlTW9kZWw8SnBhQ29udGV4dE5vZGU+IGJ1aWxkQ2hpbGRyZW5Nb2RlbCgpIHsKLQkJCUxpc3Q8Q29sbGVjdGlvblZhbHVlTW9kZWw8PyBleHRlbmRzIEpwYUNvbnRleHROb2RlPj4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8Q29sbGVjdGlvblZhbHVlTW9kZWw8PyBleHRlbmRzIEpwYUNvbnRleHROb2RlPj4oKTsKLQkJCWxpc3QuYWRkKGJ1aWxkU3BlY2lmaWVkT3JtWG1sQ3ZtKCkpOwotCQkJbGlzdC5hZGQoYnVpbGRJbXBsaWVkTWFwcGluZ0ZpbGVDdm0oKSk7Ci0JCQlsaXN0LmFkZChidWlsZEltcGxpZWRFY2xpcHNlTGlua01hcHBpbmdGaWxlQ3ZtKCkpOwotCQkJbGlzdC5hZGQoYnVpbGRQZXJzaXN0ZW50VHlwZUN2bSgpKTsKLQkJCXJldHVybiBuZXcgQ29tcG9zaXRlQ29sbGVjdGlvblZhbHVlTW9kZWw8Q29sbGVjdGlvblZhbHVlTW9kZWw8PyBleHRlbmRzIEpwYUNvbnRleHROb2RlPiwgSnBhQ29udGV4dE5vZGU+KGxpc3QpOwotCQl9Ci0JCQotCQlwcml2YXRlIENvbGxlY3Rpb25WYWx1ZU1vZGVsPE1hcHBpbmdGaWxlPiBidWlsZEltcGxpZWRFY2xpcHNlTGlua01hcHBpbmdGaWxlQ3ZtKCkgewotCQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUNvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlcjxNYXBwaW5nRmlsZT4oCi0JCQkJbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxNYXBwaW5nRmlsZVJlZiwgTWFwcGluZ0ZpbGU+KAotCQkJCQkJbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdCwgTWFwcGluZ0ZpbGVSZWY+KAotCQkJCQkJCQlFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdC5JTVBMSUVEX0VDTElQU0VMSU5LX01BUFBJTkdfRklMRV9SRUZfUFJPUEVSVFksCi0JCQkJCQkJCWdldE1vZGVsKCkpIHsKLQkJCQkJCQlAT3ZlcnJpZGUKLQkJCQkJCQlwcm90ZWN0ZWQgTWFwcGluZ0ZpbGVSZWYgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCQkJCXJldHVybiBzdWJqZWN0LmdldEltcGxpZWRFY2xpcHNlTGlua01hcHBpbmdGaWxlUmVmKCk7Ci0JCQkJCQkJfQotCQkJCQkJfSwKLQkJCQkJCU1hcHBpbmdGaWxlUmVmLk1BUFBJTkdfRklMRV9QUk9QRVJUWSkgewotCQkJCQlAT3ZlcnJpZGUKLQkJCQkJcHJvdGVjdGVkIE1hcHBpbmdGaWxlIGJ1aWxkVmFsdWVfKCkgewotCQkJCQkJcmV0dXJuIHN1YmplY3QuZ2V0TWFwcGluZ0ZpbGUoKTsKLQkJCQkJfQotCQkJCX0KLQkJCSk7Ci0JCX0KLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZXhtbC9kZXRhaWxzL0VjbGlwc2VMaW5rTmF2aWdhdG9ySXRlbUxhYmVsUHJvdmlkZXJGYWN0b3J5LmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wZXJzaXN0ZW5jZXhtbC9kZXRhaWxzL0VjbGlwc2VMaW5rTmF2aWdhdG9ySXRlbUxhYmVsUHJvdmlkZXJGYWN0b3J5LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDZmYTAzZDMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGVyc2lzdGVuY2V4bWwvZGV0YWlscy9FY2xpcHNlTGlua05hdmlnYXRvckl0ZW1MYWJlbFByb3ZpZGVyRmFjdG9yeS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNleG1sLmRldGFpbHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwucGxhdGZvcm0uZ2VuZXJpYy5HZW5lcmljTmF2aWdhdG9ySXRlbUxhYmVsUHJvdmlkZXJGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5qZmFjZS5JdGVtTGFiZWxQcm92aWRlckZhY3Rvcnk7Ci0KLS8qKgotICogRWNsaXBzZUxpbmtOYXZpZ2F0b3JJdGVtTGFiZWxQcm92aWRlckZhY3RvcnkKLSAqLwotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rTmF2aWdhdG9ySXRlbUxhYmVsUHJvdmlkZXJGYWN0b3J5Ci0JZXh0ZW5kcyBHZW5lcmljTmF2aWdhdG9ySXRlbUxhYmVsUHJvdmlkZXJGYWN0b3J5Ci0JaW1wbGVtZW50cyBJdGVtTGFiZWxQcm92aWRlckZhY3RvcnkKLXsKLQkKLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BsYXRmb3JtL0VjbGlwc2VMaW5rMV8xSnBhUGxhdGZvcm1VaUZhY3RvcnkuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BsYXRmb3JtL0VjbGlwc2VMaW5rMV8xSnBhUGxhdGZvcm1VaUZhY3RvcnkuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmViMmFhZi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wbGF0Zm9ybS9FY2xpcHNlTGluazFfMUpwYVBsYXRmb3JtVWlGYWN0b3J5LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0MyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBsYXRmb3JtOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLkVjbGlwc2VMaW5rSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5zdHJ1Y3R1cmUuRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVJlc291cmNlTW9kZWxTdHJ1Y3R1cmVQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhUGxhdGZvcm1VaTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhUGxhdGZvcm1VaUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLkdlbmVyaWNKcGFQbGF0Zm9ybVVpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnN0cnVjdHVyZS5KYXZhUmVzb3VyY2VNb2RlbFN0cnVjdHVyZVByb3ZpZGVyOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmsxXzFKcGFQbGF0Zm9ybVVpRmFjdG9yeSBpbXBsZW1lbnRzIEpwYVBsYXRmb3JtVWlGYWN0b3J5Ci17Ci0KLQkvKioKLQkgKiBaZXJvIGFyZyBjb25zdHJ1Y3RvciBmb3IgZXh0ZW5zaW9uIHBvaW50Ci0JICovCi0JcHVibGljIEVjbGlwc2VMaW5rMV8xSnBhUGxhdGZvcm1VaUZhY3RvcnkoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JcHVibGljIEpwYVBsYXRmb3JtVWkgYnVpbGRKcGFQbGF0Zm9ybVVpKCkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rSnBhUGxhdGZvcm1VaSgKLQkJCW5ldyBFY2xpcHNlTGlua0pwYVVpRmFjdG9yeSgpLCAvL25ldyBFY2xpcHNlTGluazFfMUpwYVVpRmFjdG9yeSgpIGlzIG5vdCBiZWluZyB1c2VkIGJlY2F1c2UgCi0JCQkJCQkJCQkJICAgLy93ZSBkb24ndCB3YW50IHRoZSBqYXZhIEFjY2VzcyBhbm5vdGF0aW9uIHdvcmsgdG8gYmUgZXhwb3NlZCB5ZXQKLQkJCQkJCQkJCQkgICAvL0VjbGlwc2VMaW5rIGhhcyBiYWNrZWQgb3V0IGl0cyBKUEEgMi4wIGFubm90YXRpb24gc3VwcG9ydCB1bnRpbCAKLQkJCQkJCQkJCQkgICAvL2l0IGlzIHJlbGVhc2VkIG9yIGxpY2Vuc2luZyBpc3N1ZXMgYXJlIGNsZWFyZWQgdXAKLQkJCW5ldyBFY2xpcHNlTGlua05hdmlnYXRvclByb3ZpZGVyKCksCi0JCQlKYXZhUmVzb3VyY2VNb2RlbFN0cnVjdHVyZVByb3ZpZGVyLmluc3RhbmNlKCksIAotCQkJRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVJlc291cmNlTW9kZWxTdHJ1Y3R1cmVQcm92aWRlci5pbnN0YW5jZSgpLAotCQkJR2VuZXJpY0pwYVBsYXRmb3JtVWlQcm92aWRlci5pbnN0YW5jZSgpLAotCQkJRWNsaXBzZUxpbmtKcGFQbGF0Zm9ybVVpUHJvdmlkZXIuaW5zdGFuY2UoKSwKLQkJCUVjbGlwc2VMaW5rMV8xSnBhUGxhdGZvcm1VaVByb3ZpZGVyLmluc3RhbmNlKCkKLQkJKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wbGF0Zm9ybS9FY2xpcHNlTGluazFfMUpwYVBsYXRmb3JtVWlQcm92aWRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGxhdGZvcm0vRWNsaXBzZUxpbmsxXzFKcGFQbGF0Zm9ybVVpUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjIxYTM2Zi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wbGF0Zm9ybS9FY2xpcHNlTGluazFfMUpwYVBsYXRmb3JtVWlQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTE2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBsYXRmb3JtOwotCi1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5BdHRyaWJ1dGVNYXBwaW5nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGluazFfMU9ybUJhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzLkVjbGlwc2VMaW5rMV8xT3JtQmFzaWNNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRhYmxlVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuRWNsaXBzZUxpbmsxXzFPcm1FbWJlZGRlZElkTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzLkVjbGlwc2VMaW5rMV8xT3JtRW1iZWRkZWRNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuRWNsaXBzZUxpbmsxXzFPcm1FbnRpdHlVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGluazFfMU9ybUlkTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzLkVjbGlwc2VMaW5rMV8xT3JtTWFueVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGluazFfMU9ybU1hbnlUb09uZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGluazFfMU9ybU1hcHBlZFN1cGVyY2xhc3NVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGluazFfMU9ybU9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGluazFfMU9ybU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzLkVjbGlwc2VMaW5rMV8xT3JtVHJhbnNmb3JtYXRpb25NYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuRWNsaXBzZUxpbmsxXzFPcm1UcmFuc2llbnRNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuRWNsaXBzZUxpbmsxXzFPcm1WYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzLkVjbGlwc2VMaW5rMV8xT3JtVmVyc2lvbk1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5zdHJ1Y3R1cmUuRWNsaXBzZUxpbmsxXzFPcm1SZXNvdXJjZU1vZGVsU3RydWN0dXJlUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVBsYXRmb3JtVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5BdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5EZWZhdWx0QXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuRGVmYXVsdFR5cGVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFEZXRhaWxzUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuVHlwZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5BYnN0cmFjdEpwYVBsYXRmb3JtVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuc3RydWN0dXJlLkpwYVN0cnVjdHVyZVByb3ZpZGVyOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmsxXzFKcGFQbGF0Zm9ybVVpUHJvdmlkZXIgZXh0ZW5kcyBBYnN0cmFjdEpwYVBsYXRmb3JtVWlQcm92aWRlcgotewotCi0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgSnBhUGxhdGZvcm1VaVByb3ZpZGVyIElOU1RBTkNFID0gbmV3IEVjbGlwc2VMaW5rMV8xSnBhUGxhdGZvcm1VaVByb3ZpZGVyKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEpwYVBsYXRmb3JtVWlQcm92aWRlciBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGluazFfMUpwYVBsYXRmb3JtVWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogZGV0YWlscyBwcm92aWRlcnMgKioqKioqKioqKgotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGFkZERldGFpbHNQcm92aWRlcnNUbyhMaXN0PEpwYURldGFpbHNQcm92aWRlcj4gcHJvdmlkZXJzKSB7Ci0JCS8vbm9uZSBzcGVjaWZpYyB0byBFY2xpcHNlTGluayAxLjEKLQl9Ci0JCi0JLy8gKioqKioqKioqKiBzdHJ1Y3R1cmUgcHJvdmlkZXJzICoqKioqKioqKioKLQkKLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBhZGRNYXBwaW5nRmlsZVN0cnVjdHVyZVByb3ZpZGVyc1RvKExpc3Q8SnBhU3RydWN0dXJlUHJvdmlkZXI+IHByb3ZpZGVycykgewotCQlwcm92aWRlcnMuYWRkKEVjbGlwc2VMaW5rMV8xT3JtUmVzb3VyY2VNb2RlbFN0cnVjdHVyZVByb3ZpZGVyLmluc3RhbmNlKCkpOwotCX0KLQotCQotCS8vICoqKioqKioqKiogdHlwZSBtYXBwaW5nIHVpIHByb3ZpZGVycyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBhZGRUeXBlTWFwcGluZ1VpUHJvdmlkZXJzVG8oTGlzdDxUeXBlTWFwcGluZ1VpUHJvdmlkZXI8Pz4+IHByb3ZpZGVycykgewotCQlwcm92aWRlcnMuYWRkKEVjbGlwc2VMaW5rMV8xT3JtRW50aXR5VWlQcm92aWRlci5pbnN0YW5jZSgpKTsKLQkJcHJvdmlkZXJzLmFkZChFY2xpcHNlTGluazFfMU9ybU1hcHBlZFN1cGVyY2xhc3NVaVByb3ZpZGVyLmluc3RhbmNlKCkpOwotCQlwcm92aWRlcnMuYWRkKEVjbGlwc2VMaW5rMV8xT3JtRW1iZWRkYWJsZVVpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGFkZERlZmF1bHRUeXBlTWFwcGluZ1VpUHJvdmlkZXJzVG8oTGlzdDxEZWZhdWx0VHlwZU1hcHBpbmdVaVByb3ZpZGVyPD8+PiBwcm92aWRlcnMpIHsKLQkJLy9ub25lIHNwZWNpZmljIHRvIEVjbGlwc2VMaW5rIDEuMQotCX0KLQkKLQkKLQkvLyAqKioqKioqKioqIGF0dHJpYnV0ZSBtYXBwaW5nIHVpIHByb3ZpZGVycyAqKioqKioqKioqCi0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgYWRkQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXJzVG8oTGlzdDxBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjw/IGV4dGVuZHMgQXR0cmlidXRlTWFwcGluZz4+IHByb3ZpZGVycykgewotCQlwcm92aWRlcnMuYWRkKEVjbGlwc2VMaW5rMV8xT3JtSWRNYXBwaW5nVWlQcm92aWRlci5pbnN0YW5jZSgpKTsKLQkJcHJvdmlkZXJzLmFkZChFY2xpcHNlTGluazFfMU9ybUVtYmVkZGVkSWRNYXBwaW5nVWlQcm92aWRlci5pbnN0YW5jZSgpKTsKLQkJcHJvdmlkZXJzLmFkZChFY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmsxXzFPcm1CYXNpY0NvbGxlY3Rpb25NYXBwaW5nVWlQcm92aWRlci5pbnN0YW5jZSgpKTsKLQkJcHJvdmlkZXJzLmFkZChFY2xpcHNlTGluazFfMU9ybUJhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmsxXzFPcm1WZXJzaW9uTWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmsxXzFPcm1NYW55VG9PbmVNYXBwaW5nVWlQcm92aWRlci5pbnN0YW5jZSgpKTsKLQkJcHJvdmlkZXJzLmFkZChFY2xpcHNlTGluazFfMU9ybU9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyLmluc3RhbmNlKCkpOwotCQlwcm92aWRlcnMuYWRkKEVjbGlwc2VMaW5rMV8xT3JtRW1iZWRkZWRNYXBwaW5nVWlQcm92aWRlci5pbnN0YW5jZSgpKTsKLQkJcHJvdmlkZXJzLmFkZChFY2xpcHNlTGluazFfMU9ybU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmsxXzFPcm1WYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmsxXzFPcm1NYW55VG9NYW55TWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmsxXzFPcm1UcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyLmluc3RhbmNlKCkpOwotCQlwcm92aWRlcnMuYWRkKEVjbGlwc2VMaW5rMV8xT3JtVHJhbnNpZW50TWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGFkZERlZmF1bHRBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcnNUbyhMaXN0PERlZmF1bHRBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjw/IGV4dGVuZHMgQXR0cmlidXRlTWFwcGluZz4+IHByb3ZpZGVycykgewotCQkvL25vbmUgc3BlY2lmaWMgdG8gRWNsaXBzZUxpbmsgMS4xCi0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGxhdGZvcm0vRWNsaXBzZUxpbmtKcGFQbGF0Zm9ybVVpLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wbGF0Zm9ybS9FY2xpcHNlTGlua0pwYVBsYXRmb3JtVWkuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNWNlYWE5ZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wbGF0Zm9ybS9FY2xpcHNlTGlua0pwYVBsYXRmb3JtVWkuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDgsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wbGF0Zm9ybTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuSVN0cnVjdHVyZWRTZWxlY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuSnBhUHJvamVjdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuZGRsZ2VuLkVjbGlwc2VMaW5rRERMR2VuZXJhdG9yVWk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVBsYXRmb3JtVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuSnBhVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5wbGF0Zm9ybS5iYXNlLkJhc2VKcGFQbGF0Zm9ybVVpOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5uYXZpZ2F0b3IuSnBhTmF2aWdhdG9yUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLnN0cnVjdHVyZS5KcGFTdHJ1Y3R1cmVQcm92aWRlcjsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rSnBhUGxhdGZvcm1VaQotCWV4dGVuZHMgQmFzZUpwYVBsYXRmb3JtVWkKLXsKLQlwdWJsaWMgRWNsaXBzZUxpbmtKcGFQbGF0Zm9ybVVpKAotCQlKcGFVaUZhY3RvcnkganBhVWlGYWN0b3J5LAotCQlKcGFOYXZpZ2F0b3JQcm92aWRlciBuYXZpZ2F0b3JQcm92aWRlciwKLQkJSnBhU3RydWN0dXJlUHJvdmlkZXIgcGVyc2lzdGVuY2VTdHJ1Y3R1cmVQcm92aWRlciwgCi0JCUpwYVN0cnVjdHVyZVByb3ZpZGVyIGphdmFTdHJ1Y3R1cmVQcm92aWRlciwKLQkJSnBhUGxhdGZvcm1VaVByb3ZpZGVyLi4uIHBsYXRmb3JtVWlQcm92aWRlcnMpIAotCXsKLQkJc3VwZXIoanBhVWlGYWN0b3J5LCBuYXZpZ2F0b3JQcm92aWRlciwgcGVyc2lzdGVuY2VTdHJ1Y3R1cmVQcm92aWRlciwgamF2YVN0cnVjdHVyZVByb3ZpZGVyLCBwbGF0Zm9ybVVpUHJvdmlkZXJzKTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIERETCBnZW5lcmF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIGdlbmVyYXRlRERMKEpwYVByb2plY3QgcHJvamVjdCwgSVN0cnVjdHVyZWRTZWxlY3Rpb24gc2VsZWN0aW9uKSB7Ci0JCUVjbGlwc2VMaW5rRERMR2VuZXJhdG9yVWkuZ2VuZXJhdGUocHJvamVjdCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wbGF0Zm9ybS9FY2xpcHNlTGlua0pwYVBsYXRmb3JtVWlGYWN0b3J5LmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wbGF0Zm9ybS9FY2xpcHNlTGlua0pwYVBsYXRmb3JtVWlGYWN0b3J5LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDExNzA5NzIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGxhdGZvcm0vRWNsaXBzZUxpbmtKcGFQbGF0Zm9ybVVpRmFjdG9yeS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wbGF0Zm9ybTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua0pwYVVpRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuc3RydWN0dXJlLkVjbGlwc2VMaW5rUGVyc2lzdGVuY2VSZXNvdXJjZU1vZGVsU3RydWN0dXJlUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVBsYXRmb3JtVWk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVBsYXRmb3JtVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5HZW5lcmljSnBhUGxhdGZvcm1VaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5zdHJ1Y3R1cmUuSmF2YVJlc291cmNlTW9kZWxTdHJ1Y3R1cmVQcm92aWRlcjsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rSnBhUGxhdGZvcm1VaUZhY3RvcnkgaW1wbGVtZW50cyBKcGFQbGF0Zm9ybVVpRmFjdG9yeQotewotCi0JLyoqCi0JICogWmVybyBhcmcgY29uc3RydWN0b3IgZm9yIGV4dGVuc2lvbiBwb2ludAotCSAqLwotCXB1YmxpYyBFY2xpcHNlTGlua0pwYVBsYXRmb3JtVWlGYWN0b3J5KCkgewotCQlzdXBlcigpOwotCX0KLQotCXB1YmxpYyBKcGFQbGF0Zm9ybVVpIGJ1aWxkSnBhUGxhdGZvcm1VaSgpIHsKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGlua0pwYVBsYXRmb3JtVWkoCi0JCQluZXcgRWNsaXBzZUxpbmtKcGFVaUZhY3RvcnkoKSwKLQkJCW5ldyBFY2xpcHNlTGlua05hdmlnYXRvclByb3ZpZGVyKCksCi0JCQlKYXZhUmVzb3VyY2VNb2RlbFN0cnVjdHVyZVByb3ZpZGVyLmluc3RhbmNlKCksIAotCQkJRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVJlc291cmNlTW9kZWxTdHJ1Y3R1cmVQcm92aWRlci5pbnN0YW5jZSgpLAotCQkJR2VuZXJpY0pwYVBsYXRmb3JtVWlQcm92aWRlci5pbnN0YW5jZSgpLAotCQkJRWNsaXBzZUxpbmtKcGFQbGF0Zm9ybVVpUHJvdmlkZXIuaW5zdGFuY2UoKQotCQkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BsYXRmb3JtL0VjbGlwc2VMaW5rSnBhUGxhdGZvcm1VaVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9wbGF0Zm9ybS9FY2xpcHNlTGlua0pwYVBsYXRmb3JtVWlQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwYmFlMWMzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BsYXRmb3JtL0VjbGlwc2VMaW5rSnBhUGxhdGZvcm1VaVByb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMzIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwucGxhdGZvcm07Ci0KLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LkF0dHJpYnV0ZU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLmphdmEuZGV0YWlscy5EZWZhdWx0T25lVG9NYW55TWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLmphdmEuZGV0YWlscy5EZWZhdWx0T25lVG9PbmVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuamF2YS5kZXRhaWxzLkRlZmF1bHRWYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLmphdmEuZGV0YWlscy5FY2xpcHNlTGlua0phdmFCYXNpY0NvbGxlY3Rpb25NYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuamF2YS5kZXRhaWxzLkVjbGlwc2VMaW5rSmF2YUJhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLmphdmEuZGV0YWlscy5FY2xpcHNlTGlua0phdmFUcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5qYXZhLmRldGFpbHMuRWNsaXBzZUxpbmtKYXZhVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGlua0VudGl0eU1hcHBpbmdzRGV0YWlsc1Byb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGlua09ybUJhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGlua09ybUJhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzLkVjbGlwc2VMaW5rT3JtQmFzaWNNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuRWNsaXBzZUxpbmtPcm1FbWJlZGRhYmxlVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuRWNsaXBzZUxpbmtPcm1FbWJlZGRlZElkTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzLkVjbGlwc2VMaW5rT3JtRW1iZWRkZWRNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuRWNsaXBzZUxpbmtPcm1FbnRpdHlVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGlua09ybUlkTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzLkVjbGlwc2VMaW5rT3JtTWFueVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGlua09ybU1hbnlUb09uZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGlua09ybU1hcHBlZFN1cGVyY2xhc3NVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGlua09ybU9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5vcm0uZGV0YWlscy5FY2xpcHNlTGlua09ybU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzLkVjbGlwc2VMaW5rT3JtVHJhbnNmb3JtYXRpb25NYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuRWNsaXBzZUxpbmtPcm1UcmFuc2llbnRNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwub3JtLmRldGFpbHMuRWNsaXBzZUxpbmtPcm1WYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLm9ybS5kZXRhaWxzLkVjbGlwc2VMaW5rT3JtVmVyc2lvbk1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5zdHJ1Y3R1cmUuRWNsaXBzZUxpbmtPcm1SZXNvdXJjZU1vZGVsU3RydWN0dXJlUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVBsYXRmb3JtVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5BdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5EZWZhdWx0QXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuRGVmYXVsdFR5cGVNYXBwaW5nVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuZGV0YWlscy5KcGFEZXRhaWxzUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmRldGFpbHMuVHlwZU1hcHBpbmdVaVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5BYnN0cmFjdEpwYVBsYXRmb3JtVWlQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuc3RydWN0dXJlLkpwYVN0cnVjdHVyZVByb3ZpZGVyOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtKcGFQbGF0Zm9ybVVpUHJvdmlkZXIgZXh0ZW5kcyBBYnN0cmFjdEpwYVBsYXRmb3JtVWlQcm92aWRlcgotewotCi0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgSnBhUGxhdGZvcm1VaVByb3ZpZGVyIElOU1RBTkNFID0gbmV3IEVjbGlwc2VMaW5rSnBhUGxhdGZvcm1VaVByb3ZpZGVyKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEpwYVBsYXRmb3JtVWlQcm92aWRlciBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGlua0pwYVBsYXRmb3JtVWlQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogZGV0YWlscyBwcm92aWRlcnMgKioqKioqKioqKgotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGFkZERldGFpbHNQcm92aWRlcnNUbyhMaXN0PEpwYURldGFpbHNQcm92aWRlcj4gcHJvdmlkZXJzKSB7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmtFbnRpdHlNYXBwaW5nc0RldGFpbHNQcm92aWRlci5pbnN0YW5jZSgpKTsKLQl9Ci0JCi0JCi0JLy8gKioqKioqKioqKiBzdHJ1Y3R1cmUgcHJvdmlkZXJzICoqKioqKioqKioKLQkKLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBhZGRNYXBwaW5nRmlsZVN0cnVjdHVyZVByb3ZpZGVyc1RvKExpc3Q8SnBhU3RydWN0dXJlUHJvdmlkZXI+IHByb3ZpZGVycykgewotCQlwcm92aWRlcnMuYWRkKEVjbGlwc2VMaW5rT3JtUmVzb3VyY2VNb2RlbFN0cnVjdHVyZVByb3ZpZGVyLmluc3RhbmNlKCkpOwotCX0KLQkKLQkKLQkvLyAqKioqKioqKioqIHR5cGUgbWFwcGluZyB1aSBwcm92aWRlcnMgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgYWRkVHlwZU1hcHBpbmdVaVByb3ZpZGVyc1RvKExpc3Q8VHlwZU1hcHBpbmdVaVByb3ZpZGVyPD8+PiBwcm92aWRlcnMpIHsKLQkJcHJvdmlkZXJzLmFkZChFY2xpcHNlTGlua09ybUVudGl0eVVpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmtPcm1NYXBwZWRTdXBlcmNsYXNzVWlQcm92aWRlci5pbnN0YW5jZSgpKTsKLQkJcHJvdmlkZXJzLmFkZChFY2xpcHNlTGlua09ybUVtYmVkZGFibGVVaVByb3ZpZGVyLmluc3RhbmNlKCkpOwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBhZGREZWZhdWx0VHlwZU1hcHBpbmdVaVByb3ZpZGVyc1RvKExpc3Q8RGVmYXVsdFR5cGVNYXBwaW5nVWlQcm92aWRlcjw/Pj4gcHJvdmlkZXJzKSB7Ci0JCS8vbm9uZSBzcGVjaWZpYyB0byBFY2xpcHNlTGluawotCX0KLQkKLQkKLQkvLyAqKioqKioqKioqIGF0dHJpYnV0ZSBtYXBwaW5nIHVpIHByb3ZpZGVycyAqKioqKioqKioqCi0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgYWRkQXR0cmlidXRlTWFwcGluZ1VpUHJvdmlkZXJzVG8oTGlzdDxBdHRyaWJ1dGVNYXBwaW5nVWlQcm92aWRlcjw/IGV4dGVuZHMgQXR0cmlidXRlTWFwcGluZz4+IHByb3ZpZGVycykgewotCQlwcm92aWRlcnMuYWRkKEVjbGlwc2VMaW5rSmF2YUJhc2ljQ29sbGVjdGlvbk1hcHBpbmdVaVByb3ZpZGVyLmluc3RhbmNlKCkpOwotCQlwcm92aWRlcnMuYWRkKEVjbGlwc2VMaW5rSmF2YUJhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmtKYXZhVmFyaWFibGVPbmVUb09uZU1hcHBpbmdVaVByb3ZpZGVyLmluc3RhbmNlKCkpOwotCQlwcm92aWRlcnMuYWRkKEVjbGlwc2VMaW5rSmF2YVRyYW5zZm9ybWF0aW9uTWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCQotCQlwcm92aWRlcnMuYWRkKEVjbGlwc2VMaW5rT3JtSWRNYXBwaW5nVWlQcm92aWRlci5pbnN0YW5jZSgpKTsKLQkJcHJvdmlkZXJzLmFkZChFY2xpcHNlTGlua09ybUVtYmVkZGVkSWRNYXBwaW5nVWlQcm92aWRlci5pbnN0YW5jZSgpKTsKLQkJcHJvdmlkZXJzLmFkZChFY2xpcHNlTGlua09ybUJhc2ljTWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmtPcm1CYXNpY0NvbGxlY3Rpb25NYXBwaW5nVWlQcm92aWRlci5pbnN0YW5jZSgpKTsKLQkJcHJvdmlkZXJzLmFkZChFY2xpcHNlTGlua09ybUJhc2ljTWFwTWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmtPcm1WZXJzaW9uTWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmtPcm1NYW55VG9PbmVNYXBwaW5nVWlQcm92aWRlci5pbnN0YW5jZSgpKTsKLQkJcHJvdmlkZXJzLmFkZChFY2xpcHNlTGlua09ybU9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyLmluc3RhbmNlKCkpOwotCQlwcm92aWRlcnMuYWRkKEVjbGlwc2VMaW5rT3JtRW1iZWRkZWRNYXBwaW5nVWlQcm92aWRlci5pbnN0YW5jZSgpKTsKLQkJcHJvdmlkZXJzLmFkZChFY2xpcHNlTGlua09ybU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmtPcm1WYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmtPcm1NYW55VG9NYW55TWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRWNsaXBzZUxpbmtPcm1UcmFuc2Zvcm1hdGlvbk1hcHBpbmdVaVByb3ZpZGVyLmluc3RhbmNlKCkpOwotCQlwcm92aWRlcnMuYWRkKEVjbGlwc2VMaW5rT3JtVHJhbnNpZW50TWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgYWRkRGVmYXVsdEF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyc1RvKExpc3Q8RGVmYXVsdEF0dHJpYnV0ZU1hcHBpbmdVaVByb3ZpZGVyPD8gZXh0ZW5kcyBBdHRyaWJ1dGVNYXBwaW5nPj4gcHJvdmlkZXJzKSB7Ci0JCXByb3ZpZGVycy5hZGQoRGVmYXVsdE9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JCXByb3ZpZGVycy5hZGQoRGVmYXVsdE9uZVRvTWFueU1hcHBpbmdVaVByb3ZpZGVyLmluc3RhbmNlKCkpOwotCQlwcm92aWRlcnMuYWRkKERlZmF1bHRWYXJpYWJsZU9uZVRvT25lTWFwcGluZ1VpUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGxhdGZvcm0vRWNsaXBzZUxpbmtOYXZpZ2F0b3JQcm92aWRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvcGxhdGZvcm0vRWNsaXBzZUxpbmtOYXZpZ2F0b3JQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmOGU1YzRiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3BsYXRmb3JtL0VjbGlwc2VMaW5rTmF2aWdhdG9yUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDM0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wbGF0Zm9ybTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5wZXJzaXN0ZW5jZXhtbC5kZXRhaWxzLkVjbGlwc2VMaW5rTmF2aWdhdG9ySXRlbUNvbnRlbnRQcm92aWRlckZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnBlcnNpc3RlbmNleG1sLmRldGFpbHMuRWNsaXBzZUxpbmtOYXZpZ2F0b3JJdGVtTGFiZWxQcm92aWRlckZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmpmYWNlLkl0ZW1MYWJlbFByb3ZpZGVyRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuamZhY2UuVHJlZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5uYXZpZ2F0b3IuSnBhTmF2aWdhdG9yUHJvdmlkZXI7Ci0KLS8qKgotICogRWNsaXBzZUxpbmtOYXZpZ2F0b3JQcm92aWRlcgotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtOYXZpZ2F0b3JQcm92aWRlciBpbXBsZW1lbnRzIEpwYU5hdmlnYXRvclByb3ZpZGVyCi17Ci0JcHVibGljIEl0ZW1MYWJlbFByb3ZpZGVyRmFjdG9yeSBnZXRJdGVtTGFiZWxQcm92aWRlckZhY3RvcnkoKSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmtOYXZpZ2F0b3JJdGVtTGFiZWxQcm92aWRlckZhY3RvcnkoKTsKLQl9Ci0KLQlwdWJsaWMgVHJlZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5IGdldFRyZWVJdGVtQ29udGVudFByb3ZpZGVyRmFjdG9yeSgpIHsKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGlua05hdmlnYXRvckl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5KCk7Ci0JfQotCi0JcHVibGljIHZvaWQgZGlzcG9zZSgpIHsKLQkKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9zdHJ1Y3R1cmUvRWNsaXBzZUxpbmsxXzFPcm1SZXNvdXJjZU1vZGVsU3RydWN0dXJlUHJvdmlkZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3N0cnVjdHVyZS9FY2xpcHNlTGluazFfMU9ybVJlc291cmNlTW9kZWxTdHJ1Y3R1cmVQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjNjcyMzQ2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3N0cnVjdHVyZS9FY2xpcHNlTGluazFfMU9ybVJlc291cmNlTW9kZWxTdHJ1Y3R1cmVQcm92aWRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5zdHJ1Y3R1cmU7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuY29udGVudC5JQ29udGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwuSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5zdHJ1Y3R1cmUuT3JtSXRlbUNvbnRlbnRQcm92aWRlckZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnN0cnVjdHVyZS5Pcm1JdGVtTGFiZWxQcm92aWRlckZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmpmYWNlLkl0ZW1MYWJlbFByb3ZpZGVyRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuamZhY2UuVHJlZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5zdHJ1Y3R1cmUuSnBhU3RydWN0dXJlUHJvdmlkZXI7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU9ybVJlc291cmNlTW9kZWxTdHJ1Y3R1cmVQcm92aWRlcgotCWltcGxlbWVudHMgSnBhU3RydWN0dXJlUHJvdmlkZXIKLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBKcGFTdHJ1Y3R1cmVQcm92aWRlciBJTlNUQU5DRSA9IG5ldyBFY2xpcHNlTGluazFfMU9ybVJlc291cmNlTW9kZWxTdHJ1Y3R1cmVQcm92aWRlcigpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaW5nbGV0b24uCi0JICovCi0JcHVibGljIHN0YXRpYyBKcGFTdHJ1Y3R1cmVQcm92aWRlciBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFY2xpcHNlTGluazFfMU9ybVJlc291cmNlTW9kZWxTdHJ1Y3R1cmVQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JcHVibGljIElDb250ZW50VHlwZSBnZXRDb250ZW50VHlwZSgpIHsKLQkJcmV0dXJuIEpwdEVjbGlwc2VMaW5rQ29yZVBsdWdpbi5FQ0xJUFNFTElOSzFfMV9PUk1fWE1MX0NPTlRFTlRfVFlQRTsKLQl9Ci0KLQlwdWJsaWMgVHJlZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5IGdldFRyZWVJdGVtQ29udGVudFByb3ZpZGVyRmFjdG9yeSgpIHsKLQkJcmV0dXJuIG5ldyBPcm1JdGVtQ29udGVudFByb3ZpZGVyRmFjdG9yeSgpOwotCX0KLQkKLQlwdWJsaWMgSXRlbUxhYmVsUHJvdmlkZXJGYWN0b3J5IGdldEl0ZW1MYWJlbFByb3ZpZGVyRmFjdG9yeSgpIHsKLQkJcmV0dXJuIG5ldyBPcm1JdGVtTGFiZWxQcm92aWRlckZhY3RvcnkoKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3N0cnVjdHVyZS9FY2xpcHNlTGlua09ybVJlc291cmNlTW9kZWxTdHJ1Y3R1cmVQcm92aWRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvc3RydWN0dXJlL0VjbGlwc2VMaW5rT3JtUmVzb3VyY2VNb2RlbFN0cnVjdHVyZVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDY1NmJhOGMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvc3RydWN0dXJlL0VjbGlwc2VMaW5rT3JtUmVzb3VyY2VNb2RlbFN0cnVjdHVyZVByb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnN0cnVjdHVyZTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsuY29yZS5pbnRlcm5hbC5KcHRFY2xpcHNlTGlua0NvcmVQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnN0cnVjdHVyZS5Pcm1JdGVtQ29udGVudFByb3ZpZGVyRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuc3RydWN0dXJlLk9ybUl0ZW1MYWJlbFByb3ZpZGVyRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuamZhY2UuSXRlbUxhYmVsUHJvdmlkZXJGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5qZmFjZS5UcmVlSXRlbUNvbnRlbnRQcm92aWRlckZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLnN0cnVjdHVyZS5KcGFTdHJ1Y3R1cmVQcm92aWRlcjsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rT3JtUmVzb3VyY2VNb2RlbFN0cnVjdHVyZVByb3ZpZGVyCi0JaW1wbGVtZW50cyBKcGFTdHJ1Y3R1cmVQcm92aWRlcgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEpwYVN0cnVjdHVyZVByb3ZpZGVyIElOU1RBTkNFID0gbmV3IEVjbGlwc2VMaW5rT3JtUmVzb3VyY2VNb2RlbFN0cnVjdHVyZVByb3ZpZGVyKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEpwYVN0cnVjdHVyZVByb3ZpZGVyIGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEVjbGlwc2VMaW5rT3JtUmVzb3VyY2VNb2RlbFN0cnVjdHVyZVByb3ZpZGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlwdWJsaWMgSUNvbnRlbnRUeXBlIGdldENvbnRlbnRUeXBlKCkgewotCQlyZXR1cm4gSnB0RWNsaXBzZUxpbmtDb3JlUGx1Z2luLkVDTElQU0VMSU5LX09STV9YTUxfQ09OVEVOVF9UWVBFOwotCX0KLQotCXB1YmxpYyBUcmVlSXRlbUNvbnRlbnRQcm92aWRlckZhY3RvcnkgZ2V0VHJlZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5KCkgewotCQlyZXR1cm4gbmV3IE9ybUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5KCk7Ci0JfQotCQotCXB1YmxpYyBJdGVtTGFiZWxQcm92aWRlckZhY3RvcnkgZ2V0SXRlbUxhYmVsUHJvdmlkZXJGYWN0b3J5KCkgewotCQlyZXR1cm4gbmV3IE9ybUl0ZW1MYWJlbFByb3ZpZGVyRmFjdG9yeSgpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvc3RydWN0dXJlL0VjbGlwc2VMaW5rUGVyc2lzdGVuY2VJdGVtQ29udGVudFByb3ZpZGVyRmFjdG9yeS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvc3RydWN0dXJlL0VjbGlwc2VMaW5rUGVyc2lzdGVuY2VJdGVtQ29udGVudFByb3ZpZGVyRmFjdG9yeS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyZTg5ZjdmLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3N0cnVjdHVyZS9FY2xpcHNlTGlua1BlcnNpc3RlbmNlSXRlbUNvbnRlbnRQcm92aWRlckZhY3RvcnkuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEzNyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuc3RydWN0dXJlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLkpwYVN0cnVjdHVyZU5vZGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5wZXJzaXN0ZW5jZS5DbGFzc1JlZjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LnBlcnNpc3RlbmNlLk1hcHBpbmdGaWxlUmVmOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQucGVyc2lzdGVuY2UuUGVyc2lzdGVuY2VVbml0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLmNvbnRleHQucGVyc2lzdGVuY2UuRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLmpmYWNlLkRlbGVnYXRpbmdUcmVlQ29udGVudEFuZExhYmVsUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnN0cnVjdHVyZS5QZXJzaXN0ZW5jZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5qZmFjZS5EZWxlZ2F0aW5nQ29udGVudEFuZExhYmVsUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmpmYWNlLlRyZWVJdGVtQ29udGVudFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25Bc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkNvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkxpc3RBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkxpc3RDb2xsZWN0aW9uVmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5Ci0JZXh0ZW5kcyBQZXJzaXN0ZW5jZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5Ci17Ci0JQE92ZXJyaWRlCi0JcHVibGljIFRyZWVJdGVtQ29udGVudFByb3ZpZGVyIGJ1aWxkSXRlbUNvbnRlbnRQcm92aWRlcigKLQkJCU9iamVjdCBpdGVtLCBEZWxlZ2F0aW5nQ29udGVudEFuZExhYmVsUHJvdmlkZXIgY29udGVudEFuZExhYmVsUHJvdmlkZXIpIHsKLQkJRGVsZWdhdGluZ1RyZWVDb250ZW50QW5kTGFiZWxQcm92aWRlciB0cmVlQ29udGVudFByb3ZpZGVyID0gKERlbGVnYXRpbmdUcmVlQ29udGVudEFuZExhYmVsUHJvdmlkZXIpIGNvbnRlbnRBbmRMYWJlbFByb3ZpZGVyOwotCQlpZiAoaXRlbSBpbnN0YW5jZW9mIEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0KSB7Ci0JCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0SXRlbUNvbnRlbnRQcm92aWRlcigoRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQpIGl0ZW0sIHRyZWVDb250ZW50UHJvdmlkZXIpOwkKLQkJfQotCQlyZXR1cm4gc3VwZXIuYnVpbGRJdGVtQ29udGVudFByb3ZpZGVyKGl0ZW0sIGNvbnRlbnRBbmRMYWJlbFByb3ZpZGVyKTsKLQl9Ci0JCi0JCi0JcHVibGljIHN0YXRpYyBjbGFzcyBFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdEl0ZW1Db250ZW50UHJvdmlkZXIgCi0JCWV4dGVuZHMgUGVyc2lzdGVuY2VVbml0SXRlbUNvbnRlbnRQcm92aWRlcgotCXsKLQkJcHVibGljIEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0SXRlbUNvbnRlbnRQcm92aWRlcigKLQkJCQlFY2xpcHNlTGlua1BlcnNpc3RlbmNlVW5pdCBwZXJzaXN0ZW5jZVVuaXQsIERlbGVnYXRpbmdUcmVlQ29udGVudEFuZExhYmVsUHJvdmlkZXIgY29udGVudFByb3ZpZGVyKSB7Ci0JCQlzdXBlcihwZXJzaXN0ZW5jZVVuaXQsIGNvbnRlbnRQcm92aWRlcik7Ci0JCX0KLQkJCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQgZ2V0TW9kZWwoKSB7Ci0JCQlyZXR1cm4gKEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0KSBzdXBlci5nZXRNb2RlbCgpOwotCQl9Ci0JCQotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIENvbGxlY3Rpb25WYWx1ZU1vZGVsPEpwYVN0cnVjdHVyZU5vZGU+IGJ1aWxkQ2hpbGRyZW5Nb2RlbCgpIHsKLQkJCUNvbGxlY3Rpb25WYWx1ZU1vZGVsPE1hcHBpbmdGaWxlUmVmPiBzcGVjaWZpZWRNYXBwaW5nRmlsZUN2bSA9IAotCQkJCW5ldyBMaXN0Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyPE1hcHBpbmdGaWxlUmVmPigKLQkJCQluZXcgTGlzdEFzcGVjdEFkYXB0ZXI8UGVyc2lzdGVuY2VVbml0LCBNYXBwaW5nRmlsZVJlZj4oCi0JCQkJCQlQZXJzaXN0ZW5jZVVuaXQuU1BFQ0lGSUVEX01BUFBJTkdfRklMRV9SRUZTX0xJU1QsCi0JCQkJCQlnZXRNb2RlbCgpKSB7Ci0JCQkJCUBPdmVycmlkZQotCQkJCQlwcm90ZWN0ZWQgTGlzdEl0ZXJhdG9yPE1hcHBpbmdGaWxlUmVmPiBsaXN0SXRlcmF0b3JfKCkgewotCQkJCQkJcmV0dXJuIHN1YmplY3Quc3BlY2lmaWVkTWFwcGluZ0ZpbGVSZWZzKCk7Ci0JCQkJCX0KLQkJCQkJQE92ZXJyaWRlCi0JCQkJCXByb3RlY3RlZCBpbnQgc2l6ZV8oKSB7Ci0JCQkJCQlyZXR1cm4gc3ViamVjdC5zcGVjaWZpZWRNYXBwaW5nRmlsZVJlZnNTaXplKCk7Ci0JCQkJCX0KLQkJCQl9KTsKLQkJCQotCQkJQ29sbGVjdGlvblZhbHVlTW9kZWw8TWFwcGluZ0ZpbGVSZWY+IGltcGxpZWRNYXBwaW5nRmlsZUN2bSA9IAotCQkJCW5ldyBQcm9wZXJ0eUNvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlcjxNYXBwaW5nRmlsZVJlZj4oCi0JCQkJCW5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8UGVyc2lzdGVuY2VVbml0LCBNYXBwaW5nRmlsZVJlZj4oCi0JCQkJCQkJUGVyc2lzdGVuY2VVbml0LklNUExJRURfTUFQUElOR19GSUxFX1JFRl9QUk9QRVJUWSwKLQkJCQkJCQlnZXRNb2RlbCgpKSB7Ci0JCQkJCQlAT3ZlcnJpZGUKLQkJCQkJCXByb3RlY3RlZCBNYXBwaW5nRmlsZVJlZiBidWlsZFZhbHVlXygpIHsKLQkJCQkJCQlyZXR1cm4gc3ViamVjdC5nZXRJbXBsaWVkTWFwcGluZ0ZpbGVSZWYoKTsKLQkJCQkJCX0KLQkJCQkJfQotCQkJCSk7Ci0JCQlDb2xsZWN0aW9uVmFsdWVNb2RlbDxNYXBwaW5nRmlsZVJlZj4gaW1wbGllZEVjbGlwc2VMaW5rTWFwcGluZ0ZpbGVDdm0gPSAKLQkJCQluZXcgUHJvcGVydHlDb2xsZWN0aW9uVmFsdWVNb2RlbEFkYXB0ZXI8TWFwcGluZ0ZpbGVSZWY+KAotCQkJCQluZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VVbml0LCBNYXBwaW5nRmlsZVJlZj4oCi0JCQkJCQkJRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVVuaXQuSU1QTElFRF9FQ0xJUFNFTElOS19NQVBQSU5HX0ZJTEVfUkVGX1BST1BFUlRZLAotCQkJCQkJCWdldE1vZGVsKCkpIHsKLQkJCQkJCUBPdmVycmlkZQotCQkJCQkJcHJvdGVjdGVkIE1hcHBpbmdGaWxlUmVmIGJ1aWxkVmFsdWVfKCkgewotCQkJCQkJCXJldHVybiBzdWJqZWN0LmdldEltcGxpZWRFY2xpcHNlTGlua01hcHBpbmdGaWxlUmVmKCk7Ci0JCQkJCQl9Ci0JCQkJCX0KLQkJCQkpOwotCQkJQ29sbGVjdGlvblZhbHVlTW9kZWw8Q2xhc3NSZWY+IHNwZWNpZmllZENsYXNzQ3ZtID0gCi0JCQkJbmV3IExpc3RDb2xsZWN0aW9uVmFsdWVNb2RlbEFkYXB0ZXI8Q2xhc3NSZWY+KAotCQkJCW5ldyBMaXN0QXNwZWN0QWRhcHRlcjxQZXJzaXN0ZW5jZVVuaXQsIENsYXNzUmVmPigKLQkJCQkJCVBlcnNpc3RlbmNlVW5pdC5TUEVDSUZJRURfQ0xBU1NfUkVGU19MSVNULAotCQkJCQkJZ2V0TW9kZWwoKSkgewotCQkJCQlAT3ZlcnJpZGUKLQkJCQkJcHJvdGVjdGVkIExpc3RJdGVyYXRvcjxDbGFzc1JlZj4gbGlzdEl0ZXJhdG9yXygpIHsKLQkJCQkJCXJldHVybiBzdWJqZWN0LnNwZWNpZmllZENsYXNzUmVmcygpOwotCQkJCQl9Ci0JCQkJCUBPdmVycmlkZQotCQkJCQlwcm90ZWN0ZWQgaW50IHNpemVfKCkgewotCQkJCQkJcmV0dXJuIHN1YmplY3Quc3BlY2lmaWVkQ2xhc3NSZWZzU2l6ZSgpOwotCQkJCQl9Ci0JCQkJfSk7Ci0JCQlDb2xsZWN0aW9uVmFsdWVNb2RlbDxDbGFzc1JlZj4gaW1wbGllZENsYXNzQ3ZtID0gCi0JCQkJbmV3IENvbGxlY3Rpb25Bc3BlY3RBZGFwdGVyPFBlcnNpc3RlbmNlVW5pdCwgQ2xhc3NSZWY+KAotCQkJCQkJUGVyc2lzdGVuY2VVbml0LklNUExJRURfQ0xBU1NfUkVGU19DT0xMRUNUSU9OLAotCQkJCQkJZ2V0TW9kZWwoKSkgewotCQkJCQlAT3ZlcnJpZGUKLQkJCQkJcHJvdGVjdGVkIEl0ZXJhdG9yPENsYXNzUmVmPiBpdGVyYXRvcl8oKSB7Ci0JCQkJCQlyZXR1cm4gc3ViamVjdC5pbXBsaWVkQ2xhc3NSZWZzKCk7Ci0JCQkJCX0KLQkJCQkJQE92ZXJyaWRlCi0JCQkJCXByb3RlY3RlZCBpbnQgc2l6ZV8oKSB7Ci0JCQkJCQlyZXR1cm4gc3ViamVjdC5pbXBsaWVkQ2xhc3NSZWZzU2l6ZSgpOwotCQkJCQl9Ci0JCQkJfTsKLQkJCUxpc3Q8Q29sbGVjdGlvblZhbHVlTW9kZWw8PyBleHRlbmRzIEpwYVN0cnVjdHVyZU5vZGU+PiBsaXN0ID0gbmV3IEFycmF5TGlzdDxDb2xsZWN0aW9uVmFsdWVNb2RlbDw/IGV4dGVuZHMgSnBhU3RydWN0dXJlTm9kZT4+KDQpOwotCQkJbGlzdC5hZGQoc3BlY2lmaWVkTWFwcGluZ0ZpbGVDdm0pOwotCQkJbGlzdC5hZGQoaW1wbGllZE1hcHBpbmdGaWxlQ3ZtKTsKLQkJCWxpc3QuYWRkKGltcGxpZWRFY2xpcHNlTGlua01hcHBpbmdGaWxlQ3ZtKTsKLQkJCWxpc3QuYWRkKHNwZWNpZmllZENsYXNzQ3ZtKTsKLQkJCWxpc3QuYWRkKGltcGxpZWRDbGFzc0N2bSk7Ci0JCQkKLQkJCXJldHVybiBuZXcgQ29tcG9zaXRlQ29sbGVjdGlvblZhbHVlTW9kZWw8Q29sbGVjdGlvblZhbHVlTW9kZWw8PyBleHRlbmRzIEpwYVN0cnVjdHVyZU5vZGU+LCBKcGFTdHJ1Y3R1cmVOb2RlPihsaXN0KTsKLQkJfQotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3N0cnVjdHVyZS9FY2xpcHNlTGlua1BlcnNpc3RlbmNlUmVzb3VyY2VNb2RlbFN0cnVjdHVyZVByb3ZpZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC9zdHJ1Y3R1cmUvRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVJlc291cmNlTW9kZWxTdHJ1Y3R1cmVQcm92aWRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1NTAyZDI2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3N0cnVjdHVyZS9FY2xpcHNlTGlua1BlcnNpc3RlbmNlUmVzb3VyY2VNb2RlbFN0cnVjdHVyZVByb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1MSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLnN0cnVjdHVyZTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5jb250ZW50LklDb250ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcHRDb3JlUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5zdHJ1Y3R1cmUuUGVyc2lzdGVuY2VJdGVtTGFiZWxQcm92aWRlckZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmpmYWNlLkl0ZW1MYWJlbFByb3ZpZGVyRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuamZhY2UuVHJlZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5zdHJ1Y3R1cmUuSnBhU3RydWN0dXJlUHJvdmlkZXI7Ci0KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGlua1BlcnNpc3RlbmNlUmVzb3VyY2VNb2RlbFN0cnVjdHVyZVByb3ZpZGVyCi0JaW1wbGVtZW50cyBKcGFTdHJ1Y3R1cmVQcm92aWRlcgotewotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEpwYVN0cnVjdHVyZVByb3ZpZGVyIElOU1RBTkNFID0gbmV3IEVjbGlwc2VMaW5rUGVyc2lzdGVuY2VSZXNvdXJjZU1vZGVsU3RydWN0dXJlUHJvdmlkZXIoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgSnBhU3RydWN0dXJlUHJvdmlkZXIgaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0KLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRWNsaXBzZUxpbmtQZXJzaXN0ZW5jZVJlc291cmNlTW9kZWxTdHJ1Y3R1cmVQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JcHVibGljIElDb250ZW50VHlwZSBnZXRDb250ZW50VHlwZSgpIHsKLQkJcmV0dXJuIEpwdENvcmVQbHVnaW4uUEVSU0lTVEVOQ0VfWE1MX0NPTlRFTlRfVFlQRTsKLQl9Ci0KLQlwdWJsaWMgVHJlZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5IGdldFRyZWVJdGVtQ29udGVudFByb3ZpZGVyRmFjdG9yeSgpIHsKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGlua1BlcnNpc3RlbmNlSXRlbUNvbnRlbnRQcm92aWRlckZhY3RvcnkoKTsKLQl9Ci0KLQlwdWJsaWMgSXRlbUxhYmVsUHJvdmlkZXJGYWN0b3J5IGdldEl0ZW1MYWJlbFByb3ZpZGVyRmFjdG9yeSgpIHsKLQkJcmV0dXJuIG5ldyBQZXJzaXN0ZW5jZUl0ZW1MYWJlbFByb3ZpZGVyRmFjdG9yeSgpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvd2l6YXJkcy9FY2xpcHNlTGluazFfMU1hcHBpbmdGaWxlV2l6YXJkLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC93aXphcmRzL0VjbGlwc2VMaW5rMV8xTWFwcGluZ0ZpbGVXaXphcmQuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjNiNTE1ZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC93aXphcmRzL0VjbGlwc2VMaW5rMV8xTWFwcGluZ0ZpbGVXaXphcmQuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQ2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiAgQ29weXJpZ2h0IChjKSAyMDA5ICBPcmFjbGUuIAotICogIEFsbCByaWdodHMgcmVzZXJ2ZWQuICBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSAKLSAqICBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCAKLSAqICBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAKLSAqICBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotICogIAotICogIENvbnRyaWJ1dG9yczogCi0gKiAgCU9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC53aXphcmRzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLmNvcmUuaW50ZXJuYWwub3BlcmF0aW9ucy5FY2xpcHNlTGluazFfMU9ybUZpbGVDcmVhdGlvbkRhdGFNb2RlbFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS5pbnRlcm5hbC5FY2xpcHNlTGlua1VpTWVzc2FnZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLndpemFyZHMub3JtLk1hcHBpbmdGaWxlV2l6YXJkOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aXphcmRzLm9ybS5NYXBwaW5nRmlsZVdpemFyZFBhZ2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UudWkuSU5ld1dpemFyZDsKLWltcG9ydCBvcmcuZWNsaXBzZS53c3QuY29tbW9uLmZyYW1ld29ya3MuZGF0YW1vZGVsLklEYXRhTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uud3N0LmNvbW1vbi5mcmFtZXdvcmtzLmRhdGFtb2RlbC5JRGF0YU1vZGVsUHJvdmlkZXI7Ci0KLS8qKgotICogVGhpcyBpcyByZWZlcmVuY2VkIGluIHRoZSBwbHVnaW4ueG1sIGFzIGFuIG9yZy5lY2xpcHNlLnVpLm5ld1dpemFyZHMgZXh0ZW5zaW9uCi0gKi8KLXB1YmxpYyBjbGFzcyBFY2xpcHNlTGluazFfMU1hcHBpbmdGaWxlV2l6YXJkIGV4dGVuZHMgTWFwcGluZ0ZpbGVXaXphcmQgCi0JaW1wbGVtZW50cyBJTmV3V2l6YXJkIAotewotCXB1YmxpYyBFY2xpcHNlTGluazFfMU1hcHBpbmdGaWxlV2l6YXJkKCkgewotCQl0aGlzKG51bGwpOwotCX0KLQkKLQlwdWJsaWMgRWNsaXBzZUxpbmsxXzFNYXBwaW5nRmlsZVdpemFyZChJRGF0YU1vZGVsIGRhdGFNb2RlbCkgewotCQlzdXBlcihkYXRhTW9kZWwpOwotCQlzZXRXaW5kb3dUaXRsZShFY2xpcHNlTGlua1VpTWVzc2FnZXMuRWNsaXBzZUxpbmsxXzFNYXBwaW5nRmlsZVdpemFyZF90aXRsZSk7Ci0JfQotCQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBNYXBwaW5nRmlsZVdpemFyZFBhZ2UgYnVpbGRNYXBwaW5nRmlsZVdpemFyZFBhZ2UoKSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmtNYXBwaW5nRmlsZVdpemFyZFBhZ2UoZ2V0RGF0YU1vZGVsKCksICJQYWdlXzEiLCBFY2xpcHNlTGlua1VpTWVzc2FnZXMuRWNsaXBzZUxpbmsxXzFNYXBwaW5nRmlsZVdpemFyZFBhZ2VfdGl0bGUsIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5FY2xpcHNlTGluazFfMU1hcHBpbmdGaWxlV2l6YXJkUGFnZV9kZXNjKTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIElEYXRhTW9kZWxQcm92aWRlciBnZXREZWZhdWx0UHJvdmlkZXIoKSB7Ci0JCXJldHVybiBuZXcgRWNsaXBzZUxpbmsxXzFPcm1GaWxlQ3JlYXRpb25EYXRhTW9kZWxQcm92aWRlcigpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay51aS9zcmMvb3JnL2VjbGlwc2UvanB0L2VjbGlwc2VsaW5rL3VpL2ludGVybmFsL3dpemFyZHMvRWNsaXBzZUxpbmtNYXBwaW5nRmlsZVdpemFyZC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvd2l6YXJkcy9FY2xpcHNlTGlua01hcHBpbmdGaWxlV2l6YXJkLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGNlOWUxMTcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvd2l6YXJkcy9FY2xpcHNlTGlua01hcHBpbmdGaWxlV2l6YXJkLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogIENvcHlyaWdodCAoYykgMjAwOCAgT3JhY2xlLiAKLSAqICBBbGwgcmlnaHRzIHJlc2VydmVkLiAgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgCi0gKiAgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgd2hpY2ggCi0gKiAgYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgCi0gKiAgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSAqICAKLSAqICBDb250cmlidXRvcnM6IAotICogIAlPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwud2l6YXJkczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5lY2xpcHNlbGluay5jb3JlLmludGVybmFsLm9wZXJhdGlvbnMuRWNsaXBzZUxpbmtPcm1GaWxlQ3JlYXRpb25EYXRhTW9kZWxQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkuaW50ZXJuYWwuRWNsaXBzZUxpbmtVaU1lc3NhZ2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC53aXphcmRzLm9ybS5NYXBwaW5nRmlsZVdpemFyZDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2l6YXJkcy5vcm0uTWFwcGluZ0ZpbGVXaXphcmRQYWdlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnVpLklOZXdXaXphcmQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uud3N0LmNvbW1vbi5mcmFtZXdvcmtzLmRhdGFtb2RlbC5JRGF0YU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLndzdC5jb21tb24uZnJhbWV3b3Jrcy5kYXRhbW9kZWwuSURhdGFNb2RlbFByb3ZpZGVyOwotCi0vKioKLSAqIFRoaXMgaXMgcmVmZXJlbmNlZCBpbiB0aGUgcGx1Z2luLnhtbCBhcyBhbiBvcmcuZWNsaXBzZS51aS5uZXdXaXphcmRzIGV4dGVuc2lvbgotICovCi1wdWJsaWMgY2xhc3MgRWNsaXBzZUxpbmtNYXBwaW5nRmlsZVdpemFyZCBleHRlbmRzIE1hcHBpbmdGaWxlV2l6YXJkIAotCWltcGxlbWVudHMgSU5ld1dpemFyZCAKLXsKLQlwdWJsaWMgRWNsaXBzZUxpbmtNYXBwaW5nRmlsZVdpemFyZCgpIHsKLQkJdGhpcyhudWxsKTsKLQl9Ci0JCi0JcHVibGljIEVjbGlwc2VMaW5rTWFwcGluZ0ZpbGVXaXphcmQoSURhdGFNb2RlbCBkYXRhTW9kZWwpIHsKLQkJc3VwZXIoZGF0YU1vZGVsKTsKLQkJc2V0V2luZG93VGl0bGUoRWNsaXBzZUxpbmtVaU1lc3NhZ2VzLk1hcHBpbmdGaWxlV2l6YXJkX3RpdGxlKTsKLQl9Ci0JCi0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIE1hcHBpbmdGaWxlV2l6YXJkUGFnZSBidWlsZE1hcHBpbmdGaWxlV2l6YXJkUGFnZSgpIHsKLQkJcmV0dXJuIG5ldyBFY2xpcHNlTGlua01hcHBpbmdGaWxlV2l6YXJkUGFnZShnZXREYXRhTW9kZWwoKSwgIlBhZ2VfMSIsIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5NYXBwaW5nRmlsZVdpemFyZFBhZ2VfdGl0bGUsIEVjbGlwc2VMaW5rVWlNZXNzYWdlcy5NYXBwaW5nRmlsZVdpemFyZFBhZ2VfZGVzYyk7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBJRGF0YU1vZGVsUHJvdmlkZXIgZ2V0RGVmYXVsdFByb3ZpZGVyKCkgewotCQlyZXR1cm4gbmV3IEVjbGlwc2VMaW5rT3JtRmlsZUNyZWF0aW9uRGF0YU1vZGVsUHJvdmlkZXIoKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC93aXphcmRzL0VjbGlwc2VMaW5rTWFwcGluZ0ZpbGVXaXphcmRQYWdlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZWNsaXBzZWxpbmsudWkvc3JjL29yZy9lY2xpcHNlL2pwdC9lY2xpcHNlbGluay91aS9pbnRlcm5hbC93aXphcmRzL0VjbGlwc2VMaW5rTWFwcGluZ0ZpbGVXaXphcmRQYWdlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDVmMTY4Y2QuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpL3NyYy9vcmcvZWNsaXBzZS9qcHQvZWNsaXBzZWxpbmsvdWkvaW50ZXJuYWwvd2l6YXJkcy9FY2xpcHNlTGlua01hcHBpbmdGaWxlV2l6YXJkUGFnZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICBDb3B5cmlnaHQgKGMpIDIwMDggIE9yYWNsZS4gCi0gKiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4gIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIAotICogIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIAotICogIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IAotICogIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0gKiAgCi0gKiAgQ29udHJpYnV0b3JzOiAKLSAqICAJT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmVjbGlwc2VsaW5rLnVpLmludGVybmFsLndpemFyZHM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2l6YXJkcy5vcm0uTWFwcGluZ0ZpbGVXaXphcmRQYWdlOwotaW1wb3J0IG9yZy5lY2xpcHNlLndzdC5jb21tb24uZnJhbWV3b3Jrcy5kYXRhbW9kZWwuSURhdGFNb2RlbDsKLQotcHVibGljIGNsYXNzIEVjbGlwc2VMaW5rTWFwcGluZ0ZpbGVXaXphcmRQYWdlIGV4dGVuZHMgTWFwcGluZ0ZpbGVXaXphcmRQYWdlCi17Ci0JcHVibGljIEVjbGlwc2VMaW5rTWFwcGluZ0ZpbGVXaXphcmRQYWdlKElEYXRhTW9kZWwgZGF0YU1vZGVsLCBTdHJpbmcgcGFnZU5hbWUsIFN0cmluZyB0aXRsZSwgU3RyaW5nIGRlc2MpIHsKLQkJc3VwZXIoZGF0YU1vZGVsLCBwYWdlTmFtZSk7Ci0JCXNldFRpdGxlKHRpdGxlKTsKLQkJc2V0RGVzY3JpcHRpb24oZGVzYyk7Ci0JCXNldFBhZ2VDb21wbGV0ZShmYWxzZSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi8uY2xhc3NwYXRoIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi8uY2xhc3NwYXRoCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3MzFiMDBmLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vLmNsYXNzcGF0aAorKysgL2Rldi9udWxsCkBAIC0xLDkgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxjbGFzc3BhdGg+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9InNyYyIgcGF0aD0ic3JjIi8+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9InNyYyIgcGF0aD0icHJvcGVydHlfZmlsZXMiLz4KLQk8Y2xhc3NwYXRoZW50cnkgZXhwb3J0ZWQ9InRydWUiIGtpbmQ9ImxpYiIgcGF0aD0ibGliL3ZlbG9jaXR5LTEuNS5qYXIiLz4KLQk8Y2xhc3NwYXRoZW50cnkga2luZD0iY29uIiBwYXRoPSJvcmcuZWNsaXBzZS5qZHQubGF1bmNoaW5nLkpSRV9DT05UQUlORVIvb3JnLmVjbGlwc2UuamR0LmludGVybmFsLmRlYnVnLnVpLmxhdW5jaGVyLlN0YW5kYXJkVk1UeXBlL0oyU0UtMS41Ii8+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9ImNvbiIgcGF0aD0ib3JnLmVjbGlwc2UucGRlLmNvcmUucmVxdWlyZWRQbHVnaW5zIi8+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9Im91dHB1dCIgcGF0aD0iYmluIi8+Ci08L2NsYXNzcGF0aD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vLmN2c2lnbm9yZSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vLmN2c2lnbm9yZQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYTE5NmRkNy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuLy5jdnNpZ25vcmUKKysrIC9kZXYvbnVsbApAQCAtMSw2ICswLDAgQEAKLWJpbgotQGRvdAotdGVtcC5mb2xkZXIKLWJ1aWxkLnhtbAotamF2YUNvbXBpbGVyLi4uYXJncwotamF2YUNvbXBpbGVyLi4uYXJncy4qClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi8ucHJvamVjdCBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vLnByb2plY3QKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVmMmQ1MDguLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi8ucHJvamVjdAorKysgL2Rldi9udWxsCkBAIC0xLDI4ICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08cHJvamVjdERlc2NyaXB0aW9uPgotCTxuYW1lPm9yZy5lY2xpcHNlLmpwdC5nZW48L25hbWU+Ci0JPGNvbW1lbnQ+PC9jb21tZW50PgotCTxwcm9qZWN0cz4KLQk8L3Byb2plY3RzPgotCTxidWlsZFNwZWM+Ci0JCTxidWlsZENvbW1hbmQ+Ci0JCQk8bmFtZT5vcmcuZWNsaXBzZS5qZHQuY29yZS5qYXZhYnVpbGRlcjwvbmFtZT4KLQkJCTxhcmd1bWVudHM+Ci0JCQk8L2FyZ3VtZW50cz4KLQkJPC9idWlsZENvbW1hbmQ+Ci0JCTxidWlsZENvbW1hbmQ+Ci0JCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuTWFuaWZlc3RCdWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5TY2hlbWFCdWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQk8L2J1aWxkU3BlYz4KLQk8bmF0dXJlcz4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5wZGUuUGx1Z2luTmF0dXJlPC9uYXR1cmU+Ci0JCTxuYXR1cmU+b3JnLmVjbGlwc2UuamR0LmNvcmUuamF2YW5hdHVyZTwvbmF0dXJlPgotCTwvbmF0dXJlcz4KLTwvcHJvamVjdERlc2NyaXB0aW9uPgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMWYxNWZmMi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcworKysgL2Rldi9udWxsCkBAIC0xLDMgKzAsMCBAQAotI1R1ZSBKYW4gMTUgMTE6MTI6MDcgRVNUIDIwMDgKLWVjbGlwc2UucHJlZmVyZW5jZXMudmVyc2lvbj0xCi1lbmNvZGluZy88cHJvamVjdD49SVNPLTg4NTktMQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuamR0LmNvcmUucHJlZnMgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5qZHQuY29yZS5wcmVmcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggM2UxZDUwYS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5qZHQuY29yZS5wcmVmcworKysgL2Rldi9udWxsCkBAIC0xLDcgKzAsMCBAQAotI1N1biBNYXkgMjcgMTQ6Mjg6NTQgRURUIDIwMDcKLWVjbGlwc2UucHJlZmVyZW5jZXMudmVyc2lvbj0xCi1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5jb2RlZ2VuLnRhcmdldFBsYXRmb3JtPTEuNQotb3JnLmVjbGlwc2UuamR0LmNvcmUuY29tcGlsZXIuY29tcGxpYW5jZT0xLjUKLW9yZy5lY2xpcHNlLmpkdC5jb3JlLmNvbXBpbGVyLnByb2JsZW0uYXNzZXJ0SWRlbnRpZmllcj1lcnJvcgotb3JnLmVjbGlwc2UuamR0LmNvcmUuY29tcGlsZXIucHJvYmxlbS5lbnVtSWRlbnRpZmllcj1lcnJvcgotb3JnLmVjbGlwc2UuamR0LmNvcmUuY29tcGlsZXIuc291cmNlPTEuNQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9NRVRBLUlORi9NQU5JRkVTVC5NRiBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vTUVUQS1JTkYvTUFOSUZFU1QuTUYKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVlOWM4MGEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9NRVRBLUlORi9NQU5JRkVTVC5NRgorKysgL2Rldi9udWxsCkBAIC0xLDIyICswLDAgQEAKLU1hbmlmZXN0LVZlcnNpb246IDEuMAotQnVuZGxlLU1hbmlmZXN0VmVyc2lvbjogMgotQnVuZGxlLU5hbWU6ICVwbHVnaW5OYW1lCi1CdW5kbGUtVmVuZG9yOiAlcHJvdmlkZXJOYW1lCi1CdW5kbGUtU3ltYm9saWNOYW1lOiBvcmcuZWNsaXBzZS5qcHQuZ2VuCi1CdW5kbGUtVmVyc2lvbjogMS4zLjAucXVhbGlmaWVyCi1CdW5kbGUtQ2xhc3NQYXRoOiAuLAotIGxpYi92ZWxvY2l0eS0xLjUuamFyCi1CdW5kbGUtTG9jYWxpemF0aW9uOiBwbHVnaW4KLUV4cG9ydC1QYWNrYWdlOiBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsO3gtZnJpZW5kczo9Im9yZy5lY2xpcHNlLmpwdC51aSIsCi0gb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDIsCi0gb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDIudXRpbAotUmVxdWlyZS1CdW5kbGU6IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZTtidW5kbGUtdmVyc2lvbj0iWzMuNC4wLDQuMC4wKSIsCi0gb3JnLmVjbGlwc2UuamR0LmNvcmU7YnVuZGxlLXZlcnNpb249IlszLjQuMCw0LjAuMCkiLAotIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5O2J1bmRsZS12ZXJzaW9uPSJbMS4yLjAsMi4wLjApIiwKLSBvcmcuZWNsaXBzZS5qcHQuZGI7YnVuZGxlLXZlcnNpb249IlsxLjIuMCwyLjAuMCkiLAotIG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzO2J1bmRsZS12ZXJzaW9uPSJbMy40LjAsNC4wLjApIiwKLSBvcmcuZWNsaXBzZS5qZmFjZS50ZXh0O2J1bmRsZS12ZXJzaW9uPSJbMy40LjAsNC4wLjApIiwKLSBvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnM7YnVuZGxlLXZlcnNpb249IjMuMi4wIiwKLSBvcmcuYXBhY2hlLmNvbW1vbnMubGFuZztidW5kbGUtdmVyc2lvbj0iMi4xLjAiLAotIG9yZy5hcGFjaGUub3JvO2J1bmRsZS12ZXJzaW9uPSIyLjAuOCIKLUJ1bmRsZS1SZXF1aXJlZEV4ZWN1dGlvbkVudmlyb25tZW50OiBKMlNFLTEuNQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9hYm91dC5odG1sIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9hYm91dC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiZTUzNGJhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vYWJvdXQuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDM0ICswLDAgQEAKLTwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAvL0VOIj4KLTxIVE1MPgotCi08aGVhZD4KLTx0aXRsZT5BYm91dDwvdGl0bGU+Ci08bWV0YSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9SVNPLTg4NTktMSI+Ci08L2hlYWQ+Ci0KLTxCT0RZIGxhbmc9IkVOLVVTIj4KLQotPEgzPkFib3V0IFRoaXMgQ29udGVudDwvSDM+Ci0KLTxQPk1heSAwMiwgMjAwODwvUD4KLQotPEgzPkxpY2Vuc2U8L0gzPgotCi08UD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBhbGwgY29udGVudCBpbiB0aGlzIHBsdWctaW4gCi0oIkNvbnRlbnQiKS4gVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQgYmVsb3csIHRoZSBDb250ZW50IGlzIHByb3ZpZGVkIHRvIHlvdSAKLXVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAKLSgiRVBMIikuIEEgY29weSBvZiB0aGUgRVBMIGlzIGF2YWlsYWJsZSBhdAotPEEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9vcmcvZG9jdW1lbnRzL2VwbC12MTAucGhwIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL29yZy9kb2N1bWVudHMvZXBsLXYxMC5waHA8L0E+LiAKLUZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAiUHJvZ3JhbSIgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvUD4KLQotPFA+SWYgeW91IGRpZCBub3QgcmVjZWl2ZSB0aGlzIENvbnRlbnQgZGlyZWN0bHkgZnJvbSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uLCB0aGUgCi1Db250ZW50IGlzIGJlaW5nIHJlZGlzdHJpYnV0ZWQgYnkgYW5vdGhlciBwYXJ0eSAoIlJlZGlzdHJpYnV0b3IiKSBhbmQgZGlmZmVyZW50IAotdGVybXMgYW5kIGNvbmRpdGlvbnMgbWF5IGFwcGx5IHRvIHlvdXIgdXNlIG9mIGFueSBvYmplY3QgY29kZSBpbiB0aGUgQ29udGVudC4gCi1DaGVjayB0aGUgUmVkaXN0cmlidXRvcidzIGxpY2Vuc2UgdGhhdCB3YXMgcHJvdmlkZWQgd2l0aCB0aGUgQ29udGVudC4gSWYgbm8gc3VjaCAKLWxpY2Vuc2UgZXhpc3RzLCBjb250YWN0IHRoZSBSZWRpc3RyaWJ1dG9yLiBVbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCBiZWxvdywgdGhlIAotdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVQTCBzdGlsbCBhcHBseSB0byBhbnkgc291cmNlIGNvZGUgaW4gdGhlIENvbnRlbnQgCi1hbmQgc3VjaCBzb3VyY2UgY29kZSBtYXkgYmUgb2J0YWluZWQgYXQKLTxBIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnLzwvQT4uPC9QPgotCi08L0JPRFk+Ci08L0hUTUw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL2J1aWxkLnByb3BlcnRpZXMgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL2J1aWxkLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDNjYmI2MzUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9idWlsZC5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTkgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSMgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0jIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0jIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi1zb3VyY2UuLiA9IHNyYy8sXAotICAgICAgICAgICAgICAgcHJvcGVydHlfZmlsZXMvCi1vdXRwdXQuLiA9IGJpbi8KLWJpbi5pbmNsdWRlcyA9IC4sXAotICAgICAgICAgICAgICAgTUVUQS1JTkYvLFwKLSAgICAgICAgICAgICAgIGFib3V0Lmh0bWwsXAotICAgICAgICAgICAgICAgcGx1Z2luLnByb3BlcnRpZXMsXAotICAgICAgICAgICAgICAgbGliL3ZlbG9jaXR5LTEuNS5qYXIsXAotICAgICAgICAgICAgICAgdGVtcGxhdGVzLwotamFycy5jb21waWxlLm9yZGVyID0gLgpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9jb21wb25lbnQueG1sIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9jb21wb25lbnQueG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3YTRlMDRlLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vY29tcG9uZW50LnhtbAorKysgL2Rldi9udWxsCkBAIC0xICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+PGNvbXBvbmVudCAgeG1sbnM9Imh0dHA6Ly9lY2xpcHNlLm9yZy93dHAvcmVsZW5nL3Rvb2xzL2NvbXBvbmVudC1tb2RlbCIgbmFtZT0ib3JnLmVjbGlwc2UuanB0LmdlbiI+PGRlc2NyaXB0aW9uIHVybD0iIj48L2Rlc2NyaXB0aW9uPjxjb21wb25lbnQtZGVwZW5kcyB1bnJlc3RyaWN0ZWQ9InRydWUiPjwvY29tcG9uZW50LWRlcGVuZHM+PHBsdWdpbiBpZD0ib3JnLmVjbGlwc2UuanB0LmdlbiIgZnJhZ21lbnQ9ImZhbHNlIi8+PC9jb21wb25lbnQ+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9saWIvdmVsb2NpdHktMS41LmphciBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vbGliL3ZlbG9jaXR5LTEuNS5qYXIKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDdjN2YyYzQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9saWIvdmVsb2NpdHktMS41LmphcgorKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vcGx1Z2luLnByb3BlcnRpZXMgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3BsdWdpbi5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0ODc1YThiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vcGx1Z2luLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwyNCArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jICBDb3B5cmlnaHQgKGMpIDIwMDcgT3JhY2xlLiAKLSMgIEFsbCByaWdodHMgcmVzZXJ2ZWQuICBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIAotIyAgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIAotIyAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgCi0jICBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotIyAgCi0jICBDb250cmlidXRvcnM6IAotIyAgCU9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotIyBUbyBjb2RlIGRldmVsb3BlcjoKLSMgICBEbyBOT1QgY2hhbmdlIHRoZSBwcm9wZXJ0aWVzIGJldHdlZW4gdGhpcyBsaW5lIGFuZCB0aGUKLSMgICAiJSUlIEVORCBPRiBUUkFOU0xBVEVEIFBST1BFUlRJRVMgJSUlIiBsaW5lLgotIyAgIE1ha2UgYSBuZXcgcHJvcGVydHkgbmFtZSwgYXBwZW5kIHRvIHRoZSBlbmQgb2YgdGhlIGZpbGUgYW5kIGNoYW5nZQotIyAgIHRoZSBjb2RlIHRvIHVzZSB0aGUgbmV3IHByb3BlcnR5LgotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0jICUlJSBFTkQgT0YgVFJBTlNMQVRFRCBQUk9QRVJUSUVTICUlJQotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotCi1wbHVnaW5OYW1lID0gSmF2YSBQZXJzaXN0ZW5jZSBBUEkgVG9vbHMgLSBFbnRpdHkgR2VuCi1wcm92aWRlck5hbWUgPSBFY2xpcHNlLm9yZwpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9wcm9wZXJ0eV9maWxlcy9qcHRfZ2VuLnByb3BlcnRpZXMgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3Byb3BlcnR5X2ZpbGVzL2pwdF9nZW4ucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzQyN2JlMS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3Byb3BlcnR5X2ZpbGVzL2pwdF9nZW4ucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDE2ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0jIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotIyB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotIyBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotCi1QYWNrYWdlR2VuZXJhdG9yX3Rhc2tOYW1lPUdlbmVyYXRlIEVudGl0aWVzCi1HZW5TY29wZV90YXNrTmFtZT1CdWlsZCBEYXRhYmFzZSBNb2RlbAotRW50aXR5R2VuZXJhdG9yX3Rhc2tOYW1lPUdlbmVyYXRlIEVudGl0eTogezB9Ci1FcnJvcl9HZW5lcmF0aW5nX0VudGl0aWVzID0gRXJyb3IgR2VuZXJhdGluZyBFbnRpdGllczsgCi0KLVRlbXBsYXRlc19ub3RGb3VuZCA9IFVuYWJsZSB0byBmaW5kIEpQQSBlbnRpdGllcyBnZW5lcmF0aW9uIHRlbXBsYXRlcyBpbiBwbHVnaW4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsL0VudGl0eUdlblRvb2xzLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsL0VudGl0eUdlblRvb2xzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDA1ODQ5MGUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbC9FbnRpdHlHZW5Ub29scy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsOwotCi1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuTmFtZVRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotCi0vKioKLSAqIFV0aWxpdHkgbWV0aG9kcyBmb3IgZW50aXR5IGdlbmVyYXRpb24uCi0gKi8KLXB1YmxpYyBjbGFzcyBFbnRpdHlHZW5Ub29scyB7Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgKGRhdGFiYXNlKSBpZGVudGlmaWVyIHRvIGEgdW5pcXVlICJKYXZhIHN0eWxlIgotCSAqIGNsYXNzIG5hbWUuCi0JICogQHNlZSAjY29udmVydFRvVW5pcXVlSmF2YVN0eWxlSWRlbnRpZmllcihTdHJpbmcsIGJvb2xlYW4sIENvbGxlY3Rpb24pCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQ2xhc3NOYW1lKFN0cmluZyBpZGVudGlmaWVyLCBDb2xsZWN0aW9uPFN0cmluZz4gY2xhc3NOYW1lcykgewotCQlyZXR1cm4gY29udmVydFRvVW5pcXVlSmF2YVN0eWxlSWRlbnRpZmllcihpZGVudGlmaWVyLCB0cnVlLCBjbGFzc05hbWVzKTsKLQl9Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgKGRhdGFiYXNlKSBpZGVudGlmaWVyIHRvIGEgdW5pcXVlICJKYXZhIHN0eWxlIgotCSAqIGF0dHJpYnV0ZSAoZmllbGQvcHJvcGVydHkpIG5hbWUuCi0JICogQHNlZSAjY29udmVydFRvVW5pcXVlSmF2YVN0eWxlSWRlbnRpZmllcihTdHJpbmcsIGJvb2xlYW4sIENvbGxlY3Rpb24pCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQXR0cmlidXRlTmFtZShTdHJpbmcgaWRlbnRpZmllciwgQ29sbGVjdGlvbjxTdHJpbmc+IGF0dHJpYnV0ZU5hbWVzKSB7Ci0JCXJldHVybiBjb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVJZGVudGlmaWVyKGlkZW50aWZpZXIsIGZhbHNlLCBhdHRyaWJ1dGVOYW1lcyk7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkIChkYXRhYmFzZSkgaWRlbnRpZmllciB0byBhIHVuaXF1ZSAiSmF2YSBzdHlsZSIKLQkgKiBpZGVudGlmaWVyOgotCSAqICAgICAtIGlmIHRoZSBpZGVudGlmaWVyIGlzIGFsbC1jYXBzLCBjb252ZXJ0IHVuZGVyc2NvcmVzIHRvICJjYW1lbCBjYXNlIgotCSAqICAgICAtIGlmIHRoZSBpZGVudGlmaWVyIGlzIG5vdCBhbGwtY2FwcywgbGVhdmUgaXQgdW5jaGFuZ2VkIChleGNlcHQsIHBvc3NpYmx5LCBmb3IgdGhlIGZpcnN0IGxldHRlcikKLQkgKiAgICAgLSBjb252ZXJ0IHRvIGEgbGVnYWwgSmF2YSBpZGVudGlmaWVyCi0JICogICAgICAgICAtIGVsaW1pbmF0ZSBpbGxlZ2FsIGNoYXJhY3RlcnMKLQkgKiAgICAgICAgIC0gaWYgdGhlIHJlc3VsdCBpcyBhIHJlc2VydmVkIHdvcmQsIG1vZGlmeSBpdCBzbGlnaHRseQotCSAqIElmIHRoZSByZXN1bHQgaXMgYWxyZWFkeSBvbmUgb2YgdGhlIHNwZWNpZmllZCBleGlzdGluZyBpZGVudGlmaWVycwotCSAqIChpZ25vcmluZyBjYXNlIHNvIHdlIGRvbid0IGhhdmUgZmlsZW5hbWUgY29sbGlzaW9ucyBvbiBXaW5kb3dzKSwKLQkgKiBtb2RpZnkgaXQgc2xpZ2h0bHkgYWdhaW4uCi0JICogICAgICJGT08iID0+ICJGb28iIG9yICJmb28iCi0JICogICAgICJGT09fQkFSIiA9PiAiRm9vQmFyIiBvciAiZm9vQmFyIgotCSAqICAgICAiUEFDS0FHRSIgPT4gIlBhY2thZ2UiIG9yICJwYWNrYWdlXyIKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBjb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVJZGVudGlmaWVyKFN0cmluZyBpZGVudGlmaWVyLCBib29sZWFuIGNhcGl0YWxpemVGaXJzdExldHRlciwgQ29sbGVjdGlvbjxTdHJpbmc+IGlkZW50aWZpZXJzKSB7Ci0JCVN0cmluZyByZXN1bHQgPSBpZGVudGlmaWVyOwotCQlpZiAoU3RyaW5nVG9vbHMuc3RyaW5nSXNVcHBlcmNhc2UocmVzdWx0KSkgewotCQkJLy8gbGVhdmUgbWl4ZWQgY2FzZSBpZGVudGlmaWVycyBhbG9uZT8KLQkJCXJlc3VsdCA9IFN0cmluZ1Rvb2xzLmNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlKHJlc3VsdCwgY2FwaXRhbGl6ZUZpcnN0TGV0dGVyKTsKLQkJfSBlbHNlIHsKLQkJCXJlc3VsdCA9IGNhcGl0YWxpemVGaXJzdExldHRlciA/IFN0cmluZ1Rvb2xzLmNhcGl0YWxpemUocmVzdWx0KSA6IFN0cmluZ1Rvb2xzLnVuY2FwaXRhbGl6ZShyZXN1bHQpOwotCQl9Ci0JCXJlc3VsdCA9IE5hbWVUb29scy5jb252ZXJ0VG9KYXZhSWRlbnRpZmllcihyZXN1bHQpOwotCQkvLyBhc3N1bWUgdGhhdCBjb252ZXJ0aW5nIHRvIGEgdW5pcXVlIG5hbWUgd2lsbCBub3QgcmVzdWx0IGluIGEgSmF2YSByZXNlcnZlZCB3b3JkCi0JCS8vIChzaW5jZSBubyBKYXZhIHJlc2VydmVkIHdvcmRzIGVuZCB3aXRoIGEgbnVtYmVyKQotCQlyZXN1bHQgPSBOYW1lVG9vbHMudW5pcXVlTmFtZUZvcklnbm9yZUNhc2UocmVzdWx0LCBpZGVudGlmaWVycyk7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9yICoqKioqKioqKioKLQotCS8qKgotCSAqIFN1cHByZXNzIGRlZmF1bHQgY29uc3RydWN0b3IsIGVuc3VyaW5nIG5vbi1pbnN0YW50aWFiaWxpdHkuCi0JICovCi0JcHJpdmF0ZSBFbnRpdHlHZW5Ub29scygpIHsKLQkJc3VwZXIoKTsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsL0VudGl0eUdlbmVyYXRvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbC9FbnRpdHlHZW5lcmF0b3IuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMTdmYTE3MS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsL0VudGl0eUdlbmVyYXRvci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTc3OSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5nZW4uaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLmlvLlByaW50V3JpdGVyOwotaW1wb3J0IGphdmEuaW8uU2VyaWFsaXphYmxlOwotaW1wb3J0IGphdmEuaW8uU3RyaW5nV3JpdGVyOwotaW1wb3J0IGphdmEubGFuZy5yZWZsZWN0Lk1vZGlmaWVyOwotaW1wb3J0IGphdmEudGV4dC5Db2xsYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuQ29tcGFyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuSGFzaE1hcDsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk1hcDsKLWltcG9ydCBqYXZhLnV0aWwuU2V0OwotaW1wb3J0IGphdmEudXRpbC5UcmVlU2V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5JUHJvZ3Jlc3NNb25pdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5TdWJNb25pdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklKYXZhTW9kZWxTdGF0dXNDb25zdGFudHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSVBhY2thZ2VGcmFnbWVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5KYXZhTW9kZWxFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkNvbHVtbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuRm9yZWlnbktleTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuVGFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuSmF2YVR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQm9vbGVhbkhvbGRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5JbmRlbnRpbmdQcmludFdyaXRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5OYW1lVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkZpbHRlcmluZ0l0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci0KLS8vIFRPRE8gZm9ybWF0IGdlbmVyYXRlZCBjb2RlIHBlciBwcmVmZXJlbmNlcwotLy8gVE9ETyBvcmdhbml6ZSBnZW5lcmF0ZWQgaW1wb3J0cyBwZXIgcHJlZmVyZW5jZXMKLS8qKgotICogVGhpcyBnZW5lcmF0b3Igd2lsbCBnZW5lcmF0ZSBhbiBlbnRpdHkgZm9yIGEgdGFibGUuCi0gKi8KLXB1YmxpYyBjbGFzcyBFbnRpdHlHZW5lcmF0b3IgewotCWZpbmFsIENvbmZpZyBjb25maWc7Ci0JcHJpdmF0ZSBmaW5hbCBJUGFja2FnZUZyYWdtZW50IHBhY2thZ2VGcmFnbWVudDsKLQlwcml2YXRlIGZpbmFsIEdlblRhYmxlIGdlblRhYmxlOwotCXByaXZhdGUgZmluYWwgU3RyaW5nIGVudGl0eUNsYXNzTmFtZTsKLQlwcml2YXRlIGZpbmFsIFN0cmluZyBwa0NsYXNzTmFtZTsKLQotCi0JLy8gKioqKioqKioqKiBwdWJsaWMgQVBJICoqKioqKioqKioKLQotCXN0YXRpYyB2b2lkIGdlbmVyYXRlRW50aXR5KAotCQkJQ29uZmlnIGNvbmZpZywKLQkJCUlQYWNrYWdlRnJhZ21lbnQgcGFja2FnZUZyYWdtZW50LAotCQkJR2VuVGFibGUgZ2VuVGFibGUsCi0JCQlJUHJvZ3Jlc3NNb25pdG9yIHByb2dyZXNzTW9uaXRvcgotCSkgewotCQlpZiAoKGNvbmZpZyA9PSBudWxsKSB8fCAocGFja2FnZUZyYWdtZW50ID09IG51bGwpIHx8IChnZW5UYWJsZSA9PSBudWxsKSkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJbmV3IEVudGl0eUdlbmVyYXRvcihjb25maWcsIHBhY2thZ2VGcmFnbWVudCwgZ2VuVGFibGUpLmdlbmVyYXRlRW50aXR5KHByb2dyZXNzTW9uaXRvcik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9yL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCXByaXZhdGUgRW50aXR5R2VuZXJhdG9yKENvbmZpZyBjb25maWcsIElQYWNrYWdlRnJhZ21lbnQgcGFja2FnZUZyYWdtZW50LCBHZW5UYWJsZSBnZW5UYWJsZSkgewotCQlzdXBlcigpOwotCQl0aGlzLmNvbmZpZyA9IGNvbmZpZzsKLQkJdGhpcy5wYWNrYWdlRnJhZ21lbnQgPSBwYWNrYWdlRnJhZ21lbnQ7Ci0JCXRoaXMuZ2VuVGFibGUgPSBnZW5UYWJsZTsKLQkJdGhpcy5lbnRpdHlDbGFzc05hbWUgPSB0aGlzLmZ1bGx5UXVhbGlmeSh0aGlzLmdldEVudGl0eU5hbWUoKSk7Ci0JCXRoaXMucGtDbGFzc05hbWUgPSB0aGlzLmVudGl0eUNsYXNzTmFtZSArICcuJyArIGNvbmZpZy5nZXRQcmltYXJ5S2V5TWVtYmVyQ2xhc3NOYW1lKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvZGUgZ2VuICoqKioqKioqKioKLQotCXByaXZhdGUgdm9pZCBnZW5lcmF0ZUVudGl0eShJUHJvZ3Jlc3NNb25pdG9yIHByb2dyZXNzTW9uaXRvcikgewotCQl0cnkgewotCQkJdGhpcy5nZW5lcmF0ZUVudGl0eV8ocHJvZ3Jlc3NNb25pdG9yKTsKLQkJfSBjYXRjaCAoSmF2YU1vZGVsRXhjZXB0aW9uIGV4KSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihleCk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgZ2VuZXJhdGVFbnRpdHlfKElQcm9ncmVzc01vbml0b3IgcHJvZ3Jlc3NNb25pdG9yKSB0aHJvd3MgSmF2YU1vZGVsRXhjZXB0aW9uIHsKLQkJU3ViTW9uaXRvciBzbSA9IFN1Yk1vbml0b3IuY29udmVydChwcm9ncmVzc01vbml0b3IsIHRoaXMuYnVpbGRUYXNrTmFtZSgpLCAxMDApOwotCQlTdHJpbmcgZmlsZU5hbWUgPSB0aGlzLmdldEVudGl0eU5hbWUoKSArICIuamF2YSI7ICAvLyROT04tTkxTLTEkCi0JCVN0cmluZyBzb3VyY2UgPSB0aGlzLmJ1aWxkU291cmNlKCk7Ci0JCXNtLndvcmtlZCgyMCk7Ci0JCXRyeSB7Ci0JCQl0aGlzLnBhY2thZ2VGcmFnbWVudC5jcmVhdGVDb21waWxhdGlvblVuaXQoZmlsZU5hbWUsIHNvdXJjZSwgZmFsc2UsIHNtLm5ld0NoaWxkKDQwKSk7Ci0JCX0gY2F0Y2ggKEphdmFNb2RlbEV4Y2VwdGlvbiBleCkgewotCQkJaWYgKGV4LmdldEphdmFNb2RlbFN0YXR1cygpLmdldENvZGUoKSA9PSBJSmF2YU1vZGVsU3RhdHVzQ29uc3RhbnRzLk5BTUVfQ09MTElTSU9OKSB7Ci0JCQkJaWYgKHRoaXMuY29uZmlnLmdldE92ZXJ3cml0ZUNvbmZpcm1lcigpLm92ZXJ3cml0ZSh0aGlzLmVudGl0eUNsYXNzTmFtZSkpIHsKLQkJCQkJdGhpcy5wYWNrYWdlRnJhZ21lbnQuY3JlYXRlQ29tcGlsYXRpb25Vbml0KGZpbGVOYW1lLCBzb3VyY2UsIHRydWUsIHNtLm5ld0NoaWxkKDQwKSk7Ci0JCQkJfQotCQkJfSBlbHNlIHsKLQkJCQl0aHJvdyBleDsKLQkJCX0KLQkJfQotCQlzbS5zZXRXb3JrUmVtYWluaW5nKDApOwotCX0KLQotCXByaXZhdGUgU3RyaW5nIGJ1aWxkVGFza05hbWUoKSB7Ci0JCXJldHVybiBOTFMuYmluZChKcHRHZW5NZXNzYWdlcy5FbnRpdHlHZW5lcmF0b3JfdGFza05hbWUsIHRoaXMuZ2V0RW50aXR5TmFtZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBidWlsZCB0aGUgImJvZHkiIHNvdXJjZSBmaXJzdDsgdGhlbiBidWlsZCB0aGUgInBhY2thZ2UiIGFuZCAiaW1wb3J0cyIgc291cmNlCi0JICogYW5kIGNvbmNhdGVuYXRlIHRoZSAiYm9keSIgc291cmNlIHRvIGl0Ci0JICovCi0JcHJpdmF0ZSBTdHJpbmcgYnVpbGRTb3VyY2UoKSB7Ci0JCS8vIGJ1aWxkIHRoZSBib2R5IHNvdXJjZSBmaXJzdCBzbyB3ZSBjYW4gZ2F0aGVyIHVwIHRoZSBpbXBvcnQgc3RhdGVtZW50cwotCQlCb2R5U291cmNlIGJvZHlTb3VyY2UgPSB0aGlzLmJ1aWxkQm9keVNvdXJjZSgpOwotCi0JCVN0cmluZ1dyaXRlciBzdyA9IG5ldyBTdHJpbmdXcml0ZXIoYm9keVNvdXJjZS5sZW5ndGgoKSArIDIwMDApOwotCQlQcmludFdyaXRlciBwdyA9IG5ldyBQcmludFdyaXRlcihzdyk7Ci0JCXRoaXMucHJpbnRQYWNrYWdlQW5kSW1wb3J0c09uKHB3LCBib2R5U291cmNlKTsKLQkJcHcucHJpbnQoYm9keVNvdXJjZS5nZXRTb3VyY2UoKSk7Ci0JCXJldHVybiBzdy50b1N0cmluZygpOwotCX0KLQotCXByaXZhdGUgQm9keVNvdXJjZSBidWlsZEJvZHlTb3VyY2UoKSB7Ci0JCUVudGl0eVNvdXJjZVdyaXRlciBwdyA9IG5ldyBFbnRpdHlTb3VyY2VXcml0ZXIodGhpcy5nZXRQYWNrYWdlTmFtZSgpLCB0aGlzLmVudGl0eUNsYXNzTmFtZSk7Ci0JCXRoaXMucHJpbnRCb2R5U291cmNlT24ocHcpOwotCQlyZXR1cm4gcHc7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50Qm9keVNvdXJjZU9uKEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQl0aGlzLnByaW50Q2xhc3NEZWNsYXJhdGlvbk9uKHB3KTsKLQotCQlwdy5pbmRlbnQoKTsKLQkJCXRoaXMucHJpbnRFbnRpdHlQcmltYXJ5S2V5RmllbGRzT24ocHcpOwotCQkJdGhpcy5wcmludEVudGl0eU5vblByaW1hcnlLZXlCYXNpY0ZpZWxkc09uKHB3KTsKLQkJCXRoaXMucHJpbnRFbnRpdHlNYW55VG9PbmVGaWVsZHNPbihwdyk7Ci0JCQl0aGlzLnByaW50RW50aXR5T25lVG9NYW55RmllbGRzT24ocHcpOwotCQkJdGhpcy5wcmludEVudGl0eU93bmVkTWFueVRvTWFueUZpZWxkc09uKHB3KTsKLQkJCXRoaXMucHJpbnRFbnRpdHlOb25Pd25lZE1hbnlUb01hbnlGaWVsZHNPbihwdyk7Ci0JCQl0aGlzLnByaW50U2VyaWFsVmVyc2lvblVJREZpZWxkT24ocHcpOwotCQkJcHcucHJpbnRsbigpOwotCi0JCQl0aGlzLnByaW50WmVyb0FyZ3VtZW50Q29uc3RydWN0b3JPbih0aGlzLmdldEVudGl0eU5hbWUoKSwgdGhpcy5jb25maWcuZ2V0TWV0aG9kVmlzaWJpbGl0eUNsYXVzZSgpLCBwdyk7Ci0JCQlpZiAodGhpcy5jb25maWcucHJvcGVydHlBY2Nlc3NUeXBlKCkgfHwgdGhpcy5jb25maWcuZ2VuZXJhdGVHZXR0ZXJzQW5kU2V0dGVycygpKSB7Ci0JCQkJdGhpcy5wcmludEVudGl0eVByaW1hcnlLZXlQcm9wZXJ0aWVzT24ocHcpOwotCQkJCXRoaXMucHJpbnRFbnRpdHlOb25QcmltYXJ5S2V5QmFzaWNQcm9wZXJ0aWVzT24ocHcpOwotCQkJCXRoaXMucHJpbnRFbnRpdHlNYW55VG9PbmVQcm9wZXJ0aWVzT24ocHcpOwotCQkJCXRoaXMucHJpbnRFbnRpdHlPbmVUb01hbnlQcm9wZXJ0aWVzT24ocHcpOwotCQkJCXRoaXMucHJpbnRFbnRpdHlPd25lZE1hbnlUb01hbnlQcm9wZXJ0aWVzT24ocHcpOwotCQkJCXRoaXMucHJpbnRFbnRpdHlOb25Pd25lZE1hbnlUb01hbnlQcm9wZXJ0aWVzT24ocHcpOwotCQkJfQotCi0JCQlpZiAodGhpcy5wcmltYXJ5S2V5Q2xhc3NJc1JlcXVpcmVkKCkpIHsKLQkJCQl0aGlzLnByaW50UHJpbWFyeUtleUNsYXNzT24ocHcpOwotCQkJfQotCQlwdy51bmRlbnQoKTsKLQotCQlwdy5wcmludCgnfScpOwotCQlwdy5wcmludGxuKCk7ICAvLyBFT0YKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY2xhc3MgZGVjbGFyYXRpb24gKioqKioqKioqKgotCi0JcHJpdmF0ZSB2b2lkIHByaW50Q2xhc3NEZWNsYXJhdGlvbk9uKEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQl0aGlzLnByaW50RW50aXR5QW5ub3RhdGlvbk9uKHB3KTsKLQkJdGhpcy5wcmludFRhYmxlQW5ub3RhdGlvbk9uKHB3KTsKLQkJdGhpcy5wcmludElkQ2xhc3NBbm5vdGF0aW9uT24ocHcpOwotCi0JCXB3LnByaW50KCJwdWJsaWMgY2xhc3MgIik7ICAvLyROT04tTkxTLTEkCi0JCXB3LnByaW50VHlwZURlY2xhcmF0aW9uKHRoaXMuZW50aXR5Q2xhc3NOYW1lKTsKLQkJaWYgKGNvbmZpZy5zZXJpYWxpemFibGUoKSkgewotCQkJcHcucHJpbnQoIiBpbXBsZW1lbnRzICIpOyAgLy8kTk9OLU5MUy0xJAotCQkJcHcucHJpbnRUeXBlRGVjbGFyYXRpb24oU2VyaWFsaXphYmxlLmNsYXNzLmdldE5hbWUoKSk7Ci0JCX0KLQkJcHcucHJpbnQoIiB7Iik7ICAvLyROT04tTkxTLTEkCi0JCXB3LnByaW50bG4oKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRFbnRpdHlBbm5vdGF0aW9uT24oRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCXB3LnByaW50QW5ub3RhdGlvbihKUEEuRU5USVRZKTsKLQkJcHcucHJpbnRsbigpOwotCX0KLQotCXByaXZhdGUgdm9pZCBwcmludFRhYmxlQW5ub3RhdGlvbk9uKEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlTdHJpbmcgdGFibGVOYW1lID0gdGhpcy5jb25maWcuZ2V0RGF0YWJhc2VBbm5vdGF0aW9uTmFtZUJ1aWxkZXIoKS5idWlsZFRhYmxlQW5ub3RhdGlvbk5hbWUodGhpcy5nZXRFbnRpdHlOYW1lKCksIHRoaXMuZ2V0VGFibGUoKSk7Ci0JCWlmICh0YWJsZU5hbWUgPT0gbnVsbCkgewotCQkJcmV0dXJuOyAgLy8gdGhlIGRlZmF1bHQgdGFibGUgbmFtZSBpcyBPSwotCQl9Ci0JCXB3LnByaW50QW5ub3RhdGlvbihKUEEuVEFCTEUpOwotCQlwdy5wcmludCgiKG5hbWU9Iik7ICAvLyROT04tTkxTLTEkCi0JCXB3LnByaW50U3RyaW5nTGl0ZXJhbCh0YWJsZU5hbWUpOwotCQlwdy5wcmludCgnKScpOwotCQlwdy5wcmludGxuKCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50SWRDbGFzc0Fubm90YXRpb25PbihFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJaWYgKHRoaXMucHJpbWFyeUtleUNsYXNzSXNSZXF1aXJlZCgpICYmIHRoaXMuY29uZmlnLmdlbmVyYXRlSWRDbGFzc0ZvckNvbXBvdW5kUEsoKSkgewotCQkJcHcucHJpbnRBbm5vdGF0aW9uKEpQQS5JRF9DTEFTUyk7Ci0JCQlwdy5wcmludCgnKCcpOwotCQkJcHcucHJpbnRUeXBlRGVjbGFyYXRpb24odGhpcy5wa0NsYXNzTmFtZSk7Ci0JCQlwdy5wcmludCgiLmNsYXNzKSIpOyAgLy8kTk9OLU5MUy0xJAotCQkJcHcucHJpbnRsbigpOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHByaW1hcnkga2V5IGZpZWxkcyAqKioqKioqKioqCi0KLQlwcml2YXRlIHZvaWQgcHJpbnRFbnRpdHlQcmltYXJ5S2V5RmllbGRzT24oRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCWlmICh0aGlzLnByaW1hcnlLZXlDbGFzc0lzUmVxdWlyZWQoKSAmJiB0aGlzLmNvbmZpZy5nZW5lcmF0ZUVtYmVkZGVkSWRGb3JDb21wb3VuZFBLKCkpIHsKLQkJCXRoaXMucHJpbnRFbnRpdHlFbWJlZGRlZElkUHJpbWFyeUtleUZpZWxkT24ocHcpOwotCQl9IGVsc2UgewotCQkJdGhpcy5wcmludEVudGl0eVJlYWRPbmx5UHJpbWFyeUtleUZpZWxkc09uKHB3KTsKLQkJCXRoaXMucHJpbnRFbnRpdHlXcml0YWJsZVByaW1hcnlLZXlGaWVsZHNPbihwdyk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRFbnRpdHlFbWJlZGRlZElkUHJpbWFyeUtleUZpZWxkT24oRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCWlmICh0aGlzLmNvbmZpZy5maWVsZEFjY2Vzc1R5cGUoKSkgewotCQkJcHcucHJpbnRBbm5vdGF0aW9uKEpQQS5FTUJFRERFRF9JRCk7Ci0JCQlwdy5wcmludGxuKCk7Ci0JCX0KLQkJdGhpcy5wcmludEZpZWxkT24odGhpcy5nZW5UYWJsZS5nZXRBdHRyaWJ1dGVOYW1lRm9yRW1iZWRkZWRJZCgpLCB0aGlzLnBrQ2xhc3NOYW1lLCBwdyk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50RW50aXR5UmVhZE9ubHlQcmltYXJ5S2V5RmllbGRzT24oRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCXRoaXMucHJpbnRQcmltYXJ5S2V5RmllbGRzT24ocHcsIHRydWUsIHRydWUpOyAgLy8gdHJ1ZT1yZWFkLW9ubHk7IHRydWU9cHJpbnQgSUQgYW5ub3RhdGlvbiBvbiBmaWVsZHMKLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRFbnRpdHlXcml0YWJsZVByaW1hcnlLZXlGaWVsZHNPbihFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJdGhpcy5wcmludFByaW1hcnlLZXlGaWVsZHNPbihwdywgZmFsc2UsIHRydWUpOyAgLy8gZmFsc2U9d3JpdGFibGU7IHRydWU9cHJpbnQgSUQgYW5ub3RhdGlvbiBvbiBmaWVsZHMKLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRQcmltYXJ5S2V5RmllbGRzT24oRW50aXR5U291cmNlV3JpdGVyIHB3LCBib29sZWFuIHJlYWRPbmx5LCBib29sZWFuIHByaW50SWRBbm5vdGF0aW9uKSB7Ci0JCWZvciAoSXRlcmF0b3I8Q29sdW1uPiBzdHJlYW0gPSB0aGlzLnByaW1hcnlLZXlDb2x1bW5zKHJlYWRPbmx5KTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQl0aGlzLnByaW50UHJpbWFyeUtleUZpZWxkT24oc3RyZWFtLm5leHQoKSwgcHcsIHJlYWRPbmx5LCBwcmludElkQW5ub3RhdGlvbik7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPENvbHVtbj4gcHJpbWFyeUtleUNvbHVtbnMoYm9vbGVhbiByZWFkT25seSkgewotCQlyZXR1cm4gcmVhZE9ubHkgPyB0aGlzLmdlblRhYmxlLnJlYWRPbmx5UHJpbWFyeUtleUNvbHVtbnMoKSA6IHRoaXMuZ2VuVGFibGUud3JpdGFibGVQcmltYXJ5S2V5Q29sdW1ucygpOwotCX0KLQotCS8vIFRPRE8gaWYgdGhlIGZpZWxkJ3MgdHlwZSBpcyBqYXZhLnV0aWwvc3FsLkRhdGUsIGl0IG5lZWRzIEBUZW1wb3JhbChEQVRFKQotCS8vIFRPRE8gaWYgdGhlIHByaW1hcnkga2V5IGlzIGF1dG8tZ2VuZXJhdGVkLCB0aGUgZmllbGQgbXVzdCBiZSBhbiBpbnRlZ3JhbCB0eXBlCi0JcHJpdmF0ZSB2b2lkIHByaW50UHJpbWFyeUtleUZpZWxkT24oQ29sdW1uIGNvbHVtbiwgRW50aXR5U291cmNlV3JpdGVyIHB3LCBib29sZWFuIHJlYWRPbmx5LCBib29sZWFuIHByaW50SWRBbm5vdGF0aW9uKSB7Ci0JCVN0cmluZyBmaWVsZE5hbWUgPSB0aGlzLmdlblRhYmxlLmdldEF0dHJpYnV0ZU5hbWVGb3IoY29sdW1uKTsKLQkJaWYgKHRoaXMuY29uZmlnLmZpZWxkQWNjZXNzVHlwZSgpKSB7Ci0JCQlpZiAocHJpbnRJZEFubm90YXRpb24pIHsKLQkJCQlwdy5wcmludEFubm90YXRpb24oSlBBLklEKTsKLQkJCQlwdy5wcmludGxuKCk7Ci0JCQl9Ci0JCQlTdHJpbmcgY29sdW1uTmFtZSA9IHRoaXMuY29uZmlnLmdldERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyKCkuYnVpbGRDb2x1bW5Bbm5vdGF0aW9uTmFtZShmaWVsZE5hbWUsIGNvbHVtbik7Ci0JCQlpZiAocmVhZE9ubHkpIHsKLQkJCQl0aGlzLnByaW50UmVhZE9ubHlDb2x1bW5Bbm5vdGF0aW9uT24oY29sdW1uTmFtZSwgcHcpOwotCQkJfSBlbHNlIHsKLQkJCQl0aGlzLnByaW50Q29sdW1uQW5ub3RhdGlvbk9uKGNvbHVtbk5hbWUsIHB3KTsKLQkJCX0KLQkJfQotCQl0aGlzLnByaW50RmllbGRPbihmaWVsZE5hbWUsIGNvbHVtbi5nZXRQcmltYXJ5S2V5SmF2YVR5cGVEZWNsYXJhdGlvbigpLCBwdyk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50UmVhZE9ubHlDb2x1bW5Bbm5vdGF0aW9uT24oU3RyaW5nIGNvbHVtbk5hbWUsIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlwdy5wcmludEFubm90YXRpb24oSlBBLkNPTFVNTik7Ci0JCXB3LnByaW50KCcoJyk7Ci0JCWlmIChjb2x1bW5OYW1lICE9IG51bGwpIHsKLQkJCXB3LnByaW50KCJuYW1lPSIpOyAgLy8kTk9OLU5MUy0xJAotCQkJcHcucHJpbnRTdHJpbmdMaXRlcmFsKGNvbHVtbk5hbWUpOwotCQkJcHcucHJpbnQoIiwgIik7ICAvLyROT04tTkxTLTEkCi0JCX0KLQkJcHcucHJpbnQoImluc2VydGFibGU9ZmFsc2UsIHVwZGF0YWJsZT1mYWxzZSkiKTsgIC8vJE5PTi1OTFMtMSQKLQkJcHcucHJpbnRsbigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBiYXNpYyBmaWVsZHMgKioqKioqKioqKgotCi0JcHJpdmF0ZSB2b2lkIHByaW50RW50aXR5Tm9uUHJpbWFyeUtleUJhc2ljRmllbGRzT24oRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCWZvciAoSXRlcmF0b3I8Q29sdW1uPiBzdHJlYW0gPSB0aGlzLmdlblRhYmxlLm5vblByaW1hcnlLZXlCYXNpY0NvbHVtbnMoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQl0aGlzLnByaW50RW50aXR5Tm9uUHJpbWFyeUtleUJhc2ljRmllbGRPbihzdHJlYW0ubmV4dCgpLCBwdyk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRFbnRpdHlOb25QcmltYXJ5S2V5QmFzaWNGaWVsZE9uKENvbHVtbiBjb2x1bW4sIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlTdHJpbmcgZmllbGROYW1lID0gdGhpcy5nZW5UYWJsZS5nZXRBdHRyaWJ1dGVOYW1lRm9yKGNvbHVtbik7Ci0JCWlmICh0aGlzLmNvbmZpZy5maWVsZEFjY2Vzc1R5cGUoKSkgewotCQkJU3RyaW5nIGNvbHVtbk5hbWUgPSB0aGlzLmNvbmZpZy5nZXREYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlcigpLmJ1aWxkQ29sdW1uQW5ub3RhdGlvbk5hbWUoZmllbGROYW1lLCBjb2x1bW4pOwotCQkJdGhpcy5wcmludENvbHVtbkFubm90YXRpb25Pbihjb2x1bW5OYW1lLCBwdyk7Ci0JCX0KLQkJaWYgKGNvbHVtbi5pc0xPQigpKSB7Ci0JCQlwdy5wcmludEFubm90YXRpb24oSlBBLkxPQik7Ci0JCQlwdy5wcmludGxuKCk7Ci0JCX0KLQkJdGhpcy5wcmludEZpZWxkT24oZmllbGROYW1lLCBjb2x1bW4uZ2V0SmF2YVR5cGVEZWNsYXJhdGlvbigpLCBwdyk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50Q29sdW1uQW5ub3RhdGlvbk9uKFN0cmluZyBjb2x1bW5OYW1lLCBFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJaWYgKGNvbHVtbk5hbWUgIT0gbnVsbCkgeyAgLy8gdGhlIGNvbHVtbiBuYW1lIGlzIG51bGwgaWYgdGhlIGRlZmF1bHQgaXMgT0sKLQkJCXB3LnByaW50QW5ub3RhdGlvbihKUEEuQ09MVU1OKTsKLQkJCXB3LnByaW50KCIobmFtZT0iKTsgIC8vJE5PTi1OTFMtMSQKLQkJCXB3LnByaW50U3RyaW5nTGl0ZXJhbChjb2x1bW5OYW1lKTsKLQkJCXB3LnByaW50KCcpJyk7Ci0JCQlwdy5wcmludGxuKCk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogbWFueS10by1vbmUgZmllbGRzICoqKioqKioqKioKLQotCXByaXZhdGUgdm9pZCBwcmludEVudGl0eU1hbnlUb09uZUZpZWxkc09uKEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlmb3IgKEl0ZXJhdG9yPE1hbnlUb09uZVJlbGF0aW9uPiBzdHJlYW0gPSB0aGlzLmdlblRhYmxlLm1hbnlUb09uZVJlbGF0aW9ucygpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCXRoaXMucHJpbnRFbnRpdHlNYW55VG9PbmVGaWVsZE9uKHN0cmVhbS5uZXh0KCksIHB3KTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBwcmludEVudGl0eU1hbnlUb09uZUZpZWxkT24oTWFueVRvT25lUmVsYXRpb24gcmVsYXRpb24sIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlTdHJpbmcgZmllbGROYW1lID0gdGhpcy5nZW5UYWJsZS5nZXRBdHRyaWJ1dGVOYW1lRm9yKHJlbGF0aW9uKTsKLQkJaWYgKHRoaXMuY29uZmlnLmZpZWxkQWNjZXNzVHlwZSgpKSB7Ci0JCQl0aGlzLnByaW50TWFueVRvT25lQW5ub3RhdGlvbk9uKGZpZWxkTmFtZSwgcmVsYXRpb24sIHB3KTsKLQkJfQotCQl0aGlzLnByaW50RmllbGRPbihmaWVsZE5hbWUsIHRoaXMuZnVsbHlRdWFsaWZ5KHJlbGF0aW9uLmdldFJlZmVyZW5jZWRFbnRpdHlOYW1lKCkpLCBwdyk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50TWFueVRvT25lQW5ub3RhdGlvbk9uKFN0cmluZyBhdHRyaWJ1dGVOYW1lLCBNYW55VG9PbmVSZWxhdGlvbiByZWxhdGlvbiwgRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCXB3LnByaW50QW5ub3RhdGlvbihKUEEuTUFOWV9UT19PTkUpOwotCQlwdy5wcmludGxuKCk7Ci0JCUZvcmVpZ25LZXkgZm9yZWlnbktleSA9IHJlbGF0aW9uLmdldEZvcmVpZ25LZXkoKTsKLQkJaWYgKGZvcmVpZ25LZXkucmVmZXJlbmNlc1NpbmdsZUNvbHVtblByaW1hcnlLZXkoKSkgewotCQkJLy8gaWYgdGhlIEZLIHJlZmVyZW5jZXMgYSBzaW5nbGUtY29sdW1uIFBLLCAncmVmZXJlbmNlZENvbHVtbk5hbWUnIGlzIG5vdCByZXF1aXJlZAotCQkJU3RyaW5nIGpvaW5Db2x1bW5OYW1lID0gdGhpcy5jb25maWcuZ2V0RGF0YWJhc2VBbm5vdGF0aW9uTmFtZUJ1aWxkZXIoKS5idWlsZEpvaW5Db2x1bW5Bbm5vdGF0aW9uTmFtZShhdHRyaWJ1dGVOYW1lLCBmb3JlaWduS2V5KTsKLQkJCWlmIChqb2luQ29sdW1uTmFtZSA9PSBudWxsKSB7Ci0JCQkJLy8gbm8gSm9pbkNvbHVtbiBhbm5vdGF0aW9uIG5lZWRlZDogdGhlIGRlZmF1bHQgJ25hbWUnIGFuZCAncmVmZXJlbmNlZENvbHVtbk5hbWUnIHdvcmsKLQkJCX0gZWxzZSB7Ci0JCQkJLy8gdGhlcmUgaXMgb25seSBhIHNpbmdsZSBqb2luIGNvbHVtbiBoZXJlIChqdXN0IG5vdCB0aGUgZGVmYXVsdCBuYW1lKQotCQkJCXRoaXMucHJpbnRKb2luQ29sdW1uQW5ub3RhdGlvbk9uKGpvaW5Db2x1bW5OYW1lLCBudWxsLCBwdyk7Ci0JCQkJcHcucHJpbnRsbigpOwotCQkJfQotCQl9IGVsc2UgewotCQkJdGhpcy5wcmludE1hbnlUb09uZUpvaW5Db2x1bW5zQW5ub3RhdGlvbk9uKGZvcmVpZ25LZXksIHB3KTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBwcmludE1hbnlUb09uZUpvaW5Db2x1bW5zQW5ub3RhdGlvbk9uKEZvcmVpZ25LZXkgZm9yZWlnbktleSwgRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCWlmIChmb3JlaWduS2V5LmNvbHVtblBhaXJzU2l6ZSgpID4gMSkgewotCQkJcHcucHJpbnRBbm5vdGF0aW9uKEpQQS5KT0lOX0NPTFVNTlMpOwotCQkJcHcucHJpbnQoIih7Iik7ICAvLyROT04tTkxTLTEkCi0JCQlwdy5wcmludGxuKCk7Ci0JCQlwdy5pbmRlbnQoKTsKLQkJfQotCQl0aGlzLnByaW50Sm9pbkNvbHVtbkFubm90YXRpb25zT24oZm9yZWlnbktleSwgcHcpOwotCQlpZiAoZm9yZWlnbktleS5jb2x1bW5QYWlyc1NpemUoKSA+IDEpIHsKLQkJCXB3LnVuZGVudCgpOwotCQkJcHcucHJpbnRsbigpOwotCQkJcHcucHJpbnQoIn0pIik7ICAvLyROT04tTkxTLTEkCi0JCX0KLQkJcHcucHJpbnRsbigpOwotCX0KLQotCXByaXZhdGUgdm9pZCBwcmludEpvaW5Db2x1bW5Bbm5vdGF0aW9uc09uKEZvcmVpZ25LZXkgZm9yZWlnbktleSwgRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCWZvciAoSXRlcmF0b3I8Rm9yZWlnbktleS5Db2x1bW5QYWlyPiBzdHJlYW0gPSBmb3JlaWduS2V5LmNvbHVtblBhaXJzKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJdGhpcy5wcmludEpvaW5Db2x1bW5Bbm5vdGF0aW9uT24oc3RyZWFtLm5leHQoKSwgcHcpOwotCQkJaWYgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCQlwdy5wcmludGxuKCcsJyk7Ci0JCQl9Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRKb2luQ29sdW1uQW5ub3RhdGlvbk9uKEZvcmVpZ25LZXkuQ29sdW1uUGFpciBjb2x1bW5QYWlyLCBFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJdGhpcy5wcmludEpvaW5Db2x1bW5Bbm5vdGF0aW9uT24oCi0JCQl0aGlzLmNvbmZpZy5nZXREYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlcigpLmJ1aWxkSm9pbkNvbHVtbkFubm90YXRpb25OYW1lKGNvbHVtblBhaXIuZ2V0QmFzZUNvbHVtbigpKSwKLQkJCXRoaXMuY29uZmlnLmdldERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyKCkuYnVpbGRKb2luQ29sdW1uQW5ub3RhdGlvbk5hbWUoY29sdW1uUGFpci5nZXRSZWZlcmVuY2VkQ29sdW1uKCkpLAotCQkJcHcKLQkJKTsKLQl9Ci0KLQkvKioKLQkgKiAnYmFzZUNvbHVtbk5hbWUnIGNhbm5vdCBiZSBudWxsOwotCSAqICdyZWZlcmVuY2VkQ29sdW1uTmFtZScgaXMgbnVsbCB3aGVuIHRoZSBkZWZhdWx0IGlzIGFwcGxpY2FibGUgKGkuZS4gdGhlCi0JICogcmVmZXJlbmNlZCBjb2x1bW4gaXMgdGhlIHNpbmdsZS1jb2x1bW4gcHJpbWFyeSBrZXkgY29sdW1uIG9mIHRoZQotCSAqIHJlZmVyZW5jZWQgdGFibGUpCi0JICovCi0JcHJpdmF0ZSB2b2lkIHByaW50Sm9pbkNvbHVtbkFubm90YXRpb25PbihTdHJpbmcgYmFzZUNvbHVtbk5hbWUsIFN0cmluZyByZWZlcmVuY2VkQ29sdW1uTmFtZSwgRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCXB3LnByaW50QW5ub3RhdGlvbihKUEEuSk9JTl9DT0xVTU4pOwotCQlwdy5wcmludCgiKG5hbWU9Iik7ICAvLyROT04tTkxTLTEkCi0JCXB3LnByaW50U3RyaW5nTGl0ZXJhbChiYXNlQ29sdW1uTmFtZSk7Ci0KLQkJaWYgKHJlZmVyZW5jZWRDb2x1bW5OYW1lICE9IG51bGwpIHsKLQkJCXB3LnByaW50KCIsIHJlZmVyZW5jZWRDb2x1bW5OYW1lPSIpOyAgLy8kTk9OLU5MUy0xJAotCQkJcHcucHJpbnRTdHJpbmdMaXRlcmFsKHJlZmVyZW5jZWRDb2x1bW5OYW1lKTsKLQkJfQotCi0JCXB3LnByaW50KCcpJyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIG9uZS10by1tYW55IGZpZWxkcyAqKioqKioqKioqCi0KLQlwcml2YXRlIHZvaWQgcHJpbnRFbnRpdHlPbmVUb01hbnlGaWVsZHNPbihFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJZm9yIChJdGVyYXRvcjxPbmVUb01hbnlSZWxhdGlvbj4gc3RyZWFtID0gdGhpcy5nZW5UYWJsZS5vbmVUb01hbnlSZWxhdGlvbnMoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQl0aGlzLnByaW50RW50aXR5T25lVG9NYW55RmllbGRPbihzdHJlYW0ubmV4dCgpLCBwdyk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRFbnRpdHlPbmVUb01hbnlGaWVsZE9uKE9uZVRvTWFueVJlbGF0aW9uIHJlbGF0aW9uLCBFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJU3RyaW5nIGZpZWxkTmFtZSA9IHRoaXMuZ2VuVGFibGUuZ2V0QXR0cmlidXRlTmFtZUZvcihyZWxhdGlvbik7Ci0JCWlmICh0aGlzLmNvbmZpZy5maWVsZEFjY2Vzc1R5cGUoKSkgewotCQkJdGhpcy5wcmludE9uZVRvTWFueUFubm90YXRpb25PbihyZWxhdGlvbiwgcHcpOwotCQl9Ci0JCXRoaXMucHJpbnRDb2xsZWN0aW9uRmllbGRPbihmaWVsZE5hbWUsIHRoaXMuZnVsbHlRdWFsaWZ5KHJlbGF0aW9uLmdldFJlZmVyZW5jZWRFbnRpdHlOYW1lKCkpLCBwdyk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50T25lVG9NYW55QW5ub3RhdGlvbk9uKE9uZVRvTWFueVJlbGF0aW9uIHJlbGF0aW9uLCBFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJcHcucHJpbnRBbm5vdGF0aW9uKEpQQS5PTkVfVE9fTUFOWSk7Ci0JCXB3LnByaW50KCIobWFwcGVkQnk9XCIiKTsgIC8vJE5PTi1OTFMtMSQKLQkJcHcucHJpbnQocmVsYXRpb24uZ2V0TWFwcGVkQnkoKSk7Ci0JCXB3LnByaW50KCJcIikiKTsgIC8vJE5PTi1OTFMtMSQKLQkJcHcucHJpbnRsbigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBvd25lZCBtYW55LXRvLW1hbnkgZmllbGRzICoqKioqKioqKioKLQotCXByaXZhdGUgdm9pZCBwcmludEVudGl0eU93bmVkTWFueVRvTWFueUZpZWxkc09uKEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlmb3IgKEl0ZXJhdG9yPE1hbnlUb01hbnlSZWxhdGlvbj4gIHN0cmVhbSA9IHRoaXMuZ2VuVGFibGUub3duZWRNYW55VG9NYW55UmVsYXRpb25zKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJdGhpcy5wcmludEVudGl0eU93bmVkTWFueVRvTWFueUZpZWxkT24oc3RyZWFtLm5leHQoKSwgcHcpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50RW50aXR5T3duZWRNYW55VG9NYW55RmllbGRPbihNYW55VG9NYW55UmVsYXRpb24gcmVsYXRpb24sIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlTdHJpbmcgZmllbGROYW1lID0gdGhpcy5nZW5UYWJsZS5nZXRBdHRyaWJ1dGVOYW1lRm9yT3duZWQocmVsYXRpb24pOwotCQlpZiAodGhpcy5jb25maWcuZmllbGRBY2Nlc3NUeXBlKCkpIHsKLQkJCXRoaXMucHJpbnRPd25lZE1hbnlUb01hbnlBbm5vdGF0aW9uT24oZmllbGROYW1lLCByZWxhdGlvbiwgcHcpOwotCQl9Ci0JCXRoaXMucHJpbnRDb2xsZWN0aW9uRmllbGRPbihmaWVsZE5hbWUsIHRoaXMuZnVsbHlRdWFsaWZ5KHJlbGF0aW9uLmdldE5vbk93bmluZ0VudGl0eU5hbWUoKSksIHB3KTsKLQl9Ci0KLQkvKioKLQkgKiBvbmx5IHByaW50IHRoZSBKb2luVGFibGUgYW5ub3RhdGlvbiBpZiBvbmUgb3IgbW9yZSBvZiB0aGUKLQkgKiBbZ2VuZXJhdGVkXSBlbGVtZW50cyBpcyBub3QgZGVmYXVsdGVkOgotCSAqICAgICBuYW1lCi0JICogICAgIGpvaW5Db2x1bW5zCi0JICogICAgIGludmVyc2VKb2luQ29sdW1ucwotCSAqIHRodXMgdGhlIG5lZWQgZm9yIHRoZSAncHJpbnRKb2luVGFibGVBbm5vdGF0aW9uJyBmbGFnCi0JICovCi0JcHJpdmF0ZSB2b2lkIHByaW50T3duZWRNYW55VG9NYW55QW5ub3RhdGlvbk9uKFN0cmluZyBhdHRyaWJ1dGVOYW1lLCBNYW55VG9NYW55UmVsYXRpb24gcmVsYXRpb24sIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlwdy5wcmludEFubm90YXRpb24oSlBBLk1BTllfVE9fTUFOWSk7Ci0JCXB3LnByaW50bG4oKTsKLQkJQm9vbGVhbkhvbGRlciBwcmludEpvaW5UYWJsZUFubm90YXRpb24gPSBuZXcgQm9vbGVhbkhvbGRlcih0cnVlKTsKLQotCQlpZiAoICEgcmVsYXRpb24uam9pblRhYmxlTmFtZUlzRGVmYXVsdCgpKSB7ICAvLyBkYi1vbmx5IHRlc3QgLSBubyBuZWVkIHRvIGRlbGVnYXRlIHRvIHBsYXRmb3JtPwotCQkJcHJpbnRKb2luVGFibGVBbm5vdGF0aW9uLnNldEZhbHNlKCk7Ci0JCQlwdy5wcmludEFubm90YXRpb24oSlBBLkpPSU5fVEFCTEUpOwotCQkJcHcucHJpbnQoIihuYW1lPSIpOyAgLy8kTk9OLU5MUy0xJAotCQkJcHcucHJpbnRTdHJpbmdMaXRlcmFsKHRoaXMuY29uZmlnLmdldERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyKCkuYnVpbGRKb2luVGFibGVBbm5vdGF0aW9uTmFtZShyZWxhdGlvbi5nZXRKb2luR2VuVGFibGUoKS5nZXRUYWJsZSgpKSk7Ci0JCX0KLQotCQl0aGlzLnByaW50Sm9pblRhYmxlSm9pbkNvbHVtbkFubm90YXRpb25zT24oCi0JCQkJImpvaW5Db2x1bW5zIiwgIC8vJE5PTi1OTFMtMSQKLQkJCQlhdHRyaWJ1dGVOYW1lLAotCQkJCXJlbGF0aW9uLmdldE93bmluZ0ZvcmVpZ25LZXkoKSwKLQkJCQlwcmludEpvaW5UYWJsZUFubm90YXRpb24sCi0JCQkJcHcKLQkJKTsKLQotCQl0aGlzLnByaW50Sm9pblRhYmxlSm9pbkNvbHVtbkFubm90YXRpb25zT24oCi0JCQkJImludmVyc2VKb2luQ29sdW1ucyIsICAvLyROT04tTkxTLTEkCi0JCQkJcmVsYXRpb24uZ2V0Tm9uT3duaW5nR2VuVGFibGUoKS5nZXRBdHRyaWJ1dGVOYW1lRm9yTm9uT3duZWQocmVsYXRpb24pLAotCQkJCXJlbGF0aW9uLmdldE5vbk93bmluZ0ZvcmVpZ25LZXkoKSwKLQkJCQlwcmludEpvaW5UYWJsZUFubm90YXRpb24sCi0JCQkJcHcKLQkJKTsKLQotCQlpZiAocHJpbnRKb2luVGFibGVBbm5vdGF0aW9uLmlzRmFsc2UoKSkgewotCQkJcHcucHJpbnQoJyknKTsKLQkJCXB3LnByaW50bG4oKTsKLQkJfQotCX0KLQotCS8qKgotCSAqICdlbGVtZW50TmFtZScgaXMgZWl0aGVyICJqb2luQ29sdW1ucyIgb3IgImludmVyc2VKb2luQ29sdW1ucyIKLQkgKi8KLQlwcml2YXRlIHZvaWQgcHJpbnRKb2luVGFibGVKb2luQ29sdW1uQW5ub3RhdGlvbnNPbihTdHJpbmcgZWxlbWVudE5hbWUsIFN0cmluZyBhdHRyaWJ1dGVOYW1lLCBGb3JlaWduS2V5IGZvcmVpZ25LZXksIEJvb2xlYW5Ib2xkZXIgcHJpbnRKb2luVGFibGVBbm5vdGF0aW9uLCBFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJLy8gd2UgaGF2ZSB0byBwcmUtY2FsY3VsYXRlIHdoZXRoZXIgZWl0aGVyICduYW1lJyBhbmQvb3IgJ3JlZmVyZW5jZWRDb2x1bW5OYW1lJwotCQkvLyBpcyByZXF1aXJlZCBiZWNhdXNlIHRoZXkgYXJlIHdyYXBwZWQgYnkgdGhlIEpvaW5UYWJsZSBhbm5vdGF0aW9uIGFuZCB3ZQotCQkvLyBuZWVkIHRvIHByaW50IHRoZSBKb2luVGFibGUgYW5ub3RhdGlvbiBmaXJzdCAoaWYgaXQgaGFzbid0IGFscmVhZHkgYmVlbiBwcmludGVkKQotCQlib29sZWFuIHByaW50UmVmID0gISBmb3JlaWduS2V5LnJlZmVyZW5jZXNTaW5nbGVDb2x1bW5QcmltYXJ5S2V5KCk7Ci0JCS8vIGlmICdyZWZlcmVuY2VkQ29sdW1uTmFtZScgaXMgcmVxdWlyZWQsICduYW1lJyBpcyBhbHNvIHJlcXVpcmVkIChpLmUuIGl0IGNhbm5vdCBiZSBkZWZhdWx0ZWQpOwotCQkvLyBidXQgd2Ugd2lsbCBjYWxjdWxhdGUgaXQgbGF0ZXIgWzFdLCBzaW5jZSB0aGVyZSBjb3VsZCBiZSBtdWx0aXBsZSBqb2luIGNvbHVtbnMKLQkJU3RyaW5nIGpvaW5Db2x1bW5OYW1lID0gKHByaW50UmVmKSA/Ci0JCQkJCW51bGwgIC8vICdqb2luQ29sdW1uTmFtZScgaXMgbm90IHVzZWQKLQkJCQk6Ci0JCQkJCXRoaXMuY29uZmlnLmdldERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyKCkuYnVpbGRKb2luQ29sdW1uQW5ub3RhdGlvbk5hbWUoYXR0cmlidXRlTmFtZSwgZm9yZWlnbktleSk7Ci0JCWJvb2xlYW4gcHJpbnRCYXNlID0gKHByaW50UmVmIHx8IChqb2luQ29sdW1uTmFtZSAhPSBudWxsKSk7Ci0JCWlmIChwcmludEJhc2UgfHwgcHJpbnRSZWYpIHsKLQkJCWlmIChwcmludEpvaW5UYWJsZUFubm90YXRpb24uaXNUcnVlKCkpIHsKLQkJCQlwcmludEpvaW5UYWJsZUFubm90YXRpb24uc2V0RmFsc2UoKTsKLQkJCQlwdy5wcmludEFubm90YXRpb24oSlBBLkpPSU5fVEFCTEUpOwotCQkJCXB3LnByaW50KCcoJyk7Ci0JCQl9IGVsc2UgewotCQkJCXB3LnByaW50KCcsJyk7Ci0JCQl9Ci0JCQlwdy5wcmludGxuKCk7Ci0JCQlwdy5pbmRlbnQoKTsKLQkJCQlpZiAocHJpbnRSZWYpIHsKLQkJCQkJLy8gaWYgJ3ByaW50UmVmJyBpcyB0cnVlLCAnam9pbkNvbHVtbk5hbWUnIHdpbGwgYWx3YXlzIGJlICJJR05PUkVEIiAoc28gd2UgaWdub3JlIGl0KQotCQkJCQl0aGlzLnByaW50Sm9pblRhYmxlSm9pbkNvbHVtbkFubm90YXRpb25zT24oZWxlbWVudE5hbWUsIGZvcmVpZ25LZXksIHB3KTsgIC8vIFsxXQotCQkJCX0gZWxzZSB7Ci0JCQkJCS8vIGlmIHRoZSBGSyByZWZlcmVuY2VzIGEgc2luZ2xlLWNvbHVtbiBQSywgJ3JlZmVyZW5jZWRDb2x1bW5OYW1lJyBpcyBub3QgcmVxdWlyZWQKLQkJCQkJaWYgKHByaW50QmFzZSkgewotCQkJCQkJLy8gdGhlcmUgaXMgb25seSBhIHNpbmdsZSBqb2luIGNvbHVtbiBoZXJlIChqdXN0IG5vdCB0aGUgZGVmYXVsdCBuYW1lKQotCQkJCQkJcHcucHJpbnQoZWxlbWVudE5hbWUpOwotCQkJCQkJcHcucHJpbnQoJz0nKTsKLQkJCQkJCXRoaXMucHJpbnRKb2luQ29sdW1uQW5ub3RhdGlvbk9uKGpvaW5Db2x1bW5OYW1lLCBudWxsLCBwdyk7Ci0JCQkJCX0gZWxzZSB7Ci0JCQkJCQkvLyBubyBKb2luQ29sdW1uIGFubm90YXRpb24gbmVlZGVkOiB0aGUgZGVmYXVsdCAnbmFtZScgYW5kICdyZWZlcmVuY2VkQ29sdW1uTmFtZScgd29yawotCQkJCQl9Ci0JCQkJfQotCQkJcHcudW5kZW50KCk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiAnZWxlbWVudE5hbWUnIGlzIGVpdGhlciAiam9pbkNvbHVtbnMiIG9yICJpbnZlcnNlSm9pbkNvbHVtbnMiCi0JICovCi0JcHJpdmF0ZSB2b2lkIHByaW50Sm9pblRhYmxlSm9pbkNvbHVtbkFubm90YXRpb25zT24oU3RyaW5nIGVsZW1lbnROYW1lLCBGb3JlaWduS2V5IGZvcmVpZ25LZXksIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlwdy5wcmludChlbGVtZW50TmFtZSk7Ci0JCXB3LnByaW50KCc9Jyk7Ci0JCWlmIChmb3JlaWduS2V5LmNvbHVtblBhaXJzU2l6ZSgpID4gMSkgewotCQkJcHcucHJpbnQoJ3snKTsKLQkJCXB3LnByaW50bG4oKTsKLQkJCXB3LmluZGVudCgpOwotCQl9Ci0JCXRoaXMucHJpbnRKb2luQ29sdW1uQW5ub3RhdGlvbnNPbihmb3JlaWduS2V5LCBwdyk7Ci0JCWlmIChmb3JlaWduS2V5LmNvbHVtblBhaXJzU2l6ZSgpID4gMSkgewotCQkJcHcudW5kZW50KCk7Ci0JCQlwdy5wcmludGxuKCk7Ci0JCQlwdy5wcmludCgnfScpOwotCQkJcHcucHJpbnRsbigpOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIG5vbi1vd25lZCBtYW55LXRvLW1hbnkgZmllbGRzICoqKioqKioqKioKLQotCXByaXZhdGUgdm9pZCBwcmludEVudGl0eU5vbk93bmVkTWFueVRvTWFueUZpZWxkc09uKEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlmb3IgKEl0ZXJhdG9yPE1hbnlUb01hbnlSZWxhdGlvbj4gc3RyZWFtID0gdGhpcy5nZW5UYWJsZS5ub25Pd25lZE1hbnlUb01hbnlSZWxhdGlvbnMoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQl0aGlzLnByaW50RW50aXR5Tm9uT3duZWRNYW55VG9NYW55RmllbGRPbihzdHJlYW0ubmV4dCgpLCBwdyk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRFbnRpdHlOb25Pd25lZE1hbnlUb01hbnlGaWVsZE9uKE1hbnlUb01hbnlSZWxhdGlvbiByZWxhdGlvbiwgRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCVN0cmluZyBmaWVsZE5hbWUgPSB0aGlzLmdlblRhYmxlLmdldEF0dHJpYnV0ZU5hbWVGb3JOb25Pd25lZChyZWxhdGlvbik7Ci0JCWlmICh0aGlzLmNvbmZpZy5maWVsZEFjY2Vzc1R5cGUoKSkgewotCQkJdGhpcy5wcmludE5vbk93bmVkTWFueVRvTWFueUFubm90YXRpb25PbihyZWxhdGlvbiwgcHcpOwotCQl9Ci0JCXRoaXMucHJpbnRDb2xsZWN0aW9uRmllbGRPbihmaWVsZE5hbWUsIHRoaXMuZnVsbHlRdWFsaWZ5KHJlbGF0aW9uLmdldE93bmluZ0VudGl0eU5hbWUoKSksIHB3KTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnROb25Pd25lZE1hbnlUb01hbnlBbm5vdGF0aW9uT24oTWFueVRvTWFueVJlbGF0aW9uIHJlbGF0aW9uLCBFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJcHcucHJpbnRBbm5vdGF0aW9uKEpQQS5NQU5ZX1RPX01BTlkpOwotCQlwdy5wcmludCgiKG1hcHBlZEJ5PVwiIik7ICAvLyROT04tTkxTLTEkCi0JCXB3LnByaW50KHJlbGF0aW9uLmdldE1hcHBlZEJ5KCkpOwotCQlwdy5wcmludCgiXCIpIik7ICAvLyROT04tTkxTLTEkCi0JCXB3LnByaW50bG4oKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogbWlzYyAqKioqKioqKioqCi0KLQlwcml2YXRlIHZvaWQgcHJpbnRTZXJpYWxWZXJzaW9uVUlERmllbGRPbihFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJaWYgKHRoaXMuY29uZmlnLmdlbmVyYXRlU2VyaWFsVmVyc2lvblVJRCgpKSB7Ci0JCQlwdy5wcmludCgicHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Iik7ICAvLyROT04tTkxTLTEkCi0JCQlwdy5wcmludGxuKCk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRaZXJvQXJndW1lbnRDb25zdHJ1Y3Rvck9uKFN0cmluZyBjdG9yTmFtZSwgU3RyaW5nIHZpc2liaWxpdHksIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlpZiAodGhpcy5jb25maWcuZ2VuZXJhdGVEZWZhdWx0Q29uc3RydWN0b3IoKSkgewotCQkJcHcucHJpbnRWaXNpYmlsaXR5KHZpc2liaWxpdHkpOwotCQkJcHcucHJpbnQoY3Rvck5hbWUpOwotCQkJcHcucHJpbnQoIigpIHsiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCXB3LnByaW50bG4oKTsKLQkJCXB3LmluZGVudCgpOwotCQkJCXB3LnByaW50bG4oInN1cGVyKCk7Iik7ICAvLyROT04tTkxTLTEkCi0JCQlwdy51bmRlbnQoKTsKLQkJCXB3LnByaW50KCd9Jyk7Ci0JCQlwdy5wcmludGxuKCk7Ci0JCQlwdy5wcmludGxuKCk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogcHJpbWFyeSBrZXkgcHJvcGVydGllcyAqKioqKioqKioqCi0KLQlwcml2YXRlIHZvaWQgcHJpbnRFbnRpdHlQcmltYXJ5S2V5UHJvcGVydGllc09uKEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlpZiAodGhpcy5wcmltYXJ5S2V5Q2xhc3NJc1JlcXVpcmVkKCkgJiYgdGhpcy5jb25maWcuZ2VuZXJhdGVFbWJlZGRlZElkRm9yQ29tcG91bmRQSygpKSB7Ci0JCQl0aGlzLnByaW50RW50aXR5RW1iZWRkZWRJZFByaW1hcnlLZXlQcm9wZXJ0eU9uKHB3KTsKLQkJfSBlbHNlIHsKLQkJCXRoaXMucHJpbnRFbnRpdHlSZWFkT25seVByaW1hcnlLZXlQcm9wZXJ0aWVzT24ocHcpOwotCQkJdGhpcy5wcmludEVudGl0eVdyaXRhYmxlUHJpbWFyeUtleVByb3BlcnRpZXNPbihwdyk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRFbnRpdHlFbWJlZGRlZElkUHJpbWFyeUtleVByb3BlcnR5T24oRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCWlmICh0aGlzLmNvbmZpZy5wcm9wZXJ0eUFjY2Vzc1R5cGUoKSkgewotCQkJcHcucHJpbnRBbm5vdGF0aW9uKEpQQS5FTUJFRERFRF9JRCk7Ci0JCQlwdy5wcmludGxuKCk7Ci0JCX0KLQkJdGhpcy5wcmludFByb3BlcnR5T24odGhpcy5nZW5UYWJsZS5nZXRBdHRyaWJ1dGVOYW1lRm9yRW1iZWRkZWRJZCgpLCB0aGlzLnBrQ2xhc3NOYW1lLCBwdyk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50RW50aXR5UmVhZE9ubHlQcmltYXJ5S2V5UHJvcGVydGllc09uKEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQl0aGlzLnByaW50UHJpbWFyeUtleVByb3BlcnRpZXNPbihwdywgdHJ1ZSwgdHJ1ZSk7ICAvLyB0cnVlPXJlYWQtb25seTsgdHJ1ZT1wcmludCBJRCBhbm5vdGF0aW9uIG9uIGdldHRlcnMKLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRFbnRpdHlXcml0YWJsZVByaW1hcnlLZXlQcm9wZXJ0aWVzT24oRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCXRoaXMucHJpbnRQcmltYXJ5S2V5UHJvcGVydGllc09uKHB3LCBmYWxzZSwgdHJ1ZSk7ICAvLyBmYWxzZT13cml0YWJsZTsgdHJ1ZT1wcmludCBJRCBhbm5vdGF0aW9uIG9uIGdldHRlcnMKLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRQcmltYXJ5S2V5UHJvcGVydGllc09uKEVudGl0eVNvdXJjZVdyaXRlciBwdywgYm9vbGVhbiByZWFkT25seSwgYm9vbGVhbiBwcmludElkQW5ub3RhdGlvbikgewotCQlmb3IgKEl0ZXJhdG9yPENvbHVtbj4gc3RyZWFtID0gdGhpcy5wcmltYXJ5S2V5Q29sdW1ucyhyZWFkT25seSk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJdGhpcy5wcmludFByaW1hcnlLZXlQcm9wZXJ0eU9uKHN0cmVhbS5uZXh0KCksIHB3LCByZWFkT25seSwgcHJpbnRJZEFubm90YXRpb24pOwotCQl9Ci0JfQotCi0JLy8gVE9ETyBpZiB0aGUgcHJvcGVydHkncyB0eXBlIGlzIGphdmEudXRpbC9zcWwuRGF0ZSwgaXQgbmVlZHMgQFRlbXBvcmFsKERBVEUpCi0JLy8gVE9ETyBpZiB0aGUgcHJpbWFyeSBrZXkgaXMgYXV0by1nZW5lcmF0ZWQsIHRoZSBwcm9wZXJ0eSBtdXN0IGJlIGFuIGludGVncmFsIHR5cGUKLQlwcml2YXRlIHZvaWQgcHJpbnRQcmltYXJ5S2V5UHJvcGVydHlPbihDb2x1bW4gY29sdW1uLCBFbnRpdHlTb3VyY2VXcml0ZXIgcHcsIGJvb2xlYW4gcmVhZE9ubHksIGJvb2xlYW4gcHJpbnRJZEFubm90YXRpb24pIHsKLQkJU3RyaW5nIHByb3BlcnR5TmFtZSA9IHRoaXMuZ2VuVGFibGUuZ2V0QXR0cmlidXRlTmFtZUZvcihjb2x1bW4pOwotCQlpZiAodGhpcy5jb25maWcucHJvcGVydHlBY2Nlc3NUeXBlKCkpIHsKLQkJCWlmIChwcmludElkQW5ub3RhdGlvbikgewotCQkJCXB3LnByaW50QW5ub3RhdGlvbihKUEEuSUQpOwotCQkJCXB3LnByaW50bG4oKTsKLQkJCX0KLQkJCVN0cmluZyBjb2x1bW5OYW1lID0gdGhpcy5jb25maWcuZ2V0RGF0YWJhc2VBbm5vdGF0aW9uTmFtZUJ1aWxkZXIoKS5idWlsZENvbHVtbkFubm90YXRpb25OYW1lKHByb3BlcnR5TmFtZSwgY29sdW1uKTsKLQkJCWlmIChyZWFkT25seSkgewotCQkJCXRoaXMucHJpbnRSZWFkT25seUNvbHVtbkFubm90YXRpb25Pbihjb2x1bW5OYW1lLCBwdyk7Ci0JCQl9IGVsc2UgewotCQkJCXRoaXMucHJpbnRDb2x1bW5Bbm5vdGF0aW9uT24oY29sdW1uTmFtZSwgcHcpOwotCQkJfQotCQl9Ci0JCXRoaXMucHJpbnRQcm9wZXJ0eU9uKHByb3BlcnR5TmFtZSwgY29sdW1uLmdldFByaW1hcnlLZXlKYXZhVHlwZURlY2xhcmF0aW9uKCksIHB3KTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYmFzaWMgcHJvcGVydGllcyAqKioqKioqKioqCi0KLQlwcml2YXRlIHZvaWQgcHJpbnRFbnRpdHlOb25QcmltYXJ5S2V5QmFzaWNQcm9wZXJ0aWVzT24oRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCWZvciAoSXRlcmF0b3I8Q29sdW1uPiBzdHJlYW0gPSB0aGlzLmdlblRhYmxlLm5vblByaW1hcnlLZXlCYXNpY0NvbHVtbnMoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQl0aGlzLnByaW50RW50aXR5Tm9uUHJpbWFyeUtleUJhc2ljUHJvcGVydHlPbihzdHJlYW0ubmV4dCgpLCBwdyk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRFbnRpdHlOb25QcmltYXJ5S2V5QmFzaWNQcm9wZXJ0eU9uKENvbHVtbiBjb2x1bW4sIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlTdHJpbmcgcHJvcGVydHlOYW1lID0gdGhpcy5nZW5UYWJsZS5nZXRBdHRyaWJ1dGVOYW1lRm9yKGNvbHVtbik7Ci0JCWlmICh0aGlzLmNvbmZpZy5wcm9wZXJ0eUFjY2Vzc1R5cGUoKSkgewotCQkJU3RyaW5nIGNvbHVtbk5hbWUgPSB0aGlzLmNvbmZpZy5nZXREYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlcigpLmJ1aWxkQ29sdW1uQW5ub3RhdGlvbk5hbWUocHJvcGVydHlOYW1lLCBjb2x1bW4pOwotCQkJdGhpcy5wcmludENvbHVtbkFubm90YXRpb25Pbihjb2x1bW5OYW1lLCBwdyk7Ci0JCX0KLQkJdGhpcy5wcmludFByb3BlcnR5T24ocHJvcGVydHlOYW1lLCBjb2x1bW4uZ2V0SmF2YVR5cGVEZWNsYXJhdGlvbigpLCBwdyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIG1hbnktdG8tb25lIHByb3BlcnRpZXMgKioqKioqKioqKgotCi0JcHJpdmF0ZSB2b2lkIHByaW50RW50aXR5TWFueVRvT25lUHJvcGVydGllc09uKEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlmb3IgKEl0ZXJhdG9yPE1hbnlUb09uZVJlbGF0aW9uPiBzdHJlYW0gPSB0aGlzLmdlblRhYmxlLm1hbnlUb09uZVJlbGF0aW9ucygpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCXRoaXMucHJpbnRFbnRpdHlNYW55VG9PbmVQcm9wZXJ0eU9uKHN0cmVhbS5uZXh0KCksIHB3KTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBwcmludEVudGl0eU1hbnlUb09uZVByb3BlcnR5T24oTWFueVRvT25lUmVsYXRpb24gcmVsYXRpb24sIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlTdHJpbmcgcHJvcGVydHlOYW1lID0gdGhpcy5nZW5UYWJsZS5nZXRBdHRyaWJ1dGVOYW1lRm9yKHJlbGF0aW9uKTsKLQkJaWYgKHRoaXMuY29uZmlnLnByb3BlcnR5QWNjZXNzVHlwZSgpKSB7Ci0JCQl0aGlzLnByaW50TWFueVRvT25lQW5ub3RhdGlvbk9uKHByb3BlcnR5TmFtZSwgcmVsYXRpb24sIHB3KTsKLQkJfQotCQlTdHJpbmcgdHlwZURlY2xhcmF0aW9uID0gdGhpcy5mdWxseVF1YWxpZnkocmVsYXRpb24uZ2V0UmVmZXJlbmNlZEVudGl0eU5hbWUoKSk7Ci0JCXRoaXMucHJpbnRQcm9wZXJ0eU9uKHByb3BlcnR5TmFtZSwgdHlwZURlY2xhcmF0aW9uLCBwdyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIG9uZS10by1tYW55IHByb3BlcnRpZXMgKioqKioqKioqKgotCi0JcHJpdmF0ZSB2b2lkIHByaW50RW50aXR5T25lVG9NYW55UHJvcGVydGllc09uKEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlmb3IgKEl0ZXJhdG9yPE9uZVRvTWFueVJlbGF0aW9uPiBzdHJlYW0gPSB0aGlzLmdlblRhYmxlLm9uZVRvTWFueVJlbGF0aW9ucygpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCXRoaXMucHJpbnRFbnRpdHlPbmVUb01hbnlQcm9wZXJ0eU9uKHN0cmVhbS5uZXh0KCksIHB3KTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBwcmludEVudGl0eU9uZVRvTWFueVByb3BlcnR5T24oT25lVG9NYW55UmVsYXRpb24gcmVsYXRpb24sIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlTdHJpbmcgcHJvcGVydHlOYW1lID0gdGhpcy5nZW5UYWJsZS5nZXRBdHRyaWJ1dGVOYW1lRm9yKHJlbGF0aW9uKTsKLQkJaWYgKHRoaXMuY29uZmlnLnByb3BlcnR5QWNjZXNzVHlwZSgpKSB7Ci0JCQl0aGlzLnByaW50T25lVG9NYW55QW5ub3RhdGlvbk9uKHJlbGF0aW9uLCBwdyk7Ci0JCX0KLQkJU3RyaW5nIGVsZW1lbnRUeXBlRGVjbGFyYXRpb24gPSB0aGlzLmZ1bGx5UXVhbGlmeShyZWxhdGlvbi5nZXRSZWZlcmVuY2VkRW50aXR5TmFtZSgpKTsKLQkJdGhpcy5wcmludENvbGxlY3Rpb25Qcm9wZXJ0eU9uKHByb3BlcnR5TmFtZSwgZWxlbWVudFR5cGVEZWNsYXJhdGlvbiwgcHcpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBvd25lZCBtYW55LXRvLW1hbnkgcHJvcGVydGllcyAqKioqKioqKioqCi0KLQlwcml2YXRlIHZvaWQgcHJpbnRFbnRpdHlPd25lZE1hbnlUb01hbnlQcm9wZXJ0aWVzT24oRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCWZvciAoSXRlcmF0b3I8TWFueVRvTWFueVJlbGF0aW9uPiBzdHJlYW0gPSB0aGlzLmdlblRhYmxlLm93bmVkTWFueVRvTWFueVJlbGF0aW9ucygpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCXRoaXMucHJpbnRFbnRpdHlPd25lZE1hbnlUb01hbnlQcm9wZXJ0eU9uKHN0cmVhbS5uZXh0KCksIHB3KTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBwcmludEVudGl0eU93bmVkTWFueVRvTWFueVByb3BlcnR5T24oTWFueVRvTWFueVJlbGF0aW9uIHJlbGF0aW9uLCBFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJU3RyaW5nIHByb3BlcnR5TmFtZSA9IHRoaXMuZ2VuVGFibGUuZ2V0QXR0cmlidXRlTmFtZUZvck93bmVkKHJlbGF0aW9uKTsKLQkJaWYgKHRoaXMuY29uZmlnLnByb3BlcnR5QWNjZXNzVHlwZSgpKSB7Ci0JCQl0aGlzLnByaW50T3duZWRNYW55VG9NYW55QW5ub3RhdGlvbk9uKHByb3BlcnR5TmFtZSwgcmVsYXRpb24sIHB3KTsKLQkJfQotCQlTdHJpbmcgZWxlbWVudFR5cGVEZWNsYXJhdGlvbiA9IHRoaXMuZnVsbHlRdWFsaWZ5KHJlbGF0aW9uLmdldE5vbk93bmluZ0VudGl0eU5hbWUoKSk7Ci0JCXRoaXMucHJpbnRDb2xsZWN0aW9uUHJvcGVydHlPbihwcm9wZXJ0eU5hbWUsIGVsZW1lbnRUeXBlRGVjbGFyYXRpb24sIHB3KTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogbm9uLW93bmVkIG1hbnktdG8tbWFueSBwcm9wZXJ0aWVzICoqKioqKioqKioKLQotCXByaXZhdGUgdm9pZCBwcmludEVudGl0eU5vbk93bmVkTWFueVRvTWFueVByb3BlcnRpZXNPbihFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJZm9yIChJdGVyYXRvcjxNYW55VG9NYW55UmVsYXRpb24+IHN0cmVhbSA9IHRoaXMuZ2VuVGFibGUubm9uT3duZWRNYW55VG9NYW55UmVsYXRpb25zKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJdGhpcy5wcmludEVudGl0eU5vbk93bmVkTWFueVRvTWFueVByb3BlcnR5T24oc3RyZWFtLm5leHQoKSwgcHcpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50RW50aXR5Tm9uT3duZWRNYW55VG9NYW55UHJvcGVydHlPbihNYW55VG9NYW55UmVsYXRpb24gcmVsYXRpb24sIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlTdHJpbmcgcHJvcGVydHlOYW1lID0gdGhpcy5nZW5UYWJsZS5nZXRBdHRyaWJ1dGVOYW1lRm9yTm9uT3duZWQocmVsYXRpb24pOwotCQlpZiAodGhpcy5jb25maWcucHJvcGVydHlBY2Nlc3NUeXBlKCkpIHsKLQkJCXRoaXMucHJpbnROb25Pd25lZE1hbnlUb01hbnlBbm5vdGF0aW9uT24ocmVsYXRpb24sIHB3KTsKLQkJfQotCQlTdHJpbmcgZWxlbWVudFR5cGVEZWNsYXJhdGlvbiA9IHRoaXMuZnVsbHlRdWFsaWZ5KHJlbGF0aW9uLmdldE93bmluZ0VudGl0eU5hbWUoKSk7Ci0JCXRoaXMucHJpbnRDb2xsZWN0aW9uUHJvcGVydHlPbihwcm9wZXJ0eU5hbWUsIGVsZW1lbnRUeXBlRGVjbGFyYXRpb24sIHB3KTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY29tcG91bmQgcHJpbWFyeSBrZXkgY2xhc3MgKioqKioqKioqKgotCi0JcHJpdmF0ZSB2b2lkIHByaW50UHJpbWFyeUtleUNsYXNzT24oRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCXB3LnByaW50bG4oKTsKLQkJaWYgKHRoaXMuY29uZmlnLmdlbmVyYXRlRW1iZWRkZWRJZEZvckNvbXBvdW5kUEsoKSkgewotCQkJcHcucHJpbnRBbm5vdGF0aW9uKEpQQS5FTUJFRERBQkxFKTsKLQkJCXB3LnByaW50bG4oKTsKLQkJfQotCQlwdy5wcmludCgicHVibGljIHN0YXRpYyBjbGFzcyAiKTsgIC8vJE5PTi1OTFMtMSQKLQkJcHcucHJpbnQodGhpcy5jb25maWcuZ2V0UHJpbWFyeUtleU1lbWJlckNsYXNzTmFtZSgpKTsKLQkJcHcucHJpbnQoIiBpbXBsZW1lbnRzICIpOyAgLy8kTk9OLU5MUy0xJAotCQlwdy5wcmludFR5cGVEZWNsYXJhdGlvbihTZXJpYWxpemFibGUuY2xhc3MuZ2V0TmFtZSgpKTsKLQkJcHcucHJpbnQoIiB7Iik7ICAvLyROT04tTkxTLTEkCi0JCXB3LnByaW50bG4oKTsKLQotCQlwdy5pbmRlbnQoKTsKLQkJCWlmICh0aGlzLmNvbmZpZy5nZW5lcmF0ZUVtYmVkZGVkSWRGb3JDb21wb3VuZFBLKCkpIHsKLQkJCQl0aGlzLnByaW50RW1iZWRkYWJsZVJlYWRPbmx5UHJpbWFyeUtleUZpZWxkc09uKHB3KTsKLQkJCQl0aGlzLnByaW50RW1iZWRkYWJsZVdyaXRhYmxlUHJpbWFyeUtleUZpZWxkc09uKHB3KTsKLQkJCX0gZWxzZSB7Ci0JCQkJdGhpcy5wcmludElkRmllbGRzT24ocHcpOwotCQkJfQotCQkJdGhpcy5wcmludFNlcmlhbFZlcnNpb25VSURGaWVsZE9uKHB3KTsKLQkJCXB3LnByaW50bG4oKTsKLQkJCXRoaXMucHJpbnRaZXJvQXJndW1lbnRDb25zdHJ1Y3Rvck9uKHRoaXMuY29uZmlnLmdldFByaW1hcnlLZXlNZW1iZXJDbGFzc05hbWUoKSwgInB1YmxpYyIsIHB3KTsgIC8vJE5PTi1OTFMtMSQKLQotCQkJaWYgKHRoaXMuY29uZmlnLnByb3BlcnR5QWNjZXNzVHlwZSgpIHx8IHRoaXMuY29uZmlnLmdlbmVyYXRlR2V0dGVyc0FuZFNldHRlcnMoKSkgewotCQkJCWlmICh0aGlzLmNvbmZpZy5nZW5lcmF0ZUVtYmVkZGVkSWRGb3JDb21wb3VuZFBLKCkpIHsKLQkJCQkJdGhpcy5wcmludEVtYmVkZGFibGVSZWFkT25seVByaW1hcnlLZXlQcm9wZXJ0aWVzT24ocHcpOwotCQkJCQl0aGlzLnByaW50RW1iZWRkYWJsZVdyaXRhYmxlUHJpbWFyeUtleVByb3BlcnRpZXNPbihwdyk7Ci0JCQkJfSBlbHNlIHsKLQkJCQkJdGhpcy5wcmludElkUHJvcGVydGllc09uKHB3KTsKLQkJCQl9Ci0JCQl9Ci0KLQkJCXRoaXMucHJpbnRQcmltYXJ5S2V5RXF1YWxzTWV0aG9kT24odGhpcy5jb25maWcuZ2V0UHJpbWFyeUtleU1lbWJlckNsYXNzTmFtZSgpLCB0aGlzLmdldFRhYmxlKCkucHJpbWFyeUtleUNvbHVtbnMoKSwgcHcpOwotCQkJdGhpcy5wcmludFByaW1hcnlLZXlIYXNoQ29kZU1ldGhvZE9uKHRoaXMuZ2V0VGFibGUoKS5wcmltYXJ5S2V5Q29sdW1ucygpLCBwdyk7Ci0JCXB3LnVuZGVudCgpOwotCi0JCXB3LnByaW50KCd9Jyk7Ci0JCXB3LnByaW50bG4oKTsKLQkJcHcucHJpbnRsbigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBjb21wb3VuZCBwcmltYXJ5IGtleSBjbGFzcyBmaWVsZHMgKioqKioqKioqKgotCi0JcHJpdmF0ZSB2b2lkIHByaW50RW1iZWRkYWJsZVJlYWRPbmx5UHJpbWFyeUtleUZpZWxkc09uKEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQl0aGlzLnByaW50UHJpbWFyeUtleUZpZWxkc09uKHB3LCB0cnVlLCBmYWxzZSk7ICAvLyB0cnVlPXJlYWQtb25seTsgZmFsc2U9ZG8gbm90IHByaW50IElEIGFubm90YXRpb24gb24gZmllbGRzCi0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50RW1iZWRkYWJsZVdyaXRhYmxlUHJpbWFyeUtleUZpZWxkc09uKEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQl0aGlzLnByaW50UHJpbWFyeUtleUZpZWxkc09uKHB3LCBmYWxzZSwgZmFsc2UpOyAgLy8gZmFsc2U9d3JpdGFibGU7IGZhbHNlPWRvIG5vdCBwcmludCBJRCBhbm5vdGF0aW9uIG9uIGZpZWxkcwotCX0KLQotCXByaXZhdGUgdm9pZCBwcmludElkRmllbGRzT24oRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCWZvciAoSXRlcmF0b3I8Q29sdW1uPiBzdHJlYW0gPSB0aGlzLmdldFRhYmxlKCkucHJpbWFyeUtleUNvbHVtbnMoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQl0aGlzLnByaW50SWRGaWVsZE9uKHN0cmVhbS5uZXh0KCksIHB3KTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBwcmludElkRmllbGRPbihDb2x1bW4gY29sdW1uLCBFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJdGhpcy5wcmludEZpZWxkT24odGhpcy5nZW5UYWJsZS5nZXRBdHRyaWJ1dGVOYW1lRm9yKGNvbHVtbiksIGNvbHVtbi5nZXRQcmltYXJ5S2V5SmF2YVR5cGVEZWNsYXJhdGlvbigpLCBwdyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbXBvdW5kIHByaW1hcnkga2V5IGNsYXNzIHByb3BlcnRpZXMgKioqKioqKioqKgotCi0JcHJpdmF0ZSB2b2lkIHByaW50RW1iZWRkYWJsZVJlYWRPbmx5UHJpbWFyeUtleVByb3BlcnRpZXNPbihFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJdGhpcy5wcmludFByaW1hcnlLZXlQcm9wZXJ0aWVzT24ocHcsIHRydWUsIGZhbHNlKTsgIC8vIHRydWU9cmVhZC1vbmx5OyBmYWxzZT1kbyBub3QgcHJpbnQgSUQgYW5ub3RhdGlvbiBvbiBnZXR0ZXJzCi0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50RW1iZWRkYWJsZVdyaXRhYmxlUHJpbWFyeUtleVByb3BlcnRpZXNPbihFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJdGhpcy5wcmludFByaW1hcnlLZXlQcm9wZXJ0aWVzT24ocHcsIGZhbHNlLCBmYWxzZSk7ICAvLyBmYWxzZT13cml0YWJsZTsgZmFsc2U9ZG8gbm90IHByaW50IElEIGFubm90YXRpb24gb24gZ2V0dGVycwotCX0KLQotCXByaXZhdGUgdm9pZCBwcmludElkUHJvcGVydGllc09uKEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlmb3IgKEl0ZXJhdG9yPENvbHVtbj4gc3RyZWFtID0gdGhpcy5nZXRUYWJsZSgpLnByaW1hcnlLZXlDb2x1bW5zKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJdGhpcy5wcmludElkUHJvcGVydHlPbihzdHJlYW0ubmV4dCgpLCBwdyk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRJZFByb3BlcnR5T24oQ29sdW1uIGNvbHVtbiwgRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCXRoaXMucHJpbnRQcm9wZXJ0eU9uKHRoaXMuZ2VuVGFibGUuZ2V0QXR0cmlidXRlTmFtZUZvcihjb2x1bW4pLCBjb2x1bW4uZ2V0UHJpbWFyeUtleUphdmFUeXBlRGVjbGFyYXRpb24oKSwgcHcpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBjb21wb3VuZCBwcmltYXJ5IGtleSBjbGFzcyBlcXVhbHMgKioqKioqKioqKgotCi0JcHJpdmF0ZSB2b2lkIHByaW50UHJpbWFyeUtleUVxdWFsc01ldGhvZE9uKFN0cmluZyBjbGFzc05hbWUsIEl0ZXJhdG9yPENvbHVtbj4gY29sdW1ucywgRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCXB3LnByaW50QW5ub3RhdGlvbigiamF2YS5sYW5nLk92ZXJyaWRlIik7ICAvLyROT04tTkxTLTEkCi0JCXB3LnByaW50bG4oKTsKLQotCQlwdy5wcmludGxuKCJwdWJsaWMgYm9vbGVhbiBlcXVhbHMoT2JqZWN0IG8pIHsiKTsgIC8vJE5PTi1OTFMtMSQKLQkJcHcuaW5kZW50KCk7Ci0JCQlwdy5wcmludGxuKCJpZiAobyA9PSB0aGlzKSB7Iik7ICAvLyROT04tTkxTLTEkCi0JCQlwdy5pbmRlbnQoKTsKLQkJCQlwdy5wcmludGxuKCJyZXR1cm4gdHJ1ZTsiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCXB3LnVuZGVudCgpOwotCQkJcHcucHJpbnQoJ30nKTsKLQkJCXB3LnByaW50bG4oKTsKLQotCQkJcHcucHJpbnQoImlmICggISAobyBpbnN0YW5jZW9mICIpOyAgLy8kTk9OLU5MUy0xJAotCQkJcHcucHJpbnQoY2xhc3NOYW1lKTsKLQkJCXB3LnByaW50KCIpKSB7Iik7ICAvLyROT04tTkxTLTEkCi0JCQlwdy5wcmludGxuKCk7Ci0JCQlwdy5pbmRlbnQoKTsKLQkJCQlwdy5wcmludGxuKCJyZXR1cm4gZmFsc2U7Iik7ICAvLyROT04tTkxTLTEkCi0JCQlwdy51bmRlbnQoKTsKLQkJCXB3LnByaW50KCd9Jyk7Ci0JCQlwdy5wcmludGxuKCk7Ci0KLQkJCXB3LnByaW50KGNsYXNzTmFtZSk7Ci0JCQlwdy5wcmludCgiIG90aGVyID0gKCIpOyAgLy8kTk9OLU5MUy0xJAotCQkJcHcucHJpbnQoY2xhc3NOYW1lKTsKLQkJCXB3LnByaW50KCIpIG87Iik7ICAvLyROT04tTkxTLTEkCi0JCQlwdy5wcmludGxuKCk7Ci0KLQkJCXB3LnByaW50KCJyZXR1cm4gIik7ICAvLyROT04tTkxTLTEkCi0JCQlwdy5pbmRlbnQoKTsKLQkJCQl3aGlsZSAoY29sdW1ucy5oYXNOZXh0KCkpIHsKLQkJCQkJdGhpcy5wcmludFByaW1hcnlLZXlFcXVhbHNDbGF1c2VPbihjb2x1bW5zLm5leHQoKSwgcHcpOwotCQkJCQlpZiAoY29sdW1ucy5oYXNOZXh0KCkpIHsKLQkJCQkJCXB3LnByaW50bG4oKTsKLQkJCQkJCXB3LnByaW50KCImJiAiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCQkJfQotCQkJCX0KLQkJCQlwdy5wcmludCgnOycpOwotCQkJCXB3LnByaW50bG4oKTsKLQkJCXB3LnVuZGVudCgpOwotCQlwdy51bmRlbnQoKTsKLQkJcHcucHJpbnQoJ30nKTsKLQkJcHcucHJpbnRsbigpOwotCQlwdy5wcmludGxuKCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50UHJpbWFyeUtleUVxdWFsc0NsYXVzZU9uKENvbHVtbiBjb2x1bW4sIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlTdHJpbmcgZmllbGROYW1lID0gdGhpcy5nZW5UYWJsZS5nZXRBdHRyaWJ1dGVOYW1lRm9yKGNvbHVtbik7Ci0JCUphdmFUeXBlIGphdmFUeXBlID0gY29sdW1uLmdldFByaW1hcnlLZXlKYXZhVHlwZSgpOwotCQlpZiAoamF2YVR5cGUuaXNQcmltaXRpdmUoKSkgewotCQkJdGhpcy5wcmludFByaW1pdGl2ZUVxdWFsc0NsYXVzZU9uKGZpZWxkTmFtZSwgcHcpOwotCQl9IGVsc2UgewotCQkJdGhpcy5wcmludFJlZmVyZW5jZUVxdWFsc0NsYXVzZU9uKGZpZWxkTmFtZSwgcHcpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50UHJpbWl0aXZlRXF1YWxzQ2xhdXNlT24oU3RyaW5nIGZpZWxkTmFtZSwgRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCXB3LnByaW50KCIodGhpcy4iKTsgIC8vJE5PTi1OTFMtMSQKLQkJcHcucHJpbnQoZmllbGROYW1lKTsKLQkJcHcucHJpbnQoIiA9PSBvdGhlci4iKTsgIC8vJE5PTi1OTFMtMSQKLQkJcHcucHJpbnQoZmllbGROYW1lKTsKLQkJcHcucHJpbnQoJyknKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRSZWZlcmVuY2VFcXVhbHNDbGF1c2VPbihTdHJpbmcgZmllbGROYW1lLCBFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJcHcucHJpbnQoInRoaXMuIik7ICAvLyROT04tTkxTLTEkCi0JCXB3LnByaW50KGZpZWxkTmFtZSk7Ci0JCXB3LnByaW50KCIuZXF1YWxzKG90aGVyLiIpOyAgLy8kTk9OLU5MUy0xJAotCQlwdy5wcmludChmaWVsZE5hbWUpOwotCQlwdy5wcmludCgnKScpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBjb21wb3VuZCBwcmltYXJ5IGtleSBjbGFzcyBoYXNoIGNvZGUgKioqKioqKioqKgotCi0JcHJpdmF0ZSB2b2lkIHByaW50UHJpbWFyeUtleUhhc2hDb2RlTWV0aG9kT24oSXRlcmF0b3I8Q29sdW1uPiBjb2x1bW5zLCBFbnRpdHlTb3VyY2VXcml0ZXIgcHcpIHsKLQkJcHcucHJpbnRBbm5vdGF0aW9uKCJqYXZhLmxhbmcuT3ZlcnJpZGUiKTsgIC8vJE5PTi1OTFMtMSQKLQkJcHcucHJpbnRsbigpOwotCi0JCXB3LnByaW50bG4oInB1YmxpYyBpbnQgaGFzaENvZGUoKSB7Iik7ICAvLyROT04tTkxTLTEkCi0JCXB3LmluZGVudCgpOwotCQkJcHcucHJpbnRsbigiZmluYWwgaW50IHByaW1lID0gMzE7Iik7ICAvLyROT04tTkxTLTEkCi0JCQlwdy5wcmludGxuKCJpbnQgaGFzaCA9IDE3OyIpOyAgLy8kTk9OLU5MUy0xJAotCQkJd2hpbGUgKGNvbHVtbnMuaGFzTmV4dCgpKSB7Ci0JCQkJcHcucHJpbnQoImhhc2ggPSBoYXNoICogcHJpbWUgKyAiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCQl0aGlzLnByaW50UHJpbWFyeUtleUhhc2hDb2RlQ2xhdXNlT24oY29sdW1ucy5uZXh0KCksIHB3KTsKLQkJCQlwdy5wcmludCgnOycpOwotCQkJCXB3LnByaW50bG4oKTsKLQkJCX0KLQkJCXB3LnByaW50bG4oInJldHVybiBoYXNoOyIpOyAgLy8kTk9OLU5MUy0xJAotCQlwdy51bmRlbnQoKTsKLQkJcHcucHJpbnQoJ30nKTsKLQkJcHcucHJpbnRsbigpOwotCQlwdy5wcmludGxuKCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHByaW50UHJpbWFyeUtleUhhc2hDb2RlQ2xhdXNlT24oQ29sdW1uIGNvbHVtbiwgRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCVN0cmluZyBmaWVsZE5hbWUgPSB0aGlzLmdlblRhYmxlLmdldEF0dHJpYnV0ZU5hbWVGb3IoY29sdW1uKTsKLQkJSmF2YVR5cGUgamF2YVR5cGUgPSBjb2x1bW4uZ2V0UHJpbWFyeUtleUphdmFUeXBlKCk7Ci0JCWlmIChqYXZhVHlwZS5pc1ByaW1pdGl2ZSgpKSB7Ci0JCQl0aGlzLnByaW50UHJpbWl0aXZlSGFzaENvZGVDbGF1c2VPbihqYXZhVHlwZS5nZXRFbGVtZW50VHlwZU5hbWUoKSwgZmllbGROYW1lLCBwdyk7Ci0JCX0gZWxzZSB7Ci0JCQl0aGlzLnByaW50UmVmZXJlbmNlSGFzaENvZGVDbGF1c2VPbihmaWVsZE5hbWUsIHB3KTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBwcmludFByaW1pdGl2ZUhhc2hDb2RlQ2xhdXNlT24oU3RyaW5nIHByaW1pdGl2ZU5hbWUsIFN0cmluZyBmaWVsZE5hbWUsIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlpZiAocHJpbWl0aXZlTmFtZS5lcXVhbHMoImludCIpKSB7ICAvLyROT04tTkxTLTEkCi0JCQkvLyB0aGlzLnZhbHVlCi0JCQlwdy5wcmludCgidGhpcy4iKTsgIC8vJE5PTi1OTFMtMSQKLQkJCXB3LnByaW50KGZpZWxkTmFtZSk7Ci0JCX0gZWxzZSBpZiAocHJpbWl0aXZlTmFtZS5lcXVhbHMoInNob3J0IikgIC8vJE5PTi1OTFMtMSQKLQkJCQl8fCBwcmltaXRpdmVOYW1lLmVxdWFscygiYnl0ZSIpICAvLyROT04tTkxTLTEkCi0JCQkJfHwgcHJpbWl0aXZlTmFtZS5lcXVhbHMoImNoYXIiKSkgeyAgLy8kTk9OLU5MUy0xJAotCQkJLy8gKChpbnQpIHRoaXMudmFsdWUpICAtIGV4cGxpY2l0IGNhc3QKLQkJCXB3LnByaW50KCIoKGludCkgdGhpcy4iKTsgIC8vJE5PTi1OTFMtMSQKLQkJCXB3LnByaW50KGZpZWxkTmFtZSk7Ci0JCQlwdy5wcmludCgnKScpOwotCQl9IGVsc2UgaWYgKHByaW1pdGl2ZU5hbWUuZXF1YWxzKCJsb25nIikpIHsgIC8vIGNyaWJiZWQgZnJvbSBMb25nI2hhc2hDb2RlKCkgIC8vJE5PTi1OTFMtMSQKLQkJCS8vICgoaW50KSAodGhpcy52YWx1ZSBeICh0aGlzLnZhbHVlID4+PiAzMikpKQotCQkJcHcucHJpbnQoIigoaW50KSAodGhpcy4iKTsgIC8vJE5PTi1OTFMtMSQKLQkJCXB3LnByaW50KGZpZWxkTmFtZSk7Ci0JCQlwdy5wcmludCgiIF4gKHRoaXMuIik7ICAvLyROT04tTkxTLTEkCi0JCQlwdy5wcmludChmaWVsZE5hbWUpOwotCQkJcHcucHJpbnQoIiA+Pj4gMzIpKSkiKTsgIC8vJE5PTi1OTFMtMSQKLQkJfSBlbHNlIGlmIChwcmltaXRpdmVOYW1lLmVxdWFscygiZmxvYXQiKSkgeyAgLy8gY3JpYmJlZCBmcm9tIEZsb2F0I2hhc2hDb2RlKCkgIC8vJE5PTi1OTFMtMSQKLQkJCS8vIGphdmEubGFuZy5GbG9hdC5mbG9hdFRvSW50Qml0cyh0aGlzLnZhbHVlKQotCQkJcHcucHJpbnRUeXBlRGVjbGFyYXRpb24oImphdmEubGFuZy5GbG9hdCIpOyAgLy8kTk9OLU5MUy0xJAotCQkJcHcucHJpbnQoIi5mbG9hdFRvSW50Qml0cyh0aGlzLiIpOyAgLy8kTk9OLU5MUy0xJAotCQkJcHcucHJpbnQoZmllbGROYW1lKTsKLQkJCXB3LnByaW50KCcpJyk7Ci0JCX0gZWxzZSBpZiAocHJpbWl0aXZlTmFtZS5lcXVhbHMoImRvdWJsZSIpKSB7ICAvLyBjcmliYmVkIGZyb20gRG91YmxlI2hhc2hDb2RlKCkgIC8vJE5PTi1OTFMtMSQKLQkJCS8vCSgoaW50KSAoamF2YS5sYW5nLkRvdWJsZS5kb3VibGVUb0xvbmdCaXRzKHRoaXMudmFsdWUpIF4gKGphdmEubGFuZy5Eb3VibGUuZG91YmxlVG9Mb25nQml0cyh0aGlzLnZhbHVlKSA+Pj4gMzIpKSkKLQkJCXB3LnByaW50KCIoKGludCkgKCIpOyAgLy8kTk9OLU5MUy0xJAotCQkJcHcucHJpbnRUeXBlRGVjbGFyYXRpb24oImphdmEubGFuZy5Eb3VibGUiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCXB3LnByaW50KCIuZG91YmxlVG9Mb25nQml0cyh0aGlzLiIpOyAgLy8kTk9OLU5MUy0xJAotCQkJcHcucHJpbnQoZmllbGROYW1lKTsKLQkJCXB3LnByaW50KCIpIF4gKCIpOyAgLy8kTk9OLU5MUy0xJAotCQkJcHcucHJpbnRUeXBlRGVjbGFyYXRpb24oImphdmEubGFuZy5Eb3VibGUiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCXB3LnByaW50KCIuZG91YmxlVG9Mb25nQml0cyh0aGlzLiIpOyAgLy8kTk9OLU5MUy0xJAotCQkJcHcucHJpbnQoZmllbGROYW1lKTsKLQkJCXB3LnByaW50KCIpID4+PiAzMikpKSIpOyAgLy8kTk9OLU5MUy0xJAotCQl9IGVsc2UgaWYgKHByaW1pdGl2ZU5hbWUuZXF1YWxzKCJib29sZWFuIikpIHsgIC8vJE5PTi1OTFMtMSQKLQkJCS8vICh0aGlzLnZhbHVlID8gMSA6IDApCi0JCQlwdy5wcmludCgiKHRoaXMuIik7ICAvLyROT04tTkxTLTEkCi0JCQlwdy5wcmludChmaWVsZE5hbWUpOwotCQkJcHcucHJpbnQoIiA/IDEgOiAwKSIpOyAgLy8kTk9OLU5MUy0xJAotCQl9IGVsc2UgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbihwcmltaXRpdmVOYW1lKTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBwcmludFJlZmVyZW5jZUhhc2hDb2RlQ2xhdXNlT24oU3RyaW5nIGZpZWxkTmFtZSwgRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCXB3LnByaW50KCJ0aGlzLiIpOyAgLy8kTk9OLU5MUy0xJAotCQlwdy5wcmludChmaWVsZE5hbWUpOwotCQlwdy5wcmludCgiLmhhc2hDb2RlKCkiKTsgIC8vJE5PTi1OTFMtMSQKLQl9Ci0KLQotCS8vICoqKioqKioqKiogcGFja2FnZSBhbmQgaW1wb3J0cyAqKioqKioqKioqCi0KLQlwcml2YXRlIHZvaWQgcHJpbnRQYWNrYWdlQW5kSW1wb3J0c09uKFByaW50V3JpdGVyIHB3LCBCb2R5U291cmNlIGJvZHlTb3VyY2UpIHsKLQkJaWYgKHRoaXMuZ2V0UGFja2FnZU5hbWUoKS5sZW5ndGgoKSAhPSAwKSB7Ci0JCQlwdy5wcmludCgicGFja2FnZSAiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCXB3LnByaW50KHRoaXMuZ2V0UGFja2FnZU5hbWUoKSk7Ci0JCQlwdy5wcmludCgnOycpOwotCQkJcHcucHJpbnRsbigpOwotCQkJcHcucHJpbnRsbigpOwotCQl9Ci0KLQkJZm9yIChJdGVyYXRvcjxNYXAuRW50cnk8U3RyaW5nLCBTdHJpbmc+PiBzdHJlYW0gPSBib2R5U291cmNlLmltcG9ydEVudHJpZXMoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQlNYXAuRW50cnk8U3RyaW5nLCBTdHJpbmc+IGVudHJ5ID0gc3RyZWFtLm5leHQoKTsKLQkJCXB3LnByaW50KCJpbXBvcnQgIik7ICAvLyROT04tTkxTLTEkCi0JCQlwdy5wcmludChlbnRyeS5nZXRWYWx1ZSgpKTsgIC8vIHBhY2thZ2UKLQkJCXB3LnByaW50KCcuJyk7Ci0JCQlwdy5wcmludChlbnRyeS5nZXRLZXkoKSk7ICAvLyBzaG9ydCBjbGFzcyBuYW1lCi0JCQlwdy5wcmludCgnOycpOwotCQkJcHcucHJpbnRsbigpOwotCQl9Ci0JCXB3LnByaW50bG4oKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogZmllbGRzICoqKioqKioqKioKLQotCS8qKgotCSAqIHZpc2liaWxpdHkgaXMgc2V0IGluIHRoZSBjb25maWcKLQkgKi8KLQlwcml2YXRlIHZvaWQgcHJpbnRGaWVsZE9uKFN0cmluZyBmaWVsZE5hbWUsIFN0cmluZyB0eXBlRGVjbGFyYXRpb24sIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlwdy5wcmludEZpZWxkKAotCQkJCWZpZWxkTmFtZSwKLQkJCQl0eXBlRGVjbGFyYXRpb24sCi0JCQkJdGhpcy5jb25maWcuZ2V0RmllbGRWaXNpYmlsaXR5Q2xhdXNlKCkKLQkJKTsKLQl9Ci0KLQkvKioKLQkgKiB2aXNpYmlsaXR5IGFuZCBjb2xsZWN0aW9uIHR5cGUgYXJlIHNldCBpbiB0aGUgY29uZmlnCi0JICovCi0JcHJpdmF0ZSB2b2lkIHByaW50Q29sbGVjdGlvbkZpZWxkT24oU3RyaW5nIGZpZWxkTmFtZSwgU3RyaW5nIGVsZW1lbnRUeXBlRGVjbGFyYXRpb24sIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlwdy5wcmludFBhcmFtZXRlcml6ZWRGaWVsZCgKLQkJCQlmaWVsZE5hbWUsCi0JCQkJdGhpcy5jb25maWcuZ2V0Q29sbGVjdGlvblR5cGVOYW1lKCksCi0JCQkJZWxlbWVudFR5cGVEZWNsYXJhdGlvbiwKLQkJCQl0aGlzLmNvbmZpZy5nZXRGaWVsZFZpc2liaWxpdHlDbGF1c2UoKQotCQkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBwcm9wZXJ0aWVzICoqKioqKioqKioKLQotCS8qKgotCSAqIHZpc2liaWxpdHkgaXMgc2V0IGluIHRoZSBjb25maWcKLQkgKi8KLQlwcml2YXRlIHZvaWQgcHJpbnRQcm9wZXJ0eU9uKFN0cmluZyBwcm9wZXJ0eU5hbWUsIFN0cmluZyB0eXBlRGVjbGFyYXRpb24sIEVudGl0eVNvdXJjZVdyaXRlciBwdykgewotCQlwdy5wcmludEdldHRlckFuZFNldHRlcigKLQkJCQlwcm9wZXJ0eU5hbWUsCi0JCQkJdHlwZURlY2xhcmF0aW9uLAotCQkJCXRoaXMuY29uZmlnLmdldE1ldGhvZFZpc2liaWxpdHlDbGF1c2UoKQotCQkpOwotCX0KLQotCS8qKgotCSAqIHZpc2liaWxpdHkgYW5kIGNvbGxlY3Rpb24gdHlwZSBhcmUgc2V0IGluIHRoZSBjb25maWcKLQkgKi8KLQlwcml2YXRlIHZvaWQgcHJpbnRDb2xsZWN0aW9uUHJvcGVydHlPbihTdHJpbmcgcHJvcGVydHlOYW1lLCBTdHJpbmcgZWxlbWVudFR5cGVEZWNsYXJhdGlvbiwgRW50aXR5U291cmNlV3JpdGVyIHB3KSB7Ci0JCXB3LnByaW50Q29sbGVjdGlvbkdldHRlckFuZFNldHRlcigKLQkJCQlwcm9wZXJ0eU5hbWUsCi0JCQkJdGhpcy5jb25maWcuZ2V0Q29sbGVjdGlvblR5cGVOYW1lKCksCi0JCQkJZWxlbWVudFR5cGVEZWNsYXJhdGlvbiwKLQkJCQl0aGlzLmNvbmZpZy5nZXRNZXRob2RWaXNpYmlsaXR5Q2xhdXNlKCkKLQkJKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY29udmVuaWVuY2UgbWV0aG9kcyAqKioqKioqKioqCi0KLQlwcml2YXRlIFN0cmluZyBnZXRQYWNrYWdlTmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMucGFja2FnZUZyYWdtZW50LmdldEVsZW1lbnROYW1lKCk7Ci0JfQotCi0JcHJpdmF0ZSBUYWJsZSBnZXRUYWJsZSgpIHsKLQkJcmV0dXJuIHRoaXMuZ2VuVGFibGUuZ2V0VGFibGUoKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBnZXRFbnRpdHlOYW1lKCkgewotCQlyZXR1cm4gdGhpcy5nZW5UYWJsZS5nZXRFbnRpdHlOYW1lKCk7Ci0JfQotCi0JcHJpdmF0ZSBib29sZWFuIHByaW1hcnlLZXlDbGFzc0lzUmVxdWlyZWQoKSB7Ci0JCXJldHVybiB0aGlzLmdldFRhYmxlKCkucHJpbWFyeUtleUNvbHVtbnNTaXplKCkgPiAxOwotCX0KLQotCXByaXZhdGUgU3RyaW5nIGZ1bGx5UXVhbGlmeShTdHJpbmcgc2hvcnRDbGFzc05hbWUpIHsKLQkJU3RyaW5nIHBrZyA9IHRoaXMuZ2V0UGFja2FnZU5hbWUoKTsKLQkJcmV0dXJuIChwa2cubGVuZ3RoKCkgPT0gMCkgPyBzaG9ydENsYXNzTmFtZSA6IHBrZyArICcuJyArIHNob3J0Q2xhc3NOYW1lOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuZ2VuVGFibGUuZ2V0TmFtZSgpICsgIiA9PiAiICsgdGhpcy5lbnRpdHlDbGFzc05hbWUpOyAgLy8kTk9OLU5MUy0xJAotCX0KLQotCi0JLy8gKioqKioqKioqKiBzb3VyY2Ugd3JpdGVyICoqKioqKioqKioKLQotCXByaXZhdGUgaW50ZXJmYWNlIEJvZHlTb3VyY2UgewotCi0JCS8qKgotCQkgKiByZXR1cm4gYSBzb3J0ZWQgc2V0IG9mIG1hcCBlbnRyaWVzOyB0aGUga2V5IGlzIHRoZSBzaG9ydCBjbGFzcyBuYW1lLAotCQkgKiB0aGUgdmFsdWUgaXMgdGhlIHBhY2thZ2UgbmFtZQotCQkgKi8KLQkJSXRlcmF0b3I8TWFwLkVudHJ5PFN0cmluZywgU3RyaW5nPj4gaW1wb3J0RW50cmllcygpOwotCi0JCS8qKgotCQkgKiByZXR1cm4gdGhlIGJvZHkgc291cmNlIGNvZGUKLQkJICovCi0JCVN0cmluZyBnZXRTb3VyY2UoKTsKLQotCQkvKioKLQkJICogcmV0dXJuIHRoZSBsZW5ndGggb2YgdGhlIGJvZHkgc291cmNlIGNvZGUKLQkJICovCi0JCWludCBsZW5ndGgoKTsKLQotCX0KLQotCS8qKgotCSAqIEV4dGVuZCBJbmRlbnRpbmdQcmludFdyaXRlciB3aXRoIHNvbWUgbWV0aG9kcyB0aGF0IGZhY2lsaXRhdGUgYnVpbGRpbmcKLQkgKiBjbGFzcyBzb3VyY2UgY29kZS4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBFbnRpdHlTb3VyY2VXcml0ZXIgZXh0ZW5kcyBJbmRlbnRpbmdQcmludFdyaXRlciBpbXBsZW1lbnRzIEJvZHlTb3VyY2UgewotCQlmaW5hbCBTdHJpbmcgcGFja2FnZU5hbWU7Ci0JCWZpbmFsIFN0cmluZyBjbGFzc05hbWU7Ci0JCS8vIGtleSA9IHNob3J0IGNsYXNzIG5hbWU7IHZhbHVlID0gcGFja2FnZSBuYW1lCi0JCXByaXZhdGUgZmluYWwgTWFwPFN0cmluZywgU3RyaW5nPiBpbXBvcnRzID0gbmV3IEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+KCk7Ci0KLQkJRW50aXR5U291cmNlV3JpdGVyKFN0cmluZyBwYWNrYWdlTmFtZSwgU3RyaW5nIGNsYXNzTmFtZSkgewotCQkJc3VwZXIobmV3IFN0cmluZ1dyaXRlcigyMDAwMCkpOwotCQkJdGhpcy5wYWNrYWdlTmFtZSA9IHBhY2thZ2VOYW1lOwotCQkJdGhpcy5jbGFzc05hbWUgPSBjbGFzc05hbWU7Ci0JCX0KLQotCQkvKioKLQkJICogQ29udmVydCB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byBhIFN0cmluZyBMaXRlcmFsIGFuZCBwcmludCBpdCwKLQkJICogYWRkaW5nIHRoZSBzdXJyb3VuZGluZyBkb3VibGUtcXVvdGVzIGFuZCBlc2NhcGluZyBjaGFyYWN0ZXJzCi0JCSAqIGFzIG5lY2Vzc2FyeS4KLQkJICovCi0JCXZvaWQgcHJpbnRTdHJpbmdMaXRlcmFsKFN0cmluZyBzdHJpbmcpIHsKLQkJCVN0cmluZ1Rvb2xzLmNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT24oc3RyaW5nLCB0aGlzKTsKLQkJfQotCi0JCXZvaWQgcHJpbnRWaXNpYmlsaXR5KFN0cmluZyB2aXNpYmlsaXR5TW9kaWZpZXIpIHsKLQkJCWlmICh2aXNpYmlsaXR5TW9kaWZpZXIubGVuZ3RoKCkgIT0gMCkgewotCQkJCXRoaXMucHJpbnQodmlzaWJpbGl0eU1vZGlmaWVyKTsKLQkJCQl0aGlzLnByaW50KCcgJyk7Ci0JCQl9Ci0JCX0KLQotCQl2b2lkIHByaW50QW5ub3RhdGlvbihTdHJpbmcgYW5ub3RhdGlvbk5hbWUpIHsKLQkJCXRoaXMucHJpbnQoJ0AnKTsKLQkJCXRoaXMucHJpbnRUeXBlRGVjbGFyYXRpb24oYW5ub3RhdGlvbk5hbWUpOwotCQl9Ci0KLQkJdm9pZCBwcmludFR5cGVEZWNsYXJhdGlvbihTdHJpbmcgdHlwZURlY2xhcmF0aW9uKSB7Ci0JCQl0aGlzLnByaW50KHRoaXMuYnVpbGRJbXBvcnRlZFR5cGVEZWNsYXJhdGlvbih0eXBlRGVjbGFyYXRpb24pKTsKLQkJfQotCi0JCS8qKgotCQkgKiBSZXR1cm4gdGhlIHNwZWNpZmllZCBjbGFzcydzICJpbXBvcnRlZCIgbmFtZS4KLQkJICogVGhlIGNsYXNzIGRlY2xhcmF0aW9uIG11c3QgYmUgb2YgdGhlIGZvcm06Ci0JCSAqICAgICAiaW50IgotCQkgKiAgICAgImludFtdIiAobm90ICJbSSIpCi0JCSAqICAgICAiamF2YS5sYW5nLk9iamVjdCIKLQkJICogICAgICJqYXZhLmxhbmcuT2JqZWN0W10iIChub3QgIltMamF2YS5sYW5nLk9iamVjdDsiKQotCQkgKiAgICAgImphdmEudXRpbC5NYXAuRW50cnkiIChub3QgImphdmEudXRpbC5NYXAkRW50cnkiKQotCQkgKiAgICAgImphdmEudXRpbC5NYXAuRW50cnlbXVtdIiAobm90ICJbW0xqYXZhLnV0aWwuTWFwJEVudHJ5OyIpCi0JCSAqLwotCQlwcml2YXRlIFN0cmluZyBidWlsZEltcG9ydGVkVHlwZURlY2xhcmF0aW9uKFN0cmluZyB0eXBlRGVjbGFyYXRpb24pIHsKLQkJCWlmICh0aGlzLnR5cGVEZWNsYXJhdGlvbklzTWVtYmVyQ2xhc3ModHlwZURlY2xhcmF0aW9uKSkgewotCQkJCS8vIG5vIG5lZWQgZm9yIGFuIGltcG9ydCwganVzdCByZXR1cm4gdGhlIHBhcnRpYWxseS1xdWFsaWZpZWQgbmFtZQotCQkJCXJldHVybiB0aGlzLmJ1aWxkTWVtYmVyQ2xhc3NUeXBlRGVjbGFyYXRpb24odHlwZURlY2xhcmF0aW9uKTsKLQkJCX0KLQkJCWludCBsYXN0ID0gdHlwZURlY2xhcmF0aW9uLmxhc3RJbmRleE9mKCcuJyk7Ci0JCQlTdHJpbmcgcGtnID0gKGxhc3QgPT0gLTEpID8gIiIgOiB0eXBlRGVjbGFyYXRpb24uc3Vic3RyaW5nKDAsIGxhc3QpOyAgLy8kTk9OLU5MUy0xJAotCQkJU3RyaW5nIHNob3J0VHlwZURlY2xhcmF0aW9uID0gdHlwZURlY2xhcmF0aW9uLnN1YnN0cmluZyhsYXN0ICsgMSk7Ci0JCQlTdHJpbmcgc2hvcnRFbGVtZW50VHlwZU5hbWUgPSBzaG9ydFR5cGVEZWNsYXJhdGlvbjsKLQkJCXdoaWxlIChzaG9ydEVsZW1lbnRUeXBlTmFtZS5lbmRzV2l0aCgiW10iKSkgeyAgLy8kTk9OLU5MUy0xJAotCQkJCXNob3J0RWxlbWVudFR5cGVOYW1lID0gc2hvcnRFbGVtZW50VHlwZU5hbWUuc3Vic3RyaW5nKDAsIHNob3J0RWxlbWVudFR5cGVOYW1lLmxlbmd0aCgpIC0gMik7Ci0JCQl9Ci0JCQlTdHJpbmcgcHJldiA9IHRoaXMuaW1wb3J0cy5nZXQoc2hvcnRFbGVtZW50VHlwZU5hbWUpOwotCQkJaWYgKHByZXYgPT0gbnVsbCkgewotCQkJCS8vIHRoaXMgaXMgdGhlIGZpcnN0IGNsYXNzIHdpdGggdGhpcyBzaG9ydCBlbGVtZW50IHR5cGUgbmFtZQotCQkJCXRoaXMuaW1wb3J0cy5wdXQoc2hvcnRFbGVtZW50VHlwZU5hbWUsIHBrZyk7Ci0JCQkJcmV0dXJuIHNob3J0VHlwZURlY2xhcmF0aW9uOwotCQkJfQotCQkJaWYgKHByZXYuZXF1YWxzKHBrZykpIHsKLQkJCQkvLyB0aGlzIGVsZW1lbnQgdHlwZSBoYXMgYWxyZWFkeSBiZWVuIGltcG9ydGVkCi0JCQkJcmV0dXJuIHNob3J0VHlwZURlY2xhcmF0aW9uOwotCQkJfQotCQkJLy8gYW5vdGhlciBjbGFzcyB3aXRoIHRoZSBzYW1lIHNob3J0IGVsZW1lbnQgdHlwZSBuYW1lIGhhcyBiZWVuCi0JCQkvLyBwcmV2aW91c2x5IGltcG9ydGVkLCBzbyB0aGlzIG9uZSBtdXN0IGJlIHVzZWQgZnVsbHktcXVhbGlmaWVkCi0JCQlyZXR1cm4gdHlwZURlY2xhcmF0aW9uOwotCQl9Ci0KLQkJLyoqCi0JCSAqIGUuZy4gImZvby5iYXIuRW1wbG95ZWUuUEsiIHdpbGwgcmV0dXJuIHRydWUKLQkJICovCi0JCXByaXZhdGUgYm9vbGVhbiB0eXBlRGVjbGFyYXRpb25Jc01lbWJlckNsYXNzKFN0cmluZyB0eXBlRGVjbGFyYXRpb24pIHsKLQkJCXJldHVybiAodHlwZURlY2xhcmF0aW9uLmxlbmd0aCgpID4gdGhpcy5jbGFzc05hbWUubGVuZ3RoKCkpCi0JCQkJCSYmIHR5cGVEZWNsYXJhdGlvbi5zdGFydHNXaXRoKHRoaXMuY2xhc3NOYW1lKQotCQkJCQkmJiAodHlwZURlY2xhcmF0aW9uLmNoYXJBdCh0aGlzLmNsYXNzTmFtZS5sZW5ndGgoKSkgPT0gJy4nKTsKLQkJfQotCi0JCS8qKgotCQkgKiBlLmcuICJmb28uYmFyLkVtcGxveWVlLlBLIiB3aWxsIHJldHVybiAiRW1wbG95ZWUuUEsiCi0JCSAqIHRoaXMgcHJldmVudHMgY29sbGlzaW9ucyB3aXRoIG90aGVyIGltcG9ydGVkIGNsYXNzZXMgKGUuZy4gImpvby5qYXIuUEsiKQotCQkgKi8KLQkJcHJpdmF0ZSBTdHJpbmcgYnVpbGRNZW1iZXJDbGFzc1R5cGVEZWNsYXJhdGlvbihTdHJpbmcgdHlwZURlY2xhcmF0aW9uKSB7Ci0JCQlpbnQgaW5kZXggPSB0aGlzLnBhY2thZ2VOYW1lLmxlbmd0aCgpOwotCQkJaWYgKGluZGV4ICE9IDApIHsKLQkJCQlpbmRleCsrOyAgLy8gYnVtcCBwYXN0IHRoZSAnLicKLQkJCX0KLQkJCXJldHVybiB0eXBlRGVjbGFyYXRpb24uc3Vic3RyaW5nKGluZGV4KTsKLQkJfQotCi0JCXByaXZhdGUgSXRlcmF0b3I8TWFwLkVudHJ5PFN0cmluZywgU3RyaW5nPj4gc29ydGVkSW1wb3J0RW50cmllcygpIHsKLQkJCVRyZWVTZXQ8TWFwLkVudHJ5PFN0cmluZywgU3RyaW5nPj4gc29ydGVkSW1wb3J0cyA9IG5ldyBUcmVlU2V0PE1hcC5FbnRyeTxTdHJpbmcsIFN0cmluZz4+KHRoaXMuYnVpbGRJbXBvcnRFbnRyaWVzQ29tcGFyYXRvcigpKTsKLQkJCXNvcnRlZEltcG9ydHMuYWRkQWxsKHRoaXMuaW1wb3J0cy5lbnRyeVNldCgpKTsKLQkJCXJldHVybiBzb3J0ZWRJbXBvcnRzLml0ZXJhdG9yKCk7Ci0JCX0KLQotCQlwcml2YXRlIENvbXBhcmF0b3I8TWFwLkVudHJ5PFN0cmluZywgU3RyaW5nPj4gYnVpbGRJbXBvcnRFbnRyaWVzQ29tcGFyYXRvcigpIHsKLQkJCXJldHVybiBuZXcgQ29tcGFyYXRvcjxNYXAuRW50cnk8U3RyaW5nLCBTdHJpbmc+PigpIHsKLQkJCQlwdWJsaWMgaW50IGNvbXBhcmUoTWFwLkVudHJ5PFN0cmluZywgU3RyaW5nPiBlMSwgTWFwLkVudHJ5PFN0cmluZywgU3RyaW5nPiBlMikgewotCQkJCQlDb2xsYXRvciBjb2xsYXRvciA9IENvbGxhdG9yLmdldEluc3RhbmNlKCk7Ci0JCQkJCWludCBwa2cgPSBjb2xsYXRvci5jb21wYXJlKGUxLmdldFZhbHVlKCksIGUyLmdldFZhbHVlKCkpOwotCQkJCQlyZXR1cm4gKHBrZyA9PSAwKSA/IGNvbGxhdG9yLmNvbXBhcmUoZTEuZ2V0S2V5KCksIGUyLmdldEtleSgpKSA6IHBrZzsKLQkJCQl9Ci0JCQl9OwotCQl9Ci0KLQkJdm9pZCBwcmludEZpZWxkKFN0cmluZyBmaWVsZE5hbWUsIFN0cmluZyB0eXBlRGVjbGFyYXRpb24sIFN0cmluZyB2aXNpYmlsaXR5KSB7Ci0JCQl0aGlzLnByaW50VmlzaWJpbGl0eSh2aXNpYmlsaXR5KTsKLQkJCXRoaXMucHJpbnRUeXBlRGVjbGFyYXRpb24odHlwZURlY2xhcmF0aW9uKTsKLQkJCXRoaXMucHJpbnQoJyAnKTsKLQkJCXRoaXMucHJpbnQoZmllbGROYW1lKTsKLQkJCXRoaXMucHJpbnQoJzsnKTsKLQkJCXRoaXMucHJpbnRsbigpOwotCQkJdGhpcy5wcmludGxuKCk7Ci0JCX0KLQotCQl2b2lkIHByaW50UGFyYW1ldGVyaXplZEZpZWxkKFN0cmluZyBmaWVsZE5hbWUsIFN0cmluZyB0eXBlRGVjbGFyYXRpb24sIFN0cmluZyBwYXJhbWV0ZXJUeXBlRGVjbGFyYXRpb24sIFN0cmluZyB2aXNpYmlsaXR5KSB7Ci0JCQl0aGlzLnByaW50VmlzaWJpbGl0eSh2aXNpYmlsaXR5KTsKLQkJCXRoaXMucHJpbnRUeXBlRGVjbGFyYXRpb24odHlwZURlY2xhcmF0aW9uKTsKLQkJCXRoaXMucHJpbnQoJzwnKTsKLQkJCXRoaXMucHJpbnRUeXBlRGVjbGFyYXRpb24ocGFyYW1ldGVyVHlwZURlY2xhcmF0aW9uKTsKLQkJCXRoaXMucHJpbnQoJz4nKTsKLQkJCXRoaXMucHJpbnQoJyAnKTsKLQkJCXRoaXMucHJpbnQoZmllbGROYW1lKTsKLQkJCXRoaXMucHJpbnQoJzsnKTsKLQkJCXRoaXMucHJpbnRsbigpOwotCQkJdGhpcy5wcmludGxuKCk7Ci0JCX0KLQotCQl2b2lkIHByaW50R2V0dGVyQW5kU2V0dGVyKFN0cmluZyBwcm9wZXJ0eU5hbWUsIFN0cmluZyB0eXBlRGVjbGFyYXRpb24sIFN0cmluZyB2aXNpYmlsaXR5KSB7Ci0JCQl0aGlzLnByaW50R2V0dGVyKHByb3BlcnR5TmFtZSwgdHlwZURlY2xhcmF0aW9uLCB2aXNpYmlsaXR5KTsKLQkJCXRoaXMucHJpbnRsbigpOwotCQkJdGhpcy5wcmludGxuKCk7Ci0KLQkJCXRoaXMucHJpbnRTZXR0ZXIocHJvcGVydHlOYW1lLCB0eXBlRGVjbGFyYXRpb24sIHZpc2liaWxpdHkpOwotCQkJdGhpcy5wcmludGxuKCk7Ci0JCQl0aGlzLnByaW50bG4oKTsKLQkJfQotCi0JCXByaXZhdGUgdm9pZCBwcmludEdldHRlcihTdHJpbmcgcHJvcGVydHlOYW1lLCBTdHJpbmcgdHlwZURlY2xhcmF0aW9uLCBTdHJpbmcgdmlzaWJpbGl0eSkgewotCQkJdGhpcy5wcmludFZpc2liaWxpdHkodmlzaWJpbGl0eSk7Ci0JCQl0aGlzLnByaW50VHlwZURlY2xhcmF0aW9uKHR5cGVEZWNsYXJhdGlvbik7Ci0JCQl0aGlzLnByaW50KCcgJyk7Ci0JCQl0aGlzLnByaW50KHR5cGVEZWNsYXJhdGlvbi5lcXVhbHMoImJvb2xlYW4iKSA/ICJpcyIgOiAiZ2V0Iik7ICAvLyROT04tTkxTLTEkIC8vJE5PTi1OTFMtMiQgLy8kTk9OLU5MUy0zJAotCQkJdGhpcy5wcmludChTdHJpbmdUb29scy5jYXBpdGFsaXplKHByb3BlcnR5TmFtZSkpOwotCQkJdGhpcy5wcmludCgiKCkgeyIpOyAgLy8kTk9OLU5MUy0xJAotCQkJdGhpcy5wcmludGxuKCk7Ci0KLQkJCXRoaXMuaW5kZW50KCk7Ci0JCQkJdGhpcy5wcmludCgicmV0dXJuIHRoaXMuIik7ICAvLyROT04tTkxTLTEkCi0JCQkJdGhpcy5wcmludChwcm9wZXJ0eU5hbWUpOwotCQkJCXRoaXMucHJpbnQoJzsnKTsKLQkJCQl0aGlzLnByaW50bG4oKTsKLQkJCXRoaXMudW5kZW50KCk7Ci0KLQkJCXRoaXMucHJpbnQoJ30nKTsKLQkJfQotCi0JCXByaXZhdGUgdm9pZCBwcmludFNldHRlcihTdHJpbmcgcHJvcGVydHlOYW1lLCBTdHJpbmcgdHlwZURlY2xhcmF0aW9uLCBTdHJpbmcgdmlzaWJpbGl0eSkgewotCQkJdGhpcy5wcmludFZpc2liaWxpdHkodmlzaWJpbGl0eSk7Ci0JCQl0aGlzLnByaW50KCJ2b2lkIHNldCIpOyAgLy8kTk9OLU5MUy0xJAotCQkJdGhpcy5wcmludChTdHJpbmdUb29scy5jYXBpdGFsaXplKHByb3BlcnR5TmFtZSkpOwotCQkJdGhpcy5wcmludCgnKCcpOwotCQkJdGhpcy5wcmludFR5cGVEZWNsYXJhdGlvbih0eXBlRGVjbGFyYXRpb24pOwotCQkJdGhpcy5wcmludCgnICcpOwotCQkJdGhpcy5wcmludChwcm9wZXJ0eU5hbWUpOwotCQkJdGhpcy5wcmludCgiKSB7Iik7ICAvLyROT04tTkxTLTEkCi0JCQl0aGlzLnByaW50bG4oKTsKLQotCQkJdGhpcy5pbmRlbnQoKTsKLQkJCQl0aGlzLnByaW50KCJ0aGlzLiIpOyAgLy8kTk9OLU5MUy0xJAotCQkJCXRoaXMucHJpbnQocHJvcGVydHlOYW1lKTsKLQkJCQl0aGlzLnByaW50KCIgPSAiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCQl0aGlzLnByaW50KHByb3BlcnR5TmFtZSk7Ci0JCQkJdGhpcy5wcmludCgnOycpOwotCQkJCXRoaXMucHJpbnRsbigpOwotCQkJdGhpcy51bmRlbnQoKTsKLQotCQkJdGhpcy5wcmludCgnfScpOwotCQl9Ci0KLQkJdm9pZCBwcmludENvbGxlY3Rpb25HZXR0ZXJBbmRTZXR0ZXIoU3RyaW5nIHByb3BlcnR5TmFtZSwgU3RyaW5nIGNvbGxlY3Rpb25UeXBlRGVjbGFyYXRpb24sIFN0cmluZyBlbGVtZW50VHlwZURlY2xhcmF0aW9uLCBTdHJpbmcgdmlzaWJpbGl0eSkgewotCQkJdGhpcy5wcmludENvbGxlY3Rpb25HZXR0ZXIocHJvcGVydHlOYW1lLCBjb2xsZWN0aW9uVHlwZURlY2xhcmF0aW9uLCBlbGVtZW50VHlwZURlY2xhcmF0aW9uLCB2aXNpYmlsaXR5KTsKLQkJCXRoaXMucHJpbnRsbigpOwotCQkJdGhpcy5wcmludGxuKCk7Ci0KLQkJCXRoaXMucHJpbnRDb2xsZWN0aW9uU2V0dGVyKHByb3BlcnR5TmFtZSwgY29sbGVjdGlvblR5cGVEZWNsYXJhdGlvbiwgZWxlbWVudFR5cGVEZWNsYXJhdGlvbiwgdmlzaWJpbGl0eSk7Ci0JCQl0aGlzLnByaW50bG4oKTsKLQkJCXRoaXMucHJpbnRsbigpOwotCQl9Ci0KLQkJcHJpdmF0ZSB2b2lkIHByaW50Q29sbGVjdGlvbkdldHRlcihTdHJpbmcgcHJvcGVydHlOYW1lLCBTdHJpbmcgY29sbGVjdGlvblR5cGVEZWNsYXJhdGlvbiwgU3RyaW5nIGVsZW1lbnRUeXBlRGVjbGFyYXRpb24sIFN0cmluZyB2aXNpYmlsaXR5KSB7Ci0JCQl0aGlzLnByaW50VmlzaWJpbGl0eSh2aXNpYmlsaXR5KTsKLQkJCXRoaXMucHJpbnRUeXBlRGVjbGFyYXRpb24oY29sbGVjdGlvblR5cGVEZWNsYXJhdGlvbik7Ci0JCQl0aGlzLnByaW50KCc8Jyk7Ci0JCQl0aGlzLnByaW50VHlwZURlY2xhcmF0aW9uKGVsZW1lbnRUeXBlRGVjbGFyYXRpb24pOwotCQkJdGhpcy5wcmludCgiPiBnZXQiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCXRoaXMucHJpbnQoU3RyaW5nVG9vbHMuY2FwaXRhbGl6ZShwcm9wZXJ0eU5hbWUpKTsKLQkJCXRoaXMucHJpbnQoIigpIHsiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCXRoaXMucHJpbnRsbigpOwotCi0JCQl0aGlzLmluZGVudCgpOwotCQkJCXRoaXMucHJpbnQoInJldHVybiB0aGlzLiIpOyAgLy8kTk9OLU5MUy0xJAotCQkJCXRoaXMucHJpbnQocHJvcGVydHlOYW1lKTsKLQkJCQl0aGlzLnByaW50KCc7Jyk7Ci0JCQkJdGhpcy5wcmludGxuKCk7Ci0JCQl0aGlzLnVuZGVudCgpOwotCi0JCQl0aGlzLnByaW50KCd9Jyk7Ci0JCX0KLQotCQlwcml2YXRlIHZvaWQgcHJpbnRDb2xsZWN0aW9uU2V0dGVyKFN0cmluZyBwcm9wZXJ0eU5hbWUsIFN0cmluZyBjb2xsZWN0aW9uVHlwZURlY2xhcmF0aW9uLCBTdHJpbmcgZWxlbWVudFR5cGVEZWNsYXJhdGlvbiwgU3RyaW5nIHZpc2liaWxpdHkpIHsKLQkJCXRoaXMucHJpbnRWaXNpYmlsaXR5KHZpc2liaWxpdHkpOwotCQkJdGhpcy5wcmludCgidm9pZCBzZXQiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCXRoaXMucHJpbnQoU3RyaW5nVG9vbHMuY2FwaXRhbGl6ZShwcm9wZXJ0eU5hbWUpKTsKLQkJCXRoaXMucHJpbnQoJygnKTsKLQkJCXRoaXMucHJpbnRUeXBlRGVjbGFyYXRpb24oY29sbGVjdGlvblR5cGVEZWNsYXJhdGlvbik7Ci0JCQl0aGlzLnByaW50KCc8Jyk7Ci0JCQl0aGlzLnByaW50VHlwZURlY2xhcmF0aW9uKGVsZW1lbnRUeXBlRGVjbGFyYXRpb24pOwotCQkJdGhpcy5wcmludCgnPicpOwotCQkJdGhpcy5wcmludCgnICcpOwotCQkJdGhpcy5wcmludChwcm9wZXJ0eU5hbWUpOwotCQkJdGhpcy5wcmludCgiKSB7Iik7ICAvLyROT04tTkxTLTEkCi0JCQl0aGlzLnByaW50bG4oKTsKLQotCQkJdGhpcy5pbmRlbnQoKTsKLQkJCQl0aGlzLnByaW50KCJ0aGlzLiIpOyAgLy8kTk9OLU5MUy0xJAotCQkJCXRoaXMucHJpbnQocHJvcGVydHlOYW1lKTsKLQkJCQl0aGlzLnByaW50KCIgPSAiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCQl0aGlzLnByaW50KHByb3BlcnR5TmFtZSk7Ci0JCQkJdGhpcy5wcmludCgnOycpOwotCQkJCXRoaXMucHJpbnRsbigpOwotCQkJdGhpcy51bmRlbnQoKTsKLQotCQkJdGhpcy5wcmludCgnfScpOwotCQl9Ci0KLQotCQkvLyAqKioqKioqKioqIEJvZHlTb3VyY2UgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JCXB1YmxpYyBJdGVyYXRvcjxNYXAuRW50cnk8U3RyaW5nLCBTdHJpbmc+PiBpbXBvcnRFbnRyaWVzKCkgewotCQkJcmV0dXJuIG5ldyBGaWx0ZXJpbmdJdGVyYXRvcjxNYXAuRW50cnk8U3RyaW5nLCBTdHJpbmc+LCBNYXAuRW50cnk8U3RyaW5nLCBTdHJpbmc+Pih0aGlzLnNvcnRlZEltcG9ydEVudHJpZXMoKSkgewotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCBib29sZWFuIGFjY2VwdChNYXAuRW50cnk8U3RyaW5nLCBTdHJpbmc+IG5leHQpIHsKLQkJCQkJU3RyaW5nIHBrZyA9IG5leHQuZ2V0VmFsdWUoKTsKLQkJCQkJaWYgKHBrZy5lcXVhbHMoIiIpICAvLyROT04tTkxTLTEkCi0JCQkJCQkJfHwgcGtnLmVxdWFscygiamF2YS5sYW5nIikgIC8vJE5PTi1OTFMtMSQKLQkJCQkJCQl8fCBwa2cuZXF1YWxzKEVudGl0eVNvdXJjZVdyaXRlci50aGlzLnBhY2thZ2VOYW1lKSkgewotCQkJCQkJcmV0dXJuIGZhbHNlOwotCQkJCQl9Ci0JCQkJCXJldHVybiB0cnVlOwotCQkJCX0KLQkJCX07Ci0JCX0KLQotCQlwdWJsaWMgU3RyaW5nIGdldFNvdXJjZSgpIHsKLQkJCXJldHVybiB0aGlzLm91dC50b1N0cmluZygpOwotCQl9Ci0KLQkJcHVibGljIGludCBsZW5ndGgoKSB7Ci0JCQlyZXR1cm4gKChTdHJpbmdXcml0ZXIpIHRoaXMub3V0KS5nZXRCdWZmZXIoKS5sZW5ndGgoKTsKLQkJfQotCi0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbmZpZyAqKioqKioqKioqCi0KLQlwdWJsaWMgc3RhdGljIGNsYXNzIENvbmZpZyB7Ci0JCXByaXZhdGUgYm9vbGVhbiBjb252ZXJ0VG9KYXZhU3R5bGVJZGVudGlmaWVycyA9IHRydWU7Ci0KLQkJcHJpdmF0ZSBib29sZWFuIHByb3BlcnR5QWNjZXNzVHlwZSA9IGZhbHNlOyAgLy8gYXMgb3Bwb3NlZCB0byAiZmllbGQiCi0KLQkJcHJpdmF0ZSBTdHJpbmcgY29sbGVjdGlvblR5cGVOYW1lID0gU2V0LmNsYXNzLmdldE5hbWUoKTsKLQkJcHJpdmF0ZSBTdHJpbmcgY29sbGVjdGlvbkF0dHJpYnV0ZU5hbWVTdWZmaXggPSAiQ29sbGVjdGlvbiI7ICAvLyBlLmcuICJwcml2YXRlIFNldDxGb28+IGZvb0NvbGxlY3Rpb24iICAvLyROT04tTkxTLTEkCi0KLQkJcHJpdmF0ZSBpbnQgZmllbGRWaXNpYmlsaXR5ID0gTW9kaWZpZXIuUFJJVkFURTsKLQkJcHJpdmF0ZSBpbnQgbWV0aG9kVmlzaWJpbGl0eSA9IE1vZGlmaWVyLlBVQkxJQzsKLQotCQlwcml2YXRlIGJvb2xlYW4gZ2VuZXJhdGVHZXR0ZXJzQW5kU2V0dGVycyA9IHRydWU7Ci0JCXByaXZhdGUgYm9vbGVhbiBnZW5lcmF0ZURlZmF1bHRDb25zdHJ1Y3RvciA9IHRydWU7Ci0KLQkJcHJpdmF0ZSBib29sZWFuIHNlcmlhbGl6YWJsZSA9IHRydWU7Ci0JCXByaXZhdGUgYm9vbGVhbiBnZW5lcmF0ZVNlcmlhbFZlcnNpb25VSUQgPSB0cnVlOwotCi0JCXByaXZhdGUgYm9vbGVhbiBnZW5lcmF0ZUVtYmVkZGVkSWRGb3JDb21wb3VuZFBLID0gdHJ1ZTsgIC8vIGFzIG9wcG9zZWQgdG8gSWRDbGFzcwotCQlwcml2YXRlIFN0cmluZyBlbWJlZGRlZElkQXR0cmlidXRlTmFtZSA9ICJwayI7ICAvLyROT04tTkxTLTEkCi0JCXByaXZhdGUgU3RyaW5nIHByaW1hcnlLZXlNZW1iZXJDbGFzc05hbWUgPSAiUEsiOyAgLy8kTk9OLU5MUy0xJAotCi0JCS8qKgotCQkgKiBrZXkgPSB0YWJsZQotCQkgKiB2YWx1ZSA9IGVudGl0eSBuYW1lCi0JCSAqLwotCQlwcml2YXRlIEhhc2hNYXA8VGFibGUsIFN0cmluZz4gdGFibGVzID0gbmV3IEhhc2hNYXA8VGFibGUsIFN0cmluZz4oKTsKLQotCQlwcml2YXRlIERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyIGRhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyID0gRGF0YWJhc2VBbm5vdGF0aW9uTmFtZUJ1aWxkZXIuRGVmYXVsdC5JTlNUQU5DRTsKLQotCQlwcml2YXRlIE92ZXJ3cml0ZUNvbmZpcm1lciBvdmVyd3JpdGVDb25maXJtZXIgPSBPdmVyd3JpdGVDb25maXJtZXIuTmV2ZXIuSU5TVEFOQ0U7Ci0KLQkJcHVibGljIHN0YXRpYyBmaW5hbCBpbnQgUFJJVkFURSA9IDA7Ci0JCXB1YmxpYyBzdGF0aWMgZmluYWwgaW50IFBBQ0tBR0UgPSAxOwotCQlwdWJsaWMgc3RhdGljIGZpbmFsIGludCBQUk9URUNURUQgPSAyOwotCQlwdWJsaWMgc3RhdGljIGZpbmFsIGludCBQVUJMSUMgPSAzOwotCi0KLQkJcHVibGljIGJvb2xlYW4gY29udmVydFRvSmF2YVN0eWxlSWRlbnRpZmllcnMoKSB7Ci0JCQlyZXR1cm4gdGhpcy5jb252ZXJ0VG9KYXZhU3R5bGVJZGVudGlmaWVyczsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXRDb252ZXJ0VG9KYXZhU3R5bGVJZGVudGlmaWVycyhib29sZWFuIGNvbnZlcnRUb0phdmFTdHlsZUlkZW50aWZpZXJzKSB7Ci0JCQl0aGlzLmNvbnZlcnRUb0phdmFTdHlsZUlkZW50aWZpZXJzID0gY29udmVydFRvSmF2YVN0eWxlSWRlbnRpZmllcnM7Ci0JCX0KLQotCQlwdWJsaWMgYm9vbGVhbiBwcm9wZXJ0eUFjY2Vzc1R5cGUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5wcm9wZXJ0eUFjY2Vzc1R5cGU7Ci0JCX0KLQkJcHVibGljIHZvaWQgc2V0UHJvcGVydHlBY2Nlc3NUeXBlKGJvb2xlYW4gcHJvcGVydHlBY2Nlc3NUeXBlKSB7Ci0JCQl0aGlzLnByb3BlcnR5QWNjZXNzVHlwZSA9IHByb3BlcnR5QWNjZXNzVHlwZTsKLQkJfQotCi0JCXB1YmxpYyBib29sZWFuIGZpZWxkQWNjZXNzVHlwZSgpIHsKLQkJCXJldHVybiAhIHRoaXMucHJvcGVydHlBY2Nlc3NUeXBlOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldEZpZWxkQWNjZXNzVHlwZShib29sZWFuIGZpZWxkQWNjZXNzVHlwZSkgewotCQkJdGhpcy5wcm9wZXJ0eUFjY2Vzc1R5cGUgPSAhIGZpZWxkQWNjZXNzVHlwZTsKLQkJfQotCi0JCXB1YmxpYyBTdHJpbmcgZ2V0Q29sbGVjdGlvblR5cGVOYW1lKCkgewotCQkJcmV0dXJuIHRoaXMuY29sbGVjdGlvblR5cGVOYW1lOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldENvbGxlY3Rpb25UeXBlTmFtZShTdHJpbmcgY29sbGVjdGlvblR5cGVOYW1lKSB7Ci0JCQl0aGlzLmNoZWNrUmVxdWlyZWRTdHJpbmcoY29sbGVjdGlvblR5cGVOYW1lLCAiY29sbGVjdGlvbiB0eXBlIG5hbWUgaXMgcmVxdWlyZWQiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCXRoaXMuY29sbGVjdGlvblR5cGVOYW1lID0gY29sbGVjdGlvblR5cGVOYW1lOwotCQl9Ci0KLQkJcHVibGljIFN0cmluZyBnZXRDb2xsZWN0aW9uQXR0cmlidXRlTmFtZVN1ZmZpeCgpIHsKLQkJCXJldHVybiB0aGlzLmNvbGxlY3Rpb25BdHRyaWJ1dGVOYW1lU3VmZml4OwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldENvbGxlY3Rpb25BdHRyaWJ1dGVOYW1lU3VmZml4KFN0cmluZyBjb2xsZWN0aW9uQXR0cmlidXRlTmFtZVN1ZmZpeCkgewotCQkJdGhpcy5jb2xsZWN0aW9uQXR0cmlidXRlTmFtZVN1ZmZpeCA9IGNvbGxlY3Rpb25BdHRyaWJ1dGVOYW1lU3VmZml4OwotCQl9Ci0KLQkJcHVibGljIGludCBnZXRGaWVsZFZpc2liaWxpdHkoKSB7Ci0JCQlyZXR1cm4gdGhpcy5maWVsZFZpc2liaWxpdHk7Ci0JCX0KLQkJLyoqIGVudGl0eSBmaWVsZHMgY2Fubm90IGJlICdwdWJsaWMnICovCi0JCXB1YmxpYyB2b2lkIHNldEZpZWxkVmlzaWJpbGl0eShpbnQgZmllbGRWaXNpYmlsaXR5KSB7Ci0JCQlzd2l0Y2ggKGZpZWxkVmlzaWJpbGl0eSkgewotCQkJCWNhc2UgUFJJVkFURToKLQkJCQljYXNlIFBBQ0tBR0U6Ci0JCQkJY2FzZSBQUk9URUNURUQ6Ci0JCQkJCXRoaXMuZmllbGRWaXNpYmlsaXR5ID0gZmllbGRWaXNpYmlsaXR5OwotCQkJCQlicmVhazsKLQkJCQlkZWZhdWx0OgotCQkJCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJpbnZhbGlkIGZpZWxkIHZpc2liaWxpdHk6ICIgKyBmaWVsZFZpc2liaWxpdHkpOyAgLy8kTk9OLU5MUy0xJAotCQkJfQotCQl9Ci0JCVN0cmluZyBnZXRGaWVsZFZpc2liaWxpdHlDbGF1c2UoKSB7Ci0JCQlzd2l0Y2ggKHRoaXMuZmllbGRWaXNpYmlsaXR5KSB7Ci0JCQkJY2FzZSBQUklWQVRFOgotCQkJCQlyZXR1cm4gInByaXZhdGUiOyAgLy8kTk9OLU5MUy0xJAotCQkJCWNhc2UgUEFDS0FHRToKLQkJCQkJcmV0dXJuICIiOyAgLy8kTk9OLU5MUy0xJAotCQkJCWNhc2UgUFJPVEVDVEVEOgotCQkJCQlyZXR1cm4gInByb3RlY3RlZCI7ICAvLyROT04tTkxTLTEkCi0JCQkJZGVmYXVsdDoKLQkJCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigiaW52YWxpZCBmaWVsZCB2aXNpYmlsaXR5OiAiICsgdGhpcy5maWVsZFZpc2liaWxpdHkpOyAgLy8kTk9OLU5MUy0xJAotCQkJfQotCQl9Ci0KLQkJcHVibGljIGludCBnZXRNZXRob2RWaXNpYmlsaXR5KCkgewotCQkJcmV0dXJuIHRoaXMubWV0aG9kVmlzaWJpbGl0eTsKLQkJfQotCQkvKiogZW50aXR5IHByb3BlcnRpZXMgbXVzdCBiZSAncHVibGljJyBvciAncHJvdGVjdGVkJyAqLwotCQlwdWJsaWMgdm9pZCBzZXRNZXRob2RWaXNpYmlsaXR5KGludCBtZXRob2RWaXNpYmlsaXR5KSB7Ci0JCQlzd2l0Y2ggKG1ldGhvZFZpc2liaWxpdHkpIHsKLQkJCQljYXNlIFBST1RFQ1RFRDoKLQkJCQljYXNlIFBVQkxJQzoKLQkJCQkJdGhpcy5tZXRob2RWaXNpYmlsaXR5ID0gbWV0aG9kVmlzaWJpbGl0eTsKLQkJCQkJYnJlYWs7Ci0JCQkJZGVmYXVsdDoKLQkJCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiaW52YWxpZCBtZXRob2QgdmlzaWJpbGl0eTogIiArIG1ldGhvZFZpc2liaWxpdHkpOyAgLy8kTk9OLU5MUy0xJAotCQkJfQotCQl9Ci0JCVN0cmluZyBnZXRNZXRob2RWaXNpYmlsaXR5Q2xhdXNlKCkgewotCQkJc3dpdGNoICh0aGlzLm1ldGhvZFZpc2liaWxpdHkpIHsKLQkJCQljYXNlIFBST1RFQ1RFRDoKLQkJCQkJcmV0dXJuICJwcm90ZWN0ZWQiOyAgLy8kTk9OLU5MUy0xJAotCQkJCWNhc2UgUFVCTElDOgotCQkJCQlyZXR1cm4gInB1YmxpYyI7ICAvLyROT04tTkxTLTEkCi0JCQkJZGVmYXVsdDoKLQkJCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigiaW52YWxpZCBtZXRob2QgdmlzaWJpbGl0eTogIiArIHRoaXMubWV0aG9kVmlzaWJpbGl0eSk7ICAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCX0KLQotCQlwdWJsaWMgYm9vbGVhbiBnZW5lcmF0ZUdldHRlcnNBbmRTZXR0ZXJzKCkgewotCQkJcmV0dXJuIHRoaXMuZ2VuZXJhdGVHZXR0ZXJzQW5kU2V0dGVyczsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXRHZW5lcmF0ZUdldHRlcnNBbmRTZXR0ZXJzKGJvb2xlYW4gZ2VuZXJhdGVHZXR0ZXJzQW5kU2V0dGVycykgewotCQkJdGhpcy5nZW5lcmF0ZUdldHRlcnNBbmRTZXR0ZXJzID0gZ2VuZXJhdGVHZXR0ZXJzQW5kU2V0dGVyczsKLQkJfQotCi0JCXB1YmxpYyBib29sZWFuIGdlbmVyYXRlRGVmYXVsdENvbnN0cnVjdG9yKCkgewotCQkJcmV0dXJuIHRoaXMuZ2VuZXJhdGVEZWZhdWx0Q29uc3RydWN0b3I7Ci0JCX0KLQkJcHVibGljIHZvaWQgc2V0R2VuZXJhdGVEZWZhdWx0Q29uc3RydWN0b3IoYm9vbGVhbiBnZW5lcmF0ZURlZmF1bHRDb25zdHJ1Y3RvcikgewotCQkJdGhpcy5nZW5lcmF0ZURlZmF1bHRDb25zdHJ1Y3RvciA9IGdlbmVyYXRlRGVmYXVsdENvbnN0cnVjdG9yOwotCQl9Ci0KLQkJcHVibGljIGJvb2xlYW4gc2VyaWFsaXphYmxlKCkgewotCQkJcmV0dXJuIHRoaXMuc2VyaWFsaXphYmxlOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldFNlcmlhbGl6YWJsZShib29sZWFuIHNlcmlhbGl6YWJsZSkgewotCQkJdGhpcy5zZXJpYWxpemFibGUgPSBzZXJpYWxpemFibGU7Ci0JCX0KLQotCQlwdWJsaWMgYm9vbGVhbiBnZW5lcmF0ZVNlcmlhbFZlcnNpb25VSUQoKSB7Ci0JCQlyZXR1cm4gdGhpcy5nZW5lcmF0ZVNlcmlhbFZlcnNpb25VSUQ7Ci0JCX0KLQkJcHVibGljIHZvaWQgc2V0R2VuZXJhdGVTZXJpYWxWZXJzaW9uVUlEKGJvb2xlYW4gZ2VuZXJhdGVTZXJpYWxWZXJzaW9uVUlEKSB7Ci0JCQl0aGlzLmdlbmVyYXRlU2VyaWFsVmVyc2lvblVJRCA9IGdlbmVyYXRlU2VyaWFsVmVyc2lvblVJRDsKLQkJfQotCi0JCXB1YmxpYyBib29sZWFuIGdlbmVyYXRlRW1iZWRkZWRJZEZvckNvbXBvdW5kUEsoKSB7Ci0JCQlyZXR1cm4gdGhpcy5nZW5lcmF0ZUVtYmVkZGVkSWRGb3JDb21wb3VuZFBLOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldEdlbmVyYXRlRW1iZWRkZWRJZEZvckNvbXBvdW5kUEsoYm9vbGVhbiBnZW5lcmF0ZUVtYmVkZGVkSWRGb3JDb21wb3VuZFBLKSB7Ci0JCQl0aGlzLmdlbmVyYXRlRW1iZWRkZWRJZEZvckNvbXBvdW5kUEsgPSBnZW5lcmF0ZUVtYmVkZGVkSWRGb3JDb21wb3VuZFBLOwotCQl9Ci0KLQkJcHVibGljIGJvb2xlYW4gZ2VuZXJhdGVJZENsYXNzRm9yQ29tcG91bmRQSygpIHsKLQkJCXJldHVybiAhIHRoaXMuZ2VuZXJhdGVFbWJlZGRlZElkRm9yQ29tcG91bmRQSzsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXRHZW5lcmF0ZUlkQ2xhc3NGb3JDb21wb3VuZFBLKGJvb2xlYW4gZ2VuZXJhdGVJZENsYXNzRm9yQ29tcG91bmRQSykgewotCQkJdGhpcy5nZW5lcmF0ZUVtYmVkZGVkSWRGb3JDb21wb3VuZFBLID0gISBnZW5lcmF0ZUlkQ2xhc3NGb3JDb21wb3VuZFBLOwotCQl9Ci0KLQkJcHVibGljIFN0cmluZyBnZXRFbWJlZGRlZElkQXR0cmlidXRlTmFtZSgpIHsKLQkJCXJldHVybiB0aGlzLmVtYmVkZGVkSWRBdHRyaWJ1dGVOYW1lOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldEVtYmVkZGVkSWRBdHRyaWJ1dGVOYW1lKFN0cmluZyBlbWJlZGRlZElkQXR0cmlidXRlTmFtZSkgewotCQkJdGhpcy5jaGVja1JlcXVpcmVkU3RyaW5nKGVtYmVkZGVkSWRBdHRyaWJ1dGVOYW1lLCAiRW1iZWRkZWRJZCBhdHRyaWJ1dGUgbmFtZSBpcyByZXF1aXJlZCIpOyAgLy8kTk9OLU5MUy0xJAotCQkJdGhpcy5lbWJlZGRlZElkQXR0cmlidXRlTmFtZSA9IGVtYmVkZGVkSWRBdHRyaWJ1dGVOYW1lOwotCQl9Ci0KLQkJcHVibGljIFN0cmluZyBnZXRQcmltYXJ5S2V5TWVtYmVyQ2xhc3NOYW1lKCkgewotCQkJcmV0dXJuIHRoaXMucHJpbWFyeUtleU1lbWJlckNsYXNzTmFtZTsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXRQcmltYXJ5S2V5TWVtYmVyQ2xhc3NOYW1lKFN0cmluZyBwcmltYXJ5S2V5TWVtYmVyQ2xhc3NOYW1lKSB7Ci0JCQl0aGlzLmNoZWNrUmVxdWlyZWRTdHJpbmcocHJpbWFyeUtleU1lbWJlckNsYXNzTmFtZSwgInByaW1hcnkga2V5IG1lbWJlciBjbGFzcyBuYW1lIGlzIHJlcXVpcmVkIik7ICAvLyROT04tTkxTLTEkCi0JCQl0aGlzLnByaW1hcnlLZXlNZW1iZXJDbGFzc05hbWUgPSBwcmltYXJ5S2V5TWVtYmVyQ2xhc3NOYW1lOwotCQl9Ci0KLQkJU3RyaW5nIGdldEVudGl0eU5hbWUoVGFibGUgdGFibGUpIHsKLQkJCXJldHVybiB0aGlzLnRhYmxlcy5nZXQodGFibGUpOwotCQl9Ci0JCUl0ZXJhdG9yPFRhYmxlPiB0YWJsZXMoKSB7Ci0JCQlyZXR1cm4gdGhpcy50YWJsZXMua2V5U2V0KCkuaXRlcmF0b3IoKTsKLQkJfQotCQlpbnQgdGFibGVzU2l6ZSgpIHsKLQkJCXJldHVybiB0aGlzLnRhYmxlcy5zaXplKCk7Ci0JCX0KLQkJcHVibGljIHZvaWQgYWRkVGFibGUoVGFibGUgdGFibGUsIFN0cmluZyBlbnRpdHlOYW1lKSB7Ci0JCQlpZiAodGFibGUgPT0gbnVsbCkgewotCQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigidGFibGUgaXMgcmVxdWlyZWQiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCX0KLQkJCXRoaXMuY2hlY2tSZXF1aXJlZFN0cmluZyhlbnRpdHlOYW1lLCAiZW50aXR5IG5hbWUgaXMgcmVxdWlyZWQiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCWlmICh0aGlzLnRhYmxlcy5jb250YWluc0tleSh0YWJsZSkpIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJkdXBsaWNhdGUgdGFibGU6ICIgKyB0YWJsZS5nZXROYW1lKCkpOyAgLy8kTk9OLU5MUy0xJAotCQkJfQotCQkJaWYgKHRoaXMudGFibGVzLnZhbHVlcygpLmNvbnRhaW5zKGVudGl0eU5hbWUpKSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiZHVwbGljYXRlIGVudGl0eSBuYW1lOiAiICsgZW50aXR5TmFtZSk7ICAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCQlpZiAoICEgTmFtZVRvb2xzLnN0cmluZ0NvbnNpc3RzT2ZKYXZhSWRlbnRpZmllckNoYXJhY3RlcnMoZW50aXR5TmFtZSkpIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJlbnRpdHkgbmFtZSBpcyBub3QgYSB2YWxpZCBKYXZhIGlkZW50aWZpZXI6ICIgKyBlbnRpdHlOYW1lKTsgIC8vJE5PTi1OTFMtMSQKLQkJCX0KLQkJCWlmIChOYW1lVG9vbHMuSkFWQV9SRVNFUlZFRF9XT1JEU19TRVQuY29udGFpbnMoZW50aXR5TmFtZSkpIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJlbnRpdHkgbmFtZSBpcyBhIEphdmEgcmVzZXJ2ZWQgd29yZDogIiArIGVudGl0eU5hbWUpOyAgLy8kTk9OLU5MUy0xJAotCQkJfQotCQkJdGhpcy50YWJsZXMucHV0KHRhYmxlLCBlbnRpdHlOYW1lKTsKLQkJfQotCi0JCXB1YmxpYyBEYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlciBnZXREYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlcigpIHsKLQkJCXJldHVybiB0aGlzLmRhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyKERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyIGRhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyKSB7Ci0JCQlpZiAoZGF0YWJhc2VBbm5vdGF0aW9uTmFtZUJ1aWxkZXIgPT0gbnVsbCkgewotCQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigiZGF0YWJhc2UgYW5ub3RhdGlvbiBuYW1lIGJ1aWxkZXIgaXMgcmVxdWlyZWQiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCX0KLQkJCXRoaXMuZGF0YWJhc2VBbm5vdGF0aW9uTmFtZUJ1aWxkZXIgPSBkYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlcjsKLQkJfQotCi0JCXB1YmxpYyBPdmVyd3JpdGVDb25maXJtZXIgZ2V0T3ZlcndyaXRlQ29uZmlybWVyKCkgewotCQkJcmV0dXJuIHRoaXMub3ZlcndyaXRlQ29uZmlybWVyOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldE92ZXJ3cml0ZUNvbmZpcm1lcihPdmVyd3JpdGVDb25maXJtZXIgb3ZlcndyaXRlQ29uZmlybWVyKSB7Ci0JCQlpZiAob3ZlcndyaXRlQ29uZmlybWVyID09IG51bGwpIHsKLQkJCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oIm92ZXJ3cml0ZSBjb25maXJtZXIgaXMgcmVxdWlyZWQiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCX0KLQkJCXRoaXMub3ZlcndyaXRlQ29uZmlybWVyID0gb3ZlcndyaXRlQ29uZmlybWVyOwotCQl9Ci0KLQkJcHJpdmF0ZSB2b2lkIGNoZWNrUmVxdWlyZWRTdHJpbmcoU3RyaW5nIHN0cmluZywgU3RyaW5nIG1lc3NhZ2UpIHsKLQkJCWlmICgoc3RyaW5nID09IG51bGwpIHx8IChzdHJpbmcubGVuZ3RoKCkgPT0gMCkpIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKG1lc3NhZ2UpOwotCQkJfQotCQl9Ci0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogb3ZlcndyaXRlIGNvbmZpcm1lciAqKioqKioqKioqCi0KLQlwdWJsaWMgc3RhdGljIGludGVyZmFjZSBPdmVyd3JpdGVDb25maXJtZXIgewotCQkvKioKLQkJICogUmV0dXJuIHdoZXRoZXIgdGhlIGVudGl0eSBnZW5lcmF0b3Igc2hvdWxkIG92ZXJ3cml0ZSB0aGUgc3BlY2lmaWVkCi0JCSAqIGZpbGUuCi0JCSAqLwotCQlib29sZWFuIG92ZXJ3cml0ZShTdHJpbmcgY2xhc3NOYW1lKTsKLQotCi0JCWZpbmFsIGNsYXNzIEFsd2F5cyBpbXBsZW1lbnRzIE92ZXJ3cml0ZUNvbmZpcm1lciB7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIE92ZXJ3cml0ZUNvbmZpcm1lciBJTlNUQU5DRSA9IG5ldyBBbHdheXMoKTsKLQkJCXB1YmxpYyBzdGF0aWMgT3ZlcndyaXRlQ29uZmlybWVyIGluc3RhbmNlKCkgewotCQkJCXJldHVybiBJTlNUQU5DRTsKLQkJCX0KLQkJCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJCXByaXZhdGUgQWx3YXlzKCkgewotCQkJCXN1cGVyKCk7Ci0JCQl9Ci0JCQkvLyBldmVyeXRoaW5nIHdpbGwgYmUgb3ZlcndyaXR0ZW4KLQkJCXB1YmxpYyBib29sZWFuIG92ZXJ3cml0ZShTdHJpbmcgYXJnMCkgewotCQkJCXJldHVybiB0cnVlOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiT3ZlcndyaXRlQ29uZmlybWVyLkFsd2F5cyI7ICAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCX0KLQotCi0JCWZpbmFsIGNsYXNzIE5ldmVyIGltcGxlbWVudHMgT3ZlcndyaXRlQ29uZmlybWVyIHsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgT3ZlcndyaXRlQ29uZmlybWVyIElOU1RBTkNFID0gbmV3IE5ldmVyKCk7Ci0JCQlwdWJsaWMgc3RhdGljIE92ZXJ3cml0ZUNvbmZpcm1lciBpbnN0YW5jZSgpIHsKLQkJCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCQl9Ci0JCQkvLyBlbnN1cmUgc2luZ2xlIGluc3RhbmNlCi0JCQlwcml2YXRlIE5ldmVyKCkgewotCQkJCXN1cGVyKCk7Ci0JCQl9Ci0JCQkvLyBub3RoaW5nIHdpbGwgYmUgb3ZlcndyaXR0ZW4KLQkJCXB1YmxpYyBib29sZWFuIG92ZXJ3cml0ZShTdHJpbmcgYXJnMCkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gIk92ZXJ3cml0ZUNvbmZpcm1lci5OZXZlciI7ICAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCX0KLQotCX0KLQotCi0JLy8gKioqKioqKioqKiBhbm5vdGF0aW9uIG5hbWUgYnVpbGRlciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBQcm92aWRlIGEgcGx1Z2dhYmxlIHdheSB0byBkZXRlcm1pbmUgd2hldGhlciBhbmQgaG93IHRoZSBlbnRpdHkgZ2VuZXJhdG9yCi0JICogcHJpbnRzIHRoZSBuYW1lcyBvZiB2YXJpb3VzIGRhdGFiYXNlIG9iamVjdHMuCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnRlcmZhY2UgRGF0YWJhc2VBbm5vdGF0aW9uTmFtZUJ1aWxkZXIgewotCi0JCS8qKgotCQkgKiBHaXZlbiB0aGUgbmFtZSBvZiBhbiBlbnRpdHkgYW5kIHRoZSB0YWJsZSB0byB3aGljaCBpdCBpcyBtYXBwZWQsCi0JCSAqIGJ1aWxkIGFuZCByZXR1cm4gYSBzdHJpbmcgdG8gYmUgdXNlZCBhcyB0aGUgdmFsdWUgZm9yIHRoZSBlbnRpdHkncwotCQkgKiBUYWJsZSBhbm5vdGF0aW9uJ3MgJ25hbWUnIGVsZW1lbnQuIFJldHVybiBudWxsIGlmIHRoZSBlbnRpdHkKLQkJICogbWFwcyB0byB0aGUgdGFibGUgYnkgZGVmYXVsdC4KLQkJICovCi0JCVN0cmluZyBidWlsZFRhYmxlQW5ub3RhdGlvbk5hbWUoU3RyaW5nIGVudGl0eU5hbWUsIFRhYmxlIHRhYmxlKTsKLQotCQkvKioKLQkJICogR2l2ZW4gdGhlIG5hbWUgb2YgYW4gYXR0cmlidXRlIChmaWVsZCBvciBwcm9wZXJ0eSkgYW5kIHRoZSBjb2x1bW4KLQkJICogdG8gd2hpY2ggaXQgaXMgbWFwcGVkLAotCQkgKiBidWlsZCBhbmQgcmV0dXJuIGEgc3RyaW5nIHRvIGJlIHVzZWQgYXMgdGhlIHZhbHVlIGZvciB0aGUgYXR0cmlidXRlJ3MKLQkJICogQ29sdW1uIGFubm90YXRpb24ncyAnbmFtZScgZWxlbWVudC4gUmV0dXJuIG51bGwgaWYgdGhlIGF0dHJpYnV0ZQotCQkgKiBtYXBzIHRvIHRoZSBjb2x1bW4gYnkgZGVmYXVsdC4KLQkJICovCi0JCVN0cmluZyBidWlsZENvbHVtbkFubm90YXRpb25OYW1lKFN0cmluZyBhdHRyaWJ1dGVOYW1lLCBDb2x1bW4gY29sdW1uKTsKLQotCQkvKioKLQkJICogR2l2ZW4gdGhlIG5hbWUgb2YgYW4gYXR0cmlidXRlIChmaWVsZCBvciBwcm9wZXJ0eSkgYW5kIHRoZQotCQkgKiBtYW55LXRvLW9uZSBvciBtYW55LXRvLW1hbnkgZm9yZWlnbiBrZXkgdG8gd2hpY2ggaXQgaXMgbWFwcGVkLAotCQkgKiBidWlsZCBhbmQgcmV0dXJuIGEgc3RyaW5nIHRvIGJlIHVzZWQgYXMgdGhlIHZhbHVlIGZvciB0aGUgYXR0cmlidXRlJ3MKLQkJICogSm9pbkNvbHVtbiBhbm5vdGF0aW9uJ3MgJ25hbWUnIGVsZW1lbnQuIFJldHVybiBudWxsIGlmIHRoZSBhdHRyaWJ1dGUKLQkJICogbWFwcyB0byB0aGUgam9pbiBjb2x1bW4gYnkgZGVmYXVsdC4KLQkJICogVGhlIHNwZWNpZmllZCBmb3JlaWduIGtleSBjb25zaXN0cyBvZiBhIHNpbmdsZSBjb2x1bW4gcGFpciB3aG9zZQotCQkgKiByZWZlcmVuY2VkIGNvbHVtbiBpcyB0aGUgc2luZ2xlLWNvbHVtbiBwcmltYXJ5IGtleSBvZiB0aGUgZm9yZWlnbgotCQkgKiBrZXkncyByZWZlcmVuY2VkIHRhYmxlLgotCQkgKi8KLQkJU3RyaW5nIGJ1aWxkSm9pbkNvbHVtbkFubm90YXRpb25OYW1lKFN0cmluZyBhdHRyaWJ1dGVOYW1lLCBGb3JlaWduS2V5IGZvcmVpZ25LZXkpOwotCi0JCS8qKgotCQkgKiBCdWlsZCBhbmQgcmV0dXJuIGEgc3RyaW5nIHRvIGJlIHVzZWQgYXMgdGhlIHZhbHVlIGZvciBhIEpvaW5Db2x1bW4KLQkJICogYW5ub3RhdGlvbidzICduYW1lJyBvciAncmVmZXJlbmNlZENvbHVtbk5hbWUnIGVsZW1lbnQuCi0JCSAqIFRoaXMgaXMgY2FsbGVkIGZvciBtYW55LXRvLW9uZSBhbmQgbWFueS10by1tYW55IG1hcHBpbmdzIHdoZW4KLQkJICogdGhlIGRlZmF1bHQgam9pbiBjb2x1bW4gbmFtZSBhbmQvb3IgcmVmZXJlbmNlZCBjb2x1bW4gbmFtZSBhcmUvaXMKLQkJICogbm90IGFwcGxpY2FibGUuCi0JCSAqIEBzZWUgYnVpbGRKb2luQ29sdW1uQW5ub3RhdGlvbk5hbWUoU3RyaW5nLCBGb3JlaWduS2V5KQotCQkgKi8KLQkJU3RyaW5nIGJ1aWxkSm9pbkNvbHVtbkFubm90YXRpb25OYW1lKENvbHVtbiBjb2x1bW4pOwotCi0JCS8qKgotCQkgKiBCdWlsZCBhbmQgcmV0dXJuIGEgc3RyaW5nIHRvIGJlIHVzZWQgYXMgdGhlIHZhbHVlIGZvciBhIEpvaW5UYWJsZQotCQkgKiBhbm5vdGF0aW9uJ3MgJ25hbWUnIGVsZW1lbnQuCi0JCSAqIFRoaXMgaXMgY2FsbGVkIGZvciBtYW55LXRvLW1hbnkgbWFwcGluZ3Mgd2hlbiB0aGUgZGVmYXVsdAotCQkgKiBqb2luIHRhYmxlIG5hbWUgaXMgbm90IGFwcGxpY2FibGUuCi0JCSAqLwotCQlTdHJpbmcgYnVpbGRKb2luVGFibGVBbm5vdGF0aW9uTmFtZShUYWJsZSB0YWJsZSk7Ci0KLQotCQkvKioKLQkJICogVGhlIGRlZmF1bHQgaW1wbGVtZW50YXRpb24gc2ltcGxlIHJldHVybnMgdGhlIGRhdGFiYXNlIG9iamVjdCdzIG5hbWUsCi0JCSAqIHVuYWx0ZXJlZC4KLQkJICovCi0JCWZpbmFsIGNsYXNzIERlZmF1bHQgaW1wbGVtZW50cyBEYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlciB7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyIElOU1RBTkNFID0gbmV3IERlZmF1bHQoKTsKLQkJCXB1YmxpYyBzdGF0aWMgRGF0YWJhc2VBbm5vdGF0aW9uTmFtZUJ1aWxkZXIgaW5zdGFuY2UoKSB7Ci0JCQkJcmV0dXJuIElOU1RBTkNFOwotCQkJfQotCQkJLy8gZW5zdXJlIHNpbmdsZSBpbnN0YW5jZQotCQkJcHJpdmF0ZSBEZWZhdWx0KCkgewotCQkJCXN1cGVyKCk7Ci0JCQl9Ci0JCQlwdWJsaWMgU3RyaW5nIGJ1aWxkVGFibGVBbm5vdGF0aW9uTmFtZShTdHJpbmcgZW50aXR5TmFtZSwgVGFibGUgdGFibGUpIHsKLQkJCQlyZXR1cm4gdGFibGUuZ2V0TmFtZSgpOwotCQkJfQotCQkJcHVibGljIFN0cmluZyBidWlsZENvbHVtbkFubm90YXRpb25OYW1lKFN0cmluZyBhdHRyaWJ1dGVOYW1lLCBDb2x1bW4gY29sdW1uKSB7Ci0JCQkJcmV0dXJuIGNvbHVtbi5nZXROYW1lKCk7Ci0JCQl9Ci0JCQlwdWJsaWMgU3RyaW5nIGJ1aWxkSm9pbkNvbHVtbkFubm90YXRpb25OYW1lKFN0cmluZyBhdHRyaWJ1dGVOYW1lLCBGb3JlaWduS2V5IGZvcmVpZ25LZXkpIHsKLQkJCQlyZXR1cm4gZm9yZWlnbktleS5nZXRDb2x1bW5QYWlyKCkuZ2V0QmFzZUNvbHVtbigpLmdldE5hbWUoKTsKLQkJCX0KLQkJCXB1YmxpYyBTdHJpbmcgYnVpbGRKb2luQ29sdW1uQW5ub3RhdGlvbk5hbWUoQ29sdW1uIGNvbHVtbikgewotCQkJCXJldHVybiBjb2x1bW4uZ2V0TmFtZSgpOwotCQkJfQotCQkJcHVibGljIFN0cmluZyBidWlsZEpvaW5UYWJsZUFubm90YXRpb25OYW1lKFRhYmxlIHRhYmxlKSB7Ci0JCQkJcmV0dXJuIHRhYmxlLmdldE5hbWUoKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gIkRhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyLkRlZmF1bHQiOyAgLy8kTk9OLU5MUy0xJAotCQkJfQotCQl9Ci0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwvR2VuU2NvcGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwvR2VuU2NvcGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNGU1MjRlNi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsL0dlblNjb3BlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxODYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsOwotCi1pbXBvcnQgamF2YS51dGlsLkhhc2hNYXA7Ci1pbXBvcnQgamF2YS51dGlsLkhhc2hTZXQ7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5JUHJvZ3Jlc3NNb25pdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5PcGVyYXRpb25DYW5jZWxlZEV4Y2VwdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuU3ViTW9uaXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuVGFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5GaWx0ZXJpbmdJdGVyYXRvcjsKLQotLyoqCi0gKiBCdWlsZCBhIEdlblRhYmxlIGZvciBlYWNoIGRiLlRhYmxlIHBhc3NlZCBpbi4KLSAqIERldGVybWluZSBhbGwgdGhlIHJlbGF0aW9ucyBhbW9uZyB0aGUgdGFibGVzIGluIHRoZSBzY29wZToKLSAqICAgICBtYW55LXRvLW1hbnkKLSAqICAgICBtYW55LXRvLW9uZQotICogICAgIG9uZS10by1tYW55Ci0gKiBNYWtlIGEgZmlyc3QgcGFzcyB0byBkZXRlcm1pbmUgZWFjaCBlbnRpdHkgdGFibGUncyBKYXZhIGF0dHJpYnV0ZSBuYW1lcywKLSAqIGJlY2F1c2Ugd2Ugd2lsbCBuZWVkIHRoZW0gb24gc3Vic2VxdWVudCBwYXNzZXMuCi0gKi8KLWNsYXNzIEdlblNjb3BlIHsKLQlwcml2YXRlIGZpbmFsIEVudGl0eUdlbmVyYXRvci5Db25maWcgZW50aXR5Q29uZmlnOwotCXByaXZhdGUgZmluYWwgSGFzaE1hcDxUYWJsZSwgR2VuVGFibGU+IGdlblRhYmxlczsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3Rpb24vaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JR2VuU2NvcGUoRW50aXR5R2VuZXJhdG9yLkNvbmZpZyBlbnRpdHlDb25maWcsIElQcm9ncmVzc01vbml0b3IgcHJvZ3Jlc3NNb25pdG9yKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuZW50aXR5Q29uZmlnID0gZW50aXR5Q29uZmlnOwotCQl0aGlzLmdlblRhYmxlcyA9IG5ldyBIYXNoTWFwPFRhYmxlLCBHZW5UYWJsZT4oZW50aXR5Q29uZmlnLnRhYmxlc1NpemUoKSk7Ci0JCVN1Yk1vbml0b3Igc20gPSBTdWJNb25pdG9yLmNvbnZlcnQocHJvZ3Jlc3NNb25pdG9yLCBKcHRHZW5NZXNzYWdlcy5HZW5TY29wZV90YXNrTmFtZSwgNCk7Ci0KLQkJdGhpcy5idWlsZEdlblRhYmxlcygpOwotCQlzbS53b3JrZWQoMSk7Ci0JCXRoaXMuY2hlY2tDYW5jZWxlZChzbSk7Ci0KLQkJdGhpcy5idWlsZE1hbnlUb01hbnlSZWxhdGlvbnMoKTsKLQkJc20ud29ya2VkKDEpOwotCQl0aGlzLmNoZWNrQ2FuY2VsZWQoc20pOwotCi0JCXRoaXMuYnVpbGRNYW55VG9PbmVSZWxhdGlvbnMoKTsgIC8vIHRoaXMgd2lsbCBhbHNvIGJ1aWxkIHRoZSBjb3JyZXNwb25kaW5nIG9uZS10by1tYW55IHJlbGF0aW9ucwotCQlzbS53b3JrZWQoMSk7Ci0JCXRoaXMuY2hlY2tDYW5jZWxlZChzbSk7Ci0KLQkJdGhpcy5idWlsZEF0dHJpYnV0ZU5hbWVzKCk7Ci0JCXNtLndvcmtlZCgxKTsKLQkJdGhpcy5jaGVja0NhbmNlbGVkKHNtKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRHZW5UYWJsZXMoKSB7Ci0JCWZvciAoSXRlcmF0b3I8VGFibGU+IHN0cmVhbSA9IGVudGl0eUNvbmZpZy50YWJsZXMoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQlUYWJsZSB0YWJsZSA9IHN0cmVhbS5uZXh0KCk7Ci0JCQl0aGlzLmdlblRhYmxlcy5wdXQodGFibGUsIG5ldyBHZW5UYWJsZSh0aGlzLCB0YWJsZSkpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogZmluZCBhbGwgdGhlICJqb2luIiB0YWJsZXMKLQkgKi8KLQlwcml2YXRlIHZvaWQgYnVpbGRNYW55VG9NYW55UmVsYXRpb25zKCkgewotCQlmb3IgKEl0ZXJhdG9yPEdlblRhYmxlPiBzdHJlYW0gPSB0aGlzLmdlblRhYmxlcygpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCXN0cmVhbS5uZXh0KCkuYnVpbGRKb2luVGFibGVSZWxhdGlvbigpOwotCQl9Ci0KLQkJLy8gcmV2ZXJ0IGFueSAiam9pbiIgdGFibGUgdGhhdCBpcyByZWZlcmVuY2VkIGJ5IGFub3RoZXIgdGFibGUgYmFjayB0byBhbiAiZW50aXR5IiB0YWJsZQotCQlIYXNoU2V0PEdlblRhYmxlPiByZWZlcmVuY2VkR2VuVGFibGVzID0gdGhpcy5idWlsZFJlZmVyZW5jZWRHZW5UYWJsZXMoKTsKLQkJZm9yIChJdGVyYXRvcjxHZW5UYWJsZT4gc3RyZWFtID0gdGhpcy5qb2luR2VuVGFibGVzKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJR2VuVGFibGUgam9pbkdlblRhYmxlID0gc3RyZWFtLm5leHQoKTsKLQkJCWlmIChyZWZlcmVuY2VkR2VuVGFibGVzLmNvbnRhaW5zKGpvaW5HZW5UYWJsZSkpIHsKLQkJCQlqb2luR2VuVGFibGUuY2xlYXJKb2luVGFibGVSZWxhdGlvbigpOwotCQkJfQotCQl9Ci0JfQotCi0JLyoqCi0JICogZmluZCBhbGwgdGhlIG1hbnktdG8tb25lIGFuZCBjb3JyZXNwb25kaW5nIG9uZS10by1tYW55IHJlbGF0aW9ucwotCSAqLwotCXByaXZhdGUgdm9pZCBidWlsZE1hbnlUb09uZVJlbGF0aW9ucygpIHsKLQkJZm9yIChJdGVyYXRvcjxHZW5UYWJsZT4gc3RyZWFtID0gdGhpcy5lbnRpdHlHZW5UYWJsZXMoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQlzdHJlYW0ubmV4dCgpLmJ1aWxkTWFueVRvT25lUmVsYXRpb25zKCk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBkZXRlcm1pbmUgYWxsIHRoZSBKYXZhIGF0dHJpYnV0ZSBuYW1lcyB1cC1mcm9udCBiZWNhdXNlIHdlIHdpbGwKLQkgKiBuZWVkIHRoZW0gZm9yIHRoaW5ncyBsaWtlICdtYXBwZWRCeScgYW5ub3RhdGlvbiBlbGVtZW50cwotCSAqLwotCXByaXZhdGUgdm9pZCBidWlsZEF0dHJpYnV0ZU5hbWVzKCkgewotCQlmb3IgKEl0ZXJhdG9yPEdlblRhYmxlPiBzdHJlYW0gPSB0aGlzLmVudGl0eUdlblRhYmxlcygpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCXN0cmVhbS5uZXh0KCkuYnVpbGRBdHRyaWJ1dGVOYW1lcygpOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHBhY2thZ2UgQVBJICoqKioqKioqKioKLQotCUVudGl0eUdlbmVyYXRvci5Db25maWcgZ2V0RW50aXR5Q29uZmlnKCkgewotCQlyZXR1cm4gdGhpcy5lbnRpdHlDb25maWc7Ci0JfQotCi0JLyoqCi0JICogcmV0dXJuIG9ubHkgdGhlIGdlbiB0YWJsZXMgdGhhdCBhcmUgc3VpdGFibGUgZm9yIGdlbmVyYXRpbmcKLQkgKiBlbnRpdGllcyAoaS5lLiBleGNsdWRlIHRoZSAiam9pbiIgdGFibGVzKQotCSAqLwotCUl0ZXJhdG9yPEdlblRhYmxlPiBlbnRpdHlHZW5UYWJsZXMoKSB7Ci0JCXJldHVybiBuZXcgRmlsdGVyaW5nSXRlcmF0b3I8R2VuVGFibGUsIEdlblRhYmxlPih0aGlzLmdlblRhYmxlcygpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBib29sZWFuIGFjY2VwdChHZW5UYWJsZSBnZW5UYWJsZSkgewotCQkJCXJldHVybiAhIGdlblRhYmxlLmlzSm9pblRhYmxlKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JaW50IGVudGl0eVRhYmxlc1NpemUoKSB7Ci0JCXJldHVybiBDb2xsZWN0aW9uVG9vbHMuc2l6ZSh0aGlzLmVudGl0eUdlblRhYmxlcygpKTsKLQl9Ci0KLQkvKioKLQkgKiByZXR1cm4gdGhlIGdlbiB0YWJsZSBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgZGIgdGFibGU7Ci0JICogcmV0dXJuIG51bGwgaWYgdGhlIGdlbiB0YWJsZSBpcyBub3QgImluLXNjb3BlIiAoZS5nLiBhIGRiIGZvcmVpZ24ga2V5Ci0JICogbWlnaHQgaGF2ZSBhIHJlZmVyZW5jZSB0byBhIGRiIHRhYmxlIHRoYXQgd2FzIG5vdCBpbmNsdWRlZCBpbiB0aGUKLQkgKiBzY29wZSwgc28gd2Ugd29uJ3QgaGF2ZSBhIGNvcnJlc3BvbmRpbmcgZ2VuIHRhYmxlKQotCSAqLwotCUdlblRhYmxlIGdldEdlblRhYmxlKFRhYmxlIHRhYmxlKSB7Ci0JCXJldHVybiB0aGlzLmdlblRhYmxlcy5nZXQodGFibGUpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbnRlcm5hbCBtZXRob2RzICoqKioqKioqKioKLQotCXByaXZhdGUgSXRlcmF0b3I8R2VuVGFibGU+IGdlblRhYmxlcygpIHsKLQkJcmV0dXJuIHRoaXMuZ2VuVGFibGVzLnZhbHVlcygpLml0ZXJhdG9yKCk7Ci0JfQotCi0JcHJpdmF0ZSBpbnQgZ2VuVGFibGVzU2l6ZSgpIHsKLQkJcmV0dXJuIHRoaXMuZ2VuVGFibGVzLnNpemUoKTsKLQl9Ci0KLQkvKioKLQkgKiByZXR1cm4gb25seSB0aGUgImpvaW4iIGdlbiB0YWJsZXMKLQkgKi8KLQlwcml2YXRlIEl0ZXJhdG9yPEdlblRhYmxlPiBqb2luR2VuVGFibGVzKCkgewotCQlyZXR1cm4gbmV3IEZpbHRlcmluZ0l0ZXJhdG9yPEdlblRhYmxlLCBHZW5UYWJsZT4odGhpcy5nZW5UYWJsZXMoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgYm9vbGVhbiBhY2NlcHQoR2VuVGFibGUgZ2VuVGFibGUpIHsKLQkJCQlyZXR1cm4gZ2VuVGFibGUuaXNKb2luVGFibGUoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQkvKioKLQkgKiBidWlsZCBhIHNldCBvZiB0aGUgZ2VuIHRhYmxlcyB0aGF0IGFyZSByZWZlcmVuY2VkIGJ5IG90aGVyIGdlbiB0YWJsZXMKLQkgKiBpbiB0aGUgc2NvcGUKLQkgKi8KLQlwcml2YXRlIEhhc2hTZXQ8R2VuVGFibGU+IGJ1aWxkUmVmZXJlbmNlZEdlblRhYmxlcygpIHsKLQkJSGFzaFNldDxHZW5UYWJsZT4gcmVmZXJlbmNlZEdlblRhYmxlcyA9IG5ldyBIYXNoU2V0PEdlblRhYmxlPih0aGlzLmdlblRhYmxlc1NpemUoKSk7Ci0JCWZvciAoSXRlcmF0b3I8R2VuVGFibGU+IHN0cmVhbSA9IHRoaXMuZ2VuVGFibGVzKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJc3RyZWFtLm5leHQoKS5hZGRSZWZlcmVuY2VkR2VuVGFibGVzVG8ocmVmZXJlbmNlZEdlblRhYmxlcyk7Ci0JCX0KLQkJcmV0dXJuIHJlZmVyZW5jZWRHZW5UYWJsZXM7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGNoZWNrQ2FuY2VsZWQoSVByb2dyZXNzTW9uaXRvciBwcm9ncmVzc01vbml0b3IpIHsKLQkJaWYgKHByb2dyZXNzTW9uaXRvci5pc0NhbmNlbGVkKCkpIHsKLQkJCXRocm93IG5ldyBPcGVyYXRpb25DYW5jZWxlZEV4Y2VwdGlvbigpOwotCQl9Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5nZW5UYWJsZXMpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbC9HZW5UYWJsZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbC9HZW5UYWJsZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjN2ZjYjI5Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwvR2VuVGFibGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDM3NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5nZW4uaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5IYXNoTWFwOwotaW1wb3J0IGphdmEudXRpbC5IYXNoU2V0OwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuU2V0OwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkNvbHVtbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuRm9yZWlnbktleTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuVGFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLk5hbWVUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuRmlsdGVyaW5nSXRlcmF0b3I7Ci0KLS8qKgotICogYXNzb2NpYXRlIGEgdGFibGUgd2l0aCB0aGUgdmFyaW91cyByZWxhdGlvbnMgdGhhdCB3aWxsIGJlIHVzZWQgd2hlbgotICogZ2VuZXJhdGluZyB0aGUgZW50aXR5IGNvcnJlc3BvbmRpbmcgdG8gdGhlIHRhYmxlCi0gKi8KLWNsYXNzIEdlblRhYmxlIHsKLQlwcml2YXRlIGZpbmFsIEdlblNjb3BlIHNjb3BlOwotCXByaXZhdGUgZmluYWwgVGFibGUgdGFibGU7Ci0KLQkvLyB0aGVzZSByZWxhdGlvbnMgY2Fubm90IGJlIGJ1aWx0IHVudGlsIGFmdGVyIHdlIGhhdmUgYnVpbHQgYWxsIHRoZSBzY29wZSdzIHRhYmxlcwotCXByaXZhdGUgTWFueVRvTWFueVJlbGF0aW9uIGpvaW5UYWJsZVJlbGF0aW9uOwotCXByaXZhdGUgZmluYWwgQXJyYXlMaXN0PE1hbnlUb01hbnlSZWxhdGlvbj4gb3duZWRNYW55VG9NYW55UmVsYXRpb25zID0gbmV3IEFycmF5TGlzdDxNYW55VG9NYW55UmVsYXRpb24+KCk7Ci0JcHJpdmF0ZSBmaW5hbCBBcnJheUxpc3Q8TWFueVRvTWFueVJlbGF0aW9uPiBub25Pd25lZE1hbnlUb01hbnlSZWxhdGlvbnMgPSBuZXcgQXJyYXlMaXN0PE1hbnlUb01hbnlSZWxhdGlvbj4oKTsKLQlwcml2YXRlIGZpbmFsIEFycmF5TGlzdDxNYW55VG9PbmVSZWxhdGlvbj4gbWFueVRvT25lUmVsYXRpb25zID0gbmV3IEFycmF5TGlzdDxNYW55VG9PbmVSZWxhdGlvbj4oKTsKLQlwcml2YXRlIGZpbmFsIEFycmF5TGlzdDxPbmVUb01hbnlSZWxhdGlvbj4gb25lVG9NYW55UmVsYXRpb25zID0gbmV3IEFycmF5TGlzdDxPbmVUb01hbnlSZWxhdGlvbj4oKTsKLQlwcml2YXRlIGZpbmFsIEhhc2hTZXQ8Q29sdW1uPiBmb3JlaWduS2V5Q29sdW1ucyA9IG5ldyBIYXNoU2V0PENvbHVtbj4oKTsKLQotCXByaXZhdGUgZmluYWwgSGFzaFNldDxTdHJpbmc+IGF0dHJpYnV0ZU5hbWVzID0gbmV3IEhhc2hTZXQ8U3RyaW5nPigpOwotCXByaXZhdGUgU3RyaW5nIGF0dHJpYnV0ZU5hbWVGb3JFbWJlZGRlZElkOwotCXByaXZhdGUgZmluYWwgSGFzaE1hcDxDb2x1bW4sIFN0cmluZz4gYmFzaWNBdHRyaWJ1dGVOYW1lcyA9IG5ldyBIYXNoTWFwPENvbHVtbiwgU3RyaW5nPigpOwotCXByaXZhdGUgZmluYWwgSGFzaE1hcDxNYW55VG9PbmVSZWxhdGlvbiwgU3RyaW5nPiBtYW55VG9PbmVBdHRyaWJ1dGVOYW1lcyA9IG5ldyBIYXNoTWFwPE1hbnlUb09uZVJlbGF0aW9uLCBTdHJpbmc+KCk7Ci0JcHJpdmF0ZSBmaW5hbCBIYXNoTWFwPE9uZVRvTWFueVJlbGF0aW9uLCBTdHJpbmc+IG9uZVRvTWFueUF0dHJpYnV0ZU5hbWVzID0gbmV3IEhhc2hNYXA8T25lVG9NYW55UmVsYXRpb24sIFN0cmluZz4oKTsKLQlwcml2YXRlIGZpbmFsIEhhc2hNYXA8TWFueVRvTWFueVJlbGF0aW9uLCBTdHJpbmc+IG93bmVkTWFueVRvTWFueUF0dHJpYnV0ZU5hbWVzID0gbmV3IEhhc2hNYXA8TWFueVRvTWFueVJlbGF0aW9uLCBTdHJpbmc+KCk7Ci0JcHJpdmF0ZSBmaW5hbCBIYXNoTWFwPE1hbnlUb01hbnlSZWxhdGlvbiwgU3RyaW5nPiBub25Pd25lZE1hbnlUb01hbnlBdHRyaWJ1dGVOYW1lcyA9IG5ldyBIYXNoTWFwPE1hbnlUb01hbnlSZWxhdGlvbiwgU3RyaW5nPigpOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdGlvbi9pbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0KLQlHZW5UYWJsZShHZW5TY29wZSBzY29wZSwgVGFibGUgdGFibGUpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5zY29wZSA9IHNjb3BlOwotCQl0aGlzLnRhYmxlID0gdGFibGU7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHBhY2thZ2UgQVBJICoqKioqKioqKioKLQotCUVudGl0eUdlbmVyYXRvci5Db25maWcgZ2V0RW50aXR5Q29uZmlnKCkgewotCQlyZXR1cm4gdGhpcy5zY29wZS5nZXRFbnRpdHlDb25maWcoKTsKLQl9Ci0KLQkvKioKLQkgKiBleGFtcGxlczoKLQkgKiAgIEdlblRhYmxlKEZPTykgPT4gIkZPT19DT0xMRUNUSU9OIgotCSAqICAgR2VuVGFibGUoZm9vKSA9PiAiZm9vQ29sbGVjdGlvbiIKLQkgKiAgIEdlblRhYmxlKEZvbykgPT4gIkZvb0NvbGxlY3Rpb24iCi0JICovCi0JU3RyaW5nIGdldENvbGxlY3Rpb25BdHRyaWJ1dGVOYW1lKCkgewotCQlTdHJpbmcgbmFtZSA9IHRoaXMuZ2V0TmFtZSgpOwotCQlTdHJpbmcgc3VmZml4ID0gdGhpcy5nZXRFbnRpdHlDb25maWcoKS5nZXRDb2xsZWN0aW9uQXR0cmlidXRlTmFtZVN1ZmZpeCgpOwotCQlpZiAoU3RyaW5nVG9vbHMuc3RyaW5nSXNVcHBlcmNhc2UobmFtZSkpIHsgIC8vIGhtbW0gIH5ianYKLQkJCXN1ZmZpeCA9ICdfJyArIHN1ZmZpeC50b1VwcGVyQ2FzZSgpOwotCQl9Ci0JCXJldHVybiBuYW1lICsgc3VmZml4OwotCX0KLQotCS8qKgotCSAqIGRldGVybWluZSB3aGV0aGVyIHRoZSB0YWJsZSBpcyBhICJqb2luIiB0YWJsZSB3aXRoaW4gdGhlIHRhYmxlJ3Mgc2NvcGU7Ci0JICogdGhpcyBjYW4gYmUgcmVtb3ZlZCwgbGF0ZXIsIGlmIHdlIGZpbmQgYW5vdGhlciB0YWJsZSByZWZlcmVuY2VzIHRoZSwKLQkgKiBzZWVtaW5nbHksIGpvaW4gdGFibGUKLQkgKiBAc2VlICNjbGVhckpvaW5UYWJsZVJlbGF0aW9uKCkgKGFuZCBjYWxsZXJzKQotCSAqLwotCXZvaWQgYnVpbGRKb2luVGFibGVSZWxhdGlvbigpIHsKLQkJaWYgKCAhIHRoaXMudGFibGUuaXNQb3NzaWJsZUpvaW5UYWJsZSgpKSB7Ci0JCQlyZXR1cm47ICAvLyB0aGUgdGFibGUgbXVzdCBoYXZlIGV4YWN0bHkgMiBmb3JlaWduIGtleXMKLQkJfQotCQlGb3JlaWduS2V5IG93bmluZ0ZLID0gdGhpcy50YWJsZS5nZXRKb2luVGFibGVPd25pbmdGb3JlaWduS2V5KCk7Ci0JCUdlblRhYmxlIG93bmluZ0dlblRhYmxlID0gdGhpcy5zY29wZS5nZXRHZW5UYWJsZShvd25pbmdGSy5nZXRSZWZlcmVuY2VkVGFibGUoKSk7Ci0JCWlmIChvd25pbmdHZW5UYWJsZSA9PSBudWxsKSB7Ci0JCQlyZXR1cm47ICAvLyBib3RoIHRhYmxlcyBtdXN0IGJlIGluIHRoZSBzY29wZQotCQl9Ci0JCUZvcmVpZ25LZXkgbm9uT3duaW5nRksgPSB0aGlzLnRhYmxlLmdldEpvaW5UYWJsZU5vbk93bmluZ0ZvcmVpZ25LZXkoKTsKLQkJR2VuVGFibGUgbm9uT3duaW5nR2VuVGFibGUgPSB0aGlzLnNjb3BlLmdldEdlblRhYmxlKG5vbk93bmluZ0ZLLmdldFJlZmVyZW5jZWRUYWJsZSgpKTsKLQkJaWYgKG5vbk93bmluZ0dlblRhYmxlID09IG51bGwpIHsKLQkJCXJldHVybjsgIC8vIGJvdGggdGFibGVzIG11c3QgYmUgaW4gdGhlIHNjb3BlCi0JCX0KLQkJdGhpcy5qb2luVGFibGVSZWxhdGlvbiA9IG5ldyBNYW55VG9NYW55UmVsYXRpb24oCi0JCQkJCQkJCQkJCXRoaXMsCi0JCQkJCQkJCQkJCW93bmluZ0ZLLAotCQkJCQkJCQkJCQlvd25pbmdHZW5UYWJsZSwKLQkJCQkJCQkJCQkJbm9uT3duaW5nRkssCi0JCQkJCQkJCQkJCW5vbk93bmluZ0dlblRhYmxlCi0JCQkJCQkJCQkJKTsKLQl9Ci0KLQkvKioKLQkgKiB1c2VkIGJ5IHRoZSBzY29wZSB0byBmaWd1cmUgb3V0IHdoZXRoZXIgImpvaW4iIHRhYmxlcyBzaG91bGQgYmUKLQkgKiBjb252ZXJ0ZWQgdG8gImVudGl0eSIgdGFibGVzCi0JICovCi0Jdm9pZCBhZGRSZWZlcmVuY2VkR2VuVGFibGVzVG8oU2V0PEdlblRhYmxlPiByZWZlcmVuY2VkVGFibGVzKSB7Ci0JCWZvciAoSXRlcmF0b3I8Rm9yZWlnbktleT4gc3RyZWFtID0gdGhpcy50YWJsZS5mb3JlaWduS2V5cygpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCUZvcmVpZ25LZXkgZmsgPSBzdHJlYW0ubmV4dCgpOwotCQkJR2VuVGFibGUgZ2VuVGFibGUgPSB0aGlzLnNjb3BlLmdldEdlblRhYmxlKGZrLmdldFJlZmVyZW5jZWRUYWJsZSgpKTsKLQkJCWlmIChnZW5UYWJsZSAhPSBudWxsKSB7Ci0JCQkJcmVmZXJlbmNlZFRhYmxlcy5hZGQoZ2VuVGFibGUpOwotCQkJfQotCQl9Ci0JfQotCi0JLyoqCi0JICogdGhlIHNjb3BlIGNsZWFycyB0aGUgam9pbiB0YWJsZSByZWxhdGlvbiBpZiB0aGVyZSBhcmUgYW55IHJlZmVyZW5jZXMKLQkgKiB0byB0aGUgam9pbiB0YWJsZSBmcm9tIG90aGVyIHRhYmxlcyBpbiB0aGUgc2NvcGUKLQkgKi8KLQl2b2lkIGNsZWFySm9pblRhYmxlUmVsYXRpb24oKSB7Ci0JCXRoaXMuam9pblRhYmxlUmVsYXRpb24uY2xlYXIoKTsKLQkJdGhpcy5qb2luVGFibGVSZWxhdGlvbiA9IG51bGw7Ci0JfQotCi0JLyoqCi0JICogZmluZCAiaW4tc2NvcGUiIGZvcmVpZ24ga2V5cwotCSAqLwotCXZvaWQgYnVpbGRNYW55VG9PbmVSZWxhdGlvbnMoKSB7Ci0JCWZvciAoSXRlcmF0b3I8Rm9yZWlnbktleT4gc3RyZWFtID0gdGhpcy50YWJsZS5mb3JlaWduS2V5cygpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCUZvcmVpZ25LZXkgZmsgPSBzdHJlYW0ubmV4dCgpOwotCQkJR2VuVGFibGUgcmVmZXJlbmNlZEdlblRhYmxlID0gdGhpcy5zY29wZS5nZXRHZW5UYWJsZShmay5nZXRSZWZlcmVuY2VkVGFibGUoKSk7Ci0JCQlpZiAocmVmZXJlbmNlZEdlblRhYmxlICE9IG51bGwpIHsKLQkJCQl0aGlzLm1hbnlUb09uZVJlbGF0aW9ucy5hZGQobmV3IE1hbnlUb09uZVJlbGF0aW9uKHRoaXMsIGZrLCByZWZlcmVuY2VkR2VuVGFibGUpKTsKLQkJCX0KLQkJfQotCX0KLQotCS8qKgotCSAqIG5vdyB0aGF0IGFsbCB0aGUgcmVsYXRpb25zIGFyZSBpbiBwbGFjZSwgd2UgY2FuIGNvbmZpZ3VyZSB0aGUgSmF2YQotCSAqIGF0dHJpYnV0ZSBuYW1lcwotCSAqLwotCXZvaWQgYnVpbGRBdHRyaWJ1dGVOYW1lcygpIHsKLQkJdGhpcy5idWlsZEF0dHJpYnV0ZU5hbWVGb3JFbWJlZGRlZElkKCk7Ci0KLQkJLy8gZ2F0aGVyIHVwIGFsbCB0aGUgdGFibGUncyBjb2x1bW5zLi4uCi0JCVNldDxDb2x1bW4+IGNvbHVtbnMgPSBDb2xsZWN0aW9uVG9vbHMuc2V0KHRoaXMudGFibGUuY29sdW1ucygpLCB0aGlzLnRhYmxlLmNvbHVtbnNTaXplKCkpOwotCQkvLyAuLi5yZW1vdmUgdGhlIGNvbHVtbnMgdGhhdCBiZWxvbmcgZXhjbHVzaXZlbHkgdG8gbWFueS10by1vbmUgZm9yZWlnbiBrZXlzLi4uCi0JCXRoaXMuYnVpbGRNYW55VG9PbmVBdHRyaWJ1dGVOYW1lcyhjb2x1bW5zKTsKLQkJLy8gLi4uYW5kIHVzZSB0aGUgcmVtYWluaW5nIGNvbHVtbnMgdG8gZ2VuZXJhdGUgImJhc2ljIiBhdHRyaWJ1dGUgbmFtZXMKLQkJdGhpcy5idWlsZEJhc2ljQXR0cmlidXRlTmFtZXMoY29sdW1ucyk7Ci0KLQkJdGhpcy5idWlsZE9uZVRvTWFueUF0dHJpYnV0ZU5hbWVzKCk7Ci0JCXRoaXMuYnVpbGRPd25lZE1hbnlUb01hbnlBdHRyaWJ1dGVOYW1lcygpOwotCQl0aGlzLmJ1aWxkTm9uT3duZWRNYW55VG9NYW55QXR0cmlidXRlTmFtZXMoKTsKLQl9Ci0KLQkvKioKLQkgKiByZXR1cm4gdGhlIGNvbHVtbnMgdGhhdCBhcmUgcGFydCBvZiB0aGUgdGFibGUncyBwcmltYXJ5IGtleQotCSAqIGJ1dCBhcmUgYWxzbyBwYXJ0IG9mIGFuICJpbi1zY29wZSIgZm9yZWlnbiBrZXkKLQkgKi8KLQlJdGVyYXRvcjxDb2x1bW4+IHJlYWRPbmx5UHJpbWFyeUtleUNvbHVtbnMoKSB7Ci0JCXJldHVybiBuZXcgRmlsdGVyaW5nSXRlcmF0b3I8Q29sdW1uLCBDb2x1bW4+KHRoaXMudGFibGUucHJpbWFyeUtleUNvbHVtbnMoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgYm9vbGVhbiBhY2NlcHQoQ29sdW1uIHBrQ29sdW1uKSB7Ci0JCQkJcmV0dXJuIHBrQ29sdW1uLmlzUGFydE9mRm9yZWlnbktleSgpOwotCQkJfQotCQl9OwotCX0KLQotCS8qKgotCSAqIHJldHVybiB0aGUgY29sdW1ucyB0aGF0IGFyZSBwYXJ0IG9mIHRoZSB0YWJsZSdzIHByaW1hcnkga2V5Ci0JICogYnV0IGFyZSBOT1QgcGFydCBvZiBhbnkgImluLXNjb3BlIiBmb3JlaWduIGtleQotCSAqLwotCUl0ZXJhdG9yPENvbHVtbj4gd3JpdGFibGVQcmltYXJ5S2V5Q29sdW1ucygpIHsKLQkJcmV0dXJuIG5ldyBGaWx0ZXJpbmdJdGVyYXRvcjxDb2x1bW4sIENvbHVtbj4odGhpcy50YWJsZS5wcmltYXJ5S2V5Q29sdW1ucygpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBib29sZWFuIGFjY2VwdChDb2x1bW4gcGtDb2x1bW4pIHsKLQkJCQlyZXR1cm4gISBwa0NvbHVtbi5pc1BhcnRPZkZvcmVpZ25LZXkoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQkvKioKLQkgKiByZXR1cm4gdGhlIGNvbHVtbnMgdGhhdCBORUlUSEVSIHBhcnQgb2YgdGhlIHRhYmxlJ3MgcHJpbWFyeSBrZXkKLQkgKiBOT1IgcGFydCBvZiBhbnkgZm9yZWlnbiBrZXkKLQkgKi8KLQlJdGVyYXRvcjxDb2x1bW4+IG5vblByaW1hcnlLZXlCYXNpY0NvbHVtbnMoKSB7Ci0JCXJldHVybiBuZXcgRmlsdGVyaW5nSXRlcmF0b3I8Q29sdW1uLCBDb2x1bW4+KHRoaXMudGFibGUuY29sdW1ucygpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBib29sZWFuIGFjY2VwdChDb2x1bW4gY29sdW1uKSB7Ci0JCQkJcmV0dXJuICEgKGNvbHVtbi5pc1BhcnRPZlByaW1hcnlLZXkoKSB8fCBjb2x1bW4uaXNQYXJ0T2ZGb3JlaWduS2V5KCkpOwotCQkJfQotCQl9OwotCX0KLQotCVRhYmxlIGdldFRhYmxlKCkgewotCQlyZXR1cm4gdGhpcy50YWJsZTsKLQl9Ci0KLQlTdHJpbmcgZ2V0RW50aXR5TmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0RW50aXR5Q29uZmlnKCkuZ2V0RW50aXR5TmFtZSh0aGlzLnRhYmxlKTsKLQl9Ci0KLQlib29sZWFuIGlzSm9pblRhYmxlKCkgewotCQlyZXR1cm4gdGhpcy5qb2luVGFibGVSZWxhdGlvbiAhPSBudWxsOwotCX0KLQotCXZvaWQgYWRkT3duZWRNYW55VG9NYW55UmVsYXRpb24oTWFueVRvTWFueVJlbGF0aW9uIHJlbGF0aW9uKSB7Ci0JCXRoaXMub3duZWRNYW55VG9NYW55UmVsYXRpb25zLmFkZChyZWxhdGlvbik7Ci0JfQotCi0Jdm9pZCByZW1vdmVPd25lZE1hbnlUb01hbnlSZWxhdGlvbihNYW55VG9NYW55UmVsYXRpb24gcmVsYXRpb24pIHsKLQkJdGhpcy5vd25lZE1hbnlUb01hbnlSZWxhdGlvbnMucmVtb3ZlKHJlbGF0aW9uKTsKLQl9Ci0KLQl2b2lkIGFkZE5vbk93bmVkTWFueVRvTWFueVJlbGF0aW9uKE1hbnlUb01hbnlSZWxhdGlvbiByZWxhdGlvbikgewotCQl0aGlzLm5vbk93bmVkTWFueVRvTWFueVJlbGF0aW9ucy5hZGQocmVsYXRpb24pOwotCX0KLQotCXZvaWQgcmVtb3ZlTm9uT3duZWRNYW55VG9NYW55UmVsYXRpb24oTWFueVRvTWFueVJlbGF0aW9uIHJlbGF0aW9uKSB7Ci0JCXRoaXMubm9uT3duZWRNYW55VG9NYW55UmVsYXRpb25zLnJlbW92ZShyZWxhdGlvbik7Ci0JfQotCi0Jdm9pZCBhZGRPbmVUb01hbnlSZWxhdGlvbihPbmVUb01hbnlSZWxhdGlvbiByZWxhdGlvbikgewotCQl0aGlzLm9uZVRvTWFueVJlbGF0aW9ucy5hZGQocmVsYXRpb24pOwotCX0KLQotCUl0ZXJhdG9yPE1hbnlUb09uZVJlbGF0aW9uPiBtYW55VG9PbmVSZWxhdGlvbnMoKSB7Ci0JCXJldHVybiB0aGlzLm1hbnlUb09uZVJlbGF0aW9ucy5pdGVyYXRvcigpOwotCX0KLQotCUl0ZXJhdG9yPE9uZVRvTWFueVJlbGF0aW9uPiBvbmVUb01hbnlSZWxhdGlvbnMoKSB7Ci0JCXJldHVybiB0aGlzLm9uZVRvTWFueVJlbGF0aW9ucy5pdGVyYXRvcigpOwotCX0KLQotCUl0ZXJhdG9yPE1hbnlUb01hbnlSZWxhdGlvbj4gb3duZWRNYW55VG9NYW55UmVsYXRpb25zKCkgewotCQlyZXR1cm4gdGhpcy5vd25lZE1hbnlUb01hbnlSZWxhdGlvbnMuaXRlcmF0b3IoKTsKLQl9Ci0KLQlJdGVyYXRvcjxNYW55VG9NYW55UmVsYXRpb24+IG5vbk93bmVkTWFueVRvTWFueVJlbGF0aW9ucygpIHsKLQkJcmV0dXJuIHRoaXMubm9uT3duZWRNYW55VG9NYW55UmVsYXRpb25zLml0ZXJhdG9yKCk7Ci0JfQotCi0JLyoqCi0JICogdGhpcyB3aWxsIHJldHVybiBudWxsIGlmIHdlIGRvbid0IHdhbnQgYW4gZW1iZWRkZWQgaWQgYXR0cmlidXRlCi0JICovCi0JU3RyaW5nIGdldEF0dHJpYnV0ZU5hbWVGb3JFbWJlZGRlZElkKCkgewotCQlyZXR1cm4gdGhpcy5hdHRyaWJ1dGVOYW1lRm9yRW1iZWRkZWRJZDsKLQl9Ci0KLQlTdHJpbmcgZ2V0QXR0cmlidXRlTmFtZUZvcihDb2x1bW4gY29sdW1uKSB7Ci0JCXJldHVybiB0aGlzLmJhc2ljQXR0cmlidXRlTmFtZXMuZ2V0KGNvbHVtbik7Ci0JfQotCi0JU3RyaW5nIGdldEF0dHJpYnV0ZU5hbWVGb3IoTWFueVRvT25lUmVsYXRpb24gcmVsYXRpb24pIHsKLQkJcmV0dXJuIHRoaXMubWFueVRvT25lQXR0cmlidXRlTmFtZXMuZ2V0KHJlbGF0aW9uKTsKLQl9Ci0KLQlTdHJpbmcgZ2V0QXR0cmlidXRlTmFtZUZvcihPbmVUb01hbnlSZWxhdGlvbiByZWxhdGlvbikgewotCQlyZXR1cm4gdGhpcy5vbmVUb01hbnlBdHRyaWJ1dGVOYW1lcy5nZXQocmVsYXRpb24pOwotCX0KLQotCVN0cmluZyBnZXRBdHRyaWJ1dGVOYW1lRm9yT3duZWQoTWFueVRvTWFueVJlbGF0aW9uIHJlbGF0aW9uKSB7Ci0JCXJldHVybiB0aGlzLm93bmVkTWFueVRvTWFueUF0dHJpYnV0ZU5hbWVzLmdldChyZWxhdGlvbik7Ci0JfQotCi0JU3RyaW5nIGdldEF0dHJpYnV0ZU5hbWVGb3JOb25Pd25lZChNYW55VG9NYW55UmVsYXRpb24gcmVsYXRpb24pIHsKLQkJcmV0dXJuIHRoaXMubm9uT3duZWRNYW55VG9NYW55QXR0cmlidXRlTmFtZXMuZ2V0KHJlbGF0aW9uKTsKLQl9Ci0KLQlTdHJpbmcgZ2V0TmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMudGFibGUuZ2V0TmFtZSgpOwotCX0KLQotCWJvb2xlYW4gam9pblRhYmxlTmFtZUlzRGVmYXVsdCgpIHsKLQkJcmV0dXJuIHRoaXMudGFibGUuam9pblRhYmxlTmFtZUlzRGVmYXVsdCgpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbnRlcm5hbCBBUEkgKioqKioqKioqKgotCi0JLyoqCi0JICogaWYgd2UgYXJlIGdvaW5nIHRvIGdlbmVyYXRlIGFuIEVtYmVkZGVkSWQgYXR0cmlidXRlLCBhZGQgaXRzIG5hbWUgdG8KLQkgKiAnYXR0cmlidXRlTmFtZXMnIHNvIHdlIGRvbid0IGNvbGxpZGUgd2l0aCBpdCBsYXRlciwgd2hlbiBnZW5lcmF0aW5nCi0JICogYXR0cmlidXRlIG5hbWVzIGZvciB0aGUgY29sdW1ucyBldGMuCi0JICovCi0JcHJpdmF0ZSB2b2lkIGJ1aWxkQXR0cmlidXRlTmFtZUZvckVtYmVkZGVkSWQoKSB7Ci0JCWlmICgodGhpcy50YWJsZS5wcmltYXJ5S2V5Q29sdW1uc1NpemUoKSA+IDEpICYmIHRoaXMuZ2V0RW50aXR5Q29uZmlnKCkuZ2VuZXJhdGVFbWJlZGRlZElkRm9yQ29tcG91bmRQSygpKSB7Ci0JCQl0aGlzLmF0dHJpYnV0ZU5hbWVGb3JFbWJlZGRlZElkID0gdGhpcy5jb25maWd1cmVBdHRyaWJ1dGVOYW1lKHRoaXMuZ2V0RW50aXR5Q29uZmlnKCkuZ2V0RW1iZWRkZWRJZEF0dHJpYnV0ZU5hbWUoKSk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBXaGlsZSB3ZSBhcmUgZmlndXJpbmcgb3V0IHRoZSBuYW1lcyBmb3IgdGhlIG06MSBhdHRyaWJ1dGVzLCByZW1vdmUgZnJvbSB0aGUKLQkgKiBzcGVjaWZpZWQgc2V0IG9mIGNvbHVtbnMgdGhlIGNvbHVtbnMgdGhhdCBhcmUgb25seSBwYXJ0IG9mIHRoZSBmb3JlaWduIGtleXMKLQkgKiAobGVhdmluZyB0aGUgcmVtYWluaW5nIGNvbHVtbnMgZm9yIGJhc2ljIGF0dHJpYnV0ZXMpLgotCSAqIFN0b3JlIHRoZSBjYWxjdWxhdGVkIG5hbWVzIHNvIHdlIGNhbiBnZXQgdGhlbSBiYWNrIGxhdGVyLCB3aGVuIHdlCi0JICogYXJlIGdlbmVyYXRpbmcgc291cmNlLgotCSAqLwotCXByaXZhdGUgdm9pZCBidWlsZE1hbnlUb09uZUF0dHJpYnV0ZU5hbWVzKFNldDxDb2x1bW4+IGNvbHVtbnMpIHsKLQkJZm9yIChNYW55VG9PbmVSZWxhdGlvbiByZWxhdGlvbiA6IHRoaXMubWFueVRvT25lUmVsYXRpb25zKSB7Ci0JCQlDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsKGNvbHVtbnMsIHJlbGF0aW9uLmdldEZvcmVpZ25LZXkoKS5ub25QcmltYXJ5S2V5QmFzZUNvbHVtbnMoKSk7Ci0JCQlDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKHRoaXMuZm9yZWlnbktleUNvbHVtbnMsIHJlbGF0aW9uLmdldEZvcmVpZ25LZXkoKS5iYXNlQ29sdW1ucygpKTsKLQkJCVN0cmluZyBhdHRyaWJ1dGVOYW1lID0gdGhpcy5jb25maWd1cmVBdHRyaWJ1dGVOYW1lKHJlbGF0aW9uLmdldEF0dHJpYnV0ZU5hbWUoKSk7Ci0JCQlyZWxhdGlvbi5zZXRNYXBwZWRCeShhdHRyaWJ1dGVOYW1lKTsKLQkJCXRoaXMubWFueVRvT25lQXR0cmlidXRlTmFtZXMucHV0KHJlbGF0aW9uLCBhdHRyaWJ1dGVOYW1lKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIEJ1aWxkIGEgdW5pcXVlIGF0dHJpYnV0ZSBuYW1lIGZvciB0aGUgc3BlY2lmaWVkICJiYXNpYyIgY29sdW1ucywKLQkgKiBjaGVja2luZyBmb3IgbmFtZSBjb2xsaXNpb25zLgotCSAqIFN0b3JlIHRoZSBjYWxjdWxhdGVkIG5hbWVzIHNvIHdlIGNhbiBnZXQgdGhlbSBiYWNrIGxhdGVyLCB3aGVuIHdlCi0JICogYXJlIGdlbmVyYXRpbmcgc291cmNlLgotCSAqLwotCXByaXZhdGUgdm9pZCBidWlsZEJhc2ljQXR0cmlidXRlTmFtZXMoU2V0PENvbHVtbj4gY29sdW1ucykgewotCQlmb3IgKENvbHVtbiBjb2x1bW4gOiBjb2x1bW5zKSB7Ci0JCQlTdHJpbmcgYXR0cmlidXRlTmFtZSA9IHRoaXMuY29uZmlndXJlQXR0cmlidXRlTmFtZShjb2x1bW4uZ2V0TmFtZSgpKTsKLQkJCXRoaXMuYmFzaWNBdHRyaWJ1dGVOYW1lcy5wdXQoY29sdW1uLCBhdHRyaWJ1dGVOYW1lKTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZE9uZVRvTWFueUF0dHJpYnV0ZU5hbWVzKCkgewotCQlmb3IgKE9uZVRvTWFueVJlbGF0aW9uIHJlbGF0aW9uIDogdGhpcy5vbmVUb01hbnlSZWxhdGlvbnMpIHsKLQkJCVN0cmluZyBhdHRyaWJ1dGVOYW1lID0gdGhpcy5jb25maWd1cmVBdHRyaWJ1dGVOYW1lKHJlbGF0aW9uLmdldEF0dHJpYnV0ZU5hbWUoKSk7Ci0JCQl0aGlzLm9uZVRvTWFueUF0dHJpYnV0ZU5hbWVzLnB1dChyZWxhdGlvbiwgYXR0cmlidXRlTmFtZSk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRPd25lZE1hbnlUb01hbnlBdHRyaWJ1dGVOYW1lcygpIHsKLQkJZm9yIChNYW55VG9NYW55UmVsYXRpb24gcmVsYXRpb24gOiB0aGlzLm93bmVkTWFueVRvTWFueVJlbGF0aW9ucykgewotCQkJU3RyaW5nIGF0dHJpYnV0ZU5hbWUgPSB0aGlzLmNvbmZpZ3VyZUF0dHJpYnV0ZU5hbWUocmVsYXRpb24uZ2V0T3duZWRBdHRyaWJ1dGVOYW1lKCkpOwotCQkJcmVsYXRpb24uc2V0TWFwcGVkQnkoYXR0cmlidXRlTmFtZSk7Ci0JCQl0aGlzLm93bmVkTWFueVRvTWFueUF0dHJpYnV0ZU5hbWVzLnB1dChyZWxhdGlvbiwgYXR0cmlidXRlTmFtZSk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGROb25Pd25lZE1hbnlUb01hbnlBdHRyaWJ1dGVOYW1lcygpIHsKLQkJZm9yIChNYW55VG9NYW55UmVsYXRpb24gcmVsYXRpb24gOiB0aGlzLm5vbk93bmVkTWFueVRvTWFueVJlbGF0aW9ucykgewotCQkJU3RyaW5nIGF0dHJpYnV0ZU5hbWUgPSB0aGlzLmNvbmZpZ3VyZUF0dHJpYnV0ZU5hbWUocmVsYXRpb24uZ2V0Tm9uT3duZWRBdHRyaWJ1dGVOYW1lKCkpOwotCQkJdGhpcy5ub25Pd25lZE1hbnlUb01hbnlBdHRyaWJ1dGVOYW1lcy5wdXQocmVsYXRpb24sIGF0dHJpYnV0ZU5hbWUpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkIGF0dHJpYnV0ZSBuYW1lIHRvIHNvbWV0aGluZyB1bmlxdWUgZm9yIHRoZSBlbnRpdHksCi0JICogY29udmVydGluZyBpdCB0byBzb21ldGhpbmcgSmF2YS1saWtlIGlmIHRoZSBjb25maWcgZmxhZyBpcyBzZXQuCi0JICogU3RvcmUgdGhlIGNhbGN1bGF0ZWQgbmFtZSB0byBwcmV2ZW50IGZ1dHVyZSBuYW1lIGNvbGxpc2lvbnMuCi0JICovCi0JcHJpdmF0ZSBTdHJpbmcgY29uZmlndXJlQXR0cmlidXRlTmFtZShTdHJpbmcgYXR0cmlidXRlTmFtZSkgewotCQlTdHJpbmcgcmVzdWx0ID0gYXR0cmlidXRlTmFtZTsKLQkJaWYgKHRoaXMuZ2V0RW50aXR5Q29uZmlnKCkuY29udmVydFRvSmF2YVN0eWxlSWRlbnRpZmllcnMoKSkgewotCQkJcmVzdWx0ID0gRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQXR0cmlidXRlTmFtZShyZXN1bHQsIHRoaXMuYXR0cmlidXRlTmFtZXMpOwotCQl9IGVsc2UgewotCQkJLy8gZmlyc3QsIGNvbnZlcnQgdGhlIGF0dHJpYnV0ZSBuYW1lIHRvIGEgbGVnYWwgSmF2YSBpZGVudGlmaWVyCi0JCQlyZXN1bHQgPSBOYW1lVG9vbHMuY29udmVydFRvSmF2YUlkZW50aWZpZXIocmVzdWx0KTsKLQkJCS8vIHRoZW4gbWFrZSBzdXJlIGl0J3MgdW5pcXVlCi0JCQlyZXN1bHQgPSBOYW1lVG9vbHMudW5pcXVlTmFtZUZvcklnbm9yZUNhc2UoYXR0cmlidXRlTmFtZSwgdGhpcy5hdHRyaWJ1dGVOYW1lcyk7Ci0JCX0KLQkJdGhpcy5hdHRyaWJ1dGVOYW1lcy5hZGQocmVzdWx0KTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuYnVpbGRUb1N0cmluZ0Zvcih0aGlzLCB0aGlzLnRhYmxlKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwvSlBBLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsL0pQQS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1OWEwNDJhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwvSlBBLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzMDEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsOwotCi0KLS8qKgotICogSlBBIEphdmEtcmVsYXRlZCBzdHVmZiAoYW5ub3RhdGlvbnMgZXRjLikKLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKi8KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGludGVyZmFjZSBKUEEgewotCi0JLy8gSlBBIHBhY2thZ2UKLQlTdHJpbmcgUEFDS0FHRSA9ICJqYXZheC5wZXJzaXN0ZW5jZSI7Ci0JU3RyaW5nIFBBQ0tBR0VfID0gUEFDS0FHRSArICcuJzsKLQotCi0JLy8gKioqKioqKioqKiBBUEkgKioqKioqKioqKgotCi0JLy8gSlBBIGFubm90YXRpb25zCi0JU3RyaW5nIEFTU09DSUFUSU9OX09WRVJSSURFID0gUEFDS0FHRV8gKyAiQXNzb2NpYXRpb25PdmVycmlkZSI7Ci0JCVN0cmluZyBBU1NPQ0lBVElPTl9PVkVSUklERV9fTkFNRSA9ICJuYW1lIjsKLQkJU3RyaW5nIEFTU09DSUFUSU9OX09WRVJSSURFX19KT0lOX0NPTFVNTlMgPSAiam9pbkNvbHVtbnMiOwotCVN0cmluZyBBU1NPQ0lBVElPTl9PVkVSUklERVMgPSBQQUNLQUdFXyArICJBc3NvY2lhdGlvbk92ZXJyaWRlcyI7Ci0JCVN0cmluZyBBU1NPQ0lBVElPTl9PVkVSUklERVNfX1ZBTFVFID0gInZhbHVlIjsKLQlTdHJpbmcgQVRUUklCVVRFX09WRVJSSURFID0gUEFDS0FHRV8gKyAiQXR0cmlidXRlT3ZlcnJpZGUiOwotCQlTdHJpbmcgQVRUUklCVVRFX09WRVJSSURFX19OQU1FID0gIm5hbWUiOwotCQlTdHJpbmcgQVRUUklCVVRFX09WRVJSSURFX19DT0xVTU4gPSAiY29sdW1uIjsKLQlTdHJpbmcgQVRUUklCVVRFX09WRVJSSURFUyA9IFBBQ0tBR0VfICsgIkF0dHJpYnV0ZU92ZXJyaWRlcyI7Ci0JCVN0cmluZyBBVFRSSUJVVEVfT1ZFUlJJREVTX19WQUxVRSA9ICJ2YWx1ZSI7Ci0JU3RyaW5nIEJBU0lDID0gUEFDS0FHRV8gKyAiQmFzaWMiOwotCQlTdHJpbmcgQkFTSUNfX0ZFVENIID0gImZldGNoIjsKLQkJU3RyaW5nIEJBU0lDX19PUFRJT05BTCA9ICJvcHRpb25hbCI7Ci0JU3RyaW5nIENPTFVNTiA9IFBBQ0tBR0VfICsgIkNvbHVtbiI7Ci0JCVN0cmluZyBDT0xVTU5fX05BTUUgPSAibmFtZSI7Ci0JCVN0cmluZyBDT0xVTU5fX1VOSVFVRSA9ICJ1bmlxdWUiOwotCQlTdHJpbmcgQ09MVU1OX19OVUxMQUJMRSA9ICJudWxsYWJsZSI7Ci0JCVN0cmluZyBDT0xVTU5fX0lOU0VSVEFCTEUgPSAiaW5zZXJ0YWJsZSI7Ci0JCVN0cmluZyBDT0xVTU5fX1VQREFUQUJMRSA9ICJ1cGRhdGFibGUiOwotCQlTdHJpbmcgQ09MVU1OX19DT0xVTU5fREVGSU5JVElPTiA9ICJjb2x1bW5EZWZpbml0aW9uIjsKLQkJU3RyaW5nIENPTFVNTl9fVEFCTEUgPSAidGFibGUiOwotCQlTdHJpbmcgQ09MVU1OX19MRU5HVEggPSAibGVuZ3RoIjsKLQkJU3RyaW5nIENPTFVNTl9fUFJFQ0lTSU9OID0gInByZWNpc2lvbiI7Ci0JCVN0cmluZyBDT0xVTU5fX1NDQUxFID0gInNjYWxlIjsKLQlTdHJpbmcgQ09MVU1OX1JFU1VMVCA9IFBBQ0tBR0VfICsgIkNvbHVtblJlc3VsdCI7Ci0JCVN0cmluZyBDT0xVTU5fUkVTVUxUX19OQU1FID0gIm5hbWUiOwotCVN0cmluZyBESVNDUklNSU5BVE9SX0NPTFVNTiA9IFBBQ0tBR0VfICsgIkRpc2NyaW1pbmF0b3JDb2x1bW4iOwotCQlTdHJpbmcgRElTQ1JJTUlOQVRPUl9DT0xVTU5fX05BTUUgPSAibmFtZSI7Ci0JCVN0cmluZyBESVNDUklNSU5BVE9SX0NPTFVNTl9fRElTQ1JJTUlOQVRPUl9UWVBFID0gImRpc2NyaW1pbmF0b3JUeXBlIjsKLQkJU3RyaW5nIERJU0NSSU1JTkFUT1JfQ09MVU1OX19DT0xVTU5fREVGSU5JVElPTiA9ICJjb2x1bW5EZWZpbml0aW9uIjsKLQkJU3RyaW5nIERJU0NSSU1JTkFUT1JfQ09MVU1OX19MRU5HVEggPSAibGVuZ3RoIjsKLQlTdHJpbmcgRElTQ1JJTUlOQVRPUl9WQUxVRSA9IFBBQ0tBR0VfICsgIkRpc2NyaW1pbmF0b3JWYWx1ZSI7Ci0JCVN0cmluZyBESVNDUklNSU5BVE9SX1ZBTFVFX19WQUxVRSA9ICJ2YWx1ZSI7Ci0JU3RyaW5nIEVNQkVEREFCTEUgPSBQQUNLQUdFXyArICJFbWJlZGRhYmxlIjsKLQlTdHJpbmcgRU1CRURERUQgPSBQQUNLQUdFXyArICJFbWJlZGRlZCI7Ci0JU3RyaW5nIEVNQkVEREVEX0lEID0gUEFDS0FHRV8gKyAiRW1iZWRkZWRJZCI7Ci0JU3RyaW5nIEVOVElUWSA9IFBBQ0tBR0VfICsgIkVudGl0eSI7Ci0JCVN0cmluZyBFTlRJVFlfX05BTUUgPSAibmFtZSI7Ci0JU3RyaW5nIEVOVElUWV9MSVNURU5FUlMgPSBQQUNLQUdFXyArICJFbnRpdHlMaXN0ZW5lcnMiOwotCQlTdHJpbmcgRU5USVRZX0xJU1RFTkVSU19fVkFMVUUgPSAidmFsdWUiOwotCVN0cmluZyBFTlRJVFlfUkVTVUxUID0gUEFDS0FHRV8gKyAiRW50aXR5UmVzdWx0IjsKLQkJU3RyaW5nIEVOVElUWV9SRVNVTFRfX0VOVElUWV9DTEFTUyA9ICJlbnRpdHlDbGFzcyI7Ci0JCVN0cmluZyBFTlRJVFlfUkVTVUxUX19GSUVMRFMgPSAiZmllbGRzIjsKLQkJU3RyaW5nIEVOVElUWV9SRVNVTFRfX0RJU0NSSU1JTkFUT1JfQ09MVU1OID0gImRpc2NyaW1pbmF0b3JDb2x1bW4iOwotCVN0cmluZyBFTlVNRVJBVEVEID0gUEFDS0FHRV8gKyAiRW51bWVyYXRlZCI7Ci0JCVN0cmluZyBFTlVNRVJBVEVEX19WQUxVRSA9ICJ2YWx1ZSI7Ci0JU3RyaW5nIEVYQ0xVREVfREVGQVVMVF9MSVNURU5FUlMgPSBQQUNLQUdFXyArICJFeGNsdWRlRGVmYXVsdExpc3RlbmVycyI7Ci0JU3RyaW5nIEVYQ0xVREVfU1VQRVJDTEFTU19MSVNURU5FUlMgPSBQQUNLQUdFXyArICJFeGNsdWRlU3VwZXJjbGFzc0xpc3RlbmVycyI7Ci0JU3RyaW5nIEZJRUxEX1JFU1VMVCA9IFBBQ0tBR0VfICsgIkZpZWxkUmVzdWx0IjsKLQkJU3RyaW5nIEZJRUxEX1JFU1VMVF9fTkFNRSA9ICJuYW1lIjsKLQkJU3RyaW5nIEZJRUxEX1JFU1VMVF9fQ09MVU1OID0gImNvbHVtbiI7Ci0JU3RyaW5nIEZMVVNIX01PREUgPSBQQUNLQUdFXyArICJGbHVzaE1vZGUiOwotCQlTdHJpbmcgRkxVU0hfTU9ERV9fVkFMVUUgPSAidmFsdWUiOwotCVN0cmluZyBHRU5FUkFURURfVkFMVUUgPSBQQUNLQUdFXyArICJHZW5lcmF0ZWRWYWx1ZSI7Ci0JCVN0cmluZyBHRU5FUkFURURfVkFMVUVfX1NUUkFURUdZID0gInN0cmF0ZWd5IjsKLQkJU3RyaW5nIEdFTkVSQVRFRF9WQUxVRV9fR0VORVJBVE9SID0gImdlbmVyYXRvciI7Ci0JU3RyaW5nIElEID0gUEFDS0FHRV8gKyAiSWQiOwotCVN0cmluZyBJRF9DTEFTUyA9IFBBQ0tBR0VfICsgIklkQ2xhc3MiOwotCQlTdHJpbmcgSURfQ0xBU1NfX1ZBTFVFID0gInZhbHVlIjsKLQlTdHJpbmcgSU5IRVJJVEFOQ0UgPSBQQUNLQUdFXyArICJJbmhlcml0YW5jZSI7Ci0JCVN0cmluZyBJTkhFUklUQU5DRV9fU1RSQVRFR1kgPSAic3RyYXRlZ3kiOwotCVN0cmluZyBKT0lOX0NPTFVNTiA9IFBBQ0tBR0VfICsgIkpvaW5Db2x1bW4iOwotCQlTdHJpbmcgSk9JTl9DT0xVTU5fX05BTUUgPSAibmFtZSI7Ci0JCVN0cmluZyBKT0lOX0NPTFVNTl9fUkVGRVJFTkNFRF9DT0xVTU5fTkFNRSA9ICJyZWZlcmVuY2VkQ29sdW1uTmFtZSI7Ci0JCVN0cmluZyBKT0lOX0NPTFVNTl9fVU5JUVVFID0gInVuaXF1ZSI7Ci0JCVN0cmluZyBKT0lOX0NPTFVNTl9fTlVMTEFCTEUgPSAibnVsbGFibGUiOwotCQlTdHJpbmcgSk9JTl9DT0xVTU5fX0lOU0VSVEFCTEUgPSAiaW5zZXJ0YWJsZSI7Ci0JCVN0cmluZyBKT0lOX0NPTFVNTl9fVVBEQVRBQkxFID0gInVwZGF0YWJsZSI7Ci0JCVN0cmluZyBKT0lOX0NPTFVNTl9fQ09MVU1OX0RFRklOSVRJT04gPSAiY29sdW1uRGVmaW5pdGlvbiI7Ci0JCVN0cmluZyBKT0lOX0NPTFVNTl9fVEFCTEUgPSAidGFibGUiOwotCVN0cmluZyBKT0lOX0NPTFVNTlMgPSBQQUNLQUdFXyArICJKb2luQ29sdW1ucyI7Ci0JCVN0cmluZyBKT0lOX0NPTFVNTlNfX1ZBTFVFID0gInZhbHVlIjsKLQlTdHJpbmcgSk9JTl9UQUJMRSA9IFBBQ0tBR0VfICsgIkpvaW5UYWJsZSI7Ci0JCVN0cmluZyBKT0lOX1RBQkxFX19OQU1FID0gIm5hbWUiOwotCQlTdHJpbmcgSk9JTl9UQUJMRV9fQ0FUQUxPRyA9ICJjYXRhbG9nIjsKLQkJU3RyaW5nIEpPSU5fVEFCTEVfX1NDSEVNQSA9ICJzY2hlbWEiOwotCQlTdHJpbmcgSk9JTl9UQUJMRV9fSk9JTl9DT0xVTU5TID0gImpvaW5Db2x1bW5zIjsKLQkJU3RyaW5nIEpPSU5fVEFCTEVfX0lOVkVSU0VfSk9JTl9DT0xVTU5TID0gImludmVyc2VKb2luQ29sdW1ucyI7Ci0JCVN0cmluZyBKT0lOX1RBQkxFX19VTklRVUVfQ09OU1RSQUlOVFMgPSAidW5pcXVlQ29uc3RyYWludHMiOwotCVN0cmluZyBMT0IgPSBQQUNLQUdFXyArICJMb2IiOwotCVN0cmluZyBNQU5ZX1RPX01BTlkgPSBQQUNLQUdFXyArICJNYW55VG9NYW55IjsKLQkJU3RyaW5nIE1BTllfVE9fTUFOWV9fVEFSR0VUX0VOVElUWSA9ICJ0YXJnZXRFbnRpdHkiOwotCQlTdHJpbmcgTUFOWV9UT19NQU5ZX19DQVNDQURFID0gImNhc2NhZGUiOwotCQlTdHJpbmcgTUFOWV9UT19NQU5ZX19GRVRDSCA9ICJmZXRjaCI7Ci0JCVN0cmluZyBNQU5ZX1RPX01BTllfX01BUFBFRF9CWSA9ICJtYXBwZWRCeSI7Ci0JU3RyaW5nIE1BTllfVE9fT05FID0gUEFDS0FHRV8gKyAiTWFueVRvT25lIjsKLQkJU3RyaW5nIE1BTllfVE9fT05FX19UQVJHRVRfRU5USVRZID0gInRhcmdldEVudGl0eSI7Ci0JCVN0cmluZyBNQU5ZX1RPX09ORV9fQ0FTQ0FERSA9ICJjYXNjYWRlIjsKLQkJU3RyaW5nIE1BTllfVE9fT05FX19GRVRDSCA9ICJmZXRjaCI7Ci0JCVN0cmluZyBNQU5ZX1RPX09ORV9fT1BUSU9OQUwgPSAib3B0aW9uYWwiOwotCVN0cmluZyBNQVBfS0VZID0gUEFDS0FHRV8gKyAiTWFwS2V5IjsKLQkJU3RyaW5nIE1BUF9LRVlfX05BTUUgPSAibmFtZSI7Ci0JU3RyaW5nIE1BUFBFRF9TVVBFUkNMQVNTID0gUEFDS0FHRV8gKyAiTWFwcGVkU3VwZXJjbGFzcyI7Ci0JU3RyaW5nIE5BTUVEX05BVElWRV9RVUVSSUVTID0gUEFDS0FHRV8gKyAiTmFtZWROYXRpdmVRdWVyaWVzIjsKLQkJU3RyaW5nIE5BTUVEX05BVElWRV9RVUVSSUVTX19WQUxVRSA9ICJ2YWx1ZSI7Ci0JU3RyaW5nIE5BTUVEX05BVElWRV9RVUVSWSA9IFBBQ0tBR0VfICsgIk5hbWVkTmF0aXZlUXVlcnkiOwotCQlTdHJpbmcgTkFNRURfTkFUSVZFX1FVRVJZX19OQU1FID0gIm5hbWUiOwotCQlTdHJpbmcgTkFNRURfTkFUSVZFX1FVRVJZX19RVUVSWSA9ICJxdWVyeSI7Ci0JCVN0cmluZyBOQU1FRF9OQVRJVkVfUVVFUllfX0hJTlRTID0gImhpbnRzIjsKLQkJU3RyaW5nIE5BTUVEX05BVElWRV9RVUVSWV9fUkVTVUxUX0NMQVNTID0gInJlc3VsdENsYXNzIjsKLQkJU3RyaW5nIE5BTUVEX05BVElWRV9RVUVSWV9fUkVTVUxUX1NFVF9NQVBQSU5HID0gInJlc3VsdFNldE1hcHBpbmciOwotCVN0cmluZyBOQU1FRF9RVUVSSUVTID0gUEFDS0FHRV8gKyAiTmFtZWRRdWVyaWVzIjsKLQkJU3RyaW5nIE5BTUVEX1FVRVJJRVNfX1ZBTFVFID0gInZhbHVlIjsKLQlTdHJpbmcgTkFNRURfUVVFUlkgPSBQQUNLQUdFXyArICJOYW1lZFF1ZXJ5IjsKLQkJU3RyaW5nIE5BTUVEX1FVRVJZX19OQU1FID0gIm5hbWUiOwotCQlTdHJpbmcgTkFNRURfUVVFUllfX1FVRVJZID0gInF1ZXJ5IjsKLQkJU3RyaW5nIE5BTUVEX1FVRVJZX19ISU5UUyA9ICJoaW50cyI7Ci0JU3RyaW5nIE9ORV9UT19NQU5ZID0gUEFDS0FHRV8gKyAiT25lVG9NYW55IjsKLQkJU3RyaW5nIE9ORV9UT19NQU5ZX19UQVJHRVRfRU5USVRZID0gInRhcmdldEVudGl0eSI7Ci0JCVN0cmluZyBPTkVfVE9fTUFOWV9fQ0FTQ0FERSA9ICJjYXNjYWRlIjsKLQkJU3RyaW5nIE9ORV9UT19NQU5ZX19GRVRDSCA9ICJmZXRjaCI7Ci0JCVN0cmluZyBPTkVfVE9fTUFOWV9fTUFQUEVEX0JZID0gIm1hcHBlZEJ5IjsKLQlTdHJpbmcgT05FX1RPX09ORSA9IFBBQ0tBR0VfICsgIk9uZVRvT25lIjsKLQkJU3RyaW5nIE9ORV9UT19PTkVfX1RBUkdFVF9FTlRJVFkgPSAidGFyZ2V0RW50aXR5IjsKLQkJU3RyaW5nIE9ORV9UT19PTkVfX0NBU0NBREUgPSAiY2FzY2FkZSI7Ci0JCVN0cmluZyBPTkVfVE9fT05FX19GRVRDSCA9ICJmZXRjaCI7Ci0JCVN0cmluZyBPTkVfVE9fT05FX19PUFRJT05BTCA9ICJvcHRpb25hbCI7Ci0JCVN0cmluZyBPTkVfVE9fT05FX19NQVBQRURfQlkgPSAibWFwcGVkQnkiOwotCVN0cmluZyBPUkRFUl9CWSA9IFBBQ0tBR0VfICsgIk9yZGVyQnkiOwotCQlTdHJpbmcgT1JERVJfQllfX1ZBTFVFID0gInZhbHVlIjsKLQlTdHJpbmcgUEVSU0lTVEVOQ0VfQ09OVEVYVCA9IFBBQ0tBR0VfICsgIlBlcnNpc3RlbmNlQ29udGV4dCI7Ci0JCVN0cmluZyBQRVJTSVNURU5DRV9DT05URVhUX19OQU1FID0gIm5hbWUiOwotCQlTdHJpbmcgUEVSU0lTVEVOQ0VfQ09OVEVYVF9fVU5JVF9OQU1FID0gInVuaXROYW1lIjsKLQkJU3RyaW5nIFBFUlNJU1RFTkNFX0NPTlRFWFRfX1RZUEUgPSAidHlwZSI7Ci0JU3RyaW5nIFBFUlNJU1RFTkNFX0NPTlRFWFRTID0gUEFDS0FHRV8gKyAiUGVyc2lzdGVuY2VDb250ZXh0cyI7Ci0JCVN0cmluZyBQRVJTSVNURU5DRV9DT05URVhUU19fVkFMVUUgPSAidmFsdWUiOwotCVN0cmluZyBQRVJTSVNURU5DRV9VTklUID0gUEFDS0FHRV8gKyAiWG1sUGVyc2lzdGVuY2VVbml0IjsKLQkJU3RyaW5nIFBFUlNJU1RFTkNFX1VOSVRfX05BTUUgPSAibmFtZSI7Ci0JCVN0cmluZyBQRVJTSVNURU5DRV9VTklUX19VTklUX05BTUUgPSAidW5pdE5hbWUiOwotCVN0cmluZyBQRVJTSVNURU5DRV9VTklUUyA9IFBBQ0tBR0VfICsgIlBlcnNpc3RlbmNlVW5pdHMiOwotCQlTdHJpbmcgUEVSU0lTVEVOQ0VfVU5JVFNfX1ZBTFVFID0gInZhbHVlIjsKLQlTdHJpbmcgUE9TVF9MT0FEID0gUEFDS0FHRV8gKyAiUG9zdExvYWQiOwotCVN0cmluZyBQT1NUX1BFUlNJU1QgPSBQQUNLQUdFXyArICJQb3N0UGVyc2lzdCI7Ci0JU3RyaW5nIFBPU1RfUkVNT1ZFID0gUEFDS0FHRV8gKyAiUG9zdFJlbW92ZSI7Ci0JU3RyaW5nIFBPU1RfVVBEQVRFID0gUEFDS0FHRV8gKyAiUG9zdFVwZGF0ZSI7Ci0JU3RyaW5nIFBSRV9QRVJTSVNUID0gUEFDS0FHRV8gKyAiUHJlUGVyc2lzdCI7Ci0JU3RyaW5nIFBSRV9SRU1PVkUgPSBQQUNLQUdFXyArICJQcmVSZW1vdmUiOwotCVN0cmluZyBQUkVfVVBEQVRFID0gUEFDS0FHRV8gKyAiUHJlVXBkYXRlIjsKLQlTdHJpbmcgUFJJTUFSWV9LRVlfSk9JTl9DT0xVTU4gPSBQQUNLQUdFXyArICJQcmltYXJ5S2V5Sm9pbkNvbHVtbiI7Ci0JCVN0cmluZyBQUklNQVJZX0tFWV9KT0lOX0NPTFVNTl9fTkFNRSA9ICJuYW1lIjsKLQkJU3RyaW5nIFBSSU1BUllfS0VZX0pPSU5fQ09MVU1OX19SRUZFUkVOQ0VEX0NPTFVNTl9OQU1FID0gInJlZmVyZW5jZWRDb2x1bW5OYW1lIjsKLQkJU3RyaW5nIFBSSU1BUllfS0VZX0pPSU5fQ09MVU1OX19DT0xVTU5fREVGSU5JVElPTiA9ICJjb2x1bW5EZWZpbml0aW9uIjsKLQlTdHJpbmcgUFJJTUFSWV9LRVlfSk9JTl9DT0xVTU5TID0gUEFDS0FHRV8gKyAiUHJpbWFyeUtleUpvaW5Db2x1bW5zIjsKLQkJU3RyaW5nIFBSSU1BUllfS0VZX0pPSU5fQ09MVU1OU19fVkFMVUUgPSAidmFsdWUiOwotCVN0cmluZyBRVUVSWV9ISU5UID0gUEFDS0FHRV8gKyAiUXVlcnlIaW50IjsKLQkJU3RyaW5nIFFVRVJZX0hJTlRfX05BTUUgPSAibmFtZSI7Ci0JCVN0cmluZyBRVUVSWV9ISU5UX19WQUxVRSA9ICJ2YWx1ZSI7Ci0JU3RyaW5nIFNFQ09OREFSWV9UQUJMRSA9IFBBQ0tBR0VfICsgIlNlY29uZGFyeVRhYmxlIjsKLQkJU3RyaW5nIFNFQ09OREFSWV9UQUJMRV9fTkFNRSA9ICJuYW1lIjsKLQkJU3RyaW5nIFNFQ09OREFSWV9UQUJMRV9fQ0FUQUxPRyA9ICJjYXRhbG9nIjsKLQkJU3RyaW5nIFNFQ09OREFSWV9UQUJMRV9fU0NIRU1BID0gInNjaGVtYSI7Ci0JCVN0cmluZyBTRUNPTkRBUllfVEFCTEVfX1BLX0pPSU5fQ09MVU1OUyA9ICJwa0pvaW5Db2x1bW5zIjsKLQkJU3RyaW5nIFNFQ09OREFSWV9UQUJMRV9fVU5JUVVFX0NPTlNUUkFJTlRTID0gInVuaXF1ZUNvbnN0cmFpbnRzIjsKLQlTdHJpbmcgU0VDT05EQVJZX1RBQkxFUyA9IFBBQ0tBR0VfICsgIlNlY29uZGFyeVRhYmxlcyI7Ci0JCVN0cmluZyBTRUNPTkRBUllfVEFCTEVTX19WQUxVRSA9ICJ2YWx1ZSI7Ci0JU3RyaW5nIFNFUVVFTkNFX0dFTkVSQVRPUiA9IFBBQ0tBR0VfICsgIlNlcXVlbmNlR2VuZXJhdG9yIjsKLQkJU3RyaW5nIFNFUVVFTkNFX0dFTkVSQVRPUl9fTkFNRSA9ICJuYW1lIjsKLQkJU3RyaW5nIFNFUVVFTkNFX0dFTkVSQVRPUl9fU0VRVUVOQ0VfTkFNRSA9ICJzZXF1ZW5jZU5hbWUiOwotCQlTdHJpbmcgU0VRVUVOQ0VfR0VORVJBVE9SX19JTklUSUFMX1ZBTFVFID0gImluaXRpYWxWYWx1ZSI7Ci0JCVN0cmluZyBTRVFVRU5DRV9HRU5FUkFUT1JfX0FMTE9DQVRJT05fU0laRSA9ICJhbGxvY2F0aW9uU2l6ZSI7Ci0JU3RyaW5nIFNRTF9SRVNVTFRfU0VUX01BUFBJTkcgPSBQQUNLQUdFXyArICJTcWxSZXN1bHRTZXRNYXBwaW5nIjsKLQkJU3RyaW5nIFNRTF9SRVNVTFRfU0VUX01BUFBJTkdfX05BTUUgPSAibmFtZSI7Ci0JCVN0cmluZyBTUUxfUkVTVUxUX1NFVF9NQVBQSU5HX19FTlRJVElFUyA9ICJlbnRpdGllcyI7Ci0JCVN0cmluZyBTUUxfUkVTVUxUX1NFVF9NQVBQSU5HX19DT0xVTU5TID0gImNvbHVtbnMiOwotCVN0cmluZyBUQUJMRSA9IFBBQ0tBR0VfICsgIlRhYmxlIjsKLQkJU3RyaW5nIFRBQkxFX19OQU1FID0gIm5hbWUiOwotCQlTdHJpbmcgVEFCTEVfX0NBVEFMT0cgPSAiY2F0YWxvZyI7Ci0JCVN0cmluZyBUQUJMRV9fU0NIRU1BID0gInNjaGVtYSI7Ci0JCVN0cmluZyBUQUJMRV9fVU5JUVVFX0NPTlNUUkFJTlRTID0gInVuaXF1ZUNvbnN0cmFpbnRzIjsKLQlTdHJpbmcgVEFCTEVfR0VORVJBVE9SID0gUEFDS0FHRV8gKyAiVGFibGVHZW5lcmF0b3IiOwotCQlTdHJpbmcgVEFCTEVfR0VORVJBVE9SX19OQU1FID0gIm5hbWUiOwotCQlTdHJpbmcgVEFCTEVfR0VORVJBVE9SX19UQUJMRSA9ICJ0YWJsZSI7Ci0JCVN0cmluZyBUQUJMRV9HRU5FUkFUT1JfX0NBVEFMT0cgPSAiY2F0YWxvZyI7Ci0JCVN0cmluZyBUQUJMRV9HRU5FUkFUT1JfX1NDSEVNQSA9ICJzY2hlbWEiOwotCQlTdHJpbmcgVEFCTEVfR0VORVJBVE9SX19QS19DT0xVTU5fTkFNRSA9ICJwa0NvbHVtbk5hbWUiOwotCQlTdHJpbmcgVEFCTEVfR0VORVJBVE9SX19WQUxVRV9DT0xVTU5fTkFNRSA9ICJ2YWx1ZUNvbHVtbk5hbWUiOwotCQlTdHJpbmcgVEFCTEVfR0VORVJBVE9SX19QS19DT0xVTU5fVkFMVUUgPSAicGtDb2x1bW5WYWx1ZSI7Ci0JCVN0cmluZyBUQUJMRV9HRU5FUkFUT1JfX0lOSVRJQUxfVkFMVUUgPSAiaW5pdGlhbFZhbHVlIjsKLQkJU3RyaW5nIFRBQkxFX0dFTkVSQVRPUl9fQUxMT0NBVElPTl9TSVpFID0gImFsbG9jYXRpb25TaXplIjsKLQkJU3RyaW5nIFRBQkxFX0dFTkVSQVRPUl9fVU5JUVVFX0NPTlNUUkFJTlRTID0gInVuaXF1ZUNvbnN0cmFpbnRzIjsKLQlTdHJpbmcgVEVNUE9SQUwgPSBQQUNLQUdFXyArICJUZW1wb3JhbCI7Ci0JCVN0cmluZyBURU1QT1JBTF9fVkFMVUUgPSAidmFsdWUiOwotCVN0cmluZyBUUkFOU0lFTlQgPSBQQUNLQUdFXyArICJUcmFuc2llbnQiOwotCVN0cmluZyBVTklRVUVfQ09OU1RSQUlOVCA9IFBBQ0tBR0VfICsgIlVuaXF1ZUNvbnN0cmFpbnQiOwotCQlTdHJpbmcgVU5JUVVFX0NPTlNUUkFJTlRfX0NPTFVNTl9OQU1FUyA9ICJjb2x1bW5OYW1lcyI7Ci0JU3RyaW5nIFZFUlNJT04gPSBQQUNLQUdFXyArICJWZXJzaW9uIjsKLQotCS8vIEpQQSBlbnVtcwotCVN0cmluZyBHRU5FUkFUSU9OX1RZUEUgPSBQQUNLQUdFXyArICJHZW5lcmF0aW9uVHlwZSI7Ci0JCVN0cmluZyBHRU5FUkFUSU9OX1RZUEVfID0gR0VORVJBVElPTl9UWVBFICsgJy4nOwotCQlTdHJpbmcgR0VORVJBVElPTl9UWVBFX19BVVRPID0gR0VORVJBVElPTl9UWVBFXyArICJBVVRPIjsKLQkJU3RyaW5nIEdFTkVSQVRJT05fVFlQRV9fSURFTlRJVFkgPSBHRU5FUkFUSU9OX1RZUEVfICsgIklERU5USVRZIjsKLQkJU3RyaW5nIEdFTkVSQVRJT05fVFlQRV9fU0VRVUVOQ0UgPSBHRU5FUkFUSU9OX1RZUEVfICsgIlNFUVVFTkNFIjsKLQkJU3RyaW5nIEdFTkVSQVRJT05fVFlQRV9fVEFCTEUgPSBHRU5FUkFUSU9OX1RZUEVfICsgIlRBQkxFIjsKLQotCVN0cmluZyBDQVNDQURFX1RZUEUgPSBQQUNLQUdFXyArICJDYXNjYWRlVHlwZSI7Ci0JCVN0cmluZyBDQVNDQURFX1RZUEVfID0gQ0FTQ0FERV9UWVBFICsgJy4nOwotCQlTdHJpbmcgQ0FTQ0FERV9UWVBFX19BTEwgPSBDQVNDQURFX1RZUEVfICsgIkFMTCI7Ci0JCVN0cmluZyBDQVNDQURFX1RZUEVfX01FUkdFID0gQ0FTQ0FERV9UWVBFXyArICJNRVJHRSI7Ci0JCVN0cmluZyBDQVNDQURFX1RZUEVfX1BFUlNJU1QgPSBDQVNDQURFX1RZUEVfICsgIlBFUlNJU1QiOwotCQlTdHJpbmcgQ0FTQ0FERV9UWVBFX19SRUZSRVNIID0gQ0FTQ0FERV9UWVBFXyArICJSRUZSRVNIIjsKLQkJU3RyaW5nIENBU0NBREVfVFlQRV9fUkVNT1ZFID0gQ0FTQ0FERV9UWVBFXyArICJSRU1PVkUiOwotCi0JU3RyaW5nIERJU0NSSU1JTkFUT1JfVFlQRSA9IFBBQ0tBR0VfICsgIkRpc2NyaW1pbmF0b3JUeXBlIjsKLQkJU3RyaW5nIERJU0NSSU1JTkFUT1JfVFlQRV8gPSBESVNDUklNSU5BVE9SX1RZUEUgKyAnLic7Ci0JCVN0cmluZyBESVNDUklNSU5BVE9SX1RZUEVfX0NIQVIgPSBESVNDUklNSU5BVE9SX1RZUEVfICsgIkNIQVIiOwotCQlTdHJpbmcgRElTQ1JJTUlOQVRPUl9UWVBFX19JTlRFR0VSID0gRElTQ1JJTUlOQVRPUl9UWVBFXyArICJJTlRFR0VSIjsKLQkJU3RyaW5nIERJU0NSSU1JTkFUT1JfVFlQRV9fU1RSSU5HID0gRElTQ1JJTUlOQVRPUl9UWVBFXyArICJTVFJJTkciOwotCi0JU3RyaW5nIEVOVU1fVFlQRSA9IFBBQ0tBR0VfICsgIkVudW1UeXBlIjsKLQkJU3RyaW5nIEVOVU1fVFlQRV8gPSBFTlVNX1RZUEUgKyAnLic7Ci0JCVN0cmluZyBFTlVNX1RZUEVfX09SRElOQUwgPSBFTlVNX1RZUEVfICsgIk9SRElOQUwiOwotCQlTdHJpbmcgRU5VTV9UWVBFX19TVFJJTkcgPSBFTlVNX1RZUEVfICsgIlNUUklORyI7Ci0KLQlTdHJpbmcgRkVUQ0hfVFlQRSA9IFBBQ0tBR0VfICsgIkZldGNoVHlwZSI7Ci0JCVN0cmluZyBGRVRDSF9UWVBFXyA9IEZFVENIX1RZUEUgKyAnLic7Ci0JCVN0cmluZyBGRVRDSF9UWVBFX19FQUdFUiA9IEZFVENIX1RZUEVfICsgIkVBR0VSIjsKLQkJU3RyaW5nIEZFVENIX1RZUEVfX0xBWlkgPSBGRVRDSF9UWVBFXyArICJMQVpZIjsKLQotCVN0cmluZyBGTFVTSF9NT0RFX1RZUEUgPSBQQUNLQUdFXyArICJGbHVzaE1vZGVUeXBlIjsKLQkJU3RyaW5nIEZMVVNIX01PREVfVFlQRV8gPSBGTFVTSF9NT0RFX1RZUEUgKyAnLic7Ci0JCVN0cmluZyBGTFVTSF9NT0RFX1RZUEVfX0FVVE8gPSBGTFVTSF9NT0RFX1RZUEVfICsgIkFVVE8iOwotCQlTdHJpbmcgRkxVU0hfTU9ERV9UWVBFX19DT01NSVQgPSBGTFVTSF9NT0RFX1RZUEVfICsgIkNPTU1JVCI7Ci0KLQlTdHJpbmcgSU5IRVJJVEFOQ0VfVFlQRSA9IFBBQ0tBR0VfICsgIkluaGVyaXRhbmNlVHlwZSI7Ci0JCVN0cmluZyBJTkhFUklUQU5DRV9UWVBFXyA9IElOSEVSSVRBTkNFX1RZUEUgKyAnLic7Ci0JCVN0cmluZyBJTkhFUklUQU5DRV9UWVBFX19KT0lORUQgPSBJTkhFUklUQU5DRV9UWVBFXyArICJKT0lORUQiOwotCQlTdHJpbmcgSU5IRVJJVEFOQ0VfVFlQRV9fU0lOR0xFX1RBQkxFID0gSU5IRVJJVEFOQ0VfVFlQRV8gKyAiU0lOR0xFX1RBQkxFIjsKLQkJU3RyaW5nIElOSEVSSVRBTkNFX1RZUEVfX1RBQkxFX1BFUl9DTEFTUyA9IElOSEVSSVRBTkNFX1RZUEVfICsgIlRBQkxFX1BFUl9DTEFTUyI7Ci0KLQlTdHJpbmcgUEVSU0lTVEVOQ0VfQ09OVEVYVF9UWVBFID0gUEFDS0FHRV8gKyAiUGVyc2lzdGVuY2VDb250ZXh0VHlwZSI7Ci0JCVN0cmluZyBQRVJTSVNURU5DRV9DT05URVhUX1RZUEVfID0gUEVSU0lTVEVOQ0VfQ09OVEVYVF9UWVBFICsgJy4nOwotCQlTdHJpbmcgUEVSU0lTVEVOQ0VfQ09OVEVYVF9UWVBFX19FWFRFTkRFRCA9IFBFUlNJU1RFTkNFX0NPTlRFWFRfVFlQRV8gKyAiRVhURU5ERUQiOwotCQlTdHJpbmcgUEVSU0lTVEVOQ0VfQ09OVEVYVF9UWVBFX19UUkFOU0FDVElPTiA9IFBFUlNJU1RFTkNFX0NPTlRFWFRfVFlQRV8gKyAiVFJBTlNBQ1RJT04iOwotCi0JU3RyaW5nIFRFTVBPUkFMX1RZUEUgPSBQQUNLQUdFXyArICJUZW1wb3JhbFR5cGUiOwotCQlTdHJpbmcgVEVNUE9SQUxfVFlQRV8gPSBURU1QT1JBTF9UWVBFICsgJy4nOwotCQlTdHJpbmcgVEVNUE9SQUxfVFlQRV9fREFURSA9IFRFTVBPUkFMX1RZUEVfICsgIkRBVEUiOwotCQlTdHJpbmcgVEVNUE9SQUxfVFlQRV9fVElNRSA9IFRFTVBPUkFMX1RZUEVfICsgIlRJTUUiOwotCQlTdHJpbmcgVEVNUE9SQUxfVFlQRV9fVElNRVNUQU1QID0gVEVNUE9SQUxfVFlQRV8gKyAiVElNRVNUQU1QIjsKLQotCS8vIEpQQSBpbnRlcmZhY2VzCi0JU3RyaW5nIEVOVElUWV9NQU5BR0VSID0gUEFDS0FHRV8gKyAiRW50aXR5TWFuYWdlciI7Ci0JU3RyaW5nIEVOVElUWV9NQU5BR0VSX0ZBQ1RPUlkgPSBQQUNLQUdFXyArICJFbnRpdHlNYW5hZ2VyRmFjdG9yeSI7Ci0JU3RyaW5nIEVOVElUWV9UUkFOU0FDVElPTiA9IFBBQ0tBR0VfICsgIkVudGl0eVRyYW5zYWN0aW9uIjsKLQlTdHJpbmcgSU5TVFJVTUVOVEFCTEVfQ0xBU1NfTE9BREVSID0gUEFDS0FHRV8gKyAiSW5zdHJ1bWVudGFibGVDbGFzc0xvYWRlciI7Ci0JU3RyaW5nIFFVRVJZID0gUEFDS0FHRV8gKyAiUXVlcnkiOwotCi0JLy8gSlBBIGNsYXNzZXMKLQlTdHJpbmcgUEVSU0lTVEVOQ0UgPSBQQUNLQUdFXyArICJYbWxQZXJzaXN0ZW5jZSI7Ci0KLQkvLyBKUEEgZXhjZXB0aW9ucwotCVN0cmluZyBOT05fVU5JUVVFX1JFU1VMVF9FWENFUFRJT04gPSBQQUNLQUdFXyArICJOb25VbmlxdWVSZXN1bHRFeGNlcHRpb24iOwotCVN0cmluZyBPQkpFQ1RfTk9UX0ZPVU5EX0VYQ0VQVElPTiA9IFBBQ0tBR0VfICsgIk9iamVjdE5vdEZvdW5kRXhjZXB0aW9uIjsKLQlTdHJpbmcgUEVSU0lTVEVOQ0VfRVhDRVBUSU9OID0gUEFDS0FHRV8gKyAiUGVyc2lzdGVuY2VFeGNlcHRpb24iOwotCi0KLQkvLyAqKioqKioqKioqIFNQSSAqKioqKioqKioqCi0KLQkvLyBKUEEgU1BJIHBhY2thZ2UKLQlTdHJpbmcgU1BJX1BBQ0tBR0UgPSBQQUNLQUdFXyArICJzcGkiOwotCVN0cmluZyBTUElfUEFDS0FHRV8gPSBTUElfUEFDS0FHRSArICcuJzsKLQotCS8vIEpQQSBTUEkgaW50ZXJmYWNlcwotCVN0cmluZyBFTlRJVFlfTUFOQUdFUl9GQUNUT1JZX1BST1ZJREVSID0gU1BJX1BBQ0tBR0VfICsgIkVudGl0eU1hbmFnZXJGYWN0b3J5UHJvdmlkZXIiOwotCVN0cmluZyBQRVJTSVNURU5DRV9JTkZPID0gU1BJX1BBQ0tBR0VfICsgIlBlcnNpc3RlbmNlSW5mbyI7Ci0JU3RyaW5nIFBFUlNJU1RFTkNFX1BST1ZJREVSID0gU1BJX1BBQ0tBR0VfICsgIlBlcnNpc3RlbmNlUHJvdmlkZXIiOwotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsL0pwdEdlbk1lc3NhZ2VzLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsL0pwdEdlbk1lc3NhZ2VzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGI3NjVhYmQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbC9KcHRHZW5NZXNzYWdlcy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsOwotCi1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLQotLyoqCi0gKiBMb2NhbGl6ZWQgbWVzc2FnZXMgdXNlZCBieSBEYWxpIGVudGl0eSBnZW5lcmF0aW9uLgotICovCi1jbGFzcyBKcHRHZW5NZXNzYWdlcyB7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQYWNrYWdlR2VuZXJhdG9yX3Rhc2tOYW1lOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEdlblNjb3BlX3Rhc2tOYW1lOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEVudGl0eUdlbmVyYXRvcl90YXNrTmFtZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUZW1wbGF0ZXNfbm90Rm91bmQ7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQlVORExFX05BTUUgPSAianB0X2dlbiI7IC8vJE5PTi1OTFMtMSQKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBDbGFzczw/PiBCVU5ETEVfQ0xBU1MgPSBKcHRHZW5NZXNzYWdlcy5jbGFzczsKLQlzdGF0aWMgewotCQlOTFMuaW5pdGlhbGl6ZU1lc3NhZ2VzKEJVTkRMRV9OQU1FLCBCVU5ETEVfQ0xBU1MpOwotCX0KLQkKLQlwcml2YXRlIEpwdEdlbk1lc3NhZ2VzKCkgewotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwvTWFueVRvTWFueVJlbGF0aW9uLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsL01hbnlUb01hbnlSZWxhdGlvbi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxMjYzMWE1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwvTWFueVRvTWFueVJlbGF0aW9uLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMTEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkZvcmVpZ25LZXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci0KLS8qKgotICogVGhpcyBvYmplY3QgaXMgc2hhcmVkIGJ5IHRoZSB0d28gZ2VuIHRhYmxlcyB0aGF0IG1ha2UgdXAgdGhlIHJlbGF0aW9uLgotICogVXBvbiBjb25zdHJ1Y3Rpb24sICdtYXBwZWRCeScgd2lsbCBiZSAnbnVsbCcuIFRoZSBmaXJzdCBnZW4gdGFibGUgdG8gYmUKLSAqIHVzZWQgdG8gZ2VuZXJhdGUgYW4gZW50aXR5IHdpbGwgZmlsbCBpbiAnbWFwcGVkQnknIHdpdGggdGhlIGFwcHJvcHJpYXRlCi0gKiBhdHRyaWJ1dGUgKGZpZWxkL3Byb3BlcnR5KSBuYW1lLgotICovCi1jbGFzcyBNYW55VG9NYW55UmVsYXRpb24gewotCXByaXZhdGUgZmluYWwgR2VuVGFibGUgam9pbkdlblRhYmxlOwotCXByaXZhdGUgZmluYWwgRm9yZWlnbktleSBvd25pbmdGb3JlaWduS2V5OwotCXByaXZhdGUgZmluYWwgR2VuVGFibGUgb3duaW5nR2VuVGFibGU7Ci0JcHJpdmF0ZSBmaW5hbCBGb3JlaWduS2V5IG5vbk93bmluZ0ZvcmVpZ25LZXk7Ci0JcHJpdmF0ZSBmaW5hbCBHZW5UYWJsZSBub25Pd25pbmdHZW5UYWJsZTsKLQlwcml2YXRlIFN0cmluZyBtYXBwZWRCeTsgIC8vIHNldCB3aGlsZSBnZW5lcmF0aW5nIGVudGl0aWVzCi0KLQotCU1hbnlUb01hbnlSZWxhdGlvbigKLQkJCUdlblRhYmxlIGpvaW5HZW5UYWJsZSwKLQkJCUZvcmVpZ25LZXkgb3duaW5nRm9yZWlnbktleSwKLQkJCUdlblRhYmxlIG93bmluZ0dlblRhYmxlLAotCQkJRm9yZWlnbktleSBub25Pd25pbmdGb3JlaWduS2V5LAotCQkJR2VuVGFibGUgbm9uT3duaW5nR2VuVGFibGUKLQkpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5qb2luR2VuVGFibGUgPSBqb2luR2VuVGFibGU7Ci0KLQkJdGhpcy5vd25pbmdGb3JlaWduS2V5ID0gb3duaW5nRm9yZWlnbktleTsKLQkJdGhpcy5vd25pbmdHZW5UYWJsZSA9IG93bmluZ0dlblRhYmxlOwotCQlvd25pbmdHZW5UYWJsZS5hZGRPd25lZE1hbnlUb01hbnlSZWxhdGlvbih0aGlzKTsKLQotCQl0aGlzLm5vbk93bmluZ0ZvcmVpZ25LZXkgPSBub25Pd25pbmdGb3JlaWduS2V5OwotCQl0aGlzLm5vbk93bmluZ0dlblRhYmxlID0gbm9uT3duaW5nR2VuVGFibGU7Ci0JCW5vbk93bmluZ0dlblRhYmxlLmFkZE5vbk93bmVkTWFueVRvTWFueVJlbGF0aW9uKHRoaXMpOwotCX0KLQotCUdlblRhYmxlIGdldEpvaW5HZW5UYWJsZSgpIHsKLQkJcmV0dXJuIHRoaXMuam9pbkdlblRhYmxlOwotCX0KLQotCUZvcmVpZ25LZXkgZ2V0T3duaW5nRm9yZWlnbktleSgpIHsKLQkJcmV0dXJuIHRoaXMub3duaW5nRm9yZWlnbktleTsKLQl9Ci0KLQlHZW5UYWJsZSBnZXRPd25pbmdHZW5UYWJsZSgpIHsKLQkJcmV0dXJuIHRoaXMub3duaW5nR2VuVGFibGU7Ci0JfQotCi0JRm9yZWlnbktleSBnZXROb25Pd25pbmdGb3JlaWduS2V5KCkgewotCQlyZXR1cm4gdGhpcy5ub25Pd25pbmdGb3JlaWduS2V5OwotCX0KLQotCUdlblRhYmxlIGdldE5vbk93bmluZ0dlblRhYmxlKCkgewotCQlyZXR1cm4gdGhpcy5ub25Pd25pbmdHZW5UYWJsZTsKLQl9Ci0KLQlTdHJpbmcgZ2V0T3duZWRBdHRyaWJ1dGVOYW1lKCkgewotCQlyZXR1cm4gdGhpcy5ub25Pd25pbmdHZW5UYWJsZS5nZXRDb2xsZWN0aW9uQXR0cmlidXRlTmFtZSgpOwotCX0KLQotCVN0cmluZyBnZXROb25Pd25lZEF0dHJpYnV0ZU5hbWUoKSB7Ci0JCXJldHVybiB0aGlzLm93bmluZ0dlblRhYmxlLmdldENvbGxlY3Rpb25BdHRyaWJ1dGVOYW1lKCk7Ci0JfQotCi0JLyoqCi0JICogdGhlIHNjb3BlIGNsZWFycyB0aGUgam9pbiB0YWJsZSByZWxhdGlvbiBpZiB0aGVyZSBhcmUgYW55IHJlZmVyZW5jZXMKLQkgKiB0byB0aGUgam9pbiB0YWJsZQotCSAqLwotCXZvaWQgY2xlYXIoKSB7Ci0JCXRoaXMub3duaW5nR2VuVGFibGUucmVtb3ZlT3duZWRNYW55VG9NYW55UmVsYXRpb24odGhpcyk7Ci0JCXRoaXMubm9uT3duaW5nR2VuVGFibGUucmVtb3ZlTm9uT3duZWRNYW55VG9NYW55UmVsYXRpb24odGhpcyk7Ci0JfQotCi0JU3RyaW5nIGdldE1hcHBlZEJ5KCkgewotCQlyZXR1cm4gdGhpcy5tYXBwZWRCeTsKLQl9Ci0KLQl2b2lkIHNldE1hcHBlZEJ5KFN0cmluZyBtYXBwZWRCeSkgewotCQl0aGlzLm1hcHBlZEJ5ID0gbWFwcGVkQnk7Ci0JfQotCi0JU3RyaW5nIGdldE93bmluZ0VudGl0eU5hbWUoKSB7Ci0JCXJldHVybiB0aGlzLm93bmluZ0dlblRhYmxlLmdldEVudGl0eU5hbWUoKTsKLQl9Ci0KLQlTdHJpbmcgZ2V0Tm9uT3duaW5nRW50aXR5TmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMubm9uT3duaW5nR2VuVGFibGUuZ2V0RW50aXR5TmFtZSgpOwotCX0KLQotCWJvb2xlYW4gam9pblRhYmxlTmFtZUlzRGVmYXVsdCgpIHsKLQkJcmV0dXJuIHRoaXMuam9pbkdlblRhYmxlLmpvaW5UYWJsZU5hbWVJc0RlZmF1bHQoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuYnVpbGRUb1N0cmluZ0Zvcih0aGlzLCB0aGlzLmpvaW5HZW5UYWJsZSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsL01hbnlUb09uZVJlbGF0aW9uLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsL01hbnlUb09uZVJlbGF0aW9uLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGI2OWU0MDIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbC9NYW55VG9PbmVSZWxhdGlvbi5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkZvcmVpZ25LZXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci0KLS8qKgotICogVGhpcyBvYmplY3QgaXMgaGVsZCBieSB0aGUgImJhc2UiIGdlbiB0YWJsZSBhbmQsIGluZGlyZWN0bHkgdmlhIGEKLSAqIG9uZS10by1tYW55IHJlbGF0aW9uLCB0aGUgInJlZmVyZW5jZWQiIGdlbiB0YWJsZS4KLSAqIFRoZSAibWFwcGVkIGJ5IiBhdHRyaWJ1dGUgKGZpZWxkL3Byb3BlcnR5KSBuYW1lIGlzIHNldCB3aGlsZSB0aGUKLSAqICJiYXNlIiB0YWJsZSBpcyBjYWxjdWxhdGluZyBpdHMgYXR0cmlidXRlIG5hbWVzLgotICovCi1jbGFzcyBNYW55VG9PbmVSZWxhdGlvbiB7Ci0JcHJpdmF0ZSBmaW5hbCBHZW5UYWJsZSBiYXNlR2VuVGFibGU7ICAvLyB0aGUgIm1hbnkiIHNpZGUgKGUuZy4gRGV0YWlsKQotCXByaXZhdGUgZmluYWwgRm9yZWlnbktleSBmb3JlaWduS2V5OwotCXByaXZhdGUgZmluYWwgR2VuVGFibGUgcmVmZXJlbmNlZEdlblRhYmxlOyAgLy8gdGhlICJvbmUiIHNpZGUgKGUuZy4gTWFzdGVyKQotCXByaXZhdGUgU3RyaW5nIG1hcHBlZEJ5OyAgLy8gc2V0IHdoaWxlIGdlbmVyYXRpbmcgZW50aXRpZXM7IHVzZWQgYnkgcGFydG5lciBvbmUtdG8tbWFueSByZWxhdGlvbgotCi0KLQlNYW55VG9PbmVSZWxhdGlvbigKLQkJCUdlblRhYmxlIGJhc2VHZW5UYWJsZSwKLQkJCUZvcmVpZ25LZXkgZm9yZWlnbktleSwKLQkJCUdlblRhYmxlIHJlZmVyZW5jZWRHZW5UYWJsZQotCSkgewotCQlzdXBlcigpOwotCQl0aGlzLmJhc2VHZW5UYWJsZSA9IGJhc2VHZW5UYWJsZTsKLQkJdGhpcy5mb3JlaWduS2V5ID0gZm9yZWlnbktleTsKLQkJdGhpcy5yZWZlcmVuY2VkR2VuVGFibGUgPSByZWZlcmVuY2VkR2VuVGFibGU7Ci0JCXJlZmVyZW5jZWRHZW5UYWJsZS5hZGRPbmVUb01hbnlSZWxhdGlvbihuZXcgT25lVG9NYW55UmVsYXRpb24odGhpcykpOwotCX0KLQotCUdlblRhYmxlIGdldEJhc2VHZW5UYWJsZSgpIHsKLQkJcmV0dXJuIHRoaXMuYmFzZUdlblRhYmxlOwotCX0KLQotCUZvcmVpZ25LZXkgZ2V0Rm9yZWlnbktleSgpIHsKLQkJcmV0dXJuIHRoaXMuZm9yZWlnbktleTsKLQl9Ci0KLQlHZW5UYWJsZSBnZXRSZWZlcmVuY2VkR2VuVGFibGUoKSB7Ci0JCXJldHVybiB0aGlzLnJlZmVyZW5jZWRHZW5UYWJsZTsKLQl9Ci0KLQlTdHJpbmcgZ2V0QXR0cmlidXRlTmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMuZm9yZWlnbktleS5nZXRBdHRyaWJ1dGVOYW1lKCk7Ci0JfQotCi0JU3RyaW5nIGdldE1hcHBlZEJ5KCkgewotCQlyZXR1cm4gdGhpcy5tYXBwZWRCeTsKLQl9Ci0KLQl2b2lkIHNldE1hcHBlZEJ5KFN0cmluZyBtYXBwZWRCeSkgewotCQl0aGlzLm1hcHBlZEJ5ID0gbWFwcGVkQnk7Ci0JfQotCi0JU3RyaW5nIGdldEJhc2VFbnRpdHlOYW1lKCkgewotCQlyZXR1cm4gdGhpcy5iYXNlR2VuVGFibGUuZ2V0RW50aXR5TmFtZSgpOwotCX0KLQotCVN0cmluZyBnZXRSZWZlcmVuY2VkRW50aXR5TmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMucmVmZXJlbmNlZEdlblRhYmxlLmdldEVudGl0eU5hbWUoKTsKLQl9Ci0KLQlTdHJpbmcgZ2V0QmFzZUdlblRhYmxlQ29sbGVjdGlvbkF0dHJpYnV0ZU5hbWUoKSB7Ci0JCXJldHVybiB0aGlzLmJhc2VHZW5UYWJsZS5nZXRDb2xsZWN0aW9uQXR0cmlidXRlTmFtZSgpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuZm9yZWlnbktleSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsL09uZVRvTWFueVJlbGF0aW9uLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsL09uZVRvTWFueVJlbGF0aW9uLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhkODMyY2MuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbC9PbmVUb01hbnlSZWxhdGlvbi5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci0KLS8qKgotICogVGhpcyBvYmplY3QgaXMgdGhlIGludmVyc2Ugb2YgdGhlIGNvcnJlc3BvbmRpbmcgbWFueS10by1vbmUgcmVsYXRpb24uCi0gKi8KLWNsYXNzIE9uZVRvTWFueVJlbGF0aW9uIHsKLQlwcml2YXRlIGZpbmFsIE1hbnlUb09uZVJlbGF0aW9uIG1hbnlUb09uZVJlbGF0aW9uOwotCi0KLQlPbmVUb01hbnlSZWxhdGlvbihNYW55VG9PbmVSZWxhdGlvbiBtYW55VG9PbmVSZWxhdGlvbikgewotCQlzdXBlcigpOwotCQl0aGlzLm1hbnlUb09uZVJlbGF0aW9uID0gbWFueVRvT25lUmVsYXRpb247Ci0JfQotCi0JTWFueVRvT25lUmVsYXRpb24gZ2V0TWFueVRvT25lUmVsYXRpb24oKSB7Ci0JCXJldHVybiB0aGlzLm1hbnlUb09uZVJlbGF0aW9uOwotCX0KLQotCVN0cmluZyBnZXRBdHRyaWJ1dGVOYW1lKCkgewotCQlyZXR1cm4gdGhpcy5tYW55VG9PbmVSZWxhdGlvbi5nZXRCYXNlR2VuVGFibGVDb2xsZWN0aW9uQXR0cmlidXRlTmFtZSgpOwotCX0KLQotCVN0cmluZyBnZXRNYXBwZWRCeSgpIHsKLQkJcmV0dXJuIHRoaXMubWFueVRvT25lUmVsYXRpb24uZ2V0TWFwcGVkQnkoKTsKLQl9Ci0KLQlTdHJpbmcgZ2V0UmVmZXJlbmNlZEVudGl0eU5hbWUoKSB7Ci0JCXJldHVybiB0aGlzLm1hbnlUb09uZVJlbGF0aW9uLmdldEJhc2VFbnRpdHlOYW1lKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5tYW55VG9PbmVSZWxhdGlvbik7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsL1BhY2thZ2VHZW5lcmF0b3IuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwvUGFja2FnZUdlbmVyYXRvci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwYWEwYjVlLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwvUGFja2FnZUdlbmVyYXRvci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTAzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuSVByb2dyZXNzTW9uaXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuT3BlcmF0aW9uQ2FuY2VsZWRFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLlN1Yk1vbml0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSVBhY2thZ2VGcmFnbWVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotLyoqCi0gKiBUaGlzIGdlbmVyYXRvciB3aWxsIGdlbmVyYXRlIGEgcGFja2FnZSBvZiBlbnRpdGllcyBmb3IgYSBzZXQgb2YgdGFibGVzLgotICovCi1wdWJsaWMgY2xhc3MgUGFja2FnZUdlbmVyYXRvciB7Ci0JcHJpdmF0ZSBmaW5hbCBDb25maWcgY29uZmlnOwotCXByaXZhdGUgZmluYWwgRW50aXR5R2VuZXJhdG9yLkNvbmZpZyBlbnRpdHlDb25maWc7Ci0JcHJpdmF0ZSBmaW5hbCBHZW5TY29wZSBzY29wZTsKLQotCi0JLy8gKioqKioqKioqKiBwdWJsaWMgQVBJICoqKioqKioqKioKLQotCXB1YmxpYyBzdGF0aWMgdm9pZCBnZW5lcmF0ZUVudGl0aWVzKAotCQkJQ29uZmlnIGNvbmZpZywKLQkJCUVudGl0eUdlbmVyYXRvci5Db25maWcgZW50aXR5Q29uZmlnLAotCQkJSVByb2dyZXNzTW9uaXRvciBwcm9ncmVzc01vbml0b3IKLQkpIHsKLQkJaWYgKChjb25maWcgPT0gbnVsbCkgfHwgKGVudGl0eUNvbmZpZyA9PSBudWxsKSkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJU3ViTW9uaXRvciBzbSA9IFN1Yk1vbml0b3IuY29udmVydChwcm9ncmVzc01vbml0b3IsIEpwdEdlbk1lc3NhZ2VzLlBhY2thZ2VHZW5lcmF0b3JfdGFza05hbWUsIDEwMCk7Ci0JCW5ldyBQYWNrYWdlR2VuZXJhdG9yKGNvbmZpZywgZW50aXR5Q29uZmlnLCBzbS5uZXdDaGlsZCgxMCkpLmdlbmVyYXRlRW50aXRpZXMoc20ubmV3Q2hpbGQoOTApKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0aW9uL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCXByaXZhdGUgUGFja2FnZUdlbmVyYXRvcigKLQkJCUNvbmZpZyBjb25maWcsCi0JCQlFbnRpdHlHZW5lcmF0b3IuQ29uZmlnIGVudGl0eUNvbmZpZywKLQkJCUlQcm9ncmVzc01vbml0b3IgcHJvZ3Jlc3NNb25pdG9yCi0JKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuY29uZmlnID0gY29uZmlnOwotCQl0aGlzLmVudGl0eUNvbmZpZyA9IGVudGl0eUNvbmZpZzsKLQkJdGhpcy5zY29wZSA9IG5ldyBHZW5TY29wZShlbnRpdHlDb25maWcsIHByb2dyZXNzTW9uaXRvcik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGdlbmVyYXRpb24gKioqKioqKioqKgotCi0JcHJpdmF0ZSB2b2lkIGdlbmVyYXRlRW50aXRpZXMoSVByb2dyZXNzTW9uaXRvciBwcm9ncmVzc01vbml0b3IpIHsKLQkJU3ViTW9uaXRvciBzbSA9IFN1Yk1vbml0b3IuY29udmVydChwcm9ncmVzc01vbml0b3IsIHRoaXMuc2NvcGUuZW50aXR5VGFibGVzU2l6ZSgpKTsKLQkJZm9yIChJdGVyYXRvcjxHZW5UYWJsZT4gc3RyZWFtID0gdGhpcy5zY29wZS5lbnRpdHlHZW5UYWJsZXMoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQl0aGlzLmNoZWNrQ2FuY2VsZWQoc20pOwotCQkJdGhpcy5nZW5lcmF0ZUVudGl0eShzdHJlYW0ubmV4dCgpLCBzbS5uZXdDaGlsZCgxKSk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgZ2VuZXJhdGVFbnRpdHkoR2VuVGFibGUgZ2VuVGFibGUsIElQcm9ncmVzc01vbml0b3IgcHJvZ3Jlc3NNb25pdG9yKSB7Ci0JCUVudGl0eUdlbmVyYXRvci5nZW5lcmF0ZUVudGl0eSgKLQkJCQl0aGlzLmVudGl0eUNvbmZpZywKLQkJCQl0aGlzLmNvbmZpZy5nZXRQYWNrYWdlRnJhZ21lbnQoKSwKLQkJCQlnZW5UYWJsZSwKLQkJCQlwcm9ncmVzc01vbml0b3IKLQkJKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgY2hlY2tDYW5jZWxlZChJUHJvZ3Jlc3NNb25pdG9yIHByb2dyZXNzTW9uaXRvcikgewotCQlpZiAocHJvZ3Jlc3NNb25pdG9yLmlzQ2FuY2VsZWQoKSkgewotCQkJdGhyb3cgbmV3IE9wZXJhdGlvbkNhbmNlbGVkRXhjZXB0aW9uKCk7Ci0JCX0KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuYnVpbGRUb1N0cmluZ0Zvcih0aGlzLCB0aGlzLnNjb3BlKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY29uZmlnICoqKioqKioqKioKLQotCXB1YmxpYyBzdGF0aWMgY2xhc3MgQ29uZmlnIHsKLQkJcHJpdmF0ZSBJUGFja2FnZUZyYWdtZW50IHBhY2thZ2VGcmFnbWVudDsKLQotCQlwdWJsaWMgSVBhY2thZ2VGcmFnbWVudCBnZXRQYWNrYWdlRnJhZ21lbnQoKSB7Ci0JCQlyZXR1cm4gdGhpcy5wYWNrYWdlRnJhZ21lbnQ7Ci0JCX0KLQotCQlwdWJsaWMgdm9pZCBzZXRQYWNrYWdlRnJhZ21lbnQoSVBhY2thZ2VGcmFnbWVudCBwYWNrYWdlRnJhZ21lbnQpIHsKLQkJCXRoaXMucGFja2FnZUZyYWdtZW50ID0gcGFja2FnZUZyYWdtZW50OwotCQl9Ci0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL0Fzc29jaWF0aW9uLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9Bc3NvY2lhdGlvbi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0N2NhZDkwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL0Fzc29jaWF0aW9uLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzODggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsMjsKLQotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkZvcmVpZ25LZXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDIudXRpbC5TdHJpbmdVdGlsOwotCi0vKioKLSAqIFJlcHJlc2VudHMgYW4gT1JNIGFzc29jaWF0aW9uLgotICogVGhlcmUgYXJlIHR3byB0eXBlcyBvZiBhc3NvY2lhdGlvbnM6Ci0gKiA8dWw+PGxpPnNpbXBsZSBhc3NvY2lhdGlvbjogQW4gYXNzb2NpYXRpb24gYmV0d2VlbiB0d28gZGF0YWJhc2UgdGFibGVzLgotICogVGhlIDxlbT5yZWZlcnJlcjwvY29kZT4gdGFibGUgaXMgdGhlIG9uZSBjb250YWluaW5nIHRoZSBmb3JlaWduIGtleQotICogLCB0aGUgPGVtPnJlZmVyZW5jZWQ8L2NvZGU+IHRhYmxlIGlzIHRoZSBvdGhlciBwYXJ0eS48YnI+Ci0gKiAKLSAqIDxsaT5tYW55IHRvIG1hbnkgYXNzb2NpYXRpb246IEFuIGFzc29jaWF0aW9uIGJldHdlZW4gdHdvIHRhYmxlcyBqb2luZWQgYnkgCi0gKiBhIDxlbT5qb2luIHRhYmxlPC9lbT4uCi0gKiBJbiB0aGUgZXhhbXBsZSBBVVRIT1IsIEJPT0ssIEFVVEhPUl9CT09LLCBUaGUgcmVmZXJyZXIgYW5kIHJlZmVyZW5jZWQgYXJlIAotICogQVVUSE9SIGFuZCAgQk9PSywgYW5kIHRoZSBqb2luIHRhYmxlIGlzIEFVVEhPUl9CT09LLgotICogPC91bD4KLSAqIAotICovCi1wdWJsaWMgY2xhc3MgQXNzb2NpYXRpb24gaW1wbGVtZW50cyBqYXZhLmlvLlNlcmlhbGl6YWJsZQotewotCXByaXZhdGUgZmluYWwgc3RhdGljIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDI7Ci0KLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBNQU5ZX1RPX09ORSA9ICJtYW55LXRvLW9uZSI7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgTUFOWV9UT19NQU5ZID0gIm1hbnktdG8tbWFueSI7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgT05FX1RPX09ORSA9ICJvbmUtdG8tb25lIjsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBPTkVfVE9fTUFOWSA9ICJvbmUtdG8tbWFueSI7Ci0JCi0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgQklfREkgPSAiYmktZGkiOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIE5PUk1BTF9ESSA9ICJub3JtYWwtZGkiOyAvL3JlZmVycmVyLT5yZWZlcmVuY2VkCi0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgT1BQT1NJVEVfREkgPSAib3Bwb3NpdGUtZGkiOyAvL3JlZmVyZW5jZWQtPnJlZmVycmVyCi0JCi0JcHJpdmF0ZSB0cmFuc2llbnQgT1JNR2VuQ3VzdG9taXplciBtQ3VzdG9taXplcjsKLQlwcml2YXRlIFN0cmluZyBtUmVmZXJyZXJUYWJsZU5hbWU7Ci0JcHJpdmF0ZSBTdHJpbmcgbVJlZmVyZW5jZWRUYWJsZU5hbWU7Ci0JcHJpdmF0ZSBTdHJpbmcgbUpvaW5UYWJsZU5hbWU7Ci0KLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBtUmVmZXJyZXJDb2xOYW1lczsgLypTdHJpbmcgb2JqZWN0cyovCi0JcHJpdmF0ZSBMaXN0PFN0cmluZz4gbVJlZmVyZW5jZWRDb2xOYW1lczsgLypTdHJpbmcgb2JqZWN0cyovCi0JcHJpdmF0ZSBMaXN0PFN0cmluZz4gbVJlZmVycmVySm9pbkNvbE5hbWVzOyAvKlN0cmluZyBvYmplY3RzKi8KLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBtUmVmZXJlbmNlZEpvaW5Db2xOYW1lczsgLypTdHJpbmcgb2JqZWN0cyovCi0KLQlwcml2YXRlIHRyYW5zaWVudCBMaXN0PE9STUdlbkNvbHVtbj4gbVJlZmVycmVyQ29sczsgLypPUk1HZW5Db2x1bW4gb2JqZWN0cyovCi0JcHJpdmF0ZSB0cmFuc2llbnQgTGlzdDxPUk1HZW5Db2x1bW4+IG1SZWZlcmVuY2VkQ29sczsgLypPUk1HZW5Db2x1bW4gb2JqZWN0cyovCi0JcHJpdmF0ZSB0cmFuc2llbnQgTGlzdDxPUk1HZW5Db2x1bW4+IG1SZWZlcnJlckpvaW5Db2xzOyAvKk9STUdlbkNvbHVtbiBvYmplY3RzKi8KLQlwcml2YXRlIHRyYW5zaWVudCBMaXN0PE9STUdlbkNvbHVtbj4gbVJlZmVyZW5jZWRKb2luQ29sczsgLypPUk1HZW5Db2x1bW4gb2JqZWN0cyovCi0JCi0JcHJpdmF0ZSBTdHJpbmcgbUNhcmRpbmFsaXR5OwotCXByaXZhdGUgU3RyaW5nIG1EaXJlY3Rpb25hbGl0eTsKLQlwcml2YXRlIGJ5dGUgbUZsYWdzID0gR0VORVJBVEVEOwotCQotCXByaXZhdGUgQXNzb2NpYXRpb25Sb2xlIG1SZWZlcnJlclJvbGU7Ci0JcHJpdmF0ZSBBc3NvY2lhdGlvblJvbGUgbVJlZmVyZW5jZWRSb2xlOwotCi0JcHJpdmF0ZSB0cmFuc2llbnQgRm9yZWlnbktleSBtRm9yZWlnbktleTsJCi0JCi0JLypjb25zdGFudHMgZm9yIG1GbGFncyovCi0JLyp3aGV0aGVyIHRoZSBhc3NvY2lhdGlvbiBzaG91bGQgYmUgZ2VuZXJhdGVkKi8KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBieXRlIEdFTkVSQVRFRCA9IDEgPDwgMDsKLQkvKndoZXRoZXIgdGhlIGFzc29jaWF0aW9uIGlzIGN1c3RvbSAoaS5lIGlzIG5vdCBhdXRvIGNvbXB1dGVkIGZyb20gZm9yZWlnbiBrZXlzIHJlbGF0aW9uc2hpcHMpLiovCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgYnl0ZSBDVVNUT00gPSAxIDw8IDE7Ci0JCi0JLyoqCi0JICogVGhlIHNpbXBsZSBhc3NvY2lhdGlvbiBjb25zdHJ1Y3Rvci4KLQkgKiBUaGUgMiB0YWJsZXMgYXJlIGpvaW5lZCB3aGVuIHRoZSB2YWx1ZXMgb2YgZWFjaCBjb2x1bW4gaW4KLQkgKiByZWZlcnJlckNvbE5hbWVzIG1hdGNoIGl0cyBjb3JyZXNwb25kaW5nIGNvbHVtbiBpbiByZWZlcmVuY2VkQ29sTmFtZXMuCi0JICogCi0JICogQHBhcmFtIHJlZmVycmVyVGFibGVOYW1lIFRoZSAiZm9yZWlnbiBrZXkiIHRhYmxlLgotCSAqIEBwYXJhbSByZWZlcnJlckNvbE5hbWVzIFRoZSBjb2x1bW4gbmFtZXMgaW4gdGhlIHJlZmVycmVyIHRhYmxlLgotCSAqIEBwYXJhbSByZWZlcmVuY2VkVGFibGVOYW1lIFRoZSAicHJpbWFyeSBrZXkiIHRhYmxlLgotCSAqIEBwYXJhbSByZWZlcmVuY2VkQ29sTmFtZXMgVGhlIGNvbHVtbiBuYW1lcyBpbiB0aGUgcmVmZXJlbmNlZCB0YWJsZS4KLQkgKi8KLQlwdWJsaWMgQXNzb2NpYXRpb24oT1JNR2VuQ3VzdG9taXplciBjdXN0b21pemVyLCBTdHJpbmcgcmVmZXJyZXJUYWJsZU5hbWUsIExpc3Q8U3RyaW5nPiByZWZlcnJlckNvbE5hbWVzCi0JCQksIFN0cmluZyByZWZlcmVuY2VkVGFibGVOYW1lLCBMaXN0PFN0cmluZz4gcmVmZXJlbmNlZENvbE5hbWVzKSAgewotCQlzdXBlcigpOwotCQkKLQkJbUN1c3RvbWl6ZXIgPSBjdXN0b21pemVyOwotCQltUmVmZXJyZXJUYWJsZU5hbWUgPSByZWZlcnJlclRhYmxlTmFtZTsKLQkJbVJlZmVyZW5jZWRUYWJsZU5hbWUgPSByZWZlcmVuY2VkVGFibGVOYW1lOwotCQltUmVmZXJyZXJDb2xOYW1lcyA9IHJlZmVycmVyQ29sTmFtZXM7Ci0JCW1SZWZlcmVuY2VkQ29sTmFtZXMgPSByZWZlcmVuY2VkQ29sTmFtZXM7Ci0JCQotCQltQ2FyZGluYWxpdHkgPSBNQU5ZX1RPX09ORTsKLQkJbURpcmVjdGlvbmFsaXR5ID0gQklfREk7Ci0JCQotCQlzZXRDdXN0b20odHJ1ZSk7Ci0JfQotCS8qKgotCSAqIFRoZSBtYW55IHRvIG1hbnkgY29uc3RydWN0b3IuCi0JICogVGhlIDIgdGFibGVzIGFyZSBqb2luZWQgd2hlbiB0aGUgdmFsdWVzIG9mIGVhY2ggY29sdW1uIGluCi0JICogcmVmZXJyZXJDb2xOYW1lcyBtYXRjaCBpdHMgY29ycmVzcG9uZGluZyBjb2x1bW4gaW4gcmVmZXJyZXJKb2luQ29sTmFtZXMKLQkgKiAsIGFuZCBlYWNoIGNvbHVtbiBpbiByZWZlcmVuY2VkQ29sTmFtZXMgbWF0Y2ggaXRzIGNvcnJlc3BvbmRpbmcgY29sdW1uIGluIHJlZmVyZW5jZWRKb2luQ29sTmFtZXMuCi0JICoKLQkgKi8KLQlwdWJsaWMgQXNzb2NpYXRpb24oT1JNR2VuQ3VzdG9taXplciBjdXN0b21pemVyLCBTdHJpbmcgcmVmZXJyZXJUYWJsZU5hbWUsIExpc3Q8U3RyaW5nPiByZWZlcnJlckNvbE5hbWVzCi0JCQksIFN0cmluZyByZWZlcmVuY2VkVGFibGVOYW1lLCBMaXN0PFN0cmluZz4gcmVmZXJlbmNlZENvbE5hbWVzCi0JCQksIFN0cmluZyBqb2luVGFibGVOYW1lLCBMaXN0PFN0cmluZz4gcmVmZXJyZXJKb2luQ29sTmFtZXMsIExpc3Q8U3RyaW5nPiByZWZlcmVuY2VkSm9pbkNvbE5hbWVzKSB7Ci0JCXN1cGVyKCk7Ci0JCQotCQltQ3VzdG9taXplciA9IGN1c3RvbWl6ZXI7Ci0JCW1SZWZlcnJlclRhYmxlTmFtZSA9IHJlZmVycmVyVGFibGVOYW1lOwotCQltUmVmZXJlbmNlZFRhYmxlTmFtZSA9IHJlZmVyZW5jZWRUYWJsZU5hbWU7Ci0JCW1SZWZlcnJlckNvbE5hbWVzID0gcmVmZXJyZXJDb2xOYW1lczsKLQkJbVJlZmVyZW5jZWRDb2xOYW1lcyA9IHJlZmVyZW5jZWRDb2xOYW1lczsKLQkJbUpvaW5UYWJsZU5hbWUgPSBqb2luVGFibGVOYW1lOwotCQltUmVmZXJyZXJKb2luQ29sTmFtZXMgPSByZWZlcnJlckpvaW5Db2xOYW1lczsKLQkJbVJlZmVyZW5jZWRKb2luQ29sTmFtZXMgPSByZWZlcmVuY2VkSm9pbkNvbE5hbWVzOwotCQkKLQkJbUNhcmRpbmFsaXR5ID0gTUFOWV9UT19NQU5ZOwkKLQkJbURpcmVjdGlvbmFsaXR5ID0gQklfREk7Ci0JCQotCQlzZXRDdXN0b20odHJ1ZSk7Ci0JfQotCS8qKgotCSAqIEVtcHR5IGNvbnN0cnVjdG9yIG5lZWRlZCBieSB0aGUgZGVzZXJpYWxpemF0aW9uIChzaG91bGQgbm90IGJlIHVzZWQgb3RoZXJ3aXNlKS4KLQkgKi8KLQlwdWJsaWMgQXNzb2NpYXRpb24oKSB7Ci0JfQotCS8qKgotCSAqIENvbXB1dGVzIHRoZSBjYXJkaW5hbGl0eSBiYXNlZG9uIHRoZSBmb3JpZ24ga2V5IGRlZmluaXRpb25zLgotCSAqLwotCXB1YmxpYyB2b2lkIGNvbXB1dGVDYXJkaW5hbGl0eSgpICB7Ci0JCS8qYnkgZGVmYXVsdCB0aGUgYXNzb2NpYXRpb24gaXMgbWFueS10by1vbmUgdW5sZXNzIHRoZSBmb3JlaWduIGtleSAKLQkJICogaXMgYWxzbyB0aGUgcHJpbWFyeSBrZXksIGluIHdoaWNoIGNhc2UgaXQgaXMgYSBvbmUtdG8tb25lLiovCi0JCW1DYXJkaW5hbGl0eSA9IE1BTllfVE9fT05FOwotCQkKLQkJTGlzdDxPUk1HZW5Db2x1bW4+IHJlZmVycmVyQ29scyA9IGdldFJlZmVycmVyQ29sdW1ucygpOwotCQlMaXN0PE9STUdlbkNvbHVtbj4gcGtDb2xzID0gZ2V0UmVmZXJyZXJUYWJsZSgpLmdldFByaW1hcnlLZXlDb2x1bW5zKCk7Ci0JCWlmIChwa0NvbHMuc2l6ZSgpID09IHJlZmVycmVyQ29scy5zaXplKCkpIHsKLQkJCWJvb2xlYW4gaXNGa1BrID0gdHJ1ZTsKLQkJCWZvciAoaW50IGkgPSAwLCBuID0gcGtDb2xzLnNpemUoKTsgaSA8IG47ICsraSkgewotCQkJCWlmICghKChPUk1HZW5Db2x1bW4pcGtDb2xzLmdldChpKSkuZ2V0TmFtZSgpLmVxdWFscygoKE9STUdlbkNvbHVtbilyZWZlcnJlckNvbHMuZ2V0KGkpKS5nZXROYW1lKCkpKSB7Ci0JCQkJCWlzRmtQayA9IGZhbHNlOwotCQkJCQlicmVhazsKLQkJCQl9Ci0JCQl9Ci0JCQlpZiAoaXNGa1BrKSB7Ci0JCQkJbUNhcmRpbmFsaXR5ID0gT05FX1RPX09ORTsKLQkJCX0KLQkJfQotCQkKLQkJc2V0Q3VzdG9tKGZhbHNlKTsKLQl9Ci0JLyoqCi0JICogQ2FsbGVkIGFmdGVyIHRoZSBhc3Njb2NpYXRpb25zIGFyZSBkZXNlcmlhbGl6ZWQgdG8gYXR0YWNoIAotCSAqIHRoZSBjdXN0b21pemVyIG9iamVjdC4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCByZXN0b3JlKE9STUdlbkN1c3RvbWl6ZXIgY3VzdG9taXplcikgewotCQltQ3VzdG9taXplciA9IGN1c3RvbWl6ZXI7Ci0JCQotCQlpZiAobVJlZmVycmVyUm9sZSAhPSBudWxsKSB7Ci0JCQltUmVmZXJyZXJSb2xlLnJlc3RvcmUodGhpcyk7Ci0JCX0KLQkJaWYgKG1SZWZlcmVuY2VkUm9sZSAhPSBudWxsKSB7Ci0JCQltUmVmZXJlbmNlZFJvbGUucmVzdG9yZSh0aGlzKTsKLQkJfQotCX0KLQlwdWJsaWMgT1JNR2VuVGFibGUgZ2V0UmVmZXJyZXJUYWJsZSgpICB7Ci0JCXJldHVybiBtQ3VzdG9taXplci5nZXRUYWJsZShtUmVmZXJyZXJUYWJsZU5hbWUpOwotCX0KLQlwdWJsaWMgU3RyaW5nIGdldFJlZmVycmVyVGFibGVOYW1lKCkgewotCQlyZXR1cm4gbVJlZmVycmVyVGFibGVOYW1lOwotCX0KLQlwdWJsaWMgT1JNR2VuVGFibGUgZ2V0UmVmZXJlbmNlZFRhYmxlKCkgIHsKLQkJcmV0dXJuIG1DdXN0b21pemVyLmdldFRhYmxlKG1SZWZlcmVuY2VkVGFibGVOYW1lKTsKLQl9Ci0JcHVibGljIFN0cmluZyBnZXRSZWZlcmVuY2VkVGFibGVOYW1lKCkgewotCQlyZXR1cm4gbVJlZmVyZW5jZWRUYWJsZU5hbWU7Ci0JfQotCXB1YmxpYyBPUk1HZW5UYWJsZSBnZXRKb2luVGFibGUoKSAgewotCQlyZXR1cm4gbUN1c3RvbWl6ZXIuZ2V0VGFibGUobUpvaW5UYWJsZU5hbWUpOwotCX0KLQlwdWJsaWMgU3RyaW5nIGdldEpvaW5UYWJsZU5hbWUoKSB7Ci0JCXJldHVybiBtSm9pblRhYmxlTmFtZTsKLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgPGNvZGU+T1JNR2VuQ29sdW1uPC9jb2RlPiBvYmplY3RzIGZvciB0aGUgcmVmZXJyZXIKLQkgKiBjb2x1bW5zLgotCSAqLwotCXB1YmxpYyBMaXN0PE9STUdlbkNvbHVtbj4gZ2V0UmVmZXJyZXJDb2x1bW5zKCkgewotCQlpZiAobVJlZmVycmVyQ29scyA9PSBudWxsKSB7Ci0JCQlPUk1HZW5UYWJsZSByZWZlcnJlclRhYmxlID0gZ2V0UmVmZXJyZXJUYWJsZSgpOwotCQkJbVJlZmVycmVyQ29scyA9IHJlZmVycmVyVGFibGUuZ2V0Q29sdW1uc0J5TmFtZXMobVJlZmVycmVyQ29sTmFtZXMpOwotCQl9Ci0JCXJldHVybiBtUmVmZXJyZXJDb2xzOwotCX0KLQlwdWJsaWMgTGlzdDxTdHJpbmc+IGdldFJlZmVycmVyQ29sdW1uTmFtZXMoKSB7Ci0JCXJldHVybiBtUmVmZXJyZXJDb2xOYW1lczsKLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgPGNvZGU+T1JNR2VuQ29sdW1uPC9jb2RlPiBvYmplY3RzIGZvciB0aGUgcmVmZXJlbmNlZAotCSAqIGNvbHVtbnMuCi0JICovCi0JcHVibGljIExpc3Q8T1JNR2VuQ29sdW1uPiBnZXRSZWZlcmVuY2VkQ29sdW1ucygpIHsKLQkJaWYgKG1SZWZlcmVuY2VkQ29scyA9PSBudWxsKSB7Ci0JCQltUmVmZXJlbmNlZENvbHMgPSBnZXRSZWZlcmVuY2VkVGFibGUoKS5nZXRDb2x1bW5zQnlOYW1lcyhtUmVmZXJlbmNlZENvbE5hbWVzKTsKLQkJfQotCQlyZXR1cm4gbVJlZmVyZW5jZWRDb2xzOwotCX0KLQlwdWJsaWMgTGlzdDxTdHJpbmc+IGdldFJlZmVyZW5jZWRDb2x1bW5OYW1lcygpIHsKLQkJcmV0dXJuIG1SZWZlcmVuY2VkQ29sTmFtZXM7Ci0JfQotCXB1YmxpYyBMaXN0PE9STUdlbkNvbHVtbj4gZ2V0UmVmZXJyZXJKb2luQ29sdW1ucygpIHsKLQkJaWYgKG1SZWZlcnJlckpvaW5Db2xzID09IG51bGwpIHsKLQkJCW1SZWZlcnJlckpvaW5Db2xzID0gZ2V0Sm9pblRhYmxlKCkuZ2V0Q29sdW1uc0J5TmFtZXMobVJlZmVycmVySm9pbkNvbE5hbWVzKTsKLQkJfQotCQlyZXR1cm4gbVJlZmVycmVySm9pbkNvbHM7Ci0JfQotCXB1YmxpYyBMaXN0PFN0cmluZz4gZ2V0UmVmZXJyZXJKb2luQ29sdW1uTmFtZXMoKSB7Ci0JCXJldHVybiBtUmVmZXJyZXJKb2luQ29sTmFtZXM7Ci0JfQotCXB1YmxpYyBMaXN0PE9STUdlbkNvbHVtbj4gZ2V0UmVmZXJlbmNlZEpvaW5Db2x1bW5zKCkgIHsKLQkJaWYgKG1SZWZlcmVuY2VkSm9pbkNvbHMgPT0gbnVsbCkgewotCQkJbVJlZmVyZW5jZWRKb2luQ29scyA9IGdldEpvaW5UYWJsZSgpLmdldENvbHVtbnNCeU5hbWVzKG1SZWZlcmVuY2VkSm9pbkNvbE5hbWVzKTsKLQkJfQotCQlyZXR1cm4gbVJlZmVyZW5jZWRKb2luQ29sczsKLQl9Ci0JcHVibGljIExpc3Q8U3RyaW5nPiBnZXRSZWZlcmVuY2VkSm9pbkNvbHVtbk5hbWVzKCkgewotCQlyZXR1cm4gbVJlZmVyZW5jZWRKb2luQ29sTmFtZXM7Ci0JfQotCS8qKgotCSAqIFJldHVybnMgdGhlIGFzc29jaWF0aW9uIGNhcmRpbmFsaXR5LCBvbmUgb2Yge0BsaW5rICNNQU5ZX1RPX09ORX18e0BsaW5rICNNQU5ZX1RPX01BTll9Ci0JICogfHtAbGluayAjT05FX1RPX09ORX18e0BsaW5rICNPTkVfVE9fTUFOWX0KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdldENhcmRpbmFsaXR5KCkgewotCQlyZXR1cm4gbUNhcmRpbmFsaXR5OwotCX0KLQlwdWJsaWMgdm9pZCBzZXRDYXJkaW5hbGl0eShTdHJpbmcgY2FyZGluYWxpdHkpIHsKLQkJYXNzZXJ0KGNhcmRpbmFsaXR5LmVxdWFscyhNQU5ZX1RPX09ORSkgfHwgY2FyZGluYWxpdHkuZXF1YWxzKE1BTllfVE9fTUFOWSkgfHwgY2FyZGluYWxpdHkuZXF1YWxzKE9ORV9UT19PTkUpIHx8IGNhcmRpbmFsaXR5LmVxdWFscyhPTkVfVE9fTUFOWSkpOwotCQltQ2FyZGluYWxpdHkgPSBjYXJkaW5hbGl0eTsKLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgYXNzb2NpYXRpb24gZGlyZWN0aW9uYWxpdHksIG9uZSBvZiB7QGxpbmsgI0JJX0RJfXx7QGxpbmsgI05PUk1BTF9ESX0KLQkgKiB8e0BsaW5rICNPUFBPU0lURV9ESX0KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdldERpcmVjdGlvbmFsaXR5KCkgewotCQlyZXR1cm4gbURpcmVjdGlvbmFsaXR5OwotCX0KLQlwdWJsaWMgdm9pZCBzZXREaXJlY3Rpb25hbGl0eShTdHJpbmcgZGlyKSB7Ci0JCWFzc2VydChkaXIuZXF1YWxzKEJJX0RJKSB8fCBkaXIuZXF1YWxzKE5PUk1BTF9ESSkgfHwgZGlyLmVxdWFscyhPUFBPU0lURV9ESSkpOwotCQlpZiAoIWRpci5lcXVhbHMobURpcmVjdGlvbmFsaXR5KSkgewotCQkJbURpcmVjdGlvbmFsaXR5ID0gZGlyOwotCQkJCi0JCQlpZiAoZGlyLmVxdWFscyhOT1JNQUxfREkpKSB7Ci0JCQkJbVJlZmVyZW5jZWRSb2xlID0gbnVsbDsKLQkJCX0gZWxzZSBpZiAoZGlyLmVxdWFscyhPUFBPU0lURV9ESSkpIHsKLQkJCQltUmVmZXJyZXJSb2xlID0gbnVsbDsKLQkJCX0KLQkJfQotCX0KLQkKLQkvKioKLQkgKiBUZXN0cyB3aGV0aGVyIHRoaXMgYXNzb2NpYXRpb24gaXMgYmlkaXJlY3Rpb25hbC4KLQkgKiBUaGlzIGlzIGEgc2hvcnRjdXQgZm9yIDxjb2RlPmdldERpcmVjdGlvbmFsaXR5KCkuZXF1YWxzKEJJX0RJKTwvY29kZT4uCi0JICovCi0JcHVibGljIGJvb2xlYW4gaXNCaWRpcmVjdGlvbmFsKCkgewotCQlyZXR1cm4gbURpcmVjdGlvbmFsaXR5LmVxdWFscyhCSV9ESSk7Ci0JfQotCS8qKgotCSAqIFJldHVybnMgdHJ1ZSBvZiB0aGlzIGFzc29jaWF0aW9uIHNob3VsZCBiZSBnZW5lcmF0ZWQuIAotCSAqLwotCXB1YmxpYyBib29sZWFuIGlzR2VuZXJhdGVkKCkgewotCQlyZXR1cm4gKG1GbGFncyAmIEdFTkVSQVRFRCkgIT0gMDsKLQl9Ci0JcHVibGljIHZvaWQgc2V0R2VuZXJhdGVkKGJvb2xlYW4gZ2VuZXJhdGVkKSB7Ci0JCWlmIChnZW5lcmF0ZWQgIT0gaXNHZW5lcmF0ZWQoKSkgewotCQkJaWYgKGdlbmVyYXRlZCkgewotCQkJCW1GbGFncyB8PSBHRU5FUkFURUQ7Ci0JCQl9IGVsc2UgewotCQkJCW1GbGFncyAmPSB+R0VORVJBVEVEOwotCQkJfQotCQkJbVJlZmVycmVyUm9sZSA9IG1SZWZlcmVuY2VkUm9sZSA9IG51bGw7Ci0JCX0KLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0cnVlIG9mIHRoaXMgYXNzb2NpYXRpb24gaXMgY3VzdG9tIChpLmUgaXMgbm90IGF1dG8gY29tcHV0ZWQgZnJvbSBmb3JlaWduIGtleXMgcmVsYXRpb25zaGlwcykuIAotCSAqLwotCXB1YmxpYyBib29sZWFuIGlzQ3VzdG9tKCkgewotCQlyZXR1cm4gKG1GbGFncyAmIENVU1RPTSkgIT0gMDsKLQl9Ci0JcHVibGljIHZvaWQgc2V0Q3VzdG9tKGJvb2xlYW4gY3VzdG9tKSB7Ci0JCWlmIChjdXN0b20pIHsKLQkJCW1GbGFncyB8PSBDVVNUT007Ci0JCX0gZWxzZSB7Ci0JCQltRmxhZ3MgJj0gfkNVU1RPTTsKLQkJfQotCX0KLQkvKioKLQkgKiBSZXR1cm5zIHRoZSBhc3NvY2lhdGlvbiByb2xlIGZvciB0aGUgcmVmZXJyZXIgc2lkZSwgb3IgbnVsbCAKLQkgKiBpZiBub25lIChpLmUgaWYgdGhlIGRpcmVjdGlvbmFsaXR5IGRvZXMgbm90IGluY2x1ZGUgaXQpLgotCSAqLwotCXB1YmxpYyBBc3NvY2lhdGlvblJvbGUgZ2V0UmVmZXJyZXJSb2xlKCkgewotCQlpZiAobVJlZmVycmVyUm9sZSA9PSBudWxsICYmIGlzR2VuZXJhdGVkKCkpIHsKLQkJCWlmICghZ2V0RGlyZWN0aW9uYWxpdHkoKS5lcXVhbHMoT1BQT1NJVEVfREkpKSB7IC8vQklfREkgb3IgTk9STUFMX0RJCi0JCQkJbVJlZmVycmVyUm9sZSA9IG5ldyBBc3NvY2lhdGlvblJvbGUodGhpcywgdHJ1ZS8qaXNSZWZlcnJlckVuZCovKTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gbVJlZmVycmVyUm9sZTsKLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgYXNzb2NpYXRpb24gcm9sZSBmb3IgdGhlIHJlZmVyZW5jZWQgc2lkZSwgb3IgbnVsbCAKLQkgKiBpZiBub25lIChpLmUgaWYgdGhlIGRpcmVjdGlvbmFsaXR5IGRvZXMgbm90IGluY2x1ZGUgaXQpLgotCSAqLwotCXB1YmxpYyBBc3NvY2lhdGlvblJvbGUgZ2V0UmVmZXJlbmNlZFJvbGUoKSB7Ci0JCWlmIChtUmVmZXJlbmNlZFJvbGUgPT0gbnVsbCAmJiBpc0dlbmVyYXRlZCgpKSB7Ci0JCQlpZiAoIWdldERpcmVjdGlvbmFsaXR5KCkuZXF1YWxzKEFzc29jaWF0aW9uLk5PUk1BTF9ESSkpIHsgLy9CSV9ESSBvciBPUFBPU0lURV9ESQotCQkJCW1SZWZlcmVuY2VkUm9sZSA9IG5ldyBBc3NvY2lhdGlvblJvbGUodGhpcywgZmFsc2UvKmlzUmVmZXJyZXJFbmQqLyk7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIG1SZWZlcmVuY2VkUm9sZTsKLQl9Ci0JLyoqCi0JICogVGVzdHMgd2hldGhlciB0aGlzIGFzc29jaWF0aW9uIGlzIHZhbGlkICh2YWxpZCB0YWJsZSBhbmQgY29sdW1uIG5hbWVzKS4KLQkgKi8KLQlwcm90ZWN0ZWQgYm9vbGVhbiBpc1ZhbGlkKCl7Ci0JCWlmICghaXNWYWxpZFRhYmxlQW5kQ29sdW1ucyhtUmVmZXJyZXJUYWJsZU5hbWUsIG1SZWZlcnJlckNvbE5hbWVzKQotCQkJCXx8ICFpc1ZhbGlkVGFibGVBbmRDb2x1bW5zKG1SZWZlcmVuY2VkVGFibGVOYW1lLCBtUmVmZXJlbmNlZENvbE5hbWVzKSkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCWlmIChtSm9pblRhYmxlTmFtZSAhPSBudWxsKSB7Ci0JCQlpZiAoIWlzVmFsaWRUYWJsZUFuZENvbHVtbnMobUpvaW5UYWJsZU5hbWUsIG1SZWZlcnJlckpvaW5Db2xOYW1lcykKLQkJCQkJfHwgIWlzVmFsaWRUYWJsZUFuZENvbHVtbnMobUpvaW5UYWJsZU5hbWUsIG1SZWZlcmVuY2VkSm9pbkNvbE5hbWVzKSkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0JCQkKLQkJfQotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0JcHJpdmF0ZSBib29sZWFuIGlzVmFsaWRUYWJsZUFuZENvbHVtbnMoU3RyaW5nIHRhYmxlTmFtZSwgTGlzdDxTdHJpbmc+IGNvbHVtbk5hbWVzKSB7Ci0JCU9STUdlblRhYmxlIHRhYmxlID0gbUN1c3RvbWl6ZXIuZ2V0VGFibGUodGFibGVOYW1lKTsKLQkJaWYgKHRhYmxlID09IG51bGwpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlmb3IgKGludCBpID0gMCwgbiA9IGNvbHVtbk5hbWVzLnNpemUoKTsgaSA8IG47ICsraSkgewotCQkJU3RyaW5nIGNvbE5hbWUgPSAoU3RyaW5nKWNvbHVtbk5hbWVzLmdldChpKTsKLQkJCWlmICh0YWJsZS5nZXRDb2x1bW5CeU5hbWUoY29sTmFtZSkgPT0gbnVsbCkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgc2V0Rm9yZWlnbktleShGb3JlaWduS2V5IGZvcmVpZ25LZXkpIHsKLQkJdGhpcy5tRm9yZWlnbktleSA9IGZvcmVpZ25LZXk7Ci0JCQotCX0KLQlwdWJsaWMgRm9yZWlnbktleSBnZXRGb3JlaWduS2V5KCl7Ci0JCXJldHVybiB0aGlzLm1Gb3JlaWduS2V5OwotCX07CQotCXB1YmxpYyBib29sZWFuIGVxdWFscyhPYmplY3Qgb2JqKSB7Ci0JCWlmKCB0aGlzID09IG9iaiApCi0JCQlyZXR1cm4gdHJ1ZTsKLQkJaWYoIG9iaiBpbnN0YW5jZW9mIEFzc29jaWF0aW9uICl7Ci0JCQlBc3NvY2lhdGlvbiBhc3NvY2lhdGlvbjIgPSAoQXNzb2NpYXRpb24pb2JqOwotCQkJaWYgKCF0aGlzLmdldFJlZmVycmVyVGFibGVOYW1lKCkuZXF1YWxzKGFzc29jaWF0aW9uMi5nZXRSZWZlcnJlclRhYmxlTmFtZSgpKQotCQkJCQl8fCAhdGhpcy5nZXRSZWZlcmVuY2VkVGFibGVOYW1lKCkuZXF1YWxzKGFzc29jaWF0aW9uMi5nZXRSZWZlcmVuY2VkVGFibGVOYW1lKCkpCi0JCQkJCXx8ICFTdHJpbmdVdGlsLmVxdWFsT2JqZWN0cyh0aGlzLmdldEpvaW5UYWJsZU5hbWUoKSwgYXNzb2NpYXRpb24yLmdldEpvaW5UYWJsZU5hbWUoKSkKLQkJCQkJfHwgIXRoaXMuZ2V0UmVmZXJyZXJDb2x1bW5OYW1lcygpLmVxdWFscyhhc3NvY2lhdGlvbjIuZ2V0UmVmZXJyZXJDb2x1bW5OYW1lcygpKQotCQkJCQl8fCAhdGhpcy5nZXRSZWZlcmVuY2VkQ29sdW1uTmFtZXMoKS5lcXVhbHMoYXNzb2NpYXRpb24yLmdldFJlZmVyZW5jZWRDb2x1bW5OYW1lcygpKQotCQkJCQkpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9CQkJCQkKLQkJCS8qdGhlIDIgYXNzb2NpYXRpb24gaGF2ZSB0aGUgc2FtZSByZWZlcnJlciwgcmVmZXJlbmNlZCBhbmQgam9pbiB0YWJsZSovCi0JCQkvL0lmIE1UTyBvciBPVE0gYXNzb2NpYXRpb24KLQkJCWlmICh0aGlzLmdldEpvaW5UYWJsZU5hbWUoKSA9PSBudWxsKSB7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0JCQlpZiAodGhpcy5nZXRSZWZlcnJlckpvaW5Db2x1bW5OYW1lcygpLmVxdWFscyhhc3NvY2lhdGlvbjIuZ2V0UmVmZXJyZXJKb2luQ29sdW1uTmFtZXMoKSkKLQkJCQkJJiYgdGhpcy5nZXRSZWZlcmVuY2VkSm9pbkNvbHVtbk5hbWVzKCkuZXF1YWxzKGFzc29jaWF0aW9uMi5nZXRSZWZlcmVuY2VkSm9pbkNvbHVtbk5hbWVzKCkpKSB7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0JCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpewotCQlyZXR1cm4gbVJlZmVycmVyVGFibGVOYW1lICsgIiAiICsgbUNhcmRpbmFsaXR5ICsgIiAiICsgbVJlZmVyZW5jZWRUYWJsZU5hbWUgOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL0Fzc29jaWF0aW9uUm9sZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbDIvQXNzb2NpYXRpb25Sb2xlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGUxYWFkM2UuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbDIvQXNzb2NpYXRpb25Sb2xlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyNTEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsMjsKLQotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLQotLyoqCi0gKiBSZXByZXNlbnRzIGFuIGFzc29jaWF0aW9uIHJvbGUgKHRoZSByZWZlcnJlciBvciByZWZlcmVuY2VkIHJvbGUpLgotICogCi0gKi8KLXB1YmxpYyBjbGFzcyBBc3NvY2lhdGlvblJvbGUgaW1wbGVtZW50cyBqYXZhLmlvLlNlcmlhbGl6YWJsZQotewotCXByaXZhdGUgdHJhbnNpZW50IEFzc29jaWF0aW9uIG1Bc3NvY2lhdGlvbjsgLy90cmFuc2llbnQ6IHNlZSByZXN0b3JlCi0JcHJpdmF0ZSBib29sZWFuIG1Jc1JlZmVycmVyUm9sZTsKLQlwcml2YXRlIFN0cmluZyBtUHJvcGVydHlOYW1lOwotCXByaXZhdGUgU3RyaW5nIG1DYXNjYWRlOwotCQotCXByaXZhdGUgZmluYWwgc3RhdGljIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDE7Ci0JCQotCUFzc29jaWF0aW9uUm9sZShBc3NvY2lhdGlvbiBhc3NvY2lhdGlvbiwgYm9vbGVhbiBpc1JlZmVycmVyUm9sZSkgewotCQlzdXBlcigpOwotCQkKLQkJbUFzc29jaWF0aW9uID0gYXNzb2NpYXRpb247Ci0JCW1Jc1JlZmVycmVyUm9sZSA9IGlzUmVmZXJyZXJSb2xlOwotCX0KLQkvKioKLQkgKiBFbXB0eSBjb25zdHJ1Y3RvciBuZWVkZWQgYnkgdGhlIGRlc2VyaWFsaXphdGlvbiAoc2hvdWxkIG5vdCBiZSB1c2VkIG90aGVyd2lzZSkuCi0JICovCi0JcHVibGljIEFzc29jaWF0aW9uUm9sZSgpIHsKLQl9Ci0JLyoqCi0JICogQ2FsbGVkIGFmdGVyIHRoZSBhc3Njb2NpYXRpb25zIGFyZSBkZXNlcmlhbGl6ZWQgdG8gYXR0YWNoIAotCSAqIHRoZSBjdXN0b21pemVyIG9iamVjdC4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCByZXN0b3JlKEFzc29jaWF0aW9uIGFzc29jaWF0aW9uKSB7Ci0JCW1Bc3NvY2lhdGlvbiA9IGFzc29jaWF0aW9uOwotCX0KLQlwdWJsaWMgQXNzb2NpYXRpb24gZ2V0QXNzb2NpYXRpb24oKSB7Ci0JCXJldHVybiBtQXNzb2NpYXRpb247Ci0JfQotCXB1YmxpYyBib29sZWFuIGlzUmVmZXJyZXJSb2xlKCkgewotCQlyZXR1cm4gbUlzUmVmZXJyZXJSb2xlOwotCX0KLQkvKioKLQkgKiBSZXR1cm5zIHRoZSBvcHBvc2l0ZSByb2xlIG9yIG51bGwgaWYgdGhlIGFzc29jaWF0aW9uIAotCSAqIGlzIG5vdCBiaSBkaXJlY3Rpb25hbC4KLQkgKi8KLQlwdWJsaWMgQXNzb2NpYXRpb25Sb2xlIGdldE9wcG9zaXRlUm9sZSgpIHsKLQkJQXNzb2NpYXRpb24gYXNzb2NpYXRpb24gPSBnZXRBc3NvY2lhdGlvbigpOwotCQlpZiAoIWFzc29jaWF0aW9uLmdldERpcmVjdGlvbmFsaXR5KCkuZXF1YWxzKEFzc29jaWF0aW9uLkJJX0RJKSkgewotCQkJcmV0dXJuIG51bGw7Ci0JCX0KLQkJaWYgKGlzUmVmZXJyZXJSb2xlKCkpIHsKLQkJCXJldHVybiBhc3NvY2lhdGlvbi5nZXRSZWZlcmVuY2VkUm9sZSgpOwotCQl9IGVsc2UgewotCQkJcmV0dXJuIGFzc29jaWF0aW9uLmdldFJlZmVycmVyUm9sZSgpOwotCQl9Ci0JfQotCS8qKgotCSAqIFJldHVybnMgdGhlIGFzc29jaWF0aW9uIGNhcmRpbmFsaXR5LCBvbmUgb2Yge0BsaW5rICNNQU5ZX1RPX09ORX18e0BsaW5rICNNQU5ZX1RPX01BTll9Ci0JICogfHtAbGluayAjT05FX1RPX09ORX18e0BsaW5rICNPTkVfVE9fTUFOWX0KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdldENhcmRpbmFsaXR5KCkgewotCQlTdHJpbmcgdHlwZSA9IG1Bc3NvY2lhdGlvbi5nZXRDYXJkaW5hbGl0eSgpOwotCQlpZiAoIW1Jc1JlZmVycmVyUm9sZSkgewotCQkJaWYgKHR5cGUuZXF1YWxzKEFzc29jaWF0aW9uLk9ORV9UT19NQU5ZKSkgewotCQkJCXR5cGUgPSBBc3NvY2lhdGlvbi5NQU5ZX1RPX09ORTsKLQkJCX0gZWxzZSBpZiAodHlwZS5lcXVhbHMoQXNzb2NpYXRpb24uTUFOWV9UT19PTkUpKSB7Ci0JCQkJdHlwZSA9IEFzc29jaWF0aW9uLk9ORV9UT19NQU5ZOwotCQkJfQotCQl9Ci0JCXJldHVybiB0eXBlOwotCX0KLQlwdWJsaWMgT1JNR2VuVGFibGUgZ2V0UmVmZXJyZXJUYWJsZSgpIHsKLQkJaWYgKG1Jc1JlZmVycmVyUm9sZSkgewotCQkJcmV0dXJuIG1Bc3NvY2lhdGlvbi5nZXRSZWZlcnJlclRhYmxlKCk7Ci0JCX0gZWxzZSB7Ci0JCQlyZXR1cm4gbUFzc29jaWF0aW9uLmdldFJlZmVyZW5jZWRUYWJsZSgpOwotCQl9Ci0JfQotCXB1YmxpYyBMaXN0PE9STUdlbkNvbHVtbj4gZ2V0UmVmZXJyZXJDb2x1bW5zKCl7Ci0JCWlmIChtSXNSZWZlcnJlclJvbGUpIHsKLQkJCXJldHVybiBtQXNzb2NpYXRpb24uZ2V0UmVmZXJyZXJDb2x1bW5zKCk7Ci0JCX0gZWxzZSB7Ci0JCQlyZXR1cm4gbUFzc29jaWF0aW9uLmdldFJlZmVyZW5jZWRDb2x1bW5zKCk7Ci0JCX0KLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgcmVmZXJlbmNlZCBjb2x1bW4gY29ycmVzcG9uZGluZyB0byBhIHJlZmVycmVyIGNvbHVtbi4KLQkgKi8KLQlwdWJsaWMgT1JNR2VuQ29sdW1uIGdldFJlZmVyZW5jZWRDb2x1bW4oU3RyaW5nIHJlZmVycmVyQ29sdW1uKSAgewotCQlib29sZWFuIGhhc0pvaW5UYWJsZSA9IG1Bc3NvY2lhdGlvbi5nZXRKb2luVGFibGUoKSAhPSBudWxsOwotCQlMaXN0PE9STUdlbkNvbHVtbj4gcmVmZXJyZXJDb2x1bW5zID0gZ2V0UmVmZXJyZXJDb2x1bW5zKCk7Ci0JCWZvciAoaW50IGkgPSAwLCBuID0gcmVmZXJyZXJDb2x1bW5zLnNpemUoKTsgaSA8IG47ICsraSkgewotCQkJT1JNR2VuQ29sdW1uIGNvbHVtbiA9IChPUk1HZW5Db2x1bW4pcmVmZXJyZXJDb2x1bW5zLmdldChpKTsKLQkJCWlmIChjb2x1bW4uZ2V0TmFtZSgpLmVxdWFscyhyZWZlcnJlckNvbHVtbikpIHsKLQkJCQlpZiAoaGFzSm9pblRhYmxlKSB7Ci0JCQkJCXJldHVybiAoT1JNR2VuQ29sdW1uKWdldFJlZmVycmVySm9pbkNvbHVtbnMoKS5nZXQoaSk7Ci0JCQkJfSBlbHNlIHsKLQkJCQkJcmV0dXJuIChPUk1HZW5Db2x1bW4pZ2V0UmVmZXJlbmNlZENvbHVtbnMoKS5nZXQoaSk7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWFzc2VydChmYWxzZSk7Ci0JCXJldHVybiBudWxsOwotCX0KLQkvKioKLQkgKiBSZXR1cm5zIHRoZSByZWZlcnJlciBjb2x1bW4gY29ycmVzcG9uZGluZyB0byBhIHJlZmVyZW5jZWQgY29sdW1uLgotCSAqLwotCXB1YmxpYyBPUk1HZW5Db2x1bW4gZ2V0UmVmZXJyZXJDb2x1bW4oU3RyaW5nIHJlZmVyZW5jZWRDb2x1bW4pICB7Ci0JCWJvb2xlYW4gaGFzSm9pblRhYmxlID0gbUFzc29jaWF0aW9uLmdldEpvaW5UYWJsZSgpICE9IG51bGw7Ci0JCUxpc3Q8T1JNR2VuQ29sdW1uPiByZWZlcmVuY2VkQ29sdW1ucyA9IGdldFJlZmVyZW5jZWRDb2x1bW5zKCk7Ci0JCWZvciAoaW50IGkgPSAwLCBuID0gcmVmZXJlbmNlZENvbHVtbnMuc2l6ZSgpOyBpIDwgbjsgKytpKSB7Ci0JCQlPUk1HZW5Db2x1bW4gY29sdW1uID0gKE9STUdlbkNvbHVtbilyZWZlcmVuY2VkQ29sdW1ucy5nZXQoaSk7Ci0JCQlpZiAoY29sdW1uLmdldE5hbWUoKS5lcXVhbHMocmVmZXJlbmNlZENvbHVtbikpIHsKLQkJCQlpZiAoaGFzSm9pblRhYmxlKSB7Ci0JCQkJCXJldHVybiAoT1JNR2VuQ29sdW1uKWdldFJlZmVyZW5jZWRKb2luQ29sdW1ucygpLmdldChpKTsKLQkJCQl9IGVsc2UgewotCQkJCQlyZXR1cm4gKE9STUdlbkNvbHVtbilnZXRSZWZlcnJlckNvbHVtbnMoKS5nZXQoaSk7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWFzc2VydChmYWxzZSk7Ci0JCXJldHVybiBudWxsOwotCX0KLQlwdWJsaWMgT1JNR2VuVGFibGUgZ2V0UmVmZXJlbmNlZFRhYmxlKCkgIHsKLQkJaWYgKG1Jc1JlZmVycmVyUm9sZSkgewotCQkJcmV0dXJuIG1Bc3NvY2lhdGlvbi5nZXRSZWZlcmVuY2VkVGFibGUoKTsKLQkJfSBlbHNlIHsKLQkJCXJldHVybiBtQXNzb2NpYXRpb24uZ2V0UmVmZXJyZXJUYWJsZSgpOwotCQl9Ci0JfQotCXB1YmxpYyBMaXN0PE9STUdlbkNvbHVtbj4gZ2V0UmVmZXJlbmNlZENvbHVtbnMoKSAgewotCQlpZiAobUlzUmVmZXJyZXJSb2xlKSB7Ci0JCQlyZXR1cm4gbUFzc29jaWF0aW9uLmdldFJlZmVyZW5jZWRDb2x1bW5zKCk7Ci0JCX0gZWxzZSB7Ci0JCQlyZXR1cm4gbUFzc29jaWF0aW9uLmdldFJlZmVycmVyQ29sdW1ucygpOwotCQl9Ci0JfQotCXB1YmxpYyBMaXN0PE9STUdlbkNvbHVtbj4gZ2V0UmVmZXJyZXJKb2luQ29sdW1ucygpICB7Ci0JCWlmIChtSXNSZWZlcnJlclJvbGUpIHsKLQkJCXJldHVybiBtQXNzb2NpYXRpb24uZ2V0UmVmZXJyZXJKb2luQ29sdW1ucygpOwotCQl9IGVsc2UgewotCQkJcmV0dXJuIG1Bc3NvY2lhdGlvbi5nZXRSZWZlcmVuY2VkSm9pbkNvbHVtbnMoKTsKLQkJfQotCX0KLQlwdWJsaWMgTGlzdDxPUk1HZW5Db2x1bW4+IGdldFJlZmVyZW5jZWRKb2luQ29sdW1ucygpICB7Ci0JCWlmIChtSXNSZWZlcnJlclJvbGUpIHsKLQkJCXJldHVybiBtQXNzb2NpYXRpb24uZ2V0UmVmZXJlbmNlZEpvaW5Db2x1bW5zKCk7Ci0JCX0gZWxzZSB7Ci0JCQlyZXR1cm4gbUFzc29jaWF0aW9uLmdldFJlZmVycmVySm9pbkNvbHVtbnMoKTsKLQkJfQotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm5zIHRoZSBuYW1lIHRoYXQgc2hvdWxkIGJlIHVzZWQgYnkgdGhlIGdlbmVyYXRvciBmb3IgCi0JICogdGhlIHByb3BlcnR5IGNvcnJlc3BvbmRpbmcgdG8gdGhpcyByb2xlLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0UHJvcGVydHlOYW1lKCkgICB7Ci0JCWlmIChtUHJvcGVydHlOYW1lICE9IG51bGwpIHsgLy9pZiB0aGUgdXNlciBleHBsaWNpdGx5IHNldCBpdCB0aGVuIGRvbid0IGJlIHRvbyBzbWFydAotCQkJcmV0dXJuIG1Qcm9wZXJ0eU5hbWU7Ci0JCX0KLQkJU3RyaW5nIHByb3BOYW1lID0iIjsKLQkJT1JNR2VuVGFibGUgcmVmZXJyZXJUYWJsZSA9IGdldFJlZmVycmVyVGFibGUoKTsKLQkJT1JNR2VuVGFibGUgcmVmZXJlbmNlZFRhYmxlID0gZ2V0UmVmZXJlbmNlZFRhYmxlKCk7Ci0KLQkJYm9vbGVhbiBpc1Npbmd1bGFyID0gaXNTaW5ndWxhcigpOwotCQlwcm9wTmFtZSA9IHJlZmVyZW5jZWRUYWJsZS5nZXRWYXJOYW1lKGlzU2luZ3VsYXIpOwotCQkKLQkJTGlzdDxBc3NvY2lhdGlvblJvbGU+IGNsYXNoaW5nUm9sZXMgPSBuZXcgamF2YS51dGlsLkFycmF5TGlzdDxBc3NvY2lhdGlvblJvbGU+KCk7IC8vcm9sZXMgd2l0aCBvdXIgc2FtZSByZWZlcnJlciBhbmQgcmVmZXJlbmNlZCB0YWJsZXMgKGkuZSB3b3VsZCB5aWVsZCB0aGUgc2FtZSBwcm9wZXJ0eSBuYW1lIGluIHRoZSBzYW1lIGJlYW4pCi0JCS8qbWFrZSBzdXJlIHRoZXJlIGlzIG5vIHJvbGUgd2l0aCB0aGUgc2FtZSBuYW1lLiovCi0JCWZvciAoSXRlcmF0b3I8QXNzb2NpYXRpb25Sb2xlPiBpdGVyID0gcmVmZXJyZXJUYWJsZS5nZXRBc3NvY2lhdGlvblJvbGVzKCkuaXRlcmF0b3IoKTsgaXRlci5oYXNOZXh0KCk7ICkgewotCQkJQXNzb2NpYXRpb25Sb2xlIHJvbGUgPSAoQXNzb2NpYXRpb25Sb2xlKWl0ZXIubmV4dCgpOwotCQkJaWYgKHJvbGUuZ2V0UmVmZXJyZXJUYWJsZSgpLmdldE5hbWUoKS5lcXVhbHMocmVmZXJyZXJUYWJsZS5nZXROYW1lKCkpCi0JCQkJCSYmIHJvbGUuZ2V0UmVmZXJlbmNlZFRhYmxlKCkuZ2V0TmFtZSgpLmVxdWFscyhyZWZlcmVuY2VkVGFibGUuZ2V0TmFtZSgpKQotCQkJCQkmJiByb2xlLmlzU2luZ3VsYXIoKSA9PSBpc1Npbmd1bGFyKSB7Ci0JCQkJY2xhc2hpbmdSb2xlcy5hZGQocm9sZSk7Ci0JCQl9Ci0JCX0KLQkJaWYgKGNsYXNoaW5nUm9sZXMuc2l6ZSgpID4gMSkgewotCQkJaW50IGluZGV4ID0gY2xhc2hpbmdSb2xlcy5pbmRleE9mKHRoaXMpOwotCQkJYXNzZXJ0KGluZGV4ID49IDApOwotCQkJcHJvcE5hbWUgKz0gaW5kZXgrMTsKLQkJfQotCQkKLQkJLyptYWtlIHN1cmUgdGhlcmUgaXMgbm8gY29sdW1uIHdpdGggdGhlIHNhbWUgbmFtZS4qLwotCQlmb3IgKEl0ZXJhdG9yPE9STUdlbkNvbHVtbj4gaXRlciA9IHJlZmVycmVyVGFibGUuZ2V0Q29sdW1ucygpLml0ZXJhdG9yKCk7IGl0ZXIuaGFzTmV4dCgpOyApIHsKLQkJCU9STUdlbkNvbHVtbiBjb2x1bW4gPSAoT1JNR2VuQ29sdW1uKWl0ZXIubmV4dCgpOwotCQkJaWYgKGNvbHVtbi5nZXRQcm9wZXJ0eU5hbWUoKS5lcXVhbHMocHJvcE5hbWUpKSB7Ci0JCQkJU3RyaW5nIHByZWZpeCA9IGlzU2luZ3VsYXIgPyAiQmVhbiIgOiAiU2V0IjsKLQkJCQlwcm9wTmFtZSArPSBwcmVmaXg7Ci0JCQkJYnJlYWs7Ci0JCQl9Ci0JCX0KLQkJCi0JCXJldHVybiBwcm9wTmFtZTsKLQl9Ci0JcHJpdmF0ZSBib29sZWFuIGlzU2luZ3VsYXIoKSB7Ci0JCVN0cmluZyBjYXJkaW5hbGl0eSA9IGdldENhcmRpbmFsaXR5KCk7Ci0JCXJldHVybiBjYXJkaW5hbGl0eS5lcXVhbHMoQXNzb2NpYXRpb24uT05FX1RPX09ORSkgfHwgY2FyZGluYWxpdHkuZXF1YWxzKEFzc29jaWF0aW9uLk1BTllfVE9fT05FKTsKLQl9Ci0JLyoqCi0JICogQ2hhbmdlcyB0aGUgbmFtZSB0aGF0IHNob3VsZCBiZSB1c2VkIGJ5IHRoZSBnZW5lcmF0b3IgZm9yIAotCSAqIHRoZSBwcm9wZXJ0eSBjb3JyZXNwb25kaW5nIHRvIHRoaXMgcm9sZS4KLQkgKiBJZiB0aGUgYXJndW1lbnQgbmFtZSBpcyBudWxsIG9yIGVtcHR5IHN0cmluZyB0aGVuIHRoZSAKLQkgKiBkZWZhdWx0IGNvbXB1dGVkIG5hbWUgaXMgdXNlZC4KLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRQcm9wZXJ0eU5hbWUoU3RyaW5nIG5hbWUpICB7Ci0JCWlmIChuYW1lICE9IG51bGwgJiYgbmFtZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQluYW1lID0gbnVsbDsKLQkJfQotCQlpZiAobmFtZSAhPSBudWxsICYmIG5hbWUuZXF1YWxzKGdldFByb3BlcnR5TmFtZSgpKSkgewotCQkJbmFtZSA9IG51bGw7Ci0JCX0KLQkJbVByb3BlcnR5TmFtZSA9IG5hbWU7Ci0JfQotCS8qKgotCSAqIFJldHVybnMgdGhlIGNhc2NhZGUgdmFsdWUgZm9yIHRoaXMgcm9sZSwgb3IgbnVsbCBpZiBub25lLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0Q2FzY2FkZSgpIHsKLQkJcmV0dXJuIG1DYXNjYWRlOwotCX0KLQlwdWJsaWMgdm9pZCBzZXRDYXNjYWRlKFN0cmluZyBjYXNjYWRlKSB7Ci0JCWlmIChjYXNjYWRlICE9IG51bGwgJiYgY2FzY2FkZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQljYXNjYWRlID0gbnVsbDsKLQkJfQotCQltQ2FzY2FkZSA9IGNhc2NhZGU7Ci0JfQotCS8qKgotCSAqIFJldHVybnMgYSBkZXNjcmlwdGl2ZSBzdHJpbmcgdXNlZCBpbiBhIGNvbW1lbnQgaW4gdGhlIGdlbmVyYXRlZCAKLQkgKiBmaWxlIChmcm9tIHRoZSBWZWxvY2l0eSB0ZW1wbGF0ZSkuCi0JICovCi0JcHVibGljIFN0cmluZyBnZXREZXNjcmlwdGlvbigpICB7Ci0JCS8vPCEtLSAkZGlyZWN0aW9uYWxpdHkgJGNhcmRpbmFsaXR5IGFzc29jaWF0aW9uIHRvICRyZWZlcmVuY2VkQ2xhc3NOYW1lIC0tPgotCQlTdHJpbmcgZGlyZWN0aW9uYWxpdHk7Ci0JCWlmIChnZXRBc3NvY2lhdGlvbigpLmdldERpcmVjdGlvbmFsaXR5KCkuZXF1YWxzKEFzc29jaWF0aW9uLkJJX0RJKSkgewotCQkJZGlyZWN0aW9uYWxpdHkgPSAiYmktZGlyZWN0aW9uYWwiOwotCQl9IGVsc2UgewotCQkJZGlyZWN0aW9uYWxpdHkgPSAidW5pLWRpcmVjdGlvbmFsIjsKLQkJfQotCQlyZXR1cm4gZGlyZWN0aW9uYWxpdHkgKyAiICIgKyBnZXRBc3NvY2lhdGlvbigpLmdldENhcmRpbmFsaXR5KCkgKyAiIGFzc29jaWF0aW9uIHRvICIgKyBnZXRSZWZlcmVuY2VkVGFibGUoKS5nZXRDbGFzc05hbWUoKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9CYXNlRW50aXR5R2VuQ3VzdG9taXplci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbDIvQmFzZUVudGl0eUdlbkN1c3RvbWl6ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzc3MDFiZC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9CYXNlRW50aXR5R2VuQ3VzdG9taXplci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjI5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDI7Ci0KLWltcG9ydCBqYXZhLmlvLkZpbGU7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLlNldDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuQ29sdW1uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5TY2hlbWE7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDIudXRpbC5EVFBVdGlsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5nZW4uaW50ZXJuYWwyLnV0aWwuU3RyaW5nVXRpbDsKLQotLyoqCi0gKiBEZWZhdWx0IGltcGxlbWVudGF0aW9uIG9mIE9STUdlbkN1c3RvbWl6ZXIgYWNjb3JkaW5nIHRvIEpQQSBzcGVjaWZpY2F0aW9uIGZvcgotICogZW50aXR5IGdlbmVyYXRpb24uCi0gKiAKLSAqIFRoaXMgaXMgdXNlZCB0byByZXRyaWV2ZS9jaGFuZ2UgdGhlIHByb3BlcnRpZXMgZnJvbSB0aGUgd2l6YXJkIGFuZCBpcyBhbHNvCi0gKiBwYXNzZWQgYXMgYSBjb250ZXh0IG9iamVjdCB0byBWZWxvY2l0eS4KLSAqLwotcHVibGljIGNsYXNzIEJhc2VFbnRpdHlHZW5DdXN0b21pemVyIGV4dGVuZHMgT1JNR2VuQ3VzdG9taXplcgotCWltcGxlbWVudHMgamF2YS5pby5TZXJpYWxpemFibGUKLXsKLQlwcml2YXRlIGZpbmFsIHN0YXRpYyBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxOwotCi0JLyogbWFwcGluZyBraW5kcyAqLwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBCQVNJQ19NQVBQSU5HX0tJTkQgPSAiYmFzaWMiOyAvLyROT04tTkxTLTEkCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIElEX01BUFBJTkdfS0lORCA9ICJpZCI7IC8vJE5PTi1OTFMtMSQKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgVkVSU0lPTl9NQVBQSU5HX0tJTkQgPSAidmVyc2lvbiI7IC8vJE5PTi1OTFMtMSQKLQotCS8qCi0JICogdGhlIHN0cmluZ3MgZm9yIGdlbmVyYXRvciBuYW1lcy4gVGhlc2UgYXBwZWFyIGluIGEgY29tYm8gYm94IGFuZCB1c2VkIGJ5Ci0JICogdGhlIFZlbG9jaXR5IHRlbXBsYXRlIHByb2Nlc3NpbmcuCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEFVVE9fR0VORVJBVE9SID0gImF1dG8iOyAvLyROT04tTkxTLTEkCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIE5PTkVfR0VORVJBVE9SID0gIm5vbmUiOyAvLyROT04tTkxTLTEkCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIElERU5USVRZX0dFTkVSQVRPUiA9ICJpZGVudGl0eSI7IC8vJE5PTi1OTFMtMSQKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgU0VRVUVOQ0VfR0VORVJBVE9SID0gInNlcXVlbmNlIjsgLy8kTk9OLU5MUy0xJAotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBUQUJMRV9HRU5FUkFUT1IgPSAidGFibGUiOyAvLyROT04tTkxTLTEkCi0KLQlwdWJsaWMgQmFzZUVudGl0eUdlbkN1c3RvbWl6ZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgaW5pdChGaWxlIGZpbGUsIFNjaGVtYSBzY2hlbWEpIHsKLQkJc3VwZXIuaW5pdChmaWxlLCBzY2hlbWEpOwotCX0KLQotCS8vIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0JLy8gLS0tLS0tIE9STUdlbkN1c3RvbWl6ZXIgbWV0aG9kcwotCS8vIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0JQE92ZXJyaWRlCi0JcHVibGljIExpc3Q8U3RyaW5nPiBnZXRBbGxJZEdlbmVyYXRvcnMoKSB7Ci0JCUxpc3Q8U3RyaW5nPiByZXN1bHQgPSBuZXcgamF2YS51dGlsLkFycmF5TGlzdDxTdHJpbmc+KDUpOwotCQkvKiBhZGQgaW4gdGhlIG9yZGVyIGluIHdoaWNoIHRoZXkgd291bGQgYXBwZWFyIGluIHRoZSBjb21ibyAqLwotCQlyZXN1bHQuYWRkKEFVVE9fR0VORVJBVE9SKTsKLQkJcmVzdWx0LmFkZChJREVOVElUWV9HRU5FUkFUT1IpOwotCQlyZXN1bHQuYWRkKFNFUVVFTkNFX0dFTkVSQVRPUik7Ci0JCXJlc3VsdC5hZGQoVEFCTEVfR0VORVJBVE9SKTsKLQkJcmVzdWx0LmFkZChOT05FX0dFTkVSQVRPUik7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyBnZXROb0lkR2VuZXJhdG9yKCkgewotCQlyZXR1cm4gTk9ORV9HRU5FUkFUT1I7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyBnZXRJZGVudGl0eUlkR2VuZXJhdG9yKCkgewotCQlyZXR1cm4gSURFTlRJVFlfR0VORVJBVE9SOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTZXQ8U3RyaW5nPiBnZXRTZXF1ZW5jZUlkR2VuZXJhdG9ycygpIHsKLQkJU2V0PFN0cmluZz4gcmVzdWx0ID0gbmV3IGphdmEudXRpbC5IYXNoU2V0PFN0cmluZz4oMyk7Ci0JCXJlc3VsdC5hZGQoU0VRVUVOQ0VfR0VORVJBVE9SKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIGdldFByb3BlcnR5VHlwZUZyb21Db2x1bW4oQ29sdW1uIGNvbHVtbikgewotCQlyZXR1cm4gRFRQVXRpbC5nZXRKYXZhVHlwZShnZXRTY2hlbWEoKSwgY29sdW1uKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlAU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLQlwdWJsaWMgU3RyaW5nW10gZ2V0QWxsUHJvcGVydHlUeXBlcygpIHsKLQkJLyoKLQkJICogSmF2YSBwcmltaXRpdmUgdHlwZXMsIHdyYXBwZXIgb2YgdGhlIHByaW1pdGl2ZSB0eXBlcyAsCi0JCSAqIGphdmEubGFuZy5TdHJpbmcsIGphdmEubWF0aC5CaWdJbnRlZ2VyLCBqYXZhLm1hdGguQmlnRGVjaW1hbCwKLQkJICogamF2YS51dGlsLkRhdGUsIGphdmEudXRpbC5DYWxlbmRhciwgamF2YS5zcWwuRGF0ZSwgamF2YS5zcWwuVGltZSwKLQkJICogamF2YS5zcWwuVGltZXN0YW1wLCBieXRlW10sIEJ5dGVbXSwgY2hhcltdLCBDaGFyYWN0ZXJbXSwgZW51bXMsIGFuZAotCQkgKiBhbnkgb3RoZXIgdHlwZSB0aGF0IGltcGxlbWVudHMgU2VyaWFsaXphYmxlLgotCQkgKi8KLQkJLy8gcmV0dXJuIGluIHRoZSBvcmRlciB0aGF0IHdpbGwgYmUgdXNlZCBpbiB0aGUgY29tYm8KLQkJcmV0dXJuIG5ldyBTdHJpbmdbXSB7Ci0JCQkiYm9vbGVhbiIsCi0JCQkiQm9vbGVhbiIsCi0JCQkiYnl0ZSIsCi0JCQkiQnl0ZSIsCi0JCQkiYnl0ZVtdIiwKLQkJCSJjaGFyIiwKLQkJCSJjaGFyW10iLAotCQkJIkNoYXJhY3RlciIsCi0JCQkiQ2hhcmFjdGVyW10iLAotCQkJImRvdWJsZSIsCi0JCQkiRG91YmxlIiwKLQkJCSJmbG9hdCIsCi0JCQkiRmxvYXQiLAotCQkJImludCIsCi0JCQkiSW50ZWdlciIsCi0JCQkibG9uZyIsCi0JCQkiTG9uZyIsCi0JCQkiT2JqZWN0IiwKLQkJCSJzaG9ydCIsCi0JCQkiU2hvcnQiLAotCQkJIlN0cmluZyIsCi0JCQlqYXZhLm1hdGguQmlnRGVjaW1hbC5jbGFzcy5nZXROYW1lKCksCi0JCQlqYXZhLm1hdGguQmlnSW50ZWdlci5jbGFzcy5nZXROYW1lKCksCi0JCQlqYXZhLnV0aWwuQ2FsZW5kYXIuY2xhc3MuZ2V0TmFtZSgpLAotCQkJamF2YS51dGlsLkRhdGUuY2xhc3MuZ2V0TmFtZSgpLAotCQkJamF2YS5zcWwuRGF0ZS5jbGFzcy5nZXROYW1lKCksCi0JCQlqYXZhLnNxbC5UaW1lLmNsYXNzLmdldE5hbWUoKSwKLQkJCWphdmEuc3FsLlRpbWVzdGFtcC5jbGFzcy5nZXROYW1lKCkKLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nW10gZ2V0QWxsTWFwcGluZ0tpbmRzKCkgewotCQlyZXR1cm4gbmV3IFN0cmluZ1tdIHsKLQkJCUJBU0lDX01BUFBJTkdfS0lORCwgSURfTUFQUElOR19LSU5ELCBWRVJTSU9OX01BUFBJTkdfS0lORAotCQl9OwotCX0KLQotCS8qCi0JICogKG5vbi1KYXZhZG9jKQotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgZ2V0QmFzaWNNYXBwaW5nS2luZCgpIHsKLQkJcmV0dXJuIEJBU0lDX01BUFBJTkdfS0lORDsKLQl9Ci0KLQkvKgotCSAqIChub24tSmF2YWRvYykKLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIGdldElkTWFwcGluZ0tpbmQoKSB7Ci0JCXJldHVybiBJRF9NQVBQSU5HX0tJTkQ7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIGJvb2xlYW4gZWRpdENhc2NhZGUoQXNzb2NpYXRpb25Sb2xlIHJvbGUpIHsKLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBib29sZWFuIG1hbnlTaWRlSXNBc3NvY2lhdGlvbk93bmVyKCkgewotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQkvLyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotCS8vIC0tLS0gVmVsb2NpdHkgdGVtcGxhdGVzIG1ldGhvZHMKLQkvLyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotCS8qKgotCSAqIFJldHVybnMgdGhlIGNhc2NhZGVzIGFubm90YXRpb24gbWVtYmVyIHZhbHVlLCBvciBlbXB0eSBzdHJpbmcgaWYgbm9uZS4KLQkgKiBFbXB0eSBzdHJpbmcgaXMgcmV0dXJuZWQgaW5zdGVhZCBvZiBudWxsIGJlY2F1c2UgVmVsb2NpdHkgZG9lcyBub3QgbGlrZQotCSAqIG51bGwgd2hlbiB1c2VkIGluICNzZXQuCi0JICovCi0JcHVibGljIFN0cmluZyBnZW5DYXNjYWRlcyhBc3NvY2lhdGlvblJvbGUgcm9sZSkgewotCQlMaXN0PFN0cmluZz4gY2FzY2FkZXMgPSBTdHJpbmdVdGlsLnN0clRvTGlzdChyb2xlLmdldENhc2NhZGUoKSwgJywnLCB0cnVlLyogdHJpbSAqLyk7Ci0JCWlmIChjYXNjYWRlcyA9PSBudWxsKSB7Ci0JCQlyZXR1cm4gIiI7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQlTdHJpbmdCdWZmZXIgYnVmZmVyID0gbmV3IFN0cmluZ0J1ZmZlcigneycpOwotCQlmb3IgKGludCBpID0gMCwgbiA9IGNhc2NhZGVzLnNpemUoKTsgaSA8IG47ICsraSkgewotCQkJU3RyaW5nIGNhc2NhZGUgPSBjYXNjYWRlcy5nZXQoaSk7Ci0JCQlTdHJpbmcgZW51bVN0cjsKLQkJCWlmIChjYXNjYWRlLmVxdWFscyhUYWdOYW1lcy5BTExfQ0FTQ0FERSkpIHsKLQkJCQllbnVtU3RyID0gIkNhc2NhZGVUeXBlLkFMTCI7IC8vJE5PTi1OTFMtMSQKLQkJCX0KLQkJCWVsc2UgaWYgKGNhc2NhZGUuZXF1YWxzKFRhZ05hbWVzLlBFUlNJU1RfQ0FTQ0FERSkpIHsKLQkJCQllbnVtU3RyID0gIkNhc2NhZGVUeXBlLlBFUlNJU1QiOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCQllbHNlIGlmIChjYXNjYWRlLmVxdWFscyhUYWdOYW1lcy5NRVJHRV9DQVNDQURFKSkgewotCQkJCWVudW1TdHIgPSAiQ2FzY2FkZVR5cGUuTUVSR0UiOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCQllbHNlIGlmIChjYXNjYWRlLmVxdWFscyhUYWdOYW1lcy5SRU1PVkVfQ0FTQ0FERSkpIHsKLQkJCQllbnVtU3RyID0gIkNhc2NhZGVUeXBlLlJFTU9WRSI7IC8vJE5PTi1OTFMtMSQKLQkJCX0KLQkJCWVsc2UgewotCQkJCWFzc2VydCAoY2FzY2FkZS5lcXVhbHMoVGFnTmFtZXMuUkVGUkVTSF9DQVNDQURFKSk7Ci0JCQkJZW51bVN0ciA9ICJDYXNjYWRlVHlwZS5SRUZSRVNIIjsgLy8kTk9OLU5MUy0xJAotCQkJfQotCQkJaWYgKGkgIT0gMCkgewotCQkJCWJ1ZmZlci5hcHBlbmQoIiwgIik7IC8vJE5PTi1OTFMtMSQKLQkJCX0KLQkJCWJ1ZmZlci5hcHBlbmQoZW51bVN0cik7Ci0JCX0KLQkJYnVmZmVyLmFwcGVuZCgnfScpOwotCQlyZXR1cm4gYnVmZmVyLnRvU3RyaW5nKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0aGUgZmV0Y2ggdHlwZSBhbm5vdGF0aW9uIG1lbWJlciB2YWx1ZSwgb3IgZW1wdHkgc3RyaW5nIGlmIG5vbmUuCi0JICogRW1wdHkgc3RyaW5nIGlzIHJldHVybmVkIGluc3RlYWQgb2YgbnVsbCBiZWNhdXNlIFZlbG9jaXR5IGRvZXMgbm90IGxpa2UKLQkgKiBudWxsIHdoZW4gdXNlZCBpbiAjc2V0LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgZ2VuRmV0Y2goT1JNR2VuVGFibGUgdGFibGUpIHsKLQkJU3RyaW5nIGZldGNoID0gdGFibGUuZ2V0RGVmYXVsdEZldGNoKCk7Ci0JCWlmIChmZXRjaCA9PSBudWxsIHx8IE9STUdlblRhYmxlLkRFRkFVTFRfRkVUQ0guZXF1YWxzKGZldGNoKSkgewotCQkJcmV0dXJuICIiOyAvLyROT04tTkxTLTEkCi0JCX0KLQkJZWxzZSBpZiAoZmV0Y2guZXF1YWxzKE9STUdlblRhYmxlLkxBWllfRkVUQ0gpKSB7Ci0JCQlyZXR1cm4gIkZldGNoVHlwZS5MQVpZIjsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCWVsc2UgewotCQkJcmV0dXJuICJGZXRjaFR5cGUuRUFHRVIiOyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9EYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbDIvRGF0YWJhc2VBbm5vdGF0aW9uTmFtZUJ1aWxkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmZiNzBjZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9EYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTA1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDI7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuQ29sdW1uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5Gb3JlaWduS2V5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5UYWJsZTsKLQotCi0vKioKLSAqIFByb3ZpZGUgYSBwbHVnZ2FibGUgd2F5IHRvIGRldGVybWluZSB3aGV0aGVyIGFuZCBob3cgdGhlIGVudGl0eSBnZW5lcmF0b3IKLSAqIHByaW50cyB0aGUgbmFtZXMgb2YgdmFyaW91cyBkYXRhYmFzZSBvYmplY3RzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyIHsKLQotCS8qKgotCSAqIEdpdmVuIHRoZSBuYW1lIG9mIGFuIGVudGl0eSBhbmQgdGhlIHRhYmxlIHRvIHdoaWNoIGl0IGlzIG1hcHBlZCwKLQkgKiBidWlsZCBhbmQgcmV0dXJuIGEgc3RyaW5nIHRvIGJlIHVzZWQgYXMgdGhlIHZhbHVlIGZvciB0aGUgZW50aXR5J3MKLQkgKiBUYWJsZSBhbm5vdGF0aW9uJ3MgJ25hbWUnIGVsZW1lbnQuIFJldHVybiBudWxsIGlmIHRoZSBlbnRpdHkKLQkgKiBtYXBzIHRvIHRoZSB0YWJsZSBieSBkZWZhdWx0LgotCSAqLwotCVN0cmluZyBidWlsZFRhYmxlQW5ub3RhdGlvbk5hbWUoU3RyaW5nIGVudGl0eU5hbWUsIFRhYmxlIHRhYmxlKTsKLQotCS8qKgotCSAqIEdpdmVuIHRoZSBuYW1lIG9mIGFuIGF0dHJpYnV0ZSAoZmllbGQgb3IgcHJvcGVydHkpIGFuZCB0aGUgY29sdW1uCi0JICogdG8gd2hpY2ggaXQgaXMgbWFwcGVkLAotCSAqIGJ1aWxkIGFuZCByZXR1cm4gYSBzdHJpbmcgdG8gYmUgdXNlZCBhcyB0aGUgdmFsdWUgZm9yIHRoZSBhdHRyaWJ1dGUncwotCSAqIENvbHVtbiBhbm5vdGF0aW9uJ3MgJ25hbWUnIGVsZW1lbnQuIFJldHVybiBudWxsIGlmIHRoZSBhdHRyaWJ1dGUKLQkgKiBtYXBzIHRvIHRoZSBjb2x1bW4gYnkgZGVmYXVsdC4KLQkgKi8KLQlTdHJpbmcgYnVpbGRDb2x1bW5Bbm5vdGF0aW9uTmFtZShTdHJpbmcgYXR0cmlidXRlTmFtZSwgQ29sdW1uIGNvbHVtbik7Ci0KLQkvKioKLQkgKiBHaXZlbiB0aGUgbmFtZSBvZiBhbiBhdHRyaWJ1dGUgKGZpZWxkIG9yIHByb3BlcnR5KSBhbmQgdGhlCi0JICogbWFueS10by1vbmUgb3IgbWFueS10by1tYW55IGZvcmVpZ24ga2V5IHRvIHdoaWNoIGl0IGlzIG1hcHBlZCwKLQkgKiBidWlsZCBhbmQgcmV0dXJuIGEgc3RyaW5nIHRvIGJlIHVzZWQgYXMgdGhlIHZhbHVlIGZvciB0aGUgYXR0cmlidXRlJ3MKLQkgKiBKb2luQ29sdW1uIGFubm90YXRpb24ncyAnbmFtZScgZWxlbWVudC4gUmV0dXJuIG51bGwgaWYgdGhlIGF0dHJpYnV0ZQotCSAqIG1hcHMgdG8gdGhlIGpvaW4gY29sdW1uIGJ5IGRlZmF1bHQuCi0JICogVGhlIHNwZWNpZmllZCBmb3JlaWduIGtleSBjb25zaXN0cyBvZiBhIHNpbmdsZSBjb2x1bW4gcGFpciB3aG9zZQotCSAqIHJlZmVyZW5jZWQgY29sdW1uIGlzIHRoZSBzaW5nbGUtY29sdW1uIHByaW1hcnkga2V5IG9mIHRoZSBmb3JlaWduCi0JICoga2V5J3MgcmVmZXJlbmNlZCB0YWJsZS4KLQkgKi8KLQlTdHJpbmcgYnVpbGRKb2luQ29sdW1uQW5ub3RhdGlvbk5hbWUoU3RyaW5nIGF0dHJpYnV0ZU5hbWUsIEZvcmVpZ25LZXkgZm9yZWlnbktleSk7Ci0KLQkvKioKLQkgKiBCdWlsZCBhbmQgcmV0dXJuIGEgc3RyaW5nIHRvIGJlIHVzZWQgYXMgdGhlIHZhbHVlIGZvciBhIEpvaW5Db2x1bW4KLQkgKiBhbm5vdGF0aW9uJ3MgJ25hbWUnIG9yICdyZWZlcmVuY2VkQ29sdW1uTmFtZScgZWxlbWVudC4KLQkgKiBUaGlzIGlzIGNhbGxlZCBmb3IgbWFueS10by1vbmUgYW5kIG1hbnktdG8tbWFueSBtYXBwaW5ncyB3aGVuCi0JICogdGhlIGRlZmF1bHQgam9pbiBjb2x1bW4gbmFtZSBhbmQvb3IgcmVmZXJlbmNlZCBjb2x1bW4gbmFtZSBhcmUvaXMKLQkgKiBub3QgYXBwbGljYWJsZS4KLQkgKiBAc2VlIGJ1aWxkSm9pbkNvbHVtbkFubm90YXRpb25OYW1lKFN0cmluZywgRm9yZWlnbktleSkKLQkgKi8KLQlTdHJpbmcgYnVpbGRKb2luQ29sdW1uQW5ub3RhdGlvbk5hbWUoQ29sdW1uIGNvbHVtbik7Ci0KLQkvKioKLQkgKiBCdWlsZCBhbmQgcmV0dXJuIGEgc3RyaW5nIHRvIGJlIHVzZWQgYXMgdGhlIHZhbHVlIGZvciBhIEpvaW5UYWJsZQotCSAqIGFubm90YXRpb24ncyAnbmFtZScgZWxlbWVudC4KLQkgKiBUaGlzIGlzIGNhbGxlZCBmb3IgbWFueS10by1tYW55IG1hcHBpbmdzIHdoZW4gdGhlIGRlZmF1bHQKLQkgKiBqb2luIHRhYmxlIG5hbWUgaXMgbm90IGFwcGxpY2FibGUuCi0JICovCi0JU3RyaW5nIGJ1aWxkSm9pblRhYmxlQW5ub3RhdGlvbk5hbWUoVGFibGUgdGFibGUpOwotCi0KLQkvKioKLQkgKiBUaGUgZGVmYXVsdCBpbXBsZW1lbnRhdGlvbiBzaW1wbGUgcmV0dXJucyB0aGUgZGF0YWJhc2Ugb2JqZWN0J3MgbmFtZSwKLQkgKiB1bmFsdGVyZWQuCi0JICovCi0JZmluYWwgY2xhc3MgRGVmYXVsdCBpbXBsZW1lbnRzIERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyIHsKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBEYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlciBJTlNUQU5DRSA9IG5ldyBEZWZhdWx0KCk7Ci0JCXB1YmxpYyBzdGF0aWMgRGF0YWJhc2VBbm5vdGF0aW9uTmFtZUJ1aWxkZXIgaW5zdGFuY2UoKSB7Ci0JCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCX0KLQkJLy8gZW5zdXJlIHNpbmdsZSBpbnN0YW5jZQotCQlwcml2YXRlIERlZmF1bHQoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCXB1YmxpYyBTdHJpbmcgYnVpbGRUYWJsZUFubm90YXRpb25OYW1lKFN0cmluZyBlbnRpdHlOYW1lLCBUYWJsZSB0YWJsZSkgewotCQkJcmV0dXJuIHRhYmxlLmdldE5hbWUoKTsKLQkJfQotCQlwdWJsaWMgU3RyaW5nIGJ1aWxkQ29sdW1uQW5ub3RhdGlvbk5hbWUoU3RyaW5nIGF0dHJpYnV0ZU5hbWUsIENvbHVtbiBjb2x1bW4pIHsKLQkJCXJldHVybiBjb2x1bW4uZ2V0TmFtZSgpOwotCQl9Ci0JCXB1YmxpYyBTdHJpbmcgYnVpbGRKb2luQ29sdW1uQW5ub3RhdGlvbk5hbWUoU3RyaW5nIGF0dHJpYnV0ZU5hbWUsIEZvcmVpZ25LZXkgZm9yZWlnbktleSkgewotCQkJcmV0dXJuIGZvcmVpZ25LZXkuZ2V0Q29sdW1uUGFpcigpLmdldEJhc2VDb2x1bW4oKS5nZXROYW1lKCk7Ci0JCX0KLQkJcHVibGljIFN0cmluZyBidWlsZEpvaW5Db2x1bW5Bbm5vdGF0aW9uTmFtZShDb2x1bW4gY29sdW1uKSB7Ci0JCQlyZXR1cm4gY29sdW1uLmdldE5hbWUoKTsKLQkJfQotCQlwdWJsaWMgU3RyaW5nIGJ1aWxkSm9pblRhYmxlQW5ub3RhdGlvbk5hbWUoVGFibGUgdGFibGUpIHsKLQkJCXJldHVybiB0YWJsZS5nZXROYW1lKCk7Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gIkRhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyLkRlZmF1bHQiOyAgLy8kTk9OLU5MUy0xJAotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9Gb3JlaWduS2V5SW5mby5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbDIvRm9yZWlnbktleUluZm8uamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOThlNzZkNi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9Gb3JlaWduS2V5SW5mby5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTIwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDI7Ci0KLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5Gb3JlaWduS2V5OwotCi0vKioKLSAqIFJlcHJlc2VudHMgdGhlIG1ldGFkYXRhIGZvciBhIHBhcnRpY3VsYXIgZm9yZWlnbiBrZXkgcmVsYXRpb25zaGlwIAotICogaW4gYSByZWxhdGlvbmFsIGRhdGFiYXNlIHNjaGVtYS4KLSAqIDxwLz4KLSAqIFRoZSByZWZlcnJlciBjb2x1bW4gaXMgb25lIHdoaWNoIGFjdHVhbGx5IGNvbnRhaW5zIGEgZm9yZWlnbiAKLSAqIGtleSBjb25zdHJhaW50LCBhbmQgaXMgZXF1aXZhbGVudCB0byB0aGUgImZvcmVpZ24ga2V5IiBjb2x1bW4uCi0gKiA8cC8+Ci0gKiBUaGUgcmVmZXJlbmNlZCBjb2x1bW4gaXMgb25lIHdoaWNoIGEgcmVmZXJyZXIgb3IgZm9yZWlnbiBrZXkgCi0gKiBjb2x1bW4gcmVmZXJlbmNlcywgYW5kIGlzIGVxdWl2YWxlbnQgdG8gdGhlICJwcmltYXJ5IGtleSIgY29sdW1uLgotICogCi0gKi8KLXB1YmxpYyBjbGFzcyBGb3JlaWduS2V5SW5mbwotewotCXByaXZhdGUgdHJhbnNpZW50IEZvcmVpZ25LZXkgbUZvcmVpZ25LZXkgOwotICAgIHByaXZhdGUgU3RyaW5nIG1OYW1lOwotICAgIHByaXZhdGUgU3RyaW5nIG1SZWZlcnJlclRhYmxlTmFtZTsKLSAgICBwcml2YXRlIFN0cmluZyBtUmVmZXJlbmNlZFRhYmxlTmFtZTsKLSAgICBwcml2YXRlIExpc3Q8U3RyaW5nPiBtUmVmZXJyZXJDb2xOYW1lcyA9IG5ldyBqYXZhLnV0aWwuQXJyYXlMaXN0PFN0cmluZz4oKTsKLSAgICBwcml2YXRlIExpc3Q8U3RyaW5nPiBtUmVmZXJlbmNlZENvbE5hbWVzID0gbmV3IGphdmEudXRpbC5BcnJheUxpc3Q8U3RyaW5nPigpOwotICAgIAotICAgIC8qKgotICAgICAqIEBwYXJhbSBmayBUaGUgbmFtZSBvZiB0aGUgY29uc3RyYWludCBiYWNraW5nIAotICAgICAqIHRoaXMgZm9yZWlnbiBrZXkgbWV0YWRhdGEgaW5zdGFuY2UuCi0gICAgICovCi0gICAgcHVibGljIEZvcmVpZ25LZXlJbmZvKEZvcmVpZ25LZXkgZmssIFN0cmluZyByZWZlcnJlclRhYmxlTmFtZSwgU3RyaW5nIHJlZmVyZW5jZWRUYWJsZU5hbWUpIHsKLSAgICAJbUZvcmVpZ25LZXkgPSBmazsKLSAgICAJbU5hbWUgPSBmay5nZXROYW1lKCk7Ci0gICAgCW1SZWZlcnJlclRhYmxlTmFtZSA9IHJlZmVycmVyVGFibGVOYW1lOwotICAgIAltUmVmZXJlbmNlZFRhYmxlTmFtZSA9IHJlZmVyZW5jZWRUYWJsZU5hbWU7Ci0JfQotICAgIC8qKgotICAgICAqIE9idGFpbiB0aGUgY29uc3RyYWludCBuYW1lIGZvciB0aGlzIGZvcmVpZ24ga2V5IHNwZWNpZmljYXRpb24uCi0gICAgICogVGhlIG5hbWUgZm9yIGEgRm9yZWlnbiBLZXkgbWF5LCBhcyBwZXIgdGhlIEpEQkMgc3BlY2lmaWNhdGlvbiwKLSAgICAgKiBiZSA8Y29kZT5udWxsPC9jb2RlPiB3aGVyZSB0aGUgY29uc3RyYWludCBpcyBub3QgbmFtZWQuCi0gICAgICogSW4gYWRkaXRpb24sIGl0IG1heSBiZSBoYXJkbHkgcmVjb2duaXphYmxlIHRvIHRoZSB1c2VyLAotICAgICAqIHBhcnRpY3VsYXJseSBmb3IgREIvMiBjb25zdHJhaW50cy4KLSAgICAgKiAKLSAgICAgKiBAcmV0dXJuIFRoZSBuYW1lIG9mIHRoZSBjb25zdHJhaW50IGJhY2tpbmcKLSAgICAgKiAgICAgICAgIHRoaXMgZm9yZWlnbiBrZXkgbWV0YWRhdGEgaW5zdGFuY2UuCi0gICAgICovCi0gICAgcHVibGljIFN0cmluZyBnZXROYW1lKCkKLSAgICB7Ci0gICAgICAgIHJldHVybiBtTmFtZTsKLSAgICB9Ci0gICAgCi0gICAgcHVibGljIEZvcmVpZ25LZXkgZ2V0Rm9yZWlnbktleSgpewotICAgIAlyZXR1cm4gbUZvcmVpZ25LZXk7Ci0gICAgfQotICAgIC8qKgotICAgICAqIEFkZCBhbm90aGVyIHBhaXIgb2YgZm9yZWlnbiBrZXkgbWFwcGluZ3MgZm9yIHRoaXMgZm9yZWlnbiBrZXkKLSAgICAgKiBkZWZpbml0aW9uLgotICAgICAqIAotICAgICAqIEBwYXJhbSByZWZlcnJlckNvbHVtbiBUaGUgcmVmZXJyZXIgY29sdW1uIG5hbWUgZm9yIHRoaXMgbWFwcGluZy4KLSAgICAgKiAKLSAgICAgKiBAcGFyYW0gcmVmZXJlbmNlZENvbHVtbiBUaGUgcmVmZXJlbmNlZCBjb2x1bW4gbmFtZSBmb3IgdGhpcyBtYXBwaW5nLgotICAgICAqLwotICAgIHB1YmxpYyB2b2lkIGFkZENvbHVtbk1hcHBpbmcoU3RyaW5nIHJlZmVycmVyQ29sTmFtZSwgU3RyaW5nIHJlZmVyZW5jZWRDb2xOYW1lKSB7Ci0gICAgCW1SZWZlcnJlckNvbE5hbWVzLmFkZChyZWZlcnJlckNvbE5hbWUpOwotICAgIAltUmVmZXJlbmNlZENvbE5hbWVzLmFkZChyZWZlcmVuY2VkQ29sTmFtZSk7Ci0gICAgfQotICAgIC8qKgotICAgICAqIFJldHVybnMgdGhlIHJlZmVycmVyIHRhYmxlIG5hbWUgb2YgdGhpcyBmb3JlaWduIGtleQotICAgICAqIHJlbGF0aW9uc2hpcC4KLSAgICAgKi8KLSAgICBwdWJsaWMgU3RyaW5nIGdldFJlZmVycmVyVGFibGVOYW1lKCkgewotICAgICAgICByZXR1cm4gbVJlZmVycmVyVGFibGVOYW1lOwotICAgIH0KLSAgICAvKioKLSAgICAgKiBSZXR1cm5zIHRoZSByZWZlcnJlciBjb2x1bW4gbmFtZXMgZm9yIHRoaXMKLSAgICAgKiBmb3JlaWduIGtleS4KLSAgICAgKiBUaGUgc2l6ZSBvZiB0aGlzIGxpc3QgaXMgYWx3YXlzIHRoZSBzYW1lIGFzIHRoZSBzaXplIG9mIAotICAgICAqIHRoZSBsaXN0IHJldHVyZWQgZnJvbSA8Y29kZT5nZXRSZWZlcmVuY2VkQ29sdW1uTmFtZXM8L2NvZGU+Ci0gICAgICovCi0gICAgcHVibGljIExpc3Q8U3RyaW5nPiBnZXRSZWZlcnJlckNvbHVtbk5hbWVzKCkgewotICAgICAgICByZXR1cm4gbVJlZmVycmVyQ29sTmFtZXM7Ci0gICAgfQotICAgIC8qKgotICAgICAqIFJldHVybnMgdGhlIHJlZmVyZW5jZWQgdGFibGUgbmFtZSBvZiB0aGlzIGZvcmVpZ24ga2V5Ci0gICAgICogcmVsYXRpb25zaGlwLgotICAgICAqLwotICAgIHB1YmxpYyBTdHJpbmcgZ2V0UmVmZXJlbmNlZFRhYmxlTmFtZSgpIHsKLSAgICAJIHJldHVybiBtUmVmZXJlbmNlZFRhYmxlTmFtZTsKLSAgICB9Ci0gICAgLyoqCi0gICAgICogUmV0dXJucyB0aGUgcmVmZXJlbmNlZCBjb2x1bW4gbmFtZXMgZm9yIHRoaXMKLSAgICAgKiBmb3JlaWduIGtleS4KLSAgICAgKiBUaGUgc2l6ZSBvZiB0aGlzIGxpc3QgaXMgYWx3YXlzIHRoZSBzYW1lIGFzIHRoZSBzaXplIG9mIAotICAgICAqIHRoZSBsaXN0IHJldHVyZWQgZnJvbSA8Y29kZT5nZXRSZWZlcnJlckNvbHVtbk5hbWVzPC9jb2RlPgotICAgICAqLwotICAgIHB1YmxpYyBMaXN0PFN0cmluZz4gZ2V0UmVmZXJlbmNlZENvbHVtbk5hbWVzKCkgewotICAgICAgICByZXR1cm4gbVJlZmVyZW5jZWRDb2xOYW1lczsKLSAgICB9Ci0gICAgLyogKG5vbi1KYXZhZG9jKQotICAgICAqIEBzZWUgamF2YS5sYW5nLk9iamVjdCN0b1N0cmluZygpCi0gICAgICovCi0gICAgcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLSAgICAJcmV0dXJuICJuYW1lPSIgKyBtTmFtZQotCQkrICIsIHJlZmVycmVyVGFibGU9IiArIG1SZWZlcnJlclRhYmxlTmFtZQotCQkrICIsIHJlZmVyZW5jZWRUYWJsZT0iICsgbVJlZmVyZW5jZWRUYWJsZU5hbWUKLQkJKyAiLCByZWZlcnJlckNvbHVtbnM9IiArIG1SZWZlcnJlckNvbE5hbWVzCi0JCSsgIiwgcmVmZXJlbmNlZENvbHVtbnM9IiArIG1SZWZlcmVuY2VkQ29sTmFtZXMKLQkJCTsKLSAgICB9Ci19Ci0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL0pwdEdlbk1lc3NhZ2VzLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9KcHRHZW5NZXNzYWdlcy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjYTNhNTEyLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL0pwdEdlbk1lc3NhZ2VzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5nZW4uaW50ZXJuYWwyOwotCi1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS51dGlsLk5MUzsKLQotLyoqCi0gKiBMb2NhbGl6ZWQgbWVzc2FnZXMgdXNlZCBieSBEYWxpIGVudGl0eSBnZW5lcmF0aW9uLgotICovCi1jbGFzcyBKcHRHZW5NZXNzYWdlcyB7Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBQYWNrYWdlR2VuZXJhdG9yX3Rhc2tOYW1lOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEdlblNjb3BlX3Rhc2tOYW1lOwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIEVudGl0eUdlbmVyYXRvcl90YXNrTmFtZTsKLQlwdWJsaWMgc3RhdGljIFN0cmluZyBUZW1wbGF0ZXNfbm90Rm91bmQ7Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgRXJyb3JfR2VuZXJhdGluZ19FbnRpdGllczsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBCVU5ETEVfTkFNRSA9ICJqcHRfZ2VuIjsgLy8kTk9OLU5MUy0xJAotCXByaXZhdGUgc3RhdGljIGZpbmFsIENsYXNzPD8+IEJVTkRMRV9DTEFTUyA9IEpwdEdlbk1lc3NhZ2VzLmNsYXNzOwotCXN0YXRpYyB7Ci0JCU5MUy5pbml0aWFsaXplTWVzc2FnZXMoQlVORExFX05BTUUsIEJVTkRMRV9DTEFTUyk7Ci0JfQotCQotCXByaXZhdGUgSnB0R2VuTWVzc2FnZXMoKSB7Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbDIvSnB0R2VuUGx1Z2luLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9KcHRHZW5QbHVnaW4uamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjA3MWRkZi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9KcHRHZW5QbHVnaW4uamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDMzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDI7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuQ29yZUV4Y2VwdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuSUxvZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuSVN0YXR1czsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuUGxhdGZvcm07Ci1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLlN0YXR1czsKLWltcG9ydCBvcmcub3NnaS5mcmFtZXdvcmsuQnVuZGxlOwotCi1wdWJsaWMgY2xhc3MgSnB0R2VuUGx1Z2luIHsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBQTFVHSU5fSUQgPSAib3JnLmVjbGlwc2UuanB0LmdlbiI7Ci0JcHVibGljIHN0YXRpYyB2b2lkIGxvZ0V4Y2VwdGlvbiAoIFN0cmluZyBtc2csIFRocm93YWJsZSBlICkgewotCQlCdW5kbGUgYnVuZGxlID0gUGxhdGZvcm0uZ2V0QnVuZGxlKFBMVUdJTl9JRCk7Ci0JCUlMb2cgbG9nID0gUGxhdGZvcm0uZ2V0TG9nKGJ1bmRsZSk7Ci0JCWxvZy5sb2cobmV3IFN0YXR1cyhJU3RhdHVzLkVSUk9SLCBQTFVHSU5fSUQsIG1zZywgZSApKTsJCQotCX0KLQkKLQlwdWJsaWMgc3RhdGljIHZvaWQgbG9nRXhjZXB0aW9uKCBDb3JlRXhjZXB0aW9uIGNlICkgewotCQlJU3RhdHVzIHN0YXR1cyA9IGNlLmdldFN0YXR1cygpOwotCQlCdW5kbGUgYnVuZGxlID0gUGxhdGZvcm0uZ2V0QnVuZGxlKFBMVUdJTl9JRCk7Ci0JCUlMb2cgbG9nID0gUGxhdGZvcm0uZ2V0TG9nKGJ1bmRsZSk7Ci0JCWxvZy5sb2cobmV3IFN0YXR1cyhJU3RhdHVzLkVSUk9SLCBQTFVHSU5fSUQsIHN0YXR1cy5nZXRNZXNzYWdlKCksIGNlKSk7CQkKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9PUk1HZW5Db2x1bW4uamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL09STUdlbkNvbHVtbi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1MTcxOTY3Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL09STUdlbkNvbHVtbi5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzM2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDI7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbnM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuQ29sdW1uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5UYWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsLkVudGl0eUdlblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5nZW4uaW50ZXJuYWwyLnV0aWwuRFRQVXRpbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsMi51dGlsLlN0cmluZ1V0aWw7Ci0KLQotLyoqCi0gKiBSZXByZXNlbnRzIHRoZSBPUk0gZ2VuZXJhdGlvbiBwcm9wZXJ0aWVzIGZvciBhIGRhdGFiYXNlIAotICogY29sdW1uLgotICogCi0gKiA8cD5UaGlzIGlzIGRlc2lnbmVkIHRvIGJlIGNyZWF0ZWQvY2hhbmdlZCBieSB0aGUgZ2VuZXJhdGlvbiB3aXphcmQsCi0gKiBhbmQgZ2VuZXJhdGVkIHVzaW5nIFZlbG9jaXR5IHRlbXBsYXRlcy4KLSAqIFRoZSBtb2RpZmllZCBwcm9wZXJ0aWVzIChpZiBhbnkpIGFyZSBwZXJzaXN0ZWQvcmV0cmlldmVkIHVzaW5nIAotICogPGNvZGU+T1JNR2VuQ3VzdG9taXplcjwvY29kZT4uCi0gKiAKLSAqLwotcHVibGljIGNsYXNzIE9STUdlbkNvbHVtbgotewotCXByaXZhdGUgVGFibGUgbVRhYmxlOwotCXByaXZhdGUgQ29sdW1uIG1EYkNvbHVtbjsKLQlwcml2YXRlIE9STUdlbkN1c3RvbWl6ZXIgbUN1c3RvbWl6ZXI7Ci0JcHJpdmF0ZSBzdGF0aWMgU3RyaW5nIEpBVkFfTEFOR19QQUNLQUdFID0gImphdmEubGFuZy4iOwotCQotCXB1YmxpYyBPUk1HZW5Db2x1bW4oQ29sdW1uIGRiQ29sdW1uLCBPUk1HZW5DdXN0b21pemVyIGN1c3RvbWl6ZXIpIHsKLQkJc3VwZXIoKTsKLQkJCi0JCW1EYkNvbHVtbiA9IGRiQ29sdW1uOwotCQltQ3VzdG9taXplciA9IGN1c3RvbWl6ZXI7Ci0JCW1UYWJsZSA9IGRiQ29sdW1uLmdldFRhYmxlKCkgOwotCX0KLQlwdWJsaWMgT1JNR2VuQ3VzdG9taXplciBnZXRDdXN0b21pemVyKCkgewotCQlyZXR1cm4gbUN1c3RvbWl6ZXI7Ci0JfQotCQotCXByb3RlY3RlZCBTdHJpbmcgY3VzdG9taXplZChTdHJpbmcgcHJvcE5hbWUpIHsKLQkJcmV0dXJuIGdldEN1c3RvbWl6ZXIoKS5nZXRQcm9wZXJ0eShwcm9wTmFtZSwgbVRhYmxlLmdldE5hbWUoKSwgZ2V0TmFtZSgpKTsKLQl9Ci0JcHJvdGVjdGVkIGJvb2xlYW4gY3VzdG9taXplZEJvb2xlYW4oU3RyaW5nIHByb3BOYW1lKSB7Ci0JCXJldHVybiBnZXRDdXN0b21pemVyKCkuZ2V0Qm9vbGVhblByb3BlcnR5KHByb3BOYW1lLCBtVGFibGUuZ2V0TmFtZSgpLCBnZXROYW1lKCkpOwotCX0KLQlwcm90ZWN0ZWQgdm9pZCBzZXRDdXN0b21pemVkKFN0cmluZyBwcm9wTmFtZSwgU3RyaW5nIHZhbHVlKSB7Ci0JCWlmICh2YWx1ZSAhPSBudWxsICYmIHZhbHVlLmxlbmd0aCgpID09IDApIHsKLQkJCXZhbHVlID0gbnVsbDsKLQkJfQotCQlnZXRDdXN0b21pemVyKCkuc2V0UHJvcGVydHkocHJvcE5hbWUsIHZhbHVlLCBtVGFibGUuZ2V0TmFtZSgpLCBnZXROYW1lKCkpOwotCX0KLQlwcm90ZWN0ZWQgdm9pZCBzZXRDdXN0b21pemVkQm9vbGVhbihTdHJpbmcgcHJvcE5hbWUsIGJvb2xlYW4gdmFsdWUsIGJvb2xlYW4gZGVmYXVsdFZhbHVlKSB7Ci0JCWlmIChkZWZhdWx0VmFsdWUgPT0gdmFsdWUpIHsKLQkJCXNldEN1c3RvbWl6ZWQocHJvcE5hbWUsIG51bGwpOyAvL3JlbW92ZSB0aGUgcHJvcGVydHkKLQkJfSBlbHNlIHsKLQkJCWdldEN1c3RvbWl6ZXIoKS5zZXRCb29sZWFuUHJvcGVydHkocHJvcE5hbWUsIHZhbHVlLCBtVGFibGUuZ2V0TmFtZSgpLCBnZXROYW1lKCkpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIFJldHVybnMgdGhlIGNvbHVtbiBuYW1lLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0TmFtZSgpIHsKLQkJU3RyaW5nIGFubm90YXRpb25OYW1lID0gdGhpcy5tQ3VzdG9taXplci5nZXREYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlcigpLgotCQkJYnVpbGRDb2x1bW5Bbm5vdGF0aW9uTmFtZShtRGJDb2x1bW4uZ2V0TmFtZSgpLCBtRGJDb2x1bW4pOwotCQlyZXR1cm4gYW5ub3RhdGlvbk5hbWUhPW51bGwgPyBhbm5vdGF0aW9uTmFtZSA6IG1EYkNvbHVtbi5nZXROYW1lKCk7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXRKb2luQ29sdW1uTmFtZSgpewotCQlTdHJpbmcgYW5ub3RhdGlvbk5hbWUgPSB0aGlzLm1DdXN0b21pemVyLmdldERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyKCkuCi0JCQlidWlsZEpvaW5Db2x1bW5Bbm5vdGF0aW9uTmFtZShtRGJDb2x1bW4pOwotCQlyZXR1cm4gYW5ub3RhdGlvbk5hbWUhPW51bGwgPyBhbm5vdGF0aW9uTmFtZSA6IG1EYkNvbHVtbi5nZXROYW1lKCk7Ci0JfQotCQotCXB1YmxpYyBDb2x1bW4gZ2V0RGJDb2x1bW4oKXsKLQkJcmV0dXJuIHRoaXMubURiQ29sdW1uOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm5zIHRoZSBnZW5lcmF0ZWQgYmVhbiBwcm9wZXJ0eSBuYW1lIGZvciB0aGUgZ2l2ZW4gY29sdW1uLgotCSAqIERvZXMgbm90IHJldHVybiBudWxsLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0UHJvcGVydHlOYW1lKCkgewotCQlTdHJpbmcgbmFtZSA9IGN1c3RvbWl6ZWQoUFJPUEVSVFlfTkFNRSk7Ci0JCWlmIChuYW1lID09IG51bGwpIHsKLQkJCS8vbmFtZSA9IFN0cmluZ1V0aWwuY29sdW1uTmFtZVRvVmFyTmFtZShnZXROYW1lKCkpOwotCQkJbmFtZSA9IEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUoZ2V0TmFtZSgpLCBDb2xsZWN0aW9ucy5FTVBUWV9TRVQpOwotCQl9Ci0JCXJldHVybiBuYW1lOwotCX0KLQlwdWJsaWMgdm9pZCBzZXRQcm9wZXJ0eU5hbWUoU3RyaW5nIG5hbWUpIHsKLQkJaWYgKCFTdHJpbmdVdGlsLmVxdWFsT2JqZWN0cyhuYW1lLCBnZXRQcm9wZXJ0eU5hbWUoKSkpIHsKLQkJCXNldEN1c3RvbWl6ZWQoUFJPUEVSVFlfTkFNRSwgbmFtZSk7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRydWUgaWYgdGhlIHZhbHVlcyBvZiBuYW1lIGVsZW1lbnQgaW4gdGhlIEBDb2x1bW4gaXMgZGVmYXVsdAotCSAqIHNvIHdlIGNhbiBza2lwIGdlbmVyYXRpbmcgdGhlIGFubm90YXRpb24KLQkgKiAKLQkgKiBAcmV0dXJuIHRydWUKLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBpc0RlZmF1bHQoKXsKLQkJcmV0dXJuIGlzRGVmYXVsdG5hbWUoKSAmJiBpc1VwZGF0ZWFibGUoKSAmJiBpc0luc2VydGFibGUoKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRydWUgaWYgdGhlIHZhbHVlcyBvZiBuYW1lIGVsZW1lbnQgaW4gdGhlIEBDb2x1bW4gaXMgZGVmYXVsdAotCSAqIHNvIHdlIGNhbiBza2lwIGdlbmVyYXRpbmcgdGhlIGFubm90YXRpb24KLQkgKiAKLQkgKiBAcmV0dXJuIHRydWUKLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBpc0RlZmF1bHRuYW1lKCl7Ci0JCVN0cmluZyBwcm9wTmFtZSA9IGdldFByb3BlcnR5TmFtZSgpOwotLy8JCVN0cmluZyBkYkNvbHVtbk5hbWUgPSBnZXROYW1lKCk7Ci0vLwkJcmV0dXJuIHByb3BOYW1lLmVxdWFsc0lnbm9yZUNhc2UoIGRiQ29sdW1uTmFtZSApOwotCQlTdHJpbmcgYW5ub3RhdGlvbk5hbWUgPSB0aGlzLm1DdXN0b21pemVyLmdldERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyKCkuCi0JCQlidWlsZENvbHVtbkFubm90YXRpb25OYW1lKHByb3BOYW1lICwgdGhpcy5tRGJDb2x1bW4gKTsKLQkJcmV0dXJuIGFubm90YXRpb25OYW1lPT1udWxsOwotCX0KLQotCQotCS8qKgotCSAqIFJldHVybnMgdGhlIGNvbHVtbiB0eXBlLgotCSAqIERvZXMgbm90IHJldHVybiBudWxsLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0UHJvcGVydHlUeXBlKCkgIHsKLQkJU3RyaW5nIHR5cGUgPSBjdXN0b21pemVkKFBST1BFUlRZX1RZUEUpOwotCQlpZiAodHlwZSA9PSBudWxsKSB7Ci0JCQl0eXBlID0gZ2V0Q3VzdG9taXplcigpLmdldFByb3BlcnR5VHlwZUZyb21Db2x1bW4oIHRoaXMubURiQ29sdW1uICk7Ci0JCX0KLQkJaWYoIHR5cGUuc3RhcnRzV2l0aChKQVZBX0xBTkdfUEFDS0FHRSkgKXsKLQkJCXR5cGUgPSB0eXBlLnN1YnN0cmluZyggSkFWQV9MQU5HX1BBQ0tBR0UubGVuZ3RoKCkgKTsKLQkJfQotCQlyZXR1cm4gdHlwZTsKLQl9Ci0JcHVibGljIHZvaWQgc2V0UHJvcGVydHlUeXBlKFN0cmluZyB0eXBlKSAgewotCQlpZiAoIVN0cmluZ1V0aWwuZXF1YWxPYmplY3RzKHR5cGUsIGdldFByb3BlcnR5VHlwZSgpKSkgewotCQkJc2V0Q3VzdG9taXplZChQUk9QRVJUWV9UWVBFLCB0eXBlKTsKLQkJfQotCX0KLQkvKioKLQkgKiBSZXR1cm5zIHRydWUgaWYgdGhlIGNvbHVtbiB0eXBlIGlzIG51bWVyaWMuCi0JICovCi0JcHVibGljIGJvb2xlYW4gaXNOdW1lcmljKCkgewotCQlib29sZWFuIHJldCA9IHRoaXMubURiQ29sdW1uLmlzTnVtZXJpYygpIDsKLQkJcmV0dXJuIHJldDsKLQkJCi0JfQotCS8qKgotCSAqIFJldHVybnMgdGhlIG1hcHBpbmcga2luZCwgb25lIG9mIHtAbGluayAjUFJPUEVSVFlfTUFQUElOR19LSU5EfXx7QGxpbmsgI0lEX01BUFBJTkdfS0lORH0KLQkgKiB8e0BsaW5rICNWRVJTSU9OX01BUFBJTkdfS0lORH18e0BsaW5rICNUSU1FU1RBTVBfTUFQUElOR19LSU5EfS4KLQkgKiAKLQkgKiBUaGlzIG1ldGhvZCBkb2VzIG5vdCByZXR1cm4gbnVsbCAoZGVmYXVsdHMgdG8gYmFzaWMgcHJvcGVydHkgdHlwZSkuCi0JICovCi0JcHVibGljIFN0cmluZyBnZXRNYXBwaW5nS2luZCgpIHsKLQkJU3RyaW5nIGtpbmQgPSBjdXN0b21pemVkKE1BUFBJTkdfS0lORCk7Ci0JCWlmIChraW5kID09IG51bGwpIHsKLQkJCWtpbmQgPSBnZXRDdXN0b21pemVyKCkuZ2V0QmFzaWNNYXBwaW5nS2luZCgpOwotCQkJCi0JCQlpZiAoIHRoaXMubURiQ29sdW1uLmlzUGFydE9mUHJpbWFyeUtleSgpIAotCQkJCSAmJiBEVFBVdGlsLmdldFByaW1hcnlLZXlDb2x1bW5OYW1lcyggdGhpcy5tRGJDb2x1bW4uZ2V0VGFibGUoKSApLnNpemUoKSA9PSAxKSB7Ci0JCQkJa2luZCA9IGdldEN1c3RvbWl6ZXIoKS5nZXRJZE1hcHBpbmdLaW5kKCk7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGtpbmQ7Ci0JfQotCXB1YmxpYyB2b2lkIHNldE1hcHBpbmdLaW5kKFN0cmluZyBtYXBwaW5nS2luZCkgIHsKLQkJaWYgKCFTdHJpbmdVdGlsLmVxdWFsT2JqZWN0cyhtYXBwaW5nS2luZCwgZ2V0TWFwcGluZ0tpbmQoKSkpIHsKLQkJCXNldEN1c3RvbWl6ZWQoTUFQUElOR19LSU5ELCBtYXBwaW5nS2luZCk7Ci0JCX0KLQl9Ci0JcHVibGljIGJvb2xlYW4gaXNOdWxsYWJsZSgpIHsKLQkJcmV0dXJuIHRoaXMubURiQ29sdW1uLmlzTnVsbGFibGUoKTsKLQl9Ci0KLQlwdWJsaWMgaW50IGdldFNpemUoKSB7Ci0JCWlmKCB0aGlzLm1EYkNvbHVtbi5pc051bWVyaWMoKSl7Ci0JCQlyZXR1cm4gbURiQ29sdW1uLmdldFByZWNpc2lvbigpOwotCQl9Ci0JCXJldHVybiBtRGJDb2x1bW4uZ2V0TGVuZ3RoKCk7Ci0JfQotCi0JcHVibGljIGludCBnZXREZWNpbWFsRGlnaXRzKCkgewotCQlpZiggdGhpcy5tRGJDb2x1bW4uaXNOdW1lcmljKCkgKXsKLQkJCXJldHVybiBtRGJDb2x1bW4uZ2V0U2NhbGUoKTsKLQkJfQotCQlyZXR1cm4gLTE7Ci0JfQotCQotCXB1YmxpYyBib29sZWFuIGlzUHJpbWFyeUtleSgpewotCQlyZXR1cm4gdGhpcy5tRGJDb2x1bW4uaXNQYXJ0T2ZQcmltYXJ5S2V5KCkgOwotCX0KLQlwdWJsaWMgYm9vbGVhbiBpc0ZvcmVpZ25LZXkoKSAgewotCQlyZXR1cm4gdGhpcy5tRGJDb2x1bW4uaXNQYXJ0T2ZGb3JlaWduS2V5KCkgOwotCX0KLQlwdWJsaWMgYm9vbGVhbiBpc1VuaXF1ZSgpICB7Ci0JCXJldHVybiB0aGlzLm1EYkNvbHVtbi5pc1BhcnRPZlVuaXF1ZUNvbnN0cmFpbnQoKSA7Ci0JfQotCXB1YmxpYyBTdHJpbmcgZ2V0UHJvcGVydHlEZXNjcmlwdGlvbigpIHsKLQkJcmV0dXJuIGN1c3RvbWl6ZWQoUFJPUEVSVFlfREVTQyk7Ci0JfQotCQotCXB1YmxpYyBib29sZWFuIGlzRGF0YVR5cGVMT0IoKXsKLQkJcmV0dXJuIHRoaXMubURiQ29sdW1uLmlzTE9CKCk7Ci0JfQkKLQotCXB1YmxpYyBib29sZWFuIGlzTmVlZE1hcFRlbXBvcmFsVHlwZSgpewotCQlTdHJpbmcgcHJvcGVydHlUeXBlID0gdGhpcy5nZXRQcm9wZXJ0eVR5cGUoKTsKLQkJcmV0dXJuICggcHJvcGVydHlUeXBlLmVxdWFscygiamF2YS51dGlsLkRhdGUiKSB8fCBwcm9wZXJ0eVR5cGUuZXF1YWxzKCJqYXZhLnV0aWwuQ2FsZW5kYXIiKSApOyAKLQl9CQotCQotCXB1YmxpYyBTdHJpbmcgZ2V0VGVtcG9yYWxUeXBlKCl7Ci0JCVN0cmluZyBkZWZhdWx0VHlwZSA9IGdldEN1c3RvbWl6ZXIoKS5nZXRQcm9wZXJ0eVR5cGVGcm9tQ29sdW1uKCB0aGlzLm1EYkNvbHVtbiApOwotCQlpZiggZGVmYXVsdFR5cGUuZXF1YWxzKCJqYXZhLnNxbC5EYXRlIikpewotCQkJcmV0dXJuICJEQVRFIjsKLQkJfWVsc2UgaWYoIGRlZmF1bHRUeXBlLmVxdWFscygiamF2YS5zcWwuVGltZSIpKXsKLQkJCXJldHVybiAiVElNRSI7Ci0JCX1lbHNlIHsKLQkJCXJldHVybiAiVElNRVNUQU1QIjsKLQkJfQotCX0JCi0JCi0JLyoqCi0JICogUmV0dXJucyB0aGUgZ2VuZXJhdGVkIHByb3BlcnR5IGdldHRlciBzY29wZSwgb25lIG9mIHtAbGluayAjUFVCTElDX1NDT1BFfXx7QGxpbmsgI1BST1RFQ1RFRF9TQ09QRX0KLQkgKiB8e0BsaW5rICNQUklWQVRFX1NDT1BFfS4KLQkgKiBUaGlzIG1ldGhvZCBuZXZlciByZXR1cm5zIG51bGwgKGRlZmF1bHRzIHRvIHB1YmxpYykuCi0JICovCi0JcHVibGljIFN0cmluZyBnZXRQcm9wZXJ0eUdldFNjb3BlKCkgewotCQlTdHJpbmcgc2NvcGUgPSBjdXN0b21pemVkKFBST1BFUlRZX0dFVF9TQ09QRSk7Ci0JCWlmIChzY29wZSA9PSBudWxsKSB7Ci0JCQlzY29wZSA9IFBVQkxJQ19TQ09QRTsKLQkJfQotCQlyZXR1cm4gc2NvcGU7Ci0JfQotCXB1YmxpYyB2b2lkIHNldFByb3BlcnR5R2V0U2NvcGUoU3RyaW5nIHNjb3BlKSB7Ci0JCWlmICghU3RyaW5nVXRpbC5lcXVhbE9iamVjdHMoc2NvcGUsIGdldFByb3BlcnR5R2V0U2NvcGUoKSkpIHsKLQkJCXNldEN1c3RvbWl6ZWQoUFJPUEVSVFlfR0VUX1NDT1BFLCBzY29wZSk7Ci0JCX0KLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgZ2VuZXJhdGVkIHByb3BlcnR5IHNldHRlciBzY29wZSwgb25lIG9mIHtAbGluayAjUFVCTElDX1NDT1BFfXx7QGxpbmsgI1BST1RFQ1RFRF9TQ09QRX0KLQkgKiB8e0BsaW5rICNQUklWQVRFX1NDT1BFfS4KLQkgKiBUaGlzIG1ldGhvZCBuZXZlciByZXR1cm5zIG51bGwgKGRlZmF1bHRzIHRvIHB1YmxpYykuCi0JICovCi0JcHVibGljIFN0cmluZyBnZXRQcm9wZXJ0eVNldFNjb3BlKCkgewotCQlTdHJpbmcgc2NvcGUgPSBjdXN0b21pemVkKFBST1BFUlRZX1NFVF9TQ09QRSk7Ci0JCWlmIChzY29wZSA9PSBudWxsKSB7Ci0JCQlzY29wZSA9IFBVQkxJQ19TQ09QRTsKLQkJfQotCQlyZXR1cm4gc2NvcGU7Ci0JfQotCXB1YmxpYyB2b2lkIHNldFByb3BlcnR5U2V0U2NvcGUoU3RyaW5nIHNjb3BlKSB7Ci0JCWlmICghU3RyaW5nVXRpbC5lcXVhbE9iamVjdHMoc2NvcGUsIGdldFByb3BlcnR5U2V0U2NvcGUoKSkpIHsKLQkJCXNldEN1c3RvbWl6ZWQoUFJPUEVSVFlfU0VUX1NDT1BFLCBzY29wZSk7Ci0JCX0KLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgZ2VuZXJhdGVkIGZpZWxkIG1lbWJlciBzY29wZSwgb25lIG9mIHtAbGluayAjUFVCTElDX1NDT1BFfXx7QGxpbmsgI1BST1RFQ1RFRF9TQ09QRX0KLQkgKiB8e0BsaW5rICNQUklWQVRFX1NDT1BFfS4KLQkgKiBUaGlzIG1ldGhvZCBuZXZlciByZXR1cm5zIG51bGwgKGRlZmF1bHRzIHRvIHByaXZhdGUpLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0RmllbGRTY29wZSgpIHsKLQkJU3RyaW5nIHNjb3BlID0gY3VzdG9taXplZChGSUVMRF9TQ09QRSk7Ci0JCWlmIChzY29wZSA9PSBudWxsKSB7Ci0JCQlzY29wZSA9IFBSSVZBVEVfU0NPUEU7Ci0JCX0KLQkJcmV0dXJuIHNjb3BlOwotCX0KLQkvKioKLQkgKiBSZXR1cm5zIHRydWUgaWYgdGhpcyBjb2x1bW4gc2hvdWxkIGJlIHVzZWQgaW4gdGhlIAotCSAqIDxjb2RlPmVxdWFsczwvY29kZT4gbWV0aG9kIGltcGxlbWVudGF0aW9uLgotCSAqLwotCXB1YmxpYyBib29sZWFuIGlzVXNlSW5FcXVhbHMoKSAgewotCQlyZXR1cm4gY3VzdG9taXplZEJvb2xlYW4oVVNFX0lOX0VRVUFMUykgfHwgaXNQcmltYXJ5S2V5KCk7Ci0JfQotCXB1YmxpYyB2b2lkIHNldFVzZUluRXF1YWxzKGJvb2xlYW4gdmFsdWUpIHsKLQkJc2V0Q3VzdG9taXplZEJvb2xlYW4oVVNFX0lOX0VRVUFMUywgdmFsdWUsIGZhbHNlKTsKLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0cnVlIGlmIHRoaXMgY29sdW1uIHNob3VsZCBiZSB1c2VkIGluIHRoZSAKLQkgKiA8Y29kZT50b1N0cmluZzwvY29kZT4gbWV0aG9kIGltcGxlbWVudGF0aW9uLgotCSAqLwotCXB1YmxpYyBib29sZWFuIGlzVXNlSW5Ub1N0cmluZygpICB7Ci0JCXJldHVybiBjdXN0b21pemVkQm9vbGVhbihVU0VfSU5fVE9fU1RSSU5HKSB8fCBpc1ByaW1hcnlLZXkoKTsKLQl9Ci0JcHVibGljIHZvaWQgc2V0VXNlSW5Ub1N0cmluZyhib29sZWFuIHZhbHVlKSB7Ci0JCXNldEN1c3RvbWl6ZWRCb29sZWFuKFVTRV9JTl9UT19TVFJJTkcsIHZhbHVlLCBmYWxzZSk7Ci0JfQotCXB1YmxpYyBib29sZWFuIGlzVXBkYXRlYWJsZSgpIHsKLQkJcmV0dXJuICEiZmFsc2UiLmVxdWFscyhjdXN0b21pemVkKFVQREFURUFCTEUpKTsgLy9kZWZhdWx0cyB0byB0cnVlCi0JfQotCXB1YmxpYyB2b2lkIHNldFVwZGF0ZWFibGUoYm9vbGVhbiB2YWx1ZSkgewotCQlzZXRDdXN0b21pemVkQm9vbGVhbihVUERBVEVBQkxFLCB2YWx1ZSwgdHJ1ZSk7Ci0JfQotCXB1YmxpYyBib29sZWFuIGlzSW5zZXJ0YWJsZSgpIHsKLQkJcmV0dXJuICEiZmFsc2UiLmVxdWFscyhjdXN0b21pemVkKElOU0VSVEFCTEUpKTsgLy9kZWZhdWx0cyB0byB0cnVlCi0JfQotCXB1YmxpYyB2b2lkIHNldEluc2VydGFibGUoYm9vbGVhbiB2YWx1ZSkgewotCQlzZXRDdXN0b21pemVkQm9vbGVhbihJTlNFUlRBQkxFLCB2YWx1ZSwgdHJ1ZSk7Ci0JfQotCXB1YmxpYyBib29sZWFuIGlzR2VuZXJhdGVkKCkgewotCQlyZXR1cm4gISJmYWxzZSIuZXF1YWxzKGN1c3RvbWl6ZWQoR0VORVJBVEVEKSk7IC8vZGVmYXVsdHMgdG8gdHJ1ZQotCX0KLQlwdWJsaWMgdm9pZCBzZXRHZW5lcmF0ZWQoYm9vbGVhbiB2YWx1ZSkgewotCQlzZXRDdXN0b21pemVkQm9vbGVhbihHRU5FUkFURUQsIHZhbHVlLCB0cnVlKTsKLQl9Ci0JCi0JLypnZXQvc2V0IGFuZCBmaWVsZCBzY29wZXMqLwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFBVQkxJQ19TQ09QRSA9ICJwdWJsaWMiOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFBST1RFQ1RFRF9TQ09QRSA9ICJwcm90ZWN0ZWQiOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFBSSVZBVEVfU0NPUEUgPSAicHJpdmF0ZSI7Ci0KLQkvKmN1c3RvbWl6YXRpb24gcHJvcGVydGllcyovCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIFBST1BFUlRZX05BTUUgPSAicHJvcGVydHlOYW1lIjsKLQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIFN0cmluZyBQUk9QRVJUWV9UWVBFID0gInByb3BlcnR5VHlwZSI7Ci0JcHJvdGVjdGVkIHN0YXRpYyBmaW5hbCBTdHJpbmcgTUFQUElOR19LSU5EID0gIm1hcHBpbmdLaW5kIjsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgUFJPUEVSVFlfREVTQyA9ICJwcm9wZXJ0eURlc2MiOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBQUk9QRVJUWV9HRVRfU0NPUEUgPSAicHJvcGVydHlHZXRTY29wZSI7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIFBST1BFUlRZX1NFVF9TQ09QRSA9ICJwcm9wZXJ0eVNldFNjb3BlIjsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgRklFTERfU0NPUEUgPSAiZmllbGRTY29wZSI7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIFVTRV9JTl9FUVVBTFMgPSAidXNlSW5FcXVhbHMiOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBVU0VfSU5fVE9fU1RSSU5HID0gInVzZUluVG9TdHJpbmciOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBVUERBVEVBQkxFID0gInVwZGF0ZWFibGUiOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBJTlNFUlRBQkxFID0gImluc2VydGFibGUiOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBHRU5FUkFURUQgPSAiZ2VuUHJvcGVydHkiOwotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbDIvT1JNR2VuQ3VzdG9taXplci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbDIvT1JNR2VuQ3VzdG9taXplci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3ZWUwNTE3Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL09STUdlbkN1c3RvbWl6ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDc3MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5nZW4uaW50ZXJuYWwyOwotCi1pbXBvcnQgamF2YS5pby5CeXRlQXJyYXlJbnB1dFN0cmVhbTsKLWltcG9ydCBqYXZhLmlvLkZpbGU7Ci1pbXBvcnQgamF2YS5pby5JT0V4Y2VwdGlvbjsKLWltcG9ydCBqYXZhLmlvLklucHV0U3RyZWFtOwotaW1wb3J0IGphdmEuaW8uT2JqZWN0SW5wdXRTdHJlYW07Ci1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLk1hcDsKLWltcG9ydCBqYXZhLnV0aWwuU2V0OwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkNvcmVFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklTdGF0dXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLlN0YXR1czsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuQ29sdW1uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5TY2hlbWE7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLlRhYmxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5nZW4uaW50ZXJuYWwyLnV0aWwuRFRQVXRpbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsMi51dGlsLkZpbGVVdGlsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5nZW4uaW50ZXJuYWwyLnV0aWwuU3RyaW5nVXRpbDsKLQotLyoqCi0gKiBDb250YWlucyB0aGUgaW5mb3JtYXRpb24gdXNlZCB0byBjdXN0b21pemUgdGhlIGRhdGFiYXNlIHNjaGVtYSB0byBPUk0gZW50aXR5IAotICogZ2VuZXJhdGlvbi4KLSAqIAotICogPHA+VGhlIGN1c3RvbWl6YXRpb24gc2V0dGluZ3MgYXJlIG1haW5seSBleHBvc2VkIGluIHRoZSBmb3JtIG9mIAotICogcHJvcGVydGllcy4gVGhlcmUgYXJlIG5vIGFzc3VtcHRpb25zIGluIHRoaXMgY2xhc3MgYWJvdXQgdGhlIG1lYW5pbmcgb2YgdGhlIAotICogcHJvcGVydHkgbmFtZXMuIFByb3BlcnRpZXMgY2FuIGJlIGFzc29jaWF0ZWQgdG8gc3BlY2lmaWMgdGFibGVzIGFuZCB0YWJsZSAKLSAqIGNvbHVtbnMsIG9yIGdsb2JhbGx5IGZvciBhbnkgdGFibGUgYW5kL29yIGNvbHVtbi4KLSAqIAotICogPHA+U3ViY2xhc3MgY2FuIGltcGxlbWVudCB0aGUgc2V0cyBvZiBhYnN0cmFjdCBtZXRob2RzIHRvIHByb3ZpZGUgT1JNIHZlbmRvcgotICogc3BlY2lmaWMgcHJvcGVydGllcy4KLSAqIAotICovCi1wdWJsaWMgYWJzdHJhY3QgY2xhc3MgT1JNR2VuQ3VzdG9taXplciBpbXBsZW1lbnRzIGphdmEuaW8uU2VyaWFsaXphYmxlCi17Ci0JcHJpdmF0ZSBmaW5hbCBzdGF0aWMgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMTsKLQotCS8qKgotCSAqIEEgdmFsdWUgcGFzc2VkIGZvciB0aGUgdGFibGUgbmFtZSBhcmd1bWVudCB0byBnZXQvc2V0UHJvcGVydHkgCi0JICogaW5kaWNhdGluZyB0aGF0IHRoZSB2YWx1ZSBhcHBsaWVzIHRvIGFueSB0YWJsZS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBBTllfVEFCTEUgPSAiX19hbnlUYWJsZV9fIjsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBHRU5FUkFURV9ERExfQU5OT1RBVElPTiA9ICJnZW5lcmF0ZURETEFubm90YXRpb25zIjsKLQkvKnRoZSBzdHJpbmcgdXNlZCBpbiB0aGUgcHJvcGVydHkgbmFtZSBpbiBtUHJvcHMgdG8gaW5kaWNhdGUgCi0JICogYSBudWxsIHRhYmxlIHZhbHVlLiovCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIE5VTExfVEFCTEUgPSAiIjsKLQkvKnRoZSBzdHJpbmcgdXNlZCBpbiB0aGUgcHJvcGVydHkgbmFtZSBpbiBtUHJvcHMgdG8gaW5kaWNhdGUgCi0JICogYSBudWxsIGNvbHVtbiB2YWx1ZS4qLwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBOVUxMX0NPTFVNTiA9ICIiOwotCQotCS8qVGhpcyB2ZXJzaW9uIG51bWJlciBpcyB3cml0dGVuIGluIHRoZSBoZWFkZXIgb2YgdGhlIGN1c3RvbWl6YXRpb24gc3RyZWFtCi0JICogYW5kIHJlYWQgYXQgZGUtc2VyaWFsaXphdGlvbiB0aW1lLCBpZiBpdCBpcyBkaWZmZXJlbnQgdGhlbiB0aGUgZmlsZSBpcyBpbnZhbGlkYXRlZC4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBpbnQgRklMRV9WRVJTSU9OID0gMjsKLQkKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgVVBEQVRFX0NPTkZJR19GSUxFID0gInVwZGF0ZUNvbmZpZ0ZpbGUiOwotCi0JcHJpdmF0ZSB0cmFuc2llbnQgU2NoZW1hIG1TY2hlbWE7Ci0JcHJpdmF0ZSB0cmFuc2llbnQgRmlsZSBtRmlsZTsKLQkKLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBtVGFibGVOYW1lczsKLQkvKmtleTogdGFibGUgbmFtZSwgdmFsdWU6IE9STUdlblRhYmxlIG9iamVjdC4qLwotCXByaXZhdGUgdHJhbnNpZW50IE1hcDxTdHJpbmcgLCBPUk1HZW5UYWJsZT4gbVRhYmxlczsKLQkvKnRoZSA8Y29kZT5Bc3NvY2lhdGlvbjwvY29kZT4gb2JqZWN0cyBzb3J0ZWQgYnkgdGhlaXIgImZyb20iIAotCSAqIHRhYmxlIG5hbWUuIEluY2x1ZGVzIGFsbCBhc3NvY2lhdGlvbiBkZXJpdmVkIGZyb20gZm9yZWlnbiBrZXlzIAotCSAqIGluIHVzZXIgc2VsZWN0ZWQgdGFibGVzLiBTaW5jZSBzb21lIG9mIHRoZSBmb3JlaWduIGtleXMgbWF5IHBvaW50IHRvIHRhYmxlCi0JICogdXNlciBkb2VzIG5vdCBzZWxlY3QsIHRoaXMgbGlzdCBtYXkgYmUgZGlmZmVyZW50IGZyb20gIG1WYWxpZEFzc29jaWF0aW9ucwotCSAqKi8KLQlwcml2YXRlIExpc3Q8QXNzb2NpYXRpb24+IG1Bc3NvY2lhdGlvbnM7Ci0JLyoKLQkgKiBMaXN0IG9mIHZhbGlkIGFzc29jaWF0aW9ucyB3aXRoaW4gdGhlIHVzZXIgc2VsZWN0ZWQgdGFibGVzICAKLQkgKiAqLwotCXByaXZhdGUgdHJhbnNpZW50IExpc3Q8QXNzb2NpYXRpb24+IG1WYWxpZEFzc29jaWF0aW9uczsKLQlwcml2YXRlIHRyYW5zaWVudCBib29sZWFuIG1JbnZhbGlkRm9yZWlnbkFzc29jaWF0aW9uczsKLQkKLQkvKnRoZSBwcm9wZXJ0eSBuYW1lIGlzIGluIHRoZSBmb3JtICR0YWJsZU5hbWUuJGNvbHVtbk5hbWUuJHByb3BlcnR5TmFtZS4KLQkgKiBXaGVyZSB0YWJsZU5hbWUgY291bGQgYmUgTlVMTF9UQUJMRSBvciBBTllfVEFCTEUKLQkgKiBhbmQgY29sdW1uTmFtZSBjb3VsZCBiZSBOVUxMX0NPTFVNTiovCi0JcHJpdmF0ZSBNYXA8U3RyaW5nLCBTdHJpbmc+IG1Qcm9wcyA9IG5ldyBqYXZhLnV0aWwuSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4oKTsKLQotCXByaXZhdGUgdHJhbnNpZW50IERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyIGRhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyID0gRGF0YWJhc2VBbm5vdGF0aW9uTmFtZUJ1aWxkZXIuRGVmYXVsdC5JTlNUQU5DRTsKLQkKLQkvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0JLy8tLS0tIGFic3RyYWN0IG1ldGhvZHMKLQkvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0JLyoqCi0JICogUmV0dXJucyBhbGwgdGhlIHByaW1hcnkga2V5IGdlbmVyYXRvciBzY2hlbWVzLgotCSAqIFRoaXMgY2FuIHJldHVybiBhbnkgc3RyaW5ncyBhcyBmYXIgYXMgdGhlIFZlbG9jaXR5IHRlbXBsYXRlIAotCSAqIHByb2Nlc3NvciB1bmRlcnN0YW5kIHRoZW0uCi0JICovCi0JcHVibGljIGFic3RyYWN0IExpc3Q8U3RyaW5nPiBnZXRBbGxJZEdlbmVyYXRvcnMoKTsKLQkvKioKLQkgKiBSZXR1cm5zIHRoZSBzdHJpbmcgcmVwcmVzZW50aW5nIHRoZSBkZXZlbG9wZXItYXNzaWduZWQgaWQgZ2VuZXJhdG9yLgotCSAqIFRoaXMgY2FuIHJldHVybiBhbnkgc3RyaW5ncyBhcyBmYXIgYXMgdGhlIFZlbG9jaXR5IHRlbXBsYXRlIAotCSAqIHByb2Nlc3NvciB1bmRlcnN0YW5kIHRoZW0uCi0JICovCi0JcHVibGljIGFic3RyYWN0IFN0cmluZyBnZXROb0lkR2VuZXJhdG9yKCk7Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgc3RyaW5nIHJlcHJlc2VudGluZyB0aGUgaWRlbnRpdHkgaWQgZ2VuZXJhdG9yLgotCSAqIFRoaXMgY2FuIHJldHVybiBhbnkgc3RyaW5ncyBhcyBmYXIgYXMgdGhlIFZlbG9jaXR5IHRlbXBsYXRlIAotCSAqIHByb2Nlc3NvciB1bmRlcnN0YW5kIHRoZW0uCi0JICovCi0JcHVibGljIGFic3RyYWN0IFN0cmluZyBnZXRJZGVudGl0eUlkR2VuZXJhdG9yKCk7Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgc3RyaW5ncyByZXByZXNlbnRpbmcgdGhlIHNlcXVlbmNlIGdlbmVyYXRvcnMuCi0JICogVGhpcyBjYW4gcmV0dXJuIGFueSBzdHJpbmdzIGFzIGZhciBhcyB0aGUgVmVsb2NpdHkgdGVtcGxhdGUgCi0JICogcHJvY2Vzc29yIHVuZGVyc3RhbmQgdGhlbS4KLQkgKi8KLQlwdWJsaWMgYWJzdHJhY3QgU2V0PFN0cmluZz4gZ2V0U2VxdWVuY2VJZEdlbmVyYXRvcnMoKTsKLQkvKioKLQkgKiBSZXR1cm5zIGEgcHJvcGVydHkgdHlwZSBmcm9tIHRoZSBnaXZlbiBkYXRhYmFzZSBjb2x1bW4uCi0JICogVGhpcyBjYW4gcmV0dXJuIGFueSBzdHJpbmdzIGFzIGZhciBhcyB0aGUgVmVsb2NpdHkgdGVtcGxhdGUgCi0JICogcHJvY2Vzc29yIHVuZGVyc3RhbmQgdGhlbS4KLQkgKi8KLQlwdWJsaWMgYWJzdHJhY3QgU3RyaW5nIGdldFByb3BlcnR5VHlwZUZyb21Db2x1bW4oQ29sdW1uIGNvbHVtbikgOwotCS8qKgotCSAqIFJldHVybnMgYWxsIHRoZSBzdHJpbmdzIHJlcHJlc2VudGluZyBwcm9wZXJ0eSB0eXBlcy4KLQkgKiBUaGlzIGNhbiByZXR1cm4gYW55IHN0cmluZ3MgYXMgZmFyIGFzIHRoZSBWZWxvY2l0eSB0ZW1wbGF0ZSAKLQkgKiBwcm9jZXNzb3IgdW5kZXJzdGFuZCB0aGVtLgotCSAqLwotCXB1YmxpYyBhYnN0cmFjdCBTdHJpbmdbXSBnZXRBbGxQcm9wZXJ0eVR5cGVzKCk7Ci0JLyoqCi0JICogUmV0dXJucyBhbGwgdGhlIHN0cmluZ3MgcmVwcmVzZW50aW5nIHByb3BlcnR5IG1hcHBpbmcga2luZHMuCi0JICogVGhpcyBjYW4gcmV0dXJuIGFueSBzdHJpbmdzIGFzIGZhciBhcyB0aGUgVmVsb2NpdHkgdGVtcGxhdGUgCi0JICogcHJvY2Vzc29yIHVuZGVyc3RhbmQgdGhlbS4KLQkgKi8KLQlwdWJsaWMgYWJzdHJhY3QgU3RyaW5nW10gZ2V0QWxsTWFwcGluZ0tpbmRzKCk7Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgYmFzaWMgKGRlZmF1bHQpIHByb3BlcnR5IG1hcHBpbmcga2luZC4KLQkgKiBUaGlzIGNhbiByZXR1cm4gYW55IHN0cmluZ3MgYXMgZmFyIGFzIHRoZSBWZWxvY2l0eSB0ZW1wbGF0ZSAKLQkgKiBwcm9jZXNzb3IgdW5kZXJzdGFuZCB0aGVtLgotCSAqLwotCXB1YmxpYyBhYnN0cmFjdCBTdHJpbmcgZ2V0QmFzaWNNYXBwaW5nS2luZCgpOwotCS8qKgotCSAqIFJldHVybnMgdGhlIGlkIChwcmltYXJ5IGtleSkgcHJvcGVydHkgbWFwcGluZyBraW5kLgotCSAqIFRoaXMgY2FuIHJldHVybiBhbnkgc3RyaW5ncyBhcyBmYXIgYXMgdGhlIFZlbG9jaXR5IHRlbXBsYXRlIAotCSAqIHByb2Nlc3NvciB1bmRlcnN0YW5kIHRoZW0uCi0JICovCi0JcHVibGljIGFic3RyYWN0IFN0cmluZyBnZXRJZE1hcHBpbmdLaW5kKCk7Ci0JLyoqCi0JICogSW50ZXJhY3RzIHdpdGggdGhlIHVzZXIgdG8gZWRpdCB0aGUgY2FzY2FkZSBvZiB0aGUgZ2l2ZW4gCi0JICogcm9sZS4KLQkgKiBUaGlzIG1ldGhvZCBzaG91bGQgYWxzbyBjYWxsIDxjb2RlPkFzc29jaWF0aW9uUm9sZS5zZXRDYXNjYWRlPC9jb2RlPi4KLQkgKiAKLQkgKiBAcmV0dXJuIGZhbHNlIGlmIHRoZSB1c2VyIGludGVyYWN0aW9uIGlzIGNhbmNlbGxlZC4KLQkgKi8KLQlwdWJsaWMgYWJzdHJhY3QgYm9vbGVhbiBlZGl0Q2FzY2FkZShBc3NvY2lhdGlvblJvbGUgcm9sZSk7Ci0JCi0JLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotCS8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLQotCS8qKgotCSAqIEBwYXJhbSBmaWxlIFRoZSBmaWxlIHRoYXQgY29udGFpbnMgdGhlIGN1c3RvbWl6YXRpb24gc2V0dGluZ3MuCi0JICogVGhlIGZpbGUgaXMgY3JlYXRlZCBpZiBuZWNlc3Nhcnkgd2hlbiB0aGUgPGNvZGU+c2F2ZTwvY29kZT4gCi0JICogbWV0aG9kIGlzIGNhbGxlZC4KLQkgKi8KLQlwdWJsaWMgdm9pZCBpbml0KCBGaWxlIGZpbGUsIFNjaGVtYSBzY2hlbWEpIHsKLQkJdGhpcy5tU2NoZW1hID0gc2NoZW1hOwotCQltRmlsZSA9IGZpbGU7Ci0JCQotCQlpZiAoIWZpbGUuZXhpc3RzKCkpIHsKLQkJCXNldFByb3BlcnR5KE9STUdlblRhYmxlLkRFRkFVTFRfRkVUQ0gsIE9STUdlblRhYmxlLkRFRkFVTFRfRkVUQ0gsIE9STUdlbkN1c3RvbWl6ZXIuQU5ZX1RBQkxFLCBudWxsKTsKLQkJCXJldHVybjsKLQkJfQotCQlJbnB1dFN0cmVhbSBpc3RyZWFtID0gbnVsbDsKLQkJT2JqZWN0SW5wdXRTdHJlYW0gb2lzID0gbnVsbDsKLQkJdHJ5IAotCQl7Ci0JCQkvL3JlYWQgaXQgaW4gYSBmaWxlIGZpcnN0IHRvIHNwZWVkdXAgZGVzZXJpYWxpemF0aW9uCi0JCQlieXRlW10gYnl0ZXMgPSBGaWxlVXRpbC5yZWFkRmlsZShmaWxlKTsKLQkJCWlzdHJlYW0gPSBuZXcgQnl0ZUFycmF5SW5wdXRTdHJlYW0oYnl0ZXMpOwotCQkJb2lzID0gbmV3IE9iamVjdElucHV0U3RyZWFtKGlzdHJlYW0pOwotCQkJCi0JCQlGaWxlSGVhZGVyIGhlYWRlciA9IChGaWxlSGVhZGVyKW9pcy5yZWFkT2JqZWN0KCk7Ci0JCQlpZiAoaGVhZGVyLm1WZXJzaW9uID09IEZJTEVfVkVSU0lPTikgewotCQkJCU9STUdlbkN1c3RvbWl6ZXIgY3VzdG9taXplciA9IChPUk1HZW5DdXN0b21pemVyKW9pcy5yZWFkT2JqZWN0KCk7Ci0JCQkJcmVzdG9yZShjdXN0b21pemVyKTsKLQkJCX0KLQkJfSBjYXRjaCAoRXhjZXB0aW9uIGV4KSB7Ci0JCQlTeXN0ZW0ub3V0LnByaW50bG4oIioqKk9STUdlbkN1c3RvbWl6ZXIubG9hZCBmYWlsZWQgIitmaWxlKyI6ICIgKyBleCk7CQkJCQotCQl9Ci0JCWZpbmFsbHkgCi0JCXsKLQkJCWlmIChvaXMgIT0gbnVsbCkKLQkJCXsKLQkJCQl0cnkgCi0JCQkJewotCQkJCQlvaXMuY2xvc2UoKTsKLQkJCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBlKSB7Ci0JCQkJfQotCQkJfQotCQkJCi0JCQlpZiAoaXN0cmVhbSAhPSBudWxsKQotCQkJewotCQkJCXRyeSAKLQkJCQl7Ci0JCQkJCWlzdHJlYW0uY2xvc2UoKTsKLQkJCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBlKSB7Ci0JCQkJfQotCQkJfQotCQl9Ci0JfQotCQotCXB1YmxpYyB2b2lkIHNldFNjaGVtYShTY2hlbWEgc2NoZW1hKXsKLQkJdGhpcy5tU2NoZW1hID0gc2NoZW1hOwotCX0KLQotCXB1YmxpYyBTY2hlbWEgZ2V0U2NoZW1hKCl7Ci0JCXJldHVybiBtU2NoZW1hOwotCX0KLQkKLQkvKioKLQkgKiBFbXB0eSBjb25zdHJ1Y3RvciBuZWVkZWQgYnkgdGhlIGRlc2VyaWFsaXphdGlvbi4KLQkgKi8KLQlwdWJsaWMgT1JNR2VuQ3VzdG9taXplcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQkvKioKLQkgKiBTYXZlcyB0aGUgY3VzdG9taXphdGlvbiBmaWxlLgotCSAqIFRoZSBmaWxlIGlzIGNyZWF0ZWQgaWYgbmVjZXNzYXJ5LgotCSAqLwotCXB1YmxpYyB2b2lkIHNhdmUoKSB0aHJvd3MgSU9FeGNlcHRpb24gewotCQkvL1N5c3RlbS5vdXQucHJpbnRsbigiLS0tT1JNR2VuQ3VzdG9taXplci5zYXZlOiAiICsgbUZpbGUpOwotCQlpZiAoIW1GaWxlLmV4aXN0cygpICYmICFtRmlsZS5jcmVhdGVOZXdGaWxlKCkpIHsKLQkJCXJldHVybjsKLQkJfQotCQlqYXZhLmlvLkZpbGVPdXRwdXRTdHJlYW0gZm9zID0gbnVsbDsKLQkJamF2YS5pby5PYmplY3RPdXRwdXRTdHJlYW0gb29zID0gbnVsbDsKLQkJYm9vbGVhbiBkZWxldGVJdCA9IHRydWU7Ci0JCXRyeSB7Ci0JCQlmb3MgPSBuZXcgamF2YS5pby5GaWxlT3V0cHV0U3RyZWFtKG1GaWxlKTsKLQkJCW9vcyA9IG5ldyBqYXZhLmlvLk9iamVjdE91dHB1dFN0cmVhbShmb3MpOwotCQkJRmlsZUhlYWRlciBoZWFkZXIgPSBuZXcgRmlsZUhlYWRlcigpOwotCQkJb29zLndyaXRlT2JqZWN0KGhlYWRlcik7Ci0JCQlvb3Mud3JpdGVPYmplY3QodGhpcyk7Ci0JCQlkZWxldGVJdCA9IGZhbHNlOwotCQl9IGNhdGNoIChFeGNlcHRpb24gZXgpIHsKLQkJCS8vZGVsZXRlSXQgaXMgdHJ1ZSwgc28gdGhlIGNhY2hlIGlzIG5vdCBzYXZlZC4KLQkJCUNvcmVFeGNlcHRpb24gY2UgPSBuZXcgQ29yZUV4Y2VwdGlvbihuZXcgU3RhdHVzKElTdGF0dXMuRVJST1IsIEpwdEdlblBsdWdpbi5QTFVHSU5fSUQsCi0JCQkJCSJVbmFibGUgdG8gc2F2ZSB0aGUgT1JNR2VuQ3VzdG9taXplciBmaWxlOiAiK21GaWxlLGV4KSk7Ci0JCQlKcHRHZW5QbHVnaW4ubG9nRXhjZXB0aW9uKCBjZSApOwotCQl9IGZpbmFsbHkgewotCQkJdHJ5IHsKLQkJCQlpZiAob29zIT1udWxsKSBvb3MuY2xvc2UoKTsKLQkJCQlpZiAoZm9zIT1udWxsKSBmb3MuY2xvc2UoKTsKLQkJCQlpZiAoZGVsZXRlSXQpIHsKLQkJCQkJbUZpbGUuZGVsZXRlKCk7Ci0JCQkJfQotCQkJfSBjYXRjaCAoamF2YS5pby5JT0V4Y2VwdGlvbiBleDIpIHt9CQotCQl9Ci0JfQotCQotCXB1YmxpYyBEYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlciBnZXREYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlcigpIHsKLQkJcmV0dXJuIHRoaXMuZGF0YWJhc2VBbm5vdGF0aW9uTmFtZUJ1aWxkZXI7Ci0JfQotCXB1YmxpYyB2b2lkIHNldERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyKERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyIGRhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyKSB7Ci0JCWlmIChkYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlciA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oImRhdGFiYXNlIGFubm90YXRpb24gbmFtZSBidWlsZGVyIGlzIHJlcXVpcmVkIik7ICAvLyROT04tTkxTLTEkCi0JCX0KLQkJdGhpcy5kYXRhYmFzZUFubm90YXRpb25OYW1lQnVpbGRlciA9IGRhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyOwotCX0JCi0KLQkvKioKLQkgKiBSZXR1cm5zIHtAbGluayAjR0VORVJBVEVfRERMX0FOTk9UQVRJT059ICBpbmRpY2F0aW5nIHdoZXRoZXIKLQkgKiB0aGUgb3B0aW9uYWwgRERMIHBhcmFtZXRlcnMgbGlrZSBsZW5ndGgsIG51bGxhYmxlLCB1bnFpdWUsIGV0YyBzaG91bGQgYmUgZ2VuZXJhdGVkIAotCSAqIGluIEBDb2x1bW4gYW5ub3RhdGlvbi4KLQkgKiBkZWZhdWx0cyB0byBmYWxzZS4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBpc0dlbmVyYXRlRERMQW5ub3RhdGlvbnMoKSB7Ci0JCXJldHVybiAidHJ1ZSIuZXF1YWxzKGdldFByb3BlcnR5KEdFTkVSQVRFX0RETF9BTk5PVEFUSU9OLCBBTllfVEFCTEUsIG51bGwpKTsgLy9kZWZhdWx0cyB0byBmYWxzZQotCX0KLQotCS8qKgotCSAqIFJldHVybnMgYSBwcm9wZXJ0eSB2YWx1ZS4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdldFByb3BlcnR5KFN0cmluZyBwcm9wZXJ0eU5hbWUsIFN0cmluZyB0YWJsZU5hbWUsIFN0cmluZyBjb2xOYW1lKSB7Ci0JCVN0cmluZyBrZXkgPSBnZXRQcm9wS2V5KHByb3BlcnR5TmFtZSwgdGFibGVOYW1lLCBjb2xOYW1lKTsKLQkJU3RyaW5nIHZhbHVlID0gKFN0cmluZyltUHJvcHMuZ2V0KGtleSk7Ci0JCS8qaWYgdGhlIGtleSBkb2VzIG5vdCBleGlzdCBhbmQgaXQgaXMgYSB0YWJsZSBwcm9wZXJ0eSB0aGVuIAotCQkgKiBnZXQgdGhlIGRlZmF1bHQgdGFibGUgcHJvcGVydHkuKi8KLQkJaWYgKHZhbHVlID09IG51bGwgJiYgdGFibGVOYW1lICE9IG51bGwgJiYgY29sTmFtZSA9PSBudWxsICYmICF0YWJsZU5hbWUuZXF1YWxzKEFOWV9UQUJMRSkpIHsKLQkJCXZhbHVlID0gZ2V0UHJvcGVydHkocHJvcGVydHlOYW1lLCBBTllfVEFCTEUsIGNvbE5hbWUpOwotCQl9Ci0JCXJldHVybiB2YWx1ZTsKLQl9Ci0JLyoqCi0JICogQ2hhbmdlcyBhIHByb3BlcnR5IHZhbHVlLgotCSAqIAotCSAqIEBwYXJhbSB2YWx1ZSBUaGUgbmV3IHZhbHVlLCBjb3VsZCBiZSBudWxsLgotCSAqLwotCXB1YmxpYyB2b2lkIHNldFByb3BlcnR5KFN0cmluZyBwcm9wZXJ0eU5hbWUsIFN0cmluZyB2YWx1ZSwgU3RyaW5nIHRhYmxlTmFtZSwgU3RyaW5nIGNvbE5hbWUpIHsKLQkJU3RyaW5nIGtleSA9IGdldFByb3BLZXkocHJvcGVydHlOYW1lLCB0YWJsZU5hbWUsIGNvbE5hbWUpOwotCQlpZiAodmFsdWUgIT0gbnVsbCkgewotCQkJbVByb3BzLnB1dChrZXksIHZhbHVlKTsKLQkJfSBlbHNlIHsKLQkJCW1Qcm9wcy5yZW1vdmUoa2V5KTsKLQkJfQotCX0KLQkvKioKLQkgKiBTYW1lIGFzIHtAbGluayAjZ2V0UHJvcGVydHkoU3RyaW5nLCBTdHJpbmcsIFN0cmluZyl9IGJ1dCAKLQkgKiBjb252ZXJ0cyB0aGUgdmFsdWUgdG8gYm9vbGVhbi4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBnZXRCb29sZWFuUHJvcGVydHkoU3RyaW5nIHByb3BlcnR5TmFtZSwgU3RyaW5nIHRhYmxlTmFtZSwgU3RyaW5nIGNvbE5hbWUpIHsKLQkJU3RyaW5nIHZhbHVlID0gZ2V0UHJvcGVydHkocHJvcGVydHlOYW1lLCB0YWJsZU5hbWUsIGNvbE5hbWUpOwotCQlyZXR1cm4gInRydWUiLmVxdWFscyh2YWx1ZSk7Ci0JfQotCS8qKgotCSAqIENoYW5nZXMgYSB0YWJsZSBib29sZWFuIHByb3BlcnR5IHZhbHVlLgotCSAqLwotCXB1YmxpYyB2b2lkIHNldEJvb2xlYW5Qcm9wZXJ0eShTdHJpbmcgcHJvcGVydHlOYW1lLCBib29sZWFuIHZhbHVlLCBTdHJpbmcgdGFibGVOYW1lLCBTdHJpbmcgY29sTmFtZSkgewotCQlzZXRQcm9wZXJ0eShwcm9wZXJ0eU5hbWUsIHZhbHVlID8gInRydWUiIDogImZhbHNlIiwgdGFibGVOYW1lLCBjb2xOYW1lKTsKLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgbmFtZXMgb2YgdGhlIHRhYmxlcyB0byBnZW5lcmF0ZS4KLQkgKi8KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwdWJsaWMgTGlzdDxTdHJpbmc+IGdldFRhYmxlTmFtZXMoKSB7Ci0JCXJldHVybiBtVGFibGVOYW1lcyAhPSBudWxsID8gbVRhYmxlTmFtZXMgOiBqYXZhLnV0aWwuQ29sbGVjdGlvbnMuRU1QVFlfTElTVDsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJucyB0aGUgZmV0Y2ggdHlwZSBhbm5vdGF0aW9uIG1lbWJlciB2YWx1ZSwgb3IgZW1wdHkgc3RyaW5nIAotCSAqIGlmIG5vbmUuCi0JICogRW1wdHkgc3RyaW5nIGlzIHJldHVybmVkIGluc3RlYWQgb2YgbnVsbCBiZWNhdXNlIFZlbG9jaXR5IGRvZXMgbm90IGxpa2UgbnVsbCAKLQkgKiB3aGVuIHVzZWQgaW4gI3NldC4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdlbkZldGNoKE9STUdlblRhYmxlIHRhYmxlKSB7Ci0JCXJldHVybiAiIjsKLQl9CQotCS8qKgotCSAqIENhbGxlZCB3aGVuIHRoZSB0YWJsZSB1c2VyIHNlbGVjdGlvbiBpcyBjaGFuZ2VkIGluIHRoZSAKLQkgKiBnZW5lcmF0aW9uIHdpemFyZC4KLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRUYWJsZU5hbWVzKExpc3Q8U3RyaW5nPiB0YWJsZU5hbWVzKSB7Ci0JCW1UYWJsZU5hbWVzID0gdGFibGVOYW1lczsKLQkJbVRhYmxlcyA9IG51bGw7Ci0JCW1WYWxpZEFzc29jaWF0aW9ucyA9IG51bGw7IC8vcmVjb21wdXRlCi0JCW1JbnZhbGlkRm9yZWlnbkFzc29jaWF0aW9ucyA9IHRydWU7IC8vbWFrZSBzdXJlIGZvcmVpZ24gYXNzb2NpYXRpb25zIGZyb20gbmV3bHkgYWRkZWQgdGFibGVzIGFyZSBjb21wdXRlZC4KLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgdGFibGUgbmFtZXMgdG8gYmUgZ2VuZXJhdGVkLgotCSAqIFRoaXMgbWlnaHQgYmUgZGlmZmVyZW50IGZyb20gPGNvZGU+Z2V0VGFibGVOYW1lczwvY29kZT4gaWYgdGhlcmUgCi0JICogYXJlIG1hbnktdG8tbWFueSBqb2luIHRhYmxlcyBhbmQgYXJlIG5vdCBjb250cmlidXRpbmcgCi0JICogaW4gYW55IG90aGVyIGFzc29jaWF0aW9ucy4KLQkgKi8KLQlwdWJsaWMgTGlzdDxTdHJpbmc+IGdldEdlblRhYmxlTmFtZXMoKSAgewotCQlMaXN0PFN0cmluZz4gbmFtZXMgPSBnZXRUYWJsZU5hbWVzKCk7Ci0JCUxpc3Q8U3RyaW5nPiByZXN1bHQgPSBuZXcgamF2YS51dGlsLkFycmF5TGlzdDxTdHJpbmc+KG5hbWVzLnNpemUoKSk7Ci0JCQotCQkvKmZpbHRlciBvdXQgam9pbiB0YWJsZXMqLwotCQlMaXN0PEFzc29jaWF0aW9uPiBhc3NvY2lhdGlvbnMgPSBnZXRBc3NvY2lhdGlvbnMoKTsKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHRhYmxlTmFtZXNJdGVyID0gbmFtZXMuaXRlcmF0b3IoKTsgdGFibGVOYW1lc0l0ZXIuaGFzTmV4dCgpOyApIHsKLQkJCVN0cmluZyB0YWJsZU5hbWUgPSAoU3RyaW5nKXRhYmxlTmFtZXNJdGVyLm5leHQoKTsKLQkJCWJvb2xlYW4gaXNWYWxpZCA9IHRydWU7Ci0JCQkKLQkJCWZvciAoSXRlcmF0b3I8QXNzb2NpYXRpb24+IGFzc29jSXRlciA9IGFzc29jaWF0aW9ucy5pdGVyYXRvcigpOyBhc3NvY0l0ZXIuaGFzTmV4dCgpOyApIHsKLQkJCQlBc3NvY2lhdGlvbiBhc3NvY2lhdGlvbiA9IChBc3NvY2lhdGlvbilhc3NvY0l0ZXIubmV4dCgpOwotCQkJCWlmICghYXNzb2NpYXRpb24uaXNHZW5lcmF0ZWQoKSkgewotCQkJCQljb250aW51ZTsKLQkJCQl9Ci0JCQkJaWYgKHRhYmxlTmFtZS5lcXVhbHMoYXNzb2NpYXRpb24uZ2V0UmVmZXJyZXJUYWJsZU5hbWUoKSkKLQkJCQkJCXx8IHRhYmxlTmFtZS5lcXVhbHMoYXNzb2NpYXRpb24uZ2V0UmVmZXJlbmNlZFRhYmxlTmFtZSgpKSkgewotCQkJCQlpc1ZhbGlkID0gdHJ1ZTsKLQkJCQkJYnJlYWs7Ci0JCQkJfQotCQkJCWlmICh0YWJsZU5hbWUuZXF1YWxzKGFzc29jaWF0aW9uLmdldEpvaW5UYWJsZU5hbWUoKSkpIHsKLQkJCQkJaXNWYWxpZCA9IGZhbHNlOwotCQkJCX0KLQkJCX0KLQkJCWlmIChpc1ZhbGlkKSB7Ci0JCQkJcmVzdWx0LmFkZCh0YWJsZU5hbWUpOwotCQkJfQotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCS8qKgotCSAqIFJldHVybnMgYW4gPGNvZGU+T1JNR2VuVGFibGU8L2NvZGU+IG9iamVjdCBnaXZlbiBpdHMgbmFtZSwgb3IgCi0JICogbnVsbCBpZiBub25lLgotCSAqLwotCXB1YmxpYyBPUk1HZW5UYWJsZSBnZXRUYWJsZShTdHJpbmcgdGFibGVOYW1lKSAgewotCQlpZiAobVRhYmxlcyA9PSBudWxsKSB7Ci0JCQltVGFibGVzID0gbmV3IGphdmEudXRpbC5IYXNoTWFwPFN0cmluZywgT1JNR2VuVGFibGU+KG1UYWJsZU5hbWVzLnNpemUoKSk7Ci0JCX0KLQkJCi0JCWlmKG1UYWJsZU5hbWVzIT1udWxsICYmIG1TY2hlbWEhPW51bGwpewotCQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IGl0ZXIgPSBtVGFibGVOYW1lcy5pdGVyYXRvcigpOyBpdGVyLmhhc05leHQoKTsgKSB7Ci0JCQkJU3RyaW5nIG5hbWUgPSAoU3RyaW5nKWl0ZXIubmV4dCgpOwotCQkJCVRhYmxlIGRiVGFibGUgPSBtU2NoZW1hLmdldFRhYmxlTmFtZWQoIG5hbWUgKTsKLQkJCQlpZiAoZGJUYWJsZSAhPSBudWxsKSB7Ci0JCQkJCW1UYWJsZXMucHV0KG5hbWUsIGNyZWF0ZUdlblRhYmxlKGRiVGFibGUpKTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIChPUk1HZW5UYWJsZSltVGFibGVzLmdldCh0YWJsZU5hbWUpOwotCX0KLQkvKioKLQkgKiBSZXR1cm5zIHRoZSA8Y29kZT5Bc3NvY2lhdGlvbjwvY29kZT4gb2JqZWN0cyBzb3J0ZWQgYnkgdGhlaXIgImZyb20iIAotCSAqIHRhYmxlIG5hbWUuCi0JICovCi0JcHVibGljIExpc3Q8QXNzb2NpYXRpb24+IGdldEFzc29jaWF0aW9ucygpewotCQlyZXR1cm4gZ2V0QXNzb2NpYXRpb25zKHRydWUvKnZhbGlkT25seSovKTsKLQl9Ci0JLyoqCi0JICogQWRkcyB0aGUgZ2l2ZW4gYXNzb2NpYXRpb24uCi0JICovCi0JcHVibGljIHZvaWQgYWRkQXNzb2NpYXRpb24oQXNzb2NpYXRpb24gYXNzb2NpYXRpb24pICB7Ci0JCWdldEFzc29jaWF0aW9ucyhmYWxzZS8qdmFsaWRPbmx5Ki8pLmFkZChhc3NvY2lhdGlvbik7Ci0JCWlmIChtVmFsaWRBc3NvY2lhdGlvbnMgIT0gbnVsbCkgewotCQkJbVZhbGlkQXNzb2NpYXRpb25zLmFkZChhc3NvY2lhdGlvbik7Ci0JCX0KLQkJCi0JfQotCS8qKgotCSAqIERlbGV0ZXMgdGhlIGdpdmVuIGFzc29jaWF0aW9uLgotCSAqLwotCXB1YmxpYyB2b2lkIGRlbGV0ZUFzc29jaWF0aW9uKEFzc29jaWF0aW9uIGFzc29jaWF0aW9uKSAgewotCQlib29sZWFuIHJlbW92ZWQgPSBnZXRBc3NvY2lhdGlvbnMoZmFsc2UvKnZhbGlkT25seSovKS5yZW1vdmUoYXNzb2NpYXRpb24pOwotCQlhc3NlcnQocmVtb3ZlZCk7Ci0JCQotCQlpZiAobVZhbGlkQXNzb2NpYXRpb25zICE9IG51bGwpIHsKLQkJCXJlbW92ZWQgPSBtVmFsaWRBc3NvY2lhdGlvbnMucmVtb3ZlKGFzc29jaWF0aW9uKTsKLQkJCWFzc2VydChyZW1vdmVkKTsKLQkJfQotCX0KLQkvKioKLQkgKiBSZXR1cm5zIHRydWUgaWYgYW4gYXNzb2NpYXRpb24gc2ltaWxhciB0byB0aGUgZ2l2ZW4gYXNzb2NpYXRpb24gCi0JICogYWxyZWFkeSBleGlzdHMuCi0JICogVGhpcyBpcyBkZWNpZGVkIGJhc2VkIG9ubHkgb24gdGhlIGFzc29jaWF0aW9uIHRhYmxlcyBhbmQgY29sdW1ucy4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBzaW1pbGFyQXNzb2NpYXRpb25FeGlzdHMoQXNzb2NpYXRpb24gYXNzb2NpYXRpb24pIHsKLQkJdHJ5IHsKLQkJCWZvciAoSXRlcmF0b3I8QXNzb2NpYXRpb24+IGl0ZXIgPSBnZXRBc3NvY2lhdGlvbnMoZmFsc2UvKnZhbGlkT25seSovKS5pdGVyYXRvcigpOyBpdGVyLmhhc05leHQoKTsgKSB7Ci0JCQkJQXNzb2NpYXRpb24gYXNzb2NpYXRpb24yID0gKEFzc29jaWF0aW9uKWl0ZXIubmV4dCgpOwotCQkJCWlmICghYXNzb2NpYXRpb24uZ2V0UmVmZXJyZXJUYWJsZU5hbWUoKS5lcXVhbHMoYXNzb2NpYXRpb24yLmdldFJlZmVycmVyVGFibGVOYW1lKCkpCi0JCQkJCQl8fCAhYXNzb2NpYXRpb24uZ2V0UmVmZXJlbmNlZFRhYmxlTmFtZSgpLmVxdWFscyhhc3NvY2lhdGlvbjIuZ2V0UmVmZXJlbmNlZFRhYmxlTmFtZSgpKQotCQkJCQkJfHwgIVN0cmluZ1V0aWwuZXF1YWxPYmplY3RzKGFzc29jaWF0aW9uLmdldEpvaW5UYWJsZU5hbWUoKSwgYXNzb2NpYXRpb24yLmdldEpvaW5UYWJsZU5hbWUoKSkKLQkJCQkJCXx8ICFhc3NvY2lhdGlvbi5nZXRSZWZlcnJlckNvbHVtbk5hbWVzKCkuZXF1YWxzKGFzc29jaWF0aW9uMi5nZXRSZWZlcnJlckNvbHVtbk5hbWVzKCkpCi0JCQkJCQl8fCAhYXNzb2NpYXRpb24uZ2V0UmVmZXJlbmNlZENvbHVtbk5hbWVzKCkuZXF1YWxzKGFzc29jaWF0aW9uMi5nZXRSZWZlcmVuY2VkQ29sdW1uTmFtZXMoKSkKLQkJCQkJCSkgewotCQkJCQljb250aW51ZTsKLQkJCQl9CQkJCQkKLQkJCQkvKnRoZSAyIGFzc29jaWF0aW9uIGhhdmUgdGhlIHNhbWUgcmVmZXJyZXIsIHJlZmVyZW5jZWQgYW5kIGpvaW4gdGFibGUqLwotCQkJCWlmIChhc3NvY2lhdGlvbi5nZXRKb2luVGFibGVOYW1lKCkgPT0gbnVsbCkgewotCQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCQl9Ci0JCQkJaWYgKGFzc29jaWF0aW9uLmdldFJlZmVycmVySm9pbkNvbHVtbk5hbWVzKCkuZXF1YWxzKGFzc29jaWF0aW9uMi5nZXRSZWZlcnJlckpvaW5Db2x1bW5OYW1lcygpKQotCQkJCQkJJiYgYXNzb2NpYXRpb24uZ2V0UmVmZXJlbmNlZEpvaW5Db2x1bW5OYW1lcygpLmVxdWFscyhhc3NvY2lhdGlvbjIuZ2V0UmVmZXJlbmNlZEpvaW5Db2x1bW5OYW1lcygpKSkgewotCQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0gY2F0Y2ggKEV4Y2VwdGlvbiBlKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQkvKioKLQkgKiBDcmVhdGVzIHRoZSA8Y29kZT5PUk1HZW5UYWJsZTwvY29kZT4gaW5zdGFuY2UuIAotCSAqLwotCXB1YmxpYyBPUk1HZW5UYWJsZSBjcmVhdGVHZW5UYWJsZShUYWJsZSBkYlRhYmxlKSB7Ci0JCXJldHVybiBuZXcgT1JNR2VuVGFibGUoZGJUYWJsZSwgdGhpcyk7Ci0JfQotCS8qKgotCSAqIENyZWF0ZXMgdGhlIDxjb2RlPk9STUdlbkNvbHVtbjwvY29kZT4gaW5zdGFuY2UuCi0JICovCi0JcHJvdGVjdGVkIE9STUdlbkNvbHVtbiBjcmVhdGVHZW5Db2x1bW4oQ29sdW1uIGRiQ29sKSB7Ci0JCXJldHVybiBuZXcgT1JNR2VuQ29sdW1uKGRiQ29sLCB0aGlzKTsKLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0cnVlIG9mIHRoZSB1bmRlcmx5aW5nIHBlcnNpc3RlbmNlIHNwZWNzIHJlcXVpcmUgdGhlICJtYW55IiBzaWRlIAotCSAqIG9mIGFuIGFzc29jaWF0aW9uIHRvIGJlIHRoZSBvd25lciAobGlrZSBFSkIzKS4KLQkgKi8KLQlwcm90ZWN0ZWQgYm9vbGVhbiBtYW55U2lkZUlzQXNzb2NpYXRpb25Pd25lcigpIHsKLQkJcmV0dXJuIGZhbHNlOwotCX0KLQlwdWJsaWMgYm9vbGVhbiBpc1VwZGF0ZUNvbmZpZ0ZpbGUoKSB7Ci0JCXJldHVybiAhImZhbHNlIi5lcXVhbHMoZ2V0UHJvcGVydHkoVVBEQVRFX0NPTkZJR19GSUxFLCBudWxsLCBudWxsKSk7IC8vZGVmYXVsdHMgdG8gdHJ1ZQotCX0KLQlwdWJsaWMgdm9pZCBzZXRVcGRhdGVDb25maWdGaWxlKGJvb2xlYW4gdmFsdWUpIHsKLQkJaWYgKHZhbHVlKSB7IC8vZGVmYXVsdCBpcyB0cnVlCi0JCQlzZXRQcm9wZXJ0eShVUERBVEVfQ09ORklHX0ZJTEUsIG51bGwsIG51bGwsIG51bGwpOyAvL3JlbW92ZSBpdAotCQl9IGVsc2UgewotCQkJc2V0Qm9vbGVhblByb3BlcnR5KFVQREFURV9DT05GSUdfRklMRSwgdmFsdWUsIG51bGwsIG51bGwpOwotCQl9Ci0JfQotCi0JLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotCS8vLS0tLSBWZWxvY2l0eSB0ZW1wbGF0ZXMgbWV0aG9kcwotCS8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLQkvKioKLQkgKiBSZXR1cm5zIGEgZ2V0dGVyIG1ldGhvZCBuYW1lIGdpdmVuIGEgcHJvcGVydHkgbmFtZS4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIHByb3BlcnR5R2V0dGVyKFN0cmluZyBwcm9wZXJ0eU5hbWUpIHsKLQkJcmV0dXJuICJnZXQiK1N0cmluZ1V0aWwuaW5pdFVwcGVyKHByb3BlcnR5TmFtZSk7Ci0JfQotCS8qKgotCSAqIFJldHVybnMgYSBzZXR0ZXIgbWV0aG9kIG5hbWUgZ2l2ZW4gYSBwcm9wZXJ0eSBuYW1lLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgcHJvcGVydHlTZXR0ZXIoU3RyaW5nIHByb3BlcnR5TmFtZSkgewotCQlyZXR1cm4gInNldCIrU3RyaW5nVXRpbC5pbml0VXBwZXIocHJvcGVydHlOYW1lKTsKLQl9Ci0JcHVibGljIFN0cmluZyBxdW90ZShTdHJpbmcgcykgewotCQlyZXR1cm4gU3RyaW5nVXRpbC5xdW90ZShzLCAnIicpOwotCX0KLQlwdWJsaWMgU3RyaW5nIHF1b3RlKGJvb2xlYW4gYikgewotCQlyZXR1cm4gcXVvdGUoU3RyaW5nLnZhbHVlT2YoYikpOwotCX0KLQlwdWJsaWMgU3RyaW5nIHF1b3RlKGludCBpKSB7Ci0JCXJldHVybiBxdW90ZShTdHJpbmcudmFsdWVPZihpKSk7Ci0JfQotCS8qKgotCSAqIEFwcGVuZHMgYW4gYW5ub3RhdGlvbiBtZW1iZXIgbmFtZSBhbmQgdmFsdWUgdG8gYW4gZXhpc3RpbmcgYW5ub3RhdGlvbi4KLQkgKiAKLQkgKiBAcGFyYW0gcyBUaGUgYW5ub3RhdGlvbiBtZW1iZXJzIHN0cmluZy4KLQkgKgotCSAqIEBwYXJhbSBtZW1iZXJWYWx1ZSBUaGUgbWVtYmVyIHZhbHVlLCBpZiBudWxsIG9yIGVtcHR5IHN0cmluZ3MgdGhlbiAKLQkgKiBub3RoaW5nIGlzIGFwcGVuZWQuCi0JICogCi0JICogQHBhcmFtIHdoZXRoZXIgdG8gZG91YmxlIHF1b3RlIHRoZSBtZW1iZXIgdmFsdWUuCi0JICovCi0JcHVibGljIFN0cmluZyBhcHBlbmRBbm5vdGF0aW9uKFN0cmluZyBzLCBTdHJpbmcgbWVtYmVyTmFtZSwgU3RyaW5nIG1lbWJlclZhbHVlLCBib29sZWFuIHF1b3RlKSB7Ci0JCWlmIChtZW1iZXJWYWx1ZSA9PSBudWxsIHx8IG1lbWJlclZhbHVlLmxlbmd0aCgpID09IDApIHsKLQkJCXJldHVybiBzOwotCQl9Ci0JCVN0cmluZ0J1ZmZlciBidWZmZXIgPSBuZXcgU3RyaW5nQnVmZmVyKHMpOwotCQlpZiAoYnVmZmVyLmxlbmd0aCgpICE9IDApIHsKLQkJCWJ1ZmZlci5hcHBlbmQoIiwgIik7Ci0JCX0KLQkJYnVmZmVyLmFwcGVuZChtZW1iZXJOYW1lKTsKLQkJYnVmZmVyLmFwcGVuZCgnPScpOwotCQlpZiAocXVvdGUpIHsKLQkJCWJ1ZmZlci5hcHBlbmQoJyInKTsKLQkJfQotCQlidWZmZXIuYXBwZW5kKG1lbWJlclZhbHVlKTsKLQkJaWYgKHF1b3RlKSB7Ci0JCQlidWZmZXIuYXBwZW5kKCciJyk7Ci0JCX0KLQkJcmV0dXJuIGJ1ZmZlci50b1N0cmluZygpOwotCX0KLQlwdWJsaWMgYm9vbGVhbiBpc0pESzFfNSgpIHsKLQkJcmV0dXJuIHRydWU7Ci0JfQotCQotCS8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLQkvLy0tLS0gcHJpdmF0ZSBtZXRob2RzCi0JLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotCS8qKgotCSAqIFJlc3RvcmVzIHRoZSBjdXN0b21pemF0aW9uIHNldHRpbmdzIGZyb20gdGhlIGdpdmVuIAotCSAqIChwZXJzaXN0ZWQpIGN1c3RvbWl6ZXIuCi0JICovCi0JcHJpdmF0ZSB2b2lkIHJlc3RvcmUoT1JNR2VuQ3VzdG9taXplciBjdXN0b21pemVyKSAgewotCQltVGFibGVOYW1lcyA9IGN1c3RvbWl6ZXIubVRhYmxlTmFtZXM7Ci0JCW1Bc3NvY2lhdGlvbnMgPSBjdXN0b21pemVyLm1Bc3NvY2lhdGlvbnM7Ci0JCW1Qcm9wcyA9IGN1c3RvbWl6ZXIubVByb3BzOwotCQlpZiggbVNjaGVtYSA9PSBudWxsICkKLQkJCXJldHVybjsKLQkJCi0JCS8qcmVtb3ZlIGludmFsaWQgdGFibGUgbmFtZXMqLwotCQlmb3IgKGludCBpID0gbVRhYmxlTmFtZXMuc2l6ZSgpLTE7IGkgPj0gMDsgLS1pKSB7Ci0JCQlTdHJpbmcgdGFibGVOYW1lID0gKFN0cmluZyltVGFibGVOYW1lcy5nZXQoaSk7Ci0JCQlpZiAobVNjaGVtYS5nZXRUYWJsZU5hbWVkKCB0YWJsZU5hbWUpID09IG51bGwpIHsKLQkJCQltVGFibGVOYW1lcy5yZW1vdmUoaSk7Ci0JCQl9Ci0JCX0KLQkJaWYoIG1Bc3NvY2lhdGlvbnMhPW51bGwgKXsKLQkJCS8qcmVzdG9yZSB0aGUgYXNzb2NpYXRpb25zKi8KLQkJCWZvciAoSXRlcmF0b3I8QXNzb2NpYXRpb24+IGl0ZXIgPSBtQXNzb2NpYXRpb25zLml0ZXJhdG9yKCk7IGl0ZXIuaGFzTmV4dCgpOyApIHsKLQkJCQlBc3NvY2lhdGlvbiBhc3NvY2lhdGlvbiA9IChBc3NvY2lhdGlvbilpdGVyLm5leHQoKTsKLQkJCQlhc3NvY2lhdGlvbi5yZXN0b3JlKHRoaXMpOwotCQkJfQotCQkJLyphZGQgdGhlIGZvcmVpZ24ga2V5cyBhc3NvY2lhdGlvbnMganVzdCBpbiBjYXNlIHRoZSB0YWJsZXMgY2hhbmdlZCBzaW5jZSAKLQkJCSAqIHRoZSBsYXN0IHRpbWUgdGhlIHN0YXRlIHdhcyBwZXJzaXN0ZWQuIFBhc3MgY2hlY2tFeGlzdGluZyB0cnVlIHNvIHRoYXQgdGhlIAotCQkJICogYXNzb2NpYXRpb25zIHJlc3RvcmVkIGFib3ZlIGFyZSBub3Qgb3ZlcndyaXR0ZW4uKi8KLQkJCWFkZEZvcmVpZ25LZXlBc3NvY2lhdGlvbnModHJ1ZS8qY2hlY2tFeGlzdGluZyovKTsKLQkJfQotCX0KLQkvKioKLQkgKiBSZXR1cm5zIHRoZSBrZXkgaW4gbVByb3BzIGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCAKLQkgKiBwcm9wZXJ0eU5hbWUsIHRhYmxlIGFuZCBjb2x1bW4uCi0JICovCi0JcHJpdmF0ZSBTdHJpbmcgZ2V0UHJvcEtleShTdHJpbmcgcHJvcGVydHlOYW1lLCBTdHJpbmcgdGFibGVOYW1lLCBTdHJpbmcgY29sTmFtZSkgewotCQlpZiAodGFibGVOYW1lID09IG51bGwpIHsKLQkJCXRhYmxlTmFtZSA9IE5VTExfVEFCTEU7Ci0JCX0KLQkJaWYgKGNvbE5hbWUgPT0gbnVsbCkgewotCQkJY29sTmFtZSA9IE5VTExfQ09MVU1OOwotCQl9Ci0JCXJldHVybiB0YWJsZU5hbWUgKyAnLicgKyBjb2xOYW1lICsgJy4nICsgcHJvcGVydHlOYW1lOwotCX0KLQkvKioKLQkgKiBSZXR1cm5zIHRoZSBhc3NvY2lhdGlvbnMgdGhhdCBhcmUgdmFsaWQgZm9yIHRoZSAKLQkgKiBjdXJyZW50IHRhYmxlcy4KLQkgKi8KLQlwcml2YXRlIExpc3Q8QXNzb2NpYXRpb24+IGdldEFzc29jaWF0aW9ucyhib29sZWFuIHZhbGlkT25seSl7Ci0JCWlmIChtQXNzb2NpYXRpb25zID09IG51bGwpIHsKLQkJCW1Bc3NvY2lhdGlvbnMgPSBuZXcgamF2YS51dGlsLkFycmF5TGlzdDxBc3NvY2lhdGlvbj4oKTsKLQkJCQotCQkJYWRkRm9yZWlnbktleUFzc29jaWF0aW9ucyhmYWxzZS8qY2hlY2tFeGlzdGluZyovKTsKLQkJfSBlbHNlIGlmIChtSW52YWxpZEZvcmVpZ25Bc3NvY2lhdGlvbnMpIHsKLQkJCW1JbnZhbGlkRm9yZWlnbkFzc29jaWF0aW9ucyA9IGZhbHNlOwotCQkJCi0JCQlhZGRGb3JlaWduS2V5QXNzb2NpYXRpb25zKHRydWUvKmNoZWNrRXhpc3RpbmcqLyk7Ci0JCX0KLQkJTGlzdDxBc3NvY2lhdGlvbj4gYXNzb2NpYXRpb25zOwotCQlpZiAodmFsaWRPbmx5KSB7Ci0JCQlpZiAobVZhbGlkQXNzb2NpYXRpb25zID09IG51bGwpIHsKLQkJCQkvKmZpbHRlciBvdXQgdGhlIGludmFsaWQgYXNzb2NpYXRpb25zKi8KLQkJCQltVmFsaWRBc3NvY2lhdGlvbnMgPSBuZXcgQXJyYXlMaXN0PEFzc29jaWF0aW9uPihtQXNzb2NpYXRpb25zLnNpemUoKSk7Ci0JCQkJZm9yIChpbnQgaSA9IDAsIG4gPSBtQXNzb2NpYXRpb25zLnNpemUoKTsgaSA8IG47ICsraSkgewotCQkJCQlBc3NvY2lhdGlvbiBhc3NvY2lhdGlvbiA9IChBc3NvY2lhdGlvbiltQXNzb2NpYXRpb25zLmdldChpKTsKLQkJCQkJaWYgKGFzc29jaWF0aW9uLmlzVmFsaWQoKSkgewotCQkJCQkJbVZhbGlkQXNzb2NpYXRpb25zLmFkZChhc3NvY2lhdGlvbik7Ci0JCQkJCX0KLQkJCQl9Ci0JCQl9Ci0JCQlhc3NvY2lhdGlvbnMgPSBtVmFsaWRBc3NvY2lhdGlvbnM7Ci0JCX0gZWxzZSB7Ci0JCQlhc3NvY2lhdGlvbnMgPSBtQXNzb2NpYXRpb25zOwotCQl9Ci0JCXJldHVybiBhc3NvY2lhdGlvbnM7Ci0JfQotCXByaXZhdGUgdm9pZCBhZGRGb3JlaWduS2V5QXNzb2NpYXRpb25zKGJvb2xlYW4gY2hlY2tFeGlzdGluZykgewotCQlMaXN0PFN0cmluZz4gdGFibGVOYW1lcyA9IGdldFRhYmxlTmFtZXMoKTsKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IGl0ZXIgPSB0YWJsZU5hbWVzLml0ZXJhdG9yKCk7IGl0ZXIuaGFzTmV4dCgpOyApIHsKLQkJCU9STUdlblRhYmxlIHRhYmxlID0gZ2V0VGFibGUoKFN0cmluZylpdGVyLm5leHQoKSk7Ci0JCQlhZGRGb3JlaWduS2V5QXNzb2NpYXRpb25zKHRhYmxlLCBjaGVja0V4aXN0aW5nKTsKLQkJfQotCX0KLQlwcml2YXRlIHZvaWQgYWRkRm9yZWlnbktleUFzc29jaWF0aW9ucyhPUk1HZW5UYWJsZSB0YWJsZSwgYm9vbGVhbiBjaGVja0V4aXN0aW5nKSB7Ci0JCWlmKHRhYmxlPT1udWxsKQotCQkJcmV0dXJuOwotCQkKLQkJCi0JCUxpc3Q8Rm9yZWlnbktleUluZm8+IGZLZXlzID0gbnVsbDsKLQkJCi0JCXRyeXsKLQkJCWZLZXlzID0gRFRQVXRpbC5nZXRGb3JlaWduS2V5cyh0YWJsZS5nZXREYlRhYmxlKCkpOwotCQl9Y2F0Y2goRXhjZXB0aW9uIGlzZSl7Ci0JCQkvL3dvcmthcm91bmQgRGFsaSBidWcgZm9yIG5vdwotCQkJcmV0dXJuOwotCQl9Ci0JCQotCQlpZiggZktleXMuc2l6ZSgpPT0wICkKLQkJCXJldHVybjsKLQkJCi0JCUxpc3Q8QXNzb2NpYXRpb24+IGFkZGVkQXNzb2NpYXRpb25zID0gbmV3IGphdmEudXRpbC5BcnJheUxpc3Q8QXNzb2NpYXRpb24+KCk7Ci0JCWZvciAoSXRlcmF0b3I8Rm9yZWlnbktleUluZm8+IGl0ZXIgPSBmS2V5cy5pdGVyYXRvcigpOyBpdGVyLmhhc05leHQoKTsgKSB7Ci0JCQlGb3JlaWduS2V5SW5mbyBma2kgPSAoRm9yZWlnbktleUluZm8paXRlci5uZXh0KCk7Ci0JCQlPUk1HZW5UYWJsZSByZWZlcmVuY2VkVGFibGUgPSBnZXRUYWJsZShma2kuZ2V0UmVmZXJlbmNlZFRhYmxlTmFtZSgpKTsKLQkJCWlmIChyZWZlcmVuY2VkVGFibGUgPT0gbnVsbCkgewotCQkJCWNvbnRpbnVlOwotCQkJfQotCQkJQXNzb2NpYXRpb24gYXNzb2NpYXRpb24gPSBuZXcgQXNzb2NpYXRpb24odGhpcywgdGFibGUuZ2V0TmFtZSgpLCBma2kuZ2V0UmVmZXJyZXJDb2x1bW5OYW1lcygpCi0JCQkJCQksIHJlZmVyZW5jZWRUYWJsZS5nZXROYW1lKCksIGZraS5nZXRSZWZlcmVuY2VkQ29sdW1uTmFtZXMoKSk7Ci0JCQlhc3NvY2lhdGlvbi5jb21wdXRlQ2FyZGluYWxpdHkoKTsKLQkJCS8vRGVmZXIgdGhlIGNoZWNrIG9mIHNpbWlsYXJBc3NvY2lhdGlvbkV4aXN0cyBhZnRlciBjb21wdXRlTWFueVRvTWFueSgpCi0JCQkvL290aGVyd2lzZSB0aGUgTVRNIGFzc29jaWF0aW9uIHdpbGwgbm90IGNvbXB1dGVkIGNvcnJlY3RseSBpbiBzb21lIGNhc2VzLgotCQkJLy9pZiAoY2hlY2tFeGlzdGluZyAmJiBzaW1pbGFyQXNzb2NpYXRpb25FeGlzdHMoYXNzb2NpYXRpb24pKSB7Ci0JCQkvLwljb250aW51ZTsKLQkJCS8vfQotCQkJYWRkZWRBc3NvY2lhdGlvbnMuYWRkKGFzc29jaWF0aW9uKTsKLQkJfQotCQkKLQkJQXNzb2NpYXRpb24gbTJtID0gY29tcHV0ZU1hbnlUb01hbnkodGFibGUsIGFkZGVkQXNzb2NpYXRpb25zKTsKLQkJaWYgKG0ybSAhPSBudWxsKSB7Ci0JCQkvKmRvIG5vdCBnZW5lcmF0ZSB0aGUgMiBtYW55LXRvLW9uZSovCi0JCQlmb3IgKGludCBpID0gMDsgaSA8IGFkZGVkQXNzb2NpYXRpb25zLnNpemUoKTsgKytpKSB7Ci0JCQkJQXNzb2NpYXRpb24gYXNzb2NpYXRpb24gPSAoQXNzb2NpYXRpb24pYWRkZWRBc3NvY2lhdGlvbnMuZ2V0KGkpOwotCQkJCWFzc29jaWF0aW9uLnNldEdlbmVyYXRlZChmYWxzZSk7Ci0JCQl9Ci0JCQlhZGRlZEFzc29jaWF0aW9ucy5hZGQoMCwgbTJtKTsKLQkJfQotCQkvL3JlbW92ZSB0aGUgYXNzb2NpYXRpb24gaWYgYWxyZWFkeSBleGlzdGluZwotCQlJdGVyYXRvcjxBc3NvY2lhdGlvbj4gaXQgPSAgYWRkZWRBc3NvY2lhdGlvbnMuaXRlcmF0b3IoKTsgCi0JCXdoaWxlKCBpdC5oYXNOZXh0KCkgKXsKLQkJCUFzc29jaWF0aW9uIG5ld0Fzc29jaWF0aW9uID0gaXQubmV4dCgpOwotCQkJZm9yKCBBc3NvY2lhdGlvbiBhc3NvY2lhdGlvbiA6IG1Bc3NvY2lhdGlvbnMgKXsKLQkJCQlpZiggbmV3QXNzb2NpYXRpb24uZXF1YWxzKCBhc3NvY2lhdGlvbiApKXsKLQkJCQkJLy9JZiB0aGUgYXNzb2NpYXRpb24gaXMgZXhpc3RpbmcsIGRvbid0IGFkZC4KLQkJCQkJLy9vbmx5IGNvcHkgdGhlIGdlbmVyYXRlZCBmbGFnCi0JCQkJCWFzc29jaWF0aW9uLnNldEdlbmVyYXRlZCggbmV3QXNzb2NpYXRpb24uaXNHZW5lcmF0ZWQoKSApOwotCQkJCQlpdC5yZW1vdmUoKTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJbUFzc29jaWF0aW9ucy5hZGRBbGwoYWRkZWRBc3NvY2lhdGlvbnMpOwotCX0KLQlwcml2YXRlIEFzc29jaWF0aW9uIGNvbXB1dGVNYW55VG9NYW55KE9STUdlblRhYmxlIHRhYmxlLCBMaXN0PEFzc29jaWF0aW9uPiBhZGRlZEFzc29jaWF0aW9ucykgewotCQkvKm1hbnktdG8tbWFueSBhc3NvY2lhdGlvbnMgaWY6Ci0JCSAqIC1hZGRlZEFzc29jaWF0aW9ucyBjb250YWlucyAyIG1hbnktdG8tb25lIGFzc29jaWF0aW9ucyB0byAyIGRpZmZlcmVudCB0YWJsZXMgdDEgYW5kIHQyLgotCQkgKiAtPGNvZGU+dGFibGU8L2NvZGU+IGNvbnRhaW5zIG9ubHkgdGhlIHByaW1hcnkga2V5IGNvbHVtbnMuCi0JCSAqIC10aGUgcHJpbWFyeSBrZXkgb2YgPGNvZGU+dGFibGU8L2NvZGU+IGlzIHRoZSBjb25jYXRlbmF0aW9uIG9mIGl0cyBmb3JlaWduIAotCQkgKiAJa2V5cyB0byB0MSBhbmQgdDIuKi8KLQkJCi0JCWlmIChhZGRlZEFzc29jaWF0aW9ucy5zaXplKCkgIT0gMikgewotCQkJcmV0dXJuIG51bGw7Ci0JCX0KLQkJCi0JCS8vQXNzdW1lIE1UTSB0YWJsZSBzaG91bGQgaGF2ZSBvbmx5IHR3byBjb2x1bW5zIHRoYXQgYXJlIGZvcmVpZ24ga2V5cwotCQlpZiggdGFibGUuZ2V0Q29sdW1ucygpLnNpemUoKSAhPSAyICl7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQkKLQkJQXNzb2NpYXRpb24gYXNzb2MxID0gKEFzc29jaWF0aW9uKWFkZGVkQXNzb2NpYXRpb25zLmdldCgwKTsKLQkJQXNzb2NpYXRpb24gYXNzb2MyID0gKEFzc29jaWF0aW9uKWFkZGVkQXNzb2NpYXRpb25zLmdldCgxKTsKLQkJaWYgKGFzc29jMS5nZXRDYXJkaW5hbGl0eSgpICE9IEFzc29jaWF0aW9uLk1BTllfVE9fT05FCi0JCQkJfHwgYXNzb2MyLmdldENhcmRpbmFsaXR5KCkgIT0gQXNzb2NpYXRpb24uTUFOWV9UT19PTkUpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCU9STUdlblRhYmxlIHQxID0gYXNzb2MxLmdldFJlZmVyZW5jZWRUYWJsZSgpOwotCQlPUk1HZW5UYWJsZSB0MiA9IGFzc29jMi5nZXRSZWZlcmVuY2VkVGFibGUoKTsKLQotLy9Db21tZW50ZWQgb3V0IGJlY2F1c2UgdGhlIGFzc3VtcHRpb24gaXMgdG9vIHJlc3RyaWN0aXZlOiAKLS8vdGhpcyBjaGVjayB3aWxsIHByZXZlbnQgZ2VuZXJhdGluZyB0YWJsZSBNVE0gdG8gaXRzZWxmCQkKLS8vCQlpZiAodDEuZ2V0TmFtZSgpLmVxdWFscyh0Mi5nZXROYW1lKCkpIHx8IAotLy8JCQkJdDEuZ2V0TmFtZSgpLmVxdWFscyh0YWJsZS5nZXROYW1lKCkpIHx8IHQyLmdldE5hbWUoKS5lcXVhbHModGFibGUuZ2V0TmFtZSgpKSkgewotCQlpZiggdDEuZ2V0TmFtZSgpLmVxdWFscyh0YWJsZS5nZXROYW1lKCkpIHx8IHQyLmdldE5hbWUoKS5lcXVhbHModGFibGUuZ2V0TmFtZSgpKSApIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCQotLy9Db21tZW50ZWQgb3V0IGJlY2F1c2UgdGhlIGFzc3VtcHRpb24gaXMgdG9vIHJlc3RyaWN0aXZlOiAKLS8vdGhpcyBjaGVjayB3aWxsIHByZXZlbnQgZ2VuZXJhdGluZyBNVE0gbWFwcGluZyB0YWJsZSBub3QgaGF2aW5nIAotLy9wcmltYXJ5IGtleSBkZWZpbmVkIAkJCi0vLwkJTGlzdCBwa05hbWVzID0gRFRQVXRpbC5nZXRQcmltYXJ5S2V5Q29sdW1uTmFtZXModGFibGUuZ2V0RGJUYWJsZSgpKTsKLS8vCQlpZiAocGtOYW1lcy5zaXplKCkgIT0gdGFibGUuZ2V0Q29sdW1uTmFtZXMoKS5zaXplKCkpIHsKLS8vCQkJcmV0dXJuIG51bGw7Ci0vLwkJfQotLy8JCUxpc3QgZmtOYW1lcyA9IG5ldyBqYXZhLnV0aWwuQXJyYXlMaXN0KGFzc29jMS5nZXRSZWZlcnJlckNvbHVtbk5hbWVzKCkpOyAvL2Nsb25lIGJlY2F1c2Ugd2UgbW9kaWZ5IGJ5IGFkZEFsbCBiZWxvdwotLy8JCWZrTmFtZXMuYWRkQWxsKGFzc29jMi5nZXRSZWZlcnJlckNvbHVtbk5hbWVzKCkpOwotLy8JCWlmICghQ29sbGVjdGlvblV0aWwuZXF1YWxzSWdub3JlT3JkZXIocGtOYW1lcywgZmtOYW1lcykpIHsKLS8vCQkJcmV0dXJuIG51bGw7Ci0vLwkJfQotCQlBc3NvY2lhdGlvbiBtMm0gPSBuZXcgQXNzb2NpYXRpb24odGhpcywgdDEuZ2V0TmFtZSgpLypyZWZlcnJlclRhYmxlTmFtZSovLCBhc3NvYzEuZ2V0UmVmZXJlbmNlZENvbHVtbk5hbWVzKCkvKnJlZmVycmVyQ29sTmFtZXMqLwotCQkJCSwgdDIuZ2V0TmFtZSgpLypyZWZlcmVuY2VkVGFibGVOYW1lKi8sIGFzc29jMi5nZXRSZWZlcmVuY2VkQ29sdW1uTmFtZXMoKS8qcmVmZXJlbmNlZENvbE5hbWVzKi8KLQkJCQksIHRhYmxlLmdldE5hbWUoKSwgYXNzb2MxLmdldFJlZmVycmVyQ29sdW1uTmFtZXMoKS8qcmVmZXJyZXJKb2luQ29sTmFtZXMqLywgYXNzb2MyLmdldFJlZmVycmVyQ29sdW1uTmFtZXMoKS8qcmVmZXJlbmNlZEpvaW5Db2xOYW1lcyovKTsKLQkJbTJtLnNldEN1c3RvbShmYWxzZSk7Ci0JCXJldHVybiBtMm07Ci0JfQotCi0JLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLQkvLy0tLS0gRmlsZUhlYWRlciBjbGFzcyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotCS8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0JLyoqCi0JICogVGhlIGhlYWRlciBvZiB0aGUgY3VzdG9taXphdGlvbiBmaWxlLgotCSAqLwotCXByaXZhdGUgc3RhdGljIGNsYXNzIEZpbGVIZWFkZXIgaW1wbGVtZW50cyBqYXZhLmlvLlNlcmlhbGl6YWJsZQotCXsKLQkJcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0JCS8qKgotCQkgKiBTaG91bGQgYmUgYXJndW1lbnQtbGVzcyBiZWNhdXNlIGl0IGlzIHVzZWQgaW4gCi0JCSAqIHRoZSBkZS1zZXJpYWxpemF0aW9uIHByb2Nlc3MuCi0JCSAqLwotCQlwdWJsaWMgRmlsZUhlYWRlcigpIHsKLQkJCW1WZXJzaW9uID0gRklMRV9WRVJTSU9OOwotCQl9Ci0JCWludCBtVmVyc2lvbjsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9PUk1HZW5UYWJsZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbDIvT1JNR2VuVGFibGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOThmYjBjMy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9PUk1HZW5UYWJsZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsOTM4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDI7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5BcnJheXM7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb25zOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuQ29sdW1uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5UYWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsLkVudGl0eUdlblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5nZW4uaW50ZXJuYWwyLnV0aWwuRFRQVXRpbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsMi51dGlsLlN0cmluZ1V0aWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuSmF2YVR5cGU7Ci0KLS8qKgotICogUmVwcmVzZW50cyB0aGUgT1JNIGdlbmVyYXRpb24gcHJvcGVydGllcyBmb3IgYSBkYXRhYmFzZSB0YWJsZS4KLSAqIAotICogPHA+Ci0gKiBUaGlzIGlzIGRlc2lnbmVkIHRvIGJlIGNyZWF0ZWQvY2hhbmdlZCBieSB0aGUgZ2VuZXJhdGlvbiB3aXphcmQsIGFuZAotICogZ2VuZXJhdGVkIHVzaW5nIFZlbG9jaXR5IHRlbXBsYXRlcy4gVGhlIG1vZGlmaWVkIHByb3BlcnRpZXMgKGlmIGFueSkgYXJlCi0gKiBwZXJzaXN0ZWQvcmV0cmlldmVkIHVzaW5nIDxjb2RlPk9STUdlbkN1c3RvbWl6ZXI8L2NvZGU+LgotICogCi0gKi8KLXB1YmxpYyBjbGFzcyBPUk1HZW5UYWJsZQotewotCXByaXZhdGUgT1JNR2VuQ3VzdG9taXplciBtQ3VzdG9taXplcjsKLQlwcml2YXRlIExpc3Q8T1JNR2VuQ29sdW1uPiBtQ29sdW1uczsKLQlwcml2YXRlIFRhYmxlIG1EYlRhYmxlOwotCi0JLyoqCi0JICogQHBhcmFtIHRhYmxlCi0JICogICAgICAgICAgICBUaGUgZGF0YWJhc2UgdGFibGUgb3IgbnVsbCBpZiB0aGlzIHRhYmxlIGlzIHVzZWQgdG8gZ2V0L3NldAotCSAqICAgICAgICAgICAgdGhlIGRlZmF1bHQgdGFibGUgcHJvcGVydGllcyAocHJvcGVydGllcyB0aGF0IGFwcGx5IHRvIGFsbAotCSAqICAgICAgICAgICAgdGFibGVzIHVubGVzcyBvdmVycmlkZW4pLgotCSAqLwotCXB1YmxpYyBPUk1HZW5UYWJsZShUYWJsZSB0YWJsZSwgT1JNR2VuQ3VzdG9taXplciBjdXN0b21pemVyKSB7Ci0JCXN1cGVyKCk7Ci0JCW1EYlRhYmxlID0gdGFibGU7Ci0JCW1DdXN0b21pemVyID0gY3VzdG9taXplcjsKLQl9Ci0KLQlwdWJsaWMgT1JNR2VuQ3VzdG9taXplciBnZXRDdXN0b21pemVyKCkgewotCQlyZXR1cm4gbUN1c3RvbWl6ZXI7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0cnVlIGlmIHRoaXMgdGFibGUgaXMgaXMgdXNlZCB0byBnZXQvc2V0IHRoZSBkZWZhdWx0IHRhYmxlCi0JICogcHJvcGVydGllcy4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBpc0RlZmF1bHRzVGFibGUoKSB7Ci0JCXJldHVybiBtRGJUYWJsZSA9PSBudWxsOwotCX0KLQotCXByb3RlY3RlZCBTdHJpbmcgY3VzdG9taXplZChTdHJpbmcgcHJvcE5hbWUpIHsKLQkJcmV0dXJuIGdldEN1c3RvbWl6ZXIoKS5nZXRQcm9wZXJ0eShwcm9wTmFtZSwgZ2V0TmFtZSgpLCBudWxsKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgYm9vbGVhbiBjdXN0b21pemVkQm9vbGVhbihTdHJpbmcgcHJvcE5hbWUpIHsKLQkJcmV0dXJuIGdldEN1c3RvbWl6ZXIoKS5nZXRCb29sZWFuUHJvcGVydHkocHJvcE5hbWUsIGdldE5hbWUoKSwgbnVsbCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgc2V0Q3VzdG9taXplZChTdHJpbmcgcHJvcE5hbWUsIFN0cmluZyB2YWx1ZSkgewotCQlpZiAodmFsdWUgIT0gbnVsbCAmJiB2YWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQl2YWx1ZSA9IG51bGw7Ci0JCX0KLQkJZ2V0Q3VzdG9taXplcigpLnNldFByb3BlcnR5KHByb3BOYW1lLCB2YWx1ZSwgZ2V0TmFtZSgpLCBudWxsKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBzZXRDdXN0b21pemVkQm9vbGVhbihTdHJpbmcgcHJvcE5hbWUsIGJvb2xlYW4gdmFsdWUsIGJvb2xlYW4gZGVmYXVsdFZhbHVlKSB7Ci0JCWlmIChkZWZhdWx0VmFsdWUgPT0gdmFsdWUpIHsKLQkJCXNldEN1c3RvbWl6ZWQocHJvcE5hbWUsIG51bGwpOyAvLyByZW1vdmUgdGhlIHByb3BlcnR5Ci0JCX0KLQkJZWxzZSB7Ci0JCQlnZXRDdXN0b21pemVyKCkuc2V0Qm9vbGVhblByb3BlcnR5KHByb3BOYW1lLCB2YWx1ZSwgZ2V0TmFtZSgpLCBudWxsKTsKLQkJfQotCX0KLQotCXB1YmxpYyBUYWJsZSBnZXREYlRhYmxlKCkgewotCQlyZXR1cm4gbURiVGFibGU7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0aGUgdGFibGUgbmFtZS4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdldE5hbWUoKSB7Ci0JCWlmIChtRGJUYWJsZSA9PSBudWxsKQotCQkJcmV0dXJuIE9STUdlbkN1c3RvbWl6ZXIuQU5ZX1RBQkxFOwotCQlyZXR1cm4gbURiVGFibGUuZ2V0TmFtZSgpOwotCX0KLQotCXB1YmxpYyBTdHJpbmcgZ2V0Sm9pblRhYmxlQW5ub3RhdGlvbk5hbWUoKSB7Ci0JCWlmIChtRGJUYWJsZSA9PSBudWxsKQotCQkJcmV0dXJuIE9STUdlbkN1c3RvbWl6ZXIuQU5ZX1RBQkxFOwotCQlTdHJpbmcgYW5ub3RhdGlvbk5hbWUgPSB0aGlzLm1DdXN0b21pemVyLmdldERhdGFiYXNlQW5ub3RhdGlvbk5hbWVCdWlsZGVyKCkuYnVpbGRKb2luVGFibGVBbm5vdGF0aW9uTmFtZShtRGJUYWJsZSk7Ci0JCXJldHVybiBhbm5vdGF0aW9uTmFtZSAhPSBudWxsID8gYW5ub3RhdGlvbk5hbWUgOiBtRGJUYWJsZS5nZXROYW1lKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0aGUgZGF0YWJhc2Ugc2NoZW1hIGNvbnRhaW5pbmcgdGhlIHRhYmxlLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0U2NoZW1hKCkgewotCQlpZiAoRFRQVXRpbC5pc0RlZmF1bHRTY2hlbWEobURiVGFibGUpKQotCQkJcmV0dXJuICIiOyAvLyROT04tTkxTLTEkCi0JCVN0cmluZyBzY2hlbWFOYW1lID0gbURiVGFibGUuZ2V0U2NoZW1hKCkuZ2V0TmFtZSgpOwotCQlyZXR1cm4gc2NoZW1hTmFtZTsKLQl9Ci0KLQkvKioKLQkgKiBTZXRzIHRoZSBwYWNrYWdlIGZvciB0aGUgZ2VuZXJhdGVkIGNsYXNzIChlbXB0eSBzdHJpbmcgZm9yIHRoZSBkZWZhdWx0Ci0JICogcGFja2FnZSkKLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRQYWNrYWdlKFN0cmluZyBzcmNGb2xkZXIsIFN0cmluZyBwa2cpIHsKLQkJc2V0Q3VzdG9taXplZChTUkNfRk9MREVSLCBzcmNGb2xkZXIpOwotCQlnZXRDdXN0b21pemVyKCkuc2V0UHJvcGVydHkoUEFDS0FHRSwgcGtnLCBnZXROYW1lKCksIG51bGwpOyAvLyBub3QKLQkJCQkJCQkJCQkJCQkJCQkJLy8gY2FsbGluZwotCQkJCQkJCQkJCQkJCQkJCQkvLyBzZXRDdXN0b21pemVkCi0JCQkJCQkJCQkJCQkJCQkJCS8vIHNvIHRoYXQKLQkJCQkJCQkJCQkJCQkJCQkJLy8gZW1wdHkKLQkJCQkJCQkJCQkJCQkJCQkJLy8gc3RyaW5ncwotCQkJCQkJCQkJCQkJCQkJCQkvLyBkbyBub3QKLQkJCQkJCQkJCQkJCQkJCQkJLy8gZ2V0Ci0JCQkJCQkJCQkJCQkJCQkJCS8vIG51bGxlZAotCQkJCQkJCQkJCQkJCQkJCQkvLyBvdXQuCi0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0aGUgSmF2YSBwYWNrYWdlIChlbXB0eSBzdHJpbmcgZm9yIHRoZSBkZWZhdWx0IHBhY2thZ2UpLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0UGFja2FnZSgpIHsKLQkJcmV0dXJuIGN1c3RvbWl6ZWQoUEFDS0FHRSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0aGUgZ2VuZXJhdGVkIEphdmEgY2xhc3MgbmFtZSAobm90IHF1YWxpZmllZCkuCi0JICovCi0JcHVibGljIFN0cmluZyBnZXRDbGFzc05hbWUoKSB7Ci0JCVN0cmluZyBuYW1lID0gY3VzdG9taXplZChDTEFTU19OQU1FKTsKLQkJaWYgKG5hbWUgPT0gbnVsbCkgewotCQkJLy8gbmFtZSA9IFN0cmluZ1V0aWwudGFibGVOYW1lVG9WYXJOYW1lKGdldE5hbWUoKSk7Ci0JCQkvLyBuYW1lID0gU3RyaW5nVXRpbC5pbml0VXBwZXIobmFtZSk7Ci0JCQluYW1lID0gRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQ2xhc3NOYW1lKGdldE5hbWUoKSwgbmV3IEFycmF5TGlzdDxTdHJpbmc+KCkpOwotCQkJbmFtZSA9IFN0cmluZ1V0aWwuc2luZ3VsYXJpc2UobmFtZSk7Ci0JCX0KLQkJcmV0dXJuIG5hbWU7Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0Q2xhc3NOYW1lKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJLyoKLQkJICogaWYgdGhlIGNsYXNzIG5hbWUgaXMgdGhlIHNhbWUgYXMgdGhlIChwb3NzaWJseSBjb21wdXRlZCkgY2xhc3MgbmFtZQotCQkgKiB0aGVuIG5vdGhpbmcgdG8gZG8KLQkJICovCi0JCWlmICghU3RyaW5nVXRpbC5lcXVhbE9iamVjdHMoY2xhc3NOYW1lLCBnZXRDbGFzc05hbWUoKSkpIHsKLQkJCXNldEN1c3RvbWl6ZWQoQ0xBU1NfTkFNRSwgY2xhc3NOYW1lKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFJldHVybnMgYSBuYW1lIHN1aXRhYmxlIHRvIGJlIHVzZWQgYXMgYSB2YXJpYWJsZSBvciBjbGFzcyBuYW1lLiBUaGlzIGlzCi0JICogY29tcHV0ZWQgYmFzZWQgb24gdGhlIHRhYmxlIG5hbWUuCi0JICogCi0JICogQHBhcmFtIHNpbmd1bGFyCi0JICogICAgICAgICAgICBXaGV0aGVyIHRoZSBuYW1lIHNob3VsZCBiZSBzaW5ndWxhciBvciBwbHVyYWwuCi0JICovCi0JcHVibGljIFN0cmluZyBnZXRWYXJOYW1lKGJvb2xlYW4gc2luZ3VsYXIpIHsKLQkJU3RyaW5nIG5hbWUgPSBTdHJpbmdVdGlsLnRhYmxlTmFtZVRvVmFyTmFtZShnZXROYW1lKCkpOwotCQlpZiAoc2luZ3VsYXIpIHsKLQkJCW5hbWUgPSBTdHJpbmdVdGlsLnNpbmd1bGFyaXNlKG5hbWUpOwotCQl9Ci0JCWVsc2UgewotCQkJbmFtZSA9IFN0cmluZ1V0aWwucGx1cmFsaXNlKG5hbWUpOwotCQl9Ci0JCXJldHVybiBuYW1lOwotCX0KLQotCS8qKgotCSAqIFJldHVybnMgdGhlIGZ1bGx5IHF1YWxpZmllZCBnZW5lcmF0ZWQgSmF2YSBjbGFzcyBuYW1lLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0UXVhbGlmaWVkQ2xhc3NOYW1lKCkgewotCQlyZXR1cm4gcXVhbGlmeShnZXRDbGFzc05hbWUoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0aGUgY29tcG9zaXRlIGtleSBKYXZhIGNsYXNzIG5hbWUgKG5vdCBxdWFsaWZpZWQpLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0Q29tcG9zaXRlS2V5Q2xhc3NOYW1lKCkgewotCQlTdHJpbmcgbmFtZSA9IGN1c3RvbWl6ZWQoQ09NUE9TSVRFX0tFWV9DTEFTU19OQU1FKTsKLQkJaWYgKG5hbWUgPT0gbnVsbCkgewotCQkJbmFtZSA9IGdldENsYXNzTmFtZSgpICsgIlBLIjsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCXJldHVybiBuYW1lOwotCX0KLQotCS8qKgotCSAqIFJldHVybnMgdGhlIGZ1bGx5IHF1YWxpZmllZCBjb21wb3NpdGUga2V5IEphdmEgY2xhc3MgbmFtZS4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdldFF1YWxpZmllZENvbXBvc2l0ZUtleUNsYXNzTmFtZSgpIHsKLQkJcmV0dXJuIHF1YWxpZnkoZ2V0Q29tcG9zaXRlS2V5Q2xhc3NOYW1lKCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybnMgdGhlIGNvbXBvc2l0ZSBrZXkgcHJvcGVydHkgbmFtZS4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdldENvbXBvc2l0ZUtleVByb3BlcnR5TmFtZSgpIHsKLQkJcmV0dXJuICJpZCI7IC8vJE5PTi1OTFMtMSQKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm5zIHRoZSA8Y29kZT5PUk1HZW5Db2x1bW48L2NvZGU+IG9iamVjdHMgdG8gYmUgZ2VuZXJhdGVkIGZvciB0aGlzCi0JICogdGFibGUuCi0JICovCi0JcHVibGljIExpc3Q8T1JNR2VuQ29sdW1uPiBnZXRDb2x1bW5zKCkgewotCQlpZiAobUNvbHVtbnMgPT0gbnVsbCkgewotCQkJbUNvbHVtbnMgPSBuZXcgQXJyYXlMaXN0PE9STUdlbkNvbHVtbj4oKTsKLQkJCUl0ZXJhdG9yPENvbHVtbj4gY29scyA9IG1EYlRhYmxlLmNvbHVtbnMoKTsKLQkJCXdoaWxlIChjb2xzLmhhc05leHQoKSkgewotCQkJCUNvbHVtbiBjID0gY29scy5uZXh0KCk7Ci0JCQkJT1JNR2VuQ29sdW1uIGdlbkNvbHVtbiA9IGdldEN1c3RvbWl6ZXIoKS5jcmVhdGVHZW5Db2x1bW4oYyk7Ci0JCQkJbUNvbHVtbnMuYWRkKGdlbkNvbHVtbik7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIG1Db2x1bW5zOwotCX0KLQotCXB1YmxpYyBMaXN0PFN0cmluZz4gZ2V0Q29sdW1uTmFtZXMoKSB7Ci0JCUl0ZXJhdG9yPENvbHVtbj4gY29scyA9IG1EYlRhYmxlLmNvbHVtbnMoKTsKLQkJTGlzdDxTdHJpbmc+IHJldCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQl3aGlsZSAoY29scy5oYXNOZXh0KCkpIHsKLQkJCUNvbHVtbiBjID0gY29scy5uZXh0KCk7Ci0JCQlyZXQuYWRkKGMuZ2V0TmFtZSgpKTsKLQkJfQotCQlyZXR1cm4gcmV0OwotCX0KLQotCS8qKgotCSAqIFJldHVybnMgdGhlIDxjb2RlPk9STUdlbkNvbHVtbjwvY29kZT4gb2JqZWN0cyByZXByZXNlbnRpbmcgdGhlIHRhYmxlJ3MKLQkgKiBwcmltYXJ5IGtleS4KLQkgKi8KLQlwdWJsaWMgTGlzdDxPUk1HZW5Db2x1bW4+IGdldFByaW1hcnlLZXlDb2x1bW5zKCkgewotCQlMaXN0PENvbHVtbj4gZGJDb2xzID0gRFRQVXRpbC5nZXRQcmltYXJ5S2V5Q29sdW1ucyhtRGJUYWJsZSk7Ci0JCUxpc3Q8T1JNR2VuQ29sdW1uPiByZXQgPSBuZXcgQXJyYXlMaXN0PE9STUdlbkNvbHVtbj4oKTsKLQkJZm9yIChDb2x1bW4gZGJDb2wgOiBkYkNvbHMpIHsKLQkJCXJldC5hZGQobmV3IE9STUdlbkNvbHVtbihkYkNvbCwgdGhpcy5tQ3VzdG9taXplcikpOwotCQl9Ci0JCXJldHVybiByZXQ7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0aGUgcHJpbWFyeSBrZXkgY29sdW1uIG9yIG51bGwgaWYgdGhlcmUgaXMgbm8gb3IgbWFueSBwcmltYXJ5IGtleQotCSAqIGNvbHVtbnMuCi0JICovCi0JcHVibGljIE9STUdlbkNvbHVtbiBnZXRQcmltYXJ5S2V5Q29sdW1uKCkgewotCQlPUk1HZW5Db2x1bW4gcGtDb2wgPSBudWxsOwotCQlMaXN0PE9STUdlbkNvbHVtbj4gcGtDb2x1bW5zID0gZ2V0UHJpbWFyeUtleUNvbHVtbnMoKTsKLQkJaWYgKHBrQ29sdW1ucy5zaXplKCkgPT0gMSkgewotCQkJLy8gQ29sdW1uIGRiQ29sID0gKENvbHVtbilwa0NvbHVtbnMuZ2V0KDApOwotCQkJcGtDb2wgPSBwa0NvbHVtbnMuZ2V0KDApOyAvLyAoT1JNR2VuQ29sdW1uKQotCQkJCQkJCQkJCS8vIG1DdXN0b21pemVyLmNyZWF0ZUdlbkNvbHVtbihkYkNvbCk7Ci0JCX0KLQkJZWxzZSB7Ci0JCQkvKgotCQkJICogaWYgbm8gcGsgY29sdW1uIHRoZW4gbG9vayBmb3IgdGhlIGZpcnN0IGNvbHVtbiB3aXRoIGlkIG1hcHBpbmcKLQkJCSAqIGtpbmQuIFRoaXMgaXMgc28gdGhhdCB0aGUgd2l6YXJkIGNhbiBiZSB1c2VkIHdpdGggdGFibGVzIG5vdAotCQkJICogaGF2aW5nIHByaW1hcnkga2V5cy4KLQkJCSAqLwotCQkJTGlzdDxPUk1HZW5Db2x1bW4+IGNvbHVtbnMgPSBnZXRDb2x1bW5zKCk7Ci0JCQlmb3IgKGludCBpID0gMCwgbiA9IGNvbHVtbnMuc2l6ZSgpOyBpIDwgbjsgKytpKSB7Ci0JCQkJT1JNR2VuQ29sdW1uIGNvbHVtbiA9IGNvbHVtbnMuZ2V0KGkpOwotCQkJCWlmIChjb2x1bW4uZ2V0TWFwcGluZ0tpbmQoKS5lcXVhbHMobUN1c3RvbWl6ZXIuZ2V0SWRNYXBwaW5nS2luZCgpKSkgewotCQkJCQlwa0NvbCA9IGNvbHVtbjsKLQkJCQkJYnJlYWs7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCXJldHVybiBwa0NvbDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm5zIHRydWUgaWYgdGhlcmUgaXMgbW9yZSB0aGFuIDEgcGsgY29sdW1uLgotCSAqLwotCXB1YmxpYyBib29sZWFuIGlzQ29tcG9zaXRlS2V5KCkgewotCQlyZXR1cm4gRFRQVXRpbC5nZXRQcmltYXJ5S2V5Q29sdW1uTmFtZXMobURiVGFibGUpLnNpemUoKSA+IDE7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0aGUgPGNvZGU+T1JNR2VuQ29sdW1uPC9jb2RlPiBvYmplY3RzIGZvciB0aGUgdGhlIGNvbHVtbnMgdGhhdAotCSAqIGFyZSBub3QgcGFydCBvZiBhbnkgYXNzb2NpYXRpb24uCi0JICogCi0JICogQHBhcmFtIGdlbk9ubHkKLQkgKiAgICAgICAgICAgIFdoZXRoZXIgdG8gaW5jbHVkZSBvbmx5IHRoZSBjb2x1bW5zIG1hcmtlZCBmb3IgZ2VuZXJhdGlvbi4KLQkgKiAKLQkgKiBAcGFyYW0gaW5jbHVkZVBrCi0JICogICAgICAgICAgICBXaGV0aGVyIHRvIGluY2x1ZGUgdGhlIHByaW1hcnkga2xleSBjb2x1bW4ocykuCi0JICogCi0JICogQHBhcmFtIGluY2x1ZGVJbmhlcml0ZWQKLQkgKiAgICAgICAgICAgIFdoZXRoZXIgdG8gaW5jbHVkZSB0aGUgY29sdW1ucyBhc3NvY2lhdGVkIHdpdGggSmF2YSBwcm9wZXJ0aWVzCi0JICogICAgICAgICAgICB0aGF0IGV4aXN0IGluIHRoZSBzdXBlciBjbGFzcyAoaWYgYW55KS4KLQkgKi8KLQlwdWJsaWMgTGlzdDxPUk1HZW5Db2x1bW4+IGdldFNpbXBsZUNvbHVtbnMoYm9vbGVhbiBnZW5Pbmx5LCBib29sZWFuIGluY2x1ZGVQaywgYm9vbGVhbiBpbmNsdWRlSW5oZXJpdGVkKSB7Ci0JCUxpc3Q8T1JNR2VuQ29sdW1uPiByZXN1bHQgPSBuZXcgamF2YS51dGlsLkFycmF5TGlzdDxPUk1HZW5Db2x1bW4+KCk7Ci0JCUxpc3Q8T1JNR2VuQ29sdW1uPiBjb2x1bW5zID0gZ2V0Q29sdW1ucygpOwotCQlMaXN0PEFzc29jaWF0aW9uUm9sZT4gcm9sZXMgPSBnZXRBc3NvY2lhdGlvblJvbGVzKCk7Ci0JCWZvciAoaW50IGkgPSAwLCBuID0gY29sdW1ucy5zaXplKCk7IGkgPCBuOyArK2kpIHsKLQkJCU9STUdlbkNvbHVtbiBjb2x1bW4gPSBjb2x1bW5zLmdldChpKTsKLQkJCWlmIChnZW5Pbmx5ICYmICFjb2x1bW4uaXNHZW5lcmF0ZWQoKSkgewotCQkJCWNvbnRpbnVlOwotCQkJfQotCQkJaWYgKGNvbHVtbi5pc1ByaW1hcnlLZXkoKSkgewotCQkJCWlmICghaW5jbHVkZVBrIHx8IGlzQ29tcG9zaXRlS2V5KCkpIHsKLQkJCQkJY29udGludWU7Ci0JCQkJfQotCQkJfQotCQkJZWxzZSBpZiAoaXNDb2x1bW5JbkFzc2NvY2lhdGlvbihjb2x1bW4sIHJvbGVzKSkgewotCQkJCWNvbnRpbnVlOwotCQkJfQotCQkJcmVzdWx0LmFkZChjb2x1bW4pOwotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JcHVibGljIExpc3Q8T1JNR2VuQ29sdW1uPiBnZXRTaW1wbGVDb2x1bW5zKCkgewotCQlyZXR1cm4gZ2V0U2ltcGxlQ29sdW1ucyh0cnVlLyogZ2VuT25seSAqLywgdHJ1ZS8qIGluY2x1ZGVQayAqLywgdHJ1ZS8qIGluY2x1ZGVJbmhlcml0ZWQgKi8pOwotCX0KLQotCS8qKgotCSAqIFJldHVybnMgZmFsc2UgaWYgdGhlIGdpdmVuIGNvbHVtbiBzaG91bGQgYmUgZ2VuZXJhdGVkIHdpdGggZmFsc2UKLQkgKiB1cGRhdGFibGUvaW5zZXJ0YWJsZS4gVGhpcyBpcyB0aGUgY2FzZSB3aGVuIHRoZSBjb2x1bW4gaXMgbWFwcGVkIG1vcmUKLQkgKiB0aGFuIG9uY2UsIHRoaXMgdXN1YWxseSBoYXBwZW4gd2l0aCBjb2x1bW5zIGluIGNvbXBvc2l0ZSBrZXlzIGFuZAotCSAqIG1hbnktdG8tb25lIGFzc29jaWF0aW9ucy4KLQkgKiAKLQkgKiA8YnI+Ci0JICogTm90ZSB0aGF0IGZvciBIaWJlcm5hdGUgdGhlIGNvbHVtbiBwYXJhbSBpcyBudWxsIGJlY2F1c2UgdGhlCi0JICogaW5zZXJ0L3VwZGF0ZSBhdHRyaWJ1dGVzIGFyZSBzcGVjaWZpZWQgZm9yIHRoZSBtYW55LXRvLW9uZSB0YWcgaXRzZWxmCi0JICogaW5zdGVhZCBvZiB0aGUgbmVzdGVkIGNvbHVtbiB0YWdzIChib2d1cyBvYnZpb3VzbHkpLgotCSAqLwotCXB1YmxpYyBib29sZWFuIGlzQ29sdW1uVXBkYXRlSW5zZXJ0KEFzc29jaWF0aW9uUm9sZSByb2xlLCBPUk1HZW5Db2x1bW4gY29sdW1uKSB7Ci0JCWlmIChjb2x1bW4gPT0gbnVsbCkgewotCQkJZm9yIChJdGVyYXRvcjxPUk1HZW5Db2x1bW4+IGl0ZXIgPSByb2xlLmdldFJlZmVycmVyQ29sdW1ucygpLml0ZXJhdG9yKCk7IGl0ZXIuaGFzTmV4dCgpOykgewotCQkJCU9STUdlbkNvbHVtbiBjID0gaXRlci5uZXh0KCk7Ci0JCQkJaWYgKCFpc0NvbHVtblVwZGF0ZUluc2VydChyb2xlLCBjKSkgewotCQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQkJfQotCQkJfQotCQkJcmV0dXJuIHRydWU7Ci0JCX0KLQkJaWYgKGNvbHVtbi5pc1ByaW1hcnlLZXkoKSkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCS8qCi0JCSAqIHNob3VsZCBsb29rIGlmIHRoZXJlIGFyZSBtdWx0aXBsZSBhc3NvY2lhdGlvbnMgdXNpbmcgdGhlIHNhbWUgY29sdW1uCi0JCSAqIGFuZCByZXR1cm4gZmFsc2UsIGJ1dCB0aGlzIGlzIHByb2JhYmx5IGFuIHVudXN1YWwgY2FzZS4KLQkJICovCi0JCXJldHVybiB0cnVlOwotCX0KLQotCS8qKgotCSAqIFJldHVybnMgdGhlIDxjb2RlPk9STUdlbkNvbHVtbjwvY29kZT4gb2JqZWN0cyBjb3JyZXNwb25kaW5nIHRvIHRoZSBnaXZlbgotCSAqIGNvbHVtbiBuYW1lcy4KLQkgKi8KLQlwdWJsaWMgTGlzdDxPUk1HZW5Db2x1bW4+IGdldENvbHVtbnNCeU5hbWVzKExpc3Q8U3RyaW5nPiBuYW1lcykgewotCQlMaXN0PE9STUdlbkNvbHVtbj4gcmVzdWx0ID0gbmV3IGphdmEudXRpbC5BcnJheUxpc3Q8T1JNR2VuQ29sdW1uPigpOwotCQlmb3IgKFN0cmluZyBuYW1lIDogbmFtZXMpIHsKLQkJCU9STUdlbkNvbHVtbiBjb2x1bW4gPSBnZXRDb2x1bW5CeU5hbWUobmFtZSk7Ci0JCQlhc3NlcnQgKGNvbHVtbiAhPSBudWxsKTsKLQkJCWlmIChjb2x1bW4gIT0gbnVsbCkgewotCQkJCXJlc3VsdC5hZGQoY29sdW1uKTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIFJldHVybnMgdGhlIGNvbHVtbnMgaGF2aW5nIHRoZSBnaXZlbiBuYW1lLCBvciBudWxsIGlmIG5vbmUuCi0JICovCi0JcHVibGljIE9STUdlbkNvbHVtbiBnZXRDb2x1bW5CeU5hbWUoU3RyaW5nIG5hbWUpIHsKLQkJTGlzdDxPUk1HZW5Db2x1bW4+IGNvbHVtbnMgPSBnZXRDb2x1bW5zKCk7Ci0JCWZvciAoaW50IGkgPSAwLCBuID0gY29sdW1ucy5zaXplKCk7IGkgPCBuOyArK2kpIHsKLQkJCU9STUdlbkNvbHVtbiBjb2x1bW4gPSBjb2x1bW5zLmdldChpKTsKLQkJCWlmIChjb2x1bW4uZ2V0TmFtZSgpLmVxdWFscyhuYW1lKSkgewotCQkJCXJldHVybiBjb2x1bW47Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIG51bGw7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0aGUgPGNvZGU+QXNzb2NpYXRpb25Sb2xlPC9jb2RlPiBvYmplY3RzIGZvciB0aGlzIHRhYmxlLiBPbmx5IHRoZQotCSAqIGFzc29jaWF0aW9uIG1hcmtlZCBmb3IgZ2VuZXJhdGlvbiBhcmUgcmV0dXJuZWQuCi0JICovCi0JcHVibGljIExpc3Q8QXNzb2NpYXRpb25Sb2xlPiBnZXRBc3NvY2lhdGlvblJvbGVzKCkgewotCQkvKgotCQkgKiB0aGlzIGlzIG5vdCBjYWNoZWQgaW50ZW50aW9uYWxseSBiZWNhdXNlIGludmFsaWRhdGluZyB0aGUgY2FjaGUgd2l0aAotCQkgKiB3aXphcmQgY2hhbmdlcyBpcyBraW5kYSB0cmlja3kuCi0JCSAqLwotCQlMaXN0PEFzc29jaWF0aW9uUm9sZT4gYXNzb2NpYXRpb25Sb2xlcyA9IG5ldyBBcnJheUxpc3Q8QXNzb2NpYXRpb25Sb2xlPigpOwotCQlTdHJpbmcgbmFtZSA9IGdldE5hbWUoKTsKLQkJTGlzdDxBc3NvY2lhdGlvbj4gYXNzb2NpYXRpb25zID0gbUN1c3RvbWl6ZXIuZ2V0QXNzb2NpYXRpb25zKCk7Ci0JCWZvciAoSXRlcmF0b3I8QXNzb2NpYXRpb24+IGl0ZXIgPSBhc3NvY2lhdGlvbnMuaXRlcmF0b3IoKTsgaXRlci5oYXNOZXh0KCk7KSB7Ci0JCQlBc3NvY2lhdGlvbiBhc3NvY2lhdGlvbiA9IGl0ZXIubmV4dCgpOwotCQkJaWYgKCFhc3NvY2lhdGlvbi5pc0dlbmVyYXRlZCgpKSB7Ci0JCQkJY29udGludWU7Ci0JCQl9Ci0JCQkvKgotCQkJICogY2hlY2sgYm90aCByZWZlcnJlcmFuZCByZWZlcmVuY2VkIGJlY2F1c2UgYW4gYXNzb2NpYXRpb24gY291bGQgYmUKLQkJCSAqIGZyb20tdG8gdGhlIHNhbWUgdGFibGUgKGVtcGxveWVlL21hbmFnZXIpCi0JCQkgKi8KLQkJCWlmIChhc3NvY2lhdGlvbi5nZXRSZWZlcnJlclRhYmxlKCkuZ2V0TmFtZSgpLmVxdWFscyhuYW1lKSkgewotCQkJCUFzc29jaWF0aW9uUm9sZSByb2xlID0gYXNzb2NpYXRpb24uZ2V0UmVmZXJyZXJSb2xlKCk7Ci0JCQkJaWYgKHJvbGUgIT0gbnVsbCkgewotCQkJCQlhc3NvY2lhdGlvblJvbGVzLmFkZChyb2xlKTsKLQkJCQl9Ci0JCQl9Ci0JCQlpZiAoYXNzb2NpYXRpb24uZ2V0UmVmZXJlbmNlZFRhYmxlKCkuZ2V0TmFtZSgpLmVxdWFscyhuYW1lKSkgewotCQkJCUFzc29jaWF0aW9uUm9sZSByb2xlID0gYXNzb2NpYXRpb24uZ2V0UmVmZXJlbmNlZFJvbGUoKTsKLQkJCQlpZiAocm9sZSAhPSBudWxsKSB7Ci0JCQkJCWFzc29jaWF0aW9uUm9sZXMuYWRkKHJvbGUpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlyZXR1cm4gYXNzb2NpYXRpb25Sb2xlczsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGdldENsYXNzRGVzY3JpcHRpb24oKSB7Ci0JCXJldHVybiBjdXN0b21pemVkKENMQVNTX0RFU0MpOwotCX0KLQotCS8qKgotCSAqIFJldHVybnMgdGhlIGdlbmVyYXRlZCBjbGFzcyBzY29wZSwgb25lIG9mIHtAbGluayAjUFVCTElDX1NDT1BFfXwKLQkgKiB7QGxpbmsgI1BST1RFQ1RFRF9TQ09QRX0gfHtAbGluayAjUFJJVkFURV9TQ09QRX0uIFRoaXMgbWV0aG9kIG5ldmVyCi0JICogcmV0dXJucyBudWxsIChkZWZhdWx0cyB0byBwdWJsaWMpLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0Q2xhc3NTY29wZSgpIHsKLQkJU3RyaW5nIHNjb3BlID0gY3VzdG9taXplZChDTEFTU19TQ09QRSk7Ci0JCWlmIChzY29wZSA9PSBudWxsKSB7Ci0JCQlzY29wZSA9IFBVQkxJQ19TQ09QRTsKLQkJfQotCQlyZXR1cm4gc2NvcGU7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXRFeHRlbmRzKCkgewotCQlyZXR1cm4gY3VzdG9taXplZChFWFRFTkRTKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBzZXRFeHRlbmRzKFN0cmluZyBiYXNlQ2xhc3MpIHsKLQkJc2V0Q3VzdG9taXplZChFWFRFTkRTLCBiYXNlQ2xhc3MpOwotCX0KLQotCXB1YmxpYyBMaXN0PFN0cmluZz4gZ2V0SW1wbGVtZW50cygpIHsKLQkJU3RyaW5nIHN0ciA9IGN1c3RvbWl6ZWQoSU1QTEVNRU5UUyk7Ci0JCUxpc3Q8U3RyaW5nPiByZXN1bHQgPSBTdHJpbmdVdGlsLnN0clRvTGlzdChzdHIsICcsJywgdHJ1ZS8qIHRyaW0gKi8pOwotCQlpZiAocmVzdWx0ID09IG51bGwpIHsKLQkJCXJlc3VsdCA9IENvbGxlY3Rpb25zLmVtcHR5TGlzdCgpOwotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0SW1wbGVtZW50cyhMaXN0PFN0cmluZz4gaW50ZXJmYWNlcykgewotCQlzZXRDdXN0b21pemVkKElNUExFTUVOVFMsIFN0cmluZ1V0aWwubGlzdFRvU3RyKGludGVyZmFjZXMsICcsJykpOwotCX0KLQotCS8qKgotCSAqIFJldHVybnMgdGhlIHN0cmluZyB0aGF0IHNob3VsZCBiZSBnZW5lcmF0ZWQgaW4gdGhlIEphdmEgY2xhc3MgZm9yIGV4dGVuZHMKLQkgKiBhbmQgaW1wbGVtZW50cy4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdlbmVyYXRlRXh0ZW5kc0ltcGxlbWVudHMoKSB7Ci0JCVN0cmluZ0J1ZmZlciBidWZmZXIgPSBuZXcgU3RyaW5nQnVmZmVyKCk7Ci0JCVN0cmluZyBleHRlbmRzQ2xhc3MgPSBnZXRFeHRlbmRzKCk7Ci0JCWlmIChleHRlbmRzQ2xhc3MgIT0gbnVsbCAmJiAhZXh0ZW5kc0NsYXNzLmVxdWFscygiamF2YS5sYW5nLk9iamVjdCIpICYmICFleHRlbmRzQ2xhc3MuZXF1YWxzKCJPYmplY3QiKSkgewotCQkJYnVmZmVyLmFwcGVuZCgiZXh0ZW5kcyAiICsgc2ltcGxpZnlDbGFzc05hbWUoZXh0ZW5kc0NsYXNzKSk7Ci0JCX0KLQkJYnVmZmVyLmFwcGVuZCgiIGltcGxlbWVudHMgU2VyaWFsaXphYmxlIik7IC8vIGFzc3VtaW5nIHRoYXQgdGhlIEphdmEKLQkJCQkJCQkJCQkJCQkvLyBmaWxlIHRlbXBsYXRlIGltcG9ydHMgdGhlCi0JCQkJCQkJCQkJCQkJLy8gamF2YS5pby5TZXJpYWxpemFibGUKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IGl0ZXIgPSBnZXRJbXBsZW1lbnRzKCkuaXRlcmF0b3IoKTsgaXRlci5oYXNOZXh0KCk7KSB7Ci0JCQlidWZmZXIuYXBwZW5kKCIsICIgKyBzaW1wbGlmeUNsYXNzTmFtZShpdGVyLm5leHQoKSkpOwotCQl9Ci0JCXJldHVybiBidWZmZXIudG9TdHJpbmcoKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBzaW1wbGlmeUNsYXNzTmFtZShTdHJpbmcgZnVsbENsYXNzTmFtZSkgewotCQlmaW5hbCBTdHJpbmcgSkFWQV9MQU5HID0gImphdmEubGFuZy4iOwotCQlpZiAoZnVsbENsYXNzTmFtZS5zdGFydHNXaXRoKEpBVkFfTEFORykpIHsKLQkJCXJldHVybiBmdWxsQ2xhc3NOYW1lLnN1YnN0cmluZyhKQVZBX0xBTkcubGVuZ3RoKCkpOwotCQl9Ci0JCVN0cmluZyBwa2cgPSBTdHJpbmdVdGlsLmdldFBhY2thZ2VOYW1lKGZ1bGxDbGFzc05hbWUpOwotCQlpZiAocGtnICE9IG51bGwgJiYgU3RyaW5nVXRpbC5lcXVhbE9iamVjdHMocGtnLCBnZXRQYWNrYWdlKCkpKSB7Ci0JCQlyZXR1cm4gU3RyaW5nVXRpbC5nZXRDbGFzc05hbWUoZnVsbENsYXNzTmFtZSk7Ci0JCX0KLQkJcmV0dXJuIGZ1bGxDbGFzc05hbWU7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0aGUgaWQgZ2VuZXJhdG9yIHNjaGVtZSAoYXNzaWduZWQsIHNlcXVlbmNlLCBldGMpLiBEb2VzIG5vdAotCSAqIHJldHVybiBudWxsLCBkZWZhdWx0cyB0byAiYXNzaWduZWQiIG9yICJpZGVudGl0eSIgZGVwZW5kaW5nIG9uIHdoZXRoZXIKLQkgKiB0aGUgdGFibGUgaGFzIGFuIGlkZW50aXR5IGNvbHVtbi4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdldElkR2VuZXJhdG9yKCkgewotCQlTdHJpbmcgZ2VuZXJhdG9yID0gY3VzdG9taXplZChJRF9HRU5FUkFUT1IpOwotCQlTdHJpbmcgbm9uZUdlbmVyYXRvciA9IGdldEN1c3RvbWl6ZXIoKS5nZXROb0lkR2VuZXJhdG9yKCk7Ci0JCWlmICghaXNEZWZhdWx0c1RhYmxlKCkpIHsKLQkJCS8qCi0JCQkgKiBUaGlzIGlzIGRvbmUgbWFpbmx5IGJlY2F1c2UgdGhlcmUgbWlnaHQgYmUgY2FzZXMgd2hlcmUgc29tZQotCQkJICogdGFibGVzIGhhdmUgYXV0b2luY3RlbWVudCBwayBhbmQgb3RoZXJzIGFyZSBhc3NpZ25lZC4gSW4gdGhpcwotCQkJICogY2FzZSB0aGlzIG1ha2VzIGl0IHNvIHRoYXQgaXQgaXMgcG9zc2libGUgdG8gaGF2ZSBhICJub25lIgotCQkJICogZGVmYXVsdCB2YWx1ZSB0aGF0IGlzIGludGVycHJldGVkIGRlcGVuZGluZyBvbiB0aGUgY2FzZS4KLQkJCSAqLwotCQkJaWYgKGdlbmVyYXRvciA9PSBudWxsIHx8IGdlbmVyYXRvci5lcXVhbHMobm9uZUdlbmVyYXRvcikpIHsKLQkJCQlPUk1HZW5Db2x1bW4gcGtDb2x1bW4gPSBnZXRQcmltYXJ5S2V5Q29sdW1uKCk7Ci0JCQkJaWYgKHBrQ29sdW1uICE9IG51bGwgJiYgRFRQVXRpbC5pc0F1dG9JbmNyZW1lbnQocGtDb2x1bW4uZ2V0RGJDb2x1bW4oKSkpIHsKLQkJCQkJZ2VuZXJhdG9yID0gZ2V0Q3VzdG9taXplcigpLmdldElkZW50aXR5SWRHZW5lcmF0b3IoKTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGdlbmVyYXRvciA9PSBudWxsKSB7Ci0JCQlnZW5lcmF0b3IgPSBub25lR2VuZXJhdG9yOwotCQl9Ci0JCXJldHVybiBnZW5lcmF0b3I7Ci0JfQotCi0JLyoqCi0JICogQ2hhbmdlcyB0aGUgaWQgZ2VuZXJhdG9yIHNjaGVtZSAoYXNzaWduZWQsIHNlcXVlbmNlLCBldGMpLgotCSAqLwotCXB1YmxpYyB2b2lkIHNldElkR2VuZXJhdG9yKFN0cmluZyBzY2hlbWUpIHsKLQkJc2V0Q3VzdG9taXplZChJRF9HRU5FUkFUT1IsIHNjaGVtZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0aGUgc2VxdWVuY2UgbmFtZSBmb3IgdGhlIGdpdmVuIHRhYmxlLCBvciBudWxsIGlmIG5vbmUgKG1ha2VzCi0JICogc2Vuc2Ugb25seSB3aGVuIHRoZSBzY2hlbWUgaXMgbmF0aXZlLCBzZXF1ZW5jZSwgLi4pLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0U2VxdWVuY2UoKSB7Ci0JCXJldHVybiBjdXN0b21pemVkKFNFUVVFTkNFKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBzZXRTZXF1ZW5jZShTdHJpbmcgbmFtZSkgewotCQlzZXRDdXN0b21pemVkKFNFUVVFTkNFLCBuYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm5zIHRoZSBzZXF1ZW5jZSBuYW1lIGFmdGVyIHJlcGxhY2luZyB0aGUgJHt0YWJsZX0gYW5kICR7cGt9IGJ5IHRoZWlyCi0JICogdmFsdWVzLCBvciBudWxsIGlmIG5vbmUuCi0JICovCi0JcHVibGljIFN0cmluZyBnZXRGb3JtYXR0ZWRTZXF1ZW5jZSgpIHsKLQkJU3RyaW5nIHNlcXVlbmNlID0gZ2V0U2VxdWVuY2UoKTsKLQkJaWYgKHNlcXVlbmNlICE9IG51bGwpIHsKLQkJCS8qIHJlc29sdmUgdGhlICR7dGFibGV9IGFuZCAke3BrfSBwYXR0ZXJucyAqLwotCQkJc2VxdWVuY2UgPSBTdHJpbmdVdGlsLnN0clJlcGxhY2Uoc2VxdWVuY2UsIFRBQkxFX1NFUV9QQVRURVJOLCBnZXROYW1lKCkpOwotCQkJaWYgKHNlcXVlbmNlLmluZGV4T2YoUEtfU0VRX1BBVFRFUk4pID49IDApIHsKLQkJCQlMaXN0PFN0cmluZz4gcGtOYW1lcyA9IERUUFV0aWwuZ2V0UHJpbWFyeUtleUNvbHVtbk5hbWVzKGdldERiVGFibGUoKSk7Ci0JCQkJU3RyaW5nIHBrTmFtZSA9IG51bGw7Ci0JCQkJaWYgKHBrTmFtZXMuc2l6ZSgpID4gMCkgewotCQkJCQlwa05hbWUgPSBwa05hbWVzLmdldCgwKTsKLQkJCQl9Ci0JCQkJc2VxdWVuY2UgPSBTdHJpbmdVdGlsLnN0clJlcGxhY2Uoc2VxdWVuY2UsIFBLX1NFUV9QQVRURVJOLCBwa05hbWUpOwotCQkJfQotCQl9Ci0JCXJldHVybiBzZXF1ZW5jZSAhPSBudWxsID8gc2VxdWVuY2UudG9VcHBlckNhc2UoKSA6ICIiOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGlzSW1wbGVtZW50RXF1YWxzKCkgewotCQlyZXR1cm4gISJ0cnVlIi5lcXVhbHMoY3VzdG9taXplZChJTVBMRU1FTlRfRVFVQUxTKSk7IC8vIGRlZmF1bHRzIHRvCi0JCQkJCQkJCQkJCQkJCQkJLy8gZmFsc2UKLQl9Ci0KLQlwdWJsaWMgdm9pZCBzZXRJbXBsZW1lbnRFcXVhbHMoYm9vbGVhbiB2YWx1ZSkgewotCQlzZXRDdXN0b21pemVkQm9vbGVhbihJTVBMRU1FTlRfRVFVQUxTLCB2YWx1ZSwgdHJ1ZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0cnVlIGlmIHRoZXJlIGlzIGFueSBjb2x1bW4gcGFydGljaXBhdGluZyBpbiBlcXVhbHMvaGFzaGNvZGUuCi0JICovCi0JcHVibGljIGJvb2xlYW4gaGFzQ29sdW1uc0luRXF1YWxzKCkgewotCQlMaXN0PE9STUdlbkNvbHVtbj4gY29sdW1ucyA9IGdldFNpbXBsZUNvbHVtbnMoKTsKLQkJZm9yIChpbnQgaSA9IDAsIG4gPSBjb2x1bW5zLnNpemUoKTsgaSA8IG47ICsraSkgewotCQkJT1JNR2VuQ29sdW1uIGNvbHVtbiA9IGNvbHVtbnMuZ2V0KGkpOwotCQkJaWYgKGNvbHVtbi5pc1VzZUluRXF1YWxzKCkpIHsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB7QGxpbmsgI0dFTkVSQVRFX0RETF9BTk5PVEFUSU9OfSBpbmRpY2F0aW5nIHdoZXRoZXIgdGhlIG9wdGlvbmFsCi0JICogRERMIHBhcmFtZXRlcnMgbGlrZSBsZW5ndGgsIG51bGxhYmxlLCB1bnFpdWUsIGV0YyBzaG91bGQgYmUgZ2VuZXJhdGVkIGluIEBDb2x1bW4KLQkgKiBhbm5vdGF0aW9uLiBkZWZhdWx0cyB0byBmYWxzZS4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBpc0dlbmVyYXRlRERMQW5ub3RhdGlvbnMoKSB7Ci0JCXJldHVybiAidHJ1ZSIuZXF1YWxzKGN1c3RvbWl6ZWQoT1JNR2VuQ3VzdG9taXplci5HRU5FUkFURV9ERExfQU5OT1RBVElPTikpOyAvLyBkZWZhdWx0cwotCQkJCQkJCQkJCQkJCQkJCQkJCQkJLy8gdG8KLQkJCQkJCQkJCQkJCQkJCQkJCQkJCS8vIGZhbHNlCi0JfQotCi0JcHVibGljIHZvaWQgc2V0R2VuZXJhdGVERExBbm5vdGF0aW9ucyhib29sZWFuIGdlbmVyYXRlKSB7Ci0JCXNldEN1c3RvbWl6ZWRCb29sZWFuKE9STUdlbkN1c3RvbWl6ZXIuR0VORVJBVEVfRERMX0FOTk9UQVRJT04sIGdlbmVyYXRlLCBmYWxzZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyBvbmUgb2Yge0BsaW5rICNQUk9QRVJUWV9BQ0NFU1N9fHtAbGluayAjRklFTERfQUNDRVNTfSBpbmRpY2F0aW5nCi0JICogaG93IHRoZSBlbnRpdHkgcHJvcGVydGllcyBhcmUgbWFwcGVkLiBEb2VzIG5vdCByZXR1cm4gbnVsbCAoZGVmYXVsdHMgdG8KLQkgKiB7QGxpbmsgI0ZJRUxEX0FDQ0VTU30pLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0QWNjZXNzKCkgewotCQlTdHJpbmcgbmFtZSA9IGN1c3RvbWl6ZWQoQUNDRVNTKTsKLQkJaWYgKG5hbWUgPT0gbnVsbCkgewotCQkJbmFtZSA9IEZJRUxEX0FDQ0VTUzsKLQkJfQotCQlyZXR1cm4gbmFtZTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBzZXRBY2Nlc3MoU3RyaW5nIGFjY2VzcykgewotCQlhc3NlcnQgKGFjY2VzcyA9PSBudWxsIHx8IGFjY2Vzcy5lcXVhbHMoUFJPUEVSVFlfQUNDRVNTKSB8fCBhY2Nlc3MuZXF1YWxzKEZJRUxEX0FDQ0VTUykpOwotCQlpZiAoIVN0cmluZ1V0aWwuZXF1YWxPYmplY3RzKGFjY2VzcywgZ2V0QWNjZXNzKCkpKSB7Ci0JCQlzZXRDdXN0b21pemVkKEFDQ0VTUywgYWNjZXNzKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFJldHVybnMgb25lIG9mIHtAbGluayAjTEFaWV9GRVRDSH18e0BsaW5rICNFQUdFUl9GRVRDSH0gaW5kaWNhdGluZyBob3cKLQkgKiB0aGUgdGFibGUgYXNzb2NpYXRpb25zIGFyZSBmZWNoZWQuIFJldHVybnMgbnVsbCBpZiB0aGUgcHJvdmlkZXIgZGVmYXVsdHMKLQkgKiBzaG91bGQgYmUgdXNlZC4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdldERlZmF1bHRGZXRjaCgpIHsKLQkJcmV0dXJuIGN1c3RvbWl6ZWQoREVGQVVMVF9GRVRDSCk7Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0RGVmYXVsdEZldGNoKFN0cmluZyBmZXRjaCkgewotCQlhc3NlcnQgKGZldGNoID09IG51bGwgfHwgZmV0Y2guZXF1YWxzKExBWllfRkVUQ0gpIHx8IGZldGNoLmVxdWFscyhFQUdFUl9GRVRDSCkpOwotCQlzZXRDdXN0b21pemVkKERFRkFVTFRfRkVUQ0gsIGZldGNoKTsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nW10gZ2V0U3VwcG9ydGVkQ29sbGVjdGlvblR5cGVzKCkgewotCQlyZXR1cm4gbmV3IFN0cmluZ1tdIHsKLQkJCVNFVF9DT0xMRUNUSU9OX1RZUEUsIExJU1RfQ09MTEVDVElPTl9UWVBFCi0JCX07Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyBvbmUgb2Yge0BsaW5rICNMSVNUX0NPTExFQ1RJT05fVFlQRX18e0BsaW5rICNTRVRfQ09MTEVDVElPTl9UWVBFfQotCSAqIGluZGljYXRpbmcgdGhlIEphdmEgdHlwZSAoZnVsbCBjbGFzcyBuYW1lKSB1c2VkIGZvciBwcm9wZXJ0aWVzIG9mCi0JICogY29sbGVjdGlvbiB0eXBlcy4gVGhpcyBkb2VzIG5vdCByZXR1cm4gbnVsbCAoZGVmYXVsdHMgdG8gbGlzdCkuCi0JICovCi0JcHVibGljIFN0cmluZyBnZXREZWZhdWx0Q29sbGVjdGlvblR5cGUoKSB7Ci0JCVN0cmluZyBjVHlwZSA9IGN1c3RvbWl6ZWQoREVGQVVMVF9DT0xMRUNUSU9OX1RZUEUpOwotCQlpZiAoY1R5cGUgPT0gbnVsbCkgewotCQkJY1R5cGUgPSBTRVRfQ09MTEVDVElPTl9UWVBFOwotCQl9Ci0JCXJldHVybiBjVHlwZTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBzZXREZWZhdWx0Q29sbGVjdGlvblR5cGUoU3RyaW5nIGNUeXBlKSB7Ci0JCWFzc2VydCAoY1R5cGUuZXF1YWxzKExJU1RfQ09MTEVDVElPTl9UWVBFKSB8fCBjVHlwZS5lcXVhbHMoU0VUX0NPTExFQ1RJT05fVFlQRSkpOwotCQlzZXRDdXN0b21pemVkKERFRkFVTFRfQ09MTEVDVElPTl9UWVBFLCBjVHlwZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyB0cnVlIGlmIHRoZSBwcmltYXJ5IGtleSBpcyBjb21wb3VuZCBhbmQgYW55IG9mIGl0cyBjb2x1bW5zIHNob3VsZAotCSAqIGJlIGluY2x1ZGVkIGluIHRoZSA8Y29kZT5lcXVhbHM8L2NvZGU+IG1ldGhvZCBpbXBsZW1lbnRhdGlvbi4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBpc0NvbXBvdW5kS2V5VXNlSW5FcXVhbHMoKSB7Ci0JCWlmIChpc0NvbXBvc2l0ZUtleSgpKSB7Ci0JCQlmb3IgKEl0ZXJhdG9yPE9STUdlbkNvbHVtbj4gaXRlciA9IGdldFByaW1hcnlLZXlDb2x1bW5zKCkuaXRlcmF0b3IoKTsgaXRlci5oYXNOZXh0KCk7KSB7Ci0JCQkJT1JNR2VuQ29sdW1uIGNvbHVtbiA9IGl0ZXIubmV4dCgpOwotCQkJCWlmIChjb2x1bW4uaXNVc2VJbkVxdWFscygpKSB7Ci0JCQkJCXJldHVybiB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaXNSb2xlVXNlSW5FcXVhbHMoQXNzb2NpYXRpb25Sb2xlIHJvbGUpIHsKLQkJZm9yIChJdGVyYXRvcjxPUk1HZW5Db2x1bW4+IGl0ZXIgPSByb2xlLmdldFJlZmVycmVyQ29sdW1ucygpLml0ZXJhdG9yKCk7IGl0ZXIuaGFzTmV4dCgpOykgewotCQkJT1JNR2VuQ29sdW1uIGNvbHVtbiA9IGl0ZXIubmV4dCgpOwotCQkJaWYgKGNvbHVtbi5pc1VzZUluRXF1YWxzKCkpIHsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRydWUgaWYgdGhlIHZhbHVlcyBvZiBuYW1lIGVsZW1lbnQgaW4gdGhlIEBUYWJsZSBpcyBkZWZhdWx0IHNvIHdlCi0JICogY2FuIHNraXAgZ2VuZXJhdGluZyB0aGUgYW5ub3RhdGlvbgotCSAqIAotCSAqIEByZXR1cm4gdHJ1ZQotCSAqLwotCXB1YmxpYyBib29sZWFuIGlzRGVmYXVsdG5hbWUoKSB7Ci0JCVN0cmluZyBlbnRpdHlOYW1lID0gZ2V0Q2xhc3NOYW1lKCk7Ci0JCVN0cmluZyBhbm5vdGF0aW9uTmFtZSA9IHRoaXMubUN1c3RvbWl6ZXIuZ2V0RGF0YWJhc2VBbm5vdGF0aW9uTmFtZUJ1aWxkZXIoKS5idWlsZFRhYmxlQW5ub3RhdGlvbk5hbWUoZW50aXR5TmFtZSwgbURiVGFibGUpOwotCQlyZXR1cm4gYW5ub3RhdGlvbk5hbWUgPT0gbnVsbDsKLQl9Ci0KLQkvKioKLQkgKiBRdWFsaWZpZXMgYSBjbGFzcyBuYW1lIGlmIHRoZXJlIGlzIGEgcGFja2FnZS4KLQkgKi8KLQlwcml2YXRlIFN0cmluZyBxdWFsaWZ5KFN0cmluZyBjbGFzc05hbWUpIHsKLQkJU3RyaW5nIHBrZyA9IGdldFBhY2thZ2UoKTsKLQkJaWYgKHBrZyAhPSBudWxsICYmIHBrZy5sZW5ndGgoKSAhPSAwKSB7Ci0JCQljbGFzc05hbWUgPSBwa2cgKyAnLicgKyBjbGFzc05hbWU7Ci0JCX0KLQkJcmV0dXJuIGNsYXNzTmFtZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm5zIHRydWUgaWYgdGhlIGdpdmVuIGNvbHVtbiBpcyBwYXJ0IG9mIGFueSBhc3NvY2lhdGlvbi4KLQkgKi8KLQlwcml2YXRlIGJvb2xlYW4gaXNDb2x1bW5JbkFzc2NvY2lhdGlvbihPUk1HZW5Db2x1bW4gY29sdW1uLCBMaXN0PEFzc29jaWF0aW9uUm9sZT4gcm9sZXMpIHsKLQkJZm9yIChpbnQgaSA9IDAsIG4gPSByb2xlcy5zaXplKCk7IGkgPCBuOyArK2kpIHsKLQkJCUFzc29jaWF0aW9uUm9sZSByb2xlID0gcm9sZXMuZ2V0KGkpOwotCQkJTGlzdDxPUk1HZW5Db2x1bW4+IGNvbHMgPSByb2xlLmdldFJlZmVycmVyQ29sdW1ucygpOwotCQkJZm9yIChPUk1HZW5Db2x1bW4gY29sIDogY29scykgewotCQkJCWlmIChjb2wuZ2V0TmFtZSgpLmVxdWFscyhjb2x1bW4uZ2V0TmFtZSgpKSkgewotCQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCS8qKgotCSAqIFByaW50IHRoZSBjbGF1c2UgdG8gYmUgdXNlZCBpbiB0aGUgZ2VuZXJhdGVkIGVxdWFscygpIG1ldGhvZAotCSAqIAotCSAqIEByZXR1cm4gU3RyaW5nCi0JICovCi0JcHVibGljIFN0cmluZyBnZXRQcmltYXJ5S2V5RXF1YWxzQ2xhdXNlKCkgewotCQlTdHJpbmdCdWlsZGVyIGJ1ZiA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7Ci0JCUl0ZXJhdG9yPE9STUdlbkNvbHVtbj4gY29sdW1ucyA9IHRoaXMuZ2V0UHJpbWFyeUtleUNvbHVtbnMoKS5pdGVyYXRvcigpOwotCQl3aGlsZSAoY29sdW1ucy5oYXNOZXh0KCkpIHsKLQkJCXRoaXMucHJpbnRQcmltYXJ5S2V5RXF1YWxzQ2xhdXNlT24oY29sdW1ucy5uZXh0KCksIGJ1Zik7Ci0JCQlpZiAoY29sdW1ucy5oYXNOZXh0KCkpIHsKLQkJCQlidWYuYXBwZW5kKCJcbiIpOwotCQkJCWJ1Zi5hcHBlbmQoIlx0XHRcdCIpOwotCQkJCWJ1Zi5hcHBlbmQoIiYmICIpOwotCQkJfQotCQl9Ci0JCWJ1Zi5hcHBlbmQoIjsiKTsKLQkJcmV0dXJuIGJ1Zi50b1N0cmluZygpOwotCX0KLQotCXByaXZhdGUgdm9pZCBwcmludFByaW1hcnlLZXlFcXVhbHNDbGF1c2VPbihPUk1HZW5Db2x1bW4gY29sdW1uLCBTdHJpbmdCdWlsZGVyIGJ1ZikgewotCQlTdHJpbmcgZmllbGROYW1lID0gY29sdW1uLmdldFByb3BlcnR5TmFtZSgpOwotCQlKYXZhVHlwZSBqYXZhVHlwZSA9IGNvbHVtbi5nZXREYkNvbHVtbigpLmdldFByaW1hcnlLZXlKYXZhVHlwZSgpOwotCQlpZiAoamF2YVR5cGUuaXNQcmltaXRpdmUoKSkgewotCQkJdGhpcy5wcmludFByaW1pdGl2ZUVxdWFsc0NsYXVzZU9uKGZpZWxkTmFtZSwgYnVmKTsKLQkJfQotCQllbHNlIHsKLQkJCXRoaXMucHJpbnRSZWZlcmVuY2VFcXVhbHNDbGF1c2VPbihmaWVsZE5hbWUsIGJ1Zik7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRQcmltaXRpdmVFcXVhbHNDbGF1c2VPbihTdHJpbmcgZmllbGROYW1lLCBTdHJpbmdCdWlsZGVyIGJ1ZikgewotCQlidWYuYXBwZW5kKCIodGhpcy4iKTsKLQkJYnVmLmFwcGVuZChmaWVsZE5hbWUpOwotCQlidWYuYXBwZW5kKCIgPT0gY2FzdE90aGVyLiIpOwotCQlidWYuYXBwZW5kKGZpZWxkTmFtZSk7Ci0JCWJ1Zi5hcHBlbmQoJyknKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRSZWZlcmVuY2VFcXVhbHNDbGF1c2VPbihTdHJpbmcgZmllbGROYW1lLCBTdHJpbmdCdWlsZGVyIGJ1ZikgewotCQlidWYuYXBwZW5kKCJ0aGlzLiIpOwotCQlidWYuYXBwZW5kKGZpZWxkTmFtZSk7Ci0JCWJ1Zi5hcHBlbmQoIi5lcXVhbHMoY2FzdE90aGVyLiIpOwotCQlidWYuYXBwZW5kKGZpZWxkTmFtZSk7Ci0JCWJ1Zi5hcHBlbmQoJyknKTsKLQl9Ci0KLQkvKioKLQkgKiBQcmludCB0aGUgY2xhdXNlIHRvIGJlIHVzZWQgaW4gdGhlIGdlbmVyYXRlZCBoYXNDb2RlKCkgbWV0aG9kCi0JICogCi0JICogQHJldHVybiBTdHJpbmcKLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdldFByaW1hcnlLZXlIYXNoQ29kZUNsYXVzZSgpIHsKLQkJU3RyaW5nQnVpbGRlciBidWYgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQlJdGVyYXRvcjxPUk1HZW5Db2x1bW4+IGNvbHVtbnMgPSB0aGlzLmdldFByaW1hcnlLZXlDb2x1bW5zKCkuaXRlcmF0b3IoKTsKLQkJd2hpbGUgKGNvbHVtbnMuaGFzTmV4dCgpKSB7Ci0JCQlidWYuYXBwZW5kKCJoYXNoID0gaGFzaCAqIHByaW1lICsgIik7Ci0JCQl0aGlzLnByaW50UHJpbWFyeUtleUhhc2hDb2RlQ2xhdXNlT24oY29sdW1ucy5uZXh0KCksIGJ1Zik7Ci0JCQlidWYuYXBwZW5kKCc7Jyk7Ci0JCQlidWYuYXBwZW5kKCdcbicpOwotCQkJYnVmLmFwcGVuZCgiXHRcdCIpOwotCQl9Ci0JCXJldHVybiBidWYudG9TdHJpbmcoKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRQcmltYXJ5S2V5SGFzaENvZGVDbGF1c2VPbihPUk1HZW5Db2x1bW4gY29sdW1uLCBTdHJpbmdCdWlsZGVyIGJ1ZikgewotCQlTdHJpbmcgZmllbGROYW1lID0gY29sdW1uLmdldFByb3BlcnR5TmFtZSgpOwotCQlKYXZhVHlwZSBqYXZhVHlwZSA9IGNvbHVtbi5nZXREYkNvbHVtbigpLmdldFByaW1hcnlLZXlKYXZhVHlwZSgpOwotCQlpZiAoamF2YVR5cGUuaXNQcmltaXRpdmUoKSkgewotCQkJdGhpcy5wcmludFByaW1pdGl2ZUhhc2hDb2RlQ2xhdXNlT24oamF2YVR5cGUuZ2V0RWxlbWVudFR5cGVOYW1lKCksIGZpZWxkTmFtZSwgYnVmKTsKLQkJfQotCQllbHNlIHsKLQkJCXRoaXMucHJpbnRSZWZlcmVuY2VIYXNoQ29kZUNsYXVzZU9uKGZpZWxkTmFtZSwgYnVmKTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBwcmludFByaW1pdGl2ZUhhc2hDb2RlQ2xhdXNlT24oU3RyaW5nIHByaW1pdGl2ZU5hbWUsIFN0cmluZyBmaWVsZE5hbWUsIFN0cmluZ0J1aWxkZXIgYnVmKSB7Ci0JCWlmIChwcmltaXRpdmVOYW1lLmVxdWFscygiaW50IikpIHsKLQkJCS8vIHRoaXMudmFsdWUKLQkJCWJ1Zi5hcHBlbmQoInRoaXMuIik7Ci0JCQlidWYuYXBwZW5kKGZpZWxkTmFtZSk7Ci0JCX0KLQkJZWxzZSBpZiAocHJpbWl0aXZlTmFtZS5lcXVhbHMoInNob3J0IikgfHwgcHJpbWl0aXZlTmFtZS5lcXVhbHMoImJ5dGUiKSB8fCBwcmltaXRpdmVOYW1lLmVxdWFscygiY2hhciIpKSB7IC8vIGV4cGxpY2l0Ci0JCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCS8vIGNhc3QKLQkJCS8vICgoaW50KSB0aGlzLnZhbHVlKQotCQkJYnVmLmFwcGVuZCgiKChpbnQpIHRoaXMuIik7Ci0JCQlidWYuYXBwZW5kKGZpZWxkTmFtZSk7Ci0JCQlidWYuYXBwZW5kKCcpJyk7Ci0JCX0KLQkJZWxzZSBpZiAocHJpbWl0aXZlTmFtZS5lcXVhbHMoImxvbmciKSkgeyAvLyBjcmliYmVkIGZyb20gTG9uZyNoYXNoQ29kZSgpCi0JCQkvLyAoKGludCkgKHRoaXMudmFsdWUgXiAodGhpcy52YWx1ZSA+Pj4gMzIpKSkKLQkJCWJ1Zi5hcHBlbmQoIigoaW50KSAodGhpcy4iKTsKLQkJCWJ1Zi5hcHBlbmQoZmllbGROYW1lKTsKLQkJCWJ1Zi5hcHBlbmQoIiBeICh0aGlzLiIpOwotCQkJYnVmLmFwcGVuZChmaWVsZE5hbWUpOwotCQkJYnVmLmFwcGVuZCgiID4+PiAzMikpKSIpOwotCQl9Ci0JCWVsc2UgaWYgKHByaW1pdGl2ZU5hbWUuZXF1YWxzKCJmbG9hdCIpKSB7IC8vIGNyaWJiZWQgZnJvbQotCQkJCQkJCQkJCQkJCS8vIEZsb2F0I2hhc2hDb2RlKCkKLQkJCS8vIGphdmEubGFuZy5GbG9hdC5mbG9hdFRvSW50Qml0cyh0aGlzLnZhbHVlKQotCQkJYnVmLmFwcGVuZCgiamF2YS5sYW5nLkZsb2F0Iik7Ci0JCQlidWYuYXBwZW5kKCIuZmxvYXRUb0ludEJpdHModGhpcy4iKTsKLQkJCWJ1Zi5hcHBlbmQoZmllbGROYW1lKTsKLQkJCWJ1Zi5hcHBlbmQoJyknKTsKLQkJfQotCQllbHNlIGlmIChwcmltaXRpdmVOYW1lLmVxdWFscygiZG91YmxlIikpIHsgLy8gY3JpYmJlZCBmcm9tCi0JCQkJCQkJCQkJCQkJLy8gRG91YmxlI2hhc2hDb2RlKCkKLQkJCS8vICgoaW50KSAoamF2YS5sYW5nLkRvdWJsZS5kb3VibGVUb0xvbmdCaXRzKHRoaXMudmFsdWUpIF4KLQkJCS8vIChqYXZhLmxhbmcuRG91YmxlLmRvdWJsZVRvTG9uZ0JpdHModGhpcy52YWx1ZSkgPj4+IDMyKSkpCi0JCQlidWYuYXBwZW5kKCIoKGludCkgKCIpOwotCQkJYnVmLmFwcGVuZCgiamF2YS5sYW5nLkRvdWJsZSIpOwotCQkJYnVmLmFwcGVuZCgiLmRvdWJsZVRvTG9uZ0JpdHModGhpcy4iKTsKLQkJCWJ1Zi5hcHBlbmQoZmllbGROYW1lKTsKLQkJCWJ1Zi5hcHBlbmQoIikgXiAoIik7Ci0JCQlidWYuYXBwZW5kKCJqYXZhLmxhbmcuRG91YmxlIik7Ci0JCQlidWYuYXBwZW5kKCIuZG91YmxlVG9Mb25nQml0cyh0aGlzLiIpOwotCQkJYnVmLmFwcGVuZChmaWVsZE5hbWUpOwotCQkJYnVmLmFwcGVuZCgiKSA+Pj4gMzIpKSkiKTsKLQkJfQotCQllbHNlIGlmIChwcmltaXRpdmVOYW1lLmVxdWFscygiYm9vbGVhbiIpKSB7Ci0JCQkvLyAodGhpcy52YWx1ZSA/IDEgOiAwKQotCQkJYnVmLmFwcGVuZCgiKHRoaXMuIik7Ci0JCQlidWYuYXBwZW5kKGZpZWxkTmFtZSk7Ci0JCQlidWYuYXBwZW5kKCIgPyAxIDogMCkiKTsKLQkJfQotCQllbHNlIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24ocHJpbWl0aXZlTmFtZSk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgcHJpbnRSZWZlcmVuY2VIYXNoQ29kZUNsYXVzZU9uKFN0cmluZyBmaWVsZE5hbWUsIFN0cmluZ0J1aWxkZXIgYnVmKSB7Ci0JCWJ1Zi5hcHBlbmQoInRoaXMuIik7Ci0JCWJ1Zi5hcHBlbmQoZmllbGROYW1lKTsKLQkJYnVmLmFwcGVuZCgiLmhhc2hDb2RlKCkiKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gIm5hbWU9IiArIHRoaXMuZ2V0TmFtZSgpICsgIjsgY29sdW1ucz0iICsgQXJyYXlzLnRvU3RyaW5nKHRoaXMuZ2V0Q29sdW1uTmFtZXMoKS50b0FycmF5KCkpOwotCX0KLQotCS8qIGNsYXNzIHNjb3BlcyAqLwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFBVQkxJQ19TQ09QRSA9ICJwdWJsaWMiOwotCi0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgUFJPVEVDVEVEX1NDT1BFID0gInByb3RlY3RlZCI7Ci0KLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBQUklWQVRFX1NDT1BFID0gInByaXZhdGUiOwotCi0JLyogYWNjZXNzIGNvbnN0YW50cy4gTm90ZSB0aGF0IHRoZXNlIHN0cmluZ3MgYXJlIHVzZWQgaW4gdGhlIHVpICovCi0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgUFJPUEVSVFlfQUNDRVNTID0gInByb3BlcnR5IjsKLQotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIEZJRUxEX0FDQ0VTUyA9ICJmaWVsZCI7Ci0KLQkvKgotCSAqIGRlZmF1bHQgZmVjaCBjb25zdGFudHMuIE5vdGUgdGhhdCB0aGVzZSBzdHJpbmdzIGFyZSB1c2VkIGluIHRoZSBnZW4KLQkgKiB2ZWxvY2l0eSB0ZW1wbGF0ZXMuCi0JICovCi0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgREVGQVVMVF9GRVRDSCA9ICJkZWZhdWx0RmV0Y2giOwotCi0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgTEFaWV9GRVRDSCA9ICJsYXp5IjsKLQotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIEVBR0VSX0ZFVENIID0gImVhZ2VyIjsKLQotCS8qCi0JICogZGVmYXVsdCBjb2xsZWN0aW9uIHR5cGUgY29uc3RhbnRzLiBOb3RlIHRoYXQgdGhlc2Ugc3RyaW5ncyBhcmUgdXNlZCBpbgotCSAqIHRoZSBnZW4gdmVsb2NpdHkgdGVtcGxhdGVzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIExJU1RfQ09MTEVDVElPTl9UWVBFID0gImphdmEudXRpbC5MaXN0IjsKLQotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFNFVF9DT0xMRUNUSU9OX1RZUEUgPSAiamF2YS51dGlsLlNldCI7Ci0KLQkvKioKLQkgKiBUaGUgcGF0dGVybiByZXBsYWNlZCBieSB0aGUgdGFibGUgbmFtZSBpbiB0aGUgaWQgZ2VuZXJhdG9yIHNlcXVlbmNlIG5hbWUKLQkgKiBwYXJhbS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBUQUJMRV9TRVFfUEFUVEVSTiA9ICIkdGFibGUiOwotCi0JLyoqCi0JICogVGhlIHBhdHRlcm4gcmVwbGFjZWQgYnkgdGhlIHByaW1hcnkga2V5IGluIHRoZSBpZCBnZW5lcmF0b3Igc2VxdWVuY2UgbmFtZQotCSAqIHBhcmFtLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFBLX1NFUV9QQVRURVJOID0gIiRwayI7Ci0KLQkvKiBjdXN0b21pemF0aW9uIHByb3BlcnRpZXMgKi8KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgUEFDS0FHRSA9ICJwYWNrYWdlIjsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBTUkNfRk9MREVSID0gInNyY0ZvbGRlciI7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQ0xBU1NfTkFNRSA9ICJjbGFzc05hbWUiOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIENMQVNTX0RFU0MgPSAiY2xhc3NEZXNjIjsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBDTEFTU19TQ09QRSA9ICJjbGFzc1Njb3BlIjsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBFWFRFTkRTID0gImV4dGVuZHMiOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIElNUExFTUVOVFMgPSAiaW1wbGVtZW50cyI7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgSURfR0VORVJBVE9SID0gImlkR2VuZXJhdG9yIjsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBTRVFVRU5DRSA9ICJzZXF1ZW5jZSI7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQ09NUE9TSVRFX0tFWV9DTEFTU19OQU1FID0gImNvbXBvc2l0ZUtleUNsYXNzTmFtZSI7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgSU1QTEVNRU5UX0VRVUFMUyA9ICJpbXBsZW1lbnRFcXVhbHMiOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEFDQ0VTUyA9ICJhY2Nlc3MiOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIERFRkFVTFRfQ09MTEVDVElPTl9UWVBFID0gImRlZmF1bHRDb2xsZWN0aW9uVHlwZSI7Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9PdmVyd3JpdGVDb25maXJtZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL092ZXJ3cml0ZUNvbmZpcm1lci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4ZTlkN2UxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL092ZXJ3cml0ZUNvbmZpcm1lci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsMjsKLQotcHVibGljIGludGVyZmFjZSBPdmVyd3JpdGVDb25maXJtZXIgewotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBlbnRpdHkgZ2VuZXJhdG9yIHNob3VsZCBvdmVyd3JpdGUgdGhlIHNwZWNpZmllZAotCSAqIGZpbGUuCi0JICovCi0JYm9vbGVhbiBvdmVyd3JpdGUoU3RyaW5nIGNsYXNzTmFtZSk7Ci0KLQotCWZpbmFsIGNsYXNzIEFsd2F5cyBpbXBsZW1lbnRzIE92ZXJ3cml0ZUNvbmZpcm1lciB7Ci0JCXB1YmxpYyBzdGF0aWMgZmluYWwgT3ZlcndyaXRlQ29uZmlybWVyIElOU1RBTkNFID0gbmV3IEFsd2F5cygpOwotCQlwdWJsaWMgc3RhdGljIE92ZXJ3cml0ZUNvbmZpcm1lciBpbnN0YW5jZSgpIHsKLQkJCXJldHVybiBJTlNUQU5DRTsKLQkJfQotCQkvLyBlbnN1cmUgc2luZ2xlIGluc3RhbmNlCi0JCXByaXZhdGUgQWx3YXlzKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQkvLyBldmVyeXRoaW5nIHdpbGwgYmUgb3ZlcndyaXR0ZW4KLQkJcHVibGljIGJvb2xlYW4gb3ZlcndyaXRlKFN0cmluZyBhcmcwKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiT3ZlcndyaXRlQ29uZmlybWVyLkFsd2F5cyI7ICAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLQotCWZpbmFsIGNsYXNzIE5ldmVyIGltcGxlbWVudHMgT3ZlcndyaXRlQ29uZmlybWVyIHsKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBPdmVyd3JpdGVDb25maXJtZXIgSU5TVEFOQ0UgPSBuZXcgTmV2ZXIoKTsKLQkJcHVibGljIHN0YXRpYyBPdmVyd3JpdGVDb25maXJtZXIgaW5zdGFuY2UoKSB7Ci0JCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCX0KLQkJLy8gZW5zdXJlIHNpbmdsZSBpbnN0YW5jZQotCQlwcml2YXRlIE5ldmVyKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQkvLyBub3RoaW5nIHdpbGwgYmUgb3ZlcndyaXR0ZW4KLQkJcHVibGljIGJvb2xlYW4gb3ZlcndyaXRlKFN0cmluZyBhcmcwKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gIk92ZXJ3cml0ZUNvbmZpcm1lci5OZXZlciI7ICAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9QYWNrYWdlR2VuZXJhdG9yMi5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbDIvUGFja2FnZUdlbmVyYXRvcjIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMTc1NTQwMC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9QYWNrYWdlR2VuZXJhdG9yMi5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjg2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLQotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsMjsKLQotaW1wb3J0IGphdmEuaW8uQnl0ZUFycmF5SW5wdXRTdHJlYW07Ci1pbXBvcnQgamF2YS5pby5GaWxlOwotaW1wb3J0IGphdmEuaW8uSU9FeGNlcHRpb247Ci1pbXBvcnQgamF2YS5pby5TdHJpbmdXcml0ZXI7Ci1pbXBvcnQgamF2YS5uZXQuVVJMOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuUHJvcGVydGllczsKLWltcG9ydCBqYXZhLnV0aWwubG9nZ2luZy5MZXZlbDsKLWltcG9ydCBqYXZhLnV0aWwubG9nZ2luZy5Mb2dnZXI7Ci0KLWltcG9ydCBvcmcuYXBhY2hlLnZlbG9jaXR5LlZlbG9jaXR5Q29udGV4dDsKLWltcG9ydCBvcmcuYXBhY2hlLnZlbG9jaXR5LmFwcC5WZWxvY2l0eUVuZ2luZTsKLWltcG9ydCBvcmcuYXBhY2hlLnZlbG9jaXR5LnJ1bnRpbWUubG9nLkpka0xvZ0NodXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklGaWxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklGb2xkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkNvcmVFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkZpbGVMb2NhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5JUHJvZ3Jlc3NNb25pdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5JU3RhdHVzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5OdWxsUHJvZ3Jlc3NNb25pdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5QYXRoOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5QbGF0Zm9ybTsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuU3RhdHVzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5TdWJNb25pdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklKYXZhUHJvamVjdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JUGFja2FnZUZyYWdtZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklQYWNrYWdlRnJhZ21lbnRSb290OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLkphdmFNb2RlbEV4Y2VwdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsMi51dGlsLkNvbXBpbGF0aW9uVW5pdE1vZGlmaWVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5nZW4uaW50ZXJuYWwyLnV0aWwuRmlsZVV0aWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDIudXRpbC5VcmxVdGlsOwotaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kudXRpbC5OTFM7Ci1pbXBvcnQgb3JnLm9zZ2kuZnJhbWV3b3JrLkJ1bmRsZTsKLQotLyoqCi0gKiBUaGlzIGdlbmVyYXRvciB3aWxsIGdlbmVyYXRlIGEgcGFja2FnZSBvZiBlbnRpdGllcyBmb3IgYSBzZXQgb2YgdGFibGVzLgotICovCi1wdWJsaWMgY2xhc3MgUGFja2FnZUdlbmVyYXRvcjIgeyAKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBMT0dHRVJfTkFNRSA9ICJvcmcuZWNsaXBzZS5qcHQuZW50aXRpZXMuZ2VuLmxvZyI7IC8vJE5PTi1OTFMtMSQKLQlwcml2YXRlIElKYXZhUHJvamVjdCBqYXZhUHJvamVjdDsKLQlwcml2YXRlIE9STUdlbkN1c3RvbWl6ZXIgY3VzdG9taXplciA7IAotCXByaXZhdGUgc3RhdGljIE92ZXJ3cml0ZUNvbmZpcm1lciBvdmVyd3JpdGVDb25maXJtZXIgPSBudWxsOwotCi0Jc3RhdGljIHB1YmxpYyB2b2lkIHNldE92ZXJ3cml0ZUNvbmZpcm1lcihPdmVyd3JpdGVDb25maXJtZXIgY29uZmlybWVyKXsKLQkJb3ZlcndyaXRlQ29uZmlybWVyID0gY29uZmlybWVyOwotCX0KLQkvKioKLQkgKiBAcGFyYW0gY3VzdG9taXplcgotCSAqIEBwYXJhbSBzeW5jaHJvbml6ZVBlcnNpc3RlbmNlWG1sCi0JICogQHBhcmFtIGNvcHlKZGJjRHJpdmUKLQkgKiBAdGhyb3dzIEV4Y2VwdGlvbiAKLQkgKi8KLQlzdGF0aWMgcHVibGljIHZvaWQgZ2VuZXJhdGUoSUphdmFQcm9qZWN0IGpwYVByb2plY3QsIE9STUdlbkN1c3RvbWl6ZXIgY3VzdG9taXplciwgSVByb2dyZXNzTW9uaXRvciBtb25pdG9yICkgdGhyb3dzIENvcmVFeGNlcHRpb24gewotCQlQYWNrYWdlR2VuZXJhdG9yMiBnZW5lcmF0b3IgPSBuZXcgUGFja2FnZUdlbmVyYXRvcjIoKTsKLQkJZ2VuZXJhdG9yLnNldFByb2plY3QoanBhUHJvamVjdCk7Ci0JCWdlbmVyYXRvci5zZXRDdXN0b21pemVyKGN1c3RvbWl6ZXIpOwotCQkKLQkJdHJ5IHsKLQkJCWdlbmVyYXRvci5kb0dlbmVyYXRlKCAgbW9uaXRvcik7Ci0JCX0gY2F0Y2ggKEV4Y2VwdGlvbiBlKSB7Ci0JCQl0aHJvdyBuZXcgQ29yZUV4Y2VwdGlvbihuZXcgU3RhdHVzKElTdGF0dXMuRVJST1IsIEpwdEdlblBsdWdpbi5QTFVHSU5fSUQsIEpwdEdlbk1lc3NhZ2VzLkVycm9yX0dlbmVyYXRpbmdfRW50aXRpZXMsIGUpKTsKLQkJfQotCX0KLQkKLQlwcml2YXRlIE9iamVjdCBnZXRDdXN0b21pemVyKCkgewotCQlyZXR1cm4gdGhpcy5jdXN0b21pemVyOwotCX0KLQotCXByaXZhdGUgdm9pZCBzZXRDdXN0b21pemVyKE9STUdlbkN1c3RvbWl6ZXIgY3VzdG9taXplcjIpIHsKLQkJdGhpcy5jdXN0b21pemVyID0gY3VzdG9taXplcjI7Ci0JfQotCQotCXByaXZhdGUgdm9pZCBzZXRQcm9qZWN0KElKYXZhUHJvamVjdCBwcm9qICl7Ci0JCXRoaXMuamF2YVByb2plY3QgPSBwcm9qOwotCX0KLQkKLQlwcm90ZWN0ZWQgdm9pZCBkb0dlbmVyYXRlKCAgSVByb2dyZXNzTW9uaXRvciBtb25pdG9yICkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWdlbmVyYXRlSW50ZXJuYWwoIG1vbml0b3IgKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBnZW5lcmF0ZUludGVybmFsKCBJUHJvZ3Jlc3NNb25pdG9yIHByb2dyZXNzKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJRmlsZSB0ZW1wbERpciA9IHByZXBhcmVUZW1wbGF0ZXNGb2xkZXIoKTsKLQotCQlMaXN0PFN0cmluZz4gZ2VuQ2xhc3NlcyA9IG5ldyBqYXZhLnV0aWwuQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJTGlzdDxTdHJpbmc+IHRhYmxlTmFtZXMgPSBjdXN0b21pemVyLmdldEdlblRhYmxlTmFtZXMoKTsKLQotCQkvKiAuamF2YSBwZXIgdGFibGUsIHBlcnNpc3RlbmNlLnhtbCwgcmVmcmVzaCBwYWNrYWdlIGZvbGRlciAqLwotCQlTdHJpbmcgdGFza05hbWUgPSBOTFMuYmluZChKcHRHZW5NZXNzYWdlcy5FbnRpdHlHZW5lcmF0b3JfdGFza05hbWUsICJUb3RhbCAiKyB0YWJsZU5hbWVzLnNpemUoKSArIDIpOy8vJE5PTi1OTFMtMSQKLQkJcHJvZ3Jlc3MuYmVnaW5UYXNrKHRhc2tOYW1lLCB0YWJsZU5hbWVzLnNpemUoKSArIDIpOwotCi0KLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IGl0ZXIgPSB0YWJsZU5hbWVzLml0ZXJhdG9yKCk7IGl0ZXIuaGFzTmV4dCgpOykgewotCQkJU3RyaW5nIHRhYmxlTmFtZSA9IGl0ZXIubmV4dCgpOwotCQkJT1JNR2VuVGFibGUgdGFibGUgPSBjdXN0b21pemVyLmdldFRhYmxlKHRhYmxlTmFtZSk7Ci0KLQkJCVN0cmluZyBjbGFzc05hbWUgPSB0YWJsZS5nZXRRdWFsaWZpZWRDbGFzc05hbWUoKTsKLQotCQkJZ2VuZXJhdGVDbGFzcyh0YWJsZSwgdGVtcGxEaXIuZ2V0QWJzb2x1dGVQYXRoKCksIHByb2dyZXNzKTsKLQkJCXByb2dyZXNzLndvcmtlZCgxKTsKLQotCQkJZ2VuQ2xhc3Nlcy5hZGQoIGNsYXNzTmFtZSApOwotCQkJLyoKLQkJCSAqIGFkZCB0aGUgY29tcG9zaXRlIGtleSBjbGFzcyB0byBwZXJzaXN0ZW5jZS54bWwgYmVjYXVzZSBzb21lIAotCQkJICogSlBBIHByb3ZpZGVyKGUuZy4gS29kbykgcmVxdWlyZXMgaXQuIEhpYmVybmF0ZSBkb2Vzbid0IHNlZW0gdG8gY2FyZSkuIAotCQkJICovCi0JCQlpZiAodGFibGUuaXNDb21wb3NpdGVLZXkoKSkgewotCQkJCWdlbkNsYXNzZXMuYWRkKHRhYmxlLmdldFF1YWxpZmllZENvbXBvc2l0ZUtleUNsYXNzTmFtZSgpKTsKLQkJCX0KLQkJfQotCQlwcm9ncmVzcy5kb25lKCk7Ci0JfQotCi0JcHJpdmF0ZSBGaWxlIHByZXBhcmVUZW1wbGF0ZXNGb2xkZXIoKSB0aHJvd3MgSU9FeGNlcHRpb24sIEV4Y2VwdGlvbiwKLQkJCUNvcmVFeGNlcHRpb24gewotCQkvL1ByZXBhcmUgdGhlIFZlbG9jaXR5IHRlbXBsYXRlIGZvbGRlcjoKLQkJLy9JZiB0aGUgcGx1Zy1pbiBpcyBwYWNrYWdlZCBhcyBhIEpBUiwgd2UgbmVlZCBleHRyYWN0IHRoZSB0ZW1wbGF0ZSAKLQkJLy9mb2xkZXIgaW50byB0aGUgcGx1Zy1pbiBzdGF0ZSBsb2NhdGlvbi4gVGhpcyBpcyByZXF1aXJlZCBieSBWZWxvY2l0eQotCQkvL3NpbmNlIHdlIHVzZSBpbmNsdWRlZCB0ZW1wbGF0ZXMuCi0JCUJ1bmRsZSBidW5kbGUgPSBQbGF0Zm9ybS5nZXRCdW5kbGUoSnB0R2VuUGx1Z2luLlBMVUdJTl9JRCk7Ci0JCVN0cmluZyB0ZW1wbGF0ZXNQYXRoID0gInRlbXBsYXRlcy9lbnRpdGllcy8iOyAgLy8kTk9OLU5MUy0xJAotCQlQYXRoIHBhdGggPSBuZXcgUGF0aCggdGVtcGxhdGVzUGF0aCk7Ci0JCVVSTCB1cmwgPSBGaWxlTG9jYXRvci5maW5kKGJ1bmRsZSwgcGF0aCwgbnVsbCk7Ci0JCWlmICggdXJsID09bnVsbCAgKSB7Ci0JCQl0aHJvdyBuZXcgQ29yZUV4Y2VwdGlvbihuZXcgU3RhdHVzKElTdGF0dXMuRVJST1IsIEpwdEdlblBsdWdpbi5QTFVHSU5fSUQsICBKcHRHZW5NZXNzYWdlcy5UZW1wbGF0ZXNfbm90Rm91bmQgKyAiICIrICBKcHRHZW5QbHVnaW4uUExVR0lOX0lEICsgIi8iICsgdGVtcGxhdGVzUGF0aCkgKTsvLyROT04tTkxTLTEkCi0JCX0JCQotCQlVUkwgdGVtcGxVcmwgPSBGaWxlTG9jYXRvci5yZXNvbHZlKHVybCk7Ci0JCQotCQkvL0hhdmUgdGhpcyBjaGVjayBzbyB0aGF0IHRoZSBjb2RlIHdvdWxkIHdvcmsgaW4gYm90aCBQREUgYW5kIEpBUmVkIHBsdWctaW4gYXQgcnVudGltZQotCQlGaWxlIHRlbXBsRGlyID0gbnVsbDsKLQkJaWYoIFVybFV0aWwuaXNKYXJVcmwodGVtcGxVcmwpICl7Ci0JCQl0ZW1wbERpciA9IEZpbGVVdGlsLmV4dHJhY3RGaWxlc0Zyb21CdW5kbGUoIHRlbXBsVXJsLCBidW5kbGUsIHRlbXBsYXRlc1BhdGggKTsKLQkJfWVsc2V7Ci0JCQl0ZW1wbERpciA9IFVybFV0aWwuZ2V0VXJsRmlsZSh0ZW1wbFVybCk7Ci0JCX0KLQkJCi0KLQkJaWYgKHRlbXBsRGlyPT1udWxsIHx8ICF0ZW1wbERpci5leGlzdHMoKSkgewotCQkJdGhyb3cgbmV3IENvcmVFeGNlcHRpb24obmV3IFN0YXR1cyhJU3RhdHVzLkVSUk9SLCBKcHRHZW5QbHVnaW4uUExVR0lOX0lELCAgSnB0R2VuTWVzc2FnZXMuVGVtcGxhdGVzX25vdEZvdW5kICsgIiAiKyAgSnB0R2VuUGx1Z2luLlBMVUdJTl9JRCApICk7Ly8kTk9OLU5MUy0xJAotCQl9Ci0JCXJldHVybiB0ZW1wbERpcjsKLQl9Ci0JCi0JLyoqCi0JICogU2F2ZXMvQ3JlYXRlcyB0aGUgLmphdmEgZmlsZSBjb3JyZXNwb25kaW5nIHRvIGEgZGF0YWJhc2UgdGFibGUgCi0JICogd2l0aCB0aGUgZ2l2ZW4gY29udGVudC4KLQkgKiAKLQkgKiBAcGFyYW0gdGVtcGxEaXIgVGhlIHZlbG9jaXR5IHRlbXBsYXRlIGZpbGUgZGlyZWN0b3J5LiBJdCBpcyBhc3N1bWVkIAotCSAqIHRoYXQgdGhpcyBkaXJlY3RvcnkgY29udGFpbnMgdGhlIDIgZmlsZXMgPGVtPm1haW4uamF2YS52bTwvZW0+IAotCSAqIGFuZCA8ZW0+cGsuamF2YS52bTwvZW0+IAotCSAqIEBwYXJhbSBwcm9ncmVzcyAKLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBnZW5lcmF0ZUNsYXNzKE9STUdlblRhYmxlIHRhYmxlLCBTdHJpbmcgdGVtcGxhdGVEaXJQYXRoLCBJUHJvZ3Jlc3NNb25pdG9yIG1vbml0b3IpIHRocm93cyBFeGNlcHRpb24gewotCi0JCVN0cmluZyBzdWJUYXNrTmFtZSA9IE5MUy5iaW5kKEpwdEdlbk1lc3NhZ2VzLkVudGl0eUdlbmVyYXRvcl90YXNrTmFtZSwgdGFibGUuZ2V0TmFtZSgpKTsKLQkJU3ViTW9uaXRvciBzbSA9IFN1Yk1vbml0b3IuY29udmVydChtb25pdG9yLCBzdWJUYXNrTmFtZSwgMTAwKTsKLQotCQl0cnl7Ci0JCQlJRm9sZGVyIGphdmFQYWNrYWdlRm9sZGVyID0gZ2V0SmF2YVBhY2thZ2VGb2xkZXIodGFibGUsIG1vbml0b3IpOwotCQkJSUZpbGUgamF2YUZpbGUgPSBqYXZhUGFja2FnZUZvbGRlci5nZXRGaWxlKCB0YWJsZS5nZXRDbGFzc05hbWUoKSArICIuamF2YSIpOyAvLyROT04tTkxTLTEkCi0JCQkKLQkJCWlmKCBqYXZhRmlsZS5leGlzdHMoKSApewotCQkJCWlmKCBvdmVyd3JpdGVDb25maXJtZXIhPW51bGwgJiYgIW92ZXJ3cml0ZUNvbmZpcm1lci5vdmVyd3JpdGUoamF2YUZpbGUuZ2V0TmFtZSgpKSApCi0JCQkJCXJldHVybjsKLQkJCX0KLQkJCS8vSmRrTG9nQ2h1dGUgaW4gdGhpcyB2ZXJzaW9uIG9mIFZlbG9jaXR5IG5vdCBhbGxvdyB0byBzZXQgbG9nIGxldmVsCi0JCQkvL1dvcmthcm91bmQgYnkgcHJlc2V0IHRoZSBsb2cgbGV2ZWwgYmVmb3JlIFZlbG9jaXR5IGlzIGluaXRpYWxpemVkCi0JCQlMb2dnZXIgbG9nZ2VyID0gTG9nZ2VyLmdldExvZ2dlciggTE9HR0VSX05BTUUgKTsKLQkJCWxvZ2dlci5zZXRMZXZlbCggTGV2ZWwuU0VWRVJFICk7Ci0JCQkKLQkJCVByb3BlcnRpZXMgdmVwID0gbmV3IFByb3BlcnRpZXMoKTsKLQkJCXZlcC5zZXRQcm9wZXJ0eSgiZmlsZS5yZXNvdXJjZS5sb2FkZXIucGF0aCIsIHRlbXBsYXRlRGlyUGF0aCk7IC8vJE5PTi1OTFMtMSQKLQkJCXZlcC5zZXRQcm9wZXJ0eSggSmRrTG9nQ2h1dGUuUlVOVElNRV9MT0dfSkRLX0xPR0dFUiwgTE9HR0VSX05BTUUgKTsKLQkJCVZlbG9jaXR5RW5naW5lIHZlID0gbmV3IFZlbG9jaXR5RW5naW5lKCk7Ci0JCSAgICB2ZS5pbml0KHZlcCk7Ci0JCSAgICBzbS53b3JrZWQoMjApOwotCQkgICAgCi0JCSAgICBnZW5lcmF0ZUphdmFGaWxlKHRhYmxlLCBqYXZhRmlsZSwgdmUsICJtYWluLmphdmEudm0iLCB0cnVlLyppc0RvbWFpbkNsYXNzKi8sIG1vbml0b3IpOyAvLyROT04tTkxTLTEkCi0JCSAgICBzbS53b3JrZWQoODApOwotCQkgICAgCi0JCSAgICBpZiAodGFibGUuaXNDb21wb3NpdGVLZXkoKSkgewotCQkgICAgCUlGaWxlIGNvbXBvc2l0ZUtleUZpbGUgPSBqYXZhUGFja2FnZUZvbGRlci5nZXRGaWxlKCB0YWJsZS5nZXRDb21wb3NpdGVLZXlDbGFzc05hbWUoKSsiLmphdmEiKTsgLy8kTk9OLU5MUy0xJAotCQkgICAgCWdlbmVyYXRlSmF2YUZpbGUodGFibGUsIGNvbXBvc2l0ZUtleUZpbGUsIHZlLCAicGsuamF2YS52bSIsIGZhbHNlLyppc0RvbWFpbkNsYXNzKi8sIG1vbml0b3IgKTsgLy8kTk9OLU5MUy0xJAotCQkgICAgfQotCQkgICAgCi0JCQlqYXZhRmlsZS5yZWZyZXNoTG9jYWwoMSwgbmV3IE51bGxQcm9ncmVzc01vbml0b3IoKSk7Ci0JCQkKLQkJfSBjYXRjaChUaHJvd2FibGUgZSl7Ci0JCQlDb3JlRXhjZXB0aW9uIGNlID0gbmV3IENvcmVFeGNlcHRpb24obmV3IFN0YXR1cyhJU3RhdHVzLkVSUk9SLCBKcHRHZW5QbHVnaW4uUExVR0lOX0lELCBKcHRHZW5NZXNzYWdlcy5UZW1wbGF0ZXNfbm90Rm91bmQgKyAiIiArIEpwdEdlblBsdWdpbi5QTFVHSU5fSUQgLCBlKSApOy8vJE5PTi1OTFMtMSQKLQkJCUpwdEdlblBsdWdpbi5sb2dFeGNlcHRpb24oIGNlICk7Ci0JCX0KLQkJc20uc2V0V29ya1JlbWFpbmluZygwKTsKLQl9Ci0JCi0JcHJpdmF0ZSB2b2lkIGdlbmVyYXRlSmF2YUZpbGUoT1JNR2VuVGFibGUgdGFibGUsIElGaWxlIGphdmFGaWxlLCBWZWxvY2l0eUVuZ2luZSB2ZQotCQkJLCBTdHJpbmcgdGVtcGxhdGVOYW1lLCBib29sZWFuIGlzRG9tYWluQ2xhc3MsIElQcm9ncmVzc01vbml0b3IgbW9uaXRvcikgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVZlbG9jaXR5Q29udGV4dCBjb250ZXh0ID0gbmV3IFZlbG9jaXR5Q29udGV4dCgpOwotICAgICAgICBjb250ZXh0LnB1dCgidGFibGUiLCB0YWJsZSk7IC8vJE5PTi1OTFMtMSQKLSAgICAgICAgY29udGV4dC5wdXQoImN1c3RvbWl6ZXIiLCBnZXRDdXN0b21pemVyKCkpOyAvLyROT04tTkxTLTEkCi0gICAgICAgIAotCQlTdHJpbmdXcml0ZXIgdyA9IG5ldyBTdHJpbmdXcml0ZXIoKTsKLQkJdmUubWVyZ2VUZW1wbGF0ZSh0ZW1wbGF0ZU5hbWUsIGNvbnRleHQsIHcpOwotCQkKLQkJU3RyaW5nIGZpbGVDb250ZW50ID0gdy50b1N0cmluZygpOwotCQlpZiAoamF2YUZpbGUuZXhpc3RzKCkpIHsKLQkJCWlmIChpc0RvbWFpbkNsYXNzKSB7Ci0JCQkJdXBkYXRlRXhpc3RpbmdEb21haW5DbGFzcyh0YWJsZS5nZXRRdWFsaWZpZWRDbGFzc05hbWUoKSwgamF2YUZpbGUsIGZpbGVDb250ZW50KTsKLQkJCX0gZWxzZSB7Ci0JCQkJamF2YUZpbGUuc2V0Q29udGVudHMobmV3IEJ5dGVBcnJheUlucHV0U3RyZWFtKGZpbGVDb250ZW50LmdldEJ5dGVzKCkpLCB0cnVlLCB0cnVlLCBtb25pdG9yICk7Ci0JCQl9Ci0JCX0gZWxzZSB7Ci0JCQljcmVhdGVGaWxlKGphdmFGaWxlLCBuZXcgQnl0ZUFycmF5SW5wdXRTdHJlYW0oZmlsZUNvbnRlbnQuZ2V0Qnl0ZXMoKSkpOwotCQl9CQkKLQl9Ci0JCi0JCi0JLyoqCi0JICogVXBkYXRlcyB0aGUgKGV4aXN0aW5nKSBKYXZhIGZpbGUgY29ycmVzcG9uZGluZyB0byB0aGUgZ2l2ZW4gY2xhc3MuCi0JICogCi0JICogQHBhcmFtIGNsYXNzTmFtZSBUaGUgcXVhbGlmaWVkIGNsYXNzIG5hbWUuCi0JICogCi0JICogQHBhcmFtIGphdmFGaWxlIFRoZSBleGlzdGluZyBKYXZhIGZpbGUgb2YgdGhlIGNsYXNzIHRvIHVwZGF0ZS4KLQkgKiAKLQkgKiBAcGFyYW0gZmlsZUNvbnRlbnQgVGhlIG5ldyBmaWxlIGNvbnRlbnQuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgdXBkYXRlRXhpc3RpbmdEb21haW5DbGFzcyhTdHJpbmcgY2xhc3NOYW1lLCBJRmlsZSBqYXZhRmlsZSwgU3RyaW5nIGZpbGVDb250ZW50KSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJLyp1c2UgQ29tcGlsYXRpb25Vbml0TW9kaWZpZXIgaW5zdGVhZCBvZiBjYWxsaW5nIFdpZGVFbnYuZ2V0RW52KCkuc2V0RmlsZUNvbnRlbnQgCi0JCSAqIHNvIHRoYXQgaWYgdGhlIHVuaXQgaXMgdXAgdG8gZGF0ZSBpZiBpdCBpcyB1c2VkIGJlZm9yZSBmaWxlIGNoYW5nZSAKLQkJICogbm90aWZpY2F0aW9ucyBhcmUgZGVsaXZlcmVkIChzZWUgRUpCM0ltcG9ydFNjaGVtYVdpemFyZC51cGRhdGVFeGlzdGluZ0RvbWFpbkNsYXNzIGZvciBleGFtcGxlKSovCi0JCUlKYXZhUHJvamVjdCBwcm9qZWN0ID0gamF2YVByb2plY3QuZ2V0SmF2YVByb2plY3QoKTsKLQkJQ29tcGlsYXRpb25Vbml0TW9kaWZpZXIgbW9kaWZpZXIgPSBuZXcgQ29tcGlsYXRpb25Vbml0TW9kaWZpZXIocHJvamVjdCwgY2xhc3NOYW1lKTsKLQkJbW9kaWZpZXIuc2V0SmF2YVNvdXJjZShmaWxlQ29udGVudCk7Ci0JCW1vZGlmaWVyLnNhdmUoKTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgY3JlYXRlRmlsZShJRmlsZSBmaWxlLCBqYXZhLmlvLklucHV0U3RyZWFtIGNvbnRlbnRzKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7CQkKLQkJZmlsZS5jcmVhdGUoY29udGVudHMsIGZhbHNlLCBudWxsLyptb25pdG9yKi8pOwotCX0KLQkKLQlwdWJsaWMgSUZvbGRlciBnZXRKYXZhUGFja2FnZUZvbGRlcihPUk1HZW5UYWJsZSB0YWJsZSwgSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7Ci0JCUlQYWNrYWdlRnJhZ21lbnRSb290IHJvb3QgPSBnZXREZWZhdWx0SmF2YVNyb3VjZUxvY2F0aW9uICggamF2YVByb2plY3QgKSA7Ci0JCVN0cmluZyBwYWNrYWdlTmFtZSA9IHRhYmxlLmdldFBhY2thZ2UoKTsKLQkJaWYoIHBhY2thZ2VOYW1lPT1udWxsICkgcGFja2FnZU5hbWUgPSIiOwotCQlJUGFja2FnZUZyYWdtZW50IHBhY2thZ2VGcmFnbWVudCA9IHJvb3QuZ2V0UGFja2FnZUZyYWdtZW50KHBhY2thZ2VOYW1lKTsKLQkJaWYoICFwYWNrYWdlRnJhZ21lbnQuZXhpc3RzKCkpewotCQkJcm9vdC5jcmVhdGVQYWNrYWdlRnJhZ21lbnQocGFja2FnZU5hbWUsIHRydWUsIG1vbml0b3IpOwotCQl9CQkKLQkJcmV0dXJuIChJRm9sZGVyKXBhY2thZ2VGcmFnbWVudC5nZXRSZXNvdXJjZSgpOwotCX0KLQkKLQlwcml2YXRlIElQYWNrYWdlRnJhZ21lbnRSb290IGdldERlZmF1bHRKYXZhU3JvdWNlTG9jYXRpb24oSUphdmFQcm9qZWN0IGpwcm9qZWN0KXsKLQkJaWYgKGpwcm9qZWN0ICE9IG51bGwpIHsKLQkJCXRyeSB7Ci0JCQkJaWYgKGpwcm9qZWN0LmV4aXN0cygpKSB7Ci0JCQkJCUlQYWNrYWdlRnJhZ21lbnRSb290W10gcm9vdHMgPSBqcHJvamVjdC5nZXRQYWNrYWdlRnJhZ21lbnRSb290cygpOwotCQkJCQlmb3IgKGludCBpPSAwOyBpIDwgcm9vdHMubGVuZ3RoOyBpKyspIHsKLQkJCQkJCWlmIChyb290c1tpXS5nZXRLaW5kKCkgPT0gSVBhY2thZ2VGcmFnbWVudFJvb3QuS19TT1VSQ0UpIHsKLQkJCQkJCQlyZXR1cm4gcm9vdHNbaV0gOyAKLQkJCQkJCX0KLQkJCQkJfQkJCQkJCQkKLQkJCQl9Ci0JCQl9IGNhdGNoIChKYXZhTW9kZWxFeGNlcHRpb24gZSkgewotCQkJCUpwdEdlblBsdWdpbi5sb2dFeGNlcHRpb24oZSk7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIG51bGw7Ci0JfQotCi0JCi0JLy8gKioqKioqKioqKiBhbm5vdGF0aW9uIG5hbWUgYnVpbGRlciAqKioqKioqKioqCi0KLQkKLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL1RhZ05hbWVzLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi9UYWdOYW1lcy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5MmE2MGZlLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL1RhZ05hbWVzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5nZW4uaW50ZXJuYWwyOwotCi0vKioKLSAqIFRPRE86IG1lcmdlIHdpdGggSlBBIGNsYXNzID8KLSAqIFRoZSBKUEEgbWFwcGluZyB0YWcgYW5kIGF0dHJpYnV0ZSBuYW1lcy4KLSAqIAotICovCi1wdWJsaWMgY2xhc3MgVGFnTmFtZXMKLXsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBCQVNJQ19UQUcgPSAiYmFzaWMiOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIENBU0NBREVfVEFHID0gImNhc2NhZGUiOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIENPTFVNTl9UQUcgPSAiY29sdW1uIjsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBFTUJFRERFRF9UQUcgPSAiZW1iZWRkZWQiOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIEVNQkVEREVEX0lEX1RBRyA9ICJlbWJlZGRlZC1pZCI7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgR0VORVJBVEVEX1ZBTFVFX1RBRyA9ICJnZW5lcmF0ZWQtdmFsdWUiOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIElEX1RBRyA9ICJpZCI7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgSURfQ0xBU1NfVEFHID0gImlkIjsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBKT0lOX0NPTFVNTl9UQUcgPSAiam9pbi1jb2x1bW4iOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIElOVkVSU0VfSk9JTl9DT0xVTU5fVEFHID0gImludmVyc2Utam9pbi1jb2x1bW4iOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIExPQl9UQUcgPSAibG9iIjsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBNQU5ZX1RPX01BTllfVEFHID0gIm1hbnktdG8tbWFueSI7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgTUFOWV9UT19PTkVfVEFHID0gIm1hbnktdG8tb25lIjsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBNQVBQRURfQllfVEFHID0gIm1hcHBlZC1ieSI7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgT05FX1RPX01BTllfVEFHID0gIm9uZS10by1tYW55IjsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBPTkVfVE9fT05FX1RBRyA9ICJvbmUtdG8tb25lIjsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBQS19KT0lOX0NPTFVNTl9UQUcgPSAicHJpbWFyeS1rZXktam9pbi1jb2x1bW4iOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFRBQkxFX1RBRyA9ICJ0YWJsZSI7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgVkVSU0lPTl9UQUcgPSAidmVyc2lvbiI7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgSk9JTl9UQUJMRV9UQUcgPSAiam9pbi10YWJsZSI7Ci0KLQkvKmNhc2NhZGUgdGFncyovCi0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgQUxMX0NBU0NBREUgPSAiYWxsIjsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBQRVJTSVNUX0NBU0NBREUgPSAicGVyc2lzdCI7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgTUVSR0VfQ0FTQ0FERSA9ICJtZXJnZSI7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgUkVNT1ZFX0NBU0NBREUgPSAicmVtb3ZlIjsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBSRUZSRVNIX0NBU0NBREUgPSAicmVmcmVzaCI7Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi91dGlsL0NvbXBpbGF0aW9uVW5pdE1vZGlmaWVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi91dGlsL0NvbXBpbGF0aW9uVW5pdE1vZGlmaWVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDA0Y2Y2MzYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi9pbnRlcm5hbDIvdXRpbC9Db21waWxhdGlvblVuaXRNb2RpZmllci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTMxICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDIudXRpbDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklDb21waWxhdGlvblVuaXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSUphdmFQcm9qZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLkphdmFNb2RlbEV4Y2VwdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uQVNUOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5BU1RQYXJzZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkNvbXBpbGF0aW9uVW5pdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS50ZXh0LkRvY3VtZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLnRleHQuZWRpdHMuVGV4dEVkaXQ7Ci0KLQotLyoqCi0gKiBQZXJmb3JtcyB0aGUgZ3J1bnQgd29yayBuZWVkZWQgZm9yIG1vZGlmeWluZyBhIGNvbXBpbGF0aW9uIAotICogdW5pdCBhbmQgcGVyZm9ybXMgdGhlIG1vZGlmaWVkIGNvbXBpbGF0aW9uIHVuaXQgc2F2ZS4KLSAqIAotICogVGhlIHR5cGljYWwgdXNhZ2UgaXMgYXMgZm9sbG93czoKLSAqIDxvbD48bGk+Q3JlYXRlIGFuIGluc3RhbmNlLgotICogCi0gKiA8bGk+TW9kaWZ5IHRoZSBjb21waWxhdGlvbiB1bml0IHVzaW5nIEFTVCBvcGVyYXRpb25zIHBlcmZvcm1lZCAKLSAqIAlvbiB0aGUgbm9kZSByZXR1cm5lZCBieSB7QGxpbmsgI2dldENvbXBpbGF0aW9uVW5pdE5vZGUoKX0uCi0gKiAgQWx0ZXJuYXRpdmVseSB5b3UgY2FuIGNhbGwgPGNvZGU+c2V0SmF2YVNvdXJjZTwvY29kZT4gdG8gY2hhbmdlIHRoZSBlbnRpcmUgc291cmNlIGNvZGUuIAotICogCi0gKiA8bGk+Q2FsbCB0aGUge0BsaW5rICNzYXZlKCl9IG1ldGhvZC4KLSAqIAotICovCi1wdWJsaWMgY2xhc3MgQ29tcGlsYXRpb25Vbml0TW9kaWZpZXIKLXsKLQlwcml2YXRlIElKYXZhUHJvamVjdCBtUHJvamVjdDsKLQlwcml2YXRlIElDb21waWxhdGlvblVuaXQgbUNvbXBpbGF0aW9uVW5pdDsKLQlwcml2YXRlIENvbXBpbGF0aW9uVW5pdCBtQ29tcGlsYXRpb25Vbml0Tm9kZTsKLQlwcml2YXRlIERvY3VtZW50IG1Eb2N1bWVudDsKLQkKLQlwdWJsaWMgQ29tcGlsYXRpb25Vbml0TW9kaWZpZXIoSUphdmFQcm9qZWN0IHByb2plY3QsIFN0cmluZyBjbGFzc05hbWUpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlcigpOwotCQkKLQkJbVByb2plY3QgPSBwcm9qZWN0OwotCQkKLQkJSVR5cGUgdHlwZSA9IHByb2plY3QuZmluZFR5cGUoY2xhc3NOYW1lKTsKLQkJaWYgKHR5cGUgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IEV4Y2VwdGlvbigiVGhlIGNsYXNzICIgKyBjbGFzc05hbWUgKyAiIGRvZXMgbm90IGV4aXN0LiIpOwotCQl9Ci0JCW1Db21waWxhdGlvblVuaXQgPSB0eXBlLmdldENvbXBpbGF0aW9uVW5pdCgpOwotCQlpZiAobUNvbXBpbGF0aW9uVW5pdCA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgRXhjZXB0aW9uKCJUaGUgc291cmNlIGNvZGUgZm9yICIgKyBjbGFzc05hbWUgKyAiIGRvZXMgbm90IGV4aXN0LiIpOwotCQl9Ci0JfQotCXB1YmxpYyBDb21waWxhdGlvblVuaXRNb2RpZmllcihJSmF2YVByb2plY3QgcHJvamVjdCwgSUNvbXBpbGF0aW9uVW5pdCBjdSkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyKCk7Ci0JCQotCQltUHJvamVjdCA9IHByb2plY3Q7Ci0JCW1Db21waWxhdGlvblVuaXQgPSBjdTsKLQl9Ci0JcHVibGljIENvbXBpbGF0aW9uVW5pdE1vZGlmaWVyKElKYXZhUHJvamVjdCBwcm9qZWN0LCBJQ29tcGlsYXRpb25Vbml0IGN1LCBDb21waWxhdGlvblVuaXQgY3VOb2RlKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIoKTsKLQkJCi0JCW1Qcm9qZWN0ID0gcHJvamVjdDsKLQkJbUNvbXBpbGF0aW9uVW5pdCA9IGN1OwotCQltQ29tcGlsYXRpb25Vbml0Tm9kZSA9IGN1Tm9kZTsKLQkJCi0JCWdldENvbXBpbGF0aW9uVW5pdE5vZGUoKTsgLy90byBjcmVhdGUgbURvY3VtZW50ICh0aGUgY2FsbGVyIGluIHRoaXMgY2FzZSBkb2VzIG5vdCBoYXZlIHRvIGNhbGwgZ2V0Q29tcGlsYXRpb25Vbml0Tm9kZSkKLQl9Ci0JcHVibGljIElDb21waWxhdGlvblVuaXQgZ2V0Q29tcGlsYXRpb25Vbml0KCkgewotCQlyZXR1cm4gbUNvbXBpbGF0aW9uVW5pdDsKLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgY29tcGlsYXRpb24gdW5pdCBub2RlIHRoYXQgc2hvdWxkIGJlIHVzZWQgZm9yIAotCSAqIHR5aGUgbW9kaWZpY2F0aW9uIEFTVCBvcGVyYXRpb25zLgotCSAqLwotCXB1YmxpYyBDb21waWxhdGlvblVuaXQgZ2V0Q29tcGlsYXRpb25Vbml0Tm9kZSgpIHsKLQkJaWYgKG1Db21waWxhdGlvblVuaXROb2RlID09IG51bGwpIHsKLQkJCUFTVFBhcnNlciBjID0gQVNUUGFyc2VyLm5ld1BhcnNlcihBU1QuSkxTMyk7Ci0JCQljLnNldFNvdXJjZShtQ29tcGlsYXRpb25Vbml0KTsKLQkJCWMuc2V0UmVzb2x2ZUJpbmRpbmdzKHRydWUpOwotCQkJbUNvbXBpbGF0aW9uVW5pdE5vZGUgPSAoQ29tcGlsYXRpb25Vbml0KWMuY3JlYXRlQVNUKG51bGwpOwotCQl9Ci0JCWlmIChtRG9jdW1lbnQgPT0gbnVsbCkgewotCQkJdHJ5IHsKLQkJCQltRG9jdW1lbnQgPSBuZXcgRG9jdW1lbnQobUNvbXBpbGF0aW9uVW5pdC5nZXRCdWZmZXIoKS5nZXRDb250ZW50cygpKTsKLQkJCX0gY2F0Y2ggKEphdmFNb2RlbEV4Y2VwdGlvbiBlKSB7Ci0JCQkJZS5wcmludFN0YWNrVHJhY2UoKTsKLQkJCX0KLQkJCQotCQkJbUNvbXBpbGF0aW9uVW5pdE5vZGUucmVjb3JkTW9kaWZpY2F0aW9ucygpOwotCQl9Ci0JCQotCQlyZXR1cm4gbUNvbXBpbGF0aW9uVW5pdE5vZGU7Ci0JfQotCS8qKgotCSAqIENoYW5nZXMgdGhlIGVudGlyZSBKYXZhIHNvdXJjZSBjb2RlIG9mIHRoZSBjb21waWxhdGlvbiB1bml0LgotCSAqLwotCXB1YmxpYyB2b2lkIHNldEphdmFTb3VyY2UoU3RyaW5nIG5ld1NvdXJjZSkgewotCQl0cnkgewotCQkJbUNvbXBpbGF0aW9uVW5pdC5nZXRCdWZmZXIoKS5zZXRDb250ZW50cyhuZXdTb3VyY2UpOwotCQl9IGNhdGNoIChKYXZhTW9kZWxFeGNlcHRpb24gZSkgewotCQkJZS5wcmludFN0YWNrVHJhY2UoKTsKLQkJfQotCX0KLQkvKioKLQkgKiBTYXZlcyB0aGUgY29tcGlsYXRpb24gdW5pdCBtb2RpZmljYXRpb25zLgotCSAqLwotCXB1YmxpYyB2b2lkIHNhdmUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJaWYgKG1Db21waWxhdGlvblVuaXROb2RlICE9IG51bGwpIHsKLQkJCWFzc2VydChtRG9jdW1lbnQgIT0gbnVsbCk7IC8vc2VlIGdldENvbXBpbGF0aW9uVW5pdE5vZGUKLQkJCQotCQkJLy9jb21wdXRhdGlvbiBvZiB0aGUgdGV4dCBlZGl0cwotCQkJVGV4dEVkaXQgZWRpdHMgPSBtQ29tcGlsYXRpb25Vbml0Tm9kZS5yZXdyaXRlKG1Eb2N1bWVudCwgbVByb2plY3QuZ2V0T3B0aW9ucyh0cnVlKSk7Ci0JCQkvL2NvbXB1dGF0aW9uIG9mIHRoZSBuZXcgc291cmNlIGNvZGUKLQkJCWVkaXRzLmFwcGx5KG1Eb2N1bWVudCk7Ci0JCQlTdHJpbmcgbmV3U291cmNlID0gbURvY3VtZW50LmdldCgpOwotCQkJLy8gdXBkYXRlIG9mIHRoZSBjb21waWxhdGlvbiB1bml0Ci0JCQltQ29tcGlsYXRpb25Vbml0LmdldEJ1ZmZlcigpLnNldENvbnRlbnRzKG5ld1NvdXJjZSk7Ci0JCX0KLQkJCi0JCWlmIChtQ29tcGlsYXRpb25Vbml0LmlzV29ya2luZ0NvcHkoKSkgewotCQkJbUNvbXBpbGF0aW9uVW5pdC5jb21taXRXb3JraW5nQ29weSh0cnVlLypmb3JjZSovLCBudWxsLyptb25pdG9yKi8pOwotCQl9IGVsc2UgewotCQkJbUNvbXBpbGF0aW9uVW5pdC5zYXZlKG51bGwvKm1vbml0b3IqLywgdHJ1ZS8qZm9yY2UqLyk7Ci0JCX0KLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi91dGlsL0RUUFV0aWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL3V0aWwvRFRQVXRpbC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmZWUwNTQ0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL3V0aWwvRFRQVXRpbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTE2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDIudXRpbDsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkNvbHVtbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuRm9yZWlnbktleTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuU2NoZW1hOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5UYWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuRm9yZWlnbktleS5Db2x1bW5QYWlyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5nZW4uaW50ZXJuYWwyLkZvcmVpZ25LZXlJbmZvOwotCi0vKioKLSAqIENvbGxlY3Rpb24gb2YgdXRpbGl0eSBtZXRob2RzIHRvIGFjY2VzcyBEVFAgYW5kIG90aGVyIGpwdC5kYiBBUElzIAotICoKLSAqLwotcHVibGljIGNsYXNzIERUUFV0aWwgewotCi0JLyoqCi0JICogUmV0dXJuIGxpc3Qgb2YgdGhlIHBrIG5hbWVzCi0JICogQHBhcmFtIGRiVGFibGUKLQkgKiBAcmV0dXJuCi0JICovCi0JcHVibGljIHN0YXRpYyBMaXN0PFN0cmluZz4gZ2V0UHJpbWFyeUtleUNvbHVtbk5hbWVzKFRhYmxlIGRiVGFibGUgKSB7Ci0JCUl0ZXJhdG9yPENvbHVtbj4gcGtDb2x1bW5zID0gZGJUYWJsZS5wcmltYXJ5S2V5Q29sdW1ucygpOwotCQlBcnJheUxpc3Q8U3RyaW5nPiByZXQgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJd2hpbGUoIHBrQ29sdW1ucy5oYXNOZXh0KCkgKXsKLQkJCXJldC5hZGQoIHBrQ29sdW1ucy5uZXh0KCkuZ2V0TmFtZSgpICk7Ci0JCX0KLQkJcmV0dXJuIHJldDsKLQl9Ci0KLQkvKioKLQkgKiAKLQkgKiBAcGFyYW0gZGJUYWJsZQotCSAqIEByZXR1cm4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIExpc3Q8Q29sdW1uPiBnZXRQcmltYXJ5S2V5Q29sdW1ucyhUYWJsZSBkYlRhYmxlICkgewotCQlJdGVyYXRvcjxDb2x1bW4+IHBrQ29sdW1ucyA9IGRiVGFibGUucHJpbWFyeUtleUNvbHVtbnMoKTsKLQkJQXJyYXlMaXN0PENvbHVtbj4gcmV0ID0gbmV3IEFycmF5TGlzdDxDb2x1bW4+KCk7Ci0JCXdoaWxlKCBwa0NvbHVtbnMuaGFzTmV4dCgpICl7Ci0JCQlyZXQuYWRkKCBwa0NvbHVtbnMubmV4dCgpICk7Ci0JCX0KLQkJcmV0dXJuIHJldDsKLQl9Ci0JCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGlzQXV0b0luY3JlbWVudChDb2x1bW4gYyl7Ci0JCS8vQCBUT0RPCi0JCS8vQmxvY2tlZCBieSBEVFAgYnVnCi0JCS8vaHR0cHM6Ly9idWdzLmVjbGlwc2Uub3JnL2J1Z3Mvc2hvd19idWcuY2dpP2lkPTI1MDAyMwotCQkvL1RoZSBEYWxpIGJ1ZyBpcwotCQkvL2h0dHBzOi8vYnVncy5lY2xpcHNlLm9yZy9idWdzL3Nob3dfYnVnLmNnaT9pZD0yNDk2NTgKLQkJLy8KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBsaXN0IG9mIGZrCi0JICogQHBhcmFtIGRiVGFibGUKLQkgKiBAcmV0dXJuCi0JICovCi0JcHVibGljIHN0YXRpYyBMaXN0PEZvcmVpZ25LZXlJbmZvPiBnZXRGb3JlaWduS2V5cyhUYWJsZSBkYlRhYmxlKSB7Ci0JCUxpc3Q8Rm9yZWlnbktleUluZm8+IHJldCA9IG5ldyBBcnJheUxpc3Q8Rm9yZWlnbktleUluZm8+KCk7Ci0JCWlmKGRiVGFibGUhPW51bGwpewotCQkJSXRlcmF0b3I8Rm9yZWlnbktleT4gZmtzID0gZGJUYWJsZS5mb3JlaWduS2V5cygpOwotCQkJd2hpbGUoIGZrcy5oYXNOZXh0KCkgKXsKLQkJCQlGb3JlaWduS2V5IGZrICA9IGZrcy5uZXh0KCk7Ci0JCQkJQ29sdW1uUGFpciBjb2x1bW5QYWlyID0gZmsuZ2V0Q29sdW1uUGFpcigpOwotCi0JCQkJU3RyaW5nIHRhYmxlTmFtZSA9IGRiVGFibGUuZ2V0TmFtZSgpOwotCQkJCVN0cmluZyByZWZlcmVuY2VkVGFibGVOYW1lID0gIiI7Ci0JCQkJVGFibGUgcmVmZXJlbmNlZFRhYmxlID0gZmsuZ2V0UmVmZXJlbmNlZFRhYmxlKCk7Ci0JCQkJcmVmZXJlbmNlZFRhYmxlTmFtZSA9IHJlZmVyZW5jZWRUYWJsZS5nZXROYW1lKCk7Ci0JCQkJRm9yZWlnbktleUluZm8gZmtJbmZvID0gbmV3IEZvcmVpZ25LZXlJbmZvKGZrLCB0YWJsZU5hbWUsIHJlZmVyZW5jZWRUYWJsZU5hbWUgKTsKLQkJCQlTdHJpbmcgYmFzZUNvbE5hbWUgPSBjb2x1bW5QYWlyLmdldEJhc2VDb2x1bW4oKS5nZXROYW1lKCk7Ci0JCQkJU3RyaW5nIHJlZmVyZW5jZWRDb2xOYW1lID0gY29sdW1uUGFpci5nZXRSZWZlcmVuY2VkQ29sdW1uKCkuZ2V0TmFtZSgpOwotCQkJCWZrSW5mby5hZGRDb2x1bW5NYXBwaW5nKCBiYXNlQ29sTmFtZSwgIHJlZmVyZW5jZWRDb2xOYW1lICk7Ci0JCQkJcmV0LmFkZCggZmtJbmZvICk7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIHJldDsKLQl9Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBnZXRKYXZhVHlwZShTY2hlbWEgc2NoZW1hLCBDb2x1bW4gZGJDb2x1bW4pIHsKLQkJaWYoIGlzUHJpbWFyeUtleShkYkNvbHVtbikgKQotCQkJcmV0dXJuIGRiQ29sdW1uLmdldFByaW1hcnlLZXlKYXZhVHlwZURlY2xhcmF0aW9uKCk7Ci0JCXJldHVybiBkYkNvbHVtbi5nZXRKYXZhVHlwZURlY2xhcmF0aW9uKCk7Ci0JfQotCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGlzUHJpbWFyeUtleShDb2x1bW4gZGJDb2x1bW4pewotCQlUYWJsZSBkYlRhYmxlID0gZGJDb2x1bW4uZ2V0VGFibGUoKTsKLQkJSXRlcmF0b3I8Q29sdW1uPiBwa0NvbHVtbnMgPSBkYlRhYmxlLnByaW1hcnlLZXlDb2x1bW5zKCk7CQkKLQkJd2hpbGUoIHBrQ29sdW1ucy5oYXNOZXh0KCkgKXsKLQkJCWlmKCBwa0NvbHVtbnMubmV4dCgpLmVxdWFscyggZGJDb2x1bW4gKSl7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQkKLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gaXNEZWZhdWx0U2NoZW1hKFRhYmxlIGRiVGFibGUpewotCQlTdHJpbmcgc2NoZW1hTmFtZSA9IGRiVGFibGUuZ2V0U2NoZW1hKCkuZ2V0TmFtZSgpOwotCQlTY2hlbWEgZGVmYXVsdFNjaGVtYSA9IGRiVGFibGUuZ2V0U2NoZW1hKCkuZ2V0Q29ubmVjdGlvblByb2ZpbGUoKS5nZXREYXRhYmFzZSgpLmdldERlZmF1bHRTY2hlbWEoKTsKLQkJcmV0dXJuIGRlZmF1bHRTY2hlbWEuZ2V0TmFtZSgpID09IHNjaGVtYU5hbWU7Ci0JfQkKLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL3V0aWwvRmlsZVV0aWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL3V0aWwvRmlsZVV0aWwuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZGRiYjY3Ny4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi91dGlsL0ZpbGVVdGlsLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyMTggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsMi51dGlsOwotCi1pbXBvcnQgamF2YS5pby5GaWxlOwotaW1wb3J0IGphdmEuaW8uRmlsZUlucHV0U3RyZWFtOwotaW1wb3J0IGphdmEuaW8uRmlsZU91dHB1dFN0cmVhbTsKLWltcG9ydCBqYXZhLmlvLklPRXhjZXB0aW9uOwotaW1wb3J0IGphdmEuaW8uSW5wdXRTdHJlYW07Ci1pbXBvcnQgamF2YS5pby5PdXRwdXRTdHJlYW07Ci1pbXBvcnQgamF2YS5uZXQuTWFsZm9ybWVkVVJMRXhjZXB0aW9uOwotaW1wb3J0IGphdmEubmV0LlVSTDsKLWltcG9ydCBqYXZhLnV0aWwuamFyLkphcklucHV0U3RyZWFtOwotaW1wb3J0IGphdmEudXRpbC5qYXIuTWFuaWZlc3Q7Ci1pbXBvcnQgamF2YS51dGlsLnppcC5aaXBFbnRyeTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklGaWxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLlJlc291cmNlc1BsdWdpbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuQ29yZUV4Y2VwdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuUGF0aDsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuUGxhdGZvcm07Ci1pbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS5zZXJ2aWNlLmRhdGFsb2NhdGlvbi5Mb2NhdGlvbjsKLWltcG9ydCBvcmcub3NnaS5mcmFtZXdvcmsuQnVuZGxlOwotCi0vKioKLSAqIENvbGxlY3Rpb25zIG9mIHV0aWxpdHkgbWV0aG9kcyBoYW5kbGluZyBmaWxlcy4KLSAqIAotICovCi1wdWJsaWMgY2xhc3MgRmlsZVV0aWwKLXsKLQkKLQlwcml2YXRlIHN0YXRpYyBTdHJpbmcgREVMRVRFX0ZPTERFUl9FUlIgPSAiVGhlIGRpcmVjdG9yeSAlcyBjb3VsZCBub3QgYmUgZGVsZXRlZC4iOwotCXByaXZhdGUgc3RhdGljIFN0cmluZyBERUxFVEVfRklMRV9FUlIgPSAiVGhlIGZpbGUgJXMgY291bGQgbm90IGJlIGRlbGV0ZWQuIjsKLQlwcml2YXRlIHN0YXRpYyBTdHJpbmcgRklMRV9SRUFET05MWV9FUlIgPSAiVGhlIGZpbGUgJXMgY291bGQgbm90IGJlIG1vZGlmaWVkIGJlY2F1c2Ugd3JpdGUgYWNjZXNzIGlzIGRlbmllZC5cblBsZWFzZSBtYWtlIHN1cmUgdGhhdCB0aGUgZmlsZSBpcyBub3QgbWFya2VkIGFzIHJlYWRvbmx5IGluIHRoZSBmaWxlIHN5c3RlbS4iOwotCi0JcHVibGljIHN0YXRpYyB2b2lkIGRlbGV0ZUZvbGRlcihGaWxlIGZvbGRlcikKLQkJdGhyb3dzIElPRXhjZXB0aW9uCi0JewotCQlGaWxlW10gZmlsZXMgPSBmb2xkZXIubGlzdEZpbGVzKCk7Ci0JCS8vZW1wdHkgdGhlIGZvbGRlciBmaXJzdCAoamF2YS5pby5maWxlLmRlbGV0ZSByZXF1aXJlcyBpdCBlbXB0eSkKLQkJaWYgKGZpbGVzICE9IG51bGwpIHsKLQkJCWZvciAoaW50IGkgPSAwOyBpIDwgZmlsZXMubGVuZ3RoOyArK2kpIHsKLQkJCQlGaWxlIGYgPSBmaWxlc1tpXTsKLQkJCQlpZiAoZi5pc0RpcmVjdG9yeSgpKQotCQkJCQlkZWxldGVGb2xkZXIoZik7Ci0JCQkJZWxzZQotCQkJCQlkZWxldGVQYXRoKGYpOwotCQkJfQotCQl9Ci0JCWRlbGV0ZVBhdGgoZm9sZGVyKTsKLQl9Ci0KLQlwdWJsaWMgc3RhdGljIHZvaWQgZGVsZXRlUGF0aChGaWxlIGYpCi0JCXRocm93cyBJT0V4Y2VwdGlvbgotCXsKLQkJaWYgKCFmLmRlbGV0ZSgpKSB7Ci0JCQlTdHJpbmcgbXNnSWQgPSBmLmlzRGlyZWN0b3J5KCkgPyAgREVMRVRFX0ZPTERFUl9FUlIgOiAgREVMRVRFX0ZJTEVfRVJSOwotCQkJdGhyb3cgbmV3IElPRXhjZXB0aW9uKCBTdHJpbmcuZm9ybWF0KG1zZ0lkLGYuZ2V0UGF0aCgpKSk7Ci0JCX0KLQl9Ci0JCi0JcHVibGljIHN0YXRpYyBieXRlW10gcmVhZEZpbGUoRmlsZSBzcmMpCi0JCXRocm93cyBJT0V4Y2VwdGlvbgotCXsKLQkJamF2YS5pby5GaWxlSW5wdXRTdHJlYW0gZmluID0gbmV3IGphdmEuaW8uRmlsZUlucHV0U3RyZWFtKHNyYyk7Ci0JCXRyeSB7Ci0JCQlsb25nIGZpbGVMZW4gPSBzcmMubGVuZ3RoKCk7Ci0JCQlpZiAoZmlsZUxlbiA+IEludGVnZXIuTUFYX1ZBTFVFKQotCQkJCXRocm93IG5ldyBJT0V4Y2VwdGlvbigiZmlsZSBsZW5ndGggdG9vIGJpZyB0byBiZSByZWFkIGJ5IEZpbGVVdGlsLnJlYWRGaWxlOiAiICsgZmlsZUxlbik7Ci0JCQotCQkJYnl0ZVtdIGJ5dGVzID0gbmV3IGJ5dGVbKGludClmaWxlTGVuXTsKLQkJCWZpbi5yZWFkKGJ5dGVzKTsKLQkJCXJldHVybiBieXRlczsKLQkJfQotCQlmaW5hbGx5IHsKLQkJCWZpbi5jbG9zZSgpOwotCQl9Ci0JfQotCi0JcHVibGljIHN0YXRpYyB2b2lkIHdyaXRlRmlsZShGaWxlIGRlc3QsIGJ5dGVbXSBieXRlcykKLQkJdGhyb3dzIElPRXhjZXB0aW9uCi0JewotCQlpZiAoZGVzdC5leGlzdHMoKSAmJiAhZGVzdC5jYW5Xcml0ZSgpKQotCQkJdGhyb3cgbmV3IElPRXhjZXB0aW9uKCBGSUxFX1JFQURPTkxZX0VSUiApOyAgLy90aHJvdyB3aXRoIGEgY2xlYXIgZXJyb3IgYmVjYXVzZSBvdGhlcndpc2UgRmlsZU91dHB1dFN0cmVhbSB0aHJvd3MgRmlsZU5vdEZvdW5kRXhjZXB0aW9uIQotCQlqYXZhLmlvLkZpbGVPdXRwdXRTdHJlYW0gZm91dCA9IG5ldyBqYXZhLmlvLkZpbGVPdXRwdXRTdHJlYW0oZGVzdC5nZXRQYXRoKCksIGZhbHNlLyphcHBlbmQqLyk7Ci0JCXRyeSB7Ci0JCQlmb3V0LndyaXRlKGJ5dGVzKTsKLQkJfQotCQlmaW5hbGx5IHsKLQkJCWZvdXQuZmx1c2goKTsKLQkJCWZvdXQuY2xvc2UoKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFJldHVybnMgdGhlIHVybCBmb3IgYSBmaWxlLgotCSAqIFRoaXMgYmFzaWNhbGx5IHRoZSBzYW1lIGFzIGZpbGUudG9VcmwoKSBidXQgd2l0aG91dCB0aGUgbm9uLXNlbnNlIGV4Y2VwdGlvbi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFVSTCBnZXRGaWxlVXJsKEZpbGUgZmlsZSkgewotCQl0cnkgewotCQkJcmV0dXJuIGZpbGUudG9VUkkoKS50b1VSTCgpOwotCQl9IGNhdGNoIChNYWxmb3JtZWRVUkxFeGNlcHRpb24gZSkgewotCQkJcmV0dXJuIG51bGw7IC8vc2hvdWxkIG5vdCBoYXBwZW4gYXMgZmlsZS50b1VSTCgpIGRvZXMgbm90IHJlYWxseSB0aHJvdyBhbiBleGNlcHRpb24KLQkJfQotCX0KLQotCXB1YmxpYyBzdGF0aWMgdm9pZCBzZXRGaWxlQ29udGVudChGaWxlIGZpbGUsIGphdmEuaW8uSW5wdXRTdHJlYW0gY29udGVudHMpIHRocm93cyBqYXZhLmlvLklPRXhjZXB0aW9uIHsKLQkJUGF0aCBwYXRoID0gbmV3IFBhdGgoZmlsZS5nZXRBYnNvbHV0ZVBhdGgoKSk7Ci0JCXRyeSB7Ci0JCQlJRmlsZSBpRmlsZSA9IFJlc291cmNlc1BsdWdpbi5nZXRXb3Jrc3BhY2UoKS5nZXRSb290KCkuZ2V0RmlsZUZvckxvY2F0aW9uKHBhdGgpOwotCQkJaWYgKGlGaWxlID09IG51bGwpIHsKLQkJCQl0aHJvdyBuZXcgSU9FeGNlcHRpb24oIlRoZSBwYXRoICIgKyBmaWxlICsgIiBkb2VzIG5vdCBzZWVtIHRvIGJlIGEgdmFsaWQgZmlsZSBwYXRoLiIpOwotCQkJfQotCQkJaUZpbGUuc2V0Q29udGVudHMoY29udGVudHMsIHRydWUvKmZvcmNlKi8sIHRydWUvKmtlZXBIaXN0b3J5Ki8sIG51bGwvKm1vbml0b3IqLyk7Ci0JCX0gY2F0Y2ggKENvcmVFeGNlcHRpb24gZXgpIHsKLQkJCXRocm93IG5ldyBJT0V4Y2VwdGlvbihleC5nZXRNZXNzYWdlKCkpOwotCQl9Ci0JfQkKLQkKLSAgICAvKioKLSAgICAgKiBFeHRyYWN0IHRoZSBjb250ZW50cyBvZiBhIEphciBhcmNoaXZlIHRvIHRoZSBzcGVjaWZpZWQgZGVzdGluYXRpb24uCi0gICAgICovCi0gICAgcHVibGljIHN0YXRpYyB2b2lkIHVuamFyKElucHV0U3RyZWFtIGluLCBGaWxlIGRlc3QpIHRocm93cyBJT0V4Y2VwdGlvbiB7Ci0gICAgICAgIGlmICghZGVzdC5leGlzdHMoKSkgewotICAgICAgICAgICAgZGVzdC5ta2RpcnMoKTsKLSAgICAgICAgfQotICAgICAgICBpZiAoIWRlc3QuaXNEaXJlY3RvcnkoKSkgewotICAgICAgICAgICAgdGhyb3cgbmV3IElPRXhjZXB0aW9uKCJEZXN0aW5hdGlvbiBtdXN0IGJlIGEgZGlyZWN0b3J5LiIpOy8vJE5PTi1OTFMtMSQKLSAgICAgICAgfQotICAgICAgICBKYXJJbnB1dFN0cmVhbSBqaW4gPSBuZXcgSmFySW5wdXRTdHJlYW0oaW4pOwotICAgICAgICBieXRlW10gYnVmZmVyID0gbmV3IGJ5dGVbMTAyNF07Ci0KLSAgICAgICAgWmlwRW50cnkgZW50cnkgPSBqaW4uZ2V0TmV4dEVudHJ5KCk7Ci0gICAgICAgIHdoaWxlIChlbnRyeSAhPSBudWxsKSB7Ci0gICAgICAgICAgICBTdHJpbmcgZmlsZU5hbWUgPSBlbnRyeS5nZXROYW1lKCk7Ci0gICAgICAgICAgICBpZiAoZmlsZU5hbWUuY2hhckF0KGZpbGVOYW1lLmxlbmd0aCgpIC0gMSkgPT0gJy8nKSB7Ci0gICAgICAgICAgICAgICAgZmlsZU5hbWUgPSBmaWxlTmFtZS5zdWJzdHJpbmcoMCwgZmlsZU5hbWUubGVuZ3RoKCkgLSAxKTsKLSAgICAgICAgICAgIH0KLSAgICAgICAgICAgIGlmIChmaWxlTmFtZS5jaGFyQXQoMCkgPT0gJy8nKSB7Ci0gICAgICAgICAgICAgICAgZmlsZU5hbWUgPSBmaWxlTmFtZS5zdWJzdHJpbmcoMSk7Ci0gICAgICAgICAgICB9Ci0gICAgICAgICAgICBpZiAoRmlsZS5zZXBhcmF0b3JDaGFyICE9ICcvJykgewotICAgICAgICAgICAgICAgIGZpbGVOYW1lID0gZmlsZU5hbWUucmVwbGFjZSgnLycsIEZpbGUuc2VwYXJhdG9yQ2hhcik7Ci0gICAgICAgICAgICB9Ci0gICAgICAgICAgICBGaWxlIGZpbGUgPSBuZXcgRmlsZShkZXN0LCBmaWxlTmFtZSk7Ci0gICAgICAgICAgICBpZiAoZW50cnkuaXNEaXJlY3RvcnkoKSkgewotICAgICAgICAgICAgICAgIC8vIG1ha2Ugc3VyZSB0aGUgZGlyZWN0b3J5IGV4aXN0cwotICAgICAgICAgICAgICAgIGZpbGUubWtkaXJzKCk7Ci0gICAgICAgICAgICAgICAgamluLmNsb3NlRW50cnkoKTsKLSAgICAgICAgICAgIH0gZWxzZSB7Ci0gICAgICAgICAgICAgICAgLy8gbWFrZSBzdXJlIHRoZSBkaXJlY3RvcnkgZXhpc3RzCi0gICAgICAgICAgICAgICAgRmlsZSBwYXJlbnQgPSBmaWxlLmdldFBhcmVudEZpbGUoKTsKLSAgICAgICAgICAgICAgICBpZiAocGFyZW50ICE9IG51bGwgJiYgIXBhcmVudC5leGlzdHMoKSkgewotICAgICAgICAgICAgICAgICAgICBwYXJlbnQubWtkaXJzKCk7Ci0gICAgICAgICAgICAgICAgfQotCi0gICAgICAgICAgICAgICAgLy8gZHVtcCB0aGUgZmlsZQotICAgICAgICAgICAgICAgIE91dHB1dFN0cmVhbSBvdXQgPSBuZXcgRmlsZU91dHB1dFN0cmVhbShmaWxlKTsKLSAgICAgICAgICAgICAgICBpbnQgbGVuID0gMDsKLSAgICAgICAgICAgICAgICB3aGlsZSAoKGxlbiA9IGppbi5yZWFkKGJ1ZmZlciwgMCwgYnVmZmVyLmxlbmd0aCkpICE9IC0xKSB7Ci0gICAgICAgICAgICAgICAgICAgIG91dC53cml0ZShidWZmZXIsIDAsIGxlbik7Ci0gICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgIG91dC5mbHVzaCgpOwotICAgICAgICAgICAgICAgIG91dC5jbG9zZSgpOwotICAgICAgICAgICAgICAgIGppbi5jbG9zZUVudHJ5KCk7Ci0gICAgICAgICAgICAgICAgZmlsZS5zZXRMYXN0TW9kaWZpZWQoZW50cnkuZ2V0VGltZSgpKTsKLSAgICAgICAgICAgIH0KLSAgICAgICAgICAgIGVudHJ5ID0gamluLmdldE5leHRFbnRyeSgpOwotICAgICAgICB9Ci0gICAgICAgIC8qIEV4cGxpY2l0bHkgd3JpdGUgb3V0IHRoZSBNRVRBLUlORi9NQU5JRkVTVC5NRiBzbyB0aGF0IGFueSBoZWFkZXJzIHN1Y2gKLSAgICAgICAgIGFzIHRoZSBDbGFzcy1QYXRoIGFyZSBzZWVuIGZvciB0aGUgdW5wYWNrYWdlZCBqYXIKLSAgICAgICAgICovCi0gICAgICAgIE1hbmlmZXN0IG1mID0gamluLmdldE1hbmlmZXN0KCk7Ci0gICAgICAgIGlmIChtZiAhPSBudWxsKSB7Ci0gICAgICAgICAgICBGaWxlIGZpbGUgPSBuZXcgRmlsZShkZXN0LCAiTUVUQS1JTkYvTUFOSUZFU1QuTUYiKTsvLyROT04tTkxTLTEkCi0gICAgICAgICAgICBGaWxlIHBhcmVudCA9IGZpbGUuZ2V0UGFyZW50RmlsZSgpOwotICAgICAgICAgICAgaWYgKHBhcmVudC5leGlzdHMoKSA9PSBmYWxzZSkgewotICAgICAgICAgICAgICAgIHBhcmVudC5ta2RpcnMoKTsKLSAgICAgICAgICAgIH0KLSAgICAgICAgICAgIE91dHB1dFN0cmVhbSBvdXQgPSBuZXcgRmlsZU91dHB1dFN0cmVhbShmaWxlKTsKLSAgICAgICAgICAgIG1mLndyaXRlKG91dCk7Ci0gICAgICAgICAgICBvdXQuZmx1c2goKTsKLSAgICAgICAgICAgIG91dC5jbG9zZSgpOwotICAgICAgICB9Ci0gICAgICAgIGppbi5jbG9zZSgpOwotICAgIH0KLSAgICAKLQkvL1VzZWQgdG8gVW56aXAgdGhlIGEgc3BlY2lmaWMgZm9sZGVyIHBhY2tlZCBpbnNpZGUgYSBwbHVnLWluIGJ1bmRsZSB0byB0aGUgcGx1Zy1pbiBzdGF0ZSBsb2NhdGlvbgotCXB1YmxpYyBzdGF0aWMgRmlsZSBleHRyYWN0RmlsZXNGcm9tQnVuZGxlKCBVUkwgdXJsLCBCdW5kbGUgYnVuZGxlLCBTdHJpbmcgcGF0aCApIHRocm93cyBFeGNlcHRpb24gewotCQlVUkwgamFyVXJsID0gVXJsVXRpbC5nZXRKYXJGaWxlVXJsKHVybCk7Ci0JCUZpbGUgamFyRmlsZSA9IG5ldyBGaWxlKGphclVybC5nZXRGaWxlKCkgKTsKLQkJTG9jYXRpb24gY29uZmlnTG9jYXRpb24gPSBQbGF0Zm9ybS5nZXRDb25maWd1cmF0aW9uTG9jYXRpb24oKTsKLQkJU3RyaW5nIHBsdWdpbklkID0gYnVuZGxlLmdldFN5bWJvbGljTmFtZSgpOwotCQlGaWxlIGNvbmZpZ0ZvbGRlciA9IG5ldyBGaWxlKCBjb25maWdMb2NhdGlvbi5nZXRVUkwoKS5nZXRGaWxlKCksIHBsdWdpbklkKTsKLQkJRmlsZSB0ZW1wbERpciA9IG5ldyBGaWxlKCBjb25maWdGb2xkZXIsIHBhdGggKTsKLQkJaWYoICF0ZW1wbERpci5leGlzdHMoKSApewotCQkJRmlsZVV0aWwudW5qYXIoIG5ldyBGaWxlSW5wdXRTdHJlYW0oIGphckZpbGUgKSwgY29uZmlnRm9sZGVyICk7Ci0JCQkvL0RlbGV0ZSB1bi1yZWxhdGVkIGZpbGVzIGFuZCBmb2xkZXJzCi0JCQlGaWxlW10gZmlsZXMgPSBjb25maWdGb2xkZXIubGlzdEZpbGVzKCk7Ci0JCQlmb3IoIEZpbGUgZiA6IGZpbGVzICl7Ci0JCQkJaWYoIGYuaXNGaWxlKCkgKQotCQkJCQlmLmRlbGV0ZSgpOwotCQkJCWVsc2UgaWYoICB0ZW1wbERpci5nZXRQYXRoKCkuaW5kZXhPZiggZi5nZXRQYXRoKCkgKSAhPTAgICl7Ci0JCQkJCUZpbGVVdGlsLmRlbGV0ZUZvbGRlcihmKTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIHRlbXBsRGlyIDsKLQl9CQotfQotCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi91dGlsL1N0cmluZ1V0aWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL3V0aWwvU3RyaW5nVXRpbC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyNTc0ZWVkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL3V0aWwvU3RyaW5nVXRpbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNjQ4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbDIudXRpbDsKLQotaW1wb3J0IGphdmEuYmVhbnMuSW50cm9zcGVjdG9yOwotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb25zOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLQotcHVibGljIGNsYXNzIFN0cmluZ1V0aWwKLXsKLQkvKioKLQkgKiBQYWRzIGEgc3RyaW5nIGJ5IGFkZGluZyBhIHNlcXVlbmNlIG9mIGFuIGFyYml0cmFyeSBjaGFyYWN0ZXIgYXQgdGhlIGJlZ2lubmluZy4KLQkgKiBAcGFyYW0gcGFkQ2hhciBUaGUgY2hhcmFjdGVyIHRvIGJlIHVzZWQgZm9yIHBhZGRpbmcuCi0JICogQHBhcmFtIGxlbiBUaGUgZGVzaXJlZCBsZW5ndGggYWZ0ZXIgcGFkZGluZy4KLQkgKiBAcmV0dXJuIFRoZSBwYWRkZWQgc3RyaW5nLiBGb3IgZXhhbXBsZSBpZiA8Y29kZT5zdHI8L2NvZGU+IGlzICJmNGUiIGFuZCA8Y29kZT5wYWRDaGFyPC9jb2RlPiBpcyAnMCcgCi0JICogYW5kIDxjb2RlPmxlbjwvY29kZT4gaXMgNiB0aGVuIHRoaXMgbWV0aG9kIHJldHVybnMgIjAwMGY0ZSIKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBwYWRMZWZ0KFN0cmluZyBzdHIsIGNoYXIgcGFkQ2hhciwgaW50IGxlbikgewotCQlpZihzdHIgPT0gbnVsbCkgewotCQkJcmV0dXJuIG51bGw7Ci0JCX0KLQkJaW50IHN0ckxlbiA9IHN0ci5sZW5ndGgoKTsKLQkJaWYgKHN0ckxlbiA8IGxlbikgewotCQkJU3RyaW5nQnVmZmVyIGJ1ZmZlciA9IG5ldyBTdHJpbmdCdWZmZXIobGVuKTsKLQkJCWludCBjb3VudCA9IGxlbi1zdHJMZW47Ci0JCQlmb3IgKGludCBpID0gMDsgaSA8IGNvdW50OyArK2kpCi0JCQkJYnVmZmVyLmFwcGVuZChwYWRDaGFyKTsKLQkJCWJ1ZmZlci5hcHBlbmQoc3RyKTsKLQkJCXN0ciA9IGJ1ZmZlci50b1N0cmluZygpOwotCQl9Ci0JCXJldHVybiBzdHI7Ci0JfQotCS8qKgotCSAqIEluc2VydHMgYSBnaXZlbiBjaGFyYWN0ZXIgYXQgdGhlIGJlZ2lubmluZyBhbmQgYXQgdGhlIGVuZCBvZiB0aGUgc3BlY2lmaWVkIHN0cmluZy4KLQkgKiBGb3IgZXhhbXBsZSBpZiB0aGUgc3RyaW5nIGlzIDx0dD5leHRyZW1lPC90dD4gYW5kIHRoZSBjaGFyIGlzIDx0dD4nPC90dD4gdGhlbiAKLQkgKiB0aGUgcmV0dXJuZWQgc3RyaW5nIGlzIDx0dD4nZXh0ZXJtZSc8L3R0Pi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBxdW90ZShTdHJpbmcgc3RyLCBjaGFyIGMpIHsKLQkJYXNzZXJ0KHN0ciAhPSBudWxsKTsKLQkJU3RyaW5nQnVmZmVyIGJ1ZmZlciA9IG5ldyBTdHJpbmdCdWZmZXIoc3RyLmxlbmd0aCgpKzIpOwotCQlidWZmZXIuYXBwZW5kKGMpOwotCQlidWZmZXIuYXBwZW5kKHN0cik7Ci0JCWJ1ZmZlci5hcHBlbmQoYyk7Ci0JCXJldHVybiBidWZmZXIudG9TdHJpbmcoKTsKLQl9Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgZG91YmxlUXVvdGUoU3RyaW5nIHN0cikgewotCQlyZXR1cm4gcXVvdGUoc3RyLCAnIicpOwotCX0KLQkvKioKLQkgKiBSZW1vdmVzIHRoZSBmaXJzdCBhbmQgbGFzdCBzaW5nbGUgb3IgZG91YmxlIHF1b3RlcyAoaWYgdGhleSBleGlzdCkuCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgdW5xdW90ZShTdHJpbmcgcXVvdGVkKSB7Ci0JCWlmIChxdW90ZWQgIT0gbnVsbCAmJiBxdW90ZWQubGVuZ3RoKCkgPj0gMil7Ci0JCQlpbnQgbGVuID0gcXVvdGVkLmxlbmd0aCgpOwotCQkJY2hhciBmaXJzdENoYXIgPSBxdW90ZWQuY2hhckF0KDApOwotCQkJY2hhciBsYXN0Q2hhciA9IHF1b3RlZC5jaGFyQXQobGVuLTEpOwotCQkJaWYgKGZpcnN0Q2hhciA9PSBsYXN0Q2hhciAmJiAoZmlyc3RDaGFyID09ICdcJycgfHwgZmlyc3RDaGFyID09ICciJykpIHsKLQkJCQlyZXR1cm4gcXVvdGVkLnN1YnN0cmluZygxLCBsZW4tMSk7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIHF1b3RlZDsKLQl9Ci0JLyoqCi0JICogVHJ1bmNhdGVzIGEgc3RyaW5nIGFuZCBhZGRzICIuLi4iIGluIHRoZSByZXN1bHQgc3RyaW5nLgotCSAqIElmIHRoZSBzdHJpbmcgbGVuZ3RoIGlzIGxlc3Mgb3IgZXF1YWwgdG8gdGhlIG1heCBsZW4gdGhlbiAKLQkgKiB0aGUgb3JpZ2luYWwgc3RyaW5nIGlzIHJldHVybmVkLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHRydW5jYXRlKFN0cmluZyBzLCBpbnQgbWF4TGVuKSB7Ci0JCWlmIChzID09IG51bGwpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCWludCBsZW4gPSBzLmxlbmd0aCgpOwotCQlpZiAobGVuID4gbWF4TGVuKSB7Ci0JCQlpbnQgc2VnbWVudExlbiA9IG1heExlbi8yOwotCQkJcyA9IHMuc3Vic3RyaW5nKDAsIHNlZ21lbnRMZW4pICsgIi4uLiIgKyBzLnN1YnN0cmluZyhsZW4tc2VnbWVudExlbik7Ci0JCX0KLQkJcmV0dXJuIHM7Ci0JfQotCS8qKgotCSAqIFJldHVybnMgYSBzdHJpbmcgY29udGFpbmluZyB0aGUgc2FtZSBjaGFyYWN0ZXIgcmVwZWF0ZWQuCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgcmVwZWF0KGNoYXIgYywgaW50IGNvdW50KSB7Ci0JCVN0cmluZ0J1ZmZlciBidWZmZXIgPSBuZXcgU3RyaW5nQnVmZmVyKGNvdW50KTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBjb3VudDsgKytpKSB7Ci0JCQlidWZmZXIuYXBwZW5kKGMpOwotCQl9Ci0JCXJldHVybiBidWZmZXIudG9TdHJpbmcoKTsKLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgZ2l2ZW4gc3RyaW5nIHVubGVzcyBpdCBpcyBlbXRwdHkgd2hlcmUgaXQgcmV0dXJucyBudWxsLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIG51bGxJZkVtcHR5KFN0cmluZyBzKSB7Ci0JCWlmIChzICE9IG51bGwgJiYgcy5sZW5ndGgoKSA9PSAwKSB7Ci0JCQlzID0gbnVsbDsKLQkJfQotCQlyZXR1cm4gczsKLQl9Ci0JLyoqCi0gICAgICogUmV0dXJucyBhIHN0cmluZyBjb250YWluaW5nIHRoZSBzYW1lIGNoYXJhY3RlcnMgYXMgdGhlIGFyZ3VtZW50IHN0cmluZyAKLQkgKiBleGNlcHQgdGhhdCB0aGUgY29udHJvbCBjaGFyYWN0ZXJzIGFyZSByZXBsYWNlZCBieSB0aGUgdGhlaXIgaGV4IGNvZGUuCi0JICogRm9yIGV4YW1wbGUgaWYgdGhlIHN0cmluZyBpcyAiYWJcbmMiIHRoZSByZXR1cm5lZCBzdHJpbmcgaXMgImFiezB4QX1jIi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBnZXRWaXNpYmxlU3RyaW5nKFN0cmluZyBzKSB7Ci0JCWlmIChzID09IG51bGwpCi0JCQlyZXR1cm4gbnVsbDsKLQkJaW50IGxlbiA9IHMubGVuZ3RoKCk7Ci0JCVN0cmluZ0J1ZmZlciBidWZmZXIgPSBuZXcgU3RyaW5nQnVmZmVyKCk7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyArK2kpIHsKLQkJCWNoYXIgYyA9IHMuY2hhckF0KGkpOwotCQkJaWYgKGMgPD0gMHgxRiB8fCAoYyA9PSAweDIwICYmIChpID09IDAgfHwgaSA9PSBsZW4tMSkpKSB7Ci0JCQkJYnVmZmVyLmFwcGVuZCgiKDB4IiArIEludGVnZXIudG9IZXhTdHJpbmcoKGludCljKS50b1VwcGVyQ2FzZSgpICsgIikiKTsKLQkJCX0KLQkJCWVsc2UgYnVmZmVyLmFwcGVuZChjKTsKLQkJfQotCQlyZXR1cm4gYnVmZmVyLnRvU3RyaW5nKCk7Ci0JfQotCS8qKgotCSAqIFJlcGxhY2VzIGEgcG9ydGlvbiBvZiBzdHJpbmcuCi0JICogQHBhcmFtIHN0ciBUaGUgb3JpZ2luYWwgc3RyaW5nLgotCSAqIEBwYXJhbSBvZmZzZXQgVGhlIG9mZnNldCBpbiB0aGUgb3JpZ2luYWwgc3RyaW5nIHdoZXJlIHRoZSByZXBsYWNlIHN0YXJ0cwotCSAqIEBwYXJhbSBsZW4gVGhlIHJlcGxhY2UgbGVuZ3RoIHRoZSBvcmlnaW5hbCBzdHJpbmcKLQkgKiBAcGFyYW0gcmVwbGFjZVN0ciBUaGUgcmVwbGFjZW1lbnQgc3RyaW5nCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgc3RyUmVwbGFjZShTdHJpbmcgc3RyLCBpbnQgb2Zmc2V0LCBpbnQgbGVuLCBTdHJpbmcgcmVwbGFjZVN0cikgewotCQlTdHJpbmdCdWZmZXIgYnVmZmVyID0gbmV3IFN0cmluZ0J1ZmZlcihzdHIubGVuZ3RoKCktbGVuK3JlcGxhY2VTdHIubGVuZ3RoKCkpOwotCQlidWZmZXIuYXBwZW5kKHN0ci5zdWJzdHJpbmcoMCwgb2Zmc2V0KSk7Ci0JCWJ1ZmZlci5hcHBlbmQocmVwbGFjZVN0cik7Ci0JCWJ1ZmZlci5hcHBlbmQoc3RyLnN1YnN0cmluZyhvZmZzZXQrbGVuKSk7Ci0JCQotCQlyZXR1cm4gYnVmZmVyLnRvU3RyaW5nKCk7Ci0JfQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHN0clJlcGxhY2UoU3RyaW5nIHN0ciwgU3RyaW5nIHBhdHRlcm4sIFN0cmluZyByZXBsYWNlU3RyKQotCXsKLQkJaWYoc3RyID09IG51bGwpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCWlmKHBhdHRlcm4gPT0gbnVsbCB8fCBwYXR0ZXJuLmVxdWFscygiIikpIHsKLQkJCXJldHVybiBzdHI7Ci0JCX0KLQkJaW50IGluZGV4ID0gc3RyLmluZGV4T2YocGF0dGVybik7Ci0JCWlmIChpbmRleCA8IDApCi0JCQlyZXR1cm4gc3RyOwotCQkKLQkJaWYgKHJlcGxhY2VTdHIgPT0gbnVsbCkKLQkJCXJlcGxhY2VTdHIgPSAiIjsKLQkJcmV0dXJuIHN0ci5zdWJzdHJpbmcoMCwgaW5kZXgpICsgcmVwbGFjZVN0ciArIHN0ci5zdWJzdHJpbmcoaW5kZXggKyBwYXR0ZXJuLmxlbmd0aCgpKTsKLQl9Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgc3RyUmVwbGFjZUFsbChTdHJpbmcgc3RyLCBTdHJpbmcgcGF0dGVybiwgU3RyaW5nIHJlcGxhY2VTdHIpCi0JewotCQlpZihzdHIgPT0gbnVsbCkgewotCQkJcmV0dXJuIG51bGw7Ci0JCX0KLQkJaWYgKHJlcGxhY2VTdHIgPT0gbnVsbCkKLQkJCXJlcGxhY2VTdHIgPSAiIjsKLQkJaWYocGF0dGVybiA9PSBudWxsIHx8IHBhdHRlcm4uZXF1YWxzKCIiKSkgewotCQkJcmV0dXJuIHN0cjsKLQkJfQotCQlpbnQgaW5kZXggPSBzdHIuaW5kZXhPZihwYXR0ZXJuKTsKLQkJd2hpbGUgKGluZGV4ID49IDApIHsKLQkJCXN0ciA9IHN0ci5zdWJzdHJpbmcoMCwgaW5kZXgpICsgcmVwbGFjZVN0ciArIHN0ci5zdWJzdHJpbmcoaW5kZXggKyBwYXR0ZXJuLmxlbmd0aCgpKTsKLQkJCWluZGV4ID0gc3RyLmluZGV4T2YocGF0dGVybiwgaW5kZXgrcmVwbGFjZVN0ci5sZW5ndGgoKSk7Ci0JCX0KLQkJcmV0dXJuIHN0cjsKLQl9Ci0JcHVibGljIHN0YXRpYyBTdHJpbmcgc3RySW5zZXJ0KFN0cmluZyBzdHIsIGludCBpbmRleCwgU3RyaW5nIGluc2VydFN0cikKLQl7Ci0JCXJldHVybiBzdHIuc3Vic3RyaW5nKDAsIGluZGV4KQotCQkJCSsgaW5zZXJ0U3RyCi0JCQkJKyBzdHIuc3Vic3RyaW5nKGluZGV4KTsKLQl9Ci0gICAgLyoqCi0gICAgICogVG9rZW5pemUgdGhlIHNwZWNpZmllZCBzdHJpbmcgaW50byBhIDxjb2RlPkxpc3Q8L2NvZGU+IG9mCi0gICAgICogd29yZHMuCi0gICAgICogSWYgdGhlIHN0cmluZyBzcGVjaWZpZWQgaXMgPGNvZGU+bnVsbDwvY29kZT4gb3IgZW1wdHksIHRoaXMKLSAgICAgKiBtZXRob2Qgd2lsbCByZXR1cm4gPGNvZGU+bnVsbDwvY29kZT4uCi0gICAgICogCi0gICAgICogQHBhcmFtIHMgICAgICBUaGUgc3RyaW5nIHRvIHRva2VuaXplIGludG8gYSA8Y29kZT5MaXN0PC9jb2RlPi4KLSAgICAgKiBAcGFyYW0gc2VwICAgIFRoZSBzZXBhcmF0b3IgY2hhcmFjdGVyIHRvIHVzZSB0byBzcGxpdAotICAgICAqICAgICAgICAgICAgICAgdGhlIHN0cmluZy4KLSAgICAgKiBAcGFyYW0gdHJpbSAgIElmIDxjb2RlPnRydWU8L2NvZGU+LCBydW4gPGNvZGU+dHJpbTwvY29kZT4gb24KLSAgICAgKiAgICAgICAgICAgICAgIGVhY2ggZWxlbWVudCBpbiB0aGUgcmVzdWx0IDxjb2RlPkxpc3Q8L2NvZGU+LgotICAgICAqIAotICAgICAqIEByZXR1cm4gQSA8Y29kZT5MaXN0PC9jb2RlPiBjb250YWluaW5nIGFsbCB0b2tlbml6ZWQgd29yZHMKLSAgICAgKiAgICAgICAgIGluIHRoZSBwYXJhbWV0ZXIgc3RyaW5nLgotICAgICAqICAgICAgICAgRWFjaCBlbGVtZW50IGlzIG9mIHR5cGUgPGNvZGU+U3RyaW5nPC9jb2RlPi4KLSAgICAgKi8KLQlwdWJsaWMgc3RhdGljIExpc3Q8U3RyaW5nPiBzdHJUb0xpc3QoU3RyaW5nIHMsIGNoYXIgc2VwLCBib29sZWFuIHRyaW0pCi0JewotCS8vZXg6IGlmIHNlcCBpcyAnOycgdGhlbiBzIHNob3VsZCBiZSBzb21ldGluZyBsaWtlICJSZWQ7QmxhY2siCi0JCWlmIChzID09IG51bGwgfHwgcy5sZW5ndGgoKSA9PSAwKQotCQkJcmV0dXJuIG51bGw7Ci0JCQkKLQkJQXJyYXlMaXN0PFN0cmluZz4gcmVzdWx0ID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCQotCQljaGFyIGRlbGltaXRlcnNbXSA9IHtzZXB9OwotCQlqYXZhLnV0aWwuU3RyaW5nVG9rZW5pemVyIHRva2VuaXplciA9IG5ldyBqYXZhLnV0aWwuU3RyaW5nVG9rZW5pemVyKHMsIG5ldyBTdHJpbmcoZGVsaW1pdGVycyksIHRydWUvKnJldHVybkRlbGltaXRlcnMqLyk7Ci0JCVN0cmluZyBsYXN0VG9rPW51bGw7Ci0JCXdoaWxlICh0b2tlbml6ZXIuaGFzTW9yZVRva2VucygpKSB7Ci0JCQlTdHJpbmcgdG9rID0gdG9rZW5pemVyLm5leHRUb2tlbigpOwotCQkJaWYgKHRvay5sZW5ndGgoKT09MSAmJiB0b2suY2hhckF0KDApPT1zZXApey8vZGVsaW1pdGVyCi0JCQkgICAgaWYgKHRvay5lcXVhbHMobGFzdFRvayl8fGxhc3RUb2s9PW51bGwvKmZpcnN0IGVsZW1lbnQgaXMgZW1wdHkqLykKLQkJCSAgICAgICAgcmVzdWx0LmFkZCgiIik7Ci0JCQl9Ci0JCQllbHNlewotCQkJICAgIGlmICh0cmltKQotCQkJICAgICAgICB0b2sgPSB0b2sudHJpbSgpOwotCQkJICAgIHJlc3VsdC5hZGQodG9rKTsKLQkJCX0KLQkJCWxhc3RUb2s9dG9rOwotCQl9Ci0JCWlmKGxhc3RUb2subGVuZ3RoKCk9PTEgJiYgbGFzdFRvay5jaGFyQXQoMCk9PXNlcCkvL2xhc3QgZWxlbWVudCBpcyBlbXB0eQotCQkgICAgcmVzdWx0LmFkZCgiIik7Ci0JCXJlc3VsdC50cmltVG9TaXplKCk7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCXB1YmxpYyBzdGF0aWMgTGlzdDxTdHJpbmc+IHN0clRvTGlzdChTdHJpbmcgcywgY2hhciBzZXApCi0JewotCQlyZXR1cm4gc3RyVG9MaXN0KHMsIHNlcCwgZmFsc2UvKnRyaW0qLyk7Ci0JfQotCQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGxpc3RUb1N0cihDb2xsZWN0aW9uIGEsIGNoYXIgc2VwKQotCXsKLQkJcmV0dXJuIGxpc3RUb1N0cihhLCBTdHJpbmcudmFsdWVPZihzZXApKTsKLQl9Ci0JCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgbGlzdFRvU3RyKENvbGxlY3Rpb248T2JqZWN0PiBhLCBTdHJpbmcgc2VwKSB7Ci0JCS8vcmV2ZXJzZSBvZiBzdHJUb0xpc3QKLQkJaWYgKGEgPT0gbnVsbCkKLQkJCXJldHVybiBudWxsOwotCQlpbnQgY291bnQgPSBhLnNpemUoKTsKLQkJaWYgKGNvdW50ID09IDApCi0JCQlyZXR1cm4gbnVsbDsKLQkJCi0JCVN0cmluZ0J1ZmZlciBidWZmZXIgPSBudWxsOwotCQlmb3IgKEl0ZXJhdG9yPE9iamVjdD4gaXRlciA9IGEuaXRlcmF0b3IoKTsgaXRlci5oYXNOZXh0KCk7ICkKLQkJewotCQkJT2JqZWN0IG9iaiA9IGl0ZXIubmV4dCgpOwotCQkJaWYgKG9iaiA9PSBudWxsKQotCQkJCWNvbnRpbnVlOwotCQkJCi0JCQlpZiAoYnVmZmVyID09IG51bGwpCi0JCQkJYnVmZmVyID0gbmV3IFN0cmluZ0J1ZmZlcigpOwotCQkJZWxzZQotCQkJCWJ1ZmZlci5hcHBlbmQoc2VwKTsKLQkJCWlmIChvYmogaW5zdGFuY2VvZiBTdHJpbmcpCi0JCQkJYnVmZmVyLmFwcGVuZCgoU3RyaW5nKW9iaik7Ci0JCQllbHNlCi0JCQkJYnVmZmVyLmFwcGVuZChvYmopOwotCQl9Ci0JCXJldHVybiAoYnVmZmVyICE9IG51bGwpID8gYnVmZmVyLnRvU3RyaW5nKCkgOiBudWxsOwotCX0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSB0ZXh0IG9mIGEgU3RyaW5nIGludG8gYSBNYXAgb2YgU3RyaW5ncywgd2hlcmUgZWFjaAotCSAqIGtleSBhbmQgdmFsdWUgaW4gdGhlIE1hcCBpcyBvZiB0eXBlIFN0cmluZy4KLQkgKiAKLQkgKiBAcGFyYW0gcyAgICAgIFRoZSBzdHJpbmcgdG8gYmUgY29udmVydGVkIHRvIGEgTWFwLgotCSAqIEBwYXJhbSBzZXAxICAgVGhlIHNlcGFyYXRvciBiZXR3ZWVuIGtleXMgYW5kIHRoZWlyCi0JICogICAgICAgICAgICAgICB2YWx1ZXMuCi0JICogQHBhcmFtIHNlcDIgICBUaGUgc2VwYXJhdG9yIGJldHdlZW4ga2V5LXZhbHVlIHBhaXJzLgotCSAqIAotCSAqIEByZXR1cm4gVGhlIHN0cmluZyBjb252ZXJ0ZWQgdG8gYSBNYXAuCi0JICovCi0JcHVibGljIHN0YXRpYyBqYXZhLnV0aWwuTWFwPFN0cmluZywgU3RyaW5nPiBzdHJUb01hcChTdHJpbmcgcywgY2hhciBzZXAxLCBjaGFyIHNlcDIpCi0JewotCQlyZXR1cm4gc3RyVG9NYXAocywgc2VwMSwgc2VwMiwgZmFsc2UvKmxvd2VyY2FzZUtleXMqLyk7Ci0JfQotCS8qKgotCSAqIENvbnZlcnQgdGhlIHRleHQgb2YgYSBTdHJpbmcgaW50byBhIE1hcCBvZiBTdHJpbmdzLCB3aGVyZSBlYWNoCi0JICoga2V5IGFuZCB2YWx1ZSBpbiB0aGUgTWFwIGlzIG9mIHR5cGUgU3RyaW5nLgotCSAqIFRoaXMgZm9ybSBhbHNvIGFsbG93cyB5b3UgdG8gc3BlY2lmeSB0aGF0IGFsbCBrZXlzIHdpbGwgYmUKLQkgKiBjb252ZXJ0ZWQgdG8gbG93ZXItY2FzZSBiZWZvcmUgYWRkaW5nIHRvIHRoZSBNYXAuCi0JICogCi0JICogQHBhcmFtIHMgICAgICBUaGUgc3RyaW5nIHRvIGJlIGNvbnZlcnRlZCB0byBhIE1hcC4KLQkgKiBAcGFyYW0gc2VwMSAgIFRoZSBzZXBhcmF0b3IgYmV0d2VlbiBrZXlzIGFuZCB0aGVpcgotCSAqICAgICAgICAgICAgICAgdmFsdWVzLgotCSAqIEBwYXJhbSBzZXAyICAgVGhlIHNlcGFyYXRvciBiZXR3ZWVuIGtleS12YWx1ZSBwYWlycy4KLQkgKiBAcGFyYW0gbG93ZXJjYXNlS2V5cwotCSAqICAgICAgICAgICAgICAgV2hldGhlciB0byBjb252ZXJ0IGtleXMgdG8gbG93ZXIgY2FzZQotCSAqICAgICAgICAgICAgICAgYmVmb3JlIGFkZGluZyB0byB0aGUgTWFwLgotCSAqIAotCSAqIEByZXR1cm4gVGhlIHN0cmluZyBjb252ZXJ0ZWQgdG8gYSBNYXAuCi0JICovCi0JcHVibGljIHN0YXRpYyBqYXZhLnV0aWwuTWFwPFN0cmluZywgU3RyaW5nPiBzdHJUb01hcChTdHJpbmcgcywgY2hhciBzZXAxLCBjaGFyIHNlcDIsIGJvb2xlYW4gbG93ZXJjYXNlS2V5cykKLQl7Ci0JCS8vZXg6IGlmIHNlcDEgaXMgJzonIGFuZCBzZXAyIGlzICcsJyB0aGVuIHMgc2hvdWxkIGJlIHNvbWV0aGluZyBsaWtlICJjb2xvcjpSZWQsc2l6ZTpYTCIKLQkJCi0JCWlmIChzID09IG51bGwgfHwgcy5sZW5ndGgoKSA9PSAwKSB7Ci0JCQlyZXR1cm4gQ29sbGVjdGlvbnMuZW1wdHlNYXAoKTsKLQkJfQotCQkJCi0JCWphdmEudXRpbC5MaXN0PFN0cmluZz4gYSA9IHN0clRvTGlzdChzLCBzZXAyKTsKLQkJaWYgKGEgPT0gbnVsbCkgewotCQkJcmV0dXJuIENvbGxlY3Rpb25zLmVtcHR5TWFwKCk7Ci0JCX0KLQkJCi0JCWphdmEudXRpbC5IYXNoTWFwPFN0cmluZywgU3RyaW5nPiBobSA9IG5ldyBqYXZhLnV0aWwuSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4oKTsKLQkJaW50IGNvdW50ID0gYS5zaXplKCk7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgY291bnQ7ICsraSkKLQkJewotCQkJU3RyaW5nIHMyID0gKFN0cmluZylhLmdldChpKTsgLy9leDogY29sb3I6UmVkCi0JCQlpbnQgcG9zID0gczIuaW5kZXhPZihzZXAxKTsKLQkJCWlmIChwb3MgPj0gMCkKLQkJCXsKLQkJCQlTdHJpbmcgbmFtZSA9IHMyLnN1YnN0cmluZygwLCBwb3MpOwotCQkJCVN0cmluZyB2YWwgPSBzMi5zdWJzdHJpbmcocG9zKzEpOwotCQkJCWlmIChsb3dlcmNhc2VLZXlzKQotCQkJCQluYW1lID0gbmFtZS50b0xvd2VyQ2FzZSgpOwotCQkJCWhtLnB1dChuYW1lLCB2YWwpOwotCQkJfQotCQl9Ci0JCXJldHVybiBobTsKLQl9Ci0JCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgbWFwVG9TdHIoamF2YS51dGlsLk1hcCBobSwgY2hhciBzZXAxLCBjaGFyIHNlcDIpCi0JLy9yZXZlcnNlIG9mIHN0clRvTWFwCi0JewotCQlpZiAoaG0gPT0gbnVsbCB8fCBobS5pc0VtcHR5KCkpCi0JCQlyZXR1cm4gbnVsbDsKLQkJCi0JCVN0cmluZ0J1ZmZlciBidWZmZXIgPSBuZXcgU3RyaW5nQnVmZmVyKCk7Ci0JCWphdmEudXRpbC5JdGVyYXRvcjxqYXZhLnV0aWwuTWFwLkVudHJ5PiBpdGVyID0gaG0uZW50cnlTZXQoKS5pdGVyYXRvcigpOwotCQl3aGlsZSAoaXRlci5oYXNOZXh0KCkpIHsKLQkJCWphdmEudXRpbC5NYXAuRW50cnkgZW50cnkgPSAoamF2YS51dGlsLk1hcC5FbnRyeSlpdGVyLm5leHQoKTsKLQkJCWJ1ZmZlci5hcHBlbmQoZW50cnkuZ2V0S2V5KCkpOwotCQkJYnVmZmVyLmFwcGVuZChzZXAxKTsKLQkJCWJ1ZmZlci5hcHBlbmQoZW50cnkuZ2V0VmFsdWUoKSk7Ci0JCQlpZiAoaXRlci5oYXNOZXh0KCkpIHsKLQkJCQlidWZmZXIuYXBwZW5kKHNlcDIpOwotCQkJfQotCQl9Ci0JCXJldHVybiBidWZmZXIudG9TdHJpbmcoKTsKLQl9Ci0gICAgLyoqCi0gICAgICogUGVyZm9ybSBhIDxlbT5jYXNlIGluc2Vuc2l0aXZlPC9lbT4gY29tcGFyaXNvbiBiZXR3ZWVuCi0gICAgICogdGhlIHN0cmluZyByZXByZXNlbnRhdGlvbnMgb2YgdHdvIG9iamVjdHMuCi0gICAgICogCi0gICAgICogQHBhcmFtIG9iajEgICBUaGUgZmlyc3Qgb2JqZWN0IHRvIGNvbXBhcmUuCi0gICAgICogQHBhcmFtIG9iajIgICBUaGUgc2Vjb25kIG9iamVjdCB0byBjb21wYXJlLgotICAgICAqIAotICAgICAqIEByZXR1cm4gPGNvZGU+dHJ1ZTwvY29kZT4gaWYgYm90aCBvYmplY3RzIGhhdmUgdGhlCi0gICAgICogICAgICAgICBzYW1lIGNhc2UtaW5zZW5zaXRpdmUgc3RyaW5nIHJlcHJlc2VudGF0aW9uLgotICAgICAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjb21wYXJlQXNTdHJpbmdzKE9iamVjdCBvYmoxLCBPYmplY3Qgb2JqMikKLQl7CQotCQlpZiAob2JqMSA9PSBudWxsIHx8IG9iajIgPT0gbnVsbCkKLQkJCXJldHVybiBvYmoxID09IG9iajI7Ci0JCQotCQlTdHJpbmcgczEsIHMyOwotCQlpZiAob2JqMSBpbnN0YW5jZW9mIFN0cmluZykgewotCQkJczEgPSAoU3RyaW5nKW9iajE7Ci0gICAgICAgIH0gZWxzZSB7Ci0JCQlzMSA9IG9iajEudG9TdHJpbmcoKTsKLSAgICAgICAgfQotCQlpZiAob2JqMiBpbnN0YW5jZW9mIFN0cmluZykgewotCQkJczIgPSAoU3RyaW5nKW9iajI7Ci0gICAgICAgIH0KLSAgICAgICAgZWxzZSB7Ci0JCQlzMiA9IG9iajIudG9TdHJpbmcoKTsKLSAgICAgICAgfQotCQkKLQkJcmV0dXJuIHMxLmVxdWFsc0lnbm9yZUNhc2UoczIpOwotCX0KLQkvKioKLQkgKiBUZXN0cyB3aGV0aGVyIGEgc3RyaW5nIHN0YXJ0cyB3aXRoIGFueSBvZiBhIGxpc3Qgb2Ygc3RyaW5ncy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gc3RhcnRzV2l0aEFueShTdHJpbmcgcywgTGlzdDxTdHJpbmc+IHByZWZpeGVzKSB7Ci0JCWludCBjb3VudCA9IHByZWZpeGVzLnNpemUoKTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBjb3VudDsgKytpKSB7Ci0JCQlpZiAocy5zdGFydHNXaXRoKChTdHJpbmcpcHJlZml4ZXMuZ2V0KGkpKSkgewotCQkJCXJldHVybiB0cnVlOwotCQkJfQotCQl9Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgYXJndW1lbnQgc3RyaW5nIHdpdGggdGhlIGZpcnN0IGNoYXIgdXBwZXItY2FzZS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBpbml0VXBwZXIoU3RyaW5nIHN0cikgewotCQlpZiAoc3RyID09IG51bGwgfHwgc3RyLmxlbmd0aCgpID09IDApIHsKLQkJCXJldHVybiBzdHI7Ci0JCX0KLQkJcmV0dXJuIENoYXJhY3Rlci50b1VwcGVyQ2FzZShzdHIuY2hhckF0KDApKSArIHN0ci5zdWJzdHJpbmcoMSk7Ci0JfQotCS8qKgotCSAqIFJldHVybnMgdGhlIGFyZ3VtZW50IHN0cmluZyB3aXRoIHRoZSBmaXJzdCBjaGFyIGxvd2VyLWNhc2UuCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgaW5pdExvd2VyKFN0cmluZyBzdHIpIHsKLQkJaWYgKHN0ciA9PSBudWxsIHx8IHN0ci5sZW5ndGgoKSA9PSAwKSB7Ci0JCQlyZXR1cm4gc3RyOwotCQl9Ci0JCXJldHVybiBDaGFyYWN0ZXIudG9Mb3dlckNhc2Uoc3RyLmNoYXJBdCgwKSkgKyBzdHIuc3Vic3RyaW5nKDEpOwotCX0KLQkvKioKLQkgKiBUZXN0cyB3aGV0aGVyIGFsbCBjaGFyYWN0ZXJzIGluIHRoZSBnaXZlbiBzdHJpbmcgYXJlIHVwcGVyCi0JICogY2FzZS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gaXNVcHBlckNhc2UoU3RyaW5nIHMpIHsKLQkJcmV0dXJuIHMudG9VcHBlckNhc2UoKS5lcXVhbHMocyk7Ci0JfQotCS8qKgotCSAqIFJldHVybnMgdGhlIGZpcnN0IG5vbi13aGl0ZSBjaGFyIGluZGV4IHN0YXJ0aW5nIGZyb20gdGhlIAotCSAqIHNwZWNpZmllZCBpbmRleC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludCBza2lwV2hpdGVTcGFjZXMoU3RyaW5nIHN0ciwgaW50IGluZGV4KSB7Ci0JCWludCBsZW4gPSBzdHIubGVuZ3RoKCk7Ci0JCXdoaWxlIChpbmRleCA8IGxlbikgewotCQkJaWYgKCFDaGFyYWN0ZXIuaXNXaGl0ZXNwYWNlKHN0ci5jaGFyQXQoaW5kZXgpKSkgewotCQkJCWJyZWFrOwotCQkJfQotCQkJKytpbmRleDsKLQkJfQotCQlyZXR1cm4gaW5kZXg7Ci0JfQotCS8qKgotCSAqIENvbGxhcHNlcyBjb25zZWN1dGl2ZSB3aGl0ZSBzcGFjZXMgaW50byBvbmUgc3BhY2UuCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY29sbGFwc2VXaGl0ZVNwYWNlcyhTdHJpbmcgc3RyKXsKLQkgICAgU3RyaW5nIHJlc3VsdD1udWxsOwotCSAgICBpZiAoc3RyIT1udWxsKXsKLQkgICAgICAgIFN0cmluZ0J1ZmZlciBidWZmZXI9bmV3IFN0cmluZ0J1ZmZlcigpOwotCSAgICAgICAgYm9vbGVhbiBpc0luV2hpdGVTcGFjZT1mYWxzZTsKLQkgICAgICAgIGZvciAoaW50IGk9MDtpPHN0ci5sZW5ndGgoKTtpKyspewotCSAgICAgICAgICAgIGNoYXIgYz1zdHIuY2hhckF0KGkpOwotCSAgICAgICAgICAgIGlmIChDaGFyYWN0ZXIuaXNXaGl0ZXNwYWNlKGMpKXsKLQkgICAgICAgICAgICAgICAgaXNJbldoaXRlU3BhY2U9dHJ1ZTsKLQkgICAgICAgICAgICB9Ci0JICAgICAgICAgICAgZWxzZSB7Ci0JICAgICAgICAgICAgICAgIGlmIChpc0luV2hpdGVTcGFjZSkKLQkgICAgICAgICAgICAgICAgICAgIGJ1ZmZlci5hcHBlbmQoIiAiKTsKLQkgICAgICAgICAgICAgICAgaXNJbldoaXRlU3BhY2U9ZmFsc2U7ICAgCi0JICAgICAgICAgICAgICAgIGJ1ZmZlci5hcHBlbmQoYyk7Ci0JICAgICAgICAgICAgfQotCSAgICAgICAgfQotCSAgICAgICAgcmVzdWx0PWJ1ZmZlci50b1N0cmluZygpOwotCSAgICB9Ci0JICAgIHJldHVybiByZXN1bHQ7Ci0JfQotCQotCS8qKgotCSAqIFV0aWxpdHkgbWV0aG9kcyB1c2VkIHRvIGNvbnZlcnQgREIgb2JqZWN0IG5hbWVzIHRvICAKLQkgKiBhcHByb3ByaWF0ZSBKYXZhIHR5cGUgYW5kIGZpZWxkIG5hbWUgCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgcGx1cmFsaXNlKFN0cmluZyBuYW1lKSB7Ci0JCVN0cmluZyByZXN1bHQgPSBuYW1lOwotCQlpZiAobmFtZS5sZW5ndGgoKSA9PSAxKSB7Ci0JCQlyZXN1bHQgKz0gJ3MnOwotCQl9IGVsc2UgaWYgKCFzZWVtc1BsdXJhbGlzZWQobmFtZSkpIHsKLQkJCVN0cmluZyBsb3dlciA9IG5hbWUudG9Mb3dlckNhc2UoKTsKLQkJCWlmICghbG93ZXIuZW5kc1dpdGgoImRhdGEiKSkgeyAvL29yZGVyRGF0YSAtLT4gb3JkZXJEYXRhcyBpcyBkdW1iCi0JCQkJY2hhciBzZWNvbmRMYXN0ID0gbG93ZXIuY2hhckF0KG5hbWUubGVuZ3RoKCkgLSAyKTsKLQkJCQlpZiAoIWlzVm93ZWwoc2Vjb25kTGFzdCkgJiYgbG93ZXIuZW5kc1dpdGgoInkiKSkgewotCQkJCQkvLyBjaXR5LCBib2R5IGV0YyAtLT4gY2l0aWVzLCBib2RpZXMKLQkJCQkJcmVzdWx0ID0gbmFtZS5zdWJzdHJpbmcoMCwgbmFtZS5sZW5ndGgoKSAtIDEpICsgImllcyI7Ci0JCQkJfSBlbHNlIGlmIChsb3dlci5lbmRzV2l0aCgiY2giKSB8fCBsb3dlci5lbmRzV2l0aCgicyIpKSB7Ci0JCQkJCS8vIHN3aXRjaCAtLT4gc3dpdGNoZXMgIG9yIGJ1cyAtLT4gYnVzZXMKLQkJCQkJcmVzdWx0ID0gbmFtZSArICJlcyI7Ci0JCQkJfSBlbHNlIHsKLQkJCQkJcmVzdWx0ID0gbmFtZSArICJzIjsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBzaW5ndWxhcmlzZShTdHJpbmcgbmFtZSkgewotCQlTdHJpbmcgcmVzdWx0ID0gbmFtZTsKLQkJaWYgKHNlZW1zUGx1cmFsaXNlZChuYW1lKSkgewotCQkJU3RyaW5nIGxvd2VyID0gbmFtZS50b0xvd2VyQ2FzZSgpOwotCQkJaWYgKGxvd2VyLmVuZHNXaXRoKCJpZXMiKSkgewotCQkJCS8vIGNpdGllcyAtLT4gY2l0eQotCQkJCXJlc3VsdCA9IG5hbWUuc3Vic3RyaW5nKDAsIG5hbWUubGVuZ3RoKCkgLSAzKSArICJ5IjsKLQkJCX0gZWxzZSBpZiAobG93ZXIuZW5kc1dpdGgoImNoZXMiKSB8fCBsb3dlci5lbmRzV2l0aCgic2VzIikpIHsKLQkJCQkvLyBzd2l0Y2hlcyAtLT4gc3dpdGNoIG9yIGJ1c2VzIC0tPiBidXMKLQkJCQlyZXN1bHQgPSBuYW1lLnN1YnN0cmluZygwLCBuYW1lLmxlbmd0aCgpIC0gMik7Ci0JCQl9IGVsc2UgaWYgKGxvd2VyLmVuZHNXaXRoKCJzIikpIHsKLQkJCQkvLyBjdXN0b21lcnMgLS0+IGN1c3RvbWVyCi0JCQkJcmVzdWx0ID0gbmFtZS5zdWJzdHJpbmcoMCwgbmFtZS5sZW5ndGgoKSAtIDEpOwotCQkJfQotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCXByaXZhdGUgZmluYWwgc3RhdGljIGJvb2xlYW4gaXNWb3dlbChjaGFyIGMpIHsKLQkJYm9vbGVhbiB2b3dlbCA9IGZhbHNlOwotCQl2b3dlbCB8PSBjID09ICdhJzsKLQkJdm93ZWwgfD0gYyA9PSAnZSc7Ci0JCXZvd2VsIHw9IGMgPT0gJ2knOwotCQl2b3dlbCB8PSBjID09ICdvJzsKLQkJdm93ZWwgfD0gYyA9PSAndSc7Ci0JCXZvd2VsIHw9IGMgPT0gJ3knOwotCQlyZXR1cm4gdm93ZWw7Ci0JfQotCXByaXZhdGUgc3RhdGljIGJvb2xlYW4gc2VlbXNQbHVyYWxpc2VkKFN0cmluZyBuYW1lKSB7Ci0JCW5hbWUgPSBuYW1lLnRvTG93ZXJDYXNlKCk7Ci0JCWJvb2xlYW4gcGx1cmFsaXNlZCA9IGZhbHNlOwotCQlwbHVyYWxpc2VkIHw9IG5hbWUuZW5kc1dpdGgoImVzIik7Ci0JCXBsdXJhbGlzZWQgfD0gbmFtZS5lbmRzV2l0aCgicyIpOwotCQlwbHVyYWxpc2VkICY9ICEobmFtZS5lbmRzV2l0aCgic3MiKSB8fCBuYW1lLmVuZHNXaXRoKCJ1cyIpKTsKLQkJcmV0dXJuIHBsdXJhbGlzZWQ7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybnMgdGhlIHBhY2thZ2UgbmFtZSBvZiBhIGNsYXNzIG5hbWUuCi0JICogRm9yIGV4YW1wbGUgaWYgZ2l2ZW4gPGNvZGU+b3JhY2xlLnV0aWwuT2JqZWN0VXRpbDwvY29kZT4gaXQgd291bGQgcmV0dXJuIAotCSAqIDxjb2RlPm9yYWNsZS51dGlsPC9jb2RlPi4gSWYgdGhlIGNsYXNzIGlzIG5vdCBpbiBhIHBhY2thZ2UgdGhlbiBudWxsIGlzIHJldHVybmVkLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGdldFBhY2thZ2VOYW1lKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJaWYoY2xhc3NOYW1lID09IG51bGwpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCWludCBsYXN0RG90SW5kZXggPSBjbGFzc05hbWUubGFzdEluZGV4T2YoJy4nKTsKLQkJaWYgKGxhc3REb3RJbmRleCA8IDApCi0JCQlyZXR1cm4gbnVsbDsKLQkJcmV0dXJuIGNsYXNzTmFtZS5zdWJzdHJpbmcoMCwgbGFzdERvdEluZGV4KTsKLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgY2xhc3MgbmFtZSBnaXZlbiBhIGZ1bGwgY2xhc3MgbmFtZS4KLQkgKiBGb3IgZXhhbXBsZSBpZiBnaXZlbiA8Y29kZT5vcmFjbGUudXRpbC5PYmplY3RVdGlsPC9jb2RlPiBpdCB3b3VsZCByZXR1cm4gCi0JICogPGNvZGU+T2JqZWN0VXRpbDwvY29kZT4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBnZXRDbGFzc05hbWUoU3RyaW5nIGZ1bGxDbGFzc05hbWUpIHsKLQkJaWYoZnVsbENsYXNzTmFtZSA9PSBudWxsKSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQlpbnQgbGFzdERvdEluZGV4ID0gZnVsbENsYXNzTmFtZS5sYXN0SW5kZXhPZignLicpOwotCQlpZiAobGFzdERvdEluZGV4IDwgMCkKLQkJCXJldHVybiBmdWxsQ2xhc3NOYW1lOwotCQlyZXR1cm4gZnVsbENsYXNzTmFtZS5zdWJzdHJpbmcobGFzdERvdEluZGV4KzEpOwotCX0KLQotCQotCS8qKgotCSAqIENvbnZlcnRzIGEgZGF0YWJhc2UgY29sdW1uIG5hbWUgdG8gYSBKYXZhIHZhcmlhYmxlIG5hbWUgKDxlbT5maXJzdCBsZXR0ZXIKLQkgKiBub3QgY2FwaXRhbGl6ZWQ8L2VtPikuCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY29sdW1uTmFtZVRvVmFyTmFtZShTdHJpbmcgY29sdW1uTmFtZSkgewotCQlyZXR1cm4gZGJOYW1lVG9WYXJOYW1lKGNvbHVtbk5hbWUpOwotCX0KLQkvKioKLQkgKiBDb252ZXJ0cyBhIGRhdGFiYXNlIHRhYmxlIG5hbWUgdG8gYSBKYXZhIHZhcmlhYmxlIG5hbWUgKDxlbT5maXJzdCBsZXR0ZXIKLQkgKiBub3QgY2FwaXRhbGl6ZWQ8L2VtPikuCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgdGFibGVOYW1lVG9WYXJOYW1lKFN0cmluZyB0YWJsZU5hbWUpIHsKLQkJcmV0dXJuIGRiTmFtZVRvVmFyTmFtZSh0YWJsZU5hbWUpOwotCX0KLQkvKioKLQkgKiBDb252ZXJ0cyBhIGRhdGFiYXNlIG5hbWUgKHRhYmxlIG9yIGNvbHVtbikgdG8gYSBqYXZhIG5hbWUgKDxlbT5maXJzdCBsZXR0ZXIKLQkgKiBub3QgY2FwaXRhbGl6ZWQ8L2VtPikuIGVtcGxveWVlX25hbWUgb3IgZW1wbG95ZWUtbmFtZSAtPiBlbXBsb3llZU5hbWUKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBTdHJpbmcgZGJOYW1lVG9WYXJOYW1lKFN0cmluZyBzKSB7Ci0JCWlmICgiIi5lcXVhbHMocykpIHsKLQkJCXJldHVybiBzOwotCQl9Ci0JCVN0cmluZ0J1ZmZlciByZXN1bHQgPSBuZXcgU3RyaW5nQnVmZmVyKCk7Ci0KLQkJYm9vbGVhbiBjYXBpdGFsaXplID0gdHJ1ZTsKLQkJYm9vbGVhbiBsYXN0Q2FwaXRhbCA9IGZhbHNlOwotCQlib29sZWFuIGxhc3REZWNhcGl0YWxpemVkID0gZmFsc2U7Ci0JCVN0cmluZyBwID0gbnVsbDsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBzLmxlbmd0aCgpOyBpKyspIHsKLQkJCVN0cmluZyBjID0gcy5zdWJzdHJpbmcoaSwgaSArIDEpOwotCQkJaWYgKCJfIi5lcXVhbHMoYykgfHwgIiAiLmVxdWFscyhjKSkgewotCQkJCWNhcGl0YWxpemUgPSB0cnVlOwotCQkJCWNvbnRpbnVlOwotCQkJfQotCi0JCQlpZiAoYy50b1VwcGVyQ2FzZSgpLmVxdWFscyhjKSkgewotCQkJCWlmIChsYXN0RGVjYXBpdGFsaXplZCAmJiAhbGFzdENhcGl0YWwpIHsKLQkJCQkJY2FwaXRhbGl6ZSA9IHRydWU7Ci0JCQkJfQotCQkJCWxhc3RDYXBpdGFsID0gdHJ1ZTsKLQkJCX0gZWxzZSB7Ci0JCQkJbGFzdENhcGl0YWwgPSBmYWxzZTsKLQkJCX0KLQotCQkJaWYgKGNhcGl0YWxpemUpIHsKLQkJCQlpZiAocCA9PSBudWxsIHx8ICFwLmVxdWFscygiXyIpKSB7Ci0JCQkJCXJlc3VsdC5hcHBlbmQoYy50b1VwcGVyQ2FzZSgpKTsKLQkJCQkJY2FwaXRhbGl6ZSA9IGZhbHNlOwotCQkJCQlwID0gYzsKLQkJCQl9IGVsc2UgewotCQkJCQlyZXN1bHQuYXBwZW5kKGMudG9Mb3dlckNhc2UoKSk7Ci0JCQkJCWNhcGl0YWxpemUgPSBmYWxzZTsKLQkJCQkJcCA9IGM7Ci0JCQkJfQotCQkJfSBlbHNlIHsKLQkJCQlyZXN1bHQuYXBwZW5kKGMudG9Mb3dlckNhc2UoKSk7Ci0JCQkJbGFzdERlY2FwaXRhbGl6ZWQgPSB0cnVlOwotCQkJCXAgPSBjOwotCQkJfQotCi0JCX0KLQkJLyp0aGlzIHdhcyB1c2luZyBTdHJpbmdVdGlsLmluaXRMb3dlci4gQ2hhbmdlZCB0byBJbnRyb3NwZWN0b3IuZGVjYXBpdGFsaXplIHNvIHRoYXQgCi0JCSAqIGl0IHJldHVybnMgdGhlIGNvcnJlY3QgYmVhbiBwcm9wZXJ0eSBuYW1lIHdoZW4gY2FsbGVkIGZyb20gY29sdW1uTmFtZVRvVmFyTmFtZS4KLQkJICogVGhpcyBpcyBuZWNlc3NhcnkgYmVjYXVzZSBvdGhlcndpc2UgVVJMIHdvdWxkIGJlIHVSTCB3aGljaCB3b3VsZCBjYXVzZSAKLQkJICogYW4gIlRoZSBwcm9wZXJ0eSB1UkwgaXMgdW5kZWZpbmVkIGZvciB0aGUgdHlwZSB4eCIgZXJyb3IgYmVjYXVzZSAKLQkJICogSW50cm9zcGVjdG9yLmdldEJlYW5JbmZvICh1c2VkIGJ5IEphdmFUeXBlSW50cm9zcGVjdG9yKSByZXR1cm5zIAotCQkgKiB0aGUgcHJvcGVydHkgbmFtZSBhcyBVUkwuKi8KLQkJU3RyaW5nIHJlc3VsdFN0ciA9IEludHJvc3BlY3Rvci5kZWNhcGl0YWxpemUocmVzdWx0LnRvU3RyaW5nKCkpOwotCQlpZiAocmVzdWx0U3RyLmVxdWFscygiY2xhc3MiKSkgewotCQkJLy8gImNsYXNzIiBpcyBpbGxlZ2FsIGJlY2F1c2VPZiBPYmplY3QuZ2V0Q2xhc3MoKSBjbGFzaAotCQkJcmVzdWx0U3RyID0gImNsYXp6IjsKLQkJfQotCQlyZXR1cm4gcmVzdWx0U3RyOwotCX0KLQkKLQkvKioKLQkgKiBDb21wYXJlIHR3byBvYmplY3RzLiBJZiBib3RoIFN0cmluZywgaWdub3JlIGNhc2UKLQkgKiBAcGFyYW0gbzEKLQkgKiBAcGFyYW0gbzIKLQkgKiBAcGFyYW0gaWdub3JlQ2FzZUlmU3RyCi0JICogQHJldHVybgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBlcXVhbE9iamVjdHMoT2JqZWN0IG8xLCBPYmplY3QgbzIsIGJvb2xlYW4gaWdub3JlQ2FzZUlmU3RyKQotCXsKLQkJaWYgKG8xID09IG8yKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCSAgICBib29sZWFuIHJlc3VsdDsKLQkgICAgaWYgKG8xID09IG51bGwgfHwgbzIgPT0gbnVsbCkgewotCSAgICAJcmV0dXJuIGZhbHNlOyAvL3dlIGFscmVhZHkgY2hlY2tlZCBvMSA9PSBvMiBhYm92ZQotCSAgICB9Ci0JICAgIGlmIChpZ25vcmVDYXNlSWZTdHIgJiYgbzEgaW5zdGFuY2VvZiBTdHJpbmcgJiYgbzIgaW5zdGFuY2VvZiBTdHJpbmcpCi0JICAgICAgICByZXN1bHQgPSAoKFN0cmluZylvMSkuZXF1YWxzSWdub3JlQ2FzZSgoU3RyaW5nKW8yKTsKLQkgICAgZWxzZQotCSAgICAgICAgcmVzdWx0ID0gbzEuZXF1YWxzKG8yKTsKLQkKLQkgICAgcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gZXF1YWxPYmplY3RzKE9iamVjdCBvMSwgT2JqZWN0IG8yKQotCXsKLQkgICAgcmV0dXJuIGVxdWFsT2JqZWN0cyhvMSwgbzIsIGZhbHNlLyppZ25vcmVDYXNlSWZTdHIqLyk7Ci0JfQotCQotfQotCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL2ludGVybmFsMi91dGlsL1VybFV0aWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL3V0aWwvVXJsVXRpbC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlMDk3NTk2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vaW50ZXJuYWwyL3V0aWwvVXJsVXRpbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTI1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLQotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZ2VuLmludGVybmFsMi51dGlsOwotCi1pbXBvcnQgamF2YS5pby5GaWxlOwotaW1wb3J0IGphdmEuaW8uSU9FeGNlcHRpb247Ci1pbXBvcnQgamF2YS5uZXQuTWFsZm9ybWVkVVJMRXhjZXB0aW9uOwotaW1wb3J0IGphdmEubmV0LlVSTDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5GaWxlTG9jYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuUGF0aDsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuUGxhdGZvcm07Ci1pbXBvcnQgb3JnLm9zZ2kuZnJhbWV3b3JrLkJ1bmRsZTsKLQotLyoqCi0gKiBDb2xsZWN0aW9ucyBvZiB1dGlsaXR5IG1ldGhvZHMgaGFuZGxpbmcgVVJMcy4KLSAqIAotICovCi1wdWJsaWMgY2xhc3MgVXJsVXRpbAotewotCS8qKgotCSAqIFRoZSA8Y29kZT5maWxlPC9jb2RlPiBzdHJpbmcgaW5kaWNhdGluZyBhIHVybCBmaWxlIHByb3RvY29sLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIEZJTEVfUFJPVE9DT0wgPSAiZmlsZSI7Ci0JLyoqCi0JICogVGhlIDxjb2RlPmZpbGU8L2NvZGU+IHN0cmluZyBpbmRpY2F0aW5nIGEgdXJsIGh0dHAgcHJvdG9jb2wuCi0JICovCi0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgSFRUUF9QUk9UT0NPTCA9ICJodHRwIjsKLQkvKioKLQkgKiBUaGUgPGNvZGU+ZmlsZTwvY29kZT4gc3RyaW5nIGluZGljYXRpbmcgYSB1cmwgaHR0cCBwcm90b2NvbC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBIVFRQU19QUk9UT0NPTCA9ICJodHRwcyI7Ci0JLyoqCi0JICogVGhlIDxjb2RlPmZpbGU8L2NvZGU+IHN0cmluZyBpbmRpY2F0aW5nIGEgdXJsIGZpbGUgcHJvdG9jb2wuCi0JICovCi0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgSkFSX1BST1RPQ09MID0gImphciI7Ci0KLQkKLQkvKioKLQkgKiBSZXR1cm5zIHRydWUgaWYgdGhlIHNwZWNpZmllZCB1cmwgaXMgdG8gYSBmaWxlLCBpLmUgaXRzIHByb3RvY29sIGlzIDxjb2RlPmZpbGU8L2NvZGU+LgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBpc0ZpbGVVcmwoVVJMIHVybCkgewotCQlyZXR1cm4gdXJsICE9IG51bGwgJiYgRklMRV9QUk9UT0NPTC5lcXVhbHModXJsLmdldFByb3RvY29sKCkpOwotCX0KLQkvKioKLQkgKiBSZXR1cm5zIHRydWUgaWYgdGhlIHNwZWNpZmllZCB1cmwgaXMgdG8gYSBqYXIsIGkuZSBpdHMgcHJvdG9jb2wgaXMgPGNvZGU+amFyPC9jb2RlPi4KLQkgKiBGb3IgZXhhbXBsZSA8Y29kZT5qYXI6ZmlsZTovQzovdGVzdGFwcHMvZXhhbXBsZS9XRUItSU5GL2xpYi9zdHJ1dHMuamFyIS9NRVRBLUlORi90bGRzL3N0cnV0cy1iZWFuLnRsZDwvY29kZT4uCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGlzSmFyVXJsKFVSTCB1cmwpIHsKLQkJcmV0dXJuIHVybCAhPSBudWxsICYmIEpBUl9QUk9UT0NPTC5lcXVhbHModXJsLmdldFByb3RvY29sKCkpOwotCX0KLQkvKioKLQkgKiBSZXR1cm5zIHRydWUgaWYgdGhlIHNwZWNpZmllZCB1cmwgcHJvdG9jb2wgaXMgaHR0cC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gaXNIdHRwVXJsKFVSTCB1cmwpIHsKLQkJU3RyaW5nIHByb3RvY29sID0gIHVybC5nZXRQcm90b2NvbCgpOwotCQlyZXR1cm4gdXJsICE9IG51bGwgJiYgKEhUVFBfUFJPVE9DT0wuZXF1YWxzKHByb3RvY29sKSB8fCBIVFRQU19QUk9UT0NPTC5lcXVhbHMocHJvdG9jb2wpKTsKLQl9Ci0JLyoqCi0JICogUmV0dXJucyB0aGUgPGNvZGU+RmlsZTwvY29kZT4gY29ycmVzcG9uZGluZyB0byBhIHVybCwgb3IgbnVsbCBpZiB0aGUgdXJsIAotCSAqIHByb3RvY29sIGlzIG5vdCBmaWxlLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgamF2YS5pby5GaWxlIGdldFVybEZpbGUoVVJMIHVybCkgewotCQlpZiAoaXNGaWxlVXJsKHVybCkgJiYgIWlzSmFyVXJsKCB1cmwgKSApewotCQkJRmlsZSByZXQgPSBuZXcgamF2YS5pby5GaWxlKHVybC5nZXRGaWxlKCkpOwotCQkJcmV0dXJuIHJldCA7Ci0JCX0KLQkJcmV0dXJuIG51bGw7Ci0gCX0KLQotCQotCS8qKgotCSAqIFJldHVybnMgdGhlIHVybCB0byBhIGphciBmaWxlIGdpdmVuIGEgdXJsIHRvIGEgZmlsZSBpbnNpZGUgCi0JICogdGhlIGphci4KLQkgKiBGb3IgZXhhbXBsZSBpZiBnaXZlbiAKLQkgKiA8Y29kZT5qYXI6ZmlsZTovQzovdGVzdGFwcHMvZXhhbXBsZS9XRUItSU5GL2xpYi9zdHJ1dHMuamFyIS9NRVRBLUlORi90bGRzL3N0cnV0cy1iZWFuLnRsZDwvY29kZT4KLQkgKiB0aGlzIG1ldGhvZCByZXR1cm5zIDxjb2RlPmZpbGU6L0M6L3Rlc3RhcHBzL2V4YW1wbGUvV0VCLUlORi9saWIvc3RydXRzLmphcjwvY29kZT4uCi0JICogCi0JICogPHA+UmV0dXJucyBudWxsIGlmIHRoZSBnaXZlbiB1cmwgaXMgbm90IHJlY29nbml6ZWQgYXMgYSB1cmwgdG8gYSBmaWxlIAotCSAqIGluc2lkZSBhIGphci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFVSTCBnZXRKYXJGaWxlVXJsKFVSTCB1cmwpIHsKLQkJaWYgKCFpc0phclVybCh1cmwpKSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQlTdHJpbmcgZmlsZSA9IHVybC5nZXRGaWxlKCk7IC8vZmlsZTovQzovdGVzdGFwcHMvZXhhbXBsZS9XRUItSU5GL2xpYi9zdHJ1dHMuamFyIS9NRVRBLUlORi90bGRzL3N0cnV0cy1iZWFuLnRsZAotCQlpbnQgaW5kZXggPSBmaWxlLmluZGV4T2YoJyEnKTsKLQkJaWYgKGluZGV4IDwgMCkgewotCQkJcmV0dXJuIG51bGw7Ci0JCX0KLQkJU3RyaW5nIGphckZpbGVVcmxTdHIgPSBmaWxlLnN1YnN0cmluZygwLCBpbmRleCk7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gbmV3IFVSTChqYXJGaWxlVXJsU3RyKTsKLQkJfSBjYXRjaCAoTWFsZm9ybWVkVVJMRXhjZXB0aW9uIGUpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JfQotCQotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBpc1JlbW90ZShTdHJpbmcgdXJsKXsKLQkJcmV0dXJuIHVybC5zdGFydHNXaXRoKCJodHRwOiIpfHx1cmwuc3RhcnRzV2l0aCgiaHR0cHM6Iil8fHVybC5zdGFydHNXaXRoKCJ3d3cuIik7Ci0JfQotCQotCXB1YmxpYyBzdGF0aWMgRmlsZSBnZXRUZW1wbGF0ZUZvbGRlcihTdHJpbmcgcGx1Z0lkICwgU3RyaW5nIHN0clBhdGggKXsKLQkJQnVuZGxlIGJ1bmRsZSA9IFBsYXRmb3JtLmdldEJ1bmRsZSggcGx1Z0lkICk7Ci0JCVBhdGggcGF0aCA9IG5ldyBQYXRoKCBzdHJQYXRoICk7Ci0JCVVSTCB1cmwgPSBGaWxlTG9jYXRvci5maW5kKGJ1bmRsZSwgcGF0aCwgbnVsbCk7Ci0JCXRyeSB7Ci0JCQlVUkwgdGVtcGxVcmw7Ci0JCQl0ZW1wbFVybCA9IEZpbGVMb2NhdG9yLnJlc29sdmUodXJsKTsKLQkJCUZpbGUgdGVtcGxEaXIgPSBVcmxVdGlsLmdldFVybEZpbGUodGVtcGxVcmwpOwotCQkJcmV0dXJuIHRlbXBsRGlyIDsKLQkJfSBjYXRjaCAoSU9FeGNlcHRpb24gZSkgewotCQkJZS5wcmludFN0YWNrVHJhY2UoKTsKLQkJfQotCQlyZXR1cm4gbnVsbDsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3RlbXBsYXRlcy9lbnRpdGllcy9jb2x1bW4udm0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3RlbXBsYXRlcy9lbnRpdGllcy9jb2x1bW4udm0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQ4ZTdmMzIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi90ZW1wbGF0ZXMvZW50aXRpZXMvY29sdW1uLnZtCisrKyAvZGV2L251bGwKQEAgLTEsNTIgKzAsMCBAQAotIyNpbmNsdWRlZCB0ZW1wbGF0ZS4gR2VuZXJhdGVzIHRoZSBAQ29sdW1uIGFubm90YXRpb24uCi0jI0Fzc3VtZXMgdGhhdCB0aGUgY29udGV4dCBoYXMgYSAiY29sdW1uIiBhbmQgYSAidGFibGUiIG9iamVjdAotIyNnZW5lcmF0ZSBhbm5vdGF0aW9uIG9ubHkgdGhlIHBhcmFtZXRlcnMgZm9yIHRoZSBjb2x1bW4gTk9UIGRlZmF1bHQKLSMjYW5kIHRoZSBnZW5lcmF0ZURMTEFubm90YXRpb24gcHJvcGVydHkgaXMgbm90IHNldCBvbiB0aGUgdGFibGUKLSMjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotI21hY3JvKCBhcHBlbmQgJG1lbWJlcnMgJHBhcmFtZXRlcnMgKQotI2lmKCAkbWVtYmVycyA9PSAiIikKLSNzZXQoICRtZW1iZXJzID0gJHBhcmFtZXRlcnMgKQotI2Vsc2UKLSNzZXQoICRtZW1iZXJzID0gIiRtZW1iZXJzLCAkcGFyYW1ldGVycyIgKSAKLSNlbmQJCi0jZW5kCi0jIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLSNpZiAoICRjb2x1bW4uZGF0YVR5cGVMT0IpCi0gICAgQExvYigpCi0jZW5kCi0jaWYgKCAkY29sdW1uLm5lZWRNYXBUZW1wb3JhbFR5cGUpCi0gICAgQFRlbXBvcmFsKCBUZW1wb3JhbFR5cGUuJGNvbHVtbi50ZW1wb3JhbFR5cGUpCi0jZW5kCi0jc2V0ICgkbWVtYmVycyA9ICIiKQotI2lmICggISRjb2x1bW4uZGVmYXVsdCB8fCAkY3VzdG9taXplci5nZW5lcmF0ZURETEFubm90YXRpb25zICkKLSNzZXQgKCRtZW1iZXJzID0gIm5hbWU9JGN1c3RvbWl6ZXIucXVvdGUoJGNvbHVtbi5uYW1lKSIpCi0jaWYgKCEkY29sdW1uLmluc2VydGFibGUpCi0jc2V0ICgkbWVtYmVycyA9ICIkbWVtYmVycywgaW5zZXJ0YWJsZT1mYWxzZSIpCi0jZW5kCi0jaWYgKCEkY29sdW1uLnVwZGF0ZWFibGUpCi0jc2V0ICgkbWVtYmVycyA9ICIkbWVtYmVycywgdXBkYXRhYmxlPWZhbHNlIikKLSNlbmQKLSNlbmQKLSNpZiggJGN1c3RvbWl6ZXIuZ2VuZXJhdGVERExBbm5vdGF0aW9ucyApCi0jaWYgKCRjb2x1bW4udW5pcXVlKQotI2FwcGVuZCgkbWVtYmVycyAgInVuaXF1ZT10cnVlIikKLSNlbmQKLSNpZiAoISRjb2x1bW4ubnVsbGFibGUpCi0jYXBwZW5kKCRtZW1iZXJzICAibnVsbGFibGU9ZmFsc2UiKQotI2VuZAotI2lmICgkY29sdW1uLnNpemUgPiAwKQotI2lmICgkY29sdW1uLm51bWVyaWMpCi0jYXBwZW5kKCRtZW1iZXJzICJwcmVjaXNpb249JGNvbHVtbi5zaXplIikKLSNpZiAoJGNvbHVtbi5kZWNpbWFsRGlnaXRzICE9IDAgJiYgJGNvbHVtbi5kZWNpbWFsRGlnaXRzICE9IC0xKQotI2FwcGVuZCgkbWVtYmVycyAic2NhbGU9JGNvbHVtbi5kZWNpbWFsRGlnaXRzIikKLSNlbmQKLSNlbHNlCi0jaWYgKCAhJGNvbHVtbi5kYXRhVHlwZUxPQikKLSNhcHBlbmQoJG1lbWJlcnMgImxlbmd0aD0kY29sdW1uLnNpemUiKQotI2VuZAotI2VuZAotI2VuZAotI2VuZAotI2lmKCAkbWVtYmVycyAhPSIiICkKLQlAQ29sdW1uKCRtZW1iZXJzKQotI2VuZApkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi90ZW1wbGF0ZXMvZW50aXRpZXMvam9pbi52bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vdGVtcGxhdGVzL2VudGl0aWVzL2pvaW4udm0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDMyMTE3YzYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi90ZW1wbGF0ZXMvZW50aXRpZXMvam9pbi52bQorKysgL2Rldi9udWxsCkBAIC0xLDY5ICswLDAgQEAKLSMjaW5jbHVkZWQgdGVtcGxhdGUuIEdlbmVyYXRlcyB0aGUgQEpvaW5UYWJsZSwgQEpvaW5Db2x1bW4gb3IgQEpvaW5Db2x1bW5zIGFubm90YXRpb24uCi0jI0Fzc3VtZXMgdGhhdCB0aGUgY29udGV4dCBoYXMgYSAicm9sZSIgb2JqZWN0IHJlcHJlc2VudGluZyB0aGUgZ2VuZXJhdGVkIEFzc29jaWF0aW9uUm9sZQotIyMKLSMjbWFjcm8gam9pbkNvbHVtbiB1c2VzICRjb2x1bW4sICRyZWZlcmVuY2VkQ29sdW1uCi0jbWFjcm8gKGpvaW5Db2x1bW4gJGNvbHVtbiAkcmVmZXJlbmNlZENvbHVtbikKLSNzZXQgKCRtZW1iZXJzID0gIm5hbWU9JGN1c3RvbWl6ZXIucXVvdGUoJGNvbHVtbi5qb2luQ29sdW1uTmFtZSkiKQotI2lmKCAhJHJlZmVyZW5jZWRDb2x1bW4ucHJpbWFyeUtleSApCi0jc2V0ICgkbWVtYmVycyA9ICIkbWVtYmVycywgcmVmZXJlbmNlZENvbHVtbk5hbWU9JGN1c3RvbWl6ZXIucXVvdGUoJHJlZmVyZW5jZWRDb2x1bW4ubmFtZSkiKQotI2VuZAotI2lmKCAkY3VzdG9taXplci5nZW5lcmF0ZURETEFubm90YXRpb25zICkKLSNpZiAoJGNvbHVtbi51bmlxdWUgJiYgISRjb2x1bW4ucHJpbWFyeUtleSkKLSNzZXQgKCRtZW1iZXJzID0gIiRtZW1iZXJzLCB1bmlxdWU9dHJ1ZSIpCi0jZW5kCi0jaWYgKCEkY29sdW1uLm51bGxhYmxlKQotI3NldCAoJG1lbWJlcnMgPSAiJG1lbWJlcnMsIG51bGxhYmxlPWZhbHNlIikKLSNlbmQKLSNlbmQKLSNpZiAoJGN1c3RvbWl6ZXIuZ2VuZXJhdGVERExBbm5vdGF0aW9ucyAmJiAhJHJvbGUuYXNzb2NpYXRpb24uam9pblRhYmxlICYmICEkcm9sZS5yZWZlcnJlclRhYmxlLmlzQ29sdW1uVXBkYXRlSW5zZXJ0KCRyb2xlLCAkY29sdW1uKSkKLSNzZXQgKCRtZW1iZXJzID0gIiRtZW1iZXJzLCBpbnNlcnRhYmxlPWZhbHNlLCB1cGRhdGFibGU9ZmFsc2UiKQotI2VuZAotQEpvaW5Db2x1bW4oJG1lbWJlcnMpI2VuZAotIyMKLSMjCi0jIwotI2lmICgkcm9sZS5hc3NvY2lhdGlvbi5qb2luVGFibGUpCi0jc2V0ICgkam9pblRhYmxlID0gJHJvbGUuYXNzb2NpYXRpb24uam9pblRhYmxlKQotCUBKb2luVGFibGUoCi0JCW5hbWU9IiR7am9pblRhYmxlLmpvaW5UYWJsZUFubm90YXRpb25OYW1lfSIKLSNpZiAoJGpvaW5UYWJsZS5zY2hlbWEhPSIiKQotCQksIHNjaGVtYT0iJHtqb2luVGFibGUuc2NoZW1hfSIKLSNlbmQKLQkJLCBqb2luQ29sdW1ucz17Ci0jZm9yZWFjaCAoJGNvbHVtbiBpbiAkcm9sZS5yZWZlcnJlckNvbHVtbnMpCi0jc2V0ICgkcmVmZXJlbmNlZENvbHVtbiA9ICRyb2xlLmdldFJlZmVyZW5jZWRDb2x1bW4oJHtjb2x1bW4ubmFtZX0pKQotIyMkcmVmZXJlbmNlZENvbHVtbiBpcyB0aGUgY29sdW1uIGluIHRoZSBqb2luIHRhYmxlCi0JCQkjam9pbkNvbHVtbigkcmVmZXJlbmNlZENvbHVtbiAkY29sdW1uKSwKLSNlbmQKLQkJCX0KLQkJLCBpbnZlcnNlSm9pbkNvbHVtbnM9ewotI2ZvcmVhY2ggKCRjb2x1bW4gaW4gJHJvbGUucmVmZXJlbmNlZENvbHVtbnMpCi0jc2V0ICgkcmVmZXJlbmNlZENvbHVtbiA9ICRyb2xlLmdldFJlZmVycmVyQ29sdW1uKCR7Y29sdW1uLm5hbWV9KSkKLSMjJHJlZmVyZW5jZWRDb2x1bW4gaXMgdGhlIGNvbHVtbiBpbiB0aGUgam9pbiB0YWJsZQotCQkJI2pvaW5Db2x1bW4oJHJlZmVyZW5jZWRDb2x1bW4gJGNvbHVtbiksCi0jZW5kCi0JCQl9Ci0JCSkKLSNlbHNlCi0jaWYgKCRyb2xlLnJlZmVycmVyQ29sdW1ucy5zaXplKCkgPT0gMSkKLSNzZXQgKCRjb2x1bW4gPSAkcm9sZS5yZWZlcnJlckNvbHVtbnMuZ2V0KDApKQotI3NldCAoJHJlZmVyZW5jZWRDb2x1bW4gPSAkcm9sZS5nZXRSZWZlcmVuY2VkQ29sdW1uKCR7Y29sdW1uLm5hbWV9KSkKLSNzZXQgKCRyZWZlcmVuY2VkVGFibGVOYW1lID0gJHJvbGUuZ2V0UmVmZXJlbmNlZFRhYmxlKCkuZ2V0TmFtZSgpICkKLSNzZXQoICRyZWZlcmVuY2VkVGFibGVQa05hbWUgPSAkcm9sZS5nZXRSZWZlcmVuY2VkVGFibGUoKS5nZXRQcmltYXJ5S2V5Q29sdW1uKCkubmFtZSApCi0jc2V0KCAkY29tcHV0ZWRKb2luQ29sdW1uTmFtZSA9ICIke3JvbGUucHJvcGVydHlOYW1lfV8ke3JlZmVyZW5jZWRUYWJsZVBrTmFtZX0iICkKLSNpZigkY29sdW1uLm5hbWUudG9VcHBlckNhc2UoKSAhPSAkY29tcHV0ZWRKb2luQ29sdW1uTmFtZS50b1VwcGVyQ2FzZSgpICkKLQkjam9pbkNvbHVtbigkY29sdW1uICRyZWZlcmVuY2VkQ29sdW1uKQotCi0jZWxzZWlmKCAkY3VzdG9taXplci5nZW5lcmF0ZURETEFubm90YXRpb25zICkKLQkjam9pbkNvbHVtbigkY29sdW1uICRyZWZlcmVuY2VkQ29sdW1uKQotCi0jZW5kCi0jZWxzZQotCUBKb2luQ29sdW1ucyh7Ci0jZm9yZWFjaCAoJGNvbHVtbiBpbiAkcm9sZS5yZWZlcnJlckNvbHVtbnMpCi0jc2V0ICgkcmVmZXJlbmNlZENvbHVtbiA9ICRyb2xlLmdldFJlZmVyZW5jZWRDb2x1bW4oJHtjb2x1bW4ubmFtZX0pKQotCQkjam9pbkNvbHVtbigkY29sdW1uICRyZWZlcmVuY2VkQ29sdW1uKSwKLSNlbmQJCQotCQl9KQotI2VuZAotI2VuZApcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vdGVtcGxhdGVzL2VudGl0aWVzL21haW4uamF2YS52bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vdGVtcGxhdGVzL2VudGl0aWVzL21haW4uamF2YS52bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMGViNmM0Yi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3RlbXBsYXRlcy9lbnRpdGllcy9tYWluLmphdmEudm0KKysrIC9kZXYvbnVsbApAQCAtMSwxMzIgKzAsMCBAQAotI2lmICgkdGFibGUucGFja2FnZSAhPSAiIikKLXBhY2thZ2UgJHt0YWJsZS5wYWNrYWdlfTsKLSNlbmQKLQotaW1wb3J0IGphdmEuaW8uU2VyaWFsaXphYmxlOwotaW1wb3J0IGphdmF4LnBlcnNpc3RlbmNlLio7Ci0KLS8qKgotICogVGhlIHBlcnNpc3RlbnQgY2xhc3MgZm9yIHRoZSAke3RhYmxlLm5hbWV9IGRhdGFiYXNlIHRhYmxlLgotICogCi0gKi8KLUBFbnRpdHkKLSNpZiggISR7dGFibGUuZGVmYXVsdG5hbWV9IHx8ICRjdXN0b21pemVyLmdlbmVyYXRlRERMQW5ub3RhdGlvbnMpCi1AVGFibGUobmFtZT0iJHt0YWJsZS5uYW1lfSIpCi0jZW5kCi1wdWJsaWMgY2xhc3MgJHt0YWJsZS5jbGFzc05hbWV9ICR7dGFibGUuZ2VuZXJhdGVFeHRlbmRzSW1wbGVtZW50cygpfSB7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0jIyMjIwotIyMjIyMgZmllbGRzCi0jIyMjIwotI2lmICgkdGFibGUuY29tcG9zaXRlS2V5KQotI2lmICgkdGFibGUuYWNjZXNzID09ICJmaWVsZCIpCi0KLQlARW1iZWRkZWRJZAotI2VuZAotCXByaXZhdGUgJHt0YWJsZS5jb21wb3NpdGVLZXlDbGFzc05hbWV9ICR7dGFibGUuY29tcG9zaXRlS2V5UHJvcGVydHlOYW1lfTsKLSNlbmQKLSNmb3JlYWNoICgkY29sdW1uIGluICR0YWJsZS5nZXRTaW1wbGVDb2x1bW5zKHRydWUsIHRydWUsIGZhbHNlKSkKLSNpZiAoJHRhYmxlLmFjY2VzcyA9PSAiZmllbGQiKQotCi0jcGFyc2UoIm1hcHBpbmdLaW5kLnZtIikKLSNwYXJzZSgiY29sdW1uLnZtIikKLSNlbmQKLQkke2NvbHVtbi5maWVsZFNjb3BlfSAke2NvbHVtbi5wcm9wZXJ0eVR5cGV9ICR7Y29sdW1uLnByb3BlcnR5TmFtZX07Ci0jZW5kCi0jZm9yZWFjaCAoJHJvbGUgaW4gJHRhYmxlLmFzc29jaWF0aW9uUm9sZXMpCi0jIyMjIwotIyMjIyMgZmllbGQgYW5ub3RhdGlvbnMKLSMjIyMjCi0jaWYgKCR0YWJsZS5hY2Nlc3MgPT0gImZpZWxkIikKLQotCS8vJHtyb2xlLmRlc2NyaXB0aW9ufQotI2lmICgkcm9sZS5jYXJkaW5hbGl0eSA9PSAibWFueS10by1vbmUiKQotI3BhcnNlKCJtYW55VG9PbmUudm0iKQotI2Vsc2VpZiAoJHJvbGUuY2FyZGluYWxpdHkgPT0gIm1hbnktdG8tbWFueSIpCi0jcGFyc2UoIm1hbnlUb01hbnkudm0iKQotI2Vsc2VpZiAoJHJvbGUuY2FyZGluYWxpdHkgPT0gIm9uZS10by1tYW55IikKLSNwYXJzZSgib25lVG9NYW55LnZtIikKLSNlbHNlaWYgKCRyb2xlLmNhcmRpbmFsaXR5ID09ICJvbmUtdG8tb25lIikKLSNwYXJzZSgib25lVG9PbmUudm0iKQotI2VuZAotI2VuZAotIyMjIyMKLSMjIyMjIGZpZWxkIGRlY2xhcmF0aW9uCi0jIyMjIwotI2lmICgkcm9sZS5jYXJkaW5hbGl0eSA9PSAibWFueS10by1vbmUiIHx8ICRyb2xlLmNhcmRpbmFsaXR5ID09ICJvbmUtdG8tb25lIikKLSNzZXQgKCRwcm9wZXJ0eVR5cGUgPSAke3JvbGUucmVmZXJlbmNlZFRhYmxlLmNsYXNzTmFtZX0pCi0jZWxzZWlmICgkcm9sZS5jYXJkaW5hbGl0eSA9PSAibWFueS10by1tYW55IiB8fCAkcm9sZS5jYXJkaW5hbGl0eSA9PSAib25lLXRvLW1hbnkiKQotI3NldCAoJHByb3BlcnR5VHlwZSA9ICIke3JvbGUucmVmZXJlbmNlZFRhYmxlLmRlZmF1bHRDb2xsZWN0aW9uVHlwZX08JHtyb2xlLnJlZmVyZW5jZWRUYWJsZS5jbGFzc05hbWV9PiIpCi0jZW5kCi0JcHJpdmF0ZSAkcHJvcGVydHlUeXBlICRyb2xlLnByb3BlcnR5TmFtZTsKLSNlbmQKLQotICAgIHB1YmxpYyAke3RhYmxlLmNsYXNzTmFtZX0oKSB7Ci0gICAgfQotIyMjIyMKLSMjIyMjIHNpbXBsZSBwcm9wZXJ0aWVzIGdldHRlcnMgYW5kIHNldHRlcnMKLSMjIyMjCi0jaWYgKCR0YWJsZS5jb21wb3NpdGVLZXkpCi0jaWYgKCR0YWJsZS5hY2Nlc3MgPT0gInByb3BlcnR5IikKLQotCUBFbWJlZGRlZElkCi0jZW5kCi0JcHVibGljICR0YWJsZS5jb21wb3NpdGVLZXlDbGFzc05hbWUgJGN1c3RvbWl6ZXIucHJvcGVydHlHZXR0ZXIoJHRhYmxlLmNvbXBvc2l0ZUtleVByb3BlcnR5TmFtZSkoKSB7Ci0JCXJldHVybiB0aGlzLiR7dGFibGUuY29tcG9zaXRlS2V5UHJvcGVydHlOYW1lfTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCAkY3VzdG9taXplci5wcm9wZXJ0eVNldHRlcigkdGFibGUuY29tcG9zaXRlS2V5UHJvcGVydHlOYW1lKSgkdGFibGUuY29tcG9zaXRlS2V5Q2xhc3NOYW1lICR0YWJsZS5jb21wb3NpdGVLZXlQcm9wZXJ0eU5hbWUpIHsKLQkJdGhpcy4ke3RhYmxlLmNvbXBvc2l0ZUtleVByb3BlcnR5TmFtZX0gPSAke3RhYmxlLmNvbXBvc2l0ZUtleVByb3BlcnR5TmFtZX07Ci0JfQotCQotI2VuZAotI2ZvcmVhY2ggKCRjb2x1bW4gaW4gJHRhYmxlLmdldFNpbXBsZUNvbHVtbnModHJ1ZSwgdHJ1ZSwgZmFsc2UpKQotI2lmICgkdGFibGUuYWNjZXNzID09ICJwcm9wZXJ0eSIpCi0KLSNwYXJzZSgibWFwcGluZ0tpbmQudm0iKQotI3BhcnNlKCJjb2x1bW4udm0iKQotI2VuZAotCSRjb2x1bW4ucHJvcGVydHlHZXRTY29wZSAkY29sdW1uLnByb3BlcnR5VHlwZSAkY3VzdG9taXplci5wcm9wZXJ0eUdldHRlcigkY29sdW1uLnByb3BlcnR5TmFtZSkoKSB7Ci0JCXJldHVybiB0aGlzLiR7Y29sdW1uLnByb3BlcnR5TmFtZX07Ci0JfQotCi0JJGNvbHVtbi5wcm9wZXJ0eVNldFNjb3BlIHZvaWQgJGN1c3RvbWl6ZXIucHJvcGVydHlTZXR0ZXIoJGNvbHVtbi5wcm9wZXJ0eU5hbWUpKCRjb2x1bW4ucHJvcGVydHlUeXBlICRjb2x1bW4ucHJvcGVydHlOYW1lKSB7Ci0JCXRoaXMuJHtjb2x1bW4ucHJvcGVydHlOYW1lfSA9ICR7Y29sdW1uLnByb3BlcnR5TmFtZX07Ci0JfQotCi0jZW5kCi0jIyMjIwotIyMjIyMgYXNzb2NpYXRpb25zIGdldHRlcnMgYW5kIHNldHRlcnMKLSMjIyMjCi0jZm9yZWFjaCAoJHJvbGUgaW4gJHRhYmxlLmFzc29jaWF0aW9uUm9sZXMpCi0jaWYgKCR0YWJsZS5hY2Nlc3MgPT0gInByb3BlcnR5IikKLQotCS8vJHtyb2xlLmRlc2NyaXB0aW9ufQotI2lmICgkcm9sZS5jYXJkaW5hbGl0eSA9PSAibWFueS10by1vbmUiKQotI3BhcnNlKCJtYW55VG9PbmUudm0iKQotI2Vsc2VpZiAoJHJvbGUuY2FyZGluYWxpdHkgPT0gIm1hbnktdG8tbWFueSIpCi0jcGFyc2UoIm1hbnlUb01hbnkudm0iKQotI2Vsc2VpZiAoJHJvbGUuY2FyZGluYWxpdHkgPT0gIm9uZS10by1tYW55IikKLSNwYXJzZSgib25lVG9NYW55LnZtIikKLSNlbHNlaWYgKCRyb2xlLmNhcmRpbmFsaXR5ID09ICJvbmUtdG8tb25lIikKLSNwYXJzZSgib25lVG9PbmUudm0iKQotI2VuZAotI2VuZAotIyMKLSNpZiAoJHJvbGUuY2FyZGluYWxpdHkgPT0gIm1hbnktdG8tb25lIiB8fCAkcm9sZS5jYXJkaW5hbGl0eSA9PSAib25lLXRvLW9uZSIpCi0jc2V0ICgkcHJvcGVydHlUeXBlID0gJHJvbGUucmVmZXJlbmNlZFRhYmxlLmNsYXNzTmFtZSkKLSNlbHNlaWYgKCRyb2xlLmNhcmRpbmFsaXR5ID09ICJtYW55LXRvLW1hbnkiIHx8ICRyb2xlLmNhcmRpbmFsaXR5ID09ICJvbmUtdG8tbWFueSIpCi0jc2V0ICgkcHJvcGVydHlUeXBlID0gIiR7cm9sZS5yZWZlcmVuY2VkVGFibGUuZGVmYXVsdENvbGxlY3Rpb25UeXBlfTwke3JvbGUucmVmZXJlbmNlZFRhYmxlLmNsYXNzTmFtZX0+IikKLSNlbmQKLQlwdWJsaWMgJHByb3BlcnR5VHlwZSAkY3VzdG9taXplci5wcm9wZXJ0eUdldHRlcigkcm9sZS5wcm9wZXJ0eU5hbWUpKCkgewotCQlyZXR1cm4gdGhpcy4ke3JvbGUucHJvcGVydHlOYW1lfTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCAke2N1c3RvbWl6ZXIucHJvcGVydHlTZXR0ZXIoJHJvbGUucHJvcGVydHlOYW1lKX0oJHByb3BlcnR5VHlwZSAkcm9sZS5wcm9wZXJ0eU5hbWUpIHsKLQkJdGhpcy4ke3JvbGUucHJvcGVydHlOYW1lfSA9ICRyb2xlLnByb3BlcnR5TmFtZTsKLQl9Ci0JCi0jIwotI2VuZAotIyMKLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3RlbXBsYXRlcy9lbnRpdGllcy9tYW55VG9NYW55LnZtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi90ZW1wbGF0ZXMvZW50aXRpZXMvbWFueVRvTWFueS52bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYWZmZWQ2My4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3RlbXBsYXRlcy9lbnRpdGllcy9tYW55VG9NYW55LnZtCisrKyAvZGV2L251bGwKQEAgLTEsMTggKzAsMCBAQAotIyNpbmNsdWRlZCB0ZW1wbGF0ZS4gR2VuZXJhdGVzIHRoZSBATWFueVRvTWFueSBhbm5vdGF0aW9uLgotIyNBc3N1bWVzIHRoYXQgdGhlIGNvbnRleHQgaGFzIGEgInJvbGUiIG9iamVjdCByZXByZXNlbnRpbmcgdGhlIGdlbmVyYXRlZCBBc3NvY2lhdGlvblJvbGUKLSMjCi0jaWYgKCRyb2xlLmFzc29jaWF0aW9uLmJpZGlyZWN0aW9uYWwgJiYgISRyb2xlLmlzUmVmZXJyZXJSb2xlKCkpIyN0aGUgb3duaW5nIHNpZGUgKGVpdGhlciBzaWRlIGZvciBtYW55LXRvLW1hbnkpCi0jc2V0ICgkbWVtYmVycyA9ICRjdXN0b21pemVyLmFwcGVuZEFubm90YXRpb24oIiIsICJtYXBwZWRCeSIsICRyb2xlLm9wcG9zaXRlUm9sZS5wcm9wZXJ0eU5hbWUsIHRydWUpKQotI3NldCAoJG1lbWJlcnMgPSAkY3VzdG9taXplci5hcHBlbmRBbm5vdGF0aW9uKCRtZW1iZXJzLCAiY2FzY2FkZSIsICRjdXN0b21pemVyLmdlbkNhc2NhZGVzKCRyb2xlKSwgZmFsc2UpKQotI2lmKCRjdXN0b21pemVyLmdlbkZldGNoKCRyb2xlLnJlZmVycmVyVGFibGUpIT0iIiAmJiAkY3VzdG9taXplci5nZW5GZXRjaCgkcm9sZS5yZWZlcnJlclRhYmxlKSE9IkZldGNoVHlwZS5MQVpZIikKLSNzZXQgKCRtZW1iZXJzID0gJGN1c3RvbWl6ZXIuYXBwZW5kQW5ub3RhdGlvbigkbWVtYmVycywgImZldGNoIiwgJGN1c3RvbWl6ZXIuZ2VuRmV0Y2goJHJvbGUucmVmZXJyZXJUYWJsZSksIGZhbHNlKSkKLSNlbmQKLQlATWFueVRvTWFueSgkbWVtYmVycykKLSNlbHNlCi0jc2V0ICgkbWVtYmVycyA9ICRjdXN0b21pemVyLmFwcGVuZEFubm90YXRpb24oIiIsICJjYXNjYWRlIiwgJGN1c3RvbWl6ZXIuZ2VuQ2FzY2FkZXMoJHJvbGUpLCBmYWxzZSkpCi0jaWYoJGN1c3RvbWl6ZXIuZ2VuRmV0Y2goJHJvbGUucmVmZXJyZXJUYWJsZSkhPSIiICYmICRjdXN0b21pemVyLmdlbkZldGNoKCRyb2xlLnJlZmVycmVyVGFibGUpIT0iRmV0Y2hUeXBlLkxBWlkiKQotI3NldCAoJG1lbWJlcnMgPSAkY3VzdG9taXplci5hcHBlbmRBbm5vdGF0aW9uKCRtZW1iZXJzLCAiZmV0Y2giLCAkY3VzdG9taXplci5nZW5GZXRjaCgkcm9sZS5yZWZlcnJlclRhYmxlKSwgZmFsc2UpKQotI2VuZAotCUBNYW55VG9NYW55KCRtZW1iZXJzKQotI3BhcnNlKCJqb2luLnZtIikKLSNlbmQKXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3RlbXBsYXRlcy9lbnRpdGllcy9tYW55VG9PbmUudm0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3RlbXBsYXRlcy9lbnRpdGllcy9tYW55VG9PbmUudm0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDdkMjc5YmIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi90ZW1wbGF0ZXMvZW50aXRpZXMvbWFueVRvT25lLnZtCisrKyAvZGV2L251bGwKQEAgLTEsMTMgKzAsMCBAQAotIyNpbmNsdWRlZCB0ZW1wbGF0ZS4gR2VuZXJhdGVzIHRoZSBATWFueVRvT25lIGFubm90YXRpb24uCi0jI0Fzc3VtZXMgdGhhdCB0aGUgY29udGV4dCBoYXMgYSAicm9sZSIgb2JqZWN0IHJlcHJlc2VudGluZyB0aGUgZ2VuZXJhdGVkIEFzc29jaWF0aW9uUm9sZQotIyMKLSNzZXQgKCRtZW1iZXJzID0gJGN1c3RvbWl6ZXIuYXBwZW5kQW5ub3RhdGlvbigiIiwgImNhc2NhZGUiLCAkY3VzdG9taXplci5nZW5DYXNjYWRlcygkcm9sZSksIGZhbHNlKSkKLSNpZiggJGN1c3RvbWl6ZXIuZ2VuRmV0Y2goJHJvbGUucmVmZXJyZXJUYWJsZSkhPSAiIiAmJiAkY3VzdG9taXplci5nZW5GZXRjaCgkcm9sZS5yZWZlcnJlclRhYmxlKSE9ICJGZXRjaFR5cGUuRUFHRVIiKQotI3NldCAoJG1lbWJlcnMgPSAkY3VzdG9taXplci5hcHBlbmRBbm5vdGF0aW9uKCRtZW1iZXJzLCAiZmV0Y2giLCAkY3VzdG9taXplci5nZW5GZXRjaCgkcm9sZS5yZWZlcnJlclRhYmxlKSwgZmFsc2UpKQotI2VuZAotI2lmKCRtZW1iZXJzIT0iIikKLQlATWFueVRvT25lKCRtZW1iZXJzKQotI2Vsc2UKLSAgICBATWFueVRvT25lCi0jZW5kCi0jcGFyc2UoImpvaW4udm0iKQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vdGVtcGxhdGVzL2VudGl0aWVzL21hcHBpbmdLaW5kLnZtIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi90ZW1wbGF0ZXMvZW50aXRpZXMvbWFwcGluZ0tpbmQudm0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGYzNzhjYjIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi90ZW1wbGF0ZXMvZW50aXRpZXMvbWFwcGluZ0tpbmQudm0KKysrIC9kZXYvbnVsbApAQCAtMSwzNCArMCwwIEBACi0jI2luY2x1ZGVkIHRlbXBsYXRlLiBHZW5lcmF0ZXMgdGhlIEBCYXNpYywgQElkLCBAVmVyc2lvbiBhbm5vdGF0aW9ucy4KLSMjQXNzdW1lcyB0aGF0IHRoZSBjb250ZXh0IGhhcyBhICJjb2x1bW4iIG9iamVjdAotIyMKLSNzZXQgKCRtYXBwaW5nS2luZCA9ICRjb2x1bW4ubWFwcGluZ0tpbmQpCi0jaWYgKCRtYXBwaW5nS2luZCA9PSAiaWQiKQotCUBJZAotI3NldCAoJGlkR2VuZXJhdG9yID0gJHRhYmxlLmlkR2VuZXJhdG9yKQotI2lmICgkaWRHZW5lcmF0b3IgPT0gImF1dG8iKQotI3NldCAoJGdlbmVyYXRpb25UeXBlID0gIkdlbmVyYXRpb25UeXBlLkFVVE8iKQotI2Vsc2VpZiAoJGlkR2VuZXJhdG9yID09ICJpZGVudGl0eSIpCi0jc2V0ICgkZ2VuZXJhdGlvblR5cGUgPSAiR2VuZXJhdGlvblR5cGUuSURFTlRJVFkiKQotI2Vsc2VpZiAoJGlkR2VuZXJhdG9yID09ICJzZXF1ZW5jZSIpCi0jc2V0ICgkZ2VuZXJhdGlvblR5cGUgPSAiR2VuZXJhdGlvblR5cGUuU0VRVUVOQ0UiKQotI2Vsc2VpZiAoJGlkR2VuZXJhdG9yID09ICJ0YWJsZSIpCi0jc2V0ICgkZ2VuZXJhdGlvblR5cGUgPSAiR2VuZXJhdGlvblR5cGUuVEFCTEUiKQotI2Vsc2UKLSNzZXQgKCRnZW5lcmF0aW9uVHlwZSA9ICIiKQotI2VuZAotI2lmICgkaWRHZW5lcmF0b3IgPT0gInNlcXVlbmNlIiApCi0jc2V0ICgkZ2VuZXJhdG9yTmFtZSA9ICIke3RhYmxlLm5hbWUudG9VcHBlckNhc2UoKX1fJHtjb2x1bW4ucHJvcGVydHlOYW1lLnRvVXBwZXJDYXNlKCl9X0dFTkVSQVRPUiIpCi0jaWYoICR0YWJsZS5mb3JtYXR0ZWRTZXF1ZW5jZSAhPSAiIiApCi0JQFNlcXVlbmNlR2VuZXJhdG9yKG5hbWU9IiRnZW5lcmF0b3JOYW1lIiwgc2VxdWVuY2VOYW1lPSIkdGFibGUuZm9ybWF0dGVkU2VxdWVuY2UiKQotI2Vsc2UKLQlAU2VxdWVuY2VHZW5lcmF0b3IobmFtZT0iJGdlbmVyYXRvck5hbWUiICkKLSNlbmQJCi0JQEdlbmVyYXRlZFZhbHVlKHN0cmF0ZWd5PSRnZW5lcmF0aW9uVHlwZSwgZ2VuZXJhdG9yPSIkZ2VuZXJhdG9yTmFtZSIpCi0jZWxzZWlmICgkZ2VuZXJhdGlvblR5cGUgIT0gIiIpCi0JQEdlbmVyYXRlZFZhbHVlKHN0cmF0ZWd5PSRnZW5lcmF0aW9uVHlwZSkKLSNlbmQgICAgICAKLSNlbHNlaWYgKCRtYXBwaW5nS2luZCA9PSAidmVyc2lvbiIpCi0JQFZlcnNpb24oKQotI2Vsc2UKLSMjREVGQVVMVCBpcyBAQmFzaWMoKSwgbm8gbmVlZCB0byBnZW5lcmF0ZQotI2VuZApcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vdGVtcGxhdGVzL2VudGl0aWVzL29uZVRvTWFueS52bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vdGVtcGxhdGVzL2VudGl0aWVzL29uZVRvTWFueS52bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDZmMTVjYi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3RlbXBsYXRlcy9lbnRpdGllcy9vbmVUb01hbnkudm0KKysrIC9kZXYvbnVsbApAQCAtMSwxOCArMCwwIEBACi0jI2luY2x1ZGVkIHRlbXBsYXRlLiBHZW5lcmF0ZXMgdGhlIEBPbmVUb01hbnkgYW5ub3RhdGlvbi4KLSMjQXNzdW1lcyB0aGF0IHRoZSBjb250ZXh0IGhhcyBhICJyb2xlIiBvYmplY3QgcmVwcmVzZW50aW5nIHRoZSBnZW5lcmF0ZWQgQXNzb2NpYXRpb25Sb2xlCi0jIwotI2lmICgkcm9sZS5hc3NvY2lhdGlvbi5iaWRpcmVjdGlvbmFsKQotI3NldCAoJG1lbWJlcnMgPSAkY3VzdG9taXplci5hcHBlbmRBbm5vdGF0aW9uKCIiLCAibWFwcGVkQnkiLCAkcm9sZS5vcHBvc2l0ZVJvbGUucHJvcGVydHlOYW1lLCB0cnVlKSkKLSNzZXQgKCRtZW1iZXJzID0gJGN1c3RvbWl6ZXIuYXBwZW5kQW5ub3RhdGlvbigkbWVtYmVycywgImNhc2NhZGUiLCAkY3VzdG9taXplci5nZW5DYXNjYWRlcygkcm9sZSksIGZhbHNlKSkKLSNpZigkY3VzdG9taXplci5nZW5GZXRjaCgkcm9sZS5yZWZlcnJlclRhYmxlKSE9IiIgJiYgJGN1c3RvbWl6ZXIuZ2VuRmV0Y2goJHJvbGUucmVmZXJyZXJUYWJsZSkgIT0iRmV0Y2hUeXBlLkxBWlkiKQotI3NldCAoJG1lbWJlcnMgPSAkY3VzdG9taXplci5hcHBlbmRBbm5vdGF0aW9uKCRtZW1iZXJzLCAiZmV0Y2giLCAkY3VzdG9taXplci5nZW5GZXRjaCgkcm9sZS5yZWZlcnJlclRhYmxlKSwgZmFsc2UpKQotI2VuZAotCUBPbmVUb01hbnkoJG1lbWJlcnMpCi0jZWxzZQotI3NldCAoJG1lbWJlcnMgPSAkY3VzdG9taXplci5hcHBlbmRBbm5vdGF0aW9uKCIiLCAiY2FzY2FkZSIsICRjdXN0b21pemVyLmdlbkNhc2NhZGVzKCRyb2xlKSwgZmFsc2UpKQotI2lmKCRjdXN0b21pemVyLmdlbkZldGNoKCRyb2xlLnJlZmVycmVyVGFibGUpIT0iIiAmJiAkY3VzdG9taXplci5nZW5GZXRjaCgkcm9sZS5yZWZlcnJlclRhYmxlKSAhPSJGZXRjaFR5cGUuTEFaWSIpCi0jc2V0ICgkbWVtYmVycyA9ICRjdXN0b21pemVyLmFwcGVuZEFubm90YXRpb24oJG1lbWJlcnMsICJmZXRjaCIsICRjdXN0b21pemVyLmdlbkZldGNoKCRyb2xlLnJlZmVycmVyVGFibGUpLCBmYWxzZSkpCi0jZW5kCi0JQE9uZVRvTWFueSgkbWVtYmVycykKLSNwYXJzZSgiam9pbi52bSIpCi0jZW5kClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi90ZW1wbGF0ZXMvZW50aXRpZXMvb25lVG9PbmUudm0gYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3RlbXBsYXRlcy9lbnRpdGllcy9vbmVUb09uZS52bQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggN2JkNzUxOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQuZ2VuL3RlbXBsYXRlcy9lbnRpdGllcy9vbmVUb09uZS52bQorKysgL2Rldi9udWxsCkBAIC0xLDIyICswLDAgQEAKLSMjaW5jbHVkZWQgdGVtcGxhdGUuIEdlbmVyYXRlcyB0aGUgQE9uZVRvT25lIGFubm90YXRpb24uCi0jI0Fzc3VtZXMgdGhhdCB0aGUgY29udGV4dCBoYXMgYSAicm9sZSIgb2JqZWN0IHJlcHJlc2VudGluZyB0aGUgZ2VuZXJhdGVkIEFzc29jaWF0aW9uUm9sZQotIyMKLSNpZiAoJHJvbGUuYXNzb2NpYXRpb24uYmlkaXJlY3Rpb25hbCAmJiAhJHJvbGUuaXNSZWZlcnJlclJvbGUoKSkjI3RoZSBvd25pbmcgc2lkZSAoZWl0aGVyIHNpZGUgZm9yIG9uZS10by1vbmUpCi0jc2V0ICgkbWVtYmVycyA9ICRjdXN0b21pemVyLmFwcGVuZEFubm90YXRpb24oIiIsICJtYXBwZWRCeSIsICRyb2xlLm9wcG9zaXRlUm9sZS5wcm9wZXJ0eU5hbWUsIHRydWUpKQotI3NldCAoJG1lbWJlcnMgPSAkY3VzdG9taXplci5hcHBlbmRBbm5vdGF0aW9uKCRtZW1iZXJzLCAiY2FzY2FkZSIsICRjdXN0b21pemVyLmdlbkNhc2NhZGVzKCRyb2xlKSwgZmFsc2UpKQotI2lmKCAkY3VzdG9taXplci5nZW5GZXRjaCgkcm9sZS5yZWZlcnJlclRhYmxlKSE9IiIgJiYgJGN1c3RvbWl6ZXIuZ2VuRmV0Y2goJHJvbGUucmVmZXJyZXJUYWJsZSkhPSJGZXRjaFR5cGUuRUFHRVIiICkKLSNzZXQgKCRtZW1iZXJzID0gJGN1c3RvbWl6ZXIuYXBwZW5kQW5ub3RhdGlvbigkbWVtYmVycywgImZldGNoIiwgJGN1c3RvbWl6ZXIuZ2VuRmV0Y2goJHJvbGUucmVmZXJyZXJUYWJsZSksIGZhbHNlKSkKLSNlbmQKLQlAT25lVG9PbmUoJG1lbWJlcnMpCi0jZWxzZQotI3NldCAoJG1lbWJlcnMgPSAkY3VzdG9taXplci5hcHBlbmRBbm5vdGF0aW9uKCIiLCAiY2FzY2FkZSIsICRjdXN0b21pemVyLmdlbkNhc2NhZGVzKCRyb2xlKSwgZmFsc2UpKQotI2lmKCAkY3VzdG9taXplci5nZW5GZXRjaCgkcm9sZS5yZWZlcnJlclRhYmxlKSE9IiIgJiYgJGN1c3RvbWl6ZXIuZ2VuRmV0Y2goJHJvbGUucmVmZXJyZXJUYWJsZSkhPSJGZXRjaFR5cGUuRUFHRVIiICkKLSNzZXQgKCRtZW1iZXJzID0gJGN1c3RvbWl6ZXIuYXBwZW5kQW5ub3RhdGlvbigkbWVtYmVycywgImZldGNoIiwgJGN1c3RvbWl6ZXIuZ2VuRmV0Y2goJHJvbGUucmVmZXJyZXJUYWJsZSksIGZhbHNlKSkKLSNlbmQKLSNpZigkbWVtYmVycyE9IiIpCi0JQE9uZVRvT25lKCRtZW1iZXJzKQotI2Vsc2UKLQlAT25lVG9PbmUKLSNlbmQKLSNwYXJzZSgiam9pbi52bSIpCi0jZW5kClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi90ZW1wbGF0ZXMvZW50aXRpZXMvcGsuamF2YS52bSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC5nZW4vdGVtcGxhdGVzL2VudGl0aWVzL3BrLmphdmEudm0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDE4MzEwOTguLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0Lmdlbi90ZW1wbGF0ZXMvZW50aXRpZXMvcGsuamF2YS52bQorKysgL2Rldi9udWxsCkBAIC0xLDY2ICswLDAgQEAKLSNpZiAoJHRhYmxlLnBhY2thZ2UgIT0gIiIpCi1wYWNrYWdlICR7dGFibGUucGFja2FnZX07Ci0jZW5kCi0KLWltcG9ydCBqYXZhLmlvLlNlcmlhbGl6YWJsZTsKLWltcG9ydCBqYXZheC5wZXJzaXN0ZW5jZS4qOwotCi0vKioKLSAqIFRoZSBwcmltYXJ5IGtleSBjbGFzcyBmb3IgdGhlICR7dGFibGUubmFtZX0gZGF0YWJhc2UgdGFibGUuCi0gKiAKLSAqLwotQEVtYmVkZGFibGUKLXB1YmxpYyBjbGFzcyAke3RhYmxlLmNvbXBvc2l0ZUtleUNsYXNzTmFtZX0gaW1wbGVtZW50cyBTZXJpYWxpemFibGUgewotCS8vZGVmYXVsdCBzZXJpYWwgdmVyc2lvbiBpZCwgcmVxdWlyZWQgZm9yIHNlcmlhbGl6YWJsZSBjbGFzc2VzLgotCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDFMOwotIyMjIyMKLSMjIyMjIGZpZWxkcwotIyMjIyMKLSNmb3JlYWNoICgkY29sdW1uIGluICR0YWJsZS5wcmltYXJ5S2V5Q29sdW1ucykKLSNpZiAoJHRhYmxlLmFjY2VzcyA9PSAiZmllbGQiKQotCi0jcGFyc2UoImNvbHVtbi52bSIpCi0jZW5kCi0JJHtjb2x1bW4uZmllbGRTY29wZX0gJHtjb2x1bW4ucHJvcGVydHlUeXBlfSAke2NvbHVtbi5wcm9wZXJ0eU5hbWV9OwotI2VuZAotCi0gICAgcHVibGljICR7dGFibGUuY29tcG9zaXRlS2V5Q2xhc3NOYW1lfSgpIHsKLSAgICB9Ci0jIyMjIwotIyMjIyMgc2ltcGxlIHByb3BlcnRpZXMgZ2V0dGVycyBhbmQgc2V0dGVycwotIyMjIyMKLSNmb3JlYWNoICgkY29sdW1uIGluICR0YWJsZS5wcmltYXJ5S2V5Q29sdW1ucykKLSNpZiAoJHRhYmxlLmFjY2VzcyA9PSAicHJvcGVydHkiKQotCi0jcGFyc2UoImNvbHVtbi52bSIpCi0jZW5kCi0JJGNvbHVtbi5wcm9wZXJ0eUdldFNjb3BlICRjb2x1bW4ucHJvcGVydHlUeXBlICRjdXN0b21pemVyLnByb3BlcnR5R2V0dGVyKCRjb2x1bW4ucHJvcGVydHlOYW1lKSgpIHsKLQkJcmV0dXJuIHRoaXMuJHtjb2x1bW4ucHJvcGVydHlOYW1lfTsKLQl9Ci0JJGNvbHVtbi5wcm9wZXJ0eVNldFNjb3BlIHZvaWQgJGN1c3RvbWl6ZXIucHJvcGVydHlTZXR0ZXIoJGNvbHVtbi5wcm9wZXJ0eU5hbWUpKCRjb2x1bW4ucHJvcGVydHlUeXBlICRjb2x1bW4ucHJvcGVydHlOYW1lKSB7Ci0JCXRoaXMuJHtjb2x1bW4ucHJvcGVydHlOYW1lfSA9ICR7Y29sdW1uLnByb3BlcnR5TmFtZX07Ci0JfQotI2VuZAotIyMKLSMjIGVxdWFscy9oYXNoQ29kZQotCi0JcHVibGljIGJvb2xlYW4gZXF1YWxzKE9iamVjdCBvdGhlcikgewotCQlpZiAodGhpcyA9PSBvdGhlcikgewotCQkJcmV0dXJuIHRydWU7Ci0JCX0KLQkJaWYgKCEob3RoZXIgaW5zdGFuY2VvZiAke3RhYmxlLmNvbXBvc2l0ZUtleUNsYXNzTmFtZX0pKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJJHt0YWJsZS5jb21wb3NpdGVLZXlDbGFzc05hbWV9IGNhc3RPdGhlciA9ICgke3RhYmxlLmNvbXBvc2l0ZUtleUNsYXNzTmFtZX0pb3RoZXI7Ci0JCXJldHVybiAKLQkJCSR7dGFibGUucHJpbWFyeUtleUVxdWFsc0NsYXVzZX0KLQotICAgIH0KLSAgICAKLQlwdWJsaWMgaW50IGhhc2hDb2RlKCkgewotCQlmaW5hbCBpbnQgcHJpbWUgPSAzMTsKLQkJaW50IGhhc2ggPSAxNzsKLQkJJHt0YWJsZS5wcmltYXJ5S2V5SGFzaENvZGVDbGF1c2V9Ci0JCXJldHVybiBoYXNoOwotICAgIH0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS8uY2xhc3NwYXRoIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvLmNsYXNzcGF0aApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzA0ZTg2MS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS8uY2xhc3NwYXRoCisrKyAvZGV2L251bGwKQEAgLTEsNyArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPGNsYXNzcGF0aD4KLQk8Y2xhc3NwYXRoZW50cnkga2luZD0ic3JjIiBwYXRoPSJzcmMiLz4KLQk8Y2xhc3NwYXRoZW50cnkga2luZD0iY29uIiBwYXRoPSJvcmcuZWNsaXBzZS5qZHQubGF1bmNoaW5nLkpSRV9DT05UQUlORVIvb3JnLmVjbGlwc2UuamR0LmludGVybmFsLmRlYnVnLnVpLmxhdW5jaGVyLlN0YW5kYXJkVk1UeXBlL0oyU0UtMS41Ii8+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9ImNvbiIgcGF0aD0ib3JnLmVjbGlwc2UucGRlLmNvcmUucmVxdWlyZWRQbHVnaW5zIi8+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9Im91dHB1dCIgcGF0aD0iYmluIi8+Ci08L2NsYXNzcGF0aD4KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5Ly5jdnNpZ25vcmUgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS8uY3ZzaWdub3JlCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhMTI4NjA1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5Ly5jdnNpZ25vcmUKKysrIC9kZXYvbnVsbApAQCAtMSw0ICswLDAgQEAKLWJpbgotQGRvdAotdGVtcC5mb2xkZXIKLWJ1aWxkLnhtbApcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5Ly5wcm9qZWN0IGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvLnByb2plY3QKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDk5YjM4OWIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvLnByb2plY3QKKysrIC9kZXYvbnVsbApAQCAtMSwyOCArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPHByb2plY3REZXNjcmlwdGlvbj4KLQk8bmFtZT5vcmcuZWNsaXBzZS5qcHQudXRpbGl0eTwvbmFtZT4KLQk8Y29tbWVudD48L2NvbW1lbnQ+Ci0JPHByb2plY3RzPgotCTwvcHJvamVjdHM+Ci0JPGJ1aWxkU3BlYz4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLmpkdC5jb3JlLmphdmFidWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5NYW5pZmVzdEJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLlNjaGVtYUJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCTwvYnVpbGRTcGVjPgotCTxuYXR1cmVzPgotCQk8bmF0dXJlPm9yZy5lY2xpcHNlLnBkZS5QbHVnaW5OYXR1cmU8L25hdHVyZT4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5qZHQuY29yZS5qYXZhbmF0dXJlPC9uYXR1cmU+Ci0JPC9uYXR1cmVzPgotPC9wcm9qZWN0RGVzY3JpcHRpb24+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhlNWIyYzIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzCisrKyAvZGV2L251bGwKQEAgLTEsMyArMCwwIEBACi0jVHVlIEphbiAxNSAxMToxMjoyMiBFU1QgMjAwOAotZWNsaXBzZS5wcmVmZXJlbmNlcy52ZXJzaW9uPTEKLWVuY29kaW5nLzxwcm9qZWN0Pj1JU08tODg1OS0xCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuamR0LmNvcmUucHJlZnMgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuamR0LmNvcmUucHJlZnMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQ0MzgyNjAuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvLnNldHRpbmdzL29yZy5lY2xpcHNlLmpkdC5jb3JlLnByZWZzCisrKyAvZGV2L251bGwKQEAgLTEsNyArMCwwIEBACi0jU3VuIE1heSAyNyAxNDo1NTozNyBFRFQgMjAwNwotZWNsaXBzZS5wcmVmZXJlbmNlcy52ZXJzaW9uPTEKLW9yZy5lY2xpcHNlLmpkdC5jb3JlLmNvbXBpbGVyLmNvZGVnZW4udGFyZ2V0UGxhdGZvcm09MS41Ci1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5jb21wbGlhbmNlPTEuNQotb3JnLmVjbGlwc2UuamR0LmNvcmUuY29tcGlsZXIucHJvYmxlbS5hc3NlcnRJZGVudGlmaWVyPWVycm9yCi1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5wcm9ibGVtLmVudW1JZGVudGlmaWVyPWVycm9yCi1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5zb3VyY2U9MS41CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9NRVRBLUlORi9NQU5JRkVTVC5NRiBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L01FVEEtSU5GL01BTklGRVNULk1GCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5ZjFmMDlkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L01FVEEtSU5GL01BTklGRVNULk1GCisrKyAvZGV2L251bGwKQEAgLTEsNjcgKzAsMCBAQAotTWFuaWZlc3QtVmVyc2lvbjogMS4wCi1CdW5kbGUtTWFuaWZlc3RWZXJzaW9uOiAyCi1CdW5kbGUtTmFtZTogJXBsdWdpbk5hbWUKLUJ1bmRsZS1WZW5kb3I6ICVwcm92aWRlck5hbWUKLUJ1bmRsZS1TeW1ib2xpY05hbWU6IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Ci1CdW5kbGUtVmVyc2lvbjogMS4zLjAucXVhbGlmaWVyCi1CdW5kbGUtTG9jYWxpemF0aW9uOiBwbHVnaW4KLUV4cG9ydC1QYWNrYWdlOiBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eSwKLSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLSAgeC1mcmllbmRzOj0ib3JnLmVjbGlwc2UuanB0LmNvcmUsCi0gICBvcmcuZWNsaXBzZS5qcHQuZGIsCi0gICBvcmcuZWNsaXBzZS5qcHQuZGIudWksCi0gICBvcmcuZWNsaXBzZS5qcHQuZ2VuLAotICAgb3JnLmVjbGlwc2UuanB0LnVpIiwKLSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0gIHgtZnJpZW5kczo9Im9yZy5lY2xpcHNlLmpwdC5jb3JlLAotICAgb3JnLmVjbGlwc2UuanB0LmRiLAotICAgb3JnLmVjbGlwc2UuanB0LmRiLnVpLAotICAgb3JnLmVjbGlwc2UuanB0LmdlbiwKLSAgIG9yZy5lY2xpcHNlLmpwdC51aSIsCi0gb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWw7Ci0gIHgtZnJpZW5kczo9Im9yZy5lY2xpcHNlLmpwdC5jb3JlLAotICAgb3JnLmVjbGlwc2UuanB0LmRiLAotICAgb3JnLmVjbGlwc2UuanB0LmRiLnVpLAotICAgb3JnLmVjbGlwc2UuanB0LmdlbiwKLSAgIG9yZy5lY2xpcHNlLmpwdC51aSIsCi0gb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwubGlzdGVuZXIuYXd0OwotICB4LWZyaWVuZHM6PSJvcmcuZWNsaXBzZS5qcHQuY29yZSwKLSAgIG9yZy5lY2xpcHNlLmpwdC5kYiwKLSAgIG9yZy5lY2xpcHNlLmpwdC5kYi51aSwKLSAgIG9yZy5lY2xpcHNlLmpwdC5nZW4sCi0gICBvcmcuZWNsaXBzZS5qcHQudWkiLAotIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotICB4LWZyaWVuZHM6PSJvcmcuZWNsaXBzZS5qcHQuY29yZSwKLSAgIG9yZy5lY2xpcHNlLmpwdC5kYiwKLSAgIG9yZy5lY2xpcHNlLmpwdC5kYi51aSwKLSAgIG9yZy5lY2xpcHNlLmpwdC5nZW4sCi0gICBvcmcuZWNsaXBzZS5qcHQudWkiLAotIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnByZWZzOwotICB4LWZyaWVuZHM6PSJvcmcuZWNsaXBzZS5qcHQuY29yZSwKLSAgIG9yZy5lY2xpcHNlLmpwdC5kYiwKLSAgIG9yZy5lY2xpcHNlLmpwdC5kYi51aSwKLSAgIG9yZy5lY2xpcHNlLmpwdC5nZW4sCi0gICBvcmcuZWNsaXBzZS5qcHQudWkiLAotIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nOwotICB4LWZyaWVuZHM6PSJvcmcuZWNsaXBzZS5qcHQuY29yZSwKLSAgIG9yZy5lY2xpcHNlLmpwdC5kYiwKLSAgIG9yZy5lY2xpcHNlLmpwdC5kYi51aSwKLSAgIG9yZy5lY2xpcHNlLmpwdC5nZW4sCi0gICBvcmcuZWNsaXBzZS5qcHQudWkiLAotIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm5vZGU7Ci0gIHgtZnJpZW5kczo9Im9yZy5lY2xpcHNlLmpwdC5jb3JlLAotICAgb3JnLmVjbGlwc2UuanB0LmRiLAotICAgb3JnLmVjbGlwc2UuanB0LmRiLnVpLAotICAgb3JnLmVjbGlwc2UuanB0LmdlbiwKLSAgIG9yZy5lY2xpcHNlLmpwdC51aSIsCi0gb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuc3dpbmc7Ci0gIHgtZnJpZW5kczo9Im9yZy5lY2xpcHNlLmpwdC5jb3JlLAotICAgb3JnLmVjbGlwc2UuanB0LmRiLAotICAgb3JnLmVjbGlwc2UuanB0LmRiLnVpLAotICAgb3JnLmVjbGlwc2UuanB0LmdlbiwKLSAgIG9yZy5lY2xpcHNlLmpwdC51aSIsCi0gb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwsCi0gb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQsCi0gb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIsCi0gb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUKLUJ1bmRsZS1SZXF1aXJlZEV4ZWN1dGlvbkVudmlyb25tZW50OiBKMlNFLTEuNQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvYWJvdXQuaHRtbCBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L2Fib3V0Lmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJlNTM0YmEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvYWJvdXQuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDM0ICswLDAgQEAKLTwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAvL0VOIj4KLTxIVE1MPgotCi08aGVhZD4KLTx0aXRsZT5BYm91dDwvdGl0bGU+Ci08bWV0YSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9SVNPLTg4NTktMSI+Ci08L2hlYWQ+Ci0KLTxCT0RZIGxhbmc9IkVOLVVTIj4KLQotPEgzPkFib3V0IFRoaXMgQ29udGVudDwvSDM+Ci0KLTxQPk1heSAwMiwgMjAwODwvUD4KLQotPEgzPkxpY2Vuc2U8L0gzPgotCi08UD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBhbGwgY29udGVudCBpbiB0aGlzIHBsdWctaW4gCi0oIkNvbnRlbnQiKS4gVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQgYmVsb3csIHRoZSBDb250ZW50IGlzIHByb3ZpZGVkIHRvIHlvdSAKLXVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAKLSgiRVBMIikuIEEgY29weSBvZiB0aGUgRVBMIGlzIGF2YWlsYWJsZSBhdAotPEEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9vcmcvZG9jdW1lbnRzL2VwbC12MTAucGhwIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL29yZy9kb2N1bWVudHMvZXBsLXYxMC5waHA8L0E+LiAKLUZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAiUHJvZ3JhbSIgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvUD4KLQotPFA+SWYgeW91IGRpZCBub3QgcmVjZWl2ZSB0aGlzIENvbnRlbnQgZGlyZWN0bHkgZnJvbSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uLCB0aGUgCi1Db250ZW50IGlzIGJlaW5nIHJlZGlzdHJpYnV0ZWQgYnkgYW5vdGhlciBwYXJ0eSAoIlJlZGlzdHJpYnV0b3IiKSBhbmQgZGlmZmVyZW50IAotdGVybXMgYW5kIGNvbmRpdGlvbnMgbWF5IGFwcGx5IHRvIHlvdXIgdXNlIG9mIGFueSBvYmplY3QgY29kZSBpbiB0aGUgQ29udGVudC4gCi1DaGVjayB0aGUgUmVkaXN0cmlidXRvcidzIGxpY2Vuc2UgdGhhdCB3YXMgcHJvdmlkZWQgd2l0aCB0aGUgQ29udGVudC4gSWYgbm8gc3VjaCAKLWxpY2Vuc2UgZXhpc3RzLCBjb250YWN0IHRoZSBSZWRpc3RyaWJ1dG9yLiBVbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCBiZWxvdywgdGhlIAotdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVQTCBzdGlsbCBhcHBseSB0byBhbnkgc291cmNlIGNvZGUgaW4gdGhlIENvbnRlbnQgCi1hbmQgc3VjaCBzb3VyY2UgY29kZSBtYXkgYmUgb2J0YWluZWQgYXQKLTxBIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnLzwvQT4uPC9QPgotCi08L0JPRFk+Ci08L0hUTUw+CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9idWlsZC5wcm9wZXJ0aWVzIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMTFhYjhkNC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9idWlsZC5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTcgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSMgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0jIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0jIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi1qYXZhY1NvdXJjZT0xLjUKLWphdmFjVGFyZ2V0PTEuNQotc291cmNlLi4gPSBzcmMvCi1vdXRwdXQuLiA9IGJpbi8KLWJpbi5pbmNsdWRlcyA9IC4sXAotICAgICAgICAgICAgICAgTUVUQS1JTkYvLFwKLSAgICAgICAgICAgICAgIGFib3V0Lmh0bWwsXAotICAgICAgICAgICAgICAgcGx1Z2luLnByb3BlcnRpZXMKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L2NvbXBvbmVudC54bWwgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9jb21wb25lbnQueG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiMjEwYjI4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L2NvbXBvbmVudC54bWwKKysrIC9kZXYvbnVsbApAQCAtMSArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/Pjxjb21wb25lbnQgIHhtbG5zPSJodHRwOi8vZWNsaXBzZS5vcmcvd3RwL3JlbGVuZy90b29scy9jb21wb25lbnQtbW9kZWwiIG5hbWU9Im9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Ij48ZGVzY3JpcHRpb24gdXJsPSIiPjwvZGVzY3JpcHRpb24+PGNvbXBvbmVudC1kZXBlbmRzIHVucmVzdHJpY3RlZD0idHJ1ZSI+PC9jb21wb25lbnQtZGVwZW5kcz48cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5qcHQudXRpbGl0eSIgZnJhZ21lbnQ9ImZhbHNlIi8+PC9jb21wb25lbnQ+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvcGx1Z2luLnByb3BlcnRpZXMgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9wbHVnaW4ucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTVjMDI5ZC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9wbHVnaW4ucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDI0ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNiwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0jIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotIyB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotIyBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotIyBUbyBjb2RlIGRldmVsb3BlcjoKLSMgICBEbyBOT1QgY2hhbmdlIHRoZSBwcm9wZXJ0aWVzIGJldHdlZW4gdGhpcyBsaW5lIGFuZCB0aGUKLSMgICAiJSUlIEVORCBPRiBUUkFOU0xBVEVEIFBST1BFUlRJRVMgJSUlIiBsaW5lLgotIyAgIE1ha2UgYSBuZXcgcHJvcGVydHkgbmFtZSwgYXBwZW5kIHRvIHRoZSBlbmQgb2YgdGhlIGZpbGUgYW5kIGNoYW5nZQotIyAgIHRoZSBjb2RlIHRvIHVzZSB0aGUgbmV3IHByb3BlcnR5LgotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0jICUlJSBFTkQgT0YgVFJBTlNMQVRFRCBQUk9QRVJUSUVTICUlJQotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotCi1wbHVnaW5OYW1lID0gSmF2YSBQZXJzaXN0ZW5jZSBBUEkgVG9vbHMgLSBVdGlsaXR5Ci1wcm92aWRlck5hbWUgPSBFY2xpcHNlLm9yZwotCmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvQ29tbWFuZC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L0NvbW1hbmQuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjBmYmZhZi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvQ29tbWFuZC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eTsKLQotLyoqCi0gKiBTaW1wbGUgaW50ZXJmYWNlIGZvciBpbXBsZW1lbnRpbmcgdGhlIEdPRiBDb21tYW5kIGRlc2lnbiBwYXR0ZXJuLAotICogYW5kIGl0IGRvZXNuJ3QgY2FycnkgdGhlIGJhZ2dhZ2Ugb2YgamF2YS5sYW5nLlJ1bm5hYmxlLgotICogCi0gKiBQcm92aXNpb25hbCBBUEk6IFRoaXMgaW50ZXJmYWNlIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbAotICogdW5kZXIgZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZwotICogc3RhYmlsaXR5LiBJdCBpcyBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20KLSAqIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgdGhpcyBBUEkKLSAqIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KLSAqLwotcHVibGljIGludGVyZmFjZSBDb21tYW5kIHsKLQotCS8qKgotCSAqIEV4ZWN1dGUgdGhlIGNvbW1hbmQuIFRoZSBzZW1hbnRpY3Mgb2YgdGhlIGNvbW1hbmQKLQkgKiBpcyBkZXRlcm1pbmVkIGJ5IHRoZSBjb250cmFjdCBiZXR3ZWVuIHRoZSBjbGllbnQgYW5kIHNlcnZlci4KLQkgKi8KLQl2b2lkIGV4ZWN1dGUoKTsKLQotCS8qKgotCSAqIFNpbmdsZXRvbiBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgY29tbWFuZCBpbnRlcmZhY2UgdGhhdCB3aWxsIGRvIG5vdGhpbmcKLQkgKiB3aGVuIGV4ZWN1dGVkLgotCSAqLwotCWZpbmFsIGNsYXNzIE51bGwgaW1wbGVtZW50cyBDb21tYW5kIHsKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBDb21tYW5kIElOU1RBTkNFID0gbmV3IE51bGwoKTsKLQkJcHVibGljIHN0YXRpYyBDb21tYW5kIGluc3RhbmNlKCkgewotCQkJcmV0dXJuIElOU1RBTkNFOwotCQl9Ci0JCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJcHJpdmF0ZSBOdWxsKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBleGVjdXRlKCkgewotCQkJLy8gZG8gbm90aGluZwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuICJDb21tYW5kLk51bGwiOyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLQkvKioKLQkgKiBTaW5nbGV0b24gaW1wbGVtZW50YXRpb24gb2YgdGhlIGNvbW1hbmQgaW50ZXJmYWNlIHRoYXQgd2lsbCB0aHJvdyBhbgotCSAqIGV4Y2VwdGlvbiB3aGVuIGV4ZWN1dGVkLgotCSAqLwotCWZpbmFsIGNsYXNzIERpc2FibGVkIGltcGxlbWVudHMgQ29tbWFuZCB7Ci0JCXB1YmxpYyBzdGF0aWMgZmluYWwgQ29tbWFuZCBJTlNUQU5DRSA9IG5ldyBEaXNhYmxlZCgpOwotCQlwdWJsaWMgc3RhdGljIENvbW1hbmQgaW5zdGFuY2UoKSB7Ci0JCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCX0KLQkJLy8gZW5zdXJlIHNpbmdsZSBpbnN0YW5jZQotCQlwcml2YXRlIERpc2FibGVkKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQkvLyB0aHJvdyBhbiBleGNlcHRpb24KLQkJcHVibGljIHZvaWQgZXhlY3V0ZSgpIHsKLQkJCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuICJDb21tYW5kLkRpc2FibGVkIjsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvQ29tbWFuZEV4ZWN1dG9yLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvQ29tbWFuZEV4ZWN1dG9yLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGRkZTcxNGEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L0NvbW1hbmRFeGVjdXRvci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eTsKLQotLyoqCi0gKiBUaGlzIGludGVyZmFjZSBhbGxvd3MgY2xpZW50cyB0byBjb250cm9sIGhvdyBhIGNvbW1hbmQgaXMgZXhlY3V0ZWQuCi0gKiBUaGlzIGlzIHVzZWZ1bCB3aGVuIHRoZSBzZXJ2ZXIgcHJvdmlkZXMgdGhlIGNvbW1hbmQgYnV0IHRoZSBjbGllbnQgcHJvdmlkZXMKLSAqIHRoZSBjb250ZXh0IChlLmcuIHRoZSBjbGllbnQgd291bGQgbGlrZSB0byBkaXNwYXRjaCB0aGUgY29tbWFuZCB0byB0aGUgVUkKLSAqIHRocmVhZCkuCi0gKiAKLSAqIFByb3Zpc2lvbmFsIEFQSTogVGhpcyBpbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsCi0gKiB1bmRlciBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nCi0gKiBzdGFiaWxpdHkuIEl0IGlzIGF2YWlsYWJsZSBhdCB0aGlzIGVhcmx5IHN0YWdlIHRvIHNvbGljaXQgZmVlZGJhY2sgZnJvbQotICogcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyB0aGlzIEFQSQotICogd2lsbCBhbG1vc3QgY2VydGFpbmx5IGJlIGJyb2tlbiAocmVwZWF0ZWRseSkgYXMgdGhlIEFQSSBldm9sdmVzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIENvbW1hbmRFeGVjdXRvciB7Ci0KLQkvKioKLQkgKiBFeGVjdXRlIHRoZSBzcGVjaWZpZWQgY29tbWFuZC4KLQkgKi8KLQl2b2lkIGV4ZWN1dGUoQ29tbWFuZCBjb21tYW5kKTsKLQotCi0JLyoqCi0JICogU2luZ2xldG9uIGltcGxlbWVudGF0aW9uIG9mIHRoZSBjb21tYW5kIGV4ZWN1dG9yIGludGVyZmFjZQotCSAqIHRoYXQgc2ltcGx5IGV4ZWN1dGVzIHRoZSBjb21tYW5kIHdpdGhvdXQgYW55IHNvcnQgb2YgZW5oYW5jZW1lbnQuCi0JICovCi0JZmluYWwgY2xhc3MgRGVmYXVsdCBpbXBsZW1lbnRzIENvbW1hbmRFeGVjdXRvciB7Ci0JCXB1YmxpYyBzdGF0aWMgZmluYWwgQ29tbWFuZEV4ZWN1dG9yIElOU1RBTkNFID0gbmV3IERlZmF1bHQoKTsKLQkJcHVibGljIHN0YXRpYyBDb21tYW5kRXhlY3V0b3IgaW5zdGFuY2UoKSB7Ci0JCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCX0KLQkJLy8gZW5zdXJlIHNpbmdsZSBpbnN0YW5jZQotCQlwcml2YXRlIERlZmF1bHQoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGV4ZWN1dGUoQ29tbWFuZCBjb21tYW5kKSB7Ci0JCQljb21tYW5kLmV4ZWN1dGUoKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiQ29tbWFuZEV4ZWN1dG9yLkRlZmF1bHQiOyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9GaWx0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9GaWx0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYTEyODVhNS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvRmlsdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMDYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eTsKLQotLyoqCi0gKiBVc2VkIGJ5IHZhcmlvdXMgInBsdWdnYWJsZSIgY2xhc3NlcyB0byBmaWx0ZXIgb2JqZWN0cy4KLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKi8KLXB1YmxpYyBpbnRlcmZhY2UgRmlsdGVyPFQ+IHsKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgb2JqZWN0IGlzICJhY2NlcHRlZCIgYnkgdGhlCi0JICogZmlsdGVyLiBUaGUgc2VtYW50aWNzIG9mICJhY2NlcHQiIGlzIGRldGVybWluZWQgYnkgdGhlCi0JICogY29udHJhY3QgYmV0d2VlbiB0aGUgY2xpZW50IGFuZCB0aGUgc2VydmVyLgotCSAqLwotCWJvb2xlYW4gYWNjZXB0KFQgbyk7Ci0KLQotCS8qKgotCSAqIFNpbmdsZXRvbiBpbXBsZW1ldGF0aW9uIG9mIHRoZSBmaWx0ZXIgaW50ZXJmYWNlIHRoYXQgYWNjZXB0cyBhbGwgdGhlCi0JICogb2JqZWN0cyAoaS5lLiBpdCBkb2VzIG5vIGZpbHRlcmluZykuCi0JICovCi0JZmluYWwgY2xhc3MgTnVsbDxTPiBpbXBsZW1lbnRzIEZpbHRlcjxTPiB7Ci0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlwdWJsaWMgc3RhdGljIGZpbmFsIEZpbHRlciBJTlNUQU5DRSA9IG5ldyBOdWxsKCk7Ci0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlwdWJsaWMgc3RhdGljIDxSPiBGaWx0ZXI8Uj4gaW5zdGFuY2UoKSB7Ci0JCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCX0KLQkJLy8gZW5zdXJlIHNpbmdsZSBpbnN0YW5jZQotCQlwcml2YXRlIE51bGwoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCS8vIG5vdGhpbmcgaXMgZmlsdGVyZWQgLSBldmVyeXRoaW5nIGlzIGFjY2VwdGVkCi0JCXB1YmxpYyBib29sZWFuIGFjY2VwdChTIG8pIHsKLQkJCXJldHVybiB0cnVlOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuICJGaWx0ZXIuTnVsbCI7ICAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLQkvKioKLQkgKiBTaW5nbGV0b24gaW1wbGVtZXRhdGlvbiBvZiB0aGUgZmlsdGVyIGludGVyZmFjZSB0aGF0IGFjY2VwdHMgbm9uZSBvZiB0aGUKLQkgKiBvYmplY3RzIChpLmUuIGl0IGZpbHRlcnMgb3V0IGFsbCB0aGUgb2JqZWN0cykuCi0JICovCi0JZmluYWwgY2xhc3MgT3BhcXVlPFM+IGltcGxlbWVudHMgRmlsdGVyPFM+IHsKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCXB1YmxpYyBzdGF0aWMgZmluYWwgRmlsdGVyIElOU1RBTkNFID0gbmV3IE9wYXF1ZSgpOwotCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJcHVibGljIHN0YXRpYyA8Uj4gRmlsdGVyPFI+IGluc3RhbmNlKCkgewotCQkJcmV0dXJuIElOU1RBTkNFOwotCQl9Ci0JCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJcHJpdmF0ZSBPcGFxdWUoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCS8vIGV2ZXJ5dGhpbmcgaXMgZmlsdGVyZWQgLSBub3RoaW5nIGlzIGFjY2VwdGVkCi0JCXB1YmxpYyBib29sZWFuIGFjY2VwdChTIG8pIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiRmlsdGVyLk9wYXF1ZSI7ICAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLQkvKioKLQkgKiBTaW5nbGV0b24gaW1wbGVtZXRhdGlvbiBvZiB0aGUgZmlsdGVyIGludGVyZmFjZSB0aGF0IHRocm93cyBhbiBleGNlcHRpb24KLQkgKiBpZiBjYWxsZWQuCi0JICovCi0JZmluYWwgY2xhc3MgRGlzYWJsZWQ8Uz4gaW1wbGVtZW50cyBGaWx0ZXI8Uz4gewotCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBGaWx0ZXIgSU5TVEFOQ0UgPSBuZXcgRGlzYWJsZWQoKTsKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCXB1YmxpYyBzdGF0aWMgPFI+IEZpbHRlcjxSPiBpbnN0YW5jZSgpIHsKLQkJCXJldHVybiBJTlNUQU5DRTsKLQkJfQotCQkvLyBlbnN1cmUgc2luZ2xlIGluc3RhbmNlCi0JCXByaXZhdGUgRGlzYWJsZWQoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCS8vIHRocm93IGFuIGV4Y2VwdGlvbgotCQlwdWJsaWMgYm9vbGVhbiBhY2NlcHQoUyBvKSB7Ci0JCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiRmlsdGVyLkRpc2FibGVkIjsgIC8vJE5PTi1OTFMtMSQKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L0phdmFUeXBlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvSmF2YVR5cGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggY2ZiYTU4ZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvSmF2YVR5cGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEyOCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5OwotCi1pbXBvcnQgamF2YS5pby5QcmludFdyaXRlcjsKLQotLyoqCi0gKiBUaGlzIGludGVyZmFjZSBkZXNjcmliZXMgYSBKYXZhIHR5cGU7IGkuZS4gaXRzICJlbGVtZW50IHR5cGUiCi0gKiBhbmQgaXRzICJhcnJheSBkZXB0aCIuIFRoZSBlbGVtZW50IHR5cGUgaXMgcmVmZXJlbmNlZCBieSBuYW1lLAotICogYWxsb3dpbmcgdXMgdG8gcmVmZXJlbmNlIGNsYXNzZXMgdGhhdCBhcmUgbm90IChvciBjYW5ub3QgYmUpIGxvYWRlZC4KLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKiAKLSAqIFRoaXMgaW50ZXJmYWNlIGlzIG5vdCBpbnRlbmRlZCB0byBiZSBpbXBsZW1lbnRlZCBieSBjbGllbnRzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIEphdmFUeXBlCi0JZXh0ZW5kcyBDb21wYXJhYmxlPEphdmFUeXBlPgotewotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBuYW1lIG9mIHRoZSB0eXBlJ3MgImVsZW1lbnQgdHlwZSIuCi0JICogQSBtZW1iZXIgdHlwZSB3aWxsIGhhdmUgb25lIG9yIG1vcmUgJyQnIGNoYXJhY3RlcnMgaW4gaXRzIG5hbWUuCi0JICovCi0JU3RyaW5nIGdldEVsZW1lbnRUeXBlTmFtZSgpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSB0eXBlJ3MgImFycmF5IGRlcHRoIi4KLQkgKi8KLQlpbnQgZ2V0QXJyYXlEZXB0aCgpOwotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHR5cGUgaXMgYW4gYXJyYXkgKGkuZS4gaXRzICJhcnJheSBkZXB0aCIgaXMgZ3JlYXRlcgotCSAqIHRoYW4gemVybykuCi0JICovCi0JYm9vbGVhbiBpc0FycmF5KCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgdHlwZSBpcyBhICJwcmltaXRpdmUiIChlLmcuICdpbnQnLCAnZmxvYXQnKS4KLQkgKiBOQjogdm9pZC5jbGFzcy5pc1ByaW1pdGl2ZSgpID09IHRydWUKLQkgKi8KLQlib29sZWFuIGlzUHJpbWl0aXZlKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgdHlwZSBpcyBhICJwcmltaXRpdmUiIChlLmcuICdqYXZhLmxhbmcuSW50ZWdlcicsCi0JICogJ2phdmEubGFuZy5GbG9hdCcpLgotCSAqIE5COiB2b2lkLmNsYXNzLmlzUHJpbWl0aXZlKCkgPT0gdHJ1ZQotCSAqLwotCWJvb2xlYW4gaXNQcmltaXRpdmVXcmFwcGVyKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgdHlwZSBpcyBhICJ2YXJpYWJsZSBwcmltaXRpdmUiIChlLmcuICdpbnQnLCAnZmxvYXQnLAotCSAqIGJ1dCBub3QgJ3ZvaWQnKS4KLQkgKiBOQjogdmFyaWFibGVzIGNhbm5vdCBiZSBkZWNsYXJlZCAndm9pZCcKLQkgKi8KLQlib29sZWFuIGlzVmFyaWFibGVQcmltaXRpdmUoKTsKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSB0eXBlIGlzIGEgInZhcmlhYmxlIHByaW1pdGl2ZSIgKGUuZy4KLQkgKiAnamF2YS5sYW5nLkludGVnZXInLCAnamF2YS5sYW5nLkZsb2F0JywgYnV0IG5vdCAnamF2YS5sYW5nLlZvaWQnKS4KLQkgKiBOQjogdmFyaWFibGVzIGNhbm5vdCBiZSBkZWNsYXJlZCAndm9pZCcKLQkgKi8KLQlib29sZWFuIGlzVmFyaWFibGVQcmltaXRpdmVXcmFwcGVyKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNsYXNzIGNvcnJlc3BvbmRpbmcgdG8gdGhlIHR5cGUncyBlbGVtZW50IHR5cGUgYW5kIGFycmF5IGRlcHRoLgotCSAqLwotCUNsYXNzPD8+IGdldEphdmFDbGFzcygpIHRocm93cyBDbGFzc05vdEZvdW5kRXhjZXB0aW9uOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSB2ZXJzaW9uIG9mIHRoZSB0eXBlJ3MgbmFtZSB0aGF0IG1hdGNoZXMgdGhhdAotCSAqIHJldHVybmVkIGJ5IGphdmEubGFuZy5DbGFzcyNnZXROYW1lKCkKLQkgKiAoZS5nLiAiW1tKIiwgIltMamF2YS5sYW5nLk9iamVjdDsiLCAiamF2YS51dGlsLk1hcCRFbnRyeSIpLgotCSAqLwotCVN0cmluZyBnZXRKYXZhQ2xhc3NOYW1lKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgdHlwZSBpcyBlcXVhbCB0byB0aGUgc3BlY2lmaWVkIHR5cGUuCi0JICovCi0JYm9vbGVhbiBlcXVhbHMoU3RyaW5nIG90aGVyRWxlbWVudFR5cGVOYW1lLCBpbnQgb3RoZXJBcnJheURlcHRoKTsKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSB0eXBlIGRlc2NyaWJlcyB0byB0aGUgc3BlY2lmaWVkIHR5cGUuCi0JICovCi0JYm9vbGVhbiBkZXNjcmliZXMoU3RyaW5nIGNsYXNzTmFtZSk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgdHlwZSBkZXNjcmliZXMgdG8gdGhlIHNwZWNpZmllZCB0eXBlLgotCSAqLwotCWJvb2xlYW4gZGVzY3JpYmVzKENsYXNzPD8+IGphdmFDbGFzcyk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgdHlwZSBpcyBlcXVhbCB0byB0aGUgc3BlY2lmaWVkIHR5cGUuCi0JICovCi0JYm9vbGVhbiBlcXVhbHMoSmF2YVR5cGUgb3RoZXIpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSB2ZXJzaW9uIG9mIHRoZSB0eXBlJ3MgbmFtZSB0aGF0IGNhbiBiZSB1c2VkIGluIHNvdXJjZSBjb2RlOgotCSAqICAgICAiW1tKIiA9PiAibG9uZ1tdW10iCi0JICogICAgICJqYXZhLnV0aWwuTWFwJEVudHJ5IiA9PiAiamF2YS51dGlsLk1hcC5FbnRyeSIKLQkgKi8KLQlTdHJpbmcgZGVjbGFyYXRpb24oKTsKLQotCS8qKgotCSAqIEFwcGVuZCB0aGUgdmVyc2lvbiBvZiB0aGUgdHlwZSdzIG5hbWUgdGhhdCBjYW4gYmUgdXNlZCBpbiBzb3VyY2UgY29kZToKLQkgKiAgICAgIltbSiIgPT4gImxvbmdbXVtdIgotCSAqICAgICAiamF2YS51dGlsLk1hcCRFbnRyeSIgPT4gImphdmEudXRpbC5NYXAuRW50cnkiCi0JICovCi0Jdm9pZCBhcHBlbmREZWNsYXJhdGlvblRvKFN0cmluZ0J1aWxkZXIgc2IpOwotCi0JLyoqCi0JICogUHJpbnQgdGhlIHZlcnNpb24gb2YgdGhlIHR5cGUncyBuYW1lIHRoYXQgY2FuIGJlIHVzZWQgaW4gc291cmNlIGNvZGU6Ci0JICogICAgICJbW0oiID0+ICJsb25nW11bXSIKLQkgKiAgICAgImphdmEudXRpbC5NYXAkRW50cnkiID0+ICJqYXZhLnV0aWwuTWFwLkVudHJ5IgotCSAqLwotCXZvaWQgcHJpbnREZWNsYXJhdGlvbk9uKFByaW50V3JpdGVyIHB3KTsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L01ldGhvZFNpZ25hdHVyZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L01ldGhvZFNpZ25hdHVyZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMGFkZmQ5Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9NZXRob2RTaWduYXR1cmUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDc1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHk7Ci0KLWltcG9ydCBqYXZhLmlvLlByaW50V3JpdGVyOwotaW1wb3J0IGphdmEubGFuZy5yZWZsZWN0Lk1ldGhvZDsKLQotLyoqCi0gKiBUaGlzIGludGVyZmFjZSBkZXNjcmliZXMgYSBKYXZhIG1ldGhvZCBzaWduYXR1cmU7IGkuZS4gaXRzICJuYW1lIgotICogYW5kIGl0cyAicGFyYW1ldGVyIHR5cGVzIi4gVGhlIHBhcmFtZXRlciB0eXBlcyBhcmUgcmVmZXJlbmNlZCBieSBuYW1lLAotICogYWxsb3dpbmcgdXMgdG8gcmVmZXJlbmNlIGNsYXNzZXMgdGhhdCBhcmUgbm90IChvciBjYW5ub3QgYmUpIGxvYWRlZC4KLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKiAKLSAqIFRoaXMgaW50ZXJmYWNlIGlzIG5vdCBpbnRlbmRlZCB0byBiZSBpbXBsZW1lbnRlZCBieSBjbGllbnRzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIE1ldGhvZFNpZ25hdHVyZQotCWV4dGVuZHMgQ29tcGFyYWJsZTxNZXRob2RTaWduYXR1cmU+Ci17Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG1ldGhvZCdzIG5hbWUuCi0JICovCi0JU3RyaW5nIGdldE5hbWUoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgbWV0aG9kJ3MgcGFyYW1ldGVyIHR5cGVzLgotCSAqLwotCUphdmFUeXBlW10gZ2V0UGFyYW1ldGVyVHlwZXMoKTsKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBtZXRob2Qgc2lnbmF0dXJlIGRlc2NyaWJlcyB0aGUgc3BlY2lmaWVkIG1ldGhvZC4KLQkgKi8KLQlib29sZWFuIGRlc2NyaWJlcyhNZXRob2QgbWV0aG9kKTsKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBtZXRob2Qgc2lnbmF0dXJlIGVxdWFscyB0aGUgc3BlY2lmaWVkIHNpZ25hdHVyZS4KLQkgKi8KLQlib29sZWFuIGVxdWFscyhTdHJpbmcgb3RoZXJOYW1lLCBKYXZhVHlwZVtdIG90aGVyUGFyYW1ldGVyVHlwZXMpOwotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIG1ldGhvZCBzaWduYXR1cmUgZXF1YWxzIHRoZSBzcGVjaWZpZWQgc2lnbmF0dXJlLgotCSAqLwotCWJvb2xlYW4gZXF1YWxzKE1ldGhvZFNpZ25hdHVyZSBvdGhlcik7Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBzdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgdGhlIG1ldGhvZCdzIHNpZ25hdHVyZToKLQkgKiAgICAgImZvbyhpbnQsIGphdmEubGFuZy5TdHJpbmcpIgotCSAqLwotCVN0cmluZyBnZXRTaWduYXR1cmUoKTsKLQotCS8qKgotCSAqIEFwcGVuZCBhIHN0cmluZyByZXByZXNlbnRhdGlvbiBvZiB0aGUgbWV0aG9kJ3Mgc2lnbmF0dXJlOgotCSAqICAgICAiZm9vKGludCwgamF2YS5sYW5nLlN0cmluZykiCi0JICovCi0Jdm9pZCBhcHBlbmRTaWduYXR1cmVUbyhTdHJpbmdCdWlsZGVyIHNiKTsKLQotCS8qKgotCSAqIFByaW50IGEgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBtZXRob2QncyBzaWduYXR1cmU6Ci0JICogICAgICJmb28oaW50LCBqYXZhLmxhbmcuU3RyaW5nKSIKLQkgKi8KLQl2b2lkIHByaW50U2lnbmF0dXJlT24oUHJpbnRXcml0ZXIgcHcpOwotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvQWJzdHJhY3RBc3NvY2lhdGlvbi5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0Fic3RyYWN0QXNzb2NpYXRpb24uamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmE5ZWIyMS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvQWJzdHJhY3RBc3NvY2lhdGlvbi5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotLyoqCi0gKiBJbXBsZW1lbnQgc29tZSBvZiB0aGUgbWV0aG9kcyBpbiBBc3NvY2lhdGlvbiB0aGF0IGNhbgotICogYmUgZGVmaW5lZCBpbiB0ZXJtcyBvZiB0aGUgb3RoZXIgbWV0aG9kcy4KLSAqLwotcHVibGljIGFic3RyYWN0IGNsYXNzIEFic3RyYWN0QXNzb2NpYXRpb248SywgVj4KLQlpbXBsZW1lbnRzIEFzc29jaWF0aW9uPEssIFY+Ci17Ci0KLQkvKioKLQkgKiBEZWZhdWx0IGNvbnN0cnVjdG9yLgotCSAqLwotCXByb3RlY3RlZCBBYnN0cmFjdEFzc29jaWF0aW9uKCkgewotCQlzdXBlcigpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgYm9vbGVhbiBlcXVhbHMoT2JqZWN0IG8pIHsKLQkJaWYgKCAhIChvIGluc3RhbmNlb2YgQXNzb2NpYXRpb24pKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJQXNzb2NpYXRpb248PywgPz4gb3RoZXIgPSAoQXNzb2NpYXRpb248PywgPz4pIG87Ci0JCXJldHVybiAodGhpcy5rZXkoKSA9PSBudWxsID8KLQkJCQkJb3RoZXIua2V5KCkgPT0gbnVsbCA6IHRoaXMua2V5KCkuZXF1YWxzKG90aGVyLmtleSgpKSkKLQkJCSYmICh0aGlzLnZhbHVlKCkgPT0gbnVsbCA/Ci0JCQkJCW90aGVyLnZhbHVlKCkgPT0gbnVsbCA6IHRoaXMudmFsdWUoKS5lcXVhbHMob3RoZXIudmFsdWUoKSkpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgaW50IGhhc2hDb2RlKCkgewotCQlyZXR1cm4gKHRoaXMua2V5KCkgPT0gbnVsbCA/IDAgOiB0aGlzLmtleSgpLmhhc2hDb2RlKCkpCi0JCQleICh0aGlzLnZhbHVlKCkgPT0gbnVsbCA/IDAgOiB0aGlzLnZhbHVlKCkuaGFzaENvZGUoKSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHN5bmNocm9uaXplZCBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiB0aGlzLmtleSgpICsgIiA9PiAiICsgdGhpcy52YWx1ZSgpOyAvLyROT04tTkxTLTEkCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvQXNzb2NpYXRpb24uamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9Bc3NvY2lhdGlvbi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMzEzMGU4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9Bc3NvY2lhdGlvbi5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotLyoqCi0gKiBTdHJhaWdodGZvcndhcmQgZGVmaW5pdGlvbiBvZiBhbiBvYmplY3QgcGFpcmluZy4KLSAqIFRoZSBrZXkgaXMgaW1tdXRhYmxlLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIEFzc29jaWF0aW9uPEssIFY+IHsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXNzb2NpYXRpb24ncyBrZXkuCi0JICovCi0JSyBrZXkoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXNzb2NpYXRpb24ncyB2YWx1ZS4KLQkgKi8KLQlWIHZhbHVlKCk7Ci0KLQkvKioKLQkgKiBTZXQgdGhlIGFzc29jaWF0aW9uJ3MgdmFsdWUuCi0JICogUmV0dXJuIHRoZSBwcmV2aW91cyB2YWx1ZS4KLQkgKi8KLQlWIHNldFZhbHVlKFYgdmFsdWUpOwotCi0JLyoqCi0JICogUmV0dXJuIHRydWUgaWYgYm90aCB0aGUgYXNzb2NpYXRpb25zJyBrZXlzIGFuZCB2YWx1ZXMKLQkgKiBhcmUgZXF1YWwuCi0JICovCi0JYm9vbGVhbiBlcXVhbHMoT2JqZWN0IG8pOwotCi0JLyoqCi0JICogUmV0dXJuIGEgaGFzaCBjb2RlIGJhc2VkIG9uIHRoZSBhc3NvY2lhdGlvbidzCi0JICoga2V5IGFuZCB2YWx1ZS4KLQkgKi8KLQlpbnQgaGFzaENvZGUoKTsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0JhZy5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0JhZy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiMmM3MjIzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9CYWcuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE4NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsOwotCi1pbXBvcnQgamF2YS5pby5TZXJpYWxpemFibGU7Ci1pbXBvcnQgamF2YS51dGlsLkFic3RyYWN0Q29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkVtcHR5SXRlcmF0b3I7Ci0KLS8qKgotICogQSBjb2xsZWN0aW9uIHRoYXQgYWxsb3dzIGR1cGxpY2F0ZSBlbGVtZW50cy4KLSAqIDxwPgotICogVGhlIDxjb2RlPkJhZzwvY29kZT4gaW50ZXJmYWNlIHBsYWNlcyBhZGRpdGlvbmFsIHN0aXB1bGF0aW9ucywKLSAqIGJleW9uZCB0aG9zZSBpbmhlcml0ZWQgZnJvbSB0aGUgPGNvZGU+amF2YS51dGlsLkNvbGxlY3Rpb248L2NvZGU+IGludGVyZmFjZSwKLSAqIG9uIHRoZSBjb250cmFjdHMgb2YgdGhlIDxjb2RlPmVxdWFsczwvY29kZT4gYW5kIDxjb2RlPmhhc2hDb2RlPC9jb2RlPiBtZXRob2RzLgotICogCi0gKiBAc2VlIEhhc2hCYWcKLSAqLwotCi1wdWJsaWMgaW50ZXJmYWNlIEJhZzxFPiBleHRlbmRzIGphdmEudXRpbC5Db2xsZWN0aW9uPEU+IHsKLQotCS8qKgotCSAqIENvbXBhcmVzIHRoZSBzcGVjaWZpZWQgb2JqZWN0IHdpdGggdGhpcyBiYWcgZm9yIGVxdWFsaXR5LiBSZXR1cm5zCi0JICogPGNvZGU+dHJ1ZTwvY29kZT4gaWYgdGhlIHNwZWNpZmllZCBvYmplY3QgaXMgYWxzbyBhIGJhZywgdGhlIHR3byBiYWdzCi0JICogaGF2ZSB0aGUgc2FtZSBzaXplLCBhbmQgZXZlcnkgbWVtYmVyIG9mIHRoZSBzcGVjaWZpZWQgYmFnIGlzCi0JICogY29udGFpbmVkIGluIHRoaXMgYmFnIHdpdGggdGhlIHNhbWUgbnVtYmVyIG9mIG9jY3VycmVuY2VzIChvciBlcXVpdmFsZW50bHksCi0JICogZXZlcnkgbWVtYmVyIG9mIHRoaXMgYmFnIGlzIGNvbnRhaW5lZCBpbiB0aGUgc3BlY2lmaWVkIGJhZyB3aXRoIHRoZSBzYW1lCi0JICogbnVtYmVyIG9mIG9jY3VycmVuY2VzKS4gVGhpcyBkZWZpbml0aW9uIGVuc3VyZXMgdGhhdCB0aGUKLQkgKiBlcXVhbHMgbWV0aG9kIHdvcmtzIHByb3Blcmx5IGFjcm9zcyBkaWZmZXJlbnQgaW1wbGVtZW50YXRpb25zIG9mIHRoZQotCSAqIGJhZyBpbnRlcmZhY2UuCi0JICovCi0JYm9vbGVhbiBlcXVhbHMoT2JqZWN0IG8pOwotCi0JLyoqCi0JICogUmV0dXJucyB0aGUgaGFzaCBjb2RlIHZhbHVlIGZvciB0aGlzIGJhZy4gVGhlIGhhc2ggY29kZSBvZiBhIGJhZyBpcwotCSAqIGRlZmluZWQgdG8gYmUgdGhlIHN1bSBvZiB0aGUgaGFzaCBjb2RlcyBvZiB0aGUgZWxlbWVudHMgaW4gdGhlIGJhZywKLQkgKiB3aGVyZSB0aGUgaGFzaGNvZGUgb2YgYSA8Y29kZT5udWxsPC9jb2RlPiBlbGVtZW50IGlzIGRlZmluZWQgdG8gYmUgemVyby4KLQkgKiBUaGlzIGVuc3VyZXMgdGhhdCA8Y29kZT5iMS5lcXVhbHMoYjIpPC9jb2RlPiBpbXBsaWVzIHRoYXQKLQkgKiA8Y29kZT5iMS5oYXNoQ29kZSgpID09IGIyLmhhc2hDb2RlKCk8L2NvZGU+IGZvciBhbnkgdHdvIGJhZ3MKLQkgKiA8Y29kZT5iMTwvY29kZT4gYW5kIDxjb2RlPmIyPC9jb2RlPiwgYXMgcmVxdWlyZWQgYnkgdGhlIGdlbmVyYWwKLQkgKiBjb250cmFjdCBvZiB0aGUgPGNvZGU+T2JqZWN0Lmhhc2hDb2RlPC9jb2RlPiBtZXRob2QuCi0JICovCi0JaW50IGhhc2hDb2RlKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG51bWJlciBvZiB0aW1lcyB0aGUgc3BlY2lmaWVkIG9iamVjdCBvY2N1cnMgaW4gdGhlIGJhZy4KLQkgKi8KLQlpbnQgY291bnQoT2JqZWN0IG8pOwotCi0JLyoqCi0JICogQWRkIHRoZSBzcGVjaWZpZWQgb2JqZWN0IHRoZSBzcGVjaWZpZWQgbnVtYmVyIG9mIHRpbWVzIHRvIHRoZSBiYWcuCi0JICovCi0JYm9vbGVhbiBhZGQoRSBvLCBpbnQgY291bnQpOwotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgbnVtYmVyIG9mIG9jY3VycmVuY2VzIG9mIHRoZSBzcGVjaWZpZWQgb2JqZWN0Ci0JICogZnJvbSB0aGUgYmFnLiBSZXR1cm4gd2hldGhlciB0aGUgYmFnIGNoYW5nZWQuCi0JICovCi0JYm9vbGVhbiByZW1vdmUoT2JqZWN0IG8sIGludCBjb3VudCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gYW4gaXRlcmF0b3IgdGhhdCByZXR1cm5zIGVhY2ggaXRlbSBpbiB0aGUgYmFnCi0JICogb25jZSBhbmQgb25seSBvbmNlLCBpcnJlc3BlY3RpdmUgb2YgaG93IG1hbnkgdGltZXMKLQkgKiB0aGUgaXRlbSB3YXMgYWRkZWQgdG8gdGhlIGJhZy4KLQkgKi8KLQlqYXZhLnV0aWwuSXRlcmF0b3I8RT4gdW5pcXVlSXRlcmF0b3IoKTsKLQotCS8qKgotCSAqIFJldHVybiBhbiBpdGVyYXRvciB0aGF0IHJldHVybnMgYW4gZW50cnkgZm9yIGVhY2ggaXRlbSBpbiB0aGUgYmFnCi0JICogb25jZSBhbmQgb25seSBvbmNlLCBpcnJlc3BlY3RpdmUgb2YgaG93IG1hbnkgdGltZXMKLQkgKiB0aGUgaXRlbSB3YXMgYWRkZWQgdG8gdGhlIGJhZy4gVGhlIGVudHJ5IHdpbGwgaW5kaWNhdGUgdGhlIGl0ZW0ncwotCSAqIGNvdW50LgotCSAqLwotCWphdmEudXRpbC5JdGVyYXRvcjxFbnRyeTxFPj4gZW50cmllcygpOwotCi0KLQkvKioKLQkgKiBBIGJhZyBlbnRyeSAoZWxlbWVudC1jb3VudCBwYWlyKS4KLQkgKiBUaGUgPGNvZGU+QmFnLmVudHJpZXM8L2NvZGU+IG1ldGhvZCByZXR1cm5zIGFuIGl0ZXJhdG9yIHdob3NlCi0JICogZWxlbWVudHMgYXJlIG9mIHRoaXMgY2xhc3MuIFRoZSA8aT5vbmx5PC9pPiB3YXkgdG8gb2J0YWluIGEgcmVmZXJlbmNlCi0JICogdG8gYSBiYWcgZW50cnkgaXMgZnJvbSB0aGUgaXRlcmF0b3IgcmV0dXJuZWQgYnkgdGhpcyBtZXRob2QuIFRoZXNlCi0JICogPGNvZGU+QmFnLkVudHJ5PC9jb2RlPiBvYmplY3RzIGFyZSB2YWxpZCA8aT5vbmx5PC9pPiBmb3IgdGhlIGR1cmF0aW9uCi0JICogb2YgdGhlIGl0ZXJhdGlvbjsgbW9yZSBmb3JtYWxseSwgdGhlIGJlaGF2aW9yIG9mIGEgYmFnIGVudHJ5IGlzCi0JICogdW5kZWZpbmVkIGlmIHRoZSBiYWNraW5nIGJhZyBoYXMgYmVlbiBtb2RpZmllZCBhZnRlciB0aGUgZW50cnkgd2FzCi0JICogcmV0dXJuZWQgYnkgdGhlIGl0ZXJhdG9yLCBleGNlcHQgdGhyb3VnaCB0aGUgPGNvZGU+c2V0Q291bnQ8L2NvZGU+Ci0JICogb3BlcmF0aW9uIG9uIHRoZSBiYWcgZW50cnkuCi0JICovCi0JaW50ZXJmYWNlIEVudHJ5PEU+IHsKLQotCQkvKioKLQkJICogUmV0dXJuIHRoZSBlbnRyeSdzIGVsZW1lbnQuCi0JCSAqLwotCQlFIGdldEVsZW1lbnQoKTsKLQotCQkvKioKLQkJICogUmV0dXJuIGVudHJ5J3MgY291bnQ7IGkuZS4gdGhlIG51bWJlciBvZiB0aW1lcyB0aGUgZW50cnkncyBlbGVtZW50Ci0JCSAqIG9jY3VycyBpbiB0aGUgYmFnLgotCQkgKiBAc2VlIEJhZyNjb3VudChPYmplY3QpCi0JCSAqLwotCQlpbnQgZ2V0Q291bnQoKTsKLQotCQkvKioKLQkJICogU2V0IHRoZSBlbnRyeSdzIGNvdW50OyBpLmUuIHRoZSBudW1iZXIgb2YgdGltZXMgdGhlIGVudHJ5J3MgZWxlbWVudAotCQkgKiBvY2N1cnMgaW4gdGhlIGJhZy4gVGhlIG5ldyBjb3VudCBtdXN0IGJlIGEgcG9zaXRpdmUgbnVtYmVyLgotCQkgKiBSZXR1cm4gdGhlIHByZXZpb3VzIGNvdW50IG9mIHRoZSBlbnRyeSdzIGVsZW1lbnQuCi0JCSAqIE5COiBVc2UgdGhlIGl0ZXJhdG9yJ3MgPGNvZGU+cmVtb3ZlPC9jb2RlPiBtZXRob2QgdG8gc2V0IHRoZQotCQkgKiBjb3VudCB0byB6ZXJvLgotCQkgKi8KLQkJaW50IHNldENvdW50KGludCBjb3VudCk7Ci0KLQkJLyoqCi0JCSAqIFJldHVybiB3aGV0aGVyIHRoZSBlbnRyeSBpcyBlcXVhbCB0byB0aGUgc3BlY2lmaWVkIG9iamVjdDsKLQkJICogaS5lLiB0aGUgc3BlY2lmaWVkIG9iamVjdCBpcyBhIDxjb2RlPkJhZy5FbnRyeTwvY29kZT4gYW5kIGl0cwotCQkgKiBlbGVtZW50IGFuZCBjb3VudCBhcmUgdGhlIHNhbWUgYXMgdGhlIGVudHJ5J3MuCi0JCSAqLwotCQlib29sZWFuIGVxdWFscyhPYmplY3Qgb2JqKTsKLQotCQkvKioKLQkJICogUmV0dXJuIHRoZSBlbnRyeSdzIGhhc2ggY29kZS4KLQkJICovCi0JCWludCBoYXNoQ29kZSgpOwotCi0JfQotCi0KLQlmaW5hbCBjbGFzcyBFbXB0eTxFPiBleHRlbmRzIEFic3RyYWN0Q29sbGVjdGlvbjxFPiBpbXBsZW1lbnRzIEJhZzxFPiwgU2VyaWFsaXphYmxlIHsKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCXB1YmxpYyBzdGF0aWMgZmluYWwgQmFnIElOU1RBTkNFID0gbmV3IEVtcHR5KCk7Ci0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlwdWJsaWMgc3RhdGljIDxUPiBCYWc8VD4gaW5zdGFuY2UoKSB7Ci0JCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCX0KLQkJLy8gZW5zdXJlIHNpbmdsZSBpbnN0YW5jZQotCQlwcml2YXRlIEVtcHR5KCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIEl0ZXJhdG9yPEU+IGl0ZXJhdG9yKCkgewotCQkJcmV0dXJuIEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIGludCBzaXplKCkgewotCQkJcmV0dXJuIDA7Ci0JCX0KLQkJcHVibGljIEl0ZXJhdG9yPEU+IHVuaXF1ZUl0ZXJhdG9yKCkgewotCQkJcmV0dXJuIEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQkJfQotCQlwdWJsaWMgaW50IGNvdW50KE9iamVjdCBvKSB7Ci0JCQlyZXR1cm4gMDsKLQkJfQotCQlwdWJsaWMgSXRlcmF0b3I8QmFnLkVudHJ5PEU+PiBlbnRyaWVzKCkgewotCQkJcmV0dXJuIEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQkJfQotCQlwdWJsaWMgYm9vbGVhbiByZW1vdmUoT2JqZWN0IG8sIGludCBjb3VudCkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCXB1YmxpYyBib29sZWFuIGFkZChFIG8sIGludCBjb3VudCkgewotCQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBib29sZWFuIGVxdWFscyhPYmplY3QgbykgewotCQkJaWYgKG8gPT0gdGhpcykgewotCQkJCXJldHVybiB0cnVlOwotCQkJfQotCQkJaWYgKCAhIChvIGluc3RhbmNlb2YgQmFnKSkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJCXJldHVybiAoKEJhZzw/Pikgbykuc2l6ZSgpID09IDA7Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBpbnQgaGFzaENvZGUoKSB7Ci0JCQlyZXR1cm4gMDsKLQkJfQotCQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQkJcHJpdmF0ZSBPYmplY3QgcmVhZFJlc29sdmUoKSB7Ci0JCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9CaWRpRmlsdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvQmlkaUZpbHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlN2JkZjhjLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9CaWRpRmlsdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMDUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LkZpbHRlcjsKLQotLyoqCi0gKiBVc2VkIGJ5IHZhcmlvdXMgInBsdWdnYWJsZSIgY2xhc3NlcyB0byBmaWx0ZXIgb2JqZWN0cwotICogaW4gYm90aCBkaXJlY3Rpb25zLgotICogCi0gKiBJZiBhbnlvbmUgY2FuIGNvbWUgdXAgd2l0aCBhIGJldHRlciBjbGFzcyBuYW1lCi0gKiBhbmQvb3IgbWV0aG9kIG5hbWUsIEkgd291bGQgbG92ZSB0byBoZWFyIGl0LiAgfmJqdgotICovCi1wdWJsaWMgaW50ZXJmYWNlIEJpZGlGaWx0ZXI8VD4gZXh0ZW5kcyBGaWx0ZXI8VD4gewotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBvYmplY3QgaXMgImFjY2VwdGVkIiBieSB0aGUKLQkgKiAicmV2ZXJzZSIgZmlsdGVyLiBXaGF0IHRoYXQgbWVhbnMgaXMgZGV0ZXJtaW5lZCBieSB0aGUgY2xpZW50LgotCSAqLwotCWJvb2xlYW4gcmV2ZXJzZUFjY2VwdChUIG8pOwotCi0KLQlmaW5hbCBjbGFzcyBOdWxsPFM+IGltcGxlbWVudHMgQmlkaUZpbHRlcjxTPiB7Ci0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlwdWJsaWMgc3RhdGljIGZpbmFsIEJpZGlGaWx0ZXIgSU5TVEFOQ0UgPSBuZXcgTnVsbCgpOwotCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJcHVibGljIHN0YXRpYyA8Uj4gQmlkaUZpbHRlcjxSPiBpbnN0YW5jZSgpIHsKLQkJCXJldHVybiBJTlNUQU5DRTsKLQkJfQotCQkvLyBlbnN1cmUgc2luZ2xlIGluc3RhbmNlCi0JCXByaXZhdGUgTnVsbCgpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQkJLy8gbm90aGluZyBpcyBmaWx0ZXJlZCAtIGV2ZXJ5dGhpbmcgaXMgYWNjZXB0ZWQKLQkJcHVibGljIGJvb2xlYW4gYWNjZXB0KFMgbykgewotCQkJcmV0dXJuIHRydWU7Ci0JCX0KLQkJLy8gbm90aGluZyBpcyAicmV2ZXJzZS1maWx0ZXJlZCIgLSBldmVyeXRoaW5nIGlzIGFjY2VwdGVkCi0JCXB1YmxpYyBib29sZWFuIHJldmVyc2VBY2NlcHQoUyBvKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiQmlkaUZpbHRlci5OdWxsIjsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JfQotCi0JZmluYWwgY2xhc3MgT3BhcXVlPFM+IGltcGxlbWVudHMgQmlkaUZpbHRlcjxTPiB7Ci0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlwdWJsaWMgc3RhdGljIGZpbmFsIEJpZGlGaWx0ZXIgSU5TVEFOQ0UgPSBuZXcgT3BhcXVlKCk7Ci0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlwdWJsaWMgc3RhdGljIDxSPiBCaWRpRmlsdGVyPFI+IGluc3RhbmNlKCkgewotCQkJcmV0dXJuIElOU1RBTkNFOwotCQl9Ci0JCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJcHJpdmF0ZSBPcGFxdWUoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCS8vIGV2ZXJ5dGhpbmcgaXMgZmlsdGVyZWQgLSBub3RoaW5nIGlzIGFjY2VwdGVkCi0JCXB1YmxpYyBib29sZWFuIGFjY2VwdChTIG8pIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQkvLyBldmVyeXRoaW5nIGlzICJyZXZlcnNlLWZpbHRlcmVkIiAtIG5vdGhpbmcgaXMgYWNjZXB0ZWQKLQkJcHVibGljIGJvb2xlYW4gcmV2ZXJzZUFjY2VwdChTIG8pIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiQmlkaUZpbHRlci5PcGFxdWUiOyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLQlmaW5hbCBjbGFzcyBEaXNhYmxlZDxTPiBpbXBsZW1lbnRzIEJpZGlGaWx0ZXI8Uz4gewotCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBCaWRpRmlsdGVyIElOU1RBTkNFID0gbmV3IERpc2FibGVkKCk7Ci0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlwdWJsaWMgc3RhdGljIDxSPiBCaWRpRmlsdGVyPFI+IGluc3RhbmNlKCkgewotCQkJcmV0dXJuIElOU1RBTkNFOwotCQl9Ci0JCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJcHJpdmF0ZSBEaXNhYmxlZCgpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQkJLy8gdGhyb3cgYW4gZXhjZXB0aW9uCi0JCXB1YmxpYyBib29sZWFuIGFjY2VwdChTIG8pIHsKLQkJCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCQl9Ci0JCS8vIHRocm93IGFuIGV4Y2VwdGlvbgotCQlwdWJsaWMgYm9vbGVhbiByZXZlcnNlQWNjZXB0KFMgbykgewotCQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gIkJpZGlGaWx0ZXIuRGlzYWJsZWQiOyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9CaWRpU3RyaW5nQ29udmVydGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvQmlkaVN0cmluZ0NvbnZlcnRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1ZDIyNTlkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9CaWRpU3RyaW5nQ29udmVydGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMjcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotLyoqCi0gKiBVc2VkIGJ5IHZhcmlvdXMgInBsdWdnYWJsZSIgY2xhc3NlcyB0byB0cmFuc2Zvcm0gb2JqZWN0cwotICogaW50byBzdHJpbmdzIGFuZCB2aWNlIHZlcnNhLgotICogCi0gKiBJZiBhbnlvbmUgY2FuIGNvbWUgdXAgd2l0aCBhIGJldHRlciBjbGFzcyBuYW1lCi0gKiBhbmQvb3IgbWV0aG9kIG5hbWUsIEkgd291bGQgbG92ZSB0byBoZWFyIGl0LiAgfmJqdgotICovCi1wdWJsaWMgaW50ZXJmYWNlIEJpZGlTdHJpbmdDb252ZXJ0ZXI8VD4gZXh0ZW5kcyBTdHJpbmdDb252ZXJ0ZXI8VD4gewotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkIHN0cmluZyBpbnRvIGFuIG9iamVjdC4KLQkgKiBUaGUgc2VtYW50aWNzIG9mICJjb252ZXJ0IHRvIG9iamVjdCIgaXMgZGV0ZXJtaW5lZCBieSB0aGUKLQkgKiBjb250cmFjdCBiZXR3ZWVuIHRoZSBjbGllbnQgYW5kIHRoZSBzZXJ2ZXIuCi0JICogVHlwaWNhbGx5LCBpZiB0aGUgc3RyaW5nIGlzIG51bGwsIG51bGwgaXMgcmV0dXJuZWQuCi0JICovCi0JVCBjb252ZXJ0VG9PYmplY3QoU3RyaW5nIHMpOwotCi0KLQlmaW5hbCBjbGFzcyBEZWZhdWx0PFM+IGltcGxlbWVudHMgQmlkaVN0cmluZ0NvbnZlcnRlcjxTPiB7Ci0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlwdWJsaWMgc3RhdGljIGZpbmFsIEJpZGlTdHJpbmdDb252ZXJ0ZXIgSU5TVEFOQ0UgPSBuZXcgRGVmYXVsdCgpOwotCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJcHVibGljIHN0YXRpYyA8Uj4gQmlkaVN0cmluZ0NvbnZlcnRlcjxSPiBpbnN0YW5jZSgpIHsKLQkJCXJldHVybiBJTlNUQU5DRTsKLQkJfQotCQkvLyBlbnN1cmUgc2luZ2xlIGluc3RhbmNlCi0JCXByaXZhdGUgRGVmYXVsdCgpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQkJLy8gc2ltcGx5IHJldHVybiB0aGUgb2JqZWN0J3MgI3RvU3RyaW5nKCkgcmVzdWx0Ci0JCXB1YmxpYyBTdHJpbmcgY29udmVydFRvU3RyaW5nKFMgbykgewotCQkJcmV0dXJuIChvID09IG51bGwpID8gbnVsbCA6IG8udG9TdHJpbmcoKTsKLQkJfQotCQkvLyBzaW1wbHkgcmV0dXJuIHRoZSBzdHJpbmcKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCXB1YmxpYyBTIGNvbnZlcnRUb09iamVjdChTdHJpbmcgcykgewotCQkJcmV0dXJuIChTKSBzOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuICJCaWRpU3RyaW5nQ29udmVydGVyLkRlZmF1bHQiOyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLQlmaW5hbCBjbGFzcyBEaXNhYmxlZDxTPiBpbXBsZW1lbnRzIEJpZGlTdHJpbmdDb252ZXJ0ZXI8Uz4gewotCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBCaWRpU3RyaW5nQ29udmVydGVyIElOU1RBTkNFID0gbmV3IERpc2FibGVkKCk7Ci0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlwdWJsaWMgc3RhdGljIDxSPiBCaWRpU3RyaW5nQ29udmVydGVyPFI+IGluc3RhbmNlKCkgewotCQkJcmV0dXJuIElOU1RBTkNFOwotCQl9Ci0JCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJcHJpdmF0ZSBEaXNhYmxlZCgpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQkJLy8gdGhyb3cgYW4gZXhjZXB0aW9uCi0JCXB1YmxpYyBTdHJpbmcgY29udmVydFRvU3RyaW5nKFMgbykgewotCQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JCX0KLQkJLy8gdGhyb3cgYW4gZXhjZXB0aW9uCi0JCXB1YmxpYyBTIGNvbnZlcnRUb09iamVjdChTdHJpbmcgcykgewotCQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gIkJpZGlTdHJpbmdDb252ZXJ0ZXIuRGlzYWJsZWQiOyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLQlmaW5hbCBjbGFzcyBCb29sZWFuQ29udmVydGVyIGltcGxlbWVudHMgQmlkaVN0cmluZ0NvbnZlcnRlcjxCb29sZWFuPiB7Ci0JCXB1YmxpYyBzdGF0aWMgZmluYWwgQmlkaVN0cmluZ0NvbnZlcnRlcjxCb29sZWFuPiBJTlNUQU5DRSA9IG5ldyBCb29sZWFuQ29udmVydGVyKCk7Ci0JCXB1YmxpYyBzdGF0aWMgQmlkaVN0cmluZ0NvbnZlcnRlcjxCb29sZWFuPiBpbnN0YW5jZSgpIHsKLQkJCXJldHVybiBJTlNUQU5DRTsKLQkJfQotCQkvLyBlbnN1cmUgc2luZ2xlIGluc3RhbmNlCi0JCXByaXZhdGUgQm9vbGVhbkNvbnZlcnRlcigpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQkJLyoqIFJldHVybiAidHJ1ZSIgaWYgdGhlIEJvb2xlYW4gaXMgdHJ1ZSwgb3RoZXJ3aXNlIHJldHVybiAiZmFsc2UiLiAqLwotCQlwdWJsaWMgU3RyaW5nIGNvbnZlcnRUb1N0cmluZyhCb29sZWFuIGIpIHsKLQkJCXJldHVybiAoYiA9PSBudWxsKSA/IG51bGwgOiBiLnRvU3RyaW5nKCk7Ci0JCX0KLQkJLyoqIFJldHVybiBCb29sZWFuLlRSVUUgaWYgdGhlIHN0cmluZyBpcyAidHJ1ZSIgKGNhc2UtaW5zZW5zaXRpdmUpLCBvdGhlcndpc2UgcmV0dXJuIEJvb2xlYW4uRkFMU0UuICovCi0JCXB1YmxpYyBCb29sZWFuIGNvbnZlcnRUb09iamVjdChTdHJpbmcgcykgewotCQkJcmV0dXJuIChzID09IG51bGwpID8gbnVsbCA6IEJvb2xlYW4udmFsdWVPZihzKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiQmlkaVN0cmluZ0NvbnZlcnRlci5Cb29sZWFuQ29udmVydGVyIjsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JfQotCi0JZmluYWwgY2xhc3MgSW50ZWdlckNvbnZlcnRlciBpbXBsZW1lbnRzIEJpZGlTdHJpbmdDb252ZXJ0ZXI8SW50ZWdlcj4gewotCQlwdWJsaWMgc3RhdGljIGZpbmFsIEJpZGlTdHJpbmdDb252ZXJ0ZXI8SW50ZWdlcj4gSU5TVEFOQ0UgPSBuZXcgSW50ZWdlckNvbnZlcnRlcigpOwotCQlwdWJsaWMgc3RhdGljIEJpZGlTdHJpbmdDb252ZXJ0ZXI8SW50ZWdlcj4gaW5zdGFuY2UoKSB7Ci0JCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCX0KLQkJLy8gZW5zdXJlIHNpbmdsZSBpbnN0YW5jZQotCQlwcml2YXRlIEludGVnZXJDb252ZXJ0ZXIoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCS8qKiBJbnRlZ2VyJ3MgI3RvU3RyaW5nKCkgd29ya3Mgd2VsbC4gKi8KLQkJcHVibGljIFN0cmluZyBjb252ZXJ0VG9TdHJpbmcoSW50ZWdlciBpbnRlZ2VyKSB7Ci0JCQlyZXR1cm4gKGludGVnZXIgPT0gbnVsbCkgPyBudWxsIDogaW50ZWdlci50b1N0cmluZygpOwotCQl9Ci0JCS8qKiBDb252ZXJ0IHRoZSBzdHJpbmcgdG8gYW4gSW50ZWdlciwgaWYgcG9zc2libGUuICovCi0JCXB1YmxpYyBJbnRlZ2VyIGNvbnZlcnRUb09iamVjdChTdHJpbmcgcykgewotCQkJcmV0dXJuIChzID09IG51bGwpID8gbnVsbCA6IEludGVnZXIudmFsdWVPZihzKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiQmlkaVN0cmluZ0NvbnZlcnRlci5JbnRlZ2VyQ29udmVydGVyIjsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvQmlkaVRyYW5zZm9ybWVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvQmlkaVRyYW5zZm9ybWVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDgwMTYxYmMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0JpZGlUcmFuc2Zvcm1lci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotLyoqCi0gKiBVc2VkIGJ5IHZhcmlvdXMgInBsdWdnYWJsZSIgY2xhc3NlcyB0byB0cmFuc2Zvcm0gb2JqZWN0cwotICogaW4gYm90aCBkaXJlY3Rpb25zLgotICogCi0gKiBJZiBhbnlvbmUgY2FuIGNvbWUgdXAgd2l0aCBhIGJldHRlciBjbGFzcyBuYW1lCi0gKiBhbmQvb3IgbWV0aG9kIG5hbWUsIEkgd291bGQgbG92ZSB0byBoZWFyIGl0LiAgfmJqdgotICovCi1wdWJsaWMgaW50ZXJmYWNlIEJpZGlUcmFuc2Zvcm1lcjxUMSwgVDI+IGV4dGVuZHMgVHJhbnNmb3JtZXI8VDEsIFQyPiB7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlICJyZXZlcnNlLXRyYW5zZm9ybWVkIiBvYmplY3QuCi0JICogVGhlIHNlbWFudGljcyBvZiAicmV2ZXJzZS10cmFuc2Zvcm0iIGlzIGRldGVybWluZWQgYnkgdGhlCi0JICogY29udHJhY3QgYmV0d2VlbiB0aGUgY2xpZW50IGFuZCB0aGUgc2VydmVyLgotCSAqLwotCVQxIHJldmVyc2VUcmFuc2Zvcm0oVDIgbyk7Ci0KLQotCWZpbmFsIGNsYXNzIE51bGw8UzEsIFMyPiBpbXBsZW1lbnRzIEJpZGlUcmFuc2Zvcm1lcjxTMSwgUzI+IHsKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCXB1YmxpYyBzdGF0aWMgZmluYWwgQmlkaVRyYW5zZm9ybWVyIElOU1RBTkNFID0gbmV3IE51bGwoKTsKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCXB1YmxpYyBzdGF0aWMgPFIxLCBSMj4gQmlkaVRyYW5zZm9ybWVyPFIxLCBSMj4gaW5zdGFuY2UoKSB7Ci0JCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCX0KLQkJLy8gZW5zdXJlIHNpbmdsZSBpbnN0YW5jZQotCQlwcml2YXRlIE51bGwoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCS8vIHNpbXBseSByZXR1cm4gdGhlIG9iamVjdCwgdW5jaGFuZ2VkCi0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlwdWJsaWMgUzIgdHJhbnNmb3JtKFMxIG8pIHsKLQkJCXJldHVybiAoUzIpIG87Ci0JCX0KLQkJLy8gc2ltcGx5IHJldHVybiB0aGUgb2JqZWN0LCB1bmNoYW5nZWQKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCXB1YmxpYyBTMSByZXZlcnNlVHJhbnNmb3JtKFMyIG8pIHsKLQkJCXJldHVybiAoUzEpIG87Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gIkJpZGlUcmFuc2Zvcm1lci5OdWxsIjsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JfQotCi0JZmluYWwgY2xhc3MgRGlzYWJsZWQ8UzEsIFMyPiBpbXBsZW1lbnRzIEJpZGlUcmFuc2Zvcm1lcjxTMSwgUzI+IHsKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCXB1YmxpYyBzdGF0aWMgZmluYWwgQmlkaVRyYW5zZm9ybWVyIElOU1RBTkNFID0gbmV3IERpc2FibGVkKCk7Ci0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlwdWJsaWMgc3RhdGljIDxSMSwgUjI+IEJpZGlUcmFuc2Zvcm1lcjxSMSwgUjI+IGluc3RhbmNlKCkgewotCQkJcmV0dXJuIElOU1RBTkNFOwotCQl9Ci0JCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJcHJpdmF0ZSBEaXNhYmxlZCgpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQkJLy8gdGhyb3cgYW4gZXhjZXB0aW9uCi0JCXB1YmxpYyBTMiB0cmFuc2Zvcm0oUzEgbykgewotCQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JCX0KLQkJLy8gdGhyb3cgYW4gZXhjZXB0aW9uCi0JCXB1YmxpYyBTMSByZXZlcnNlVHJhbnNmb3JtKFMyIG8pIHsKLQkJCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuICJCaWRpVHJhbnNmb3JtZXIuRGlzYWJsZWQiOyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9CaXRUb29scy5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0JpdFRvb2xzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDU0NGY1YmIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0JpdFRvb2xzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyMTQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotLyoqCi0gKiBBc3NvcnRlZCBiaXQgdG9vbHMKLSAqLwotcHVibGljIGNsYXNzIEJpdFRvb2xzIHsKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgJ2ZsYWdzJyBoYXMgdGhlIHNwZWNpZmllZAotCSAqICdmbGFnVG9DaGVjaycgc2V0LgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBmbGFnSXNTZXQoaW50IGZsYWdzLCBpbnQgZmxhZ1RvQ2hlY2spIHsKLQkJcmV0dXJuIGFsbEZsYWdzQXJlU2V0KGZsYWdzLCBmbGFnVG9DaGVjayk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCAnZmxhZ3MnIGhhcyB0aGUgc3BlY2lmaWVkCi0JICogJ2ZsYWdUb0NoZWNrJyB0dXJuZWQgb2ZmLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBmbGFnSXNPZmYoaW50IGZsYWdzLCBpbnQgZmxhZ1RvQ2hlY2spIHsKLQkJcmV0dXJuIGFsbEZsYWdzQXJlT2ZmKGZsYWdzLCBmbGFnVG9DaGVjayk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCAnZmxhZ3MnIGhhcyBPTkxZIHRoZSBzcGVjaWZpZWQKLQkgKiAnZmxhZ1RvQ2hlY2snIHNldC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gb25seUZsYWdJc1NldChpbnQgZmxhZ3MsIGludCBmbGFnVG9DaGVjaykgewotCQlyZXR1cm4gb25seUZsYWdzQXJlU2V0KGZsYWdzLCBmbGFnVG9DaGVjayk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCAnZmxhZ3MnIGhhcyBPTkxZIHRoZSBzcGVjaWZpZWQKLQkgKiAnZmxhZ1RvQ2hlY2snIHR1cm5lZCBvZmYuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIG9ubHlGbGFnSXNPZmYoaW50IGZsYWdzLCBpbnQgZmxhZ1RvQ2hlY2spIHsKLQkJcmV0dXJuIG9ubHlGbGFnc0FyZU9mZihmbGFncywgZmxhZ1RvQ2hlY2spOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgJ2ZsYWdzJyBoYXMgYWxsIHRoZSBzcGVjaWZpZWQKLQkgKiAnZmxhZ3NUb0NoZWNrJyBzZXQuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGFsbEZsYWdzQXJlU2V0KGludCBmbGFncywgaW50IGZsYWdzVG9DaGVjaykgewotCQlyZXR1cm4gKGZsYWdzICYgZmxhZ3NUb0NoZWNrKSA9PSBmbGFnc1RvQ2hlY2s7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCAnZmxhZ3MnIGhhcyBhbGwgdGhlIHNwZWNpZmllZAotCSAqICdmbGFnc1RvQ2hlY2snIHR1cm5lZCBvZmYuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGFsbEZsYWdzQXJlT2ZmKGludCBmbGFncywgaW50IGZsYWdzVG9DaGVjaykgewotCQlyZXR1cm4gKGZsYWdzICYgZmxhZ3NUb0NoZWNrKSA9PSAwOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgJ2ZsYWdzJyBoYXMgT05MWSB0aGUgc3BlY2lmaWVkCi0JICogJ2ZsYWdzVG9DaGVjaycgc2V0LgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBvbmx5RmxhZ3NBcmVTZXQoaW50IGZsYWdzLCBpbnQgZmxhZ3NUb0NoZWNrKSB7Ci0JCXJldHVybiBhbGxGbGFnc0FyZVNldChmbGFncywgZmxhZ3NUb0NoZWNrKSAmJiBhbGxGbGFnc0FyZU9mZihmbGFncywgfmZsYWdzVG9DaGVjayk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCAnZmxhZ3MnIGhhcyBPTkxZIHRoZSBzcGVjaWZpZWQKLQkgKiAnZmxhZ3NUb0NoZWNrJyB0dXJuZWQgb2ZmLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBvbmx5RmxhZ3NBcmVPZmYoaW50IGZsYWdzLCBpbnQgZmxhZ3NUb0NoZWNrKSB7Ci0JCXJldHVybiBhbGxGbGFnc0FyZU9mZihmbGFncywgZmxhZ3NUb0NoZWNrKSAmJiBhbGxGbGFnc0FyZVNldChmbGFncywgfmZsYWdzVG9DaGVjayk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCAnZmxhZ3MnIGhhcyBhbnkgb25lIG9mIHRoZSBzcGVjaWZpZWQKLQkgKiAnZmxhZ3NUb0NoZWNrJyBzZXQuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGFueUZsYWdzQXJlU2V0KGludCBmbGFncywgaW50IGZsYWdzVG9DaGVjaykgewotCQlyZXR1cm4gKGZsYWdzICYgZmxhZ3NUb0NoZWNrKSAhPSAwOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgJ2ZsYWdzJyBoYXMgYW55IG9uZSBvZiB0aGUgc3BlY2lmaWVkCi0JICogJ2ZsYWdzVG9DaGVjaycgdHVybmVkIG9mZi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gYW55RmxhZ3NBcmVPZmYoaW50IGZsYWdzLCBpbnQgZmxhZ3NUb0NoZWNrKSB7Ci0JCXJldHVybiAoZmxhZ3MgJiBmbGFnc1RvQ2hlY2spICE9IGZsYWdzVG9DaGVjazsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkICdmbGFncycgaGFzIGFsbCB0aGUgc3BlY2lmaWVkCi0JICogJ2ZsYWdzVG9DaGVjaycgc2V0LgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBhbGxGbGFnc0FyZVNldChpbnQgZmxhZ3MsIGludFtdIGZsYWdzVG9DaGVjaykgewotCQlmb3IgKGludCBpID0gZmxhZ3NUb0NoZWNrLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlpZiAoICEgYWxsRmxhZ3NBcmVTZXQoZmxhZ3MsIGZsYWdzVG9DaGVja1tpXSkpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCAnZmxhZ3MnIGhhcyBhbGwgdGhlIHNwZWNpZmllZAotCSAqICdmbGFnc1RvQ2hlY2snIHR1cm5lZCBvZmYuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGFsbEZsYWdzQXJlT2ZmKGludCBmbGFncywgaW50W10gZmxhZ3NUb0NoZWNrKSB7Ci0JCWZvciAoaW50IGkgPSBmbGFnc1RvQ2hlY2subGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCWlmICggISBhbGxGbGFnc0FyZU9mZihmbGFncywgZmxhZ3NUb0NoZWNrW2ldKSkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkICdmbGFncycgaGFzIE9OTFkgdGhlIHNwZWNpZmllZAotCSAqICdmbGFnc1RvQ2hlY2snIHNldC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gb25seUZsYWdzQXJlU2V0KGludCBmbGFncywgaW50W10gZmxhZ3NUb0NoZWNrKSB7Ci0JCWludCBjb21iaW5lZEZsYWdzID0gb3JGbGFncyhmbGFnc1RvQ2hlY2spOwotCQlyZXR1cm4gYWxsRmxhZ3NBcmVTZXQoZmxhZ3MsIGNvbWJpbmVkRmxhZ3MpICYmIGFsbEZsYWdzQXJlT2ZmKGZsYWdzLCB+Y29tYmluZWRGbGFncyk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCAnZmxhZ3MnIGhhcyBPTkxZIHRoZSBzcGVjaWZpZWQKLQkgKiAnZmxhZ3NUb0NoZWNrJyB0dXJuZWQgb2ZmLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBvbmx5RmxhZ3NBcmVPZmYoaW50IGZsYWdzLCBpbnRbXSBmbGFnc1RvQ2hlY2spIHsKLQkJaW50IGNvbWJpbmVkRmxhZ3MgPSBvckZsYWdzKGZsYWdzVG9DaGVjayk7Ci0JCXJldHVybiBhbGxGbGFnc0FyZU9mZihmbGFncywgY29tYmluZWRGbGFncykgJiYgYWxsRmxhZ3NBcmVTZXQoZmxhZ3MsIH5jb21iaW5lZEZsYWdzKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkICdmbGFncycgaGFzIGFueSBvbmUgb2YgdGhlIHNwZWNpZmllZAotCSAqICdmbGFnc1RvQ2hlY2snIHNldC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gYW55RmxhZ3NBcmVTZXQoaW50IGZsYWdzLCBpbnRbXSBmbGFnc1RvQ2hlY2spIHsKLQkJZm9yIChpbnQgaSA9IGZsYWdzVG9DaGVjay5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJaWYgKGFueUZsYWdzQXJlU2V0KGZsYWdzLCBmbGFnc1RvQ2hlY2tbaV0pKSB7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgJ2ZsYWdzJyBoYXMgYW55IG9uZSBvZiB0aGUgc3BlY2lmaWVkCi0JICogJ2ZsYWdzVG9DaGVjaycgdHVybmVkIG9mZi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gYW55RmxhZ3NBcmVPZmYoaW50IGZsYWdzLCBpbnRbXSBmbGFnc1RvQ2hlY2spIHsKLQkJZm9yIChpbnQgaSA9IGZsYWdzVG9DaGVjay5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJaWYgKGFueUZsYWdzQXJlT2ZmKGZsYWdzLCBmbGFnc1RvQ2hlY2tbaV0pKSB7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCS8qKgotCSAqIE9SIGFsbCB0aGUgc3BlY2lmaWVkICdmbGFncycgdG9nZXRoZXIgYW5kIHJldHVybiB0aGUgcmVzdWx0LgotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50IG9yRmxhZ3MoaW50W10gZmxhZ3MpIHsKLQkJaW50IGxhc3QgPSBmbGFncy5sZW5ndGggLSAxOwotCQlpbnQgcmVzdWx0ID0gZmxhZ3NbbGFzdF07Ci0JCWZvciAoaW50IGkgPSBsYXN0OyBpLS0gPiAwOyApIHsKLQkJCXJlc3VsdCB8PSBmbGFnc1tpXTsKLQkJfQotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIEFORCBhbGwgdGhlIHNwZWNpZmllZCAnZmxhZ3MnIHRvZ2V0aGVyIGFuZCByZXR1cm4gdGhlIHJlc3VsdC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludCBhbmRGbGFncyhpbnRbXSBmbGFncykgewotCQlpbnQgbGFzdCA9IGZsYWdzLmxlbmd0aCAtIDE7Ci0JCWludCByZXN1bHQgPSBmbGFnc1tsYXN0XTsKLQkJZm9yIChpbnQgaSA9IGxhc3Q7IGktLSA+IDA7ICkgewotCQkJcmVzdWx0ICY9IGZsYWdzW2ldOwotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoqCi0JICogWE9SIGFsbCB0aGUgc3BlY2lmaWVkICdmbGFncycgdG9nZXRoZXIgYW5kIHJldHVybiB0aGUgcmVzdWx0LgotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50IHhvckZsYWdzKGludFtdIGZsYWdzKSB7Ci0JCWludCBsYXN0ID0gZmxhZ3MubGVuZ3RoIC0gMTsKLQkJaW50IHJlc3VsdCA9IGZsYWdzW2xhc3RdOwotCQlmb3IgKGludCBpID0gbGFzdDsgaS0tID4gMDsgKSB7Ci0JCQlyZXN1bHQgXj0gZmxhZ3NbaV07Ci0JCX0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3IgKioqKioqKioqKgotCi0JLyoqCi0JICogU3VwcHJlc3MgZGVmYXVsdCBjb25zdHJ1Y3RvciwgZW5zdXJpbmcgbm9uLWluc3RhbnRpYWJpbGl0eS4KLQkgKi8KLQlwcml2YXRlIEJpdFRvb2xzKCkgewotCQlzdXBlcigpOwotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9Cb29sZWFuSG9sZGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvQm9vbGVhbkhvbGRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlMDE0ZTRlLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9Cb29sZWFuSG9sZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMjYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uU2VyaWFsaXphYmxlOwotCi0vKioKLSAqIFByb3ZpZGUgYSBjb250YWluZXIgZm9yIHBhc3NpbmcgYSBmbGFnIHRoYXQgY2FuIGJlIGNoYW5nZWQgYnkgdGhlIHJlY2lwaWVudC4KLSAqIEBzZWUgU3luY2hyb25pemVkQm9vbGVhbgotICovCi1wdWJsaWMgY2xhc3MgQm9vbGVhbkhvbGRlcgotCWltcGxlbWVudHMgQ2xvbmVhYmxlLCBTZXJpYWxpemFibGUKLXsKLQkvKiogQmFja2luZyBib29sZWFuLiAqLwotCXByaXZhdGUgYm9vbGVhbiB2YWx1ZTsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDFMOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDcmVhdGUgYSBib29sZWFuIGhvbGRlciB3aXRoIHRoZSBzcGVjaWZpZWQgaW5pdGlhbCB2YWx1ZS4KLQkgKi8KLQlwdWJsaWMgQm9vbGVhbkhvbGRlcihib29sZWFuIHZhbHVlKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMudmFsdWUgPSB2YWx1ZTsKLQl9Ci0KLQkvKioKLQkgKiBDcmVhdGUgYSBib29sZWFuIGhvbGRlciB3aXRoIGFuIGluaXRpYWwgdmFsdWUgb2YgZmFsc2UuCi0JICovCi0JcHVibGljIEJvb2xlYW5Ib2xkZXIoKSB7Ci0JCXRoaXMoZmFsc2UpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBhY2Nlc3NvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjdXJyZW50IGJvb2xlYW4gdmFsdWUuCi0JICovCi0JcHVibGljIGJvb2xlYW4gZ2V0VmFsdWUoKSB7Ci0JCXJldHVybiB0aGlzLnZhbHVlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjdXJyZW50IGJvb2xlYW4gdmFsdWUgaXMgdHJ1ZS4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBpc1RydWUoKSB7Ci0JCXJldHVybiB0aGlzLnZhbHVlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjdXJyZW50IGJvb2xlYW4gdmFsdWUgaXMgZmFsc2UuCi0JICovCi0JcHVibGljIGJvb2xlYW4gaXNGYWxzZSgpIHsKLQkJcmV0dXJuICEgdGhpcy52YWx1ZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgY3VycmVudCBib29sZWFuIHZhbHVlIGlzIHRoZSBzcGVjaWZpZWQgdmFsdWUuCi0JICovCi0JcHVibGljIGJvb2xlYW4gaXMoYm9vbGVhbiB2KSB7Ci0JCXJldHVybiB0aGlzLnZhbHVlID09IHY7Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSBib29sZWFuIHZhbHVlLgotCSAqLwotCXB1YmxpYyB2b2lkIHNldFZhbHVlKGJvb2xlYW4gdmFsdWUpIHsKLQkJdGhpcy52YWx1ZSA9IHZhbHVlOwotCX0KLQotCS8qKgotCSAqIFNldCB0aGUgYm9vbGVhbiB2YWx1ZSB0byB0cnVlLgotCSAqLwotCXB1YmxpYyB2b2lkIHNldFRydWUoKSB7Ci0JCXRoaXMudmFsdWUgPSB0cnVlOwotCX0KLQotCS8qKgotCSAqIFNldCB0aGUgYm9vbGVhbiB2YWx1ZSB0byBmYWxzZS4KLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRGYWxzZSgpIHsKLQkJdGhpcy52YWx1ZSA9IGZhbHNlOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBzdGFuZGFyZCBtZXRob2RzICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXB1YmxpYyBPYmplY3QgY2xvbmUoKSB7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gc3VwZXIuY2xvbmUoKTsKLQkJfSBjYXRjaCAoQ2xvbmVOb3RTdXBwb3J0ZWRFeGNlcHRpb24gZXgpIHsKLQkJCXRocm93IG5ldyBJbnRlcm5hbEVycm9yKCk7Ci0JCX0KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgYm9vbGVhbiBlcXVhbHMoT2JqZWN0IG8pIHsKLQkJaWYgKG8gaW5zdGFuY2VvZiBCb29sZWFuSG9sZGVyKSB7Ci0JCQlyZXR1cm4gdGhpcy52YWx1ZSA9PSAoKEJvb2xlYW5Ib2xkZXIpIG8pLnZhbHVlOwotCQl9Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgaW50IGhhc2hDb2RlKCkgewotCQlyZXR1cm4gdGhpcy52YWx1ZSA/IDEgOiAwOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiAnWycgKyBTdHJpbmcudmFsdWVPZih0aGlzLnZhbHVlKSArICddJzsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9DbGFzc1Rvb2xzLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvQ2xhc3NUb29scy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzNThhNGI2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9DbGFzc1Rvb2xzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNzExICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5Db25zdHJ1Y3RvcjsKLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5GaWVsZDsKLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5JbnZvY2F0aW9uVGFyZ2V0RXhjZXB0aW9uOwotaW1wb3J0IGphdmEubGFuZy5yZWZsZWN0Lk1ldGhvZDsKLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5Nb2RpZmllcjsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbnM7Ci1pbXBvcnQgamF2YS51dGlsLlN0YWNrOwotCi0vKioKLSAqIENvbnZlbmllbmNlIG1ldGhvZHMgcmVsYXRlZCB0byB0aGUgamF2YS5sYW5nLnJlZmxlY3QgcGFja2FnZS4KLSAqIFRoZXNlIG1ldGhvZHMgcHJvdmlkZSBzaG9ydGN1dHMgZm9yIG1hbmlwdWxhdGluZyBvYmplY3RzIHZpYQotICogcmVmbGVjdGlvbjsgcGFydGljdWxhcmx5IHdoZW4gZGVhbGluZyB3aXRoIGZpZWxkcyBhbmQvb3IgbWV0aG9kcyB0aGF0Ci0gKiBhcmUgbm90IHB1YmxpY2x5IGFjY2Vzc2libGUgb3IgYXJlIGluaGVyaXRlZC4KLSAqIAotICogSW4gbW9zdCBjYXNlcywgYWxsIHRoZSBleGNlcHRpb25zIGFyZSBoYW5kbGVkIGFuZAotICogd3JhcHBlZCBpbiBqYXZhLmxhbmcuUnVudGltZUV4Y2VwdGlvbnM7IHNvIHRoZXNlIG1ldGhvZHMgc2hvdWxkCi0gKiBiZSB1c2VkIHdoZW4geW91IGFyZSBjb25maWRlbnQgdGhhdCB5b3Ugd2lsbCBub3QgaGF2aW5nIGFueSBwcm9ibGVtcwotICogdXNpbmcgcmVmbGVjdGlvbi4KLSAqIAotICogVGhlcmUgYXJlIGFsc28gYSBudW1iZXIgb2YgbWV0aG9kcyB3aG9zZSBuYW1lcwotICogYmVnaW4gd2l0aCAiYXR0ZW1wdCIuIFRoZXNlIG1ldGhvZHMgd2lsbCB0aHJvdyBhIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbgotICogb3IgTm9TdWNoRmllbGRFeGNlcHRpb24gd2hlbiBhcHByb3ByaWF0ZSwgYWxsb3dpbmcgeW91IHRvIHByb2JlCi0gKiBmb3IgbWV0aG9kcyB0aGF0IHNob3VsZCBiZSBwcmVzZW50IGJ1dCBtaWdodCBub3QuCi0gKi8KLXB1YmxpYyBmaW5hbCBjbGFzcyBDbGFzc1Rvb2xzIHsKLQotCXB1YmxpYyBzdGF0aWMgZmluYWwgQ2xhc3M8Pz5bXSBaRVJPX1BBUkFNRVRFUl9UWVBFUyA9IG5ldyBDbGFzc1swXTsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIE9iamVjdFtdIFpFUk9fUEFSQU1FVEVSUyA9IG5ldyBPYmplY3RbMF07Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIENSID0gU3RyaW5nVG9vbHMuQ1I7Ci0KLQlwdWJsaWMgc3RhdGljIGZpbmFsIGNoYXIgTkVTVEVEX0NMQVNTX05BTUVfU0VQQVJBVE9SID0gJyQnOwotCi0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIEFSUkFZX0lORElDQVRPUiA9ICdbJzsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIGNoYXIgVFlQRV9ERUNMQVJBVElPTl9BUlJBWV9PUEVOID0gJ1snOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgY2hhciBUWVBFX0RFQ0xBUkFUSU9OX0FSUkFZX0NMT1NFID0gJ10nOwotCi0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIFJFRkVSRU5DRV9DTEFTU19DT0RFID0gJ0wnOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgY2hhciBSRUZFUkVOQ0VfQ0xBU1NfTkFNRV9ERUxJTUlURVIgPSAnOyc7Ci0JCi0JcHJpdmF0ZSBzdGF0aWMgUHJpbWl0aXZlW10gUFJJTUlUSVZFUzsgIC8vIHBzZXVkby0nZmluYWwnIC0gbGF6eS1pbml0aWFsaXplZAotCXB1YmxpYyBzdGF0aWMgZmluYWwgY2hhciBCWVRFX0NPREUgPSAnQic7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIENIQVJfQ09ERSA9ICdDJzsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIGNoYXIgRE9VQkxFX0NPREUgPSAnRCc7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIEZMT0FUX0NPREUgPSAnRic7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIElOVF9DT0RFID0gJ0knOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgY2hhciBMT05HX0NPREUgPSAnSic7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIFNIT1JUX0NPREUgPSAnUyc7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIEJPT0xFQU5fQ09ERSA9ICdaJzsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIGNoYXIgVk9JRF9DT0RFID0gJ1YnOwotCXByaXZhdGUgc3RhdGljIGludCBNQVhfUFJJTUlUSVZFX0NMQVNTX05BTUVfTEVOR1RIID0gLTE7ICAvLyBwc2V1ZG8tJ2ZpbmFsJyAtIGxhenktaW5pdGlhbGl6ZWQKLQlwcml2YXRlIHN0YXRpYyBpbnQgTUFYX1BSSU1JVElWRV9XUkFQUEVSX0NMQVNTX05BTUVfTEVOR1RIID0gLTE7ICAvLyBwc2V1ZG8tJ2ZpbmFsJyAtIGxhenktaW5pdGlhbGl6ZWQKLQotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFZPSURfQ0xBU1NfTkFNRSA9IHZvaWQuY2xhc3MuZ2V0TmFtZSgpOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFZPSURfV1JBUFBFUl9DTEFTU19OQU1FID0gamF2YS5sYW5nLlZvaWQuY2xhc3MuZ2V0TmFtZSgpOwotCi0KLQkvKioKLQkgKiBSZXR1cm4gYWxsIHRoZSBmaWVsZHMgZm9yIHRoZQotCSAqIHNwZWNpZmllZCBjbGFzcywgaW5jbHVkaW5nIGluaGVyaXRlZCBmaWVsZHMuCi0JICogQ2xhc3MjYWxsRmllbGRzKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIEZpZWxkW10gYWxsRmllbGRzKENsYXNzPD8+IGphdmFDbGFzcykgewotCQlTdGFjazxGaWVsZD4gc3RhY2sgPSBuZXcgU3RhY2s8RmllbGQ+KCk7Ci0JCWZvciAoQ2xhc3M8Pz4gdGVtcENsYXNzID0gamF2YUNsYXNzOyB0ZW1wQ2xhc3MgIT0gbnVsbDsgdGVtcENsYXNzID0gdGVtcENsYXNzLmdldFN1cGVyY2xhc3MoKSkgewotCQkJcHVzaERlY2xhcmVkRmllbGRzKHRlbXBDbGFzcywgc3RhY2spOwotCQl9Ci0JCUNvbGxlY3Rpb25zLnJldmVyc2Uoc3RhY2spOwotCQlyZXR1cm4gc3RhY2sudG9BcnJheShuZXcgRmllbGRbc3RhY2suc2l6ZSgpXSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiBhbGwgdGhlIG1ldGhvZHMgZm9yIHRoZQotCSAqIHNwZWNpZmllZCBjbGFzcywgaW5jbHVkaW5nIGluaGVyaXRlZCBtZXRob2RzLgotCSAqIENsYXNzI2FsbE1ldGhvZHMoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgTWV0aG9kW10gYWxsTWV0aG9kcyhDbGFzczw/PiBqYXZhQ2xhc3MpIHsKLQkJU3RhY2s8TWV0aG9kPiBzdGFjayA9IG5ldyBTdGFjazxNZXRob2Q+KCk7Ci0JCWZvciAoQ2xhc3M8Pz4gdGVtcENsYXNzID0gamF2YUNsYXNzOyB0ZW1wQ2xhc3MgIT0gbnVsbDsgdGVtcENsYXNzID0gdGVtcENsYXNzLmdldFN1cGVyY2xhc3MoKSkgewotCQkJcHVzaERlY2xhcmVkTWV0aG9kcyh0ZW1wQ2xhc3MsIHN0YWNrKTsKLQkJfQotCQlDb2xsZWN0aW9ucy5yZXZlcnNlKHN0YWNrKTsKLQkJcmV0dXJuIHN0YWNrLnRvQXJyYXkobmV3IE1ldGhvZFtzdGFjay5zaXplKCldKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIFJldHVybiBhIG5ldyBpbnN0YW5jZSBvZiB0aGUgc3BlY2lmaWVkIGNsYXNzLAotCSAqIHVzaW5nIHRoZSBjbGFzcydzIGRlZmF1bHQgKHplcm8tYXJndW1lbnQpIGNvbnN0cnVjdG9yLgotCSAqIFRocm93IGFuIGV4Y2VwdGlvbiBpZiB0aGUgZGVmYXVsdCBjb25zdHJ1Y3RvciBpcyBub3QgZGVmaW5lZC4KLQkgKiBDbGFzcyNuZXdJbnN0YW5jZSgpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24KLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxUPiBUIGF0dGVtcHROZXdJbnN0YW5jZShDbGFzczxUPiBqYXZhQ2xhc3MpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24gewotCQlyZXR1cm4gYXR0ZW1wdE5ld0luc3RhbmNlKGphdmFDbGFzcywgWkVST19QQVJBTUVURVJfVFlQRVMsIFpFUk9fUEFSQU1FVEVSUyk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBpbnN0YW5jZSBvZiB0aGUgc3BlY2lmaWVkIGNsYXNzLAotCSAqIGdpdmVuIHRoZSBjb25zdHJ1Y3RvciBwYXJhbWV0ZXIgdHlwZXMgYW5kIHBhcmFtZXRlcnMuCi0JICogVGhyb3cgYW4gZXhjZXB0aW9uIGlmIHRoZSBjb25zdHJ1Y3RvciBpcyBub3QgZGVmaW5lZC4KLQkgKiBDbGFzcyNuZXdJbnN0YW5jZShDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzLCBPYmplY3RbXSBwYXJhbWV0ZXJzKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uCi0JICovCi0JcHVibGljIHN0YXRpYyA8VD4gVCBhdHRlbXB0TmV3SW5zdGFuY2UoQ2xhc3M8VD4gamF2YUNsYXNzLCBDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzLCBPYmplY3RbXSBwYXJhbWV0ZXJzKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJdHJ5IHsKLQkJCXJldHVybiBjb25zdHJ1Y3RvcihqYXZhQ2xhc3MsIHBhcmFtZXRlclR5cGVzKS5uZXdJbnN0YW5jZShwYXJhbWV0ZXJzKTsKLQkJfSBjYXRjaCAoSW5zdGFudGlhdGlvbkV4Y2VwdGlvbiBpZSkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oaWUgKyBDUiArIGZ1bGx5UXVhbGlmaWVkQ29uc3RydWN0b3JTaWduYXR1cmUoamF2YUNsYXNzLCBwYXJhbWV0ZXJUeXBlcyksIGllKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFjY2Vzc0V4Y2VwdGlvbiBpYWUpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGlhZSArIENSICsgZnVsbHlRdWFsaWZpZWRDb25zdHJ1Y3RvclNpZ25hdHVyZShqYXZhQ2xhc3MsIHBhcmFtZXRlclR5cGVzKSwgaWFlKTsKLQkJfSBjYXRjaCAoSW52b2NhdGlvblRhcmdldEV4Y2VwdGlvbiBpdGUpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGZ1bGx5UXVhbGlmaWVkQ29uc3RydWN0b3JTaWduYXR1cmUoamF2YUNsYXNzLCBwYXJhbWV0ZXJUeXBlcykgKyBDUiArIGl0ZS5nZXRUYXJnZXRFeGNlcHRpb24oKSwgaXRlKTsKLQkJfQotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogUmV0dXJuIGEgbmV3IGluc3RhbmNlIG9mIHRoZSBzcGVjaWZpZWQgY2xhc3MsCi0JICogZ2l2ZW4gdGhlIGNvbnN0cnVjdG9yIHBhcmFtZXRlciB0eXBlIGFuZCBwYXJhbWV0ZXIuCi0JICogVGhyb3cgYW4gZXhjZXB0aW9uIGlmIHRoZSBjb25zdHJ1Y3RvciBpcyBub3QgZGVmaW5lZC4KLQkgKiBDbGFzcyNuZXdJbnN0YW5jZShDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uCi0JICovCi0JcHVibGljIHN0YXRpYyA8VD4gVCBhdHRlbXB0TmV3SW5zdGFuY2UoQ2xhc3M8VD4gamF2YUNsYXNzLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIGF0dGVtcHROZXdJbnN0YW5jZShqYXZhQ2xhc3MsIG5ldyBDbGFzc1tdIHtwYXJhbWV0ZXJUeXBlfSwgbmV3IE9iamVjdFtdIHtwYXJhbWV0ZXJ9KTsKLQl9Ci0JCi0JLyoqCi0JICogQXR0ZW1wdCB0byBnZXQgYSBmaWVsZCB2YWx1ZSwgZ2l2ZW4gdGhlIGNvbnRhaW5pbmcgb2JqZWN0IGFuZCBmaWVsZCBuYW1lLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIFVzZWZ1bCBmb3IgYWNjZXNzaW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBmaWVsZHMuCi0JICogVGhyb3cgYW4gZXhjZXB0aW9uIGlmIHRoZSBmaWVsZCBpcyBub3QgZGVmaW5lZC4KLQkgKiBPYmplY3QjZ2V0RmllbGRWYWx1ZShTdHJpbmcgZmllbGROYW1lKSB0aHJvd3MgTm9TdWNoRmllbGRFeGNlcHRpb24KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBhdHRlbXB0VG9HZXRGaWVsZFZhbHVlKE9iamVjdCBvYmplY3QsIFN0cmluZyBmaWVsZE5hbWUpIHRocm93cyBOb1N1Y2hGaWVsZEV4Y2VwdGlvbiB7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gZmllbGQob2JqZWN0LCBmaWVsZE5hbWUpLmdldChvYmplY3QpOwotCQl9IGNhdGNoIChJbGxlZ2FsQWNjZXNzRXhjZXB0aW9uIGlhZSkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oaWFlICsgQ1IgKyBmdWxseVF1YWxpZmllZEZpZWxkTmFtZShvYmplY3QsIGZpZWxkTmFtZSksIGlhZSk7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogQXR0ZW1wdCB0byBnZXQgYSBzdGF0aWMgZmllbGQgdmFsdWUsIGdpdmVuIHRoZSBjb250YWluaW5nIG9iamVjdCBhbmQgZmllbGQgbmFtZS4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBVc2VmdWwgZm9yIGFjY2Vzc2luZyBwcml2YXRlLCBwYWNrYWdlLCBvciBwcm90ZWN0ZWQgZmllbGRzLgotCSAqIFRocm93IGFuIGV4Y2VwdGlvbiBpZiB0aGUgZmllbGQgaXMgbm90IGRlZmluZWQuCi0JICogQ2xhc3MjZ2V0U3RhdGljRmllbGRWYWx1ZShTdHJpbmcgZmllbGROYW1lKSB0aHJvd3MgTm9TdWNoRmllbGRFeGNlcHRpb24KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBhdHRlbXB0VG9HZXRTdGF0aWNGaWVsZFZhbHVlKENsYXNzPD8+IGphdmFDbGFzcywgU3RyaW5nIGZpZWxkTmFtZSkgdGhyb3dzIE5vU3VjaEZpZWxkRXhjZXB0aW9uIHsKLQkJdHJ5IHsKLQkJCXJldHVybiBmaWVsZChqYXZhQ2xhc3MsIGZpZWxkTmFtZSkuZ2V0KG51bGwpOwotCQl9IGNhdGNoIChJbGxlZ2FsQWNjZXNzRXhjZXB0aW9uIGlhZSkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oaWFlICsgQ1IgKyBmdWxseVF1YWxpZmllZEZpZWxkTmFtZShqYXZhQ2xhc3MsIGZpZWxkTmFtZSksIGlhZSk7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIEF0dGVtcHQgdG8gZXhlY3V0ZSBhIHplcm8tYXJndW1lbnQgbWV0aG9kLAotCSAqIGdpdmVuIHRoZSByZWNlaXZlciBhbmQgbWV0aG9kIG5hbWUuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogVGhyb3cgYW4gZXhjZXB0aW9uIGlmIHRoZSBtZXRob2QgaXMgbm90IGZvdW5kLgotCSAqIFVzZWZ1bCBmb3IgaW52b2tpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIG1ldGhvZHMuCi0JICogT2JqZWN0I2V4ZWN1dGUoU3RyaW5nIG1ldGhvZE5hbWUpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBhdHRlbXB0VG9FeGVjdXRlTWV0aG9kKE9iamVjdCByZWNlaXZlciwgU3RyaW5nIG1ldGhvZE5hbWUpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24gewotCQlyZXR1cm4gYXR0ZW1wdFRvRXhlY3V0ZU1ldGhvZChyZWNlaXZlciwgbWV0aG9kTmFtZSwgWkVST19QQVJBTUVURVJfVFlQRVMsIFpFUk9fUEFSQU1FVEVSUyk7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBBdHRlbXB0IHRvIGV4ZWN1dGUgYSBtZXRob2QsIGdpdmVuIHRoZSByZWNlaXZlciwKLQkgKiBtZXRob2QgbmFtZSwgcGFyYW1ldGVyIHR5cGUsIGFuZCBwYXJhbWV0ZXIuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogVGhyb3cgYW4gZXhjZXB0aW9uIGlmIHRoZSBtZXRob2QgaXMgbm90IGZvdW5kLgotCSAqIFVzZWZ1bCBmb3IgaW52b2tpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIG1ldGhvZHMuCi0JICogT2JqZWN0I2V4ZWN1dGUoU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+IHBhcmFtZXRlclR5cGUsIE9iamVjdCBwYXJhbWV0ZXIpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBhdHRlbXB0VG9FeGVjdXRlTWV0aG9kKE9iamVjdCByZWNlaXZlciwgU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+IHBhcmFtZXRlclR5cGUsIE9iamVjdCBwYXJhbWV0ZXIpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24gewotCQlyZXR1cm4gYXR0ZW1wdFRvRXhlY3V0ZU1ldGhvZChyZWNlaXZlciwgbWV0aG9kTmFtZSwgbmV3IENsYXNzW10ge3BhcmFtZXRlclR5cGV9LCBuZXcgT2JqZWN0W10ge3BhcmFtZXRlcn0pOwotCX0KLQkKLQkvKioKLQkgKiBBdHRlbXB0IHRvIGV4ZWN1dGUgYSBtZXRob2QsIGdpdmVuIHRoZSByZWNlaXZlciwKLQkgKiBtZXRob2QgbmFtZSwgcGFyYW1ldGVyIHR5cGVzLCBhbmQgcGFyYW1ldGVycy4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBUaHJvdyBhbiBleGNlcHRpb24gaWYgdGhlIG1ldGhvZCBpcyBub3QgZm91bmQuCi0JICogVXNlZnVsIGZvciBpbnZva2luZyBwcml2YXRlLCBwYWNrYWdlLCBvciBwcm90ZWN0ZWQgbWV0aG9kcy4KLQkgKiBPYmplY3QjZXhlY3V0ZShTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbgotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IGF0dGVtcHRUb0V4ZWN1dGVNZXRob2QoT2JqZWN0IHJlY2VpdmVyLCBTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBleGVjdXRlTWV0aG9kKG1ldGhvZChyZWNlaXZlciwgbWV0aG9kTmFtZSwgcGFyYW1ldGVyVHlwZXMpLCByZWNlaXZlciwgcGFyYW1ldGVycyk7Ci0JfQotCQotCS8qKgotCSAqIEF0dGVtcHQgdG8gZXhlY3V0ZSBhIG1ldGhvZCwgZ2l2ZW4gdGhlIHJlY2VpdmVyLAotCSAqIG1ldGhvZCBuYW1lLCBwYXJhbWV0ZXIgdHlwZXMsIGFuZCBwYXJhbWV0ZXJzLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIFRocm93IGFuIGV4Y2VwdGlvbiBpZiB0aGUgbWV0aG9kIGlzIG5vdCBmb3VuZC4KLQkgKiBJZiB0aGUgZXhlY3V0ZWQgbWV0aG9kIHRocm93cyBhbiBleGNlcHRpb24sIHJldGhyb3cgdGhhdCBleGNlcHRpb24uCi0JICogVXNlZnVsIGZvciBpbnZva2luZyBwcml2YXRlLCBwYWNrYWdlLCBvciBwcm90ZWN0ZWQgbWV0aG9kcy4KLQkgKiBPYmplY3QjZXhlY3V0ZShTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbgotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IGF0dGVtcHRUb0V4ZWN1dGVNZXRob2RXaXRoRXhjZXB0aW9uKE9iamVjdCByZWNlaXZlciwgU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMsIE9iamVjdFtdIHBhcmFtZXRlcnMpIAotCQl0aHJvd3MgVGhyb3dhYmxlLCBOb1N1Y2hNZXRob2RFeGNlcHRpb24gCi0JewotCQlyZXR1cm4gZXhlY3V0ZU1ldGhvZFdpdGhFeGNlcHRpb24obWV0aG9kKHJlY2VpdmVyLCBtZXRob2ROYW1lLCBwYXJhbWV0ZXJUeXBlcyksIHJlY2VpdmVyLCBwYXJhbWV0ZXJzKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIEF0dGVtcHQgdG8gZXhlY3V0ZSBhIHplcm8tYXJndW1lbnQgc3RhdGljIG1ldGhvZCwKLQkgKiBnaXZlbiB0aGUgY2xhc3MgYW5kIG1ldGhvZCBuYW1lLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIFRocm93IGFuIGV4Y2VwdGlvbiBpZiB0aGUgbWV0aG9kIGlzIG5vdCBmb3VuZC4KLQkgKiBVc2VmdWwgZm9yIGludm9raW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBtZXRob2RzLgotCSAqIENsYXNzI2V4ZWN1dGVTdGF0aWNNZXRob2QoU3RyaW5nIG1ldGhvZE5hbWUpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBhdHRlbXB0VG9FeGVjdXRlU3RhdGljTWV0aG9kKENsYXNzPD8+IGphdmFDbGFzcywgU3RyaW5nIG1ldGhvZE5hbWUpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24gewotCQlyZXR1cm4gYXR0ZW1wdFRvRXhlY3V0ZVN0YXRpY01ldGhvZChqYXZhQ2xhc3MsIG1ldGhvZE5hbWUsIFpFUk9fUEFSQU1FVEVSX1RZUEVTLCBaRVJPX1BBUkFNRVRFUlMpOwotCX0KLQkKLQkvKioKLQkgKiBBdHRlbXB0IHRvIGV4ZWN1dGUgYSBzdGF0aWMgbWV0aG9kLCBnaXZlbiB0aGUgY2xhc3MsCi0JICogbWV0aG9kIG5hbWUsIHBhcmFtZXRlciB0eXBlcywgYW5kIHBhcmFtZXRlcnMuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogVGhyb3cgYW4gZXhjZXB0aW9uIGlmIHRoZSBtZXRob2QgaXMgbm90IGZvdW5kLgotCSAqIFVzZWZ1bCBmb3IgaW52b2tpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIG1ldGhvZHMuCi0JICogQ2xhc3MjZXhlY3V0ZVN0YXRpY01ldGhvZChTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbgotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IGF0dGVtcHRUb0V4ZWN1dGVTdGF0aWNNZXRob2QoQ2xhc3M8Pz4gamF2YUNsYXNzLCBTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBleGVjdXRlU3RhdGljTWV0aG9kKHN0YXRpY01ldGhvZChqYXZhQ2xhc3MsIG1ldGhvZE5hbWUsIHBhcmFtZXRlclR5cGVzKSwgcGFyYW1ldGVycyk7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBBdHRlbXB0IHRvIGV4ZWN1dGUgYSBzdGF0aWMgbWV0aG9kLCBnaXZlbiB0aGUgY2xhc3MsCi0JICogbWV0aG9kIG5hbWUsIHBhcmFtZXRlciB0eXBlLCBhbmQgcGFyYW1ldGVyLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIFRocm93IGFuIGV4Y2VwdGlvbiBpZiB0aGUgbWV0aG9kIGlzIG5vdCBmb3VuZC4KLQkgKiBVc2VmdWwgZm9yIGludm9raW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBtZXRob2RzLgotCSAqIENsYXNzI2V4ZWN1dGVTdGF0aWNNZXRob2QoU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+IHBhcmFtZXRlclR5cGUsIE9iamVjdCBwYXJhbWV0ZXIpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBhdHRlbXB0VG9FeGVjdXRlU3RhdGljTWV0aG9kKENsYXNzPD8+IGphdmFDbGFzcywgU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+IHBhcmFtZXRlclR5cGUsIE9iamVjdCBwYXJhbWV0ZXIpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24gewotCQlyZXR1cm4gYXR0ZW1wdFRvRXhlY3V0ZVN0YXRpY01ldGhvZChqYXZhQ2xhc3MsIG1ldGhvZE5hbWUsIG5ldyBDbGFzc1tdIHtwYXJhbWV0ZXJUeXBlfSwgbmV3IE9iamVjdFtdIHtwYXJhbWV0ZXJ9KTsKLQl9Ci0JCi0JLyoqCi0JICogQXR0ZW1wdCB0byBzZXQgYSBmaWVsZCB2YWx1ZSwgZ2l2ZW4gdGhlCi0JICogY29udGFpbmluZyBvYmplY3QsIGZpZWxkIG5hbWUsIGFuZCBuZXcgZmllbGQgdmFsdWUuCi0JICogVXNlZnVsIGZvciBhY2Nlc3NpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIGZpZWxkcy4KLQkgKiBUaHJvdyBhbiBleGNlcHRpb24gaWYgdGhlIGZpZWxkIGlzIG5vdCBkZWZpbmVkLgotCSAqIE9iamVjdCNzZXRGaWVsZFZhbHVlKFN0cmluZyBmaWVsZE5hbWUsIE9iamVjdCBmaWVsZFZhbHVlKSB0aHJvd3MgTm9TdWNoRmllbGRFeGNlcHRpb24KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgYXR0ZW1wdFRvU2V0RmllbGRWYWx1ZShPYmplY3Qgb2JqZWN0LCBTdHJpbmcgZmllbGROYW1lLCBPYmplY3QgZmllbGRWYWx1ZSkgdGhyb3dzIE5vU3VjaEZpZWxkRXhjZXB0aW9uIHsKLQkJdHJ5IHsKLQkJCWZpZWxkKG9iamVjdCwgZmllbGROYW1lKS5zZXQob2JqZWN0LCBmaWVsZFZhbHVlKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFjY2Vzc0V4Y2VwdGlvbiBpYWUpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGlhZSArIENSICsgZnVsbHlRdWFsaWZpZWRGaWVsZE5hbWUob2JqZWN0LCBmaWVsZE5hbWUpLCBpYWUpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIEF0dGVtcHQgdG8gc2V0IGEgc3RhdGljIGZpZWxkIHZhbHVlLCBnaXZlbiB0aGUKLQkgKiBjb250YWluaW5nIGNsYXNzLCBmaWVsZCBuYW1lLCBhbmQgbmV3IGZpZWxkIHZhbHVlLgotCSAqIFVzZWZ1bCBmb3IgYWNjZXNzaW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBmaWVsZHMuCi0JICogVGhyb3cgYW4gZXhjZXB0aW9uIGlmIHRoZSBmaWVsZCBpcyBub3QgZGVmaW5lZC4KLQkgKiBDbGFzcyNzZXRTdGF0aWNGaWVsZFZhbHVlKFN0cmluZyBmaWVsZE5hbWUsIE9iamVjdCBmaWVsZFZhbHVlKSB0aHJvd3MgTm9TdWNoRmllbGRFeGNlcHRpb24KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgYXR0ZW1wdFRvU2V0U3RhdGljRmllbGRWYWx1ZShDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBmaWVsZE5hbWUsIE9iamVjdCBmaWVsZFZhbHVlKSB0aHJvd3MgTm9TdWNoRmllbGRFeGNlcHRpb24gewotCQl0cnkgewotCQkJZmllbGQoamF2YUNsYXNzLCBmaWVsZE5hbWUpLnNldChudWxsLCBmaWVsZFZhbHVlKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFjY2Vzc0V4Y2VwdGlvbiBpYWUpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGlhZSArIENSICsgZnVsbHlRdWFsaWZpZWRGaWVsZE5hbWUoamF2YUNsYXNzLCBmaWVsZE5hbWUpLCBpYWUpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBSZXR1cm4gdGhlIGRlZmF1bHQgKHplcm8tYXJndW1lbnQpIGNvbnN0cnVjdG9yCi0JICogZm9yIHRoZSBzcGVjaWZpZWQgY2xhc3MuCi0JICogU2V0IGFjY2Vzc2libGUgdG8gdHJ1ZSwgc28gd2UgY2FuIGFjY2VzcwotCSAqIHByaXZhdGUvcGFja2FnZS9wcm90ZWN0ZWQgY29uc3RydWN0b3JzLgotCSAqIENsYXNzI2NvbnN0cnVjdG9yKCkgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbgotCSAqLwotCXB1YmxpYyBzdGF0aWMgPFQ+IENvbnN0cnVjdG9yPFQ+IGNvbnN0cnVjdG9yKENsYXNzPFQ+IGphdmFDbGFzcykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBjb25zdHJ1Y3RvcihqYXZhQ2xhc3MsIFpFUk9fUEFSQU1FVEVSX1RZUEVTKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjb25zdHJ1Y3RvciBmb3IgdGhlIHNwZWNpZmllZCBjbGFzcwotCSAqIGFuZCBmb3JtYWwgcGFyYW1ldGVyIHR5cGVzLgotCSAqIFNldCBhY2Nlc3NpYmxlIHRvIHRydWUsIHNvIHdlIGNhbiBhY2Nlc3MKLQkgKiBwcml2YXRlL3BhY2thZ2UvcHJvdGVjdGVkIGNvbnN0cnVjdG9ycy4KLQkgKiBDbGFzcyNjb25zdHJ1Y3RvcihDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uCi0JICovCi0JcHVibGljIHN0YXRpYyA8VD4gQ29uc3RydWN0b3I8VD4gY29uc3RydWN0b3IoQ2xhc3M8VD4gamF2YUNsYXNzLCBDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJQ29uc3RydWN0b3I8VD4gY29uc3RydWN0b3IgPSBqYXZhQ2xhc3MuZ2V0RGVjbGFyZWRDb25zdHJ1Y3RvcihwYXJhbWV0ZXJUeXBlcyk7Ci0JCWNvbnN0cnVjdG9yLnNldEFjY2Vzc2libGUodHJ1ZSk7Ci0JCXJldHVybiBjb25zdHJ1Y3RvcjsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIFJldHVybiB0aGUgY29uc3RydWN0b3IgZm9yIHRoZSBzcGVjaWZpZWQgY2xhc3MKLQkgKiBhbmQgZm9ybWFsIHBhcmFtZXRlciB0eXBlLgotCSAqIFNldCBhY2Nlc3NpYmxlIHRvIHRydWUsIHNvIHdlIGNhbiBhY2Nlc3MKLQkgKiBwcml2YXRlL3BhY2thZ2UvcHJvdGVjdGVkIGNvbnN0cnVjdG9ycy4KLQkgKiBDbGFzcyNjb25zdHJ1Y3RvcihDbGFzczw/PiBwYXJhbWV0ZXJUeXBlKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uCi0JICovCi0JcHVibGljIHN0YXRpYyA8VD4gQ29uc3RydWN0b3I8VD4gY29uc3RydWN0b3IoQ2xhc3M8VD4gamF2YUNsYXNzLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIGNvbnN0cnVjdG9yKGphdmFDbGFzcywgbmV3IENsYXNzW10ge3BhcmFtZXRlclR5cGV9KTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBkZWNsYXJlZCBmaWVsZHMgZm9yIHRoZSBzcGVjaWZpZWQgY2xhc3MuCi0JICogU2V0IGFjY2Vzc2libGUgdG8gdHJ1ZSwgc28gd2UgY2FuIGFjY2VzcwotCSAqIHByaXZhdGUvcGFja2FnZS9wcm90ZWN0ZWQgZmllbGRzLgotCSAqIENsYXNzI2FjY2Vzc2libGVEZWNsYXJlZEZpZWxkcygpCi0JICovCi0JcHVibGljIHN0YXRpYyBGaWVsZFtdIGRlY2xhcmVkRmllbGRzKENsYXNzPD8+IGphdmFDbGFzcykgewotCQlGaWVsZFtdIGZpZWxkcyA9IGphdmFDbGFzcy5nZXREZWNsYXJlZEZpZWxkcygpOwotCQlmb3IgKEZpZWxkIGZpZWxkIDogZmllbGRzKSB7Ci0JCQlmaWVsZC5zZXRBY2Nlc3NpYmxlKHRydWUpOwotCQl9Ci0JCXJldHVybiBmaWVsZHM7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgZGVjbGFyZWQgbWV0aG9kcyBmb3IgdGhlCi0JICogc3BlY2lmaWVkIGNsYXNzLgotCSAqIFNldCBhY2Nlc3NpYmxlIHRvIHRydWUsIHNvIHdlIGNhbiBhY2Nlc3MKLQkgKiBwcml2YXRlL3BhY2thZ2UvcHJvdGVjdGVkIG1ldGhvZHMuCi0JICogQ2xhc3MjYWNjZXNzaWJsZURlY2xhcmVkTWV0aG9kcygpCi0JICovCi0JcHVibGljIHN0YXRpYyBNZXRob2RbXSBkZWNsYXJlZE1ldGhvZHMoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCU1ldGhvZFtdIG1ldGhvZHMgPSBqYXZhQ2xhc3MuZ2V0RGVjbGFyZWRNZXRob2RzKCk7Ci0JCWZvciAoTWV0aG9kIG1ldGhvZCA6IG1ldGhvZHMpIHsKLQkJCW1ldGhvZC5zZXRBY2Nlc3NpYmxlKHRydWUpOwotCQl9Ci0JCXJldHVybiBtZXRob2RzOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIGRlZmF1bHQgKHplcm8tYXJndW1lbnQpIGNvbnN0cnVjdG9yCi0JICogZm9yIHRoZSBzcGVjaWZpZWQgY2xhc3MuCi0JICogU2V0IGFjY2Vzc2libGUgdG8gdHJ1ZSwgc28gd2UgY2FuIGFjY2VzcwotCSAqIHByaXZhdGUvcGFja2FnZS9wcm90ZWN0ZWQgY29uc3RydWN0b3JzLgotCSAqIENsYXNzI2RlZmF1bHRDb25zdHJ1Y3RvcigpCi0JICovCi0JcHVibGljIHN0YXRpYyA8VD4gQ29uc3RydWN0b3I8VD4gZGVmYXVsdENvbnN0cnVjdG9yKENsYXNzPFQ+IGphdmFDbGFzcykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBjb25zdHJ1Y3RvcihqYXZhQ2xhc3MpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gYSBmaWVsZCBmb3IgdGhlIHNwZWNpZmllZCBjbGFzcyBhbmQgZmllbGQgbmFtZS4KLQkgKiBJZiB0aGUgY2xhc3MgZG9lcyBub3QgZGlyZWN0bHkKLQkgKiBkZWZpbmUgdGhlIGZpZWxkLCBsb29rIGZvciBpdCBpbiB0aGUgY2xhc3MncyBzdXBlcmNsYXNzZXMuCi0JICogU2V0IGFjY2Vzc2libGUgdG8gdHJ1ZSwgc28gd2UgY2FuIGFjY2VzcwotCSAqIHByaXZhdGUvcGFja2FnZS9wcm90ZWN0ZWQgZmllbGRzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgRmllbGQgZmllbGQoQ2xhc3M8Pz4gamF2YUNsYXNzLCBTdHJpbmcgZmllbGROYW1lKSB0aHJvd3MgTm9TdWNoRmllbGRFeGNlcHRpb24gewotCQlGaWVsZCBmaWVsZCA9IG51bGw7Ci0JCXRyeSB7Ci0JCQlmaWVsZCA9IGphdmFDbGFzcy5nZXREZWNsYXJlZEZpZWxkKGZpZWxkTmFtZSk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEZpZWxkRXhjZXB0aW9uIGV4KSB7Ci0JCQlDbGFzczw/PiBzdXBlcmNsYXNzID0gamF2YUNsYXNzLmdldFN1cGVyY2xhc3MoKTsKLQkJCWlmIChzdXBlcmNsYXNzID09IG51bGwpIHsKLQkJCQl0aHJvdyBleDsKLQkJCX0KLQkJCS8vIHJlY3Vyc2UKLQkJCXJldHVybiBmaWVsZChzdXBlcmNsYXNzLCBmaWVsZE5hbWUpOwotCQl9Ci0JCWZpZWxkLnNldEFjY2Vzc2libGUodHJ1ZSk7Ci0JCXJldHVybiBmaWVsZDsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIFJldHVybiBhIGZpZWxkIGZvciB0aGUgc3BlY2lmaWVkIG9iamVjdCBhbmQgZmllbGQgbmFtZS4KLQkgKiBJZiB0aGUgb2JqZWN0J3MgY2xhc3MgZG9lcyBub3QgZGlyZWN0bHkKLQkgKiBkZWZpbmUgdGhlIGZpZWxkLCBsb29rIGZvciBpdCBpbiB0aGUgY2xhc3MncyBzdXBlcmNsYXNzZXMuCi0JICogU2V0IGFjY2Vzc2libGUgdG8gdHJ1ZSwgc28gd2UgY2FuIGFjY2VzcwotCSAqIHByaXZhdGUvcGFja2FnZS9wcm90ZWN0ZWQgZmllbGRzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgRmllbGQgZmllbGQoT2JqZWN0IG9iamVjdCwgU3RyaW5nIGZpZWxkTmFtZSkgdGhyb3dzIE5vU3VjaEZpZWxkRXhjZXB0aW9uIHsKLQkJcmV0dXJuIGZpZWxkKG9iamVjdC5nZXRDbGFzcygpLCBmaWVsZE5hbWUpOwotCX0KLQkKLQkvKgotCSAqIFJldHVybiBhIHN0cmluZyByZXByZXNlbnRhdGlvbiBvZiB0aGUgc3BlY2lmaWVkIGNvbnN0cnVjdG9yLgotCSAqLwotCXByaXZhdGUgc3RhdGljIFN0cmluZyBmdWxseVF1YWxpZmllZENvbnN0cnVjdG9yU2lnbmF0dXJlKENsYXNzPD8+IGphdmFDbGFzcywgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcykgewotCQlyZXR1cm4gZnVsbHlRdWFsaWZpZWRNZXRob2RTaWduYXR1cmUoamF2YUNsYXNzLCBudWxsLCBwYXJhbWV0ZXJUeXBlcyk7Ci0JfQotCQotCS8qCi0JICogUmV0dXJuIGEgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBzcGVjaWZpZWQgZmllbGQuCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgU3RyaW5nIGZ1bGx5UXVhbGlmaWVkRmllbGROYW1lKENsYXNzPD8+IGphdmFDbGFzcywgU3RyaW5nIGZpZWxkTmFtZSkgewotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoMjAwKTsKLQkJc2IuYXBwZW5kKGphdmFDbGFzcy5nZXROYW1lKCkpOwotCQlzYi5hcHBlbmQoJy4nKTsKLQkJc2IuYXBwZW5kKGZpZWxkTmFtZSk7Ci0JCXJldHVybiBzYi50b1N0cmluZygpOwotCX0KLQkKLQkvKgotCSAqIFJldHVybiBhIHN0cmluZyByZXByZXNlbnRhdGlvbiBvZiB0aGUgc3BlY2lmaWVkIGZpZWxkLgotCSAqLwotCXByaXZhdGUgc3RhdGljIFN0cmluZyBmdWxseVF1YWxpZmllZEZpZWxkTmFtZShPYmplY3Qgb2JqZWN0LCBTdHJpbmcgZmllbGROYW1lKSB7Ci0JCXJldHVybiBmdWxseVF1YWxpZmllZEZpZWxkTmFtZShvYmplY3QuZ2V0Q2xhc3MoKSwgZmllbGROYW1lKTsKLQl9Ci0JCi0JLyoKLQkgKiBSZXR1cm4gYSBzdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgdGhlIHNwZWNpZmllZCBtZXRob2QuCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgU3RyaW5nIGZ1bGx5UXVhbGlmaWVkTWV0aG9kU2lnbmF0dXJlKENsYXNzPD8+IGphdmFDbGFzcywgU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXNiLmFwcGVuZChqYXZhQ2xhc3MuZ2V0TmFtZSgpKTsKLQkJLy8gdGhpcyBjaGVjayBhbGxvd3MgdXMgdG8gdXNlIHRoaXMgY29kZSBmb3IgY29uc3RydWN0b3JzLCB3aGVyZSB0aGUgbWV0aG9kTmFtZSBpcyBudWxsCi0JCWlmIChtZXRob2ROYW1lICE9IG51bGwpIHsKLQkJCXNiLmFwcGVuZCgnLicpOwotCQkJc2IuYXBwZW5kKG1ldGhvZE5hbWUpOwotCQl9Ci0JCXNiLmFwcGVuZCgnKCcpOwotCQlpbnQgbWF4ID0gcGFyYW1ldGVyVHlwZXMubGVuZ3RoIC0gMTsKLQkJaWYgKG1heCAhPSAtMSkgewotCQkJLy8gc3RvcCBvbmUgc2hvcnQgb2YgdGhlIGVuZCBvZiB0aGUgYXJyYXkKLQkJCWZvciAoaW50IGkgPSAwOyBpIDwgbWF4OyBpKyspIHsKLQkJCQlzYi5hcHBlbmQocGFyYW1ldGVyVHlwZXNbaV0uZ2V0TmFtZSgpKTsKLQkJCQlzYi5hcHBlbmQoIiwgIik7IC8vJE5PTi1OTFMtMSQKLQkJCX0KLQkJCXNiLmFwcGVuZChwYXJhbWV0ZXJUeXBlc1ttYXhdLmdldE5hbWUoKSk7Ci0JCX0KLQkJc2IuYXBwZW5kKCcpJyk7Ci0JCXJldHVybiBzYi50b1N0cmluZygpOwotCX0KLQkKLQkvKgotCSAqIFJldHVybiBhIHN0cmluZyByZXByZXNlbnRhdGlvbiBvZiB0aGUgc3BlY2lmaWVkIG1ldGhvZC4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBTdHJpbmcgZnVsbHlRdWFsaWZpZWRNZXRob2RTaWduYXR1cmUoT2JqZWN0IHJlY2VpdmVyLCBTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcykgewotCQlyZXR1cm4gZnVsbHlRdWFsaWZpZWRNZXRob2RTaWduYXR1cmUocmVjZWl2ZXIuZ2V0Q2xhc3MoKSwgbWV0aG9kTmFtZSwgcGFyYW1ldGVyVHlwZXMpOwotCX0KLQkKLQkvKioKLQkgKiBHZXQgYSBmaWVsZCB2YWx1ZSwgZ2l2ZW4gdGhlIGNvbnRhaW5pbmcgb2JqZWN0IGFuZCBmaWVsZCBuYW1lLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIFVzZWZ1bCBmb3IgYWNjZXNzaW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBmaWVsZHMuCi0JICogT2JqZWN0I2dldEZpZWxkVmFsdWUoU3RyaW5nIGZpZWxkTmFtZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBmaWVsZFZhbHVlKE9iamVjdCBvYmplY3QsIFN0cmluZyBmaWVsZE5hbWUpIHsKLQkJdHJ5IHsKLQkJCXJldHVybiBhdHRlbXB0VG9HZXRGaWVsZFZhbHVlKG9iamVjdCwgZmllbGROYW1lKTsKLQkJfSBjYXRjaCAoTm9TdWNoRmllbGRFeGNlcHRpb24gbnNmZSkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24obnNmZSArIENSICsgZnVsbHlRdWFsaWZpZWRGaWVsZE5hbWUob2JqZWN0LCBmaWVsZE5hbWUpLCBuc2ZlKTsKLQkJfQotCX0KLQkKLQkvKioKLQkgKiBHZXQgYSBzdGF0aWMgZmllbGQgdmFsdWUsIGdpdmVuIHRoZSBjb250YWluaW5nIGNsYXNzIGFuZCBmaWVsZCBuYW1lLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIFVzZWZ1bCBmb3IgYWNjZXNzaW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBmaWVsZHMuCi0JICogQ2xhc3MjZ2V0U3RhdGljRmllbGRWYWx1ZShTdHJpbmcgZmllbGROYW1lKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IHN0YXRpY0ZpZWxkVmFsdWUoQ2xhc3M8Pz4gamF2YUNsYXNzLCBTdHJpbmcgZmllbGROYW1lKSB7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gYXR0ZW1wdFRvR2V0U3RhdGljRmllbGRWYWx1ZShqYXZhQ2xhc3MsIGZpZWxkTmFtZSk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEZpZWxkRXhjZXB0aW9uIG5zZmUpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKG5zZmUgKyBDUiArIGZ1bGx5UXVhbGlmaWVkRmllbGROYW1lKGphdmFDbGFzcywgZmllbGROYW1lKSwgbnNmZSk7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIEV4ZWN1dGUgYSB6ZXJvLWFyZ3VtZW50IG1ldGhvZCwgZ2l2ZW4gdGhlIHJlY2VpdmVyIGFuZCBtZXRob2QgbmFtZS4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBVc2VmdWwgZm9yIGludm9raW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBtZXRob2RzLgotCSAqIE9iamVjdCNleGVjdXRlKFN0cmluZyBtZXRob2ROYW1lKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IGV4ZWN1dGVNZXRob2QoT2JqZWN0IHJlY2VpdmVyLCBTdHJpbmcgbWV0aG9kTmFtZSkgewotCQlyZXR1cm4gZXhlY3V0ZU1ldGhvZChyZWNlaXZlciwgbWV0aG9kTmFtZSwgWkVST19QQVJBTUVURVJfVFlQRVMsIFpFUk9fUEFSQU1FVEVSUyk7Ci0JfQotCQotCS8qKgotCSAqIEV4ZWN1dGUgYSBtZXRob2QsIGdpdmVuIHRoZSByZWNlaXZlciwKLQkgKiBtZXRob2QgbmFtZSwgcGFyYW1ldGVyIHR5cGVzLCBhbmQgcGFyYW1ldGVycy4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBVc2VmdWwgZm9yIGludm9raW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBtZXRob2RzLgotCSAqIE9iamVjdCNleGVjdXRlKFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzLCBPYmplY3RbXSBwYXJhbWV0ZXJzKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IGV4ZWN1dGVNZXRob2QoT2JqZWN0IHJlY2VpdmVyLCBTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycykgewotCQl0cnkgewotCQkJcmV0dXJuIGF0dGVtcHRUb0V4ZWN1dGVNZXRob2QocmVjZWl2ZXIsIG1ldGhvZE5hbWUsIHBhcmFtZXRlclR5cGVzLCBwYXJhbWV0ZXJzKTsKLQkJfSBjYXRjaCAoTm9TdWNoTWV0aG9kRXhjZXB0aW9uIG5zbWUpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKG5zbWUgKyBDUiArIGZ1bGx5UXVhbGlmaWVkTWV0aG9kU2lnbmF0dXJlKHJlY2VpdmVyLCBtZXRob2ROYW1lLCBwYXJhbWV0ZXJUeXBlcyksIG5zbWUpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBFeGVjdXRlIGEgb25lLWFyZ3VtZW50IG1ldGhvZCwgZ2l2ZW4gdGhlIHJlY2VpdmVyLAotCSAqIG1ldGhvZCBuYW1lLCBwYXJhbWV0ZXIgdHlwZSwgYW5kIHBhcmFtZXRlci4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBVc2VmdWwgZm9yIGludm9raW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBtZXRob2RzLgotCSAqIE9iamVjdCNleGVjdXRlKFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IGV4ZWN1dGVNZXRob2QoT2JqZWN0IHJlY2VpdmVyLCBTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz4gcGFyYW1ldGVyVHlwZSwgT2JqZWN0IHBhcmFtZXRlcikgewotCQlyZXR1cm4gZXhlY3V0ZU1ldGhvZChyZWNlaXZlciwgbWV0aG9kTmFtZSwgbmV3IENsYXNzW10ge3BhcmFtZXRlclR5cGV9LCBuZXcgT2JqZWN0W10ge3BhcmFtZXRlcn0pOwotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogRXhlY3V0ZSBhIHplcm8tYXJndW1lbnQgbWV0aG9kLCBnaXZlbiB0aGUgcmVjZWl2ZXIgYW5kIG1ldGhvZCBuYW1lLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIElmIHRoZSBtZXRob2QgdGhyb3dzIGFuIGV4Y2VwdGlvbiwgcmV0aHJvdyB0aGF0IGV4Y2VwdGlvbi4KLQkgKiBVc2VmdWwgZm9yIGludm9raW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBtZXRob2RzLgotCSAqIE9iamVjdCNleGVjdXRlKFN0cmluZyBtZXRob2ROYW1lKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IGV4ZWN1dGVNZXRob2RXaXRoRXhjZXB0aW9uKE9iamVjdCByZWNlaXZlciwgU3RyaW5nIG1ldGhvZE5hbWUpIAotCQl0aHJvd3MgVGhyb3dhYmxlCi0JewotCQlyZXR1cm4gZXhlY3V0ZU1ldGhvZFdpdGhFeGNlcHRpb24ocmVjZWl2ZXIsIG1ldGhvZE5hbWUsIFpFUk9fUEFSQU1FVEVSX1RZUEVTLCBaRVJPX1BBUkFNRVRFUlMpOwotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogRXhlY3V0ZSBhIG9uZS1hcmd1bWVudCBtZXRob2QsIGdpdmVuIHRoZSByZWNlaXZlciwKLQkgKiBtZXRob2QgbmFtZSwgcGFyYW1ldGVyIHR5cGUsIGFuZCBwYXJhbWV0ZXIuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogSWYgdGhlIG1ldGhvZCB0aHJvd3MgYW4gZXhjZXB0aW9uLCByZXRocm93IHRoYXQgZXhjZXB0aW9uLgotCSAqIFVzZWZ1bCBmb3IgaW52b2tpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIG1ldGhvZHMuCi0JICogT2JqZWN0I2V4ZWN1dGUoU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+IHBhcmFtZXRlclR5cGUsIE9iamVjdCBwYXJhbWV0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgZXhlY3V0ZU1ldGhvZFdpdGhFeGNlcHRpb24oT2JqZWN0IHJlY2VpdmVyLCBTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz4gcGFyYW1ldGVyVHlwZSwgT2JqZWN0IHBhcmFtZXRlcikgCi0JCXRocm93cyBUaHJvd2FibGUKLQl7Ci0JCXJldHVybiBleGVjdXRlTWV0aG9kV2l0aEV4Y2VwdGlvbihyZWNlaXZlciwgbWV0aG9kTmFtZSwgbmV3IENsYXNzW10ge3BhcmFtZXRlclR5cGV9LCBuZXcgT2JqZWN0W10ge3BhcmFtZXRlcn0pOwotCX0KLQkKLQkvKioKLQkgKiBFeGVjdXRlIGEgbWV0aG9kLCBnaXZlbiB0aGUgcmVjZWl2ZXIsCi0JICogbWV0aG9kIG5hbWUsIHBhcmFtZXRlciB0eXBlcywgYW5kIHBhcmFtZXRlcnMuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogSWYgdGhlIG1ldGhvZCB0aHJvd3MgYW4gZXhjZXB0aW9uLCByZXRocm93IHRoYXQgZXhjZXB0aW9uLgotCSAqIFVzZWZ1bCBmb3IgaW52b2tpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIG1ldGhvZHMuCi0JICogT2JqZWN0I2V4ZWN1dGUoU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMsIE9iamVjdFtdIHBhcmFtZXRlcnMpCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgZXhlY3V0ZU1ldGhvZFdpdGhFeGNlcHRpb24oT2JqZWN0IHJlY2VpdmVyLCBTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycykgCi0JCXRocm93cyBUaHJvd2FibGUKLQl7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gYXR0ZW1wdFRvRXhlY3V0ZU1ldGhvZFdpdGhFeGNlcHRpb24ocmVjZWl2ZXIsIG1ldGhvZE5hbWUsIHBhcmFtZXRlclR5cGVzLCBwYXJhbWV0ZXJzKTsKLQkJfSBjYXRjaCAoTm9TdWNoTWV0aG9kRXhjZXB0aW9uIG5zbWUpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKG5zbWUgKyBDUiArIGZ1bGx5UXVhbGlmaWVkTWV0aG9kU2lnbmF0dXJlKHJlY2VpdmVyLCBtZXRob2ROYW1lLCBwYXJhbWV0ZXJUeXBlcyksIG5zbWUpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIEV4ZWN1dGUgdGhlIHNwZWNpZmllZCBtZXRob2Qgd2l0aCB0aGUgc3BlY2lmaWVkIHBhcmFtZXRlcnMuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogQ29udmVydCBleGNlcHRpb25zIHRvIFJ1bnRpbWVFeGNlcHRpb25zLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IGV4ZWN1dGVNZXRob2QoTWV0aG9kIG1ldGhvZCwgT2JqZWN0IHJlY2VpdmVyLCBPYmplY3RbXSBwYXJhbWV0ZXJzKSB7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gbWV0aG9kLmludm9rZShyZWNlaXZlciwgcGFyYW1ldGVycyk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBY2Nlc3NFeGNlcHRpb24gaWFlKSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihpYWUgKyBDUiArIG1ldGhvZCwgaWFlKTsKLQkJfSBjYXRjaCAoSW52b2NhdGlvblRhcmdldEV4Y2VwdGlvbiBpdGUpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKG1ldGhvZCArIENSICsgaXRlLmdldFRhcmdldEV4Y2VwdGlvbigpLCBpdGUpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIEV4ZWN1dGUgdGhlIHNwZWNpZmllZCBtZXRob2Qgd2l0aCB0aGUgc3BlY2lmaWVkIHBhcmFtZXRlcnMuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogSWYgdGhlIG1ldGhvZCB0aHJvd3MgYW4gZXhjZXB0aW9uLCByZXRocm93IHRoYXQgZXhjZXB0aW9uLgotCSAqIENvbnZlcnQgYWxsIG90aGVyIGV4Y2VwdGlvbnMgdG8gUnVudGltZUV4Y2VwdGlvbnMuCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgZXhlY3V0ZU1ldGhvZFdpdGhFeGNlcHRpb24oTWV0aG9kIG1ldGhvZCwgT2JqZWN0IHJlY2VpdmVyLCBPYmplY3RbXSBwYXJhbWV0ZXJzKQotCQl0aHJvd3MgVGhyb3dhYmxlCi0JewotCQl0cnkgewotCQkJcmV0dXJuIG1ldGhvZC5pbnZva2UocmVjZWl2ZXIsIHBhcmFtZXRlcnMpOwotCQl9IGNhdGNoIChJbGxlZ2FsQWNjZXNzRXhjZXB0aW9uIGlhZSkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oaWFlICsgQ1IgKyBtZXRob2QsIGlhZSk7Ci0JCX0gY2F0Y2ggKEludm9jYXRpb25UYXJnZXRFeGNlcHRpb24gaXRlKSB7Ci0JCQlUaHJvd2FibGUgY2F1c2UgPSBpdGUuZ2V0Q2F1c2UoKTsKLQkJCWlmIChjYXVzZSA9PSBudWxsKSB7Ci0JCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24obWV0aG9kLnRvU3RyaW5nKCksIGl0ZSk7Ci0JCQl9Ci0JCQl0aHJvdyBjYXVzZTsKLQkJfQotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogRXhlY3V0ZSBhIHplcm8tYXJndW1lbnQgc3RhdGljIG1ldGhvZCwKLQkgKiBnaXZlbiB0aGUgY2xhc3MgYW5kIG1ldGhvZCBuYW1lLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIFVzZWZ1bCBmb3IgaW52b2tpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIG1ldGhvZHMuCi0JICogQ2xhc3MjZXhlY3V0ZVN0YXRpY01ldGhvZChTdHJpbmcgbWV0aG9kTmFtZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBleGVjdXRlU3RhdGljTWV0aG9kKENsYXNzPD8+IGphdmFDbGFzcywgU3RyaW5nIG1ldGhvZE5hbWUpIHsKLQkJcmV0dXJuIGV4ZWN1dGVTdGF0aWNNZXRob2QoamF2YUNsYXNzLCBtZXRob2ROYW1lLCBaRVJPX1BBUkFNRVRFUl9UWVBFUywgWkVST19QQVJBTUVURVJTKTsKLQl9Ci0JCi0JLyoqCi0JICogRXhlY3V0ZSBhIHN0YXRpYyBtZXRob2QsIGdpdmVuIHRoZSBjbGFzcywKLQkgKiBtZXRob2QgbmFtZSwgcGFyYW1ldGVyIHR5cGVzLCBhbmQgcGFyYW1ldGVycy4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBVc2VmdWwgZm9yIGludm9raW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBtZXRob2RzLgotCSAqIENsYXNzI2V4ZWN1dGVTdGF0aWNNZXRob2QoU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMsIE9iamVjdFtdIHBhcmFtZXRlcnMpCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgZXhlY3V0ZVN0YXRpY01ldGhvZChDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzLCBPYmplY3RbXSBwYXJhbWV0ZXJzKSB7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gYXR0ZW1wdFRvRXhlY3V0ZVN0YXRpY01ldGhvZChqYXZhQ2xhc3MsIG1ldGhvZE5hbWUsIHBhcmFtZXRlclR5cGVzLCBwYXJhbWV0ZXJzKTsKLQkJfSBjYXRjaCAoTm9TdWNoTWV0aG9kRXhjZXB0aW9uIG5zbWUpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKG5zbWUgKyBDUiArIGZ1bGx5UXVhbGlmaWVkTWV0aG9kU2lnbmF0dXJlKGphdmFDbGFzcywgbWV0aG9kTmFtZSwgcGFyYW1ldGVyVHlwZXMpLCBuc21lKTsKLQkJfQotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogRXhlY3V0ZSBhIHN0YXRpYyBtZXRob2QsIGdpdmVuIHRoZSBjbGFzcywKLQkgKiBtZXRob2QgbmFtZSwgcGFyYW1ldGVyIHR5cGUsIGFuZCBwYXJhbWV0ZXIuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogVXNlZnVsIGZvciBpbnZva2luZyBwcml2YXRlLCBwYWNrYWdlLCBvciBwcm90ZWN0ZWQgbWV0aG9kcy4KLQkgKiBDbGFzcyNleGVjdXRlU3RhdGljTWV0aG9kKFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IGV4ZWN1dGVTdGF0aWNNZXRob2QoQ2xhc3M8Pz4gamF2YUNsYXNzLCBTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz4gcGFyYW1ldGVyVHlwZSwgT2JqZWN0IHBhcmFtZXRlcikgewotCQlyZXR1cm4gZXhlY3V0ZVN0YXRpY01ldGhvZChqYXZhQ2xhc3MsIG1ldGhvZE5hbWUsIG5ldyBDbGFzc1tdIHtwYXJhbWV0ZXJUeXBlfSwgbmV3IE9iamVjdFtdIHtwYXJhbWV0ZXJ9KTsKLQl9Ci0JCi0JLyoqCi0JICogRXhlY3V0ZSB0aGUgc3BlY2lmaWVkIHN0YXRpYyBtZXRob2Qgd2l0aCB0aGUgc3BlY2lmaWVkIHBhcmFtZXRlcnMuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogQ29udmVydCBleGNlcHRpb25zIHRvIFJ1bnRpbWVFeGNlcHRpb25zLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IGV4ZWN1dGVTdGF0aWNNZXRob2QoTWV0aG9kIG1ldGhvZCwgT2JqZWN0W10gcGFyYW1ldGVycykgewotCQlyZXR1cm4gZXhlY3V0ZU1ldGhvZChtZXRob2QsIG51bGwsIHBhcmFtZXRlcnMpOwotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogUmV0dXJuIGEgemVyby1hcmd1bWVudCBtZXRob2QgZm9yIHRoZSBzcGVjaWZpZWQgY2xhc3MKLQkgKiBhbmQgbWV0aG9kIG5hbWUuIElmIHRoZSBjbGFzcyBkb2VzIG5vdCBkaXJlY3RseQotCSAqIGltcGxlbWVudCB0aGUgbWV0aG9kLCBsb29rIGZvciBpdCBpbiB0aGUgY2xhc3MncyBzdXBlcmNsYXNzZXMuCi0JICogU2V0IGFjY2Vzc2libGUgdG8gdHJ1ZSwgc28gd2UgY2FuIGFjY2VzcwotCSAqIHByaXZhdGUvcGFja2FnZS9wcm90ZWN0ZWQgbWV0aG9kcy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE1ldGhvZCBtZXRob2QoQ2xhc3M8Pz4gamF2YUNsYXNzLCBTdHJpbmcgbWV0aG9kTmFtZSkgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBtZXRob2QoamF2YUNsYXNzLCBtZXRob2ROYW1lLCBaRVJPX1BBUkFNRVRFUl9UWVBFUyk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiBhIG1ldGhvZCBmb3IgdGhlIHNwZWNpZmllZCBjbGFzcywgbWV0aG9kIG5hbWUsCi0JICogYW5kIGZvcm1hbCBwYXJhbWV0ZXIgdHlwZXMuIElmIHRoZSBjbGFzcyBkb2VzIG5vdCBkaXJlY3RseQotCSAqIGltcGxlbWVudCB0aGUgbWV0aG9kLCBsb29rIGZvciBpdCBpbiB0aGUgY2xhc3MncyBzdXBlcmNsYXNzZXMuCi0JICogU2V0IGFjY2Vzc2libGUgdG8gdHJ1ZSwgc28gd2UgY2FuIGFjY2VzcwotCSAqIHByaXZhdGUvcGFja2FnZS9wcm90ZWN0ZWQgbWV0aG9kcy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE1ldGhvZCBtZXRob2QoQ2xhc3M8Pz4gamF2YUNsYXNzLCBTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCU1ldGhvZCBtZXRob2QgPSBudWxsOwotCQl0cnkgewotCQkJbWV0aG9kID0gamF2YUNsYXNzLmdldERlY2xhcmVkTWV0aG9kKG1ldGhvZE5hbWUsIHBhcmFtZXRlclR5cGVzKTsKLQkJfSBjYXRjaCAoTm9TdWNoTWV0aG9kRXhjZXB0aW9uIGV4KSB7Ci0JCQlDbGFzczw/PiBzdXBlcmNsYXNzID0gamF2YUNsYXNzLmdldFN1cGVyY2xhc3MoKTsKLQkJCWlmIChzdXBlcmNsYXNzID09IG51bGwpIHsKLQkJCQl0aHJvdyBleDsKLQkJCX0KLQkJCS8vIHJlY3Vyc2UKLQkJCXJldHVybiBtZXRob2Qoc3VwZXJjbGFzcywgbWV0aG9kTmFtZSwgcGFyYW1ldGVyVHlwZXMpOwotCQl9Ci0JCW1ldGhvZC5zZXRBY2Nlc3NpYmxlKHRydWUpOwotCQlyZXR1cm4gbWV0aG9kOwotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogUmV0dXJuIGEgbWV0aG9kIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzLCBtZXRob2QgbmFtZSwKLQkgKiBhbmQgZm9ybWFsIHBhcmFtZXRlciB0eXBlLiBJZiB0aGUgY2xhc3MgZG9lcyBub3QgZGlyZWN0bHkKLQkgKiBpbXBsZW1lbnQgdGhlIG1ldGhvZCwgbG9vayBmb3IgaXQgaW4gdGhlIGNsYXNzJ3Mgc3VwZXJjbGFzc2VzLgotCSAqIFNldCBhY2Nlc3NpYmxlIHRvIHRydWUsIHNvIHdlIGNhbiBhY2Nlc3MKLQkgKiBwcml2YXRlL3BhY2thZ2UvcHJvdGVjdGVkIG1ldGhvZHMuCi0JICovCi0JcHVibGljIHN0YXRpYyBNZXRob2QgbWV0aG9kKENsYXNzPD8+IGphdmFDbGFzcywgU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+IHBhcmFtZXRlclR5cGUpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24gewotCQlyZXR1cm4gbWV0aG9kKGphdmFDbGFzcywgbWV0aG9kTmFtZSwgbmV3IENsYXNzW10ge3BhcmFtZXRlclR5cGV9KTsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIFJldHVybiBhIHplcm8tYXJndW1lbnQgbWV0aG9kIGZvciB0aGUgc3BlY2lmaWVkIG9iamVjdAotCSAqIGFuZCBtZXRob2QgbmFtZS4gSWYgdGhlIG9iamVjdCdzIGNsYXNzIGRvZXMgbm90IGRpcmVjdGx5Ci0JICogaW1wbGVtZW50IHRoZSBtZXRob2QsIGxvb2sgZm9yIGl0IGluIHRoZSBjbGFzcydzIHN1cGVyY2xhc3Nlcy4KLQkgKiBTZXQgYWNjZXNzaWJsZSB0byB0cnVlLCBzbyB3ZSBjYW4gYWNjZXNzCi0JICogcHJpdmF0ZS9wYWNrYWdlL3Byb3RlY3RlZCBtZXRob2RzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgTWV0aG9kIG1ldGhvZChPYmplY3Qgb2JqZWN0LCBTdHJpbmcgbWV0aG9kTmFtZSkgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBtZXRob2Qob2JqZWN0LmdldENsYXNzKCksIG1ldGhvZE5hbWUpOwotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogUmV0dXJuIGEgbWV0aG9kIGZvciB0aGUgc3BlY2lmaWVkIG9iamVjdCwgbWV0aG9kIG5hbWUsCi0JICogYW5kIGZvcm1hbCBwYXJhbWV0ZXIgdHlwZXMuIElmIHRoZSBvYmplY3QncyBjbGFzcyBkb2VzIG5vdCBkaXJlY3RseQotCSAqIGltcGxlbWVudCB0aGUgbWV0aG9kLCBsb29rIGZvciBpdCBpbiB0aGUgY2xhc3MncyBzdXBlcmNsYXNzZXMuCi0JICogU2V0IGFjY2Vzc2libGUgdG8gdHJ1ZSwgc28gd2UgY2FuIGFjY2VzcwotCSAqIHByaXZhdGUvcGFja2FnZS9wcm90ZWN0ZWQgbWV0aG9kcy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE1ldGhvZCBtZXRob2QoT2JqZWN0IG9iamVjdCwgU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24gewotCQlyZXR1cm4gbWV0aG9kKG9iamVjdC5nZXRDbGFzcygpLCBtZXRob2ROYW1lLCBwYXJhbWV0ZXJUeXBlcyk7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBSZXR1cm4gYSBtZXRob2QgZm9yIHRoZSBzcGVjaWZpZWQgb2JqZWN0LCBtZXRob2QgbmFtZSwKLQkgKiBhbmQgZm9ybWFsIHBhcmFtZXRlciB0eXBlLiBJZiB0aGUgb2JqZWN0J3MgY2xhc3MgZG9lcyBub3QgZGlyZWN0bHkKLQkgKiBpbXBsZW1lbnQgdGhlIG1ldGhvZCwgbG9vayBmb3IgaXQgaW4gdGhlIGNsYXNzJ3Mgc3VwZXJjbGFzc2VzLgotCSAqIFNldCBhY2Nlc3NpYmxlIHRvIHRydWUsIHNvIHdlIGNhbiBhY2Nlc3MKLQkgKiBwcml2YXRlL3BhY2thZ2UvcHJvdGVjdGVkIG1ldGhvZHMuCi0JICovCi0JcHVibGljIHN0YXRpYyBNZXRob2QgbWV0aG9kKE9iamVjdCBvYmplY3QsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIG1ldGhvZChvYmplY3QuZ2V0Q2xhc3MoKSwgbWV0aG9kTmFtZSwgcGFyYW1ldGVyVHlwZSk7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBSZXR1cm4gdGhlIHNwZWNpZmllZCBjbGFzcyAod2l0aG91dCB0aGUgY2hlY2tlZCBleGNlcHRpb24pLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQ2xhc3M8Pz4gY2xhc3NGb3JOYW1lKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJdHJ5IHsKLQkJCXJldHVybiBDbGFzcy5mb3JOYW1lKGNsYXNzTmFtZSk7Ci0JCX0gY2F0Y2ggKENsYXNzTm90Rm91bmRFeGNlcHRpb24gZXgpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGNsYXNzTmFtZSwgZXgpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBSZXR1cm4gYSBuZXcgaW5zdGFuY2Ugb2YgdGhlIHNwZWNpZmllZCBjbGFzcywKLQkgKiB1c2luZyB0aGUgY2xhc3MncyBkZWZhdWx0ICh6ZXJvLWFyZ3VtZW50KSBjb25zdHJ1Y3Rvci4KLQkgKiBDbGFzcyNuZXdJbnN0YW5jZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyA8VD4gVCBuZXdJbnN0YW5jZShDbGFzczxUPiBqYXZhQ2xhc3MpIHsKLQkJcmV0dXJuIG5ld0luc3RhbmNlKGphdmFDbGFzcywgWkVST19QQVJBTUVURVJfVFlQRVMsIFpFUk9fUEFSQU1FVEVSUyk7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBSZXR1cm4gYSBuZXcgaW5zdGFuY2Ugb2YgdGhlIHNwZWNpZmllZCBjbGFzcywKLQkgKiB1c2luZyB0aGUgY2xhc3MncyBkZWZhdWx0ICh6ZXJvLWFyZ3VtZW50KSBjb25zdHJ1Y3Rvci4KLQkgKiBDbGFzcyNuZXdJbnN0YW5jZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgbmV3SW5zdGFuY2UoU3RyaW5nIGNsYXNzTmFtZSkgdGhyb3dzIENsYXNzTm90Rm91bmRFeGNlcHRpb24gewotCQlyZXR1cm4gbmV3SW5zdGFuY2UoY2xhc3NOYW1lLCBudWxsKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIFJldHVybiBhIG5ldyBpbnN0YW5jZSBvZiB0aGUgc3BlY2lmaWVkIGNsYXNzLAotCSAqIHVzaW5nIHRoZSBjbGFzcydzIGRlZmF1bHQgKHplcm8tYXJndW1lbnQpIGNvbnN0cnVjdG9yLgotCSAqIENsYXNzI25ld0luc3RhbmNlKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBuZXdJbnN0YW5jZShTdHJpbmcgY2xhc3NOYW1lLCBDbGFzc0xvYWRlciBjbGFzc0xvYWRlcikgdGhyb3dzIENsYXNzTm90Rm91bmRFeGNlcHRpb24gewotCQlyZXR1cm4gbmV3SW5zdGFuY2UoQ2xhc3MuZm9yTmFtZShjbGFzc05hbWUsIHRydWUsIGNsYXNzTG9hZGVyKSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBpbnN0YW5jZSBvZiB0aGUgc3BlY2lmaWVkIGNsYXNzLAotCSAqIGdpdmVuIHRoZSBjb25zdHJ1Y3RvciBwYXJhbWV0ZXIgdHlwZXMgYW5kIHBhcmFtZXRlcnMuCi0JICogQ2xhc3MjbmV3SW5zdGFuY2UoQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxUPiBUIG5ld0luc3RhbmNlKENsYXNzPFQ+IGphdmFDbGFzcywgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycykgewotCQl0cnkgewotCQkJcmV0dXJuIGF0dGVtcHROZXdJbnN0YW5jZShqYXZhQ2xhc3MsIHBhcmFtZXRlclR5cGVzLCBwYXJhbWV0ZXJzKTsKLQkJfSBjYXRjaCAoTm9TdWNoTWV0aG9kRXhjZXB0aW9uIG5zbWUpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKG5zbWUgKyBDUiArIGZ1bGx5UXVhbGlmaWVkQ29uc3RydWN0b3JTaWduYXR1cmUoamF2YUNsYXNzLCBwYXJhbWV0ZXJUeXBlcyksIG5zbWUpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBpbnN0YW5jZSBvZiB0aGUgc3BlY2lmaWVkIGNsYXNzLAotCSAqIGdpdmVuIHRoZSBjb25zdHJ1Y3RvciBwYXJhbWV0ZXIgdHlwZXMgYW5kIHBhcmFtZXRlcnMuCi0JICogQ2xhc3MjbmV3SW5zdGFuY2UoQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBuZXdJbnN0YW5jZShTdHJpbmcgY2xhc3NOYW1lLCBDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzLCBPYmplY3RbXSBwYXJhbWV0ZXJzKSB0aHJvd3MgQ2xhc3NOb3RGb3VuZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBuZXdJbnN0YW5jZShjbGFzc05hbWUsIHBhcmFtZXRlclR5cGVzLCBwYXJhbWV0ZXJzLCBudWxsKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIGEgbmV3IGluc3RhbmNlIG9mIHRoZSBzcGVjaWZpZWQgY2xhc3MsCi0JICogZ2l2ZW4gdGhlIGNvbnN0cnVjdG9yIHBhcmFtZXRlciB0eXBlcyBhbmQgcGFyYW1ldGVycy4KLQkgKiBDbGFzcyNuZXdJbnN0YW5jZShDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzLCBPYmplY3RbXSBwYXJhbWV0ZXJzKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IG5ld0luc3RhbmNlKFN0cmluZyBjbGFzc05hbWUsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMsIE9iamVjdFtdIHBhcmFtZXRlcnMsIENsYXNzTG9hZGVyIGNsYXNzTG9hZGVyKSB0aHJvd3MgQ2xhc3NOb3RGb3VuZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBuZXdJbnN0YW5jZShDbGFzcy5mb3JOYW1lKGNsYXNzTmFtZSwgdHJ1ZSwgY2xhc3NMb2FkZXIpLCBwYXJhbWV0ZXJUeXBlcywgcGFyYW1ldGVycyk7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBSZXR1cm4gYSBuZXcgaW5zdGFuY2Ugb2YgdGhlIHNwZWNpZmllZCBjbGFzcywKLQkgKiBnaXZlbiB0aGUgY29uc3RydWN0b3IgcGFyYW1ldGVyIHR5cGUgYW5kIHBhcmFtZXRlci4KLQkgKiBDbGFzcyNuZXdJbnN0YW5jZShDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPFQ+IFQgbmV3SW5zdGFuY2UoQ2xhc3M8VD4gamF2YUNsYXNzLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKSB7Ci0JCXJldHVybiBuZXdJbnN0YW5jZShqYXZhQ2xhc3MsIG5ldyBDbGFzc1tdIHtwYXJhbWV0ZXJUeXBlfSwgbmV3IE9iamVjdFtdIHtwYXJhbWV0ZXJ9KTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIGEgbmV3IGluc3RhbmNlIG9mIHRoZSBzcGVjaWZpZWQgY2xhc3MsCi0JICogZ2l2ZW4gdGhlIGNvbnN0cnVjdG9yIHBhcmFtZXRlciB0eXBlIGFuZCBwYXJhbWV0ZXIuCi0JICogQ2xhc3MjbmV3SW5zdGFuY2UoQ2xhc3M8Pz4gcGFyYW1ldGVyVHlwZSwgT2JqZWN0IHBhcmFtZXRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBuZXdJbnN0YW5jZShTdHJpbmcgY2xhc3NOYW1lLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKSB0aHJvd3MgQ2xhc3NOb3RGb3VuZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBuZXdJbnN0YW5jZShjbGFzc05hbWUsIHBhcmFtZXRlclR5cGUsIHBhcmFtZXRlciwgbnVsbCk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBpbnN0YW5jZSBvZiB0aGUgc3BlY2lmaWVkIGNsYXNzLAotCSAqIGdpdmVuIHRoZSBjb25zdHJ1Y3RvciBwYXJhbWV0ZXIgdHlwZSBhbmQgcGFyYW1ldGVyLgotCSAqIENsYXNzI25ld0luc3RhbmNlKENsYXNzPD8+IHBhcmFtZXRlclR5cGUsIE9iamVjdCBwYXJhbWV0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgbmV3SW5zdGFuY2UoU3RyaW5nIGNsYXNzTmFtZSwgQ2xhc3M8Pz4gcGFyYW1ldGVyVHlwZSwgT2JqZWN0IHBhcmFtZXRlciwgQ2xhc3NMb2FkZXIgY2xhc3NMb2FkZXIpIHRocm93cyBDbGFzc05vdEZvdW5kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIG5ld0luc3RhbmNlKENsYXNzLmZvck5hbWUoY2xhc3NOYW1lLCBmYWxzZSwgY2xhc3NMb2FkZXIpLCBwYXJhbWV0ZXJUeXBlLCBwYXJhbWV0ZXIpOwotCX0KLQkKLQkvKgotCSAqIFB1c2ggdGhlIGRlY2xhcmVkIGZpZWxkcyBmb3IgdGhlIHNwZWNpZmllZCBjbGFzcwotCSAqIG9udG8gdGhlIHRvcCBvZiB0aGUgc3RhY2suCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBwdXNoRGVjbGFyZWRGaWVsZHMoQ2xhc3M8Pz4gamF2YUNsYXNzLCBTdGFjazxGaWVsZD4gc3RhY2spIHsKLQkJRmllbGRbXSBmaWVsZHMgPSBkZWNsYXJlZEZpZWxkcyhqYXZhQ2xhc3MpOwotCQlmb3IgKGludCBpID0gZmllbGRzLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlzdGFjay5wdXNoKGZpZWxkc1tpXSk7Ci0JCX0KLQl9Ci0JCi0JLyoKLQkgKiBQdXNoIHRoZSBkZWNsYXJlZCBtZXRob2RzIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzCi0JICogb250byB0aGUgdG9wIG9mIHRoZSBzdGFjay4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIHB1c2hEZWNsYXJlZE1ldGhvZHMoQ2xhc3M8Pz4gamF2YUNsYXNzLCBTdGFjazxNZXRob2Q+IHN0YWNrKSB7Ci0JCU1ldGhvZFtdIG1ldGhvZHMgPSBkZWNsYXJlZE1ldGhvZHMoamF2YUNsYXNzKTsKLQkJZm9yIChpbnQgaSA9IG1ldGhvZHMubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCXN0YWNrLnB1c2gobWV0aG9kc1tpXSk7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogU2V0IGEgZmllbGQgdmFsdWUsIGdpdmVuIHRoZSBjb250YWluaW5nIG9iamVjdCwgZmllbGQgbmFtZSwgYW5kIG5ldyBmaWVsZCB2YWx1ZS4KLQkgKiBVc2VmdWwgZm9yIGFjY2Vzc2luZyBwcml2YXRlLCBwYWNrYWdlLCBvciBwcm90ZWN0ZWQgZmllbGRzLgotCSAqIE9iamVjdCNzZXRGaWVsZFZhbHVlKFN0cmluZyBmaWVsZE5hbWUsIE9iamVjdCBmaWVsZFZhbHVlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBzZXRGaWVsZFZhbHVlKE9iamVjdCBvYmplY3QsIFN0cmluZyBmaWVsZE5hbWUsIE9iamVjdCBmaWVsZFZhbHVlKSB7Ci0JCXRyeSB7Ci0JCQlhdHRlbXB0VG9TZXRGaWVsZFZhbHVlKG9iamVjdCwgZmllbGROYW1lLCBmaWVsZFZhbHVlKTsKLQkJfSBjYXRjaCAoTm9TdWNoRmllbGRFeGNlcHRpb24gbnNmZSkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24obnNmZSArIENSICsgZnVsbHlRdWFsaWZpZWRGaWVsZE5hbWUob2JqZWN0LCBmaWVsZE5hbWUpLCBuc2ZlKTsKLQkJfQotCX0KLQkKLQkvKioKLQkgKiBTZXQgYSBzdGF0aWMgZmllbGQgdmFsdWUsIGdpdmVuIHRoZSBjb250YWluaW5nIGNsYXNzLCBmaWVsZCBuYW1lLCBhbmQgbmV3IGZpZWxkIHZhbHVlLgotCSAqIFVzZWZ1bCBmb3IgYWNjZXNzaW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBmaWVsZHMuCi0JICogQ2xhc3Mjc2V0U3RhdGljRmllbGRWYWx1ZShTdHJpbmcgZmllbGROYW1lLCBPYmplY3QgZmllbGRWYWx1ZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgc2V0U3RhdGljRmllbGRWYWx1ZShDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBmaWVsZE5hbWUsIE9iamVjdCBmaWVsZFZhbHVlKSB7Ci0JCXRyeSB7Ci0JCQlhdHRlbXB0VG9TZXRTdGF0aWNGaWVsZFZhbHVlKGphdmFDbGFzcywgZmllbGROYW1lLCBmaWVsZFZhbHVlKTsKLQkJfSBjYXRjaCAoTm9TdWNoRmllbGRFeGNlcHRpb24gbnNmZSkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24obnNmZSArIENSICsgZnVsbHlRdWFsaWZpZWRGaWVsZE5hbWUoamF2YUNsYXNzLCBmaWVsZE5hbWUpLCBuc2ZlKTsKLQkJfQotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNob3J0IG5hbWUgb2YgdGhlIG9iamVjdCdzIGNsYXNzLgotCSAqIENsYXNzI2dldFNob3J0TmFtZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgc2hvcnRDbGFzc05hbWVGb3JPYmplY3QoT2JqZWN0IG9iamVjdCkgewotCQlyZXR1cm4gc2hvcnROYW1lRm9yKG9iamVjdC5nZXRDbGFzcygpKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaG9ydCBuYW1lIG9mIHRoZSBjbGFzcyAoZS5nLiAiT2JqZWN0IikuCi0JICogQ2xhc3MjZ2V0U2hvcnROYW1lKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBzaG9ydE5hbWVGb3JDbGFzc05hbWVkKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJcmV0dXJuIGNsYXNzTmFtZS5zdWJzdHJpbmcoY2xhc3NOYW1lLmxhc3RJbmRleE9mKCcuJykgKyAxKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaG9ydCBuYW1lIG9mIHRoZSBjbGFzcyAoZS5nLiAiT2JqZWN0IikuCi0JICogQ2xhc3MjZ2V0U2hvcnROYW1lKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBzaG9ydE5hbWVGb3IoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCXJldHVybiBzaG9ydE5hbWVGb3JDbGFzc05hbWVkKGphdmFDbGFzcy5nZXROYW1lKCkpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIG5lc3RlZCBuYW1lIG9mIHRoZSBvYmplY3QncyBjbGFzcy4KLQkgKiBDbGFzcyNnZXROZXN0ZWROYW1lKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBuZXN0ZWRDbGFzc05hbWVGb3JPYmplY3QoT2JqZWN0IG9iamVjdCkgewotCQlyZXR1cm4gbmVzdGVkTmFtZUZvcihvYmplY3QuZ2V0Q2xhc3MoKSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgbmVzdGVkIG5hbWUgb2YgdGhlIGNsYXNzIChlLmcuICJFbnRyeSIpLgotCSAqIENsYXNzI2dldE5lc3RlZE5hbWUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIG5lc3RlZE5hbWVGb3JDbGFzc05hbWVkKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJcmV0dXJuIGNsYXNzTmFtZS5zdWJzdHJpbmcoY2xhc3NOYW1lLmxhc3RJbmRleE9mKE5FU1RFRF9DTEFTU19OQU1FX1NFUEFSQVRPUikgKyAxKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBuZXN0ZWQgbmFtZSBvZiB0aGUgY2xhc3MgKGUuZy4gIkVudHJ5IikuCi0JICogQ2xhc3MjZ2V0TmVzdGVkTmFtZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgbmVzdGVkTmFtZUZvcihDbGFzczw/PiBqYXZhQ2xhc3MpIHsKLQkJcmV0dXJuIG5lc3RlZE5hbWVGb3JDbGFzc05hbWVkKGphdmFDbGFzcy5nZXROYW1lKCkpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlICJ0b1N0cmluZygpIiBuYW1lIG9mIHRoZSBvYmplY3QncyBjbGFzcy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyB0b1N0cmluZ0NsYXNzTmFtZUZvck9iamVjdChPYmplY3Qgb2JqZWN0KSB7Ci0JCXJldHVybiB0b1N0cmluZ05hbWVGb3Iob2JqZWN0LmdldENsYXNzKCkpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlICJ0b1N0cmluZygpIiBuYW1lIG9mIHRoZSBjbGFzcy4KLQkgKiAiTWVtYmVyIiBjbGFzc2VzIHdpbGwgcmV0dXJuIG9ubHkgdGhlIGZpbmFsIG5hbWU6Ci0JICogICAgICJjb20uZm9vLmJhci5Ub3BMZXZlbENsYXNzJE1lbWJlckNsYXNzJE5lc3RlZE1lbWJlckNsYXNzIgotCSAqICAgICAgICAgPT4gIk5lc3RlZE1lbWJlckNsYXNzIgotCSAqICJMb2NhbCIgYW5kICJhbm9ueW1vdXMiIGNsYXNzZXMgd2lsbCBzdGlsbCByZXR1cm4gdGhlIGVtYmVkZGVkICckJ3M6Ci0JICogICAgICJjb20uZm9vLmJhci5Ub3BMZXZlbENsYXNzJDFMb2NhbENsYXNzIgotCSAqICAgICAgICAgPT4gIlRvcExldmVsQ2xhc3MkMUxvY2FsQ2xhc3MiCi0JICogICAgICJjb20uZm9vLmJhci5Ub3BMZXZlbENsYXNzJDEiCi0JICogICAgICAgICA9PiAiVG9wTGV2ZWxDbGFzcyQxIgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nTmFtZUZvckNsYXNzTmFtZWQoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlyZXR1cm4gY2xhc3NOYW1lZElzTWVtYmVyKGNsYXNzTmFtZSkgPwotCQkJY2xhc3NOYW1lLnN1YnN0cmluZyhjbGFzc05hbWUubGFzdEluZGV4T2YoTkVTVEVEX0NMQVNTX05BTUVfU0VQQVJBVE9SKSArIDEpCi0JCToKLQkJCWNsYXNzTmFtZS5zdWJzdHJpbmcoY2xhc3NOYW1lLmxhc3RJbmRleE9mKCcuJykgKyAxKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSAidG9TdHJpbmcoKSIgbmFtZSBvZiB0aGUgY2xhc3MuCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgdG9TdHJpbmdOYW1lRm9yKENsYXNzPD8+IGphdmFDbGFzcykgewotCQlyZXR1cm4gdG9TdHJpbmdOYW1lRm9yQ2xhc3NOYW1lZChqYXZhQ2xhc3MuZ2V0TmFtZSgpKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBwYWNrYWdlIG5hbWUgb2YgdGhlIGNsYXNzIChlLmcuICJqYXZhLmxhbmciKS4KLQkgKiBDbGFzcyNnZXRQYWNrYWdlTmFtZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgcGFja2FnZU5hbWVGb3IoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCXJldHVybiBwYWNrYWdlTmFtZUZvckNsYXNzTmFtZWQoamF2YUNsYXNzLmdldE5hbWUoKSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgcGFja2FnZSBuYW1lIG9mIHRoZSBjbGFzcyAoZS5nLiAiamF2YS5sYW5nIikuCi0JICogQ2xhc3MjZ2V0UGFja2FnZU5hbWUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHBhY2thZ2VOYW1lRm9yQ2xhc3NOYW1lZChTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCWludCBsYXN0UGVyaW9kID0gY2xhc3NOYW1lLmxhc3RJbmRleE9mKCcuJyk7Ci0JCWlmIChsYXN0UGVyaW9kID09IC0xKSB7Ci0JCQlyZXR1cm4gIiI7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQlyZXR1cm4gY2xhc3NOYW1lLnN1YnN0cmluZygwLCBsYXN0UGVyaW9kKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaG9ydCBuYW1lIG9mIHRoZSBjbGFzcywKLQkgKiBmb2xsb3dlZCBieSBpdHMgcGFja2FnZSBuYW1lIChlLmcuICJPYmplY3QgKGphdmEubGFuZykiKS4KLQkgKiBDbGFzcyNnZXRTaG9ydE5hbWVXaXRoUGFja2FnZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgc2hvcnROYW1lV2l0aFBhY2thZ2UoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigyMDApOwotCQlzYi5hcHBlbmQoc2hvcnROYW1lRm9yKGphdmFDbGFzcykpOwotCQlpZiAoICEgamF2YUNsYXNzLmlzUHJpbWl0aXZlKCkpIHsKLQkJCXNiLmFwcGVuZCgiICgiKTsgLy8kTk9OLU5MUy0xJAotCQkJc2IuYXBwZW5kKHBhY2thZ2VOYW1lRm9yKGphdmFDbGFzcykpOwotCQkJc2IuYXBwZW5kKCcpJyk7Ci0JCX0KLQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBSZXR1cm4gYSB6ZXJvLWFyZ3VtZW50LCBzdGF0aWMgbWV0aG9kIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzCi0JICogYW5kIG1ldGhvZCBuYW1lLiBJZiB0aGUgY2xhc3MgZG9lcyBub3QgZGlyZWN0bHkKLQkgKiBpbXBsZW1lbnQgdGhlIG1ldGhvZCwgbG9vayBmb3IgaXQgaW4gdGhlIGNsYXNzJ3Mgc3VwZXJjbGFzc2VzLgotCSAqIFNldCBhY2Nlc3NpYmxlIHRvIHRydWUsIHNvIHdlIGNhbiBhY2Nlc3MKLQkgKiBwcml2YXRlL3BhY2thZ2UvcHJvdGVjdGVkIG1ldGhvZHMuCi0JICovCi0JcHVibGljIHN0YXRpYyBNZXRob2Qgc3RhdGljTWV0aG9kKENsYXNzPD8+IGphdmFDbGFzcywgU3RyaW5nIG1ldGhvZE5hbWUpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24gewotCQlyZXR1cm4gc3RhdGljTWV0aG9kKGphdmFDbGFzcywgbWV0aG9kTmFtZSwgWkVST19QQVJBTUVURVJfVFlQRVMpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gYSBzdGF0aWMgbWV0aG9kIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzLCBtZXRob2QgbmFtZSwKLQkgKiBhbmQgZm9ybWFsIHBhcmFtZXRlciB0eXBlcy4gSWYgdGhlIGNsYXNzIGRvZXMgbm90IGRpcmVjdGx5Ci0JICogaW1wbGVtZW50IHRoZSBtZXRob2QsIGxvb2sgZm9yIGl0IGluIHRoZSBjbGFzcydzIHN1cGVyY2xhc3Nlcy4KLQkgKiBTZXQgYWNjZXNzaWJsZSB0byB0cnVlLCBzbyB3ZSBjYW4gYWNjZXNzCi0JICogcHJpdmF0ZS9wYWNrYWdlL3Byb3RlY3RlZCBtZXRob2RzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgTWV0aG9kIHN0YXRpY01ldGhvZChDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJTWV0aG9kIG1ldGhvZCA9IG1ldGhvZChqYXZhQ2xhc3MsIG1ldGhvZE5hbWUsIHBhcmFtZXRlclR5cGVzKTsKLQkJaWYgKE1vZGlmaWVyLmlzU3RhdGljKG1ldGhvZC5nZXRNb2RpZmllcnMoKSkpIHsKLQkJCXJldHVybiBtZXRob2Q7Ci0JCX0KLQkJdGhyb3cgbmV3IE5vU3VjaE1ldGhvZEV4Y2VwdGlvbihmdWxseVF1YWxpZmllZE1ldGhvZFNpZ25hdHVyZShqYXZhQ2xhc3MsIG1ldGhvZE5hbWUsIHBhcmFtZXRlclR5cGVzKSk7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBSZXR1cm4gYSBzdGF0aWMgbWV0aG9kIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzLCBtZXRob2QgbmFtZSwKLQkgKiBhbmQgZm9ybWFsIHBhcmFtZXRlciB0eXBlLiBJZiB0aGUgY2xhc3MgZG9lcyBub3QgZGlyZWN0bHkKLQkgKiBpbXBsZW1lbnQgdGhlIG1ldGhvZCwgbG9vayBmb3IgaXQgaW4gdGhlIGNsYXNzJ3Mgc3VwZXJjbGFzc2VzLgotCSAqIFNldCBhY2Nlc3NpYmxlIHRvIHRydWUsIHNvIHdlIGNhbiBhY2Nlc3MKLQkgKiBwcml2YXRlL3BhY2thZ2UvcHJvdGVjdGVkIG1ldGhvZHMuCi0JICovCi0JcHVibGljIHN0YXRpYyBNZXRob2Qgc3RhdGljTWV0aG9kKENsYXNzPD8+IGphdmFDbGFzcywgU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+IHBhcmFtZXRlclR5cGVzKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIHN0YXRpY01ldGhvZChqYXZhQ2xhc3MsIG1ldGhvZE5hbWUsIG5ldyBDbGFzc1tdIHtwYXJhbWV0ZXJUeXBlc30pOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgY2xhc3MgY2FuIGJlICJkZWNsYXJlZCIgaW4gY29kZTsKLQkgKiBpLmUuIGl0IGlzIGVpdGhlciBhICJ0b3AtbGV2ZWwiIGNsYXNzIG9yIGEgIm1lbWJlciIgY2xhc3MsIGJ1dCBpdAotCSAqIGlzIG5vdCBhbiAiYXJyYXkiIGNsYXNzLiBUaGlzIG1ldGhvZCByb2xscyB0b2dldGhlciBhbGwgdGhlIGNoZWNrcwotCSAqIGZyb20gdGhlIG90aGVyIG1ldGhvZHMgZm9yIGEgYml0IG9mIGEgcGVyZm9ybWFuY2UgdHdlYWsuCi0JICogQ2xhc3MjaXNEZWNsYXJhYmxlKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY2xhc3NOYW1lZElzRGVjbGFyYWJsZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCWlmIChjbGFzc05hbWUuY2hhckF0KDApID09IEFSUkFZX0lORElDQVRPUikgewotCQkJcmV0dXJuIGZhbHNlOwkJLy8gaXQgaXMgYW4gImFycmF5IiBjbGFzcwotCQl9Ci0JCWludCBpbmRleCA9IGNsYXNzTmFtZS5pbmRleE9mKE5FU1RFRF9DTEFTU19OQU1FX1NFUEFSQVRPUik7Ci0JCWlmIChpbmRleCA9PSAtMSkgewotCQkJcmV0dXJuIHRydWU7CQkvLyBpdCBpcyBhICJ0b3AtbGV2ZWwiIGNsYXNzCi0JCX0KLQkJZG8gewotCQkJLy8gdGhlIGNoYXJhY3RlciBpbW1lZGlhdGVseSBhZnRlciBlYWNoIGRvbGxhciBzaWduIGNhbm5vdCBiZSBhIGRpZ2l0Ci0JCQlpbmRleCsrOwotCQkJaWYgKENoYXJhY3Rlci5pc0RpZ2l0KGNsYXNzTmFtZS5jaGFyQXQoaW5kZXgpKSkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJCWluZGV4ID0gY2xhc3NOYW1lLmluZGV4T2YoTkVTVEVEX0NMQVNTX05BTUVfU0VQQVJBVE9SLCBpbmRleCk7Ci0JCX0gd2hpbGUgKGluZGV4ICE9IC0xKTsKLQkJcmV0dXJuIHRydWU7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgY2xhc3MgaXMgYSAidG9wLWxldmVsIiBjbGFzcywKLQkgKiBhcyBvcHBvc2VkIHRvIGEgIm1lbWJlciIsICJsb2NhbCIsIG9yICJhbm9ueW1vdXMiIGNsYXNzLAotCSAqIHVzaW5nIHRoZSBzdGFuZGFyZCBqZGsgbmFtaW5nIGNvbnZlbnRpb25zIChpLmUuIHRoZSBjbGFzcwotCSAqIG5hbWUgZG9lcyBOT1QgY29udGFpbiBhICckJzogIlRvcExldmVsQ2xhc3MiKS4KLQkgKiBDbGFzcyNpc1RvcExldmVsKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY2xhc3NOYW1lZElzVG9wTGV2ZWwoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlpZiAoY2xhc3NOYW1lZElzQXJyYXkoY2xhc3NOYW1lKSkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCXJldHVybiBjbGFzc05hbWUuaW5kZXhPZihORVNURURfQ0xBU1NfTkFNRV9TRVBBUkFUT1IpID09IC0xOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgY2xhc3MgaXMgYSAibWVtYmVyIiBjbGFzcywKLQkgKiBhcyBvcHBvc2VkIHRvIGEgInRvcC1sZXZlbCIsICJsb2NhbCIsIG9yICJhbm9ueW1vdXMiIGNsYXNzLAotCSAqIHVzaW5nIHRoZSBzdGFuZGFyZCBqZGsgbmFtaW5nIGNvbnZlbnRpb25zIChpLmUuIHRoZSBjbGFzcwotCSAqIG5hbWUgY29udGFpbnMgYXQgbGVhc3Qgb25lICckJyBhbmQgYWxsIHRoZSBuYW1lcyBiZXR3ZWVuCi0JICogZWFjaCAnJCcgYXJlIGxlZ2FsIGNsYXNzIG5hbWVzOgotCSAqICJUb3BMZXZlbENsYXNzJE1lbWJlckNsYXNzJE5lc3RlZE1lbWJlckNsYXNzIikuCi0JICogQ2xhc3MjaXNNZW1iZXIoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjbGFzc05hbWVkSXNNZW1iZXIoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlpZiAoY2xhc3NOYW1lZElzQXJyYXkoY2xhc3NOYW1lKSkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCWludCBpbmRleCA9IGNsYXNzTmFtZS5pbmRleE9mKE5FU1RFRF9DTEFTU19OQU1FX1NFUEFSQVRPUik7Ci0JCWlmIChpbmRleCA9PSAtMSkgewotCQkJcmV0dXJuIGZhbHNlOwkvLyBpdCBpcyBhICJ0b3AtbGV2ZWwiIGNsYXNzCi0JCX0KLQkJZG8gewotCQkJLy8gdGhlIGNoYXJhY3RlciBpbW1lZGlhdGVseSBhZnRlciBlYWNoIGRvbGxhciBzaWduIGNhbm5vdCBiZSBhIGRpZ2l0Ci0JCQlpbmRleCsrOwotCQkJaWYgKENoYXJhY3Rlci5pc0RpZ2l0KGNsYXNzTmFtZS5jaGFyQXQoaW5kZXgpKSkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJCWluZGV4ID0gY2xhc3NOYW1lLmluZGV4T2YoTkVTVEVEX0NMQVNTX05BTUVfU0VQQVJBVE9SLCBpbmRleCk7Ci0JCX0gd2hpbGUgKGluZGV4ICE9IC0xKTsKLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBjbGFzcyBpcyBhICJsb2NhbCIgY2xhc3MsCi0JICogYXMgb3Bwb3NlZCB0byBhICJ0b3AtbGV2ZWwiLCAibWVtYmVyIiwgb3IgImFub255bW91cyIgY2xhc3MsCi0JICogdXNpbmcgdGhlIHN0YW5kYXJkIGpkayAob3IgRWNsaXBzZSkgbmFtaW5nIGNvbnZlbnRpb25zLgotCSAqIEluIHRoZSBqZGssIHRoZSBjbGFzcyBuYW1lIGVuZHMgd2l0aCAnJG5ublhYWCcgd2hlcmUgdGhlICckJyBpcwotCSAqIGZvbGxvd2VkIGJ5IGEgc2VyaWVzIG9mIG51bWVyaWMgZGlnaXRzIHdoaWNoIGFyZSBmb2xsb3dlZCBieSB0aGUKLQkgKiBsb2NhbCBjbGFzcyBuYW1lOiAiVG9wTGV2ZWxDbGFzcyQxTG9jYWxDbGFzcyIuCi0JICogSW4gRWNsaXBzZSwgdGhlIGNsYXNzIG5hbWUgZW5kcyB3aXRoICckbm5uJFhYWCcgd2hlcmUgdGhlICckJyBpcwotCSAqIGZvbGxvd2VkIGJ5IGEgc2VyaWVzIG9mIG51bWVyaWMgZGlnaXRzIHdoaWNoIGFyZSBzZXBhcmF0ZWQgZnJvbQotCSAqIHRoZSBsb2NhbCBjbGFzcyBuYW1lIGJ5IGFub3RoZXIgJyQnOiAiVG9wTGV2ZWxDbGFzcyQxJExvY2FsQ2xhc3MiLgotCSAqIENsYXNzI2lzTG9jYWwoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjbGFzc05hbWVkSXNMb2NhbChTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCWlmIChjbGFzc05hbWVkSXNBcnJheShjbGFzc05hbWUpKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJaW50IGRvbGxhciA9IGNsYXNzTmFtZS5pbmRleE9mKE5FU1RFRF9DTEFTU19OQU1FX1NFUEFSQVRPUik7Ci0JCWlmIChkb2xsYXIgPT0gLTEpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlpZiAoICEgQ2hhcmFjdGVyLmlzRGlnaXQoY2xhc3NOYW1lLmNoYXJBdChkb2xsYXIgKyAxKSkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlpbnQgbGVuID0gY2xhc3NOYW1lLmxlbmd0aCgpOwotCQlmb3IgKGludCBpID0gZG9sbGFyICsgMjsgaSA8IGxlbjsgaSsrKSB7Ci0JCQlpZiAoQ2hhcmFjdGVyLmlzSmF2YUlkZW50aWZpZXJTdGFydChjbGFzc05hbWUuY2hhckF0KGkpKSkgewotCQkJCXJldHVybiB0cnVlOwotCQkJfQotCQl9Ci0JCS8vIGFsbCB0aGUgY2hhcmFjdGVycyBwYXN0IHRoZSAkIGFyZSBkaWdpdHMgKGFub255bW91cykKLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgY2xhc3MgaXMgYW4gImFub255bW91cyIgY2xhc3MsCi0JICogYXMgb3Bwb3NlZCB0byBhICJ0b3AtbGV2ZWwiLCAibWVtYmVyIiwgb3IgImxvY2FsIiBjbGFzcywKLQkgKiB1c2luZyB0aGUgc3RhbmRhcmQgamRrIG5hbWluZyBjb252ZW50aW9ucyAoaS5lLiB0aGUgY2xhc3MKLQkgKiBuYW1lIGVuZHMgd2l0aCAnJG5ubicgd2hlcmUgYWxsIHRoZSBjaGFyYWN0ZXJzIHBhc3QgdGhlCi0JICogbGFzdCAnJCcgYXJlIG51bWVyaWMgZGlnaXRzOiAiVG9wTGV2ZWxDbGFzcyQxIikuCi0JICogQ2xhc3MjaXNBbm9ueW1vdXMoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjbGFzc05hbWVkSXNBbm9ueW1vdXMoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlpZiAoY2xhc3NOYW1lZElzQXJyYXkoY2xhc3NOYW1lKSkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCWludCBkb2xsYXIgPSBjbGFzc05hbWUuaW5kZXhPZihORVNURURfQ0xBU1NfTkFNRV9TRVBBUkFUT1IpOwotCQlpZiAoZG9sbGFyID09IC0xKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJaW50IHN0YXJ0ID0gZG9sbGFyICsgMTsKLQkJZm9yIChpbnQgaSA9IGNsYXNzTmFtZS5sZW5ndGgoKTsgaS0tID4gc3RhcnQ7ICkgewotCQkJaWYgKCAhIENoYXJhY3Rlci5pc0RpZ2l0KGNsYXNzTmFtZS5jaGFyQXQoaSkpKSB7Ci0JCQkJcmV0dXJuIGZhbHNlOwotCQkJfQotCQl9Ci0JCS8vIGFsbCB0aGUgY2hhcmFjdGVycyBwYXN0IHRoZSAkIGFyZSBkaWdpdHMKLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSAiYXJyYXkgZGVwdGgiIG9mIHRoZSBzcGVjaWZpZWQgY2xhc3MuCi0JICogVGhlIGRlcHRoIGlzIHRoZSBudW1iZXIgb2YgZGltZW5zaW9ucyBmb3IgYW4gYXJyYXkgdHlwZS4KLQkgKiBOb24tYXJyYXkgdHlwZXMgaGF2ZSBhIGRlcHRoIG9mIHplcm8uCi0JICogQ2xhc3MjZ2V0QXJyYXlEZXB0aCgpCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnQgYXJyYXlEZXB0aEZvcihDbGFzczw/PiBqYXZhQ2xhc3MpIHsKLQkJaW50IGRlcHRoID0gMDsKLQkJd2hpbGUgKGphdmFDbGFzcy5pc0FycmF5KCkpIHsKLQkJCWRlcHRoKys7Ci0JCQlqYXZhQ2xhc3MgPSBqYXZhQ2xhc3MuZ2V0Q29tcG9uZW50VHlwZSgpOwotCQl9Ci0JCXJldHVybiBkZXB0aDsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSAiYXJyYXkgZGVwdGgiIG9mIHRoZSBzcGVjaWZpZWQgb2JqZWN0LgotCSAqIFRoZSBkZXB0aCBpcyB0aGUgbnVtYmVyIG9mIGRpbWVuc2lvbnMgZm9yIGFuIGFycmF5LgotCSAqIE5vbi1hcnJheXMgaGF2ZSBhIGRlcHRoIG9mIHplcm8uCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnQgYXJyYXlEZXB0aEZvck9iamVjdChPYmplY3Qgb2JqZWN0KSB7Ci0JCXJldHVybiBhcnJheURlcHRoRm9yKG9iamVjdC5nZXRDbGFzcygpKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSAiYXJyYXkgZGVwdGgiIG9mIHRoZSBzcGVjaWZpZWQgY2xhc3MuCi0JICogVGhlIGRlcHRoIGlzIHRoZSBudW1iZXIgb2YgZGltZW5zaW9ucyBmb3IgYW4gYXJyYXkgdHlwZS4KLQkgKiBOb24tYXJyYXkgdHlwZXMgaGF2ZSBhIGRlcHRoIG9mIHplcm8uCi0JICogQHNlZSBqYXZhLmxhbmcuQ2xhc3MjZ2V0TmFtZSgpCi0JICogQ2xhc3MjZ2V0QXJyYXlEZXB0aCgpCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnQgYXJyYXlEZXB0aEZvckNsYXNzTmFtZWQoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlpbnQgZGVwdGggPSAwOwotCQl3aGlsZSAoY2xhc3NOYW1lLmNoYXJBdChkZXB0aCkgPT0gQVJSQVlfSU5ESUNBVE9SKSB7Ci0JCQlkZXB0aCsrOwotCQl9Ci0JCXJldHVybiBkZXB0aDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGNsYXNzIGlzIGFuIGFycmF5IHR5cGUuCi0JICogQHNlZSBqYXZhLmxhbmcuQ2xhc3MjZ2V0TmFtZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNsYXNzTmFtZWRJc0FycmF5KFN0cmluZyBjbGFzc05hbWUpIHsKLQkJcmV0dXJuIGNsYXNzTmFtZS5jaGFyQXQoMCkgPT0gQVJSQVlfSU5ESUNBVE9SOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgImVsZW1lbnQgdHlwZSIgb2YgdGhlIHNwZWNpZmllZCBjbGFzcy4KLQkgKiBUaGUgZWxlbWVudCB0eXBlIGlzIHRoZSBiYXNlIHR5cGUgaGVsZCBieSBhbiBhcnJheSB0eXBlLgotCSAqIEEgbm9uLWFycmF5IHR5cGUgc2ltcGx5IHJldHVybnMgaXRzZWxmLgotCSAqIENsYXNzI2dldEVsZW1lbnRUeXBlKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIENsYXNzPD8+IGVsZW1lbnRUeXBlRm9yKENsYXNzPD8+IGphdmFDbGFzcykgewotCQl3aGlsZSAoamF2YUNsYXNzLmlzQXJyYXkoKSkgewotCQkJamF2YUNsYXNzID0gamF2YUNsYXNzLmdldENvbXBvbmVudFR5cGUoKTsKLQkJfQotCQlyZXR1cm4gamF2YUNsYXNzOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgImVsZW1lbnQgdHlwZSIgb2YgdGhlIHNwZWNpZmllZCBvYmplY3QuCi0JICogVGhlIGVsZW1lbnQgdHlwZSBpcyB0aGUgYmFzZSB0eXBlIGhlbGQgYnkgYW4gYXJyYXkuCi0JICogQSBub24tYXJyYXkgc2ltcGx5IHJldHVybnMgaXRzIGNsYXNzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQ2xhc3M8Pz4gZWxlbWVudFR5cGVGb3JPYmplY3QoT2JqZWN0IG9iamVjdCkgewotCQlyZXR1cm4gZWxlbWVudFR5cGVGb3Iob2JqZWN0LmdldENsYXNzKCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgImVsZW1lbnQgdHlwZSIgb2YgdGhlIHNwZWNpZmllZCBjbGFzcy4KLQkgKiBUaGUgZWxlbWVudCB0eXBlIGlzIHRoZSBiYXNlIHR5cGUgaGVsZCBieSBhbiBhcnJheSB0eXBlLgotCSAqIE5vbi1hcnJheSB0eXBlcyBzaW1wbHkgcmV0dXJuIHRoZW1zZWx2ZXMuCi0JICogQ2xhc3MjZ2V0RWxlbWVudFR5cGUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGVsZW1lbnRUeXBlTmFtZUZvcihDbGFzczw/PiBqYXZhQ2xhc3MpIHsKLQkJcmV0dXJuIGVsZW1lbnRUeXBlRm9yKGphdmFDbGFzcykuZ2V0TmFtZSgpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgImVsZW1lbnQgdHlwZSIgb2YgdGhlIHNwZWNpZmllZCBjbGFzcy4KLQkgKiBUaGUgZWxlbWVudCB0eXBlIGlzIHRoZSBiYXNlIHR5cGUgaGVsZCBieSBhbiBhcnJheSB0eXBlLgotCSAqIE5vbi1hcnJheSB0eXBlcyBzaW1wbHkgcmV0dXJuIHRoZW1zZWx2ZXMuCi0JICogQHNlZSBqYXZhLmxhbmcuQ2xhc3MjZ2V0TmFtZSgpCi0JICogQ2xhc3MjZ2V0RWxlbWVudFR5cGUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGVsZW1lbnRUeXBlTmFtZUZvckNsYXNzTmFtZWQoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlpbnQgZGVwdGggPSBhcnJheURlcHRoRm9yQ2xhc3NOYW1lZChjbGFzc05hbWUpOwotCQlpZiAoZGVwdGggPT0gMCkgewotCQkJLy8gdGhlIG5hbWUgaXMgaW4gdGhlIGZvcm06ICJqYXZhLmxhbmcuT2JqZWN0IiBvciAiaW50IgotCQkJcmV0dXJuIGNsYXNzTmFtZTsKLQkJfQotCQlpbnQgbGFzdCA9IGNsYXNzTmFtZS5sZW5ndGgoKSAtIDE7Ci0JCWlmIChjbGFzc05hbWUuY2hhckF0KGRlcHRoKSA9PSBSRUZFUkVOQ0VfQ0xBU1NfQ09ERSkgewotCQkJLy8gdGhlIG5hbWUgaXMgaW4gdGhlIGZvcm06ICJbW1tMamF2YS5sYW5nLk9iamVjdDsiCi0JCQlyZXR1cm4gY2xhc3NOYW1lLnN1YnN0cmluZyhkZXB0aCArIDEsIGxhc3QpOwkvLyBkcm9wIHRoZSB0cmFpbGluZyAnOycKLQkJfQotCQkvLyB0aGUgbmFtZSBpcyBpbiB0aGUgZm9ybTogIltbW0kiCi0JCXJldHVybiBjbGFzc05hbWVGb3JDb2RlKGNsYXNzTmFtZS5jaGFyQXQobGFzdCkpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGNsYXNzIGlzIGEgInJlZmVyZW5jZSIKLQkgKiBjbGFzcyAoaS5lLiBuZWl0aGVyICd2b2lkJyBub3Igb25lIG9mIHRoZSBwcmltaXRpdmUgdmFyaWFibGUgY2xhc3NlcywKLQkgKiBbJ2Jvb2xlYW4nLCAnaW50JywgJ2Zsb2F0JywgZXRjLl0pLgotCSAqIE5COiB2b2lkLmNsYXNzLmlzUHJpbWl0aXZlKCkgPT0gdHJ1ZQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjbGFzc05hbWVkSXNSZWZlcmVuY2UoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlyZXR1cm4gISBjbGFzc05hbWVkSXNQcmltaXRpdmUoY2xhc3NOYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGNsYXNzIGlzIGEgcHJpbWl0aXZlCi0JICogY2xhc3MgKGkuZS4gJ3ZvaWQnIG9yIG9uZSBvZiB0aGUgcHJpbWl0aXZlIHZhcmlhYmxlIGNsYXNzZXMsCi0JICogWydib29sZWFuJywgJ2ludCcsICdmbG9hdCcsIGV0Yy5dKS4KLQkgKiBOQjogdm9pZC5jbGFzcy5pc1ByaW1pdGl2ZSgpID09IHRydWUKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY2xhc3NOYW1lZElzUHJpbWl0aXZlKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJaWYgKGNsYXNzTmFtZWRJc0FycmF5KGNsYXNzTmFtZSkgfHwgKGNsYXNzTmFtZS5sZW5ndGgoKSA+IG1heFByaW1pdGl2ZUNsYXNzTmFtZUxlbmd0aCgpKSkgewotCQkJcmV0dXJuIGZhbHNlOyAgLy8gcGVyZm9ybWFuY2UgdHdlYWsKLQkJfQotCQlQcmltaXRpdmVbXSBjb2RlcyA9IHByaW1pdGl2ZXMoKTsKLQkJZm9yIChpbnQgaSA9IGNvZGVzLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlpZiAoY29kZXNbaV0uamF2YUNsYXNzLmdldE5hbWUoKS5lcXVhbHMoY2xhc3NOYW1lKSkgewotCQkJCXJldHVybiB0cnVlOwotCQkJfQotCQl9Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGNsYXNzIGlzIGEgInZhcmlhYmxlIiBwcmltaXRpdmUKLQkgKiBjbGFzcyAoaS5lLiAnYm9vbGVhbicsICdpbnQnLCAnZmxvYXQnLCBldGMuLCBidXQgbm90ICd2b2lkJykuCi0JICogTkI6IHZvaWQuY2xhc3MuaXNQcmltaXRpdmUoKSA9PSB0cnVlCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNsYXNzTmFtZWRJc1ZhcmlhYmxlUHJpbWl0aXZlKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJcmV0dXJuIGNsYXNzTmFtZWRJc1ByaW1pdGl2ZShjbGFzc05hbWUpCi0JCQkmJiAoICEgY2xhc3NOYW1lLmVxdWFscyhWT0lEX0NMQVNTX05BTUUpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGNsYXNzIGlzIGEgcHJpbWl0aXZlIHdyYXBwZXIKLQkgKiBjbGFzcyAoaS5lLiAnamF2YS5sYW5nLlZvaWQnIG9yIG9uZSBvZiB0aGUgcHJpbWl0aXZlIHZhcmlhYmxlIHdyYXBwZXIgY2xhc3NlcywKLQkgKiBbJ2phdmEubGFuZy5Cb29sZWFuJywgJ2phdmEubGFuZy5JbnRlZ2VyJywgJ2phdmEubGFuZy5GbG9hdCcsIGV0Yy5dKS4KLQkgKiBOQjogdm9pZC5jbGFzcy5pc1ByaW1pdGl2ZSgpID09IHRydWUKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY2xhc3NOYW1lZElzUHJpbWl0aXZlV3JhcHBlckNsYXNzKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJaWYgKGNsYXNzTmFtZWRJc0FycmF5KGNsYXNzTmFtZSkgfHwgKGNsYXNzTmFtZS5sZW5ndGgoKSA+IG1heFByaW1pdGl2ZVdyYXBwZXJDbGFzc05hbWVMZW5ndGgoKSkpIHsKLQkJCXJldHVybiBmYWxzZTsgIC8vIHBlcmZvcm1hbmNlIHR3ZWFrCi0JCX0KLQkJUHJpbWl0aXZlW10gY29kZXMgPSBwcmltaXRpdmVzKCk7Ci0JCWZvciAoaW50IGkgPSBjb2Rlcy5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJaWYgKGNvZGVzW2ldLndyYXBwZXJDbGFzcy5nZXROYW1lKCkuZXF1YWxzKGNsYXNzTmFtZSkpIHsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBjbGFzcyBpcyBhICJ2YXJpYWJsZSIgcHJpbWl0aXZlCi0JICogY2xhc3MgKGkuZS4gJ2Jvb2xlYW4nLCAnaW50JywgJ2Zsb2F0JywgZXRjLiwgYnV0IG5vdCAndm9pZCcpLgotCSAqIE5COiB2b2lkLmNsYXNzLmlzUHJpbWl0aXZlKCkgPT0gdHJ1ZQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjbGFzc05hbWVkSXNWYXJpYWJsZVByaW1pdGl2ZVdyYXBwZXJDbGFzcyhTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCXJldHVybiBjbGFzc05hbWVkSXNQcmltaXRpdmVXcmFwcGVyQ2xhc3MoY2xhc3NOYW1lKQotCQkJJiYgKCAhIGNsYXNzTmFtZS5lcXVhbHMoVk9JRF9XUkFQUEVSX0NMQVNTX05BTUUpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGNsYXNzIGlzIGEgcHJpbWl0aXZlIHdyYXBwZXIKLQkgKiBjbGFzcyAoaS5lLiAnamF2YS5sYW5nLlZvaWQnIG9yIG9uZSBvZiB0aGUgcHJpbWl0aXZlIHZhcmlhYmxlIHdyYXBwZXIgY2xhc3NlcywKLQkgKiBbJ2phdmEubGFuZy5Cb29sZWFuJywgJ2phdmEubGFuZy5JbnRlZ2VyJywgJ2phdmEubGFuZy5GbG9hdCcsIGV0Yy5dKS4KLQkgKiBOQjogdm9pZC5jbGFzcy5pc1ByaW1pdGl2ZSgpID09IHRydWUKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY2xhc3NJc1ByaW1pdGl2ZVdyYXBwZXJDbGFzcyhDbGFzczw/PiBqYXZhQ2xhc3MpIHsKLQkJaWYgKGphdmFDbGFzcy5pc0FycmF5KCkgfHwgKGphdmFDbGFzcy5nZXROYW1lKCkubGVuZ3RoKCkgPiBtYXhQcmltaXRpdmVXcmFwcGVyQ2xhc3NOYW1lTGVuZ3RoKCkpKSB7Ci0JCQlyZXR1cm4gZmFsc2U7ICAvLyBwZXJmb3JtYW5jZSB0d2VhawotCQl9Ci0JCVByaW1pdGl2ZVtdIGNvZGVzID0gcHJpbWl0aXZlcygpOwotCQlmb3IgKGludCBpID0gY29kZXMubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCWlmIChjb2Rlc1tpXS53cmFwcGVyQ2xhc3MgPT0gamF2YUNsYXNzKSB7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgY2xhc3MgaXMgYSAidmFyaWFibGUiIHByaW1pdGl2ZQotCSAqIGNsYXNzIChpLmUuICdib29sZWFuJywgJ2ludCcsICdmbG9hdCcsIGV0Yy4sIGJ1dCBub3QgJ3ZvaWQnKS4KLQkgKiBOQjogdm9pZC5jbGFzcy5pc1ByaW1pdGl2ZSgpID09IHRydWUKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY2xhc3NJc1ZhcmlhYmxlUHJpbWl0aXZlV3JhcHBlckNsYXNzKENsYXNzPD8+IGphdmFDbGFzcykgewotCQlyZXR1cm4gY2xhc3NJc1ByaW1pdGl2ZVdyYXBwZXJDbGFzcyhqYXZhQ2xhc3MpCi0JCQkmJiAoamF2YUNsYXNzICE9IGphdmEubGFuZy5Wb2lkLmNsYXNzKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNsYXNzIG5hbWUgZm9yIHRoZSBzcGVjaWZpZWQgY2xhc3MgY29kZS4KLQkgKiBAc2VlIGphdmEubGFuZy5DbGFzcyNnZXROYW1lKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBjbGFzc05hbWVGb3JDb2RlKGNoYXIgY2xhc3NDb2RlKSB7Ci0JCXJldHVybiBjbGFzc0ZvckNvZGUoY2xhc3NDb2RlKS5nZXROYW1lKCk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgY2xhc3MgbmFtZSBmb3IgdGhlIHNwZWNpZmllZCBjbGFzcyBjb2RlLgotCSAqIEBzZWUgamF2YS5sYW5nLkNsYXNzI2dldE5hbWUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGNsYXNzTmFtZUZvckNvZGUoaW50IGNsYXNzQ29kZSkgewotCQlyZXR1cm4gY2xhc3NOYW1lRm9yQ29kZSgoY2hhcikgY2xhc3NDb2RlKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjbGFzcyBmb3IgdGhlIHNwZWNpZmllZCBjbGFzcyBjb2RlLgotCSAqIEBzZWUgamF2YS5sYW5nLkNsYXNzI2dldE5hbWUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgQ2xhc3M8Pz4gY2xhc3NGb3JDb2RlKGNoYXIgY2xhc3NDb2RlKSB7Ci0JCVByaW1pdGl2ZVtdIGNvZGVzID0gcHJpbWl0aXZlcygpOwotCQlmb3IgKGludCBpID0gY29kZXMubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCWlmIChjb2Rlc1tpXS5jb2RlID09IGNsYXNzQ29kZSkgewotCQkJCXJldHVybiBjb2Rlc1tpXS5qYXZhQ2xhc3M7Ci0JCQl9Ci0JCX0KLQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbihTdHJpbmcudmFsdWVPZihjbGFzc0NvZGUpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNsYXNzIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzIGNvZGUuCi0JICogQHNlZSBqYXZhLmxhbmcuQ2xhc3MjZ2V0TmFtZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBDbGFzczw/PiBjbGFzc0ZvckNvZGUoaW50IGNsYXNzQ29kZSkgewotCQlyZXR1cm4gY2xhc3NGb3JDb2RlKChjaGFyKSBjbGFzc0NvZGUpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNsYXNzIGNvZGUgZm9yIHRoZSBzcGVjaWZpZWQgY2xhc3MuCi0JICogQHNlZSBqYXZhLmxhbmcuQ2xhc3MjZ2V0TmFtZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyIGNvZGVGb3JDbGFzcyhDbGFzczw/PiBqYXZhQ2xhc3MpIHsKLQkJaWYgKCggISBqYXZhQ2xhc3MuaXNBcnJheSgpKSAmJiAoamF2YUNsYXNzLmdldE5hbWUoKS5sZW5ndGgoKSA8PSBtYXhQcmltaXRpdmVDbGFzc05hbWVMZW5ndGgoKSkpIHsKLQkJCVByaW1pdGl2ZVtdIGNvZGVzID0gcHJpbWl0aXZlcygpOwotCQkJZm9yIChpbnQgaSA9IGNvZGVzLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQkJaWYgKGNvZGVzW2ldLmphdmFDbGFzcyA9PSBqYXZhQ2xhc3MpIHsKLQkJCQkJcmV0dXJuIGNvZGVzW2ldLmNvZGU7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oamF2YUNsYXNzLmdldE5hbWUoKSk7CQkKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjbGFzcyBjb2RlIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzLgotCSAqIEBzZWUgamF2YS5sYW5nLkNsYXNzI2dldE5hbWUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhciBjb2RlRm9yQ2xhc3NOYW1lZChTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCWlmICgoICEgY2xhc3NOYW1lZElzQXJyYXkoY2xhc3NOYW1lKSkgJiYgKGNsYXNzTmFtZS5sZW5ndGgoKSA8PSBtYXhQcmltaXRpdmVDbGFzc05hbWVMZW5ndGgoKSkpIHsKLQkJCVByaW1pdGl2ZVtdIGNvZGVzID0gcHJpbWl0aXZlcygpOwotCQkJZm9yIChpbnQgaSA9IGNvZGVzLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQkJaWYgKGNvZGVzW2ldLmphdmFDbGFzcy5nZXROYW1lKCkuZXF1YWxzKGNsYXNzTmFtZSkpIHsKLQkJCQkJcmV0dXJuIGNvZGVzW2ldLmNvZGU7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oY2xhc3NOYW1lKTsJCQotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgY2xhc3MgZm9yIHRoZSBzcGVjaWZpZWQgInR5cGUgZGVjbGFyYXRpb24iLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQ2xhc3M8Pz4gY2xhc3NGb3JUeXBlRGVjbGFyYXRpb24oU3RyaW5nIHR5cGVEZWNsYXJhdGlvbikgdGhyb3dzIENsYXNzTm90Rm91bmRFeGNlcHRpb24gewotCQlyZXR1cm4gY2xhc3NGb3JUeXBlRGVjbGFyYXRpb24odHlwZURlY2xhcmF0aW9uLCBudWxsKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjbGFzcyBmb3IgdGhlIHNwZWNpZmllZCAidHlwZSBkZWNsYXJhdGlvbiIsCi0JICogdXNpbmcgdGhlIHNwZWNpZmllZCBjbGFzcyBsb2FkZXIuCi0JICovCi0JcHVibGljIHN0YXRpYyBDbGFzczw/PiBjbGFzc0ZvclR5cGVEZWNsYXJhdGlvbihTdHJpbmcgdHlwZURlY2xhcmF0aW9uLCBDbGFzc0xvYWRlciBjbGFzc0xvYWRlcikgdGhyb3dzIENsYXNzTm90Rm91bmRFeGNlcHRpb24gewotCQlUeXBlRGVjbGFyYXRpb24gdGQgPSB0eXBlRGVjbGFyYXRpb24odHlwZURlY2xhcmF0aW9uKTsKLQkJcmV0dXJuIGNsYXNzRm9yVHlwZURlY2xhcmF0aW9uKHRkLmVsZW1lbnRUeXBlTmFtZSwgdGQuYXJyYXlEZXB0aCwgY2xhc3NMb2FkZXIpOwotCX0KLQotCXByaXZhdGUgc3RhdGljIFR5cGVEZWNsYXJhdGlvbiB0eXBlRGVjbGFyYXRpb24oU3RyaW5nIHR5cGVEZWNsYXJhdGlvbikgewotCQl0eXBlRGVjbGFyYXRpb24gPSBTdHJpbmdUb29scy5yZW1vdmVBbGxXaGl0ZXNwYWNlKHR5cGVEZWNsYXJhdGlvbik7Ci0JCWludCBhcnJheURlcHRoID0gYXJyYXlEZXB0aEZvclR5cGVEZWNsYXJhdGlvbl8odHlwZURlY2xhcmF0aW9uKTsKLQkJU3RyaW5nIGVsZW1lbnRUeXBlTmFtZSA9IGVsZW1lbnRUeXBlTmFtZUZvclR5cGVEZWNsYXJhdGlvbl8odHlwZURlY2xhcmF0aW9uLCBhcnJheURlcHRoKTsKLQkJcmV0dXJuIG5ldyBUeXBlRGVjbGFyYXRpb24oZWxlbWVudFR5cGVOYW1lLCBhcnJheURlcHRoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNsYXNzIGZvciB0aGUgc3BlY2lmaWVkICJ0eXBlIGRlY2xhcmF0aW9uIi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIENsYXNzPD8+IGNsYXNzRm9yVHlwZURlY2xhcmF0aW9uKFN0cmluZyBlbGVtZW50VHlwZU5hbWUsIGludCBhcnJheURlcHRoKSB0aHJvd3MgQ2xhc3NOb3RGb3VuZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBjbGFzc0ZvclR5cGVEZWNsYXJhdGlvbihlbGVtZW50VHlwZU5hbWUsIGFycmF5RGVwdGgsIG51bGwpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNsYXNzIGZvciB0aGUgc3BlY2lmaWVkICJ0eXBlIGRlY2xhcmF0aW9uIiwKLQkgKiB1c2luZyB0aGUgc3BlY2lmaWVkIGNsYXNzIGxvYWRlci4KLQkgKi8KLQkvLyBzZWUgdGhlICJFdmFsdWF0aW9uIiBvZiBqZGsgYnVnIDY0NDY2MjcgZm9yIGEgZGlzY3Vzc2lvbiBvZiBsb2FkaW5nIGNsYXNzZXMKLQlwdWJsaWMgc3RhdGljIENsYXNzPD8+IGNsYXNzRm9yVHlwZURlY2xhcmF0aW9uKFN0cmluZyBlbGVtZW50VHlwZU5hbWUsIGludCBhcnJheURlcHRoLCBDbGFzc0xvYWRlciBjbGFzc0xvYWRlcikgdGhyb3dzIENsYXNzTm90Rm91bmRFeGNlcHRpb24gewotCQkvLyBwcmltaXRpdmVzIGNhbm5vdCBiZSBsb2FkZWQgdmlhIENsYXNzI2Zvck5hbWUoKSwKLQkJLy8gc28gY2hlY2sgZm9yIGEgcHJpbWl0aXZlIGNsYXNzIG5hbWUgZmlyc3QKLQkJUHJpbWl0aXZlIHBjYyA9IG51bGw7Ci0JCWlmIChlbGVtZW50VHlwZU5hbWUubGVuZ3RoKCkgPD0gbWF4UHJpbWl0aXZlQ2xhc3NOYW1lTGVuZ3RoKCkpIHsgIC8vIHBlcmZvcm1hbmNlIHR3ZWFrCi0JCQlQcmltaXRpdmVbXSBjb2RlcyA9IHByaW1pdGl2ZXMoKTsKLQkJCWZvciAoaW50IGkgPSBjb2Rlcy5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJCWlmIChjb2Rlc1tpXS5qYXZhQ2xhc3MuZ2V0TmFtZSgpLmVxdWFscyhlbGVtZW50VHlwZU5hbWUpKSB7Ci0JCQkJCXBjYyA9IGNvZGVzW2ldOwotCQkJCQlicmVhazsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQotCQkvLyBub24tYXJyYXkKLQkJaWYgKGFycmF5RGVwdGggPT0gMCkgewotCQkJcmV0dXJuIChwY2MgPT0gbnVsbCkgPyBDbGFzcy5mb3JOYW1lKGVsZW1lbnRUeXBlTmFtZSwgZmFsc2UsIGNsYXNzTG9hZGVyKSA6IHBjYy5qYXZhQ2xhc3M7Ci0JCX0KLQotCQkvLyBhcnJheQotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoMTAwKTsKLQkJZm9yIChpbnQgaSA9IGFycmF5RGVwdGg7IGktLSA+IDA7ICkgewotCQkJc2IuYXBwZW5kKEFSUkFZX0lORElDQVRPUik7Ci0JCX0KLQkJaWYgKHBjYyA9PSBudWxsKSB7Ci0JCQlzYi5hcHBlbmQoUkVGRVJFTkNFX0NMQVNTX0NPREUpOwotCQkJc2IuYXBwZW5kKGVsZW1lbnRUeXBlTmFtZSk7Ci0JCQlzYi5hcHBlbmQoUkVGRVJFTkNFX0NMQVNTX05BTUVfREVMSU1JVEVSKTsKLQkJfSBlbHNlIHsKLQkJCXNiLmFwcGVuZChwY2MuY29kZSk7Ci0JCX0KLQkJcmV0dXJuIENsYXNzLmZvck5hbWUoc2IudG9TdHJpbmcoKSwgZmFsc2UsIGNsYXNzTG9hZGVyKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjbGFzcyBuYW1lIGZvciB0aGUgc3BlY2lmaWVkICJ0eXBlIGRlY2xhcmF0aW9uIjsgZS5nLgotCSAqICAgICAiaW50W10iIC0+ICJbSSIKLQkgKiBAc2VlIGphdmEubGFuZy5DbGFzcyNnZXROYW1lKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBjbGFzc05hbWVGb3JUeXBlRGVjbGFyYXRpb24oU3RyaW5nIHR5cGVEZWNsYXJhdGlvbikgewotCQlUeXBlRGVjbGFyYXRpb24gdGQgPSB0eXBlRGVjbGFyYXRpb24odHlwZURlY2xhcmF0aW9uKTsKLQkJcmV0dXJuIGNsYXNzTmFtZUZvclR5cGVEZWNsYXJhdGlvbih0ZC5lbGVtZW50VHlwZU5hbWUsIHRkLmFycmF5RGVwdGgpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgZGVwdGggZm9yIHRoZSBzcGVjaWZpZWQgInR5cGUgZGVjbGFyYXRpb24iOyBlLmcuCi0JICogICAgICJpbnRbXSIgLT4gMQotCSAqICAgICAiamF2YS5sYW5nLlN0cmluZ1tdW11bXSIgLT4gMwotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50IGFycmF5RGVwdGhGb3JUeXBlRGVjbGFyYXRpb24oU3RyaW5nIHR5cGVEZWNsYXJhdGlvbikgewotCQlyZXR1cm4gYXJyYXlEZXB0aEZvclR5cGVEZWNsYXJhdGlvbl8oU3RyaW5nVG9vbHMucmVtb3ZlQWxsV2hpdGVzcGFjZSh0eXBlRGVjbGFyYXRpb24pKTsKLQl9Ci0KLQkvKgotCSAqIEFzc3VtZSBubyB3aGl0ZXNwYWNlIGluIHRoZSB0eXBlIGRlY2xhcmF0aW9uLgotCSAqLwotCXByaXZhdGUgc3RhdGljIGludCBhcnJheURlcHRoRm9yVHlwZURlY2xhcmF0aW9uXyhTdHJpbmcgdHlwZURlY2xhcmF0aW9uKSB7Ci0JCWludCBsYXN0ID0gdHlwZURlY2xhcmF0aW9uLmxlbmd0aCgpIC0gMTsKLQkJaW50IGRlcHRoID0gMDsKLQkJaW50IGNsb3NlID0gbGFzdDsKLQkJd2hpbGUgKHR5cGVEZWNsYXJhdGlvbi5jaGFyQXQoY2xvc2UpID09IFRZUEVfREVDTEFSQVRJT05fQVJSQVlfQ0xPU0UpIHsKLQkJCWlmICh0eXBlRGVjbGFyYXRpb24uY2hhckF0KGNsb3NlIC0gMSkgPT0gVFlQRV9ERUNMQVJBVElPTl9BUlJBWV9PUEVOKSB7Ci0JCQkJZGVwdGgrKzsKLQkJCX0gZWxzZSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiaW52YWxpZCB0eXBlIGRlY2xhcmF0aW9uOiAiICsgdHlwZURlY2xhcmF0aW9uKTsgLy8kTk9OLU5MUy0xJAotCQkJfQotCQkJY2xvc2UgPSBsYXN0IC0gKGRlcHRoICogMik7Ci0JCX0KLQkJcmV0dXJuIGRlcHRoOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIGVsZW1lbnQgdHlwZSBuYW1lIGZvciB0aGUgc3BlY2lmaWVkICJ0eXBlIGRlY2xhcmF0aW9uIjsgZS5nLgotCSAqICAgICAiaW50W10iIC0+ICJpbnQiCi0JICogICAgICJqYXZhLmxhbmcuU3RyaW5nW11bXVtdIiAtPiAiamF2YS5sYW5nLlN0cmluZyIKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBlbGVtZW50VHlwZU5hbWVGb3JUeXBlRGVjbGFyYXRpb24oU3RyaW5nIHR5cGVEZWNsYXJhdGlvbikgewotCQl0eXBlRGVjbGFyYXRpb24gPSBTdHJpbmdUb29scy5yZW1vdmVBbGxXaGl0ZXNwYWNlKHR5cGVEZWNsYXJhdGlvbik7Ci0JCXJldHVybiBlbGVtZW50VHlwZU5hbWVGb3JUeXBlRGVjbGFyYXRpb25fKHR5cGVEZWNsYXJhdGlvbiwgYXJyYXlEZXB0aEZvclR5cGVEZWNsYXJhdGlvbl8odHlwZURlY2xhcmF0aW9uKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBlbGVtZW50IHR5cGUgbmFtZSBmb3IgdGhlIHNwZWNpZmllZCAidHlwZSBkZWNsYXJhdGlvbiI7IGUuZy4KLQkgKiAgICAgImludFtdIiAtPiAiaW50IgotCSAqICAgICAiamF2YS5sYW5nLlN0cmluZ1tdW11bXSIgLT4gImphdmEubGFuZy5TdHJpbmciCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgZWxlbWVudFR5cGVOYW1lRm9yVHlwZURlY2xhcmF0aW9uKFN0cmluZyB0eXBlRGVjbGFyYXRpb24sIGludCBhcnJheURlcHRoKSB7Ci0JCXJldHVybiBlbGVtZW50VHlwZU5hbWVGb3JUeXBlRGVjbGFyYXRpb25fKFN0cmluZ1Rvb2xzLnJlbW92ZUFsbFdoaXRlc3BhY2UodHlwZURlY2xhcmF0aW9uKSwgYXJyYXlEZXB0aCk7Ci0JfQotCi0JLyoKLQkgKiBBc3N1bWUgbm8gd2hpdGVzcGFjZSBpbiB0aGUgdHlwZSBkZWNsYXJhdGlvbi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBlbGVtZW50VHlwZU5hbWVGb3JUeXBlRGVjbGFyYXRpb25fKFN0cmluZyB0eXBlRGVjbGFyYXRpb24sIGludCBhcnJheURlcHRoKSB7Ci0JCXJldHVybiB0eXBlRGVjbGFyYXRpb24uc3Vic3RyaW5nKDAsIHR5cGVEZWNsYXJhdGlvbi5sZW5ndGgoKSAtIChhcnJheURlcHRoICogMikpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgY2xhc3MgbmFtZSBmb3IgdGhlIHNwZWNpZmllZCAidHlwZSBkZWNsYXJhdGlvbiIuCi0JICogQHNlZSBqYXZhLmxhbmcuQ2xhc3MjZ2V0TmFtZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY2xhc3NOYW1lRm9yVHlwZURlY2xhcmF0aW9uKFN0cmluZyBlbGVtZW50VHlwZU5hbWUsIGludCBhcnJheURlcHRoKSB7Ci0JCS8vIG5vbi1hcnJheQotCQlpZiAoYXJyYXlEZXB0aCA9PSAwKSB7Ci0JCQlyZXR1cm4gZWxlbWVudFR5cGVOYW1lOwotCQl9Ci0KLQkJaWYgKGVsZW1lbnRUeXBlTmFtZS5lcXVhbHMoVk9JRF9DTEFTU19OQU1FKSkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbignXCcnICsgVk9JRF9DTEFTU19OQU1FICsgIicgbXVzdCBoYXZlIGFuIGFycmF5IGRlcHRoIG9mIHplcm86ICIgKyBhcnJheURlcHRoICsgJy4nKTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCS8vIGFycmF5Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigxMDApOwotCQlmb3IgKGludCBpID0gYXJyYXlEZXB0aDsgaS0tID4gMDsgKSB7Ci0JCQlzYi5hcHBlbmQoQVJSQVlfSU5ESUNBVE9SKTsKLQkJfQotCi0JCS8vIGxvb2sgZm9yIGEgcHJpbWl0aXZlIGZpcnN0Ci0JCVByaW1pdGl2ZSBwY2MgPSBudWxsOwotCQlpZiAoZWxlbWVudFR5cGVOYW1lLmxlbmd0aCgpIDw9IG1heFByaW1pdGl2ZUNsYXNzTmFtZUxlbmd0aCgpKSB7ICAvLyBwZXJmb3JtYW5jZSB0d2VhawotCQkJUHJpbWl0aXZlW10gY29kZXMgPSBwcmltaXRpdmVzKCk7Ci0JCQlmb3IgKGludCBpID0gY29kZXMubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCQlpZiAoY29kZXNbaV0uamF2YUNsYXNzLmdldE5hbWUoKS5lcXVhbHMoZWxlbWVudFR5cGVOYW1lKSkgewotCQkJCQlwY2MgPSBjb2Rlc1tpXTsKLQkJCQkJYnJlYWs7Ci0JCQkJfQotCQkJfQotCQl9Ci0KLQkJaWYgKHBjYyA9PSBudWxsKSB7Ci0JCQlzYi5hcHBlbmQoUkVGRVJFTkNFX0NMQVNTX0NPREUpOwotCQkJc2IuYXBwZW5kKGVsZW1lbnRUeXBlTmFtZSk7Ci0JCQlzYi5hcHBlbmQoUkVGRVJFTkNFX0NMQVNTX05BTUVfREVMSU1JVEVSKTsKLQkJfSBlbHNlIHsKLQkJCXNiLmFwcGVuZChwY2MuY29kZSk7Ci0JCX0KLQotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogcHJpbWl0aXZlIGNvbnN0YW50cyAqKioqKioqKioqCi0KLQlwcml2YXRlIHN5bmNocm9uaXplZCBzdGF0aWMgaW50IG1heFByaW1pdGl2ZUNsYXNzTmFtZUxlbmd0aCgpIHsKLQkJaWYgKE1BWF9QUklNSVRJVkVfQ0xBU1NfTkFNRV9MRU5HVEggPT0gLTEpIHsKLQkJCU1BWF9QUklNSVRJVkVfQ0xBU1NfTkFNRV9MRU5HVEggPSBjYWxjdWxhdGVNYXhQcmltaXRpdmVDbGFzc05hbWVMZW5ndGgoKTsKLQkJfQotCQlyZXR1cm4gTUFYX1BSSU1JVElWRV9DTEFTU19OQU1FX0xFTkdUSDsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBpbnQgY2FsY3VsYXRlTWF4UHJpbWl0aXZlQ2xhc3NOYW1lTGVuZ3RoKCkgewotCQlpbnQgbWF4ID0gLTE7Ci0JCVByaW1pdGl2ZVtdIGNvZGVzID0gcHJpbWl0aXZlcygpOwotCQlmb3IgKGludCBpID0gY29kZXMubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCWludCBsZW4gPSBjb2Rlc1tpXS5qYXZhQ2xhc3MuZ2V0TmFtZSgpLmxlbmd0aCgpOwotCQkJaWYgKGxlbiA+IG1heCkgewotCQkJCW1heCA9IGxlbjsKLQkJCX0KLQkJfQotCQlyZXR1cm4gbWF4OwotCX0KLQotCXByaXZhdGUgc3luY2hyb25pemVkIHN0YXRpYyBpbnQgbWF4UHJpbWl0aXZlV3JhcHBlckNsYXNzTmFtZUxlbmd0aCgpIHsKLQkJaWYgKE1BWF9QUklNSVRJVkVfV1JBUFBFUl9DTEFTU19OQU1FX0xFTkdUSCA9PSAtMSkgewotCQkJTUFYX1BSSU1JVElWRV9XUkFQUEVSX0NMQVNTX05BTUVfTEVOR1RIID0gY2FsY3VsYXRlTWF4UHJpbWl0aXZlV3JhcHBlckNsYXNzTmFtZUxlbmd0aCgpOwotCQl9Ci0JCXJldHVybiBNQVhfUFJJTUlUSVZFX1dSQVBQRVJfQ0xBU1NfTkFNRV9MRU5HVEg7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgaW50IGNhbGN1bGF0ZU1heFByaW1pdGl2ZVdyYXBwZXJDbGFzc05hbWVMZW5ndGgoKSB7Ci0JCWludCBtYXggPSAtMTsKLQkJUHJpbWl0aXZlW10gY29kZXMgPSBwcmltaXRpdmVzKCk7Ci0JCWZvciAoaW50IGkgPSBjb2Rlcy5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJaW50IGxlbiA9IGNvZGVzW2ldLndyYXBwZXJDbGFzcy5nZXROYW1lKCkubGVuZ3RoKCk7Ci0JCQlpZiAobGVuID4gbWF4KSB7Ci0JCQkJbWF4ID0gbGVuOwotCQkJfQotCQl9Ci0JCXJldHVybiBtYXg7Ci0JfQotCi0JcHJpdmF0ZSBzeW5jaHJvbml6ZWQgc3RhdGljIFByaW1pdGl2ZVtdIHByaW1pdGl2ZXMoKSB7Ci0JCWlmIChQUklNSVRJVkVTID09IG51bGwpIHsKLQkJCVBSSU1JVElWRVMgPSBidWlsZFByaW1pdGl2ZXMoKTsKLQkJfQotCQlyZXR1cm4gUFJJTUlUSVZFUzsKLQl9Ci0JCi0JLyoqCi0JICogTkI6IHZvaWQuY2xhc3MuaXNQcmltaXRpdmUoKSA9PSB0cnVlCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgUHJpbWl0aXZlW10gYnVpbGRQcmltaXRpdmVzKCkgewotCQlQcmltaXRpdmVbXSByZXN1bHQgPSBuZXcgUHJpbWl0aXZlWzldOwotCQlyZXN1bHRbMF0gPSBuZXcgUHJpbWl0aXZlKEJZVEVfQ09ERSwgamF2YS5sYW5nLkJ5dGUuY2xhc3MpOwotCQlyZXN1bHRbMV0gPSBuZXcgUHJpbWl0aXZlKENIQVJfQ09ERSwgamF2YS5sYW5nLkNoYXJhY3Rlci5jbGFzcyk7Ci0JCXJlc3VsdFsyXSA9IG5ldyBQcmltaXRpdmUoRE9VQkxFX0NPREUsIGphdmEubGFuZy5Eb3VibGUuY2xhc3MpOwotCQlyZXN1bHRbM10gPSBuZXcgUHJpbWl0aXZlKEZMT0FUX0NPREUsIGphdmEubGFuZy5GbG9hdC5jbGFzcyk7Ci0JCXJlc3VsdFs0XSA9IG5ldyBQcmltaXRpdmUoSU5UX0NPREUsIGphdmEubGFuZy5JbnRlZ2VyLmNsYXNzKTsKLQkJcmVzdWx0WzVdID0gbmV3IFByaW1pdGl2ZShMT05HX0NPREUsIGphdmEubGFuZy5Mb25nLmNsYXNzKTsKLQkJcmVzdWx0WzZdID0gbmV3IFByaW1pdGl2ZShTSE9SVF9DT0RFLCBqYXZhLmxhbmcuU2hvcnQuY2xhc3MpOwotCQlyZXN1bHRbN10gPSBuZXcgUHJpbWl0aXZlKEJPT0xFQU5fQ09ERSwgamF2YS5sYW5nLkJvb2xlYW4uY2xhc3MpOwotCQlyZXN1bHRbOF0gPSBuZXcgUHJpbWl0aXZlKFZPSURfQ09ERSwgamF2YS5sYW5nLlZvaWQuY2xhc3MpOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBtZW1iZXIgY2xhc3NlcyAqKioqKioqKioqCi0KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBQcmltaXRpdmUgewotCQlmaW5hbCBjaGFyIGNvZGU7Ci0JCWZpbmFsIENsYXNzPD8+IGphdmFDbGFzczsKLQkJZmluYWwgQ2xhc3M8Pz4gd3JhcHBlckNsYXNzOwotCQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgV1JBUFBFUl9DTEFTU19UWVBFX0ZJRUxEX05BTUUgPSAiVFlQRSI7IC8vJE5PTi1OTFMtMSQKLQkJLy8gZS5nLiBqYXZhLmxhbmcuQm9vbGVhbi5UWVBFID0+IGJvb2xlYW4uY2xhc3MKLQkJUHJpbWl0aXZlKGNoYXIgY29kZSwgQ2xhc3M8Pz4gd3JhcHBlckNsYXNzKSB7Ci0JCQl0aGlzLmNvZGUgPSBjb2RlOwotCQkJdGhpcy53cmFwcGVyQ2xhc3MgPSB3cmFwcGVyQ2xhc3M7Ci0JCQl0aGlzLmphdmFDbGFzcyA9IChDbGFzczw/Pikgc3RhdGljRmllbGRWYWx1ZSh3cmFwcGVyQ2xhc3MsIFdSQVBQRVJfQ0xBU1NfVFlQRV9GSUVMRF9OQU1FKTsKLQkJfQotCX0KLQotCXByaXZhdGUgc3RhdGljIGNsYXNzIFR5cGVEZWNsYXJhdGlvbiB7Ci0JCWZpbmFsIFN0cmluZyBlbGVtZW50VHlwZU5hbWU7Ci0JCWZpbmFsIGludCBhcnJheURlcHRoOwotCQlUeXBlRGVjbGFyYXRpb24oU3RyaW5nIGVsZW1lbnRUeXBlTmFtZSwgaW50IGFycmF5RGVwdGgpIHsKLQkJCXRoaXMuZWxlbWVudFR5cGVOYW1lID0gZWxlbWVudFR5cGVOYW1lOwotCQkJdGhpcy5hcnJheURlcHRoID0gYXJyYXlEZXB0aDsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBzdXBwcmVzc2VkIGNvbnN0cnVjdG9yICoqKioqKioqKioKLQotCS8qKgotCSAqIFN1cHByZXNzIGRlZmF1bHQgY29uc3RydWN0b3IsIGVuc3VyaW5nIG5vbi1pbnN0YW50aWFiaWxpdHkuCi0JICovCi0JcHJpdmF0ZSBDbGFzc1Rvb2xzKCkgewotCQlzdXBlcigpOwotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9DbGFzc3BhdGguamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9DbGFzc3BhdGguamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggM2Y3ZGIyZC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvQ2xhc3NwYXRoLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw5MTEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uRmlsZTsKLWltcG9ydCBqYXZhLmlvLkZpbGVGaWx0ZXI7Ci1pbXBvcnQgamF2YS5pby5JT0V4Y2VwdGlvbjsKLWltcG9ydCBqYXZhLmlvLlNlcmlhbGl6YWJsZTsKLWltcG9ydCBqYXZhLm5ldC5VUklTeW50YXhFeGNlcHRpb247Ci1pbXBvcnQgamF2YS5uZXQuVVJMOwotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkVudW1lcmF0aW9uOwotaW1wb3J0IGphdmEudXRpbC5IYXNoU2V0OwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuemlwLlppcEVudHJ5OwotaW1wb3J0IGphdmEudXRpbC56aXAuWmlwRmlsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5GaWx0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkFycmF5SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkNvbXBvc2l0ZUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5FbXB0eUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5GaWx0ZXJpbmdJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuVHJhbnNmb3JtYXRpb25JdGVyYXRvcjsKLQotLyoqCi0gKiBUT0RPCi0gKi8KLXB1YmxpYyBjbGFzcyBDbGFzc3BhdGgKLQlpbXBsZW1lbnRzIFNlcmlhbGl6YWJsZQotewotCS8qKiBUaGUgZW50cmllcyBpbiB0aGUgY2xhc3NwYXRoICovCi0JcHJpdmF0ZSBmaW5hbCBFbnRyeVtdIGVudHJpZXM7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCi0JLy8gKioqKioqKioqKiBzdGF0aWMgbWV0aG9kcyAqKioqKioqKioqCi0KLQkvLyAqKioqKiBmYWN0b3J5IG1ldGhvZHMgZm9yICJzdGFuZGFyZCIgY2xhc3NwYXRocyAqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBKYXZhICJib290IiBjbGFzc3BhdGguIFRoaXMgaW5jbHVkZXMgcnQuamFyLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQ2xhc3NwYXRoIGJvb3RDbGFzc3BhdGgoKSB7Ci0JCXJldHVybiBuZXcgQ2xhc3NwYXRoKFN5c3RlbS5nZXRQcm9wZXJ0eSgic3VuLmJvb3QuY2xhc3MucGF0aCIpKTsgLy8kTk9OLU5MUy0xJAotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gYSAidmlydHVhbCBjbGFzc3BhdGgiIHRoYXQgY29udGFpbnMgYWxsIHRoZSBqYXJzCi0JICogdGhhdCB3b3VsZCBiZSB1c2VkIGJ5IHRoZSBKYXZhIEV4dGVuc2lvbiBNZWNoYW5pc20uCi0JICovCi0JcHVibGljIHN0YXRpYyBDbGFzc3BhdGggamF2YUV4dGVuc2lvbkNsYXNzcGF0aCgpIHsKLQkJRmlsZVtdIGRpcnMgPSBqYXZhRXh0ZW5zaW9uRGlyZWN0b3JpZXMoKTsKLQkJTGlzdDxTdHJpbmc+IGphckZpbGVOYW1lcyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlmb3IgKEZpbGUgZGlyIDogZGlycykgewotCQkJaWYgKGRpci5pc0RpcmVjdG9yeSgpKSB7Ci0JCQkJYWRkSmFyRmlsZU5hbWVzVG8oZGlyLCBqYXJGaWxlTmFtZXMpOwotCQkJfQotCQl9Ci0JCXJldHVybiBuZXcgQ2xhc3NwYXRoKGphckZpbGVOYW1lcyk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBKYXZhICJzeXN0ZW0iIGNsYXNzcGF0aC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIENsYXNzcGF0aCBqYXZhQ2xhc3NwYXRoKCkgewotCQlyZXR1cm4gbmV3IENsYXNzcGF0aChTeXN0ZW0uZ2V0UHJvcGVydHkoImphdmEuY2xhc3MucGF0aCIpKTsgLy8kTk9OLU5MUy0xJAotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgdW5yZXRvdWNoZWQgImNvbXBsZXRlIiBjbGFzc3BhdGguCi0JICogVGhpcyBpbmNsdWRlcyB0aGUgYm9vdCBjbGFzc3BhdGgsIHRoZSBKYXZhIEV4dGVuc2lvbgotCSAqIE1lY2hhbmlzbSBjbGFzc3BhdGgsIGFuZCB0aGUgbm9ybWFsICJzeXN0ZW0iIGNsYXNzcGF0aC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIENsYXNzcGF0aCBjb21wbGV0ZUNsYXNzcGF0aCgpIHsKLQkJcmV0dXJuIG5ldyBDbGFzc3BhdGgobmV3IENsYXNzcGF0aFtdIHsKLQkJCQlib290Q2xhc3NwYXRoKCksCi0JCQkJamF2YUV4dGVuc2lvbkNsYXNzcGF0aCgpLAotCQkJCWphdmFDbGFzc3BhdGgoKQotCQl9KTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBjbGFzc3BhdGggdGhhdCBjb250YWlucyB0aGUgbG9jYXRpb24gb2YgdGhlIHNwZWNpZmllZCBjbGFzcy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIENsYXNzcGF0aCBjbGFzc3BhdGhGb3IoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCXJldHVybiBuZXcgQ2xhc3NwYXRoKGxvY2F0aW9uRm9yKGphdmFDbGFzcykpOwotCX0KLQotCi0JLy8gKioqKiogZmlsZSA9PiBjbGFzcyAqKioqKgotCi0JLyoqCi0JICogQ29udmVydCBhIHJlbGF0aXZlIGZpbGUgbmFtZSB0byBhIGNsYXNzIG5hbWU7IHRoaXMgd2lsbCB3b3JrIGZvcgotCSAqIGFueSBmaWxlIHRoYXQgaGFzIGEgc2luZ2xlIGV4dGVuc2lvbiBiZXlvbmQgdGhlIGJhc2UKLQkgKiBjbGFzcyBuYW1lLgotCSAqIGUuZy4gImphdmEvbGFuZy9TdHJpbmcuY2xhc3MiIGlzIGNvbnZlcnRlZCB0byAiamF2YS5sYW5nLlN0cmluZyIKLQkgKiBlLmcuICJqYXZhL2xhbmcvU3RyaW5nLmphdmEiIGlzIGNvbnZlcnRlZCB0byAiamF2YS5sYW5nLlN0cmluZyIKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBjb252ZXJ0VG9DbGFzc05hbWUoU3RyaW5nIGNsYXNzRmlsZU5hbWUpIHsKLQkJU3RyaW5nIGNsYXNzTmFtZSA9IEZpbGVUb29scy5zdHJpcEV4dGVuc2lvbihjbGFzc0ZpbGVOYW1lKTsKLQkJLy8gZG8gdGhpcyBmb3IgYXJjaGl2ZSBlbnRyeSBuYW1lcwotCQljbGFzc05hbWUgPSBjbGFzc05hbWUucmVwbGFjZSgnLycsICcuJyk7Ci0JCS8vIGRvIHRoaXMgZm9yIE8vUy1zcGVjaWZpYyBmaWxlIG5hbWVzCi0JCWlmIChGaWxlLnNlcGFyYXRvckNoYXIgIT0gJy8nKSB7Ci0JCQljbGFzc05hbWUgPSBjbGFzc05hbWUucmVwbGFjZShGaWxlLnNlcGFyYXRvckNoYXIsICcuJyk7Ci0JCX0KLQkJcmV0dXJuIGNsYXNzTmFtZTsKLQl9Ci0KLQkvKioKLQkgKiBDb252ZXJ0IGEgZmlsZSB0byBhIGNsYXNzIG5hbWU7Ci0JICogZS5nLiBGaWxlKGphdmEvbGFuZy9TdHJpbmcuY2xhc3MpIGlzIGNvbnZlcnRlZCB0byAiamF2YS5sYW5nLlN0cmluZyIKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBjb252ZXJ0VG9DbGFzc05hbWUoRmlsZSBjbGFzc0ZpbGUpIHsKLQkJcmV0dXJuIGNvbnZlcnRUb0NsYXNzTmFtZShjbGFzc0ZpbGUuZ2V0UGF0aCgpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb252ZXJ0IGEgcmVsYXRpdmUgZmlsZSBuYW1lIHRvIGEgY2xhc3M7Ci0JICogZS5nLiAiamF2YS9sYW5nL1N0cmluZy5jbGFzcyIgaXMgY29udmVydGVkIHRvIGphdmEubGFuZy5TdHJpbmcuY2xhc3MKLQkgKi8KLQlwdWJsaWMgc3RhdGljIENsYXNzPD8+IGNvbnZlcnRUb0NsYXNzKFN0cmluZyBjbGFzc0ZpbGVOYW1lKSB0aHJvd3MgQ2xhc3NOb3RGb3VuZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBDbGFzcy5mb3JOYW1lKGNvbnZlcnRUb0NsYXNzTmFtZShjbGFzc0ZpbGVOYW1lKSk7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCBhIHJlbGF0aXZlIGZpbGUgdG8gYSBjbGFzczsKLQkgKiBlLmcuIEZpbGUoamF2YS9sYW5nL1N0cmluZy5jbGFzcykgaXMgY29udmVydGVkIHRvIGphdmEubGFuZy5TdHJpbmcuY2xhc3MKLQkgKi8KLQlwdWJsaWMgc3RhdGljIENsYXNzPD8+IGNvbnZlcnRUb0NsYXNzKEZpbGUgY2xhc3NGaWxlKSB0aHJvd3MgQ2xhc3NOb3RGb3VuZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBjb252ZXJ0VG9DbGFzcyhjbGFzc0ZpbGUuZ2V0UGF0aCgpKTsKLQl9Ci0KLQotCS8vICoqKioqIGNsYXNzID0+IEpBUiBlbnRyeSAqKioqKgotCi0JLyoqCi0JICogQ29udmVydCBhIGNsYXNzIG5hbWUgdG8gYW4gYXJjaGl2ZSBlbnRyeSBuYW1lIGJhc2U7Ci0JICogZS5nLiAiamF2YS5sYW5nLlN0cmluZyIgaXMgY29udmVydGVkIHRvICJqYXZhL2xhbmcvU3RyaW5nIgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGNvbnZlcnRUb0FyY2hpdmVFbnRyeU5hbWVCYXNlKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJcmV0dXJuIGNsYXNzTmFtZS5yZXBsYWNlKCcuJywgJy8nKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVydCBhIGNsYXNzIHRvIGFuIGFyY2hpdmUgZW50cnkgbmFtZSBiYXNlOwotCSAqIGUuZy4gamF2YS5sYW5nLlN0cmluZy5jbGFzcyBpcyBjb252ZXJ0ZWQgdG8gImphdmEvbGFuZy9TdHJpbmciCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY29udmVydFRvQXJjaGl2ZUVudHJ5TmFtZUJhc2UoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCXJldHVybiBjb252ZXJ0VG9BcmNoaXZlRW50cnlOYW1lQmFzZShqYXZhQ2xhc3MuZ2V0TmFtZSgpKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVydCBhIGNsYXNzIG5hbWUgdG8gYW4gYXJjaGl2ZSBjbGFzcyBmaWxlIGVudHJ5IG5hbWU7Ci0JICogZS5nLiAiamF2YS5sYW5nLlN0cmluZyIgaXMgY29udmVydGVkIHRvICJqYXZhL2xhbmcvU3RyaW5nLmNsYXNzIgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGNvbnZlcnRUb0FyY2hpdmVDbGFzc0ZpbGVFbnRyeU5hbWUoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlyZXR1cm4gY29udmVydFRvQXJjaGl2ZUVudHJ5TmFtZUJhc2UoY2xhc3NOYW1lKSArICIuY2xhc3MiOyAvLyROT04tTkxTLTEkCi0JfQotCQotCS8qKgotCSAqIENvbnZlcnQgYSBjbGFzcyB0byBhbiBhcmNoaXZlIGNsYXNzIGZpbGUgZW50cnkgbmFtZTsKLQkgKiBlLmcuIGphdmEubGFuZy5TdHJpbmcuY2xhc3MgaXMgY29udmVydGVkIHRvICJqYXZhL2xhbmcvU3RyaW5nLmNsYXNzIgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGNvbnZlcnRUb0FyY2hpdmVDbGFzc0ZpbGVFbnRyeU5hbWUoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCXJldHVybiBjb252ZXJ0VG9BcmNoaXZlQ2xhc3NGaWxlRW50cnlOYW1lKGphdmFDbGFzcy5nZXROYW1lKCkpOwotCX0KLQkKLQotCS8vICoqKioqIGNsYXNzID0+IGZpbGUgKC5jbGFzcyBvciAuamF2YSkgKioqKioKLQotCS8qKgotCSAqIENvbnZlcnQgYSBjbGFzcyBuYW1lIHRvIGEgZmlsZSBuYW1lIGJhc2UgZm9yIHRoZSBjdXJyZW50IE8vUzsKLQkgKiBlLmcuICJqYXZhLmxhbmcuU3RyaW5nIiBpcyBjb252ZXJ0ZWQgdG8gImphdmEvbGFuZy9TdHJpbmciIG9uIFVuaXgKLQkgKiBhbmQgImphdmFcXGxhbmdcXFN0cmluZyIgb24gV2luZG93cwotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGNvbnZlcnRUb0ZpbGVOYW1lQmFzZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCXJldHVybiBjbGFzc05hbWUucmVwbGFjZSgnLicsIEZpbGUuc2VwYXJhdG9yQ2hhcik7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlcnQgYSBjbGFzcyB0byBhIGZpbGUgbmFtZSBiYXNlIGZvciB0aGUgY3VycmVudCBPL1M7Ci0JICogZS5nLiBqYXZhLmxhbmcuU3RyaW5nLmNsYXNzIGlzIGNvbnZlcnRlZCB0byAiamF2YS9sYW5nL1N0cmluZyIgb24gVW5peAotCSAqIGFuZCAiamF2YVxcbGFuZ1xcU3RyaW5nIiBvbiBXaW5kb3dzCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY29udmVydFRvRmlsZU5hbWVCYXNlKENsYXNzPD8+IGphdmFDbGFzcykgewotCQlyZXR1cm4gY29udmVydFRvRmlsZU5hbWVCYXNlKGphdmFDbGFzcy5nZXROYW1lKCkpOwotCX0KLQkKLQkvKioKLQkgKiBDb252ZXJ0IGEgY2xhc3MgbmFtZSB0byBhIGNsYXNzIGZpbGUgbmFtZSBmb3IgdGhlIGN1cnJlbnQgTy9TOwotCSAqIGUuZy4gImphdmEubGFuZy5TdHJpbmciIGlzIGNvbnZlcnRlZCB0byAiamF2YS9sYW5nL1N0cmluZy5jbGFzcyIgb24gVW5peAotCSAqIGFuZCAiamF2YVxcbGFuZ1xcU3RyaW5nLmNsYXNzIiBvbiBXaW5kb3dzCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY29udmVydFRvQ2xhc3NGaWxlTmFtZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCXJldHVybiBjb252ZXJ0VG9GaWxlTmFtZUJhc2UoY2xhc3NOYW1lKSArICIuY2xhc3MiOyAvLyROT04tTkxTLTEkCi0JfQotCQotCS8qKgotCSAqIENvbnZlcnQgYSBjbGFzcyB0byBhIGNsYXNzIGZpbGUgbmFtZSBmb3IgdGhlIGN1cnJlbnQgTy9TOwotCSAqIGUuZy4gamF2YS5sYW5nLlN0cmluZy5jbGFzcyBpcyBjb252ZXJ0ZWQgdG8gImphdmEvbGFuZy9TdHJpbmcuY2xhc3MiIG9uIFVuaXgKLQkgKiBhbmQgImphdmFcXGxhbmdcXFN0cmluZy5jbGFzcyIgb24gV2luZG93cwotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGNvbnZlcnRUb0NsYXNzRmlsZU5hbWUoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCXJldHVybiBjb252ZXJ0VG9DbGFzc0ZpbGVOYW1lKGphdmFDbGFzcy5nZXROYW1lKCkpOwotCX0KLQkKLQkvKioKLQkgKiBDb252ZXJ0IGEgY2xhc3MgbmFtZSB0byBhIGNsYXNzIGZpbGUgZm9yIHRoZSBjdXJyZW50IE8vUzsKLQkgKiBlLmcuICJqYXZhLmxhbmcuU3RyaW5nIiBpcyBjb252ZXJ0ZWQgdG8gRmlsZShqYXZhL2xhbmcvU3RyaW5nLmNsYXNzKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgRmlsZSBjb252ZXJ0VG9DbGFzc0ZpbGUoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlyZXR1cm4gbmV3IEZpbGUoY29udmVydFRvQ2xhc3NGaWxlTmFtZShjbGFzc05hbWUpKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVydCBhIGNsYXNzIHRvIGEgY2xhc3MgZmlsZSBmb3IgdGhlIGN1cnJlbnQgTy9TOwotCSAqIGUuZy4gamF2YS5sYW5nLlN0cmluZy5jbGFzcyBpcyBjb252ZXJ0ZWQgdG8gRmlsZShqYXZhL2xhbmcvU3RyaW5nLmNsYXNzKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgRmlsZSBjb252ZXJ0VG9DbGFzc0ZpbGUoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCXJldHVybiBjb252ZXJ0VG9DbGFzc0ZpbGUoamF2YUNsYXNzLmdldE5hbWUoKSk7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlcnQgYSBjbGFzcyBuYW1lIHRvIGEgamF2YSBmaWxlIG5hbWUgZm9yIHRoZSBjdXJyZW50IE8vUzsKLQkgKiBlLmcuICJqYXZhLmxhbmcuU3RyaW5nIiBpcyBjb252ZXJ0ZWQgdG8gImphdmEvbGFuZy9TdHJpbmcuamF2YSIgb24gVW5peAotCSAqIGFuZCAiamF2YVxcbGFuZ1xcU3RyaW5nLmphdmEiIG9uIFdpbmRvd3MKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBjb252ZXJ0VG9KYXZhRmlsZU5hbWUoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlyZXR1cm4gY29udmVydFRvRmlsZU5hbWVCYXNlKGNsYXNzTmFtZSkgKyAiLmphdmEiOyAvLyROT04tTkxTLTEkCi0JfQotCi0JLyoqCi0JICogQ29udmVydCBhIGNsYXNzIHRvIGEgamF2YSBmaWxlIG5hbWUgZm9yIHRoZSBjdXJyZW50IE8vUzsKLQkgKiBlLmcuIGphdmEubGFuZy5TdHJpbmcuY2xhc3MgaXMgY29udmVydGVkIHRvICJqYXZhL2xhbmcvU3RyaW5nLmphdmEiIG9uIFVuaXgKLQkgKiBhbmQgImphdmFcXGxhbmdcXFN0cmluZy5qYXZhIiBvbiBXaW5kb3dzCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY29udmVydFRvSmF2YUZpbGVOYW1lKENsYXNzPD8+IGphdmFDbGFzcykgewotCQlyZXR1cm4gY29udmVydFRvSmF2YUZpbGVOYW1lKGphdmFDbGFzcy5nZXROYW1lKCkpOwotCX0KLQotCS8qKgotCSAqIENvbnZlcnQgYSBjbGFzcyBuYW1lIHRvIGEgamF2YSBmaWxlIGZvciB0aGUgY3VycmVudCBPL1M7Ci0JICogZS5nLiAiamF2YS5sYW5nLlN0cmluZyIgaXMgY29udmVydGVkIHRvIEZpbGUoamF2YS9sYW5nL1N0cmluZy5qYXZhKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgRmlsZSBjb252ZXJ0VG9KYXZhRmlsZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCXJldHVybiBuZXcgRmlsZShjb252ZXJ0VG9KYXZhRmlsZU5hbWUoY2xhc3NOYW1lKSk7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCBhIGNsYXNzIHRvIGEgamF2YSBmaWxlIGZvciB0aGUgY3VycmVudCBPL1M7Ci0JICogZS5nLiBqYXZhLmxhbmcuU3RyaW5nLmNsYXNzIGlzIGNvbnZlcnRlZCB0byBGaWxlKGphdmEvbGFuZy9TdHJpbmcuamF2YSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIEZpbGUgY29udmVydFRvSmF2YUZpbGUoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCXJldHVybiBjb252ZXJ0VG9KYXZhRmlsZShqYXZhQ2xhc3MuZ2V0TmFtZSgpKTsKLQl9Ci0KLQotCS8vICoqKioqIGNsYXNzID0+IHJlc291cmNlICoqKioqCi0KLQkvKioKLQkgKiBDb252ZXJ0IGEgY2xhc3MgdG8gYSByZXNvdXJjZSBuYW1lOwotCSAqIGUuZy4gamF2YS5sYW5nLlN0cmluZy5jbGFzcyBpcyBjb252ZXJ0ZWQgdG8gIi9qYXZhL2xhbmcvU3RyaW5nLmNsYXNzIi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBjb252ZXJ0VG9SZXNvdXJjZU5hbWUoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCXJldHVybiAnLycgKyBjb252ZXJ0VG9BcmNoaXZlQ2xhc3NGaWxlRW50cnlOYW1lKGphdmFDbGFzcyk7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCBhIGNsYXNzIHRvIGEgcmVzb3VyY2U7Ci0JICogZS5nLiBqYXZhLmxhbmcuU3RyaW5nLmNsYXNzIGlzIGNvbnZlcnRlZCB0bwotCSAqIFVSTChqYXI6ZmlsZTovQzovamRrLzEuNC4yXzA0L2pyZS9saWIvcnQuamFyIS9qYXZhL2xhbmcvU3RyaW5nLmNsYXNzKS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFVSTCBjb252ZXJ0VG9SZXNvdXJjZShDbGFzczw/PiBqYXZhQ2xhc3MpIHsKLQkJcmV0dXJuIGphdmFDbGFzcy5nZXRSZXNvdXJjZShjb252ZXJ0VG9SZXNvdXJjZU5hbWUoamF2YUNsYXNzKSk7Ci0JfQotCi0KLQkvLyAqKioqKiB1dGlsaXRpZXMgKioqKioKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgZmlsZSBpcyBhbiBhcmNoaXZlIGZpbGU7Ci0JICogaS5lLiBpdHMgbmFtZSBlbmRzIHdpdGggIi56aXAiIG9yICIuamFyIgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBmaWxlTmFtZUlzQXJjaGl2ZShTdHJpbmcgZmlsZU5hbWUpIHsKLQkJU3RyaW5nIGV4dCA9IEZpbGVUb29scy5leHRlbnNpb24oZmlsZU5hbWUpLnRvTG93ZXJDYXNlKCk7Ci0JCXJldHVybiBleHQuZXF1YWxzKCIuamFyIikgfHwgZXh0LmVxdWFscygiLnppcCIpOyAvLyROT04tTkxTLTEkIC8vJE5PTi1OTFMtMiQKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBmaWxlIGlzIGFuIGFyY2hpdmUgZmlsZTsKLQkgKiBpLmUuIGl0cyBuYW1lIGVuZHMgd2l0aCAiLnppcCIgb3IgIi5qYXIiCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGZpbGVJc0FyY2hpdmUoRmlsZSBmaWxlKSB7Ci0JCXJldHVybiBmaWxlTmFtZUlzQXJjaGl2ZShmaWxlLmdldE5hbWUoKSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB3aGF0IHNob3VsZCBiZSB0aGUgZnVsbHktcXVhbGlmaWVkIGZpbGUgbmFtZQotCSAqIGZvciB0aGUgSlJFIHJ1bnRpbWUgSkFSOwotCSAqIGUuZy4gIkM6XGpkazEuNC4yXzA0XGpyZVxsaWJccnQuamFyIi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBydEphck5hbWUoKSB7Ci0JCXJldHVybiBsb2NhdGlvbkZvcihqYXZhLmxhbmcuT2JqZWN0LmNsYXNzKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBsb2NhdGlvbiBmcm9tIHdoZXJlIHRoZSBzcGVjaWZpZWQgY2xhc3Mgd2FzIGxvYWRlZC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBsb2NhdGlvbkZvcihDbGFzczw/PiBqYXZhQ2xhc3MpIHsKLQkJVVJMIHVybCA9IGNvbnZlcnRUb1Jlc291cmNlKGphdmFDbGFzcyk7Ci0JCVN0cmluZyBwYXRoOwotCQl0cnkgewotCQkJcGF0aCA9IEZpbGVUb29scy5idWlsZEZpbGUodXJsKS5nZXRQYXRoKCk7Ci0JCX0gY2F0Y2ggKFVSSVN5bnRheEV4Y2VwdGlvbiBleCkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oZXgpOwotCQl9Ci0JCVN0cmluZyBwcm90b2NvbCA9IHVybC5nZXRQcm90b2NvbCgpLnRvTG93ZXJDYXNlKCk7Ci0JCWlmIChwcm90b2NvbC5lcXVhbHMoImphciIpKSB7IC8vJE5PTi1OTFMtMSQKLQkJCS8vIGlmIHRoZSBjbGFzcyBpcyBpbiBhIEpBUiwgdGhlIFVSTCB3aWxsIGxvb2sgc29tZXRoaW5nIGxpa2UgdGhpczoKLQkJCS8vICAgICBqYXI6ZmlsZTovQzovamRrLzEuNC4yXzA0L2pyZS9saWIvcnQuamFyIS9qYXZhL2xhbmcvU3RyaW5nLmNsYXNzCi0JCQlyZXR1cm4gcGF0aC5zdWJzdHJpbmcoMCwgcGF0aC5pbmRleE9mKCchJykpOwotCQl9IGVsc2UgaWYgKHByb3RvY29sLmVxdWFscygiZmlsZSIpKSB7IC8vJE5PTi1OTFMtMSQKLQkJCS8vIGlmIHRoZSBjbGFzcyBpcyBpbiBhIGRpcmVjdG9yeSwgdGhlIFVSTCB3aWxsIGxvb2sgc29tZXRoaW5nIGxpa2UgdGhpczoKLQkJCS8vICAgICBmaWxlOi9DOi9kZXYvbWFpbi9td2Rldi9jbGFzcy9vcmcvZWNsaXBzZS9kYWxpL3V0aWxpdHkvQ2xhc3NwYXRoLmNsYXNzCi0JCQlyZXR1cm4gcGF0aC5zdWJzdHJpbmcoMCwgcGF0aC5sZW5ndGgoKSAtIGNvbnZlcnRUb0NsYXNzRmlsZU5hbWUoamF2YUNsYXNzKS5sZW5ndGgoKSAtIDEpOwotCQl9IGVsc2UgaWYgKHByb3RvY29sLmVxdWFscygiYnVuZGxlcmVzb3VyY2UiKSkgeyAvLyROT04tTkxTLTEkCi0JCQkvLyBpZiB0aGUgY2xhc3MgaXMgaW4gYSBidW5kbGUgcmVzb3VyY2UgKEVjbGlwc2U/KSwgdGhlIFVSTCB3aWxsIGxvb2sgc29tZXRoaW5nIGxpa2UgdGhpczoKLQkJCS8vICAgICBidW5kbGVyZXNvdXJjZTovLzQzL29yZy9lY2xpcHNlL2RhbGkvdXRpbGl0eS9DbGFzc3BhdGguY2xhc3MKLQkJCXJldHVybiBwYXRoLnN1YnN0cmluZygwLCBwYXRoLmxlbmd0aCgpIC0gY29udmVydFRvQ2xhc3NGaWxlTmFtZShqYXZhQ2xhc3MpLmxlbmd0aCgpIC0gMSk7Ci0JCX0KLQotCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKHVybC50b1N0cmluZygpKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBkaXJlY3RvcmllcyB1c2VkIGJ5IHRoZSBKYXZhIEV4dGVuc2lvbiBNZWNoYW5pc20uCi0JICovCi0JcHVibGljIHN0YXRpYyBGaWxlW10gamF2YUV4dGVuc2lvbkRpcmVjdG9yaWVzKCkgewotCQlyZXR1cm4gY29udmVydFRvRmlsZXMoamF2YUV4dGVuc2lvbkRpcmVjdG9yeU5hbWVzKCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgZGlyZWN0b3J5IG5hbWVzIHVzZWQgYnkgdGhlIEphdmEgRXh0ZW5zaW9uIE1lY2hhbmlzbS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZ1tdIGphdmFFeHRlbnNpb25EaXJlY3RvcnlOYW1lcygpIHsKLQkJcmV0dXJuIFN5c3RlbS5nZXRQcm9wZXJ0eSgiamF2YS5leHQuZGlycyIpLnNwbGl0KEZpbGUucGF0aFNlcGFyYXRvcik7IC8vJE5PTi1OTFMtMSQKLQl9Ci0KLQotCS8vICoqKioqIGludGVybmFsICoqKioqCi0KLQlwcml2YXRlIHN0YXRpYyBGaWxlW10gY29udmVydFRvRmlsZXMoU3RyaW5nW10gZmlsZU5hbWVzKSB7Ci0JCUZpbGVbXSBmaWxlcyA9IG5ldyBGaWxlW2ZpbGVOYW1lcy5sZW5ndGhdOwotCQlmb3IgKGludCBpID0gZmlsZU5hbWVzLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlmaWxlc1tpXSA9IG5ldyBGaWxlKGZpbGVOYW1lc1tpXSk7Ci0JCX0KLQkJcmV0dXJuIGZpbGVzOwotCX0KLQotCXByaXZhdGUgc3RhdGljIHZvaWQgYWRkSmFyRmlsZU5hbWVzVG8oRmlsZSBkaXIsIExpc3Q8U3RyaW5nPiBqYXJGaWxlTmFtZXMpIHsKLQkJRmlsZVtdIGphckZpbGVzID0gamFyRmlsZXNJbihkaXIpOwotCQlmb3IgKEZpbGUgamFyRmlsZSA6IGphckZpbGVzKSB7Ci0JCQlqYXJGaWxlTmFtZXMuYWRkKEZpbGVUb29scy5jYW5vbmljYWxGaWxlKGphckZpbGUpLmdldFBhdGgoKSk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBGaWxlW10gamFyRmlsZXNJbihGaWxlIGRpcmVjdG9yeSkgewotCQlyZXR1cm4gZGlyZWN0b3J5Lmxpc3RGaWxlcyhqYXJGaWxlRmlsdGVyKCkpOwotCX0KLQotCXByaXZhdGUgc3RhdGljIEZpbGVGaWx0ZXIgamFyRmlsZUZpbHRlcigpIHsKLQkJcmV0dXJuIG5ldyBGaWxlRmlsdGVyKCkgewotCQkJcHVibGljIGJvb2xlYW4gYWNjZXB0KEZpbGUgZmlsZSkgewotCQkJCXJldHVybiBGaWxlVG9vbHMuZXh0ZW5zaW9uKGZpbGUuZ2V0TmFtZSgpKS50b0xvd2VyQ2FzZSgpLmVxdWFscygiLmphciIpOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCX07Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBjbGFzc3BhdGggd2l0aCB0aGUgc3BlY2lmaWVkIGVudHJpZXMuCi0JICovCi0JcHJpdmF0ZSBDbGFzc3BhdGgoRW50cnlbXSBlbnRyaWVzKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuZW50cmllcyA9IGVudHJpZXM7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgY2xhc3NwYXRoIHdpdGggdGhlIHNwZWNpZmllZCBlbnRyaWVzLgotCSAqLwotCXB1YmxpYyBDbGFzc3BhdGgoU3RyaW5nW10gZmlsZU5hbWVzKSB7Ci0JCXRoaXMoYnVpbGRFbnRyaWVzKGZpbGVOYW1lcykpOwotCX0KLQotCS8qKgotCSAqIFNraXAgZW1wdHkgZmlsZSBuYW1lcyBiZWNhdXNlIHRoZXkgd2lsbCBlbmQgdXAgZXhwYW5kaW5nIHRvIHRoZSBjdXJyZW50Ci0JICogd29ya2luZyBkaXJlY3RvcnksIHdoaWNoIGlzIG5vdCB3aGF0IHdlIHdhbnQuIEVtcHR5IGZpbGUgbmFtZXMgYWN0dWFsbHkKLQkgKiBvY2N1ciB3aXRoIHNvbWUgZnJlcXVlbmN5OyBzdWNoIGFzIHdoZW4gdGhlIGNsYXNzcGF0aCBoYXMgYmVlbiBidWlsdCB1cAotCSAqIGR5bmFtaWNhbGx5IHdpdGggdG9vIG1hbnkgc2VwYXJhdG9ycy4gRm9yIGV4YW1wbGU6Ci0JICogICAgICJDOlxkZXZcZm9vLmphcjs7QzpcZGV2XGJhci5qYXIiCi0JICogd2lsbCBiZSBwYXJzZWQgaW50byB0aHJlZSBmaWxlIG5hbWVzOgotCSAqICAgICB7ICJDOlxkZXZcZm9vLmphciIsICIiLCAiQzpcZGV2XGJhci5qYXIiIH0KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBFbnRyeVtdIGJ1aWxkRW50cmllcyhTdHJpbmdbXSBmaWxlTmFtZXMpIHsKLQkJTGlzdDxFbnRyeT4gZW50cmllcyA9IG5ldyBBcnJheUxpc3Q8RW50cnk+KCk7Ci0JCWZvciAoU3RyaW5nIGZpbGVOYW1lIDogZmlsZU5hbWVzKSB7Ci0JCQlpZiAoKGZpbGVOYW1lICE9IG51bGwpICYmIChmaWxlTmFtZS5sZW5ndGgoKSAhPSAwKSkgewotCQkJCWVudHJpZXMuYWRkKG5ldyBFbnRyeShmaWxlTmFtZSkpOwotCQkJfQotCQl9Ci0JCXJldHVybiBlbnRyaWVzLnRvQXJyYXkobmV3IEVudHJ5W2VudHJpZXMuc2l6ZSgpXSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgY2xhc3NwYXRoIHdpdGggdGhlIHNwZWNpZmllZCBwYXRoLgotCSAqLwotCXB1YmxpYyBDbGFzc3BhdGgoU3RyaW5nIHBhdGgpIHsKLQkJdGhpcyhwYXRoLnNwbGl0KEZpbGUucGF0aFNlcGFyYXRvcikpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGNsYXNzcGF0aCB3aXRoIHRoZSBzcGVjaWZpZWQgZW50cmllcy4KLQkgKi8KLQlwdWJsaWMgQ2xhc3NwYXRoKExpc3Q8U3RyaW5nPiBmaWxlTmFtZXMpIHsKLQkJdGhpcyhmaWxlTmFtZXMudG9BcnJheShuZXcgU3RyaW5nW2ZpbGVOYW1lcy5zaXplKCldKSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc29saWRhdGUgdGhlIHNwZWNpZmllZCBjbGFzc3BhdGhzIGludG8gYSBzaW5nbGUgY2xhc3NwYXRoLgotCSAqLwotCXB1YmxpYyBDbGFzc3BhdGgoQ2xhc3NwYXRoW10gY2xhc3NwYXRocykgewotCQl0aGlzKGNvbnNvbGlkYXRlRW50cmllcyhjbGFzc3BhdGhzKSk7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgRW50cnlbXSBjb25zb2xpZGF0ZUVudHJpZXMoQ2xhc3NwYXRoW10gY2xhc3NwYXRocykgewotCQlMaXN0PEVudHJ5PiBlbnRyaWVzID0gbmV3IEFycmF5TGlzdDxFbnRyeT4oKTsKLQkJZm9yIChDbGFzc3BhdGggY2xhc3NwYXRoIDogY2xhc3NwYXRocykgewotCQkJQ29sbGVjdGlvblRvb2xzLmFkZEFsbChlbnRyaWVzLCBjbGFzc3BhdGguZW50cmllcygpKTsKLQkJfQotCQlyZXR1cm4gZW50cmllcy50b0FycmF5KG5ldyBFbnRyeVtlbnRyaWVzLnNpemUoKV0pOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBwdWJsaWMgQVBJICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB0aGUgY2xhc3NwYXRoJ3MgZW50cmllcy4KLQkgKi8KLQlwdWJsaWMgRW50cnlbXSBlbnRyaWVzKCkgewotCQlyZXR1cm4gdGhpcy5lbnRyaWVzOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgY2xhc3NwYXRoJ3MgcGF0aC4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIHBhdGgoKSB7Ci0JCUVudHJ5W10gbG9jYWxFbnRyaWVzID0gdGhpcy5lbnRyaWVzOwotCQlpbnQgbWF4ID0gbG9jYWxFbnRyaWVzLmxlbmd0aCAtIDE7Ci0JCWlmIChtYXggPT0gLTEpIHsKLQkJCXJldHVybiAiIjsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigyMDAwKTsKLQkJLy8gc3RvcCBvbmUgc2hvcnQgb2YgdGhlIGVuZCBvZiB0aGUgYXJyYXkKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBtYXg7IGkrKykgewotCQkJc2IuYXBwZW5kKGxvY2FsRW50cmllc1tpXS5maWxlTmFtZSgpKTsKLQkJCXNiLmFwcGVuZChGaWxlLnBhdGhTZXBhcmF0b3JDaGFyKTsKLQkJfQotCQlzYi5hcHBlbmQobG9jYWxFbnRyaWVzW21heF0uZmlsZU5hbWUoKSk7Ci0JCXJldHVybiBzYi50b1N0cmluZygpOwotCX0KLQotCS8qKgotCSAqIFNlYXJjaCB0aGUgY2xhc3NwYXRoIGZvciB0aGUgc3BlY2lmaWVkICh1bnF1YWxpZmllZCkgZmlsZQotCSAqIGFuZCByZXR1cm4gaXRzIGVudHJ5LiBSZXR1cm4gbnVsbCBpZiBhbiBlbnRyeSBpcyBub3QgZm91bmQuCi0JICogRm9yIGV4YW1wbGUsIHlvdSBjb3VsZCB1c2UgdGhpcyBtZXRob2QgdG8gZmluZCB0aGUgZW50cnkKLQkgKiBmb3IgInJ0LmphciIgb3IgInRvcGxpbmsuamFyIi4KLQkgKi8KLQlwdWJsaWMgRW50cnkgZW50cnlGb3JGaWxlTmFtZWQoU3RyaW5nIHNob3J0RmlsZU5hbWUpIHsKLQkJRW50cnlbXSBsb2NhbEVudHJpZXMgPSB0aGlzLmVudHJpZXM7Ci0JCWZvciAoRW50cnkgZW50cnkgOiBsb2NhbEVudHJpZXMpIHsKLQkJCWlmIChlbnRyeS5maWxlKCkuZ2V0TmFtZSgpLmVxdWFscyhzaG9ydEZpbGVOYW1lKSkgewotCQkJCXJldHVybiBlbnRyeTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGZpcnN0IGVudHJ5IGZpbGUgaW4gdGhlIGNsYXNzcGF0aAotCSAqIHRoYXQgY29udGFpbnMgdGhlIHNwZWNpZmllZCBjbGFzcy4KLQkgKiBSZXR1cm4gbnVsbCBpZiBhbiBlbnRyeSBpcyBub3QgZm91bmQuCi0JICovCi0JcHVibGljIEVudHJ5IGVudHJ5Rm9yQ2xhc3NOYW1lZChTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCVN0cmluZyByZWxhdGl2ZUNsYXNzRmlsZU5hbWUgPSBjb252ZXJ0VG9DbGFzc0ZpbGVOYW1lKGNsYXNzTmFtZSk7Ci0JCVN0cmluZyBhcmNoaXZlRW50cnlOYW1lID0gY29udmVydFRvQXJjaGl2ZUNsYXNzRmlsZUVudHJ5TmFtZShjbGFzc05hbWUpOwotCQlFbnRyeVtdIGxvY2FsRW50cmllcyA9IHRoaXMuZW50cmllczsKLQkJZm9yIChFbnRyeSBlbnRyeSA6IGxvY2FsRW50cmllcykgewotCQkJaWYgKGVudHJ5LmNvbnRhaW5zKHJlbGF0aXZlQ2xhc3NGaWxlTmFtZSwgYXJjaGl2ZUVudHJ5TmFtZSkpIHsKLQkJCQlyZXR1cm4gZW50cnk7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIG51bGw7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBuYW1lcyBvZiBhbGwgdGhlIGNsYXNzZXMgZGlzY292ZXJlZCBvbiB0aGUgY2xhc3NwYXRoLAotCSAqIHdpdGggZHVwbGljYXRlcyByZW1vdmVkLgotCSAqLwotCXB1YmxpYyBTdHJpbmdbXSBjbGFzc05hbWVzKCkgewotCQlyZXR1cm4gdGhpcy5jbGFzc05hbWVzKEZpbHRlci5OdWxsLjxTdHJpbmc+aW5zdGFuY2UoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBuYW1lcyBvZiBhbGwgdGhlIGNsYXNzZXMgZGlzY292ZXJlZCBvbiB0aGUgY2xhc3NwYXRoCi0JICogYW5kIGFjY2VwdGVkIGJ5IHRoZSBzcGVjaWZpZWQgZmlsdGVyLCB3aXRoIGR1cGxpY2F0ZXMgcmVtb3ZlZC4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nW10gY2xhc3NOYW1lcyhGaWx0ZXI8U3RyaW5nPiBmaWx0ZXIpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGNsYXNzTmFtZXMgPSBuZXcgSGFzaFNldDxTdHJpbmc+KDEwMDAwKTsKLQkJdGhpcy5hZGRDbGFzc05hbWVzVG8oY2xhc3NOYW1lcywgZmlsdGVyKTsKLQkJcmV0dXJuIGNsYXNzTmFtZXMudG9BcnJheShuZXcgU3RyaW5nW2NsYXNzTmFtZXMuc2l6ZSgpXSk7Ci0JfQotCi0JLyoqCi0JICogQWRkIHRoZSBuYW1lcyBvZiBhbGwgdGhlIGNsYXNzZXMgZGlzY292ZXJlZCBvbiB0aGUgY2xhc3NwYXRoCi0JICogdG8gdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLgotCSAqLwotCXB1YmxpYyB2b2lkIGFkZENsYXNzTmFtZXNUbyhDb2xsZWN0aW9uPFN0cmluZz4gY2xhc3NOYW1lcykgewotCQl0aGlzLmFkZENsYXNzTmFtZXNUbyhjbGFzc05hbWVzLCBGaWx0ZXIuTnVsbC48U3RyaW5nPmluc3RhbmNlKCkpOwotCX0KLQotCS8qKgotCSAqIEFkZCB0aGUgbmFtZXMgb2YgYWxsIHRoZSBjbGFzc2VzIGRpc2NvdmVyZWQgb24gdGhlIGNsYXNzcGF0aAotCSAqIGFuZCBhY2NlcHRlZCBieSB0aGUgc3BlY2lmaWVkIGZpbHRlciB0byB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24uCi0JICovCi0JcHVibGljIHZvaWQgYWRkQ2xhc3NOYW1lc1RvKENvbGxlY3Rpb248U3RyaW5nPiBjbGFzc05hbWVzLCBGaWx0ZXI8U3RyaW5nPiBmaWx0ZXIpIHsKLQkJRW50cnlbXSBsb2NhbEVudHJpZXMgPSB0aGlzLmVudHJpZXM7Ci0JCWZvciAoRW50cnkgZW50cnkgOiBsb2NhbEVudHJpZXMpIHsKLQkJCWVudHJ5LmFkZENsYXNzTmFtZXNUbyhjbGFzc05hbWVzLCBmaWx0ZXIpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBuYW1lcyBvZiBhbGwgdGhlIGNsYXNzZXMgZGlzY292ZXJlZCBvbiB0aGUgY2xhc3NwYXRoLgotCSAqIEp1c3QgYSBiaXQgbW9yZSBwZXJmb3JtYW50IHRoYW4gI2NsYXNzTmFtZXMoKS4KLQkgKi8KLQlwdWJsaWMgSXRlcmF0b3I8U3RyaW5nPiBjbGFzc05hbWVzU3RyZWFtKCkgewotCQlyZXR1cm4gdGhpcy5jbGFzc05hbWVzU3RyZWFtKEZpbHRlci5OdWxsLjxTdHJpbmc+aW5zdGFuY2UoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBuYW1lcyBvZiBhbGwgdGhlIGNsYXNzZXMgZGlzY292ZXJlZCBvbiB0aGUgY2xhc3NwYXRoCi0JICogdGhhdCBhcmUgYWNjZXB0ZWQgYnkgdGhlIHNwZWNpZmllZCBmaWx0ZXIuCi0JICogSnVzdCBhIGJpdCBtb3JlIHBlcmZvcm1hbnQgdGhhbiAjY2xhc3NOYW1lcyhGaWx0ZXIpLgotCSAqLwotCXB1YmxpYyBJdGVyYXRvcjxTdHJpbmc+IGNsYXNzTmFtZXNTdHJlYW0oRmlsdGVyPFN0cmluZz4gZmlsdGVyKSB7Ci0JCXJldHVybiBuZXcgQ29tcG9zaXRlSXRlcmF0b3I8U3RyaW5nPih0aGlzLmVudHJ5Q2xhc3NOYW1lc1N0cmVhbXMoZmlsdGVyKSk7Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxJdGVyYXRvcjxTdHJpbmc+PiBlbnRyeUNsYXNzTmFtZXNTdHJlYW1zKGZpbmFsIEZpbHRlcjxTdHJpbmc+IGZpbHRlcikgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8RW50cnksIEl0ZXJhdG9yPFN0cmluZz4+KG5ldyBBcnJheUl0ZXJhdG9yPEVudHJ5Pih0aGlzLmVudHJpZXMpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBJdGVyYXRvcjxTdHJpbmc+IHRyYW5zZm9ybShFbnRyeSBlbnRyeSkgewotCQkJCXJldHVybiBlbnRyeS5jbGFzc05hbWVzU3RyZWFtKGZpbHRlcik7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgImNvbXByZXNzZWQiIHZlcnNpb24gb2YgdGhlIGNsYXNzcGF0aCB3aXRoIGl0cwotCSAqIGR1cGxpY2F0ZSBlbnRyaWVzIGVsaW1pbmF0ZWQuCi0JICovCi0JcHVibGljIENsYXNzcGF0aCBjb21wcmVzc2VkKCkgewotCQlyZXR1cm4gbmV3IENsYXNzcGF0aChDb2xsZWN0aW9uVG9vbHMucmVtb3ZlRHVwbGljYXRlRWxlbWVudHModGhpcy5lbnRyaWVzKSk7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgY2xhc3NwYXRoIHRvIGFuIGFycmF5IG9mIFVSTHMKLQkgKiAodGhhdCBjYW4gYmUgdXNlZCB0byBpbnN0YW50aWF0ZSBhIFVSTENsYXNzTG9hZGVyKS4KLQkgKi8KLQlwdWJsaWMgVVJMW10gdXJscygpIHsKLQkJRW50cnlbXSBsb2NhbEVudHJpZXMgPSB0aGlzLmVudHJpZXM7Ci0JCWludCBsZW4gPSBsb2NhbEVudHJpZXMubGVuZ3RoOwotCQlVUkxbXSB1cmxzID0gbmV3IFVSTFtsZW5dOwotCQlmb3IgKGludCBpID0gMDsgaSA8IGxlbjsgaSsrKSB7Ci0JCQl1cmxzW2ldID0gbG9jYWxFbnRyaWVzW2ldLnVybCgpOwotCQl9Ci0JCXJldHVybiB1cmxzOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMucGF0aCgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5uZXIgY2xhc3MgKioqKioqKioqKgotCi0JLyoqCi0JICogVE9ETwotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2xhc3MgRW50cnkgaW1wbGVtZW50cyBTZXJpYWxpemFibGUgewotCQlwcml2YXRlIGZpbmFsIFN0cmluZyBmaWxlTmFtZTsKLQkJcHJpdmF0ZSBmaW5hbCBGaWxlIGZpbGU7Ci0JCXByaXZhdGUgZmluYWwgRmlsZSBjYW5vbmljYWxGaWxlOwotCi0JCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDFMOwotCi0JCUVudHJ5KFN0cmluZyBmaWxlTmFtZSkgewotCQkJc3VwZXIoKTsKLQkJCWlmICgoZmlsZU5hbWUgPT0gbnVsbCkgfHwgKGZpbGVOYW1lLmxlbmd0aCgpID09IDApKSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiJ2ZpbGVOYW1lJyBtdXN0IGJlIG5vbi1lbXB0eSIpOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCQl0aGlzLmZpbGVOYW1lID0gZmlsZU5hbWU7Ci0JCQl0aGlzLmZpbGUgPSBuZXcgRmlsZShmaWxlTmFtZSk7Ci0JCQl0aGlzLmNhbm9uaWNhbEZpbGUgPSBGaWxlVG9vbHMuY2Fub25pY2FsRmlsZSh0aGlzLmZpbGUpOwotCQl9Ci0KLQkJcHVibGljIFN0cmluZyBmaWxlTmFtZSgpIHsKLQkJCXJldHVybiB0aGlzLmZpbGVOYW1lOwotCQl9Ci0KLQkJcHVibGljIEZpbGUgZmlsZSgpIHsKLQkJCXJldHVybiB0aGlzLmZpbGU7Ci0JCX0KLQotCQlwdWJsaWMgRmlsZSBjYW5vbmljYWxGaWxlKCkgewotCQkJcmV0dXJuIHRoaXMuY2Fub25pY2FsRmlsZTsKLQkJfQotCi0JCXB1YmxpYyBTdHJpbmcgY2Fub25pY2FsRmlsZU5hbWUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5jYW5vbmljYWxGaWxlLmdldEFic29sdXRlUGF0aCgpOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBib29sZWFuIGVxdWFscyhPYmplY3QgbykgewotCQkJaWYgKCAhIChvIGluc3RhbmNlb2YgRW50cnkpKSB7Ci0JCQkJcmV0dXJuIGZhbHNlOwotCQkJfQotCQkJcmV0dXJuICgoRW50cnkpIG8pLmNhbm9uaWNhbEZpbGUuZXF1YWxzKHRoaXMuY2Fub25pY2FsRmlsZSk7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIGludCBoYXNoQ29kZSgpIHsKLQkJCXJldHVybiB0aGlzLmNhbm9uaWNhbEZpbGUuaGFzaENvZGUoKTsKLQkJfQotCi0JCS8qKgotCQkgKiBSZXR1cm4gdGhlIGVudHJ5J3MgImNhbm9uaWNhbCIgVVJMLgotCQkgKi8KLQkJcHVibGljIFVSTCB1cmwoKSB7Ci0JCQl0cnkgewotCQkJCXJldHVybiB0aGlzLmNhbm9uaWNhbEZpbGUudG9VUkkoKS50b1VSTCgpOwotCQkJfSBjYXRjaCAoSU9FeGNlcHRpb24gZXgpIHsKLQkJCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihleCk7Ci0JCQl9Ci0JCX0KLQotCQkvKioKLQkJICogUmV0dXJuIHdoZXRoZXIgdGhlIGVudHJ5IGNvbnRhaW5zIHRoZSBzcGVjaWZpZWQgY2xhc3MuCi0JCSAqLwotCQlwdWJsaWMgYm9vbGVhbiBjb250YWlucyhDbGFzczw/PiBqYXZhQ2xhc3MpIHsKLQkJCXJldHVybiB0aGlzLmNvbnRhaW5zKGphdmFDbGFzcy5nZXROYW1lKCkpOwotCQl9Ci0KLQkJLyoqCi0JCSAqIFJldHVybiB3aGV0aGVyIHRoZSBlbnRyeSBjb250YWlucyB0aGUgc3BlY2lmaWVkIGNsYXNzLgotCQkgKi8KLQkJcHVibGljIGJvb2xlYW4gY29udGFpbnMoU3RyaW5nIGNsYXNzTmFtZSkgewotCQkJcmV0dXJuIHRoaXMuY29udGFpbnMoY29udmVydFRvQ2xhc3NGaWxlTmFtZShjbGFzc05hbWUpLCBjb252ZXJ0VG9BcmNoaXZlQ2xhc3NGaWxlRW50cnlOYW1lKGNsYXNzTmFtZSkpOwotCQl9Ci0KLQkJLyoqCi0JCSAqIFJldHVybiB3aGV0aGVyIHRoZSBlbnRyeSBjb250YWlucyBlaXRoZXIgdGhlIHNwZWNpZmllZCByZWxhdGl2ZQotCQkgKiBjbGFzcyBmaWxlIG9yIHRoZSBzcGVjaWZpZWQgYXJjaGl2ZSBlbnRyeS4KLQkJICogTm90IHRoZSBwcmV0dGllc3Qgc2lnbmF0dXJlLCBidXQgaXQncyBpbnRlcm5hbC4uLi4KLQkJICovCi0JCWJvb2xlYW4gY29udGFpbnMoU3RyaW5nIHJlbGF0aXZlQ2xhc3NGaWxlTmFtZSwgU3RyaW5nIGFyY2hpdmVFbnRyeU5hbWUpIHsKLQkJCWlmICggISB0aGlzLmNhbm9uaWNhbEZpbGUuZXhpc3RzKCkpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCQlpZiAodGhpcy5jYW5vbmljYWxGaWxlLmlzRGlyZWN0b3J5KCkgJiYgKG5ldyBGaWxlKHRoaXMuY2Fub25pY2FsRmlsZSwgcmVsYXRpdmVDbGFzc0ZpbGVOYW1lKSkuZXhpc3RzKCkpIHsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQkJCXJldHVybiAoZmlsZUlzQXJjaGl2ZSh0aGlzLmNhbm9uaWNhbEZpbGUpICYmIHRoaXMuYXJjaGl2ZUNvbnRhaW5zRW50cnkoYXJjaGl2ZUVudHJ5TmFtZSkpOwotCQl9Ci0KLQkJLyoqCi0JCSAqIFJldHVybiB3aGV0aGVyIHRoZSBlbnRyeSdzIGFyY2hpdmUgY29udGFpbnMgdGhlIHNwZWNpZmllZCBlbnRyeS4KLQkJICovCi0JCXByaXZhdGUgYm9vbGVhbiBhcmNoaXZlQ29udGFpbnNFbnRyeShTdHJpbmcgemlwRW50cnlOYW1lKSB7Ci0JCQlaaXBGaWxlIHppcEZpbGUgPSBudWxsOwotCQkJWmlwRW50cnkgemlwRW50cnkgPSBudWxsOwotCQkJdHJ5IHsKLQkJCQl6aXBGaWxlID0gbmV3IFppcEZpbGUodGhpcy5jYW5vbmljYWxGaWxlKTsKLQkJCQl6aXBFbnRyeSA9IHppcEZpbGUuZ2V0RW50cnkoemlwRW50cnlOYW1lKTsKLQkJCX0gY2F0Y2ggKElPRXhjZXB0aW9uIGV4KSB7Ci0JCQkJLy8gc29tZXRoaW5nIGlzIHdyb25nLCBsZWF2ZSB0aGUgZW50cnkgbnVsbAotCQkJfSBmaW5hbGx5IHsKLQkJCQl0cnkgewotCQkJCQlpZiAoemlwRmlsZSAhPSBudWxsKSB7Ci0JCQkJCQl6aXBGaWxlLmNsb3NlKCk7Ci0JCQkJCX0KLQkJCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBleCkgewotCQkJCQl6aXBFbnRyeSA9IG51bGw7CS8vIHNvbWV0aGluZyBpcyB3cm9uZywgY2xlYXIgb3V0IHRoZSBlbnRyeQotCQkJCX0KLQkJCX0KLQkJCXJldHVybiB6aXBFbnRyeSAhPSBudWxsOwotCQl9Ci0KLQkJLyoqCi0JCSAqIFJldHVybiB0aGUgbmFtZXMgb2YgYWxsIHRoZSBjbGFzc2VzIGRpc2NvdmVyZWQgaW4gdGhlIGVudHJ5LgotCQkgKi8KLQkJcHVibGljIFN0cmluZ1tdIGNsYXNzTmFtZXMoKSB7Ci0JCQlyZXR1cm4gdGhpcy5jbGFzc05hbWVzKEZpbHRlci5OdWxsLjxTdHJpbmc+aW5zdGFuY2UoKSk7Ci0JCX0KLQotCQkvKioKLQkJICogUmV0dXJuIHRoZSBuYW1lcyBvZiBhbGwgdGhlIGNsYXNzZXMgZGlzY292ZXJlZCBpbiB0aGUgZW50cnkKLQkJICogYW5kIGFjY2VwdGVkIGJ5IHRoZSBzcGVjaWZpZWQgZmlsdGVyLgotCQkgKi8KLQkJcHVibGljIFN0cmluZ1tdIGNsYXNzTmFtZXMoRmlsdGVyPFN0cmluZz4gZmlsdGVyKSB7Ci0JCQlDb2xsZWN0aW9uPFN0cmluZz4gY2xhc3NOYW1lcyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigyMDAwKTsKLQkJCXRoaXMuYWRkQ2xhc3NOYW1lc1RvKGNsYXNzTmFtZXMsIGZpbHRlcik7Ci0JCQlyZXR1cm4gY2xhc3NOYW1lcy50b0FycmF5KG5ldyBTdHJpbmdbY2xhc3NOYW1lcy5zaXplKCldKTsKLQkJfQotCi0JCS8qKgotCQkgKiBBZGQgdGhlIG5hbWVzIG9mIGFsbCB0aGUgY2xhc3NlcyBkaXNjb3ZlcmVkIGluIHRoZSBlbnRyeQotCQkgKiB0byB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24uCi0JCSAqLwotCQlwdWJsaWMgdm9pZCBhZGRDbGFzc05hbWVzVG8oQ29sbGVjdGlvbjxTdHJpbmc+IGNsYXNzTmFtZXMpIHsKLQkJCXRoaXMuYWRkQ2xhc3NOYW1lc1RvKGNsYXNzTmFtZXMsIEZpbHRlci5OdWxsLjxTdHJpbmc+aW5zdGFuY2UoKSk7Ci0JCX0KLQotCQkvKioKLQkJICogQWRkIHRoZSBuYW1lcyBvZiBhbGwgdGhlIGNsYXNzZXMgZGlzY292ZXJlZCBpbiB0aGUgZW50cnkKLQkJICogYW5kIGFjY2VwdGVkIGJ5IHRoZSBzcGVjaWZpZWQgZmlsdGVyIHRvIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbi4KLQkJICovCi0JCXB1YmxpYyB2b2lkIGFkZENsYXNzTmFtZXNUbyhDb2xsZWN0aW9uPFN0cmluZz4gY2xhc3NOYW1lcywgRmlsdGVyPFN0cmluZz4gZmlsdGVyKSB7Ci0JCQlpZiAodGhpcy5jYW5vbmljYWxGaWxlLmV4aXN0cygpKSB7Ci0JCQkJaWYgKHRoaXMuY2Fub25pY2FsRmlsZS5pc0RpcmVjdG9yeSgpKSB7Ci0JCQkJCXRoaXMuYWRkQ2xhc3NOYW1lc0ZvckRpcmVjdG9yeVRvKGNsYXNzTmFtZXMsIGZpbHRlcik7Ci0JCQkJfSBlbHNlIGlmIChmaWxlSXNBcmNoaXZlKHRoaXMuY2Fub25pY2FsRmlsZSkpIHsKLQkJCQkJdGhpcy5hZGRDbGFzc05hbWVzRm9yQXJjaGl2ZVRvKGNsYXNzTmFtZXMsIGZpbHRlcik7Ci0JCQkJfQotCQkJfQotCQl9Ci0KLQkJLyoqCi0JCSAqIEFkZCB0aGUgbmFtZXMgb2YgYWxsIHRoZSBjbGFzc2VzIGRpc2NvdmVyZWQKLQkJICogdW5kZXIgdGhlIGVudHJ5J3MgZGlyZWN0b3J5IGFuZCBhY2NlcHRlZCBieQotCQkgKiB0aGUgc3BlY2lmaWVkIGZpbHRlciB0byB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24uCi0JCSAqLwotCQlwcml2YXRlIHZvaWQgYWRkQ2xhc3NOYW1lc0ZvckRpcmVjdG9yeVRvKENvbGxlY3Rpb248U3RyaW5nPiBjbGFzc05hbWVzLCBGaWx0ZXI8U3RyaW5nPiBmaWx0ZXIpIHsKLQkJCWludCBzdGFydCA9IHRoaXMuY2Fub25pY2FsRmlsZS5nZXRBYnNvbHV0ZVBhdGgoKS5sZW5ndGgoKSArIDE7Ci0JCQlmb3IgKEl0ZXJhdG9yPEZpbGU+IHN0cmVhbSA9IHRoaXMuY2xhc3NGaWxlc0ZvckRpcmVjdG9yeSgpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCQlTdHJpbmcgY2xhc3NOYW1lID0gY29udmVydFRvQ2xhc3NOYW1lKHN0cmVhbS5uZXh0KCkuZ2V0QWJzb2x1dGVQYXRoKCkuc3Vic3RyaW5nKHN0YXJ0KSk7Ci0JCQkJaWYgKGZpbHRlci5hY2NlcHQoY2xhc3NOYW1lKSkgewotCQkJCQljbGFzc05hbWVzLmFkZChjbGFzc05hbWUpOwotCQkJCX0KLQkJCX0KLQkJfQotCi0JCS8qKgotCQkgKiBSZXR1cm4gYW4gaXRlcmF0b3Igb24gYWxsIHRoZSBjbGFzcyBmaWxlcyBkaXNjb3ZlcmVkCi0JCSAqIHVuZGVyIHRoZSBlbnRyeSdzIGRpcmVjdG9yeS4KLQkJICovCi0JCXByaXZhdGUgSXRlcmF0b3I8RmlsZT4gY2xhc3NGaWxlc0ZvckRpcmVjdG9yeSgpIHsKLQkJCXJldHVybiBuZXcgRmlsdGVyaW5nSXRlcmF0b3I8RmlsZSwgRmlsZT4oRmlsZVRvb2xzLmZpbGVzSW5UcmVlKHRoaXMuY2Fub25pY2FsRmlsZSkpIHsKLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgYm9vbGVhbiBhY2NlcHQoRmlsZSBuZXh0KSB7Ci0JCQkJCXJldHVybiBFbnRyeS50aGlzLmZpbGVOYW1lTWlnaHRCZUZvckNsYXNzRmlsZShuZXh0LmdldE5hbWUoKSk7Ci0JCQkJfQotCQkJfTsKLQkJfQotCi0JCS8qKgotCQkgKiBBZGQgdGhlIG5hbWVzIG9mIGFsbCB0aGUgY2xhc3NlcyBkaXNjb3ZlcmVkCi0JCSAqIGluIHRoZSBlbnRyeSdzIGFyY2hpdmUgZmlsZSBhbmQgYWNjZXB0ZWQgYnkgdGhlCi0JCSAqIHNwZWNpZmllZCBmaWx0ZXIgdG8gdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLgotCQkgKi8KLQkJcHJpdmF0ZSB2b2lkIGFkZENsYXNzTmFtZXNGb3JBcmNoaXZlVG8oQ29sbGVjdGlvbjxTdHJpbmc+IGNsYXNzTmFtZXMsIEZpbHRlcjxTdHJpbmc+IGZpbHRlcikgewotCQkJWmlwRmlsZSB6aXBGaWxlID0gbnVsbDsKLQkJCXRyeSB7Ci0JCQkJemlwRmlsZSA9IG5ldyBaaXBGaWxlKHRoaXMuY2Fub25pY2FsRmlsZSk7Ci0JCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBleCkgewotCQkJCXJldHVybjsKLQkJCX0KLQkJCWZvciAoRW51bWVyYXRpb248PyBleHRlbmRzIFppcEVudHJ5PiBzdHJlYW0gPSB6aXBGaWxlLmVudHJpZXMoKTsgc3RyZWFtLmhhc01vcmVFbGVtZW50cygpOyApIHsKLQkJCQlaaXBFbnRyeSB6aXBFbnRyeSA9IHN0cmVhbS5uZXh0RWxlbWVudCgpOwotCQkJCVN0cmluZyB6aXBFbnRyeU5hbWUgPSB6aXBFbnRyeS5nZXROYW1lKCk7Ci0JCQkJaWYgKHRoaXMuZmlsZU5hbWVNaWdodEJlRm9yQ2xhc3NGaWxlKHppcEVudHJ5TmFtZSkpIHsKLQkJCQkJU3RyaW5nIGNsYXNzTmFtZSA9IGNvbnZlcnRUb0NsYXNzTmFtZSh6aXBFbnRyeU5hbWUpOwotCQkJCQlpZiAoZmlsdGVyLmFjY2VwdChjbGFzc05hbWUpKSB7Ci0JCQkJCQljbGFzc05hbWVzLmFkZChjbGFzc05hbWUpOwotCQkJCQl9Ci0JCQkJfQotCQkJfQotCQkJdHJ5IHsKLQkJCQl6aXBGaWxlLmNsb3NlKCk7Ci0JCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBleCkgewotCQkJCXJldHVybjsKLQkJCX0KLQkJfQotCi0JCS8qKgotCQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGZpbGUgbWlnaHQgYmUgYSBKYXZhIGNsYXNzIGZpbGUuCi0JCSAqIFRoZSBmaWxlIG5hbWUgbXVzdCBhdCBsZWFzdCBlbmQgd2l0aCAiLmNsYXNzIiBhbmQgY29udGFpbiBubyBzcGFjZXMuCi0JCSAqIChOZWl0aGVyIGNsYXNzIG5hbWVzIG5vciBwYWNrYWdlIG5hbWVzIG1heSBjb250YWluIHNwYWNlcy4pCi0JCSAqIFdoZXRoZXIgaXQgYWN0dWFsbHkgaXMgYSBjbGFzcyBmaWxlIHdpbGwgbmVlZCB0byBiZSBkZXRlcm1pbmVkIGJ5Ci0JCSAqIGEgY2xhc3MgbG9hZGVyLgotCQkgKi8KLQkJYm9vbGVhbiBmaWxlTmFtZU1pZ2h0QmVGb3JDbGFzc0ZpbGUoU3RyaW5nIG5hbWUpIHsKLQkJCXJldHVybiBGaWxlVG9vbHMuZXh0ZW5zaW9uKG5hbWUpLnRvTG93ZXJDYXNlKCkuZXF1YWxzKCIuY2xhc3MiKSAvLyROT04tTkxTLTEkCi0JCQkJCSYmIChuYW1lLmluZGV4T2YoJyAnKSA9PSAtMSk7Ci0JCX0KLQotCQkvKioKLQkJICogUmV0dXJuIHRoZSBuYW1lcyBvZiBhbGwgdGhlIGNsYXNzZXMgZGlzY292ZXJlZCBvbiB0aGUgY2xhc3NwYXRoLgotCQkgKiBKdXN0IGEgYml0IG1vcmUgcGVyZm9ybWFudCB0aGFuICNjbGFzc05hbWVzKCkuCi0JCSAqLwotCQlwdWJsaWMgSXRlcmF0b3I8U3RyaW5nPiBjbGFzc05hbWVzU3RyZWFtKCkgewotCQkJcmV0dXJuIHRoaXMuY2xhc3NOYW1lc1N0cmVhbShGaWx0ZXIuTnVsbC48U3RyaW5nPmluc3RhbmNlKCkpOwotCQl9Ci0KLQkJLyoqCi0JCSAqIFJldHVybiB0aGUgbmFtZXMgb2YgYWxsIHRoZSBjbGFzc2VzIGRpc2NvdmVyZWQgb24gdGhlIGNsYXNzcGF0aAotCQkgKiB0aGF0IGFyZSBhY2NlcHRlZCBieSB0aGUgc3BlY2lmaWVkIGZpbHRlci4KLQkJICogSnVzdCBhIGJpdCBtb3JlIHBlcmZvcm1hbnQgdGhhbiAjY2xhc3NOYW1lcyhGaWx0ZXIpLgotCQkgKi8KLQkJcHVibGljIEl0ZXJhdG9yPFN0cmluZz4gY2xhc3NOYW1lc1N0cmVhbShGaWx0ZXI8U3RyaW5nPiBmaWx0ZXIpIHsKLQkJCWlmICh0aGlzLmNhbm9uaWNhbEZpbGUuZXhpc3RzKCkpIHsKLQkJCQlpZiAodGhpcy5jYW5vbmljYWxGaWxlLmlzRGlyZWN0b3J5KCkpIHsKLQkJCQkJcmV0dXJuIHRoaXMuY2xhc3NOYW1lc0ZvckRpcmVjdG9yeShmaWx0ZXIpOwotCQkJCX0KLQkJCQlpZiAoZmlsZUlzQXJjaGl2ZSh0aGlzLmNhbm9uaWNhbEZpbGUpKSB7Ci0JCQkJCXJldHVybiB0aGlzLmNsYXNzTmFtZXNGb3JBcmNoaXZlKGZpbHRlcik7Ci0JCQkJfQotCQkJfQotCQkJcmV0dXJuIEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQkJfQotCi0JCS8qKgotCQkgKiBSZXR1cm4gdGhlIG5hbWVzIG9mIGFsbCB0aGUgY2xhc3NlcyBkaXNjb3ZlcmVkCi0JCSAqIHVuZGVyIHRoZSBlbnRyeSdzIGRpcmVjdG9yeSBhbmQgYWNjZXB0ZWQgYnkKLQkJICogdGhlIHNwZWNpZmllZCBmaWx0ZXIuCi0JCSAqLwotCQlwcml2YXRlIEl0ZXJhdG9yPFN0cmluZz4gY2xhc3NOYW1lc0ZvckRpcmVjdG9yeShGaWx0ZXI8U3RyaW5nPiBmaWx0ZXIpIHsKLQkJCXJldHVybiBuZXcgRmlsdGVyaW5nSXRlcmF0b3I8U3RyaW5nLCBTdHJpbmc+KHRoaXMuY2xhc3NOYW1lc0ZvckRpcmVjdG9yeSgpLCBmaWx0ZXIpOwotCQl9Ci0KLQkJLyoqCi0JCSAqIFRyYW5zZm9ybSB0aGUgY2xhc3MgZmlsZXMgdG8gY2xhc3MgbmFtZXMuCi0JCSAqLwotCQlwcml2YXRlIEl0ZXJhdG9yPFN0cmluZz4gY2xhc3NOYW1lc0ZvckRpcmVjdG9yeSgpIHsKLQkJCWZpbmFsIGludCBzdGFydCA9IHRoaXMuY2Fub25pY2FsRmlsZS5nZXRBYnNvbHV0ZVBhdGgoKS5sZW5ndGgoKSArIDE7Ci0JCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8RmlsZSwgU3RyaW5nPih0aGlzLmNsYXNzRmlsZXNGb3JEaXJlY3RvcnkoKSkgewotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKEZpbGUgZikgewotCQkJCQlyZXR1cm4gY29udmVydFRvQ2xhc3NOYW1lKGYuZ2V0QWJzb2x1dGVQYXRoKCkuc3Vic3RyaW5nKHN0YXJ0KSk7Ci0JCQkJfQotCQkJfTsKLQkJfQotCi0JCS8qKgotCQkgKiBSZXR1cm4gdGhlIG5hbWVzIG9mIGFsbCB0aGUgY2xhc3NlcyBkaXNjb3ZlcmVkCi0JCSAqIGluIHRoZSBlbnRyeSdzIGFyY2hpdmUgZmlsZSBhbmQgYWNjZXB0ZWQgYnkgdGhlCi0JCSAqIHNwZWNpZmllZCBmaWx0ZXIuCi0JCSAqLwotCQlwcml2YXRlIEl0ZXJhdG9yPFN0cmluZz4gY2xhc3NOYW1lc0ZvckFyY2hpdmUoRmlsdGVyPFN0cmluZz4gZmlsdGVyKSB7Ci0JCQkvLyB3ZSBjYW4ndCBzaW1wbHkgd3JhcCBpdGVyYXRvcnMgaGVyZSBiZWNhdXNlIHdlIG5lZWQgdG8gY2xvc2UgdGhlIGFyY2hpdmUgZmlsZS4uLgotCQkJWmlwRmlsZSB6aXBGaWxlID0gbnVsbDsKLQkJCXRyeSB7Ci0JCQkJemlwRmlsZSA9IG5ldyBaaXBGaWxlKHRoaXMuY2Fub25pY2FsRmlsZSk7Ci0JCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBleCkgewotCQkJCXJldHVybiBFbXB0eUl0ZXJhdG9yLmluc3RhbmNlKCk7Ci0JCQl9Ci0JCQlDb2xsZWN0aW9uPFN0cmluZz4gY2xhc3NOYW1lcyA9IG5ldyBIYXNoU2V0PFN0cmluZz4oemlwRmlsZS5zaXplKCkpOwotCQkJZm9yIChFbnVtZXJhdGlvbjw/IGV4dGVuZHMgWmlwRW50cnk+IHN0cmVhbSA9IHppcEZpbGUuZW50cmllcygpOyBzdHJlYW0uaGFzTW9yZUVsZW1lbnRzKCk7ICkgewotCQkJCVppcEVudHJ5IHppcEVudHJ5ID0gc3RyZWFtLm5leHRFbGVtZW50KCk7Ci0JCQkJU3RyaW5nIHppcEVudHJ5TmFtZSA9IHppcEVudHJ5LmdldE5hbWUoKTsKLQkJCQlpZiAodGhpcy5maWxlTmFtZU1pZ2h0QmVGb3JDbGFzc0ZpbGUoemlwRW50cnlOYW1lKSkgewotCQkJCQlTdHJpbmcgY2xhc3NOYW1lID0gY29udmVydFRvQ2xhc3NOYW1lKHppcEVudHJ5TmFtZSk7Ci0JCQkJCWlmIChmaWx0ZXIuYWNjZXB0KGNsYXNzTmFtZSkpIHsKLQkJCQkJCWNsYXNzTmFtZXMuYWRkKGNsYXNzTmFtZSk7Ci0JCQkJCX0KLQkJCQl9Ci0JCQl9Ci0JCQl0cnkgewotCQkJCXppcEZpbGUuY2xvc2UoKTsKLQkJCX0gY2F0Y2ggKElPRXhjZXB0aW9uIGV4KSB7Ci0JCQkJcmV0dXJuIEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQkJCX0KLQkJCXJldHVybiBjbGFzc05hbWVzLml0ZXJhdG9yKCk7Ci0JCX0KLQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0NvbGxlY3Rpb25Ub29scy5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0NvbGxlY3Rpb25Ub29scy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzNDc4MDI0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9Db2xsZWN0aW9uVG9vbHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQwMDggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEubGFuZy5yZWZsZWN0LkFycmF5OwotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkFycmF5czsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbnM7Ci1pbXBvcnQgamF2YS51dGlsLkNvbXBhcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkVudW1lcmF0aW9uOwotaW1wb3J0IGphdmEudXRpbC5IYXNoU2V0OwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlua2VkSGFzaFNldDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5SYW5kb207Ci1pbXBvcnQgamF2YS51dGlsLlJhbmRvbUFjY2VzczsKLWltcG9ydCBqYXZhLnV0aWwuVHJlZVNldDsKLWltcG9ydCBqYXZhLnV0aWwuVmVjdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5BcnJheUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5HZW5lcmljSXRlcmF0b3JXcmFwcGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5TaW5nbGVFbGVtZW50SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlNpbmdsZUVsZW1lbnRMaXN0SXRlcmF0b3I7Ci0KLXB1YmxpYyBmaW5hbCBjbGFzcyBDb2xsZWN0aW9uVG9vbHMgewotCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJpdmF0ZSBzdGF0aWMgPEU+IEVbXSBuZXdBcnJheShFW10gYXJyYXksIGludCBsZW5ndGgpIHsKLQkJcmV0dXJuIChFW10pIEFycmF5Lm5ld0luc3RhbmNlKGFycmF5LmdldENsYXNzKCkuZ2V0Q29tcG9uZW50VHlwZSgpLCBsZW5ndGgpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBhcnJheSB0aGF0IGNvbnRhaW5zIHRoZSBlbGVtZW50cyBpbiB0aGUKLQkgKiBzcGVjaWZpZWQgYXJyYXkgZm9sbG93ZWQgYnkgdGhlIHNwZWNpZmllZCBvYmplY3QgdG8gYmUgYWRkZWQuCi0JICogamF2YS51dGlsLkFycmF5cyNhZGQoT2JqZWN0W10gYXJyYXksIE9iamVjdCBvKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSBhZGQoRVtdIGFycmF5LCBFIHZhbHVlKSB7Ci0JCWludCBsZW4gPSBhcnJheS5sZW5ndGg7Ci0JCUVbXSByZXN1bHQgPSBuZXdBcnJheShhcnJheSwgbGVuICsgMSk7Ci0JCWlmIChsZW4gPiAwKSB7Ci0JCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCAwLCByZXN1bHQsIDAsIGxlbik7Ci0JCX0KLQkJcmVzdWx0W2xlbl0gPSB2YWx1ZTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgYXJyYXkgdGhhdCBjb250YWlucyB0aGUgZWxlbWVudHMgaW4gdGhlCi0JICogc3BlY2lmaWVkIGFycmF5IHdpdGggdGhlIHNwZWNpZmllZCBvYmplY3QgYWRkZWQgYXQgdGhlIHNwZWNpZmllZCBpbmRleC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2FkZChPYmplY3RbXSBhcnJheSwgaW50IGluZGV4LCBPYmplY3QgbykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gYWRkKEVbXSBhcnJheSwgaW50IGluZGV4LCBFIHZhbHVlKSB7Ci0JCWludCBsZW4gPSBhcnJheS5sZW5ndGg7Ci0JCUVbXSByZXN1bHQgPSBuZXdBcnJheShhcnJheSwgbGVuICsgMSk7Ci0JCWlmIChpbmRleCA+IDApIHsKLQkJCVN5c3RlbS5hcnJheWNvcHkoYXJyYXksIDAsIHJlc3VsdCwgMCwgaW5kZXgpOwotCQl9Ci0JCXJlc3VsdFtpbmRleF0gPSB2YWx1ZTsKLQkJaWYgKGxlbiA+IGluZGV4KSB7Ci0JCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCBpbmRleCwgcmVzdWx0LCBpbmRleCArIDEsIGxlbiAtIGluZGV4KTsKLQkJfQotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBhcnJheSB0aGF0IGNvbnRhaW5zIHRoZSBlbGVtZW50cyBpbiB0aGUKLQkgKiBzcGVjaWZpZWQgYXJyYXkgZm9sbG93ZWQgYnkgdGhlIHNwZWNpZmllZCB2YWx1ZSB0byBiZSBhZGRlZC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2FkZChjaGFyW10gYXJyYXksIGNoYXIgdmFsdWUpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gYWRkKGNoYXJbXSBhcnJheSwgY2hhciB2YWx1ZSkgewotCQlpbnQgbGVuID0gYXJyYXkubGVuZ3RoOwotCQljaGFyW10gcmVzdWx0ID0gbmV3IGNoYXJbbGVuICsgMV07Ci0JCWlmIChsZW4gPiAwKSB7Ci0JCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCAwLCByZXN1bHQsIDAsIGxlbik7Ci0JCX0KLQkJcmVzdWx0W2xlbl0gPSB2YWx1ZTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgYXJyYXkgdGhhdCBjb250YWlucyB0aGUgZWxlbWVudHMgaW4gdGhlCi0JICogc3BlY2lmaWVkIGFycmF5IHdpdGggdGhlIHNwZWNpZmllZCB2YWx1ZSBhZGRlZCBhdCB0aGUgc3BlY2lmaWVkIGluZGV4LgotCSAqIGphdmEudXRpbC5BcnJheXMjYWRkKGNoYXJbXSBhcnJheSwgaW50IGluZGV4LCBjaGFyIHZhbHVlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIGFkZChjaGFyW10gYXJyYXksIGludCBpbmRleCwgY2hhciB2YWx1ZSkgewotCQlpbnQgbGVuID0gYXJyYXkubGVuZ3RoOwotCQljaGFyW10gcmVzdWx0ID0gbmV3IGNoYXJbbGVuICsgMV07Ci0JCWlmIChpbmRleCA+IDApIHsKLQkJCVN5c3RlbS5hcnJheWNvcHkoYXJyYXksIDAsIHJlc3VsdCwgMCwgaW5kZXgpOwotCQl9Ci0JCXJlc3VsdFtpbmRleF0gPSB2YWx1ZTsKLQkJaWYgKGxlbiA+IGluZGV4KSB7Ci0JCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCBpbmRleCwgcmVzdWx0LCBpbmRleCArIDEsIGxlbiAtIGluZGV4KTsKLQkJfQotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBhcnJheSB0aGF0IGNvbnRhaW5zIHRoZSBlbGVtZW50cyBpbiB0aGUKLQkgKiBzcGVjaWZpZWQgYXJyYXkgZm9sbG93ZWQgYnkgdGhlIHNwZWNpZmllZCB2YWx1ZSB0byBiZSBhZGRlZC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2FkZChpbnRbXSBhcnJheSwgaW50IHZhbHVlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50W10gYWRkKGludFtdIGFycmF5LCBpbnQgdmFsdWUpIHsKLQkJaW50IGxlbiA9IGFycmF5Lmxlbmd0aDsKLQkJaW50W10gcmVzdWx0ID0gbmV3IGludFtsZW4gKyAxXTsKLQkJaWYgKGxlbiA+IDApIHsKLQkJCVN5c3RlbS5hcnJheWNvcHkoYXJyYXksIDAsIHJlc3VsdCwgMCwgbGVuKTsKLQkJfQotCQlyZXN1bHRbbGVuXSA9IHZhbHVlOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBhcnJheSB0aGF0IGNvbnRhaW5zIHRoZSBlbGVtZW50cyBpbiB0aGUKLQkgKiBzcGVjaWZpZWQgYXJyYXkgd2l0aCB0aGUgc3BlY2lmaWVkIHZhbHVlIGFkZGVkIGF0IHRoZSBzcGVjaWZpZWQgaW5kZXguCi0JICogamF2YS51dGlsLkFycmF5cyNhZGQoaW50W10gYXJyYXksIGludCBpbmRleCwgaW50IHZhbHVlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50W10gYWRkKGludFtdIGFycmF5LCBpbnQgaW5kZXgsIGludCB2YWx1ZSkgewotCQlpbnQgbGVuID0gYXJyYXkubGVuZ3RoOwotCQlpbnRbXSByZXN1bHQgPSBuZXcgaW50W2xlbiArIDFdOwotCQlpZiAoaW5kZXggPiAwKSB7Ci0JCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCAwLCByZXN1bHQsIDAsIGluZGV4KTsKLQkJfQotCQlyZXN1bHRbaW5kZXhdID0gdmFsdWU7Ci0JCWlmIChsZW4gPiBpbmRleCkgewotCQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgaW5kZXgsIHJlc3VsdCwgaW5kZXggKyAxLCBsZW4gLSBpbmRleCk7Ci0JCX0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBBZGQgYWxsIHRoZSBlbGVtZW50cyByZXR1cm5lZCBieSB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlCi0JICogdG8gdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjb2xsZWN0aW9uIGNoYW5nZWQgYXMgYSByZXN1bHQuCi0JICogamF2YS51dGlsLkNvbGxlY3Rpb24jYWRkQWxsKGphdmEubGFuZy5JdGVyYWJsZSBpdGVyYWJsZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBib29sZWFuIGFkZEFsbChDb2xsZWN0aW9uPD8gc3VwZXIgRT4gY29sbGVjdGlvbiwgSXRlcmFibGU8PyBleHRlbmRzIEU+IGl0ZXJhYmxlKSB7Ci0JCXJldHVybiBhZGRBbGwoY29sbGVjdGlvbiwgaXRlcmFibGUuaXRlcmF0b3IoKSk7Ci0JfQotCi0JLyoqCi0JICogQWRkIGFsbCB0aGUgZWxlbWVudHMgcmV0dXJuZWQgYnkgdGhlIHNwZWNpZmllZCBpdGVyYWJsZQotCSAqIHRvIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbi4KLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgY29sbGVjdGlvbiBjaGFuZ2VkIGFzIGEgcmVzdWx0LgotCSAqIGphdmEudXRpbC5Db2xsZWN0aW9uI2FkZEFsbChqYXZhLmxhbmcuSXRlcmFibGUgaXRlcmFibGUpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gYm9vbGVhbiBhZGRBbGwoQ29sbGVjdGlvbjw/IHN1cGVyIEU+IGNvbGxlY3Rpb24sIEl0ZXJhYmxlPD8gZXh0ZW5kcyBFPiBpdGVyYWJsZSwgaW50IHNpemUpIHsKLQkJcmV0dXJuIGFkZEFsbChjb2xsZWN0aW9uLCBpdGVyYWJsZS5pdGVyYXRvcigpLCBzaXplKTsKLQl9Ci0KLQkvKioKLQkgKiBBZGQgYWxsIHRoZSBlbGVtZW50cyByZXR1cm5lZCBieSB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9yCi0JICogdG8gdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjb2xsZWN0aW9uIGNoYW5nZWQgYXMgYSByZXN1bHQuCi0JICogamF2YS51dGlsLkNvbGxlY3Rpb24jYWRkQWxsKGphdmEudXRpbC5JdGVyYXRvciBpdGVyYXRvcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBib29sZWFuIGFkZEFsbChDb2xsZWN0aW9uPD8gc3VwZXIgRT4gY29sbGVjdGlvbiwgSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yKSB7Ci0JCXJldHVybiAoaXRlcmF0b3IuaGFzTmV4dCgpKSA/IGNvbGxlY3Rpb24uYWRkQWxsKGxpc3QoaXRlcmF0b3IpKSA6IGZhbHNlOwotCX0KLQotCS8qKgotCSAqIEFkZCBhbGwgdGhlIGVsZW1lbnRzIHJldHVybmVkIGJ5IHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IKLQkgKiB0byB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24uCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGNvbGxlY3Rpb24gY2hhbmdlZCBhcyBhIHJlc3VsdC4KLQkgKiBqYXZhLnV0aWwuQ29sbGVjdGlvbiNhZGRBbGwoamF2YS51dGlsLkl0ZXJhdG9yIGl0ZXJhdG9yKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IGJvb2xlYW4gYWRkQWxsKENvbGxlY3Rpb248PyBzdXBlciBFPiBjb2xsZWN0aW9uLCBJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IsIGludCBzaXplKSB7Ci0JCXJldHVybiAoaXRlcmF0b3IuaGFzTmV4dCgpKSA/IGNvbGxlY3Rpb24uYWRkQWxsKGxpc3QoaXRlcmF0b3IsIHNpemUpKSA6IGZhbHNlOwotCX0KLQotCS8qKgotCSAqIEFkZCBhbGwgdGhlIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQgYXJyYXkKLQkgKiB0byB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24uCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGNvbGxlY3Rpb24gY2hhbmdlZCBhcyBhIHJlc3VsdC4KLQkgKiBqYXZhLnV0aWwuQ29sbGVjdGlvbiNhZGRBbGwoT2JqZWN0W10gYXJyYXkpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gYm9vbGVhbiBhZGRBbGwoQ29sbGVjdGlvbjw/IHN1cGVyIEU+IGNvbGxlY3Rpb24sIEVbXSBhcnJheSkgewotCQlyZXR1cm4gKGFycmF5Lmxlbmd0aCA9PSAwKSA/IGZhbHNlIDogY29sbGVjdGlvbi5hZGRBbGwoQXJyYXlzLmFzTGlzdChhcnJheSkpOwotCX0KLQotCS8qKgotCSAqIEFkZCBhbGwgdGhlIGVsZW1lbnRzIHJldHVybmVkIGJ5IHRoZSBzcGVjaWZpZWQgaXRlcmFibGUKLQkgKiB0byB0aGUgc3BlY2lmaWVkIGxpc3QgYXQgdGhlIHNwZWNpZmllZCBpbmRleC4KLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgbGlzdCBjaGFuZ2VkIGFzIGEgcmVzdWx0LgotCSAqIGphdmEudXRpbC5MaXN0I2FkZEFsbChqYXZhLmxhbmcuSXRlcmFibGUgaXRlcmFibGUpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gYm9vbGVhbiBhZGRBbGwoTGlzdDw/IHN1cGVyIEU+IGxpc3QsIGludCBpbmRleCwgSXRlcmFibGU8RT4gaXRlcmFibGUpIHsKLQkJcmV0dXJuIGFkZEFsbChsaXN0LCBpbmRleCwgaXRlcmFibGUuaXRlcmF0b3IoKSk7Ci0JfQotCi0JLyoqCi0JICogQWRkIGFsbCB0aGUgZWxlbWVudHMgcmV0dXJuZWQgYnkgdGhlIHNwZWNpZmllZCBpdGVyYWJsZQotCSAqIHRvIHRoZSBzcGVjaWZpZWQgbGlzdCBhdCB0aGUgc3BlY2lmaWVkIGluZGV4LgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBsaXN0IGNoYW5nZWQgYXMgYSByZXN1bHQuCi0JICogamF2YS51dGlsLkxpc3QjYWRkQWxsKGphdmEubGFuZy5JdGVyYWJsZSBpdGVyYWJsZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBib29sZWFuIGFkZEFsbChMaXN0PD8gc3VwZXIgRT4gbGlzdCwgaW50IGluZGV4LCBJdGVyYWJsZTxFPiBpdGVyYWJsZSwgaW50IHNpemUpIHsKLQkJcmV0dXJuIGFkZEFsbChsaXN0LCBpbmRleCwgaXRlcmFibGUuaXRlcmF0b3IoKSwgc2l6ZSk7Ci0JfQotCi0JLyoqCi0JICogQWRkIGFsbCB0aGUgZWxlbWVudHMgcmV0dXJuZWQgYnkgdGhlIHNwZWNpZmllZCBpdGVyYXRvcgotCSAqIHRvIHRoZSBzcGVjaWZpZWQgbGlzdCBhdCB0aGUgc3BlY2lmaWVkIGluZGV4LgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBsaXN0IGNoYW5nZWQgYXMgYSByZXN1bHQuCi0JICogamF2YS51dGlsLkxpc3QjYWRkQWxsKGphdmEudXRpbC5JdGVyYXRvciBpdGVyYXRvcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBib29sZWFuIGFkZEFsbChMaXN0PD8gc3VwZXIgRT4gbGlzdCwgaW50IGluZGV4LCBJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IpIHsKLQkJcmV0dXJuIChpdGVyYXRvci5oYXNOZXh0KCkpID8gbGlzdC5hZGRBbGwoaW5kZXgsIGxpc3QoaXRlcmF0b3IpKSA6IGZhbHNlOwotCX0KLQotCS8qKgotCSAqIEFkZCBhbGwgdGhlIGVsZW1lbnRzIHJldHVybmVkIGJ5IHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IKLQkgKiB0byB0aGUgc3BlY2lmaWVkIGxpc3QgYXQgdGhlIHNwZWNpZmllZCBpbmRleC4KLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgbGlzdCBjaGFuZ2VkIGFzIGEgcmVzdWx0LgotCSAqIGphdmEudXRpbC5MaXN0I2FkZEFsbChqYXZhLnV0aWwuSXRlcmF0b3IgaXRlcmF0b3IpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gYm9vbGVhbiBhZGRBbGwoTGlzdDw/IHN1cGVyIEU+IGxpc3QsIGludCBpbmRleCwgSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yLCBpbnQgc2l6ZSkgewotCQlyZXR1cm4gKGl0ZXJhdG9yLmhhc05leHQoKSkgPyBsaXN0LmFkZEFsbChpbmRleCwgbGlzdChpdGVyYXRvciwgc2l6ZSkpIDogZmFsc2U7Ci0JfQotCi0JLyoqCi0JICogQWRkIGFsbCB0aGUgZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZCBhcnJheQotCSAqIHRvIHRoZSBzcGVjaWZpZWQgbGlzdCBhdCB0aGUgc3BlY2lmaWVkIGluZGV4LgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBsaXN0IGNoYW5nZWQgYXMgYSByZXN1bHQuCi0JICogamF2YS51dGlsLkxpc3QjYWRkQWxsKE9iamVjdFtdIGFycmF5KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IGJvb2xlYW4gYWRkQWxsKExpc3Q8PyBzdXBlciBFPiBsaXN0LCBpbnQgaW5kZXgsIEVbXSBhcnJheSkgewotCQlyZXR1cm4gKGFycmF5Lmxlbmd0aCA9PSAwKSA/IGZhbHNlIDogbGlzdC5hZGRBbGwoaW5kZXgsIEFycmF5cy5hc0xpc3QoYXJyYXkpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgYXJyYXkgdGhhdCBjb250YWlucyB0aGUgZWxlbWVudHMgaW4gdGhlCi0JICogc3BlY2lmaWVkIGFycmF5IGZvbGxvd2VkIGJ5IHRoZSBlbGVtZW50cwotCSAqIGluIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbi4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2FkZEFsbChPYmplY3RbXSBhcnJheSwgamF2YS51dGlsLkNvbGxlY3Rpb24gYykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gYWRkQWxsKEVbXSBhcnJheSwgQ29sbGVjdGlvbjw/IGV4dGVuZHMgRT4gY29sbGVjdGlvbikgewotCQlpbnQgc2l6ZSA9IGNvbGxlY3Rpb24uc2l6ZSgpOwotCQlyZXR1cm4gKHNpemUgPT0gMCkgPyBhcnJheSA6IGFkZEFsbChhcnJheSwgY29sbGVjdGlvbiwgc2l6ZSk7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIGNvbGxlY3Rpb24gaXMgbm9uLWVtcHR5Ci0JICovCi0JcHJpdmF0ZSBzdGF0aWMgPEU+IEVbXSBhZGRBbGxfKEVbXSBhcnJheSwgQ29sbGVjdGlvbjw/IGV4dGVuZHMgRT4gY29sbGVjdGlvbikgewotCQlyZXR1cm4gYWRkQWxsKGFycmF5LCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uLnNpemUoKSk7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIGNvbGxlY3Rpb24gaXMgbm9uLWVtcHR5Ci0JICovCi0JcHJpdmF0ZSBzdGF0aWMgPEU+IEVbXSBhZGRBbGwoRVtdIGFycmF5LCBDb2xsZWN0aW9uPD8gZXh0ZW5kcyBFPiBjb2xsZWN0aW9uLCBpbnQgY29sbGVjdGlvblNpemUpIHsKLQkJaW50IGxlbiA9IGFycmF5Lmxlbmd0aDsKLQkJRVtdIHJlc3VsdCA9IG5ld0FycmF5KGFycmF5LCBsZW4gKyBjb2xsZWN0aW9uU2l6ZSk7Ci0JCWlmIChsZW4gPiAwKSB7Ci0JCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCAwLCByZXN1bHQsIDAsIGxlbik7Ci0JCX0KLQkJaW50IGkgPSBsZW47Ci0JCWZvciAoRSBpdGVtIDogY29sbGVjdGlvbikgewotCQkJcmVzdWx0W2krK10gPSBpdGVtOwotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgbmV3IGFycmF5IHRoYXQgY29udGFpbnMgdGhlIGVsZW1lbnRzIGluIHRoZQotCSAqIHNwZWNpZmllZCBhcnJheSBmb2xsb3dlZCBieSB0aGUgZWxlbWVudHMKLQkgKiBpbiB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlLgotCSAqIGphdmEudXRpbC5BcnJheXMjYWRkQWxsKE9iamVjdFtdIGFycmF5LCBqYXZhLmxhbmcuSXRlcmFibGUgaXRlcmFibGUpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gRVtdIGFkZEFsbChFW10gYXJyYXksIEl0ZXJhYmxlPD8gZXh0ZW5kcyBFPiBpdGVyYWJsZSkgewotCQlyZXR1cm4gYWRkQWxsKGFycmF5LCBpdGVyYWJsZS5pdGVyYXRvcigpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgYXJyYXkgdGhhdCBjb250YWlucyB0aGUgZWxlbWVudHMgaW4gdGhlCi0JICogc3BlY2lmaWVkIGFycmF5IGZvbGxvd2VkIGJ5IHRoZSBlbGVtZW50cwotCSAqIGluIHRoZSBzcGVjaWZpZWQgaXRlcmFibGUuCi0JICogamF2YS51dGlsLkFycmF5cyNhZGRBbGwoT2JqZWN0W10gYXJyYXksIGphdmEubGFuZy5JdGVyYWJsZSBpdGVyYWJsZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gYWRkQWxsKEVbXSBhcnJheSwgSXRlcmFibGU8PyBleHRlbmRzIEU+IGl0ZXJhYmxlLCBpbnQgc2l6ZSkgewotCQlyZXR1cm4gYWRkQWxsKGFycmF5LCBpdGVyYWJsZS5pdGVyYXRvcigpLCBzaXplKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgYXJyYXkgdGhhdCBjb250YWlucyB0aGUgZWxlbWVudHMgaW4gdGhlCi0JICogc3BlY2lmaWVkIGFycmF5IGZvbGxvd2VkIGJ5IHRoZSBlbGVtZW50cwotCSAqIGluIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICogamF2YS51dGlsLkFycmF5cyNhZGRBbGwoT2JqZWN0W10gYXJyYXksIGphdmEudXRpbC5JdGVyYXRvciBpdGVyYXRvcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gYWRkQWxsKEVbXSBhcnJheSwgSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yKSB7Ci0JCXJldHVybiAoaXRlcmF0b3IuaGFzTmV4dCgpKSA/IGFkZEFsbF8oYXJyYXksIGxpc3QoaXRlcmF0b3IpKSA6IGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBhcnJheSB0aGF0IGNvbnRhaW5zIHRoZSBlbGVtZW50cyBpbiB0aGUKLQkgKiBzcGVjaWZpZWQgYXJyYXkgZm9sbG93ZWQgYnkgdGhlIGVsZW1lbnRzCi0JICogaW4gdGhlIHNwZWNpZmllZCBpdGVyYXRvci4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2FkZEFsbChPYmplY3RbXSBhcnJheSwgamF2YS51dGlsLkl0ZXJhdG9yIGl0ZXJhdG9yKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSBhZGRBbGwoRVtdIGFycmF5LCBJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IsIGludCBzaXplKSB7Ci0JCXJldHVybiAoaXRlcmF0b3IuaGFzTmV4dCgpKSA/IGFkZEFsbF8oYXJyYXksIGxpc3QoaXRlcmF0b3IsIHNpemUpKSA6IGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBhcnJheSB0aGF0IGNvbnRhaW5zIHRoZSBlbGVtZW50cyBpbiB0aGUKLQkgKiBzcGVjaWZpZWQgYXJyYXkgMSBmb2xsb3dlZCBieSB0aGUgZWxlbWVudHMKLQkgKiBpbiB0aGUgc3BlY2lmaWVkIGFycmF5IDIuCi0JICogamF2YS51dGlsLkFycmF5cyNhZGRBbGwoT2JqZWN0W10gYXJyYXkxLCBPYmplY3RbXSBhcnJheTIpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gRVtdIGFkZEFsbChFW10gYXJyYXkxLCBFW10gYXJyYXkyKSB7Ci0JCWludCBhcnJheTJMZW5ndGggPSBhcnJheTIubGVuZ3RoOwotCQlyZXR1cm4gKGFycmF5Mkxlbmd0aCA9PSAwKSA/IGFycmF5MSA6IGFkZEFsbChhcnJheTEsIGFycmF5MiwgYXJyYXkyTGVuZ3RoKTsKLQl9Ci0KLQkvKioKLQkgKiBhc3N1bWUgYXJyYXkyTGVuZ3RoID4gMAotCSAqLwotCXByaXZhdGUgc3RhdGljIDxFPiBFW10gYWRkQWxsKEVbXSBhcnJheTEsIEVbXSBhcnJheTIsIGludCBhcnJheTJMZW5ndGgpIHsKLQkJaW50IGFycmF5MUxlbmd0aCA9IGFycmF5MS5sZW5ndGg7Ci0JCXJldHVybiAoYXJyYXkxTGVuZ3RoID09IDApID8gYXJyYXkyIDogYWRkQWxsKGFycmF5MSwgYXJyYXkyLCBhcnJheTFMZW5ndGgsIGFycmF5Mkxlbmd0aCk7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIGFycmF5MUxlbmd0aCA+IDAgYW5kIGFycmF5Mkxlbmd0aCA+IDAKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyA8RT4gRVtdIGFkZEFsbChFW10gYXJyYXkxLCBFW10gYXJyYXkyLCBpbnQgYXJyYXkxTGVuZ3RoLCBpbnQgYXJyYXkyTGVuZ3RoKSB7Ci0JCUVbXSByZXN1bHQgPSBuZXdBcnJheShhcnJheTEsIGFycmF5MUxlbmd0aCArIGFycmF5Mkxlbmd0aCk7Ci0JCVN5c3RlbS5hcnJheWNvcHkoYXJyYXkxLCAwLCByZXN1bHQsIDAsIGFycmF5MUxlbmd0aCk7Ci0JCVN5c3RlbS5hcnJheWNvcHkoYXJyYXkyLCAwLCByZXN1bHQsIGFycmF5MUxlbmd0aCwgYXJyYXkyTGVuZ3RoKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgYXJyYXkgdGhhdCBjb250YWlucyBhbGwgdGhlIGVsZW1lbnRzIGluICBhbGwgdGhlCi0JICogc3BlY2lmaWVkIGFycmF5cywgY29uY2F0ZW5hdGVkIGluIHRoZSBzcGVjaWZpZWQgb3JkZXIuCi0JICogVGhpcyBpcyB1c2VmdWwgZm9yIGJ1aWxkaW5nIGNvbnN0YW50IGFycmF5cyBvdXQgb3RoZXIgY29uc3RhbnQgYXJyYXlzLgotCSAqIGphdmEudXRpbC5BcnJheXMjY29uY2F0ZW5hdGUoT2JqZWN0W10uLi4gYXJyYXlzKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSBjb25jYXRlbmF0ZShFW10uLi4gYXJyYXlzKSB7Ci0JCWludCBsZW4gPSAwOwotCQlmb3IgKEVbXSBhcnJheSA6IGFycmF5cykgewotCQkJbGVuICs9IGFycmF5Lmxlbmd0aDsKLQkJfQotCQlFW10gcmVzdWx0ID0gbmV3QXJyYXkoYXJyYXlzWzBdLCBsZW4pOwotCQlpZiAobGVuID09IDApIHsKLQkJCXJldHVybiByZXN1bHQ7Ci0JCX0KLQkJaW50IGN1cnJlbnQgPSAwOwotCQlmb3IgKEVbXSBhcnJheSA6IGFycmF5cykgewotCQkJaW50IGFycmF5TGVuZ3RoID0gYXJyYXkubGVuZ3RoOwotCQkJaWYgKGFycmF5TGVuZ3RoICE9IDApIHsKLQkJCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCAwLCByZXN1bHQsIGN1cnJlbnQsIGFycmF5TGVuZ3RoKTsKLQkJCQljdXJyZW50ICs9IGFycmF5TGVuZ3RoOwotCQkJfQotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgbmV3IGFycmF5IHRoYXQgY29udGFpbnMgdGhlIGVsZW1lbnRzIGluIHRoZQotCSAqIGZpcnN0IHNwZWNpZmllZCBhcnJheSB3aXRoIHRoZSBvYmplY3RzIGluIHRoZSBzZWNvbmQKLQkgKiBzcGVjaWZpZWQgYXJyYXkgYWRkZWQgYXQgdGhlIHNwZWNpZmllZCBpbmRleC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2FkZChPYmplY3RbXSBhcnJheTEsIGludCBpbmRleCwgT2JqZWN0W10gYXJyYXkyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSBhZGRBbGwoRVtdIGFycmF5MSwgaW50IGluZGV4LCBFW10gYXJyYXkyKSB7Ci0JCWludCBhcnJheTJMZW5ndGggPSBhcnJheTIubGVuZ3RoOwotCQlyZXR1cm4gKGFycmF5Mkxlbmd0aCA9PSAwKSA/IGFycmF5MSA6IGFkZEFsbChhcnJheTEsIGluZGV4LCBhcnJheTIsIGFycmF5Mkxlbmd0aCk7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIGFycmF5Mkxlbmd0aCA+IDAKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyA8RT4gRVtdIGFkZEFsbChFW10gYXJyYXkxLCBpbnQgaW5kZXgsIEVbXSBhcnJheTIsIGludCBhcnJheTJMZW5ndGgpIHsKLQkJaW50IGFycmF5MUxlbmd0aCA9IGFycmF5MS5sZW5ndGg7Ci0JCXJldHVybiAoaW5kZXggPT0gYXJyYXkxTGVuZ3RoKSA/ICAvLyBhcnJheTIgYWRkZWQgdG8gZW5kIG9mIGFycmF5MQotCQkJCShhcnJheTFMZW5ndGggPT0gMCkgPyBhcnJheTIgOiBhZGRBbGwoYXJyYXkxLCBhcnJheTIsIGFycmF5MUxlbmd0aCwgYXJyYXkyTGVuZ3RoKQotCQkJOgotCQkJCWFkZEFsbChhcnJheTEsIGluZGV4LCBhcnJheTIsIGFycmF5MUxlbmd0aCwgYXJyYXkyTGVuZ3RoKTsKLQl9Ci0KLQkvKioKLQkgKiBhc3N1bWUgYXJyYXkxTGVuZ3RoID4gMCBhbmQgYXJyYXkyTGVuZ3RoID4gMAotCSAqLwotCXByaXZhdGUgc3RhdGljIDxFPiBFW10gYWRkQWxsKEVbXSBhcnJheTEsIGludCBpbmRleCwgRVtdIGFycmF5MiwgaW50IGFycmF5MUxlbmd0aCwgaW50IGFycmF5Mkxlbmd0aCkgewotCQlFW10gcmVzdWx0ID0gbmV3QXJyYXkoYXJyYXkxLCBhcnJheTFMZW5ndGggKyBhcnJheTJMZW5ndGgpOwotCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5MSwgMCwgcmVzdWx0LCAwLCBpbmRleCk7Ci0JCVN5c3RlbS5hcnJheWNvcHkoYXJyYXkyLCAwLCByZXN1bHQsIGluZGV4LCBhcnJheTJMZW5ndGgpOwotCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5MSwgaW5kZXgsIHJlc3VsdCwgaW5kZXggKyBhcnJheTJMZW5ndGgsIGFycmF5MUxlbmd0aCAtIGluZGV4KTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgYXJyYXkgdGhhdCBjb250YWlucyB0aGUgZWxlbWVudHMgaW4gdGhlCi0JICogc3BlY2lmaWVkIGFycmF5IHdpdGggdGhlIGVsZW1lbnRzCi0JICogaW4gdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uIGluc2VydGVkIGF0IHRoZSBzcGVjaWZpZWQgaW5kZXguCi0JICogamF2YS51dGlsLkFycmF5cyNhZGRBbGwoT2JqZWN0W10gYXJyYXksIGludCBpbmRleCwgamF2YS51dGlsLkNvbGxlY3Rpb24gYykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gYWRkQWxsKEVbXSBhcnJheSwgaW50IGluZGV4LCBDb2xsZWN0aW9uPD8gZXh0ZW5kcyBFPiBjb2xsZWN0aW9uKSB7Ci0JCWludCBzaXplID0gY29sbGVjdGlvbi5zaXplKCk7Ci0JCXJldHVybiAoc2l6ZSA9PSAwKSA/IGFycmF5IDogYWRkQWxsKGFycmF5LCBpbmRleCwgY29sbGVjdGlvbiwgc2l6ZSk7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIGNvbGxlY3Rpb24gaXMgbm9uLWVtcHR5Ci0JICovCi0JcHJpdmF0ZSBzdGF0aWMgPEU+IEVbXSBhZGRBbGxfKEVbXSBhcnJheSwgaW50IGluZGV4LCBDb2xsZWN0aW9uPD8gZXh0ZW5kcyBFPiBjb2xsZWN0aW9uKSB7Ci0JCXJldHVybiBhZGRBbGwoYXJyYXksIGluZGV4LCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uLnNpemUoKSk7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIGNvbGxlY3Rpb24gaXMgbm9uLWVtcHR5Ci0JICovCi0JcHJpdmF0ZSBzdGF0aWMgPEU+IEVbXSBhZGRBbGwoRVtdIGFycmF5LCBpbnQgaW5kZXgsIENvbGxlY3Rpb248PyBleHRlbmRzIEU+IGNvbGxlY3Rpb24sIGludCBjb2xsZWN0aW9uU2l6ZSkgewotCQlpbnQgYXJyYXlMZW5ndGggPSBhcnJheS5sZW5ndGg7Ci0JCUVbXSByZXN1bHQgPSBuZXdBcnJheShhcnJheSwgYXJyYXlMZW5ndGggKyBjb2xsZWN0aW9uU2l6ZSk7Ci0JCWlmICgoYXJyYXlMZW5ndGggPT0gMCkgJiYgKGluZGV4ID09IDApKSB7Ci0JCQlyZXR1cm4gY29sbGVjdGlvbi50b0FycmF5KHJlc3VsdCk7Ci0JCX0KLQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgMCwgcmVzdWx0LCAwLCBpbmRleCk7Ci0JCWludCBpID0gaW5kZXg7Ci0JCWZvciAoRSBpdGVtIDogY29sbGVjdGlvbikgewotCQkJcmVzdWx0W2krK10gPSBpdGVtOwotCQl9Ci0JCVN5c3RlbS5hcnJheWNvcHkoYXJyYXksIGluZGV4LCByZXN1bHQsIGluZGV4ICsgY29sbGVjdGlvblNpemUsIGFycmF5TGVuZ3RoIC0gaW5kZXgpOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBhcnJheSB0aGF0IGNvbnRhaW5zIHRoZSBlbGVtZW50cyBpbiB0aGUKLQkgKiBzcGVjaWZpZWQgYXJyYXkgd2l0aCB0aGUgZWxlbWVudHMKLQkgKiBpbiB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlIGluc2VydGVkIGF0IHRoZSBzcGVjaWZpZWQgaW5kZXguCi0JICogamF2YS51dGlsLkFycmF5cyNhZGRBbGwoT2JqZWN0W10gYXJyYXksIGludCBpbmRleCwgamF2YS5sYW5nLkl0ZXJhYmxlIGl0ZXJhYmxlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSBhZGRBbGwoRVtdIGFycmF5LCBpbnQgaW5kZXgsIEl0ZXJhYmxlPD8gZXh0ZW5kcyBFPiBpdGVyYWJsZSkgewotCQlyZXR1cm4gYWRkQWxsKGFycmF5LCBpbmRleCwgaXRlcmFibGUuaXRlcmF0b3IoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgbmV3IGFycmF5IHRoYXQgY29udGFpbnMgdGhlIGVsZW1lbnRzIGluIHRoZQotCSAqIHNwZWNpZmllZCBhcnJheSB3aXRoIHRoZSBlbGVtZW50cwotCSAqIGluIHRoZSBzcGVjaWZpZWQgaXRlcmFibGUgaW5zZXJ0ZWQgYXQgdGhlIHNwZWNpZmllZCBpbmRleC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2FkZEFsbChPYmplY3RbXSBhcnJheSwgaW50IGluZGV4LCBqYXZhLmxhbmcuSXRlcmFibGUgaXRlcmFibGUpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gRVtdIGFkZEFsbChFW10gYXJyYXksIGludCBpbmRleCwgSXRlcmFibGU8PyBleHRlbmRzIEU+IGl0ZXJhYmxlLCBpbnQgc2l6ZSkgewotCQlyZXR1cm4gYWRkQWxsKGFycmF5LCBpbmRleCwgaXRlcmFibGUuaXRlcmF0b3IoKSwgc2l6ZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgbmV3IGFycmF5IHRoYXQgY29udGFpbnMgdGhlIGVsZW1lbnRzIGluIHRoZQotCSAqIHNwZWNpZmllZCBhcnJheSB3aXRoIHRoZSBlbGVtZW50cwotCSAqIGluIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IgaW5zZXJ0ZWQgYXQgdGhlIHNwZWNpZmllZCBpbmRleC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2FkZEFsbChPYmplY3RbXSBhcnJheSwgaW50IGluZGV4LCBqYXZhLnV0aWwuSXRlcmF0b3IgaXRlcmF0b3IpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gRVtdIGFkZEFsbChFW10gYXJyYXksIGludCBpbmRleCwgSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yKSB7Ci0JCXJldHVybiAoaXRlcmF0b3IuaGFzTmV4dCgpKSA/IGFkZEFsbF8oYXJyYXksIGluZGV4LCBsaXN0KGl0ZXJhdG9yKSkgOiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgYXJyYXkgdGhhdCBjb250YWlucyB0aGUgZWxlbWVudHMgaW4gdGhlCi0JICogc3BlY2lmaWVkIGFycmF5IHdpdGggdGhlIGVsZW1lbnRzCi0JICogaW4gdGhlIHNwZWNpZmllZCBpdGVyYXRvciBpbnNlcnRlZCBhdCB0aGUgc3BlY2lmaWVkIGluZGV4LgotCSAqIGphdmEudXRpbC5BcnJheXMjYWRkQWxsKE9iamVjdFtdIGFycmF5LCBpbnQgaW5kZXgsIGphdmEudXRpbC5JdGVyYXRvciBpdGVyYXRvcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gYWRkQWxsKEVbXSBhcnJheSwgaW50IGluZGV4LCBJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IsIGludCBzaXplKSB7Ci0JCXJldHVybiAoaXRlcmF0b3IuaGFzTmV4dCgpKSA/IGFkZEFsbF8oYXJyYXksIGluZGV4LCBsaXN0KGl0ZXJhdG9yLCBzaXplKSkgOiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgYXJyYXkgdGhhdCBjb250YWlucyB0aGUgZWxlbWVudHMgaW4gdGhlCi0JICogc3BlY2lmaWVkIGFycmF5IDEgZm9sbG93ZWQgYnkgdGhlIGVsZW1lbnRzCi0JICogaW4gdGhlIHNwZWNpZmllZCBhcnJheSAyLgotCSAqIGphdmEudXRpbC5BcnJheXMjYWRkQWxsKGNoYXJbXSBhcnJheTEsIGNoYXJbXSBhcnJheTIpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gYWRkQWxsKGNoYXJbXSBhcnJheTEsIGNoYXJbXSBhcnJheTIpIHsKLQkJaW50IGFycmF5Mkxlbmd0aCA9IGFycmF5Mi5sZW5ndGg7Ci0JCXJldHVybiAoYXJyYXkyTGVuZ3RoID09IDApID8gYXJyYXkxIDogYWRkQWxsKGFycmF5MSwgYXJyYXkyLCBhcnJheTJMZW5ndGgpOwotCX0KLQotCS8qKgotCSAqIGFzc3VtZSBhcnJheTJMZW5ndGggPiAwCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgY2hhcltdIGFkZEFsbChjaGFyW10gYXJyYXkxLCBjaGFyW10gYXJyYXkyLCBpbnQgYXJyYXkyTGVuZ3RoKSB7Ci0JCWludCBhcnJheTFMZW5ndGggPSBhcnJheTEubGVuZ3RoOwotCQlyZXR1cm4gKGFycmF5MUxlbmd0aCA9PSAwKSA/IGFycmF5MiA6IGFkZEFsbChhcnJheTEsIGFycmF5MiwgYXJyYXkxTGVuZ3RoLCBhcnJheTJMZW5ndGgpOwotCX0KLQotCS8qKgotCSAqIGFzc3VtZSBhcnJheTFMZW5ndGggPiAwIGFuZCBhcnJheTJMZW5ndGggPiAwCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgY2hhcltdIGFkZEFsbChjaGFyW10gYXJyYXkxLCBjaGFyW10gYXJyYXkyLCBpbnQgYXJyYXkxTGVuZ3RoLCBpbnQgYXJyYXkyTGVuZ3RoKSB7Ci0JCWNoYXJbXSByZXN1bHQgPSBuZXcgY2hhclthcnJheTFMZW5ndGggKyBhcnJheTJMZW5ndGhdOwotCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5MSwgMCwgcmVzdWx0LCAwLCBhcnJheTFMZW5ndGgpOwotCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5MiwgMCwgcmVzdWx0LCBhcnJheTFMZW5ndGgsIGFycmF5Mkxlbmd0aCk7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgbmV3IGFycmF5IHRoYXQgY29udGFpbnMgYWxsIHRoZSBlbGVtZW50cyBpbiAgYWxsIHRoZQotCSAqIHNwZWNpZmllZCBhcnJheXMsIGNvbmNhdGVuYXRlZCBpbiB0aGUgc3BlY2lmaWVkIG9yZGVyLgotCSAqIFRoaXMgaXMgdXNlZnVsIGZvciBidWlsZGluZyBjb25zdGFudCBhcnJheXMgb3V0IG90aGVyIGNvbnN0YW50IGFycmF5cy4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2NvbmNhdGVuYXRlKGNoYXJbXS4uLiBhcnJheXMpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gY29uY2F0ZW5hdGUoY2hhcltdLi4uIGFycmF5cykgewotCQlpbnQgbGVuID0gMDsKLQkJZm9yIChjaGFyW10gYXJyYXkgOiBhcnJheXMpIHsKLQkJCWxlbiArPSBhcnJheS5sZW5ndGg7Ci0JCX0KLQkJaWYgKGxlbiA9PSAwKSB7Ci0JCQlyZXR1cm4gRU1QVFlfQ0hBUl9BUlJBWTsKLQkJfQotCQljaGFyW10gcmVzdWx0ID0gbmV3IGNoYXJbbGVuXTsKLQkJaW50IGN1cnJlbnQgPSAwOwotCQlmb3IgKGNoYXJbXSBhcnJheSA6IGFycmF5cykgewotCQkJaW50IGFycmF5TGVuZ3RoID0gYXJyYXkubGVuZ3RoOwotCQkJaWYgKGFycmF5TGVuZ3RoICE9IDApIHsKLQkJCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCAwLCByZXN1bHQsIGN1cnJlbnQsIGFycmF5TGVuZ3RoKTsKLQkJCQljdXJyZW50ICs9IGFycmF5TGVuZ3RoOwotCQkJfQotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgbmV3IGFycmF5IHRoYXQgY29udGFpbnMgdGhlIGVsZW1lbnRzIGluIHRoZQotCSAqIGZpcnN0IHNwZWNpZmllZCBhcnJheSB3aXRoIHRoZSBvYmplY3RzIGluIHRoZSBzZWNvbmQKLQkgKiBzcGVjaWZpZWQgYXJyYXkgYWRkZWQgYXQgdGhlIHNwZWNpZmllZCBpbmRleC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2FkZChjaGFyW10gYXJyYXkxLCBpbnQgaW5kZXgsIGNoYXJbXSBhcnJheTIpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gYWRkQWxsKGNoYXJbXSBhcnJheTEsIGludCBpbmRleCwgY2hhcltdIGFycmF5MikgewotCQlpbnQgYXJyYXkyTGVuZ3RoID0gYXJyYXkyLmxlbmd0aDsKLQkJcmV0dXJuIChhcnJheTJMZW5ndGggPT0gMCkgPyBhcnJheTEgOiBhZGRBbGwoYXJyYXkxLCBpbmRleCwgYXJyYXkyLCBhcnJheTJMZW5ndGgpOwotCX0KLQotCS8qKgotCSAqIGFzc3VtZSBhcnJheTJMZW5ndGggPiAwCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgY2hhcltdIGFkZEFsbChjaGFyW10gYXJyYXkxLCBpbnQgaW5kZXgsIGNoYXJbXSBhcnJheTIsIGludCBhcnJheTJMZW5ndGgpIHsKLQkJaW50IGFycmF5MUxlbmd0aCA9IGFycmF5MS5sZW5ndGg7Ci0JCXJldHVybiAoaW5kZXggPT0gYXJyYXkxTGVuZ3RoKSA/ICAvLyBhcnJheTIgYWRkZWQgdG8gZW5kIG9mIGFycmF5MQotCQkJCShhcnJheTFMZW5ndGggPT0gMCkgPyBhcnJheTIgOiBhZGRBbGwoYXJyYXkxLCBhcnJheTIsIGFycmF5MUxlbmd0aCwgYXJyYXkyTGVuZ3RoKQotCQkJOgotCQkJCWFkZEFsbChhcnJheTEsIGluZGV4LCBhcnJheTIsIGFycmF5MUxlbmd0aCwgYXJyYXkyTGVuZ3RoKTsKLQl9Ci0KLQkvKioKLQkgKiBhc3N1bWUgYXJyYXkxTGVuZ3RoID4gMCBhbmQgYXJyYXkyTGVuZ3RoID4gMAotCSAqLwotCXByaXZhdGUgc3RhdGljIGNoYXJbXSBhZGRBbGwoY2hhcltdIGFycmF5MSwgaW50IGluZGV4LCBjaGFyW10gYXJyYXkyLCBpbnQgYXJyYXkxTGVuZ3RoLCBpbnQgYXJyYXkyTGVuZ3RoKSB7Ci0JCWNoYXJbXSByZXN1bHQgPSBuZXcgY2hhclthcnJheTFMZW5ndGggKyBhcnJheTJMZW5ndGhdOwotCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5MSwgMCwgcmVzdWx0LCAwLCBpbmRleCk7Ci0JCVN5c3RlbS5hcnJheWNvcHkoYXJyYXkyLCAwLCByZXN1bHQsIGluZGV4LCBhcnJheTJMZW5ndGgpOwotCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5MSwgaW5kZXgsIHJlc3VsdCwgaW5kZXggKyBhcnJheTJMZW5ndGgsIGFycmF5MUxlbmd0aCAtIGluZGV4KTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgYXJyYXkgdGhhdCBjb250YWlucyB0aGUgZWxlbWVudHMgaW4gdGhlCi0JICogc3BlY2lmaWVkIGFycmF5IDEgZm9sbG93ZWQgYnkgdGhlIGVsZW1lbnRzCi0JICogaW4gdGhlIHNwZWNpZmllZCBhcnJheSAyLgotCSAqIGphdmEudXRpbC5BcnJheXMjYWRkQWxsKGludFtdIGFycmF5MSwgaW50W10gYXJyYXkyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50W10gYWRkQWxsKGludFtdIGFycmF5MSwgaW50W10gYXJyYXkyKSB7Ci0JCWludCBhcnJheTJMZW5ndGggPSBhcnJheTIubGVuZ3RoOwotCQlyZXR1cm4gKGFycmF5Mkxlbmd0aCA9PSAwKSA/IGFycmF5MSA6IGFkZEFsbChhcnJheTEsIGFycmF5MiwgYXJyYXkyTGVuZ3RoKTsKLQl9Ci0KLQkvKioKLQkgKiBhc3N1bWUgYXJyYXkyTGVuZ3RoID4gMAotCSAqLwotCXByaXZhdGUgc3RhdGljIGludFtdIGFkZEFsbChpbnRbXSBhcnJheTEsIGludFtdIGFycmF5MiwgaW50IGFycmF5Mkxlbmd0aCkgewotCQlpbnQgYXJyYXkxTGVuZ3RoID0gYXJyYXkxLmxlbmd0aDsKLQkJcmV0dXJuIChhcnJheTFMZW5ndGggPT0gMCkgPyBhcnJheTIgOiBhZGRBbGwoYXJyYXkxLCBhcnJheTIsIGFycmF5MUxlbmd0aCwgYXJyYXkyTGVuZ3RoKTsKLQl9Ci0KLQkvKioKLQkgKiBhc3N1bWUgYXJyYXkxTGVuZ3RoID4gMCBhbmQgYXJyYXkyTGVuZ3RoID4gMAotCSAqLwotCXByaXZhdGUgc3RhdGljIGludFtdIGFkZEFsbChpbnRbXSBhcnJheTEsIGludFtdIGFycmF5MiwgaW50IGFycmF5MUxlbmd0aCwgaW50IGFycmF5Mkxlbmd0aCkgewotCQlpbnRbXSByZXN1bHQgPSBuZXcgaW50W2FycmF5MUxlbmd0aCArIGFycmF5Mkxlbmd0aF07Ci0JCVN5c3RlbS5hcnJheWNvcHkoYXJyYXkxLCAwLCByZXN1bHQsIDAsIGFycmF5MUxlbmd0aCk7Ci0JCVN5c3RlbS5hcnJheWNvcHkoYXJyYXkyLCAwLCByZXN1bHQsIGFycmF5MUxlbmd0aCwgYXJyYXkyTGVuZ3RoKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgYXJyYXkgdGhhdCBjb250YWlucyBhbGwgdGhlIGVsZW1lbnRzIGluICBhbGwgdGhlCi0JICogc3BlY2lmaWVkIGFycmF5cywgY29uY2F0ZW5hdGVkIGluIHRoZSBzcGVjaWZpZWQgb3JkZXIuCi0JICogVGhpcyBpcyB1c2VmdWwgZm9yIGJ1aWxkaW5nIGNvbnN0YW50IGFycmF5cyBvdXQgb3RoZXIgY29uc3RhbnQgYXJyYXlzLgotCSAqIGphdmEudXRpbC5BcnJheXMjY29uY2F0ZW5hdGUoaW50W10uLi4gYXJyYXlzKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50W10gY29uY2F0ZW5hdGUoaW50W10uLi4gYXJyYXlzKSB7Ci0JCWludCBsZW4gPSAwOwotCQlmb3IgKGludFtdIGFycmF5IDogYXJyYXlzKSB7Ci0JCQlsZW4gKz0gYXJyYXkubGVuZ3RoOwotCQl9Ci0JCWlmIChsZW4gPT0gMCkgewotCQkJcmV0dXJuIEVNUFRZX0lOVF9BUlJBWTsKLQkJfQotCQlpbnRbXSByZXN1bHQgPSBuZXcgaW50W2xlbl07Ci0JCWludCBjdXJyZW50ID0gMDsKLQkJZm9yIChpbnRbXSBhcnJheSA6IGFycmF5cykgewotCQkJaW50IGFycmF5TGVuZ3RoID0gYXJyYXkubGVuZ3RoOwotCQkJaWYgKGFycmF5TGVuZ3RoICE9IDApIHsKLQkJCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCAwLCByZXN1bHQsIGN1cnJlbnQsIGFycmF5TGVuZ3RoKTsKLQkJCQljdXJyZW50ICs9IGFycmF5TGVuZ3RoOwotCQkJfQotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgbmV3IGFycmF5IHRoYXQgY29udGFpbnMgdGhlIGVsZW1lbnRzIGluIHRoZQotCSAqIGZpcnN0IHNwZWNpZmllZCBhcnJheSB3aXRoIHRoZSBvYmplY3RzIGluIHRoZSBzZWNvbmQKLQkgKiBzcGVjaWZpZWQgYXJyYXkgYWRkZWQgYXQgdGhlIHNwZWNpZmllZCBpbmRleC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2FkZChpbnRbXSBhcnJheTEsIGludCBpbmRleCwgaW50W10gYXJyYXkyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50W10gYWRkQWxsKGludFtdIGFycmF5MSwgaW50IGluZGV4LCBpbnRbXSBhcnJheTIpIHsKLQkJaW50IGFycmF5Mkxlbmd0aCA9IGFycmF5Mi5sZW5ndGg7Ci0JCXJldHVybiAoYXJyYXkyTGVuZ3RoID09IDApID8gYXJyYXkxIDogYWRkQWxsKGFycmF5MSwgaW5kZXgsIGFycmF5MiwgYXJyYXkyTGVuZ3RoKTsKLQl9Ci0KLQkvKioKLQkgKiBhc3N1bWUgYXJyYXkyTGVuZ3RoID4gMAotCSAqLwotCXByaXZhdGUgc3RhdGljIGludFtdIGFkZEFsbChpbnRbXSBhcnJheTEsIGludCBpbmRleCwgaW50W10gYXJyYXkyLCBpbnQgYXJyYXkyTGVuZ3RoKSB7Ci0JCWludCBhcnJheTFMZW5ndGggPSBhcnJheTEubGVuZ3RoOwotCQlyZXR1cm4gKGluZGV4ID09IGFycmF5MUxlbmd0aCkgPyAgLy8gYXJyYXkyIGFkZGVkIHRvIGVuZCBvZiBhcnJheTEKLQkJCQkoYXJyYXkxTGVuZ3RoID09IDApID8gYXJyYXkyIDogYWRkQWxsKGFycmF5MSwgYXJyYXkyLCBhcnJheTFMZW5ndGgsIGFycmF5Mkxlbmd0aCkKLQkJCToKLQkJCQlhZGRBbGwoYXJyYXkxLCBpbmRleCwgYXJyYXkyLCBhcnJheTFMZW5ndGgsIGFycmF5Mkxlbmd0aCk7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIGFycmF5MUxlbmd0aCA+IDAgYW5kIGFycmF5Mkxlbmd0aCA+IDAKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBpbnRbXSBhZGRBbGwoaW50W10gYXJyYXkxLCBpbnQgaW5kZXgsIGludFtdIGFycmF5MiwgaW50IGFycmF5MUxlbmd0aCwgaW50IGFycmF5Mkxlbmd0aCkgewotCQlpbnRbXSByZXN1bHQgPSBuZXcgaW50W2FycmF5MUxlbmd0aCArIGFycmF5Mkxlbmd0aF07Ci0JCVN5c3RlbS5hcnJheWNvcHkoYXJyYXkxLCAwLCByZXN1bHQsIDAsIGluZGV4KTsKLQkJU3lzdGVtLmFycmF5Y29weShhcnJheTIsIDAsIHJlc3VsdCwgaW5kZXgsIGFycmF5Mkxlbmd0aCk7Ci0JCVN5c3RlbS5hcnJheWNvcHkoYXJyYXkxLCBpbmRleCwgcmVzdWx0LCBpbmRleCArIGFycmF5Mkxlbmd0aCwgYXJyYXkxTGVuZ3RoIC0gaW5kZXgpOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhbiBhcnJheSBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmFibGUuCi0JICogQHNlZSBqYXZhLnV0aWwuQ29sbGVjdGlvbiN0b0FycmF5KCkKLQkgKiBqYXZhLmxhbmcuSXRlcmFibGUjdG9BcnJheSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3RbXSBhcnJheShJdGVyYWJsZTw/PiBpdGVyYWJsZSkgewotCQlyZXR1cm4gYXJyYXkoaXRlcmFibGUuaXRlcmF0b3IoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGFuIGFycmF5IGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBpdGVyYWJsZS4KLQkgKiBAc2VlIGphdmEudXRpbC5Db2xsZWN0aW9uI3RvQXJyYXkoKQotCSAqIGphdmEubGFuZy5JdGVyYWJsZSN0b0FycmF5KCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdFtdIGFycmF5KEl0ZXJhYmxlPD8+IGl0ZXJhYmxlLCBpbnQgc2l6ZSkgewotCQlyZXR1cm4gYXJyYXkoaXRlcmFibGUuaXRlcmF0b3IoKSwgc2l6ZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGFuIGFycmF5IGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBpdGVyYWJsZTsKLQkgKiB0aGUgcnVudGltZSB0eXBlIG9mIHRoZSByZXR1cm5lZCBhcnJheSBpcyB0aGF0IG9mIHRoZSBzcGVjaWZpZWQgYXJyYXkuCi0JICogSWYgdGhlIGNvbGxlY3Rpb24gZml0cyBpbiB0aGUgc3BlY2lmaWVkIGFycmF5LCBpdCBpcyByZXR1cm5lZCB0aGVyZWluLgotCSAqIE90aGVyd2lzZSwgYSBuZXcgYXJyYXkgaXMgYWxsb2NhdGVkIHdpdGggdGhlIHJ1bnRpbWUgdHlwZSBvZiB0aGUKLQkgKiBzcGVjaWZpZWQgYXJyYXkgYW5kIHRoZSBzaXplIG9mIHRoaXMgY29sbGVjdGlvbi4KLQkgKiBAc2VlIGphdmEudXRpbC5Db2xsZWN0aW9uI3RvQXJyYXkoamF2YS5sYW5nLk9iamVjdFtdKQotCSAqIGphdmEubGFuZy5JdGVyYWJsZSN0b0FycmF5KE9iamVjdFtdKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSBhcnJheShJdGVyYWJsZTw/IGV4dGVuZHMgRT4gaXRlcmFibGUsIEVbXSBhcnJheSkgewotCQlyZXR1cm4gYXJyYXkoaXRlcmFibGUuaXRlcmF0b3IoKSwgYXJyYXkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhbiBhcnJheSBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmFibGU7Ci0JICogdGhlIHJ1bnRpbWUgdHlwZSBvZiB0aGUgcmV0dXJuZWQgYXJyYXkgaXMgdGhhdCBvZiB0aGUgc3BlY2lmaWVkIGFycmF5LgotCSAqIElmIHRoZSBjb2xsZWN0aW9uIGZpdHMgaW4gdGhlIHNwZWNpZmllZCBhcnJheSwgaXQgaXMgcmV0dXJuZWQgdGhlcmVpbi4KLQkgKiBPdGhlcndpc2UsIGEgbmV3IGFycmF5IGlzIGFsbG9jYXRlZCB3aXRoIHRoZSBydW50aW1lIHR5cGUgb2YgdGhlCi0JICogc3BlY2lmaWVkIGFycmF5IGFuZCB0aGUgc2l6ZSBvZiB0aGlzIGNvbGxlY3Rpb24uCi0JICogQHNlZSBqYXZhLnV0aWwuQ29sbGVjdGlvbiN0b0FycmF5KGphdmEubGFuZy5PYmplY3RbXSkKLQkgKiBqYXZhLmxhbmcuSXRlcmFibGUjdG9BcnJheShPYmplY3RbXSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gYXJyYXkoSXRlcmFibGU8PyBleHRlbmRzIEU+IGl0ZXJhYmxlLCBpbnQgc2l6ZSwgRVtdIGFycmF5KSB7Ci0JCXJldHVybiBhcnJheShpdGVyYWJsZS5pdGVyYXRvcigpLCBzaXplLCBhcnJheSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGFuIGFycmF5IGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBpdGVyYXRvci4KLQkgKiBAc2VlIGphdmEudXRpbC5Db2xsZWN0aW9uI3RvQXJyYXkoKQotCSAqIGphdmEudXRpbC5JdGVyYXRvciN0b0FycmF5KCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdFtdIGFycmF5KEl0ZXJhdG9yPD8+IGl0ZXJhdG9yKSB7Ci0JCXJldHVybiAoaXRlcmF0b3IuaGFzTmV4dCgpKSA/IGxpc3QoaXRlcmF0b3IpLnRvQXJyYXkoKSA6IEVNUFRZX09CSkVDVF9BUlJBWTsKLQl9Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgT2JqZWN0W10gRU1QVFlfT0JKRUNUX0FSUkFZID0gbmV3IE9iamVjdFswXTsKLQotCS8qKgotCSAqIFJldHVybiBhbiBhcnJheSBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICogQHNlZSBqYXZhLnV0aWwuQ29sbGVjdGlvbiN0b0FycmF5KCkKLQkgKiBqYXZhLnV0aWwuSXRlcmF0b3IjdG9BcnJheSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3RbXSBhcnJheShJdGVyYXRvcjw/PiBpdGVyYXRvciwgaW50IHNpemUpIHsKLQkJcmV0dXJuIChpdGVyYXRvci5oYXNOZXh0KCkpID8gbGlzdChpdGVyYXRvciwgc2l6ZSkudG9BcnJheSgpIDogRU1QVFlfT0JKRUNUX0FSUkFZOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhbiBhcnJheSBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3I7Ci0JICogdGhlIHJ1bnRpbWUgdHlwZSBvZiB0aGUgcmV0dXJuZWQgYXJyYXkgaXMgdGhhdCBvZiB0aGUgc3BlY2lmaWVkIGFycmF5LgotCSAqIElmIHRoZSBjb2xsZWN0aW9uIGZpdHMgaW4gdGhlIHNwZWNpZmllZCBhcnJheSwgaXQgaXMgcmV0dXJuZWQgdGhlcmVpbi4KLQkgKiBPdGhlcndpc2UsIGEgbmV3IGFycmF5IGlzIGFsbG9jYXRlZCB3aXRoIHRoZSBydW50aW1lIHR5cGUgb2YgdGhlCi0JICogc3BlY2lmaWVkIGFycmF5IGFuZCB0aGUgc2l6ZSBvZiB0aGlzIGNvbGxlY3Rpb24uCi0JICogQHNlZSBqYXZhLnV0aWwuQ29sbGVjdGlvbiN0b0FycmF5KGphdmEubGFuZy5PYmplY3RbXSkKLQkgKiBqYXZhLnV0aWwuSXRlcmF0b3IjdG9BcnJheShPYmplY3RbXSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gYXJyYXkoSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yLCBFW10gYXJyYXkpIHsKLQkJcmV0dXJuIChpdGVyYXRvci5oYXNOZXh0KCkpID8gbGlzdChpdGVyYXRvcikudG9BcnJheShhcnJheSkgOiBuZXdBcnJheShhcnJheSwgMCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGFuIGFycmF5IGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBpdGVyYXRvcjsKLQkgKiB0aGUgcnVudGltZSB0eXBlIG9mIHRoZSByZXR1cm5lZCBhcnJheSBpcyB0aGF0IG9mIHRoZSBzcGVjaWZpZWQgYXJyYXkuCi0JICogSWYgdGhlIGNvbGxlY3Rpb24gZml0cyBpbiB0aGUgc3BlY2lmaWVkIGFycmF5LCBpdCBpcyByZXR1cm5lZCB0aGVyZWluLgotCSAqIE90aGVyd2lzZSwgYSBuZXcgYXJyYXkgaXMgYWxsb2NhdGVkIHdpdGggdGhlIHJ1bnRpbWUgdHlwZSBvZiB0aGUKLQkgKiBzcGVjaWZpZWQgYXJyYXkgYW5kIHRoZSBzaXplIG9mIHRoaXMgY29sbGVjdGlvbi4KLQkgKiBAc2VlIGphdmEudXRpbC5Db2xsZWN0aW9uI3RvQXJyYXkoamF2YS5sYW5nLk9iamVjdFtdKQotCSAqIGphdmEudXRpbC5JdGVyYXRvciN0b0FycmF5KE9iamVjdFtdKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSBhcnJheShJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IsIGludCBzaXplLCBFW10gYXJyYXkpIHsKLQkJcmV0dXJuIChpdGVyYXRvci5oYXNOZXh0KCkpID8gbGlzdChpdGVyYXRvciwgc2l6ZSkudG9BcnJheShhcnJheSkgOiBuZXdBcnJheShhcnJheSwgMCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgYmFnIGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBlbnVtZXJhdGlvbi4KLQkgKiBIYXNoQmFnKGphdmEudXRpbC5FbnVtZXJhdGlvbiBlbnVtZXJhdGlvbikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBIYXNoQmFnPEU+IGJhZyhFbnVtZXJhdGlvbjw/IGV4dGVuZHMgRT4gZW51bWVyYXRpb24pIHsKLQkJcmV0dXJuIGJhZyhlbnVtZXJhdGlvbiwgbmV3IEhhc2hCYWc8RT4oKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgYmFnIGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBlbnVtZXJhdGlvbi4KLQkgKiBIYXNoQmFnKGphdmEudXRpbC5FbnVtZXJhdGlvbiBlbnVtZXJhdGlvbikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBIYXNoQmFnPEU+IGJhZyhFbnVtZXJhdGlvbjw/IGV4dGVuZHMgRT4gZW51bWVyYXRpb24sIGludCBzaXplKSB7Ci0JCXJldHVybiBiYWcoZW51bWVyYXRpb24sIG5ldyBIYXNoQmFnPEU+KHNpemUpKTsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyA8RT4gSGFzaEJhZzxFPiBiYWcoRW51bWVyYXRpb248PyBleHRlbmRzIEU+IGVudW1lcmF0aW9uLCBIYXNoQmFnPEU+IGJhZykgewotCQl3aGlsZSAoZW51bWVyYXRpb24uaGFzTW9yZUVsZW1lbnRzKCkpIHsKLQkJCWJhZy5hZGQoZW51bWVyYXRpb24ubmV4dEVsZW1lbnQoKSk7Ci0JCX0KLQkJcmV0dXJuIGJhZzsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBiYWcgY29ycmVzcG9uZGluZyB0byB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlLgotCSAqIEhhc2hCYWcoamF2YS5sYW5nLkl0ZXJhYmxlIGl0ZXJhYmxlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEhhc2hCYWc8RT4gYmFnKEl0ZXJhYmxlPD8gZXh0ZW5kcyBFPiBpdGVyYWJsZSkgewotCQlyZXR1cm4gYmFnKGl0ZXJhYmxlLml0ZXJhdG9yKCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIGJhZyBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmFibGUuCi0JICogSGFzaEJhZyhqYXZhLmxhbmcuSXRlcmFibGUgaXRlcmFibGUpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gSGFzaEJhZzxFPiBiYWcoSXRlcmFibGU8PyBleHRlbmRzIEU+IGl0ZXJhYmxlLCBpbnQgc2l6ZSkgewotCQlyZXR1cm4gYmFnKGl0ZXJhYmxlLml0ZXJhdG9yKCksIHNpemUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIGJhZyBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICogSGFzaEJhZyhqYXZhLnV0aWwuSXRlcmF0b3IgaXRlcmF0b3IpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gSGFzaEJhZzxFPiBiYWcoSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yKSB7Ci0JCXJldHVybiBiYWcoaXRlcmF0b3IsIG5ldyBIYXNoQmFnPEU+KCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIGJhZyBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICogSGFzaEJhZyhqYXZhLnV0aWwuSXRlcmF0b3IgaXRlcmF0b3IpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gSGFzaEJhZzxFPiBiYWcoSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yLCBpbnQgc2l6ZSkgewotCQlyZXR1cm4gYmFnKGl0ZXJhdG9yLCBuZXcgSGFzaEJhZzxFPihzaXplKSk7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgPEU+IEhhc2hCYWc8RT4gYmFnKEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVyYXRvciwgSGFzaEJhZzxFPiBiYWcpIHsKLQkJd2hpbGUgKGl0ZXJhdG9yLmhhc05leHQoKSkgewotCQkJYmFnLmFkZChpdGVyYXRvci5uZXh0KCkpOwotCQl9Ci0JCXJldHVybiBiYWc7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgYmFnIGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBhcnJheS4KLQkgKiBIYXNoQmFnKE9iamVjdFtdIGFycmF5KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEhhc2hCYWc8RT4gYmFnKEUuLi4gYXJyYXkpIHsKLQkJaW50IGxlbiA9IGFycmF5Lmxlbmd0aDsKLQkJSGFzaEJhZzxFPiBiYWcgPSBuZXcgSGFzaEJhZzxFPihsZW4pOwotCQlmb3IgKEUgaXRlbSA6IGFycmF5KSB7Ci0JCQliYWcuYWRkKGl0ZW0pOwotCQl9Ci0JCXJldHVybiBiYWc7Ci0JfQotCi0JLyoqCi0JICogQ2xlYXIgdGhlIHNwZWNpZmllZCBhcnJheS4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2NsZWFyKE9iamVjdFtdIGFycmF5KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSBjbGVhcihFW10gYXJyYXkpIHsKLQkJaWYgKGFycmF5Lmxlbmd0aCA9PSAwKSB7Ci0JCQlyZXR1cm4gYXJyYXk7Ci0JCX0KLQkJcmV0dXJuIG5ld0FycmF5KGFycmF5LCAwKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBjb2xsZWN0aW9uIGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBlbnVtZXJhdGlvbi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBIYXNoQmFnPEU+IGNvbGxlY3Rpb24oRW51bWVyYXRpb248PyBleHRlbmRzIEU+IGVudW1lcmF0aW9uKSB7Ci0JCXJldHVybiBiYWcoZW51bWVyYXRpb24pOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIGNvbGxlY3Rpb24gY29ycmVzcG9uZGluZyB0byB0aGUgc3BlY2lmaWVkIGVudW1lcmF0aW9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEhhc2hCYWc8RT4gY29sbGVjdGlvbihFbnVtZXJhdGlvbjw/IGV4dGVuZHMgRT4gZW51bWVyYXRpb24sIGludCBzaXplKSB7Ci0JCXJldHVybiBiYWcoZW51bWVyYXRpb24sIHNpemUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIGNvbGxlY3Rpb24gY29ycmVzcG9uZGluZyB0byB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEhhc2hCYWc8RT4gY29sbGVjdGlvbihJdGVyYWJsZTw/IGV4dGVuZHMgRT4gaXRlcmFibGUpIHsKLQkJcmV0dXJuIGNvbGxlY3Rpb24oaXRlcmFibGUuaXRlcmF0b3IoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgY29sbGVjdGlvbiBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmFibGUuCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gSGFzaEJhZzxFPiBjb2xsZWN0aW9uKEl0ZXJhYmxlPD8gZXh0ZW5kcyBFPiBpdGVyYWJsZSwgaW50IHNpemUpIHsKLQkJcmV0dXJuIGNvbGxlY3Rpb24oaXRlcmFibGUuaXRlcmF0b3IoKSwgc2l6ZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgY29sbGVjdGlvbiBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gSGFzaEJhZzxFPiBjb2xsZWN0aW9uKEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVyYXRvcikgewotCQlyZXR1cm4gYmFnKGl0ZXJhdG9yKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBjb2xsZWN0aW9uIGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBpdGVyYXRvci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBIYXNoQmFnPEU+IGNvbGxlY3Rpb24oSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yLCBpbnQgc2l6ZSkgewotCQlyZXR1cm4gYmFnKGl0ZXJhdG9yLCBzaXplKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBjb2xsZWN0aW9uIGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBhcnJheS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBIYXNoQmFnPEU+IGNvbGxlY3Rpb24oRS4uLiBhcnJheSkgewotCQlyZXR1cm4gYmFnKGFycmF5KTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGVudW1lcmF0aW9uIGNvbnRhaW5zIHRoZQotCSAqIHNwZWNpZmllZCBlbGVtZW50LgotCSAqIGphdmEudXRpbC5FbnVtZXJhdGlvbiNjb250YWlucyhPYmplY3QgbykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY29udGFpbnMoRW51bWVyYXRpb248Pz4gZW51bWVyYXRpb24sIE9iamVjdCB2YWx1ZSkgewotCQlpZiAodmFsdWUgPT0gbnVsbCkgewotCQkJd2hpbGUgKGVudW1lcmF0aW9uLmhhc01vcmVFbGVtZW50cygpKSB7Ci0JCQkJaWYgKGVudW1lcmF0aW9uLm5leHRFbGVtZW50KCkgPT0gbnVsbCkgewotCQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0gZWxzZSB7Ci0JCQl3aGlsZSAoZW51bWVyYXRpb24uaGFzTW9yZUVsZW1lbnRzKCkpIHsKLQkJCQlpZiAodmFsdWUuZXF1YWxzKGVudW1lcmF0aW9uLm5leHRFbGVtZW50KCkpKSB7Ci0JCQkJCXJldHVybiB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBpdGVyYWJsZSBjb250YWlucyB0aGUKLQkgKiBzcGVjaWZpZWQgZWxlbWVudC4KLQkgKiBqYXZhLmxhbmcuSXRlcmFibGUjY29udGFpbnMoT2JqZWN0IG8pCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zKEl0ZXJhYmxlPD8+IGl0ZXJhYmxlLCBPYmplY3QgdmFsdWUpIHsKLQkJcmV0dXJuIGNvbnRhaW5zKGl0ZXJhYmxlLml0ZXJhdG9yKCksIHZhbHVlKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9yIGNvbnRhaW5zIHRoZQotCSAqIHNwZWNpZmllZCBlbGVtZW50LgotCSAqIGphdmEudXRpbC5JdGVyYXRvciNjb250YWlucyhPYmplY3QgbykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY29udGFpbnMoSXRlcmF0b3I8Pz4gaXRlcmF0b3IsIE9iamVjdCB2YWx1ZSkgewotCQlpZiAodmFsdWUgPT0gbnVsbCkgewotCQkJd2hpbGUgKGl0ZXJhdG9yLmhhc05leHQoKSkgewotCQkJCWlmIChpdGVyYXRvci5uZXh0KCkgPT0gbnVsbCkgewotCQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0gZWxzZSB7Ci0JCQl3aGlsZSAoaXRlcmF0b3IuaGFzTmV4dCgpKSB7Ci0JCQkJaWYgKHZhbHVlLmVxdWFscyhpdGVyYXRvci5uZXh0KCkpKSB7Ci0JCQkJCXJldHVybiB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBhcnJheSBjb250YWlucyB0aGUKLQkgKiBzcGVjaWZpZWQgZWxlbWVudC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2NvbnRhaW5zKE9iamVjdFtdIGFycmF5LCBPYmplY3QgbykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY29udGFpbnMoT2JqZWN0W10gYXJyYXksIE9iamVjdCB2YWx1ZSkgewotCQlpZiAodmFsdWUgPT0gbnVsbCkgewotCQkJZm9yIChpbnQgaSA9IGFycmF5Lmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQkJaWYgKGFycmF5W2ldID09IG51bGwpIHsKLQkJCQkJcmV0dXJuIHRydWU7Ci0JCQkJfQotCQkJfQotCQl9IGVsc2UgewotCQkJZm9yIChpbnQgaSA9IGFycmF5Lmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQkJaWYgKHZhbHVlLmVxdWFscyhhcnJheVtpXSkpIHsKLQkJCQkJcmV0dXJuIHRydWU7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGFycmF5IGNvbnRhaW5zIHRoZQotCSAqIHNwZWNpZmllZCBlbGVtZW50LgotCSAqIGphdmEudXRpbC5BcnJheXMjY29udGFpbnMoY2hhcltdIGFycmF5LCBjaGFyIHZhbHVlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjb250YWlucyhjaGFyW10gYXJyYXksIGNoYXIgdmFsdWUpIHsKLQkJcmV0dXJuIGNvbnRhaW5zKGFycmF5LCB2YWx1ZSwgYXJyYXkubGVuZ3RoKTsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zKGNoYXJbXSBhcnJheSwgY2hhciB2YWx1ZSwgaW50IGFycmF5TGVuZ3RoKSB7Ci0JCWZvciAoaW50IGkgPSBhcnJheUxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlpZiAoYXJyYXlbaV0gPT0gdmFsdWUpIHsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBhcnJheSBjb250YWlucyB0aGUKLQkgKiBzcGVjaWZpZWQgZWxlbWVudC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2NvbnRhaW5zKGludFtdIGFycmF5LCBpbnQgdmFsdWUpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zKGludFtdIGFycmF5LCBpbnQgdmFsdWUpIHsKLQkJcmV0dXJuIGNvbnRhaW5zKGFycmF5LCB2YWx1ZSwgYXJyYXkubGVuZ3RoKTsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zKGludFtdIGFycmF5LCBpbnQgdmFsdWUsIGludCBhcnJheUxlbmd0aCkgewotCQlmb3IgKGludCBpID0gYXJyYXlMZW5ndGg7IGktLSA+IDA7ICkgewotCQkJaWYgKGFycmF5W2ldID09IHZhbHVlKSB7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbiBjb250YWlucyBhbGwgb2YgdGhlCi0JICogZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZCBpdGVyYWJsZS4KLQkgKiBqYXZhLnV0aWwuQ29sbGVjdGlvbiNjb250YWluc0FsbChqYXZhLmxhbmcuSXRlcmFibGUgaXRlcmFibGUpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zQWxsKENvbGxlY3Rpb248Pz4gY29sbGVjdGlvbiwgSXRlcmFibGU8Pz4gaXRlcmFibGUpIHsKLQkJcmV0dXJuIGNvbnRhaW5zQWxsKGNvbGxlY3Rpb24sIGl0ZXJhYmxlLml0ZXJhdG9yKCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbiBjb250YWlucyBhbGwgb2YgdGhlCi0JICogZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZCBpdGVyYXRvci4KLQkgKiBqYXZhLnV0aWwuQ29sbGVjdGlvbiNjb250YWluc0FsbChqYXZhLnV0aWwuSXRlcmF0b3IgaXRlcmF0b3IpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zQWxsKENvbGxlY3Rpb248Pz4gY29sbGVjdGlvbiwgSXRlcmF0b3I8Pz4gaXRlcmF0b3IpIHsKLQkJd2hpbGUgKGl0ZXJhdG9yLmhhc05leHQoKSkgewotCQkJaWYgKCAhIGNvbGxlY3Rpb24uY29udGFpbnMoaXRlcmF0b3IubmV4dCgpKSkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24gY29udGFpbnMgYWxsIG9mIHRoZQotCSAqIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQgYXJyYXkuCi0JICogamF2YS51dGlsLkNvbGxlY3Rpb24jY29udGFpbnNBbGwoT2JqZWN0W10gYXJyYXkpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zQWxsKENvbGxlY3Rpb248Pz4gY29sbGVjdGlvbiwgT2JqZWN0W10gYXJyYXkpIHsKLQkJZm9yIChpbnQgaSA9IGFycmF5Lmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlpZiAoICEgY29sbGVjdGlvbi5jb250YWlucyhhcnJheVtpXSkpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBpdGVyYWJsZSBjb250YWlucyBhbGwgb2YgdGhlCi0JICogZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLgotCSAqIGphdmEubGFuZy5JdGVyYWJsZSNjb250YWluc0FsbChqYXZhLnV0aWwuQ29sbGVjdGlvbiBjb2xsZWN0aW9uKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjb250YWluc0FsbChJdGVyYWJsZTw/PiBpdGVyYWJsZSwgQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uKSB7Ci0JCXJldHVybiBjb250YWluc0FsbChpdGVyYWJsZS5pdGVyYXRvcigpLCBjb2xsZWN0aW9uKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlIGNvbnRhaW5zIGFsbCBvZiB0aGUKLQkgKiBlbGVtZW50cyBpbiB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24uCi0JICogamF2YS5sYW5nLkl0ZXJhYmxlI2NvbnRhaW5zQWxsKGphdmEudXRpbC5Db2xsZWN0aW9uIGNvbGxlY3Rpb24pCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zQWxsKEl0ZXJhYmxlPD8+IGl0ZXJhYmxlLCBpbnQgc2l6ZSwgQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uKSB7Ci0JCXJldHVybiBjb250YWluc0FsbChpdGVyYWJsZS5pdGVyYXRvcigpLCBzaXplLCBjb2xsZWN0aW9uKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlIDEgY29udGFpbnMgYWxsIG9mIHRoZQotCSAqIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQgaXRlcmFibGUgMi4KLQkgKiBqYXZhLmxhbmcuSXRlcmFibGUjY29udGFpbnNBbGwoamF2YS5sYW5nLkl0ZXJhYmxlIGl0ZXJhYmxlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjb250YWluc0FsbChJdGVyYWJsZTw/PiBpdGVyYWJsZTEsIEl0ZXJhYmxlPD8+IGl0ZXJhYmxlMikgewotCQlyZXR1cm4gY29udGFpbnNBbGwoaXRlcmFibGUxLml0ZXJhdG9yKCksIGl0ZXJhYmxlMi5pdGVyYXRvcigpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlIDEgY29udGFpbnMgYWxsIG9mIHRoZQotCSAqIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQgaXRlcmFibGUgMi4KLQkgKiBqYXZhLmxhbmcuSXRlcmFibGUjY29udGFpbnNBbGwoamF2YS5sYW5nLkl0ZXJhYmxlIGl0ZXJhYmxlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjb250YWluc0FsbChJdGVyYWJsZTw/PiBpdGVyYWJsZTEsIGludCBzaXplLCBJdGVyYWJsZTw/PiBpdGVyYWJsZTIpIHsKLQkJcmV0dXJuIGNvbnRhaW5zQWxsKGl0ZXJhYmxlMS5pdGVyYXRvcigpLCBzaXplLCBpdGVyYWJsZTIuaXRlcmF0b3IoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBpdGVyYWJsZSBjb250YWlucyBhbGwgb2YgdGhlCi0JICogZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZCBpdGVyYXRvci4KLQkgKiBqYXZhLmxhbmcuSXRlcmFibGUjY29udGFpbnNBbGwoamF2YS51dGlsLkl0ZXJhdG9yIGl0ZXJhdG9yKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjb250YWluc0FsbChJdGVyYWJsZTw/PiBpdGVyYWJsZSwgSXRlcmF0b3I8Pz4gaXRlcmF0b3IpIHsKLQkJcmV0dXJuIGNvbnRhaW5zQWxsKGl0ZXJhYmxlLml0ZXJhdG9yKCksIGl0ZXJhdG9yKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlIGNvbnRhaW5zIGFsbCBvZiB0aGUKLQkgKiBlbGVtZW50cyBpbiB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9yLgotCSAqIGphdmEubGFuZy5JdGVyYWJsZSNjb250YWluc0FsbChqYXZhLnV0aWwuSXRlcmF0b3IgaXRlcmF0b3IpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zQWxsKEl0ZXJhYmxlPD8+IGl0ZXJhYmxlLCBpbnQgc2l6ZSwgSXRlcmF0b3I8Pz4gaXRlcmF0b3IpIHsKLQkJcmV0dXJuIGNvbnRhaW5zQWxsKGl0ZXJhYmxlLml0ZXJhdG9yKCksIHNpemUsIGl0ZXJhdG9yKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlIGNvbnRhaW5zIGFsbCBvZiB0aGUKLQkgKiBlbGVtZW50cyBpbiB0aGUgc3BlY2lmaWVkIGFycmF5LgotCSAqIGphdmEubGFuZy5JdGVyYWJsZSNjb250YWluc0FsbChPYmplY3RbXSBhcnJheSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY29udGFpbnNBbGwoSXRlcmFibGU8Pz4gaXRlcmFibGUsIE9iamVjdFtdIGFycmF5KSB7Ci0JCXJldHVybiBjb250YWluc0FsbChpdGVyYWJsZS5pdGVyYXRvcigpLCBhcnJheSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBpdGVyYWJsZSBjb250YWlucyBhbGwgb2YgdGhlCi0JICogZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZCBhcnJheS4KLQkgKiBqYXZhLmxhbmcuSXRlcmFibGUjY29udGFpbnNBbGwoT2JqZWN0W10gYXJyYXkpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zQWxsKEl0ZXJhYmxlPD8+IGl0ZXJhYmxlLCBpbnQgc2l6ZSwgT2JqZWN0W10gYXJyYXkpIHsKLQkJcmV0dXJuIGNvbnRhaW5zQWxsKGl0ZXJhYmxlLml0ZXJhdG9yKCksIHNpemUsIGFycmF5KTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9yIGNvbnRhaW5zIGFsbCBvZiB0aGUKLQkgKiBlbGVtZW50cyBpbiB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24uCi0JICogamF2YS51dGlsLkl0ZXJhdG9yI2NvbnRhaW5zQWxsKGphdmEudXRpbC5Db2xsZWN0aW9uIGNvbGxlY3Rpb24pCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zQWxsKEl0ZXJhdG9yPD8+IGl0ZXJhdG9yLCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24pIHsKLQkJcmV0dXJuIGNvbGxlY3Rpb24oaXRlcmF0b3IpLmNvbnRhaW5zQWxsKGNvbGxlY3Rpb24pOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IgY29udGFpbnMgYWxsIG9mIHRoZQotCSAqIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbi4KLQkgKiBqYXZhLnV0aWwuSXRlcmF0b3IjY29udGFpbnNBbGwoamF2YS51dGlsLkNvbGxlY3Rpb24gY29sbGVjdGlvbikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY29udGFpbnNBbGwoSXRlcmF0b3I8Pz4gaXRlcmF0b3IsIGludCBzaXplLCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24pIHsKLQkJcmV0dXJuIGNvbGxlY3Rpb24oaXRlcmF0b3IsIHNpemUpLmNvbnRhaW5zQWxsKGNvbGxlY3Rpb24pOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IgY29udGFpbnMgYWxsIG9mIHRoZQotCSAqIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQgaXRlcmFibGUuCi0JICogamF2YS51dGlsLkl0ZXJhdG9yI2NvbnRhaW5zQWxsKGphdmEubGFuZy5JdGVyYWJsZSBpdGVyYWJsZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY29udGFpbnNBbGwoSXRlcmF0b3I8Pz4gaXRlcmF0b3IsIEl0ZXJhYmxlPD8+IGl0ZXJhYmxlKSB7Ci0JCXJldHVybiBjb250YWluc0FsbChjb2xsZWN0aW9uKGl0ZXJhdG9yKSwgaXRlcmFibGUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IgY29udGFpbnMgYWxsIG9mIHRoZQotCSAqIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQgaXRlcmFibGUuCi0JICogamF2YS51dGlsLkl0ZXJhdG9yI2NvbnRhaW5zQWxsKGphdmEubGFuZy5JdGVyYWJsZSBpdGVyYWJsZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY29udGFpbnNBbGwoSXRlcmF0b3I8Pz4gaXRlcmF0b3IsIGludCBzaXplLCBJdGVyYWJsZTw/PiBpdGVyYWJsZSkgewotCQlyZXR1cm4gY29udGFpbnNBbGwoY29sbGVjdGlvbihpdGVyYXRvciwgc2l6ZSksIGl0ZXJhYmxlKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9yIDEgY29udGFpbnMgYWxsIG9mIHRoZQotCSAqIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IgMi4KLQkgKiBqYXZhLnV0aWwuSXRlcmF0b3IjY29udGFpbnNBbGwoamF2YS51dGlsLkl0ZXJhdG9yIGl0ZXJhdG9yKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjb250YWluc0FsbChJdGVyYXRvcjw/PiBpdGVyYXRvcjEsIEl0ZXJhdG9yPD8+IGl0ZXJhdG9yMikgewotCQlyZXR1cm4gY29udGFpbnNBbGwoY29sbGVjdGlvbihpdGVyYXRvcjEpLCBpdGVyYXRvcjIpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IgMSBjb250YWlucyBhbGwgb2YgdGhlCi0JICogZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZCBpdGVyYXRvciAyLgotCSAqIGphdmEudXRpbC5JdGVyYXRvciNjb250YWluc0FsbChqYXZhLnV0aWwuSXRlcmF0b3IgaXRlcmF0b3IpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zQWxsKEl0ZXJhdG9yPD8+IGl0ZXJhdG9yMSwgaW50IHNpemUsIEl0ZXJhdG9yPD8+IGl0ZXJhdG9yMikgewotCQlyZXR1cm4gY29udGFpbnNBbGwoY29sbGVjdGlvbihpdGVyYXRvcjEsIHNpemUpLCBpdGVyYXRvcjIpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IgY29udGFpbnMgYWxsIG9mIHRoZQotCSAqIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQgYXJyYXkuCi0JICogamF2YS51dGlsLkl0ZXJhdG9yI2NvbnRhaW5zQWxsKE9iamVjdFtdIGFycmF5KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjb250YWluc0FsbChJdGVyYXRvcjw/PiBpdGVyYXRvciwgT2JqZWN0W10gYXJyYXkpIHsKLQkJcmV0dXJuIGNvbnRhaW5zQWxsKGNvbGxlY3Rpb24oaXRlcmF0b3IpLCBhcnJheSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBpdGVyYXRvciBjb250YWlucyBhbGwgb2YgdGhlCi0JICogZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZCBhcnJheS4KLQkgKiBqYXZhLnV0aWwuSXRlcmF0b3IjY29udGFpbnNBbGwoT2JqZWN0W10gYXJyYXkpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zQWxsKEl0ZXJhdG9yPD8+IGl0ZXJhdG9yLCBpbnQgc2l6ZSwgT2JqZWN0W10gYXJyYXkpIHsKLQkJcmV0dXJuIGNvbnRhaW5zQWxsKGNvbGxlY3Rpb24oaXRlcmF0b3IsIHNpemUpLCBhcnJheSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBhcnJheSBjb250YWlucyBhbGwgb2YgdGhlCi0JICogZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLgotCSAqIGphdmEudXRpbC5BcnJheXMjY29udGFpbnNBbGwoT2JqZWN0W10gYXJyYXksIGphdmEudXRpbC5Db2xsZWN0aW9uIGNvbGxlY3Rpb24pCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zQWxsKE9iamVjdFtdIGFycmF5LCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24pIHsKLQkJcmV0dXJuIGNvbnRhaW5zQWxsKGFycmF5LCBjb2xsZWN0aW9uLml0ZXJhdG9yKCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgYXJyYXkgY29udGFpbnMgYWxsIG9mIHRoZQotCSAqIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQgaXRlcmFibGUuCi0JICogamF2YS51dGlsLkFycmF5cyNjb250YWluc0FsbChPYmplY3RbXSBhcnJheSwgamF2YS5sYW5nLkl0ZXJhYmxlIGl0ZXJhYmxlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjb250YWluc0FsbChPYmplY3RbXSBhcnJheSwgSXRlcmFibGU8Pz4gaXRlcmFibGUpIHsKLQkJcmV0dXJuIGNvbnRhaW5zQWxsKGFycmF5LCBpdGVyYWJsZS5pdGVyYXRvcigpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGFycmF5IGNvbnRhaW5zIGFsbCBvZiB0aGUKLQkgKiBlbGVtZW50cyBpbiB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9yLgotCSAqIGphdmEudXRpbC5BcnJheXMjY29udGFpbnNBbGwoT2JqZWN0W10gYXJyYXksIGphdmEudXRpbC5JdGVyYXRvciBpdGVyYXRvcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY29udGFpbnNBbGwoT2JqZWN0W10gYXJyYXksIEl0ZXJhdG9yPD8+IGl0ZXJhdG9yKSB7Ci0JCXdoaWxlIChpdGVyYXRvci5oYXNOZXh0KCkpIHsKLQkJCWlmICggISBjb250YWlucyhhcnJheSwgaXRlcmF0b3IubmV4dCgpKSkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGFycmF5IDEgY29udGFpbnMgYWxsIG9mIHRoZQotCSAqIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQgYXJyYXkgMi4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2NvbnRhaW5zQWxsKE9iamVjdFtdIGFycmF5MSwgT2JqZWN0W10gYXJyYXkyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjb250YWluc0FsbChPYmplY3RbXSBhcnJheTEsIE9iamVjdFtdIGFycmF5MikgewotCQlmb3IgKGludCBpID0gYXJyYXkyLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlpZiAoICEgY29udGFpbnMoYXJyYXkxLCBhcnJheTJbaV0pKSB7Ci0JCQkJcmV0dXJuIGZhbHNlOwotCQkJfQotCQl9Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgYXJyYXkgMSBjb250YWlucyBhbGwgb2YgdGhlCi0JICogZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZCBhcnJheSAyLgotCSAqIGphdmEudXRpbC5BcnJheXMjY29udGFpbnNBbGwoY2hhcltdIGFycmF5MSwgY2hhcltdIGFycmF5MikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY29udGFpbnNBbGwoY2hhcltdIGFycmF5MSwgY2hhcltdIGFycmF5MikgewotCQlmb3IgKGludCBpID0gYXJyYXkyLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlpZiAoICEgY29udGFpbnMoYXJyYXkxLCBhcnJheTJbaV0pKSB7Ci0JCQkJcmV0dXJuIGZhbHNlOwotCQkJfQotCQl9Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgYXJyYXkgMSBjb250YWlucyBhbGwgb2YgdGhlCi0JICogZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZCBhcnJheSAyLgotCSAqIGphdmEudXRpbC5BcnJheXMjY29udGFpbnNBbGwoaW50W10gYXJyYXkxLCBpbnRbXSBhcnJheTIpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNvbnRhaW5zQWxsKGludFtdIGFycmF5MSwgaW50W10gYXJyYXkyKSB7Ci0JCWZvciAoaW50IGkgPSBhcnJheTIubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCWlmICggISBjb250YWlucyhhcnJheTEsIGFycmF5MltpXSkpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBpbmRleCBvZiB0aGUgZmlyc3QgZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZAotCSAqIGFycmF5cyB0aGF0IGFyZSBkaWZmZXJlbnQsIGJlZ2lubmluZyBhdCB0aGUgZW5kLgotCSAqIElmIHRoZSBhcnJheXMgYXJlIGlkZW50aWNhbCwgcmV0dXJuIC0xLgotCSAqIElmIHRoZSBhcnJheXMgYXJlIGRpZmZlcmVudCBzaXplcywgcmV0dXJuIHRoZSBpbmRleCBvZiB0aGUKLQkgKiBsYXN0IGVsZW1lbnQgaW4gdGhlIGxvbmdlciBhcnJheS4KLQkgKiBVc2UgdGhlIGVsZW1lbnRzJyAjZXF1YWxzKCkgbWV0aG9kIHRvIGNvbXBhcmUgdGhlCi0JICogZWxlbWVudHMuCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnQgZGlmZkVuZChPYmplY3RbXSBhcnJheTEsIE9iamVjdFtdIGFycmF5MikgewotCQlyZXR1cm4gZGlmZkVuZChBcnJheXMuYXNMaXN0KGFycmF5MSksIEFycmF5cy5hc0xpc3QoYXJyYXkyKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBpbmRleCBvZiB0aGUgZmlyc3QgZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZAotCSAqIGxpc3RzIHRoYXQgYXJlIGRpZmZlcmVudCwgYmVnaW5uaW5nIGF0IHRoZSBlbmQuCi0JICogSWYgdGhlIGxpc3RzIGFyZSBpZGVudGljYWwsIHJldHVybiAtMS4KLQkgKiBJZiB0aGUgbGlzdHMgYXJlIGRpZmZlcmVudCBzaXplcywgcmV0dXJuIHRoZSBpbmRleCBvZiB0aGUKLQkgKiBsYXN0IGVsZW1lbnQgaW4gdGhlIGxvbmdlciBsaXN0LgotCSAqIFVzZSB0aGUgZWxlbWVudHMnICNlcXVhbHMoKSBtZXRob2QgdG8gY29tcGFyZSB0aGUKLQkgKiBlbGVtZW50cy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludCBkaWZmRW5kKExpc3Q8Pz4gbGlzdDEsIExpc3Q8Pz4gbGlzdDIpIHsKLQkJaW50IHNpemUxID0gbGlzdDEuc2l6ZSgpOwotCQlpbnQgc2l6ZTIgPSBsaXN0Mi5zaXplKCk7Ci0JCWlmIChzaXplMSAhPSBzaXplMikgewotCQkJcmV0dXJuIE1hdGgubWF4KHNpemUxLCBzaXplMikgLSAxOwotCQl9Ci0JCWludCBlbmQgPSBzaXplMSAtIDE7Ci0JCXdoaWxlIChlbmQgPiAtMSkgewotCQkJT2JqZWN0IG8gPSBsaXN0MS5nZXQoZW5kKTsKLQkJCWlmIChvID09IG51bGwpIHsKLQkJCQlpZiAobGlzdDIuZ2V0KGVuZCkgPT0gbnVsbCkgewotCQkJCQllbmQtLTsKLQkJCQl9IGVsc2UgewotCQkJCQlyZXR1cm4gZW5kOwotCQkJCX0KLQkJCX0gZWxzZSB7Ci0JCQkJaWYgKG8uZXF1YWxzKGxpc3QyLmdldChlbmQpKSkgewotCQkJCQllbmQtLTsKLQkJCQl9IGVsc2UgewotCQkJCQlyZXR1cm4gZW5kOwotCQkJCX0KLQkJCX0KLQkJfQotCQlyZXR1cm4gZW5kOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgcmFuZ2Ugb2YgZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZAotCSAqIGFycmF5cyB0aGF0IGFyZSBkaWZmZXJlbnQuCi0JICogSWYgdGhlIGFycmF5cyBhcmUgaWRlbnRpY2FsLCByZXR1cm4gW3NpemUsIC0xXS4KLQkgKiBVc2UgdGhlIGVsZW1lbnRzJyAjZXF1YWxzKCkgbWV0aG9kIHRvIGNvbXBhcmUgdGhlCi0JICogZWxlbWVudHMuCi0JICogQHNlZSAjZGlmZlN0YXJ0KE9iamVjdFtdLCBPYmplY3RbXSkKLQkgKiBAc2VlICNkaWZmRW5kKE9iamVjdFtdLCBPYmplY3RbXSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFJhbmdlIGRpZmZSYW5nZShPYmplY3RbXSBhcnJheTEsIE9iamVjdFtdIGFycmF5MikgewotCQlyZXR1cm4gZGlmZlJhbmdlKEFycmF5cy5hc0xpc3QoYXJyYXkxKSwgQXJyYXlzLmFzTGlzdChhcnJheTIpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHJhbmdlIG9mIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQKLQkgKiBhcnJheXMgdGhhdCBhcmUgZGlmZmVyZW50LgotCSAqIElmIHRoZSBhcnJheXMgYXJlIGlkZW50aWNhbCwgcmV0dXJuIFtzaXplLCAtMV0uCi0JICogVXNlIHRoZSBlbGVtZW50cycgI2VxdWFscygpIG1ldGhvZCB0byBjb21wYXJlIHRoZQotCSAqIGVsZW1lbnRzLgotCSAqIEBzZWUgI2RpZmZTdGFydChqYXZhLnV0aWwuTGlzdCwgamF2YS51dGlsLkxpc3QpCi0JICogQHNlZSAjZGlmZkVuZChqYXZhLnV0aWwuTGlzdCwgamF2YS51dGlsLkxpc3QpCi0JICovCi0JcHVibGljIHN0YXRpYyBSYW5nZSBkaWZmUmFuZ2UoTGlzdDw/PiBsaXN0MSwgTGlzdDw/PiBsaXN0MikgewotCQlpbnQgZW5kID0gZGlmZkVuZChsaXN0MSwgbGlzdDIpOwotCQlpZiAoZW5kID09IC0xKSB7Ci0JCQkvLyB0aGUgbGlzdHMgYXJlIGlkZW50aWNhbCwgdGhlIHN0YXJ0IGlzIHRoZSBzaXplIG9mIHRoZSB0d28gbGlzdHMKLQkJCXJldHVybiBuZXcgUmFuZ2UobGlzdDEuc2l6ZSgpLCBlbmQpOwotCQl9Ci0JCS8vIHRoZSBsaXN0cyBhcmUgZGlmZmVyZW50LCBjYWxjdWxhdGUgdGhlIHN0YXJ0IG9mIHRoZSByYW5nZQotCQlyZXR1cm4gbmV3IFJhbmdlKGRpZmZTdGFydChsaXN0MSwgbGlzdDIpLCBlbmQpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaW5kZXggb2YgdGhlIGZpcnN0IGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQKLQkgKiBhcnJheXMgdGhhdCBhcmUgZGlmZmVyZW50LiBJZiB0aGUgYXJyYXlzIGFyZSBpZGVudGljYWwsIHJldHVybgotCSAqIHRoZSBzaXplIG9mIHRoZSB0d28gYXJyYXlzIChpLmUuIG9uZSBwYXN0IHRoZSBsYXN0IGluZGV4KS4KLQkgKiBJZiB0aGUgYXJyYXlzIGFyZSBkaWZmZXJlbnQgc2l6ZXMgYW5kIGFsbCB0aGUgZWxlbWVudHMgaW4KLQkgKiB0aGUgc2hvcnRlciBhcnJheSBtYXRjaCB0aGVpciBjb3JyZXNwb25kaW5nIGVsZW1lbnRzIGluCi0JICogdGhlIGxvbmdlciBhcnJheSwgcmV0dXJuIHRoZSBzaXplIG9mIHRoZSBzaG9ydGVyIGFycmF5Ci0JICogKGkuZS4gb25lIHBhc3QgdGhlIGxhc3QgaW5kZXggb2YgdGhlIHNob3J0ZXIgYXJyYXkpLgotCSAqIFVzZSB0aGUgZWxlbWVudHMnICNlcXVhbHMoKSBtZXRob2QgdG8gY29tcGFyZSB0aGUKLQkgKiBlbGVtZW50cy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludCBkaWZmU3RhcnQoT2JqZWN0W10gYXJyYXkxLCBPYmplY3RbXSBhcnJheTIpIHsKLQkJcmV0dXJuIGRpZmZTdGFydChBcnJheXMuYXNMaXN0KGFycmF5MSksIEFycmF5cy5hc0xpc3QoYXJyYXkyKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBpbmRleCBvZiB0aGUgZmlyc3QgZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZAotCSAqIGxpc3RzIHRoYXQgYXJlIGRpZmZlcmVudC4gSWYgdGhlIGxpc3RzIGFyZSBpZGVudGljYWwsIHJldHVybgotCSAqIHRoZSBzaXplIG9mIHRoZSB0d28gbGlzdHMgKGkuZS4gb25lIHBhc3QgdGhlIGxhc3QgaW5kZXgpLgotCSAqIElmIHRoZSBsaXN0cyBhcmUgZGlmZmVyZW50IHNpemVzIGFuZCBhbGwgdGhlIGVsZW1lbnRzIGluCi0JICogdGhlIHNob3J0ZXIgbGlzdCBtYXRjaCB0aGVpciBjb3JyZXNwb25kaW5nIGVsZW1lbnRzIGluCi0JICogdGhlIGxvbmdlciBsaXN0LCByZXR1cm4gdGhlIHNpemUgb2YgdGhlIHNob3J0ZXIgbGlzdAotCSAqIChpLmUuIG9uZSBwYXN0IHRoZSBsYXN0IGluZGV4IG9mIHRoZSBzaG9ydGVyIGxpc3QpLgotCSAqIFVzZSB0aGUgZWxlbWVudHMnICNlcXVhbHMoKSBtZXRob2QgdG8gY29tcGFyZSB0aGUKLQkgKiBlbGVtZW50cy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludCBkaWZmU3RhcnQoTGlzdDw/PiBsaXN0MSwgTGlzdDw/PiBsaXN0MikgewotCQlpbnQgZW5kID0gTWF0aC5taW4obGlzdDEuc2l6ZSgpLCBsaXN0Mi5zaXplKCkpOwotCQlpbnQgc3RhcnQgPSAwOwotCQl3aGlsZSAoc3RhcnQgPCBlbmQpIHsKLQkJCU9iamVjdCBvID0gbGlzdDEuZ2V0KHN0YXJ0KTsKLQkJCWlmIChvID09IG51bGwpIHsKLQkJCQlpZiAobGlzdDIuZ2V0KHN0YXJ0KSA9PSBudWxsKSB7Ci0JCQkJCXN0YXJ0Kys7Ci0JCQkJfSBlbHNlIHsKLQkJCQkJcmV0dXJuIHN0YXJ0OwotCQkJCX0KLQkJCX0gZWxzZSB7Ci0JCQkJaWYgKG8uZXF1YWxzKGxpc3QyLmdldChzdGFydCkpKSB7Ci0JCQkJCXN0YXJ0Kys7Ci0JCQkJfSBlbHNlIHsKLQkJCQkJcmV0dXJuIHN0YXJ0OwotCQkJCX0KLQkJCX0KLQkJfQotCQlyZXR1cm4gc3RhcnQ7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBpdGVyYXRvcnMgcmV0dXJuIGVxdWFsIGVsZW1lbnRzLgotCSAqIGphdmEudXRpbC5JdGVyYXRvciNlcXVhbHMoamF2YS51dGlsLkl0ZXJhdG9yIGl0ZXJhdG9yKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBlcXVhbHMoSXRlcmF0b3I8Pz4gaXRlcmF0b3IxLCBJdGVyYXRvcjw/PiBpdGVyYXRvcjIpIHsKLQkJd2hpbGUgKGl0ZXJhdG9yMS5oYXNOZXh0KCkgJiYgaXRlcmF0b3IyLmhhc05leHQoKSkgewotCQkJT2JqZWN0IG8xID0gaXRlcmF0b3IxLm5leHQoKTsKLQkJCU9iamVjdCBvMiA9IGl0ZXJhdG9yMi5uZXh0KCk7Ci0JCQlpZiAoICEgKG8xID09IG51bGwgPyBvMiA9PSBudWxsIDogbzEuZXF1YWxzKG8yKSkpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuICEgKGl0ZXJhdG9yMS5oYXNOZXh0KCkgfHwgaXRlcmF0b3IyLmhhc05leHQoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBlbGVtZW50IGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBpbmRleAotCSAqIGluIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICogamF2YS51dGlsLkxpc3RJdGVyYXRvciNnZXQoaW50IGluZGV4KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEUgZ2V0KExpc3RJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IsIGludCBpbmRleCkgewotCQl3aGlsZSAoaXRlcmF0b3IuaGFzTmV4dCgpKSB7Ci0JCQlFIG5leHQgPSBpdGVyYXRvci5uZXh0KCk7Ci0JCQlpZiAoaXRlcmF0b3IucHJldmlvdXNJbmRleCgpID09IGluZGV4KSB7Ci0JCQkJcmV0dXJuIG5leHQ7Ci0JCQl9Ci0JCX0KLQkJdGhyb3cgbmV3IEluZGV4T3V0T2ZCb3VuZHNFeGNlcHRpb24oU3RyaW5nLnZhbHVlT2YoaW5kZXgpICsgJzonICsgU3RyaW5nLnZhbHVlT2YoaXRlcmF0b3IucHJldmlvdXNJbmRleCgpKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBhcnJheXMgY29udGFpbiB0aGUgc2FtZSBlbGVtZW50cy4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2lkZW50aWNhbChPYmplY3RbXSBhcnJheTEsIE9iamVjdFtdIGFycmF5MikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gaWRlbnRpY2FsKE9iamVjdFtdIGFycmF5MSwgT2JqZWN0W10gYXJyYXkyKSB7Ci0JCWlmIChhcnJheTEgPT0gYXJyYXkyKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCQlpZiAoYXJyYXkxID09IG51bGwgfHwgYXJyYXkyID09IG51bGwpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlpbnQgbGVuZ3RoID0gYXJyYXkxLmxlbmd0aDsKLQkJaWYgKGFycmF5Mi5sZW5ndGggIT0gbGVuZ3RoKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJZm9yIChpbnQgaSA9IGxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlpZiAoYXJyYXkxW2ldICE9IGFycmF5MltpXSkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9ycyByZXR1cm4gdGhlIHNhbWUgZWxlbWVudHMuCi0JICogamF2YS51dGlsLkl0ZXJhdG9yI2lkZW50aWNhbChqYXZhLnV0aWwuSXRlcmF0b3IgaXRlcmF0b3IpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGlkZW50aWNhbChJdGVyYXRvcjw/PiBpdGVyYXRvcjEsIEl0ZXJhdG9yPD8+IGl0ZXJhdG9yMikgewotCQl3aGlsZSAoaXRlcmF0b3IxLmhhc05leHQoKSAmJiBpdGVyYXRvcjIuaGFzTmV4dCgpKSB7Ci0JCQlpZiAoaXRlcmF0b3IxLm5leHQoKSAhPSBpdGVyYXRvcjIubmV4dCgpKSB7Ci0JCQkJcmV0dXJuIGZhbHNlOwotCQkJfQotCQl9Ci0JCXJldHVybiAhIChpdGVyYXRvcjEuaGFzTmV4dCgpIHx8IGl0ZXJhdG9yMi5oYXNOZXh0KCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaW5kZXggb2YgdGhlIGZpcnN0IGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQKLQkgKiBhcnJheXMgdGhhdCBhcmUgZGlmZmVyZW50LCBiZWdpbm5pbmcgYXQgdGhlIGVuZC4KLQkgKiBJZiB0aGUgYXJyYXlzIGFyZSBpZGVudGljYWwsIHJldHVybiAtMS4KLQkgKiBJZiB0aGUgYXJyYXlzIGFyZSBkaWZmZXJlbnQgc2l6ZXMsIHJldHVybiB0aGUgaW5kZXggb2YgdGhlCi0JICogbGFzdCBlbGVtZW50IGluIHRoZSBsb25nZXIgYXJyYXkuCi0JICogVXNlIG9iamVjdCBpZGVudGl0eSB0byBjb21wYXJlIHRoZSBlbGVtZW50cy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludCBpZGVudGl0eURpZmZFbmQoT2JqZWN0W10gYXJyYXkxLCBPYmplY3RbXSBhcnJheTIpIHsKLQkJcmV0dXJuIGlkZW50aXR5RGlmZkVuZChBcnJheXMuYXNMaXN0KGFycmF5MSksIEFycmF5cy5hc0xpc3QoYXJyYXkyKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBpbmRleCBvZiB0aGUgZmlyc3QgZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZAotCSAqIGxpc3RzIHRoYXQgYXJlIGRpZmZlcmVudCwgYmVnaW5uaW5nIGF0IHRoZSBlbmQuCi0JICogSWYgdGhlIGxpc3RzIGFyZSBpZGVudGljYWwsIHJldHVybiAtMS4KLQkgKiBJZiB0aGUgbGlzdHMgYXJlIGRpZmZlcmVudCBzaXplcywgcmV0dXJuIHRoZSBpbmRleCBvZiB0aGUKLQkgKiBsYXN0IGVsZW1lbnQgaW4gdGhlIGxvbmdlciBsaXN0LgotCSAqIFVzZSBvYmplY3QgaWRlbnRpdHkgdG8gY29tcGFyZSB0aGUgZWxlbWVudHMuCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnQgaWRlbnRpdHlEaWZmRW5kKExpc3Q8Pz4gbGlzdDEsIExpc3Q8Pz4gbGlzdDIpIHsKLQkJaW50IHNpemUxID0gbGlzdDEuc2l6ZSgpOwotCQlpbnQgc2l6ZTIgPSBsaXN0Mi5zaXplKCk7Ci0JCWlmIChzaXplMSAhPSBzaXplMikgewotCQkJcmV0dXJuIE1hdGgubWF4KHNpemUxLCBzaXplMikgLSAxOwotCQl9Ci0JCWludCBlbmQgPSBzaXplMSAtIDE7Ci0JCXdoaWxlIChlbmQgPiAtMSkgewotCQkJaWYgKGxpc3QxLmdldChlbmQpID09IGxpc3QyLmdldChlbmQpKSB7Ci0JCQkJZW5kLS07Ci0JCQl9IGVsc2UgewotCQkJCXJldHVybiBlbmQ7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGVuZDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHJhbmdlIG9mIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQKLQkgKiBhcnJheXMgdGhhdCBhcmUgZGlmZmVyZW50LgotCSAqIElmIHRoZSBhcnJheXMgYXJlIGlkZW50aWNhbCwgcmV0dXJuIFtzaXplLCAtMV0uCi0JICogVXNlIG9iamVjdCBpZGVudGl0eSB0byBjb21wYXJlIHRoZSBlbGVtZW50cy4KLQkgKiBAc2VlICNpZGVudGl0eURpZmZTdGFydChPYmplY3RbXSwgT2JqZWN0W10pCi0JICogQHNlZSAjaWRlbnRpdHlEaWZmRW5kKE9iamVjdFtdLCBPYmplY3RbXSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFJhbmdlIGlkZW50aXR5RGlmZlJhbmdlKE9iamVjdFtdIGFycmF5MSwgT2JqZWN0W10gYXJyYXkyKSB7Ci0JCXJldHVybiBpZGVudGl0eURpZmZSYW5nZShBcnJheXMuYXNMaXN0KGFycmF5MSksIEFycmF5cy5hc0xpc3QoYXJyYXkyKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSByYW5nZSBvZiBlbGVtZW50cyBpbiB0aGUgc3BlY2lmaWVkCi0JICogYXJyYXlzIHRoYXQgYXJlIGRpZmZlcmVudC4KLQkgKiBJZiB0aGUgYXJyYXlzIGFyZSBpZGVudGljYWwsIHJldHVybiBbc2l6ZSwgLTFdLgotCSAqIFVzZSBvYmplY3QgaWRlbnRpdHkgdG8gY29tcGFyZSB0aGUgZWxlbWVudHMuCi0JICogQHNlZSAjaWRlbnRpdHlEaWZmU3RhcnQoamF2YS51dGlsLkxpc3QsIGphdmEudXRpbC5MaXN0KQotCSAqIEBzZWUgI2lkZW50aXR5RGlmZkVuZChqYXZhLnV0aWwuTGlzdCwgamF2YS51dGlsLkxpc3QpCi0JICovCi0JcHVibGljIHN0YXRpYyBSYW5nZSBpZGVudGl0eURpZmZSYW5nZShMaXN0PD8+IGxpc3QxLCBMaXN0PD8+IGxpc3QyKSB7Ci0JCWludCBlbmQgPSBpZGVudGl0eURpZmZFbmQobGlzdDEsIGxpc3QyKTsKLQkJaWYgKGVuZCA9PSAtMSkgewotCQkJLy8gdGhlIGxpc3RzIGFyZSBpZGVudGljYWwsIHRoZSBzdGFydCBpcyB0aGUgc2l6ZSBvZiB0aGUgdHdvIGxpc3RzCi0JCQlyZXR1cm4gbmV3IFJhbmdlKGxpc3QxLnNpemUoKSwgZW5kKTsKLQkJfQotCQkvLyB0aGUgbGlzdHMgYXJlIGRpZmZlcmVudCwgY2FsY3VsYXRlIHRoZSBzdGFydCBvZiB0aGUgcmFuZ2UKLQkJcmV0dXJuIG5ldyBSYW5nZShpZGVudGl0eURpZmZTdGFydChsaXN0MSwgbGlzdDIpLCBlbmQpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaW5kZXggb2YgdGhlIGZpcnN0IGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQKLQkgKiBhcnJheXMgdGhhdCBhcmUgZGlmZmVyZW50LiBJZiB0aGUgYXJyYXlzIGFyZSBpZGVudGljYWwsIHJldHVybgotCSAqIHRoZSBzaXplIG9mIHRoZSB0d28gYXJyYXlzIChpLmUuIG9uZSBwYXN0IHRoZSBsYXN0IGluZGV4KS4KLQkgKiBJZiB0aGUgYXJyYXlzIGFyZSBkaWZmZXJlbnQgc2l6ZXMgYW5kIGFsbCB0aGUgZWxlbWVudHMgaW4KLQkgKiB0aGUgc2hvcnRlciBhcnJheSBtYXRjaCB0aGVpciBjb3JyZXNwb25kaW5nIGVsZW1lbnRzIGluCi0JICogdGhlIGxvbmdlciBhcnJheSwgcmV0dXJuIHRoZSBzaXplIG9mIHRoZSBzaG9ydGVyIGFycmF5Ci0JICogKGkuZS4gb25lIHBhc3QgdGhlIGxhc3QgaW5kZXggb2YgdGhlIHNob3J0ZXIgYXJyYXkpLgotCSAqIFVzZSBvYmplY3QgaWRlbnRpdHkgdG8gY29tcGFyZSB0aGUgZWxlbWVudHMuCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnQgaWRlbnRpdHlEaWZmU3RhcnQoT2JqZWN0W10gYXJyYXkxLCBPYmplY3RbXSBhcnJheTIpIHsKLQkJcmV0dXJuIGlkZW50aXR5RGlmZlN0YXJ0KEFycmF5cy5hc0xpc3QoYXJyYXkxKSwgQXJyYXlzLmFzTGlzdChhcnJheTIpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGluZGV4IG9mIHRoZSBmaXJzdCBlbGVtZW50cyBpbiB0aGUgc3BlY2lmaWVkCi0JICogbGlzdHMgdGhhdCBhcmUgZGlmZmVyZW50LiBJZiB0aGUgbGlzdHMgYXJlIGlkZW50aWNhbCwgcmV0dXJuCi0JICogdGhlIHNpemUgb2YgdGhlIHR3byBsaXN0cyAoaS5lLiBvbmUgcGFzdCB0aGUgbGFzdCBpbmRleCkuCi0JICogSWYgdGhlIGxpc3RzIGFyZSBkaWZmZXJlbnQgc2l6ZXMgYW5kIGFsbCB0aGUgZWxlbWVudHMgaW4KLQkgKiB0aGUgc2hvcnRlciBsaXN0IG1hdGNoIHRoZWlyIGNvcnJlc3BvbmRpbmcgZWxlbWVudHMgaW4KLQkgKiB0aGUgbG9uZ2VyIGxpc3QsIHJldHVybiB0aGUgc2l6ZSBvZiB0aGUgc2hvcnRlciBsaXN0Ci0JICogKGkuZS4gb25lIHBhc3QgdGhlIGxhc3QgaW5kZXggb2YgdGhlIHNob3J0ZXIgbGlzdCkuCi0JICogVXNlIG9iamVjdCBpZGVudGl0eSB0byBjb21wYXJlIHRoZSBlbGVtZW50cy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludCBpZGVudGl0eURpZmZTdGFydChMaXN0PD8+IGxpc3QxLCBMaXN0PD8+IGxpc3QyKSB7Ci0JCWludCBlbmQgPSBNYXRoLm1pbihsaXN0MS5zaXplKCksIGxpc3QyLnNpemUoKSk7Ci0JCWludCBzdGFydCA9IDA7Ci0JCXdoaWxlIChzdGFydCA8IGVuZCkgewotCQkJaWYgKGxpc3QxLmdldChzdGFydCkgPT0gbGlzdDIuZ2V0KHN0YXJ0KSkgewotCQkJCXN0YXJ0Kys7Ci0JCQl9IGVsc2UgewotCQkJCXJldHVybiBzdGFydDsKLQkJCX0KLQkJfQotCQlyZXR1cm4gc3RhcnQ7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBpbmRleCBvZiB0aGUgZmlyc3Qgb2NjdXJyZW5jZSBvZiB0aGUKLQkgKiBzcGVjaWZpZWQgZWxlbWVudCBpbiB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9yLAotCSAqIG9yIHJldHVybiAtMSBpZiB0aGVyZSBpcyBubyBzdWNoIGluZGV4LgotCSAqIGphdmEudXRpbC5JdGVyYXRvciNpbmRleE9mKE9iamVjdCBvKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50IGluZGV4T2YoSXRlcmF0b3I8Pz4gaXRlcmF0b3IsIE9iamVjdCB2YWx1ZSkgewotCQlpZiAodmFsdWUgPT0gbnVsbCkgewotCQkJZm9yIChpbnQgaSA9IDA7IGl0ZXJhdG9yLmhhc05leHQoKTsgaSsrKSB7Ci0JCQkJaWYgKGl0ZXJhdG9yLm5leHQoKSA9PSBudWxsKSB7Ci0JCQkJCXJldHVybiBpOwotCQkJCX0KLQkJCX0KLQkJfSBlbHNlIHsKLQkJCWZvciAoaW50IGkgPSAwOyBpdGVyYXRvci5oYXNOZXh0KCk7IGkrKykgewotCQkJCWlmICh2YWx1ZS5lcXVhbHMoaXRlcmF0b3IubmV4dCgpKSkgewotCQkJCQlyZXR1cm4gaTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIC0xOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaW5kZXggb2YgdGhlIGZpcnN0IG9jY3VycmVuY2Ugb2YgdGhlCi0JICogc3BlY2lmaWVkIGVsZW1lbnQgaW4gdGhlIHNwZWNpZmllZCBhcnJheSwKLQkgKiBvciByZXR1cm4gLTEgaWYgdGhlcmUgaXMgbm8gc3VjaCBpbmRleC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2luZGV4T2YoT2JqZWN0W10gYXJyYXksIE9iamVjdCBvKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50IGluZGV4T2YoT2JqZWN0W10gYXJyYXksIE9iamVjdCB2YWx1ZSkgewotCQlpbnQgbGVuID0gYXJyYXkubGVuZ3RoOwotCQlpZiAodmFsdWUgPT0gbnVsbCkgewotCQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsZW47IGkrKykgewotCQkJCWlmIChhcnJheVtpXSA9PSBudWxsKSB7Ci0JCQkJCXJldHVybiBpOwotCQkJCX0KLQkJCX0KLQkJfSBlbHNlIHsKLQkJCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKLQkJCQlpZiAodmFsdWUuZXF1YWxzKGFycmF5W2ldKSkgewotCQkJCQlyZXR1cm4gaTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIC0xOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaW5kZXggb2YgdGhlIGZpcnN0IG9jY3VycmVuY2Ugb2YgdGhlCi0JICogc3BlY2lmaWVkIGVsZW1lbnQgaW4gdGhlIHNwZWNpZmllZCBhcnJheSwKLQkgKiBvciByZXR1cm4gLTEgaWYgdGhlcmUgaXMgbm8gc3VjaCBpbmRleC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2luZGV4T2YoY2hhcltdIGFycmF5LCBjaGFyIHZhbHVlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50IGluZGV4T2YoY2hhcltdIGFycmF5LCBjaGFyIHZhbHVlKSB7Ci0JCWludCBsZW4gPSBhcnJheS5sZW5ndGg7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKLQkJCWlmIChhcnJheVtpXSA9PSB2YWx1ZSkgewotCQkJCXJldHVybiBpOwotCQkJfQotCQl9Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGluZGV4IG9mIHRoZSBmaXJzdCBvY2N1cnJlbmNlIG9mIHRoZQotCSAqIHNwZWNpZmllZCBlbGVtZW50IGluIHRoZSBzcGVjaWZpZWQgYXJyYXksCi0JICogb3IgcmV0dXJuIC0xIGlmIHRoZXJlIGlzIG5vIHN1Y2ggaW5kZXguCi0JICogamF2YS51dGlsLkFycmF5cyNpbmRleE9mKGludFtdIGFycmF5LCBpbnQgdmFsdWUpCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnQgaW5kZXhPZihpbnRbXSBhcnJheSwgaW50IHZhbHVlKSB7Ci0JCWludCBsZW4gPSBhcnJheS5sZW5ndGg7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKLQkJCWlmIChhcnJheVtpXSA9PSB2YWx1ZSkgewotCQkJCXJldHVybiBpOwotCQkJfQotCQl9Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG1heGltdW0gaW5kZXggb2Ygd2hlcmUgdGhlIHNwZWNpZmllZCBjb21wYXJhYmxlIG9iamVjdAotCSAqIHNob3VsZCBiZSBpbnNlcnRlZCBpbnRvIHRoZSBzcGVjaWZpZWQgc29ydGVkIGxpc3QgYW5kIHN0aWxsIGtlZXAKLQkgKiB0aGUgbGlzdCBzb3J0ZWQuCi0JICovCi0JcHVibGljIHN0YXRpYyA8RSBleHRlbmRzIENvbXBhcmFibGU8PyBzdXBlciBFPj4gaW50IGluc2VydGlvbkluZGV4T2YoTGlzdDxFPiBzb3J0ZWRMaXN0LCBDb21wYXJhYmxlPEU+IHZhbHVlKSB7Ci0JCWludCBsZW4gPSBzb3J0ZWRMaXN0LnNpemUoKTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsZW47IGkrKykgewotCQkJaWYgKHZhbHVlLmNvbXBhcmVUbyhzb3J0ZWRMaXN0LmdldChpKSkgPCAwKSB7Ci0JCQkJcmV0dXJuIGk7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGxlbjsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG1heGltdW0gaW5kZXggb2Ygd2hlcmUgdGhlIHNwZWNpZmllZCBvYmplY3QKLQkgKiBzaG91bGQgYmUgaW5zZXJ0ZWQgaW50byB0aGUgc3BlY2lmaWVkIHNvcnRlZCBsaXN0IGFuZCBzdGlsbCBrZWVwCi0JICogdGhlIGxpc3Qgc29ydGVkLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IGludCBpbnNlcnRpb25JbmRleE9mKExpc3Q8RT4gc29ydGVkTGlzdCwgRSB2YWx1ZSwgQ29tcGFyYXRvcjw/IHN1cGVyIEU+IGNvbXBhcmF0b3IpIHsKLQkJaW50IGxlbiA9IHNvcnRlZExpc3Quc2l6ZSgpOwotCQlmb3IgKGludCBpID0gMDsgaSA8IGxlbjsgaSsrKSB7Ci0JCQlpZiAoY29tcGFyYXRvci5jb21wYXJlKHZhbHVlLCBzb3J0ZWRMaXN0LmdldChpKSkgPCAwKSB7Ci0JCQkJcmV0dXJuIGk7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGxlbjsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG1heGltdW0gaW5kZXggb2Ygd2hlcmUgdGhlIHNwZWNpZmllZCBjb21wYXJhYmxlIG9iamVjdAotCSAqIHNob3VsZCBiZSBpbnNlcnRlZCBpbnRvIHRoZSBzcGVjaWZpZWQgc29ydGVkIGFycmF5IGFuZCBzdGlsbCBrZWVwCi0JICogdGhlIGFycmF5IHNvcnRlZC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFIGV4dGVuZHMgQ29tcGFyYWJsZTw/IHN1cGVyIEU+PiBpbnQgaW5zZXJ0aW9uSW5kZXhPZihFW10gc29ydGVkQXJyYXksIENvbXBhcmFibGU8RT4gdmFsdWUpIHsKLQkJaW50IGxlbiA9IHNvcnRlZEFycmF5Lmxlbmd0aDsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsZW47IGkrKykgewotCQkJaWYgKHZhbHVlLmNvbXBhcmVUbyhzb3J0ZWRBcnJheVtpXSkgPCAwKSB7Ci0JCQkJcmV0dXJuIGk7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGxlbjsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG1heGltdW0gaW5kZXggb2Ygd2hlcmUgdGhlIHNwZWNpZmllZCBjb21wYXJhYmxlIG9iamVjdAotCSAqIHNob3VsZCBiZSBpbnNlcnRlZCBpbnRvIHRoZSBzcGVjaWZpZWQgc29ydGVkIGFycmF5IGFuZCBzdGlsbCBrZWVwCi0JICogdGhlIGFycmF5IHNvcnRlZC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBpbnQgaW5zZXJ0aW9uSW5kZXhPZihFW10gc29ydGVkQXJyYXksIEUgdmFsdWUsIENvbXBhcmF0b3I8PyBzdXBlciBFPiBjb21wYXJhdG9yKSB7Ci0JCWludCBsZW4gPSBzb3J0ZWRBcnJheS5sZW5ndGg7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKLQkJCWlmIChjb21wYXJhdG9yLmNvbXBhcmUodmFsdWUsIHNvcnRlZEFycmF5W2ldKSA8IDApIHsKLQkJCQlyZXR1cm4gaTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gbGVuOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIG9uZS11c2UgSXRlcmFibGUgZm9yIHRoZSBJdGVyYXRvciBnaXZlbi4KLQkgKiBUaHJvd3MgYW4gSWxsZWdhbFN0YXRlRXhjZXB0aW9uIGlmIGl0ZXJhYmxlKCkgaXMgY2FsbGVkIG1vcmUgdGhhbiBvbmNlLgotCSAqIEFzIHN1Y2gsIHRoaXMgdXRpbGl0eSBzaG91bGQgb25seSBiZSB1c2VkIGluIG9uZS11c2Ugc2l0dWF0aW9ucywgc3VjaCBhcwotCSAqIGEgImZvciIgbG9vcC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBJdGVyYWJsZTxFPiBpdGVyYWJsZShJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IpIHsKLQkJcmV0dXJuIG5ldyBTaW5nbGVVc2VJdGVyYWJsZTxFPihpdGVyYXRvcik7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGFuIGl0ZXJhYmxlIG9uIHRoZSBlbGVtZW50cyBpbiB0aGUgc3BlY2lmaWVkIGFycmF5LgotCSAqIGphdmEudXRpbC5BcnJheXMjaXRlcmFibGUoT2JqZWN0W10gYXJyYXkpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gSXRlcmFibGU8RT4gaXRlcmFibGUoRS4uLiBhcnJheSkgewotCQlyZXR1cm4gQXJyYXlzLmFzTGlzdChhcnJheSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGFuIGl0ZXJhdG9yIG9uIHRoZSBlbGVtZW50cyBpbiB0aGUgc3BlY2lmaWVkIGFycmF5LgotCSAqIGphdmEudXRpbC5BcnJheXMjaXRlcmF0b3IoT2JqZWN0W10gYXJyYXkpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gSXRlcmF0b3I8RT4gaXRlcmF0b3IoRS4uLiBhcnJheSkgewotCQlyZXR1cm4gbmV3IEFycmF5SXRlcmF0b3I8RT4oYXJyYXkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaW5kZXggb2YgdGhlIGxhc3Qgb2NjdXJyZW5jZSBvZiB0aGUKLQkgKiBzcGVjaWZpZWQgZWxlbWVudCBpbiB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9yLAotCSAqIG9yIHJldHVybiAtMSBpZiB0aGVyZSBpcyBubyBzdWNoIGluZGV4LgotCSAqIGphdmEudXRpbC5JdGVyYXRvciNsYXN0SW5kZXhPZihPYmplY3QgbykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludCBsYXN0SW5kZXhPZihJdGVyYXRvcjw/PiBpdGVyYXRvciwgT2JqZWN0IHZhbHVlKSB7Ci0JCXJldHVybiAoaXRlcmF0b3IuaGFzTmV4dCgpKSA/IGxpc3QoaXRlcmF0b3IpLmxhc3RJbmRleE9mKHZhbHVlKSA6IC0xOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaW5kZXggb2YgdGhlIGxhc3Qgb2NjdXJyZW5jZSBvZiB0aGUKLQkgKiBzcGVjaWZpZWQgZWxlbWVudCBpbiB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9yLAotCSAqIG9yIHJldHVybiAtMSBpZiB0aGVyZSBpcyBubyBzdWNoIGluZGV4LgotCSAqIGphdmEudXRpbC5JdGVyYXRvciNsYXN0SW5kZXhPZihPYmplY3QgbykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludCBsYXN0SW5kZXhPZihJdGVyYXRvcjw/PiBpdGVyYXRvciwgaW50IHNpemUsIE9iamVjdCB2YWx1ZSkgewotCQlyZXR1cm4gKGl0ZXJhdG9yLmhhc05leHQoKSkgPyBsaXN0KGl0ZXJhdG9yLCBzaXplKS5sYXN0SW5kZXhPZih2YWx1ZSkgOiAtMTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGluZGV4IG9mIHRoZSBsYXN0IG9jY3VycmVuY2Ugb2YgdGhlCi0JICogc3BlY2lmaWVkIGVsZW1lbnQgaW4gdGhlIHNwZWNpZmllZCBhcnJheSwKLQkgKiBvciByZXR1cm4gLTEgaWYgdGhlcmUgaXMgbm8gc3VjaCBpbmRleC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2xhc3RJbmRleE9mKE9iamVjdFtdIGFycmF5LCBPYmplY3QgbykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludCBsYXN0SW5kZXhPZihPYmplY3RbXSBhcnJheSwgT2JqZWN0IHZhbHVlKSB7Ci0JCWludCBsZW4gPSBhcnJheS5sZW5ndGg7Ci0JCWlmICh2YWx1ZSA9PSBudWxsKSB7Ci0JCQlmb3IgKGludCBpID0gbGVuOyBpLS0gPiAwOyApIHsKLQkJCQlpZiAoYXJyYXlbaV0gPT0gbnVsbCkgewotCQkJCQlyZXR1cm4gaTsKLQkJCQl9Ci0JCQl9Ci0JCX0gZWxzZSB7Ci0JCQlmb3IgKGludCBpID0gbGVuOyBpLS0gPiAwOyApIHsKLQkJCQlpZiAodmFsdWUuZXF1YWxzKGFycmF5W2ldKSkgewotCQkJCQlyZXR1cm4gaTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIC0xOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaW5kZXggb2YgdGhlIGxhc3Qgb2NjdXJyZW5jZSBvZiB0aGUKLQkgKiBzcGVjaWZpZWQgZWxlbWVudCBpbiB0aGUgc3BlY2lmaWVkIGFycmF5LAotCSAqIG9yIHJldHVybiAtMSBpZiB0aGVyZSBpcyBubyBzdWNoIGluZGV4LgotCSAqIGphdmEudXRpbC5BcnJheXMjbGFzdEluZGV4T2YoY2hhcltdIGFycmF5LCBjaGFyIHZhbHVlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50IGxhc3RJbmRleE9mKGNoYXJbXSBhcnJheSwgY2hhciB2YWx1ZSkgewotCQlmb3IgKGludCBpID0gYXJyYXkubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCWlmIChhcnJheVtpXSA9PSB2YWx1ZSkgewotCQkJCXJldHVybiBpOwotCQkJfQotCQl9Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGluZGV4IG9mIHRoZSBsYXN0IG9jY3VycmVuY2Ugb2YgdGhlCi0JICogc3BlY2lmaWVkIGVsZW1lbnQgaW4gdGhlIHNwZWNpZmllZCBhcnJheSwKLQkgKiBvciByZXR1cm4gLTEgaWYgdGhlcmUgaXMgbm8gc3VjaCBpbmRleC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2xhc3RJbmRleE9mKGludFtdIGFycmF5LCBpbnQgdmFsdWUpCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnQgbGFzdEluZGV4T2YoaW50W10gYXJyYXksIGludCB2YWx1ZSkgewotCQlmb3IgKGludCBpID0gYXJyYXkubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCWlmIChhcnJheVtpXSA9PSB2YWx1ZSkgewotCQkJCXJldHVybiBpOwotCQkJfQotCQl9Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBsaXN0IGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBpdGVyYWJsZS4KLQkgKiBqYXZhLmxhbmcuSXRlcmFibGUjdG9MaXN0KCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBBcnJheUxpc3Q8RT4gbGlzdChJdGVyYWJsZTw/IGV4dGVuZHMgRT4gaXRlcmFibGUpIHsKLQkJcmV0dXJuIGxpc3QoaXRlcmFibGUuaXRlcmF0b3IoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgbGlzdCBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmFibGUuCi0JICogamF2YS5sYW5nLkl0ZXJhYmxlI3RvTGlzdCgpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gQXJyYXlMaXN0PEU+IGxpc3QoSXRlcmFibGU8PyBleHRlbmRzIEU+IGl0ZXJhYmxlLCBpbnQgc2l6ZSkgewotCQlyZXR1cm4gbGlzdChpdGVyYWJsZS5pdGVyYXRvcigpLCBzaXplKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBsaXN0IGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBpdGVyYXRvci4KLQkgKiBqYXZhLnV0aWwuSXRlcmF0b3IjdG9MaXN0KCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBBcnJheUxpc3Q8RT4gbGlzdChJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IpIHsKLQkJcmV0dXJuIGxpc3QoaXRlcmF0b3IsIG5ldyBBcnJheUxpc3Q8RT4oKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgbGlzdCBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICogamF2YS51dGlsLkl0ZXJhdG9yI3RvTGlzdCgpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gQXJyYXlMaXN0PEU+IGxpc3QoSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yLCBpbnQgc2l6ZSkgewotCQlyZXR1cm4gbGlzdChpdGVyYXRvciwgbmV3IEFycmF5TGlzdDxFPihzaXplKSk7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgPEU+IEFycmF5TGlzdDxFPiBsaXN0KEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVyYXRvciwgQXJyYXlMaXN0PEU+IGxpc3QpIHsKLQkJd2hpbGUgKGl0ZXJhdG9yLmhhc05leHQoKSkgewotCQkJbGlzdC5hZGQoaXRlcmF0b3IubmV4dCgpKTsKLQkJfQotCQlyZXR1cm4gbGlzdDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBsaXN0IGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBhcnJheS4KLQkgKiBVbmxpa2UgamF2YS51dGlsLkFycmF5cy5hc0xpc3QoT2JqZWN0W10pLCB0aGUgbGlzdAotCSAqIGlzIG1vZGlmaWFibGUgYW5kIGlzIG5vdCBiYWNrZWQgYnkgdGhlIGFycmF5LgotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEFycmF5TGlzdDxFPiBsaXN0KEUuLi4gYXJyYXkpIHsKLQkJQXJyYXlMaXN0PEU+IGxpc3QgPSBuZXcgQXJyYXlMaXN0PEU+KGFycmF5Lmxlbmd0aCk7Ci0JCWZvciAoRSBpdGVtIDogYXJyYXkpIHsKLQkJCWxpc3QuYWRkKGl0ZW0pOwotCQl9Ci0JCXJldHVybiBsaXN0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIGxpc3QgaXRlcmF0b3IgZm9yIHRoZSBzcGVjaWZpZWQgYXJyYXkuCi0JICogamF2YS51dGlsLkFycmF5cyNsaXN0SXRlcmF0b3IoT2JqZWN0W10gYXJyYXkpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gTGlzdEl0ZXJhdG9yPEU+IGxpc3RJdGVyYXRvcihFLi4uIGFycmF5KSB7Ci0JCXJldHVybiBsaXN0SXRlcmF0b3IoYXJyYXksIDApOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIGxpc3QgaXRlcmF0b3IgZm9yIHRoZSBzcGVjaWZpZWQgYXJyYXkKLQkgKiBzdGFydGluZyBhdCB0aGUgc3BlY2lmaWVkIHBvc2l0aW9uIGluIHRoZSBhcnJheS4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI2xpc3RJdGVyYXRvcihPYmplY3RbXSBhcnJheSwgaW50IGluZGV4KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IExpc3RJdGVyYXRvcjxFPiBsaXN0SXRlcmF0b3IoRVtdIGFycmF5LCBpbnQgaW5kZXgpIHsKLQkJcmV0dXJuIEFycmF5cy5hc0xpc3QoYXJyYXkpLmxpc3RJdGVyYXRvcihpbmRleCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjaGFyYWN0ZXIgZnJvbSB0aGUgc3BlY2lmaWVkIGFycmF5IHdpdGggdGhlIG1heGltdW0gdmFsdWUuCi0JICogamF2YS51dGlsLkFycmF5cyNtYXgoY2hhcltdIGFycmF5KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhciBtYXgoY2hhci4uLiBhcnJheSkgewotCQlpbnQgbGVuID0gYXJyYXkubGVuZ3RoOwotCQlpZiAobGVuID09IDApIHsKLQkJCXRocm93IG5ldyBJbmRleE91dE9mQm91bmRzRXhjZXB0aW9uKCk7Ci0JCX0KLQkJY2hhciBtYXggPSBhcnJheVswXTsKLQkJLy8gc3RhcnQgYXQgMQotCQlmb3IgKGludCBpID0gMTsgaSA8IGxlbjsgaSsrKSB7Ci0JCQljaGFyIG5leHQgPSBhcnJheVtpXTsKLQkJCWlmIChuZXh0ID4gbWF4KSB7Ci0JCQkJbWF4ID0gbmV4dDsKLQkJCX0KLQkJfQotCQlyZXR1cm4gbWF4OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaW50ZWdlciBmcm9tIHRoZSBzcGVjaWZpZWQgYXJyYXkgd2l0aCB0aGUgbWF4aW11bSB2YWx1ZS4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI21heChpbnRbXSBhcnJheSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludCBtYXgoaW50Li4uIGFycmF5KSB7Ci0JCWludCBsZW4gPSBhcnJheS5sZW5ndGg7Ci0JCWlmIChsZW4gPT0gMCkgewotCQkJdGhyb3cgbmV3IEluZGV4T3V0T2ZCb3VuZHNFeGNlcHRpb24oKTsKLQkJfQotCQlpbnQgbWF4ID0gYXJyYXlbMF07Ci0JCS8vIHN0YXJ0IGF0IDEKLQkJZm9yIChpbnQgaSA9IDE7IGkgPCBsZW47IGkrKykgewotCQkJaW50IG5leHQgPSBhcnJheVtpXTsKLQkJCWlmIChuZXh0ID4gbWF4KSB7Ci0JCQkJbWF4ID0gbmV4dDsKLQkJCX0KLQkJfQotCQlyZXR1cm4gbWF4OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgY2hhcmFjdGVyIGZyb20gdGhlIHNwZWNpZmllZCBhcnJheSB3aXRoIHRoZSBtaW5pbXVtIHZhbHVlLgotCSAqIGphdmEudXRpbC5BcnJheXMjbWluKGNoYXJbXSBhcnJheSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXIgbWluKGNoYXIuLi4gYXJyYXkpIHsKLQkJaW50IGxlbiA9IGFycmF5Lmxlbmd0aDsKLQkJaWYgKGxlbiA9PSAwKSB7Ci0JCQl0aHJvdyBuZXcgSW5kZXhPdXRPZkJvdW5kc0V4Y2VwdGlvbigpOwotCQl9Ci0JCWNoYXIgbWluID0gYXJyYXlbMF07Ci0JCS8vIHN0YXJ0IGF0IDEKLQkJZm9yIChpbnQgaSA9IDE7IGkgPCBsZW47IGkrKykgewotCQkJY2hhciBuZXh0ID0gYXJyYXlbaV07Ci0JCQlpZiAobmV4dCA8IG1pbikgewotCQkJCW1pbiA9IG5leHQ7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIG1pbjsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGludGVnZXIgZnJvbSB0aGUgc3BlY2lmaWVkIGFycmF5IHdpdGggdGhlIG1pbmltdW0gdmFsdWUuCi0JICogamF2YS51dGlsLkFycmF5cyNtaW4oaW50W10gYXJyYXkpCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnQgbWluKGludC4uLiBhcnJheSkgewotCQlpbnQgbGVuID0gYXJyYXkubGVuZ3RoOwotCQlpZiAobGVuID09IDApIHsKLQkJCXRocm93IG5ldyBJbmRleE91dE9mQm91bmRzRXhjZXB0aW9uKCk7Ci0JCX0KLQkJaW50IG1pbiA9IGFycmF5WzBdOwotCQkvLyBzdGFydCBhdCAxCi0JCWZvciAoaW50IGkgPSAxOyBpIDwgbGVuOyBpKyspIHsKLQkJCWludCBuZXh0ID0gYXJyYXlbaV07Ci0JCQlpZiAobmV4dCA8IG1pbikgewotCQkJCW1pbiA9IG5leHQ7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIG1pbjsKLQl9Ci0KLQkvKioKLQkgKiBNb3ZlIGFuIGVsZW1lbnQgZnJvbSB0aGUgc3BlY2lmaWVkIHNvdXJjZSBpbmRleCB0byB0aGUgc3BlY2lmaWVkIHRhcmdldAotCSAqIGluZGV4LiBSZXR1cm4gdGhlIGFsdGVyZWQgYXJyYXkuCi0JICogamF2YS51dGlsLkFycmF5cyNtb3ZlKE9iamVjdFtdIGFycmF5LCBpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gbW92ZShFW10gYXJyYXksIGludCB0YXJnZXRJbmRleCwgaW50IHNvdXJjZUluZGV4KSB7Ci0JCXJldHVybiAodGFyZ2V0SW5kZXggPT0gc291cmNlSW5kZXgpID8gYXJyYXkgOiBtb3ZlXyhhcnJheSwgdGFyZ2V0SW5kZXgsIHNvdXJjZUluZGV4KTsKLQl9Ci0KLQkvKioKLQkgKiBhc3N1bWUgdGFyZ2V0SW5kZXggIT0gc291cmNlSW5kZXgKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyA8RT4gRVtdIG1vdmVfKEVbXSBhcnJheSwgaW50IHRhcmdldEluZGV4LCBpbnQgc291cmNlSW5kZXgpIHsKLQkJRSB0ZW1wID0gYXJyYXlbc291cmNlSW5kZXhdOwotCQlpZiAodGFyZ2V0SW5kZXggPCBzb3VyY2VJbmRleCkgewotCQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgdGFyZ2V0SW5kZXgsIGFycmF5LCB0YXJnZXRJbmRleCArIDEsIHNvdXJjZUluZGV4IC0gdGFyZ2V0SW5kZXgpOwotCQl9IGVsc2UgewotCQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgc291cmNlSW5kZXggKyAxLCBhcnJheSwgc291cmNlSW5kZXgsIHRhcmdldEluZGV4IC0gc291cmNlSW5kZXgpOwotCQl9Ci0JCWFycmF5W3RhcmdldEluZGV4XSA9IHRlbXA7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBNb3ZlIGVsZW1lbnRzIGZyb20gdGhlIHNwZWNpZmllZCBzb3VyY2UgaW5kZXggdG8gdGhlIHNwZWNpZmllZCB0YXJnZXQKLQkgKiBpbmRleC4gUmV0dXJuIHRoZSBhbHRlcmVkIGFycmF5LgotCSAqIGphdmEudXRpbC5BcnJheXMjbW92ZShPYmplY3RbXSBhcnJheSwgaW50IHRhcmdldEluZGV4LCBpbnQgc291cmNlSW5kZXgsIGludCBsZW5ndGgpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gRVtdIG1vdmUoRVtdIGFycmF5LCBpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCwgaW50IGxlbmd0aCkgewotCQlpZiAoKHRhcmdldEluZGV4ID09IHNvdXJjZUluZGV4KSB8fCAobGVuZ3RoID09IDApKSB7Ci0JCQlyZXR1cm4gYXJyYXk7Ci0JCX0KLQkJaWYgKGxlbmd0aCA9PSAxKSB7Ci0JCQlyZXR1cm4gbW92ZV8oYXJyYXksIHRhcmdldEluZGV4LCBzb3VyY2VJbmRleCk7Ci0JCX0KLQkJRVtdIHRlbXAgPSBuZXdBcnJheShhcnJheSwgbGVuZ3RoKTsKLQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgc291cmNlSW5kZXgsIHRlbXAsIDAsIGxlbmd0aCk7Ci0JCWlmICh0YXJnZXRJbmRleCA8IHNvdXJjZUluZGV4KSB7Ci0JCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCB0YXJnZXRJbmRleCwgYXJyYXksIHRhcmdldEluZGV4ICsgbGVuZ3RoLCBzb3VyY2VJbmRleCAtIHRhcmdldEluZGV4KTsKLQkJfSBlbHNlIHsKLQkJCVN5c3RlbS5hcnJheWNvcHkoYXJyYXksIHNvdXJjZUluZGV4ICsgbGVuZ3RoLCBhcnJheSwgc291cmNlSW5kZXgsIHRhcmdldEluZGV4IC0gc291cmNlSW5kZXgpOwotCQl9Ci0JCVN5c3RlbS5hcnJheWNvcHkodGVtcCwgMCwgYXJyYXksIHRhcmdldEluZGV4LCBsZW5ndGgpOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogTW92ZSBhbiBlbGVtZW50IGZyb20gdGhlIHNwZWNpZmllZCBzb3VyY2UgaW5kZXggdG8gdGhlIHNwZWNpZmllZCB0YXJnZXQKLQkgKiBpbmRleC4gUmV0dXJuIHRoZSBhbHRlcmVkIGFycmF5LgotCSAqIGphdmEudXRpbC5BcnJheXMjbW92ZShpbnRbXSBhcnJheSwgaW50IHRhcmdldEluZGV4LCBpbnQgc291cmNlSW5kZXgpCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnRbXSBtb3ZlKGludFtdIGFycmF5LCBpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCkgewotCQlyZXR1cm4gKHRhcmdldEluZGV4ID09IHNvdXJjZUluZGV4KSA/IGFycmF5IDogbW92ZV8oYXJyYXksIHRhcmdldEluZGV4LCBzb3VyY2VJbmRleCk7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIHRhcmdldEluZGV4ICE9IHNvdXJjZUluZGV4Ci0JICovCi0JcHJpdmF0ZSBzdGF0aWMgaW50W10gbW92ZV8oaW50W10gYXJyYXksIGludCB0YXJnZXRJbmRleCwgaW50IHNvdXJjZUluZGV4KSB7Ci0JCWludCB0ZW1wID0gYXJyYXlbc291cmNlSW5kZXhdOwotCQlpZiAodGFyZ2V0SW5kZXggPCBzb3VyY2VJbmRleCkgewotCQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgdGFyZ2V0SW5kZXgsIGFycmF5LCB0YXJnZXRJbmRleCArIDEsIHNvdXJjZUluZGV4IC0gdGFyZ2V0SW5kZXgpOwotCQl9IGVsc2UgewotCQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgc291cmNlSW5kZXggKyAxLCBhcnJheSwgc291cmNlSW5kZXgsIHRhcmdldEluZGV4IC0gc291cmNlSW5kZXgpOwotCQl9Ci0JCWFycmF5W3RhcmdldEluZGV4XSA9IHRlbXA7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBNb3ZlIGVsZW1lbnRzIGZyb20gdGhlIHNwZWNpZmllZCBzb3VyY2UgaW5kZXggdG8gdGhlIHNwZWNpZmllZCB0YXJnZXQKLQkgKiBpbmRleC4gUmV0dXJuIHRoZSBhbHRlcmVkIGFycmF5LgotCSAqIGphdmEudXRpbC5BcnJheXMjbW92ZShpbnRbXSBhcnJheSwgaW50IHRhcmdldEluZGV4LCBpbnQgc291cmNlSW5kZXgsIGludCBsZW5ndGgpCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnRbXSBtb3ZlKGludFtdIGFycmF5LCBpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCwgaW50IGxlbmd0aCkgewotCQlpZiAoKHRhcmdldEluZGV4ID09IHNvdXJjZUluZGV4KSB8fCAobGVuZ3RoID09IDApKSB7Ci0JCQlyZXR1cm4gYXJyYXk7Ci0JCX0KLQkJaWYgKGxlbmd0aCA9PSAxKSB7Ci0JCQlyZXR1cm4gbW92ZV8oYXJyYXksIHRhcmdldEluZGV4LCBzb3VyY2VJbmRleCk7Ci0JCX0KLQkJaW50W10gdGVtcCA9IG5ldyBpbnRbbGVuZ3RoXTsKLQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgc291cmNlSW5kZXgsIHRlbXAsIDAsIGxlbmd0aCk7Ci0JCWlmICh0YXJnZXRJbmRleCA8IHNvdXJjZUluZGV4KSB7Ci0JCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCB0YXJnZXRJbmRleCwgYXJyYXksIHRhcmdldEluZGV4ICsgbGVuZ3RoLCBzb3VyY2VJbmRleCAtIHRhcmdldEluZGV4KTsKLQkJfSBlbHNlIHsKLQkJCVN5c3RlbS5hcnJheWNvcHkoYXJyYXksIHNvdXJjZUluZGV4ICsgbGVuZ3RoLCBhcnJheSwgc291cmNlSW5kZXgsIHRhcmdldEluZGV4IC0gc291cmNlSW5kZXgpOwotCQl9Ci0JCVN5c3RlbS5hcnJheWNvcHkodGVtcCwgMCwgYXJyYXksIHRhcmdldEluZGV4LCBsZW5ndGgpOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogTW92ZSBhbiBlbGVtZW50IGZyb20gdGhlIHNwZWNpZmllZCBzb3VyY2UgaW5kZXggdG8gdGhlIHNwZWNpZmllZCB0YXJnZXQKLQkgKiBpbmRleC4gUmV0dXJuIHRoZSBhbHRlcmVkIGFycmF5LgotCSAqIGphdmEudXRpbC5BcnJheXMjbW92ZShjaGFyW10gYXJyYXksIGludCB0YXJnZXRJbmRleCwgaW50IHNvdXJjZUluZGV4KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIG1vdmUoY2hhcltdIGFycmF5LCBpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCkgewotCQlyZXR1cm4gKHRhcmdldEluZGV4ID09IHNvdXJjZUluZGV4KSA/IGFycmF5IDogbW92ZV8oYXJyYXksIHRhcmdldEluZGV4LCBzb3VyY2VJbmRleCk7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIHRhcmdldEluZGV4ICE9IHNvdXJjZUluZGV4Ci0JICovCi0JcHJpdmF0ZSBzdGF0aWMgY2hhcltdIG1vdmVfKGNoYXJbXSBhcnJheSwgaW50IHRhcmdldEluZGV4LCBpbnQgc291cmNlSW5kZXgpIHsKLQkJY2hhciB0ZW1wID0gYXJyYXlbc291cmNlSW5kZXhdOwotCQlpZiAodGFyZ2V0SW5kZXggPCBzb3VyY2VJbmRleCkgewotCQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgdGFyZ2V0SW5kZXgsIGFycmF5LCB0YXJnZXRJbmRleCArIDEsIHNvdXJjZUluZGV4IC0gdGFyZ2V0SW5kZXgpOwotCQl9IGVsc2UgewotCQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgc291cmNlSW5kZXggKyAxLCBhcnJheSwgc291cmNlSW5kZXgsIHRhcmdldEluZGV4IC0gc291cmNlSW5kZXgpOwotCQl9Ci0JCWFycmF5W3RhcmdldEluZGV4XSA9IHRlbXA7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBNb3ZlIGVsZW1lbnRzIGZyb20gdGhlIHNwZWNpZmllZCBzb3VyY2UgaW5kZXggdG8gdGhlIHNwZWNpZmllZCB0YXJnZXQKLQkgKiBpbmRleC4gUmV0dXJuIHRoZSBhbHRlcmVkIGFycmF5LgotCSAqIGphdmEudXRpbC5BcnJheXMjbW92ZShjaGFyW10gYXJyYXksIGludCB0YXJnZXRJbmRleCwgaW50IHNvdXJjZUluZGV4LCBpbnQgbGVuZ3RoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIG1vdmUoY2hhcltdIGFycmF5LCBpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCwgaW50IGxlbmd0aCkgewotCQlpZiAoKHRhcmdldEluZGV4ID09IHNvdXJjZUluZGV4KSB8fCAobGVuZ3RoID09IDApKSB7Ci0JCQlyZXR1cm4gYXJyYXk7Ci0JCX0KLQkJaWYgKGxlbmd0aCA9PSAxKSB7Ci0JCQlyZXR1cm4gbW92ZV8oYXJyYXksIHRhcmdldEluZGV4LCBzb3VyY2VJbmRleCk7Ci0JCX0KLQkJY2hhcltdIHRlbXAgPSBuZXcgY2hhcltsZW5ndGhdOwotCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCBzb3VyY2VJbmRleCwgdGVtcCwgMCwgbGVuZ3RoKTsKLQkJaWYgKHRhcmdldEluZGV4IDwgc291cmNlSW5kZXgpIHsKLQkJCVN5c3RlbS5hcnJheWNvcHkoYXJyYXksIHRhcmdldEluZGV4LCBhcnJheSwgdGFyZ2V0SW5kZXggKyBsZW5ndGgsIHNvdXJjZUluZGV4IC0gdGFyZ2V0SW5kZXgpOwotCQl9IGVsc2UgewotCQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgc291cmNlSW5kZXggKyBsZW5ndGgsIGFycmF5LCBzb3VyY2VJbmRleCwgdGFyZ2V0SW5kZXggLSBzb3VyY2VJbmRleCk7Ci0JCX0KLQkJU3lzdGVtLmFycmF5Y29weSh0ZW1wLCAwLCBhcnJheSwgdGFyZ2V0SW5kZXgsIGxlbmd0aCk7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBNb3ZlIGFuIGVsZW1lbnQgZnJvbSB0aGUgc3BlY2lmaWVkIHNvdXJjZSBpbmRleCB0byB0aGUgc3BlY2lmaWVkIHRhcmdldAotCSAqIGluZGV4LiBSZXR1cm4gdGhlIGFsdGVyZWQgbGlzdC4KLQkgKiBqYXZhLnV0aWwuTGlzdCNtb3ZlKGludCB0YXJnZXRJbmRleCwgaW50IHNvdXJjZUluZGV4KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IExpc3Q8RT4gbW92ZShMaXN0PEU+IGxpc3QsIGludCB0YXJnZXRJbmRleCwgaW50IHNvdXJjZUluZGV4KSB7Ci0JCXJldHVybiAodGFyZ2V0SW5kZXggPT0gc291cmNlSW5kZXgpID8gbGlzdCA6IG1vdmVfKGxpc3QsIHRhcmdldEluZGV4LCBzb3VyY2VJbmRleCk7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIHRhcmdldEluZGV4ICE9IHNvdXJjZUluZGV4Ci0JICovCi0JcHJpdmF0ZSBzdGF0aWMgPEU+IExpc3Q8RT4gbW92ZV8oTGlzdDxFPiBsaXN0LCBpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCkgewotCQlpZiAobGlzdCBpbnN0YW5jZW9mIFJhbmRvbUFjY2VzcykgewotCQkJLy8gbW92ZSBlbGVtZW50cywgbGVhdmluZyB0aGUgbGlzdCBpbiBwbGFjZQotCQkJRSB0ZW1wID0gbGlzdC5nZXQoc291cmNlSW5kZXgpOwotCQkJaWYgKHRhcmdldEluZGV4IDwgc291cmNlSW5kZXgpIHsKLQkJCQlmb3IgKGludCBpID0gc291cmNlSW5kZXg7IGktLSA+IHRhcmdldEluZGV4OyApIHsKLQkJCQkJbGlzdC5zZXQoaSArIDEsIGxpc3QuZ2V0KGkpKTsKLQkJCQl9Ci0JCQl9IGVsc2UgewotCQkJCWZvciAoaW50IGkgPSBzb3VyY2VJbmRleDsgaSA8IHRhcmdldEluZGV4OyBpKyspIHsKLQkJCQkJbGlzdC5zZXQoaSwgbGlzdC5nZXQoaSArIDEpKTsKLQkJCQl9Ci0JCQl9Ci0JCQlsaXN0LnNldCh0YXJnZXRJbmRleCwgdGVtcCk7Ci0JCX0gZWxzZSB7Ci0JCQkvLyByZW1vdmUgdGhlIGVsZW1lbnQgYW5kIHJlLWFkZCBpdCBhdCB0aGUgdGFyZ2V0IGluZGV4Ci0JCQlsaXN0LmFkZCh0YXJnZXRJbmRleCwgbGlzdC5yZW1vdmUoc291cmNlSW5kZXgpKTsKLQkJfQotCQlyZXR1cm4gbGlzdDsKLQl9Ci0KLQkvKioKLQkgKiBNb3ZlIGVsZW1lbnRzIGZyb20gdGhlIHNwZWNpZmllZCBzb3VyY2UgaW5kZXggdG8gdGhlIHNwZWNpZmllZCB0YXJnZXQKLQkgKiBpbmRleC4gUmV0dXJuIHRoZSBhbHRlcmVkIGxpc3QuCi0JICogamF2YS51dGlsLkxpc3QjbW92ZShpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCwgaW50IGxlbmd0aCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBMaXN0PEU+IG1vdmUoTGlzdDxFPiBsaXN0LCBpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCwgaW50IGxlbmd0aCkgewotCQlpZiAoKHRhcmdldEluZGV4ID09IHNvdXJjZUluZGV4KSB8fCAobGVuZ3RoID09IDApKSB7Ci0JCQlyZXR1cm4gbGlzdDsKLQkJfQotCQlpZiAobGVuZ3RoID09IDEpIHsKLQkJCXJldHVybiBtb3ZlXyhsaXN0LCB0YXJnZXRJbmRleCwgc291cmNlSW5kZXgpOwotCQl9Ci0JCWlmIChsaXN0IGluc3RhbmNlb2YgUmFuZG9tQWNjZXNzKSB7Ci0JCQkvLyBtb3ZlIGVsZW1lbnRzLCBsZWF2aW5nIHRoZSBsaXN0IGluIHBsYWNlCi0JCQlBcnJheUxpc3Q8RT4gdGVtcCA9IG5ldyBBcnJheUxpc3Q8RT4obGlzdC5zdWJMaXN0KHNvdXJjZUluZGV4LCBzb3VyY2VJbmRleCArIGxlbmd0aCkpOwotCQkJaWYgKHRhcmdldEluZGV4IDwgc291cmNlSW5kZXgpIHsKLQkJCQlmb3IgKGludCBpID0gc291cmNlSW5kZXg7IGktLSA+IHRhcmdldEluZGV4OyApIHsKLQkJCQkJbGlzdC5zZXQoaSArIGxlbmd0aCwgbGlzdC5nZXQoaSkpOwotCQkJCX0KLQkJCX0gZWxzZSB7Ci0JCQkJZm9yIChpbnQgaSA9IHNvdXJjZUluZGV4OyBpIDwgdGFyZ2V0SW5kZXg7IGkrKykgewotCQkJCQlsaXN0LnNldChpLCBsaXN0LmdldChpICsgbGVuZ3RoKSk7Ci0JCQkJfQotCQkJfQotCQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsZW5ndGg7IGkrKykgewotCQkJCWxpc3Quc2V0KHRhcmdldEluZGV4ICsgaSwgdGVtcC5nZXQoaSkpOwotCQkJfQotCQl9IGVsc2UgewotCQkJLy8gcmVtb3ZlIHRoZSBlbGVtZW50cyBhbmQgcmUtYWRkIHRoZW0gYXQgdGhlIHRhcmdldCBpbmRleAotCQkJbGlzdC5hZGRBbGwodGFyZ2V0SW5kZXgsIHJlbW92ZUVsZW1lbnRzQXRJbmRleChsaXN0LCBzb3VyY2VJbmRleCwgbGVuZ3RoKSk7Ci0JCX0KLQkJcmV0dXJuIGxpc3Q7Ci0JfQotCi0JLyoqCi0JICogUmVwbGFjZSBhbGwgb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCBvbGQgdmFsdWUgd2l0aAotCSAqIHRoZSBzcGVjaWZpZWQgbmV3IHZhbHVlLgotCSAqIGphdmEudXRpbC5BcnJheXMjcmVwbGFjZUFsbChPYmplY3RbXSBhcnJheSwgT2JqZWN0IG9sZFZhbHVlLCBPYmplY3QgbmV3VmFsdWUpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gRVtdIHJlcGxhY2VBbGwoRVtdIGFycmF5LCBPYmplY3Qgb2xkVmFsdWUsIEUgbmV3VmFsdWUpIHsKLQkJaWYgKG9sZFZhbHVlID09IG51bGwpIHsKLQkJCWZvciAoaW50IGkgPSBhcnJheS5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJCWlmIChhcnJheVtpXSA9PSBudWxsKSB7Ci0JCQkJCWFycmF5W2ldID0gbmV3VmFsdWU7Ci0JCQkJfQotCQkJfQotCQl9IGVsc2UgewotCQkJZm9yIChpbnQgaSA9IGFycmF5Lmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQkJaWYgKG9sZFZhbHVlLmVxdWFscyhhcnJheVtpXSkpIHsKLQkJCQkJYXJyYXlbaV0gPSBuZXdWYWx1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJlcGxhY2UgYWxsIG9jY3VycmVuY2VzIG9mIHRoZSBzcGVjaWZpZWQgb2xkIHZhbHVlIHdpdGgKLQkgKiB0aGUgc3BlY2lmaWVkIG5ldyB2YWx1ZS4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI3JlcGxhY2VBbGwoaW50W10gYXJyYXksIGludCBvbGRWYWx1ZSwgaW50IG5ld1ZhbHVlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50W10gcmVwbGFjZUFsbChpbnRbXSBhcnJheSwgaW50IG9sZFZhbHVlLCBpbnQgbmV3VmFsdWUpIHsKLQkJZm9yIChpbnQgaSA9IGFycmF5Lmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlpZiAoYXJyYXlbaV0gPT0gb2xkVmFsdWUpIHsKLQkJCQlhcnJheVtpXSA9IG5ld1ZhbHVlOwotCQkJfQotCQl9Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBsYWNlIGFsbCBvY2N1cnJlbmNlcyBvZiB0aGUgc3BlY2lmaWVkIG9sZCB2YWx1ZSB3aXRoCi0JICogdGhlIHNwZWNpZmllZCBuZXcgdmFsdWUuCi0JICogamF2YS51dGlsLkFycmF5cyNyZXBsYWNlQWxsKGNoYXJbXSBhcnJheSwgY2hhciBvbGRWYWx1ZSwgY2hhciBuZXdWYWx1ZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXJbXSByZXBsYWNlQWxsKGNoYXJbXSBhcnJheSwgY2hhciBvbGRWYWx1ZSwgY2hhciBuZXdWYWx1ZSkgewotCQlmb3IgKGludCBpID0gYXJyYXkubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCWlmIChhcnJheVtpXSA9PSBvbGRWYWx1ZSkgewotCQkJCWFycmF5W2ldID0gbmV3VmFsdWU7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBhcnJheSB0aGF0IGNvbnRhaW5zIHRoZSBlbGVtZW50cyBpbiB0aGUKLQkgKiBzcGVjaWZpZWQgYXJyYXkgd2l0aCB0aGUgc3BlY2lmaWVkIGVsZW1lbnQgcmVtb3ZlZC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI3JlbW92ZShPYmplY3RbXSBhcnJheSwgT2JqZWN0IHZhbHVlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSByZW1vdmUoRVtdIGFycmF5LCBPYmplY3QgdmFsdWUpIHsKLQkJcmV0dXJuIHJlbW92ZUVsZW1lbnRBdEluZGV4KGFycmF5LCBpbmRleE9mKGFycmF5LCB2YWx1ZSkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBhcnJheSB0aGF0IGNvbnRhaW5zIHRoZSBlbGVtZW50cyBpbiB0aGUKLQkgKiBzcGVjaWZpZWQgYXJyYXkgd2l0aCB0aGUgc3BlY2lmaWVkIGVsZW1lbnQgcmVtb3ZlZC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI3JlbW92ZShjaGFyW10gYXJyYXksIGNoYXIgdmFsdWUpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gcmVtb3ZlKGNoYXJbXSBhcnJheSwgY2hhciB2YWx1ZSkgewotCQlyZXR1cm4gcmVtb3ZlRWxlbWVudEF0SW5kZXgoYXJyYXksIGluZGV4T2YoYXJyYXksIHZhbHVlKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgbmV3IGFycmF5IHRoYXQgY29udGFpbnMgdGhlIGVsZW1lbnRzIGluIHRoZQotCSAqIHNwZWNpZmllZCBhcnJheSB3aXRoIHRoZSBzcGVjaWZpZWQgZWxlbWVudCByZW1vdmVkLgotCSAqIGphdmEudXRpbC5BcnJheXMjcmVtb3ZlKGludFtdIGFycmF5LCBpbnQgdmFsdWUpCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnRbXSByZW1vdmUoaW50W10gYXJyYXksIGludCB2YWx1ZSkgewotCQlyZXR1cm4gcmVtb3ZlRWxlbWVudEF0SW5kZXgoYXJyYXksIGluZGV4T2YoYXJyYXksIHZhbHVlKSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGFsbCB0aGUgZWxlbWVudHMgcmV0dXJuZWQgYnkgdGhlIHNwZWNpZmllZCBpdGVyYWJsZQotCSAqIGZyb20gdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjb2xsZWN0aW9uIGNoYW5nZWQgYXMgYSByZXN1bHQuCi0JICogamF2YS51dGlsLkNvbGxlY3Rpb24jcmVtb3ZlQWxsKGphdmEubGFuZy5JdGVyYWJsZSBpdGVyYWJsZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gcmVtb3ZlQWxsKENvbGxlY3Rpb248Pz4gY29sbGVjdGlvbiwgSXRlcmFibGU8Pz4gaXRlcmFibGUpIHsKLQkJcmV0dXJuIHJlbW92ZUFsbChjb2xsZWN0aW9uLCBpdGVyYWJsZS5pdGVyYXRvcigpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYWxsIHRoZSBlbGVtZW50cyByZXR1cm5lZCBieSB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlCi0JICogZnJvbSB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24uCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGNvbGxlY3Rpb24gY2hhbmdlZCBhcyBhIHJlc3VsdC4KLQkgKiBqYXZhLnV0aWwuQ29sbGVjdGlvbiNyZW1vdmVBbGwoamF2YS5sYW5nLkl0ZXJhYmxlIGl0ZXJhYmxlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiByZW1vdmVBbGwoQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uLCBJdGVyYWJsZTw/PiBpdGVyYWJsZSwgaW50IHNpemUpIHsKLQkJcmV0dXJuIHJlbW92ZUFsbChjb2xsZWN0aW9uLCBpdGVyYWJsZS5pdGVyYXRvcigpLCBzaXplKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYWxsIHRoZSBlbGVtZW50cyByZXR1cm5lZCBieSB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9yCi0JICogZnJvbSB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24uCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGNvbGxlY3Rpb24gY2hhbmdlZCBhcyBhIHJlc3VsdC4KLQkgKiBqYXZhLnV0aWwuQ29sbGVjdGlvbiNyZW1vdmVBbGwoamF2YS51dGlsLkl0ZXJhdG9yIGl0ZXJhdG9yKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiByZW1vdmVBbGwoQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uLCBJdGVyYXRvcjw/PiBpdGVyYXRvcikgewotCQlyZXR1cm4gKGl0ZXJhdG9yLmhhc05leHQoKSkgPyBjb2xsZWN0aW9uLnJlbW92ZUFsbChzZXQoaXRlcmF0b3IpKSA6IGZhbHNlOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBhbGwgdGhlIGVsZW1lbnRzIHJldHVybmVkIGJ5IHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IKLQkgKiBmcm9tIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbi4KLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgY29sbGVjdGlvbiBjaGFuZ2VkIGFzIGEgcmVzdWx0LgotCSAqIGphdmEudXRpbC5Db2xsZWN0aW9uI3JlbW92ZUFsbChqYXZhLnV0aWwuSXRlcmF0b3IgaXRlcmF0b3IpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIHJlbW92ZUFsbChDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIEl0ZXJhdG9yPD8+IGl0ZXJhdG9yLCBpbnQgc2l6ZSkgewotCQlyZXR1cm4gKGl0ZXJhdG9yLmhhc05leHQoKSkgPyBjb2xsZWN0aW9uLnJlbW92ZUFsbChzZXQoaXRlcmF0b3IsIHNpemUpKSA6IGZhbHNlOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBhbGwgdGhlIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQgYXJyYXkKLQkgKiBmcm9tIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbi4KLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgY29sbGVjdGlvbiBjaGFuZ2VkIGFzIGEgcmVzdWx0LgotCSAqIGphdmEudXRpbC5Db2xsZWN0aW9uI3JlbW92ZUFsbChPYmplY3RbXSBhcnJheSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gcmVtb3ZlQWxsKENvbGxlY3Rpb248Pz4gY29sbGVjdGlvbiwgT2JqZWN0W10gYXJyYXkpIHsKLQkJcmV0dXJuIGNvbGxlY3Rpb24ucmVtb3ZlQWxsKHNldChhcnJheSkpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBmcm9tIHRoZSBzcGVjaWZpZWQgYXJyYXkgYWxsIHRoZSBlbGVtZW50cyBpbgotCSAqIHRoZSBzcGVjaWZpZWQgaXRlcmFibGUgYW5kIHJldHVybiB0aGUgcmVzdWx0LgotCSAqIGphdmEudXRpbC5BcnJheXMjcmVtb3ZlQWxsKE9iamVjdFtdIGFycmF5LCBJdGVyYWJsZSBpdGVyYWJsZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gcmVtb3ZlQWxsKEVbXSBhcnJheSwgSXRlcmFibGU8Pz4gaXRlcmFibGUpIHsKLQkJcmV0dXJuIHJlbW92ZUFsbChhcnJheSwgaXRlcmFibGUuaXRlcmF0b3IoKSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGZyb20gdGhlIHNwZWNpZmllZCBhcnJheSBhbGwgdGhlIGVsZW1lbnRzIGluCi0JICogdGhlIHNwZWNpZmllZCBpdGVyYWJsZSBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogamF2YS51dGlsLkFycmF5cyNyZW1vdmVBbGwoT2JqZWN0W10gYXJyYXksIEl0ZXJhYmxlIGl0ZXJhYmxlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSByZW1vdmVBbGwoRVtdIGFycmF5LCBJdGVyYWJsZTw/PiBpdGVyYWJsZSwgaW50IHNpemUpIHsKLQkJcmV0dXJuIHJlbW92ZUFsbChhcnJheSwgaXRlcmFibGUuaXRlcmF0b3IoKSwgc2l6ZSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGZyb20gdGhlIHNwZWNpZmllZCBhcnJheSBhbGwgdGhlIGVsZW1lbnRzIGluCi0JICogdGhlIHNwZWNpZmllZCBpdGVyYXRvciBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogamF2YS51dGlsLkFycmF5cyNyZW1vdmVBbGwoT2JqZWN0W10gYXJyYXksIEl0ZXJhdG9yIGl0ZXJhdG9yKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSByZW1vdmVBbGwoRVtdIGFycmF5LCBJdGVyYXRvcjw/PiBpdGVyYXRvcikgewotCQlyZXR1cm4gKGl0ZXJhdG9yLmhhc05leHQoKSkgPyByZW1vdmVBbGxfKGFycmF5LCBzZXQoaXRlcmF0b3IpKSA6IGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBmcm9tIHRoZSBzcGVjaWZpZWQgYXJyYXkgYWxsIHRoZSBlbGVtZW50cyBpbgotCSAqIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IgYW5kIHJldHVybiB0aGUgcmVzdWx0LgotCSAqIGphdmEudXRpbC5BcnJheXMjcmVtb3ZlQWxsKE9iamVjdFtdIGFycmF5LCBJdGVyYXRvciBpdGVyYXRvcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gcmVtb3ZlQWxsKEVbXSBhcnJheSwgSXRlcmF0b3I8Pz4gaXRlcmF0b3IsIGludCBzaXplKSB7Ci0JCXJldHVybiAoaXRlcmF0b3IuaGFzTmV4dCgpKSA/IHJlbW92ZUFsbF8oYXJyYXksIHNldChpdGVyYXRvciwgc2l6ZSkpIDogYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGZyb20gdGhlIHNwZWNpZmllZCBhcnJheSBhbGwgdGhlIGVsZW1lbnRzIGluCi0JICogdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uIGFuZCByZXR1cm4gdGhlIHJlc3VsdC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI3JlbW92ZUFsbChPYmplY3RbXSBhcnJheSwgQ29sbGVjdGlvbiBjb2xsZWN0aW9uKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSByZW1vdmVBbGwoRVtdIGFycmF5LCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24pIHsKLQkJcmV0dXJuIChjb2xsZWN0aW9uLmlzRW1wdHkoKSkgPyBhcnJheSA6IHJlbW92ZUFsbF8oYXJyYXksIGNvbGxlY3Rpb24pOwotCX0KLQotCS8qKgotCSAqIGFzc3VtZSB0aGUgY29sbGVjdGlvbiBpcyBub24tZW1wdHkKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyA8RT4gRVtdIHJlbW92ZUFsbF8oRVtdIGFycmF5LCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24pIHsKLQkJaW50IGFycmF5TGVuZ3RoID0gYXJyYXkubGVuZ3RoOwotCQlyZXR1cm4gKGFycmF5TGVuZ3RoID09IDApID8gYXJyYXkgOiByZW1vdmVBbGwoYXJyYXksIGNvbGxlY3Rpb24sIGFycmF5TGVuZ3RoKTsKLQl9Ci0KLQkvKioKLQkgKiBhc3N1bWUgdGhlIGNvbGxlY3Rpb24gaXMgbm9uLWVtcHR5IGFuZCBhcnJheUxlbmd0aCA+IDAKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyA8RT4gRVtdIHJlbW92ZUFsbChFW10gYXJyYXksIENvbGxlY3Rpb248Pz4gY29sbGVjdGlvbiwgaW50IGFycmF5TGVuZ3RoKSB7Ci0JCWludFtdIGluZGljZXMgPSBuZXcgaW50W2FycmF5TGVuZ3RoXTsKLQkJaW50IGogPSAwOwotCQlmb3IgKGludCBpID0gMDsgaSA8IGFycmF5TGVuZ3RoOyBpKyspIHsKLQkJCWlmICggISBjb2xsZWN0aW9uLmNvbnRhaW5zKGFycmF5W2ldKSkgewotCQkJCWluZGljZXNbaisrXSA9IGk7Ci0JCQl9Ci0JCX0KLQkJaWYgKGogPT0gYXJyYXlMZW5ndGgpIHsKLQkJCXJldHVybiBhcnJheTsgIC8vIG5vdGhpbmcgd2FzIHJlbW92ZWQKLQkJfQotCQlFW10gcmVzdWx0ID0gbmV3QXJyYXkoYXJyYXksIGopOwotCQlpbnQgcmVzdWx0TGVuZ3RoID0gcmVzdWx0Lmxlbmd0aDsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCByZXN1bHRMZW5ndGg7IGkrKykgewotCQkJcmVzdWx0W2ldID0gYXJyYXlbaW5kaWNlc1tpXV07Ci0JCX0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgZnJvbSB0aGUgZmlyc3Qgc3BlY2lmaWVkIGFycmF5IGFsbCB0aGUgZWxlbWVudHMgaW4KLQkgKiB0aGUgc2Vjb25kIHNwZWNpZmllZCBhcnJheSBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogamF2YS51dGlsLkFycmF5cyNyZW1vdmVBbGwoT2JqZWN0W10gYXJyYXkxLCBPYmplY3RbXSBhcnJheTIpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gRVtdIHJlbW92ZUFsbChFW10gYXJyYXkxLCBPYmplY3RbXSBhcnJheTIpIHsKLQkJLy8gY29udmVydCB0byBhIGJhZyB0byB0YWtlIGFkdmFudGFnZSBvZiBoYXNoZWQgbG9vay11cAotCQlyZXR1cm4gKGFycmF5Mi5sZW5ndGggPT0gMCkgPyBhcnJheTEgOiByZW1vdmVBbGxfKGFycmF5MSwgc2V0KGFycmF5MikpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBmcm9tIHRoZSBmaXJzdCBzcGVjaWZpZWQgYXJyYXkgYWxsIHRoZSBlbGVtZW50cyBpbgotCSAqIHRoZSBzZWNvbmQgc3BlY2lmaWVkIGFycmF5IGFuZCByZXR1cm4gdGhlIHJlc3VsdC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI3JlbW92ZUFsbChjaGFyW10gYXJyYXkxLCBjaGFyW10gYXJyYXkyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIHJlbW92ZUFsbChjaGFyW10gYXJyYXkxLCBjaGFyW10gYXJyYXkyKSB7Ci0JCWlmIChhcnJheTIubGVuZ3RoID09IDApIHsKLQkJCXJldHVybiBhcnJheTE7Ci0JCX0KLQkJaW50IGFycmF5MUxlbmd0aCA9IGFycmF5MS5sZW5ndGg7Ci0JCWlmIChhcnJheTFMZW5ndGggPT0gMCkgewotCQkJcmV0dXJuIGFycmF5MTsKLQkJfQotCQlpbnRbXSBpbmRpY2VzID0gbmV3IGludFthcnJheTFMZW5ndGhdOwotCQlpbnQgaiA9IDA7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgYXJyYXkxTGVuZ3RoOyBpKyspIHsKLQkJCWlmICggISBjb250YWlucyhhcnJheTIsIGFycmF5MVtpXSkpIHsKLQkJCQlpbmRpY2VzW2orK10gPSBpOwotCQkJfQotCQl9Ci0JCWlmIChqID09IGFycmF5MUxlbmd0aCkgewotCQkJcmV0dXJuIGFycmF5MTsgIC8vIG5vdGhpbmcgd2FzIHJlbW92ZWQKLQkJfQotCQljaGFyW10gcmVzdWx0ID0gbmV3IGNoYXJbal07Ci0JCWludCByZXN1bHRMZW5ndGggPSByZXN1bHQubGVuZ3RoOwotCQlmb3IgKGludCBpID0gMDsgaSA8IHJlc3VsdExlbmd0aDsgaSsrKSB7Ci0JCQlyZXN1bHRbaV0gPSBhcnJheTFbaW5kaWNlc1tpXV07Ci0JCX0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgZnJvbSB0aGUgZmlyc3Qgc3BlY2lmaWVkIGFycmF5IGFsbCB0aGUgZWxlbWVudHMgaW4KLQkgKiB0aGUgc2Vjb25kIHNwZWNpZmllZCBhcnJheSBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogamF2YS51dGlsLkFycmF5cyNyZW1vdmVBbGwoaW50W10gYXJyYXkxLCBpbnRbXSBhcnJheTIpCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnRbXSByZW1vdmVBbGwoaW50W10gYXJyYXkxLCBpbnRbXSBhcnJheTIpIHsKLQkJaWYgKGFycmF5Mi5sZW5ndGggPT0gMCkgewotCQkJcmV0dXJuIGFycmF5MTsKLQkJfQotCQlpbnQgYXJyYXkxTGVuZ3RoID0gYXJyYXkxLmxlbmd0aDsKLQkJaWYgKGFycmF5MUxlbmd0aCA9PSAwKSB7Ci0JCQlyZXR1cm4gYXJyYXkxOwotCQl9Ci0JCWludFtdIGluZGljZXMgPSBuZXcgaW50W2FycmF5MUxlbmd0aF07Ci0JCWludCBqID0gMDsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBhcnJheTFMZW5ndGg7IGkrKykgewotCQkJaWYgKCAhIGNvbnRhaW5zKGFycmF5MiwgYXJyYXkxW2ldKSkgewotCQkJCWluZGljZXNbaisrXSA9IGk7Ci0JCQl9Ci0JCX0KLQkJaWYgKGogPT0gYXJyYXkxTGVuZ3RoKSB7Ci0JCQlyZXR1cm4gYXJyYXkxOyAgLy8gbm90aGluZyB3YXMgcmVtb3ZlZAotCQl9Ci0JCWludFtdIHJlc3VsdCA9IG5ldyBpbnRbal07Ci0JCWludCByZXN1bHRMZW5ndGggPSByZXN1bHQubGVuZ3RoOwotCQlmb3IgKGludCBpID0gMDsgaSA8IHJlc3VsdExlbmd0aDsgaSsrKSB7Ci0JCQlyZXN1bHRbaV0gPSBhcnJheTFbaW5kaWNlc1tpXV07Ci0JCX0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYWxsIG9jY3VycmVuY2VzIG9mIHRoZSBzcGVjaWZpZWQgZWxlbWVudAotCSAqIGZyb20gdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjb2xsZWN0aW9uIGNoYW5nZWQgYXMgYSByZXN1bHQuCi0JICogamF2YS51dGlsLkNvbGxlY3Rpb24jcmVtb3ZlQWxsT2NjdXJyZW5jZXMoT2JqZWN0IHZhbHVlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiByZW1vdmVBbGxPY2N1cnJlbmNlcyhDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIE9iamVjdCB2YWx1ZSkgewotCQlib29sZWFuIG1vZGlmaWVkID0gZmFsc2U7Ci0JCUl0ZXJhdG9yPD8+IHN0cmVhbSA9IGNvbGxlY3Rpb24uaXRlcmF0b3IoKTsKLQkJaWYgKHZhbHVlID09IG51bGwpIHsKLQkJCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQkJaWYgKHN0cmVhbS5uZXh0KCkgPT0gbnVsbCkgewotCQkJCQlzdHJlYW0ucmVtb3ZlKCk7Ci0JCQkJCW1vZGlmaWVkID0gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0gZWxzZSB7Ci0JCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJCWlmICh2YWx1ZS5lcXVhbHMoc3RyZWFtLm5leHQoKSkpIHsKLQkJCQkJc3RyZWFtLnJlbW92ZSgpOwotCQkJCQltb2RpZmllZCA9IHRydWU7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCXJldHVybiBtb2RpZmllZDsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgZnJvbSB0aGUgc3BlY2lmaWVkIGFycmF5IGFsbCBvY2N1cnJlbmNlcyBvZgotCSAqIHRoZSBzcGVjaWZpZWQgZWxlbWVudCBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogamF2YS51dGlsLkFycmF5cyNyZW1vdmVBbGxPY2N1cnJlbmNlcyhPYmplY3RbXSBhcnJheSwgT2JqZWN0IHZhbHVlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSByZW1vdmVBbGxPY2N1cnJlbmNlcyhFW10gYXJyYXksIE9iamVjdCB2YWx1ZSkgewotCQlpbnQgYXJyYXlMZW5ndGggPSBhcnJheS5sZW5ndGg7Ci0JCWlmIChhcnJheUxlbmd0aCA9PSAwKSB7Ci0JCQlyZXR1cm4gYXJyYXk7Ci0JCX0KLQkJaW50W10gaW5kaWNlcyA9IG5ldyBpbnRbYXJyYXlMZW5ndGhdOwotCQlpbnQgaiA9IDA7Ci0JCWlmICh2YWx1ZSA9PSBudWxsKSB7Ci0JCQlmb3IgKGludCBpID0gYXJyYXlMZW5ndGg7IGktLSA+IDA7ICkgewotCQkJCWlmIChhcnJheVtpXSAhPSBudWxsKSB7Ci0JCQkJCWluZGljZXNbaisrXSA9IGk7Ci0JCQkJfQotCQkJfQotCQl9IGVsc2UgewotCQkJZm9yIChpbnQgaSA9IGFycmF5Lmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQkJaWYgKCAhIHZhbHVlLmVxdWFscyhhcnJheVtpXSkpIHsKLQkJCQkJaW5kaWNlc1tqKytdID0gaTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGogPT0gYXJyYXlMZW5ndGgpIHsKLQkJCXJldHVybiBhcnJheTsgIC8vIG5vdGhpbmcgd2FzIHJlbW92ZWQKLQkJfQotCQlFW10gcmVzdWx0ID0gbmV3QXJyYXkoYXJyYXksIGopOwotCQlpbnQgcmVzdWx0TGVuZ3RoID0gcmVzdWx0Lmxlbmd0aDsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCByZXN1bHRMZW5ndGg7IGkrKykgewotCQkJcmVzdWx0W2ldID0gYXJyYXlbaW5kaWNlc1tpXV07Ci0JCX0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgZnJvbSB0aGUgc3BlY2lmaWVkIGFycmF5IGFsbCBvY2N1cnJlbmNlcyBvZgotCSAqIHRoZSBzcGVjaWZpZWQgZWxlbWVudCBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogamF2YS51dGlsLkFycmF5cyNyZW1vdmVBbGxPY2N1cnJlbmNlcyhjaGFyW10gYXJyYXksIGNoYXIgdmFsdWUpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gcmVtb3ZlQWxsT2NjdXJyZW5jZXMoY2hhcltdIGFycmF5LCBjaGFyIHZhbHVlKSB7Ci0JCWludCBhcnJheUxlbmd0aCA9IGFycmF5Lmxlbmd0aDsKLQkJaWYgKGFycmF5TGVuZ3RoID09IDApIHsKLQkJCXJldHVybiBhcnJheTsKLQkJfQotCQlpbnRbXSBpbmRpY2VzID0gbmV3IGludFthcnJheUxlbmd0aF07Ci0JCWludCBqID0gMDsKLQkJZm9yIChpbnQgaSA9IGFycmF5TGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCWlmIChhcnJheVtpXSAhPSB2YWx1ZSkgewotCQkJCWluZGljZXNbaisrXSA9IGk7Ci0JCQl9Ci0JCX0KLQkJaWYgKGogPT0gYXJyYXlMZW5ndGgpIHsKLQkJCXJldHVybiBhcnJheTsgIC8vIG5vdGhpbmcgd2FzIHJlbW92ZWQKLQkJfQotCQljaGFyW10gcmVzdWx0ID0gbmV3IGNoYXJbal07Ci0JCWludCByZXN1bHRMZW5ndGggPSByZXN1bHQubGVuZ3RoOwotCQlmb3IgKGludCBpID0gMDsgaSA8IHJlc3VsdExlbmd0aDsgaSsrKSB7Ci0JCQlyZXN1bHRbaV0gPSBhcnJheVtpbmRpY2VzW2ldXTsKLQkJfQotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBmcm9tIHRoZSBzcGVjaWZpZWQgYXJyYXkgYWxsIG9jY3VycmVuY2VzIG9mCi0JICogdGhlIHNwZWNpZmllZCBlbGVtZW50IGFuZCByZXR1cm4gdGhlIHJlc3VsdC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI3JlbW92ZUFsbE9jY3VycmVuY2VzKGludFtdIGFycmF5LCBpbnQgdmFsdWUpCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnRbXSByZW1vdmVBbGxPY2N1cnJlbmNlcyhpbnRbXSBhcnJheSwgaW50IHZhbHVlKSB7Ci0JCWludCBhcnJheUxlbmd0aCA9IGFycmF5Lmxlbmd0aDsKLQkJaWYgKGFycmF5TGVuZ3RoID09IDApIHsKLQkJCXJldHVybiBhcnJheTsKLQkJfQotCQlpbnRbXSBpbmRpY2VzID0gbmV3IGludFthcnJheUxlbmd0aF07Ci0JCWludCBqID0gMDsKLQkJZm9yIChpbnQgaSA9IGFycmF5TGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCWlmIChhcnJheVtpXSAhPSB2YWx1ZSkgewotCQkJCWluZGljZXNbaisrXSA9IGk7Ci0JCQl9Ci0JCX0KLQkJaWYgKGogPT0gYXJyYXlMZW5ndGgpIHsKLQkJCXJldHVybiBhcnJheTsgIC8vIG5vdGhpbmcgd2FzIHJlbW92ZWQKLQkJfQotCQlpbnRbXSByZXN1bHQgPSBuZXcgaW50W2pdOwotCQlpbnQgcmVzdWx0TGVuZ3RoID0gcmVzdWx0Lmxlbmd0aDsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCByZXN1bHRMZW5ndGg7IGkrKykgewotCQkJcmVzdWx0W2ldID0gYXJyYXlbaW5kaWNlc1tpXV07Ci0JCX0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgYXJyYXkgdGhhdCBjb250YWlucyB0aGUgZWxlbWVudHMgaW4gdGhlCi0JICogc3BlY2lmaWVkIGFycmF5IHdpdGggdGhlIHNwZWNpZmllZCBlbGVtZW50IHJlbW92ZWQuCi0JICogamF2YS51dGlsLkFycmF5cyNyZW1vdmVFbGVtZW50QXRJbmRleChPYmplY3RbXSBhcnJheSwgaW50IGluZGV4KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSByZW1vdmVFbGVtZW50QXRJbmRleChFW10gYXJyYXksIGludCBpbmRleCkgewotCQlyZXR1cm4gcmVtb3ZlRWxlbWVudHNBdEluZGV4KGFycmF5LCBpbmRleCwgMSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgbmV3IGFycmF5IHRoYXQgY29udGFpbnMgdGhlIGVsZW1lbnRzIGluIHRoZQotCSAqIHNwZWNpZmllZCBhcnJheSB3aXRoIHRoZSBzcGVjaWZpZWQgZWxlbWVudCByZW1vdmVkLgotCSAqIGphdmEudXRpbC5BcnJheXMjcmVtb3ZlRWxlbWVudEF0SW5kZXgoY2hhcltdIGFycmF5LCBpbnQgaW5kZXgpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gcmVtb3ZlRWxlbWVudEF0SW5kZXgoY2hhcltdIGFycmF5LCBpbnQgaW5kZXgpIHsKLQkJcmV0dXJuIHJlbW92ZUVsZW1lbnRzQXRJbmRleChhcnJheSwgaW5kZXgsIDEpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBhcnJheSB0aGF0IGNvbnRhaW5zIHRoZSBlbGVtZW50cyBpbiB0aGUKLQkgKiBzcGVjaWZpZWQgYXJyYXkgd2l0aCB0aGUgc3BlY2lmaWVkIGVsZW1lbnQgcmVtb3ZlZC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI3JlbW92ZUVsZW1lbnRBdEluZGV4KGludFtdIGFycmF5LCBpbnQgaW5kZXgpCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnRbXSByZW1vdmVFbGVtZW50QXRJbmRleChpbnRbXSBhcnJheSwgaW50IGluZGV4KSB7Ci0JCXJldHVybiByZW1vdmVFbGVtZW50c0F0SW5kZXgoYXJyYXksIGluZGV4LCAxKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgdGhlIGVsZW1lbnRzIGF0IHRoZSBzcGVjaWZpZWQgaW5kZXguCi0JICogUmV0dXJuIHRoZSByZW1vdmVkIGVsZW1lbnRzLgotCSAqIGphdmEudXRpbC5MaXN0I3JlbW92ZShpbnQgaW5kZXgsIGludCBsZW5ndGgpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gQXJyYXlMaXN0PEU+IHJlbW92ZUVsZW1lbnRzQXRJbmRleChMaXN0PEU+IGxpc3QsIGludCBpbmRleCwgaW50IGxlbmd0aCkgewotCQlMaXN0PEU+IHN1Ykxpc3QgPSBsaXN0LnN1Ykxpc3QoaW5kZXgsIGluZGV4ICsgbGVuZ3RoKTsKLQkJQXJyYXlMaXN0PEU+IHJlc3VsdCA9IG5ldyBBcnJheUxpc3Q8RT4oc3ViTGlzdCk7Ci0JCXN1Ykxpc3QuY2xlYXIoKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgYXJyYXkgdGhhdCBjb250YWlucyB0aGUgZWxlbWVudHMgaW4gdGhlCi0JICogc3BlY2lmaWVkIGFycmF5IHdpdGggdGhlIHNwZWNpZmllZCBlbGVtZW50cyByZW1vdmVkLgotCSAqIGphdmEudXRpbC5BcnJheXMjcmVtb3ZlRWxlbWVudHNBdEluZGV4KE9iamVjdFtdIGFycmF5LCBpbnQgaW5kZXgsIGludCBsZW5ndGgpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gRVtdIHJlbW92ZUVsZW1lbnRzQXRJbmRleChFW10gYXJyYXksIGludCBpbmRleCwgaW50IGxlbmd0aCkgewotCQlpbnQgYXJyYXlMZW5ndGggPSBhcnJheS5sZW5ndGg7Ci0JCWludCBuZXdMZW5ndGggPSBhcnJheUxlbmd0aCAtIGxlbmd0aDsKLQkJRVtdIHJlc3VsdCA9IG5ld0FycmF5KGFycmF5LCBuZXdMZW5ndGgpOwotCQlpZiAoKG5ld0xlbmd0aCA9PSAwKSAmJiAoaW5kZXggPT0gMCkpIHsKLQkJCXJldHVybiByZXN1bHQ7ICAvLyBwZXJmb3JtYW5jZSB0d2VhawotCQl9Ci0JCVN5c3RlbS5hcnJheWNvcHkoYXJyYXksIDAsIHJlc3VsdCwgMCwgaW5kZXgpOwotCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCBpbmRleCArIGxlbmd0aCwgcmVzdWx0LCBpbmRleCwgbmV3TGVuZ3RoIC0gaW5kZXgpOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBhcnJheSB0aGF0IGNvbnRhaW5zIHRoZSBlbGVtZW50cyBpbiB0aGUKLQkgKiBzcGVjaWZpZWQgYXJyYXkgd2l0aCB0aGUgc3BlY2lmaWVkIGVsZW1lbnRzIHJlbW92ZWQuCi0JICogamF2YS51dGlsLkFycmF5cyNyZW1vdmVFbGVtZW50QXRJbmRleChjaGFyW10gYXJyYXksIGludCBpbmRleCwgaW50IGxlbmd0aCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXJbXSByZW1vdmVFbGVtZW50c0F0SW5kZXgoY2hhcltdIGFycmF5LCBpbnQgaW5kZXgsIGludCBsZW5ndGgpIHsKLQkJaW50IGFycmF5TGVuZ3RoID0gYXJyYXkubGVuZ3RoOwotCQlpbnQgbmV3TGVuZ3RoID0gYXJyYXlMZW5ndGggLSBsZW5ndGg7Ci0JCWlmICgobmV3TGVuZ3RoID09IDApICYmIChpbmRleCA9PSAwKSkgewotCQkJcmV0dXJuIEVNUFRZX0NIQVJfQVJSQVk7ICAvLyBwZXJmb3JtYW5jZSB0d2VhawotCQl9Ci0JCWNoYXJbXSByZXN1bHQgPSBuZXcgY2hhcltuZXdMZW5ndGhdOwotCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCAwLCByZXN1bHQsIDAsIGluZGV4KTsKLQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgaW5kZXggKyBsZW5ndGgsIHJlc3VsdCwgaW5kZXgsIG5ld0xlbmd0aCAtIGluZGV4KTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgY2hhcltdIEVNUFRZX0NIQVJfQVJSQVkgPSBuZXcgY2hhclswXTsKLQotCS8qKgotCSAqIFJldHVybiBhIG5ldyBhcnJheSB0aGF0IGNvbnRhaW5zIHRoZSBlbGVtZW50cyBpbiB0aGUKLQkgKiBzcGVjaWZpZWQgYXJyYXkgd2l0aCB0aGUgc3BlY2lmaWVkIGVsZW1lbnRzIHJlbW92ZWQuCi0JICogamF2YS51dGlsLkFycmF5cyNyZW1vdmVFbGVtZW50QXRJbmRleChpbnRbXSBhcnJheSwgaW50IGluZGV4LCBpbnQgbGVuZ3RoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50W10gcmVtb3ZlRWxlbWVudHNBdEluZGV4KGludFtdIGFycmF5LCBpbnQgaW5kZXgsIGludCBsZW5ndGgpIHsKLQkJaW50IGFycmF5TGVuZ3RoID0gYXJyYXkubGVuZ3RoOwotCQlpbnQgbmV3TGVuZ3RoID0gYXJyYXlMZW5ndGggLSBsZW5ndGg7Ci0JCWlmICgobmV3TGVuZ3RoID09IDApICYmIChpbmRleCA9PSAwKSkgewotCQkJcmV0dXJuIEVNUFRZX0lOVF9BUlJBWTsgIC8vIHBlcmZvcm1hbmNlIHR3ZWFrCi0JCX0KLQkJaW50W10gcmVzdWx0ID0gbmV3IGludFtuZXdMZW5ndGhdOwotCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCAwLCByZXN1bHQsIDAsIGluZGV4KTsKLQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgaW5kZXggKyBsZW5ndGgsIHJlc3VsdCwgaW5kZXgsIG5ld0xlbmd0aCAtIGluZGV4KTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgaW50W10gRU1QVFlfSU5UX0FSUkFZID0gbmV3IGludFswXTsKLQotCS8qKgotCSAqIFJlbW92ZSBhbnkgZHVwbGljYXRlIGVsZW1lbnRzIGZyb20gdGhlIHNwZWNpZmllZCBhcnJheSwKLQkgKiB3aGlsZSBtYWludGFpbmluZyB0aGUgb3JkZXIuCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gRVtdIHJlbW92ZUR1cGxpY2F0ZUVsZW1lbnRzKEUuLi4gYXJyYXkpIHsKLQkJaW50IGxlbiA9IGFycmF5Lmxlbmd0aDsKLQkJaWYgKChsZW4gPT0gMCkgfHwgKGxlbiA9PSAxKSkgewotCQkJcmV0dXJuIGFycmF5OwotCQl9Ci0JCUFycmF5TGlzdDxFPiB0ZW1wID0gbGlzdChhcnJheSk7Ci0JCXJldHVybiByZW1vdmVEdXBsaWNhdGVFbGVtZW50cyh0ZW1wLCBsZW4pID8KLQkJCQkJdGVtcC50b0FycmF5KG5ld0FycmF5KGFycmF5LCB0ZW1wLnNpemUoKSkpCi0JCQkJOgotCQkJCQlhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYW55IGR1cGxpY2F0ZSBlbGVtZW50cyBmcm9tIHRoZSBzcGVjaWZpZWQgbGlzdCwKLQkgKiB3aGlsZSBtYWludGFpbmluZyB0aGUgb3JkZXIuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGxpc3QgY2hhbmdlZCBhcyBhIHJlc3VsdC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBib29sZWFuIHJlbW92ZUR1cGxpY2F0ZUVsZW1lbnRzKExpc3Q8RT4gbGlzdCkgewotCQlpbnQgc2l6ZSA9IGxpc3Quc2l6ZSgpOwotCQlpZiAoKHNpemUgPT0gMCkgfHwgKHNpemUgPT0gMSkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlyZXR1cm4gcmVtb3ZlRHVwbGljYXRlRWxlbWVudHMobGlzdCwgc2l6ZSk7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIGxpc3QgaXMgbm9uLWVtcHR5Ci0JICovCi0JcHJpdmF0ZSBzdGF0aWMgPEU+IGJvb2xlYW4gcmVtb3ZlRHVwbGljYXRlRWxlbWVudHMoTGlzdDxFPiBsaXN0LCBpbnQgc2l6ZSkgewotCQlMaW5rZWRIYXNoU2V0PEU+IHRlbXAgPSBuZXcgTGlua2VkSGFzaFNldDxFPihzaXplKTsJCS8vIHRha2UgYWR2YW50YWdlIG9mIGhhc2hlZCBsb29rLXVwCi0JCWJvb2xlYW4gY2hhbmdlZCA9IGZhbHNlOwotCQlmb3IgKEUgaXRlbSA6IGxpc3QpIHsKLQkJCWlmICggISB0ZW1wLmFkZChpdGVtKSkgewotCQkJCWNoYW5nZWQgPSB0cnVlOyAgLy8gZHVwbGljYXRlIGl0ZW0KLQkJCX0KLQkJfQotCQlpZiAoY2hhbmdlZCkgewotCQkJaW50IGkgPSAwOwotCQkJZm9yIChJdGVyYXRvcjxFPiBzdHJlYW0gPSB0ZW1wLml0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJCWxpc3Quc2V0KGksIHN0cmVhbS5uZXh0KCkpOwotCQkJCWkrKzsKLQkJCX0KLQkJCWludCB0ZW1wU2l6ZSA9IHRlbXAuc2l6ZSgpOwotCQkJZm9yIChpID0gbGlzdC5zaXplKCk7IGktLSA+IHRlbXBTaXplOyApIHsKLQkJCQlsaXN0LnJlbW92ZShpKTsgIC8vIHB1bGwgb2ZmIHRoZSBlbmQKLQkJCX0KLQkJfQotCQlyZXR1cm4gY2hhbmdlZDsKLQl9Ci0KLQkvKioKLQkgKiBSZXRhaW4gb25seSB0aGUgZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZCBpdGVyYWJsZQotCSAqIGluIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbi4KLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgY29sbGVjdGlvbiBjaGFuZ2VkIGFzIGEgcmVzdWx0LgotCSAqIGphdmEudXRpbC5Db2xsZWN0aW9uI3JldGFpbkFsbChqYXZhLmxhbmcuSXRlcmFibGUgaXRlcmFibGUpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIHJldGFpbkFsbChDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIEl0ZXJhYmxlPD8+IGl0ZXJhYmxlKSB7Ci0JCXJldHVybiByZXRhaW5BbGwoY29sbGVjdGlvbiwgaXRlcmFibGUuaXRlcmF0b3IoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0YWluIG9ubHkgdGhlIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQgaXRlcmFibGUKLQkgKiBpbiB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24uCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGNvbGxlY3Rpb24gY2hhbmdlZCBhcyBhIHJlc3VsdC4KLQkgKiBqYXZhLnV0aWwuQ29sbGVjdGlvbiNyZXRhaW5BbGwoamF2YS5sYW5nLkl0ZXJhYmxlIGl0ZXJhYmxlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiByZXRhaW5BbGwoQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uLCBJdGVyYWJsZTw/PiBpdGVyYWJsZSwgaW50IHNpemUpIHsKLQkJcmV0dXJuIHJldGFpbkFsbChjb2xsZWN0aW9uLCBpdGVyYWJsZS5pdGVyYXRvcigpLCBzaXplKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXRhaW4gb25seSB0aGUgZWxlbWVudHMgaW4gdGhlIHNwZWNpZmllZCBpdGVyYXRvcgotCSAqIGluIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbi4KLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgY29sbGVjdGlvbiBjaGFuZ2VkIGFzIGEgcmVzdWx0LgotCSAqIGphdmEudXRpbC5Db2xsZWN0aW9uI3JldGFpbkFsbChqYXZhLnV0aWwuSXRlcmF0b3IgaXRlcmF0b3IpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIHJldGFpbkFsbChDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIEl0ZXJhdG9yPD8+IGl0ZXJhdG9yKSB7Ci0JCWlmIChpdGVyYXRvci5oYXNOZXh0KCkpIHsKLQkJCXJldHVybiBjb2xsZWN0aW9uLnJldGFpbkFsbChzZXQoaXRlcmF0b3IpKTsKLQkJfQotCQlpZiAoY29sbGVjdGlvbi5pc0VtcHR5KCkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQljb2xsZWN0aW9uLmNsZWFyKCk7Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCS8qKgotCSAqIFJldGFpbiBvbmx5IHRoZSBlbGVtZW50cyBpbiB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9yCi0JICogaW4gdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjb2xsZWN0aW9uIGNoYW5nZWQgYXMgYSByZXN1bHQuCi0JICogamF2YS51dGlsLkNvbGxlY3Rpb24jcmV0YWluQWxsKGphdmEudXRpbC5JdGVyYXRvciBpdGVyYXRvcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gcmV0YWluQWxsKENvbGxlY3Rpb248Pz4gY29sbGVjdGlvbiwgSXRlcmF0b3I8Pz4gaXRlcmF0b3IsIGludCBzaXplKSB7Ci0JCWlmIChpdGVyYXRvci5oYXNOZXh0KCkpIHsKLQkJCXJldHVybiBjb2xsZWN0aW9uLnJldGFpbkFsbChzZXQoaXRlcmF0b3IsIHNpemUpKTsKLQkJfQotCQlpZiAoY29sbGVjdGlvbi5pc0VtcHR5KCkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQljb2xsZWN0aW9uLmNsZWFyKCk7Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCS8qKgotCSAqIFJldGFpbiBvbmx5IHRoZSBlbGVtZW50cyBpbiB0aGUgc3BlY2lmaWVkIGFycmF5Ci0JICogaW4gdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjb2xsZWN0aW9uIGNoYW5nZWQgYXMgYSByZXN1bHQuCi0JICogamF2YS51dGlsLkNvbGxlY3Rpb24jcmV0YWluQWxsKE9iamVjdFtdIGFycmF5KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiByZXRhaW5BbGwoQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uLCBPYmplY3RbXSBhcnJheSkgewotCQlpZiAoYXJyYXkubGVuZ3RoID4gMCkgewotCQkJcmV0dXJuIGNvbGxlY3Rpb24ucmV0YWluQWxsKHNldChhcnJheSkpOwotCQl9Ci0JCWlmIChjb2xsZWN0aW9uLmlzRW1wdHkoKSkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCWNvbGxlY3Rpb24uY2xlYXIoKTsKLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JLyoqCi0JICogUmV0YWluIGluIHRoZSBzcGVjaWZpZWQgYXJyYXkgYWxsIHRoZSBlbGVtZW50cyBpbgotCSAqIHRoZSBzcGVjaWZpZWQgaXRlcmFibGUgYW5kIHJldHVybiB0aGUgcmVzdWx0LgotCSAqIGphdmEudXRpbC5BcnJheXMjcmV0YWluQWxsKE9iamVjdFtdIGFycmF5LCBJdGVyYWJsZSBpdGVyYWJsZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gcmV0YWluQWxsKEVbXSBhcnJheSwgSXRlcmFibGU8Pz4gaXRlcmFibGUpIHsKLQkJaW50IGFycmF5TGVuZ3RoID0gYXJyYXkubGVuZ3RoOwotCQlyZXR1cm4gKGFycmF5TGVuZ3RoID09IDApID8gYXJyYXkgOiByZXRhaW5BbGwoYXJyYXksIGFycmF5TGVuZ3RoLCBpdGVyYWJsZS5pdGVyYXRvcigpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXRhaW4gaW4gdGhlIHNwZWNpZmllZCBhcnJheSBhbGwgdGhlIGVsZW1lbnRzIGluCi0JICogdGhlIHNwZWNpZmllZCBpdGVyYWJsZSBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogamF2YS51dGlsLkFycmF5cyNyZXRhaW5BbGwoT2JqZWN0W10gYXJyYXksIEl0ZXJhYmxlIGl0ZXJhYmxlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSByZXRhaW5BbGwoRVtdIGFycmF5LCBJdGVyYWJsZTw/PiBpdGVyYWJsZSwgaW50IHNpemUpIHsKLQkJaW50IGFycmF5TGVuZ3RoID0gYXJyYXkubGVuZ3RoOwotCQlyZXR1cm4gKGFycmF5TGVuZ3RoID09IDApID8gYXJyYXkgOiByZXRhaW5BbGwoYXJyYXksIGFycmF5TGVuZ3RoLCBpdGVyYWJsZS5pdGVyYXRvcigpLCBzaXplKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXRhaW4gaW4gdGhlIHNwZWNpZmllZCBhcnJheSBhbGwgdGhlIGVsZW1lbnRzIGluCi0JICogdGhlIHNwZWNpZmllZCBpdGVyYXRvciBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogamF2YS51dGlsLkFycmF5cyNyZXRhaW5BbGwoT2JqZWN0W10gYXJyYXksIEl0ZXJhdG9yIGl0ZXJhdG9yKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSByZXRhaW5BbGwoRVtdIGFycmF5LCBJdGVyYXRvcjw/PiBpdGVyYXRvcikgewotCQlpbnQgYXJyYXlMZW5ndGggPSBhcnJheS5sZW5ndGg7Ci0JCXJldHVybiAoYXJyYXlMZW5ndGggPT0gMCkgPyBhcnJheSA6IHJldGFpbkFsbChhcnJheSwgYXJyYXlMZW5ndGgsIGl0ZXJhdG9yKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXRhaW4gaW4gdGhlIHNwZWNpZmllZCBhcnJheSBhbGwgdGhlIGVsZW1lbnRzIGluCi0JICogdGhlIHNwZWNpZmllZCBpdGVyYXRvciBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogamF2YS51dGlsLkFycmF5cyNyZXRhaW5BbGwoT2JqZWN0W10gYXJyYXksIEl0ZXJhdG9yIGl0ZXJhdG9yKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSByZXRhaW5BbGwoRVtdIGFycmF5LCBJdGVyYXRvcjw/PiBpdGVyYXRvciwgaW50IHNpemUpIHsKLQkJaW50IGFycmF5TGVuZ3RoID0gYXJyYXkubGVuZ3RoOwotCQlyZXR1cm4gKGFycmF5TGVuZ3RoID09IDApID8gYXJyYXkgOiByZXRhaW5BbGwoYXJyYXksIGFycmF5TGVuZ3RoLCBpdGVyYXRvciwgc2l6ZSk7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIGFycmF5TGVuZ3RoID4gMAotCSAqLwotCXByaXZhdGUgc3RhdGljIDxFPiBFW10gcmV0YWluQWxsKEVbXSBhcnJheSwgaW50IGFycmF5TGVuZ3RoLCBJdGVyYXRvcjw/PiBpdGVyYXRvcikgewotCQlyZXR1cm4gKGl0ZXJhdG9yLmhhc05leHQoKSkgPwotCQkJCXJldGFpbkFsbF8oYXJyYXksIHNldChpdGVyYXRvciksIGFycmF5TGVuZ3RoKQotCQkJOgotCQkJCW5ld0FycmF5KGFycmF5LCAwKTsKLQl9Ci0KLQkvKioKLQkgKiBhc3N1bWUgYXJyYXlMZW5ndGggPiAwCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgPEU+IEVbXSByZXRhaW5BbGwoRVtdIGFycmF5LCBpbnQgYXJyYXlMZW5ndGgsIEl0ZXJhdG9yPD8+IGl0ZXJhdG9yLCBpbnQgaXRlcmF0b3JTaXplKSB7Ci0JCXJldHVybiAoaXRlcmF0b3IuaGFzTmV4dCgpKSA/Ci0JCQkJcmV0YWluQWxsXyhhcnJheSwgc2V0KGl0ZXJhdG9yLCBpdGVyYXRvclNpemUpLCBhcnJheUxlbmd0aCkKLQkJCToKLQkJCQluZXdBcnJheShhcnJheSwgMCk7Ci0JfQotCi0JLyoqCi0JICogUmV0YWluIGluIHRoZSBzcGVjaWZpZWQgYXJyYXkgYWxsIHRoZSBlbGVtZW50cyBpbgotCSAqIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbiBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogamF2YS51dGlsLkFycmF5cyNyZXRhaW5BbGwoT2JqZWN0W10gYXJyYXksIENvbGxlY3Rpb24gY29sbGVjdGlvbikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gcmV0YWluQWxsKEVbXSBhcnJheSwgQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uKSB7Ci0JCWludCBhcnJheUxlbmd0aCA9IGFycmF5Lmxlbmd0aDsKLQkJcmV0dXJuIChhcnJheUxlbmd0aCA9PSAwKSA/IGFycmF5IDogcmV0YWluQWxsKGFycmF5LCBjb2xsZWN0aW9uLCBhcnJheUxlbmd0aCk7Ci0JfQotCi0JLyoqCi0JICogYXNzdW1lIGFycmF5TGVuZ3RoID4gMAotCSAqLwotCXByaXZhdGUgc3RhdGljIDxFPiBFW10gcmV0YWluQWxsKEVbXSBhcnJheSwgQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uLCBpbnQgYXJyYXlMZW5ndGgpIHsKLQkJcmV0dXJuIChjb2xsZWN0aW9uLmlzRW1wdHkoKSkgPwotCQkJCW5ld0FycmF5KGFycmF5LCAwKQotCQkJOgotCQkJCXJldGFpbkFsbF8oYXJyYXksIGNvbGxlY3Rpb24sIGFycmF5TGVuZ3RoKTsKLQl9Ci0KLQkvKioKLQkgKiBhc3N1bWUgY29sbGVjdGlvbiBpcyBub24tZW1wdHkgYW5kIGFycmF5TGVuZ3RoID4gMAotCSAqLwotCXByaXZhdGUgc3RhdGljIDxFPiBFW10gcmV0YWluQWxsXyhFW10gYXJyYXksIENvbGxlY3Rpb248Pz4gY29sbGVjdGlvbiwgaW50IGFycmF5TGVuZ3RoKSB7Ci0JCWludFtdIGluZGljZXMgPSBuZXcgaW50W2FycmF5TGVuZ3RoXTsKLQkJaW50IGogPSAwOwotCQlmb3IgKGludCBpID0gMDsgaSA8IGFycmF5TGVuZ3RoOyBpKyspIHsKLQkJCWlmIChjb2xsZWN0aW9uLmNvbnRhaW5zKGFycmF5W2ldKSkgewotCQkJCWluZGljZXNbaisrXSA9IGk7Ci0JCQl9Ci0JCX0KLQkJaWYgKGogPT0gYXJyYXlMZW5ndGgpIHsKLQkJCXJldHVybiBhcnJheTsgIC8vIGV2ZXJ5dGhpbmcgd2FzIHJldGFpbmVkCi0JCX0KLQkJRVtdIHJlc3VsdCA9IG5ld0FycmF5KGFycmF5LCBqKTsKLQkJaW50IHJlc3VsdExlbmd0aCA9IHJlc3VsdC5sZW5ndGg7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgcmVzdWx0TGVuZ3RoOyBpKyspIHsKLQkJCXJlc3VsdFtpXSA9IGFycmF5W2luZGljZXNbaV1dOwotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGZyb20gdGhlIGZpcnN0IHNwZWNpZmllZCBhcnJheSBhbGwgdGhlIGVsZW1lbnRzIGluCi0JICogdGhlIHNlY29uZCBzcGVjaWZpZWQgYXJyYXkgYW5kIHJldHVybiB0aGUgcmVzdWx0LgotCSAqIGphdmEudXRpbC5BcnJheXMjcmV0YWluQWxsKE9iamVjdFtdIGFycmF5MSwgT2JqZWN0W10gYXJyYXkyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSByZXRhaW5BbGwoRVtdIGFycmF5MSwgT2JqZWN0W10gYXJyYXkyKSB7Ci0JCWludCBhcnJheTFMZW5ndGggPSBhcnJheTEubGVuZ3RoOwotCQlyZXR1cm4gKGFycmF5Mi5sZW5ndGggPT0gMCkgPwotCQkJCShhcnJheTFMZW5ndGggPT0gMCkgPyBhcnJheTEgOiBuZXdBcnJheShhcnJheTEsIDApCi0JCQk6Ci0JCQkJcmV0YWluQWxsKGFycmF5MSwgc2V0KGFycmF5MiksIGFycmF5MUxlbmd0aCk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGZyb20gdGhlIGZpcnN0IHNwZWNpZmllZCBhcnJheSBhbGwgdGhlIGVsZW1lbnRzIGluCi0JICogdGhlIHNlY29uZCBzcGVjaWZpZWQgYXJyYXkgYW5kIHJldHVybiB0aGUgcmVzdWx0LgotCSAqIGphdmEudXRpbC5BcnJheXMjcmV0YWluQWxsKGNoYXJbXSBhcnJheTEsIGNoYXJbXSBhcnJheTIpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gcmV0YWluQWxsKGNoYXJbXSBhcnJheTEsIGNoYXJbXSBhcnJheTIpIHsKLQkJaW50IGFycmF5MUxlbmd0aCA9IGFycmF5MS5sZW5ndGg7Ci0JCXJldHVybiAoYXJyYXkxTGVuZ3RoID09IDApID8gYXJyYXkxIDogcmV0YWluQWxsKGFycmF5MSwgYXJyYXkyLCBhcnJheTFMZW5ndGgpOwotCX0KLQotCS8qKgotCSAqIGFzc3VtZSBhcnJheTFMZW5ndGggPiAwCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgY2hhcltdIHJldGFpbkFsbChjaGFyW10gYXJyYXkxLCBjaGFyW10gYXJyYXkyLCBpbnQgYXJyYXkxTGVuZ3RoKSB7Ci0JCWludCBhcnJheTJMZW5ndGggPSBhcnJheTIubGVuZ3RoOwotCQlyZXR1cm4gKGFycmF5Mkxlbmd0aCA9PSAwKSA/IEVNUFRZX0NIQVJfQVJSQVkgOiByZXRhaW5BbGwoYXJyYXkxLCBhcnJheTIsIGFycmF5MUxlbmd0aCwgYXJyYXkyTGVuZ3RoKTsKLQl9Ci0KLQkvKioKLQkgKiBhc3N1bWUgYXJyYXkxTGVuZ3RoID4gMCBhbmQgYXJyYXkyTGVuZ3RoID4gMAotCSAqLwotCXByaXZhdGUgc3RhdGljIGNoYXJbXSByZXRhaW5BbGwoY2hhcltdIGFycmF5MSwgY2hhcltdIGFycmF5MiwgaW50IGFycmF5MUxlbmd0aCwgaW50IGFycmF5Mkxlbmd0aCkgewotCQlpbnRbXSBpbmRpY2VzID0gbmV3IGludFthcnJheTFMZW5ndGhdOwotCQlpbnQgaiA9IDA7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgYXJyYXkxTGVuZ3RoOyBpKyspIHsKLQkJCWlmIChjb250YWlucyhhcnJheTIsIGFycmF5MVtpXSwgYXJyYXkyTGVuZ3RoKSkgewotCQkJCWluZGljZXNbaisrXSA9IGk7Ci0JCQl9Ci0JCX0KLQkJaWYgKGogPT0gYXJyYXkxTGVuZ3RoKSB7Ci0JCQlyZXR1cm4gYXJyYXkxOyAgLy8gZXZlcnl0aGluZyB3YXMgcmV0YWluZWQKLQkJfQotCQljaGFyW10gcmVzdWx0ID0gbmV3IGNoYXJbal07Ci0JCWludCByZXN1bHRMZW5ndGggPSByZXN1bHQubGVuZ3RoOwotCQlmb3IgKGludCBpID0gMDsgaSA8IHJlc3VsdExlbmd0aDsgaSsrKSB7Ci0JCQlyZXN1bHRbaV0gPSBhcnJheTFbaW5kaWNlc1tpXV07Ci0JCX0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgZnJvbSB0aGUgZmlyc3Qgc3BlY2lmaWVkIGFycmF5IGFsbCB0aGUgZWxlbWVudHMgaW4KLQkgKiB0aGUgc2Vjb25kIHNwZWNpZmllZCBhcnJheSBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogamF2YS51dGlsLkFycmF5cyNyZXRhaW5BbGwoaW50W10gYXJyYXkxLCBpbnRbXSBhcnJheTIpCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnRbXSByZXRhaW5BbGwoaW50W10gYXJyYXkxLCBpbnRbXSBhcnJheTIpIHsKLQkJaW50IGFycmF5MUxlbmd0aCA9IGFycmF5MS5sZW5ndGg7Ci0JCXJldHVybiAoYXJyYXkxTGVuZ3RoID09IDApID8gYXJyYXkxIDogcmV0YWluQWxsKGFycmF5MSwgYXJyYXkyLCBhcnJheTFMZW5ndGgpOwotCX0KLQotCS8qKgotCSAqIGFzc3VtZSBhcnJheTFMZW5ndGggPiAwCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgaW50W10gcmV0YWluQWxsKGludFtdIGFycmF5MSwgaW50W10gYXJyYXkyLCBpbnQgYXJyYXkxTGVuZ3RoKSB7Ci0JCWludCBhcnJheTJMZW5ndGggPSBhcnJheTIubGVuZ3RoOwotCQlyZXR1cm4gKGFycmF5Mkxlbmd0aCA9PSAwKSA/IEVNUFRZX0lOVF9BUlJBWSA6IHJldGFpbkFsbChhcnJheTEsIGFycmF5MiwgYXJyYXkxTGVuZ3RoLCBhcnJheTJMZW5ndGgpOwotCX0KLQotCS8qKgotCSAqIGFzc3VtZSBhcnJheTFMZW5ndGggPiAwIGFuZCBhcnJheTJMZW5ndGggPiAwCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgaW50W10gcmV0YWluQWxsKGludFtdIGFycmF5MSwgaW50W10gYXJyYXkyLCBpbnQgYXJyYXkxTGVuZ3RoLCBpbnQgYXJyYXkyTGVuZ3RoKSB7Ci0JCWludFtdIGluZGljZXMgPSBuZXcgaW50W2FycmF5MUxlbmd0aF07Ci0JCWludCBqID0gMDsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBhcnJheTFMZW5ndGg7IGkrKykgewotCQkJaWYgKGNvbnRhaW5zKGFycmF5MiwgYXJyYXkxW2ldLCBhcnJheTJMZW5ndGgpKSB7Ci0JCQkJaW5kaWNlc1tqKytdID0gaTsKLQkJCX0KLQkJfQotCQlpZiAoaiA9PSBhcnJheTFMZW5ndGgpIHsKLQkJCXJldHVybiBhcnJheTE7ICAvLyBldmVyeXRoaW5nIHdhcyByZXRhaW5lZAotCQl9Ci0JCWludFtdIHJlc3VsdCA9IG5ldyBpbnRbal07Ci0JCWludCByZXN1bHRMZW5ndGggPSByZXN1bHQubGVuZ3RoOwotCQlmb3IgKGludCBpID0gMDsgaSA8IHJlc3VsdExlbmd0aDsgaSsrKSB7Ci0JCQlyZXN1bHRbaV0gPSBhcnJheTFbaW5kaWNlc1tpXV07Ci0JCX0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFycmF5IHJldmVyc2VkLgotCSAqIGphdmEudXRpbC5BcnJheXMucmV2ZXJzZShPYmplY3RbXSBhcnJheSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gcmV2ZXJzZShFLi4uIGFycmF5KSB7Ci0JCWludCBsZW4gPSBhcnJheS5sZW5ndGg7Ci0JCWZvciAoaW50IGkgPSAwLCBtaWQgPSBsZW4gPj4gMSwgaiA9IGxlbiAtIDE7IGkgPCBtaWQ7IGkrKywgai0tKSB7Ci0JCQlzd2FwKGFycmF5LCBpLCBqKTsKLQkJfQotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSByZXZlcnNlZC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzLnJldmVyc2UoY2hhcltdIGFycmF5KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIHJldmVyc2UoY2hhci4uLiBhcnJheSkgewotCQlpbnQgbGVuID0gYXJyYXkubGVuZ3RoOwotCQlmb3IgKGludCBpID0gMCwgbWlkID0gbGVuID4+IDEsIGogPSBsZW4gLSAxOyBpIDwgbWlkOyBpKyssIGotLSkgewotCQkJc3dhcChhcnJheSwgaSwgaik7Ci0JCX0KLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgcmV2ZXJzZWQuCi0JICogamF2YS51dGlsLkFycmF5cy5yZXZlcnNlKGludFtdIGFycmF5KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50W10gcmV2ZXJzZShpbnQuLi4gYXJyYXkpIHsKLQkJaW50IGxlbiA9IGFycmF5Lmxlbmd0aDsKLQkJZm9yIChpbnQgaSA9IDAsIG1pZCA9IGxlbiA+PiAxLCBqID0gbGVuIC0gMTsgaSA8IG1pZDsgaSsrLCBqLS0pIHsKLQkJCXN3YXAoYXJyYXksIGksIGopOwotCQl9Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBsaXN0IHdpdGggZW50cmllcyBpbiByZXZlcnNlIG9yZGVyIGZyb20gdGhvc2UKLQkgKiByZXR1cm5lZCBieSB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IExpc3Q8RT4gcmV2ZXJzZUxpc3QoSXRlcmFibGU8PyBleHRlbmRzIEU+IGl0ZXJhYmxlKSB7Ci0JCXJldHVybiByZXZlcnNlKGxpc3QoaXRlcmFibGUpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBsaXN0IHdpdGggZW50cmllcyBpbiByZXZlcnNlIG9yZGVyIGZyb20gdGhvc2UKLQkgKiByZXR1cm5lZCBieSB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IExpc3Q8RT4gcmV2ZXJzZUxpc3QoSXRlcmFibGU8PyBleHRlbmRzIEU+IGl0ZXJhYmxlLCBpbnQgc2l6ZSkgewotCQlyZXR1cm4gcmV2ZXJzZShsaXN0KGl0ZXJhYmxlLCBzaXplKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgbGlzdCB3aXRoIGVudHJpZXMgaW4gcmV2ZXJzZSBvcmRlciBmcm9tIHRob3NlCi0JICogcmV0dXJuZWQgYnkgdGhlIHNwZWNpZmllZCBpdGVyYXRvci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBMaXN0PEU+IHJldmVyc2VMaXN0KEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVyYXRvcikgewotCQlyZXR1cm4gcmV2ZXJzZShsaXN0KGl0ZXJhdG9yKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgbGlzdCB3aXRoIGVudHJpZXMgaW4gcmV2ZXJzZSBvcmRlciBmcm9tIHRob3NlCi0JICogcmV0dXJuZWQgYnkgdGhlIHNwZWNpZmllZCBpdGVyYXRvci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBMaXN0PEU+IHJldmVyc2VMaXN0KEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVyYXRvciwgaW50IHNpemUpIHsKLQkJcmV0dXJuIHJldmVyc2UobGlzdChpdGVyYXRvciwgc2l6ZSkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgcm90YXRlZCBhcnJheSBhZnRlciByb3RhdGluZyBpdCBvbmUgcG9zaXRpb24uCi0JICogamF2YS51dGlsLkFycmF5cy5yb3RhdGUoT2JqZWN0W10gYXJyYXkpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gRVtdIHJvdGF0ZShFLi4uIGFycmF5KSB7Ci0JCXJldHVybiByb3RhdGUoYXJyYXksIDEpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgcm90YXRlZCBhcnJheSBhZnRlciByb3RhdGluZyBpdCB0aGUgc3BlY2lmaWVkIGRpc3RhbmNlLgotCSAqIGphdmEudXRpbC5BcnJheXMucm90YXRlKE9iamVjdFtdIGFycmF5LCBpbnQgZGlzdGFuY2UpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gRVtdIHJvdGF0ZShFW10gYXJyYXksIGludCBkaXN0YW5jZSkgewotCQlpbnQgbGVuID0gYXJyYXkubGVuZ3RoOwotCQlpZiAoKGxlbiA9PSAwKSB8fCAobGVuID09IDEpKSB7Ci0JCQlyZXR1cm4gYXJyYXk7Ci0JCX0KLQkJZGlzdGFuY2UgPSBkaXN0YW5jZSAlIGxlbjsKLQkJaWYgKGRpc3RhbmNlIDwgMCkgewotCQkJZGlzdGFuY2UgKz0gbGVuOwotCQl9Ci0JCWlmIChkaXN0YW5jZSA9PSAwKSB7Ci0JCQlyZXR1cm4gYXJyYXk7Ci0JCX0KLQkJZm9yIChpbnQgY3ljbGVTdGFydCA9IDAsIG5Nb3ZlZCA9IDA7IG5Nb3ZlZCAhPSBsZW47IGN5Y2xlU3RhcnQrKykgewotCQkJRSBkaXNwbGFjZWQgPSBhcnJheVtjeWNsZVN0YXJ0XTsKLQkJCWludCBpID0gY3ljbGVTdGFydDsKLQkJCWRvIHsKLQkJCQlpICs9IGRpc3RhbmNlOwotCQkJCWlmIChpID49IGxlbikgewotCQkJCQlpIC09IGxlbjsKLQkJCQl9Ci0JCQkJRSB0ZW1wID0gYXJyYXlbaV07Ci0JCQkJYXJyYXlbaV0gPSBkaXNwbGFjZWQ7Ci0JCQkJZGlzcGxhY2VkID0gdGVtcDsKLQkJCQluTW92ZWQgKys7Ci0JCQl9IHdoaWxlIChpICE9IGN5Y2xlU3RhcnQpOwotCQl9Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHJvdGF0ZWQgYXJyYXkgYWZ0ZXIgcm90YXRpbmcgaXQgb25lIHBvc2l0aW9uLgotCSAqIGphdmEudXRpbC5BcnJheXMucm90YXRlKGNoYXJbXSBhcnJheSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXJbXSByb3RhdGUoY2hhci4uLiBhcnJheSkgewotCQlyZXR1cm4gcm90YXRlKGFycmF5LCAxKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHJvdGF0ZWQgYXJyYXkgYWZ0ZXIgcm90YXRpbmcgaXQgdGhlIHNwZWNpZmllZCBkaXN0YW5jZS4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzLnJvdGF0ZShjaGFyW10gYXJyYXksIGludCBkaXN0YW5jZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXJbXSByb3RhdGUoY2hhcltdIGFycmF5LCBpbnQgZGlzdGFuY2UpIHsKLQkJaW50IGxlbiA9IGFycmF5Lmxlbmd0aDsKLQkJaWYgKChsZW4gPT0gMCkgfHwgKGxlbiA9PSAxKSkgewotCQkJcmV0dXJuIGFycmF5OwotCQl9Ci0JCWRpc3RhbmNlID0gZGlzdGFuY2UgJSBsZW47Ci0JCWlmIChkaXN0YW5jZSA8IDApIHsKLQkJCWRpc3RhbmNlICs9IGxlbjsKLQkJfQotCQlpZiAoZGlzdGFuY2UgPT0gMCkgewotCQkJcmV0dXJuIGFycmF5OwotCQl9Ci0JCWZvciAoaW50IGN5Y2xlU3RhcnQgPSAwLCBuTW92ZWQgPSAwOyBuTW92ZWQgIT0gbGVuOyBjeWNsZVN0YXJ0KyspIHsKLQkJCWNoYXIgZGlzcGxhY2VkID0gYXJyYXlbY3ljbGVTdGFydF07Ci0JCQlpbnQgaSA9IGN5Y2xlU3RhcnQ7Ci0JCQlkbyB7Ci0JCQkJaSArPSBkaXN0YW5jZTsKLQkJCQlpZiAoaSA+PSBsZW4pIHsKLQkJCQkJaSAtPSBsZW47Ci0JCQkJfQotCQkJCWNoYXIgdGVtcCA9IGFycmF5W2ldOwotCQkJCWFycmF5W2ldID0gZGlzcGxhY2VkOwotCQkJCWRpc3BsYWNlZCA9IHRlbXA7Ci0JCQkJbk1vdmVkICsrOwotCQkJfSB3aGlsZSAoaSAhPSBjeWNsZVN0YXJ0KTsKLQkJfQotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSByb3RhdGVkIGFycmF5IGFmdGVyIHJvdGF0aW5nIGl0IG9uZSBwb3NpdGlvbi4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzLnJvdGF0ZShpbnRbXSBhcnJheSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludFtdIHJvdGF0ZShpbnQuLi4gYXJyYXkpIHsKLQkJcmV0dXJuIHJvdGF0ZShhcnJheSwgMSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSByb3RhdGVkIGFycmF5IGFmdGVyIHJvdGF0aW5nIGl0IHRoZSBzcGVjaWZpZWQgZGlzdGFuY2UuCi0JICogamF2YS51dGlsLkFycmF5cy5yb3RhdGUoaW50W10gYXJyYXksIGludCBkaXN0YW5jZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludFtdIHJvdGF0ZShpbnRbXSBhcnJheSwgaW50IGRpc3RhbmNlKSB7Ci0JCWludCBsZW4gPSBhcnJheS5sZW5ndGg7Ci0JCWlmICgobGVuID09IDApIHx8IChsZW4gPT0gMSkpIHsKLQkJCXJldHVybiBhcnJheTsKLQkJfQotCQlkaXN0YW5jZSA9IGRpc3RhbmNlICUgbGVuOwotCQlpZiAoZGlzdGFuY2UgPCAwKSB7Ci0JCQlkaXN0YW5jZSArPSBsZW47Ci0JCX0KLQkJaWYgKGRpc3RhbmNlID09IDApIHsKLQkJCXJldHVybiBhcnJheTsKLQkJfQotCQlmb3IgKGludCBjeWNsZVN0YXJ0ID0gMCwgbk1vdmVkID0gMDsgbk1vdmVkICE9IGxlbjsgY3ljbGVTdGFydCsrKSB7Ci0JCQlpbnQgZGlzcGxhY2VkID0gYXJyYXlbY3ljbGVTdGFydF07Ci0JCQlpbnQgaSA9IGN5Y2xlU3RhcnQ7Ci0JCQlkbyB7Ci0JCQkJaSArPSBkaXN0YW5jZTsKLQkJCQlpZiAoaSA+PSBsZW4pIHsKLQkJCQkJaSAtPSBsZW47Ci0JCQkJfQotCQkJCWludCB0ZW1wID0gYXJyYXlbaV07Ci0JCQkJYXJyYXlbaV0gPSBkaXNwbGFjZWQ7Ci0JCQkJZGlzcGxhY2VkID0gdGVtcDsKLQkJCQluTW92ZWQgKys7Ci0JCQl9IHdoaWxlIChpICE9IGN5Y2xlU3RhcnQpOwotCQl9Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBzZXQgY29ycmVzcG9uZGluZyB0byB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlLgotCSAqIGphdmEudXRpbC5IYXNoU2V0KGphdmEubGFuZy5JdGVyYWJsZSBpdGVyYWJsZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBIYXNoU2V0PEU+IHNldChJdGVyYWJsZTw/IGV4dGVuZHMgRT4gaXRlcmFibGUpIHsKLQkJcmV0dXJuIHNldChpdGVyYWJsZS5pdGVyYXRvcigpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBzZXQgY29ycmVzcG9uZGluZyB0byB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlLgotCSAqIGphdmEudXRpbC5IYXNoU2V0KGphdmEubGFuZy5JdGVyYWJsZSBpdGVyYWJsZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBIYXNoU2V0PEU+IHNldChJdGVyYWJsZTw/IGV4dGVuZHMgRT4gaXRlcmFibGUsIGludCBzaXplKSB7Ci0JCXJldHVybiBzZXQoaXRlcmFibGUuaXRlcmF0b3IoKSwgc2l6ZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgc2V0IGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBpdGVyYXRvci4KLQkgKiBqYXZhLnV0aWwuSGFzaFNldChqYXZhLnV0aWwuSXRlcmF0b3IgaXRlcmF0b3IpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gSGFzaFNldDxFPiBzZXQoSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yKSB7Ci0JCXJldHVybiBzZXQoaXRlcmF0b3IsIG5ldyBIYXNoU2V0PEU+KCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIHNldCBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICogamF2YS51dGlsLkhhc2hTZXQoamF2YS51dGlsLkl0ZXJhdG9yIGl0ZXJhdG9yKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEhhc2hTZXQ8RT4gc2V0KEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVyYXRvciwgaW50IHNpemUpIHsKLQkJcmV0dXJuIHNldChpdGVyYXRvciwgbmV3IEhhc2hTZXQ8RT4oc2l6ZSkpOwotCX0KLQotCXByaXZhdGUgc3RhdGljIDxFPiBIYXNoU2V0PEU+IHNldChJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IsIEhhc2hTZXQ8RT4gc2V0KSB7Ci0JCXdoaWxlIChpdGVyYXRvci5oYXNOZXh0KCkpIHsKLQkJCXNldC5hZGQoaXRlcmF0b3IubmV4dCgpKTsKLQkJfQotCQlyZXR1cm4gc2V0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIHNldCBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgYXJyYXkuCi0JICogamF2YS51dGlsLkhhc2hTZXQoT2JqZWN0W10gYXJyYXkpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gSGFzaFNldDxFPiBzZXQoRS4uLiBhcnJheSkgewotCQlIYXNoU2V0PEU+IHNldCA9IG5ldyBIYXNoU2V0PEU+KGFycmF5Lmxlbmd0aCk7Ci0JCWZvciAoRSBpdGVtIDogYXJyYXkpIHsKLQkJCXNldC5hZGQoaXRlbSk7Ci0JCX0KLQkJcmV0dXJuIHNldDsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBSYW5kb20gUkFORE9NID0gbmV3IFJhbmRvbSgpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciAic2h1ZmZsaW5nIiBpdC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI3NodWZmbGUoT2JqZWN0W10gYXJyYXkpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gRVtdIHNodWZmbGUoRS4uLiBhcnJheSkgewotCQlyZXR1cm4gc2h1ZmZsZShhcnJheSwgUkFORE9NKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFycmF5IGFmdGVyICJzaHVmZmxpbmciIGl0LgotCSAqIGphdmEudXRpbC5BcnJheXMjc2h1ZmZsZShPYmplY3RbXSBhcnJheSwgUmFuZG9tIHIpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gRVtdIHNodWZmbGUoRVtdIGFycmF5LCBSYW5kb20gcmFuZG9tKSB7Ci0JCWludCBsZW4gPSBhcnJheS5sZW5ndGg7Ci0JCWlmICgobGVuID09IDApIHx8IChsZW4gPT0gMSkpIHsKLQkJCXJldHVybiBhcnJheTsKLQkJfQotCQlmb3IgKGludCBpID0gbGVuOyBpLS0gPiAwOyApIHsKLQkJCXN3YXAoYXJyYXksIGksIHJhbmRvbS5uZXh0SW50KGxlbikpOwotCQl9Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFycmF5IGFmdGVyICJzaHVmZmxpbmciIGl0LgotCSAqIGphdmEudXRpbC5BcnJheXMjc2h1ZmZsZShjaGFyW10gYXJyYXkpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gc2h1ZmZsZShjaGFyLi4uIGFycmF5KSB7Ci0JCXJldHVybiBzaHVmZmxlKGFycmF5LCBSQU5ET00pOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgInNodWZmbGluZyIgaXQuCi0JICogamF2YS51dGlsLkFycmF5cyNzaHVmZmxlKGNoYXJbXSBhcnJheSwgUmFuZG9tIHIpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gc2h1ZmZsZShjaGFyW10gYXJyYXksIFJhbmRvbSByYW5kb20pIHsKLQkJaW50IGxlbiA9IGFycmF5Lmxlbmd0aDsKLQkJaWYgKChsZW4gPT0gMCkgfHwgKGxlbiA9PSAxKSkgewotCQkJcmV0dXJuIGFycmF5OwotCQl9Ci0JCWZvciAoaW50IGkgPSBsZW47IGktLSA+IDA7ICkgewotCQkJc3dhcChhcnJheSwgaSwgcmFuZG9tLm5leHRJbnQobGVuKSk7Ci0JCX0KLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgInNodWZmbGluZyIgaXQuCi0JICogamF2YS51dGlsLkFycmF5cyNzaHVmZmxlKGludFtdIGFycmF5KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50W10gc2h1ZmZsZShpbnQuLi4gYXJyYXkpIHsKLQkJcmV0dXJuIHNodWZmbGUoYXJyYXksIFJBTkRPTSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciAic2h1ZmZsaW5nIiBpdC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI3NodWZmbGUoaW50W10gYXJyYXksIFJhbmRvbSByKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50W10gc2h1ZmZsZShpbnRbXSBhcnJheSwgUmFuZG9tIHJhbmRvbSkgewotCQlpbnQgbGVuID0gYXJyYXkubGVuZ3RoOwotCQlpZiAoKGxlbiA9PSAwKSB8fCAobGVuID09IDEpKSB7Ci0JCQlyZXR1cm4gYXJyYXk7Ci0JCX0KLQkJZm9yIChpbnQgaSA9IGxlbjsgaS0tID4gMDsgKSB7Ci0JCQlzd2FwKGFycmF5LCBpLCByYW5kb20ubmV4dEludChsZW4pKTsKLQkJfQotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGFuIGl0ZXJhdG9yIHRoYXQgcmV0dXJucyBvbmx5IHRoZSBzaW5nbGUsCi0JICogc3BlY2lmaWVkIG9iamVjdC4KLQkgKiBPYmplY3QjdG9JdGVyYXRvcigpID8hCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gSXRlcmF0b3I8RT4gc2luZ2xldG9uSXRlcmF0b3IoRSB2YWx1ZSkgewotCQlyZXR1cm4gbmV3IFNpbmdsZUVsZW1lbnRJdGVyYXRvcjxFPih2YWx1ZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgbGlzdCBpdGVyYXRvciB0aGF0IHJldHVybnMgb25seSB0aGUgc2luZ2xlLAotCSAqIHNwZWNpZmllZCBvYmplY3QuCi0JICogT2JqZWN0I3RvSXRlcmF0b3IoKSA/IQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IExpc3RJdGVyYXRvcjxFPiBzaW5nbGV0b25MaXN0SXRlcmF0b3IoRSB2YWx1ZSkgewotCQlyZXR1cm4gbmV3IFNpbmdsZUVsZW1lbnRMaXN0SXRlcmF0b3I8RT4odmFsdWUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgbnVtYmVyIG9mIGVsZW1lbnRzIHJldHVybmVkIGJ5IHRoZSBzcGVjaWZpZWQgaXRlcmFibGUuCi0JICogamF2YS5sYW5nLkl0ZXJhYmxlI3NpemUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50IHNpemUoSXRlcmFibGU8Pz4gaXRlcmFibGUpIHsKLQkJcmV0dXJuIHNpemUoaXRlcmFibGUuaXRlcmF0b3IoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBudW1iZXIgb2YgZWxlbWVudHMgcmV0dXJuZWQgYnkgdGhlIHNwZWNpZmllZCBpdGVyYXRvci4KLQkgKiBqYXZhLnV0aWwuSXRlcmF0b3Ijc2l6ZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnQgc2l6ZShJdGVyYXRvcjw/PiBpdGVyYXRvcikgewotCQlpbnQgc2l6ZSA9IDA7Ci0JCXdoaWxlIChpdGVyYXRvci5oYXNOZXh0KCkpIHsKLQkJCWl0ZXJhdG9yLm5leHQoKTsKLQkJCXNpemUrKzsKLQkJfQotCQlyZXR1cm4gc2l6ZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBzb3J0ZWQgc2V0IGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBpdGVyYWJsZS4KLQkgKiBqYXZhLnV0aWwuVHJlZVNldChqYXZhLmxhbmcuSXRlcmFibGUgaXRlcmFibGUpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RSBleHRlbmRzIENvbXBhcmFibGU8PyBzdXBlciBFPj4gVHJlZVNldDxFPiBzb3J0ZWRTZXQoSXRlcmFibGU8PyBleHRlbmRzIEU+IGl0ZXJhYmxlKSB7Ci0JCXJldHVybiBzb3J0ZWRTZXQoaXRlcmFibGUsIG51bGwpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIHNvcnRlZCBzZXQgY29ycmVzcG9uZGluZyB0byB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlLgotCSAqIGphdmEudXRpbC5UcmVlU2V0KGphdmEubGFuZy5JdGVyYWJsZSBpdGVyYWJsZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFIGV4dGVuZHMgQ29tcGFyYWJsZTw/IHN1cGVyIEU+PiBUcmVlU2V0PEU+IHNvcnRlZFNldChJdGVyYWJsZTw/IGV4dGVuZHMgRT4gaXRlcmFibGUsIGludCBzaXplKSB7Ci0JCXJldHVybiBzb3J0ZWRTZXQoaXRlcmFibGUsIHNpemUsIG51bGwpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIHNvcnRlZCBzZXQgY29ycmVzcG9uZGluZyB0byB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlCi0JICogYW5kIGNvbXBhcmF0b3IuCi0JICogamF2YS51dGlsLlRyZWVTZXQoamF2YS5sYW5nLkl0ZXJhYmxlIGl0ZXJhYmxlLCBqYXZhLnV0aWwuQ29tcGFyYXRvciBjKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IFRyZWVTZXQ8RT4gc29ydGVkU2V0KEl0ZXJhYmxlPD8gZXh0ZW5kcyBFPiBpdGVyYWJsZSwgQ29tcGFyYXRvcjw/IHN1cGVyIEU+IGNvbXBhcmF0b3IpIHsKLQkJcmV0dXJuIHNvcnRlZFNldChpdGVyYWJsZS5pdGVyYXRvcigpLCBjb21wYXJhdG9yKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBzb3J0ZWQgc2V0IGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBpdGVyYWJsZQotCSAqIGFuZCBjb21wYXJhdG9yLgotCSAqIGphdmEudXRpbC5UcmVlU2V0KGphdmEubGFuZy5JdGVyYWJsZSBpdGVyYWJsZSwgamF2YS51dGlsLkNvbXBhcmF0b3IgYykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBUcmVlU2V0PEU+IHNvcnRlZFNldChJdGVyYWJsZTw/IGV4dGVuZHMgRT4gaXRlcmFibGUsIGludCBzaXplLCBDb21wYXJhdG9yPD8gc3VwZXIgRT4gY29tcGFyYXRvcikgewotCQlyZXR1cm4gc29ydGVkU2V0KGl0ZXJhYmxlLml0ZXJhdG9yKCksIHNpemUsIGNvbXBhcmF0b3IpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIHNvcnRlZCBzZXQgY29ycmVzcG9uZGluZyB0byB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9yLgotCSAqIGphdmEudXRpbC5UcmVlU2V0KGphdmEudXRpbC5JdGVyYXRvciBpdGVyYXRvcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFIGV4dGVuZHMgQ29tcGFyYWJsZTw/IHN1cGVyIEU+PiBUcmVlU2V0PEU+IHNvcnRlZFNldChJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IpIHsKLQkJcmV0dXJuIHNvcnRlZFNldChpdGVyYXRvciwgbnVsbCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgc29ydGVkIHNldCBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICogamF2YS51dGlsLlRyZWVTZXQoamF2YS51dGlsLkl0ZXJhdG9yIGl0ZXJhdG9yKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEUgZXh0ZW5kcyBDb21wYXJhYmxlPD8gc3VwZXIgRT4+IFRyZWVTZXQ8RT4gc29ydGVkU2V0KEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVyYXRvciwgaW50IHNpemUpIHsKLQkJcmV0dXJuIHNvcnRlZFNldChpdGVyYXRvciwgc2l6ZSwgbnVsbCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgc29ydGVkIHNldCBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IKLQkgKiBhbmQgY29tcGFyYXRvci4KLQkgKiBqYXZhLnV0aWwuVHJlZVNldChqYXZhLnV0aWwuSXRlcmF0b3IgaXRlcmF0b3IsIGphdmEudXRpbC5Db21wYXJhdG9yIGMpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gVHJlZVNldDxFPiBzb3J0ZWRTZXQoSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yLCBDb21wYXJhdG9yPD8gc3VwZXIgRT4gY29tcGFyYXRvcikgewotCQlyZXR1cm4gc29ydGVkU2V0KGxpc3QoaXRlcmF0b3IpLCBjb21wYXJhdG9yKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBzb3J0ZWQgc2V0IGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBpdGVyYXRvcgotCSAqIGFuZCBjb21wYXJhdG9yLgotCSAqIGphdmEudXRpbC5UcmVlU2V0KGphdmEudXRpbC5JdGVyYXRvciBpdGVyYXRvciwgamF2YS51dGlsLkNvbXBhcmF0b3IgYykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBUcmVlU2V0PEU+IHNvcnRlZFNldChJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IsIGludCBzaXplLCBDb21wYXJhdG9yPD8gc3VwZXIgRT4gY29tcGFyYXRvcikgewotCQlyZXR1cm4gc29ydGVkU2V0KGxpc3QoaXRlcmF0b3IsIHNpemUpLCBjb21wYXJhdG9yKTsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyA8RT4gVHJlZVNldDxFPiBzb3J0ZWRTZXQoTGlzdDxFPiBsaXN0LCBDb21wYXJhdG9yPD8gc3VwZXIgRT4gY29tcGFyYXRvcikgewotCQlUcmVlU2V0PEU+IHNvcnRlZFNldCA9IG5ldyBUcmVlU2V0PEU+KGNvbXBhcmF0b3IpOwotCQlzb3J0ZWRTZXQuYWRkQWxsKGxpc3QpOwotCQlyZXR1cm4gc29ydGVkU2V0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIHNvcnRlZCBzZXQgY29ycmVzcG9uZGluZyB0byB0aGUgc3BlY2lmaWVkIGFycmF5LgotCSAqIGphdmEudXRpbC5UcmVlU2V0KE9iamVjdFtdIGFycmF5KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEUgZXh0ZW5kcyBDb21wYXJhYmxlPD8gc3VwZXIgRT4+IFRyZWVTZXQ8RT4gc29ydGVkU2V0KEUuLi4gYXJyYXkpIHsKLQkJcmV0dXJuIHNvcnRlZFNldChhcnJheSwgbnVsbCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgc29ydGVkIHNldCBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgYXJyYXkKLQkgKiBhbmQgY29tcGFyYXRvci4KLQkgKiBqYXZhLnV0aWwuVHJlZVNldChPYmplY3RbXSBhcnJheSwgamF2YS51dGlsLkNvbXBhcmF0b3IgYykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBUcmVlU2V0PEU+IHNvcnRlZFNldChFW10gYXJyYXksIENvbXBhcmF0b3I8PyBzdXBlciBFPiBjb21wYXJhdG9yKSB7Ci0JCVRyZWVTZXQ8RT4gc29ydGVkU2V0ID0gbmV3IFRyZWVTZXQ8RT4oY29tcGFyYXRvcik7Ci0JCXNvcnRlZFNldC5hZGRBbGwoQXJyYXlzLmFzTGlzdChhcnJheSkpOwotCQlyZXR1cm4gc29ydGVkU2V0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIHN1Yi1hcnJheSBvZiB0aGUgc3BlY2lmaWVkIGFycmF5LCBzdGFydGluZyBhdCB0aGUgc3BlY2lmaWVkCi0JICogcG9zaXRpb24gd2l0aCB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI3N1YkFycmF5KEVbXSBhcnJheSwgaW50IHN0YXJ0LCBpbnQgbGVuZ3RoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSBzdWJBcnJheShFW10gYXJyYXksIGludCBzdGFydCwgaW50IGxlbmd0aCkgewotCQlFW10gcmVzdWx0ID0gbmV3QXJyYXkoYXJyYXksIGxlbmd0aCk7Ci0JCWlmIChsZW5ndGggPiAwKSB7Ci0JCQlTeXN0ZW0uYXJyYXljb3B5KGFycmF5LCBzdGFydCwgcmVzdWx0LCAwLCBsZW5ndGgpOwotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgc3ViLWFycmF5IG9mIHRoZSBzcGVjaWZpZWQgYXJyYXksIHN0YXJ0aW5nIGF0IHRoZSBzcGVjaWZpZWQKLQkgKiBwb3NpdGlvbiB3aXRoIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIGphdmEudXRpbC5BcnJheXMjc3ViQXJyYXkoaW50W10gYXJyYXksIGludCBzdGFydCwgaW50IGxlbmd0aCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludFtdIHN1YkFycmF5KGludFtdIGFycmF5LCBpbnQgc3RhcnQsIGludCBsZW5ndGgpIHsKLQkJaW50W10gcmVzdWx0ID0gbmV3IGludFtsZW5ndGhdOwotCQlpZiAobGVuZ3RoID4gMCkgewotCQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgc3RhcnQsIHJlc3VsdCwgMCwgbGVuZ3RoKTsKLQkJfQotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIHN1Yi1hcnJheSBvZiB0aGUgc3BlY2lmaWVkIGFycmF5LCBzdGFydGluZyBhdCB0aGUgc3BlY2lmaWVkCi0JICogcG9zaXRpb24gd2l0aCB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI3N1YkFycmF5KGNoYXJbXSBhcnJheSwgaW50IHN0YXJ0LCBpbnQgbGVuZ3RoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIHN1YkFycmF5KGNoYXJbXSBhcnJheSwgaW50IHN0YXJ0LCBpbnQgbGVuZ3RoKSB7Ci0JCWNoYXJbXSByZXN1bHQgPSBuZXcgY2hhcltsZW5ndGhdOwotCQlpZiAobGVuZ3RoID4gMCkgewotCQkJU3lzdGVtLmFycmF5Y29weShhcnJheSwgc3RhcnQsIHJlc3VsdCwgMCwgbGVuZ3RoKTsKLQkJfQotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgdGhlIHNwZWNpZmllZCBlbGVtZW50cyBoYXZlIGJlZW4gInN3YXBwZWQiLgotCSAqIGphdmEudXRpbC5BcnJheXMjc3dhcChPYmplY3RbXSBhcnJheSwgaW50IGksIGludCBqKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSBzd2FwKEVbXSBhcnJheSwgaW50IGksIGludCBqKSB7Ci0JCUUgdGVtcCA9IGFycmF5W2ldOwotCQlhcnJheVtpXSA9IGFycmF5W2pdOwotCQlhcnJheVtqXSA9IHRlbXA7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFycmF5IGFmdGVyIHRoZSBzcGVjaWZpZWQgZWxlbWVudHMgaGF2ZSBiZWVuICJzd2FwcGVkIi4KLQkgKiBqYXZhLnV0aWwuQXJyYXlzI3N3YXAoY2hhcltdIGFycmF5LCBpbnQgaSwgaW50IGopCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gc3dhcChjaGFyW10gYXJyYXksIGludCBpLCBpbnQgaikgewotCQljaGFyIHRlbXAgPSBhcnJheVtpXTsKLQkJYXJyYXlbaV0gPSBhcnJheVtqXTsKLQkJYXJyYXlbal0gPSB0ZW1wOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciB0aGUgc3BlY2lmaWVkIGVsZW1lbnRzIGhhdmUgYmVlbiAic3dhcHBlZCIuCi0JICogamF2YS51dGlsLkFycmF5cyNzd2FwKGludFtdIGFycmF5LCBpbnQgaSwgaW50IGopCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnRbXSBzd2FwKGludFtdIGFycmF5LCBpbnQgaSwgaW50IGopIHsKLQkJaW50IHRlbXAgPSBhcnJheVtpXTsKLQkJYXJyYXlbaV0gPSBhcnJheVtqXTsKLQkJYXJyYXlbal0gPSB0ZW1wOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgdmVjdG9yIGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBpdGVyYWJsZS4KLQkgKiBUaGlzIGlzIHVzZWZ1bCBmb3IgbGVnYWN5IGNvZGUgdGhhdCByZXF1aXJlcyBhIGphdmEudXRpbC5WZWN0b3IuCi0JICogamF2YS51dGlsLlZlY3RvcihqYXZhLmxhbmcuSXRlcmFibGUgaXRlcmFibGUpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gVmVjdG9yPEU+IHZlY3RvcihJdGVyYWJsZTw/IGV4dGVuZHMgRT4gaXRlcmFibGUpIHsKLQkJcmV0dXJuIHZlY3RvcihpdGVyYWJsZS5pdGVyYXRvcigpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSB2ZWN0b3IgY29ycmVzcG9uZGluZyB0byB0aGUgc3BlY2lmaWVkIGl0ZXJhYmxlLgotCSAqIFRoaXMgaXMgdXNlZnVsIGZvciBsZWdhY3kgY29kZSB0aGF0IHJlcXVpcmVzIGEgamF2YS51dGlsLlZlY3Rvci4KLQkgKiBqYXZhLnV0aWwuVmVjdG9yKGphdmEubGFuZy5JdGVyYWJsZSBpdGVyYWJsZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBWZWN0b3I8RT4gdmVjdG9yKEl0ZXJhYmxlPD8gZXh0ZW5kcyBFPiBpdGVyYWJsZSwgaW50IHNpemUpIHsKLQkJcmV0dXJuIHZlY3RvcihpdGVyYWJsZS5pdGVyYXRvcigpLCBzaXplKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSB2ZWN0b3IgY29ycmVzcG9uZGluZyB0byB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9yLgotCSAqIFRoaXMgaXMgdXNlZnVsIGZvciBsZWdhY3kgY29kZSB0aGF0IHJlcXVpcmVzIGEgamF2YS51dGlsLlZlY3Rvci4KLQkgKiBqYXZhLnV0aWwuVmVjdG9yKGphdmEudXRpbC5JdGVyYXRvciBpdGVyYXRvcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBWZWN0b3I8RT4gdmVjdG9yKEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVyYXRvcikgewotCQlyZXR1cm4gdmVjdG9yKGl0ZXJhdG9yLCBuZXcgVmVjdG9yPEU+KCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIHZlY3RvciBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICogVGhpcyBpcyB1c2VmdWwgZm9yIGxlZ2FjeSBjb2RlIHRoYXQgcmVxdWlyZXMgYSBqYXZhLnV0aWwuVmVjdG9yLgotCSAqIGphdmEudXRpbC5WZWN0b3IoamF2YS51dGlsLkl0ZXJhdG9yIGl0ZXJhdG9yKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IFZlY3RvcjxFPiB2ZWN0b3IoSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yLCBpbnQgc2l6ZSkgewotCQlyZXR1cm4gdmVjdG9yKGl0ZXJhdG9yLCBuZXcgVmVjdG9yPEU+KHNpemUpKTsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyA8RT4gVmVjdG9yPEU+IHZlY3RvcihJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IsIFZlY3RvcjxFPiB2KSB7Ci0JCXdoaWxlIChpdGVyYXRvci5oYXNOZXh0KCkpIHsKLQkJCXYuYWRkRWxlbWVudChpdGVyYXRvci5uZXh0KCkpOwotCQl9Ci0JCXJldHVybiB2OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIHZlY3RvciBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgYXJyYXkuCi0JICogVGhpcyBpcyB1c2VmdWwgZm9yIGxlZ2FjeSBjb2RlIHRoYXQgcmVxdWlyZXMgYSBqYXZhLnV0aWwuVmVjdG9yLgotCSAqIGphdmEudXRpbC5WZWN0b3IoT2JqZWN0W10gYXJyYXkpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gVmVjdG9yPEU+IHZlY3RvcihFLi4uIGFycmF5KSB7Ci0JCVZlY3RvcjxFPiB2ID0gbmV3IFZlY3RvcjxFPihhcnJheS5sZW5ndGgpOwotCQlmb3IgKEUgaXRlbSA6IGFycmF5KSB7Ci0JCQl2LmFkZEVsZW1lbnQoaXRlbSk7Ci0JCX0KLQkJcmV0dXJuIHY7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHNpbmdsZS11c2UgSXRlcmFibGUgKioqKioqKioqKgotCi0JLyoqCi0JICogVGhpcyBpcyBhIG9uZS10aW1lIHVzZSBpdGVyYWJsZSB0aGF0IGNhbiByZXR1cm4gYSBzaW5nbGUgaXRlcmF0b3IuCi0JICogT25jZSB0aGUgaXRlcmF0b3IgaXMgcmV0dXJuZWQgdGhlIGl0ZXJhYmxlIGlzIG5vIGxvbmdlciB2YWxpZC4KLQkgKiBBcyBzdWNoLCB0aGlzIHV0aWxpdHkgc2hvdWxkIG9ubHkgYmUgdXNlZCBpbiBvbmUtdGltZSB1c2Ugc2l0dWF0aW9ucywKLQkgKiBzdWNoIGFzIGEgJ2Zvci1lYWNoJyBsb29wLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2xhc3MgU2luZ2xlVXNlSXRlcmFibGU8RT4gaW1wbGVtZW50cyBJdGVyYWJsZTxFPiB7Ci0JCXByaXZhdGUgSXRlcmF0b3I8RT4gaXRlcmF0b3I7Ci0KLQkJcHVibGljIFNpbmdsZVVzZUl0ZXJhYmxlKEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVyYXRvcikgewotCQkJc3VwZXIoKTsKLQkJCWlmIChpdGVyYXRvciA9PSBudWxsKSB7Ci0JCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCQl9Ci0JCQl0aGlzLml0ZXJhdG9yID0gbmV3IEdlbmVyaWNJdGVyYXRvcldyYXBwZXI8RT4oaXRlcmF0b3IpOwotCQl9Ci0KLQkJcHVibGljIEl0ZXJhdG9yPEU+IGl0ZXJhdG9yKCkgewotCQkJaWYgKHRoaXMuaXRlcmF0b3IgPT0gbnVsbCkgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oIlRoaXMgbWV0aG9kIGhhcyBhbHJlYWR5IGJlZW4gY2FsbGVkLiIpOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCQlJdGVyYXRvcjxFPiByZXN1bHQgPSB0aGlzLml0ZXJhdG9yOwotCQkJdGhpcy5pdGVyYXRvciA9IG51bGw7Ci0JCQlyZXR1cm4gcmVzdWx0OwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gU3RyaW5nVG9vbHMuYnVpbGRUb1N0cmluZ0Zvcih0aGlzLCB0aGlzLml0ZXJhdG9yKTsKLQkJfQotCi0JfQotCi0KLQkvLyAqKioqKioqKioqIGphdmEudXRpbC5Db2xsZWN0aW9ucyBlbmhhbmNlbWVudHMgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBkZXN0aW5hdGlvbiBsaXN0IGFmdGVyIHRoZSBzb3VyY2UgbGlzdCBoYXMgYmVlbiBjb3BpZWQgaW50byBpdC4KLQkgKiBAc2VlIGphdmEudXRpbC5Db2xsZWN0aW9ucyNjb3B5KGphdmEudXRpbC5MaXN0LCBqYXZhLnV0aWwuTGlzdCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBMaXN0PD8gc3VwZXIgRT4gY29weShMaXN0PD8gc3VwZXIgRT4gZGVzdCwgTGlzdDw/IGV4dGVuZHMgRT4gc3JjKSB7Ci0JCUNvbGxlY3Rpb25zLmNvcHkoZGVzdCwgc3JjKTsKLQkJcmV0dXJuIGRlc3Q7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBsaXN0IGFmdGVyIGl0IGhhcyBiZWVuICJmaWxsZWQiLgotCSAqIEBzZWUgamF2YS51dGlsLkNvbGxlY3Rpb25zI2ZpbGwoamF2YS51dGlsLkxpc3QsIGphdmEubGFuZy5PYmplY3QpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gTGlzdDw/IHN1cGVyIEU+IGZpbGwoTGlzdDw/IHN1cGVyIEU+IGxpc3QsIEUgdmFsdWUpIHsKLQkJQ29sbGVjdGlvbnMuZmlsbChsaXN0LCB2YWx1ZSk7Ci0JCXJldHVybiBsaXN0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgbGlzdCBhZnRlciBpdCBoYXMgYmVlbiAicmV2ZXJzZWQiLgotCSAqIEBzZWUgamF2YS51dGlsLkNvbGxlY3Rpb25zI3JldmVyc2UoamF2YS51dGlsLkxpc3QpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gTGlzdDxFPiByZXZlcnNlKExpc3Q8RT4gbGlzdCkgewotCQlDb2xsZWN0aW9ucy5yZXZlcnNlKGxpc3QpOwotCQlyZXR1cm4gbGlzdDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGxpc3QgYWZ0ZXIgaXQgaGFzIGJlZW4gInJvdGF0ZWQiIGJ5IG9uZSBwb3NpdGlvbi4KLQkgKiBAc2VlIGphdmEudXRpbC5Db2xsZWN0aW9ucyNyb3RhdGUoamF2YS51dGlsLkxpc3QsIGludCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBMaXN0PEU+IHJvdGF0ZShMaXN0PEU+IGxpc3QpIHsKLQkJcmV0dXJuIHJvdGF0ZShsaXN0LCAxKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGxpc3QgYWZ0ZXIgaXQgaGFzIGJlZW4gInJvdGF0ZWQiLgotCSAqIEBzZWUgamF2YS51dGlsLkNvbGxlY3Rpb25zI3JvdGF0ZShqYXZhLnV0aWwuTGlzdCwgaW50KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IExpc3Q8RT4gcm90YXRlKExpc3Q8RT4gbGlzdCwgaW50IGRpc3RhbmNlKSB7Ci0JCUNvbGxlY3Rpb25zLnJvdGF0ZShsaXN0LCBkaXN0YW5jZSk7Ci0JCXJldHVybiBsaXN0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgbGlzdCBhZnRlciBpdCBoYXMgYmVlbiAic2h1ZmZsZWQiLgotCSAqIEBzZWUgamF2YS51dGlsLkNvbGxlY3Rpb25zI3NodWZmbGUoamF2YS51dGlsLkxpc3QpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gTGlzdDxFPiBzaHVmZmxlKExpc3Q8RT4gbGlzdCkgewotCQlDb2xsZWN0aW9ucy5zaHVmZmxlKGxpc3QpOwotCQlyZXR1cm4gbGlzdDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGxpc3QgYWZ0ZXIgaXQgaGFzIGJlZW4gInNodWZmbGVkIi4KLQkgKiBAc2VlIGphdmEudXRpbC5Db2xsZWN0aW9ucyNzaHVmZmxlKGphdmEudXRpbC5MaXN0LCBqYXZhLnV0aWwuUmFuZG9tKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IExpc3Q8RT4gc2h1ZmZsZShMaXN0PEU+IGxpc3QsIFJhbmRvbSByYW5kb20pIHsKLQkJQ29sbGVjdGlvbnMuc2h1ZmZsZShsaXN0LCByYW5kb20pOwotCQlyZXR1cm4gbGlzdDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGxpc3QgYWZ0ZXIgaXQgaGFzIGJlZW4gInNvcnRlZCIuCi0JICogTkI6IFRoZSBsaXN0IGlzIHNvcnRlZCBpbiBwbGFjZSBhcyBhIHNpZGUtZWZmZWN0LgotCSAqIEBzZWUgamF2YS51dGlsLkNvbGxlY3Rpb25zI3NvcnQoamF2YS51dGlsLkxpc3QpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RSBleHRlbmRzIENvbXBhcmFibGU8PyBzdXBlciBFPj4gTGlzdDxFPiBzb3J0KExpc3Q8RT4gbGlzdCkgewotCQlDb2xsZWN0aW9ucy5zb3J0KGxpc3QpOwotCQlyZXR1cm4gbGlzdDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGxpc3QgYWZ0ZXIgaXQgaGFzIGJlZW4gInNvcnRlZCIuCi0JICogTkI6IFRoZSBsaXN0IGlzIHNvcnRlZCBpbiBwbGFjZSBhcyBhIHNpZGUtZWZmZWN0LgotCSAqIEBzZWUgamF2YS51dGlsLkNvbGxlY3Rpb25zI3NvcnQoamF2YS51dGlsLkxpc3QsIGphdmEudXRpbC5Db21wYXJhdG9yKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IExpc3Q8RT4gc29ydChMaXN0PEU+IGxpc3QsIENvbXBhcmF0b3I8PyBzdXBlciBFPiBjb21wYXJhdG9yKSB7Ci0JCUNvbGxlY3Rpb25zLnNvcnQobGlzdCwgY29tcGFyYXRvcik7Ci0JCXJldHVybiBsaXN0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaXRlcmFibGUgYWZ0ZXIgaXQgaGFzIGJlZW4gInNvcnRlZCIuCi0JICovCi0JcHVibGljIHN0YXRpYyA8RSBleHRlbmRzIENvbXBhcmFibGU8PyBzdXBlciBFPj4gSXRlcmFibGU8RT4gc29ydChJdGVyYWJsZTxFPiBpdGVyYWJsZSkgewotCQlyZXR1cm4gc29ydChpdGVyYWJsZSwgbnVsbCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBpdGVyYWJsZSBhZnRlciBpdCBoYXMgYmVlbiAic29ydGVkIi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBJdGVyYWJsZTxFPiBzb3J0KEl0ZXJhYmxlPEU+IGl0ZXJhYmxlLCBDb21wYXJhdG9yPD8gc3VwZXIgRT4gY29tcGFyYXRvcikgewotCQlyZXR1cm4gc29ydChsaXN0KGl0ZXJhYmxlKSwgY29tcGFyYXRvcik7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBpdGVyYXRvciBhZnRlciBpdCBoYXMgYmVlbiAic29ydGVkIi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFIGV4dGVuZHMgQ29tcGFyYWJsZTw/IHN1cGVyIEU+PiBMaXN0SXRlcmF0b3I8RT4gc29ydChJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IpIHsKLQkJcmV0dXJuIHNvcnQoaXRlcmF0b3IsIG51bGwpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaXRlcmF0b3IgYWZ0ZXIgaXQgaGFzIGJlZW4gInNvcnRlZCIuCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gTGlzdEl0ZXJhdG9yPEU+IHNvcnQoSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yLCBDb21wYXJhdG9yPD8gc3VwZXIgRT4gY29tcGFyYXRvcikgewotCQlyZXR1cm4gc29ydChsaXN0KGl0ZXJhdG9yKSwgY29tcGFyYXRvcikubGlzdEl0ZXJhdG9yKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBsaXN0IGFmdGVyIHRoZSBzcGVjaWZpZWQgZWxlbWVudHMgaGF2ZSBiZWVuICJzd2FwcGVkIi4KLQkgKiBAc2VlIGphdmEudXRpbC5Db2xsZWN0aW9ucyNzd2FwKGphdmEudXRpbC5MaXN0LCBpbnQsIGludCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBMaXN0PEU+IHN3YXAoTGlzdDxFPiBsaXN0LCBpbnQgaSwgaW50IGopIHsKLQkJQ29sbGVjdGlvbnMuc3dhcChsaXN0LCBpLCBqKTsKLQkJcmV0dXJuIGxpc3Q7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGphdmEudXRpbC5BcnJheXMgZW5oYW5jZW1lbnRzICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gImZpbGxlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI2ZpbGwoYm9vbGVhbltdLCBib29sZWFuKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbltdIGZpbGwoYm9vbGVhbltdIGFycmF5LCBib29sZWFuIHZhbHVlKSB7Ci0JCUFycmF5cy5maWxsKGFycmF5LCB2YWx1ZSk7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFycmF5IGFmdGVyIGl0IGhhcyBiZWVuICJmaWxsZWQiLgotCSAqIEBzZWUgamF2YS51dGlsLkFycmF5cyNmaWxsKGJvb2xlYW5bXSwgaW50LCBpbnQsIGJvb2xlYW4pCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuW10gZmlsbChib29sZWFuW10gYXJyYXksIGludCBmcm9tSW5kZXgsIGludCB0b0luZGV4LCBib29sZWFuIHZhbHVlKSB7Ci0JCUFycmF5cy5maWxsKGFycmF5LCBmcm9tSW5kZXgsIHRvSW5kZXgsIHZhbHVlKTsKLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gImZpbGxlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI2ZpbGwoYnl0ZVtdLCBieXRlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYnl0ZVtdIGZpbGwoYnl0ZVtdIGFycmF5LCBieXRlIHZhbHVlKSB7Ci0JCUFycmF5cy5maWxsKGFycmF5LCB2YWx1ZSk7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFycmF5IGFmdGVyIGl0IGhhcyBiZWVuICJmaWxsZWQiLgotCSAqIEBzZWUgamF2YS51dGlsLkFycmF5cyNmaWxsKGJ5dGVbXSwgaW50LCBpbnQsIGJ5dGUpCi0JICovCi0JcHVibGljIHN0YXRpYyBieXRlW10gZmlsbChieXRlW10gYXJyYXksIGludCBmcm9tSW5kZXgsIGludCB0b0luZGV4LCBieXRlIHZhbHVlKSB7Ci0JCUFycmF5cy5maWxsKGFycmF5LCBmcm9tSW5kZXgsIHRvSW5kZXgsIHZhbHVlKTsKLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gImZpbGxlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI2ZpbGwoY2hhcltdLCBjaGFyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIGZpbGwoY2hhcltdIGFycmF5LCBjaGFyIHZhbHVlKSB7Ci0JCUFycmF5cy5maWxsKGFycmF5LCB2YWx1ZSk7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFycmF5IGFmdGVyIGl0IGhhcyBiZWVuICJmaWxsZWQiLgotCSAqIEBzZWUgamF2YS51dGlsLkFycmF5cyNmaWxsKGNoYXJbXSwgaW50LCBpbnQsIGNoYXIpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gZmlsbChjaGFyW10gYXJyYXksIGludCBmcm9tSW5kZXgsIGludCB0b0luZGV4LCBjaGFyIHZhbHVlKSB7Ci0JCUFycmF5cy5maWxsKGFycmF5LCBmcm9tSW5kZXgsIHRvSW5kZXgsIHZhbHVlKTsKLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gImZpbGxlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI2ZpbGwoZG91YmxlW10sIGRvdWJsZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGRvdWJsZVtdIGZpbGwoZG91YmxlW10gYXJyYXksIGRvdWJsZSB2YWx1ZSkgewotCQlBcnJheXMuZmlsbChhcnJheSwgdmFsdWUpOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciBpdCBoYXMgYmVlbiAiZmlsbGVkIi4KLQkgKiBAc2VlIGphdmEudXRpbC5BcnJheXMjZmlsbChkb3VibGVbXSwgaW50LCBpbnQsIGRvdWJsZSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGRvdWJsZVtdIGZpbGwoZG91YmxlW10gYXJyYXksIGludCBmcm9tSW5kZXgsIGludCB0b0luZGV4LCBkb3VibGUgdmFsdWUpIHsKLQkJQXJyYXlzLmZpbGwoYXJyYXksIGZyb21JbmRleCwgdG9JbmRleCwgdmFsdWUpOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciBpdCBoYXMgYmVlbiAiZmlsbGVkIi4KLQkgKiBAc2VlIGphdmEudXRpbC5BcnJheXMjZmlsbChmbG9hdFtdLCBmbG9hdCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGZsb2F0W10gZmlsbChmbG9hdFtdIGFycmF5LCBmbG9hdCB2YWx1ZSkgewotCQlBcnJheXMuZmlsbChhcnJheSwgdmFsdWUpOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciBpdCBoYXMgYmVlbiAiZmlsbGVkIi4KLQkgKiBAc2VlIGphdmEudXRpbC5BcnJheXMjZmlsbChmbG9hdFtdLCBpbnQsIGludCwgZmxvYXQpCi0JICovCi0JcHVibGljIHN0YXRpYyBmbG9hdFtdIGZpbGwoZmxvYXRbXSBhcnJheSwgaW50IGZyb21JbmRleCwgaW50IHRvSW5kZXgsIGZsb2F0IHZhbHVlKSB7Ci0JCUFycmF5cy5maWxsKGFycmF5LCBmcm9tSW5kZXgsIHRvSW5kZXgsIHZhbHVlKTsKLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gImZpbGxlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI2ZpbGwoaW50W10sIGludCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludFtdIGZpbGwoaW50W10gYXJyYXksIGludCB2YWx1ZSkgewotCQlBcnJheXMuZmlsbChhcnJheSwgdmFsdWUpOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciBpdCBoYXMgYmVlbiAiZmlsbGVkIi4KLQkgKiBAc2VlIGphdmEudXRpbC5BcnJheXMjZmlsbChpbnRbXSwgaW50LCBpbnQsIGludCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludFtdIGZpbGwoaW50W10gYXJyYXksIGludCBmcm9tSW5kZXgsIGludCB0b0luZGV4LCBpbnQgdmFsdWUpIHsKLQkJQXJyYXlzLmZpbGwoYXJyYXksIGZyb21JbmRleCwgdG9JbmRleCwgdmFsdWUpOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciBpdCBoYXMgYmVlbiAiZmlsbGVkIi4KLQkgKiBAc2VlIGphdmEudXRpbC5BcnJheXMjZmlsbChPYmplY3RbXSwgT2JqZWN0KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSBmaWxsKEVbXSBhcnJheSwgRSB2YWx1ZSkgewotCQlBcnJheXMuZmlsbChhcnJheSwgdmFsdWUpOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciBpdCBoYXMgYmVlbiAiZmlsbGVkIi4KLQkgKiBAc2VlIGphdmEudXRpbC5BcnJheXMjZmlsbChPYmplY3RbXSwgaW50LCBpbnQsIE9iamVjdCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gZmlsbChFW10gYXJyYXksIGludCBmcm9tSW5kZXgsIGludCB0b0luZGV4LCBFIHZhbHVlKSB7Ci0JCUFycmF5cy5maWxsKGFycmF5LCBmcm9tSW5kZXgsIHRvSW5kZXgsIHZhbHVlKTsKLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gImZpbGxlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI2ZpbGwobG9uZ1tdLCBsb25nKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgbG9uZ1tdIGZpbGwobG9uZ1tdIGFycmF5LCBsb25nIHZhbHVlKSB7Ci0JCUFycmF5cy5maWxsKGFycmF5LCB2YWx1ZSk7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFycmF5IGFmdGVyIGl0IGhhcyBiZWVuICJmaWxsZWQiLgotCSAqIEBzZWUgamF2YS51dGlsLkFycmF5cyNmaWxsKGxvbmdbXSwgaW50LCBpbnQsIGxvbmcpCi0JICovCi0JcHVibGljIHN0YXRpYyBsb25nW10gZmlsbChsb25nW10gYXJyYXksIGludCBmcm9tSW5kZXgsIGludCB0b0luZGV4LCBsb25nIHZhbHVlKSB7Ci0JCUFycmF5cy5maWxsKGFycmF5LCBmcm9tSW5kZXgsIHRvSW5kZXgsIHZhbHVlKTsKLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gImZpbGxlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI2ZpbGwoc2hvcnRbXSwgc2hvcnQpCi0JICovCi0JcHVibGljIHN0YXRpYyBzaG9ydFtdIGZpbGwoc2hvcnRbXSBhcnJheSwgc2hvcnQgdmFsdWUpIHsKLQkJQXJyYXlzLmZpbGwoYXJyYXksIHZhbHVlKTsKLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gImZpbGxlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI2ZpbGwoc2hvcnRbXSwgaW50LCBpbnQsIHNob3J0KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgc2hvcnRbXSBmaWxsKHNob3J0W10gYXJyYXksIGludCBmcm9tSW5kZXgsIGludCB0b0luZGV4LCBzaG9ydCB2YWx1ZSkgewotCQlBcnJheXMuZmlsbChhcnJheSwgZnJvbUluZGV4LCB0b0luZGV4LCB2YWx1ZSk7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFycmF5IGFmdGVyIGl0IGhhcyBiZWVuICJzb3J0ZWQiLgotCSAqIEBzZWUgamF2YS51dGlsLkFycmF5cyNzb3J0KGJ5dGVbXSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJ5dGVbXSBzb3J0KGJ5dGUuLi4gYXJyYXkpIHsKLQkJQXJyYXlzLnNvcnQoYXJyYXkpOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciBpdCBoYXMgYmVlbiAic29ydGVkIi4KLQkgKiBAc2VlIGphdmEudXRpbC5BcnJheXMjc29ydChieXRlW10sIGludCwgaW50KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYnl0ZVtdIHNvcnQoYnl0ZVtdIGFycmF5LCBpbnQgZnJvbUluZGV4LCBpbnQgdG9JbmRleCkgewotCQlBcnJheXMuc29ydChhcnJheSwgZnJvbUluZGV4LCB0b0luZGV4KTsKLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gInNvcnRlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI3NvcnQoY2hhcltdKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIHNvcnQoY2hhci4uLiBhcnJheSkgewotCQlBcnJheXMuc29ydChhcnJheSk7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFycmF5IGFmdGVyIGl0IGhhcyBiZWVuICJzb3J0ZWQiLgotCSAqIEBzZWUgamF2YS51dGlsLkFycmF5cyNzb3J0KGNoYXJbXSwgaW50LCBpbnQpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gc29ydChjaGFyW10gYXJyYXksIGludCBmcm9tSW5kZXgsIGludCB0b0luZGV4KSB7Ci0JCUFycmF5cy5zb3J0KGFycmF5LCBmcm9tSW5kZXgsIHRvSW5kZXgpOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciBpdCBoYXMgYmVlbiAic29ydGVkIi4KLQkgKiBAc2VlIGphdmEudXRpbC5BcnJheXMjc29ydChkb3VibGVbXSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGRvdWJsZVtdIHNvcnQoZG91YmxlLi4uIGFycmF5KSB7Ci0JCUFycmF5cy5zb3J0KGFycmF5KTsKLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gInNvcnRlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI3NvcnQoZG91YmxlW10sIGludCwgaW50KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgZG91YmxlW10gc29ydChkb3VibGVbXSBhcnJheSwgaW50IGZyb21JbmRleCwgaW50IHRvSW5kZXgpIHsKLQkJQXJyYXlzLnNvcnQoYXJyYXksIGZyb21JbmRleCwgdG9JbmRleCk7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFycmF5IGFmdGVyIGl0IGhhcyBiZWVuICJzb3J0ZWQiLgotCSAqIEBzZWUgamF2YS51dGlsLkFycmF5cyNzb3J0KGZsb2F0W10pCi0JICovCi0JcHVibGljIHN0YXRpYyBmbG9hdFtdIHNvcnQoZmxvYXQuLi4gYXJyYXkpIHsKLQkJQXJyYXlzLnNvcnQoYXJyYXkpOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciBpdCBoYXMgYmVlbiAic29ydGVkIi4KLQkgKiBAc2VlIGphdmEudXRpbC5BcnJheXMjc29ydChmbG9hdFtdLCBpbnQsIGludCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGZsb2F0W10gc29ydChmbG9hdFtdIGFycmF5LCBpbnQgZnJvbUluZGV4LCBpbnQgdG9JbmRleCkgewotCQlBcnJheXMuc29ydChhcnJheSwgZnJvbUluZGV4LCB0b0luZGV4KTsKLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gInNvcnRlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI3NvcnQoaW50W10pCi0JICovCi0JcHVibGljIHN0YXRpYyBpbnRbXSBzb3J0KGludC4uLiBhcnJheSkgewotCQlBcnJheXMuc29ydChhcnJheSk7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFycmF5IGFmdGVyIGl0IGhhcyBiZWVuICJzb3J0ZWQiLgotCSAqIEBzZWUgamF2YS51dGlsLkFycmF5cyNzb3J0KGludFtdLCBpbnQsIGludCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludFtdIHNvcnQoaW50W10gYXJyYXksIGludCBmcm9tSW5kZXgsIGludCB0b0luZGV4KSB7Ci0JCUFycmF5cy5zb3J0KGFycmF5LCBmcm9tSW5kZXgsIHRvSW5kZXgpOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciBpdCBoYXMgYmVlbiAic29ydGVkIi4KLQkgKiBAc2VlIGphdmEudXRpbC5BcnJheXMjc29ydChPYmplY3RbXSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gc29ydChFLi4uIGFycmF5KSB7Ci0JCUFycmF5cy5zb3J0KGFycmF5KTsKLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gInNvcnRlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI3NvcnQoT2JqZWN0W10sIGphdmEudXRpbC5Db21wYXJhdG9yKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPEU+IEVbXSBzb3J0KEVbXSBhcnJheSwgQ29tcGFyYXRvcjw/IHN1cGVyIEU+IGNvbXBhcmF0b3IpIHsKLQkJQXJyYXlzLnNvcnQoYXJyYXksIGNvbXBhcmF0b3IpOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciBpdCBoYXMgYmVlbiAic29ydGVkIi4KLQkgKiBAc2VlIGphdmEudXRpbC5BcnJheXMjc29ydChPYmplY3RbXSwgaW50LCBpbnQpCi0JICovCi0JcHVibGljIHN0YXRpYyA8RT4gRVtdIHNvcnQoRVtdIGFycmF5LCBpbnQgZnJvbUluZGV4LCBpbnQgdG9JbmRleCkgewotCQlBcnJheXMuc29ydChhcnJheSwgZnJvbUluZGV4LCB0b0luZGV4KTsKLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gInNvcnRlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI3NvcnQoT2JqZWN0W10sIGludCwgaW50LCBqYXZhLnV0aWwuQ29tcGFyYXRvcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxFPiBFW10gc29ydChFW10gYXJyYXksIGludCBmcm9tSW5kZXgsIGludCB0b0luZGV4LCBDb21wYXJhdG9yPD8gc3VwZXIgRT4gY29tcGFyYXRvcikgewotCQlBcnJheXMuc29ydChhcnJheSwgZnJvbUluZGV4LCB0b0luZGV4LCBjb21wYXJhdG9yKTsKLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gInNvcnRlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI3NvcnQobG9uZ1tdKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgbG9uZ1tdIHNvcnQobG9uZy4uLiBhcnJheSkgewotCQlBcnJheXMuc29ydChhcnJheSk7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFycmF5IGFmdGVyIGl0IGhhcyBiZWVuICJzb3J0ZWQiLgotCSAqIEBzZWUgamF2YS51dGlsLkFycmF5cyNzb3J0KGxvbmdbXSwgaW50LCBpbnQpCi0JICovCi0JcHVibGljIHN0YXRpYyBsb25nW10gc29ydChsb25nW10gYXJyYXksIGludCBmcm9tSW5kZXgsIGludCB0b0luZGV4KSB7Ci0JCUFycmF5cy5zb3J0KGFycmF5LCBmcm9tSW5kZXgsIHRvSW5kZXgpOwotCQlyZXR1cm4gYXJyYXk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhcnJheSBhZnRlciBpdCBoYXMgYmVlbiAic29ydGVkIi4KLQkgKiBAc2VlIGphdmEudXRpbC5BcnJheXMjc29ydChzaG9ydFtdKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgc2hvcnRbXSBzb3J0KHNob3J0Li4uIGFycmF5KSB7Ci0JCUFycmF5cy5zb3J0KGFycmF5KTsKLQkJcmV0dXJuIGFycmF5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgYWZ0ZXIgaXQgaGFzIGJlZW4gInNvcnRlZCIuCi0JICogQHNlZSBqYXZhLnV0aWwuQXJyYXlzI3NvcnQoc2hvcnRbXSwgaW50LCBpbnQpCi0JICovCi0JcHVibGljIHN0YXRpYyBzaG9ydFtdIHNvcnQoc2hvcnRbXSBhcnJheSwgaW50IGZyb21JbmRleCwgaW50IHRvSW5kZXgpIHsKLQkJQXJyYXlzLnNvcnQoYXJyYXksIGZyb21JbmRleCwgdG9JbmRleCk7Ci0JCXJldHVybiBhcnJheTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3IgKioqKioqKioqKgotCi0JLyoqCi0JICogU3VwcHJlc3MgZGVmYXVsdCBjb25zdHJ1Y3RvciwgZW5zdXJpbmcgbm9uLWluc3RhbnRpYWJpbGl0eS4KLQkgKi8KLQlwcml2YXRlIENvbGxlY3Rpb25Ub29scygpIHsKLQkJc3VwZXIoKTsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvQ29tbWFuZFJ1bm5hYmxlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvQ29tbWFuZFJ1bm5hYmxlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGMyYmQ0ZTIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0NvbW1hbmRSdW5uYWJsZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LkNvbW1hbmQ7Ci0KLS8qKgotICogV3JhcCBhIENvbW1hbmQgc28gaXQgY2FuIGJlIHVzZWQgYXMgYSBSdW5uYWJsZS4KLSAqLwotcHVibGljIGNsYXNzIENvbW1hbmRSdW5uYWJsZSBpbXBsZW1lbnRzIFJ1bm5hYmxlIHsKLQlwcm90ZWN0ZWQgZmluYWwgQ29tbWFuZCBjb21tYW5kOwotCi0JcHVibGljIENvbW1hbmRSdW5uYWJsZShDb21tYW5kIGNvbW1hbmQpIHsKLQkJc3VwZXIoKTsKLQkJaWYgKGNvbW1hbmQgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy5jb21tYW5kID0gY29tbWFuZDsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBydW4oKSB7Ci0JCXRoaXMuY29tbWFuZC5leGVjdXRlKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuICJSdW5uYWJsZVsiICsgdGhpcy5jb21tYW5kLnRvU3RyaW5nKCkgKyddJzsgLy8kTk9OLU5MUy0xJAotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0NvdW50ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9Db3VudGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZiZTNjZGUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0NvdW50ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEwOSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsOwotCi1pbXBvcnQgamF2YS5pby5TZXJpYWxpemFibGU7Ci0KLS8qKgotICogVGhpcyBjbGFzcyBjYW4gYmUgdXNlZCB3aGVyZXZlciBhIG11dGFibGUgaW50ZWdlciBvYmplY3QgaXMgbmVlZGVkLgotICogSXQgaXMgYSBjcm9zcyBiZXR3ZWVuIGFuIGludCBhbmQgYW4gSW50ZWdlci4gSXQgY2FuIGJlIHN0b3JlZCBpbiBhIHN0YW5kYXJkCi0gKiBjb250YWluZXIgKGUuZy4gQ29sbGVjdGlvbikgYnV0IGNhbiBiZSBtb2RpZmllZC4KLSAqLwotcHVibGljIGZpbmFsIGNsYXNzIENvdW50ZXIKLQlpbXBsZW1lbnRzIENsb25lYWJsZSwgU2VyaWFsaXphYmxlCi17Ci0JcHJpdmF0ZSBpbnQgY291bnQgPSAwOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGNvdW50ZXIgd2l0aCB0aGUgc3BlY2lmaWVkIGluaXRpYWwgdmFsdWUuCi0JICovCi0JcHVibGljIENvdW50ZXIoaW50IGNvdW50KSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuY291bnQgPSBjb3VudDsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBjb3VudGVyIHdpdGggYW4gaW5pdGlhbCB2YWx1ZSBvZiB6ZXJvLgotCSAqLwotCXB1YmxpYyBDb3VudGVyKCkgewotCQl0aGlzKDApOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgY3VycmVudCBjb3VudCBvZiB0aGUgY291bnRlci4KLQkgKi8KLQlwdWJsaWMgc3luY2hyb25pemVkIGludCBjb3VudCgpIHsKLQkJcmV0dXJuIHRoaXMuY291bnQ7Ci0JfQotCi0JLyoqCi0JICogSW5jcmVtZW50IGFuZCByZXR1cm4gdGhlIGN1cnJlbnQgY291bnQgb2YgdGhlIGNvdW50ZXIuCi0JICovCi0JcHVibGljIHN5bmNocm9uaXplZCBpbnQgaW5jcmVtZW50KCkgewotCQlyZXR1cm4gKyt0aGlzLmNvdW50OwotCX0KLQotCS8qKgotCSAqIEluY3JlbWVudCBhbmQgcmV0dXJuIHRoZSBjdXJyZW50IGNvdW50IG9mIHRoZSBjb3VudGVyLgotCSAqLwotCXB1YmxpYyBzeW5jaHJvbml6ZWQgaW50IGluY3JlbWVudChpbnQgaW5jcmVtZW50KSB7Ci0JCXJldHVybiB0aGlzLmNvdW50ICs9IGluY3JlbWVudDsKLQl9Ci0KLQkvKioKLQkgKiBEZXJlbWVudCBhbmQgcmV0dXJuIHRoZSBjdXJyZW50IGNvdW50IG9mIHRoZSBjb3VudGVyLgotCSAqLwotCXB1YmxpYyBzeW5jaHJvbml6ZWQgaW50IGRlY3JlbWVudCgpIHsKLQkJcmV0dXJuIC0tdGhpcy5jb3VudDsKLQl9Ci0KLQkvKioKLQkgKiBEZXJlbWVudCBhbmQgcmV0dXJuIHRoZSBjdXJyZW50IGNvdW50IG9mIHRoZSBjb3VudGVyLgotCSAqLwotCXB1YmxpYyBzeW5jaHJvbml6ZWQgaW50IGRlY3JlbWVudChpbnQgZGVjcmVtZW50KSB7Ci0JCXJldHVybiB0aGlzLmNvdW50IC09IGRlY3JlbWVudDsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgc3luY2hyb25pemVkIGJvb2xlYW4gZXF1YWxzKE9iamVjdCBvKSB7Ci0JCWlmICggISAobyBpbnN0YW5jZW9mIENvdW50ZXIpKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJcmV0dXJuIHRoaXMuY291bnQgPT0gKChDb3VudGVyKSBvKS5jb3VudDsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgc3luY2hyb25pemVkIGludCBoYXNoQ29kZSgpIHsKLQkJcmV0dXJuIHRoaXMuY291bnQ7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHN5bmNocm9uaXplZCBPYmplY3QgY2xvbmUoKSB7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gc3VwZXIuY2xvbmUoKTsKLQkJfSBjYXRjaCAoQ2xvbmVOb3RTdXBwb3J0ZWRFeGNlcHRpb24gZXgpIHsKLQkJCXRocm93IG5ldyBJbnRlcm5hbEVycm9yKCk7Ci0JCX0KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgc3luY2hyb25pemVkIFN0cmluZyB0b1N0cmluZygpIHsKLQkJU3RyaW5nQnVmZmVyIHNiID0gbmV3IFN0cmluZ0J1ZmZlcigpOwotCQlzYi5hcHBlbmQoQ2xhc3NUb29scy5zaG9ydENsYXNzTmFtZUZvck9iamVjdCh0aGlzKSk7Ci0JCXNiLmFwcGVuZCgnKCcpOwotCQlzYi5hcHBlbmQodGhpcy5jb3VudCk7Ci0JCXNiLmFwcGVuZCgnKScpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9FbXB0eUl0ZXJhYmxlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvRW1wdHlJdGVyYWJsZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxZjkwZjNkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9FbXB0eUl0ZXJhYmxlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5FbXB0eUl0ZXJhdG9yOwotCi0vKioKLSAqIEFuIDxjb2RlPkVtcHR5SXRlcmFibGU8L2NvZGU+IGlzIGp1c3QgdGhhdC4KLSAqLwotcHVibGljIGZpbmFsIGNsYXNzIEVtcHR5SXRlcmFibGU8RT4KLQlpbXBsZW1lbnRzIEl0ZXJhYmxlPEU+Ci17Ci0KLQkvLyBzaW5nbGV0b24KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFbXB0eUl0ZXJhYmxlIElOU1RBTkNFID0gbmV3IEVtcHR5SXRlcmFibGUoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXB1YmxpYyBzdGF0aWMgPFQ+IEl0ZXJhYmxlPFQ+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEVtcHR5SXRlcmFibGUoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JcHVibGljIEl0ZXJhdG9yPEU+IGl0ZXJhdG9yKCkgewotCQlyZXR1cm4gRW1wdHlJdGVyYXRvci5pbnN0YW5jZSgpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0ZpbGVUb29scy5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0ZpbGVUb29scy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxOThlNzQ1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9GaWxlVG9vbHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEwMDcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uRmlsZTsKLWltcG9ydCBqYXZhLmlvLkZpbGVGaWx0ZXI7Ci1pbXBvcnQgamF2YS5pby5GaWxlSW5wdXRTdHJlYW07Ci1pbXBvcnQgamF2YS5pby5GaWxlT3V0cHV0U3RyZWFtOwotaW1wb3J0IGphdmEuaW8uSU9FeGNlcHRpb247Ci1pbXBvcnQgamF2YS5uZXQuVVJJOwotaW1wb3J0IGphdmEubmV0LlVSSVN5bnRheEV4Y2VwdGlvbjsKLWltcG9ydCBqYXZhLm5ldC5VUkw7Ci1pbXBvcnQgamF2YS5uaW8uY2hhbm5lbHMuRmlsZUNoYW5uZWw7Ci1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbnM7Ci1pbXBvcnQgamF2YS51dGlsLkhhc2hTZXQ7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmEudXRpbC5TZXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkFycmF5SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkNvbXBvc2l0ZUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5GaWx0ZXJpbmdJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuVHJhbnNmb3JtYXRpb25JdGVyYXRvcjsKLQotLyoqCi0gKiBBc3NvcnRlZCBmaWxlIHRvb2xzOgotICogLSBkZWxldGUgZW50aXJlIHRyZWVzIG9mIGRpcmVjdG9yaWVzIGFuZCBmaWxlcwotICogLSBidWlsZCBpdGVyYXRvcnMgb24gZW50aXJlIHRyZWVzIG9mIGRpcmVjdG9yaWVzIGFuZCBmaWxlcwotICogLSBidWlsZCBhIHRlbXBvcmFyeSBkaXJlY3RvcnkKLSAqIC0gImNhbm9uaXplIiBmaWxlcwotICovCi1wdWJsaWMgZmluYWwgY2xhc3MgRmlsZVRvb2xzIHsKLQotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFVTRVJfSE9NRV9ESVJFQ1RPUllfTkFNRSA9IFN5c3RlbS5nZXRQcm9wZXJ0eSgidXNlci5ob21lIik7IC8vJE5PTi1OTFMtMSQKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBVU0VSX1RFTVBPUkFSWV9ESVJFQ1RPUllfTkFNRSA9IFN5c3RlbS5nZXRQcm9wZXJ0eSgiamF2YS5pby50bXBkaXIiKTsgLy8kTk9OLU5MUy0xJAotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIERFRkFVTFRfVEVNUE9SQVJZX0RJUkVDVE9SWV9OQU1FID0gInRtcGRpciI7IC8vJE5PTi1OTFMtMSQKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBDVVJSRU5UX1dPUktJTkdfRElSRUNUT1JZX05BTUUgPSBTeXN0ZW0uZ2V0UHJvcGVydHkoInVzZXIuZGlyIik7IC8vJE5PTi1OTFMtMSQKLQotICAgIC8qKiBBIGxpc3Qgb2Ygc29tZSBpbnZhbGlkIGZpbGUgbmFtZSBjaGFyYWN0ZXJzLgotCQkJCTogaXMgdGhlIGZpbGVuYW1lIHNlcGFyYXRvciBpbiBNYWNPUyBhbmQgdGhlIGRyaXZlIGluZGljYXRvciBpbiBET1MKLQkJCQkqIGlzIGEgRE9TIHdpbGRjYXJkIGNoYXJhY3RlcgotCQkJCXwgaXMgYSBET1MgcmVkaXJlY3Rpb24gY2hhcmFjdGVyCi0JCQkJJiBpcyBvdXIgb3duIGVzY2FwZSBjaGFyYWN0ZXIKLQkJCQkvIGlzIHRoZSBmaWxlbmFtZSBzZXBhcmF0b3IgaW4gVW5peCBhbmQgdGhlIGNvbW1hbmQgb3B0aW9uIHRhZyBpbiBET1MKLQkJCQlcIGlzIHRoZSBmaWxlbmFtZSBzZXBhcmF0b3IgaW4gRE9TL1dpbmRvd3MgYW5kIHRoZSBlc2NhcGUgY2hhcmFjdGVyIGluIFVuaXgKLQkJCQk7IGlzID8/PwotCQkJCT8gaXMgYSBET1Mgd2lsZGNhcmQgY2hhcmFjdGVyCi0JCQkJWyBpcyA/Pz8KLQkJCQldIGlzID8/PwotCQkJCT0gaXMgPz8/Ci0JCQkJKyBpcyA/Pz8KLQkJCQk8IGlzIGEgRE9TIHJlZGlyZWN0aW9uIGNoYXJhY3RlcgotCQkJCT4gaXMgYSBET1MgcmVkaXJlY3Rpb24gY2hhcmFjdGVyCi0JCQkJIiBpcyB1c2VkIGJ5IERPUyB0byBkZWxpbWl0IGZpbGUgbmFtZXMgd2l0aCBzcGFjZXMKLQkJCQksIGlzID8/PwotICAgICAqLwotCXB1YmxpYyBzdGF0aWMgZmluYWwgY2hhcltdIElOVkFMSURfRklMRU5BTUVfQ0hBUkFDVEVSUyA9IHsgJzonLCAnKicsICd8JywgJyYnLCAnLycsICdcXCcsICc7JywgJz8nLCAnWycsICddJywgJz0nLCAnKycsICc8JywgJz4nLCAnIicsICcsJyB9OwotCi0JLyoqIFRoaXMgZW5jb2RlciB3aWxsIGNvbnZlcnQgc3RyaW5ncyBpbnRvIHZhbGlkIGZpbGUgbmFtZXMuICovCi0JcHVibGljIHN0YXRpYyBmaW5hbCBYTUxTdHJpbmdFbmNvZGVyIEZJTEVfTkFNRV9FTkNPREVSID0gbmV3IFhNTFN0cmluZ0VuY29kZXIoSU5WQUxJRF9GSUxFTkFNRV9DSEFSQUNURVJTKTsKLQotCS8qKiBXaW5kb3dzIGZpbGVzIHRoYXQgYXJlIHJlZGlyZWN0ZWQgdG8gZGV2aWNlcyBldGMuICovCi0JQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nW10gV0lORE9XU19SRVNFUlZFRF9GSUxFX05BTUVTID0gewotCQkiY29uIiwKLQkJImF1eCIsCi0JCSJjb20xIiwgImNvbTIiLCAiY29tMyIsICJjb200IiwgImNvbTUiLCAiY29tNiIsICJjb203IiwgImNvbTgiLCAiY29tOSIsCi0JCSJscHQxIiwgImxwdDIiLCAibHB0MyIsICJscHQ0IiwgImxwdDUiLCAibHB0NiIsICJscHQ3IiwgImxwdDgiLCAibHB0OSIsCi0JCSJwcm4iLAotCQkibnVsIgotCX07Ci0KLQkvKiogVGhlIGRlZmF1bHQgbGVuZ3RoIG9mIGEgc2hvcnRlbmVkIGZpbGUgbmFtZS4gKi8KLQlwdWJsaWMgc3RhdGljIGZpbmFsIGludCBNQVhJTVVNX1NIT1JURU5FRF9GSUxFX05BTUVfTEVOR1RIID0gNjA7Ci0KLQotCS8vICoqKioqKioqKiogZGVsZXRpbmcgZGlyZWN0b3JpZXMgKioqKioqKioqKgotCi0JLyoqCi0JICogRGVsZXRlIHRoZSBzcGVjaWZpZWQgZGlyZWN0b3J5IGFuZCBhbGwgb2YgaXRzIGNvbnRlbnRzLgotCSAqIDxlbT5VU0UgV0lUSCBDQVJFLjwvZW0+Ci0JICogRmlsZSNkZWxldGVBbGwoKT8KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgZGVsZXRlRGlyZWN0b3J5KFN0cmluZyBkaXJlY3RvcnlOYW1lKSB7Ci0JCWRlbGV0ZURpcmVjdG9yeShuZXcgRmlsZShkaXJlY3RvcnlOYW1lKSk7Ci0JfQotCQotCS8qKgotCSAqIERlbGV0ZSB0aGUgc3BlY2lmaWVkIGRpcmVjdG9yeSBhbmQgYWxsIG9mIGl0cyBjb250ZW50cy4KLQkgKiA8ZW0+VVNFIFdJVEggQ0FSRS48L2VtPgotCSAqIEZpbGUjZGVsZXRlQWxsKCk/Ci0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGRlbGV0ZURpcmVjdG9yeShGaWxlIGRpcmVjdG9yeSkgewotCQlkZWxldGVEaXJlY3RvcnlDb250ZW50cyhkaXJlY3RvcnkpOwotCQlpZiAoICEgZGlyZWN0b3J5LmRlbGV0ZSgpKSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbigidW5hYmxlIHRvIGRlbGV0ZSBkaXJlY3Rvcnk6ICIgKyBkaXJlY3RvcnkuZ2V0QWJzb2x1dGVQYXRoKCkpOyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0JCi0JLyoqCi0JICogRGVsZXRlIHRoZSBjb250ZW50cyBvZiB0aGUgc3BlY2lmaWVkIGRpcmVjdG9yeQotCSAqIChidXQgbm90IHRoZSBkaXJlY3RvcnkgaXRzZWxmKS4KLQkgKiA8ZW0+VVNFIFdJVEggQ0FSRS48L2VtPgotCSAqIEZpbGUjZGVsZXRlRmlsZXMoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBkZWxldGVEaXJlY3RvcnlDb250ZW50cyhTdHJpbmcgZGlyZWN0b3J5TmFtZSkgewotCQlkZWxldGVEaXJlY3RvcnlDb250ZW50cyhuZXcgRmlsZShkaXJlY3RvcnlOYW1lKSk7Ci0JfQotCQotCS8qKgotCSAqIERlbGV0ZSB0aGUgY29udGVudHMgb2YgdGhlIHNwZWNpZmllZCBkaXJlY3RvcnkKLQkgKiAoYnV0IG5vdCB0aGUgZGlyZWN0b3J5IGl0c2VsZikuCi0JICogPGVtPlVTRSBXSVRIIENBUkUuPC9lbT4KLQkgKiBGaWxlI2RlbGV0ZUZpbGVzKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgZGVsZXRlRGlyZWN0b3J5Q29udGVudHMoRmlsZSBkaXJlY3RvcnkpIHsKLQkJZm9yIChGaWxlIGZpbGUgOiBkaXJlY3RvcnkubGlzdEZpbGVzKCkpIHsKLQkJCWlmIChmaWxlLmlzRGlyZWN0b3J5KCkpIHsKLQkJCQlkZWxldGVEaXJlY3RvcnkoZmlsZSk7CS8vIHJlY3Vyc2UgdGhyb3VnaCBzdWJkaXJlY3RvcmllcwotCQkJfSBlbHNlIHsKLQkJCQlpZiAoICEgZmlsZS5kZWxldGUoKSkgewotCQkJCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbigidW5hYmxlIHRvIGRlbGV0ZSBmaWxlOiAiICsgZmlsZS5nZXRBYnNvbHV0ZVBhdGgoKSk7IC8vJE5PTi1OTFMtMSQKLQkJCQl9Ci0JCQl9Ci0JCX0KLQl9Ci0JCi0KLQkvLyAqKioqKioqKioqIGNvcHlpbmcgZmlsZXMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29waWVzIHRoZSBjb250ZW50IG9mIHRoZSBzb3VyY2UgZmlsZSB0byB0aGUgZGVzdGluYXRpb24gZmlsZS4KLQkgKiBGaWxlI2NvcHkoRmlsZSBkZXN0aW5hdGlvbkZpbGUpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGNvcHlUb0ZpbGUoRmlsZSBzb3VyY2VGaWxlLCBGaWxlIGRlc3RpbmF0aW9uRmlsZSkKLQkJdGhyb3dzIElPRXhjZXB0aW9uCi0JewotCQlGaWxlQ2hhbm5lbCBzb3VyY2VDaGFubmVsID0gbmV3IEZpbGVJbnB1dFN0cmVhbShzb3VyY2VGaWxlKS5nZXRDaGFubmVsKCk7Ci0JCUZpbGVDaGFubmVsIGRlc3RpbmF0aW9uQ2hhbm5lbCA9IG5ldyBGaWxlT3V0cHV0U3RyZWFtKGRlc3RpbmF0aW9uRmlsZSkuZ2V0Q2hhbm5lbCgpOwotCQl0cnkgewotCQkJZGVzdGluYXRpb25DaGFubmVsLnRyYW5zZmVyRnJvbShzb3VyY2VDaGFubmVsLCAwLCBzb3VyY2VDaGFubmVsLnNpemUoKSk7Ci0JCX0gZmluYWxseSB7Ci0JCQlzb3VyY2VDaGFubmVsLmNsb3NlKCk7Ci0JCQlkZXN0aW5hdGlvbkNoYW5uZWwuY2xvc2UoKTsKLQkJfQotCX0KLQkKLQkvKioKLQkgKiBDb3BpZXMgdGhlIGNvbnRlbnQgb2YgdGhlIHNvdXJjZSBmaWxlIHRvIGEgZmlsZSBieQotCSAqIHRoZSBzYW1lIG5hbWUgaW4gdGhlIGRlc3RpbmF0aW9uIGRpcmVjdG9yeS4KLQkgKiBGaWxlI2NvcHlUb0RpcmVjdG9yeShGaWxlIGRlc3RpbmF0aW9uRGlyZWN0b3J5KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBjb3B5VG9EaXJlY3RvcnkoRmlsZSBzb3VyY2VGaWxlLCBGaWxlIGRlc3RpbmF0aW9uRGlyZWN0b3J5KQotCQl0aHJvd3MgSU9FeGNlcHRpb24KLQl7Ci0JCUZpbGUgZGVzdGluYXRpb25GaWxlID0gbmV3IEZpbGUoZGVzdGluYXRpb25EaXJlY3RvcnksIHNvdXJjZUZpbGUuZ2V0TmFtZSgpKTsKLQkJZGVzdGluYXRpb25GaWxlLmNyZWF0ZU5ld0ZpbGUoKTsKLQkJY29weVRvRmlsZShzb3VyY2VGaWxlLCBkZXN0aW5hdGlvbkZpbGUpOwotCX0KLQkKLQotCS8vICoqKioqKioqKiogaXRlcmF0b3Jpbmcgb3ZlciBmaWxlcyBhbmQgZGlyZWN0b3JpZXMgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIGFuIGl0ZXJhdG9yIG9uIGFsbCB0aGUgZmlsZXMgaW4gdGhlIHNwZWNpZmllZCBkaXJlY3RvcnkuCi0JICogVGhlIGl0ZXJhdG9yIHdpbGwgc2tpcCBvdmVyIHN1YmRpcmVjdG9yaWVzLgotCSAqIEZpbGUjZmlsZXMoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgSXRlcmF0b3I8RmlsZT4gZmlsZXNJbihTdHJpbmcgZGlyZWN0b3J5TmFtZSkgewotCQlyZXR1cm4gZmlsZXNJbihuZXcgRmlsZShkaXJlY3RvcnlOYW1lKSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiBhbiBpdGVyYXRvciBvbiBhbGwgdGhlIGZpbGVzIGluIHRoZSBzcGVjaWZpZWQgZGlyZWN0b3J5LgotCSAqIFRoZSBpdGVyYXRvciB3aWxsIHNraXAgb3ZlciBzdWJkaXJlY3Rvcmllcy4KLQkgKiBGaWxlI2ZpbGVzKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIEl0ZXJhdG9yPEZpbGU+IGZpbGVzSW4oRmlsZSBkaXJlY3RvcnkpIHsKLQkJcmV0dXJuIGZpbGVzSW4oZGlyZWN0b3J5Lmxpc3RGaWxlcygpKTsKLQl9Ci0JCi0JcHJpdmF0ZSBzdGF0aWMgSXRlcmF0b3I8RmlsZT4gZmlsZXNJbihGaWxlW10gZmlsZXMpIHsKLQkJcmV0dXJuIG5ldyBGaWx0ZXJpbmdJdGVyYXRvcjxGaWxlLCBGaWxlPihuZXcgQXJyYXlJdGVyYXRvcjxGaWxlPihmaWxlcykpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGJvb2xlYW4gYWNjZXB0KEZpbGUgbmV4dCkgewotCQkJCXJldHVybiBuZXh0LmlzRmlsZSgpOwotCQkJfQotCQl9OwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gYW4gaXRlcmF0b3Igb24gYWxsIHRoZSBzdWJkaXJlY3RvcmllcwotCSAqIGluIHRoZSBzcGVjaWZpZWQgZGlyZWN0b3J5LgotCSAqIEZpbGUjc3ViRGlyZWN0b3JpZXMoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgSXRlcmF0b3I8RmlsZT4gZGlyZWN0b3JpZXNJbihTdHJpbmcgZGlyZWN0b3J5TmFtZSkgewotCQlyZXR1cm4gZGlyZWN0b3JpZXNJbihuZXcgRmlsZShkaXJlY3RvcnlOYW1lKSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiBhbiBpdGVyYXRvciBvbiBhbGwgdGhlIHN1YmRpcmVjdG9yaWVzCi0JICogaW4gdGhlIHNwZWNpZmllZCBkaXJlY3RvcnkuCi0JICogRmlsZSNzdWJEaXJlY3RvcmllcygpCi0JICovCi0JcHVibGljIHN0YXRpYyBJdGVyYXRvcjxGaWxlPiBkaXJlY3Rvcmllc0luKEZpbGUgZGlyZWN0b3J5KSB7Ci0JCXJldHVybiBkaXJlY3Rvcmllc0luKGRpcmVjdG9yeS5saXN0RmlsZXMoKSk7Ci0JfQotCQotCXByaXZhdGUgc3RhdGljIEl0ZXJhdG9yPEZpbGU+IGRpcmVjdG9yaWVzSW4oRmlsZVtdIGZpbGVzKSB7Ci0JCXJldHVybiBuZXcgRmlsdGVyaW5nSXRlcmF0b3I8RmlsZSwgRmlsZT4obmV3IEFycmF5SXRlcmF0b3I8RmlsZT4oZmlsZXMpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBib29sZWFuIGFjY2VwdChGaWxlIG5leHQpIHsKLQkJCQlyZXR1cm4gbmV4dC5pc0RpcmVjdG9yeSgpOwotCQkJfQotCQl9OwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gYW4gaXRlcmF0b3Igb24gYWxsIHRoZSBmaWxlcyB1bmRlciB0aGUgc3BlY2lmaWVkCi0JICogZGlyZWN0b3J5LCByZWN1cnNpbmcgaW50byBzdWJkaXJlY3Rvcmllcy4KLQkgKiBUaGUgaXRlcmF0b3Igd2lsbCBza2lwIG92ZXIgdGhlIHN1YmRpcmVjdG9yaWVzIHRoZW1zZWx2ZXMuCi0JICogRmlsZSNmaWxlc1JlY3Vyc2UoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgSXRlcmF0b3I8RmlsZT4gZmlsZXNJblRyZWUoU3RyaW5nIGRpcmVjdG9yeU5hbWUpIHsKLQkJcmV0dXJuIGZpbGVzSW5UcmVlKG5ldyBGaWxlKGRpcmVjdG9yeU5hbWUpKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIGFuIGl0ZXJhdG9yIG9uIGFsbCB0aGUgZmlsZXMgdW5kZXIgdGhlIHNwZWNpZmllZAotCSAqIGRpcmVjdG9yeSwgcmVjdXJzaW5nIGludG8gc3ViZGlyZWN0b3JpZXMuCi0JICogVGhlIGl0ZXJhdG9yIHdpbGwgc2tpcCBvdmVyIHRoZSBzdWJkaXJlY3RvcmllcyB0aGVtc2VsdmVzLgotCSAqIEZpbGUjZmlsZXNSZWN1cnNlKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIEl0ZXJhdG9yPEZpbGU+IGZpbGVzSW5UcmVlKEZpbGUgZGlyZWN0b3J5KSB7Ci0JCXJldHVybiBmaWxlc0luVHJlZUFzU2V0KGRpcmVjdG9yeSkuaXRlcmF0b3IoKTsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBTZXQ8RmlsZT4gZmlsZXNJblRyZWVBc1NldChGaWxlIGRpcmVjdG9yeSkgewotCQlTZXQ8RmlsZT4gZmlsZXMgPSBuZXcgSGFzaFNldDxGaWxlPigxMDAwMCk7Ci0JCWFkZEZpbGVzSW5UcmVlVG8oZGlyZWN0b3J5LCBmaWxlcyk7Ci0JCXJldHVybiBmaWxlczsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyB2b2lkIGFkZEZpbGVzSW5UcmVlVG8oRmlsZSBkaXJlY3RvcnksIENvbGxlY3Rpb248RmlsZT4gYWxsRmlsZXMpIHsKLQkJZm9yIChGaWxlIGZpbGUgOiBkaXJlY3RvcnkubGlzdEZpbGVzKCkpIHsKLQkJCWlmIChmaWxlLmlzRmlsZSgpKSB7Ci0JCQkJYWxsRmlsZXMuYWRkKGZpbGUpOwotCQkJfSBlbHNlIGlmIChmaWxlLmlzRGlyZWN0b3J5KCkpIHsKLQkJCQlhZGRGaWxlc0luVHJlZVRvKGZpbGUsIGFsbEZpbGVzKTsKLQkJCX0KLQkJfQotCX0KLQotCS8qKgotCSAqIFJldHVybiBhbiBpdGVyYXRvciBvbiBhbGwgdGhlIGRpcmVjdG9yaWVzIHVuZGVyIHRoZSBzcGVjaWZpZWQKLQkgKiBkaXJlY3RvcnksIHJlY3Vyc2luZyBpbnRvIHN1YmRpcmVjdG9yaWVzLgotCSAqIEZpbGUjc3ViRGlyZWN0b3JpZXNSZWN1cnNlKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIEl0ZXJhdG9yPEZpbGU+IGRpcmVjdG9yaWVzSW5UcmVlKFN0cmluZyBkaXJlY3RvcnlOYW1lKSB7Ci0JCXJldHVybiBkaXJlY3Rvcmllc0luVHJlZShuZXcgRmlsZShkaXJlY3RvcnlOYW1lKSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiBhbiBpdGVyYXRvciBvbiBhbGwgdGhlIGRpcmVjdG9yaWVzIHVuZGVyIHRoZSBzcGVjaWZpZWQKLQkgKiBkaXJlY3RvcnksIHJlY3Vyc2luZyBpbnRvIHN1YmRpcmVjdG9yaWVzLgotCSAqIEZpbGUjc3ViRGlyZWN0b3JpZXNSZWN1cnNlKCkKLQkgKi8KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwdWJsaWMgc3RhdGljIEl0ZXJhdG9yPEZpbGU+IGRpcmVjdG9yaWVzSW5UcmVlKEZpbGUgZGlyZWN0b3J5KSB7Ci0JCUZpbGVbXSBmaWxlcyA9IGRpcmVjdG9yeS5saXN0RmlsZXMoKTsKLQkJcmV0dXJuIG5ldyBDb21wb3NpdGVJdGVyYXRvcjxGaWxlPihkaXJlY3Rvcmllc0luKGZpbGVzKSwgZGlyZWN0b3JpZXNJblRyZWVzKGRpcmVjdG9yaWVzSW4oZmlsZXMpKSk7Ci0JfQotCQotCXByaXZhdGUgc3RhdGljIEl0ZXJhdG9yPEZpbGU+IGRpcmVjdG9yaWVzSW5UcmVlcyhJdGVyYXRvcjxGaWxlPiBkaXJlY3RvcmllcykgewotCQlyZXR1cm4gbmV3IENvbXBvc2l0ZUl0ZXJhdG9yPEZpbGU+KAotCQkJbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8RmlsZSwgSXRlcmF0b3I8RmlsZT4+KGRpcmVjdG9yaWVzKSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIEl0ZXJhdG9yPEZpbGU+IHRyYW5zZm9ybShGaWxlIG5leHQpIHsKLQkJCQkJcmV0dXJuIEZpbGVUb29scy5kaXJlY3Rvcmllc0luVHJlZShuZXh0KTsKLQkJCQl9Ci0JCQl9Ci0JCSk7Ci0JfQotCQotCi0JLy8gKioqKioqKioqKiBzaG9ydCBmaWxlIG5hbWUgbWFuaXB1bGF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIFN0cmlwIHRoZSBleHRlbnNpb24gZnJvbSB0aGUgc3BlY2lmaWVkIGZpbGUgbmFtZQotCSAqIGFuZCByZXR1cm4gdGhlIHJlc3VsdC4gSWYgdGhlIGZpbGUgbmFtZSBoYXMgbm8KLQkgKiBleHRlbnNpb24sIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZAotCSAqIEZpbGUjYmFzZVBhdGgoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHN0cmlwRXh0ZW5zaW9uKFN0cmluZyBmaWxlTmFtZSkgewotCQlpbnQgaW5kZXggPSBmaWxlTmFtZS5sYXN0SW5kZXhPZignLicpOwotCQlpZiAoaW5kZXggPT0gLTEpIHsKLQkJCXJldHVybiBmaWxlTmFtZTsKLQkJfQotCQlyZXR1cm4gZmlsZU5hbWUuc3Vic3RyaW5nKDAsIGluZGV4KTsKLQl9Ci0JCi0JLyoqCi0JICogU3RyaXAgdGhlIGV4dGVuc2lvbiBmcm9tIHRoZSBzcGVjaWZpZWQgZmlsZSdzIG5hbWUKLQkgKiBhbmQgcmV0dXJuIHRoZSByZXN1bHQuIElmIHRoZSBmaWxlJ3MgbmFtZSBoYXMgbm8KLQkgKiBleHRlbnNpb24sIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZAotCSAqIEZpbGUjYmFzZVBhdGgoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHN0cmlwRXh0ZW5zaW9uKEZpbGUgZmlsZSkgewotCQlyZXR1cm4gc3RyaXBFeHRlbnNpb24oZmlsZS5nZXRQYXRoKCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgZXh0ZW5zaW9uLCBpbmNsdWRpbmcgdGhlIGRvdCwgb2YgdGhlIHNwZWNpZmllZCBmaWxlIG5hbWUuCi0JICogSWYgdGhlIGZpbGUgbmFtZSBoYXMgbm8gZXh0ZW5zaW9uLCByZXR1cm4gYW4gZW1wdHkgc3RyaW5nLgotCSAqIEZpbGUjZXh0ZW5zaW9uKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBleHRlbnNpb24oU3RyaW5nIGZpbGVOYW1lKSB7Ci0JCWludCBpbmRleCA9IGZpbGVOYW1lLmxhc3RJbmRleE9mKCcuJyk7Ci0JCWlmIChpbmRleCA9PSAtMSkgewotCQkJcmV0dXJuICIiOyAvLyROT04tTkxTLTEkCi0JCX0KLQkJcmV0dXJuIGZpbGVOYW1lLnN1YnN0cmluZyhpbmRleCk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgZXh0ZW5zaW9uLCBpbmNsdWRpbmcgdGhlIGRvdCwgb2YgdGhlIHNwZWNpZmllZCBmaWxlJ3MgbmFtZS4KLQkgKiBJZiB0aGUgZmlsZSdzIG5hbWUgaGFzIG5vIGV4dGVuc2lvbiwgcmV0dXJuIGFuIGVtcHR5IHN0cmluZy4KLQkgKiBGaWxlI2V4dGVuc2lvbigpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgZXh0ZW5zaW9uKEZpbGUgZmlsZSkgewotCQlyZXR1cm4gZXh0ZW5zaW9uKGZpbGUuZ2V0UGF0aCgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogdGVtcG9yYXJ5IGRpcmVjdG9yaWVzICoqKioqKioqKioKLQotCS8qKgotCSAqIEJ1aWxkIGFuZCByZXR1cm4gYW4gZW1wdHkgdGVtcG9yYXJ5IGRpcmVjdG9yeSB3aXRoIHRoZSBzcGVjaWZpZWQKLQkgKiBuYW1lLiBJZiB0aGUgZGlyZWN0b3J5IGFscmVhZHkgZXhpc3RzLCBpdCB3aWxsIGJlIGNsZWFyZWQgb3V0LgotCSAqIFRoaXMgZGlyZWN0b3J5IHdpbGwgYmUgYSBzdWJkaXJlY3Rvcnkgb2YgdGhlIEphdmEgdGVtcG9yYXJ5IGRpcmVjdG9yeSwKLQkgKiBhcyBpbmRpY2F0ZWQgYnkgdGhlIFN5c3RlbSBwcm9wZXJ0eSAiamF2YS5pby50bXBkaXIiLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgRmlsZSBlbXB0eVRlbXBvcmFyeURpcmVjdG9yeShTdHJpbmcgbmFtZSkgewotCQlGaWxlIGRpciA9IG5ldyBGaWxlKHVzZXJUZW1wb3JhcnlEaXJlY3RvcnkoKSwgbmFtZSk7Ci0JCWlmIChkaXIuZXhpc3RzKCkpIHsKLQkJCWRlbGV0ZURpcmVjdG9yeUNvbnRlbnRzKGRpcik7Ci0JCX0gZWxzZSB7Ci0JCQlkaXIubWtkaXJzKCk7Ci0JCX0KLQkJcmV0dXJuIGRpcjsKLQl9Ci0JCi0JLyoqCi0JICogQnVpbGQgYW5kIHJldHVybiBhbiBlbXB0eSB0ZW1wb3JhcnkgZGlyZWN0b3J5IHdpdGggYQotCSAqIG5hbWUgb2YgInRtcGRpciIuIElmIHRoZSBkaXJlY3RvcnkgYWxyZWFkeSBleGlzdHMsIGl0IHdpbGwgYmUgY2xlYXJlZCBvdXQuCi0JICogVGhpcyBkaXJlY3Rvcnkgd2lsbCBiZSBhIHN1YmRpcmVjdG9yeSBvZiB0aGUgSmF2YSB0ZW1wb3JhcnkgZGlyZWN0b3J5LAotCSAqIGFzIGluZGljYXRlZCBieSB0aGUgU3lzdGVtIHByb3BlcnR5ICJqYXZhLmlvLnRtcGRpciIuCi0JICovCi0JcHVibGljIHN0YXRpYyBGaWxlIGVtcHR5VGVtcG9yYXJ5RGlyZWN0b3J5KCkgewotCQlyZXR1cm4gZW1wdHlUZW1wb3JhcnlEaXJlY3RvcnkoREVGQVVMVF9URU1QT1JBUllfRElSRUNUT1JZX05BTUUpOwotCX0KLQkKLQkvKioKLQkgKiBCdWlsZCBhbmQgcmV0dXJuIGEgdGVtcG9yYXJ5IGRpcmVjdG9yeSB3aXRoIHRoZSBzcGVjaWZpZWQKLQkgKiBuYW1lLiBJZiB0aGUgZGlyZWN0b3J5IGFscmVhZHkgZXhpc3RzLCBpdCB3aWxsIGJlIGxlZnQgdW5jaGFuZ2VkOwotCSAqIGlmIGl0IGRvZXMgbm90IGFscmVhZHkgZXhpc3QsIGl0IHdpbGwgYmUgY3JlYXRlZC4KLQkgKiBUaGlzIGRpcmVjdG9yeSB3aWxsIGJlIGEgc3ViZGlyZWN0b3J5IG9mIHRoZSBKYXZhIHRlbXBvcmFyeSBkaXJlY3RvcnksCi0JICogYXMgaW5kaWNhdGVkIGJ5IHRoZSBTeXN0ZW0gcHJvcGVydHkgImphdmEuaW8udG1wZGlyIi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEZpbGUgdGVtcG9yYXJ5RGlyZWN0b3J5KFN0cmluZyBuYW1lKSB7Ci0JCUZpbGUgZGlyID0gbmV3IEZpbGUodXNlclRlbXBvcmFyeURpcmVjdG9yeSgpLCBuYW1lKTsKLQkJaWYgKCAhIGRpci5leGlzdHMoKSkgewotCQkJZGlyLm1rZGlycygpOwotCQl9Ci0JCXJldHVybiBkaXI7Ci0JfQotCQotCS8qKgotCSAqIEJ1aWxkIGFuZCByZXR1cm4gYSB0ZW1wb3JhcnkgZGlyZWN0b3J5IHdpdGggYSBuYW1lIG9mCi0JICogInRtcGRpciIuIElmIHRoZSBkaXJlY3RvcnkgYWxyZWFkeSBleGlzdHMsIGl0IHdpbGwgYmUgbGVmdCB1bmNoYW5nZWQ7Ci0JICogaWYgaXQgZG9lcyBub3QgYWxyZWFkeSBleGlzdCwgaXQgd2lsbCBiZSBjcmVhdGVkLgotCSAqIFRoaXMgZGlyZWN0b3J5IHdpbGwgYmUgYSBzdWJkaXJlY3Rvcnkgb2YgdGhlIEphdmEgdGVtcG9yYXJ5IGRpcmVjdG9yeSwKLQkgKiBhcyBpbmRpY2F0ZWQgYnkgdGhlIFN5c3RlbSBwcm9wZXJ0eSAiamF2YS5pby50bXBkaXIiLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgRmlsZSB0ZW1wb3JhcnlEaXJlY3RvcnkoKSB7Ci0JCXJldHVybiB0ZW1wb3JhcnlEaXJlY3RvcnkoREVGQVVMVF9URU1QT1JBUllfRElSRUNUT1JZX05BTUUpOwotCX0KLQkKLQkvKioKLQkgKiBCdWlsZCBhbmQgcmV0dXJuIGEgKm5ldyogdGVtcG9yYXJ5IGRpcmVjdG9yeSB3aXRoIHRoZSBzcGVjaWZpZWQKLQkgKiBwcmVmaXguIFRoZSBwcmVmaXggd2lsbCBiZSBhcHBlbmRlZCB3aXRoIGEgbnVtYmVyIHRoYXQKLQkgKiBpcyBpbmNyZW1lbnRlZCwgc3RhcnRpbmcgd2l0aCAxLCB1bnRpbCBhIG5vbi1wcmUtZXhpc3RpbmcgZGlyZWN0b3J5Ci0JICogaXMgZm91bmQgYW5kIHN1Y2Nlc3NmdWxseSBjcmVhdGVkLiBUaGlzIGRpcmVjdG9yeSB3aWxsIGJlIGEKLQkgKiBzdWJkaXJlY3Rvcnkgb2YgdGhlIEphdmEgdGVtcG9yYXJ5IGRpcmVjdG9yeSwgYXMgaW5kaWNhdGVkIGJ5Ci0JICogdGhlIFN5c3RlbSBwcm9wZXJ0eSAiamF2YS5pby50bXBkaXIiLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgRmlsZSBuZXdUZW1wb3JhcnlEaXJlY3RvcnkoU3RyaW5nIHByZWZpeCkgewotCQlpZiAoICEgcHJlZml4LmVuZHNXaXRoKCIuIikpIHsgLy8kTk9OLU5MUy0xJAotCQkJcHJlZml4ID0gcHJlZml4ICsgJy4nOwotCQl9Ci0JCUZpbGUgZGlyOwotCQlpbnQgaSA9IDA7Ci0JCWRvIHsKLQkJCWkrKzsKLQkJCWRpciA9IG5ldyBGaWxlKHVzZXJUZW1wb3JhcnlEaXJlY3RvcnkoKSwgcHJlZml4ICsgaSk7Ci0JCX0gd2hpbGUgKCAhIGRpci5ta2RpcnMoKSk7Ci0JCXJldHVybiBkaXI7Ci0JfQotCQotCS8qKgotCSAqIEJ1aWxkIGFuZCByZXR1cm4gYSAqbmV3KiB0ZW1wb3JhcnkgZGlyZWN0b3J5IHdpdGggYQotCSAqIHByZWZpeCBvZiAidG1wZGlyIi4gVGhpcyBwcmVmaXggd2lsbCBiZSBhcHBlbmRlZCB3aXRoIGEgbnVtYmVyIHRoYXQKLQkgKiBpcyBpbmNyZW1lbnRlZCwgc3RhcnRpbmcgd2l0aCAxLCB1bnRpbCBhIG5vbi1wcmUtZXhpc3RpbmcgZGlyZWN0b3J5Ci0JICogaXMgZm91bmQgYW5kIHN1Y2Nlc3NmdWxseSBjcmVhdGVkLiBUaGlzIGRpcmVjdG9yeSB3aWxsIGJlIGEKLQkgKiBzdWJkaXJlY3Rvcnkgb2YgdGhlIEphdmEgdGVtcG9yYXJ5IGRpcmVjdG9yeSwgYXMgaW5kaWNhdGVkIGJ5Ci0JICogdGhlIFN5c3RlbSBwcm9wZXJ0eSAiamF2YS5pby50bXBkaXIiLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgRmlsZSBuZXdUZW1wb3JhcnlEaXJlY3RvcnkoKSB7Ci0JCXJldHVybiBuZXdUZW1wb3JhcnlEaXJlY3RvcnkoREVGQVVMVF9URU1QT1JBUllfRElSRUNUT1JZX05BTUUpOwotCX0KLQkKLQotCS8vICoqKioqKioqKiogcmVzb3VyY2UgZmlsZXMgKioqKioqKioqKgotCi0JLyoqCi0JICogQnVpbGQgYW5kIHJldHVybiBhIGZpbGUgZm9yIHRoZSBzcGVjaWZpZWQgcmVzb3VyY2UuCi0JICogVGhlIHJlc291cmNlIG5hbWUgbXVzdCBiZSBmdWxseS1xdWFsaWZpZWQsIGkuZS4gaXQgY2Fubm90IGJlIHJlbGF0aXZlCi0JICogdG8gdGhlIHBhY2thZ2UgbmFtZS9kaXJlY3RvcnkuCi0JICogTkI6IFRoZXJlIGlzIGEgYnVnIGluIGpkazEuNC54IHRoZSBwcmV2ZW50cyB1cyBmcm9tIGdldHRpbmcKLQkgKiBhIHJlc291cmNlIHRoYXQgaGFzIHNwYWNlcyAob3Igb3RoZXIgc3BlY2lhbCBjaGFyYWN0ZXJzKSBpbgotCSAqIGl0cyBuYW1lLi4uLiAoc2VlIFN1bidzIEphdmEgYnVnIDQ0NjY0ODUpCi0JICovCi0JcHVibGljIHN0YXRpYyBGaWxlIHJlc291cmNlRmlsZShTdHJpbmcgcmVzb3VyY2VOYW1lKSB0aHJvd3MgVVJJU3ludGF4RXhjZXB0aW9uIHsKLQkJaWYgKCAhIHJlc291cmNlTmFtZS5zdGFydHNXaXRoKCIvIikpIHsgLy8kTk9OLU5MUy0xJAotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbihyZXNvdXJjZU5hbWUpOwotCQl9Ci0JCXJldHVybiByZXNvdXJjZUZpbGUocmVzb3VyY2VOYW1lLCBGaWxlVG9vbHMuY2xhc3MpOwotCX0KLQkKLQkvKioKLQkgKiBCdWlsZCBhbmQgcmV0dXJuIGEgZmlsZSBmb3IgdGhlIHNwZWNpZmllZCByZXNvdXJjZS4KLQkgKiBOQjogVGhlcmUgaXMgYSBidWcgaW4gamRrMS40LnggdGhlIHByZXZlbnRzIHVzIGZyb20gZ2V0dGluZwotCSAqIGEgcmVzb3VyY2UgdGhhdCBoYXMgc3BhY2VzIChvciBvdGhlciBzcGVjaWFsIGNoYXJhY3RlcnMpIGluCi0JICogaXRzIG5hbWUuLi4uIChzZWUgU3VuJ3MgSmF2YSBidWcgNDQ2NjQ4NSkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIEZpbGUgcmVzb3VyY2VGaWxlKFN0cmluZyByZXNvdXJjZU5hbWUsIENsYXNzPD8+IGphdmFDbGFzcykgdGhyb3dzIFVSSVN5bnRheEV4Y2VwdGlvbiB7Ci0JCVVSTCB1cmwgPSBqYXZhQ2xhc3MuZ2V0UmVzb3VyY2UocmVzb3VyY2VOYW1lKTsKLQkJcmV0dXJuIGJ1aWxkRmlsZSh1cmwpOwotCX0KLQkKLQkvKioKLQkgKiBCdWlsZCBhbmQgcmV0dXJuIGEgZmlsZSBmb3IgdGhlIHNwZWNpZmllZCBVUkwuCi0JICogTkI6IFRoZXJlIGlzIGEgYnVnIGluIGpkazEuNC54IHRoZSBwcmV2ZW50cyB1cyBmcm9tIGdldHRpbmcKLQkgKiBhIHJlc291cmNlIHRoYXQgaGFzIHNwYWNlcyAob3Igb3RoZXIgc3BlY2lhbCBjaGFyYWN0ZXJzKSBpbgotCSAqIGl0cyBuYW1lLi4uLiAoc2VlIFN1bidzIEphdmEgYnVnIDQ0NjY0ODUpCi0JICovCi0JcHVibGljIHN0YXRpYyBGaWxlIGJ1aWxkRmlsZShVUkwgdXJsKSB0aHJvd3MgVVJJU3ludGF4RXhjZXB0aW9uIHsKLQkJcmV0dXJuIGJ1aWxkRmlsZSh1cmwuZ2V0RmlsZSgpKTsKLQl9Ci0JCi0JLyoqCi0JICogQnVpbGQgYW5kIHJldHVybiBhIGZpbGUgZm9yIHRoZSBzcGVjaWZpZWQgZmlsZSBuYW1lLgotCSAqIE5COiBUaGVyZSBpcyBhIGJ1ZyBpbiBqZGsxLjQueCB0aGUgcHJldmVudHMgdXMgZnJvbSBnZXR0aW5nCi0JICogYSByZXNvdXJjZSB0aGF0IGhhcyBzcGFjZXMgKG9yIG90aGVyIHNwZWNpYWwgY2hhcmFjdGVycykgaW4KLQkgKiBpdHMgbmFtZS4uLi4gKHNlZSBTdW4ncyBKYXZhIGJ1ZyA0NDY2NDg1KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgRmlsZSBidWlsZEZpbGUoU3RyaW5nIGZpbGVOYW1lKSB0aHJvd3MgVVJJU3ludGF4RXhjZXB0aW9uIHsKLQkJVVJJIHVyaSA9IG5ldyBVUkkoZmlsZU5hbWUpOwotCQlGaWxlIGZpbGUgPSBuZXcgRmlsZSh1cmkuZ2V0UGF0aCgpKTsKLQkJcmV0dXJuIGZpbGU7Ci0JfQotCQotCi0JLy8gKioqKioqKioqKiAiY2Fub25pY2FsIiBmaWxlcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgZmlsZSBpbnRvIGEgImNhbm9uaWNhbCIgZmlsZS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEZpbGUgY2Fub25pY2FsRmlsZShGaWxlIGZpbGUpIHsKLQkJdHJ5IHsKLQkJCXJldHVybiBmaWxlLmdldENhbm9uaWNhbEZpbGUoKTsKLQkJfSBjYXRjaCAoSU9FeGNlcHRpb24gaW9leGNlcHRpb24pIHsKLQkJCS8vIHNldHRsZSBmb3IgdGhlIGFic29sdXRlIGZpbGUKLQkJCXJldHVybiBmaWxlLmdldEFic29sdXRlRmlsZSgpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIEJ1aWxkIGFuIGl0ZXJhdG9yIHRoYXQgd2lsbCBjb252ZXJ0IHRoZSBzcGVjaWZpZWQgZmlsZXMKLQkgKiBpbnRvICJjYW5vbmljYWwiIGZpbGVzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgSXRlcmF0b3I8RmlsZT4gY2Fub25pY2FsRmlsZXMoSXRlcmF0b3I8RmlsZT4gZmlsZXMpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yPEZpbGUsIEZpbGU+KGZpbGVzKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBGaWxlIHRyYW5zZm9ybShGaWxlIG5leHQpIHsKLQkJCQlyZXR1cm4gY2Fub25pY2FsRmlsZShuZXh0KTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JLyoqCi0JICogQnVpbGQgYW4gaXRlcmF0b3IgdGhhdCB3aWxsIGNvbnZlcnQgdGhlIHNwZWNpZmllZCBmaWxlcwotCSAqIGludG8gImNhbm9uaWNhbCIgZmlsZXMuCi0JICovCi0JcHVibGljIHN0YXRpYyBJdGVyYXRvcjxGaWxlPiBjYW5vbmljYWxGaWxlcyhDb2xsZWN0aW9uPEZpbGU+IGZpbGVzKSB7Ci0JCXJldHVybiBjYW5vbmljYWxGaWxlcyhmaWxlcy5pdGVyYXRvcigpKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkIGZpbGUgbmFtZSBpbnRvIGEgImNhbm9uaWNhbCIgZmlsZSBuYW1lLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGNhbm9uaWNhbEZpbGVOYW1lKFN0cmluZyBmaWxlTmFtZSkgewotCQlyZXR1cm4gY2Fub25pY2FsRmlsZShuZXcgRmlsZShmaWxlTmFtZSkpLmdldEFic29sdXRlUGF0aCgpOwotCX0KLQkKLQkvKioKLQkgKiBCdWlsZCBhbiBpdGVyYXRvciB0aGF0IHdpbGwgY29udmVydCB0aGUgc3BlY2lmaWVkIGZpbGUgbmFtZXMKLQkgKiBpbnRvICJjYW5vbmljYWwiIGZpbGUgbmFtZXMuCi0JICovCi0JcHVibGljIHN0YXRpYyBJdGVyYXRvcjxTdHJpbmc+IGNhbm9uaWNhbEZpbGVOYW1lcyhJdGVyYXRvcjxTdHJpbmc+IGZpbGVOYW1lcykgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8U3RyaW5nLCBTdHJpbmc+KGZpbGVOYW1lcykgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShTdHJpbmcgbmV4dCkgewotCQkJCXJldHVybiBjYW5vbmljYWxGaWxlTmFtZShuZXh0KTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JLyoqCi0JICogQnVpbGQgYW4gaXRlcmF0b3IgdGhhdCB3aWxsIGNvbnZlcnQgdGhlIHNwZWNpZmllZCBmaWxlIG5hbWVzCi0JICogaW50byAiY2Fub25pY2FsIiBmaWxlIG5hbWVzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgSXRlcmF0b3I8U3RyaW5nPiBjYW5vbmljYWxGaWxlTmFtZXMoQ29sbGVjdGlvbjxTdHJpbmc+IGZpbGVOYW1lcykgewotCQlyZXR1cm4gY2Fub25pY2FsRmlsZU5hbWVzKGZpbGVOYW1lcy5pdGVyYXRvcigpKTsKLQl9Ci0JCi0KLQkvLyAqKioqKioqKioqIGZpbGUgbmFtZSB2YWxpZGF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgZmlsZSBuYW1lIGlzIGludmFsaWQuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGZpbGVOYW1lSXNJbnZhbGlkKFN0cmluZyBmaWxlbmFtZSkgewotCQlyZXR1cm4gISBmaWxlTmFtZUlzVmFsaWQoZmlsZW5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgZmlsZSBuYW1lIGlzIHZhbGlkLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBmaWxlTmFtZUlzVmFsaWQoU3RyaW5nIGZpbGVuYW1lKSB7Ci0JCWludCBsZW4gPSBmaWxlbmFtZS5sZW5ndGgoKTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsZW47IGkrKykgewotCQkJY2hhciBmaWxlbmFtZUNoYXIgPSBmaWxlbmFtZS5jaGFyQXQoaSk7Ci0JCQlpZiAoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKElOVkFMSURfRklMRU5BTUVfQ0hBUkFDVEVSUywgZmlsZW5hbWVDaGFyKSkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBpbGxlZ2FsIGNoYXJhY3RlcnMgaW4gdGhlIHNwZWNpZmllZCBmaWxlIG5hbWUgdG8KLQkgKiB0aGUgc3BlY2lmaWVkIGNoYXJhY3RlciBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY29udmVydFRvVmFsaWRGaWxlTmFtZShTdHJpbmcgZmlsZW5hbWUsIGNoYXIgcmVwbGFjZW1lbnRDaGFyKSB7Ci0JCWludCBsZW4gPSBmaWxlbmFtZS5sZW5ndGgoKTsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKGxlbik7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKLQkJCWNoYXIgZmlsZW5hbWVDaGFyID0gZmlsZW5hbWUuY2hhckF0KGkpOwotCQkJaWYgKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhJTlZBTElEX0ZJTEVOQU1FX0NIQVJBQ1RFUlMsIGZpbGVuYW1lQ2hhcikpIHsKLQkJCQlzYi5hcHBlbmQocmVwbGFjZW1lbnRDaGFyKTsKLQkJCX0gZWxzZSB7Ci0JCQkJc2IuYXBwZW5kKGZpbGVuYW1lQ2hhcik7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgaWxsZWdhbCBjaGFyYWN0ZXJzIGluIHRoZSBzcGVjaWZpZWQgZmlsZSBuYW1lIHRvCi0JICogcGVyaW9kcyAoJy4nKSBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY29udmVydFRvVmFsaWRGaWxlTmFtZShTdHJpbmcgZmlsZW5hbWUpIHsKLQkJcmV0dXJuIGNvbnZlcnRUb1ZhbGlkRmlsZU5hbWUoZmlsZW5hbWUsICcuJyk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBmaWxlIG5hbWUgaXMgInJlc2VydmVkIgotCSAqIChpLmUuIGl0IGNhbm5vdCBiZSB1c2VkIGZvciAidXNlciIgZmlsZXMpLiBXaW5kb3dzIHJlc2VydmVzCi0JICogYSBudW1iZXIgb2YgZmlsZSBuYW1lcyAoZS5nLiBDT04sIEFVWCwgUFJOKS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gZmlsZU5hbWVJc1Jlc2VydmVkKFN0cmluZyBmaWxlTmFtZSkgewotCQlpZiAoZXhlY3V0aW5nT25XaW5kb3dzKCkpIHsKLQkJCXJldHVybiBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoV0lORE9XU19SRVNFUlZFRF9GSUxFX05BTUVTLCBmaWxlTmFtZS50b0xvd2VyQ2FzZSgpKTsKLQkJfQotCQlyZXR1cm4gZmFsc2U7CS8vIFVuaXggZG9lcyBub3QgaGF2ZSBhbnkgInJlc2VydmVkIiBmaWxlIG5hbWVzIChJIHRoaW5rLi4uKQotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgZmlsZSBjb250YWlucyBhbnkgInJlc2VydmVkIgotCSAqIGNvbXBvbmVudHMuCi0JICogV2luZG93cyByZXNlcnZlcyBhIG51bWJlciBvZiBmaWxlIG5hbWVzIChlLmcuIENPTiwgQVVYLCBQUk4pOwotCSAqIGFuZCB0aGVzZSBmaWxlIG5hbWVzIGNhbm5vdCBiZSB1c2VkIGZvciBlaXRoZXIgdGhlIG5hbWVzIG9mCi0JICogZmlsZXMgb3IgZGlyZWN0b3JpZXMuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGZpbGVIYXNBbnlSZXNlcnZlZENvbXBvbmVudHMoRmlsZSBmaWxlKSB7Ci0JCUZpbGUgdGVtcCA9IGZpbGU7Ci0JCXdoaWxlICh0ZW1wICE9IG51bGwpIHsKLQkJCWlmIChmaWxlTmFtZUlzUmVzZXJ2ZWQodGVtcC5nZXROYW1lKCkpKSB7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0JCQl0ZW1wID0gdGVtcC5nZXRQYXJlbnRGaWxlKCk7Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBzaG9ydGVuZWQgZmlsZSBuYW1lcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gYSBzaG9ydGVyIHZlcnNpb24gb2YgdGhlIGFic29sdXRlIGZpbGUgbmFtZSBmb3IgdGhlIHNwZWNpZmllZCBmaWxlLgotCSAqIFRoZSBzaG9ydGVyIHZlcnNpb24gd2lsbCBub3QgYmUgbG9uZ2VyIHRoYW4gdGhlIG1heGltdW0gbGVuZ3RoLgotCSAqIFRoZSBmaXJzdCBkaXJlY3RvcnkgKHVzdWFsbHkgdGhlIGRyaXZlIGxldHRlcikgYW5kIHRoZSBmaWxlIG5hbWUgb3IgdGhlCi0JICogbGFzdCBkaXJlY3Rvcnkgd2lsbCBhbHdheXMgYmUgYWRkZWQgdG8gdGhlIGdlbmVyYXRlZCBzdHJpbmcgcmVnYXJkbGVzcyBvZgotCSAqIHRoZSBtYXhpbXVtIGxlbmd0aCBhbGxvd2VkLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHNob3J0ZW5GaWxlTmFtZShVUkwgdXJsKSB7Ci0JCXJldHVybiBzaG9ydGVuRmlsZU5hbWUodXJsLCBNQVhJTVVNX1NIT1JURU5FRF9GSUxFX05BTUVfTEVOR1RIKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBzaG9ydGVyIHZlcnNpb24gb2YgdGhlIGFic29sdXRlIGZpbGUgbmFtZSBmb3IgdGhlIHNwZWNpZmllZCBmaWxlLgotCSAqIFRoZSBzaG9ydGVyIHZlcnNpb24gd2lsbCBub3QgYmUgbG9uZ2VyIHRoYW4gdGhlIG1heGltdW0gbGVuZ3RoLgotCSAqIFRoZSBmaXJzdCBkaXJlY3RvcnkgKHVzdWFsbHkgdGhlIGRyaXZlIGxldHRlcikgYW5kIHRoZSBmaWxlIG5hbWUgb3IgdGhlCi0JICogbGFzdCBkaXJlY3Rvcnkgd2lsbCBhbHdheXMgYmUgYWRkZWQgdG8gdGhlIGdlbmVyYXRlZCBzdHJpbmcgcmVnYXJkbGVzcyBvZgotCSAqIHRoZSBtYXhpbXVtIGxlbmd0aCBhbGxvd2VkLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHNob3J0ZW5GaWxlTmFtZShVUkwgdXJsLCBpbnQgbWF4TGVuZ3RoKSB7Ci0JCUZpbGUgZmlsZTsKLQkJdHJ5IHsKLQkJCWZpbGUgPSBidWlsZEZpbGUodXJsKTsKLQkJfSBjYXRjaCAoVVJJU3ludGF4RXhjZXB0aW9uIGUpIHsKLQkJCWZpbGUgPSBuZXcgRmlsZSh1cmwuZ2V0RmlsZSgpKTsKLQkJfQotCQlyZXR1cm4gc2hvcnRlbkZpbGVOYW1lKGZpbGUsIG1heExlbmd0aCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgc2hvcnRlciB2ZXJzaW9uIG9mIHRoZSBhYnNvbHV0ZSBmaWxlIG5hbWUgZm9yIHRoZSBzcGVjaWZpZWQgZmlsZS4KLQkgKiBUaGUgc2hvcnRlciB2ZXJzaW9uIHdpbGwgbm90IGJlIGxvbmdlciB0aGFuIHRoZSBtYXhpbXVtIGxlbmd0aC4KLQkgKiBUaGUgZmlyc3QgZGlyZWN0b3J5ICh1c3VhbGx5IHRoZSBkcml2ZSBsZXR0ZXIpIGFuZCB0aGUgZmlsZSBuYW1lIG9yIHRoZQotCSAqIGxhc3QgZGlyZWN0b3J5IHdpbGwgYWx3YXlzIGJlIGFkZGVkIHRvIHRoZSBnZW5lcmF0ZWQgc3RyaW5nIHJlZ2FyZGxlc3Mgb2YKLQkgKiB0aGUgbWF4aW11bSBsZW5ndGggYWxsb3dlZC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBzaG9ydGVuRmlsZU5hbWUoRmlsZSBmaWxlKSB7Ci0JCXJldHVybiBzaG9ydGVuRmlsZU5hbWUoZmlsZSwgTUFYSU1VTV9TSE9SVEVORURfRklMRV9OQU1FX0xFTkdUSCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgc2hvcnRlciB2ZXJzaW9uIG9mIHRoZSBhYnNvbHV0ZSBmaWxlIG5hbWUgZm9yIHRoZSBzcGVjaWZpZWQgZmlsZS4KLQkgKiBUaGUgc2hvcnRlciB2ZXJzaW9uIHdpbGwgbm90IGJlIGxvbmdlciB0aGFuIHRoZSBtYXhpbXVtIGxlbmd0aC4KLQkgKiBUaGUgZmlyc3QgZGlyZWN0b3J5ICh1c3VhbGx5IHRoZSBkcml2ZSBsZXR0ZXIpIGFuZCB0aGUgZmlsZSBuYW1lIG9yIHRoZQotCSAqIGxhc3QgZGlyZWN0b3J5IHdpbGwgYWx3YXlzIGJlIGFkZGVkIHRvIHRoZSBnZW5lcmF0ZWQgc3RyaW5nIHJlZ2FyZGxlc3Mgb2YKLQkgKiB0aGUgbWF4aW11bSBsZW5ndGggYWxsb3dlZC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBzaG9ydGVuRmlsZU5hbWUoRmlsZSBmaWxlLCBpbnQgbWF4TGVuZ3RoKSB7Ci0JCVN0cmluZyBhYnNvbHV0ZUZpbGVOYW1lID0gY2Fub25pY2FsRmlsZShmaWxlKS5nZXRBYnNvbHV0ZVBhdGgoKTsKLQkJaWYgKGFic29sdXRlRmlsZU5hbWUubGVuZ3RoKCkgPD0gbWF4TGVuZ3RoKSB7Ci0JCQkvLyBubyBuZWVkIHRvIHNob3J0ZW4KLQkJCXJldHVybiBhYnNvbHV0ZUZpbGVOYW1lOwotCQl9Ci0KLQkJLy8gYnJlYWsgZG93biB0aGUgcGF0aCBpbnRvIGl0cyBjb21wb25lbnRzCi0JCVN0cmluZyBmcyA9IEZpbGUuc2VwYXJhdG9yOwotCQlTdHJpbmdbXSBwYXRocyA9IGFic29sdXRlRmlsZU5hbWUuc3BsaXQoJ1xcJyArIGZzKTsKLQotCQlpZiAocGF0aHMubGVuZ3RoIDw9IDEpIHsKLQkJCS8vIGUuZy4gIkM6XCIKLQkJCXJldHVybiBwYXRoc1swXTsKLQkJfQotCi0JCWlmIChwYXRocy5sZW5ndGggPT0gMikgewotCQkJLy8gZS5nLiAiQzpcTXlSZWFsbHlMb25nRmlsZU5hbWUuZXh0IiBvciAiQzpcTXlSZWFsbHlMb25nRGlyZWN0b3J5TmFtZSIKLQkJCS8vIHJldHVybiB0aGUgY29tcGxldGUgZmlsZSBuYW1lIHNpbmNlIHRoaXMgaXMgYSBtaW5pbXVtIHJlcXVpcmVtZW50LAotCQkJLy8gcmVnYXJkbGVzcyBvZiB0aGUgbWF4aW11bSBsZW5ndGggYWxsb3dlZAotCQkJcmV0dXJuIGFic29sdXRlRmlsZU5hbWU7Ci0JCX0KLQotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKLQkJc2IuYXBwZW5kKHBhdGhzWzBdKTsJCS8vIGFsd2F5cyBhZGQgdGhlIGZpcnN0IGRpcmVjdG9yeSwgd2hpY2ggaXMgdXN1YWxseSB0aGUgZHJpdmUgbGV0dGVyCi0KLQkJLy8gS2VlcCB0aGUgaW5kZXggb2YgaW5zZXJ0aW9uIGludG8gdGhlIHN0cmluZyBidWZmZXIKLQkJaW50IGluc2VydEluZGV4ID0gc2IubGVuZ3RoKCk7Ci0KLQkJc2IuYXBwZW5kKGZzKTsKLQkJc2IuYXBwZW5kKHBhdGhzW3BhdGhzLmxlbmd0aCAtIDFdKTsJCS8vIGFwcGVuZCB0aGUgZmlsZSBuYW1lIG9yIHRoZSBsYXN0IGRpcmVjdG9yeQotCi0JCW1heExlbmd0aCAtPSA0OyAgICAgICAgICAgICAgICAgICAgICAvLyAtNCBmb3IgIi8uLi4iCi0KLQkJaW50IGN1cnJlbnRMZW5ndGggPSBzYi5sZW5ndGgoKSAtIDQ7IC8vIC00IGZvciAiLy4uLiIKLQkJaW50IGxlZnRJbmRleCA9IDE7ICAgICAgICAgICAgICAgICAgIC8vICAxIHRvIHNraXAgdGhlIHJvb3QgZGlyZWN0b3J5Ci0JCWludCByaWdodEluZGV4ID0gcGF0aHMubGVuZ3RoIC0gMjsgICAvLyAtMSBmb3IgdGhlIGZpbGUgbmFtZSBvciB0aGUgbGFzdCBkaXJlY3RvcnkKLQotCQlib29sZWFuIGNhbkFkZEZyb21MZWZ0ID0gdHJ1ZTsKLQkJYm9vbGVhbiBjYW5BZGRGcm9tUmlnaHQgPSB0cnVlOwotCi0JCS8vIEFkZCBlYWNoIGRpcmVjdG9yeSwgdGhlIGluc2VydGlvbiBpcyBnb2luZyBpbiBib3RoIGRpcmVjdGlvbjogbGVmdCBhbmQKLQkJLy8gcmlnaHQsIG9uY2UgYSBzaWRlIGNhbid0IGJlIGFkZGVkLCB0aGUgb3RoZXIgc2lkZSBpcyBzdGlsbCBjb250aW51aW5nCi0JCS8vIHVudGlsIGJvdGggY2FuJ3QgYWRkIGFueW1vcmUKLQkJd2hpbGUgKHRydWUpIHsKLQkJCWlmICghY2FuQWRkRnJvbUxlZnQgJiYgIWNhbkFkZEZyb21SaWdodCkKLQkJCQlicmVhazsKLQotCQkJaWYgKGNhbkFkZEZyb21SaWdodCkgewotCQkJCVN0cmluZyByaWdodERpcmVjdG9yeSA9IHBhdGhzW3JpZ2h0SW5kZXhdOwotCQkJCWludCByaWdodExlbmd0aCA9IHJpZ2h0RGlyZWN0b3J5Lmxlbmd0aCgpOwotCi0JCQkJLy8gQWRkIHRoZSBkaXJlY3Rvcnkgb24gdGhlIHJpZ2h0IHNpZGUgb2YgdGhlIGxvb3AKLQkJCQlpZiAoY3VycmVudExlbmd0aCArIHJpZ2h0TGVuZ3RoICsgMSA8PSBtYXhMZW5ndGgpIHsKLQkJCQkJc2IuaW5zZXJ0KGluc2VydEluZGV4LCAgICAgZnMpOwotCQkJCQlzYi5pbnNlcnQoaW5zZXJ0SW5kZXggKyAxLCByaWdodERpcmVjdG9yeSk7Ci0KLQkJCQkJY3VycmVudExlbmd0aCArPSByaWdodExlbmd0aCArIDE7Ci0JCQkJCXJpZ2h0SW5kZXgtLTsKLQotCQkJCQkvLyBUaGUgcmlnaHQgc2lkZSBpcyBub3cgb3ZlcmxhcHBpbmcgdGhlIGxlZnQgc2lkZSwgdGhhdCBtZWFucwotCQkJCQkvLyB3ZSBjYW4ndCBhZGQgZnJvbSB0aGUgcmlnaHQgc2lkZSBhbnltb3JlCi0JCQkJCWlmIChsZWZ0SW5kZXggPj0gcmlnaHRJbmRleCkgewotCQkJCQkJY2FuQWRkRnJvbVJpZ2h0ID0gZmFsc2U7Ci0JCQkJCX0KLQkJCQl9IGVsc2UgewotCQkJCQljYW5BZGRGcm9tUmlnaHQgPSBmYWxzZTsKLQkJCQl9Ci0JCQl9Ci0KLQkJCWlmIChjYW5BZGRGcm9tTGVmdCkgewotCQkJCVN0cmluZyBsZWZ0RGlyZWN0b3J5ID0gcGF0aHNbbGVmdEluZGV4XTsKLQkJCQlpbnQgbGVmdExlbmd0aCA9IGxlZnREaXJlY3RvcnkubGVuZ3RoKCk7Ci0KLQkJCQkvLyBBZGQgdGhlIGRpcmVjdG9yeSBvbiB0aGUgbGVmdCBzaWRlIG9mIHRoZSBsb29wCi0JCQkJaWYgKGN1cnJlbnRMZW5ndGggKyBsZWZ0TGVuZ3RoICsgMSA8PSBtYXhMZW5ndGgpIHsKLQkJCQkJc2IuaW5zZXJ0KGluc2VydEluZGV4LCAgICAgZnMpOwotCQkJCQlzYi5pbnNlcnQoaW5zZXJ0SW5kZXggKyAxLCBsZWZ0RGlyZWN0b3J5KTsKLQotCQkJCQlpbnNlcnRJbmRleCArPSBsZWZ0TGVuZ3RoICsgMTsKLQkJCQkJY3VycmVudExlbmd0aCArPSBsZWZ0TGVuZ3RoICsgMTsKLQkJCQkJbGVmdEluZGV4Kys7Ci0KLQkJCQkJLy8gVGhlIGxlZnQgc2lkZSBpcyBub3cgb3ZlcmxhcHBpbmcgdGhlIHJpZ2h0IHNpZGUsIHRoYXQgbWVhbnMKLQkJCQkJLy8gd2UgY2FuJ3QgYWRkIGZyb20gdGhlIGxlZnQgc2lkZSBhbnltb3JlCi0JCQkJCWlmIChsZWZ0SW5kZXggPj0gcmlnaHRJbmRleCkgewotCQkJCQkJY2FuQWRkRnJvbUxlZnQgPSBmYWxzZTsKLQkJCQkJfQotCQkJCX0gZWxzZSB7Ci0JCQkJCWNhbkFkZEZyb21MZWZ0ID0gZmFsc2U7Ci0JCQkJfQotCQkJfQotCQl9Ci0KLQkJaWYgKGxlZnRJbmRleCA8PSByaWdodEluZGV4KSB7Ci0JCQlzYi5pbnNlcnQoaW5zZXJ0SW5kZXgsIGZzKTsKLQkJCXNiLmluc2VydChpbnNlcnRJbmRleCArIDEsICIuLi4iKTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0KLQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHN5c3RlbSBwcm9wZXJ0aWVzICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiBhIGZpbGUgcmVwcmVzZW50aW5nIHRoZSB1c2VyJ3MgaG9tZSBkaXJlY3RvcnkuCi0JICovCi0JcHVibGljIHN0YXRpYyBGaWxlIHVzZXJIb21lRGlyZWN0b3J5KCkgewotCQlyZXR1cm4gbmV3IEZpbGUoVVNFUl9IT01FX0RJUkVDVE9SWV9OQU1FKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIGEgZmlsZSByZXByZXNlbnRpbmcgdGhlIHVzZXIncyB0ZW1wb3JhcnkgZGlyZWN0b3J5LgotCSAqLwotCXB1YmxpYyBzdGF0aWMgRmlsZSB1c2VyVGVtcG9yYXJ5RGlyZWN0b3J5KCkgewotCQlyZXR1cm4gbmV3IEZpbGUoVVNFUl9URU1QT1JBUllfRElSRUNUT1JZX05BTUUpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gYSBmaWxlIHJlcHJlc2VudGluZyB0aGUgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEZpbGUgY3VycmVudFdvcmtpbmdEaXJlY3RvcnkoKSB7Ci0JCXJldHVybiBuZXcgRmlsZShDVVJSRU5UX1dPUktJTkdfRElSRUNUT1JZX05BTUUpOwotCX0KLQkKLQotCS8vICoqKioqKioqKiogbWlzY2VsbGFuZW91cyAqKioqKioqKioqCi0KLQlwcml2YXRlIHN0YXRpYyBib29sZWFuIGV4ZWN1dGluZ09uV2luZG93cygpIHsKLQkJcmV0dXJuIGV4ZWN1dGluZ09uKCJXaW5kb3dzIik7IC8vJE5PTi1OTFMtMSQKLQl9Ci0KLS8vCXByaXZhdGUgc3RhdGljIGJvb2xlYW4gZXhlY3V0aW5nT25MaW51eCgpIHsKLS8vCQlyZXR1cm4gZXhlY3V0aW5nT24oIkxpbnV4Iik7Ci0vLwl9Ci0vLwotCXByaXZhdGUgc3RhdGljIGJvb2xlYW4gZXhlY3V0aW5nT24oU3RyaW5nIG9zTmFtZSkgewotCQlyZXR1cm4gU3lzdGVtLmdldFByb3BlcnR5KCJvcy5uYW1lIikuaW5kZXhPZihvc05hbWUpICE9IC0xOyAvLyROT04tTkxTLTEkCi0JfQotCi0JLyoqCi0JICogUmV0dXJuIG9ubHkgdGhlIGZpbGVzIHRoYXQgZml0IHRoZSBmaWx0ZXIuCi0JICogRmlsZSNmaWxlcyhGaWxlRmlsdGVyIGZpbGVGaWx0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyBJdGVyYXRvcjxGaWxlPiBmaWx0ZXIoSXRlcmF0b3I8RmlsZT4gZmlsZXMsIGZpbmFsIEZpbGVGaWx0ZXIgZmlsZUZpbHRlcikgewotCQlyZXR1cm4gbmV3IEZpbHRlcmluZ0l0ZXJhdG9yPEZpbGUsIEZpbGU+KGZpbGVzKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBib29sZWFuIGFjY2VwdChGaWxlIG5leHQpIHsKLQkJCQlyZXR1cm4gZmlsZUZpbHRlci5hY2NlcHQobmV4dCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgZmlsZSB0aGF0IGlzIGEgcmUtc3BlY2lmaWNhdGlvbiBvZiB0aGUgc3BlY2lmaWVkCi0JICogZmlsZSwgcmVsYXRpdmUgdG8gdGhlIHNwZWNpZmllZCBkaXJlY3RvcnkuCi0JICogICAgIExpbnV4L1VuaXgvTWFjOgotCSAqICAgICAgICAgY29udmVydFRvUmVsYXRpdmVGaWxlKC9mb28vYmFyL2Jhei5qYXZhLCAvZm9vKQotCSAqICAgICAgICAgICAgID0+IGJhci9iYXouamF2YQotCSAqICAgICBXaW5kb3dzOgotCSAqICAgICAgICAgY29udmVydFRvUmVsYXRpdmVGaWxlKEM6XGZvb1xiYXJcYmF6LmphdmEsIEM6XGZvbykKLQkgKiAgICAgICAgICAgICA9PiBiYXIvYmF6LmphdmEKLQkgKiBUaGUgZmlsZSBjYW4gYmUgZWl0aGVyIGEgZmlsZSBvciBhIGRpcmVjdG9yeTsgdGhlIGRpcmVjdG9yeQotCSAqICpzaG91bGQqIGJlIGEgZGlyZWN0b3J5LgotCSAqIElmIHRoZSBmaWxlIGlzIGFscmVhZHkgcmVsYXRpdmUgb3IgaXQgY2Fubm90IGJlIG1hZGUgcmVsYXRpdmUKLQkgKiB0byB0aGUgZGlyZWN0b3J5LCBpdCB3aWxsIGJlIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiAKLQkgKiBOQjogVGhpcyBtZXRob2QgaGFzIGJlZW4gdGVzdGVkIG9uIFdpbmRvd3MgYW5kIExpbnV4LAotCSAqIGJ1dCBub3QgTWFjIChidXQgdGhlIE1hYyBpcyBVbml4LWJhc2VkIHRoZXNlIGRheXMsIHNvCi0JICogaXQgc2hvdWxkbid0IGJlIGEgcHJvYmxlbS4uLikuCi0JICovCi0JcHVibGljIHN0YXRpYyBGaWxlIGNvbnZlcnRUb1JlbGF0aXZlRmlsZShmaW5hbCBGaWxlIGZpbGUsIGZpbmFsIEZpbGUgZGlyKSB7Ci0JCS8vIGNoZWNrIHdoZXRoZXIgdGhlIGZpbGUgaXMgYWxyZWFkeSByZWxhdGl2ZQotCQlpZiAoICEgZmlsZS5pc0Fic29sdXRlKCkpIHsKLQkJCXJldHVybiBmaWxlOwkJLy8gcmV0dXJuIHVuY2hhbmdlZAotCQl9Ci0KLQkJRmlsZSBjRmlsZSA9IGNhbm9uaWNhbEZpbGUoZmlsZSk7Ci0JCUZpbGUgY0RpciA9IGNhbm9uaWNhbEZpbGUoZGlyKTsKLQotCQkvLyB0aGUgdHdvIGFyZSB0aGUgc2FtZSBkaXJlY3RvcnkKLQkJaWYgKGNGaWxlLmVxdWFscyhjRGlyKSkgewotCQkJcmV0dXJuIG5ldyBGaWxlKCIuIik7IC8vJE5PTi1OTFMtMSQKLQkJfQotCi0JCUZpbGVbXSBmaWxlUGF0aEZpbGVzID0gcGF0aEZpbGVzKGNGaWxlKTsKLQkJRmlsZVtdIGRpclBhdGhGaWxlcyA9IHBhdGhGaWxlcyhjRGlyKTsKLQotCQkvLyBXaW5kb3dzIG9ubHkgKD8pOiB0aGUgcm9vdHMgYXJlIGRpZmZlcmVudCAtIGUuZy4gRDpcIHZzLiBDOlwKLQkJaWYgKCAhIGRpclBhdGhGaWxlc1swXS5lcXVhbHMoZmlsZVBhdGhGaWxlc1swXSkpIHsKLQkJCXJldHVybiBmaWxlOwkJLy8gcmV0dXJuIHVuY2hhbmdlZAotCQl9Ci0KLQkJLy8gYXQgdGhpcyBwb2ludCB3ZSBrbm93IHRoZSByb290IGlzIHRoZSBzYW1lLCBub3cgZmluZCBob3cgbXVjaCBpcyBpbiBjb21tb24KLQkJaW50IGkgPSAwOwkJLy8gdGhpcyB3aWxsIHBvaW50IGF0IHRoZSBmaXJzdCBtaXNjb21wYXJlCi0JCXdoaWxlICgoaSA8IGRpclBhdGhGaWxlcy5sZW5ndGgpICYmIChpIDwgZmlsZVBhdGhGaWxlcy5sZW5ndGgpKSB7Ci0JCQlpZiAoZGlyUGF0aEZpbGVzW2ldLmVxdWFscyhmaWxlUGF0aEZpbGVzW2ldKSkgewotCQkJCWkrKzsKLQkJCX0gZWxzZSB7Ci0JCQkJYnJlYWs7Ci0JCQl9Ci0JCX0KLQkJLy8gc2F2ZSBvdXIgY3VycmVudCBwb3NpdGlvbgotCQlpbnQgZmlyc3RNaXNtYXRjaCA9IGk7Ci0KLQkJLy8gY2hlY2sgd2hldGhlciB0aGUgZmlsZSBpcyBBQk9WRSB0aGUgZGlyZWN0b3J5OiAuLi8uLgotCQlpZiAoZmlyc3RNaXNtYXRjaCA9PSBmaWxlUGF0aEZpbGVzLmxlbmd0aCkgewotCQkJcmV0dXJuIHJlbGF0aXZlUGFyZW50RmlsZShkaXJQYXRoRmlsZXMubGVuZ3RoIC0gZmlyc3RNaXNtYXRjaCk7Ci0JCX0KLQotCQkvLyBidWlsZCBhIG5ldyBmaWxlIGZyb20gdGhlIHBhdGggYmV5b25kIHRoZSBtYXRjaGluZyBwb3J0aW9ucwotCQlGaWxlIGRpZmYgPSBuZXcgRmlsZShmaWxlUGF0aEZpbGVzW2ldLmdldE5hbWUoKSk7Ci0JCXdoaWxlICgrK2kgPCBmaWxlUGF0aEZpbGVzLmxlbmd0aCkgewotCQkJZGlmZiA9IG5ldyBGaWxlKGRpZmYsIGZpbGVQYXRoRmlsZXNbaV0uZ2V0TmFtZSgpKTsKLQkJfQotCi0JCS8vIGNoZWNrIHdoZXRoZXIgdGhlIGZpbGUgaXMgQkVMT1cgdGhlIGRpcmVjdG9yeTogc3ViZGlyMS9zdWJkaXIyL2ZpbGUuZXh0Ci0JCWlmIChmaXJzdE1pc21hdGNoID09IGRpclBhdGhGaWxlcy5sZW5ndGgpIHsKLQkJCXJldHVybiBkaWZmOwotCQl9Ci0KLQkJLy8gdGhlIGZpbGUgbXVzdCBiZSBhIFBFRVIgb2YgdGhlIGRpcmVjdG9yeTogLi4vLi4vc3ViZGlyMS9zdWJkaXIyL2ZpbGUuZXh0Ci0JCXJldHVybiBuZXcgRmlsZShyZWxhdGl2ZVBhcmVudEZpbGUoZGlyUGF0aEZpbGVzLmxlbmd0aCAtIGZpcnN0TWlzbWF0Y2gpLCBkaWZmLmdldFBhdGgoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgZmlsZSB0aGF0IGlzIGEgcmUtc3BlY2lmaWNhdGlvbiBvZiB0aGUgc3BlY2lmaWVkCi0JICogZmlsZSwgcmVsYXRpdmUgdG8gdGhlIGN1cnJlbnQgd29ya2luZyBkaXJlY3RvcnkuCi0JICogICAgIExpbnV4L1VuaXgvTWFjIChDV0QgPSAvZm9vKToKLQkgKiAgICAgICAgIGNvbnZlcnRUb1JlbGF0aXZlRmlsZSgvZm9vL2Jhci9iYXouamF2YSkKLQkgKiAgICAgICAgICAgICA9PiBiYXIvYmF6LmphdmEKLQkgKiAgICAgV2luZG93cyAoQ1dEID0gQzpcZm9vKToKLQkgKiAgICAgICAgIGNvbnZlcnRUb1JlbGF0aXZlRmlsZShDOlxmb29cYmFyXGJhei5qYXZhKQotCSAqICAgICAgICAgICAgID0+IGJhci9iYXouamF2YQotCSAqIFRoZSBmaWxlIGNhbiBiZSBlaXRoZXIgYSBmaWxlIG9yIGEgZGlyZWN0b3J5LgotCSAqIElmIHRoZSBmaWxlIGlzIGFscmVhZHkgcmVsYXRpdmUgb3IgaXQgY2Fubm90IGJlIG1hZGUgcmVsYXRpdmUKLQkgKiB0byB0aGUgZGlyZWN0b3J5LCBpdCB3aWxsIGJlIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiAKLQkgKiBOQjogVGhpcyBtZXRob2QgaGFzIGJlZW4gdGVzdGVkIG9uIFdpbmRvd3MgYW5kIExpbnV4LAotCSAqIGJ1dCBub3QgTWFjIChidXQgdGhlIE1hYyBpcyBVbml4LWJhc2VkIHRoZXNlIGRheXMsIHNvCi0JICogaXQgc2hvdWxkbid0IGJlIGEgcHJvYmxlbS4uLikuCi0JICovCi0JcHVibGljIHN0YXRpYyBGaWxlIGNvbnZlcnRUb1JlbGF0aXZlRmlsZShmaW5hbCBGaWxlIGZpbGUpIHsKLQkJcmV0dXJuIGNvbnZlcnRUb1JlbGF0aXZlRmlsZShmaWxlLCBjdXJyZW50V29ya2luZ0RpcmVjdG9yeSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYW4gYXJyYXkgb2YgZmlsZXMgcmVwcmVzZW50aW5nIHRoZSBwYXRoIHRvIHRoZSBzcGVjaWZpZWQKLQkgKiBmaWxlLiBGb3IgZXhhbXBsZToKLQkgKiAgICAgQzovZm9vL2Jhci9iYXoudHh0ID0+Ci0JICogICAgIHsgQzovLCBDOi9mb28sIEM6L2Zvby9iYXIsIEM6L2Zvby9iYXIvYmF6LnR4dCB9Ci0JICovCi0JcHJpdmF0ZSBzdGF0aWMgRmlsZVtdIHBhdGhGaWxlcyhGaWxlIGZpbGUpIHsKLQkJTGlzdDxGaWxlPiBwYXRoID0gbmV3IEFycmF5TGlzdDxGaWxlPigpOwotCQlmb3IgKEZpbGUgZiA9IGZpbGU7IGYgIT0gbnVsbDsgZiA9IGYuZ2V0UGFyZW50RmlsZSgpKSB7Ci0JCQlwYXRoLmFkZChmKTsKLQkJfQotCQlDb2xsZWN0aW9ucy5yZXZlcnNlKHBhdGgpOwotCQlyZXR1cm4gcGF0aC50b0FycmF5KG5ldyBGaWxlW3BhdGguc2l6ZSgpXSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgZmlsZSB3aXRoIHRoZSBzcGVjaWZpZWQgKG5vbi16ZXJvKSBudW1iZXIgb2YgcmVsYXRpdmUKLQkgKiBmaWxlIG5hbWVzLCBlLmcuIHh4eCgzKSA9PiAuLi8uLi8uLgotCSAqLwotCXByaXZhdGUgc3RhdGljIEZpbGUgcmVsYXRpdmVQYXJlbnRGaWxlKGludCBsZW4pIHsKLQkJaWYgKGxlbiA8PSAwKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJsZW5ndGggbXVzdCBiZSBncmVhdGVyIHRoYW4gemVybzogIiArIGxlbik7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQlGaWxlIHJlc3VsdCA9IG5ldyBGaWxlKCIuLiIpOyAvLyROT04tTkxTLTEkCi0JCWZvciAoaW50IGkgPSBsZW4gLSAxOyBpLS0gPiAwOyApIHsKLQkJCXJlc3VsdCA9IG5ldyBGaWxlKHJlc3VsdCwgIi4uIik7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIGZpbGUgdGhhdCBpcyBhIHJlLXNwZWNpZmljYXRpb24gb2YgdGhlIHNwZWNpZmllZAotCSAqIGZpbGUsIGFic29sdXRlIHRvIHRoZSBzcGVjaWZpZWQgZGlyZWN0b3J5LgotCSAqICAgICBMaW51eC9Vbml4L01hYzoKLQkgKiAgICAgICAgIGNvbnZlcnRUb0Fic29sdXRlRmlsZShiYXIvYmF6LmphdmEsIC9mb28pCi0JICogICAgICAgICAgICAgPT4gL2Zvby9iYXIvYmF6LmphdmEKLQkgKiAgICAgV2luZG93czoKLQkgKiAgICAgICAgIGNvbnZlcnRUb0Fic29sdXRlRmlsZShiYXIvYmF6LmphdmEsIEM6XGZvbykKLQkgKiAgICAgICAgICAgICA9PiBDOlxmb29cYmFyXGJhei5qYXZhCi0JICogVGhlIGZpbGUgY2FuIGJlIGVpdGhlciBhIGZpbGUgb3IgYSBkaXJlY3Rvcnk7IHRoZSBkaXJlY3RvcnkKLQkgKiAqc2hvdWxkKiBiZSBhIGRpcmVjdG9yeS4KLQkgKiBJZiB0aGUgZmlsZSBpcyBhbHJlYWR5IGFic29sdXRlLCBpdCB3aWxsIGJlIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiAKLQkgKiBOQjogVGhpcyBtZXRob2QgaGFzIGJlZW4gdGVzdGVkIG9uIFdpbmRvd3MgYW5kIExpbnV4LAotCSAqIGJ1dCBub3QgTWFjIChidXQgdGhlIE1hYyBpcyBVbml4LWJhc2VkIHRoZXNlIGRheXMsIHNvCi0JICogaXQgc2hvdWxkbid0IGJlIGEgcHJvYmxlbS4uLikuCi0JICovCi0JcHVibGljIHN0YXRpYyBGaWxlIGNvbnZlcnRUb0Fic29sdXRlRmlsZShmaW5hbCBGaWxlIGZpbGUsIGZpbmFsIEZpbGUgZGlyKSB7Ci0JCS8vIGNoZWNrIHdoZXRoZXIgdGhlIGZpbGUgaXMgYWxyZWFkeSBhYnNvbHV0ZQotCQlpZiAoZmlsZS5pc0Fic29sdXRlKCkpIHsKLQkJCXJldHVybiBmaWxlOwkJLy8gcmV0dXJuIHVuY2hhbmdlZAotCQl9Ci0JCXJldHVybiBjYW5vbmljYWxGaWxlKG5ldyBGaWxlKGRpciwgZmlsZS5nZXRQYXRoKCkpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBmaWxlIHRoYXQgaXMgYSByZS1zcGVjaWZpY2F0aW9uIG9mIHRoZSBzcGVjaWZpZWQKLQkgKiBmaWxlLCBhYnNvbHV0ZSB0byB0aGUgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeS4KLQkgKiAgICAgTGludXgvVW5peC9NYWMgKENXRCA9IC9mb28pOgotCSAqICAgICAgICAgY29udmVydFRvQWJzb2x1dGVGaWxlKGJhci9iYXouamF2YSkKLQkgKiAgICAgICAgICAgICA9PiAvZm9vL2Jhci9iYXouamF2YQotCSAqICAgICBXaW5kb3dzIChDV0QgPSBDOlxmb28pOgotCSAqICAgICAgICAgY29udmVydFRvQWJzb2x1dGVGaWxlKGJhci9iYXouamF2YSkKLQkgKiAgICAgICAgICAgICA9PiBDOlxmb29cYmFyXGJhei5qYXZhCi0JICogVGhlIGZpbGUgY2FuIGJlIGVpdGhlciBhIGZpbGUgb3IgYSBkaXJlY3RvcnkuCi0JICogSWYgdGhlIGZpbGUgaXMgYWxyZWFkeSBhYnNvbHV0ZSwgaXQgd2lsbCBiZSByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogCi0JICogTkI6IFRoaXMgbWV0aG9kIGhhcyBiZWVuIHRlc3RlZCBvbiBXaW5kb3dzIGFuZCBMaW51eCwKLQkgKiBidXQgbm90IE1hYyAoYnV0IHRoZSBNYWMgaXMgVW5peC1iYXNlZCB0aGVzZSBkYXlzLCBzbwotCSAqIGl0IHNob3VsZG4ndCBiZSBhIHByb2JsZW0uLi4pLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgRmlsZSBjb252ZXJ0VG9BYnNvbHV0ZUZpbGUoZmluYWwgRmlsZSBmaWxlKSB7Ci0JCXJldHVybiBjb252ZXJ0VG9BYnNvbHV0ZUZpbGUoZmlsZSwgY3VycmVudFdvcmtpbmdEaXJlY3RvcnkoKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9yICoqKioqKioqKioKLQotCS8qKgotCSAqIFN1cHByZXNzIGRlZmF1bHQgY29uc3RydWN0b3IsIGVuc3VyaW5nIG5vbi1pbnN0YW50aWFiaWxpdHkuCi0JICovCi0JcHJpdmF0ZSBGaWxlVG9vbHMoKSB7Ci0JCXN1cGVyKCk7Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0hhc2hCYWcuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9IYXNoQmFnLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGIzNTQwZTIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0hhc2hCYWcuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDkxMyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsOwotCi1pbXBvcnQgamF2YS5pby5TZXJpYWxpemFibGU7Ci1pbXBvcnQgamF2YS51dGlsLkFic3RyYWN0Q29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuQ29uY3VycmVudE1vZGlmaWNhdGlvbkV4Y2VwdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci0KLS8qKgotICogVGhpcyBjbGFzcyBpbXBsZW1lbnRzIHRoZSA8Y29kZT5CYWc8L2NvZGU+IGludGVyZmFjZSwgYmFja2VkIGJ5IGEKLSAqIGhhc2ggdGFibGUuIEl0IG1ha2VzIG5vIGd1YXJhbnRlZXMgYXMgdG8gdGhlIGl0ZXJhdGlvbiBvcmRlciBvZgotICogdGhlIGJhZydzIGVsZW1lbnRzOyBpbiBwYXJ0aWN1bGFyLCBpdCBkb2VzIG5vdCBndWFyYW50ZWUgdGhhdCB0aGUgb3JkZXIKLSAqIHdpbGwgcmVtYWluIGNvbnN0YW50IG92ZXIgdGltZS4gVGhpcyBjbGFzcyBwZXJtaXRzIHRoZSA8Y29kZT5udWxsPC9jb2RlPgotICogZWxlbWVudC4KLSAqIDxwPgotICogVGhpcyBjbGFzcyBvZmZlcnMgY29uc3RhbnQgdGltZSBwZXJmb3JtYW5jZSBmb3IgdGhlIGJhc2ljIG9wZXJhdGlvbnMKLSAqICg8Y29kZT5hZGQ8L2NvZGU+LCA8Y29kZT5yZW1vdmU8L2NvZGU+LCA8Y29kZT5jb250YWluczwvY29kZT4gYW5kCi0gKiA8Y29kZT5zaXplPC9jb2RlPiksIGFzc3VtaW5nIHRoZSBoYXNoIGZ1bmN0aW9uIGRpc3BlcnNlcyB0aGUgZWxlbWVudHMKLSAqIHByb3Blcmx5IGFtb25nIHRoZSBidWNrZXRzLiBJdGVyYXRpbmcgb3ZlciB0aGlzIGJhZyByZXF1aXJlcyB0aW1lCi0gKiBwcm9wb3J0aW9uYWwgdG8gdGhlIHN1bSBvZiB0aGUgYmFnJ3Mgc2l6ZSAodGhlIG51bWJlciBvZiBlbGVtZW50cykgcGx1cyB0aGUKLSAqICJjYXBhY2l0eSIgb2YgdGhlIGJhY2tpbmcgaGFzaCB0YWJsZSAodGhlIG51bWJlciBvZiBidWNrZXRzKS4gVGh1cywgaXQgaXMKLSAqIGltcG9ydGFudCBub3QgdG8gc2V0IHRoZSBpbml0aWFsIGNhcGFjaXR5IHRvbyBoaWdoIChvciB0aGUgbG9hZCBmYWN0b3IgdG9vCi0gKiBsb3cpIGlmIGl0ZXJhdGlvbiBwZXJmb3JtYW5jZSBpcyBpbXBvcnRhbnQuCi0gKiA8cD4KLSAqIDxiPk5vdGUgdGhhdCB0aGlzIGltcGxlbWVudGF0aW9uIGlzIG5vdCBzeW5jaHJvbml6ZWQuPC9iPiBJZiBtdWx0aXBsZQotICogdGhyZWFkcyBhY2Nlc3MgYSBiYWcgY29uY3VycmVudGx5LCBhbmQgYXQgbGVhc3Qgb25lIG9mIHRoZSB0aHJlYWRzIG1vZGlmaWVzCi0gKiB0aGUgYmFnLCBpdCA8aT5tdXN0PC9pPiBiZSBzeW5jaHJvbml6ZWQgZXh0ZXJuYWxseS4gVGhpcyBpcyB0eXBpY2FsbHkKLSAqIGFjY29tcGxpc2hlZCBieSBzeW5jaHJvbml6aW5nIG9uIHNvbWUgb2JqZWN0IHRoYXQgbmF0dXJhbGx5IGVuY2Fwc3VsYXRlcwotICogdGhlIGJhZy4gSWYgbm8gc3VjaCBvYmplY3QgZXhpc3RzLCB0aGUgYmFnIHNob3VsZCBiZSAid3JhcHBlZCIgdXNpbmcgdGhlCi0gKiA8Y29kZT5Db2xsZWN0aW9ucy5zeW5jaHJvbml6ZWRDb2xsZWN0aW9uPC9jb2RlPiBtZXRob2QuIFRoaXMgaXMKLSAqIGJlc3QgZG9uZSBhdCBjcmVhdGlvbiB0aW1lLCB0byBwcmV2ZW50IGFjY2lkZW50YWwgdW5zeW5jaHJvbml6ZWQgYWNjZXNzCi0gKiB0byB0aGUgYmFnOgotICogPHByZT4KLSAqIENvbGxlY3Rpb24gYyA9IENvbGxlY3Rpb25zLnN5bmNocm9uaXplZENvbGxlY3Rpb24obmV3IEhhc2hCYWcoLi4uKSk7Ci0gKiA8L3ByZT4KLSAqIDxwPgotICogVGhlIGl0ZXJhdG9ycyByZXR1cm5lZCBieSB0aGlzIGNsYXNzJ3MgPGNvZGU+aXRlcmF0b3I8L2NvZGU+IG1ldGhvZCBhcmUKLSAqIDxpPmZhaWwtZmFzdDwvaT46IGlmIHRoZSBiYWcgaXMgbW9kaWZpZWQgYXQgYW55IHRpbWUgYWZ0ZXIgdGhlIGl0ZXJhdG9yIGlzCi0gKiBjcmVhdGVkLCBpbiBhbnkgd2F5IGV4Y2VwdCB0aHJvdWdoIHRoZSBpdGVyYXRvcidzIG93biA8Y29kZT5yZW1vdmU8L2NvZGU+Ci0gKiBtZXRob2QsIHRoZSBpdGVyYXRvciB0aHJvd3MgYSA8Y29kZT5Db25jdXJyZW50TW9kaWZpY2F0aW9uRXhjZXB0aW9uPC9jb2RlPi4KLSAqIFRodXMsIGluIHRoZSBmYWNlIG9mIGNvbmN1cnJlbnQgbW9kaWZpY2F0aW9uLCB0aGUgaXRlcmF0b3IgZmFpbHMgcXVpY2tseQotICogYW5kIGNsZWFubHksIHJhdGhlciB0aGFuIHJpc2tpbmcgYXJiaXRyYXJ5LCBub24tZGV0ZXJtaW5pc3RpYyBiZWhhdmlvciBhdAotICogYW4gdW5kZXRlcm1pbmVkIHRpbWUgaW4gdGhlIGZ1dHVyZS4KLSAqIAotICogQHNlZQlDb2xsZWN0aW9ucyNzeW5jaHJvbml6ZWRDb2xsZWN0aW9uKENvbGxlY3Rpb24pCi0gKi8KLXB1YmxpYyBjbGFzcyBIYXNoQmFnPEU+Ci0JZXh0ZW5kcyBBYnN0cmFjdENvbGxlY3Rpb248RT4KLQlpbXBsZW1lbnRzIEJhZzxFPiwgQ2xvbmVhYmxlLCBTZXJpYWxpemFibGUKLXsKLQotCS8qKiBUaGUgaGFzaCB0YWJsZS4gKi8KLQl0cmFuc2llbnQgRW50cnk8RT5bXSB0YWJsZTsKLQotCS8qKiBUaGUgdG90YWwgbnVtYmVyIG9mIGVudHJpZXMgaW4gdGhlIGJhZy4gKi8KLQl0cmFuc2llbnQgaW50IGNvdW50ID0gMDsKLQotCS8qKiBUaGUgbnVtYmVyIG9mIHVuaXF1ZSBlbnRyaWVzIGluIHRoZSBiYWcuICovCi0JdHJhbnNpZW50IGludCB1bmlxdWVDb3VudCA9IDA7Ci0KLQkvKioKLQkgKiBUaGUgaGFzaCB0YWJsZSBpcyByZWhhc2hlZCB3aGVuIGl0cyBzaXplIGV4Y2VlZHMgdGhpcyB0aHJlc2hvbGQuIChUaGUKLQkgKiB2YWx1ZSBvZiB0aGlzIGZpZWxkIGlzIChpbnQpKGNhcGFjaXR5ICogbG9hZEZhY3RvcikuKQotCSAqCi0JICogQHNlcmlhbAotCSAqLwotCXByaXZhdGUgaW50IHRocmVzaG9sZDsKLQotCS8qKgotCSAqIFRoZSBsb2FkIGZhY3RvciBmb3IgdGhlIGhhc2ggdGFibGUuCi0JICoKLQkgKiBAc2VyaWFsCi0JICovCi0JcHJpdmF0ZSBmbG9hdCBsb2FkRmFjdG9yOwotCi0JLyoqCi0JICogVGhlIG51bWJlciBvZiB0aW1lcyB0aGlzIGJhZyBoYXMgYmVlbiBzdHJ1Y3R1cmFsbHkgbW9kaWZpZWQuCi0JICogU3RydWN0dXJhbCBtb2RpZmljYXRpb25zIGFyZSB0aG9zZSB0aGF0IGNoYW5nZSB0aGUgbnVtYmVyIG9mIGVudHJpZXMgaW4KLQkgKiB0aGUgYmFnIG9yIG90aGVyd2lzZSBtb2RpZnkgaXRzIGludGVybmFsIHN0cnVjdHVyZSAoZS5nLiByZWhhc2gpLgotCSAqIFRoaXMgZmllbGQgaXMgdXNlZCB0byBtYWtlIGl0ZXJhdG9ycyBvbiB0aGlzIGJhZyBmYWlsLWZhc3QuCi0JICoKLQkgKiBAc2VlIGphdmEudXRpbC5Db25jdXJyZW50TW9kaWZpY2F0aW9uRXhjZXB0aW9uCi0JICovCi0JdHJhbnNpZW50IGludCBtb2RDb3VudCA9IDA7Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3RzIGEgbmV3LCBlbXB0eSBiYWcgd2l0aCB0aGUKLQkgKiBkZWZhdWx0IGNhcGFjaXR5LCB3aGljaCBpcyAxMSwgYW5kIGxvYWQgZmFjdG9yLCB3aGljaCBpcyAwLjc1LgotCSAqLwotCXB1YmxpYyBIYXNoQmFnKCkgewotCQl0aGlzKDExLCAwLjc1Zik7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0cyBhIG5ldywgZW1wdHkgYmFnIHdpdGggdGhlIHNwZWNpZmllZCBpbml0aWFsIGNhcGFjaXR5Ci0JICogYW5kIGRlZmF1bHQgbG9hZCBmYWN0b3IsIHdoaWNoIGlzIDAuNzUuCi0JICoKLQkgKiBAcGFyYW0gaW5pdGlhbENhcGFjaXR5IHRoZSBpbml0aWFsIGNhcGFjaXR5IG9mIHRoZSBiYWNraW5nIG1hcC4KLQkgKiBAdGhyb3dzIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpZiB0aGUgaW5pdGlhbCBjYXBhY2l0eSBpcyBsZXNzCi0JICogICAgIHRoYW4gemVyby4KLQkgKi8KLQlwdWJsaWMgSGFzaEJhZyhpbnQgaW5pdGlhbENhcGFjaXR5KSB7Ci0JCXRoaXMoaW5pdGlhbENhcGFjaXR5LCAwLjc1Zik7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0cyBhIG5ldywgZW1wdHkgYmFnIHdpdGgKLQkgKiB0aGUgc3BlY2lmaWVkIGluaXRpYWwgY2FwYWNpdHkgYW5kIHRoZSBzcGVjaWZpZWQgbG9hZCBmYWN0b3IuCi0JICoKLQkgKiBAcGFyYW0gaW5pdGlhbENhcGFjaXR5IHRoZSBpbml0aWFsIGNhcGFjaXR5IG9mIHRoZSBiYWNraW5nIG1hcC4KLQkgKiBAcGFyYW0gbG9hZEZhY3RvciB0aGUgbG9hZCBmYWN0b3Igb2YgdGhlIGJhY2tpbmcgbWFwLgotCSAqIEB0aHJvd3MgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGlmIHRoZSBpbml0aWFsIGNhcGFjaXR5IGlzIGxlc3MKLQkgKiAgICAgdGhhbiB6ZXJvLCBvciBpZiB0aGUgbG9hZCBmYWN0b3IgaXMgbm9ucG9zaXRpdmUuCi0JICovCi0JcHVibGljIEhhc2hCYWcoaW50IGluaXRpYWxDYXBhY2l0eSwgZmxvYXQgbG9hZEZhY3RvcikgewotCQlpZiAoaW5pdGlhbENhcGFjaXR5IDwgMCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiSWxsZWdhbCBJbml0aWFsIENhcGFjaXR5OiAiICsgaW5pdGlhbENhcGFjaXR5KTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCWlmIChsb2FkRmFjdG9yIDw9IDAgfHwgRmxvYXQuaXNOYU4obG9hZEZhY3RvcikpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oIklsbGVnYWwgTG9hZCBmYWN0b3I6ICIgKyBsb2FkRmFjdG9yKTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCWlmIChpbml0aWFsQ2FwYWNpdHkgPT0gMCkgewotCQkJaW5pdGlhbENhcGFjaXR5ID0gMTsKLQkJfQotCQl0aGlzLmxvYWRGYWN0b3IgPSBsb2FkRmFjdG9yOwotCQl0aGlzLnRhYmxlID0gdGhpcy5idWlsZFRhYmxlKGluaXRpYWxDYXBhY2l0eSk7Ci0JCXRoaXMudGhyZXNob2xkID0gKGludCkgKGluaXRpYWxDYXBhY2l0eSAqIGxvYWRGYWN0b3IpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdHMgYSBuZXcgYmFnIGNvbnRhaW5pbmcgdGhlIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQKLQkgKiBjb2xsZWN0aW9uLiBUaGUgY2FwYWNpdHkgb2YgdGhlIGJhZyBpcwotCSAqIHR3aWNlIHRoZSBzaXplIG9mIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbiBvciAxMSAod2hpY2hldmVyIGlzCi0JICogZ3JlYXRlciksIGFuZCB0aGUgZGVmYXVsdCBsb2FkIGZhY3Rvciwgd2hpY2ggaXMgMC43NSwgaXMgdXNlZC4KLQkgKgotCSAqIEBwYXJhbSBjIHRoZSBjb2xsZWN0aW9uIHdob3NlIGVsZW1lbnRzIGFyZSB0byBiZSBwbGFjZWQgaW50byB0aGlzIGJhZy4KLQkgKi8KLQlwdWJsaWMgSGFzaEJhZyhDb2xsZWN0aW9uPD8gZXh0ZW5kcyBFPiBjKSB7Ci0JCXRoaXMoTWF0aC5tYXgoMipjLnNpemUoKSwgMTEpKTsKLQkJdGhpcy5hZGRBbGwoYyk7Ci0JfQotCi0JLyoqCi0JICogVGhpcyBpbXBsZW1lbnRhdGlvbiBzaW1wbHkgcmV0dXJucyB0aGUgbWFpbnRhaW5lZCBjb3VudC4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgaW50IHNpemUoKSB7Ci0JCXJldHVybiB0aGlzLmNvdW50OwotCX0KLQotCS8qKgotCSAqIFRoaXMgaW1wbGVtZW50YXRpb24gc2ltcGx5IGNvbXBhcmVzIHRoZSBtYWludGFpbmVkIGNvdW50IHRvIHplcm8uCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIGJvb2xlYW4gaXNFbXB0eSgpIHsKLQkJcmV0dXJuIHRoaXMuY291bnQgPT0gMDsKLQl9Ci0KLQkvKioKLQkgKiBUaGlzIGltcGxlbWVudGF0aW9uIHNlYXJjaGVzIGZvciB0aGUgb2JqZWN0IGluIHRoZSBoYXNoIHRhYmxlIGJ5IGNhbGN1bGF0aW5nCi0JICogdGhlIG9iamVjdCdzIGhhc2ggY29kZSBhbmQgZXhhbWluaW5nIHRoZSBlbnRyaWVzIGluIHRoZSBjb3JyZXNwb25kaW5nIGhhc2gKLQkgKiB0YWJsZSBidWNrZXQuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIGJvb2xlYW4gY29udGFpbnMoT2JqZWN0IG8pIHsKLQkJRW50cnk8RT5bXSB0YWIgPSB0aGlzLnRhYmxlOwotCQlpZiAobyA9PSBudWxsKSB7Ci0JCQlmb3IgKEVudHJ5PEU+IGUgPSB0YWJbMF07IGUgIT0gbnVsbDsgZSA9IGUubmV4dCkgewotCQkJCWlmIChlLm9iamVjdCA9PSBudWxsKSB7Ci0JCQkJCXJldHVybiB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfSBlbHNlIHsKLQkJCWludCBoYXNoID0gby5oYXNoQ29kZSgpOwotCQkJaW50IGluZGV4ID0gKGhhc2ggJiAweDdGRkZGRkZGKSAlIHRhYi5sZW5ndGg7Ci0JCQlmb3IgKEVudHJ5PEU+IGUgPSB0YWJbaW5kZXhdOyBlICE9IG51bGw7IGUgPSBlLm5leHQpIHsKLQkJCQlpZiAoKGUuaGFzaCA9PSBoYXNoKSAmJiBvLmVxdWFscyhlLm9iamVjdCkpIHsKLQkJCQkJcmV0dXJuIHRydWU7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQlwdWJsaWMgaW50IGNvdW50KE9iamVjdCBvKSB7Ci0JCUVudHJ5PEU+W10gdGFiID0gdGhpcy50YWJsZTsKLQkJaWYgKG8gPT0gbnVsbCkgewotCQkJZm9yIChFbnRyeTxFPiBlID0gdGFiWzBdOyBlICE9IG51bGw7IGUgPSBlLm5leHQpIHsKLQkJCQlpZiAoZS5vYmplY3QgPT0gbnVsbCkgewotCQkJCQlyZXR1cm4gZS5jb3VudDsKLQkJCQl9Ci0JCQl9Ci0JCX0gZWxzZSB7Ci0JCQlpbnQgaGFzaCA9IG8uaGFzaENvZGUoKTsKLQkJCWludCBpbmRleCA9IChoYXNoICYgMHg3RkZGRkZGRikgJSB0YWIubGVuZ3RoOwotCQkJZm9yIChFbnRyeTxFPiBlID0gdGFiW2luZGV4XTsgZSAhPSBudWxsOyBlID0gZS5uZXh0KSB7Ci0JCQkJaWYgKChlLmhhc2ggPT0gaGFzaCkgJiYgby5lcXVhbHMoZS5vYmplY3QpKSB7Ci0JCQkJCXJldHVybiBlLmNvdW50OwotCQkJCX0KLQkJCX0KLQkJfQotCQlyZXR1cm4gMDsKLQl9Ci0KLQkvKioKLQkgKiBSZWhhc2hlcyB0aGUgY29udGVudHMgb2YgdGhpcyBiYWcgaW50byBhIG5ldyBoYXNoIHRhYmxlCi0JICogd2l0aCBhIGxhcmdlciBjYXBhY2l0eS4gVGhpcyBtZXRob2QgaXMgY2FsbGVkIHdoZW4gdGhlCi0JICogbnVtYmVyIG9mIGRpZmZlcmVudCBlbGVtZW50cyBpbiB0aGlzIG1hcCBleGNlZWRzIGl0cwotCSAqIGNhcGFjaXR5IGFuZCBsb2FkIGZhY3Rvci4KLQkgKi8KLQlwcml2YXRlIHZvaWQgcmVoYXNoKCkgewotCQlFbnRyeTxFPltdIG9sZE1hcCA9IHRoaXMudGFibGU7Ci0JCWludCBvbGRDYXBhY2l0eSA9IG9sZE1hcC5sZW5ndGg7Ci0KLQkJaW50IG5ld0NhcGFjaXR5ID0gb2xkQ2FwYWNpdHkgKiAyICsgMTsKLQkJRW50cnk8RT5bXSBuZXdUYWJsZSA9IHRoaXMuYnVpbGRUYWJsZShuZXdDYXBhY2l0eSk7Ci0KLQkJdGhpcy5tb2RDb3VudCsrOwotCQl0aGlzLnRocmVzaG9sZCA9IChpbnQpIChuZXdDYXBhY2l0eSAqIHRoaXMubG9hZEZhY3Rvcik7Ci0JCXRoaXMudGFibGUgPSBuZXdUYWJsZTsKLQotCQlmb3IgKGludCBpID0gb2xkQ2FwYWNpdHk7IGktLSA+IDA7ICkgewotCQkJZm9yIChFbnRyeTxFPiBvbGQgPSBvbGRNYXBbaV07IG9sZCAhPSBudWxsOyApIHsKLQkJCQlFbnRyeTxFPiBlID0gb2xkOwotCQkJCW9sZCA9IG9sZC5uZXh0OwotCi0JCQkJaW50IGluZGV4ID0gKGUuaGFzaCAmIDB4N0ZGRkZGRkYpICUgbmV3Q2FwYWNpdHk7Ci0JCQkJZS5uZXh0ID0gbmV3VGFibGVbaW5kZXhdOwotCQkJCW5ld1RhYmxlW2luZGV4XSA9IGU7Ci0JCQl9Ci0JCX0KLQl9Ci0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcml2YXRlIEVudHJ5PEU+W10gYnVpbGRUYWJsZShpbnQgY2FwYWNpdHkpIHsKLQkJcmV0dXJuIG5ldyBFbnRyeVtjYXBhY2l0eV07Ci0JfQotCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJpdmF0ZSA8VD4gRW50cnk8RT4gYnVpbGRFbnRyeShpbnQgaGFzaCwgT2JqZWN0IG8sIEVudHJ5PFQ+IG5leHQpIHsKLQkJcmV0dXJuIG5ldyBFbnRyeShoYXNoLCBvLCBuZXh0KTsKLQl9Ci0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcml2YXRlIDxUPiBFbnRyeTxFPiBidWlsZEVudHJ5KGludCBoYXNoLCBPYmplY3QgbywgaW50IGNudCwgRW50cnk8VD4gbmV4dCkgewotCQlyZXR1cm4gbmV3IEVudHJ5KGhhc2gsIG8sIGNudCwgbmV4dCk7Ci0JfQotCi0JLyoqCi0JICogVGhpcyBpbXBsZW1lbnRhdGlvbiBzZWFyY2hlcyBmb3IgdGhlIG9iamVjdCBpbiB0aGUgaGFzaCB0YWJsZSBieSBjYWxjdWxhdGluZwotCSAqIHRoZSBvYmplY3QncyBoYXNoIGNvZGUgYW5kIGV4YW1pbmluZyB0aGUgZW50cmllcyBpbiB0aGUgY29ycmVzcG9uZGluZyBoYXNoCi0JICogdGFibGUgYnVja2V0LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyBib29sZWFuIGFkZChFIG8pIHsKLQkJdGhpcy5tb2RDb3VudCsrOwotCQlFbnRyeTxFPltdIHRhYiA9IHRoaXMudGFibGU7Ci0JCWludCBoYXNoID0gMDsKLQkJaW50IGluZGV4ID0gMDsKLQotCQkvLyBpZiB0aGUgb2JqZWN0IGlzIGFscmVhZHkgaW4gdGhlIGJhZywgc2ltcGx5IGJ1bXAgaXRzIGNvdW50Ci0JCWlmIChvID09IG51bGwpIHsKLQkJCWZvciAoRW50cnk8RT4gZSA9IHRhYlswXTsgZSAhPSBudWxsOyBlID0gZS5uZXh0KSB7Ci0JCQkJaWYgKGUub2JqZWN0ID09IG51bGwpIHsKLQkJCQkJZS5jb3VudCsrOwotCQkJCQl0aGlzLmNvdW50Kys7Ci0JCQkJCXJldHVybiB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfSBlbHNlIHsKLQkJCWhhc2ggPSBvLmhhc2hDb2RlKCk7Ci0JCQlpbmRleCA9IChoYXNoICYgMHg3RkZGRkZGRikgJSB0YWIubGVuZ3RoOwotCQkJZm9yIChFbnRyeTxFPiBlID0gdGFiW2luZGV4XTsgZSAhPSBudWxsOyBlID0gZS5uZXh0KSB7Ci0JCQkJaWYgKChlLmhhc2ggPT0gaGFzaCkgJiYgby5lcXVhbHMoZS5vYmplY3QpKSB7Ci0JCQkJCWUuY291bnQrKzsKLQkJCQkJdGhpcy5jb3VudCsrOwotCQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQotCQkvLyByZWhhc2ggdGhlIHRhYmxlIGlmIHRoZSB0aHJlc2hvbGQgaXMgZXhjZWVkZWQKLQkJaWYgKHRoaXMudW5pcXVlQ291bnQgPj0gdGhpcy50aHJlc2hvbGQpIHsKLQkJCXRoaXMucmVoYXNoKCk7Ci0JCQl0YWIgPSB0aGlzLnRhYmxlOwotCQkJaW5kZXggPSAoaGFzaCAmIDB4N0ZGRkZGRkYpICUgdGFiLmxlbmd0aDsKLQkJfQotCi0JCS8vIGNyZWF0ZSB0aGUgbmV3IGVudHJ5IGFuZCBwdXQgaXQgaW4gdGhlIHRhYmxlCi0JCUVudHJ5PEU+IGUgPSB0aGlzLmJ1aWxkRW50cnkoaGFzaCwgbywgdGFiW2luZGV4XSk7Ci0JCXRhYltpbmRleF0gPSBlOwotCQl0aGlzLmNvdW50Kys7Ci0JCXRoaXMudW5pcXVlQ291bnQrKzsKLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JLyoqCi0JICogVGhpcyBpbXBsZW1lbnRhdGlvbiBzZWFyY2hlcyBmb3IgdGhlIG9iamVjdCBpbiB0aGUgaGFzaCB0YWJsZSBieSBjYWxjdWxhdGluZwotCSAqIHRoZSBvYmplY3QncyBoYXNoIGNvZGUgYW5kIGV4YW1pbmluZyB0aGUgZW50cmllcyBpbiB0aGUgY29ycmVzcG9uZGluZyBoYXNoCi0JICogdGFibGUgYnVja2V0LgotCSAqLwotCXB1YmxpYyBib29sZWFuIGFkZChFIG8sIGludCBjbnQpIHsKLQkJaWYgKGNudCA8PSAwKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJdGhpcy5tb2RDb3VudCsrOwotCQlFbnRyeTxFPltdIHRhYiA9IHRoaXMudGFibGU7Ci0JCWludCBoYXNoID0gMDsKLQkJaW50IGluZGV4ID0gMDsKLQotCQkvLyBpZiB0aGUgb2JqZWN0IGlzIGFscmVhZHkgaW4gdGhlIGJhZywgc2ltcGx5IGJ1bXAgaXRzIGNvdW50Ci0JCWlmIChvID09IG51bGwpIHsKLQkJCWZvciAoRW50cnk8RT4gZSA9IHRhYlswXTsgZSAhPSBudWxsOyBlID0gZS5uZXh0KSB7Ci0JCQkJaWYgKGUub2JqZWN0ID09IG51bGwpIHsKLQkJCQkJZS5jb3VudCArPSBjbnQ7Ci0JCQkJCXRoaXMuY291bnQgKz0gY250OwotCQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0gZWxzZSB7Ci0JCQloYXNoID0gby5oYXNoQ29kZSgpOwotCQkJaW5kZXggPSAoaGFzaCAmIDB4N0ZGRkZGRkYpICUgdGFiLmxlbmd0aDsKLQkJCWZvciAoRW50cnk8RT4gZSA9IHRhYltpbmRleF07IGUgIT0gbnVsbDsgZSA9IGUubmV4dCkgewotCQkJCWlmICgoZS5oYXNoID09IGhhc2gpICYmIG8uZXF1YWxzKGUub2JqZWN0KSkgewotCQkJCQllLmNvdW50ICs9IGNudDsKLQkJCQkJdGhpcy5jb3VudCArPSBjbnQ7Ci0JCQkJCXJldHVybiB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfQotCi0JCS8vIHJlaGFzaCB0aGUgdGFibGUgaWYgdGhlIHRocmVzaG9sZCBpcyBleGNlZWRlZAotCQlpZiAodGhpcy51bmlxdWVDb3VudCA+PSB0aGlzLnRocmVzaG9sZCkgewotCQkJdGhpcy5yZWhhc2goKTsKLQkJCXRhYiA9IHRoaXMudGFibGU7Ci0JCQlpbmRleCA9IChoYXNoICYgMHg3RkZGRkZGRikgJSB0YWIubGVuZ3RoOwotCQl9Ci0KLQkJLy8gY3JlYXRlIHRoZSBuZXcgZW50cnkgYW5kIHB1dCBpdCBpbiB0aGUgdGFibGUKLQkJRW50cnk8RT4gZSA9IHRoaXMuYnVpbGRFbnRyeShoYXNoLCBvLCBjbnQsIHRhYltpbmRleF0pOwotCQl0YWJbaW5kZXhdID0gZTsKLQkJdGhpcy5jb3VudCArPSBjbnQ7Ci0JCXRoaXMudW5pcXVlQ291bnQrKzsKLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JLyoqCi0JICogVGhpcyBpbXBsZW1lbnRhdGlvbiBzZWFyY2hlcyBmb3IgdGhlIG9iamVjdCBpbiB0aGUgaGFzaCB0YWJsZSBieSBjYWxjdWxhdGluZwotCSAqIHRoZSBvYmplY3QncyBoYXNoIGNvZGUgYW5kIGV4YW1pbmluZyB0aGUgZW50cmllcyBpbiB0aGUgY29ycmVzcG9uZGluZyBoYXNoCi0JICogdGFibGUgYnVja2V0LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyBib29sZWFuIHJlbW92ZShPYmplY3QgbykgewotCQlFbnRyeTxFPltdIHRhYiA9IHRoaXMudGFibGU7Ci0JCWlmIChvID09IG51bGwpIHsKLQkJCWZvciAoRW50cnk8RT4gZSA9IHRhYlswXSwgcHJldiA9IG51bGw7IGUgIT0gbnVsbDsgcHJldiA9IGUsIGUgPSBlLm5leHQpIHsKLQkJCQlpZiAoZS5vYmplY3QgPT0gbnVsbCkgewotCQkJCQl0aGlzLm1vZENvdW50Kys7Ci0JCQkJCWUuY291bnQtLTsKLQkJCQkJLy8gaWYgd2UgYXJlIHJlbW92aW5nIHRoZSBsYXN0IG9uZSwgcmVtb3ZlIHRoZSBlbnRyeSBmcm9tIHRoZSB0YWJsZQotCQkJCQlpZiAoZS5jb3VudCA9PSAwKSB7Ci0JCQkJCQlpZiAocHJldiA9PSBudWxsKSB7Ci0JCQkJCQkJdGFiWzBdID0gZS5uZXh0OwotCQkJCQkJfSBlbHNlIHsKLQkJCQkJCQlwcmV2Lm5leHQgPSBlLm5leHQ7Ci0JCQkJCQl9Ci0JCQkJCQl0aGlzLnVuaXF1ZUNvdW50LS07Ci0JCQkJCX0KLQkJCQkJdGhpcy5jb3VudC0tOwotCQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0gZWxzZSB7Ci0JCQlpbnQgaGFzaCA9IG8uaGFzaENvZGUoKTsKLQkJCWludCBpbmRleCA9IChoYXNoICYgMHg3RkZGRkZGRikgJSB0YWIubGVuZ3RoOwotCQkJZm9yIChFbnRyeTxFPiBlID0gdGFiW2luZGV4XSwgcHJldiA9IG51bGw7IGUgIT0gbnVsbDsgcHJldiA9IGUsIGUgPSBlLm5leHQpIHsKLQkJCQlpZiAoKGUuaGFzaCA9PSBoYXNoKSAmJiBvLmVxdWFscyhlLm9iamVjdCkpIHsKLQkJCQkJdGhpcy5tb2RDb3VudCsrOwotCQkJCQllLmNvdW50LS07Ci0JCQkJCS8vIGlmIHdlIGFyZSByZW1vdmluZyB0aGUgbGFzdCBvbmUsIHJlbW92ZSB0aGUgZW50cnkgZnJvbSB0aGUgdGFibGUKLQkJCQkJaWYgKGUuY291bnQgPT0gMCkgewotCQkJCQkJaWYgKHByZXYgPT0gbnVsbCkgewotCQkJCQkJCXRhYltpbmRleF0gPSBlLm5leHQ7Ci0JCQkJCQl9IGVsc2UgewotCQkJCQkJCXByZXYubmV4dCA9IGUubmV4dDsKLQkJCQkJCX0KLQkJCQkJCXRoaXMudW5pcXVlQ291bnQtLTsKLQkJCQkJfQotCQkJCQl0aGlzLmNvdW50LS07Ci0JCQkJCXJldHVybiB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfQotCi0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQkvKioKLQkgKiBUaGlzIGltcGxlbWVudGF0aW9uIHNlYXJjaGVzIGZvciB0aGUgb2JqZWN0IGluIHRoZSBoYXNoIHRhYmxlIGJ5IGNhbGN1bGF0aW5nCi0JICogdGhlIG9iamVjdCdzIGhhc2ggY29kZSBhbmQgZXhhbWluaW5nIHRoZSBlbnRyaWVzIGluIHRoZSBjb3JyZXNwb25kaW5nIGhhc2gKLQkgKiB0YWJsZSBidWNrZXQuCi0JICovCi0JcHVibGljIGJvb2xlYW4gcmVtb3ZlKE9iamVjdCBvLCBpbnQgY250KSB7Ci0JCWlmIChjbnQgPD0gMCkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCUVudHJ5PEU+W10gdGFiID0gdGhpcy50YWJsZTsKLQkJaWYgKG8gPT0gbnVsbCkgewotCQkJZm9yIChFbnRyeTxFPiBlID0gdGFiWzBdLCBwcmV2ID0gbnVsbDsgZSAhPSBudWxsOyBwcmV2ID0gZSwgZSA9IGUubmV4dCkgewotCQkJCWlmIChlLm9iamVjdCA9PSBudWxsKSB7Ci0JCQkJCXRoaXMubW9kQ291bnQrKzsKLQkJCQkJaW50IGNudDIgPSAoY250IDwgZS5jb3VudCkgPyBjbnQgOiBlLmNvdW50OwotCQkJCQllLmNvdW50IC09IGNudDI7Ci0JCQkJCS8vIGlmIHdlIGFyZSByZW1vdmluZyB0aGUgbGFzdCBlbGVtZW50KHMpLCByZW1vdmUgdGhlIGVudHJ5IGZyb20gdGhlIHRhYmxlCi0JCQkJCWlmIChlLmNvdW50ID09IDApIHsKLQkJCQkJCWlmIChwcmV2ID09IG51bGwpIHsKLQkJCQkJCQl0YWJbMF0gPSBlLm5leHQ7Ci0JCQkJCQl9IGVsc2UgewotCQkJCQkJCXByZXYubmV4dCA9IGUubmV4dDsKLQkJCQkJCX0KLQkJCQkJCXRoaXMudW5pcXVlQ291bnQtLTsKLQkJCQkJfQotCQkJCQl0aGlzLmNvdW50IC09IGNudDI7Ci0JCQkJCXJldHVybiB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfSBlbHNlIHsKLQkJCWludCBoYXNoID0gby5oYXNoQ29kZSgpOwotCQkJaW50IGluZGV4ID0gKGhhc2ggJiAweDdGRkZGRkZGKSAlIHRhYi5sZW5ndGg7Ci0JCQlmb3IgKEVudHJ5PEU+IGUgPSB0YWJbaW5kZXhdLCBwcmV2ID0gbnVsbDsgZSAhPSBudWxsOyBwcmV2ID0gZSwgZSA9IGUubmV4dCkgewotCQkJCWlmICgoZS5oYXNoID09IGhhc2gpICYmIG8uZXF1YWxzKGUub2JqZWN0KSkgewotCQkJCQl0aGlzLm1vZENvdW50Kys7Ci0JCQkJCWludCBjbnQyID0gKGNudCA8IGUuY291bnQpID8gY250IDogZS5jb3VudDsKLQkJCQkJZS5jb3VudCAtPSBjbnQyOwotCQkJCQkvLyBpZiB3ZSBhcmUgcmVtb3ZpbmcgdGhlIGxhc3QgZWxlbWVudChzKSwgcmVtb3ZlIHRoZSBlbnRyeSBmcm9tIHRoZSB0YWJsZQotCQkJCQlpZiAoZS5jb3VudCA9PSAwKSB7Ci0JCQkJCQlpZiAocHJldiA9PSBudWxsKSB7Ci0JCQkJCQkJdGFiW2luZGV4XSA9IGUubmV4dDsKLQkJCQkJCX0gZWxzZSB7Ci0JCQkJCQkJcHJldi5uZXh0ID0gZS5uZXh0OwotCQkJCQkJfQotCQkJCQkJdGhpcy51bmlxdWVDb3VudC0tOwotCQkJCQl9Ci0JCQkJCXRoaXMuY291bnQgLT0gY250MjsKLQkJCQkJcmV0dXJuIHRydWU7Ci0JCQkJfQotCQkJfQotCQl9Ci0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCS8qKgotCSAqIFRoaXMgaW1wbGVtZW50YXRpb24gc2ltcGx5IGNsZWFycyBvdXQgYWxsIG9mIHRoZSBoYXNoIHRhYmxlIGJ1Y2tldHMuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgY2xlYXIoKSB7Ci0JCUVudHJ5PEU+W10gdGFiID0gdGhpcy50YWJsZTsKLQkJdGhpcy5tb2RDb3VudCsrOwotCQlmb3IgKGludCBpID0gdGFiLmxlbmd0aDsgLS1pID49IDA7ICkgewotCQkJdGFiW2ldID0gbnVsbDsKLQkJfQotCQl0aGlzLmNvdW50ID0gMDsKLQkJdGhpcy51bmlxdWVDb3VudCA9IDA7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJucyBhIHNoYWxsb3cgY29weSBvZiB0aGlzIGJhZzogdGhlIGVsZW1lbnRzCi0JICogdGhlbXNlbHZlcyBhcmUgbm90IGNsb25lZC4KLQkgKgotCSAqIEByZXR1cm4gYSBzaGFsbG93IGNvcHkgb2YgdGhpcyBiYWcuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIEhhc2hCYWc8RT4gY2xvbmUoKSB7Ci0JCXRyeSB7Ci0JCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJCUhhc2hCYWc8RT4gY2xvbmUgPSAoSGFzaEJhZzxFPikgc3VwZXIuY2xvbmUoKTsKLQkJCWNsb25lLnRhYmxlID0gdGhpcy5idWlsZFRhYmxlKHRoaXMudGFibGUubGVuZ3RoKTsKLQkJCWZvciAoaW50IGkgPSB0aGlzLnRhYmxlLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQkJY2xvbmUudGFibGVbaV0gPSAodGhpcy50YWJsZVtpXSA9PSBudWxsKSAKLQkJCQkJCT8gbnVsbCA6IChFbnRyeTxFPikgdGhpcy50YWJsZVtpXS5jbG9uZSgpOwotCQkJfQotCQkJY2xvbmUubW9kQ291bnQgPSAwOwotCQkJcmV0dXJuIGNsb25lOwotCQl9IGNhdGNoIChDbG9uZU5vdFN1cHBvcnRlZEV4Y2VwdGlvbiBlKSB7Ci0JCQl0aHJvdyBuZXcgSW50ZXJuYWxFcnJvcigpOwotCQl9Ci0JfQotCi0KLQkvKioKLQkgKiBIYXNoIHRhYmxlIGNvbGxpc2lvbiBsaXN0IGVudHJ5LgotCSAqLwotCXByaXZhdGUgc3RhdGljIGNsYXNzIEVudHJ5PEU+IGltcGxlbWVudHMgQmFnLkVudHJ5PEU+IHsKLQkJaW50IGhhc2g7Ci0JCUUgb2JqZWN0OwotCQlpbnQgY291bnQ7Ci0JCUVudHJ5PEU+IG5leHQ7Ci0KLQkJRW50cnkoaW50IGhhc2gsIEUgb2JqZWN0LCBFbnRyeTxFPiBuZXh0KSB7Ci0JCQl0aGlzKGhhc2gsIG9iamVjdCwgMSwgbmV4dCk7Ci0JCX0KLQotCQlFbnRyeShpbnQgaGFzaCwgRSBvYmplY3QsIGludCBjb3VudCwgRW50cnk8RT4gbmV4dCkgewotCQkJdGhpcy5oYXNoID0gaGFzaDsKLQkJCXRoaXMub2JqZWN0ID0gb2JqZWN0OwotCQkJdGhpcy5jb3VudCA9IGNvdW50OwotCQkJdGhpcy5uZXh0ID0gbmV4dDsKLQkJfQotCi0JCS8qKgotCQkgKiBDYXNjYWRlIHRoZSBjbG9uZSB0byBhbGwgdGhlIGVudHJpZXMgaW4gdGhlIHNhbWUgYnVja2V0LgotCQkgKi8KLQkJQE92ZXJyaWRlCi0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlwcm90ZWN0ZWQgRW50cnk8RT4gY2xvbmUoKSB7Ci0JCQlyZXR1cm4gbmV3IEVudHJ5KHRoaXMuaGFzaCwgdGhpcy5vYmplY3QsIHRoaXMuY291bnQsCi0JCQkJCSh0aGlzLm5leHQgPT0gbnVsbCA/IG51bGwgOiB0aGlzLm5leHQuY2xvbmUoKSkpOwotCQl9Ci0KLQkJLy8gKioqKiogQmFnLkVudHJ5IGltcGxlbWVudGF0aW9uCi0JCXB1YmxpYyBFIGdldEVsZW1lbnQoKSB7Ci0JCQlyZXR1cm4gdGhpcy5vYmplY3Q7Ci0JCX0KLQotCQlwdWJsaWMgaW50IGdldENvdW50KCkgewotCQkJcmV0dXJuIHRoaXMuY291bnQ7Ci0JCX0KLQotCQlwdWJsaWMgaW50IHNldENvdW50KGludCBjb3VudCkgewotCQkJaWYgKGNvdW50IDw9IDApIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJjb3VudCBtdXN0IGJlIGdyZWF0ZXIgdGhhbiB6ZXJvOiAiICsgY291bnQpOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCQlpbnQgb2xkID0gdGhpcy5jb3VudDsKLQkJCXRoaXMuY291bnQgPSBjb3VudDsKLQkJCXJldHVybiBvbGQ7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIGJvb2xlYW4gZXF1YWxzKE9iamVjdCBvKSB7Ci0JCQlpZiAoICEgKG8gaW5zdGFuY2VvZiBCYWcuRW50cnkpKSB7Ci0JCQkJcmV0dXJuIGZhbHNlOwotCQkJfQotCQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCQlCYWcuRW50cnkgZSA9IChCYWcuRW50cnkpIG87Ci0JCQlpZiAodGhpcy5jb3VudCAhPSBlLmdldENvdW50KCkpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCQlPYmplY3QgbzEgPSB0aGlzLm9iamVjdDsKLQkJCU9iamVjdCBvMiA9IGUuZ2V0RWxlbWVudCgpOwotCQkJaWYgKG8xID09IG8yKSB7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0JCQlpZiAobzEgPT0gbnVsbCkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJCXJldHVybiBvMS5lcXVhbHMobzIpOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBpbnQgaGFzaENvZGUoKSB7Ci0JCQlFIG8gPSB0aGlzLm9iamVjdDsKLQkJCXJldHVybiAobyA9PSBudWxsKSA/IDAgOiAodGhpcy5jb3VudCAqIG8uaGFzaENvZGUoKSk7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiB0aGlzLm9iamVjdCArICI9PiIgKyB0aGlzLmNvdW50OyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLQotCUBPdmVycmlkZQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXB1YmxpYyBJdGVyYXRvcjxFPiBpdGVyYXRvcigpIHsKLQkJcmV0dXJuICh0aGlzLmNvdW50ID09IDApID8gRU1QVFlfSVRFUkFUT1IgOiBuZXcgSGFzaEl0ZXJhdG9yKCk7Ci0JfQotCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHVibGljIEl0ZXJhdG9yPEU+IHVuaXF1ZUl0ZXJhdG9yKCkgewotCQlyZXR1cm4gKHRoaXMuY291bnQgPT0gMCkgPyBFTVBUWV9JVEVSQVRPUiA6IG5ldyBVbmlxdWVJdGVyYXRvcigpOwotCX0KLQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXB1YmxpYyBJdGVyYXRvcjxCYWcuRW50cnk8RT4+IGVudHJpZXMoKSB7Ci0JCXJldHVybiAodGhpcy5jb3VudCA9PSAwKSA/IEVNUFRZX0lURVJBVE9SIDogbmV3IEVudHJ5SXRlcmF0b3IoKTsKLQl9Ci0KLQotCS8qKgotCSAqIEVtcHR5IGl0ZXJhdG9yIHRoYXQgZG9lcyBqdXN0IGFib3V0IG5vdGhpbmcuCi0JICovCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgSXRlcmF0b3IgRU1QVFlfSVRFUkFUT1IgPSBuZXcgRW1wdHlJdGVyYXRvcigpOwotCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJpdmF0ZSBzdGF0aWMgY2xhc3MgRW1wdHlJdGVyYXRvciBpbXBsZW1lbnRzIEl0ZXJhdG9yIHsKLQotCQlFbXB0eUl0ZXJhdG9yKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCi0JCXB1YmxpYyBib29sZWFuIGhhc05leHQoKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQotCQlwdWJsaWMgT2JqZWN0IG5leHQoKSB7Ci0JCQl0aHJvdyBuZXcgTm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpOwotCQl9Ci0KLQkJcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigpOwotCQl9Ci0JfQotCi0KLQlwcml2YXRlIGNsYXNzIEhhc2hJdGVyYXRvciBpbXBsZW1lbnRzIEl0ZXJhdG9yPEU+IHsKLQkJcHJpdmF0ZSBFbnRyeTxFPltdIGxvY2FsVGFibGUgPSBIYXNoQmFnLnRoaXMudGFibGU7Ci0JCXByaXZhdGUgaW50IGluZGV4ID0gdGhpcy5sb2NhbFRhYmxlLmxlbmd0aDsJLy8gc3RhcnQgYXQgdGhlIGVuZCBvZiB0aGUgdGFibGUKLQkJcHJpdmF0ZSBFbnRyeTxFPiBuZXh0RW50cnkgPSBudWxsOwotCQlwcml2YXRlIGludCBuZXh0RW50cnlDb3VudCA9IDA7Ci0JCXByaXZhdGUgRW50cnk8RT4gbGFzdFJldHVybmVkRW50cnkgPSBudWxsOwotCi0JCS8qKgotCQkgKiBUaGUgbW9kQ291bnQgdmFsdWUgdGhhdCB0aGUgaXRlcmF0b3IgYmVsaWV2ZXMgdGhhdCB0aGUgYmFja2luZwotCQkgKiBiYWcgc2hvdWxkIGhhdmUuIElmIHRoaXMgZXhwZWN0YXRpb24gaXMgdmlvbGF0ZWQsIHRoZSBpdGVyYXRvcgotCQkgKiBoYXMgZGV0ZWN0ZWQgYSBjb25jdXJyZW50IG1vZGlmaWNhdGlvbi4KLQkJICovCi0JCXByaXZhdGUgaW50IGV4cGVjdGVkTW9kQ291bnQgPSBIYXNoQmFnLnRoaXMubW9kQ291bnQ7Ci0KLQkJSGFzaEl0ZXJhdG9yKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCi0JCXB1YmxpYyBib29sZWFuIGhhc05leHQoKSB7Ci0JCQlFbnRyeTxFPiBlID0gdGhpcy5uZXh0RW50cnk7Ci0JCQlpbnQgaSA9IHRoaXMuaW5kZXg7Ci0JCQlFbnRyeTxFPltdIHRhYiA9IHRoaXMubG9jYWxUYWJsZTsKLQkJCS8vIFVzZSBsb2NhbHMgZm9yIGZhc3RlciBsb29wIGl0ZXJhdGlvbgotCQkJd2hpbGUgKChlID09IG51bGwpICYmIChpID4gMCkpIHsKLQkJCQllID0gdGFiWy0taV07CQkvLyBtb3ZlIGJhY2t3YXJkcyB0aHJvdWdoIHRoZSB0YWJsZQotCQkJfQotCQkJdGhpcy5uZXh0RW50cnkgPSBlOwotCQkJdGhpcy5pbmRleCA9IGk7Ci0JCQlyZXR1cm4gZSAhPSBudWxsOwotCQl9Ci0KLQkJcHVibGljIEUgbmV4dCgpIHsKLQkJCWlmIChIYXNoQmFnLnRoaXMubW9kQ291bnQgIT0gdGhpcy5leHBlY3RlZE1vZENvdW50KSB7Ci0JCQkJdGhyb3cgbmV3IENvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24oKTsKLQkJCX0KLQkJCUVudHJ5PEU+IGV0ID0gdGhpcy5uZXh0RW50cnk7Ci0JCQlpbnQgaSA9IHRoaXMuaW5kZXg7Ci0JCQlFbnRyeTxFPltdIHRhYiA9IHRoaXMubG9jYWxUYWJsZTsKLQkJCS8vIFVzZSBsb2NhbHMgZm9yIGZhc3RlciBsb29wIGl0ZXJhdGlvbgotCQkJd2hpbGUgKChldCA9PSBudWxsKSAmJiAoaSA+IDApKSB7Ci0JCQkJZXQgPSB0YWJbLS1pXTsJCS8vIG1vdmUgYmFja3dhcmRzIHRocm91Z2ggdGhlIHRhYmxlCi0JCQl9Ci0JCQl0aGlzLm5leHRFbnRyeSA9IGV0OwotCQkJdGhpcy5pbmRleCA9IGk7Ci0JCQlpZiAoZXQgPT0gbnVsbCkgewotCQkJCXRocm93IG5ldyBOb1N1Y2hFbGVtZW50RXhjZXB0aW9uKCk7Ci0JCQl9Ci0JCQlFbnRyeTxFPiBlID0gdGhpcy5sYXN0UmV0dXJuZWRFbnRyeSA9IHRoaXMubmV4dEVudHJ5OwotCQkJdGhpcy5uZXh0RW50cnlDb3VudCsrOwotCQkJaWYgKHRoaXMubmV4dEVudHJ5Q291bnQgPT0gZS5jb3VudCkgewotCQkJCXRoaXMubmV4dEVudHJ5ID0gZS5uZXh0OwotCQkJCXRoaXMubmV4dEVudHJ5Q291bnQgPSAwOwotCQkJfQotCQkJcmV0dXJuIGUub2JqZWN0OwotCQl9Ci0KLQkJcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQkJaWYgKHRoaXMubGFzdFJldHVybmVkRW50cnkgPT0gbnVsbCkgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oKTsKLQkJCX0KLQkJCWlmIChIYXNoQmFnLnRoaXMubW9kQ291bnQgIT0gdGhpcy5leHBlY3RlZE1vZENvdW50KSB7Ci0JCQkJdGhyb3cgbmV3IENvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24oKTsKLQkJCX0KLQkJCUVudHJ5PEU+W10gdGFiID0gdGhpcy5sb2NhbFRhYmxlOwotCQkJaW50IHNsb3QgPSAodGhpcy5sYXN0UmV0dXJuZWRFbnRyeS5oYXNoICYgMHg3RkZGRkZGRikgJSB0YWIubGVuZ3RoOwotCQkJZm9yIChFbnRyeTxFPiBlID0gdGFiW3Nsb3RdLCBwcmV2ID0gbnVsbDsgZSAhPSBudWxsOyBwcmV2ID0gZSwgZSA9IGUubmV4dCkgewotCQkJCWlmIChlID09IHRoaXMubGFzdFJldHVybmVkRW50cnkpIHsKLQkJCQkJSGFzaEJhZy50aGlzLm1vZENvdW50Kys7Ci0JCQkJCXRoaXMuZXhwZWN0ZWRNb2RDb3VudCsrOwotCQkJCQllLmNvdW50LS07Ci0JCQkJCWlmIChlLmNvdW50ID09IDApIHsKLQkJCQkJCS8vIGlmIHdlIGFyZSByZW1vdmluZyB0aGUgbGFzdCBvbmUsIHJlbW92ZSB0aGUgZW50cnkgZnJvbSB0aGUgdGFibGUKLQkJCQkJCWlmIChwcmV2ID09IG51bGwpIHsKLQkJCQkJCQl0YWJbc2xvdF0gPSBlLm5leHQ7Ci0JCQkJCQl9IGVsc2UgewotCQkJCQkJCXByZXYubmV4dCA9IGUubmV4dDsKLQkJCQkJCX0KLQkJCQkJCUhhc2hCYWcudGhpcy51bmlxdWVDb3VudC0tOwotCQkJCQl9IGVsc2UgewotCQkJCQkJLy8gc2xpZGUgYmFjayB0aGUgY291bnQgdG8gYWNjb3VudCBmb3IgdGhlIGp1c3QtcmVtb3ZlZCBlbGVtZW50Ci0JCQkJCQl0aGlzLm5leHRFbnRyeUNvdW50LS07Ci0JCQkJCX0KLQkJCQkJSGFzaEJhZy50aGlzLmNvdW50LS07Ci0JCQkJCXRoaXMubGFzdFJldHVybmVkRW50cnkgPSBudWxsOwkvLyBpdCBjYW5ub3QgYmUgcmVtb3ZlZCBhZ2FpbgotCQkJCQlyZXR1cm47Ci0JCQkJfQotCQkJfQotCQkJdGhyb3cgbmV3IENvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24oKTsKLQkJfQotCi0JfQotCi0KLQlwcml2YXRlIGNsYXNzIEVudHJ5SXRlcmF0b3IgaW1wbGVtZW50cyBJdGVyYXRvcjxFbnRyeTxFPj4gewotCQlwcml2YXRlIEVudHJ5PEU+W10gbG9jYWxUYWJsZSA9IEhhc2hCYWcudGhpcy50YWJsZTsKLQkJcHJpdmF0ZSBpbnQgaW5kZXggPSB0aGlzLmxvY2FsVGFibGUubGVuZ3RoOwkvLyBzdGFydCBhdCB0aGUgZW5kIG9mIHRoZSB0YWJsZQotCQlwcml2YXRlIEVudHJ5PEU+IG5leHRFbnRyeSA9IG51bGw7Ci0JCXByaXZhdGUgRW50cnk8RT4gbGFzdFJldHVybmVkRW50cnkgPSBudWxsOwotCi0JCS8qKgotCQkgKiBUaGUgbW9kQ291bnQgdmFsdWUgdGhhdCB0aGUgaXRlcmF0b3IgYmVsaWV2ZXMgdGhhdCB0aGUgYmFja2luZwotCQkgKiBiYWcgc2hvdWxkIGhhdmUuIElmIHRoaXMgZXhwZWN0YXRpb24gaXMgdmlvbGF0ZWQsIHRoZSBpdGVyYXRvcgotCQkgKiBoYXMgZGV0ZWN0ZWQgYSBjb25jdXJyZW50IG1vZGlmaWNhdGlvbi4KLQkJICovCi0JCXByaXZhdGUgaW50IGV4cGVjdGVkTW9kQ291bnQgPSBIYXNoQmFnLnRoaXMubW9kQ291bnQ7Ci0KLQkJRW50cnlJdGVyYXRvcigpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQotCQlwdWJsaWMgYm9vbGVhbiBoYXNOZXh0KCkgewotCQkJRW50cnk8RT4gZSA9IHRoaXMubmV4dEVudHJ5OwotCQkJaW50IGkgPSB0aGlzLmluZGV4OwotCQkJRW50cnk8RT5bXSB0YWIgPSB0aGlzLmxvY2FsVGFibGU7Ci0JCQkvLyBVc2UgbG9jYWxzIGZvciBmYXN0ZXIgbG9vcCBpdGVyYXRpb24KLQkJCXdoaWxlICgoZSA9PSBudWxsKSAmJiAoaSA+IDApKSB7Ci0JCQkJZSA9IHRhYlstLWldOwkJLy8gbW92ZSBiYWNrd2FyZHMgdGhyb3VnaCB0aGUgdGFibGUKLQkJCX0KLQkJCXRoaXMubmV4dEVudHJ5ID0gZTsKLQkJCXRoaXMuaW5kZXggPSBpOwotCQkJcmV0dXJuIGUgIT0gbnVsbDsKLQkJfQotCi0JCXB1YmxpYyBFbnRyeTxFPiBuZXh0KCkgewotCQkJaWYgKEhhc2hCYWcudGhpcy5tb2RDb3VudCAhPSB0aGlzLmV4cGVjdGVkTW9kQ291bnQpIHsKLQkJCQl0aHJvdyBuZXcgQ29uY3VycmVudE1vZGlmaWNhdGlvbkV4Y2VwdGlvbigpOwotCQkJfQotCQkJRW50cnk8RT4gZXQgPSB0aGlzLm5leHRFbnRyeTsKLQkJCWludCBpID0gdGhpcy5pbmRleDsKLQkJCUVudHJ5PEU+W10gdGFiID0gdGhpcy5sb2NhbFRhYmxlOwotCQkJLy8gVXNlIGxvY2FscyBmb3IgZmFzdGVyIGxvb3AgaXRlcmF0aW9uCi0JCQl3aGlsZSAoKGV0ID09IG51bGwpICYmIChpID4gMCkpIHsKLQkJCQlldCA9IHRhYlstLWldOwkJLy8gbW92ZSBiYWNrd2FyZHMgdGhyb3VnaCB0aGUgdGFibGUKLQkJCX0KLQkJCXRoaXMubmV4dEVudHJ5ID0gZXQ7Ci0JCQl0aGlzLmluZGV4ID0gaTsKLQkJCWlmIChldCA9PSBudWxsKSB7Ci0JCQkJdGhyb3cgbmV3IE5vU3VjaEVsZW1lbnRFeGNlcHRpb24oKTsKLQkJCX0KLQkJCUVudHJ5PEU+IGUgPSB0aGlzLmxhc3RSZXR1cm5lZEVudHJ5ID0gdGhpcy5uZXh0RW50cnk7Ci0JCQl0aGlzLm5leHRFbnRyeSA9IGUubmV4dDsKLQkJCXJldHVybiBlOwotCQl9Ci0KLQkJcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQkJaWYgKHRoaXMubGFzdFJldHVybmVkRW50cnkgPT0gbnVsbCkgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oKTsKLQkJCX0KLQkJCWlmIChIYXNoQmFnLnRoaXMubW9kQ291bnQgIT0gdGhpcy5leHBlY3RlZE1vZENvdW50KSB7Ci0JCQkJdGhyb3cgbmV3IENvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24oKTsKLQkJCX0KLQkJCUVudHJ5PEU+W10gdGFiID0gdGhpcy5sb2NhbFRhYmxlOwotCQkJaW50IHNsb3QgPSAodGhpcy5sYXN0UmV0dXJuZWRFbnRyeS5oYXNoICYgMHg3RkZGRkZGRikgJSB0YWIubGVuZ3RoOwotCQkJZm9yIChFbnRyeTxFPiBlID0gdGFiW3Nsb3RdLCBwcmV2ID0gbnVsbDsgZSAhPSBudWxsOyBwcmV2ID0gZSwgZSA9IGUubmV4dCkgewotCQkJCWlmIChlID09IHRoaXMubGFzdFJldHVybmVkRW50cnkpIHsKLQkJCQkJSGFzaEJhZy50aGlzLm1vZENvdW50Kys7Ci0JCQkJCXRoaXMuZXhwZWN0ZWRNb2RDb3VudCsrOwotCQkJCQkvLyByZW1vdmUgdGhlIGVudHJ5IGZyb20gdGhlIHRhYmxlCi0JCQkJCWlmIChwcmV2ID09IG51bGwpIHsKLQkJCQkJCXRhYltzbG90XSA9IGUubmV4dDsKLQkJCQkJfSBlbHNlIHsKLQkJCQkJCXByZXYubmV4dCA9IGUubmV4dDsKLQkJCQkJfQotCQkJCQlIYXNoQmFnLnRoaXMudW5pcXVlQ291bnQtLTsKLQkJCQkJSGFzaEJhZy50aGlzLmNvdW50IC09IHRoaXMubGFzdFJldHVybmVkRW50cnkuY291bnQ7Ci0JCQkJCXRoaXMubGFzdFJldHVybmVkRW50cnkgPSBudWxsOwkvLyBpdCBjYW5ub3QgYmUgcmVtb3ZlZCBhZ2FpbgotCQkJCQlyZXR1cm47Ci0JCQkJfQotCQkJfQotCQkJdGhyb3cgbmV3IENvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24oKTsKLQkJfQotCi0JfQotCi0KLQlwcml2YXRlIGNsYXNzIFVuaXF1ZUl0ZXJhdG9yIGltcGxlbWVudHMgSXRlcmF0b3I8RT4gewotCQlwcml2YXRlIEVudHJ5SXRlcmF0b3IgZW50cnlJdGVyYXRvciA9IG5ldyBFbnRyeUl0ZXJhdG9yKCk7Ci0JCQotCQlVbmlxdWVJdGVyYXRvcigpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQotCQlwdWJsaWMgYm9vbGVhbiBoYXNOZXh0KCkgewotCQkJcmV0dXJuIHRoaXMuZW50cnlJdGVyYXRvci5oYXNOZXh0KCk7Ci0JCX0KLQotCQlwdWJsaWMgRSBuZXh0KCkgewotCQkJcmV0dXJuIHRoaXMuZW50cnlJdGVyYXRvci5uZXh0KCkub2JqZWN0OwotCQl9Ci0KLQkJcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQkJdGhpcy5lbnRyeUl0ZXJhdG9yLnJlbW92ZSgpOwotCQl9Ci0KLQl9Ci0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBib29sZWFuIGVxdWFscyhPYmplY3QgbykgewotCQlpZiAobyA9PSB0aGlzKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCQlpZiAoICEgKG8gaW5zdGFuY2VvZiBCYWcpKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCUJhZzxFPiBiID0gKEJhZzxFPikgbzsKLQkJaWYgKGIuc2l6ZSgpICE9IHRoaXMuc2l6ZSgpKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJQmFnPEU+IGNsb25lID0gdGhpcy5jbG9uZSgpOwotCQlmb3IgKEUgZSA6IGIpIHsKLQkJCWlmICggISBjbG9uZS5yZW1vdmUoZSkpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGNsb25lLmlzRW1wdHkoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgaW50IGhhc2hDb2RlKCkgewotCQlpbnQgaCA9IDA7Ci0JCWZvciAoSXRlcmF0b3I8RT4gc3RyZWFtID0gdGhpcy5pdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCU9iamVjdCBuZXh0ID0gc3RyZWFtLm5leHQoKTsKLQkJCWlmIChuZXh0ICE9IG51bGwpIHsKLQkJCQloICs9IG5leHQuaGFzaENvZGUoKTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gaDsKLQl9Ci0KLQkvKioKLQkgKiBTYXZlIHRoZSBzdGF0ZSBvZiB0aGlzIGJhZyB0byBhIHN0cmVhbSAoaS5lLiBzZXJpYWxpemUgaXQpLgotCSAqCi0JICogQHNlcmlhbERhdGEgRW1pdCB0aGUgY2FwYWNpdHkgb2YgdGhlIGJhZyAoaW50KSwKLQkgKiAgICAgZm9sbG93ZWQgYnkgdGhlIG51bWJlciBvZiB1bmlxdWUgZWxlbWVudHMgaW4gdGhlIGJhZyAoaW50KSwKLQkgKiAgICAgZm9sbG93ZWQgYnkgYWxsIG9mIHRoZSBiYWcncyBlbGVtZW50cyAoZWFjaCBhbiBPYmplY3QpIGFuZAotCSAqICAgICB0aGVpciBjb3VudHMgKGVhY2ggYW4gaW50KSwgaW4gbm8gcGFydGljdWxhciBvcmRlci4KLQkgKi8KLQlwcml2YXRlIHN5bmNocm9uaXplZCB2b2lkIHdyaXRlT2JqZWN0KGphdmEuaW8uT2JqZWN0T3V0cHV0U3RyZWFtIHMpCi0JCQkJdGhyb3dzIGphdmEuaW8uSU9FeGNlcHRpb24gewotCQkvLyB3cml0ZSBvdXQgdGhlIHRocmVzaG9sZCwgbG9hZCBmYWN0b3IsIGFuZCBhbnkgaGlkZGVuIHN0dWZmCi0JCXMuZGVmYXVsdFdyaXRlT2JqZWN0KCk7Ci0KLQkJLy8gd3JpdGUgb3V0IG51bWJlciBvZiBidWNrZXRzCi0JCXMud3JpdGVJbnQodGhpcy50YWJsZS5sZW5ndGgpOwotCi0JCS8vIHdyaXRlIG91dCBudW1iZXIgb2YgdW5pcXVlIGVsZW1lbnRzCi0JCXMud3JpdGVJbnQodGhpcy51bmlxdWVDb3VudCk7Ci0KLQkJRW50cnk8RT5bXSB0YWIgPSB0aGlzLnRhYmxlOwotCQkvLyB3cml0ZSBvdXQgZWxlbWVudHMgYW5kIGNvdW50cyAoYWx0ZXJuYXRpbmcpCi0JCWZvciAoRW50cnk8RT4gZW50cnkgOiB0YWIpIHsKLQkJCXdoaWxlIChlbnRyeSAhPSBudWxsKSB7Ci0JCQkJcy53cml0ZU9iamVjdChlbnRyeS5vYmplY3QpOwotCQkJCXMud3JpdGVJbnQoZW50cnkuY291bnQpOwotCQkJCWVudHJ5ID0gZW50cnkubmV4dDsKLQkJCX0KLQkJfQotCX0KLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDFMOwotCi0JLyoqCi0JICogUmVjb25zdGl0dXRlIHRoZSBiYWcgZnJvbSBhIHN0cmVhbSAoaS5lLiBkZXNlcmlhbGl6ZSBpdCkuCi0JICovCi0JcHJpdmF0ZSBzeW5jaHJvbml6ZWQgdm9pZCByZWFkT2JqZWN0KGphdmEuaW8uT2JqZWN0SW5wdXRTdHJlYW0gcykKLQkJCQl0aHJvd3MgamF2YS5pby5JT0V4Y2VwdGlvbiwgQ2xhc3NOb3RGb3VuZEV4Y2VwdGlvbiB7Ci0JCS8vIHJlYWQgaW4gdGhlIHRocmVzaG9sZCwgbG9hZGZhY3RvciwgYW5kIGFueSBoaWRkZW4gc3R1ZmYKLQkJcy5kZWZhdWx0UmVhZE9iamVjdCgpOwotCi0JCS8vIHJlYWQgaW4gbnVtYmVyIG9mIGJ1Y2tldHMgYW5kIGFsbG9jYXRlIHRoZSBidWNrZXQgYXJyYXkKLQkJdGhpcy50YWJsZSA9IHRoaXMuYnVpbGRUYWJsZShzLnJlYWRJbnQoKSk7Ci0KLQkJLy8gcmVhZCBpbiBudW1iZXIgb2YgdW5pcXVlIGVsZW1lbnRzCi0JCWludCB1bmlxdWUgPSBzLnJlYWRJbnQoKTsKLQotCQkvLyByZWFkIHRoZSBlbGVtZW50cyBhbmQgY291bnRzLCBhbmQgcHV0IHRoZSBlbGVtZW50cyBpbiB0aGUgYmFnCi0JCWZvciAoaW50IGkgPSAwOyBpIDwgdW5pcXVlOyBpKyspIHsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJRSBlbGVtZW50ID0gKEUpIHMucmVhZE9iamVjdCgpOwotCQkJaW50IGVsZW1lbnRDb3VudCA9IHMucmVhZEludCgpOwotCQkJdGhpcy5hZGQoZWxlbWVudCwgZWxlbWVudENvdW50KTsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0lkZW50aXR5SGFzaEJhZy5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0lkZW50aXR5SGFzaEJhZy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1MjNhMzkwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9JZGVudGl0eUhhc2hCYWcuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDg3OCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsOwotCi1pbXBvcnQgamF2YS5pby5TZXJpYWxpemFibGU7Ci1pbXBvcnQgamF2YS51dGlsLkFic3RyYWN0Q29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuQ29uY3VycmVudE1vZGlmaWNhdGlvbkV4Y2VwdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci0KLS8qKgotICogVGhpcyBjbGFzcyBpbXBsZW1lbnRzIHRoZSA8Y29kZT5CYWc8L2NvZGU+IGludGVyZmFjZSB3aXRoIGEKLSAqIGhhc2ggdGFibGUsIHVzaW5nIG9iamVjdC1pZGVudGl0eSBpbiBwbGFjZSBvZiBvYmplY3QtZXF1YWxpdHkgd2hlbgotICogY29tcGFyaW5nIGVsZW1lbnRzLiBJbiBvdGhlciB3b3JkcywgaW4gYW4gPGNvZGU+SWRlbnRpdHlIYXNoQmFnPC9jb2RlPiwKLSAqIHR3byBvYmplY3RzIDxjb2RlPmsxPC9jb2RlPiBhbmQgPGNvZGU+azI8L2NvZGU+IGFyZSBjb25zaWRlcmVkCi0gKiBlcXVhbCBpZiBhbmQgb25seSBpZiA8Y29kZT4oazEgPT0gazIpPC9jb2RlPi4gKEluIG5vcm1hbCA8Y29kZT5CYWc8L2NvZGU+Ci0gKiBpbXBsZW1lbnRhdGlvbnMgKGxpa2UgPGNvZGU+SGFzaEJhZzwvY29kZT4pIHR3byBvYmplY3RzIDxjb2RlPmsxPC9jb2RlPgotICogYW5kIDxjb2RlPmsyPC9jb2RlPiBhcmUgY29uc2lkZXJlZCBlcXVhbCBpZiBhbmQgb25seSBpZgotICogPGNvZGU+KGsxID09IG51bGwgPyBrMiA9PSBudWxsIDogazEuZXF1YWxzKGsyKSk8L2NvZGU+LikKLSAqIDxwPgotICogPGI+Ci0gKiBUaGlzIGNsYXNzIGlzIDxpPm5vdDwvaT4gYSBnZW5lcmFsLXB1cnBvc2UgPGNvZGU+QmFnPC9jb2RlPgotICogaW1wbGVtZW50YXRpb24hIFdoaWxlIHRoaXMgY2xhc3MgaW1wbGVtZW50cyB0aGUgPGNvZGU+QmFnPC9jb2RlPiBpbnRlcmZhY2UsIGl0Ci0gKiBpbnRlbnRpb25hbGx5IHZpb2xhdGVzIDxjb2RlPkJhZydzPC9jb2RlPiBnZW5lcmFsIGNvbnRyYWN0LCB3aGljaCBtYW5kYXRlcyB0aGUKLSAqIHVzZSBvZiB0aGUgPGNvZGU+ZXF1YWxzPC9jb2RlPiBtZXRob2Qgd2hlbiBjb21wYXJpbmcgb2JqZWN0cy4gVGhpcyBjbGFzcyBpcwotICogZGVzaWduZWQgZm9yIHVzZSBvbmx5IGluIHRoZSByYXJlIGNhc2VzIHdoZXJlaW4gb2JqZWN0LWlkZW50aXR5Ci0gKiBzZW1hbnRpY3MgYXJlIHJlcXVpcmVkLgotICogPC9iPgotICogPHA+Ci0gKiBUaGlzIGNsYXNzIG1ha2VzIG5vIGd1YXJhbnRlZXMgYXMgdG8gdGhlIGl0ZXJhdGlvbiBvcmRlciBvZgotICogdGhlIGJhZydzIGVsZW1lbnRzOyBpbiBwYXJ0aWN1bGFyLCBpdCBkb2VzIG5vdCBndWFyYW50ZWUgdGhhdCB0aGUgb3JkZXIKLSAqIHdpbGwgcmVtYWluIGNvbnN0YW50IG92ZXIgdGltZS4gVGhpcyBjbGFzcyBwZXJtaXRzIHRoZSA8Y29kZT5udWxsPC9jb2RlPgotICogZWxlbWVudC4KLSAqIDxwPgotICogVGhpcyBjbGFzcyBvZmZlcnMgY29uc3RhbnQgdGltZSBwZXJmb3JtYW5jZSBmb3IgdGhlIGJhc2ljIG9wZXJhdGlvbnMKLSAqICg8Y29kZT5hZGQ8L2NvZGU+LCA8Y29kZT5yZW1vdmU8L2NvZGU+LCA8Y29kZT5jb250YWluczwvY29kZT4gYW5kCi0gKiA8Y29kZT5zaXplPC9jb2RlPiksIGFzc3VtaW5nIHRoZSBzeXN0ZW0gaWRlbnRpdHkgaGFzaCBmdW5jdGlvbgotICogKHtAbGluayBTeXN0ZW0jaWRlbnRpdHlIYXNoQ29kZShPYmplY3QpfSkgZGlzcGVyc2VzIGVsZW1lbnRzIHByb3Blcmx5Ci0gKiBhbW9uZyB0aGUgYnVja2V0cy4gSXRlcmF0aW5nIG92ZXIgdGhpcyBiYWcgcmVxdWlyZXMgdGltZQotICogcHJvcG9ydGlvbmFsIHRvIHRoZSBzdW0gb2YgdGhlIGJhZydzIHNpemUgKHRoZSBudW1iZXIgb2YgZWxlbWVudHMpIHBsdXMgdGhlCi0gKiAiY2FwYWNpdHkiIG9mIHRoZSBiYWNraW5nIGhhc2ggdGFibGUgKHRoZSBudW1iZXIgb2YgYnVja2V0cykuIFRodXMsIGl0IGlzCi0gKiBpbXBvcnRhbnQgbm90IHRvIHNldCB0aGUgaW5pdGlhbCBjYXBhY2l0eSB0b28gaGlnaCAob3IgdGhlIGxvYWQgZmFjdG9yIHRvbwotICogbG93KSBpZiBpdGVyYXRpb24gcGVyZm9ybWFuY2UgaXMgaW1wb3J0YW50LgotICogPHA+Ci0gKiA8Yj5Ob3RlIHRoYXQgdGhpcyBpbXBsZW1lbnRhdGlvbiBpcyBub3Qgc3luY2hyb25pemVkLjwvYj4gSWYgbXVsdGlwbGUKLSAqIHRocmVhZHMgYWNjZXNzIGEgYmFnIGNvbmN1cnJlbnRseSwgYW5kIGF0IGxlYXN0IG9uZSBvZiB0aGUgdGhyZWFkcyBtb2RpZmllcwotICogdGhlIGJhZywgaXQgPGk+bXVzdDwvaT4gYmUgc3luY2hyb25pemVkIGV4dGVybmFsbHkuIFRoaXMgaXMgdHlwaWNhbGx5Ci0gKiBhY2NvbXBsaXNoZWQgYnkgc3luY2hyb25pemluZyBvbiBzb21lIG9iamVjdCB0aGF0IG5hdHVyYWxseSBlbmNhcHN1bGF0ZXMKLSAqIHRoZSBiYWcuIElmIG5vIHN1Y2ggb2JqZWN0IGV4aXN0cywgdGhlIGJhZyBzaG91bGQgYmUgIndyYXBwZWQiIHVzaW5nIHRoZQotICogPGNvZGU+Q29sbGVjdGlvbnMuc3luY2hyb25pemVkQ29sbGVjdGlvbjwvY29kZT4gbWV0aG9kLiBUaGlzIGlzCi0gKiBiZXN0IGRvbmUgYXQgY3JlYXRpb24gdGltZSwgdG8gcHJldmVudCBhY2NpZGVudGFsIHVuc3luY2hyb25pemVkIGFjY2VzcwotICogdG8gdGhlIGJhZzoKLSAqIDxwcmU+Ci0gKiBDb2xsZWN0aW9uIGMgPSBDb2xsZWN0aW9ucy5zeW5jaHJvbml6ZWRDb2xsZWN0aW9uKG5ldyBJZGVudGl0eUhhc2hCYWcoLi4uKSk7Ci0gKiA8L3ByZT4KLSAqIDxwPgotICogVGhlIGl0ZXJhdG9ycyByZXR1cm5lZCBieSB0aGlzIGNsYXNzJ3MgPGNvZGU+aXRlcmF0b3I8L2NvZGU+IG1ldGhvZCBhcmUKLSAqIDxpPmZhaWwtZmFzdDwvaT46IGlmIHRoZSBiYWcgaXMgbW9kaWZpZWQgYXQgYW55IHRpbWUgYWZ0ZXIgdGhlIGl0ZXJhdG9yIGlzCi0gKiBjcmVhdGVkLCBpbiBhbnkgd2F5IGV4Y2VwdCB0aHJvdWdoIHRoZSBpdGVyYXRvcidzIG93biA8Y29kZT5yZW1vdmU8L2NvZGU+Ci0gKiBtZXRob2QsIHRoZSBpdGVyYXRvciB0aHJvd3MgYSA8Y29kZT5Db25jdXJyZW50TW9kaWZpY2F0aW9uRXhjZXB0aW9uPC9jb2RlPi4KLSAqIFRodXMsIGluIHRoZSBmYWNlIG9mIGNvbmN1cnJlbnQgbW9kaWZpY2F0aW9uLCB0aGUgaXRlcmF0b3IgZmFpbHMgcXVpY2tseQotICogYW5kIGNsZWFubHksIHJhdGhlciB0aGFuIHJpc2tpbmcgYXJiaXRyYXJ5LCBub24tZGV0ZXJtaW5pc3RpYyBiZWhhdmlvciBhdAotICogYW4gdW5kZXRlcm1pbmVkIHRpbWUgaW4gdGhlIGZ1dHVyZS4KLSAqIAotICogQHNlZQlDb2xsZWN0aW9ucyNzeW5jaHJvbml6ZWRDb2xsZWN0aW9uKENvbGxlY3Rpb24pCi0gKi8KLQotcHVibGljIGNsYXNzIElkZW50aXR5SGFzaEJhZzxFPgotCWV4dGVuZHMgQWJzdHJhY3RDb2xsZWN0aW9uPEU+Ci0JaW1wbGVtZW50cyBCYWc8RT4sIENsb25lYWJsZSwgU2VyaWFsaXphYmxlCi17Ci0KLQkvKiogVGhlIGhhc2ggdGFibGUuICovCi0JdHJhbnNpZW50IEVudHJ5PEU+W10gdGFibGU7Ci0KLQkvKiogVGhlIHRvdGFsIG51bWJlciBvZiBlbnRyaWVzIGluIHRoZSBiYWcuICovCi0JdHJhbnNpZW50IGludCBjb3VudCA9IDA7Ci0KLQkvKiogVGhlIG51bWJlciBvZiB1bmlxdWUgZW50cmllcyBpbiB0aGUgYmFnLiAqLwotCXRyYW5zaWVudCBpbnQgdW5pcXVlQ291bnQgPSAwOwotCi0JLyoqCi0JICogVGhlIGhhc2ggdGFibGUgaXMgcmVoYXNoZWQgd2hlbiBpdHMgc2l6ZSBleGNlZWRzIHRoaXMgdGhyZXNob2xkLiAoVGhlCi0JICogdmFsdWUgb2YgdGhpcyBmaWVsZCBpcyAoaW50KShjYXBhY2l0eSAqIGxvYWRGYWN0b3IpLikKLQkgKgotCSAqIEBzZXJpYWwKLQkgKi8KLQlwcml2YXRlIGludCB0aHJlc2hvbGQ7Ci0KLQkvKioKLQkgKiBUaGUgbG9hZCBmYWN0b3IgZm9yIHRoZSBoYXNoIHRhYmxlLgotCSAqCi0JICogQHNlcmlhbAotCSAqLwotCXByaXZhdGUgZmxvYXQgbG9hZEZhY3RvcjsKLQotCS8qKgotCSAqIFRoZSBudW1iZXIgb2YgdGltZXMgdGhpcyBiYWcgaGFzIGJlZW4gc3RydWN0dXJhbGx5IG1vZGlmaWVkLgotCSAqIFN0cnVjdHVyYWwgbW9kaWZpY2F0aW9ucyBhcmUgdGhvc2UgdGhhdCBjaGFuZ2UgdGhlIG51bWJlciBvZiBlbnRyaWVzIGluCi0JICogdGhlIGJhZyBvciBvdGhlcndpc2UgbW9kaWZ5IGl0cyBpbnRlcm5hbCBzdHJ1Y3R1cmUgKGUuZy4gcmVoYXNoKS4KLQkgKiBUaGlzIGZpZWxkIGlzIHVzZWQgdG8gbWFrZSBpdGVyYXRvcnMgb24gdGhpcyBiYWcgZmFpbC1mYXN0LgotCSAqCi0JICogQHNlZSBqYXZhLnV0aWwuQ29uY3VycmVudE1vZGlmaWNhdGlvbkV4Y2VwdGlvbgotCSAqLwotCXRyYW5zaWVudCBpbnQgbW9kQ291bnQgPSAwOwotCi0JLyoqCi0JICogQ29uc3RydWN0cyBhIG5ldywgZW1wdHkgYmFnIHdpdGggdGhlCi0JICogZGVmYXVsdCBjYXBhY2l0eSwgd2hpY2ggaXMgMTEsIGFuZCBsb2FkIGZhY3Rvciwgd2hpY2ggaXMgMC43NS4KLQkgKi8KLQlwdWJsaWMgSWRlbnRpdHlIYXNoQmFnKCkgewotCQl0aGlzKDExLCAwLjc1Zik7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0cyBhIG5ldywgZW1wdHkgYmFnIHdpdGggdGhlIHNwZWNpZmllZCBpbml0aWFsIGNhcGFjaXR5Ci0JICogYW5kIGRlZmF1bHQgbG9hZCBmYWN0b3IsIHdoaWNoIGlzIDAuNzUuCi0JICoKLQkgKiBAcGFyYW0gaW5pdGlhbENhcGFjaXR5IHRoZSBpbml0aWFsIGNhcGFjaXR5IG9mIHRoZSBiYWNraW5nIG1hcC4KLQkgKiBAdGhyb3dzIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpZiB0aGUgaW5pdGlhbCBjYXBhY2l0eSBpcyBsZXNzCi0JICogICAgIHRoYW4gemVyby4KLQkgKi8KLQlwdWJsaWMgSWRlbnRpdHlIYXNoQmFnKGludCBpbml0aWFsQ2FwYWNpdHkpIHsKLQkJdGhpcyhpbml0aWFsQ2FwYWNpdHksIDAuNzVmKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3RzIGEgbmV3LCBlbXB0eSBiYWcgd2l0aAotCSAqIHRoZSBzcGVjaWZpZWQgaW5pdGlhbCBjYXBhY2l0eSBhbmQgdGhlIHNwZWNpZmllZCBsb2FkIGZhY3Rvci4KLQkgKgotCSAqIEBwYXJhbSBpbml0aWFsQ2FwYWNpdHkgdGhlIGluaXRpYWwgY2FwYWNpdHkgb2YgdGhlIGJhY2tpbmcgbWFwLgotCSAqIEBwYXJhbSBsb2FkRmFjdG9yIHRoZSBsb2FkIGZhY3RvciBvZiB0aGUgYmFja2luZyBtYXAuCi0JICogQHRocm93cyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaWYgdGhlIGluaXRpYWwgY2FwYWNpdHkgaXMgbGVzcwotCSAqICAgICB0aGFuIHplcm8sIG9yIGlmIHRoZSBsb2FkIGZhY3RvciBpcyBub25wb3NpdGl2ZS4KLQkgKi8KLQlwdWJsaWMgSWRlbnRpdHlIYXNoQmFnKGludCBpbml0aWFsQ2FwYWNpdHksIGZsb2F0IGxvYWRGYWN0b3IpIHsKLQkJaWYgKGluaXRpYWxDYXBhY2l0eSA8IDApIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oIklsbGVnYWwgSW5pdGlhbCBDYXBhY2l0eTogIiArIGluaXRpYWxDYXBhY2l0eSk7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQlpZiAobG9hZEZhY3RvciA8PSAwIHx8IEZsb2F0LmlzTmFOKGxvYWRGYWN0b3IpKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJJbGxlZ2FsIExvYWQgZmFjdG9yOiAiICsgbG9hZEZhY3Rvcik7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQlpZiAoaW5pdGlhbENhcGFjaXR5ID09IDApIHsKLQkJCWluaXRpYWxDYXBhY2l0eSA9IDE7Ci0JCX0KLQkJdGhpcy5sb2FkRmFjdG9yID0gbG9hZEZhY3RvcjsKLQkJdGhpcy50YWJsZSA9IHRoaXMuYnVpbGRUYWJsZShpbml0aWFsQ2FwYWNpdHkpOwotCQl0aGlzLnRocmVzaG9sZCA9IChpbnQpIChpbml0aWFsQ2FwYWNpdHkgKiBsb2FkRmFjdG9yKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3RzIGEgbmV3IGJhZyBjb250YWluaW5nIHRoZSBlbGVtZW50cyBpbiB0aGUgc3BlY2lmaWVkCi0JICogY29sbGVjdGlvbi4gVGhlIGNhcGFjaXR5IG9mIHRoZSBiYWcgaXMKLQkgKiB0d2ljZSB0aGUgc2l6ZSBvZiB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24gb3IgMTEgKHdoaWNoZXZlciBpcwotCSAqIGdyZWF0ZXIpLCBhbmQgdGhlIGRlZmF1bHQgbG9hZCBmYWN0b3IsIHdoaWNoIGlzIDAuNzUsIGlzIHVzZWQuCi0JICoKLQkgKiBAcGFyYW0gYyB0aGUgY29sbGVjdGlvbiB3aG9zZSBlbGVtZW50cyBhcmUgdG8gYmUgcGxhY2VkIGludG8gdGhpcyBiYWcuCi0JICovCi0JcHVibGljIElkZW50aXR5SGFzaEJhZyhDb2xsZWN0aW9uPD8gZXh0ZW5kcyBFPiBjKSB7Ci0JCXRoaXMoTWF0aC5tYXgoMipjLnNpemUoKSwgMTEpKTsKLQkJdGhpcy5hZGRBbGwoYyk7Ci0JfQotCi0JLyoqCi0JICogVGhpcyBpbXBsZW1lbnRhdGlvbiBzaW1wbHkgcmV0dXJucyB0aGUgbWFpbnRhaW5lZCBjb3VudC4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgaW50IHNpemUoKSB7Ci0JCXJldHVybiB0aGlzLmNvdW50OwotCX0KLQotCS8qKgotCSAqIFRoaXMgaW1wbGVtZW50YXRpb24gc2ltcGx5IGNvbXBhcmVzIHRoZSBtYWludGFpbmVkIGNvdW50IHRvIHplcm8uCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIGJvb2xlYW4gaXNFbXB0eSgpIHsKLQkJcmV0dXJuIHRoaXMuY291bnQgPT0gMDsKLQl9Ci0KLQkvKioKLQkgKiBUaGlzIGltcGxlbWVudGF0aW9uIHNlYXJjaGVzIGZvciB0aGUgb2JqZWN0IGluIHRoZSBoYXNoIHRhYmxlIGJ5Ci0JICogY2FsY3VsYXRpbmcgdGhlIG9iamVjdCdzIGlkZW50aXR5IGhhc2ggY29kZSBhbmQgZXhhbWluaW5nIHRoZQotCSAqIGVudHJpZXMgaW4gdGhlIGNvcnJlc3BvbmRpbmcgaGFzaCB0YWJsZSBidWNrZXQuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIGJvb2xlYW4gY29udGFpbnMoT2JqZWN0IG8pIHsKLQkJRW50cnk8RT5bXSB0YWIgPSB0aGlzLnRhYmxlOwotCQlpbnQgaGFzaCA9IFN5c3RlbS5pZGVudGl0eUhhc2hDb2RlKG8pOwotCQlpbnQgaW5kZXggPSAoaGFzaCAmIDB4N0ZGRkZGRkYpICUgdGFiLmxlbmd0aDsKLQkJZm9yIChFbnRyeTxFPiBlID0gdGFiW2luZGV4XTsgZSAhPSBudWxsOyBlID0gZS5uZXh0KSB7Ci0JCQlpZiAoKGUuaGFzaCA9PSBoYXNoKSAmJiAoZS5vYmplY3QgPT0gbykpIHsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JcHVibGljIGludCBjb3VudChPYmplY3QgbykgewotCQlFbnRyeTxFPltdIHRhYiA9IHRoaXMudGFibGU7Ci0JCWludCBoYXNoID0gU3lzdGVtLmlkZW50aXR5SGFzaENvZGUobyk7Ci0JCWludCBpbmRleCA9IChoYXNoICYgMHg3RkZGRkZGRikgJSB0YWIubGVuZ3RoOwotCQlmb3IgKEVudHJ5PEU+IGUgPSB0YWJbaW5kZXhdOyBlICE9IG51bGw7IGUgPSBlLm5leHQpIHsKLQkJCWlmICgoZS5oYXNoID09IGhhc2gpICYmIChlLm9iamVjdCA9PSBvKSkgewotCQkJCXJldHVybiBlLmNvdW50OwotCQkJfQotCQl9Ci0JCXJldHVybiAwOwotCX0KLQotCS8qKgotCSAqIFJlaGFzaGVzIHRoZSBjb250ZW50cyBvZiB0aGlzIGJhZyBpbnRvIGEgbmV3IGhhc2ggdGFibGUKLQkgKiB3aXRoIGEgbGFyZ2VyIGNhcGFjaXR5LiBUaGlzIG1ldGhvZCBpcyBjYWxsZWQgd2hlbiB0aGUKLQkgKiBudW1iZXIgb2YgZGlmZmVyZW50IGVsZW1lbnRzIGluIHRoaXMgbWFwIGV4Y2VlZHMgaXRzCi0JICogY2FwYWNpdHkgYW5kIGxvYWQgZmFjdG9yLgotCSAqLwotCXByaXZhdGUgdm9pZCByZWhhc2goKSB7Ci0JCUVudHJ5PEU+W10gb2xkTWFwID0gdGhpcy50YWJsZTsKLQkJaW50IG9sZENhcGFjaXR5ID0gb2xkTWFwLmxlbmd0aDsKLQotCQlpbnQgbmV3Q2FwYWNpdHkgPSBvbGRDYXBhY2l0eSAqIDIgKyAxOwotCQlFbnRyeTxFPltdIG5ld1RhYmxlID0gdGhpcy5idWlsZFRhYmxlKG5ld0NhcGFjaXR5KTsKLQotCQl0aGlzLm1vZENvdW50Kys7Ci0JCXRoaXMudGhyZXNob2xkID0gKGludCkgKG5ld0NhcGFjaXR5ICogdGhpcy5sb2FkRmFjdG9yKTsKLQkJdGhpcy50YWJsZSA9IG5ld1RhYmxlOwotCi0JCWZvciAoaW50IGkgPSBvbGRDYXBhY2l0eTsgaS0tID4gMDsgKSB7Ci0JCQlmb3IgKEVudHJ5PEU+IG9sZCA9IG9sZE1hcFtpXTsgb2xkICE9IG51bGw7ICkgewotCQkJCUVudHJ5PEU+IGUgPSBvbGQ7Ci0JCQkJb2xkID0gb2xkLm5leHQ7Ci0KLQkJCQlpbnQgaW5kZXggPSAoZS5oYXNoICYgMHg3RkZGRkZGRikgJSBuZXdDYXBhY2l0eTsKLQkJCQllLm5leHQgPSBuZXdUYWJsZVtpbmRleF07Ci0JCQkJbmV3VGFibGVbaW5kZXhdID0gZTsKLQkJCX0KLQkJfQotCX0KLQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByaXZhdGUgRW50cnk8RT5bXSBidWlsZFRhYmxlKGludCBjYXBhY2l0eSkgewotCQlyZXR1cm4gbmV3IEVudHJ5W2NhcGFjaXR5XTsKLQl9Ci0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcml2YXRlIDxUPiBFbnRyeTxFPiBidWlsZEVudHJ5KGludCBoYXNoLCBPYmplY3QgbywgRW50cnk8VD4gbmV4dCkgewotCQlyZXR1cm4gbmV3IEVudHJ5KGhhc2gsIG8sIG5leHQpOwotCX0KLQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByaXZhdGUgPFQ+IEVudHJ5PEU+IGJ1aWxkRW50cnkoaW50IGhhc2gsIE9iamVjdCBvLCBpbnQgY250LCBFbnRyeTxUPiBuZXh0KSB7Ci0JCXJldHVybiBuZXcgRW50cnkoaGFzaCwgbywgY250LCBuZXh0KTsKLQl9Ci0KLQkvKioKLQkgKiBUaGlzIGltcGxlbWVudGF0aW9uIHNlYXJjaGVzIGZvciB0aGUgb2JqZWN0IGluIHRoZSBoYXNoIHRhYmxlIGJ5Ci0JICogY2FsY3VsYXRpbmcgdGhlIG9iamVjdCdzIGlkZW50aXR5IGhhc2ggY29kZSBhbmQgZXhhbWluaW5nIHRoZQotCSAqIGVudHJpZXMgaW4gdGhlIGNvcnJlc3BvbmRpbmcgaGFzaCB0YWJsZSBidWNrZXQuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIGJvb2xlYW4gYWRkKEUgbykgewotCQl0aGlzLm1vZENvdW50Kys7Ci0JCUVudHJ5PEU+W10gdGFiID0gdGhpcy50YWJsZTsKLQkJaW50IGhhc2ggPSAwOwotCQlpbnQgaW5kZXggPSAwOwotCi0JCS8vIGlmIHRoZSBvYmplY3QgaXMgYWxyZWFkeSBpbiB0aGUgYmFnLCBzaW1wbHkgYnVtcCBpdHMgY291bnQKLQkJaGFzaCA9IFN5c3RlbS5pZGVudGl0eUhhc2hDb2RlKG8pOwotCQlpbmRleCA9IChoYXNoICYgMHg3RkZGRkZGRikgJSB0YWIubGVuZ3RoOwotCQlmb3IgKEVudHJ5PEU+IGUgPSB0YWJbaW5kZXhdOyBlICE9IG51bGw7IGUgPSBlLm5leHQpIHsKLQkJCWlmICgoZS5oYXNoID09IGhhc2gpICYmIChlLm9iamVjdCA9PSBvKSkgewotCQkJCWUuY291bnQrKzsKLQkJCQl0aGlzLmNvdW50Kys7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0JCX0KLQotCQkvLyByZWhhc2ggdGhlIHRhYmxlIGlmIHRoZSB0aHJlc2hvbGQgaXMgZXhjZWVkZWQKLQkJaWYgKHRoaXMudW5pcXVlQ291bnQgPj0gdGhpcy50aHJlc2hvbGQpIHsKLQkJCXRoaXMucmVoYXNoKCk7Ci0JCQl0YWIgPSB0aGlzLnRhYmxlOwotCQkJaW5kZXggPSAoaGFzaCAmIDB4N0ZGRkZGRkYpICUgdGFiLmxlbmd0aDsKLQkJfQotCi0JCS8vIGNyZWF0ZSB0aGUgbmV3IGVudHJ5IGFuZCBwdXQgaXQgaW4gdGhlIHRhYmxlCi0JCUVudHJ5PEU+IGUgPSB0aGlzLmJ1aWxkRW50cnkoaGFzaCwgbywgdGFiW2luZGV4XSk7Ci0JCXRhYltpbmRleF0gPSBlOwotCQl0aGlzLmNvdW50Kys7Ci0JCXRoaXMudW5pcXVlQ291bnQrKzsKLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JLyoqCi0JICogVGhpcyBpbXBsZW1lbnRhdGlvbiBzZWFyY2hlcyBmb3IgdGhlIG9iamVjdCBpbiB0aGUgaGFzaCB0YWJsZSBieQotCSAqIGNhbGN1bGF0aW5nIHRoZSBvYmplY3QncyBpZGVudGl0eSBoYXNoIGNvZGUgYW5kIGV4YW1pbmluZyB0aGUKLQkgKiBlbnRyaWVzIGluIHRoZSBjb3JyZXNwb25kaW5nIGhhc2ggdGFibGUgYnVja2V0LgotCSAqLwotCXB1YmxpYyBib29sZWFuIGFkZChFIG8sIGludCBjbnQpIHsKLQkJaWYgKGNudCA8PSAwKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJdGhpcy5tb2RDb3VudCsrOwotCQlFbnRyeTxFPltdIHRhYiA9IHRoaXMudGFibGU7Ci0JCWludCBoYXNoID0gMDsKLQkJaW50IGluZGV4ID0gMDsKLQotCQkvLyBpZiB0aGUgb2JqZWN0IGlzIGFscmVhZHkgaW4gdGhlIGJhZywgc2ltcGx5IGJ1bXAgaXRzIGNvdW50Ci0JCWhhc2ggPSBTeXN0ZW0uaWRlbnRpdHlIYXNoQ29kZShvKTsKLQkJaW5kZXggPSAoaGFzaCAmIDB4N0ZGRkZGRkYpICUgdGFiLmxlbmd0aDsKLQkJZm9yIChFbnRyeTxFPiBlID0gdGFiW2luZGV4XTsgZSAhPSBudWxsOyBlID0gZS5uZXh0KSB7Ci0JCQlpZiAoKGUuaGFzaCA9PSBoYXNoKSAmJiAoZS5vYmplY3QgPT0gbykpIHsKLQkJCQllLmNvdW50ICs9IGNudDsKLQkJCQl0aGlzLmNvdW50ICs9IGNudDsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQkJfQotCi0JCS8vIHJlaGFzaCB0aGUgdGFibGUgaWYgdGhlIHRocmVzaG9sZCBpcyBleGNlZWRlZAotCQlpZiAodGhpcy51bmlxdWVDb3VudCA+PSB0aGlzLnRocmVzaG9sZCkgewotCQkJdGhpcy5yZWhhc2goKTsKLQkJCXRhYiA9IHRoaXMudGFibGU7Ci0JCQlpbmRleCA9IChoYXNoICYgMHg3RkZGRkZGRikgJSB0YWIubGVuZ3RoOwotCQl9Ci0KLQkJLy8gY3JlYXRlIHRoZSBuZXcgZW50cnkgYW5kIHB1dCBpdCBpbiB0aGUgdGFibGUKLQkJRW50cnk8RT4gZSA9IHRoaXMuYnVpbGRFbnRyeShoYXNoLCBvLCBjbnQsIHRhYltpbmRleF0pOwotCQl0YWJbaW5kZXhdID0gZTsKLQkJdGhpcy5jb3VudCArPSBjbnQ7Ci0JCXRoaXMudW5pcXVlQ291bnQrKzsKLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JLyoqCi0JICogVGhpcyBpbXBsZW1lbnRhdGlvbiBzZWFyY2hlcyBmb3IgdGhlIG9iamVjdCBpbiB0aGUgaGFzaCB0YWJsZSBieQotCSAqIGNhbGN1bGF0aW5nIHRoZSBvYmplY3QncyBpZGVudGl0eSBoYXNoIGNvZGUgYW5kIGV4YW1pbmluZyB0aGUKLQkgKiBlbnRyaWVzIGluIHRoZSBjb3JyZXNwb25kaW5nIGhhc2ggdGFibGUgYnVja2V0LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyBib29sZWFuIHJlbW92ZShPYmplY3QgbykgewotCQlFbnRyeTxFPltdIHRhYiA9IHRoaXMudGFibGU7Ci0JCWludCBoYXNoID0gU3lzdGVtLmlkZW50aXR5SGFzaENvZGUobyk7Ci0JCWludCBpbmRleCA9IChoYXNoICYgMHg3RkZGRkZGRikgJSB0YWIubGVuZ3RoOwotCQlmb3IgKEVudHJ5PEU+IGUgPSB0YWJbaW5kZXhdLCBwcmV2ID0gbnVsbDsgZSAhPSBudWxsOyBwcmV2ID0gZSwgZSA9IGUubmV4dCkgewotCQkJaWYgKChlLmhhc2ggPT0gaGFzaCkgJiYgKGUub2JqZWN0ID09IG8pKSB7Ci0JCQkJdGhpcy5tb2RDb3VudCsrOwotCQkJCWUuY291bnQtLTsKLQkJCQkvLyBpZiB3ZSBhcmUgcmVtb3ZpbmcgdGhlIGxhc3Qgb25lLCByZW1vdmUgdGhlIGVudHJ5IGZyb20gdGhlIHRhYmxlCi0JCQkJaWYgKGUuY291bnQgPT0gMCkgewotCQkJCQlpZiAocHJldiA9PSBudWxsKSB7Ci0JCQkJCQl0YWJbaW5kZXhdID0gZS5uZXh0OwotCQkJCQl9IGVsc2UgewotCQkJCQkJcHJldi5uZXh0ID0gZS5uZXh0OwotCQkJCQl9Ci0JCQkJCXRoaXMudW5pcXVlQ291bnQtLTsKLQkJCQl9Ci0JCQkJdGhpcy5jb3VudC0tOwotCQkJCXJldHVybiB0cnVlOwotCQkJfQotCQl9Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQkvKioKLQkgKiBUaGlzIGltcGxlbWVudGF0aW9uIHNlYXJjaGVzIGZvciB0aGUgb2JqZWN0IGluIHRoZSBoYXNoIHRhYmxlIGJ5Ci0JICogY2FsY3VsYXRpbmcgdGhlIG9iamVjdCdzIGlkZW50aXR5IGhhc2ggY29kZSBhbmQgZXhhbWluaW5nIHRoZQotCSAqIGVudHJpZXMgaW4gdGhlIGNvcnJlc3BvbmRpbmcgaGFzaCB0YWJsZSBidWNrZXQuCi0JICovCi0JcHVibGljIGJvb2xlYW4gcmVtb3ZlKE9iamVjdCBvLCBpbnQgY250KSB7Ci0JCWlmIChjbnQgPD0gMCkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCUVudHJ5PEU+W10gdGFiID0gdGhpcy50YWJsZTsKLQkJaW50IGhhc2ggPSBTeXN0ZW0uaWRlbnRpdHlIYXNoQ29kZShvKTsKLQkJaW50IGluZGV4ID0gKGhhc2ggJiAweDdGRkZGRkZGKSAlIHRhYi5sZW5ndGg7Ci0JCWZvciAoRW50cnk8RT4gZSA9IHRhYltpbmRleF0sIHByZXYgPSBudWxsOyBlICE9IG51bGw7IHByZXYgPSBlLCBlID0gZS5uZXh0KSB7Ci0JCQlpZiAoKGUuaGFzaCA9PSBoYXNoKSAmJiAoZS5vYmplY3QgPT0gbykpIHsKLQkJCQl0aGlzLm1vZENvdW50Kys7Ci0JCQkJaW50IGNudDIgPSAoY250IDwgZS5jb3VudCkgPyBjbnQgOiBlLmNvdW50OwotCQkJCWUuY291bnQgLT0gY250MjsKLQkJCQkvLyBpZiB3ZSBhcmUgcmVtb3ZpbmcgdGhlIGxhc3QgZWxlbWVudChzKSwgcmVtb3ZlIHRoZSBlbnRyeSBmcm9tIHRoZSB0YWJsZQotCQkJCWlmIChlLmNvdW50ID09IDApIHsKLQkJCQkJaWYgKHByZXYgPT0gbnVsbCkgewotCQkJCQkJdGFiW2luZGV4XSA9IGUubmV4dDsKLQkJCQkJfSBlbHNlIHsKLQkJCQkJCXByZXYubmV4dCA9IGUubmV4dDsKLQkJCQkJfQotCQkJCQl0aGlzLnVuaXF1ZUNvdW50LS07Ci0JCQkJfQotCQkJCXRoaXMuY291bnQgLT0gY250MjsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JLyoqCi0JICogVGhpcyBpbXBsZW1lbnRhdGlvbiB1c2VzIG9iamVjdC1pZGVudGl0eSB0byBkZXRlcm1pbmUgd2hldGhlcgotCSAqIHNwZWNpZmllZCBjb2xsZWN0aW9uIGNvbnRhaW5zIGEgcGFydGljdWxhciBlbGVtZW50LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyBib29sZWFuIHJlbW92ZUFsbChDb2xsZWN0aW9uPD8+IGMpIHsKLQkJcmV0dXJuIHN1cGVyLnJlbW92ZUFsbCh0aGlzLmJ1aWxkSWRlbnRpdHlIYXNoQmFnKGMpKTsKLQl9Ci0KLQkvKioKLQkgKiBUaGlzIGltcGxlbWVudGF0aW9uIHVzZXMgb2JqZWN0LWlkZW50aXR5IHRvIGRldGVybWluZSB3aGV0aGVyCi0JICogc3BlY2lmaWVkIGNvbGxlY3Rpb24gY29udGFpbnMgYSBwYXJ0aWN1bGFyIGVsZW1lbnQuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIGJvb2xlYW4gcmV0YWluQWxsKENvbGxlY3Rpb248Pz4gYykgewotCQlyZXR1cm4gc3VwZXIucmV0YWluQWxsKHRoaXMuYnVpbGRJZGVudGl0eUhhc2hCYWcoYykpOwotCX0KLQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByaXZhdGUgQ29sbGVjdGlvbjw/PiBidWlsZElkZW50aXR5SGFzaEJhZyhDb2xsZWN0aW9uPD8+IGMpIHsKLQkJcmV0dXJuIG5ldyBJZGVudGl0eUhhc2hCYWcoYyk7Ci0JfQotCi0JLyoqCi0JICogVGhpcyBpbXBsZW1lbnRhdGlvbiBzaW1wbHkgY2xlYXJzIG91dCBhbGwgb2YgdGhlIGhhc2ggdGFibGUgYnVja2V0cy4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBjbGVhcigpIHsKLQkJRW50cnk8RT5bXSB0YWIgPSB0aGlzLnRhYmxlOwotCQl0aGlzLm1vZENvdW50Kys7Ci0JCWZvciAoaW50IGkgPSB0YWIubGVuZ3RoOyAtLWkgPj0gMDsgKSB7Ci0JCQl0YWJbaV0gPSBudWxsOwotCQl9Ci0JCXRoaXMuY291bnQgPSAwOwotCQl0aGlzLnVuaXF1ZUNvdW50ID0gMDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm5zIGEgc2hhbGxvdyBjb3B5IG9mIHRoaXMgYmFnOiB0aGUgZWxlbWVudHMKLQkgKiB0aGVtc2VsdmVzIGFyZSBub3QgY2xvbmVkLgotCSAqCi0JICogQHJldHVybiBhIHNoYWxsb3cgY29weSBvZiB0aGlzIGJhZy4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgSWRlbnRpdHlIYXNoQmFnPEU+IGNsb25lKCkgewotCQl0cnkgewotCQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCQlJZGVudGl0eUhhc2hCYWc8RT4gY2xvbmUgPSAoSWRlbnRpdHlIYXNoQmFnPEU+KSBzdXBlci5jbG9uZSgpOwotCQkJY2xvbmUudGFibGUgPSB0aGlzLmJ1aWxkVGFibGUodGhpcy50YWJsZS5sZW5ndGgpOwotCQkJZm9yIChpbnQgaSA9IHRoaXMudGFibGUubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCQljbG9uZS50YWJsZVtpXSA9ICh0aGlzLnRhYmxlW2ldID09IG51bGwpIAotCQkJCQkJPyBudWxsIDogKEVudHJ5PEU+KSB0aGlzLnRhYmxlW2ldLmNsb25lKCk7Ci0JCQl9Ci0JCQljbG9uZS5tb2RDb3VudCA9IDA7Ci0JCQlyZXR1cm4gY2xvbmU7Ci0JCX0gY2F0Y2ggKENsb25lTm90U3VwcG9ydGVkRXhjZXB0aW9uIGUpIHsKLQkJCXRocm93IG5ldyBJbnRlcm5hbEVycm9yKCk7Ci0JCX0KLQl9Ci0KLQotCS8qKgotCSAqIEhhc2ggdGFibGUgY29sbGlzaW9uIGxpc3QgZW50cnkuCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgY2xhc3MgRW50cnk8RT4gaW1wbGVtZW50cyBCYWcuRW50cnk8RT4gewotCQlpbnQgaGFzaDsKLQkJRSBvYmplY3Q7Ci0JCWludCBjb3VudDsKLQkJRW50cnk8RT4gbmV4dDsKLQotCQlFbnRyeShpbnQgaGFzaCwgRSBvYmplY3QsIEVudHJ5PEU+IG5leHQpIHsKLQkJCXRoaXMoaGFzaCwgb2JqZWN0LCAxLCBuZXh0KTsKLQkJfQotCi0JCUVudHJ5KGludCBoYXNoLCBFIG9iamVjdCwgaW50IGNvdW50LCBFbnRyeTxFPiBuZXh0KSB7Ci0JCQl0aGlzLmhhc2ggPSBoYXNoOwotCQkJdGhpcy5vYmplY3QgPSBvYmplY3Q7Ci0JCQl0aGlzLmNvdW50ID0gY291bnQ7Ci0JCQl0aGlzLm5leHQgPSBuZXh0OwotCQl9Ci0KLQkJLyoqCi0JCSAqIENhc2NhZGUgdGhlIGNsb25lIHRvIGFsbCB0aGUgZW50cmllcyBpbiB0aGUgc2FtZSBidWNrZXQuCi0JCSAqLwotCQlAT3ZlcnJpZGUKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCXByb3RlY3RlZCBFbnRyeTxFPiBjbG9uZSgpIHsKLQkJCXJldHVybiBuZXcgRW50cnkodGhpcy5oYXNoLCB0aGlzLm9iamVjdCwgdGhpcy5jb3VudCwKLQkJCQkJKHRoaXMubmV4dCA9PSBudWxsID8gbnVsbCA6IHRoaXMubmV4dC5jbG9uZSgpKSk7Ci0JCX0KLQotCi0JCS8vICoqKioqIEJhZy5FbnRyeSBpbXBsZW1lbnRhdGlvbgotCQlwdWJsaWMgRSBnZXRFbGVtZW50KCkgewotCQkJcmV0dXJuIHRoaXMub2JqZWN0OwotCQl9Ci0KLQkJcHVibGljIGludCBnZXRDb3VudCgpIHsKLQkJCXJldHVybiB0aGlzLmNvdW50OwotCQl9Ci0KLQkJcHVibGljIGludCBzZXRDb3VudChpbnQgY291bnQpIHsKLQkJCWlmIChjb3VudCA8PSAwKSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiY291bnQgbXVzdCBiZSBncmVhdGVyIHRoYW4gemVybzogIiArIGNvdW50KTsgLy8kTk9OLU5MUy0xJAotCQkJfQotCQkJaW50IG9sZCA9IHRoaXMuY291bnQ7Ci0JCQl0aGlzLmNvdW50ID0gY291bnQ7Ci0JCQlyZXR1cm4gb2xkOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBib29sZWFuIGVxdWFscyhPYmplY3QgbykgewotCQkJaWYgKCAhIChvIGluc3RhbmNlb2YgQmFnLkVudHJ5KSkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJQmFnLkVudHJ5IGUgPSAoQmFnLkVudHJ5KSBvOwotCQkJcmV0dXJuICh0aGlzLm9iamVjdCA9PSBlLmdldEVsZW1lbnQoKSkKLQkJCQkJJiYgKHRoaXMuY291bnQgPT0gZS5nZXRDb3VudCgpKTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgaW50IGhhc2hDb2RlKCkgewotCQkJRSBvID0gdGhpcy5vYmplY3Q7Ci0JCQlyZXR1cm4gKG8gPT0gbnVsbCkgPyAwIDogKHRoaXMuY291bnQgKiBvLmhhc2hDb2RlKCkpOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gdGhpcy5vYmplY3QgKyAiPT4iICsgdGhpcy5jb3VudDsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JfQotCi0KLQlAT3ZlcnJpZGUKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwdWJsaWMgSXRlcmF0b3I8RT4gaXRlcmF0b3IoKSB7Ci0JCXJldHVybiAodGhpcy5jb3VudCA9PSAwKSA/IEVNUFRZX0lURVJBVE9SIDogbmV3IEhhc2hJdGVyYXRvcigpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhbiBpdGVyYXRvciB0aGF0IHJldHVybnMgZWFjaCBpdGVtIGluIHRoZSBiYWcKLQkgKiBvbmNlIGFuZCBvbmx5IG9uY2UsIGlycmVzcGVjdGl2ZSBvZiBob3cgbWFueSB0aW1lcwotCSAqIHRoZSBpdGVtIHdhcyBhZGRlZCB0byB0aGUgYmFnLgotCSAqLwotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXB1YmxpYyBJdGVyYXRvcjxFPiB1bmlxdWVJdGVyYXRvcigpIHsKLQkJcmV0dXJuICh0aGlzLmNvdW50ID09IDApID8gRU1QVFlfSVRFUkFUT1IgOiBuZXcgVW5pcXVlSXRlcmF0b3IoKTsKLQl9Ci0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwdWJsaWMgSXRlcmF0b3I8QmFnLkVudHJ5PEU+PiBlbnRyaWVzKCkgewotCQlyZXR1cm4gKHRoaXMuY291bnQgPT0gMCkgPyBFTVBUWV9JVEVSQVRPUiA6IG5ldyBFbnRyeUl0ZXJhdG9yKCk7Ci0JfQotCi0KLQkvKioKLQkgKiBFbXB0eSBpdGVyYXRvciB0aGF0IGRvZXMganVzdCBhYm91dCBub3RoaW5nLgotCSAqLwotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByaXZhdGUgc3RhdGljIGZpbmFsIEl0ZXJhdG9yIEVNUFRZX0lURVJBVE9SID0gbmV3IEVtcHR5SXRlcmF0b3IoKTsKLQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByaXZhdGUgc3RhdGljIGNsYXNzIEVtcHR5SXRlcmF0b3IgaW1wbGVtZW50cyBJdGVyYXRvciB7Ci0KLQkJRW1wdHlJdGVyYXRvcigpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQotCQlwdWJsaWMgYm9vbGVhbiBoYXNOZXh0KCkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0KLQkJcHVibGljIE9iamVjdCBuZXh0KCkgewotCQkJdGhyb3cgbmV3IE5vU3VjaEVsZW1lbnRFeGNlcHRpb24oKTsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIHJlbW92ZSgpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oKTsKLQkJfQotCX0KLQotCi0JcHJpdmF0ZSBjbGFzcyBIYXNoSXRlcmF0b3IgaW1wbGVtZW50cyBJdGVyYXRvcjxFPiB7Ci0JCXByaXZhdGUgRW50cnk8RT5bXSBsb2NhbFRhYmxlID0gSWRlbnRpdHlIYXNoQmFnLnRoaXMudGFibGU7Ci0JCXByaXZhdGUgaW50IGluZGV4ID0gdGhpcy5sb2NhbFRhYmxlLmxlbmd0aDsJLy8gc3RhcnQgYXQgdGhlIGVuZCBvZiB0aGUgdGFibGUKLQkJcHJpdmF0ZSBFbnRyeTxFPiBuZXh0RW50cnkgPSBudWxsOwotCQlwcml2YXRlIGludCBuZXh0RW50cnlDb3VudCA9IDA7Ci0JCXByaXZhdGUgRW50cnk8RT4gbGFzdFJldHVybmVkRW50cnkgPSBudWxsOwotCi0JCS8qKgotCQkgKiBUaGUgbW9kQ291bnQgdmFsdWUgdGhhdCB0aGUgaXRlcmF0b3IgYmVsaWV2ZXMgdGhhdCB0aGUgYmFja2luZwotCQkgKiBiYWcgc2hvdWxkIGhhdmUuIElmIHRoaXMgZXhwZWN0YXRpb24gaXMgdmlvbGF0ZWQsIHRoZSBpdGVyYXRvcgotCQkgKiBoYXMgZGV0ZWN0ZWQgYSBjb25jdXJyZW50IG1vZGlmaWNhdGlvbi4KLQkJICovCi0JCXByaXZhdGUgaW50IGV4cGVjdGVkTW9kQ291bnQgPSBJZGVudGl0eUhhc2hCYWcudGhpcy5tb2RDb3VudDsKLQotCQlIYXNoSXRlcmF0b3IoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0KLQkJcHVibGljIGJvb2xlYW4gaGFzTmV4dCgpIHsKLQkJCUVudHJ5PEU+IGUgPSB0aGlzLm5leHRFbnRyeTsKLQkJCWludCBpID0gdGhpcy5pbmRleDsKLQkJCUVudHJ5PEU+W10gdGFiID0gdGhpcy5sb2NhbFRhYmxlOwotCQkJLy8gVXNlIGxvY2FscyBmb3IgZmFzdGVyIGxvb3AgaXRlcmF0aW9uCi0JCQl3aGlsZSAoKGUgPT0gbnVsbCkgJiYgKGkgPiAwKSkgewotCQkJCWUgPSB0YWJbLS1pXTsJCS8vIG1vdmUgYmFja3dhcmRzIHRocm91Z2ggdGhlIHRhYmxlCi0JCQl9Ci0JCQl0aGlzLm5leHRFbnRyeSA9IGU7Ci0JCQl0aGlzLmluZGV4ID0gaTsKLQkJCXJldHVybiBlICE9IG51bGw7Ci0JCX0KLQotCQlwdWJsaWMgRSBuZXh0KCkgewotCQkJaWYgKElkZW50aXR5SGFzaEJhZy50aGlzLm1vZENvdW50ICE9IHRoaXMuZXhwZWN0ZWRNb2RDb3VudCkgewotCQkJCXRocm93IG5ldyBDb25jdXJyZW50TW9kaWZpY2F0aW9uRXhjZXB0aW9uKCk7Ci0JCQl9Ci0JCQlFbnRyeTxFPiBldCA9IHRoaXMubmV4dEVudHJ5OwotCQkJaW50IGkgPSB0aGlzLmluZGV4OwotCQkJRW50cnk8RT5bXSB0YWIgPSB0aGlzLmxvY2FsVGFibGU7Ci0JCQkvLyBVc2UgbG9jYWxzIGZvciBmYXN0ZXIgbG9vcCBpdGVyYXRpb24KLQkJCXdoaWxlICgoZXQgPT0gbnVsbCkgJiYgKGkgPiAwKSkgewotCQkJCWV0ID0gdGFiWy0taV07CQkvLyBtb3ZlIGJhY2t3YXJkcyB0aHJvdWdoIHRoZSB0YWJsZQotCQkJfQotCQkJdGhpcy5uZXh0RW50cnkgPSBldDsKLQkJCXRoaXMuaW5kZXggPSBpOwotCQkJaWYgKGV0ID09IG51bGwpIHsKLQkJCQl0aHJvdyBuZXcgTm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpOwotCQkJfQotCQkJRW50cnk8RT4gZSA9IHRoaXMubGFzdFJldHVybmVkRW50cnkgPSB0aGlzLm5leHRFbnRyeTsKLQkJCXRoaXMubmV4dEVudHJ5Q291bnQrKzsKLQkJCWlmICh0aGlzLm5leHRFbnRyeUNvdW50ID09IGUuY291bnQpIHsKLQkJCQl0aGlzLm5leHRFbnRyeSA9IGUubmV4dDsKLQkJCQl0aGlzLm5leHRFbnRyeUNvdW50ID0gMDsKLQkJCX0KLQkJCXJldHVybiBlLm9iamVjdDsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIHJlbW92ZSgpIHsKLQkJCWlmICh0aGlzLmxhc3RSZXR1cm5lZEVudHJ5ID09IG51bGwpIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCk7Ci0JCQl9Ci0JCQlpZiAoSWRlbnRpdHlIYXNoQmFnLnRoaXMubW9kQ291bnQgIT0gdGhpcy5leHBlY3RlZE1vZENvdW50KSB7Ci0JCQkJdGhyb3cgbmV3IENvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24oKTsKLQkJCX0KLQkJCUVudHJ5PEU+W10gdGFiID0gdGhpcy5sb2NhbFRhYmxlOwotCQkJaW50IHNsb3QgPSAodGhpcy5sYXN0UmV0dXJuZWRFbnRyeS5oYXNoICYgMHg3RkZGRkZGRikgJSB0YWIubGVuZ3RoOwotCQkJZm9yIChFbnRyeTxFPiBlID0gdGFiW3Nsb3RdLCBwcmV2ID0gbnVsbDsgZSAhPSBudWxsOyBwcmV2ID0gZSwgZSA9IGUubmV4dCkgewotCQkJCWlmIChlID09IHRoaXMubGFzdFJldHVybmVkRW50cnkpIHsKLQkJCQkJSWRlbnRpdHlIYXNoQmFnLnRoaXMubW9kQ291bnQrKzsKLQkJCQkJdGhpcy5leHBlY3RlZE1vZENvdW50Kys7Ci0JCQkJCWUuY291bnQtLTsKLQkJCQkJaWYgKGUuY291bnQgPT0gMCkgewotCQkJCQkJLy8gaWYgd2UgYXJlIHJlbW92aW5nIHRoZSBsYXN0IG9uZSwgcmVtb3ZlIHRoZSBlbnRyeSBmcm9tIHRoZSB0YWJsZQotCQkJCQkJaWYgKHByZXYgPT0gbnVsbCkgewotCQkJCQkJCXRhYltzbG90XSA9IGUubmV4dDsKLQkJCQkJCX0gZWxzZSB7Ci0JCQkJCQkJcHJldi5uZXh0ID0gZS5uZXh0OwotCQkJCQkJfQotCQkJCQkJSWRlbnRpdHlIYXNoQmFnLnRoaXMudW5pcXVlQ291bnQtLTsKLQkJCQkJfSBlbHNlIHsKLQkJCQkJCS8vIHNsaWRlIGJhY2sgdGhlIGNvdW50IHRvIGFjY291bnQgZm9yIHRoZSBqdXN0LXJlbW92ZWQgZWxlbWVudAotCQkJCQkJdGhpcy5uZXh0RW50cnlDb3VudC0tOwotCQkJCQl9Ci0JCQkJCUlkZW50aXR5SGFzaEJhZy50aGlzLmNvdW50LS07Ci0JCQkJCXRoaXMubGFzdFJldHVybmVkRW50cnkgPSBudWxsOwkvLyBpdCBjYW5ub3QgYmUgcmVtb3ZlZCBhZ2FpbgotCQkJCQlyZXR1cm47Ci0JCQkJfQotCQkJfQotCQkJdGhyb3cgbmV3IENvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24oKTsKLQkJfQotCX0KLQotCi0JcHJpdmF0ZSBjbGFzcyBFbnRyeUl0ZXJhdG9yIGltcGxlbWVudHMgSXRlcmF0b3I8RW50cnk8RT4+IHsKLQkJcHJpdmF0ZSBFbnRyeTxFPltdIGxvY2FsVGFibGUgPSBJZGVudGl0eUhhc2hCYWcudGhpcy50YWJsZTsKLQkJcHJpdmF0ZSBpbnQgaW5kZXggPSB0aGlzLmxvY2FsVGFibGUubGVuZ3RoOwkvLyBzdGFydCBhdCB0aGUgZW5kIG9mIHRoZSB0YWJsZQotCQlwcml2YXRlIEVudHJ5PEU+IG5leHRFbnRyeSA9IG51bGw7Ci0JCXByaXZhdGUgRW50cnk8RT4gbGFzdFJldHVybmVkRW50cnkgPSBudWxsOwotCi0JCS8qKgotCQkgKiBUaGUgbW9kQ291bnQgdmFsdWUgdGhhdCB0aGUgaXRlcmF0b3IgYmVsaWV2ZXMgdGhhdCB0aGUgYmFja2luZwotCQkgKiBiYWcgc2hvdWxkIGhhdmUuIElmIHRoaXMgZXhwZWN0YXRpb24gaXMgdmlvbGF0ZWQsIHRoZSBpdGVyYXRvcgotCQkgKiBoYXMgZGV0ZWN0ZWQgYSBjb25jdXJyZW50IG1vZGlmaWNhdGlvbi4KLQkJICovCi0JCXByaXZhdGUgaW50IGV4cGVjdGVkTW9kQ291bnQgPSBJZGVudGl0eUhhc2hCYWcudGhpcy5tb2RDb3VudDsKLQotCQlFbnRyeUl0ZXJhdG9yKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCi0JCXB1YmxpYyBib29sZWFuIGhhc05leHQoKSB7Ci0JCQlFbnRyeTxFPiBlID0gdGhpcy5uZXh0RW50cnk7Ci0JCQlpbnQgaSA9IHRoaXMuaW5kZXg7Ci0JCQlFbnRyeTxFPltdIHRhYiA9IHRoaXMubG9jYWxUYWJsZTsKLQkJCS8vIFVzZSBsb2NhbHMgZm9yIGZhc3RlciBsb29wIGl0ZXJhdGlvbgotCQkJd2hpbGUgKChlID09IG51bGwpICYmIChpID4gMCkpIHsKLQkJCQllID0gdGFiWy0taV07CQkvLyBtb3ZlIGJhY2t3YXJkcyB0aHJvdWdoIHRoZSB0YWJsZQotCQkJfQotCQkJdGhpcy5uZXh0RW50cnkgPSBlOwotCQkJdGhpcy5pbmRleCA9IGk7Ci0JCQlyZXR1cm4gZSAhPSBudWxsOwotCQl9Ci0KLQkJcHVibGljIEVudHJ5PEU+IG5leHQoKSB7Ci0JCQlpZiAoSWRlbnRpdHlIYXNoQmFnLnRoaXMubW9kQ291bnQgIT0gdGhpcy5leHBlY3RlZE1vZENvdW50KSB7Ci0JCQkJdGhyb3cgbmV3IENvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24oKTsKLQkJCX0KLQkJCUVudHJ5PEU+IGV0ID0gdGhpcy5uZXh0RW50cnk7Ci0JCQlpbnQgaSA9IHRoaXMuaW5kZXg7Ci0JCQlFbnRyeTxFPltdIHRhYiA9IHRoaXMubG9jYWxUYWJsZTsKLQkJCS8vIFVzZSBsb2NhbHMgZm9yIGZhc3RlciBsb29wIGl0ZXJhdGlvbgotCQkJd2hpbGUgKChldCA9PSBudWxsKSAmJiAoaSA+IDApKSB7Ci0JCQkJZXQgPSB0YWJbLS1pXTsJCS8vIG1vdmUgYmFja3dhcmRzIHRocm91Z2ggdGhlIHRhYmxlCi0JCQl9Ci0JCQl0aGlzLm5leHRFbnRyeSA9IGV0OwotCQkJdGhpcy5pbmRleCA9IGk7Ci0JCQlpZiAoZXQgPT0gbnVsbCkgewotCQkJCXRocm93IG5ldyBOb1N1Y2hFbGVtZW50RXhjZXB0aW9uKCk7Ci0JCQl9Ci0JCQlFbnRyeTxFPiBlID0gdGhpcy5sYXN0UmV0dXJuZWRFbnRyeSA9IHRoaXMubmV4dEVudHJ5OwotCQkJdGhpcy5uZXh0RW50cnkgPSBlLm5leHQ7Ci0JCQlyZXR1cm4gZTsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIHJlbW92ZSgpIHsKLQkJCWlmICh0aGlzLmxhc3RSZXR1cm5lZEVudHJ5ID09IG51bGwpIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCk7Ci0JCQl9Ci0JCQlpZiAoSWRlbnRpdHlIYXNoQmFnLnRoaXMubW9kQ291bnQgIT0gdGhpcy5leHBlY3RlZE1vZENvdW50KSB7Ci0JCQkJdGhyb3cgbmV3IENvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24oKTsKLQkJCX0KLQkJCUVudHJ5PEU+W10gdGFiID0gdGhpcy5sb2NhbFRhYmxlOwotCQkJaW50IHNsb3QgPSAodGhpcy5sYXN0UmV0dXJuZWRFbnRyeS5oYXNoICYgMHg3RkZGRkZGRikgJSB0YWIubGVuZ3RoOwotCQkJZm9yIChFbnRyeTxFPiBlID0gdGFiW3Nsb3RdLCBwcmV2ID0gbnVsbDsgZSAhPSBudWxsOyBwcmV2ID0gZSwgZSA9IGUubmV4dCkgewotCQkJCWlmIChlID09IHRoaXMubGFzdFJldHVybmVkRW50cnkpIHsKLQkJCQkJSWRlbnRpdHlIYXNoQmFnLnRoaXMubW9kQ291bnQrKzsKLQkJCQkJdGhpcy5leHBlY3RlZE1vZENvdW50Kys7Ci0JCQkJCS8vIHJlbW92ZSB0aGUgZW50cnkgZnJvbSB0aGUgdGFibGUKLQkJCQkJaWYgKHByZXYgPT0gbnVsbCkgewotCQkJCQkJdGFiW3Nsb3RdID0gZS5uZXh0OwotCQkJCQl9IGVsc2UgewotCQkJCQkJcHJldi5uZXh0ID0gZS5uZXh0OwotCQkJCQl9Ci0JCQkJCUlkZW50aXR5SGFzaEJhZy50aGlzLnVuaXF1ZUNvdW50LS07Ci0JCQkJCUlkZW50aXR5SGFzaEJhZy50aGlzLmNvdW50IC09IHRoaXMubGFzdFJldHVybmVkRW50cnkuY291bnQ7Ci0JCQkJCXRoaXMubGFzdFJldHVybmVkRW50cnkgPSBudWxsOwkvLyBpdCBjYW5ub3QgYmUgcmVtb3ZlZCBhZ2FpbgotCQkJCQlyZXR1cm47Ci0JCQkJfQotCQkJfQotCQkJdGhyb3cgbmV3IENvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24oKTsKLQkJfQotCi0JfQotCi0KLQlwcml2YXRlIGNsYXNzIFVuaXF1ZUl0ZXJhdG9yIGltcGxlbWVudHMgSXRlcmF0b3I8RT4gewotCQlwcml2YXRlIEVudHJ5SXRlcmF0b3IgZW50cnlJdGVyYXRvciA9IG5ldyBFbnRyeUl0ZXJhdG9yKCk7Ci0JCQotCQlVbmlxdWVJdGVyYXRvcigpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQotCQlwdWJsaWMgYm9vbGVhbiBoYXNOZXh0KCkgewotCQkJcmV0dXJuIHRoaXMuZW50cnlJdGVyYXRvci5oYXNOZXh0KCk7Ci0JCX0KLQotCQlwdWJsaWMgRSBuZXh0KCkgewotCQkJcmV0dXJuIHRoaXMuZW50cnlJdGVyYXRvci5uZXh0KCkub2JqZWN0OwotCQl9Ci0KLQkJcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQkJdGhpcy5lbnRyeUl0ZXJhdG9yLnJlbW92ZSgpOwotCQl9Ci0KLQl9Ci0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBib29sZWFuIGVxdWFscyhPYmplY3QgbykgewotCQlpZiAobyA9PSB0aGlzKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfSBlbHNlIGlmIChvIGluc3RhbmNlb2YgSWRlbnRpdHlIYXNoQmFnKSB7Ci0JCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJCUlkZW50aXR5SGFzaEJhZzxFPiBiID0gKElkZW50aXR5SGFzaEJhZzxFPikgbzsKLQkJCWlmIChiLnNpemUoKSAhPSB0aGlzLnNpemUoKSkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJCUlkZW50aXR5SGFzaEJhZzxFPiBjbG9uZSA9IHRoaXMuY2xvbmUoKTsKLQkJCWZvciAoRSBlIDogYikgewotCQkJCWlmICggISBjbG9uZS5yZW1vdmUoZSkpIHsKLQkJCQkJcmV0dXJuIGZhbHNlOwotCQkJCX0KLQkJCX0KLQkJCXJldHVybiBjbG9uZS5pc0VtcHR5KCk7Ci0JCX0gZWxzZSBpZiAobyBpbnN0YW5jZW9mIEJhZykgewotCQkJLy8gaG1tbS4uLgotCQkJcmV0dXJuIHRoaXMuYnVpbGRCYWcoKS5lcXVhbHMobyk7Ci0JCX0gZWxzZSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQl9Ci0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcml2YXRlIEJhZzxFPiBidWlsZEJhZygpIHsKLQkJcmV0dXJuIG5ldyBIYXNoQmFnKHRoaXMpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBpbnQgaGFzaENvZGUoKSB7Ci0JCWludCBoID0gMDsKLQkJZm9yIChFIGUgOiB0aGlzKSB7Ci0JCQloICs9IFN5c3RlbS5pZGVudGl0eUhhc2hDb2RlKGUpOwotCQl9Ci0JCXJldHVybiBoOwotCX0KLQotCS8qKgotCSAqIFNhdmUgdGhlIHN0YXRlIG9mIHRoaXMgYmFnIHRvIGEgc3RyZWFtIChpLmUuIHNlcmlhbGl6ZSBpdCkuCi0JICoKLQkgKiBAc2VyaWFsRGF0YSBFbWl0IHRoZSBjYXBhY2l0eSBvZiB0aGUgYmFnIChpbnQpLAotCSAqICAgICBmb2xsb3dlZCBieSB0aGUgbnVtYmVyIG9mIHVuaXF1ZSBlbGVtZW50cyBpbiB0aGUgYmFnIChpbnQpLAotCSAqICAgICBmb2xsb3dlZCBieSBhbGwgb2YgdGhlIGJhZydzIGVsZW1lbnRzIChlYWNoIGFuIE9iamVjdCkgYW5kCi0JICogICAgIHRoZWlyIGNvdW50cyAoZWFjaCBhbiBpbnQpLCBpbiBubyBwYXJ0aWN1bGFyIG9yZGVyLgotCSAqLwotCXByaXZhdGUgc3luY2hyb25pemVkIHZvaWQgd3JpdGVPYmplY3QoamF2YS5pby5PYmplY3RPdXRwdXRTdHJlYW0gcykKLQkJCQl0aHJvd3MgamF2YS5pby5JT0V4Y2VwdGlvbiB7Ci0JCS8vIHdyaXRlIG91dCB0aGUgdGhyZXNob2xkLCBsb2FkIGZhY3RvciwgYW5kIGFueSBoaWRkZW4gc3R1ZmYKLQkJcy5kZWZhdWx0V3JpdGVPYmplY3QoKTsKLQotCQkvLyB3cml0ZSBvdXQgbnVtYmVyIG9mIGJ1Y2tldHMKLQkJcy53cml0ZUludCh0aGlzLnRhYmxlLmxlbmd0aCk7Ci0KLQkJLy8gd3JpdGUgb3V0IG51bWJlciBvZiB1bmlxdWUgZWxlbWVudHMKLQkJcy53cml0ZUludCh0aGlzLnVuaXF1ZUNvdW50KTsKLQotCQlFbnRyeTxFPltdIHRhYiA9IHRoaXMudGFibGU7Ci0JCS8vIHdyaXRlIG91dCBlbGVtZW50cyBhbmQgY291bnRzIChhbHRlcm5hdGluZykKLQkJZm9yIChFbnRyeTxFPiBlbnRyeSA6IHRhYikgewotCQkJd2hpbGUgKGVudHJ5ICE9IG51bGwpIHsKLQkJCQlzLndyaXRlT2JqZWN0KGVudHJ5Lm9iamVjdCk7Ci0JCQkJcy53cml0ZUludChlbnRyeS5jb3VudCk7Ci0JCQkJZW50cnkgPSBlbnRyeS5uZXh0OwotCQkJfQotCQl9Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0KLQkvKioKLQkgKiBSZWNvbnN0aXR1dGUgdGhlIGJhZyBmcm9tIGEgc3RyZWFtIChpLmUuIGRlc2VyaWFsaXplIGl0KS4KLQkgKi8KLQlwcml2YXRlIHN5bmNocm9uaXplZCB2b2lkIHJlYWRPYmplY3QoamF2YS5pby5PYmplY3RJbnB1dFN0cmVhbSBzKQotCQkJCXRocm93cyBqYXZhLmlvLklPRXhjZXB0aW9uLCBDbGFzc05vdEZvdW5kRXhjZXB0aW9uIHsKLQkJLy8gcmVhZCBpbiB0aGUgdGhyZXNob2xkLCBsb2FkZmFjdG9yLCBhbmQgYW55IGhpZGRlbiBzdHVmZgotCQlzLmRlZmF1bHRSZWFkT2JqZWN0KCk7Ci0KLQkJLy8gcmVhZCBpbiBudW1iZXIgb2YgYnVja2V0cyBhbmQgYWxsb2NhdGUgdGhlIGJ1Y2tldCBhcnJheQotCQl0aGlzLnRhYmxlID0gdGhpcy5idWlsZFRhYmxlKHMucmVhZEludCgpKTsKLQotCQkvLyByZWFkIGluIG51bWJlciBvZiB1bmlxdWUgZWxlbWVudHMKLQkJaW50IHVuaXF1ZSA9IHMucmVhZEludCgpOwotCi0JCS8vIHJlYWQgdGhlIGVsZW1lbnRzIGFuZCBjb3VudHMsIGFuZCBwdXQgdGhlIGVsZW1lbnRzIGluIHRoZSBiYWcKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCB1bmlxdWU7IGkrKykgewotCQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCQlFIGVsZW1lbnQgPSAoRSkgcy5yZWFkT2JqZWN0KCk7Ci0JCQlpbnQgZWxlbWVudENvdW50ID0gcy5yZWFkSW50KCk7Ci0JCQlmb3IgKGludCBqID0gMDsgaiA8IGVsZW1lbnRDb3VudDsgaisrKSB7Ci0JCQkJdGhpcy5hZGQoZWxlbWVudCk7Ci0JCQl9Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9JbmRlbnRpbmdQcmludFdyaXRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0luZGVudGluZ1ByaW50V3JpdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDUzZTYxYmUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0luZGVudGluZ1ByaW50V3JpdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNDggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uUHJpbnRXcml0ZXI7Ci1pbXBvcnQgamF2YS5pby5Xcml0ZXI7Ci0KLS8qKgotICogRXh0ZW5kIFByaW50V3JpdGVyIHRvIGF1dG9tYXRpY2FsbHkgaW5kZW50IG5ldyBsaW5lcy4KLSAqLwotcHVibGljIGNsYXNzIEluZGVudGluZ1ByaW50V3JpdGVyIGV4dGVuZHMgUHJpbnRXcml0ZXIgewotCi0JcHJpdmF0ZSBmaW5hbCBTdHJpbmcgaW5kZW50OwotCXByaXZhdGUgaW50IGluZGVudExldmVsOwotCXByaXZhdGUgYm9vbGVhbiBuZWVkc0luZGVudDsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIERFRkFVTFRfSU5ERU5UID0gIlx0IjsgLy8kTk9OLU5MUy0xJAotCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSB3cml0ZXIgdGhhdCBpbmRlbnRzIHdpdGggdGFicy4KLQkgKi8KLQlwdWJsaWMgSW5kZW50aW5nUHJpbnRXcml0ZXIoV3JpdGVyIG91dCkgewotCQl0aGlzKG91dCwgREVGQVVMVF9JTkRFTlQpOwotCX0KLQkKLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSB3cml0ZXIgdGhhdCBpbmRlbnRzIHdpdGggdGhlIHNwZWNpZmllZCBzdHJpbmcuCi0JICovCi0JcHVibGljIEluZGVudGluZ1ByaW50V3JpdGVyKFdyaXRlciBvdXQsIFN0cmluZyBpbmRlbnQpIHsKLQkJc3VwZXIob3V0KTsKLQkJdGhpcy5pbmRlbnQgPSBpbmRlbnQ7Ci0JCXRoaXMuaW5kZW50TGV2ZWwgPSAwOwotCQl0aGlzLm5lZWRzSW5kZW50ID0gdHJ1ZTsKLQl9Ci0JCi0JLyoqCi0JICogU2V0IGZsYWcgc28gZm9sbG93aW5nIGxpbmUgaXMgaW5kZW50ZWQuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgcHJpbnRsbigpIHsKLQkJc3luY2hyb25pemVkICh0aGlzLmxvY2spIHsKLQkJCXN1cGVyLnByaW50bG4oKTsKLQkJCXRoaXMubmVlZHNJbmRlbnQgPSB0cnVlOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIFByaW50IHRoZSBhcHByb3ByaWF0ZSBpbmRlbnQuCi0JICovCi0JcHJpdmF0ZSB2b2lkIHByaW50SW5kZW50KCkgewotCQlpZiAodGhpcy5uZWVkc0luZGVudCkgewotCQkJdGhpcy5uZWVkc0luZGVudCA9IGZhbHNlOwotCQkJZm9yIChpbnQgaSA9IHRoaXMuaW5kZW50TGV2ZWw7IGktLSA+IDA7ICkgewotCQkJCXRoaXMucHJpbnQodGhpcy5pbmRlbnQpOwotCQkJfQotCQl9Ci0JfQotCQotCS8qKgotCSAqIFdyaXRlIGEgcG9ydGlvbiBvZiBhbiBhcnJheSBvZiBjaGFyYWN0ZXJzLgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHdyaXRlKGNoYXIgYnVmW10sIGludCBvZmYsIGludCBsZW4pIHsKLQkJc3luY2hyb25pemVkICh0aGlzLmxvY2spIHsKLQkJCXRoaXMucHJpbnRJbmRlbnQoKTsKLQkJCXN1cGVyLndyaXRlKGJ1Ziwgb2ZmLCBsZW4pOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIFdyaXRlIGEgc2luZ2xlIGNoYXJhY3Rlci4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB3cml0ZShpbnQgYykgewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubG9jaykgewotCQkJdGhpcy5wcmludEluZGVudCgpOwotCQkJc3VwZXIud3JpdGUoYyk7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogV3JpdGUgYSBwb3J0aW9uIG9mIGEgc3RyaW5nLgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHdyaXRlKFN0cmluZyBzLCBpbnQgb2ZmLCBpbnQgbGVuKSB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5sb2NrKSB7Ci0JCQl0aGlzLnByaW50SW5kZW50KCk7Ci0JCQlzdXBlci53cml0ZShzLCBvZmYsIGxlbik7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogQnVtcCB0aGUgaW5kZW50IGxldmVsLgotCSAqLwotCXB1YmxpYyB2b2lkIGluZGVudCgpIHsKLQkJdGhpcy5pbmNyZW1lbnRJbmRlbnRMZXZlbCgpOwotCX0KLQkKLQkvKioKLQkgKiBEZWNyZW1lbnQgdGhlIGluZGVudCBsZXZlbC4KLQkgKi8KLQlwdWJsaWMgdm9pZCB1bmRlbnQoKSB7Ci0JCXRoaXMuZGVjcmVtZW50SW5kZW50TGV2ZWwoKTsKLQl9Ci0JCi0JLyoqCi0JICogQnVtcCB0aGUgaW5kZW50IGxldmVsLgotCSAqLwotCXB1YmxpYyB2b2lkIGluY3JlbWVudEluZGVudExldmVsKCkgewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubG9jaykgewotCQkJdGhpcy5pbmRlbnRMZXZlbCsrOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIERlY3JlbWVudCB0aGUgaW5kZW50IGxldmVsLgotCSAqLwotCXB1YmxpYyB2b2lkIGRlY3JlbWVudEluZGVudExldmVsKCkgewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubG9jaykgewotCQkJdGhpcy5pbmRlbnRMZXZlbC0tOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgY3VycmVudCBpbmRlbnQgbGV2ZWwuCi0JICovCi0JcHVibGljIGludCBpbmRlbnRMZXZlbCgpIHsKLQkJcmV0dXJuIHRoaXMuaW5kZW50TGV2ZWw7Ci0JfQotCQotCS8qKgotCSAqIEFsbG93IHRoZSBpbmRlbnQgbGV2ZWwgdG8gYmUgc2V0IGRpcmVjdGx5LgotCSAqLwotCXB1YmxpYyB2b2lkIHNldEluZGVudExldmVsKGludCBpbmRlbnRMZXZlbCkgewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubG9jaykgewotCQkJdGhpcy5pbmRlbnRMZXZlbCA9IGluZGVudExldmVsOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvSkRCQ1Rvb2xzLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvSkRCQ1Rvb2xzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQzODk5ZWUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0pEQkNUb29scy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzQ5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLnNxbC5UeXBlczsKLWltcG9ydCBqYXZhLnV0aWwuSGFzaE1hcDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5KYXZhVHlwZTsKLQotLyoqCi0gKiBIZWxwZXIgbWV0aG9kcyBmb3IgZGVhbGluZyB3aXRoIHRoZSBKREJDIEFQSS4KLSAqLwotcHVibGljIGZpbmFsIGNsYXNzIEpEQkNUb29scyB7Ci0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgSkRCQyB0eXBlIGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBjbGFzcy4KLQkgKiBAc2VlIGphdmEuc3FsLlR5cGVzCi0JICovCi0JcHVibGljIHN0YXRpYyBKREJDVHlwZSBqZGJjVHlwZUZvckNsYXNzTmFtZWQoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlKYXZhVG9KREJDVHlwZU1hcHBpbmcgbWFwcGluZyA9IGphdmFUb0pEQkNUeXBlTWFwcGluZyhjbGFzc05hbWUpOwotCQlyZXR1cm4gKG1hcHBpbmcgPT0gbnVsbCkgPyBERUZBVUxUX0pEQkNfVFlQRSA6IG1hcHBpbmcuZ2V0SkRCQ1R5cGUoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIEpEQkMgdHlwZSBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgY2xhc3MuCi0JICogQHNlZSBqYXZhLnNxbC5UeXBlcwotCSAqLwotCXB1YmxpYyBzdGF0aWMgSkRCQ1R5cGUgamRiY1R5cGVGb3IoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCXJldHVybiBqZGJjVHlwZUZvckNsYXNzTmFtZWQoamF2YUNsYXNzLmdldE5hbWUoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBKREJDIHR5cGUgY29ycmVzcG9uZGluZyB0byB0aGUgc3BlY2lmaWVkIGNsYXNzLgotCSAqIEBzZWUgamF2YS5zcWwuVHlwZXMKLQkgKi8KLQlwdWJsaWMgc3RhdGljIEpEQkNUeXBlIGpkYmNUeXBlRm9yKEphdmFUeXBlIGphdmFUeXBlKSB7Ci0JCXJldHVybiBqZGJjVHlwZUZvckNsYXNzTmFtZWQoamF2YVR5cGUuZ2V0SmF2YUNsYXNzTmFtZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIEphdmEgdHlwZSBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgSkRCQyB0eXBlLgotCSAqIEBzZWUgamF2YS5zcWwuVHlwZXMKLQkgKi8KLQlwdWJsaWMgc3RhdGljIEphdmFUeXBlIGphdmFUeXBlRm9ySkRCQ1R5cGVOYW1lZChTdHJpbmcgamRiY1R5cGVOYW1lKSB7Ci0JCUpEQkNUb0phdmFUeXBlTWFwcGluZyBtYXBwaW5nID0gamRiY1RvSmF2YVR5cGVNYXBwaW5nKGpkYmNUeXBlTmFtZSk7Ci0JCXJldHVybiAobWFwcGluZyA9PSBudWxsKSA/IERFRkFVTFRfSkFWQV9UWVBFIDogbWFwcGluZy5nZXRKYXZhVHlwZSgpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgSmF2YSB0eXBlIGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBKREJDIHR5cGUuCi0JICogQHNlZSBqYXZhLnNxbC5UeXBlcwotCSAqLwotCXB1YmxpYyBzdGF0aWMgSmF2YVR5cGUgamF2YVR5cGVGb3IoSkRCQ1R5cGUgamRiY1R5cGUpIHsKLQkJcmV0dXJuIGphdmFUeXBlRm9ySkRCQ1R5cGVOYW1lZChqZGJjVHlwZS5uYW1lKCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgSmF2YSB0eXBlIGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBKREJDIHR5cGUuCi0JICogQHNlZSBqYXZhLnNxbC5UeXBlcwotCSAqLwotCXB1YmxpYyBzdGF0aWMgSmF2YVR5cGUgamF2YVR5cGVGb3JKREJDVHlwZUNvZGUoaW50IGpkYmNUeXBlQ29kZSkgewotCQlyZXR1cm4gamF2YVR5cGVGb3IoSkRCQ1R5cGUudHlwZShqZGJjVHlwZUNvZGUpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW50ZXJuYWwgc3R1ZmYgKioqKioqKioqKgotCi0KLQkvLyAqKioqKioqKioqIEpEQkMgPT4gSmF2YSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBKREJDID0+IEphdmEgdHlwZSBtYXBwaW5ncywga2V5ZWQgYnkgSkRCQyB0eXBlIG5hbWUgKGUuZy4gIlZBUkNIQVIiKQotCSAqLwotCXByaXZhdGUgc3RhdGljIEhhc2hNYXA8U3RyaW5nLCBKREJDVG9KYXZhVHlwZU1hcHBpbmc+IEpEQkNfVE9fSkFWQV9UWVBFX01BUFBJTkdTOyAgLy8gcHNldWRvICdmaW5hbCcgLSBsYXp5LWluaXRpYWxpemVkCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgSmF2YVR5cGUgREVGQVVMVF9KQVZBX1RZUEUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoamF2YS5sYW5nLk9iamVjdC5jbGFzcyk7ICAvLyBUT0RPIE9iamVjdCBpcyB0aGUgZGVmYXVsdD8KLQotCi0JcHJpdmF0ZSBzdGF0aWMgSkRCQ1RvSmF2YVR5cGVNYXBwaW5nIGpkYmNUb0phdmFUeXBlTWFwcGluZyhTdHJpbmcgamRiY1R5cGVOYW1lKSB7Ci0JCXJldHVybiBqZGJjVG9KYXZhVHlwZU1hcHBpbmdzKCkuZ2V0KGpkYmNUeXBlTmFtZSk7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgc3luY2hyb25pemVkIEhhc2hNYXA8U3RyaW5nLCBKREJDVG9KYXZhVHlwZU1hcHBpbmc+IGpkYmNUb0phdmFUeXBlTWFwcGluZ3MoKSB7Ci0JCWlmIChKREJDX1RPX0pBVkFfVFlQRV9NQVBQSU5HUyA9PSBudWxsKSB7Ci0JCQlKREJDX1RPX0pBVkFfVFlQRV9NQVBQSU5HUyA9IGJ1aWxkSkRCQ1RvSmF2YVR5cGVNYXBwaW5ncygpOwotCQl9Ci0JCXJldHVybiBKREJDX1RPX0pBVkFfVFlQRV9NQVBQSU5HUzsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBIYXNoTWFwPFN0cmluZywgSkRCQ1RvSmF2YVR5cGVNYXBwaW5nPiBidWlsZEpEQkNUb0phdmFUeXBlTWFwcGluZ3MoKSB7Ci0JCUhhc2hNYXA8U3RyaW5nLCBKREJDVG9KYXZhVHlwZU1hcHBpbmc+IG1hcHBpbmdzID0gbmV3IEhhc2hNYXA8U3RyaW5nLCBKREJDVG9KYXZhVHlwZU1hcHBpbmc+KCk7Ci0JCWFkZEpEQkNUb0phdmFUeXBlTWFwcGluZ3NUbyhtYXBwaW5ncyk7Ci0JCXJldHVybiBtYXBwaW5nczsKLQl9Ci0KLQkvKioKLQkgKiBoYXJkIGNvZGUgdGhlIGRlZmF1bHQgbWFwcGluZ3MgZnJvbSB0aGUgSkRCQyB0eXBlcyB0byB0aGUKLQkgKiBhcHByb3ByaWF0ZSBKYXZhIHR5cGVzCi0JICogQHNlZSBqYXZhLnNxbC5UeXBlcwotCSAqIHNlZSAiSkRCQyAzLjAgU3BlY2lmaWNhdGlvbiIgQXBwZW5kaXggQgotCSAqLwotCXByaXZhdGUgc3RhdGljIHZvaWQgYWRkSkRCQ1RvSmF2YVR5cGVNYXBwaW5nc1RvKEhhc2hNYXA8U3RyaW5nLCBKREJDVG9KYXZhVHlwZU1hcHBpbmc+IG1hcHBpbmdzKSB7Ci0JCWFkZEpEQkNUb0phdmFUeXBlTWFwcGluZ1RvKFR5cGVzLkFSUkFZLCBqYXZhLnNxbC5BcnJheS5jbGFzcywgbWFwcGluZ3MpOwotCQlhZGRKREJDVG9KYXZhVHlwZU1hcHBpbmdUbyhUeXBlcy5CSUdJTlQsIGxvbmcuY2xhc3MsIG1hcHBpbmdzKTsKLQkJYWRkSkRCQ1RvSmF2YVR5cGVNYXBwaW5nVG8oVHlwZXMuQklOQVJZLCBieXRlW10uY2xhc3MsIG1hcHBpbmdzKTsKLQkJYWRkSkRCQ1RvSmF2YVR5cGVNYXBwaW5nVG8oVHlwZXMuQklULCBib29sZWFuLmNsYXNzLCBtYXBwaW5ncyk7Ci0JCWFkZEpEQkNUb0phdmFUeXBlTWFwcGluZ1RvKFR5cGVzLkJMT0IsIGphdmEuc3FsLkJsb2IuY2xhc3MsIG1hcHBpbmdzKTsKLQkJYWRkSkRCQ1RvSmF2YVR5cGVNYXBwaW5nVG8oVHlwZXMuQk9PTEVBTiwgYm9vbGVhbi5jbGFzcywgbWFwcGluZ3MpOwotCQlhZGRKREJDVG9KYXZhVHlwZU1hcHBpbmdUbyhUeXBlcy5DSEFSLCBqYXZhLmxhbmcuU3RyaW5nLmNsYXNzLCBtYXBwaW5ncyk7Ci0JCWFkZEpEQkNUb0phdmFUeXBlTWFwcGluZ1RvKFR5cGVzLkNMT0IsIGphdmEuc3FsLkNsb2IuY2xhc3MsIG1hcHBpbmdzKTsKLQkJYWRkSkRCQ1RvSmF2YVR5cGVNYXBwaW5nVG8oVHlwZXMuREFUQUxJTkssIGphdmEubmV0LlVSTC5jbGFzcywgbWFwcGluZ3MpOwotCQlhZGRKREJDVG9KYXZhVHlwZU1hcHBpbmdUbyhUeXBlcy5EQVRFLCBqYXZhLnNxbC5EYXRlLmNsYXNzLCBtYXBwaW5ncyk7Ci0JCWFkZEpEQkNUb0phdmFUeXBlTWFwcGluZ1RvKFR5cGVzLkRFQ0lNQUwsIGphdmEubWF0aC5CaWdEZWNpbWFsLmNsYXNzLCBtYXBwaW5ncyk7Ci0JCWFkZEpEQkNUb0phdmFUeXBlTWFwcGluZ1RvKFR5cGVzLkRJU1RJTkNULCBqYXZhLmxhbmcuT2JqZWN0LmNsYXNzLCBtYXBwaW5ncyk7ICAvLyA/Pz8KLQkJYWRkSkRCQ1RvSmF2YVR5cGVNYXBwaW5nVG8oVHlwZXMuRE9VQkxFLCBkb3VibGUuY2xhc3MsIG1hcHBpbmdzKTsKLQkJYWRkSkRCQ1RvSmF2YVR5cGVNYXBwaW5nVG8oVHlwZXMuRkxPQVQsIGRvdWJsZS5jbGFzcywgbWFwcGluZ3MpOwotCQlhZGRKREJDVG9KYXZhVHlwZU1hcHBpbmdUbyhUeXBlcy5JTlRFR0VSLCBpbnQuY2xhc3MsIG1hcHBpbmdzKTsKLQkJYWRkSkRCQ1RvSmF2YVR5cGVNYXBwaW5nVG8oVHlwZXMuSkFWQV9PQkpFQ1QsIGphdmEubGFuZy5PYmplY3QuY2xhc3MsIG1hcHBpbmdzKTsgIC8vID8/PwotCQlhZGRKREJDVG9KYXZhVHlwZU1hcHBpbmdUbyhUeXBlcy5MT05HVkFSQklOQVJZLCBieXRlW10uY2xhc3MsIG1hcHBpbmdzKTsKLQkJYWRkSkRCQ1RvSmF2YVR5cGVNYXBwaW5nVG8oVHlwZXMuTE9OR1ZBUkNIQVIsIGphdmEubGFuZy5TdHJpbmcuY2xhc3MsIG1hcHBpbmdzKTsKLQkJLy8gbm90IHN1cmUgd2h5IHRoaXMgaXMgZGVmaW5lZCBpbiBqYXZhLnNxbC5UeXBlcwotLy8JCWFkZEpEQkNUb0phdmFUeXBlTWFwcGluZ1RvKFR5cGVzLk5VTEwsIGphdmEubGFuZy5PYmplY3QuY2xhc3MsIG1hcHBpbmdzKTsKLQkJYWRkSkRCQ1RvSmF2YVR5cGVNYXBwaW5nVG8oVHlwZXMuTlVNRVJJQywgamF2YS5tYXRoLkJpZ0RlY2ltYWwuY2xhc3MsIG1hcHBpbmdzKTsKLQkJYWRkSkRCQ1RvSmF2YVR5cGVNYXBwaW5nVG8oVHlwZXMuT1RIRVIsIGphdmEubGFuZy5PYmplY3QuY2xhc3MsIG1hcHBpbmdzKTsJLy8gPz8/Ci0JCWFkZEpEQkNUb0phdmFUeXBlTWFwcGluZ1RvKFR5cGVzLlJFQUwsIGZsb2F0LmNsYXNzLCBtYXBwaW5ncyk7Ci0JCWFkZEpEQkNUb0phdmFUeXBlTWFwcGluZ1RvKFR5cGVzLlJFRiwgamF2YS5zcWwuUmVmLmNsYXNzLCBtYXBwaW5ncyk7Ci0JCWFkZEpEQkNUb0phdmFUeXBlTWFwcGluZ1RvKFR5cGVzLlNNQUxMSU5ULCBzaG9ydC5jbGFzcywgbWFwcGluZ3MpOwotCQlhZGRKREJDVG9KYXZhVHlwZU1hcHBpbmdUbyhUeXBlcy5TVFJVQ1QsIGphdmEuc3FsLlN0cnVjdC5jbGFzcywgbWFwcGluZ3MpOwotCQlhZGRKREJDVG9KYXZhVHlwZU1hcHBpbmdUbyhUeXBlcy5USU1FLCBqYXZhLnNxbC5UaW1lLmNsYXNzLCBtYXBwaW5ncyk7Ci0JCWFkZEpEQkNUb0phdmFUeXBlTWFwcGluZ1RvKFR5cGVzLlRJTUVTVEFNUCwgamF2YS5zcWwuVGltZXN0YW1wLmNsYXNzLCBtYXBwaW5ncyk7Ci0JCWFkZEpEQkNUb0phdmFUeXBlTWFwcGluZ1RvKFR5cGVzLlRJTllJTlQsIGJ5dGUuY2xhc3MsIG1hcHBpbmdzKTsKLQkJYWRkSkRCQ1RvSmF2YVR5cGVNYXBwaW5nVG8oVHlwZXMuVkFSQklOQVJZLCBieXRlW10uY2xhc3MsIG1hcHBpbmdzKTsKLQkJYWRkSkRCQ1RvSmF2YVR5cGVNYXBwaW5nVG8oVHlwZXMuVkFSQ0hBUiwgamF2YS5sYW5nLlN0cmluZy5jbGFzcywgbWFwcGluZ3MpOwotCX0KLQotCXByaXZhdGUgc3RhdGljIHZvaWQgYWRkSkRCQ1RvSmF2YVR5cGVNYXBwaW5nVG8oaW50IGpkYmNUeXBlQ29kZSwgQ2xhc3M8Pz4gamF2YUNsYXNzLCBIYXNoTWFwPFN0cmluZywgSkRCQ1RvSmF2YVR5cGVNYXBwaW5nPiBtYXBwaW5ncykgewotCQkvLyBjaGVjayBmb3IgZHVwbGljYXRlcwotCQlKREJDVHlwZSBqZGJjVHlwZSA9IEpEQkNUeXBlLnR5cGUoamRiY1R5cGVDb2RlKTsKLQkJT2JqZWN0IHByZXYgPSBtYXBwaW5ncy5wdXQoamRiY1R5cGUubmFtZSgpLCBidWlsZEpEQkNUb0phdmFUeXBlTWFwcGluZyhqZGJjVHlwZSwgamF2YUNsYXNzKSk7Ci0JCWlmIChwcmV2ICE9IG51bGwpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oImR1cGxpY2F0ZSBKREJDIHR5cGU6ICIgKyBqZGJjVHlwZS5uYW1lKCkpOyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBKREJDVG9KYXZhVHlwZU1hcHBpbmcgYnVpbGRKREJDVG9KYXZhVHlwZU1hcHBpbmcoSkRCQ1R5cGUgamRiY1R5cGUsIENsYXNzPD8+IGphdmFDbGFzcykgewotCQlyZXR1cm4gbmV3IEpEQkNUb0phdmFUeXBlTWFwcGluZyhqZGJjVHlwZSwgbmV3IFNpbXBsZUphdmFUeXBlKGphdmFDbGFzcykpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBKYXZhID0+IEpEQkMgKioqKioqKioqKgotCi0JLyoqCi0JICogSmF2YSA9PiBKREJDIHR5cGUgbWFwcGluZ3MsIGtleWVkIGJ5IEphdmEgY2xhc3MgbmFtZSAoZS5nLiAiamF2YS5sYW5nLk9iamVjdCIpCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgSGFzaE1hcDxTdHJpbmcsIEphdmFUb0pEQkNUeXBlTWFwcGluZz4gSkFWQV9UT19KREJDX1RZUEVfTUFQUElOR1M7ICAvLyBwc2V1ZG8gJ2ZpbmFsJyAtIGxhenktaW5pdGlhbGl6ZWQKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBKREJDVHlwZSBERUZBVUxUX0pEQkNfVFlQRSA9IEpEQkNUeXBlLnR5cGUoVHlwZXMuVkFSQ0hBUik7ICAvLyBUT0RPIFZBUkNIQVIgaXMgdGhlIGRlZmF1bHQ/Ci0KLQotCXByaXZhdGUgc3RhdGljIEphdmFUb0pEQkNUeXBlTWFwcGluZyBqYXZhVG9KREJDVHlwZU1hcHBpbmcoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlyZXR1cm4gamF2YVRvSkRCQ1R5cGVNYXBwaW5ncygpLmdldChjbGFzc05hbWUpOwotCX0KLQotCXByaXZhdGUgc3RhdGljIHN5bmNocm9uaXplZCBIYXNoTWFwPFN0cmluZywgSmF2YVRvSkRCQ1R5cGVNYXBwaW5nPiBqYXZhVG9KREJDVHlwZU1hcHBpbmdzKCkgewotCQlpZiAoSkFWQV9UT19KREJDX1RZUEVfTUFQUElOR1MgPT0gbnVsbCkgewotCQkJSkFWQV9UT19KREJDX1RZUEVfTUFQUElOR1MgPSBidWlsZEphdmFUb0pEQkNUeXBlTWFwcGluZ3MoKTsKLQkJfQotCQlyZXR1cm4gSkFWQV9UT19KREJDX1RZUEVfTUFQUElOR1M7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgSGFzaE1hcDxTdHJpbmcsIEphdmFUb0pEQkNUeXBlTWFwcGluZz4gYnVpbGRKYXZhVG9KREJDVHlwZU1hcHBpbmdzKCkgewotCQlIYXNoTWFwPFN0cmluZywgSmF2YVRvSkRCQ1R5cGVNYXBwaW5nPiBtYXBwaW5ncyA9IG5ldyBIYXNoTWFwPFN0cmluZywgSmF2YVRvSkRCQ1R5cGVNYXBwaW5nPigpOwotCQlhZGRKYXZhVG9KREJDVHlwZU1hcHBpbmdzVG8obWFwcGluZ3MpOwotCQlyZXR1cm4gbWFwcGluZ3M7Ci0JfQotCi0JLyoqCi0JICogaGFyZCBjb2RlIHRoZSBkZWZhdWx0IG1hcHBpbmdzIGZyb20gdGhlIEphdmEgdHlwZXMgdG8gdGhlCi0JICogYXBwcm9wcmlhdGUgSkRCQyB0eXBlcwotCSAqIEBzZWUgamF2YS5zcWwuVHlwZXMKLQkgKiBzZWUgIkpEQkMgMy4wIFNwZWNpZmljYXRpb24iIEFwcGVuZGl4IEIKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIGFkZEphdmFUb0pEQkNUeXBlTWFwcGluZ3NUbyhIYXNoTWFwPFN0cmluZywgSmF2YVRvSkRCQ1R5cGVNYXBwaW5nPiBtYXBwaW5ncykgewotCQkvLyBwcmltaXRpdmVzCi0JCWFkZEphdmFUb0pEQkNUeXBlTWFwcGluZ1RvKGJvb2xlYW4uY2xhc3MsIFR5cGVzLkJJVCwgbWFwcGluZ3MpOwotCQlhZGRKYXZhVG9KREJDVHlwZU1hcHBpbmdUbyhieXRlLmNsYXNzLCBUeXBlcy5USU5ZSU5ULCBtYXBwaW5ncyk7Ci0JCWFkZEphdmFUb0pEQkNUeXBlTWFwcGluZ1RvKGRvdWJsZS5jbGFzcywgVHlwZXMuRE9VQkxFLCBtYXBwaW5ncyk7Ci0JCWFkZEphdmFUb0pEQkNUeXBlTWFwcGluZ1RvKGZsb2F0LmNsYXNzLCBUeXBlcy5SRUFMLCBtYXBwaW5ncyk7Ci0JCWFkZEphdmFUb0pEQkNUeXBlTWFwcGluZ1RvKGludC5jbGFzcywgVHlwZXMuSU5URUdFUiwgbWFwcGluZ3MpOwotCQlhZGRKYXZhVG9KREJDVHlwZU1hcHBpbmdUbyhsb25nLmNsYXNzLCBUeXBlcy5CSUdJTlQsIG1hcHBpbmdzKTsKLQkJYWRkSmF2YVRvSkRCQ1R5cGVNYXBwaW5nVG8oc2hvcnQuY2xhc3MsIFR5cGVzLlNNQUxMSU5ULCBtYXBwaW5ncyk7Ci0KLQkJLy8gcmVmZXJlbmNlIGNsYXNzZXMKLQkJYWRkSmF2YVRvSkRCQ1R5cGVNYXBwaW5nVG8oamF2YS5sYW5nLkJvb2xlYW4uY2xhc3MsIFR5cGVzLkJJVCwgbWFwcGluZ3MpOwotCQlhZGRKYXZhVG9KREJDVHlwZU1hcHBpbmdUbyhqYXZhLmxhbmcuQnl0ZS5jbGFzcywgVHlwZXMuVElOWUlOVCwgbWFwcGluZ3MpOwotCQlhZGRKYXZhVG9KREJDVHlwZU1hcHBpbmdUbyhqYXZhLmxhbmcuRG91YmxlLmNsYXNzLCBUeXBlcy5ET1VCTEUsIG1hcHBpbmdzKTsKLQkJYWRkSmF2YVRvSkRCQ1R5cGVNYXBwaW5nVG8oamF2YS5sYW5nLkZsb2F0LmNsYXNzLCBUeXBlcy5SRUFMLCBtYXBwaW5ncyk7Ci0JCWFkZEphdmFUb0pEQkNUeXBlTWFwcGluZ1RvKGphdmEubGFuZy5JbnRlZ2VyLmNsYXNzLCBUeXBlcy5JTlRFR0VSLCBtYXBwaW5ncyk7Ci0JCWFkZEphdmFUb0pEQkNUeXBlTWFwcGluZ1RvKGphdmEubGFuZy5Mb25nLmNsYXNzLCBUeXBlcy5CSUdJTlQsIG1hcHBpbmdzKTsKLQkJYWRkSmF2YVRvSkRCQ1R5cGVNYXBwaW5nVG8oamF2YS5sYW5nLlNob3J0LmNsYXNzLCBUeXBlcy5TTUFMTElOVCwgbWFwcGluZ3MpOwotCQlhZGRKYXZhVG9KREJDVHlwZU1hcHBpbmdUbyhqYXZhLmxhbmcuU3RyaW5nLmNsYXNzLCBUeXBlcy5WQVJDSEFSLCBtYXBwaW5ncyk7Ci0JCWFkZEphdmFUb0pEQkNUeXBlTWFwcGluZ1RvKGphdmEubWF0aC5CaWdEZWNpbWFsLmNsYXNzLCBUeXBlcy5OVU1FUklDLCBtYXBwaW5ncyk7Ci0JCWFkZEphdmFUb0pEQkNUeXBlTWFwcGluZ1RvKGphdmEubmV0LlVSTC5jbGFzcywgVHlwZXMuREFUQUxJTkssIG1hcHBpbmdzKTsKLQkJYWRkSmF2YVRvSkRCQ1R5cGVNYXBwaW5nVG8oamF2YS5zcWwuQXJyYXkuY2xhc3MsIFR5cGVzLkFSUkFZLCBtYXBwaW5ncyk7Ci0JCWFkZEphdmFUb0pEQkNUeXBlTWFwcGluZ1RvKGphdmEuc3FsLkJsb2IuY2xhc3MsIFR5cGVzLkJMT0IsIG1hcHBpbmdzKTsKLQkJYWRkSmF2YVRvSkRCQ1R5cGVNYXBwaW5nVG8oamF2YS5zcWwuQ2xvYi5jbGFzcywgVHlwZXMuQ0xPQiwgbWFwcGluZ3MpOwotCQlhZGRKYXZhVG9KREJDVHlwZU1hcHBpbmdUbyhqYXZhLnNxbC5EYXRlLmNsYXNzLCBUeXBlcy5EQVRFLCBtYXBwaW5ncyk7Ci0JCWFkZEphdmFUb0pEQkNUeXBlTWFwcGluZ1RvKGphdmEuc3FsLlJlZi5jbGFzcywgVHlwZXMuUkVGLCBtYXBwaW5ncyk7Ci0JCWFkZEphdmFUb0pEQkNUeXBlTWFwcGluZ1RvKGphdmEuc3FsLlN0cnVjdC5jbGFzcywgVHlwZXMuU1RSVUNULCBtYXBwaW5ncyk7Ci0JCWFkZEphdmFUb0pEQkNUeXBlTWFwcGluZ1RvKGphdmEuc3FsLlRpbWUuY2xhc3MsIFR5cGVzLlRJTUUsIG1hcHBpbmdzKTsKLQkJYWRkSmF2YVRvSkRCQ1R5cGVNYXBwaW5nVG8oamF2YS5zcWwuVGltZXN0YW1wLmNsYXNzLCBUeXBlcy5USU1FU1RBTVAsIG1hcHBpbmdzKTsKLQotCQkvLyBhcnJheXMKLQkJYWRkSmF2YVRvSkRCQ1R5cGVNYXBwaW5nVG8oYnl0ZVtdLmNsYXNzLCBUeXBlcy5WQVJCSU5BUlksIG1hcHBpbmdzKTsKLQkJYWRkSmF2YVRvSkRCQ1R5cGVNYXBwaW5nVG8oamF2YS5sYW5nLkJ5dGVbXS5jbGFzcywgVHlwZXMuVkFSQklOQVJZLCBtYXBwaW5ncyk7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBhZGRKYXZhVG9KREJDVHlwZU1hcHBpbmdUbyhDbGFzczw/PiBqYXZhQ2xhc3MsIGludCBqZGJjVHlwZUNvZGUsIEhhc2hNYXA8U3RyaW5nLCBKYXZhVG9KREJDVHlwZU1hcHBpbmc+IG1hcHBpbmdzKSB7Ci0JCS8vIGNoZWNrIGZvciBkdXBsaWNhdGVzCi0JCU9iamVjdCBwcmV2ID0gbWFwcGluZ3MucHV0KGphdmFDbGFzcy5nZXROYW1lKCksIGJ1aWxkSmF2YVRvSkRCQ1R5cGVNYXBwaW5nKGphdmFDbGFzcywgamRiY1R5cGVDb2RlKSk7Ci0JCWlmIChwcmV2ICE9IG51bGwpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oImR1cGxpY2F0ZSBKYXZhIGNsYXNzOiAiICsgKChKYXZhVG9KREJDVHlwZU1hcHBpbmcpIHByZXYpLmdldEphdmFUeXBlKCkuZGVjbGFyYXRpb24oKSk7IC8vJE5PTi1OTFMtMSQKLQkJfQotCX0KLQotCXByaXZhdGUgc3RhdGljIEphdmFUb0pEQkNUeXBlTWFwcGluZyBidWlsZEphdmFUb0pEQkNUeXBlTWFwcGluZyhDbGFzczw/PiBqYXZhQ2xhc3MsIGludCBqZGJjVHlwZUNvZGUpIHsKLQkJcmV0dXJuIG5ldyBKYXZhVG9KREJDVHlwZU1hcHBpbmcobmV3IFNpbXBsZUphdmFUeXBlKGphdmFDbGFzcyksIEpEQkNUeXBlLnR5cGUoamRiY1R5cGVDb2RlKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9yICoqKioqKioqKioKLQotCS8qKgotCSAqIFN1cHByZXNzIGRlZmF1bHQgY29uc3RydWN0b3IsIGVuc3VyaW5nIG5vbi1pbnN0YW50aWFiaWxpdHkuCi0JICovCi0JcHJpdmF0ZSBKREJDVG9vbHMoKSB7Ci0JCXN1cGVyKCk7Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBtZW1iZXIgY2xhc3NlcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBKREJDID0+IEphdmEKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBKREJDVG9KYXZhVHlwZU1hcHBpbmcgewotCQlwcml2YXRlIGZpbmFsIEpEQkNUeXBlIGpkYmNUeXBlOwotCQlwcml2YXRlIGZpbmFsIEphdmFUeXBlIGphdmFUeXBlOwotCi0JCUpEQkNUb0phdmFUeXBlTWFwcGluZyhKREJDVHlwZSBqZGJjVHlwZSwgSmF2YVR5cGUgamF2YVR5cGUpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLmpkYmNUeXBlID0gamRiY1R5cGU7Ci0JCQl0aGlzLmphdmFUeXBlID0gamF2YVR5cGU7Ci0JCX0KLQotCQlwdWJsaWMgSkRCQ1R5cGUgZ2V0SkRCQ1R5cGUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5qZGJjVHlwZTsKLQkJfQotCi0JCXB1YmxpYyBKYXZhVHlwZSBnZXRKYXZhVHlwZSgpIHsKLQkJCXJldHVybiB0aGlzLmphdmFUeXBlOwotCQl9Ci0KLQkJcHVibGljIGJvb2xlYW4gbWFwcyhpbnQgamRiY1R5cGVDb2RlKSB7Ci0JCQlyZXR1cm4gdGhpcy5qZGJjVHlwZS5jb2RlKCkgPT0gamRiY1R5cGVDb2RlOwotCQl9Ci0KLQkJcHVibGljIGJvb2xlYW4gbWFwcyhTdHJpbmcgamRiY1R5cGVOYW1lKSB7Ci0JCQlyZXR1cm4gdGhpcy5qZGJjVHlwZS5uYW1lKCkuZXF1YWxzKGpkYmNUeXBlTmFtZSk7Ci0JCX0KLQotCQlwdWJsaWMgYm9vbGVhbiBtYXBzKEpEQkNUeXBlIHR5cGUpIHsKLQkJCXJldHVybiB0aGlzLmpkYmNUeXBlID09IHR5cGU7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQkJdGhpcy5hcHBlbmRUbyhzYik7Ci0JCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIGFwcGVuZFRvKFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJCXRoaXMuamRiY1R5cGUuYXBwZW5kVG8oc2IpOwotCQkJc2IuYXBwZW5kKCIgPT4gIik7IC8vJE5PTi1OTFMtMSQKLQkJCXRoaXMuamF2YVR5cGUuYXBwZW5kRGVjbGFyYXRpb25UbyhzYik7Ci0JCX0KLQotCX0KLQotCS8qKgotCSAqIEphdmEgPT4gSkRCQwotCSAqLwotCXByaXZhdGUgc3RhdGljIGNsYXNzIEphdmFUb0pEQkNUeXBlTWFwcGluZyB7Ci0JCXByaXZhdGUgZmluYWwgSmF2YVR5cGUgamF2YVR5cGU7Ci0JCXByaXZhdGUgZmluYWwgSkRCQ1R5cGUgamRiY1R5cGU7Ci0KLQkJSmF2YVRvSkRCQ1R5cGVNYXBwaW5nKEphdmFUeXBlIGphdmFUeXBlLCBKREJDVHlwZSBqZGJjVHlwZSkgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMuamF2YVR5cGUgPSBqYXZhVHlwZTsKLQkJCXRoaXMuamRiY1R5cGUgPSBqZGJjVHlwZTsKLQkJfQotCi0JCXB1YmxpYyBKYXZhVHlwZSBnZXRKYXZhVHlwZSgpIHsKLQkJCXJldHVybiB0aGlzLmphdmFUeXBlOwotCQl9Ci0KLQkJcHVibGljIEpEQkNUeXBlIGdldEpEQkNUeXBlKCkgewotCQkJcmV0dXJuIHRoaXMuamRiY1R5cGU7Ci0JCX0KLQotCQlwdWJsaWMgYm9vbGVhbiBtYXBzKEphdmFUeXBlIGp0KSB7Ci0JCQlyZXR1cm4gdGhpcy5qYXZhVHlwZS5lcXVhbHMoanQpOwotCQl9Ci0KLQkJcHVibGljIGJvb2xlYW4gbWFwcyhTdHJpbmcgZWxlbWVudFR5cGVOYW1lLCBpbnQgYXJyYXlEZXB0aCkgewotCQkJcmV0dXJuIHRoaXMuamF2YVR5cGUuZXF1YWxzKGVsZW1lbnRUeXBlTmFtZSwgYXJyYXlEZXB0aCk7Ci0JCX0KLQotCQlwdWJsaWMgYm9vbGVhbiBtYXBzKFN0cmluZyBqYXZhQ2xhc3NOYW1lKSB7Ci0JCQlyZXR1cm4gdGhpcy5qYXZhVHlwZS5kZXNjcmliZXMoamF2YUNsYXNzTmFtZSk7Ci0JCX0KLQotCQlwdWJsaWMgYm9vbGVhbiBtYXBzKENsYXNzPD8+IGphdmFDbGFzcykgewotCQkJcmV0dXJuIHRoaXMuamF2YVR5cGUuZGVzY3JpYmVzKGphdmFDbGFzcyk7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQkJdGhpcy5hcHBlbmRUbyhzYik7Ci0JCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIGFwcGVuZFRvKFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJCXRoaXMuamF2YVR5cGUuYXBwZW5kRGVjbGFyYXRpb25UbyhzYik7Ci0JCQlzYi5hcHBlbmQoIiA9PiAiKTsgLy8kTk9OLU5MUy0xJAotCQkJdGhpcy5qZGJjVHlwZS5hcHBlbmRUbyhzYik7Ci0JCX0KLQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL0pEQkNUeXBlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvSkRCQ1R5cGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTYzNTI4My4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvSkRCQ1R5cGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE2NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsOwotCi1pbXBvcnQgamF2YS5pby5TZXJpYWxpemFibGU7Ci1pbXBvcnQgamF2YS5sYW5nLnJlZmxlY3QuRmllbGQ7Ci1pbXBvcnQgamF2YS5zcWwuVHlwZXM7Ci1pbXBvcnQgamF2YS50ZXh0LkNvbGxhdG9yOwotCi0vKioKLSAqIEFzc29jaWF0ZSB0aGUgSmF2YSBjb25zdGFudCBhbmQgdGhlIEpEQkMgdHlwZSBuYW1lLgotICogVGhlc2UgYXJlIGRlcml2ZWQgZnJvbSBqYXZhLnNxbC5UeXBlcy4KLSAqIAotICogQHNlZSBqYXZhLnNxbC5UeXBlcwotICovCi1wdWJsaWMgZmluYWwgY2xhc3MgSkRCQ1R5cGUKLQlpbXBsZW1lbnRzIENvbXBhcmFibGU8SkRCQ1R5cGU+LCBDbG9uZWFibGUsIFNlcmlhbGl6YWJsZQotewotCi0JLyoqCi0JICogdGhlIGNvbnN0YW50IG5hbWUgKGUuZy4gVkFSQ0hBUikKLQkgKi8KLQlwcml2YXRlIGZpbmFsIFN0cmluZyBuYW1lOwotCi0JLyoqCi0JICogdGhlIEpEQkMgY29kZSB1c2VkIGJ5IEpEQkMgZHJpdmVycwotCSAqLwotCXByaXZhdGUgZmluYWwgaW50IGNvZGU7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgSkRCQyB0eXBlIHdpdGggdGhlIHNwZWNpZmllZCBuYW1lIGFuZCB0eXBlIGNvZGUuCi0JICogVGhpcyBpcyBwcml2YXRlIGJlY2F1c2UgYWxsIHRoZSBwb3NzaWJsZSBKREJDIHR5cGVzIGFyZSBidWlsdCBhbmQKLQkgKiBzdG9yZWQgaW4gdGhlIHN0YXRpYyBhcnJheSBUWVBFUy4KLQkgKiBAc2VlICN0eXBlcygpCi0JICovCi0JcHJpdmF0ZSBKREJDVHlwZShTdHJpbmcgbmFtZSwgaW50IGNvZGUpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5uYW1lID0gbmFtZTsKLQkJdGhpcy5jb2RlID0gY29kZTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYWNjZXNzb3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB0aGUgbmFtZSBvZiB0aGUgdHlwZSwgYXMgZGVmaW5lZCBpbiBqYXZhLnNxbC5UeXBlcy4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIG5hbWUoKSB7Ci0JCXJldHVybiB0aGlzLm5hbWU7Ci0JfQotCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHR5cGUgY29kZSwgYXMgZGVmaW5lZCBpbiBqYXZhLnNxbC5UeXBlcy4KLQkgKi8KLQlwdWJsaWMgaW50IGNvZGUoKSB7Ci0JCXJldHVybiB0aGlzLmNvZGU7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHByaW50aW5nIGFuZCBkaXNwbGF5aW5nICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIGFwcGVuZFRvKFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJc2IuYXBwZW5kKHRoaXMubmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7Ci0JCXNiLmFwcGVuZChDbGFzc1Rvb2xzLnNob3J0Q2xhc3NOYW1lRm9yT2JqZWN0KHRoaXMpKTsKLQkJc2IuYXBwZW5kKCcoJyk7Ci0JCXRoaXMuYXBwZW5kVG8oc2IpOwotCQlzYi5hcHBlbmQoJyknKTsKLQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIEpEQkNUeXBlIGNsb25lKCkgewotCQl0cnkgewotCQkJcmV0dXJuIChKREJDVHlwZSkgc3VwZXIuY2xvbmUoKTsKLQkJfSBjYXRjaCAoQ2xvbmVOb3RTdXBwb3J0ZWRFeGNlcHRpb24gZXgpIHsKLQkJCXRocm93IG5ldyBJbnRlcm5hbEVycm9yKCk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgaW50IGNvbXBhcmVUbyhKREJDVHlwZSB0eXBlKSB7Ci0JCXJldHVybiBDb2xsYXRvci5nZXRJbnN0YW5jZSgpLmNvbXBhcmUodGhpcy5uYW1lLCB0eXBlLm5hbWUpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBzdGF0aWMgc3R1ZmYgKioqKioqKioqKgotCi0JLyoqCi0JICogYWxsIHRoZSBKREJDIHR5cGUgZGVmaW5lZCBpbiBqYXZhLnNxbC5UeXBlcwotCSAqLwotCXByaXZhdGUgc3RhdGljIEpEQkNUeXBlW10gVFlQRVM7CQkvLyBwc2V1ZG8gJ2ZpbmFsJyAtIGxhenktaW5pdGlhbGl6ZWQKLQotCi0JcHVibGljIHN5bmNocm9uaXplZCBzdGF0aWMgSkRCQ1R5cGVbXSB0eXBlcygpIHsKLQkJaWYgKFRZUEVTID09IG51bGwpIHsKLQkJCVRZUEVTID0gYnVpbGRUeXBlcygpOwotCQl9Ci0JCXJldHVybiBUWVBFUzsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIEpEQkMgdHlwZSBmb3IgdGhlIHNwZWNpZmllZCB0eXBlIGNvZGUgKGUuZy4gVHlwZXMuVkFSQ0hBUikuCi0JICogQHNlZSBqYXZhLnNxbC5UeXBlcwotCSAqLwotCXB1YmxpYyBzdGF0aWMgSkRCQ1R5cGUgdHlwZShpbnQgY29kZSkgewotCQlKREJDVHlwZVtdIHR5cGVzID0gdHlwZXMoKTsKLQkJZm9yIChpbnQgaSA9IHR5cGVzLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlpZiAodHlwZXNbaV0uY29kZSgpID09IGNvZGUpIHsKLQkJCQlyZXR1cm4gdHlwZXNbaV07Ci0JCQl9Ci0JCX0KLQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiaW52YWxpZCBKREJDIHR5cGUgY29kZTogIiArIGNvZGUpOyAvLyROT04tTkxTLTEkCi0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBKREJDIHR5cGUgZm9yIHRoZSBzcGVjaWZpZWQgdHlwZSBuYW1lIChlLmcuICJWQVJDSEFSIikuCi0JICogQHNlZSBqYXZhLnNxbC5UeXBlcwotCSAqLwotCXB1YmxpYyBzdGF0aWMgSkRCQ1R5cGUgdHlwZShTdHJpbmcgbmFtZSkgewotCQlKREJDVHlwZVtdIHR5cGVzID0gdHlwZXMoKTsKLQkJZm9yIChpbnQgaSA9IHR5cGVzLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlpZiAodHlwZXNbaV0ubmFtZSgpLmVxdWFscyhuYW1lKSkgewotCQkJCXJldHVybiB0eXBlc1tpXTsKLQkJCX0KLQkJfQotCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJpbnZhbGlkIEpEQkMgdHlwZSBuYW1lOiAiICsgbmFtZSk7IC8vJE5PTi1OTFMtMSQKLQl9Ci0KLQkvKioKLQkgKiBidWlsZCB1cCB0aGUgSkRCQyB0eXBlcyB2aWEgcmVmbGVjdGlvbgotCSAqIEBzZWUgamF2YS5zcWwuVHlwZXMKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBKREJDVHlwZVtdIGJ1aWxkVHlwZXMoKSB7Ci0JCUZpZWxkW10gZmllbGRzID0gVHlwZXMuY2xhc3MuZ2V0RGVjbGFyZWRGaWVsZHMoKTsKLQkJaW50IGxlbiA9IGZpZWxkcy5sZW5ndGg7Ci0JCUpEQkNUeXBlW10gdHlwZXMgPSBuZXcgSkRCQ1R5cGVbbGVuXTsKLQkJZm9yIChpbnQgaSA9IGxlbjsgaS0tID4gMDsgKSB7Ci0JCQlTdHJpbmcgbmFtZSA9IGZpZWxkc1tpXS5nZXROYW1lKCk7Ci0JCQlpbnQgY29kZTsKLQkJCXRyeSB7Ci0JCQkJY29kZSA9ICgoSW50ZWdlcikgZmllbGRzW2ldLmdldChudWxsKSkuaW50VmFsdWUoKTsKLQkJCX0gY2F0Y2ggKElsbGVnYWxBY2Nlc3NFeGNlcHRpb24gZXgpIHsKLQkJCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihleCk7CS8vIHNob3VsZG4ndCBoYXBwZW4uLi4KLQkJCX0KLQkJCXR5cGVzW2ldID0gbmV3IEpEQkNUeXBlKG5hbWUsIGNvZGUpOwotCQl9Ci0JCXJldHVybiB0eXBlczsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9MaXN0ZW5lckxpc3QuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9MaXN0ZW5lckxpc3QuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYTc3NDliZC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvTGlzdGVuZXJMaXN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMTcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uSU9FeGNlcHRpb247Ci1pbXBvcnQgamF2YS5pby5PYmplY3RJbnB1dFN0cmVhbTsKLWltcG9ydCBqYXZhLmlvLk9iamVjdE91dHB1dFN0cmVhbTsKLWltcG9ydCBqYXZhLmlvLlNlcmlhbGl6YWJsZTsKLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5BcnJheTsKLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlzOwotaW1wb3J0IGphdmEudXRpbC5FdmVudExpc3RlbmVyOwotCi0vKioKLSAqIE1haW50YWluIGEgdGhyZWFkLXNhZmUgbGlzdCBvZiBsaXN0ZW5lcnMgdGhhdCBkb2VzIG5vdCBhbGxvdyBkdXBsaWNhdGVzLgotICovCi1wdWJsaWMgY2xhc3MgTGlzdGVuZXJMaXN0PEwgZXh0ZW5kcyBFdmVudExpc3RlbmVyPgotCWltcGxlbWVudHMgU2VyaWFsaXphYmxlCi17Ci0JcHJpdmF0ZSB0cmFuc2llbnQgdm9sYXRpbGUgTFtdIGxpc3RlbmVyczsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDFMOwotCi0KLQlwdWJsaWMgTGlzdGVuZXJMaXN0KENsYXNzPEw+IGxpc3RlbmVyQ2xhc3MpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5saXN0ZW5lcnMgPSB0aGlzLmJ1aWxkRW1wdHlBcnJheShsaXN0ZW5lckNsYXNzKTsKLQl9Ci0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcml2YXRlIExbXSBidWlsZEVtcHR5QXJyYXkoQ2xhc3M8TD4gbGlzdGVuZXJDbGFzcykgewotCQlyZXR1cm4gKExbXSkgQXJyYXkubmV3SW5zdGFuY2UobGlzdGVuZXJDbGFzcywgMCk7Ci0JfQotCi0JcHVibGljIExbXSBnZXRMaXN0ZW5lcnMoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3RlbmVyczsKLQl9Ci0KLQlwdWJsaWMgaW50IHNpemUoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3RlbmVycy5sZW5ndGg7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaXNFbXB0eSgpIHsKLQkJcmV0dXJuIHRoaXMubGlzdGVuZXJzLmxlbmd0aCA9PSAwOwotCX0KLQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCBhZGQoTCBsaXN0ZW5lcikgewotCQlpZiAobGlzdGVuZXIgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJaWYgKENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmxpc3RlbmVycywgbGlzdGVuZXIpKSB7Ci0JCQlyZXR1cm47Ly90aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJkdXBsaWNhdGUgbGlzdGVuZXI6ICIgKyBsaXN0ZW5lcik7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQl0aGlzLmxpc3RlbmVycyA9IENvbGxlY3Rpb25Ub29scy5hZGQodGhpcy5saXN0ZW5lcnMsIGxpc3RlbmVyKTsKLQl9Ci0KLQlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgcmVtb3ZlKEwgbGlzdGVuZXIpIHsKLQkJaWYgKGxpc3RlbmVyID09IG51bGwpIHsKLQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigpOwotCQl9Ci0JCWludCBpbmRleCA9IENvbGxlY3Rpb25Ub29scy5pbmRleE9mKHRoaXMubGlzdGVuZXJzLCBsaXN0ZW5lcik7Ci0JCWlmIChpbmRleCA9PSAtMSkgewotCQkJcmV0dXJuOy8vdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigidW5yZWdpc3RlcmVkIGxpc3RlbmVyOiAiICsgbGlzdGVuZXIpOyAvLyROT04tTkxTLTEkCi0JCX0KLQkJdGhpcy5saXN0ZW5lcnMgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlRWxlbWVudEF0SW5kZXgodGhpcy5saXN0ZW5lcnMsIGluZGV4KTsKLQl9Ci0KLQlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgY2xlYXIoKSB7Ci0JCXRoaXMubGlzdGVuZXJzID0gQ29sbGVjdGlvblRvb2xzLmNsZWFyKHRoaXMubGlzdGVuZXJzKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gQXJyYXlzLnRvU3RyaW5nKHRoaXMubGlzdGVuZXJzKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogc2VyaWFsaXphdGlvbiAqKioqKioqKioqCi0KLQlwcml2YXRlIHN5bmNocm9uaXplZCB2b2lkIHdyaXRlT2JqZWN0KE9iamVjdE91dHB1dFN0cmVhbSBzKSB0aHJvd3MgSU9FeGNlcHRpb24gewotCQkvLyB3cml0ZSBvdXQgYW55IGhpZGRlbiBzdHVmZgotCQlzLmRlZmF1bHRXcml0ZU9iamVjdCgpOwotCi0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlDbGFzczxMPiBsaXN0ZW5lckNsYXNzID0gKENsYXNzPEw+KSB0aGlzLmxpc3RlbmVycy5nZXRDbGFzcygpLmdldENvbXBvbmVudFR5cGUoKTsKLQkJcy53cml0ZU9iamVjdChsaXN0ZW5lckNsYXNzKTsKLQotCQkvLyBvbmx5IHdyaXRlIG91dCBzZXJpYWxpemFibGUgbGlzdGVuZXJzCi0JCWZvciAoTCBsaXN0ZW5lciA6IHRoaXMubGlzdGVuZXJzKSB7Ci0JCQlpZiAobGlzdGVuZXIgaW5zdGFuY2VvZiBTZXJpYWxpemFibGUpIHsKLQkJCQlzLndyaXRlT2JqZWN0KGxpc3RlbmVyKTsKLQkJCX0KLQkJfQotCi0JCXMud3JpdGVPYmplY3QobnVsbCk7Ci0gICAgfQotCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJpdmF0ZSBzeW5jaHJvbml6ZWQgdm9pZCByZWFkT2JqZWN0KE9iamVjdElucHV0U3RyZWFtIHMpIHRocm93cyBDbGFzc05vdEZvdW5kRXhjZXB0aW9uLCBJT0V4Y2VwdGlvbiB7Ci0JCS8vIHJlYWQgaW4gYW55IGhpZGRlbiBzdHVmZgotCQlzLmRlZmF1bHRSZWFkT2JqZWN0KCk7Ci0KLQkJQ2xhc3M8TD4gbGlzdGVuZXJDbGFzcyA9IChDbGFzczxMPikgcy5yZWFkT2JqZWN0KCk7Ci0JCXRoaXMubGlzdGVuZXJzID0gdGhpcy5idWlsZEVtcHR5QXJyYXkobGlzdGVuZXJDbGFzcyk7Ci0JCU9iamVjdCBvOwotCQl3aGlsZSAoKG8gPSBzLnJlYWRPYmplY3QoKSkgIT0gbnVsbCkgewotCQkJdGhpcy5hZGQoKEwpIG8pOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvTmFtZVRvb2xzLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvTmFtZVRvb2xzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGUwMjQ1NDkuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL05hbWVUb29scy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzcyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLmJlYW5zLkludHJvc3BlY3RvcjsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbnM7Ci1pbXBvcnQgamF2YS51dGlsLkhhc2hTZXQ7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Tb3J0ZWRTZXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkFycmF5SXRlcmF0b3I7Ci0KLS8qKgotICogVmFyaW91cyBoZWxwZXIgbWV0aG9kcyBmb3IgZ2VuZXJhdGluZyBuYW1lcy4KLSAqLwotcHVibGljIGZpbmFsIGNsYXNzIE5hbWVUb29scyB7Ci0KLQkvKioKLQkgKiBHaXZlbiBhICJyb290IiBuYW1lIGFuZCBhIHNldCBvZiBleGlzdGluZyBuYW1lcywgZ2VuZXJhdGUgYSB1bmlxdWUKLQkgKiBuYW1lIHRoYXQgaXMgZWl0aGVyIHRoZSAicm9vdCIgbmFtZSBvciBzb21lIHZhcmlhdGlvbiBvbiB0aGUgInJvb3QiCi0JICogbmFtZSAoZS5nLiAicm9vdDIiLCAicm9vdDMiLC4uLikuIFRoZSBuYW1lcyBhcmUgY2FzZS1zZW5zaXRpdmUKLQkgKiAoaS5lLiAiUm9vdCIgYW5kICJyb290IiBhcmUgYm90aCBhbGxvd2VkKS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyB1bmlxdWVOYW1lRm9yKFN0cmluZyByb290TmFtZSwgSXRlcmF0b3I8U3RyaW5nPiBleGlzdGluZ05hbWVzKSB7Ci0JCXJldHVybiB1bmlxdWVOYW1lRm9yKHJvb3ROYW1lLCBDb2xsZWN0aW9uVG9vbHMuc2V0KGV4aXN0aW5nTmFtZXMpKTsKLQl9Ci0JCi0JLyoqCi0JICogR2l2ZW4gYSAicm9vdCIgbmFtZSBhbmQgYSBzZXQgb2YgZXhpc3RpbmcgbmFtZXMsIGdlbmVyYXRlIGEgdW5pcXVlCi0JICogbmFtZSB0aGF0IGlzIGVpdGhlciB0aGUgInJvb3QiIG5hbWUgb3Igc29tZSB2YXJpYXRpb24gb24gdGhlICJyb290IgotCSAqIG5hbWUgKGUuZy4gInJvb3QyIiwgInJvb3QzIiwuLi4pLiBUaGUgbmFtZXMgYXJlIGNhc2Utc2Vuc2l0aXZlCi0JICogKGkuZS4gIlJvb3QiIGFuZCAicm9vdCIgYXJlIGJvdGggYWxsb3dlZCkuCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgdW5pcXVlTmFtZUZvcihTdHJpbmcgcm9vdE5hbWUsIENvbGxlY3Rpb248U3RyaW5nPiBleGlzdGluZ05hbWVzKSB7Ci0JCXJldHVybiB1bmlxdWVOYW1lRm9yKHJvb3ROYW1lLCBleGlzdGluZ05hbWVzLCByb290TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogR2l2ZW4gYSAicm9vdCIgbmFtZSBhbmQgYSBzZXQgb2YgZXhpc3RpbmcgbmFtZXMsIGdlbmVyYXRlIGEgdW5pcXVlCi0JICogbmFtZSB0aGF0IGlzIGVpdGhlciB0aGUgInJvb3QiIG5hbWUgb3Igc29tZSB2YXJpYXRpb24gb24gdGhlICJyb290IgotCSAqIG5hbWUgKGUuZy4gInJvb3QyIiwgInJvb3QzIiwuLi4pLiBUaGUgbmFtZXMgYXJlIE5PVCBjYXNlLXNlbnNpdGl2ZQotCSAqIChpLmUuICJSb290IiBhbmQgInJvb3QiIGFyZSBOT1QgYm90aCBhbGxvd2VkKS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyB1bmlxdWVOYW1lRm9ySWdub3JlQ2FzZShTdHJpbmcgcm9vdE5hbWUsIEl0ZXJhdG9yPFN0cmluZz4gZXhpc3RpbmdOYW1lcykgewotCQlyZXR1cm4gdW5pcXVlTmFtZUZvcklnbm9yZUNhc2Uocm9vdE5hbWUsIENvbGxlY3Rpb25Ub29scy5zZXQoZXhpc3RpbmdOYW1lcykpOwotCX0KLQotCS8qKgotCSAqIEdpdmVuIGEgInJvb3QiIG5hbWUgYW5kIGEgc2V0IG9mIGV4aXN0aW5nIG5hbWVzLCBnZW5lcmF0ZSBhIHVuaXF1ZQotCSAqIG5hbWUgdGhhdCBpcyBlaXRoZXIgdGhlICJyb290IiBuYW1lIG9yIHNvbWUgdmFyaWF0aW9uIG9uIHRoZSAicm9vdCIKLQkgKiBuYW1lIChlLmcuICJyb290MiIsICJyb290MyIsLi4uKS4gVGhlIG5hbWVzIGFyZSBOT1QgY2FzZS1zZW5zaXRpdmUKLQkgKiAoaS5lLiAiUm9vdCIgYW5kICJyb290IiBhcmUgTk9UIGJvdGggYWxsb3dlZCkuCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgdW5pcXVlTmFtZUZvcklnbm9yZUNhc2UoU3RyaW5nIHJvb3ROYW1lLCBDb2xsZWN0aW9uPFN0cmluZz4gZXhpc3RpbmdOYW1lcykgewotCQlyZXR1cm4gdW5pcXVlTmFtZUZvcihyb290TmFtZSwgY29udmVydFRvTG93ZXJDYXNlKGV4aXN0aW5nTmFtZXMpLCByb290TmFtZS50b0xvd2VyQ2FzZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiB1c2UgdGhlIHN1ZmZpeGVkICJ0ZW1wbGF0ZSIgbmFtZSB0byBwZXJmb3JtIHRoZSBjb21wYXJpc29ucywgYnV0IFJFVFVSTgotCSAqIHRoZSBzdWZmaXhlZCAicm9vdCIgbmFtZTsgdGhpcyBhbGxvd3MgY2FzZS1pbnNlbnNpdGl2ZSBjb21wYXJpc29ucwotCSAqIChpLmUuIHRoZSAidGVtcGxhdGUiIG5hbWUgaGFzIGJlZW4gbW9ycGhlZCB0byB0aGUgc2FtZSBjYXNlIGFzCi0JICogdGhlICJleGlzdGluZyIgbmFtZXMsIHdoaWxlIHRoZSAicm9vdCIgbmFtZSBoYXMgbm90LCBidXQgdGhlICJyb290IiBuYW1lCi0JICogaXMgd2hhdCB0aGUgY2xpZW50IHdhbnRzIG1vcnBoZWQgdG8gYmUgdW5pcXVlKQotCSAqLwotCXByaXZhdGUgc3RhdGljIFN0cmluZyB1bmlxdWVOYW1lRm9yKFN0cmluZyByb290TmFtZSwgQ29sbGVjdGlvbjxTdHJpbmc+IGV4aXN0aW5nTmFtZXMsIFN0cmluZyB0ZW1wbGF0ZU5hbWUpIHsKLQkJaWYgKCAhIGV4aXN0aW5nTmFtZXMuY29udGFpbnModGVtcGxhdGVOYW1lKSkgewotCQkJcmV0dXJuIHJvb3ROYW1lOwotCQl9Ci0JCVN0cmluZyB1bmlxdWVOYW1lID0gdGVtcGxhdGVOYW1lOwotCQlmb3IgKGludCBzdWZmaXggPSAyOyB0cnVlOyBzdWZmaXgrKykgewotCQkJaWYgKCAhIGV4aXN0aW5nTmFtZXMuY29udGFpbnModW5pcXVlTmFtZSArIHN1ZmZpeCkpIHsKLQkJCQlyZXR1cm4gcm9vdE5hbWUuY29uY2F0KFN0cmluZy52YWx1ZU9mKHN1ZmZpeCkpOwotCQkJfQotCQl9Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24gb2Ygc3RyaW5ncyB0byBhIGNvbGxlY3Rpb24gb2YgdGhlIHNhbWUKLQkgKiBzdHJpbmdzIGNvbnZlcnRlZCB0byBsb3dlciBjYXNlLgotCSAqLwotCXByaXZhdGUgc3RhdGljIEhhc2hTZXQ8U3RyaW5nPiBjb252ZXJ0VG9Mb3dlckNhc2UoQ29sbGVjdGlvbjxTdHJpbmc+IHN0cmluZ3MpIHsKLQkJSGFzaFNldDxTdHJpbmc+IHJlc3VsdCA9IG5ldyBIYXNoU2V0PFN0cmluZz4oc3RyaW5ncy5zaXplKCkpOwotCQlmb3IgKFN0cmluZyBzdHJpbmcgOiBzdHJpbmdzKSB7Ci0JCQlyZXN1bHQuYWRkKHN0cmluZy50b0xvd2VyQ2FzZSgpKTsKLQkJfQotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIEJ1aWxkIGEgZnVsbHktcXVhbGlmaWVkIG5hbWUgZm9yIHRoZSBzcGVjaWZpZWQgZGF0YWJhc2Ugb2JqZWN0LgotCSAqIFZhcmlhdGlvbnM6Ci0JICogICAgIGNhdGFsb2cuc2NoZW1hLm5hbWUKLQkgKiAgICAgY2F0YWxvZy4ubmFtZQotCSAqICAgICBzY2hlbWEubmFtZQotCSAqICAgICBuYW1lCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgYnVpbGRRdWFsaWZpZWREYXRhYmFzZU9iamVjdE5hbWUoU3RyaW5nIGNhdGFsb2csIFN0cmluZyBzY2hlbWEsIFN0cmluZyBuYW1lKSB7Ci0JCWlmIChuYW1lID09IG51bGwpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCWlmICgoY2F0YWxvZyA9PSBudWxsKSAmJiAoc2NoZW1hID09IG51bGwpKSB7Ci0JCQlyZXR1cm4gbmFtZTsKLQkJfQotCi0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigxMDApOwotCQlpZiAoY2F0YWxvZyAhPSBudWxsKSB7Ci0JCQlzYi5hcHBlbmQoY2F0YWxvZyk7Ci0JCQlzYi5hcHBlbmQoJy4nKTsKLQkJfQotCQlpZiAoc2NoZW1hICE9IG51bGwpIHsKLQkJCXNiLmFwcGVuZChzY2hlbWEpOwotCQl9Ci0JCXNiLmFwcGVuZCgnLicpOwotCQlzYi5hcHBlbmQobmFtZSk7Ci0JCXJldHVybiBzYi50b1N0cmluZygpOwotCX0KLQotCS8qKgotCSAqIFRoZSBzZXQgb2YgcmVzZXJ2ZWQgd29yZHMgaW4gdGhlIEphdmEgcHJvZ3JhbW1pbmcgbGFuZ3VhZ2UuCi0JICogVGhlc2Ugd29yZHMgY2Fubm90IGJlIHVzZWQgYXMgaWRlbnRpZmllcnMgKGkuZS4gbmFtZXMpLgotCSAqIGh0dHA6Ly9qYXZhLnN1bi5jb20vZG9jcy9ib29rcy90dXRvcmlhbC9qYXZhL251dHNhbmRib2x0cy9fa2V5d29yZHMuaHRtbAotCSAqLwotCUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nW10gSkFWQV9SRVNFUlZFRF9XT1JEUyA9IG5ldyBTdHJpbmdbXSB7Ci0JCQkJImFic3RyYWN0IiwKLQkJCQkiYXNzZXJ0IiwgIC8vIGpkayAxLjQKLQkJCQkiYm9vbGVhbiIsCi0JCQkJImJyZWFrIiwKLQkJCQkiYnl0ZSIsCi0JCQkJImNhc2UiLAotCQkJCSJjYXRjaCIsCi0JCQkJImNoYXIiLAotCQkJCSJjbGFzcyIsCi0JCQkJImNvbnN0IiwgIC8vIHVudXNlZAotCQkJCSJjb250aW51ZSIsCi0JCQkJImRlZmF1bHQiLAotCQkJCSJkbyIsCi0JCQkJImRvdWJsZSIsCi0JCQkJImVsc2UiLAotCQkJCSJlbnVtIiwgIC8vIGpkayAxLjUKLQkJCQkiZXh0ZW5kcyIsCi0JCQkJImZhbHNlIiwKLQkJCQkiZmluYWwiLAotCQkJCSJmaW5hbGx5IiwKLQkJCQkiZmxvYXQiLAotCQkJCSJmb3IiLAotCQkJCSJnb3RvIiwgIC8vIHVudXNlZAotCQkJCSJpZiIsCi0JCQkJImltcGxlbWVudHMiLAotCQkJCSJpbXBvcnQiLAotCQkJCSJpbnN0YW5jZW9mIiwKLQkJCQkiaW50IiwKLQkJCQkiaW50ZXJmYWNlIiwKLQkJCQkibG9uZyIsCi0JCQkJIm5hdGl2ZSIsCi0JCQkJIm5ldyIsCi0JCQkJIm51bGwiLAotCQkJCSJwYWNrYWdlIiwKLQkJCQkicHJpdmF0ZSIsCi0JCQkJInByb3RlY3RlZCIsCi0JCQkJInB1YmxpYyIsCi0JCQkJInJldHVybiIsCi0JCQkJInNob3J0IiwKLQkJCQkic3RhdGljIiwKLQkJCQkic3RyaWN0ZnAiLCAgLy8gamRrIDEuMgotCQkJCSJzdXBlciIsCi0JCQkJInN3aXRjaCIsCi0JCQkJInN5bmNocm9uaXplZCIsCi0JCQkJInRoaXMiLAotCQkJCSJ0aHJvdyIsCi0JCQkJInRocm93cyIsCi0JCQkJInRyYW5zaWVudCIsCi0JCQkJInRydWUiLAotCQkJCSJ0cnkiLAotCQkJCSJ2b2lkIiwKLQkJCQkidm9sYXRpbGUiLAotCQkJCSJ3aGlsZSIKLQkJCX07Ci0KLQkvKioKLQkgKiBUaGUgc2V0IG9mIHJlc2VydmVkIHdvcmRzIGluIHRoZSBKYXZhIHByb2dyYW1taW5nIGxhbmd1YWdlLgotCSAqIFRoZXNlIHdvcmRzIGNhbm5vdCBiZSB1c2VkIGFzIGlkZW50aWZpZXJzIChpLmUuIG5hbWVzKS4KLQkgKiBodHRwOi8vamF2YS5zdW4uY29tL2RvY3MvYm9va3MvdHV0b3JpYWwvamF2YS9udXRzYW5kYm9sdHMvX2tleXdvcmRzLmh0bWwKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGZpbmFsIFNvcnRlZFNldDxTdHJpbmc+IEpBVkFfUkVTRVJWRURfV09SRFNfU0VUID0gCi0JCUNvbGxlY3Rpb25zLnVubW9kaWZpYWJsZVNvcnRlZFNldChDb2xsZWN0aW9uVG9vbHMuc29ydGVkU2V0KEpBVkFfUkVTRVJWRURfV09SRFMpKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2V0IG9mIEphdmEgcHJvZ3JhbW1pbmcgbGFuZ3VhZ2UgcmVzZXJ2ZWQgd29yZHMuCi0JICogVGhlc2Ugd29yZHMgY2Fubm90IGJlIHVzZWQgYXMgaWRlbnRpZmllcnMgKGkuZS4gbmFtZXMpLgotCSAqIGh0dHA6Ly9qYXZhLnN1bi5jb20vZG9jcy9ib29rcy90dXRvcmlhbC9qYXZhL251dHNhbmRib2x0cy9fa2V5d29yZHMuaHRtbAotCSAqLwotCXB1YmxpYyBzdGF0aWMgSXRlcmF0b3I8U3RyaW5nPiBqYXZhUmVzZXJ2ZWRXb3JkcygpIHsKLQkJcmV0dXJuIG5ldyBBcnJheUl0ZXJhdG9yPFN0cmluZz4oSkFWQV9SRVNFUlZFRF9XT1JEUyk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBzdHJpbmcgY29uc2lzdHMgb2YgSmF2YSBpZGVudGlmaWVyCi0JICogY2hhcmFjdGVycyAoYnV0IG1heSBiZSBhIHJlc2VydmVkIHdvcmQpLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBzdHJpbmdDb25zaXN0c09mSmF2YUlkZW50aWZpZXJDaGFyYWN0ZXJzKFN0cmluZyBzdHJpbmcpIHsKLQkJaWYgKHN0cmluZy5sZW5ndGgoKSA9PSAwKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJcmV0dXJuIHN0cmluZ0NvbnNpc3RzT2ZKYXZhSWRlbnRpZmllckNoYXJhY3RlcnNfKHN0cmluZy50b0NoYXJBcnJheSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIHN0cmluZyBjb25zaXN0cyBvZiBKYXZhIGlkZW50aWZpZXIKLQkgKiBjaGFyYWN0ZXJzIChidXQgbWF5IGJlIGEgcmVzZXJ2ZWQgd29yZCkuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIHN0cmluZ0NvbnNpc3RzT2ZKYXZhSWRlbnRpZmllckNoYXJhY3RlcnMoY2hhcltdIHN0cmluZykgewotCQlpZiAoc3RyaW5nLmxlbmd0aCA9PSAwKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJcmV0dXJuIHN0cmluZ0NvbnNpc3RzT2ZKYXZhSWRlbnRpZmllckNoYXJhY3RlcnNfKHN0cmluZyk7Ci0JfQotCi0JLyoqCi0JICogVGhlIHNwZWNpZmllZCBzdHJpbmcgbXVzdCBub3QgYmUgZW1wdHkuCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgYm9vbGVhbiBzdHJpbmdDb25zaXN0c09mSmF2YUlkZW50aWZpZXJDaGFyYWN0ZXJzXyhjaGFyW10gc3RyaW5nKSB7Ci0JCWlmICggISBDaGFyYWN0ZXIuaXNKYXZhSWRlbnRpZmllclN0YXJ0KHN0cmluZ1swXSkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlmb3IgKGludCBpID0gc3RyaW5nLmxlbmd0aDsgaS0tID4gMTsgKSB7ICAvLyBOQjogZW5kIHdpdGggMQotCQkJaWYgKCAhIENoYXJhY3Rlci5pc0phdmFJZGVudGlmaWVyUGFydChzdHJpbmdbaV0pKSB7Ci0JCQkJcmV0dXJuIGZhbHNlOwotCQkJfQotCQl9Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGlzIGEgdmFsaWQgSmF2YSBpZGVudGlmaWVyLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBzdHJpbmdJc0xlZ2FsSmF2YUlkZW50aWZpZXIoU3RyaW5nIHN0cmluZykgewotCQlyZXR1cm4gc3RyaW5nQ29uc2lzdHNPZkphdmFJZGVudGlmaWVyQ2hhcmFjdGVycyhzdHJpbmcpCi0JCQkJJiYgISBKQVZBX1JFU0VSVkVEX1dPUkRTX1NFVC5jb250YWlucyhzdHJpbmcpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGlzIGEgdmFsaWQgSmF2YSBpZGVudGlmaWVyLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBzdHJpbmdJc0xlZ2FsSmF2YUlkZW50aWZpZXIoY2hhcltdIHN0cmluZykgewotCQlyZXR1cm4gc3RyaW5nQ29uc2lzdHNPZkphdmFJZGVudGlmaWVyQ2hhcmFjdGVycyhzdHJpbmcpCi0JCQkJJiYgISBKQVZBX1JFU0VSVkVEX1dPUkRTX1NFVC5jb250YWlucyhuZXcgU3RyaW5nKHN0cmluZykpOwotCX0KLQotCS8qKgotCSAqIENvbnZlcnQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gYSB2YWxpZCBKYXZhIGlkZW50aWZpZXIKLQkgKiBieSBzdWJzdGl0dXRpbmcgYW4gdW5kZXJzY29yZSAnXycgZm9yIGFueSBpbnZhbGlkIGNoYXJhY3RlcnMKLQkgKiBpbiB0aGUgc3RyaW5nIGFuZCBhcHBlbmRpbmcgYW4gdW5kZXJzY29yZSAnXycgdG8gdGhlIHN0cmluZyBpZgotCSAqIGl0IGlzIGEgSmF2YSByZXNlcnZlZCB3b3JkLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGNvbnZlcnRUb0phdmFJZGVudGlmaWVyKFN0cmluZyBzdHJpbmcpIHsKLQkJcmV0dXJuIGNvbnZlcnRUb0phdmFJZGVudGlmaWVyKHN0cmluZywgJ18nKTsKLQl9Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIGEgdmFsaWQgSmF2YSBpZGVudGlmaWVyCi0JICogYnkgc3Vic3RpdHV0aW5nIHRoZSBzcGVjaWZpZWQgY2hhcmFjdGVyIGZvciBhbnkgaW52YWxpZCBjaGFyYWN0ZXJzCi0JICogaW4gdGhlIHN0cmluZyBhbmQsIGlmIG5lY2Vzc2FyeSwgYXBwZW5kaW5nIHRoZSBzcGVjaWZpZWQgY2hhcmFjdGVyCi0JICogdG8gdGhlIHN0cmluZyB1bnRpbCBpdCBpcyBub3QgYSBKYXZhIHJlc2VydmVkIHdvcmQuCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY29udmVydFRvSmF2YUlkZW50aWZpZXIoU3RyaW5nIHN0cmluZywgY2hhciBjKSB7Ci0JCWlmIChzdHJpbmcubGVuZ3RoKCkgPT0gMCkgewotCQkJcmV0dXJuIHN0cmluZzsKLQkJfQotCQlpZiAoSkFWQV9SRVNFUlZFRF9XT1JEU19TRVQuY29udGFpbnMoc3RyaW5nKSkgewotCQkJLy8gYSByZXNlcnZlZCB3b3JkIGlzIGEgdmFsaWQgaWRlbnRpZmllciwgd2UganVzdCBuZWVkIHRvIHR3ZWFrIGl0IGEgYml0Ci0JCQljaGVja0NoYXJJc0phdmFJZGVudGlmaWVyUGFydChjKTsKLQkJCXJldHVybiBjb252ZXJ0VG9KYXZhSWRlbnRpZmllcihzdHJpbmcgKyBjLCBjKTsKLQkJfQotCQljaGFyW10gYXJyYXkgPSBzdHJpbmcudG9DaGFyQXJyYXkoKTsKLQkJcmV0dXJuIGNvbnZlcnRUb0phdmFJZGVudGlmaWVyXyhhcnJheSwgYykgPyBuZXcgU3RyaW5nKGFycmF5KSA6IHN0cmluZzsKLQl9Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIGEgdmFsaWQgSmF2YSBpZGVudGlmaWVyCi0JICogYnkgc3Vic3RpdHV0aW5nIGFuIHVuZGVyc2NvcmUgJ18nIGZvciBhbnkgaW52YWxpZCBjaGFyYWN0ZXJzCi0JICogaW4gdGhlIHN0cmluZyBhbmQgYXBwZW5kaW5nIGFuIHVuZGVyc2NvcmUgJ18nIHRvIHRoZSBzdHJpbmcgaWYKLQkgKiBpdCBpcyBhIEphdmEgcmVzZXJ2ZWQgd29yZC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXJbXSBjb252ZXJ0VG9KYXZhSWRlbnRpZmllcihjaGFyW10gc3RyaW5nKSB7Ci0JCXJldHVybiBjb252ZXJ0VG9KYXZhSWRlbnRpZmllcihzdHJpbmcsICdfJyk7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byBhIHZhbGlkIEphdmEgaWRlbnRpZmllcgotCSAqIGJ5IHN1YnN0aXR1dGluZyB0aGUgc3BlY2lmaWVkIGNoYXJhY3RlciBmb3IgYW55IGludmFsaWQgY2hhcmFjdGVycwotCSAqIGluIHRoZSBzdHJpbmcgYW5kLCBpZiBuZWNlc3NhcnksIGFwcGVuZGluZyB0aGUgc3BlY2lmaWVkIGNoYXJhY3RlcgotCSAqIHRvIHRoZSBzdHJpbmcgdW50aWwgaXQgaXMgbm90IGEgSmF2YSByZXNlcnZlZCB3b3JkLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIGNvbnZlcnRUb0phdmFJZGVudGlmaWVyKGNoYXJbXSBzdHJpbmcsIGNoYXIgYykgewotCQlpZiAoc3RyaW5nLmxlbmd0aCA9PSAwKSB7Ci0JCQlyZXR1cm4gc3RyaW5nOwotCQl9Ci0JCWlmIChKQVZBX1JFU0VSVkVEX1dPUkRTX1NFVC5jb250YWlucyhuZXcgU3RyaW5nKHN0cmluZykpKSB7Ci0JCQkvLyBhIHJlc2VydmVkIHdvcmQgaXMgYSB2YWxpZCBpZGVudGlmaWVyLCB3ZSBqdXN0IG5lZWQgdG8gdHdlYWsgaXQgYSBiaXQKLQkJCWNoZWNrQ2hhcklzSmF2YUlkZW50aWZpZXJQYXJ0KGMpOwotCQkJcmV0dXJuIGNvbnZlcnRUb0phdmFJZGVudGlmaWVyKENvbGxlY3Rpb25Ub29scy5hZGQoc3RyaW5nLCBjKSwgYyk7Ci0JCX0KLQkJY29udmVydFRvSmF2YUlkZW50aWZpZXJfKHN0cmluZywgYyk7Ci0JCXJldHVybiBzdHJpbmc7Ci0JfQotCi0JLyoqCi0JICogVGhlIHNwZWNpZmllZCBzdHJpbmcgbXVzdCBub3QgYmUgZW1wdHkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHN0cmluZyB3YXMgbW9kaWZpZWQuCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgYm9vbGVhbiBjb252ZXJ0VG9KYXZhSWRlbnRpZmllcl8oY2hhcltdIHN0cmluZywgY2hhciBjKSB7Ci0JCWJvb2xlYW4gbW9kID0gZmFsc2U7Ci0JCWlmICggISBDaGFyYWN0ZXIuaXNKYXZhSWRlbnRpZmllclN0YXJ0KHN0cmluZ1swXSkpIHsKLQkJCWNoZWNrQ2hhcklzSmF2YUlkZW50aWZpZXJTdGFydChjKTsKLQkJCXN0cmluZ1swXSA9IGM7Ci0JCQltb2QgPSB0cnVlOwotCQl9Ci0JCWNoZWNrQ2hhcklzSmF2YUlkZW50aWZpZXJQYXJ0KGMpOwotCQlmb3IgKGludCBpID0gc3RyaW5nLmxlbmd0aDsgaS0tID4gMTsgKSB7ICAvLyBOQjogZW5kIHdpdGggMQotCQkJaWYgKCAhIENoYXJhY3Rlci5pc0phdmFJZGVudGlmaWVyUGFydChzdHJpbmdbaV0pKSB7Ci0JCQkJc3RyaW5nW2ldID0gYzsKLQkJCQltb2QgPSB0cnVlOwotCQkJfQotCQl9Ci0JCXJldHVybiBtb2Q7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBjaGVja0NoYXJJc0phdmFJZGVudGlmaWVyU3RhcnQoY2hhciBjKSB7Ci0JCWlmICggISBDaGFyYWN0ZXIuaXNKYXZhSWRlbnRpZmllclN0YXJ0KGMpKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJpbnZhbGlkIEphdmEgaWRlbnRpZmllciBzdGFydCBjaGFyOiAnIiArIGMgKyAnXCcnKTsgIC8vJE5PTi1OTFMtMSQKLQkJfQotCX0KLQotCXByaXZhdGUgc3RhdGljIHZvaWQgY2hlY2tDaGFySXNKYXZhSWRlbnRpZmllclBhcnQoY2hhciBjKSB7Ci0JCWlmICggISBDaGFyYWN0ZXIuaXNKYXZhSWRlbnRpZmllclBhcnQoYykpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oImludmFsaWQgSmF2YSBpZGVudGlmaWVyIHBhcnQgY2hhcjogJyIgKyBjICsgJ1wnJyk7ICAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgbWV0aG9kIG5hbWUgdG8gYSBwcm9wZXJ0eSBuYW1lLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGNvbnZlcnRHZXR0ZXJNZXRob2ROYW1lVG9Qcm9wZXJ0eU5hbWUoU3RyaW5nIG1ldGhvZE5hbWUpIHsKLQkJaW50IGJlZ2luSW5kZXggPSAwOwotCQlpZiAobWV0aG9kTmFtZS5zdGFydHNXaXRoKCJnZXQiKSkgeyAvLyROT04tTkxTLTEkCi0JCQliZWdpbkluZGV4ID0gMzsKLQkJfSBlbHNlIGlmIChtZXRob2ROYW1lLnN0YXJ0c1dpdGgoImlzIikpIHsgLy8kTk9OLU5MUy0xJAotCQkJYmVnaW5JbmRleCA9IDI7Ci0JCX0KLQkJcmV0dXJuIEludHJvc3BlY3Rvci5kZWNhcGl0YWxpemUobWV0aG9kTmFtZS5zdWJzdHJpbmcoYmVnaW5JbmRleCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBTdXBwcmVzcyBkZWZhdWx0IGNvbnN0cnVjdG9yLCBlbnN1cmluZyBub24taW5zdGFudGlhYmlsaXR5LgotCSAqLwotCXByaXZhdGUgTmFtZVRvb2xzKCkgewotCQlzdXBlcigpOwotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9OdWxsTGlzdC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL051bGxMaXN0LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDFkZWM0NzMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL051bGxMaXN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNTAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5FbXB0eUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5FbXB0eUxpc3RJdGVyYXRvcjsKLQotLyoqCi0gKiBBICJudWxsIiBsaXN0IGlzIGEgYml0IGRpZmZlcmVudCBmcm9tIGFuICJlbXB0eSIgbGlzdDogaXQgYWxsb3dzIGNsaWVudHMgdG8KLSAqIGFkZC9yZW1vdmUgZWxlbWVudHMgdG8vZnJvbSBpdCBidXQgbmV2ZXIgY2hhbmdlcy4gVGhpcyBpcyB1c2VmdWwKLSAqIGZvciBwYXNzaW5nIHRvIG1ldGhvZHMgdGhhdCByZXF1aXJlIGEgImNvbGxlY3RpbmcgcGFyYW1ldGVyIiBidXQgdGhlCi0gKiBjbGllbnQgd2lsbCBpZ25vcmUgdGhlIHJlc3VsdGluZyAiY29sbGVjdGlvbiIuCi0gKiAKLSAqIE5COiBXZSByZXR1cm4gJ251bGwnIGZyb20gdGhlIGZvbGxvd2luZyBtZXRob2RzIChhcyBvcHBvc2VkIHRvIHRocm93aW5nCi0gKiBhbiBleGNlcHRpb24pOgotICogICAgIGdldChpbnQpIDogRQotICogICAgIHJlbW92ZShpbnQpIDogRQotICogICAgIHNldChpbnQsIEUpIDogRQotICovCi1wdWJsaWMgZmluYWwgY2xhc3MgTnVsbExpc3Q8RT4gaW1wbGVtZW50cyBMaXN0PEU+IHsKLQotCS8vIHNpbmdsZXRvbgotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByaXZhdGUgc3RhdGljIGZpbmFsIE51bGxMaXN0IElOU1RBTkNFID0gbmV3IE51bGxMaXN0KCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwdWJsaWMgc3RhdGljIDxFPiBMaXN0PEU+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIE51bGxMaXN0KCkgewotCQlzdXBlcigpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGFkZChFIG8pIHsKLQkJcmV0dXJuIGZhbHNlOyAgLy8gdGhlIGxpc3QgZGlkIG5vdCBjaGFuZ2UKLQl9Ci0KLQlwdWJsaWMgdm9pZCBhZGQoaW50IGluZGV4LCBFIGVsZW1lbnQpIHsKLQkJLy8gaWdub3JlCi0JfQotCi0JcHVibGljIGJvb2xlYW4gYWRkQWxsKENvbGxlY3Rpb248PyBleHRlbmRzIEU+IGMpIHsKLQkJcmV0dXJuIGZhbHNlOyAgLy8gdGhlIGxpc3QgZGlkIG5vdCBjaGFuZ2UKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBhZGRBbGwoaW50IGluZGV4LCBDb2xsZWN0aW9uPD8gZXh0ZW5kcyBFPiBjKSB7Ci0JCXJldHVybiBmYWxzZTsgIC8vIHRoZSBsaXN0IGRpZCBub3QgY2hhbmdlCi0JfQotCi0JcHVibGljIHZvaWQgY2xlYXIoKSB7Ci0JCS8vIGlnbm9yZQotCX0KLQotCXB1YmxpYyBib29sZWFuIGNvbnRhaW5zKE9iamVjdCBvKSB7Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBjb250YWluc0FsbChDb2xsZWN0aW9uPD8+IGMpIHsKLQkJcmV0dXJuIGMuaXNFbXB0eSgpOwotCX0KLQotCXB1YmxpYyBFIGdldChpbnQgaW5kZXgpIHsKLQkJdGhyb3cgbmV3IEluZGV4T3V0T2ZCb3VuZHNFeGNlcHRpb24oIkluZGV4OiAiICsgaW5kZXggKyAiLCBTaXplOiAwIik7IC8vJE5PTi1OTFMtMSQgLy8kTk9OLU5MUy0yJAotCX0KLQotCXB1YmxpYyBpbnQgaW5kZXhPZihPYmplY3QgbykgewotCQlyZXR1cm4gLTE7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaXNFbXB0eSgpIHsKLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JcHVibGljIEl0ZXJhdG9yPEU+IGl0ZXJhdG9yKCkgewotCQlyZXR1cm4gRW1wdHlJdGVyYXRvci5pbnN0YW5jZSgpOwotCX0KLQotCXB1YmxpYyBpbnQgbGFzdEluZGV4T2YoT2JqZWN0IG8pIHsKLQkJcmV0dXJuIC0xOwotCX0KLQotCXB1YmxpYyBMaXN0SXRlcmF0b3I8RT4gbGlzdEl0ZXJhdG9yKCkgewotCQlyZXR1cm4gRW1wdHlMaXN0SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQl9Ci0KLQlwdWJsaWMgTGlzdEl0ZXJhdG9yPEU+IGxpc3RJdGVyYXRvcihpbnQgaW5kZXgpIHsKLQkJcmV0dXJuIEVtcHR5TGlzdEl0ZXJhdG9yLmluc3RhbmNlKCk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gcmVtb3ZlKE9iamVjdCBvKSB7Ci0JCXJldHVybiBmYWxzZTsgIC8vIHRoZSBsaXN0IGRpZCBub3QgY2hhbmdlCi0JfQotCi0JcHVibGljIEUgcmVtb3ZlKGludCBpbmRleCkgewotCQl0aHJvdyBuZXcgSW5kZXhPdXRPZkJvdW5kc0V4Y2VwdGlvbigiSW5kZXg6ICIgKyBpbmRleCArICIsIFNpemU6IDAiKTsgLy8kTk9OLU5MUy0xJCAvLyROT04tTkxTLTIkCi0JfQotCi0JcHVibGljIGJvb2xlYW4gcmVtb3ZlQWxsKENvbGxlY3Rpb248Pz4gYykgewotCQlyZXR1cm4gZmFsc2U7ICAvLyB0aGUgbGlzdCBkaWQgbm90IGNoYW5nZQotCX0KLQotCXB1YmxpYyBib29sZWFuIHJldGFpbkFsbChDb2xsZWN0aW9uPD8+IGMpIHsKLQkJcmV0dXJuIGZhbHNlOyAgLy8gdGhlIGxpc3QgZGlkIG5vdCBjaGFuZ2UKLQl9Ci0KLQlwdWJsaWMgRSBzZXQoaW50IGluZGV4LCBFIGVsZW1lbnQpIHsKLQkJdGhyb3cgbmV3IEluZGV4T3V0T2ZCb3VuZHNFeGNlcHRpb24oIkluZGV4OiAiICsgaW5kZXggKyAiLCBTaXplOiAwIik7IC8vJE5PTi1OTFMtMSQgLy8kTk9OLU5MUy0yJAotCX0KLQotCXB1YmxpYyBpbnQgc2l6ZSgpIHsKLQkJcmV0dXJuIDA7Ci0JfQotCi0JcHVibGljIExpc3Q8RT4gc3ViTGlzdChpbnQgZnJvbUluZGV4LCBpbnQgdG9JbmRleCkgewotCQlyZXR1cm4gdGhpczsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBPYmplY3RbXSBFTVBUWV9PQkpFQ1RfQVJSQVkgPSBuZXcgT2JqZWN0WzBdOwotCXB1YmxpYyBPYmplY3RbXSB0b0FycmF5KCkgewotCQlyZXR1cm4gRU1QVFlfT0JKRUNUX0FSUkFZOwotCX0KLQotCXB1YmxpYyA8VD4gVFtdIHRvQXJyYXkoVFtdIGEpIHsKLQkJcmV0dXJuIGE7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcyk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvUmFuZ2UuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9SYW5nZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxNzY5MThkLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9SYW5nZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uU2VyaWFsaXphYmxlOwotCi0vKioKLSAqIFRoaXMgc2ltcGxlIGNvbnRhaW5lciBjbGFzcyBzaW1wbHkgcHV0cyBhIGJpdCBvZiBzZW1hbnRpY3MKLSAqIGFyb3VuZCBhIHBhaXIgb2YgbnVtYmVycy4KLSAqLwotcHVibGljIGNsYXNzIFJhbmdlCi0JaW1wbGVtZW50cyBDbG9uZWFibGUsIFNlcmlhbGl6YWJsZQotewotCS8qKiBUaGUgc3RhcnRpbmcgaW5kZXggb2YgdGhlIHJhbmdlLiAqLwotCXB1YmxpYyBmaW5hbCBpbnQgc3RhcnQ7Ci0KLQkvKiogVGhlIGVuZGluZyBpbmRleCBvZiB0aGUgcmFuZ2UuICovCi0JcHVibGljIGZpbmFsIGludCBlbmQ7Ci0KLQkvKioKLQkgKiBUaGUgc2l6ZSBjYW4gYmUgbmVnYXRpdmUgaWYgdGhlIGVuZGluZyBpbmRleAotCSAqIGlzIGxlc3MgdGhhbiB0aGUgc3RhcnRpbmcgaW5kZXguCi0JICovCi0JcHVibGljIGZpbmFsIGludCBzaXplOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0KLQotCS8qKgotCSAqIENvbnN0cnVjdCB3aXRoIHRoZSBzcGVjaWZpZWQgc3RhcnQgYW5kIGVuZCwKLQkgKiBib3RoIG9mIHdoaWNoIGFyZSBpbW11dGFibGUuCi0JICovCi0JcHVibGljIFJhbmdlKGludCBzdGFydCwgaW50IGVuZCkgewotCQlzdXBlcigpOwotCQl0aGlzLnN0YXJ0ID0gc3RhcnQ7Ci0JCXRoaXMuZW5kID0gZW5kOwotCQl0aGlzLnNpemUgPSBlbmQgLSBzdGFydCArIDE7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHJhbmdlIGluY2x1ZGVzIHRoZSBzcGVjaWZpZWQKLQkgKiBpbmRleC4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBpbmNsdWRlcyhpbnQgaW5kZXgpIHsKLQkJcmV0dXJuICh0aGlzLnN0YXJ0IDw9IGluZGV4KSAmJiAoaW5kZXggPD0gdGhpcy5lbmQpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBib29sZWFuIGVxdWFscyhPYmplY3QgbykgewotCQlpZiAodGhpcyA9PSBvKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCQlpZiAoICEgKG8gaW5zdGFuY2VvZiBSYW5nZSkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlSYW5nZSBvdGhlclJhbmdlID0gKFJhbmdlKSBvOwotCQlyZXR1cm4gKHRoaXMuc3RhcnQgPT0gb3RoZXJSYW5nZS5zdGFydCkKLQkJCSYmICh0aGlzLmVuZCA9PSBvdGhlclJhbmdlLmVuZCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIGludCBoYXNoQ29kZSgpIHsKLQkJcmV0dXJuIHRoaXMuc3RhcnQgXiB0aGlzLmVuZDsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgUmFuZ2UgY2xvbmUoKSB7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gKFJhbmdlKSBzdXBlci5jbG9uZSgpOwotCQl9IGNhdGNoIChDbG9uZU5vdFN1cHBvcnRlZEV4Y2VwdGlvbiBleCkgewotCQkJdGhyb3cgbmV3IEludGVybmFsRXJyb3IoKTsKLQkJfQotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiAnWycgKyB0aGlzLnN0YXJ0ICsgIiwgIiArIHRoaXMuZW5kICsgJ10nOyAvLyROT04tTkxTLTEkCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvUmV2ZXJzZUNvbXBhcmF0b3IuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9SZXZlcnNlQ29tcGFyYXRvci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxMGMwMWY4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9SZXZlcnNlQ29tcGFyYXRvci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uU2VyaWFsaXphYmxlOwotaW1wb3J0IGphdmEudXRpbC5Db21wYXJhdG9yOwotCi0vKioKLSAqIFRoaXMgY29tcGFyYXRvciB3aWxsIHJldmVyc2UgdGhlIG9yZGVyIG9mIHRoZSBzcGVjaWZpZWQgY29tcGFyYXRvci4KLSAqIElmIHRoZSBjb21wYXJhdG9yIGlzIG51bGwsIHRoZSBuYXR1cmFsIG9yZGVyaW5nIG9mIHRoZSBvYmplY3RzIHdpbGwgYmUgdXNlZC4KLSAqLwotcHVibGljIGNsYXNzIFJldmVyc2VDb21wYXJhdG9yPEUgZXh0ZW5kcyBDb21wYXJhYmxlPD8gc3VwZXIgRT4+Ci0JaW1wbGVtZW50cyBDb21wYXJhdG9yPEU+LCBTZXJpYWxpemFibGUKLXsKLQlwcml2YXRlIGZpbmFsIENvbXBhcmF0b3I8RT4gY29tcGFyYXRvcjsKLQotCXB1YmxpYyBSZXZlcnNlQ29tcGFyYXRvcigpIHsKLQkJdGhpcyhudWxsKTsKLQl9Ci0KLQlwdWJsaWMgUmV2ZXJzZUNvbXBhcmF0b3IoQ29tcGFyYXRvcjxFPiBjb21wYXJhdG9yKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuY29tcGFyYXRvciA9IGNvbXBhcmF0b3I7Ci0JfQotCi0JcHVibGljIGludCBjb21wYXJlKEUgZTEsIEUgZTIpIHsKLQkJcmV0dXJuICh0aGlzLmNvbXBhcmF0b3IgPT0gbnVsbCkgPwotCQkJZTIuY29tcGFyZVRvKGUxKQotCQk6Ci0JCQl0aGlzLmNvbXBhcmF0b3IuY29tcGFyZShlMiwgZTEpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1J1bm5hYmxlQ29tbWFuZC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1J1bm5hYmxlQ29tbWFuZC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1YjE1ZWUwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9SdW5uYWJsZUNvbW1hbmQuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDM3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWw7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5Db21tYW5kOwotCi0vKioKLSAqIFdyYXAgYSBSdW5uYWJsZSBzbyBpdCBjYW4gYmUgdXNlZCBhcyBhIENvbW1hbmQuCi0gKi8KLXB1YmxpYyBjbGFzcyBSdW5uYWJsZUNvbW1hbmQgaW1wbGVtZW50cyBDb21tYW5kIHsKLQlwcm90ZWN0ZWQgZmluYWwgUnVubmFibGUgcnVubmFibGU7Ci0KLQlwdWJsaWMgUnVubmFibGVDb21tYW5kKFJ1bm5hYmxlIHJ1bm5hYmxlKSB7Ci0JCXN1cGVyKCk7Ci0JCWlmIChydW5uYWJsZSA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLnJ1bm5hYmxlID0gcnVubmFibGU7Ci0JfQotCi0JcHVibGljIHZvaWQgZXhlY3V0ZSgpIHsKLQkJdGhpcy5ydW5uYWJsZS5ydW4oKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gIkNvbW1hbmRbIiArIHRoaXMucnVubmFibGUudG9TdHJpbmcoKSArJ10nOyAvLyROT04tTkxTLTEkCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU2ltcGxlQXNzb2NpYXRpb24uamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9TaW1wbGVBc3NvY2lhdGlvbi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3YzliMGE3Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9TaW1wbGVBc3NvY2lhdGlvbi5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNjkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uU2VyaWFsaXphYmxlOwotCi0vKioKLSAqIFN0cmFpZ2h0Zm9yd2FyZCBpbXBsZW1lbnRhdGlvbiBvZiBBc3NvY2lhdGlvbi4KLSAqLwotcHVibGljIGNsYXNzIFNpbXBsZUFzc29jaWF0aW9uPEssIFY+Ci0JZXh0ZW5kcyBBYnN0cmFjdEFzc29jaWF0aW9uPEssIFY+Ci0JaW1wbGVtZW50cyBDbG9uZWFibGUsIFNlcmlhbGl6YWJsZQotewotCXByaXZhdGUgZmluYWwgSyBrZXk7Ci0JcHJpdmF0ZSBWIHZhbHVlOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBhc3NvY2lhdGlvbiB3aXRoIHRoZSBzcGVjaWZpZWQga2V5Ci0JICogYW5kIGEgbnVsbCB2YWx1ZS4KLQkgKi8KLQlwdWJsaWMgU2ltcGxlQXNzb2NpYXRpb24oSyBrZXkpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5rZXkgPSBrZXk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGFzc29jaWF0aW9uIHdpdGggdGhlIHNwZWNpZmllZCBrZXkgYW5kIHZhbHVlLgotCSAqLwotCXB1YmxpYyBTaW1wbGVBc3NvY2lhdGlvbihLIGtleSwgViB2YWx1ZSkgewotCQl0aGlzKGtleSk7Ci0JCXRoaXMudmFsdWUgPSB2YWx1ZTsKLQl9Ci0KLQotCXB1YmxpYyBLIGtleSgpIHsKLQkJcmV0dXJuIHRoaXMua2V5OwotCX0KLQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgViB2YWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMudmFsdWU7Ci0JfQotCi0JcHVibGljIHN5bmNocm9uaXplZCBWIHNldFZhbHVlKFYgdmFsdWUpIHsKLQkJViBvbGQgPSB0aGlzLnZhbHVlOwotCQl0aGlzLnZhbHVlID0gdmFsdWU7Ci0JCXJldHVybiBvbGQ7Ci0JfQotCi0JQE92ZXJyaWRlCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHVibGljIHN5bmNocm9uaXplZCBTaW1wbGVBc3NvY2lhdGlvbjxLLCBWPiBjbG9uZSgpIHsKLQkJdHJ5IHsKLQkJCXJldHVybiAoU2ltcGxlQXNzb2NpYXRpb248SywgVj4pIHN1cGVyLmNsb25lKCk7Ci0JCX0gY2F0Y2ggKENsb25lTm90U3VwcG9ydGVkRXhjZXB0aW9uIGV4KSB7Ci0JCQl0aHJvdyBuZXcgSW50ZXJuYWxFcnJvcigpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU2ltcGxlRmlsdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU2ltcGxlRmlsdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDgwZTIxZjkuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1NpbXBsZUZpbHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTA3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLmlvLlNlcmlhbGl6YWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5GaWx0ZXI7Ci0KLS8qKgotICogU2ltcGxlLCBhYnN0cmFjdCBpbXBsZW1lbnRhdGlvbiBvZiA8Y29kZT5GaWx0ZXI8L2NvZGU+Ci0gKiB0aGF0IGhvbGRzIG9uIHRvIGEgY3JpdGVyaW9uIG9iamVjdCB0aGF0IGNhbiBiZSB1c2VkIGluIHRoZQotICogPGNvZGU+YWNjZXB0KE9iamVjdCk8L2NvZGU+IG9yIDxjb2RlPnJlamVjdChPYmplY3QpPC9jb2RlPgotICogbWV0aG9kcy4gU3ViY2xhc3NlcyBjYW4gb3ZlcnJpZGUgZWl0aGVyIG9mIHRoZXNlIG1ldGhvZHMsCi0gKiBkZXBlbmRpbmcgb24gd2hpY2ggaXMgZWFzaWVyIHRvIGltcGxlbWVudC4gTm90ZSB0aGF0IGF0IGxlYXN0Ci0gKiBvbmUgb2YgdGhlc2UgbWV0aG9kcyA8ZW0+bXVzdDwvZW0+IGJlIG92ZXJyaWRkZW4gb3IKLSAqIGFuIGluZmluaXRlIGxvb3Agd2lsbCBvY2N1ci4gSWYgYm90aCBvZiB0aGVtIGFyZSBvdmVycmlkZGVuLAotICogb25seSB0aGUgPGNvZGU+YWNjZXB0KE9iamVjdCk8L2NvZGU+IG1ldGhvZCB3aWxsIGJlIHVzZWQuCi0gKiA8cD4KLSAqIFNpbXBsaWZpZXMgdGhlIGltcGxlbWVudGF0aW9uIG9mIHN0cmFpZ2h0Zm9yd2FyZCBpbm5lciBjbGFzc2VzLgotICogSGVyZSBpcyBhbiBleGFtcGxlIG9mIGEgZmlsdGVyIHRoYXQgY2FuIGJlIHVzZWQgYnkgYQotICogPGNvZGU+RmlsdGVyaW5nSXRlcmF0b3I8L2NvZGU+IHRvIHJldHVybiBvbmx5IHRob3NlIHN0cmluZ3MKLSAqIGluIHRoZSBuZXN0ZWQgaXRlcmF0b3Igc3RhcnQgd2l0aCAicHJlZml4IjoKLSAqIDxwcmU+Ci0gKglGaWx0ZXI8U3RyaW5nPiBmaWx0ZXIgPSBuZXcgU2ltcGxlRmlsdGVyPFN0cmluZz4oInByZWZpeCIpIHsKLSAqCQlwdWJsaWMgYm9vbGVhbiBhY2NlcHQoU3RyaW5nIG8pIHsKLSAqCQkJcmV0dXJuIG8uc3RhcnRzV2l0aCgoU3RyaW5nKSBjcml0ZXJpb24pOwotICoJCX0KLSAqCX07Ci0gKiA8L3ByZT4KLSAqLwotcHVibGljIGFic3RyYWN0IGNsYXNzIFNpbXBsZUZpbHRlcjxULCBTPgotCWltcGxlbWVudHMgRmlsdGVyPFQ+LCBDbG9uZWFibGUsIFNlcmlhbGl6YWJsZQotewotCXByb3RlY3RlZCBmaW5hbCBTIGNyaXRlcmlvbjsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDFMOwotCi0KLQkvKioKLQkgKiBNb3JlIHVzZWZ1bCBjb25zdHJ1Y3Rvci4gVGhlIHNwZWNpZmllZCBjcml0ZXJpb24gY2FuCi0JICogYmUgdXNlZCBieSBhIHN1YmNsYXNzIHRvICJhY2NlcHQiIG9yICJyZWplY3QiIG9iamVjdHMuCi0JICovCi0JcHJvdGVjdGVkIFNpbXBsZUZpbHRlcihTIGNyaXRlcmlvbikgewotCQlzdXBlcigpOwotCQl0aGlzLmNyaXRlcmlvbiA9IGNyaXRlcmlvbjsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBzaW1wbGUgZmlsdGVyIHdpdGggYSBudWxsIGNyaXRlcmlvbgotCSAqLwotCXByb3RlY3RlZCBTaW1wbGVGaWx0ZXIoKSB7Ci0JCXRoaXMobnVsbCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHRoZSBzcGVjaWZpZWQgb2JqZWN0IHNob3VsZCBiZSAicmVqZWN0ZWQiLgotCSAqIFRoZSBzZW1hbnRpY3Mgb2YgInJlamVjdGVkIiBpcyBkZXRlcm1pbmVkIGJ5IHRoZSBjbGllbnQuCi0JICovCi0JcHJvdGVjdGVkIGJvb2xlYW4gcmVqZWN0KFQgbykgewotCQlyZXR1cm4gISB0aGlzLmFjY2VwdChvKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgdGhlIHNwZWNpZmllZCBvYmplY3Qgc2hvdWxkIGJlICJhY2NlcHRlZCIuCi0JICogVGhlIHNlbWFudGljcyBvZiAiYWNjZXB0ZWQiIGlzIGRldGVybWluZWQgYnkgdGhlIGNsaWVudC4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBhY2NlcHQoVCBvKSB7Ci0JCXJldHVybiAhIHRoaXMucmVqZWN0KG8pOwotCX0KLQotCUBPdmVycmlkZQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXB1YmxpYyBTaW1wbGVGaWx0ZXI8VCwgUz4gY2xvbmUoKSB7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gKFNpbXBsZUZpbHRlcjxULCBTPikgc3VwZXIuY2xvbmUoKTsKLQkJfSBjYXRjaCAoQ2xvbmVOb3RTdXBwb3J0ZWRFeGNlcHRpb24gZXgpIHsKLQkJCXRocm93IG5ldyBJbnRlcm5hbEVycm9yKCk7Ci0JCX0KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgYm9vbGVhbiBlcXVhbHMoT2JqZWN0IG8pIHsKLQkJaWYgKCAhIChvIGluc3RhbmNlb2YgU2ltcGxlRmlsdGVyKSkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCVNpbXBsZUZpbHRlcjw/LCA/PiBvdGhlciA9IChTaW1wbGVGaWx0ZXI8PywgPz4pIG87Ci0JCXJldHVybiAodGhpcy5jcml0ZXJpb24gPT0gbnVsbCkgPwotCQkJKG90aGVyLmNyaXRlcmlvbiA9PSBudWxsKSA6IHRoaXMuY3JpdGVyaW9uLmVxdWFscyhvdGhlci5jcml0ZXJpb24pOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBpbnQgaGFzaENvZGUoKSB7Ci0JCXJldHVybiAodGhpcy5jcml0ZXJpb24gPT0gbnVsbCkgPyAwIDogdGhpcy5jcml0ZXJpb24uaGFzaENvZGUoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuYnVpbGRUb1N0cmluZ0Zvcih0aGlzLCB0aGlzLmNyaXRlcmlvbik7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU2ltcGxlSmF2YVR5cGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9TaW1wbGVKYXZhVHlwZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0MDM0NzIwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9TaW1wbGVKYXZhVHlwZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjMyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLmlvLlByaW50V3JpdGVyOwotaW1wb3J0IGphdmEuaW8uU2VyaWFsaXphYmxlOwotaW1wb3J0IGphdmEudGV4dC5Db2xsYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5KYXZhVHlwZTsKLQotLyoqCi0gKiBTdHJhaWdodGZvcndhcmQgaW1wbGVtZW50YXRpb24gb2YgdGhlIEphdmFUeXBlIGludGVyZmFjZS4KLSAqLwotcHVibGljIGZpbmFsIGNsYXNzIFNpbXBsZUphdmFUeXBlCi0JaW1wbGVtZW50cyBKYXZhVHlwZSwgQ2xvbmVhYmxlLCBTZXJpYWxpemFibGUKLXsKLQotCS8qKgotCSAqIHN0b3JlIHRoZSB0eXBlIGFzIGEgbmFtZSwgc28gd2UgY2FuIHJlZmVyZW5jZSBjbGFzc2VzCi0JICogdGhhdCBhcmUgbm90IGxvYWRlZAotCSAqLwotCXByaXZhdGUgZmluYWwgU3RyaW5nIGVsZW1lbnRUeXBlTmFtZTsKLQotCS8qKgotCSAqIG5vbi1hcnJheSB0eXBlcyBoYXZlIGFuIGFycmF5IGRlcHRoIG9mIHplcm8KLQkgKi8KLQlwcml2YXRlIGZpbmFsIGludCBhcnJheURlcHRoOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEJSQUNLRVRTID0gIltdIjsgLy8kTk9OLU5MUy0xJAotCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDFMOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBKYXZhIHR5cGUgd2l0aCB0aGUgc3BlY2lmaWVkIGVsZW1lbnQgdHlwZSBhbmQgYXJyYXkgZGVwdGguCi0JICovCi0JcHVibGljIFNpbXBsZUphdmFUeXBlKFN0cmluZyBlbGVtZW50VHlwZU5hbWUsIGludCBhcnJheURlcHRoKSB7Ci0JCXN1cGVyKCk7Ci0JCWlmICgoZWxlbWVudFR5cGVOYW1lID09IG51bGwpIHx8IChlbGVtZW50VHlwZU5hbWUubGVuZ3RoKCkgPT0gMCkpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oIlRoZSBlbGVtZW50IHR5cGUgbmFtZSBpcyByZXF1aXJlZC4iKTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCWlmIChDbGFzc1Rvb2xzLmFycmF5RGVwdGhGb3JDbGFzc05hbWVkKGVsZW1lbnRUeXBlTmFtZSkgIT0gMCkgewkJLy8gZS5nLiAiW0xqYXZhLmxhbmcuT2JqZWN0OyIKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oIlRoZSBlbGVtZW50IHR5cGUgbXVzdCBub3QgYmUgYW4gYXJyYXk6ICIgKyBlbGVtZW50VHlwZU5hbWUgKyAnLicpOyAvLyROT04tTkxTLTEkCi0JCX0KLQkJaWYgKGFycmF5RGVwdGggPCAwKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJUaGUgYXJyYXkgZGVwdGggbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gemVybzogIiArIGFycmF5RGVwdGggKyAnLicpOyAvLyROT04tTkxTLTEkCi0JCX0KLQkJaWYgKGVsZW1lbnRUeXBlTmFtZS5lcXVhbHModm9pZC5jbGFzcy5nZXROYW1lKCkpICYmIChhcnJheURlcHRoICE9IDApKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCIndm9pZCcgbXVzdCBoYXZlIGFuIGFycmF5IGRlcHRoIG9mIHplcm86ICIgKyBhcnJheURlcHRoICsgJy4nKTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCXRoaXMuZWxlbWVudFR5cGVOYW1lID0gZWxlbWVudFR5cGVOYW1lOwotCQl0aGlzLmFycmF5RGVwdGggPSBhcnJheURlcHRoOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIEphdmEgdHlwZSBmb3IgdGhlIHNwZWNpZmllZCBjbGFzcy4KLQkgKiBUaGUgY2xhc3MgbmFtZSBjYW4gYmUgaW4gb25lIG9mIHRoZSBmb2xsb3dpbmcgZm9ybXM6Ci0JICogICAgIGphdmEubGFuZy5PYmplY3QKLQkgKiAgICAgaW50Ci0JICogICAgIGphdmEudXRpbC5NYXAkRW50cnkKLQkgKiAgICAgW0xqYXZhLmxhbmcuT2JqZWN0OwotCSAqICAgICBbSQotCSAqICAgICBbTGphdmEudXRpbC5NYXAkRW50cnk7Ci0JICovCi0JcHVibGljIFNpbXBsZUphdmFUeXBlKFN0cmluZyBqYXZhQ2xhc3NOYW1lKSB7Ci0JCXRoaXMoQ2xhc3NUb29scy5lbGVtZW50VHlwZU5hbWVGb3JDbGFzc05hbWVkKGphdmFDbGFzc05hbWUpLCBDbGFzc1Rvb2xzLmFycmF5RGVwdGhGb3JDbGFzc05hbWVkKGphdmFDbGFzc05hbWUpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBKYXZhIHR5cGUgZm9yIHRoZSBzcGVjaWZpZWQgY2xhc3MuCi0JICovCi0JcHVibGljIFNpbXBsZUphdmFUeXBlKENsYXNzPD8+IGphdmFDbGFzcykgewotCQl0aGlzKGphdmFDbGFzcy5nZXROYW1lKCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBhY2Nlc3NvcnMgKioqKioqKioqKgotCi0JcHVibGljIFN0cmluZyBnZXRFbGVtZW50VHlwZU5hbWUoKSB7Ci0JCXJldHVybiB0aGlzLmVsZW1lbnRUeXBlTmFtZTsKLQl9Ci0KLQlwdWJsaWMgaW50IGdldEFycmF5RGVwdGgoKSB7Ci0JCXJldHVybiB0aGlzLmFycmF5RGVwdGg7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHF1ZXJpZXMgKioqKioqKioqKgotCi0JcHVibGljIGJvb2xlYW4gaXNBcnJheSgpIHsKLQkJcmV0dXJuIHRoaXMuYXJyYXlEZXB0aCA+IDA7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaXNQcmltaXRpdmUoKSB7Ci0JCXJldHVybiAodGhpcy5hcnJheURlcHRoID09IDApICYmIENsYXNzVG9vbHMuY2xhc3NOYW1lZElzUHJpbWl0aXZlKHRoaXMuZWxlbWVudFR5cGVOYW1lKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBpc1ByaW1pdGl2ZVdyYXBwZXIoKSB7Ci0JCXJldHVybiAodGhpcy5hcnJheURlcHRoID09IDApICYmIENsYXNzVG9vbHMuY2xhc3NOYW1lZElzUHJpbWl0aXZlV3JhcHBlckNsYXNzKHRoaXMuZWxlbWVudFR5cGVOYW1lKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBpc1ZhcmlhYmxlUHJpbWl0aXZlKCkgewotCQlyZXR1cm4gKHRoaXMuYXJyYXlEZXB0aCA9PSAwKSAmJiBDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc1ZhcmlhYmxlUHJpbWl0aXZlKHRoaXMuZWxlbWVudFR5cGVOYW1lKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBpc1ZhcmlhYmxlUHJpbWl0aXZlV3JhcHBlcigpIHsKLQkJcmV0dXJuICh0aGlzLmFycmF5RGVwdGggPT0gMCkgJiYgQ2xhc3NUb29scy5jbGFzc05hbWVkSXNWYXJpYWJsZVByaW1pdGl2ZVdyYXBwZXJDbGFzcyh0aGlzLmVsZW1lbnRUeXBlTmFtZSk7Ci0JfQotCi0JcHVibGljIENsYXNzPD8+IGdldEphdmFDbGFzcygpIHRocm93cyBDbGFzc05vdEZvdW5kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIENsYXNzVG9vbHMuY2xhc3NGb3JUeXBlRGVjbGFyYXRpb24odGhpcy5lbGVtZW50VHlwZU5hbWUsIHRoaXMuYXJyYXlEZXB0aCk7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXRKYXZhQ2xhc3NOYW1lKCkgewotCQlyZXR1cm4gQ2xhc3NUb29scy5jbGFzc05hbWVGb3JUeXBlRGVjbGFyYXRpb24odGhpcy5lbGVtZW50VHlwZU5hbWUsIHRoaXMuYXJyYXlEZXB0aCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbXBhcmlzb24gKioqKioqKioqKgotCi0JcHVibGljIGJvb2xlYW4gZXF1YWxzKFN0cmluZyBvdGhlckVsZW1lbnRUeXBlTmFtZSwgaW50IG90aGVyQXJyYXlEZXB0aCkgewotCQlyZXR1cm4gKHRoaXMuYXJyYXlEZXB0aCA9PSBvdGhlckFycmF5RGVwdGgpCi0JCQkmJiB0aGlzLmVsZW1lbnRUeXBlTmFtZS5lcXVhbHMob3RoZXJFbGVtZW50VHlwZU5hbWUpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGRlc2NyaWJlcyhTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCXJldHVybiB0aGlzLmVxdWFscyhDbGFzc1Rvb2xzLmVsZW1lbnRUeXBlTmFtZUZvckNsYXNzTmFtZWQoY2xhc3NOYW1lKSwgQ2xhc3NUb29scy5hcnJheURlcHRoRm9yQ2xhc3NOYW1lZChjbGFzc05hbWUpKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBkZXNjcmliZXMoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCXJldHVybiB0aGlzLmRlc2NyaWJlcyhqYXZhQ2xhc3MuZ2V0TmFtZSgpKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBlcXVhbHMoSmF2YVR5cGUgb3RoZXIpIHsKLQkJcmV0dXJuIHRoaXMuZXF1YWxzKG90aGVyLmdldEVsZW1lbnRUeXBlTmFtZSgpLCBvdGhlci5nZXRBcnJheURlcHRoKCkpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBib29sZWFuIGVxdWFscyhPYmplY3QgbykgewotCQlyZXR1cm4gKHRoaXMgPT0gbykgPyB0cnVlIDogKG8gaW5zdGFuY2VvZiBKYXZhVHlwZSkgPyB0aGlzLmVxdWFscygoSmF2YVR5cGUpIG8pIDogZmFsc2U7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIGludCBoYXNoQ29kZSgpIHsKLQkJcmV0dXJuIHRoaXMuZWxlbWVudFR5cGVOYW1lLmhhc2hDb2RlKCkgXiB0aGlzLmFycmF5RGVwdGg7Ci0JfQotCi0JcHVibGljIGludCBjb21wYXJlVG8oSmF2YVR5cGUganQpIHsKLQkJaW50IHggPSBDb2xsYXRvci5nZXRJbnN0YW5jZSgpLmNvbXBhcmUodGhpcy5lbGVtZW50VHlwZU5hbWUsIGp0LmdldEVsZW1lbnRUeXBlTmFtZSgpKTsKLQkJcmV0dXJuICh4ICE9IDApID8geCA6ICh0aGlzLmFycmF5RGVwdGggLSBqdC5nZXRBcnJheURlcHRoKCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBwcmludGluZyBhbmQgZGlzcGxheWluZyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHZlcnNpb24gb2YgdGhlIHR5cGUncyBuYW1lIHRoYXQgY2FuIGJlIHVzZWQgaW4gc291cmNlIGNvZGU6Ci0JICogICAgICJbW0oiID0+ICJsb25nW11bXSIKLQkgKiAgICAgImphdmEudXRpbC5NYXAkRW50cnkiID0+ICJqYXZhLnV0aWwuTWFwLkVudHJ5IgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZGVjbGFyYXRpb24oKSB7Ci0JCWlmICh0aGlzLmFycmF5RGVwdGggPT0gMCkgewotCQkJcmV0dXJuIHRoaXMuZ2V0RWxlbWVudFR5cGVOYW1lRGVjbGFyYXRpb24oKTsKLQkJfQotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIodGhpcy5lbGVtZW50VHlwZU5hbWUubGVuZ3RoKCkgKyAoMiAqIHRoaXMuYXJyYXlEZXB0aCkpOwotCQl0aGlzLmFwcGVuZERlY2xhcmF0aW9uVG8oc2IpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQkvKioKLQkgKiBBcHBlbmQgdGhlIHZlcnNpb24gb2YgdGhlIHR5cGUncyBuYW1lIHRoYXQgY2FuIGJlIHVzZWQgaW4gc291cmNlIGNvZGU6Ci0JICogICAgICJbW0oiID0+ICJsb25nW11bXSIKLQkgKiAgICAgImphdmEudXRpbC5NYXAkRW50cnkiID0+ICJqYXZhLnV0aWwuTWFwLkVudHJ5IgotCSAqLwotCXB1YmxpYyB2b2lkIGFwcGVuZERlY2xhcmF0aW9uVG8oU3RyaW5nQnVpbGRlciBzYikgewotCQlzYi5hcHBlbmQodGhpcy5nZXRFbGVtZW50VHlwZU5hbWVEZWNsYXJhdGlvbigpKTsKLQkJZm9yIChpbnQgaSA9IHRoaXMuYXJyYXlEZXB0aDsgaS0tID4gMDsgKSB7Ci0JCQlzYi5hcHBlbmQoQlJBQ0tFVFMpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUHJpbnQgdGhlIHZlcnNpb24gb2YgdGhlIHR5cGUncyBuYW1lIHRoYXQgY2FuIGJlIHVzZWQgaW4gc291cmNlIGNvZGU6Ci0JICogICAgICJbW0oiID0+ICJsb25nW11bXSIKLQkgKiAgICAgImphdmEudXRpbC5NYXAkRW50cnkiID0+ICJqYXZhLnV0aWwuTWFwLkVudHJ5IgotCSAqLwotCXB1YmxpYyB2b2lkIHByaW50RGVjbGFyYXRpb25PbihQcmludFdyaXRlciBwdykgewotCQlwdy5wcmludCh0aGlzLmdldEVsZW1lbnRUeXBlTmFtZURlY2xhcmF0aW9uKCkpOwotCQlmb3IgKGludCBpID0gdGhpcy5hcnJheURlcHRoOyBpLS0gPiAwOyApIHsKLQkJCXB3LnByaW50KEJSQUNLRVRTKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFRoZSAnJCcgdmVyc2lvbiBvZiB0aGUgbmFtZSBpcyB1c2VkIGluIENsYXNzLmZvck5hbWUoU3RyaW5nKSwKLQkgKiBidXQgdGhlICcuJyB2ZXJzaW9uIG9mIHRoZSBuYW1lIGlzIHVzZWQgaW4gc291cmNlIGNvZGUuCi0JICogVmVyeSBpcnJpdGF0aW5nLi4uLgotCSAqLwotCXByaXZhdGUgU3RyaW5nIGdldEVsZW1lbnRUeXBlTmFtZURlY2xhcmF0aW9uKCkgewotCQlyZXR1cm4gdGhpcy5lbGVtZW50VHlwZU5hbWUucmVwbGFjZSgnJCcsICcuJyk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7Ci0JCXNiLmFwcGVuZChDbGFzc1Rvb2xzLnNob3J0Q2xhc3NOYW1lRm9yT2JqZWN0KHRoaXMpKTsKLQkJc2IuYXBwZW5kKCcoJyk7Ci0JCXRoaXMuYXBwZW5kRGVjbGFyYXRpb25UbyhzYik7Ci0JCXNiLmFwcGVuZCgnKScpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY2xvbmluZyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgT2JqZWN0IGNsb25lKCkgewotCQl0cnkgewotCQkJcmV0dXJuIHN1cGVyLmNsb25lKCk7Ci0JCX0gY2F0Y2ggKENsb25lTm90U3VwcG9ydGVkRXhjZXB0aW9uIGV4KSB7Ci0JCQl0aHJvdyBuZXcgSW50ZXJuYWxFcnJvcigpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU2ltcGxlTWV0aG9kU2lnbmF0dXJlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU2ltcGxlTWV0aG9kU2lnbmF0dXJlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGEwMjg5MTMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1NpbXBsZU1ldGhvZFNpZ25hdHVyZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjU5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLmlvLlByaW50V3JpdGVyOwotaW1wb3J0IGphdmEuaW8uU2VyaWFsaXphYmxlOwotaW1wb3J0IGphdmEubGFuZy5yZWZsZWN0Lk1ldGhvZDsKLWltcG9ydCBqYXZhLnRleHQuQ29sbGF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkFycmF5czsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5KYXZhVHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5NZXRob2RTaWduYXR1cmU7Ci0KLS8qKgotICogU3RyYWlnaHRmb3J3YXJkIGltcGxlbWVudGF0aW9uIG9mIHRoZSBNZXRob2RTaWduYXR1cmUgaW50ZXJmYWNlLgotICovCi1wdWJsaWMgZmluYWwgY2xhc3MgU2ltcGxlTWV0aG9kU2lnbmF0dXJlCi0JaW1wbGVtZW50cyBNZXRob2RTaWduYXR1cmUsIENsb25lYWJsZSwgU2VyaWFsaXphYmxlCi17Ci0JcHJpdmF0ZSBmaW5hbCBTdHJpbmcgbmFtZTsKLQotCS8qKgotCSAqIHN0b3JlIHRoZSBwYXJhbWV0ZXIgdHlwZXMgYXMgbmFtZXMsIHNvIHdlIGNhbiByZWZlcmVuY2UgY2xhc3NlcwotCSAqIHRoYXQgYXJlIG5vdCBsb2FkZWQKLQkgKi8KLQlwcml2YXRlIGZpbmFsIEphdmFUeXBlW10gcGFyYW1ldGVyVHlwZXM7Ci0KLQlwdWJsaWMgc3RhdGljIGZpbmFsIEphdmFUeXBlW10gRU1QVFlfUEFSQU1FVEVSX1RZUEVTID0gbmV3IEphdmFUeXBlWzBdOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIFBBUkFNRVRFUl9TRVBBUkFUT1IgPSAiLCAiOyAvLyROT04tTkxTLTEkCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIG1ldGhvZCBzaWduYXR1cmUgd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUgYW5kCi0JICogbm8gcGFyYW1ldGVyIHR5cGVzLgotCSAqLwotCXB1YmxpYyBTaW1wbGVNZXRob2RTaWduYXR1cmUoU3RyaW5nIG5hbWUpIHsKLQkJdGhpcyhuYW1lLCBFTVBUWV9QQVJBTUVURVJfVFlQRVMpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIG1ldGhvZCBzaWduYXR1cmUgd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUgYW5kIHBhcmFtZXRlcgotCSAqIHR5cGVzLgotCSAqLwotCXB1YmxpYyBTaW1wbGVNZXRob2RTaWduYXR1cmUoU3RyaW5nIG5hbWUsIEphdmFUeXBlLi4uIHBhcmFtZXRlclR5cGVzKSB7Ci0JCXN1cGVyKCk7Ci0JCWlmICgobmFtZSA9PSBudWxsKSB8fCAobmFtZS5sZW5ndGgoKSA9PSAwKSkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiVGhlIG5hbWUgaXMgcmVxdWlyZWQuIik7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQlpZiAocGFyYW1ldGVyVHlwZXMgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiVGhlIHBhcmFtZXRlciB0eXBlcyBhcmUgcmVxdWlyZWQuIik7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQljaGVja1BhcmFtZXRlclR5cGVzKHBhcmFtZXRlclR5cGVzKTsKLQkJdGhpcy5uYW1lID0gbmFtZTsKLQkJdGhpcy5wYXJhbWV0ZXJUeXBlcyA9IHBhcmFtZXRlclR5cGVzOwotCX0KLQotCXByaXZhdGUgc3RhdGljIHZvaWQgY2hlY2tQYXJhbWV0ZXJUeXBlcyhKYXZhVHlwZVtdIHBhcmFtZXRlclR5cGVzKSB7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgcGFyYW1ldGVyVHlwZXMubGVuZ3RoOyBpKyspIHsKLQkJCWlmIChwYXJhbWV0ZXJUeXBlc1tpXSA9PSBudWxsKSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiTWlzc2luZyBwYXJhbWV0ZXIgdHlwZTogIiArIGkpOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCQlpZiAocGFyYW1ldGVyVHlwZXNbaV0uZ2V0RWxlbWVudFR5cGVOYW1lKCkuZXF1YWxzKHZvaWQuY2xhc3MuZ2V0TmFtZSgpKSkgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oIkEgcGFyYW1ldGVyIHR5cGUgb2YgJ3ZvaWQnIGlzIG5vdCBhbGxvd2VkOiAiICsgaSk7IC8vJE5PTi1OTFMtMSQKLQkJCX0KLQkJfQotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIG1ldGhvZCBzaWduYXR1cmUgd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUgYW5kIHBhcmFtZXRlcgotCSAqIHR5cGVzLgotCSAqLwotCXB1YmxpYyBTaW1wbGVNZXRob2RTaWduYXR1cmUoU3RyaW5nIG5hbWUsIFN0cmluZy4uLiBwYXJhbWV0ZXJUeXBlTmFtZXMpIHsKLQkJdGhpcyhuYW1lLCBidWlsZFBhcmFtZXRlclR5cGVzKHBhcmFtZXRlclR5cGVOYW1lcykpOwotCX0KLQotCXByaXZhdGUgc3RhdGljIEphdmFUeXBlW10gYnVpbGRQYXJhbWV0ZXJUeXBlcyhTdHJpbmdbXSBwYXJhbWV0ZXJUeXBlTmFtZXMpIHsKLQkJaWYgKHBhcmFtZXRlclR5cGVOYW1lcyA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJUaGUgcGFyYW1ldGVyIHR5cGUgbmFtZXMgYXJlIHJlcXVpcmVkLiIpOyAvLyROT04tTkxTLTEkCi0JCX0KLQkJSmF2YVR5cGVbXSBwYXJhbWV0ZXJUeXBlcyA9IG5ldyBKYXZhVHlwZVtwYXJhbWV0ZXJUeXBlTmFtZXMubGVuZ3RoXTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBwYXJhbWV0ZXJUeXBlTmFtZXMubGVuZ3RoOyBpKyspIHsKLQkJCWlmIChwYXJhbWV0ZXJUeXBlTmFtZXNbaV0gPT0gbnVsbCkgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oIk1pc3NpbmcgcGFyYW1ldGVyIHR5cGUgbmFtZTogIiArIGkpOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCQlwYXJhbWV0ZXJUeXBlc1tpXSA9IG5ldyBTaW1wbGVKYXZhVHlwZShwYXJhbWV0ZXJUeXBlTmFtZXNbaV0pOwotCQl9Ci0JCXJldHVybiBwYXJhbWV0ZXJUeXBlczsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBtZXRob2Qgc2lnbmF0dXJlIHdpdGggdGhlIHNwZWNpZmllZCBuYW1lIGFuZCBwYXJhbWV0ZXIKLQkgKiB0eXBlcy4KLQkgKi8KLQlwdWJsaWMgU2ltcGxlTWV0aG9kU2lnbmF0dXJlKFN0cmluZyBuYW1lLCBDbGFzczw/Pi4uLiBwYXJhbWV0ZXJKYXZhQ2xhc3NlcykgewotCQl0aGlzKG5hbWUsIGJ1aWxkUGFyYW1ldGVyVHlwZU5hbWVzKHBhcmFtZXRlckphdmFDbGFzc2VzKSk7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgU3RyaW5nW10gYnVpbGRQYXJhbWV0ZXJUeXBlTmFtZXMoQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJKYXZhQ2xhc3NlcykgewotCQlpZiAocGFyYW1ldGVySmF2YUNsYXNzZXMgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiVGhlIHBhcmFtZXRlciBKYXZhIGNsYXNzZXMgYXJlIHJlcXVpcmVkLiIpOyAvLyROT04tTkxTLTEkCi0JCX0KLQkJU3RyaW5nW10gcGFyYW1ldGVyVHlwZU5hbWVzID0gbmV3IFN0cmluZ1twYXJhbWV0ZXJKYXZhQ2xhc3Nlcy5sZW5ndGhdOwotCQlmb3IgKGludCBpID0gMDsgaSA8IHBhcmFtZXRlckphdmFDbGFzc2VzLmxlbmd0aDsgaSsrKSB7Ci0JCQlpZiAocGFyYW1ldGVySmF2YUNsYXNzZXNbaV0gPT0gbnVsbCkgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oIk1pc3NpbmcgcGFyYW1ldGVyIEphdmEgY2xhc3M6ICIgKyBpKTsgLy8kTk9OLU5MUy0xJAotCQkJfQotCQkJcGFyYW1ldGVyVHlwZU5hbWVzW2ldID0gcGFyYW1ldGVySmF2YUNsYXNzZXNbaV0uZ2V0TmFtZSgpOwotCQl9Ci0JCXJldHVybiBwYXJhbWV0ZXJUeXBlTmFtZXM7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgbWV0aG9kIHNpZ25hdHVyZSBmb3IgdGhlIHNwZWNpZmllZCBKYXZhIG1ldGhvZC4KLQkgKi8KLQlwdWJsaWMgU2ltcGxlTWV0aG9kU2lnbmF0dXJlKE1ldGhvZCBtZXRob2QpIHsKLQkJdGhpcyhtZXRob2QuZ2V0TmFtZSgpLCBtZXRob2QuZ2V0UGFyYW1ldGVyVHlwZXMoKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGFjY2Vzc29ycyAqKioqKioqKioqCi0KLQlwdWJsaWMgU3RyaW5nIGdldE5hbWUoKSB7Ci0JCXJldHVybiB0aGlzLm5hbWU7Ci0JfQotCi0JcHVibGljIEphdmFUeXBlW10gZ2V0UGFyYW1ldGVyVHlwZXMoKSB7Ci0JCXJldHVybiB0aGlzLnBhcmFtZXRlclR5cGVzOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBjb21wYXJpc29uICoqKioqKioqKioKLQotCXB1YmxpYyBib29sZWFuIGRlc2NyaWJlcyhNZXRob2QgbWV0aG9kKSB7Ci0JCXJldHVybiB0aGlzLm5hbWUuZXF1YWxzKG1ldGhvZC5nZXROYW1lKCkpCi0JCQkJJiYgdGhpcy5wYXJhbWV0ZXJUeXBlc0Rlc2NyaWJlKG1ldGhvZC5nZXRQYXJhbWV0ZXJUeXBlcygpKTsKLQl9Ci0KLQlwcml2YXRlIGJvb2xlYW4gcGFyYW1ldGVyVHlwZXNEZXNjcmliZShDbGFzczw/PltdIG90aGVyUGFyYW1ldGVyVHlwZXMpIHsKLQkJSmF2YVR5cGVbXSBsb2NhbFBhcmFtZXRlclR5cGVzID0gdGhpcy5wYXJhbWV0ZXJUeXBlczsKLQkJaW50IGxlbiA9IGxvY2FsUGFyYW1ldGVyVHlwZXMubGVuZ3RoOwotCQlpZiAob3RoZXJQYXJhbWV0ZXJUeXBlcy5sZW5ndGggIT0gbGVuKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJZm9yIChpbnQgaSA9IGxlbjsgaS0tID4gMDsgKSB7Ci0JCQlpZiAoICEgbG9jYWxQYXJhbWV0ZXJUeXBlc1tpXS5kZXNjcmliZXMob3RoZXJQYXJhbWV0ZXJUeXBlc1tpXSkpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCX0KLSAgICAgICAgcmV0dXJuIHRydWU7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gZXF1YWxzKFN0cmluZyBvdGhlck5hbWUsIEphdmFUeXBlW10gb3RoZXJQYXJhbWV0ZXJUeXBlcykgewotCQlyZXR1cm4gdGhpcy5uYW1lLmVxdWFscyhvdGhlck5hbWUpCi0JCQkJJiYgQXJyYXlzLmVxdWFscyh0aGlzLnBhcmFtZXRlclR5cGVzLCBvdGhlclBhcmFtZXRlclR5cGVzKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBlcXVhbHMoTWV0aG9kU2lnbmF0dXJlIG90aGVyKSB7Ci0JCXJldHVybiB0aGlzLmVxdWFscyhvdGhlci5nZXROYW1lKCksIG90aGVyLmdldFBhcmFtZXRlclR5cGVzKCkpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBib29sZWFuIGVxdWFscyhPYmplY3QgbykgewotCQlyZXR1cm4gKHRoaXMgPT0gbykgPyB0cnVlIDogKG8gaW5zdGFuY2VvZiBNZXRob2RTaWduYXR1cmUpID8gdGhpcy5lcXVhbHMoKE1ldGhvZFNpZ25hdHVyZSkgbykgOiBmYWxzZTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgaW50IGhhc2hDb2RlKCkgewotCQlyZXR1cm4gdGhpcy5uYW1lLmhhc2hDb2RlKCkgXiBBcnJheXMuaGFzaENvZGUodGhpcy5wYXJhbWV0ZXJUeXBlcyk7Ci0JfQotCi0JcHVibGljIGludCBjb21wYXJlVG8oTWV0aG9kU2lnbmF0dXJlIG1zKSB7Ci0JCWludCBjb21wYXJlID0gQ29sbGF0b3IuZ2V0SW5zdGFuY2UoKS5jb21wYXJlKHRoaXMubmFtZSwgbXMuZ2V0TmFtZSgpKTsKLQkJcmV0dXJuIChjb21wYXJlICE9IDApID8gY29tcGFyZSA6IHRoaXMuY29tcGFyZVBhcmFtZXRlclR5cGVzKG1zLmdldFBhcmFtZXRlclR5cGVzKCkpOwotCX0KLQotCXByaXZhdGUgaW50IGNvbXBhcmVQYXJhbWV0ZXJUeXBlcyhKYXZhVHlwZVtdIG90aGVyUGFyYW1ldGVyVHlwZXMpIHsKLQkJSmF2YVR5cGVbXSBsb2NhbFBhcmFtZXRlclR5cGVzID0gdGhpcy5wYXJhbWV0ZXJUeXBlczsKLQkJaW50IGxlbjEgPSBsb2NhbFBhcmFtZXRlclR5cGVzLmxlbmd0aDsKLQkJaW50IGxlbjIgPSBvdGhlclBhcmFtZXRlclR5cGVzLmxlbmd0aDsKLQkJaW50IG1pbiA9IE1hdGgubWluKGxlbjEsIGxlbjIpOwotCQlmb3IgKGludCBpID0gMDsgaSA8IG1pbjsgaSsrKSB7Ci0JCQlpbnQgY29tcGFyZSA9IGxvY2FsUGFyYW1ldGVyVHlwZXNbaV0uY29tcGFyZVRvKG90aGVyUGFyYW1ldGVyVHlwZXNbaV0pOwotCQkJaWYgKGNvbXBhcmUgIT0gMCkgewotCQkJCXJldHVybiBjb21wYXJlOwotCQkJfQotCQl9Ci0JCXJldHVybiAobGVuMSA9PSBsZW4yKSA/IDAgOiAobGVuMSA8IGxlbjIpID8gLTEgOiAxOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBwcmludGluZyBhbmQgZGlzcGxheWluZyAqKioqKioqKioqCi0KLQlwdWJsaWMgU3RyaW5nIGdldFNpZ25hdHVyZSgpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXRoaXMuYXBwZW5kU2lnbmF0dXJlVG8oc2IpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBhcHBlbmRTaWduYXR1cmVUbyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXNiLmFwcGVuZCh0aGlzLm5hbWUpOwotCQlzYi5hcHBlbmQoJygnKTsKLQkJSmF2YVR5cGVbXSBsb2NhbFBhcmFtZXRlclR5cGVzID0gdGhpcy5wYXJhbWV0ZXJUeXBlczsKLQkJaW50IGxlbiA9IGxvY2FsUGFyYW1ldGVyVHlwZXMubGVuZ3RoOwotCQlmb3IgKGludCBpID0gMDsgaSA8IGxlbjsgaSsrKSB7Ci0JCQlpZiAoaSAhPSAwKSB7Ci0JCQkJc2IuYXBwZW5kKFBBUkFNRVRFUl9TRVBBUkFUT1IpOwotCQkJfQotCQkJbG9jYWxQYXJhbWV0ZXJUeXBlc1tpXS5hcHBlbmREZWNsYXJhdGlvblRvKHNiKTsKLQkJfQotCQlzYi5hcHBlbmQoJyknKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBwcmludFNpZ25hdHVyZU9uKFByaW50V3JpdGVyIHB3KSB7Ci0JCXB3LnByaW50KHRoaXMubmFtZSk7Ci0JCXB3LnByaW50KCcoJyk7Ci0JCUphdmFUeXBlW10gbG9jYWxQYXJhbWV0ZXJUeXBlcyA9IHRoaXMucGFyYW1ldGVyVHlwZXM7Ci0JCWludCBsZW4gPSBsb2NhbFBhcmFtZXRlclR5cGVzLmxlbmd0aDsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsZW47IGkrKykgewotCQkJaWYgKGkgIT0gMCkgewotCQkJCXB3LnByaW50KFBBUkFNRVRFUl9TRVBBUkFUT1IpOwotCQkJfQotCQkJbG9jYWxQYXJhbWV0ZXJUeXBlc1tpXS5wcmludERlY2xhcmF0aW9uT24ocHcpOwotCQl9Ci0JCXB3LnByaW50KCcpJyk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXNiLmFwcGVuZChDbGFzc1Rvb2xzLnNob3J0Q2xhc3NOYW1lRm9yT2JqZWN0KHRoaXMpKTsKLQkJc2IuYXBwZW5kKCcoJyk7Ci0JCXRoaXMuYXBwZW5kU2lnbmF0dXJlVG8oc2IpOwotCQlzYi5hcHBlbmQoJyknKTsKLQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNsb25pbmcgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHVibGljIE9iamVjdCBjbG9uZSgpIHsKLQkJdHJ5IHsKLQkJCXJldHVybiBzdXBlci5jbG9uZSgpOwotCQl9IGNhdGNoIChDbG9uZU5vdFN1cHBvcnRlZEV4Y2VwdGlvbiBleCkgewotCQkJdGhyb3cgbmV3IEludGVybmFsRXJyb3IoKTsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1NpbXBsZVN0YWNrLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU2ltcGxlU3RhY2suamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjE4Mzk0My4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU2ltcGxlU3RhY2suamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDk1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLmlvLlNlcmlhbGl6YWJsZTsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuRW1wdHlTdGFja0V4Y2VwdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuTGlua2VkTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTm9TdWNoRWxlbWVudEV4Y2VwdGlvbjsKLQotLyoqCi0gKiBTdHJhaWdodGZvcndhcmQgaW1wbGVtZW50YXRpb24gb2YgdGhlIFN0YWNrIGludGVyZmFjZS4KLSAqLwotcHVibGljIGNsYXNzIFNpbXBsZVN0YWNrPEU+Ci0JaW1wbGVtZW50cyBTdGFjazxFPiwgQ2xvbmVhYmxlLCBTZXJpYWxpemFibGUKLXsKLQlwcml2YXRlIExpbmtlZExpc3Q8RT4gZWxlbWVudHM7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGVtcHR5IHN0YWNrLgotCSAqLwotCXB1YmxpYyBTaW1wbGVTdGFjaygpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5lbGVtZW50cyA9IG5ldyBMaW5rZWRMaXN0PEU+KCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgc3RhY2sgY29udGFpbmluZyB0aGUgZWxlbWVudHMgb2YgdGhlIHNwZWNpZmllZAotCSAqIGNvbGxlY3Rpb24uIFRoZSBzdGFjayB3aWxsIHBvcCBpdHMgZWxlbWVudHMgaW4gcmV2ZXJzZSBvZiB0aGUKLQkgKiBvcmRlciB0aGV5IGFyZSByZXR1cm5lZCBieSB0aGUgY29sbGVjdGlvbidzIGl0ZXJhdG9yIChpLmUuIHRoZQotCSAqIGxhc3QgZWxlbWVudCByZXR1cm5lZCBieSB0aGUgY29sbGVjdGlvbidzIGl0ZXJhdG9yIHdpbGwgYmUgdGhlCi0JICogZmlyc3QgZWxlbWVudCByZXR1cm5lZCBieSAjcG9wKCkpLgotCSAqLwotCXB1YmxpYyBTaW1wbGVTdGFjayhDb2xsZWN0aW9uPD8gZXh0ZW5kcyBFPiBjKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuZWxlbWVudHMgPSBuZXcgTGlua2VkTGlzdDxFPihjKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogU3RhY2sgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIHZvaWQgcHVzaChFIG8pIHsKLQkJdGhpcy5lbGVtZW50cy5hZGRMYXN0KG8pOwotCX0KLQotCXB1YmxpYyBFIHBvcCgpIHsKLQkJdHJ5IHsKLQkJCXJldHVybiB0aGlzLmVsZW1lbnRzLnJlbW92ZUxhc3QoKTsKLQkJfSBjYXRjaCAoTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBleCkgewotCQkJdGhyb3cgbmV3IEVtcHR5U3RhY2tFeGNlcHRpb24oKTsKLQkJfQotCX0KLQotCXB1YmxpYyBFIHBlZWsoKSB7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gdGhpcy5lbGVtZW50cy5nZXRMYXN0KCk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCXRocm93IG5ldyBFbXB0eVN0YWNrRXhjZXB0aW9uKCk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBpc0VtcHR5KCkgewotCQlyZXR1cm4gdGhpcy5lbGVtZW50cy5pc0VtcHR5KCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIENsb25lYWJsZSBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU2ltcGxlU3RhY2s8RT4gY2xvbmUoKSB7Ci0JCXRyeSB7Ci0JCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJCVNpbXBsZVN0YWNrPEU+IGNsb25lID0gKFNpbXBsZVN0YWNrPEU+KSBzdXBlci5jbG9uZSgpOwotCQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCQlMaW5rZWRMaXN0PEU+IGxsID0gKExpbmtlZExpc3Q8RT4pIHRoaXMuZWxlbWVudHMuY2xvbmUoKTsKLQkJCWNsb25lLmVsZW1lbnRzID0gbGw7Ci0JCQlyZXR1cm4gY2xvbmU7Ci0JCX0gY2F0Y2ggKENsb25lTm90U3VwcG9ydGVkRXhjZXB0aW9uIGV4KSB7Ci0JCQl0aHJvdyBuZXcgSW50ZXJuYWxFcnJvcigpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU2ltcGxlU3RyaW5nTWF0Y2hlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1NpbXBsZVN0cmluZ01hdGNoZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzZjOTY3Ni4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU2ltcGxlU3RyaW5nTWF0Y2hlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjU5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLmlvLlNlcmlhbGl6YWJsZTsKLWltcG9ydCBqYXZhLnV0aWwucmVnZXguUGF0dGVybjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5GaWx0ZXI7Ci0KLS8vIFRPRE8gdGhlIHJlZ2V4IGNvZGUgaXMgbm90IHZlcnkgZmFzdCAtIHdlIGNvdWxkIHByb2JhYmx5IGRvIGJldHRlciwKLS8vIGhhbmQtY29kaW5nIHRoZSBtYXRjaGluZyBhbGdvcml0aG0gKGVjbGlwc2UgU3RyaW5nTWF0Y2hlcj8pCi0vKioKLSAqIFRoaXMgY2xhc3MgaW1wbGVtZW50cyBhIHNpbXBsZSBzdHJpbmctbWF0Y2hpbmcgYWxnb3JpdGhtIHRoYXQgaXMgYSBsaXR0bGUKLSAqIG1vcmUgdXNlci1mcmllbmRseSB0aGFuIHN0YW5kYXJkIHJlZ3VsYXIgZXhwcmVzc2lvbnMuIEluc3RhbnRpYXRlIGEKLSAqIHN0cmluZyBtYXRjaGVyIHdpdGggYSBmaWx0ZXIgcGF0dGVybiBhbmQgdGhlbiB5b3UgY2FuIHVzZSB0aGUgbWF0Y2hlcgotICogdG8gZGV0ZXJtaW5lIHdoZXRoZXIgYW5vdGhlciBzdHJpbmcgKG9yIG9iamVjdCkgbWF0Y2hlcyB0aGUgcGF0dGVybi4KLSAqIFlvdSBjYW4gYWxzbyBzcGVjaWZ5IHdoZXRoZXIgdGhlIG1hdGNoaW5nIHNob3VsZCBiZSBjYXNlLXNlbnNpdGl2ZS4KLSAqIAotICogVGhlIHBhdHRlcm4gY2FuIGNvbnRhaW4gdHdvICJtZXRhLWNoYXJhY3RlcnMiOgotICogCScqJyB3aWxsIG1hdGNoIGFueSBzZXQgb2YgemVybyBvciBtb3JlIGNoYXJhY3RlcnMKLSAqIAknPycgd2lsbCBtYXRjaCBhbnkgc2luZ2xlIGNoYXJhY3RlcgotICogCi0gKiBTdWJjbGFzc2VzIGNhbiBvdmVycmlkZSAjcHJlZml4KCkgYW5kL29yICNzdWZmaXgoKSB0byBjaGFuZ2Ugd2hhdAotICogc3RyaW5ncyBhcmUgcHJlcGVuZGVkIG9yIGFwcGVuZGVkIHRvIHRoZSBvcmlnaW5hbCBwYXR0ZXJuIHN0cmluZy4KLSAqIFRoaXMgY2FuIG9mZmVyIGEgc2xpZ2h0IHBlcmZvcm1hbmNlIGltcHJvdmVtZW50IG92ZXIgY29uY2F0ZW5hdGluZwotICogc3RyaW5ncyBiZWZvcmUgY2FsbGluZyAjc2V0UGF0dGVyblN0cmluZyhTdHJpbmcpLgotICogQnkgZGVmYXVsdCwgYSAnKicgaXMgYXBwZW5kZWQgdG8gZXZlcnkgc3RyaW5nLgotICogCi0gKiBUaGlzIGNsYXNzIGFsc28gdXNlcyB0aGUgc3RyaW5nLW1hdGNoaW5nIGFsZ29yaXRobSB0byAiZmlsdGVyIiBvYmplY3RzCi0gKiAoYW5kLCBhcyBhIHJlc3VsdCwgYWxzbyBpbXBsZW1lbnRzIHRoZSBGaWx0ZXIgaW50ZXJmYWNlKS4KLSAqIEEgc3RyaW5nIGNvbnZlcnRlciBpcyB1c2VkIHRvIGRldGVybWluZSB3aGF0IHN0cmluZyBhc3BlY3Qgb2YgdGhlCi0gKiBvYmplY3QgaXMgY29tcGFyZWQgdG8gdGhlIHBhdHRlcm4uIEJ5IGRlZmF1bHQgdGhlIHN0cmluZyByZXR1cm5lZAotICogYnkgdGhlIG9iamVjdCdzICN0b1N0cmluZygpIG1ldGhvZCBpcyBwYXNzZWQgdG8gdGhlIHBhdHRlcm4gbWF0Y2hlci4KLSAqLwotcHVibGljIGNsYXNzIFNpbXBsZVN0cmluZ01hdGNoZXI8VD4KLQlpbXBsZW1lbnRzIFN0cmluZ01hdGNoZXIsIEZpbHRlcjxUPiwgU2VyaWFsaXphYmxlCi17Ci0KLQkvKiogQW4gYWRhcHRlciB0aGF0IGNvbnZlcnRzIHRoZSBvYmplY3RzIGludG8gc3RyaW5ncyB0byBiZSBtYXRjaGVkIHdpdGggdGhlIHBhdHRlcm4uICovCi0JcHJpdmF0ZSBTdHJpbmdDb252ZXJ0ZXI8VD4gc3RyaW5nQ29udmVydGVyOwotCi0JLyoqIFRoZSBzdHJpbmcgdXNlZCB0byBjb25zdHJ1Y3QgdGhlIHJlZ3VsYXIgZXhwcmVzc2lvbiBwYXR0ZXJuLiAqLwotCXByaXZhdGUgU3RyaW5nIHBhdHRlcm5TdHJpbmc7Ci0KLQkvKiogV2hldGhlciB0aGUgbWF0Y2hlciBpZ25vcmVzIGNhc2UgLSB0aGUgZGVmYXVsdCBpcyB0cnVlLiAqLwotCXByaXZhdGUgYm9vbGVhbiBpZ25vcmVzQ2FzZTsKLQotCS8qKiBUaGUgcmVndWxhciBleHByZXNzaW9uIHBhdHRlcm4gYnVpbHQgZnJvbSB0aGUgcGF0dGVybiBzdHJpbmcuICovCi0JcHJpdmF0ZSBQYXR0ZXJuIHBhdHRlcm47Ci0KLQkvKiogQSBsaXN0IG9mIHRoZSBtZXRhLWNoYXJhY3RlcnMgd2UgbmVlZCB0byBlc2NhcGUgaWYgZm91bmQgaW4gdGhlIHBhdHRlcm4gc3RyaW5nLiAqLwotCXB1YmxpYyBzdGF0aWMgZmluYWwgY2hhcltdIFJFR19FWF9NRVRBX0NIQVJTID0geyAnKCcsICdbJywgJ3snLCAnXFwnLCAnXicsICckJywgJ3wnLCAnKScsICc/JywgJyonLCAnKycsICcuJyB9OwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHN0cmluZyBtYXRjaGVyIHdpdGggYW4gcGF0dGVybiB0aGF0IHdpbGwgbWF0Y2gKLQkgKiBhbnkgc3RyaW5nIGFuZCBpZ25vcmUgY2FzZS4KLQkgKi8KLQlwdWJsaWMgU2ltcGxlU3RyaW5nTWF0Y2hlcigpIHsKLQkJdGhpcygiKiIpOyAvLyROT04tTkxTLTEkCi0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgc3RyaW5nIG1hdGNoZXIgd2l0aCB0aGUgc3BlY2lmaWVkIHBhdHRlcm4KLQkgKiB0aGF0IHdpbGwgaWdub3JlIGNhc2UuCi0JICovCi0JcHVibGljIFNpbXBsZVN0cmluZ01hdGNoZXIoU3RyaW5nIHBhdHRlcm5TdHJpbmcpIHsKLQkJdGhpcyhwYXR0ZXJuU3RyaW5nLCB0cnVlKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBzdHJpbmcgbWF0Y2hlciB3aXRoIHRoZSBzcGVjaWZpZWQgcGF0dGVybiB0aGF0IHdpbGwKLQkgKiBpZ25vcmUgY2FzZSBhcyBzcGVjaWZpZWQuCi0JICovCi0JcHVibGljIFNpbXBsZVN0cmluZ01hdGNoZXIoU3RyaW5nIHBhdHRlcm5TdHJpbmcsIGJvb2xlYW4gaWdub3Jlc0Nhc2UpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5wYXR0ZXJuU3RyaW5nID0gcGF0dGVyblN0cmluZzsKLQkJdGhpcy5pZ25vcmVzQ2FzZSA9IGlnbm9yZXNDYXNlOwotCQl0aGlzLmluaXRpYWxpemUoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZSgpIHsKLQkJdGhpcy5zdHJpbmdDb252ZXJ0ZXIgPSBTdHJpbmdDb252ZXJ0ZXIuRGVmYXVsdC5pbnN0YW5jZSgpOwotCQl0aGlzLnJlYnVpbGRQYXR0ZXJuKCk7Ci0JfQotCi0JLyoqCi0JICogR2l2ZW4gdGhlIGN1cnJlbnQgcGF0dGVybiBzdHJpbmcgYW5kIGNhc2Utc2Vuc2l0aXZpdHkgc2V0dGluZywKLQkgKiByZS1idWlsZCB0aGUgcmVndWxhciBleHByZXNzaW9uIHBhdHRlcm4uCi0JICovCi0JcHJvdGVjdGVkIHN5bmNocm9uaXplZCB2b2lkIHJlYnVpbGRQYXR0ZXJuKCkgewotCQl0aGlzLnBhdHRlcm4gPSB0aGlzLmJ1aWxkUGF0dGVybigpOwotCX0KLQotCS8qKgotCSAqIEdpdmVuIHRoZSBjdXJyZW50IHBhdHRlcm4gc3RyaW5nIGFuZCBjYXNlLXNlbnNpdGl2aXR5IHNldHRpbmcsCi0JICogYnVpbGQgYW5kIHJldHVybiBhIHJlZ3VsYXIgZXhwcmVzc2lvbiBwYXR0ZXJuIHRoYXQgY2FuIGJlIHVzZWQKLQkgKiB0byBtYXRjaCBzdHJpbmdzLgotCSAqLwotCXByb3RlY3RlZCBQYXR0ZXJuIGJ1aWxkUGF0dGVybigpIHsKLQkJaW50IHBhdHRlcm5GbGFncyA9IDB4MDsKLQkJaWYgKHRoaXMuaWdub3Jlc0Nhc2UpIHsKLQkJCXBhdHRlcm5GbGFncyA9IFBhdHRlcm4uVU5JQ09ERV9DQVNFIHwgUGF0dGVybi5DQVNFX0lOU0VOU0lUSVZFOwotCQl9Ci0JCXJldHVybiBQYXR0ZXJuLmNvbXBpbGUodGhpcy5jb252ZXJ0VG9SZWdFeCh0aGlzLnBhdHRlcm5TdHJpbmcpLCBwYXR0ZXJuRmxhZ3MpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBTdHJpbmdNYXRjaGVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCBzZXRQYXR0ZXJuU3RyaW5nKFN0cmluZyBwYXR0ZXJuU3RyaW5nKSB7Ci0JCXRoaXMucGF0dGVyblN0cmluZyA9IHBhdHRlcm5TdHJpbmc7Ci0JCXRoaXMucmVidWlsZFBhdHRlcm4oKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIHN0cmluZyBtYXRjaGVzIHRoZSBwYXR0ZXJuLgotCSAqLwotCXB1YmxpYyBzeW5jaHJvbml6ZWQgYm9vbGVhbiBtYXRjaGVzKFN0cmluZyBzdHJpbmcpIHsKLQkJcmV0dXJuIHRoaXMucGF0dGVybi5tYXRjaGVyKHN0cmluZykubWF0Y2hlcygpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBGaWx0ZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIHN5bmNocm9uaXplZCBib29sZWFuIGFjY2VwdChUIG8pIHsKLQkJcmV0dXJuIHRoaXMubWF0Y2hlcyh0aGlzLnN0cmluZ0NvbnZlcnRlci5jb252ZXJ0VG9TdHJpbmcobykpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBhY2Nlc3NvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzdHJpbmcgY29udmVydGVyIHVzZWQgdG8gY29udmVydCB0aGUgb2JqZWN0cwotCSAqIHBhc3NlZCB0byB0aGUgbWF0Y2hlciBpbnRvIHN0cmluZ3MuCi0JICovCi0JcHVibGljIHN5bmNocm9uaXplZCBTdHJpbmdDb252ZXJ0ZXI8VD4gc3RyaW5nQ29udmVydGVyKCkgewotCQlyZXR1cm4gdGhpcy5zdHJpbmdDb252ZXJ0ZXI7Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSBzdHJpbmcgY29udmVydGVyIHVzZWQgdG8gY29udmVydCB0aGUgb2JqZWN0cwotCSAqIHBhc3NlZCB0byB0aGUgbWF0Y2hlciBpbnRvIHN0cmluZ3MuCi0JICovCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIHNldFN0cmluZ0NvbnZlcnRlcihTdHJpbmdDb252ZXJ0ZXI8VD4gc3RyaW5nQ29udmVydGVyKSB7Ci0JCXRoaXMuc3RyaW5nQ29udmVydGVyID0gc3RyaW5nQ29udmVydGVyOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgb3JpZ2luYWwgcGF0dGVybiBzdHJpbmcuCi0JICovCi0JcHVibGljIHN5bmNocm9uaXplZCBTdHJpbmcgcGF0dGVyblN0cmluZygpIHsKLQkJcmV0dXJuIHRoaXMucGF0dGVyblN0cmluZzsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgbWF0Y2hlciBpZ25vcmVzIGNhc2UuCi0JICovCi0JcHVibGljIHN5bmNocm9uaXplZCBib29sZWFuIGlnbm9yZXNDYXNlKCkgewotCQlyZXR1cm4gdGhpcy5pZ25vcmVzQ2FzZTsKLQl9Ci0KLQkvKioKLQkgKiBTZXQgd2hldGhlciB0aGUgbWF0Y2hlciBpZ25vcmVzIGNhc2UuCi0JICovCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIHNldElnbm9yZXNDYXNlKGJvb2xlYW4gaWdub3Jlc0Nhc2UpIHsKLQkJdGhpcy5pZ25vcmVzQ2FzZSA9IGlnbm9yZXNDYXNlOwotCQl0aGlzLnJlYnVpbGRQYXR0ZXJuKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSByZWd1bGFyIGV4cHJlc3Npb24gcGF0dGVybi4KLQkgKi8KLQlwdWJsaWMgc3luY2hyb25pemVkIFBhdHRlcm4gcGF0dGVybigpIHsKLQkJcmV0dXJuIHRoaXMucGF0dGVybjsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogb3RoZXIgcHVibGljIEFQSSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHJlZ3VsYXIgZXhwcmVzc2lvbiBjb3JyZXNwb25kaW5nIHRvCi0JICogdGhlIG9yaWdpbmFsIHBhdHRlcm4gc3RyaW5nLgotCSAqLwotCXB1YmxpYyBzeW5jaHJvbml6ZWQgU3RyaW5nIHJlZ3VsYXJFeHByZXNzaW9uKCkgewotCQlyZXR1cm4gdGhpcy5jb252ZXJ0VG9SZWdFeCh0aGlzLnBhdHRlcm5TdHJpbmcpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBjb252ZXJ0aW5nICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnZlcnQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gYSByZWd1bGFyIGV4cHJlc3Npb24uCi0JICovCi0JcHJvdGVjdGVkIFN0cmluZyBjb252ZXJ0VG9SZWdFeChTdHJpbmcgc3RyaW5nKSB7Ci0JCVN0cmluZ0J1ZmZlciBzYiA9IG5ldyBTdHJpbmdCdWZmZXIoc3RyaW5nLmxlbmd0aCgpICsgMTApOwotCQl0aGlzLmNvbnZlcnRUb1JlZ0V4T24odGhpcy5wcmVmaXgoKSwgc2IpOwotCQl0aGlzLmNvbnZlcnRUb1JlZ0V4T24oc3RyaW5nLCBzYik7Ci0JCXRoaXMuY29udmVydFRvUmVnRXhPbih0aGlzLnN1ZmZpeCgpLCBzYik7Ci0JCXJldHVybiBzYi50b1N0cmluZygpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhbnkgcHJlZml4IHRoYXQgc2hvdWxkIGJlIHByZXBlbmRlZCB0byB0aGUgb3JpZ2luYWwKLQkgKiBzdHJpbmcuIEJ5IGRlZmF1bHQsIHRoZXJlIGlzIG5vIHByZWZpeC4KLQkgKi8KLQlwcm90ZWN0ZWQgU3RyaW5nIHByZWZpeCgpIHsKLQkJcmV0dXJuICIiOyAvLyROT04tTkxTLTEkCi0JfQotCi0JLyoqCi0JICogUmV0dXJuIGFueSBzdWZmaXggdGhhdCBzaG91bGQgYmUgYXBwZW5kZWQgdG8gdGhlIG9yaWdpbmFsCi0JICogc3RyaW5nLiBTaW5jZSB0aGlzIGNsYXNzIGlzIHR5cGljYWxseSB1c2VkIGluIFVJIHNpdHVhdGlvbiB3aGVyZQotCSAqIHRoZSB1c2VyIGlzIHR5cGluZyBpbiBhIHBhdHRlcm4gdXNlZCB0byBmaWx0ZXIgYSBsaXN0LCB0aGUgZGVmYXVsdAotCSAqIHN1ZmZpeCBpcyBhIHdpbGRjYXJkIGNoYXJhY3Rlci4KLQkgKi8KLQlwcm90ZWN0ZWQgU3RyaW5nIHN1ZmZpeCgpIHsKLQkJcmV0dXJuICIqIjsgLy8kTk9OLU5MUy0xJAotCX0KLQotCS8qKgotCSAqIENvbnZlcnQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gYSByZWd1bGFyIGV4cHJlc3Npb24uCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgY29udmVydFRvUmVnRXhPbihTdHJpbmcgc3RyaW5nLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJY2hhcltdIGNoYXJBcnJheSA9IHN0cmluZy50b0NoYXJBcnJheSgpOwotCQlpbnQgbGVuZ3RoID0gY2hhckFycmF5Lmxlbmd0aDsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsZW5ndGg7IGkrKykgewotCQkJY2hhciBjID0gY2hhckFycmF5W2ldOwotCQkJLy8gY29udmVydCB1c2VyLWZyaWVuZGx5IG1ldGEtY2hhcnMgaW50byByZWdleCBtZXRhLWNoYXJzCi0JCQlpZiAoYyA9PSAnKicpIHsKLQkJCQlzYi5hcHBlbmQoIi4qIik7IC8vJE5PTi1OTFMtMSQKLQkJCQljb250aW51ZTsKLQkJCX0KLQkJCWlmIChjID09ICc/JykgewotCQkJCXNiLmFwcGVuZCgnLicpOwotCQkJCWNvbnRpbnVlOwotCQkJfQotCQkJLy8gZXNjYXBlIHJlZ2V4IG1ldGEtY2hhcnMKLQkJCWlmIChDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoUkVHX0VYX01FVEFfQ0hBUlMsIGMpKSB7Ci0JCQkJc2IuYXBwZW5kKCdcXCcpOwotCQkJfQotCQkJc2IuYXBwZW5kKGMpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU3RhY2suamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9TdGFjay5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5M2JlZjY0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9TdGFjay5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uU2VyaWFsaXphYmxlOwotaW1wb3J0IGphdmEudXRpbC5FbXB0eVN0YWNrRXhjZXB0aW9uOwotCi0vKioKLSAqIEludGVyZmFjZSBkZWZpbmluZyB0aGUgY2xhc3NpYyBzdGFjayBiZWhhdmlvciwKLSAqIHdpdGhvdXQgdGhlIGJhY2tkb29ycyBhbGxvd2VkIGJ5IGphdmEudXRpbC5TdGFjay4KLSAqIEUgaXMgdGhlIHR5cGUgb2YgZWxlbWVudHMgY29udGFpbmVkIGJ5IHRoZSBTdGFjay4KLSAqLwotcHVibGljIGludGVyZmFjZSBTdGFjazxFPiB7Ci0KLQkvKioKLQkgKiAiUHVzaCIgdGhlIHNwZWNpZmllZCBpdGVtIG9uIHRvIHRoZSB0b3Agb2YgdGhlIHN0YWNrLgotCSAqLwotCXZvaWQgcHVzaChFIG8pOwotCi0JLyoqCi0JICogIlBvcCIgYW4gaXRlbSBmcm9tIHRoZSB0b3Agb2YgdGhlIHN0YWNrLgotCSAqLwotCUUgcG9wKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGl0ZW0gb24gdGhlIHRvcCBvZiB0aGUgc3RhY2sKLQkgKiB3aXRob3V0IHJlbW92aW5nIGl0IGZyb20gdGhlIHN0YWNrLgotCSAqLwotCUUgcGVlaygpOwotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHN0YWNrIGlzIGVtcHR5LgotCSAqLwotCWJvb2xlYW4gaXNFbXB0eSgpOwotCi0KLQlmaW5hbCBjbGFzcyBFbXB0eTxFPiBpbXBsZW1lbnRzIFN0YWNrPEU+LCBTZXJpYWxpemFibGUgewotCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdGFjayBJTlNUQU5DRSA9IG5ldyBFbXB0eSgpOwotCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJcHVibGljIHN0YXRpYyA8VD4gU3RhY2s8VD4gaW5zdGFuY2UoKSB7Ci0JCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCX0KLQkJLy8gZW5zdXJlIHNpbmdsZSBpbnN0YW5jZQotCQlwcml2YXRlIEVtcHR5KCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBwdXNoKEUgbykgewotCQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JCX0KLQkJcHVibGljIEUgcG9wKCkgewotCQkJdGhyb3cgbmV3IEVtcHR5U3RhY2tFeGNlcHRpb24oKTsKLQkJfQotCQlwdWJsaWMgRSBwZWVrKCkgewotCQkJdGhyb3cgbmV3IEVtcHR5U3RhY2tFeGNlcHRpb24oKTsKLQkJfQotCQlwdWJsaWMgYm9vbGVhbiBpc0VtcHR5KCkgewotCQkJcmV0dXJuIHRydWU7Ci0JCX0KLQkJcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0JCXByaXZhdGUgT2JqZWN0IHJlYWRSZXNvbHZlKCkgewotCQkJcmV0dXJuIElOU1RBTkNFOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU3RyaW5nQ29udmVydGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU3RyaW5nQ29udmVydGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDg3ODJlMDcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1N0cmluZ0NvbnZlcnRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNjggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotLyoqCi0gKiBVc2VkIGJ5IHZhcmlvdXMgInBsdWdnYWJsZSIgY2xhc3NlcyB0byB0cmFuc2Zvcm0gb2JqZWN0cwotICogaW50byBzdHJpbmdzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIFN0cmluZ0NvbnZlcnRlcjxUPiB7Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgb2JqZWN0IGludG8gYSBzdHJpbmcuCi0JICogVGhlIHNlbWFudGljcyBvZiAiY29udmVydCIgaXMgZGV0ZXJtaW5lZCBieSB0aGUKLQkgKiBjb250cmFjdCBiZXR3ZWVuIHRoZSBjbGllbnQgYW5kIHRoZSBzZXJ2ZXIuCi0JICovCi0JU3RyaW5nIGNvbnZlcnRUb1N0cmluZyhUIG8pOwotCi0KLQlmaW5hbCBjbGFzcyBEZWZhdWx0PFM+IGltcGxlbWVudHMgU3RyaW5nQ29udmVydGVyPFM+IHsKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nQ29udmVydGVyIElOU1RBTkNFID0gbmV3IERlZmF1bHQoKTsKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCXB1YmxpYyBzdGF0aWMgPFI+IFN0cmluZ0NvbnZlcnRlcjxSPiBpbnN0YW5jZSgpIHsKLQkJCXJldHVybiBJTlNUQU5DRTsKLQkJfQotCQkvLyBlbnN1cmUgc2luZ2xlIGluc3RhbmNlCi0JCXByaXZhdGUgRGVmYXVsdCgpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQkJLy8gc2ltcGx5IHJldHVybiB0aGUgb2JqZWN0J3MgI3RvU3RyaW5nKCkgcmVzdWx0Ci0JCXB1YmxpYyBTdHJpbmcgY29udmVydFRvU3RyaW5nKFMgbykgewotCQkJcmV0dXJuIChvID09IG51bGwpID8gbnVsbCA6IG8udG9TdHJpbmcoKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiU3RyaW5nQ29udmVydGVyLkRlZmF1bHQiOyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLQlmaW5hbCBjbGFzcyBEaXNhYmxlZDxTPiBpbXBsZW1lbnRzIFN0cmluZ0NvbnZlcnRlcjxTPiB7Ci0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZ0NvbnZlcnRlciBJTlNUQU5DRSA9IG5ldyBEaXNhYmxlZCgpOwotCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJcHVibGljIHN0YXRpYyA8Uj4gU3RyaW5nQ29udmVydGVyPFI+IGluc3RhbmNlKCkgewotCQkJcmV0dXJuIElOU1RBTkNFOwotCQl9Ci0JCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJcHJpdmF0ZSBEaXNhYmxlZCgpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQkJLy8gdGhyb3cgYW4gZXhjZXB0aW9uCi0JCXB1YmxpYyBTdHJpbmcgY29udmVydFRvU3RyaW5nKFMgbykgewotCQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gIlN0cmluZ0NvbnZlcnRlci5EaXNhYmxlZCI7IC8vJE5PTi1OTFMtMSQKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1N0cmluZ01hdGNoZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9TdHJpbmdNYXRjaGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDIwOTVmZTYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1N0cmluZ01hdGNoZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWw7Ci0KLS8qKgotICogVGhpcyBpbnRlcmZhY2UgZGVmaW5lcyBhIHNpbXBsZSBBUEkgZm9yIGFsbG93aW5nICJwbHVnZ2FibGUiCi0gKiBzdHJpbmcgbWF0Y2hlcnMgdGhhdCBjYW4gYmUgY29uZmlndXJlZCB3aXRoIGEgcGF0dGVybiBzdHJpbmcKLSAqIHRoZW4gdXNlZCB0byBkZXRlcm1pbmUgd2hhdCBzdHJpbmdzIG1hdGNoIHRoZSBwYXR0ZXJuLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIFN0cmluZ01hdGNoZXIgewotCi0JLyoqCi0JICogU2V0IHRoZSBwYXR0ZXJuIHN0cmluZyB1c2VkIHRvIGRldGVybWluZSBmdXR1cmUKLQkgKiBtYXRjaGVzLiBUaGUgZm9ybWF0IGFuZCBzZW1hbnRpY3Mgb2YgdGhlIHBhdHRlcm4KLQkgKiBzdHJpbmcgYXJlIGRldGVybWluZWQgYnkgdGhlIGNvbnRyYWN0IGJldHdlZW4gdGhlCi0JICogY2xpZW50IGFuZCB0aGUgc2VydmVyLgotCSAqLwotCXZvaWQgc2V0UGF0dGVyblN0cmluZyhTdHJpbmcgcGF0dGVyblN0cmluZyk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIHN0cmluZyBtYXRjaGVzIHRoZQotCSAqIGVzdGFibGlzaGVkIHBhdHRlcm4gc3RyaW5nLiBUaGUgc2VtYW50aWNzIG9mIGEgbWF0Y2gKLQkgKiBpcyBkZXRlcm1pbmVkIGJ5IHRoZSBjb250cmFjdCBiZXR3ZWVuIHRoZQotCSAqIGNsaWVudCBhbmQgdGhlIHNlcnZlci4KLQkgKi8KLQlib29sZWFuIG1hdGNoZXMoU3RyaW5nIHN0cmluZyk7Ci0KLQotCWZpbmFsIGNsYXNzIE51bGwgaW1wbGVtZW50cyBTdHJpbmdNYXRjaGVyIHsKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmdNYXRjaGVyIElOU1RBTkNFID0gbmV3IE51bGwoKTsKLQkJcHVibGljIHN0YXRpYyBTdHJpbmdNYXRjaGVyIGluc3RhbmNlKCkgewotCQkJcmV0dXJuIElOU1RBTkNFOwotCQl9Ci0JCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJcHJpdmF0ZSBOdWxsKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXRQYXR0ZXJuU3RyaW5nKFN0cmluZyBwYXR0ZXJuU3RyaW5nKSB7Ci0JCQkvLyBpZ25vcmUgdGhlIHBhdHRlcm4gc3RyaW5nCi0JCX0KLQkJcHVibGljIGJvb2xlYW4gbWF0Y2hlcyhTdHJpbmcgc3RyaW5nKSB7Ci0JCQkvLyBldmVyeXRoaW5nIGlzIGEgbWF0Y2gKLQkJCXJldHVybiB0cnVlOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuICJTdHJpbmdNYXRjaGVyLk51bGwiOyAvLyROT04tTkxTLTEkCi0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9TdHJpbmdUb29scy5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1N0cmluZ1Rvb2xzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGIzYzY5YjEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1N0cmluZ1Rvb2xzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0MTQ1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLmlvLklPRXhjZXB0aW9uOwotaW1wb3J0IGphdmEuaW8uV3JpdGVyOwotaW1wb3J0IGphdmEudXRpbC5BcnJheXM7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5UcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yOwotCi0vKioKLSAqIENvbnZlbmllbmNlIG1ldGhvZHMgcmVsYXRlZCB0byB0aGUgamF2YS5sYW5nLlN0cmluZyBjbGFzcy4KLSAqIAotICogQXMgb2YgamRrIDEuNSwgaXQncyB0ZW1wdGluZyB0byBjb252ZXJ0IGFsbCBvZiB0aGVzZSBtZXRob2RzIHRvIHVzZQotICogamF2YS5sYW5nLkFwcGVuZGFibGUgKGluc3RlYWQgb2YgU3RyaW5nQnVmZmVyLCBTdHJpbmdCdWlsZGVyLCBhbmQgV3JpdGVyKTsKLSAqIGJ1dCBhbGwgdGhlIEFwcGVuZGFibGUgbWV0aG9kcyB0aHJvdyBqYXZhLmlvLklPRXhjZXB0aW9uICh5ZWNoKSBhbmQgd2UKLSAqIFttaWdodD9dIGdldCBhIGJpdCBiZXR0ZXIgcGVyZm9ybWFuY2UgaW52b2tpbmcgbWV0aG9kcyBvbiBjbGFzc2VzIHRoYW4KLSAqIHdlIGdldCBvbiBpbnRlcmZhY2VzLiA6LSkKLSAqLwotcHVibGljIGZpbmFsIGNsYXNzIFN0cmluZ1Rvb2xzIHsKLQotCS8qKiBjYXJyaWFnZSByZXR1cm4gKi8KLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBDUiA9IFN5c3RlbS5nZXRQcm9wZXJ0eSgibGluZS5zZXBhcmF0b3IiKTsgIC8vJE5PTi1OTFMtMSQKLQotCS8qKiBkb3VibGUgcXVvdGUgKi8KLQlwdWJsaWMgc3RhdGljIGZpbmFsIGNoYXIgUVVPVEUgPSAnIic7Ci0KLQkvKiogcGFyZW50aGVzaXMgKi8KLQlwdWJsaWMgc3RhdGljIGZpbmFsIGNoYXIgT1BFTl9QQVJFTlRIRVNJUyA9ICcoJzsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIGNoYXIgQ0xPU0VfUEFSRU5USEVTSVMgPSAnKSc7Ci0KLQkvKiogYnJhY2tldHMgKi8KLQlwdWJsaWMgc3RhdGljIGZpbmFsIGNoYXIgT1BFTl9CUkFDS0VUID0gJ1snOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgY2hhciBDTE9TRV9CUkFDS0VUID0gJ10nOwotCi0JLyoqIGJyYWNrZXRzICovCi0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIE9QRU5fQlJBQ0UgPSAneyc7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIENMT1NFX0JSQUNFID0gJ30nOwotCi0JLyoqIGJyYWNrZXRzICovCi0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIE9QRU5fQ0hFVlJPTiA9ICc8JzsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIGNoYXIgQ0xPU0VfQ0hFVlJPTiA9ICc+JzsKLQotCS8qKiBlbXB0eSBzdHJpbmcgKi8KLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBFTVBUWV9TVFJJTkcgPSAiIjsgLy8kTk9OLU5MUy0xJAotCi0JLyoqIGVtcHR5IGNoYXIgYXJyYXkgKi8KLQlwdWJsaWMgc3RhdGljIGZpbmFsIGNoYXJbXSBFTVBUWV9DSEFSX0FSUkFZID0gbmV3IGNoYXJbMF07Ci0KLQotCi0JLy8gKioqKioqKioqKiBwYWRkaW5nL3RydW5jYXRpbmcgKioqKioqKioqKgotCi0JLyoqCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBhbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaXMgdGhyb3duLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggc3BhY2VzIGF0IHRoZSBlbmQuCi0JICogU3RyaW5nI3BhZChpbnQpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgcGFkKFN0cmluZyBzdHJpbmcsIGludCBsZW5ndGgpIHsKLQkJcmV0dXJuIHBhZChzdHJpbmcsIGxlbmd0aCwgJyAnKTsKLQl9Ci0KLQkvKioKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpcyB0aHJvd24uCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCBzcGFjZXMgYXQgdGhlIGVuZC4KLQkgKiBTdHJpbmcjcGFkT24oaW50LCBXcml0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHBhZE9uKFN0cmluZyBzdHJpbmcsIGludCBsZW5ndGgsIFdyaXRlciB3cml0ZXIpIHsKLQkJcGFkT24oc3RyaW5nLCBsZW5ndGgsICcgJywgd3JpdGVyKTsKLQl9Ci0KLQkvKioKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpcyB0aHJvd24uCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCBzcGFjZXMgYXQgdGhlIGVuZC4KLQkgKiBTdHJpbmcjcGFkT24oaW50LCBTdHJpbmdCdWZmZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHBhZE9uKFN0cmluZyBzdHJpbmcsIGludCBsZW5ndGgsIFN0cmluZ0J1ZmZlciBzYikgewotCQlwYWRPbihzdHJpbmcsIGxlbmd0aCwgJyAnLCBzYik7Ci0JfQotCi0JLyoqCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBhbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaXMgdGhyb3duLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggc3BhY2VzIGF0IHRoZSBlbmQuCi0JICogU3RyaW5nI3BhZE9uKGludCwgU3RyaW5nQnVpbGRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcGFkT24oU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCwgU3RyaW5nQnVpbGRlciBzYikgewotCQlwYWRPbihzdHJpbmcsIGxlbmd0aCwgJyAnLCBzYik7Ci0JfQotCi0JLyoqCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBhbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaXMgdGhyb3duLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggdGhlCi0JICogc3BlY2lmaWVkIGNoYXJhY3RlciBhdCB0aGUgZW5kLgotCSAqIFN0cmluZyNwYWQoaW50LCBjaGFyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHBhZChTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMpIHsKLQkJaW50IHN0cmluZ0xlbmd0aCA9IHN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKHN0cmluZ0xlbmd0aCA+IGxlbmd0aCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiU3RyaW5nIGlzIHRvbyBsb25nOiAiICsgc3RyaW5nTGVuZ3RoICsgIiA+ICIgKyBsZW5ndGgpOyAgLy8kTk9OLU5MUy0xJCAgLy8kTk9OLU5MUy0yJAotCQl9Ci0JCWlmIChzdHJpbmdMZW5ndGggPT0gbGVuZ3RoKSB7Ci0JCQlyZXR1cm4gc3RyaW5nOwotCQl9Ci0JCXJldHVybiBwYWRfKHN0cmluZywgbGVuZ3RoLCBjKTsKLQl9Ci0KLQkvKioKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpcyB0aHJvd24uCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB0aGUKLQkgKiBzcGVjaWZpZWQgY2hhcmFjdGVyIGF0IHRoZSBlbmQuCi0JICogU3RyaW5nI3BhZE9uKGludCwgY2hhciwgV3JpdGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBwYWRPbihTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFdyaXRlciB3cml0ZXIpIHsKLQkJaW50IHN0cmluZ0xlbmd0aCA9IHN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKHN0cmluZ0xlbmd0aCA+IGxlbmd0aCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiU3RyaW5nIGlzIHRvbyBsb25nOiAiICsgc3RyaW5nTGVuZ3RoICsgIiA+ICIgKyBsZW5ndGgpOyAgLy8kTk9OLU5MUy0xJCAgLy8kTk9OLU5MUy0yJAotCQl9Ci0JCWlmIChzdHJpbmdMZW5ndGggPT0gbGVuZ3RoKSB7Ci0JCQl3cml0ZVN0cmluZ09uKHN0cmluZywgd3JpdGVyKTsKLQkJfSBlbHNlIHsKLQkJCXBhZE9uXyhzdHJpbmcsIGxlbmd0aCwgYywgd3JpdGVyKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFBhZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgYW4gSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGlzIHRocm93bi4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHRoZQotCSAqIHNwZWNpZmllZCBjaGFyYWN0ZXIgYXQgdGhlIGVuZC4KLQkgKiBTdHJpbmcjcGFkT24oaW50LCBjaGFyLCBTdHJpbmdCdWZmZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHBhZE9uKFN0cmluZyBzdHJpbmcsIGludCBsZW5ndGgsIGNoYXIgYywgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoKCk7Ci0JCWlmIChzdHJpbmdMZW5ndGggPiBsZW5ndGgpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oIlN0cmluZyBpcyB0b28gbG9uZzogIiArIHN0cmluZ0xlbmd0aCArICIgPiAiICsgbGVuZ3RoKTsgIC8vJE5PTi1OTFMtMSQgIC8vJE5PTi1OTFMtMiQKLQkJfQotCQlpZiAoc3RyaW5nTGVuZ3RoID09IGxlbmd0aCkgewotCQkJc2IuYXBwZW5kKHN0cmluZyk7Ci0JCX0gZWxzZSB7Ci0JCQlwYWRPbl8oc3RyaW5nLCBsZW5ndGgsIGMsIHNiKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFBhZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgYW4gSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGlzIHRocm93bi4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHRoZQotCSAqIHNwZWNpZmllZCBjaGFyYWN0ZXIgYXQgdGhlIGVuZC4KLQkgKiBTdHJpbmcjcGFkT24oaW50LCBjaGFyLCBTdHJpbmdCdWlsZGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBwYWRPbihTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJaW50IHN0cmluZ0xlbmd0aCA9IHN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKHN0cmluZ0xlbmd0aCA+IGxlbmd0aCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiU3RyaW5nIGlzIHRvbyBsb25nOiAiICsgc3RyaW5nTGVuZ3RoICsgIiA+ICIgKyBsZW5ndGgpOyAgLy8kTk9OLU5MUy0xJCAgLy8kTk9OLU5MUy0yJAotCQl9Ci0JCWlmIChzdHJpbmdMZW5ndGggPT0gbGVuZ3RoKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQkJfSBlbHNlIHsKLQkJCXBhZE9uXyhzdHJpbmcsIGxlbmd0aCwgYywgc2IpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBhbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaXMgdGhyb3duLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggc3BhY2VzIGF0IHRoZSBlbmQuCi0JICogU3RyaW5nI3BhZChpbnQpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gcGFkKGNoYXJbXSBzdHJpbmcsIGludCBsZW5ndGgpIHsKLQkJcmV0dXJuIHBhZChzdHJpbmcsIGxlbmd0aCwgJyAnKTsKLQl9Ci0KLQkvKioKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpcyB0aHJvd24uCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCBzcGFjZXMgYXQgdGhlIGVuZC4KLQkgKiBTdHJpbmcjcGFkT24oaW50LCB3cml0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHBhZE9uKGNoYXJbXSBzdHJpbmcsIGludCBsZW5ndGgsIFdyaXRlciB3cml0ZXIpIHsKLQkJcGFkT24oc3RyaW5nLCBsZW5ndGgsICcgJywgd3JpdGVyKTsKLQl9Ci0KLQkvKioKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpcyB0aHJvd24uCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCBzcGFjZXMgYXQgdGhlIGVuZC4KLQkgKiBTdHJpbmcjcGFkT24oaW50LCBTdHJpbmdCdWZmZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHBhZE9uKGNoYXJbXSBzdHJpbmcsIGludCBsZW5ndGgsIFN0cmluZ0J1ZmZlciBzYikgewotCQlwYWRPbihzdHJpbmcsIGxlbmd0aCwgJyAnLCBzYik7Ci0JfQotCi0JLyoqCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBhbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaXMgdGhyb3duLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggc3BhY2VzIGF0IHRoZSBlbmQuCi0JICogU3RyaW5nI3BhZE9uKGludCwgU3RyaW5nQnVpbGRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcGFkT24oY2hhcltdIHN0cmluZywgaW50IGxlbmd0aCwgU3RyaW5nQnVpbGRlciBzYikgewotCQlwYWRPbihzdHJpbmcsIGxlbmd0aCwgJyAnLCBzYik7Ci0JfQotCi0JLyoqCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBhbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaXMgdGhyb3duLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggdGhlCi0JICogc3BlY2lmaWVkIGNoYXJhY3RlciBhdCB0aGUgZW5kLgotCSAqIFN0cmluZyNwYWQoaW50LCBjaGFyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIHBhZChjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMpIHsKLQkJaW50IHN0cmluZ0xlbmd0aCA9IHN0cmluZy5sZW5ndGg7Ci0JCWlmIChzdHJpbmdMZW5ndGggPiBsZW5ndGgpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oIlN0cmluZyBpcyB0b28gbG9uZzogIiArIHN0cmluZ0xlbmd0aCArICIgPiAiICsgbGVuZ3RoKTsgIC8vJE5PTi1OTFMtMSQgIC8vJE5PTi1OTFMtMiQKLQkJfQotCQlpZiAoc3RyaW5nTGVuZ3RoID09IGxlbmd0aCkgewotCQkJcmV0dXJuIHN0cmluZzsKLQkJfQotCQlyZXR1cm4gcGFkXyhzdHJpbmcsIGxlbmd0aCwgYyk7Ci0JfQotCi0JLyoqCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBhbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaXMgdGhyb3duLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggdGhlCi0JICogc3BlY2lmaWVkIGNoYXJhY3RlciBhdCB0aGUgZW5kLgotCSAqIFN0cmluZyNwYWRPbihpbnQsIGNoYXIsIFdyaXRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcGFkT24oY2hhcltdIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoOwotCQlpZiAoc3RyaW5nTGVuZ3RoID4gbGVuZ3RoKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJTdHJpbmcgaXMgdG9vIGxvbmc6ICIgKyBzdHJpbmdMZW5ndGggKyAiID4gIiArIGxlbmd0aCk7ICAvLyROT04tTkxTLTEkICAvLyROT04tTkxTLTIkCi0JCX0KLQkJaWYgKHN0cmluZ0xlbmd0aCA9PSBsZW5ndGgpIHsKLQkJCXdyaXRlU3RyaW5nT24oc3RyaW5nLCB3cml0ZXIpOwotCQl9IGVsc2UgewotCQkJcGFkT25fKHN0cmluZywgbGVuZ3RoLCBjLCB3cml0ZXIpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBhbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaXMgdGhyb3duLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggdGhlCi0JICogc3BlY2lmaWVkIGNoYXJhY3RlciBhdCB0aGUgZW5kLgotCSAqIFN0cmluZyNwYWRPbihpbnQsIGNoYXIsIFN0cmluZ0J1ZmZlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcGFkT24oY2hhcltdIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJaW50IHN0cmluZ0xlbmd0aCA9IHN0cmluZy5sZW5ndGg7Ci0JCWlmIChzdHJpbmdMZW5ndGggPiBsZW5ndGgpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oIlN0cmluZyBpcyB0b28gbG9uZzogIiArIHN0cmluZ0xlbmd0aCArICIgPiAiICsgbGVuZ3RoKTsgIC8vJE5PTi1OTFMtMSQgIC8vJE5PTi1OTFMtMiQKLQkJfQotCQlpZiAoc3RyaW5nTGVuZ3RoID09IGxlbmd0aCkgewotCQkJc2IuYXBwZW5kKHN0cmluZyk7Ci0JCX0gZWxzZSB7Ci0JCQlwYWRPbl8oc3RyaW5nLCBsZW5ndGgsIGMsIHNiKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFBhZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgYW4gSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGlzIHRocm93bi4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHRoZQotCSAqIHNwZWNpZmllZCBjaGFyYWN0ZXIgYXQgdGhlIGVuZC4KLQkgKiBTdHJpbmcjcGFkT24oaW50LCBjaGFyLCBTdHJpbmdCdWlsZGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBwYWRPbihjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJaW50IHN0cmluZ0xlbmd0aCA9IHN0cmluZy5sZW5ndGg7Ci0JCWlmIChzdHJpbmdMZW5ndGggPiBsZW5ndGgpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oIlN0cmluZyBpcyB0b28gbG9uZzogIiArIHN0cmluZ0xlbmd0aCArICIgPiAiICsgbGVuZ3RoKTsgIC8vJE5PTi1OTFMtMSQgIC8vJE5PTi1OTFMtMiQKLQkJfQotCQlpZiAoc3RyaW5nTGVuZ3RoID09IGxlbmd0aCkgewotCQkJc2IuYXBwZW5kKHN0cmluZyk7Ci0JCX0gZWxzZSB7Ci0JCQlwYWRPbl8oc3RyaW5nLCBsZW5ndGgsIGMsIHNiKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFBhZCBvciB0cnVuY2F0ZSB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgdHJ1bmNhdGVkLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggc3BhY2VzIGF0IHRoZSBlbmQuCi0JICogU3RyaW5nI3BhZE9yVHJ1bmNhdGUoaW50KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHBhZE9yVHJ1bmNhdGUoU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCkgewotCQlyZXR1cm4gcGFkT3JUcnVuY2F0ZShzdHJpbmcsIGxlbmd0aCwgJyAnKTsKLQl9Ci0KLQkvKioKLQkgKiBQYWQgb3IgdHJ1bmNhdGUgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHRydW5jYXRlZC4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHNwYWNlcyBhdCB0aGUgZW5kLgotCSAqIFN0cmluZyNwYWRPclRydW5jYXRlT24oaW50LCBXcml0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHBhZE9yVHJ1bmNhdGVPbihTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCXBhZE9yVHJ1bmNhdGVPbihzdHJpbmcsIGxlbmd0aCwgJyAnLCB3cml0ZXIpOwotCX0KLQotCS8qKgotCSAqIFBhZCBvciB0cnVuY2F0ZSB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgdHJ1bmNhdGVkLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggc3BhY2VzIGF0IHRoZSBlbmQuCi0JICogU3RyaW5nI3BhZE9yVHJ1bmNhdGVPbihpbnQsIFN0cmluZ0J1ZmZlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcGFkT3JUcnVuY2F0ZU9uKFN0cmluZyBzdHJpbmcsIGludCBsZW5ndGgsIFN0cmluZ0J1ZmZlciBzYikgewotCQlwYWRPclRydW5jYXRlT24oc3RyaW5nLCBsZW5ndGgsICcgJywgc2IpOwotCX0KLQotCS8qKgotCSAqIFBhZCBvciB0cnVuY2F0ZSB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgdHJ1bmNhdGVkLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggc3BhY2VzIGF0IHRoZSBlbmQuCi0JICogU3RyaW5nI3BhZE9yVHJ1bmNhdGVPbihpbnQsIFN0cmluZ0J1aWxkZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHBhZE9yVHJ1bmNhdGVPbihTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXBhZE9yVHJ1bmNhdGVPbihzdHJpbmcsIGxlbmd0aCwgJyAnLCBzYik7Ci0JfQotCi0JLyoqCi0JICogUGFkIG9yIHRydW5jYXRlIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyB0cnVuY2F0ZWQuCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB0aGUKLQkgKiBzcGVjaWZpZWQgY2hhcmFjdGVyIGF0IHRoZSBlbmQuCi0JICogU3RyaW5nI3BhZE9yVHJ1bmNhdGUoaW50LCBjaGFyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHBhZE9yVHJ1bmNhdGUoU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjKSB7Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoKCk7Ci0JCWlmIChzdHJpbmdMZW5ndGggPT0gbGVuZ3RoKSB7Ci0JCQlyZXR1cm4gc3RyaW5nOwotCQl9Ci0JCWlmIChzdHJpbmdMZW5ndGggPiBsZW5ndGgpIHsKLQkJCXJldHVybiBzdHJpbmcuc3Vic3RyaW5nKDAsIGxlbmd0aCk7Ci0JCX0KLQkJcmV0dXJuIHBhZF8oc3RyaW5nLCBsZW5ndGgsIGMpOwotCX0KLQotCS8qKgotCSAqIFBhZCBvciB0cnVuY2F0ZSB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgdHJ1bmNhdGVkLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggdGhlCi0JICogc3BlY2lmaWVkIGNoYXJhY3RlciBhdCB0aGUgZW5kLgotCSAqIFN0cmluZyNwYWRPclRydW5jYXRlT24oaW50LCBjaGFyLCBXcml0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHBhZE9yVHJ1bmNhdGVPbihTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFdyaXRlciB3cml0ZXIpIHsKLQkJaW50IHN0cmluZ0xlbmd0aCA9IHN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKHN0cmluZ0xlbmd0aCA9PSBsZW5ndGgpIHsKLQkJCXdyaXRlU3RyaW5nT24oc3RyaW5nLCB3cml0ZXIpOwotCQl9IGVsc2UgaWYgKHN0cmluZ0xlbmd0aCA+IGxlbmd0aCkgewotCQkJd3JpdGVTdHJpbmdPbihzdHJpbmcuc3Vic3RyaW5nKDAsIGxlbmd0aCksIHdyaXRlcik7Ci0JCX0gZWxzZSB7Ci0JCQlwYWRPbl8oc3RyaW5nLCBsZW5ndGgsIGMsIHdyaXRlcik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBQYWQgb3IgdHJ1bmNhdGUgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHRydW5jYXRlZC4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHRoZQotCSAqIHNwZWNpZmllZCBjaGFyYWN0ZXIgYXQgdGhlIGVuZC4KLQkgKiBTdHJpbmcjcGFkT3JUcnVuY2F0ZU9uKGludCwgY2hhciwgU3RyaW5nQnVmZmVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBwYWRPclRydW5jYXRlT24oU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJaW50IHN0cmluZ0xlbmd0aCA9IHN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKHN0cmluZ0xlbmd0aCA9PSBsZW5ndGgpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcpOwotCQl9IGVsc2UgaWYgKHN0cmluZ0xlbmd0aCA+IGxlbmd0aCkgewotCQkJc2IuYXBwZW5kKHN0cmluZy5zdWJzdHJpbmcoMCwgbGVuZ3RoKSk7Ci0JCX0gZWxzZSB7Ci0JCQlwYWRPbl8oc3RyaW5nLCBsZW5ndGgsIGMsIHNiKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFBhZCBvciB0cnVuY2F0ZSB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgdHJ1bmNhdGVkLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggdGhlCi0JICogc3BlY2lmaWVkIGNoYXJhY3RlciBhdCB0aGUgZW5kLgotCSAqIFN0cmluZyNwYWRPclRydW5jYXRlT24oaW50LCBjaGFyLCBTdHJpbmdCdWlsZGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBwYWRPclRydW5jYXRlT24oU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoKCk7Ci0JCWlmIChzdHJpbmdMZW5ndGggPT0gbGVuZ3RoKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQkJfSBlbHNlIGlmIChzdHJpbmdMZW5ndGggPiBsZW5ndGgpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcuc3Vic3RyaW5nKDAsIGxlbmd0aCkpOwotCQl9IGVsc2UgewotCQkJcGFkT25fKHN0cmluZywgbGVuZ3RoLCBjLCBzYik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBQYWQgb3IgdHJ1bmNhdGUgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHRydW5jYXRlZC4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHNwYWNlcyBhdCB0aGUgZW5kLgotCSAqIFN0cmluZyNwYWRPclRydW5jYXRlKGludCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXJbXSBwYWRPclRydW5jYXRlKGNoYXJbXSBzdHJpbmcsIGludCBsZW5ndGgpIHsKLQkJcmV0dXJuIHBhZE9yVHJ1bmNhdGUoc3RyaW5nLCBsZW5ndGgsICcgJyk7Ci0JfQotCi0JLyoqCi0JICogUGFkIG9yIHRydW5jYXRlIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyB0cnVuY2F0ZWQuCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCBzcGFjZXMgYXQgdGhlIGVuZC4KLQkgKiBTdHJpbmcjcGFkT3JUcnVuY2F0ZU9uKGludCwgV3JpdGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBwYWRPclRydW5jYXRlT24oY2hhcltdIHN0cmluZywgaW50IGxlbmd0aCwgV3JpdGVyIHdyaXRlcikgewotCQlwYWRPclRydW5jYXRlT24oc3RyaW5nLCBsZW5ndGgsICcgJywgd3JpdGVyKTsKLQl9Ci0KLQkvKioKLQkgKiBQYWQgb3IgdHJ1bmNhdGUgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHRydW5jYXRlZC4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHNwYWNlcyBhdCB0aGUgZW5kLgotCSAqIFN0cmluZyNwYWRPclRydW5jYXRlT24oaW50LCBTdHJpbmdCdWZmZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHBhZE9yVHJ1bmNhdGUoY2hhcltdIHN0cmluZywgaW50IGxlbmd0aCwgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCXBhZE9yVHJ1bmNhdGVPbihzdHJpbmcsIGxlbmd0aCwgJyAnLCBzYik7Ci0JfQotCi0JLyoqCi0JICogUGFkIG9yIHRydW5jYXRlIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyB0cnVuY2F0ZWQuCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCBzcGFjZXMgYXQgdGhlIGVuZC4KLQkgKiBTdHJpbmcjcGFkT3JUcnVuY2F0ZU9uKGludCwgU3RyaW5nQnVpbGRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcGFkT3JUcnVuY2F0ZShjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXBhZE9yVHJ1bmNhdGVPbihzdHJpbmcsIGxlbmd0aCwgJyAnLCBzYik7Ci0JfQotCi0JLyoqCi0JICogUGFkIG9yIHRydW5jYXRlIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyB0cnVuY2F0ZWQuCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB0aGUKLQkgKiBzcGVjaWZpZWQgY2hhcmFjdGVyIGF0IHRoZSBlbmQuCi0JICogU3RyaW5nI3BhZE9yVHJ1bmNhdGUoaW50LCBjaGFyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIHBhZE9yVHJ1bmNhdGUoY2hhcltdIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjKSB7Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoOwotCQlpZiAoc3RyaW5nTGVuZ3RoID09IGxlbmd0aCkgewotCQkJcmV0dXJuIHN0cmluZzsKLQkJfQotCQlpZiAoc3RyaW5nTGVuZ3RoID4gbGVuZ3RoKSB7Ci0JCQljaGFyW10gcmVzdWx0ID0gbmV3IGNoYXJbbGVuZ3RoXTsKLQkJCVN5c3RlbS5hcnJheWNvcHkoc3RyaW5nLCAwLCByZXN1bHQsIDAsIGxlbmd0aCk7Ci0JCQlyZXR1cm4gcmVzdWx0OwotCQl9Ci0JCXJldHVybiBwYWRfKHN0cmluZywgbGVuZ3RoLCBjKTsKLQl9Ci0KLQkvKioKLQkgKiBQYWQgb3IgdHJ1bmNhdGUgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHRydW5jYXRlZC4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHRoZQotCSAqIHNwZWNpZmllZCBjaGFyYWN0ZXIgYXQgdGhlIGVuZC4KLQkgKiBTdHJpbmcjcGFkT3JUcnVuY2F0ZU9uKGludCwgY2hhciwgV3JpdGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBwYWRPclRydW5jYXRlT24oY2hhcltdIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoOwotCQlpZiAoc3RyaW5nTGVuZ3RoID09IGxlbmd0aCkgewotCQkJd3JpdGVTdHJpbmdPbihzdHJpbmcsIHdyaXRlcik7Ci0JCX0gZWxzZSBpZiAoc3RyaW5nTGVuZ3RoID4gbGVuZ3RoKSB7Ci0JCQl3cml0ZVN0cmluZ09uKHN0cmluZywgMCwgbGVuZ3RoLCB3cml0ZXIpOwotCQl9IGVsc2UgewotCQkJcGFkT25fKHN0cmluZywgbGVuZ3RoLCBjLCB3cml0ZXIpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUGFkIG9yIHRydW5jYXRlIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyB0cnVuY2F0ZWQuCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB0aGUKLQkgKiBzcGVjaWZpZWQgY2hhcmFjdGVyIGF0IHRoZSBlbmQuCi0JICogU3RyaW5nI3BhZE9yVHJ1bmNhdGVPbihpbnQsIGNoYXIsIFN0cmluZ0J1ZmZlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcGFkT3JUcnVuY2F0ZU9uKGNoYXJbXSBzdHJpbmcsIGludCBsZW5ndGgsIGNoYXIgYywgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoOwotCQlpZiAoc3RyaW5nTGVuZ3RoID09IGxlbmd0aCkgewotCQkJc2IuYXBwZW5kKHN0cmluZyk7Ci0JCX0gZWxzZSBpZiAoc3RyaW5nTGVuZ3RoID4gbGVuZ3RoKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nLCAwLCBsZW5ndGgpOwotCQl9IGVsc2UgewotCQkJcGFkT25fKHN0cmluZywgbGVuZ3RoLCBjLCBzYik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBQYWQgb3IgdHJ1bmNhdGUgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHRydW5jYXRlZC4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHRoZQotCSAqIHNwZWNpZmllZCBjaGFyYWN0ZXIgYXQgdGhlIGVuZC4KLQkgKiBTdHJpbmcjcGFkT3JUcnVuY2F0ZU9uKGludCwgY2hhciwgU3RyaW5nQnVpbGRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcGFkT3JUcnVuY2F0ZU9uKGNoYXJbXSBzdHJpbmcsIGludCBsZW5ndGgsIGNoYXIgYywgU3RyaW5nQnVpbGRlciBzYikgewotCQlpbnQgc3RyaW5nTGVuZ3RoID0gc3RyaW5nLmxlbmd0aDsKLQkJaWYgKHN0cmluZ0xlbmd0aCA9PSBsZW5ndGgpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcpOwotCQl9IGVsc2UgaWYgKHN0cmluZ0xlbmd0aCA+IGxlbmd0aCkgewotCQkJc2IuYXBwZW5kKHN0cmluZywgMCwgbGVuZ3RoKTsKLQkJfSBlbHNlIHsKLQkJCXBhZE9uXyhzdHJpbmcsIGxlbmd0aCwgYywgc2IpOwotCQl9Ci0JfQotCi0JLyoKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgd2l0aG91dCB2YWxpZGF0aW5nIHRoZSBwYXJtcy4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBTdHJpbmcgcGFkXyhTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMpIHsKLQkJcmV0dXJuIG5ldyBTdHJpbmcocGFkXyhzdHJpbmcudG9DaGFyQXJyYXkoKSwgbGVuZ3RoLCBjKSk7Ci0JfQotCi0JLyoKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgd2l0aG91dCB2YWxpZGF0aW5nIHRoZSBwYXJtcy4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIHBhZE9uXyhTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFdyaXRlciB3cml0ZXIpIHsKLQkJd3JpdGVTdHJpbmdPbihzdHJpbmcsIHdyaXRlcik7Ci0JCWZpbGxfKHN0cmluZywgbGVuZ3RoLCBjLCB3cml0ZXIpOwotCX0KLQotCS8qCi0JICogQWRkIGVub3VnaCBjaGFyYWN0ZXJzIHRvIHRoZSBzcGVjaWZpZWQgd3JpdGVyIHRvIGNvbXBlbnNhdGUgZm9yCi0JICogdGhlIGRpZmZlcmVuY2UgYmV0d2VlbiB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIGZpbGxfKFN0cmluZyBzdHJpbmcsIGludCBsZW5ndGgsIGNoYXIgYywgV3JpdGVyIHdyaXRlcikgewotCQlmaWxsXyhzdHJpbmcubGVuZ3RoKCksIGxlbmd0aCwgYywgd3JpdGVyKTsKLQl9Ci0KLQkvKgotCSAqIEFkZCBlbm91Z2ggY2hhcmFjdGVycyB0byB0aGUgc3BlY2lmaWVkIHdyaXRlciB0byBjb21wZW5zYXRlIGZvcgotCSAqIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4gdGhlIHNwZWNpZmllZCBzdHJpbmcgYW5kIHNwZWNpZmllZCBsZW5ndGguCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBmaWxsXyhjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFdyaXRlciB3cml0ZXIpIHsKLQkJZmlsbF8oc3RyaW5nLmxlbmd0aCwgbGVuZ3RoLCBjLCB3cml0ZXIpOwotCX0KLQotCS8qCi0JICogQWRkIGVub3VnaCBjaGFyYWN0ZXJzIHRvIHRoZSBzcGVjaWZpZWQgd3JpdGVyIHRvIGNvbXBlbnNhdGUgZm9yCi0JICogdGhlIGRpZmZlcmVuY2UgYmV0d2VlbiB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIGZpbGxfKGludCBzdHJpbmdMZW5ndGgsIGludCBsZW5ndGgsIGNoYXIgYywgV3JpdGVyIHdyaXRlcikgewotCQl3cml0ZVN0cmluZ09uKENvbGxlY3Rpb25Ub29scy5maWxsKG5ldyBjaGFyW2xlbmd0aCAtIHN0cmluZ0xlbmd0aF0sIGMpLCB3cml0ZXIpOwotCX0KLQotCS8qCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGhvdXQgdmFsaWRhdGluZyB0aGUgcGFybXMuCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBwYWRPbl8oU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJc2IuYXBwZW5kKHN0cmluZyk7Ci0JCWZpbGxfKHN0cmluZywgbGVuZ3RoLCBjLCBzYik7Ci0JfQotCi0JLyoKLQkgKiBBZGQgZW5vdWdoIGNoYXJhY3RlcnMgdG8gdGhlIHNwZWNpZmllZCBzdHJpbmcgYnVmZmVyIHRvIGNvbXBlbnNhdGUgZm9yCi0JICogdGhlIGRpZmZlcmVuY2UgYmV0d2VlbiB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIGZpbGxfKFN0cmluZyBzdHJpbmcsIGludCBsZW5ndGgsIGNoYXIgYywgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWZpbGxfKHN0cmluZy5sZW5ndGgoKSwgbGVuZ3RoLCBjLCBzYik7Ci0JfQotCi0JLyoKLQkgKiBBZGQgZW5vdWdoIGNoYXJhY3RlcnMgdG8gdGhlIHNwZWNpZmllZCBzdHJpbmcgYnVmZmVyIHRvIGNvbXBlbnNhdGUgZm9yCi0JICogdGhlIGRpZmZlcmVuY2UgYmV0d2VlbiB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIGZpbGxfKGNoYXJbXSBzdHJpbmcsIGludCBsZW5ndGgsIGNoYXIgYywgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWZpbGxfKHN0cmluZy5sZW5ndGgsIGxlbmd0aCwgYywgc2IpOwotCX0KLQotCS8qCi0JICogQWRkIGVub3VnaCBjaGFyYWN0ZXJzIHRvIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGJ1ZmZlciB0byBjb21wZW5zYXRlIGZvcgotCSAqIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4gdGhlIHNwZWNpZmllZCBzdHJpbmcgYW5kIHNwZWNpZmllZCBsZW5ndGguCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBmaWxsXyhpbnQgc3RyaW5nTGVuZ3RoLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFN0cmluZ0J1ZmZlciBzYikgewotCQlzYi5hcHBlbmQoQ29sbGVjdGlvblRvb2xzLmZpbGwobmV3IGNoYXJbbGVuZ3RoIC0gc3RyaW5nTGVuZ3RoXSwgYykpOwotCX0KLQotCS8qCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGhvdXQgdmFsaWRhdGluZyB0aGUgcGFybXMuCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBwYWRPbl8oU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXNiLmFwcGVuZChzdHJpbmcpOwotCQlmaWxsXyhzdHJpbmcsIGxlbmd0aCwgYywgc2IpOwotCX0KLQotCS8qCi0JICogQWRkIGVub3VnaCBjaGFyYWN0ZXJzIHRvIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGJ1aWxkZXIgdG8gY29tcGVuc2F0ZSBmb3IKLQkgKiB0aGUgZGlmZmVyZW5jZSBiZXR3ZWVuIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGFuZCBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqLwotCXByaXZhdGUgc3RhdGljIHZvaWQgZmlsbF8oU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWZpbGxfKHN0cmluZy5sZW5ndGgoKSwgbGVuZ3RoLCBjLCBzYik7Ci0JfQotCi0JLyoKLQkgKiBBZGQgZW5vdWdoIGNoYXJhY3RlcnMgdG8gdGhlIHNwZWNpZmllZCBzdHJpbmcgYnVpbGRlciB0byBjb21wZW5zYXRlIGZvcgotCSAqIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4gdGhlIHNwZWNpZmllZCBzdHJpbmcgYW5kIHNwZWNpZmllZCBsZW5ndGguCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBmaWxsXyhjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJZmlsbF8oc3RyaW5nLmxlbmd0aCwgbGVuZ3RoLCBjLCBzYik7Ci0JfQotCi0JLyoKLQkgKiBBZGQgZW5vdWdoIGNoYXJhY3RlcnMgdG8gdGhlIHNwZWNpZmllZCBzdHJpbmcgYnVpbGRlciB0byBjb21wZW5zYXRlIGZvcgotCSAqIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4gdGhlIHNwZWNpZmllZCBzdHJpbmcgYW5kIHNwZWNpZmllZCBsZW5ndGguCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBmaWxsXyhpbnQgc3RyaW5nTGVuZ3RoLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJc2IuYXBwZW5kKENvbGxlY3Rpb25Ub29scy5maWxsKG5ldyBjaGFyW2xlbmd0aCAtIHN0cmluZ0xlbmd0aF0sIGMpKTsKLQl9Ci0KLQkvKgotCSAqIFBhZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRob3V0IHZhbGlkYXRpbmcgdGhlIHBhcm1zLgotCSAqLwotCXByaXZhdGUgc3RhdGljIGNoYXJbXSBwYWRfKGNoYXJbXSBzdHJpbmcsIGludCBsZW5ndGgsIGNoYXIgYykgewotCQljaGFyW10gcmVzdWx0ID0gbmV3IGNoYXJbbGVuZ3RoXTsKLQkJaW50IHN0cmluZ0xlbmd0aCA9IHN0cmluZy5sZW5ndGg7Ci0JCVN5c3RlbS5hcnJheWNvcHkoc3RyaW5nLCAwLCByZXN1bHQsIDAsIHN0cmluZ0xlbmd0aCk7Ci0JCUFycmF5cy5maWxsKHJlc3VsdCwgc3RyaW5nTGVuZ3RoLCBsZW5ndGgsIGMpOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGhvdXQgdmFsaWRhdGluZyB0aGUgcGFybXMuCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBwYWRPbl8oY2hhcltdIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCXdyaXRlU3RyaW5nT24oc3RyaW5nLCB3cml0ZXIpOwotCQlmaWxsXyhzdHJpbmcsIGxlbmd0aCwgYywgd3JpdGVyKTsKLQl9Ci0KLQkvKgotCSAqIFBhZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRob3V0IHZhbGlkYXRpbmcgdGhlIHBhcm1zLgotCSAqLwotCXByaXZhdGUgc3RhdGljIHZvaWQgcGFkT25fKGNoYXJbXSBzdHJpbmcsIGludCBsZW5ndGgsIGNoYXIgYywgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCXNiLmFwcGVuZChzdHJpbmcpOwotCQlmaWxsXyhzdHJpbmcsIGxlbmd0aCwgYywgc2IpOwotCX0KLQotCS8qCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGhvdXQgdmFsaWRhdGluZyB0aGUgcGFybXMuCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBwYWRPbl8oY2hhcltdIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXNiLmFwcGVuZChzdHJpbmcpOwotCQlmaWxsXyhzdHJpbmcsIGxlbmd0aCwgYywgc2IpOwotCX0KLQotCS8qKgotCSAqIFBhZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgYW4gSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGlzIHRocm93bi4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHplcm9zIGF0IHRoZSBmcm9udC4KLQkgKiBTdHJpbmcjemVyb1BhZChpbnQpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgemVyb1BhZChTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoKSB7Ci0JCXJldHVybiBmcm9udFBhZChzdHJpbmcsIGxlbmd0aCwgJzAnKTsKLQl9Ci0KLQkvKioKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpcyB0aHJvd24uCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB6ZXJvcyBhdCB0aGUgZnJvbnQuCi0JICogU3RyaW5nI3plcm9QYWRPbihpbnQsIFdyaXRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgemVyb1BhZE9uKFN0cmluZyBzdHJpbmcsIGludCBsZW5ndGgsIFdyaXRlciB3cml0ZXIpIHsKLQkJZnJvbnRQYWRPbihzdHJpbmcsIGxlbmd0aCwgJzAnLCB3cml0ZXIpOwotCX0KLQotCS8qKgotCSAqIFBhZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgYW4gSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGlzIHRocm93bi4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHplcm9zIGF0IHRoZSBmcm9udC4KLQkgKiBTdHJpbmcjemVyb1BhZE9uKGludCwgU3RyaW5nQnVmZmVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCB6ZXJvUGFkT24oU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCwgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWZyb250UGFkT24oc3RyaW5nLCBsZW5ndGgsICcwJywgc2IpOwotCX0KLQotCS8qKgotCSAqIFBhZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgYW4gSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGlzIHRocm93bi4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHplcm9zIGF0IHRoZSBmcm9udC4KLQkgKiBTdHJpbmcjemVyb1BhZE9uKGludCwgU3RyaW5nQnVpbGRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgemVyb1BhZE9uKFN0cmluZyBzdHJpbmcsIGludCBsZW5ndGgsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJZnJvbnRQYWRPbihzdHJpbmcsIGxlbmd0aCwgJzAnLCBzYik7Ci0JfQotCi0JLyoqCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBhbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaXMgdGhyb3duLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggdGhlCi0JICogc3BlY2lmaWVkIGNoYXJhY3RlciBhdCB0aGUgZnJvbnQuCi0JICogU3RyaW5nI2Zyb250UGFkKGludCwgY2hhcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBmcm9udFBhZChTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMpIHsKLQkJaW50IHN0cmluZ0xlbmd0aCA9IHN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKHN0cmluZ0xlbmd0aCA+IGxlbmd0aCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiU3RyaW5nIGlzIHRvbyBsb25nOiAiICsgc3RyaW5nTGVuZ3RoICsgIiA+ICIgKyBsZW5ndGgpOyAgLy8kTk9OLU5MUy0xJCAgLy8kTk9OLU5MUy0yJAotCQl9Ci0JCWlmIChzdHJpbmdMZW5ndGggPT0gbGVuZ3RoKSB7Ci0JCQlyZXR1cm4gc3RyaW5nOwotCQl9Ci0JCXJldHVybiBmcm9udFBhZF8oc3RyaW5nLCBsZW5ndGgsIGMpOwotCX0KLQotCS8qKgotCSAqIFBhZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgYW4gSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGlzIHRocm93bi4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHRoZQotCSAqIHNwZWNpZmllZCBjaGFyYWN0ZXIgYXQgdGhlIGZyb250LgotCSAqIFN0cmluZyNmcm9udFBhZE9uKGludCwgY2hhciwgV3JpdGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBmcm9udFBhZE9uKFN0cmluZyBzdHJpbmcsIGludCBsZW5ndGgsIGNoYXIgYywgV3JpdGVyIHdyaXRlcikgewotCQlpbnQgc3RyaW5nTGVuZ3RoID0gc3RyaW5nLmxlbmd0aCgpOwotCQlpZiAoc3RyaW5nTGVuZ3RoID4gbGVuZ3RoKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJTdHJpbmcgaXMgdG9vIGxvbmc6ICIgKyBzdHJpbmdMZW5ndGggKyAiID4gIiArIGxlbmd0aCk7ICAvLyROT04tTkxTLTEkICAvLyROT04tTkxTLTIkCi0JCX0KLQkJaWYgKHN0cmluZ0xlbmd0aCA9PSBsZW5ndGgpIHsKLQkJCXdyaXRlU3RyaW5nT24oc3RyaW5nLCB3cml0ZXIpOwotCQl9IGVsc2UgewotCQkJZnJvbnRQYWRPbl8oc3RyaW5nLCBsZW5ndGgsIGMsIHdyaXRlcik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpcyB0aHJvd24uCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB0aGUKLQkgKiBzcGVjaWZpZWQgY2hhcmFjdGVyIGF0IHRoZSBmcm9udC4KLQkgKiBTdHJpbmcjZnJvbnRQYWRPbihpbnQsIGNoYXIsIFN0cmluZ0J1ZmZlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgZnJvbnRQYWRPbihTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFN0cmluZ0J1ZmZlciBzYikgewotCQlpbnQgc3RyaW5nTGVuZ3RoID0gc3RyaW5nLmxlbmd0aCgpOwotCQlpZiAoc3RyaW5nTGVuZ3RoID4gbGVuZ3RoKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJTdHJpbmcgaXMgdG9vIGxvbmc6ICIgKyBzdHJpbmdMZW5ndGggKyAiID4gIiArIGxlbmd0aCk7ICAvLyROT04tTkxTLTEkICAvLyROT04tTkxTLTIkCi0JCX0KLQkJaWYgKHN0cmluZ0xlbmd0aCA9PSBsZW5ndGgpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcpOwotCQl9IGVsc2UgewotCQkJZnJvbnRQYWRPbl8oc3RyaW5nLCBsZW5ndGgsIGMsIHNiKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFBhZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgYW4gSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGlzIHRocm93bi4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHRoZQotCSAqIHNwZWNpZmllZCBjaGFyYWN0ZXIgYXQgdGhlIGZyb250LgotCSAqIFN0cmluZyNmcm9udFBhZE9uKGludCwgY2hhciwgU3RyaW5nQnVpbGRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgZnJvbnRQYWRPbihTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJaW50IHN0cmluZ0xlbmd0aCA9IHN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKHN0cmluZ0xlbmd0aCA+IGxlbmd0aCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiU3RyaW5nIGlzIHRvbyBsb25nOiAiICsgc3RyaW5nTGVuZ3RoICsgIiA+ICIgKyBsZW5ndGgpOyAgLy8kTk9OLU5MUy0xJCAgLy8kTk9OLU5MUy0yJAotCQl9Ci0JCWlmIChzdHJpbmdMZW5ndGggPT0gbGVuZ3RoKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQkJfSBlbHNlIHsKLQkJCWZyb250UGFkT25fKHN0cmluZywgbGVuZ3RoLCBjLCBzYik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpcyB0aHJvd24uCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB6ZXJvcyBhdCB0aGUgZnJvbnQuCi0JICogU3RyaW5nI3plcm9QYWQoaW50KQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIHplcm9QYWQoY2hhcltdIHN0cmluZywgaW50IGxlbmd0aCkgewotCQlyZXR1cm4gZnJvbnRQYWQoc3RyaW5nLCBsZW5ndGgsICcwJyk7Ci0JfQotCi0JLyoqCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBhbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaXMgdGhyb3duLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggemVyb3MgYXQgdGhlIGZyb250LgotCSAqIFN0cmluZyN6ZXJvUGFkT24oaW50LCBXcml0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHplcm9QYWRPbihjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWZyb250UGFkT24oc3RyaW5nLCBsZW5ndGgsICcwJywgd3JpdGVyKTsKLQl9Ci0KLQkvKioKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpcyB0aHJvd24uCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB6ZXJvcyBhdCB0aGUgZnJvbnQuCi0JICogU3RyaW5nI3plcm9QYWRPbihpbnQsIFN0cmluZ0J1ZmZlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgemVyb1BhZE9uKGNoYXJbXSBzdHJpbmcsIGludCBsZW5ndGgsIFN0cmluZ0J1ZmZlciBzYikgewotCQlmcm9udFBhZE9uKHN0cmluZywgbGVuZ3RoLCAnMCcsIHNiKTsKLQl9Ci0KLQkvKioKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpcyB0aHJvd24uCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB6ZXJvcyBhdCB0aGUgZnJvbnQuCi0JICogU3RyaW5nI3plcm9QYWRPbihpbnQsIFN0cmluZ0J1aWxkZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHplcm9QYWRPbihjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWZyb250UGFkT24oc3RyaW5nLCBsZW5ndGgsICcwJywgc2IpOwotCX0KLQotCS8qKgotCSAqIFBhZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgYW4gSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGlzIHRocm93bi4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHRoZQotCSAqIHNwZWNpZmllZCBjaGFyYWN0ZXIgYXQgdGhlIGZyb250LgotCSAqIFN0cmluZyNmcm9udFBhZChpbnQsIGNoYXIpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gZnJvbnRQYWQoY2hhcltdIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjKSB7Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoOwotCQlpZiAoc3RyaW5nTGVuZ3RoID4gbGVuZ3RoKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJTdHJpbmcgaXMgdG9vIGxvbmc6ICIgKyBzdHJpbmdMZW5ndGggKyAiID4gIiArIGxlbmd0aCk7ICAvLyROT04tTkxTLTEkICAvLyROT04tTkxTLTIkCi0JCX0KLQkJaWYgKHN0cmluZ0xlbmd0aCA9PSBsZW5ndGgpIHsKLQkJCXJldHVybiBzdHJpbmc7Ci0JCX0KLQkJcmV0dXJuIGZyb250UGFkXyhzdHJpbmcsIGxlbmd0aCwgYyk7Ci0JfQotCi0JLyoqCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBhbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaXMgdGhyb3duLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggdGhlCi0JICogc3BlY2lmaWVkIGNoYXJhY3RlciBhdCB0aGUgZnJvbnQuCi0JICogU3RyaW5nI2Zyb250UGFkT24oaW50LCBjaGFyLCBXcml0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGZyb250UGFkT24oY2hhcltdIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoOwotCQlpZiAoc3RyaW5nTGVuZ3RoID4gbGVuZ3RoKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJTdHJpbmcgaXMgdG9vIGxvbmc6ICIgKyBzdHJpbmdMZW5ndGggKyAiID4gIiArIGxlbmd0aCk7ICAvLyROT04tTkxTLTEkICAvLyROT04tTkxTLTIkCi0JCX0KLQkJaWYgKHN0cmluZ0xlbmd0aCA9PSBsZW5ndGgpIHsKLQkJCXdyaXRlU3RyaW5nT24oc3RyaW5nLCB3cml0ZXIpOwotCQl9IGVsc2UgewotCQkJZnJvbnRQYWRPbl8oc3RyaW5nLCBsZW5ndGgsIGMsIHdyaXRlcik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpcyB0aHJvd24uCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB0aGUKLQkgKiBzcGVjaWZpZWQgY2hhcmFjdGVyIGF0IHRoZSBmcm9udC4KLQkgKiBTdHJpbmcjZnJvbnRQYWRPbihpbnQsIGNoYXIsIFN0cmluZ0J1ZmZlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgZnJvbnRQYWRPbihjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFN0cmluZ0J1ZmZlciBzYikgewotCQlpbnQgc3RyaW5nTGVuZ3RoID0gc3RyaW5nLmxlbmd0aDsKLQkJaWYgKHN0cmluZ0xlbmd0aCA+IGxlbmd0aCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiU3RyaW5nIGlzIHRvbyBsb25nOiAiICsgc3RyaW5nTGVuZ3RoICsgIiA+ICIgKyBsZW5ndGgpOyAgLy8kTk9OLU5MUy0xJCAgLy8kTk9OLU5MUy0yJAotCQl9Ci0JCWlmIChzdHJpbmdMZW5ndGggPT0gbGVuZ3RoKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQkJfSBlbHNlIHsKLQkJCWZyb250UGFkT25fKHN0cmluZywgbGVuZ3RoLCBjLCBzYik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpcyB0aHJvd24uCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB0aGUKLQkgKiBzcGVjaWZpZWQgY2hhcmFjdGVyIGF0IHRoZSBmcm9udC4KLQkgKiBTdHJpbmcjZnJvbnRQYWRPbihpbnQsIGNoYXIsIFN0cmluZ0J1aWxkZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGZyb250UGFkT24oY2hhcltdIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoOwotCQlpZiAoc3RyaW5nTGVuZ3RoID4gbGVuZ3RoKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJTdHJpbmcgaXMgdG9vIGxvbmc6ICIgKyBzdHJpbmdMZW5ndGggKyAiID4gIiArIGxlbmd0aCk7ICAvLyROT04tTkxTLTEkICAvLyROT04tTkxTLTIkCi0JCX0KLQkJaWYgKHN0cmluZ0xlbmd0aCA9PSBsZW5ndGgpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcpOwotCQl9IGVsc2UgewotCQkJZnJvbnRQYWRPbl8oc3RyaW5nLCBsZW5ndGgsIGMsIHNiKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFBhZCBvciB0cnVuY2F0ZSB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgb25seSB0aGUgbGFzdCBwYXJ0IG9mIHRoZSBzdHJpbmcgaXMgcmV0dXJuZWQuCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB6ZXJvcyBhdCB0aGUgZnJvbnQuCi0JICogU3RyaW5nI3plcm9QYWRPclRydW5jYXRlKGludCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyB6ZXJvUGFkT3JUcnVuY2F0ZShTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoKSB7Ci0JCXJldHVybiBmcm9udFBhZE9yVHJ1bmNhdGUoc3RyaW5nLCBsZW5ndGgsICcwJyk7Ci0JfQotCi0JLyoqCi0JICogUGFkIG9yIHRydW5jYXRlIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBvbmx5IHRoZSBsYXN0IHBhcnQgb2YgdGhlIHN0cmluZyBpcyByZXR1cm5lZC4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHplcm9zIGF0IHRoZSBmcm9udC4KLQkgKiBTdHJpbmcjemVyb1BhZE9yVHJ1bmNhdGVPbihpbnQsIFdyaXRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgemVyb1BhZE9yVHJ1bmNhdGVPbihTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWZyb250UGFkT3JUcnVuY2F0ZU9uKHN0cmluZywgbGVuZ3RoLCAnMCcsIHdyaXRlcik7Ci0JfQotCi0JLyoqCi0JICogUGFkIG9yIHRydW5jYXRlIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBvbmx5IHRoZSBsYXN0IHBhcnQgb2YgdGhlIHN0cmluZyBpcyByZXR1cm5lZC4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHplcm9zIGF0IHRoZSBmcm9udC4KLQkgKiBTdHJpbmcjemVyb1BhZE9yVHJ1bmNhdGVPbihpbnQsIFN0cmluZ0J1ZmZlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgemVyb1BhZE9yVHJ1bmNhdGVPbihTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJZnJvbnRQYWRPclRydW5jYXRlT24oc3RyaW5nLCBsZW5ndGgsICcwJywgc2IpOwotCX0KLQotCS8qKgotCSAqIFBhZCBvciB0cnVuY2F0ZSB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgb25seSB0aGUgbGFzdCBwYXJ0IG9mIHRoZSBzdHJpbmcgaXMgcmV0dXJuZWQuCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB6ZXJvcyBhdCB0aGUgZnJvbnQuCi0JICogU3RyaW5nI3plcm9QYWRPclRydW5jYXRlT24oaW50LCBTdHJpbmdCdWlsZGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCB6ZXJvUGFkT3JUcnVuY2F0ZU9uKFN0cmluZyBzdHJpbmcsIGludCBsZW5ndGgsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJZnJvbnRQYWRPclRydW5jYXRlT24oc3RyaW5nLCBsZW5ndGgsICcwJywgc2IpOwotCX0KLQotCS8qKgotCSAqIFBhZCBvciB0cnVuY2F0ZSB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgb25seSB0aGUgbGFzdCBwYXJ0IG9mIHRoZSBzdHJpbmcgaXMgcmV0dXJuZWQuCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB0aGUKLQkgKiBzcGVjaWZpZWQgY2hhcmFjdGVyIGF0IHRoZSBmcm9udC4KLQkgKiBTdHJpbmcjZnJvbnRQYWRPclRydW5jYXRlKGludCwgY2hhcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBmcm9udFBhZE9yVHJ1bmNhdGUoU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjKSB7Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoKCk7Ci0JCWlmIChzdHJpbmdMZW5ndGggPT0gbGVuZ3RoKSB7Ci0JCQlyZXR1cm4gc3RyaW5nOwotCQl9Ci0JCWlmIChzdHJpbmdMZW5ndGggPiBsZW5ndGgpIHsKLQkJCXJldHVybiBzdHJpbmcuc3Vic3RyaW5nKHN0cmluZ0xlbmd0aCAtIGxlbmd0aCk7Ci0JCX0KLQkJcmV0dXJuIGZyb250UGFkXyhzdHJpbmcsIGxlbmd0aCwgYyk7Ci0JfQotCi0JLyoqCi0JICogUGFkIG9yIHRydW5jYXRlIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBvbmx5IHRoZSBsYXN0IHBhcnQgb2YgdGhlIHN0cmluZyBpcyByZXR1cm5lZC4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHRoZQotCSAqIHNwZWNpZmllZCBjaGFyYWN0ZXIgYXQgdGhlIGZyb250LgotCSAqIFN0cmluZyNmcm9udFBhZE9yVHJ1bmNhdGVPbihpbnQsIGNoYXIsIFdyaXRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgZnJvbnRQYWRPclRydW5jYXRlT24oU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoKCk7Ci0JCWlmIChzdHJpbmdMZW5ndGggPT0gbGVuZ3RoKSB7Ci0JCQl3cml0ZVN0cmluZ09uKHN0cmluZywgd3JpdGVyKTsKLQkJfSBlbHNlIGlmIChzdHJpbmdMZW5ndGggPiBsZW5ndGgpIHsKLQkJCXdyaXRlU3RyaW5nT24oc3RyaW5nLnN1YnN0cmluZyhzdHJpbmdMZW5ndGggLSBsZW5ndGgpLCB3cml0ZXIpOwotCQl9IGVsc2UgewotCQkJZnJvbnRQYWRPbl8oc3RyaW5nLCBsZW5ndGgsIGMsIHdyaXRlcik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBQYWQgb3IgdHJ1bmNhdGUgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIG9ubHkgdGhlIGxhc3QgcGFydCBvZiB0aGUgc3RyaW5nIGlzIHJldHVybmVkLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggdGhlCi0JICogc3BlY2lmaWVkIGNoYXJhY3RlciBhdCB0aGUgZnJvbnQuCi0JICogU3RyaW5nI2Zyb250UGFkT3JUcnVuY2F0ZU9uKGludCwgY2hhciwgU3RyaW5nQnVmZmVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBmcm9udFBhZE9yVHJ1bmNhdGVPbihTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFN0cmluZ0J1ZmZlciBzYikgewotCQlpbnQgc3RyaW5nTGVuZ3RoID0gc3RyaW5nLmxlbmd0aCgpOwotCQlpZiAoc3RyaW5nTGVuZ3RoID09IGxlbmd0aCkgewotCQkJc2IuYXBwZW5kKHN0cmluZyk7Ci0JCX0gZWxzZSBpZiAoc3RyaW5nTGVuZ3RoID4gbGVuZ3RoKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nLnN1YnN0cmluZyhzdHJpbmdMZW5ndGggLSBsZW5ndGgpKTsKLQkJfSBlbHNlIHsKLQkJCWZyb250UGFkT25fKHN0cmluZywgbGVuZ3RoLCBjLCBzYik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBQYWQgb3IgdHJ1bmNhdGUgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICogSWYgdGhlIHN0cmluZyBpcyBhbHJlYWR5IHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCi0JICogSWYgaXQgaXMgbG9uZ2VyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIG9ubHkgdGhlIGxhc3QgcGFydCBvZiB0aGUgc3RyaW5nIGlzIHJldHVybmVkLgotCSAqIElmIGl0IGlzIHNob3J0ZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcGFkZGVkIHdpdGggdGhlCi0JICogc3BlY2lmaWVkIGNoYXJhY3RlciBhdCB0aGUgZnJvbnQuCi0JICogU3RyaW5nI2Zyb250UGFkT3JUcnVuY2F0ZU9uKGludCwgY2hhciwgU3RyaW5nQnVpbGRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgZnJvbnRQYWRPclRydW5jYXRlT24oU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoKCk7Ci0JCWlmIChzdHJpbmdMZW5ndGggPT0gbGVuZ3RoKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQkJfSBlbHNlIGlmIChzdHJpbmdMZW5ndGggPiBsZW5ndGgpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcuc3Vic3RyaW5nKHN0cmluZ0xlbmd0aCAtIGxlbmd0aCkpOwotCQl9IGVsc2UgewotCQkJZnJvbnRQYWRPbl8oc3RyaW5nLCBsZW5ndGgsIGMsIHNiKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFBhZCBvciB0cnVuY2F0ZSB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgb25seSB0aGUgbGFzdCBwYXJ0IG9mIHRoZSBzdHJpbmcgaXMgcmV0dXJuZWQuCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB6ZXJvcyBhdCB0aGUgZnJvbnQuCi0JICogU3RyaW5nI3plcm9QYWRPclRydW5jYXRlKGludCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXJbXSB6ZXJvUGFkT3JUcnVuY2F0ZShjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoKSB7Ci0JCXJldHVybiBmcm9udFBhZE9yVHJ1bmNhdGUoc3RyaW5nLCBsZW5ndGgsICcwJyk7Ci0JfQotCi0JLyoqCi0JICogUGFkIG9yIHRydW5jYXRlIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBvbmx5IHRoZSBsYXN0IHBhcnQgb2YgdGhlIHN0cmluZyBpcyByZXR1cm5lZC4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHplcm9zIGF0IHRoZSBmcm9udC4KLQkgKiBTdHJpbmcjemVyb1BhZE9yVHJ1bmNhdGVPbihpbnQsIFdyaXRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgemVyb1BhZE9yVHJ1bmNhdGVPbihjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWZyb250UGFkT3JUcnVuY2F0ZU9uKHN0cmluZywgbGVuZ3RoLCAnMCcsIHdyaXRlcik7Ci0JfQotCi0JLyoqCi0JICogUGFkIG9yIHRydW5jYXRlIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBvbmx5IHRoZSBsYXN0IHBhcnQgb2YgdGhlIHN0cmluZyBpcyByZXR1cm5lZC4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHplcm9zIGF0IHRoZSBmcm9udC4KLQkgKiBTdHJpbmcjemVyb1BhZE9yVHJ1bmNhdGVPbihpbnQsIFN0cmluZ0J1ZmZlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgemVyb1BhZE9yVHJ1bmNhdGVPbihjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJZnJvbnRQYWRPclRydW5jYXRlT24oc3RyaW5nLCBsZW5ndGgsICcwJywgc2IpOwotCX0KLQotCS8qKgotCSAqIFBhZCBvciB0cnVuY2F0ZSB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgb25seSB0aGUgbGFzdCBwYXJ0IG9mIHRoZSBzdHJpbmcgaXMgcmV0dXJuZWQuCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB6ZXJvcyBhdCB0aGUgZnJvbnQuCi0JICogU3RyaW5nI3plcm9QYWRPclRydW5jYXRlT24oaW50LCBTdHJpbmdCdWlsZGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCB6ZXJvUGFkT3JUcnVuY2F0ZU9uKGNoYXJbXSBzdHJpbmcsIGludCBsZW5ndGgsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJZnJvbnRQYWRPclRydW5jYXRlT24oc3RyaW5nLCBsZW5ndGgsICcwJywgc2IpOwotCX0KLQotCS8qKgotCSAqIFBhZCBvciB0cnVuY2F0ZSB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgb25seSB0aGUgbGFzdCBwYXJ0IG9mIHRoZSBzdHJpbmcgaXMgcmV0dXJuZWQuCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB0aGUgCi0JICogc3BlY2lmaWVkIGNoYXJhY3RlciBhdCB0aGUgZnJvbnQuCi0JICogU3RyaW5nI2Zyb250UGFkT3JUcnVuY2F0ZShpbnQsIGNoYXIpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gZnJvbnRQYWRPclRydW5jYXRlKGNoYXJbXSBzdHJpbmcsIGludCBsZW5ndGgsIGNoYXIgYykgewotCQlpbnQgc3RyaW5nTGVuZ3RoID0gc3RyaW5nLmxlbmd0aDsKLQkJaWYgKHN0cmluZ0xlbmd0aCA9PSBsZW5ndGgpIHsKLQkJCXJldHVybiBzdHJpbmc7Ci0JCX0KLQkJaWYgKHN0cmluZ0xlbmd0aCA+IGxlbmd0aCkgewotCQkJY2hhcltdIHJlc3VsdCA9IG5ldyBjaGFyW2xlbmd0aF07Ci0JCQlTeXN0ZW0uYXJyYXljb3B5KHN0cmluZywgc3RyaW5nTGVuZ3RoIC0gbGVuZ3RoLCByZXN1bHQsIDAsIGxlbmd0aCk7Ci0JCQlyZXR1cm4gcmVzdWx0OwotCQl9Ci0JCXJldHVybiBmcm9udFBhZF8oc3RyaW5nLCBsZW5ndGgsIGMpOwotCX0KLQotCS8qKgotCSAqIFBhZCBvciB0cnVuY2F0ZSB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHJldHVybmVkIHVuY2hhbmdlZC4KLQkgKiBJZiBpdCBpcyBsb25nZXIgdGhhbiB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgb25seSB0aGUgbGFzdCBwYXJ0IG9mIHRoZSBzdHJpbmcgaXMgcmV0dXJuZWQuCi0JICogSWYgaXQgaXMgc2hvcnRlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBpdCBpcyBwYWRkZWQgd2l0aCB0aGUgCi0JICogc3BlY2lmaWVkIGNoYXJhY3RlciBhdCB0aGUgZnJvbnQuCi0JICogU3RyaW5nI2Zyb250UGFkT3JUcnVuY2F0ZU9uKGludCwgY2hhciwgV3JpdGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBmcm9udFBhZE9yVHJ1bmNhdGVPbihjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFdyaXRlciB3cml0ZXIpIHsKLQkJaW50IHN0cmluZ0xlbmd0aCA9IHN0cmluZy5sZW5ndGg7Ci0JCWlmIChzdHJpbmdMZW5ndGggPT0gbGVuZ3RoKSB7Ci0JCQl3cml0ZVN0cmluZ09uKHN0cmluZywgd3JpdGVyKTsKLQkJfSBlbHNlIGlmIChzdHJpbmdMZW5ndGggPiBsZW5ndGgpIHsKLQkJCXdyaXRlU3RyaW5nT24oc3RyaW5nLCBzdHJpbmdMZW5ndGggLSBsZW5ndGgsIGxlbmd0aCwgd3JpdGVyKTsKLQkJfSBlbHNlIHsKLQkJCWZyb250UGFkT25fKHN0cmluZywgbGVuZ3RoLCBjLCB3cml0ZXIpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUGFkIG9yIHRydW5jYXRlIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBvbmx5IHRoZSBsYXN0IHBhcnQgb2YgdGhlIHN0cmluZyBpcyByZXR1cm5lZC4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHRoZSAKLQkgKiBzcGVjaWZpZWQgY2hhcmFjdGVyIGF0IHRoZSBmcm9udC4KLQkgKiBTdHJpbmcjZnJvbnRQYWRPclRydW5jYXRlT24oaW50LCBjaGFyLCBTdHJpbmdCdWZmZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGZyb250UGFkT3JUcnVuY2F0ZU9uKGNoYXJbXSBzdHJpbmcsIGludCBsZW5ndGgsIGNoYXIgYywgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoOwotCQlpZiAoc3RyaW5nTGVuZ3RoID09IGxlbmd0aCkgewotCQkJc2IuYXBwZW5kKHN0cmluZyk7Ci0JCX0gZWxzZSBpZiAoc3RyaW5nTGVuZ3RoID4gbGVuZ3RoKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nLCBzdHJpbmdMZW5ndGggLSBsZW5ndGgsIGxlbmd0aCk7Ci0JCX0gZWxzZSB7Ci0JCQlmcm9udFBhZE9uXyhzdHJpbmcsIGxlbmd0aCwgYywgc2IpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUGFkIG9yIHRydW5jYXRlIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIGxlbmd0aCwgaXQgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLgotCSAqIElmIGl0IGlzIGxvbmdlciB0aGFuIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLCBvbmx5IHRoZSBsYXN0IHBhcnQgb2YgdGhlIHN0cmluZyBpcyByZXR1cm5lZC4KLQkgKiBJZiBpdCBpcyBzaG9ydGVyIHRoYW4gdGhlIHNwZWNpZmllZCBsZW5ndGgsIGl0IGlzIHBhZGRlZCB3aXRoIHRoZSAKLQkgKiBzcGVjaWZpZWQgY2hhcmFjdGVyIGF0IHRoZSBmcm9udC4KLQkgKiBTdHJpbmcjZnJvbnRQYWRPclRydW5jYXRlT24oaW50LCBjaGFyLCBTdHJpbmdCdWlsZGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBmcm9udFBhZE9yVHJ1bmNhdGVPbihjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJaW50IHN0cmluZ0xlbmd0aCA9IHN0cmluZy5sZW5ndGg7Ci0JCWlmIChzdHJpbmdMZW5ndGggPT0gbGVuZ3RoKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQkJfSBlbHNlIGlmIChzdHJpbmdMZW5ndGggPiBsZW5ndGgpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcsIHN0cmluZ0xlbmd0aCAtIGxlbmd0aCwgbGVuZ3RoKTsKLQkJfSBlbHNlIHsKLQkJCWZyb250UGFkT25fKHN0cmluZywgbGVuZ3RoLCBjLCBzYik7Ci0JCX0KLQl9Ci0KLQkvKgotCSAqIEZyb250LXBhZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRob3V0IHZhbGlkYXRpbmcgdGhlIHBhcm1zLgotCSAqLwotCXByaXZhdGUgc3RhdGljIFN0cmluZyBmcm9udFBhZF8oU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjKSB7Ci0JCXJldHVybiBuZXcgU3RyaW5nKGZyb250UGFkXyhzdHJpbmcudG9DaGFyQXJyYXkoKSwgbGVuZ3RoLCBjKSk7Ci0JfQotCi0JLyoKLQkgKiBaZXJvLXBhZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRob3V0IHZhbGlkYXRpbmcgdGhlIHBhcm1zLgotCSAqLwotCXByaXZhdGUgc3RhdGljIGNoYXJbXSBmcm9udFBhZF8oY2hhcltdIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjKSB7Ci0JCWNoYXJbXSByZXN1bHQgPSBuZXcgY2hhcltsZW5ndGhdOwotCQlpbnQgc3RyaW5nTGVuZ3RoID0gc3RyaW5nLmxlbmd0aDsKLQkJaW50IHBhZExlbmd0aCA9IGxlbmd0aCAtIHN0cmluZ0xlbmd0aDsKLQkJU3lzdGVtLmFycmF5Y29weShzdHJpbmcsIDAsIHJlc3VsdCwgcGFkTGVuZ3RoLCBzdHJpbmdMZW5ndGgpOwotCQlBcnJheXMuZmlsbChyZXN1bHQsIDAsIHBhZExlbmd0aCwgYyk7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgd2l0aG91dCB2YWxpZGF0aW5nIHRoZSBwYXJtcy4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIGZyb250UGFkT25fKFN0cmluZyBzdHJpbmcsIGludCBsZW5ndGgsIGNoYXIgYywgV3JpdGVyIHdyaXRlcikgewotCQlmaWxsXyhzdHJpbmcsIGxlbmd0aCwgYywgd3JpdGVyKTsKLQkJd3JpdGVTdHJpbmdPbihzdHJpbmcsIHdyaXRlcik7Ci0JfQotCi0JLyoKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgd2l0aG91dCB2YWxpZGF0aW5nIHRoZSBwYXJtcy4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIGZyb250UGFkT25fKGNoYXJbXSBzdHJpbmcsIGludCBsZW5ndGgsIGNoYXIgYywgV3JpdGVyIHdyaXRlcikgewotCQlmaWxsXyhzdHJpbmcsIGxlbmd0aCwgYywgd3JpdGVyKTsKLQkJd3JpdGVTdHJpbmdPbihzdHJpbmcsIHdyaXRlcik7Ci0JfQotCi0JLyoKLQkgKiBQYWQgdGhlIHNwZWNpZmllZCBzdHJpbmcgd2l0aG91dCB2YWxpZGF0aW5nIHRoZSBwYXJtcy4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIGZyb250UGFkT25fKFN0cmluZyBzdHJpbmcsIGludCBsZW5ndGgsIGNoYXIgYywgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWZpbGxfKHN0cmluZywgbGVuZ3RoLCBjLCBzYik7Ci0JCXNiLmFwcGVuZChzdHJpbmcpOwotCX0KLQotCS8qCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGhvdXQgdmFsaWRhdGluZyB0aGUgcGFybXMuCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBmcm9udFBhZE9uXyhjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFN0cmluZ0J1ZmZlciBzYikgewotCQlmaWxsXyhzdHJpbmcsIGxlbmd0aCwgYywgc2IpOwotCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQl9Ci0KLQkvKgotCSAqIFBhZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRob3V0IHZhbGlkYXRpbmcgdGhlIHBhcm1zLgotCSAqLwotCXByaXZhdGUgc3RhdGljIHZvaWQgZnJvbnRQYWRPbl8oU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCwgY2hhciBjLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWZpbGxfKHN0cmluZywgbGVuZ3RoLCBjLCBzYik7Ci0JCXNiLmFwcGVuZChzdHJpbmcpOwotCX0KLQotCS8qCi0JICogUGFkIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGhvdXQgdmFsaWRhdGluZyB0aGUgcGFybXMuCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBmcm9udFBhZE9uXyhjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoLCBjaGFyIGMsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJZmlsbF8oc3RyaW5nLCBsZW5ndGgsIGMsIHNiKTsKLQkJc2IuYXBwZW5kKHN0cmluZyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGRlbGltaXRpbmcvcXVvdGluZyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBEZWxpbWl0IHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGggZG91YmxlIHF1b3Rlcy4KLQkgKiBFc2NhcGUgYW55IG9jY3VycmVuY2VzIG9mIGEgZG91YmxlIHF1b3RlIGluIHRoZSBzdHJpbmcgd2l0aCBhbm90aGVyCi0JICogZG91YmxlIHF1b3RlLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHF1b3RlKFN0cmluZyBzdHJpbmcpIHsKLQkJcmV0dXJuIGRlbGltaXQoc3RyaW5nLCBRVU9URSk7Ci0JfQotCi0JLyoqCi0JICogRGVsaW1pdCB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRoIGRvdWJsZSBxdW90ZXMuCi0JICogRXNjYXBlIGFueSBvY2N1cnJlbmNlcyBvZiBhIGRvdWJsZSBxdW90ZSBpbiB0aGUgc3RyaW5nIHdpdGggYW5vdGhlcgotCSAqIGRvdWJsZSBxdW90ZS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcXVvdGVPbihTdHJpbmcgc3RyaW5nLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWRlbGltaXRPbihzdHJpbmcsIFFVT1RFLCB3cml0ZXIpOwotCX0KLQotCS8qKgotCSAqIERlbGltaXQgdGhlIHNwZWNpZmllZCBzdHJpbmcgd2l0aCBkb3VibGUgcXVvdGVzLgotCSAqIEVzY2FwZSBhbnkgb2NjdXJyZW5jZXMgb2YgYSBkb3VibGUgcXVvdGUgaW4gdGhlIHN0cmluZyB3aXRoIGFub3RoZXIKLQkgKiBkb3VibGUgcXVvdGUuCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHF1b3RlT24oU3RyaW5nIHN0cmluZywgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWRlbGltaXRPbihzdHJpbmcsIFFVT1RFLCBzYik7Ci0JfQotCi0JLyoqCi0JICogRGVsaW1pdCB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRoIGRvdWJsZSBxdW90ZXMuCi0JICogRXNjYXBlIGFueSBvY2N1cnJlbmNlcyBvZiBhIGRvdWJsZSBxdW90ZSBpbiB0aGUgc3RyaW5nIHdpdGggYW5vdGhlcgotCSAqIGRvdWJsZSBxdW90ZS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcXVvdGVPbihTdHJpbmcgc3RyaW5nLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWRlbGltaXRPbihzdHJpbmcsIFFVT1RFLCBzYik7Ci0JfQotCi0JLyoqCi0JICogRGVsaW1pdCBlYWNoIG9mIHRoZSBzcGVjaWZpZWQgc3RyaW5ncyB3aXRoIGRvdWJsZSBxdW90ZXMuCi0JICogRXNjYXBlIGFueSBvY2N1cnJlbmNlcyBvZiBhIGRvdWJsZSBxdW90ZSBpbiBhIHN0cmluZyB3aXRoIGFub3RoZXIKLQkgKiBkb3VibGUgcXVvdGUuCi0JICovCi0JcHVibGljIHN0YXRpYyBJdGVyYXRvcjxTdHJpbmc+IHF1b3RlKEl0ZXJhdG9yPFN0cmluZz4gc3RyaW5ncykgewotCQlyZXR1cm4gZGVsaW1pdChzdHJpbmdzLCBRVU9URSk7Ci0JfQotCi0JLyoqCi0JICogRGVsaW1pdCB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRoIHRoZSBzcGVjaWZpZWQgZGVsaW1pdGVyOyBpLmUuIHB1dCBhIGNvcHkgb2YKLQkgKiB0aGUgZGVsaW1pdGVyIGF0IHRoZSBmcm9udCBhbmQgYmFjayBvZiB0aGUgcmVzdWx0aW5nIHN0cmluZy4KLQkgKiBFc2NhcGUgYW55IG9jY3VycmVuY2VzIG9mIHRoZSBkZWxpbWl0ZXIgaW4gdGhlIHN0cmluZyB3aXRoIGFub3RoZXIgZGVsaW1pdGVyLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGRlbGltaXQoU3RyaW5nIHN0cmluZywgY2hhciBkZWxpbWl0ZXIpIHsKLQkJcmV0dXJuIG5ldyBTdHJpbmcoZGVsaW1pdChzdHJpbmcudG9DaGFyQXJyYXkoKSwgZGVsaW1pdGVyKSk7Ci0JfQotCi0JLyoqCi0JICogRGVsaW1pdCB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRoIHRoZSBzcGVjaWZpZWQgZGVsaW1pdGVyOyBpLmUuIHB1dCBhIGNvcHkgb2YKLQkgKiB0aGUgZGVsaW1pdGVyIGF0IHRoZSBmcm9udCBhbmQgYmFjayBvZiB0aGUgcmVzdWx0aW5nIHN0cmluZy4KLQkgKiBFc2NhcGUgYW55IG9jY3VycmVuY2VzIG9mIHRoZSBkZWxpbWl0ZXIgaW4gdGhlIHN0cmluZyB3aXRoIGFub3RoZXIgZGVsaW1pdGVyLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBkZWxpbWl0T24oU3RyaW5nIHN0cmluZywgY2hhciBkZWxpbWl0ZXIsIFdyaXRlciB3cml0ZXIpIHsKLQkJZGVsaW1pdE9uKHN0cmluZy50b0NoYXJBcnJheSgpLCBkZWxpbWl0ZXIsIHdyaXRlcik7Ci0JfQotCi0JLyoqCi0JICogRGVsaW1pdCB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRoIHRoZSBzcGVjaWZpZWQgZGVsaW1pdGVyOyBpLmUuIHB1dCBhIGNvcHkgb2YKLQkgKiB0aGUgZGVsaW1pdGVyIGF0IHRoZSBmcm9udCBhbmQgYmFjayBvZiB0aGUgcmVzdWx0aW5nIHN0cmluZy4KLQkgKiBFc2NhcGUgYW55IG9jY3VycmVuY2VzIG9mIHRoZSBkZWxpbWl0ZXIgaW4gdGhlIHN0cmluZyB3aXRoIGFub3RoZXIgZGVsaW1pdGVyLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBkZWxpbWl0T24oU3RyaW5nIHN0cmluZywgY2hhciBkZWxpbWl0ZXIsIFN0cmluZ0J1ZmZlciBzYikgewotCQlkZWxpbWl0T24oc3RyaW5nLnRvQ2hhckFycmF5KCksIGRlbGltaXRlciwgc2IpOwotCX0KLQotCS8qKgotCSAqIERlbGltaXQgdGhlIHNwZWNpZmllZCBzdHJpbmcgd2l0aCB0aGUgc3BlY2lmaWVkIGRlbGltaXRlcjsgaS5lLiBwdXQgYSBjb3B5IG9mCi0JICogdGhlIGRlbGltaXRlciBhdCB0aGUgZnJvbnQgYW5kIGJhY2sgb2YgdGhlIHJlc3VsdGluZyBzdHJpbmcuCi0JICogRXNjYXBlIGFueSBvY2N1cnJlbmNlcyBvZiB0aGUgZGVsaW1pdGVyIGluIHRoZSBzdHJpbmcgd2l0aCBhbm90aGVyIGRlbGltaXRlci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgZGVsaW1pdE9uKFN0cmluZyBzdHJpbmcsIGNoYXIgZGVsaW1pdGVyLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWRlbGltaXRPbihzdHJpbmcudG9DaGFyQXJyYXkoKSwgZGVsaW1pdGVyLCBzYik7Ci0JfQotCi0JLyoqCi0JICogRGVsaW1pdCBlYWNoIG9mIHRoZSBzcGVjaWZpZWQgc3RyaW5ncyB3aXRoIHRoZSBzcGVjaWZpZWQgZGVsaW1pdGVyOyBpLmUuIHB1dCBhCi0JICogY29weSBvZiB0aGUgZGVsaW1pdGVyIGF0IHRoZSBmcm9udCBhbmQgYmFjayBvZiB0aGUgcmVzdWx0aW5nIHN0cmluZy4KLQkgKiBFc2NhcGUgYW55IG9jY3VycmVuY2VzIG9mIHRoZSBkZWxpbWl0ZXIgaW4gYSBzdHJpbmcgd2l0aCBhbm90aGVyIGRlbGltaXRlci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEl0ZXJhdG9yPFN0cmluZz4gZGVsaW1pdChJdGVyYXRvcjxTdHJpbmc+IHN0cmluZ3MsIGZpbmFsIGNoYXIgZGVsaW1pdGVyKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25JdGVyYXRvcjxTdHJpbmcsIFN0cmluZz4oc3RyaW5ncykgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShTdHJpbmcgc3RyaW5nKSB7Ci0JCQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmRlbGltaXQoc3RyaW5nLCBkZWxpbWl0ZXIpOwotCQkJfQotCQl9OwotCX0KLQotCS8qKgotCSAqIERlbGltaXQgdGhlIHNwZWNpZmllZCBzdHJpbmcgd2l0aCB0aGUgc3BlY2lmaWVkIGRlbGltaXRlcjsgaS5lLiBwdXQgYSBjb3B5IG9mCi0JICogdGhlIGRlbGltaXRlciBhdCB0aGUgZnJvbnQgYW5kIGJhY2sgb2YgdGhlIHJlc3VsdGluZyBzdHJpbmcuCi0JICogRXNjYXBlIGFueSBvY2N1cnJlbmNlcyBvZiBhIHNpbmdsZS1jaGFyYWN0ZXIgZGVsaW1pdGVyIGluIHRoZSBzdHJpbmcgd2l0aAotCSAqIGFub3RoZXIgZGVsaW1pdGVyLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGRlbGltaXQoU3RyaW5nIHN0cmluZywgU3RyaW5nIGRlbGltaXRlcikgewotCQlpZiAoZGVsaW1pdGVyLmxlbmd0aCgpID09IDEpIHsKLQkJCXJldHVybiBkZWxpbWl0KHN0cmluZywgZGVsaW1pdGVyLmNoYXJBdCgwKSk7Ci0JCX0KLQkJcmV0dXJuIG5ldyBTdHJpbmcoZGVsaW1pdChzdHJpbmcudG9DaGFyQXJyYXkoKSwgZGVsaW1pdGVyLnRvQ2hhckFycmF5KCkpKTsKLQl9Ci0KLQkvKioKLQkgKiBEZWxpbWl0IHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGggdGhlIHNwZWNpZmllZCBkZWxpbWl0ZXI7IGkuZS4gcHV0IGEgY29weSBvZgotCSAqIHRoZSBkZWxpbWl0ZXIgYXQgdGhlIGZyb250IGFuZCBiYWNrIG9mIHRoZSByZXN1bHRpbmcgc3RyaW5nLgotCSAqIEVzY2FwZSBhbnkgb2NjdXJyZW5jZXMgb2YgYSBzaW5nbGUtY2hhcmFjdGVyIGRlbGltaXRlciBpbiB0aGUgc3RyaW5nIHdpdGgKLQkgKiBhbm90aGVyIGRlbGltaXRlci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgZGVsaW1pdE9uKFN0cmluZyBzdHJpbmcsIFN0cmluZyBkZWxpbWl0ZXIsIFdyaXRlciB3cml0ZXIpIHsKLQkJaWYgKGRlbGltaXRlci5sZW5ndGgoKSA9PSAxKSB7Ci0JCQlkZWxpbWl0T24oc3RyaW5nLCBkZWxpbWl0ZXIuY2hhckF0KDApLCB3cml0ZXIpOwotCQl9IGVsc2UgewotCQkJZGVsaW1pdE9uKHN0cmluZy50b0NoYXJBcnJheSgpLCBkZWxpbWl0ZXIudG9DaGFyQXJyYXkoKSwgd3JpdGVyKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIERlbGltaXQgdGhlIHNwZWNpZmllZCBzdHJpbmcgd2l0aCB0aGUgc3BlY2lmaWVkIGRlbGltaXRlcjsgaS5lLiBwdXQgYSBjb3B5IG9mCi0JICogdGhlIGRlbGltaXRlciBhdCB0aGUgZnJvbnQgYW5kIGJhY2sgb2YgdGhlIHJlc3VsdGluZyBzdHJpbmcuCi0JICogRXNjYXBlIGFueSBvY2N1cnJlbmNlcyBvZiBhIHNpbmdsZS1jaGFyYWN0ZXIgZGVsaW1pdGVyIGluIHRoZSBzdHJpbmcgd2l0aAotCSAqIGFub3RoZXIgZGVsaW1pdGVyLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBkZWxpbWl0T24oU3RyaW5nIHN0cmluZywgU3RyaW5nIGRlbGltaXRlciwgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWlmIChkZWxpbWl0ZXIubGVuZ3RoKCkgPT0gMSkgewotCQkJZGVsaW1pdE9uKHN0cmluZywgZGVsaW1pdGVyLmNoYXJBdCgwKSwgc2IpOwotCQl9IGVsc2UgewotCQkJZGVsaW1pdE9uKHN0cmluZy50b0NoYXJBcnJheSgpLCBkZWxpbWl0ZXIudG9DaGFyQXJyYXkoKSwgc2IpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogRGVsaW1pdCB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRoIHRoZSBzcGVjaWZpZWQgZGVsaW1pdGVyOyBpLmUuIHB1dCBhIGNvcHkgb2YKLQkgKiB0aGUgZGVsaW1pdGVyIGF0IHRoZSBmcm9udCBhbmQgYmFjayBvZiB0aGUgcmVzdWx0aW5nIHN0cmluZy4KLQkgKiBFc2NhcGUgYW55IG9jY3VycmVuY2VzIG9mIGEgc2luZ2xlLWNoYXJhY3RlciBkZWxpbWl0ZXIgaW4gdGhlIHN0cmluZyB3aXRoCi0JICogYW5vdGhlciBkZWxpbWl0ZXIuCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGRlbGltaXRPbihTdHJpbmcgc3RyaW5nLCBTdHJpbmcgZGVsaW1pdGVyLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWlmIChkZWxpbWl0ZXIubGVuZ3RoKCkgPT0gMSkgewotCQkJZGVsaW1pdE9uKHN0cmluZywgZGVsaW1pdGVyLmNoYXJBdCgwKSwgc2IpOwotCQl9IGVsc2UgewotCQkJZGVsaW1pdE9uKHN0cmluZy50b0NoYXJBcnJheSgpLCBkZWxpbWl0ZXIudG9DaGFyQXJyYXkoKSwgc2IpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogRGVsaW1pdCBlYWNoIG9mIHRoZSBzcGVjaWZpZWQgc3RyaW5ncyB3aXRoIHRoZSBzcGVjaWZpZWQgZGVsaW1pdGVyOyBpLmUuIHB1dCBhCi0JICogY29weSBvZiB0aGUgZGVsaW1pdGVyIGF0IHRoZSBmcm9udCBhbmQgYmFjayBvZiB0aGUgcmVzdWx0aW5nIHN0cmluZy4KLQkgKiBFc2NhcGUgYW55IG9jY3VycmVuY2VzIG9mIGEgc2luZ2xlLWNoYXJhY3RlciBkZWxpbWl0ZXIgaW4gYSBzdHJpbmcgd2l0aAotCSAqIGFub3RoZXIgZGVsaW1pdGVyLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgSXRlcmF0b3I8U3RyaW5nPiBkZWxpbWl0KEl0ZXJhdG9yPFN0cmluZz4gc3RyaW5ncywgZmluYWwgU3RyaW5nIGRlbGltaXRlcikgewotCQlpZiAoZGVsaW1pdGVyLmxlbmd0aCgpID09IDEpIHsKLQkJCXJldHVybiBkZWxpbWl0KHN0cmluZ3MsIGRlbGltaXRlci5jaGFyQXQoMCkpOwotCQl9Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25JdGVyYXRvcjxTdHJpbmcsIFN0cmluZz4oc3RyaW5ncykgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIHRyYW5zZm9ybShTdHJpbmcgc3RyaW5nKSB7Ci0JCQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmRlbGltaXQoc3RyaW5nLCBkZWxpbWl0ZXIpOwotCQkJfQotCQl9OwotCX0KLQotCS8qKgotCSAqIERlbGltaXQgdGhlIHNwZWNpZmllZCBzdHJpbmcgd2l0aCBkb3VibGUgcXVvdGVzLgotCSAqIEVzY2FwZSBhbnkgb2NjdXJyZW5jZXMgb2YgYSBkb3VibGUgcXVvdGUgaW4gdGhlIHN0cmluZyB3aXRoIGFub3RoZXIKLQkgKiBkb3VibGUgcXVvdGUuCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gcXVvdGUoY2hhcltdIHN0cmluZykgewotCQlyZXR1cm4gZGVsaW1pdChzdHJpbmcsIFFVT1RFKTsKLQl9Ci0KLQkvKioKLQkgKiBEZWxpbWl0IHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGggZG91YmxlIHF1b3Rlcy4KLQkgKiBFc2NhcGUgYW55IG9jY3VycmVuY2VzIG9mIGEgZG91YmxlIHF1b3RlIGluIHRoZSBzdHJpbmcgd2l0aCBhbm90aGVyCi0JICogZG91YmxlIHF1b3RlLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBxdW90ZU9uKGNoYXJbXSBzdHJpbmcsIFdyaXRlciB3cml0ZXIpIHsKLQkJZGVsaW1pdE9uKHN0cmluZywgUVVPVEUsIHdyaXRlcik7Ci0JfQotCi0JLyoqCi0JICogRGVsaW1pdCB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRoIGRvdWJsZSBxdW90ZXMuCi0JICogRXNjYXBlIGFueSBvY2N1cnJlbmNlcyBvZiBhIGRvdWJsZSBxdW90ZSBpbiB0aGUgc3RyaW5nIHdpdGggYW5vdGhlcgotCSAqIGRvdWJsZSBxdW90ZS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcXVvdGVPbihjaGFyW10gc3RyaW5nLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJZGVsaW1pdE9uKHN0cmluZywgUVVPVEUsIHNiKTsKLQl9Ci0KLQkvKioKLQkgKiBEZWxpbWl0IHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGggZG91YmxlIHF1b3Rlcy4KLQkgKiBFc2NhcGUgYW55IG9jY3VycmVuY2VzIG9mIGEgZG91YmxlIHF1b3RlIGluIHRoZSBzdHJpbmcgd2l0aCBhbm90aGVyCi0JICogZG91YmxlIHF1b3RlLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBxdW90ZU9uKGNoYXJbXSBzdHJpbmcsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJZGVsaW1pdE9uKHN0cmluZywgUVVPVEUsIHNiKTsKLQl9Ci0KLQkvKioKLQkgKiBEZWxpbWl0IGVhY2ggb2YgdGhlIHNwZWNpZmllZCBzdHJpbmdzIHdpdGggZG91YmxlIHF1b3Rlcy4KLQkgKiBFc2NhcGUgYW55IG9jY3VycmVuY2VzIG9mIGEgZG91YmxlIHF1b3RlIGluIGEgc3RyaW5nIHdpdGggYW5vdGhlcgotCSAqIGRvdWJsZSBxdW90ZS4KLQkgKi8KLQkvLyBjYW5ub3QgbmFtZSBtZXRob2Qgc2ltcGx5ICdxdW90ZScgYmVjYXVzZSBvZiB0eXBlLWVyYXN1cmUuLi4KLQlwdWJsaWMgc3RhdGljIEl0ZXJhdG9yPGNoYXJbXT4gcXVvdGVDaGFyQXJyYXlzKEl0ZXJhdG9yPGNoYXJbXT4gc3RyaW5ncykgewotCQlyZXR1cm4gZGVsaW1pdENoYXJBcnJheXMoc3RyaW5ncywgUVVPVEUpOwotCX0KLQotCS8qKgotCSAqIERlbGltaXQgdGhlIHNwZWNpZmllZCBzdHJpbmcgd2l0aCB0aGUgc3BlY2lmaWVkIGRlbGltaXRlcjsgaS5lLiBwdXQgYSBjb3B5IG9mCi0JICogdGhlIGRlbGltaXRlciBhdCB0aGUgZnJvbnQgYW5kIGJhY2sgb2YgdGhlIHJlc3VsdGluZyBzdHJpbmcuCi0JICogRXNjYXBlIGFueSBvY2N1cnJlbmNlcyBvZiB0aGUgZGVsaW1pdGVyIGluIHRoZSBzdHJpbmcgd2l0aCBhbm90aGVyIGRlbGltaXRlci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXJbXSBkZWxpbWl0KGNoYXJbXSBzdHJpbmcsIGNoYXIgZGVsaW1pdGVyKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcihzdHJpbmcubGVuZ3RoICsgMik7Ci0JCWRlbGltaXRPbihzdHJpbmcsIGRlbGltaXRlciwgc2IpOwotCQlyZXR1cm4gY29udmVydFRvQ2hhckFycmF5KHNiKTsKLQl9Ci0KLQkvKioKLQkgKiBEZWxpbWl0IHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGggdGhlIHNwZWNpZmllZCBkZWxpbWl0ZXI7IGkuZS4gcHV0IGEgY29weSBvZgotCSAqIHRoZSBkZWxpbWl0ZXIgYXQgdGhlIGZyb250IGFuZCBiYWNrIG9mIHRoZSByZXN1bHRpbmcgc3RyaW5nLgotCSAqIEVzY2FwZSBhbnkgb2NjdXJyZW5jZXMgb2YgdGhlIGRlbGltaXRlciBpbiB0aGUgc3RyaW5nIHdpdGggYW5vdGhlciBkZWxpbWl0ZXIuCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGRlbGltaXRPbihjaGFyW10gc3RyaW5nLCBjaGFyIGRlbGltaXRlciwgV3JpdGVyIHdyaXRlcikgewotCQl3cml0ZUNoYXJPbihkZWxpbWl0ZXIsIHdyaXRlcik7Ci0JCXdyaXRlU3RyaW5nT24oc3RyaW5nLCBkZWxpbWl0ZXIsIHdyaXRlcik7Ci0JCXdyaXRlQ2hhck9uKGRlbGltaXRlciwgd3JpdGVyKTsKLQl9Ci0KLQkvKioKLQkgKiBEZWxpbWl0IHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGggdGhlIHNwZWNpZmllZCBkZWxpbWl0ZXI7IGkuZS4gcHV0IGEgY29weSBvZgotCSAqIHRoZSBkZWxpbWl0ZXIgYXQgdGhlIGZyb250IGFuZCBiYWNrIG9mIHRoZSByZXN1bHRpbmcgc3RyaW5nLgotCSAqIEVzY2FwZSBhbnkgb2NjdXJyZW5jZXMgb2YgdGhlIGRlbGltaXRlciBpbiB0aGUgc3RyaW5nIHdpdGggYW5vdGhlciBkZWxpbWl0ZXIuCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGRlbGltaXRPbihjaGFyW10gc3RyaW5nLCBjaGFyIGRlbGltaXRlciwgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCXNiLmFwcGVuZChkZWxpbWl0ZXIpOwotCQlmb3IgKGNoYXIgYyA6IHN0cmluZykgewotCQkJaWYgKGMgPT0gZGVsaW1pdGVyKSB7Ci0JCQkJc2IuYXBwZW5kKGMpOwotCQkJfQotCQkJc2IuYXBwZW5kKGMpOwotCQl9Ci0JCXNiLmFwcGVuZChkZWxpbWl0ZXIpOwotCX0KLQotCS8qKgotCSAqIERlbGltaXQgdGhlIHNwZWNpZmllZCBzdHJpbmcgd2l0aCB0aGUgc3BlY2lmaWVkIGRlbGltaXRlcjsgaS5lLiBwdXQgYSBjb3B5IG9mCi0JICogdGhlIGRlbGltaXRlciBhdCB0aGUgZnJvbnQgYW5kIGJhY2sgb2YgdGhlIHJlc3VsdGluZyBzdHJpbmcuCi0JICogRXNjYXBlIGFueSBvY2N1cnJlbmNlcyBvZiB0aGUgZGVsaW1pdGVyIGluIHRoZSBzdHJpbmcgd2l0aCBhbm90aGVyIGRlbGltaXRlci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgZGVsaW1pdE9uKGNoYXJbXSBzdHJpbmcsIGNoYXIgZGVsaW1pdGVyLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXNiLmFwcGVuZChkZWxpbWl0ZXIpOwotCQlmb3IgKGNoYXIgYyA6IHN0cmluZykgewotCQkJaWYgKGMgPT0gZGVsaW1pdGVyKSB7Ci0JCQkJc2IuYXBwZW5kKGMpOwotCQkJfQotCQkJc2IuYXBwZW5kKGMpOwotCQl9Ci0JCXNiLmFwcGVuZChkZWxpbWl0ZXIpOwotCX0KLQotCS8qKgotCSAqIERlbGltaXQgZWFjaCBvZiB0aGUgc3BlY2lmaWVkIHN0cmluZ3Mgd2l0aCB0aGUgc3BlY2lmaWVkIGRlbGltaXRlcjsgaS5lLiBwdXQgYQotCSAqIGNvcHkgb2YgdGhlIGRlbGltaXRlciBhdCB0aGUgZnJvbnQgYW5kIGJhY2sgb2YgdGhlIHJlc3VsdGluZyBzdHJpbmcuCi0JICogRXNjYXBlIGFueSBvY2N1cnJlbmNlcyBvZiB0aGUgZGVsaW1pdGVyIGluIGEgc3RyaW5nIHdpdGggYW5vdGhlciBkZWxpbWl0ZXIuCi0JICovCi0JLy8gY2Fubm90IG5hbWUgbWV0aG9kIHNpbXBseSAnZGVsaW1pdCcgYmVjYXVzZSBvZiB0eXBlLWVyYXN1cmUuLi4KLQlwdWJsaWMgc3RhdGljIEl0ZXJhdG9yPGNoYXJbXT4gZGVsaW1pdENoYXJBcnJheXMoSXRlcmF0b3I8Y2hhcltdPiBzdHJpbmdzLCBmaW5hbCBjaGFyIGRlbGltaXRlcikgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8Y2hhcltdLCBjaGFyW10+KHN0cmluZ3MpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGNoYXJbXSB0cmFuc2Zvcm0oY2hhcltdIHN0cmluZykgewotCQkJCXJldHVybiBTdHJpbmdUb29scy5kZWxpbWl0KHN0cmluZywgZGVsaW1pdGVyKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQkvKioKLQkgKiBEZWxpbWl0IHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGggdGhlIHNwZWNpZmllZCBkZWxpbWl0ZXI7IGkuZS4gcHV0IGEgY29weSBvZgotCSAqIHRoZSBkZWxpbWl0ZXIgYXQgdGhlIGZyb250IGFuZCBiYWNrIG9mIHRoZSByZXN1bHRpbmcgc3RyaW5nLgotCSAqIEVzY2FwZSBhbnkgb2NjdXJyZW5jZXMgb2YgYSBzaW5nbGUtY2hhcmFjdGVyIGRlbGltaXRlciBpbiB0aGUgc3RyaW5nIHdpdGgKLQkgKiBhbm90aGVyIGRlbGltaXRlci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXJbXSBkZWxpbWl0KGNoYXJbXSBzdHJpbmcsIGNoYXJbXSBkZWxpbWl0ZXIpIHsKLQkJaW50IGRlbGltaXRlckxlbmd0aCA9IGRlbGltaXRlci5sZW5ndGg7Ci0JCWlmIChkZWxpbWl0ZXJMZW5ndGggPT0gMSkgewotCQkJcmV0dXJuIGRlbGltaXQoc3RyaW5nLCBkZWxpbWl0ZXJbMF0pOwotCQl9Ci0JCWludCBzdHJpbmdMZW5ndGggPSBzdHJpbmcubGVuZ3RoOwotCQljaGFyW10gcmVzdWx0ID0gbmV3IGNoYXJbc3RyaW5nTGVuZ3RoKygyKmRlbGltaXRlckxlbmd0aCldOwotCQlTeXN0ZW0uYXJyYXljb3B5KGRlbGltaXRlciwgMCwgcmVzdWx0LCAwLCBkZWxpbWl0ZXJMZW5ndGgpOwotCQlTeXN0ZW0uYXJyYXljb3B5KHN0cmluZywgMCwgcmVzdWx0LCBkZWxpbWl0ZXJMZW5ndGgsIHN0cmluZ0xlbmd0aCk7Ci0JCVN5c3RlbS5hcnJheWNvcHkoZGVsaW1pdGVyLCAwLCByZXN1bHQsIHN0cmluZ0xlbmd0aCtkZWxpbWl0ZXJMZW5ndGgsIGRlbGltaXRlckxlbmd0aCk7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoqCi0JICogRGVsaW1pdCB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRoIHRoZSBzcGVjaWZpZWQgZGVsaW1pdGVyOyBpLmUuIHB1dCBhIGNvcHkgb2YKLQkgKiB0aGUgZGVsaW1pdGVyIGF0IHRoZSBmcm9udCBhbmQgYmFjayBvZiB0aGUgcmVzdWx0aW5nIHN0cmluZy4KLQkgKiBFc2NhcGUgYW55IG9jY3VycmVuY2VzIG9mIGEgc2luZ2xlLWNoYXJhY3RlciBkZWxpbWl0ZXIgaW4gdGhlIHN0cmluZyB3aXRoCi0JICogYW5vdGhlciBkZWxpbWl0ZXIuCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGRlbGltaXRPbihjaGFyW10gc3RyaW5nLCBjaGFyW10gZGVsaW1pdGVyLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWlmIChkZWxpbWl0ZXIubGVuZ3RoID09IDEpIHsKLQkJCWRlbGltaXRPbihzdHJpbmcsIGRlbGltaXRlclswXSwgd3JpdGVyKTsKLQkJfSBlbHNlIHsKLQkJCXdyaXRlU3RyaW5nT24oZGVsaW1pdGVyLCB3cml0ZXIpOwotCQkJd3JpdGVTdHJpbmdPbihzdHJpbmcsIHdyaXRlcik7Ci0JCQl3cml0ZVN0cmluZ09uKGRlbGltaXRlciwgd3JpdGVyKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIERlbGltaXQgdGhlIHNwZWNpZmllZCBzdHJpbmcgd2l0aCB0aGUgc3BlY2lmaWVkIGRlbGltaXRlcjsgaS5lLiBwdXQgYSBjb3B5IG9mCi0JICogdGhlIGRlbGltaXRlciBhdCB0aGUgZnJvbnQgYW5kIGJhY2sgb2YgdGhlIHJlc3VsdGluZyBzdHJpbmcuCi0JICogRXNjYXBlIGFueSBvY2N1cnJlbmNlcyBvZiBhIHNpbmdsZS1jaGFyYWN0ZXIgZGVsaW1pdGVyIGluIHRoZSBzdHJpbmcgd2l0aAotCSAqIGFub3RoZXIgZGVsaW1pdGVyLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBkZWxpbWl0T24oY2hhcltdIHN0cmluZywgY2hhcltdIGRlbGltaXRlciwgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWlmIChkZWxpbWl0ZXIubGVuZ3RoID09IDEpIHsKLQkJCWRlbGltaXRPbihzdHJpbmcsIGRlbGltaXRlclswXSwgc2IpOwotCQl9IGVsc2UgewotCQkJc2IuYXBwZW5kKGRlbGltaXRlcik7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQkJCXNiLmFwcGVuZChkZWxpbWl0ZXIpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogRGVsaW1pdCB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRoIHRoZSBzcGVjaWZpZWQgZGVsaW1pdGVyOyBpLmUuIHB1dCBhIGNvcHkgb2YKLQkgKiB0aGUgZGVsaW1pdGVyIGF0IHRoZSBmcm9udCBhbmQgYmFjayBvZiB0aGUgcmVzdWx0aW5nIHN0cmluZy4KLQkgKiBFc2NhcGUgYW55IG9jY3VycmVuY2VzIG9mIGEgc2luZ2xlLWNoYXJhY3RlciBkZWxpbWl0ZXIgaW4gdGhlIHN0cmluZyB3aXRoCi0JICogYW5vdGhlciBkZWxpbWl0ZXIuCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGRlbGltaXRPbihjaGFyW10gc3RyaW5nLCBjaGFyW10gZGVsaW1pdGVyLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWlmIChkZWxpbWl0ZXIubGVuZ3RoID09IDEpIHsKLQkJCWRlbGltaXRPbihzdHJpbmcsIGRlbGltaXRlclswXSwgc2IpOwotCQl9IGVsc2UgewotCQkJc2IuYXBwZW5kKGRlbGltaXRlcik7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQkJCXNiLmFwcGVuZChkZWxpbWl0ZXIpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogRGVsaW1pdCBlYWNoIG9mIHRoZSBzcGVjaWZpZWQgc3RyaW5ncyB3aXRoIHRoZSBzcGVjaWZpZWQgZGVsaW1pdGVyOyBpLmUuIHB1dCBhCi0JICogY29weSBvZiB0aGUgZGVsaW1pdGVyIGF0IHRoZSBmcm9udCBhbmQgYmFjayBvZiB0aGUgcmVzdWx0aW5nIHN0cmluZy4KLQkgKiBFc2NhcGUgYW55IG9jY3VycmVuY2VzIG9mIGEgc2luZ2xlLWNoYXJhY3RlciBkZWxpbWl0ZXIgaW4gYSBzdHJpbmcgd2l0aAotCSAqIGFub3RoZXIgZGVsaW1pdGVyLgotCSAqLwotCS8vIGNhbm5vdCBuYW1lIG1ldGhvZCBzaW1wbHkgJ2RlbGltaXQnIGJlY2F1c2Ugb2YgdHlwZS1lcmFzdXJlLi4uCi0JcHVibGljIHN0YXRpYyBJdGVyYXRvcjxjaGFyW10+IGRlbGltaXRDaGFyQXJyYXlzKEl0ZXJhdG9yPGNoYXJbXT4gc3RyaW5ncywgZmluYWwgY2hhcltdIGRlbGltaXRlcikgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8Y2hhcltdLCBjaGFyW10+KHN0cmluZ3MpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGNoYXJbXSB0cmFuc2Zvcm0oY2hhcltdIHN0cmluZykgewotCQkJCXJldHVybiBTdHJpbmdUb29scy5kZWxpbWl0KHN0cmluZywgZGVsaW1pdGVyKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogZGVsaW1pdGluZyBxdWVyaWVzICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGlzIHF1b3RlZDogIlwiZm9vXCIiLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBzdHJpbmdJc1F1b3RlZChTdHJpbmcgc3RyaW5nKSB7Ci0JCXJldHVybiBzdHJpbmdJc0RlbGltaXRlZChzdHJpbmcsIFFVT1RFKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIHN0cmluZyBpcyBwYXJlbnRoZXRpY2FsOiAiKGZvbykiLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBzdHJpbmdJc1BhcmVudGhldGljYWwoU3RyaW5nIHN0cmluZykgewotCQlyZXR1cm4gc3RyaW5nSXNEZWxpbWl0ZWQoc3RyaW5nLCBPUEVOX1BBUkVOVEhFU0lTLCBDTE9TRV9QQVJFTlRIRVNJUyk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBzdHJpbmcgaXMgYnJhY2tldGVkOiAiW2Zvb10iLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBzdHJpbmdJc0JyYWNrZXRlZChTdHJpbmcgc3RyaW5nKSB7Ci0JCXJldHVybiBzdHJpbmdJc0RlbGltaXRlZChzdHJpbmcsIE9QRU5fQlJBQ0tFVCwgQ0xPU0VfQlJBQ0tFVCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBzdHJpbmcgaXMgYnJhY2VkOiAie2Zvb30iLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBzdHJpbmdJc0JyYWNlZChTdHJpbmcgc3RyaW5nKSB7Ci0JCXJldHVybiBzdHJpbmdJc0RlbGltaXRlZChzdHJpbmcsIE9QRU5fQlJBQ0UsIENMT1NFX0JSQUNFKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIHN0cmluZyBpcyBjaGV2cm9uZWQ6ICI8Zm9vPiIuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIHN0cmluZ0lzQ2hldnJvbmVkKFN0cmluZyBzdHJpbmcpIHsKLQkJcmV0dXJuIHN0cmluZ0lzRGVsaW1pdGVkKHN0cmluZywgT1BFTl9DSEVWUk9OLCBDTE9TRV9DSEVWUk9OKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIHN0cmluZyBpcyBkZWxpbWl0ZWQgYnkgdGhlIHNwZWNpZmllZAotCSAqIGNoYXJhY3Rlci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gc3RyaW5nSXNEZWxpbWl0ZWQoU3RyaW5nIHN0cmluZywgY2hhciBjKSB7Ci0JCXJldHVybiBzdHJpbmdJc0RlbGltaXRlZChzdHJpbmcsIGMsIGMpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGlzIGRlbGltaXRlZCBieSB0aGUgc3BlY2lmaWVkCi0JICogY2hhcmFjdGVycy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gc3RyaW5nSXNEZWxpbWl0ZWQoU3RyaW5nIHN0cmluZywgY2hhciBzdGFydCwgY2hhciBlbmQpIHsKLQkJaW50IGxlbiA9IHN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKGxlbiA8IDIpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlyZXR1cm4gc3RyaW5nSXNEZWxpbWl0ZWQoc3RyaW5nLnRvQ2hhckFycmF5KCksIHN0YXJ0LCBlbmQsIGxlbik7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBzdHJpbmcgaXMgcXVvdGVkOiAiXCJmb29cIiIuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIHN0cmluZ0lzUXVvdGVkKGNoYXJbXSBzdHJpbmcpIHsKLQkJcmV0dXJuIHN0cmluZ0lzRGVsaW1pdGVkKHN0cmluZywgUVVPVEUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGlzIHBhcmVudGhldGljYWw6ICIoZm9vKSIuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIHN0cmluZ0lzUGFyZW50aGV0aWNhbChjaGFyW10gc3RyaW5nKSB7Ci0JCXJldHVybiBzdHJpbmdJc0RlbGltaXRlZChzdHJpbmcsIE9QRU5fUEFSRU5USEVTSVMsIENMT1NFX1BBUkVOVEhFU0lTKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIHN0cmluZyBpcyBicmFja2V0ZWQ6ICJbZm9vXSIuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIHN0cmluZ0lzQnJhY2tldGVkKGNoYXJbXSBzdHJpbmcpIHsKLQkJcmV0dXJuIHN0cmluZ0lzRGVsaW1pdGVkKHN0cmluZywgT1BFTl9CUkFDS0VULCBDTE9TRV9CUkFDS0VUKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIHN0cmluZyBpcyBicmFjZWQ6ICJ7Zm9vfSIuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIHN0cmluZ0lzQnJhY2VkKGNoYXJbXSBzdHJpbmcpIHsKLQkJcmV0dXJuIHN0cmluZ0lzRGVsaW1pdGVkKHN0cmluZywgT1BFTl9CUkFDRSwgQ0xPU0VfQlJBQ0UpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGlzIGNoZXZyb25lZDogIjxmb28+Ii4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gc3RyaW5nSXNDaGV2cm9uZWQoY2hhcltdIHN0cmluZykgewotCQlyZXR1cm4gc3RyaW5nSXNEZWxpbWl0ZWQoc3RyaW5nLCBPUEVOX0NIRVZST04sIENMT1NFX0NIRVZST04pOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGlzIGRlbGltaXRlZCBieSB0aGUgc3BlY2lmaWVkCi0JICogY2hhcmFjdGVyLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBzdHJpbmdJc0RlbGltaXRlZChjaGFyW10gc3RyaW5nLCBjaGFyIGMpIHsKLQkJcmV0dXJuIHN0cmluZ0lzRGVsaW1pdGVkKHN0cmluZywgYywgYyk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBzdHJpbmcgaXMgZGVsaW1pdGVkIGJ5IHRoZSBzcGVjaWZpZWQKLQkgKiBjaGFyYWN0ZXJzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBzdHJpbmdJc0RlbGltaXRlZChjaGFyW10gc3RyaW5nLCBjaGFyIHN0YXJ0LCBjaGFyIGVuZCkgewotCQlpbnQgbGVuID0gc3RyaW5nLmxlbmd0aDsKLQkJaWYgKGxlbiA8IDIpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlyZXR1cm4gc3RyaW5nSXNEZWxpbWl0ZWQoc3RyaW5nLCBzdGFydCwgZW5kLCBsZW4pOwotCX0KLQotCXByaXZhdGUgc3RhdGljIGJvb2xlYW4gc3RyaW5nSXNEZWxpbWl0ZWQoY2hhcltdIHMsIGNoYXIgc3RhcnQsIGNoYXIgZW5kLCBpbnQgbGVuKSB7Ci0JCXJldHVybiAoc1swXSA9PSBzdGFydCkgJiYgKHNbbGVuIC0gMV0gPT0gZW5kKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogdW5kZWxpbWl0aW5nICoqKioqKioqKioKLQotCS8qKgotCSAqIFJlbW92ZSB0aGUgZGVsaW1pdGVycyBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nLCByZW1vdmluZyBhbnkgZXNjYXBlCi0JICogY2hhcmFjdGVycy4gVGhyb3cgYW4gSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGlmIHRoZSBzdHJpbmcgaXMgdG9vIHNob3J0Ci0JICogdG8gdW5kZWxpbWl0IChpLmUuIGxlbmd0aCA8IDIpLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHVuZGVsaW1pdChTdHJpbmcgc3RyaW5nKSB7Ci0JCWludCBsZW4gPSBzdHJpbmcubGVuZ3RoKCkgLSAyOwotCQlpZiAobGVuIDwgMCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiaW52YWxpZCBzdHJpbmc6IFwiIiArIHN0cmluZyArICciJyk7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQlpZiAobGVuID09IDApIHsKLQkJCXJldHVybiBFTVBUWV9TVFJJTkc7Ci0JCX0KLQkJcmV0dXJuIG5ldyBTdHJpbmcodW5kZWxpbWl0XyhzdHJpbmcudG9DaGFyQXJyYXkoKSwgbGVuKSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBmaXJzdCBhbmQgbGFzdCBjb3VudCBjaGFyYWN0ZXJzIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcuCi0JICogSWYgdGhlIHN0cmluZyBpcyB0b28gc2hvcnQgdG8gYmUgdW5kZWxpbWl0ZWQsIHRocm93IGFuCi0JICogSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uLgotCSAqIFVzZSB0aGlzIG1ldGhvZCB0byB1bmRlbGltaXQgc3RyaW5ncyB0aGF0IGRvIG5vdCBlc2NhcGUgZW1iZWRkZWQKLQkgKiBkZWxpbWl0ZXJzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHVuZGVsaW1pdChTdHJpbmcgc3RyaW5nLCBpbnQgY291bnQpIHsKLQkJaW50IGxlbiA9IHN0cmluZy5sZW5ndGgoKSAtICgyICogY291bnQpOwotCQlpZiAobGVuIDwgMCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiaW52YWxpZCBzdHJpbmc6IFwiIiArIHN0cmluZyArICciJyk7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQlpZiAobGVuID09IDApIHsKLQkJCXJldHVybiBFTVBUWV9TVFJJTkc7Ci0JCX0KLQkJcmV0dXJuIG5ldyBTdHJpbmcodW5kZWxpbWl0KHN0cmluZy50b0NoYXJBcnJheSgpLCBsZW4sIGNvdW50KSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBkZWxpbWl0ZXJzIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcsIHJlbW92aW5nIGFueSBlc2NhcGUKLQkgKiBjaGFyYWN0ZXJzLiBUaHJvdyBhbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaWYgdGhlIHN0cmluZyBpcyB0b28gc2hvcnQKLQkgKiB0byB1bmRlbGltaXQgKGkuZS4gbGVuZ3RoIDwgMikuCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gdW5kZWxpbWl0KGNoYXJbXSBzdHJpbmcpIHsKLQkJaW50IGxlbiA9IHN0cmluZy5sZW5ndGggLSAyOwotCQlpZiAobGVuIDwgMCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiaW52YWxpZCBzdHJpbmc6IFwiIiArIG5ldyBTdHJpbmcoc3RyaW5nKSArICciJyk7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQlpZiAobGVuID09IDApIHsKLQkJCXJldHVybiBFTVBUWV9DSEFSX0FSUkFZOwotCQl9Ci0JCXJldHVybiB1bmRlbGltaXRfKHN0cmluZywgbGVuKTsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBjaGFyW10gdW5kZWxpbWl0XyhjaGFyW10gc3RyaW5nLCBpbnQgbGVuZ3RoKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcihsZW5ndGgpOwotCQl1bmRlbGltaXRPbl8oc3RyaW5nLCBzYik7Ci0JCXJldHVybiBjb252ZXJ0VG9DaGFyQXJyYXkoc2IpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSB0aGUgZmlyc3QgYW5kIGxhc3QgY291bnQgY2hhcmFjdGVycyBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgdG9vIHNob3J0IHRvIGJlIHVuZGVsaW1pdGVkLCB0aHJvdyBhbgotCSAqIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbi4KLQkgKiBVc2UgdGhpcyBtZXRob2QgdG8gdW5kZWxpbWl0IHN0cmluZ3MgdGhhdCBkbyBub3QgZXNjYXBlIGVtYmVkZGVkCi0JICogZGVsaW1pdGVycy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXJbXSB1bmRlbGltaXQoY2hhcltdIHN0cmluZywgaW50IGNvdW50KSB7Ci0JCWludCBsZW4gPSBzdHJpbmcubGVuZ3RoIC0gKDIgKiBjb3VudCk7Ci0JCWlmIChsZW4gPCAwKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJpbnZhbGlkIHN0cmluZzogXCIiICsgbmV3IFN0cmluZyhzdHJpbmcpICsgJyInKTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCWlmIChsZW4gPT0gMCkgewotCQkJcmV0dXJuIEVNUFRZX0NIQVJfQVJSQVk7Ci0JCX0KLQkJcmV0dXJuIHVuZGVsaW1pdChzdHJpbmcsIGxlbiwgY291bnQpOwotCX0KLQotCXByaXZhdGUgc3RhdGljIGNoYXJbXSB1bmRlbGltaXQoY2hhcltdIHN0cmluZywgaW50IGxlbiwgaW50IGNvdW50KSB7Ci0JCWNoYXJbXSByZXN1bHQgPSBuZXcgY2hhcltsZW5dOwotCQlTeXN0ZW0uYXJyYXljb3B5KHN0cmluZywgY291bnQsIHJlc3VsdCwgMCwgbGVuKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgdGhlIGRlbGltaXRlcnMgZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZywgcmVtb3ZpbmcgYW55IGVzY2FwZQotCSAqIGNoYXJhY3RlcnMuIFRocm93IGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpZiB0aGUgc3RyaW5nIGlzIHRvbyBzaG9ydAotCSAqIHRvIHVuZGVsaW1pdCAoaS5lLiBsZW5ndGggPCAyKS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgdW5kZWxpbWl0T24oU3RyaW5nIHN0cmluZywgV3JpdGVyIHdyaXRlcikgewotCQl1bmRlbGltaXRPbihzdHJpbmcudG9DaGFyQXJyYXkoKSwgd3JpdGVyKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgdGhlIGZpcnN0IGFuZCBsYXN0IGNvdW50IGNoYXJhY3RlcnMgZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZy4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIHRvbyBzaG9ydCB0byBiZSB1bmRlbGltaXRlZCwgdGhyb3cgYW4KLQkgKiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24uCi0JICogVXNlIHRoaXMgbWV0aG9kIHRvIHVuZGVsaW1pdCBzdHJpbmdzIHRoYXQgZG8gbm90IGVzY2FwZSBlbWJlZGRlZAotCSAqIGRlbGltaXRlcnMuCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHVuZGVsaW1pdE9uKFN0cmluZyBzdHJpbmcsIGludCBjb3VudCwgV3JpdGVyIHdyaXRlcikgewotCQlpbnQgbGVuID0gc3RyaW5nLmxlbmd0aCgpIC0gKDIgKiBjb3VudCk7Ci0JCWlmIChsZW4gPCAwKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJpbnZhbGlkIHN0cmluZzogXCIiICsgc3RyaW5nICsgJyInKTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCWlmIChsZW4gPT0gMCkgewotCQkJcmV0dXJuOwotCQl9Ci0JCXdyaXRlU3RyaW5nT24oc3RyaW5nLCBjb3VudCwgbGVuLCB3cml0ZXIpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSB0aGUgZGVsaW1pdGVycyBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nLCByZW1vdmluZyBhbnkgZXNjYXBlCi0JICogY2hhcmFjdGVycy4gVGhyb3cgYW4gSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGlmIHRoZSBzdHJpbmcgaXMgdG9vIHNob3J0Ci0JICogdG8gdW5kZWxpbWl0IChpLmUuIGxlbmd0aCA8IDIpLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCB1bmRlbGltaXRPbihTdHJpbmcgc3RyaW5nLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJdW5kZWxpbWl0T24oc3RyaW5nLnRvQ2hhckFycmF5KCksIHNiKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgdGhlIGZpcnN0IGFuZCBsYXN0IGNvdW50IGNoYXJhY3RlcnMgZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZy4KLQkgKiBJZiB0aGUgc3RyaW5nIGlzIHRvbyBzaG9ydCB0byBiZSB1bmRlbGltaXRlZCwgdGhyb3cgYW4KLQkgKiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24uCi0JICogVXNlIHRoaXMgbWV0aG9kIHRvIHVuZGVsaW1pdCBzdHJpbmdzIHRoYXQgZG8gbm90IGVzY2FwZSBlbWJlZGRlZAotCSAqIGRlbGltaXRlcnMuCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHVuZGVsaW1pdE9uKFN0cmluZyBzdHJpbmcsIGludCBjb3VudCwgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWludCBsZW4gPSBzdHJpbmcubGVuZ3RoKCkgLSAoMiAqIGNvdW50KTsKLQkJaWYgKGxlbiA8IDApIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oImludmFsaWQgc3RyaW5nOiBcIiIgKyBzdHJpbmcgKyAnIicpOyAvLyROT04tTkxTLTEkCi0JCX0KLQkJaWYgKGxlbiA9PSAwKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQkJc2IuYXBwZW5kKHN0cmluZywgY291bnQsIGNvdW50ICsgbGVuKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgdGhlIGRlbGltaXRlcnMgZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZywgcmVtb3ZpbmcgYW55IGVzY2FwZQotCSAqIGNoYXJhY3RlcnMuIFRocm93IGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpZiB0aGUgc3RyaW5nIGlzIHRvbyBzaG9ydAotCSAqIHRvIHVuZGVsaW1pdCAoaS5lLiBsZW5ndGggPCAyKS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgdW5kZWxpbWl0T24oU3RyaW5nIHN0cmluZywgU3RyaW5nQnVpbGRlciBzYikgewotCQl1bmRlbGltaXRPbihzdHJpbmcudG9DaGFyQXJyYXkoKSwgc2IpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSB0aGUgZmlyc3QgYW5kIGxhc3QgY291bnQgY2hhcmFjdGVycyBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgdG9vIHNob3J0IHRvIGJlIHVuZGVsaW1pdGVkLCB0aHJvdyBhbgotCSAqIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbi4KLQkgKiBVc2UgdGhpcyBtZXRob2QgdG8gdW5kZWxpbWl0IHN0cmluZ3MgdGhhdCBkbyBub3QgZXNjYXBlIGVtYmVkZGVkCi0JICogZGVsaW1pdGVycy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgdW5kZWxpbWl0T24oU3RyaW5nIHN0cmluZywgaW50IGNvdW50LCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWludCBsZW4gPSBzdHJpbmcubGVuZ3RoKCkgLSAoMiAqIGNvdW50KTsKLQkJaWYgKGxlbiA8IDApIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oImludmFsaWQgc3RyaW5nOiBcIiIgKyBzdHJpbmcgKyAnIicpOyAvLyROT04tTkxTLTEkCi0JCX0KLQkJaWYgKGxlbiA9PSAwKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQkJc2IuYXBwZW5kKHN0cmluZywgY291bnQsIGNvdW50ICsgbGVuKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgdGhlIGRlbGltaXRlcnMgZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZywgcmVtb3ZpbmcgYW55IGVzY2FwZQotCSAqIGNoYXJhY3RlcnMuIFRocm93IGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpZiB0aGUgc3RyaW5nIGlzIHRvbyBzaG9ydAotCSAqIHRvIHVuZGVsaW1pdCAoaS5lLiBsZW5ndGggPCAyKS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgdW5kZWxpbWl0T24oY2hhcltdIHN0cmluZywgV3JpdGVyIHdyaXRlcikgewotCQlpbnQgbGVuID0gc3RyaW5nLmxlbmd0aCAtIDI7Ci0JCWlmIChsZW4gPCAwKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJpbnZhbGlkIHN0cmluZzogXCIiICsgbmV3IFN0cmluZyhzdHJpbmcpICsgJyInKTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCWlmIChsZW4gPT0gMCkgewotCQkJcmV0dXJuOwotCQl9Ci0JCXVuZGVsaW1pdE9uXyhzdHJpbmcsIHdyaXRlcik7Ci0JfQotCi0JLyoqCi0JICogcHJlLWNvbmRpdGlvbjogc3RyaW5nIGlzIGF0IGxlYXN0IDMgY2hhcmFjdGVycyBsb25nCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCB1bmRlbGltaXRPbl8oY2hhcltdIHN0cmluZywgV3JpdGVyIHdyaXRlcikgewotCQljaGFyIGRlbGltaXRlciA9IHN0cmluZ1swXTsgIC8vIHRoZSBmaXJzdCBjaGFyIGlzIHRoZSBkZWxpbWl0ZXIKLQkJY2hhciBjID0gc3RyaW5nWzBdOwotCQljaGFyIG5leHQgPSBzdHJpbmdbMV07Ci0JCWludCBpID0gMTsKLQkJaW50IGxhc3QgPSBzdHJpbmcubGVuZ3RoIC0gMTsKLQkJZG8gewotCQkJYyA9IG5leHQ7Ci0JCQl3cml0ZUNoYXJPbihjLCB3cml0ZXIpOwotCQkJaSsrOwotCQkJbmV4dCA9IHN0cmluZ1tpXTsKLQkJCWlmIChjID09IGRlbGltaXRlcikgewotCQkJCWlmICgobmV4dCAhPSBkZWxpbWl0ZXIpIHx8IChpID09IGxhc3QpKSB7Ci0JCQkJCS8vIGFuIGVtYmVkZGVkIGRlbGltaXRlciBtdXN0IGJlIGZvbGxvd2VkIGJ5IGFub3RoZXIgZGVsaW1pdGVyCi0JCQkJCXJldHVybjsKLQkJCQl9Ci0JCQkJaSsrOwotCQkJCW5leHQgPSBzdHJpbmdbaV07Ci0JCQl9Ci0JCX0gd2hpbGUgKGkgIT0gbGFzdCk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBmaXJzdCBhbmQgbGFzdCBjb3VudCBjaGFyYWN0ZXJzIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcuCi0JICogSWYgdGhlIHN0cmluZyBpcyB0b28gc2hvcnQgdG8gYmUgdW5kZWxpbWl0ZWQsIHRocm93IGFuCi0JICogSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uLgotCSAqIFVzZSB0aGlzIG1ldGhvZCB0byB1bmRlbGltaXQgc3RyaW5ncyB0aGF0IGRvIG5vdCBlc2NhcGUgZW1iZWRkZWQKLQkgKiBkZWxpbWl0ZXJzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCB1bmRlbGltaXRPbihjaGFyW10gc3RyaW5nLCBpbnQgY291bnQsIFdyaXRlciB3cml0ZXIpIHsKLQkJaW50IGxlbiA9IHN0cmluZy5sZW5ndGggLSAoMiAqIGNvdW50KTsKLQkJaWYgKGxlbiA8IDApIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oImludmFsaWQgc3RyaW5nOiBcIiIgKyBuZXcgU3RyaW5nKHN0cmluZykgKyAnIicpOyAvLyROT04tTkxTLTEkCi0JCX0KLQkJaWYgKGxlbiA9PSAwKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQkJd3JpdGVTdHJpbmdPbihzdHJpbmcsIGNvdW50LCBsZW4sIHdyaXRlcik7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBkZWxpbWl0ZXJzIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcsIHJlbW92aW5nIGFueSBlc2NhcGUKLQkgKiBjaGFyYWN0ZXJzLiBUaHJvdyBhbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaWYgdGhlIHN0cmluZyBpcyB0b28gc2hvcnQKLQkgKiB0byB1bmRlbGltaXQgKGkuZS4gbGVuZ3RoIDwgMikuCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHVuZGVsaW1pdE9uKGNoYXJbXSBzdHJpbmcsIFN0cmluZ0J1ZmZlciBzYikgewotCQlpbnQgbGVuID0gc3RyaW5nLmxlbmd0aCAtIDI7Ci0JCWlmIChsZW4gPCAwKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJpbnZhbGlkIHN0cmluZzogXCIiICsgbmV3IFN0cmluZyhzdHJpbmcpICsgJyInKTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCWlmIChsZW4gPT0gMCkgewotCQkJcmV0dXJuOwotCQl9Ci0JCXVuZGVsaW1pdE9uXyhzdHJpbmcsIHNiKTsKLQl9Ci0KLQkvKioKLQkgKiBwcmUtY29uZGl0aW9uOiBzdHJpbmcgaXMgYXQgbGVhc3QgMyBjaGFyYWN0ZXJzIGxvbmcKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIHVuZGVsaW1pdE9uXyhjaGFyW10gc3RyaW5nLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJY2hhciBkZWxpbWl0ZXIgPSBzdHJpbmdbMF07ICAvLyB0aGUgZmlyc3QgY2hhciBpcyB0aGUgZGVsaW1pdGVyCi0JCWNoYXIgYyA9IHN0cmluZ1swXTsKLQkJY2hhciBuZXh0ID0gc3RyaW5nWzFdOwotCQlpbnQgaSA9IDE7Ci0JCWludCBsYXN0ID0gc3RyaW5nLmxlbmd0aCAtIDE7Ci0JCWRvIHsKLQkJCWMgPSBuZXh0OwotCQkJc2IuYXBwZW5kKGMpOwotCQkJaSsrOwotCQkJbmV4dCA9IHN0cmluZ1tpXTsKLQkJCWlmIChjID09IGRlbGltaXRlcikgewotCQkJCWlmICgobmV4dCAhPSBkZWxpbWl0ZXIpIHx8IChpID09IGxhc3QpKSB7Ci0JCQkJCS8vIGFuIGVtYmVkZGVkIGRlbGltaXRlciBtdXN0IGJlIGZvbGxvd2VkIGJ5IGFub3RoZXIgZGVsaW1pdGVyCi0JCQkJCXJldHVybjsKLQkJCQl9Ci0JCQkJaSsrOwotCQkJCW5leHQgPSBzdHJpbmdbaV07Ci0JCQl9Ci0JCX0gd2hpbGUgKGkgIT0gbGFzdCk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBmaXJzdCBhbmQgbGFzdCBjb3VudCBjaGFyYWN0ZXJzIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcuCi0JICogSWYgdGhlIHN0cmluZyBpcyB0b28gc2hvcnQgdG8gYmUgdW5kZWxpbWl0ZWQsIHRocm93IGFuCi0JICogSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uLgotCSAqIFVzZSB0aGlzIG1ldGhvZCB0byB1bmRlbGltaXQgc3RyaW5ncyB0aGF0IGRvIG5vdCBlc2NhcGUgZW1iZWRkZWQKLQkgKiBkZWxpbWl0ZXJzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCB1bmRlbGltaXRPbihjaGFyW10gc3RyaW5nLCBpbnQgY291bnQsIFN0cmluZ0J1ZmZlciBzYikgewotCQlpbnQgbGVuID0gc3RyaW5nLmxlbmd0aCAtICgyICogY291bnQpOwotCQlpZiAobGVuIDwgMCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiaW52YWxpZCBzdHJpbmc6IFwiIiArIG5ldyBTdHJpbmcoc3RyaW5nKSArICciJyk7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQlpZiAobGVuID09IDApIHsKLQkJCXJldHVybjsKLQkJfQotCQlzYi5hcHBlbmQoc3RyaW5nLCBjb3VudCwgbGVuKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgdGhlIGRlbGltaXRlcnMgZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZywgcmVtb3ZpbmcgYW55IGVzY2FwZQotCSAqIGNoYXJhY3RlcnMuIFRocm93IGFuIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBpZiB0aGUgc3RyaW5nIGlzIHRvbyBzaG9ydAotCSAqIHRvIHVuZGVsaW1pdCAoaS5lLiBsZW5ndGggPCAyKS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgdW5kZWxpbWl0T24oY2hhcltdIHN0cmluZywgU3RyaW5nQnVpbGRlciBzYikgewotCQlpbnQgbGVuID0gc3RyaW5nLmxlbmd0aCAtIDI7Ci0JCWlmIChsZW4gPCAwKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJpbnZhbGlkIHN0cmluZzogXCIiICsgbmV3IFN0cmluZyhzdHJpbmcpICsgJyInKTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCWlmIChsZW4gPT0gMCkgewotCQkJcmV0dXJuOwotCQl9Ci0JCXVuZGVsaW1pdE9uXyhzdHJpbmcsIHNiKTsKLQl9Ci0KLQkvKioKLQkgKiBwcmUtY29uZGl0aW9uOiBzdHJpbmcgaXMgYXQgbGVhc3QgMyBjaGFyYWN0ZXJzIGxvbmcKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIHVuZGVsaW1pdE9uXyhjaGFyW10gc3RyaW5nLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWNoYXIgZGVsaW1pdGVyID0gc3RyaW5nWzBdOyAgLy8gdGhlIGZpcnN0IGNoYXIgaXMgdGhlIGRlbGltaXRlcgotCQljaGFyIGMgPSBzdHJpbmdbMF07Ci0JCWNoYXIgbmV4dCA9IHN0cmluZ1sxXTsKLQkJaW50IGkgPSAxOwotCQlpbnQgbGFzdCA9IHN0cmluZy5sZW5ndGggLSAxOwotCQlkbyB7Ci0JCQljID0gbmV4dDsKLQkJCXNiLmFwcGVuZChjKTsKLQkJCWkrKzsKLQkJCW5leHQgPSBzdHJpbmdbaV07Ci0JCQlpZiAoYyA9PSBkZWxpbWl0ZXIpIHsKLQkJCQlpZiAoKG5leHQgIT0gZGVsaW1pdGVyKSB8fCAoaSA9PSBsYXN0KSkgewotCQkJCQkvLyBhbiBlbWJlZGRlZCBkZWxpbWl0ZXIgbXVzdCBiZSBmb2xsb3dlZCBieSBhbm90aGVyIGRlbGltaXRlcgotCQkJCQlyZXR1cm47Ci0JCQkJfQotCQkJCWkrKzsKLQkJCQluZXh0ID0gc3RyaW5nW2ldOwotCQkJfQotCQl9IHdoaWxlIChpICE9IGxhc3QpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSB0aGUgZmlyc3QgYW5kIGxhc3QgY291bnQgY2hhcmFjdGVycyBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nLgotCSAqIElmIHRoZSBzdHJpbmcgaXMgdG9vIHNob3J0IHRvIGJlIHVuZGVsaW1pdGVkLCB0aHJvdyBhbgotCSAqIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbi4KLQkgKiBVc2UgdGhpcyBtZXRob2QgdG8gdW5kZWxpbWl0IHN0cmluZ3MgdGhhdCBkbyBub3QgZXNjYXBlIGVtYmVkZGVkCi0JICogZGVsaW1pdGVycy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgdW5kZWxpbWl0T24oY2hhcltdIHN0cmluZywgaW50IGNvdW50LCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWludCBsZW4gPSBzdHJpbmcubGVuZ3RoIC0gKDIgKiBjb3VudCk7Ci0JCWlmIChsZW4gPCAwKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJpbnZhbGlkIHN0cmluZzogXCIiICsgbmV3IFN0cmluZyhzdHJpbmcpICsgJyInKTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCWlmIChsZW4gPT0gMCkgewotCQkJcmV0dXJuOwotCQl9Ci0JCXNiLmFwcGVuZChzdHJpbmcsIGNvdW50LCBsZW4pOwotCX0KLQotCi0JLy8gKioqKioqKioqKiByZW1vdmluZyBjaGFyYWN0ZXJzICoqKioqKioqKioKLQotCS8qKgotCSAqIFJlbW92ZSB0aGUgZmlyc3Qgb2NjdXJyZW5jZSBvZiB0aGUgc3BlY2lmaWVkIGNoYXJhY3RlcgotCSAqIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcgYW5kIHJldHVybiB0aGUgcmVzdWx0LgotCSAqIFN0cmluZyNyZW1vdmVGaXJzdE9jY3VycmVuY2UoY2hhcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyByZW1vdmVGaXJzdE9jY3VycmVuY2UoU3RyaW5nIHN0cmluZywgY2hhciBjKSB7Ci0JCWludCBpbmRleCA9IHN0cmluZy5pbmRleE9mKGMpOwotCQlpZiAoaW5kZXggPT0gLTEpIHsKLQkJCS8vIGNoYXJhY3RlciBub3QgZm91bmQKLQkJCXJldHVybiBzdHJpbmc7Ci0JCX0KLQkJaWYgKGluZGV4ID09IDApIHsKLQkJCS8vIGNoYXJhY3RlciBmb3VuZCBhdCB0aGUgZnJvbnQgb2Ygc3RyaW5nCi0JCQlyZXR1cm4gc3RyaW5nLnN1YnN0cmluZygxKTsKLQkJfQotCQlpbnQgbGFzdCA9IHN0cmluZy5sZW5ndGgoKSAtIDE7Ci0JCWlmIChpbmRleCA9PSBsYXN0KSB7Ci0JCQkvLyBjaGFyYWN0ZXIgZm91bmQgYXQgdGhlIGVuZCBvZiBzdHJpbmcKLQkJCXJldHVybiBzdHJpbmcuc3Vic3RyaW5nKDAsIGxhc3QpOwotCQl9Ci0JCS8vIGNoYXJhY3RlciBmb3VuZCBzb21ld2hlcmUgaW4gdGhlIG1pZGRsZSBvZiB0aGUgc3RyaW5nCi0JCXJldHVybiBzdHJpbmcuc3Vic3RyaW5nKDAsIGluZGV4KS5jb25jYXQoc3RyaW5nLnN1YnN0cmluZyhpbmRleCArIDEpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgdGhlIGZpcnN0IG9jY3VycmVuY2Ugb2YgdGhlIHNwZWNpZmllZCBjaGFyYWN0ZXIKLQkgKiBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGFuZCBwcmludCB0aGUgcmVzdWx0IG9uIHRoZSBzcGVjaWZpZWQgc3RyZWFtLgotCSAqIFN0cmluZyNyZW1vdmVGaXJzdE9jY3VycmVuY2VPbihjaGFyLCBXcml0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHJlbW92ZUZpcnN0T2NjdXJyZW5jZU9uKFN0cmluZyBzdHJpbmcsIGNoYXIgYywgV3JpdGVyIHdyaXRlcikgewotCQlpbnQgaW5kZXggPSBzdHJpbmcuaW5kZXhPZihjKTsKLQkJaWYgKGluZGV4ID09IC0xKSB7Ci0JCQl3cml0ZVN0cmluZ09uKHN0cmluZywgd3JpdGVyKTsKLQkJfSBlbHNlIHsKLQkJCXJlbW92ZUNoYXJBdEluZGV4T24oc3RyaW5nLnRvQ2hhckFycmF5KCksIGluZGV4LCB3cml0ZXIpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBmaXJzdCBvY2N1cnJlbmNlIG9mIHRoZSBzcGVjaWZpZWQgY2hhcmFjdGVyCi0JICogZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgcHJpbnQgdGhlIHJlc3VsdCBvbiB0aGUgc3BlY2lmaWVkIHN0cmVhbS4KLQkgKiBTdHJpbmcjcmVtb3ZlRmlyc3RPY2N1cnJlbmNlT24oY2hhciwgU3RyaW5nQnVmZmVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCByZW1vdmVGaXJzdE9jY3VycmVuY2VPbihTdHJpbmcgc3RyaW5nLCBjaGFyIGMsIFN0cmluZ0J1ZmZlciBzYikgewotCQlpbnQgaW5kZXggPSBzdHJpbmcuaW5kZXhPZihjKTsKLQkJaWYgKGluZGV4ID09IC0xKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQkJfSBlbHNlIHsKLQkJCXJlbW92ZUNoYXJBdEluZGV4T24oc3RyaW5nLnRvQ2hhckFycmF5KCksIGluZGV4LCBzYik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgdGhlIGZpcnN0IG9jY3VycmVuY2Ugb2YgdGhlIHNwZWNpZmllZCBjaGFyYWN0ZXIKLQkgKiBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGFuZCBwcmludCB0aGUgcmVzdWx0IG9uIHRoZSBzcGVjaWZpZWQgc3RyZWFtLgotCSAqIFN0cmluZyNyZW1vdmVGaXJzdE9jY3VycmVuY2VPbihjaGFyLCBTdHJpbmdCdWlsZGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCByZW1vdmVGaXJzdE9jY3VycmVuY2VPbihTdHJpbmcgc3RyaW5nLCBjaGFyIGMsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJaW50IGluZGV4ID0gc3RyaW5nLmluZGV4T2YoYyk7Ci0JCWlmIChpbmRleCA9PSAtMSkgewotCQkJc2IuYXBwZW5kKHN0cmluZyk7Ci0JCX0gZWxzZSB7Ci0JCQlyZW1vdmVDaGFyQXRJbmRleE9uKHN0cmluZy50b0NoYXJBcnJheSgpLCBpbmRleCwgc2IpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBmaXJzdCBvY2N1cnJlbmNlIG9mIHRoZSBzcGVjaWZpZWQgY2hhcmFjdGVyCi0JICogZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogU3RyaW5nI3JlbW92ZUZpcnN0T2NjdXJyZW5jZShjaGFyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIHJlbW92ZUZpcnN0T2NjdXJyZW5jZShjaGFyW10gc3RyaW5nLCBjaGFyIGMpIHsKLQkJaW50IGluZGV4ID0gQ29sbGVjdGlvblRvb2xzLmluZGV4T2Yoc3RyaW5nLCBjKTsKLQkJaWYgKGluZGV4ID09IC0xKSB7Ci0JCQkvLyBjaGFyYWN0ZXIgbm90IGZvdW5kCi0JCQlyZXR1cm4gc3RyaW5nOwotCQl9Ci0JCWludCBsYXN0ID0gc3RyaW5nLmxlbmd0aCAtIDE7Ci0JCWNoYXJbXSByZXN1bHQgPSBuZXcgY2hhcltsYXN0XTsKLQkJaWYgKGluZGV4ID09IDApIHsKLQkJCS8vIGNoYXJhY3RlciBmb3VuZCBhdCB0aGUgZnJvbnQgb2Ygc3RyaW5nCi0JCQlTeXN0ZW0uYXJyYXljb3B5KHN0cmluZywgMSwgcmVzdWx0LCAwLCBsYXN0KTsKLQkJfSBlbHNlIGlmIChpbmRleCA9PSBsYXN0KSB7Ci0JCQkvLyBjaGFyYWN0ZXIgZm91bmQgYXQgdGhlIGVuZCBvZiBzdHJpbmcKLQkJCVN5c3RlbS5hcnJheWNvcHkoc3RyaW5nLCAwLCByZXN1bHQsIDAsIGxhc3QpOwotCQl9IGVsc2UgewotCQkJLy8gY2hhcmFjdGVyIGZvdW5kIHNvbWV3aGVyZSBpbiB0aGUgbWlkZGxlIG9mIHRoZSBzdHJpbmcKLQkJCVN5c3RlbS5hcnJheWNvcHkoc3RyaW5nLCAwLCByZXN1bHQsIDAsIGluZGV4KTsKLQkJCVN5c3RlbS5hcnJheWNvcHkoc3RyaW5nLCBpbmRleCArIDEsIHJlc3VsdCwgaW5kZXgsIGxhc3QgLSBpbmRleCk7Ci0JCX0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgdGhlIGZpcnN0IG9jY3VycmVuY2Ugb2YgdGhlIHNwZWNpZmllZCBjaGFyYWN0ZXIKLQkgKiBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGFuZCBwcmludCB0aGUgcmVzdWx0IG9uIHRoZSBzcGVjaWZpZWQgc3RyZWFtLgotCSAqIFN0cmluZyNyZW1vdmVGaXJzdE9jY3VycmVuY2VPbihjaGFyLCBXcml0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHJlbW92ZUZpcnN0T2NjdXJyZW5jZU9uKGNoYXJbXSBzdHJpbmcsIGNoYXIgYywgV3JpdGVyIHdyaXRlcikgewotCQlpbnQgaW5kZXggPSBDb2xsZWN0aW9uVG9vbHMuaW5kZXhPZihzdHJpbmcsIGMpOwotCQlpZiAoaW5kZXggPT0gLTEpIHsKLQkJCXdyaXRlU3RyaW5nT24oc3RyaW5nLCB3cml0ZXIpOwotCQl9IGVsc2UgewotCQkJcmVtb3ZlQ2hhckF0SW5kZXhPbihzdHJpbmcsIGluZGV4LCB3cml0ZXIpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCByZW1vdmVDaGFyQXRJbmRleE9uKGNoYXJbXSBzdHJpbmcsIGludCBpbmRleCwgV3JpdGVyIHdyaXRlcikgewotCQlpbnQgbGFzdCA9IHN0cmluZy5sZW5ndGggLSAxOwotCQlpZiAoaW5kZXggPT0gMCkgewotCQkJLy8gY2hhcmFjdGVyIGZvdW5kIGF0IHRoZSBmcm9udCBvZiBzdHJpbmcKLQkJCXdyaXRlU3RyaW5nT24oc3RyaW5nLCAxLCBsYXN0LCB3cml0ZXIpOwotCQl9IGVsc2UgaWYgKGluZGV4ID09IGxhc3QpIHsKLQkJCS8vIGNoYXJhY3RlciBmb3VuZCBhdCB0aGUgZW5kIG9mIHN0cmluZwotCQkJd3JpdGVTdHJpbmdPbihzdHJpbmcsIDAsIGxhc3QsIHdyaXRlcik7Ci0JCX0gZWxzZSB7Ci0JCQkvLyBjaGFyYWN0ZXIgZm91bmQgc29tZXdoZXJlIGluIHRoZSBtaWRkbGUgb2YgdGhlIHN0cmluZwotCQkJd3JpdGVTdHJpbmdPbihzdHJpbmcsIDAsIGluZGV4LCB3cml0ZXIpOwotCQkJd3JpdGVTdHJpbmdPbihzdHJpbmcsIGluZGV4ICsgMSwgbGFzdCAtIGluZGV4LCB3cml0ZXIpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBmaXJzdCBvY2N1cnJlbmNlIG9mIHRoZSBzcGVjaWZpZWQgY2hhcmFjdGVyCi0JICogZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgcHJpbnQgdGhlIHJlc3VsdCBvbiB0aGUgc3BlY2lmaWVkIHN0cmVhbS4KLQkgKiBTdHJpbmcjcmVtb3ZlRmlyc3RPY2N1cnJlbmNlT24oY2hhciwgU3RyaW5nQnVmZmVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCByZW1vdmVGaXJzdE9jY3VycmVuY2VPbihjaGFyW10gc3RyaW5nLCBjaGFyIGMsIFN0cmluZ0J1ZmZlciBzYikgewotCQlpbnQgaW5kZXggPSBDb2xsZWN0aW9uVG9vbHMuaW5kZXhPZihzdHJpbmcsIGMpOwotCQlpZiAoaW5kZXggPT0gLTEpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcpOwotCQl9IGVsc2UgewotCQkJcmVtb3ZlQ2hhckF0SW5kZXhPbihzdHJpbmcsIGluZGV4LCBzYik7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyB2b2lkIHJlbW92ZUNoYXJBdEluZGV4T24oY2hhcltdIHN0cmluZywgaW50IGluZGV4LCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJaW50IGxhc3QgPSBzdHJpbmcubGVuZ3RoIC0gMTsKLQkJaWYgKGluZGV4ID09IDApIHsKLQkJCS8vIGNoYXJhY3RlciBmb3VuZCBhdCB0aGUgZnJvbnQgb2Ygc3RyaW5nCi0JCQlzYi5hcHBlbmQoc3RyaW5nLCAxLCBsYXN0KTsKLQkJfSBlbHNlIGlmIChpbmRleCA9PSBsYXN0KSB7Ci0JCQkvLyBjaGFyYWN0ZXIgZm91bmQgYXQgdGhlIGVuZCBvZiBzdHJpbmcKLQkJCXNiLmFwcGVuZChzdHJpbmcsIDAsIGxhc3QpOwotCQl9IGVsc2UgewotCQkJLy8gY2hhcmFjdGVyIGZvdW5kIHNvbWV3aGVyZSBpbiB0aGUgbWlkZGxlIG9mIHRoZSBzdHJpbmcKLQkJCXNiLmFwcGVuZChzdHJpbmcsIDAsIGluZGV4KTsKLQkJCXNiLmFwcGVuZChzdHJpbmcsIGluZGV4ICsgMSwgbGFzdCAtIGluZGV4KTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFJlbW92ZSB0aGUgZmlyc3Qgb2NjdXJyZW5jZSBvZiB0aGUgc3BlY2lmaWVkIGNoYXJhY3RlcgotCSAqIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcgYW5kIHByaW50IHRoZSByZXN1bHQgb24gdGhlIHNwZWNpZmllZCBzdHJlYW0uCi0JICogU3RyaW5nI3JlbW92ZUZpcnN0T2NjdXJyZW5jZU9uKGNoYXIsIFN0cmluZ0J1aWxkZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHJlbW92ZUZpcnN0T2NjdXJyZW5jZU9uKGNoYXJbXSBzdHJpbmcsIGNoYXIgYywgU3RyaW5nQnVpbGRlciBzYikgewotCQlpbnQgaW5kZXggPSBDb2xsZWN0aW9uVG9vbHMuaW5kZXhPZihzdHJpbmcsIGMpOwotCQlpZiAoaW5kZXggPT0gLTEpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcpOwotCQl9IGVsc2UgewotCQkJcmVtb3ZlQ2hhckF0SW5kZXhPbihzdHJpbmcsIGluZGV4LCBzYik7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyB2b2lkIHJlbW92ZUNoYXJBdEluZGV4T24oY2hhcltdIHN0cmluZywgaW50IGluZGV4LCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWludCBsYXN0ID0gc3RyaW5nLmxlbmd0aCAtIDE7Ci0JCWlmIChpbmRleCA9PSAwKSB7Ci0JCQkvLyBjaGFyYWN0ZXIgZm91bmQgYXQgdGhlIGZyb250IG9mIHN0cmluZwotCQkJc2IuYXBwZW5kKHN0cmluZywgMSwgbGFzdCk7Ci0JCX0gZWxzZSBpZiAoaW5kZXggPT0gbGFzdCkgewotCQkJLy8gY2hhcmFjdGVyIGZvdW5kIGF0IHRoZSBlbmQgb2Ygc3RyaW5nCi0JCQlzYi5hcHBlbmQoc3RyaW5nLCAwLCBsYXN0KTsKLQkJfSBlbHNlIHsKLQkJCS8vIGNoYXJhY3RlciBmb3VuZCBzb21ld2hlcmUgaW4gdGhlIG1pZGRsZSBvZiB0aGUgc3RyaW5nCi0JCQlzYi5hcHBlbmQoc3RyaW5nLCAwLCBpbmRleCk7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nLCBpbmRleCArIDEsIGxhc3QgLSBpbmRleCk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYWxsIG9jY3VycmVuY2VzIG9mIHRoZSBzcGVjaWZpZWQgY2hhcmFjdGVyCi0JICogZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogU3RyaW5nI3JlbW92ZUFsbE9jY3VycmVuY2VzKGNoYXIpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgcmVtb3ZlQWxsT2NjdXJyZW5jZXMoU3RyaW5nIHN0cmluZywgY2hhciBjKSB7Ci0JCWludCBmaXJzdCA9IHN0cmluZy5pbmRleE9mKGMpOwotCQlyZXR1cm4gKGZpcnN0ID09IC0xKSA/IHN0cmluZyA6IG5ldyBTdHJpbmcocmVtb3ZlQWxsT2NjdXJyZW5jZXNfKHN0cmluZy50b0NoYXJBcnJheSgpLCBjLCBmaXJzdCkpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBhbGwgb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCBjaGFyYWN0ZXIKLQkgKiBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGFuZCB3cml0ZSB0aGUgcmVzdWx0IHRvIHRoZSBzcGVjaWZpZWQgc3RyZWFtLgotCSAqIFN0cmluZyNyZW1vdmVBbGxPY2N1cnJlbmNlc09uKGNoYXIsIFdyaXRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcmVtb3ZlQWxsT2NjdXJyZW5jZXNPbihTdHJpbmcgc3RyaW5nLCBjaGFyIGMsIFdyaXRlciB3cml0ZXIpIHsKLQkJaW50IGZpcnN0ID0gc3RyaW5nLmluZGV4T2YoYyk7Ci0JCWlmIChmaXJzdCA9PSAtMSkgewotCQkJd3JpdGVTdHJpbmdPbihzdHJpbmcsIHdyaXRlcik7Ci0JCX0gZWxzZSB7Ci0JCQlyZW1vdmVBbGxPY2N1cnJlbmNlc09uXyhzdHJpbmcudG9DaGFyQXJyYXkoKSwgYywgZmlyc3QsIHdyaXRlcik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYWxsIG9jY3VycmVuY2VzIG9mIHRoZSBzcGVjaWZpZWQgY2hhcmFjdGVyCi0JICogZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgd3JpdGUgdGhlIHJlc3VsdCB0byB0aGUgc3BlY2lmaWVkIHN0cmVhbS4KLQkgKiBTdHJpbmcjcmVtb3ZlQWxsT2NjdXJyZW5jZXNPbihjaGFyLCBTdHJpbmdCdWZmZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHJlbW92ZUFsbE9jY3VycmVuY2VzT24oU3RyaW5nIHN0cmluZywgY2hhciBjLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJaW50IGZpcnN0ID0gc3RyaW5nLmluZGV4T2YoYyk7Ci0JCWlmIChmaXJzdCA9PSAtMSkgewotCQkJc2IuYXBwZW5kKHN0cmluZyk7Ci0JCX0gZWxzZSB7Ci0JCQlyZW1vdmVBbGxPY2N1cnJlbmNlc09uXyhzdHJpbmcudG9DaGFyQXJyYXkoKSwgYywgZmlyc3QsIHNiKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBhbGwgb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCBjaGFyYWN0ZXIKLQkgKiBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGFuZCB3cml0ZSB0aGUgcmVzdWx0IHRvIHRoZSBzcGVjaWZpZWQgc3RyZWFtLgotCSAqIFN0cmluZyNyZW1vdmVBbGxPY2N1cnJlbmNlc09uKGNoYXIsIFN0cmluZ0J1aWxkZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHJlbW92ZUFsbE9jY3VycmVuY2VzT24oU3RyaW5nIHN0cmluZywgY2hhciBjLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWludCBmaXJzdCA9IHN0cmluZy5pbmRleE9mKGMpOwotCQlpZiAoZmlyc3QgPT0gLTEpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcpOwotCQl9IGVsc2UgewotCQkJcmVtb3ZlQWxsT2NjdXJyZW5jZXNPbl8oc3RyaW5nLnRvQ2hhckFycmF5KCksIGMsIGZpcnN0LCBzYik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYWxsIG9jY3VycmVuY2VzIG9mIHRoZSBzcGVjaWZpZWQgY2hhcmFjdGVyCi0JICogZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogU3RyaW5nI3JlbW92ZUFsbE9jY3VycmVuY2VzKGNoYXIpCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gcmVtb3ZlQWxsT2NjdXJyZW5jZXMoY2hhcltdIHN0cmluZywgY2hhciBjKSB7Ci0JCWludCBmaXJzdCA9IENvbGxlY3Rpb25Ub29scy5pbmRleE9mKHN0cmluZywgYyk7Ci0JCXJldHVybiAoZmlyc3QgPT0gLTEpID8gc3RyaW5nIDogcmVtb3ZlQWxsT2NjdXJyZW5jZXNfKHN0cmluZywgYywgZmlyc3QpOwotCX0KLQotCS8qCi0JICogVGhlIGluZGV4IG9mIHRoZSBmaXJzdCBtYXRjaGluZyBjaGFyYWN0ZXIgaXMgcGFzc2VkIGluLgotCSAqLwotCXByaXZhdGUgc3RhdGljIGNoYXJbXSByZW1vdmVBbGxPY2N1cnJlbmNlc18oY2hhcltdIHN0cmluZywgY2hhciBjLCBpbnQgZmlyc3QpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKHN0cmluZy5sZW5ndGgpOwotCQlyZW1vdmVBbGxPY2N1cnJlbmNlc09uXyhzdHJpbmcsIGMsIGZpcnN0LCBzYik7Ci0JCXJldHVybiBjb252ZXJ0VG9DaGFyQXJyYXkoc2IpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBhbGwgb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCBjaGFyYWN0ZXIKLQkgKiBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGFuZCB3cml0ZSB0aGUgcmVzdWx0IHRvIHRoZQotCSAqIHNwZWNpZmllZCB3cml0ZXIuCi0JICogU3RyaW5nI3JlbW92ZUFsbE9jY3VycmVuY2VzT24oY2hhciwgV3JpdGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCByZW1vdmVBbGxPY2N1cnJlbmNlc09uKGNoYXJbXSBzdHJpbmcsIGNoYXIgYywgV3JpdGVyIHdyaXRlcikgewotCQlpbnQgZmlyc3QgPSBDb2xsZWN0aW9uVG9vbHMuaW5kZXhPZihzdHJpbmcsIGMpOwotCQlpZiAoZmlyc3QgPT0gLTEpIHsKLQkJCXdyaXRlU3RyaW5nT24oc3RyaW5nLCB3cml0ZXIpOwotCQl9IGVsc2UgewotCQkJcmVtb3ZlQWxsT2NjdXJyZW5jZXNPbl8oc3RyaW5nLCBjLCBmaXJzdCwgd3JpdGVyKTsKLQkJfQotCX0KLQotCS8qCi0JICogVGhlIGluZGV4IG9mIHRoZSBmaXJzdCBtYXRjaGluZyBjaGFyYWN0ZXIgaXMgcGFzc2VkIGluLgotCSAqLwotCXByaXZhdGUgc3RhdGljIHZvaWQgcmVtb3ZlQWxsT2NjdXJyZW5jZXNPbl8oY2hhcltdIHN0cmluZywgY2hhciBjLCBpbnQgZmlyc3QsIFdyaXRlciB3cml0ZXIpIHsKLQkJd3JpdGVTdHJpbmdPbihzdHJpbmcsIDAsIGZpcnN0LCB3cml0ZXIpOwotCQlpbnQgbGVuID0gc3RyaW5nLmxlbmd0aDsKLQkJZm9yIChpbnQgaSA9IGZpcnN0OyBpIDwgbGVuOyBpKyspIHsKLQkJCWNoYXIgZCA9IHN0cmluZ1tpXTsKLQkJCWlmIChkICE9IGMpIHsKLQkJCQl3cml0ZUNoYXJPbihkLCB3cml0ZXIpOwotCQkJfQotCQl9Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGFsbCBvY2N1cnJlbmNlcyBvZiB0aGUgc3BlY2lmaWVkIGNoYXJhY3RlcgotCSAqIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcgYW5kIGFwcGVuZCB0aGUgcmVzdWx0IHRvIHRoZQotCSAqIHNwZWNpZmllZCBzdHJpbmcgYnVmZmVyLgotCSAqIFN0cmluZyNyZW1vdmVBbGxPY2N1cnJlbmNlc09uKGNoYXIsIFN0cmluZ0J1ZmZlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcmVtb3ZlQWxsT2NjdXJyZW5jZXNPbihjaGFyW10gc3RyaW5nLCBjaGFyIGMsIFN0cmluZ0J1ZmZlciBzYikgewotCQlpbnQgZmlyc3QgPSBDb2xsZWN0aW9uVG9vbHMuaW5kZXhPZihzdHJpbmcsIGMpOwotCQlpZiAoZmlyc3QgPT0gLTEpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcpOwotCQl9IGVsc2UgewotCQkJcmVtb3ZlQWxsT2NjdXJyZW5jZXNPbl8oc3RyaW5nLCBjLCBmaXJzdCwgc2IpOwotCQl9Ci0JfQotCi0JLyoKLQkgKiBUaGUgaW5kZXggb2YgdGhlIGZpcnN0IG1hdGNoaW5nIGNoYXJhY3RlciBpcyBwYXNzZWQgaW4uCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCByZW1vdmVBbGxPY2N1cnJlbmNlc09uXyhjaGFyW10gc3RyaW5nLCBjaGFyIGMsIGludCBmaXJzdCwgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCXNiLmFwcGVuZChzdHJpbmcsIDAsIGZpcnN0KTsKLQkJaW50IGxlbiA9IHN0cmluZy5sZW5ndGg7Ci0JCWZvciAoaW50IGkgPSBmaXJzdDsgaSA8IGxlbjsgaSsrKSB7Ci0JCQljaGFyIGQgPSBzdHJpbmdbaV07Ci0JCQlpZiAoZCAhPSBjKSB7Ci0JCQkJc2IuYXBwZW5kKGQpOwotCQkJfQotCQl9Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGFsbCBvY2N1cnJlbmNlcyBvZiB0aGUgc3BlY2lmaWVkIGNoYXJhY3RlcgotCSAqIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcgYW5kIGFwcGVuZCB0aGUgcmVzdWx0IHRvIHRoZQotCSAqIHNwZWNpZmllZCBzdHJpbmcgYnVpbGRlci4KLQkgKiBTdHJpbmcjcmVtb3ZlQWxsT2NjdXJyZW5jZXNPbihjaGFyLCBTdHJpbmdCdWlsZGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCByZW1vdmVBbGxPY2N1cnJlbmNlc09uKGNoYXJbXSBzdHJpbmcsIGNoYXIgYywgU3RyaW5nQnVpbGRlciBzYikgewotCQlpbnQgZmlyc3QgPSBDb2xsZWN0aW9uVG9vbHMuaW5kZXhPZihzdHJpbmcsIGMpOwotCQlpZiAoZmlyc3QgPT0gLTEpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcpOwotCQl9IGVsc2UgewotCQkJcmVtb3ZlQWxsT2NjdXJyZW5jZXNPbl8oc3RyaW5nLCBjLCBmaXJzdCwgc2IpOwotCQl9Ci0JfQotCi0JLyoKLQkgKiBUaGUgaW5kZXggb2YgdGhlIGZpcnN0IG1hdGNoaW5nIGNoYXJhY3RlciBpcyBwYXNzZWQgaW4uCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCByZW1vdmVBbGxPY2N1cnJlbmNlc09uXyhjaGFyW10gc3RyaW5nLCBjaGFyIGMsIGludCBmaXJzdCwgU3RyaW5nQnVpbGRlciBzYikgewotCQlzYi5hcHBlbmQoc3RyaW5nLCAwLCBmaXJzdCk7Ci0JCWludCBsZW4gPSBzdHJpbmcubGVuZ3RoOwotCQlmb3IgKGludCBpID0gZmlyc3Q7IGkgPCBsZW47IGkrKykgewotCQkJY2hhciBkID0gc3RyaW5nW2ldOwotCQkJaWYgKGQgIT0gYykgewotCQkJCXNiLmFwcGVuZChkKTsKLQkJCX0KLQkJfQotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBhbGwgdGhlIHNwYWNlcyBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGFuZCByZXR1cm4gdGhlIHJlc3VsdC4KLQkgKiBTdHJpbmcjcmVtb3ZlQWxsU3BhY2VzKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyByZW1vdmVBbGxTcGFjZXMoU3RyaW5nIHN0cmluZykgewotCQlyZXR1cm4gcmVtb3ZlQWxsT2NjdXJyZW5jZXMoc3RyaW5nLCAnICcpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBhbGwgdGhlIHNwYWNlcwotCSAqIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcgYW5kIHdyaXRlIHRoZSByZXN1bHQgdG8gdGhlIHNwZWNpZmllZCB3cml0ZXIuCi0JICogU3RyaW5nI3JlbW92ZUFsbFNwYWNlc09uKFdyaXRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcmVtb3ZlQWxsU3BhY2VzT24oU3RyaW5nIHN0cmluZywgV3JpdGVyIHdyaXRlcikgewotCQlyZW1vdmVBbGxPY2N1cnJlbmNlc09uKHN0cmluZywgJyAnLCB3cml0ZXIpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBhbGwgdGhlIHNwYWNlcwotCSAqIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcgYW5kIHdyaXRlIHRoZSByZXN1bHQgdG8gdGhlIHNwZWNpZmllZAotCSAqIHN0cmluZyBidWZmZXIuCi0JICogU3RyaW5nI3JlbW92ZUFsbFNwYWNlc09uKFN0cmluZ0J1ZmZlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcmVtb3ZlQWxsU3BhY2VzT24oU3RyaW5nIHN0cmluZywgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCXJlbW92ZUFsbE9jY3VycmVuY2VzT24oc3RyaW5nLCAnICcsIHNiKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYWxsIHRoZSBzcGFjZXMKLQkgKiBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGFuZCB3cml0ZSB0aGUgcmVzdWx0IHRvIHRoZSBzcGVjaWZpZWQKLQkgKiBzdHJpbmcgYnVpbGRlci4KLQkgKiBTdHJpbmcjcmVtb3ZlQWxsU3BhY2VzT24oU3RyaW5nQnVpbGRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcmVtb3ZlQWxsU3BhY2VzT24oU3RyaW5nIHN0cmluZywgU3RyaW5nQnVpbGRlciBzYikgewotCQlyZW1vdmVBbGxPY2N1cnJlbmNlc09uKHN0cmluZywgJyAnLCBzYik7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGFsbCB0aGUgc3BhY2VzIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcgYW5kIHJldHVybiB0aGUgcmVzdWx0LgotCSAqIFN0cmluZyNyZW1vdmVBbGxTcGFjZXMoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIHJlbW92ZUFsbFNwYWNlcyhjaGFyW10gc3RyaW5nKSB7Ci0JCXJldHVybiByZW1vdmVBbGxPY2N1cnJlbmNlcyhzdHJpbmcsICcgJyk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGFsbCB0aGUgc3BhY2VzCi0JICogZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgd3JpdGUgdGhlIHJlc3VsdCB0byB0aGUKLQkgKiBzcGVjaWZpZWQgd3JpdGVyLgotCSAqIFN0cmluZyNyZW1vdmVBbGxTcGFjZXNPbihXcml0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHJlbW92ZUFsbFNwYWNlc09uKGNoYXJbXSBzdHJpbmcsIFdyaXRlciB3cml0ZXIpIHsKLQkJcmVtb3ZlQWxsT2NjdXJyZW5jZXNPbihzdHJpbmcsICcgJywgd3JpdGVyKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYWxsIHRoZSBzcGFjZXMKLQkgKiBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGFuZCBhcHBlbmQgdGhlIHJlc3VsdCB0byB0aGUKLQkgKiBzcGVjaWZpZWQgc3RyaW5nIGJ1ZmZlci4KLQkgKiBTdHJpbmcjcmVtb3ZlQWxsU3BhY2VzT24oU3RyaW5nQnVmZmVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCByZW1vdmVBbGxTcGFjZXNPbihjaGFyW10gc3RyaW5nLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJcmVtb3ZlQWxsT2NjdXJyZW5jZXNPbihzdHJpbmcsICcgJywgc2IpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBhbGwgdGhlIHNwYWNlcwotCSAqIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcgYW5kIGFwcGVuZCB0aGUgcmVzdWx0IHRvIHRoZQotCSAqIHNwZWNpZmllZCBzdHJpbmcgYnVpbGRlci4KLQkgKiBTdHJpbmcjcmVtb3ZlQWxsU3BhY2VzT24oU3RyaW5nQnVpbGRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcmVtb3ZlQWxsU3BhY2VzT24oY2hhcltdIHN0cmluZywgU3RyaW5nQnVpbGRlciBzYikgewotCQlyZW1vdmVBbGxPY2N1cnJlbmNlc09uKHN0cmluZywgJyAnLCBzYik7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGFsbCB0aGUgd2hpdGVzcGFjZSBmcm9tIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGFuZCByZXR1cm4gdGhlIHJlc3VsdC4KLQkgKiBTdHJpbmcjcmVtb3ZlQWxsV2hpdGVzcGFjZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgcmVtb3ZlQWxsV2hpdGVzcGFjZShTdHJpbmcgc3RyaW5nKSB7Ci0JCWNoYXJbXSBzdHJpbmcyID0gc3RyaW5nLnRvQ2hhckFycmF5KCk7Ci0JCWludCBmaXJzdCA9IGluZGV4T2ZXaGl0ZXNwYWNlXyhzdHJpbmcyKTsKLQkJcmV0dXJuIChmaXJzdCA9PSAtMSkgPyBzdHJpbmcgOiBuZXcgU3RyaW5nKHJlbW92ZUFsbFdoaXRlc3BhY2VfKHN0cmluZzIsIGZpcnN0KSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGFsbCB0aGUgd2hpdGVzcGFjZQotCSAqIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcgYW5kIGFwcGVuZCB0aGUgcmVzdWx0IHRvIHRoZQotCSAqIHNwZWNpZmllZCB3cml0ZXIuCi0JICogU3RyaW5nI3JlbW92ZUFsbFdoaXRlc3BhY2VPbihXcml0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHJlbW92ZUFsbFdoaXRlc3BhY2VPbihTdHJpbmcgc3RyaW5nLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWNoYXJbXSBzdHJpbmcyID0gc3RyaW5nLnRvQ2hhckFycmF5KCk7Ci0JCWludCBmaXJzdCA9IGluZGV4T2ZXaGl0ZXNwYWNlXyhzdHJpbmcyKTsKLQkJaWYgKGZpcnN0ID09IC0xKSB7Ci0JCQl3cml0ZVN0cmluZ09uKHN0cmluZywgd3JpdGVyKTsKLQkJfSBlbHNlIHsKLQkJCXJlbW92ZUFsbFdoaXRlc3BhY2VPbl8oc3RyaW5nMiwgZmlyc3QsIHdyaXRlcik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYWxsIHRoZSB3aGl0ZXNwYWNlCi0JICogZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgYXBwZW5kIHRoZSByZXN1bHQgdG8gdGhlCi0JICogc3BlY2lmaWVkIHN0cmluZyBidWZmZXIuCi0JICogU3RyaW5nI3JlbW92ZUFsbFdoaXRlc3BhY2VPbihTdHJpbmdCdWZmZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHJlbW92ZUFsbFdoaXRlc3BhY2VPbihTdHJpbmcgc3RyaW5nLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJY2hhcltdIHN0cmluZzIgPSBzdHJpbmcudG9DaGFyQXJyYXkoKTsKLQkJaW50IGZpcnN0ID0gaW5kZXhPZldoaXRlc3BhY2VfKHN0cmluZzIpOwotCQlpZiAoZmlyc3QgPT0gLTEpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcpOwotCQl9IGVsc2UgewotCQkJcmVtb3ZlQWxsV2hpdGVzcGFjZU9uXyhzdHJpbmcyLCBmaXJzdCwgc2IpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGFsbCB0aGUgd2hpdGVzcGFjZQotCSAqIGZyb20gdGhlIHNwZWNpZmllZCBzdHJpbmcgYW5kIGFwcGVuZCB0aGUgcmVzdWx0IHRvIHRoZQotCSAqIHNwZWNpZmllZCBzdHJpbmcgYnVpbGRlci4KLQkgKiBTdHJpbmcjcmVtb3ZlQWxsV2hpdGVzcGFjZU9uKFN0cmluZ0J1aWxkZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHJlbW92ZUFsbFdoaXRlc3BhY2VPbihTdHJpbmcgc3RyaW5nLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWNoYXJbXSBzdHJpbmcyID0gc3RyaW5nLnRvQ2hhckFycmF5KCk7Ci0JCWludCBmaXJzdCA9IGluZGV4T2ZXaGl0ZXNwYWNlXyhzdHJpbmcyKTsKLQkJaWYgKGZpcnN0ID09IC0xKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQkJfSBlbHNlIHsKLQkJCXJlbW92ZUFsbFdoaXRlc3BhY2VPbl8oc3RyaW5nMiwgZmlyc3QsIHNiKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBhbGwgdGhlIHdoaXRlc3BhY2UgZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogU3RyaW5nI3JlbW92ZUFsbFdoaXRlc3BhY2UoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIHJlbW92ZUFsbFdoaXRlc3BhY2UoY2hhcltdIHN0cmluZykgewotCQlpbnQgZmlyc3QgPSBpbmRleE9mV2hpdGVzcGFjZV8oc3RyaW5nKTsKLQkJcmV0dXJuIChmaXJzdCA9PSAtMSkgPyBzdHJpbmcgOiByZW1vdmVBbGxXaGl0ZXNwYWNlXyhzdHJpbmcsIGZpcnN0KTsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBpbnQgaW5kZXhPZldoaXRlc3BhY2VfKGNoYXJbXSBzdHJpbmcpIHsKLQkJaW50IGxlbiA9IHN0cmluZy5sZW5ndGg7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKLQkJCWlmIChDaGFyYWN0ZXIuaXNXaGl0ZXNwYWNlKHN0cmluZ1tpXSkpIHsKLQkJCQlyZXR1cm4gaTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gLTE7Ci0JfQotCi0JLyoKLQkgKiBUaGUgaW5kZXggb2YgdGhlIGZpcnN0IG5vbi13aGl0ZXNwYWNlIGNoYXJhY3RlciBpcyBwYXNzZWQgaW4uCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgY2hhcltdIHJlbW92ZUFsbFdoaXRlc3BhY2VfKGNoYXJbXSBzdHJpbmcsIGludCBmaXJzdCkgewotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoc3RyaW5nLmxlbmd0aCk7Ci0JCXJlbW92ZUFsbFdoaXRlc3BhY2VPbl8oc3RyaW5nLCBmaXJzdCwgc2IpOwotCQlyZXR1cm4gY29udmVydFRvQ2hhckFycmF5KHNiKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYWxsIHRoZSB3aGl0ZXNwYWNlCi0JICogZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgYXBwZW5kIHRoZSByZXN1bHQgdG8gdGhlCi0JICogc3BlY2lmaWVkIHdyaXRlci4KLQkgKiBTdHJpbmcjcmVtb3ZlQWxsV2hpdGVzcGFjZU9uKFdyaXRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcmVtb3ZlQWxsV2hpdGVzcGFjZU9uKGNoYXJbXSBzdHJpbmcsIFdyaXRlciB3cml0ZXIpIHsKLQkJaW50IGZpcnN0ID0gaW5kZXhPZldoaXRlc3BhY2VfKHN0cmluZyk7Ci0JCWlmIChmaXJzdCA9PSAtMSkgewotCQkJd3JpdGVTdHJpbmdPbihzdHJpbmcsIHdyaXRlcik7Ci0JCX0gZWxzZSB7Ci0JCQlyZW1vdmVBbGxXaGl0ZXNwYWNlT25fKHN0cmluZywgZmlyc3QsIHdyaXRlcik7Ci0JCX0KLQl9Ci0KLQkvKgotCSAqIFRoZSBpbmRleCBvZiB0aGUgZmlyc3Qgbm9uLXdoaXRlc3BhY2UgY2hhcmFjdGVyIGlzIHBhc3NlZCBpbi4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIHJlbW92ZUFsbFdoaXRlc3BhY2VPbl8oY2hhcltdIHN0cmluZywgaW50IGZpcnN0LCBXcml0ZXIgd3JpdGVyKSB7Ci0JCXdyaXRlU3RyaW5nT24oc3RyaW5nLCAwLCBmaXJzdCwgd3JpdGVyKTsKLQkJaW50IGxlbiA9IHN0cmluZy5sZW5ndGg7Ci0JCWZvciAoaW50IGkgPSBmaXJzdDsgaSA8IGxlbjsgaSsrKSB7Ci0JCQljaGFyIGMgPSBzdHJpbmdbaV07Ci0JCQlpZiAoICEgQ2hhcmFjdGVyLmlzV2hpdGVzcGFjZShjKSkgewotCQkJCXdyaXRlQ2hhck9uKGMsIHdyaXRlcik7Ci0JCQl9Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYWxsIHRoZSB3aGl0ZXNwYWNlCi0JICogZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgYXBwZW5kIHRoZSByZXN1bHQgdG8gdGhlCi0JICogc3BlY2lmaWVkIHN0cmluZyBidWZmZXIuCi0JICogU3RyaW5nI3JlbW92ZUFsbFdoaXRlc3BhY2VPbihTdHJpbmdCdWZmZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHJlbW92ZUFsbFdoaXRlc3BhY2VPbihjaGFyW10gc3RyaW5nLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJaW50IGZpcnN0ID0gaW5kZXhPZldoaXRlc3BhY2VfKHN0cmluZyk7Ci0JCWlmIChmaXJzdCA9PSAtMSkgewotCQkJc2IuYXBwZW5kKHN0cmluZyk7Ci0JCX0gZWxzZSB7Ci0JCQlyZW1vdmVBbGxXaGl0ZXNwYWNlT25fKHN0cmluZywgZmlyc3QsIHNiKTsKLQkJfQotCX0KLQotCS8qCi0JICogVGhlIGluZGV4IG9mIHRoZSBmaXJzdCBub24td2hpdGVzcGFjZSBjaGFyYWN0ZXIgaXMgcGFzc2VkIGluLgotCSAqLwotCXByaXZhdGUgc3RhdGljIHZvaWQgcmVtb3ZlQWxsV2hpdGVzcGFjZU9uXyhjaGFyW10gc3RyaW5nLCBpbnQgZmlyc3QsIFN0cmluZ0J1ZmZlciBzYikgewotCQlzYi5hcHBlbmQoc3RyaW5nLCAwLCBmaXJzdCk7Ci0JCWludCBsZW4gPSBzdHJpbmcubGVuZ3RoOwotCQlmb3IgKGludCBpID0gZmlyc3Q7IGkgPCBsZW47IGkrKykgewotCQkJY2hhciBjID0gc3RyaW5nW2ldOwotCQkJaWYgKCAhIENoYXJhY3Rlci5pc1doaXRlc3BhY2UoYykpIHsKLQkJCQlzYi5hcHBlbmQoYyk7Ci0JCQl9Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYWxsIHRoZSB3aGl0ZXNwYWNlCi0JICogZnJvbSB0aGUgc3BlY2lmaWVkIHN0cmluZyBhbmQgYXBwZW5kIHRoZSByZXN1bHQgdG8gdGhlCi0JICogc3BlY2lmaWVkIHN0cmluZyBidWlsZGVyLgotCSAqIFN0cmluZyNyZW1vdmVBbGxXaGl0ZXNwYWNlT24oU3RyaW5nQnVpbGRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgcmVtb3ZlQWxsV2hpdGVzcGFjZU9uKGNoYXJbXSBzdHJpbmcsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJaW50IGZpcnN0ID0gaW5kZXhPZldoaXRlc3BhY2VfKHN0cmluZyk7Ci0JCWlmIChmaXJzdCA9PSAtMSkgewotCQkJc2IuYXBwZW5kKHN0cmluZyk7Ci0JCX0gZWxzZSB7Ci0JCQlyZW1vdmVBbGxXaGl0ZXNwYWNlT25fKHN0cmluZywgZmlyc3QsIHNiKTsKLQkJfQotCX0KLQotCS8qCi0JICogVGhlIGluZGV4IG9mIHRoZSBmaXJzdCBub24td2hpdGVzcGFjZSBjaGFyYWN0ZXIgaXMgcGFzc2VkIGluLgotCSAqLwotCXByaXZhdGUgc3RhdGljIHZvaWQgcmVtb3ZlQWxsV2hpdGVzcGFjZU9uXyhjaGFyW10gc3RyaW5nLCBpbnQgZmlyc3QsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJc2IuYXBwZW5kKHN0cmluZywgMCwgZmlyc3QpOwotCQlpbnQgbGVuID0gc3RyaW5nLmxlbmd0aDsKLQkJZm9yIChpbnQgaSA9IGZpcnN0OyBpIDwgbGVuOyBpKyspIHsKLQkJCWNoYXIgYyA9IHN0cmluZ1tpXTsKLQkJCWlmICggISBDaGFyYWN0ZXIuaXNXaGl0ZXNwYWNlKGMpKSB7Ci0JCQkJc2IuYXBwZW5kKGMpOwotCQkJfQotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbW1vbiBwcmVmaXggKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBsZW5ndGggb2YgdGhlIGNvbW1vbiBwcmVmaXggc2hhcmVkIGJ5IHRoZSBzcGVjaWZpZWQgc3RyaW5ncy4KLQkgKiBTdHJpbmcjY29tbW9uUHJlZml4TGVuZ3RoKFN0cmluZykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludCBjb21tb25QcmVmaXhMZW5ndGgoU3RyaW5nIHMxLCBTdHJpbmcgczIpIHsKLQkJcmV0dXJuIGNvbW1vblByZWZpeExlbmd0aChzMS50b0NoYXJBcnJheSgpLCBzMi50b0NoYXJBcnJheSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGxlbmd0aCBvZiB0aGUgY29tbW9uIHByZWZpeCBzaGFyZWQgYnkgdGhlIHNwZWNpZmllZCBzdHJpbmdzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50IGNvbW1vblByZWZpeExlbmd0aChjaGFyW10gczEsIGNoYXJbXSBzMikgewotCQlyZXR1cm4gY29tbW9uUHJlZml4TGVuZ3RoXyhzMSwgczIsIE1hdGgubWluKHMxLmxlbmd0aCwgczIubGVuZ3RoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBsZW5ndGggb2YgdGhlIGNvbW1vbiBwcmVmaXggc2hhcmVkIGJ5IHRoZSBzcGVjaWZpZWQgc3RyaW5nczsKLQkgKiBidXQgbGltaXQgdGhlIGxlbmd0aCB0byB0aGUgc3BlY2lmaWVkIG1heGltdW0uCi0JICogU3RyaW5nI2NvbW1vblByZWZpeExlbmd0aChTdHJpbmcsIGludCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGludCBjb21tb25QcmVmaXhMZW5ndGgoU3RyaW5nIHMxLCBTdHJpbmcgczIsIGludCBtYXgpIHsKLQkJcmV0dXJuIGNvbW1vblByZWZpeExlbmd0aChzMS50b0NoYXJBcnJheSgpLCBzMi50b0NoYXJBcnJheSgpLCBtYXgpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgbGVuZ3RoIG9mIHRoZSBjb21tb24gcHJlZml4IHNoYXJlZCBieSB0aGUgc3BlY2lmaWVkIHN0cmluZ3M7Ci0JICogYnV0IGxpbWl0IHRoZSBsZW5ndGggdG8gdGhlIHNwZWNpZmllZCBtYXhpbXVtLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50IGNvbW1vblByZWZpeExlbmd0aChjaGFyW10gczEsIGNoYXJbXSBzMiwgaW50IG1heCkgewotCQlyZXR1cm4gY29tbW9uUHJlZml4TGVuZ3RoXyhzMSwgczIsIE1hdGgubWluKG1heCwgTWF0aC5taW4oczEubGVuZ3RoLCBzMi5sZW5ndGgpKSk7Ci0JfQotCi0JLyoKLQkgKiBSZXR1cm4gdGhlIGxlbmd0aCBvZiB0aGUgY29tbW9uIHByZWZpeCBzaGFyZWQgYnkgdGhlIHNwZWNpZmllZCBzdHJpbmdzOwotCSAqIGJ1dCBsaW1pdCB0aGUgbGVuZ3RoIHRvIHRoZSBzcGVjaWZpZWQgbWF4aW11bS4gQXNzdW1lIHRoZSBzcGVjaWZpZWQKLQkgKiBtYXhpbXVtIGlzIGxlc3MgdGhhbiB0aGUgbGVuZ3RocyBvZiB0aGUgc3BlY2lmaWVkIHN0cmluZ3MuCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgaW50IGNvbW1vblByZWZpeExlbmd0aF8oY2hhcltdIHMxLCBjaGFyW10gczIsIGludCBtYXgpIHsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBtYXg7IGkrKykgewotCQkJaWYgKHMxW2ldICE9IHMyW2ldKSB7Ci0JCQkJcmV0dXJuIGk7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIG1heDsJLy8gYWxsIHRoZSBjaGFyYWN0ZXJzIHVwIHRvICdtYXgnIGFyZSB0aGUgc2FtZQotCX0KLQotCi0JLy8gKioqKioqKioqKiBjYXBpdGFsaXphdGlvbiAqKioqKioqKioqCi0KLQkvKgotCSAqIG5vIHplcm8tbGVuZ3RoIGNoZWNrIG9yIGxvd2VyIGNhc2UgY2hlY2sKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBjaGFyW10gY2FwaXRhbGl6ZV8oY2hhcltdIHN0cmluZykgewotCQlzdHJpbmdbMF0gPSBDaGFyYWN0ZXIudG9VcHBlckNhc2Uoc3RyaW5nWzBdKTsKLQkJcmV0dXJuIHN0cmluZzsKLQl9Ci0KLQkvKioKLQkgKiBNb2RpZnkgYW5kIHJldHVybiB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRoCi0JICogaXRzIGZpcnN0IGxldHRlciBjYXBpdGFsaXplZC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXJbXSBjYXBpdGFsaXplKGNoYXJbXSBzdHJpbmcpIHsKLQkJaWYgKChzdHJpbmcubGVuZ3RoID09IDApIHx8IENoYXJhY3Rlci5pc1VwcGVyQ2FzZShzdHJpbmdbMF0pKSB7Ci0JCQlyZXR1cm4gc3RyaW5nOwotCQl9Ci0JCXJldHVybiBjYXBpdGFsaXplXyhzdHJpbmcpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRoIGl0cyBmaXJzdCBsZXR0ZXIgY2FwaXRhbGl6ZWQuCi0JICogU3RyaW5nI2NhcGl0YWxpemUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGNhcGl0YWxpemUoU3RyaW5nIHN0cmluZykgewotCQlpZiAoKHN0cmluZy5sZW5ndGgoKSA9PSAwKSB8fCBDaGFyYWN0ZXIuaXNVcHBlckNhc2Uoc3RyaW5nLmNoYXJBdCgwKSkpIHsKLQkJCXJldHVybiBzdHJpbmc7Ci0JCX0KLQkJcmV0dXJuIG5ldyBTdHJpbmcoY2FwaXRhbGl6ZV8oc3RyaW5nLnRvQ2hhckFycmF5KCkpKTsKLQl9Ci0KLQkvKioKLQkgKiBNb2RpZnkgZWFjaCBvZiB0aGUgc3BlY2lmaWVkIHN0cmluZ3MsIGNhcGl0YWxpemluZyB0aGUgZmlyc3QgbGV0dGVyIG9mCi0JICogZWFjaC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEl0ZXJhdG9yPFN0cmluZz4gY2FwaXRhbGl6ZShJdGVyYXRvcjxTdHJpbmc+IHN0cmluZ3MpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yPFN0cmluZywgU3RyaW5nPihzdHJpbmdzKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKFN0cmluZyBzdHJpbmcpIHsKLQkJCQlyZXR1cm4gU3RyaW5nVG9vbHMuY2FwaXRhbGl6ZShzdHJpbmcpOwotCQkJfQotCQl9OwotCX0KLQotCS8qKgotCSAqIE1vZGlmeSBlYWNoIG9mIHRoZSBzcGVjaWZpZWQgc3RyaW5ncywgY2FwaXRhbGl6aW5nIHRoZSBmaXJzdCBsZXR0ZXIgb2YKLQkgKiBlYWNoLgotCSAqLwotCS8vIGNhbm5vdCBuYW1lIG1ldGhvZCBzaW1wbHkgJ2NhcGl0YWxpemUnIGJlY2F1c2Ugb2YgdHlwZS1lcmFzdXJlLi4uCi0JcHVibGljIHN0YXRpYyBJdGVyYXRvcjxjaGFyW10+IGNhcGl0YWxpemVDaGFyQXJyYXlzKEl0ZXJhdG9yPGNoYXJbXT4gc3RyaW5ncykgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8Y2hhcltdLCBjaGFyW10+KHN0cmluZ3MpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGNoYXJbXSB0cmFuc2Zvcm0oY2hhcltdIHN0cmluZykgewotCQkJCXJldHVybiBTdHJpbmdUb29scy5jYXBpdGFsaXplKHN0cmluZyk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JLyoKLQkgKiBubyB6ZXJvLWxlbmd0aCBjaGVjayBvciB1cHBlciBjYXNlIGNoZWNrCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBjYXBpdGFsaXplT25fKGNoYXJbXSBzdHJpbmcsIFN0cmluZ0J1ZmZlciBzYikgewotCQlzYi5hcHBlbmQoQ2hhcmFjdGVyLnRvVXBwZXJDYXNlKHN0cmluZ1swXSkpOwotCQlzYi5hcHBlbmQoc3RyaW5nLCAxLCBzdHJpbmcubGVuZ3RoIC0gMSk7Ci0JfQotCi0JLyoqCi0JICogQXBwZW5kIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGJ1ZmZlcgotCSAqIHdpdGggaXRzIGZpcnN0IGxldHRlciBjYXBpdGFsaXplZC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgY2FwaXRhbGl6ZU9uKGNoYXJbXSBzdHJpbmcsIFN0cmluZ0J1ZmZlciBzYikgewotCQlpZiAoc3RyaW5nLmxlbmd0aCA9PSAwKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQkJaWYgKENoYXJhY3Rlci5pc1VwcGVyQ2FzZShzdHJpbmdbMF0pKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQkJfSBlbHNlIHsKLQkJCWNhcGl0YWxpemVPbl8oc3RyaW5nLCBzYik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBBcHBlbmQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBzdHJpbmcgYnVmZmVyCi0JICogd2l0aCBpdHMgZmlyc3QgbGV0dGVyIGNhcGl0YWxpemVkLgotCSAqIFN0cmluZyNjYXBpdGFsaXplT24oU3RyaW5nQnVmZmVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBjYXBpdGFsaXplT24oU3RyaW5nIHN0cmluZywgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWlmIChzdHJpbmcubGVuZ3RoKCkgPT0gMCkgewotCQkJcmV0dXJuOwotCQl9Ci0JCWlmIChDaGFyYWN0ZXIuaXNVcHBlckNhc2Uoc3RyaW5nLmNoYXJBdCgwKSkpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcpOwotCQl9IGVsc2UgewotCQkJY2FwaXRhbGl6ZU9uXyhzdHJpbmcudG9DaGFyQXJyYXkoKSwgc2IpOwotCQl9Ci0JfQotCi0JLyoKLQkgKiBubyB6ZXJvLWxlbmd0aCBjaGVjayBvciB1cHBlciBjYXNlIGNoZWNrCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBjYXBpdGFsaXplT25fKGNoYXJbXSBzdHJpbmcsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJc2IuYXBwZW5kKENoYXJhY3Rlci50b1VwcGVyQ2FzZShzdHJpbmdbMF0pKTsKLQkJc2IuYXBwZW5kKHN0cmluZywgMSwgc3RyaW5nLmxlbmd0aCAtIDEpOwotCX0KLQotCS8qKgotCSAqIEFwcGVuZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIHN0cmluZyBidWlsZGVyCi0JICogd2l0aCBpdHMgZmlyc3QgbGV0dGVyIGNhcGl0YWxpemVkLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBjYXBpdGFsaXplT24oY2hhcltdIHN0cmluZywgU3RyaW5nQnVpbGRlciBzYikgewotCQlpZiAoc3RyaW5nLmxlbmd0aCA9PSAwKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQkJaWYgKENoYXJhY3Rlci5pc1VwcGVyQ2FzZShzdHJpbmdbMF0pKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQkJfSBlbHNlIHsKLQkJCWNhcGl0YWxpemVPbl8oc3RyaW5nLCBzYik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBBcHBlbmQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBzdHJpbmcgYnVpbGRlcgotCSAqIHdpdGggaXRzIGZpcnN0IGxldHRlciBjYXBpdGFsaXplZC4KLQkgKiBTdHJpbmcjY2FwaXRhbGl6ZU9uKFN0cmluZ0J1ZmZlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgY2FwaXRhbGl6ZU9uKFN0cmluZyBzdHJpbmcsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJaWYgKHN0cmluZy5sZW5ndGgoKSA9PSAwKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQkJaWYgKENoYXJhY3Rlci5pc1VwcGVyQ2FzZShzdHJpbmcuY2hhckF0KDApKSkgewotCQkJc2IuYXBwZW5kKHN0cmluZyk7Ci0JCX0gZWxzZSB7Ci0JCQljYXBpdGFsaXplT25fKHN0cmluZy50b0NoYXJBcnJheSgpLCBzYik7Ci0JCX0KLQl9Ci0KLQkvKgotCSAqIG5vIHplcm8tbGVuZ3RoIGNoZWNrIG9yIHVwcGVyIGNhc2UgY2hlY2sKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIGNhcGl0YWxpemVPbl8oY2hhcltdIHN0cmluZywgV3JpdGVyIHdyaXRlcikgewotCQl3cml0ZUNoYXJPbihDaGFyYWN0ZXIudG9VcHBlckNhc2Uoc3RyaW5nWzBdKSwgd3JpdGVyKTsKLQkJd3JpdGVTdHJpbmdPbihzdHJpbmcsIDEsIHN0cmluZy5sZW5ndGggLSAxLCB3cml0ZXIpOwotCX0KLQotCS8qKgotCSAqIEFwcGVuZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIHN0cmluZyBidWZmZXIKLQkgKiB3aXRoIGl0cyBmaXJzdCBsZXR0ZXIgY2FwaXRhbGl6ZWQuCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGNhcGl0YWxpemVPbihjaGFyW10gc3RyaW5nLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWlmIChzdHJpbmcubGVuZ3RoID09IDApIHsKLQkJCXJldHVybjsKLQkJfQotCQlpZiAoQ2hhcmFjdGVyLmlzVXBwZXJDYXNlKHN0cmluZ1swXSkpIHsKLQkJCXdyaXRlU3RyaW5nT24oc3RyaW5nLCB3cml0ZXIpOwotCQl9IGVsc2UgewotCQkJY2FwaXRhbGl6ZU9uXyhzdHJpbmcsIHdyaXRlcik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBBcHBlbmQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBzdHJpbmcgYnVmZmVyCi0JICogd2l0aCBpdHMgZmlyc3QgbGV0dGVyIGNhcGl0YWxpemVkLgotCSAqIFN0cmluZyNjYXBpdGFsaXplT24oV3JpdGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBjYXBpdGFsaXplT24oU3RyaW5nIHN0cmluZywgV3JpdGVyIHdyaXRlcikgewotCQlpZiAoc3RyaW5nLmxlbmd0aCgpID09IDApIHsKLQkJCXJldHVybjsKLQkJfQotCQlpZiAoQ2hhcmFjdGVyLmlzVXBwZXJDYXNlKHN0cmluZy5jaGFyQXQoMCkpKSB7Ci0JCQl3cml0ZVN0cmluZ09uKHN0cmluZywgd3JpdGVyKTsKLQkJfSBlbHNlIHsKLQkJCWNhcGl0YWxpemVPbl8oc3RyaW5nLnRvQ2hhckFycmF5KCksIHdyaXRlcik7Ci0JCX0KLQl9Ci0KLQkvKgotCSAqIG5vIHplcm8tbGVuZ3RoIGNoZWNrIG9yIGxvd2VyIGNhc2UgY2hlY2sKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBjaGFyW10gdW5jYXBpdGFsaXplXyhjaGFyW10gc3RyaW5nKSB7Ci0JCXN0cmluZ1swXSA9IENoYXJhY3Rlci50b0xvd2VyQ2FzZShzdHJpbmdbMF0pOwotCQlyZXR1cm4gc3RyaW5nOwotCX0KLQotCXByaXZhdGUgc3RhdGljIGJvb2xlYW4gc3RyaW5nTmVlZE5vdEJlVW5jYXBpdGFsaXplZF8oY2hhcltdIHN0cmluZykgewotCQlpZiAoc3RyaW5nLmxlbmd0aCA9PSAwKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCQlpZiAoQ2hhcmFjdGVyLmlzTG93ZXJDYXNlKHN0cmluZ1swXSkpIHsKLQkJCXJldHVybiB0cnVlOwotCQl9Ci0JCS8vIGlmIGJvdGggdGhlIGZpcnN0IGFuZCBzZWNvbmQgY2hhcmFjdGVycyBhcmUgY2FwaXRhbGl6ZWQsCi0JCS8vIHJldHVybiB0aGUgc3RyaW5nIHVuY2hhbmdlZAotCQlpZiAoKHN0cmluZy5sZW5ndGggPiAxKQotCQkJCSYmIENoYXJhY3Rlci5pc1VwcGVyQ2FzZShzdHJpbmdbMV0pCi0JCQkJJiYgQ2hhcmFjdGVyLmlzVXBwZXJDYXNlKHN0cmluZ1swXSkpewotCQkJcmV0dXJuIHRydWU7Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCS8qKgotCSAqIE1vZGlmeSBhbmQgcmV0dXJuIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGggaXRzCi0JICogZmlyc3QgbGV0dGVyIGNvbnZlcnRlZCB0byBsb3dlciBjYXNlLgotCSAqIChVbmxlc3MgYm90aCB0aGUgZmlyc3QgYW5kIHNlY29uZCBsZXR0ZXJzIGFyZSB1cHBlciBjYXNlLAotCSAqIGluIHdoaWNoIGNhc2UgdGhlIHN0cmluZyBpcyByZXR1cm5lZCB1bmNoYW5nZWQuKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhcltdIHVuY2FwaXRhbGl6ZShjaGFyW10gc3RyaW5nKSB7Ci0JCWlmIChzdHJpbmdOZWVkTm90QmVVbmNhcGl0YWxpemVkXyhzdHJpbmcpKSB7Ci0JCQlyZXR1cm4gc3RyaW5nOwotCQl9Ci0JCXJldHVybiB1bmNhcGl0YWxpemVfKHN0cmluZyk7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgYm9vbGVhbiBzdHJpbmdOZWVkTm90QmVVbmNhcGl0YWxpemVkXyhTdHJpbmcgc3RyaW5nKSB7Ci0JCWlmIChzdHJpbmcubGVuZ3RoKCkgPT0gMCkgewotCQkJcmV0dXJuIHRydWU7Ci0JCX0KLQkJaWYgKENoYXJhY3Rlci5pc0xvd2VyQ2FzZShzdHJpbmcuY2hhckF0KDApKSkgewotCQkJcmV0dXJuIHRydWU7Ci0JCX0KLQkJLy8gaWYgYm90aCB0aGUgZmlyc3QgYW5kIHNlY29uZCBjaGFyYWN0ZXJzIGFyZSBjYXBpdGFsaXplZCwKLQkJLy8gcmV0dXJuIHRoZSBzdHJpbmcgdW5jaGFuZ2VkCi0JCWlmICgoc3RyaW5nLmxlbmd0aCgpID4gMSkKLQkJCQkmJiBDaGFyYWN0ZXIuaXNVcHBlckNhc2Uoc3RyaW5nLmNoYXJBdCgxKSkKLQkJCQkmJiBDaGFyYWN0ZXIuaXNVcHBlckNhc2Uoc3RyaW5nLmNoYXJBdCgwKSkpewotCQkJcmV0dXJuIHRydWU7Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgc3BlY2lmaWVkIHN0cmluZyB3aXRoIGl0cyBmaXJzdCBsZXR0ZXIgY29udmVydGVkIHRvIGxvd2VyIGNhc2UuCi0JICogKFVubGVzcyBib3RoIHRoZSBmaXJzdCBhbmQgc2Vjb25kIGxldHRlcnMgYXJlIHVwcGVyIGNhc2UsCi0JICogaW4gd2hpY2ggY2FzZSB0aGUgc3RyaW5nIGlzIHJldHVybmVkIHVuY2hhbmdlZC4pCi0JICogU3RyaW5nI3VuY2FwaXRhbGl6ZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgdW5jYXBpdGFsaXplKFN0cmluZyBzdHJpbmcpIHsKLQkJaWYgKHN0cmluZ05lZWROb3RCZVVuY2FwaXRhbGl6ZWRfKHN0cmluZykpIHsKLQkJCXJldHVybiBzdHJpbmc7Ci0JCX0KLQkJcmV0dXJuIG5ldyBTdHJpbmcodW5jYXBpdGFsaXplXyhzdHJpbmcudG9DaGFyQXJyYXkoKSkpOwotCX0KLQotCS8qCi0JICogbm8gemVyby1sZW5ndGggY2hlY2sgb3IgbG93ZXIgY2FzZSBjaGVjawotCSAqLwotCXByaXZhdGUgc3RhdGljIHZvaWQgdW5jYXBpdGFsaXplT25fKGNoYXJbXSBzdHJpbmcsIFN0cmluZ0J1ZmZlciBzYikgewotCQlzYi5hcHBlbmQoQ2hhcmFjdGVyLnRvTG93ZXJDYXNlKHN0cmluZ1swXSkpOwotCQlzYi5hcHBlbmQoc3RyaW5nLCAxLCBzdHJpbmcubGVuZ3RoIC0gMSk7Ci0JfQotCi0JLyoqCi0JICogQXBwZW5kIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGJ1ZmZlcgotCSAqIHdpdGggaXRzIGZpcnN0IGxldHRlciBjb252ZXJ0ZWQgdG8gbG93ZXIgY2FzZS4KLQkgKiAoVW5sZXNzIGJvdGggdGhlIGZpcnN0IGFuZCBzZWNvbmQgbGV0dGVycyBhcmUgdXBwZXIgY2FzZSwKLQkgKiBpbiB3aGljaCBjYXNlIHRoZSBzdHJpbmcgaXMgcmV0dXJuZWQgdW5jaGFuZ2VkLikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgdW5jYXBpdGFsaXplT24oY2hhcltdIHN0cmluZywgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWlmIChzdHJpbmdOZWVkTm90QmVVbmNhcGl0YWxpemVkXyhzdHJpbmcpKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQkJfSBlbHNlIHsKLQkJCXVuY2FwaXRhbGl6ZU9uXyhzdHJpbmcsIHNiKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIEFwcGVuZCB0aGUgc3BlY2lmaWVkIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIHN0cmluZyBidWZmZXIKLQkgKiB3aXRoIGl0cyBmaXJzdCBsZXR0ZXIgY29udmVydGVkIHRvIGxvd2VyIGNhc2UuCi0JICogKFVubGVzcyBib3RoIHRoZSBmaXJzdCBhbmQgc2Vjb25kIGxldHRlcnMgYXJlIHVwcGVyIGNhc2UsCi0JICogaW4gd2hpY2ggY2FzZSB0aGUgc3RyaW5nIGlzIHJldHVybmVkIHVuY2hhbmdlZC4pCi0JICogU3RyaW5nI3VuY2FwaXRhbGl6ZU9uKFN0cmluZ0J1ZmZlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgdW5jYXBpdGFsaXplT24oU3RyaW5nIHN0cmluZywgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWlmIChzdHJpbmdOZWVkTm90QmVVbmNhcGl0YWxpemVkXyhzdHJpbmcpKSB7Ci0JCQlzYi5hcHBlbmQoc3RyaW5nKTsKLQkJfSBlbHNlIHsKLQkJCXVuY2FwaXRhbGl6ZU9uXyhzdHJpbmcudG9DaGFyQXJyYXkoKSwgc2IpOwotCQl9Ci0JfQotCi0JLyoKLQkgKiBubyB6ZXJvLWxlbmd0aCBjaGVjayBvciBsb3dlciBjYXNlIGNoZWNrCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCB1bmNhcGl0YWxpemVPbl8oY2hhcltdIHN0cmluZywgU3RyaW5nQnVpbGRlciBzYikgewotCQlzYi5hcHBlbmQoQ2hhcmFjdGVyLnRvTG93ZXJDYXNlKHN0cmluZ1swXSkpOwotCQlzYi5hcHBlbmQoc3RyaW5nLCAxLCBzdHJpbmcubGVuZ3RoIC0gMSk7Ci0JfQotCi0JLyoqCi0JICogQXBwZW5kIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGJ1aWxkZXIKLQkgKiB3aXRoIGl0cyBmaXJzdCBsZXR0ZXIgY29udmVydGVkIHRvIGxvd2VyIGNhc2UuCi0JICogKFVubGVzcyBib3RoIHRoZSBmaXJzdCBhbmQgc2Vjb25kIGxldHRlcnMgYXJlIHVwcGVyIGNhc2UsCi0JICogaW4gd2hpY2ggY2FzZSB0aGUgc3RyaW5nIGlzIHJldHVybmVkIHVuY2hhbmdlZC4pCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHVuY2FwaXRhbGl6ZU9uKGNoYXJbXSBzdHJpbmcsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJaWYgKHN0cmluZ05lZWROb3RCZVVuY2FwaXRhbGl6ZWRfKHN0cmluZykpIHsKLQkJCXNiLmFwcGVuZChzdHJpbmcpOwotCQl9IGVsc2UgewotCQkJdW5jYXBpdGFsaXplT25fKHN0cmluZywgc2IpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogQXBwZW5kIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGJ1aWxkZXIKLQkgKiB3aXRoIGl0cyBmaXJzdCBsZXR0ZXIgY29udmVydGVkIHRvIGxvd2VyIGNhc2UuCi0JICogKFVubGVzcyBib3RoIHRoZSBmaXJzdCBhbmQgc2Vjb25kIGxldHRlcnMgYXJlIHVwcGVyIGNhc2UsCi0JICogaW4gd2hpY2ggY2FzZSB0aGUgc3RyaW5nIGlzIHJldHVybmVkIHVuY2hhbmdlZC4pCi0JICogU3RyaW5nI3VuY2FwaXRhbGl6ZU9uKFN0cmluZ0J1ZmZlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgdW5jYXBpdGFsaXplT24oU3RyaW5nIHN0cmluZywgU3RyaW5nQnVpbGRlciBzYikgewotCQlpZiAoc3RyaW5nTmVlZE5vdEJlVW5jYXBpdGFsaXplZF8oc3RyaW5nKSkgewotCQkJc2IuYXBwZW5kKHN0cmluZyk7Ci0JCX0gZWxzZSB7Ci0JCQl1bmNhcGl0YWxpemVPbl8oc3RyaW5nLnRvQ2hhckFycmF5KCksIHNiKTsKLQkJfQotCX0KLQotCS8qCi0JICogbm8gemVyby1sZW5ndGggY2hlY2sgb3IgdXBwZXIgY2FzZSBjaGVjawotCSAqLwotCXByaXZhdGUgc3RhdGljIHZvaWQgdW5jYXBpdGFsaXplT25fKGNoYXJbXSBzdHJpbmcsIFdyaXRlciB3cml0ZXIpIHsKLQkJd3JpdGVDaGFyT24oQ2hhcmFjdGVyLnRvTG93ZXJDYXNlKHN0cmluZ1swXSksIHdyaXRlcik7Ci0JCXdyaXRlU3RyaW5nT24oc3RyaW5nLCAxLCBzdHJpbmcubGVuZ3RoIC0gMSwgd3JpdGVyKTsKLQl9Ci0KLQkvKioKLQkgKiBBcHBlbmQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBzdHJpbmcgYnVmZmVyCi0JICogd2l0aCBpdHMgZmlyc3QgbGV0dGVyIGNvbnZlcnRlZCB0byBsb3dlciBjYXNlLgotCSAqIChVbmxlc3MgYm90aCB0aGUgZmlyc3QgYW5kIHNlY29uZCBsZXR0ZXJzIGFyZSB1cHBlciBjYXNlLAotCSAqIGluIHdoaWNoIGNhc2UgdGhlIHN0cmluZyBpcyByZXR1cm5lZCB1bmNoYW5nZWQuKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCB1bmNhcGl0YWxpemVPbihjaGFyW10gc3RyaW5nLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWlmIChzdHJpbmdOZWVkTm90QmVVbmNhcGl0YWxpemVkXyhzdHJpbmcpKSB7Ci0JCQl3cml0ZVN0cmluZ09uKHN0cmluZywgd3JpdGVyKTsKLQkJfSBlbHNlIHsKLQkJCXVuY2FwaXRhbGl6ZU9uXyhzdHJpbmcsIHdyaXRlcik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBBcHBlbmQgdGhlIHNwZWNpZmllZCBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBzdHJpbmcgYnVmZmVyCi0JICogd2l0aCBpdHMgZmlyc3QgbGV0dGVyIGNvbnZlcnRlZCB0byBsb3dlciBjYXNlLgotCSAqIChVbmxlc3MgYm90aCB0aGUgZmlyc3QgYW5kIHNlY29uZCBsZXR0ZXJzIGFyZSB1cHBlciBjYXNlLAotCSAqIGluIHdoaWNoIGNhc2UgdGhlIHN0cmluZyBpcyByZXR1cm5lZCB1bmNoYW5nZWQuKQotCSAqIFN0cmluZyN1bmNhcGl0YWxpemVPbihXcml0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHVuY2FwaXRhbGl6ZU9uKFN0cmluZyBzdHJpbmcsIFdyaXRlciB3cml0ZXIpIHsKLQkJaWYgKHN0cmluZ05lZWROb3RCZVVuY2FwaXRhbGl6ZWRfKHN0cmluZykpIHsKLQkJCXdyaXRlU3RyaW5nT24oc3RyaW5nLCB3cml0ZXIpOwotCQl9IGVsc2UgewotCQkJdW5jYXBpdGFsaXplT25fKHN0cmluZy50b0NoYXJBcnJheSgpLCB3cml0ZXIpOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqICN0b1N0cmluZygpIGhlbHBlciBtZXRob2RzICoqKioqKioqKioKLQotCS8qKgotCSAqIEJ1aWxkIGEgInN0YW5kYXJkIiAjdG9TdHJpbmcoKSByZXN1bHQgZm9yIHRoZSBzcGVjaWZpZWQgb2JqZWN0Ci0JICogYW5kIGFkZGl0aW9uYWwgaW5mb3JtYXRpb246Ci0JICogCUNsYXNzTmFtZVswMEYzRUU0Ml0gKGFkZCdsIGluZm8pCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgYnVpbGRUb1N0cmluZ0ZvcihPYmplY3QgbywgT2JqZWN0IGFkZGl0aW9uYWxJbmZvKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQlidWlsZFNpbXBsZVRvU3RyaW5nT24obywgc2IpOwotCQlzYi5hcHBlbmQoIiAoIik7ICAvLyROT04tTkxTLTEkCi0JCXNiLmFwcGVuZChhZGRpdGlvbmFsSW5mbyk7Ci0JCXNiLmFwcGVuZCgnKScpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQkvKioKLQkgKiBCdWlsZCBhICJzdGFuZGFyZCIgc2ltcGxlICN0b1N0cmluZygpIHJlc3VsdCBmb3IgdGhlIHNwZWNpZmllZCBvYmplY3Q6Ci0JICogCUNsYXNzTmFtZVswMEYzRUU0Ml0KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBidWlsZFRvU3RyaW5nRm9yKE9iamVjdCBvKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQlidWlsZFNpbXBsZVRvU3RyaW5nT24obywgc2IpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQkvKioKLQkgKiBBcHBlbmQgYSAic3RhbmRhcmQiIHNpbXBsZSAjdG9TdHJpbmcoKSBmb3IgdGhlIHNwZWNpZmllZCBvYmplY3QgdG8KLQkgKiB0aGUgc3BlY2lmaWVkIHN0cmluZyBidWZmZXI6Ci0JICogCUNsYXNzTmFtZVswMEYzRUU0Ml0KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgYnVpbGRTaW1wbGVUb1N0cmluZ09uKE9iamVjdCBvLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJc2IuYXBwZW5kKENsYXNzVG9vbHMudG9TdHJpbmdDbGFzc05hbWVGb3JPYmplY3QobykpOwotCQlzYi5hcHBlbmQoJ1snKTsKLQkJLy8gdXNlIFN5c3RlbSNpZGVudGl0eUhhc2hDb2RlKE9iamVjdCksIHNpbmNlIE9iamVjdCNoYXNoQ29kZSgpIG1heSBiZSBvdmVycmlkZGVuCi0JCXNiLmFwcGVuZCh6ZXJvUGFkKEludGVnZXIudG9IZXhTdHJpbmcoU3lzdGVtLmlkZW50aXR5SGFzaENvZGUobykpLnRvVXBwZXJDYXNlKCksIDgpKTsKLQkJc2IuYXBwZW5kKCddJyk7Ci0JfQotCi0JLyoqCi0JICogQXBwZW5kIGEgInN0YW5kYXJkIiBzaW1wbGUgI3RvU3RyaW5nKCkgZm9yIHRoZSBzcGVjaWZpZWQgb2JqZWN0IHRvCi0JICogdGhlIHNwZWNpZmllZCBzdHJpbmcgYnVpbGRlcjoKLQkgKiAJQ2xhc3NOYW1lWzAwRjNFRTQyXQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBidWlsZFNpbXBsZVRvU3RyaW5nT24oT2JqZWN0IG8sIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJc2IuYXBwZW5kKENsYXNzVG9vbHMudG9TdHJpbmdDbGFzc05hbWVGb3JPYmplY3QobykpOwotCQlzYi5hcHBlbmQoJ1snKTsKLQkJLy8gdXNlIFN5c3RlbSNpZGVudGl0eUhhc2hDb2RlKE9iamVjdCksIHNpbmNlIE9iamVjdCNoYXNoQ29kZSgpIG1heSBiZSBvdmVycmlkZGVuCi0JCXNiLmFwcGVuZCh6ZXJvUGFkKEludGVnZXIudG9IZXhTdHJpbmcoU3lzdGVtLmlkZW50aXR5SGFzaENvZGUobykpLnRvVXBwZXJDYXNlKCksIDgpKTsKLQkJc2IuYXBwZW5kKCddJyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHF1ZXJpZXMgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBzdHJpbmcgaXMgbnVsbCwgZW1wdHksIG9yIGNvbnRhaW5zCi0JICogb25seSB3aGl0ZXNwYWNlIGNoYXJhY3RlcnMuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIHN0cmluZ0lzRW1wdHkoU3RyaW5nIHN0cmluZykgewotCQlpZiAoc3RyaW5nID09IG51bGwpIHsKLQkJCXJldHVybiB0cnVlOwotCQl9Ci0JCWludCBsZW4gPSBzdHJpbmcubGVuZ3RoKCk7Ci0JCWlmIChsZW4gPT0gMCkgewotCQkJcmV0dXJuIHRydWU7Ci0JCX0KLQkJcmV0dXJuIHN0cmluZ0lzRW1wdHlfKHN0cmluZy50b0NoYXJBcnJheSgpLCBsZW4pOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGlzIG51bGwsIGVtcHR5LCBvciBjb250YWlucwotCSAqIG9ubHkgd2hpdGVzcGFjZSBjaGFyYWN0ZXJzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBzdHJpbmdJc0VtcHR5KGNoYXJbXSBzdHJpbmcpIHsKLQkJaWYgKHN0cmluZyA9PSBudWxsKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCQlpbnQgbGVuID0gc3RyaW5nLmxlbmd0aDsKLQkJaWYgKGxlbiA9PSAwKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCQlyZXR1cm4gc3RyaW5nSXNFbXB0eV8oc3RyaW5nLCBsZW4pOwotCX0KLQotCXByaXZhdGUgc3RhdGljIGJvb2xlYW4gc3RyaW5nSXNFbXB0eV8oY2hhcltdIHMsIGludCBsZW4pIHsKLQkJZm9yIChpbnQgaSA9IGxlbjsgaS0tID4gMDsgKSB7Ci0JCQlpZiAoICEgQ2hhcmFjdGVyLmlzV2hpdGVzcGFjZShzW2ldKSkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIHN0cmluZyBpcyBub24tbnVsbCwgbm9uLWVtcHR5LCBhbmQgZG9lcwotCSAqIG5vdCBjb250YWluIG9ubHkgd2hpdGVzcGFjZSBjaGFyYWN0ZXJzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBzdHJpbmdJc05vdEVtcHR5KFN0cmluZyBzdHJpbmcpIHsKLQkJcmV0dXJuICEgc3RyaW5nSXNFbXB0eShzdHJpbmcpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGlzIG5vbi1udWxsLCBub24tZW1wdHksIGFuZCBkb2VzCi0JICogbm90IGNvbnRhaW4gb25seSB3aGl0ZXNwYWNlIGNoYXJhY3RlcnMuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIHN0cmluZ0lzTm90RW1wdHkoY2hhcltdIHN0cmluZykgewotCQlyZXR1cm4gISBzdHJpbmdJc0VtcHR5KHN0cmluZyk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgc3RyaW5ncyBhcmUgZXF1YWwuCi0JICogQ2hlY2sgZm9yIG51bGxzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBzdHJpbmdzQXJlRXF1YWwoU3RyaW5nIHMxLCBTdHJpbmcgczIpIHsKLQkJaWYgKChzMSA9PSBudWxsKSAmJiAoczIgPT0gbnVsbCkpIHsKLQkJCXJldHVybiB0cnVlOyAgLy8gYm90aCBhcmUgbnVsbAotCQl9Ci0JCWlmICgoczEgPT0gbnVsbCkgfHwgKHMyID09IG51bGwpKSB7Ci0JCQlyZXR1cm4gZmFsc2U7ICAvLyBvbmUgaXMgbnVsbCBidXQgdGhlIG90aGVyIGlzIG5vdAotCQl9Ci0JCXJldHVybiBzMS5lcXVhbHMoczIpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIHN0cmluZ3MgYXJlIGVxdWFsLgotCSAqIENoZWNrIGZvciBudWxscy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gc3RyaW5nc0FyZUVxdWFsKGNoYXJbXSBzMSwgY2hhcltdIHMyKSB7Ci0JCWlmICgoczEgPT0gbnVsbCkgJiYgKHMyID09IG51bGwpKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsgIC8vIGJvdGggYXJlIG51bGwKLQkJfQotCQlpZiAoKHMxID09IG51bGwpIHx8IChzMiA9PSBudWxsKSkgewotCQkJcmV0dXJuIGZhbHNlOyAgLy8gb25lIGlzIG51bGwgYnV0IHRoZSBvdGhlciBpcyBub3QKLQkJfQotCQlpbnQgbGVuID0gczEubGVuZ3RoOwotCQlpZiAobGVuICE9IHMyLmxlbmd0aCkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCWZvciAoaW50IGkgPSBsZW47IGktLSA+IDA7ICkgewotCQkJaWYgKHMxW2ldICE9IHMyW2ldKSB7Ci0JCQkJcmV0dXJuIGZhbHNlOwotCQkJfQotCQl9Ci0JCXJldHVybiB0cnVlOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIHN0cmluZ3MgYXJlIGVxdWFsLCBpZ25vcmluZyBjYXNlLgotCSAqIENoZWNrIGZvciBudWxscy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gc3RyaW5nc0FyZUVxdWFsSWdub3JlQ2FzZShTdHJpbmcgczEsIFN0cmluZyBzMikgewotCQlpZiAoKHMxID09IG51bGwpICYmIChzMiA9PSBudWxsKSkgewotCQkJcmV0dXJuIHRydWU7ICAvLyBib3RoIGFyZSBudWxsCi0JCX0KLQkJaWYgKChzMSA9PSBudWxsKSB8fCAoczIgPT0gbnVsbCkpIHsKLQkJCXJldHVybiBmYWxzZTsgIC8vIG9uZSBpcyBudWxsIGJ1dCB0aGUgb3RoZXIgaXMgbm90Ci0JCX0KLQkJcmV0dXJuIHMxLmVxdWFsc0lnbm9yZUNhc2UoczIpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIHN0cmluZ3MgYXJlIGVxdWFsLCBpZ25vcmluZyBjYXNlLgotCSAqIENoZWNrIGZvciBudWxscy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gc3RyaW5nc0FyZUVxdWFsSWdub3JlQ2FzZShjaGFyW10gczEsIGNoYXJbXSBzMikgewotCQlpZiAoKHMxID09IG51bGwpICYmIChzMiA9PSBudWxsKSkgewotCQkJcmV0dXJuIHRydWU7ICAvLyBib3RoIGFyZSBudWxsCi0JCX0KLQkJaWYgKChzMSA9PSBudWxsKSB8fCAoczIgPT0gbnVsbCkpIHsKLQkJCXJldHVybiBmYWxzZTsgIC8vIG9uZSBpcyBudWxsIGJ1dCB0aGUgb3RoZXIgaXMgbm90Ci0JCX0KLQkJaW50IGxlbiA9IHMxLmxlbmd0aDsKLQkJaWYgKGxlbiAhPSBzMi5sZW5ndGgpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlmb3IgKGludCBpID0gbGVuOyBpLS0gPiAwOyApIHsKLQkJCWlmICggISBjaGFyYWN0ZXJzQXJlRXF1YWxJZ25vcmVDYXNlKHMxW2ldLCBzMltpXSkpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBzdHJpbmcgc3RhcnRzIHdpdGggdGhlIHNwZWNpZmllZCBwcmVmaXgsCi0JICogaWdub3JpbmcgY2FzZS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gc3RyaW5nU3RhcnRzV2l0aElnbm9yZUNhc2UoY2hhcltdIHN0cmluZywgY2hhcltdIHByZWZpeCkgewotCQlpbnQgcHJlZml4TGVuZ3RoID0gcHJlZml4Lmxlbmd0aDsKLQkJaWYgKHN0cmluZy5sZW5ndGggPCBwcmVmaXhMZW5ndGgpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlmb3IgKGludCBpID0gcHJlZml4TGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCWlmICggISBjaGFyYWN0ZXJzQXJlRXF1YWxJZ25vcmVDYXNlKHN0cmluZ1tpXSwgcHJlZml4W2ldKSkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBzdHJpbmcgc3RhcnRzIHdpdGggdGhlIHNwZWNpZmllZCBwcmVmaXgsCi0JICogaWdub3JpbmcgY2FzZS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gc3RyaW5nU3RhcnRzV2l0aElnbm9yZUNhc2UoU3RyaW5nIHN0cmluZywgU3RyaW5nIHByZWZpeCkgewotCQlyZXR1cm4gc3RyaW5nLnJlZ2lvbk1hdGNoZXModHJ1ZSwgMCwgcHJlZml4LCAwLCBwcmVmaXgubGVuZ3RoKCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgY2hhcmFjdGVycyBhcmUgYXJlIGVxdWFsLCBpZ25vcmluZyBjYXNlLgotCSAqIEBzZWUgamF2YS5sYW5nLlN0cmluZyNyZWdpb25NYXRjaGVzKGJvb2xlYW4sIGludCwgU3RyaW5nLCBpbnQsIGludCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY2hhcmFjdGVyc0FyZUVxdWFsSWdub3JlQ2FzZShjaGFyIGMxLCBjaGFyIGMyKSB7Ci0JCS8vICBzb21ldGhpbmcgYWJvdXQgdGhlIEdlb3JnaWFuIGFscGhhYmV0IHJlcXVpcmVzIHVzIHRvIGNoZWNrIGxvd2VyIGNhc2UgYWxzbwotCQlyZXR1cm4gKGMxID09IGMyKQotCQkJCXx8IChDaGFyYWN0ZXIudG9VcHBlckNhc2UoYzEpID09IENoYXJhY3Rlci50b1VwcGVyQ2FzZShjMikpCi0JCQkJfHwgKENoYXJhY3Rlci50b0xvd2VyQ2FzZShjMSkgPT0gQ2hhcmFjdGVyLnRvTG93ZXJDYXNlKGMyKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBzdHJpbmcgaXMgdXBwZXJjYXNlLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBzdHJpbmdJc1VwcGVyY2FzZShTdHJpbmcgc3RyaW5nKSB7Ci0JCXJldHVybiAoc3RyaW5nLmxlbmd0aCgpID09IDApID8gZmFsc2UgOiBzdHJpbmdJc1VwcGVyY2FzZV8oc3RyaW5nKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIHN0cmluZyBpcyB1cHBlcmNhc2UuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIHN0cmluZ0lzVXBwZXJjYXNlKGNoYXJbXSBzdHJpbmcpIHsKLQkJcmV0dXJuIChzdHJpbmcubGVuZ3RoID09IDApID8gZmFsc2UgOiBzdHJpbmdJc1VwcGVyY2FzZV8obmV3IFN0cmluZyhzdHJpbmcpKTsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBib29sZWFuIHN0cmluZ0lzVXBwZXJjYXNlXyhTdHJpbmcgc3RyaW5nKSB7Ci0JCXJldHVybiBzdHJpbmcuZXF1YWxzKHN0cmluZy50b1VwcGVyQ2FzZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIHN0cmluZyBpcyBsb3dlcmNhc2UuCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIHN0cmluZ0lzTG93ZXJjYXNlKFN0cmluZyBzdHJpbmcpIHsKLQkJcmV0dXJuIChzdHJpbmcubGVuZ3RoKCkgPT0gMCkgPyBmYWxzZSA6IHN0cmluZ0lzTG93ZXJjYXNlXyhzdHJpbmcpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGlzIGxvd2VyY2FzZS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gc3RyaW5nSXNMb3dlcmNhc2UoY2hhcltdIHN0cmluZykgewotCQlyZXR1cm4gKHN0cmluZy5sZW5ndGggPT0gMCkgPyBmYWxzZSA6IHN0cmluZ0lzTG93ZXJjYXNlXyhuZXcgU3RyaW5nKHN0cmluZykpOwotCX0KLQotCXByaXZhdGUgc3RhdGljIGJvb2xlYW4gc3RyaW5nSXNMb3dlcmNhc2VfKFN0cmluZyBzdHJpbmcpIHsKLQkJcmV0dXJuIHN0cmluZy5lcXVhbHMoc3RyaW5nLnRvTG93ZXJDYXNlKCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBjb252ZXJ0IGNhbWVsIGNhc2UgdG8gYWxsIGNhcHMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJjYW1lbCBjYXNlIiBzdHJpbmcgdG8gYW4gImFsbCBjYXBzIiBzdHJpbmc6Ci0JICogImxhcmdlUHJvamVjdCIgLT4gIkxBUkdFX1BST0pFQ1QiCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY29udmVydENhbWVsQ2FzZVRvQWxsQ2FwcyhTdHJpbmcgY2FtZWxDYXNlU3RyaW5nKSB7Ci0JCWludCBsZW4gPSBjYW1lbENhc2VTdHJpbmcubGVuZ3RoKCk7Ci0JCWlmIChsZW4gPT0gMCkgewotCQkJcmV0dXJuIGNhbWVsQ2FzZVN0cmluZzsKLQkJfQotCQlyZXR1cm4gbmV3IFN0cmluZyhjb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzXyhjYW1lbENhc2VTdHJpbmcudG9DaGFyQXJyYXkoKSwgbGVuKSk7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJjYW1lbCBjYXNlIiBzdHJpbmcgdG8gYW4gImFsbCBjYXBzIiBzdHJpbmc6Ci0JICogImxhcmdlUHJvamVjdCIgLT4gIkxBUkdFX1BST0pFQ1QiCi0JICovCi0JcHVibGljIHN0YXRpYyBjaGFyW10gY29udmVydENhbWVsQ2FzZVRvQWxsQ2FwcyhjaGFyW10gY2FtZWxDYXNlU3RyaW5nKSB7Ci0JCWludCBsZW4gPSBjYW1lbENhc2VTdHJpbmcubGVuZ3RoOwotCQlpZiAobGVuID09IDApIHsKLQkJCXJldHVybiBjYW1lbENhc2VTdHJpbmc7Ci0JCX0KLQkJcmV0dXJuIGNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNfKGNhbWVsQ2FzZVN0cmluZywgbGVuKTsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBjaGFyW10gY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc18oY2hhcltdIGNhbWVsQ2FzZVN0cmluZywgaW50IGxlbikgewotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIobGVuICogMik7Ci0JCWNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPbl8oY2FtZWxDYXNlU3RyaW5nLCBsZW4sIHNiKTsKLQkJcmV0dXJuIGNvbnZlcnRUb0NoYXJBcnJheShzYik7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJjYW1lbCBjYXNlIiBzdHJpbmcgdG8gYW4gImFsbCBjYXBzIiBzdHJpbmc6Ci0JICogImxhcmdlUHJvamVjdCIgLT4gIkxBUkdFX1BST0pFQ1QiCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPbihTdHJpbmcgY2FtZWxDYXNlU3RyaW5nLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJaW50IGxlbiA9IGNhbWVsQ2FzZVN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKGxlbiAhPSAwKSB7Ci0JCQljb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT25fKGNhbWVsQ2FzZVN0cmluZy50b0NoYXJBcnJheSgpLCBsZW4sIHNiKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIENvbnZlcnQgdGhlIHNwZWNpZmllZCAiY2FtZWwgY2FzZSIgc3RyaW5nIHRvIGFuICJhbGwgY2FwcyIgc3RyaW5nOgotCSAqICJsYXJnZVByb2plY3QiIC0+ICJMQVJHRV9QUk9KRUNUIgotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBjb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT24oY2hhcltdIGNhbWVsQ2FzZVN0cmluZywgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWludCBsZW4gPSBjYW1lbENhc2VTdHJpbmcubGVuZ3RoOwotCQlpZiAobGVuICE9IDApIHsKLQkJCWNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPbl8oY2FtZWxDYXNlU3RyaW5nLCBsZW4sIHNiKTsKLQkJfQotCX0KLQotCXByaXZhdGUgc3RhdGljIHZvaWQgY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uXyhjaGFyW10gY2FtZWxDYXNlU3RyaW5nLCBpbnQgbGVuLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJY2hhciBwcmV2ID0gMDsJLy8gYXNzdW1lIDAgaXMgbm90IGEgdmFsaWQgY2hhcgotCQljaGFyIGMgPSAwOwotCQljaGFyIG5leHQgPSBjYW1lbENhc2VTdHJpbmdbMF07Ci0JCWZvciAoaW50IGkgPSAxOyBpIDw9IGxlbjsgaSsrKSB7CS8vIE5COiBzdGFydCBhdCAxIGFuZCBlbmQgYXQgbGVuIQotCQkJYyA9IG5leHQ7Ci0JCQluZXh0ID0gKChpID09IGxlbikgPyAwIDogY2FtZWxDYXNlU3RyaW5nW2ldKTsKLQkJCWlmIChjYW1lbENhc2VXb3JkQnJlYWtfKHByZXYsIGMsIG5leHQpKSB7Ci0JCQkJc2IuYXBwZW5kKCdfJyk7Ci0JCQl9Ci0JCQlzYi5hcHBlbmQoQ2hhcmFjdGVyLnRvVXBwZXJDYXNlKGMpKTsKLQkJCXByZXYgPSBjOwotCQl9Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJjYW1lbCBjYXNlIiBzdHJpbmcgdG8gYW4gImFsbCBjYXBzIiBzdHJpbmc6Ci0JICogImxhcmdlUHJvamVjdCIgLT4gIkxBUkdFX1BST0pFQ1QiCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPbihTdHJpbmcgY2FtZWxDYXNlU3RyaW5nLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWludCBsZW4gPSBjYW1lbENhc2VTdHJpbmcubGVuZ3RoKCk7Ci0JCWlmIChsZW4gIT0gMCkgewotCQkJY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uXyhjYW1lbENhc2VTdHJpbmcudG9DaGFyQXJyYXkoKSwgbGVuLCBzYik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgImNhbWVsIGNhc2UiIHN0cmluZyB0byBhbiAiYWxsIGNhcHMiIHN0cmluZzoKLQkgKiAibGFyZ2VQcm9qZWN0IiAtPiAiTEFSR0VfUFJPSkVDVCIKLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uKGNoYXJbXSBjYW1lbENhc2VTdHJpbmcsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJaW50IGxlbiA9IGNhbWVsQ2FzZVN0cmluZy5sZW5ndGg7Ci0JCWlmIChsZW4gIT0gMCkgewotCQkJY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uXyhjYW1lbENhc2VTdHJpbmcsIGxlbiwgc2IpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBjb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT25fKGNoYXJbXSBjYW1lbENhc2VTdHJpbmcsIGludCBsZW4sIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJY2hhciBwcmV2ID0gMDsJLy8gYXNzdW1lIDAgaXMgbm90IGEgdmFsaWQgY2hhcgotCQljaGFyIGMgPSAwOwotCQljaGFyIG5leHQgPSBjYW1lbENhc2VTdHJpbmdbMF07Ci0JCWZvciAoaW50IGkgPSAxOyBpIDw9IGxlbjsgaSsrKSB7CS8vIE5COiBzdGFydCBhdCAxIGFuZCBlbmQgYXQgbGVuIQotCQkJYyA9IG5leHQ7Ci0JCQluZXh0ID0gKChpID09IGxlbikgPyAwIDogY2FtZWxDYXNlU3RyaW5nW2ldKTsKLQkJCWlmIChjYW1lbENhc2VXb3JkQnJlYWtfKHByZXYsIGMsIG5leHQpKSB7Ci0JCQkJc2IuYXBwZW5kKCdfJyk7Ci0JCQl9Ci0JCQlzYi5hcHBlbmQoQ2hhcmFjdGVyLnRvVXBwZXJDYXNlKGMpKTsKLQkJCXByZXYgPSBjOwotCQl9Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJjYW1lbCBjYXNlIiBzdHJpbmcgdG8gYW4gImFsbCBjYXBzIiBzdHJpbmc6Ci0JICogImxhcmdlUHJvamVjdCIgLT4gIkxBUkdFX1BST0pFQ1QiCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPbihTdHJpbmcgY2FtZWxDYXNlU3RyaW5nLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWludCBsZW4gPSBjYW1lbENhc2VTdHJpbmcubGVuZ3RoKCk7Ci0JCWlmIChsZW4gIT0gMCkgewotCQkJY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uXyhjYW1lbENhc2VTdHJpbmcudG9DaGFyQXJyYXkoKSwgbGVuLCB3cml0ZXIpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJjYW1lbCBjYXNlIiBzdHJpbmcgdG8gYW4gImFsbCBjYXBzIiBzdHJpbmc6Ci0JICogImxhcmdlUHJvamVjdCIgLT4gIkxBUkdFX1BST0pFQ1QiCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPbihjaGFyW10gY2FtZWxDYXNlU3RyaW5nLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWludCBsZW4gPSBjYW1lbENhc2VTdHJpbmcubGVuZ3RoOwotCQlpZiAobGVuICE9IDApIHsKLQkJCWNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPbl8oY2FtZWxDYXNlU3RyaW5nLCBsZW4sIHdyaXRlcik7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyB2b2lkIGNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPbl8oY2hhcltdIGNhbWVsQ2FzZVN0cmluZywgaW50IGxlbiwgV3JpdGVyIHdyaXRlcikgewotCQljaGFyIHByZXYgPSAwOwkvLyBhc3N1bWUgMCBpcyBub3QgYSB2YWxpZCBjaGFyCi0JCWNoYXIgYyA9IDA7Ci0JCWNoYXIgbmV4dCA9IGNhbWVsQ2FzZVN0cmluZ1swXTsKLQkJZm9yIChpbnQgaSA9IDE7IGkgPD0gbGVuOyBpKyspIHsJLy8gTkI6IHN0YXJ0IGF0IDEgYW5kIGVuZCBhdCBsZW4hCi0JCQljID0gbmV4dDsKLQkJCW5leHQgPSAoKGkgPT0gbGVuKSA/IDAgOiBjYW1lbENhc2VTdHJpbmdbaV0pOwotCQkJaWYgKGNhbWVsQ2FzZVdvcmRCcmVha18ocHJldiwgYywgbmV4dCkpIHsKLQkJCQl3cml0ZUNoYXJPbignXycsIHdyaXRlcik7Ci0JCQl9Ci0JCQl3cml0ZUNoYXJPbihDaGFyYWN0ZXIudG9VcHBlckNhc2UoYyksIHdyaXRlcik7Ci0JCQlwcmV2ID0gYzsKLQkJfQotCX0KLQotCS8qKgotCSAqIENvbnZlcnQgdGhlIHNwZWNpZmllZCAiY2FtZWwgY2FzZSIgc3RyaW5nIHRvIGFuICJhbGwgY2FwcyIgc3RyaW5nOgotCSAqICJsYXJnZVByb2plY3QiIC0+ICJMQVJHRV9QUk9KRUNUIgotCSAqIExpbWl0IHRoZSByZXN1bHRpbmcgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbWF4aW11bSBsZW5ndGguCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY29udmVydENhbWVsQ2FzZVRvQWxsQ2FwcyhTdHJpbmcgY2FtZWxDYXNlU3RyaW5nLCBpbnQgbWF4TGVuZ3RoKSB7Ci0JCWludCBsZW4gPSBjYW1lbENhc2VTdHJpbmcubGVuZ3RoKCk7Ci0JCWlmICgobGVuID09IDApIHx8IChtYXhMZW5ndGggPT0gMCkpIHsKLQkJCXJldHVybiBjYW1lbENhc2VTdHJpbmc7Ci0JCX0KLQkJcmV0dXJuIG5ldyBTdHJpbmcoY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc18oY2FtZWxDYXNlU3RyaW5nLnRvQ2hhckFycmF5KCksIG1heExlbmd0aCwgbGVuKSk7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJjYW1lbCBjYXNlIiBzdHJpbmcgdG8gYW4gImFsbCBjYXBzIiBzdHJpbmc6Ci0JICogImxhcmdlUHJvamVjdCIgLT4gIkxBUkdFX1BST0pFQ1QiCi0JICogTGltaXQgdGhlIHJlc3VsdGluZyBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBtYXhpbXVtIGxlbmd0aC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXJbXSBjb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzKGNoYXJbXSBjYW1lbENhc2VTdHJpbmcsIGludCBtYXhMZW5ndGgpIHsKLQkJaW50IGxlbiA9IGNhbWVsQ2FzZVN0cmluZy5sZW5ndGg7Ci0JCWlmICgobGVuID09IDApIHx8IChtYXhMZW5ndGggPT0gMCkpIHsKLQkJCXJldHVybiBjYW1lbENhc2VTdHJpbmc7Ci0JCX0KLQkJcmV0dXJuIGNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNfKGNhbWVsQ2FzZVN0cmluZywgbWF4TGVuZ3RoLCBsZW4pOwotCX0KLQotCXByaXZhdGUgc3RhdGljIGNoYXJbXSBjb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzXyhjaGFyW10gY2FtZWxDYXNlU3RyaW5nLCBpbnQgbWF4TGVuZ3RoLCBpbnQgbGVuKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcihtYXhMZW5ndGgpOwotCQljb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT25fKGNhbWVsQ2FzZVN0cmluZywgbWF4TGVuZ3RoLCBsZW4sIHNiKTsKLQkJcmV0dXJuIGNvbnZlcnRUb0NoYXJBcnJheShzYik7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJjYW1lbCBjYXNlIiBzdHJpbmcgdG8gYW4gImFsbCBjYXBzIiBzdHJpbmc6Ci0JICogImxhcmdlUHJvamVjdCIgLT4gIkxBUkdFX1BST0pFQ1QiCi0JICogTGltaXQgdGhlIHJlc3VsdGluZyBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBtYXhpbXVtIGxlbmd0aC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uKFN0cmluZyBjYW1lbENhc2VTdHJpbmcsIGludCBtYXhMZW5ndGgsIFN0cmluZ0J1ZmZlciBzYikgewotCQlpbnQgbGVuID0gY2FtZWxDYXNlU3RyaW5nLmxlbmd0aCgpOwotCQlpZiAoKGxlbiAhPSAwKSAmJiAobWF4TGVuZ3RoICE9IDApKSB7Ci0JCQljb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT25fKGNhbWVsQ2FzZVN0cmluZy50b0NoYXJBcnJheSgpLCBtYXhMZW5ndGgsIGxlbiwgc2IpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJjYW1lbCBjYXNlIiBzdHJpbmcgdG8gYW4gImFsbCBjYXBzIiBzdHJpbmc6Ci0JICogImxhcmdlUHJvamVjdCIgLT4gIkxBUkdFX1BST0pFQ1QiCi0JICogTGltaXQgdGhlIHJlc3VsdGluZyBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBtYXhpbXVtIGxlbmd0aC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uKGNoYXJbXSBjYW1lbENhc2VTdHJpbmcsIGludCBtYXhMZW5ndGgsIFN0cmluZ0J1ZmZlciBzYikgewotCQlpbnQgbGVuID0gY2FtZWxDYXNlU3RyaW5nLmxlbmd0aDsKLQkJaWYgKChsZW4gIT0gMCkgJiYgKG1heExlbmd0aCAhPSAwKSkgewotCQkJY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uXyhjYW1lbENhc2VTdHJpbmcsIG1heExlbmd0aCwgbGVuLCBzYik7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyB2b2lkIGNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPbl8oY2hhcltdIGNhbWVsQ2FzZVN0cmluZywgaW50IG1heExlbmd0aCwgaW50IGxlbiwgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWNoYXIgcHJldiA9IDA7CS8vIGFzc3VtZSAwIGlzIG5vdCBhIHZhbGlkIGNoYXIKLQkJY2hhciBjID0gMDsKLQkJY2hhciBuZXh0ID0gY2FtZWxDYXNlU3RyaW5nWzBdOwotCQlmb3IgKGludCBpID0gMTsgaSA8PSBsZW47IGkrKykgewkvLyBOQjogc3RhcnQgYXQgMSBhbmQgZW5kIGF0IGxlbiEKLQkJCWMgPSBuZXh0OwotCQkJbmV4dCA9ICgoaSA9PSBsZW4pID8gMCA6IGNhbWVsQ2FzZVN0cmluZ1tpXSk7Ci0JCQlpZiAoY2FtZWxDYXNlV29yZEJyZWFrXyhwcmV2LCBjLCBuZXh0KSkgewotCQkJCXNiLmFwcGVuZCgnXycpOwotCQkJCWlmIChzYi5sZW5ndGgoKSA9PSBtYXhMZW5ndGgpIHsKLQkJCQkJcmV0dXJuOwotCQkJCX0KLQkJCX0KLQkJCXNiLmFwcGVuZChDaGFyYWN0ZXIudG9VcHBlckNhc2UoYykpOwotCQkJaWYgKHNiLmxlbmd0aCgpID09IG1heExlbmd0aCkgewotCQkJCXJldHVybjsKLQkJCX0KLQkJCXByZXYgPSBjOwotCQl9Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJjYW1lbCBjYXNlIiBzdHJpbmcgdG8gYW4gImFsbCBjYXBzIiBzdHJpbmc6Ci0JICogImxhcmdlUHJvamVjdCIgLT4gIkxBUkdFX1BST0pFQ1QiCi0JICogTGltaXQgdGhlIHJlc3VsdGluZyBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBtYXhpbXVtIGxlbmd0aC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uKFN0cmluZyBjYW1lbENhc2VTdHJpbmcsIGludCBtYXhMZW5ndGgsIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJaW50IGxlbiA9IGNhbWVsQ2FzZVN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKChsZW4gIT0gMCkgJiYgKG1heExlbmd0aCAhPSAwKSkgewotCQkJY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uXyhjYW1lbENhc2VTdHJpbmcudG9DaGFyQXJyYXkoKSwgbWF4TGVuZ3RoLCBsZW4sIHNiKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIENvbnZlcnQgdGhlIHNwZWNpZmllZCAiY2FtZWwgY2FzZSIgc3RyaW5nIHRvIGFuICJhbGwgY2FwcyIgc3RyaW5nOgotCSAqICJsYXJnZVByb2plY3QiIC0+ICJMQVJHRV9QUk9KRUNUIgotCSAqIExpbWl0IHRoZSByZXN1bHRpbmcgc3RyaW5nIHRvIHRoZSBzcGVjaWZpZWQgbWF4aW11bSBsZW5ndGguCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPbihjaGFyW10gY2FtZWxDYXNlU3RyaW5nLCBpbnQgbWF4TGVuZ3RoLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWludCBsZW4gPSBjYW1lbENhc2VTdHJpbmcubGVuZ3RoOwotCQlpZiAoKGxlbiAhPSAwKSAmJiAobWF4TGVuZ3RoICE9IDApKSB7Ci0JCQljb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT25fKGNhbWVsQ2FzZVN0cmluZywgbWF4TGVuZ3RoLCBsZW4sIHNiKTsKLQkJfQotCX0KLQotCXByaXZhdGUgc3RhdGljIHZvaWQgY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uXyhjaGFyW10gY2FtZWxDYXNlU3RyaW5nLCBpbnQgbWF4TGVuZ3RoLCBpbnQgbGVuLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWNoYXIgcHJldiA9IDA7CS8vIGFzc3VtZSAwIGlzIG5vdCBhIHZhbGlkIGNoYXIKLQkJY2hhciBjID0gMDsKLQkJY2hhciBuZXh0ID0gY2FtZWxDYXNlU3RyaW5nWzBdOwotCQlmb3IgKGludCBpID0gMTsgaSA8PSBsZW47IGkrKykgewkvLyBOQjogc3RhcnQgYXQgMSBhbmQgZW5kIGF0IGxlbiEKLQkJCWMgPSBuZXh0OwotCQkJbmV4dCA9ICgoaSA9PSBsZW4pID8gMCA6IGNhbWVsQ2FzZVN0cmluZ1tpXSk7Ci0JCQlpZiAoY2FtZWxDYXNlV29yZEJyZWFrXyhwcmV2LCBjLCBuZXh0KSkgewotCQkJCXNiLmFwcGVuZCgnXycpOwotCQkJCWlmIChzYi5sZW5ndGgoKSA9PSBtYXhMZW5ndGgpIHsKLQkJCQkJcmV0dXJuOwotCQkJCX0KLQkJCX0KLQkJCXNiLmFwcGVuZChDaGFyYWN0ZXIudG9VcHBlckNhc2UoYykpOwotCQkJaWYgKHNiLmxlbmd0aCgpID09IG1heExlbmd0aCkgewotCQkJCXJldHVybjsKLQkJCX0KLQkJCXByZXYgPSBjOwotCQl9Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJjYW1lbCBjYXNlIiBzdHJpbmcgdG8gYW4gImFsbCBjYXBzIiBzdHJpbmc6Ci0JICogImxhcmdlUHJvamVjdCIgLT4gIkxBUkdFX1BST0pFQ1QiCi0JICogTGltaXQgdGhlIHJlc3VsdGluZyBzdHJpbmcgdG8gdGhlIHNwZWNpZmllZCBtYXhpbXVtIGxlbmd0aC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uKFN0cmluZyBjYW1lbENhc2VTdHJpbmcsIGludCBtYXhMZW5ndGgsIFdyaXRlciB3cml0ZXIpIHsKLQkJaW50IGxlbiA9IGNhbWVsQ2FzZVN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKChsZW4gIT0gMCkgJiYgKG1heExlbmd0aCAhPSAwKSkgewotCQkJY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uXyhjYW1lbENhc2VTdHJpbmcudG9DaGFyQXJyYXkoKSwgbWF4TGVuZ3RoLCBsZW4sIHdyaXRlcik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgImNhbWVsIGNhc2UiIHN0cmluZyB0byBhbiAiYWxsIGNhcHMiIHN0cmluZzoKLQkgKiAibGFyZ2VQcm9qZWN0IiAtPiAiTEFSR0VfUFJPSkVDVCIKLQkgKiBMaW1pdCB0aGUgcmVzdWx0aW5nIHN0cmluZyB0byB0aGUgc3BlY2lmaWVkIG1heGltdW0gbGVuZ3RoLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBjb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT24oY2hhcltdIGNhbWVsQ2FzZVN0cmluZywgaW50IG1heExlbmd0aCwgV3JpdGVyIHdyaXRlcikgewotCQlpbnQgbGVuID0gY2FtZWxDYXNlU3RyaW5nLmxlbmd0aDsKLQkJaWYgKChsZW4gIT0gMCkgJiYgKG1heExlbmd0aCAhPSAwKSkgewotCQkJY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uXyhjYW1lbENhc2VTdHJpbmcsIG1heExlbmd0aCwgbGVuLCB3cml0ZXIpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBjb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT25fKGNoYXJbXSBjYW1lbENhc2VTdHJpbmcsIGludCBtYXhMZW5ndGgsIGludCBsZW4sIFdyaXRlciB3cml0ZXIpIHsKLQkJY2hhciBwcmV2ID0gMDsJLy8gYXNzdW1lIDAgaXMgbm90IGEgdmFsaWQgY2hhcgotCQljaGFyIGMgPSAwOwotCQljaGFyIG5leHQgPSBjYW1lbENhc2VTdHJpbmdbMF07Ci0JCWludCB3cml0ZXJMZW5ndGggPSAwOwotCQlmb3IgKGludCBpID0gMTsgaSA8PSBsZW47IGkrKykgewkvLyBOQjogc3RhcnQgYXQgMSBhbmQgZW5kIGF0IGxlbiEKLQkJCWMgPSBuZXh0OwotCQkJbmV4dCA9ICgoaSA9PSBsZW4pID8gMCA6IGNhbWVsQ2FzZVN0cmluZ1tpXSk7Ci0JCQlpZiAoY2FtZWxDYXNlV29yZEJyZWFrXyhwcmV2LCBjLCBuZXh0KSkgewotCQkJCXdyaXRlQ2hhck9uKCdfJywgd3JpdGVyKTsKLQkJCQlpZiAoKyt3cml0ZXJMZW5ndGggPT0gbWF4TGVuZ3RoKSB7Ci0JCQkJCXJldHVybjsKLQkJCQl9Ci0JCQl9Ci0JCQl3cml0ZUNoYXJPbihDaGFyYWN0ZXIudG9VcHBlckNhc2UoYyksIHdyaXRlcik7Ci0JCQlpZiAoKyt3cml0ZXJMZW5ndGggPT0gbWF4TGVuZ3RoKSB7Ci0JCQkJcmV0dXJuOwotCQkJfQotCQkJcHJldiA9IGM7Ci0JCX0KLQl9Ci0KLQkvKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgc2VyaWVzIG9mIGNoYXJhY3RlcnMgb2NjdXIgYXQKLQkgKiBhICJjYW1lbCBjYXNlIiB3b3JrIGJyZWFrOgotCSAqICAgICAiKmFhIiAtPiBmYWxzZQotCSAqICAgICAiKkFBIiAtPiBmYWxzZQotCSAqICAgICAiKkFhIiAtPiBmYWxzZQotCSAqICAgICAiQWFBIiAtPiBmYWxzZQotCSAqICAgICAiQUFBIiAtPiBmYWxzZQotCSAqICAgICAiYWEqIiAtPiBmYWxzZQotCSAqICAgICAiQWFBIiAtPiBmYWxzZQotCSAqICAgICAiYUFhIiAtPiB0cnVlCi0JICogICAgICJBQSoiIC0+IGZhbHNlCi0JICogICAgICJBQWEiIC0+IHRydWUKLQkgKiB3aGVyZSAnKicgPT0gYW55IGNoYXIKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBib29sZWFuIGNhbWVsQ2FzZVdvcmRCcmVha18oY2hhciBwcmV2LCBjaGFyIGMsIGNoYXIgbmV4dCkgewotCQlpZiAocHJldiA9PSAwKSB7CS8vIHN0YXJ0IG9mIHN0cmluZwotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCWlmIChDaGFyYWN0ZXIuaXNMb3dlckNhc2UoYykpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlpZiAoQ2hhcmFjdGVyLmlzTG93ZXJDYXNlKHByZXYpKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCQlpZiAobmV4dCA9PSAwKSB7CS8vIGVuZCBvZiBzdHJpbmcKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlyZXR1cm4gQ2hhcmFjdGVyLmlzTG93ZXJDYXNlKG5leHQpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBjb252ZXJ0IHVuZGVyc2NvcmVzIHRvIGNhbWVsIGNhc2UgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJ1bmRlcnNjb3JlIiBzdHJpbmcgdG8gYSAiY2FtZWwgY2FzZSIgc3RyaW5nOgotCSAqICJMQVJHRV9QUk9KRUNUIiAtPiAiTGFyZ2VQcm9qZWN0IgotCSAqIENhcGl0YWxpemUgdGhlIGZpcnN0IGxldHRlci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBjb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZShTdHJpbmcgdW5kZXJzY29yZVN0cmluZykgewotCQlyZXR1cm4gY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UodW5kZXJzY29yZVN0cmluZywgdHJ1ZSk7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJ1bmRlcnNjb3JlIiBzdHJpbmcgdG8gYSAiY2FtZWwgY2FzZSIgc3RyaW5nOgotCSAqICJMQVJHRV9QUk9KRUNUIiAtPiAiTGFyZ2VQcm9qZWN0IgotCSAqIENhcGl0YWxpemUgdGhlIGZpcnN0IGxldHRlci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXJbXSBjb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZShjaGFyW10gdW5kZXJzY29yZVN0cmluZykgewotCQlyZXR1cm4gY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UodW5kZXJzY29yZVN0cmluZywgdHJ1ZSk7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJ1bmRlcnNjb3JlIiBzdHJpbmcgdG8gYSAiY2FtZWwgY2FzZSIgc3RyaW5nOgotCSAqICJMQVJHRV9QUk9KRUNUIiAtPiAibGFyZ2VQcm9qZWN0IgotCSAqIE9wdGlvbmFsbHkgY2FwaXRhbGl6ZSB0aGUgZmlyc3QgbGV0dGVyLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlKFN0cmluZyB1bmRlcnNjb3JlU3RyaW5nLCBib29sZWFuIGNhcGl0YWxpemVGaXJzdExldHRlcikgewotCQlpbnQgbGVuID0gdW5kZXJzY29yZVN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKGxlbiA9PSAwKSB7Ci0JCQlyZXR1cm4gdW5kZXJzY29yZVN0cmluZzsKLQkJfQotCQlyZXR1cm4gbmV3IFN0cmluZyhjb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZV8odW5kZXJzY29yZVN0cmluZy50b0NoYXJBcnJheSgpLCBjYXBpdGFsaXplRmlyc3RMZXR0ZXIsIGxlbikpOwotCX0KLQotCS8qKgotCSAqIENvbnZlcnQgdGhlIHNwZWNpZmllZCAidW5kZXJzY29yZSIgc3RyaW5nIHRvIGEgImNhbWVsIGNhc2UiIHN0cmluZzoKLQkgKiAiTEFSR0VfUFJPSkVDVCIgLT4gImxhcmdlUHJvamVjdCIKLQkgKiBPcHRpb25hbGx5IGNhcGl0YWxpemUgdGhlIGZpcnN0IGxldHRlci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXJbXSBjb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZShjaGFyW10gdW5kZXJzY29yZVN0cmluZywgYm9vbGVhbiBjYXBpdGFsaXplRmlyc3RMZXR0ZXIpIHsKLQkJaW50IGxlbiA9IHVuZGVyc2NvcmVTdHJpbmcubGVuZ3RoOwotCQlpZiAobGVuID09IDApIHsKLQkJCXJldHVybiB1bmRlcnNjb3JlU3RyaW5nOwotCQl9Ci0JCXJldHVybiBjb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZV8odW5kZXJzY29yZVN0cmluZywgY2FwaXRhbGl6ZUZpcnN0TGV0dGVyLCBsZW4pOwotCX0KLQotCXByaXZhdGUgc3RhdGljIGNoYXJbXSBjb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZV8oY2hhcltdIHVuZGVyc2NvcmVTdHJpbmcsIGJvb2xlYW4gY2FwaXRhbGl6ZUZpcnN0TGV0dGVyLCBpbnQgbGVuKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcihsZW4pOwotCQljb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uXyh1bmRlcnNjb3JlU3RyaW5nLCBjYXBpdGFsaXplRmlyc3RMZXR0ZXIsIGxlbiwgc2IpOwotCQlyZXR1cm4gY29udmVydFRvQ2hhckFycmF5KHNiKTsKLQl9Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgInVuZGVyc2NvcmUiIHN0cmluZyB0byBhICJjYW1lbCBjYXNlIiBzdHJpbmc6Ci0JICogIkxBUkdFX1BST0pFQ1QiIC0+ICJsYXJnZVByb2plY3QiCi0JICogT3B0aW9uYWxseSBjYXBpdGFsaXplIHRoZSBmaXJzdCBsZXR0ZXIuCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT24oU3RyaW5nIHVuZGVyc2NvcmVTdHJpbmcsIGJvb2xlYW4gY2FwaXRhbGl6ZUZpcnN0TGV0dGVyLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJaW50IGxlbiA9IHVuZGVyc2NvcmVTdHJpbmcubGVuZ3RoKCk7Ci0JCWlmIChsZW4gIT0gMCkgewotCQkJY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbl8odW5kZXJzY29yZVN0cmluZy50b0NoYXJBcnJheSgpLCBjYXBpdGFsaXplRmlyc3RMZXR0ZXIsIGxlbiwgc2IpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJ1bmRlcnNjb3JlIiBzdHJpbmcgdG8gYSAiY2FtZWwgY2FzZSIgc3RyaW5nOgotCSAqICJMQVJHRV9QUk9KRUNUIiAtPiAibGFyZ2VQcm9qZWN0IgotCSAqIE9wdGlvbmFsbHkgY2FwaXRhbGl6ZSB0aGUgZmlyc3QgbGV0dGVyLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBjb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uKGNoYXJbXSB1bmRlcnNjb3JlU3RyaW5nLCBib29sZWFuIGNhcGl0YWxpemVGaXJzdExldHRlciwgU3RyaW5nQnVmZmVyIHNiKSB7Ci0JCWludCBsZW4gPSB1bmRlcnNjb3JlU3RyaW5nLmxlbmd0aDsKLQkJaWYgKGxlbiAhPSAwKSB7Ci0JCQljb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uXyh1bmRlcnNjb3JlU3RyaW5nLCBjYXBpdGFsaXplRmlyc3RMZXR0ZXIsIGxlbiwgc2IpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBjb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uXyhjaGFyW10gdW5kZXJzY29yZVN0cmluZywgYm9vbGVhbiBjYXBpdGFsaXplRmlyc3RMZXR0ZXIsIGludCBsZW4sIFN0cmluZ0J1ZmZlciBzYikgewotCQljaGFyIHByZXYgPSAwOwotCQljaGFyIGMgPSAwOwotCQlib29sZWFuIGZpcnN0ID0gdHJ1ZTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsZW47IGkrKykgewotCQkJcHJldiA9IGM7Ci0JCQljID0gdW5kZXJzY29yZVN0cmluZ1tpXTsKLQkJCWlmIChjID09ICdfJykgewotCQkJCWNvbnRpbnVlOwotCQkJfQotCQkJaWYgKGZpcnN0KSB7Ci0JCQkJZmlyc3QgPSBmYWxzZTsKLQkJCQlzYi5hcHBlbmQoY2FwaXRhbGl6ZUZpcnN0TGV0dGVyID8gQ2hhcmFjdGVyLnRvVXBwZXJDYXNlKGMpIDogQ2hhcmFjdGVyLnRvTG93ZXJDYXNlKGMpKTsKLQkJCX0gZWxzZSB7Ci0JCQkJc2IuYXBwZW5kKChwcmV2ID09ICdfJykgPyBDaGFyYWN0ZXIudG9VcHBlckNhc2UoYykgOiBDaGFyYWN0ZXIudG9Mb3dlckNhc2UoYykpOwotCQkJfQotCQl9Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgc3BlY2lmaWVkICJ1bmRlcnNjb3JlIiBzdHJpbmcgdG8gYSAiY2FtZWwgY2FzZSIgc3RyaW5nOgotCSAqICJMQVJHRV9QUk9KRUNUIiAtPiAibGFyZ2VQcm9qZWN0IgotCSAqIE9wdGlvbmFsbHkgY2FwaXRhbGl6ZSB0aGUgZmlyc3QgbGV0dGVyLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBjb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uKFN0cmluZyB1bmRlcnNjb3JlU3RyaW5nLCBib29sZWFuIGNhcGl0YWxpemVGaXJzdExldHRlciwgU3RyaW5nQnVpbGRlciBzYikgewotCQlpbnQgbGVuID0gdW5kZXJzY29yZVN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKGxlbiAhPSAwKSB7Ci0JCQljb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uXyh1bmRlcnNjb3JlU3RyaW5nLnRvQ2hhckFycmF5KCksIGNhcGl0YWxpemVGaXJzdExldHRlciwgbGVuLCBzYik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgInVuZGVyc2NvcmUiIHN0cmluZyB0byBhICJjYW1lbCBjYXNlIiBzdHJpbmc6Ci0JICogIkxBUkdFX1BST0pFQ1QiIC0+ICJsYXJnZVByb2plY3QiCi0JICogT3B0aW9uYWxseSBjYXBpdGFsaXplIHRoZSBmaXJzdCBsZXR0ZXIuCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT24oY2hhcltdIHVuZGVyc2NvcmVTdHJpbmcsIGJvb2xlYW4gY2FwaXRhbGl6ZUZpcnN0TGV0dGVyLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWludCBsZW4gPSB1bmRlcnNjb3JlU3RyaW5nLmxlbmd0aDsKLQkJaWYgKGxlbiAhPSAwKSB7Ci0JCQljb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uXyh1bmRlcnNjb3JlU3RyaW5nLCBjYXBpdGFsaXplRmlyc3RMZXR0ZXIsIGxlbiwgc2IpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBjb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uXyhjaGFyW10gdW5kZXJzY29yZVN0cmluZywgYm9vbGVhbiBjYXBpdGFsaXplRmlyc3RMZXR0ZXIsIGludCBsZW4sIFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJY2hhciBwcmV2ID0gMDsKLQkJY2hhciBjID0gMDsKLQkJYm9vbGVhbiBmaXJzdCA9IHRydWU7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKLQkJCXByZXYgPSBjOwotCQkJYyA9IHVuZGVyc2NvcmVTdHJpbmdbaV07Ci0JCQlpZiAoYyA9PSAnXycpIHsKLQkJCQljb250aW51ZTsKLQkJCX0KLQkJCWlmIChmaXJzdCkgewotCQkJCWZpcnN0ID0gZmFsc2U7Ci0JCQkJc2IuYXBwZW5kKGNhcGl0YWxpemVGaXJzdExldHRlciA/IENoYXJhY3Rlci50b1VwcGVyQ2FzZShjKSA6IENoYXJhY3Rlci50b0xvd2VyQ2FzZShjKSk7Ci0JCQl9IGVsc2UgewotCQkJCXNiLmFwcGVuZCgocHJldiA9PSAnXycpID8gQ2hhcmFjdGVyLnRvVXBwZXJDYXNlKGMpIDogQ2hhcmFjdGVyLnRvTG93ZXJDYXNlKGMpKTsKLQkJCX0KLQkJfQotCX0KLQotCS8qKgotCSAqIENvbnZlcnQgdGhlIHNwZWNpZmllZCAidW5kZXJzY29yZSIgc3RyaW5nIHRvIGEgImNhbWVsIGNhc2UiIHN0cmluZzoKLQkgKiAiTEFSR0VfUFJPSkVDVCIgLT4gImxhcmdlUHJvamVjdCIKLQkgKiBPcHRpb25hbGx5IGNhcGl0YWxpemUgdGhlIGZpcnN0IGxldHRlci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbihTdHJpbmcgdW5kZXJzY29yZVN0cmluZywgYm9vbGVhbiBjYXBpdGFsaXplRmlyc3RMZXR0ZXIsIFdyaXRlciB3cml0ZXIpIHsKLQkJaW50IGxlbiA9IHVuZGVyc2NvcmVTdHJpbmcubGVuZ3RoKCk7Ci0JCWlmIChsZW4gIT0gMCkgewotCQkJY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbl8odW5kZXJzY29yZVN0cmluZy50b0NoYXJBcnJheSgpLCBjYXBpdGFsaXplRmlyc3RMZXR0ZXIsIGxlbiwgd3JpdGVyKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIENvbnZlcnQgdGhlIHNwZWNpZmllZCAidW5kZXJzY29yZSIgc3RyaW5nIHRvIGEgImNhbWVsIGNhc2UiIHN0cmluZzoKLQkgKiAiTEFSR0VfUFJPSkVDVCIgLT4gImxhcmdlUHJvamVjdCIKLQkgKiBPcHRpb25hbGx5IGNhcGl0YWxpemUgdGhlIGZpcnN0IGxldHRlci4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIHZvaWQgY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbihjaGFyW10gdW5kZXJzY29yZVN0cmluZywgYm9vbGVhbiBjYXBpdGFsaXplRmlyc3RMZXR0ZXIsIFdyaXRlciB3cml0ZXIpIHsKLQkJaW50IGxlbiA9IHVuZGVyc2NvcmVTdHJpbmcubGVuZ3RoOwotCQlpZiAobGVuICE9IDApIHsKLQkJCWNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25fKHVuZGVyc2NvcmVTdHJpbmcsIGNhcGl0YWxpemVGaXJzdExldHRlciwgbGVuLCB3cml0ZXIpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBjb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uXyhjaGFyW10gdW5kZXJzY29yZVN0cmluZywgYm9vbGVhbiBjYXBpdGFsaXplRmlyc3RMZXR0ZXIsIGludCBsZW4sIFdyaXRlciB3cml0ZXIpIHsKLQkJY2hhciBwcmV2ID0gMDsKLQkJY2hhciBjID0gMDsKLQkJYm9vbGVhbiBmaXJzdCA9IHRydWU7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKLQkJCXByZXYgPSBjOwotCQkJYyA9IHVuZGVyc2NvcmVTdHJpbmdbaV07Ci0JCQlpZiAoYyA9PSAnXycpIHsKLQkJCQljb250aW51ZTsKLQkJCX0KLQkJCWlmIChmaXJzdCkgewotCQkJCWZpcnN0ID0gZmFsc2U7Ci0JCQkJd3JpdGVDaGFyT24oY2FwaXRhbGl6ZUZpcnN0TGV0dGVyID8gQ2hhcmFjdGVyLnRvVXBwZXJDYXNlKGMpIDogQ2hhcmFjdGVyLnRvTG93ZXJDYXNlKGMpLCB3cml0ZXIpOwotCQkJfSBlbHNlIHsKLQkJCQl3cml0ZUNoYXJPbigocHJldiA9PSAnXycpID8gQ2hhcmFjdGVyLnRvVXBwZXJDYXNlKGMpIDogQ2hhcmFjdGVyLnRvTG93ZXJDYXNlKGMpLCB3cml0ZXIpOwotCQkJfQotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbnZlcnQgdG8gSmF2YSBzdHJpbmcgbGl0ZXJhbCAqKioqKioqKioqCi0KLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBFTVBUWV9KQVZBX1NUUklOR19MSVRFUkFMID0gIlwiXCIiOyAgLy8kTk9OLU5MUy0xJAotCXB1YmxpYyBzdGF0aWMgZmluYWwgY2hhcltdIEVNUFRZX0pBVkFfU1RSSU5HX0xJVEVSQUxfQ0hBUl9BUlJBWSA9IEVNUFRZX0pBVkFfU1RSSU5HX0xJVEVSQUwudG9DaGFyQXJyYXkoKTsKLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsKFN0cmluZyBzdHJpbmcpIHsKLQkJaW50IGxlbiA9IHN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKGxlbiA9PSAwKSB7Ci0JCQlyZXR1cm4gRU1QVFlfSkFWQV9TVFJJTkdfTElURVJBTDsKLQkJfQotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIobGVuICsgNSk7Ci0JCWNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT25fKHN0cmluZy50b0NoYXJBcnJheSgpLCBzYiwgbGVuKTsKLQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7Ci0JfQotCi0JcHVibGljIHN0YXRpYyBjaGFyW10gY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWwoY2hhcltdIHN0cmluZykgewotCQlpbnQgbGVuID0gc3RyaW5nLmxlbmd0aDsKLQkJaWYgKGxlbiA9PSAwKSB7Ci0JCQlyZXR1cm4gRU1QVFlfSkFWQV9TVFJJTkdfTElURVJBTF9DSEFSX0FSUkFZOwotCQl9Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcihsZW4gKyA1KTsKLQkJY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbl8oc3RyaW5nLCBzYiwgbGVuKTsKLQkJbGVuID0gc2IubGVuZ3RoKCk7Ci0JCWNoYXJbXSByZXN1bHQgPSBuZXcgY2hhcltsZW5dOwotCQlzYi5nZXRDaGFycygwLCBsZW4sIHJlc3VsdCwgMCk7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JcHVibGljIHN0YXRpYyBJdGVyYXRvcjxTdHJpbmc+IGNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFscyhJdGVyYXRvcjxTdHJpbmc+IHN0cmluZ3MpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yPFN0cmluZywgU3RyaW5nPihzdHJpbmdzKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKFN0cmluZyBzdHJpbmcpIHsKLQkJCQlyZXR1cm4gU3RyaW5nVG9vbHMuY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWwoc3RyaW5nKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQkvLyBjYW5ub3QgbmFtZSBtZXRob2Qgc2ltcGx5ICdjb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbHMnIGJlY2F1c2Ugb2YgdHlwZS1lcmFzdXJlLi4uCi0JcHVibGljIHN0YXRpYyBJdGVyYXRvcjxjaGFyW10+IGNvbnZlcnRUb0phdmFDaGFyQXJyYXlMaXRlcmFscyhJdGVyYXRvcjxjaGFyW10+IHN0cmluZ3MpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yPGNoYXJbXSwgY2hhcltdPihzdHJpbmdzKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBjaGFyW10gdHJhbnNmb3JtKGNoYXJbXSBzdHJpbmcpIHsKLQkJCQlyZXR1cm4gU3RyaW5nVG9vbHMuY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWwoc3RyaW5nKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwdWJsaWMgc3RhdGljIHZvaWQgY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbihTdHJpbmcgc3RyaW5nLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJaW50IGxlbiA9IHN0cmluZy5sZW5ndGgoKTsKLQkJaWYgKGxlbiA9PSAwKSB7Ci0JCQlzYi5hcHBlbmQoRU1QVFlfSkFWQV9TVFJJTkdfTElURVJBTCk7Ci0JCX0gZWxzZSB7Ci0JCQljb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbE9uXyhzdHJpbmcudG9DaGFyQXJyYXkoKSwgc2IsIGxlbik7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgc3RhdGljIHZvaWQgY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbihjaGFyW10gc3RyaW5nLCBTdHJpbmdCdWZmZXIgc2IpIHsKLQkJaW50IGxlbiA9IHN0cmluZy5sZW5ndGg7Ci0JCWlmIChsZW4gPT0gMCkgewotCQkJc2IuYXBwZW5kKEVNUFRZX0pBVkFfU1RSSU5HX0xJVEVSQUwpOwotCQl9IGVsc2UgewotCQkJY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbl8oc3RyaW5nLCBzYiwgbGVuKTsKLQkJfQotCX0KLQotCS8qCi0JICogbm8gbGVuZ3RoIGNoZWNrcwotCSAqLwotCXByaXZhdGUgc3RhdGljIHZvaWQgY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbl8oY2hhcltdIHN0cmluZywgU3RyaW5nQnVmZmVyIHNiLCBpbnQgbGVuKSB7Ci0JCXNiLmVuc3VyZUNhcGFjaXR5KHNiLmxlbmd0aCgpICsgbGVuICsgNSk7Ci0JCXNiLmFwcGVuZChRVU9URSk7Ci0JCWZvciAoY2hhciBjIDogc3RyaW5nKSB7Ci0JCQlzd2l0Y2ggKGMpIHsKLQkJCQljYXNlICdcYic6ICAvLyBiYWNrc3BhY2UKLQkJCQkJc2IuYXBwZW5kKCJcXGIiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCQkJYnJlYWs7Ci0JCQkJY2FzZSAnXHQnOiAgLy8gaG9yaXpvbnRhbCB0YWIKLQkJCQkJc2IuYXBwZW5kKCJcXHQiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCQkJYnJlYWs7Ci0JCQkJY2FzZSAnXG4nOiAgLy8gbGluZS1mZWVkIExGCi0JCQkJCXNiLmFwcGVuZCgiXFxuIik7ICAvLyROT04tTkxTLTEkCi0JCQkJCWJyZWFrOwotCQkJCWNhc2UgJ1xmJzogIC8vIGZvcm0tZmVlZCBGRgotCQkJCQlzYi5hcHBlbmQoIlxcZiIpOyAgLy8kTk9OLU5MUy0xJAotCQkJCQlicmVhazsKLQkJCQljYXNlICdccic6ICAvLyBjYXJyaWFnZS1yZXR1cm4gQ1IKLQkJCQkJc2IuYXBwZW5kKCJcXHIiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCQkJYnJlYWs7Ci0JCQkJY2FzZSAnIic6ICAvLyBkb3VibGUtcXVvdGUKLQkJCQkJc2IuYXBwZW5kKCJcXFwiIik7ICAvLyROT04tTkxTLTEkCi0JCQkJCWJyZWFrOwotLy8JCQkJY2FzZSAnXCcnOiAgLy8gc2luZ2xlLXF1b3RlCi0vLwkJCQkJc2IuYXBwZW5kKCJcXCciKTsgIC8vJE5PTi1OTFMtMSQKLS8vCQkJCQlicmVhazsKLQkJCQljYXNlICdcXCc6ICAvLyBiYWNrc2xhc2gKLQkJCQkJc2IuYXBwZW5kKCJcXFxcIik7ICAvLyROT04tTkxTLTEkCi0JCQkJCWJyZWFrOwotCQkJCWRlZmF1bHQ6Ci0JCQkJCXNiLmFwcGVuZChjKTsKLQkJCQkJYnJlYWs7Ci0JCQl9Ci0JCX0KLQkJc2IuYXBwZW5kKFFVT1RFKTsKLQl9Ci0KLQlwdWJsaWMgc3RhdGljIHZvaWQgY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbihTdHJpbmcgc3RyaW5nLCBTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWludCBsZW4gPSBzdHJpbmcubGVuZ3RoKCk7Ci0JCWlmIChsZW4gPT0gMCkgewotCQkJc2IuYXBwZW5kKEVNUFRZX0pBVkFfU1RSSU5HX0xJVEVSQUwpOwotCQl9IGVsc2UgewotCQkJY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbl8oc3RyaW5nLnRvQ2hhckFycmF5KCksIHNiLCBsZW4pOwotCQl9Ci0JfQotCi0JcHVibGljIHN0YXRpYyB2b2lkIGNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT24oY2hhcltdIHN0cmluZywgU3RyaW5nQnVpbGRlciBzYikgewotCQlpbnQgbGVuID0gc3RyaW5nLmxlbmd0aDsKLQkJaWYgKGxlbiA9PSAwKSB7Ci0JCQlzYi5hcHBlbmQoRU1QVFlfSkFWQV9TVFJJTkdfTElURVJBTCk7Ci0JCX0gZWxzZSB7Ci0JCQljb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbE9uXyhzdHJpbmcsIHNiLCBsZW4pOwotCQl9Ci0JfQotCi0JLyoKLQkgKiBubyBsZW5ndGggY2hlY2tzCi0JICovCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCBjb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbE9uXyhjaGFyW10gc3RyaW5nLCBTdHJpbmdCdWlsZGVyIHNiLCBpbnQgbGVuKSB7Ci0JCXNiLmVuc3VyZUNhcGFjaXR5KHNiLmxlbmd0aCgpICsgbGVuICsgNSk7Ci0JCXNiLmFwcGVuZChRVU9URSk7Ci0JCWZvciAoY2hhciBjIDogc3RyaW5nKSB7Ci0JCQlzd2l0Y2ggKGMpIHsKLQkJCQljYXNlICdcYic6ICAvLyBiYWNrc3BhY2UKLQkJCQkJc2IuYXBwZW5kKCJcXGIiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCQkJYnJlYWs7Ci0JCQkJY2FzZSAnXHQnOiAgLy8gaG9yaXpvbnRhbCB0YWIKLQkJCQkJc2IuYXBwZW5kKCJcXHQiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCQkJYnJlYWs7Ci0JCQkJY2FzZSAnXG4nOiAgLy8gbGluZS1mZWVkIExGCi0JCQkJCXNiLmFwcGVuZCgiXFxuIik7ICAvLyROT04tTkxTLTEkCi0JCQkJCWJyZWFrOwotCQkJCWNhc2UgJ1xmJzogIC8vIGZvcm0tZmVlZCBGRgotCQkJCQlzYi5hcHBlbmQoIlxcZiIpOyAgLy8kTk9OLU5MUy0xJAotCQkJCQlicmVhazsKLQkJCQljYXNlICdccic6ICAvLyBjYXJyaWFnZS1yZXR1cm4gQ1IKLQkJCQkJc2IuYXBwZW5kKCJcXHIiKTsgIC8vJE5PTi1OTFMtMSQKLQkJCQkJYnJlYWs7Ci0JCQkJY2FzZSAnIic6ICAvLyBkb3VibGUtcXVvdGUKLQkJCQkJc2IuYXBwZW5kKCJcXFwiIik7ICAvLyROT04tTkxTLTEkCi0JCQkJCWJyZWFrOwotLy8JCQkJY2FzZSAnXCcnOiAgLy8gc2luZ2xlLXF1b3RlCi0vLwkJCQkJc2IuYXBwZW5kKCJcXCciKTsgIC8vJE5PTi1OTFMtMSQKLS8vCQkJCQlicmVhazsKLQkJCQljYXNlICdcXCc6ICAvLyBiYWNrc2xhc2gKLQkJCQkJc2IuYXBwZW5kKCJcXFxcIik7ICAvLyROT04tTkxTLTEkCi0JCQkJCWJyZWFrOwotCQkJCWRlZmF1bHQ6Ci0JCQkJCXNiLmFwcGVuZChjKTsKLQkJCQkJYnJlYWs7Ci0JCQl9Ci0JCX0KLQkJc2IuYXBwZW5kKFFVT1RFKTsKLQl9Ci0KLQlwdWJsaWMgc3RhdGljIHZvaWQgY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbihTdHJpbmcgc3RyaW5nLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWlmIChzdHJpbmcubGVuZ3RoKCkgPT0gMCkgewotCQkJd3JpdGVTdHJpbmdPbihFTVBUWV9KQVZBX1NUUklOR19MSVRFUkFMLCB3cml0ZXIpOwotCQl9IGVsc2UgewotCQkJY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbl8oc3RyaW5nLnRvQ2hhckFycmF5KCksIHdyaXRlcik7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgc3RhdGljIHZvaWQgY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbihjaGFyW10gc3RyaW5nLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCWlmIChzdHJpbmcubGVuZ3RoID09IDApIHsKLQkJCXdyaXRlU3RyaW5nT24oRU1QVFlfSkFWQV9TVFJJTkdfTElURVJBTCwgd3JpdGVyKTsKLQkJfSBlbHNlIHsKLQkJCWNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT25fKHN0cmluZywgd3JpdGVyKTsKLQkJfQotCX0KLQotCS8qCi0JICogbm8gbGVuZ3RoIGNoZWNrcwotCSAqLwotCXByaXZhdGUgc3RhdGljIHZvaWQgY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbl8oY2hhcltdIHN0cmluZywgV3JpdGVyIHdyaXRlcikgewotCQl3cml0ZUNoYXJPbihRVU9URSwgd3JpdGVyKTsKLQkJZm9yIChjaGFyIGMgOiBzdHJpbmcpIHsKLQkJCXN3aXRjaCAoYykgewotCQkJCWNhc2UgJ1xiJzogIC8vIGJhY2tzcGFjZQotCQkJCQl3cml0ZVN0cmluZ09uKCJcXGIiLCB3cml0ZXIpOyAgLy8kTk9OLU5MUy0xJAotCQkJCQlicmVhazsKLQkJCQljYXNlICdcdCc6ICAvLyBob3Jpem9udGFsIHRhYgotCQkJCQl3cml0ZVN0cmluZ09uKCJcXHQiLCB3cml0ZXIpOyAgLy8kTk9OLU5MUy0xJAotCQkJCQlicmVhazsKLQkJCQljYXNlICdcbic6ICAvLyBsaW5lLWZlZWQgTEYKLQkJCQkJd3JpdGVTdHJpbmdPbigiXFxuIiwgd3JpdGVyKTsgIC8vJE5PTi1OTFMtMSQKLQkJCQkJYnJlYWs7Ci0JCQkJY2FzZSAnXGYnOiAgLy8gZm9ybS1mZWVkIEZGCi0JCQkJCXdyaXRlU3RyaW5nT24oIlxcZiIsIHdyaXRlcik7ICAvLyROT04tTkxTLTEkCi0JCQkJCWJyZWFrOwotCQkJCWNhc2UgJ1xyJzogIC8vIGNhcnJpYWdlLXJldHVybiBDUgotCQkJCQl3cml0ZVN0cmluZ09uKCJcXHIiLCB3cml0ZXIpOyAgLy8kTk9OLU5MUy0xJAotCQkJCQlicmVhazsKLQkJCQljYXNlICciJzogIC8vIGRvdWJsZS1xdW90ZQotCQkJCQl3cml0ZVN0cmluZ09uKCJcXFwiIiwgd3JpdGVyKTsgIC8vJE5PTi1OTFMtMSQKLQkJCQkJYnJlYWs7Ci0vLwkJCQljYXNlICdcJyc6ICAvLyBzaW5nbGUtcXVvdGUKLS8vCQkJCQl3cml0ZVN0cmluZ09uKCJcXCciLCB3cml0ZXIpOyAgLy8kTk9OLU5MUy0xJAotLy8JCQkJCWJyZWFrOwotCQkJCWNhc2UgJ1xcJzogIC8vIGJhY2tzbGFzaAotCQkJCQl3cml0ZVN0cmluZ09uKCJcXFxcIiwgd3JpdGVyKTsgIC8vJE5PTi1OTFMtMSQKLQkJCQkJYnJlYWs7Ci0JCQkJZGVmYXVsdDoKLQkJCQkJd3JpdGVDaGFyT24oYywgd3JpdGVyKTsKLQkJCQkJYnJlYWs7Ci0JCQl9Ci0JCX0KLQkJd3JpdGVDaGFyT24oUVVPVEUsIHdyaXRlcik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbnZlbmllbmNlICoqKioqKioqKioKLQotCXB1YmxpYyBzdGF0aWMgY2hhcltdIGNvbnZlcnRUb0NoYXJBcnJheShTdHJpbmdCdWZmZXIgc2IpIHsKLQkJaW50IGxlbiA9IHNiLmxlbmd0aCgpOwotCQljaGFyW10gcmVzdWx0ID0gbmV3IGNoYXJbbGVuXTsKLQkJc2IuZ2V0Q2hhcnMoMCwgbGVuLCByZXN1bHQsIDApOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCXB1YmxpYyBzdGF0aWMgY2hhcltdIGNvbnZlcnRUb0NoYXJBcnJheShTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCWludCBsZW4gPSBzYi5sZW5ndGgoKTsKLQkJY2hhcltdIHJlc3VsdCA9IG5ldyBjaGFyW2xlbl07Ci0JCXNiLmdldENoYXJzKDAsIGxlbiwgcmVzdWx0LCAwKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyB2b2lkIHdyaXRlU3RyaW5nT24oY2hhcltdIHN0cmluZywgV3JpdGVyIHdyaXRlcikgewotCQl0cnkgewotCQkJd3JpdGVyLndyaXRlKHN0cmluZyk7Ci0JCX0gY2F0Y2ggKElPRXhjZXB0aW9uIGV4KSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihleCk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyB2b2lkIHdyaXRlU3RyaW5nT24oY2hhcltdIHN0cmluZywgY2hhciBlc2NhcGUsIFdyaXRlciB3cml0ZXIpIHsKLQkJdHJ5IHsKLQkJCWZvciAoY2hhciBjIDogc3RyaW5nKSB7Ci0JCQkJaWYgKGMgPT0gZXNjYXBlKSB7Ci0JCQkJCXdyaXRlci53cml0ZShjKTsKLQkJCQl9Ci0JCQkJd3JpdGVyLndyaXRlKGMpOwotCQkJfQotCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBleCkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oZXgpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgdm9pZCB3cml0ZVN0cmluZ09uKGNoYXJbXSBzdHJpbmcsIGludCBvZmYsIGludCBsZW4sIFdyaXRlciB3cml0ZXIpIHsKLQkJdHJ5IHsKLQkJCXdyaXRlci53cml0ZShzdHJpbmcsIG9mZiwgbGVuKTsKLQkJfSBjYXRjaCAoSU9FeGNlcHRpb24gZXgpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGV4KTsKLQkJfQotCX0KLQotCXByaXZhdGUgc3RhdGljIHZvaWQgd3JpdGVTdHJpbmdPbihTdHJpbmcgc3RyaW5nLCBpbnQgb2ZmLCBpbnQgbGVuLCBXcml0ZXIgd3JpdGVyKSB7Ci0JCXRyeSB7Ci0JCQl3cml0ZXIud3JpdGUoc3RyaW5nLCBvZmYsIGxlbik7Ci0JCX0gY2F0Y2ggKElPRXhjZXB0aW9uIGV4KSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihleCk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyB2b2lkIHdyaXRlU3RyaW5nT24oU3RyaW5nIHN0cmluZywgV3JpdGVyIHdyaXRlcikgewotCQl0cnkgewotCQkJd3JpdGVyLndyaXRlKHN0cmluZyk7Ci0JCX0gY2F0Y2ggKElPRXhjZXB0aW9uIGV4KSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihleCk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyB2b2lkIHdyaXRlQ2hhck9uKGNoYXIgYywgV3JpdGVyIHdyaXRlcikgewotCQl0cnkgewotCQkJd3JpdGVyLndyaXRlKGMpOwotCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBleCkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oZXgpOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9yICoqKioqKioqKioKLQotCS8qCi0JICogU3VwcHJlc3MgZGVmYXVsdCBjb25zdHJ1Y3RvciwgZW5zdXJpbmcgbm9uLWluc3RhbnRpYWJpbGl0eS4KLQkgKi8KLQlwcml2YXRlIFN0cmluZ1Rvb2xzKCkgewotCQlzdXBlcigpOwotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9TeW5jaHJvbml6ZWRCb29sZWFuLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU3luY2hyb25pemVkQm9vbGVhbi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDFhYTY0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9TeW5jaHJvbml6ZWRCb29sZWFuLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNzQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uU2VyaWFsaXphYmxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LkNvbW1hbmQ7Ci0KLS8qKgotICogVGhpcyBjbGFzcyBwcm92aWRlcyBzeW5jaHJvbml6ZWQgYWNjZXNzIHRvIGEgYm9vbGVhbiB2YWx1ZS4KLSAqIEl0IGFsc28gcHJvdmlkZXMgcHJvdG9jb2wgZm9yIHN1c3BlbmRpbmcgYSB0aHJlYWQgdW50aWwgdGhlCi0gKiBib29sZWFuIHZhbHVlIGlzIHNldCB0byB0cnVlIG9yIGZhbHNlLCB3aXRoIG9wdGlvbmFsIHRpbWUtb3V0cy4KLSAqIEBzZWUgQm9vbGVhbkhvbGRlcgotICovCi1wdWJsaWMgY2xhc3MgU3luY2hyb25pemVkQm9vbGVhbgotCWltcGxlbWVudHMgQ2xvbmVhYmxlLCBTZXJpYWxpemFibGUKLXsKLQkvKiogQmFja2luZyBib29sZWFuLiAqLwotCXByaXZhdGUgYm9vbGVhbiB2YWx1ZTsKLQotCS8qKiBPYmplY3QgdG8gc3luY2hyb25pemUgb24uICovCi0JcHJpdmF0ZSBmaW5hbCBPYmplY3QgbXV0ZXg7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ3JlYXRlIGEgc3luY2hyb25pemVkIGJvb2xlYW4gd2l0aCB0aGUgc3BlY2lmaWVkIGluaXRpYWwgdmFsdWUKLQkgKiBhbmQgbXV0ZXguCi0JICovCi0JcHVibGljIFN5bmNocm9uaXplZEJvb2xlYW4oYm9vbGVhbiB2YWx1ZSwgT2JqZWN0IG11dGV4KSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMudmFsdWUgPSB2YWx1ZTsKLQkJdGhpcy5tdXRleCA9IG11dGV4OwotCX0KLQotCS8qKgotCSAqIENyZWF0ZSBhIHN5bmNocm9uaXplZCBib29sZWFuIHdpdGggdGhlIHNwZWNpZmllZCBpbml0aWFsIHZhbHVlLgotCSAqLwotCXB1YmxpYyBTeW5jaHJvbml6ZWRCb29sZWFuKGJvb2xlYW4gdmFsdWUpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy52YWx1ZSA9IHZhbHVlOwotCQl0aGlzLm11dGV4ID0gdGhpczsKLQl9Ci0KLQkvKioKLQkgKiBDcmVhdGUgYSBzeW5jaHJvbml6ZWQgYm9vbGVhbiB3aXRoIGFuIGluaXRpYWwgdmFsdWUgb2YgZmFsc2UKLQkgKiBhbmQgc3BlY2lmaWVkIG11dGV4LgotCSAqLwotCXB1YmxpYyBTeW5jaHJvbml6ZWRCb29sZWFuKE9iamVjdCBtdXRleCkgewotCQl0aGlzKGZhbHNlLCBtdXRleCk7Ci0JfQotCi0JLyoqCi0JICogQ3JlYXRlIGEgc3luY2hyb25pemVkIGJvb2xlYW4gd2l0aCBhbiBpbml0aWFsIHZhbHVlIG9mIGZhbHNlLgotCSAqLwotCXB1YmxpYyBTeW5jaHJvbml6ZWRCb29sZWFuKCkgewotCQl0aGlzKGZhbHNlKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYWNjZXNzb3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB0aGUgY3VycmVudCBib29sZWFuIHZhbHVlLgotCSAqLwotCXB1YmxpYyBib29sZWFuIHZhbHVlKCkgewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXJldHVybiB0aGlzLnZhbHVlOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGN1cnJlbnQgYm9vbGVhbiB2YWx1ZSBpcyB0cnVlLgotCSAqLwotCXB1YmxpYyBib29sZWFuIGlzVHJ1ZSgpIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQlyZXR1cm4gdGhpcy52YWx1ZTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjdXJyZW50IGJvb2xlYW4gdmFsdWUgaXMgZmFsc2UuCi0JICovCi0JcHVibGljIGJvb2xlYW4gaXNGYWxzZSgpIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQlyZXR1cm4gISB0aGlzLnZhbHVlOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGN1cnJlbnQgYm9vbGVhbiB2YWx1ZSBpcyB0aGUgc3BlY2lmaWVkIHZhbHVlLgotCSAqLwotCXB1YmxpYyBib29sZWFuIGlzKGJvb2xlYW4gdikgewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXJldHVybiB0aGlzLnZhbHVlID09IHY7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBTZXQgdGhlIGJvb2xlYW4gdmFsdWUuIElmIHRoZSB2YWx1ZSBjaGFuZ2VzLCBhbGwgd2FpdGluZwotCSAqIHRocmVhZHMgYXJlIG5vdGlmaWVkLgotCSAqLwotCXB1YmxpYyB2b2lkIHNldFZhbHVlKGJvb2xlYW4gdmFsdWUpIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQlpZiAodGhpcy52YWx1ZSAhPSB2YWx1ZSkgewotCQkJCXRoaXMudmFsdWUgPSB2YWx1ZTsKLQkJCQl0aGlzLm11dGV4Lm5vdGlmeUFsbCgpOwotCQkJfQotCQl9Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSBib29sZWFuIHZhbHVlIHRvIHRydWUuIElmIHRoZSB2YWx1ZSBjaGFuZ2VzLCBhbGwgd2FpdGluZwotCSAqIHRocmVhZHMgYXJlIG5vdGlmaWVkLgotCSAqLwotCXB1YmxpYyB2b2lkIHNldFRydWUoKSB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJdGhpcy5zZXRWYWx1ZSh0cnVlKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFNldCB0aGUgYm9vbGVhbiB2YWx1ZSB0byBmYWxzZS4gSWYgdGhlIHZhbHVlIGNoYW5nZXMsIGFsbCB3YWl0aW5nCi0JICogdGhyZWFkcyBhcmUgbm90aWZpZWQuCi0JICovCi0JcHVibGljIHZvaWQgc2V0RmFsc2UoKSB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJdGhpcy5zZXRWYWx1ZShmYWxzZSk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG9iamVjdCB0aGlzIG9iamVjdCBsb2NrcyBvbiB3aGlsZSBwZXJmb3JtaW5nCi0JICogaXRzIG9wZXJhdGlvbnMuCi0JICovCi0JcHVibGljIE9iamVjdCBtdXRleCgpIHsKLQkJcmV0dXJuIHRoaXMubXV0ZXg7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluZGVmaW5pdGUgd2FpdHMgKioqKioqKioqKgotCi0JLyoqCi0JICogU3VzcGVuZCB0aGUgY3VycmVudCB0aHJlYWQgdW50aWwgdGhlIGJvb2xlYW4gdmFsdWUgY2hhbmdlcwotCSAqIHRvIHRoZSBzcGVjaWZpZWQgdmFsdWUuIElmIHRoZSBib29sZWFuIHZhbHVlIGlzIGFscmVhZHkgdGhlCi0JICogc3BlY2lmaWVkIHZhbHVlLCByZXR1cm4gaW1tZWRpYXRlbHkuCi0JICovCi0JcHVibGljIHZvaWQgd2FpdFVudGlsVmFsdWVJcyhib29sZWFuIHYpIHRocm93cyBJbnRlcnJ1cHRlZEV4Y2VwdGlvbiB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJd2hpbGUgKHRoaXMudmFsdWUgIT0gdikgewotCQkJCXRoaXMubXV0ZXgud2FpdCgpOwotCQkJfQotCQl9Ci0JfQotCi0JLyoqCi0JICogU3VzcGVuZCB0aGUgY3VycmVudCB0aHJlYWQgdW50aWwgdGhlIGJvb2xlYW4gdmFsdWUgY2hhbmdlcyB0byB0cnVlLgotCSAqIElmIHRoZSBib29sZWFuIHZhbHVlIGlzIGFscmVhZHkgdHJ1ZSwgcmV0dXJuIGltbWVkaWF0ZWx5LgotCSAqLwotCXB1YmxpYyB2b2lkIHdhaXRVbnRpbFRydWUoKSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXRoaXMud2FpdFVudGlsVmFsdWVJcyh0cnVlKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSBib29sZWFuIHZhbHVlIGNoYW5nZXMgdG8gZmFsc2UuCi0JICogSWYgdGhlIGJvb2xlYW4gdmFsdWUgaXMgYWxyZWFkeSBmYWxzZSwgcmV0dXJuIGltbWVkaWF0ZWx5LgotCSAqLwotCXB1YmxpYyB2b2lkIHdhaXRVbnRpbEZhbHNlKCkgdGhyb3dzIEludGVycnVwdGVkRXhjZXB0aW9uIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQl0aGlzLndhaXRVbnRpbFZhbHVlSXMoZmFsc2UpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU3VzcGVuZCB0aGUgY3VycmVudCB0aHJlYWQgdW50aWwgdGhlIGJvb2xlYW4gdmFsdWUgY2hhbmdlcyB0bwotCSAqIE5PVCB0aGUgc3BlY2lmaWVkIHZhbHVlLCB0aGVuIGNoYW5nZSBpdCBiYWNrIHRvIHRoZSBzcGVjaWZpZWQKLQkgKiB2YWx1ZSBhbmQgY29udGludWUgZXhlY3V0aW5nLiBJZiB0aGUgYm9vbGVhbiB2YWx1ZSBpcyBhbHJlYWR5Ci0JICogTk9UIHRoZSBzcGVjaWZpZWQgdmFsdWUsIHNldCB0aGUgdmFsdWUgdG8gdGhlIHNwZWNpZmllZCB2YWx1ZQotCSAqIGltbWVkaWF0ZWx5LgotCSAqLwotCXB1YmxpYyB2b2lkIHdhaXRUb1NldFZhbHVlKGJvb2xlYW4gdikgdGhyb3dzIEludGVycnVwdGVkRXhjZXB0aW9uIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQl0aGlzLndhaXRVbnRpbFZhbHVlSXMoICEgdik7Ci0JCQl0aGlzLnNldFZhbHVlKHYpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU3VzcGVuZCB0aGUgY3VycmVudCB0aHJlYWQgdW50aWwgdGhlIGJvb2xlYW4gdmFsdWUgY2hhbmdlcyB0byBmYWxzZSwKLQkgKiB0aGVuIGNoYW5nZSBpdCBiYWNrIHRvIHRydWUgYW5kIGNvbnRpbnVlIGV4ZWN1dGluZy4gSWYgdGhlIGJvb2xlYW4KLQkgKiB2YWx1ZSBpcyBhbHJlYWR5IGZhbHNlLCBzZXQgdGhlIHZhbHVlIHRvIHRydWUgaW1tZWRpYXRlbHkuCi0JICovCi0JcHVibGljIHZvaWQgd2FpdFRvU2V0VHJ1ZSgpIHRocm93cyBJbnRlcnJ1cHRlZEV4Y2VwdGlvbiB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJdGhpcy53YWl0VG9TZXRWYWx1ZSh0cnVlKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSBib29sZWFuIHZhbHVlIGNoYW5nZXMgdG8gdHJ1ZSwKLQkgKiB0aGVuIGNoYW5nZSBpdCBiYWNrIHRvIGZhbHNlIGFuZCBjb250aW51ZSBleGVjdXRpbmcuIElmIHRoZSBib29sZWFuCi0JICogdmFsdWUgaXMgYWxyZWFkeSB0cnVlLCBzZXQgdGhlIHZhbHVlIHRvIGZhbHNlIGltbWVkaWF0ZWx5LgotCSAqLwotCXB1YmxpYyB2b2lkIHdhaXRUb1NldEZhbHNlKCkgdGhyb3dzIEludGVycnVwdGVkRXhjZXB0aW9uIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQl0aGlzLndhaXRUb1NldFZhbHVlKGZhbHNlKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiB0aW1lZCB3YWl0cyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBTdXNwZW5kIHRoZSBjdXJyZW50IHRocmVhZCB1bnRpbCB0aGUgYm9vbGVhbiB2YWx1ZSBjaGFuZ2VzCi0JICogdG8gdGhlIHNwZWNpZmllZCB2YWx1ZSBvciB0aGUgc3BlY2lmaWVkIHRpbWUtb3V0IG9jY3Vycy4KLQkgKiBUaGUgdGltZS1vdXQgaXMgc3BlY2lmaWVkIGluIG1pbGxpc2Vjb25kcy4gUmV0dXJuIHRydWUgaWYgdGhlIHNwZWNpZmllZAotCSAqIHZhbHVlIHdhcyBhY2hpZXZlZDsgcmV0dXJuIGZhbHNlIGlmIGEgdGltZS1vdXQgb2NjdXJyZWQuCi0JICogSWYgdGhlIGJvb2xlYW4gdmFsdWUgaXMgYWxyZWFkeSB0aGUgc3BlY2lmaWVkIHZhbHVlLCByZXR1cm4gdHJ1ZQotCSAqIGltbWVkaWF0ZWx5LgotCSAqLwotCXB1YmxpYyBib29sZWFuIHdhaXRVbnRpbFZhbHVlSXMoYm9vbGVhbiB2LCBsb25nIHRpbWVvdXQpIHRocm93cyBJbnRlcnJ1cHRlZEV4Y2VwdGlvbiB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJaWYgKHRpbWVvdXQgPT0gMEwpIHsKLQkJCQl0aGlzLndhaXRVbnRpbFZhbHVlSXModik7CS8vIHdhaXQgaW5kZWZpbml0ZWx5IHVudGlsIG5vdGlmaWVkCi0JCQkJcmV0dXJuIHRydWU7CS8vIGlmIGl0IGV2ZXIgY29tZXMgYmFjaywgdGhlIGNvbmRpdGlvbiB3YXMgbWV0Ci0JCQl9Ci0JCi0JCQlsb25nIHN0b3AgPSBTeXN0ZW0uY3VycmVudFRpbWVNaWxsaXMoKSArIHRpbWVvdXQ7Ci0JCQlsb25nIHJlbWFpbmluZyA9IHRpbWVvdXQ7Ci0JCQl3aGlsZSAoKHRoaXMudmFsdWUgIT0gdikgJiYgKHJlbWFpbmluZyA+IDBMKSkgewotCQkJCXRoaXMubXV0ZXgud2FpdChyZW1haW5pbmcpOwotCQkJCXJlbWFpbmluZyA9IHN0b3AgLSBTeXN0ZW0uY3VycmVudFRpbWVNaWxsaXMoKTsKLQkJCX0KLQkJCXJldHVybiAodGhpcy52YWx1ZSA9PSB2KTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSBib29sZWFuIHZhbHVlIGNoYW5nZXMKLQkgKiB0byB0cnVlIG9yIHRoZSBzcGVjaWZpZWQgdGltZS1vdXQgb2NjdXJzLgotCSAqIFRoZSB0aW1lLW91dCBpcyBzcGVjaWZpZWQgaW4gbWlsbGlzZWNvbmRzLiBSZXR1cm4gdHJ1ZSBpZiB0aGUgc3BlY2lmaWVkCi0JICogdmFsdWUgd2FzIGFjaGlldmVkOyByZXR1cm4gZmFsc2UgaWYgYSB0aW1lLW91dCBvY2N1cnJlZC4KLQkgKiBJZiB0aGUgYm9vbGVhbiB2YWx1ZSBpcyBhbHJlYWR5IHRydWUsIHJldHVybiB0cnVlIGltbWVkaWF0ZWx5LgotCSAqLwotCXB1YmxpYyBib29sZWFuIHdhaXRVbnRpbFRydWUobG9uZyB0aW1lb3V0KSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXJldHVybiB0aGlzLndhaXRVbnRpbFZhbHVlSXModHJ1ZSwgdGltZW91dCk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBTdXNwZW5kIHRoZSBjdXJyZW50IHRocmVhZCB1bnRpbCB0aGUgYm9vbGVhbiB2YWx1ZSBjaGFuZ2VzCi0JICogdG8gZmFsc2Ugb3IgdGhlIHNwZWNpZmllZCB0aW1lLW91dCBvY2N1cnMuCi0JICogVGhlIHRpbWUtb3V0IGlzIHNwZWNpZmllZCBpbiBtaWxsaXNlY29uZHMuIFJldHVybiB0cnVlIGlmIHRoZSBzcGVjaWZpZWQKLQkgKiB2YWx1ZSB3YXMgYWNoaWV2ZWQ7IHJldHVybiBmYWxzZSBpZiBhIHRpbWUtb3V0IG9jY3VycmVkLgotCSAqIElmIHRoZSBib29sZWFuIHZhbHVlIGlzIGFscmVhZHkgdHJ1ZSwgcmV0dXJuIHRydWUgaW1tZWRpYXRlbHkuCi0JICovCi0JcHVibGljIGJvb2xlYW4gd2FpdFVudGlsRmFsc2UobG9uZyB0aW1lb3V0KSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXJldHVybiB0aGlzLndhaXRVbnRpbFZhbHVlSXMoZmFsc2UsIHRpbWVvdXQpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU3VzcGVuZCB0aGUgY3VycmVudCB0aHJlYWQgdW50aWwgdGhlIGJvb2xlYW4gdmFsdWUgY2hhbmdlcyB0byBOT1QgdGhlCi0JICogc3BlY2lmaWVkIHZhbHVlLCB0aGVuIGNoYW5nZSBpdCBiYWNrIHRvIHRoZSBzcGVjaWZpZWQgdmFsdWUgYW5kIGNvbnRpbnVlCi0JICogZXhlY3V0aW5nLiBJZiB0aGUgYm9vbGVhbiB2YWx1ZSBkb2VzIG5vdCBjaGFuZ2UgdG8gZmFsc2UgYmVmb3JlIHRoZQotCSAqIHRpbWUtb3V0LCBzaW1wbHkgY29udGludWUgZXhlY3V0aW5nIHdpdGhvdXQgY2hhbmdpbmcgdGhlIHZhbHVlLgotCSAqIFRoZSB0aW1lLW91dCBpcyBzcGVjaWZpZWQgaW4gbWlsbGlzZWNvbmRzLiBSZXR1cm4gdHJ1ZSBpZiB0aGUgdmFsdWUgd2FzCi0JICogc2V0IHRvIHRoZSBzcGVjaWZpZWQgdmFsdWU7IHJldHVybiBmYWxzZSBpZiBhIHRpbWUtb3V0IG9jY3VycmVkLgotCSAqIElmIHRoZSBib29sZWFuIHZhbHVlIGlzIGFscmVhZHkgTk9UIHRoZSBzcGVjaWZpZWQgdmFsdWUsIHNldCB0aGUgdmFsdWUKLQkgKiB0byB0aGUgc3BlY2lmaWVkIHZhbHVlIGltbWVkaWF0ZWx5IGFuZCByZXR1cm4gdHJ1ZS4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiB3YWl0VG9TZXRWYWx1ZShib29sZWFuIHYsIGxvbmcgdGltZW91dCkgdGhyb3dzIEludGVycnVwdGVkRXhjZXB0aW9uIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQlib29sZWFuIHN1Y2Nlc3MgPSB0aGlzLndhaXRVbnRpbFZhbHVlSXMoICEgdiwgdGltZW91dCk7Ci0JCQlpZiAoc3VjY2VzcykgewotCQkJCXRoaXMuc2V0VmFsdWUodik7Ci0JCQl9Ci0JCQlyZXR1cm4gc3VjY2VzczsKLQkJfQotCX0KLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSBib29sZWFuIHZhbHVlIGNoYW5nZXMgdG8gZmFsc2UsCi0JICogdGhlbiBjaGFuZ2UgaXQgYmFjayB0byB0cnVlIGFuZCBjb250aW51ZSBleGVjdXRpbmcuIElmIHRoZSBib29sZWFuCi0JICogdmFsdWUgZG9lcyBub3QgY2hhbmdlIHRvIGZhbHNlIGJlZm9yZSB0aGUgdGltZS1vdXQsIHNpbXBseSBjb250aW51ZQotCSAqIGV4ZWN1dGluZyB3aXRob3V0IGNoYW5naW5nIHRoZSB2YWx1ZS4gVGhlIHRpbWUtb3V0IGlzIHNwZWNpZmllZCBpbgotCSAqIG1pbGxpc2Vjb25kcy4gUmV0dXJuIHRydWUgaWYgdGhlIHZhbHVlIHdhcyBzZXQgdG8gdHJ1ZTsgcmV0dXJuIGZhbHNlCi0JICogaWYgYSB0aW1lLW91dCBvY2N1cnJlZC4gSWYgdGhlIGJvb2xlYW4gdmFsdWUgaXMgYWxyZWFkeSBmYWxzZSwgc2V0IHRoZQotCSAqIHZhbHVlIHRvIHRydWUgaW1tZWRpYXRlbHkgYW5kIHJldHVybiB0cnVlLgotCSAqLwotCXB1YmxpYyBib29sZWFuIHdhaXRUb1NldFRydWUobG9uZyB0aW1lb3V0KSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXJldHVybiB0aGlzLndhaXRUb1NldFZhbHVlKHRydWUsIHRpbWVvdXQpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU3VzcGVuZCB0aGUgY3VycmVudCB0aHJlYWQgdW50aWwgdGhlIGJvb2xlYW4gdmFsdWUgY2hhbmdlcyB0byB0cnVlLAotCSAqIHRoZW4gY2hhbmdlIGl0IGJhY2sgdG8gZmFsc2UgYW5kIGNvbnRpbnVlIGV4ZWN1dGluZy4gSWYgdGhlIGJvb2xlYW4KLQkgKiB2YWx1ZSBkb2VzIG5vdCBjaGFuZ2UgdG8gdHJ1ZSBiZWZvcmUgdGhlIHRpbWUtb3V0LCBzaW1wbHkgY29udGludWUKLQkgKiBleGVjdXRpbmcgd2l0aG91dCBjaGFuZ2luZyB0aGUgdmFsdWUuIFRoZSB0aW1lLW91dCBpcyBzcGVjaWZpZWQgaW4KLQkgKiBtaWxsaXNlY29uZHMuIFJldHVybiB0cnVlIGlmIHRoZSB2YWx1ZSB3YXMgc2V0IHRvIGZhbHNlOyByZXR1cm4gZmFsc2UKLQkgKiBpZiBhIHRpbWUtb3V0IG9jY3VycmVkLiBJZiB0aGUgYm9vbGVhbiB2YWx1ZSBpcyBhbHJlYWR5IHRydWUsIHNldCB0aGUKLQkgKiB2YWx1ZSB0byBmYWxzZSBpbW1lZGlhdGVseSBhbmQgcmV0dXJuIHRydWUuCi0JICovCi0JcHVibGljIGJvb2xlYW4gd2FpdFRvU2V0RmFsc2UobG9uZyB0aW1lb3V0KSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXJldHVybiB0aGlzLndhaXRUb1NldFZhbHVlKGZhbHNlLCB0aW1lb3V0KTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBzeW5jaHJvbml6ZWQgYmVoYXZpb3IgKioqKioqKioqKgotCi0JLyoqCi0JICogSWYgdGhlIGN1cnJlbnQgdGhyZWFkIGlzIG5vdCBpbnRlcnJ1cHRlZCwgZXhlY3V0ZSB0aGUgc3BlY2lmaWVkIGNvbW1hbmQgCi0JICogd2l0aCB0aGUgbXV0ZXggbG9ja2VkLiBUaGlzIGlzIHVzZWZ1bCBmb3IgaW5pdGlhbGl6aW5nIHRoZSB2YWx1ZSBpbiBhbm90aGVyCi0JICogdGhyZWFkLgotCSAqLwotCXB1YmxpYyB2b2lkIGV4ZWN1dGUoQ29tbWFuZCBjb21tYW5kKSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewotCQlpZiAoVGhyZWFkLmludGVycnVwdGVkKCkpIHsKLQkJCXRocm93IG5ldyBJbnRlcnJ1cHRlZEV4Y2VwdGlvbigpOwotCQl9Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJY29tbWFuZC5leGVjdXRlKCk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogc3RhbmRhcmQgbWV0aG9kcyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgT2JqZWN0IGNsb25lKCkgewotCQl0cnkgewotCQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQkJcmV0dXJuIHN1cGVyLmNsb25lKCk7Ci0JCQl9Ci0JCX0gY2F0Y2ggKENsb25lTm90U3VwcG9ydGVkRXhjZXB0aW9uIGV4KSB7Ci0JCQl0aHJvdyBuZXcgSW50ZXJuYWxFcnJvcigpOwotCQl9Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIGJvb2xlYW4gZXF1YWxzKE9iamVjdCBvKSB7Ci0JCWlmIChvIGluc3RhbmNlb2YgU3luY2hyb25pemVkQm9vbGVhbikgewotCQkJcmV0dXJuIHRoaXMudmFsdWUoKSA9PSAoKFN5bmNocm9uaXplZEJvb2xlYW4pIG8pLnZhbHVlKCk7Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBpbnQgaGFzaENvZGUoKSB7Ci0JCXJldHVybiB0aGlzLnZhbHVlKCkgPyAxIDogMDsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gU3RyaW5nLnZhbHVlT2YodGhpcy52YWx1ZSgpKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9TeW5jaHJvbml6ZWRPYmplY3QuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9TeW5jaHJvbml6ZWRPYmplY3QuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmNmODNkYi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU3luY2hyb25pemVkT2JqZWN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNzIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uU2VyaWFsaXphYmxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LkNvbW1hbmQ7Ci0KLS8qKgotICogVGhpcyBjbGFzcyBwcm92aWRlcyBzeW5jaHJvbml6ZWQgYWNjZXNzIHRvIGFuIG9iamVjdCBvZiB0eXBlIFQuCi0gKiBJdCBhbHNvIHByb3ZpZGVzIHByb3RvY29sIGZvciBzdXNwZW5kaW5nIGEgdGhyZWFkIHVudGlsIHRoZQotICogdmFsdWUgaXMgc2V0IHRvIG51bGwgb3IgYSBub24tbnVsbCB2YWx1ZSwgd2l0aCBvcHRpb25hbCB0aW1lLW91dHMuCi0gKi8KLXB1YmxpYyBjbGFzcyBTeW5jaHJvbml6ZWRPYmplY3Q8VD4KLQlpbXBsZW1lbnRzIENsb25lYWJsZSwgU2VyaWFsaXphYmxlCi17Ci0JLyoqIEJhY2tpbmcgdmFsdWUuICovCi0JcHJpdmF0ZSBUIHZhbHVlOwotCi0JLyoqIE9iamVjdCB0byBzeW5jaHJvbml6ZSBvbi4gKi8KLQlwcml2YXRlIGZpbmFsIE9iamVjdCBtdXRleDsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDFMOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDcmVhdGUgYSBzeW5jaHJvbml6ZWQgb2JqZWN0IHdpdGggdGhlIHNwZWNpZmllZCBpbml0aWFsIHZhbHVlCi0JICogYW5kIG11dGV4LgotCSAqLwotCXB1YmxpYyBTeW5jaHJvbml6ZWRPYmplY3QoVCB2YWx1ZSwgT2JqZWN0IG11dGV4KSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMudmFsdWUgPSB2YWx1ZTsKLQkJdGhpcy5tdXRleCA9IG11dGV4OwotCX0KLQotCS8qKgotCSAqIENyZWF0ZSBhIHN5bmNocm9uaXplZCBvYmplY3Qgd2l0aCB0aGUgc3BlY2lmaWVkIGluaXRpYWwgdmFsdWUuCi0JICovCi0JcHVibGljIFN5bmNocm9uaXplZE9iamVjdChUIHZhbHVlKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMudmFsdWUgPSB2YWx1ZTsKLQkJdGhpcy5tdXRleCA9IHRoaXM7Ci0JfQotCi0JLyoqCi0JICogQ3JlYXRlIGEgc3luY2hyb25pemVkIG9iamVjdCB3aXRoIGFuIGluaXRpYWwgdmFsdWUgb2YgbnVsbC4KLQkgKi8KLQlwdWJsaWMgU3luY2hyb25pemVkT2JqZWN0KCkgewotCQl0aGlzKG51bGwpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBhY2Nlc3NvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjdXJyZW50IHZhbHVlLgotCSAqLwotCXB1YmxpYyBUIHZhbHVlKCkgewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXJldHVybiB0aGlzLnZhbHVlOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGN1cnJlbnQgdmFsdWUgaXMgbnVsbC4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBpc051bGwoKSB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJcmV0dXJuIHRoaXMudmFsdWUgPT0gbnVsbDsKLQkJfQotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjdXJyZW50IHZhbHVlIGlzIG5vdCBudWxsLgotCSAqLwotCXB1YmxpYyBib29sZWFuIGlzTm90TnVsbCgpIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQlyZXR1cm4gdGhpcy52YWx1ZSAhPSBudWxsOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSB2YWx1ZS4gSWYgdGhlIHZhbHVlIGNoYW5nZXMsIGFsbCB3YWl0aW5nCi0JICogdGhyZWFkcyBhcmUgbm90aWZpZWQuCi0JICovCi0JcHVibGljIHZvaWQgc2V0VmFsdWUoVCB2YWx1ZSkgewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCWlmICh0aGlzLnZhbHVlICE9IHZhbHVlKSB7Ci0JCQkJdGhpcy52YWx1ZSA9IHZhbHVlOwotCQkJCXRoaXMubXV0ZXgubm90aWZ5QWxsKCk7Ci0JCQl9Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBTZXQgdGhlIHZhbHVlIHRvIG51bGwuIElmIHRoZSB2YWx1ZSBjaGFuZ2VzLCBhbGwgd2FpdGluZwotCSAqIHRocmVhZHMgYXJlIG5vdGlmaWVkLgotCSAqLwotCXB1YmxpYyB2b2lkIHNldE51bGwoKSB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJdGhpcy5zZXRWYWx1ZShudWxsKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgb2JqZWN0IHRoaXMgb2JqZWN0IGxvY2tzIG9uIHdoaWxlIHBlcmZvcm1pbmcKLQkgKiBpdHMgb3BlcmF0aW9ucy4KLQkgKi8KLQlwdWJsaWMgT2JqZWN0IG11dGV4KCkgewotCQlyZXR1cm4gdGhpcy5tdXRleDsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5kZWZpbml0ZSB3YWl0cyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBTdXNwZW5kIHRoZSBjdXJyZW50IHRocmVhZCB1bnRpbCB0aGUgdmFsdWUgY2hhbmdlcwotCSAqIHRvIHRoZSBzcGVjaWZpZWQgdmFsdWUuIElmIHRoZSB2YWx1ZSBpcyBhbHJlYWR5IHRoZQotCSAqIHNwZWNpZmllZCB2YWx1ZSwgcmV0dXJuIGltbWVkaWF0ZWx5LgotCSAqLwotCXB1YmxpYyB2b2lkIHdhaXRVbnRpbFZhbHVlSXMoVCB2KSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXdoaWxlICh0aGlzLnZhbHVlICE9IHYpIHsKLQkJCQl0aGlzLm11dGV4LndhaXQoKTsKLQkJCX0KLQkJfQotCX0KLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSB2YWx1ZSBjaGFuZ2VzCi0JICogdG8gc29tZXRoaW5nIG90aGVyIHRoYW4gdGhlIHNwZWNpZmllZCB2YWx1ZS4gSWYgdGhlCi0JICogdmFsdWUgaXMgYWxyZWFkeSBOT1QgdGhlIHNwZWNpZmllZCB2YWx1ZSwgcmV0dXJuIGltbWVkaWF0ZWx5LgotCSAqLwotCXB1YmxpYyB2b2lkIHdhaXRVbnRpbFZhbHVlSXNOb3QoVCB2KSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXdoaWxlICh0aGlzLnZhbHVlID09IHYpIHsKLQkJCQl0aGlzLm11dGV4LndhaXQoKTsKLQkJCX0KLQkJfQotCX0KLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSB2YWx1ZSBjaGFuZ2VzIHRvIG51bGwuCi0JICogSWYgdGhlIHZhbHVlIGlzIGFscmVhZHkgbnVsbCwgcmV0dXJuIGltbWVkaWF0ZWx5LgotCSAqLwotCXB1YmxpYyB2b2lkIHdhaXRVbnRpbE51bGwoKSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXRoaXMud2FpdFVudGlsVmFsdWVJcyhudWxsKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSB2YWx1ZSBjaGFuZ2VzCi0JICogdG8gc29tZXRoaW5nIG90aGVyIHRoYW4gbnVsbC4KLQkgKiBJZiB0aGUgdmFsdWUgaXMgYWxyZWFkeSBOT1QgbnVsbCwgcmV0dXJuIGltbWVkaWF0ZWx5LgotCSAqLwotCXB1YmxpYyB2b2lkIHdhaXRVbnRpbE5vdE51bGwoKSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXRoaXMud2FpdFVudGlsVmFsdWVJc05vdChudWxsKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSB2YWx1ZSBjaGFuZ2VzIHRvCi0JICogc29tZXRoaW5nIG90aGVyIHRoYW4gdGhlIHNwZWNpZmllZCB2YWx1ZSwgdGhlbiBjaGFuZ2UKLQkgKiBpdCBiYWNrIHRvIHRoZSBzcGVjaWZpZWQgdmFsdWUgYW5kIGNvbnRpbnVlIGV4ZWN1dGluZy4KLQkgKiBJZiB0aGUgdmFsdWUgaXMgYWxyZWFkeSBOT1QgdGhlIHNwZWNpZmllZCB2YWx1ZSwgc2V0Ci0JICogdGhlIHZhbHVlIGltbWVkaWF0ZWx5LgotCSAqLwotCXB1YmxpYyB2b2lkIHdhaXRUb1NldFZhbHVlKFQgdikgdGhyb3dzIEludGVycnVwdGVkRXhjZXB0aW9uIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQl0aGlzLndhaXRVbnRpbFZhbHVlSXNOb3Qodik7Ci0JCQl0aGlzLnNldFZhbHVlKHYpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU3VzcGVuZCB0aGUgY3VycmVudCB0aHJlYWQgdW50aWwgdGhlIHZhbHVlIGNoYW5nZXMgdG8KLQkgKiBzb21ldGhpbmcgb3RoZXIgdGhhbiBudWxsLCB0aGVuIGNoYW5nZSBpdCBiYWNrIHRvIG51bGwKLQkgKiBhbmQgY29udGludWUgZXhlY3V0aW5nLiBJZiB0aGUgdmFsdWUgaXMgYWxyZWFkeSBOT1QgbnVsbCwKLQkgKiBzZXQgdGhlIHZhbHVlIHRvIG51bGwgaW1tZWRpYXRlbHkuCi0JICovCi0JcHVibGljIHZvaWQgd2FpdFRvU2V0TnVsbCgpIHRocm93cyBJbnRlcnJ1cHRlZEV4Y2VwdGlvbiB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJdGhpcy53YWl0VW50aWxOb3ROdWxsKCk7Ci0JCQl0aGlzLnNldFZhbHVlKG51bGwpOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHRpbWVkIHdhaXRzICoqKioqKioqKioKLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSB2YWx1ZSBjaGFuZ2VzCi0JICogdG8gdGhlIHNwZWNpZmllZCB2YWx1ZSBvciB0aGUgc3BlY2lmaWVkIHRpbWUtb3V0IG9jY3Vycy4KLQkgKiBUaGUgdGltZS1vdXQgaXMgc3BlY2lmaWVkIGluIG1pbGxpc2Vjb25kcy4gUmV0dXJuIHRydWUgaWYgdGhlIHNwZWNpZmllZAotCSAqIHZhbHVlIHdhcyBhY2hpZXZlZDsgcmV0dXJuIGZhbHNlIGlmIGEgdGltZS1vdXQgb2NjdXJyZWQuCi0JICogSWYgdGhlIHZhbHVlIGlzIGFscmVhZHkgdGhlIHNwZWNpZmllZCB2YWx1ZSwgcmV0dXJuIHRydWUgaW1tZWRpYXRlbHkuCi0JICovCi0JcHVibGljIGJvb2xlYW4gd2FpdFVudGlsVmFsdWVJcyhUIHYsIGxvbmcgdGltZW91dCkgdGhyb3dzIEludGVycnVwdGVkRXhjZXB0aW9uIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQlpZiAodGltZW91dCA9PSAwTCkgewotCQkJCXRoaXMud2FpdFVudGlsVmFsdWVJcyh2KTsJLy8gd2FpdCBpbmRlZmluaXRlbHkgdW50aWwgbm90aWZpZWQKLQkJCQlyZXR1cm4gdHJ1ZTsJLy8gaWYgaXQgZXZlciBjb21lcyBiYWNrLCB0aGUgY29uZGl0aW9uIHdhcyBtZXQKLQkJCX0KLQotCQkJbG9uZyBzdG9wID0gU3lzdGVtLmN1cnJlbnRUaW1lTWlsbGlzKCkgKyB0aW1lb3V0OwotCQkJbG9uZyByZW1haW5pbmcgPSB0aW1lb3V0OwotCQkJd2hpbGUgKCh0aGlzLnZhbHVlICE9IHYpICYmIChyZW1haW5pbmcgPiAwTCkpIHsKLQkJCQl0aGlzLm11dGV4LndhaXQocmVtYWluaW5nKTsKLQkJCQlyZW1haW5pbmcgPSBzdG9wIC0gU3lzdGVtLmN1cnJlbnRUaW1lTWlsbGlzKCk7Ci0JCQl9Ci0JCQlyZXR1cm4gKHRoaXMudmFsdWUgPT0gdik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBTdXNwZW5kIHRoZSBjdXJyZW50IHRocmVhZCB1bnRpbCB0aGUgdmFsdWUgY2hhbmdlcyB0byBzb21ldGhpbmcKLQkgKiBvdGhlciB0aGFuIHRoZSBzcGVjaWZpZWQgdmFsdWUgb3IgdGhlIHNwZWNpZmllZCB0aW1lLW91dCBvY2N1cnMuCi0JICogVGhlIHRpbWUtb3V0IGlzIHNwZWNpZmllZCBpbiBtaWxsaXNlY29uZHMuIFJldHVybiB0cnVlIGlmIHRoZSBzcGVjaWZpZWQKLQkgKiB2YWx1ZSB3YXMgcmVtb3ZlZDsgcmV0dXJuIGZhbHNlIGlmIGEgdGltZS1vdXQgb2NjdXJyZWQuCi0JICogSWYgdGhlIHZhbHVlIGlzIGFscmVhZHkgTk9UIHRoZSBzcGVjaWZpZWQgdmFsdWUsIHJldHVybiB0cnVlIGltbWVkaWF0ZWx5LgotCSAqLwotCXB1YmxpYyBib29sZWFuIHdhaXRVbnRpbFZhbHVlSXNOb3QoVCB2LCBsb25nIHRpbWVvdXQpIHRocm93cyBJbnRlcnJ1cHRlZEV4Y2VwdGlvbiB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJaWYgKHRpbWVvdXQgPT0gMEwpIHsKLQkJCQl0aGlzLndhaXRVbnRpbFZhbHVlSXNOb3Qodik7CS8vIHdhaXQgaW5kZWZpbml0ZWx5IHVudGlsIG5vdGlmaWVkCi0JCQkJcmV0dXJuIHRydWU7CS8vIGlmIGl0IGV2ZXIgY29tZXMgYmFjaywgdGhlIGNvbmRpdGlvbiB3YXMgbWV0Ci0JCQl9Ci0KLQkJCWxvbmcgc3RvcCA9IFN5c3RlbS5jdXJyZW50VGltZU1pbGxpcygpICsgdGltZW91dDsKLQkJCWxvbmcgcmVtYWluaW5nID0gdGltZW91dDsKLQkJCXdoaWxlICgodGhpcy52YWx1ZSA9PSB2KSAmJiAocmVtYWluaW5nID4gMEwpKSB7Ci0JCQkJdGhpcy5tdXRleC53YWl0KHJlbWFpbmluZyk7Ci0JCQkJcmVtYWluaW5nID0gc3RvcCAtIFN5c3RlbS5jdXJyZW50VGltZU1pbGxpcygpOwotCQkJfQotCQkJcmV0dXJuICh0aGlzLnZhbHVlICE9IHYpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU3VzcGVuZCB0aGUgY3VycmVudCB0aHJlYWQgdW50aWwgdGhlIHZhbHVlIGNoYW5nZXMKLQkgKiB0byBudWxsIG9yIHRoZSBzcGVjaWZpZWQgdGltZS1vdXQgb2NjdXJzLgotCSAqIFRoZSB0aW1lLW91dCBpcyBzcGVjaWZpZWQgaW4gbWlsbGlzZWNvbmRzLiBSZXR1cm4gdHJ1ZSBpZiB0aGUgc3BlY2lmaWVkCi0JICogdmFsdWUgd2FzIGFjaGlldmVkOyByZXR1cm4gZmFsc2UgaWYgYSB0aW1lLW91dCBvY2N1cnJlZC4KLQkgKiBJZiB0aGUgdmFsdWUgaXMgYWxyZWFkeSBudWxsLCByZXR1cm4gdHJ1ZSBpbW1lZGlhdGVseS4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiB3YWl0VW50aWxOdWxsKGxvbmcgdGltZW91dCkgdGhyb3dzIEludGVycnVwdGVkRXhjZXB0aW9uIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQlyZXR1cm4gdGhpcy53YWl0VW50aWxWYWx1ZUlzKG51bGwsIHRpbWVvdXQpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU3VzcGVuZCB0aGUgY3VycmVudCB0aHJlYWQgdW50aWwgdGhlIHZhbHVlIGNoYW5nZXMKLQkgKiB0byBzb21ldGhpbmcgb3RoZXIgdGhhbiBudWxsIG9yIHRoZSBzcGVjaWZpZWQgdGltZS1vdXQgb2NjdXJzLgotCSAqIFRoZSB0aW1lLW91dCBpcyBzcGVjaWZpZWQgaW4gbWlsbGlzZWNvbmRzLiBSZXR1cm4gdHJ1ZSBpZiB0aGUgc3BlY2lmaWVkCi0JICogdmFsdWUgd2FzIGFjaGlldmVkOyByZXR1cm4gZmFsc2UgaWYgYSB0aW1lLW91dCBvY2N1cnJlZC4KLQkgKiBJZiB0aGUgdmFsdWUgaXMgYWxyZWFkeSBOT1QgbnVsbCwgcmV0dXJuIHRydWUgaW1tZWRpYXRlbHkuCi0JICovCi0JcHVibGljIGJvb2xlYW4gd2FpdFVudGlsTm90TnVsbChsb25nIHRpbWVvdXQpIHRocm93cyBJbnRlcnJ1cHRlZEV4Y2VwdGlvbiB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJcmV0dXJuIHRoaXMud2FpdFVudGlsVmFsdWVJc05vdChudWxsLCB0aW1lb3V0KTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSB2YWx1ZSBjaGFuZ2VzIHRvCi0JICogc29tZXRoaW5nIG90aGVyIHRoYW4gdGhlIHNwZWNpZmllZCB2YWx1ZSwgdGhlbiBjaGFuZ2UKLQkgKiBpdCBiYWNrIHRvIHRoZSBzcGVjaWZpZWQgdmFsdWUgYW5kIGNvbnRpbnVlIGV4ZWN1dGluZy4KLQkgKiBJZiB0aGUgdmFsdWUgZG9lcyBub3QgY2hhbmdlIHRvIHNvbWV0aGluZyBvdGhlciB0aGFuIHRoZQotCSAqIHNwZWNpZmllZCBiZWZvcmUgdGhlIHRpbWUtb3V0LCBzaW1wbHkgY29udGludWUgZXhlY3V0aW5nCi0JICogd2l0aG91dCBjaGFuZ2luZyB0aGUgdmFsdWUuCi0JICogVGhlIHRpbWUtb3V0IGlzIHNwZWNpZmllZCBpbiBtaWxsaXNlY29uZHMuIFJldHVybiB0cnVlIGlmIHRoZSB2YWx1ZSB3YXMKLQkgKiBzZXQgdG8gdHJ1ZTsgcmV0dXJuIGZhbHNlIGlmIGEgdGltZS1vdXQgb2NjdXJyZWQuCi0JICogSWYgdGhlIHZhbHVlIGlzIGFscmVhZHkgc29tZXRoaW5nIG90aGVyIHRoYW4gdGhlIHNwZWNpZmllZCB2YWx1ZSwgc2V0Ci0JICogdGhlIHZhbHVlIGltbWVkaWF0ZWx5IGFuZCByZXR1cm4gdHJ1ZS4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiB3YWl0VG9TZXRWYWx1ZShUIHYsIGxvbmcgdGltZW91dCkgdGhyb3dzIEludGVycnVwdGVkRXhjZXB0aW9uIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQlib29sZWFuIHN1Y2Nlc3MgPSB0aGlzLndhaXRVbnRpbFZhbHVlSXNOb3QodiwgdGltZW91dCk7Ci0JCQlpZiAoc3VjY2VzcykgewotCQkJCXRoaXMuc2V0VmFsdWUodik7Ci0JCQl9Ci0JCQlyZXR1cm4gc3VjY2VzczsKLQkJfQotCX0KLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSB2YWx1ZSBjaGFuZ2VzIHRvIHNvbWV0aGluZwotCSAqIG90aGVyIHRoYW4gbnVsbCwgdGhlbiBjaGFuZ2UgaXQgYmFjayB0byBudWxsIGFuZCBjb250aW51ZSBleGVjdXRpbmcuCi0JICogSWYgdGhlIHZhbHVlIGRvZXMgbm90IGNoYW5nZSB0byBzb21ldGhpbmcgb3RoZXIgdGhhbiBudWxsIGJlZm9yZQotCSAqIHRoZSB0aW1lLW91dCwgc2ltcGx5IGNvbnRpbnVlIGV4ZWN1dGluZyB3aXRob3V0IGNoYW5naW5nIHRoZSB2YWx1ZS4KLQkgKiBUaGUgdGltZS1vdXQgaXMgc3BlY2lmaWVkIGluIG1pbGxpc2Vjb25kcy4gUmV0dXJuIHRydWUgaWYgdGhlIHZhbHVlIHdhcwotCSAqIHNldCB0byBmYWxzZTsgcmV0dXJuIGZhbHNlIGlmIGEgdGltZS1vdXQgb2NjdXJyZWQuCi0JICogSWYgdGhlIHZhbHVlIGlzIGFscmVhZHkgc29tZXRoaW5nIG90aGVyIHRoYW4gbnVsbCwgc2V0Ci0JICogdGhlIHZhbHVlIHRvIG51bGwgaW1tZWRpYXRlbHkgYW5kIHJldHVybiB0cnVlLgotCSAqLwotCXB1YmxpYyBib29sZWFuIHdhaXRUb1NldE51bGwobG9uZyB0aW1lb3V0KSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCWJvb2xlYW4gc3VjY2VzcyA9IHRoaXMud2FpdFVudGlsTm90TnVsbCh0aW1lb3V0KTsKLQkJCWlmIChzdWNjZXNzKSB7Ci0JCQkJdGhpcy5zZXRWYWx1ZShudWxsKTsKLQkJCX0KLQkJCXJldHVybiBzdWNjZXNzOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHN5bmNocm9uaXplZCBiZWhhdmlvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBJZiBjdXJyZW50IHRocmVhZCBpcyBub3QgaW50ZXJydXB0ZWQsIGV4ZWN1dGUgdGhlIHNwZWNpZmllZCBjb21tYW5kIAotCSAqIHdpdGggdGhlIG11dGV4IGxvY2tlZC4gVGhpcyBpcyB1c2VmdWwgZm9yIGluaXRpYWxpemluZyB0aGUgdmFsdWUgaW4gYW5vdGhlcgotCSAqIHRocmVhZC4KLQkgKi8KLQlwdWJsaWMgdm9pZCBleGVjdXRlKENvbW1hbmQgY29tbWFuZCkgdGhyb3dzIEludGVycnVwdGVkRXhjZXB0aW9uIHsKLQkJaWYgKFRocmVhZC5pbnRlcnJ1cHRlZCgpKSB7Ci0JCQl0aHJvdyBuZXcgSW50ZXJydXB0ZWRFeGNlcHRpb24oKTsKLQkJfQotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCWNvbW1hbmQuZXhlY3V0ZSgpOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHN0YW5kYXJkIG1ldGhvZHMgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN5bmNocm9uaXplZE9iamVjdDxUPiBjbG9uZSgpIHsKLQkJdHJ5IHsKLQkJCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJCVN5bmNocm9uaXplZE9iamVjdDxUPiBjbG9uZSA9IChTeW5jaHJvbml6ZWRPYmplY3Q8VD4pIHN1cGVyLmNsb25lKCk7Ci0JCQkJcmV0dXJuIGNsb25lOwotCQkJfQotCQl9IGNhdGNoIChDbG9uZU5vdFN1cHBvcnRlZEV4Y2VwdGlvbiBleCkgewotCQkJdGhyb3cgbmV3IEludGVybmFsRXJyb3IoKTsKLQkJfQotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBib29sZWFuIGVxdWFscyhPYmplY3Qgb2JqKSB7Ci0JCWlmICggISAob2JqIGluc3RhbmNlb2YgU3luY2hyb25pemVkT2JqZWN0KSkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCU9iamVjdCB2MSA9IHRoaXMudmFsdWUoKTsKLQkJT2JqZWN0IHYyID0gKChTeW5jaHJvbml6ZWRPYmplY3Q8Pz4pIG9iaikudmFsdWUoKTsKLQkJcmV0dXJuICh2MSA9PSBudWxsKSA/Ci0JCQkodjIgPT0gbnVsbCkgOiB2MS5lcXVhbHModjIpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBpbnQgaGFzaENvZGUoKSB7Ci0JCU9iamVjdCB2ID0gdGhpcy52YWx1ZSgpOwotCQlyZXR1cm4gKHYgPT0gbnVsbCkgPyAwIDogdi5oYXNoQ29kZSgpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmcudmFsdWVPZih0aGlzLnZhbHVlKCkpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1N5bmNocm9uaXplZFN0YWNrLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU3luY2hyb25pemVkU3RhY2suamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTIzMmM0MC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvU3luY2hyb25pemVkU3RhY2suamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI3OSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsOwotCi1pbXBvcnQgamF2YS5pby5TZXJpYWxpemFibGU7Ci1pbXBvcnQgamF2YS51dGlsLkVtcHR5U3RhY2tFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuQ29tbWFuZDsKLQotLyoqCi0gKiBUaHJlYWQtc2FmZSBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgU3RhY2sgaW50ZXJmYWNlLgotICogVGhpcyBhbHNvIHByb3ZpZGVzIHByb3RvY29sIGZvciBzdXNwZW5kaW5nIGEgdGhyZWFkIHVudGlsIHRoZQotICogc3RhY2sgaXMgZW1wdHkgb3Igbm90IGVtcHR5LCB3aXRoIG9wdGlvbmFsIHRpbWUtb3V0cy4KLSAqLwotcHVibGljIGNsYXNzIFN5bmNocm9uaXplZFN0YWNrPEU+Ci0JaW1wbGVtZW50cyBTdGFjazxFPiwgU2VyaWFsaXphYmxlCi17Ci0JLyoqIEJhY2tpbmcgc3RhY2suICovCi0JcHJpdmF0ZSBTdGFjazxFPiBzdGFjazsKLQotCS8qKiBPYmplY3QgdG8gc3luY2hyb25pemUgb24uICovCi0JcHJpdmF0ZSBmaW5hbCBPYmplY3QgbXV0ZXg7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgc3luY2hyb25pemVkIHN0YWNrIHRoYXQgd3JhcHMgdGhlCi0JICogc3BlY2lmaWVkIHN0YWNrIGFuZCBsb2NrcyBvbiB0aGUgc3BlY2lmaWVkIG11dGV4LgotCSAqLwotCXB1YmxpYyBTeW5jaHJvbml6ZWRTdGFjayhTdGFjazxFPiBzdGFjaywgT2JqZWN0IG11dGV4KSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuc3RhY2sgPSBzdGFjazsKLQkJdGhpcy5tdXRleCA9IG11dGV4OwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHN5bmNocm9uaXplZCBzdGFjayB0aGF0IHdyYXBzIHRoZQotCSAqIHNwZWNpZmllZCBzdGFjayBhbmQgbG9ja3Mgb24gaXRzZWxmLgotCSAqLwotCXB1YmxpYyBTeW5jaHJvbml6ZWRTdGFjayhTdGFjazxFPiBzdGFjaykgewotCQlzdXBlcigpOwotCQl0aGlzLnN0YWNrID0gc3RhY2s7Ci0JCXRoaXMubXV0ZXggPSB0aGlzOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHN5bmNocm9uaXplZCBzdGFjayB0aGF0IGxvY2tzIG9uIHRoZSBzcGVjaWZpZWQgbXV0ZXguCi0JICovCi0JcHVibGljIFN5bmNocm9uaXplZFN0YWNrKE9iamVjdCBtdXRleCkgewotCQl0aGlzKG5ldyBTaW1wbGVTdGFjazxFPigpLCBtdXRleCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgc3luY2hyb25pemVkIHN0YWNrIHRoYXQgbG9ja3Mgb24gaXRzZWxmLgotCSAqLwotCXB1YmxpYyBTeW5jaHJvbml6ZWRTdGFjaygpIHsKLQkJdGhpcyhuZXcgU2ltcGxlU3RhY2s8RT4oKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIFN0YWNrIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIHB1c2goRSBvKSB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJdGhpcy5zdGFjay5wdXNoKG8pOwotCQkJdGhpcy5tdXRleC5ub3RpZnlBbGwoKTsKLQkJfQotCX0KLQotCXB1YmxpYyBFIHBvcCgpIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQlFIG8gPSB0aGlzLnN0YWNrLnBvcCgpOwotCQkJdGhpcy5tdXRleC5ub3RpZnlBbGwoKTsKLQkJCXJldHVybiBvOwotCQl9Ci0JfQotCi0JcHVibGljIEUgcGVlaygpIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQlyZXR1cm4gdGhpcy5zdGFjay5wZWVrKCk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBpc0VtcHR5KCkgewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXJldHVybiB0aGlzLnN0YWNrLmlzRW1wdHkoKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbmRlZmluaXRlIHdhaXRzICoqKioqKioqKioKLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSBzdGFjaydzIGVtcHR5IHN0YXR1cyBjaGFuZ2VzCi0JICogdG8gdGhlIHNwZWNpZmllZCB2YWx1ZS4KLQkgKi8KLQlwdWJsaWMgdm9pZCB3YWl0VW50aWxFbXB0eUlzKGJvb2xlYW4gZW1wdHkpIHRocm93cyBJbnRlcnJ1cHRlZEV4Y2VwdGlvbiB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJd2hpbGUgKHRoaXMuaXNFbXB0eSgpICE9IGVtcHR5KSB7Ci0JCQkJdGhpcy5tdXRleC53YWl0KCk7Ci0JCQl9Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBTdXNwZW5kIHRoZSBjdXJyZW50IHRocmVhZCB1bnRpbCB0aGUgc3RhY2sgaXMgZW1wdHkuCi0JICovCi0JcHVibGljIHZvaWQgd2FpdFVudGlsRW1wdHkoKSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXRoaXMud2FpdFVudGlsRW1wdHlJcyh0cnVlKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSBzdGFjayBoYXMgc29tZXRoaW5nIG9uIGl0LgotCSAqLwotCXB1YmxpYyB2b2lkIHdhaXRVbnRpbE5vdEVtcHR5KCkgdGhyb3dzIEludGVycnVwdGVkRXhjZXB0aW9uIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQl0aGlzLndhaXRVbnRpbEVtcHR5SXMoZmFsc2UpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU3VzcGVuZCB0aGUgY3VycmVudCB0aHJlYWQgdW50aWwgdGhlIHN0YWNrIGlzIGVtcHR5LAotCSAqIHRoZW4gInB1c2giIHRoZSBzcGVjaWZpZWQgaXRlbSBvbiB0byB0aGUgdG9wIG9mIHRoZSBzdGFjawotCSAqIGFuZCBjb250aW51ZSBleGVjdXRpbmcuCi0JICovCi0JcHVibGljIHZvaWQgd2FpdFRvUHVzaChFIG8pIHRocm93cyBJbnRlcnJ1cHRlZEV4Y2VwdGlvbiB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJdGhpcy53YWl0VW50aWxFbXB0eSgpOwotCQkJdGhpcy5wdXNoKG8pOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU3VzcGVuZCB0aGUgY3VycmVudCB0aHJlYWQgdW50aWwgdGhlIHN0YWNrIGhhcyBzb21ldGhpbmcgb24gaXQsCi0JICogdGhlbiAicG9wIiBhbiBpdGVtIGZyb20gdGhlIHRvcCBvZiB0aGUgc3RhY2sgYW5kIHJldHVybiBpdC4KLQkgKi8KLQlwdWJsaWMgT2JqZWN0IHdhaXRUb1BvcCgpIHRocm93cyBJbnRlcnJ1cHRlZEV4Y2VwdGlvbiB7Ci0JCXN5bmNocm9uaXplZCAodGhpcy5tdXRleCkgewotCQkJdGhpcy53YWl0VW50aWxOb3RFbXB0eSgpOwotCQkJcmV0dXJuIHRoaXMucG9wKCk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogdGltZWQgd2FpdHMgKioqKioqKioqKgotCi0JLyoqCi0JICogU3VzcGVuZCB0aGUgY3VycmVudCB0aHJlYWQgdW50aWwgdGhlIHN0YWNrJ3MgZW1wdHkgc3RhdHVzIGNoYW5nZXMKLQkgKiB0byB0aGUgc3BlY2lmaWVkIHZhbHVlIG9yIHRoZSBzcGVjaWZpZWQgdGltZS1vdXQgb2NjdXJzLgotCSAqIFRoZSB0aW1lLW91dCBpcyBzcGVjaWZpZWQgaW4gbWlsbGlzZWNvbmRzLiBSZXR1cm4gdHJ1ZSBpZiB0aGUgc3BlY2lmaWVkCi0JICogdmFsdWUgd2FzIGFjaGlldmVkOyByZXR1cm4gZmFsc2UgaWYgYSB0aW1lLW91dCBvY2N1cnJlZC4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiB3YWl0VW50aWxFbXB0eUlzKGJvb2xlYW4gZW1wdHksIGxvbmcgdGltZW91dCkgdGhyb3dzIEludGVycnVwdGVkRXhjZXB0aW9uIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQlpZiAodGltZW91dCA9PSAwTCkgewotCQkJCXRoaXMud2FpdFVudGlsRW1wdHlJcyhlbXB0eSk7CS8vIHdhaXQgaW5kZWZpbml0ZWx5IHVudGlsIG5vdGlmaWVkCi0JCQkJcmV0dXJuIHRydWU7CS8vIGlmIGl0IGV2ZXIgY29tZXMgYmFjaywgdGhlIGNvbmRpdGlvbiB3YXMgbWV0Ci0JCQl9Ci0KLQkJCWxvbmcgc3RvcCA9IFN5c3RlbS5jdXJyZW50VGltZU1pbGxpcygpICsgdGltZW91dDsKLQkJCWxvbmcgcmVtYWluaW5nID0gdGltZW91dDsKLQkJCXdoaWxlICgodGhpcy5pc0VtcHR5KCkgIT0gZW1wdHkpICYmIChyZW1haW5pbmcgPiAwTCkpIHsKLQkJCQl0aGlzLm11dGV4LndhaXQocmVtYWluaW5nKTsKLQkJCQlyZW1haW5pbmcgPSBzdG9wIC0gU3lzdGVtLmN1cnJlbnRUaW1lTWlsbGlzKCk7Ci0JCQl9Ci0JCQlyZXR1cm4gKHRoaXMuaXNFbXB0eSgpID09IGVtcHR5KTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSBzdGFjayBpcyBlbXB0eQotCSAqIG9yIHRoZSBzcGVjaWZpZWQgdGltZS1vdXQgb2NjdXJzLgotCSAqIFRoZSB0aW1lLW91dCBpcyBzcGVjaWZpZWQgaW4gbWlsbGlzZWNvbmRzLiBSZXR1cm4gdHJ1ZSBpZgotCSAqIHRoZSBzdGFjayBpcyBlbXB0eTsgcmV0dXJuIGZhbHNlIGlmIGEgdGltZS1vdXQgb2NjdXJyZWQuCi0JICovCi0JcHVibGljIGJvb2xlYW4gd2FpdFVudGlsRW1wdHkobG9uZyB0aW1lb3V0KSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXJldHVybiB0aGlzLndhaXRVbnRpbEVtcHR5SXModHJ1ZSwgdGltZW91dCk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBTdXNwZW5kIHRoZSBjdXJyZW50IHRocmVhZCB1bnRpbCB0aGUgc3RhY2sgaGFzIHNvbWV0aGluZyBvbiBpdC4KLQkgKiBvciB0aGUgc3BlY2lmaWVkIHRpbWUtb3V0IG9jY3Vycy4KLQkgKiBUaGUgdGltZS1vdXQgaXMgc3BlY2lmaWVkIGluIG1pbGxpc2Vjb25kcy4gUmV0dXJuIHRydWUgaWYKLQkgKiB0aGUgc3RhY2sgaGFzIHNvbWV0aGluZyBvbiBpdDsgcmV0dXJuIGZhbHNlIGlmIGEgdGltZS1vdXQgb2NjdXJyZWQuCi0JICovCi0JcHVibGljIGJvb2xlYW4gd2FpdFVudGlsTm90RW1wdHkobG9uZyB0aW1lb3V0KSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXJldHVybiB0aGlzLndhaXRVbnRpbEVtcHR5SXMoZmFsc2UsIHRpbWVvdXQpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU3VzcGVuZCB0aGUgY3VycmVudCB0aHJlYWQgdW50aWwgdGhlIHN0YWNrIGlzIGVtcHR5LAotCSAqIHRoZW4gInB1c2giIHRoZSBzcGVjaWZpZWQgaXRlbSBvbiB0byB0aGUgdG9wIG9mIHRoZSBzdGFjawotCSAqIGFuZCBjb250aW51ZSBleGVjdXRpbmcuIElmIHRoZSBzdGFjayBpcyBub3QgZW1wdGllZCBvdXQKLQkgKiBiZWZvcmUgdGhlIHRpbWUtb3V0LCBzaW1wbHkgY29udGludWUgZXhlY3V0aW5nIHdpdGhvdXQKLQkgKiAicHVzaGluZyIgdGhlIGl0ZW0uCi0JICogVGhlIHRpbWUtb3V0IGlzIHNwZWNpZmllZCBpbiBtaWxsaXNlY29uZHMuIFJldHVybiB0cnVlIGlmIHRoZQotCSAqIGl0ZW0gd2FzIHB1c2hlZDsgcmV0dXJuIGZhbHNlIGlmIGEgdGltZS1vdXQgb2NjdXJyZWQuCi0JICovCi0JcHVibGljIGJvb2xlYW4gd2FpdFRvUHVzaChFIG8sIGxvbmcgdGltZW91dCkgdGhyb3dzIEludGVycnVwdGVkRXhjZXB0aW9uIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQlib29sZWFuIHN1Y2Nlc3MgPSB0aGlzLndhaXRVbnRpbEVtcHR5KHRpbWVvdXQpOwotCQkJaWYgKHN1Y2Nlc3MpIHsKLQkJCQl0aGlzLnB1c2gobyk7Ci0JCQl9Ci0JCQlyZXR1cm4gc3VjY2VzczsKLQkJfQotCX0KLQotCS8qKgotCSAqIFN1c3BlbmQgdGhlIGN1cnJlbnQgdGhyZWFkIHVudGlsIHRoZSBzdGFjayBoYXMgc29tZXRoaW5nIG9uIGl0LAotCSAqIHRoZW4gInBvcCIgYW4gaXRlbSBmcm9tIHRoZSB0b3Agb2YgdGhlIHN0YWNrIGFuZCByZXR1cm4gaXQuCi0JICogSWYgdGhlIHN0YWNrIGlzIGVtcHR5IGFuZCBub3RoaW5nIGlzICJwdXNoZWQiIG9uIHRvIGl0IGJlZm9yZSB0aGUKLQkgKiB0aW1lLW91dCwgdGhyb3cgYW4gZW1wdHkgc3RhY2sgZXhjZXB0aW9uLgotCSAqIFRoZSB0aW1lLW91dCBpcyBzcGVjaWZpZWQgaW4gbWlsbGlzZWNvbmRzLgotCSAqLwotCXB1YmxpYyBPYmplY3Qgd2FpdFRvUG9wKGxvbmcgdGltZW91dCkgdGhyb3dzIEludGVycnVwdGVkRXhjZXB0aW9uIHsKLQkJc3luY2hyb25pemVkICh0aGlzLm11dGV4KSB7Ci0JCQlib29sZWFuIHN1Y2Nlc3MgPSB0aGlzLndhaXRVbnRpbE5vdEVtcHR5KHRpbWVvdXQpOwotCQkJaWYgKHN1Y2Nlc3MpIHsKLQkJCQlyZXR1cm4gdGhpcy5wb3AoKTsKLQkJCX0KLQkJCXRocm93IG5ldyBFbXB0eVN0YWNrRXhjZXB0aW9uKCk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogc3luY2hyb25pemVkIGJlaGF2aW9yICoqKioqKioqKioKLQotCS8qKgotCSAqIElmIHRoZSBjdXJyZW50IHRocmVhZCBpcyBub3QgaW50ZXJydXB0ZWQsIGV4ZWN1dGUgdGhlIHNwZWNpZmllZCBjb21tYW5kIAotCSAqIHdpdGggdGhlIG11dGV4IGxvY2tlZC4gVGhpcyBpcyB1c2VmdWwgZm9yIGluaXRpYWxpemluZyB0aGUgc3RhY2sgaW4gYW5vdGhlcgotCSAqIHRocmVhZC4KLQkgKi8KLQlwdWJsaWMgdm9pZCBleGVjdXRlKENvbW1hbmQgY29tbWFuZCkgdGhyb3dzIEludGVycnVwdGVkRXhjZXB0aW9uIHsKLQkJaWYgKFRocmVhZC5pbnRlcnJ1cHRlZCgpKSB7Ci0JCQl0aHJvdyBuZXcgSW50ZXJydXB0ZWRFeGNlcHRpb24oKTsKLQkJfQotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCWNvbW1hbmQuZXhlY3V0ZSgpOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGFkZGl0aW9uYWwgcHVibGljIHByb3RvY29sICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB0aGUgb2JqZWN0IHRoaXMgb2JqZWN0IGxvY2tzIG9uIHdoaWxlIHBlcmZvcm1pbmcKLQkgKiBpdHMgb3BlcmF0aW9ucy4KLQkgKi8KLQlwdWJsaWMgT2JqZWN0IG11dGV4KCkgewotCQlyZXR1cm4gdGhpcy5tdXRleDsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogT2JqZWN0IG92ZXJyaWRlcyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlzeW5jaHJvbml6ZWQgKHRoaXMubXV0ZXgpIHsKLQkJCXJldHVybiB0aGlzLnN0YWNrLnRvU3RyaW5nKCk7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9UaHJlYWRMb2NhbENvbW1hbmQuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9UaHJlYWRMb2NhbENvbW1hbmQuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzEyMDM4ZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvVGhyZWFkTG9jYWxDb21tYW5kLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw2MyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuQ29tbWFuZDsKLQotLyoqCi0gKiBUaGlzIGltcGxlbWVudGF0aW9uIG9mIHRoZSBDb21tYW5kIGludGVyZmFjZSBhbGxvd3MgdGhlIGNsaWVudCB0bwotICogc3BlY2lmeSBhIGRpZmZlcmVudCBDb21tYW5kIGZvciBlYWNoIHRocmVhZC4KLSAqLwotcHVibGljIGNsYXNzIFRocmVhZExvY2FsQ29tbWFuZCBpbXBsZW1lbnRzIENvbW1hbmQgewotCXByb3RlY3RlZCBmaW5hbCBUaHJlYWRMb2NhbDxDb21tYW5kPiB0aHJlYWRMb2NhbDsKLQlwcm90ZWN0ZWQgZmluYWwgQ29tbWFuZCBkZWZhdWx0Q29tbWFuZDsKLQotCS8qKgotCSAqIFRoZSBkZWZhdWx0IGNvbW1hbmQgZG9lcyBub3RoaW5nLgotCSAqLwotCXB1YmxpYyBUaHJlYWRMb2NhbENvbW1hbmQoKSB7Ci0JCXRoaXMoQ29tbWFuZC5OdWxsLmluc3RhbmNlKCkpOwotCX0KLQotCXB1YmxpYyBUaHJlYWRMb2NhbENvbW1hbmQoQ29tbWFuZCBkZWZhdWx0Q29tbWFuZCkgewotCQlzdXBlcigpOwotCQl0aGlzLmRlZmF1bHRDb21tYW5kID0gZGVmYXVsdENvbW1hbmQ7Ci0JCXRoaXMudGhyZWFkTG9jYWwgPSB0aGlzLmJ1aWxkVGhyZWFkTG9jYWwoKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgVGhyZWFkTG9jYWw8Q29tbWFuZD4gYnVpbGRUaHJlYWRMb2NhbCgpIHsKLQkJcmV0dXJuIG5ldyBUaHJlYWRMb2NhbDxDb21tYW5kPigpOwotCX0KLQotCXB1YmxpYyB2b2lkIGV4ZWN1dGUoKSB7Ci0JCXRoaXMuZ2V0KCkuZXhlY3V0ZSgpOwotCX0KLQotCXByb3RlY3RlZCBDb21tYW5kIGdldCgpIHsKLQkJQ29tbWFuZCBjb21tYW5kID0gdGhpcy50aHJlYWRMb2NhbC5nZXQoKTsKLQkJcmV0dXJuIChjb21tYW5kICE9IG51bGwpID8gY29tbWFuZCA6IHRoaXMuZGVmYXVsdENvbW1hbmQ7Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSBjdXJyZW50IHRocmVhZCdzIGNvbW1hbmQgdG8gdGhlIHNwZWNpZmllZCB2YWx1ZS4KLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXQoQ29tbWFuZCBjb21tYW5kKSB7Ci0JCXRoaXMudGhyZWFkTG9jYWwuc2V0KGNvbW1hbmQpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBjdXJyZW50IHRocmVhZCdzIGNvbW1hbmQuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0KCkudG9TdHJpbmcoKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9UaHJlYWRMb2NhbENvbW1hbmRFeGVjdXRvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1RocmVhZExvY2FsQ29tbWFuZEV4ZWN1dG9yLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDdjYjQ5YjQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1RocmVhZExvY2FsQ29tbWFuZEV4ZWN1dG9yLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw2NSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuQ29tbWFuZDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5Db21tYW5kRXhlY3V0b3I7Ci0KLS8qKgotICogVGhpcyBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgQ29tbWFuZEV4ZWN1dG9yIGludGVyZmFjZSBhbGxvd3MgdGhlIGNsaWVudCB0bwotICogc3BlY2lmeSBhIGRpZmZlcmVudCBDb21tYW5kIEV4ZWN1dG9yIGZvciBlYWNoIHRocmVhZC4KLSAqLwotcHVibGljIGNsYXNzIFRocmVhZExvY2FsQ29tbWFuZEV4ZWN1dG9yIGltcGxlbWVudHMgQ29tbWFuZEV4ZWN1dG9yIHsKLQlwcm90ZWN0ZWQgZmluYWwgVGhyZWFkTG9jYWw8Q29tbWFuZEV4ZWN1dG9yPiB0aHJlYWRMb2NhbDsKLQlwcm90ZWN0ZWQgZmluYWwgQ29tbWFuZEV4ZWN1dG9yIGRlZmF1bHRDb21tYW5kRXhlY3V0b3I7Ci0KLQkvKioKLQkgKiBUaGUgZGVmYXVsdCBjb21tYW5kIGV4ZWN1dG9yIHNpbXBseSBleGVjdXRlcyB0aGUgY29tbWFuZCBkaXJlY3RseS4KLQkgKi8KLQlwdWJsaWMgVGhyZWFkTG9jYWxDb21tYW5kRXhlY3V0b3IoKSB7Ci0JCXRoaXMoQ29tbWFuZEV4ZWN1dG9yLkRlZmF1bHQuaW5zdGFuY2UoKSk7Ci0JfQotCi0JcHVibGljIFRocmVhZExvY2FsQ29tbWFuZEV4ZWN1dG9yKENvbW1hbmRFeGVjdXRvciBkZWZhdWx0Q29tbWFuZEV4ZWN1dG9yKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuZGVmYXVsdENvbW1hbmRFeGVjdXRvciA9IGRlZmF1bHRDb21tYW5kRXhlY3V0b3I7Ci0JCXRoaXMudGhyZWFkTG9jYWwgPSB0aGlzLmJ1aWxkVGhyZWFkTG9jYWwoKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgVGhyZWFkTG9jYWw8Q29tbWFuZEV4ZWN1dG9yPiBidWlsZFRocmVhZExvY2FsKCkgewotCQlyZXR1cm4gbmV3IFRocmVhZExvY2FsPENvbW1hbmRFeGVjdXRvcj4oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBleGVjdXRlKENvbW1hbmQgY29tbWFuZCkgewotCQl0aGlzLmdldCgpLmV4ZWN1dGUoY29tbWFuZCk7Ci0JfQotCi0JcHJvdGVjdGVkIENvbW1hbmRFeGVjdXRvciBnZXQoKSB7Ci0JCUNvbW1hbmRFeGVjdXRvciBjZSA9IHRoaXMudGhyZWFkTG9jYWwuZ2V0KCk7Ci0JCXJldHVybiAoY2UgIT0gbnVsbCkgPyBjZSA6IHRoaXMuZGVmYXVsdENvbW1hbmRFeGVjdXRvcjsKLQl9Ci0KLQkvKioKLQkgKiBTZXQgdGhlIGN1cnJlbnQgdGhyZWFkJ3MgY29tbWFuZCBleGVjdXRvciB0byB0aGUgc3BlY2lmaWVkIHZhbHVlLgotCSAqLwotCXB1YmxpYyB2b2lkIHNldChDb21tYW5kRXhlY3V0b3IgY29tbWFuZEV4ZWN1dG9yKSB7Ci0JCXRoaXMudGhyZWFkTG9jYWwuc2V0KGNvbW1hbmRFeGVjdXRvcik7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgdGhlIGN1cnJlbnQgdGhyZWFkJ3MgY29tbWFuZAotCSAqIGV4ZWN1dG9yLgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiB0aGlzLmdldCgpLnRvU3RyaW5nKCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvVHJhbnNmb3JtZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9UcmFuc2Zvcm1lci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5NDZlNjk3Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9UcmFuc2Zvcm1lci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNjkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbDsKLQotLyoqCi0gKiBVc2VkIGJ5IHZhcmlvdXMgInBsdWdnYWJsZSIgY2xhc3NlcyB0byB0cmFuc2Zvcm0gb2JqZWN0cy4KLSAqIFRyYW5zZm9ybSBhbiBvYmplY3Qgb2YgdHlwZSBUMSB0byBhbiBvYmplY3Qgb2YgdHlwZSBUMi4KLSAqLwotcHVibGljIGludGVyZmFjZSBUcmFuc2Zvcm1lcjxUMSwgVDI+IHsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgdHJhbnNmb3JtZWQgb2JqZWN0LgotCSAqIFRoZSBzZW1hbnRpY3Mgb2YgInRyYW5zZm9ybSIgaXMgZGV0ZXJtaW5lZCBieSB0aGUKLQkgKiBjb250cmFjdCBiZXR3ZWVuIHRoZSBjbGllbnQgYW5kIHRoZSBzZXJ2ZXIuCi0JICovCi0JVDIgdHJhbnNmb3JtKFQxIG8pOwotCi0KLQlmaW5hbCBjbGFzcyBOdWxsPFMxLCBTMj4gaW1wbGVtZW50cyBUcmFuc2Zvcm1lcjxTMSwgUzI+IHsKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCXB1YmxpYyBzdGF0aWMgZmluYWwgVHJhbnNmb3JtZXIgSU5TVEFOQ0UgPSBuZXcgTnVsbCgpOwotCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJcHVibGljIHN0YXRpYyA8UjEsIFIyPiBUcmFuc2Zvcm1lcjxSMSwgUjI+IGluc3RhbmNlKCkgewotCQkJcmV0dXJuIElOU1RBTkNFOwotCQl9Ci0JCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJcHJpdmF0ZSBOdWxsKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQkvLyBzaW1wbHkgcmV0dXJuIHRoZSBvYmplY3QsIHVuY2hhbmdlZAotCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJcHVibGljIFMyIHRyYW5zZm9ybShTMSBvKSB7Ci0JCQlyZXR1cm4gKFMyKSBvOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuICJUcmFuc2Zvcm1lci5OdWxsIjsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JfQotCi0JZmluYWwgY2xhc3MgRGlzYWJsZWQ8UzEsIFMyPiBpbXBsZW1lbnRzIFRyYW5zZm9ybWVyPFMxLCBTMj4gewotCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBUcmFuc2Zvcm1lciBJTlNUQU5DRSA9IG5ldyBEaXNhYmxlZCgpOwotCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJcHVibGljIHN0YXRpYyA8UjEsIFIyPiBUcmFuc2Zvcm1lcjxSMSwgUjI+IGluc3RhbmNlKCkgewotCQkJcmV0dXJuIElOU1RBTkNFOwotCQl9Ci0JCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJcHJpdmF0ZSBEaXNhYmxlZCgpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQkJLy8gdGhyb3cgYW4gZXhjZXB0aW9uCi0JCXB1YmxpYyBTMiB0cmFuc2Zvcm0oUzEgbykgewotCQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gIlRyYW5zZm9ybWVyLkRpc2FibGVkIjsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvWE1MU3RyaW5nRW5jb2Rlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL1hNTFN0cmluZ0VuY29kZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggY2Q5YWIxOC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvWE1MU3RyaW5nRW5jb2Rlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTgyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLmlvLklPRXhjZXB0aW9uOwotaW1wb3J0IGphdmEuaW8uUmVhZGVyOwotaW1wb3J0IGphdmEuaW8uU3RyaW5nUmVhZGVyOwotCi0vKioKLSAqIFRoaXMgZW5jb2RlciB3aWxsIHJlcGxhY2UgYW55IG9mIGEgc3BlY2lmaWVkIHNldCBvZiBjaGFyYWN0ZXJzIHdpdGggYW4gWE1MCi0gKiAiY2hhcmFjdGVyIHJlZmVyZW5jZSI6ICcvJyA9PiAiJiN4MmY7IgotICovCi1wdWJsaWMgZmluYWwgY2xhc3MgWE1MU3RyaW5nRW5jb2RlciB7Ci0KLQkvKiogVGhlIHNldCBvZiBjaGFyYWN0ZXJzIHRvIGJlIGNvbnZlcnRlZCBpbnRvIFhNTCBjaGFyYWN0ZXIgcmVmZXJlbmNlcy4gKi8KLQlwcml2YXRlIGZpbmFsIGNoYXJbXSBjaGFyczsKLQotCS8qKiBDYWNoZSB0aGUgdmFsdWUgb2YgdGhlIGhpZ2hlc3QgY2hhcmFjdGVyIGluIHRoZSBzZXQgYWJvdmUuICovCi0JcHJpdmF0ZSBmaW5hbCBjaGFyIG1heENoYXI7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBlbmNvZGVyIHRoYXQgY29udmVydHMgdGhlIHNwZWNpZmllZCBzZXQgb2YgY2hhcmFjdGVycwotCSAqIGludG8gWE1MIGNoYXJhY3RlciByZWZlcmVuY2VzLgotCSAqLwotCXB1YmxpYyBYTUxTdHJpbmdFbmNvZGVyKGNoYXJbXSBjaGFycykgewotCQlzdXBlcigpOwotCQlpZiAoY2hhcnMgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJLy8gdGhlIGFtcGVyc2FuZCBtdXN0IGJlIGluY2x1ZGVkIHNpbmNlIGl0IGlzIHRoZSBlc2NhcGUgY2hhcmFjdGVyCi0JCWlmIChDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoY2hhcnMsICcmJykpIHsKLQkJCXRoaXMuY2hhcnMgPSBjaGFyczsKLQkJfSBlbHNlIHsKLQkJCXRoaXMuY2hhcnMgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGNoYXJzLCAnJicpOwotCQl9Ci0JCXRoaXMubWF4Q2hhciA9IHRoaXMuY2FsY3VsYXRlTWF4SW52YWxpZEZpbGVOYW1lQ2hhcigpOwotCX0KLQotCS8qKgotCSAqIENhbGN1bGF0ZSB0aGUgbWF4aW11bSB2YWx1ZSBvZiB0aGUgc2V0IG9mIGNoYXJhY3RlcnMgdG8gYmUgY29udmVydGVkCi0JICogaW50byBYTUwgY2hhcmFjdGVyIHJlZmVyZW5jZXMuIFRoaXMgd2lsbCBiZSB1c2VkIHRvIHNob3J0LWNpcmN1aXQgdGhlCi0JICogc2VhcmNoIGZvciBhIGNoYXJhY3RlciBpbiB0aGUgc2V0LgotCSAqIEBzZWUgI2NoYXJJc1RvQmVFbmNvZGVkKGNoYXIpCi0JICovCi0JcHJpdmF0ZSBjaGFyIGNhbGN1bGF0ZU1heEludmFsaWRGaWxlTmFtZUNoYXIoKSB7Ci0JCWNoYXJbXSBsb2NhbENoYXJzID0gdGhpcy5jaGFyczsKLQkJY2hhciBtYXggPSAwOwotCQlmb3IgKGludCBpID0gbG9jYWxDaGFycy5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJY2hhciBjID0gbG9jYWxDaGFyc1tpXTsKLQkJCWlmIChtYXggPCBjKSB7Ci0JCQkJbWF4ID0gYzsKLQkJCX0KLQkJfQotCQlyZXR1cm4gbWF4OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBBUEkgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzcGVjaWZpZWQgc3RyaW5nIHdpdGggYW55IGNoYXJhY3RlcnMgaW4gdGhlIHNldAotCSAqIHJlcGxhY2VkIHdpdGggWE1MIGNoYXJhY3RlciByZWZlcmVuY2VzLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZW5jb2RlKFN0cmluZyBzKSB7Ci0JCWludCBsZW4gPSBzLmxlbmd0aCgpOwotCQkvLyBhbGxvdyBmb3IgYSBmZXcgZW5jb2RlZCBjaGFyYWN0ZXJzCi0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcihsZW4gKyAyMCk7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKLQkJCXRoaXMuYXBwZW5kQ2hhcmFjdGVyVG8ocy5jaGFyQXQoaSksIHNiKTsKLQkJfQotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNwZWNpZmllZCBzdHJpbmcgd2l0aCBhbnkgWE1MIGNoYXJhY3RlciByZWZlcmVuY2VzCi0JICogcmVwbGFjZWQgYnkgdGhlIGNoYXJhY3RlcnMgdGhlbXNlbHZlcy4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGRlY29kZShTdHJpbmcgcykgewotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIocy5sZW5ndGgoKSk7Ci0JCVN0cmluZ0J1aWxkZXIgdGVtcCA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7CS8vIHBlcmZvcm1hbmNlIHR3ZWFrCi0JCXRoaXMuZGVjb2RlVG8obmV3IFN0cmluZ1JlYWRlcihzKSwgc2IsIHRlbXApOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW50ZXJuYWwgbWV0aG9kcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBBcHBlbmQgdGhlIHNwZWNpZmllZCBjaGFyYWN0ZXIgdG8gdGhlIHN0cmluZyBidWZmZXIsCi0JICogY29udmVydGluZyBpdCB0byBhbiBYTUwgY2hhcmFjdGVyIHJlZmVyZW5jZSBpZiBuZWNlc3NhcnkuCi0JICovCi0JcHJpdmF0ZSB2b2lkIGFwcGVuZENoYXJhY3RlclRvKGNoYXIgYywgU3RyaW5nQnVpbGRlciBzYikgewotCQlpZiAodGhpcy5jaGFySXNUb0JlRW5jb2RlZChjKSkgewotCQkJdGhpcy5hcHBlbmRDaGFyYWN0ZXJSZWZlcmVuY2VUbyhjLCBzYik7Ci0JCX0gZWxzZSB7Ci0JCQlzYi5hcHBlbmQoYyk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGNoYXJhY3RlciBpcyBvbmUgb2YgdGhlIGNoYXJhY3RlcnMKLQkgKiB0byBiZSBjb252ZXJ0ZWQgdG8gWE1MIGNoYXJhY3RlciByZWZlcmVuY2VzLgotCSAqLwotCXByaXZhdGUgYm9vbGVhbiBjaGFySXNUb0JlRW5jb2RlZChjaGFyIGMpIHsKLQkJcmV0dXJuIChjIDw9IHRoaXMubWF4Q2hhcikgJiYgQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuY2hhcnMsIGMpOwotCX0KLQotCS8qKgotCSAqIEFwcGVuZCB0aGUgc3BlY2lmaWVkIGNoYXJhY3RlcidzIFhNTCBjaGFyYWN0ZXIgcmVmZXJlbmNlIHRvIHRoZQotCSAqIHNwZWNpZmllZCBzdHJpbmcgYnVmZmVyIChlLmcuICcvJyA9PiAiJiN4MmY7IikuCi0JICovCi0JcHJpdmF0ZSB2b2lkIGFwcGVuZENoYXJhY3RlclJlZmVyZW5jZVRvKGNoYXIgYywgU3RyaW5nQnVpbGRlciBzYikgewotCQlzYi5hcHBlbmQoIiYjeCIpOyAvLyROT04tTkxTLTEkCi0JCXNiLmFwcGVuZChJbnRlZ2VyLnRvU3RyaW5nKGMsIDE2KSk7Ci0JCXNiLmFwcGVuZCgnOycpOwotCX0KLQotCXByaXZhdGUgdm9pZCBkZWNvZGVUbyhSZWFkZXIgcmVhZGVyLCBTdHJpbmdCdWlsZGVyIHNiLCBTdHJpbmdCdWlsZGVyIHRlbXApIHsKLQkJdHJ5IHsKLQkJCXRoaXMuZGVjb2RlVG9fKHJlYWRlciwgc2IsIHRlbXApOwotCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBleCkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oZXgpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGRlY29kZVRvXyhSZWFkZXIgcmVhZGVyLCBTdHJpbmdCdWlsZGVyIHNiLCBTdHJpbmdCdWlsZGVyIHRlbXApIHRocm93cyBJT0V4Y2VwdGlvbiB7Ci0JCWludCBjID0gcmVhZGVyLnJlYWQoKTsKLQkJd2hpbGUgKGMgIT0gLTEpIHsKLQkJCWlmIChjID09ICcmJykgewotCQkJCXRoaXMuZGVjb2RlQ2hhcmFjdGVyUmVmZXJlbmNlVG8ocmVhZGVyLCBzYiwgdGVtcCk7Ci0JCQl9IGVsc2UgewotCQkJCXNiLmFwcGVuZCgoY2hhcikgYyk7Ci0JCQl9Ci0JCQljID0gcmVhZGVyLnJlYWQoKTsKLQkJfQotCQlyZWFkZXIuY2xvc2UoKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgZGVjb2RlQ2hhcmFjdGVyUmVmZXJlbmNlVG8oUmVhZGVyIHJlYWRlciwgU3RyaW5nQnVpbGRlciBzYiwgU3RyaW5nQnVpbGRlciB0ZW1wKSB0aHJvd3MgSU9FeGNlcHRpb24gewotCQlpbnQgYyA9IHJlYWRlci5yZWFkKCk7Ci0JCXRoaXMuY2hlY2tDaGFyKGMsICcjJyk7Ci0JCWMgPSByZWFkZXIucmVhZCgpOwotCQl0aGlzLmNoZWNrQ2hhcihjLCAneCcpOwotCi0JCXRlbXAuc2V0TGVuZ3RoKDApOyAgLy8gcmUtdXNlIHRlbXAKLQkJYyA9IHJlYWRlci5yZWFkKCk7Ci0JCXdoaWxlIChjICE9ICc7JykgewotCQkJdGhpcy5jaGVja0VuZE9mU3RyZWFtKGMpOwotCQkJdGVtcC5hcHBlbmQoKGNoYXIpIGMpOwotCQkJYyA9IHJlYWRlci5yZWFkKCk7Ci0JCX0KLQkJU3RyaW5nIGNoYXJWYWx1ZSA9IHRlbXAudG9TdHJpbmcoKTsKLQkJaWYgKGNoYXJWYWx1ZS5sZW5ndGgoKSA9PSAwKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJtaXNzaW5nIG51bWVyaWMgc3RyaW5nIik7IC8vJE5PTi1OTFMtMSQKLQkJfQotCQlzYi5hcHBlbmQoKGNoYXIpIEludGVnZXIucGFyc2VJbnQoY2hhclZhbHVlLCAxNikpOwotCX0KLQotCXByaXZhdGUgdm9pZCBjaGVja0NoYXIoaW50IGMsIGludCBleHBlY3RlZCkgewotCQl0aGlzLmNoZWNrRW5kT2ZTdHJlYW0oYyk7Ci0JCWlmIChjICE9IGV4cGVjdGVkKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJleHBlY3RlZCAnIiArIChjaGFyKSBleHBlY3RlZCArICInLCBidXQgZW5jb3VudGVyZWQgJyIgKyAoY2hhcikgYyArICInIik7IC8vJE5PTi1OTFMtMSQgLy8kTk9OLU5MUy0yJCAvLyROT04tTkxTLTMkCi0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgY2hlY2tFbmRPZlN0cmVhbShpbnQgYykgewotCQlpZiAoYyA9PSAtMSkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigidW5leHBlY3RlZCBlbmQgb2Ygc3RyaW5nIik7IC8vJE5PTi1OTFMtMSQKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9BcnJheUl0ZXJhdG9yLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0FycmF5SXRlcmF0b3IuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDBkZDBmNi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0FycmF5SXRlcmF0b3IuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDczICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5czsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotLyoqCi0gKiBBbiA8Y29kZT5BcnJheUl0ZXJhdG9yPC9jb2RlPiBwcm92aWRlcyBhbiA8Y29kZT5JdGVyYXRvcjwvY29kZT4KLSAqIGZvciBhbiBhcnJheSBvZiBvYmplY3RzIG9mIHR5cGUgRS4KLSAqLwotcHVibGljIGNsYXNzIEFycmF5SXRlcmF0b3I8RT4KLQlpbXBsZW1lbnRzIEl0ZXJhdG9yPEU+Ci17Ci0JZmluYWwgRVtdIGFycmF5OwkvLyBwcml2YXRlLXByb3RlY3RlZAotCWludCBuZXh0SW5kZXg7CQkvLyBwcml2YXRlLXByb3RlY3RlZAotCXByaXZhdGUgZmluYWwgaW50IG1heEluZGV4OwotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGl0ZXJhdG9yIGZvciB0aGUgc3BlY2lmaWVkIGFycmF5LgotCSAqLwotCXB1YmxpYyBBcnJheUl0ZXJhdG9yKEUuLi4gYXJyYXkpIHsKLQkJdGhpcyhhcnJheSwgMCwgYXJyYXkubGVuZ3RoKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGl0ZXJhdG9yIGZvciB0aGUgc3BlY2lmaWVkIGFycmF5LAotCSAqIHN0YXJ0aW5nIGF0IHRoZSBzcGVjaWZpZWQgc3RhcnQgaW5kZXggYW5kIGNvbnRpbnVpbmcgZm9yCi0JICogdGhlIHNwZWNpZmllZCBsZW5ndGguCi0JICovCi0JcHVibGljIEFycmF5SXRlcmF0b3IoRVtdIGFycmF5LCBpbnQgc3RhcnQsIGludCBsZW5ndGgpIHsKLQkJaWYgKChzdGFydCA8IDApIHx8IChzdGFydCA+IGFycmF5Lmxlbmd0aCkpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oInN0YXJ0OiAiICsgc3RhcnQpOyAvLyROT04tTkxTLTEkCi0JCX0KLQkJaWYgKChsZW5ndGggPCAwKSB8fCAobGVuZ3RoID4gYXJyYXkubGVuZ3RoIC0gc3RhcnQpKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJsZW5ndGg6ICIgKyBsZW5ndGgpOyAvLyROT04tTkxTLTEkCi0JCX0KLQkJdGhpcy5hcnJheSA9IGFycmF5OwotCQl0aGlzLm5leHRJbmRleCA9IHN0YXJ0OwotCQl0aGlzLm1heEluZGV4ID0gc3RhcnQgKyBsZW5ndGg7Ci0JfQotCQotCXB1YmxpYyBib29sZWFuIGhhc05leHQoKSB7Ci0JCXJldHVybiB0aGlzLm5leHRJbmRleCA8IHRoaXMubWF4SW5kZXg7Ci0JfQotCQotCXB1YmxpYyBFIG5leHQoKSB7Ci0JCWlmICh0aGlzLmhhc05leHQoKSkgewotCQkJcmV0dXJuIHRoaXMuYXJyYXlbdGhpcy5uZXh0SW5kZXgrK107Ci0JCX0KLQkJdGhyb3cgbmV3IE5vU3VjaEVsZW1lbnRFeGNlcHRpb24oKTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgQXJyYXlzLnRvU3RyaW5nKHRoaXMuYXJyYXkpKTsKLQl9Ci0JCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0FycmF5TGlzdEl0ZXJhdG9yLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0FycmF5TGlzdEl0ZXJhdG9yLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDViNzBlZDQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9BcnJheUxpc3RJdGVyYXRvci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Ob1N1Y2hFbGVtZW50RXhjZXB0aW9uOwotCi0vKioKLSAqIEFuIDxjb2RlPkFycmF5TGlzdEl0ZXJhdG9yPC9jb2RlPiBwcm92aWRlcyBhIDxjb2RlPkxpc3RJdGVyYXRvcjwvY29kZT4KLSAqIGZvciBhbiBhcnJheSBvZiBvYmplY3RzLgotICogCi0gKiBUaGUgbmFtZSBtaWdodCBiZSBhIGJpdCBjb25mdXNpbmc6Ci0gKiBUaGlzIGlzIGEgPGNvZGU+TGlzdEl0ZXJhdG9yPC9jb2RlPiBmb3IgYW4gPGNvZGU+QXJyYXk8L2NvZGU+OwotICogPGVtPm5vdDwvZW0+IGFuIDxjb2RlPkl0ZXJhdG9yPC9jb2RlPiBmb3IgYW4gPGNvZGU+QXJyYXlMaXN0PC9jb2RlPi4KLSAqLwotcHVibGljIGNsYXNzIEFycmF5TGlzdEl0ZXJhdG9yPEU+Ci0JZXh0ZW5kcyBBcnJheUl0ZXJhdG9yPEU+Ci0JaW1wbGVtZW50cyBMaXN0SXRlcmF0b3I8RT4KLXsKLQlwcml2YXRlIGZpbmFsIGludCBtaW5JbmRleDsKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGxpc3QgaXRlcmF0b3IgZm9yIHRoZSBzcGVjaWZpZWQgYXJyYXkuCi0JICovCi0JcHVibGljIEFycmF5TGlzdEl0ZXJhdG9yKEUuLi4gYXJyYXkpIHsKLQkJdGhpcyhhcnJheSwgMCwgYXJyYXkubGVuZ3RoKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29uc3RydWN0IGEgbGlzdCBpdGVyYXRvciBmb3IgdGhlIHNwZWNpZmllZCBhcnJheSwKLQkgKiBzdGFydGluZyBhdCB0aGUgc3BlY2lmaWVkIHN0YXJ0IGluZGV4IGFuZCBjb250aW51aW5nIGZvcgotCSAqIHRoZSBzcGVjaWZpZWQgbGVuZ3RoLgotCSAqLwotCXB1YmxpYyBBcnJheUxpc3RJdGVyYXRvcihFW10gYXJyYXksIGludCBzdGFydCwgaW50IGxlbmd0aCkgewotCQlzdXBlcihhcnJheSwgc3RhcnQsIGxlbmd0aCk7Ci0JCXRoaXMubWluSW5kZXggPSBzdGFydDsKLQl9Ci0JCi0JcHVibGljIGludCBuZXh0SW5kZXgoKSB7Ci0JCXJldHVybiB0aGlzLm5leHRJbmRleDsKLQl9Ci0JCi0JcHVibGljIGludCBwcmV2aW91c0luZGV4KCkgewotCQlyZXR1cm4gdGhpcy5uZXh0SW5kZXggLSAxOwotCX0KLQkKLQlwdWJsaWMgYm9vbGVhbiBoYXNQcmV2aW91cygpIHsKLQkJcmV0dXJuIHRoaXMubmV4dEluZGV4ID4gdGhpcy5taW5JbmRleDsKLQl9Ci0JCi0JcHVibGljIEUgcHJldmlvdXMoKSB7Ci0JCWlmICh0aGlzLmhhc1ByZXZpb3VzKCkpIHsKLQkJCXJldHVybiB0aGlzLmFycmF5Wy0tdGhpcy5uZXh0SW5kZXhdOwotCQl9Ci0JCXRocm93IG5ldyBOb1N1Y2hFbGVtZW50RXhjZXB0aW9uKCk7Ci0JfQotCQotCXB1YmxpYyB2b2lkIGFkZChFIGUpIHsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHNldChFIGUpIHsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBzdXBlci50b1N0cmluZygpOwotCX0KLQkKLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvQ2hhaW5JdGVyYXRvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9DaGFpbkl0ZXJhdG9yLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJhNTM4ZDYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9DaGFpbkl0ZXJhdG9yLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNDUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci0KLS8qKgotICogQSA8Y29kZT5DaGFpbkl0ZXJhdG9yPC9jb2RlPiBwcm92aWRlcyBhIHBsdWdnYWJsZSA8Y29kZT5JdGVyYXRvcjwvY29kZT4KLSAqIHRoYXQgbG9vcHMgb3ZlciBhIGNoYWluIG9mIGFyYml0cmFyaWx5IGxpbmtlZCBvYmplY3RzLiBUaGUgY2hhaW4KLSAqIHNob3VsZCBiZSBudWxsLXRlcm1pbmF0ZWQgKGkuZS4gYSBjYWxsIHRvIHRoZSA8Y29kZT5uZXh0TGluayhPYmplY3QpPC9jb2RlPgotICogbWV0aG9kIHNob3VsZCByZXR1cm4gPGNvZGU+bnVsbDwvY29kZT4gd2hlbiBpdCBpcyBwYXNzZWQgdGhlIGxhc3QKLSAqIGxpbmsgb2YgdGhlIGNoYWluKS4KLSAqIFRvIHVzZSwgc3VwcGx5IGEgc3RhcnRpbmcgbGluayBhbmQgc3VwcGx5IGEgPGNvZGU+TGlua2VyPC9jb2RlPiBvciAKLSAqIHN1YmNsYXNzIDxjb2RlPkNoYWluSXRlcmF0b3I8L2NvZGU+IGFuZCBvdmVycmlkZSB0aGUKLSAqIDxjb2RlPm5leHRMaW5rKE9iamVjdCk8L2NvZGU+IG1ldGhvZC4KLSAqIFRoZSBzdGFydGluZyBsaW5rIHdpbGwgYmUgdGhlIGZpcnN0IG9iamVjdCByZXR1cm5lZCBieSB0aGUgaXRlcmF0b3IuCi0gKiBJZiB0aGUgc3RhcnRpbmcgbGluayBpcyA8Y29kZT5udWxsPC9jb2RlPiwgdGhlIGl0ZXJhdG9yIHdpbGwgYmUgZW1wdHkuCi0gKiBOb3RlIHRoYXQgdGhlIGl0ZXJhdG9yIGRvZXMgbm90IHN1cHBvcnQgPGNvZGU+bnVsbDwvY29kZT4gZWxlbWVudHMuCi0gKi8KLXB1YmxpYyBjbGFzcyBDaGFpbkl0ZXJhdG9yPEU+Ci0JaW1wbGVtZW50cyBJdGVyYXRvcjxFPgotewotCXByaXZhdGUgRSBuZXh0TGluazsKLQlwcml2YXRlIGZpbmFsIExpbmtlcjxFPiBsaW5rZXI7Ci0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBpdGVyYXRvciB3aXRoIHRoZSBzcGVjaWZpZWQgc3RhcnRpbmcgbGluawotCSAqIGFuZCBhIGRpc2FibGVkIGxpbmtlci4KLQkgKiBVc2UgdGhpcyBjb25zdHJ1Y3RvciBpZiB5b3Ugd2FudCB0byBvdmVycmlkZSB0aGUKLQkgKiA8Y29kZT5uZXh0TGluayhPYmplY3QpPC9jb2RlPiBtZXRob2QgaW5zdGVhZCBvZiBidWlsZGluZwotCSAqIGEgPGNvZGU+TGlua2VyPC9jb2RlPi4KLQkgKi8KLQlwdWJsaWMgQ2hhaW5JdGVyYXRvcihFIHN0YXJ0TGluaykgewotCQl0aGlzKHN0YXJ0TGluaywgTGlua2VyLkRpc2FibGVkLjxFPmluc3RhbmNlKCkpOwotCX0KLQkKLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gaXRlcmF0b3Igd2l0aCB0aGUgc3BlY2lmaWVkIHN0YXJ0aW5nIGxpbmsKLQkgKiBhbmQgbGlua2VyLgotCSAqLwotCXB1YmxpYyBDaGFpbkl0ZXJhdG9yKEUgc3RhcnRMaW5rLCBMaW5rZXI8RT4gbGlua2VyKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMubmV4dExpbmsgPSBzdGFydExpbms7Ci0JCXRoaXMubGlua2VyID0gbGlua2VyOwotCX0KLQkKLQlwdWJsaWMgYm9vbGVhbiBoYXNOZXh0KCkgewotCQlyZXR1cm4gdGhpcy5uZXh0TGluayAhPSBudWxsOwotCX0KLQkKLQlwdWJsaWMgRSBuZXh0KCkgewotCQlpZiAodGhpcy5uZXh0TGluayA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpOwotCQl9Ci0JCUUgcmVzdWx0ID0gdGhpcy5uZXh0TGluazsKLQkJdGhpcy5uZXh0TGluayA9IHRoaXMubmV4dExpbmsodGhpcy5uZXh0TGluayk7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHJlbW92ZSgpIHsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgbmV4dCBsaW5rIGluIHRoZSBjaGFpbi4KLQkgKi8KLQlwcm90ZWN0ZWQgRSBuZXh0TGluayhFIGN1cnJlbnRMaW5rKSB7Ci0JCXJldHVybiB0aGlzLmxpbmtlci5uZXh0TGluayhjdXJyZW50TGluayk7Ci0JfQotCQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMubmV4dExpbmspOwotCX0KLQkKLQotCS8vKioqKioqKioqKiBpbm5lciBjbGFzc2VzICoqKioqKioqKioKLQotCS8qKgotCSAqIFVzZWQgYnkgPGNvZGU+Q2hhaW5JdGVyYXRvcjwvY29kZT4gdG8gbGluawotCSAqIHRoZSBlbGVtZW50cyBpbiB0aGUgY2hhaW4uCi0JICovCi0JcHVibGljIGludGVyZmFjZSBMaW5rZXI8VD4gewotCi0JCS8qKgotCQkgKiBSZXR1cm4gdGhlIG5leHQgbGluayBpbiB0aGUgY2hhaW4uCi0JCSAqLwotCQlUIG5leHRMaW5rKFQgY3VycmVudExpbmspOwotCi0KLQkJZmluYWwgY2xhc3MgTnVsbDxTPiBpbXBsZW1lbnRzIExpbmtlcjxTPiB7Ci0JCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgTGlua2VyIElOU1RBTkNFID0gbmV3IE51bGwoKTsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHVibGljIHN0YXRpYyA8Uj4gTGlua2VyPFI+IGluc3RhbmNlKCkgewotCQkJCXJldHVybiBJTlNUQU5DRTsKLQkJCX0KLQkJCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJCXByaXZhdGUgTnVsbCgpIHsKLQkJCQlzdXBlcigpOwotCQkJfQotCQkJLy8gc2ltcGx5IHJldHVybiBudWxsLCBpbmRpY2F0aW5nIHRoZSBjaGFpbiBpcyBlbmRlZAotCQkJcHVibGljIFMgbmV4dExpbmsoUyBjdXJyZW50TGluaykgewotCQkJCXJldHVybiBudWxsOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiQ2hhaW5JdGVyYXRvci5MaW5rZXIuTnVsbCI7IC8vJE5PTi1OTFMtMSQKLQkJCX0KLQkJfQotCi0JCWZpbmFsIGNsYXNzIERpc2FibGVkPFM+IGltcGxlbWVudHMgTGlua2VyPFM+IHsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBMaW5rZXIgSU5TVEFOQ0UgPSBuZXcgRGlzYWJsZWQoKTsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHVibGljIHN0YXRpYyA8Uj4gTGlua2VyPFI+IGluc3RhbmNlKCkgewotCQkJCXJldHVybiBJTlNUQU5DRTsKLQkJCX0KLQkJCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJCXByaXZhdGUgRGlzYWJsZWQoKSB7Ci0JCQkJc3VwZXIoKTsKLQkJCX0KLQkJCS8vIHRocm93IGFuIGV4Y2VwdGlvbgotCQkJcHVibGljIFMgbmV4dExpbmsoUyBjdXJyZW50TGluaykgewotCQkJCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOyAgLy8gQ2hhaW5JdGVyYXRvci5uZXh0TGluayhPYmplY3QpIHdhcyBub3QgaW1wbGVtZW50ZWQKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gIkNoYWluSXRlcmF0b3IuTGlua2VyLkRpc2FibGVkIjsgLy8kTk9OLU5MUy0xJAotCQkJfQotCQl9Ci0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvQ2xvbmVJdGVyYXRvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9DbG9uZUl0ZXJhdG9yLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDc5NzY0MzkuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9DbG9uZUl0ZXJhdG9yLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNTQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci0KLS8qKgotICogQSA8Y29kZT5DbG9uZUl0ZXJhdG9yPC9jb2RlPiBpdGVyYXRlcyBvdmVyIGEgY29weSBvZiBhIGNvbGxlY3Rpb24sCi0gKiBhbGxvd2luZyBmb3IgY29uY3VycmVudCBhY2Nlc3MgdG8gdGhlIG9yaWdpbmFsIGNvbGxlY3Rpb24uCi0gKiA8cD4KLSAqIFRoZSBvcmlnaW5hbCBjb2xsZWN0aW9uIHBhc3NlZCB0byB0aGUgPGNvZGU+Q2xvbmVJdGVyYXRvcjwvY29kZT4ncwotICogY29uc3RydWN0b3Igc2hvdWxkIGJlIHN5bmNocm9uaXplZDsgb3RoZXJ3aXNlIHlvdSBydW4gdGhlIHJpc2sgb2YKLSAqIGEgY29ycnVwdGVkIGNvbGxlY3Rpb24uCi0gKiA8cD4KLSAqIEJ5IGRlZmF1bHQsIGEgPGNvZGU+Q2xvbmVJdGVyYXRvcjwvY29kZT4gZG9lcyBub3Qgc3VwcG9ydCB0aGUKLSAqIDxjb2RlPiNyZW1vdmUoKTwvY29kZT4gb3BlcmF0aW9uOyB0aGlzIGlzIGJlY2F1c2UgaXQgZG9lcyBub3QgaGF2ZQotICogYWNjZXNzIHRvIHRoZSBvcmlnaW5hbCBjb2xsZWN0aW9uLiBCdXQgaWYgdGhlIDxjb2RlPkNsb25lSXRlcmF0b3I8L2NvZGU+Ci0gKiBpcyBzdXBwbGllZCB3aXRoIGFuIDxjb2RlPk11dGF0b3I8L2NvZGU+IGl0IHdpbGwgZGVsZWdhdGUgdGhlCi0gKiA8Y29kZT4jcmVtb3ZlKCk8L2NvZGU+IG9wZXJhdGlvbiB0byB0aGUgPGNvZGU+TXV0YXRvcjwvY29kZT4uCi0gKiBBbHRlcm5hdGl2ZWx5LCBhIHN1YmNsYXNzIGNhbiBvdmVycmlkZSB0aGUgPGNvZGU+I3JlbW92ZShPYmplY3QpPC9jb2RlPgotICogbWV0aG9kLgotICovCi1wdWJsaWMgY2xhc3MgQ2xvbmVJdGVyYXRvcjxFPgotCWltcGxlbWVudHMgSXRlcmF0b3I8RT4KLXsKLQlwcml2YXRlIGZpbmFsIEl0ZXJhdG9yPE9iamVjdD4gbmVzdGVkSXRlcmF0b3I7Ci0JcHJpdmF0ZSBFIGN1cnJlbnQ7Ci0JcHJpdmF0ZSBmaW5hbCBNdXRhdG9yPEU+IG11dGF0b3I7Ci0JcHJpdmF0ZSBib29sZWFuIHJlbW92ZUFsbG93ZWQ7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBpdGVyYXRvciBvbiBhIGNvcHkgb2YgdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLgotCSAqIFRoZSA8Y29kZT4jcmVtb3ZlKCk8L2NvZGU+IG1ldGhvZCB3aWxsIG5vdCBiZSBzdXBwb3J0ZWQsCi0JICogdW5sZXNzIGEgc3ViY2xhc3Mgb3ZlcnJpZGVzIHRoZSA8Y29kZT4jcmVtb3ZlKE9iamVjdCk8L2NvZGU+LgotCSAqLwotCXB1YmxpYyBDbG9uZUl0ZXJhdG9yKENvbGxlY3Rpb248PyBleHRlbmRzIEU+IGMpIHsKLQkJdGhpcyhjLCBNdXRhdG9yLlJlYWRPbmx5LjxFPmluc3RhbmNlKCkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBpdGVyYXRvciBvbiBhIGNvcHkgb2YgdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLgotCSAqIFVzZSB0aGUgc3BlY2lmaWVkIG11dGF0b3IgdG8gcmVtb3ZlIG9iamVjdHMgZnJvbSB0aGUKLQkgKiBvcmlnaW5hbCBjb2xsZWN0aW9uLgotCSAqLwotCXB1YmxpYyBDbG9uZUl0ZXJhdG9yKENvbGxlY3Rpb248PyBleHRlbmRzIEU+IGMsIE11dGF0b3I8RT4gbXV0YXRvcikgewotCQlzdXBlcigpOwotCQl0aGlzLm5lc3RlZEl0ZXJhdG9yID0gbmV3IEFycmF5SXRlcmF0b3I8T2JqZWN0PihjLnRvQXJyYXkoKSk7Ci0JCXRoaXMuY3VycmVudCA9IG51bGw7Ci0JCXRoaXMubXV0YXRvciA9IG11dGF0b3I7Ci0JCXRoaXMucmVtb3ZlQWxsb3dlZCA9IGZhbHNlOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBJdGVyYXRvciBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgYm9vbGVhbiBoYXNOZXh0KCkgewotCQlyZXR1cm4gdGhpcy5uZXN0ZWRJdGVyYXRvci5oYXNOZXh0KCk7Ci0JfQotCi0JcHVibGljIEUgbmV4dCgpIHsKLQkJdGhpcy5jdXJyZW50ID0gdGhpcy5uZXN0ZWROZXh0KCk7Ci0JCXRoaXMucmVtb3ZlQWxsb3dlZCA9IHRydWU7Ci0JCXJldHVybiB0aGlzLmN1cnJlbnQ7Ci0JfQotCi0JcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQlpZiAoICEgdGhpcy5yZW1vdmVBbGxvd2VkKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy5yZW1vdmUodGhpcy5jdXJyZW50KTsKLQkJdGhpcy5yZW1vdmVBbGxvd2VkID0gZmFsc2U7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGludGVybmFsIG1ldGhvZHMgKioqKioqKioqKgotCi0JLyoqCi0JICogVGhlIGNvbGxlY3Rpb24gcGFzc2VkIGluIGR1cmluZyBjb25zdHJ1Y3Rpb24gaGVsZCBFcywKLQkgKiBzbyB0aGlzIGNhc3QgaXMgbm90IGEgcHJvYmxlbS4gV2UgbmVlZCB0aGlzIGNhc3QgYmVjYXVzZQotCSAqIGFsbCB0aGUgZWxlbWVudHMgb2YgdGhlIG9yaWdpbmFsIGNvbGxlY3Rpb24gd2VyZSBjb3BpZWQgaW50bwotCSAqIGFuIG9iamVjdCBhcnJheSAoT2JqZWN0W10pLgotCSAqLwotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByb3RlY3RlZCBFIG5lc3RlZE5leHQoKSB7Ci0JCXJldHVybiAoRSkgdGhpcy5uZXN0ZWRJdGVyYXRvci5uZXh0KCk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgZWxlbWVudCBmcm9tIHRoZSBvcmlnaW5hbCBjb2xsZWN0aW9uLgotCSAqIDxwPgotCSAqIFRoaXMgbWV0aG9kIGNhbiBiZSBvdmVycmlkZGVuIGJ5IGEgc3ViY2xhc3MgYXMgYW4KLQkgKiBhbHRlcm5hdGl2ZSB0byBidWlsZGluZyBhbiA8Y29kZT5NdXRhdG9yPC9jb2RlPi4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCByZW1vdmUoRSBlKSB7Ci0JCXRoaXMubXV0YXRvci5yZW1vdmUoZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcyk7Ci0JfQotCi0KLQkvLyoqKioqKioqKiogbWVtYmVyIGludGVyZmFjZSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBVc2VkIGJ5IDxjb2RlPkNsb25lSXRlcmF0b3I8L2NvZGU+IHRvIHJlbW92ZQotCSAqIGVsZW1lbnRzIGZyb20gdGhlIG9yaWdpbmFsIGNvbGxlY3Rpb247IHNpbmNlIHRoZSBpdGVyYXRvcgotCSAqIGRvZXMgbm90IGhhdmUgZGlyZWN0IGFjY2VzcyB0byB0aGUgb3JpZ2luYWwgY29sbGVjdGlvbi4KLQkgKi8KLQlwdWJsaWMgaW50ZXJmYWNlIE11dGF0b3I8VD4gewotCi0JCS8qKgotCQkgKiBSZW1vdmUgdGhlIHNwZWNpZmllZCBvYmplY3QgZnJvbSB0aGUgb3JpZ2luYWwgY29sbGVjdGlvbi4KLQkJICovCi0JCXZvaWQgcmVtb3ZlKFQgY3VycmVudCk7Ci0KLQotCQlmaW5hbCBjbGFzcyBSZWFkT25seTxTPiBpbXBsZW1lbnRzIE11dGF0b3I8Uz4gewotCQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIE11dGF0b3IgSU5TVEFOQ0UgPSBuZXcgUmVhZE9ubHkoKTsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHVibGljIHN0YXRpYyA8Uj4gTXV0YXRvcjxSPiBpbnN0YW5jZSgpIHsKLQkJCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCQl9Ci0JCQkvLyBlbnN1cmUgc2luZ2xlIGluc3RhbmNlCi0JCQlwcml2YXRlIFJlYWRPbmx5KCkgewotCQkJCXN1cGVyKCk7Ci0JCQl9Ci0JCQkvLyByZW1vdmUgaXMgbm90IHN1cHBvcnRlZAotCQkJcHVibGljIHZvaWQgcmVtb3ZlKE9iamVjdCBjdXJyZW50KSB7Ci0JCQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJDbG9uZUl0ZXJhdG9yLk11dGF0b3IuUmVhZE9ubHkiOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCX0KLQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9DbG9uZUxpc3RJdGVyYXRvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9DbG9uZUxpc3RJdGVyYXRvci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4NmRlNWEwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvQ2xvbmVMaXN0SXRlcmF0b3IuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI1NSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9yczsKLQotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotCi0vKioKLSAqIEEgPGNvZGU+Q2xvbmVMaXN0SXRlcmF0b3I8L2NvZGU+IGl0ZXJhdGVzIG92ZXIgYSBjb3B5IG9mIGEgbGlzdCwKLSAqIGFsbG93aW5nIGZvciBjb25jdXJyZW50IGFjY2VzcyB0byB0aGUgb3JpZ2luYWwgbGlzdC4KLSAqIDxwPgotICogVGhlIG9yaWdpbmFsIGxpc3QgcGFzc2VkIHRvIHRoZSA8Y29kZT5DbG9uZUxpc3RJdGVyYXRvcjwvY29kZT4ncwotICogY29uc3RydWN0b3Igc2hvdWxkIGJlIHN5bmNocm9uaXplZDsgb3RoZXJ3aXNlIHlvdSBydW4gdGhlIHJpc2sgb2YKLSAqIGEgY29ycnVwdGVkIGxpc3QuCi0gKiA8cD4KLSAqIEJ5IGRlZmF1bHQsIGEgPGNvZGU+Q2xvbmVMaXN0SXRlcmF0b3I8L2NvZGU+IGRvZXMgbm90IHN1cHBvcnQgdGhlCi0gKiBtb2RpZmljYXRpb24gb3BlcmF0aW9uczsgdGhpcyBpcyBiZWNhdXNlIGl0IGRvZXMgbm90IGhhdmUKLSAqIGFjY2VzcyB0byB0aGUgb3JpZ2luYWwgbGlzdC4gQnV0IGlmIHRoZSA8Y29kZT5DbG9uZUxpc3RJdGVyYXRvcjwvY29kZT4KLSAqIGlzIHN1cHBsaWVkIHdpdGggYSA8Y29kZT5NdXRhdG9yPC9jb2RlPiBpdCB3aWxsIGRlbGVnYXRlIHRoZQotICogbW9kaWZpY2F0aW9uIG9wZXJhdGlvbnMgdG8gdGhlIDxjb2RlPk11dGF0b3I8L2NvZGU+LgotICogQWx0ZXJuYXRpdmVseSwgYSBzdWJjbGFzcyBjYW4gb3ZlcnJpZGUgdGhlIG1vZGlmaWNhdGlvbiBtZXRob2RzLgotICovCi1wdWJsaWMgY2xhc3MgQ2xvbmVMaXN0SXRlcmF0b3I8RT4KLQlpbXBsZW1lbnRzIExpc3RJdGVyYXRvcjxFPgotewotCXByaXZhdGUgZmluYWwgTGlzdEl0ZXJhdG9yPE9iamVjdD4gbmVzdGVkTGlzdEl0ZXJhdG9yOwotCXByaXZhdGUgaW50IGN1cnNvcjsKLQlwcml2YXRlIFN0YXRlIHN0YXRlOwotCXByaXZhdGUgZmluYWwgTXV0YXRvcjxFPiBtdXRhdG9yOwotCi0JcHJpdmF0ZSBlbnVtIFN0YXRlIHsKLQkJVU5LTk9XTiwKLQkJUFJFVklPVVMsCi0JCU5FWFQKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGxpc3QgaXRlcmF0b3Igb24gYSBjb3B5IG9mIHRoZSBzcGVjaWZpZWQgbGlzdC4KLQkgKiBUaGUgbW9kaWZpY2F0aW9uIG1ldGhvZHMgd2lsbCBub3QgYmUgc3VwcG9ydGVkLAotCSAqIHVubGVzcyBhIHN1YmNsYXNzIG92ZXJyaWRlcyB0aGVtLgotCSAqLwotCXB1YmxpYyBDbG9uZUxpc3RJdGVyYXRvcihMaXN0PD8gZXh0ZW5kcyBFPiBsaXN0KSB7Ci0JCXRoaXMobGlzdCwgTXV0YXRvci5SZWFkT25seS48RT5pbnN0YW5jZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBsaXN0IGl0ZXJhdG9yIG9uIGEgY29weSBvZiB0aGUgc3BlY2lmaWVkIGxpc3QuCi0JICogVXNlIHRoZSBzcGVjaWZpZWQgbGlzdCBtdXRhdG9yIHRvIG1vZGlmeSB0aGUgb3JpZ2luYWwgbGlzdC4KLQkgKi8KLQlwdWJsaWMgQ2xvbmVMaXN0SXRlcmF0b3IoTGlzdDw/IGV4dGVuZHMgRT4gbGlzdCwgTXV0YXRvcjxFPiBtdXRhdG9yKSB7Ci0JCXN1cGVyKCk7Ci0JCS8vIGJ1aWxkIGEgY29weSBvZiB0aGUgbGlzdCBhbmQga2VlcCBpdCBpbiBzeW5jaCB3aXRoIG9yaWdpbmFsIChpZiB0aGUgbXV0YXRvciBhbGxvd3MgY2hhbmdlcykKLQkJLy8gdGhhdCB3YXkgdGhlIG5lc3RlZCBsaXN0IGl0ZXJhdG9yIHdpbGwgbWFpbnRhaW4gc29tZSBvZiBvdXIgc3RhdGUKLQkJdGhpcy5uZXN0ZWRMaXN0SXRlcmF0b3IgPSBDb2xsZWN0aW9uVG9vbHMubGlzdChsaXN0LnRvQXJyYXkoKSkubGlzdEl0ZXJhdG9yKCk7Ci0JCXRoaXMubXV0YXRvciA9IG11dGF0b3I7Ci0JCXRoaXMuY3Vyc29yID0gMDsKLQkJdGhpcy5zdGF0ZSA9IFN0YXRlLlVOS05PV047Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIExpc3RJdGVyYXRvciBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgYm9vbGVhbiBoYXNOZXh0KCkgewotCQlyZXR1cm4gdGhpcy5uZXN0ZWRMaXN0SXRlcmF0b3IuaGFzTmV4dCgpOwotCX0KLQotCXB1YmxpYyBFIG5leHQoKSB7Ci0JCS8vIGFsbG93IHRoZSBuZXN0ZWQgaXRlcmF0b3IgdG8gdGhyb3cgYW4gZXhjZXB0aW9uIGJlZm9yZSB3ZSBtb2RpZnkgdGhlIGluZGV4Ci0JCUUgbmV4dCA9IHRoaXMubmVzdGVkTmV4dCgpOwotCQl0aGlzLmN1cnNvcisrOwotCQl0aGlzLnN0YXRlID0gU3RhdGUuTkVYVDsKLQkJcmV0dXJuIG5leHQ7Ci0JfQotCi0JcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQkvLyBhbGxvdyB0aGUgbmVzdGVkIGl0ZXJhdG9yIHRvIHRocm93IGFuIGV4Y2VwdGlvbiBiZWZvcmUgd2UgbW9kaWZ5IHRoZSBvcmlnaW5hbCBsaXN0Ci0JCXRoaXMubmVzdGVkTGlzdEl0ZXJhdG9yLnJlbW92ZSgpOwotCQlpZiAodGhpcy5zdGF0ZSA9PSBTdGF0ZS5QUkVWSU9VUykgewotCQkJdGhpcy5yZW1vdmUodGhpcy5jdXJzb3IpOwotCQl9IGVsc2UgewotCQkJdGhpcy5jdXJzb3ItLTsKLQkJCXRoaXMucmVtb3ZlKHRoaXMuY3Vyc29yKTsKLQkJfQotCX0KLQotCXB1YmxpYyBpbnQgbmV4dEluZGV4KCkgewotCQlyZXR1cm4gdGhpcy5uZXN0ZWRMaXN0SXRlcmF0b3IubmV4dEluZGV4KCk7Ci0JfQotCi0JcHVibGljIGludCBwcmV2aW91c0luZGV4KCkgewotCQlyZXR1cm4gdGhpcy5uZXN0ZWRMaXN0SXRlcmF0b3IucHJldmlvdXNJbmRleCgpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGhhc1ByZXZpb3VzKCkgewotCQlyZXR1cm4gdGhpcy5uZXN0ZWRMaXN0SXRlcmF0b3IuaGFzUHJldmlvdXMoKTsKLQl9Ci0KLQlwdWJsaWMgRSBwcmV2aW91cygpIHsKLQkJLy8gYWxsb3cgdGhlIG5lc3RlZCBpdGVyYXRvciB0byB0aHJvdyBhbiBleGNlcHRpb24gYmVmb3JlIHdlIG1vZGlmeSB0aGUgaW5kZXgKLQkJRSBwcmV2aW91cyA9IHRoaXMubmVzdGVkUHJldmlvdXMoKTsKLQkJdGhpcy5jdXJzb3ItLTsKLQkJdGhpcy5zdGF0ZSA9IFN0YXRlLlBSRVZJT1VTOwotCQlyZXR1cm4gcHJldmlvdXM7Ci0JfQotCi0JcHVibGljIHZvaWQgYWRkKEUgbykgewotCQkvLyBhbGxvdyB0aGUgbmVzdGVkIGl0ZXJhdG9yIHRvIHRocm93IGFuIGV4Y2VwdGlvbiBiZWZvcmUgd2UgbW9kaWZ5IHRoZSBvcmlnaW5hbCBsaXN0Ci0JCXRoaXMubmVzdGVkTGlzdEl0ZXJhdG9yLmFkZChvKTsKLQkJdGhpcy5hZGQodGhpcy5jdXJzb3IsIG8pOwotCQl0aGlzLmN1cnNvcisrOwotCX0KLQotCXB1YmxpYyB2b2lkIHNldChFIG8pIHsKLQkJLy8gYWxsb3cgdGhlIG5lc3RlZCBpdGVyYXRvciB0byB0aHJvdyBhbiBleGNlcHRpb24gYmVmb3JlIHdlIG1vZGlmeSB0aGUgb3JpZ2luYWwgbGlzdAotCQl0aGlzLm5lc3RlZExpc3RJdGVyYXRvci5zZXQobyk7Ci0JCWlmICh0aGlzLnN0YXRlID09IFN0YXRlLlBSRVZJT1VTKSB7Ci0JCQl0aGlzLnNldCh0aGlzLmN1cnNvciwgbyk7Ci0JCX0gZWxzZSB7Ci0JCQl0aGlzLnNldCh0aGlzLmN1cnNvciAtIDEsIG8pOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGludGVybmFsIG1ldGhvZHMgKioqKioqKioqKgotCi0JLyoqCi0JICogVGhlIGxpc3QgcGFzc2VkIGluIGR1cmluZyBjb25zdHJ1Y3Rpb24gaGVsZCBFcywKLQkgKiBzbyB0aGlzIGNhc3QgaXMgbm90IGEgcHJvYmxlbS4gV2UgbmVlZCB0aGlzIGNhc3QgYmVjYXVzZQotCSAqIGFsbCB0aGUgZWxlbWVudHMgb2YgdGhlIG9yaWdpbmFsIGNvbGxlY3Rpb24gd2VyZSBjb3BpZWQgaW50bwotCSAqIGFuIG9iamVjdCBhcnJheSAoT2JqZWN0W10pLgotCSAqLwotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByb3RlY3RlZCBFIG5lc3RlZE5leHQoKSB7Ci0JCXJldHVybiAoRSkgdGhpcy5uZXN0ZWRMaXN0SXRlcmF0b3IubmV4dCgpOwotCX0KLQotCS8qKgotCSAqIFRoZSBsaXN0IHBhc3NlZCBpbiBkdXJpbmcgY29uc3RydWN0aW9uIGhlbGQgRXMsCi0JICogc28gdGhpcyBjYXN0IGlzIG5vdCBhIHByb2JsZW0uIFdlIG5lZWQgdGhpcyBjYXN0IGJlY2F1c2UKLQkgKiBhbGwgdGhlIGVsZW1lbnRzIG9mIHRoZSBvcmlnaW5hbCBjb2xsZWN0aW9uIHdlcmUgY29waWVkIGludG8KLQkgKiBhbiBvYmplY3QgYXJyYXkgKE9iamVjdFtdKS4KLQkgKi8KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcm90ZWN0ZWQgRSBuZXN0ZWRQcmV2aW91cygpIHsKLQkJcmV0dXJuIChFKSB0aGlzLm5lc3RlZExpc3RJdGVyYXRvci5wcmV2aW91cygpOwotCX0KLQotCS8qKgotCSAqIEFkZCB0aGUgc3BlY2lmaWVkIGVsZW1lbnQgdG8gdGhlIG9yaWdpbmFsIGxpc3QuCi0JICogPHA+Ci0JICogVGhpcyBtZXRob2QgY2FuIGJlIG92ZXJyaWRkZW4gYnkgYSBzdWJjbGFzcyBhcyBhbgotCSAqIGFsdGVybmF0aXZlIHRvIGJ1aWxkaW5nIGEgPGNvZGU+TXV0YXRvcjwvY29kZT4uCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgYWRkKGludCBpbmRleCwgRSBvKSB7Ci0JCXRoaXMubXV0YXRvci5hZGQoaW5kZXgsIG8pOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSB0aGUgc3BlY2lmaWVkIGVsZW1lbnQgZnJvbSB0aGUgb3JpZ2luYWwgbGlzdC4KLQkgKiA8cD4KLQkgKiBUaGlzIG1ldGhvZCBjYW4gYmUgb3ZlcnJpZGRlbiBieSBhIHN1YmNsYXNzIGFzIGFuCi0JICogYWx0ZXJuYXRpdmUgdG8gYnVpbGRpbmcgYSA8Y29kZT5NdXRhdG9yPC9jb2RlPi4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCByZW1vdmUoaW50IGluZGV4KSB7Ci0JCXRoaXMubXV0YXRvci5yZW1vdmUoaW5kZXgpOwotCX0KLQotCS8qKgotCSAqIFNldCB0aGUgc3BlY2lmaWVkIGVsZW1lbnQgaW4gdGhlIG9yaWdpbmFsIGxpc3QuCi0JICogPHA+Ci0JICogVGhpcyBtZXRob2QgY2FuIGJlIG92ZXJyaWRkZW4gYnkgYSBzdWJjbGFzcyBhcyBhbgotCSAqIGFsdGVybmF0aXZlIHRvIGJ1aWxkaW5nIGEgPGNvZGU+TXV0YXRvcjwvY29kZT4uCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgc2V0KGludCBpbmRleCwgRSBvKSB7Ci0JCXRoaXMubXV0YXRvci5zZXQoaW5kZXgsIG8pOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBvdmVycmlkZXMgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcyk7Ci0JfQotCi0KLQkvLyoqKioqKioqKiogbWVtYmVyIGludGVyZmFjZSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBVc2VkIGJ5IDxjb2RlPkNsb25lTGlzdEl0ZXJhdG9yPC9jb2RlPiB0byByZW1vdmUKLQkgKiBlbGVtZW50cyBmcm9tIHRoZSBvcmlnaW5hbCBsaXN0OyBzaW5jZSB0aGUgbGlzdCBpdGVyYXRvcgotCSAqIGRvZXMgbm90IGhhdmUgZGlyZWN0IGFjY2VzcyB0byB0aGUgb3JpZ2luYWwgbGlzdC4KLQkgKi8KLQlwdWJsaWMgaW50ZXJmYWNlIE11dGF0b3I8VD4gewotCi0JCS8qKgotCQkgKiBBZGQgdGhlIHNwZWNpZmllZCBvYmplY3QgdG8gdGhlIG9yaWdpbmFsIGxpc3QuCi0JCSAqLwotCQl2b2lkIGFkZChpbnQgaW5kZXgsIFQgbyk7Ci0KLQkJLyoqCi0JCSAqIFJlbW92ZSB0aGUgc3BlY2lmaWVkIG9iamVjdCBmcm9tIHRoZSBvcmlnaW5hbCBsaXN0LgotCQkgKi8KLQkJdm9pZCByZW1vdmUoaW50IGluZGV4KTsKLQotCQkvKioKLQkJICogU2V0IHRoZSBzcGVjaWZpZWQgb2JqZWN0IGluIHRoZSBvcmlnaW5hbCBsaXN0LgotCQkgKi8KLQkJdm9pZCBzZXQoaW50IGluZGV4LCBUIG8pOwotCi0KLQkJZmluYWwgY2xhc3MgUmVhZE9ubHk8Uz4gaW1wbGVtZW50cyBNdXRhdG9yPFM+IHsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBNdXRhdG9yIElOU1RBTkNFID0gbmV3IFJlYWRPbmx5KCk7Ci0JCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJCXB1YmxpYyBzdGF0aWMgPFI+IE11dGF0b3I8Uj4gaW5zdGFuY2UoKSB7Ci0JCQkJcmV0dXJuIElOU1RBTkNFOwotCQkJfQotCQkJLy8gZW5zdXJlIHNpbmdsZSBpbnN0YW5jZQotCQkJcHJpdmF0ZSBSZWFkT25seSgpIHsKLQkJCQlzdXBlcigpOwotCQkJfQotCQkJLy8gYWRkIGlzIG5vdCBzdXBwb3J0ZWQKLQkJCXB1YmxpYyB2b2lkIGFkZChpbnQgaW5kZXgsIE9iamVjdCBvKSB7Ci0JCQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JCQl9Ci0JCQkvLyByZW1vdmUgaXMgbm90IHN1cHBvcnRlZAotCQkJcHVibGljIHZvaWQgcmVtb3ZlKGludCBpbmRleCkgewotCQkJCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCQkJfQotCQkJLy8gc2V0IGlzIG5vdCBzdXBwb3J0ZWQKLQkJCXB1YmxpYyB2b2lkIHNldChpbnQgaW5kZXgsIE9iamVjdCBvKSB7Ci0JCQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJDbG9uZUxpc3RJdGVyYXRvci5NdXRhdG9yLlJlYWRPbmx5IjsgLy8kTk9OLU5MUy0xJAotCQkJfQotCQl9Ci0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvQ29tcG9zaXRlSXRlcmF0b3IuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvQ29tcG9zaXRlSXRlcmF0b3IuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDgzZjUzNS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0NvbXBvc2l0ZUl0ZXJhdG9yLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMjYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci0KLS8qKgotICogQSA8Y29kZT5Db21wb3NpdGVJdGVyYXRvcjwvY29kZT4gd3JhcHMgYSBjb2xsZWN0aW9uCi0gKiBvZiA8Y29kZT5JdGVyYXRvcjwvY29kZT5zIGFuZCBtYWtlcyB0aGVtIGFwcGVhciB0byBiZSBhIHNpbmdsZQotICogPGNvZGU+SXRlcmF0b3I8L2NvZGU+LgotICovCi1wdWJsaWMgY2xhc3MgQ29tcG9zaXRlSXRlcmF0b3I8RT4KLQlpbXBsZW1lbnRzIEl0ZXJhdG9yPEU+Ci17Ci0JcHJpdmF0ZSBmaW5hbCBJdGVyYXRvcjw/IGV4dGVuZHMgSXRlcmF0b3I8PyBleHRlbmRzIEU+PiBpdGVyYXRvcnM7Ci0JcHJpdmF0ZSBJdGVyYXRvcjw/IGV4dGVuZHMgRT4gY3VycmVudEl0ZXJhdG9yOwotCXByaXZhdGUgSXRlcmF0b3I8PyBleHRlbmRzIEU+IGxhc3RJdGVyYXRvclRvUmV0dXJuTmV4dDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGl0ZXJhdG9yIHdpdGggdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uIG9mIGl0ZXJhdG9ycy4KLQkgKi8KLQlwdWJsaWMgQ29tcG9zaXRlSXRlcmF0b3IoQ29sbGVjdGlvbjw/IGV4dGVuZHMgSXRlcmF0b3I8PyBleHRlbmRzIEU+PiBpdGVyYXRvcnMpIHsKLQkJdGhpcyhpdGVyYXRvcnMuaXRlcmF0b3IoKSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGl0ZXJhdG9yIHdpdGggdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uIG9mIGl0ZXJhdG9ycy4KLQkgKi8KLQlwdWJsaWMgQ29tcG9zaXRlSXRlcmF0b3IoSXRlcmF0b3I8PyBleHRlbmRzIEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPj4gaXRlcmF0b3JzKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuaXRlcmF0b3JzID0gaXRlcmF0b3JzOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBpdGVyYXRvciB3aXRoIHRoZSBzcGVjaWZpZWQgb2JqZWN0IHByZXBlbmRlZAotCSAqIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICovCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHVibGljIENvbXBvc2l0ZUl0ZXJhdG9yKEUgb2JqZWN0LCBJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IpIHsKLQkJdGhpcyhuZXcgU2luZ2xlRWxlbWVudEl0ZXJhdG9yPEU+KG9iamVjdCksIGl0ZXJhdG9yKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gaXRlcmF0b3Igd2l0aCB0aGUgc3BlY2lmaWVkIG9iamVjdCBhcHBlbmRlZAotCSAqIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICovCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHVibGljIENvbXBvc2l0ZUl0ZXJhdG9yKEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVyYXRvciwgRSBvYmplY3QpIHsKLQkJdGhpcyhpdGVyYXRvciwgbmV3IFNpbmdsZUVsZW1lbnRJdGVyYXRvcjxFPihvYmplY3QpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gaXRlcmF0b3Igd2l0aCB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9ycy4KLQkgKi8KLQlwdWJsaWMgQ29tcG9zaXRlSXRlcmF0b3IoSXRlcmF0b3I8PyBleHRlbmRzIEU+Li4uIGl0ZXJhdG9ycykgewotCQl0aGlzKG5ldyBBcnJheUl0ZXJhdG9yPEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPj4oaXRlcmF0b3JzKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIEl0ZXJhdG9yIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBib29sZWFuIGhhc05leHQoKSB7Ci0JCXRyeSB7Ci0JCQl0aGlzLmxvYWRDdXJyZW50SXRlcmF0b3IoKTsKLQkJfSBjYXRjaCAoTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBleCkgewotCQkJLy8gdGhpcyBvY2N1cnMgaWYgdGhlcmUgYXJlIG5vIGl0ZXJhdG9ycyBhdCBhbGwKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlyZXR1cm4gdGhpcy5jdXJyZW50SXRlcmF0b3IuaGFzTmV4dCgpOwotCX0KLQotCXB1YmxpYyBFIG5leHQoKSB7Ci0JCXRoaXMubG9hZEN1cnJlbnRJdGVyYXRvcigpOwotCQlFIHJlc3VsdCA9IHRoaXMuY3VycmVudEl0ZXJhdG9yLm5leHQoKTsKLQotCQkvLyB0aGUgc3RhdGVtZW50IGFib3ZlIHdpbGwgdGhyb3cgYSBOb1N1Y2hFbGVtZW50RXhjZXB0aW9uCi0JCS8vIGlmIHRoZSBjdXJyZW50IGl0ZXJhdG9yIGlzIGF0IHRoZSBlbmQgb2YgdGhlIGxpbmU7Ci0JCS8vIHNvIGlmIHdlIGdldCBoZXJlLCB3ZSBjYW4gc2V0ICdsYXN0SXRlcmF0b3JUb1JldHVybk5leHQnCi0JCXRoaXMubGFzdEl0ZXJhdG9yVG9SZXR1cm5OZXh0ID0gdGhpcy5jdXJyZW50SXRlcmF0b3I7Ci0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwdWJsaWMgdm9pZCByZW1vdmUoKSB7Ci0JCWlmICh0aGlzLmxhc3RJdGVyYXRvclRvUmV0dXJuTmV4dCA9PSBudWxsKSB7Ci0JCQkvLyBDb21wb3NpdGVJdGVyYXRvciNuZXh0KCkgaGFzIG5ldmVyIGJlZW4gY2FsbGVkCi0JCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy5sYXN0SXRlcmF0b3JUb1JldHVybk5leHQucmVtb3ZlKCk7Ci0JfQotCi0JLyoqCi0JICogTG9hZCBjdXJyZW50SXRlcmF0b3Igd2l0aCB0aGUgZmlyc3QgaXRlcmF0b3IgdGhhdCA8Y29kZT5oYXNOZXh0KCk8L2NvZGU+Ci0JICogb3IgdGhlIGZpbmFsIGl0ZXJhdG9yIGlmIGFsbCB0aGUgZWxlbWVudHMgaGF2ZSBhbHJlYWR5IGJlZW4gcmV0cmlldmVkLgotCSAqLwotCXByaXZhdGUgdm9pZCBsb2FkQ3VycmVudEl0ZXJhdG9yKCkgewotCQlpZiAodGhpcy5jdXJyZW50SXRlcmF0b3IgPT0gbnVsbCkgewotCQkJdGhpcy5jdXJyZW50SXRlcmF0b3IgPSB0aGlzLml0ZXJhdG9ycy5uZXh0KCk7Ci0JCX0KLQkJd2hpbGUgKCggISB0aGlzLmN1cnJlbnRJdGVyYXRvci5oYXNOZXh0KCkpICYmIHRoaXMuaXRlcmF0b3JzLmhhc05leHQoKSkgewotCQkJdGhpcy5jdXJyZW50SXRlcmF0b3IgPSB0aGlzLml0ZXJhdG9ycy5uZXh0KCk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogb3ZlcnJpZGVzICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuaXRlcmF0b3JzKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvQ29tcG9zaXRlTGlzdEl0ZXJhdG9yLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0NvbXBvc2l0ZUxpc3RJdGVyYXRvci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjMjAzN2YwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvQ29tcG9zaXRlTGlzdEl0ZXJhdG9yLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxOTQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Ob1N1Y2hFbGVtZW50RXhjZXB0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotCi0vKioKLSAqIEEgPGNvZGU+Q29tcG9zaXRlTGlzdEl0ZXJhdG9yPC9jb2RlPiB3cmFwcyBhIGxpc3QKLSAqIG9mIDxjb2RlPkxpc3RJdGVyYXRvcjwvY29kZT5zIGFuZCBtYWtlcyB0aGVtIGFwcGVhciB0byBiZSBhIHNpbmdsZQotICogPGNvZGU+TGlzdEl0ZXJhdG9yPC9jb2RlPi4KLSAqLwotcHVibGljIGNsYXNzIENvbXBvc2l0ZUxpc3RJdGVyYXRvcjxFPgotCWltcGxlbWVudHMgTGlzdEl0ZXJhdG9yPEU+Ci17Ci0JcHJpdmF0ZSBmaW5hbCBMaXN0SXRlcmF0b3I8PyBleHRlbmRzIExpc3RJdGVyYXRvcjxFPj4gaXRlcmF0b3JzOwotCXByaXZhdGUgTGlzdEl0ZXJhdG9yPEU+IG5leHRJdGVyYXRvcjsKLQlwcml2YXRlIGludCBuZXh0SW5kZXg7Ci0gCS8qKgotIAkgKiB0cnVlIGlmICJuZXh0IiB3YXMgbGFzdCByZXR1cm5lZDsgZmFsc2UgaWYgInByZXZpb3VzIiB3YXMgbGFzdCByZXR1cm5lZDsKLSAJICogdGhpcyBkZXRlcm1pbmVzIHRoZSBlZmZlY3Qgb2YgcmVtb3ZlKE9iamVjdCkgb24gbmV4dEluZGV4Ci0gCSAqLwotCXByaXZhdGUgYm9vbGVhbiBuZXh0UmV0dXJuZWQ7Ci0JcHJpdmF0ZSBMaXN0SXRlcmF0b3I8RT4gbGFzdEl0ZXJhdG9yVG9SZXR1cm5FbGVtZW50OwotCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBsaXN0IGl0ZXJhdG9yIHdpdGggdGhlIHNwZWNpZmllZCBsaXN0IG9mIGxpc3QgaXRlcmF0b3JzLgotCSAqLwotCXB1YmxpYyBDb21wb3NpdGVMaXN0SXRlcmF0b3IoTGlzdDw/IGV4dGVuZHMgTGlzdEl0ZXJhdG9yPEU+PiBpdGVyYXRvcnMpIHsKLQkJdGhpcyhpdGVyYXRvcnMubGlzdEl0ZXJhdG9yKCkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGxpc3QgaXRlcmF0b3Igd2l0aCB0aGUgc3BlY2lmaWVkIGxpc3Qgb2YgbGlzdCBpdGVyYXRvcnMuCi0JICovCi0JcHVibGljIENvbXBvc2l0ZUxpc3RJdGVyYXRvcihMaXN0SXRlcmF0b3I8PyBleHRlbmRzIExpc3RJdGVyYXRvcjxFPj4gaXRlcmF0b3JzKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuaXRlcmF0b3JzID0gaXRlcmF0b3JzOwotCQl0aGlzLm5leHRJbmRleCA9IDA7Ci0JCXRoaXMubmV4dFJldHVybmVkID0gZmFsc2U7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgbGlzdCBpdGVyYXRvciB3aXRoIHRoZSBzcGVjaWZpZWQgb2JqZWN0IHByZXBlbmRlZAotCSAqIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICovCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHVibGljIENvbXBvc2l0ZUxpc3RJdGVyYXRvcihFIG9iamVjdCwgTGlzdEl0ZXJhdG9yPEU+IGl0ZXJhdG9yKSB7Ci0JCXRoaXMobmV3IFNpbmdsZUVsZW1lbnRMaXN0SXRlcmF0b3I8RT4ob2JqZWN0KSwgaXRlcmF0b3IpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGxpc3QgaXRlcmF0b3Igd2l0aCB0aGUgc3BlY2lmaWVkIG9iamVjdCBhcHBlbmRlZAotCSAqIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICovCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHVibGljIENvbXBvc2l0ZUxpc3RJdGVyYXRvcihMaXN0SXRlcmF0b3I8RT4gaXRlcmF0b3IsIEUgb2JqZWN0KSB7Ci0JCXRoaXMoaXRlcmF0b3IsIG5ldyBTaW5nbGVFbGVtZW50TGlzdEl0ZXJhdG9yPEU+KG9iamVjdCkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGxpc3QgaXRlcmF0b3Igd2l0aCB0aGUgc3BlY2lmaWVkIGxpc3QgaXRlcmF0b3JzLgotCSAqLwotCXB1YmxpYyBDb21wb3NpdGVMaXN0SXRlcmF0b3IoTGlzdEl0ZXJhdG9yPEU+Li4uIGl0ZXJhdG9ycykgewotCQl0aGlzKG5ldyBBcnJheUxpc3RJdGVyYXRvcjxMaXN0SXRlcmF0b3I8RT4+KGl0ZXJhdG9ycykpOwotCX0KLQotCXB1YmxpYyB2b2lkIGFkZChFIG8pIHsKLQkJdGhpcy5jaGVja05leHRJdGVyYXRvcigpOwotCQl0aGlzLm5leHRJdGVyYXRvci5hZGQobyk7Ci0JCXRoaXMubmV4dEluZGV4Kys7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaGFzTmV4dCgpIHsKLQkJdHJ5IHsKLQkJCXRoaXMubG9hZE5leHRJdGVyYXRvcigpOwotCQl9IGNhdGNoIChOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQkvLyB0aGlzIG9jY3VycyBpZiB0aGVyZSBhcmUgbm8gaXRlcmF0b3JzIGF0IGFsbAotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCXJldHVybiB0aGlzLm5leHRJdGVyYXRvci5oYXNOZXh0KCk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaGFzUHJldmlvdXMoKSB7Ci0JCXRyeSB7Ci0JCQl0aGlzLmxvYWRQcmV2aW91c0l0ZXJhdG9yKCk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCS8vIHRoaXMgb2NjdXJzIGlmIHRoZXJlIGFyZSBubyBpdGVyYXRvcnMgYXQgYWxsCi0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJcmV0dXJuIHRoaXMubmV4dEl0ZXJhdG9yLmhhc1ByZXZpb3VzKCk7Ci0JfQotCi0JcHVibGljIEUgbmV4dCgpIHsKLQkJdGhpcy5sb2FkTmV4dEl0ZXJhdG9yKCk7Ci0JCUUgcmVzdWx0ID0gdGhpcy5uZXh0SXRlcmF0b3IubmV4dCgpOwotCi0JCS8vIHRoZSBzdGF0ZW1lbnQgYWJvdmUgd2lsbCB0aHJvdyBhIE5vU3VjaEVsZW1lbnRFeGNlcHRpb24KLQkJLy8gaWYgdGhlIGN1cnJlbnQgaXRlcmF0b3IgaXMgYXQgdGhlIGVuZCBvZiB0aGUgbGluZTsKLQkJLy8gc28gaWYgd2UgZ2V0IGhlcmUsIHdlIGNhbiBzZXQgdGhlICdsYXN0SXRlcmF0b3JUb1JldHVybkVsZW1lbnQnCi0JCXRoaXMubGFzdEl0ZXJhdG9yVG9SZXR1cm5FbGVtZW50ID0gdGhpcy5uZXh0SXRlcmF0b3I7Ci0JCXRoaXMubmV4dEluZGV4Kys7Ci0JCXRoaXMubmV4dFJldHVybmVkID0gdHJ1ZTsKLQotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCXB1YmxpYyBpbnQgbmV4dEluZGV4KCkgewotCQlyZXR1cm4gdGhpcy5uZXh0SW5kZXg7Ci0JfQotCi0JcHVibGljIEUgcHJldmlvdXMoKSB7Ci0JCXRoaXMubG9hZFByZXZpb3VzSXRlcmF0b3IoKTsKLQkJRSByZXN1bHQgPSB0aGlzLm5leHRJdGVyYXRvci5wcmV2aW91cygpOwotCi0JCS8vIHRoZSBzdGF0ZW1lbnQgYWJvdmUgd2lsbCB0aHJvdyBhIE5vU3VjaEVsZW1lbnRFeGNlcHRpb24KLQkJLy8gaWYgdGhlIGN1cnJlbnQgaXRlcmF0b3IgaXMgYXQgdGhlIGVuZCBvZiB0aGUgbGluZTsKLQkJLy8gc28gaWYgd2UgZ2V0IGhlcmUsIHdlIGNhbiBzZXQgdGhlICdsYXN0SXRlcmF0b3JUb1JldHVybkVsZW1lbnQnCi0JCXRoaXMubGFzdEl0ZXJhdG9yVG9SZXR1cm5FbGVtZW50ID0gdGhpcy5uZXh0SXRlcmF0b3I7Ci0JCXRoaXMubmV4dEluZGV4LS07Ci0JCXRoaXMubmV4dFJldHVybmVkID0gZmFsc2U7Ci0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwdWJsaWMgaW50IHByZXZpb3VzSW5kZXgoKSB7Ci0JCXJldHVybiB0aGlzLm5leHRJbmRleCAgLSAxOwotCX0KLQotCXB1YmxpYyB2b2lkIHJlbW92ZSgpIHsKLQkJaWYgKHRoaXMubGFzdEl0ZXJhdG9yVG9SZXR1cm5FbGVtZW50ID09IG51bGwpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLmxhc3RJdGVyYXRvclRvUmV0dXJuRWxlbWVudC5yZW1vdmUoKTsKLQkJaWYgKHRoaXMubmV4dFJldHVybmVkKSB7Ci0JCQkvLyBkZWNyZW1lbnQgdGhlIGluZGV4IGJlY2F1c2UgdGhlICJuZXh0IiBlbGVtZW50IGhhcyBtb3ZlZCBmb3J3YXJkIGluIHRoZSBsaXN0Ci0JCQl0aGlzLm5leHRJbmRleC0tOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0KEUgZSkgewotCQlpZiAodGhpcy5sYXN0SXRlcmF0b3JUb1JldHVybkVsZW1lbnQgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigpOwotCQl9Ci0JCXRoaXMubGFzdEl0ZXJhdG9yVG9SZXR1cm5FbGVtZW50LnNldChlKTsKLQl9Ci0KLQkvKioKLQkgKiBMb2FkICduZXh0SXRlcmF0b3InIHdpdGggdGhlIGZpcnN0IGl0ZXJhdG9yIHRoYXQgPGNvZGU+aGFzTmV4dCgpPC9jb2RlPgotCSAqIG9yIHRoZSBmaW5hbCBpdGVyYXRvciBpZiBhbGwgdGhlIGVsZW1lbnRzIGhhdmUgYWxyZWFkeSBiZWVuIHJldHJpZXZlZC4KLQkgKi8KLQlwcml2YXRlIHZvaWQgbG9hZE5leHRJdGVyYXRvcigpIHsKLQkJdGhpcy5jaGVja05leHRJdGVyYXRvcigpOwotCQl3aGlsZSAoKCAhIHRoaXMubmV4dEl0ZXJhdG9yLmhhc05leHQoKSkgJiYgdGhpcy5pdGVyYXRvcnMuaGFzTmV4dCgpKSB7Ci0JCQl0aGlzLm5leHRJdGVyYXRvciA9IHRoaXMuaXRlcmF0b3JzLm5leHQoKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIExvYWQgJ25leHRJdGVyYXRvcicgd2l0aCB0aGUgZmlyc3QgaXRlcmF0b3IgdGhhdCA8Y29kZT5oYXNQcmV2aW91cygpPC9jb2RlPgotCSAqIG9yIHRoZSBmaXJzdCBpdGVyYXRvciBpZiBhbGwgdGhlIGVsZW1lbnRzIGhhdmUgYWxyZWFkeSBiZWVuIHJldHJpZXZlZC4KLQkgKi8KLQlwcml2YXRlIHZvaWQgbG9hZFByZXZpb3VzSXRlcmF0b3IoKSB7Ci0JCXRoaXMuY2hlY2tOZXh0SXRlcmF0b3IoKTsKLQkJd2hpbGUgKCggISB0aGlzLm5leHRJdGVyYXRvci5oYXNQcmV2aW91cygpKSAmJiB0aGlzLml0ZXJhdG9ycy5oYXNQcmV2aW91cygpKSB7Ci0JCQl0aGlzLm5leHRJdGVyYXRvciA9IHRoaXMuaXRlcmF0b3JzLnByZXZpb3VzKCk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBJZiAnbmV4dEl0ZXJhdG9yJyBpcyBudWxsLCBsb2FkIGl0IHdpdGggdGhlIGZpcnN0IGl0ZXJhdG9yLgotCSAqLwotCXByaXZhdGUgdm9pZCBjaGVja05leHRJdGVyYXRvcigpIHsKLQkJaWYgKHRoaXMubmV4dEl0ZXJhdG9yID09IG51bGwpIHsKLQkJCXRoaXMubmV4dEl0ZXJhdG9yID0gdGhpcy5pdGVyYXRvcnMubmV4dCgpOwotCQl9Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5pdGVyYXRvcnMpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9FbXB0eUVudW1lcmF0aW9uLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0VtcHR5RW51bWVyYXRpb24uamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMWU3NzIxYS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0VtcHR5RW51bWVyYXRpb24uamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkVudW1lcmF0aW9uOwotaW1wb3J0IGphdmEudXRpbC5Ob1N1Y2hFbGVtZW50RXhjZXB0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotCi0vKioKLSAqIEEgPGNvZGU+TnVsbEVudW1lcmF0aW9uPC9jb2RlPiBpcyBqdXN0IHRoYXQuCi0gKi8KLXB1YmxpYyBmaW5hbCBjbGFzcyBFbXB0eUVudW1lcmF0aW9uPEU+Ci0JaW1wbGVtZW50cyBFbnVtZXJhdGlvbjxFPgotewotCi0JLy8gc2luZ2xldG9uCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgRW1wdHlFbnVtZXJhdGlvbiBJTlNUQU5DRSA9IG5ldyBFbXB0eUVudW1lcmF0aW9uKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwdWJsaWMgc3RhdGljIDxUPiBFbnVtZXJhdGlvbjxUPiBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBFbXB0eUVudW1lcmF0aW9uKCkgewotCQlzdXBlcigpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGhhc01vcmVFbGVtZW50cygpIHsKLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCXB1YmxpYyBFIG5leHRFbGVtZW50KCkgewotCQl0aHJvdyBuZXcgTm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9FbXB0eUl0ZXJhdG9yLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0VtcHR5SXRlcmF0b3IuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYWFjYWMzMy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0VtcHR5SXRlcmF0b3IuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Ob1N1Y2hFbGVtZW50RXhjZXB0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotCi0vKioKLSAqIEFuIDxjb2RlPkVtcHR5SXRlcmF0b3I8L2NvZGU+IGlzIGp1c3QgdGhhdC4KLSAqLwotcHVibGljIGZpbmFsIGNsYXNzIEVtcHR5SXRlcmF0b3I8RT4KLQlpbXBsZW1lbnRzIEl0ZXJhdG9yPEU+Ci17Ci0KLQkvLyBzaW5nbGV0b24KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBFbXB0eUl0ZXJhdG9yIElOU1RBTkNFID0gbmV3IEVtcHR5SXRlcmF0b3IoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXB1YmxpYyBzdGF0aWMgPFQ+IEl0ZXJhdG9yPFQ+IGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEVtcHR5SXRlcmF0b3IoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaGFzTmV4dCgpIHsKLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCXB1YmxpYyBFIG5leHQoKSB7Ci0JCXRocm93IG5ldyBOb1N1Y2hFbGVtZW50RXhjZXB0aW9uKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuYnVpbGRUb1N0cmluZ0Zvcih0aGlzKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvRW1wdHlMaXN0SXRlcmF0b3IuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvRW1wdHlMaXN0SXRlcmF0b3IuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjNhYjRhNC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0VtcHR5TGlzdEl0ZXJhdG9yLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw4MyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9yczsKLQotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci0KLS8qKgotICogQW4gPGNvZGU+RW1wdHlMaXN0SXRlcmF0b3I8L2NvZGU+IGlzIGp1c3QgdGhhdC4KLSAqLwotcHVibGljIGZpbmFsIGNsYXNzIEVtcHR5TGlzdEl0ZXJhdG9yPEU+Ci0JaW1wbGVtZW50cyBMaXN0SXRlcmF0b3I8RT4KLXsKLQotCS8vIHNpbmdsZXRvbgotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByaXZhdGUgc3RhdGljIGZpbmFsIEVtcHR5TGlzdEl0ZXJhdG9yIElOU1RBTkNFID0gbmV3IEVtcHR5TGlzdEl0ZXJhdG9yKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwdWJsaWMgc3RhdGljIDxUPiBMaXN0SXRlcmF0b3I8VD4gaW5zdGFuY2UoKSB7Ci0JCXJldHVybiBJTlNUQU5DRTsKLQl9Ci0KLQkvKioKLQkgKiBFbnN1cmUgc2luZ2xlIGluc3RhbmNlLgotCSAqLwotCXByaXZhdGUgRW1wdHlMaXN0SXRlcmF0b3IoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQotCXB1YmxpYyB2b2lkIGFkZChFIGUpIHsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaGFzTmV4dCgpIHsKLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGhhc1ByZXZpb3VzKCkgewotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JcHVibGljIEUgbmV4dCgpIHsKLQkJdGhyb3cgbmV3IE5vU3VjaEVsZW1lbnRFeGNlcHRpb24oKTsKLQl9Ci0KLQlwdWJsaWMgaW50IG5leHRJbmRleCgpIHsKLQkJcmV0dXJuIDA7Ci0JfQotCi0JcHVibGljIEUgcHJldmlvdXMoKSB7Ci0JCXRocm93IG5ldyBOb1N1Y2hFbGVtZW50RXhjZXB0aW9uKCk7Ci0JfQotCi0JcHVibGljIGludCBwcmV2aW91c0luZGV4KCkgewotCQlyZXR1cm4gLTE7Ci0JfQotCi0JcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBzZXQoRSBlKSB7Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMpOwotCX0KLQkKLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvRW51bWVyYXRpb25JdGVyYXRvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9FbnVtZXJhdGlvbkl0ZXJhdG9yLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGE3NTcxMGMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9FbnVtZXJhdGlvbkl0ZXJhdG9yLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9yczsKLQotaW1wb3J0IGphdmEudXRpbC5FbnVtZXJhdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci0KLS8qKgotICogQW4gPGNvZGU+RW51bWVyYXRpb25JdGVyYXRvcjwvY29kZT4gd3JhcHMgYW4KLSAqIDxjb2RlPkVudW1lcmF0aW9uPC9jb2RlPiBzbyB0aGF0IGl0IGNhbiBiZSB0cmVhdGVkIGxpa2UgYW4KLSAqIDxjb2RlPkl0ZXJhdG9yPC9jb2RlPi4KLSAqLwotcHVibGljIGNsYXNzIEVudW1lcmF0aW9uSXRlcmF0b3I8RT4KLQlpbXBsZW1lbnRzIEl0ZXJhdG9yPEU+Ci17Ci0JcHJpdmF0ZSBmaW5hbCBFbnVtZXJhdGlvbjw/IGV4dGVuZHMgRT4gZW51bWVyYXRpb247Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gaXRlcmF0b3IgdGhhdCB3cmFwcyB0aGUgc3BlY2lmaWVkIGVudW1lcmF0aW9uLgotCSAqLwotCXB1YmxpYyBFbnVtZXJhdGlvbkl0ZXJhdG9yKEVudW1lcmF0aW9uPD8gZXh0ZW5kcyBFPiBlbnVtZXJhdGlvbikgewotCQl0aGlzLmVudW1lcmF0aW9uID0gZW51bWVyYXRpb247Ci0JfQotCQotCXB1YmxpYyBib29sZWFuIGhhc05leHQoKSB7Ci0JCXJldHVybiB0aGlzLmVudW1lcmF0aW9uLmhhc01vcmVFbGVtZW50cygpOwotCX0KLQkKLQlwdWJsaWMgRSBuZXh0KCkgewotCQlyZXR1cm4gdGhpcy5lbnVtZXJhdGlvbi5uZXh0RWxlbWVudCgpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCByZW1vdmUoKSB7Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuYnVpbGRUb1N0cmluZ0Zvcih0aGlzLCB0aGlzLmVudW1lcmF0aW9uKTsKLQl9Ci0JCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0ZpbHRlcmluZ0l0ZXJhdG9yLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0ZpbHRlcmluZ0l0ZXJhdG9yLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZhMjJjNjUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9GaWx0ZXJpbmdJdGVyYXRvci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTM0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Ob1N1Y2hFbGVtZW50RXhjZXB0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LkZpbHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotLyoqCi0gKiBBIDxjb2RlPkZpbHRlcmluZ0l0ZXJhdG9yPC9jb2RlPiB3cmFwcyBhbm90aGVyIDxjb2RlPkl0ZXJhdG9yPC9jb2RlPgotICogYW5kIHVzZXMgYSA8Y29kZT5GaWx0ZXI8L2NvZGU+IHRvIGRldGVybWluZSB3aGljaCBlbGVtZW50cyBpbiB0aGUKLSAqIG5lc3RlZCBpdGVyYXRvciBhcmUgdG8gYmUgcmV0dXJuZWQgYnkgY2FsbHMgdG8gPGNvZGU+bmV4dCgpPC9jb2RlPi4KLSAqIDxwPgotICogQXMgYW4gYWx0ZXJuYXRpdmUgdG8gYnVpbGRpbmcgYSA8Y29kZT5GaWx0ZXI8L2NvZGU+LCBhIHN1YmNsYXNzCi0gKiBvZiA8Y29kZT5GaWx0ZXJpbmdJdGVyYXRvcjwvY29kZT4gY2FuIG92ZXJyaWRlIHRoZQotICogPGNvZGU+YWNjZXB0KE9iamVjdCk8L2NvZGU+IG1ldGhvZC4KLSAqIDxwPgotICogT25lLCBwb3NzaWJseSB1bmRlc2lyYWJsZSwgc2lkZS1lZmZlY3Qgb2YgdXNpbmcgdGhpcyBpdGVyYXRvciBpcyB0aGF0Ci0gKiB0aGUgbmVzdGVkIGl0ZXJhdG9yJ3MgPGNvZGU+bmV4dCgpPC9jb2RlPiBtZXRob2Qgd2lsbCBiZSBpbnZva2VkCi0gKiA8ZW0+YmVmb3JlPC9lbT4gdGhlIGZpbHRlcmVkIGl0ZXJhdG9yJ3MgPGNvZGU+bmV4dCgpPC9jb2RlPgotICogbWV0aG9kIGlzIGludm9rZWQuIFRoaXMgaXMgYmVjYXVzZSB0aGUgIm5leHQiIGVsZW1lbnQgbXVzdCBiZQotICogY2hlY2tlZCBmb3Igd2hldGhlciBpdCBpcyB0byBiZSBhY2NlcHRlZCBiZWZvcmUgdGhlIGZpbHRlcmVkIGl0ZXJhdG9yCi0gKiBjYW4gZGV0ZXJtaW5lIHdoZXRoZXIgaXQgaGFzIGEgIm5leHQiIGVsZW1lbnQgKGkuZS4gdGhhdCB0aGUKLSAqIDxjb2RlPmhhc05leHQoKTwvY29kZT4gbWV0aG9kIHNob3VsZCByZXR1cm4gPGNvZGU+dHJ1ZTwvY29kZT4pLgotICogVGhpcyBhbHNvIHByZXZlbnRzIGEgZmlsdGVyZWQgaXRlcmF0b3IgZnJvbSBzdXBwb3J0aW5nIHRoZSBvcHRpb25hbAotICogPGNvZGU+cmVtb3ZlKCk8L2NvZGU+IG1ldGhvZC4KLSAqLwotcHVibGljIGNsYXNzIEZpbHRlcmluZ0l0ZXJhdG9yPEUxLCBFMj4KLQlpbXBsZW1lbnRzIEl0ZXJhdG9yPEUyPgotewotCXByaXZhdGUgZmluYWwgSXRlcmF0b3I8PyBleHRlbmRzIEUxPiBuZXN0ZWRJdGVyYXRvcjsKLQlwcml2YXRlIGZpbmFsIEZpbHRlcjxFMT4gZmlsdGVyOwotCXByaXZhdGUgRTIgbmV4dDsKLQlwcml2YXRlIGJvb2xlYW4gZG9uZTsKLQotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGl0ZXJhdG9yIHdpdGggdGhlIHNwZWNpZmllZCBuZXN0ZWQKLQkgKiBpdGVyYXRvciBhbmQgYSBkaXNhYmxlZCBmaWx0ZXIuCi0JICogVXNlIHRoaXMgY29uc3RydWN0b3IgaWYgeW91IHdhbnQgdG8gb3ZlcnJpZGUgdGhlCi0JICogPGNvZGU+YWNjZXB0KE9iamVjdCk8L2NvZGU+IG1ldGhvZCBpbnN0ZWFkIG9mIGJ1aWxkaW5nCi0JICogYSA8Y29kZT5GaWx0ZXI8L2NvZGU+LgotCSAqLwotCXB1YmxpYyBGaWx0ZXJpbmdJdGVyYXRvcihJdGVyYXRvcjw/IGV4dGVuZHMgRTE+IG5lc3RlZEl0ZXJhdG9yKSB7Ci0JCXRoaXMobmVzdGVkSXRlcmF0b3IsIEZpbHRlci5EaXNhYmxlZC48RTE+aW5zdGFuY2UoKSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGl0ZXJhdG9yIHdpdGggdGhlIHNwZWNpZmllZCBuZXN0ZWQKLQkgKiBpdGVyYXRvciBhbmQgZmlsdGVyLgotCSAqLwotCXB1YmxpYyBGaWx0ZXJpbmdJdGVyYXRvcihJdGVyYXRvcjw/IGV4dGVuZHMgRTE+IG5lc3RlZEl0ZXJhdG9yLCBGaWx0ZXI8RTE+IGZpbHRlcikgewotCQlzdXBlcigpOwotCQl0aGlzLm5lc3RlZEl0ZXJhdG9yID0gbmVzdGVkSXRlcmF0b3I7Ci0JCXRoaXMuZmlsdGVyID0gZmlsdGVyOwotCQl0aGlzLmxvYWROZXh0KCk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaGFzTmV4dCgpIHsKLQkJcmV0dXJuICEgdGhpcy5kb25lOwotCX0KLQotCXB1YmxpYyBFMiBuZXh0KCkgewotCQlpZiAodGhpcy5kb25lKSB7Ci0JCQl0aHJvdyBuZXcgTm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpOwotCQl9Ci0JCUUyIHJlc3VsdCA9IHRoaXMubmV4dDsKLQkJdGhpcy5sb2FkTmV4dCgpOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIEJlY2F1c2Ugd2UgbmVlZCB0byBwcmUtbG9hZCB0aGUgbmV4dCBlbGVtZW50Ci0JICogdG8gYmUgcmV0dXJuZWQsIHdlIGNhbm5vdCBzdXBwb3J0IHRoZSA8Y29kZT5yZW1vdmUoKTwvY29kZT4KLQkgKiBtZXRob2QuCi0JICovCi0JcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLQkvKioKLQkgKiBMb2FkIG5leHQgd2l0aCB0aGUgbmV4dCB2YWxpZCBlbnRyeSBmcm9tIHRoZSBuZXN0ZWQKLQkgKiBpdGVyYXRvci4gSWYgdGhlcmUgYXJlIG5vbmUsIG5leHQgaXMgc2V0IHRvIDxjb2RlPkVORDwvY29kZT4uCi0JICovCi0JcHJpdmF0ZSB2b2lkIGxvYWROZXh0KCkgewotCQl0aGlzLmRvbmUgPSB0cnVlOwotCQl3aGlsZSAodGhpcy5uZXN0ZWRJdGVyYXRvci5oYXNOZXh0KCkgJiYgKHRoaXMuZG9uZSkpIHsKLQkJCUUxIHRlbXAgPSB0aGlzLm5lc3RlZEl0ZXJhdG9yLm5leHQoKTsKLQkJCWlmICh0aGlzLmFjY2VwdCh0ZW1wKSkgewotCQkJCS8vIGFzc3VtZSB0aGF0IGlmIHRoZSBvYmplY3Qgd2FzIGFjY2VwdGVkIGl0IGlzIG9mIHR5cGUgRQotCQkJCXRoaXMubmV4dCA9IHRoaXMuY2FzdCh0ZW1wKTsKLQkJCQl0aGlzLmRvbmUgPSBmYWxzZTsKLQkJCX0gZWxzZSB7Ci0JCQkJdGhpcy5uZXh0ID0gbnVsbDsKLQkJCQl0aGlzLmRvbmUgPSB0cnVlOwotCQkJfQotCQl9Ci0JfQotCi0JLyoqCi0JICogV2UgaGF2ZSB0byBhc3N1bWUgdGhlIGZpbHRlciB3aWxsIG9ubHkgImFjY2VwdCIgb2JqZWN0cyB0aGF0IGNhbgotCSAqIGJlIGNhc3QgdG8gRTIuCi0JICovCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJpdmF0ZSBFMiBjYXN0KEUxIG8pIHsKLQkJcmV0dXJuIChFMikgbzsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgPGNvZGU+RmlsdGVyaW5nSXRlcmF0b3I8L2NvZGU+Ci0JICogc2hvdWxkIHJldHVybiB0aGUgc3BlY2lmaWVkIG5leHQgZWxlbWVudCBmcm9tIGEgY2FsbCB0byB0aGUKLQkgKiA8Y29kZT5uZXh0KCk8L2NvZGU+IG1ldGhvZC4KLQkgKiA8cD4KLQkgKiBUaGlzIG1ldGhvZCBjYW4gYmUgb3ZlcnJpZGRlbiBieSBhIHN1YmNsYXNzIGFzIGFuCi0JICogYWx0ZXJuYXRpdmUgdG8gYnVpbGRpbmcgYSA8Y29kZT5GaWx0ZXI8L2NvZGU+LgotCSAqLwotCXByb3RlY3RlZCBib29sZWFuIGFjY2VwdChFMSBvKSB7Ci0JCXJldHVybiB0aGlzLmZpbHRlci5hY2NlcHQobyk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5uZXN0ZWRJdGVyYXRvcik7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0dlbmVyaWNJdGVyYXRvcldyYXBwZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvR2VuZXJpY0l0ZXJhdG9yV3JhcHBlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMWU1ZTBhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvR2VuZXJpY0l0ZXJhdG9yV3JhcHBlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci0KLS8qKgotICogV3JhcCBhbiBpdGVyYXRvciBvbiBlbGVtZW50cyBvZiBhbnkgc3ViLXR5cGUgb2YgRSwgY29udmVydGluZyBpdCBpbnRvIGFuCi0gKiBpdGVyYXRvciBvbiBlbGVtZW50cyBvZiB0eXBlIEUuIFRoaXMgc2hvdWxkbid0IGJlIGEgcHJvYmxlbSBzaW5jZSB0aGVyZQotICogaXMgbm8gd2F5IHRvIGFkZCBlbGVtZW50cyB0byB0aGUgaXRlcmF0b3IuCi0gKi8KLXB1YmxpYyBjbGFzcyBHZW5lcmljSXRlcmF0b3JXcmFwcGVyPEU+Ci0JaW1wbGVtZW50cyBJdGVyYXRvcjxFPgotewotCXByaXZhdGUgZmluYWwgSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yOwotCi0JcHVibGljIEdlbmVyaWNJdGVyYXRvcldyYXBwZXIoSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuaXRlcmF0b3IgPSBpdGVyYXRvcjsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBoYXNOZXh0KCkgewotCQlyZXR1cm4gdGhpcy5pdGVyYXRvci5oYXNOZXh0KCk7Ci0JfQotCi0JcHVibGljIEUgbmV4dCgpIHsKLQkJcmV0dXJuIHRoaXMuaXRlcmF0b3IubmV4dCgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHJlbW92ZSgpIHsKLQkJdGhpcy5pdGVyYXRvci5yZW1vdmUoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuYnVpbGRUb1N0cmluZ0Zvcih0aGlzLCB0aGlzLml0ZXJhdG9yKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvR3JhcGhJdGVyYXRvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9HcmFwaEl0ZXJhdG9yLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGIxOGRmNzMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9HcmFwaEl0ZXJhdG9yLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyNDIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSGFzaFNldDsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpbmtlZExpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci1pbXBvcnQgamF2YS51dGlsLlNldDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotLyoqCi0gKiBBIDxjb2RlPkdyYXBoSXRlcmF0b3I8L2NvZGU+IGlzIHNpbWlsYXIgdG8gYSA8Y29kZT5UcmVlSXRlcmF0b3I8L2NvZGU+Ci0gKiBleGNlcHQgdGhhdCBpdCBjYW5ub3QgYmUgYXNzdW1lZCB0aGF0IGFsbCBub2RlcyBhc3N1bWUgYSBzdHJpY3QgdHJlZQotICogc3RydWN0dXJlLiAgRm9yIGluc3RhbmNlLCBpbiBhIHRyZWUsIGEgbm9kZSBjYW5ub3QgYmUgYSBkZXNjZW5kZW50IG9mCi0gKiBpdHNlbGYsIGJ1dCBhIGdyYXBoIG1heSBoYXZlIGEgY3ljbGljYWwgc3RydWN0dXJlLgotICogCi0gKiBBIDxjb2RlPkdyYXBoSXRlcmF0b3I8L2NvZGU+IHNpbXBsaWZpZXMgdGhlIHRyYXZlcnNhbCBvZiBhCi0gKiBncmFwaCBvZiBvYmplY3RzLCB3aGVyZSB0aGUgb2JqZWN0cycgcHJvdG9jb2wocykgcHJvdmlkZXMKLSAqIGEgbWV0aG9kIGZvciBnZXR0aW5nIHRoZSBuZXh0IGNvbGxlY3Rpb24gb2Ygbm9kZXMgaW4gdGhlIGdyYXBoLAotICogKG9yICpuZWlnaGJvcnMqKSwgYnV0IGRvZXMgbm90IHByb3ZpZGUgYSBtZXRob2QgZm9yIGdldHRpbmcgKmFsbCogCi0gKiBvZiB0aGUgbm9kZXMgaW4gdGhlIGdyYXBoLgotICogKGUuZy4gYSBuZWlnaGJvciBjYW4gcmV0dXJuIGhpcyBuZWlnaGJvcnMsIGFuZCB0aG9zZSBuZWlnaGJvcnMKLSAqIGNhbiByZXR1cm4gdGhlaXIgbmVpZ2hib3JzLCB3aGljaCBtaWdodCBhbHNvIGluY2x1ZGUgdGhlIG9yaWdpbmFsCi0gKiBuZWlnaGJvciwgYnV0IHlvdSBvbmx5IHdhbnQgdG8gdmlzaXQgdGhlIG9yaWdpbmFsIG5laWdoYm9yIG9uY2UuKQotICogPHA+Ci0gKiBJZiBhIG5laWdoYm9yIGhhcyBhbHJlYWR5IGJlZW4gdmlzaXRlZCAoZGV0ZXJtaW5lZCBieSB1c2luZyAKLSAqIDxjb2RlPmVxdWFscyhPYmplY3QpPC9jb2RlPiksIHRoYXQgbmVpZ2hib3IgaXMgbm90IHZpc2l0ZWQgYWdhaW4sCi0gKiBub3IgYXJlIHRoZSBuZWlnaGJvcnMgb2YgdGhhdCBvYmplY3QuCi0gKiA8cD4KLSAqIEl0IGlzIHVwIHRvIHRoZSB1c2VyIG9mIHRoaXMgY2xhc3MgdG8gZW5zdXJlIGEgKmNvbXBsZXRlKiBncmFwaC4KLSAqIDxwPgotICogVG8gdXNlLCBzdXBwbHk6PHVsPgotICogPGxpPiBlaXRoZXIgdGhlIGluaXRpYWwgbm9kZSBvZiB0aGUgZ3JhcGggb3IgYW4gSXRlcmF0b3Igb3ZlciBhbgotICogaW5pdGlhbCBjb2xsZWN0aW9uIG9mIGdyYXBoIG5vZGVzCi0gKiA8bGk+IGEgPGNvZGU+TWlzdGVyUm9nZXJzPC9jb2RlPiB0aGF0IHRlbGxzIHdobyB0aGUgbmVpZ2hib3JzIGFyZQotICogb2YgZWFjaCBub2RlCi0gKiAoYWx0ZXJuYXRpdmVseSwgc3ViY2xhc3MgPGNvZGU+R3JhcGhJdGVyYXRvcjwvY29kZT4KLSAqIGFuZCBvdmVycmlkZSB0aGUgPGNvZGU+bmVpZ2hib3JzKE9iamVjdCk8L2NvZGU+IG1ldGhvZCkKLSAqIDwvdWw+Ci0gKiA8cD4KLSAqIDxjb2RlPnJlbW92ZSgpPC9jb2RlPiBpcyBub3Qgc3VwcG9ydGVkLiAgVGhpcyBtZXRob2QsIGlmIAotICogZGVzaXJlZCwgbXVzdCBiZSBpbXBsZW1lbnRlZCBieSB0aGUgdXNlciBvZiB0aGlzIGNsYXNzLgotICovCi1wdWJsaWMgY2xhc3MgR3JhcGhJdGVyYXRvcjxFPgotCWltcGxlbWVudHMgSXRlcmF0b3I8RT4KLXsKLQlwcml2YXRlIGZpbmFsIENvbGxlY3Rpb248SXRlcmF0b3I8PyBleHRlbmRzIEU+PiBpdGVyYXRvcnM7Ci0JcHJpdmF0ZSBmaW5hbCBTZXQ8RT4gdmlzaXRlZE5laWdoYm9yczsKLQlwcml2YXRlIGZpbmFsIE1pc3RlclJvZ2VyczxFPiBtaXN0ZXJSb2dlcnM7Ci0JCi0JcHJpdmF0ZSBJdGVyYXRvcjw/IGV4dGVuZHMgRT4gY3VycmVudEl0ZXJhdG9yOwotCQotCXByaXZhdGUgRSBuZXh0TmVpZ2hib3I7Ci0JcHJpdmF0ZSBib29sZWFuIGRvbmU7Ci0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBpdGVyYXRvciB3aXRoIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbiBvZiByb290cwotCSAqIGFuZCBhIGRpc2FibGVkIG1pc3RlciByb2dlcnMuCi0JICogVXNlIHRoaXMgY29uc3RydWN0b3IgaWYgeW91IHdhbnQgdG8gb3ZlcnJpZGUgdGhlCi0JICogPGNvZGU+Y2hpbGRyZW4oT2JqZWN0KTwvY29kZT4gbWV0aG9kIGluc3RlYWQgb2YgYnVpbGRpbmcKLQkgKiBhIDxjb2RlPk1pc3RlclJvZ2VyczwvY29kZT4uCi0JICovCi0JcHVibGljIEdyYXBoSXRlcmF0b3IoRS4uLiByb290cykgewotCQl0aGlzKG5ldyBBcnJheUl0ZXJhdG9yPEU+KHJvb3RzKSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGl0ZXJhdG9yIHdpdGggdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uIG9mIHJvb3RzCi0JICogYW5kIGEgZGlzYWJsZWQgbWlzdGVyIHJvZ2Vycy4KLQkgKiBVc2UgdGhpcyBjb25zdHJ1Y3RvciBpZiB5b3Ugd2FudCB0byBvdmVycmlkZSB0aGUKLQkgKiA8Y29kZT5jaGlsZHJlbihPYmplY3QpPC9jb2RlPiBtZXRob2QgaW5zdGVhZCBvZiBidWlsZGluZwotCSAqIGEgPGNvZGU+TWlzdGVyUm9nZXJzPC9jb2RlPi4KLQkgKi8KLQlwdWJsaWMgR3JhcGhJdGVyYXRvcihJdGVyYXRvcjw/IGV4dGVuZHMgRT4gcm9vdHMpIHsKLQkJdGhpcyhyb290cywgTWlzdGVyUm9nZXJzLkRpc2FibGVkLjxFPmluc3RhbmNlKCkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBpdGVyYXRvciB3aXRoIHRoZSBzcGVjaWZpZWQgcm9vdAotCSAqIGFuZCBhIGRpc2FibGVkIG1pc3RlciByb2dlcnMuCi0JICogVXNlIHRoaXMgY29uc3RydWN0b3IgaWYgeW91IHdhbnQgdG8gb3ZlcnJpZGUgdGhlCi0JICogPGNvZGU+Y2hpbGRyZW4oT2JqZWN0KTwvY29kZT4gbWV0aG9kIGluc3RlYWQgb2YgYnVpbGRpbmcKLQkgKiBhIDxjb2RlPk1pc3RlclJvZ2VyczwvY29kZT4uCi0JICovCi0JcHVibGljIEdyYXBoSXRlcmF0b3IoRSByb290KSB7Ci0JCXRoaXMocm9vdCwgTWlzdGVyUm9nZXJzLkRpc2FibGVkLjxFPmluc3RhbmNlKCkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBpdGVyYXRvciB3aXRoIHRoZSBzcGVjaWZpZWQgcm9vdAotCSAqIGFuZCBtaXN0ZXIgcm9nZXJzLgotCSAqLwotCXB1YmxpYyBHcmFwaEl0ZXJhdG9yKEUgcm9vdCwgTWlzdGVyUm9nZXJzPEU+IG1pc3RlclJvZ2VycykgewotCQl0aGlzKG5ldyBTaW5nbGVFbGVtZW50SXRlcmF0b3I8RT4ocm9vdCksIG1pc3RlclJvZ2Vycyk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGl0ZXJhdG9yIHdpdGggdGhlIHNwZWNpZmllZCByb290cwotCSAqIGFuZCBtaXN0ZXIgcm9nZXJzLgotCSAqLwotCXB1YmxpYyBHcmFwaEl0ZXJhdG9yKEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiByb290cywgTWlzdGVyUm9nZXJzPEU+IG1pc3RlclJvZ2VycykgewotCQlzdXBlcigpOwotCQl0aGlzLmN1cnJlbnRJdGVyYXRvciA9IHJvb3RzOwotCQkvLyB1c2UgYSBMaW5rZWRMaXN0IHNpbmNlIHdlIHdpbGwgYmUgcHVsbGluZyBvZmYgdGhlIGZyb250IGFuZCBhZGRpbmcgdG8gdGhlIGVuZAotCQl0aGlzLml0ZXJhdG9ycyA9IG5ldyBMaW5rZWRMaXN0PEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPj4oKTsKLQkJdGhpcy5taXN0ZXJSb2dlcnMgPSBtaXN0ZXJSb2dlcnM7Ci0JCXRoaXMudmlzaXRlZE5laWdoYm9ycyA9IG5ldyBIYXNoU2V0PEU+KCk7Ci0JCXRoaXMubG9hZE5leHROZWlnaGJvcigpOwotCX0KLQotCS8qKgotCSAqIExvYWQgbmV4dCBuZWlnaGJvciB3aXRoIHRoZSBuZXh0IGVudHJ5IGZyb20gdGhlIGN1cnJlbnQgaXRlcmF0b3IuCi0JICogSWYgdGhlIGN1cnJlbnQgaXRlcmF0b3IgaGFzIG5vbmUsIGxvYWQgdGhlIG5leHQgaXRlcmF0b3IuCi0JICogSWYgdGhlcmUgYXJlIG5vIG1vcmUsIHRoZSAnZG9uZScgZmxhZyBpcyBzZXQuCi0JICovCi0JcHJpdmF0ZSB2b2lkIGxvYWROZXh0TmVpZ2hib3IoKSB7Ci0JCWlmICh0aGlzLmN1cnJlbnRJdGVyYXRvciA9PSBFbXB0eUl0ZXJhdG9yLmluc3RhbmNlKCkpIHsKLQkJCXRoaXMuZG9uZSA9IHRydWU7Ci0JCX0KLQkJZWxzZSBpZiAodGhpcy5jdXJyZW50SXRlcmF0b3IuaGFzTmV4dCgpKSB7Ci0JCQlFIG5leHRQb3NzaWJsZU5laWdoYm9yID0gdGhpcy5jdXJyZW50SXRlcmF0b3IubmV4dCgpOwotCQkJaWYgKHRoaXMudmlzaXRlZE5laWdoYm9ycy5jb250YWlucyhuZXh0UG9zc2libGVOZWlnaGJvcikpIHsKLQkJCQl0aGlzLmxvYWROZXh0TmVpZ2hib3IoKTsgIC8vIHJlY3Vyc2UKLQkJCX0gZWxzZSB7Ci0JCQkJdGhpcy5uZXh0TmVpZ2hib3IgPSBuZXh0UG9zc2libGVOZWlnaGJvcjsKLQkJCQl0aGlzLnZpc2l0ZWROZWlnaGJvcnMuYWRkKG5leHRQb3NzaWJsZU5laWdoYm9yKTsKLQkJCQl0aGlzLml0ZXJhdG9ycy5hZGQodGhpcy5uZWlnaGJvcnMobmV4dFBvc3NpYmxlTmVpZ2hib3IpKTsKLQkJCX0KLQkJfSAKLQkJZWxzZSB7Ci0JCQlmb3IgKEl0ZXJhdG9yPD8gZXh0ZW5kcyBJdGVyYXRvcjw/IGV4dGVuZHMgRT4+IHN0cmVhbSA9IHRoaXMuaXRlcmF0b3JzLml0ZXJhdG9yKCk7ICEgdGhpcy5jdXJyZW50SXRlcmF0b3IuaGFzTmV4dCgpICYmIHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJCXRoaXMuY3VycmVudEl0ZXJhdG9yID0gc3RyZWFtLm5leHQoKTsKLQkJCQlzdHJlYW0ucmVtb3ZlKCk7Ci0JCQl9Ci0JCQlpZiAoICEgdGhpcy5jdXJyZW50SXRlcmF0b3IuaGFzTmV4dCgpKSB7Ci0JCQkJdGhpcy5jdXJyZW50SXRlcmF0b3IgPSBFbXB0eUl0ZXJhdG9yLmluc3RhbmNlKCk7Ci0JCQl9Ci0JCQl0aGlzLmxvYWROZXh0TmVpZ2hib3IoKTsgIC8vIHJlY3Vyc2UKLQkJfQotCX0KLQotCXB1YmxpYyBib29sZWFuIGhhc05leHQoKSB7Ci0JCXJldHVybiAhIHRoaXMuZG9uZTsKLQl9Ci0KLQlwdWJsaWMgRSBuZXh0KCkgewotCQlpZiAodGhpcy5kb25lKSB7Ci0JCQl0aHJvdyBuZXcgTm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpOwotCQl9Ci0JCUUgbmV4dCA9IHRoaXMubmV4dE5laWdoYm9yOwotCQl0aGlzLmxvYWROZXh0TmVpZ2hib3IoKTsKLQkJcmV0dXJuIG5leHQ7Ci0JfQotCi0JcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGltbWVkaWF0ZSBuZWlnaGJvcnMgb2YgdGhlIHNwZWNpZmllZCBvYmplY3QuCi0JICovCi0JcHJvdGVjdGVkIEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBuZWlnaGJvcnMoRSBuZXh0KSB7Ci0JCXJldHVybiB0aGlzLm1pc3RlclJvZ2Vycy5uZWlnaGJvcnMobmV4dCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5jdXJyZW50SXRlcmF0b3IpOwotCX0KLQkKLQkKLQkvLyoqKioqKioqKiogaW5uZXIgY2xhc3NlcyAqKioqKioqKioqCi0JCi0JLyoqCi0JICogVXNlZCBieSA8Y29kZT5HcmFwaEl0ZXJhdG9yPC9jb2RlPiB0byByZXRyaWV2ZQotCSAqIHRoZSBpbW1lZGlhdGUgbmVpZ2hib3JzIG9mIGEgbm9kZSBpbiB0aGUgZ3JhcGguCi0JICogIlRoZXNlIGFyZSB0aGUgcGVvcGxlIGluIHlvdXIgbmVpZ2hib3Job29kLi4uIgotCSAqLwotCXB1YmxpYyBpbnRlcmZhY2UgTWlzdGVyUm9nZXJzPFQ+IHsKLQotCQkvKioKLQkJICogUmV0dXJuIHRoZSBpbW1lZGlhdGUgbmVpZ2hib3JzIG9mIHRoZSBzcGVjaWZpZWQgb2JqZWN0LgotCQkgKi8KLQkJSXRlcmF0b3I8PyBleHRlbmRzIFQ+IG5laWdoYm9ycyhUIG5leHQpOwotCQkKLQkJCi0JCWZpbmFsIGNsYXNzIE51bGw8Uz4gaW1wbGVtZW50cyBNaXN0ZXJSb2dlcnM8Uz4gewotCQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIE1pc3RlclJvZ2VycyBJTlNUQU5DRSA9IG5ldyBOdWxsKCk7Ci0JCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJCXB1YmxpYyBzdGF0aWMgPFI+IE1pc3RlclJvZ2VyczxSPiBpbnN0YW5jZSgpIHsKLQkJCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCQl9Ci0JCQkvLyBlbnN1cmUgc2luZ2xlIGluc3RhbmNlCi0JCQlwcml2YXRlIE51bGwoKSB7Ci0JCQkJc3VwZXIoKTsKLQkJCX0KLQkJCS8vIHJldHVybiBubyBuZWlnaGJvcnMKLQkJCXB1YmxpYyBJdGVyYXRvcjxTPiBuZWlnaGJvcnMoUyBuZXh0KSB7Ci0JCQkJcmV0dXJuIEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gIkdyYXBoSXRlcmF0b3IuTWlzdGVyUm9nZXJzLk51bGwiOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCX0KLQotCQkvKiogVGhlIG1pc3RlciByb2dlcnMgdXNlZCB3aGVuIHRoZSAjbmVpZ2hib3JzKE9iamVjdCkgbWV0aG9kIGlzIG92ZXJyaWRkZW4uICovCi0JCWZpbmFsIGNsYXNzIERpc2FibGVkPFM+IGltcGxlbWVudHMgTWlzdGVyUm9nZXJzPFM+IHsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBNaXN0ZXJSb2dlcnMgSU5TVEFOQ0UgPSBuZXcgRGlzYWJsZWQoKTsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHVibGljIHN0YXRpYyA8Uj4gTWlzdGVyUm9nZXJzPFI+IGluc3RhbmNlKCkgewotCQkJCXJldHVybiBJTlNUQU5DRTsKLQkJCX0KLQkJCS8vIGVuc3VyZSBzaW5nbGUgaW5zdGFuY2UKLQkJCXByaXZhdGUgRGlzYWJsZWQoKSB7Ci0JCQkJc3VwZXIoKTsKLQkJCX0KLQkJCS8vIHRocm93IGFuIGV4Y2VwdGlvbgotCQkJcHVibGljIEl0ZXJhdG9yPFM+IG5laWdoYm9ycyhTIG5leHQpIHsKLQkJCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsgIC8vIEdyYXBoSXRlcmF0b3IubmVpZ2hib3JzKE9iamVjdCkgd2FzIG5vdCBpbXBsZW1lbnRlZAotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiR3JhcGhJdGVyYXRvci5NaXN0ZXJSb2dlcnMuRGlzYWJsZWQiOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCX0KLQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9JdGVyYXRvckVudW1lcmF0aW9uLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0l0ZXJhdG9yRW51bWVyYXRpb24uamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNTVhNGYwOC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL0l0ZXJhdG9yRW51bWVyYXRpb24uamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQ3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkVudW1lcmF0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotLyoqCi0gKiBBbiA8Y29kZT5JdGVyYXRvckVudW1lcmF0aW9uPC9jb2RlPiB3cmFwcyBhbgotICogPGNvZGU+SXRlcmF0b3I8L2NvZGU+IHNvIHRoYXQgaXQgY2FuIGJlIHRyZWF0ZWQgbGlrZSBhbgotICogPGNvZGU+RW51bWVyYXRpb248L2NvZGU+LgotICovCi1wdWJsaWMgY2xhc3MgSXRlcmF0b3JFbnVtZXJhdGlvbjxFPgotCWltcGxlbWVudHMgRW51bWVyYXRpb248RT4KLXsKLQlwcml2YXRlIGZpbmFsIEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVyYXRvcjsKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBlbnVtZXJhdGlvbiB0aGF0IHdyYXBzIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICovCi0JcHVibGljIEl0ZXJhdG9yRW51bWVyYXRpb24oSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZXJhdG9yKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuaXRlcmF0b3IgPSBpdGVyYXRvcjsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBoYXNNb3JlRWxlbWVudHMoKSB7Ci0JCXJldHVybiB0aGlzLml0ZXJhdG9yLmhhc05leHQoKTsKLQl9Ci0KLQlwdWJsaWMgRSBuZXh0RWxlbWVudCgpIHsKLQkJcmV0dXJuIHRoaXMuaXRlcmF0b3IubmV4dCgpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuaXRlcmF0b3IpOwotCX0KLQkKLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvUGVla2FibGVJdGVyYXRvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9QZWVrYWJsZUl0ZXJhdG9yLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDMxNmFlZGMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9QZWVrYWJsZUl0ZXJhdG9yLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMDAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci0KLS8qKgotICogQSA8Y29kZT5QZWVrYWJsZUl0ZXJhdG9yPC9jb2RlPiB3cmFwcyBhbm90aGVyIDxjb2RlPkl0ZXJhdG9yPC9jb2RlPgotICogYW5kIGFsbG93cyBhIDxjb2RlPnBlZWsoKTwvY29kZT4gYXQgdGhlIG5leHQgZWxlbWVudCB0byBiZSAKLSAqIHJldHVybmVkIGJ5IDxjb2RlPm5leHQoKTwvY29kZT4uCi0gKiA8cD4KLSAqIE9uZSwgcG9zc2libHkgdW5kZXNpcmFibGUsIHNpZGUtZWZmZWN0IG9mIHVzaW5nIHRoaXMgaXRlcmF0b3IgaXMgdGhhdAotICogdGhlIG5lc3RlZCBpdGVyYXRvcidzIDxjb2RlPm5leHQoKTwvY29kZT4gbWV0aG9kIHdpbGwgYmUgaW52b2tlZAotICogPGVtPmJlZm9yZTwvZW0+IHRoZSBwZWVrYWJsZSBpdGVyYXRvcidzIDxjb2RlPm5leHQoKTwvY29kZT4KLSAqIG1ldGhvZCBpcyBpbnZva2VkLiBUaGlzIGlzIGJlY2F1c2UgdGhlICJuZXh0IiBlbGVtZW50IG11c3QgYmUKLSAqIHByZS1sb2FkZWQgZm9yIHRoZSA8Y29kZT5wZWVrKCk8L2NvZGU+IG1ldGhvZC4KLSAqIFRoaXMgYWxzbyBwcmV2ZW50cyBhIHBlZWthYmxlIGl0ZXJhdG9yIGZyb20gc3VwcG9ydGluZyB0aGUgb3B0aW9uYWwKLSAqIDxjb2RlPnJlbW92ZSgpPC9jb2RlPiBtZXRob2QuCi0gKi8KLQotcHVibGljIGNsYXNzIFBlZWthYmxlSXRlcmF0b3I8RT4KLQlpbXBsZW1lbnRzIEl0ZXJhdG9yPEU+Ci17Ci0JcHJpdmF0ZSBmaW5hbCBJdGVyYXRvcjw/IGV4dGVuZHMgRT4gbmVzdGVkSXRlcmF0b3I7Ci0JcHJpdmF0ZSBFIG5leHQ7Ci0JcHJpdmF0ZSBib29sZWFuIGRvbmU7Ci0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHBlZWthYmxlIGl0ZXJhdG9yIHRoYXQgd3JhcHMgdGhlIHNwZWNpZmllZCBuZXN0ZWQKLQkgKiBpdGVyYXRvci4KLQkgKi8KLQlwdWJsaWMgUGVla2FibGVJdGVyYXRvcihJdGVyYXRvcjw/IGV4dGVuZHMgRT4gbmVzdGVkSXRlcmF0b3IpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5uZXN0ZWRJdGVyYXRvciA9IG5lc3RlZEl0ZXJhdG9yOwotCQl0aGlzLmRvbmUgPSBmYWxzZTsKLQkJdGhpcy5sb2FkTmV4dCgpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGhhc05leHQoKSB7Ci0JCXJldHVybiAhIHRoaXMuZG9uZTsKLQl9Ci0KLQlwdWJsaWMgRSBuZXh0KCkgewotCQlpZiAodGhpcy5kb25lKSB7Ci0JCQl0aHJvdyBuZXcgTm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpOwotCQl9Ci0JCUUgcmVzdWx0ID0gdGhpcy5uZXh0OwotCQl0aGlzLmxvYWROZXh0KCk7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBlbGVtZW50IHRoYXQgd2lsbCBiZSByZXR1cm5lZCBieSB0aGUgbmV4dCBjYWxsIHRvIHRoZQotCSAqIDxjb2RlPm5leHQoKTwvY29kZT4gbWV0aG9kLCB3aXRob3V0IGFkdmFuY2luZyBwYXN0IGl0LgotCSAqLwotCXB1YmxpYyBFIHBlZWsoKSB7Ci0JCWlmICh0aGlzLmRvbmUpIHsKLQkJCXRocm93IG5ldyBOb1N1Y2hFbGVtZW50RXhjZXB0aW9uKCk7Ci0JCX0KLQkJcmV0dXJuIHRoaXMubmV4dDsKLQl9Ci0KLQkvKioKLQkgKiBCZWNhdXNlIHdlIG5lZWQgdG8gcHJlLWxvYWQgdGhlIG5leHQgZWxlbWVudAotCSAqIHRvIGJlIHJldHVybmVkLCB3ZSBjYW5ub3Qgc3VwcG9ydCB0aGUgPGNvZGU+cmVtb3ZlKCk8L2NvZGU+Ci0JICogbWV0aG9kLgotCSAqLwotCXB1YmxpYyB2b2lkIHJlbW92ZSgpIHsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0JLyoqCi0JICogTG9hZCBuZXh0IHdpdGggdGhlIG5leHQgZW50cnkgZnJvbSB0aGUgbmVzdGVkCi0JICogaXRlcmF0b3IuIElmIHRoZXJlIGFyZSBub25lLCBuZXh0IGlzIHNldCB0byA8Y29kZT5FTkQ8L2NvZGU+LgotCSAqLwotCXByaXZhdGUgdm9pZCBsb2FkTmV4dCgpIHsKLQkJaWYgKHRoaXMubmVzdGVkSXRlcmF0b3IuaGFzTmV4dCgpKSB7Ci0JCQl0aGlzLm5leHQgPSB0aGlzLm5lc3RlZEl0ZXJhdG9yLm5leHQoKTsKLQkJfSBlbHNlIHsKLQkJCXRoaXMubmV4dCA9IG51bGw7Ci0JCQl0aGlzLmRvbmUgPSB0cnVlOwotCQl9Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5uZXN0ZWRJdGVyYXRvcik7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL1JlYWRPbmx5Q29tcG9zaXRlTGlzdEl0ZXJhdG9yLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL1JlYWRPbmx5Q29tcG9zaXRlTGlzdEl0ZXJhdG9yLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDExOGQ2ZWIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9SZWFkT25seUNvbXBvc2l0ZUxpc3RJdGVyYXRvci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTc4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDgsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTm9TdWNoRWxlbWVudEV4Y2VwdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotLyoqCi0gKiBBIDxjb2RlPlJlYWRPbmx5Q29tcG9zaXRlTGlzdEl0ZXJhdG9yPC9jb2RlPiB3cmFwcyBhIGxpc3QKLSAqIG9mIDxjb2RlPkxpc3RJdGVyYXRvcjwvY29kZT5zIGFuZCBtYWtlcyB0aGVtIGFwcGVhciB0byBiZSBhIHNpbmdsZQotICogcmVhZC1vbmx5IDxjb2RlPkxpc3RJdGVyYXRvcjwvY29kZT4uIEEgcmVhZC1vbmx5IGNvbXBvc2l0ZSBsaXN0Ci0gKiBpdGVyYXRvciBpcyBtb3JlIGZsZXhpYmxlIHRoYW4gYSBub3JtYWwgY29tcG9zaXRlIGxpc3QgaXRlcmF0b3Igd2hlbiBpdAotICogY29tZXMgdG8gdGhlIGVsZW1lbnQgdHlwZXMgb2YgdGhlIG5lc3RlZCBpdGVyYXRvcnMuCi0gKi8KLXB1YmxpYyBjbGFzcyBSZWFkT25seUNvbXBvc2l0ZUxpc3RJdGVyYXRvcjxFPgotCWltcGxlbWVudHMgTGlzdEl0ZXJhdG9yPEU+Ci17Ci0JcHJpdmF0ZSBmaW5hbCBMaXN0SXRlcmF0b3I8PyBleHRlbmRzIExpc3RJdGVyYXRvcjw/IGV4dGVuZHMgRT4+IGl0ZXJhdG9yczsKLQlwcml2YXRlIExpc3RJdGVyYXRvcjw/IGV4dGVuZHMgRT4gbmV4dEl0ZXJhdG9yOwotCXByaXZhdGUgaW50IG5leHRJbmRleDsKLQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgcmVhZC1vbmx5IGxpc3QgaXRlcmF0b3Igd2l0aCB0aGUgc3BlY2lmaWVkIGxpc3Qgb2YKLQkgKiBsaXN0IGl0ZXJhdG9ycy4KLQkgKi8KLQlwdWJsaWMgUmVhZE9ubHlDb21wb3NpdGVMaXN0SXRlcmF0b3IoTGlzdDw/IGV4dGVuZHMgTGlzdEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPj4gaXRlcmF0b3JzKSB7Ci0JCXRoaXMoaXRlcmF0b3JzLmxpc3RJdGVyYXRvcigpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSByZWFkLW9ubHkgbGlzdCBpdGVyYXRvciB3aXRoIHRoZSBzcGVjaWZpZWQgbGlzdCBvZgotCSAqIGxpc3QgaXRlcmF0b3JzLgotCSAqLwotCXB1YmxpYyBSZWFkT25seUNvbXBvc2l0ZUxpc3RJdGVyYXRvcihMaXN0SXRlcmF0b3I8PyBleHRlbmRzIExpc3RJdGVyYXRvcjw/IGV4dGVuZHMgRT4+IGl0ZXJhdG9ycykgewotCQlzdXBlcigpOwotCQl0aGlzLml0ZXJhdG9ycyA9IGl0ZXJhdG9yczsKLQkJdGhpcy5uZXh0SW5kZXggPSAwOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHJlYWQtb25seSBsaXN0IGl0ZXJhdG9yIHdpdGggdGhlIHNwZWNpZmllZCBvYmplY3QgcHJlcGVuZGVkCi0JICogdG8gdGhlIHNwZWNpZmllZCBpdGVyYXRvci4KLQkgKi8KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwdWJsaWMgUmVhZE9ubHlDb21wb3NpdGVMaXN0SXRlcmF0b3IoRSBvYmplY3QsIExpc3RJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IpIHsKLQkJdGhpcyhuZXcgU2luZ2xlRWxlbWVudExpc3RJdGVyYXRvcjxFPihvYmplY3QpLCBpdGVyYXRvcik7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgcmVhZC1vbmx5IGxpc3QgaXRlcmF0b3Igd2l0aCB0aGUgc3BlY2lmaWVkIG9iamVjdCBhcHBlbmRlZAotCSAqIHRvIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JICovCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHVibGljIFJlYWRPbmx5Q29tcG9zaXRlTGlzdEl0ZXJhdG9yKExpc3RJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IsIEUgb2JqZWN0KSB7Ci0JCXRoaXMoaXRlcmF0b3IsIG5ldyBTaW5nbGVFbGVtZW50TGlzdEl0ZXJhdG9yPEU+KG9iamVjdCkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHJlYWQtb25seSBsaXN0IGl0ZXJhdG9yIHdpdGggdGhlIHNwZWNpZmllZCBsaXN0IGl0ZXJhdG9ycy4KLQkgKi8KLQlwdWJsaWMgUmVhZE9ubHlDb21wb3NpdGVMaXN0SXRlcmF0b3IoTGlzdEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPi4uLiBpdGVyYXRvcnMpIHsKLQkJdGhpcyhuZXcgQXJyYXlMaXN0SXRlcmF0b3I8TGlzdEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPj4oaXRlcmF0b3JzKSk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaGFzTmV4dCgpIHsKLQkJdHJ5IHsKLQkJCXRoaXMubG9hZE5leHRJdGVyYXRvcigpOwotCQl9IGNhdGNoIChOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQkvLyB0aGlzIG9jY3VycyBpZiB0aGVyZSBhcmUgbm8gaXRlcmF0b3JzIGF0IGFsbAotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCXJldHVybiB0aGlzLm5leHRJdGVyYXRvci5oYXNOZXh0KCk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaGFzUHJldmlvdXMoKSB7Ci0JCXRyeSB7Ci0JCQl0aGlzLmxvYWRQcmV2aW91c0l0ZXJhdG9yKCk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCS8vIHRoaXMgb2NjdXJzIGlmIHRoZXJlIGFyZSBubyBpdGVyYXRvcnMgYXQgYWxsCi0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJcmV0dXJuIHRoaXMubmV4dEl0ZXJhdG9yLmhhc1ByZXZpb3VzKCk7Ci0JfQotCi0JcHVibGljIEUgbmV4dCgpIHsKLQkJdGhpcy5sb2FkTmV4dEl0ZXJhdG9yKCk7Ci0JCUUgcmVzdWx0ID0gdGhpcy5uZXh0SXRlcmF0b3IubmV4dCgpOwotCQotCQkvLyB0aGUgc3RhdGVtZW50IGFib3ZlIHdpbGwgdGhyb3cgYSBOb1N1Y2hFbGVtZW50RXhjZXB0aW9uCi0JCS8vIGlmIHRoZSBjdXJyZW50IGl0ZXJhdG9yIGlzIGF0IHRoZSBlbmQgb2YgdGhlIGxpbmU7Ci0JCS8vIHNvIGlmIHdlIGdldCBoZXJlLCB3ZSBjYW4gaW5jcmVtZW50ICduZXh0SW5kZXgnCi0JCXRoaXMubmV4dEluZGV4Kys7Ci0JCi0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JcHVibGljIGludCBuZXh0SW5kZXgoKSB7Ci0JCXJldHVybiB0aGlzLm5leHRJbmRleDsKLQl9Ci0KLQlwdWJsaWMgRSBwcmV2aW91cygpIHsKLQkJdGhpcy5sb2FkUHJldmlvdXNJdGVyYXRvcigpOwotCQlFIHJlc3VsdCA9IHRoaXMubmV4dEl0ZXJhdG9yLnByZXZpb3VzKCk7Ci0JCi0JCS8vIHRoZSBzdGF0ZW1lbnQgYWJvdmUgd2lsbCB0aHJvdyBhIE5vU3VjaEVsZW1lbnRFeGNlcHRpb24KLQkJLy8gaWYgdGhlIGN1cnJlbnQgaXRlcmF0b3IgaXMgYXQgdGhlIGVuZCBvZiB0aGUgbGluZTsKLQkJLy8gc28gaWYgd2UgZ2V0IGhlcmUsIHdlIGNhbiBkZWNyZW1lbnQgJ25leHRJbmRleCcKLQkJdGhpcy5uZXh0SW5kZXgtLTsKLQkKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwdWJsaWMgaW50IHByZXZpb3VzSW5kZXgoKSB7Ci0JCXJldHVybiB0aGlzLm5leHRJbmRleCAgLSAxOwotCX0KLQotCXB1YmxpYyB2b2lkIGFkZChFIG8pIHsKLQkJLy8gdGhlIGxpc3QgaXRlcmF0b3IgaXMgcmVhZC1vbmx5Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHJlbW92ZSgpIHsKLQkJLy8gdGhlIGxpc3QgaXRlcmF0b3IgaXMgcmVhZC1vbmx5Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHNldChFIGUpIHsKLQkJLy8gdGhlIGxpc3QgaXRlcmF0b3IgaXMgcmVhZC1vbmx5Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQotCS8qKgotCSAqIExvYWQgbmV4dEl0ZXJhdG9yIHdpdGggdGhlIGZpcnN0IGl0ZXJhdG9yIHRoYXQgPGNvZGU+aGFzTmV4dCgpPC9jb2RlPgotCSAqIG9yIHRoZSBmaW5hbCBpdGVyYXRvciBpZiBhbGwgdGhlIGVsZW1lbnRzIGhhdmUgYWxyZWFkeSBiZWVuIHJldHJpZXZlZC4KLQkgKi8KLQlwcml2YXRlIHZvaWQgbG9hZE5leHRJdGVyYXRvcigpIHsKLQkJdGhpcy5jaGVja05leHRJdGVyYXRvcigpOwotCQl3aGlsZSAoKCAhIHRoaXMubmV4dEl0ZXJhdG9yLmhhc05leHQoKSkgJiYgdGhpcy5pdGVyYXRvcnMuaGFzTmV4dCgpKSB7Ci0JCQl0aGlzLm5leHRJdGVyYXRvciA9IHRoaXMuaXRlcmF0b3JzLm5leHQoKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIExvYWQgbmV4dEl0ZXJhdG9yIHdpdGggdGhlIGZpcnN0IGl0ZXJhdG9yIHRoYXQgPGNvZGU+aGFzUHJldmlvdXMoKTwvY29kZT4KLQkgKiBvciB0aGUgZmlyc3QgaXRlcmF0b3IgaWYgYWxsIHRoZSBlbGVtZW50cyBoYXZlIGFscmVhZHkgYmVlbiByZXRyaWV2ZWQuCi0JICovCi0JcHJpdmF0ZSB2b2lkIGxvYWRQcmV2aW91c0l0ZXJhdG9yKCkgewotCQl0aGlzLmNoZWNrTmV4dEl0ZXJhdG9yKCk7Ci0JCXdoaWxlICgoICEgdGhpcy5uZXh0SXRlcmF0b3IuaGFzUHJldmlvdXMoKSkgJiYgdGhpcy5pdGVyYXRvcnMuaGFzUHJldmlvdXMoKSkgewotCQkJdGhpcy5uZXh0SXRlcmF0b3IgPSB0aGlzLml0ZXJhdG9ycy5wcmV2aW91cygpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogSWYgJ25leHRJdGVyYXRvcicgaXMgbnVsbCwgbG9hZCBpdCB3aXRoIHRoZSBmaXJzdCBpdGVyYXRvci4KLQkgKi8KLQlwcml2YXRlIHZvaWQgY2hlY2tOZXh0SXRlcmF0b3IoKSB7Ci0JCWlmICh0aGlzLm5leHRJdGVyYXRvciA9PSBudWxsKSB7Ci0JCQl0aGlzLm5leHRJdGVyYXRvciA9IHRoaXMuaXRlcmF0b3JzLm5leHQoKTsKLQkJfQotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuaXRlcmF0b3JzKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvUmVhZE9ubHlJdGVyYXRvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9SZWFkT25seUl0ZXJhdG9yLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGRmMGE1MTMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9SZWFkT25seUl0ZXJhdG9yLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw2MSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9yczsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotLyoqCi0gKiBBIDxjb2RlPlJlYWRPbmx5SXRlcmF0b3I8L2NvZGU+IHdyYXBzIGFub3RoZXIgPGNvZGU+SXRlcmF0b3I8L2NvZGU+Ci0gKiBhbmQgcmVtb3ZlcyBzdXBwb3J0IGZvciAjcmVtb3ZlKCkuCi0gKi8KLXB1YmxpYyBjbGFzcyBSZWFkT25seUl0ZXJhdG9yPEU+Ci0JaW1wbGVtZW50cyBJdGVyYXRvcjxFPgotewotCXByaXZhdGUgZmluYWwgSXRlcmF0b3I8PyBleHRlbmRzIEU+IG5lc3RlZEl0ZXJhdG9yOwotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGl0ZXJhdG9yIG9uIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbiB0aGF0Ci0JICogZGlzYWxsb3dzIHJlbW92ZXMuCi0JICovCi0JcHVibGljIFJlYWRPbmx5SXRlcmF0b3IoQ29sbGVjdGlvbjw/IGV4dGVuZHMgRT4gYykgewotCQl0aGlzKGMuaXRlcmF0b3IoKSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGl0ZXJhdG9yIHdpdGggdGhlIHNwZWNpZmllZCBuZXN0ZWQgaXRlcmF0b3IKLQkgKiBhbmQgZGlzYWxsb3cgcmVtb3Zlcy4KLQkgKi8KLQlwdWJsaWMgUmVhZE9ubHlJdGVyYXRvcihJdGVyYXRvcjw/IGV4dGVuZHMgRT4gbmVzdGVkSXRlcmF0b3IpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5uZXN0ZWRJdGVyYXRvciA9IG5lc3RlZEl0ZXJhdG9yOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGhhc05leHQoKSB7Ci0JCS8vIGRlbGVnYXRlIHRvIHRoZSBuZXN0ZWQgaXRlcmF0b3IKLQkJcmV0dXJuIHRoaXMubmVzdGVkSXRlcmF0b3IuaGFzTmV4dCgpOwotCX0KLQotCXB1YmxpYyBFIG5leHQoKSB7Ci0JCS8vIGRlbGVnYXRlIHRvIHRoZSBuZXN0ZWQgaXRlcmF0b3IKLQkJcmV0dXJuIHRoaXMubmVzdGVkSXRlcmF0b3IubmV4dCgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHJlbW92ZSgpIHsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5uZXN0ZWRJdGVyYXRvcik7Ci0JfQotCQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9SZWFkT25seUxpc3RJdGVyYXRvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9SZWFkT25seUxpc3RJdGVyYXRvci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjM2IyNTkxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvUmVhZE9ubHlMaXN0SXRlcmF0b3IuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDkzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotLyoqCi0gKiBBIDxjb2RlPlJlYWRPbmx5TGlzdEl0ZXJhdG9yPC9jb2RlPiB3cmFwcyBhbm90aGVyCi0gKiA8Y29kZT5MaXN0SXRlcmF0b3I8L2NvZGU+IGFuZCByZW1vdmVzIHN1cHBvcnQgZm9yOgotICogCSNyZW1vdmUoKQotICogCSNzZXQoT2JqZWN0KQotICogCSNhZGQoT2JqZWN0KQotICovCi1wdWJsaWMgY2xhc3MgUmVhZE9ubHlMaXN0SXRlcmF0b3I8RT4KLQlpbXBsZW1lbnRzIExpc3RJdGVyYXRvcjxFPgotewotCXByaXZhdGUgZmluYWwgTGlzdEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBuZXN0ZWRMaXN0SXRlcmF0b3I7Ci0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBpdGVyYXRvciBvbiB0aGUgc3BlY2lmaWVkIGxpc3QgdGhhdAotCSAqIGRpc2FsbG93cyByZW1vdmVzLCBzZXRzLCBhbmQgYWRkcy4KLQkgKi8KLQlwdWJsaWMgUmVhZE9ubHlMaXN0SXRlcmF0b3IoTGlzdDw/IGV4dGVuZHMgRT4gbGlzdCkgewotCQl0aGlzKGxpc3QubGlzdEl0ZXJhdG9yKCkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBpdGVyYXRvciBvbiB0aGUgc3BlY2lmaWVkIGxpc3QgaXRlcmF0b3IgdGhhdAotCSAqIGRpc2FsbG93cyByZW1vdmVzLCBzZXRzLCBhbmQgYWRkcy4KLQkgKi8KLQlwdWJsaWMgUmVhZE9ubHlMaXN0SXRlcmF0b3IoTGlzdEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBuZXN0ZWRMaXN0SXRlcmF0b3IpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5uZXN0ZWRMaXN0SXRlcmF0b3IgPSBuZXN0ZWRMaXN0SXRlcmF0b3I7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaGFzTmV4dCgpIHsKLQkJLy8gZGVsZWdhdGUgdG8gdGhlIG5lc3RlZCBpdGVyYXRvcgotCQlyZXR1cm4gdGhpcy5uZXN0ZWRMaXN0SXRlcmF0b3IuaGFzTmV4dCgpOwotCX0KLQotCXB1YmxpYyBFIG5leHQoKSB7Ci0JCS8vIGRlbGVnYXRlIHRvIHRoZSBuZXN0ZWQgaXRlcmF0b3IKLQkJcmV0dXJuIHRoaXMubmVzdGVkTGlzdEl0ZXJhdG9yLm5leHQoKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBoYXNQcmV2aW91cygpIHsKLQkJLy8gZGVsZWdhdGUgdG8gdGhlIG5lc3RlZCBpdGVyYXRvcgotCQlyZXR1cm4gdGhpcy5uZXN0ZWRMaXN0SXRlcmF0b3IuaGFzUHJldmlvdXMoKTsKLQl9Ci0KLQlwdWJsaWMgRSBwcmV2aW91cygpIHsKLQkJLy8gZGVsZWdhdGUgdG8gdGhlIG5lc3RlZCBpdGVyYXRvcgotCQlyZXR1cm4gdGhpcy5uZXN0ZWRMaXN0SXRlcmF0b3IucHJldmlvdXMoKTsKLQl9Ci0KLQlwdWJsaWMgaW50IG5leHRJbmRleCgpIHsKLQkJLy8gZGVsZWdhdGUgdG8gdGhlIG5lc3RlZCBpdGVyYXRvcgotCQlyZXR1cm4gdGhpcy5uZXN0ZWRMaXN0SXRlcmF0b3IubmV4dEluZGV4KCk7Ci0JfQotCi0JcHVibGljIGludCBwcmV2aW91c0luZGV4KCkgewotCQkvLyBkZWxlZ2F0ZSB0byB0aGUgbmVzdGVkIGl0ZXJhdG9yCi0JCXJldHVybiB0aGlzLm5lc3RlZExpc3RJdGVyYXRvci5wcmV2aW91c0luZGV4KCk7Ci0JfQotCi0JcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBzZXQoRSBvKSB7Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQotCXB1YmxpYyB2b2lkIGFkZChFIG8pIHsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5uZXN0ZWRMaXN0SXRlcmF0b3IpOwotCX0KLQkKLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvUmVzdWx0U2V0SXRlcmF0b3IuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvUmVzdWx0U2V0SXRlcmF0b3IuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYjU4OTFjNy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL1Jlc3VsdFNldEl0ZXJhdG9yLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNTQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnNxbC5SZXN1bHRTZXQ7Ci1pbXBvcnQgamF2YS5zcWwuU1FMRXhjZXB0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTm9TdWNoRWxlbWVudEV4Y2VwdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotLyoqCi0gKiBBIDxjb2RlPlJlc3VsdFNldEl0ZXJhdG9yPC9jb2RlPiB3cmFwcyBhIDxjb2RlPlJlc3VsdFNldDwvY29kZT4KLSAqIGFuZCB0cmFuc2Zvcm1zIGl0cyByb3dzIGZvciBjbGllbnQgY29uc3VtcHRpb24uIFN1YmNsYXNzZXMgY2FuIG92ZXJyaWRlCi0gKiA8Y29kZT4jYnVpbGROZXh0KFJlc3VsdFNldCk8L2NvZGU+IHRvIGJ1aWxkIHRoZSBleHBlY3RlZCBvYmplY3QgZnJvbQotICogdGhlIGN1cnJlbnQgcm93IG9mIHRoZSByZXN1bHQgc2V0LgotICogPHA+Ci0gKiBUbyB1c2UsIHN1cHBseTo8dWw+Ci0gKiA8bGk+IGEgPGNvZGU+UmVzdWx0U2V0PC9jb2RlPgotICogPGxpPiBhbiA8Y29kZT5BZGFwdGVyPC9jb2RlPiB0aGF0IGNvbnZlcnRzIGEgcm93IGluIHRoZSA8Y29kZT5SZXN1bHRTZXQ8L2NvZGU+Ci0gKiBpbnRvIHRoZSBkZXNpcmVkIG9iamVjdAotICogKGFsdGVybmF0aXZlbHksIHN1YmNsYXNzIDxjb2RlPlJlc3VsdFNldEl0ZXJhdG9yPC9jb2RlPgotICogYW5kIG92ZXJyaWRlIHRoZSA8Y29kZT5idWlsZE5leHQoUmVzdWx0U2V0KTwvY29kZT4gbWV0aG9kKQotICogPC91bD4KLSAqIDxwPgotICovCi1wdWJsaWMgY2xhc3MgUmVzdWx0U2V0SXRlcmF0b3I8RT4KLQlpbXBsZW1lbnRzIEl0ZXJhdG9yPEU+Ci17Ci0JcHJpdmF0ZSBmaW5hbCBSZXN1bHRTZXQgcmVzdWx0U2V0OwotCXByaXZhdGUgZmluYWwgQWRhcHRlcjxFPiBhZGFwdGVyOwotCXByaXZhdGUgRSBuZXh0OwotCXByaXZhdGUgYm9vbGVhbiBkb25lOwotCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gaXRlcmF0b3Igb24gdGhlIHNwZWNpZmllZCByZXN1bHQgc2V0IHRoYXQgcmV0dXJucwotCSAqIHRoZSBvYmplY3RzIHByb2R1Y2VkIGJ5IHRoZSBzcGVjaWZpZWQgYWRhcHRlci4KLQkgKi8KLQlwdWJsaWMgUmVzdWx0U2V0SXRlcmF0b3IoUmVzdWx0U2V0IHJlc3VsdFNldCwgQWRhcHRlcjxFPiBhZGFwdGVyKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMucmVzdWx0U2V0ID0gcmVzdWx0U2V0OwotCQl0aGlzLmFkYXB0ZXIgPSBhZGFwdGVyOwotCQl0aGlzLmRvbmUgPSBmYWxzZTsKLQkJdGhpcy5uZXh0ID0gdGhpcy5idWlsZE5leHQoKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gaXRlcmF0b3Igb24gdGhlIHNwZWNpZmllZCByZXN1bHQgc2V0IHRoYXQgcmV0dXJucwotCSAqIHRoZSBmaXJzdCBvYmplY3QgaW4gZWFjaCByb3cgb2YgdGhlIHJlc3VsdCBzZXQuCi0JICovCi0JcHVibGljIFJlc3VsdFNldEl0ZXJhdG9yKFJlc3VsdFNldCByZXN1bHRTZXQpIHsKLQkJdGhpcyhyZXN1bHRTZXQsIEFkYXB0ZXIuRGVmYXVsdC48RT5pbnN0YW5jZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBCdWlsZCB0aGUgbmV4dCBvYmplY3QgZm9yIHRoZSBpdGVyYXRvciB0byByZXR1cm4uCi0JICogQ2xvc2UgdGhlIHJlc3VsdCBzZXQgd2hlbiB3ZSByZWFjaCB0aGUgZW5kLgotCSAqLwotCXByaXZhdGUgRSBidWlsZE5leHQoKSB7Ci0JCXRyeSB7Ci0JCQlpZiAodGhpcy5yZXN1bHRTZXQubmV4dCgpKSB7Ci0JCQkJcmV0dXJuIHRoaXMuYnVpbGROZXh0KHRoaXMucmVzdWx0U2V0KTsKLQkJCX0KLQkJCXRoaXMucmVzdWx0U2V0LmNsb3NlKCk7Ci0JCQl0aGlzLmRvbmUgPSB0cnVlOwotCQkJcmV0dXJuIG51bGw7Ci0JCX0gY2F0Y2ggKFNRTEV4Y2VwdGlvbiBleCkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oZXgpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogQnkgZGVmYXVsdCwgcmV0dXJuIHRoZSBmaXJzdCBvYmplY3QgaW4gdGhlIGN1cnJlbnQgcm93Ci0JICogb2YgdGhlIHJlc3VsdCBzZXQuIEFueSA8Y29kZT5TUUxFeGNlcHRpb248L2NvZGU+cyB3aWxsCi0JICogYmUgY2F1Z2h0IGFuZCB3cmFwcGVkIGluIGEgPGNvZGU+UnVudGltZUV4Y2VwdGlvbjwvY29kZT4uCi0JICovCi0JcHJvdGVjdGVkIEUgYnVpbGROZXh0KFJlc3VsdFNldCBycykgdGhyb3dzIFNRTEV4Y2VwdGlvbiB7Ci0JCXJldHVybiB0aGlzLmFkYXB0ZXIuYnVpbGROZXh0KHJzKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBoYXNOZXh0KCkgewotCQlyZXR1cm4gISB0aGlzLmRvbmU7Ci0JfQotCi0JcHVibGljIEUgbmV4dCgpIHsKLQkJaWYgKHRoaXMuZG9uZSkgewotCQkJdGhyb3cgbmV3IE5vU3VjaEVsZW1lbnRFeGNlcHRpb24oKTsKLQkJfQotCQlFIHRlbXAgPSB0aGlzLm5leHQ7Ci0JCXRoaXMubmV4dCA9IHRoaXMuYnVpbGROZXh0KCk7Ci0JCXJldHVybiB0ZW1wOwotCX0KLQotCXB1YmxpYyB2b2lkIHJlbW92ZSgpIHsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5yZXN1bHRTZXQpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbnRlcmZhY2UgKioqKioqKioqKgotCi0JLyoqCi0JICogVXNlZCBieSA8Y29kZT5SZXN1bHRTZXRJdGVyYXRvcjwvY29kZT4gdG8gY29udmVydCBhCi0JICogPGNvZGU+UmVzdWx0U2V0PC9jb2RlPidzIGN1cnJlbnQgcm93IGludG8gdGhlIG5leHQgb2JqZWN0Ci0JICogdG8gYmUgcmV0dXJuZWQgYnkgdGhlIDxjb2RlPkl0ZXJhdG9yPC9jb2RlPi4KLQkgKi8KLQlwdWJsaWMgaW50ZXJmYWNlIEFkYXB0ZXI8VD4gewotCi0JCS8qKgotCQkgKiBSZXR1cm4gYW4gb2JqZWN0IGNvcnJlc3BvbmRpbmcgdG8gdGhlIHJlc3VsdCBzZXQncwotCQkgKiAiY3VycmVudCIgcm93LiBBbnkgPGNvZGU+U1FMRXhjZXB0aW9uPC9jb2RlPnMgd2lsbAotCQkgKiBiZSBjYXVnaHQgYW5kIHdyYXBwZWQgaW4gYSA8Y29kZT5SdW50aW1lRXhjZXB0aW9uPC9jb2RlPi4KLQkJICogQHNlZSBqYXZhLnNxbC5SZXN1bHRTZXQKLQkJICovCi0JCVQgYnVpbGROZXh0KFJlc3VsdFNldCBycykgdGhyb3dzIFNRTEV4Y2VwdGlvbjsKLQotCi0JCWZpbmFsIGNsYXNzIERlZmF1bHQ8Uz4gaW1wbGVtZW50cyBBZGFwdGVyPFM+IHsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBBZGFwdGVyIElOU1RBTkNFID0gbmV3IERlZmF1bHQoKTsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHVibGljIHN0YXRpYyA8Uj4gQWRhcHRlcjxSPiBpbnN0YW5jZSgpIHsKLQkJCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCQl9Ci0JCQkvLyBlbnN1cmUgc2luZ2xlIGluc3RhbmNlCi0JCQlwcml2YXRlIERlZmF1bHQoKSB7Ci0JCQkJc3VwZXIoKTsKLQkJCX0KLQkJCS8vIHJldHVybiB0aGUgZmlyc3Qgb2JqZWN0IGluIHRoZSBjdXJyZW50IHJvdyBvZiB0aGUgcmVzdWx0IHNldAotCQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCQlwdWJsaWMgUyBidWlsZE5leHQoUmVzdWx0U2V0IHJzKSB0aHJvd3MgU1FMRXhjZXB0aW9uIHsKLQkJCQkvLyByZXN1bHQgc2V0IGNvbHVtbnMgYXJlIGluZGV4ZWQgc3RhcnRpbmcgd2l0aCAxCi0JCQkJcmV0dXJuIChTKSBycy5nZXRPYmplY3QoMSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJSZXN1bHRTZXRJdGVyYXRvci5BZGFwdGVyLkRlZmF1bHQiOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCX0KLQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9TaW5nbGVFbGVtZW50SXRlcmF0b3IuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvU2luZ2xlRWxlbWVudEl0ZXJhdG9yLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDc1ZmQ5ZDguLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9TaW5nbGVFbGVtZW50SXRlcmF0b3IuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDYzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Ob1N1Y2hFbGVtZW50RXhjZXB0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotCi0vKioKLSAqIEEgPGNvZGU+U2luZ2xlRWxlbWVudEl0ZXJhdG9yPC9jb2RlPiBob2xkcyBhIHNpbmdsZSBlbGVtZW50Ci0gKiBhbmQgcmV0dXJucyBpdCB3aXRoIHRoZSBmaXJzdCBjYWxsIHRvIDxjb2RlPm5leHQoKTwvY29kZT4sIGF0Ci0gKiB3aGljaCBwb2ludCBpdCB3aWxsIHJldHVybiA8Y29kZT5mYWxzZTwvY29kZT4gdG8gYW55IHN1YnNlcXVlbnQKLSAqIGNhbGwgdG8gPGNvZGU+aGFzTmV4dCgpPC9jb2RlPi4KLSAqIDxwPgotICogQSA8Y29kZT5TaW5nbGVFbGVtZW50SXRlcmF0b3I8L2NvZGU+IGlzIGVxdWl2YWxlbnQgdG8gdGhlCi0gKiA8Y29kZT5JdGVyYXRvcjwvY29kZT4gcmV0dXJuZWQgYnk6Ci0gKiAJPGNvZGU+amF2YS51dGlsLkNvbGxlY3Rpb25zLnNpbmdsZXRvbihlbGVtZW50KS5pdGVyYXRvcigpPC9jb2RlPgotICovCi1wdWJsaWMgY2xhc3MgU2luZ2xlRWxlbWVudEl0ZXJhdG9yPEU+Ci0JaW1wbGVtZW50cyBJdGVyYXRvcjxFPgotewotCXByaXZhdGUgZmluYWwgRSBlbGVtZW50OwotCXByaXZhdGUgYm9vbGVhbiBkb25lOwotCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gaXRlcmF0b3IgdGhhdCByZXR1cm5zIG9ubHkgdGhlIHNwZWNpZmllZCBlbGVtZW50LgotCSAqLwotCXB1YmxpYyBTaW5nbGVFbGVtZW50SXRlcmF0b3IoRSBlbGVtZW50KSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuZWxlbWVudCA9IGVsZW1lbnQ7Ci0JCXRoaXMuZG9uZSA9IGZhbHNlOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGhhc05leHQoKSB7Ci0JCXJldHVybiAhIHRoaXMuZG9uZTsKLQl9Ci0KLQlwdWJsaWMgRSBuZXh0KCkgewotCQlpZiAodGhpcy5kb25lKSB7Ci0JCQl0aHJvdyBuZXcgTm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpOwotCQl9Ci0JCXRoaXMuZG9uZSA9IHRydWU7Ci0JCXJldHVybiB0aGlzLmVsZW1lbnQ7Ci0JfQotCi0JcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuYnVpbGRUb1N0cmluZ0Zvcih0aGlzLCB0aGlzLmVsZW1lbnQpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9TaW5nbGVFbGVtZW50TGlzdEl0ZXJhdG9yLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL1NpbmdsZUVsZW1lbnRMaXN0SXRlcmF0b3IuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzk5Y2I3Mi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL1NpbmdsZUVsZW1lbnRMaXN0SXRlcmF0b3IuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDk0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTm9TdWNoRWxlbWVudEV4Y2VwdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotLyoqCi0gKiBBIDxjb2RlPlNpbmdsZUVsZW1lbnRMaXN0SXRlcmF0b3I8L2NvZGU+IGhvbGRzIGEgc2luZ2xlIGVsZW1lbnQKLSAqIGFuZCByZXR1cm5zIGl0IHdpdGggdGhlIGZpcnN0IGNhbGwgdG8gPGNvZGU+bmV4dCgpPC9jb2RlPiwgYXQKLSAqIHdoaWNoIHBvaW50IGl0IHdpbGwgcmV0dXJuIDxjb2RlPmZhbHNlPC9jb2RlPiB0byBhbnkgc3Vic2VxdWVudAotICogY2FsbCB0byA8Y29kZT5oYXNOZXh0KCk8L2NvZGU+LiBMaWtld2lzZSwgaXQgd2lsbCByZXR1cm4gPGNvZGU+ZmFsc2U8L2NvZGU+Ci0gKiB0byBhIGNhbGwgdG8gPGNvZGU+aGFzUHJldmlvdXMoKTwvY29kZT4gdW50aWwgYSBjYWxsIHRvIDxjb2RlPm5leHQoKTwvY29kZT4sCi0gKiBhdCB3aGljaCBwb2ludCBhIGNhbGwgdG8gPGNvZGU+cHJldmlvdXMoKTwvY29kZT4gd2lsbCByZXR1cm4gdGhlCi0gKiBzaW5nbGUgZWxlbWVudC4KLSAqIDxwPgotICogQSA8Y29kZT5TaW5nbGVFbGVtZW50TGlzdEl0ZXJhdG9yPC9jb2RlPiBpcyBlcXVpdmFsZW50IHRvIHRoZQotICogPGNvZGU+SXRlcmF0b3I8L2NvZGU+IHJldHVybmVkIGJ5OgotICogCTxjb2RlPmphdmEudXRpbC5Db2xsZWN0aW9ucy5zaW5nbGV0b25MaXN0KGVsZW1lbnQpLmxpc3RJdGVyYXRvcigpPC9jb2RlPgotICovCi1wdWJsaWMgY2xhc3MgU2luZ2xlRWxlbWVudExpc3RJdGVyYXRvcjxFPgotCWltcGxlbWVudHMgTGlzdEl0ZXJhdG9yPEU+Ci17Ci0JcHJpdmF0ZSBmaW5hbCBFIGVsZW1lbnQ7Ci0JcHJpdmF0ZSBib29sZWFuIGhhc05leHQ7Ci0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGxpc3QgaXRlcmF0b3IgdGhhdCByZXR1cm5zIG9ubHkgdGhlIHNwZWNpZmllZCBlbGVtZW50LgotCSAqLwotCXB1YmxpYyBTaW5nbGVFbGVtZW50TGlzdEl0ZXJhdG9yKEUgZWxlbWVudCkgewotCQlzdXBlcigpOwotCQl0aGlzLmVsZW1lbnQgPSBlbGVtZW50OwotCQl0aGlzLmhhc05leHQgPSB0cnVlOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGhhc05leHQoKSB7Ci0JCXJldHVybiB0aGlzLmhhc05leHQ7Ci0JfQotCi0JcHVibGljIEUgbmV4dCgpIHsKLQkJaWYgKHRoaXMuaGFzTmV4dCkgewotCQkJdGhpcy5oYXNOZXh0ID0gZmFsc2U7Ci0JCQlyZXR1cm4gdGhpcy5lbGVtZW50OwotCQl9Ci0JCXRocm93IG5ldyBOb1N1Y2hFbGVtZW50RXhjZXB0aW9uKCk7Ci0JfQotCi0JcHVibGljIGludCBuZXh0SW5kZXgoKSB7Ci0JCXJldHVybiB0aGlzLmhhc05leHQgPyAwIDogMTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBoYXNQcmV2aW91cygpIHsKLQkJcmV0dXJuICEgdGhpcy5oYXNOZXh0OwotCX0KLQotCXB1YmxpYyBFIHByZXZpb3VzKCkgewotCQlpZiAodGhpcy5oYXNOZXh0KSB7Ci0JCQl0aHJvdyBuZXcgTm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpOwotCQl9Ci0JCXRoaXMuaGFzTmV4dCA9IHRydWU7Ci0JCXJldHVybiB0aGlzLmVsZW1lbnQ7Ci0JfQotCi0JcHVibGljIGludCBwcmV2aW91c0luZGV4KCkgewotCQlyZXR1cm4gdGhpcy5oYXNOZXh0ID8gLTEgOiAwOwotCX0KLQotCXB1YmxpYyB2b2lkIGFkZChFIGUpIHsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0KEUgZSkgewotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCByZW1vdmUoKSB7Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuZWxlbWVudCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvaXRlcmF0b3JzL1RyYW5zZm9ybWF0aW9uSXRlcmF0b3IuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvVHJhbnNmb3JtYXRpb25JdGVyYXRvci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiOTcwZDI4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvVHJhbnNmb3JtYXRpb25JdGVyYXRvci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuVHJhbnNmb3JtZXI7Ci0KLQotLyoqCi0gKiBBIDxjb2RlPlRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8L2NvZGU+IHdyYXBzIGFub3RoZXIgPGNvZGU+SXRlcmF0b3I8L2NvZGU+Ci0gKiBhbmQgdHJhbnNmb3JtcyBpdHMgcmVzdWx0cyBmb3IgY2xpZW50IGNvbnN1bXB0aW9uLiBUbyB1c2UsIHN1cHBseSBhIAotICogPGNvZGU+VHJhbnNmb3JtZXI8L2NvZGU+IG9yIHN1YmNsYXNzIDxjb2RlPlRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8L2NvZGU+Ci0gKiBhbmQgb3ZlcnJpZGUgdGhlIDxjb2RlPnRyYW5zZm9ybShPYmplY3QpPC9jb2RlPiBtZXRob2QuCi0gKiBPYmplY3RzIG9mIHR5cGUgRTEgYXJlIHRyYW5zZm9ybWVkIGludG8gb2JqZWN0cyBvZiB0eXBlIEUyOwotICogaS5lLiB0aGUgaXRlcmF0b3IgcmV0dXJucyBvYmplY3RzIG9mIHR5cGUgRTIuCi0gKi8KLXB1YmxpYyBjbGFzcyBUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yPEUxLCBFMj4KLQlpbXBsZW1lbnRzIEl0ZXJhdG9yPEUyPgotewotCXByaXZhdGUgZmluYWwgSXRlcmF0b3I8PyBleHRlbmRzIEUxPiBuZXN0ZWRJdGVyYXRvcjsKLQlwcml2YXRlIGZpbmFsIFRyYW5zZm9ybWVyPEUxLCA/IGV4dGVuZHMgRTI+IHRyYW5zZm9ybWVyOwotCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gaXRlcmF0b3Igd2l0aCB0aGUgc3BlY2lmaWVkIG5lc3RlZCBpdGVyYXRvcgotCSAqIGFuZCBhIGRpc2FibGVkIHRyYW5zZm9ybWVyLgotCSAqIFVzZSB0aGlzIGNvbnN0cnVjdG9yIGlmIHlvdSB3YW50IHRvIG92ZXJyaWRlIHRoZQotCSAqIDxjb2RlPnRyYW5zZm9ybShPYmplY3QpPC9jb2RlPiBtZXRob2QgaW5zdGVhZCBvZiBidWlsZGluZwotCSAqIGEgPGNvZGU+VHJhbnNmb3JtZXI8L2NvZGU+LgotCSAqLwotCXB1YmxpYyBUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yKEl0ZXJhdG9yPD8gZXh0ZW5kcyBFMT4gbmVzdGVkSXRlcmF0b3IpIHsKLQkJdGhpcyhuZXN0ZWRJdGVyYXRvciwgVHJhbnNmb3JtZXIuRGlzYWJsZWQuPEUxLCBFMj5pbnN0YW5jZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gaXRlcmF0b3Igd2l0aCB0aGUgc3BlY2lmaWVkIG5lc3RlZCBpdGVyYXRvcgotCSAqIGFuZCB0cmFuc2Zvcm1lci4KLQkgKi8KLQlwdWJsaWMgVHJhbnNmb3JtYXRpb25JdGVyYXRvcihJdGVyYXRvcjw/IGV4dGVuZHMgRTE+IG5lc3RlZEl0ZXJhdG9yLCBUcmFuc2Zvcm1lcjxFMSwgPyBleHRlbmRzIEUyPiB0cmFuc2Zvcm1lcikgewotCQlzdXBlcigpOwotCQl0aGlzLm5lc3RlZEl0ZXJhdG9yID0gbmVzdGVkSXRlcmF0b3I7Ci0JCXRoaXMudHJhbnNmb3JtZXIgPSB0cmFuc2Zvcm1lcjsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBoYXNOZXh0KCkgewotCQkvLyBkZWxlZ2F0ZSB0byB0aGUgbmVzdGVkIGl0ZXJhdG9yCi0JCXJldHVybiB0aGlzLm5lc3RlZEl0ZXJhdG9yLmhhc05leHQoKTsKLQl9Ci0KLQlwdWJsaWMgRTIgbmV4dCgpIHsKLQkJLy8gdHJhbnNmb3JtIHRoZSBvYmplY3QgcmV0dXJuZWQgYnkgdGhlIG5lc3RlZCBpdGVyYXRvciBiZWZvcmUgcmV0dXJuaW5nIGl0Ci0JCXJldHVybiB0aGlzLnRyYW5zZm9ybSh0aGlzLm5lc3RlZEl0ZXJhdG9yLm5leHQoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQkvLyBkZWxlZ2F0ZSB0byB0aGUgbmVzdGVkIGl0ZXJhdG9yCi0JCXRoaXMubmVzdGVkSXRlcmF0b3IucmVtb3ZlKCk7Ci0JfQotCi0JLyoqCi0JICogVHJhbnNmb3JtIHRoZSBzcGVjaWZpZWQgb2JqZWN0IGFuZCByZXR1cm4gdGhlIHJlc3VsdC4KLQkgKi8KLQlwcm90ZWN0ZWQgRTIgdHJhbnNmb3JtKEUxIG5leHQpIHsKLQkJcmV0dXJuIHRoaXMudHJhbnNmb3JtZXIudHJhbnNmb3JtKG5leHQpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMubmVzdGVkSXRlcmF0b3IpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9UcmFuc2Zvcm1hdGlvbkxpc3RJdGVyYXRvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9UcmFuc2Zvcm1hdGlvbkxpc3RJdGVyYXRvci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwODdmYzExLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvVHJhbnNmb3JtYXRpb25MaXN0SXRlcmF0b3IuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEwOCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9yczsKLQotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuVHJhbnNmb3JtZXI7Ci0KLS8qKgotICogQSA8Y29kZT5UcmFuc2Zvcm1hdGlvbkxpc3RJdGVyYXRvcjwvY29kZT4gd3JhcHMgYW5vdGhlciA8Y29kZT5MaXN0SXRlcmF0b3I8L2NvZGU+Ci0gKiBhbmQgdHJhbnNmb3JtcyBpdHMgcmVzdWx0cyBmb3IgY2xpZW50IGNvbnN1bXB0aW9uLiBUbyB1c2UsIHN1cHBseSBhIAotICogPGNvZGU+VHJhbnNmb3JtZXI8L2NvZGU+IG9yIHN1YmNsYXNzIDxjb2RlPlRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8L2NvZGU+Ci0gKiBhbmQgb3ZlcnJpZGUgdGhlIDxjb2RlPnRyYW5zZm9ybShPYmplY3QpPC9jb2RlPiBtZXRob2QuCi0gKiAKLSAqIFRoZSBtZXRob2RzIDxjb2RlPnNldChPYmplY3QpPC9jb2RlPiBhbmQgPGNvZGU+YWRkKE9iamVjdCk8L2NvZGU+Ci0gKiBhcmUgbGVmdCB1bnN1cHBvcnRlZCBpbiB0aGlzIGNsYXNzLgotICovCi1wdWJsaWMgY2xhc3MgVHJhbnNmb3JtYXRpb25MaXN0SXRlcmF0b3I8RTEsIEUyPgotCWltcGxlbWVudHMgTGlzdEl0ZXJhdG9yPEUyPgotewotCXByaXZhdGUgZmluYWwgTGlzdEl0ZXJhdG9yPD8gZXh0ZW5kcyBFMT4gbmVzdGVkSXRlcmF0b3I7Ci0JcHJpdmF0ZSBmaW5hbCBUcmFuc2Zvcm1lcjxFMSwgPyBleHRlbmRzIEUyPiB0cmFuc2Zvcm1lcjsKLQotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGl0ZXJhdG9yIHdpdGggdGhlIHNwZWNpZmllZCBuZXN0ZWQgaXRlcmF0b3IKLQkgKiBhbmQgYSBkaXNhYmxlZCB0cmFuc2Zvcm1lci4KLQkgKiBVc2UgdGhpcyBjb25zdHJ1Y3RvciBpZiB5b3Ugd2FudCB0byBvdmVycmlkZSB0aGUKLQkgKiA8Y29kZT50cmFuc2Zvcm0oT2JqZWN0KTwvY29kZT4gbWV0aG9kIGluc3RlYWQgb2YgYnVpbGRpbmcKLQkgKiBhIDxjb2RlPlRyYW5zZm9ybWVyPC9jb2RlPi4KLQkgKi8KLQlwdWJsaWMgVHJhbnNmb3JtYXRpb25MaXN0SXRlcmF0b3IoTGlzdEl0ZXJhdG9yPD8gZXh0ZW5kcyBFMT4gbmVzdGVkSXRlcmF0b3IpIHsKLQkJdGhpcyhuZXN0ZWRJdGVyYXRvciwgVHJhbnNmb3JtZXIuRGlzYWJsZWQuPEUxLCBFMj5pbnN0YW5jZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gaXRlcmF0b3Igd2l0aCB0aGUgc3BlY2lmaWVkIG5lc3RlZCBpdGVyYXRvcgotCSAqIGFuZCB0cmFuc2Zvcm1lci4KLQkgKi8KLQlwdWJsaWMgVHJhbnNmb3JtYXRpb25MaXN0SXRlcmF0b3IoTGlzdEl0ZXJhdG9yPD8gZXh0ZW5kcyBFMT4gbmVzdGVkSXRlcmF0b3IsIFRyYW5zZm9ybWVyPEUxLCA/IGV4dGVuZHMgRTI+IHRyYW5zZm9ybWVyKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMubmVzdGVkSXRlcmF0b3IgPSBuZXN0ZWRJdGVyYXRvcjsKLQkJdGhpcy50cmFuc2Zvcm1lciA9IHRyYW5zZm9ybWVyOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGhhc05leHQoKSB7Ci0JCS8vIGRlbGVnYXRlIHRvIHRoZSBuZXN0ZWQgaXRlcmF0b3IKLQkJcmV0dXJuIHRoaXMubmVzdGVkSXRlcmF0b3IuaGFzTmV4dCgpOwotCX0KLQotCXB1YmxpYyBFMiBuZXh0KCkgewotCQkvLyB0cmFuc2Zvcm0gdGhlIG9iamVjdCByZXR1cm5lZCBieSB0aGUgbmVzdGVkIGl0ZXJhdG9yIGJlZm9yZSByZXR1cm5pbmcgaXQKLQkJcmV0dXJuIHRoaXMudHJhbnNmb3JtKHRoaXMubmVzdGVkSXRlcmF0b3IubmV4dCgpKTsKLQl9Ci0KLQlwdWJsaWMgaW50IG5leHRJbmRleCgpIHsKLQkJLy8gZGVsZWdhdGUgdG8gdGhlIG5lc3RlZCBpdGVyYXRvcgotCQlyZXR1cm4gdGhpcy5uZXN0ZWRJdGVyYXRvci5uZXh0SW5kZXgoKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBoYXNQcmV2aW91cygpIHsKLQkJLy8gZGVsZWdhdGUgdG8gdGhlIG5lc3RlZCBpdGVyYXRvcgotCQlyZXR1cm4gdGhpcy5uZXN0ZWRJdGVyYXRvci5oYXNQcmV2aW91cygpOwotCX0KLQotCXB1YmxpYyBFMiBwcmV2aW91cygpIHsKLQkJLy8gdHJhbnNmb3JtIHRoZSBvYmplY3QgcmV0dXJuZWQgYnkgdGhlIG5lc3RlZCBpdGVyYXRvciBiZWZvcmUgcmV0dXJuaW5nIGl0Ci0JCXJldHVybiB0aGlzLnRyYW5zZm9ybSh0aGlzLm5lc3RlZEl0ZXJhdG9yLnByZXZpb3VzKCkpOwotCX0KLQotCXB1YmxpYyBpbnQgcHJldmlvdXNJbmRleCgpIHsKLQkJLy8gZGVsZWdhdGUgdG8gdGhlIG5lc3RlZCBpdGVyYXRvcgotCQlyZXR1cm4gdGhpcy5uZXN0ZWRJdGVyYXRvci5wcmV2aW91c0luZGV4KCk7Ci0JfQotCi0JcHVibGljIHZvaWQgYWRkKEUyIG8pIHsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0KEUyIG8pIHsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQkvLyBkZWxlZ2F0ZSB0byB0aGUgbmVzdGVkIGl0ZXJhdG9yCi0JCXRoaXMubmVzdGVkSXRlcmF0b3IucmVtb3ZlKCk7Ci0JfQotCi0JLyoqCi0JICogVHJhbnNmb3JtIHRoZSBzcGVjaWZpZWQgb2JqZWN0IGFuZCByZXR1cm4gdGhlIHJlc3VsdC4KLQkgKi8KLQlwcm90ZWN0ZWQgRTIgdHJhbnNmb3JtKEUxIG5leHQpIHsKLQkJcmV0dXJuIHRoaXMudHJhbnNmb3JtZXIudHJhbnNmb3JtKG5leHQpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMubmVzdGVkSXRlcmF0b3IpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9UcmVlSXRlcmF0b3IuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9pdGVyYXRvcnMvVHJlZUl0ZXJhdG9yLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQ3MDc0ZDcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL2l0ZXJhdG9ycy9UcmVlSXRlcmF0b3IuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE5NCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9yczsKLQotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlua2VkTGlzdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotLyoqCi0gKiBBIDxjb2RlPlRyZWVJdGVyYXRvcjwvY29kZT4gc2ltcGxpZmllcyB0aGUgdHJhdmVyc2FsIG9mIGEKLSAqIHRyZWUgb2Ygb2JqZWN0cywgd2hlcmUgdGhlIG9iamVjdHMnIHByb3RvY29sKHMpIHByb3ZpZGVzCi0gKiBhIG1ldGhvZCBmb3IgZ2V0dGluZyB0aGUgaW1tZWRpYXRlIGNoaWxkcmVuIG9mIHRoZSBnaXZlbgotICogbm9kZSBidXQgZG9lcyBub3QgcHJvdmlkZSBhIG1ldGhvZCBmb3IgZ2V0dGluZyBhbGwgdGhlCi0gKiBkZXNjZW5kYW50cyAoY2hpbGRyZW4sIGdyYW5kY2hpbGRyZW4sIGV0Yy4pIG9mIHRoZSBnaXZlbiBub2RlLgotICogPHA+Ci0gKiBUbyB1c2UsIHN1cHBseTo8dWw+Ci0gKiA8bGk+IGVpdGhlciB0aGUgcm9vdCBlbGVtZW50IG9mIHRoZSB0cmVlIG9yLCBpZiB0aGUgdHJlZSBoYXMKLSAqIG11bHRpcGxlIHJvb3RzLCBhbiA8Y29kZT5JdGVyYXRvcjwvY29kZT4gb3ZlciB0aGUgc2V0IG9mIHJvb3RzCi0gKiA8bGk+IGEgPGNvZGU+TWlkd2lmZTwvY29kZT4gdGhhdCBkZWxpdmVycyB0aGUgY2hpbGRyZW4KLSAqIG9mIGVhY2ggY2hpbGQKLSAqIChhbHRlcm5hdGl2ZWx5LCBzdWJjbGFzcyA8Y29kZT5UcmVlSXRlcmF0b3I8L2NvZGU+Ci0gKiBhbmQgb3ZlcnJpZGUgdGhlIDxjb2RlPmNoaWxkcmVuKE9iamVjdCk8L2NvZGU+IG1ldGhvZCkKLSAqIDwvdWw+Ci0gKiA8cD4KLSAqLwotcHVibGljIGNsYXNzIFRyZWVJdGVyYXRvcjxFPgotCWltcGxlbWVudHMgSXRlcmF0b3I8RT4KLXsKLQlwcml2YXRlIGZpbmFsIExpbmtlZExpc3Q8SXRlcmF0b3I8PyBleHRlbmRzIEU+PiBpdGVyYXRvcnM7Ci0JcHJpdmF0ZSBmaW5hbCBNaWR3aWZlPEU+IG1pZHdpZmU7Ci0JcHJpdmF0ZSBJdGVyYXRvcjw/IGV4dGVuZHMgRT4gY3VycmVudEl0ZXJhdG9yOwotCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gaXRlcmF0b3Igd2l0aCB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24gb2Ygcm9vdHMKLQkgKiBhbmQgYSBkaXNhYmxlZCBtaWR3aWZlLgotCSAqIFVzZSB0aGlzIGNvbnN0cnVjdG9yIGlmIHlvdSB3YW50IHRvIG92ZXJyaWRlIHRoZQotCSAqIDxjb2RlPmNoaWxkcmVuKE9iamVjdCk8L2NvZGU+IG1ldGhvZCBpbnN0ZWFkIG9mIGJ1aWxkaW5nCi0JICogYSA8Y29kZT5NaWR3aWZlPC9jb2RlPi4KLQkgKi8KLQlwdWJsaWMgVHJlZUl0ZXJhdG9yKEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiByb290cykgewotCQl0aGlzKHJvb3RzLCBNaWR3aWZlLkRpc2FibGVkLjxFPmluc3RhbmNlKCkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBpdGVyYXRvciB3aXRoIHRoZSBzcGVjaWZpZWQgcm9vdAotCSAqIGFuZCBhIGRpc2FibGVkIG1pZHdpZmUuCi0JICogVXNlIHRoaXMgY29uc3RydWN0b3IgaWYgeW91IHdhbnQgdG8gb3ZlcnJpZGUgdGhlCi0JICogPGNvZGU+Y2hpbGRyZW4oT2JqZWN0KTwvY29kZT4gbWV0aG9kIGluc3RlYWQgb2YgYnVpbGRpbmcKLQkgKiBhIDxjb2RlPk1pZHdpZmU8L2NvZGU+LgotCSAqLwotCXB1YmxpYyBUcmVlSXRlcmF0b3IoRSByb290KSB7Ci0JCXRoaXMocm9vdCwgTWlkd2lmZS5EaXNhYmxlZC48RT5pbnN0YW5jZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gaXRlcmF0b3Igd2l0aCB0aGUgc3BlY2lmaWVkIHJvb3QKLQkgKiBhbmQgbWlkd2lmZS4KLQkgKi8KLQlwdWJsaWMgVHJlZUl0ZXJhdG9yKEUgcm9vdCwgTWlkd2lmZTxFPiBtaWR3aWZlKSB7Ci0JCXRoaXMobmV3IFNpbmdsZUVsZW1lbnRJdGVyYXRvcjxFPihyb290KSwgbWlkd2lmZSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGl0ZXJhdG9yIHdpdGggdGhlIHNwZWNpZmllZCByb290cwotCSAqIGFuZCBtaWR3aWZlLgotCSAqLwotCXB1YmxpYyBUcmVlSXRlcmF0b3IoSXRlcmF0b3I8PyBleHRlbmRzIEU+IHJvb3RzLCBNaWR3aWZlPEU+IG1pZHdpZmUpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5jdXJyZW50SXRlcmF0b3IgPSByb290czsKLQkJLy8gdXNlIGEgTGlua2VkTGlzdCBzaW5jZSB3ZSB3aWxsIGJlIHB1bGxpbmcgb2ZmIHRoZSBmcm9udCBhbmQgYWRkaW5nIHRvIHRoZSBlbmQKLQkJdGhpcy5pdGVyYXRvcnMgPSBuZXcgTGlua2VkTGlzdDxJdGVyYXRvcjw/IGV4dGVuZHMgRT4+KCk7Ci0JCXRoaXMubWlkd2lmZSA9IG1pZHdpZmU7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaGFzTmV4dCgpIHsKLQkJaWYgKHRoaXMuY3VycmVudEl0ZXJhdG9yLmhhc05leHQoKSkgewotCQkJcmV0dXJuIHRydWU7Ci0JCX0KLQkJZm9yIChJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlcmF0b3IgOiB0aGlzLml0ZXJhdG9ycykgewotCQkJaWYgKGl0ZXJhdG9yLmhhc05leHQoKSkgewotCQkJCXJldHVybiB0cnVlOwotCQkJfQotCQl9Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQlwdWJsaWMgRSBuZXh0KCkgewotCQlpZiAodGhpcy5jdXJyZW50SXRlcmF0b3IuaGFzTmV4dCgpKSB7Ci0JCQlyZXR1cm4gdGhpcy5uZXh0SW50ZXJuYWwoKTsKLQkJfQotCQlmb3IgKEl0ZXJhdG9yPEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPj4gc3RyZWFtID0gdGhpcy5pdGVyYXRvcnMuaXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQl0aGlzLmN1cnJlbnRJdGVyYXRvciA9IHN0cmVhbS5uZXh0KCk7Ci0JCQlpZiAodGhpcy5jdXJyZW50SXRlcmF0b3IuaGFzTmV4dCgpKSB7Ci0JCQkJYnJlYWs7Ci0JCQl9Ci0JCQlzdHJlYW0ucmVtb3ZlKCk7Ci0JCX0KLQkJcmV0dXJuIHRoaXMubmV4dEludGVybmFsKCk7Ci0JfQotCi0JLyoqCi0JICogRmV0Y2ggdGhlIGNoaWxkcmVuIG9mIHRoZSBuZXh0IG5vZGUgYmVmb3JlIHJldHVybmluZyBpdC4KLQkgKi8KLQlwcml2YXRlIEUgbmV4dEludGVybmFsKCkgewotCQlFIG5leHQgPSB0aGlzLmN1cnJlbnRJdGVyYXRvci5uZXh0KCk7Ci0JCXRoaXMuaXRlcmF0b3JzLmFkZCh0aGlzLmNoaWxkcmVuKG5leHQpKTsKLQkJcmV0dXJuIG5leHQ7Ci0JfQotCi0JcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQl0aGlzLmN1cnJlbnRJdGVyYXRvci5yZW1vdmUoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGltbWVkaWF0ZSBjaGlsZHJlbiBvZiB0aGUgc3BlY2lmaWVkIG9iamVjdC4KLQkgKi8KLQlwcm90ZWN0ZWQgSXRlcmF0b3I8PyBleHRlbmRzIEU+IGNoaWxkcmVuKEUgbmV4dCkgewotCQlyZXR1cm4gdGhpcy5taWR3aWZlLmNoaWxkcmVuKG5leHQpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuY3VycmVudEl0ZXJhdG9yKTsKLQl9Ci0KLQotCS8vKioqKioqKioqKiBpbm5lciBjbGFzc2VzICoqKioqKioqKioKLQotCS8qKgotCSAqIFVzZWQgYnkgPGNvZGU+VHJlZUl0ZXJhdG9yPC9jb2RlPiB0byByZXRyaWV2ZQotCSAqIHRoZSBpbW1lZGlhdGUgY2hpbGRyZW4gb2YgYSBub2RlIGluIHRoZSB0cmVlLgotCSAqLwotCXB1YmxpYyBpbnRlcmZhY2UgTWlkd2lmZTxUPiB7Ci0KLQkJLyoqCi0JCSAqIFJldHVybiB0aGUgaW1tZWRpYXRlIGNoaWxkcmVuIG9mIHRoZSBzcGVjaWZpZWQgb2JqZWN0LgotCQkgKi8KLQkJSXRlcmF0b3I8PyBleHRlbmRzIFQ+IGNoaWxkcmVuKFQgbyk7Ci0KLQotCQlmaW5hbCBjbGFzcyBOdWxsPFM+IGltcGxlbWVudHMgTWlkd2lmZTxTPiB7Ci0JCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgTWlkd2lmZSBJTlNUQU5DRSA9IG5ldyBOdWxsKCk7Ci0JCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJCXB1YmxpYyBzdGF0aWMgPFI+IE1pZHdpZmU8Uj4gaW5zdGFuY2UoKSB7Ci0JCQkJcmV0dXJuIElOU1RBTkNFOwotCQkJfQotCQkJLy8gZW5zdXJlIHNpbmdsZSBpbnN0YW5jZQotCQkJcHJpdmF0ZSBOdWxsKCkgewotCQkJCXN1cGVyKCk7Ci0JCQl9Ci0JCQkvLyByZXR1cm4gbm8gbmVpZ2hib3JzCi0JCQlwdWJsaWMgSXRlcmF0b3I8Uz4gY2hpbGRyZW4oUyBuZXh0KSB7Ci0JCQkJcmV0dXJuIEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gIlRyZWVJdGVyYXRvci5NaWR3aWZlLk51bGwiOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCX0KLQotCQkvKiogVGhlIG1pZHdpZmUgdXNlZCB3aGVuIHRoZSAjY2hpbGRyZW4oT2JqZWN0KSBtZXRob2QgaXMgb3ZlcnJpZGRlbi4gKi8KLQkJZmluYWwgY2xhc3MgRGlzYWJsZWQ8Uz4gaW1wbGVtZW50cyBNaWR3aWZlPFM+IHsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBNaWR3aWZlIElOU1RBTkNFID0gbmV3IERpc2FibGVkKCk7Ci0JCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJCXB1YmxpYyBzdGF0aWMgPFI+IE1pZHdpZmU8Uj4gaW5zdGFuY2UoKSB7Ci0JCQkJcmV0dXJuIElOU1RBTkNFOwotCQkJfQotCQkJLy8gZW5zdXJlIHNpbmdsZSBpbnN0YW5jZQotCQkJcHJpdmF0ZSBEaXNhYmxlZCgpIHsKLQkJCQlzdXBlcigpOwotCQkJfQotCQkJLy8gdGhyb3cgYW4gZXhjZXB0aW9uCi0JCQlwdWJsaWMgSXRlcmF0b3I8Uz4gY2hpbGRyZW4oUyBuZXh0KSB7Ci0JCQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7ICAvLyBUcmVlSXRlcmF0b3IuY2hpbGRyZW4oT2JqZWN0KSB3YXMgbm90IGltcGxlbWVudGVkCi0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJUcmVlSXRlcmF0b3IuTWlkd2lmZS5EaXNhYmxlZCI7IC8vJE5PTi1OTFMtMSQKLQkJCX0KLQkJfQotCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvQWJzdHJhY3RNb2RlbC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL0Fic3RyYWN0TW9kZWwuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzU0ZDkwMC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvQWJzdHJhY3RNb2RlbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzI2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWw7Ci0KLWltcG9ydCBqYXZhLmlvLlNlcmlhbGl6YWJsZTsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5Nb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Db2xsZWN0aW9uQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuTGlzdENoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlByb3BlcnR5Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuU3RhdGVDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5UcmVlQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkxpc3RDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlN0YXRlQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuVHJlZUNoYW5nZUxpc3RlbmVyOwotCi0vKioKLSAqIENvbnZlbmllbmNlIGltcGxlbWVudGF0aW9uIG9mIE1vZGVsIHByb3RvY29sLgotICovCi1wdWJsaWMgYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3RNb2RlbCBpbXBsZW1lbnRzIE1vZGVsLCBTZXJpYWxpemFibGUgewotCS8qKgotCSAqIERlbGVnYXRlIHN0YXRlL3Byb3BlcnR5L2NvbGxlY3Rpb24vbGlzdC90cmVlIGNoYW5nZSBzdXBwb3J0IHRvIHRoaXMKLQkgKiBoZWxwZXIgb2JqZWN0LiBUaGUgY2hhbmdlIHN1cHBvcnQgb2JqZWN0IGlzICJsYXp5LWluaXRpYWxpemVkIi4KLQkgKi8KLQlwcml2YXRlIENoYW5nZVN1cHBvcnQgY2hhbmdlU3VwcG9ydDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMvaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JLyoqCi0JICogRGVmYXVsdCBjb25zdHJ1Y3Rvci4KLQkgKiBUaGlzIHdpbGwgY2FsbCAjaW5pdGlhbGl6ZSgpIG9uIHRoZSBuZXdseS1jcmVhdGVkIGluc3RhbmNlLgotCSAqLwotCXByb3RlY3RlZCBBYnN0cmFjdE1vZGVsKCkgewotCQlzdXBlcigpOwotCX0KLQotCS8qKgotCSAqIFRoaXMgYWNjZXNzb3Igd2lsbCBidWlsZCB0aGUgY2hhbmdlIHN1cHBvcnQgd2hlbiByZXF1aXJlZC4KLQkgKi8KLQlwcm90ZWN0ZWQgc3luY2hyb25pemVkIENoYW5nZVN1cHBvcnQgZ2V0Q2hhbmdlU3VwcG9ydCgpIHsKLQkJaWYgKHRoaXMuY2hhbmdlU3VwcG9ydCA9PSBudWxsKSB7Ci0JCQl0aGlzLmNoYW5nZVN1cHBvcnQgPSB0aGlzLmJ1aWxkQ2hhbmdlU3VwcG9ydCgpOwotCQl9Ci0JCXJldHVybiB0aGlzLmNoYW5nZVN1cHBvcnQ7Ci0JfQotCi0JLyoqCi0JICogQWxsb3cgc3ViY2xhc3NlcyB0byB0d2VhayB0aGUgY2hhbmdlIHN1cHBvcnQgdXNlZC4KLQkgKi8KLQlwcm90ZWN0ZWQgQ2hhbmdlU3VwcG9ydCBidWlsZENoYW5nZVN1cHBvcnQoKSB7Ci0JCXJldHVybiBuZXcgQ2hhbmdlU3VwcG9ydCh0aGlzKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogc3RhdGUgY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIGFkZFN0YXRlQ2hhbmdlTGlzdGVuZXIoU3RhdGVDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5hZGRTdGF0ZUNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQl9Ci0KLQlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgcmVtb3ZlU3RhdGVDaGFuZ2VMaXN0ZW5lcihTdGF0ZUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLnJlbW92ZVN0YXRlQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZXJlIGFyZSBhbnkgc3RhdGUgY2hhbmdlIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBoYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmhhc0FueVN0YXRlQ2hhbmdlTGlzdGVuZXJzKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlcmUgYXJlIG5vIHN0YXRlIGNoYW5nZSBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIGJvb2xlYW4gaGFzTm9TdGF0ZUNoYW5nZUxpc3RlbmVycygpIHsKLQkJcmV0dXJuICEgdGhpcy5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCB2b2lkIGZpcmVTdGF0ZUNoYW5nZWQoU3RhdGVDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlU3RhdGVDaGFuZ2VkKGV2ZW50KTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlU3RhdGVDaGFuZ2VkKCkgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlU3RhdGVDaGFuZ2VkKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHByb3BlcnR5IGNoYW5nZSBzdXBwb3J0ICoqKioqKioqKioKLQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCBhZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JfQotCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIGFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoU3RyaW5nIHByb3BlcnR5TmFtZSwgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHByb3BlcnR5TmFtZSwgbGlzdGVuZXIpOwotCX0KLQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCByZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JfQotCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIHJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoU3RyaW5nIHByb3BlcnR5TmFtZSwgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHByb3BlcnR5TmFtZSwgbGlzdGVuZXIpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZXJlIGFyZSBhbnkgcHJvcGVydHkgY2hhbmdlIGxpc3RlbmVycyBmb3IgYSBzcGVjaWZpYyBwcm9wZXJ0eS4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBoYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhTdHJpbmcgcHJvcGVydHlOYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhwcm9wZXJ0eU5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZXJlIGFyZSBhbnkgcHJvcGVydHkgY2hhbmdlIGxpc3RlbmVycyBmb3IgYSBzcGVjaWZpYyBwcm9wZXJ0eS4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBoYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFN0cmluZyBwcm9wZXJ0eU5hbWUpIHsKLQkJcmV0dXJuICEgdGhpcy5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhwcm9wZXJ0eU5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZXJlIGFyZSBhbnkgcHJvcGVydHkgY2hhbmdlIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBoYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycygpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlcmUgYXJlIGFueSBwcm9wZXJ0eSBjaGFuZ2UgbGlzdGVuZXJzLgotCSAqLwotCXB1YmxpYyBib29sZWFuIGhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoKSB7Ci0JCXJldHVybiAhIHRoaXMuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlUHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZVByb3BlcnR5Q2hhbmdlZChldmVudCk7Ci0JfQotCi0JcHJvdGVjdGVkIGZpbmFsIHZvaWQgZmlyZVByb3BlcnR5Q2hhbmdlZChTdHJpbmcgcHJvcGVydHlOYW1lLCBPYmplY3Qgb2xkVmFsdWUsIE9iamVjdCBuZXdWYWx1ZSkgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlUHJvcGVydHlDaGFuZ2VkKHByb3BlcnR5TmFtZSwgb2xkVmFsdWUsIG5ld1ZhbHVlKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlUHJvcGVydHlDaGFuZ2VkKFN0cmluZyBwcm9wZXJ0eU5hbWUsIGludCBvbGRWYWx1ZSwgaW50IG5ld1ZhbHVlKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmZpcmVQcm9wZXJ0eUNoYW5nZWQocHJvcGVydHlOYW1lLCBvbGRWYWx1ZSwgbmV3VmFsdWUpOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCB2b2lkIGZpcmVQcm9wZXJ0eUNoYW5nZWQoU3RyaW5nIHByb3BlcnR5TmFtZSwgYm9vbGVhbiBvbGRWYWx1ZSwgYm9vbGVhbiBuZXdWYWx1ZSkgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlUHJvcGVydHlDaGFuZ2VkKHByb3BlcnR5TmFtZSwgb2xkVmFsdWUsIG5ld1ZhbHVlKTsKLQl9Ci0KLQkvKioKLQkgKiBpbXBsaWVkICdudWxsJyBvbGQgdmFsdWUKLQkgKi8KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlUHJvcGVydHlDaGFuZ2VkKFN0cmluZyBwcm9wZXJ0eU5hbWUsIE9iamVjdCBuZXdWYWx1ZSkgewotCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQocHJvcGVydHlOYW1lLCBudWxsLCBuZXdWYWx1ZSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbGxlY3Rpb24gY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIGFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQl9Ci0KLQlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKFN0cmluZyBjb2xsZWN0aW9uTmFtZSwgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihjb2xsZWN0aW9uTmFtZSwgbGlzdGVuZXIpOwotCX0KLQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCByZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLnJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JfQotCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIHJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihTdHJpbmcgY29sbGVjdGlvbk5hbWUsIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoY29sbGVjdGlvbk5hbWUsIGxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGVyZSBhcmUgYW55IGNvbGxlY3Rpb24gY2hhbmdlIGxpc3RlbmVycyBmb3IgYSBzcGVjaWZpYyBjb2xsZWN0aW9uLgotCSAqLwotCXB1YmxpYyBib29sZWFuIGhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKGNvbGxlY3Rpb25OYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGVyZSBhcmUgYW55IGNvbGxlY3Rpb24gY2hhbmdlIGxpc3RlbmVycyBmb3IgYSBzcGVjaWZpYyBjb2xsZWN0aW9uLgotCSAqLwotCXB1YmxpYyBib29sZWFuIGhhc05vQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJcmV0dXJuICEgdGhpcy5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKGNvbGxlY3Rpb25OYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGVyZSBhcmUgYW55IGNvbGxlY3Rpb24gY2hhbmdlIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBoYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycygpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZXJlIGFyZSBhbnkgY29sbGVjdGlvbiBjaGFuZ2UgbGlzdGVuZXJzLgotCSAqLwotCXB1YmxpYyBib29sZWFuIGhhc05vQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycygpIHsKLQkJcmV0dXJuICEgdGhpcy5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKCk7Ci0JfQotCi0JcHJvdGVjdGVkIGZpbmFsIHZvaWQgZmlyZUl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmZpcmVJdGVtc0FkZGVkKGV2ZW50KTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlSXRlbXNBZGRlZChTdHJpbmcgY29sbGVjdGlvbk5hbWUsIENvbGxlY3Rpb248Pz4gYWRkZWRJdGVtcykgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlSXRlbXNBZGRlZChjb2xsZWN0aW9uTmFtZSwgYWRkZWRJdGVtcyk7Ci0JfQotCi0JcHJvdGVjdGVkIGZpbmFsIHZvaWQgZmlyZUl0ZW1BZGRlZChTdHJpbmcgY29sbGVjdGlvbk5hbWUsIE9iamVjdCBhZGRlZEl0ZW0pIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZUl0ZW1BZGRlZChjb2xsZWN0aW9uTmFtZSwgYWRkZWRJdGVtKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlSXRlbXNSZW1vdmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlSXRlbXNSZW1vdmVkKGV2ZW50KTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlSXRlbXNSZW1vdmVkKFN0cmluZyBjb2xsZWN0aW9uTmFtZSwgQ29sbGVjdGlvbjw/PiByZW1vdmVkSXRlbXMpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZUl0ZW1zUmVtb3ZlZChjb2xsZWN0aW9uTmFtZSwgcmVtb3ZlZEl0ZW1zKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlSXRlbVJlbW92ZWQoU3RyaW5nIGNvbGxlY3Rpb25OYW1lLCBPYmplY3QgcmVtb3ZlZEl0ZW0pIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZUl0ZW1SZW1vdmVkKGNvbGxlY3Rpb25OYW1lLCByZW1vdmVkSXRlbSk7Ci0JfQotCi0JcHJvdGVjdGVkIGZpbmFsIHZvaWQgZmlyZUNvbGxlY3Rpb25DbGVhcmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlQ29sbGVjdGlvbkNsZWFyZWQoZXZlbnQpOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCB2b2lkIGZpcmVDb2xsZWN0aW9uQ2xlYXJlZChTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZUNvbGxlY3Rpb25DbGVhcmVkKGNvbGxlY3Rpb25OYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlQ29sbGVjdGlvbkNoYW5nZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmZpcmVDb2xsZWN0aW9uQ2hhbmdlZChldmVudCk7Ci0JfQotCi0JcHJvdGVjdGVkIGZpbmFsIHZvaWQgZmlyZUNvbGxlY3Rpb25DaGFuZ2VkKFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlQ29sbGVjdGlvbkNoYW5nZWQoY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCXByb3RlY3RlZCA8RT4gYm9vbGVhbiBhZGRJdGVtVG9Db2xsZWN0aW9uKEUgaXRlbSwgQ29sbGVjdGlvbjxFPiBjb2xsZWN0aW9uLCBTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZEl0ZW1Ub0NvbGxlY3Rpb24oaXRlbSwgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCXByb3RlY3RlZCA8RT4gYm9vbGVhbiBhZGRJdGVtc1RvQ29sbGVjdGlvbihFW10gaXRlbXMsIENvbGxlY3Rpb248RT4gY29sbGVjdGlvbiwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5hZGRJdGVtc1RvQ29sbGVjdGlvbihpdGVtcywgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCXByb3RlY3RlZCA8RT4gYm9vbGVhbiBhZGRJdGVtc1RvQ29sbGVjdGlvbihDb2xsZWN0aW9uPD8gZXh0ZW5kcyBFPiBpdGVtcywgQ29sbGVjdGlvbjxFPiBjb2xsZWN0aW9uLCBTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZEl0ZW1zVG9Db2xsZWN0aW9uKGl0ZW1zLCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIDxFPiBib29sZWFuIGFkZEl0ZW1zVG9Db2xsZWN0aW9uKEl0ZXJhYmxlPD8gZXh0ZW5kcyBFPiBpdGVtcywgQ29sbGVjdGlvbjxFPiBjb2xsZWN0aW9uLCBTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZEl0ZW1zVG9Db2xsZWN0aW9uKGl0ZW1zLCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIDxFPiBib29sZWFuIGFkZEl0ZW1zVG9Db2xsZWN0aW9uKEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVtcywgQ29sbGVjdGlvbjxFPiBjb2xsZWN0aW9uLCBTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZEl0ZW1zVG9Db2xsZWN0aW9uKGl0ZW1zLCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIGJvb2xlYW4gcmVtb3ZlSXRlbUZyb21Db2xsZWN0aW9uKE9iamVjdCBpdGVtLCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQlyZXR1cm4gdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkucmVtb3ZlSXRlbUZyb21Db2xsZWN0aW9uKGl0ZW0sIGNvbGxlY3Rpb24sIGNvbGxlY3Rpb25OYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgYm9vbGVhbiByZW1vdmVJdGVtc0Zyb21Db2xsZWN0aW9uKE9iamVjdFtdIGl0ZW1zLCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQlyZXR1cm4gdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkucmVtb3ZlSXRlbXNGcm9tQ29sbGVjdGlvbihpdGVtcywgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCXByb3RlY3RlZCBib29sZWFuIHJlbW92ZUl0ZW1zRnJvbUNvbGxlY3Rpb24oQ29sbGVjdGlvbjw/PiBpdGVtcywgQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uLCBTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLnJlbW92ZUl0ZW1zRnJvbUNvbGxlY3Rpb24oaXRlbXMsIGNvbGxlY3Rpb24sIGNvbGxlY3Rpb25OYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgYm9vbGVhbiByZW1vdmVJdGVtc0Zyb21Db2xsZWN0aW9uKEl0ZXJhYmxlPD8+IGl0ZW1zLCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQlyZXR1cm4gdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkucmVtb3ZlSXRlbXNGcm9tQ29sbGVjdGlvbihpdGVtcywgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCXByb3RlY3RlZCBib29sZWFuIHJlbW92ZUl0ZW1zRnJvbUNvbGxlY3Rpb24oSXRlcmF0b3I8Pz4gaXRlbXMsIENvbGxlY3Rpb248Pz4gY29sbGVjdGlvbiwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5yZW1vdmVJdGVtc0Zyb21Db2xsZWN0aW9uKGl0ZW1zLCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIGJvb2xlYW4gcmV0YWluSXRlbXNJbkNvbGxlY3Rpb24oT2JqZWN0W10gaXRlbXMsIENvbGxlY3Rpb248Pz4gY29sbGVjdGlvbiwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5yZXRhaW5JdGVtc0luQ29sbGVjdGlvbihpdGVtcywgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCXByb3RlY3RlZCBib29sZWFuIHJldGFpbkl0ZW1zSW5Db2xsZWN0aW9uKENvbGxlY3Rpb248Pz4gaXRlbXMsIENvbGxlY3Rpb248Pz4gY29sbGVjdGlvbiwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5yZXRhaW5JdGVtc0luQ29sbGVjdGlvbihpdGVtcywgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCXByb3RlY3RlZCBib29sZWFuIHJldGFpbkl0ZW1zSW5Db2xsZWN0aW9uKEl0ZXJhYmxlPD8+IGl0ZW1zLCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQlyZXR1cm4gdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkucmV0YWluSXRlbXNJbkNvbGxlY3Rpb24oaXRlbXMsIGNvbGxlY3Rpb24sIGNvbGxlY3Rpb25OYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgYm9vbGVhbiByZXRhaW5JdGVtc0luQ29sbGVjdGlvbihJdGVyYXRvcjw/PiBpdGVtcywgQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uLCBTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLnJldGFpbkl0ZW1zSW5Db2xsZWN0aW9uKGl0ZW1zLCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIGJvb2xlYW4gY2xlYXJDb2xsZWN0aW9uKENvbGxlY3Rpb248Pz4gY29sbGVjdGlvbiwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5jbGVhckNvbGxlY3Rpb24oY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCXByb3RlY3RlZCA8RT4gYm9vbGVhbiBzeW5jaHJvbml6ZUNvbGxlY3Rpb24oQ29sbGVjdGlvbjxFPiBuZXdDb2xsZWN0aW9uLCBDb2xsZWN0aW9uPEU+IGNvbGxlY3Rpb24sIFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQlyZXR1cm4gdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuc3luY2hyb25pemVDb2xsZWN0aW9uKG5ld0NvbGxlY3Rpb24sIGNvbGxlY3Rpb24sIGNvbGxlY3Rpb25OYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgPEU+IGJvb2xlYW4gc3luY2hyb25pemVDb2xsZWN0aW9uKEl0ZXJhdG9yPEU+IG5ld0NvbGxlY3Rpb24sIENvbGxlY3Rpb248RT4gY29sbGVjdGlvbiwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5zeW5jaHJvbml6ZUNvbGxlY3Rpb24obmV3Q29sbGVjdGlvbiwgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBsaXN0IGNoYW5nZSBzdXBwb3J0ICoqKioqKioqKioKLQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCBhZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JfQotCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIGFkZExpc3RDaGFuZ2VMaXN0ZW5lcihTdHJpbmcgbGlzdE5hbWUsIExpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIobGlzdE5hbWUsIGxpc3RlbmVyKTsKLQl9Ci0KLQlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgcmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKExpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCX0KLQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCByZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoU3RyaW5nIGxpc3ROYW1lLCBMaXN0Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKGxpc3ROYW1lLCBsaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlcmUgYXJlIGFueSBsaXN0IGNoYW5nZSBsaXN0ZW5lcnMgZm9yIGEgc3BlY2lmaWMgbGlzdC4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBoYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKFN0cmluZyBsaXN0TmFtZSkgewotCQlyZXR1cm4gdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlcmUgYXJlIGFueSBsaXN0IGNoYW5nZSBsaXN0ZW5lcnMgZm9yIGEgc3BlY2lmaWMgbGlzdC4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBoYXNOb0xpc3RDaGFuZ2VMaXN0ZW5lcnMoU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXJldHVybiAhIHRoaXMuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlcmUgYXJlIGFueSBsaXN0IGNoYW5nZSBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIGJvb2xlYW4gaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycygpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGVyZSBhcmUgYW55IGxpc3QgY2hhbmdlIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBoYXNOb0xpc3RDaGFuZ2VMaXN0ZW5lcnMoKSB7Ci0JCXJldHVybiAhIHRoaXMuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycygpOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCB2b2lkIGZpcmVJdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlSXRlbXNBZGRlZChldmVudCk7Ci0JfQotCi0JcHJvdGVjdGVkIGZpbmFsIHZvaWQgZmlyZUl0ZW1zQWRkZWQoU3RyaW5nIGxpc3ROYW1lLCBpbnQgaW5kZXgsIExpc3Q8Pz4gYWRkZWRJdGVtcykgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlSXRlbXNBZGRlZChsaXN0TmFtZSwgaW5kZXgsIGFkZGVkSXRlbXMpOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCB2b2lkIGZpcmVJdGVtQWRkZWQoU3RyaW5nIGxpc3ROYW1lLCBpbnQgaW5kZXgsIE9iamVjdCBhZGRlZEl0ZW0pIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZUl0ZW1BZGRlZChsaXN0TmFtZSwgaW5kZXgsIGFkZGVkSXRlbSk7Ci0JfQotCi0JcHJvdGVjdGVkIGZpbmFsIHZvaWQgZmlyZUl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZUl0ZW1zUmVtb3ZlZChldmVudCk7Ci0JfQotCi0JcHJvdGVjdGVkIGZpbmFsIHZvaWQgZmlyZUl0ZW1zUmVtb3ZlZChTdHJpbmcgbGlzdE5hbWUsIGludCBpbmRleCwgTGlzdDw/PiByZW1vdmVkSXRlbXMpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZUl0ZW1zUmVtb3ZlZChsaXN0TmFtZSwgaW5kZXgsIHJlbW92ZWRJdGVtcyk7Ci0JfQotCi0JcHJvdGVjdGVkIGZpbmFsIHZvaWQgZmlyZUl0ZW1SZW1vdmVkKFN0cmluZyBsaXN0TmFtZSwgaW50IGluZGV4LCBPYmplY3QgcmVtb3ZlZEl0ZW0pIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZUl0ZW1SZW1vdmVkKGxpc3ROYW1lLCBpbmRleCwgcmVtb3ZlZEl0ZW0pOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCB2b2lkIGZpcmVJdGVtc1JlcGxhY2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlSXRlbXNSZXBsYWNlZChldmVudCk7Ci0JfQotCi0JcHJvdGVjdGVkIGZpbmFsIDxFPiB2b2lkIGZpcmVJdGVtc1JlcGxhY2VkKFN0cmluZyBsaXN0TmFtZSwgaW50IGluZGV4LCBMaXN0PD8gZXh0ZW5kcyBFPiBuZXdJdGVtcywgTGlzdDxFPiByZXBsYWNlZEl0ZW1zKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmZpcmVJdGVtc1JlcGxhY2VkKGxpc3ROYW1lLCBpbmRleCwgbmV3SXRlbXMsIHJlcGxhY2VkSXRlbXMpOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCB2b2lkIGZpcmVJdGVtUmVwbGFjZWQoU3RyaW5nIGxpc3ROYW1lLCBpbnQgaW5kZXgsIE9iamVjdCBuZXdJdGVtLCBPYmplY3QgcmVwbGFjZWRJdGVtKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmZpcmVJdGVtUmVwbGFjZWQobGlzdE5hbWUsIGluZGV4LCBuZXdJdGVtLCByZXBsYWNlZEl0ZW0pOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCB2b2lkIGZpcmVJdGVtc01vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlSXRlbXNNb3ZlZChldmVudCk7Ci0JfQotCi0JcHJvdGVjdGVkIGZpbmFsIDxFPiB2b2lkIGZpcmVJdGVtc01vdmVkKFN0cmluZyBsaXN0TmFtZSwgaW50IHRhcmdldEluZGV4LCBpbnQgc291cmNlSW5kZXgsIGludCBsZW5ndGgpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZUl0ZW1zTW92ZWQobGlzdE5hbWUsIHRhcmdldEluZGV4LCBzb3VyY2VJbmRleCwgbGVuZ3RoKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlSXRlbU1vdmVkKFN0cmluZyBsaXN0TmFtZSwgaW50IHRhcmdldEluZGV4LCBpbnQgc291cmNlSW5kZXgpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZUl0ZW1Nb3ZlZChsaXN0TmFtZSwgdGFyZ2V0SW5kZXgsIHNvdXJjZUluZGV4KTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlTGlzdENsZWFyZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmZpcmVMaXN0Q2xlYXJlZChldmVudCk7Ci0JfQotCi0JcHJvdGVjdGVkIGZpbmFsIHZvaWQgZmlyZUxpc3RDbGVhcmVkKFN0cmluZyBsaXN0TmFtZSkgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlTGlzdENsZWFyZWQobGlzdE5hbWUpOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCB2b2lkIGZpcmVMaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZUxpc3RDaGFuZ2VkKGV2ZW50KTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlTGlzdENoYW5nZWQoU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmZpcmVMaXN0Q2hhbmdlZChsaXN0TmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIDxFPiB2b2lkIGFkZEl0ZW1Ub0xpc3QoaW50IGluZGV4LCBFIGl0ZW0sIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZEl0ZW1Ub0xpc3QoaW5kZXgsIGl0ZW0sIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgPEU+IGJvb2xlYW4gYWRkSXRlbVRvTGlzdChFIGl0ZW0sIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5hZGRJdGVtVG9MaXN0KGl0ZW0sIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgPEU+IGJvb2xlYW4gYWRkSXRlbXNUb0xpc3QoaW50IGluZGV4LCBFW10gaXRlbXMsIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5hZGRJdGVtc1RvTGlzdChpbmRleCwgaXRlbXMsIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgPEU+IGJvb2xlYW4gYWRkSXRlbXNUb0xpc3QoaW50IGluZGV4LCBDb2xsZWN0aW9uPD8gZXh0ZW5kcyBFPiBpdGVtcywgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZEl0ZW1zVG9MaXN0KGluZGV4LCBpdGVtcywgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCXByb3RlY3RlZCA8RT4gYm9vbGVhbiBhZGRJdGVtc1RvTGlzdChpbnQgaW5kZXgsIEl0ZXJhYmxlPD8gZXh0ZW5kcyBFPiBpdGVtcywgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZEl0ZW1zVG9MaXN0KGluZGV4LCBpdGVtcywgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCXByb3RlY3RlZCA8RT4gYm9vbGVhbiBhZGRJdGVtc1RvTGlzdChpbnQgaW5kZXgsIEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVtcywgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZEl0ZW1zVG9MaXN0KGluZGV4LCBpdGVtcywgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCXByb3RlY3RlZCA8RT4gYm9vbGVhbiBhZGRJdGVtc1RvTGlzdChFW10gaXRlbXMsIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5hZGRJdGVtc1RvTGlzdChpdGVtcywgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCXByb3RlY3RlZCA8RT4gYm9vbGVhbiBhZGRJdGVtc1RvTGlzdChDb2xsZWN0aW9uPD8gZXh0ZW5kcyBFPiBpdGVtcywgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZEl0ZW1zVG9MaXN0KGl0ZW1zLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIDxFPiBib29sZWFuIGFkZEl0ZW1zVG9MaXN0KEl0ZXJhYmxlPD8gZXh0ZW5kcyBFPiBpdGVtcywgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZEl0ZW1zVG9MaXN0KGl0ZW1zLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIDxFPiBib29sZWFuIGFkZEl0ZW1zVG9MaXN0KEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVtcywgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZEl0ZW1zVG9MaXN0KGl0ZW1zLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIDxFPiBFIHJlbW92ZUl0ZW1Gcm9tTGlzdChpbnQgaW5kZXgsIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5yZW1vdmVJdGVtRnJvbUxpc3QoaW5kZXgsIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgYm9vbGVhbiByZW1vdmVJdGVtRnJvbUxpc3QoT2JqZWN0IGl0ZW0sIExpc3Q8Pz4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5yZW1vdmVJdGVtRnJvbUxpc3QoaXRlbSwgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCXByb3RlY3RlZCA8RT4gTGlzdDxFPiByZW1vdmVJdGVtc0Zyb21MaXN0KGludCBpbmRleCwgaW50IGxlbmd0aCwgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLnJlbW92ZUl0ZW1zRnJvbUxpc3QoaW5kZXgsIGxlbmd0aCwgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCXByb3RlY3RlZCBib29sZWFuIHJlbW92ZUl0ZW1zRnJvbUxpc3QoT2JqZWN0W10gaXRlbXMsIExpc3Q8Pz4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5yZW1vdmVJdGVtc0Zyb21MaXN0KGl0ZW1zLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIGJvb2xlYW4gcmVtb3ZlSXRlbXNGcm9tTGlzdChDb2xsZWN0aW9uPD8+IGl0ZW1zLCBMaXN0PD8+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlyZXR1cm4gdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkucmVtb3ZlSXRlbXNGcm9tTGlzdChpdGVtcywgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCXByb3RlY3RlZCBib29sZWFuIHJlbW92ZUl0ZW1zRnJvbUxpc3QoSXRlcmFibGU8Pz4gaXRlbXMsIExpc3Q8Pz4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5yZW1vdmVJdGVtc0Zyb21MaXN0KGl0ZW1zLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIGJvb2xlYW4gcmVtb3ZlSXRlbXNGcm9tTGlzdChJdGVyYXRvcjw/PiBpdGVtcywgTGlzdDw/PiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLnJlbW92ZUl0ZW1zRnJvbUxpc3QoaXRlbXMsIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgYm9vbGVhbiByZXRhaW5JdGVtc0luTGlzdChPYmplY3RbXSBpdGVtcywgTGlzdDw/PiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLnJldGFpbkl0ZW1zSW5MaXN0KGl0ZW1zLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIGJvb2xlYW4gcmV0YWluSXRlbXNJbkxpc3QoQ29sbGVjdGlvbjw/PiBpdGVtcywgTGlzdDw/PiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLnJldGFpbkl0ZW1zSW5MaXN0KGl0ZW1zLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIGJvb2xlYW4gcmV0YWluSXRlbXNJbkxpc3QoSXRlcmFibGU8Pz4gaXRlbXMsIExpc3Q8Pz4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5yZXRhaW5JdGVtc0luTGlzdChpdGVtcywgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCXByb3RlY3RlZCBib29sZWFuIHJldGFpbkl0ZW1zSW5MaXN0KEl0ZXJhdG9yPD8+IGl0ZW1zLCBMaXN0PD8+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlyZXR1cm4gdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkucmV0YWluSXRlbXNJbkxpc3QoaXRlbXMsIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgPEU+IEUgc2V0SXRlbUluTGlzdChpbnQgaW5kZXgsIEUgaXRlbSwgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLnNldEl0ZW1Jbkxpc3QoaW5kZXgsIGl0ZW0sIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgPEU+IGludCByZXBsYWNlSXRlbUluTGlzdChFIG9sZEl0ZW0sIEUgbmV3SXRlbSwgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLnJlcGxhY2VJdGVtSW5MaXN0KG9sZEl0ZW0sIG5ld0l0ZW0sIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgPEU+IExpc3Q8RT4gc2V0SXRlbXNJbkxpc3QoaW50IGluZGV4LCBFW10gaXRlbXMsIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5zZXRJdGVtc0luTGlzdChpbmRleCwgaXRlbXMsIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgPEU+IExpc3Q8RT4gc2V0SXRlbXNJbkxpc3QoaW50IGluZGV4LCBMaXN0PD8gZXh0ZW5kcyBFPiBpdGVtcywgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLnNldEl0ZW1zSW5MaXN0KGluZGV4LCBpdGVtcywgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCXByb3RlY3RlZCA8RT4gdm9pZCBtb3ZlSXRlbXNJbkxpc3QoaW50IHRhcmdldEluZGV4LCBpbnQgc291cmNlSW5kZXgsIGludCBsZW5ndGgsIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLm1vdmVJdGVtc0luTGlzdCh0YXJnZXRJbmRleCwgc291cmNlSW5kZXgsIGxlbmd0aCwgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCXByb3RlY3RlZCA8RT4gdm9pZCBtb3ZlSXRlbUluTGlzdChpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCwgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkubW92ZUl0ZW1Jbkxpc3QodGFyZ2V0SW5kZXgsIHNvdXJjZUluZGV4LCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIGJvb2xlYW4gY2xlYXJMaXN0KExpc3Q8Pz4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5jbGVhckxpc3QobGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCXByb3RlY3RlZCA8RT4gYm9vbGVhbiBzeW5jaHJvbml6ZUxpc3QoTGlzdDxFPiBuZXdMaXN0LCBMaXN0PEU+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlyZXR1cm4gdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuc3luY2hyb25pemVMaXN0KG5ld0xpc3QsIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgPEU+IGJvb2xlYW4gc3luY2hyb25pemVMaXN0KEl0ZXJhdG9yPEU+IG5ld0xpc3QsIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXJldHVybiB0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5zeW5jaHJvbml6ZUxpc3QobmV3TGlzdCwgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiB0cmVlIGNoYW5nZSBzdXBwb3J0ICoqKioqKioqKioKLQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCBhZGRUcmVlQ2hhbmdlTGlzdGVuZXIoVHJlZUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JfQotCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIGFkZFRyZWVDaGFuZ2VMaXN0ZW5lcihTdHJpbmcgdHJlZU5hbWUsIFRyZWVDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5hZGRUcmVlQ2hhbmdlTGlzdGVuZXIodHJlZU5hbWUsIGxpc3RlbmVyKTsKLQl9Ci0KLQlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgcmVtb3ZlVHJlZUNoYW5nZUxpc3RlbmVyKFRyZWVDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5yZW1vdmVUcmVlQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCX0KLQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCByZW1vdmVUcmVlQ2hhbmdlTGlzdGVuZXIoU3RyaW5nIHRyZWVOYW1lLCBUcmVlQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkucmVtb3ZlVHJlZUNoYW5nZUxpc3RlbmVyKHRyZWVOYW1lLCBsaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlcmUgYXJlIGFueSB0cmVlIGNoYW5nZSBsaXN0ZW5lcnMgZm9yIGEgc3BlY2lmaWMgdHJlZS4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBoYXNBbnlUcmVlQ2hhbmdlTGlzdGVuZXJzKFN0cmluZyB0cmVlTmFtZSkgewotCQlyZXR1cm4gdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuaGFzQW55VHJlZUNoYW5nZUxpc3RlbmVycyh0cmVlTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlcmUgYXJlIGFueSB0cmVlIGNoYW5nZSBsaXN0ZW5lcnMgZm9yIGEgc3BlY2lmaWMgdHJlZS4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBoYXNOb1RyZWVDaGFuZ2VMaXN0ZW5lcnMoU3RyaW5nIHRyZWVOYW1lKSB7Ci0JCXJldHVybiAhIHRoaXMuaGFzQW55VHJlZUNoYW5nZUxpc3RlbmVycyh0cmVlTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlcmUgYXJlIGFueSB0cmVlIGNoYW5nZSBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIGJvb2xlYW4gaGFzQW55VHJlZUNoYW5nZUxpc3RlbmVycygpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmhhc0FueVRyZWVDaGFuZ2VMaXN0ZW5lcnMoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGVyZSBhcmUgYW55IHRyZWUgY2hhbmdlIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBoYXNOb1RyZWVDaGFuZ2VMaXN0ZW5lcnMoKSB7Ci0JCXJldHVybiAhIHRoaXMuaGFzQW55VHJlZUNoYW5nZUxpc3RlbmVycygpOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCB2b2lkIGZpcmVOb2RlQWRkZWQoVHJlZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmZpcmVOb2RlQWRkZWQoZXZlbnQpOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCB2b2lkIGZpcmVOb2RlQWRkZWQoU3RyaW5nIHRyZWVOYW1lLCBPYmplY3RbXSBwYXRoKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmZpcmVOb2RlQWRkZWQodHJlZU5hbWUsIHBhdGgpOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCB2b2lkIGZpcmVOb2RlUmVtb3ZlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZU5vZGVSZW1vdmVkKGV2ZW50KTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlTm9kZVJlbW92ZWQoU3RyaW5nIHRyZWVOYW1lLCBPYmplY3RbXSBwYXRoKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmZpcmVOb2RlUmVtb3ZlZCh0cmVlTmFtZSwgcGF0aCk7Ci0JfQotCi0JcHJvdGVjdGVkIGZpbmFsIHZvaWQgZmlyZVRyZWVDbGVhcmVkKFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlVHJlZUNsZWFyZWQoZXZlbnQpOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCB2b2lkIGZpcmVUcmVlQ2xlYXJlZChTdHJpbmcgdHJlZU5hbWUsIE9iamVjdFtdIHBhdGgpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZVRyZWVDbGVhcmVkKHRyZWVOYW1lLCBwYXRoKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlVHJlZUNsZWFyZWQoU3RyaW5nIHRyZWVOYW1lKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmZpcmVUcmVlQ2xlYXJlZCh0cmVlTmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIGZpbmFsIHZvaWQgZmlyZVRyZWVDaGFuZ2VkKFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmdldENoYW5nZVN1cHBvcnQoKS5maXJlVHJlZUNoYW5nZWQoZXZlbnQpOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCB2b2lkIGZpcmVUcmVlQ2hhbmdlZChTdHJpbmcgdHJlZU5hbWUsIE9iamVjdFtdIHBhdGgpIHsKLQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkuZmlyZVRyZWVDaGFuZ2VkKHRyZWVOYW1lLCBwYXRoKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgdm9pZCBmaXJlVHJlZUNoYW5nZWQoU3RyaW5nIHRyZWVOYW1lKSB7Ci0JCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmZpcmVUcmVlQ2hhbmdlZCh0cmVlTmFtZSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbnZlbmllbmNlIG1ldGhvZHMgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHZhbHVlcyBhcmUgZXF1YWwsIHdpdGggdGhlIGFwcHJvcHJpYXRlIG51bGwgY2hlY2tzLgotCSAqIENvbnZlbmllbmNlIG1ldGhvZCBmb3IgY2hlY2tpbmcgd2hldGhlciBhbiBhdHRyaWJ1dGUgdmFsdWUgaGFzIGNoYW5nZWQuCi0JICogCi0JICogRE8gTk9UIHVzZSB0aGlzIHRvIGRldGVybWluZSB3aGV0aGVyIHRvIGZpcmUgYSBjaGFuZ2Ugbm90aWZpY2F0aW9uLAotCSAqIENoYW5nZVN1cHBvcnQgYWxyZWFkeSBkb2VzIHRoYXQuCi0JICovCi0JcHJvdGVjdGVkIGZpbmFsIGJvb2xlYW4gdmFsdWVzQXJlRXF1YWwoT2JqZWN0IHZhbHVlMSwgT2JqZWN0IHZhbHVlMikgewotCQlyZXR1cm4gdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkudmFsdWVzQXJlRXF1YWwodmFsdWUxLCB2YWx1ZTIpOwotCX0KLQlwcm90ZWN0ZWQgZmluYWwgYm9vbGVhbiBhdHRyaWJ1dGVWYWx1ZUhhc05vdENoYW5nZWQoT2JqZWN0IG9sZFZhbHVlLCBPYmplY3QgbmV3VmFsdWUpIHsKLQkJcmV0dXJuIHRoaXMudmFsdWVzQXJlRXF1YWwob2xkVmFsdWUsIG5ld1ZhbHVlKTsKLQl9Ci0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSB2YWx1ZXMgYXJlIGRpZmZlcmVudCwgd2l0aCB0aGUgYXBwcm9wcmlhdGUgbnVsbCBjaGVja3MuCi0JICogQ29udmVuaWVuY2UgbWV0aG9kIGZvciBjaGVja2luZyB3aGV0aGVyIGFuIGF0dHJpYnV0ZSB2YWx1ZSBoYXMgY2hhbmdlZC4KLQkgKiAKLQkgKiBETyBOT1QgdXNlIHRoaXMgdG8gZGV0ZXJtaW5lIHdoZXRoZXIgdG8gZmlyZSBhIGNoYW5nZSBub3RpZmljYXRpb24sCi0JICogQ2hhbmdlU3VwcG9ydCBhbHJlYWR5IGRvZXMgdGhhdC4KLQkgKiAKLQkgKiBGb3IgZXhhbXBsZSwgYWZ0ZXIgZmlyaW5nIHRoZSBjaGFuZ2Ugbm90aWZpY2F0aW9uLCB5b3UgY2FuIHVzZSB0aGlzIG1ldGhvZAotCSAqIHRvIGRlY2lkZSBpZiBzb21lIG90aGVyLCByZWxhdGVkLCBwaWVjZSBvZiBzdGF0ZSBuZWVkcyB0byBiZSBzeW5jaHJvbml6ZWQKLQkgKiB3aXRoIHRoZSBzdGF0ZSB0aGF0IGp1c3QgY2hhbmdlZC4KLQkgKi8KLQlwcm90ZWN0ZWQgZmluYWwgYm9vbGVhbiB2YWx1ZXNBcmVEaWZmZXJlbnQoT2JqZWN0IHZhbHVlMSwgT2JqZWN0IHZhbHVlMikgewotCQlyZXR1cm4gdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkudmFsdWVzQXJlRGlmZmVyZW50KHZhbHVlMSwgdmFsdWUyKTsKLQl9Ci0JcHJvdGVjdGVkIGZpbmFsIGJvb2xlYW4gYXR0cmlidXRlVmFsdWVIYXNDaGFuZ2VkKE9iamVjdCBvbGRWYWx1ZSwgT2JqZWN0IG5ld1ZhbHVlKSB7Ci0JCXJldHVybiB0aGlzLnZhbHVlc0FyZURpZmZlcmVudChvbGRWYWx1ZSwgbmV3VmFsdWUpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBPYmplY3Qgb3ZlcnJpZGVzICoqKioqKioqKioKLQotCS8qKgotCSAqIEFsdGhvdWdoIGNsb25pbmcgbW9kZWxzIGlzIHVzdWFsbHkgbm90IGEgR29vZCBJZGVhLAotCSAqIHdlIHNob3VsZCBhdCBsZWFzdCBzdXBwb3J0IGl0IHByb3Blcmx5LgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCBBYnN0cmFjdE1vZGVsIGNsb25lKCkgdGhyb3dzIENsb25lTm90U3VwcG9ydGVkRXhjZXB0aW9uIHsKLQkJQWJzdHJhY3RNb2RlbCBjbG9uZSA9IChBYnN0cmFjdE1vZGVsKSBzdXBlci5jbG9uZSgpOwotCQljbG9uZS5wb3N0Q2xvbmUoKTsKLQkJcmV0dXJuIGNsb25lOwotCX0KLQotCS8qKgotCSAqIFBlcmZvcm0gYW55IHBvc3QtY2xvbmUgcHJvY2Vzc2luZyBuZWNlc3NhcnkgdG8KLQkgKiBzdWNjZXNzZnVsbHkgZGlzY29ubmVjdCB0aGUgY2xvbmUgZnJvbSB0aGUgb3JpZ2luYWwuCi0JICogV2hlbiB0aGlzIG1ldGhvZCBpcyBjYWxsZWQgb24gdGhlIGNsb25lLCB0aGUgY2xvbmUKLQkgKiBpcyBhICJzaGFsbG93IiBjb3B5IG9mIHRoZSBvcmlnaW5hbCAoaS5lLiB0aGUgY2xvbmUKLQkgKiBzaGFyZXMgYWxsIGl0cyBpbnN0YW5jZSB2YXJpYWJsZXMgd2l0aCB0aGUgb3JpZ2luYWwpLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIHBvc3RDbG9uZSgpIHsKLQkJLy8gY2xlYXIgb3V0IGNoYW5nZSBzdXBwb3J0IC0gbW9kZWxzIGRvIG5vdCBzaGFyZSBsaXN0ZW5lcnMKLQkJdGhpcy5jaGFuZ2VTdXBwb3J0ID0gbnVsbDsKLQkvLyB3aGVuIHlvdSBvdmVycmlkZSB0aGlzIG1ldGhvZCwgZG9uJ3QgZm9yZ2V0IHRvIGluY2x1ZGU6Ci0JLy8Jc3VwZXIucG9zdENsb25lKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLmJ1aWxkU2ltcGxlVG9TdHJpbmdPbih0aGlzLCBzYik7Ci0JCXNiLmFwcGVuZCgiICgiKTsgLy8kTk9OLU5MUy0xJAotCQl0aGlzLnRvU3RyaW5nKHNiKTsKLQkJc2IuYXBwZW5kKCcpJyk7Ci0JCXJldHVybiBzYi50b1N0cmluZygpOwotCX0KLQotCS8qKgotCSAqIG1ha2UgdGhpcyBwdWJsaWMgc28gb25lIG1vZGVsIGNhbiBjYWxsIGEgbmVzdGVkIG1vZGVsJ3MKLQkgKiAjdG9TdHJpbmcoU3RyaW5nQnVpbGRlcikKLQkgKi8KLQlwdWJsaWMgdm9pZCB0b1N0cmluZyhAU3VwcHJlc3NXYXJuaW5ncygidW51c2VkIikgU3RyaW5nQnVpbGRlciBzYikgewotCQkvLyBzdWJjbGFzc2VzIHNob3VsZCBvdmVycmlkZSB0aGlzIHRvIGRvIHNvbWV0aGluZyBhIGJpdCBtb3JlIGhlbHBmdWwKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC9DYWxsYmFja0NoYW5nZVN1cHBvcnQuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC9DYWxsYmFja0NoYW5nZVN1cHBvcnQuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjAyYjNjMy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvQ2FsbGJhY2tDaGFuZ2VTdXBwb3J0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw3NCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsOwotCi1pbXBvcnQgamF2YS51dGlsLkV2ZW50TGlzdGVuZXI7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5MaXN0ZW5lckxpc3Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci0KLS8qKgotICogVGhpcyBjaGFuZ2Ugc3VwcG9ydCBjbGFzcyB3aWxsIG5vdGlmeSBsaXN0ZW5lcnMgd2hlbmV2ZXIgb25lIG9mIHRoZSBzb3VyY2UncwotICogYXNwZWN0cyBoYXMgY2hhbmdlZC4gT25seSB0aGUgYXNwZWN0IG5hbWUgaXMgcGFzc2VkIHRvIHRoZSBsaXN0ZW5lcjsgbm8KLSAqIGV2ZW50IGlzIGdlbmVyYXRlZC4gVGhpcyBhbGxvd3MgdGhlIGxpc3RlbmVycyB0byBkZWxlZ2F0ZSB0byB0aGUgY2hhbmdlCi0gKiBzdXBwb3J0IG9iamVjdCB2ZXJpZmljYXRpb24gdGhhdCBhbiBhc3BlY3QgYXMgYWN0dWFsbHkgY2hhbmdlZC4gVGhpcyBpcwotICogdXNlZnVsIGZvciBzaW1wbGUgdGhpbmdzIGxpa2Ugc2V0dGluZyBkaXJ0eSBmbGFncywgYmxhbmtldCB2YWxpZGF0aW9uLCBhbmQKLSAqIGJsYW5rZXQgc3ljaHJvbml6YXRpb247IGkuZS4gdGhpbmdzIHRoYXQgbWlnaHQgYmUgaW50ZXJlc3RlZCBpbiB0aGUgKm5hbWUqCi0gKiBvZiB0aGUgYXNwZWN0IHRoYXQgY2hhbmdlZCBidXQgbm90IHNvIG11Y2ggKmhvdyogdGhlIGFzcGVjdCBjaGFuZ2VkLgotICovCi1wdWJsaWMgY2xhc3MgQ2FsbGJhY2tDaGFuZ2VTdXBwb3J0Ci0JZXh0ZW5kcyBDaGFuZ2VTdXBwb3J0Ci17Ci0JcHJvdGVjdGVkIGZpbmFsIExpc3RlbmVyTGlzdDxMaXN0ZW5lcj4gbGlzdGVuZXJMaXN0OwotCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDFMOwotCi0KLQlwdWJsaWMgQ2FsbGJhY2tDaGFuZ2VTdXBwb3J0KE1vZGVsIHNvdXJjZSwgTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJdGhpcyhzb3VyY2UpOwotCQl0aGlzLmxpc3RlbmVyTGlzdC5hZGQobGlzdGVuZXIpOwotCX0KLQotCXB1YmxpYyBDYWxsYmFja0NoYW5nZVN1cHBvcnQoTW9kZWwgc291cmNlKSB7Ci0JCXN1cGVyKHNvdXJjZSk7Ci0JCXRoaXMubGlzdGVuZXJMaXN0ID0gbmV3IExpc3RlbmVyTGlzdDxMaXN0ZW5lcj4oTGlzdGVuZXIuY2xhc3MpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNvdXJjZUNoYW5nZWQoU3RyaW5nIGFzcGVjdE5hbWUpIHsKLQkJc3VwZXIuc291cmNlQ2hhbmdlZChhc3BlY3ROYW1lKTsKLQkJZm9yIChMaXN0ZW5lciBsaXN0ZW5lciA6IHRoaXMubGlzdGVuZXJMaXN0LmdldExpc3RlbmVycygpKSB7Ci0JCQlsaXN0ZW5lci5hc3BlY3RDaGFuZ2VkKGFzcGVjdE5hbWUpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgYWRkTGlzdGVuZXIoTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJdGhpcy5saXN0ZW5lckxpc3QuYWRkKGxpc3RlbmVyKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCByZW1vdmVMaXN0ZW5lcihMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLmxpc3RlbmVyTGlzdC5yZW1vdmUobGlzdGVuZXIpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBsaXN0ZW5lciBpbnRlcmZhY2UgKioqKioqKioqKgotCi0JLyoqCi0JICogTGlzdGVuZXIgdGhhdCB3aWxsIGJlIG5vdGlmaWVkIG9mIGFueSBhc3BlY3QgY2hhbmdlcy4KLQkgKi8KLQlwdWJsaWMgaW50ZXJmYWNlIExpc3RlbmVyIGV4dGVuZHMgRXZlbnRMaXN0ZW5lciB7Ci0KLQkJLyoqCi0JCSAqIFRoZSBzcGVjaWZpZWQgYXNwZWN0IGNoYW5nZWQuCi0JCSAqLwotCQl2b2lkIGFzcGVjdENoYW5nZWQoU3RyaW5nIGFzcGVjdE5hbWUpOwotCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvQ2hhbmdlU3VwcG9ydC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL0NoYW5nZVN1cHBvcnQuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggN2U1ZWVjYy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvQ2hhbmdlU3VwcG9ydC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzIxOSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsOwotCi1pbXBvcnQgamF2YS5pby5JT0V4Y2VwdGlvbjsKLWltcG9ydCBqYXZhLmlvLk9iamVjdElucHV0U3RyZWFtOwotaW1wb3J0IGphdmEuaW8uT2JqZWN0T3V0cHV0U3RyZWFtOwotaW1wb3J0IGphdmEuaW8uU2VyaWFsaXphYmxlOwotaW1wb3J0IGphdmEubGFuZy5yZWZsZWN0LkFycmF5OwotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkFycmF5czsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbnM7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuSGFzaEJhZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuQXJyYXlJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5Nb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Db2xsZWN0aW9uQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuTGlzdENoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlByb3BlcnR5Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuU3RhdGVDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5UcmVlQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkxpc3RDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlN0YXRlQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuVHJlZUNoYW5nZUxpc3RlbmVyOwotCi0vKioKLSAqIFN1cHBvcnQgb2JqZWN0IHRoYXQgY2FuIGJlIHVzZWQgYnkgaW1wbGVtZW50b3JzIG9mIHRoZSBNb2RlbCBpbnRlcmZhY2UuCi0gKiBJdCBwcm92aWRlcyBmb3Igc3RhdGUsIHByb3BlcnR5LCBjb2xsZWN0aW9uLCBsaXN0LCBhbmQgdHJlZSBjaGFuZ2Ugbm90aWZpY2F0aW9ucyB0bwotICogbGlzdGVuZXJzLgotICogCi0gKiBOQjogVGhlcmUgaXMgbG90cyBvZiBjb3B5LW4tcGFzdGUgY29kZSBpbiB0aGlzIGNsYXNzLiBOZWFybHkgYWxsIG9mIHRoaXMgZHVwbGljYXRpb24KLSAqIGlzIGFuIGVmZm9ydCB0byBwcmV2ZW50IHRoZSB1bm5lY2Vzc2FyeSBjcmVhdGlvbiBvZiBuZXcgb2JqZWN0cyAodHlwaWNhbGx5IGV2ZW50Ci0gKiBvYmplY3RzKS4gU2luY2UgbWFueSBldmVudHMgYXJlIGZpcmVkIHdoZW4gdGhlcmUgYXJlIG5vIGxpc3RlbmVycywgd2UgcG9zdHBvbmUKLSAqIHRoZSBjcmVhdGlvbiBvZiBldmVudCBvYmplY3RzIHVudGlsIHdlIGtub3cgd2UgaGF2ZSBpbnRlcmVzdGVkIGxpc3RlbmVycy4KLSAqIE1vc3QgbWV0aG9kcyBoYXZlIHRoZSAibm9uLWR1cGxpY2F0ZWQiIHZlcnNpb24gb2YgdGhlIG1ldGhvZCBib2R5IGNvbW1lbnRlZAotICogb3V0IGF0IHRoZSB0b3Agb2YgdGhlIGN1cnJlbnQgbWV0aG9kIGJvZHkuCi0gKiBUaGUgaG9wZSB3YXMgdGhhdCB0aGlzIGNsYXNzIHdvdWxkIHByb3ZlIHRvIGJlIGZhaXJseSBzdGF0aWMgYW5kIHRoZSBkdXBsaWNhdGVkCi0gKiBjb2RlIHdvdWxkIG5vdCBwcm92ZSBvbmVyb3VzOyBidXQgdGhhdCBoYXMgbm90IHByb3ZlbiB0byBiZQotICogdGhlIGNhc2UsIGFzIHdlIGhhdmUgYWRkZWQgc3VwcG9ydCBmb3IgInN0YXRlIiBjaGFuZ2VzLCAiZGlydHkiIG5vdGlmaWNhdGlvbiwKLSAqIGFuZCBjdXN0b20gIm5vdGlmaWVycyIsIHdpdGggbW9yZSB0byBjb21lLCBJJ20gc3VyZS4uLi4gIH5ianYKLSAqIAotICogTkIyOiBUaGlzIGNsYXNzIHdpbGwgY2hlY2sgdG8gc2VlIGlmLCBkdXJpbmcgdGhlIGZpcmluZyBvZiBldmVudHMsIGEgbGlzdGVuZXIKLSAqIG9uIHRoZSBvcmlnaW5hbCwgY2xvbmVkLCBsaXN0IG9mIGxpc3RlbmVycyBoYXMgYmVlbiByZW1vdmVkIGZyb20gdGhlIG1hc3RlcgotICogbGlzdCBvZiBsaXN0ZW5lcnMgKmJlZm9yZSogaXQgaXMgbm90aWZpZWQuIElmIHRoZSBsaXN0ZW5lciBoYXMgYmVlbiByZW1vdmVkCi0gKiAiY29uY3VycmVudGx5IiBpdCB3aWxsICpub3QqIGJlIG5vdGlmaWVkLiAoU2VlIHRoZSBjb2RlIHRoYXQgdXNlcyB0aGUKLSAqICdzdGlsbExpc3RlbmluZycgbG9jYWwgYm9vbGVhbiBmbGFnLikKLSAqIAotICogTkIzOiBBbnkgbGlzdGVuZXIgdGhhdCBpcyBhZGRlZCBkdXJpbmcgdGhlIGZpcmluZyBvZiBldmVudHMgd2lsbCAqbm90KiBiZQotICogYWxzbyBub3RpZmllZC4KLSAqIAotICogTkI0OiBUaGlzIGNsYXNzIGlzIHNlcmlhbGl6YWJsZSwgYnV0IGl0IHdpbGwgb25seSB3cml0ZSBvdXQgbGlzdGVuZXJzIHRoYXQKLSAqIGFyZSBhbHNvIHNlcmlhbGl6YWJsZSB3aGlsZSBzaWxlbnRseSBsZWF2aW5nIGJlaGluZCBsaXN0ZW5lcnMgdGhhdCBhcmUgbm90LgotICogCi0gKiBUT0RPIGZpcmUgYSBzdGF0ZSBjaGFuZ2UgZXZlbnQgd2l0aCAqZXZlcnkqIGNoYW5nZT8KLSAqIFRPRE8gdXNlIG9iamVjdHMgKElEcz8pIGluc3RlYWQgb2Ygc3RyaW5ncyB0byBpZGVudGlmeSBhc3BlY3RzPwotICovCi1wdWJsaWMgY2xhc3MgQ2hhbmdlU3VwcG9ydAotCWltcGxlbWVudHMgU2VyaWFsaXphYmxlCi17Ci0KLQkvKiogVGhlIG9iamVjdCB0byBiZSBwcm92aWRlZCBhcyB0aGUgInNvdXJjZSIgZm9yIGFueSBnZW5lcmF0ZWQgZXZlbnRzLiAqLwotCXByb3RlY3RlZCBmaW5hbCBNb2RlbCBzb3VyY2U7Ci0KLQkvKiogQXNzb2NpYXRlIGEgbGlzdGVuZXIgY2xhc3MgdG8gYSBjb2xsZWN0aW9uIG9mICJnZW5lcmljIiBsaXN0ZW5lcnMgZm9yIHRoYXQgY2xhc3MuICovCi0JcHJpdmF0ZSB0cmFuc2llbnQgR2VuZXJpY0xpc3RlbmVyTGlzdFtdIGdlbmVyaWNMaXN0ZW5lcnMgPSBFTVBUWV9HRU5FUklDX0xJU1RFTkVSUzsKLQkJcHJpdmF0ZSBzdGF0aWMgZmluYWwgR2VuZXJpY0xpc3RlbmVyTGlzdFtdIEVNUFRZX0dFTkVSSUNfTElTVEVORVJTID0gbmV3IEdlbmVyaWNMaXN0ZW5lckxpc3RbMF07Ci0KLQkvKiogQXNzb2NpYXRlIGFzcGVjdCBuYW1lcyB0byBjaGlsZCBjaGFuZ2Ugc3VwcG9ydCBvYmplY3RzLiAqLwotCXByaXZhdGUgQXNwZWN0Q2hpbGRbXSBhc3BlY3RDaGlsZHJlbiA9IEVNUFRZX0FTUEVDVF9DSElMRFJFTjsKLQkJcHJpdmF0ZSBzdGF0aWMgZmluYWwgQXNwZWN0Q2hpbGRbXSBFTVBUWV9BU1BFQ1RfQ0hJTERSRU4gPSBuZXcgQXNwZWN0Q2hpbGRbMF07Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3Qgc3VwcG9ydCBmb3IgdGhlIHNwZWNpZmllZCBzb3VyY2Ugb2YgY2hhbmdlIGV2ZW50cy4KLQkgKiBUaGUgc291cmNlIGNhbm5vdCBiZSBudWxsLgotCSAqLwotCXB1YmxpYyBDaGFuZ2VTdXBwb3J0KE1vZGVsIHNvdXJjZSkgewotCQlzdXBlcigpOwotCQlpZiAoc291cmNlID09IG51bGwpIHsKLQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigpOwotCQl9Ci0JCXRoaXMuc291cmNlID0gc291cmNlOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbnRlcm5hbCBiZWhhdmlvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBBZGQgYSAiZ2VuZXJpYyIgbGlzdGVuZXIgdGhhdCBsaXN0ZW5zIHRvIGFsbCBldmVudHMgYXBwcm9wcmlhdGUgdG8gdGhhdAotCSAqIGxpc3RlbmVyLCByZWdhcmRsZXNzIG9mIHRoZSBhc3BlY3QgbmFtZSBhc3NvY2lhdGVkIHdpdGggdGhhdCBldmVudC4KLQkgKiBUaGUgbGlzdGVuZXIgY2Fubm90IGJlIG51bGwuCi0JICovCi0JcHJvdGVjdGVkIDxUIGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXI+IHZvaWQgYWRkTGlzdGVuZXIoQ2xhc3M8VD4gbGlzdGVuZXJDbGFzcywgVCBsaXN0ZW5lcikgewotCQlpZiAobGlzdGVuZXIgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7CQkvLyBiZXR0ZXIgc29vbmVyIHRoYW4gbGF0ZXIKLQkJfQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUdlbmVyaWNMaXN0ZW5lckxpc3QgZ2xsID0gdGhpcy5nZXRHZW5lcmljTGlzdGVuZXJMaXN0KGxpc3RlbmVyQ2xhc3MpOwotCQkJaWYgKGdsbCA9PSBudWxsKSB7Ci0JCQkJdGhpcy5hZGRHZW5lcmljTGlzdGVuZXJMaXN0KGxpc3RlbmVyQ2xhc3MsIGxpc3RlbmVyKTsKLQkJCX0gZWxzZSB7Ci0JCQkJZ2xsLmFkZExpc3RlbmVyKGxpc3RlbmVyKTsKLQkJCX0KLQkJfQotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgImdlbmVyaWMiIGxpc3RlbmVyIGxpc3QgZm9yIHRoZSBzcGVjaWZpZWQgbGlzdGVuZXIgY2xhc3MuCi0JICogUmV0dXJuIG51bGwgaWYgdGhlIGxpc3QgaXMgbm90IHByZXNlbnQuCi0JICovCi0JcHJvdGVjdGVkIEdlbmVyaWNMaXN0ZW5lckxpc3QgZ2V0R2VuZXJpY0xpc3RlbmVyTGlzdChDbGFzczw/IGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXI+IGxpc3RlbmVyQ2xhc3MpIHsKLQkJZm9yIChHZW5lcmljTGlzdGVuZXJMaXN0IGdsbCA6IHRoaXMuZ2VuZXJpY0xpc3RlbmVycykgewotCQkJaWYgKGdsbC5saXN0ZW5lckNsYXNzID09IGxpc3RlbmVyQ2xhc3MpIHsKLQkJCQlyZXR1cm4gZ2xsOwotCQkJfQotCQl9Ci0JCXJldHVybiBudWxsOwotCX0KLQotCS8qKgotCSAqIEFkZCB0aGUgImdlbmVyaWMiIGxpc3RlbmVyIGxpc3QgZm9yIHRoZSBzcGVjaWZpZWQgbGlzdGVuZXIgY2xhc3MuCi0JICogUmV0dXJuIHRoZSBuZXdseS1idWlsdCBnZW5lcmljIGxpc3RlbmVyIGxpc3QuCi0JICovCi0JcHJvdGVjdGVkIDxUIGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXI+IEdlbmVyaWNMaXN0ZW5lckxpc3QgYWRkR2VuZXJpY0xpc3RlbmVyTGlzdChDbGFzczxUPiBsaXN0ZW5lckNsYXNzLCBUIGxpc3RlbmVyKSB7Ci0JCUdlbmVyaWNMaXN0ZW5lckxpc3QgZ2xsID0gbmV3IEdlbmVyaWNMaXN0ZW5lckxpc3QobGlzdGVuZXJDbGFzcywgbGlzdGVuZXIpOwotCQl0aGlzLmdlbmVyaWNMaXN0ZW5lcnMgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKHRoaXMuZ2VuZXJpY0xpc3RlbmVycywgZ2xsKTsKLQkJcmV0dXJuIGdsbDsKLQl9Ci0KLQkvKioKLQkgKiBBZGRzIGEgbGlzdGVuZXIgdGhhdCBsaXN0ZW5zIHRvIGFsbCBldmVudHMgYXBwcm9wcmlhdGUgdG8gdGhhdCBsaXN0ZW5lciwKLQkgKiBhbmQgb25seSB0byB0aG9zZSBldmVudHMgY2FycnlpbmcgdGhlIGFzcGVjdCBuYW1lIHNwZWNpZmllZC4KLQkgKiBUaGUgYXNwZWN0IG5hbWUgY2Fubm90IGJlIG51bGwgYW5kIHRoZSBsaXN0ZW5lciBjYW5ub3QgYmUgbnVsbC4KLQkgKi8KLQlwcm90ZWN0ZWQgPFQgZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gdm9pZCBhZGRMaXN0ZW5lcihTdHJpbmcgYXNwZWN0TmFtZSwgQ2xhc3M8VD4gbGlzdGVuZXJDbGFzcywgVCBsaXN0ZW5lcikgewotCQlpZiAoKGFzcGVjdE5hbWUgPT0gbnVsbCkgfHwgKGxpc3RlbmVyID09IG51bGwpKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsJCS8vIGJldHRlciBzb29uZXIgdGhhbiBsYXRlcgotCQl9Ci0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJQ2hhbmdlU3VwcG9ydCBjaGlsZCA9IHRoaXMuZ2V0Q2hpbGQoYXNwZWN0TmFtZSk7Ci0JCQlpZiAoY2hpbGQgPT0gbnVsbCkgewotCQkJCWNoaWxkID0gdGhpcy5hZGRDaGlsZChhc3BlY3ROYW1lKTsKLQkJCX0KLQkJCWNoaWxkLmFkZExpc3RlbmVyKGxpc3RlbmVyQ2xhc3MsIGxpc3RlbmVyKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgY2hpbGQgY2hhbmdlIHN1cHBvcnQgZm9yIHRoZSBzcGVjaWZpZWQgYXNwZWN0IG5hbWUuCi0JICogUmV0dXJuIG51bGwgaWYgdGhlIGFzcGVjdCBuYW1lIGlzIG51bGwgb3IgdGhlIGNoaWxkIGlzIG5vdCBwcmVzZW50LgotCSAqLwotCXByb3RlY3RlZCBDaGFuZ2VTdXBwb3J0IGdldENoaWxkKFN0cmluZyBhc3BlY3ROYW1lKSB7Ci0JCS8vIHB1dCBpbiBhIG51bGwgY2hlY2sgdG8gc2ltcGxpZnkgY2FsbGluZyBjb2RlCi0JCWlmIChhc3BlY3ROYW1lID09IG51bGwpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCWZvciAoQXNwZWN0Q2hpbGQgYXNwZWN0Q2hpbGQgOiB0aGlzLmFzcGVjdENoaWxkcmVuKSB7Ci0JCQlpZiAoYXNwZWN0Q2hpbGQuYXNwZWN0TmFtZSA9PSBhc3BlY3ROYW1lKSB7Ci0JCQkJcmV0dXJuIGFzcGVjdENoaWxkLmNoaWxkOwotCQkJfQotCQl9Ci0JCXJldHVybiBudWxsOwotCX0KLQotCS8qKgotCSAqIEFkZCB0aGUgY2hpbGQgY2hhbmdlIHN1cHBvcnQgZm9yIHRoZSBzcGVjaWZpZWQgYXNwZWN0IG5hbWUuCi0JICogUmV0dXJuIHRoZSBuZXdseS1idWlsdCBjaGlsZCBjaGFuZ2Ugc3VwcG9ydC4KLQkgKi8KLQlwcm90ZWN0ZWQgQ2hhbmdlU3VwcG9ydCBhZGRDaGlsZChTdHJpbmcgYXNwZWN0TmFtZSkgewotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gdGhpcy5idWlsZENoaWxkQ2hhbmdlU3VwcG9ydCgpOwotCQl0aGlzLmFzcGVjdENoaWxkcmVuID0gQ29sbGVjdGlvblRvb2xzLmFkZCh0aGlzLmFzcGVjdENoaWxkcmVuLCBuZXcgQXNwZWN0Q2hpbGQoYXNwZWN0TmFtZSwgY2hpbGQpKTsKLQkJcmV0dXJuIGNoaWxkOwotCX0KLQotCS8qKgotCSAqIEJ1aWxkIGFuZCByZXR1cm4gYSBjaGlsZCBjaGFuZ2Ugc3VwcG9ydCB0byBob2xkIGFzcGVjdC1zcGVjaWZpYyBsaXN0ZW5lcnMuCi0JICovCi0JcHJvdGVjdGVkIENoYW5nZVN1cHBvcnQgYnVpbGRDaGlsZENoYW5nZVN1cHBvcnQoKSB7Ci0JCXJldHVybiBuZXcgQ2hpbGQodGhpcy5zb3VyY2UpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZXMgYSAiZ2VuZXJpYyIgbGlzdGVuZXIgdGhhdCBoYXMgYmVlbiByZWdpc3RlcmVkIGZvciBhbGwgZXZlbnRzCi0JICogYXBwcm9wcmlhdGUgdG8gdGhhdCBsaXN0ZW5lci4KLQkgKi8KLQlwcm90ZWN0ZWQgPFQgZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gdm9pZCByZW1vdmVMaXN0ZW5lcihDbGFzczxUPiBsaXN0ZW5lckNsYXNzLCBUIGxpc3RlbmVyKSB7Ci0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJR2VuZXJpY0xpc3RlbmVyTGlzdCBnbGwgPSB0aGlzLmdldEdlbmVyaWNMaXN0ZW5lckxpc3QobGlzdGVuZXJDbGFzcyk7Ci0JCQlpZiAoZ2xsID09IG51bGwpIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJsaXN0ZW5lciBub3QgcmVnaXN0ZXJlZCIpOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCQlpZiAoICEgZ2xsLnJlbW92ZUxpc3RlbmVyKGxpc3RlbmVyKSkgeyAgLy8gbGVhdmUgdGhlIEdMTCwgZXZlbiBpZiBpdCBpcyBlbXB0eT8KLQkJCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJsaXN0ZW5lciBub3QgcmVnaXN0ZXJlZDogIiArIGxpc3RlbmVyKTsgLy8kTk9OLU5MUy0xJAotCQkJfQotCQl9Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlcyBhIGxpc3RlbmVyIHRoYXQgaGFzIGJlZW4gcmVnaXN0ZXJlZCBmb3IgYXBwcm9wcmlhdGUKLQkgKiBldmVudHMgY2FycnlpbmcgdGhlIHNwZWNpZmllZCBhc3BlY3QgbmFtZS4KLQkgKi8KLQlwcm90ZWN0ZWQgPFQgZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gdm9pZCByZW1vdmVMaXN0ZW5lcihTdHJpbmcgYXNwZWN0TmFtZSwgQ2xhc3M8VD4gbGlzdGVuZXJDbGFzcywgVCBsaXN0ZW5lcikgewotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUNoYW5nZVN1cHBvcnQgY2hpbGQgPSB0aGlzLmdldENoaWxkKGFzcGVjdE5hbWUpOwotCQkJaWYgKGNoaWxkID09IG51bGwpIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJsaXN0ZW5lciBub3QgcmVnaXN0ZXJlZCIpOyAvLyROT04tTkxTLTEkCi0JCQl9Ci0JCQljaGlsZC5yZW1vdmVMaXN0ZW5lcihsaXN0ZW5lckNsYXNzLCBsaXN0ZW5lcik7ICAvLyBsZWF2ZSB0aGUgY2hpbGQsIGV2ZW4gaWYgaXQgaXMgZW1wdHk/Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW50ZXJuYWwgcXVlcmllcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlICJnZW5lcmljIiBsaXN0ZW5lcnMgZm9yIHRoZSBzcGVjaWZpZWQgbGlzdGVuZXIgY2xhc3MuCi0JICogUmV0dXJuIG51bGwgaWYgdGhlcmUgYXJlIG5vIGxpc3RlbmVycy4KLQkgKi8KLQlwcm90ZWN0ZWQgQ2hhbmdlTGlzdGVuZXJbXSBnZXRMaXN0ZW5lcnMoQ2xhc3M8PyBleHRlbmRzIENoYW5nZUxpc3RlbmVyPiBsaXN0ZW5lckNsYXNzKSB7Ci0JCUdlbmVyaWNMaXN0ZW5lckxpc3QgZ2xsID0gdGhpcy5nZXRHZW5lcmljTGlzdGVuZXJMaXN0KGxpc3RlbmVyQ2xhc3MpOwotCQlyZXR1cm4gKGdsbCA9PSBudWxsKSA/IG51bGwgOiBnbGwubGlzdGVuZXJzOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZXJlIGFyZSBhbnkgImdlbmVyaWMiIGxpc3RlbmVycyBmb3IgdGhlIHNwZWNpZmllZAotCSAqIGxpc3RlbmVyIGNsYXNzLgotCSAqLwotCXByb3RlY3RlZCBzeW5jaHJvbml6ZWQgPFQgZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gYm9vbGVhbiBoYXNBbnlMaXN0ZW5lcnMoQ2xhc3M8VD4gbGlzdGVuZXJDbGFzcykgewotCQlHZW5lcmljTGlzdGVuZXJMaXN0IGdsbCA9IHRoaXMuZ2V0R2VuZXJpY0xpc3RlbmVyTGlzdChsaXN0ZW5lckNsYXNzKTsKLQkJcmV0dXJuIChnbGwgIT0gbnVsbCkgJiYgZ2xsLmhhc0xpc3RlbmVycygpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZXJlIGFyZSBubyAiZ2VuZXJpYyIgbGlzdGVuZXJzIGZvciB0aGUgc3BlY2lmaWVkCi0JICogbGlzdGVuZXIgY2xhc3MuCi0JICovCi0JcHJvdGVjdGVkIDxUIGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXI+IGJvb2xlYW4gaGFzTm9MaXN0ZW5lcnMoQ2xhc3M8VD4gbGlzdGVuZXJDbGFzcykgewotCQlyZXR1cm4gISB0aGlzLmhhc0FueUxpc3RlbmVycyhsaXN0ZW5lckNsYXNzKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGVyZSBhcmUgYW55IGxpc3RlbmVycyBmb3IgdGhlIHNwZWNpZmllZAotCSAqIGxpc3RlbmVyIGNsYXNzIGFuZCBhc3BlY3QgbmFtZS4KLQkgKi8KLQlwcm90ZWN0ZWQgc3luY2hyb25pemVkIGJvb2xlYW4gaGFzQW55TGlzdGVuZXJzKENsYXNzPD8gZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gbGlzdGVuZXJDbGFzcywgU3RyaW5nIGFzcGVjdE5hbWUpIHsKLQkJaWYgKHRoaXMuaGFzQW55TGlzdGVuZXJzKGxpc3RlbmVyQ2xhc3MpKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsgIC8vIHdlIGhhdmUgYSAiZ2VuZXJpYyIgbGlzdGVuZXIKLQkJfQotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gdGhpcy5nZXRDaGlsZChhc3BlY3ROYW1lKTsKLQkJcmV0dXJuIChjaGlsZCAhPSBudWxsKSAmJgotCQkJY2hpbGQuaGFzQW55TGlzdGVuZXJzKGxpc3RlbmVyQ2xhc3MpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZXJlIGFyZSBubyAiZ2VuZXJpYyIgbGlzdGVuZXJzIGZvciB0aGUgc3BlY2lmaWVkCi0JICogbGlzdGVuZXIgY2xhc3MgYW5kIGFzcGVjdCBuYW1lLgotCSAqLwotCXByb3RlY3RlZCA8VCBleHRlbmRzIENoYW5nZUxpc3RlbmVyPiBib29sZWFuIGhhc05vTGlzdGVuZXJzKENsYXNzPFQ+IGxpc3RlbmVyQ2xhc3MsIFN0cmluZyBhc3BlY3ROYW1lKSB7Ci0JCXJldHVybiAhIHRoaXMuaGFzQW55TGlzdGVuZXJzKGxpc3RlbmVyQ2xhc3MsIGFzcGVjdE5hbWUpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBUaGUgc3BlY2lmaWVkIGFzcGVjdCBvZiB0aGUgc291cmNlIGhhcyBjaGFuZ2VkOwotCSAqIG92ZXJyaWRlIHRoaXMgbWV0aG9kIHRvIHBlcmZvcm0gdGhpbmdzIGxpa2Ugc2V0dGluZyBhCi0JICogZGlydHkgZmxhZyBvciB2YWxpZGF0aW5nIHRoZSBzb3VyY2UncyBzdGF0ZS4KLQkgKiBUaGUgYXNwZWN0IElEIHdpbGwgYmUgbnVsbCBpZiBhICJzdGF0ZSBjaGFuZ2UiIG9jY3VycmVkLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIHNvdXJjZUNoYW5nZWQoQFN1cHByZXNzV2FybmluZ3MoInVudXNlZCIpIFN0cmluZyBhc3BlY3ROYW1lKSB7Ci0JCS8vIHRoZSBkZWZhdWx0IGlzIHRvIGRvIG5vdGhpbmcKLQl9Ci0KLQotCS8vICoqKioqKioqKiogc3RhdGUgY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JcHJvdGVjdGVkIHN0YXRpYyBmaW5hbCBDbGFzczxTdGF0ZUNoYW5nZUxpc3RlbmVyPiBTVEFURV9DSEFOR0VfTElTVEVORVJfQ0xBU1MgPSBTdGF0ZUNoYW5nZUxpc3RlbmVyLmNsYXNzOwotCi0JLyoqCi0JICogQWRkIGEgc3RhdGUgY2hhbmdlIGxpc3RlbmVyLgotCSAqLwotCXB1YmxpYyB2b2lkIGFkZFN0YXRlQ2hhbmdlTGlzdGVuZXIoU3RhdGVDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLmFkZExpc3RlbmVyKFNUQVRFX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgbGlzdGVuZXIpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBhIHN0YXRlIGNoYW5nZSBsaXN0ZW5lci4KLQkgKi8KLQlwdWJsaWMgdm9pZCByZW1vdmVTdGF0ZUNoYW5nZUxpc3RlbmVyKFN0YXRlQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJdGhpcy5yZW1vdmVMaXN0ZW5lcihTVEFURV9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGVyZSBhcmUgYW55IHN0YXRlIGNoYW5nZSBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIGJvb2xlYW4gaGFzQW55U3RhdGVDaGFuZ2VMaXN0ZW5lcnMoKSB7Ci0JCXJldHVybiB0aGlzLmhhc0FueUxpc3RlbmVycyhTVEFURV9DSEFOR0VfTElTVEVORVJfQ0xBU1MpOwotCX0KLQotCXByaXZhdGUgU3RhdGVDaGFuZ2VMaXN0ZW5lcltdIGdldFN0YXRlQ2hhbmdlTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gKFN0YXRlQ2hhbmdlTGlzdGVuZXJbXSkgdGhpcy5nZXRMaXN0ZW5lcnMoU1RBVEVfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTKTsKLQl9Ci0KLQkvKioKLQkgKiBGaXJlIHRoZSBzcGVjaWZpZWQgc3RhdGUgY2hhbmdlIGV2ZW50IHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlU3RhdGVDaGFuZ2VkKFN0YXRlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQotCQlTdGF0ZUNoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0KLQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQlTdGF0ZUNoYW5nZUxpc3RlbmVyW10gc3RhdGVDaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldFN0YXRlQ2hhbmdlTGlzdGVuZXJzKCk7Ci0JCQlpZiAoc3RhdGVDaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSBzdGF0ZUNoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQl9Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChTdGF0ZUNoYW5nZUxpc3RlbmVyIHRhcmdldCA6IHRhcmdldHMpIHsKLQkJCQlib29sZWFuIHN0aWxsTGlzdGVuaW5nOwotCQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCQlzdGlsbExpc3RlbmluZyA9IENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmdldFN0YXRlQ2hhbmdlTGlzdGVuZXJzKCksIHRhcmdldCk7Ci0JCQkJfQotCQkJCWlmIChzdGlsbExpc3RlbmluZykgewotCQkJCQl0YXJnZXQuc3RhdGVDaGFuZ2VkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQotCQl0aGlzLnNvdXJjZUNoYW5nZWQobnVsbCk7Ci0JfQotCi0JLyoqCi0JICogUmVwb3J0IGEgZ2VuZXJpYyBzdGF0ZSBjaGFuZ2UgZXZlbnQgdG8gYW55IHJlZ2lzdGVyZWQgc3RhdGUgY2hhbmdlCi0JICogbGlzdGVuZXJzLgotCSAqLwotCXB1YmxpYyB2b2lkIGZpcmVTdGF0ZUNoYW5nZWQoKSB7Ci0vLwkJdGhpcy5maXJlU3RhdGVDaGFuZ2UobmV3IFN0YXRlQ2hhbmdlRXZlbnQodGhpcy5zb3VyY2UpKTsKLQotCQlTdGF0ZUNoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0KLQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQlTdGF0ZUNoYW5nZUxpc3RlbmVyW10gc3RhdGVDaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldFN0YXRlQ2hhbmdlTGlzdGVuZXJzKCk7Ci0JCQlpZiAoc3RhdGVDaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSBzdGF0ZUNoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQl9Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJU3RhdGVDaGFuZ2VFdmVudCBldmVudCA9IG51bGw7Ci0JCQlmb3IgKFN0YXRlQ2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0U3RhdGVDaGFuZ2VMaXN0ZW5lcnMoKSwgdGFyZ2V0KTsKLQkJCQl9Ci0JCQkJaWYgKHN0aWxsTGlzdGVuaW5nKSB7Ci0JCQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJCQkvLyBoZXJlJ3MgdGhlIHJlYXNvbiBmb3IgdGhlIGR1cGxpY2F0ZSBjb2RlLi4uCi0JCQkJCQlldmVudCA9IG5ldyBTdGF0ZUNoYW5nZUV2ZW50KHRoaXMuc291cmNlKTsKLQkJCQkJfQotCQkJCQl0YXJnZXQuc3RhdGVDaGFuZ2VkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQotCQl0aGlzLnNvdXJjZUNoYW5nZWQobnVsbCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHByb3BlcnR5IGNoYW5nZSBzdXBwb3J0ICoqKioqKioqKioKLQotCXByb3RlY3RlZCBzdGF0aWMgZmluYWwgQ2xhc3M8UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcj4gUFJPUEVSVFlfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTID0gUHJvcGVydHlDaGFuZ2VMaXN0ZW5lci5jbGFzczsKLQotCS8qKgotCSAqIEFkZCBhIHByb3BlcnR5IGNoYW5nZSBsaXN0ZW5lciB0aGF0IGlzIHJlZ2lzdGVyZWQgZm9yIGFsbCBwcm9wZXJ0aWVzLgotCSAqLwotCXB1YmxpYyB2b2lkIGFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLmFkZExpc3RlbmVyKFBST1BFUlRZX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgbGlzdGVuZXIpOwotCX0KLQotCS8qKgotCSAqIEFkZCBhIHByb3BlcnR5IGNoYW5nZSBsaXN0ZW5lciBmb3IgdGhlIHNwZWNpZmllZCBwcm9wZXJ0eS4gVGhlIGxpc3RlbmVyCi0JICogd2lsbCBiZSBub3RpZmllZCBvbmx5IGZvciBjaGFuZ2VzIHRvIHRoZSBzcGVjaWZpZWQgcHJvcGVydHkuCi0JICovCi0JcHVibGljIHZvaWQgYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihTdHJpbmcgcHJvcGVydHlOYW1lLCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMuYWRkTGlzdGVuZXIocHJvcGVydHlOYW1lLCBQUk9QRVJUWV9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYSBwcm9wZXJ0eSBjaGFuZ2UgbGlzdGVuZXIgdGhhdCB3YXMgcmVnaXN0ZXJlZCBmb3IgYWxsIHByb3BlcnRpZXMuCi0JICovCi0JcHVibGljIHZvaWQgcmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMucmVtb3ZlTGlzdGVuZXIoUFJPUEVSVFlfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBsaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGEgcHJvcGVydHkgY2hhbmdlIGxpc3RlbmVyIHRoYXQgd2FzIHJlZ2lzdGVyZWQgZm9yIGEgc3BlY2lmaWMgcHJvcGVydHkuCi0JICovCi0JcHVibGljIHZvaWQgcmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihTdHJpbmcgcHJvcGVydHlOYW1lLCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMucmVtb3ZlTGlzdGVuZXIocHJvcGVydHlOYW1lLCBQUk9QRVJUWV9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGVyZSBhcmUgYW55IHByb3BlcnR5IGNoYW5nZSBsaXN0ZW5lcnMgdGhhdCB3aWxsCi0JICogYmUgbm90aWZpZWQgd2hlbiB0aGUgc3BlY2lmaWVkIHByb3BlcnR5IGhhcyBjaGFuZ2VkLgotCSAqLwotCXB1YmxpYyBib29sZWFuIGhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFN0cmluZyBwcm9wZXJ0eU5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuaGFzQW55TGlzdGVuZXJzKFBST1BFUlRZX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgcHJvcGVydHlOYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGVyZSBhcmUgYW55IHByb3BlcnR5IGNoYW5nZSBsaXN0ZW5lcnMgdGhhdCB3aWxsCi0JICogYmUgbm90aWZpZWQgd2hlbiBhbnkgcHJvcGVydHkgaGFzIGNoYW5nZWQuCi0JICovCi0JcHVibGljIGJvb2xlYW4gaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoKSB7Ci0JCXJldHVybiB0aGlzLmhhc0FueUxpc3RlbmVycyhQUk9QRVJUWV9DSEFOR0VfTElTVEVORVJfQ0xBU1MpOwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcltdIGdldFByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gKFByb3BlcnR5Q2hhbmdlTGlzdGVuZXJbXSkgdGhpcy5nZXRMaXN0ZW5lcnMoUFJPUEVSVFlfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTKTsKLQl9Ci0KLQkvKioKLQkgKiBGaXJlIHRoZSBzcGVjaWZpZWQgcHJvcGVydHkgY2hhbmdlIGV2ZW50IHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKiBObyBldmVudCBpcyBmaXJlZCBpZiB0aGUgZ2l2ZW4gZXZlbnQncyBvbGQgYW5kIG5ldyB2YWx1ZXMgYXJlIHRoZSBzYW1lOwotCSAqIHRoaXMgaW5jbHVkZXMgd2hlbiBib3RoIHZhbHVlcyBhcmUgbnVsbC4gVXNlIGEgc3RhdGUgY2hhbmdlIGV2ZW50Ci0JICogZm9yIGdlbmVyYWwgcHVycG9zZSBub3RpZmljYXRpb24gb2YgY2hhbmdlcy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlUHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaWYgKHRoaXMudmFsdWVzQXJlRXF1YWwoZXZlbnQuZ2V0T2xkVmFsdWUoKSwgZXZlbnQuZ2V0TmV3VmFsdWUoKSkpIHsKLQkJCXJldHVybjsgCi0JCX0KLQotCQlTdHJpbmcgcHJvcGVydHlOYW1lID0gZXZlbnQuZ2V0UHJvcGVydHlOYW1lKCk7Ci0KLQkJUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJbXSBwcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyA9IHRoaXMuZ2V0UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChwcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyAhPSBudWxsKSB7Ci0JCQkJdGFyZ2V0cyA9IHByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzLmNsb25lKCk7Ci0JCQl9Ci0JCQljaGlsZCA9IHRoaXMuZ2V0Q2hpbGQocHJvcGVydHlOYW1lKTsKLQkJfQotCi0JCWlmICh0YXJnZXRzICE9IG51bGwpIHsKLQkJCWZvciAoUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciB0YXJnZXQgOiB0YXJnZXRzKSB7Ci0JCQkJYm9vbGVhbiBzdGlsbExpc3RlbmluZzsKLQkJCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCQkJc3RpbGxMaXN0ZW5pbmcgPSBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5nZXRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJdGFyZ2V0LnByb3BlcnR5Q2hhbmdlZChldmVudCk7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWlmIChjaGlsZCAhPSBudWxsKSB7Ci0JCQljaGlsZC5maXJlUHJvcGVydHlDaGFuZ2VkKGV2ZW50KTsKLQkJfQotCi0JCXRoaXMuc291cmNlQ2hhbmdlZChwcm9wZXJ0eU5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJlcG9ydCBhIGJvdW5kIHByb3BlcnR5IHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBwcm9wZXJ0eSBjaGFuZ2UgbGlzdGVuZXJzLgotCSAqIE5vIGV2ZW50IGlzIGZpcmVkIGlmIHRoZSBnaXZlbiBvbGQgYW5kIG5ldyB2YWx1ZXMgYXJlIHRoZSBzYW1lOwotCSAqIHRoaXMgaW5jbHVkZXMgd2hlbiBib3RoIHZhbHVlcyBhcmUgbnVsbC4gVXNlIGEgc3RhdGUgY2hhbmdlIGV2ZW50Ci0JICogZm9yIGdlbmVyYWwgcHVycG9zZSBub3RpZmljYXRpb24gb2YgY2hhbmdlcy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlUHJvcGVydHlDaGFuZ2VkKFN0cmluZyBwcm9wZXJ0eU5hbWUsIE9iamVjdCBvbGRWYWx1ZSwgT2JqZWN0IG5ld1ZhbHVlKSB7Ci0vLwkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKG5ldyBQcm9wZXJ0eUNoYW5nZUV2ZW50KHRoaXMuc291cmNlLCBwcm9wZXJ0eU5hbWUsIG9sZFZhbHVlLCBuZXdWYWx1ZSkpOwotCQlpZiAodGhpcy52YWx1ZXNBcmVFcXVhbChvbGRWYWx1ZSwgbmV3VmFsdWUpKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQotCQlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0JCUNoYW5nZVN1cHBvcnQgY2hpbGQgPSBudWxsOwotCi0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcltdIHByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzID0gdGhpcy5nZXRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycygpOwotCQkJaWYgKHByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gcHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMuY2xvbmUoKTsKLQkJCX0KLQkJCWNoaWxkID0gdGhpcy5nZXRDaGlsZChwcm9wZXJ0eU5hbWUpOwotCQl9Ci0KLQkJUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCA9IG51bGw7Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIHRhcmdldCA6IHRhcmdldHMpIHsKLQkJCQlib29sZWFuIHN0aWxsTGlzdGVuaW5nOwotCQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCQlzdGlsbExpc3RlbmluZyA9IENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmdldFByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKCksIHRhcmdldCk7Ci0JCQkJfQotCQkJCWlmIChzdGlsbExpc3RlbmluZykgewotCQkJCQlpZiAoZXZlbnQgPT0gbnVsbCkgewotCQkJCQkJLy8gaGVyZSdzIHRoZSByZWFzb24gZm9yIHRoZSBkdXBsaWNhdGUgY29kZS4uLgotCQkJCQkJZXZlbnQgPSBuZXcgUHJvcGVydHlDaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgcHJvcGVydHlOYW1lLCBvbGRWYWx1ZSwgbmV3VmFsdWUpOwotCQkJCQl9Ci0JCQkJCXRhcmdldC5wcm9wZXJ0eUNoYW5nZWQoZXZlbnQpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlpZiAoY2hpbGQgIT0gbnVsbCkgewotCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQljaGlsZC5maXJlUHJvcGVydHlDaGFuZ2VkKHByb3BlcnR5TmFtZSwgb2xkVmFsdWUsIG5ld1ZhbHVlKTsKLQkJCX0gZWxzZSB7Ci0JCQkJY2hpbGQuZmlyZVByb3BlcnR5Q2hhbmdlZChldmVudCk7Ci0JCQl9Ci0JCX0KLQotCQl0aGlzLnNvdXJjZUNoYW5nZWQocHJvcGVydHlOYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYW4gaW50IGJvdW5kIHByb3BlcnR5IHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICogTm8gZXZlbnQgaXMgZmlyZWQgaWYgb2xkIGFuZCBuZXcgYXJlIGVxdWFsLgotCSAqIDxwPgotCSAqIFRoaXMgaXMgbWVyZWx5IGEgY29udmVuaWVuY2Ugd3JhcHBlciBhcm91bmQgdGhlIG1vcmUgZ2VuZXJhbAotCSAqIGZpcmVQcm9wZXJ0eUNoYW5nZSBtZXRob2QgdGhhdCB0YWtlcyBPYmplY3QgdmFsdWVzLgotCSAqLwotCXB1YmxpYyB2b2lkIGZpcmVQcm9wZXJ0eUNoYW5nZWQoU3RyaW5nIHByb3BlcnR5TmFtZSwgaW50IG9sZFZhbHVlLCBpbnQgbmV3VmFsdWUpIHsKLS8vCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQocHJvcGVydHlOYW1lLCBuZXcgSW50ZWdlcihvbGRWYWx1ZSksIG5ldyBJbnRlZ2VyKG5ld1ZhbHVlKSk7Ci0JCWlmIChvbGRWYWx1ZSA9PSBuZXdWYWx1ZSkgewotCQkJcmV0dXJuOwotCQl9Ci0KLQkJUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJbXSBwcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyA9IHRoaXMuZ2V0UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChwcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyAhPSBudWxsKSB7Ci0JCQkJdGFyZ2V0cyA9IHByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzLmNsb25lKCk7Ci0JCQl9Ci0JCQljaGlsZCA9IHRoaXMuZ2V0Q2hpbGQocHJvcGVydHlOYW1lKTsKLQkJfQotCi0JCVByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQgPSBudWxsOwotCi0JCWlmICh0YXJnZXRzICE9IG51bGwpIHsKLQkJCWZvciAoUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciB0YXJnZXQgOiB0YXJnZXRzKSB7Ci0JCQkJYm9vbGVhbiBzdGlsbExpc3RlbmluZzsKLQkJCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCQkJc3RpbGxMaXN0ZW5pbmcgPSBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5nZXRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQkJCS8vIGhlcmUncyB0aGUgcmVhc29uIGZvciB0aGUgZHVwbGljYXRlIGNvZGUuLi4KLQkJCQkJCWV2ZW50ID0gbmV3IFByb3BlcnR5Q2hhbmdlRXZlbnQodGhpcy5zb3VyY2UsIHByb3BlcnR5TmFtZSwgbmV3IEludGVnZXIob2xkVmFsdWUpLCBuZXcgSW50ZWdlcihuZXdWYWx1ZSkpOwotCQkJCQl9Ci0JCQkJCXRhcmdldC5wcm9wZXJ0eUNoYW5nZWQoZXZlbnQpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlpZiAoY2hpbGQgIT0gbnVsbCkgewotCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQljaGlsZC5maXJlUHJvcGVydHlDaGFuZ2VkKHByb3BlcnR5TmFtZSwgb2xkVmFsdWUsIG5ld1ZhbHVlKTsKLQkJCX0gZWxzZSB7Ci0JCQkJY2hpbGQuZmlyZVByb3BlcnR5Q2hhbmdlZChldmVudCk7Ci0JCQl9Ci0JCX0KLQotCQl0aGlzLnNvdXJjZUNoYW5nZWQocHJvcGVydHlOYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYSBib29sZWFuIGJvdW5kIHByb3BlcnR5IHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICogTm8gZXZlbnQgaXMgZmlyZWQgaWYgb2xkIGFuZCBuZXcgYXJlIGVxdWFsLgotCSAqIDxwPgotCSAqIFRoaXMgaXMgbWVyZWx5IGEgY29udmVuaWVuY2Ugd3JhcHBlciBhcm91bmQgdGhlIG1vcmUgZ2VuZXJhbAotCSAqIGZpcmVQcm9wZXJ0eUNoYW5nZSBtZXRob2QgdGhhdCB0YWtlcyBPYmplY3QgdmFsdWVzLgotCSAqLwotCXB1YmxpYyB2b2lkIGZpcmVQcm9wZXJ0eUNoYW5nZWQoU3RyaW5nIHByb3BlcnR5TmFtZSwgYm9vbGVhbiBvbGRWYWx1ZSwgYm9vbGVhbiBuZXdWYWx1ZSkgewotLy8JCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChwcm9wZXJ0eU5hbWUsIEJvb2xlYW4udmFsdWVPZihvbGRWYWx1ZSksIEJvb2xlYW4udmFsdWVPZihuZXdWYWx1ZSkpOwotCQlpZiAob2xkVmFsdWUgPT0gbmV3VmFsdWUpIHsKLQkJCXJldHVybjsKLQkJfQotCi0JCVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJbXSB0YXJnZXRzID0gbnVsbDsKLQkJQ2hhbmdlU3VwcG9ydCBjaGlsZCA9IG51bGw7Ci0KLQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyW10gcHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldFByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKCk7Ci0JCQlpZiAocHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSBwcm9wZXJ0eUNoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKHByb3BlcnR5TmFtZSk7Ci0JCX0KLQotCQlQcm9wZXJ0eUNoYW5nZUV2ZW50IGV2ZW50ID0gbnVsbDsKLQotCQlpZiAodGFyZ2V0cyAhPSBudWxsKSB7Ci0JCQlmb3IgKFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoKSwgdGFyZ2V0KTsKLQkJCQl9Ci0JCQkJaWYgKHN0aWxsTGlzdGVuaW5nKSB7Ci0JCQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJCQkvLyBoZXJlJ3MgdGhlIHJlYXNvbiBmb3IgdGhlIGR1cGxpY2F0ZSBjb2RlLi4uCi0JCQkJCQlldmVudCA9IG5ldyBQcm9wZXJ0eUNoYW5nZUV2ZW50KHRoaXMuc291cmNlLCBwcm9wZXJ0eU5hbWUsIEJvb2xlYW4udmFsdWVPZihvbGRWYWx1ZSksIEJvb2xlYW4udmFsdWVPZihuZXdWYWx1ZSkpOwotCQkJCQl9Ci0JCQkJCXRhcmdldC5wcm9wZXJ0eUNoYW5nZWQoZXZlbnQpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlpZiAoY2hpbGQgIT0gbnVsbCkgewotCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQljaGlsZC5maXJlUHJvcGVydHlDaGFuZ2VkKHByb3BlcnR5TmFtZSwgb2xkVmFsdWUsIG5ld1ZhbHVlKTsKLQkJCX0gZWxzZSB7Ci0JCQkJY2hpbGQuZmlyZVByb3BlcnR5Q2hhbmdlZChldmVudCk7Ci0JCQl9Ci0JCX0KLQotCQl0aGlzLnNvdXJjZUNoYW5nZWQocHJvcGVydHlOYW1lKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY29sbGVjdGlvbiBjaGFuZ2Ugc3VwcG9ydCAqKioqKioqKioqCi0KLQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIENsYXNzPENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcj4gQ09MTEVDVElPTl9DSEFOR0VfTElTVEVORVJfQ0xBU1MgPSBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIuY2xhc3M7Ci0KLQkvKioKLQkgKiBBZGQgYSBjb2xsZWN0aW9uIGNoYW5nZSBsaXN0ZW5lciB0aGF0IGlzIHJlZ2lzdGVyZWQgZm9yIGFsbCBjb2xsZWN0aW9ucy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBhZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMuYWRkTGlzdGVuZXIoQ09MTEVDVElPTl9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBBZGQgYSBjb2xsZWN0aW9uIGNoYW5nZSBsaXN0ZW5lciBmb3IgdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLiBUaGUgbGlzdGVuZXIKLQkgKiB3aWxsIGJlIG5vdGlmaWVkIG9ubHkgZm9yIGNoYW5nZXMgdG8gdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLgotCSAqLwotCXB1YmxpYyB2b2lkIGFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihTdHJpbmcgY29sbGVjdGlvbk5hbWUsIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLmFkZExpc3RlbmVyKGNvbGxlY3Rpb25OYW1lLCBDT0xMRUNUSU9OX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgbGlzdGVuZXIpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBhIGNvbGxlY3Rpb24gY2hhbmdlIGxpc3RlbmVyIHRoYXQgd2FzIHJlZ2lzdGVyZWQgZm9yIGFsbCBjb2xsZWN0aW9ucy4KLQkgKi8KLQlwdWJsaWMgdm9pZCByZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMucmVtb3ZlTGlzdGVuZXIoQ09MTEVDVElPTl9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYSBjb2xsZWN0aW9uIGNoYW5nZSBsaXN0ZW5lciB0aGF0IHdhcyByZWdpc3RlcmVkIGZvciBhIHNwZWNpZmljIGNvbGxlY3Rpb24uCi0JICovCi0JcHVibGljIHZvaWQgcmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKFN0cmluZyBjb2xsZWN0aW9uTmFtZSwgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMucmVtb3ZlTGlzdGVuZXIoY29sbGVjdGlvbk5hbWUsIENPTExFQ1RJT05fQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBsaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlcmUgYXJlIGFueSBjb2xsZWN0aW9uIGNoYW5nZSBsaXN0ZW5lcnMgdGhhdCB3aWxsCi0JICogYmUgbm90aWZpZWQgd2hlbiB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24gaGFzIGNoYW5nZWQuCi0JICovCi0JcHVibGljIGJvb2xlYW4gaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuaGFzQW55TGlzdGVuZXJzKENPTExFQ1RJT05fQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlcmUgYXJlIGFueSBjb2xsZWN0aW9uIGNoYW5nZSBsaXN0ZW5lcnMgdGhhdCB3aWxsCi0JICogYmUgbm90aWZpZWQgd2hlbiBhbnkgY29sbGVjdGlvbiBoYXMgY2hhbmdlZC4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBoYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gdGhpcy5oYXNBbnlMaXN0ZW5lcnMoQ09MTEVDVElPTl9DSEFOR0VfTElTVEVORVJfQ0xBU1MpOwotCX0KLQotCXByaXZhdGUgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyW10gZ2V0Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycygpIHsKLQkJcmV0dXJuIChDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJbXSkgdGhpcy5nZXRMaXN0ZW5lcnMoQ09MTEVDVElPTl9DSEFOR0VfTElTVEVORVJfQ0xBU1MpOwotCX0KLQotCS8qKgotCSAqIFJlcG9ydCBhIGJvdW5kIGNvbGxlY3Rpb24gdXBkYXRlIHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlSXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaWYgKGV2ZW50Lml0ZW1zU2l6ZSgpID09IDApIHsKLQkJCXJldHVybjsKLQkJfQotCi0JCVN0cmluZyBjb2xsZWN0aW9uTmFtZSA9IGV2ZW50LmdldENvbGxlY3Rpb25OYW1lKCk7Ci0KLQkJQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0JCUNoYW5nZVN1cHBvcnQgY2hpbGQgPSBudWxsOwotCi0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyW10gY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyA9IHRoaXMuZ2V0Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycygpOwotCQkJaWYgKGNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSBjb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzLmNsb25lKCk7Ci0JCQl9Ci0JCQljaGlsZCA9IHRoaXMuZ2V0Q2hpbGQoY29sbGVjdGlvbk5hbWUpOwotCQl9Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJdGFyZ2V0Lml0ZW1zQWRkZWQoZXZlbnQpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlpZiAoY2hpbGQgIT0gbnVsbCkgewotCQkJY2hpbGQuZmlyZUl0ZW1zQWRkZWQoZXZlbnQpOwotCQl9Ci0KLQkJdGhpcy5zb3VyY2VDaGFuZ2VkKGNvbGxlY3Rpb25OYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYSBib3VuZCBjb2xsZWN0aW9uIHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIHZvaWQgZmlyZUl0ZW1zQWRkZWQoU3RyaW5nIGNvbGxlY3Rpb25OYW1lLCBDb2xsZWN0aW9uPD8+IGFkZGVkSXRlbXMpIHsKLS8vCQl0aGlzLmZpcmVJdGVtc0FkZGVkKG5ldyBDb2xsZWN0aW9uQ2hhbmdlRXZlbnQodGhpcy5zb3VyY2UsIGNvbGxlY3Rpb25OYW1lLCBhZGRlZEl0ZW1zKSk7Ci0JCWlmIChhZGRlZEl0ZW1zLmlzRW1wdHkoKSkgewotCQkJcmV0dXJuOwotCQl9Ci0KLQkJQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0JCUNoYW5nZVN1cHBvcnQgY2hpbGQgPSBudWxsOwotCi0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyW10gY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyA9IHRoaXMuZ2V0Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycygpOwotCQkJaWYgKGNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSBjb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzLmNsb25lKCk7Ci0JCQl9Ci0JCQljaGlsZCA9IHRoaXMuZ2V0Q2hpbGQoY29sbGVjdGlvbk5hbWUpOwotCQl9Ci0KLQkJQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50ID0gbnVsbDsKLQotCQlpZiAodGFyZ2V0cyAhPSBudWxsKSB7Ci0JCQlmb3IgKENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciB0YXJnZXQgOiB0YXJnZXRzKSB7Ci0JCQkJYm9vbGVhbiBzdGlsbExpc3RlbmluZzsKLQkJCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCQkJc3RpbGxMaXN0ZW5pbmcgPSBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5nZXRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKCksIHRhcmdldCk7Ci0JCQkJfQotCQkJCWlmIChzdGlsbExpc3RlbmluZykgewotCQkJCQlpZiAoZXZlbnQgPT0gbnVsbCkgewotCQkJCQkJLy8gaGVyZSdzIHRoZSByZWFzb24gZm9yIHRoZSBkdXBsaWNhdGUgY29kZS4uLgotCQkJCQkJZXZlbnQgPSBuZXcgQ29sbGVjdGlvbkNoYW5nZUV2ZW50KHRoaXMuc291cmNlLCBjb2xsZWN0aW9uTmFtZSwgYWRkZWRJdGVtcyk7Ci0JCQkJCX0KLQkJCQkJdGFyZ2V0Lml0ZW1zQWRkZWQoZXZlbnQpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlpZiAoY2hpbGQgIT0gbnVsbCkgewotCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQljaGlsZC5maXJlSXRlbXNBZGRlZChjb2xsZWN0aW9uTmFtZSwgYWRkZWRJdGVtcyk7Ci0JCQl9IGVsc2UgewotCQkJCWNoaWxkLmZpcmVJdGVtc0FkZGVkKGV2ZW50KTsKLQkJCX0KLQkJfQotCi0JCXRoaXMuc291cmNlQ2hhbmdlZChjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVwb3J0IGEgYm91bmQgY29sbGVjdGlvbiB1cGRhdGUgdG8gYW55IHJlZ2lzdGVyZWQgbGlzdGVuZXJzLgotCSAqLwotCXB1YmxpYyB2b2lkIGZpcmVJdGVtQWRkZWQoU3RyaW5nIGNvbGxlY3Rpb25OYW1lLCBPYmplY3QgYWRkZWRJdGVtKSB7Ci0vLwkJdGhpcy5maXJlSXRlbXNBZGRlZChjb2xsZWN0aW9uTmFtZSwgQ29sbGVjdGlvbnMuc2luZ2xldG9uKGFkZGVkSXRlbSkpOwotCi0JCUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcltdIGNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChjb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKGNvbGxlY3Rpb25OYW1lKTsKLQkJfQotCi0JCUNvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCA9IG51bGw7Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQkJCS8vIGhlcmUncyB0aGUgcmVhc29uIGZvciB0aGUgZHVwbGljYXRlIGNvZGUuLi4KLQkJCQkJCWV2ZW50ID0gbmV3IENvbGxlY3Rpb25DaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgY29sbGVjdGlvbk5hbWUsIENvbGxlY3Rpb25zLnNpbmdsZXRvbihhZGRlZEl0ZW0pKTsKLQkJCQkJfQotCQkJCQl0YXJnZXQuaXRlbXNBZGRlZChldmVudCk7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWlmIChjaGlsZCAhPSBudWxsKSB7Ci0JCQlpZiAoZXZlbnQgPT0gbnVsbCkgewotCQkJCWNoaWxkLmZpcmVJdGVtQWRkZWQoY29sbGVjdGlvbk5hbWUsIGFkZGVkSXRlbSk7Ci0JCQl9IGVsc2UgewotCQkJCWNoaWxkLmZpcmVJdGVtc0FkZGVkKGV2ZW50KTsKLQkJCX0KLQkJfQotCi0JCXRoaXMuc291cmNlQ2hhbmdlZChjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVwb3J0IGEgYm91bmQgY29sbGVjdGlvbiB1cGRhdGUgdG8gYW55IHJlZ2lzdGVyZWQgbGlzdGVuZXJzLgotCSAqLwotCXB1YmxpYyB2b2lkIGZpcmVJdGVtc1JlbW92ZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCWlmIChldmVudC5pdGVtc1NpemUoKSA9PSAwKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQotCQlTdHJpbmcgY29sbGVjdGlvbk5hbWUgPSBldmVudC5nZXRDb2xsZWN0aW9uTmFtZSgpOwotCi0JCUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcltdIGNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChjb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKGNvbGxlY3Rpb25OYW1lKTsKLQkJfQotCi0JCWlmICh0YXJnZXRzICE9IG51bGwpIHsKLQkJCWZvciAoQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIHRhcmdldCA6IHRhcmdldHMpIHsKLQkJCQlib29sZWFuIHN0aWxsTGlzdGVuaW5nOwotCQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCQlzdGlsbExpc3RlbmluZyA9IENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmdldENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoKSwgdGFyZ2V0KTsKLQkJCQl9Ci0JCQkJaWYgKHN0aWxsTGlzdGVuaW5nKSB7Ci0JCQkJCXRhcmdldC5pdGVtc1JlbW92ZWQoZXZlbnQpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlpZiAoY2hpbGQgIT0gbnVsbCkgewotCQkJY2hpbGQuZmlyZUl0ZW1zUmVtb3ZlZChldmVudCk7Ci0JCX0KLQotCQl0aGlzLnNvdXJjZUNoYW5nZWQoY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJlcG9ydCBhIGJvdW5kIGNvbGxlY3Rpb24gdXBkYXRlIHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlSXRlbXNSZW1vdmVkKFN0cmluZyBjb2xsZWN0aW9uTmFtZSwgQ29sbGVjdGlvbjw/PiByZW1vdmVkSXRlbXMpIHsKLS8vCQl0aGlzLmZpcmVJdGVtc1JlbW92ZWQobmV3IENvbGxlY3Rpb25DaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgY29sbGVjdGlvbk5hbWUsIHJlbW92ZWRJdGVtcykpOwotCQlpZiAocmVtb3ZlZEl0ZW1zLmlzRW1wdHkoKSkgewotCQkJcmV0dXJuOwotCQl9Ci0KLQkJQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0JCUNoYW5nZVN1cHBvcnQgY2hpbGQgPSBudWxsOwotCi0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyW10gY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyA9IHRoaXMuZ2V0Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycygpOwotCQkJaWYgKGNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSBjb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzLmNsb25lKCk7Ci0JCQl9Ci0JCQljaGlsZCA9IHRoaXMuZ2V0Q2hpbGQoY29sbGVjdGlvbk5hbWUpOwotCQl9Ci0KLQkJQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50ID0gbnVsbDsKLQotCQlpZiAodGFyZ2V0cyAhPSBudWxsKSB7Ci0JCQlmb3IgKENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciB0YXJnZXQgOiB0YXJnZXRzKSB7Ci0JCQkJYm9vbGVhbiBzdGlsbExpc3RlbmluZzsKLQkJCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCQkJc3RpbGxMaXN0ZW5pbmcgPSBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5nZXRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKCksIHRhcmdldCk7Ci0JCQkJfQotCQkJCWlmIChzdGlsbExpc3RlbmluZykgewotCQkJCQlpZiAoZXZlbnQgPT0gbnVsbCkgewotCQkJCQkJLy8gaGVyZSdzIHRoZSByZWFzb24gZm9yIHRoZSBkdXBsaWNhdGUgY29kZS4uLgotCQkJCQkJZXZlbnQgPSBuZXcgQ29sbGVjdGlvbkNoYW5nZUV2ZW50KHRoaXMuc291cmNlLCBjb2xsZWN0aW9uTmFtZSwgcmVtb3ZlZEl0ZW1zKTsKLQkJCQkJfQotCQkJCQl0YXJnZXQuaXRlbXNSZW1vdmVkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGNoaWxkICE9IG51bGwpIHsKLQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJY2hpbGQuZmlyZUl0ZW1zUmVtb3ZlZChjb2xsZWN0aW9uTmFtZSwgcmVtb3ZlZEl0ZW1zKTsKLQkJCX0gZWxzZSB7Ci0JCQkJY2hpbGQuZmlyZUl0ZW1zUmVtb3ZlZChldmVudCk7Ci0JCQl9Ci0JCX0KLQotCQl0aGlzLnNvdXJjZUNoYW5nZWQoY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJlcG9ydCBhIGJvdW5kIGNvbGxlY3Rpb24gdXBkYXRlIHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlSXRlbVJlbW92ZWQoU3RyaW5nIGNvbGxlY3Rpb25OYW1lLCBPYmplY3QgcmVtb3ZlZEl0ZW0pIHsKLS8vCQl0aGlzLmZpcmVJdGVtc1JlbW92ZWQoY29sbGVjdGlvbk5hbWUsIENvbGxlY3Rpb25zLnNpbmdsZXRvbihyZW1vdmVkSXRlbSkpOwotCi0JCUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcltdIGNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChjb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKGNvbGxlY3Rpb25OYW1lKTsKLQkJfQotCi0JCUNvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCA9IG51bGw7Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQkJCS8vIGhlcmUncyB0aGUgcmVhc29uIGZvciB0aGUgZHVwbGljYXRlIGNvZGUuLi4KLQkJCQkJCWV2ZW50ID0gbmV3IENvbGxlY3Rpb25DaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgY29sbGVjdGlvbk5hbWUsIENvbGxlY3Rpb25zLnNpbmdsZXRvbihyZW1vdmVkSXRlbSkpOwotCQkJCQl9Ci0JCQkJCXRhcmdldC5pdGVtc1JlbW92ZWQoZXZlbnQpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlpZiAoY2hpbGQgIT0gbnVsbCkgewotCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQljaGlsZC5maXJlSXRlbVJlbW92ZWQoY29sbGVjdGlvbk5hbWUsIHJlbW92ZWRJdGVtKTsKLQkJCX0gZWxzZSB7Ci0JCQkJY2hpbGQuZmlyZUl0ZW1zUmVtb3ZlZChldmVudCk7Ci0JCQl9Ci0JCX0KLQotCQl0aGlzLnNvdXJjZUNoYW5nZWQoY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJlcG9ydCBhIGJvdW5kIGNvbGxlY3Rpb24gdXBkYXRlIHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlQ29sbGVjdGlvbkNsZWFyZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCVN0cmluZyBjb2xsZWN0aW9uTmFtZSA9IGV2ZW50LmdldENvbGxlY3Rpb25OYW1lKCk7Ci0KLQkJQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0JCUNoYW5nZVN1cHBvcnQgY2hpbGQgPSBudWxsOwotCi0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyW10gY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyA9IHRoaXMuZ2V0Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycygpOwotCQkJaWYgKGNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSBjb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzLmNsb25lKCk7Ci0JCQl9Ci0JCQljaGlsZCA9IHRoaXMuZ2V0Q2hpbGQoY29sbGVjdGlvbk5hbWUpOwotCQl9Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJdGFyZ2V0LmNvbGxlY3Rpb25DbGVhcmVkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGNoaWxkICE9IG51bGwpIHsKLQkJCWNoaWxkLmZpcmVDb2xsZWN0aW9uQ2xlYXJlZChldmVudCk7Ci0JCX0KLQotCQl0aGlzLnNvdXJjZUNoYW5nZWQoY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJlcG9ydCBhIGJvdW5kIGNvbGxlY3Rpb24gdXBkYXRlIHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlQ29sbGVjdGlvbkNsZWFyZWQoU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0vLwkJdGhpcy5maXJlQ29sbGVjdGlvbkNsZWFyZWQobmV3IENvbGxlY3Rpb25DaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgY29sbGVjdGlvbk5hbWUpKTsKLQotCQlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJbXSB0YXJnZXRzID0gbnVsbDsKLQkJQ2hhbmdlU3VwcG9ydCBjaGlsZCA9IG51bGw7Ci0KLQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJbXSBjb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzID0gdGhpcy5nZXRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKCk7Ci0JCQlpZiAoY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyAhPSBudWxsKSB7Ci0JCQkJdGFyZ2V0cyA9IGNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMuY2xvbmUoKTsKLQkJCX0KLQkJCWNoaWxkID0gdGhpcy5nZXRDaGlsZChjb2xsZWN0aW9uTmFtZSk7Ci0JCX0KLQotCQlDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQgPSBudWxsOwotCi0JCWlmICh0YXJnZXRzICE9IG51bGwpIHsKLQkJCWZvciAoQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIHRhcmdldCA6IHRhcmdldHMpIHsKLQkJCQlib29sZWFuIHN0aWxsTGlzdGVuaW5nOwotCQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCQlzdGlsbExpc3RlbmluZyA9IENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmdldENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoKSwgdGFyZ2V0KTsKLQkJCQl9Ci0JCQkJaWYgKHN0aWxsTGlzdGVuaW5nKSB7Ci0JCQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJCQkvLyBoZXJlJ3MgdGhlIHJlYXNvbiBmb3IgdGhlIGR1cGxpY2F0ZSBjb2RlLi4uCi0JCQkJCQlldmVudCA9IG5ldyBDb2xsZWN0aW9uQ2hhbmdlRXZlbnQodGhpcy5zb3VyY2UsIGNvbGxlY3Rpb25OYW1lKTsKLQkJCQkJfQotCQkJCQl0YXJnZXQuY29sbGVjdGlvbkNsZWFyZWQoZXZlbnQpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlpZiAoY2hpbGQgIT0gbnVsbCkgewotCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQljaGlsZC5maXJlQ29sbGVjdGlvbkNsZWFyZWQoY29sbGVjdGlvbk5hbWUpOwotCQkJfSBlbHNlIHsKLQkJCQljaGlsZC5maXJlQ29sbGVjdGlvbkNsZWFyZWQoZXZlbnQpOwotCQkJfQotCQl9Ci0KLQkJdGhpcy5zb3VyY2VDaGFuZ2VkKGNvbGxlY3Rpb25OYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYSBib3VuZCBjb2xsZWN0aW9uIHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIHZvaWQgZmlyZUNvbGxlY3Rpb25DaGFuZ2VkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQlTdHJpbmcgY29sbGVjdGlvbk5hbWUgPSBldmVudC5nZXRDb2xsZWN0aW9uTmFtZSgpOwotCi0JCUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcltdIGNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChjb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKGNvbGxlY3Rpb25OYW1lKTsKLQkJfQotCi0JCWlmICh0YXJnZXRzICE9IG51bGwpIHsKLQkJCWZvciAoQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIHRhcmdldCA6IHRhcmdldHMpIHsKLQkJCQlib29sZWFuIHN0aWxsTGlzdGVuaW5nOwotCQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCQlzdGlsbExpc3RlbmluZyA9IENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmdldENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoKSwgdGFyZ2V0KTsKLQkJCQl9Ci0JCQkJaWYgKHN0aWxsTGlzdGVuaW5nKSB7Ci0JCQkJCXRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZChldmVudCk7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWlmIChjaGlsZCAhPSBudWxsKSB7Ci0JCQljaGlsZC5maXJlQ29sbGVjdGlvbkNoYW5nZWQoZXZlbnQpOwotCQl9Ci0KLQkJdGhpcy5zb3VyY2VDaGFuZ2VkKGNvbGxlY3Rpb25OYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYSBib3VuZCBjb2xsZWN0aW9uIHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIHZvaWQgZmlyZUNvbGxlY3Rpb25DaGFuZ2VkKFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotLy8JCXRoaXMuZmlyZUNvbGxlY3Rpb25DaGFuZ2VkKG5ldyBDb2xsZWN0aW9uQ2hhbmdlRXZlbnQodGhpcy5zb3VyY2UsIGNvbGxlY3Rpb25OYW1lKSk7Ci0KLQkJQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0JCUNoYW5nZVN1cHBvcnQgY2hpbGQgPSBudWxsOwotCi0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyW10gY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyA9IHRoaXMuZ2V0Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycygpOwotCQkJaWYgKGNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSBjb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzLmNsb25lKCk7Ci0JCQl9Ci0JCQljaGlsZCA9IHRoaXMuZ2V0Q2hpbGQoY29sbGVjdGlvbk5hbWUpOwotCQl9Ci0KLQkJQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50ID0gbnVsbDsKLQotCQlpZiAodGFyZ2V0cyAhPSBudWxsKSB7Ci0JCQlmb3IgKENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciB0YXJnZXQgOiB0YXJnZXRzKSB7Ci0JCQkJYm9vbGVhbiBzdGlsbExpc3RlbmluZzsKLQkJCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCQkJc3RpbGxMaXN0ZW5pbmcgPSBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5nZXRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKCksIHRhcmdldCk7Ci0JCQkJfQotCQkJCWlmIChzdGlsbExpc3RlbmluZykgewotCQkJCQlpZiAoZXZlbnQgPT0gbnVsbCkgewotCQkJCQkJLy8gaGVyZSdzIHRoZSByZWFzb24gZm9yIHRoZSBkdXBsaWNhdGUgY29kZS4uLgotCQkJCQkJZXZlbnQgPSBuZXcgQ29sbGVjdGlvbkNoYW5nZUV2ZW50KHRoaXMuc291cmNlLCBjb2xsZWN0aW9uTmFtZSk7Ci0JCQkJCX0KLQkJCQkJdGFyZ2V0LmNvbGxlY3Rpb25DaGFuZ2VkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGNoaWxkICE9IG51bGwpIHsKLQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJY2hpbGQuZmlyZUNvbGxlY3Rpb25DaGFuZ2VkKGNvbGxlY3Rpb25OYW1lKTsKLQkJCX0gZWxzZSB7Ci0JCQkJY2hpbGQuZmlyZUNvbGxlY3Rpb25DaGFuZ2VkKGV2ZW50KTsKLQkJCX0KLQkJfQotCi0JCXRoaXMuc291cmNlQ2hhbmdlZChjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogQWRkIHRoZSBzcGVjaWZpZWQgaXRlbSB0byB0aGUgc3BlY2lmaWVkIGJvdW5kIGNvbGxlY3Rpb24KLQkgKiBhbmQgZmlyZSB0aGUgYXBwcm9wcmlhdGUgZXZlbnQgaWYgbmVjZXNzYXJ5LgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjb2xsZWN0aW9uIGNoYW5nZWQuCi0JICogQHNlZSBqYXZhLnV0aWwuQ29sbGVjdGlvbiNhZGQoT2JqZWN0KQotCSAqLwotCXB1YmxpYyA8RT4gYm9vbGVhbiBhZGRJdGVtVG9Db2xsZWN0aW9uKEUgaXRlbSwgQ29sbGVjdGlvbjxFPiBjb2xsZWN0aW9uLCBTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJaWYgKGNvbGxlY3Rpb24uYWRkKGl0ZW0pKSB7Ci0JCQl0aGlzLmZpcmVJdGVtQWRkZWQoY29sbGVjdGlvbk5hbWUsIGl0ZW0pOwotCQkJcmV0dXJuIHRydWU7Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCS8qKgotCSAqIEFkZCB0aGUgc3BlY2lmaWVkIGl0ZW1zIHRvIHRoZSBzcGVjaWZpZWQgYm91bmQgY29sbGVjdGlvbgotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudCBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgY29sbGVjdGlvbiBjaGFuZ2VkLgotCSAqIEBzZWUgamF2YS51dGlsLkNvbGxlY3Rpb24jYWRkQWxsKGphdmEudXRpbC5Db2xsZWN0aW9uKQotCSAqLwotCXB1YmxpYyA8RT4gYm9vbGVhbiBhZGRJdGVtc1RvQ29sbGVjdGlvbihFW10gaXRlbXMsIENvbGxlY3Rpb248RT4gY29sbGVjdGlvbiwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0JCXJldHVybiAoaXRlbXMubGVuZ3RoICE9IDApCi0JCQkJJiYgdGhpcy5hZGRJdGVtc1RvQ29sbGVjdGlvbl8obmV3IEFycmF5SXRlcmF0b3I8RT4oaXRlbXMpLCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogQWRkIHRoZSBzcGVjaWZpZWQgaXRlbXMgdG8gdGhlIHNwZWNpZmllZCBib3VuZCBjb2xsZWN0aW9uCi0JICogYW5kIGZpcmUgdGhlIGFwcHJvcHJpYXRlIGV2ZW50IGlmIG5lY2Vzc2FyeS4KLQkgKiBSZXR1cm4gd2hldGhlciBjb2xsZWN0aW9uIGNoYW5nZWQuCi0JICogQHNlZSBqYXZhLnV0aWwuQ29sbGVjdGlvbiNhZGRBbGwoamF2YS51dGlsLkNvbGxlY3Rpb24pCi0JICovCi0JcHVibGljIDxFPiBib29sZWFuIGFkZEl0ZW1zVG9Db2xsZWN0aW9uKENvbGxlY3Rpb248PyBleHRlbmRzIEU+IGl0ZW1zLCBDb2xsZWN0aW9uPEU+IGNvbGxlY3Rpb24sIFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQlyZXR1cm4gKCAhIGl0ZW1zLmlzRW1wdHkoKSkKLQkJCQkmJiB0aGlzLmFkZEl0ZW1zVG9Db2xsZWN0aW9uXyhpdGVtcy5pdGVyYXRvcigpLCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogQWRkIHRoZSBzcGVjaWZpZWQgaXRlbXMgdG8gdGhlIHNwZWNpZmllZCBib3VuZCBjb2xsZWN0aW9uCi0JICogYW5kIGZpcmUgdGhlIGFwcHJvcHJpYXRlIGV2ZW50IGlmIG5lY2Vzc2FyeS4KLQkgKiBSZXR1cm4gd2hldGhlciBjb2xsZWN0aW9uIGNoYW5nZWQuCi0JICogQHNlZSBqYXZhLnV0aWwuQ29sbGVjdGlvbiNhZGRBbGwoamF2YS51dGlsLkNvbGxlY3Rpb24pCi0JICovCi0JcHVibGljIDxFPiBib29sZWFuIGFkZEl0ZW1zVG9Db2xsZWN0aW9uKEl0ZXJhYmxlPD8gZXh0ZW5kcyBFPiBpdGVtcywgQ29sbGVjdGlvbjxFPiBjb2xsZWN0aW9uLCBTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuYWRkSXRlbXNUb0NvbGxlY3Rpb24oaXRlbXMuaXRlcmF0b3IoKSwgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCS8qKgotCSAqIEFkZCB0aGUgc3BlY2lmaWVkIGl0ZW1zIHRvIHRoZSBzcGVjaWZpZWQgYm91bmQgY29sbGVjdGlvbgotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudCBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgY29sbGVjdGlvbiBjaGFuZ2VkLgotCSAqIEBzZWUgamF2YS51dGlsLkNvbGxlY3Rpb24jYWRkQWxsKGphdmEudXRpbC5Db2xsZWN0aW9uKQotCSAqLwotCXB1YmxpYyA8RT4gYm9vbGVhbiBhZGRJdGVtc1RvQ29sbGVjdGlvbihJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlbXMsIENvbGxlY3Rpb248RT4gY29sbGVjdGlvbiwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0JCXJldHVybiBpdGVtcy5oYXNOZXh0KCkKLQkJCQkmJiB0aGlzLmFkZEl0ZW1zVG9Db2xsZWN0aW9uXyhpdGVtcywgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCS8qKgotCSAqIG5vIGVtcHR5IGNoZWNrCi0JICovCi0JcHJvdGVjdGVkIDxFPiBib29sZWFuIGFkZEl0ZW1zVG9Db2xsZWN0aW9uXyhJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlbXMsIENvbGxlY3Rpb248RT4gY29sbGVjdGlvbiwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0JCUNvbGxlY3Rpb248RT4gYWRkZWRJdGVtcyA9IG51bGw7Ci0JCXdoaWxlIChpdGVtcy5oYXNOZXh0KCkpIHsKLQkJCUUgaXRlbSA9IGl0ZW1zLm5leHQoKTsKLQkJCWlmIChjb2xsZWN0aW9uLmFkZChpdGVtKSkgewotCQkJCWlmIChhZGRlZEl0ZW1zID09IG51bGwpIHsKLQkJCQkJYWRkZWRJdGVtcyA9IG5ldyBBcnJheUxpc3Q8RT4oKTsKLQkJCQl9Ci0JCQkJYWRkZWRJdGVtcy5hZGQoaXRlbSk7Ci0JCQl9Ci0JCX0KLQkJaWYgKGFkZGVkSXRlbXMgIT0gbnVsbCkgewotCQkJdGhpcy5maXJlSXRlbXNBZGRlZChjb2xsZWN0aW9uTmFtZSwgYWRkZWRJdGVtcyk7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgaXRlbSBmcm9tIHRoZSBzcGVjaWZpZWQgYm91bmQgY29sbGVjdGlvbgotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudCBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGNvbGxlY3Rpb24gY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5Db2xsZWN0aW9uI3JlbW92ZShPYmplY3QpCi0JICovCi0JcHVibGljIGJvb2xlYW4gcmVtb3ZlSXRlbUZyb21Db2xsZWN0aW9uKE9iamVjdCBpdGVtLCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQlpZiAoY29sbGVjdGlvbi5yZW1vdmUoaXRlbSkpIHsKLQkJCXRoaXMuZmlyZUl0ZW1SZW1vdmVkKGNvbGxlY3Rpb25OYW1lLCBpdGVtKTsKLQkJCXJldHVybiB0cnVlOwotCQl9Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgdGhlIHNwZWNpZmllZCBpdGVtcyBmcm9tIHRoZSBzcGVjaWZpZWQgYm91bmQgY29sbGVjdGlvbgotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudCBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGNvbGxlY3Rpb24gY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5Db2xsZWN0aW9uI3JlbW92ZUFsbChqYXZhLnV0aWwuQ29sbGVjdGlvbikKLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiByZW1vdmVJdGVtc0Zyb21Db2xsZWN0aW9uKE9iamVjdFtdIGl0ZW1zLCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQlyZXR1cm4gKGl0ZW1zLmxlbmd0aCAhPSAwKQotCQkJCSYmICggISBjb2xsZWN0aW9uLmlzRW1wdHkoKSkKLQkJCQkmJiB0aGlzLnJlbW92ZUl0ZW1zRnJvbUNvbGxlY3Rpb25fKG5ldyBBcnJheUl0ZXJhdG9yPE9iamVjdD4oaXRlbXMpLCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgaXRlbXMgZnJvbSB0aGUgc3BlY2lmaWVkIGJvdW5kIGNvbGxlY3Rpb24KLQkgKiBhbmQgZmlyZSB0aGUgYXBwcm9wcmlhdGUgZXZlbnQgaWYgbmVjZXNzYXJ5LgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjb2xsZWN0aW9uIGNoYW5nZWQuCi0JICogQHNlZSBqYXZhLnV0aWwuQ29sbGVjdGlvbiNyZW1vdmVBbGwoamF2YS51dGlsLkNvbGxlY3Rpb24pCi0JICovCi0JcHVibGljIGJvb2xlYW4gcmVtb3ZlSXRlbXNGcm9tQ29sbGVjdGlvbihDb2xsZWN0aW9uPD8+IGl0ZW1zLCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQlyZXR1cm4gKCAhIGl0ZW1zLmlzRW1wdHkoKSkKLQkJCQkmJiAoICEgY29sbGVjdGlvbi5pc0VtcHR5KCkpCi0JCQkJJiYgdGhpcy5yZW1vdmVJdGVtc0Zyb21Db2xsZWN0aW9uXyhpdGVtcy5pdGVyYXRvcigpLCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgaXRlbXMgZnJvbSB0aGUgc3BlY2lmaWVkIGJvdW5kIGNvbGxlY3Rpb24KLQkgKiBhbmQgZmlyZSB0aGUgYXBwcm9wcmlhdGUgZXZlbnQgaWYgbmVjZXNzYXJ5LgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjb2xsZWN0aW9uIGNoYW5nZWQuCi0JICogQHNlZSBqYXZhLnV0aWwuQ29sbGVjdGlvbiNyZW1vdmVBbGwoamF2YS51dGlsLkNvbGxlY3Rpb24pCi0JICovCi0JcHVibGljIGJvb2xlYW4gcmVtb3ZlSXRlbXNGcm9tQ29sbGVjdGlvbihJdGVyYWJsZTw/PiBpdGVtcywgQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uLCBTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJcmV0dXJuIHRoaXMucmVtb3ZlSXRlbXNGcm9tQ29sbGVjdGlvbihpdGVtcy5pdGVyYXRvcigpLCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgaXRlbXMgZnJvbSB0aGUgc3BlY2lmaWVkIGJvdW5kIGNvbGxlY3Rpb24KLQkgKiBhbmQgZmlyZSB0aGUgYXBwcm9wcmlhdGUgZXZlbnQgaWYgbmVjZXNzYXJ5LgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjb2xsZWN0aW9uIGNoYW5nZWQuCi0JICogQHNlZSBqYXZhLnV0aWwuQ29sbGVjdGlvbiNyZW1vdmVBbGwoamF2YS51dGlsLkNvbGxlY3Rpb24pCi0JICovCi0JcHVibGljIGJvb2xlYW4gcmVtb3ZlSXRlbXNGcm9tQ29sbGVjdGlvbihJdGVyYXRvcjw/PiBpdGVtcywgQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uLCBTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJcmV0dXJuIGl0ZW1zLmhhc05leHQoKQotCQkJCSYmICggISBjb2xsZWN0aW9uLmlzRW1wdHkoKSkKLQkJCQkmJiB0aGlzLnJlbW92ZUl0ZW1zRnJvbUNvbGxlY3Rpb25fKGl0ZW1zLCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogbm8gZW1wdHkgY2hlY2tzCi0JICovCi0JcHJvdGVjdGVkIGJvb2xlYW4gcmVtb3ZlSXRlbXNGcm9tQ29sbGVjdGlvbl8oSXRlcmF0b3I8Pz4gaXRlbXMsIENvbGxlY3Rpb248Pz4gY29sbGVjdGlvbiwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0JCUhhc2hCYWc8Pz4gcmVtb3ZlZEl0ZW1zID0gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24oaXRlbXMpOwotCQlyZW1vdmVkSXRlbXMucmV0YWluQWxsKGNvbGxlY3Rpb24pOwotCQlib29sZWFuIGNoYW5nZWQgPSBjb2xsZWN0aW9uLnJlbW92ZUFsbChyZW1vdmVkSXRlbXMpOwotCi0JCWlmICggISByZW1vdmVkSXRlbXMuaXNFbXB0eSgpKSB7Ci0JCQl0aGlzLmZpcmVJdGVtc1JlbW92ZWQoY29sbGVjdGlvbk5hbWUsIHJlbW92ZWRJdGVtcyk7Ci0JCX0KLQkJcmV0dXJuIGNoYW5nZWQ7Ci0JfQotCi0JLyoqCi0JICogUmV0YWluIHRoZSBzcGVjaWZpZWQgaXRlbXMgaW4gdGhlIHNwZWNpZmllZCBib3VuZCBjb2xsZWN0aW9uCi0JICogYW5kIGZpcmUgdGhlIGFwcHJvcHJpYXRlIGV2ZW50IGlmIG5lY2Vzc2FyeS4KLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgY29sbGVjdGlvbiBjaGFuZ2VkLgotCSAqIEBzZWUgamF2YS51dGlsLkNvbGxlY3Rpb24jcmV0YWluQWxsKGphdmEudXRpbC5Db2xsZWN0aW9uKQotCSAqLwotCXB1YmxpYyBib29sZWFuIHJldGFpbkl0ZW1zSW5Db2xsZWN0aW9uKE9iamVjdFtdIGl0ZW1zLCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQlpZiAoY29sbGVjdGlvbi5pc0VtcHR5KCkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlpZiAoaXRlbXMubGVuZ3RoID09IDApIHsKLQkJCXJldHVybiB0aGlzLmNsZWFyQ29sbGVjdGlvbl8oY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCQl9Ci0JCXJldHVybiB0aGlzLnJldGFpbkl0ZW1zSW5Db2xsZWN0aW9uXyhuZXcgQXJyYXlJdGVyYXRvcjxPYmplY3Q+KGl0ZW1zKSwgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJldGFpbiB0aGUgc3BlY2lmaWVkIGl0ZW1zIGluIHRoZSBzcGVjaWZpZWQgYm91bmQgY29sbGVjdGlvbgotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudCBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGNvbGxlY3Rpb24gY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5Db2xsZWN0aW9uI3JldGFpbkFsbChqYXZhLnV0aWwuQ29sbGVjdGlvbikKLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiByZXRhaW5JdGVtc0luQ29sbGVjdGlvbihDb2xsZWN0aW9uPD8+IGl0ZW1zLCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQlpZiAoY29sbGVjdGlvbi5pc0VtcHR5KCkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlpZiAoaXRlbXMuaXNFbXB0eSgpKSB7Ci0JCQlyZXR1cm4gdGhpcy5jbGVhckNvbGxlY3Rpb25fKGNvbGxlY3Rpb24sIGNvbGxlY3Rpb25OYW1lKTsKLQkJfQotCQlyZXR1cm4gdGhpcy5yZXRhaW5JdGVtc0luQ29sbGVjdGlvbl8oaXRlbXMuaXRlcmF0b3IoKSwgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJldGFpbiB0aGUgc3BlY2lmaWVkIGl0ZW1zIGluIHRoZSBzcGVjaWZpZWQgYm91bmQgY29sbGVjdGlvbgotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudCBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGNvbGxlY3Rpb24gY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5Db2xsZWN0aW9uI3JldGFpbkFsbChqYXZhLnV0aWwuQ29sbGVjdGlvbikKLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiByZXRhaW5JdGVtc0luQ29sbGVjdGlvbihJdGVyYWJsZTw/PiBpdGVtcywgQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uLCBTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJcmV0dXJuIHRoaXMucmV0YWluSXRlbXNJbkNvbGxlY3Rpb24oaXRlbXMuaXRlcmF0b3IoKSwgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJldGFpbiB0aGUgc3BlY2lmaWVkIGl0ZW1zIGluIHRoZSBzcGVjaWZpZWQgYm91bmQgY29sbGVjdGlvbgotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudCBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGNvbGxlY3Rpb24gY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5Db2xsZWN0aW9uI3JldGFpbkFsbChqYXZhLnV0aWwuQ29sbGVjdGlvbikKLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiByZXRhaW5JdGVtc0luQ29sbGVjdGlvbihJdGVyYXRvcjw/PiBpdGVtcywgQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uLCBTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJaWYgKGNvbGxlY3Rpb24uaXNFbXB0eSgpKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJaWYgKCAhIGl0ZW1zLmhhc05leHQoKSkgewotCQkJcmV0dXJuIHRoaXMuY2xlYXJDb2xsZWN0aW9uXyhjb2xsZWN0aW9uLCBjb2xsZWN0aW9uTmFtZSk7Ci0JCX0KLQkJcmV0dXJuIHRoaXMucmV0YWluSXRlbXNJbkNvbGxlY3Rpb25fKGl0ZW1zLCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogbm8gZW1wdHkgY2hlY2tzCi0JICovCi0JcHJvdGVjdGVkIGJvb2xlYW4gcmV0YWluSXRlbXNJbkNvbGxlY3Rpb25fKEl0ZXJhdG9yPD8+IGl0ZW1zLCBDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQlIYXNoQmFnPD8+IHJldGFpbmVkSXRlbXMgPSBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbihpdGVtcyk7Ci0JCUhhc2hCYWc8Pz4gcmVtb3ZlZEl0ZW1zID0gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24oY29sbGVjdGlvbik7Ci0JCXJlbW92ZWRJdGVtcy5yZW1vdmVBbGwocmV0YWluZWRJdGVtcyk7Ci0JCWJvb2xlYW4gY2hhbmdlZCA9IGNvbGxlY3Rpb24ucmV0YWluQWxsKHJldGFpbmVkSXRlbXMpOwotCi0JCWlmICggISByZW1vdmVkSXRlbXMuaXNFbXB0eSgpKSB7Ci0JCQl0aGlzLmZpcmVJdGVtc1JlbW92ZWQoY29sbGVjdGlvbk5hbWUsIHJlbW92ZWRJdGVtcyk7Ci0JCX0KLQkJcmV0dXJuIGNoYW5nZWQ7Ci0JfQotCi0JLyoqCi0JICogQ2xlYXIgdGhlIGVudGlyZSBjb2xsZWN0aW9uCi0JICogYW5kIGZpcmUgdGhlIGFwcHJvcHJpYXRlIGV2ZW50IGlmIG5lY2Vzc2FyeS4KLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgY29sbGVjdGlvbiBjaGFuZ2VkLgotCSAqIEBzZWUgamF2YS51dGlsLkNvbGxlY3Rpb24jY2xlYXIoKQotCSAqLwotCXB1YmxpYyBib29sZWFuIGNsZWFyQ29sbGVjdGlvbihDb2xsZWN0aW9uPD8+IGNvbGxlY3Rpb24sIFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQlpZiAoY29sbGVjdGlvbi5pc0VtcHR5KCkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlyZXR1cm4gdGhpcy5jbGVhckNvbGxlY3Rpb25fKGNvbGxlY3Rpb24sIGNvbGxlY3Rpb25OYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBubyBlbXB0eSBjaGVjawotCSAqLwotCXByb3RlY3RlZCBib29sZWFuIGNsZWFyQ29sbGVjdGlvbl8oQ29sbGVjdGlvbjw/PiBjb2xsZWN0aW9uLCBTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJY29sbGVjdGlvbi5jbGVhcigpOwotCQl0aGlzLmZpcmVDb2xsZWN0aW9uQ2xlYXJlZChjb2xsZWN0aW9uTmFtZSk7Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCS8qKgotCSAqIFN5bmNocm9uaXplIHRoZSBjb2xsZWN0aW9uIHdpdGggdGhlIHNwZWNpZmllZCBuZXcgY29sbGVjdGlvbiwKLQkgKiBtYWtpbmcgYSBtaW5pbXVtIG51bWJlciBvZiByZW1vdmVzIGFuZCBhZGRzLgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBjb2xsZWN0aW9uIGNoYW5nZWQuCi0JICovCi0JcHVibGljIDxFPiBib29sZWFuIHN5bmNocm9uaXplQ29sbGVjdGlvbihDb2xsZWN0aW9uPEU+IG5ld0NvbGxlY3Rpb24sIENvbGxlY3Rpb248RT4gY29sbGVjdGlvbiwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0JCWlmIChuZXdDb2xsZWN0aW9uLmlzRW1wdHkoKSkgewotCQkJcmV0dXJuIHRoaXMuY2xlYXJDb2xsZWN0aW9uKGNvbGxlY3Rpb24sIGNvbGxlY3Rpb25OYW1lKTsKLQkJfQotCi0JCWlmIChjb2xsZWN0aW9uLmlzRW1wdHkoKSkgewotCQkJcmV0dXJuIHRoaXMuYWRkSXRlbXNUb0NvbGxlY3Rpb24obmV3Q29sbGVjdGlvbiwgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCQl9Ci0KLQkJcmV0dXJuIHRoaXMuc3luY2hyb25pemVDb2xsZWN0aW9uXyhuZXdDb2xsZWN0aW9uLCBjb2xsZWN0aW9uLCBjb2xsZWN0aW9uTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogU3luY2hyb25pemUgdGhlIGNvbGxlY3Rpb24gd2l0aCB0aGUgc3BlY2lmaWVkIG5ldyBjb2xsZWN0aW9uLAotCSAqIG1ha2luZyBhIG1pbmltdW0gbnVtYmVyIG9mIHJlbW92ZXMgYW5kIGFkZHMuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGNvbGxlY3Rpb24gY2hhbmdlZC4KLQkgKi8KLQlwdWJsaWMgPEU+IGJvb2xlYW4gc3luY2hyb25pemVDb2xsZWN0aW9uKEl0ZXJhdG9yPEU+IG5ld0NvbGxlY3Rpb24sIENvbGxlY3Rpb248RT4gY29sbGVjdGlvbiwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0JCWlmICggISBuZXdDb2xsZWN0aW9uLmhhc05leHQoKSkgewotCQkJcmV0dXJuIHRoaXMuY2xlYXJDb2xsZWN0aW9uKGNvbGxlY3Rpb24sIGNvbGxlY3Rpb25OYW1lKTsKLQkJfQotCi0JCWlmIChjb2xsZWN0aW9uLmlzRW1wdHkoKSkgewotCQkJcmV0dXJuIHRoaXMuYWRkSXRlbXNUb0NvbGxlY3Rpb24obmV3Q29sbGVjdGlvbiwgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCQl9Ci0KLQkJcmV0dXJuIHRoaXMuc3luY2hyb25pemVDb2xsZWN0aW9uXyhDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbihuZXdDb2xsZWN0aW9uKSwgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCS8qKgotCSAqIG5vIGVtcHR5IGNoZWNrcwotCSAqLwotCXByb3RlY3RlZCA8RT4gYm9vbGVhbiBzeW5jaHJvbml6ZUNvbGxlY3Rpb25fKENvbGxlY3Rpb248RT4gbmV3Q29sbGVjdGlvbiwgQ29sbGVjdGlvbjxFPiBjb2xsZWN0aW9uLCBTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJYm9vbGVhbiBjaGFuZ2VkID0gZmFsc2U7Ci0JCUNvbGxlY3Rpb248RT4gcmVtb3ZlSXRlbXMgPSBuZXcgSGFzaEJhZzxFPihjb2xsZWN0aW9uKTsKLQkJcmVtb3ZlSXRlbXMucmVtb3ZlQWxsKG5ld0NvbGxlY3Rpb24pOwotCQljaGFuZ2VkIHw9IHRoaXMucmVtb3ZlSXRlbXNGcm9tQ29sbGVjdGlvbihyZW1vdmVJdGVtcywgY29sbGVjdGlvbiwgY29sbGVjdGlvbk5hbWUpOwotCi0JCUNvbGxlY3Rpb248RT4gYWRkSXRlbXMgPSBuZXcgSGFzaEJhZzxFPihuZXdDb2xsZWN0aW9uKTsKLQkJYWRkSXRlbXMucmVtb3ZlQWxsKGNvbGxlY3Rpb24pOwotCQljaGFuZ2VkIHw9IHRoaXMuYWRkSXRlbXNUb0NvbGxlY3Rpb24oYWRkSXRlbXMsIGNvbGxlY3Rpb24sIGNvbGxlY3Rpb25OYW1lKTsKLQotCQlyZXR1cm4gY2hhbmdlZDsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogbGlzdCBjaGFuZ2Ugc3VwcG9ydCAqKioqKioqKioqCi0KLQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIENsYXNzPExpc3RDaGFuZ2VMaXN0ZW5lcj4gTElTVF9DSEFOR0VfTElTVEVORVJfQ0xBU1MgPSBMaXN0Q2hhbmdlTGlzdGVuZXIuY2xhc3M7Ci0KLQkvKioKLQkgKiBBZGQgYSBsaXN0IGNoYW5nZSBsaXN0ZW5lciB0aGF0IGlzIHJlZ2lzdGVyZWQgZm9yIGFsbCBsaXN0cy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBhZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMuYWRkTGlzdGVuZXIoTElTVF9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBBZGQgYSBsaXN0IGNoYW5nZSBsaXN0ZW5lciBmb3IgdGhlIHNwZWNpZmllZCBsaXN0LiBUaGUgbGlzdGVuZXIKLQkgKiB3aWxsIGJlIG5vdGlmaWVkIG9ubHkgZm9yIGNoYW5nZXMgdG8gdGhlIHNwZWNpZmllZCBsaXN0LgotCSAqLwotCXB1YmxpYyB2b2lkIGFkZExpc3RDaGFuZ2VMaXN0ZW5lcihTdHJpbmcgbGlzdE5hbWUsIExpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLmFkZExpc3RlbmVyKGxpc3ROYW1lLCBMSVNUX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgbGlzdGVuZXIpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBhIGxpc3QgY2hhbmdlIGxpc3RlbmVyIHRoYXQgd2FzIHJlZ2lzdGVyZWQgZm9yIGFsbCBsaXN0cy4KLQkgKi8KLQlwdWJsaWMgdm9pZCByZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMucmVtb3ZlTGlzdGVuZXIoTElTVF9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYSBsaXN0IGNoYW5nZSBsaXN0ZW5lciB0aGF0IHdhcyByZWdpc3RlcmVkIGZvciBhIHNwZWNpZmljIGxpc3QuCi0JICovCi0JcHVibGljIHZvaWQgcmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKFN0cmluZyBsaXN0TmFtZSwgTGlzdENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMucmVtb3ZlTGlzdGVuZXIobGlzdE5hbWUsIExJU1RfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBsaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlcmUgYXJlIGFueSBsaXN0IGNoYW5nZSBsaXN0ZW5lcnMgdGhhdCB3aWxsCi0JICogYmUgbm90aWZpZWQgd2hlbiB0aGUgc3BlY2lmaWVkIGxpc3QgaGFzIGNoYW5nZWQuCi0JICovCi0JcHVibGljIGJvb2xlYW4gaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuaGFzQW55TGlzdGVuZXJzKExJU1RfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlcmUgYXJlIGFueSBsaXN0IGNoYW5nZSBsaXN0ZW5lcnMgdGhhdCB3aWxsCi0JICogYmUgbm90aWZpZWQgd2hlbiBhbnkgbGlzdCBoYXMgY2hhbmdlZC4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBoYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gdGhpcy5oYXNBbnlMaXN0ZW5lcnMoTElTVF9DSEFOR0VfTElTVEVORVJfQ0xBU1MpOwotCX0KLQotCXByaXZhdGUgTGlzdENoYW5nZUxpc3RlbmVyW10gZ2V0TGlzdENoYW5nZUxpc3RlbmVycygpIHsKLQkJcmV0dXJuIChMaXN0Q2hhbmdlTGlzdGVuZXJbXSkgdGhpcy5nZXRMaXN0ZW5lcnMoTElTVF9DSEFOR0VfTElTVEVORVJfQ0xBU1MpOwotCX0KLQotCS8qKgotCSAqIFJlcG9ydCBhIGJvdW5kIGxpc3QgdXBkYXRlIHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlSXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaWYgKGV2ZW50Lml0ZW1zU2l6ZSgpID09IDApIHsKLQkJCXJldHVybjsKLQkJfQotCi0JCVN0cmluZyBsaXN0TmFtZSA9IGV2ZW50LmdldExpc3ROYW1lKCk7Ci0KLQkJTGlzdENoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0JCUNoYW5nZVN1cHBvcnQgY2hpbGQgPSBudWxsOwotCi0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJTGlzdENoYW5nZUxpc3RlbmVyW10gbGlzdENoYW5nZUxpc3RlbmVycyA9IHRoaXMuZ2V0TGlzdENoYW5nZUxpc3RlbmVycygpOwotCQkJaWYgKGxpc3RDaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSBsaXN0Q2hhbmdlTGlzdGVuZXJzLmNsb25lKCk7Ci0JCQl9Ci0JCQljaGlsZCA9IHRoaXMuZ2V0Q2hpbGQobGlzdE5hbWUpOwotCQl9Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChMaXN0Q2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0TGlzdENoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJdGFyZ2V0Lml0ZW1zQWRkZWQoZXZlbnQpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlpZiAoY2hpbGQgIT0gbnVsbCkgewotCQkJY2hpbGQuZmlyZUl0ZW1zQWRkZWQoZXZlbnQpOwotCQl9Ci0KLQkJdGhpcy5zb3VyY2VDaGFuZ2VkKGxpc3ROYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYSBib3VuZCBsaXN0IHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIHZvaWQgZmlyZUl0ZW1zQWRkZWQoU3RyaW5nIGxpc3ROYW1lLCBpbnQgaW5kZXgsIExpc3Q8Pz4gYWRkZWRJdGVtcykgewotLy8JCXRoaXMuZmlyZUl0ZW1zQWRkZWQobmV3IExpc3RDaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgbGlzdE5hbWUsIGluZGV4LCBhZGRlZEl0ZW1zKSk7Ci0JCWlmIChhZGRlZEl0ZW1zLmlzRW1wdHkoKSkgewotCQkJcmV0dXJuOwotCQl9Ci0KLQkJTGlzdENoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0JCUNoYW5nZVN1cHBvcnQgY2hpbGQgPSBudWxsOwotCi0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJTGlzdENoYW5nZUxpc3RlbmVyW10gbGlzdENoYW5nZUxpc3RlbmVycyA9IHRoaXMuZ2V0TGlzdENoYW5nZUxpc3RlbmVycygpOwotCQkJaWYgKGxpc3RDaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSBsaXN0Q2hhbmdlTGlzdGVuZXJzLmNsb25lKCk7Ci0JCQl9Ci0JCQljaGlsZCA9IHRoaXMuZ2V0Q2hpbGQobGlzdE5hbWUpOwotCQl9Ci0KLQkJTGlzdENoYW5nZUV2ZW50IGV2ZW50ID0gbnVsbDsKLQotCQlpZiAodGFyZ2V0cyAhPSBudWxsKSB7Ci0JCQlmb3IgKExpc3RDaGFuZ2VMaXN0ZW5lciB0YXJnZXQgOiB0YXJnZXRzKSB7Ci0JCQkJYm9vbGVhbiBzdGlsbExpc3RlbmluZzsKLQkJCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCQkJc3RpbGxMaXN0ZW5pbmcgPSBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5nZXRMaXN0Q2hhbmdlTGlzdGVuZXJzKCksIHRhcmdldCk7Ci0JCQkJfQotCQkJCWlmIChzdGlsbExpc3RlbmluZykgewotCQkJCQlpZiAoZXZlbnQgPT0gbnVsbCkgewotCQkJCQkJLy8gaGVyZSdzIHRoZSByZWFzb24gZm9yIHRoZSBkdXBsaWNhdGUgY29kZS4uLgotCQkJCQkJZXZlbnQgPSBuZXcgTGlzdENoYW5nZUV2ZW50KHRoaXMuc291cmNlLCBsaXN0TmFtZSwgaW5kZXgsIGFkZGVkSXRlbXMpOwotCQkJCQl9Ci0JCQkJCXRhcmdldC5pdGVtc0FkZGVkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGNoaWxkICE9IG51bGwpIHsKLQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJY2hpbGQuZmlyZUl0ZW1zQWRkZWQobGlzdE5hbWUsIGluZGV4LCBhZGRlZEl0ZW1zKTsKLQkJCX0gZWxzZSB7Ci0JCQkJY2hpbGQuZmlyZUl0ZW1zQWRkZWQoZXZlbnQpOwotCQkJfQotCQl9Ci0KLQkJdGhpcy5zb3VyY2VDaGFuZ2VkKGxpc3ROYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYSBib3VuZCBsaXN0IHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIHZvaWQgZmlyZUl0ZW1BZGRlZChTdHJpbmcgbGlzdE5hbWUsIGludCBpbmRleCwgT2JqZWN0IGFkZGVkSXRlbSkgewotLy8JCXRoaXMuZmlyZUl0ZW1zQWRkZWQobGlzdE5hbWUsIGluZGV4LCBDb2xsZWN0aW9ucy5zaW5nbGV0b25MaXN0KGFkZGVkSXRlbSkpOwotCi0JCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIGxpc3RDaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldExpc3RDaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChsaXN0Q2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gbGlzdENoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKGxpc3ROYW1lKTsKLQkJfQotCi0JCUxpc3RDaGFuZ2VFdmVudCBldmVudCA9IG51bGw7Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChMaXN0Q2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0TGlzdENoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQkJCS8vIGhlcmUncyB0aGUgcmVhc29uIGZvciB0aGUgZHVwbGljYXRlIGNvZGUuLi4KLQkJCQkJCWV2ZW50ID0gbmV3IExpc3RDaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgbGlzdE5hbWUsIGluZGV4LCBDb2xsZWN0aW9ucy5zaW5nbGV0b25MaXN0KGFkZGVkSXRlbSkpOwotCQkJCQl9Ci0JCQkJCXRhcmdldC5pdGVtc0FkZGVkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGNoaWxkICE9IG51bGwpIHsKLQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJY2hpbGQuZmlyZUl0ZW1BZGRlZChsaXN0TmFtZSwgaW5kZXgsIGFkZGVkSXRlbSk7Ci0JCQl9IGVsc2UgewotCQkJCWNoaWxkLmZpcmVJdGVtc0FkZGVkKGV2ZW50KTsKLQkJCX0KLQkJfQotCi0JCXRoaXMuc291cmNlQ2hhbmdlZChsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVwb3J0IGEgYm91bmQgbGlzdCB1cGRhdGUgdG8gYW55IHJlZ2lzdGVyZWQgbGlzdGVuZXJzLgotCSAqLwotCXB1YmxpYyB2b2lkIGZpcmVJdGVtc1JlbW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCWlmIChldmVudC5pdGVtc1NpemUoKSA9PSAwKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQotCQlTdHJpbmcgbGlzdE5hbWUgPSBldmVudC5nZXRMaXN0TmFtZSgpOwotCi0JCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIGxpc3RDaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldExpc3RDaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChsaXN0Q2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gbGlzdENoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKGxpc3ROYW1lKTsKLQkJfQotCi0JCWlmICh0YXJnZXRzICE9IG51bGwpIHsKLQkJCWZvciAoTGlzdENoYW5nZUxpc3RlbmVyIHRhcmdldCA6IHRhcmdldHMpIHsKLQkJCQlib29sZWFuIHN0aWxsTGlzdGVuaW5nOwotCQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCQlzdGlsbExpc3RlbmluZyA9IENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmdldExpc3RDaGFuZ2VMaXN0ZW5lcnMoKSwgdGFyZ2V0KTsKLQkJCQl9Ci0JCQkJaWYgKHN0aWxsTGlzdGVuaW5nKSB7Ci0JCQkJCXRhcmdldC5pdGVtc1JlbW92ZWQoZXZlbnQpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlpZiAoY2hpbGQgIT0gbnVsbCkgewotCQkJY2hpbGQuZmlyZUl0ZW1zUmVtb3ZlZChldmVudCk7Ci0JCX0KLQotCQl0aGlzLnNvdXJjZUNoYW5nZWQobGlzdE5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJlcG9ydCBhIGJvdW5kIGxpc3QgdXBkYXRlIHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlSXRlbXNSZW1vdmVkKFN0cmluZyBsaXN0TmFtZSwgaW50IGluZGV4LCBMaXN0PD8+IHJlbW92ZWRJdGVtcykgewotLy8JCXRoaXMuZmlyZUl0ZW1zUmVtb3ZlZChuZXcgTGlzdENoYW5nZUV2ZW50KHRoaXMuc291cmNlLCBsaXN0TmFtZSwgaW5kZXgsIHJlbW92ZWRJdGVtcykpOwotCQlpZiAocmVtb3ZlZEl0ZW1zLmlzRW1wdHkoKSkgewotCQkJcmV0dXJuOwotCQl9Ci0KLQkJTGlzdENoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0JCUNoYW5nZVN1cHBvcnQgY2hpbGQgPSBudWxsOwotCi0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJTGlzdENoYW5nZUxpc3RlbmVyW10gbGlzdENoYW5nZUxpc3RlbmVycyA9IHRoaXMuZ2V0TGlzdENoYW5nZUxpc3RlbmVycygpOwotCQkJaWYgKGxpc3RDaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSBsaXN0Q2hhbmdlTGlzdGVuZXJzLmNsb25lKCk7Ci0JCQl9Ci0JCQljaGlsZCA9IHRoaXMuZ2V0Q2hpbGQobGlzdE5hbWUpOwotCQl9Ci0KLQkJTGlzdENoYW5nZUV2ZW50IGV2ZW50ID0gbnVsbDsKLQotCQlpZiAodGFyZ2V0cyAhPSBudWxsKSB7Ci0JCQlmb3IgKExpc3RDaGFuZ2VMaXN0ZW5lciB0YXJnZXQgOiB0YXJnZXRzKSB7Ci0JCQkJYm9vbGVhbiBzdGlsbExpc3RlbmluZzsKLQkJCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCQkJc3RpbGxMaXN0ZW5pbmcgPSBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5nZXRMaXN0Q2hhbmdlTGlzdGVuZXJzKCksIHRhcmdldCk7Ci0JCQkJfQotCQkJCWlmIChzdGlsbExpc3RlbmluZykgewotCQkJCQlpZiAoZXZlbnQgPT0gbnVsbCkgewotCQkJCQkJLy8gaGVyZSdzIHRoZSByZWFzb24gZm9yIHRoZSBkdXBsaWNhdGUgY29kZS4uLgotCQkJCQkJZXZlbnQgPSBuZXcgTGlzdENoYW5nZUV2ZW50KHRoaXMuc291cmNlLCBsaXN0TmFtZSwgaW5kZXgsIHJlbW92ZWRJdGVtcyk7Ci0JCQkJCX0KLQkJCQkJdGFyZ2V0Lml0ZW1zUmVtb3ZlZChldmVudCk7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWlmIChjaGlsZCAhPSBudWxsKSB7Ci0JCQlpZiAoZXZlbnQgPT0gbnVsbCkgewotCQkJCWNoaWxkLmZpcmVJdGVtc1JlbW92ZWQobGlzdE5hbWUsIGluZGV4LCByZW1vdmVkSXRlbXMpOwotCQkJfSBlbHNlIHsKLQkJCQljaGlsZC5maXJlSXRlbXNSZW1vdmVkKGV2ZW50KTsKLQkJCX0KLQkJfQotCi0JCXRoaXMuc291cmNlQ2hhbmdlZChsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVwb3J0IGEgYm91bmQgbGlzdCB1cGRhdGUgdG8gYW55IHJlZ2lzdGVyZWQgbGlzdGVuZXJzLgotCSAqLwotCXB1YmxpYyB2b2lkIGZpcmVJdGVtUmVtb3ZlZChTdHJpbmcgbGlzdE5hbWUsIGludCBpbmRleCwgT2JqZWN0IHJlbW92ZWRJdGVtKSB7Ci0vLwkJdGhpcy5maXJlSXRlbXNSZW1vdmVkKGxpc3ROYW1lLCBpbmRleCwgQ29sbGVjdGlvbnMuc2luZ2xldG9uTGlzdChyZW1vdmVkSXRlbSkpOwotCi0JCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIGxpc3RDaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldExpc3RDaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChsaXN0Q2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gbGlzdENoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKGxpc3ROYW1lKTsKLQkJfQotCi0JCUxpc3RDaGFuZ2VFdmVudCBldmVudCA9IG51bGw7Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChMaXN0Q2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0TGlzdENoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQkJCS8vIGhlcmUncyB0aGUgcmVhc29uIGZvciB0aGUgZHVwbGljYXRlIGNvZGUuLi4KLQkJCQkJCWV2ZW50ID0gbmV3IExpc3RDaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgbGlzdE5hbWUsIGluZGV4LCBDb2xsZWN0aW9ucy5zaW5nbGV0b25MaXN0KHJlbW92ZWRJdGVtKSk7Ci0JCQkJCX0KLQkJCQkJdGFyZ2V0Lml0ZW1zUmVtb3ZlZChldmVudCk7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWlmIChjaGlsZCAhPSBudWxsKSB7Ci0JCQlpZiAoZXZlbnQgPT0gbnVsbCkgewotCQkJCWNoaWxkLmZpcmVJdGVtUmVtb3ZlZChsaXN0TmFtZSwgaW5kZXgsIHJlbW92ZWRJdGVtKTsKLQkJCX0gZWxzZSB7Ci0JCQkJY2hpbGQuZmlyZUl0ZW1zUmVtb3ZlZChldmVudCk7Ci0JCQl9Ci0JCX0KLQotCQl0aGlzLnNvdXJjZUNoYW5nZWQobGlzdE5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJlcG9ydCBhIGJvdW5kIGxpc3QgdXBkYXRlIHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlSXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaWYgKGV2ZW50Lml0ZW1zU2l6ZSgpID09IDApIHsKLQkJCXJldHVybjsKLQkJfQotCQkvLyBUT0RPIGNoZWNrIHRoYXQgdGhlIGl0ZW1zIGFyZSBhY3R1YWxseSBkaWZmZXJlbnQuLi4KLQotCQlTdHJpbmcgbGlzdE5hbWUgPSBldmVudC5nZXRMaXN0TmFtZSgpOwotCi0JCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIGxpc3RDaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldExpc3RDaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChsaXN0Q2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gbGlzdENoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKGxpc3ROYW1lKTsKLQkJfQotCi0JCWlmICh0YXJnZXRzICE9IG51bGwpIHsKLQkJCWZvciAoTGlzdENoYW5nZUxpc3RlbmVyIHRhcmdldCA6IHRhcmdldHMpIHsKLQkJCQlib29sZWFuIHN0aWxsTGlzdGVuaW5nOwotCQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCQlzdGlsbExpc3RlbmluZyA9IENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmdldExpc3RDaGFuZ2VMaXN0ZW5lcnMoKSwgdGFyZ2V0KTsKLQkJCQl9Ci0JCQkJaWYgKHN0aWxsTGlzdGVuaW5nKSB7Ci0JCQkJCXRhcmdldC5pdGVtc1JlcGxhY2VkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGNoaWxkICE9IG51bGwpIHsKLQkJCWNoaWxkLmZpcmVJdGVtc1JlcGxhY2VkKGV2ZW50KTsKLQkJfQotCi0JCXRoaXMuc291cmNlQ2hhbmdlZChsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVwb3J0IGEgYm91bmQgbGlzdCB1cGRhdGUgdG8gYW55IHJlZ2lzdGVyZWQgbGlzdGVuZXJzLgotCSAqLwotCXB1YmxpYyB2b2lkIGZpcmVJdGVtc1JlcGxhY2VkKFN0cmluZyBsaXN0TmFtZSwgaW50IGluZGV4LCBMaXN0PD8+IG5ld0l0ZW1zLCBMaXN0PD8+IHJlcGxhY2VkSXRlbXMpIHsKLS8vCQl0aGlzLmZpcmVJdGVtc1JlcGxhY2VkKG5ldyBMaXN0Q2hhbmdlRXZlbnQodGhpcy5zb3VyY2UsIGxpc3ROYW1lLCBpbmRleCwgbmV3SXRlbXMsIHJlcGxhY2VkSXRlbXMpKTsKLQkJaWYgKG5ld0l0ZW1zLmlzRW1wdHkoKSkgewotCQkJcmV0dXJuOwotCQl9Ci0JCS8vIFRPRE8gY2hlY2sgdGhhdCB0aGUgaXRlbXMgYXJlIGFjdHVhbGx5IGRpZmZlcmVudC4uLgotCi0JCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIGxpc3RDaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldExpc3RDaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChsaXN0Q2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gbGlzdENoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKGxpc3ROYW1lKTsKLQkJfQotCi0JCUxpc3RDaGFuZ2VFdmVudCBldmVudCA9IG51bGw7Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChMaXN0Q2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0TGlzdENoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQkJCS8vIGhlcmUncyB0aGUgcmVhc29uIGZvciB0aGUgZHVwbGljYXRlIGNvZGUuLi4KLQkJCQkJCWV2ZW50ID0gbmV3IExpc3RDaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgbGlzdE5hbWUsIGluZGV4LCBuZXdJdGVtcywgcmVwbGFjZWRJdGVtcyk7Ci0JCQkJCX0KLQkJCQkJdGFyZ2V0Lml0ZW1zUmVwbGFjZWQoZXZlbnQpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlpZiAoY2hpbGQgIT0gbnVsbCkgewotCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQljaGlsZC5maXJlSXRlbXNSZXBsYWNlZChsaXN0TmFtZSwgaW5kZXgsIG5ld0l0ZW1zLCByZXBsYWNlZEl0ZW1zKTsKLQkJCX0gZWxzZSB7Ci0JCQkJY2hpbGQuZmlyZUl0ZW1zUmVwbGFjZWQoZXZlbnQpOwotCQkJfQotCQl9Ci0KLQkJdGhpcy5zb3VyY2VDaGFuZ2VkKGxpc3ROYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYSBib3VuZCBsaXN0IHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIHZvaWQgZmlyZUl0ZW1SZXBsYWNlZChTdHJpbmcgbGlzdE5hbWUsIGludCBpbmRleCwgT2JqZWN0IG5ld0l0ZW0sIE9iamVjdCByZXBsYWNlZEl0ZW0pIHsKLS8vCQl0aGlzLmZpcmVJdGVtc1JlcGxhY2VkKGxpc3ROYW1lLCBpbmRleCwgQ29sbGVjdGlvbnMuc2luZ2xldG9uTGlzdChuZXdJdGVtKSwgQ29sbGVjdGlvbnMuc2luZ2xldG9uTGlzdChyZXBsYWNlZEl0ZW0pKTsKLQkJLy8gVE9ETyBjaGVjayB0aGF0IHRoZSBpdGVtIGlzIGFjdHVhbGx5IGRpZmZlcmVudC4uLgotCi0JCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIGxpc3RDaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldExpc3RDaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChsaXN0Q2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gbGlzdENoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKGxpc3ROYW1lKTsKLQkJfQotCi0JCUxpc3RDaGFuZ2VFdmVudCBldmVudCA9IG51bGw7Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChMaXN0Q2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0TGlzdENoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQkJCS8vIGhlcmUncyB0aGUgcmVhc29uIGZvciB0aGUgZHVwbGljYXRlIGNvZGUuLi4KLQkJCQkJCWV2ZW50ID0gbmV3IExpc3RDaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgbGlzdE5hbWUsIGluZGV4LCBDb2xsZWN0aW9ucy5zaW5nbGV0b25MaXN0KG5ld0l0ZW0pLCBDb2xsZWN0aW9ucy5zaW5nbGV0b25MaXN0KHJlcGxhY2VkSXRlbSkpOwotCQkJCQl9Ci0JCQkJCXRhcmdldC5pdGVtc1JlcGxhY2VkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGNoaWxkICE9IG51bGwpIHsKLQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJY2hpbGQuZmlyZUl0ZW1SZXBsYWNlZChsaXN0TmFtZSwgaW5kZXgsIG5ld0l0ZW0sIHJlcGxhY2VkSXRlbSk7Ci0JCQl9IGVsc2UgewotCQkJCWNoaWxkLmZpcmVJdGVtc1JlcGxhY2VkKGV2ZW50KTsKLQkJCX0KLQkJfQotCi0JCXRoaXMuc291cmNlQ2hhbmdlZChsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVwb3J0IGEgYm91bmQgbGlzdCB1cGRhdGUgdG8gYW55IHJlZ2lzdGVyZWQgbGlzdGVuZXJzLgotCSAqLwotCXB1YmxpYyB2b2lkIGZpcmVJdGVtc01vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQlpZiAoZXZlbnQuZ2V0VGFyZ2V0SW5kZXgoKSA9PSBldmVudC5nZXRTb3VyY2VJbmRleCgpKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQotCQlTdHJpbmcgbGlzdE5hbWUgPSBldmVudC5nZXRMaXN0TmFtZSgpOwotCi0JCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIGxpc3RDaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldExpc3RDaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChsaXN0Q2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gbGlzdENoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKGxpc3ROYW1lKTsKLQkJfQotCi0JCWlmICh0YXJnZXRzICE9IG51bGwpIHsKLQkJCWZvciAoTGlzdENoYW5nZUxpc3RlbmVyIHRhcmdldCA6IHRhcmdldHMpIHsKLQkJCQlib29sZWFuIHN0aWxsTGlzdGVuaW5nOwotCQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCQlzdGlsbExpc3RlbmluZyA9IENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmdldExpc3RDaGFuZ2VMaXN0ZW5lcnMoKSwgdGFyZ2V0KTsKLQkJCQl9Ci0JCQkJaWYgKHN0aWxsTGlzdGVuaW5nKSB7Ci0JCQkJCXRhcmdldC5pdGVtc01vdmVkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGNoaWxkICE9IG51bGwpIHsKLQkJCWNoaWxkLmZpcmVJdGVtc01vdmVkKGV2ZW50KTsKLQkJfQotCi0JCXRoaXMuc291cmNlQ2hhbmdlZChsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVwb3J0IGEgYm91bmQgbGlzdCB1cGRhdGUgdG8gYW55IHJlZ2lzdGVyZWQgbGlzdGVuZXJzLgotCSAqLwotCXB1YmxpYyB2b2lkIGZpcmVJdGVtc01vdmVkKFN0cmluZyBsaXN0TmFtZSwgaW50IHRhcmdldEluZGV4LCBpbnQgc291cmNlSW5kZXgsIGludCBsZW5ndGgpIHsKLS8vCQl0aGlzLmZpcmVJdGVtc01vdmVkKG5ldyBMaXN0Q2hhbmdlRXZlbnQodGhpcy5zb3VyY2UsIGxpc3ROYW1lLCB0YXJnZXRJbmRleCwgc291cmNlSW5kZXgsIGxlbmd0aCkpOwotCQlpZiAodGFyZ2V0SW5kZXggPT0gc291cmNlSW5kZXgpIHsKLQkJCXJldHVybjsKLQkJfQotCi0JCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIGxpc3RDaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldExpc3RDaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChsaXN0Q2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gbGlzdENoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKGxpc3ROYW1lKTsKLQkJfQotCi0JCUxpc3RDaGFuZ2VFdmVudCBldmVudCA9IG51bGw7Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChMaXN0Q2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0TGlzdENoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQkJCS8vIGhlcmUncyB0aGUgcmVhc29uIGZvciB0aGUgZHVwbGljYXRlIGNvZGUuLi4KLQkJCQkJCWV2ZW50ID0gbmV3IExpc3RDaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgbGlzdE5hbWUsIHRhcmdldEluZGV4LCBzb3VyY2VJbmRleCwgbGVuZ3RoKTsKLQkJCQkJfQotCQkJCQl0YXJnZXQuaXRlbXNNb3ZlZChldmVudCk7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWlmIChjaGlsZCAhPSBudWxsKSB7Ci0JCQlpZiAoZXZlbnQgPT0gbnVsbCkgewotCQkJCWNoaWxkLmZpcmVJdGVtc01vdmVkKGxpc3ROYW1lLCB0YXJnZXRJbmRleCwgc291cmNlSW5kZXgsIGxlbmd0aCk7Ci0JCQl9IGVsc2UgewotCQkJCWNoaWxkLmZpcmVJdGVtc01vdmVkKGV2ZW50KTsKLQkJCX0KLQkJfQotCi0JCXRoaXMuc291cmNlQ2hhbmdlZChsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVwb3J0IGEgYm91bmQgbGlzdCB1cGRhdGUgdG8gYW55IHJlZ2lzdGVyZWQgbGlzdGVuZXJzLgotCSAqLwotCXB1YmxpYyB2b2lkIGZpcmVJdGVtTW92ZWQoU3RyaW5nIGxpc3ROYW1lLCBpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCkgewotCQl0aGlzLmZpcmVJdGVtc01vdmVkKGxpc3ROYW1lLCB0YXJnZXRJbmRleCwgc291cmNlSW5kZXgsIDEpOwotCX0KLQotCS8qKgotCSAqIFJlcG9ydCBhIGJvdW5kIGxpc3QgdXBkYXRlIHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlTGlzdENsZWFyZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCVN0cmluZyBsaXN0TmFtZSA9IGV2ZW50LmdldExpc3ROYW1lKCk7Ci0KLQkJTGlzdENoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0JCUNoYW5nZVN1cHBvcnQgY2hpbGQgPSBudWxsOwotCi0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJTGlzdENoYW5nZUxpc3RlbmVyW10gbGlzdENoYW5nZUxpc3RlbmVycyA9IHRoaXMuZ2V0TGlzdENoYW5nZUxpc3RlbmVycygpOwotCQkJaWYgKGxpc3RDaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSBsaXN0Q2hhbmdlTGlzdGVuZXJzLmNsb25lKCk7Ci0JCQl9Ci0JCQljaGlsZCA9IHRoaXMuZ2V0Q2hpbGQobGlzdE5hbWUpOwotCQl9Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChMaXN0Q2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0TGlzdENoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJdGFyZ2V0Lmxpc3RDbGVhcmVkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGNoaWxkICE9IG51bGwpIHsKLQkJCWNoaWxkLmZpcmVMaXN0Q2xlYXJlZChldmVudCk7Ci0JCX0KLQotCQl0aGlzLnNvdXJjZUNoYW5nZWQobGlzdE5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJlcG9ydCBhIGJvdW5kIGxpc3QgdXBkYXRlIHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlTGlzdENsZWFyZWQoU3RyaW5nIGxpc3ROYW1lKSB7Ci0vLwkJdGhpcy5maXJlTGlzdENsZWFyZWQobmV3IExpc3RDaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgbGlzdE5hbWUpKTsKLQotCQlMaXN0Q2hhbmdlTGlzdGVuZXJbXSB0YXJnZXRzID0gbnVsbDsKLQkJQ2hhbmdlU3VwcG9ydCBjaGlsZCA9IG51bGw7Ci0KLQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQlMaXN0Q2hhbmdlTGlzdGVuZXJbXSBsaXN0Q2hhbmdlTGlzdGVuZXJzID0gdGhpcy5nZXRMaXN0Q2hhbmdlTGlzdGVuZXJzKCk7Ci0JCQlpZiAobGlzdENoYW5nZUxpc3RlbmVycyAhPSBudWxsKSB7Ci0JCQkJdGFyZ2V0cyA9IGxpc3RDaGFuZ2VMaXN0ZW5lcnMuY2xvbmUoKTsKLQkJCX0KLQkJCWNoaWxkID0gdGhpcy5nZXRDaGlsZChsaXN0TmFtZSk7Ci0JCX0KLQotCQlMaXN0Q2hhbmdlRXZlbnQgZXZlbnQgPSBudWxsOwotCi0JCWlmICh0YXJnZXRzICE9IG51bGwpIHsKLQkJCWZvciAoTGlzdENoYW5nZUxpc3RlbmVyIHRhcmdldCA6IHRhcmdldHMpIHsKLQkJCQlib29sZWFuIHN0aWxsTGlzdGVuaW5nOwotCQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCQlzdGlsbExpc3RlbmluZyA9IENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmdldExpc3RDaGFuZ2VMaXN0ZW5lcnMoKSwgdGFyZ2V0KTsKLQkJCQl9Ci0JCQkJaWYgKHN0aWxsTGlzdGVuaW5nKSB7Ci0JCQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJCQkvLyBoZXJlJ3MgdGhlIHJlYXNvbiBmb3IgdGhlIGR1cGxpY2F0ZSBjb2RlLi4uCi0JCQkJCQlldmVudCA9IG5ldyBMaXN0Q2hhbmdlRXZlbnQodGhpcy5zb3VyY2UsIGxpc3ROYW1lKTsKLQkJCQkJfQotCQkJCQl0YXJnZXQubGlzdENsZWFyZWQoZXZlbnQpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlpZiAoY2hpbGQgIT0gbnVsbCkgewotCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQljaGlsZC5maXJlTGlzdENsZWFyZWQobGlzdE5hbWUpOwotCQkJfSBlbHNlIHsKLQkJCQljaGlsZC5maXJlTGlzdENsZWFyZWQoZXZlbnQpOwotCQkJfQotCQl9Ci0KLQkJdGhpcy5zb3VyY2VDaGFuZ2VkKGxpc3ROYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYSBib3VuZCBsaXN0IHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIHZvaWQgZmlyZUxpc3RDaGFuZ2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQlTdHJpbmcgbGlzdE5hbWUgPSBldmVudC5nZXRMaXN0TmFtZSgpOwotCi0JCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCUxpc3RDaGFuZ2VMaXN0ZW5lcltdIGxpc3RDaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldExpc3RDaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmIChsaXN0Q2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gbGlzdENoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKGxpc3ROYW1lKTsKLQkJfQotCi0JCWlmICh0YXJnZXRzICE9IG51bGwpIHsKLQkJCWZvciAoTGlzdENoYW5nZUxpc3RlbmVyIHRhcmdldCA6IHRhcmdldHMpIHsKLQkJCQlib29sZWFuIHN0aWxsTGlzdGVuaW5nOwotCQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCQlzdGlsbExpc3RlbmluZyA9IENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmdldExpc3RDaGFuZ2VMaXN0ZW5lcnMoKSwgdGFyZ2V0KTsKLQkJCQl9Ci0JCQkJaWYgKHN0aWxsTGlzdGVuaW5nKSB7Ci0JCQkJCXRhcmdldC5saXN0Q2hhbmdlZChldmVudCk7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWlmIChjaGlsZCAhPSBudWxsKSB7Ci0JCQljaGlsZC5maXJlTGlzdENoYW5nZWQoZXZlbnQpOwotCQl9Ci0KLQkJdGhpcy5zb3VyY2VDaGFuZ2VkKGxpc3ROYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYSBib3VuZCBsaXN0IHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIHZvaWQgZmlyZUxpc3RDaGFuZ2VkKFN0cmluZyBsaXN0TmFtZSkgewotLy8JCXRoaXMuZmlyZUxpc3RDaGFuZ2VkKG5ldyBMaXN0Q2hhbmdlRXZlbnQodGhpcy5zb3VyY2UsIGxpc3ROYW1lKSk7Ci0KLQkJTGlzdENoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0JCUNoYW5nZVN1cHBvcnQgY2hpbGQgPSBudWxsOwotCi0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJTGlzdENoYW5nZUxpc3RlbmVyW10gbGlzdENoYW5nZUxpc3RlbmVycyA9IHRoaXMuZ2V0TGlzdENoYW5nZUxpc3RlbmVycygpOwotCQkJaWYgKGxpc3RDaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSBsaXN0Q2hhbmdlTGlzdGVuZXJzLmNsb25lKCk7Ci0JCQl9Ci0JCQljaGlsZCA9IHRoaXMuZ2V0Q2hpbGQobGlzdE5hbWUpOwotCQl9Ci0KLQkJTGlzdENoYW5nZUV2ZW50IGV2ZW50ID0gbnVsbDsKLQotCQlpZiAodGFyZ2V0cyAhPSBudWxsKSB7Ci0JCQlmb3IgKExpc3RDaGFuZ2VMaXN0ZW5lciB0YXJnZXQgOiB0YXJnZXRzKSB7Ci0JCQkJYm9vbGVhbiBzdGlsbExpc3RlbmluZzsKLQkJCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCQkJc3RpbGxMaXN0ZW5pbmcgPSBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5nZXRMaXN0Q2hhbmdlTGlzdGVuZXJzKCksIHRhcmdldCk7Ci0JCQkJfQotCQkJCWlmIChzdGlsbExpc3RlbmluZykgewotCQkJCQlpZiAoZXZlbnQgPT0gbnVsbCkgewotCQkJCQkJLy8gaGVyZSdzIHRoZSByZWFzb24gZm9yIHRoZSBkdXBsaWNhdGUgY29kZS4uLgotCQkJCQkJZXZlbnQgPSBuZXcgTGlzdENoYW5nZUV2ZW50KHRoaXMuc291cmNlLCBsaXN0TmFtZSk7Ci0JCQkJCX0KLQkJCQkJdGFyZ2V0Lmxpc3RDaGFuZ2VkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGNoaWxkICE9IG51bGwpIHsKLQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJY2hpbGQuZmlyZUxpc3RDaGFuZ2VkKGxpc3ROYW1lKTsKLQkJCX0gZWxzZSB7Ci0JCQkJY2hpbGQuZmlyZUxpc3RDaGFuZ2VkKGV2ZW50KTsKLQkJCX0KLQkJfQotCi0JCXRoaXMuc291cmNlQ2hhbmdlZChsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogQWRkIHRoZSBzcGVjaWZpZWQgaXRlbSB0byB0aGUgc3BlY2lmaWVkIGJvdW5kIGxpc3QgYXQgdGhlIHNwZWNpZmllZCBpbmRleAotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudC4KLQkgKiBAc2VlIGphdmEudXRpbC5MaXN0I2FkZChpbnQsIE9iamVjdCkKLQkgKi8KLQlwdWJsaWMgPEU+IHZvaWQgYWRkSXRlbVRvTGlzdChpbnQgaW5kZXgsIEUgaXRlbSwgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJbGlzdC5hZGQoaW5kZXgsIGl0ZW0pOwotCQl0aGlzLmZpcmVJdGVtQWRkZWQobGlzdE5hbWUsIGluZGV4LCBpdGVtKTsKLQl9Ci0KLQkvKioKLQkgKiBBZGQgdGhlIHNwZWNpZmllZCBpdGVtIHRvIHRoZSBlbmQgb2YgdGhlIHNwZWNpZmllZCBib3VuZCBsaXN0Ci0JICogYW5kIGZpcmUgdGhlIGFwcHJvcHJpYXRlIGV2ZW50LgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBsaXN0IGNoYW5nZWQgKGkuZS4gJ3RydWUnKS4KLQkgKiBAc2VlIGphdmEudXRpbC5MaXN0I2FkZChPYmplY3QpCi0JICovCi0JcHVibGljIDxFPiBib29sZWFuIGFkZEl0ZW1Ub0xpc3QoRSBpdGVtLCBMaXN0PEU+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlpZiAobGlzdC5hZGQoaXRlbSkpIHsKLQkJCXRoaXMuZmlyZUl0ZW1BZGRlZChsaXN0TmFtZSwgbGlzdC5zaXplKCkgLSAxLCBpdGVtKTsKLQkJCXJldHVybiB0cnVlOwotCQl9Ci0JCXJldHVybiBmYWxzZTsgIC8vIExpc3QjYWRkKE9iamVjdCkgc2hvdWxkIGFsd2F5cyByZXR1cm4gJ3RydWUnLCBzbyB3ZSBzaG91bGQgbmV2ZXIgZ2V0IGhlcmUuLi4KLQl9Ci0KLQkvKioKLQkgKiBBZGQgdGhlIHNwZWNpZmllZCBpdGVtcyB0byB0aGUgc3BlY2lmaWVkIGJvdW5kIGxpc3QgYXQgdGhlIHNwZWNpZmllZCBpbmRleAotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudCBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGxpc3QgY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5MaXN0I2FkZEFsbChpbnQsIGphdmEudXRpbC5Db2xsZWN0aW9uKQotCSAqLwotCXB1YmxpYyA8RT4gYm9vbGVhbiBhZGRJdGVtc1RvTGlzdChpbnQgaW5kZXgsIEVbXSBpdGVtcywgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIChpdGVtcy5sZW5ndGggIT0gMCkKLQkJCQkmJiB0aGlzLmFkZEl0ZW1zVG9MaXN0XyhpbmRleCwgQXJyYXlzLmFzTGlzdChpdGVtcyksIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBBZGQgdGhlIHNwZWNpZmllZCBpdGVtcyB0byB0aGUgc3BlY2lmaWVkIGJvdW5kIGxpc3QgYXQgdGhlIHNwZWNpZmllZCBpbmRleAotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudCBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGxpc3QgY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5MaXN0I2FkZEFsbChpbnQsIGphdmEudXRpbC5Db2xsZWN0aW9uKQotCSAqLwotCXB1YmxpYyA8RT4gYm9vbGVhbiBhZGRJdGVtc1RvTGlzdChpbnQgaW5kZXgsIENvbGxlY3Rpb248PyBleHRlbmRzIEU+IGl0ZW1zLCBMaXN0PEU+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlyZXR1cm4gKCAhIGl0ZW1zLmlzRW1wdHkoKSkKLQkJCQkmJiB0aGlzLmFkZEl0ZW1zVG9MaXN0XyhpbmRleCwgdGhpcy5jb252ZXJ0VG9MaXN0KGl0ZW1zKSwgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCS8qKgotCSAqIG5vIGVtcHR5IGNoZWNrCi0JICovCi0JcHJvdGVjdGVkIDxFPiBib29sZWFuIGFkZEl0ZW1zVG9MaXN0XyhpbnQgaW5kZXgsIExpc3Q8PyBleHRlbmRzIEU+IGl0ZW1zLCBMaXN0PEU+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlpZiAobGlzdC5hZGRBbGwoaW5kZXgsIGl0ZW1zKSkgewotCQkJdGhpcy5maXJlSXRlbXNBZGRlZChsaXN0TmFtZSwgaW5kZXgsIGl0ZW1zKTsKLQkJCXJldHVybiB0cnVlOwotCQl9Ci0JCXJldHVybiBmYWxzZTsgIC8vICAnaXRlbXMnIHNob3VsZCBub3QgYmUgZW1wdHksIHNvIHdlIHNob3VsZCBuZXZlciBnZXQgaGVyZS4uLgotCX0KLQotCS8qKgotCSAqIEFkZCB0aGUgc3BlY2lmaWVkIGl0ZW1zIHRvIHRoZSBzcGVjaWZpZWQgYm91bmQgbGlzdAotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudCBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGxpc3QgY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5MaXN0I2FkZEFsbChpbnQsIGphdmEudXRpbC5Db2xsZWN0aW9uKQotCSAqLwotCXB1YmxpYyA8RT4gYm9vbGVhbiBhZGRJdGVtc1RvTGlzdChpbnQgaW5kZXgsIEl0ZXJhYmxlPD8gZXh0ZW5kcyBFPiBpdGVtcywgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMuYWRkSXRlbXNUb0xpc3QoaW5kZXgsIGl0ZW1zLml0ZXJhdG9yKCksIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBBZGQgdGhlIHNwZWNpZmllZCBpdGVtcyB0byB0aGUgc3BlY2lmaWVkIGJvdW5kIGxpc3QKLQkgKiBhbmQgZmlyZSB0aGUgYXBwcm9wcmlhdGUgZXZlbnQgaWYgbmVjZXNzYXJ5LgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBsaXN0IGNoYW5nZWQuCi0JICogQHNlZSBqYXZhLnV0aWwuTGlzdCNhZGRBbGwoaW50LCBqYXZhLnV0aWwuQ29sbGVjdGlvbikKLQkgKi8KLQlwdWJsaWMgPEU+IGJvb2xlYW4gYWRkSXRlbXNUb0xpc3QoaW50IGluZGV4LCBJdGVyYXRvcjw/IGV4dGVuZHMgRT4gaXRlbXMsIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCWlmICggISBpdGVtcy5oYXNOZXh0KCkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCi0JCUFycmF5TGlzdDxFPiBhZGRlZEl0ZW1zID0gQ29sbGVjdGlvblRvb2xzLmxpc3QoaXRlbXMpOwotCQlpZiAobGlzdC5hZGRBbGwoaW5kZXgsIGFkZGVkSXRlbXMpKSB7Ci0JCQl0aGlzLmZpcmVJdGVtc0FkZGVkKGxpc3ROYW1lLCBpbmRleCwgYWRkZWRJdGVtcyk7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCQlyZXR1cm4gZmFsc2U7ICAvLyAgJ2l0ZW1zJyBzaG91bGQgbm90IGJlIGVtcHR5LCBzbyB3ZSBzaG91bGQgbmV2ZXIgZ2V0IGhlcmUuLi4KLQl9Ci0KLQkvKioKLQkgKiBBZGQgdGhlIHNwZWNpZmllZCBpdGVtcyB0byB0aGUgZW5kIG9mIHRvIHRoZSBzcGVjaWZpZWQgYm91bmQgbGlzdAotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudCBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGxpc3QgY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5MaXN0I2FkZEFsbChqYXZhLnV0aWwuQ29sbGVjdGlvbikKLQkgKi8KLQlwdWJsaWMgPEU+IGJvb2xlYW4gYWRkSXRlbXNUb0xpc3QoRVtdIGl0ZW1zLCBMaXN0PEU+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlyZXR1cm4gKGl0ZW1zLmxlbmd0aCAhPSAwKQotCQkJCSYmIHRoaXMuYWRkSXRlbXNUb0xpc3RfKEFycmF5cy5hc0xpc3QoaXRlbXMpLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogQWRkIHRoZSBzcGVjaWZpZWQgaXRlbXMgdG8gdGhlIGVuZCBvZiB0aGUgc3BlY2lmaWVkIGJvdW5kIGxpc3QKLQkgKiBhbmQgZmlyZSB0aGUgYXBwcm9wcmlhdGUgZXZlbnQgaWYgbmVjZXNzYXJ5LgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBsaXN0IGNoYW5nZWQuCi0JICogQHNlZSBqYXZhLnV0aWwuTGlzdCNhZGRBbGwoaW50LCBqYXZhLnV0aWwuQ29sbGVjdGlvbikKLQkgKi8KLQlwdWJsaWMgPEU+IGJvb2xlYW4gYWRkSXRlbXNUb0xpc3QoQ29sbGVjdGlvbjw/IGV4dGVuZHMgRT4gaXRlbXMsIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXJldHVybiAoICEgaXRlbXMuaXNFbXB0eSgpKQotCQkJCSYmIHRoaXMuYWRkSXRlbXNUb0xpc3RfKHRoaXMuY29udmVydFRvTGlzdChpdGVtcyksIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgPEU+IExpc3Q8PyBleHRlbmRzIEU+IGNvbnZlcnRUb0xpc3QoQ29sbGVjdGlvbjw/IGV4dGVuZHMgRT4gY29sbGVjdGlvbikgewotCQlyZXR1cm4gKGNvbGxlY3Rpb24gaW5zdGFuY2VvZiBMaXN0KSA/IChMaXN0PD8gZXh0ZW5kcyBFPikgY29sbGVjdGlvbiA6IG5ldyBBcnJheUxpc3Q8RT4oY29sbGVjdGlvbik7Ci0JfQotCi0JLyoqCi0JICogbm8gZW1wdHkgY2hlY2sKLQkgKi8KLQlwcm90ZWN0ZWQgPEU+IGJvb2xlYW4gYWRkSXRlbXNUb0xpc3RfKExpc3Q8PyBleHRlbmRzIEU+IGl0ZW1zLCBMaXN0PEU+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlpbnQgaW5kZXggPSBsaXN0LnNpemUoKTsKLQkJaWYgKGxpc3QuYWRkQWxsKGl0ZW1zKSkgewotCQkJdGhpcy5maXJlSXRlbXNBZGRlZChsaXN0TmFtZSwgaW5kZXgsIGl0ZW1zKTsKLQkJCXJldHVybiB0cnVlOwotCQl9Ci0JCXJldHVybiBmYWxzZTsgIC8vICAnaXRlbXMnIHNob3VsZCBub3QgYmUgZW1wdHksIHNvIHdlIHNob3VsZCBuZXZlciBnZXQgaGVyZS4uLgotCX0KLQotCS8qKgotCSAqIEFkZCB0aGUgc3BlY2lmaWVkIGl0ZW1zIHRvIHRoZSBlbmQgb2YgdG8gdGhlIHNwZWNpZmllZCBib3VuZCBsaXN0Ci0JICogYW5kIGZpcmUgdGhlIGFwcHJvcHJpYXRlIGV2ZW50IGlmIG5lY2Vzc2FyeS4KLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgbGlzdCBjaGFuZ2VkLgotCSAqIEBzZWUgamF2YS51dGlsLkxpc3QjYWRkQWxsKGphdmEudXRpbC5Db2xsZWN0aW9uKQotCSAqLwotCXB1YmxpYyA8RT4gYm9vbGVhbiBhZGRJdGVtc1RvTGlzdChJdGVyYWJsZTw/IGV4dGVuZHMgRT4gaXRlbXMsIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXJldHVybiB0aGlzLmFkZEl0ZW1zVG9MaXN0KGl0ZW1zLml0ZXJhdG9yKCksIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBBZGQgdGhlIHNwZWNpZmllZCBpdGVtcyB0byB0aGUgZW5kIG9mIHRvIHRoZSBzcGVjaWZpZWQgYm91bmQgbGlzdAotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudCBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGxpc3QgY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5MaXN0I2FkZEFsbChqYXZhLnV0aWwuQ29sbGVjdGlvbikKLQkgKi8KLQlwdWJsaWMgPEU+IGJvb2xlYW4gYWRkSXRlbXNUb0xpc3QoSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZW1zLCBMaXN0PEU+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlpZiAoICEgaXRlbXMuaGFzTmV4dCgpKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJcmV0dXJuIHRoaXMuYWRkSXRlbXNUb0xpc3RfKGl0ZW1zLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogbm8gZW1wdHkgY2hlY2sKLQkgKi8KLQlwcm90ZWN0ZWQgPEU+IGJvb2xlYW4gYWRkSXRlbXNUb0xpc3RfKEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBpdGVtcywgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJQXJyYXlMaXN0PEU+IGFkZGVkSXRlbXMgPSBDb2xsZWN0aW9uVG9vbHMubGlzdChpdGVtcyk7Ci0JCWludCBpbmRleCA9IGxpc3Quc2l6ZSgpOwotCQlpZiAobGlzdC5hZGRBbGwoYWRkZWRJdGVtcykpIHsKLQkJCXRoaXMuZmlyZUl0ZW1zQWRkZWQobGlzdE5hbWUsIGluZGV4LCBhZGRlZEl0ZW1zKTsKLQkJCXJldHVybiB0cnVlOwotCQl9Ci0JCXJldHVybiBmYWxzZTsgIC8vICAnaXRlbXMnIHNob3VsZCBub3QgYmUgZW1wdHksIHNvIHdlIHNob3VsZCBuZXZlciBnZXQgaGVyZS4uLgotCX0KLQotCS8qKgotCSAqIFJlbW92ZSB0aGUgc3BlY2lmaWVkIGl0ZW0gZnJvbSB0aGUgc3BlY2lmaWVkIGJvdW5kIGxpc3QKLQkgKiBhbmQgZmlyZSB0aGUgYXBwcm9wcmlhdGUgZXZlbnQgaWYgbmVjZXNzYXJ5LgotCSAqIFJldHVybiB0aGUgcmVtb3ZlZCBpdGVtLgotCSAqIEBzZWUgamF2YS51dGlsLkxpc3QjcmVtb3ZlKGludCkKLQkgKi8KLQlwdWJsaWMgPEU+IEUgcmVtb3ZlSXRlbUZyb21MaXN0KGludCBpbmRleCwgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJRSBpdGVtID0gbGlzdC5yZW1vdmUoaW5kZXgpOwotCQl0aGlzLmZpcmVJdGVtUmVtb3ZlZChsaXN0TmFtZSwgaW5kZXgsIGl0ZW0pOwotCQlyZXR1cm4gaXRlbTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgdGhlIHNwZWNpZmllZCBpdGVtIGZyb20gdGhlIHNwZWNpZmllZCBib3VuZCBsaXN0Ci0JICogYW5kIGZpcmUgdGhlIGFwcHJvcHJpYXRlIGV2ZW50IGlmIG5lY2Vzc2FyeS4KLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgbGlzdCBjaGFuZ2VkLgotCSAqIEBzZWUgamF2YS51dGlsLkxpc3QjcmVtb3ZlKE9iamVjdCkKLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiByZW1vdmVJdGVtRnJvbUxpc3QoT2JqZWN0IGl0ZW0sIExpc3Q8Pz4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCWludCBpbmRleCA9IGxpc3QuaW5kZXhPZihpdGVtKTsKLQkJaWYgKGluZGV4ID09IC0xKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJbGlzdC5yZW1vdmUoaW5kZXgpOwotCQl0aGlzLmZpcmVJdGVtUmVtb3ZlZChsaXN0TmFtZSwgaW5kZXgsIGl0ZW0pOwotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgdGhlIHNwZWNpZmllZCBpdGVtcyBmcm9tIHRoZSBzcGVjaWZpZWQgYm91bmQgbGlzdAotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudCBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHRoZSByZW1vdmVkIGl0ZW1zLgotCSAqIEBzZWUgamF2YS51dGlsLkxpc3QjcmVtb3ZlKGludCkKLQkgKi8KLQlwdWJsaWMgPEU+IExpc3Q8RT4gcmVtb3ZlSXRlbXNGcm9tTGlzdChpbnQgaW5kZXgsIGludCBsZW5ndGgsIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCWlmIChsZW5ndGggPT0gMCkgewotCQkJcmV0dXJuIENvbGxlY3Rpb25zLmVtcHR5TGlzdCgpOwotCQl9Ci0JCXJldHVybiB0aGlzLnJlbW92ZUl0ZW1zRnJvbUxpc3RfKGluZGV4LCBsZW5ndGgsIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBubyBlbXB0eSBjaGVjawotCSAqLwotCXByb3RlY3RlZCA8RT4gTGlzdDxFPiByZW1vdmVJdGVtc0Zyb21MaXN0XyhpbnQgaW5kZXgsIGludCBsZW5ndGgsIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCUxpc3Q8RT4gc3ViTGlzdCA9IGxpc3Quc3ViTGlzdChpbmRleCwgaW5kZXggKyBsZW5ndGgpOwotCQlMaXN0PEU+IHJlbW92ZWRJdGVtcyA9IG5ldyBBcnJheUxpc3Q8RT4oc3ViTGlzdCk7Ci0JCXN1Ykxpc3QuY2xlYXIoKTsKLQkJdGhpcy5maXJlSXRlbXNSZW1vdmVkKGxpc3ROYW1lLCBpbmRleCwgcmVtb3ZlZEl0ZW1zKTsKLQkJcmV0dXJuIHJlbW92ZWRJdGVtczsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgdGhlIHNwZWNpZmllZCBpdGVtcyBmcm9tIHRoZSBzcGVjaWZpZWQgYm91bmQgbGlzdAotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudChzKSBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGxpc3QgY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5MaXN0I3JlbW92ZUFsbChqYXZhLnV0aWwuQ29sbGVjdGlvbikKLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiByZW1vdmVJdGVtc0Zyb21MaXN0KE9iamVjdFtdIGl0ZW1zLCBMaXN0PD8+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlyZXR1cm4gKGl0ZW1zLmxlbmd0aCAhPSAwKQotCQkJCSYmICggISBsaXN0LmlzRW1wdHkoKSkKLQkJCQkmJiB0aGlzLnJlbW92ZUl0ZW1zRnJvbUxpc3RfKG5ldyBBcnJheUl0ZXJhdG9yPE9iamVjdD4oaXRlbXMpLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgaXRlbXMgZnJvbSB0aGUgc3BlY2lmaWVkIGJvdW5kIGxpc3QKLQkgKiBhbmQgZmlyZSB0aGUgYXBwcm9wcmlhdGUgZXZlbnQocykgaWYgbmVjZXNzYXJ5LgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBsaXN0IGNoYW5nZWQuCi0JICogQHNlZSBqYXZhLnV0aWwuTGlzdCNyZW1vdmVBbGwoamF2YS51dGlsLkNvbGxlY3Rpb24pCi0JICovCi0JcHVibGljIGJvb2xlYW4gcmVtb3ZlSXRlbXNGcm9tTGlzdChDb2xsZWN0aW9uPD8+IGl0ZW1zLCBMaXN0PD8+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlyZXR1cm4gKCAhIGl0ZW1zLmlzRW1wdHkoKSkKLQkJCQkmJiAoICEgbGlzdC5pc0VtcHR5KCkpCi0JCQkJJiYgdGhpcy5yZW1vdmVJdGVtc0Zyb21MaXN0XyhpdGVtcy5pdGVyYXRvcigpLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgaXRlbXMgZnJvbSB0aGUgc3BlY2lmaWVkIGJvdW5kIGxpc3QKLQkgKiBhbmQgZmlyZSB0aGUgYXBwcm9wcmlhdGUgZXZlbnQocykgaWYgbmVjZXNzYXJ5LgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBsaXN0IGNoYW5nZWQuCi0JICogQHNlZSBqYXZhLnV0aWwuTGlzdCNyZW1vdmVBbGwoamF2YS51dGlsLkNvbGxlY3Rpb24pCi0JICovCi0JcHVibGljIGJvb2xlYW4gcmVtb3ZlSXRlbXNGcm9tTGlzdChJdGVyYWJsZTw/PiBpdGVtcywgTGlzdDw/PiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMucmVtb3ZlSXRlbXNGcm9tTGlzdChpdGVtcy5pdGVyYXRvcigpLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgaXRlbXMgZnJvbSB0aGUgc3BlY2lmaWVkIGJvdW5kIGxpc3QKLQkgKiBhbmQgZmlyZSB0aGUgYXBwcm9wcmlhdGUgZXZlbnQocykgaWYgbmVjZXNzYXJ5LgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBsaXN0IGNoYW5nZWQuCi0JICogQHNlZSBqYXZhLnV0aWwuTGlzdCNyZW1vdmVBbGwoamF2YS51dGlsLkNvbGxlY3Rpb24pCi0JICovCi0JcHVibGljIGJvb2xlYW4gcmVtb3ZlSXRlbXNGcm9tTGlzdChJdGVyYXRvcjw/PiBpdGVtcywgTGlzdDw/PiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIChpdGVtcy5oYXNOZXh0KCkpCi0JCQkJJiYgKCAhIGxpc3QuaXNFbXB0eSgpKQotCQkJCSYmIHRoaXMucmVtb3ZlSXRlbXNGcm9tTGlzdF8oaXRlbXMsIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBubyBlbXB0eSBjaGVja3MKLQkgKi8KLQlwcm90ZWN0ZWQgYm9vbGVhbiByZW1vdmVJdGVtc0Zyb21MaXN0XyhJdGVyYXRvcjw/PiBpdGVtcywgTGlzdDw/PiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJYm9vbGVhbiBjaGFuZ2VkID0gZmFsc2U7Ci0JCXdoaWxlIChpdGVtcy5oYXNOZXh0KCkpIHsKLQkJCWNoYW5nZWQgfD0gdGhpcy5yZW1vdmVJdGVtRnJvbUxpc3QoaXRlbXMubmV4dCgpLCBsaXN0LCBsaXN0TmFtZSk7Ci0JCX0KLQkJcmV0dXJuIGNoYW5nZWQ7Ci0JfQotCi0JLyoqCi0JICogUmV0YWluIHRoZSBzcGVjaWZpZWQgaXRlbXMgaW4gdGhlIHNwZWNpZmllZCBib3VuZCBsaXN0Ci0JICogYW5kIGZpcmUgdGhlIGFwcHJvcHJpYXRlIGV2ZW50KHMpIGlmIG5lY2Vzc2FyeS4KLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgbGlzdCBjaGFuZ2VkLgotCSAqIEBzZWUgamF2YS51dGlsLkxpc3QjcmV0YWluQWxsKGphdmEudXRpbC5Db2xsZWN0aW9uKQotCSAqLwotCXB1YmxpYyBib29sZWFuIHJldGFpbkl0ZW1zSW5MaXN0KE9iamVjdFtdIGl0ZW1zLCBMaXN0PD8+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlpZiAobGlzdC5pc0VtcHR5KCkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlpZiAoaXRlbXMubGVuZ3RoID09IDApIHsKLQkJCXJldHVybiB0aGlzLmNsZWFyTGlzdF8obGlzdCwgbGlzdE5hbWUpOwotCQl9Ci0JCXJldHVybiB0aGlzLnJldGFpbkl0ZW1zSW5MaXN0XyhuZXcgQXJyYXlJdGVyYXRvcjxPYmplY3Q+KGl0ZW1zKSwgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJldGFpbiB0aGUgc3BlY2lmaWVkIGl0ZW1zIGluIHRoZSBzcGVjaWZpZWQgYm91bmQgbGlzdAotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudChzKSBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGxpc3QgY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5MaXN0I3JldGFpbkFsbChqYXZhLnV0aWwuQ29sbGVjdGlvbikKLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiByZXRhaW5JdGVtc0luTGlzdChDb2xsZWN0aW9uPD8+IGl0ZW1zLCBMaXN0PD8+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlpZiAobGlzdC5pc0VtcHR5KCkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlpZiAoaXRlbXMuaXNFbXB0eSgpKSB7Ci0JCQlyZXR1cm4gdGhpcy5jbGVhckxpc3RfKGxpc3QsIGxpc3ROYW1lKTsKLQkJfQotCQlyZXR1cm4gdGhpcy5yZXRhaW5JdGVtc0luTGlzdF8oaXRlbXMuaXRlcmF0b3IoKSwgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJldGFpbiB0aGUgc3BlY2lmaWVkIGl0ZW1zIGluIHRoZSBzcGVjaWZpZWQgYm91bmQgbGlzdAotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudChzKSBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGxpc3QgY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5MaXN0I3JldGFpbkFsbChqYXZhLnV0aWwuQ29sbGVjdGlvbikKLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiByZXRhaW5JdGVtc0luTGlzdChJdGVyYWJsZTw/PiBpdGVtcywgTGlzdDw/PiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJcmV0dXJuIHRoaXMucmV0YWluSXRlbXNJbkxpc3QoaXRlbXMuaXRlcmF0b3IoKSwgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJldGFpbiB0aGUgc3BlY2lmaWVkIGl0ZW1zIGluIHRoZSBzcGVjaWZpZWQgYm91bmQgbGlzdAotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudChzKSBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGxpc3QgY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5MaXN0I3JldGFpbkFsbChqYXZhLnV0aWwuQ29sbGVjdGlvbikKLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiByZXRhaW5JdGVtc0luTGlzdChJdGVyYXRvcjw/PiBpdGVtcywgTGlzdDw/PiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJaWYgKGxpc3QuaXNFbXB0eSgpKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJaWYgKCAhIGl0ZW1zLmhhc05leHQoKSkgewotCQkJcmV0dXJuIHRoaXMuY2xlYXJMaXN0XyhsaXN0LCBsaXN0TmFtZSk7Ci0JCX0KLQkJcmV0dXJuIHRoaXMucmV0YWluSXRlbXNJbkxpc3RfKGl0ZW1zLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogbm8gZW1wdHkgY2hlY2tzCi0JICovCi0JcHJvdGVjdGVkIGJvb2xlYW4gcmV0YWluSXRlbXNJbkxpc3RfKEl0ZXJhdG9yPD8+IGl0ZW1zLCBMaXN0PD8+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlIYXNoQmFnPD8+IHJldGFpbmVkSXRlbXMgPSBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbihpdGVtcyk7Ci0JCUhhc2hCYWc8Pz4gcmVtb3ZlZEl0ZW1zID0gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24obGlzdCk7Ci0JCXJlbW92ZWRJdGVtcy5yZW1vdmVBbGwocmV0YWluZWRJdGVtcyk7Ci0JCXJldHVybiB0aGlzLnJlbW92ZUl0ZW1zRnJvbUxpc3QocmVtb3ZlZEl0ZW1zLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSBzcGVjaWZpZWQgaXRlbSBpbiB0aGUgc3BlY2lmaWVkIGJvdW5kIGxpc3QKLQkgKiBhbmQgZmlyZSB0aGUgYXBwcm9wcmlhdGUgZXZlbnQgaWYgbmVjZXNzYXJ5LgotCSAqIFJldHVybiB0aGUgcmVwbGFjZWQgaXRlbS4KLQkgKiBAc2VlIGphdmEudXRpbC5MaXN0I3NldChpbnQsIE9iamVjdCkKLQkgKi8KLQlwdWJsaWMgPEU+IEUgc2V0SXRlbUluTGlzdChpbnQgaW5kZXgsIEUgaXRlbSwgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJRSByZXBsYWNlZEl0ZW0gPSBsaXN0LnNldChpbmRleCwgaXRlbSk7Ci0JCWlmICh0aGlzLnZhbHVlc0FyZURpZmZlcmVudChpdGVtLCByZXBsYWNlZEl0ZW0pKSB7Ci0JCQl0aGlzLmZpcmVJdGVtUmVwbGFjZWQobGlzdE5hbWUsIGluZGV4LCBpdGVtLCByZXBsYWNlZEl0ZW0pOwotCQl9Ci0JCXJldHVybiByZXBsYWNlZEl0ZW07Ci0JfQotCi0JLyoqCi0JICogUmVwbGFjZSB0aGUgc3BlY2lmaWVkIGl0ZW0gaW4gdGhlIHNwZWNpZmllZCBib3VuZCBsaXN0Ci0JICogYW5kIGZpcmUgdGhlIGFwcHJvcHJpYXRlIGV2ZW50IGlmIG5lY2Vzc2FyeS4KLQkgKiBSZXR1cm4gdGhlIGluZGV4IG9mIHRoZSByZXBsYWNlZCBpdGVtLgotCSAqIFJldHVybiAtMSBpZiB0aGUgaXRlbSB3YXMgbm90IGZvdW5kIGluIHRoZSBsaXN0LgotCSAqIEBzZWUgamF2YS51dGlsLkxpc3Qjc2V0KGludCwgT2JqZWN0KQotCSAqLwotCXB1YmxpYyA8RT4gaW50IHJlcGxhY2VJdGVtSW5MaXN0KEUgb2xkSXRlbSwgRSBuZXdJdGVtLCBMaXN0PEU+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlpZiAobGlzdC5pc0VtcHR5KCkpIHsKLQkJCXJldHVybiAtMTsKLQkJfQotCi0JCWludCBpbmRleCA9IGxpc3QuaW5kZXhPZihvbGRJdGVtKTsKLQkJaWYgKChpbmRleCAhPSAtMSkgJiYgdGhpcy52YWx1ZXNBcmVEaWZmZXJlbnQob2xkSXRlbSwgbmV3SXRlbSkpIHsKLQkJCWxpc3Quc2V0KGluZGV4LCBuZXdJdGVtKTsKLQkJCXRoaXMuZmlyZUl0ZW1SZXBsYWNlZChsaXN0TmFtZSwgaW5kZXgsIG5ld0l0ZW0sIG9sZEl0ZW0pOwotCQl9Ci0JCXJldHVybiBpbmRleDsKLQl9Ci0KLQkvKioKLQkgKiBTZXQgdGhlIHNwZWNpZmllZCBpdGVtcyBpbiB0aGUgc3BlY2lmaWVkIGJvdW5kIGxpc3QKLQkgKiBhbmQgZmlyZSB0aGUgYXBwcm9wcmlhdGUgZXZlbnQgaWYgbmVjZXNzYXJ5LgotCSAqIFJldHVybiB0aGUgcmVwbGFjZWQgaXRlbXMuCi0JICogQHNlZSBqYXZhLnV0aWwuTGlzdCNzZXQoaW50LCBPYmplY3QpCi0JICovCi0JcHVibGljIDxFPiBMaXN0PEU+IHNldEl0ZW1zSW5MaXN0KGludCBpbmRleCwgRVtdIGl0ZW1zLCBMaXN0PEU+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlpZiAoaXRlbXMubGVuZ3RoID09IDApIHsKLQkJCXJldHVybiBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsKLQkJfQotCQlyZXR1cm4gdGhpcy5zZXRJdGVtc0luTGlzdF8oaW5kZXgsIEFycmF5cy5hc0xpc3QoaXRlbXMpLCBsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSBzcGVjaWZpZWQgaXRlbXMgaW4gdGhlIHNwZWNpZmllZCBib3VuZCBsaXN0Ci0JICogYW5kIGZpcmUgdGhlIGFwcHJvcHJpYXRlIGV2ZW50IGlmIG5lY2Vzc2FyeS4KLQkgKiBSZXR1cm4gdGhlIHJlcGxhY2VkIGl0ZW1zLgotCSAqIEBzZWUgamF2YS51dGlsLkxpc3Qjc2V0KGludCwgT2JqZWN0KQotCSAqLwotCXB1YmxpYyA8RT4gTGlzdDxFPiBzZXRJdGVtc0luTGlzdChpbnQgaW5kZXgsIExpc3Q8PyBleHRlbmRzIEU+IGl0ZW1zLCBMaXN0PEU+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlpZiAoaXRlbXMuaXNFbXB0eSgpKSB7Ci0JCQlyZXR1cm4gQ29sbGVjdGlvbnMuZW1wdHlMaXN0KCk7Ci0JCX0KLQkJcmV0dXJuIHRoaXMuc2V0SXRlbXNJbkxpc3RfKGluZGV4LCBpdGVtcywgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCS8qKgotCSAqIG5vIGVtcHR5IGNoZWNrCi0JICovCi0JcHJvdGVjdGVkIDxFPiBMaXN0PEU+IHNldEl0ZW1zSW5MaXN0XyhpbnQgaW5kZXgsIExpc3Q8PyBleHRlbmRzIEU+IGl0ZW1zLCBMaXN0PEU+IGxpc3QsIFN0cmluZyBsaXN0TmFtZSkgewotCQlMaXN0PEU+IHN1Ykxpc3QgPSBsaXN0LnN1Ykxpc3QoaW5kZXgsIGluZGV4ICsgaXRlbXMuc2l6ZSgpKTsKLQkJTGlzdDxFPiByZXBsYWNlZEl0ZW1zID0gbmV3IEFycmF5TGlzdDxFPihzdWJMaXN0KTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBpdGVtcy5zaXplKCk7IGkrKykgewotCQkJRSBuZXdJdGVtID0gaXRlbXMuZ2V0KGkpOwotCQkJRSBvbGRJdGVtID0gc3ViTGlzdC5zZXQoaSwgbmV3SXRlbSk7Ci0JCQlpZiAodGhpcy52YWx1ZXNBcmVEaWZmZXJlbnQob2xkSXRlbSwgbmV3SXRlbSkpIHsKLQkJCQl0aGlzLmZpcmVJdGVtUmVwbGFjZWQobGlzdE5hbWUsIGluZGV4ICsgaSwgbmV3SXRlbSwgb2xkSXRlbSk7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIHJlcGxhY2VkSXRlbXM7Ci0JfQotCi0JLyoqCi0JICogTW92ZSBpdGVtcyBpbiB0aGUgc3BlY2lmaWVkIGxpc3QgZnJvbSB0aGUgc3BlY2lmaWVkIHNvdXJjZSBpbmRleCB0byB0aGUKLQkgKiBzcGVjaWZpZWQgdGFyZ2V0IGluZGV4IGZvciB0aGUgc3BlY2lmaWVkIGxlbmd0aC4KLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgbGlzdCBjaGFuZ2VkLgotCSAqLwotCXB1YmxpYyA8RT4gYm9vbGVhbiBtb3ZlSXRlbXNJbkxpc3QoaW50IHRhcmdldEluZGV4LCBpbnQgc291cmNlSW5kZXgsIGludCBsZW5ndGgsIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCWlmICgodGFyZ2V0SW5kZXggPT0gc291cmNlSW5kZXgpIHx8IChsZW5ndGggPT0gMCkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQkvLyBpdCdzIHVubGlrZWx5IGJ1dCBwb3NzaWJsZSB0aGUgbGlzdCBpcyB1bmNoYW5nZWQgYnkgdGhlIG1vdmUuLi4gKGUuZy4gYW55IG1vdmVzIHdpdGhpbiBbImZvbyIsICJmb28iLCAiZm9vIl0uLi4pCi0JCUNvbGxlY3Rpb25Ub29scy5tb3ZlKGxpc3QsIHRhcmdldEluZGV4LCBzb3VyY2VJbmRleCwgbGVuZ3RoKTsKLQkJdGhpcy5maXJlSXRlbXNNb3ZlZChsaXN0TmFtZSwgdGFyZ2V0SW5kZXgsIHNvdXJjZUluZGV4LCBsZW5ndGgpOwotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQkvKioKLQkgKiBNb3ZlIGFuIGl0ZW0gaW4gdGhlIHNwZWNpZmllZCBsaXN0IGZyb20gdGhlIHNwZWNpZmllZCBzb3VyY2UgaW5kZXggdG8gdGhlCi0JICogc3BlY2lmaWVkIHRhcmdldCBpbmRleC4KLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgbGlzdCBjaGFuZ2VkLgotCSAqLwotCXB1YmxpYyA8RT4gYm9vbGVhbiBtb3ZlSXRlbUluTGlzdChpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCwgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJaWYgKHRhcmdldEluZGV4ID09IHNvdXJjZUluZGV4KSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJLy8gaXQncyB1bmxpa2VseSBidXQgcG9zc2libGUgdGhlIGxpc3QgaXMgdW5jaGFuZ2VkIGJ5IHRoZSBtb3ZlLi4uIChlLmcuIGFueSBtb3ZlcyB3aXRoaW4gWyJmb28iLCAiZm9vIiwgImZvbyJdLi4uKQotCQlDb2xsZWN0aW9uVG9vbHMubW92ZShsaXN0LCB0YXJnZXRJbmRleCwgc291cmNlSW5kZXgpOwotCQl0aGlzLmZpcmVJdGVtTW92ZWQobGlzdE5hbWUsIHRhcmdldEluZGV4LCBzb3VyY2VJbmRleCk7Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCS8qKgotCSAqIENsZWFyIHRoZSBlbnRpcmUgbGlzdAotCSAqIGFuZCBmaXJlIHRoZSBhcHByb3ByaWF0ZSBldmVudCBpZiBuZWNlc3NhcnkuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGxpc3QgY2hhbmdlZC4KLQkgKiBAc2VlIGphdmEudXRpbC5MaXN0I2NsZWFyKCkKLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiBjbGVhckxpc3QoTGlzdDw/PiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJaWYgKGxpc3QuaXNFbXB0eSgpKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJcmV0dXJuIHRoaXMuY2xlYXJMaXN0XyhsaXN0LCBsaXN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogbm8gZW1wdHkgY2hlY2sKLQkgKi8KLQlwcm90ZWN0ZWQgYm9vbGVhbiBjbGVhckxpc3RfKExpc3Q8Pz4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCWxpc3QuY2xlYXIoKTsKLQkJdGhpcy5maXJlTGlzdENsZWFyZWQobGlzdE5hbWUpOwotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQkvKioKLQkgKiBTeW5jaHJvbml6ZSB0aGUgbGlzdCB3aXRoIHRoZSBzcGVjaWZpZWQgbmV3IGxpc3QsCi0JICogbWFraW5nIGEgbWluaW11bSBudW1iZXIgb2Ygc2V0cywgcmVtb3ZlcywgYW5kL29yIGFkZHMuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGxpc3QgY2hhbmdlZC4KLQkgKi8KLQlwdWJsaWMgPEU+IGJvb2xlYW4gc3luY2hyb25pemVMaXN0KExpc3Q8RT4gbmV3TGlzdCwgTGlzdDxFPiBsaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJaWYgKG5ld0xpc3QuaXNFbXB0eSgpKSB7Ci0JCQlyZXR1cm4gdGhpcy5jbGVhckxpc3QobGlzdCwgbGlzdE5hbWUpOwotCQl9Ci0JCWlmIChsaXN0LmlzRW1wdHkoKSkgewotCQkJcmV0dXJuIHRoaXMuYWRkSXRlbXNUb0xpc3RfKG5ld0xpc3QsIGxpc3QsIGxpc3ROYW1lKTsKLQkJfQotCQlyZXR1cm4gdGhpcy5zeW5jaHJvbml6ZUxpc3RfKG5ld0xpc3QsIGxpc3QsIGxpc3ROYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBTeW5jaHJvbml6ZSB0aGUgbGlzdCB3aXRoIHRoZSBzcGVjaWZpZWQgbmV3IGxpc3QsCi0JICogbWFraW5nIGEgbWluaW11bSBudW1iZXIgb2Ygc2V0cywgcmVtb3ZlcywgYW5kL29yIGFkZHMuCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGxpc3QgY2hhbmdlZC4KLQkgKi8KLQlwdWJsaWMgPEU+IGJvb2xlYW4gc3luY2hyb25pemVMaXN0KEl0ZXJhdG9yPEU+IG5ld0xpc3QsIExpc3Q8RT4gbGlzdCwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCWlmICggISBuZXdMaXN0Lmhhc05leHQoKSkgewotCQkJcmV0dXJuIHRoaXMuY2xlYXJMaXN0KGxpc3QsIGxpc3ROYW1lKTsKLQkJfQotCQlpZiAobGlzdC5pc0VtcHR5KCkpIHsKLQkJCXJldHVybiB0aGlzLmFkZEl0ZW1zVG9MaXN0XyhuZXdMaXN0LCBsaXN0LCBsaXN0TmFtZSk7Ci0JCX0KLQkJcmV0dXJuIHRoaXMuc3luY2hyb25pemVMaXN0XyhDb2xsZWN0aW9uVG9vbHMubGlzdChuZXdMaXN0KSwgbGlzdCwgbGlzdE5hbWUpOwotCX0KLQotCS8qKgotCSAqIG5vIGVtcHR5IGNoZWNrcwotCSAqLwotCXByb3RlY3RlZCA8RT4gYm9vbGVhbiBzeW5jaHJvbml6ZUxpc3RfKExpc3Q8RT4gbmV3TGlzdCwgTGlzdDxFPiBvbGRMaXN0LCBTdHJpbmcgbGlzdE5hbWUpIHsKLQkJaW50IG5ld1NpemUgPSBuZXdMaXN0LnNpemUoKTsKLQkJaW50IG9sZFNpemUgPSBvbGRMaXN0LnNpemUoKTsKLQotCQlib29sZWFuIGNoYW5nZWQgPSBmYWxzZTsKLQkJaW50IG1pbiA9IE1hdGgubWluKG5ld1NpemUsIG9sZFNpemUpOwotCQlmb3IgKGludCBpID0gMDsgaSA8IG1pbjsgaSsrKSB7Ci0JCQlFIG5ld0l0ZW0gPSBuZXdMaXN0LmdldChpKTsKLQkJCUUgb2xkSXRlbSA9IG9sZExpc3Quc2V0KGksIG5ld0l0ZW0pOwotCQkJaWYgKHRoaXMudmFsdWVzQXJlRGlmZmVyZW50KG9sZEl0ZW0sIG5ld0l0ZW0pKSB7Ci0JCQkJY2hhbmdlZCA9IHRydWU7Ci0JCQkJdGhpcy5maXJlSXRlbVJlcGxhY2VkKGxpc3ROYW1lLCBpLCBuZXdJdGVtLCBvbGRJdGVtKTsKLQkJCX0KLQkJfQotCi0JCWlmIChuZXdTaXplID09IG9sZFNpemUpIHsKLQkJCXJldHVybiBjaGFuZ2VkOwotCQl9Ci0KLQkJaWYgKG5ld1NpemUgPCBvbGRTaXplKSB7Ci0JCQl0aGlzLnJlbW92ZUl0ZW1zRnJvbUxpc3RfKG5ld1NpemUsIG9sZFNpemUgLSBuZXdTaXplLCBvbGRMaXN0LCBsaXN0TmFtZSk7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCi0JCS8vIG5ld1NpemUgPiBvbGRTaXplCi0JCXRoaXMuYWRkSXRlbXNUb0xpc3RfKG5ld0xpc3Quc3ViTGlzdChvbGRTaXplLCBuZXdTaXplKSwgb2xkTGlzdCwgbGlzdE5hbWUpOwotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogdHJlZSBjaGFuZ2Ugc3VwcG9ydCAqKioqKioqKioqCi0KLQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIENsYXNzPFRyZWVDaGFuZ2VMaXN0ZW5lcj4gVFJFRV9DSEFOR0VfTElTVEVORVJfQ0xBU1MgPSBUcmVlQ2hhbmdlTGlzdGVuZXIuY2xhc3M7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgT2JqZWN0W10gRU1QVFlfVFJFRV9QQVRIID0gbmV3IE9iamVjdFswXTsKLQotCS8qKgotCSAqIEFkZCBhIHRyZWUgY2hhbmdlIGxpc3RlbmVyIHRoYXQgaXMgcmVnaXN0ZXJlZCBmb3IgYWxsIHRyZWVzLgotCSAqLwotCXB1YmxpYyB2b2lkIGFkZFRyZWVDaGFuZ2VMaXN0ZW5lcihUcmVlQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJdGhpcy5hZGRMaXN0ZW5lcihUUkVFX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgbGlzdGVuZXIpOwotCX0KLQotCS8qKgotCSAqIEFkZCBhIHRyZWUgY2hhbmdlIGxpc3RlbmVyIGZvciB0aGUgc3BlY2lmaWVkIHRyZWUuIFRoZSBsaXN0ZW5lcgotCSAqIHdpbGwgYmUgbm90aWZpZWQgb25seSBmb3IgY2hhbmdlcyB0byB0aGUgc3BlY2lmaWVkIHRyZWUuCi0JICovCi0JcHVibGljIHZvaWQgYWRkVHJlZUNoYW5nZUxpc3RlbmVyKFN0cmluZyB0cmVlTmFtZSwgVHJlZUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMuYWRkTGlzdGVuZXIodHJlZU5hbWUsIFRSRUVfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBsaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGEgdHJlZSBjaGFuZ2UgbGlzdGVuZXIgdGhhdCB3YXMgcmVnaXN0ZXJlZCBmb3IgYWxsIHRyZWUuCi0JICovCi0JcHVibGljIHZvaWQgcmVtb3ZlVHJlZUNoYW5nZUxpc3RlbmVyKFRyZWVDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLnJlbW92ZUxpc3RlbmVyKFRSRUVfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBsaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIGEgdHJlZSBjaGFuZ2UgbGlzdGVuZXIgdGhhdCB3YXMgcmVnaXN0ZXJlZCBmb3IgYSBzcGVjaWZpYyB0cmVlLgotCSAqLwotCXB1YmxpYyB2b2lkIHJlbW92ZVRyZWVDaGFuZ2VMaXN0ZW5lcihTdHJpbmcgdHJlZU5hbWUsIFRyZWVDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLnJlbW92ZUxpc3RlbmVyKHRyZWVOYW1lLCBUUkVFX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgbGlzdGVuZXIpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZXJlIGFyZSBhbnkgdHJlZSBjaGFuZ2UgbGlzdGVuZXJzIHRoYXQgd2lsbAotCSAqIGJlIG5vdGlmaWVkIHdoZW4gdGhlIHNwZWNpZmllZCB0cmVlIGhhcyBjaGFuZ2VkLgotCSAqLwotCXB1YmxpYyBib29sZWFuIGhhc0FueVRyZWVDaGFuZ2VMaXN0ZW5lcnMoU3RyaW5nIHRyZWVOYW1lKSB7Ci0JCXJldHVybiB0aGlzLmhhc0FueUxpc3RlbmVycyhUUkVFX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgdHJlZU5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZXJlIGFyZSBhbnkgdHJlZSBjaGFuZ2UgbGlzdGVuZXJzIHRoYXQgd2lsbAotCSAqIGJlIG5vdGlmaWVkIHdoZW4gYW55IHRyZWUgaGFzIGNoYW5nZWQuCi0JICovCi0JcHVibGljIGJvb2xlYW4gaGFzQW55VHJlZUNoYW5nZUxpc3RlbmVycygpIHsKLQkJcmV0dXJuIHRoaXMuaGFzQW55TGlzdGVuZXJzKFRSRUVfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTKTsKLQl9Ci0KLQlwcml2YXRlIFRyZWVDaGFuZ2VMaXN0ZW5lcltdIGdldFRyZWVDaGFuZ2VMaXN0ZW5lcnMoKSB7Ci0JCXJldHVybiAoVHJlZUNoYW5nZUxpc3RlbmVyW10pIHRoaXMuZ2V0TGlzdGVuZXJzKFRSRUVfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYSBib3VuZCB0cmVlIHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIHZvaWQgZmlyZU5vZGVBZGRlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJU3RyaW5nIHRyZWVOYW1lID0gZXZlbnQuZ2V0VHJlZU5hbWUoKTsKLQotCQlUcmVlQ2hhbmdlTGlzdGVuZXJbXSB0YXJnZXRzID0gbnVsbDsKLQkJQ2hhbmdlU3VwcG9ydCBjaGlsZCA9IG51bGw7Ci0KLQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQlUcmVlQ2hhbmdlTGlzdGVuZXJbXSB0cmVlQ2hhbmdlTGlzdGVuZXJzID0gdGhpcy5nZXRUcmVlQ2hhbmdlTGlzdGVuZXJzKCk7Ci0JCQlpZiAodHJlZUNoYW5nZUxpc3RlbmVycyAhPSBudWxsKSB7Ci0JCQkJdGFyZ2V0cyA9IHRyZWVDaGFuZ2VMaXN0ZW5lcnMuY2xvbmUoKTsKLQkJCX0KLQkJCWNoaWxkID0gdGhpcy5nZXRDaGlsZCh0cmVlTmFtZSk7Ci0JCX0KLQotCQlpZiAodGFyZ2V0cyAhPSBudWxsKSB7Ci0JCQlmb3IgKFRyZWVDaGFuZ2VMaXN0ZW5lciB0YXJnZXQgOiB0YXJnZXRzKSB7Ci0JCQkJYm9vbGVhbiBzdGlsbExpc3RlbmluZzsKLQkJCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCQkJc3RpbGxMaXN0ZW5pbmcgPSBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5nZXRUcmVlQ2hhbmdlTGlzdGVuZXJzKCksIHRhcmdldCk7Ci0JCQkJfQotCQkJCWlmIChzdGlsbExpc3RlbmluZykgewotCQkJCQl0YXJnZXQubm9kZUFkZGVkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGNoaWxkICE9IG51bGwpIHsKLQkJCWNoaWxkLmZpcmVOb2RlQWRkZWQoZXZlbnQpOwotCQl9Ci0KLQkJdGhpcy5zb3VyY2VDaGFuZ2VkKHRyZWVOYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYSBib3VuZCB0cmVlIHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIHZvaWQgZmlyZU5vZGVBZGRlZChTdHJpbmcgdHJlZU5hbWUsIE9iamVjdFtdIHBhdGgpIHsKLS8vCQl0aGlzLmZpcmVOb2RlQWRkZWQobmV3IFRyZWVDaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgdHJlZU5hbWUsIHBhdGgpKTsKLQotCQlUcmVlQ2hhbmdlTGlzdGVuZXJbXSB0YXJnZXRzID0gbnVsbDsKLQkJQ2hhbmdlU3VwcG9ydCBjaGlsZCA9IG51bGw7Ci0KLQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQlUcmVlQ2hhbmdlTGlzdGVuZXJbXSB0cmVlQ2hhbmdlTGlzdGVuZXJzID0gdGhpcy5nZXRUcmVlQ2hhbmdlTGlzdGVuZXJzKCk7Ci0JCQlpZiAodHJlZUNoYW5nZUxpc3RlbmVycyAhPSBudWxsKSB7Ci0JCQkJdGFyZ2V0cyA9IHRyZWVDaGFuZ2VMaXN0ZW5lcnMuY2xvbmUoKTsKLQkJCX0KLQkJCWNoaWxkID0gdGhpcy5nZXRDaGlsZCh0cmVlTmFtZSk7Ci0JCX0KLQotCQlUcmVlQ2hhbmdlRXZlbnQgZXZlbnQgPSBudWxsOwotCi0JCWlmICh0YXJnZXRzICE9IG51bGwpIHsKLQkJCWZvciAoVHJlZUNoYW5nZUxpc3RlbmVyIHRhcmdldCA6IHRhcmdldHMpIHsKLQkJCQlib29sZWFuIHN0aWxsTGlzdGVuaW5nOwotCQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCQlzdGlsbExpc3RlbmluZyA9IENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmdldFRyZWVDaGFuZ2VMaXN0ZW5lcnMoKSwgdGFyZ2V0KTsKLQkJCQl9Ci0JCQkJaWYgKHN0aWxsTGlzdGVuaW5nKSB7Ci0JCQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJCQkvLyBoZXJlJ3MgdGhlIHJlYXNvbiBmb3IgdGhlIGR1cGxpY2F0ZSBjb2RlLi4uCi0JCQkJCQlldmVudCA9IG5ldyBUcmVlQ2hhbmdlRXZlbnQodGhpcy5zb3VyY2UsIHRyZWVOYW1lLCBwYXRoKTsKLQkJCQkJfQotCQkJCQl0YXJnZXQubm9kZUFkZGVkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGNoaWxkICE9IG51bGwpIHsKLQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJY2hpbGQuZmlyZU5vZGVBZGRlZCh0cmVlTmFtZSwgcGF0aCk7Ci0JCQl9IGVsc2UgewotCQkJCWNoaWxkLmZpcmVOb2RlQWRkZWQoZXZlbnQpOwotCQkJfQotCQl9Ci0KLQkJdGhpcy5zb3VyY2VDaGFuZ2VkKHRyZWVOYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYSBib3VuZCB0cmVlIHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIHZvaWQgZmlyZU5vZGVSZW1vdmVkKFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQlTdHJpbmcgdHJlZU5hbWUgPSBldmVudC5nZXRUcmVlTmFtZSgpOwotCi0JCVRyZWVDaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCVRyZWVDaGFuZ2VMaXN0ZW5lcltdIHRyZWVDaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldFRyZWVDaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmICh0cmVlQ2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gdHJlZUNoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKHRyZWVOYW1lKTsKLQkJfQotCi0JCWlmICh0YXJnZXRzICE9IG51bGwpIHsKLQkJCWZvciAoVHJlZUNoYW5nZUxpc3RlbmVyIHRhcmdldCA6IHRhcmdldHMpIHsKLQkJCQlib29sZWFuIHN0aWxsTGlzdGVuaW5nOwotCQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCQlzdGlsbExpc3RlbmluZyA9IENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmdldFRyZWVDaGFuZ2VMaXN0ZW5lcnMoKSwgdGFyZ2V0KTsKLQkJCQl9Ci0JCQkJaWYgKHN0aWxsTGlzdGVuaW5nKSB7Ci0JCQkJCXRhcmdldC5ub2RlUmVtb3ZlZChldmVudCk7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWlmIChjaGlsZCAhPSBudWxsKSB7Ci0JCQljaGlsZC5maXJlTm9kZVJlbW92ZWQoZXZlbnQpOwotCQl9Ci0KLQkJdGhpcy5zb3VyY2VDaGFuZ2VkKHRyZWVOYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYSBib3VuZCB0cmVlIHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIHZvaWQgZmlyZU5vZGVSZW1vdmVkKFN0cmluZyB0cmVlTmFtZSwgT2JqZWN0W10gcGF0aCkgewotLy8JCXRoaXMuZmlyZU5vZGVSZW1vdmVkKG5ldyBUcmVlQ2hhbmdlRXZlbnQodGhpcy5zb3VyY2UsIHRyZWVOYW1lLCBwYXRoKSk7Ci0KLQkJVHJlZUNoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0JCUNoYW5nZVN1cHBvcnQgY2hpbGQgPSBudWxsOwotCi0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJVHJlZUNoYW5nZUxpc3RlbmVyW10gdHJlZUNoYW5nZUxpc3RlbmVycyA9IHRoaXMuZ2V0VHJlZUNoYW5nZUxpc3RlbmVycygpOwotCQkJaWYgKHRyZWVDaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSB0cmVlQ2hhbmdlTGlzdGVuZXJzLmNsb25lKCk7Ci0JCQl9Ci0JCQljaGlsZCA9IHRoaXMuZ2V0Q2hpbGQodHJlZU5hbWUpOwotCQl9Ci0KLQkJVHJlZUNoYW5nZUV2ZW50IGV2ZW50ID0gbnVsbDsKLQotCQlpZiAodGFyZ2V0cyAhPSBudWxsKSB7Ci0JCQlmb3IgKFRyZWVDaGFuZ2VMaXN0ZW5lciB0YXJnZXQgOiB0YXJnZXRzKSB7Ci0JCQkJYm9vbGVhbiBzdGlsbExpc3RlbmluZzsKLQkJCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCQkJc3RpbGxMaXN0ZW5pbmcgPSBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5nZXRUcmVlQ2hhbmdlTGlzdGVuZXJzKCksIHRhcmdldCk7Ci0JCQkJfQotCQkJCWlmIChzdGlsbExpc3RlbmluZykgewotCQkJCQlpZiAoZXZlbnQgPT0gbnVsbCkgewotCQkJCQkJLy8gaGVyZSdzIHRoZSByZWFzb24gZm9yIHRoZSBkdXBsaWNhdGUgY29kZS4uLgotCQkJCQkJZXZlbnQgPSBuZXcgVHJlZUNoYW5nZUV2ZW50KHRoaXMuc291cmNlLCB0cmVlTmFtZSwgcGF0aCk7Ci0JCQkJCX0KLQkJCQkJdGFyZ2V0Lm5vZGVSZW1vdmVkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGNoaWxkICE9IG51bGwpIHsKLQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJY2hpbGQuZmlyZU5vZGVSZW1vdmVkKHRyZWVOYW1lLCBwYXRoKTsKLQkJCX0gZWxzZSB7Ci0JCQkJY2hpbGQuZmlyZU5vZGVSZW1vdmVkKGV2ZW50KTsKLQkJCX0KLQkJfQotCi0JCXRoaXMuc291cmNlQ2hhbmdlZCh0cmVlTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVwb3J0IGEgYm91bmQgdHJlZSB1cGRhdGUgdG8gYW55IHJlZ2lzdGVyZWQgbGlzdGVuZXJzLgotCSAqLwotCXB1YmxpYyB2b2lkIGZpcmVUcmVlQ2xlYXJlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJU3RyaW5nIHRyZWVOYW1lID0gZXZlbnQuZ2V0VHJlZU5hbWUoKTsKLQotCQlUcmVlQ2hhbmdlTGlzdGVuZXJbXSB0YXJnZXRzID0gbnVsbDsKLQkJQ2hhbmdlU3VwcG9ydCBjaGlsZCA9IG51bGw7Ci0KLQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQlUcmVlQ2hhbmdlTGlzdGVuZXJbXSB0cmVlQ2hhbmdlTGlzdGVuZXJzID0gdGhpcy5nZXRUcmVlQ2hhbmdlTGlzdGVuZXJzKCk7Ci0JCQlpZiAodHJlZUNoYW5nZUxpc3RlbmVycyAhPSBudWxsKSB7Ci0JCQkJdGFyZ2V0cyA9IHRyZWVDaGFuZ2VMaXN0ZW5lcnMuY2xvbmUoKTsKLQkJCX0KLQkJCWNoaWxkID0gdGhpcy5nZXRDaGlsZCh0cmVlTmFtZSk7Ci0JCX0KLQotCQlpZiAodGFyZ2V0cyAhPSBudWxsKSB7Ci0JCQlmb3IgKFRyZWVDaGFuZ2VMaXN0ZW5lciB0YXJnZXQgOiB0YXJnZXRzKSB7Ci0JCQkJYm9vbGVhbiBzdGlsbExpc3RlbmluZzsKLQkJCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCQkJc3RpbGxMaXN0ZW5pbmcgPSBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5nZXRUcmVlQ2hhbmdlTGlzdGVuZXJzKCksIHRhcmdldCk7Ci0JCQkJfQotCQkJCWlmIChzdGlsbExpc3RlbmluZykgewotCQkJCQl0YXJnZXQudHJlZUNsZWFyZWQoZXZlbnQpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlpZiAoY2hpbGQgIT0gbnVsbCkgewotCQkJY2hpbGQuZmlyZVRyZWVDbGVhcmVkKGV2ZW50KTsKLQkJfQotCi0JCXRoaXMuc291cmNlQ2hhbmdlZCh0cmVlTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmVwb3J0IGEgYm91bmQgdHJlZSB1cGRhdGUgdG8gYW55IHJlZ2lzdGVyZWQgbGlzdGVuZXJzLgotCSAqLwotCXB1YmxpYyB2b2lkIGZpcmVUcmVlQ2xlYXJlZChTdHJpbmcgdHJlZU5hbWUsIE9iamVjdFtdIHBhdGgpIHsKLS8vCQl0aGlzLmZpcmVUcmVlQ2xlYXJlZChuZXcgVHJlZUNoYW5nZUV2ZW50KHRoaXMuc291cmNlLCB0cmVlTmFtZSwgcGF0aCkpOwotCi0JCVRyZWVDaGFuZ2VMaXN0ZW5lcltdIHRhcmdldHMgPSBudWxsOwotCQlDaGFuZ2VTdXBwb3J0IGNoaWxkID0gbnVsbDsKLQotCQlzeW5jaHJvbml6ZWQgKHRoaXMpIHsKLQkJCVRyZWVDaGFuZ2VMaXN0ZW5lcltdIHRyZWVDaGFuZ2VMaXN0ZW5lcnMgPSB0aGlzLmdldFRyZWVDaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCWlmICh0cmVlQ2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQl0YXJnZXRzID0gdHJlZUNoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJfQotCQkJY2hpbGQgPSB0aGlzLmdldENoaWxkKHRyZWVOYW1lKTsKLQkJfQotCi0JCVRyZWVDaGFuZ2VFdmVudCBldmVudCA9IG51bGw7Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChUcmVlQ2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0VHJlZUNoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQkJCS8vIGhlcmUncyB0aGUgcmVhc29uIGZvciB0aGUgZHVwbGljYXRlIGNvZGUuLi4KLQkJCQkJCWV2ZW50ID0gbmV3IFRyZWVDaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgdHJlZU5hbWUsIHBhdGgpOwotCQkJCQl9Ci0JCQkJCXRhcmdldC50cmVlQ2xlYXJlZChldmVudCk7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWlmIChjaGlsZCAhPSBudWxsKSB7Ci0JCQlpZiAoZXZlbnQgPT0gbnVsbCkgewotCQkJCWNoaWxkLmZpcmVUcmVlQ2xlYXJlZCh0cmVlTmFtZSwgcGF0aCk7Ci0JCQl9IGVsc2UgewotCQkJCWNoaWxkLmZpcmVUcmVlQ2xlYXJlZChldmVudCk7Ci0JCQl9Ci0JCX0KLQotCQl0aGlzLnNvdXJjZUNoYW5nZWQodHJlZU5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJlcG9ydCBhIGJvdW5kIHRyZWUgdXBkYXRlIHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlVHJlZUNsZWFyZWQoU3RyaW5nIHRyZWVOYW1lKSB7Ci0JCXRoaXMuZmlyZVRyZWVDbGVhcmVkKHRyZWVOYW1lLCBFTVBUWV9UUkVFX1BBVEgpOwotCX0KLQotCS8qKgotCSAqIFJlcG9ydCBhIGJvdW5kIHRyZWUgdXBkYXRlIHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlVHJlZUNoYW5nZWQoVHJlZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCVN0cmluZyB0cmVlTmFtZSA9IGV2ZW50LmdldFRyZWVOYW1lKCk7Ci0KLQkJVHJlZUNoYW5nZUxpc3RlbmVyW10gdGFyZ2V0cyA9IG51bGw7Ci0JCUNoYW5nZVN1cHBvcnQgY2hpbGQgPSBudWxsOwotCi0JCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJVHJlZUNoYW5nZUxpc3RlbmVyW10gdHJlZUNoYW5nZUxpc3RlbmVycyA9IHRoaXMuZ2V0VHJlZUNoYW5nZUxpc3RlbmVycygpOwotCQkJaWYgKHRyZWVDaGFuZ2VMaXN0ZW5lcnMgIT0gbnVsbCkgewotCQkJCXRhcmdldHMgPSB0cmVlQ2hhbmdlTGlzdGVuZXJzLmNsb25lKCk7Ci0JCQl9Ci0JCQljaGlsZCA9IHRoaXMuZ2V0Q2hpbGQodHJlZU5hbWUpOwotCQl9Ci0KLQkJaWYgKHRhcmdldHMgIT0gbnVsbCkgewotCQkJZm9yIChUcmVlQ2hhbmdlTGlzdGVuZXIgdGFyZ2V0IDogdGFyZ2V0cykgewotCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQkJCXN0aWxsTGlzdGVuaW5nID0gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZ2V0VHJlZUNoYW5nZUxpc3RlbmVycygpLCB0YXJnZXQpOwotCQkJCX0KLQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJdGFyZ2V0LnRyZWVDaGFuZ2VkKGV2ZW50KTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJaWYgKGNoaWxkICE9IG51bGwpIHsKLQkJCWNoaWxkLmZpcmVUcmVlQ2hhbmdlZChldmVudCk7Ci0JCX0KLQotCQl0aGlzLnNvdXJjZUNoYW5nZWQodHJlZU5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJlcG9ydCBhIGJvdW5kIHRyZWUgdXBkYXRlIHRvIGFueSByZWdpc3RlcmVkIGxpc3RlbmVycy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBmaXJlVHJlZUNoYW5nZWQoU3RyaW5nIHRyZWVOYW1lLCBPYmplY3RbXSBwYXRoKSB7Ci0vLwkJdGhpcy5maXJlVHJlZUNoYW5nZWQobmV3IFRyZWVDaGFuZ2VFdmVudCh0aGlzLnNvdXJjZSwgdHJlZU5hbWUsIHBhdGgpKTsKLQotCQlUcmVlQ2hhbmdlTGlzdGVuZXJbXSB0YXJnZXRzID0gbnVsbDsKLQkJQ2hhbmdlU3VwcG9ydCBjaGlsZCA9IG51bGw7Ci0KLQkJc3luY2hyb25pemVkICh0aGlzKSB7Ci0JCQlUcmVlQ2hhbmdlTGlzdGVuZXJbXSB0cmVlQ2hhbmdlTGlzdGVuZXJzID0gdGhpcy5nZXRUcmVlQ2hhbmdlTGlzdGVuZXJzKCk7Ci0JCQlpZiAodHJlZUNoYW5nZUxpc3RlbmVycyAhPSBudWxsKSB7Ci0JCQkJdGFyZ2V0cyA9IHRyZWVDaGFuZ2VMaXN0ZW5lcnMuY2xvbmUoKTsKLQkJCX0KLQkJCWNoaWxkID0gdGhpcy5nZXRDaGlsZCh0cmVlTmFtZSk7Ci0JCX0KLQotCQlUcmVlQ2hhbmdlRXZlbnQgZXZlbnQgPSBudWxsOwotCi0JCWlmICh0YXJnZXRzICE9IG51bGwpIHsKLQkJCWZvciAoVHJlZUNoYW5nZUxpc3RlbmVyIHRhcmdldCA6IHRhcmdldHMpIHsKLQkJCQlib29sZWFuIHN0aWxsTGlzdGVuaW5nOwotCQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCQlzdGlsbExpc3RlbmluZyA9IENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmdldFRyZWVDaGFuZ2VMaXN0ZW5lcnMoKSwgdGFyZ2V0KTsKLQkJCQl9Ci0JCQkJaWYgKHN0aWxsTGlzdGVuaW5nKSB7Ci0JCQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJCQkvLyBoZXJlJ3MgdGhlIHJlYXNvbiBmb3IgdGhlIGR1cGxpY2F0ZSBjb2RlLi4uCi0JCQkJCQlldmVudCA9IG5ldyBUcmVlQ2hhbmdlRXZlbnQodGhpcy5zb3VyY2UsIHRyZWVOYW1lLCBwYXRoKTsKLQkJCQkJfQotCQkJCQl0YXJnZXQudHJlZUNoYW5nZWQoZXZlbnQpOwotCQkJCX0KLQkJCX0KLQkJfQotCQlpZiAoY2hpbGQgIT0gbnVsbCkgewotCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQljaGlsZC5maXJlVHJlZUNoYW5nZWQodHJlZU5hbWUsIHBhdGgpOwotCQkJfSBlbHNlIHsKLQkJCQljaGlsZC5maXJlVHJlZUNoYW5nZWQoZXZlbnQpOwotCQkJfQotCQl9Ci0KLQkJdGhpcy5zb3VyY2VDaGFuZ2VkKHRyZWVOYW1lKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBvcnQgYSBib3VuZCB0cmVlIHVwZGF0ZSB0byBhbnkgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMuCi0JICovCi0JcHVibGljIHZvaWQgZmlyZVRyZWVDaGFuZ2VkKFN0cmluZyB0cmVlTmFtZSkgewotCQl0aGlzLmZpcmVUcmVlQ2hhbmdlZCh0cmVlTmFtZSwgRU1QVFlfVFJFRV9QQVRIKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY29udmVuaWVuY2UgbWV0aG9kcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgdmFsdWVzIGFyZSBlcXVhbCwgd2l0aCB0aGUgYXBwcm9wcmlhdGUgbnVsbCBjaGVja3MuCi0JICogQ29udmVuaWVuY2UgbWV0aG9kIGZvciBjaGVja2luZyB3aGV0aGVyIGFuIGF0dHJpYnV0ZSB2YWx1ZSBoYXMgY2hhbmdlZC4KLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiB2YWx1ZXNBcmVFcXVhbChPYmplY3QgdmFsdWUxLCBPYmplY3QgdmFsdWUyKSB7Ci0JCWlmICgodmFsdWUxID09IG51bGwpICYmICh2YWx1ZTIgPT0gbnVsbCkpIHsKLQkJCXJldHVybiB0cnVlOwkvLyBib3RoIGFyZSBudWxsCi0JCX0KLQkJaWYgKCh2YWx1ZTEgPT0gbnVsbCkgfHwgKHZhbHVlMiA9PSBudWxsKSkgewotCQkJcmV0dXJuIGZhbHNlOwkvLyBvbmUgaXMgbnVsbCBidXQgdGhlIG90aGVyIGlzIG5vdAotCQl9Ci0JCXJldHVybiB2YWx1ZTEuZXF1YWxzKHZhbHVlMik7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHZhbHVlcyBhcmUgZGlmZmVyZW50LCB3aXRoIHRoZSBhcHByb3ByaWF0ZSBudWxsIGNoZWNrcy4KLQkgKiBDb252ZW5pZW5jZSBtZXRob2QgZm9yIGNoZWNraW5nIHdoZXRoZXIgYW4gYXR0cmlidXRlIHZhbHVlIGhhcyBjaGFuZ2VkLgotCSAqLwotCXB1YmxpYyBib29sZWFuIHZhbHVlc0FyZURpZmZlcmVudChPYmplY3QgdmFsdWUxLCBPYmplY3QgdmFsdWUyKSB7Ci0JCXJldHVybiAhIHRoaXMudmFsdWVzQXJlRXF1YWwodmFsdWUxLCB2YWx1ZTIpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBzdGFuZGFyZCBtZXRob2RzICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuc291cmNlKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogc2VyaWFsaXphdGlvbiAqKioqKioqKioqCi0KLQlwcml2YXRlIHN5bmNocm9uaXplZCB2b2lkIHdyaXRlT2JqZWN0KE9iamVjdE91dHB1dFN0cmVhbSBzKSB0aHJvd3MgSU9FeGNlcHRpb24gewotCQkvLyB3cml0ZSBvdXQgdGhlIHNvdXJjZSwgY2hpbGRyZW4sIGFuZCBhbnkgaGlkZGVuIHN0dWZmCi0JCXMuZGVmYXVsdFdyaXRlT2JqZWN0KCk7Ci0KLQkJLy8gb25seSB3cml0ZSBvdXQgU2VyaWFsaXphYmxlIGxpc3RlbmVycwotCQlpbnQgbGVuID0gdGhpcy5nZW5lcmljTGlzdGVuZXJzLmxlbmd0aDsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsZW47IGkrKykgewotCQkJdGhpcy53cml0ZU9iamVjdChzLCB0aGlzLmdlbmVyaWNMaXN0ZW5lcnNbaV0pOwotCQl9Ci0JCXMud3JpdGVPYmplY3QobnVsbCk7Ci0gICAgfQotCi0JcHJpdmF0ZSB2b2lkIHdyaXRlT2JqZWN0KE9iamVjdE91dHB1dFN0cmVhbSBzLCBHZW5lcmljTGlzdGVuZXJMaXN0IGdsbCkgdGhyb3dzIElPRXhjZXB0aW9uIHsKLQkJYm9vbGVhbiBmaXJzdCA9IHRydWU7Ci0JCWludCBsZW4gPSBnbGwubGlzdGVuZXJzLmxlbmd0aDsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsZW47IGkrKykgewotCQkJQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSBnbGwubGlzdGVuZXJzW2ldOwotCQkJaWYgKGxpc3RlbmVyIGluc3RhbmNlb2YgU2VyaWFsaXphYmxlKSB7Ci0JCQkJaWYgKGZpcnN0KSB7Ci0JCQkJCWZpcnN0ID0gZmFsc2U7Ci0JCQkJCXMud3JpdGVPYmplY3QoZ2xsLmxpc3RlbmVyQ2xhc3MpOwotCQkJCX0KLQkJCQlzLndyaXRlT2JqZWN0KGxpc3RlbmVyKTsKLQkJCX0KLQkJfQotCQlpZiAoICEgZmlyc3QpIHsKLQkJCXMud3JpdGVPYmplY3QobnVsbCk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHN5bmNocm9uaXplZCB2b2lkIHJlYWRPYmplY3QoT2JqZWN0SW5wdXRTdHJlYW0gcykgdGhyb3dzIENsYXNzTm90Rm91bmRFeGNlcHRpb24sIElPRXhjZXB0aW9uIHsKLQkJLy8gcmVhZCBpbiB0aGUgc291cmNlLCBjaGlsZHJlbiwgYW5kIGFueSBoaWRkZW4gc3R1ZmYKLQkJcy5kZWZhdWx0UmVhZE9iamVjdCgpOwotCi0JCS8vIHJlYWQgaW4gZ2VuZXJpYyBsaXN0ZW5lciBsaXN0cwotCQl0aGlzLmdlbmVyaWNMaXN0ZW5lcnMgPSBFTVBUWV9HRU5FUklDX0xJU1RFTkVSUzsKLQkJT2JqZWN0IG87Ci0JCXdoaWxlIChudWxsICE9IChvID0gcy5yZWFkT2JqZWN0KCkpKSB7Ci0JCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJCUNsYXNzPD8gZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gbGlzdGVuZXJDbGFzcyA9IChDbGFzczw/IGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXI+KSBvOwotCQkJR2VuZXJpY0xpc3RlbmVyTGlzdCBnbGwgPSBudWxsOwotCQkJd2hpbGUgKG51bGwgIT0gKG8gPSBzLnJlYWRPYmplY3QoKSkpIHsKLQkJCQlpZiAoZ2xsID09IG51bGwpIHsKLQkJCQkJZ2xsID0gdGhpcy5hZGRHZW5lcmljTGlzdGVuZXJMaXN0XyhsaXN0ZW5lckNsYXNzLCAoQ2hhbmdlTGlzdGVuZXIpIG8pOwotCQkJCX0gZWxzZSB7Ci0JCQkJCWdsbC5hZGRMaXN0ZW5lcigoQ2hhbmdlTGlzdGVuZXIpIG8pOwotCQkJCX0KLQkJCX0KLQkJfQotCX0KLQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByaXZhdGUgPFQgZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gR2VuZXJpY0xpc3RlbmVyTGlzdCBhZGRHZW5lcmljTGlzdGVuZXJMaXN0XyhDbGFzczxUPiBsaXN0ZW5lckNsYXNzLCBDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlyZXR1cm4gdGhpcy5hZGRHZW5lcmljTGlzdGVuZXJMaXN0KGxpc3RlbmVyQ2xhc3MsIChUKSBsaXN0ZW5lcik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIG1lbWJlciBjbGFzc2VzICoqKioqKioqKioKLQotCS8qKgotCSAqIFBhaXIgYSBsaXN0ZW5lciBjbGFzcyB3aXRoIGl0cyAiZ2VuZXJpYyIgbGlzdGVuZXJzLgotCSAqLwotCXByaXZhdGUgc3RhdGljIGNsYXNzIEdlbmVyaWNMaXN0ZW5lckxpc3QgewotCQlmaW5hbCBDbGFzczw/IGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXI+IGxpc3RlbmVyQ2xhc3M7Ci0JCUNoYW5nZUxpc3RlbmVyW10gbGlzdGVuZXJzOwotCi0JCTxUIGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXI+IEdlbmVyaWNMaXN0ZW5lckxpc3QoQ2xhc3M8VD4gbGlzdGVuZXJDbGFzcywgVCBsaXN0ZW5lcikgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMubGlzdGVuZXJDbGFzcyA9IGxpc3RlbmVyQ2xhc3M7Ci0JCQl0aGlzLmxpc3RlbmVycyA9IChDaGFuZ2VMaXN0ZW5lcltdKSBBcnJheS5uZXdJbnN0YW5jZShsaXN0ZW5lckNsYXNzLCAxKTsKLQkJCXRoaXMubGlzdGVuZXJzWzBdID0gbGlzdGVuZXI7Ci0JCX0KLQotCQl2b2lkIGFkZExpc3RlbmVyKENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCQl0aGlzLmxpc3RlbmVycyA9IENvbGxlY3Rpb25Ub29scy5hZGQodGhpcy5saXN0ZW5lcnMsIGxpc3RlbmVyKTsKLQkJfQotCi0JCWJvb2xlYW4gcmVtb3ZlTGlzdGVuZXIoQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJCWludCBsZW4gPSB0aGlzLmxpc3RlbmVycy5sZW5ndGg7Ci0JCQlpZiAobGVuID09IDApIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCQl0cnkgewotCQkJCXRoaXMubGlzdGVuZXJzID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZSh0aGlzLmxpc3RlbmVycywgbGlzdGVuZXIpOwotCQkJfSBjYXRjaCAoQXJyYXlJbmRleE91dE9mQm91bmRzRXhjZXB0aW9uIGV4KSB7Ci0JCQkJcmV0dXJuIGZhbHNlOyAgLy8gbGlzdGVuZXIgbm90IGluIHRoZSBsaXN0Ci0JCQl9Ci0JCQlyZXR1cm4gKHRoaXMubGlzdGVuZXJzLmxlbmd0aCArIDEpID09IGxlbjsKLQkJfQotCi0JCWJvb2xlYW4gaGFzTGlzdGVuZXJzKCkgewotCQkJcmV0dXJuIHRoaXMubGlzdGVuZXJzLmxlbmd0aCA+IDA7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIENsYXNzVG9vbHMuc2hvcnROYW1lRm9yKHRoaXMubGlzdGVuZXJDbGFzcykpOwotCQl9Ci0KLQl9Ci0KLQotCS8qKgotCSAqIFBhaXIgYW4gYXNwZWN0IG5hbWUgd2l0aCB0aGUgY2hhbmdlIHN1cHBvcnQgaG9sZGluZyBpdHMgYXNzb2NpYXRlZAotCSAqIGxpc3RlbmVycy4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBBc3BlY3RDaGlsZCBpbXBsZW1lbnRzIFNlcmlhbGl6YWJsZSB7Ci0JCWZpbmFsIFN0cmluZyBhc3BlY3ROYW1lOwotCQlmaW5hbCBDaGFuZ2VTdXBwb3J0IGNoaWxkOwotCQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCQlBc3BlY3RDaGlsZChTdHJpbmcgYXNwZWN0TmFtZSwgQ2hhbmdlU3VwcG9ydCBjaGlsZCkgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMuYXNwZWN0TmFtZSA9IGFzcGVjdE5hbWU7Ci0JCQl0aGlzLmNoaWxkID0gY2hpbGQ7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuYXNwZWN0TmFtZSk7Ci0JCX0KLQotCX0KLQotCi0JLyoqCi0JICogVGhlIGFzcGVjdC1zcGVjaWZpYyBjaGFuZ2Ugc3VwcG9ydCBjbGFzcyBkb2VzIG5vdCBuZWVkIHRvCi0JICogYnVpbGQgImdyYW5kY2hpbGRyZW4iIGNoYW5nZSBzdXBwb3J0IG9iamVjdHMuCi0JICovCi0JcHJvdGVjdGVkIHN0YXRpYyBjbGFzcyBDaGlsZCBleHRlbmRzIENoYW5nZVN1cHBvcnQgewotCQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCQlwdWJsaWMgQ2hpbGQoTW9kZWwgc291cmNlKSB7Ci0JCQlzdXBlcihzb3VyY2UpOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCBDaGFuZ2VTdXBwb3J0IGJ1aWxkQ2hpbGRDaGFuZ2VTdXBwb3J0KCkgewotCQkJLy8gdGhlcmUgc2hvdWxkIGJlIG5vIGdyYW5kY2hpbGRyZW4KLQkJCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCQl9Ci0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC9TaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0LmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvU2luZ2xlQXNwZWN0Q2hhbmdlU3VwcG9ydC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxYjQyOTUwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC9TaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzMzkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbDsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLk1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LkNvbGxlY3Rpb25DaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5MaXN0Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5TdGF0ZUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlRyZWVDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5DaGFuZ2VMaXN0ZW5lcjsKLQotLyoqCi0gKiBUaGlzIGNoYW5nZSBzdXBwb3J0IGNsYXNzIGNoYW5nZXMgdGhlIGJlaGF2aW9yIG9mIHRoZSBzdGFuZGFyZAotICogQ2hhbmdlU3VwcG9ydCBpbiBzZXZlcmFsIHdheXM6Ci0gKiAJLSBBbGwgZXZlbnRzIGZpcmVkIGJ5IHRoZSBzb3VyY2UgbXVzdCBzcGVjaWZ5IHRoZSBzaW5nbGUgYXNwZWN0LgotICogCS0gTGlzdGVuZXJzIGFyZSByZXF1aXJlZCB0byBiZSBlaXRoZXIgImdlbmVyaWMiIGxpc3RlbmVycyBvcgotICogCSAgICBsaXN0ZW5lcnMgb2YgdGhlIHNpbmdsZSBhc3BlY3QuCi0gKi8KLXB1YmxpYyBjbGFzcyBTaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0Ci0JZXh0ZW5kcyBDaGFuZ2VTdXBwb3J0Ci17Ci0JcHJvdGVjdGVkIGZpbmFsIENsYXNzPD8gZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gbGlzdGVuZXJDbGFzczsKLQlwcm90ZWN0ZWQgZmluYWwgU3RyaW5nIGFzcGVjdE5hbWU7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvciAqKioqKioqKioqCi0KLQlwdWJsaWMgU2luZ2xlQXNwZWN0Q2hhbmdlU3VwcG9ydChNb2RlbCBzb3VyY2UsIENsYXNzPD8gZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gbGlzdGVuZXJDbGFzcywgU3RyaW5nIGFzcGVjdE5hbWUpIHsKLQkJc3VwZXIoc291cmNlKTsKLQkJdGhpcy5saXN0ZW5lckNsYXNzID0gbGlzdGVuZXJDbGFzczsKLQkJdGhpcy5hc3BlY3ROYW1lID0gYXNwZWN0TmFtZTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW50ZXJuYWwgYmVoYXZpb3IgKioqKioqKioqKgotCi0JcHJpdmF0ZSBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiB1bnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpIHsKLQkJcmV0dXJuIG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigKLQkJCQkiVGhpcyBNb2RlbCBzdXBwb3J0cyBvbmx5IGNoYW5nZXMgZm9yIHRoZSBsaXN0ZW5lciB0eXBlIFwiIiArIHRoaXMubGlzdGVuZXJDbGFzcy5nZXROYW1lKCkgLy8kTk9OLU5MUy0xJAotCQkJCSsgIlwiIGFuZCB0aGUgYXNwZWN0IFwiIiArIHRoaXMuYXNwZWN0TmFtZSArICciJyAvLyROT04tTkxTLTEkCi0JCQkpOwotCX0KLQotCXByaXZhdGUgdm9pZCBjaGVjayhDbGFzczw/IGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXI+IGxDbGFzcywgU3RyaW5nIGFOYW1lKSB7Ci0JCWlmIChsQ2xhc3MgIT0gdGhpcy5saXN0ZW5lckNsYXNzKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKAotCQkJCQkiVGhpcyBNb2RlbCBzdXBwb3J0cyBvbmx5IGNoYW5nZXMgZm9yIHRoZSBsaXN0ZW5lciB0eXBlIFwiIiArIHRoaXMubGlzdGVuZXJDbGFzcy5nZXROYW1lKCkgLy8kTk9OLU5MUy0xJAotCQkJCQkrICJcIiA6IFwiIiArIGxDbGFzcy5nZXROYW1lKCkgKyAnIicgLy8kTk9OLU5MUy0xJAotCQkJCSk7Ci0JCX0KLQkJaWYgKGFOYW1lICE9IHRoaXMuYXNwZWN0TmFtZSkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigKLQkJCQkJIlRoaXMgTW9kZWwgc3VwcG9ydHMgb25seSBjaGFuZ2VzIGZvciB0aGUgYXNwZWN0IFwiIiArIHRoaXMuYXNwZWN0TmFtZSAvLyROT04tTkxTLTEkCi0JCQkJCSsgIlwiIDogXCIiICsgYU5hbWUgKyAnIicgLy8kTk9OLU5MUy0xJAotCQkJCSk7Ci0JCX0KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgPFQgZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gdm9pZCBhZGRMaXN0ZW5lcihTdHJpbmcgYU5hbWUsIENsYXNzPFQ+IGxDbGFzcywgVCBsaXN0ZW5lcikgewotCQl0aGlzLmNoZWNrKGxDbGFzcywgYU5hbWUpOwotCQlzdXBlci5hZGRMaXN0ZW5lcihhTmFtZSwgbENsYXNzLCBsaXN0ZW5lcik7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIDxUIGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXI+IHZvaWQgcmVtb3ZlTGlzdGVuZXIoU3RyaW5nIGFOYW1lLCBDbGFzczxUPiBsQ2xhc3MsIFQgbGlzdGVuZXIpIHsKLQkJdGhpcy5jaGVjayhsQ2xhc3MsIGFOYW1lKTsKLQkJc3VwZXIucmVtb3ZlTGlzdGVuZXIoYU5hbWUsIGxDbGFzcywgbGlzdGVuZXIpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbnRlcm5hbCBxdWVyaWVzICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBib29sZWFuIGhhc0FueUxpc3RlbmVycyhDbGFzczw/IGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXI+IGxDbGFzcywgU3RyaW5nIGFOYW1lKSB7Ci0JCXRoaXMuY2hlY2sobENsYXNzLCBhTmFtZSk7Ci0JCXJldHVybiBzdXBlci5oYXNBbnlMaXN0ZW5lcnMobENsYXNzLCBhTmFtZSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHN0YXRlIGNoYW5nZSBzdXBwb3J0ICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGZpcmVTdGF0ZUNoYW5nZWQoU3RhdGVDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aHJvdyB0aGlzLnVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgZmlyZVN0YXRlQ2hhbmdlZCgpIHsKLQkJdGhyb3cgdGhpcy51bnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBwcm9wZXJ0eSBjaGFuZ2Ugc3VwcG9ydCAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlUHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5jaGVjayhQUk9QRVJUWV9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGV2ZW50LmdldFByb3BlcnR5TmFtZSgpKTsKLQkJc3VwZXIuZmlyZVByb3BlcnR5Q2hhbmdlZChldmVudCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgZmlyZVByb3BlcnR5Q2hhbmdlZChTdHJpbmcgcHJvcGVydHlOYW1lLCBPYmplY3Qgb2xkVmFsdWUsIE9iamVjdCBuZXdWYWx1ZSkgewotCQl0aGlzLmNoZWNrKFBST1BFUlRZX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgcHJvcGVydHlOYW1lKTsKLQkJc3VwZXIuZmlyZVByb3BlcnR5Q2hhbmdlZChwcm9wZXJ0eU5hbWUsIG9sZFZhbHVlLCBuZXdWYWx1ZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgZmlyZVByb3BlcnR5Q2hhbmdlZChTdHJpbmcgcHJvcGVydHlOYW1lLCBpbnQgb2xkVmFsdWUsIGludCBuZXdWYWx1ZSkgewotCQl0aGlzLmNoZWNrKFBST1BFUlRZX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgcHJvcGVydHlOYW1lKTsKLQkJc3VwZXIuZmlyZVByb3BlcnR5Q2hhbmdlZChwcm9wZXJ0eU5hbWUsIG9sZFZhbHVlLCBuZXdWYWx1ZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgZmlyZVByb3BlcnR5Q2hhbmdlZChTdHJpbmcgcHJvcGVydHlOYW1lLCBib29sZWFuIG9sZFZhbHVlLCBib29sZWFuIG5ld1ZhbHVlKSB7Ci0JCXRoaXMuY2hlY2soUFJPUEVSVFlfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBwcm9wZXJ0eU5hbWUpOwotCQlzdXBlci5maXJlUHJvcGVydHlDaGFuZ2VkKHByb3BlcnR5TmFtZSwgb2xkVmFsdWUsIG5ld1ZhbHVlKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY29sbGVjdGlvbiBjaGFuZ2Ugc3VwcG9ydCAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlSXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5jaGVjayhDT0xMRUNUSU9OX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgZXZlbnQuZ2V0Q29sbGVjdGlvbk5hbWUoKSk7Ci0JCXN1cGVyLmZpcmVJdGVtc0FkZGVkKGV2ZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlSXRlbXNBZGRlZChTdHJpbmcgY29sbGVjdGlvbk5hbWUsIENvbGxlY3Rpb248Pz4gYWRkZWRJdGVtcykgewotCQl0aGlzLmNoZWNrKENPTExFQ1RJT05fQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBjb2xsZWN0aW9uTmFtZSk7Ci0JCXN1cGVyLmZpcmVJdGVtc0FkZGVkKGNvbGxlY3Rpb25OYW1lLCBhZGRlZEl0ZW1zKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlSXRlbUFkZGVkKFN0cmluZyBjb2xsZWN0aW9uTmFtZSwgT2JqZWN0IGFkZGVkSXRlbSkgewotCQl0aGlzLmNoZWNrKENPTExFQ1RJT05fQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBjb2xsZWN0aW9uTmFtZSk7Ci0JCXN1cGVyLmZpcmVJdGVtQWRkZWQoY29sbGVjdGlvbk5hbWUsIGFkZGVkSXRlbSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgZmlyZUl0ZW1zUmVtb3ZlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5jaGVjayhDT0xMRUNUSU9OX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgZXZlbnQuZ2V0Q29sbGVjdGlvbk5hbWUoKSk7Ci0JCXN1cGVyLmZpcmVJdGVtc1JlbW92ZWQoZXZlbnQpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGZpcmVJdGVtc1JlbW92ZWQoU3RyaW5nIGNvbGxlY3Rpb25OYW1lLCBDb2xsZWN0aW9uPD8+IHJlbW92ZWRJdGVtcykgewotCQl0aGlzLmNoZWNrKENPTExFQ1RJT05fQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBjb2xsZWN0aW9uTmFtZSk7Ci0JCXN1cGVyLmZpcmVJdGVtc1JlbW92ZWQoY29sbGVjdGlvbk5hbWUsIHJlbW92ZWRJdGVtcyk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgZmlyZUl0ZW1SZW1vdmVkKFN0cmluZyBjb2xsZWN0aW9uTmFtZSwgT2JqZWN0IHJlbW92ZWRJdGVtKSB7Ci0JCXRoaXMuY2hlY2soQ09MTEVDVElPTl9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGNvbGxlY3Rpb25OYW1lKTsKLQkJc3VwZXIuZmlyZUl0ZW1SZW1vdmVkKGNvbGxlY3Rpb25OYW1lLCByZW1vdmVkSXRlbSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgZmlyZUNvbGxlY3Rpb25DbGVhcmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmNoZWNrKENPTExFQ1RJT05fQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBldmVudC5nZXRDb2xsZWN0aW9uTmFtZSgpKTsKLQkJc3VwZXIuZmlyZUNvbGxlY3Rpb25DbGVhcmVkKGV2ZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlQ29sbGVjdGlvbkNsZWFyZWQoU3RyaW5nIGNvbGxlY3Rpb25OYW1lKSB7Ci0JCXRoaXMuY2hlY2soQ09MTEVDVElPTl9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGNvbGxlY3Rpb25OYW1lKTsKLQkJc3VwZXIuZmlyZUNvbGxlY3Rpb25DbGVhcmVkKGNvbGxlY3Rpb25OYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlQ29sbGVjdGlvbkNoYW5nZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuY2hlY2soQ09MTEVDVElPTl9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGV2ZW50LmdldENvbGxlY3Rpb25OYW1lKCkpOwotCQlzdXBlci5maXJlQ29sbGVjdGlvbkNoYW5nZWQoZXZlbnQpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGZpcmVDb2xsZWN0aW9uQ2hhbmdlZChTdHJpbmcgY29sbGVjdGlvbk5hbWUpIHsKLQkJdGhpcy5jaGVjayhDT0xMRUNUSU9OX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgY29sbGVjdGlvbk5hbWUpOwotCQlzdXBlci5maXJlQ29sbGVjdGlvbkNoYW5nZWQoY29sbGVjdGlvbk5hbWUpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBsaXN0IGNoYW5nZSBzdXBwb3J0ICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGZpcmVJdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmNoZWNrKExJU1RfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBldmVudC5nZXRMaXN0TmFtZSgpKTsKLQkJc3VwZXIuZmlyZUl0ZW1zQWRkZWQoZXZlbnQpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGZpcmVJdGVtc0FkZGVkKFN0cmluZyBsaXN0TmFtZSwgaW50IGluZGV4LCBMaXN0PD8+IGFkZGVkSXRlbXMpIHsKLQkJdGhpcy5jaGVjayhMSVNUX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgbGlzdE5hbWUpOwotCQlzdXBlci5maXJlSXRlbXNBZGRlZChsaXN0TmFtZSwgaW5kZXgsIGFkZGVkSXRlbXMpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGZpcmVJdGVtQWRkZWQoU3RyaW5nIGxpc3ROYW1lLCBpbnQgaW5kZXgsIE9iamVjdCBhZGRlZEl0ZW0pIHsKLQkJdGhpcy5jaGVjayhMSVNUX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgbGlzdE5hbWUpOwotCQlzdXBlci5maXJlSXRlbUFkZGVkKGxpc3ROYW1lLCBpbmRleCwgYWRkZWRJdGVtKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlSXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmNoZWNrKExJU1RfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBldmVudC5nZXRMaXN0TmFtZSgpKTsKLQkJc3VwZXIuZmlyZUl0ZW1zUmVtb3ZlZChldmVudCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgZmlyZUl0ZW1zUmVtb3ZlZChTdHJpbmcgbGlzdE5hbWUsIGludCBpbmRleCwgTGlzdDw/PiByZW1vdmVkSXRlbXMpIHsKLQkJdGhpcy5jaGVjayhMSVNUX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgbGlzdE5hbWUpOwotCQlzdXBlci5maXJlSXRlbXNSZW1vdmVkKGxpc3ROYW1lLCBpbmRleCwgcmVtb3ZlZEl0ZW1zKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlSXRlbVJlbW92ZWQoU3RyaW5nIGxpc3ROYW1lLCBpbnQgaW5kZXgsIE9iamVjdCByZW1vdmVkSXRlbSkgewotCQl0aGlzLmNoZWNrKExJU1RfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBsaXN0TmFtZSk7Ci0JCXN1cGVyLmZpcmVJdGVtUmVtb3ZlZChsaXN0TmFtZSwgaW5kZXgsIHJlbW92ZWRJdGVtKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlSXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5jaGVjayhMSVNUX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgZXZlbnQuZ2V0TGlzdE5hbWUoKSk7Ci0JCXN1cGVyLmZpcmVJdGVtc1JlcGxhY2VkKGV2ZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlSXRlbXNSZXBsYWNlZChTdHJpbmcgbGlzdE5hbWUsIGludCBpbmRleCwgTGlzdDw/PiBuZXdJdGVtcywgTGlzdDw/PiByZXBsYWNlZEl0ZW1zKSB7Ci0JCXRoaXMuY2hlY2soTElTVF9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGxpc3ROYW1lKTsKLQkJc3VwZXIuZmlyZUl0ZW1zUmVwbGFjZWQobGlzdE5hbWUsIGluZGV4LCBuZXdJdGVtcywgcmVwbGFjZWRJdGVtcyk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgZmlyZUl0ZW1SZXBsYWNlZChTdHJpbmcgbGlzdE5hbWUsIGludCBpbmRleCwgT2JqZWN0IG5ld0l0ZW0sIE9iamVjdCByZXBsYWNlZEl0ZW0pIHsKLQkJdGhpcy5jaGVjayhMSVNUX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgbGlzdE5hbWUpOwotCQlzdXBlci5maXJlSXRlbVJlcGxhY2VkKGxpc3ROYW1lLCBpbmRleCwgbmV3SXRlbSwgcmVwbGFjZWRJdGVtKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlSXRlbXNNb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5jaGVjayhMSVNUX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgZXZlbnQuZ2V0TGlzdE5hbWUoKSk7Ci0JCXN1cGVyLmZpcmVJdGVtc01vdmVkKGV2ZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlSXRlbXNNb3ZlZChTdHJpbmcgbGlzdE5hbWUsIGludCB0YXJnZXRJbmRleCwgaW50IHNvdXJjZUluZGV4LCBpbnQgbGVuZ3RoKSB7Ci0JCXRoaXMuY2hlY2soTElTVF9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGxpc3ROYW1lKTsKLQkJc3VwZXIuZmlyZUl0ZW1zTW92ZWQobGlzdE5hbWUsIHRhcmdldEluZGV4LCBzb3VyY2VJbmRleCwgbGVuZ3RoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlTGlzdENsZWFyZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuY2hlY2soTElTVF9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGV2ZW50LmdldExpc3ROYW1lKCkpOwotCQlzdXBlci5maXJlTGlzdENsZWFyZWQoZXZlbnQpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGZpcmVMaXN0Q2xlYXJlZChTdHJpbmcgbGlzdE5hbWUpIHsKLQkJdGhpcy5jaGVjayhMSVNUX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgbGlzdE5hbWUpOwotCQlzdXBlci5maXJlTGlzdENsZWFyZWQobGlzdE5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGZpcmVMaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5jaGVjayhMSVNUX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgZXZlbnQuZ2V0TGlzdE5hbWUoKSk7Ci0JCXN1cGVyLmZpcmVMaXN0Q2hhbmdlZChldmVudCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgZmlyZUxpc3RDaGFuZ2VkKFN0cmluZyBsaXN0TmFtZSkgewotCQl0aGlzLmNoZWNrKExJU1RfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBsaXN0TmFtZSk7Ci0JCXN1cGVyLmZpcmVMaXN0Q2hhbmdlZChsaXN0TmFtZSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHRyZWUgY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgZmlyZU5vZGVBZGRlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5jaGVjayhUUkVFX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgZXZlbnQuZ2V0VHJlZU5hbWUoKSk7Ci0JCXN1cGVyLmZpcmVOb2RlQWRkZWQoZXZlbnQpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGZpcmVOb2RlQWRkZWQoU3RyaW5nIHRyZWVOYW1lLCBPYmplY3RbXSBwYXRoKSB7Ci0JCXRoaXMuY2hlY2soVFJFRV9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIHRyZWVOYW1lKTsKLQkJc3VwZXIuZmlyZU5vZGVBZGRlZCh0cmVlTmFtZSwgcGF0aCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgZmlyZU5vZGVSZW1vdmVkKFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmNoZWNrKFRSRUVfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBldmVudC5nZXRUcmVlTmFtZSgpKTsKLQkJc3VwZXIuZmlyZU5vZGVSZW1vdmVkKGV2ZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlTm9kZVJlbW92ZWQoU3RyaW5nIHRyZWVOYW1lLCBPYmplY3RbXSBwYXRoKSB7Ci0JCXRoaXMuY2hlY2soVFJFRV9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIHRyZWVOYW1lKTsKLQkJc3VwZXIuZmlyZU5vZGVSZW1vdmVkKHRyZWVOYW1lLCBwYXRoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBmaXJlVHJlZUNsZWFyZWQoVHJlZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuY2hlY2soVFJFRV9DSEFOR0VfTElTVEVORVJfQ0xBU1MsIGV2ZW50LmdldFRyZWVOYW1lKCkpOwotCQlzdXBlci5maXJlVHJlZUNsZWFyZWQoZXZlbnQpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGZpcmVUcmVlQ2xlYXJlZChTdHJpbmcgdHJlZU5hbWUsIE9iamVjdFtdIHBhdGgpIHsKLQkJdGhpcy5jaGVjayhUUkVFX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgdHJlZU5hbWUpOwotCQlzdXBlci5maXJlVHJlZUNsZWFyZWQodHJlZU5hbWUsIHBhdGgpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGZpcmVUcmVlQ2hhbmdlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5jaGVjayhUUkVFX0NIQU5HRV9MSVNURU5FUl9DTEFTUywgZXZlbnQuZ2V0VHJlZU5hbWUoKSk7Ci0JCXN1cGVyLmZpcmVUcmVlQ2hhbmdlZChldmVudCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgZmlyZVRyZWVDaGFuZ2VkKFN0cmluZyB0cmVlTmFtZSwgT2JqZWN0W10gcGF0aCkgewotCQl0aGlzLmNoZWNrKFRSRUVfQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCB0cmVlTmFtZSk7Ci0JCXN1cGVyLmZpcmVUcmVlQ2hhbmdlZCh0cmVlTmFtZSwgcGF0aCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvbGlzdGVuZXIvYXd0L0FXVENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcldyYXBwZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC9saXN0ZW5lci9hd3QvQVdUQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyV3JhcHBlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0Y2FiNDA1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC9saXN0ZW5lci9hd3QvQVdUQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyV3JhcHBlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTUwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwubGlzdGVuZXIuYXd0OwotCi1pbXBvcnQgamF2YS5hd3QuRXZlbnRRdWV1ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Db2xsZWN0aW9uQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyOwotCi0vKioKLSAqIFdyYXAgYW5vdGhlciBjb2xsZWN0aW9uIGNoYW5nZSBsaXN0ZW5lciBhbmQgZm9yd2FyZCBldmVudHMgdG8gaXQgb24gdGhlIEFXVAotICogZXZlbnQgcXVldWUuCi0gKi8KLXB1YmxpYyBjbGFzcyBBV1RDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJXcmFwcGVyCi0JaW1wbGVtZW50cyBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIKLXsKLQlwcml2YXRlIGZpbmFsIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcjsKLQotCXB1YmxpYyBBV1RDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJXcmFwcGVyKENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlzdXBlcigpOwotCQlpZiAobGlzdGVuZXIgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy5saXN0ZW5lciA9IGxpc3RlbmVyOwotCX0KLQotCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCWlmIChFdmVudFF1ZXVlLmlzRGlzcGF0Y2hUaHJlYWQoKSkgewotCQkJdGhpcy5pdGVtc0FkZGVkXyhldmVudCk7Ci0JCX0gZWxzZSB7Ci0JCQl0aGlzLmV4ZWN1dGVPbkV2ZW50UXVldWUodGhpcy5idWlsZEl0ZW1zQWRkZWRSdW5uYWJsZShldmVudCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQlpZiAoRXZlbnRRdWV1ZS5pc0Rpc3BhdGNoVGhyZWFkKCkpIHsKLQkJCXRoaXMuaXRlbXNSZW1vdmVkXyhldmVudCk7Ci0JCX0gZWxzZSB7Ci0JCQl0aGlzLmV4ZWN1dGVPbkV2ZW50UXVldWUodGhpcy5idWlsZEl0ZW1zUmVtb3ZlZFJ1bm5hYmxlKGV2ZW50KSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCBjb2xsZWN0aW9uQ2xlYXJlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaWYgKEV2ZW50UXVldWUuaXNEaXNwYXRjaFRocmVhZCgpKSB7Ci0JCQl0aGlzLmNvbGxlY3Rpb25DbGVhcmVkXyhldmVudCk7Ci0JCX0gZWxzZSB7Ci0JCQl0aGlzLmV4ZWN1dGVPbkV2ZW50UXVldWUodGhpcy5idWlsZENvbGxlY3Rpb25DbGVhcmVkUnVubmFibGUoZXZlbnQpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIGNvbGxlY3Rpb25DaGFuZ2VkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQlpZiAoRXZlbnRRdWV1ZS5pc0Rpc3BhdGNoVGhyZWFkKCkpIHsKLQkJCXRoaXMuY29sbGVjdGlvbkNoYW5nZWRfKGV2ZW50KTsKLQkJfSBlbHNlIHsKLQkJCXRoaXMuZXhlY3V0ZU9uRXZlbnRRdWV1ZSh0aGlzLmJ1aWxkQ29sbGVjdGlvbkNoYW5nZWRSdW5uYWJsZShldmVudCkpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBSdW5uYWJsZSBidWlsZEl0ZW1zQWRkZWRSdW5uYWJsZShmaW5hbCBDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIG5ldyBSdW5uYWJsZSgpIHsKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlBV1RDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJXcmFwcGVyLnRoaXMuaXRlbXNBZGRlZF8oZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiaXRlbXMgYWRkZWQiOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUnVubmFibGUgYnVpbGRJdGVtc1JlbW92ZWRSdW5uYWJsZShmaW5hbCBDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIG5ldyBSdW5uYWJsZSgpIHsKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlBV1RDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJXcmFwcGVyLnRoaXMuaXRlbXNSZW1vdmVkXyhldmVudCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJpdGVtcyByZW1vdmVkIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFJ1bm5hYmxlIGJ1aWxkQ29sbGVjdGlvbkNsZWFyZWRSdW5uYWJsZShmaW5hbCBDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIG5ldyBSdW5uYWJsZSgpIHsKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlBV1RDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJXcmFwcGVyLnRoaXMuY29sbGVjdGlvbkNsZWFyZWRfKGV2ZW50KTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gImNvbGxlY3Rpb24gY2xlYXJlZCI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBSdW5uYWJsZSBidWlsZENvbGxlY3Rpb25DaGFuZ2VkUnVubmFibGUoZmluYWwgQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXJldHVybiBuZXcgUnVubmFibGUoKSB7Ci0JCQlwdWJsaWMgdm9pZCBydW4oKSB7Ci0JCQkJQVdUQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyV3JhcHBlci50aGlzLmNvbGxlY3Rpb25DaGFuZ2VkXyhldmVudCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJjb2xsZWN0aW9uIGNoYW5nZWQiOwotCQkJfQotCQl9OwotCX0KLQotCS8qKgotCSAqIEV2ZW50UXVldWUjaW52b2tlTGF0ZXIoUnVubmFibGUpIHNlZW1zIHRvIHdvcmsgT0s7Ci0JICogYnV0IHVzaW5nICNpbnZva2VBbmRXYWl0KFJ1bm5hYmxlKSBjYW4gc29tZXRpbWVzIG1ha2UgdGhpbmdzCi0JICogbW9yZSBwcmVkaWN0YWJsZSB3aGVuIGRlYnVnZ2luZywgYXQgdGhlIHJpc2sgb2YgZGVhZGxvY2tzLgotCSAqLwotCXByaXZhdGUgdm9pZCBleGVjdXRlT25FdmVudFF1ZXVlKFJ1bm5hYmxlIHIpIHsKLQkJRXZlbnRRdWV1ZS5pbnZva2VMYXRlcihyKTsKLS8vCQl0cnkgewotLy8JCQlFdmVudFF1ZXVlLmludm9rZUFuZFdhaXQocik7Ci0vLwkJfSBjYXRjaCAoSW50ZXJydXB0ZWRFeGNlcHRpb24gZXgpIHsKLS8vCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oZXgpOwotLy8JCX0gY2F0Y2ggKGphdmEubGFuZy5yZWZsZWN0Lkludm9jYXRpb25UYXJnZXRFeGNlcHRpb24gZXgpIHsKLS8vCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oZXgpOwotLy8JCX0KLQl9Ci0KLQl2b2lkIGl0ZW1zQWRkZWRfKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmxpc3RlbmVyLml0ZW1zQWRkZWQoZXZlbnQpOwotCX0KLQotCXZvaWQgaXRlbXNSZW1vdmVkXyhDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5saXN0ZW5lci5pdGVtc1JlbW92ZWQoZXZlbnQpOwotCX0KLQotCXZvaWQgY29sbGVjdGlvbkNsZWFyZWRfKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmxpc3RlbmVyLmNvbGxlY3Rpb25DbGVhcmVkKGV2ZW50KTsKLQl9Ci0KLQl2b2lkIGNvbGxlY3Rpb25DaGFuZ2VkXyhDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5saXN0ZW5lci5jb2xsZWN0aW9uQ2hhbmdlZChldmVudCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuICJBV1QoIiArIHRoaXMubGlzdGVuZXIudG9TdHJpbmcoKSArICIpIjsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC9saXN0ZW5lci9hd3QvQVdUTGlzdENoYW5nZUxpc3RlbmVyV3JhcHBlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL2xpc3RlbmVyL2F3dC9BV1RMaXN0Q2hhbmdlTGlzdGVuZXJXcmFwcGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDdiZWQwODkuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL2xpc3RlbmVyL2F3dC9BV1RMaXN0Q2hhbmdlTGlzdGVuZXJXcmFwcGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxOTggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5saXN0ZW5lci5hd3Q7Ci0KLWltcG9ydCBqYXZhLmF3dC5FdmVudFF1ZXVlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50Lkxpc3RDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5MaXN0Q2hhbmdlTGlzdGVuZXI7Ci0KLS8qKgotICogV3JhcCBhbm90aGVyIGxpc3QgY2hhbmdlIGxpc3RlbmVyIGFuZCBmb3J3YXJkIGV2ZW50cyB0byBpdCBvbiB0aGUgQVdUCi0gKiBldmVudCBxdWV1ZS4KLSAqLwotcHVibGljIGNsYXNzIEFXVExpc3RDaGFuZ2VMaXN0ZW5lcldyYXBwZXIKLQlpbXBsZW1lbnRzIExpc3RDaGFuZ2VMaXN0ZW5lcgotewotCXByaXZhdGUgZmluYWwgTGlzdENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyOwotCi0JcHVibGljIEFXVExpc3RDaGFuZ2VMaXN0ZW5lcldyYXBwZXIoTGlzdENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXN1cGVyKCk7Ci0JCWlmIChsaXN0ZW5lciA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLmxpc3RlbmVyID0gbGlzdGVuZXI7Ci0JfQotCi0JcHVibGljIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaWYgKEV2ZW50UXVldWUuaXNEaXNwYXRjaFRocmVhZCgpKSB7Ci0JCQl0aGlzLml0ZW1zQWRkZWRfKGV2ZW50KTsKLQkJfSBlbHNlIHsKLQkJCXRoaXMuZXhlY3V0ZU9uRXZlbnRRdWV1ZSh0aGlzLmJ1aWxkSXRlbXNBZGRlZFJ1bm5hYmxlKGV2ZW50KSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCBpdGVtc1JlbW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCWlmIChFdmVudFF1ZXVlLmlzRGlzcGF0Y2hUaHJlYWQoKSkgewotCQkJdGhpcy5pdGVtc1JlbW92ZWRfKGV2ZW50KTsKLQkJfSBlbHNlIHsKLQkJCXRoaXMuZXhlY3V0ZU9uRXZlbnRRdWV1ZSh0aGlzLmJ1aWxkSXRlbXNSZW1vdmVkUnVubmFibGUoZXZlbnQpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIGl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCWlmIChFdmVudFF1ZXVlLmlzRGlzcGF0Y2hUaHJlYWQoKSkgewotCQkJdGhpcy5pdGVtc01vdmVkXyhldmVudCk7Ci0JCX0gZWxzZSB7Ci0JCQl0aGlzLmV4ZWN1dGVPbkV2ZW50UXVldWUodGhpcy5idWlsZEl0ZW1zTW92ZWRSdW5uYWJsZShldmVudCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgaXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaWYgKEV2ZW50UXVldWUuaXNEaXNwYXRjaFRocmVhZCgpKSB7Ci0JCQl0aGlzLml0ZW1zUmVwbGFjZWRfKGV2ZW50KTsKLQkJfSBlbHNlIHsKLQkJCXRoaXMuZXhlY3V0ZU9uRXZlbnRRdWV1ZSh0aGlzLmJ1aWxkSXRlbXNSZXBsYWNlZFJ1bm5hYmxlKGV2ZW50KSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaWYgKEV2ZW50UXVldWUuaXNEaXNwYXRjaFRocmVhZCgpKSB7Ci0JCQl0aGlzLmxpc3RDbGVhcmVkXyhldmVudCk7Ci0JCX0gZWxzZSB7Ci0JCQl0aGlzLmV4ZWN1dGVPbkV2ZW50UXVldWUodGhpcy5idWlsZExpc3RDbGVhcmVkUnVubmFibGUoZXZlbnQpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIGxpc3RDaGFuZ2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQlpZiAoRXZlbnRRdWV1ZS5pc0Rpc3BhdGNoVGhyZWFkKCkpIHsKLQkJCXRoaXMubGlzdENoYW5nZWRfKGV2ZW50KTsKLQkJfSBlbHNlIHsKLQkJCXRoaXMuZXhlY3V0ZU9uRXZlbnRRdWV1ZSh0aGlzLmJ1aWxkTGlzdENoYW5nZWRSdW5uYWJsZShldmVudCkpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBSdW5uYWJsZSBidWlsZEl0ZW1zQWRkZWRSdW5uYWJsZShmaW5hbCBMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIG5ldyBSdW5uYWJsZSgpIHsKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlBV1RMaXN0Q2hhbmdlTGlzdGVuZXJXcmFwcGVyLnRoaXMuaXRlbXNBZGRlZF8oZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiaXRlbXMgYWRkZWQiOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUnVubmFibGUgYnVpbGRJdGVtc1JlbW92ZWRSdW5uYWJsZShmaW5hbCBMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIG5ldyBSdW5uYWJsZSgpIHsKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlBV1RMaXN0Q2hhbmdlTGlzdGVuZXJXcmFwcGVyLnRoaXMuaXRlbXNSZW1vdmVkXyhldmVudCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJpdGVtcyByZW1vdmVkIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFJ1bm5hYmxlIGJ1aWxkSXRlbXNNb3ZlZFJ1bm5hYmxlKGZpbmFsIExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQlyZXR1cm4gbmV3IFJ1bm5hYmxlKCkgewotCQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJCUFXVExpc3RDaGFuZ2VMaXN0ZW5lcldyYXBwZXIudGhpcy5pdGVtc01vdmVkXyhldmVudCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJpdGVtcyBtb3ZlZCI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBSdW5uYWJsZSBidWlsZEl0ZW1zUmVwbGFjZWRSdW5uYWJsZShmaW5hbCBMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIG5ldyBSdW5uYWJsZSgpIHsKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlBV1RMaXN0Q2hhbmdlTGlzdGVuZXJXcmFwcGVyLnRoaXMuaXRlbXNSZXBsYWNlZF8oZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiaXRlbXMgcmVwbGFjZWQiOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUnVubmFibGUgYnVpbGRMaXN0Q2xlYXJlZFJ1bm5hYmxlKGZpbmFsIExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQlyZXR1cm4gbmV3IFJ1bm5hYmxlKCkgewotCQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJCUFXVExpc3RDaGFuZ2VMaXN0ZW5lcldyYXBwZXIudGhpcy5saXN0Q2xlYXJlZF8oZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAibGlzdCBjbGVhcmVkIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFJ1bm5hYmxlIGJ1aWxkTGlzdENoYW5nZWRSdW5uYWJsZShmaW5hbCBMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIG5ldyBSdW5uYWJsZSgpIHsKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlBV1RMaXN0Q2hhbmdlTGlzdGVuZXJXcmFwcGVyLnRoaXMubGlzdENoYW5nZWRfKGV2ZW50KTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gImxpc3QgY2hhbmdlZCI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JLyoqCi0JICogRXZlbnRRdWV1ZSNpbnZva2VMYXRlcihSdW5uYWJsZSkgc2VlbXMgdG8gd29yayBPSzsKLQkgKiBidXQgdXNpbmcgI2ludm9rZUFuZFdhaXQoUnVubmFibGUpIGNhbiBzb21ldGltZXMgbWFrZSB0aGluZ3MKLQkgKiBtb3JlIHByZWRpY3RhYmxlIHdoZW4gZGVidWdnaW5nLCBhdCB0aGUgcmlzayBvZiBkZWFkbG9ja3MuCi0JICovCi0JcHJpdmF0ZSB2b2lkIGV4ZWN1dGVPbkV2ZW50UXVldWUoUnVubmFibGUgcikgewotCQlFdmVudFF1ZXVlLmludm9rZUxhdGVyKHIpOwotLy8JCXRyeSB7Ci0vLwkJCUV2ZW50UXVldWUuaW52b2tlQW5kV2FpdChyKTsKLS8vCQl9IGNhdGNoIChJbnRlcnJ1cHRlZEV4Y2VwdGlvbiBleCkgewotLy8JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihleCk7Ci0vLwkJfSBjYXRjaCAoamF2YS5sYW5nLnJlZmxlY3QuSW52b2NhdGlvblRhcmdldEV4Y2VwdGlvbiBleCkgewotLy8JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihleCk7Ci0vLwkJfQotCX0KLQotCXZvaWQgaXRlbXNBZGRlZF8oTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMubGlzdGVuZXIuaXRlbXNBZGRlZChldmVudCk7Ci0JfQotCi0Jdm9pZCBpdGVtc1JlbW92ZWRfKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmxpc3RlbmVyLml0ZW1zUmVtb3ZlZChldmVudCk7Ci0JfQotCi0Jdm9pZCBpdGVtc01vdmVkXyhMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5saXN0ZW5lci5pdGVtc01vdmVkKGV2ZW50KTsKLQl9Ci0KLQl2b2lkIGl0ZW1zUmVwbGFjZWRfKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmxpc3RlbmVyLml0ZW1zUmVwbGFjZWQoZXZlbnQpOwotCX0KLQotCXZvaWQgbGlzdENsZWFyZWRfKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmxpc3RlbmVyLmxpc3RDbGVhcmVkKGV2ZW50KTsKLQl9Ci0KLQl2b2lkIGxpc3RDaGFuZ2VkXyhMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5saXN0ZW5lci5saXN0Q2hhbmdlZChldmVudCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuICJBV1QoIiArIHRoaXMubGlzdGVuZXIudG9TdHJpbmcoKSArICIpIjsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC9saXN0ZW5lci9hd3QvQVdUUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcldyYXBwZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC9saXN0ZW5lci9hd3QvQVdUUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcldyYXBwZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmNjMzcyYS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvbGlzdGVuZXIvYXd0L0FXVFByb3BlcnR5Q2hhbmdlTGlzdGVuZXJXcmFwcGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw3NSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLmxpc3RlbmVyLmF3dDsKLQotaW1wb3J0IGphdmEuYXd0LkV2ZW50UXVldWU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotCi0vKioKLSAqIFdyYXAgYW5vdGhlciBwcm9wZXJ0eSBjaGFuZ2UgbGlzdGVuZXIgYW5kIGZvcndhcmQgZXZlbnRzIHRvIGl0IG9uIHRoZSBBV1QKLSAqIGV2ZW50IHF1ZXVlLgotICovCi1wdWJsaWMgY2xhc3MgQVdUUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcldyYXBwZXIKLQlpbXBsZW1lbnRzIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIKLXsKLQlwcml2YXRlIGZpbmFsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXI7Ci0KLQotCXB1YmxpYyBBV1RQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyV3JhcHBlcihQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXN1cGVyKCk7Ci0JCWlmIChsaXN0ZW5lciA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLmxpc3RlbmVyID0gbGlzdGVuZXI7Ci0JfQotCi0JcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaWYgKEV2ZW50UXVldWUuaXNEaXNwYXRjaFRocmVhZCgpKSB7Ci0JCQl0aGlzLnByb3BlcnR5Q2hhbmdlZF8oZXZlbnQpOwotCQl9IGVsc2UgewotCQkJdGhpcy5leGVjdXRlT25FdmVudFF1ZXVlKHRoaXMuYnVpbGRSdW5uYWJsZShldmVudCkpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBSdW5uYWJsZSBidWlsZFJ1bm5hYmxlKGZpbmFsIFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIG5ldyBSdW5uYWJsZSgpIHsKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlBV1RQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyV3JhcHBlci50aGlzLnByb3BlcnR5Q2hhbmdlZF8oZXZlbnQpOwotCQkJfQotCQl9OwotCX0KLQotCS8qKgotCSAqIEV2ZW50UXVldWUjaW52b2tlTGF0ZXIoUnVubmFibGUpIHNlZW1zIHRvIHdvcmsgT0s7Ci0JICogYnV0IHVzaW5nICNpbnZva2VBbmRXYWl0KFJ1bm5hYmxlKSBjYW4gc29tZXRpbWVzIG1ha2UgdGhpbmdzCi0JICogbW9yZSBwcmVkaWN0YWJsZSB3aGVuIGRlYnVnZ2luZywgYXQgdGhlIHJpc2sgb2YgZGVhZGxvY2tzLgotCSAqLwotCXByaXZhdGUgdm9pZCBleGVjdXRlT25FdmVudFF1ZXVlKFJ1bm5hYmxlIHIpIHsKLQkJRXZlbnRRdWV1ZS5pbnZva2VMYXRlcihyKTsKLS8vCQl0cnkgewotLy8JCQlFdmVudFF1ZXVlLmludm9rZUFuZFdhaXQocik7Ci0vLwkJfSBjYXRjaCAoSW50ZXJydXB0ZWRFeGNlcHRpb24gZXgpIHsKLS8vCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oZXgpOwotLy8JCX0gY2F0Y2ggKGphdmEubGFuZy5yZWZsZWN0Lkludm9jYXRpb25UYXJnZXRFeGNlcHRpb24gZXgpIHsKLS8vCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oZXgpOwotLy8JCX0KLQl9Ci0KLQl2b2lkIHByb3BlcnR5Q2hhbmdlZF8oUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmxpc3RlbmVyLnByb3BlcnR5Q2hhbmdlZChldmVudCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuICJBV1QoIiArIHRoaXMubGlzdGVuZXIudG9TdHJpbmcoKSArICIpIjsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC9saXN0ZW5lci9hd3QvQVdUU3RhdGVDaGFuZ2VMaXN0ZW5lcldyYXBwZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC9saXN0ZW5lci9hd3QvQVdUU3RhdGVDaGFuZ2VMaXN0ZW5lcldyYXBwZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjVmMjk4OC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvbGlzdGVuZXIvYXd0L0FXVFN0YXRlQ2hhbmdlTGlzdGVuZXJXcmFwcGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw3NCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLmxpc3RlbmVyLmF3dDsKLQotaW1wb3J0IGphdmEuYXd0LkV2ZW50UXVldWU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuU3RhdGVDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5TdGF0ZUNoYW5nZUxpc3RlbmVyOwotCi0vKioKLSAqIFdyYXAgYW5vdGhlciBzdGF0ZSBjaGFuZ2UgbGlzdGVuZXIgYW5kIGZvcndhcmQgZXZlbnRzIHRvIGl0IG9uIHRoZSBBV1QKLSAqIGV2ZW50IHF1ZXVlLgotICovCi1wdWJsaWMgY2xhc3MgQVdUU3RhdGVDaGFuZ2VMaXN0ZW5lcldyYXBwZXIKLQlpbXBsZW1lbnRzIFN0YXRlQ2hhbmdlTGlzdGVuZXIKLXsKLQlwcml2YXRlIGZpbmFsIFN0YXRlQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXI7Ci0KLQlwdWJsaWMgQVdUU3RhdGVDaGFuZ2VMaXN0ZW5lcldyYXBwZXIoU3RhdGVDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlzdXBlcigpOwotCQlpZiAobGlzdGVuZXIgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy5saXN0ZW5lciA9IGxpc3RlbmVyOwotCX0KLQotCXB1YmxpYyB2b2lkIHN0YXRlQ2hhbmdlZChTdGF0ZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCWlmIChFdmVudFF1ZXVlLmlzRGlzcGF0Y2hUaHJlYWQoKSkgewotCQkJdGhpcy5zdGF0ZUNoYW5nZWRfKGV2ZW50KTsKLQkJfSBlbHNlIHsKLQkJCXRoaXMuZXhlY3V0ZU9uRXZlbnRRdWV1ZSh0aGlzLmJ1aWxkUnVubmFibGUoZXZlbnQpKTsKLQkJfQotCX0KLQotCXByaXZhdGUgUnVubmFibGUgYnVpbGRSdW5uYWJsZShmaW5hbCBTdGF0ZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXJldHVybiBuZXcgUnVubmFibGUoKSB7Ci0JCQlwdWJsaWMgdm9pZCBydW4oKSB7Ci0JCQkJQVdUU3RhdGVDaGFuZ2VMaXN0ZW5lcldyYXBwZXIudGhpcy5zdGF0ZUNoYW5nZWRfKGV2ZW50KTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQkvKioKLQkgKiBFdmVudFF1ZXVlI2ludm9rZUxhdGVyKFJ1bm5hYmxlKSBzZWVtcyB0byB3b3JrIE9LOwotCSAqIGJ1dCB1c2luZyAjaW52b2tlQW5kV2FpdChSdW5uYWJsZSkgY2FuIHNvbWV0aW1lcyBtYWtlIHRoaW5ncwotCSAqIG1vcmUgcHJlZGljdGFibGUgd2hlbiBkZWJ1Z2dpbmcsIGF0IHRoZSByaXNrIG9mIGRlYWRsb2Nrcy4KLQkgKi8KLQlwcml2YXRlIHZvaWQgZXhlY3V0ZU9uRXZlbnRRdWV1ZShSdW5uYWJsZSByKSB7Ci0JCUV2ZW50UXVldWUuaW52b2tlTGF0ZXIocik7Ci0vLwkJdHJ5IHsKLS8vCQkJRXZlbnRRdWV1ZS5pbnZva2VBbmRXYWl0KHIpOwotLy8JCX0gY2F0Y2ggKEludGVycnVwdGVkRXhjZXB0aW9uIGV4KSB7Ci0vLwkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGV4KTsKLS8vCQl9IGNhdGNoIChqYXZhLmxhbmcucmVmbGVjdC5JbnZvY2F0aW9uVGFyZ2V0RXhjZXB0aW9uIGV4KSB7Ci0vLwkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGV4KTsKLS8vCQl9Ci0JfQotCi0Jdm9pZCBzdGF0ZUNoYW5nZWRfKFN0YXRlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5saXN0ZW5lci5zdGF0ZUNoYW5nZWQoZXZlbnQpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiAiQVdUKCIgKyB0aGlzLmxpc3RlbmVyLnRvU3RyaW5nKCkgKyAiKSI7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvbGlzdGVuZXIvYXd0L0FXVFRyZWVDaGFuZ2VMaXN0ZW5lcldyYXBwZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC9saXN0ZW5lci9hd3QvQVdUVHJlZUNoYW5nZUxpc3RlbmVyV3JhcHBlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiZTdjZmIxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC9saXN0ZW5lci9hd3QvQVdUVHJlZUNoYW5nZUxpc3RlbmVyV3JhcHBlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTUwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwubGlzdGVuZXIuYXd0OwotCi1pbXBvcnQgamF2YS5hd3QuRXZlbnRRdWV1ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5UcmVlQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuVHJlZUNoYW5nZUxpc3RlbmVyOwotCi0vKioKLSAqIFdyYXAgYW5vdGhlciB0cmVlIGNoYW5nZSBsaXN0ZW5lciBhbmQgZm9yd2FyZCBldmVudHMgdG8gaXQgb24gdGhlIEFXVAotICogZXZlbnQgcXVldWUuCi0gKi8KLXB1YmxpYyBjbGFzcyBBV1RUcmVlQ2hhbmdlTGlzdGVuZXJXcmFwcGVyCi0JaW1wbGVtZW50cyBUcmVlQ2hhbmdlTGlzdGVuZXIKLXsKLQlwcml2YXRlIGZpbmFsIFRyZWVDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcjsKLQotCXB1YmxpYyBBV1RUcmVlQ2hhbmdlTGlzdGVuZXJXcmFwcGVyKFRyZWVDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlzdXBlcigpOwotCQlpZiAobGlzdGVuZXIgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy5saXN0ZW5lciA9IGxpc3RlbmVyOwotCX0KLQotCXB1YmxpYyB2b2lkIG5vZGVBZGRlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaWYgKEV2ZW50UXVldWUuaXNEaXNwYXRjaFRocmVhZCgpKSB7Ci0JCQl0aGlzLm5vZGVBZGRlZF8oZXZlbnQpOwotCQl9IGVsc2UgewotCQkJdGhpcy5leGVjdXRlT25FdmVudFF1ZXVlKHRoaXMuYnVpbGROb2RlQWRkZWRSdW5uYWJsZShldmVudCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgbm9kZVJlbW92ZWQoVHJlZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCWlmIChFdmVudFF1ZXVlLmlzRGlzcGF0Y2hUaHJlYWQoKSkgewotCQkJdGhpcy5ub2RlUmVtb3ZlZF8oZXZlbnQpOwotCQl9IGVsc2UgewotCQkJdGhpcy5leGVjdXRlT25FdmVudFF1ZXVlKHRoaXMuYnVpbGROb2RlUmVtb3ZlZFJ1bm5hYmxlKGV2ZW50KSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0cmVlQ2xlYXJlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaWYgKEV2ZW50UXVldWUuaXNEaXNwYXRjaFRocmVhZCgpKSB7Ci0JCQl0aGlzLnRyZWVDbGVhcmVkXyhldmVudCk7Ci0JCX0gZWxzZSB7Ci0JCQl0aGlzLmV4ZWN1dGVPbkV2ZW50UXVldWUodGhpcy5idWlsZFRyZWVDbGVhcmVkUnVubmFibGUoZXZlbnQpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRyZWVDaGFuZ2VkKFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQlpZiAoRXZlbnRRdWV1ZS5pc0Rpc3BhdGNoVGhyZWFkKCkpIHsKLQkJCXRoaXMudHJlZUNoYW5nZWRfKGV2ZW50KTsKLQkJfSBlbHNlIHsKLQkJCXRoaXMuZXhlY3V0ZU9uRXZlbnRRdWV1ZSh0aGlzLmJ1aWxkVHJlZUNoYW5nZWRSdW5uYWJsZShldmVudCkpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBSdW5uYWJsZSBidWlsZE5vZGVBZGRlZFJ1bm5hYmxlKGZpbmFsIFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQlyZXR1cm4gbmV3IFJ1bm5hYmxlKCkgewotCQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJCUFXVFRyZWVDaGFuZ2VMaXN0ZW5lcldyYXBwZXIudGhpcy5ub2RlQWRkZWRfKGV2ZW50KTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gIm5vZGUgYWRkZWQiOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUnVubmFibGUgYnVpbGROb2RlUmVtb3ZlZFJ1bm5hYmxlKGZpbmFsIFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQlyZXR1cm4gbmV3IFJ1bm5hYmxlKCkgewotCQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJCUFXVFRyZWVDaGFuZ2VMaXN0ZW5lcldyYXBwZXIudGhpcy5ub2RlUmVtb3ZlZF8oZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAibm9kZSByZW1vdmVkIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFJ1bm5hYmxlIGJ1aWxkVHJlZUNsZWFyZWRSdW5uYWJsZShmaW5hbCBUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIG5ldyBSdW5uYWJsZSgpIHsKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlBV1RUcmVlQ2hhbmdlTGlzdGVuZXJXcmFwcGVyLnRoaXMudHJlZUNsZWFyZWRfKGV2ZW50KTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gInRyZWUgY2xlYXJlZCI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBSdW5uYWJsZSBidWlsZFRyZWVDaGFuZ2VkUnVubmFibGUoZmluYWwgVHJlZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXJldHVybiBuZXcgUnVubmFibGUoKSB7Ci0JCQlwdWJsaWMgdm9pZCBydW4oKSB7Ci0JCQkJQVdUVHJlZUNoYW5nZUxpc3RlbmVyV3JhcHBlci50aGlzLnRyZWVDaGFuZ2VkXyhldmVudCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJ0cmVlIGNoYW5nZWQiOwotCQkJfQotCQl9OwotCX0KLQotCS8qKgotCSAqIEV2ZW50UXVldWUjaW52b2tlTGF0ZXIoUnVubmFibGUpIHNlZW1zIHRvIHdvcmsgT0s7Ci0JICogYnV0IHVzaW5nICNpbnZva2VBbmRXYWl0KFJ1bm5hYmxlKSBjYW4gc29tZXRpbWVzIG1ha2UgdGhpbmdzCi0JICogbW9yZSBwcmVkaWN0YWJsZSB3aGVuIGRlYnVnZ2luZywgYXQgdGhlIHJpc2sgb2YgZGVhZGxvY2tzLgotCSAqLwotCXByaXZhdGUgdm9pZCBleGVjdXRlT25FdmVudFF1ZXVlKFJ1bm5hYmxlIHIpIHsKLQkJRXZlbnRRdWV1ZS5pbnZva2VMYXRlcihyKTsKLS8vCQl0cnkgewotLy8JCQlFdmVudFF1ZXVlLmludm9rZUFuZFdhaXQocik7Ci0vLwkJfSBjYXRjaCAoSW50ZXJydXB0ZWRFeGNlcHRpb24gZXgpIHsKLS8vCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oZXgpOwotLy8JCX0gY2F0Y2ggKGphdmEubGFuZy5yZWZsZWN0Lkludm9jYXRpb25UYXJnZXRFeGNlcHRpb24gZXgpIHsKLS8vCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oZXgpOwotLy8JCX0KLQl9Ci0KLQl2b2lkIG5vZGVBZGRlZF8oVHJlZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMubGlzdGVuZXIubm9kZUFkZGVkKGV2ZW50KTsKLQl9Ci0KLQl2b2lkIG5vZGVSZW1vdmVkXyhUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5saXN0ZW5lci5ub2RlUmVtb3ZlZChldmVudCk7Ci0JfQotCi0Jdm9pZCB0cmVlQ2xlYXJlZF8oVHJlZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMubGlzdGVuZXIudHJlZUNsZWFyZWQoZXZlbnQpOwotCX0KLQotCXZvaWQgdHJlZUNoYW5nZWRfKFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmxpc3RlbmVyLnRyZWVDaGFuZ2VkKGV2ZW50KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gIkFXVCgiICsgdGhpcy5saXN0ZW5lci50b1N0cmluZygpICsgIikiOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0Fic3RyYWN0VHJlZU5vZGVWYWx1ZU1vZGVsLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQWJzdHJhY3RUcmVlTm9kZVZhbHVlTW9kZWwuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTA2YzJlMS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQWJzdHJhY3RUcmVlTm9kZVZhbHVlTW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE5NCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuQ2hhaW5JdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkNoYW5nZVN1cHBvcnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuU3RhdGVDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5UcmVlTm9kZVZhbHVlTW9kZWw7Ci0KLS8qKgotICogU3ViY2xhc3NlcyBuZWVkIG9ubHkgaW1wbGVtZW50IHRoZSBmb2xsb3dpbmcgbWV0aG9kczoKLSAqIAotICogI3ZhbHVlKCkKLSAqCSAgICByZXR1cm4gdGhlIHVzZXItZGV0ZXJtaW5lZCAidmFsdWUiIG9mIHRoZSBub2RlLAotICogICAgIGkuZS4gdGhlIG9iamVjdCAid3JhcHBlZCIgYnkgdGhlIG5vZGUKLSAqIAotICogI3NldFZhbHVlKE9iamVjdCkKLSAqICAgICBzZXQgdGhlIHVzZXItZGV0ZXJtaW5lZCAidmFsdWUiIG9mIHRoZSBub2RlLAotICogICAgIGkuZS4gdGhlIG9iamVjdCAid3JhcHBlZCIgYnkgdGhlIG5vZGU7Ci0gKiAgICAgdHlwaWNhbGx5IG9ubHkgb3ZlcnJpZGRlbiBmb3Igbm9kZXMgd2l0aCAicHJpbWl0aXZlIiB2YWx1ZXMKLSAqIAotICogI3BhcmVudCgpCi0gKiAgICAgcmV0dXJuIHRoZSBwYXJlbnQgb2YgdGhlIG5vZGUsIHdoaWNoIHNob3VsZCBiZSBhbm90aGVyCi0gKiAgICAgVHJlZU5vZGVWYWx1ZU1vZGVsCi0gKiAKLSAqICNjaGlsZHJlbk1vZGVsKCkKLSAqICAgICByZXR1cm4gYSBMaXN0VmFsdWVNb2RlbCBmb3IgdGhlIG5vZGUncyBjaGlsZHJlbgotICogCi0gKiAjZW5nYWdlVmFsdWUoKSBhbmQgI2Rpc2VuZ2FnZVZhbHVlKCkKLSAqICAgICBvdmVycmlkZSB0aGVzZSBtZXRob2RzIHRvIGxpc3RlbiB0byB0aGUgbm9kZSdzIHZhbHVlIGlmCi0gKiAgICAgaXQgY2FuIGNoYW5nZSBpbiBhIHdheSB0aGF0IHNob3VsZCBiZSByZWZsZWN0ZWQgaW4gdGhlIHRyZWUKLSAqLwotcHVibGljIGFic3RyYWN0IGNsYXNzIEFic3RyYWN0VHJlZU5vZGVWYWx1ZU1vZGVsPFQ+Ci0JZXh0ZW5kcyBBYnN0cmFjdE1vZGVsCi0JaW1wbGVtZW50cyBUcmVlTm9kZVZhbHVlTW9kZWw8VD4KLXsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCQotCS8qKgotCSAqIERlZmF1bHQgY29uc3RydWN0b3IuCi0JICovCi0JcHJvdGVjdGVkIEFic3RyYWN0VHJlZU5vZGVWYWx1ZU1vZGVsKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgQ2hhbmdlU3VwcG9ydCBidWlsZENoYW5nZVN1cHBvcnQoKSB7Ci0JCS8vIHRoaXMgbW9kZWwgZmlyZXMgKmJvdGgqICJ2YWx1ZSBwcm9wZXJ0eSBjaGFuZ2UiIGFuZCAic3RhdGUgY2hhbmdlIiBldmVudHMuLi4KLS8vCQlyZXR1cm4gbmV3IFNpbmdsZUFzcGVjdENoYW5nZVN1cHBvcnQodGhpcywgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lci5jbGFzcywgUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKTsKLQkJcmV0dXJuIHN1cGVyLmJ1aWxkQ2hhbmdlU3VwcG9ydCgpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBleHRlbmQgQWJzdHJhY3RNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDbGllbnRzIHNob3VsZCBiZSBhZGRpbmcgYm90aCAic3RhdGUgY2hhbmdlIiBhbmQgInZhbHVlIHByb3BlcnR5IGNoYW5nZSIKLQkgKiBsaXN0ZW5lcnMuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgYWRkU3RhdGVDaGFuZ2VMaXN0ZW5lcihTdGF0ZUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCWlmICh0aGlzLmhhc05vU3RhdGVDaGFuZ2VMaXN0ZW5lcnMoKSkgewotCQkJdGhpcy5lbmdhZ2VWYWx1ZSgpOwotCQl9Ci0JCXN1cGVyLmFkZFN0YXRlQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCX0KLQotCS8qKgotCSAqIEJlZ2luIGxpc3RlbmluZyB0byB0aGUgbm9kZSdzIHZhbHVlJ3Mgc3RhdGUuIElmIHRoZSBzdGF0ZSBvZiB0aGUgbm9kZSBjaGFuZ2VzCi0JICogaW4gYSB3YXkgdGhhdCBzaG91bGQgYmUgcmVmbGVjdGVkIGluIHRoZSB0cmVlLCBmaXJlIGEgInN0YXRlIGNoYW5nZSIgZXZlbnQuCi0JICovCi0JcHJvdGVjdGVkIGFic3RyYWN0IHZvaWQgZW5nYWdlVmFsdWUoKTsKLQotCS8qKgotCSAqIEBzZWUgI2FkZFN0YXRlQ2hhbmdlTGlzdGVuZXIoU3RhdGVDaGFuZ2VMaXN0ZW5lcikKLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCByZW1vdmVTdGF0ZUNoYW5nZUxpc3RlbmVyKFN0YXRlQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJc3VwZXIucmVtb3ZlU3RhdGVDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWlmICh0aGlzLmhhc05vU3RhdGVDaGFuZ2VMaXN0ZW5lcnMoKSkgewotCQkJdGhpcy5kaXNlbmdhZ2VWYWx1ZSgpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU3RvcCBsaXN0ZW5pbmcgdG8gdGhlIG5vZGUncyB2YWx1ZS4KLQkgKiBAc2VlICNlbmdhZ2VWYWx1ZSgpCi0JICovCi0JcHJvdGVjdGVkIGFic3RyYWN0IHZvaWQgZGlzZW5nYWdlVmFsdWUoKTsKLQotCi0JLy8gKioqKioqKioqKiBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0JCi0JcHVibGljIHZvaWQgc2V0VmFsdWUoVCB2YWx1ZSkgewotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogVHJlZU5vZGVWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQkKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwdWJsaWMgVHJlZU5vZGVWYWx1ZU1vZGVsPFQ+W10gcGF0aCgpIHsKLQkJTGlzdDxUcmVlTm9kZVZhbHVlTW9kZWw8VD4+IHBhdGggPSBDb2xsZWN0aW9uVG9vbHMucmV2ZXJzZUxpc3QodGhpcy5iYWNrUGF0aCgpKTsKLQkJcmV0dXJuIHBhdGgudG9BcnJheShuZXcgVHJlZU5vZGVWYWx1ZU1vZGVsW3BhdGguc2l6ZSgpXSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGFuIGl0ZXJhdG9yIHRoYXQgY2xpbWJzIHVwIHRoZSBub2RlJ3MgcGF0aCwKLQkgKiBzdGFydGluZyB3aXRoLCBhbmQgaW5jbHVkaW5nLCB0aGUgbm9kZQotCSAqIGFuZCB1cCB0bywgYW5kIGluY2x1ZGluZywgdGhlIHJvb3Qgbm9kZS4KLQkgKi8KLQlwcm90ZWN0ZWQgSXRlcmF0b3I8VHJlZU5vZGVWYWx1ZU1vZGVsPFQ+PiBiYWNrUGF0aCgpIHsKLQkJcmV0dXJuIG5ldyBDaGFpbkl0ZXJhdG9yPFRyZWVOb2RlVmFsdWVNb2RlbDxUPj4odGhpcykgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgVHJlZU5vZGVWYWx1ZU1vZGVsPFQ+IG5leHRMaW5rKFRyZWVOb2RlVmFsdWVNb2RlbDxUPiBjdXJyZW50TGluaykgewotCQkJCXJldHVybiBjdXJyZW50TGluay5wYXJlbnQoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwdWJsaWMgVHJlZU5vZGVWYWx1ZU1vZGVsPFQ+IGNoaWxkKGludCBpbmRleCkgewotCQlyZXR1cm4gdGhpcy5jaGlsZHJlbk1vZGVsKCkuZ2V0KGluZGV4KTsKLQl9Ci0KLQlwdWJsaWMgaW50IGNoaWxkcmVuU2l6ZSgpIHsKLQkJcmV0dXJuIHRoaXMuY2hpbGRyZW5Nb2RlbCgpLnNpemUoKTsKLQl9Ci0KLQlwdWJsaWMgaW50IGluZGV4T2ZDaGlsZChUcmVlTm9kZVZhbHVlTW9kZWw8VD4gY2hpbGQpIHsKLQkJTGlzdFZhbHVlTW9kZWw8VHJlZU5vZGVWYWx1ZU1vZGVsPFQ+PiBjaGlsZHJlbiA9IHRoaXMuY2hpbGRyZW5Nb2RlbCgpOwotCQlpbnQgc2l6ZSA9IGNoaWxkcmVuLnNpemUoKTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBzaXplOyBpKyspIHsKLQkJCWlmIChjaGlsZHJlbi5nZXQoaSkgPT0gY2hpbGQpIHsKLQkJCQlyZXR1cm4gaTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gLTE7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gaXNMZWFmKCkgewotCQlyZXR1cm4gdGhpcy5jaGlsZHJlbk1vZGVsKCkuc2l6ZSgpID09IDA7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHN0YW5kYXJkIG1ldGhvZHMgKioqKioqKioqKgotCi0JLyoqCi0JICogV2UgaW1wbGVtZW50ICNlcXVhbHMoT2JqZWN0KSBzbyB0aGF0IFRyZWVQYXRocyBjb250YWluaW5nIHRoZXNlIG5vZGVzCi0JICogd2lsbCByZXNvbHZlIHByb3Blcmx5IHdoZW4gdGhlIG5vZGVzIGNvbnRhaW4gdGhlIHNhbWUgdmFsdWVzLiBUaGlzIGlzCi0JICogbmVjZXNzYXJ5IGJlY2F1c2Ugbm9kZXMgYXJlIGRyb3BwZWQgYW5kIHJlYnVpbHQgd2lsbHktbmlsbHkgd2hlbiBkZWFsaW5nCi0JICogd2l0aCBhIHNvcnRlZCBsaXN0IG9mIGNoaWxkcmVuOyBhbmQgdGhpcyBhbGxvd3MgdXMgdG8gc2F2ZSBhbmQgcmVzdG9yZQotCSAqIGEgdHJlZSdzIGV4cGFuZGVkIHBhdGhzLiBUaGUgbm9kZXMgaW4gdGhlIGV4cGFuZGVkIHBhdGhzIHRoYXQgYXJlCi0JICogc2F2ZWQgYmVmb3JlIGFueSBtb2RpZmljYXRpb24gKGUuZy4gcmVuYW1pbmcgYSBub2RlKSB3aWxsIGJlIGRpZmZlcmVudAotCSAqIGZyb20gdGhlIG5vZGVzIGluIHRoZSB0cmVlJ3MgcGF0aHMgYWZ0ZXIgdGhlIG1vZGlmaWNhdGlvbiwgaWYgdGhlIG1vZGlmaWNhdGlvbgotCSAqIHJlc3VsdHMgaW4gYSBwb3NzaWJsZSBjaGFuZ2UgaW4gdGhlIG5vZGUgc29ydCBvcmRlci4gIH5ianYKLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgYm9vbGVhbiBlcXVhbHMoT2JqZWN0IG8pIHsKLQkJaWYgKG8gPT0gbnVsbCkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCWlmIChvLmdldENsYXNzKCkgIT0gdGhpcy5nZXRDbGFzcygpKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCUFic3RyYWN0VHJlZU5vZGVWYWx1ZU1vZGVsPFQ+IG90aGVyID0gKEFic3RyYWN0VHJlZU5vZGVWYWx1ZU1vZGVsPFQ+KSBvOwotCQlyZXR1cm4gdGhpcy5nZXRWYWx1ZSgpLmVxdWFscyhvdGhlci5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgaW50IGhhc2hDb2RlKCkgewotCQlyZXR1cm4gdGhpcy5nZXRWYWx1ZSgpLmhhc2hDb2RlKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgdG9TdHJpbmcoU3RyaW5nQnVpbGRlciBzYikgewotCQlzYi5hcHBlbmQodGhpcy5nZXRWYWx1ZSgpKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Bc3BlY3RBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQXNwZWN0QWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmN2QzM2Q1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Bc3BlY3RBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyNzkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQ2hhbmdlU3VwcG9ydDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5TaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlByb3BlcnR5Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci0KLS8qKgotICogVGhpcyBhYnN0cmFjdCBleHRlbnNpb24gb2YgQWJzdHJhY3RNb2RlbCBwcm92aWRlcyBhIGJhc2UgZm9yIGFkZGluZyAKLSAqIGNoYW5nZSBsaXN0ZW5lcnMgKFByb3BlcnR5Q2hhbmdlLCBDb2xsZWN0aW9uQ2hhbmdlLCBMaXN0Q2hhbmdlLCBUcmVlQ2hhbmdlKQotICogdG8gYSBzdWJqZWN0IGFuZCBjb252ZXJ0aW5nIHRoZSBzdWJqZWN0J3MgY2hhbmdlIG5vdGlmaWNhdGlvbnMgaW50byBhIHNpbmdsZQotICogc2V0IG9mIGNoYW5nZSBub3RpZmljYXRpb25zIGZvciBhIGNvbW1vbiBhc3BlY3QgKGUuZy4gVkFMVUUpLgotICogCi0gKiBUaGUgYWRhcHRlciB3aWxsIG9ubHkgbGlzdGVuIHRvIHRoZSBzdWJqZWN0IChhbmQgc3ViamVjdCBob2xkZXIpIHdoZW4gdGhlCi0gKiBhZGFwdGVyIGl0c2VsZiBhY3R1YWxseSBoYXMgbGlzdGVuZXJzLiBUaGlzIHdpbGwgYWxsb3cgdGhlIGFkYXB0ZXIgdG8gYmUKLSAqIGdhcmJhZ2UgY29sbGVjdGVkIHdoZW4gYXBwcm9wcmlhdGUKLSAqLwotcHVibGljIGFic3RyYWN0IGNsYXNzIEFzcGVjdEFkYXB0ZXI8Uz4KLQlleHRlbmRzIEFic3RyYWN0TW9kZWwKLXsKLQkvKioKLQkgKiBUaGUgc3ViamVjdCB0aGF0IGhvbGRzIHRoZSBhc3BlY3QgYW5kIGZpcmVzCi0JICogY2hhbmdlIG5vdGlmaWNhdGlvbiB3aGVuIHRoZSBhc3BlY3QgY2hhbmdlcy4KLQkgKiBXZSBuZWVkIHRvIGhvbGQgb24gdG8gdGhpcyBkaXJlY3RseSBzbyB3ZSBjYW4KLQkgKiBkaXNlbmdhZ2UgaXQgd2hlbiBpdCBjaGFuZ2VzLgotCSAqLwotCXByb3RlY3RlZCBTIHN1YmplY3Q7Ci0KLQkvKioKLQkgKiBBIHZhbHVlIG1vZGVsIHRoYXQgaG9sZHMgdGhlIHN1YmplY3QKLQkgKiB0aGF0IGhvbGRzIHRoZSBhc3BlY3QgYW5kIHByb3ZpZGVzIGNoYW5nZSBub3RpZmljYXRpb24uCi0JICogVGhpcyBpcyB1c2VmdWwgd2hlbiB0aGVyZSBhcmUgYSBudW1iZXIgb2YgQXNwZWN0QWRhcHRlcnMKLQkgKiB0aGF0IGhhdmUgdGhlIHNhbWUgc3ViamVjdCBhbmQgdGhhdCBzdWJqZWN0IGNhbiBjaGFuZ2UuCi0JICogQWxsIHRoZSBBc3BlY3RBZGFwdGVycyBzaG91bGQgc2hhcmUgdGhlIHNhbWUgc3ViamVjdCBob2xkZXIuCi0JICogRm9yIG5vdywgdGhpcyBpcyBjYW4gb25seSBiZSBzZXQgdXBvbiBjb25zdHJ1Y3Rpb24gYW5kIGlzCi0JICogaW1tdXRhYmxlLgotCSAqLwotCXByb3RlY3RlZCBmaW5hbCBQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFM+IHN1YmplY3RIb2xkZXI7Ci0KLQkvKiogQSBsaXN0ZW5lciB0aGF0IGtlZXBzIHVzIGluIHN5bmNoIHdpdGggdGhlIHN1YmplY3RIb2xkZXIuICovCi0JcHJvdGVjdGVkIGZpbmFsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgc3ViamVjdENoYW5nZUxpc3RlbmVyOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gQXNwZWN0QWRhcHRlciBmb3IgdGhlIHNwZWNpZmllZCBzdWJqZWN0LgotCSAqLwotCXByb3RlY3RlZCBBc3BlY3RBZGFwdGVyKFMgc3ViamVjdCkgewotCQl0aGlzKG5ldyBTdGF0aWNQcm9wZXJ0eVZhbHVlTW9kZWw8Uz4oc3ViamVjdCkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBBc3BlY3RBZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIHN1YmplY3QgaG9sZGVyLgotCSAqIFRoZSBzdWJqZWN0IGhvbGRlciBjYW5ub3QgYmUgbnVsbC4KLQkgKi8KLQlwcm90ZWN0ZWQgQXNwZWN0QWRhcHRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFM+IHN1YmplY3RIb2xkZXIpIHsKLQkJc3VwZXIoKTsKLQkJaWYgKHN1YmplY3RIb2xkZXIgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy5zdWJqZWN0SG9sZGVyID0gc3ViamVjdEhvbGRlcjsKLQkJdGhpcy5zdWJqZWN0Q2hhbmdlTGlzdGVuZXIgPSB0aGlzLmJ1aWxkU3ViamVjdENoYW5nZUxpc3RlbmVyKCk7Ci0JCS8vIHRoZSBzdWJqZWN0IGlzIG51bGwgd2hlbiB3ZSBhcmUgbm90IGxpc3RlbmluZyB0byBpdAotCQkvLyB0aGlzIHdpbGwgdHlwaWNhbGx5IHJlc3VsdCBpbiBvdXIgdmFsdWUgYmVpbmcgbnVsbAotCQl0aGlzLnN1YmplY3QgPSBudWxsOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgQ2hhbmdlU3VwcG9ydCBidWlsZENoYW5nZVN1cHBvcnQoKSB7Ci0JCXJldHVybiBuZXcgTG9jYWxDaGFuZ2VTdXBwb3J0KHRoaXMsIHRoaXMuZ2V0TGlzdGVuZXJDbGFzcygpLCB0aGlzLmdldExpc3RlbmVyQXNwZWN0TmFtZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBUaGUgc3ViamVjdCBob2xkZXIncyB2YWx1ZSBoYXMgY2hhbmdlZCwga2VlcCBvdXIgc3ViamVjdCBpbiBzeW5jaC4KLQkgKi8KLQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZFN1YmplY3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlBc3BlY3RBZGFwdGVyLnRoaXMuc3ViamVjdENoYW5nZWQoKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gInN1YmplY3QgY2hhbmdlIGxpc3RlbmVyIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCi0JLyoqCi0JICogVGhlIHN1YmplY3QgaGFzIGNoYW5nZWQuIE5vdGlmeSBsaXN0ZW5lcnMgdGhhdCB0aGUgdmFsdWUgaGFzIGNoYW5nZWQuCi0JICovCi0JcHJvdGVjdGVkIHN5bmNocm9uaXplZCB2b2lkIHN1YmplY3RDaGFuZ2VkKCkgewotCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmdldFZhbHVlKCk7Ci0JCWJvb2xlYW4gaGFzTGlzdGVuZXJzID0gdGhpcy5oYXNMaXN0ZW5lcnMoKTsKLQkJaWYgKGhhc0xpc3RlbmVycykgewotCQkJdGhpcy5kaXNlbmdhZ2VTdWJqZWN0KCk7Ci0JCX0KLQkJdGhpcy5zdWJqZWN0ID0gdGhpcy5zdWJqZWN0SG9sZGVyLmdldFZhbHVlKCk7Ci0JCWlmIChoYXNMaXN0ZW5lcnMpIHsKLQkJCXRoaXMuZW5nYWdlU3ViamVjdCgpOwotCQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKG9sZFZhbHVlLCB0aGlzLmdldFZhbHVlKCkpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhc3BlY3QncyBjdXJyZW50IHZhbHVlLgotCSAqLwotCXByb3RlY3RlZCBhYnN0cmFjdCBPYmplY3QgZ2V0VmFsdWUoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgY2xhc3Mgb2YgbGlzdGVuZXIgdGhhdCBpcyBpbnRlcmVzdGVkIGluIHRoZSBhc3BlY3QgYWRhcHRlcidzCi0JICogY2hhbmdlcy4KLQkgKi8KLQlwcm90ZWN0ZWQgYWJzdHJhY3QgQ2xhc3M8PyBleHRlbmRzIENoYW5nZUxpc3RlbmVyPiBnZXRMaXN0ZW5lckNsYXNzKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG5hbWUgb2YgdGhlIGFzcGVjdCBhZGFwdGVyJ3MgYXNwZWN0IChlLmcuIFZBTFVFKS4KLQkgKiBUaGlzIGlzIHRoZSBuYW1lIG9mIHRoZSBhc3BlY3QgYWRhcHRlcidzIHNpbmdsZSBhc3BlY3QsIG5vdCB0aGUKLQkgKiBuYW1lIG9mIHRoZSBzdWJqZWN0J3MgYXNwZWN0IHRoZSBhc3BlY3QgYWRhcHRlciBpcyBhZGFwdGluZy4KLQkgKi8KLQlwcm90ZWN0ZWQgYWJzdHJhY3QgU3RyaW5nIGdldExpc3RlbmVyQXNwZWN0TmFtZSgpOwotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlcmUgYXJlIGFueSBsaXN0ZW5lcnMgZm9yIHRoZSBhc3BlY3QuCi0JICovCi0JcHJvdGVjdGVkIGFic3RyYWN0IGJvb2xlYW4gaGFzTGlzdGVuZXJzKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGVyZSBhcmUgbm8gbGlzdGVuZXJzIGZvciB0aGUgYXNwZWN0LgotCSAqLwotCXByb3RlY3RlZCBib29sZWFuIGhhc05vTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gISB0aGlzLmhhc0xpc3RlbmVycygpOwotCX0KLQotCS8qKgotCSAqIFRoZSBhc3BlY3QgaGFzIGNoYW5nZWQsIG5vdGlmeSBsaXN0ZW5lcnMgYXBwcm9wcmlhdGVseS4KLQkgKi8KLQlwcm90ZWN0ZWQgYWJzdHJhY3Qgdm9pZCBmaXJlQXNwZWN0Q2hhbmdlKE9iamVjdCBvbGRWYWx1ZSwgT2JqZWN0IG5ld1ZhbHVlKTsKLQotCXByb3RlY3RlZCB2b2lkIGVuZ2FnZVN1YmplY3QoKSB7Ci0JCS8vIGNoZWNrIGZvciBub3RoaW5nIHRvIGxpc3RlbiB0bwotCQlpZiAodGhpcy5zdWJqZWN0ICE9IG51bGwpIHsKLQkJCXRoaXMuZW5nYWdlU3ViamVjdF8oKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFRoZSBzdWJqZWN0IGlzIG5vdCBudWxsIC0gYWRkIG91ciBsaXN0ZW5lci4KLQkgKi8KLQlwcm90ZWN0ZWQgYWJzdHJhY3Qgdm9pZCBlbmdhZ2VTdWJqZWN0XygpOwotCi0JcHJvdGVjdGVkIHZvaWQgZGlzZW5nYWdlU3ViamVjdCgpIHsKLQkJLy8gY2hlY2sgZm9yIG5vdGhpbmcgdG8gbGlzdGVuIHRvCi0JCWlmICh0aGlzLnN1YmplY3QgIT0gbnVsbCkgewotCQkJdGhpcy5kaXNlbmdhZ2VTdWJqZWN0XygpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogVGhlIHN1YmplY3QgaXMgbm90IG51bGwgLSByZW1vdmUgb3VyIGxpc3RlbmVyLgotCSAqLwotCXByb3RlY3RlZCBhYnN0cmFjdCB2b2lkIGRpc2VuZ2FnZVN1YmplY3RfKCk7Ci0KLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VTdWJqZWN0SG9sZGVyKCkgewotCQl0aGlzLnN1YmplY3RIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMuc3ViamVjdENoYW5nZUxpc3RlbmVyKTsKLQkJLy8gc3luY2ggb3VyIHN1YmplY3QgKmFmdGVyKiB3ZSBzdGFydCBsaXN0ZW5pbmcgdG8gdGhlIHN1YmplY3QgaG9sZGVyLAotCQkvLyBzaW5jZSBpdHMgdmFsdWUgbWlnaHQgY2hhbmdlIHdoZW4gYSBsaXN0ZW5lciBpcyBhZGRlZAotCQl0aGlzLnN1YmplY3QgPSB0aGlzLnN1YmplY3RIb2xkZXIuZ2V0VmFsdWUoKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VTdWJqZWN0SG9sZGVyKCkgewotCQl0aGlzLnN1YmplY3RIb2xkZXIucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMuc3ViamVjdENoYW5nZUxpc3RlbmVyKTsKLQkJLy8gY2xlYXIgb3V0IHRoZSBzdWJqZWN0IHdoZW4gd2UgYXJlIG5vdCBsaXN0ZW5pbmcgdG8gaXRzIGhvbGRlcgotCQl0aGlzLnN1YmplY3QgPSBudWxsOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGVuZ2FnZU1vZGVscygpIHsKLQkJdGhpcy5lbmdhZ2VTdWJqZWN0SG9sZGVyKCk7Ci0JCXRoaXMuZW5nYWdlU3ViamVjdCgpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZU1vZGVscygpIHsKLQkJdGhpcy5kaXNlbmdhZ2VTdWJqZWN0KCk7Ci0JCXRoaXMuZGlzZW5nYWdlU3ViamVjdEhvbGRlcigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBsb2NhbCBjaGFuZ2Ugc3VwcG9ydCAqKioqKioqKioqCi0KLQkvKioKLQkgKiBFeHRlbmQgY2hhbmdlIHN1cHBvcnQgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSBhc3BlY3QgYWRhcHRlcidzCi0JICogbW9kZWxzICh0aGUgc3ViamVjdCBob2xkZXIgYW5kIHRoZSBzdWJqZWN0IGl0c2VsZikgd2hlbiB0aGUgZmlyc3QKLQkgKiByZWxldmFudCBsaXN0ZW5lciBpcyBhZGRlZC4KLQkgKiBDb252ZXJzZWx5LCBzdG9wIGxpc3RlbmluZyB0byB0aGUgYXNwZWN0IGFkYXB0ZXIncyBtb2RlbHMgd2hlbiB0aGUKLQkgKiBsYXN0IHJlbGV2YW50IGxpc3RlbmVyIGlzIHJlbW92ZWQuCi0JICogQSByZWxldmFudCBsaXN0ZW5lciBpcyBhIGxpc3RlbmVyIG9mIHRoZSByZWxldmFudCB0eXBlLgotCSAqLwotCXByb3RlY3RlZCBjbGFzcyBMb2NhbENoYW5nZVN1cHBvcnQgZXh0ZW5kcyBTaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0IHsKLQkJcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0KLQkJcHVibGljIExvY2FsQ2hhbmdlU3VwcG9ydChBc3BlY3RBZGFwdGVyPFM+IHNvdXJjZSwgQ2xhc3M8PyBleHRlbmRzIENoYW5nZUxpc3RlbmVyPiBsaXN0ZW5lckNsYXNzLCBTdHJpbmcgYXNwZWN0TmFtZSkgewotCQkJc3VwZXIoc291cmNlLCBsaXN0ZW5lckNsYXNzLCBhc3BlY3ROYW1lKTsKLQkJfQotCi0JCXByb3RlY3RlZCBib29sZWFuIGxpc3RlbmVySXNSZWxldmFudChDbGFzczw/IGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXI+IGxDbGFzcykgewotCQkJcmV0dXJuIGxDbGFzcyA9PSB0aGlzLmxpc3RlbmVyQ2xhc3M7Ci0JCX0KLQotCQlwcm90ZWN0ZWQgYm9vbGVhbiBoYXNOb1JlbGV2YW50TGlzdGVuZXJzKENsYXNzPD8gZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gbENsYXNzKSB7Ci0JCQlyZXR1cm4gdGhpcy5saXN0ZW5lcklzUmVsZXZhbnQobENsYXNzKQotCQkJCQkJJiYgdGhpcy5oYXNOb0xpc3RlbmVycyhsQ2xhc3MpOwotCQl9Ci0KLQkJcHJvdGVjdGVkIGJvb2xlYW4gbGlzdGVuZXJJc1JlbGV2YW50KENsYXNzPD8gZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gbENsYXNzLCBTdHJpbmcgbGlzdGVuZXJBc3BlY3ROYW1lKSB7Ci0JCQlyZXR1cm4gdGhpcy5saXN0ZW5lcklzUmVsZXZhbnQobENsYXNzKQotCQkJCQkJJiYgKGxpc3RlbmVyQXNwZWN0TmFtZSA9PSBBc3BlY3RBZGFwdGVyLnRoaXMuZ2V0TGlzdGVuZXJBc3BlY3ROYW1lKCkpOwotCQl9Ci0KLQkJcHJvdGVjdGVkIGJvb2xlYW4gaGFzTm9SZWxldmFudExpc3RlbmVycyhDbGFzczw/IGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXI+IGxDbGFzcywgU3RyaW5nIGxpc3RlbmVyQXNwZWN0TmFtZSkgewotCQkJcmV0dXJuIHRoaXMubGlzdGVuZXJJc1JlbGV2YW50KGxDbGFzcywgbGlzdGVuZXJBc3BlY3ROYW1lKQotCQkJCQkJJiYgdGhpcy5oYXNOb0xpc3RlbmVycyhsQ2xhc3MsIGxpc3RlbmVyQXNwZWN0TmFtZSk7Ci0JCX0KLQotCi0JCS8vICoqKioqKioqKiogb3ZlcnJpZGVzICoqKioqKioqKioKLQotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIDxUIGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXI+IHZvaWQgYWRkTGlzdGVuZXIoQ2xhc3M8VD4gbENsYXNzLCBUIGxpc3RlbmVyKSB7Ci0JCQlpZiAodGhpcy5oYXNOb1JlbGV2YW50TGlzdGVuZXJzKGxDbGFzcykpIHsKLQkJCQlBc3BlY3RBZGFwdGVyLnRoaXMuZW5nYWdlTW9kZWxzKCk7Ci0JCQl9Ci0JCQlzdXBlci5hZGRMaXN0ZW5lcihsQ2xhc3MsIGxpc3RlbmVyKTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgPFQgZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gdm9pZCBhZGRMaXN0ZW5lcihTdHJpbmcgbGlzdGVuZXJBc3BlY3ROYW1lLCBDbGFzczxUPiBsQ2xhc3MsIFQgbGlzdGVuZXIpIHsKLQkJCWlmICh0aGlzLmhhc05vUmVsZXZhbnRMaXN0ZW5lcnMobENsYXNzLCBsaXN0ZW5lckFzcGVjdE5hbWUpKSB7Ci0JCQkJQXNwZWN0QWRhcHRlci50aGlzLmVuZ2FnZU1vZGVscygpOwotCQkJfQotCQkJc3VwZXIuYWRkTGlzdGVuZXIobGlzdGVuZXJBc3BlY3ROYW1lLCBsQ2xhc3MsIGxpc3RlbmVyKTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgPFQgZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gdm9pZCByZW1vdmVMaXN0ZW5lcihDbGFzczxUPiBsQ2xhc3MsIFQgbGlzdGVuZXIpIHsKLQkJCXN1cGVyLnJlbW92ZUxpc3RlbmVyKGxDbGFzcywgbGlzdGVuZXIpOwotCQkJaWYgKHRoaXMuaGFzTm9SZWxldmFudExpc3RlbmVycyhsQ2xhc3MpKSB7Ci0JCQkJQXNwZWN0QWRhcHRlci50aGlzLmRpc2VuZ2FnZU1vZGVscygpOwotCQkJfQotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCA8VCBleHRlbmRzIENoYW5nZUxpc3RlbmVyPiB2b2lkIHJlbW92ZUxpc3RlbmVyKFN0cmluZyBsaXN0ZW5lckFzcGVjdE5hbWUsIENsYXNzPFQ+IGxDbGFzcywgVCBsaXN0ZW5lcikgewotCQkJc3VwZXIucmVtb3ZlTGlzdGVuZXIobGlzdGVuZXJBc3BlY3ROYW1lLCBsQ2xhc3MsIGxpc3RlbmVyKTsKLQkJCWlmICh0aGlzLmhhc05vUmVsZXZhbnRMaXN0ZW5lcnMobENsYXNzLCBsaXN0ZW5lckFzcGVjdE5hbWUpKSB7Ci0JCQkJQXNwZWN0QWRhcHRlci50aGlzLmRpc2VuZ2FnZU1vZGVscygpOwotCQkJfQotCQl9Ci0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Bc3BlY3RQcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQXNwZWN0UHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3NTg1Mzc1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Bc3BlY3RQcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNzkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQ2hhbmdlU3VwcG9ydDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5TaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIFRoaXMgYWJzdHJhY3QgY2xhc3MgcHJvdmlkZXMgdGhlIGluZnJhc3RydWN0dXJlIG5lZWRlZCB0byB3cmFwCi0gKiBhIHZhbHVlIG1vZGVsLCAibGF6aWx5IiBsaXN0ZW4gdG8gaXQsIGFuZCBjb252ZXJ0Ci0gKiBpdHMgY2hhbmdlIG5vdGlmaWNhdGlvbnMgaW50byBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCBjaGFuZ2UKLSAqIG5vdGlmaWNhdGlvbnMuCi0gKiAKLSAqIFN1YmNsYXNzZXMgbXVzdCBvdmVycmlkZToKLSAqIC0gI2J1aWxkVmFsdWUoKQotICogICAgIHRvIHJldHVybiB0aGUgY3VycmVudCBwcm9wZXJ0eSB2YWx1ZSwgYXMgZGVyaXZlZCBmcm9tIHRoZQotICogICAgIGN1cnJlbnQgbW9kZWwgdmFsdWUKLSAqIAotICovCi1wdWJsaWMgYWJzdHJhY3QgY2xhc3MgQXNwZWN0UHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlcjxUPgotCWV4dGVuZHMgQWJzdHJhY3RNb2RlbAotCWltcGxlbWVudHMgUHJvcGVydHlWYWx1ZU1vZGVsPFQ+Ci17Ci0JLyoqCi0JICogQ2FjaGUgdGhlIGN1cnJlbnQgdmFsdWUgc28gd2UgY2FuIHBhc3MgYW4gIm9sZCB2YWx1ZSIgd2hlbgotCSAqIHdlIGZpcmUgYSBwcm9wZXJ0eSBjaGFuZ2UgZXZlbnQuCi0JICogV2UgbmVlZCB0aGlzIGJlY2F1c2UgdGhlIHZhbHVlIG1heSBiZSBjYWxjdWxhdGVkIGFuZCB3ZSBtYXkKLQkgKiBub3QgYWJsZSB0byBkZXJpdmUgdGhlICJvbGQgdmFsdWUiIGZyb20gdGhlIGNvbGxlY3Rpb24KLQkgKiBjaGFuZ2UgZXZlbnQgZmlyZWQgYnkgdGhlIGNvbGxlY3Rpb24gdmFsdWUgbW9kZWwuCi0JICovCi0JcHJvdGVjdGVkIFQgdmFsdWU7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3IvaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JcHJvdGVjdGVkIEFzcGVjdFByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JCS8vIG91ciB2YWx1ZSBpcyBudWxsIHdoZW4gd2UgYXJlIG5vdCBsaXN0ZW5pbmcgdG8gdGhlIGNvbGxlY3Rpb24gaG9sZGVyCi0JCXRoaXMudmFsdWUgPSBudWxsOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBDaGFuZ2VTdXBwb3J0IGJ1aWxkQ2hhbmdlU3VwcG9ydCgpIHsKLQkJcmV0dXJuIG5ldyBTaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0KHRoaXMsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIuY2xhc3MsIFZBTFVFKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogUHJvcGVydHlWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB0aGUgY2FjaGVkIHZhbHVlLgotCSAqLwotCXB1YmxpYyBUIGdldFZhbHVlKCkgewotCQlyZXR1cm4gdGhpcy52YWx1ZTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogZXh0ZW5kIGNoYW5nZSBzdXBwb3J0ICoqKioqKioqKioKLQotCS8qKgotCSAqIEV4dGVuZCB0byBzdGFydCBsaXN0ZW5pbmcgdG8gdGhlIHdyYXBwZWQgY29sbGVjdGlvbiBpZiBuZWNlc3NhcnkuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIGFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlpZiAodGhpcy5oYXNOb0xpc3RlbmVycygpKSB7Ci0JCQl0aGlzLmVuZ2FnZU1vZGVsKCk7Ci0JCX0KLQkJc3VwZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JfQotCQotCS8qKgotCSAqIEV4dGVuZCB0byBzdGFydCBsaXN0ZW5pbmcgdG8gdGhlIHdyYXBwZWQgY29sbGVjdGlvbiBpZiBuZWNlc3NhcnkuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIGFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoU3RyaW5nIHByb3BlcnR5TmFtZSwgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlpZiAocHJvcGVydHlOYW1lID09IFZBTFVFICYmIHRoaXMuaGFzTm9MaXN0ZW5lcnMoKSkgewotCQkJdGhpcy5lbmdhZ2VNb2RlbCgpOwotCQl9Ci0JCXN1cGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIocHJvcGVydHlOYW1lLCBsaXN0ZW5lcik7Ci0JfQotCQotCS8qKgotCSAqIEV4dGVuZCB0byBzdG9wIGxpc3RlbmluZyB0byB0aGUgd3JhcHBlZCBjb2xsZWN0aW9uIGlmIG5lY2Vzc2FyeS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgcmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXN1cGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlpZiAodGhpcy5oYXNOb0xpc3RlbmVycygpKSB7Ci0JCQl0aGlzLmRpc2VuZ2FnZU1vZGVsKCk7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSB3cmFwcGVkIGNvbGxlY3Rpb24gaWYgbmVjZXNzYXJ5LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCByZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFN0cmluZyBwcm9wZXJ0eU5hbWUsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJc3VwZXIucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihwcm9wZXJ0eU5hbWUsIGxpc3RlbmVyKTsKLQkJaWYgKHByb3BlcnR5TmFtZSA9PSBWQUxVRSAmJiB0aGlzLmhhc05vTGlzdGVuZXJzKCkpIHsKLQkJCXRoaXMuZGlzZW5nYWdlTW9kZWwoKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBxdWVyaWVzICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZXJlIGFyZSBhbnkgbGlzdGVuZXJzIGZvciB0aGUgYXNwZWN0LgotCSAqLwotCXByb3RlY3RlZCBib29sZWFuIGhhc0xpc3RlbmVycygpIHsKLQkJcmV0dXJuIHRoaXMuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoVkFMVUUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZXJlIGFyZSBhbnkgbGlzdGVuZXJzIGZvciB0aGUgYXNwZWN0LgotCSAqLwotCXByb3RlY3RlZCBib29sZWFuIGhhc05vTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gISB0aGlzLmhhc0xpc3RlbmVycygpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBTdGFydCBsaXN0ZW5pbmcgdG8gdGhlIG1vZGVsIGFuZCBidWlsZCB0aGUgdmFsdWUuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlTW9kZWwoKSB7Ci0JCXRoaXMuZW5nYWdlTW9kZWxfKCk7Ci0JCS8vIHN5bmNoIG91ciB2YWx1ZSAqYWZ0ZXIqIHdlIHN0YXJ0IGxpc3RlbmluZyB0byB0aGUgY29sbGVjdGlvbiwKLQkJLy8gc2luY2UgdGhlIGNvbGxlY3Rpb24ncyB2YWx1ZSBtaWdodCBjaGFuZ2Ugd2hlbiBhIGxpc3RlbmVyIGlzIGFkZGVkCi0JCXRoaXMudmFsdWUgPSB0aGlzLmJ1aWxkVmFsdWUoKTsKLQl9Ci0KLQkvKioKLQkgKiBTdGFydCBsaXN0ZW5pbmcgdG8gdGhlIG1vZGVsLgotCSAqLwotCXByb3RlY3RlZCBhYnN0cmFjdCB2b2lkIGVuZ2FnZU1vZGVsXygpOwotCi0JLyoqCi0JICogQnVpbGQgYW5kIHJldHVybiB0aGUgY3VycmVudCB2YWx1ZSwgYXMgZGVyaXZlZCBmcm9tIHRoZQotCSAqIGN1cnJlbnQgc3RhdGUgb2YgdGhlIHdyYXBwZWQgbW9kZWwuCi0JICovCi0JcHJvdGVjdGVkIGFic3RyYWN0IFQgYnVpbGRWYWx1ZSgpOwotCi0JLyoqCi0JICogU3RvcCBsaXN0ZW5pbmcgdG8gdGhlIG1vZGVsIGFuZCBjbGVhciB0aGUgdmFsdWUuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgZGlzZW5nYWdlTW9kZWwoKSB7Ci0JCXRoaXMuZGlzZW5nYWdlTW9kZWxfKCk7Ci0JCS8vIGNsZWFyIG91dCBvdXIgdmFsdWUgd2hlbiB3ZSBhcmUgbm90IGxpc3RlbmluZyB0byB0aGUgY29sbGVjdGlvbgotCQl0aGlzLnZhbHVlID0gbnVsbDsKLQl9Ci0KLQkvKioKLQkgKiBTdG9wIGxpc3RlbmluZyB0byB0aGUgbW9kZWwuCi0JICovCi0JcHJvdGVjdGVkIGFic3RyYWN0IHZvaWQgZGlzZW5nYWdlTW9kZWxfKCk7Ci0KLQkvKioKLQkgKiBUaGUgd3JhcHBlZCBtb2RlbCBjaGFuZ2VkIGluIHNvbWUgZmFzaGlvbi4KLQkgKiBSZWNhbGN1bGF0ZSB0aGUgdmFsdWUgYW5kIG5vdGlmeSBhbnkgbGlzdGVuZXJzLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIHByb3BlcnR5Q2hhbmdlZCgpIHsKLQkJT2JqZWN0IG9sZCA9IHRoaXMudmFsdWU7Ci0JCXRoaXMudmFsdWUgPSB0aGlzLmJ1aWxkVmFsdWUoKTsKLQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKFZBTFVFLCBvbGQsIHRoaXMudmFsdWUpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0J1ZmZlcmVkV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9CdWZmZXJlZFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDg3ODFiZTQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0J1ZmZlcmVkV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDM0NSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBBIEJ1ZmZlcmVkUHJvcGVydHlWYWx1ZU1vZGVsIGlzIHVzZWQgdG8gaG9sZCBhIHRlbXBvcmFyeSBjb3B5IG9mIHRoZSB2YWx1ZQotICogaW4gYW5vdGhlciBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCAodGhlICJ3cmFwcGVkIiB2YWx1ZSBob2xkZXIpLiBUaGUgYXBwbGljYXRpb24KLSAqIGNhbiBtb2RpZnkgdGhpcyB0ZW1wb3JhcnkgY29weSwgYWQgbmF1c2VhbTsgYnV0IHRoZSB0ZW1wb3JhcnkgY29weSBpcyBvbmx5Ci0gKiBwYXNzZWQgdGhyb3VnaCB0byB0aGUgIndyYXBwZWQiIHZhbHVlIGhvbGRlciB3aGVuIHRoZSB0cmlnZ2VyICJhY2NlcHRzIiB0aGUKLSAqIGJ1ZmZlcmVkIHZhbHVlLiBBbHRlcm5hdGl2ZWx5LCB0aGUgYXBwbGljYXRpb24gY2FuICJyZXNldCIgdGhlIGJ1ZmZlcmVkIHZhbHVlCi0gKiB0byB0aGUgb3JpZ2luYWwsICJ3cmFwcGVkIiB2YWx1ZS4KLSAqIAotICogVGhlIHRyaWdnZXIgaXMgYW5vdGhlciB2YWx1ZSBtb2RlbCB0aGF0IGhvbGRzIGEgQm9vbGVhbiBhbmQgdGhlIGFwcGxpY2F0aW9uCi0gKiBjaGFuZ2VzIHRoZSB0cmlnZ2VyJ3MgdmFsdWUgdG8gdHJ1ZSBvbiAiYWNjZXB0IiwgZmFsc2Ugb24gInJlc2V0Ii4gVHlwaWNhbGx5LAotICogaW4gYSBkaWFsb2c6Ci0gKiAJLSBwcmVzc2luZyB0aGUgT0sgYnV0dG9uIHdpbGwgdHJpZ2dlciBhbiAiYWNjZXB0IiBhbmQgY2xvc2UgdGhlIGRpYWxvZwotICogCS0gcHJlc3NpbmcgdGhlIENhbmNlbCBidXR0b24gd2lsbCBzaW1wbHkgY2xvc2UgdGhlIGRpYWxvZywKLSAqIAkJZHJvcHBpbmcgdGhlICJidWZmZXJlZCIgdmFsdWVzIGludG8gdGhlIGJpdCBidWNrZXQKLSAqIAktIHByZXNzaW5nIHRoZSBBcHBseSBidXR0b24gd2lsbCB0cmlnZ2VyIGFuICJhY2NlcHQiIGFuZCBsZWF2ZSB0aGUgZGlhbG9nIG9wZW4KLSAqIAktIHByZXNzaW5nIHRoZSBSZXN0b3JlIGJ1dHRvbiB3aWxsIHRyaWdnZXIgYSAicmVzZXQiIGFuZCBsZWF2ZSB0aGUgZGlhbG9nIG9wZW4KLSAqIAotICogQSBudW1iZXIgb2YgYnVmZmVyZWQgcHJvcGVydHkgdmFsdWUgbW9kZWxzIGNhbiB3cmFwIGFub3RoZXIgc2V0IG9mCi0gKiBwcm9wZXJ0eSBhc3BlY3QgYWRhcHRlcnMgdGhhdCBhZGFwdCB0aGUgdmFyaW91cyBhc3BlY3RzIG9mIGEgc2luZ2xlCi0gKiBkb21haW4gbW9kZWwuIEFsbCB0aGUgYnVmZmVyZCBwcm9wZXJ0eSB2YWx1ZSBtb2RlbHMgY2FuIGJlIGhvb2tlZCB0byB0aGUKLSAqIHNhbWUgdHJpZ2dlciwgYW5kIHRoYXQgdHJpZ2dlciBpcyBjb250cm9sbGVkIGJ5IHRoZSBhcHBsaWNhdGlvbiwgdHlwaWNhbGx5Ci0gKiB2aWEgdGhlIE9LIGJ1dHRvbiBpbiBhIGRpYWxvZy4KLSAqIAotICogQHNlZSBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXIKLSAqLwotcHVibGljIGNsYXNzIEJ1ZmZlcmVkV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VD4KLQlleHRlbmRzIFByb3BlcnR5VmFsdWVNb2RlbFdyYXBwZXI8VD4KLQlpbXBsZW1lbnRzIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQ+Ci17Ci0KLQkvKioKLQkgKiBXZSBjYWNoZSB0aGUgdmFsdWUgaGVyZSB1bnRpbCBpdCBpcyBhY2NlcHRlZCBhbmQgcGFzc2VkCi0JICogdGhyb3VnaCB0byB0aGUgd3JhcHBlZCB2YWx1ZSBob2xkZXIuCi0JICovCi0JcHJvdGVjdGVkIFQgYnVmZmVyZWRWYWx1ZTsKLQotCS8qKgotCSAqIFRoaXMgaXMgc2V0IHRvIHRydWUgd2hlbiB3ZSBhcmUgImFjY2VwdGluZyIgdGhlIGJ1ZmZlcmVkIHZhbHVlCi0JICogYW5kIHBhc3NpbmcgaXQgdGhyb3VnaCB0byB0aGUgd3JhcHBlZCB2YWx1ZSBob2xkZXIuIFRoaXMgYWxsb3dzCi0JICogdXMgdG8gaWdub3JlIHRoZSBwcm9wZXJ0eSBjaGFuZ2UgZXZlbnQgZmlyZWQgYnkgdGhlIHdyYXBwZWQKLQkgKiB2YWx1ZSBob2xkZXIuCi0JICogKFdlIGNhbid0IHN0b3AgbGlzdGVuaW5nIHRvIHRoZSB3cmFwcGVkIHZhbHVlIGhvbGRlciwgYmVjYXVzZQotCSAqIGlmIHdlIGFyZSB0aGUgb25seSBsaXN0ZW5lciB0aGF0IGNvdWxkICJkZWFjdGl2YXRlIiB0aGUgd3JhcHBlZAotCSAqIHZhbHVlIGhvbGRlci4pCi0JICovCi0JcHJvdGVjdGVkIGJvb2xlYW4gYWNjZXB0aW5nOwotCi0JLyoqCi0JICogVGhpcyBpcyB0aGUgdHJpZ2dlciB0aGF0IGluZGljYXRlcyB3aGV0aGVyIHRoZSBidWZmZXJlZCB2YWx1ZQotCSAqIHNob3VsZCBiZSBhY2NlcHRlZCBvciByZXNldC4KLQkgKi8KLQlwcm90ZWN0ZWQgZmluYWwgUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IHRyaWdnZXJIb2xkZXI7Ci0KLQkvKiogVGhpcyBsaXN0ZW5zIHRvIHRoZSB0cmlnZ2VyIGhvbGRlci4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciB0cmlnZ2VyQ2hhbmdlTGlzdGVuZXI7Ci0KLQkvKioKLQkgKiBUaGlzIGZsYWcgaW5kaWNhdGVzIHdoZXRoZXIgb3VyIGJ1ZmZlcmVkIHZhbHVlIGhhcyBiZWVuIGFzc2lnbmVkCi0JICogYSB2YWx1ZSBhbmQgaXMgcG9zc2libHkgb3V0IG9mIHN5bmNoIHdpdGggdGhlIHdyYXBwZWQgdmFsdWUuCi0JICovCi0JcHJvdGVjdGVkIGJvb2xlYW4gYnVmZmVyaW5nOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBidWZmZXJlZCBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCB3aXRoIHRoZSBzcGVjaWZpZWQgd3JhcHBlZAotCSAqIHByb3BlcnR5IHZhbHVlIG1vZGVsIGFuZCB0cmlnZ2VyIGhvbGRlci4KLQkgKi8KLQlwdWJsaWMgQnVmZmVyZWRXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbChXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUPiB2YWx1ZUhvbGRlciwgUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IHRyaWdnZXJIb2xkZXIpIHsKLQkJc3VwZXIodmFsdWVIb2xkZXIpOwotCQlpZiAodHJpZ2dlckhvbGRlciA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLnRyaWdnZXJIb2xkZXIgPSB0cmlnZ2VySG9sZGVyOwotCQl0aGlzLmJ1ZmZlcmVkVmFsdWUgPSBudWxsOwotCQl0aGlzLmJ1ZmZlcmluZyA9IGZhbHNlOwotCQl0aGlzLmFjY2VwdGluZyA9IGZhbHNlOwotCQl0aGlzLnRyaWdnZXJDaGFuZ2VMaXN0ZW5lciA9IHRoaXMuYnVpbGRUcmlnZ2VyQ2hhbmdlTGlzdGVuZXIoKTsKLQl9Ci0JCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkVHJpZ2dlckNoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUJ1ZmZlcmVkV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWwudGhpcy50cmlnZ2VyQ2hhbmdlZChldmVudCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJ0cmlnZ2VyIGNoYW5nZSBsaXN0ZW5lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCi0JLy8gKioqKioqKioqKiBWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIElmIHdlIGFyZSBjdXJyZW50bHkgImJ1ZmZlcmluZyIgYSB2YWx1ZSwgcmV0dXJuIHRoYXQ7Ci0JICogb3RoZXJ3aXNlLCByZXR1cm4gdGhlIHdyYXBwZWQgdmFsdWUuCi0JICovCi0JcHVibGljIFQgZ2V0VmFsdWUoKSB7Ci0JCXJldHVybiB0aGlzLmJ1ZmZlcmluZyA/IHRoaXMuYnVmZmVyZWRWYWx1ZSA6IHRoaXMudmFsdWVIb2xkZXIuZ2V0VmFsdWUoKTsKLQl9Ci0KLQkvKioKLQkgKiBBc3NpZ24gdGhlIG5ldyB2YWx1ZSB0byBvdXIgImJ1ZmZlcmVkIiB2YWx1ZS4KLQkgKiBJdCB3aWxsIGJlIGZvcndhcmRlZCB0byB0aGUgd3JhcHBlZCB2YWx1ZSBob2xkZXIKLQkgKiB3aGVuIHRoZSB0cmlnZ2VyIGlzICJhY2NlcHRlZCIuCi0JICovCi0JcHVibGljIHZvaWQgc2V0VmFsdWUoVCB2YWx1ZSkgewotCQlPYmplY3Qgb2xkID0gdGhpcy5nZXRWYWx1ZSgpOwotCQl0aGlzLmJ1ZmZlcmVkVmFsdWUgPSB2YWx1ZTsKLQkJdGhpcy5idWZmZXJpbmcgPSB0cnVlOwotCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoVkFMVUUsIG9sZCwgdGhpcy5idWZmZXJlZFZhbHVlKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogUHJvcGVydHlWYWx1ZU1vZGVsV3JhcHBlciBleHRlbnNpb25zICoqKioqKioqKioKLQotCS8qKgotCSAqIGV4dGVuZCB0byBlbmdhZ2UgdGhlIHRyaWdnZXIgaG9sZGVyIGFsc28KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VWYWx1ZUhvbGRlcigpIHsKLQkJc3VwZXIuZW5nYWdlVmFsdWVIb2xkZXIoKTsKLQkJdGhpcy50cmlnZ2VySG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoVkFMVUUsIHRoaXMudHJpZ2dlckNoYW5nZUxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBleHRlbmQgdG8gZGlzZW5nYWdlIHRoZSB0cmlnZ2VyIGhvbGRlciBhbHNvCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZGlzZW5nYWdlVmFsdWVIb2xkZXIoKSB7Ci0JCXRoaXMudHJpZ2dlckhvbGRlci5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFZBTFVFLCB0aGlzLnRyaWdnZXJDaGFuZ2VMaXN0ZW5lcik7Ci0JCXN1cGVyLmRpc2VuZ2FnZVZhbHVlSG9sZGVyKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCS8qKgotCSAqIElmIHdlIGRvIG5vdCB5ZXQgaGF2ZSBhICJidWZmZXJlZCIgdmFsdWUsIHNpbXBseSBwcm9wYWdhdGUgdGhlCi0JICogY2hhbmdlIG5vdGlmaWNhdGlvbiB3aXRoIHRoZSBidWZmZXJlZCBtb2RlbCBhcyB0aGUgc291cmNlLgotCSAqIElmIHdlIGRvIGhhdmUgYSAiYnVmZmVyZWQiIHZhbHVlLCBkbyBub3RoaW5nLgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHZhbHVlQ2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCWlmICh0aGlzLmFjY2VwdGluZykgewotCQkJLy8gaWYgd2UgYXJlIGN1cnJlbnRseSAiYWNjZXB0aW5nIiB0aGUgdmFsdWUsIGlnbm9yZSBjaGFuZ2Ugbm90aWZpY2F0aW9ucywKLQkJCS8vIHNpbmNlIHdlIGNhdXNlZCB0aGVtIGFuZCBvdXIgb3duIGxpc3RlbmVycyBhcmUgYWxyZWFkeSBhd2FyZSBvZiB0aGUgY2hhbmdlCi0JCQlyZXR1cm47Ci0JCX0KLQkJaWYgKHRoaXMuYnVmZmVyaW5nKSB7Ci0JCQl0aGlzLmhhbmRsZUNoYW5nZUNvbmZsaWN0KGV2ZW50KTsKLQkJfSBlbHNlIHsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChldmVudC5jbG9uZVdpdGhTb3VyY2UodGhpcykpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIEJ5IGRlZmF1bHQsIGlmIHdlIGhhdmUgYSAiYnVmZmVyZWQiIHZhbHVlIGFuZCB0aGUgIndyYXBwZWQiIHZhbHVlIGNoYW5nZXMsCi0JICogd2Ugc2ltcGx5IGlnbm9yZSB0aGUgbmV3ICJ3cmFwcGVkIiB2YWx1ZSBhbmQgc2ltcGx5IG92ZXJsYXkgaXQgd2l0aCB0aGUKLQkgKiAiYnVmZmVyZWQiIHZhbHVlIGlmIGl0IGlzICJhY2NlcHRlZCIuICgiTGFzdCBPbmUgSW4gV2lucyIgY29uY3VycmVuY3kgbW9kZWwpCi0JICogU3ViY2xhc3NlcyBjYW4gb3ZlcnJpZGUgdGhpcyBtZXRob2QgdG8gY2hhbmdlIHRoYXQgYmVoYXZpb3Igd2l0aCBhCi0JICogZGlmZmVyZW50IGNvbmN1cnJlbmN5IG1vZGVsLiBGb3IgZXhhbXBsZSwgeW91IGNvdWxkIGRyb3AgdGhlICJidWZmZXJlZCIgdmFsdWUKLQkgKiBhbmQgcmVwbGFjZSBpdCB3aXRoIHRoZSBuZXcgIndyYXBwZWQiIHZhbHVlLCBvciB5b3UgY291bGQgdGhyb3cgYW4KLQkgKiBleGNlcHRpb24uCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgaGFuZGxlQ2hhbmdlQ29uZmxpY3QoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCkgewotCQkvLyB0aGUgZGVmYXVsdCBpcyB0byBkbyBub3RoaW5nCi0JfQotCQotCS8qKgotCSAqIFRoZSB0cmlnZ2VyIGNoYW5nZWQ6Ci0JICogSWYgaXQgaXMgbm93IHRydWUsICJhY2NlcHQiIHRoZSBidWZmZXJlZCB2YWx1ZSBhbmQgZm9yd2FyZAotCSAqIGl0IHRvIHRoZSB3cmFwcGVkIHZhbHVlIGhvbGRlci4KLQkgKiBJZiBpdCBpcyBub3cgZmFsc2UsICJyZXNldCIgdGhlIGJ1ZmZlcmVkIHZhbHVlIHRvIGl0cyBvcmlnaW5hbCB2YWx1ZS4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCB0cmlnZ2VyQ2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCWlmICggISB0aGlzLmJ1ZmZlcmluZykgewotCQkJLy8gaWYgbm90aGluZyBoYXMgYmVlbiAiYnVmZmVyZWQiLCB3ZSBkb24ndCBuZWVkIHRvIGRvIGFueXRoaW5nOgotCQkJLy8gbm90aGluZyBuZWVkcyB0byBiZSBwYXNzZWQgdGhyb3VnaDsgbm90aGluZyBuZWVkcyB0byBiZSByZXNldDsKLQkJCXJldHVybjsKLQkJfQotCQlpZiAoKChCb29sZWFuKSBldmVudC5nZXROZXdWYWx1ZSgpKS5ib29sZWFuVmFsdWUoKSkgewotCQkJLy8gc2V0IHRoZSBhY2NlcHRpbmcgZmxhZyBzbyB3ZSBpZ25vcmUgYW55IGV2ZW50cwotCQkJLy8gZmlyZWQgYnkgdGhlIHdyYXBwZWQgdmFsdWUgaG9sZGVyCi0JCQl0aGlzLmFjY2VwdGluZyA9IHRydWU7Ci0JCQl0aGlzLnZhbHVlSG9sZGVyKCkuc2V0VmFsdWUodGhpcy5idWZmZXJlZFZhbHVlKTsKLQkJCXRoaXMuYnVmZmVyZWRWYWx1ZSA9IG51bGw7Ci0JCQl0aGlzLmJ1ZmZlcmluZyA9IGZhbHNlOwotCQkJLy8gY2xlYXIgdGhlIGZsYWcgb25jZSB0aGUgImFjY2VwdCIgaXMgY29tcGxldGUKLQkJCXRoaXMuYWNjZXB0aW5nID0gZmFsc2U7Ci0JCX0gZWxzZSB7Ci0JCQkvLyBub3RpZnkgb3VyIGxpc3RlbmVycyB0aGF0IG91ciB2YWx1ZSBoYXMgYmVlbiByZXNldAotCQkJT2JqZWN0IG9sZCA9IHRoaXMuYnVmZmVyZWRWYWx1ZTsKLQkJCXRoaXMuYnVmZmVyZWRWYWx1ZSA9IG51bGw7Ci0JCQl0aGlzLmJ1ZmZlcmluZyA9IGZhbHNlOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKFZBTFVFLCBvbGQsIHRoaXMudmFsdWVIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCX0KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0b1N0cmluZyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXNiLmFwcGVuZCh0aGlzLmdldFZhbHVlKCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBjb252ZW5pZW5jZSBtZXRob2RzICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBidWZmZXJlZCBtb2RlbCBpcyBjdXJyZW50bHkgImJ1ZmZlcmluZyIKLQkgKiBhIHZhbHVlLgotCSAqLwotCXB1YmxpYyBib29sZWFuIGlzQnVmZmVyaW5nKCkgewotCQlyZXR1cm4gdGhpcy5idWZmZXJpbmc7Ci0JfQotCi0JLyoqCi0JICogT3VyIGNvbnN0cnVjdG9yIGFjY2VwdHMgb25seSBhIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQ+LgotCSAqLwotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByb3RlY3RlZCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUPiB2YWx1ZUhvbGRlcigpIHsKLQkJcmV0dXJuIChXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUPikgdGhpcy52YWx1ZUhvbGRlcjsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5uZXIgY2xhc3MgKioqKioqKioqKgotCi0JLyoqCi0JICogVHJpZ2dlciBpcyBhIHNwZWNpYWwgcHJvcGVydHkgdmFsdWUgbW9kZWwgdGhhdCBvbmx5IG1haW50YWlucyBpdHMKLQkgKiB2YWx1ZSAob2YgdHJ1ZSBvciBmYWxzZSkgZHVyaW5nIHRoZSBjaGFuZ2Ugbm90aWZpY2F0aW9uIGNhdXNlZCBieQotCSAqIHRoZSAjc2V0VmFsdWUoT2JqZWN0KSBtZXRob2QuIEluIG90aGVyIHdvcmRzLCBhIFRyaWdnZXIgb2JqZWN0Ci0JICogb25seSBoYXMgYSB2YWxpZCB2YWx1ZSAKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNsYXNzIFRyaWdnZXIgZXh0ZW5kcyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gewotCi0KLQkJLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvciAqKioqKioqKioqCi0KLQkJLyoqCi0JCSAqIENvbnN0cnVjdCBhIHRyaWdnZXIgd2l0aCBhIG51bGwgdmFsdWUuCi0JCSAqLwotCQlwdWJsaWMgVHJpZ2dlcigpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQotCi0JCS8vICoqKioqKioqKiogVmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQkJLyoqCi0JCSAqIEV4dGVuZCBzbyB0aGF0IHRoaXMgbWV0aG9kIGNhbiBvbmx5IGJlIGludm9rZWQgZHVyaW5nCi0JCSAqIGNoYW5nZSBub3RpZmljYXRpb24gdHJpZ2dlcmVkIGJ5ICNzZXRWYWx1ZShPYmplY3QpLgotCQkgKi8KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBCb29sZWFuIGdldFZhbHVlKCkgewotCQkJaWYgKHRoaXMudmFsdWUgPT0gbnVsbCkgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oIlRoZSBtZXRob2QgVHJpZ2dlci52YWx1ZSgpIG1heSBvbmx5IGJlIGNhbGxlZCBkdXJpbmcgY2hhbmdlIG5vdGlmaWNhdGlvbi4iKTsKLQkJCX0KLQkJCXJldHVybiB0aGlzLnZhbHVlOwotCQl9Ci0KLQkJLyoqCi0JCSAqIEV4dGVuZCB0byByZXNldCB0aGUgdmFsdWUgdG8gbnVsbCBvbmNlIGFsbCB0aGUKLQkJICogbGlzdGVuZXJzIGhhdmUgYmVlbiBub3RpZmllZC4KLQkJICovCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgdm9pZCBzZXRWYWx1ZShCb29sZWFuIHZhbHVlKSB7Ci0JCQlzdXBlci5zZXRWYWx1ZSh2YWx1ZSk7Ci0JCQl0aGlzLnZhbHVlID0gbnVsbDsKLQkJfQotCi0KLQkJLy8gKioqKioqKioqKiBjb252ZW5pZW5jZSBtZXRob2RzICoqKioqKioqKioKLQotCQkvKioKLQkJICogU2V0IHRoZSB0cmlnZ2VyJ3MgdmFsdWU6Ci0JCSAqIAktIHRydWUgaW5kaWNhdGVzICJhY2NlcHQiCi0JCSAqIAktIGZhbHNlIGluZGljYXRlcyAicmVzZXQiCi0JCSAqLwotCQlwdWJsaWMgdm9pZCBzZXRWYWx1ZShib29sZWFuIHZhbHVlKSB7Ci0JCQl0aGlzLnNldFZhbHVlKEJvb2xlYW4udmFsdWVPZih2YWx1ZSkpOwotCQl9Ci0KLQkJLyoqCi0JCSAqIFJldHVybiB0aGUgdHJpZ2dlcidzIHZhbHVlOgotCQkgKiAJLSB0cnVlIGluZGljYXRlcyAiYWNjZXB0IgotCQkgKiAJLSBmYWxzZSBpbmRpY2F0ZXMgInJlc2V0IgotCQkgKi8KLQkJcHVibGljIGJvb2xlYW4gYm9vbGVhblZhbHVlKCkgewotCQkJcmV0dXJuIHRoaXMuZ2V0VmFsdWUoKS5ib29sZWFuVmFsdWUoKTsKLQkJfQotCi0JCS8qKgotCQkgKiBBY2NlcHQgdGhlIHRyaWdnZXIgKGkuZS4gc2V0IGl0cyB2YWx1ZSB0byB0cnVlKS4KLQkJICovCi0JCXB1YmxpYyB2b2lkIGFjY2VwdCgpIHsKLQkJCXRoaXMuc2V0VmFsdWUodHJ1ZSk7Ci0JCX0KLQotCQkvKioKLQkJICogUmV0dXJuIHdoZXRoZXIgdGhlIHRyaWdnZXIgaGFzIGJlZW4gYWNjZXB0ZWQKLQkJICogKGkuZS4gaXRzIHZhbHVlIHdhcyBjaGFuZ2VkIHRvIHRydWUpLgotCQkgKi8KLQkJcHVibGljIGJvb2xlYW4gaXNBY2NlcHRlZCgpIHsKLQkJCXJldHVybiB0aGlzLmJvb2xlYW5WYWx1ZSgpOwotCQl9Ci0KLQkJLyoqCi0JCSAqIFJlc2V0IHRoZSB0cmlnZ2VyIChpLmUuIHNldCBpdHMgdmFsdWUgdG8gZmFsc2UpLgotCQkgKi8KLQkJcHVibGljIHZvaWQgcmVzZXQoKSB7Ci0JCQl0aGlzLnNldFZhbHVlKGZhbHNlKTsKLQkJfQotCi0JCS8qKgotCQkgKiBSZXR1cm4gd2hldGhlciB0aGUgdHJpZ2dlciBoYXMgYmVlbiByZXNldAotCQkgKiAoaS5lLiBpdHMgdmFsdWUgd2FzIGNoYW5nZWQgdG8gZmFsc2UpLgotCQkgKi8KLQkJcHVibGljIGJvb2xlYW4gaXNSZXNldCgpIHsKLQkJCXJldHVybiAhIHRoaXMuYm9vbGVhblZhbHVlKCk7Ci0JCX0KLQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0NhY2hpbmdUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0NhY2hpbmdUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhMmQxZTYxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9DYWNoaW5nVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDExMiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuVHJhbnNmb3JtZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIEEgPGNvZGU+Q2FjaGluZ1RyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPC9jb2RlPiB3cmFwcyBhbm90aGVyCi0gKiA8Y29kZT5Qcm9wZXJ0eVZhbHVlTW9kZWw8L2NvZGU+IGFuZCB1c2VzIGEgPGNvZGU+VHJhbnNmb3JtZXI8L2NvZGU+Ci0gKiB0byB0cmFuc2Zvcm0gdGhlIHdyYXBwZWQgdmFsdWUgYmVmb3JlIGl0IGlzIHJldHVybmVkIGJ5IDxjb2RlPmdldFZhbHVlKCk8L2NvZGU+LgotICogVGhlIHRyYW5zZm9ybWVkIHZhbHVlIGlzIGNhbGN1bGF0ZWQgYW5kIGNhY2hlZCBkdXJpbmcgaW5pdGlhbGl6YXRpb24gYW5kIGV2ZXJ5Ci0gKiB0aW1lIHRoZSB3cmFwcGVkIHZhbHVlIGNoYW5nZXMuIFRoaXMgY2FuIGJlIHVzZWZ1bCB3aGVuIHRoZSBvbGQgdmFsdWUKLSAqIHBhc3NlZCBpbiB0byA8Y29kZT52YWx1ZUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCk8L2NvZGU+IGNhbiBubyBsb25nZXIKLSAqIGJlICJ0cmFuc2Zvcm1lZCIgYmVjYXVzZSBpdHMgc3RhdGUgaXMgbm8gbG9uZ2VyIHZhbGlkLgotICogVGhpcyBjYWNoaW5nIGNhbiBhbHNvIGltcHJvdmUgdGltZSBwZXJmb3JtYW5jZSBpbiBzb21lIHNpdHVhdGlvbnMuCi0gKiA8cD4KLSAqIEFzIGFuIGFsdGVybmF0aXZlIHRvIGJ1aWxkaW5nIGEgPGNvZGU+VHJhbnNmb3JtZXI8L2NvZGU+LAotICogYSBzdWJjbGFzcyBvZiA8Y29kZT5DYWNoaW5nVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8L2NvZGU+IGNhbgotICogZWl0aGVyIG92ZXJyaWRlIHRoZSA8Y29kZT50cmFuc2Zvcm1fKE9iamVjdCk8L2NvZGU+IG1ldGhvZCBvciwKLSAqIGlmIHNvbWV0aGluZyBvdGhlciB0aGFuIG51bGwgc2hvdWxkIGJlIHJldHVybmVkIHdoZW4gdGhlIHdyYXBwZWQgdmFsdWUKLSAqIGlzIG51bGwsIG92ZXJyaWRlIHRoZSA8Y29kZT50cmFuc2Zvcm0oT2JqZWN0KTwvY29kZT4gbWV0aG9kLgotICovCi1wdWJsaWMgY2xhc3MgQ2FjaGluZ1RyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPFQxLCBUMj4KLQlleHRlbmRzIFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPFQxLCBUMj4KLXsKLQotCS8qKgotCSAqIENhY2hlIHRoZSB0cmFuc2Zvcm1lZCB2YWx1ZSBzbyB0aGF0IGR1cmluZyBwcm9wZXJ0eSBjaGFuZ2UgZXZlbnQgbm90aWZpY2F0aW9uCi0JICogd2UgZG8gbm90IGhhdmUgdG8gdHJhbnNmb3JtIHRoZSBvbGQgdmFsdWUuIFRoZSBvbGQgdmFsdWUgY291bGQgbm8gbG9uZ2VyIGJlIHZhbGlkIGluCi0JICogdGhlIG1vZGVsOyBhcyBhIHJlc3VsdCwgdHJhbnNmb3JtaW5nIGl0IHdvdWxkIG5vdCBiZSB2YWxpZC4KLQkgKi8KLQlwcm90ZWN0ZWQgVDIgY2FjaGVkVmFsdWU7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHByb3BlcnR5IHZhbHVlIG1vZGVsIHdpdGggdGhlIHNwZWNpZmllZCBuZXN0ZWQKLQkgKiBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCBhbmQgdGhlIGRlZmF1bHQgdHJhbnNmb3JtZXIuCi0JICogVXNlIHRoaXMgY29uc3RydWN0b3IgaWYgeW91IHdhbnQgdG8gb3ZlcnJpZGUgdGhlCi0JICogPGNvZGU+dHJhbnNmb3JtXyhPYmplY3QpPC9jb2RlPiBvciA8Y29kZT50cmFuc2Zvcm0oT2JqZWN0KTwvY29kZT4KLQkgKiBtZXRob2QgaW5zdGVhZCBvZiBidWlsZGluZyBhIDxjb2RlPlRyYW5zZm9ybWVyPC9jb2RlPi4KLQkgKi8KLQlwdWJsaWMgQ2FjaGluZ1RyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgVDE+IHZhbHVlSG9sZGVyKSB7Ci0JCXN1cGVyKHZhbHVlSG9sZGVyKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gcHJvcGVydHkgdmFsdWUgbW9kZWwgd2l0aCB0aGUgc3BlY2lmaWVkIG5lc3RlZAotCSAqIHByb3BlcnR5IHZhbHVlIG1vZGVsIGFuZCB0cmFuc2Zvcm1lci4KLQkgKi8KLQlwdWJsaWMgQ2FjaGluZ1RyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgVDE+IHZhbHVlSG9sZGVyLCBUcmFuc2Zvcm1lcjxUMSwgVDI+IHRyYW5zZm9ybWVyKSB7Ci0JCXN1cGVyKHZhbHVlSG9sZGVyLCB0cmFuc2Zvcm1lcik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCS8qKgotCSAqIFdlIGhhdmUgbGlzdGVuZXJzLCB0cmFuc2Zvcm0gdGhlIG5lc3RlZCB2YWx1ZSBhbmQgY2FjaGUgdGhlIHJlc3VsdC4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VWYWx1ZUhvbGRlcigpIHsKLQkJc3VwZXIuZW5nYWdlVmFsdWVIb2xkZXIoKTsKLQkJdGhpcy5jYWNoZWRWYWx1ZSA9IHRoaXMudHJhbnNmb3JtKHRoaXMudmFsdWVIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JfQotCi0JLyoqCi0JICogV2UgaGF2ZSBubyBtb3JlIGxpc3RlbmVycywgY2xlYXIgdGhlIGNhY2hlZCB2YWx1ZS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VWYWx1ZUhvbGRlcigpIHsKLQkJdGhpcy5jYWNoZWRWYWx1ZSA9IG51bGw7Ci0JCXN1cGVyLmRpc2VuZ2FnZVZhbHVlSG9sZGVyKCk7Ci0JfQotCi0JLyoqCi0JICogTm8gbmVlZCB0byB0cmFuc2Zvcm0gdGhlIG5lc3RlZCB2YWx1ZSwgc2ltcGx5IHJldHVybiB0aGUgY2FjaGVkIHZhbHVlLAotCSAqIHdoaWNoIGlzIGFscmVhZHkgdHJhbnNmb3JtZWQuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIFQyIGdldFZhbHVlKCkgewotCQlyZXR1cm4gdGhpcy5jYWNoZWRWYWx1ZTsKLQl9Ci0KLQkvKioKLQkgKiBUcmFuc2Zvcm0gdGhlIHNwZWNpZmllZCBuZXcgdmFsdWUsIGNhY2hpbmcgaXQgYmVmb3JlIHJldHVybmluZyBpdC4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgVDIgdHJhbnNmb3JtTmV3KFQxIHZhbHVlKSB7Ci0JCXRoaXMuY2FjaGVkVmFsdWUgPSBzdXBlci50cmFuc2Zvcm1OZXcodmFsdWUpOwotCQlyZXR1cm4gdGhpcy5jYWNoZWRWYWx1ZTsKLQl9Ci0KLQkvKioKLQkgKiBObyBuZWVkIHRvIHRyYW5zZm9ybSB0aGUgb2xkIHZhbHVlLCBzaW1wbHkgcmV0dXJuIHRoZSBjYWNoZWQgdmFsdWUsCi0JICogd2hpY2ggaXMgYWxyZWFkeSB0cmFuc2Zvcm1lZC4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgVDIgdHJhbnNmb3JtT2xkKFQxIHZhbHVlKSB7Ci0JCXJldHVybiB0aGlzLmNhY2hlZFZhbHVlOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0NhY2hpbmdUcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ2FjaGluZ1RyYW5zZm9ybWF0aW9uV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWwuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMThiNmNlMC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ2FjaGluZ1RyYW5zZm9ybWF0aW9uV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEwNyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQmlkaVRyYW5zZm9ybWVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIEEgPGNvZGU+Q2FjaGluZ1RyYW5zZm9ybWF0aW9uV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Y29kZT4gYXVnbWVudHMgdGhlCi0gKiBiZWhhdmlvciBvZiBhIDxjb2RlPlRyYW5zZm9ybWF0aW9uV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Y29kZT4gYnkgY2FjaGluZwotICogdGhlIHRyYW5zZm9ybWVkIHZhbHVlLgotICogVGhlIHRyYW5zZm9ybWVkIHZhbHVlIGlzIGNhbGN1bGF0ZWQgYW5kIGNhY2hlZCBkdXJpbmcgaW5pdGlhbGl6YXRpb24gYW5kIGV2ZXJ5Ci0gKiB0aW1lIHRoZSB3cmFwcGVkIHZhbHVlIGNoYW5nZXMuIFRoaXMgY2FuIGJlIHVzZWZ1bCB3aGVuIHRoZSBvbGQgdmFsdWUKLSAqIHBhc3NlZCBpbiB0byA8Y29kZT52YWx1ZUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCk8L2NvZGU+IGNhbiBubyBsb25nZXIKLSAqIGJlICJ0cmFuc2Zvcm1lZCIgYmVjYXVzZSBpdHMgc3RhdGUgaXMgbm8gbG9uZ2VyIHZhbGlkLgotICogVGhpcyBjYWNoaW5nIGNhbiBhbHNvIGltcHJvdmUgdGltZSBwZXJmb3JtYW5jZSBpbiBzb21lIHNpdHVhdGlvbnMuCi0gKi8KLXB1YmxpYyBjbGFzcyBDYWNoaW5nVHJhbnNmb3JtYXRpb25Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUMSwgVDI+Ci0JZXh0ZW5kcyBUcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQxLCBUMj4KLXsKLQotCS8qKgotCSAqIENhY2hlIHRoZSB0cmFuc2Zvcm1lZCB2YWx1ZSBzbyB0aGF0IGR1cmluZyBwcm9wZXJ0eSBjaGFuZ2UgZXZlbnQgbm90aWZpY2F0aW9uCi0JICogd2UgZG8gbm90IGhhdmUgdG8gdHJhbnNmb3JtIHRoZSBvbGQgdmFsdWUuIFRoZSBvbGQgdmFsdWUgY291bGQgbm8gbG9uZ2VyIGJlIHZhbGlkIGluCi0JICogdGhlIG1vZGVsOyBhcyBhIHJlc3VsdCwgdHJhbnNmb3JtaW5nIGl0IHdvdWxkIG5vdCBiZSB2YWxpZC4KLQkgKi8KLQlwcm90ZWN0ZWQgVDIgY2FjaGVkVmFsdWU7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHdyaXRhYmxlIHByb3BlcnR5IHZhbHVlIG1vZGVsIHdpdGggdGhlIHNwZWNpZmllZCBuZXN0ZWQKLQkgKiB3cml0YWJsZSBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCBhbmQgdGhlIGRlZmF1bHQgYmlkaSB0cmFuc2Zvcm1lci4KLQkgKiBVc2UgdGhpcyBjb25zdHJ1Y3RvciBpZiB5b3Ugd2FudCB0byBvdmVycmlkZSB0aGUKLQkgKiA8Y29kZT50cmFuc2Zvcm1fKE9iamVjdCk8L2NvZGU+IGFuZCA8Y29kZT5yZXZlcnNlVHJhbnNmb3JtXyhPYmplY3QpPC9jb2RlPgotCSAqIChvciA8Y29kZT50cmFuc2Zvcm0oT2JqZWN0KTwvY29kZT4gYW5kIDxjb2RlPnJldmVyc2VUcmFuc2Zvcm0oT2JqZWN0KTwvY29kZT4pCi0JICogbWV0aG9kcyBpbnN0ZWFkIG9mIGJ1aWxkaW5nIGEgPGNvZGU+QmlkaVRyYW5zZm9ybWVyPC9jb2RlPi4KLQkgKi8KLQlwdWJsaWMgQ2FjaGluZ1RyYW5zZm9ybWF0aW9uV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWwoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VDE+IHZhbHVlSG9sZGVyKSB7Ci0JCXN1cGVyKHZhbHVlSG9sZGVyKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSB3cml0YWJsZSBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCB3aXRoIHRoZSBzcGVjaWZpZWQgbmVzdGVkCi0JICogd3JpdGFibGUgcHJvcGVydHkgdmFsdWUgbW9kZWwgYW5kIGJpZGkgdHJhbnNmb3JtZXIuCi0JICovCi0JcHVibGljIENhY2hpbmdUcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQxPiB2YWx1ZUhvbGRlciwgQmlkaVRyYW5zZm9ybWVyPFQxLCBUMj4gdHJhbnNmb3JtZXIpIHsKLQkJc3VwZXIodmFsdWVIb2xkZXIsIHRyYW5zZm9ybWVyKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCi0JLyoqCi0JICogV2UgaGF2ZSBsaXN0ZW5lcnMsIHRyYW5zZm9ybSB0aGUgbmVzdGVkIHZhbHVlIGFuZCBjYWNoZSB0aGUgcmVzdWx0LgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGVuZ2FnZVZhbHVlSG9sZGVyKCkgewotCQlzdXBlci5lbmdhZ2VWYWx1ZUhvbGRlcigpOwotCQl0aGlzLmNhY2hlZFZhbHVlID0gdGhpcy50cmFuc2Zvcm0odGhpcy52YWx1ZUhvbGRlci5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBXZSBoYXZlIG5vIG1vcmUgbGlzdGVuZXJzLCBjbGVhciB0aGUgY2FjaGVkIHZhbHVlLgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZVZhbHVlSG9sZGVyKCkgewotCQl0aGlzLmNhY2hlZFZhbHVlID0gbnVsbDsKLQkJc3VwZXIuZGlzZW5nYWdlVmFsdWVIb2xkZXIoKTsKLQl9Ci0KLQkvKioKLQkgKiBObyBuZWVkIHRvIHRyYW5zZm9ybSB0aGUgbmVzdGVkIHZhbHVlLCBzaW1wbHkgcmV0dXJuIHRoZSBjYWNoZWQgdmFsdWUsCi0JICogd2hpY2ggaXMgYWxyZWFkeSB0cmFuc2Zvcm1lZC4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgVDIgZ2V0VmFsdWUoKSB7Ci0JCXJldHVybiB0aGlzLmNhY2hlZFZhbHVlOwotCX0KLQotCS8qKgotCSAqIFRyYW5zZm9ybSB0aGUgc3BlY2lmaWVkIG5ldyB2YWx1ZSwgY2FjaGluZyBpdCBiZWZvcmUgcmV0dXJuaW5nIGl0LgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCBUMiB0cmFuc2Zvcm1OZXcoVDEgdmFsdWUpIHsKLQkJdGhpcy5jYWNoZWRWYWx1ZSA9IHN1cGVyLnRyYW5zZm9ybU5ldyh2YWx1ZSk7Ci0JCXJldHVybiB0aGlzLmNhY2hlZFZhbHVlOwotCX0KLQotCS8qKgotCSAqIE5vIG5lZWQgdG8gdHJhbnNmb3JtIHRoZSBvbGQgdmFsdWUsIHNpbXBseSByZXR1cm4gdGhlIGNhY2hlZCB2YWx1ZSwKLQkgKiB3aGljaCBpcyBhbHJlYWR5IHRyYW5zZm9ybWVkLgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCBUMiB0cmFuc2Zvcm1PbGQoVDEgdmFsdWUpIHsKLQkJcmV0dXJuIHRoaXMuY2FjaGVkVmFsdWU7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ29sbGVjdGlvbkFzcGVjdEFkYXB0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Db2xsZWN0aW9uQXNwZWN0QWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmNTU3ODNlLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Db2xsZWN0aW9uQXNwZWN0QWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjM4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlzOwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkVtcHR5SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuQ29sbGVjdGlvbkNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci0KLS8qKgotICogVGhpcyBleHRlbnNpb24gb2YgQXNwZWN0QWRhcHRlciBwcm92aWRlcyBDb2xsZWN0aW9uQ2hhbmdlIHN1cHBvcnQuCi0gKiBUaGlzIGFsbG93cyB1cyB0byBjb252ZXJ0IGEgc2V0IG9mIG9uZSBvciBtb3JlIGNvbGxlY3Rpb25zIGludG8KLSAqIGEgc2luZ2xlIGNvbGxlY3Rpb24sIFZBTFVFUy4KLSAqIAotICogVGhlIHR5cGljYWwgc3ViY2xhc3Mgd2lsbCBvdmVycmlkZSB0aGUgZm9sbG93aW5nIG1ldGhvZHM6Ci0gKiAjaXRlcmF0b3JfKCkKLSAqICAgICBhdCB0aGUgdmVyeSBtaW5pbXVtLCBvdmVycmlkZSB0aGlzIG1ldGhvZCB0byByZXR1cm4gYW4gaXRlcmF0b3Igb24gdGhlCi0gKiAgICAgc3ViamVjdCdzIGNvbGxlY3Rpb24gYXNwZWN0OyBpdCBkb2VzIG5vdCBuZWVkIHRvIGJlIG92ZXJyaWRkZW4gaWYKLSAqICAgICAjaXRlcmF0b3IoKSBpcyBvdmVycmlkZGVuIGFuZCBpdHMgYmVoYXZpb3IgY2hhbmdlZAotICogI3NpemVfKCkKLSAqICAgICBvdmVycmlkZSB0aGlzIG1ldGhvZCB0byBpbXByb3ZlIHBlcmZvcm1hbmNlOyBpdCBkb2VzIG5vdCBuZWVkIHRvIGJlIG92ZXJyaWRkZW4gaWYKLSAqICAgICAjc2l6ZSgpIGlzIG92ZXJyaWRkZW4gYW5kIGl0cyBiZWhhdmlvciBjaGFuZ2VkCi0gKiAjaXRlcmF0b3IoKQotICogICAgIG92ZXJyaWRlIHRoaXMgbWV0aG9kIG9ubHkgaWYgcmV0dXJuaW5nIGFuIGVtcHR5IGl0ZXJhdG9yIHdoZW4gdGhlCi0gKiAgICAgc3ViamVjdCBpcyBudWxsIGlzIHVuYWNjZXB0YWJsZQotICogI3NpemUoKQotICogICAgIG92ZXJyaWRlIHRoaXMgbWV0aG9kIG9ubHkgaWYgcmV0dXJuaW5nIGEgemVybyB3aGVuIHRoZQotICogICAgIHN1YmplY3QgaXMgbnVsbCBpcyB1bmFjY2VwdGFibGUKLSAqLwotcHVibGljIGFic3RyYWN0IGNsYXNzIENvbGxlY3Rpb25Bc3BlY3RBZGFwdGVyPFMgZXh0ZW5kcyBNb2RlbCwgRT4KLQlleHRlbmRzIEFzcGVjdEFkYXB0ZXI8Uz4KLQlpbXBsZW1lbnRzIENvbGxlY3Rpb25WYWx1ZU1vZGVsPEU+Ci17Ci0JLyoqCi0JICogVGhlIG5hbWUgb2YgdGhlIHN1YmplY3QncyBjb2xsZWN0aW9ucyB0aGF0IHdlIHVzZSBmb3IgdGhlIHZhbHVlLgotCSAqLwotCXByb3RlY3RlZCBmaW5hbCBTdHJpbmdbXSBjb2xsZWN0aW9uTmFtZXM7Ci0JCXByb3RlY3RlZCBzdGF0aWMgZmluYWwgU3RyaW5nW10gRU1QVFlfQ09MTEVDVElPTl9OQU1FUyA9IG5ldyBTdHJpbmdbMF07Ci0KLQkvKiogQSBsaXN0ZW5lciB0aGF0IGxpc3RlbnMgdG8gdGhlIHN1YmplY3QncyBjb2xsZWN0aW9uIGFzcGVjdC4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgQ29sbGVjdGlvbkFzcGVjdEFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgc3ViamVjdAotCSAqIGFuZCBjb2xsZWN0aW9uLgotCSAqLwotCXByb3RlY3RlZCBDb2xsZWN0aW9uQXNwZWN0QWRhcHRlcihTdHJpbmcgY29sbGVjdGlvbk5hbWUsIFMgc3ViamVjdCkgewotCQl0aGlzKG5ldyBTdHJpbmdbXSB7Y29sbGVjdGlvbk5hbWV9LCBzdWJqZWN0KTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBDb2xsZWN0aW9uQXNwZWN0QWRhcHRlciBmb3IgdGhlIHNwZWNpZmllZCBzdWJqZWN0Ci0JICogYW5kIGNvbGxlY3Rpb25zLgotCSAqLwotCXByb3RlY3RlZCBDb2xsZWN0aW9uQXNwZWN0QWRhcHRlcihTdHJpbmdbXSBjb2xsZWN0aW9uTmFtZXMsIFMgc3ViamVjdCkgewotCQl0aGlzKG5ldyBTdGF0aWNQcm9wZXJ0eVZhbHVlTW9kZWw8Uz4oc3ViamVjdCksIGNvbGxlY3Rpb25OYW1lcyk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgQ29sbGVjdGlvbkFzcGVjdEFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgc3ViamVjdCBob2xkZXIKLQkgKiBhbmQgY29sbGVjdGlvbnMuCi0JICovCi0JcHJvdGVjdGVkIENvbGxlY3Rpb25Bc3BlY3RBZGFwdGVyKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgUz4gc3ViamVjdEhvbGRlciwgU3RyaW5nLi4uIGNvbGxlY3Rpb25OYW1lcykgewotCQlzdXBlcihzdWJqZWN0SG9sZGVyKTsKLQkJdGhpcy5jb2xsZWN0aW9uTmFtZXMgPSBjb2xsZWN0aW9uTmFtZXM7Ci0JCXRoaXMuY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyID0gdGhpcy5idWlsZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcigpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIENvbGxlY3Rpb25Bc3BlY3RBZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIHN1YmplY3QgaG9sZGVyCi0JICogYW5kIGNvbGxlY3Rpb25zLgotCSAqLwotCXByb3RlY3RlZCBDb2xsZWN0aW9uQXNwZWN0QWRhcHRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFM+IHN1YmplY3RIb2xkZXIsIENvbGxlY3Rpb248U3RyaW5nPiBjb2xsZWN0aW9uTmFtZXMpIHsKLQkJdGhpcyhzdWJqZWN0SG9sZGVyLCBjb2xsZWN0aW9uTmFtZXMudG9BcnJheShuZXcgU3RyaW5nW2NvbGxlY3Rpb25OYW1lcy5zaXplKCldKSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgQ29sbGVjdGlvbkFzcGVjdEFkYXB0ZXIgZm9yIGFuICJ1bmNoYW5naW5nIiBjb2xsZWN0aW9uIGluCi0JICogdGhlIHNwZWNpZmllZCBzdWJqZWN0LiBUaGlzIGlzIHVzZWZ1bCBmb3IgYSBjb2xsZWN0aW9uIGFzcGVjdCB0aGF0IGRvZXMgbm90Ci0JICogY2hhbmdlIGZvciBhIHBhcnRpY3VsYXIgc3ViamVjdDsgYnV0IHRoZSBzdWJqZWN0IHdpbGwgY2hhbmdlLCByZXN1bHRpbmcgaW4KLQkgKiBhIG5ldyBjb2xsZWN0aW9uLgotCSAqLwotCXByb3RlY3RlZCBDb2xsZWN0aW9uQXNwZWN0QWRhcHRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFM+IHN1YmplY3RIb2xkZXIpIHsKLQkJdGhpcyhzdWJqZWN0SG9sZGVyLCBFTVBUWV9DT0xMRUNUSU9OX05BTUVTKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JLyoqCi0JICogVGhlIHN1YmplY3QncyBjb2xsZWN0aW9uIGFzcGVjdCBoYXMgY2hhbmdlZCwgbm90aWZ5IHRoZSBsaXN0ZW5lcnMuCi0JICovCi0JcHJvdGVjdGVkIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBidWlsZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcigpIHsKLQkJLy8gdHJhbnNmb3JtIHRoZSBzdWJqZWN0J3MgY29sbGVjdGlvbiBjaGFuZ2UgZXZlbnRzIGludG8gVkFMVUUgY29sbGVjdGlvbiBjaGFuZ2UgZXZlbnRzCi0JCXJldHVybiBuZXcgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlDb2xsZWN0aW9uQXNwZWN0QWRhcHRlci50aGlzLml0ZW1zQWRkZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUNvbGxlY3Rpb25Bc3BlY3RBZGFwdGVyLnRoaXMuaXRlbXNSZW1vdmVkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGNvbGxlY3Rpb25DbGVhcmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUNvbGxlY3Rpb25Bc3BlY3RBZGFwdGVyLnRoaXMuY29sbGVjdGlvbkNsZWFyZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNoYW5nZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJQ29sbGVjdGlvbkFzcGVjdEFkYXB0ZXIudGhpcy5jb2xsZWN0aW9uQ2hhbmdlZChldmVudCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJjb2xsZWN0aW9uIGNoYW5nZSBsaXN0ZW5lcjogIiArIEFycmF5cy5hc0xpc3QoQ29sbGVjdGlvbkFzcGVjdEFkYXB0ZXIudGhpcy5jb2xsZWN0aW9uTmFtZXMpOwotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBDb2xsZWN0aW9uVmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGVsZW1lbnRzIG9mIHRoZSBzdWJqZWN0J3MgY29sbGVjdGlvbiBhc3BlY3QuCi0JICovCi0JcHVibGljIEl0ZXJhdG9yPEU+IGl0ZXJhdG9yKCkgewotCQlyZXR1cm4gKHRoaXMuc3ViamVjdCA9PSBudWxsKSA/IEVtcHR5SXRlcmF0b3IuPEU+aW5zdGFuY2UoKSA6IHRoaXMuaXRlcmF0b3JfKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBlbGVtZW50cyBvZiB0aGUgc3ViamVjdCdzIGNvbGxlY3Rpb24gYXNwZWN0LgotCSAqIEF0IHRoaXMgcG9pbnQgd2UgY2FuIGJlIHN1cmUgdGhhdCB0aGUgc3ViamVjdCBpcyBub3QgbnVsbC4KLQkgKiBAc2VlICNpdGVyYXRvcigpCi0JICovCi0JcHJvdGVjdGVkIEl0ZXJhdG9yPEU+IGl0ZXJhdG9yXygpIHsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaXplIG9mIHRoZSBzdWJqZWN0J3MgY29sbGVjdGlvbiBhc3BlY3QuCi0JICovCi0JcHVibGljIGludCBzaXplKCkgewotCQlyZXR1cm4gKHRoaXMuc3ViamVjdCA9PSBudWxsKSA/IDAgOiB0aGlzLnNpemVfKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaXplIG9mIHRoZSBzdWJqZWN0J3MgY29sbGVjdGlvbiBhc3BlY3QuCi0JICogQXQgdGhpcyBwb2ludCB3ZSBjYW4gYmUgc3VyZSB0aGF0IHRoZSBzdWJqZWN0IGlzIG5vdCBudWxsLgotCSAqIEBzZWUgI3NpemUoKQotCSAqLwotCXByb3RlY3RlZCBpbnQgc2l6ZV8oKSB7Ci0JCXJldHVybiBDb2xsZWN0aW9uVG9vbHMuc2l6ZSh0aGlzLml0ZXJhdG9yKCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBBc3BlY3RBZGFwdGVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBPYmplY3QgZ2V0VmFsdWUoKSB7Ci0JCXJldHVybiB0aGlzLml0ZXJhdG9yKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIENsYXNzPD8gZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gZ2V0TGlzdGVuZXJDbGFzcygpIHsKLQkJcmV0dXJuIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lci5jbGFzczsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldExpc3RlbmVyQXNwZWN0TmFtZSgpIHsKLQkJcmV0dXJuIFZBTFVFUzsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgYm9vbGVhbiBoYXNMaXN0ZW5lcnMoKSB7Ci0JCXJldHVybiB0aGlzLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoVkFMVUVTKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBmaXJlQXNwZWN0Q2hhbmdlKE9iamVjdCBvbGRWYWx1ZSwgT2JqZWN0IG5ld1ZhbHVlKSB7Ci0JCXRoaXMuZmlyZUNvbGxlY3Rpb25DaGFuZ2VkKFZBTFVFUyk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlU3ViamVjdF8oKSB7Ci0gICAgCWZvciAoU3RyaW5nIGNvbGxlY3Rpb25OYW1lIDogdGhpcy5jb2xsZWN0aW9uTmFtZXMpIHsKLQkJCSgoTW9kZWwpIHRoaXMuc3ViamVjdCkuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKGNvbGxlY3Rpb25OYW1lLCB0aGlzLmNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcik7Ci0JCX0KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VTdWJqZWN0XygpIHsKLSAgICAJZm9yIChTdHJpbmcgY29sbGVjdGlvbk5hbWUgOiB0aGlzLmNvbGxlY3Rpb25OYW1lcykgewotCQkJKChNb2RlbCkgdGhpcy5zdWJqZWN0KS5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoY29sbGVjdGlvbk5hbWUsIHRoaXMuY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKTsKLQkJfQotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHRvU3RyaW5nKFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCB0aGlzLmNvbGxlY3Rpb25OYW1lcy5sZW5ndGg7IGkrKykgewotCQkJaWYgKGkgIT0gMCkgewotCQkJCXNiLmFwcGVuZCgiLCAiKTsKLQkJCX0KLQkJCXNiLmFwcGVuZCh0aGlzLmNvbGxlY3Rpb25OYW1lc1tpXSk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5maXJlSXRlbXNBZGRlZChldmVudC5jbG9uZVdpdGhTb3VyY2UodGhpcywgVkFMVUVTKSk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNSZW1vdmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmZpcmVJdGVtc1JlbW92ZWQoZXZlbnQuY2xvbmVXaXRoU291cmNlKHRoaXMsIFZBTFVFUykpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGNvbGxlY3Rpb25DbGVhcmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmZpcmVDb2xsZWN0aW9uQ2xlYXJlZChWQUxVRVMpOyAgLy8gbm90aGluZyBmcm9tIG9yaWdpbmFsIGV2ZW50IHRvIGZvcndhcmQKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBjb2xsZWN0aW9uQ2hhbmdlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5maXJlQ29sbGVjdGlvbkNoYW5nZWQoVkFMVUVTKTsgIC8vIG5vdGhpbmcgZnJvbSBvcmlnaW5hbCBldmVudCB0byBmb3J3YXJkCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0NvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmMyMzZhYi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjk2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuUmVhZE9ubHlMaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5DaGFuZ2VTdXBwb3J0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLlNpbmdsZUFzcGVjdENoYW5nZVN1cHBvcnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuQ29sbGVjdGlvbkNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5MaXN0Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci0KLS8qKgotICogQW4gYWRhcHRlciB0aGF0IGFsbG93cyB1cyB0byBtYWtlIGEgQ29sbGVjdGlvblZhbHVlTW9kZWwgYmVoYXZlIGxpa2UKLSAqIGEgcmVhZC1vbmx5IExpc3RWYWx1ZU1vZGVsLCBzb3J0YS4KLSAqIAotICogVG8gbWFpbnRhaW4gYSByZWFzb25hYmx5IGNvbnNpc3RlbnQgYXBwZWFyYW5jZSB0byBjbGllbnQgY29kZSwgd2UKLSAqIGtlZXAgYW4gaW50ZXJuYWwgbGlzdCBzb21ld2hhdCBpbiBzeW5jaCB3aXRoIHRoZSB3cmFwcGVkIGNvbGxlY3Rpb24uCi0gKiAKLSAqIE5COiBTaW5jZSB3ZSBvbmx5IGxpc3RlbiB0byB0aGUgd3JhcHBlZCBjb2xsZWN0aW9uIHdoZW4gd2UgaGF2ZQotICogbGlzdGVuZXJzIG91cnNlbHZlcyBhbmQgd2UgY2FuIG9ubHkgc3RheSBpbiBzeW5jaCB3aXRoIHRoZSB3cmFwcGVkCi0gKiBjb2xsZWN0aW9uIHdoaWxlIHdlIGFyZSBsaXN0ZW5pbmcgdG8gaXQsIHJlc3VsdHMgdG8gdmFyaW91cyBtZXRob2RzCi0gKiAoZS5nLiAjc2l6ZSgpLCBnZXRJdGVtKGludCkpIHdpbGwgYmUgdW5wcmVkaWN0YWJsZSB3aGVuZXZlcgotICogd2UgZG8gbm90IGhhdmUgYW55IGxpc3RlbmVycy4gVGhpcyBzaG91bGQgbm90IGJlIHRvbyBwYWluZnVsIHNpbmNlLAotICogbW9zdCBsaWtlbHksIGNsaWVudCBvYmplY3RzIHdpbGwgYWxzbyBiZSBsaXN0ZW5lcnMuCi0gKi8KLXB1YmxpYyBjbGFzcyBDb2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyPEU+Ci0JZXh0ZW5kcyBBYnN0cmFjdE1vZGVsCi0JaW1wbGVtZW50cyBMaXN0VmFsdWVNb2RlbDxFPgotewotCS8qKiBUaGUgd3JhcHBlZCBjb2xsZWN0aW9uIHZhbHVlIG1vZGVsLiAqLwotCXByb3RlY3RlZCBmaW5hbCBDb2xsZWN0aW9uVmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gY29sbGVjdGlvbkhvbGRlcjsKLQotCS8qKiBBIGxpc3RlbmVyIHRoYXQgZm9yd2FyZHMgYW55IGV2ZW50cyBmaXJlZCBieSB0aGUgY29sbGVjdGlvbiBob2xkZXIuICovCi0JcHJvdGVjdGVkIGZpbmFsIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBjb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXI7Ci0KLQkvKioKLQkgKiBPdXIgaW50ZXJuYWwgbGlzdCwgd2hpY2ggaG9sZHMgdGhlIHNhbWUgZWxlbWVudHMgYXMKLQkgKiB0aGUgd3JhcHBlZCBjb2xsZWN0aW9uLCBidXQga2VlcHMgdGhlbSBpbiBvcmRlci4KLQkgKi8KLQkvLyB3ZSBkZWNsYXJlIHRoaXMgYW4gQXJyYXlMaXN0IHNvIHdlIGNhbiB1c2UgI2Nsb25lKCkgYW5kICNlbnN1cmVDYXBhY2l0eShpbnQpCi0JcHJvdGVjdGVkIGZpbmFsIEFycmF5TGlzdDxFPiBsaXN0OwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBXcmFwIHRoZSBzcGVjaWZpZWQgQ29sbGVjdGlvblZhbHVlTW9kZWwuCi0JICovCi0JcHVibGljIENvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXIoQ29sbGVjdGlvblZhbHVlTW9kZWw8PyBleHRlbmRzIEU+IGNvbGxlY3Rpb25Ib2xkZXIpIHsKLQkJc3VwZXIoKTsKLQkJaWYgKGNvbGxlY3Rpb25Ib2xkZXIgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy5jb2xsZWN0aW9uSG9sZGVyID0gY29sbGVjdGlvbkhvbGRlcjsKLQkJdGhpcy5jb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgPSB0aGlzLmJ1aWxkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKCk7Ci0JCXRoaXMubGlzdCA9IG5ldyBBcnJheUxpc3Q8RT4oKTsKLQkJLy8gcG9zdHBvbmUgYnVpbGRpbmcgdGhlIGxpc3QgYW5kIGxpc3RlbmluZyB0byB0aGUgdW5kZXJseWluZyBjb2xsZWN0aW9uCi0JCS8vIHVudGlsIHdlIGhhdmUgbGlzdGVuZXJzIG91cnNlbHZlcy4uLgotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgQ2hhbmdlU3VwcG9ydCBidWlsZENoYW5nZVN1cHBvcnQoKSB7Ci0JCXJldHVybiBuZXcgU2luZ2xlQXNwZWN0Q2hhbmdlU3VwcG9ydCh0aGlzLCBMaXN0Q2hhbmdlTGlzdGVuZXIuY2xhc3MsIExJU1RfVkFMVUVTKTsKLQl9Ci0KLQkvKioKLQkgKiBUaGUgd3JhcHBlZCBjb2xsZWN0aW9uIGhhcyBjaGFuZ2VkLCBmb3J3YXJkIGFuIGVxdWl2YWxlbnQKLQkgKiBsaXN0IGNoYW5nZSBldmVudCB0byBvdXIgbGlzdGVuZXJzLgotCSAqLwotCXByb3RlY3RlZCBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgYnVpbGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlDb2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyLnRoaXMuaXRlbXNBZGRlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc1JlbW92ZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlci50aGlzLml0ZW1zUmVtb3ZlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBjb2xsZWN0aW9uQ2xlYXJlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlDb2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyLnRoaXMuY29sbGVjdGlvbkNsZWFyZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNoYW5nZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlci50aGlzLmNvbGxlY3Rpb25DaGFuZ2VkKGV2ZW50KTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gImNvbGxlY3Rpb24gY2hhbmdlIGxpc3RlbmVyIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogTGlzdFZhbHVlTW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIEl0ZXJhdG9yPEU+IGl0ZXJhdG9yKCkgewotCQlyZXR1cm4gdGhpcy5saXN0SXRlcmF0b3IoKTsKLQl9Ci0KLQlwdWJsaWMgTGlzdEl0ZXJhdG9yPEU+IGxpc3RJdGVyYXRvcigpIHsKLQkJcmV0dXJuIG5ldyBSZWFkT25seUxpc3RJdGVyYXRvcjxFPih0aGlzLmxpc3QpOwotCX0KLQotCXB1YmxpYyBFIGdldChpbnQgaW5kZXgpIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5nZXQoaW5kZXgpOwotCX0KLQotCXB1YmxpYyBpbnQgc2l6ZSgpIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5zaXplKCk7Ci0JfQotCi0JcHVibGljIE9iamVjdFtdIHRvQXJyYXkoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3QudG9BcnJheSgpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBleHRlbmQgY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JLyoqCi0JICogT3ZlcnJpZGUgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSBjb2xsZWN0aW9uIGhvbGRlciBpZiBuZWNlc3NhcnkuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlpZiAodGhpcy5oYXNOb0xpc3RlbmVycygpKSB7Ci0JCQl0aGlzLmVuZ2FnZU1vZGVsKCk7Ci0JCX0KLQkJc3VwZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBPdmVycmlkZSB0byBzdGFydCBsaXN0ZW5pbmcgdG8gdGhlIGNvbGxlY3Rpb24gaG9sZGVyIGlmIG5lY2Vzc2FyeS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBhZGRMaXN0Q2hhbmdlTGlzdGVuZXIoU3RyaW5nIGxpc3ROYW1lLCBMaXN0Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJaWYgKGxpc3ROYW1lID09IExJU1RfVkFMVUVTICYmIHRoaXMuaGFzTm9MaXN0ZW5lcnMoKSkgewotCQkJdGhpcy5lbmdhZ2VNb2RlbCgpOwotCQl9Ci0JCXN1cGVyLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihsaXN0TmFtZSwgbGlzdGVuZXIpOwotCX0KLQotCS8qKgotCSAqIE92ZXJyaWRlIHRvIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSBjb2xsZWN0aW9uIGhvbGRlciBpZiBhcHByb3ByaWF0ZS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCByZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXN1cGVyLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWlmICh0aGlzLmhhc05vTGlzdGVuZXJzKCkpIHsKLQkJCXRoaXMuZGlzZW5nYWdlTW9kZWwoKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIE92ZXJyaWRlIHRvIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSBjb2xsZWN0aW9uIGhvbGRlciBpZiBhcHByb3ByaWF0ZS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCByZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoU3RyaW5nIGxpc3ROYW1lLCBMaXN0Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJc3VwZXIucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKGxpc3ROYW1lLCBsaXN0ZW5lcik7Ci0JCWlmIChsaXN0TmFtZSA9PSBMSVNUX1ZBTFVFUyAmJiB0aGlzLmhhc05vTGlzdGVuZXJzKCkpIHsKLQkJCXRoaXMuZGlzZW5nYWdlTW9kZWwoKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBxdWVyaWVzICoqKioqKioqKioKLQotCXByb3RlY3RlZCBib29sZWFuIGhhc0xpc3RlbmVycygpIHsKLQkJcmV0dXJuIHRoaXMuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JcHJvdGVjdGVkIGJvb2xlYW4gaGFzTm9MaXN0ZW5lcnMoKSB7Ci0JCXJldHVybiAhIHRoaXMuaGFzTGlzdGVuZXJzKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBpbmRleCBvZiB0aGUgc3BlY2lmaWVkIGl0ZW0sIHVzaW5nIG9iamVjdAotCSAqIGlkZW50aXR5IGluc3RlYWQgb2YgZXF1YWxpdHkuCi0JICovCi0JcHJvdGVjdGVkIGludCBsYXN0SWRlbnRpdHlJbmRleE9mKE9iamVjdCBvKSB7Ci0JCXJldHVybiB0aGlzLmxhc3RJZGVudGl0eUluZGV4T2YobywgdGhpcy5saXN0LnNpemUoKSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgbGFzdCBpbmRleCBvZiB0aGUgc3BlY2lmaWVkIGl0ZW0sIHN0YXJ0aW5nIGp1c3QgYmVmb3JlIHRoZQotCSAqIHRoZSBzcGVjaWZpZWQgZW5kcG9pbnQsIGFuZCB1c2luZyBvYmplY3QgaWRlbnRpdHkgaW5zdGVhZCBvZiBlcXVhbGl0eS4KLQkgKi8KLQlwcm90ZWN0ZWQgaW50IGxhc3RJZGVudGl0eUluZGV4T2YoT2JqZWN0IG8sIGludCBlbmQpIHsKLQkJZm9yIChpbnQgaSA9IGVuZDsgaS0tID4gMDsgKSB7Ci0JCQlpZiAodGhpcy5saXN0LmdldChpKSA9PSBvKSB7Ci0JCQkJcmV0dXJuIGk7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIC0xOwotCX0KLQkKLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCi0JcHJvdGVjdGVkIHZvaWQgYnVpbGRMaXN0KCkgewotCQlJdGVyYXRvcjw/IGV4dGVuZHMgRT4gc3RyZWFtID0gdGhpcy5jb2xsZWN0aW9uSG9sZGVyLml0ZXJhdG9yKCk7Ci0JCS8vIGlmIHRoZSBuZXcgY29sbGVjdGlvbiBpcyBlbXB0eSwgZG8gbm90aGluZwotCQlpZiAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJdGhpcy5saXN0LmVuc3VyZUNhcGFjaXR5KHRoaXMuY29sbGVjdGlvbkhvbGRlci5zaXplKCkpOwotCQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCQl0aGlzLmxpc3QuYWRkKHN0cmVhbS5uZXh0KCkpOwotCQkJfQotCQkJdGhpcy5wb3N0QnVpbGRMaXN0KCk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBBbGxvdyBzdWJjbGFzc2VzIHRvIG1hbmlwdWxhdGUgdGhlIGludGVybmFsIGxpc3QgYmVmb3JlCi0JICogc2VuZGluZyBvdXQgY2hhbmdlIG5vdGlmaWNhdGlvbi4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBwb3N0QnVpbGRMaXN0KCkgewotCQkvLyB0aGUgZGVmYXVsdCBpcyB0byBkbyBub3RoaW5nLi4uCi0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlTW9kZWwoKSB7Ci0JCXRoaXMuY29sbGVjdGlvbkhvbGRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCB0aGlzLmNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcik7Ci0JCS8vIHN5bmNoIG91ciBsaXN0ICphZnRlciogd2Ugc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSBjb2xsZWN0aW9uIGhvbGRlciwKLQkJLy8gc2luY2UgaXRzIHZhbHVlIG1pZ2h0IGNoYW5nZSB3aGVuIGEgbGlzdGVuZXIgaXMgYWRkZWQKLQkJdGhpcy5idWlsZExpc3QoKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VNb2RlbCgpIHsKLQkJdGhpcy5jb2xsZWN0aW9uSG9sZGVyLnJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIHRoaXMuY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKTsKLQkJLy8gY2xlYXIgb3V0IHRoZSBsaXN0IHdoZW4gd2UgYXJlIG5vdCBsaXN0ZW5pbmcgdG8gdGhlIGNvbGxlY3Rpb24gaG9sZGVyCi0JCXRoaXMubGlzdC5jbGVhcigpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJdGhpcy5hZGRJdGVtc1RvTGlzdCh0aGlzLmluZGV4VG9BZGRJdGVtcygpLCBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLml0ZW1zKGUpKSwgdGhpcy5saXN0LCBMSVNUX1ZBTFVFUyk7Ci0JfQotCQotCXByb3RlY3RlZCBpbnQgaW5kZXhUb0FkZEl0ZW1zKCkgewotCQlyZXR1cm4gdGhpcy5saXN0LnNpemUoKTsKLQl9Ci0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcm90ZWN0ZWQgSXRlcmF0b3I8RT4gaXRlbXMoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJcmV0dXJuIChJdGVyYXRvcjxFPikgZS5pdGVtcygpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGl0ZW1zUmVtb3ZlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQkvLyB3ZSBoYXZlIHRvIHJlbW92ZSB0aGUgaXRlbXMgaW5kaXZpZHVhbGx5LAotCQkvLyBzaW5jZSB0aGV5IGFyZSBwcm9iYWJseSBub3QgaW4gc2VxdWVuY2UKLQkJZm9yIChJdGVyYXRvcjxFPiBzdHJlYW0gPSB0aGlzLml0ZW1zKGUpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCXRoaXMucmVtb3ZlSXRlbUZyb21MaXN0KHRoaXMubGFzdElkZW50aXR5SW5kZXhPZihzdHJlYW0ubmV4dCgpKSwgdGhpcy5saXN0LCBMSVNUX1ZBTFVFUyk7Ci0JCX0KLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBjb2xsZWN0aW9uQ2xlYXJlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQl0aGlzLmNsZWFyTGlzdCh0aGlzLmxpc3QsIExJU1RfVkFMVUVTKTsKLQl9Ci0JCi0JLyoqCi0JICogc3luY2hyb25pemUgb3VyIGludGVybmFsIGxpc3Qgd2l0aCB0aGUgd3JhcHBlZCBjb2xsZWN0aW9uCi0JICogYW5kIGZpcmUgdGhlIGFwcHJvcHJpYXRlIGV2ZW50cwotCSAqLwotCXByb3RlY3RlZCB2b2lkIGNvbGxlY3Rpb25DaGFuZ2VkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7Ci0JCS8vIHB1dCBpbiBlbXB0eSBjaGVjayBzbyB3ZSBkb24ndCBmaXJlIGV2ZW50cyB1bm5lY2Vzc2FyaWx5Ci0JCWlmICggISB0aGlzLmxpc3QuaXNFbXB0eSgpKSB7Ci0JCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJCUFycmF5TGlzdDxFPiByZW1vdmVkSXRlbXMgPSAoQXJyYXlMaXN0PEU+KSB0aGlzLmxpc3QuY2xvbmUoKTsKLQkJCXRoaXMubGlzdC5jbGVhcigpOwotCQkJdGhpcy5maXJlSXRlbXNSZW1vdmVkKExJU1RfVkFMVUVTLCAwLCByZW1vdmVkSXRlbXMpOwotCQl9Ci0KLQkJdGhpcy5idWlsZExpc3QoKTsKLQkJLy8gcHV0IGluIGVtcHR5IGNoZWNrIHNvIHdlIGRvbid0IGZpcmUgZXZlbnRzIHVubmVjZXNzYXJpbHkKLQkJaWYgKCAhIHRoaXMubGlzdC5pc0VtcHR5KCkpIHsKLQkJCXRoaXMuZmlyZUl0ZW1zQWRkZWQoTElTVF9WQUxVRVMsIDAsIHRoaXMubGlzdCk7Ci0JCX0KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0b1N0cmluZyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXNiLmFwcGVuZCh0aGlzLmNvbGxlY3Rpb25Ib2xkZXIpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0NvbGxlY3Rpb25Qcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ29sbGVjdGlvblByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYTI4ZmY3MS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ29sbGVjdGlvblByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE0MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuQ29sbGVjdGlvbkNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uVmFsdWVNb2RlbDsKLQotLyoqCi0gKiBUaGlzIGFic3RyYWN0IGNsYXNzIHByb3ZpZGVzIHRoZSBpbmZyYXN0cnVjdHVyZSBuZWVkZWQgdG8gd3JhcAotICogYSBjb2xsZWN0aW9uIHZhbHVlIG1vZGVsLCAibGF6aWx5IiBsaXN0ZW4gdG8gaXQsIGFuZCBjb252ZXJ0Ci0gKiBpdHMgY2hhbmdlIG5vdGlmaWNhdGlvbnMgaW50byBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCBjaGFuZ2UKLSAqIG5vdGlmaWNhdGlvbnMuCi0gKiAKLSAqIFN1YmNsYXNzZXMgbXVzdCBvdmVycmlkZToKLSAqIC0gI2J1aWxkVmFsdWUoKQotICogICAgIHRvIHJldHVybiB0aGUgY3VycmVudCBwcm9wZXJ0eSB2YWx1ZSwgYXMgZGVyaXZlZCBmcm9tIHRoZQotICogICAgIGN1cnJlbnQgY29sbGVjdGlvbiB2YWx1ZQotICogCi0gKiBTdWJjbGFzc2VzIG1pZ2h0IHdhbnQgdG8gb3ZlcnJpZGU6Ci0gKiAtICNpdGVtc0FkZGVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkKLSAqIC0gI2l0ZW1zUmVtb3ZlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpCi0gKiAtICNjb2xsZWN0aW9uQ2xlYXJlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpCi0gKiAtICNjb2xsZWN0aW9uQ2hhbmdlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpCi0gKiAgICAgdG8gaW1wcm92ZSBwZXJmb3JtYW5jZSAoYnkgbm90IHJlY2FsY3VsYXRpbmcgdGhlIHZhbHVlLCBpZiBwb3NzaWJsZSkKLSAqLwotcHVibGljIGFic3RyYWN0IGNsYXNzIENvbGxlY3Rpb25Qcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyPFQ+Ci0JZXh0ZW5kcyBBc3BlY3RQcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyPFQ+Ci17Ci0JLyoqIFRoZSB3cmFwcGVkIGNvbGxlY3Rpb24gdmFsdWUgbW9kZWwuICovCi0JcHJvdGVjdGVkIGZpbmFsIENvbGxlY3Rpb25WYWx1ZU1vZGVsPD8+IGNvbGxlY3Rpb25Ib2xkZXI7Ci0KLQkvKiogQSBsaXN0ZW5lciB0aGF0IGFsbG93cyB1cyB0byBzeW5jaCB3aXRoIGNoYW5nZXMgdG8gdGhlIHdyYXBwZWQgY29sbGVjdGlvbiBob2xkZXIuICovCi0JcHJvdGVjdGVkIGZpbmFsIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBjb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXI7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3IvaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgcHJvcGVydHkgdmFsdWUgbW9kZWwgd2l0aCB0aGUgc3BlY2lmaWVkIHdyYXBwZWQKLQkgKiBjb2xsZWN0aW9uIHZhbHVlIG1vZGVsLgotCSAqLwotCXByb3RlY3RlZCBDb2xsZWN0aW9uUHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlcihDb2xsZWN0aW9uVmFsdWVNb2RlbDw/PiBjb2xsZWN0aW9uSG9sZGVyKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMuY29sbGVjdGlvbkhvbGRlciA9IGNvbGxlY3Rpb25Ib2xkZXI7Ci0JCXRoaXMuY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyID0gdGhpcy5idWlsZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcigpOwotCX0KLQotCXByb3RlY3RlZCBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgYnVpbGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlDb2xsZWN0aW9uUHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlci50aGlzLml0ZW1zQWRkZWQoZXZlbnQpOwotCQkJfQkJCi0JCQlwdWJsaWMgdm9pZCBpdGVtc1JlbW92ZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJQ29sbGVjdGlvblByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIudGhpcy5pdGVtc1JlbW92ZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNsZWFyZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJQ29sbGVjdGlvblByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIudGhpcy5jb2xsZWN0aW9uQ2xlYXJlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBjb2xsZWN0aW9uQ2hhbmdlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlDb2xsZWN0aW9uUHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlci50aGlzLmNvbGxlY3Rpb25DaGFuZ2VkKGV2ZW50KTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gImNvbGxlY3Rpb24gY2hhbmdlIGxpc3RlbmVyIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCi0JLyoqCi0JICogU3RhcnQgbGlzdGVuaW5nIHRvIHRoZSBjb2xsZWN0aW9uIGhvbGRlci4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VNb2RlbF8oKSB7Ci0JCXRoaXMuY29sbGVjdGlvbkhvbGRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCB0aGlzLmNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogU3RvcCBsaXN0ZW5pbmcgdG8gdGhlIGNvbGxlY3Rpb24gaG9sZGVyLgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZU1vZGVsXygpIHsKLQkJdGhpcy5jb2xsZWN0aW9uSG9sZGVyLnJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIHRoaXMuY29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0b1N0cmluZyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXNiLmFwcGVuZCh0aGlzLmNvbGxlY3Rpb25Ib2xkZXIpOwotCX0KLQotCQotCS8vICoqKioqKioqKiogY29sbGVjdGlvbiBjaGFuZ2Ugc3VwcG9ydCAqKioqKioqKioqCi0KLQkvKioKLQkgKiBJdGVtcyB3ZXJlIGFkZGVkIHRvIHRoZSB3cmFwcGVkIGNvbGxlY3Rpb24gaG9sZGVyOwotCSAqIHByb3BhZ2F0ZSB0aGUgY2hhbmdlIG5vdGlmaWNhdGlvbiBhcHByb3ByaWF0ZWx5LgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIGJ5IGRlZmF1bHQsIHNpbXBseSByZWNhbGN1bGF0ZSB0aGUgdmFsdWUgYW5kIGZpcmUgYW4gZXZlbnQKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZWQoKTsKLQl9Ci0KLQkvKioKLQkgKiBJdGVtcyB3ZXJlIHJlbW92ZWQgZnJvbSB0aGUgd3JhcHBlZCBjb2xsZWN0aW9uIGhvbGRlcjsKLQkgKiBwcm9wYWdhdGUgdGhlIGNoYW5nZSBub3RpZmljYXRpb24gYXBwcm9wcmlhdGVseS4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBpdGVtc1JlbW92ZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIGJ5IGRlZmF1bHQsIHNpbXBseSByZWNhbGN1bGF0ZSB0aGUgdmFsdWUgYW5kIGZpcmUgYW4gZXZlbnQKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZWQoKTsKLQl9Ci0KLQkvKioKLQkgKiBUaGUgd3JhcHBlZCBjb2xsZWN0aW9uIGhvbGRlciB3YXMgY2xlYXJlZDsKLQkgKiBwcm9wYWdhdGUgdGhlIGNoYW5nZSBub3RpZmljYXRpb24gYXBwcm9wcmlhdGVseS4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBjb2xsZWN0aW9uQ2xlYXJlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gYnkgZGVmYXVsdCwgc2ltcGx5IHJlY2FsY3VsYXRlIHRoZSB2YWx1ZSBhbmQgZmlyZSBhbiBldmVudAotCQl0aGlzLnByb3BlcnR5Q2hhbmdlZCgpOwotCX0KLQotCS8qKgotCSAqIFRoZSB2YWx1ZSBvZiB0aGUgd3JhcHBlZCBjb2xsZWN0aW9uIGhvbGRlciBoYXMgY2hhbmdlZDsKLQkgKiBwcm9wYWdhdGUgdGhlIGNoYW5nZSBub3RpZmljYXRpb24gYXBwcm9wcmlhdGVseS4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBjb2xsZWN0aW9uQ2hhbmdlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gYnkgZGVmYXVsdCwgc2ltcGx5IHJlY2FsY3VsYXRlIHRoZSB2YWx1ZSBhbmQgZmlyZSBhbiBldmVudAotCQl0aGlzLnByb3BlcnR5Q2hhbmdlZCgpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0NvbGxlY3Rpb25WYWx1ZU1vZGVsV3JhcHBlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0NvbGxlY3Rpb25WYWx1ZU1vZGVsV3JhcHBlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0MTkwZmUxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Db2xsZWN0aW9uVmFsdWVNb2RlbFdyYXBwZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE3OSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQ2hhbmdlU3VwcG9ydDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5TaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LkNvbGxlY3Rpb25DaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Db2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci0KLS8qKgotICogVGhpcyBhYnN0cmFjdCBjbGFzcyBwcm92aWRlcyB0aGUgaW5mcmFzdHJ1Y3R1cmUgbmVlZGVkIHRvIHdyYXAKLSAqIGFub3RoZXIgY29sbGVjdGlvbiB2YWx1ZSBtb2RlbCwgImxhemlseSIgbGlzdGVuIHRvIGl0LCBhbmQgcHJvcGFnYXRlCi0gKiBpdHMgY2hhbmdlIG5vdGlmaWNhdGlvbnMuCi0gKi8KLXB1YmxpYyBhYnN0cmFjdCBjbGFzcyBDb2xsZWN0aW9uVmFsdWVNb2RlbFdyYXBwZXI8RT4KLQlleHRlbmRzIEFic3RyYWN0TW9kZWwKLXsKLQotCS8qKiBUaGUgd3JhcHBlZCBjb2xsZWN0aW9uIHZhbHVlIG1vZGVsLiAqLwotCXByb3RlY3RlZCBmaW5hbCBDb2xsZWN0aW9uVmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gY29sbGVjdGlvbkhvbGRlcjsKLQotCS8qKiBBIGxpc3RlbmVyIHRoYXQgYWxsb3dzIHVzIHRvIHN5bmNoIHdpdGggY2hhbmdlcyB0byB0aGUgd3JhcHBlZCBjb2xsZWN0aW9uIGhvbGRlci4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgY29sbGVjdGlvbiB2YWx1ZSBtb2RlbCB3aXRoIHRoZSBzcGVjaWZpZWQgd3JhcHBlZAotCSAqIGNvbGxlY3Rpb24gdmFsdWUgbW9kZWwuCi0JICovCi0JcHJvdGVjdGVkIENvbGxlY3Rpb25WYWx1ZU1vZGVsV3JhcHBlcihDb2xsZWN0aW9uVmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gY29sbGVjdGlvbkhvbGRlcikgewotCQlzdXBlcigpOwotCQl0aGlzLmNvbGxlY3Rpb25Ib2xkZXIgPSBjb2xsZWN0aW9uSG9sZGVyOwotCQl0aGlzLmNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciA9IHRoaXMuYnVpbGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoKTsKLQl9Ci0JCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBDaGFuZ2VTdXBwb3J0IGJ1aWxkQ2hhbmdlU3VwcG9ydCgpIHsKLQkJcmV0dXJuIG5ldyBTaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0KHRoaXMsIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lci5jbGFzcywgQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGJ1aWxkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJQ29sbGVjdGlvblZhbHVlTW9kZWxXcmFwcGVyLnRoaXMuaXRlbXNBZGRlZChldmVudCk7Ci0JCQl9CQkKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlDb2xsZWN0aW9uVmFsdWVNb2RlbFdyYXBwZXIudGhpcy5pdGVtc1JlbW92ZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNsZWFyZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJQ29sbGVjdGlvblZhbHVlTW9kZWxXcmFwcGVyLnRoaXMuY29sbGVjdGlvbkNsZWFyZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNoYW5nZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJQ29sbGVjdGlvblZhbHVlTW9kZWxXcmFwcGVyLnRoaXMuY29sbGVjdGlvbkNoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiY29sbGVjdGlvbiBjaGFuZ2UgbGlzdGVuZXIiOwotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBleHRlbmQgY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0YXJ0IGxpc3RlbmluZyB0byB0aGUgbmVzdGVkIG1vZGVsIGlmIG5lY2Vzc2FyeS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlpZiAodGhpcy5oYXNOb0NvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTKSkgewotCQkJdGhpcy5lbmdhZ2VNb2RlbCgpOwotCQl9Ci0JCXN1cGVyLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JfQotCQotCS8qKgotCSAqIEV4dGVuZCB0byBzdGFydCBsaXN0ZW5pbmcgdG8gdGhlIG5lc3RlZCBtb2RlbCBpZiBuZWNlc3NhcnkuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIGFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihTdHJpbmcgY29sbGVjdGlvbk5hbWUsIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlpZiAoY29sbGVjdGlvbk5hbWUgPT0gQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTICYmIHRoaXMuaGFzTm9Db2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUykpIHsKLQkJCXRoaXMuZW5nYWdlTW9kZWwoKTsKLQkJfQotCQlzdXBlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoY29sbGVjdGlvbk5hbWUsIGxpc3RlbmVyKTsKLQl9Ci0JCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSBuZXN0ZWQgbW9kZWwgaWYgbmVjZXNzYXJ5LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCByZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXN1cGVyLnJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWlmICh0aGlzLmhhc05vQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMpKSB7Ci0JCQl0aGlzLmRpc2VuZ2FnZU1vZGVsKCk7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSBuZXN0ZWQgbW9kZWwgaWYgbmVjZXNzYXJ5LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCByZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoU3RyaW5nIGNvbGxlY3Rpb25OYW1lLCBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJc3VwZXIucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKGNvbGxlY3Rpb25OYW1lLCBsaXN0ZW5lcik7Ci0JCWlmIChjb2xsZWN0aW9uTmFtZSA9PSBDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMgJiYgdGhpcy5oYXNOb0NvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTKSkgewotCQkJdGhpcy5kaXNlbmdhZ2VNb2RlbCgpOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCS8qKgotCSAqIFN0YXJ0IGxpc3RlbmluZyB0byB0aGUgY29sbGVjdGlvbiBob2xkZXIuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlTW9kZWwoKSB7Ci0JCXRoaXMuY29sbGVjdGlvbkhvbGRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCB0aGlzLmNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogU3RvcCBsaXN0ZW5pbmcgdG8gdGhlIGNvbGxlY3Rpb24gaG9sZGVyLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZU1vZGVsKCkgewotCQl0aGlzLmNvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgdGhpcy5jb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIpOwotCX0KLQotCS8vIG1pbmltaXplIHNjb3BlIG9mIHN1cHByZXNzZWQgd2FybmluZ3MKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcm90ZWN0ZWQgSXRlcmF0b3I8RT4gaXRlbXMoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXJldHVybiAoSXRlcmF0b3I8RT4pIGV2ZW50Lml0ZW1zKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgdG9TdHJpbmcoU3RyaW5nQnVpbGRlciBzYikgewotCQlzYi5hcHBlbmQodGhpcy5jb2xsZWN0aW9uSG9sZGVyKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY29sbGVjdGlvbiBjaGFuZ2Ugc3VwcG9ydCAqKioqKioqKioqCi0KLQkvKioKLQkgKiBJdGVtcyB3ZXJlIGFkZGVkIHRvIHRoZSB3cmFwcGVkIGNvbGxlY3Rpb24gaG9sZGVyOwotCSAqIHByb3BhZ2F0ZSB0aGUgY2hhbmdlIG5vdGlmaWNhdGlvbiBhcHByb3ByaWF0ZWx5LgotCSAqLwotCXByb3RlY3RlZCBhYnN0cmFjdCB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KTsKLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgcmVtb3ZlZCBmcm9tIHRoZSB3cmFwcGVkIGNvbGxlY3Rpb24gaG9sZGVyOwotCSAqIHByb3BhZ2F0ZSB0aGUgY2hhbmdlIG5vdGlmaWNhdGlvbiBhcHByb3ByaWF0ZWx5LgotCSAqLwotCXByb3RlY3RlZCBhYnN0cmFjdCB2b2lkIGl0ZW1zUmVtb3ZlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpOwotCi0JLyoqCi0JICogVGhlIHdyYXBwZWQgY29sbGVjdGlvbiBob2xkZXIgd2FzIGNsZWFyZWQ7Ci0JICogcHJvcGFnYXRlIHRoZSBjaGFuZ2Ugbm90aWZpY2F0aW9uIGFwcHJvcHJpYXRlbHkuCi0JICovCi0JcHJvdGVjdGVkIGFic3RyYWN0IHZvaWQgY29sbGVjdGlvbkNsZWFyZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KTsKLQotCS8qKgotCSAqIFRoZSB2YWx1ZSBvZiB0aGUgd3JhcHBlZCBjb2xsZWN0aW9uIGhvbGRlciBoYXMgY2hhbmdlZDsKLQkgKiBwcm9wYWdhdGUgdGhlIGNoYW5nZSBub3RpZmljYXRpb24gYXBwcm9wcmlhdGVseS4KLQkgKi8KLQlwcm90ZWN0ZWQgYWJzdHJhY3Qgdm9pZCBjb2xsZWN0aW9uQ2hhbmdlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpOwotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ29tcG9zaXRlQ29sbGVjdGlvblZhbHVlTW9kZWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Db21wb3NpdGVDb2xsZWN0aW9uVmFsdWVNb2RlbC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4MTVlNDhlLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Db21wb3NpdGVDb2xsZWN0aW9uVmFsdWVNb2RlbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDA2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JZGVudGl0eUhhc2hNYXA7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5OdWxsTGlzdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5UcmFuc2Zvcm1lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuQ29tcG9zaXRlSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlRyYW5zZm9ybWF0aW9uSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuQ29sbGVjdGlvbkNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBBIDxjb2RlPkNvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPC9jb2RlPiB3cmFwcyBhbm90aGVyCi0gKiA8Y29kZT5Db2xsZWN0aW9uVmFsdWVNb2RlbDwvY29kZT4gYW5kIHVzZXMgYSA8Y29kZT5UcmFuc2Zvcm1lcjwvY29kZT4KLSAqIHRvIGNvbnZlcnQgZWFjaCBpdGVtIGluIHRoZSB3cmFwcGVkIGNvbGxlY3Rpb24gdG8geWV0IGFub3RoZXIKLSAqIDxjb2RlPkNvbGxlY3Rpb25WYWx1ZU1vZGVsPC9jb2RlPi4gVGhpcyBjb21wb3NpdGUgY29sbGVjdGlvbiBjb250YWlucwotICogdGhlIGNvbWJpbmVkIGl0ZW1zIGZyb20gYWxsIHRoZXNlIGNvbXBvbmVudCBjb2xsZWN0aW9ucy4KLSAqIAotICogTkI6IFRoZSB3cmFwcGVkIGNvbGxlY3Rpb24gbXVzdCBiZSBhbiAiaWRlbnRpdHkgc2V0IiB0aGF0IGRvZXMgbm90Ci0gKiBjb250YWluIHRoZSBzYW1lIGl0ZW0gdHdpY2Ugb3IgdGhpcyBjbGFzcyB3aWxsIHRocm93IGFuIGV4Y2VwdGlvbi4KLSAqIAotICogVGVybWlub2xvZ3k6Ci0gKiAtIHNvdXJjZXMgLSB0aGUgaXRlbXMgaW4gdGhlIHdyYXBwZWQgY29sbGVjdGlvbiB2YWx1ZSBtb2RlbDsgdGhlc2UKLSAqICAgIGFyZSBjb252ZXJ0ZWQgaW50byBjb21wb25lbnQgQ1ZNcyBieSB0aGUgdHJhbnNmb3JtZXIKLSAqIC0gY29tcG9uZW50IENWTXMgLSB0aGUgY29tcG9uZW50IGNvbGxlY3Rpb24gdmFsdWUgbW9kZWxzIHRoYXQgYXJlIGNvbWJpbmVkCi0gKiAgICBieSB0aGlzIGNvbXBvc2l0ZSBjb2xsZWN0aW9uIHZhbHVlIG1vZGVsCi0gKiAtIGl0ZW1zIC0gdGhlIGl0ZW1zIGhlbGQgYnkgdGhlIGNvbXBvbmVudCBDVk1zCi0gKi8KLXB1YmxpYyBjbGFzcyBDb21wb3NpdGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxFMSwgRTI+Ci0JZXh0ZW5kcyBDb2xsZWN0aW9uVmFsdWVNb2RlbFdyYXBwZXI8RTE+Ci0JaW1wbGVtZW50cyBDb2xsZWN0aW9uVmFsdWVNb2RlbDxFMj4KLXsKLQkvKioKLQkgKiBUaGlzIGlzIHRoZSAob3B0aW9uYWwpIHVzZXItc3VwcGxpZWQgb2JqZWN0IHRoYXQgdHJhbnNmb3JtcwotCSAqIHRoZSBpdGVtcyBpbiB0aGUgd3JhcHBlZCBjb2xsZWN0aW9uIHRvIGNvbGxlY3Rpb24gdmFsdWUgbW9kZWxzLgotCSAqLwotCXByaXZhdGUgZmluYWwgVHJhbnNmb3JtZXI8RTEsIENvbGxlY3Rpb25WYWx1ZU1vZGVsPEUyPj4gdHJhbnNmb3JtZXI7Ci0KLQkvKioKLQkgKiBDYWNoZSBvZiB0aGUgY29tcG9uZW50IGNvbGxlY3Rpb24gdmFsdWUgbW9kZWxzIHRoYXQKLQkgKiB3ZXJlIGdlbmVyYXRlZCBieSB0aGUgdHJhbnNmb3JtZXI7IGtleWVkIGJ5IHRoZSBpdGVtCi0JICogaW4gdGhlIHdyYXBwZWQgY29sbGVjdGlvbiB0aGF0IHdhcyBwYXNzZWQgdG8gdGhlIHRyYW5zZm9ybWVyLgotCSAqLwotCXByaXZhdGUgZmluYWwgSWRlbnRpdHlIYXNoTWFwPEUxLCBDb2xsZWN0aW9uVmFsdWVNb2RlbDxFMj4+IGNvbXBvbmVudENWTXM7Ci0KLQkvKioKLQkgKiBDYWNoZSBvZiB0aGUgY29sbGVjdGlvbnMgY29ycmVzcG9uZGluZyB0byB0aGUgY29tcG9uZW50Ci0JICogY29sbGVjdGlvbiB2YWx1ZSBtb2RlbHMgYWJvdmU7IGtleWVkIGJ5IHRoZSBjb21wb25lbnQKLQkgKiBjb2xsZWN0aW9uIHZhbHVlIG1vZGVscy4KLQkgKiBVc2UgQXJyYXlMaXN0cyBzbyB3ZSBjYW4gdXNlIEFycmF5TGlzdC1zcGVjaWZpYyBtZXRob2RzCi0JICogKGUuZy4gI2Nsb25lKCkgYW5kICNlbnN1cmVDYXBhY2l0eSgpKS4KLQkgKi8KLQlwcml2YXRlIGZpbmFsIElkZW50aXR5SGFzaE1hcDxDb2xsZWN0aW9uVmFsdWVNb2RlbDxFMj4sIEFycmF5TGlzdDxFMj4+IGNvbGxlY3Rpb25zOwotCi0JLyoqIExpc3RlbmVyIHRoYXQgbGlzdGVucyB0byBhbGwgdGhlIGNvbXBvbmVudCBjb2xsZWN0aW9uIHZhbHVlIG1vZGVscy4gKi8KLQlwcml2YXRlIGZpbmFsIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBjb21wb25lbnRDVk1MaXN0ZW5lcjsKLQotCS8qKiBDYWNoZSB0aGUgc2l6ZSBvZiB0aGUgY29tcG9zaXRlIGNvbGxlY3Rpb24uICovCi0JcHJpdmF0ZSBpbnQgc2l6ZTsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgY29sbGVjdGlvbiB2YWx1ZSBtb2RlbCB3aXRoIHRoZSBzcGVjaWZpZWQgd3JhcHBlZAotCSAqIGNvbGxlY3Rpb24gdmFsdWUgbW9kZWwuIFVzZSB0aGlzIGNvbnN0cnVjdG9yIGlmCi0JICogICAgIC0gdGhlIHdyYXBwZWQgY29sbGVjdGlvbiB2YWx1ZSBtb2RlbCBhbHJlYWR5IGNvbnRhaW5zIG90aGVyCi0JICogICAgICAgY29sbGVjdGlvbiB2YWx1ZSBtb2RlbHMgb3IKLQkgKiAgICAgLSB5b3Ugd2FudCB0byBvdmVycmlkZSB0aGUgPGNvZGU+dHJhbnNmb3JtKEUxKTwvY29kZT4gbWV0aG9kCi0JICogICAgICAgaW5zdGVhZCBvZiBidWlsZGluZyBhIDxjb2RlPlRyYW5zZm9ybWVyPC9jb2RlPgotCSAqLwotCXB1YmxpYyBDb21wb3NpdGVDb2xsZWN0aW9uVmFsdWVNb2RlbChDb2xsZWN0aW9uVmFsdWVNb2RlbDw/IGV4dGVuZHMgRTE+IGNvbGxlY3Rpb25Ib2xkZXIpIHsKLQkJdGhpcyhjb2xsZWN0aW9uSG9sZGVyLCBUcmFuc2Zvcm1lci5OdWxsLjxFMSwgQ29sbGVjdGlvblZhbHVlTW9kZWw8RTI+Pmluc3RhbmNlKCkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGNvbGxlY3Rpb24gdmFsdWUgbW9kZWwgd2l0aCB0aGUgc3BlY2lmaWVkIHdyYXBwZWQKLQkgKiBjb2xsZWN0aW9uIHZhbHVlIG1vZGVsIGFuZCB0cmFuc2Zvcm1lci4KLQkgKi8KLQlwdWJsaWMgQ29tcG9zaXRlQ29sbGVjdGlvblZhbHVlTW9kZWwoQ29sbGVjdGlvblZhbHVlTW9kZWw8PyBleHRlbmRzIEUxPiBjb2xsZWN0aW9uSG9sZGVyLCBUcmFuc2Zvcm1lcjxFMSwgQ29sbGVjdGlvblZhbHVlTW9kZWw8RTI+PiB0cmFuc2Zvcm1lcikgewotCQlzdXBlcihjb2xsZWN0aW9uSG9sZGVyKTsKLQkJdGhpcy50cmFuc2Zvcm1lciA9IHRyYW5zZm9ybWVyOwotCQl0aGlzLmNvbXBvbmVudENWTXMgPSBuZXcgSWRlbnRpdHlIYXNoTWFwPEUxLCBDb2xsZWN0aW9uVmFsdWVNb2RlbDxFMj4+KCk7Ci0JCXRoaXMuY29sbGVjdGlvbnMgPSBuZXcgSWRlbnRpdHlIYXNoTWFwPENvbGxlY3Rpb25WYWx1ZU1vZGVsPEUyPiwgQXJyYXlMaXN0PEUyPj4oKTsKLQkJdGhpcy5jb21wb25lbnRDVk1MaXN0ZW5lciA9IHRoaXMuYnVpbGRDb21wb25lbnRMaXN0ZW5lcigpOwotCQl0aGlzLnNpemUgPSAwOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGNvbGxlY3Rpb24gdmFsdWUgbW9kZWwgd2l0aCB0aGUgc3BlY2lmaWVkIHdyYXBwZWQKLQkgKiBsaXN0IHZhbHVlIG1vZGVsLiBVc2UgdGhpcyBjb25zdHJ1Y3RvciBpZgotCSAqICAgICAtIHRoZSB3cmFwcGVkIGxpc3QgdmFsdWUgbW9kZWwgYWxyZWFkeSBjb250YWlucyBjb2xsZWN0aW9uCi0JICogICAgICAgdmFsdWUgbW9kZWxzIG9yCi0JICogICAgIC0geW91IHdhbnQgdG8gb3ZlcnJpZGUgdGhlIDxjb2RlPnRyYW5zZm9ybShFMSk8L2NvZGU+IG1ldGhvZAotCSAqICAgICAgIGluc3RlYWQgb2YgYnVpbGRpbmcgYSA8Y29kZT5UcmFuc2Zvcm1lcjwvY29kZT4KLQkgKi8KLQlwdWJsaWMgQ29tcG9zaXRlQ29sbGVjdGlvblZhbHVlTW9kZWwoTGlzdFZhbHVlTW9kZWw8PyBleHRlbmRzIEUxPiBsaXN0SG9sZGVyKSB7Ci0JCXRoaXMobmV3IExpc3RDb2xsZWN0aW9uVmFsdWVNb2RlbEFkYXB0ZXI8RTE+KGxpc3RIb2xkZXIpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBjb2xsZWN0aW9uIHZhbHVlIG1vZGVsIHdpdGggdGhlIHNwZWNpZmllZCB3cmFwcGVkCi0JICogbGlzdCB2YWx1ZSBtb2RlbCBhbmQgdHJhbnNmb3JtZXIuCi0JICovCi0JcHVibGljIENvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsKExpc3RWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBFMT4gbGlzdEhvbGRlciwgVHJhbnNmb3JtZXI8RTEsIENvbGxlY3Rpb25WYWx1ZU1vZGVsPEUyPj4gdHJhbnNmb3JtZXIpIHsKLQkJdGhpcyhuZXcgTGlzdENvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlcjxFMT4obGlzdEhvbGRlciksIHRyYW5zZm9ybWVyKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBjb2xsZWN0aW9uIHZhbHVlIG1vZGVsIHdpdGggdGhlIHNwZWNpZmllZCwgdW5jaGFuZ2luZywgd3JhcHBlZAotCSAqIGNvbGxlY3Rpb24uIFVzZSB0aGlzIGNvbnN0cnVjdG9yIGlmCi0JICogICAgIC0gdGhlIHdyYXBwZWQgY29sbGVjdGlvbiBhbHJlYWR5IGNvbnRhaW5zIGNvbGxlY3Rpb24KLQkgKiAgICAgICB2YWx1ZSBtb2RlbHMgb3IKLQkgKiAgICAgLSB5b3Ugd2FudCB0byBvdmVycmlkZSB0aGUgPGNvZGU+dHJhbnNmb3JtKEUxKTwvY29kZT4gbWV0aG9kCi0JICogICAgICAgaW5zdGVhZCBvZiBidWlsZGluZyBhIDxjb2RlPlRyYW5zZm9ybWVyPC9jb2RlPgotCSAqLwotCXB1YmxpYyBDb21wb3NpdGVDb2xsZWN0aW9uVmFsdWVNb2RlbChDb2xsZWN0aW9uPD8gZXh0ZW5kcyBFMT4gY29sbGVjdGlvbikgewotCQl0aGlzKG5ldyBTdGF0aWNDb2xsZWN0aW9uVmFsdWVNb2RlbDxFMT4oY29sbGVjdGlvbikpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGNvbGxlY3Rpb24gdmFsdWUgbW9kZWwgd2l0aCB0aGUgc3BlY2lmaWVkLCB1bmNoYW5naW5nLCB3cmFwcGVkCi0JICogY29sbGVjdGlvbiBhbmQgdHJhbnNmb3JtZXIuCi0JICovCi0JcHVibGljIENvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsKENvbGxlY3Rpb248PyBleHRlbmRzIEUxPiBjb2xsZWN0aW9uLCBUcmFuc2Zvcm1lcjxFMSwgQ29sbGVjdGlvblZhbHVlTW9kZWw8RTI+PiB0cmFuc2Zvcm1lcikgewotCQl0aGlzKG5ldyBTdGF0aWNDb2xsZWN0aW9uVmFsdWVNb2RlbDxFMT4oY29sbGVjdGlvbiksIHRyYW5zZm9ybWVyKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JcHJvdGVjdGVkIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBidWlsZENvbXBvbmVudExpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJQ29tcG9zaXRlQ29sbGVjdGlvblZhbHVlTW9kZWwudGhpcy5jb21wb25lbnRJdGVtc0FkZGVkKGV2ZW50KTsKLQkJCX0JCQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUNvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsLnRoaXMuY29tcG9uZW50SXRlbXNSZW1vdmVkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGNvbGxlY3Rpb25DbGVhcmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUNvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsLnRoaXMuY29tcG9uZW50Q29sbGVjdGlvbkNsZWFyZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNoYW5nZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJQ29tcG9zaXRlQ29sbGVjdGlvblZhbHVlTW9kZWwudGhpcy5jb21wb25lbnRDb2xsZWN0aW9uQ2hhbmdlZChldmVudCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJjb21wb25lbnQgbGlzdGVuZXIiOwotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBDb2xsZWN0aW9uVmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgSXRlcmF0b3I8RTI+IGl0ZXJhdG9yKCkgewotCQlyZXR1cm4gbmV3IENvbXBvc2l0ZUl0ZXJhdG9yPEUyPih0aGlzLmJ1aWxkQ29sbGVjdGlvbnNJdGVyYXRvcnMoKSk7Ci0JfQotCi0JcHJvdGVjdGVkIEl0ZXJhdG9yPEl0ZXJhdG9yPEUyPj4gYnVpbGRDb2xsZWN0aW9uc0l0ZXJhdG9ycygpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yPEFycmF5TGlzdDxFMj4sIEl0ZXJhdG9yPEUyPj4odGhpcy5jb2xsZWN0aW9ucy52YWx1ZXMoKS5pdGVyYXRvcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBJdGVyYXRvcjxFMj4gdHJhbnNmb3JtKEFycmF5TGlzdDxFMj4gbmV4dCkgewotCQkJCXJldHVybiBuZXh0Lml0ZXJhdG9yKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHVibGljIGludCBzaXplKCkgewotCQlyZXR1cm4gdGhpcy5zaXplOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBDb2xsZWN0aW9uVmFsdWVNb2RlbFdyYXBwZXIgb3ZlcnJpZGVzL2ltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGVuZ2FnZU1vZGVsKCkgewotCQlzdXBlci5lbmdhZ2VNb2RlbCgpOwotCQkvLyBzeW5jaCBvdXIgY2FjaGUgKmFmdGVyKiB3ZSBzdGFydCBsaXN0ZW5pbmcgdG8gdGhlIHdyYXBwZWQgY29sbGVjdGlvbiwKLQkJLy8gc2luY2UgaXRzIHZhbHVlIG1pZ2h0IGNoYW5nZSB3aGVuIGEgbGlzdGVuZXIgaXMgYWRkZWQKLQkJdGhpcy5hZGRBbGxDb21wb25lbnRTb3VyY2VzKCk7Ci0JfQotCi0JLyoqCi0JICogVHJhbnNmb3JtIGFsbCB0aGUgc291cmNlcyB0byBjb2xsZWN0aW9uIHZhbHVlIG1vZGVscwotCSAqIGFuZCBhZGQgdGhlaXIgaXRlbXMgdG8gb3VyIGNhY2hlLCB3aXRoIG5vIGV2ZW50IG5vdGlmaWNhdGlvbi4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBhZGRBbGxDb21wb25lbnRTb3VyY2VzKCkgewotCQlmb3IgKEUxIHNvdXJjZSA6IHRoaXMuY29sbGVjdGlvbkhvbGRlcikgewotCQkJdGhpcy5hZGRDb21wb25lbnRTb3VyY2Uoc291cmNlLCBOdWxsTGlzdC48RTI+aW5zdGFuY2UoKSk7Ci0JCX0KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VNb2RlbCgpIHsKLQkJc3VwZXIuZGlzZW5nYWdlTW9kZWwoKTsKLQkJLy8gc3RvcCBsaXN0ZW5pbmcgdG8gdGhlIGNvbXBvbmVudHMuLi4KLQkJZm9yIChDb2xsZWN0aW9uVmFsdWVNb2RlbDxFMj4gY29tcG9uZW50Q1ZNIDogdGhpcy5jb21wb25lbnRDVk1zLnZhbHVlcygpKSB7Ci0JCQljb21wb25lbnRDVk0ucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKFZBTFVFUywgdGhpcy5jb21wb25lbnRDVk1MaXN0ZW5lcik7Ci0JCX0KLQkJLy8gLi4uYW5kIGNsZWFyIHRoZSBjYWNoZQotCQl0aGlzLmNvbXBvbmVudENWTXMuY2xlYXIoKTsKLQkJdGhpcy5jb2xsZWN0aW9ucy5jbGVhcigpOwotCQl0aGlzLnNpemUgPSAwOwotCX0KLQotCS8qKgotCSAqIFNvbWUgY29tcG9uZW50IHNvdXJjZXMgd2VyZSBhZGRlZDsKLQkgKiBhZGQgdGhlaXIgY29ycmVzcG9uZGluZyBpdGVtcyB0byBvdXIgY2FjaGUuCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJQXJyYXlMaXN0PEUyPiBhZGRlZEl0ZW1zID0gbmV3IEFycmF5TGlzdDxFMj4oKTsKLQkJZm9yIChJdGVyYXRvcjxFMT4gc3RyZWFtID0gdGhpcy5pdGVtcyhldmVudCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJdGhpcy5hZGRDb21wb25lbnRTb3VyY2Uoc3RyZWFtLm5leHQoKSwgYWRkZWRJdGVtcyk7Ci0JCX0KLQkJdGhpcy5maXJlSXRlbXNBZGRlZChWQUxVRVMsIGFkZGVkSXRlbXMpOwotCX0KLQotCS8qKgotCSAqIFRyYW5zZm9ybSB0aGUgc3BlY2lmaWVkIHNvdXJjZSB0byBhIGNvbGxlY3Rpb24gdmFsdWUgbW9kZWwKLQkgKiBhbmQgYWRkIGl0cyBpdGVtcyB0byBvdXIgY2FjaGUgYW5kIHRoZSAiY29sbGVjdGluZyBwYXJhbWV0ZXIiLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGFkZENvbXBvbmVudFNvdXJjZShFMSBzb3VyY2UsIExpc3Q8RTI+IGFkZGVkSXRlbXMpIHsKLQkJQ29sbGVjdGlvblZhbHVlTW9kZWw8RTI+IGNvbXBvbmVudENWTSA9IHRoaXMudHJhbnNmb3JtKHNvdXJjZSk7Ci0JCWlmICh0aGlzLmNvbXBvbmVudENWTXMucHV0KHNvdXJjZSwgY29tcG9uZW50Q1ZNKSAhPSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJkdXBsaWNhdGUgY29tcG9uZW50OiAiICsgc291cmNlKTsKLQkJfQotCQljb21wb25lbnRDVk0uYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKFZBTFVFUywgdGhpcy5jb21wb25lbnRDVk1MaXN0ZW5lcik7Ci0JCUFycmF5TGlzdDxFMj4gY29tcG9uZW50Q29sbGVjdGlvbiA9IG5ldyBBcnJheUxpc3Q8RTI+KGNvbXBvbmVudENWTS5zaXplKCkpOwotCQlpZiAodGhpcy5jb2xsZWN0aW9ucy5wdXQoY29tcG9uZW50Q1ZNLCBjb21wb25lbnRDb2xsZWN0aW9uKSAhPSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJkdXBsaWNhdGUgY29sbGVjdGlvbjogIiArIHNvdXJjZSk7Ci0JCX0KLQkJdGhpcy5hZGRDb21wb25lbnRJdGVtcyhjb21wb25lbnRDVk0sIGNvbXBvbmVudENvbGxlY3Rpb24pOwotCQlhZGRlZEl0ZW1zLmFkZEFsbChjb21wb25lbnRDb2xsZWN0aW9uKTsKLQl9Ci0KLQkvKioKLQkgKiBBZGQgdGhlIGl0ZW1zIGluIHRoZSBzcGVjaWZpZWQgY29tcG9uZW50IENWTSB0byB0aGUgc3BlY2lmaWVkIGNvbXBvbmVudAotCSAqIGNvbGxlY3Rpb24uCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgYWRkQ29tcG9uZW50SXRlbXMoQ29sbGVjdGlvblZhbHVlTW9kZWw8RTI+IGNvbXBvbmVudENWTSwgQXJyYXlMaXN0PEUyPiBjb21wb25lbnRDb2xsZWN0aW9uKSB7Ci0JCWludCBpdGVtc1NpemUgPSBjb21wb25lbnRDVk0uc2l6ZSgpOwotCQl0aGlzLnNpemUgKz0gaXRlbXNTaXplOwotCQljb21wb25lbnRDb2xsZWN0aW9uLmVuc3VyZUNhcGFjaXR5KGNvbXBvbmVudENvbGxlY3Rpb24uc2l6ZSgpICsgaXRlbXNTaXplKTsKLQkJQ29sbGVjdGlvblRvb2xzLmFkZEFsbChjb21wb25lbnRDb2xsZWN0aW9uLCBjb21wb25lbnRDVk0pOwotCX0KLQotCS8qKgotCSAqIFNvbWUgY29tcG9uZW50IHNvdXJjZXMgd2VyZSByZW1vdmVkOwotCSAqIHJlbW92ZSB0aGVpciBjb3JyZXNwb25kaW5nIGl0ZW1zIGZyb20gb3VyIGNhY2hlLgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGl0ZW1zUmVtb3ZlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJQXJyYXlMaXN0PEUyPiByZW1vdmVkSXRlbXMgPSBuZXcgQXJyYXlMaXN0PEUyPigpOwotCQlmb3IgKEl0ZXJhdG9yPEUxPiBzdHJlYW0gPSB0aGlzLml0ZW1zKGV2ZW50KTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQl0aGlzLnJlbW92ZUNvbXBvbmVudFNvdXJjZShzdHJlYW0ubmV4dCgpLCByZW1vdmVkSXRlbXMpOwotCQl9Ci0JCXRoaXMuZmlyZUl0ZW1zUmVtb3ZlZChWQUxVRVMsIHJlbW92ZWRJdGVtcyk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBpdGVtcyBjb3JyZXNwb25kaW5nIHRvIHRoZSBzcGVjaWZpZWQgc291cmNlCi0JICogZnJvbSBvdXIgY2FjaGUuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgcmVtb3ZlQ29tcG9uZW50U291cmNlKEUxIHNvdXJjZSwgTGlzdDxFMj4gcmVtb3ZlZEl0ZW1zKSB7Ci0JCUNvbGxlY3Rpb25WYWx1ZU1vZGVsPEUyPiBjb21wb25lbnRDVk0gPSB0aGlzLmNvbXBvbmVudENWTXMucmVtb3ZlKHNvdXJjZSk7Ci0JCWlmIChjb21wb25lbnRDVk0gPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigibWlzc2luZyBjb21wb25lbnQ6ICIgKyBzb3VyY2UpOwotCQl9Ci0JCWNvbXBvbmVudENWTS5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoVkFMVUVTLCB0aGlzLmNvbXBvbmVudENWTUxpc3RlbmVyKTsKLQkJQXJyYXlMaXN0PEUyPiBjb21wb25lbnRDb2xsZWN0aW9uID0gdGhpcy5jb2xsZWN0aW9ucy5yZW1vdmUoY29tcG9uZW50Q1ZNKTsKLQkJaWYgKGNvbXBvbmVudENvbGxlY3Rpb24gPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigibWlzc2luZyBjb2xsZWN0aW9uOiAiICsgc291cmNlKTsKLQkJfQotCQlyZW1vdmVkSXRlbXMuYWRkQWxsKGNvbXBvbmVudENvbGxlY3Rpb24pOwotCQl0aGlzLnJlbW92ZUNvbXBvbmVudEl0ZW1zKGNvbXBvbmVudENvbGxlY3Rpb24pOwotCX0KLQotCS8qKgotCSAqIFVwZGF0ZSBvdXIgc2l6ZSBhbmQgY29sbGVjdGlvbiBjYWNoZS4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCByZW1vdmVDb21wb25lbnRJdGVtcyhBcnJheUxpc3Q8RTI+IGNvbXBvbmVudENvbGxlY3Rpb24pIHsKLQkJdGhpcy5zaXplIC09IGNvbXBvbmVudENvbGxlY3Rpb24uc2l6ZSgpOwotCQljb21wb25lbnRDb2xsZWN0aW9uLmNsZWFyKCk7Ci0JfQotCi0JLyoqCi0JICogVGhlIGNvbXBvbmVudCBzb3VyY2VzIGNsZWFyZWQ7Ci0JICogY2xlYXIgb3VyIGNhY2hlLgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGNvbGxlY3Rpb25DbGVhcmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLnJlbW92ZUFsbENvbXBvbmVudFNvdXJjZXMoKTsKLQkJdGhpcy5maXJlQ29sbGVjdGlvbkNsZWFyZWQoVkFMVUVTKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCByZW1vdmVBbGxDb21wb25lbnRTb3VyY2VzKCkgewotCQkvLyBjb3B5IHRoZSBrZXlzIHNvIHdlIGRvbid0IGVhdCBvdXIgb3duIHRhaWwKLQkJQXJyYXlMaXN0PEUxPiBjb3B5ID0gbmV3IEFycmF5TGlzdDxFMT4odGhpcy5jb21wb25lbnRDVk1zLmtleVNldCgpKTsKLQkJZm9yIChFMSBzb3VyY2UgOiBjb3B5KSB7Ci0JCQl0aGlzLnJlbW92ZUNvbXBvbmVudFNvdXJjZShzb3VyY2UsIE51bGxMaXN0LjxFMj5pbnN0YW5jZSgpKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFRoZSBjb21wb25lbnQgc291cmNlcyBjaGFuZ2VkOwotCSAqIHJlYnVpbGQgb3VyIGNhY2hlLgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGNvbGxlY3Rpb25DaGFuZ2VkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLnJlbW92ZUFsbENvbXBvbmVudFNvdXJjZXMoKTsKLQkJdGhpcy5hZGRBbGxDb21wb25lbnRTb3VyY2VzKCk7Ci0JCXRoaXMuZmlyZUNvbGxlY3Rpb25DaGFuZ2VkKFZBTFVFUyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGludGVybmFsIG1ldGhvZHMgKioqKioqKioqKgotCi0JLyoqCi0JICogVHJhbnNmb3JtIHRoZSBzcGVjaWZpZWQgb2JqZWN0IGludG8gYSBjb2xsZWN0aW9uIHZhbHVlIG1vZGVsLgotCSAqIDxwPgotCSAqIFRoaXMgbWV0aG9kIGNhbiBiZSBvdmVycmlkZGVuIGJ5IGEgc3ViY2xhc3MgYXMgYW4KLQkgKiBhbHRlcm5hdGl2ZSB0byBidWlsZGluZyBhIDxjb2RlPlRyYW5zZm9ybWVyPC9jb2RlPi4KLQkgKi8KLQlwcm90ZWN0ZWQgQ29sbGVjdGlvblZhbHVlTW9kZWw8RTI+IHRyYW5zZm9ybShFMSB2YWx1ZSkgewotCQlyZXR1cm4gdGhpcy50cmFuc2Zvcm1lci50cmFuc2Zvcm0odmFsdWUpOwotCX0KLQotCS8qKgotCSAqIE9uZSBvZiB0aGUgY29tcG9uZW50IGNvbGxlY3Rpb25zIGhhZCBpdGVtcyBhZGRlZDsKLQkgKiBzeW5jaHJvbml6ZSBvdXIgY2FjaGVzLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGNvbXBvbmVudEl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCWludCBpdGVtc1NpemUgPSBldmVudC5pdGVtc1NpemUoKTsKLQkJdGhpcy5zaXplICs9IGl0ZW1zU2l6ZTsKLQotCQlBcnJheUxpc3Q8RTI+IGNvbXBvbmVudENvbGxlY3Rpb24gPSB0aGlzLmNvbGxlY3Rpb25zLmdldCh0aGlzLmNvbXBvbmVudENWTShldmVudCkpOwotCQljb21wb25lbnRDb2xsZWN0aW9uLmVuc3VyZUNhcGFjaXR5KGNvbXBvbmVudENvbGxlY3Rpb24uc2l6ZSgpICsgaXRlbXNTaXplKTsKLQotCQl0aGlzLmFkZEl0ZW1zVG9Db2xsZWN0aW9uKHRoaXMuY29tcG9uZW50SXRlbXMoZXZlbnQpLCBjb21wb25lbnRDb2xsZWN0aW9uLCBWQUxVRVMpOwotCX0KLQotCS8qKgotCSAqIE9uZSBvZiB0aGUgY29tcG9uZW50IGNvbGxlY3Rpb25zIGhhZCBpdGVtcyByZW1vdmVkOwotCSAqIHN5bmNocm9uaXplIG91ciBjYWNoZXMuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgY29tcG9uZW50SXRlbXNSZW1vdmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLnNpemUgLT0gZXZlbnQuaXRlbXNTaXplKCk7Ci0JCUFycmF5TGlzdDxFMj4gY29tcG9uZW50Q29sbGVjdGlvbiA9IHRoaXMuY29sbGVjdGlvbnMuZ2V0KHRoaXMuY29tcG9uZW50Q1ZNKGV2ZW50KSk7Ci0JCXRoaXMucmVtb3ZlSXRlbXNGcm9tQ29sbGVjdGlvbih0aGlzLmNvbXBvbmVudEl0ZW1zKGV2ZW50KSwgY29tcG9uZW50Q29sbGVjdGlvbiwgVkFMVUVTKTsKLQl9Ci0KLQkvKioKLQkgKiBPbmUgb2YgdGhlIGNvbXBvbmVudCBjb2xsZWN0aW9ucyB3YXMgY2xlYXJlZDsKLQkgKiBzeW5jaHJvbml6ZSBvdXIgY2FjaGVzIGJ5IGNsZWFyaW5nIG91dCB0aGUgYXBwcm9wcmlhdGUKLQkgKiBjb2xsZWN0aW9uLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGNvbXBvbmVudENvbGxlY3Rpb25DbGVhcmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQlBcnJheUxpc3Q8RTI+IGNvbXBvbmVudENvbGxlY3Rpb24gPSB0aGlzLmNvbGxlY3Rpb25zLmdldCh0aGlzLmNvbXBvbmVudENWTShldmVudCkpOwotCQlBcnJheUxpc3Q8RTI+IHJlbW92ZWRJdGVtcyA9IG5ldyBBcnJheUxpc3Q8RTI+KGNvbXBvbmVudENvbGxlY3Rpb24pOwotCQl0aGlzLnJlbW92ZUNvbXBvbmVudEl0ZW1zKGNvbXBvbmVudENvbGxlY3Rpb24pOwotCQl0aGlzLmZpcmVJdGVtc1JlbW92ZWQoVkFMVUVTLCByZW1vdmVkSXRlbXMpOwotCX0KLQotCS8qKgotCSAqIE9uZSBvZiB0aGUgY29tcG9uZW50IGNvbGxlY3Rpb25zIGNoYW5nZWQ7Ci0JICogc3luY2hyb25pemUgb3VyIGNhY2hlcyBieSBjbGVhcmluZyBvdXQgdGhlIGFwcHJvcHJpYXRlCi0JICogY29sbGVjdGlvbiBhbmQgdGhlbiByZWJ1aWxkaW5nIGl0LgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGNvbXBvbmVudENvbGxlY3Rpb25DaGFuZ2VkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQlDb2xsZWN0aW9uVmFsdWVNb2RlbDxFMj4gY29tcG9uZW50Q1ZNID0gdGhpcy5jb21wb25lbnRDVk0oZXZlbnQpOwotCQlBcnJheUxpc3Q8RTI+IGNvbXBvbmVudENvbGxlY3Rpb24gPSB0aGlzLmNvbGxlY3Rpb25zLmdldChjb21wb25lbnRDVk0pOwotCQl0aGlzLnJlbW92ZUNvbXBvbmVudEl0ZW1zKGNvbXBvbmVudENvbGxlY3Rpb24pOwotCQl0aGlzLmFkZENvbXBvbmVudEl0ZW1zKGNvbXBvbmVudENWTSwgY29tcG9uZW50Q29sbGVjdGlvbik7Ci0JCXRoaXMuZmlyZUNvbGxlY3Rpb25DaGFuZ2VkKFZBTFVFUyk7Ci0JfQotCi0JLy8gbWluaW1pemUgc2NvcGUgb2Ygc3VwcHJlc3NlZCB3YXJuaW5ncwotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByb3RlY3RlZCBJdGVyYXRvcjxFMj4gY29tcG9uZW50SXRlbXMoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXJldHVybiAoSXRlcmF0b3I8RTI+KSBldmVudC5pdGVtcygpOwotCX0KLQotCS8vIG1pbmltaXplIHNjb3BlIG9mIHN1cHByZXNzZWQgd2FybmluZ3MKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcm90ZWN0ZWQgQ29sbGVjdGlvblZhbHVlTW9kZWw8RTI+IGNvbXBvbmVudENWTShDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIChDb2xsZWN0aW9uVmFsdWVNb2RlbDxFMj4pIGV2ZW50LmdldFNvdXJjZSgpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0NvbXBvc2l0ZUxpc3RWYWx1ZU1vZGVsLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ29tcG9zaXRlTGlzdFZhbHVlTW9kZWwuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzYwOWQ1YS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ29tcG9zaXRlTGlzdFZhbHVlTW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU3NCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuVHJhbnNmb3JtZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlJlYWRPbmx5Q29tcG9zaXRlTGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5UcmFuc2Zvcm1hdGlvbkxpc3RJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5MaXN0Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuTGlzdENoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotCi0vKioKLSAqIEEgPGNvZGU+Q29tcG9zaXRlTGlzdFZhbHVlTW9kZWw8L2NvZGU+IHdyYXBzIGFub3RoZXIKLSAqIDxjb2RlPkxpc3RWYWx1ZU1vZGVsPC9jb2RlPiBhbmQgdXNlcyBhIDxjb2RlPlRyYW5zZm9ybWVyPC9jb2RlPgotICogdG8gY29udmVydCBlYWNoIGl0ZW0gaW4gdGhlIHdyYXBwZWQgbGlzdCB0byB5ZXQgYW5vdGhlcgotICogPGNvZGU+TGlzdFZhbHVlTW9kZWw8L2NvZGU+LiBUaGlzIGNvbXBvc2l0ZSBsaXN0IGNvbnRhaW5zCi0gKiB0aGUgY29tYmluZWQgaXRlbXMgZnJvbSBhbGwgdGhlc2UgY29tcG9uZW50IGxpc3RzLgotICogCi0gKiBUZXJtaW5vbG9neToKLSAqIC0gc291cmNlcyAtIHRoZSBpdGVtcyBpbiB0aGUgd3JhcHBlZCBsaXN0IHZhbHVlIG1vZGVsOyB0aGVzZQotICogICAgYXJlIGNvbnZlcnRlZCBpbnRvIGNvbXBvbmVudCBMVk1zIGJ5IHRoZSB0cmFuc2Zvcm1lcgotICogLSBjb21wb25lbnRMVk1zIC0gdGhlIGNvbXBvbmVudCBsaXN0IHZhbHVlIG1vZGVscyB0aGF0IGFyZSBjb21iaW5lZAotICogICAgYnkgdGhpcyBjb21wb3NpdGUgbGlzdCB2YWx1ZSBtb2RlbAotICogLSBpdGVtcyAtIHRoZSBpdGVtcyBoZWxkIGJ5IHRoZSBjb21wb25lbnQgTFZNcwotICovCi1wdWJsaWMgY2xhc3MgQ29tcG9zaXRlTGlzdFZhbHVlTW9kZWw8RTEsIEUyPgotCWV4dGVuZHMgTGlzdFZhbHVlTW9kZWxXcmFwcGVyPEUxPgotCWltcGxlbWVudHMgTGlzdFZhbHVlTW9kZWw8RTI+Ci17Ci0JLyoqCi0JICogVGhpcyBpcyB0aGUgKG9wdGlvbmFsKSB1c2VyLXN1cHBsaWVkIG9iamVjdCB0aGF0IHRyYW5zZm9ybXMKLQkgKiB0aGUgaXRlbXMgaW4gdGhlIHdyYXBwZWQgbGlzdCB0byBsaXN0IHZhbHVlIG1vZGVscy4KLQkgKi8KLQlwcml2YXRlIGZpbmFsIFRyYW5zZm9ybWVyPEUxLCBMaXN0VmFsdWVNb2RlbDxFMj4+IHRyYW5zZm9ybWVyOwotCi0JLyoqCi0JICogQ2FjaGUgb2YgdGhlIHNvdXJjZXMsIGNvbXBvbmVudCBMVk1zLCBsaXN0cy4KLQkgKi8KLQlwcml2YXRlIGZpbmFsIEFycmF5TGlzdDxJbmZvPiBpbmZvTGlzdDsKLQlwcm90ZWN0ZWQgY2xhc3MgSW5mbyB7Ci0JCS8vIHRoZSBvYmplY3QgcGFzc2VkIHRvIHRoZSB0cmFuc2Zvcm1lcgotCQlmaW5hbCBFMSBzb3VyY2U7Ci0JCS8vIHRoZSBsaXN0IHZhbHVlIG1vZGVsIGdlbmVyYXRlZCBieSB0aGUgdHJhbnNmb3JtZXIKLQkJZmluYWwgTGlzdFZhbHVlTW9kZWw8RTI+IGNvbXBvbmVudExWTTsKLQkJLy8gY2FjaGUgb2YgdGhlIGl0ZW1zIGhlbGQgYnkgdGhlIGNvbXBvbmVudCBMVk0KLQkJZmluYWwgQXJyYXlMaXN0PEUyPiBpdGVtczsKLQkJLy8gdGhlIGNvbXBvbmVudCBMVk0ncyBiZWdpbm5pbmcgaW5kZXggd2l0aGluIHRoZSBjb21wb3NpdGUgTFZNCi0JCWludCBiZWdpbjsKLQkJSW5mbyhFMSBzb3VyY2UsIExpc3RWYWx1ZU1vZGVsPEUyPiBjb21wb25lbnRMVk0sIEFycmF5TGlzdDxFMj4gaXRlbXMsIGludCBiZWdpbikgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMuc291cmNlID0gc291cmNlOwotCQkJdGhpcy5jb21wb25lbnRMVk0gPSBjb21wb25lbnRMVk07Ci0JCQl0aGlzLml0ZW1zID0gaXRlbXM7Ci0JCQl0aGlzLmJlZ2luID0gYmVnaW47Ci0JCX0KLQl9Ci0KLQkvKiogTGlzdGVuZXIgdGhhdCBsaXN0ZW5zIHRvIGFsbCB0aGUgY29tcG9uZW50IGxpc3QgdmFsdWUgbW9kZWxzLiAqLwotCXByaXZhdGUgZmluYWwgTGlzdENoYW5nZUxpc3RlbmVyIGNvbXBvbmVudExWTUxpc3RlbmVyOwotCi0JLyoqIENhY2hlIHRoZSBzaXplIG9mIHRoZSBjb21wb3NpdGUgbGlzdC4gKi8KLQlwcml2YXRlIGludCBzaXplOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBsaXN0IHZhbHVlIG1vZGVsIHdpdGggdGhlIHNwZWNpZmllZCB3cmFwcGVkCi0JICogbGlzdCB2YWx1ZSBtb2RlbC4gVXNlIHRoaXMgY29uc3RydWN0b3IgaWYKLQkgKiAgICAgLSB0aGUgd3JhcHBlZCBsaXN0IHZhbHVlIG1vZGVsIGFscmVhZHkgY29udGFpbnMgb3RoZXIKLQkgKiAgICAgICBsaXN0IHZhbHVlIG1vZGVscyBvcgotCSAqICAgICAtIHlvdSB3YW50IHRvIG92ZXJyaWRlIHRoZSA8Y29kZT50cmFuc2Zvcm0oRTEpPC9jb2RlPiBtZXRob2QKLQkgKiAgICAgICBpbnN0ZWFkIG9mIGJ1aWxkaW5nIGEgPGNvZGU+VHJhbnNmb3JtZXI8L2NvZGU+Ci0JICovCi0JcHVibGljIENvbXBvc2l0ZUxpc3RWYWx1ZU1vZGVsKExpc3RWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBFMT4gbGlzdEhvbGRlcikgewotCQl0aGlzKGxpc3RIb2xkZXIsIFRyYW5zZm9ybWVyLk51bGwuPEUxLCBMaXN0VmFsdWVNb2RlbDxFMj4+aW5zdGFuY2UoKSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgbGlzdCB2YWx1ZSBtb2RlbCB3aXRoIHRoZSBzcGVjaWZpZWQgd3JhcHBlZAotCSAqIGxpc3QgdmFsdWUgbW9kZWwgYW5kIHRyYW5zZm9ybWVyLgotCSAqLwotCXB1YmxpYyBDb21wb3NpdGVMaXN0VmFsdWVNb2RlbChMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRTE+IGxpc3RIb2xkZXIsIFRyYW5zZm9ybWVyPEUxLCBMaXN0VmFsdWVNb2RlbDxFMj4+IHRyYW5zZm9ybWVyKSB7Ci0JCXN1cGVyKGxpc3RIb2xkZXIpOwotCQl0aGlzLnRyYW5zZm9ybWVyID0gdHJhbnNmb3JtZXI7Ci0JCXRoaXMuaW5mb0xpc3QgPSBuZXcgQXJyYXlMaXN0PEluZm8+KCk7Ci0JCXRoaXMuY29tcG9uZW50TFZNTGlzdGVuZXIgPSB0aGlzLmJ1aWxkQ29tcG9uZW50TFZNTGlzdGVuZXIoKTsKLQkJdGhpcy5zaXplID0gMDsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBsaXN0IHZhbHVlIG1vZGVsIHdpdGggdGhlIHNwZWNpZmllZCwgdW5jaGFuZ2luZywgd3JhcHBlZAotCSAqIGxpc3QuIFVzZSB0aGlzIGNvbnN0cnVjdG9yIGlmCi0JICogICAgIC0gdGhlIHdyYXBwZWQgbGlzdCBhbHJlYWR5IGNvbnRhaW5zIGxpc3QgdmFsdWUgbW9kZWxzIG9yCi0JICogICAgIC0geW91IHdhbnQgdG8gb3ZlcnJpZGUgdGhlIDxjb2RlPnRyYW5zZm9ybShFMSk8L2NvZGU+IG1ldGhvZAotCSAqICAgICAgIGluc3RlYWQgb2YgYnVpbGRpbmcgYSA8Y29kZT5UcmFuc2Zvcm1lcjwvY29kZT4KLQkgKi8KLQlwdWJsaWMgQ29tcG9zaXRlTGlzdFZhbHVlTW9kZWwoTGlzdDw/IGV4dGVuZHMgRTE+IGxpc3QpIHsKLQkJdGhpcyhuZXcgU3RhdGljTGlzdFZhbHVlTW9kZWw8RTE+KGxpc3QpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBsaXN0IHZhbHVlIG1vZGVsIHdpdGggdGhlIHNwZWNpZmllZCwgdW5jaGFuZ2luZywgd3JhcHBlZAotCSAqIGxpc3QgYW5kIHRyYW5zZm9ybWVyLgotCSAqLwotCXB1YmxpYyBDb21wb3NpdGVMaXN0VmFsdWVNb2RlbChMaXN0PD8gZXh0ZW5kcyBFMT4gbGlzdCwgVHJhbnNmb3JtZXI8RTEsIExpc3RWYWx1ZU1vZGVsPEUyPj4gdHJhbnNmb3JtZXIpIHsKLQkJdGhpcyhuZXcgU3RhdGljTGlzdFZhbHVlTW9kZWw8RTE+KGxpc3QpLCB0cmFuc2Zvcm1lcik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCXByb3RlY3RlZCBMaXN0Q2hhbmdlTGlzdGVuZXIgYnVpbGRDb21wb25lbnRMVk1MaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBMaXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUNvbXBvc2l0ZUxpc3RWYWx1ZU1vZGVsLnRoaXMuY29tcG9uZW50SXRlbXNBZGRlZChldmVudCk7Ci0JCQl9CQkKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlDb21wb3NpdGVMaXN0VmFsdWVNb2RlbC50aGlzLmNvbXBvbmVudEl0ZW1zUmVtb3ZlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc1JlcGxhY2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUNvbXBvc2l0ZUxpc3RWYWx1ZU1vZGVsLnRoaXMuY29tcG9uZW50SXRlbXNSZXBsYWNlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc01vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUNvbXBvc2l0ZUxpc3RWYWx1ZU1vZGVsLnRoaXMuY29tcG9uZW50SXRlbXNNb3ZlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlDb21wb3NpdGVMaXN0VmFsdWVNb2RlbC50aGlzLmNvbXBvbmVudExpc3RDbGVhcmVkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGxpc3RDaGFuZ2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUNvbXBvc2l0ZUxpc3RWYWx1ZU1vZGVsLnRoaXMuY29tcG9uZW50TGlzdENoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiY29tcG9uZW50IExWTSBsaXN0ZW5lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIExpc3RWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBFMiBnZXQoaW50IGluZGV4KSB7Ci0JCWlmICgoaW5kZXggPCAwKSB8fCAoaW5kZXggPj0gdGhpcy5zaXplKSkgewotCQkJdGhyb3cgbmV3IEluZGV4T3V0T2ZCb3VuZHNFeGNlcHRpb24oIkluZGV4OiAiICsgaW5kZXggKyAiLCBTaXplOiAiICsgdGhpcy5zaXplKTsKLQkJfQotCQkvLyBtb3ZlIGJhY2t3YXJkcyB0aHJvdWdoIHRoZSBpbmZvIGxpc3QKLQkJZm9yIChpbnQgaSA9IHRoaXMuaW5mb0xpc3Quc2l6ZSgpOyBpLS0gPiAwOyApIHsKLQkJCUluZm8gaW5mbyA9IHRoaXMuaW5mb0xpc3QuZ2V0KGkpOwotCQkJaWYgKGluZGV4ID49IGluZm8uYmVnaW4pIHsKLQkJCQlyZXR1cm4gaW5mby5pdGVtcy5nZXQoaW5kZXggLSBpbmZvLmJlZ2luKTsKLQkJCX0KLQkJfQotCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCk7ICAvLyBzb21ldGhpbmcgaXMgd2FjawotCX0KLQotCXB1YmxpYyBJdGVyYXRvcjxFMj4gaXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3RJdGVyYXRvcigpOwotCX0KLQotCXB1YmxpYyBMaXN0SXRlcmF0b3I8RTI+IGxpc3RJdGVyYXRvcigpIHsKLQkJcmV0dXJuIG5ldyBSZWFkT25seUNvbXBvc2l0ZUxpc3RJdGVyYXRvcjxFMj4odGhpcy5idWlsZExpc3RzSXRlcmF0b3JzKCkpOwotCX0KLQotCXByb3RlY3RlZCBMaXN0SXRlcmF0b3I8TGlzdEl0ZXJhdG9yPEUyPj4gYnVpbGRMaXN0c0l0ZXJhdG9ycygpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkxpc3RJdGVyYXRvcjxJbmZvLCBMaXN0SXRlcmF0b3I8RTI+Pih0aGlzLmluZm9MaXN0Lmxpc3RJdGVyYXRvcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBMaXN0SXRlcmF0b3I8RTI+IHRyYW5zZm9ybShJbmZvIGluZm8pIHsKLQkJCQlyZXR1cm4gaW5mby5pdGVtcy5saXN0SXRlcmF0b3IoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwdWJsaWMgaW50IHNpemUoKSB7Ci0JCXJldHVybiB0aGlzLnNpemU7Ci0JfQotCi0JcHVibGljIE9iamVjdFtdIHRvQXJyYXkoKSB7Ci0JCXJldHVybiBDb2xsZWN0aW9uVG9vbHMuYXJyYXkodGhpcy5saXN0SXRlcmF0b3IoKSwgdGhpcy5zaXplKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogTGlzdFZhbHVlTW9kZWxXcmFwcGVyIG92ZXJyaWRlcy9pbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VNb2RlbCgpIHsKLQkJc3VwZXIuZW5nYWdlTW9kZWwoKTsKLQkJLy8gc3luY2ggb3VyIGNhY2hlICphZnRlciogd2Ugc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSB3cmFwcGVkIGxpc3QsCi0JCS8vIHNpbmNlIGl0cyB2YWx1ZSBtaWdodCBjaGFuZ2Ugd2hlbiBhIGxpc3RlbmVyIGlzIGFkZGVkCi0JCXRoaXMuYWRkQ29tcG9uZW50U291cmNlcygwLCB0aGlzLmxpc3RIb2xkZXIubGlzdEl0ZXJhdG9yKCksIHRoaXMubGlzdEhvbGRlci5zaXplKCkpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZU1vZGVsKCkgewotCQlzdXBlci5kaXNlbmdhZ2VNb2RlbCgpOwotCQkvLyBzdG9wIGxpc3RlbmluZyB0byB0aGUgY29tcG9uZW50IExWTXMuLi4KLQkJZm9yIChJbmZvIGluZm8gOiB0aGlzLmluZm9MaXN0KSB7Ci0JCQlpbmZvLmNvbXBvbmVudExWTS5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoTElTVF9WQUxVRVMsIHRoaXMuY29tcG9uZW50TFZNTGlzdGVuZXIpOwotCQl9Ci0JCS8vIC4uLmFuZCBjbGVhciB0aGUgY2FjaGUKLQkJdGhpcy5pbmZvTGlzdC5jbGVhcigpOwotCQl0aGlzLnNpemUgPSAwOwotCX0KLQotCS8qKgotCSAqIFNvbWUgY29tcG9uZW50IHNvdXJjZXMgd2VyZSBhZGRlZDsgdXBkYXRlIG91ciBjYWNoZS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmFkZENvbXBvbmVudFNvdXJjZXMoZXZlbnQuZ2V0SW5kZXgoKSwgdGhpcy5pdGVtcyhldmVudCksIGV2ZW50Lml0ZW1zU2l6ZSgpLCB0cnVlKTsgIC8vIHRydWUgPSBmaXJlIGV2ZW50Ci0JfQotCi0JLyoqCi0JICogRG8gbm90IGZpcmUgYW4gZXZlbnQuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgYWRkQ29tcG9uZW50U291cmNlcyhpbnQgYWRkZWRTb3VyY2VzSW5kZXgsIExpc3RJdGVyYXRvcjw/IGV4dGVuZHMgRTE+IGFkZGVkU291cmNlcywgaW50IGFkZGVkU291cmNlc1NpemUpIHsKLQkJdGhpcy5hZGRDb21wb25lbnRTb3VyY2VzKGFkZGVkU291cmNlc0luZGV4LCBhZGRlZFNvdXJjZXMsIGFkZGVkU291cmNlc1NpemUsIGZhbHNlKTsgIC8vIGZhbHNlID0gZG8gbm90IGZpcmUgZXZlbnQKLQl9Ci0KLQkvKioKLQkgKiBBZGQgaW5mb3MgY29ycmVzcG9uZGluZyB0byB0aGUgc3BlY2lmaWVkIHNvdXJjZXMgdG8gb3VyIGNhY2hlLgotCSAqIEZpcmUgdGhlIGFwcHJvcHJpYXRlIGV2ZW50IGlmIHJlcXVlc3RlZC4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBhZGRDb21wb25lbnRTb3VyY2VzKGludCBhZGRlZFNvdXJjZXNJbmRleCwgTGlzdEl0ZXJhdG9yPD8gZXh0ZW5kcyBFMT4gYWRkZWRTb3VyY2VzLCBpbnQgYWRkZWRTb3VyY2VzU2l6ZSwgYm9vbGVhbiBmaXJlRXZlbnQpIHsKLQkJQXJyYXlMaXN0PEluZm8+IG5ld0luZm9MaXN0ID0gbmV3IEFycmF5TGlzdDxJbmZvPihhZGRlZFNvdXJjZXNTaXplKTsKLQkJLy8gdGhlICdpdGVtcycgYXJlIGVpdGhlciB0YWNrZWQgb24gdG8gdGhlIGVuZCBvcgotCQkvLyBhdCB0aGUgJ2JlZ2luJyBpbmRleCBvZiB0aGUgZmlyc3QgJ2luZm8nIHRoYXQgaXMgYmVpbmcgcHVzaGVkIGJhY2sKLQkJaW50IG5ld0l0ZW1zSW5kZXggPSAoYWRkZWRTb3VyY2VzSW5kZXggPT0gdGhpcy5pbmZvTGlzdC5zaXplKCkpID8gdGhpcy5zaXplIDogdGhpcy5pbmZvTGlzdC5nZXQoYWRkZWRTb3VyY2VzSW5kZXgpLmJlZ2luOwotCi0JCWludCBiZWdpbiA9IG5ld0l0ZW1zSW5kZXg7Ci0JCXdoaWxlIChhZGRlZFNvdXJjZXMuaGFzTmV4dCgpKSB7Ci0JCQlFMSBzb3VyY2UgPSBhZGRlZFNvdXJjZXMubmV4dCgpOwotCQkJTGlzdFZhbHVlTW9kZWw8RTI+IGNvbXBvbmVudExWTSA9IHRoaXMudHJhbnNmb3JtKHNvdXJjZSk7Ci0JCQljb21wb25lbnRMVk0uYWRkTGlzdENoYW5nZUxpc3RlbmVyKExJU1RfVkFMVUVTLCB0aGlzLmNvbXBvbmVudExWTUxpc3RlbmVyKTsKLQkJCUFycmF5TGlzdDxFMj4gaXRlbXMgPSBuZXcgQXJyYXlMaXN0PEUyPihjb21wb25lbnRMVk0uc2l6ZSgpKTsKLQkJCUNvbGxlY3Rpb25Ub29scy5hZGRBbGwoaXRlbXMsIGNvbXBvbmVudExWTS5saXN0SXRlcmF0b3IoKSk7Ci0JCQluZXdJbmZvTGlzdC5hZGQobmV3IEluZm8oc291cmNlLCBjb21wb25lbnRMVk0sIGl0ZW1zLCBiZWdpbikpOwotCQkJYmVnaW4gKz0gaXRlbXMuc2l6ZSgpOwotCQl9Ci0JCXRoaXMuaW5mb0xpc3QuYWRkQWxsKGFkZGVkU291cmNlc0luZGV4LCBuZXdJbmZvTGlzdCk7Ci0JCWludCBuZXdJdGVtc1NpemUgPSBiZWdpbiAtIG5ld0l0ZW1zSW5kZXg7Ci0JCXRoaXMuc2l6ZSArPSBuZXdJdGVtc1NpemU7Ci0KLQkJLy8gYnVtcCB0aGUgJ2JlZ2luJyBpbmRleCBmb3IgYWxsIHRoZSBpbmZvcyB0aGF0IHdlcmUgcHVzaGVkIGJhY2sgYnkgdGhlIGluc2VydAotCQlpbnQgbW92ZWRJbmZvc0luZGV4ID0gYWRkZWRTb3VyY2VzSW5kZXggKyBhZGRlZFNvdXJjZXNTaXplOwotCQlmb3IgKGludCBpID0gbW92ZWRJbmZvc0luZGV4OyBpIDwgdGhpcy5pbmZvTGlzdC5zaXplKCk7IGkrKykgewotCQkJdGhpcy5pbmZvTGlzdC5nZXQoaSkuYmVnaW4gKz0gbmV3SXRlbXNTaXplOwotCQl9Ci0KLQkJaWYgKGZpcmVFdmVudCkgewotCQkJQXJyYXlMaXN0PEUyPiBuZXdJdGVtcyA9IG5ldyBBcnJheUxpc3Q8RTI+KG5ld0l0ZW1zU2l6ZSk7Ci0JCQlmb3IgKGludCBpID0gYWRkZWRTb3VyY2VzSW5kZXg7IGkgPCBtb3ZlZEluZm9zSW5kZXg7IGkrKykgewotCQkJCW5ld0l0ZW1zLmFkZEFsbCh0aGlzLmluZm9MaXN0LmdldChpKS5pdGVtcyk7Ci0JCQl9Ci0JCQl0aGlzLmZpcmVJdGVtc0FkZGVkKExJU1RfVkFMVUVTLCBuZXdJdGVtc0luZGV4LCBuZXdJdGVtcyk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBTb21lIGNvbXBvbmVudCBzb3VyY2VzIHdlcmUgcmVtb3ZlZDsgdXBkYXRlIG91ciBjYWNoZS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpdGVtc1JlbW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMucmVtb3ZlQ29tcG9uZW50U291cmNlcyhldmVudC5nZXRJbmRleCgpLCBldmVudC5pdGVtc1NpemUoKSwgdHJ1ZSk7ICAvLyB0cnVlID0gZmlyZSBldmVudAotCX0KLQotCS8qKgotCSAqIERvIG5vdCBmaXJlIGFuIGV2ZW50LgotCSAqLwotCXByb3RlY3RlZCB2b2lkIHJlbW92ZUNvbXBvbmVudFNvdXJjZXMoaW50IHJlbW92ZWRTb3VyY2VzSW5kZXgsIGludCByZW1vdmVkU291cmNlc1NpemUpIHsKLQkJdGhpcy5yZW1vdmVDb21wb25lbnRTb3VyY2VzKHJlbW92ZWRTb3VyY2VzSW5kZXgsIHJlbW92ZWRTb3VyY2VzU2l6ZSwgZmFsc2UpOyAgLy8gZmFsc2UgPSBkbyBub3QgZmlyZSBldmVudAotCX0KLQotCS8qKgotCSAqIFJlbW92ZSB0aGUgaW5mb3MgY29ycmVzcG9uZGluZyB0byB0aGUgc3BlY2lmaWVkIHNvdXJjZXMgZnJvbSBvdXIgY2FjaGUuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgcmVtb3ZlQ29tcG9uZW50U291cmNlcyhpbnQgcmVtb3ZlZFNvdXJjZXNJbmRleCwgaW50IHJlbW92ZWRTb3VyY2VzU2l6ZSwgYm9vbGVhbiBmaXJlRXZlbnQpIHsKLQkJaW50IHJlbW92ZWRJdGVtc0luZGV4ID0gdGhpcy5pbmZvTGlzdC5nZXQocmVtb3ZlZFNvdXJjZXNJbmRleCkuYmVnaW47Ci0JCWludCBtb3ZlZFNvdXJjZXNJbmRleCA9IHJlbW92ZWRTb3VyY2VzSW5kZXggKyByZW1vdmVkU291cmNlc1NpemU7Ci0JCWludCBtb3ZlZEl0ZW1zSW5kZXggPSAobW92ZWRTb3VyY2VzSW5kZXggPT0gdGhpcy5pbmZvTGlzdC5zaXplKCkpID8gdGhpcy5zaXplIDogdGhpcy5pbmZvTGlzdC5nZXQobW92ZWRTb3VyY2VzSW5kZXgpLmJlZ2luOwotCQlpbnQgcmVtb3ZlZEl0ZW1zU2l6ZSA9IG1vdmVkSXRlbXNJbmRleCAtIHJlbW92ZWRJdGVtc0luZGV4OwotCQl0aGlzLnNpemUgLT0gcmVtb3ZlZEl0ZW1zU2l6ZTsKLQotCQlMaXN0PEluZm8+IHN1Ykxpc3QgPSB0aGlzLmluZm9MaXN0LnN1Ykxpc3QocmVtb3ZlZFNvdXJjZXNJbmRleCwgcmVtb3ZlZFNvdXJjZXNJbmRleCArIHJlbW92ZWRTb3VyY2VzU2l6ZSk7Ci0JCUFycmF5TGlzdDxJbmZvPiByZW1vdmVkSW5mb0xpc3QgPSBuZXcgQXJyYXlMaXN0PEluZm8+KHN1Ykxpc3QpOyAgLy8gbWFrZSBhIGNvcHkKLQkJc3ViTGlzdC5jbGVhcigpOwotCi0JCS8vIGRlY3JlbWVudCB0aGUgJ2JlZ2luJyBpbmRleCBmb3IgYWxsIHRoZSBpbmZvcyB0aGF0IHdlcmUgbW92ZWQgZm9yd2FyZCBieSB0aGUgZGVsZXRlcwotCQlmb3IgKGludCBpID0gcmVtb3ZlZFNvdXJjZXNJbmRleDsgaSA8IHRoaXMuaW5mb0xpc3Quc2l6ZSgpOyBpKyspIHsKLQkJCXRoaXMuaW5mb0xpc3QuZ2V0KGkpLmJlZ2luIC09IHJlbW92ZWRJdGVtc1NpemU7Ci0JCX0KLQotCQlmb3IgKEluZm8gcmVtb3ZlZEluZm8gOiByZW1vdmVkSW5mb0xpc3QpIHsKLQkJCXJlbW92ZWRJbmZvLmNvbXBvbmVudExWTS5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoTElTVF9WQUxVRVMsIHRoaXMuY29tcG9uZW50TFZNTGlzdGVuZXIpOwotCQl9Ci0KLQkJaWYgKGZpcmVFdmVudCkgewotCQkJQXJyYXlMaXN0PEUyPiByZW1vdmVkSXRlbXMgPSBuZXcgQXJyYXlMaXN0PEUyPihyZW1vdmVkSXRlbXNTaXplKTsKLQkJCWZvciAoSW5mbyByZW1vdmVkSW5mbyA6IHJlbW92ZWRJbmZvTGlzdCkgewotCQkJCXJlbW92ZWRJdGVtcy5hZGRBbGwocmVtb3ZlZEluZm8uaXRlbXMpOwotCQkJfQotCQkJdGhpcy5maXJlSXRlbXNSZW1vdmVkKExJU1RfVkFMVUVTLCByZW1vdmVkSXRlbXNJbmRleCwgcmVtb3ZlZEl0ZW1zKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFNvbWUgY29tcG9uZW50IHNvdXJjZXMgd2VyZSByZXBsYWNlZDsgdXBkYXRlIG91ciBjYWNoZS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpdGVtc1JlcGxhY2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLnJlcGxhY2VDb21wb25lbnRTb3VyY2VzKGV2ZW50LmdldEluZGV4KCksIHRoaXMuaXRlbXMoZXZlbnQpLCBldmVudC5pdGVtc1NpemUoKSwgdHJ1ZSk7ICAvLyB0cnVlID0gZmlyZSBldmVudAotCX0KLQotCS8qKgotCSAqIFJlcGxhY2VkIGNvbXBvbmVudCBzb3VyY2VzIHdpbGwgbm90ICh0eXBpY2FsbHkpIG1hcCB0byBhIHNldCBvZiByZXBsYWNlZAotCSAqIGl0ZW1zLCBzbyB3ZSByZW1vdmUgYW5kIGFkZCB0aGUgY29ycmVzcG9uZGluZyBsaXN0cyBvZiBpdGVtcywgcmVzdWx0aW5nIGluCi0JICogdHdvIGV2ZW50cy4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCByZXBsYWNlQ29tcG9uZW50U291cmNlcyhpbnQgcmVwbGFjZWRTb3VyY2VzSW5kZXgsIExpc3RJdGVyYXRvcjw/IGV4dGVuZHMgRTE+IG5ld1NvdXJjZXMsIGludCByZXBsYWNlZFNvdXJjZXNTaXplLCBib29sZWFuIGZpcmVFdmVudCkgewotCQl0aGlzLnJlbW92ZUNvbXBvbmVudFNvdXJjZXMocmVwbGFjZWRTb3VyY2VzSW5kZXgsIHJlcGxhY2VkU291cmNlc1NpemUsIGZpcmVFdmVudCk7Ci0JCXRoaXMuYWRkQ29tcG9uZW50U291cmNlcyhyZXBsYWNlZFNvdXJjZXNJbmRleCwgbmV3U291cmNlcywgcmVwbGFjZWRTb3VyY2VzU2l6ZSwgZmlyZUV2ZW50KTsKLQl9Ci0KLQkvKioKLQkgKiBTb21lIGNvbXBvbmVudCBzb3VyY2VzIHdlcmUgbW92ZWQ7IHVwZGF0ZSBvdXIgY2FjaGUuCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNNb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5tb3ZlQ29tcG9uZW50U291cmNlcyhldmVudC5nZXRUYXJnZXRJbmRleCgpLCBldmVudC5nZXRTb3VyY2VJbmRleCgpLCBldmVudC5nZXRNb3ZlTGVuZ3RoKCksIHRydWUpOyAgLy8gdHJ1ZSA9IGZpcmUgZXZlbnQKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBtb3ZlQ29tcG9uZW50U291cmNlcyhpbnQgdGFyZ2V0U291cmNlc0luZGV4LCBpbnQgc291cmNlU291cmNlc0luZGV4LCBpbnQgbW92ZWRTb3VyY2VzTGVuZ3RoLCBib29sZWFuIGZpcmVFdmVudCkgewotCQlpbnQgc291cmNlSXRlbXNJbmRleCA9IHRoaXMuaW5mb0xpc3QuZ2V0KHNvdXJjZVNvdXJjZXNJbmRleCkuYmVnaW47Ci0KLQkJaW50IG5leHRTb3VyY2VTb3VyY2VJbmRleCA9IHNvdXJjZVNvdXJjZXNJbmRleCArIG1vdmVkU291cmNlc0xlbmd0aDsKLQkJaW50IG5leHRTb3VyY2VJdGVtSW5kZXggPSAobmV4dFNvdXJjZVNvdXJjZUluZGV4ID09IHRoaXMuaW5mb0xpc3Quc2l6ZSgpKSA/IHRoaXMuc2l6ZSA6IHRoaXMuaW5mb0xpc3QuZ2V0KG5leHRTb3VyY2VTb3VyY2VJbmRleCkuYmVnaW47Ci0JCWludCBtb3ZlSXRlbXNMZW5ndGggPSBuZXh0U291cmNlSXRlbUluZGV4IC0gc291cmNlSXRlbXNJbmRleDsKLQotCQlpbnQgdGFyZ2V0SXRlbXNJbmRleCA9IC0xOwotCQlpZiAoc291cmNlU291cmNlc0luZGV4ID4gdGFyZ2V0U291cmNlc0luZGV4KSB7Ci0JCQkvLyBtb3ZlIGZyb20gaGlnaCB0byBsb3cgaW5kZXgKLQkJCXRhcmdldEl0ZW1zSW5kZXggPSB0aGlzLmluZm9MaXN0LmdldCh0YXJnZXRTb3VyY2VzSW5kZXgpLmJlZ2luOwotCQl9IGVsc2UgewotCQkJLy8gbW92ZSBmcm9tIGxvdyB0byBoaWdoIGluZGV4IChoaWdoZXIgaXRlbXMgbW92ZSBkb3duIGR1cmluZyBtb3ZlKQotCQkJaW50IG5leHRUYXJnZXRTb3VyY2VJbmRleCA9IHRhcmdldFNvdXJjZXNJbmRleCArIG1vdmVkU291cmNlc0xlbmd0aDsKLQkJCXRhcmdldEl0ZW1zSW5kZXggPSAobmV4dFRhcmdldFNvdXJjZUluZGV4ID09IHRoaXMuaW5mb0xpc3Quc2l6ZSgpKSA/IHRoaXMuc2l6ZSA6IHRoaXMuaW5mb0xpc3QuZ2V0KG5leHRUYXJnZXRTb3VyY2VJbmRleCkuYmVnaW47Ci0JCQl0YXJnZXRJdGVtc0luZGV4ID0gdGFyZ2V0SXRlbXNJbmRleCAtIG1vdmVJdGVtc0xlbmd0aDsKLQkJfQotCi0JCUNvbGxlY3Rpb25Ub29scy5tb3ZlKHRoaXMuaW5mb0xpc3QsIHRhcmdldFNvdXJjZXNJbmRleCwgc291cmNlU291cmNlc0luZGV4LCBtb3ZlZFNvdXJjZXNMZW5ndGgpOwotCi0JCS8vIHVwZGF0ZSB0aGUgJ2JlZ2luJyBpbmRleGVzIG9mIGFsbCB0aGUgYWZmZWN0ZWQgJ2luZm9zJwotCQlpbnQgbWluID0gTWF0aC5taW4odGFyZ2V0U291cmNlc0luZGV4LCBzb3VyY2VTb3VyY2VzSW5kZXgpOwotCQlpbnQgbWF4ID0gTWF0aC5tYXgodGFyZ2V0U291cmNlc0luZGV4LCBzb3VyY2VTb3VyY2VzSW5kZXgpICsgbW92ZWRTb3VyY2VzTGVuZ3RoOwotCQlpbnQgYmVnaW4gPSBNYXRoLm1pbih0YXJnZXRJdGVtc0luZGV4LCBzb3VyY2VJdGVtc0luZGV4KTsKLQkJZm9yIChpbnQgaSA9IG1pbjsgaSA8IG1heDsgaSsrKSB7Ci0JCQlJbmZvIGluZm8gPSB0aGlzLmluZm9MaXN0LmdldChpKTsKLQkJCWluZm8uYmVnaW4gPSBiZWdpbjsKLQkJCWJlZ2luICs9IGluZm8uY29tcG9uZW50TFZNLnNpemUoKTsKLQkJfQotCi0JCWlmIChmaXJlRXZlbnQpIHsKLQkJCXRoaXMuZmlyZUl0ZW1zTW92ZWQoTElTVF9WQUxVRVMsIHRhcmdldEl0ZW1zSW5kZXgsIHNvdXJjZUl0ZW1zSW5kZXgsIG1vdmVJdGVtc0xlbmd0aCk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBUaGUgY29tcG9uZW50IHNvdXJjZXMgd2VyZSBjbGVhcmVkOyBjbGVhciBvdXIgY2FjaGUuCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgbGlzdENsZWFyZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMucmVtb3ZlQ29tcG9uZW50U291cmNlcygwLCB0aGlzLmluZm9MaXN0LnNpemUoKSk7Ci0JCXRoaXMuZmlyZUxpc3RDbGVhcmVkKExJU1RfVkFMVUVTKTsKLQl9Ci0KLQkvKioKLQkgKiBUaGUgY29tcG9uZW50IHNvdXJjZXMgY2hhbmdlZDsgcmVidWlsZCBvdXIgY2FjaGUuCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgbGlzdENoYW5nZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMucmVtb3ZlQ29tcG9uZW50U291cmNlcygwLCB0aGlzLmluZm9MaXN0LnNpemUoKSk7Ci0JCXRoaXMuYWRkQ29tcG9uZW50U291cmNlcygwLCB0aGlzLmxpc3RIb2xkZXIubGlzdEl0ZXJhdG9yKCksIHRoaXMubGlzdEhvbGRlci5zaXplKCkpOwotCQl0aGlzLmZpcmVMaXN0Q2hhbmdlZChMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgdG9TdHJpbmcoU3RyaW5nQnVpbGRlciBzYikgewotCQlzYi5hcHBlbmQoQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5saXN0SXRlcmF0b3IoKSwgdGhpcy5zaXplKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGludGVybmFsIG1ldGhvZHMgKioqKioqKioqKgotCi0JLyoqCi0JICogVHJhbnNmb3JtIHRoZSBzcGVjaWZpZWQgb2JqZWN0IGludG8gYSBsaXN0IHZhbHVlIG1vZGVsLgotCSAqIDxwPgotCSAqIFRoaXMgbWV0aG9kIGNhbiBiZSBvdmVycmlkZGVuIGJ5IGEgc3ViY2xhc3MgYXMgYW4KLQkgKiBhbHRlcm5hdGl2ZSB0byBidWlsZGluZyBhIDxjb2RlPlRyYW5zZm9ybWVyPC9jb2RlPi4KLQkgKi8KLQlwcm90ZWN0ZWQgTGlzdFZhbHVlTW9kZWw8RTI+IHRyYW5zZm9ybShFMSB2YWx1ZSkgewotCQlyZXR1cm4gdGhpcy50cmFuc2Zvcm1lci50cmFuc2Zvcm0odmFsdWUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaW5kZXggb2YgdGhlIHNwZWNpZmllZCBjb21wb25lbnQgTFZNLgotCSAqLwotCXByb3RlY3RlZCBpbnQgaW5kZXhPZihMaXN0VmFsdWVNb2RlbDxFMj4gY29tcG9uZW50TFZNKSB7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgdGhpcy5pbmZvTGlzdC5zaXplKCk7IGkrKykgewotCQkJaWYgKHRoaXMuaW5mb0xpc3QuZ2V0KGkpLmNvbXBvbmVudExWTSA9PSBjb21wb25lbnRMVk0pIHsKLQkJCQlyZXR1cm4gaTsKLQkJCX0KLQkJfQotCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCJpbnZhbGlkIGNvbXBvbmVudCBMVk06ICIgKyBjb21wb25lbnRMVk0pOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaW5kZXggb2YgdGhlIHNwZWNpZmllZCBldmVudCdzIGNvbXBvbmVudCBMVk0uCi0JICovCi0JcHJvdGVjdGVkIGludCBpbmRleEZvcihMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIHRoaXMuaW5kZXhPZih0aGlzLmNvbXBvbmVudExWTShldmVudCkpOwotCX0KLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgYWRkZWQgdG8gb25lIG9mIHRoZSBjb21wb25lbnQgbGlzdHM7Ci0JICogc3luY2hyb25pemUgb3VyIGNhY2hlLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGNvbXBvbmVudEl0ZW1zQWRkZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIHVwZGF0ZSB0aGUgYWZmZWN0ZWQgJ2JlZ2luJyBpbmRpY2VzCi0JCWludCBjb21wb25lbnRMVk1JbmRleCA9IHRoaXMuaW5kZXhGb3IoZXZlbnQpOwotCQlpbnQgbmV3SXRlbXNTaXplID0gZXZlbnQuaXRlbXNTaXplKCk7Ci0JCWZvciAoaW50IGkgPSBjb21wb25lbnRMVk1JbmRleCArIDE7IGkgPCB0aGlzLmluZm9MaXN0LnNpemUoKTsgaSsrKSB7Ci0JCQl0aGlzLmluZm9MaXN0LmdldChpKS5iZWdpbiArPSBuZXdJdGVtc1NpemU7Ci0JCX0KLQkJdGhpcy5zaXplICs9IG5ld0l0ZW1zU2l6ZTsKLQotCQkvLyBzeW5jaHJvbml6ZSB0aGUgY2FjaGVkIGxpc3QKLQkJSW5mbyBpbmZvID0gdGhpcy5pbmZvTGlzdC5nZXQoY29tcG9uZW50TFZNSW5kZXgpOwotCQlDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGluZm8uaXRlbXMsIGV2ZW50LmdldEluZGV4KCksIHRoaXMuY29tcG9uZW50SXRlbXMoZXZlbnQpLCBldmVudC5pdGVtc1NpemUoKSk7Ci0KLQkJLy8gdHJhbnNsYXRlIHRoZSBldmVudAotCQl0aGlzLmZpcmVJdGVtc0FkZGVkKGV2ZW50LmNsb25lV2l0aFNvdXJjZSh0aGlzLCBMSVNUX1ZBTFVFUywgaW5mby5iZWdpbikpOwotCX0KLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgcmVtb3ZlZCBmcm9tIG9uZSBvZiB0aGUgY29tcG9uZW50IGxpc3RzOwotCSAqIHN5bmNocm9uaXplIG91ciBjYWNoZS4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBjb21wb25lbnRJdGVtc1JlbW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIHVwZGF0ZSB0aGUgYWZmZWN0ZWQgJ2JlZ2luJyBpbmRpY2VzCi0JCWludCBjb21wb25lbnRMVk1JbmRleCA9IHRoaXMuaW5kZXhGb3IoZXZlbnQpOwotCQlpbnQgcmVtb3ZlZEl0ZW1zU2l6ZSA9IGV2ZW50Lml0ZW1zU2l6ZSgpOwotCQlmb3IgKGludCBpID0gY29tcG9uZW50TFZNSW5kZXggKyAxOyBpIDwgdGhpcy5pbmZvTGlzdC5zaXplKCk7IGkrKykgewotCQkJdGhpcy5pbmZvTGlzdC5nZXQoaSkuYmVnaW4gLT0gcmVtb3ZlZEl0ZW1zU2l6ZTsKLQkJfQotCQl0aGlzLnNpemUgLT0gcmVtb3ZlZEl0ZW1zU2l6ZTsKLQotCQkvLyBzeW5jaHJvbml6ZSB0aGUgY2FjaGVkIGxpc3QKLQkJSW5mbyBpbmZvID0gdGhpcy5pbmZvTGlzdC5nZXQoY29tcG9uZW50TFZNSW5kZXgpOwotCQlpbnQgaXRlbUluZGV4ID0gZXZlbnQuZ2V0SW5kZXgoKTsKLQkJaW5mby5pdGVtcy5zdWJMaXN0KGl0ZW1JbmRleCwgaXRlbUluZGV4ICsgZXZlbnQuaXRlbXNTaXplKCkpLmNsZWFyKCk7Ci0KLQkJLy8gdHJhbnNsYXRlIHRoZSBldmVudAotCQl0aGlzLmZpcmVJdGVtc1JlbW92ZWQoZXZlbnQuY2xvbmVXaXRoU291cmNlKHRoaXMsIExJU1RfVkFMVUVTLCBpbmZvLmJlZ2luKSk7Ci0JfQotCi0JLyoqCi0JICogSXRlbXMgd2VyZSByZXBsYWNlZCBpbiBvbmUgb2YgdGhlIGNvbXBvbmVudCBsaXN0czsKLQkgKiBzeW5jaHJvbml6ZSBvdXIgY2FjaGUuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgY29tcG9uZW50SXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gbm8gY2hhbmdlcyB0byB0aGUgJ2JlZ2luJyBpbmRpY2VzIG9yIHNpemUKLQotCQkvLyBzeW5jaHJvbml6ZSB0aGUgY2FjaGVkIGxpc3QKLQkJaW50IGNvbXBvbmVudExWTUluZGV4ID0gdGhpcy5pbmRleEZvcihldmVudCk7Ci0JCUluZm8gaW5mbyA9IHRoaXMuaW5mb0xpc3QuZ2V0KGNvbXBvbmVudExWTUluZGV4KTsKLQkJaW50IGkgPSBldmVudC5nZXRJbmRleCgpOwotCQlmb3IgKEl0ZXJhdG9yPEUyPiBzdHJlYW0gPSB0aGlzLmNvbXBvbmVudEl0ZW1zKGV2ZW50KTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQlpbmZvLml0ZW1zLnNldChpKyssIHN0cmVhbS5uZXh0KCkpOwotCQl9Ci0KLQkJLy8gdHJhbnNsYXRlIHRoZSBldmVudAotCQl0aGlzLmZpcmVJdGVtc1JlcGxhY2VkKGV2ZW50LmNsb25lV2l0aFNvdXJjZSh0aGlzLCBMSVNUX1ZBTFVFUywgaW5mby5iZWdpbikpOwotCX0KLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgbW92ZWQgaW4gb25lIG9mIHRoZSBjb21wb25lbnQgbGlzdHM7Ci0JICogc3luY2hyb25pemUgb3VyIGNhY2hlLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGNvbXBvbmVudEl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIG5vIGNoYW5nZXMgdG8gdGhlICdiZWdpbicgaW5kaWNlcyBvciBzaXplCi0KLQkJLy8gc3luY2hyb25pemUgdGhlIGNhY2hlZCBsaXN0Ci0JCWludCBjb21wb25lbnRMVk1JbmRleCA9IHRoaXMuaW5kZXhGb3IoZXZlbnQpOwotCQlJbmZvIGluZm8gPSB0aGlzLmluZm9MaXN0LmdldChjb21wb25lbnRMVk1JbmRleCk7Ci0JCUNvbGxlY3Rpb25Ub29scy5tb3ZlKGluZm8uaXRlbXMsIGV2ZW50LmdldFRhcmdldEluZGV4KCksIGV2ZW50LmdldFNvdXJjZUluZGV4KCksIGV2ZW50LmdldE1vdmVMZW5ndGgoKSk7Ci0KLQkJLy8gdHJhbnNsYXRlIHRoZSBldmVudAotCQl0aGlzLmZpcmVJdGVtc01vdmVkKGV2ZW50LmNsb25lV2l0aFNvdXJjZSh0aGlzLCBMSVNUX1ZBTFVFUywgaW5mby5iZWdpbikpOwotCX0KLQotCS8qKgotCSAqIE9uZSBvZiB0aGUgY29tcG9uZW50IGxpc3RzIHdhcyBjbGVhcmVkOwotCSAqIHN5bmNocm9uaXplIG91ciBjYWNoZS4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBjb21wb25lbnRMaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaW50IGNvbXBvbmVudExWTUluZGV4ID0gdGhpcy5pbmRleEZvcihldmVudCk7Ci0JCXRoaXMuY2xlYXJDb21wb25lbnRMaXN0KGNvbXBvbmVudExWTUluZGV4LCB0aGlzLmluZm9MaXN0LmdldChjb21wb25lbnRMVk1JbmRleCkpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGNsZWFyQ29tcG9uZW50TGlzdChpbnQgY29tcG9uZW50TFZNSW5kZXgsIEluZm8gaW5mbykgewotCQkvLyB1cGRhdGUgdGhlIGFmZmVjdGVkICdiZWdpbicgaW5kaWNlcwotCQlpbnQgcmVtb3ZlZEl0ZW1zU2l6ZSA9IGluZm8uaXRlbXMuc2l6ZSgpOwotCQlmb3IgKGludCBpID0gY29tcG9uZW50TFZNSW5kZXggKyAxOyBpIDwgdGhpcy5pbmZvTGlzdC5zaXplKCk7IGkrKykgewotCQkJdGhpcy5pbmZvTGlzdC5nZXQoaSkuYmVnaW4gLT0gcmVtb3ZlZEl0ZW1zU2l6ZTsKLQkJfQotCQl0aGlzLnNpemUgLT0gcmVtb3ZlZEl0ZW1zU2l6ZTsKLQotCQkvLyBzeW5jaHJvbml6ZSB0aGUgY2FjaGVkIGxpc3QKLQkJQXJyYXlMaXN0PEUyPiBpdGVtcyA9IG5ldyBBcnJheUxpc3Q8RTI+KGluZm8uaXRlbXMpOwotCQlpbmZvLml0ZW1zLmNsZWFyKCk7Ci0KLQkJLy8gdHJhbnNsYXRlIHRoZSBldmVudAotCQl0aGlzLmZpcmVJdGVtc1JlbW92ZWQoTElTVF9WQUxVRVMsIGluZm8uYmVnaW4sIGl0ZW1zKTsKLQl9Ci0KLQkvKioKLQkgKiBPbmUgb2YgdGhlIGNvbXBvbmVudCBsaXN0cyBjaGFuZ2VkOwotCSAqIHN5bmNocm9uaXplIG91ciBjYWNoZSBieSBjbGVhcmluZyBvdXQgdGhlIGFwcHJvcHJpYXRlCi0JICogbGlzdCBhbmQgcmVidWlsZGluZyBpdC4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBjb21wb25lbnRMaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaW50IGNvbXBvbmVudExWTUluZGV4ID0gdGhpcy5pbmRleEZvcihldmVudCk7Ci0JCUluZm8gaW5mbyA9IHRoaXMuaW5mb0xpc3QuZ2V0KGNvbXBvbmVudExWTUluZGV4KTsKLQkJdGhpcy5jbGVhckNvbXBvbmVudExpc3QoY29tcG9uZW50TFZNSW5kZXgsIGluZm8pOwotCi0JCS8vIHVwZGF0ZSB0aGUgYWZmZWN0ZWQgJ2JlZ2luJyBpbmRpY2VzCi0JCWludCBuZXdJdGVtc1NpemUgPSBpbmZvLmNvbXBvbmVudExWTS5zaXplKCk7Ci0JCWZvciAoaW50IGkgPSBjb21wb25lbnRMVk1JbmRleCArIDE7IGkgPCB0aGlzLmluZm9MaXN0LnNpemUoKTsgaSsrKSB7Ci0JCQl0aGlzLmluZm9MaXN0LmdldChpKS5iZWdpbiArPSBuZXdJdGVtc1NpemU7Ci0JCX0KLQkJdGhpcy5zaXplICs9IG5ld0l0ZW1zU2l6ZTsKLQotCQkvLyBzeW5jaHJvbml6ZSB0aGUgY2FjaGVkIGxpc3QKLQkJQ29sbGVjdGlvblRvb2xzLmFkZEFsbChpbmZvLml0ZW1zLCBpbmZvLmNvbXBvbmVudExWTS5saXN0SXRlcmF0b3IoKSwgbmV3SXRlbXNTaXplKTsKLQotCQkvLyB0cmFuc2xhdGUgdGhlIGV2ZW50Ci0JCXRoaXMuZmlyZUl0ZW1zQWRkZWQoTElTVF9WQUxVRVMsIGluZm8uYmVnaW4sIGluZm8uaXRlbXMpOwotCX0KLQotCS8vIG1pbmltaXplIHNjb3BlIG9mIHN1cHByZXNzZWQgd2FybmluZ3MKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcm90ZWN0ZWQgTGlzdEl0ZXJhdG9yPEUyPiBjb21wb25lbnRJdGVtcyhMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIChMaXN0SXRlcmF0b3I8RTI+KSBldmVudC5pdGVtcygpOwotCX0KLQotCS8vIG1pbmltaXplIHNjb3BlIG9mIHN1cHByZXNzZWQgd2FybmluZ3MKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcm90ZWN0ZWQgTGlzdFZhbHVlTW9kZWw8RTI+IGNvbXBvbmVudExWTShMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIChMaXN0VmFsdWVNb2RlbDxFMj4pIGV2ZW50LmdldFNvdXJjZSgpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0V4dGVuZGVkTGlzdFZhbHVlTW9kZWxXcmFwcGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvRXh0ZW5kZWRMaXN0VmFsdWVNb2RlbFdyYXBwZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODQ2NTBjZi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvRXh0ZW5kZWRMaXN0VmFsdWVNb2RlbFdyYXBwZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDIwNCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbnM7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5SZWFkT25seUNvbXBvc2l0ZUxpc3RJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuUmVhZE9ubHlMaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuTGlzdENoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotCi0vKioKLSAqIFRoaXMgd3JhcHBlciBleHRlbmRzIGEgTGlzdFZhbHVlTW9kZWwgKG9yIENvbGxlY3Rpb25WYWx1ZU1vZGVsKQotICogd2l0aCBmaXhlZCBjb2xsZWN0aW9ucyBvZiBpdGVtcyBvbiBlaXRoZXIgZW5kLgotICogPHA+Ci0gKiBOQjogQmUgY2FyZWZ1bCB1c2luZyBvciB3cmFwcGluZyB0aGlzIGxpc3QgdmFsdWUgbW9kZWwsIHNpbmNlIHRoZQotICogImV4dGVuZGVkIiBpdGVtcyBtYXkgYmUgdW5leHBlY3RlZCBieSB0aGUgY2xpZW50IGNvZGUgb3Igd3JhcHBlci4KLSAqLwotcHVibGljIGNsYXNzIEV4dGVuZGVkTGlzdFZhbHVlTW9kZWxXcmFwcGVyPEU+Ci0JZXh0ZW5kcyBMaXN0VmFsdWVNb2RlbFdyYXBwZXI8RT4KLQlpbXBsZW1lbnRzIExpc3RWYWx1ZU1vZGVsPEU+Ci17Ci0JLyoqIHRoZSBpdGVtcyAicHJlcGVuZGVkIiB0byB0aGUgd3JhcHBlZCBsaXN0ICovCi0JcHJvdGVjdGVkIExpc3Q8RT4gcHJlZml4OwotCi0JLyoqIHRoZSBpdGVtcyAiYXBwZW5kZWQiIHRvIHRoZSB3cmFwcGVkIGxpc3QgKi8KLQlwcm90ZWN0ZWQgTGlzdDxFPiBzdWZmaXg7Ci0KLQotCS8vICoqKioqKioqKiogbG90cyBvJyBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogRXh0ZW5kIHRoZSBzcGVjaWZpZWQgbGlzdCB3aXRoIGEgcHJlZml4IGFuZCBzdWZmaXguCi0JICovCi0JcHVibGljIEV4dGVuZGVkTGlzdFZhbHVlTW9kZWxXcmFwcGVyKExpc3Q8PyBleHRlbmRzIEU+IHByZWZpeCwgTGlzdFZhbHVlTW9kZWw8PyBleHRlbmRzIEU+IGxpc3RIb2xkZXIsIExpc3Q8PyBleHRlbmRzIEU+IHN1ZmZpeCkgewotCQlzdXBlcihsaXN0SG9sZGVyKTsKLQkJdGhpcy5wcmVmaXggPSBuZXcgQXJyYXlMaXN0PEU+KHByZWZpeCk7Ci0JCXRoaXMuc3VmZml4ID0gbmV3IEFycmF5TGlzdDxFPihzdWZmaXgpOwotCX0KLQotCS8qKgotCSAqIEV4dGVuZCB0aGUgc3BlY2lmaWVkIGxpc3Qgd2l0aCBhIHByZWZpeCBhbmQgc3VmZml4LgotCSAqLwotCXB1YmxpYyBFeHRlbmRlZExpc3RWYWx1ZU1vZGVsV3JhcHBlcihFIHByZWZpeCwgTGlzdFZhbHVlTW9kZWw8PyBleHRlbmRzIEU+IGxpc3RIb2xkZXIsIEUgc3VmZml4KSB7Ci0JCXN1cGVyKGxpc3RIb2xkZXIpOwotCQl0aGlzLnByZWZpeCA9IENvbGxlY3Rpb25zLnNpbmdsZXRvbkxpc3QocHJlZml4KTsKLQkJdGhpcy5zdWZmaXggPSBDb2xsZWN0aW9ucy5zaW5nbGV0b25MaXN0KHN1ZmZpeCk7Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRoZSBzcGVjaWZpZWQgbGlzdCB3aXRoIGEgcHJlZml4LgotCSAqLwotCXB1YmxpYyBFeHRlbmRlZExpc3RWYWx1ZU1vZGVsV3JhcHBlcihMaXN0PD8gZXh0ZW5kcyBFPiBwcmVmaXgsIExpc3RWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBFPiBsaXN0SG9sZGVyKSB7Ci0JCXN1cGVyKGxpc3RIb2xkZXIpOwotCQl0aGlzLnByZWZpeCA9IG5ldyBBcnJheUxpc3Q8RT4ocHJlZml4KTsKLQkJdGhpcy5zdWZmaXggPSBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdGhlIHNwZWNpZmllZCBsaXN0IHdpdGggYSBwcmVmaXguCi0JICovCi0JcHVibGljIEV4dGVuZGVkTGlzdFZhbHVlTW9kZWxXcmFwcGVyKEUgcHJlZml4LCBMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gbGlzdEhvbGRlcikgewotCQlzdXBlcihsaXN0SG9sZGVyKTsKLQkJdGhpcy5wcmVmaXggPSBDb2xsZWN0aW9ucy5zaW5nbGV0b25MaXN0KHByZWZpeCk7Ci0JCXRoaXMuc3VmZml4ID0gQ29sbGVjdGlvbnMuZW1wdHlMaXN0KCk7Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRoZSBzcGVjaWZpZWQgbGlzdCB3aXRoIGEgc3VmZml4LgotCSAqLwotCXB1YmxpYyBFeHRlbmRlZExpc3RWYWx1ZU1vZGVsV3JhcHBlcihMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gbGlzdEhvbGRlciwgTGlzdDw/IGV4dGVuZHMgRT4gc3VmZml4KSB7Ci0JCXN1cGVyKGxpc3RIb2xkZXIpOwotCQl0aGlzLnByZWZpeCA9IENvbGxlY3Rpb25zLmVtcHR5TGlzdCgpOwotCQl0aGlzLnN1ZmZpeCA9IG5ldyBBcnJheUxpc3Q8RT4oc3VmZml4KTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdGhlIHNwZWNpZmllZCBsaXN0IHdpdGggYSBzdWZmaXguCi0JICovCi0JcHVibGljIEV4dGVuZGVkTGlzdFZhbHVlTW9kZWxXcmFwcGVyKExpc3RWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBFPiBsaXN0SG9sZGVyLCBFIHN1ZmZpeCkgewotCQlzdXBlcihsaXN0SG9sZGVyKTsKLQkJdGhpcy5wcmVmaXggPSBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsKLQkJdGhpcy5zdWZmaXggPSBDb2xsZWN0aW9ucy5zaW5nbGV0b25MaXN0KHN1ZmZpeCk7Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRoZSBzcGVjaWZpZWQgbGlzdCB3aXRoIGEgcHJlZml4IGNvbnRhaW5pbmcgYSBzaW5nbGUgbnVsbCBpdGVtLgotCSAqLwotCXB1YmxpYyBFeHRlbmRlZExpc3RWYWx1ZU1vZGVsV3JhcHBlcihMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gbGlzdEhvbGRlcikgewotCQlzdXBlcihsaXN0SG9sZGVyKTsKLQkJdGhpcy5wcmVmaXggPSBDb2xsZWN0aW9ucy5zaW5nbGV0b25MaXN0KG51bGwpOwotCQl0aGlzLnN1ZmZpeCA9IENvbGxlY3Rpb25zLmVtcHR5TGlzdCgpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBMaXN0VmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgSXRlcmF0b3I8RT4gaXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3RJdGVyYXRvcigpOwotCX0KLQotCXB1YmxpYyBMaXN0SXRlcmF0b3I8RT4gbGlzdEl0ZXJhdG9yKCkgewotCQlyZXR1cm4gbmV3IFJlYWRPbmx5TGlzdEl0ZXJhdG9yPEU+KHRoaXMubGlzdEl0ZXJhdG9yXygpKTsKLQl9Ci0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcm90ZWN0ZWQgTGlzdEl0ZXJhdG9yPEU+IGxpc3RJdGVyYXRvcl8oKSB7Ci0JCXJldHVybiBuZXcgUmVhZE9ubHlDb21wb3NpdGVMaXN0SXRlcmF0b3I8RT4oCi0JCQl0aGlzLnByZWZpeC5saXN0SXRlcmF0b3IoKSwKLQkJCXRoaXMubGlzdEhvbGRlci5saXN0SXRlcmF0b3IoKSwKLQkJCXRoaXMuc3VmZml4Lmxpc3RJdGVyYXRvcigpCi0JCSk7Ci0JfQotCi0JcHVibGljIEUgZ2V0KGludCBpbmRleCkgewotCQlpbnQgcHJlZml4U2l6ZSA9IHRoaXMucHJlZml4LnNpemUoKTsKLQkJaWYgKGluZGV4IDwgcHJlZml4U2l6ZSkgewotCQkJcmV0dXJuIHRoaXMucHJlZml4LmdldChpbmRleCk7Ci0JCX0gZWxzZSBpZiAoaW5kZXggPj0gcHJlZml4U2l6ZSArIHRoaXMubGlzdEhvbGRlci5zaXplKCkpIHsKLQkJCXJldHVybiB0aGlzLnN1ZmZpeC5nZXQoaW5kZXggLSAocHJlZml4U2l6ZSArIHRoaXMubGlzdEhvbGRlci5zaXplKCkpKTsKLQkJfSBlbHNlIHsKLQkJCXJldHVybiB0aGlzLmxpc3RIb2xkZXIuZ2V0KGluZGV4IC0gcHJlZml4U2l6ZSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgaW50IHNpemUoKSB7Ci0JCXJldHVybiB0aGlzLnByZWZpeC5zaXplKCkgKyB0aGlzLmxpc3RIb2xkZXIuc2l6ZSgpICsgdGhpcy5zdWZmaXguc2l6ZSgpOwotCX0KLQotCXB1YmxpYyBPYmplY3RbXSB0b0FycmF5KCkgewotCQlBcnJheUxpc3Q8RT4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8RT4odGhpcy5zaXplKCkpOwotCQlsaXN0LmFkZEFsbCh0aGlzLnByZWZpeCk7Ci0JCUNvbGxlY3Rpb25Ub29scy5hZGRBbGwobGlzdCwgdGhpcy5saXN0SG9sZGVyLml0ZXJhdG9yKCkpOwotCQlsaXN0LmFkZEFsbCh0aGlzLnN1ZmZpeCk7Ci0JCXJldHVybiBsaXN0LnRvQXJyYXkoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogTGlzdFZhbHVlTW9kZWxXcmFwcGVyIGltcGxlbWVudGF0aW9uL292ZXJyaWRlcyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmZpcmVJdGVtc0FkZGVkKGV2ZW50LmNsb25lV2l0aFNvdXJjZSh0aGlzLCBMSVNUX1ZBTFVFUywgdGhpcy5wcmVmaXguc2l6ZSgpKSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmZpcmVJdGVtc1JlbW92ZWQoZXZlbnQuY2xvbmVXaXRoU291cmNlKHRoaXMsIExJU1RfVkFMVUVTLCB0aGlzLnByZWZpeC5zaXplKCkpKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpdGVtc1JlcGxhY2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmZpcmVJdGVtc1JlcGxhY2VkKGV2ZW50LmNsb25lV2l0aFNvdXJjZSh0aGlzLCBMSVNUX1ZBTFVFUywgdGhpcy5wcmVmaXguc2l6ZSgpKSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNNb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5maXJlSXRlbXNNb3ZlZChldmVudC5jbG9uZVdpdGhTb3VyY2UodGhpcywgTElTVF9WQUxVRVMsIHRoaXMucHJlZml4LnNpemUoKSkpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGxpc3RDbGVhcmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmZpcmVMaXN0Q2hhbmdlZChMSVNUX1ZBTFVFUyk7ICAvLyBub3QgImNsZWFyZWQiCi0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgbGlzdENoYW5nZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuZmlyZUxpc3RDaGFuZ2VkKExJU1RfVkFMVUVTKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0b1N0cmluZyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXNiLmFwcGVuZCh0aGlzLnByZWZpeCk7Ci0JCXNiLmFwcGVuZCgiICIpOwotCQlzdXBlci50b1N0cmluZyhzYik7Ci0JCXNiLmFwcGVuZCgiICIpOwotCQlzYi5hcHBlbmQodGhpcy5zdWZmaXgpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBtaXNjZWxsYW5lb3VzICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIHNldFByZWZpeChMaXN0PEU+IHByZWZpeCkgewotCQl0aGlzLnByZWZpeCA9IHByZWZpeDsKLQkJdGhpcy5maXJlTGlzdENoYW5nZWQoTElTVF9WQUxVRVMpOwotCX0KLQotCXB1YmxpYyB2b2lkIHNldFN1ZmZpeChMaXN0PEU+IHN1ZmZpeCkgewotCQl0aGlzLnN1ZmZpeCA9IHN1ZmZpeDsKLQkJdGhpcy5maXJlTGlzdENoYW5nZWQoTElTVF9WQUxVRVMpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0ZpbHRlcmluZ0NvbGxlY3Rpb25WYWx1ZU1vZGVsLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvRmlsdGVyaW5nQ29sbGVjdGlvblZhbHVlTW9kZWwuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOGRjODY1YS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvRmlsdGVyaW5nQ29sbGVjdGlvblZhbHVlTW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE3MSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuRmlsdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuRmlsdGVyaW5nSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlJlYWRPbmx5SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuQ29sbGVjdGlvbkNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotCi0vKioKLSAqIEEgPGNvZGU+RmlsdGVyaW5nQ29sbGVjdGlvblZhbHVlTW9kZWw8L2NvZGU+IHdyYXBzIGFub3RoZXIKLSAqIDxjb2RlPkNvbGxlY3Rpb25WYWx1ZU1vZGVsPC9jb2RlPiBhbmQgdXNlcyBhIDxjb2RlPkZpbHRlcjwvY29kZT4KLSAqIHRvIGRldGVybWluZSB3aGljaCBpdGVtcyBpbiB0aGUgY29sbGVjdGlvbiBhcmUgcmV0dXJuZWQgYnkgY2FsbHMKLSAqIHRvIDxjb2RlPiNpdGVyYXRvcigpPC9jb2RlPi4KLSAqIDxwPgotICogVGhlIGZpbHRlciBjYW4gYmUgY2hhbmdlZCBhdCBhbnkgdGltZTsgYWxsb3dpbmcgdGhlIHNhbWUKLSAqIGFkYXB0ZXIgdG8gYmUgdXNlZCB3aXRoIGRpZmZlcmVudCBmaWx0ZXIgY3JpdGVyaWEgKGUuZy4gd2hlbiB0aGUgdXNlcgotICogd2FudHMgdG8gdmlldyBhIGxpc3Qgb2YgLmphdmEgZmlsZXMpLgotICogPHA+Ci0gKiBOQjogSWYgdGhlIG9iamVjdHMgaW4gdGhlICJmaWx0ZXJlZCIgY29sbGVjdGlvbiBjYW4gY2hhbmdlIGluIHN1Y2ggYSB3YXkKLSAqIHRoYXQgdGhleSBzaG91bGQgYmUgcmVtb3ZlZCBmcm9tIHRoZSAiZmlsdGVyZWQiIGNvbGxlY3Rpb24sIHlvdSB3aWxsCi0gKiBuZWVkIHRvIHdyYXAgdGhlIG9yaWdpbmFsIGNvbGxlY3Rpb24gaW4gYW4gSXRlbUFzcGVjdExpc3RWYWx1ZU1vZGVsQWRhcHRlci4KLSAqIEZvciBleGFtcGxlLCBpZiB0aGUgZmlsdGVyIG9ubHkgImFjY2VwdHMiIGl0ZW1zIHdob3NlIG5hbWVzIGJlZ2luCi0gKiB3aXRoICJYIiBhbmQgdGhlIG5hbWVzIG9mIHRoZSBpdGVtcyBjYW4gY2hhbmdlLCB5b3Ugd2lsbCBuZWVkIHRvCi0gKiB3cmFwIHRoZSBvcmlnaW5hbCBsaXN0IG9mIHVuZmlsdGVyZWQgaXRlbXMgd2l0aCBhbgotICogSXRlbVByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyIHRoYXQgbGlzdGVucyBmb3IgY2hhbmdlcyB0byBlYWNoCi0gKiBpdGVtJ3MgbmFtZSBhbmQgZmlyZXMgdGhlIGFwcHJvcHJpYXRlIGV2ZW50IHdoZW5ldmVyIGFuIGl0ZW0ncyBuYW1lCi0gKiBjaGFuZ2VzLiBUaGUgZXZlbnQgd2lsbCBjYXVzZSB0aGlzIHdyYXBwZXIgdG8gcmUtZmlsdGVyIHRoZSBjaGFuZ2VkCi0gKiBpdGVtIGFuZCBhZGQgb3IgcmVtb3ZlIGl0IGZyb20gdGhlICJmaWx0ZXJlZCIgY29sbGVjdGlvbiBhcyBhcHByb3ByaWF0ZS4KLSAqLwotcHVibGljIGNsYXNzIEZpbHRlcmluZ0NvbGxlY3Rpb25WYWx1ZU1vZGVsPEU+Ci0JZXh0ZW5kcyBDb2xsZWN0aW9uVmFsdWVNb2RlbFdyYXBwZXI8RT4KLQlpbXBsZW1lbnRzIENvbGxlY3Rpb25WYWx1ZU1vZGVsPEU+Ci17Ci0JLyoqIFRoaXMgZmlsdGVycyB0aGUgaXRlbXMgaW4gdGhlIG5lc3RlZCBjb2xsZWN0aW9uLiAqLwotCXByaXZhdGUgRmlsdGVyPEU+IGZpbHRlcjsKLQotCS8qKiBDYWNoZSB0aGUgaXRlbXMgdGhhdCB3ZXJlIGFjY2VwdGVkIGJ5IHRoZSBmaWx0ZXIgKi8KLQlwcml2YXRlIGZpbmFsIENvbGxlY3Rpb248RT4gZmlsdGVyZWRJdGVtczsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgY29sbGVjdGlvbiB2YWx1ZSBtb2RlbCB3aXRoIHRoZSBzcGVjaWZpZWQgd3JhcHBlZAotCSAqIGNvbGxlY3Rpb24gdmFsdWUgbW9kZWwgYW5kIGEgZmlsdGVyIHRoYXQgc2ltcGx5IGFjY2VwdHMgZXZlcnkgb2JqZWN0LgotCSAqLwotCXB1YmxpYyBGaWx0ZXJpbmdDb2xsZWN0aW9uVmFsdWVNb2RlbChDb2xsZWN0aW9uVmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gY29sbGVjdGlvbkhvbGRlcikgewotCQl0aGlzKGNvbGxlY3Rpb25Ib2xkZXIsIEZpbHRlci5OdWxsLjxFPmluc3RhbmNlKCkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGNvbGxlY3Rpb24gdmFsdWUgbW9kZWwgd2l0aCB0aGUgc3BlY2lmaWVkIHdyYXBwZWQKLQkgKiBjb2xsZWN0aW9uIHZhbHVlIG1vZGVsIGFuZCBmaWx0ZXIuCi0JICovCi0JcHVibGljIEZpbHRlcmluZ0NvbGxlY3Rpb25WYWx1ZU1vZGVsKENvbGxlY3Rpb25WYWx1ZU1vZGVsPD8gZXh0ZW5kcyBFPiBjb2xsZWN0aW9uSG9sZGVyLCBGaWx0ZXI8RT4gZmlsdGVyKSB7Ci0JCXN1cGVyKGNvbGxlY3Rpb25Ib2xkZXIpOwotCQl0aGlzLmZpbHRlciA9IGZpbHRlcjsKLQkJdGhpcy5maWx0ZXJlZEl0ZW1zID0gbmV3IEFycmF5TGlzdDxFPigpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGNvbGxlY3Rpb24gdmFsdWUgbW9kZWwgd2l0aCB0aGUgc3BlY2lmaWVkIHdyYXBwZWQKLQkgKiBsaXN0IHZhbHVlIG1vZGVsIGFuZCBhIGZpbHRlciB0aGF0IHNpbXBseSBhY2NlcHRzIGV2ZXJ5IG9iamVjdC4KLQkgKi8KLQlwdWJsaWMgRmlsdGVyaW5nQ29sbGVjdGlvblZhbHVlTW9kZWwoTGlzdFZhbHVlTW9kZWw8RT4gbGlzdEhvbGRlcikgewotCQl0aGlzKG5ldyBMaXN0Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyPEU+KGxpc3RIb2xkZXIpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBjb2xsZWN0aW9uIHZhbHVlIG1vZGVsIHdpdGggdGhlIHNwZWNpZmllZCB3cmFwcGVkCi0JICogbGlzdCB2YWx1ZSBtb2RlbCBhbmQgZmlsdGVyLgotCSAqLwotCXB1YmxpYyBGaWx0ZXJpbmdDb2xsZWN0aW9uVmFsdWVNb2RlbChMaXN0VmFsdWVNb2RlbDxFPiBsaXN0SG9sZGVyLCBGaWx0ZXI8RT4gZmlsdGVyKSB7Ci0JCXRoaXMobmV3IExpc3RDb2xsZWN0aW9uVmFsdWVNb2RlbEFkYXB0ZXI8RT4obGlzdEhvbGRlciksIGZpbHRlcik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIENvbGxlY3Rpb25WYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBJdGVyYXRvcjxFPiBpdGVyYXRvcigpIHsKLQkJcmV0dXJuIG5ldyBSZWFkT25seUl0ZXJhdG9yPEU+KHRoaXMuZmlsdGVyZWRJdGVtcyk7Ci0JfQotCi0JcHVibGljIGludCBzaXplKCkgewotCQlyZXR1cm4gdGhpcy5maWx0ZXJlZEl0ZW1zLnNpemUoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogQ29sbGVjdGlvblZhbHVlTW9kZWxXcmFwcGVyIG92ZXJyaWRlcy9pbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VNb2RlbCgpIHsKLQkJc3VwZXIuZW5nYWdlTW9kZWwoKTsKLQkJLy8gc3luY2ggb3VyIGNhY2hlICphZnRlciogd2Ugc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSBuZXN0ZWQgY29sbGVjdGlvbiwKLQkJLy8gc2luY2UgaXRzIHZhbHVlIG1pZ2h0IGNoYW5nZSB3aGVuIGEgbGlzdGVuZXIgaXMgYWRkZWQKLQkJQ29sbGVjdGlvblRvb2xzLmFkZEFsbCh0aGlzLmZpbHRlcmVkSXRlbXMsIHRoaXMuZmlsdGVyKHRoaXMuY29sbGVjdGlvbkhvbGRlci5pdGVyYXRvcigpKSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZGlzZW5nYWdlTW9kZWwoKSB7Ci0JCXN1cGVyLmRpc2VuZ2FnZU1vZGVsKCk7Ci0JCS8vIGNsZWFyIG91dCB0aGUgY2FjaGUgd2hlbiB3ZSBhcmUgbm90IGxpc3RlbmluZyB0byB0aGUgbmVzdGVkIGNvbGxlY3Rpb24KLQkJdGhpcy5maWx0ZXJlZEl0ZW1zLmNsZWFyKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gZmlsdGVyIHRoZSB2YWx1ZXMgYmVmb3JlIHByb3BhZ2F0aW5nIHRoZSBjaGFuZ2UgZXZlbnQKLQkJdGhpcy5hZGRJdGVtc1RvQ29sbGVjdGlvbih0aGlzLmZpbHRlcih0aGlzLml0ZW1zKGV2ZW50KSksIHRoaXMuZmlsdGVyZWRJdGVtcywgVkFMVUVTKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpdGVtc1JlbW92ZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIGRvICpub3QqIGZpbHRlciB0aGUgdmFsdWVzLCBiZWNhdXNlIHRoZXkgbWF5IG5vIGxvbmdlciBiZQotCQkvLyAiYWNjZXB0ZWQiIGFuZCB0aGF0IG1pZ2h0IGJlIHdoeSB0aGV5IHdlcmUgcmVtb3ZlZCBpbiB0aGUgZmlyc3QgcGxhY2U7Ci0JCS8vIGFueXdheSwgYW55IGV4dHJhbmVvdXMgaXRlbXMgYXJlIGhhcm1sZXNzCi0JCXRoaXMucmVtb3ZlSXRlbXNGcm9tQ29sbGVjdGlvbihldmVudC5pdGVtcygpLCB0aGlzLmZpbHRlcmVkSXRlbXMsIFZBTFVFUyk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgY29sbGVjdGlvbkNsZWFyZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuY2xlYXJDb2xsZWN0aW9uKHRoaXMuZmlsdGVyZWRJdGVtcywgVkFMVUVTKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBjb2xsZWN0aW9uQ2hhbmdlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5yZWJ1aWxkRmlsdGVyZWRJdGVtcygpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBtaXNjZWxsYW5lb3VzICoqKioqKioqKioKLQotCS8qKgotCSAqIENoYW5nZSB0aGUgZmlsdGVyIGFuZCByZWJ1aWxkIHRoZSBjb2xsZWN0aW9uLgotCSAqLwotCXB1YmxpYyB2b2lkIHNldEZpbHRlcihGaWx0ZXI8RT4gZmlsdGVyKSB7Ci0JCXRoaXMuZmlsdGVyID0gZmlsdGVyOwotCQl0aGlzLnJlYnVpbGRGaWx0ZXJlZEl0ZW1zKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGFuIGl0ZXJhdG9yIHRoYXQgZmlsdGVycyB0aGUgc3BlY2lmaWVkIGl0ZXJhdG9yLgotCSAqLwotCXByb3RlY3RlZCBJdGVyYXRvcjxFPiBmaWx0ZXIoSXRlcmF0b3I8PyBleHRlbmRzIEU+IGl0ZW1zKSB7Ci0JCXJldHVybiBuZXcgRmlsdGVyaW5nSXRlcmF0b3I8RSwgRT4oaXRlbXMsIHRoaXMuZmlsdGVyKTsKLQl9Ci0KLQkvKioKLQkgKiBTeW5jaHJvbml6ZSBvdXIgY2FjaGUgd2l0aCB0aGUgd3JhcHBlZCBjb2xsZWN0aW9uLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIHJlYnVpbGRGaWx0ZXJlZEl0ZW1zKCkgewotCQl0aGlzLmZpbHRlcmVkSXRlbXMuY2xlYXIoKTsKLQkJQ29sbGVjdGlvblRvb2xzLmFkZEFsbCh0aGlzLmZpbHRlcmVkSXRlbXMsIHRoaXMuZmlsdGVyKHRoaXMuY29sbGVjdGlvbkhvbGRlci5pdGVyYXRvcigpKSk7Ci0JCXRoaXMuZmlyZUNvbGxlY3Rpb25DaGFuZ2VkKFZBTFVFUyk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvRmlsdGVyaW5nUHJvcGVydHlWYWx1ZU1vZGVsLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvRmlsdGVyaW5nUHJvcGVydHlWYWx1ZU1vZGVsLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGE1NmNjMzQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0ZpbHRlcmluZ1Byb3BlcnR5VmFsdWVNb2RlbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTM4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5GaWx0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci0KLS8qKgotICogQSA8Y29kZT5GaWx0ZXJpbmdQcm9wZXJ0eVZhbHVlTW9kZWw8L2NvZGU+IHdyYXBzIGFub3RoZXIKLSAqIDxjb2RlPlByb3BlcnR5VmFsdWVNb2RlbDwvY29kZT4gYW5kIHVzZXMgYSA8Y29kZT5GaWx0ZXI8L2NvZGU+Ci0gKiB0byBkZXRlcm1pbmUgd2hlbiB0aGUgd3JhcHBlZCB2YWx1ZSBpcyB0byBiZSByZXR1cm5lZCBieSBjYWxscwotICogdG8gPGNvZGU+dmFsdWUoKTwvY29kZT4uCi0gKiA8cD4KLSAqIEFzIGFuIGFsdGVybmF0aXZlIHRvIGJ1aWxkaW5nIGEgPGNvZGU+RmlsdGVyPC9jb2RlPiwgYSBzdWJjbGFzcwotICogb2YgPGNvZGU+RmlsdGVyaW5nUHJvcGVydHlWYWx1ZU1vZGVsPC9jb2RlPiBjYW4gb3ZlcnJpZGUgdGhlCi0gKiA8Y29kZT5hY2NlcHQoT2JqZWN0KTwvY29kZT4gbWV0aG9kLgotICogPHA+Ci0gKiBPbmUsIHBvc3NpYmx5IHVuZGVzaXJhYmxlLCBzaWRlLWVmZmVjdCBvZiB1c2luZyB0aGlzIHZhbHVlIG1vZGVsIGlzIHRoYXQKLSAqIGl0IG11c3QgcmV0dXJuICpzb21ldGhpbmcqIGFzIHRoZSB2YWx1ZS4gVGhlIGRlZmF1bHQgYmVoYXZpb3IgaXMKLSAqIHRvIHJldHVybiA8Y29kZT5udWxsPC9jb2RlPiB3aGVuZXZlciB0aGUgd3JhcHBlZCB2YWx1ZSBpcyBub3QgImFjY2VwdGVkIiwKLSAqIHdoaWNoIGNhbiBiZSBjb25maWd1cmVkIGFuZC9vciBvdmVycmlkZGVuLgotICovCi1wdWJsaWMgY2xhc3MgRmlsdGVyaW5nUHJvcGVydHlWYWx1ZU1vZGVsPFQ+Ci0JZXh0ZW5kcyBQcm9wZXJ0eVZhbHVlTW9kZWxXcmFwcGVyPFQ+Ci0JaW1wbGVtZW50cyBQcm9wZXJ0eVZhbHVlTW9kZWw8VD4KLXsKLQlwcm90ZWN0ZWQgZmluYWwgRmlsdGVyPFQ+IGZpbHRlcjsKLQlwcm90ZWN0ZWQgZmluYWwgVCBkZWZhdWx0VmFsdWU7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHByb3BlcnR5IHZhbHVlIG1vZGVsIHdpdGggdGhlIHNwZWNpZmllZCBuZXN0ZWQKLQkgKiBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCBhbmQgYSBkaXNhYmxlZCBmaWx0ZXIuCi0JICogVXNlIHRoaXMgY29uc3RydWN0b3IgaWYgeW91IHdhbnQgdG8gb3ZlcnJpZGUgdGhlCi0JICogPGNvZGU+YWNjZXB0KE9iamVjdCk8L2NvZGU+Ci0JICogbWV0aG9kIGluc3RlYWQgb2YgYnVpbGRpbmcgYSA8Y29kZT5GaWx0ZXI8L2NvZGU+LgotCSAqIFRoZSBkZWZhdWx0IHZhbHVlIHdpbGwgYmUgPGNvZGU+bnVsbDwvY29kZT4uCi0JICovCi0JcHVibGljIEZpbHRlcmluZ1Byb3BlcnR5VmFsdWVNb2RlbChQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFQ+IHZhbHVlSG9sZGVyKSB7Ci0JCXRoaXModmFsdWVIb2xkZXIsIEZpbHRlci5EaXNhYmxlZC48VD5pbnN0YW5jZSgpLCBudWxsKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCB3aXRoIHRoZSBzcGVjaWZpZWQgbmVzdGVkCi0JICogcHJvcGVydHkgdmFsdWUgbW9kZWwsIHNwZWNpZmllZCBkZWZhdWx0IHZhbHVlLCBhbmQgYSBkaXNhYmxlZCBmaWx0ZXIuCi0JICogVXNlIHRoaXMgY29uc3RydWN0b3IgaWYgeW91IHdhbnQgdG8gb3ZlcnJpZGUgdGhlCi0JICogPGNvZGU+YWNjZXB0KE9iamVjdCk8L2NvZGU+Ci0JICogbWV0aG9kIGluc3RlYWQgb2YgYnVpbGRpbmcgYSA8Y29kZT5GaWx0ZXI8L2NvZGU+Ci0JICogPGVtPmFuZDwvZW0+IHlvdSBuZWVkIHRvIHNwZWNpZnkKLQkgKiBhIGRlZmF1bHQgdmFsdWUgb3RoZXIgdGhhbiA8Y29kZT5udWxsPC9jb2RlPi4KLQkgKi8KLQlwdWJsaWMgRmlsdGVyaW5nUHJvcGVydHlWYWx1ZU1vZGVsKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgVD4gdmFsdWVIb2xkZXIsIFQgZGVmYXVsdFZhbHVlKSB7Ci0JCXRoaXModmFsdWVIb2xkZXIsIEZpbHRlci5EaXNhYmxlZC48VD5pbnN0YW5jZSgpLCBkZWZhdWx0VmFsdWUpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCB3aXRoIHRoZSBzcGVjaWZpZWQgbmVzdGVkCi0JICogcHJvcGVydHkgdmFsdWUgbW9kZWwgYW5kIGZpbHRlci4KLQkgKiBUaGUgZGVmYXVsdCB2YWx1ZSB3aWxsIGJlIDxjb2RlPm51bGw8L2NvZGU+LgotCSAqLwotCXB1YmxpYyBGaWx0ZXJpbmdQcm9wZXJ0eVZhbHVlTW9kZWwoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBUPiB2YWx1ZUhvbGRlciwgRmlsdGVyPFQ+IGZpbHRlcikgewotCQl0aGlzKHZhbHVlSG9sZGVyLCBmaWx0ZXIsIG51bGwpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCB3aXRoIHRoZSBzcGVjaWZpZWQgbmVzdGVkCi0JICogcHJvcGVydHkgdmFsdWUgbW9kZWwsIGZpbHRlciwgYW5kIGRlZmF1bHQgdmFsdWUuCi0JICovCi0JcHVibGljIEZpbHRlcmluZ1Byb3BlcnR5VmFsdWVNb2RlbChQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFQ+IHZhbHVlSG9sZGVyLCBGaWx0ZXI8VD4gZmlsdGVyLCBUIGRlZmF1bHRWYWx1ZSkgewotCQlzdXBlcih2YWx1ZUhvbGRlcik7Ci0JCXRoaXMuZmlsdGVyID0gZmlsdGVyOwotCQl0aGlzLmRlZmF1bHRWYWx1ZSA9IGRlZmF1bHRWYWx1ZTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogUHJvcGVydHlWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBUIGdldFZhbHVlKCkgewotCQlyZXR1cm4gdGhpcy5maWx0ZXJWYWx1ZSh0aGlzLnZhbHVlSG9sZGVyLmdldFZhbHVlKCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBQcm9wZXJ0eVZhbHVlTW9kZWxXcmFwcGVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHZhbHVlQ2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIGZpbHRlciB0aGUgdmFsdWVzIGJlZm9yZSBwcm9wYWdhdGluZyB0aGUgY2hhbmdlIGV2ZW50Ci0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlPYmplY3Qgb2xkVmFsdWUgPSB0aGlzLmZpbHRlclZhbHVlKChUKSBldmVudC5nZXRPbGRWYWx1ZSgpKTsKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCU9iamVjdCBuZXdWYWx1ZSA9IHRoaXMuZmlsdGVyVmFsdWUoKFQpIGV2ZW50LmdldE5ld1ZhbHVlKCkpOwotCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoVkFMVUUsIG9sZFZhbHVlLCBuZXdWYWx1ZSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHF1ZXJpZXMgKioqKioqKioqKgotCi0JLyoqCi0JICogSWYgdGhlIHNwZWNpZmllZCB2YWx1ZSBpcyAiYWNjZXB0ZWQiIHNpbXBseSByZXR1cm4gaXQsCi0JICogb3RoZXJ3aXNlIHJldHVybiB0aGUgZGVmYXVsdCB2YWx1ZS4KLQkgKi8KLQlwcm90ZWN0ZWQgVCBmaWx0ZXJWYWx1ZShUIHZhbHVlKSB7Ci0JCXJldHVybiB0aGlzLmFjY2VwdCh2YWx1ZSkgPyB2YWx1ZSA6IHRoaXMuZGVmYXVsdFZhbHVlKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIDxjb2RlPkZpbHRlcmluZ1Byb3BlcnR5VmFsdWVNb2RlbDwvY29kZT4gc2hvdWxkCi0JICogcmV0dXJuIHRoZSBzcGVjaWZpZWQgdmFsdWUgZnJvbSBhIGNhbGwgdG8gdGhlCi0JICogPGNvZGU+dmFsdWUoKTwvY29kZT4gbWV0aG9kOyB0aGUgdmFsdWUgY2FtZQotCSAqIGZyb20gdGhlIG5lc3RlZCBwcm9wZXJ0eSB2YWx1ZSBtb2RlbAotCSAqIDxwPgotCSAqIFRoaXMgbWV0aG9kIGNhbiBiZSBvdmVycmlkZGVuIGJ5IGEgc3ViY2xhc3MgYXMgYW4KLQkgKiBhbHRlcm5hdGl2ZSB0byBidWlsZGluZyBhIDxjb2RlPkZpbHRlcjwvY29kZT4uCi0JICovCi0JcHJvdGVjdGVkIGJvb2xlYW4gYWNjZXB0KFQgdmFsdWUpIHsKLQkJcmV0dXJuIHRoaXMuZmlsdGVyLmFjY2VwdCh2YWx1ZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBvYmplY3QgdGhhdCBzaG91bGQgYmUgcmV0dXJuZWQgaWYKLQkgKiB0aGUgbmVzdGVkIHZhbHVlIHdhcyByZWplY3RlZCBieSB0aGUgZmlsdGVyLgotCSAqIFRoZSBkZWZhdWx0IGlzIDxjb2RlPm51bGw8L2NvZGU+LgotCSAqLwotCXByb3RlY3RlZCBUIGRlZmF1bHRWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMuZGVmYXVsdFZhbHVlOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0ZpbHRlcmluZ1dyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvRmlsdGVyaW5nV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWwuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDdlMjBmNC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvRmlsdGVyaW5nV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEyNSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQmlkaUZpbHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBBIDxjb2RlPkZpbHRlcmluZ1dyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPC9jb2RlPiB3cmFwcyBhbm90aGVyCi0gKiA8Y29kZT5Xcml0YWJlbFByb3BlcnR5VmFsdWVNb2RlbDwvY29kZT4gYW5kIHVzZXMgYSA8Y29kZT5CaWRpRmlsdGVyPC9jb2RlPgotICogdG8gZGV0ZXJtaW5lIHdoZW4gdGhlIHdyYXBwZWQgdmFsdWUgaXMgdG8gYmUgcmV0dXJuZWQgYnkgY2FsbHMKLSAqIHRvIDxjb2RlPnZhbHVlKCk8L2NvZGU+IGFuZCBtb2RpZmllZCBieSBjYWxscyB0bwotICogPGNvZGU+c2V0VmFsdWUoT2JqZWN0KTwvY29kZT4uCi0gKiA8cD4KLSAqIEFzIGFuIGFsdGVybmF0aXZlIHRvIGJ1aWxkaW5nIGEgPGNvZGU+QmlkaUZpbHRlcjwvY29kZT4sIGEgc3ViY2xhc3MKLSAqIG9mIDxjb2RlPkZpbHRlcmluZ1dyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPC9jb2RlPiBjYW4gb3ZlcnJpZGUgdGhlCi0gKiA8Y29kZT5hY2NlcHQoT2JqZWN0KTwvY29kZT4gYW5kIDxjb2RlPnJldmVyc2VBY2NlcHQoT2JqZWN0KTwvY29kZT4KLSAqIG1ldGhvZHMuCi0gKiA8cD4KLSAqIE9uZSwgcG9zc2libHkgdW5kZXNpcmFibGUsIHNpZGUtZWZmZWN0IG9mIHVzaW5nIHRoaXMgdmFsdWUgbW9kZWwgaXMgdGhhdAotICogaXQgbXVzdCByZXR1cm4gKnNvbWV0aGluZyogYXMgdGhlIHZhbHVlLiBUaGUgZGVmYXVsdCBiZWhhdmlvciBpcwotICogdG8gcmV0dXJuIDxjb2RlPm51bGw8L2NvZGU+IHdoZW5ldmVyIHRoZSB3cmFwcGVkIHZhbHVlIGlzIG5vdCAiYWNjZXB0ZWQiLAotICogd2hpY2ggY2FuIGJlIGNvbmZpZ3VyZWQgYW5kL29yIG92ZXJyaWRkZW4uCi0gKiA8cD4KLSAqIFNpbWlsYXJseSwgaWYgYW4gaW5jb21pbmcgdmFsdWUgaXMgbm90ICJyZXZlcnNlQWNjZXB0ZWQiLCAqbm90aGluZyogd2lsbCBwYXNzZWQKLSAqIHRocm91Z2ggdG8gdGhlIHdyYXBwZWQgdmFsdWUgaG9sZGVyLCBub3QgZXZlbiA8Y29kZT5udWxsPC9jb2RlPi4KLSAqLwotcHVibGljIGNsYXNzIEZpbHRlcmluZ1dyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQ+Ci0JZXh0ZW5kcyBGaWx0ZXJpbmdQcm9wZXJ0eVZhbHVlTW9kZWw8VD4KLQlpbXBsZW1lbnRzIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQ+Ci17Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHByb3BlcnR5IHZhbHVlIG1vZGVsIHdpdGggdGhlIHNwZWNpZmllZCBuZXN0ZWQKLQkgKiBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCBhbmQgYSBkaXNhYmxlZCBmaWx0ZXIuCi0JICogVXNlIHRoaXMgY29uc3RydWN0b3IgaWYgeW91IHdhbnQgdG8gb3ZlcnJpZGUgdGhlCi0JICogPGNvZGU+YWNjZXB0KE9iamVjdCk8L2NvZGU+IGFuZCA8Y29kZT5yZXZlcnNlQWNjZXB0KE9iamVjdCk8L2NvZGU+Ci0JICogbWV0aG9kcyBpbnN0ZWFkIG9mIGJ1aWxkaW5nIGEgPGNvZGU+QmlkaUZpbHRlcjwvY29kZT4uCi0JICogVGhlIGRlZmF1bHQgdmFsdWUgd2lsbCBiZSA8Y29kZT5udWxsPC9jb2RlPi4KLQkgKi8KLQlwdWJsaWMgRmlsdGVyaW5nV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWwoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VD4gdmFsdWVIb2xkZXIpIHsKLQkJdGhpcyh2YWx1ZUhvbGRlciwgQmlkaUZpbHRlci5EaXNhYmxlZC48VD5pbnN0YW5jZSgpLCBudWxsKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCB3aXRoIHRoZSBzcGVjaWZpZWQgbmVzdGVkCi0JICogcHJvcGVydHkgdmFsdWUgbW9kZWwsIHNwZWNpZmllZCBkZWZhdWx0IHZhbHVlLCBhbmQgYSBkaXNhYmxlZCBmaWx0ZXIuCi0JICogVXNlIHRoaXMgY29uc3RydWN0b3IgaWYgeW91IHdhbnQgdG8gb3ZlcnJpZGUgdGhlCi0JICogPGNvZGU+YWNjZXB0KE9iamVjdCk8L2NvZGU+IGFuZCA8Y29kZT5yZXZlcnNlQWNjZXB0KE9iamVjdCk8L2NvZGU+Ci0JICogbWV0aG9kcyBpbnN0ZWFkIG9mIGJ1aWxkaW5nIGEgPGNvZGU+QmlkaUZpbHRlcjwvY29kZT4KLQkgKiA8ZW0+YW5kPC9lbT4geW91IG5lZWQgdG8gc3BlY2lmeQotCSAqIGEgZGVmYXVsdCB2YWx1ZSBvdGhlciB0aGFuIDxjb2RlPm51bGw8L2NvZGU+LgotCSAqLwotCXB1YmxpYyBGaWx0ZXJpbmdXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbChXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUPiB2YWx1ZUhvbGRlciwgVCBkZWZhdWx0VmFsdWUpIHsKLQkJdGhpcyh2YWx1ZUhvbGRlciwgQmlkaUZpbHRlci5EaXNhYmxlZC48VD5pbnN0YW5jZSgpLCBkZWZhdWx0VmFsdWUpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCB3aXRoIHRoZSBzcGVjaWZpZWQgbmVzdGVkCi0JICogcHJvcGVydHkgdmFsdWUgbW9kZWwgYW5kIGZpbHRlci4KLQkgKiBUaGUgZGVmYXVsdCB2YWx1ZSB3aWxsIGJlIDxjb2RlPm51bGw8L2NvZGU+LgotCSAqLwotCXB1YmxpYyBGaWx0ZXJpbmdXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbChXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUPiB2YWx1ZUhvbGRlciwgQmlkaUZpbHRlcjxUPiBmaWx0ZXIpIHsKLQkJdGhpcyh2YWx1ZUhvbGRlciwgZmlsdGVyLCBudWxsKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gcHJvcGVydHkgdmFsdWUgbW9kZWwgd2l0aCB0aGUgc3BlY2lmaWVkIG5lc3RlZAotCSAqIHByb3BlcnR5IHZhbHVlIG1vZGVsLCBmaWx0ZXIsIGFuZCBkZWZhdWx0IHZhbHVlLgotCSAqLwotCXB1YmxpYyBGaWx0ZXJpbmdXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbChXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUPiB2YWx1ZUhvbGRlciwgQmlkaUZpbHRlcjxUPiBmaWx0ZXIsIFQgZGVmYXVsdFZhbHVlKSB7Ci0JCXN1cGVyKHZhbHVlSG9sZGVyLCBmaWx0ZXIsIGRlZmF1bHRWYWx1ZSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIHNldFZhbHVlKFQgdmFsdWUpIHsKLQkJaWYgKHRoaXMucmV2ZXJzZUFjY2VwdCh2YWx1ZSkpIHsKLQkJCXRoaXMudmFsdWVIb2xkZXIoKS5zZXRWYWx1ZSh2YWx1ZSk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogcXVlcmllcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgPGNvZGU+RmlsdGVyaW5nV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8L2NvZGU+Ci0JICogc2hvdWxkIHBhc3MgdGhyb3VnaCB0aGUgc3BlY2lmaWVkIHZhbHVlIHRvIHRoZSBuZXN0ZWQKLQkgKiB3cml0YWJsZSBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCBpbiBhIGNhbGwgdG8gdGhlCi0JICogPGNvZGU+c2V0VmFsdWUoT2JqZWN0KTwvY29kZT4gbWV0aG9kCi0JICogPHA+Ci0JICogVGhpcyBtZXRob2QgY2FuIGJlIG92ZXJyaWRkZW4gYnkgYSBzdWJjbGFzcyBhcyBhbgotCSAqIGFsdGVybmF0aXZlIHRvIGJ1aWxkaW5nIGEgPGNvZGU+QmlkaUZpbHRlcjwvY29kZT4uCi0JICovCi0JcHJvdGVjdGVkIGJvb2xlYW4gcmV2ZXJzZUFjY2VwdChUIHZhbHVlKSB7Ci0JCXJldHVybiB0aGlzLmdldEZpbHRlcigpLnJldmVyc2VBY2NlcHQodmFsdWUpOwotCX0KLQotCS8qKgotCSAqIE91ciBjb25zdHJ1Y3RvcnMgYWNjZXB0IG9ubHkgYSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUPi4KLQkgKi8KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcm90ZWN0ZWQgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VD4gdmFsdWVIb2xkZXIoKSB7Ci0JCXJldHVybiAoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VD4pIHRoaXMudmFsdWVIb2xkZXI7Ci0JfQotCi0JLyoqCi0JICogT3VyIGNvbnN0cnVjdG9ycyBhY2NlcHQgb25seSBhIGJpZGlyZWN0aW9uYWwgZmlsdGVyLgotCSAqLwotCXByb3RlY3RlZCBCaWRpRmlsdGVyPFQ+IGdldEZpbHRlcigpIHsKLQkJcmV0dXJuIChCaWRpRmlsdGVyPFQ+KSB0aGlzLmZpbHRlcjsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9JdGVtQXNwZWN0TGlzdFZhbHVlTW9kZWxBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvSXRlbUFzcGVjdExpc3RWYWx1ZU1vZGVsQWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxNzUzOGY5Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9JdGVtQXNwZWN0TGlzdFZhbHVlTW9kZWxBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyOTUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkV2ZW50T2JqZWN0OwotaW1wb3J0IGphdmEudXRpbC5JZGVudGl0eUhhc2hNYXA7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ291bnRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuUmVhZE9ubHlMaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuTGlzdENoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotCi0vKioKLSAqIEFic3RyYWN0IGxpc3QgdmFsdWUgbW9kZWwgdGhhdCBwcm92aWRlcyBiZWhhdmlvciBmb3Igd3JhcHBpbmcgYSBsaXN0IHZhbHVlCi0gKiBtb2RlbCAob3IgY29sbGVjdGlvbiB2YWx1ZSBtb2RlbCkgYW5kIGxpc3RlbmluZyBmb3IgY2hhbmdlcyB0byBhc3BlY3RzIG9mIHRoZQotICogKml0ZW1zKiBoZWxkIGJ5IHRoZSBsaXN0IChvciBjb2xsZWN0aW9uKS4gQ2hhbmdlcyB0byB0aGUgYWN0dWFsIGxpc3QKLSAqIChvciBjb2xsZWN0aW9uKSBhcmUgYWxzbyBtb25pdG9yZWQuCi0gKiAKLSAqIFRoaXMgaXMgdXNlZnVsIGlmIHlvdSBoYXZlIGEgY29sbGVjdGlvbiBvZiBpdGVtcyB0aGF0IGNhbiBiZSBtb2RpZmllZCBieSBhZGRpbmcKLSAqIG9yIHJlbW92aW5nIGl0ZW1zIG9yIHRoZSBpdGVtcyB0aGVtc2VsdmVzIG1pZ2h0IGNoYW5nZSBpbiBhIGZhc2hpb24gdGhhdAotICogbWlnaHQgY2hhbmdlIHRoZSBjb2xsZWN0aW9uJ3MgZXh0ZXJuYWwgYXBwZWFyYW5jZS4KLSAqIAotICogU3ViY2xhc3NlcyBuZWVkIHRvIG92ZXJyaWRlIHR3byBtZXRob2RzOgotICogCi0gKiAjbGlzdGVuVG9JdGVtKE1vZGVsKQotICogICAgIGJlZ2luIGxpc3RlbmluZyB0byB0aGUgYXBwcm9wcmlhdGUgYXNwZWN0IG9mIHRoZSBzcGVjaWZpZWQgaXRlbSBhbmQgY2FsbAotICogICAgICNpdGVtQXNwZWN0Q2hhbmdlZChPYmplY3QpIHdoZW5ldmVyIHRoZSBhc3BlY3QgY2hhbmdlcwotICogCi0gKiAjc3RvcExpc3RlbmluZ1RvSXRlbShNb2RlbCkKLSAqICAgICBzdG9wIGxpc3RlbmluZyB0byB0aGUgYXBwcm9wcmlhdGUgYXNwZWN0IG9mIHRoZSBzcGVjaWZpZWQgaXRlbQotICovCi1wdWJsaWMgYWJzdHJhY3QgY2xhc3MgSXRlbUFzcGVjdExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFPgotCWV4dGVuZHMgTGlzdFZhbHVlTW9kZWxXcmFwcGVyPEU+Ci0JaW1wbGVtZW50cyBMaXN0VmFsdWVNb2RlbDxFPgotewotCi0JLyoqCi0JICogTWFpbnRhaW4gYSBjb3VudGVyIGZvciBlYWNoIG9mIHRoZSBpdGVtcyBpbiB0aGUKLQkgKiB3cmFwcGVkIGxpc3QgaG9sZGVyIHdlIGFyZSBsaXN0ZW5pbmcgdG8uCi0JICovCi0JcHJvdGVjdGVkIGZpbmFsIElkZW50aXR5SGFzaE1hcDxFLCBDb3VudGVyPiBjb3VudGVyczsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0b3IgLSB0aGUgbGlzdCBob2xkZXIgaXMgcmVxdWlyZWQuCi0JICovCi0JcHJvdGVjdGVkIEl0ZW1Bc3BlY3RMaXN0VmFsdWVNb2RlbEFkYXB0ZXIoTGlzdFZhbHVlTW9kZWw8PyBleHRlbmRzIEU+IGxpc3RIb2xkZXIpIHsKLQkJc3VwZXIobGlzdEhvbGRlcik7Ci0JCXRoaXMuY291bnRlcnMgPSBuZXcgSWRlbnRpdHlIYXNoTWFwPEUsIENvdW50ZXI+KCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0b3IgLSB0aGUgY29sbGVjdGlvbiBob2xkZXIgaXMgcmVxdWlyZWQuCi0JICovCi0JcHJvdGVjdGVkIEl0ZW1Bc3BlY3RMaXN0VmFsdWVNb2RlbEFkYXB0ZXIoQ29sbGVjdGlvblZhbHVlTW9kZWw8PyBleHRlbmRzIEU+IGNvbGxlY3Rpb25Ib2xkZXIpIHsKLQkJdGhpcyhuZXcgQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFPihjb2xsZWN0aW9uSG9sZGVyKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIExpc3RWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBJdGVyYXRvcjxFPiBpdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMubGlzdEl0ZXJhdG9yKCk7Ci0JfQotCi0JcHVibGljIExpc3RJdGVyYXRvcjxFPiBsaXN0SXRlcmF0b3IoKSB7Ci0JCXJldHVybiBuZXcgUmVhZE9ubHlMaXN0SXRlcmF0b3I8RT4odGhpcy5saXN0SG9sZGVyLmxpc3RJdGVyYXRvcigpKTsKLQl9Ci0KLQlwdWJsaWMgRSBnZXQoaW50IGluZGV4KSB7Ci0JCXJldHVybiB0aGlzLmxpc3RIb2xkZXIuZ2V0KGluZGV4KTsKLQl9Ci0KLQlwdWJsaWMgaW50IHNpemUoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3RIb2xkZXIuc2l6ZSgpOwotCX0KLQotCXB1YmxpYyBPYmplY3RbXSB0b0FycmF5KCkgewotCQlyZXR1cm4gdGhpcy5saXN0SG9sZGVyLnRvQXJyYXkoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCi0JLyoqCi0JICogU3RhcnQgbGlzdGVuaW5nIHRvIHRoZSBsaXN0IGhvbGRlciBhbmQgdGhlIGl0ZW1zIGluIHRoZSBsaXN0LgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGVuZ2FnZU1vZGVsKCkgewotCQlzdXBlci5lbmdhZ2VNb2RlbCgpOwotCQl0aGlzLmVuZ2FnZUFsbEl0ZW1zKCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlQWxsSXRlbXMoKSB7Ci0JCXRoaXMuZW5nYWdlSXRlbXModGhpcy5saXN0SG9sZGVyLml0ZXJhdG9yKCkpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGVuZ2FnZUl0ZW1zKEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBzdHJlYW0pIHsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCXRoaXMuZW5nYWdlSXRlbShzdHJlYW0ubmV4dCgpKTsKLQkJfQotCX0KLQotCXByb3RlY3RlZCB2b2lkIGVuZ2FnZUl0ZW0oRSBpdGVtKSB7Ci0JCS8vIGxpc3RlbiB0byBhbiBpdGVtIG9ubHkgb25jZQotCQlDb3VudGVyIGNvdW50ZXIgPSB0aGlzLmNvdW50ZXJzLmdldChpdGVtKTsKLQkJaWYgKGNvdW50ZXIgPT0gbnVsbCkgewotCQkJY291bnRlciA9IG5ldyBDb3VudGVyKCk7Ci0JCQl0aGlzLmNvdW50ZXJzLnB1dChpdGVtLCBjb3VudGVyKTsKLQkJCXRoaXMuc3RhcnRMaXN0ZW5pbmdUb0l0ZW0oKE1vZGVsKSBpdGVtKTsKLQkJfQotCQljb3VudGVyLmluY3JlbWVudCgpOwotCX0KLQotCS8qKgotCSAqIFN0YXJ0IGxpc3RlbmluZyB0byB0aGUgc3BlY2lmaWVkIGl0ZW0uCi0JICovCi0JcHJvdGVjdGVkIGFic3RyYWN0IHZvaWQgc3RhcnRMaXN0ZW5pbmdUb0l0ZW0oTW9kZWwgaXRlbSk7Ci0KLQkvKioKLQkgKiBTdG9wIGxpc3RlbmluZyB0byB0aGUgbGlzdCBob2xkZXIgYW5kIHRoZSBpdGVtcyBpbiB0aGUgbGlzdC4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VNb2RlbCgpIHsKLQkJdGhpcy5kaXNlbmdhZ2VBbGxJdGVtcygpOwotCQlzdXBlci5kaXNlbmdhZ2VNb2RlbCgpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZUFsbEl0ZW1zKCkgewotCQl0aGlzLmRpc2VuZ2FnZUl0ZW1zKHRoaXMubGlzdEhvbGRlci5pdGVyYXRvcigpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VJdGVtcyhJdGVyYXRvcjw/IGV4dGVuZHMgRT4gc3RyZWFtKSB7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQl0aGlzLmRpc2VuZ2FnZUl0ZW0oc3RyZWFtLm5leHQoKSk7Ci0JCX0KLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VJdGVtKEUgaXRlbSkgewotCQkvLyBzdG9wIGxpc3RlbmluZyB0byBhbiBpdGVtIG9ubHkgb25jZQotCQlDb3VudGVyIGNvdW50ZXIgPSB0aGlzLmNvdW50ZXJzLmdldChpdGVtKTsKLQkJaWYgKGNvdW50ZXIgPT0gbnVsbCkgewotCQkJLy8gc29tZXRoaW5nIGlzIHdyb25nIGlmIHRoaXMgaGFwcGVucy4uLiAgfmJqdgotCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigibWlzc2luZyBjb3VudGVyOiAiICsgaXRlbSk7Ci0JCX0KLQkJaWYgKGNvdW50ZXIuZGVjcmVtZW50KCkgPT0gMCkgewotCQkJdGhpcy5jb3VudGVycy5yZW1vdmUoaXRlbSk7Ci0JCQl0aGlzLnN0b3BMaXN0ZW5pbmdUb0l0ZW0oKE1vZGVsKSBpdGVtKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFN0b3AgbGlzdGVuaW5nIHRvIHRoZSBzcGVjaWZpZWQgaXRlbS4KLQkgKi8KLQlwcm90ZWN0ZWQgYWJzdHJhY3Qgdm9pZCBzdG9wTGlzdGVuaW5nVG9JdGVtKE1vZGVsIGl0ZW0pOwotCi0KLQkvLyAqKioqKioqKioqIGxpc3QgY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JLyoqCi0JICogSXRlbXMgd2VyZSBhZGRlZCB0byB0aGUgd3JhcHBlZCBsaXN0IGhvbGRlci4KLQkgKiBGb3J3YXJkIHRoZSBldmVudCBhbmQgYmVnaW4gbGlzdGVuaW5nIHRvIHRoZSBhZGRlZCBpdGVtcy4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkvLyByZS1maXJlIGV2ZW50IHdpdGggdGhlIHdyYXBwZXIgYXMgdGhlIHNvdXJjZQotCQl0aGlzLmZpcmVJdGVtc0FkZGVkKGV2ZW50LmNsb25lV2l0aFNvdXJjZSh0aGlzLCBMSVNUX1ZBTFVFUykpOwotCQl0aGlzLmVuZ2FnZUl0ZW1zKHRoaXMuaXRlbXMoZXZlbnQpKTsKLQl9Ci0KLQkvKioKLQkgKiBJdGVtcyB3ZXJlIHJlbW92ZWQgZnJvbSB0aGUgd3JhcHBlZCBsaXN0IGhvbGRlci4KLQkgKiBTdG9wIGxpc3RlbmluZyB0byB0aGUgcmVtb3ZlZCBpdGVtcyBhbmQgZm9yd2FyZCB0aGUgZXZlbnQuCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmRpc2VuZ2FnZUl0ZW1zKHRoaXMuaXRlbXMoZXZlbnQpKTsKLQkJLy8gcmUtZmlyZSBldmVudCB3aXRoIHRoZSB3cmFwcGVyIGFzIHRoZSBzb3VyY2UKLQkJdGhpcy5maXJlSXRlbXNSZW1vdmVkKGV2ZW50LmNsb25lV2l0aFNvdXJjZSh0aGlzLCBMSVNUX1ZBTFVFUykpOwotCX0KLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgcmVwbGFjZWQgaW4gdGhlIHdyYXBwZWQgbGlzdCBob2xkZXIuCi0JICogU3RvcCBsaXN0ZW5pbmcgdG8gdGhlIHJlbW92ZWQgaXRlbXMsIGZvcndhcmQgdGhlIGV2ZW50LAotCSAqIGFuZCBiZWdpbiBsaXN0ZW5pbmcgdG8gdGhlIGFkZGVkIGl0ZW1zLgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuZGlzZW5nYWdlSXRlbXModGhpcy5yZXBsYWNlZEl0ZW1zKGV2ZW50KSk7Ci0JCS8vIHJlLWZpcmUgZXZlbnQgd2l0aCB0aGUgd3JhcHBlciBhcyB0aGUgc291cmNlCi0JCXRoaXMuZmlyZUl0ZW1zUmVwbGFjZWQoZXZlbnQuY2xvbmVXaXRoU291cmNlKHRoaXMsIExJU1RfVkFMVUVTKSk7Ci0JCXRoaXMuZW5nYWdlSXRlbXModGhpcy5pdGVtcyhldmVudCkpOwotCX0KLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgbW92ZWQgaW4gdGhlIHdyYXBwZWQgbGlzdCBob2xkZXIuCi0JICogTm8gbmVlZCB0byBjaGFuZ2UgYW55IGxpc3RlbmVyczsganVzdCBmb3J3YXJkIHRoZSBldmVudC4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBpdGVtc01vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkvLyByZS1maXJlIGV2ZW50IHdpdGggdGhlIHdyYXBwZXIgYXMgdGhlIHNvdXJjZQotCQl0aGlzLmZpcmVJdGVtc01vdmVkKGV2ZW50LmNsb25lV2l0aFNvdXJjZSh0aGlzLCBMSVNUX1ZBTFVFUykpOwotCX0KLQotCS8qKgotCSAqIFRoZSB3cmFwcGVkIGxpc3QgaG9sZGVyIHdhcyBjbGVhcmVkLgotCSAqIFN0b3AgbGlzdGVuaW5nIHRvIHRoZSByZW1vdmVkIGl0ZW1zIGFuZCBmb3J3YXJkIHRoZSBldmVudC4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gd2Ugc2hvdWxkIG9ubHkgbmVlZCB0byBkaXNlbmdhZ2UgZWFjaCBpdGVtIG9uY2UuLi4KLQkJLy8gbWFrZSBhIGNvcHkgdG8gcHJldmVudCBhIENvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24KLQkJQ29sbGVjdGlvbjxFPiBrZXlzID0gbmV3IEFycmF5TGlzdDxFPih0aGlzLmNvdW50ZXJzLmtleVNldCgpKTsKLQkJdGhpcy5kaXNlbmdhZ2VJdGVtcyhrZXlzLml0ZXJhdG9yKCkpOwotCQl0aGlzLmNvdW50ZXJzLmNsZWFyKCk7Ci0JCS8vIHJlLWZpcmUgZXZlbnQgd2l0aCB0aGUgd3JhcHBlciBhcyB0aGUgc291cmNlCi0JCXRoaXMuZmlyZUxpc3RDbGVhcmVkKExJU1RfVkFMVUVTKTsKLQl9Ci0KLQkvKioKLQkgKiBUaGUgd3JhcHBlZCBsaXN0IGhvbGRlciBoYXMgY2hhbmdlZCBpbiBzb21lIGRyYW1hdGljIGZhc2hpb24uCi0JICogUmVjb25maWd1cmUgb3VyIGxpc3RlbmVycyBhbmQgZm9yd2FyZCB0aGUgZXZlbnQuCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgbGlzdENoYW5nZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIHdlIHNob3VsZCBvbmx5IG5lZWQgdG8gZGlzZW5nYWdlIGVhY2ggaXRlbSBvbmNlLi4uCi0JCS8vIG1ha2UgYSBjb3B5IHRvIHByZXZlbnQgYSBDb25jdXJyZW50TW9kaWZpY2F0aW9uRXhjZXB0aW9uCi0JCUNvbGxlY3Rpb248RT4ga2V5cyA9IG5ldyBBcnJheUxpc3Q8RT4odGhpcy5jb3VudGVycy5rZXlTZXQoKSk7Ci0JCXRoaXMuZGlzZW5nYWdlSXRlbXMoa2V5cy5pdGVyYXRvcigpKTsKLQkJdGhpcy5jb3VudGVycy5jbGVhcigpOwotCQkvLyByZS1maXJlIGV2ZW50IHdpdGggdGhlIHdyYXBwZXIgYXMgdGhlIHNvdXJjZQotCQl0aGlzLmZpcmVMaXN0Q2hhbmdlZChMSVNUX1ZBTFVFUyk7Ci0JCXRoaXMuZW5nYWdlQWxsSXRlbXMoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaXRlbSBjaGFuZ2Ugc3VwcG9ydCAqKioqKioqKioqCi0KLQkvKioKLQkgKiBUaGUgc3BlY2lmaWVkIGl0ZW0gaGFzIGEgYm91bmQgcHJvcGVydHkgdGhhdCBoYXMgY2hhbmdlZC4KLQkgKiBOb3RpZnkgbGlzdGVuZXJzIG9mIHRoZSBjaGFuZ2UuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgaXRlbUFzcGVjdENoYW5nZWQoRXZlbnRPYmplY3QgZXZlbnQpIHsKLQkJT2JqZWN0IGl0ZW0gPSBldmVudC5nZXRTb3VyY2UoKTsKLQkJaW50IGluZGV4ID0gdGhpcy5sYXN0SWRlbnRpdHlJbmRleE9mKGl0ZW0pOwotCQl3aGlsZSAoaW5kZXggIT0gLTEpIHsKLQkJCXRoaXMuaXRlbUFzcGVjdENoYW5nZWQoaW5kZXgsIGl0ZW0pOwotCQkJaW5kZXggPSB0aGlzLmxhc3RJZGVudGl0eUluZGV4T2YoaXRlbSwgaW5kZXgpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogVGhlIHNwZWNpZmllZCBpdGVtIGhhcyBhIGJvdW5kIHByb3BlcnR5IHRoYXQgaGFzIGNoYW5nZWQuCi0JICogTm90aWZ5IGxpc3RlbmVycyBvZiB0aGUgY2hhbmdlLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGl0ZW1Bc3BlY3RDaGFuZ2VkKGludCBpbmRleCwgT2JqZWN0IGl0ZW0pIHsKLQkJdGhpcy5maXJlSXRlbVJlcGxhY2VkKExJU1RfVkFMVUVTLCBpbmRleCwgaXRlbSwgaXRlbSk7CQkvLyBobW1tLi4uCi0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBsYXN0IGluZGV4IG9mIHRoZSBzcGVjaWZpZWQgaXRlbSwgdXNpbmcgb2JqZWN0Ci0JICogaWRlbnRpdHkgaW5zdGVhZCBvZiBlcXVhbGl0eS4KLQkgKi8KLQlwcm90ZWN0ZWQgaW50IGxhc3RJZGVudGl0eUluZGV4T2YoT2JqZWN0IG8pIHsKLQkJcmV0dXJuIHRoaXMubGFzdElkZW50aXR5SW5kZXhPZihvLCB0aGlzLmxpc3RIb2xkZXIuc2l6ZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGxhc3QgaW5kZXggb2YgdGhlIHNwZWNpZmllZCBpdGVtLCBzdGFydGluZyBqdXN0IGJlZm9yZSB0aGUKLQkgKiB0aGUgc3BlY2lmaWVkIGVuZHBvaW50LCBhbmQgdXNpbmcgb2JqZWN0IGlkZW50aXR5IGluc3RlYWQgb2YgZXF1YWxpdHkuCi0JICovCi0JcHJvdGVjdGVkIGludCBsYXN0SWRlbnRpdHlJbmRleE9mKE9iamVjdCBvLCBpbnQgZW5kKSB7Ci0JCWZvciAoaW50IGkgPSBlbmQ7IGktLSA+IDA7ICkgewotCQkJaWYgKHRoaXMubGlzdEhvbGRlci5nZXQoaSkgPT0gbykgewotCQkJCXJldHVybiBpOwotCQkJfQotCQl9Ci0JCXJldHVybiAtMTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9JdGVtQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0l0ZW1Db2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDE1MWE5MGYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0l0ZW1Db2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw5NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5czsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5Nb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Db2xsZWN0aW9uQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotCi0vKioKLSAqIEV4dGVuZCBJdGVtQXNwZWN0TGlzdFZhbHVlTW9kZWxBZGFwdGVyIHRvIGxpc3RlbiB0byBvbmUgb3IgbW9yZSBjb2xsZWN0aW9uCi0gKiBhc3BlY3RzIG9mIGVhY2ggaXRlbSBpbiB0aGUgd3JhcHBlZCBsaXN0IG1vZGVsLgotICovCi1wdWJsaWMgY2xhc3MgSXRlbUNvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXI8RT4KLQlleHRlbmRzIEl0ZW1Bc3BlY3RMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8RT4KLXsKLQotCS8qKiBUaGUgbmFtZXMgb2YgdGhlIGl0ZW1zJyBjb2xsZWN0aW9ucyB0aGF0IHdlIGxpc3RlbiB0by4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgU3RyaW5nW10gY29sbGVjdGlvbk5hbWVzOwotCi0JLyoqIExpc3RlbmVyIHRoYXQgbGlzdGVucyB0byBhbGwgdGhlIGl0ZW1zIGluIHRoZSBsaXN0LiAqLwotCXByb3RlY3RlZCBmaW5hbCBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgaXRlbUNvbGxlY3Rpb25MaXN0ZW5lcjsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgaXRlbSBDb2xsZWN0aW9ucy4KLQkgKi8KLQlwdWJsaWMgSXRlbUNvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXIoTGlzdFZhbHVlTW9kZWw8RT4gbGlzdEhvbGRlciwgU3RyaW5nLi4uIGNvbGxlY3Rpb25OYW1lcykgewotCQlzdXBlcihsaXN0SG9sZGVyKTsKLQkJdGhpcy5jb2xsZWN0aW9uTmFtZXMgPSBjb2xsZWN0aW9uTmFtZXM7Ci0JCXRoaXMuaXRlbUNvbGxlY3Rpb25MaXN0ZW5lciA9IHRoaXMuYnVpbGRJdGVtQ29sbGVjdGlvbkxpc3RlbmVyKCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgaXRlbSBDb2xsZWN0aW9ucy4KLQkgKi8KLQlwdWJsaWMgSXRlbUNvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXIoQ29sbGVjdGlvblZhbHVlTW9kZWw8RT4gY29sbGVjdGlvbkhvbGRlciwgU3RyaW5nLi4uIGNvbGxlY3Rpb25OYW1lcykgewotCQl0aGlzKG5ldyBDb2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyPEU+KGNvbGxlY3Rpb25Ib2xkZXIpLCBjb2xsZWN0aW9uTmFtZXMpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0KLQkvKioKLQkgKiBBbGwgd2UgcmVhbGx5IGNhcmUgYWJvdXQgaXMgdGhlIGZhY3QgdGhhdCBhIENvbGxlY3Rpb24gYXNwZWN0IGhhcyAKLQkgKiBjaGFuZ2VkLiAgRG8gdGhlIHNhbWUgdGhpbmcgbm8gbWF0dGVyIHdoaWNoIGV2ZW50IG9jY3Vycy4KLQkgKi8KLQlwcm90ZWN0ZWQgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGJ1aWxkSXRlbUNvbGxlY3Rpb25MaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUl0ZW1Db2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyLnRoaXMuaXRlbUFzcGVjdENoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUl0ZW1Db2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyLnRoaXMuaXRlbUFzcGVjdENoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNsZWFyZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJSXRlbUNvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXIudGhpcy5pdGVtQXNwZWN0Q2hhbmdlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBjb2xsZWN0aW9uQ2hhbmdlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlJdGVtQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlci50aGlzLml0ZW1Bc3BlY3RDaGFuZ2VkKGV2ZW50KTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gIml0ZW0gY29sbGVjdGlvbiBsaXN0ZW5lcjogIiArIEFycmF5cy5hc0xpc3QoSXRlbUNvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXIudGhpcy5jb2xsZWN0aW9uTmFtZXMpOwotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzdGFydExpc3RlbmluZ1RvSXRlbShNb2RlbCBpdGVtKSB7Ci0JCWZvciAoU3RyaW5nIGNvbGxlY3Rpb25OYW1lIDogdGhpcy5jb2xsZWN0aW9uTmFtZXMpIHsKLQkJCWl0ZW0uYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKGNvbGxlY3Rpb25OYW1lLCB0aGlzLml0ZW1Db2xsZWN0aW9uTGlzdGVuZXIpOwotCQl9Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc3RvcExpc3RlbmluZ1RvSXRlbShNb2RlbCBpdGVtKSB7Ci0JCWZvciAoU3RyaW5nIGNvbGxlY3Rpb25OYW1lIDogdGhpcy5jb2xsZWN0aW9uTmFtZXMpIHsKLQkJCWl0ZW0ucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKGNvbGxlY3Rpb25OYW1lLCB0aGlzLml0ZW1Db2xsZWN0aW9uTGlzdGVuZXIpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvSXRlbUxpc3RMaXN0VmFsdWVNb2RlbEFkYXB0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9JdGVtTGlzdExpc3RWYWx1ZU1vZGVsQWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1MzU0YzFiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9JdGVtTGlzdExpc3RWYWx1ZU1vZGVsQWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTAzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLk1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50Lkxpc3RDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5MaXN0Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci0KLS8qKgotICogRXh0ZW5kIEl0ZW1Bc3BlY3RMaXN0VmFsdWVNb2RlbEFkYXB0ZXIgdG8gbGlzdGVuIHRvIG9uZSBvciBtb3JlIGxpc3QKLSAqIGFzcGVjdHMgb2YgZWFjaCBpdGVtIGluIHRoZSB3cmFwcGVkIGxpc3QgbW9kZWwuCi0gKi8KLXB1YmxpYyBjbGFzcyBJdGVtTGlzdExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFPgotCWV4dGVuZHMgSXRlbUFzcGVjdExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFPgotewotCi0JLyoqIFRoZSBuYW1lcyBvZiB0aGUgc3ViamVjdCdzIGxpc3RzIHRoYXQgd2UgbGlzdGVuIHRvLiAqLwotCXByb3RlY3RlZCBmaW5hbCBTdHJpbmdbXSBsaXN0TmFtZXM7Ci0KLQkvKiogTGlzdGVuZXIgdGhhdCBsaXN0ZW5zIHRvIGFsbCB0aGUgaXRlbXMgaW4gdGhlIGxpc3QuICovCi0JcHJvdGVjdGVkIGZpbmFsIExpc3RDaGFuZ2VMaXN0ZW5lciBpdGVtTGlzdExpc3RlbmVyOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gYWRhcHRlciBmb3IgdGhlIHNwZWNpZmllZCBpdGVtIExpc3QgYXNwZWN0cy4KLQkgKi8KLQlwdWJsaWMgSXRlbUxpc3RMaXN0VmFsdWVNb2RlbEFkYXB0ZXIoTGlzdFZhbHVlTW9kZWw8RT4gbGlzdEhvbGRlciwgU3RyaW5nLi4uIGxpc3ROYW1lcykgewotCQlzdXBlcihsaXN0SG9sZGVyKTsKLQkJdGhpcy5saXN0TmFtZXMgPSBsaXN0TmFtZXM7Ci0JCXRoaXMuaXRlbUxpc3RMaXN0ZW5lciA9IHRoaXMuYnVpbGRJdGVtTGlzdExpc3RlbmVyKCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgaXRlbSBMaXN0IGFzcGVjdHMuCi0JICovCi0JcHVibGljIEl0ZW1MaXN0TGlzdFZhbHVlTW9kZWxBZGFwdGVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsPEU+IGNvbGxlY3Rpb25Ib2xkZXIsIFN0cmluZy4uLiBsaXN0TmFtZXMpIHsKLQkJdGhpcyhuZXcgQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFPihjb2xsZWN0aW9uSG9sZGVyKSwgbGlzdE5hbWVzKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JLyoqCi0JICogQWxsIHdlIHJlYWxseSBjYXJlIGFib3V0IGlzIHRoZSBmYWN0IHRoYXQgdGhlIExpc3QgYXNwZWN0IGhhcyAKLQkgKiBjaGFuZ2VkLiAgRG8gdGhlIHNhbWUgdGhpbmcgbm8gbWF0dGVyIHdoaWNoIGV2ZW50IG9jY3Vycy4KLQkgKi8KLQlwcm90ZWN0ZWQgTGlzdENoYW5nZUxpc3RlbmVyIGJ1aWxkSXRlbUxpc3RMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBMaXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUl0ZW1MaXN0TGlzdFZhbHVlTW9kZWxBZGFwdGVyLnRoaXMuaXRlbUFzcGVjdENoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUl0ZW1MaXN0TGlzdFZhbHVlTW9kZWxBZGFwdGVyLnRoaXMuaXRlbUFzcGVjdENoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlJdGVtTGlzdExpc3RWYWx1ZU1vZGVsQWRhcHRlci50aGlzLml0ZW1Bc3BlY3RDaGFuZ2VkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJSXRlbUxpc3RMaXN0VmFsdWVNb2RlbEFkYXB0ZXIudGhpcy5pdGVtQXNwZWN0Q2hhbmdlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlJdGVtTGlzdExpc3RWYWx1ZU1vZGVsQWRhcHRlci50aGlzLml0ZW1Bc3BlY3RDaGFuZ2VkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGxpc3RDaGFuZ2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUl0ZW1MaXN0TGlzdFZhbHVlTW9kZWxBZGFwdGVyLnRoaXMuaXRlbUFzcGVjdENoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiaXRlbSBsaXN0IGxpc3RlbmVyOiAiICsgQXJyYXlzLmFzTGlzdChJdGVtTGlzdExpc3RWYWx1ZU1vZGVsQWRhcHRlci50aGlzLmxpc3ROYW1lcyk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzdGFydExpc3RlbmluZ1RvSXRlbShNb2RlbCBpdGVtKSB7Ci0JCWZvciAoU3RyaW5nIGxpc3ROYW1lIDogdGhpcy5saXN0TmFtZXMpIHsKLQkJCWl0ZW0uYWRkTGlzdENoYW5nZUxpc3RlbmVyKGxpc3ROYW1lLCB0aGlzLml0ZW1MaXN0TGlzdGVuZXIpOwotCQl9Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc3RvcExpc3RlbmluZ1RvSXRlbShNb2RlbCBpdGVtKSB7Ci0JCWZvciAoU3RyaW5nIGxpc3ROYW1lIDogdGhpcy5saXN0TmFtZXMpIHsKLQkJCWl0ZW0ucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKGxpc3ROYW1lLCB0aGlzLml0ZW1MaXN0TGlzdGVuZXIpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvSXRlbVByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvSXRlbVByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQ4MTQwYTAuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0l0ZW1Qcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotCi0vKioKLSAqIEV4dGVuZCBJdGVtQXNwZWN0TGlzdFZhbHVlTW9kZWxBZGFwdGVyIHRvIGxpc3RlbiB0byBvbmUgb3IgbW9yZQotICogcHJvcGVydGllcyBvZiBlYWNoIGl0ZW0gaW4gdGhlIHdyYXBwZWQgbGlzdCBtb2RlbC4KLSAqLwotcHVibGljIGNsYXNzIEl0ZW1Qcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFPgotCWV4dGVuZHMgSXRlbUFzcGVjdExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFPgotewotCi0JLyoqIFRoZSBuYW1lcyBvZiB0aGUgaXRlbXMnIHByb3BlcnRpZXMgdGhhdCB3ZSBsaXN0ZW4gdG8uICovCi0JcHJvdGVjdGVkIGZpbmFsIFN0cmluZ1tdIHByb3BlcnR5TmFtZXM7Ci0KLQkvKiogTGlzdGVuZXIgdGhhdCBsaXN0ZW5zIHRvIGFsbCB0aGUgaXRlbXMgaW4gdGhlIGxpc3QuICovCi0JcHJvdGVjdGVkIGZpbmFsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgaXRlbVByb3BlcnR5TGlzdGVuZXI7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBhZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIGl0ZW0gcHJvcGVydGllcy4KLQkgKi8KLQlwdWJsaWMgSXRlbVByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyKExpc3RWYWx1ZU1vZGVsPEU+IGxpc3RIb2xkZXIsIFN0cmluZy4uLiBwcm9wZXJ0eU5hbWVzKSB7Ci0JCXN1cGVyKGxpc3RIb2xkZXIpOwotCQl0aGlzLnByb3BlcnR5TmFtZXMgPSBwcm9wZXJ0eU5hbWVzOwotCQl0aGlzLml0ZW1Qcm9wZXJ0eUxpc3RlbmVyID0gdGhpcy5idWlsZEl0ZW1Qcm9wZXJ0eUxpc3RlbmVyKCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgaXRlbSBwcm9wZXJ0aWVzLgotCSAqLwotCXB1YmxpYyBJdGVtUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXIoQ29sbGVjdGlvblZhbHVlTW9kZWw8RT4gY29sbGVjdGlvbkhvbGRlciwgU3RyaW5nLi4uIHByb3BlcnR5TmFtZXMpIHsKLQkJdGhpcyhuZXcgQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFPihjb2xsZWN0aW9uSG9sZGVyKSwgcHJvcGVydHlOYW1lcyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkSXRlbVByb3BlcnR5TGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJSXRlbVByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyLnRoaXMuaXRlbUFzcGVjdENoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiaXRlbSBwcm9wZXJ0eSBsaXN0ZW5lcjogIiArIEFycmF5cy5hc0xpc3QoSXRlbVByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyLnRoaXMucHJvcGVydHlOYW1lcyk7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzdGFydExpc3RlbmluZ1RvSXRlbShNb2RlbCBpdGVtKSB7Ci0JCWZvciAoU3RyaW5nIHByb3BlcnR5TmFtZSA6IHRoaXMucHJvcGVydHlOYW1lcykgewotCQkJaXRlbS5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHByb3BlcnR5TmFtZSwgdGhpcy5pdGVtUHJvcGVydHlMaXN0ZW5lcik7Ci0JCX0KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzdG9wTGlzdGVuaW5nVG9JdGVtKE1vZGVsIGl0ZW0pIHsKLQkJZm9yIChTdHJpbmcgcHJvcGVydHlOYW1lIDogdGhpcy5wcm9wZXJ0eU5hbWVzKSB7Ci0JCQlpdGVtLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIocHJvcGVydHlOYW1lLCB0aGlzLml0ZW1Qcm9wZXJ0eUxpc3RlbmVyKTsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0l0ZW1TdGF0ZUxpc3RWYWx1ZU1vZGVsQWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0l0ZW1TdGF0ZUxpc3RWYWx1ZU1vZGVsQWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0NmQ3ZDg2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9JdGVtU3RhdGVMaXN0VmFsdWVNb2RlbEFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDc0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5Nb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5TdGF0ZUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlN0YXRlQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci0KLS8qKgotICogRXh0ZW5kIEl0ZW1Bc3BlY3RMaXN0VmFsdWVNb2RlbEFkYXB0ZXIgdG8gbGlzdGVuIHRvIHRoZQotICogInN0YXRlIiBvZiBlYWNoIGl0ZW0gaW4gdGhlIHdyYXBwZWQgbGlzdCBtb2RlbC4KLSAqLwotcHVibGljIGNsYXNzIEl0ZW1TdGF0ZUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFPgotCWV4dGVuZHMgSXRlbUFzcGVjdExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFPgotewotCS8qKiBMaXN0ZW5lciB0aGF0IGxpc3RlbnMgdG8gYWxsIHRoZSBpdGVtcyBpbiB0aGUgbGlzdC4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgU3RhdGVDaGFuZ2VMaXN0ZW5lciBpdGVtU3RhdGVMaXN0ZW5lcjsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGFkYXB0ZXIgZm9yIHRoZSBpdGVtIHN0YXRlLgotCSAqLwotCXB1YmxpYyBJdGVtU3RhdGVMaXN0VmFsdWVNb2RlbEFkYXB0ZXIoTGlzdFZhbHVlTW9kZWw8RT4gbGlzdEhvbGRlcikgewotCQlzdXBlcihsaXN0SG9sZGVyKTsKLQkJdGhpcy5pdGVtU3RhdGVMaXN0ZW5lciA9IHRoaXMuYnVpbGRJdGVtU3RhdGVMaXN0ZW5lcigpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBhZGFwdGVyIGZvciB0aGUgaXRlbSBzdGF0ZS4KLQkgKi8KLQlwdWJsaWMgSXRlbVN0YXRlTGlzdFZhbHVlTW9kZWxBZGFwdGVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsPEU+IGNvbGxlY3Rpb25Ib2xkZXIpIHsKLQkJdGhpcyhuZXcgQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFPihjb2xsZWN0aW9uSG9sZGVyKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCXByb3RlY3RlZCBTdGF0ZUNoYW5nZUxpc3RlbmVyIGJ1aWxkSXRlbVN0YXRlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgU3RhdGVDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHN0YXRlQ2hhbmdlZChTdGF0ZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJSXRlbVN0YXRlTGlzdFZhbHVlTW9kZWxBZGFwdGVyLnRoaXMuaXRlbUFzcGVjdENoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiaXRlbSBzdGF0ZSBsaXN0ZW5lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzdGFydExpc3RlbmluZ1RvSXRlbShNb2RlbCBpdGVtKSB7Ci0JCWl0ZW0uYWRkU3RhdGVDaGFuZ2VMaXN0ZW5lcih0aGlzLml0ZW1TdGF0ZUxpc3RlbmVyKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzdG9wTGlzdGVuaW5nVG9JdGVtKE1vZGVsIGl0ZW0pIHsKLQkJaXRlbS5yZW1vdmVTdGF0ZUNoYW5nZUxpc3RlbmVyKHRoaXMuaXRlbVN0YXRlTGlzdGVuZXIpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0l0ZW1UcmVlTGlzdFZhbHVlTW9kZWxBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvSXRlbVRyZWVMaXN0VmFsdWVNb2RlbEFkYXB0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNGUzOWY2ZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvSXRlbVRyZWVMaXN0VmFsdWVNb2RlbEFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDk3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLk1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlRyZWVDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5UcmVlQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci0KLS8qKgotICogRXh0ZW5kIEl0ZW1Bc3BlY3RMaXN0VmFsdWVNb2RlbEFkYXB0ZXIgdG8gbGlzdGVuIHRvIG9uZSBvciBtb3JlIHRyZWUKLSAqIGFzcGVjdHMgb2YgZWFjaCBpdGVtIGluIHRoZSB3cmFwcGVkIGxpc3QgbW9kZWwuCi0gKi8KLXB1YmxpYyBjbGFzcyBJdGVtVHJlZUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFPgotCWV4dGVuZHMgSXRlbUFzcGVjdExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFPgotewotCi0JLyoqIFRoZSBuYW1lcyBvZiB0aGUgaXRlbXMnIHRyZWUgdGhhdCB3ZSBsaXN0ZW4gdG8uICovCi0JcHJvdGVjdGVkIGZpbmFsIFN0cmluZ1tdIHRyZWVOYW1lczsKLQotCS8qKiBMaXN0ZW5lciB0aGF0IGxpc3RlbnMgdG8gYWxsIHRoZSBpdGVtcyBpbiB0aGUgbGlzdC4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgVHJlZUNoYW5nZUxpc3RlbmVyIGl0ZW1UcmVlTGlzdGVuZXI7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBhZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIGl0ZW0gdHJlZXMuCi0JICovCi0JcHVibGljIEl0ZW1UcmVlTGlzdFZhbHVlTW9kZWxBZGFwdGVyKExpc3RWYWx1ZU1vZGVsPEU+IGxpc3RIb2xkZXIsIFN0cmluZy4uLiB0cmVlTmFtZXMpIHsKLQkJc3VwZXIobGlzdEhvbGRlcik7Ci0JCXRoaXMudHJlZU5hbWVzID0gdHJlZU5hbWVzOwotCQl0aGlzLml0ZW1UcmVlTGlzdGVuZXIgPSB0aGlzLmJ1aWxkSXRlbVRyZWVMaXN0ZW5lcigpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBhZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIGl0ZW0gdHJlZXMuCi0JICovCi0JcHVibGljIEl0ZW1UcmVlTGlzdFZhbHVlTW9kZWxBZGFwdGVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsPEU+IGNvbGxlY3Rpb25Ib2xkZXIsIFN0cmluZy4uLiB0cmVlTmFtZXMpIHsKLQkJdGhpcyhuZXcgQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFPihjb2xsZWN0aW9uSG9sZGVyKSwgdHJlZU5hbWVzKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JLyoqCi0JICogQWxsIHdlIHJlYWxseSBjYXJlIGFib3V0IGlzIHRoZSBmYWN0IHRoYXQgYSB0cmVlIGFzcGVjdCBoYXMgCi0JICogY2hhbmdlZC4gIERvIHRoZSBzYW1lIHRoaW5nIG5vIG1hdHRlciB3aGljaCBldmVudCBvY2N1cnMuCi0JICovCi0JcHJvdGVjdGVkIFRyZWVDaGFuZ2VMaXN0ZW5lciBidWlsZEl0ZW1UcmVlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJlZUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgbm9kZUFkZGVkKFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUl0ZW1UcmVlTGlzdFZhbHVlTW9kZWxBZGFwdGVyLnRoaXMuaXRlbUFzcGVjdENoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgbm9kZVJlbW92ZWQoVHJlZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJSXRlbVRyZWVMaXN0VmFsdWVNb2RlbEFkYXB0ZXIudGhpcy5pdGVtQXNwZWN0Q2hhbmdlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCB0cmVlQ2xlYXJlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlJdGVtVHJlZUxpc3RWYWx1ZU1vZGVsQWRhcHRlci50aGlzLml0ZW1Bc3BlY3RDaGFuZ2VkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIHRyZWVDaGFuZ2VkKFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUl0ZW1UcmVlTGlzdFZhbHVlTW9kZWxBZGFwdGVyLnRoaXMuaXRlbUFzcGVjdENoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiaXRlbSB0cmVlIGxpc3RlbmVyOiAiICsgQXJyYXlzLmFzTGlzdChJdGVtVHJlZUxpc3RWYWx1ZU1vZGVsQWRhcHRlci50aGlzLnRyZWVOYW1lcyk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHN0YXJ0TGlzdGVuaW5nVG9JdGVtKE1vZGVsIGl0ZW0pIHsKLQkJZm9yIChTdHJpbmcgdHJlZU5hbWUgOiB0aGlzLnRyZWVOYW1lcykgewotCQkJaXRlbS5hZGRUcmVlQ2hhbmdlTGlzdGVuZXIodHJlZU5hbWUsIHRoaXMuaXRlbVRyZWVMaXN0ZW5lcik7Ci0JCX0KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzdG9wTGlzdGVuaW5nVG9JdGVtKE1vZGVsIGl0ZW0pIHsKLQkJZm9yIChTdHJpbmcgdHJlZU5hbWUgOiB0aGlzLnRyZWVOYW1lcykgewotCQkJaXRlbS5yZW1vdmVUcmVlQ2hhbmdlTGlzdGVuZXIodHJlZU5hbWUsIHRoaXMuaXRlbVRyZWVMaXN0ZW5lcik7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9MaXN0QXNwZWN0QWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0xpc3RBc3BlY3RBZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGI4YWRhYWEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0xpc3RBc3BlY3RBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyODcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheXM7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5FbXB0eUxpc3RJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5Nb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5MaXN0Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuTGlzdENoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBUaGlzIGV4dGVuc2lvbiBvZiBBc3BlY3RBZGFwdGVyIHByb3ZpZGVzIExpc3RDaGFuZ2Ugc3VwcG9ydC4KLSAqIFRoaXMgYWxsb3dzIHVzIHRvIGNvbnZlcnQgYSBzZXQgb2Ygb25lIG9yIG1vcmUgY29sbGVjdGlvbnMgaW50bwotICogYSBzaW5nbGUgY29sbGVjdGlvbiwgTElTVF9WQUxVRVMuCi0gKiAKLSAqIFRoZSB0eXBpY2FsIHN1YmNsYXNzIHdpbGwgb3ZlcnJpZGUgdGhlIGZvbGxvd2luZyBtZXRob2RzOgotICogI2xpc3RJdGVyYXRvcl8oKQotICogICAgIGF0IHRoZSB2ZXJ5IG1pbmltdW0sIG92ZXJyaWRlIHRoaXMgbWV0aG9kIHRvIHJldHVybiBhIGxpc3QgaXRlcmF0b3IKLSAqICAgICBvbiB0aGUgc3ViamVjdCdzIGxpc3QgYXNwZWN0OyBpdCBkb2VzIG5vdCBuZWVkIHRvIGJlIG92ZXJyaWRkZW4gaWYKLSAqICAgICAjbGlzdEl0ZXJhdG9yKCkgaXMgb3ZlcnJpZGRlbiBhbmQgaXRzIGJlaGF2aW9yIGNoYW5nZWQKLSAqICNnZXQoaW50KQotICogICAgIG92ZXJyaWRlIHRoaXMgbWV0aG9kIHRvIGltcHJvdmUgcGVyZm9ybWFuY2UKLSAqICNzaXplXygpCi0gKiAgICAgb3ZlcnJpZGUgdGhpcyBtZXRob2QgdG8gaW1wcm92ZSBwZXJmb3JtYW5jZTsgaXQgZG9lcyBub3QgbmVlZCB0byBiZSBvdmVycmlkZGVuIGlmCi0gKiAgICAgI3NpemUoKSBpcyBvdmVycmlkZGVuIGFuZCBpdHMgYmVoYXZpb3IgY2hhbmdlZAotICogI2xpc3RJdGVyYXRvcigpCi0gKiAgICAgb3ZlcnJpZGUgdGhpcyBtZXRob2Qgb25seSBpZiByZXR1cm5pbmcgYW4gZW1wdHkgbGlzdCBpdGVyYXRvciB3aGVuIHRoZQotICogICAgIHN1YmplY3QgaXMgbnVsbCBpcyB1bmFjY2VwdGFibGUKLSAqICNzaXplKCkKLSAqICAgICBvdmVycmlkZSB0aGlzIG1ldGhvZCBvbmx5IGlmIHJldHVybmluZyBhIHplcm8gd2hlbiB0aGUKLSAqICAgICBzdWJqZWN0IGlzIG51bGwgaXMgdW5hY2NlcHRhYmxlCi0gKi8KLXB1YmxpYyBhYnN0cmFjdCBjbGFzcyBMaXN0QXNwZWN0QWRhcHRlcjxTIGV4dGVuZHMgTW9kZWwsIEU+Ci0JZXh0ZW5kcyBBc3BlY3RBZGFwdGVyPFM+Ci0JaW1wbGVtZW50cyBMaXN0VmFsdWVNb2RlbDxFPgotewotCS8qKgotCSAqIFRoZSBuYW1lIG9mIHRoZSBzdWJqZWN0J3MgbGlzdHMgdGhhdCB3ZSB1c2UgZm9yIHRoZSB2YWx1ZS4KLQkgKi8KLQlwcm90ZWN0ZWQgZmluYWwgU3RyaW5nW10gbGlzdE5hbWVzOwotCQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIFN0cmluZ1tdIEVNUFRZX0xJU1RfTkFNRVMgPSBuZXcgU3RyaW5nWzBdOwotCi0JLyoqIEEgbGlzdGVuZXIgdGhhdCBsaXN0ZW5zIHRvIHRoZSBzdWJqZWN0J3MgbGlzdCBhc3BlY3QuICovCi0JcHJvdGVjdGVkIGZpbmFsIExpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0Q2hhbmdlTGlzdGVuZXI7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBPYmplY3RbXSBFTVBUWV9BUlJBWSA9IG5ldyBPYmplY3RbMF07Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIExpc3RBc3BlY3RBZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIHN1YmplY3QKLQkgKiBhbmQgbGlzdC4KLQkgKi8KLQlwcm90ZWN0ZWQgTGlzdEFzcGVjdEFkYXB0ZXIoU3RyaW5nIGxpc3ROYW1lLCBTIHN1YmplY3QpIHsKLQkJdGhpcyhuZXcgU3RyaW5nW10ge2xpc3ROYW1lfSwgc3ViamVjdCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgTGlzdEFzcGVjdEFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgc3ViamVjdAotCSAqIGFuZCBsaXN0cy4KLQkgKi8KLQlwcm90ZWN0ZWQgTGlzdEFzcGVjdEFkYXB0ZXIoU3RyaW5nW10gbGlzdE5hbWVzLCBTIHN1YmplY3QpIHsKLQkJdGhpcyhuZXcgU3RhdGljUHJvcGVydHlWYWx1ZU1vZGVsPFM+KHN1YmplY3QpLCBsaXN0TmFtZXMpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIExpc3RBc3BlY3RBZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIHN1YmplY3QgaG9sZGVyCi0JICogYW5kIGxpc3RzLgotCSAqLwotCXByb3RlY3RlZCBMaXN0QXNwZWN0QWRhcHRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFM+IHN1YmplY3RIb2xkZXIsIFN0cmluZy4uLiBsaXN0TmFtZXMpIHsKLQkJc3VwZXIoc3ViamVjdEhvbGRlcik7Ci0JCXRoaXMubGlzdE5hbWVzID0gbGlzdE5hbWVzOwotCQl0aGlzLmxpc3RDaGFuZ2VMaXN0ZW5lciA9IHRoaXMuYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXIoKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBMaXN0QXNwZWN0QWRhcHRlciBmb3IgdGhlIHNwZWNpZmllZCBzdWJqZWN0IGhvbGRlcgotCSAqIGFuZCBsaXN0cy4KLQkgKi8KLQlwcm90ZWN0ZWQgTGlzdEFzcGVjdEFkYXB0ZXIoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBTPiBzdWJqZWN0SG9sZGVyLCBDb2xsZWN0aW9uPFN0cmluZz4gbGlzdE5hbWVzKSB7Ci0JCXRoaXMoc3ViamVjdEhvbGRlciwgbGlzdE5hbWVzLnRvQXJyYXkobmV3IFN0cmluZ1tsaXN0TmFtZXMuc2l6ZSgpXSkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIExpc3RBc3BlY3RBZGFwdGVyIGZvciBhbiAidW5jaGFuZ2luZyIgbGlzdCBpbgotCSAqIHRoZSBzcGVjaWZpZWQgc3ViamVjdC4gVGhpcyBpcyB1c2VmdWwgZm9yIGEgbGlzdCBhc3BlY3QgdGhhdCBkb2VzIG5vdAotCSAqIGNoYW5nZSBmb3IgYSBwYXJ0aWN1bGFyIHN1YmplY3Q7IGJ1dCB0aGUgc3ViamVjdCB3aWxsIGNoYW5nZSwgcmVzdWx0aW5nIGluCi0JICogYSBuZXcgbGlzdC4KLQkgKi8KLQlwcm90ZWN0ZWQgTGlzdEFzcGVjdEFkYXB0ZXIoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBTPiBzdWJqZWN0SG9sZGVyKSB7Ci0JCXRoaXMoc3ViamVjdEhvbGRlciwgRU1QVFlfTElTVF9OQU1FUyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIFRoZSBzdWJqZWN0J3MgbGlzdCBhc3BlY3QgaGFzIGNoYW5nZWQsIG5vdGlmeSB0aGUgbGlzdGVuZXJzLgotCSAqLwotCXByb3RlY3RlZCBMaXN0Q2hhbmdlTGlzdGVuZXIgYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCS8vIHRyYW5zZm9ybSB0aGUgc3ViamVjdCdzIGxpc3QgY2hhbmdlIGV2ZW50cyBpbnRvIFZBTFVFIGxpc3QgY2hhbmdlIGV2ZW50cwotCQlyZXR1cm4gbmV3IExpc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJTGlzdEFzcGVjdEFkYXB0ZXIudGhpcy5pdGVtc0FkZGVkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlMaXN0QXNwZWN0QWRhcHRlci50aGlzLml0ZW1zUmVtb3ZlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc1JlcGxhY2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUxpc3RBc3BlY3RBZGFwdGVyLnRoaXMuaXRlbXNSZXBsYWNlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc01vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUxpc3RBc3BlY3RBZGFwdGVyLnRoaXMuaXRlbXNNb3ZlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlMaXN0QXNwZWN0QWRhcHRlci50aGlzLmxpc3RDbGVhcmVkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGxpc3RDaGFuZ2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUxpc3RBc3BlY3RBZGFwdGVyLnRoaXMubGlzdENoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAibGlzdCBjaGFuZ2UgbGlzdGVuZXI6ICIgKyBBcnJheXMuYXNMaXN0KExpc3RBc3BlY3RBZGFwdGVyLnRoaXMubGlzdE5hbWVzKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogTGlzdFZhbHVlTW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBlbGVtZW50cyBvZiB0aGUgc3ViamVjdCdzIGxpc3QgYXNwZWN0LgotCSAqLwotCXB1YmxpYyBJdGVyYXRvcjxFPiBpdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMubGlzdEl0ZXJhdG9yKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBlbGVtZW50cyBvZiB0aGUgc3ViamVjdCdzIGxpc3QgYXNwZWN0LgotCSAqLwotCXB1YmxpYyBMaXN0SXRlcmF0b3I8RT4gbGlzdEl0ZXJhdG9yKCkgewotCQlyZXR1cm4gKHRoaXMuc3ViamVjdCA9PSBudWxsKSA/IEVtcHR5TGlzdEl0ZXJhdG9yLjxFPmluc3RhbmNlKCkgOiB0aGlzLmxpc3RJdGVyYXRvcl8oKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGVsZW1lbnRzIG9mIHRoZSBzdWJqZWN0J3MgbGlzdCBhc3BlY3QuCi0JICogQXQgdGhpcyBwb2ludCB3ZSBjYW4gYmUgc3VyZSB0aGF0IHRoZSBzdWJqZWN0IGlzIG5vdCBudWxsLgotCSAqIEBzZWUgI2xpc3RJdGVyYXRvcigpCi0JICovCi0JcHJvdGVjdGVkIExpc3RJdGVyYXRvcjxFPiBsaXN0SXRlcmF0b3JfKCkgewotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGVsZW1lbnQgYXQgdGhlIHNwZWNpZmllZCBpbmRleCBvZiB0aGUgc3ViamVjdCdzIGxpc3QgYXNwZWN0LgotCSAqLwotCXB1YmxpYyBFIGdldChpbnQgaW5kZXgpIHsKLQkJcmV0dXJuIENvbGxlY3Rpb25Ub29scy5nZXQodGhpcy5saXN0SXRlcmF0b3IoKSwgaW5kZXgpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2l6ZSBvZiB0aGUgc3ViamVjdCdzIGxpc3QgYXNwZWN0LgotCSAqLwotCXB1YmxpYyBpbnQgc2l6ZSgpIHsKLQkJcmV0dXJuIHRoaXMuc3ViamVjdCA9PSBudWxsID8gMCA6IHRoaXMuc2l6ZV8oKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpemUgb2YgdGhlIHN1YmplY3QncyBsaXN0IGFzcGVjdC4KLQkgKiBBdCB0aGlzIHBvaW50IHdlIGNhbiBiZSBzdXJlIHRoYXQgdGhlIHN1YmplY3QgaXMgbm90IG51bGwuCi0JICogQHNlZSAjc2l6ZSgpCi0JICovCi0JcHJvdGVjdGVkIGludCBzaXplXygpIHsKLQkJcmV0dXJuIENvbGxlY3Rpb25Ub29scy5zaXplKHRoaXMubGlzdEl0ZXJhdG9yKCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhbiBhcnJheSBtYW5pZmVzdGF0aW9uIG9mIHRoZSBzdWJqZWN0J3MgbGlzdCBhc3BlY3QuCi0JICovCi0JcHVibGljIE9iamVjdFtdIHRvQXJyYXkoKSB7Ci0JCXJldHVybiB0aGlzLnN1YmplY3QgPT0gbnVsbCA/IEVNUFRZX0FSUkFZIDogdGhpcy50b0FycmF5XygpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhbiBhcnJheSBtYW5pZmVzdGF0aW9uIG9mIHRoZSBzdWJqZWN0J3MgbGlzdCBhc3BlY3QuCi0JICogQXQgdGhpcyBwb2ludCB3ZSBjYW4gYmUgc3VyZSB0aGF0IHRoZSBzdWJqZWN0IGlzIG5vdCBudWxsLgotCSAqIEBzZWUgI3RvQXJyYXkoKQotCSAqLwotCXByb3RlY3RlZCBPYmplY3RbXSB0b0FycmF5XygpIHsKLQkJcmV0dXJuIENvbGxlY3Rpb25Ub29scy5hcnJheSh0aGlzLmxpc3RJdGVyYXRvcigpLCB0aGlzLnNpemUoKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIEFzcGVjdEFkYXB0ZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIE9iamVjdCBnZXRWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMuaXRlcmF0b3IoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgQ2xhc3M8PyBleHRlbmRzIENoYW5nZUxpc3RlbmVyPiBnZXRMaXN0ZW5lckNsYXNzKCkgewotCQlyZXR1cm4gTGlzdENoYW5nZUxpc3RlbmVyLmNsYXNzOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0TGlzdGVuZXJBc3BlY3ROYW1lKCkgewotCQlyZXR1cm4gTElTVF9WQUxVRVM7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIGJvb2xlYW4gaGFzTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gdGhpcy5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExJU1RfVkFMVUVTKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBmaXJlQXNwZWN0Q2hhbmdlKE9iamVjdCBvbGRWYWx1ZSwgT2JqZWN0IG5ld1ZhbHVlKSB7Ci0JCXRoaXMuZmlyZUxpc3RDaGFuZ2VkKExJU1RfVkFMVUVTKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VTdWJqZWN0XygpIHsKLSAgICAJZm9yIChTdHJpbmcgbGlzdE5hbWUgOiB0aGlzLmxpc3ROYW1lcykgewotCQkJKChNb2RlbCkgdGhpcy5zdWJqZWN0KS5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIobGlzdE5hbWUsIHRoaXMubGlzdENoYW5nZUxpc3RlbmVyKTsKLQkJfQotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZVN1YmplY3RfKCkgewotICAgIAlmb3IgKFN0cmluZyBsaXN0TmFtZSA6IHRoaXMubGlzdE5hbWVzKSB7Ci0JCQkoKE1vZGVsKSB0aGlzLnN1YmplY3QpLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihsaXN0TmFtZSwgdGhpcy5saXN0Q2hhbmdlTGlzdGVuZXIpOwotCQl9Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgdG9TdHJpbmcoU3RyaW5nQnVpbGRlciBzYikgewotCQlmb3IgKGludCBpID0gMDsgaSA8IHRoaXMubGlzdE5hbWVzLmxlbmd0aDsgaSsrKSB7Ci0JCQlpZiAoaSAhPSAwKSB7Ci0JCQkJc2IuYXBwZW5kKCIsICIpOwotCQkJfQotCQkJc2IuYXBwZW5kKHRoaXMubGlzdE5hbWVzW2ldKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQlwcm90ZWN0ZWQgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmZpcmVJdGVtc0FkZGVkKGV2ZW50LmNsb25lV2l0aFNvdXJjZSh0aGlzLCBMSVNUX1ZBTFVFUykpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5maXJlSXRlbXNSZW1vdmVkKGV2ZW50LmNsb25lV2l0aFNvdXJjZSh0aGlzLCBMSVNUX1ZBTFVFUykpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuZmlyZUl0ZW1zUmVwbGFjZWQoZXZlbnQuY2xvbmVXaXRoU291cmNlKHRoaXMsIExJU1RfVkFMVUVTKSk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNNb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5maXJlSXRlbXNNb3ZlZChldmVudC5jbG9uZVdpdGhTb3VyY2UodGhpcywgTElTVF9WQUxVRVMpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5maXJlTGlzdENsZWFyZWQoTElTVF9WQUxVRVMpOyAgLy8gbm90aGluZyBmcm9tIG9yaWdpbmFsIGV2ZW50IHRvIGZvcndhcmQKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBsaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5maXJlTGlzdENoYW5nZWQoTElTVF9WQUxVRVMpOyAgLy8gbm90aGluZyBmcm9tIG9yaWdpbmFsIGV2ZW50IHRvIGZvcndhcmQKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9MaXN0Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvTGlzdENvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkYzhhN2FhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9MaXN0Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzMDAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlJlYWRPbmx5SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5DaGFuZ2VTdXBwb3J0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLlNpbmdsZUFzcGVjdENoYW5nZVN1cHBvcnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuTGlzdENoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5MaXN0Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci0KLS8qKgotICogQW4gYWRhcHRlciB0aGF0IGFsbG93cyB1cyB0byBtYWtlIGEgTGlzdFZhbHVlTW9kZWwgYmVoYXZlIGxpa2UKLSAqIGEgcmVhZC1vbmx5IENvbGxlY3Rpb25WYWx1ZU1vZGVsLCBzb3J0YS4KLSAqIAotICogV2Uga2VlcCBhbiBpbnRlcm5hbCBjb2xsZWN0aW9uIHNvbWV3aGF0IGluIHN5bmNoIHdpdGggdGhlIHdyYXBwZWQgbGlzdC4KLSAqIAotICogTkI6IFNpbmNlIHdlIG9ubHkgbGlzdGVuIHRvIHRoZSB3cmFwcGVkIGxpc3Qgd2hlbiB3ZSBoYXZlCi0gKiBsaXN0ZW5lcnMgb3Vyc2VsdmVzIGFuZCB3ZSBjYW4gb25seSBzdGF5IGluIHN5bmNoIHdpdGggdGhlIHdyYXBwZWQKLSAqIGxpc3Qgd2hpbGUgd2UgYXJlIGxpc3RlbmluZyB0byBpdCwgcmVzdWx0cyB0byB2YXJpb3VzIG1ldGhvZHMKLSAqIChlLmcuICNzaXplKCksIHZhbHVlKCkpIHdpbGwgYmUgdW5wcmVkaWN0YWJsZSB3aGVuZXZlcgotICogd2UgZG8gbm90IGhhdmUgYW55IGxpc3RlbmVycy4gVGhpcyBzaG91bGQgbm90IGJlIHRvbyBwYWluZnVsIHNpbmNlLAotICogbW9zdCBsaWtlbHksIGNsaWVudCBvYmplY3RzIHdpbGwgYWxzbyBiZSBsaXN0ZW5lcnMuCi0gKi8KLXB1YmxpYyBjbGFzcyBMaXN0Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyPEU+Ci0JZXh0ZW5kcyBBYnN0cmFjdE1vZGVsCi0JaW1wbGVtZW50cyBDb2xsZWN0aW9uVmFsdWVNb2RlbDxFPgotewotCS8qKiBUaGUgd3JhcHBlZCBsaXN0IHZhbHVlIG1vZGVsLiAqLwotCXByb3RlY3RlZCBmaW5hbCBMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gbGlzdEhvbGRlcjsKLQotCS8qKiBBIGxpc3RlbmVyIHRoYXQgZm9yd2FyZHMgYW55IGV2ZW50cyBmaXJlZCBieSB0aGUgbGlzdCBob2xkZXIuICovCi0JcHJvdGVjdGVkIGZpbmFsIExpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0Q2hhbmdlTGlzdGVuZXI7Ci0KLQkvKioKLQkgKiBPdXIgaW50ZXJuYWwgY29sbGVjdGlvbiwgd2hpY2ggaG9sZHMgdGhlIHNhbWUgZWxlbWVudHMgYXMKLQkgKiB0aGUgd3JhcHBlZCBsaXN0LgotCSAqLwotCS8vIHdlIGRlY2xhcmUgdGhpcyBhbiBBcnJheUxpc3Qgc28gd2UgY2FuIHVzZSAjY2xvbmUoKSBhbmQgI2Vuc3VyZUNhcGFjaXR5KGludCkKLQlwcm90ZWN0ZWQgZmluYWwgQXJyYXlMaXN0PEU+IGNvbGxlY3Rpb247Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIFdyYXAgdGhlIHNwZWNpZmllZCBMaXN0VmFsdWVNb2RlbC4KLQkgKi8KLQlwdWJsaWMgTGlzdENvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlcihMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gbGlzdEhvbGRlcikgewotCQlzdXBlcigpOwotCQlpZiAobGlzdEhvbGRlciA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLmxpc3RIb2xkZXIgPSBsaXN0SG9sZGVyOwotCQl0aGlzLmxpc3RDaGFuZ2VMaXN0ZW5lciA9IHRoaXMuYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXIoKTsKLQkJdGhpcy5jb2xsZWN0aW9uID0gbmV3IEFycmF5TGlzdDxFPigpOwotCQkvLyBwb3N0cG9uZSBidWlsZGluZyB0aGUgY29sbGVjdGlvbiBhbmQgbGlzdGVuaW5nIHRvIHRoZSB1bmRlcmx5aW5nIGxpc3QKLQkJLy8gdW50aWwgd2UgaGF2ZSBsaXN0ZW5lcnMgb3Vyc2VsdmVzLi4uCi0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIENoYW5nZVN1cHBvcnQgYnVpbGRDaGFuZ2VTdXBwb3J0KCkgewotCQlyZXR1cm4gbmV3IFNpbmdsZUFzcGVjdENoYW5nZVN1cHBvcnQodGhpcywgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyLmNsYXNzLCBWQUxVRVMpOwotCX0KLQotCS8qKgotCSAqIFRoZSB3cmFwcGVkIGxpc3QgaGFzIGNoYW5nZWQsIGZvcndhcmQgYW4gZXF1aXZhbGVudAotCSAqIGNvbGxlY3Rpb24gY2hhbmdlIGV2ZW50IHRvIG91ciBsaXN0ZW5lcnMuCi0JICovCi0JcHJvdGVjdGVkIExpc3RDaGFuZ2VMaXN0ZW5lciBidWlsZExpc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBMaXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUxpc3RDb2xsZWN0aW9uVmFsdWVNb2RlbEFkYXB0ZXIudGhpcy5pdGVtc0FkZGVkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlMaXN0Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyLnRoaXMuaXRlbXNSZW1vdmVkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJTGlzdENvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlci50aGlzLml0ZW1zUmVwbGFjZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNNb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlMaXN0Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyLnRoaXMuaXRlbXNNb3ZlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlMaXN0Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyLnRoaXMubGlzdENsZWFyZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgbGlzdENoYW5nZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJTGlzdENvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlci50aGlzLmxpc3RDaGFuZ2VkKGV2ZW50KTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gImxpc3QgY2hhbmdlIGxpc3RlbmVyIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogQ29sbGVjdGlvblZhbHVlTW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIEl0ZXJhdG9yPEU+IGl0ZXJhdG9yKCkgewotCQkvLyB0cnkgdG8gcHJldmVudCBiYWNrZG9vciBtb2RpZmljYXRpb24gb2YgdGhlIGxpc3QKLQkJcmV0dXJuIG5ldyBSZWFkT25seUl0ZXJhdG9yPEU+KHRoaXMuY29sbGVjdGlvbik7Ci0JfQotCi0JcHVibGljIGludCBzaXplKCkgewotCQlyZXR1cm4gdGhpcy5jb2xsZWN0aW9uLnNpemUoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogZXh0ZW5kIGNoYW5nZSBzdXBwb3J0ICoqKioqKioqKioKLQotCS8qKgotCSAqIE92ZXJyaWRlIHRvIHN0YXJ0IGxpc3RlbmluZyB0byB0aGUgbGlzdCBob2xkZXIgaWYgbmVjZXNzYXJ5LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJaWYgKHRoaXMuaGFzTm9MaXN0ZW5lcnMoKSkgewotCQkJdGhpcy5lbmdhZ2VNb2RlbCgpOwotCQl9Ci0JCXN1cGVyLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogT3ZlcnJpZGUgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSBsaXN0IGhvbGRlciBpZiBuZWNlc3NhcnkuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKFN0cmluZyBjb2xsZWN0aW9uTmFtZSwgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCWlmIChjb2xsZWN0aW9uTmFtZSA9PSBWQUxVRVMgJiYgdGhpcy5oYXNOb0xpc3RlbmVycygpKSB7Ci0JCQl0aGlzLmVuZ2FnZU1vZGVsKCk7Ci0JCX0KLQkJc3VwZXIuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKGNvbGxlY3Rpb25OYW1lLCBsaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogT3ZlcnJpZGUgdG8gc3RvcCBsaXN0ZW5pbmcgdG8gdGhlIGxpc3QgaG9sZGVyIGlmIGFwcHJvcHJpYXRlLgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJc3VwZXIucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJaWYgKHRoaXMuaGFzTm9MaXN0ZW5lcnMoKSkgewotCQkJdGhpcy5kaXNlbmdhZ2VNb2RlbCgpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogT3ZlcnJpZGUgdG8gc3RvcCBsaXN0ZW5pbmcgdG8gdGhlIGxpc3QgaG9sZGVyIGlmIGFwcHJvcHJpYXRlLgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihTdHJpbmcgY29sbGVjdGlvbk5hbWUsIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlzdXBlci5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoY29sbGVjdGlvbk5hbWUsIGxpc3RlbmVyKTsKLQkJaWYgKGNvbGxlY3Rpb25OYW1lID09IFZBTFVFUyAmJiB0aGlzLmhhc05vTGlzdGVuZXJzKCkpIHsKLQkJCXRoaXMuZGlzZW5nYWdlTW9kZWwoKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBxdWVyaWVzICoqKioqKioqKioKLQotCXByb3RlY3RlZCBib29sZWFuIGhhc0xpc3RlbmVycygpIHsKLQkJcmV0dXJuIHRoaXMuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhWQUxVRVMpOwotCX0KLQotCXByb3RlY3RlZCBib29sZWFuIGhhc05vTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gISB0aGlzLmhhc0xpc3RlbmVycygpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaW5kZXggb2YgdGhlIHNwZWNpZmllZCBpdGVtLCB1c2luZyBvYmplY3QKLQkgKiBpZGVudGl0eSBpbnN0ZWFkIG9mIGVxdWFsaXR5LgotCSAqLwotCXByb3RlY3RlZCBpbnQgbGFzdElkZW50aXR5SW5kZXhPZihPYmplY3QgbykgewotCQlyZXR1cm4gdGhpcy5sYXN0SWRlbnRpdHlJbmRleE9mKG8sIHRoaXMuY29sbGVjdGlvbi5zaXplKCkpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIGxhc3QgaW5kZXggb2YgdGhlIHNwZWNpZmllZCBpdGVtLCBzdGFydGluZyBqdXN0IGJlZm9yZSB0aGUKLQkgKiB0aGUgc3BlY2lmaWVkIGVuZHBvaW50LCBhbmQgdXNpbmcgb2JqZWN0IGlkZW50aXR5IGluc3RlYWQgb2YgZXF1YWxpdHkuCi0JICovCi0JcHJvdGVjdGVkIGludCBsYXN0SWRlbnRpdHlJbmRleE9mKE9iamVjdCBvLCBpbnQgZW5kKSB7Ci0JCWZvciAoaW50IGkgPSBlbmQ7IGktLSA+IDA7ICkgewotCQkJaWYgKHRoaXMuY29sbGVjdGlvbi5nZXQoaSkgPT0gbykgewotCQkJCXJldHVybiBpOwotCQkJfQotCQl9Ci0JCXJldHVybiAtMTsKLQl9Ci0JCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCXByb3RlY3RlZCB2b2lkIGJ1aWxkQ29sbGVjdGlvbigpIHsKLQkJSXRlcmF0b3I8PyBleHRlbmRzIEU+IHN0cmVhbSA9IHRoaXMubGlzdEhvbGRlci5pdGVyYXRvcigpOwotCQkvLyBpZiB0aGUgbmV3IGxpc3QgaXMgZW1wdHksIGRvIG5vdGhpbmcKLQkJaWYgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCXRoaXMuY29sbGVjdGlvbi5lbnN1cmVDYXBhY2l0eSh0aGlzLmxpc3RIb2xkZXIuc2l6ZSgpKTsKLQkJCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQkJdGhpcy5jb2xsZWN0aW9uLmFkZChzdHJlYW0ubmV4dCgpKTsKLQkJCX0KLQkJfQotCX0KLQotCXByb3RlY3RlZCB2b2lkIGVuZ2FnZU1vZGVsKCkgewotCQl0aGlzLmxpc3RIb2xkZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmxpc3RDaGFuZ2VMaXN0ZW5lcik7Ci0JCS8vIHN5bmNoIG91ciBjb2xsZWN0aW9uICphZnRlciogd2Ugc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSBsaXN0IGhvbGRlciwKLQkJLy8gc2luY2UgaXRzIHZhbHVlIG1pZ2h0IGNoYW5nZSB3aGVuIGEgbGlzdGVuZXIgaXMgYWRkZWQKLQkJdGhpcy5idWlsZENvbGxlY3Rpb24oKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VNb2RlbCgpIHsKLQkJdGhpcy5saXN0SG9sZGVyLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5saXN0Q2hhbmdlTGlzdGVuZXIpOwotCQkvLyBjbGVhciBvdXQgdGhlIGNvbGxlY3Rpb24gd2hlbiB3ZSBhcmUgbm90IGxpc3RlbmluZyB0byB0aGUgbGlzdCBob2xkZXIKLQkJdGhpcy5jb2xsZWN0aW9uLmNsZWFyKCk7Ci0JfQotCi0JLy8gbWluaW1pemUgc3VwcHJlc3NlZCB3YXJuaW5ncwotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByb3RlY3RlZCBMaXN0SXRlcmF0b3I8RT4gaXRlbXMoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXJldHVybiAoTGlzdEl0ZXJhdG9yPEU+KSBldmVudC5pdGVtcygpOwotCX0KLQotCS8vIG1pbmltaXplIHN1cHByZXNzZWQgd2FybmluZ3MKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcm90ZWN0ZWQgTGlzdEl0ZXJhdG9yPEU+IHJlcGxhY2VkSXRlbXMoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXJldHVybiAoTGlzdEl0ZXJhdG9yPEU+KSBldmVudC5yZXBsYWNlZEl0ZW1zKCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5hZGRJdGVtc1RvQ29sbGVjdGlvbih0aGlzLml0ZW1zKGV2ZW50KSwgdGhpcy5jb2xsZWN0aW9uLCBWQUxVRVMpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIHJlbW92ZUludGVybmFsSXRlbXMoSXRlcmF0b3I8RT4gaXRlbXMpIHsKLQkJLy8gd2UgaGF2ZSB0byByZW1vdmUgdGhlIGl0ZW1zIGluZGl2aWR1YWxseSwKLQkJLy8gc2luY2UgdGhleSBhcmUgcHJvYmFibHkgbm90IGluIHNlcXVlbmNlCi0JCXdoaWxlIChpdGVtcy5oYXNOZXh0KCkpIHsKLQkJCU9iamVjdCByZW1vdmVkSXRlbSA9IGl0ZW1zLm5leHQoKTsKLQkJCWludCBpbmRleCA9IHRoaXMubGFzdElkZW50aXR5SW5kZXhPZihyZW1vdmVkSXRlbSk7Ci0JCQl0aGlzLmNvbGxlY3Rpb24ucmVtb3ZlKGluZGV4KTsKLQkJCXRoaXMuZmlyZUl0ZW1SZW1vdmVkKFZBTFVFUywgcmVtb3ZlZEl0ZW0pOwotCQl9Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLnJlbW92ZUludGVybmFsSXRlbXModGhpcy5pdGVtcyhldmVudCkpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMucmVtb3ZlSW50ZXJuYWxJdGVtcyh0aGlzLnJlcGxhY2VkSXRlbXMoZXZlbnQpKTsKLQkJdGhpcy5hZGRJdGVtc1RvQ29sbGVjdGlvbih0aGlzLml0ZW1zKGV2ZW50KSwgdGhpcy5jb2xsZWN0aW9uLCBWQUxVRVMpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIGRvIG5vdGhpbmc/IG1vdmluZyBpdGVtcyBpbiBhIGxpc3QgaGFzIG5vIG5ldCBlZmZlY3Qgb24gYSBjb2xsZWN0aW9uLi4uCi0JfQotCi0JcHJvdGVjdGVkIHZvaWQgbGlzdENsZWFyZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIHB1dCBpbiBlbXB0eSBjaGVjayBzbyB3ZSBkb24ndCBmaXJlIGV2ZW50cyB1bm5lY2Vzc2FyaWx5Ci0JCWlmICggISB0aGlzLmNvbGxlY3Rpb24uaXNFbXB0eSgpKSB7Ci0JCQl0aGlzLmNvbGxlY3Rpb24uY2xlYXIoKTsKLQkJCXRoaXMuZmlyZUNvbGxlY3Rpb25DbGVhcmVkKFZBTFVFUyk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBzeW5jaHJvbml6ZSBvdXIgaW50ZXJuYWwgY29sbGVjdGlvbiB3aXRoIHRoZSB3cmFwcGVkIGxpc3QKLQkgKiBhbmQgZmlyZSB0aGUgYXBwcm9wcmlhdGUgZXZlbnRzCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgbGlzdENoYW5nZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIHB1dCBpbiBlbXB0eSBjaGVjayBzbyB3ZSBkb24ndCBmaXJlIGV2ZW50cyB1bm5lY2Vzc2FyaWx5Ci0JCWlmICggISB0aGlzLmNvbGxlY3Rpb24uaXNFbXB0eSgpKSB7Ci0JCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJCUFycmF5TGlzdDxFPiByZW1vdmVkSXRlbXMgPSAoQXJyYXlMaXN0PEU+KSB0aGlzLmNvbGxlY3Rpb24uY2xvbmUoKTsKLQkJCXRoaXMuY29sbGVjdGlvbi5jbGVhcigpOwotCQkJdGhpcy5maXJlSXRlbXNSZW1vdmVkKFZBTFVFUywgcmVtb3ZlZEl0ZW1zKTsKLQkJfQotCi0JCXRoaXMuYnVpbGRDb2xsZWN0aW9uKCk7Ci0JCS8vIHB1dCBpbiBlbXB0eSBjaGVjayBzbyB3ZSBkb24ndCBmaXJlIGV2ZW50cyB1bm5lY2Vzc2FyaWx5Ci0JCWlmICggISB0aGlzLmNvbGxlY3Rpb24uaXNFbXB0eSgpKSB7Ci0JCQl0aGlzLmZpcmVJdGVtc0FkZGVkKFZBTFVFUywgdGhpcy5jb2xsZWN0aW9uKTsKLQkJfQotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHRvU3RyaW5nKFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJc2IuYXBwZW5kKHRoaXMubGlzdEhvbGRlcik7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvTGlzdEN1cmF0b3IuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9MaXN0Q3VyYXRvci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmMDQ4MjFhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9MaXN0Q3VyYXRvci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjIwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuUmVhZE9ubHlMaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuU3RhdGVDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5MaXN0Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuU3RhdGVDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci0KLS8qKgotICogVGhpcyBleHRlbnNpb24gb2YgQXNwZWN0QWRhcHRlciBwcm92aWRlcyBMaXN0Q2hhbmdlIHN1cHBvcnQKLSAqIGJ5IGFkYXB0aW5nIGEgc3ViamVjdCdzIHN0YXRlIGNoYW5nZSBldmVudHMgdG8gYSBtaW5pbXVtIHNldAotICogb2YgbGlzdCBjaGFuZ2UgZXZlbnRzLgotICovCi1wdWJsaWMgYWJzdHJhY3QgY2xhc3MgTGlzdEN1cmF0b3I8UyBleHRlbmRzIE1vZGVsLCBFPgotCWV4dGVuZHMgQXNwZWN0QWRhcHRlcjxTPgotCWltcGxlbWVudHMgTGlzdFZhbHVlTW9kZWw8RT4KLXsKLQkvKiogSG93IHRoZSBsaXN0IGxvb2tlZCBiZWZvcmUgdGhlIGxhc3Qgc3RhdGUgY2hhbmdlICovCi0JcHJpdmF0ZSBmaW5hbCBBcnJheUxpc3Q8RT4gcmVjb3JkOwotCi0JLyoqIEEgbGlzdGVuZXIgdGhhdCBsaXN0ZW5zIGZvciB0aGUgc3ViamVjdCdzIHN0YXRlIHRvIGNoYW5nZSAqLwotCXByaXZhdGUgZmluYWwgU3RhdGVDaGFuZ2VMaXN0ZW5lciBzdGF0ZUNoYW5nZUxpc3RlbmVyOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBDdXJhdG9yIGZvciB0aGUgc3BlY2lmaWVkIHN1YmplY3QuCi0JICovCi0JcHJvdGVjdGVkIExpc3RDdXJhdG9yKFMgc3ViamVjdCkgewotCQl0aGlzKG5ldyBTdGF0aWNQcm9wZXJ0eVZhbHVlTW9kZWw8Uz4oc3ViamVjdCkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGN1cmF0b3IgZm9yIHRoZSBzcGVjaWZpZWQgc3ViamVjdCBob2xkZXIuCi0JICogVGhlIHN1YmplY3QgaG9sZGVyIGNhbm5vdCBiZSBudWxsLgotCSAqLwotCXByb3RlY3RlZCBMaXN0Q3VyYXRvcihQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFM+IHN1YmplY3RIb2xkZXIpIHsKLQkJc3VwZXIoc3ViamVjdEhvbGRlcik7Ci0JCXRoaXMucmVjb3JkID0gbmV3IEFycmF5TGlzdDxFPigpOwotCQl0aGlzLnN0YXRlQ2hhbmdlTGlzdGVuZXIgPSB0aGlzLmJ1aWxkU3RhdGVDaGFuZ2VMaXN0ZW5lcigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0KLQkvKioKLQkgKiBUaGUgc3ViamVjdCdzIHN0YXRlIGhhcyBjaGFuZ2VkLCBkbyBpbnZlbnRvcnkgYW5kIHJlcG9ydCB0byBsaXN0ZW5lcnMuCi0JICovCi0JcHJvdGVjdGVkIFN0YXRlQ2hhbmdlTGlzdGVuZXIgYnVpbGRTdGF0ZUNoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFN0YXRlQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoU3RhdGVDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUxpc3RDdXJhdG9yLnRoaXMuc3VibWl0SW52ZW50b3J5UmVwb3J0KCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJzdGF0ZSBjaGFuZ2UgbGlzdGVuZXIiOwotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBMaXN0VmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgSXRlcmF0b3I8RT4gaXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3RJdGVyYXRvcigpOwotCX0KLQotCXB1YmxpYyBMaXN0SXRlcmF0b3I8RT4gbGlzdEl0ZXJhdG9yKCkgewotCQlyZXR1cm4gbmV3IFJlYWRPbmx5TGlzdEl0ZXJhdG9yPEU+KHRoaXMucmVjb3JkKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGl0ZW0gYXQgdGhlIHNwZWNpZmllZCBpbmRleCBvZiB0aGUgc3ViamVjdCdzIGxpc3QgYXNwZWN0LgotCSAqLwotCXB1YmxpYyBFIGdldChpbnQgaW5kZXgpIHsKLQkJcmV0dXJuIHRoaXMucmVjb3JkLmdldChpbmRleCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaXplIG9mIHRoZSBzdWJqZWN0J3MgbGlzdCBhc3BlY3QuCi0JICovCi0JcHVibGljIGludCBzaXplKCkgewotCQlyZXR1cm4gdGhpcy5yZWNvcmQuc2l6ZSgpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhbiBhcnJheSBtYW5pZmVzdGF0aW9uIG9mIHRoZSBzdWJqZWN0J3MgbGlzdCBhc3BlY3QuCi0JICovCi0JcHVibGljIE9iamVjdFtdIHRvQXJyYXkoKSB7Ci0JCXJldHVybiB0aGlzLnJlY29yZC50b0FycmF5KCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIEFzcGVjdEFkYXB0ZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIE9iamVjdCBnZXRWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMuaXRlcmF0b3IoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgQ2xhc3M8PyBleHRlbmRzIENoYW5nZUxpc3RlbmVyPiBnZXRMaXN0ZW5lckNsYXNzKCkgewotCQlyZXR1cm4gTGlzdENoYW5nZUxpc3RlbmVyLmNsYXNzOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0TGlzdGVuZXJBc3BlY3ROYW1lKCkgewotCQlyZXR1cm4gTElTVF9WQUxVRVM7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIGJvb2xlYW4gaGFzTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gdGhpcy5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExJU1RfVkFMVUVTKTsKLQl9Ci0KLQkvKioKLQkgKiBUaGUgYXNwZWN0IGhhcyBjaGFuZ2VkLCBub3RpZnkgbGlzdGVuZXJzIGFwcHJvcHJpYXRlbHkuCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZmlyZUFzcGVjdENoYW5nZShPYmplY3Qgb2xkVmFsdWUsIE9iamVjdCBuZXdWYWx1ZSkgewotCQl0aGlzLmZpcmVMaXN0Q2hhbmdlZChMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JLyoqCi0JICogVGhlIHN1YmplY3QgaXMgbm90IG51bGwgLSBhZGQgb3VyIGxpc3RlbmVyLgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGVuZ2FnZVN1YmplY3RfKCkgewotCQkoKE1vZGVsKSB0aGlzLnN1YmplY3QpLmFkZFN0YXRlQ2hhbmdlTGlzdGVuZXIodGhpcy5zdGF0ZUNoYW5nZUxpc3RlbmVyKTsKLQkJLy8gc3luY2ggb3VyIGxpc3QgKmFmdGVyKiB3ZSBzdGFydCBsaXN0ZW5pbmcgdG8gdGhlIHN1YmplY3QsCi0JCS8vIHNpbmNlIGl0cyB2YWx1ZSBtaWdodCBjaGFuZ2Ugd2hlbiBhIGxpc3RlbmVyIGlzIGFkZGVkCi0JCUNvbGxlY3Rpb25Ub29scy5hZGRBbGwodGhpcy5yZWNvcmQsIHRoaXMuaXRlcmF0b3JGb3JSZWNvcmQoKSk7Ci0JfQotCi0JLyoqCi0JICogVGhlIHN1YmplY3QgaXMgbm90IG51bGwgLSByZW1vdmUgb3VyIGxpc3RlbmVyLgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZVN1YmplY3RfKCkgewotCQkoKE1vZGVsKSB0aGlzLnN1YmplY3QpLnJlbW92ZVN0YXRlQ2hhbmdlTGlzdGVuZXIodGhpcy5zdGF0ZUNoYW5nZUxpc3RlbmVyKTsKLQkJLy8gY2xlYXIgb3V0IHRoZSBsaXN0IHdoZW4gd2UgYXJlIG5vdCBsaXN0ZW5pbmcgdG8gdGhlIHN1YmplY3QKLQkJdGhpcy5yZWNvcmQuY2xlYXIoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogTGlzdEN1cmF0b3IgcHJvdG9jb2wgKioqKioqKioqKgotCi0JLyoqCi0JICogVGhpcyBpcyBpbnRlbmRlZCB0byBiZSBkaWZmZXJlbnQgZnJvbSAjTGlzdFZhbHVlTW9kZWwuaXRlcmF0b3IoKS4KLQkgKiBJdCBpcyBpbnRlbmRlZCB0byBiZSB1c2VkIG9ubHkgd2hlbiB0aGUgc3ViamVjdCBjaGFuZ2VzIG9yIHRoZQotCSAqIHN1YmplY3QncyAic3RhdGUiIGNoYW5nZXMgKGFzIHNpZ25pZmllZCBieSBhIHN0YXRlIGNoYW5nZSBldmVudCkuCi0JICovCi0JcHJvdGVjdGVkIGFic3RyYWN0IEl0ZXJhdG9yPEU+IGl0ZXJhdG9yRm9yUmVjb3JkKCk7Ci0KLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCi0Jdm9pZCBzdWJtaXRJbnZlbnRvcnlSZXBvcnQoKSB7Ci0JCUxpc3Q8RT4gbmV3UmVjb3JkID0gQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5pdGVyYXRvckZvclJlY29yZCgpKTsKLQkJaW50IHJlY29yZEluZGV4ID0gMDsKLQotCQkvLyBhZGQgaXRlbXMgZnJvbSB0aGUgbmV3IHJlY29yZAotCQlmb3IgKEUgbmV3SXRlbSA6IG5ld1JlY29yZCkgewotCQkJdGhpcy5pbnZlbnRvcnlOZXdJdGVtKHJlY29yZEluZGV4LCBuZXdJdGVtKTsKLQkJCXJlY29yZEluZGV4Kys7Ci0JCX0KLQotCQkvLyBjbGVhbiBvdXQgaXRlbXMgdGhhdCBhcmUgbm8gbG9uZ2VyIGluIHRoZSBuZXcgcmVjb3JkCi0JCWZvciAocmVjb3JkSW5kZXggPSAwOyByZWNvcmRJbmRleCA8IHRoaXMucmVjb3JkLnNpemUoKTsgKSB7Ci0JCQlFIGl0ZW0gPSB0aGlzLnJlY29yZC5nZXQocmVjb3JkSW5kZXgpOwotCi0JCQlpZiAobmV3UmVjb3JkLmNvbnRhaW5zKGl0ZW0pKSB7Ci0JCQkJcmVjb3JkSW5kZXgrKzsKLQkJCX0gZWxzZSB7Ci0JCQkJdGhpcy5yZW1vdmVJdGVtRnJvbUludmVudG9yeShyZWNvcmRJbmRleCwgaXRlbSk7Ci0JCQl9Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgaW52ZW50b3J5TmV3SXRlbShpbnQgcmVjb3JkSW5kZXgsIEUgbmV3SXRlbSkgewotCQlMaXN0PEU+IHJlYyA9IG5ldyBBcnJheUxpc3Q8RT4odGhpcy5yZWNvcmQpOwotCi0JCWlmICgocmVjb3JkSW5kZXggPCByZWMuc2l6ZSgpKSAmJiByZWMuZ2V0KHJlY29yZEluZGV4KS5lcXVhbHMobmV3SXRlbSkpIHsKLQkJCXJldHVybjsKLQkJfQotCQlpZiAocmVjLmNvbnRhaW5zKG5ld0l0ZW0pKSB7Ci0JCQl0aGlzLnJlbW92ZUl0ZW1Gcm9tSW52ZW50b3J5KHJlY29yZEluZGV4LCByZWMuZ2V0KHJlY29yZEluZGV4KSk7Ci0JCQl0aGlzLmludmVudG9yeU5ld0l0ZW0ocmVjb3JkSW5kZXgsIG5ld0l0ZW0pOwotCQl9IGVsc2UgewotCQkJdGhpcy5hZGRJdGVtVG9JbnZlbnRvcnkocmVjb3JkSW5kZXgsIG5ld0l0ZW0pOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGFkZEl0ZW1Ub0ludmVudG9yeShpbnQgaW5kZXgsIEUgaXRlbSkgewotCQl0aGlzLmFkZEl0ZW1Ub0xpc3QoaW5kZXgsIGl0ZW0sIHRoaXMucmVjb3JkLCBMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHJlbW92ZUl0ZW1Gcm9tSW52ZW50b3J5KGludCBpbmRleCwgRSBpdGVtKSB7Ci0JCXRoaXMucmVtb3ZlSXRlbUZyb21MaXN0KGluZGV4LCB0aGlzLnJlY29yZCwgTElTVF9WQUxVRVMpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0xpc3RQcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvTGlzdFByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmM3OGI0Zi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvTGlzdFByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE2NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuTGlzdENoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkxpc3RDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBUaGlzIGFic3RyYWN0IGNsYXNzIHByb3ZpZGVzIHRoZSBpbmZyYXN0cnVjdHVyZSBuZWVkZWQgdG8gd3JhcAotICogYSBsaXN0IHZhbHVlIG1vZGVsLCAibGF6aWx5IiBsaXN0ZW4gdG8gaXQsIGFuZCBjb252ZXJ0Ci0gKiBpdHMgY2hhbmdlIG5vdGlmaWNhdGlvbnMgaW50byBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCBjaGFuZ2UKLSAqIG5vdGlmaWNhdGlvbnMuCi0gKiAKLSAqIFN1YmNsYXNzZXMgbXVzdCBvdmVycmlkZToKLSAqIC0gI2J1aWxkVmFsdWUoKQotICogICAgIHRvIHJldHVybiB0aGUgY3VycmVudCBwcm9wZXJ0eSB2YWx1ZSwgYXMgZGVyaXZlZCBmcm9tIHRoZQotICogICAgIGN1cnJlbnQgbGlzdCB2YWx1ZQotICogCi0gKiBTdWJjbGFzc2VzIG1pZ2h0IHdhbnQgdG8gb3ZlcnJpZGU6Ci0gKiAtICNpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkKLSAqIC0gI2l0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpCi0gKiAtICNpdGVtc1JlcGxhY2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkKLSAqIC0gI2l0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KQotICogLSAjbGlzdENsZWFyZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KQotICogLSAjbGlzdENoYW5nZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KQotICogICAgIHRvIGltcHJvdmUgcGVyZm9ybWFuY2UgKGJ5IG5vdCByZWNhbGN1bGF0aW5nIHRoZSB2YWx1ZSwgaWYgcG9zc2libGUpCi0gKi8KLXB1YmxpYyBhYnN0cmFjdCBjbGFzcyBMaXN0UHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlcjxUPgotCWV4dGVuZHMgQXNwZWN0UHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlcjxUPgotewotCS8qKiBUaGUgd3JhcHBlZCBsaXN0IHZhbHVlIG1vZGVsLiAqLwotCXByb3RlY3RlZCBmaW5hbCBMaXN0VmFsdWVNb2RlbDw/PiBsaXN0SG9sZGVyOwotCi0JLyoqIEEgbGlzdGVuZXIgdGhhdCBhbGxvd3MgdXMgdG8gc3luY2ggd2l0aCBjaGFuZ2VzIHRvIHRoZSB3cmFwcGVkIGxpc3QgaG9sZGVyLiAqLwotCXByb3RlY3RlZCBmaW5hbCBMaXN0Q2hhbmdlTGlzdGVuZXIgbGlzdENoYW5nZUxpc3RlbmVyOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9yL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHByb3BlcnR5IHZhbHVlIG1vZGVsIHdpdGggdGhlIHNwZWNpZmllZCB3cmFwcGVkCi0JICogbGlzdCB2YWx1ZSBtb2RlbC4KLQkgKi8KLQlwcm90ZWN0ZWQgTGlzdFByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIoTGlzdFZhbHVlTW9kZWw8Pz4gbGlzdEhvbGRlcikgewotCQlzdXBlcigpOwotCQl0aGlzLmxpc3RIb2xkZXIgPSBsaXN0SG9sZGVyOwotCQl0aGlzLmxpc3RDaGFuZ2VMaXN0ZW5lciA9IHRoaXMuYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXIoKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgTGlzdENoYW5nZUxpc3RlbmVyIGJ1aWxkTGlzdENoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IExpc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJTGlzdFByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIudGhpcy5pdGVtc0FkZGVkKGV2ZW50KTsKLQkJCX0JCQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUxpc3RQcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyLnRoaXMuaXRlbXNSZW1vdmVkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJTGlzdFByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIudGhpcy5pdGVtc1JlcGxhY2VkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJTGlzdFByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIudGhpcy5pdGVtc01vdmVkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGxpc3RDbGVhcmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUxpc3RQcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyLnRoaXMubGlzdENsZWFyZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgbGlzdENoYW5nZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJTGlzdFByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIudGhpcy5saXN0Q2hhbmdlZChldmVudCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJsaXN0IGNoYW5nZSBsaXN0ZW5lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCS8qKgotCSAqIFN0YXJ0IGxpc3RlbmluZyB0byB0aGUgbGlzdCBob2xkZXIuCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlTW9kZWxfKCkgewotCQl0aGlzLmxpc3RIb2xkZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmxpc3RDaGFuZ2VMaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogU3RvcCBsaXN0ZW5pbmcgdG8gdGhlIGxpc3QgaG9sZGVyLgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZU1vZGVsXygpIHsKLQkJdGhpcy5saXN0SG9sZGVyLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5saXN0Q2hhbmdlTGlzdGVuZXIpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHRvU3RyaW5nKFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJc2IuYXBwZW5kKHRoaXMubGlzdEhvbGRlcik7Ci0JfQotCi0JCi0JLy8gKioqKioqKioqKiBjb2xsZWN0aW9uIGNoYW5nZSBzdXBwb3J0ICoqKioqKioqKioKLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgYWRkZWQgdG8gdGhlIHdyYXBwZWQgbGlzdCBob2xkZXI7Ci0JICogcHJvcGFnYXRlIHRoZSBjaGFuZ2Ugbm90aWZpY2F0aW9uIGFwcHJvcHJpYXRlbHkuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gYnkgZGVmYXVsdCwgc2ltcGx5IHJlY2FsY3VsYXRlIHRoZSB2YWx1ZSBhbmQgZmlyZSBhbiBldmVudAotCQl0aGlzLnByb3BlcnR5Q2hhbmdlZCgpOwotCX0KLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgcmVtb3ZlZCBmcm9tIHRoZSB3cmFwcGVkIGxpc3QgaG9sZGVyOwotCSAqIHByb3BhZ2F0ZSB0aGUgY2hhbmdlIG5vdGlmaWNhdGlvbiBhcHByb3ByaWF0ZWx5LgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gYnkgZGVmYXVsdCwgc2ltcGx5IHJlY2FsY3VsYXRlIHRoZSB2YWx1ZSBhbmQgZmlyZSBhbiBldmVudAotCQl0aGlzLnByb3BlcnR5Q2hhbmdlZCgpOwotCX0KLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgcmVwbGFjZWQgaW4gdGhlIHdyYXBwZWQgbGlzdCBob2xkZXI7Ci0JICogcHJvcGFnYXRlIHRoZSBjaGFuZ2Ugbm90aWZpY2F0aW9uIGFwcHJvcHJpYXRlbHkuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gYnkgZGVmYXVsdCwgc2ltcGx5IHJlY2FsY3VsYXRlIHRoZSB2YWx1ZSBhbmQgZmlyZSBhbiBldmVudAotCQl0aGlzLnByb3BlcnR5Q2hhbmdlZCgpOwotCX0KLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgbW92ZWQgaW4gdGhlIHdyYXBwZWQgbGlzdCBob2xkZXI7Ci0JICogcHJvcGFnYXRlIHRoZSBjaGFuZ2Ugbm90aWZpY2F0aW9uIGFwcHJvcHJpYXRlbHkuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNNb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gYnkgZGVmYXVsdCwgc2ltcGx5IHJlY2FsY3VsYXRlIHRoZSB2YWx1ZSBhbmQgZmlyZSBhbiBldmVudAotCQl0aGlzLnByb3BlcnR5Q2hhbmdlZCgpOwotCX0KLQotCS8qKgotCSAqIFRoZSB3cmFwcGVkIGxpc3QgaG9sZGVyIHdhcyBjbGVhcmVkOwotCSAqIHByb3BhZ2F0ZSB0aGUgY2hhbmdlIG5vdGlmaWNhdGlvbiBhcHByb3ByaWF0ZWx5LgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGxpc3RDbGVhcmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkvLyBieSBkZWZhdWx0LCBzaW1wbHkgcmVjYWxjdWxhdGUgdGhlIHZhbHVlIGFuZCBmaXJlIGFuIGV2ZW50Ci0JCXRoaXMucHJvcGVydHlDaGFuZ2VkKCk7Ci0JfQotCi0JLyoqCi0JICogVGhlIHZhbHVlIG9mIHRoZSB3cmFwcGVkIGxpc3QgaG9sZGVyIGhhcyBjaGFuZ2VkOwotCSAqIHByb3BhZ2F0ZSB0aGUgY2hhbmdlIG5vdGlmaWNhdGlvbiBhcHByb3ByaWF0ZWx5LgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGxpc3RDaGFuZ2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkvLyBieSBkZWZhdWx0LCBzaW1wbHkgcmVjYWxjdWxhdGUgdGhlIHZhbHVlIGFuZCBmaXJlIGFuIGV2ZW50Ci0JCXRoaXMucHJvcGVydHlDaGFuZ2VkKCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvTGlzdFZhbHVlTW9kZWxXcmFwcGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvTGlzdFZhbHVlTW9kZWxXcmFwcGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDA2ZjVhMDcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL0xpc3RWYWx1ZU1vZGVsV3JhcHBlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjA2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQ2hhbmdlU3VwcG9ydDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5TaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50Lkxpc3RDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5MaXN0Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci0KLS8qKgotICogVGhpcyBhYnN0cmFjdCBjbGFzcyBwcm92aWRlcyB0aGUgaW5mcmFzdHJ1Y3R1cmUgbmVlZGVkIHRvIHdyYXAKLSAqIGFub3RoZXIgbGlzdCB2YWx1ZSBtb2RlbCwgImxhemlseSIgbGlzdGVuIHRvIGl0LCBhbmQgcHJvcGFnYXRlCi0gKiBpdHMgY2hhbmdlIG5vdGlmaWNhdGlvbnMuCi0gKi8KLXB1YmxpYyBhYnN0cmFjdCBjbGFzcyBMaXN0VmFsdWVNb2RlbFdyYXBwZXI8RT4KLQlleHRlbmRzIEFic3RyYWN0TW9kZWwKLXsKLQotCS8qKiBUaGUgd3JhcHBlZCBsaXN0IHZhbHVlIG1vZGVsLiAqLwotCXByb3RlY3RlZCBmaW5hbCBMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gbGlzdEhvbGRlcjsKLQotCS8qKiBBIGxpc3RlbmVyIHRoYXQgYWxsb3dzIHVzIHRvIHN5bmNoIHdpdGggY2hhbmdlcyB0byB0aGUgd3JhcHBlZCBsaXN0IGhvbGRlci4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgTGlzdENoYW5nZUxpc3RlbmVyIGxpc3RDaGFuZ2VMaXN0ZW5lcjsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgbGlzdCB2YWx1ZSBtb2RlbCB3aXRoIHRoZSBzcGVjaWZpZWQgd3JhcHBlZAotCSAqIGxpc3QgdmFsdWUgbW9kZWwuCi0JICovCi0JcHJvdGVjdGVkIExpc3RWYWx1ZU1vZGVsV3JhcHBlcihMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gbGlzdEhvbGRlcikgewotCQlzdXBlcigpOwotCQlpZiAobGlzdEhvbGRlciA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLmxpc3RIb2xkZXIgPSBsaXN0SG9sZGVyOwotCQl0aGlzLmxpc3RDaGFuZ2VMaXN0ZW5lciA9IHRoaXMuYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXIoKTsKLQl9Ci0JCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBDaGFuZ2VTdXBwb3J0IGJ1aWxkQ2hhbmdlU3VwcG9ydCgpIHsKLQkJcmV0dXJuIG5ldyBTaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0KHRoaXMsIExpc3RDaGFuZ2VMaXN0ZW5lci5jbGFzcywgTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpOwotCX0KLQotCXByb3RlY3RlZCBMaXN0Q2hhbmdlTGlzdGVuZXIgYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgTGlzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlMaXN0VmFsdWVNb2RlbFdyYXBwZXIudGhpcy5pdGVtc0FkZGVkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlMaXN0VmFsdWVNb2RlbFdyYXBwZXIudGhpcy5pdGVtc1JlbW92ZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlMaXN0VmFsdWVNb2RlbFdyYXBwZXIudGhpcy5pdGVtc1JlcGxhY2VkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJTGlzdFZhbHVlTW9kZWxXcmFwcGVyLnRoaXMuaXRlbXNNb3ZlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlMaXN0VmFsdWVNb2RlbFdyYXBwZXIudGhpcy5saXN0Q2xlYXJlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBsaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlMaXN0VmFsdWVNb2RlbFdyYXBwZXIudGhpcy5saXN0Q2hhbmdlZChldmVudCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJsaXN0IGNoYW5nZSBsaXN0ZW5lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGV4dGVuZCBjaGFuZ2Ugc3VwcG9ydCAqKioqKioqKioqCi0KLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSBuZXN0ZWQgbW9kZWwgaWYgbmVjZXNzYXJ5LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCBhZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCWlmICh0aGlzLmhhc05vTGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpIHsKLQkJCXRoaXMuZW5nYWdlTW9kZWwoKTsKLQkJfQotCQlzdXBlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCX0KLQkKLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSBuZXN0ZWQgbW9kZWwgaWYgbmVjZXNzYXJ5LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCBhZGRMaXN0Q2hhbmdlTGlzdGVuZXIoU3RyaW5nIGxpc3ROYW1lLCBMaXN0Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJaWYgKGxpc3ROYW1lID09IExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTICYmIHRoaXMuaGFzTm9MaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSkgewotCQkJdGhpcy5lbmdhZ2VNb2RlbCgpOwotCQl9Ci0JCXN1cGVyLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihsaXN0TmFtZSwgbGlzdGVuZXIpOwotCX0KLQkKLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RvcCBsaXN0ZW5pbmcgdG8gdGhlIG5lc3RlZCBtb2RlbCBpZiBuZWNlc3NhcnkuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIHJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJc3VwZXIucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJaWYgKHRoaXMuaGFzTm9MaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSkgewotCQkJdGhpcy5kaXNlbmdhZ2VNb2RlbCgpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIEV4dGVuZCB0byBzdG9wIGxpc3RlbmluZyB0byB0aGUgbmVzdGVkIG1vZGVsIGlmIG5lY2Vzc2FyeS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgcmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKFN0cmluZyBsaXN0TmFtZSwgTGlzdENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXN1cGVyLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihsaXN0TmFtZSwgbGlzdGVuZXIpOwotCQlpZiAobGlzdE5hbWUgPT0gTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMgJiYgdGhpcy5oYXNOb0xpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKSB7Ci0JCQl0aGlzLmRpc2VuZ2FnZU1vZGVsKCk7Ci0JCX0KLQl9Ci0JCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCS8qKgotCSAqIFN0YXJ0IGxpc3RlbmluZyB0byB0aGUgbGlzdCBob2xkZXIuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlTW9kZWwoKSB7Ci0JCXRoaXMubGlzdEhvbGRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMubGlzdENoYW5nZUxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBTdG9wIGxpc3RlbmluZyB0byB0aGUgbGlzdCBob2xkZXIuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgZGlzZW5nYWdlTW9kZWwoKSB7Ci0JCXRoaXMubGlzdEhvbGRlci5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMubGlzdENoYW5nZUxpc3RlbmVyKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0b1N0cmluZyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXNiLmFwcGVuZCh0aGlzLmxpc3RIb2xkZXIpOwotCX0KLQotCS8vIG1pbmltaXplIHN1cHByZXNzZWQgd2FybmluZ3MKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcm90ZWN0ZWQgTGlzdEl0ZXJhdG9yPEU+IGl0ZW1zKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQlyZXR1cm4gKExpc3RJdGVyYXRvcjxFPikgZXZlbnQuaXRlbXMoKTsKLQl9Ci0KLQkvLyBtaW5pbWl6ZSBzdXBwcmVzc2VkIHdhcm5pbmdzCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJvdGVjdGVkIExpc3RJdGVyYXRvcjxFPiByZXBsYWNlZEl0ZW1zKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQlyZXR1cm4gKExpc3RJdGVyYXRvcjxFPikgZXZlbnQucmVwbGFjZWRJdGVtcygpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBsaXN0IGNoYW5nZSBzdXBwb3J0ICoqKioqKioqKioKLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgYWRkZWQgdG8gdGhlIHdyYXBwZWQgbGlzdCBob2xkZXI7Ci0JICogcHJvcGFnYXRlIHRoZSBjaGFuZ2Ugbm90aWZpY2F0aW9uIGFwcHJvcHJpYXRlbHkuCi0JICovCi0JcHJvdGVjdGVkIGFic3RyYWN0IHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpOwotCi0JLyoqCi0JICogSXRlbXMgd2VyZSByZW1vdmVkIGZyb20gdGhlIHdyYXBwZWQgbGlzdCBob2xkZXI7Ci0JICogcHJvcGFnYXRlIHRoZSBjaGFuZ2Ugbm90aWZpY2F0aW9uIGFwcHJvcHJpYXRlbHkuCi0JICovCi0JcHJvdGVjdGVkIGFic3RyYWN0IHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCk7Ci0KLQkvKioKLQkgKiBJdGVtcyB3ZXJlIHJlcGxhY2VkIGluIHRoZSB3cmFwcGVkIGxpc3QgaG9sZGVyOwotCSAqIHByb3BhZ2F0ZSB0aGUgY2hhbmdlIG5vdGlmaWNhdGlvbiBhcHByb3ByaWF0ZWx5LgotCSAqLwotCXByb3RlY3RlZCBhYnN0cmFjdCB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KTsKLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgbW92ZWQgaW4gdGhlIHdyYXBwZWQgbGlzdCBob2xkZXI7Ci0JICogcHJvcGFnYXRlIHRoZSBjaGFuZ2Ugbm90aWZpY2F0aW9uIGFwcHJvcHJpYXRlbHkuCi0JICovCi0JcHJvdGVjdGVkIGFic3RyYWN0IHZvaWQgaXRlbXNNb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpOwotCi0JLyoqCi0JICogVGhlIHdyYXBwZWQgbGlzdCBob2xkZXIgd2FzIGNsZWFyZWQ7Ci0JICogcHJvcGFnYXRlIHRoZSBjaGFuZ2Ugbm90aWZpY2F0aW9uIGFwcHJvcHJpYXRlbHkuCi0JICovCi0JcHJvdGVjdGVkIGFic3RyYWN0IHZvaWQgbGlzdENsZWFyZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KTsKLQotCS8qKgotCSAqIFRoZSB2YWx1ZSBvZiB0aGUgd3JhcHBlZCBsaXN0IGhvbGRlciBoYXMgY2hhbmdlZDsKLQkgKiBwcm9wYWdhdGUgdGhlIGNoYW5nZSBub3RpZmljYXRpb24gYXBwcm9wcmlhdGVseS4KLQkgKi8KLQlwcm90ZWN0ZWQgYWJzdHJhY3Qgdm9pZCBsaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpOwotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvTnVsbENvbGxlY3Rpb25WYWx1ZU1vZGVsLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvTnVsbENvbGxlY3Rpb25WYWx1ZU1vZGVsLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGRiNjQ0N2MuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL051bGxDb2xsZWN0aW9uVmFsdWVNb2RlbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5DbGFzc1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5FbXB0eUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci0KLS8qKgotICogQSByZWFkLW9ubHkgY29sbGVjdGlvbiB2YWx1ZSBtb2RlbCBmb3Igd2hlbiB5b3UKLSAqIGRvbid0IG5lZWQgdG8gc3VwcG9ydCBhIGNvbGxlY3Rpb24uIEluIHBhcnRpY3VsYXIsIHRoaXMKLSAqIGlzIHVzZWZ1bCBmb3IgdGhlIGxlYWYgbm9kZXMgb2YgYSB0cmVlIHRoYXQgbmV2ZXIgaGF2ZQotICogY2hpbGRyZW4uCi0gKiAKLSAqIFdlIGRvbid0IHVzZSBhIHNpbmdsZXRvbiBiZWNhdXNlIHdlIGhvbGQgb24gdG8gbGlzdGVuZXJzLgotICovCi1wdWJsaWMgZmluYWwgY2xhc3MgTnVsbENvbGxlY3Rpb25WYWx1ZU1vZGVsPEU+Ci0JZXh0ZW5kcyBBYnN0cmFjdE1vZGVsCi0JaW1wbGVtZW50cyBDb2xsZWN0aW9uVmFsdWVNb2RlbDxFPgotewotCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDFMOwotCi0JLyoqCi0JICogRGVmYXVsdCBjb25zdHJ1Y3Rvci4KLQkgKi8KLQlwdWJsaWMgTnVsbENvbGxlY3Rpb25WYWx1ZU1vZGVsKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQotCS8vICoqKioqKioqKiogQ29sbGVjdGlvblZhbHVlTW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIGludCBzaXplKCkgewotCQlyZXR1cm4gMDsKLQl9Ci0KLQlwdWJsaWMgSXRlcmF0b3I8RT4gaXRlcmF0b3IoKSB7Ci0JCXJldHVybiBFbXB0eUl0ZXJhdG9yLmluc3RhbmNlKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIE9iamVjdCBvdmVycmlkZXMgKioqKioqKioqKgotCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLSAgICAJcmV0dXJuIENsYXNzVG9vbHMuc2hvcnRDbGFzc05hbWVGb3JPYmplY3QodGhpcyk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvTnVsbExpc3RWYWx1ZU1vZGVsLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvTnVsbExpc3RWYWx1ZU1vZGVsLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDdiZGIzYWIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL051bGxMaXN0VmFsdWVNb2RlbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkVtcHR5SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkVtcHR5TGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci0KLS8qKgotICogQW4gZW1wdHkgbGlzdCB2YWx1ZSBtb2RlbCBmb3Igd2hlbiB5b3UgZG9uJ3QKLSAqIG5lZWQgdG8gc3VwcG9ydCBhIGxpc3QuCi0gKiAKLSAqIFdlIGRvbid0IHVzZSBhIHNpbmdsZXRvbiBiZWNhdXNlIHdlIGhvbGQgb24gdG8gbGlzdGVuZXJzLgotICovCi1wdWJsaWMgZmluYWwgY2xhc3MgTnVsbExpc3RWYWx1ZU1vZGVsPEU+Ci0JZXh0ZW5kcyBBYnN0cmFjdE1vZGVsCi0JaW1wbGVtZW50cyBMaXN0VmFsdWVNb2RlbDxFPgotewotCXByaXZhdGUgc3RhdGljIGZpbmFsIE9iamVjdFtdIEVNUFRZX0FSUkFZID0gbmV3IE9iamVjdFswXTsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCS8qKgotCSAqIERlZmF1bHQgY29uc3RydWN0b3IuCi0JICovCi0JcHVibGljIE51bGxMaXN0VmFsdWVNb2RlbCgpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogTGlzdFZhbHVlTW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIEl0ZXJhdG9yPEU+IGl0ZXJhdG9yKCkgewotCQlyZXR1cm4gRW1wdHlJdGVyYXRvci5pbnN0YW5jZSgpOwotCX0KLQotCXB1YmxpYyBMaXN0SXRlcmF0b3I8RT4gbGlzdEl0ZXJhdG9yKCkgewotCQlyZXR1cm4gRW1wdHlMaXN0SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQl9Ci0KLQlwdWJsaWMgaW50IHNpemUoKSB7Ci0JCXJldHVybiAwOwotCX0KLQotCXB1YmxpYyBFIGdldChpbnQgaW5kZXgpIHsKLQkJdGhyb3cgbmV3IEluZGV4T3V0T2ZCb3VuZHNFeGNlcHRpb24oIkluZGV4OiAiICsgaW5kZXggKyAiLCBTaXplOiAwIik7Ci0JfQotCi0JcHVibGljIE9iamVjdFtdIHRvQXJyYXkoKSB7Ci0JCXJldHVybiBFTVBUWV9BUlJBWTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogT2JqZWN0IG92ZXJyaWRlcyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gQ2xhc3NUb29scy5zaG9ydENsYXNzTmFtZUZvck9iamVjdCh0aGlzKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9OdWxsUHJvcGVydHlWYWx1ZU1vZGVsLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvTnVsbFByb3BlcnR5VmFsdWVNb2RlbC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxMmM5YjY3Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9OdWxsUHJvcGVydHlWYWx1ZU1vZGVsLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBBIHByb3BlcnR5IHZhbHVlIG1vZGVsIGZvciB3aGVuIHlvdQotICogZG9uJ3QgbmVlZCB0byBzdXBwb3J0IGEgdmFsdWUuCi0gKiAKLSAqIFdlIGRvbid0IHVzZSBhIHNpbmdsZXRvbiBiZWNhdXNlIHdlIGhvbGQgb24gdG8gbGlzdGVuZXJzLgotICovCi1wdWJsaWMgY2xhc3MgTnVsbFByb3BlcnR5VmFsdWVNb2RlbDxUPgotCWV4dGVuZHMgQWJzdHJhY3RNb2RlbAotCWltcGxlbWVudHMgUHJvcGVydHlWYWx1ZU1vZGVsPFQ+Ci17Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0KLQkvKioKLQkgKiBEZWZhdWx0IGNvbnN0cnVjdG9yLgotCSAqLwotCXB1YmxpYyBOdWxsUHJvcGVydHlWYWx1ZU1vZGVsKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQotCS8vICoqKioqKioqKiogUHJvcGVydHlWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBUIGdldFZhbHVlKCkgewotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogT2JqZWN0IG92ZXJyaWRlcyAqKioqKioqKioqCi0KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gQ2xhc3NUb29scy5zaG9ydENsYXNzTmFtZUZvck9iamVjdCh0aGlzKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9OdWxsVHJlZVZhbHVlTW9kZWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9OdWxsVHJlZVZhbHVlTW9kZWwuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYjAzNWMyOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvTnVsbFRyZWVWYWx1ZU1vZGVsLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkVtcHR5SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5UcmVlVmFsdWVNb2RlbDsKLQotLyoqCi0gKiBBIHRyZWUgdmFsdWUgbW9kZWwgZm9yIHdoZW4geW91Ci0gKiBkb24ndCBuZWVkIHRvIHN1cHBvcnQgYW55IG5vZGVzLgotICogCi0gKiBXZSBkb24ndCB1c2UgYSBzaW5nbGV0b24gYmVjYXVzZSB3ZSBob2xkIG9uIHRvIGxpc3RlbmVycy4KLSAqLwotcHVibGljIGNsYXNzIE51bGxUcmVlVmFsdWVNb2RlbDxFPgotCWV4dGVuZHMgQWJzdHJhY3RNb2RlbAotCWltcGxlbWVudHMgVHJlZVZhbHVlTW9kZWw8RT4KLXsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCS8qKgotCSAqIERlZmF1bHQgY29uc3RydWN0b3IuCi0JICovCi0JcHVibGljIE51bGxUcmVlVmFsdWVNb2RlbCgpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0KLQkvLyAqKioqKioqKioqIFRyZWVWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBJdGVyYXRvcjxFPiBub2RlcygpIHsKLQkJcmV0dXJuIEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogT2JqZWN0IG92ZXJyaWRlcyAqKioqKioqKioqCi0KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gQ2xhc3NUb29scy5zaG9ydENsYXNzTmFtZUZvck9iamVjdCh0aGlzKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWIyYjRmOC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvUHJvcGVydHlBc3BlY3RBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyNTUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheXM7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBUaGlzIEFzcGVjdEFkYXB0ZXIgcHJvdmlkZXMgYmFzaWMgUHJvcGVydHlDaGFuZ2Ugc3VwcG9ydC4KLSAqIFRoaXMgYWxsb3dzIHVzIHRvIGNvbnZlcnQgYSBzZXQgb2Ygb25lIG9yIG1vcmUgcHJvcGVydGllcyBpbnRvCi0gKiBhIHNpbmdsZSBwcm9wZXJ0eSwgVkFMVUUuCi0gKiAKLSAqIFRoZSB0eXBpY2FsIHN1YmNsYXNzIHdpbGwgb3ZlcnJpZGUgdGhlIGZvbGxvd2luZyBtZXRob2RzOgotICogI2J1aWxkVmFsdWVfKCkKLSAqICAgICBhdCB0aGUgdmVyeSBtaW5pbXVtLCBvdmVycmlkZSB0aGlzIG1ldGhvZCB0byByZXR1cm4gdGhlIHZhbHVlIG9mIHRoZQotICogICAgIHN1YmplY3QncyBwcm9wZXJ0eSAob3IgInZpcnR1YWwiIHByb3BlcnR5KTsgaXQgZG9lcyBub3QgbmVlZCB0byBiZQotICogICAgIG92ZXJyaWRkZW4gaWYgI2J1aWxkVmFsdWUoKSBpcyBvdmVycmlkZGVuIGFuZCBpdHMgYmVoYXZpb3IgY2hhbmdlZAotICogI3NldFZhbHVlXyhPYmplY3QpCi0gKiAgICAgb3ZlcnJpZGUgdGhpcyBtZXRob2QgaWYgdGhlIGNsaWVudCBjb2RlIG5lZWRzIHRvICpzZXQqIHRoZSB2YWx1ZSBvZgotICogICAgIHRoZSBzdWJqZWN0J3MgcHJvcGVydHk7IG9mdGVudGltZXMsIHRob3VnaCwgdGhlIGNsaWVudCBjb2RlIChlLmcuIFVJKQotICogICAgIHdpbGwgbmVlZCBvbmx5IHRvICpnZXQqIHRoZSB2YWx1ZTsgaXQgZG9lcyBub3QgbmVlZCB0byBiZQotICogICAgIG92ZXJyaWRkZW4gaWYgI3NldFZhbHVlKE9iamVjdCkgaXMgb3ZlcnJpZGRlbiBhbmQgaXRzIGJlaGF2aW9yIGNoYW5nZWQKLSAqICNidWlsZFZhbHVlKCkKLSAqICAgICBvdmVycmlkZSB0aGlzIG1ldGhvZCBvbmx5IGlmIHJldHVybmluZyBhIG51bGwgdmFsdWUgd2hlbiB0aGUgc3ViamVjdCBpcyBudWxsCi0gKiAgICAgaXMgdW5hY2NlcHRhYmxlCi0gKiAjc2V0VmFsdWUoT2JqZWN0KQotICogICAgIG92ZXJyaWRlIHRoaXMgbWV0aG9kIG9ubHkgaWYgc29tZXRoaW5nIG11c3QgYmUgZG9uZSB3aGVuIHRoZSBzdWJqZWN0Ci0gKiAgICAgaXMgbnVsbCAoZS5nLiB0aHJvdyBhbiBleGNlcHRpb24pCi0gKi8KLXB1YmxpYyBhYnN0cmFjdCBjbGFzcyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8UyBleHRlbmRzIE1vZGVsLCBUPgotCWV4dGVuZHMgQXNwZWN0QWRhcHRlcjxTPgotCWltcGxlbWVudHMgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VD4KLXsKLQkvKioKLQkgKiBDYWNoZSB0aGUgY3VycmVudCB2YWx1ZSBvZiB0aGUgYXNwZWN0IHNvIHdlCi0JICogY2FuIHBhc3MgYW4gIm9sZCB2YWx1ZSIgd2hlbiB3ZSBmaXJlIGEgcHJvcGVydHkgY2hhbmdlIGV2ZW50LgotCSAqIFdlIG5lZWQgdGhpcyBiZWNhdXNlIHRoZSB2YWx1ZSBtYXkgYmUgY2FsY3VsYXRlZCBhbmQgbWF5Ci0JICogbm90IGJlIGluIHRoZSBwcm9wZXJ0eSBjaGFuZ2UgZXZlbnQgZmlyZWQgYnkgdGhlIHN1YmplY3QsCi0JICogZXNwZWNpYWxseSB3aGVuIGRlYWxpbmcgd2l0aCBtdWx0aXBsZSBhc3BlY3RzLgotCSAqLwotCXByb3RlY3RlZCBUIHZhbHVlOwotCi0JLyoqIFRoZSBuYW1lIG9mIHRoZSBzdWJqZWN0J3MgcHJvcGVydGllcyB0aGF0IHdlIHVzZSBmb3IgdGhlIHZhbHVlLiAqLwotCXByb3RlY3RlZCBmaW5hbCBTdHJpbmdbXSBwcm9wZXJ0eU5hbWVzOwotCQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIFN0cmluZ1tdIEVNUFRZX1BST1BFUlRZX05BTUVTID0gbmV3IFN0cmluZ1swXTsKLQotCS8qKiBBIGxpc3RlbmVyIHRoYXQgbGlzdGVucyB0byB0aGUgYXBwcm9wcmlhdGUgcHJvcGVydGllcyBvZiB0aGUgc3ViamVjdC4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBwcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgc3ViamVjdAotCSAqIGFuZCBwcm9wZXJ0eS4KLQkgKi8KLQlwcm90ZWN0ZWQgUHJvcGVydHlBc3BlY3RBZGFwdGVyKFN0cmluZyBwcm9wZXJ0eU5hbWUsIFMgc3ViamVjdCkgewotCQl0aGlzKG5ldyBTdHJpbmdbXSB7cHJvcGVydHlOYW1lfSwgc3ViamVjdCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgUHJvcGVydHlBc3BlY3RBZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIHN1YmplY3QKLQkgKiBhbmQgcHJvcGVydGllcy4KLQkgKi8KLQlwcm90ZWN0ZWQgUHJvcGVydHlBc3BlY3RBZGFwdGVyKFN0cmluZ1tdIHByb3BlcnR5TmFtZXMsIFMgc3ViamVjdCkgewotCQl0aGlzKG5ldyBTdGF0aWNQcm9wZXJ0eVZhbHVlTW9kZWw8Uz4oc3ViamVjdCksIHByb3BlcnR5TmFtZXMpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIFByb3BlcnR5QXNwZWN0QWRhcHRlciBmb3IgdGhlIHNwZWNpZmllZCBzdWJqZWN0IGhvbGRlcgotCSAqIGFuZCBwcm9wZXJ0aWVzLgotCSAqLwotCXByb3RlY3RlZCBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXIoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBTPiBzdWJqZWN0SG9sZGVyLCBTdHJpbmcuLi4gcHJvcGVydHlOYW1lcykgewotCQlzdXBlcihzdWJqZWN0SG9sZGVyKTsKLQkJdGhpcy5wcm9wZXJ0eU5hbWVzID0gcHJvcGVydHlOYW1lczsKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUxpc3RlbmVyID0gdGhpcy5idWlsZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKTsKLQkJLy8gb3VyIHZhbHVlIGlzIG51bGwgd2hlbiB3ZSBhcmUgbm90IGxpc3RlbmluZyB0byB0aGUgc3ViamVjdAotCQl0aGlzLnZhbHVlID0gbnVsbDsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgc3ViamVjdCBob2xkZXIKLQkgKiBhbmQgcHJvcGVydGllcy4KLQkgKi8KLQlwcm90ZWN0ZWQgUHJvcGVydHlBc3BlY3RBZGFwdGVyKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgUz4gc3ViamVjdEhvbGRlciwgQ29sbGVjdGlvbjxTdHJpbmc+IHByb3BlcnR5TmFtZXMpIHsKLQkJdGhpcyhzdWJqZWN0SG9sZGVyLCBwcm9wZXJ0eU5hbWVzLnRvQXJyYXkobmV3IFN0cmluZ1twcm9wZXJ0eU5hbWVzLnNpemUoKV0pKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXIgZm9yIGFuICJ1bmNoYW5naW5nIiBwcm9wZXJ0eSBpbgotCSAqIHRoZSBzcGVjaWZpZWQgc3ViamVjdC4gVGhpcyBpcyB1c2VmdWwgZm9yIGEgcHJvcGVydHkgYXNwZWN0IHRoYXQgZG9lcyBub3QKLQkgKiBjaGFuZ2UgZm9yIGEgcGFydGljdWxhciBzdWJqZWN0OyBidXQgdGhlIHN1YmplY3Qgd2lsbCBjaGFuZ2UsIHJlc3VsdGluZyBpbgotCSAqIGEgbmV3IHByb3BlcnR5LiAoQSBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbCBjb3VsZCBhbHNvIGJlCi0JICogdXNlZCBpbiB0aGlzIHNpdHVhdGlvbi4pCi0JICovCi0JcHJvdGVjdGVkIFByb3BlcnR5QXNwZWN0QWRhcHRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFM+IHN1YmplY3RIb2xkZXIpIHsKLQkJdGhpcyhzdWJqZWN0SG9sZGVyLCBFTVBUWV9QUk9QRVJUWV9OQU1FUyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIFRoZSBzdWJqZWN0J3MgcHJvcGVydHkgaGFzIGNoYW5nZWQsIG5vdGlmeSB0aGUgbGlzdGVuZXJzLgotCSAqLwotCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJLy8gdHJhbnNmb3JtIHRoZSBzdWJqZWN0J3MgcHJvcGVydHkgY2hhbmdlIGV2ZW50cyBpbnRvIFZBTFVFIHByb3BlcnR5IGNoYW5nZSBldmVudHMKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlQcm9wZXJ0eUFzcGVjdEFkYXB0ZXIudGhpcy5wcm9wZXJ0eUNoYW5nZWQoKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gInByb3BlcnR5IGNoYW5nZSBsaXN0ZW5lcjogIiArIEFycmF5cy5hc0xpc3QoUHJvcGVydHlBc3BlY3RBZGFwdGVyLnRoaXMucHJvcGVydHlOYW1lcyk7IC8vJE5PTi1OTFMtMSQKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogUHJvcGVydHlWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB0aGUgdmFsdWUgb2YgdGhlIHN1YmplY3QncyBwcm9wZXJ0eS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgZmluYWwgVCBnZXRWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMudmFsdWU7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIFNldCB0aGUgdmFsdWUgb2YgdGhlIHN1YmplY3QncyBwcm9wZXJ0eS4KLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRWYWx1ZShUIHZhbHVlKSB7Ci0JCWlmICh0aGlzLnN1YmplY3QgIT0gbnVsbCkgewotCQkJdGhpcy5zZXRWYWx1ZV8odmFsdWUpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSB2YWx1ZSBvZiB0aGUgc3ViamVjdCdzIHByb3BlcnR5LgotCSAqIEF0IHRoaXMgcG9pbnQgd2UgY2FuIGJlIHN1cmUgdGhhdCB0aGUgc3ViamVjdCBpcyBub3QgbnVsbC4KLQkgKiBAc2VlICNzZXRWYWx1ZShPYmplY3QpCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEBTdXBwcmVzc1dhcm5pbmdzKCJ1bnVzZWQiKSBUIHZhbHVlKSB7Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBBc3BlY3RBZGFwdGVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBDbGFzczw/IGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXI+IGdldExpc3RlbmVyQ2xhc3MoKSB7Ci0JCXJldHVybiBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyLmNsYXNzOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0TGlzdGVuZXJBc3BlY3ROYW1lKCkgewotCQlyZXR1cm4gVkFMVUU7Ci0JfQotCi0gICAgQE92ZXJyaWRlCi0JcHJvdGVjdGVkIGJvb2xlYW4gaGFzTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gdGhpcy5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhWQUxVRSk7Ci0JfQotCi0gICAgQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZmlyZUFzcGVjdENoYW5nZShPYmplY3Qgb2xkVmFsdWUsIE9iamVjdCBuZXdWYWx1ZSkgewotCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoVkFMVUUsIG9sZFZhbHVlLCBuZXdWYWx1ZSk7Ci0JfQotCi0gICAgQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlU3ViamVjdCgpIHsKLQkJc3VwZXIuZW5nYWdlU3ViamVjdCgpOwotCQkvLyBzeW5jaCBvdXIgdmFsdWUgKmFmdGVyKiB3ZSBzdGFydCBsaXN0ZW5pbmcgdG8gdGhlIHN1YmplY3QsCi0JCS8vIHNpbmNlIGl0cyB2YWx1ZSBtaWdodCBjaGFuZ2Ugd2hlbiBhIGxpc3RlbmVyIGlzIGFkZGVkCi0JCXRoaXMudmFsdWUgPSB0aGlzLmJ1aWxkVmFsdWUoKTsKLQl9Ci0KLSAgICBAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VTdWJqZWN0XygpIHsKLSAgICAJZm9yIChTdHJpbmcgcHJvcGVydHlOYW1lIDogdGhpcy5wcm9wZXJ0eU5hbWVzKSB7Ci0JCQkoKE1vZGVsKSB0aGlzLnN1YmplY3QpLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIocHJvcGVydHlOYW1lLCB0aGlzLnByb3BlcnR5Q2hhbmdlTGlzdGVuZXIpOwotCQl9Ci0JfQotCi0gICAgQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZGlzZW5nYWdlU3ViamVjdCgpIHsKLQkJc3VwZXIuZGlzZW5nYWdlU3ViamVjdCgpOwotCQkvLyBjbGVhciBvdXQgb3VyIHZhbHVlIHdoZW4gd2UgYXJlIG5vdCBsaXN0ZW5pbmcgdG8gdGhlIHN1YmplY3QKLQkJdGhpcy52YWx1ZSA9IG51bGw7Ci0JfQotCi0gICAgQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZGlzZW5nYWdlU3ViamVjdF8oKSB7Ci0gICAgCWZvciAoU3RyaW5nIHByb3BlcnR5TmFtZSA6IHRoaXMucHJvcGVydHlOYW1lcykgewotCQkJKChNb2RlbCkgdGhpcy5zdWJqZWN0KS5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHByb3BlcnR5TmFtZSwgdGhpcy5wcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBBYnN0cmFjdE1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHRvU3RyaW5nKFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCB0aGlzLnByb3BlcnR5TmFtZXMubGVuZ3RoOyBpKyspIHsKLQkJCWlmIChpICE9IDApIHsKLQkJCQlzYi5hcHBlbmQoIiwgIik7IC8vJE5PTi1OTFMtMSQKLQkJCX0KLQkJCXNiLmFwcGVuZCh0aGlzLnByb3BlcnR5TmFtZXNbaV0pOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXNwZWN0J3MgdmFsdWUuCi0JICogQXQgdGhpcyBwb2ludCB0aGUgc3ViamVjdCBtYXkgYmUgbnVsbC4KLQkgKi8KLQlwcm90ZWN0ZWQgVCBidWlsZFZhbHVlKCkgewotCQlyZXR1cm4gKHRoaXMuc3ViamVjdCA9PSBudWxsKSA/IG51bGwgOiB0aGlzLmJ1aWxkVmFsdWVfKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSB2YWx1ZSBvZiB0aGUgc3ViamVjdCdzIHByb3BlcnR5LgotCSAqIEF0IHRoaXMgcG9pbnQgd2UgY2FuIGJlIHN1cmUgdGhhdCB0aGUgc3ViamVjdCBpcyBub3QgbnVsbC4KLQkgKiBAc2VlICNidWlsZFZhbHVlKCkKLQkgKi8KLQlwcm90ZWN0ZWQgVCBidWlsZFZhbHVlXygpIHsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgcHJvcGVydHlDaGFuZ2VkKCkgewotCQlUIG9sZCA9IHRoaXMudmFsdWU7Ci0JCXRoaXMudmFsdWUgPSB0aGlzLmJ1aWxkVmFsdWUoKTsKLQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKG9sZCwgdGhpcy52YWx1ZSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvUHJvcGVydHlDb2xsZWN0aW9uVmFsdWVNb2RlbEFkYXB0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Qcm9wZXJ0eUNvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1YjA5YWQxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Qcm9wZXJ0eUNvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTk0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkVtcHR5SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlNpbmdsZUVsZW1lbnRJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkNoYW5nZVN1cHBvcnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuU2luZ2xlQXNwZWN0Q2hhbmdlU3VwcG9ydDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Qcm9wZXJ0eUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBBbiBhZGFwdGVyIHRoYXQgYWxsb3dzIHVzIHRvIG1ha2UgYSBQcm9wZXJ0eVZhbHVlTW9kZWwgYmVoYXZlIGxpa2UKLSAqIGEgcmVhZC1vbmx5LCBzaW5nbGUtZWxlbWVudCBDb2xsZWN0aW9uVmFsdWVNb2RlbCwgc29ydGEuCi0gKiAKLSAqIElmIHRoZSBwcm9wZXJ0eSdzIHZhbHVlIGlzIG51bGwsIGFuIGVtcHR5IGl0ZXJhdG9yIGlzIHJldHVybmVkCi0gKiAoaS5lLiB5b3UgY2FuJ3QgaGF2ZSBhIGNvbGxlY3Rpb24gd2l0aCBhIG51bGwgZWxlbWVudCkuCi0gKi8KLXB1YmxpYyBjbGFzcyBQcm9wZXJ0eUNvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlcjxFPgotCWV4dGVuZHMgQWJzdHJhY3RNb2RlbAotCWltcGxlbWVudHMgQ29sbGVjdGlvblZhbHVlTW9kZWw8RT4KLXsKLQkvKiogVGhlIHdyYXBwZWQgcHJvcGVydHkgdmFsdWUgbW9kZWwuICovCi0JcHJvdGVjdGVkIGZpbmFsIFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gdmFsdWVIb2xkZXI7Ci0KLQkvKiogQSBsaXN0ZW5lciB0aGF0IGZvcndhcmRzIGFueSBldmVudHMgZmlyZWQgYnkgdGhlIHZhbHVlIGhvbGRlci4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBwcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotCi0JLyoqIENhY2hlIHRoZSB2YWx1ZS4gKi8KLQlwcm90ZWN0ZWQgRSB2YWx1ZTsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMvaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JLyoqCi0JICogV3JhcCB0aGUgc3BlY2lmaWVkIExpc3RWYWx1ZU1vZGVsLgotCSAqLwotCXB1YmxpYyBQcm9wZXJ0eUNvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIEU+IHZhbHVlSG9sZGVyKSB7Ci0JCXN1cGVyKCk7Ci0JCWlmICh2YWx1ZUhvbGRlciA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLnZhbHVlSG9sZGVyID0gdmFsdWVIb2xkZXI7Ci0JCXRoaXMucHJvcGVydHlDaGFuZ2VMaXN0ZW5lciA9IHRoaXMuYnVpbGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCk7Ci0JCS8vIHBvc3Rwb25lIGJ1aWxkaW5nIHRoZSB2YWx1ZSBhbmQgbGlzdGVuaW5nIHRvIHRoZSB1bmRlcmx5aW5nIHZhbHVlCi0JCS8vIHVudGlsIHdlIGhhdmUgbGlzdGVuZXJzIG91cnNlbHZlcy4uLgotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBDaGFuZ2VTdXBwb3J0IGJ1aWxkQ2hhbmdlU3VwcG9ydCgpIHsKLQkJcmV0dXJuIG5ldyBTaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0KHRoaXMsIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lci5jbGFzcywgVkFMVUVTKTsKLQl9Ci0KLQkvKioKLQkgKiBUaGUgd3JhcHBlZCB2YWx1ZSBoYXMgY2hhbmdlZCwgZm9yd2FyZCBhbiBlcXVpdmFsZW50Ci0JICogY29sbGVjdGlvbiBjaGFuZ2UgZXZlbnQgdG8gb3VyIGxpc3RlbmVycy4KLQkgKi8KLQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlQcm9wZXJ0eUNvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlci50aGlzLnZhbHVlQ2hhbmdlZCgoRSkgZXZlbnQuZ2V0TmV3VmFsdWUoKSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJwcm9wZXJ0eSBjaGFuZ2UgbGlzdGVuZXIiOwotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBDb2xsZWN0aW9uVmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgSXRlcmF0b3I8RT4gaXRlcmF0b3IoKSB7Ci0JCXJldHVybiAodGhpcy52YWx1ZSA9PSBudWxsKSA/Ci0JCQkJCUVtcHR5SXRlcmF0b3IuPEU+aW5zdGFuY2UoKQotCQkJCToKLQkJCQkJbmV3IFNpbmdsZUVsZW1lbnRJdGVyYXRvcjxFPih0aGlzLnZhbHVlKTsKLQl9Ci0KLQlwdWJsaWMgaW50IHNpemUoKSB7Ci0JCXJldHVybiAodGhpcy52YWx1ZSA9PSBudWxsKSA/IDAgOiAxOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBleHRlbmQgY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JLyoqCi0JICogT3ZlcnJpZGUgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSB2YWx1ZSBob2xkZXIgaWYgbmVjZXNzYXJ5LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJaWYgKHRoaXMuaGFzTm9MaXN0ZW5lcnMoKSkgewotCQkJdGhpcy5lbmdhZ2VNb2RlbCgpOwotCQl9Ci0JCXN1cGVyLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogT3ZlcnJpZGUgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSB2YWx1ZSBob2xkZXIgaWYgbmVjZXNzYXJ5LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihTdHJpbmcgY29sbGVjdGlvbk5hbWUsIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlpZiAoY29sbGVjdGlvbk5hbWUgPT0gVkFMVUVTICYmIHRoaXMuaGFzTm9MaXN0ZW5lcnMoKSkgewotCQkJdGhpcy5lbmdhZ2VNb2RlbCgpOwotCQl9Ci0JCXN1cGVyLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihjb2xsZWN0aW9uTmFtZSwgbGlzdGVuZXIpOwotCX0KLQotCS8qKgotCSAqIE92ZXJyaWRlIHRvIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSB2YWx1ZSBob2xkZXIgaWYgYXBwcm9wcmlhdGUuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgcmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlzdXBlci5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlpZiAodGhpcy5oYXNOb0xpc3RlbmVycygpKSB7Ci0JCQl0aGlzLmRpc2VuZ2FnZU1vZGVsKCk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBPdmVycmlkZSB0byBzdG9wIGxpc3RlbmluZyB0byB0aGUgdmFsdWUgaG9sZGVyIGlmIGFwcHJvcHJpYXRlLgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihTdHJpbmcgY29sbGVjdGlvbk5hbWUsIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlzdXBlci5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoY29sbGVjdGlvbk5hbWUsIGxpc3RlbmVyKTsKLQkJaWYgKGNvbGxlY3Rpb25OYW1lID09IFZBTFVFUyAmJiB0aGlzLmhhc05vTGlzdGVuZXJzKCkpIHsKLQkJCXRoaXMuZGlzZW5nYWdlTW9kZWwoKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBxdWVyaWVzICoqKioqKioqKioKLQotCXByb3RlY3RlZCBib29sZWFuIGhhc0xpc3RlbmVycygpIHsKLQkJcmV0dXJuIHRoaXMuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhWQUxVRVMpOwotCX0KLQotCXByb3RlY3RlZCBib29sZWFuIGhhc05vTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gISB0aGlzLmhhc0xpc3RlbmVycygpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VNb2RlbCgpIHsKLQkJdGhpcy52YWx1ZUhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5wcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKTsKLQkJLy8gc3luY2ggb3VyIHZhbHVlICphZnRlciogd2Ugc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSB2YWx1ZSBob2xkZXIsCi0JCS8vIHNpbmNlIGl0cyB2YWx1ZSBtaWdodCBjaGFuZ2Ugd2hlbiBhIGxpc3RlbmVyIGlzIGFkZGVkCi0JCXRoaXMudmFsdWUgPSB0aGlzLnZhbHVlSG9sZGVyLmdldFZhbHVlKCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZGlzZW5nYWdlTW9kZWwoKSB7Ci0JCXRoaXMudmFsdWVIb2xkZXIucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMucHJvcGVydHlDaGFuZ2VMaXN0ZW5lcik7Ci0JCS8vIGNsZWFyIG91dCB0aGUgdmFsdWUgd2hlbiB3ZSBhcmUgbm90IGxpc3RlbmluZyB0byB0aGUgdmFsdWUgaG9sZGVyCi0JCXRoaXMudmFsdWUgPSBudWxsOwotCX0KLQotCS8qKgotCSAqIHN5bmNocm9uaXplIG91ciBpbnRlcm5hbCB2YWx1ZSB3aXRoIHRoZSB3cmFwcGVkIHZhbHVlCi0JICogYW5kIGZpcmUgdGhlIGFwcHJvcHJpYXRlIGV2ZW50cwotCSAqLwotCXByb3RlY3RlZCB2b2lkIHZhbHVlQ2hhbmdlZChFIG5ld1ZhbHVlKSB7Ci0JCS8vIHB1dCBpbiAiZW1wdHkiIGNoZWNrIHNvIHdlIGRvbid0IGZpcmUgZXZlbnRzIHVubmVjZXNzYXJpbHkKLQkJaWYgKHRoaXMudmFsdWUgIT0gbnVsbCkgewotCQkJRSBvbGRWYWx1ZSA9IHRoaXMudmFsdWU7Ci0JCQl0aGlzLnZhbHVlID0gbnVsbDsKLQkJCXRoaXMuZmlyZUl0ZW1SZW1vdmVkKFZBTFVFUywgb2xkVmFsdWUpOwotCQl9Ci0JCXRoaXMudmFsdWUgPSBuZXdWYWx1ZTsKLQkJLy8gcHV0IGluICJlbXB0eSIgY2hlY2sgc28gd2UgZG9uJ3QgZmlyZSBldmVudHMgdW5uZWNlc3NhcmlseQotCQlpZiAodGhpcy52YWx1ZSAhPSBudWxsKSB7Ci0JCQl0aGlzLmZpcmVJdGVtQWRkZWQoVkFMVUVTLCB0aGlzLnZhbHVlKTsKLQkJfQotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHRvU3RyaW5nKFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJc2IuYXBwZW5kKHRoaXMudmFsdWVIb2xkZXIpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1Byb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTZhZmUyOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDIxOSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkVtcHR5TGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5TaW5nbGVFbGVtZW50TGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQ2hhbmdlU3VwcG9ydDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5TaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlByb3BlcnR5Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuTGlzdENoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIEFuIGFkYXB0ZXIgdGhhdCBhbGxvd3MgdXMgdG8gbWFrZSBhIFByb3BlcnR5VmFsdWVNb2RlbCBiZWhhdmUgbGlrZQotICogYSByZWFkLW9ubHksIHNpbmdsZS1lbGVtZW50IExpc3RWYWx1ZU1vZGVsLCBzb3J0YS4KLSAqIAotICogSWYgdGhlIHByb3BlcnR5J3MgdmFsdWUgaXMgbnVsbCwgYW4gZW1wdHkgaXRlcmF0b3IgaXMgcmV0dXJuZWQKLSAqIChpLmUuIHlvdSBjYW4ndCBoYXZlIGEgbGlzdCB3aXRoIGEgbnVsbCBlbGVtZW50KS4KLSAqLwotcHVibGljIGNsYXNzIFByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyPEU+Ci0JZXh0ZW5kcyBBYnN0cmFjdE1vZGVsCi0JaW1wbGVtZW50cyBMaXN0VmFsdWVNb2RlbDxFPgotewotCi0JLyoqIFRoZSB3cmFwcGVkIHByb3BlcnR5IHZhbHVlIG1vZGVsLiAqLwotCXByb3RlY3RlZCBmaW5hbCBQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIEU+IHZhbHVlSG9sZGVyOwotCi0JLyoqIEEgbGlzdGVuZXIgdGhhdCBmb3J3YXJkcyBhbnkgZXZlbnRzIGZpcmVkIGJ5IHRoZSB2YWx1ZSBob2xkZXIuICovCi0JcHJvdGVjdGVkIGZpbmFsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgcHJvcGVydHlDaGFuZ2VMaXN0ZW5lcjsKLQotCS8qKiBDYWNoZSB0aGUgdmFsdWUuICovCi0JcHJvdGVjdGVkIEUgdmFsdWU7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIFdyYXAgdGhlIHNwZWNpZmllZCBwcm9wZXJ0eSB2YWx1ZSBtb2RlbC4KLQkgKi8KLQlwdWJsaWMgUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXIoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBFPiB2YWx1ZUhvbGRlcikgewotCQlzdXBlcigpOwotCQlpZiAodmFsdWVIb2xkZXIgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy52YWx1ZUhvbGRlciA9IHZhbHVlSG9sZGVyOwotCQl0aGlzLnByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgPSB0aGlzLmJ1aWxkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpOwotCQkvLyBwb3N0cG9uZSBidWlsZGluZyB0aGUgdmFsdWUgYW5kIGxpc3RlbmluZyB0byB0aGUgdW5kZXJseWluZyB2YWx1ZQotCQkvLyB1bnRpbCB3ZSBoYXZlIGxpc3RlbmVycyBvdXJzZWx2ZXMuLi4KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgQ2hhbmdlU3VwcG9ydCBidWlsZENoYW5nZVN1cHBvcnQoKSB7Ci0JCXJldHVybiBuZXcgU2luZ2xlQXNwZWN0Q2hhbmdlU3VwcG9ydCh0aGlzLCBMaXN0Q2hhbmdlTGlzdGVuZXIuY2xhc3MsIExJU1RfVkFMVUVTKTsKLQl9Ci0KLQkvKioKLQkgKiBUaGUgd3JhcHBlZCB2YWx1ZSBoYXMgY2hhbmdlZCwgZm9yd2FyZCBhbiBlcXVpdmFsZW50Ci0JICogbGlzdCBjaGFuZ2UgZXZlbnQgdG8gb3VyIGxpc3RlbmVycy4KLQkgKi8KLQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlQcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlci50aGlzLnZhbHVlQ2hhbmdlZCgoRSkgZXZlbnQuZ2V0TmV3VmFsdWUoKSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJwcm9wZXJ0eSBjaGFuZ2UgbGlzdGVuZXIiOwotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBMaXN0VmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgSXRlcmF0b3I8RT4gaXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3RJdGVyYXRvcigpOwotCX0KLQotCXB1YmxpYyBMaXN0SXRlcmF0b3I8RT4gbGlzdEl0ZXJhdG9yKCkgewotCQlyZXR1cm4gKHRoaXMudmFsdWUgPT0gbnVsbCkgPwotCQkJCQlFbXB0eUxpc3RJdGVyYXRvci48RT5pbnN0YW5jZSgpCi0JCQkJOgotCQkJCQluZXcgU2luZ2xlRWxlbWVudExpc3RJdGVyYXRvcjxFPih0aGlzLnZhbHVlKTsKLQl9Ci0KLQlwdWJsaWMgaW50IHNpemUoKSB7Ci0JCXJldHVybiAodGhpcy52YWx1ZSA9PSBudWxsKSA/IDAgOiAxOwotCX0KLQotCXB1YmxpYyBFIGdldChpbnQgaW5kZXgpIHsKLQkJaWYgKHRoaXMudmFsdWUgPT0gbnVsbCkgewotCQkJdGhyb3cgdGhpcy5pb29iZShpbmRleCwgMCk7Ci0JCX0KLQkJaWYgKGluZGV4ID4gMCkgewotCQkJdGhyb3cgdGhpcy5pb29iZShpbmRleCwgMSk7Ci0JCX0KLQkJcmV0dXJuIHRoaXMudmFsdWU7Ci0JfQotCi0JcHJvdGVjdGVkIHN0YXRpYyBmaW5hbCBPYmplY3RbXSBFTVBUWV9PQkpFQ1RfQVJSQVkgPSBuZXcgT2JqZWN0WzBdOwotCXB1YmxpYyBPYmplY3RbXSB0b0FycmF5KCkgewotCQlyZXR1cm4gKHRoaXMudmFsdWUgPT0gbnVsbCkgPyBFTVBUWV9PQkpFQ1RfQVJSQVkgOiBuZXcgT2JqZWN0W10ge3RoaXMudmFsdWV9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBleHRlbmQgY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JLyoqCi0JICogT3ZlcnJpZGUgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSB2YWx1ZSBob2xkZXIgaWYgbmVjZXNzYXJ5LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGFkZExpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJaWYgKHRoaXMuaGFzTm9MaXN0ZW5lcnMoKSkgewotCQkJdGhpcy5lbmdhZ2VNb2RlbCgpOwotCQl9Ci0JCXN1cGVyLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogT3ZlcnJpZGUgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSB2YWx1ZSBob2xkZXIgaWYgbmVjZXNzYXJ5LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGFkZExpc3RDaGFuZ2VMaXN0ZW5lcihTdHJpbmcgbGlzdE5hbWUsIExpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlpZiAobGlzdE5hbWUgPT0gTElTVF9WQUxVRVMgJiYgdGhpcy5oYXNOb0xpc3RlbmVycygpKSB7Ci0JCQl0aGlzLmVuZ2FnZU1vZGVsKCk7Ci0JCX0KLQkJc3VwZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKGxpc3ROYW1lLCBsaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogT3ZlcnJpZGUgdG8gc3RvcCBsaXN0ZW5pbmcgdG8gdGhlIHZhbHVlIGhvbGRlciBpZiBhcHByb3ByaWF0ZS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCByZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXN1cGVyLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWlmICh0aGlzLmhhc05vTGlzdGVuZXJzKCkpIHsKLQkJCXRoaXMuZGlzZW5nYWdlTW9kZWwoKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIE92ZXJyaWRlIHRvIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSB2YWx1ZSBob2xkZXIgaWYgYXBwcm9wcmlhdGUuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgcmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKFN0cmluZyBsaXN0TmFtZSwgTGlzdENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXN1cGVyLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihsaXN0TmFtZSwgbGlzdGVuZXIpOwotCQlpZiAobGlzdE5hbWUgPT0gTElTVF9WQUxVRVMgJiYgdGhpcy5oYXNOb0xpc3RlbmVycygpKSB7Ci0JCQl0aGlzLmRpc2VuZ2FnZU1vZGVsKCk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogcXVlcmllcyAqKioqKioqKioqCi0KLQlwcm90ZWN0ZWQgYm9vbGVhbiBoYXNMaXN0ZW5lcnMoKSB7Ci0JCXJldHVybiB0aGlzLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTElTVF9WQUxVRVMpOwotCX0KLQotCXByb3RlY3RlZCBib29sZWFuIGhhc05vTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gISB0aGlzLmhhc0xpc3RlbmVycygpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQlwcm90ZWN0ZWQgSW5kZXhPdXRPZkJvdW5kc0V4Y2VwdGlvbiBpb29iZShpbnQgaW5kZXgsIGludCBzaXplKSB7Ci0JCXJldHVybiBuZXcgSW5kZXhPdXRPZkJvdW5kc0V4Y2VwdGlvbigiSW5kZXg6ICIgKyBpbmRleCArICIsIFNpemU6ICIgKyBzaXplKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VNb2RlbCgpIHsKLQkJdGhpcy52YWx1ZUhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5wcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKTsKLQkJLy8gc3luY2ggb3VyIHZhbHVlICphZnRlciogd2Ugc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSB2YWx1ZSBob2xkZXIsCi0JCS8vIHNpbmNlIGl0cyB2YWx1ZSBtaWdodCBjaGFuZ2Ugd2hlbiBhIGxpc3RlbmVyIGlzIGFkZGVkCi0JCXRoaXMudmFsdWUgPSB0aGlzLnZhbHVlSG9sZGVyLmdldFZhbHVlKCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZGlzZW5nYWdlTW9kZWwoKSB7Ci0JCXRoaXMudmFsdWVIb2xkZXIucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMucHJvcGVydHlDaGFuZ2VMaXN0ZW5lcik7Ci0JCS8vIGNsZWFyIG91dCB0aGUgdmFsdWUgd2hlbiB3ZSBhcmUgbm90IGxpc3RlbmluZyB0byB0aGUgdmFsdWUgaG9sZGVyCi0JCXRoaXMudmFsdWUgPSBudWxsOwotCX0KLQotCS8qKgotCSAqIHN5bmNocm9uaXplIG91ciBpbnRlcm5hbCB2YWx1ZSB3aXRoIHRoZSB3cmFwcGVkIHZhbHVlCi0JICogYW5kIGZpcmUgdGhlIGFwcHJvcHJpYXRlIGV2ZW50cwotCSAqLwotCXByb3RlY3RlZCB2b2lkIHZhbHVlQ2hhbmdlZChFIG5ld1ZhbHVlKSB7Ci0JCUUgb2xkVmFsdWUgPSB0aGlzLnZhbHVlOwotCQl0aGlzLnZhbHVlID0gbmV3VmFsdWU7Ci0JCWlmIChvbGRWYWx1ZSA9PSBudWxsKSB7Ci0JCQl0aGlzLmZpcmVJdGVtQWRkZWQoTElTVF9WQUxVRVMsIDAsIG5ld1ZhbHVlKTsKLQkJfSBlbHNlIHsKLQkJCWlmIChuZXdWYWx1ZSA9PSBudWxsKSB7Ci0JCQkJdGhpcy5maXJlSXRlbVJlbW92ZWQoTElTVF9WQUxVRVMsIDAsIG9sZFZhbHVlKTsKLQkJCX0gZWxzZSB7Ci0JCQkJdGhpcy5maXJlSXRlbVJlcGxhY2VkKExJU1RfVkFMVUVTLCAwLCBuZXdWYWx1ZSwgb2xkVmFsdWUpOwotCQkJfQotCQl9Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgdG9TdHJpbmcoU3RyaW5nQnVpbGRlciBzYikgewotCQlzYi5hcHBlbmQodGhpcy52YWx1ZUhvbGRlcik7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvUHJvcGVydHlWYWx1ZU1vZGVsV3JhcHBlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1Byb3BlcnR5VmFsdWVNb2RlbFdyYXBwZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzUxOTVhZi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvUHJvcGVydHlWYWx1ZU1vZGVsV3JhcHBlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTQ1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkNoYW5nZVN1cHBvcnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuU2luZ2xlQXNwZWN0Q2hhbmdlU3VwcG9ydDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Qcm9wZXJ0eUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIFRoaXMgYWJzdHJhY3QgY2xhc3MgcHJvdmlkZXMgdGhlIGluZnJhc3RydWN0dXJlIG5lZWRlZCB0byB3cmFwCi0gKiBhbm90aGVyIHByb3BlcnR5IHZhbHVlIG1vZGVsLCAibGF6aWx5IiBsaXN0ZW4gdG8gaXQsIGFuZCBwcm9wYWdhdGUKLSAqIGl0cyBjaGFuZ2Ugbm90aWZpY2F0aW9ucy4KLSAqLwotcHVibGljIGFic3RyYWN0IGNsYXNzIFByb3BlcnR5VmFsdWVNb2RlbFdyYXBwZXI8VD4KLQlleHRlbmRzIEFic3RyYWN0TW9kZWwKLXsKLQotCS8qKiBUaGUgd3JhcHBlZCBwcm9wZXJ0eSB2YWx1ZSBtb2RlbC4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBUPiB2YWx1ZUhvbGRlcjsKLQotCS8qKiBBIGxpc3RlbmVyIHRoYXQgYWxsb3dzIHVzIHRvIHN5bmNoIHdpdGggY2hhbmdlcyB0byB0aGUgd3JhcHBlZCB2YWx1ZSBob2xkZXIuICovCi0JcHJvdGVjdGVkIGZpbmFsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgdmFsdWVDaGFuZ2VMaXN0ZW5lcjsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMvaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgcHJvcGVydHkgdmFsdWUgbW9kZWwgd2l0aCB0aGUgc3BlY2lmaWVkIHdyYXBwZWQKLQkgKiBwcm9wZXJ0eSB2YWx1ZSBtb2RlbC4gVGhlIHZhbHVlIGhvbGRlciBpcyByZXF1aXJlZC4KLQkgKi8KLQlwcm90ZWN0ZWQgUHJvcGVydHlWYWx1ZU1vZGVsV3JhcHBlcihQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFQ+IHZhbHVlSG9sZGVyKSB7Ci0JCXN1cGVyKCk7Ci0JCWlmICh2YWx1ZUhvbGRlciA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLnZhbHVlSG9sZGVyID0gdmFsdWVIb2xkZXI7Ci0JCXRoaXMudmFsdWVDaGFuZ2VMaXN0ZW5lciA9IHRoaXMuYnVpbGRWYWx1ZUNoYW5nZUxpc3RlbmVyKCk7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBDaGFuZ2VTdXBwb3J0IGJ1aWxkQ2hhbmdlU3VwcG9ydCgpIHsKLQkJcmV0dXJuIG5ldyBTaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0KHRoaXMsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIuY2xhc3MsIFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSk7Ci0JfQotCi0JcHJvdGVjdGVkIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGRWYWx1ZUNoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCVByb3BlcnR5VmFsdWVNb2RlbFdyYXBwZXIudGhpcy52YWx1ZUNoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkgICAgQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAidmFsdWUgY2hhbmdlIGxpc3RlbmVyIjsgLy8kTk9OLU5MUy0xJAotCQkJfQotCQl9OwotCX0KLQkKLQotCS8vICoqKioqKioqKiogZXh0ZW5kIGNoYW5nZSBzdXBwb3J0ICoqKioqKioqKioKLQotCS8qKgotCSAqIEV4dGVuZCB0byBzdGFydCBsaXN0ZW5pbmcgdG8gdGhlIG5lc3RlZCBtb2RlbCBpZiBuZWNlc3NhcnkuCi0JICovCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIGFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlpZiAodGhpcy5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpIHsKLQkJCXRoaXMuZW5nYWdlVmFsdWVIb2xkZXIoKTsKLQkJfQotCQlzdXBlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQl9Ci0JCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0YXJ0IGxpc3RlbmluZyB0byB0aGUgbmVzdGVkIG1vZGVsIGlmIG5lY2Vzc2FyeS4KLQkgKi8KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihTdHJpbmcgcHJvcGVydHlOYW1lLCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCWlmIChwcm9wZXJ0eU5hbWUgPT0gUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFICYmIHRoaXMuaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKSB7Ci0JCQl0aGlzLmVuZ2FnZVZhbHVlSG9sZGVyKCk7Ci0JCX0KLQkJc3VwZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihwcm9wZXJ0eU5hbWUsIGxpc3RlbmVyKTsKLQl9Ci0JCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSBuZXN0ZWQgbW9kZWwgaWYgbmVjZXNzYXJ5LgotCSAqLwotICAgIEBPdmVycmlkZQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCByZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJc3VwZXIucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWlmICh0aGlzLmhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSkgewotCQkJdGhpcy5kaXNlbmdhZ2VWYWx1ZUhvbGRlcigpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIEV4dGVuZCB0byBzdG9wIGxpc3RlbmluZyB0byB0aGUgbmVzdGVkIG1vZGVsIGlmIG5lY2Vzc2FyeS4KLQkgKi8KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgcmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihTdHJpbmcgcHJvcGVydHlOYW1lLCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXN1cGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIocHJvcGVydHlOYW1lLCBsaXN0ZW5lcik7Ci0JCWlmIChwcm9wZXJ0eU5hbWUgPT0gUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFICYmIHRoaXMuaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKSB7Ci0JCQl0aGlzLmRpc2VuZ2FnZVZhbHVlSG9sZGVyKCk7Ci0JCX0KLQl9Ci0JCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQkKLQkvKioKLQkgKiBCZWdpbiBsaXN0ZW5pbmcgdG8gdGhlIHZhbHVlIGhvbGRlci4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VWYWx1ZUhvbGRlcigpIHsKLQkJdGhpcy52YWx1ZUhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy52YWx1ZUNoYW5nZUxpc3RlbmVyKTsKLQl9Ci0JCi0JLyoqCi0JICogU3RvcCBsaXN0ZW5pbmcgdG8gdGhlIHZhbHVlIGhvbGRlci4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VWYWx1ZUhvbGRlcigpIHsKLQkJdGhpcy52YWx1ZUhvbGRlci5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy52YWx1ZUNoYW5nZUxpc3RlbmVyKTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgdG9TdHJpbmcoU3RyaW5nQnVpbGRlciBzYikgewotCQlzYi5hcHBlbmQodGhpcy52YWx1ZUhvbGRlcik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHByb3BlcnR5IGNoYW5nZSBzdXBwb3J0ICoqKioqKioqKioKLQotCS8qKgotCSAqIFRoZSB2YWx1ZSBvZiB0aGUgd3JhcHBlZCB2YWx1ZSBob2xkZXIgaGFzIGNoYW5nZWQ7Ci0JICogcHJvcGFnYXRlIHRoZSBjaGFuZ2Ugbm90aWZpY2F0aW9uIGFwcHJvcHJpYXRlbHkuCi0JICovCi0JcHJvdGVjdGVkIGFic3RyYWN0IHZvaWQgdmFsdWVDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpOwotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlNjFjNTExLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTgzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkhhc2hCYWc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5DaGFuZ2VTdXBwb3J0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLlNpbmdsZUFzcGVjdENoYW5nZVN1cHBvcnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotCi0vKioKLSAqIEltcGxlbWVudGF0aW9uIG9mIENvbGxlY3Rpb25WYWx1ZU1vZGVsIGFuZCBDb2xsZWN0aW9uIHRoYXQgc2ltcGx5IGhvbGRzIGEKLSAqIGNvbGxlY3Rpb24gYW5kIG5vdGlmaWVzIGxpc3RlbmVycyBvZiBhbnkgY2hhbmdlcy4KLSAqLwotcHVibGljIGNsYXNzIFNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPEU+Ci0JZXh0ZW5kcyBBYnN0cmFjdE1vZGVsCi0JaW1wbGVtZW50cyBDb2xsZWN0aW9uVmFsdWVNb2RlbDxFPiwgQ29sbGVjdGlvbjxFPgotewotCS8qKiBUaGUgY29sbGVjdGlvbi4gKi8KLQlwcm90ZWN0ZWQgQ29sbGVjdGlvbjxFPiBjb2xsZWN0aW9uOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBDb2xsZWN0aW9uVmFsdWVNb2RlbCBmb3IgdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uLgotCSAqLwotCXB1YmxpYyBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbChDb2xsZWN0aW9uPEU+IGNvbGxlY3Rpb24pIHsKLQkJc3VwZXIoKTsKLQkJaWYgKGNvbGxlY3Rpb24gPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy5jb2xsZWN0aW9uID0gY29sbGVjdGlvbjsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBDb2xsZWN0aW9uVmFsdWVNb2RlbCB3aXRoIGFuIGVtcHR5IGluaXRpYWwgY29sbGVjdGlvbi4KLQkgKi8KLQlwdWJsaWMgU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWwoKSB7Ci0JCXRoaXMobmV3IEhhc2hCYWc8RT4oKSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIENoYW5nZVN1cHBvcnQgYnVpbGRDaGFuZ2VTdXBwb3J0KCkgewotCQlyZXR1cm4gbmV3IFNpbmdsZUFzcGVjdENoYW5nZVN1cHBvcnQodGhpcywgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyLmNsYXNzLCBWQUxVRVMpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBDb2xsZWN0aW9uVmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgSXRlcmF0b3I8RT4gaXRlcmF0b3IoKSB7Ci0JCXJldHVybiBuZXcgTG9jYWxJdGVyYXRvcjxFPih0aGlzLmNvbGxlY3Rpb24uaXRlcmF0b3IoKSk7Ci0JfQotCi0JcHVibGljIGludCBzaXplKCkgewotCQlyZXR1cm4gdGhpcy5jb2xsZWN0aW9uLnNpemUoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogQ29sbGVjdGlvbiBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgYm9vbGVhbiBpc0VtcHR5KCkgewotCQlyZXR1cm4gdGhpcy5jb2xsZWN0aW9uLmlzRW1wdHkoKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBjb250YWlucyhPYmplY3QgbykgewotCQlyZXR1cm4gdGhpcy5jb2xsZWN0aW9uLmNvbnRhaW5zKG8pOwotCX0KLQotCXB1YmxpYyBPYmplY3RbXSB0b0FycmF5KCkgewotCQlyZXR1cm4gdGhpcy5jb2xsZWN0aW9uLnRvQXJyYXkoKTsKLQl9Ci0KLQlwdWJsaWMgPFQgZXh0ZW5kcyBPYmplY3Q+IFRbXSB0b0FycmF5KFRbXSBhKSB7Ci0JCXJldHVybiB0aGlzLmNvbGxlY3Rpb24udG9BcnJheShhKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBhZGQoRSBvKSB7Ci0JCXJldHVybiB0aGlzLmFkZEl0ZW1Ub0NvbGxlY3Rpb24obywgdGhpcy5jb2xsZWN0aW9uLCBWQUxVRVMpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIHJlbW92ZShPYmplY3QgbykgewotCQlyZXR1cm4gdGhpcy5yZW1vdmVJdGVtRnJvbUNvbGxlY3Rpb24obywgdGhpcy5jb2xsZWN0aW9uLCBWQUxVRVMpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGNvbnRhaW5zQWxsKENvbGxlY3Rpb248Pz4gYykgewotCQlyZXR1cm4gdGhpcy5jb2xsZWN0aW9uLmNvbnRhaW5zQWxsKGMpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGFkZEFsbChDb2xsZWN0aW9uPD8gZXh0ZW5kcyBFPiBjKSB7Ci0JCXJldHVybiB0aGlzLmFkZEl0ZW1zVG9Db2xsZWN0aW9uKGMsIHRoaXMuY29sbGVjdGlvbiwgVkFMVUVTKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiByZW1vdmVBbGwoQ29sbGVjdGlvbjw/PiBjKSB7Ci0JCXJldHVybiB0aGlzLnJlbW92ZUl0ZW1zRnJvbUNvbGxlY3Rpb24oYywgdGhpcy5jb2xsZWN0aW9uLCBWQUxVRVMpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIHJldGFpbkFsbChDb2xsZWN0aW9uPD8+IGMpIHsKLQkJcmV0dXJuIHRoaXMucmV0YWluSXRlbXNJbkNvbGxlY3Rpb24oYywgdGhpcy5jb2xsZWN0aW9uLCBWQUxVRVMpOwotCX0KLQotCXB1YmxpYyB2b2lkIGNsZWFyKCkgewotCQl0aGlzLmNsZWFyQ29sbGVjdGlvbih0aGlzLmNvbGxlY3Rpb24sIFZBTFVFUyk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIGJvb2xlYW4gZXF1YWxzKE9iamVjdCBvKSB7Ci0JCWlmIChvID09IHRoaXMpIHsKLQkJCXJldHVybiB0cnVlOwotCQl9Ci0JCWlmICgobyBpbnN0YW5jZW9mIENvbGxlY3Rpb24pICYmIChvIGluc3RhbmNlb2YgQ29sbGVjdGlvblZhbHVlTW9kZWwpKSB7Ci0JCQlDb2xsZWN0aW9uPEU+IGMxID0gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24odGhpcy5jb2xsZWN0aW9uKTsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJQ29sbGVjdGlvbjxFPiBjMiA9IENvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKCgoQ29sbGVjdGlvbjxFPikgbykuaXRlcmF0b3IoKSk7Ci0JCQlyZXR1cm4gYzEuZXF1YWxzKGMyKTsKLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIGludCBoYXNoQ29kZSgpIHsKLQkJcmV0dXJuIENvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKHRoaXMuY29sbGVjdGlvbikuaGFzaENvZGUoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYWRkaXRpb25hbCBiZWhhdmlvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBBbGxvdyB0aGUgY29sbGVjdGlvbiB0byBiZSByZXBsYWNlZC4KLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRDb2xsZWN0aW9uKENvbGxlY3Rpb248RT4gY29sbGVjdGlvbikgewotCQlpZiAoY29sbGVjdGlvbiA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLmNvbGxlY3Rpb24gPSBjb2xsZWN0aW9uOwotCQl0aGlzLmZpcmVDb2xsZWN0aW9uQ2hhbmdlZChWQUxVRVMpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHRvU3RyaW5nKFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJc2IuYXBwZW5kKHRoaXMuY29sbGVjdGlvbik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGl0ZXJhdG9yICoqKioqKioqKioKLQotCXByaXZhdGUgY2xhc3MgTG9jYWxJdGVyYXRvcjxUPiBpbXBsZW1lbnRzIEl0ZXJhdG9yPFQ+IHsKLQkJcHJpdmF0ZSBmaW5hbCBJdGVyYXRvcjxUPiBpdGVyYXRvcjsKLQkJcHJpdmF0ZSBUIG5leHQ7Ci0KLQkJTG9jYWxJdGVyYXRvcihJdGVyYXRvcjxUPiBpdGVyYXRvcikgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMuaXRlcmF0b3IgPSBpdGVyYXRvcjsKLQkJfQotCi0JCXB1YmxpYyBib29sZWFuIGhhc05leHQoKSB7Ci0JCQlyZXR1cm4gdGhpcy5pdGVyYXRvci5oYXNOZXh0KCk7Ci0JCX0KLQotCQlwdWJsaWMgVCBuZXh0KCkgewotCQkJcmV0dXJuIHRoaXMubmV4dCA9IHRoaXMuaXRlcmF0b3IubmV4dCgpOwotCQl9Ci0KLQkJQFN1cHByZXNzV2FybmluZ3MoInN5bnRoZXRpYy1hY2Nlc3MiKQotCQlwdWJsaWMgdm9pZCByZW1vdmUoKSB7Ci0JCQl0aGlzLml0ZXJhdG9yLnJlbW92ZSgpOwotCQkJU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWwudGhpcy5maXJlSXRlbVJlbW92ZWQoVkFMVUVTLCB0aGlzLm5leHQpOwotCQl9Ci0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TaW1wbGVMaXN0VmFsdWVNb2RlbC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1NpbXBsZUxpc3RWYWx1ZU1vZGVsLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGU2YWNhNjEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1NpbXBsZUxpc3RWYWx1ZU1vZGVsLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzMTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQ2hhbmdlU3VwcG9ydDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5TaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkxpc3RDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBJbXBsZW1lbnRhdGlvbiBvZiBMaXN0VmFsdWVNb2RlbCBhbmQgTGlzdCB0aGF0IHNpbXBseSBob2xkcyBhCi0gKiBjb2xsZWN0aW9uIGFuZCBub3RpZmllcyBsaXN0ZW5lcnMgb2YgYW55IGNoYW5nZXMuCi0gKi8KLXB1YmxpYyBjbGFzcyBTaW1wbGVMaXN0VmFsdWVNb2RlbDxFPgotCWV4dGVuZHMgQWJzdHJhY3RNb2RlbAotCWltcGxlbWVudHMgTGlzdFZhbHVlTW9kZWw8RT4sIExpc3Q8RT4KLXsKLQkvKiogVGhlIGxpc3QuICovCi0JcHJvdGVjdGVkIExpc3Q8RT4gbGlzdDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgTGlzdFZhbHVlTW9kZWwgZm9yIHRoZSBzcGVjaWZpZWQgbGlzdC4KLQkgKi8KLQlwdWJsaWMgU2ltcGxlTGlzdFZhbHVlTW9kZWwoTGlzdDxFPiBsaXN0KSB7Ci0JCXN1cGVyKCk7Ci0JCWlmIChsaXN0ID09IG51bGwpIHsKLQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigpOwotCQl9Ci0JCXRoaXMubGlzdCA9IGxpc3Q7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgTGlzdFZhbHVlTW9kZWwgd2l0aCBhbiBlbXB0eSBpbml0aWFsIGxpc3QuCi0JICovCi0JcHVibGljIFNpbXBsZUxpc3RWYWx1ZU1vZGVsKCkgewotCQl0aGlzKG5ldyBBcnJheUxpc3Q8RT4oKSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIENoYW5nZVN1cHBvcnQgYnVpbGRDaGFuZ2VTdXBwb3J0KCkgewotCQlyZXR1cm4gbmV3IFNpbmdsZUFzcGVjdENoYW5nZVN1cHBvcnQodGhpcywgTGlzdENoYW5nZUxpc3RlbmVyLmNsYXNzLCBMSVNUX1ZBTFVFUyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIExpc3RWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBJdGVyYXRvcjxFPiBpdGVyYXRvcigpIHsKLQkJcmV0dXJuIG5ldyBMb2NhbEl0ZXJhdG9yPEU+KHRoaXMubGlzdC5pdGVyYXRvcigpKTsKLQl9Ci0KLQlwdWJsaWMgTGlzdEl0ZXJhdG9yPEU+IGxpc3RJdGVyYXRvcigpIHsKLQkJcmV0dXJuIG5ldyBMb2NhbExpc3RJdGVyYXRvcjxFPih0aGlzLmxpc3QubGlzdEl0ZXJhdG9yKCkpOwotCX0KLQotCXB1YmxpYyBpbnQgc2l6ZSgpIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5zaXplKCk7Ci0JfQotCi0JcHVibGljIEUgZ2V0KGludCBpbmRleCkgewotCQlyZXR1cm4gdGhpcy5saXN0LmdldChpbmRleCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIExpc3QgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIGJvb2xlYW4gaXNFbXB0eSgpIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5pc0VtcHR5KCk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gY29udGFpbnMoT2JqZWN0IG8pIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5jb250YWlucyhvKTsKLQl9Ci0KLQlwdWJsaWMgT2JqZWN0W10gdG9BcnJheSgpIHsKLQkJcmV0dXJuIHRoaXMubGlzdC50b0FycmF5KCk7Ci0JfQotCi0JcHVibGljIDxUIGV4dGVuZHMgT2JqZWN0PiBUW10gdG9BcnJheShUW10gYSkgewotCQlyZXR1cm4gdGhpcy5saXN0LnRvQXJyYXkoYSk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gYWRkKEUgbykgewotCQlyZXR1cm4gdGhpcy5hZGRJdGVtVG9MaXN0KG8sIHRoaXMubGlzdCwgTElTVF9WQUxVRVMpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIHJlbW92ZShPYmplY3QgbykgewotCQlyZXR1cm4gdGhpcy5yZW1vdmVJdGVtRnJvbUxpc3QobywgdGhpcy5saXN0LCBMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gY29udGFpbnNBbGwoQ29sbGVjdGlvbjw/PiBjKSB7Ci0JCXJldHVybiB0aGlzLmxpc3QuY29udGFpbnNBbGwoYyk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gYWRkQWxsKENvbGxlY3Rpb248PyBleHRlbmRzIEU+IGMpIHsKLQkJcmV0dXJuIHRoaXMuYWRkSXRlbXNUb0xpc3QoYywgdGhpcy5saXN0LCBMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gYWRkQWxsKGludCBpbmRleCwgQ29sbGVjdGlvbjw/IGV4dGVuZHMgRT4gYykgewotCQlyZXR1cm4gdGhpcy5hZGRJdGVtc1RvTGlzdChpbmRleCwgYywgdGhpcy5saXN0LCBMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gcmVtb3ZlQWxsKENvbGxlY3Rpb248Pz4gYykgewotCQlyZXR1cm4gdGhpcy5yZW1vdmVJdGVtc0Zyb21MaXN0KGMsIHRoaXMubGlzdCwgTElTVF9WQUxVRVMpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIHJldGFpbkFsbChDb2xsZWN0aW9uPD8+IGMpIHsKLQkJcmV0dXJuIHRoaXMucmV0YWluSXRlbXNJbkxpc3QoYywgdGhpcy5saXN0LCBMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JcHVibGljIHZvaWQgY2xlYXIoKSB7Ci0JCXRoaXMuY2xlYXJMaXN0KHRoaXMubGlzdCwgTElTVF9WQUxVRVMpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBib29sZWFuIGVxdWFscyhPYmplY3QgbykgewotCQlpZiAobyA9PSB0aGlzKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCQlpZiAoKG8gaW5zdGFuY2VvZiBMaXN0KSAmJiAobyBpbnN0YW5jZW9mIExpc3RWYWx1ZU1vZGVsKSkgewotCQkJTGlzdDxFPiBsMSA9IENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMubGlzdCk7Ci0JCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJCUxpc3Q8RT4gbDIgPSBDb2xsZWN0aW9uVG9vbHMubGlzdCgoKExpc3Q8RT4pIG8pLml0ZXJhdG9yKCkpOwotCQkJcmV0dXJuIGwxLmVxdWFscyhsMik7Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBpbnQgaGFzaENvZGUoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3QuaGFzaENvZGUoKTsKLQl9Ci0KLQlwdWJsaWMgRSBzZXQoaW50IGluZGV4LCBFIGVsZW1lbnQpIHsKLQkJcmV0dXJuIHRoaXMuc2V0SXRlbUluTGlzdChpbmRleCwgZWxlbWVudCwgdGhpcy5saXN0LCBMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JcHVibGljIHZvaWQgYWRkKGludCBpbmRleCwgRSBlbGVtZW50KSB7Ci0JCXRoaXMuYWRkSXRlbVRvTGlzdChpbmRleCwgZWxlbWVudCwgdGhpcy5saXN0LCBMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JcHVibGljIEUgcmVtb3ZlKGludCBpbmRleCkgewotCQlyZXR1cm4gdGhpcy5yZW1vdmVJdGVtRnJvbUxpc3QoaW5kZXgsIHRoaXMubGlzdCwgTElTVF9WQUxVRVMpOwotCX0KLQotCXB1YmxpYyBpbnQgaW5kZXhPZihPYmplY3QgbykgewotCQlyZXR1cm4gdGhpcy5saXN0LmluZGV4T2Yobyk7Ci0JfQotCi0JcHVibGljIGludCBsYXN0SW5kZXhPZihPYmplY3QgbykgewotCQlyZXR1cm4gdGhpcy5saXN0Lmxhc3RJbmRleE9mKG8pOwotCX0KLQotCXB1YmxpYyBMaXN0SXRlcmF0b3I8RT4gbGlzdEl0ZXJhdG9yKGludCBpbmRleCkgewotCQlyZXR1cm4gbmV3IExvY2FsTGlzdEl0ZXJhdG9yPEU+KHRoaXMubGlzdC5saXN0SXRlcmF0b3IoaW5kZXgpKTsKLQl9Ci0KLQlwdWJsaWMgTGlzdDxFPiBzdWJMaXN0KGludCBmcm9tSW5kZXgsIGludCB0b0luZGV4KSB7Ci0JCS8vIFRPRE8gaG1tbSAgfmJqdgotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYWRkaXRpb25hbCBiZWhhdmlvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBBbGxvdyB0aGUgbGlzdCB0byBiZSByZXBsYWNlZC4KLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRMaXN0KExpc3Q8RT4gbGlzdCkgewotCQlpZiAobGlzdCA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLmxpc3QgPSBsaXN0OwotCQl0aGlzLmZpcmVMaXN0Q2hhbmdlZChMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JLyoqCi0JICogTW92ZSBhIHNpbmdsZSBlbGVtZW50LgotCSAqLwotCXB1YmxpYyB2b2lkIG1vdmUoaW50IHRhcmdldEluZGV4LCBpbnQgc291cmNlSW5kZXgpIHsKLQkJdGhpcy5tb3ZlSXRlbUluTGlzdCh0YXJnZXRJbmRleCwgc291cmNlSW5kZXgsIHRoaXMubGlzdCwgTElTVF9WQUxVRVMpOwotCX0KLQotCS8qKgotCSAqIE1vdmUgYSBzdWItbGlzdCBvZiBlbGVtZW50cy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBtb3ZlKGludCB0YXJnZXRJbmRleCwgaW50IHNvdXJjZUluZGV4LCBpbnQgbGVuZ3RoKSB7Ci0JCXRoaXMubW92ZUl0ZW1zSW5MaXN0KHRhcmdldEluZGV4LCBzb3VyY2VJbmRleCwgbGVuZ3RoLCB0aGlzLmxpc3QsIExJU1RfVkFMVUVTKTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgYSByYW5nZSBvZiBlbGVtZW50cy4KLQkgKi8KLQlwdWJsaWMgdm9pZCByZW1vdmUoaW50IGluZGV4LCBpbnQgbGVuZ3RoKSB7Ci0JCXRoaXMucmVtb3ZlSXRlbXNGcm9tTGlzdChpbmRleCwgbGVuZ3RoLCB0aGlzLmxpc3QsIExJU1RfVkFMVUVTKTsKLQl9Ci0KLQkvKioKLQkgKiBTZXQgYSByYW5nZSBvZiBlbGVtZW50cy4KLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXQoaW50IGluZGV4LCBMaXN0PEU+IGVsZW1lbnRzKSB7Ci0JCXRoaXMuc2V0SXRlbXNJbkxpc3QoaW5kZXgsIGVsZW1lbnRzLCB0aGlzLmxpc3QsIExJU1RfVkFMVUVTKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0b1N0cmluZyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXNiLmFwcGVuZCh0aGlzLmxpc3QpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpdGVyYXRvcnMgKioqKioqKioqKgotCi0JcHJpdmF0ZSBjbGFzcyBMb2NhbEl0ZXJhdG9yPFQ+IGltcGxlbWVudHMgSXRlcmF0b3I8VD4gewotCQlwcml2YXRlIGZpbmFsIEl0ZXJhdG9yPFQ+IGl0ZXJhdG9yOwotCQlwcml2YXRlIGludCBpbmRleCA9IC0xOwotCQlwcml2YXRlIFQgbmV4dDsKLQotCQlMb2NhbEl0ZXJhdG9yKEl0ZXJhdG9yPFQ+IGl0ZXJhdG9yKSB7Ci0JCQlzdXBlcigpOwotCQkJdGhpcy5pdGVyYXRvciA9IGl0ZXJhdG9yOwotCQl9Ci0KLQkJcHVibGljIGJvb2xlYW4gaGFzTmV4dCgpIHsKLQkJCXJldHVybiB0aGlzLml0ZXJhdG9yLmhhc05leHQoKTsKLQkJfQotCi0JCXB1YmxpYyBUIG5leHQoKSB7Ci0JCQl0aGlzLm5leHQgPSB0aGlzLml0ZXJhdG9yLm5leHQoKTsKLQkJCXRoaXMuaW5kZXgrKzsKLQkJCXJldHVybiB0aGlzLm5leHQ7Ci0JCX0KLQotCQlAU3VwcHJlc3NXYXJuaW5ncygic3ludGhldGljLWFjY2VzcyIpCi0JCXB1YmxpYyB2b2lkIHJlbW92ZSgpIHsKLQkJCXRoaXMuaXRlcmF0b3IucmVtb3ZlKCk7Ci0JCQlTaW1wbGVMaXN0VmFsdWVNb2RlbC50aGlzLmZpcmVJdGVtUmVtb3ZlZChMSVNUX1ZBTFVFUywgdGhpcy5pbmRleCwgdGhpcy5uZXh0KTsKLQkJfQotCi0JfQotCi0JcHJpdmF0ZSBjbGFzcyBMb2NhbExpc3RJdGVyYXRvcjxUPiBpbXBsZW1lbnRzIExpc3RJdGVyYXRvcjxUPiB7Ci0JCXByaXZhdGUgZmluYWwgTGlzdEl0ZXJhdG9yPFQ+IGl0ZXJhdG9yOwotCQlwcml2YXRlIGludCBsYXN0ID0gLTE7Ci0JCXByaXZhdGUgaW50IG5leHQgPSAwOwotCQlwcml2YXRlIFQgY3VycmVudDsKLQotCQlMb2NhbExpc3RJdGVyYXRvcihMaXN0SXRlcmF0b3I8VD4gaXRlcmF0b3IpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLml0ZXJhdG9yID0gaXRlcmF0b3I7Ci0JCX0KLQotCQlwdWJsaWMgYm9vbGVhbiBoYXNOZXh0KCkgewotCQkJcmV0dXJuIHRoaXMuaXRlcmF0b3IuaGFzTmV4dCgpOwotCQl9Ci0KLQkJcHVibGljIFQgbmV4dCgpIHsKLQkJCXRoaXMuY3VycmVudCA9IHRoaXMuaXRlcmF0b3IubmV4dCgpOwotCQkJdGhpcy5sYXN0ID0gdGhpcy5uZXh0Kys7Ci0JCQlyZXR1cm4gdGhpcy5jdXJyZW50OwotCQl9Ci0KLQkJcHVibGljIGludCBuZXh0SW5kZXgoKSB7Ci0JCQlyZXR1cm4gdGhpcy5pdGVyYXRvci5uZXh0SW5kZXgoKTsKLQkJfQotCi0JCXB1YmxpYyBib29sZWFuIGhhc1ByZXZpb3VzKCkgewotCQkJcmV0dXJuIHRoaXMuaXRlcmF0b3IuaGFzUHJldmlvdXMoKTsKLQkJfQotCi0JCXB1YmxpYyBUIHByZXZpb3VzKCkgewotCQkJdGhpcy5jdXJyZW50ID0gdGhpcy5pdGVyYXRvci5wcmV2aW91cygpOwotCQkJdGhpcy5sYXN0ID0gLS10aGlzLm5leHQ7Ci0JCQlyZXR1cm4gdGhpcy5jdXJyZW50OwotCQl9Ci0KLQkJcHVibGljIGludCBwcmV2aW91c0luZGV4KCkgewotCQkJcmV0dXJuIHRoaXMuaXRlcmF0b3IucHJldmlvdXNJbmRleCgpOwotCQl9Ci0KLQkJQFN1cHByZXNzV2FybmluZ3MoInN5bnRoZXRpYy1hY2Nlc3MiKQotCQlwdWJsaWMgdm9pZCBzZXQoVCBvKSB7Ci0JCQl0aGlzLml0ZXJhdG9yLnNldChvKTsKLQkJCVNpbXBsZUxpc3RWYWx1ZU1vZGVsLnRoaXMuZmlyZUl0ZW1SZXBsYWNlZChMSVNUX1ZBTFVFUywgdGhpcy5sYXN0LCBvLCB0aGlzLmN1cnJlbnQpOwotCQl9Ci0KLQkJQFN1cHByZXNzV2FybmluZ3MoInN5bnRoZXRpYy1hY2Nlc3MiKQotCQlwdWJsaWMgdm9pZCBhZGQoVCBvKSB7Ci0JCQl0aGlzLml0ZXJhdG9yLmFkZChvKTsKLQkJCVNpbXBsZUxpc3RWYWx1ZU1vZGVsLnRoaXMuZmlyZUl0ZW1BZGRlZChMSVNUX1ZBTFVFUywgdGhpcy5uZXh0LCBvKTsKLQkJfQotCi0JCUBTdXBwcmVzc1dhcm5pbmdzKCJzeW50aGV0aWMtYWNjZXNzIikKLQkJcHVibGljIHZvaWQgcmVtb3ZlKCkgewotCQkJdGhpcy5pdGVyYXRvci5yZW1vdmUoKTsKLQkJCVNpbXBsZUxpc3RWYWx1ZU1vZGVsLnRoaXMuZmlyZUl0ZW1SZW1vdmVkKExJU1RfVkFMVUVTLCB0aGlzLmxhc3QsIHRoaXMuY3VycmVudCk7Ci0JCX0KLQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1NpbXBsZVByb3BlcnR5VmFsdWVNb2RlbC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1NpbXBsZVByb3BlcnR5VmFsdWVNb2RlbC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlNzI0OGU2Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDY2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkNoYW5nZVN1cHBvcnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuU2luZ2xlQXNwZWN0Q2hhbmdlU3VwcG9ydDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIEltcGxlbWVudGF0aW9uIG9mIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsIHRoYXQgc2ltcGx5IGhvbGRzIG9uIHRvIGFuCi0gKiBvYmplY3QgYW5kIHVzZXMgaXQgYXMgdGhlIHZhbHVlLgotICovCi1wdWJsaWMgY2xhc3MgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPFQ+Ci0JZXh0ZW5kcyBBYnN0cmFjdE1vZGVsCi0JaW1wbGVtZW50cyBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUPgotewotCS8qKiBUaGUgdmFsdWUuICovCi0JcHJvdGVjdGVkIFQgdmFsdWU7Ci0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIFByb3BlcnR5VmFsdWVNb2RlbCBmb3IgdGhlIHNwZWNpZmllZCB2YWx1ZS4KLQkgKi8KLQlwdWJsaWMgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsKFQgdmFsdWUpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy52YWx1ZSA9IHZhbHVlOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIFByb3BlcnR5VmFsdWVNb2RlbCB3aXRoIGEgc3RhcnRpbmcgdmFsdWUgb2YgbnVsbC4KLQkgKi8KLQlwdWJsaWMgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsKCkgewotCQl0aGlzKG51bGwpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBDaGFuZ2VTdXBwb3J0IGJ1aWxkQ2hhbmdlU3VwcG9ydCgpIHsKLQkJcmV0dXJuIG5ldyBTaW5nbGVBc3BlY3RDaGFuZ2VTdXBwb3J0KHRoaXMsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIuY2xhc3MsIFZBTFVFKTsKLQl9Ci0KLQotCXB1YmxpYyBUIGdldFZhbHVlKCkgewotCQlyZXR1cm4gdGhpcy52YWx1ZTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBzZXRWYWx1ZShUIHZhbHVlKSB7Ci0JCVQgb2xkID0gdGhpcy52YWx1ZTsKLQkJdGhpcy52YWx1ZSA9IHZhbHVlOwotCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoVkFMVUUsIG9sZCwgdmFsdWUpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHRvU3RyaW5nKFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJc2IuYXBwZW5kKHRoaXMudmFsdWUpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1NvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1NvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyMTk0YmE0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Tb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEzMiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbnM7Ci1pbXBvcnQgamF2YS51dGlsLkNvbXBhcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlJhbmdlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LkNvbGxlY3Rpb25DaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBBbiBhZGFwdGVyIHRoYXQgYWxsb3dzIHVzIHRvIG1ha2UgYSA8Y29kZT5Db2xsZWN0aW9uVmFsdWVNb2RlbDwvY29kZT4KLSAqIChvciA8Y29kZT5MaXN0VmFsdWVNb2RlbDwvY29kZT4pIGJlaGF2ZSBsaWtlIGEgPGNvZGU+TGlzdFZhbHVlTW9kZWw8L2NvZGU+Ci0gKiB0aGF0IGtlZXBzIGl0cyBjb250ZW50cyBzb3J0ZWQgYW5kIG5vdGlmaWVzIGxpc3RlbmVycyBhcHByb3ByaWF0ZWx5LgotICogPHA+Ci0gKiBUaGUgY29tcGFyYXRvciBjYW4gYmUgY2hhbmdlZCBhdCBhbnkgdGltZTsgYWxsb3dpbmcgdGhlIHNhbWUKLSAqIGFkYXB0ZXIgdG8gYmUgdXNlZCB3aXRoIGRpZmZlcmVudCBzb3J0IGNyaXRlcmlhIChlLmcuIHdoZW4gdGhlIHVzZXIKLSAqIHdhbnRzIHRvIHNvcnQgYSBsaXN0IG9mIGZpbGVzIGZpcnN0IGJ5IG5hbWUsIHRoZW4gYnkgZGF0ZSwgdGhlbiBieSBzaXplKS4KLSAqIDxwPgotICogTkI6IFNpbmNlIHdlIG9ubHkgbGlzdGVuIHRvIHRoZSB3cmFwcGVkIGNvbGxlY3Rpb24gd2hlbiB3ZSBoYXZlCi0gKiBsaXN0ZW5lcnMgb3Vyc2VsdmVzIGFuZCB3ZSBjYW4gb25seSBzdGF5IGluIHN5bmNoIHdpdGggdGhlIHdyYXBwZWQKLSAqIGNvbGxlY3Rpb24gd2hpbGUgd2UgYXJlIGxpc3RlbmluZyB0byBpdCwgcmVzdWx0cyB0byB2YXJpb3VzIG1ldGhvZHMKLSAqIChlLmcuIDxjb2RlPiNzaXplKCk8L2NvZGU+LCA8Y29kZT4jZ2V0SXRlbShpbnQpPC9jb2RlPikgd2lsbCBiZQotICogdW5wcmVkaWN0YWJsZSB3aGVuZXZlcgotICogd2UgZG8gbm90IGhhdmUgYW55IGxpc3RlbmVycy4gVGhpcyBzaG91bGQgbm90IGJlIHRvbyBwYWluZnVsIHNpbmNlLAotICogbW9zdCBsaWtlbHksIGNsaWVudCBvYmplY3RzIHdpbGwgYWxzbyBiZSBsaXN0ZW5lcnMuCi0gKi8KLXB1YmxpYyBjbGFzcyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8RT4KLQlleHRlbmRzIENvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXI8RT4KLXsKLQkvKioKLQkgKiBBIGNvbXBhcmF0b3IgdXNlZCBmb3Igc29ydGluZyB0aGUgZWxlbWVudHM7Ci0JICogaWYgaXQgaXMgbnVsbCwgd2UgdXNlICJuYXR1cmFsIG9yZGVyaW5nIi4KLQkgKi8KLQlwcm90ZWN0ZWQgQ29tcGFyYXRvcjxFPiBjb21wYXJhdG9yOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBXcmFwIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbiB2YWx1ZSBtb2RlbCBhbmQgc29ydCBpdHMgY29udGVudHMKLQkgKiB1c2luZyB0aGUgc3BlY2lmaWVkIGNvbXBhcmF0b3IuCi0JICovCi0JcHVibGljIFNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcihDb2xsZWN0aW9uVmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gY29sbGVjdGlvbkhvbGRlciwgQ29tcGFyYXRvcjxFPiBjb21wYXJhdG9yKSB7Ci0JCXN1cGVyKGNvbGxlY3Rpb25Ib2xkZXIpOwotCQl0aGlzLmNvbXBhcmF0b3IgPSBjb21wYXJhdG9yOwotCX0KLQotCS8qKgotCSAqIFdyYXAgdGhlIHNwZWNpZmllZCBjb2xsZWN0aW9uIHZhbHVlIG1vZGVsIGFuZCBzb3J0IGl0cyBjb250ZW50cwotCSAqIGJhc2VkIG9uIHRoZSBlbGVtZW50cycgIm5hdHVyYWwgb3JkZXJpbmciLgotCSAqLwotCXB1YmxpYyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXIoQ29sbGVjdGlvblZhbHVlTW9kZWw8PyBleHRlbmRzIEU+IGNvbGxlY3Rpb25Ib2xkZXIpIHsKLQkJdGhpcyhjb2xsZWN0aW9uSG9sZGVyLCBudWxsKTsKLQl9Ci0KLQkvKioKLQkgKiBXcmFwIHRoZSBzcGVjaWZpZWQgbGlzdCB2YWx1ZSBtb2RlbCBhbmQgc29ydCBpdHMgY29udGVudHMKLQkgKiB1c2luZyB0aGUgc3BlY2lmaWVkIGNvbXBhcmF0b3IuCi0JICovCi0JcHVibGljIFNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcihMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gbGlzdEhvbGRlciwgQ29tcGFyYXRvcjxFPiBjb21wYXJhdG9yKSB7Ci0JCXRoaXMobmV3IExpc3RDb2xsZWN0aW9uVmFsdWVNb2RlbEFkYXB0ZXI8RT4obGlzdEhvbGRlciksIGNvbXBhcmF0b3IpOwotCX0KLQotCS8qKgotCSAqIFdyYXAgdGhlIHNwZWNpZmllZCBsaXN0IHZhbHVlIG1vZGVsIGFuZCBzb3J0IGl0cyBjb250ZW50cwotCSAqIGJhc2VkIG9uIHRoZSBlbGVtZW50cycgIm5hdHVyYWwgb3JkZXJpbmciLgotCSAqLwotCXB1YmxpYyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXIoTGlzdFZhbHVlTW9kZWw8PyBleHRlbmRzIEU+IGxpc3RIb2xkZXIpIHsKLQkJdGhpcyhsaXN0SG9sZGVyLCBudWxsKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYWNjZXNzb3JzICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIHNldENvbXBhcmF0b3IoQ29tcGFyYXRvcjxFPiBjb21wYXJhdG9yKSB7Ci0JCXRoaXMuY29tcGFyYXRvciA9IGNvbXBhcmF0b3I7Ci0JCXRoaXMuc29ydExpc3QoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCi0JLyoqCi0JICogU29ydCB0aGUgaW50ZXJuYWwgbGlzdCBiZWZvcmUKLQkgKiBzZW5kaW5nIG91dCBjaGFuZ2Ugbm90aWZpY2F0aW9uLgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHBvc3RCdWlsZExpc3QoKSB7Ci0JCXN1cGVyLnBvc3RCdWlsZExpc3QoKTsKLQkJQ29sbGVjdGlvbnMuc29ydCh0aGlzLmxpc3QsIHRoaXMuY29tcGFyYXRvcik7Ci0JfQotCi0JLyoqCi0JICogdGhlIGxpc3Qgd2lsbCBuZWVkIHRvIGJlIHNvcnRlZCBhZnRlciB0aGUgaXRlbSBpcyBhZGRlZAotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIGZpcnN0IGFkZCB0aGUgaXRlbXMgYW5kIG5vdGlmeSBvdXIgbGlzdGVuZXJzLi4uCi0JCXN1cGVyLml0ZW1zQWRkZWQoZXZlbnQpOwotCQkvLyAuLi50aGVuIHNvcnQgdGhlIGxpc3QKLQkJdGhpcy5zb3J0TGlzdCgpOwotCX0KLQotCS8qKgotCSAqIHNvcnQgdGhlIGxpc3QgYW5kIG5vdGlmeSBvdXIgbGlzdGVuZXJzLCBpZiBuZWNlc3Nhcnk7Ci0JICovCi0JcHJvdGVjdGVkIHZvaWQgc29ydExpc3QoKSB7Ci0JCS8vIHNhdmUgdGhlIHVuc29ydGVkIHN0YXRlIG9mIHRoZSBzb3J0ZWQgbGlzdCBzbyB3ZSBjYW4gbWluaW1pemUgdGhlIG51bWJlciBvZiAicmVwbGFjZWQiIGl0ZW1zCi0JCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlBcnJheUxpc3Q8RT4gdW5zb3J0ZWRMaXN0ID0gKEFycmF5TGlzdDxFPikgdGhpcy5saXN0LmNsb25lKCk7Ci0JCUNvbGxlY3Rpb25zLnNvcnQodGhpcy5saXN0LCB0aGlzLmNvbXBhcmF0b3IpOwotCQlSYW5nZSBkaWZmUmFuZ2UgPSBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmUmFuZ2UodW5zb3J0ZWRMaXN0LCB0aGlzLmxpc3QpOwotCQlpZiAoZGlmZlJhbmdlLnNpemUgPiAwKSB7Ci0JCQlMaXN0PEU+IHVuc29ydGVkSXRlbXMgPSB1bnNvcnRlZExpc3Quc3ViTGlzdChkaWZmUmFuZ2Uuc3RhcnQsIGRpZmZSYW5nZS5lbmQgKyAxKTsKLQkJCUxpc3Q8RT4gc29ydGVkSXRlbXMgPSB0aGlzLmxpc3Quc3ViTGlzdChkaWZmUmFuZ2Uuc3RhcnQsIGRpZmZSYW5nZS5lbmQgKyAxKTsKLQkJCXRoaXMuZmlyZUl0ZW1zUmVwbGFjZWQoTElTVF9WQUxVRVMsIGRpZmZSYW5nZS5zdGFydCwgc29ydGVkSXRlbXMsIHVuc29ydGVkSXRlbXMpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvU3RhdGVQcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvU3RhdGVQcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGRiNmMwYzkuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1N0YXRlUHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTAwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5Nb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5TdGF0ZUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlN0YXRlQ2hhbmdlTGlzdGVuZXI7Ci0KLS8qKgotICogVGhpcyBhYnN0cmFjdCBjbGFzcyBwcm92aWRlcyB0aGUgaW5mcmFzdHJ1Y3R1cmUgbmVlZGVkIHRvIHdyYXAKLSAqIGEgbW9kZWwsICJsYXppbHkiIGxpc3RlbiB0byBpdCwgYW5kIGNvbnZlcnQKLSAqIGl0cyBzdGF0ZSBjaGFuZ2Ugbm90aWZpY2F0aW9ucyBpbnRvIHByb3BlcnR5IHZhbHVlIG1vZGVsIGNoYW5nZQotICogbm90aWZpY2F0aW9ucy4KLSAqIAotICogU3ViY2xhc3NlcyBtdXN0IG92ZXJyaWRlOgotICogLSAjYnVpbGRWYWx1ZSgpCi0gKiAgICAgdG8gcmV0dXJuIHRoZSBjdXJyZW50IHByb3BlcnR5IHZhbHVlLCBhcyBkZXJpdmVkIGZyb20gdGhlCi0gKiAgICAgY3VycmVudCBtb2RlbAotICogCi0gKiBTdWJjbGFzc2VzIG1pZ2h0IHdhbnQgdG8gb3ZlcnJpZGU6Ci0gKiAtICNzdGF0ZUNoYW5nZWQoU3RhdGVDaGFuZ2VFdmVudCBldmVudCkKLSAqICAgICB0byBpbXByb3ZlIHBlcmZvcm1hbmNlIChieSBub3QgcmVjYWxjdWxhdGluZyB0aGUgdmFsdWUsIGlmIHBvc3NpYmxlKQotICovCi1wdWJsaWMgYWJzdHJhY3QgY2xhc3MgU3RhdGVQcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyPFQ+Ci0JZXh0ZW5kcyBBc3BlY3RQcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyPFQ+Ci17Ci0JLyoqIFRoZSB3cmFwcGVkIG1vZGVsLiAqLwotCXByb3RlY3RlZCBmaW5hbCBNb2RlbCBtb2RlbDsKLQotCS8qKiBBIGxpc3RlbmVyIHRoYXQgYWxsb3dzIHVzIHRvIHN5bmNoIHdpdGggY2hhbmdlcyB0byB0aGUgd3JhcHBlZCBtb2RlbC4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgU3RhdGVDaGFuZ2VMaXN0ZW5lciBzdGF0ZUNoYW5nZUxpc3RlbmVyOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9yL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHByb3BlcnR5IHZhbHVlIG1vZGVsIHdpdGggdGhlIHNwZWNpZmllZCB3cmFwcGVkIG1vZGVsLgotCSAqLwotCXByb3RlY3RlZCBTdGF0ZVByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIoTW9kZWwgbW9kZWwpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5tb2RlbCA9IG1vZGVsOwotCQl0aGlzLnN0YXRlQ2hhbmdlTGlzdGVuZXIgPSB0aGlzLmJ1aWxkU3RhdGVDaGFuZ2VMaXN0ZW5lcigpOwotCX0KLQotCXByb3RlY3RlZCBTdGF0ZUNoYW5nZUxpc3RlbmVyIGJ1aWxkU3RhdGVDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBTdGF0ZUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgc3RhdGVDaGFuZ2VkKFN0YXRlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlTdGF0ZVByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIudGhpcy5zdGF0ZUNoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAic3RhdGUgY2hhbmdlIGxpc3RlbmVyIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCi0JLyoqCi0JICogU3RhcnQgbGlzdGVuaW5nIHRvIHRoZSBtb2RlbC4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VNb2RlbF8oKSB7Ci0JCXRoaXMubW9kZWwuYWRkU3RhdGVDaGFuZ2VMaXN0ZW5lcih0aGlzLnN0YXRlQ2hhbmdlTGlzdGVuZXIpOwotCX0KLQotCS8qKgotCSAqIFN0b3AgbGlzdGVuaW5nIHRvIHRoZSBtb2RlbC4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VNb2RlbF8oKSB7Ci0JCXRoaXMubW9kZWwucmVtb3ZlU3RhdGVDaGFuZ2VMaXN0ZW5lcih0aGlzLnN0YXRlQ2hhbmdlTGlzdGVuZXIpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHRvU3RyaW5nKFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJc2IuYXBwZW5kKHRoaXMubW9kZWwpOwotCX0KLQotCQotCS8vICoqKioqKioqKiogc3RhdGUgY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JLyoqCi0JICogVGhlIG1vZGVsJ3Mgc3RhdGUgY2hhbmdlZDsKLQkgKiBwcm9wYWdhdGUgdGhlIGNoYW5nZSBub3RpZmljYXRpb24gYXBwcm9wcmlhdGVseS4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBzdGF0ZUNoYW5nZWQoU3RhdGVDaGFuZ2VFdmVudCBldmVudCkgewotCQkvLyBieSBkZWZhdWx0LCBzaW1wbHkgcmVjYWxjdWxhdGUgdGhlIHZhbHVlIGFuZCBmaXJlIGFuIGV2ZW50Ci0JCXRoaXMucHJvcGVydHlDaGFuZ2VkKCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvU3RhdGljQ29sbGVjdGlvblZhbHVlTW9kZWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TdGF0aWNDb2xsZWN0aW9uVmFsdWVNb2RlbC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxMzY3ODNiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TdGF0aWNDb2xsZWN0aW9uVmFsdWVNb2RlbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuUmVhZE9ubHlJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotCi0vKioKLSAqIEltcGxlbWVudGF0aW9uIG9mIENvbGxlY3Rpb25WYWx1ZU1vZGVsIHRoYXQgY2FuIGJlIHVzZWQgZm9yCi0gKiByZXR1cm5pbmcgYW4gaXRlcmF0b3Igb24gYSBzdGF0aWMgY29sbGVjdGlvbiwgYnV0IHN0aWxsIGFsbG93cyBsaXN0ZW5lcnMgdG8gYmUgYWRkZWQuCi0gKiBMaXN0ZW5lcnMgd2lsbCBORVZFUiBiZSBub3RpZmllZCBvZiBhbnkgY2hhbmdlcywgYmVjYXVzZSB0aGVyZSBzaG91bGQgYmUgbm9uZS4KLSAqLwotcHVibGljIGNsYXNzIFN0YXRpY0NvbGxlY3Rpb25WYWx1ZU1vZGVsPEU+Ci0JZXh0ZW5kcyBBYnN0cmFjdE1vZGVsCi0JaW1wbGVtZW50cyBDb2xsZWN0aW9uVmFsdWVNb2RlbDxFPgotewotCS8qKiBUaGUgY29sbGVjdGlvbi4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgQ29sbGVjdGlvbjw/IGV4dGVuZHMgRT4gY29sbGVjdGlvbjsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDFMOwotCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBzdGF0aWMgQ29sbGVjdGlvblZhbHVlTW9kZWwgZm9yIHRoZSBzcGVjaWZpZWQgYXJyYXkuCi0JICovCi0JcHVibGljIFN0YXRpY0NvbGxlY3Rpb25WYWx1ZU1vZGVsKEVbXSBhcnJheSkgewotCQl0aGlzKENvbGxlY3Rpb25Ub29scy5saXN0KGFycmF5KSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgc3RhdGljIENvbGxlY3Rpb25WYWx1ZU1vZGVsIGZvciB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24uCi0JICovCi0JcHVibGljIFN0YXRpY0NvbGxlY3Rpb25WYWx1ZU1vZGVsKENvbGxlY3Rpb248PyBleHRlbmRzIEU+IGNvbGxlY3Rpb24pIHsKLQkJc3VwZXIoKTsKLQkJaWYgKGNvbGxlY3Rpb24gPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy5jb2xsZWN0aW9uID0gY29sbGVjdGlvbjsKLQl9Ci0KLQkvLyAqKioqKioqKioqIENvbGxlY3Rpb25WYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBpbnQgc2l6ZSgpIHsKLQkJcmV0dXJuIHRoaXMuY29sbGVjdGlvbi5zaXplKCk7Ci0JfQotCi0JcHVibGljIEl0ZXJhdG9yPEU+IGl0ZXJhdG9yKCkgewotCQlyZXR1cm4gbmV3IFJlYWRPbmx5SXRlcmF0b3I8RT4odGhpcy5jb2xsZWN0aW9uLml0ZXJhdG9yKCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBPYmplY3Qgb3ZlcnJpZGVzICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuY29sbGVjdGlvbik7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvU3RhdGljTGlzdFZhbHVlTW9kZWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TdGF0aWNMaXN0VmFsdWVNb2RlbC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMWJjMmZiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TdGF0aWNMaXN0VmFsdWVNb2RlbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5SZWFkT25seUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5SZWFkT25seUxpc3RJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotCi0vKioKLSAqIEltcGxlbWVudGF0aW9uIG9mIExpc3RWYWx1ZU1vZGVsIHRoYXQgY2FuIGJlIHVzZWQgZm9yCi0gKiByZXR1cm5pbmcgYSBsaXN0IGl0ZXJhdG9yIG9uIGEgc3RhdGljIGxpc3QsIGJ1dCBzdGlsbCBhbGxvd3MgbGlzdGVuZXJzIHRvIGJlIGFkZGVkLgotICogTGlzdGVuZXJzIHdpbGwgTkVWRVIgYmUgbm90aWZpZWQgb2YgYW55IGNoYW5nZXMsIGJlY2F1c2UgdGhlcmUgc2hvdWxkIGJlIG5vbmUuCi0gKi8KLXB1YmxpYyBjbGFzcyBTdGF0aWNMaXN0VmFsdWVNb2RlbDxFPgotCWV4dGVuZHMgQWJzdHJhY3RNb2RlbAotCWltcGxlbWVudHMgTGlzdFZhbHVlTW9kZWw8RT4KLXsKLQkvKiogVGhlIHZhbHVlLiAqLwotCXByb3RlY3RlZCBmaW5hbCBMaXN0PD8gZXh0ZW5kcyBFPiBsaXN0OwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHN0YXRpYyBMaXN0VmFsdWVNb2RlbCBmb3IgdGhlIHNwZWNpZmllZCBhcnJheS4KLQkgKi8KLQlwdWJsaWMgU3RhdGljTGlzdFZhbHVlTW9kZWwoRVtdIGFycmF5KSB7Ci0JCXRoaXMoQ29sbGVjdGlvblRvb2xzLmxpc3QoYXJyYXkpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBzdGF0aWMgTGlzdFZhbHVlTW9kZWwgZm9yIHRoZSBzcGVjaWZpZWQgbGlzdC4KLQkgKi8KLQlwdWJsaWMgU3RhdGljTGlzdFZhbHVlTW9kZWwoTGlzdDw/IGV4dGVuZHMgRT4gbGlzdCkgewotCQlzdXBlcigpOwotCQlpZiAobGlzdCA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLmxpc3QgPSBsaXN0OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBMaXN0VmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgSXRlcmF0b3I8RT4gaXRlcmF0b3IoKSB7Ci0JCXJldHVybiBuZXcgUmVhZE9ubHlJdGVyYXRvcjxFPih0aGlzLmxpc3QuaXRlcmF0b3IoKSk7Ci0JfQotCi0JcHVibGljIExpc3RJdGVyYXRvcjxFPiBsaXN0SXRlcmF0b3IoKSB7Ci0JCXJldHVybiBuZXcgUmVhZE9ubHlMaXN0SXRlcmF0b3I8RT4odGhpcy5saXN0Lmxpc3RJdGVyYXRvcigpKTsKLQl9Ci0KLQlwdWJsaWMgaW50IHNpemUoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3Quc2l6ZSgpOwotCX0KLQotCXB1YmxpYyBFIGdldChpbnQgaW5kZXgpIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5nZXQoaW5kZXgpOwotCX0KLQotCXB1YmxpYyBPYmplY3RbXSB0b0FycmF5KCkgewotCQlyZXR1cm4gdGhpcy5saXN0LnRvQXJyYXkoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogT2JqZWN0IG92ZXJyaWRlcyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuYnVpbGRUb1N0cmluZ0Zvcih0aGlzLCB0aGlzLmxpc3QpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1N0YXRpY1Byb3BlcnR5VmFsdWVNb2RlbC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1N0YXRpY1Byb3BlcnR5VmFsdWVNb2RlbC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlNWVjY2YzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TdGF0aWNQcm9wZXJ0eVZhbHVlTW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBJbXBsZW1lbnRhdGlvbiBvZiBQcm9wZXJ0eVZhbHVlTW9kZWwgdGhhdCBjYW4gYmUgdXNlZCBmb3IKLSAqIHJldHVybmluZyBhIHN0YXRpYyB2YWx1ZSwgYnV0IHN0aWxsIGFsbG93cyBsaXN0ZW5lcnMgdG8gYmUgYWRkZWQuCi0gKiBMaXN0ZW5lcnMgd2lsbCBORVZFUiBiZSBub3RpZmllZCBvZiBhbnkgY2hhbmdlcywgYmVjYXVzZSB0aGVyZSBzaG91bGQgYmUgbm9uZS4KLSAqLwotcHVibGljIGNsYXNzIFN0YXRpY1Byb3BlcnR5VmFsdWVNb2RlbDxUPgotCWV4dGVuZHMgQWJzdHJhY3RNb2RlbAotCWltcGxlbWVudHMgUHJvcGVydHlWYWx1ZU1vZGVsPFQ+Ci17Ci0JLyoqIFRoZSB2YWx1ZS4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgVCB2YWx1ZTsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDFMOwotCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBzdGF0aWMgUHJvcGVydHlWYWx1ZU1vZGVsIGZvciB0aGUgc3BlY2lmaWVkIHZhbHVlLgotCSAqLwotCXB1YmxpYyBTdGF0aWNQcm9wZXJ0eVZhbHVlTW9kZWwoVCB2YWx1ZSkgewotCQlzdXBlcigpOwotCQl0aGlzLnZhbHVlID0gdmFsdWU7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIFByb3BlcnR5VmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgVCBnZXRWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMudmFsdWU7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIE9iamVjdCBvdmVycmlkZXMgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy52YWx1ZSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvU3RhdGljVHJlZVZhbHVlTW9kZWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TdGF0aWNUcmVlVmFsdWVNb2RlbC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2YzQzNWEzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TdGF0aWNUcmVlVmFsdWVNb2RlbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlJlYWRPbmx5SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5UcmVlVmFsdWVNb2RlbDsKLQotLyoqCi0gKiBJbXBsZW1lbnRhdGlvbiBvZiBUcmVlVmFsdWVNb2RlbCB0aGF0IGNhbiBiZSB1c2VkIGZvcgotICogcmV0dXJuaW5nIGFuIGl0ZXJhdG9yIG9uIGEgc3RhdGljIHRyZWUsIGJ1dCBzdGlsbCBhbGxvd3MgbGlzdGVuZXJzIHRvIGJlIGFkZGVkLgotICogTGlzdGVuZXJzIHdpbGwgTkVWRVIgYmUgbm90aWZpZWQgb2YgYW55IGNoYW5nZXMsIGJlY2F1c2UgdGhlcmUgc2hvdWxkIGJlIG5vbmUuCi0gKi8KLXB1YmxpYyBjbGFzcyBTdGF0aWNUcmVlVmFsdWVNb2RlbDxFPgotCWV4dGVuZHMgQWJzdHJhY3RNb2RlbAotCWltcGxlbWVudHMgVHJlZVZhbHVlTW9kZWw8RT4KLXsKLQkvKiogVGhlIHRyZWUncyBub2Rlcy4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgSXRlcmFibGU8PyBleHRlbmRzIEU+IG5vZGVzOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHJlYWQtb25seSBUcmVlVmFsdWVNb2RlbCBmb3IgdGhlIHNwZWNpZmllZCBub2Rlcy4KLQkgKi8KLQlwdWJsaWMgU3RhdGljVHJlZVZhbHVlTW9kZWwoSXRlcmFibGU8PyBleHRlbmRzIEU+IG5vZGVzKSB7Ci0JCXN1cGVyKCk7Ci0JCWlmIChub2RlcyA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLm5vZGVzID0gbm9kZXM7Ci0JfQotCi0JLy8gKioqKioqKioqKiBUcmVlVmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgSXRlcmF0b3I8RT4gbm9kZXMoKSB7Ci0JCXJldHVybiBuZXcgUmVhZE9ubHlJdGVyYXRvcjxFPih0aGlzLm5vZGVzLml0ZXJhdG9yKCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBPYmplY3Qgb3ZlcnJpZGVzICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIENvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKHRoaXMubm9kZXMoKSkpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1RyYW5zZm9ybWF0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVHJhbnNmb3JtYXRpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjFhN2MxZi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVHJhbnNmb3JtYXRpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI0MSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5UcmFuc2Zvcm1lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuUmVhZE9ubHlMaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuTGlzdENoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotCi0vKioKLSAqIEFuIGFkYXB0ZXIgdGhhdCBhbGxvd3MgdXMgdG8gdHJhbnNmb3JtIGEgTGlzdFZhbHVlTW9kZWwKLSAqIChvciBDb2xsZWN0aW9uVmFsdWVNb2RlbCkgaW50byBhIHJlYWQtb25seSBMaXN0VmFsdWVNb2RlbAotICogd2hvc2UgaXRlbXMgYXJlIHRyYW5mb3JtYXRpb25zIG9mIHRoZSBpdGVtcyBpbiB0aGUgd3JhcHBlZAotICogTGlzdFZhbHVlTW9kZWwuIEl0IHdpbGwga2VlcCBpdHMgY29udGVudHMgaW4gc3luY2ggd2l0aAotICogdGhlIGNvbnRlbnRzIG9mIHRoZSB3cmFwcGVkIExpc3RWYWx1ZU1vZGVsIGFuZCBub3RpZmllcyBpdHMKLSAqIGxpc3RlbmVycyBvZiBhbnkgY2hhbmdlcy4KLSAqIDxwPgotICogVGhlIHRyYW5zZm9ybWVyIGNhbiBiZSBjaGFuZ2VkIGF0IGFueSB0aW1lOyBhbGxvd2luZyB0aGUgc2FtZQotICogYWRhcHRlciB0byBiZSB1c2VkIHdpdGggZGlmZmVyZW50IHRyYW5zZm9ybWF0aW9ucy4KLSAqIDxwPgotICogTkI6IFNpbmNlIHdlIG9ubHkgbGlzdGVuIHRvIHRoZSB3cmFwcGVkIGxpc3Qgd2hlbiB3ZSBoYXZlCi0gKiBsaXN0ZW5lcnMgb3Vyc2VsdmVzIGFuZCB3ZSBjYW4gb25seSBzdGF5IGluIHN5bmNoIHdpdGggdGhlIHdyYXBwZWQKLSAqIGxpc3Qgd2hpbGUgd2UgYXJlIGxpc3RlbmluZyB0byBpdCwgcmVzdWx0cyB0byB2YXJpb3VzIG1ldGhvZHMKLSAqIChlLmcuICNzaXplKCksICNnZXRJdGVtKGludCkpIHdpbGwgYmUgdW5wcmVkaWN0YWJsZSB3aGVuZXZlcgotICogd2UgZG8gbm90IGhhdmUgYW55IGxpc3RlbmVycy4gVGhpcyBzaG91bGQgbm90IGJlIHRvbyBwYWluZnVsIHNpbmNlLAotICogbW9zdCBsaWtlbHksIGNsaWVudCBvYmplY3RzIHdpbGwgYWxzbyBiZSBsaXN0ZW5lcnMuCi0gKi8KLXB1YmxpYyBjbGFzcyBUcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFMSwgRTI+Ci0JZXh0ZW5kcyBMaXN0VmFsdWVNb2RlbFdyYXBwZXI8RTE+Ci0JaW1wbGVtZW50cyBMaXN0VmFsdWVNb2RlbDxFMj4KLXsKLQotCS8qKiBUaGlzIHRyYW5zZm9ybXMgdGhlIGl0ZW1zLCB1bmxlc3MgdGhlIHN1YmNsYXNzIG92ZXJyaWRlcyAjdHJhbnNmb3JtSXRlbShPYmplY3QpLiAqLwotCXByb3RlY3RlZCBUcmFuc2Zvcm1lcjxFMSwgRTI+IHRyYW5zZm9ybWVyOwotCi0JLyoqIFRoZSBsaXN0IG9mIHRyYW5zZm9ybWVkIGl0ZW1zLiAqLwotCXByb3RlY3RlZCBmaW5hbCBMaXN0PEUyPiB0cmFuc2Zvcm1lZExpc3Q7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdG9yIC0gdGhlIGxpc3QgaG9sZGVyIGlzIHJlcXVpcmVkLgotCSAqLwotCXB1YmxpYyBUcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcihMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRTE+IGxpc3RIb2xkZXIsIFRyYW5zZm9ybWVyPEUxLCBFMj4gdHJhbnNmb3JtZXIpIHsKLQkJc3VwZXIobGlzdEhvbGRlcik7Ci0JCXRoaXMudHJhbnNmb3JtZXIgPSB0cmFuc2Zvcm1lcjsKLQkJdGhpcy50cmFuc2Zvcm1lZExpc3QgPSBuZXcgQXJyYXlMaXN0PEUyPigpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdG9yIC0gdGhlIGxpc3QgaG9sZGVyIGlzIHJlcXVpcmVkLgotCSAqLwotCXB1YmxpYyBUcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcihMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRTE+IGxpc3RIb2xkZXIpIHsKLQkJdGhpcyhsaXN0SG9sZGVyLCBUcmFuc2Zvcm1lci5OdWxsLjxFMSwgRTI+aW5zdGFuY2UoKSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0b3IgLSB0aGUgY29sbGVjdGlvbiBob2xkZXIgaXMgcmVxdWlyZWQuCi0JICovCi0JcHVibGljIFRyYW5zZm9ybWF0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsPD8gZXh0ZW5kcyBFMT4gY29sbGVjdGlvbkhvbGRlciwgVHJhbnNmb3JtZXI8RTEsIEUyPiB0cmFuc2Zvcm1lcikgewotCQl0aGlzKG5ldyBDb2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyPEUxPihjb2xsZWN0aW9uSG9sZGVyKSwgdHJhbnNmb3JtZXIpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdG9yIC0gdGhlIGNvbGxlY3Rpb24gaG9sZGVyIGlzIHJlcXVpcmVkLgotCSAqLwotCXB1YmxpYyBUcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcihDb2xsZWN0aW9uVmFsdWVNb2RlbDw/IGV4dGVuZHMgRTE+IGNvbGxlY3Rpb25Ib2xkZXIpIHsKLQkJdGhpcyhuZXcgQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxFMT4oY29sbGVjdGlvbkhvbGRlcikpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBMaXN0VmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgSXRlcmF0b3I8RTI+IGl0ZXJhdG9yKCkgewotCQlyZXR1cm4gdGhpcy5saXN0SXRlcmF0b3IoKTsKLQl9Ci0KLQlwdWJsaWMgTGlzdEl0ZXJhdG9yPEUyPiBsaXN0SXRlcmF0b3IoKSB7Ci0JCXJldHVybiBuZXcgUmVhZE9ubHlMaXN0SXRlcmF0b3I8RTI+KHRoaXMudHJhbnNmb3JtZWRMaXN0KTsKLQl9Ci0KLQlwdWJsaWMgRTIgZ2V0KGludCBpbmRleCkgewotCQlyZXR1cm4gdGhpcy50cmFuc2Zvcm1lZExpc3QuZ2V0KGluZGV4KTsKLQl9Ci0KLQlwdWJsaWMgaW50IHNpemUoKSB7Ci0JCXJldHVybiB0aGlzLnRyYW5zZm9ybWVkTGlzdC5zaXplKCk7Ci0JfQotCi0JcHVibGljIE9iamVjdFtdIHRvQXJyYXkoKSB7Ci0JCXJldHVybiB0aGlzLnRyYW5zZm9ybWVkTGlzdC50b0FycmF5KCk7Ci0JfQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLSAgICBAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VNb2RlbCgpIHsKLQkJc3VwZXIuZW5nYWdlTW9kZWwoKTsKLQkJLy8gc3luY2ggdGhlIHRyYW5zZm9ybWVkIGxpc3QgKmFmdGVyKiB3ZSBzdGFydCBsaXN0ZW5pbmcgdG8gdGhlIGxpc3QgaG9sZGVyLAotCQkvLyBzaW5jZSBpdHMgdmFsdWUgbWlnaHQgY2hhbmdlIHdoZW4gYSBsaXN0ZW5lciBpcyBhZGRlZAotCQl0aGlzLnRyYW5zZm9ybWVkTGlzdC5hZGRBbGwodGhpcy50cmFuc2Zvcm1JdGVtcyh0aGlzLmxpc3RIb2xkZXIpKTsKLQl9Ci0KLSAgICBAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VNb2RlbCgpIHsKLQkJc3VwZXIuZGlzZW5nYWdlTW9kZWwoKTsKLQkJLy8gY2xlYXIgb3V0IHRoZSBsaXN0IHdoZW4gd2UgYXJlIG5vdCBsaXN0ZW5pbmcgdG8gdGhlIGNvbGxlY3Rpb24gaG9sZGVyCi0JCXRoaXMudHJhbnNmb3JtZWRMaXN0LmNsZWFyKCk7Ci0JfQotCi0JLyoqCi0JICogVHJhbnNmb3JtIHRoZSBpdGVtcyBhc3NvY2lhdGVkIHdpdGggdGhlIHNwZWNpZmllZCBldmVudC4KLQkgKi8KLQlwcm90ZWN0ZWQgTGlzdDxFMj4gdHJhbnNmb3JtSXRlbXMoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXJldHVybiB0aGlzLnRyYW5zZm9ybUl0ZW1zKHRoaXMuaXRlbXMoZXZlbnQpLCBldmVudC5pdGVtc1NpemUoKSk7Ci0JfQotCi0JLyoqCi0JICogVHJhbnNmb3JtIHRoZSBpdGVtcyBpbiB0aGUgc3BlY2lmaWVkIGxpc3QgdmFsdWUgbW9kZWwuCi0JICovCi0JcHJvdGVjdGVkIExpc3Q8RTI+IHRyYW5zZm9ybUl0ZW1zKExpc3RWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBFMT4gbHZtKSB7Ci0JCXJldHVybiB0aGlzLnRyYW5zZm9ybUl0ZW1zKGx2bS5saXN0SXRlcmF0b3IoKSwgbHZtLnNpemUoKSk7Ci0JfQotCi0JLyoqCi0JICogVHJhbnNmb3JtIHRoZSByZXBsYWNlZCBpdGVtcyBhc3NvY2lhdGVkIHdpdGggdGhlIHNwZWNpZmllZCBldmVudC4KLQkgKi8KLQlwcm90ZWN0ZWQgTGlzdDxFMj4gdHJhbnNmb3JtUmVwbGFjZWRJdGVtcyhMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIHRoaXMudHJhbnNmb3JtSXRlbXModGhpcy5yZXBsYWNlZEl0ZW1zKGV2ZW50KSwgZXZlbnQuaXRlbXNTaXplKCkpOwotCX0KLQotCS8qKgotCSAqIFRyYW5zZm9ybSB0aGUgc3BlY2lmaWVkIGl0ZW1zLgotCSAqLwotCXByb3RlY3RlZCBMaXN0PEUyPiB0cmFuc2Zvcm1JdGVtcyhMaXN0SXRlcmF0b3I8PyBleHRlbmRzIEUxPiBpdGVtcywgaW50IHNpemUpIHsKLQkJTGlzdDxFMj4gcmVzdWx0ID0gbmV3IEFycmF5TGlzdDxFMj4oc2l6ZSk7Ci0JCXdoaWxlIChpdGVtcy5oYXNOZXh0KCkpIHsKLQkJCXJlc3VsdC5hZGQodGhpcy50cmFuc2Zvcm1JdGVtKGl0ZW1zLm5leHQoKSkpOwotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoqCi0JICogVHJhbnNmb3JtIHRoZSBzcGVjaWZpZWQgaXRlbS4KLQkgKi8KLQlwcm90ZWN0ZWQgRTIgdHJhbnNmb3JtSXRlbShFMSBpdGVtKSB7Ci0JCXJldHVybiB0aGlzLnRyYW5zZm9ybWVyLnRyYW5zZm9ybShpdGVtKTsKLQl9Ci0KLQkvKioKLQkgKiBDaGFuZ2UgdGhlIHRyYW5zZm9ybWVyIGFuZCByZWJ1aWxkIHRoZSBjb2xsZWN0aW9uLgotCSAqLwotCXB1YmxpYyB2b2lkIHNldFRyYW5zZm9ybWVyKFRyYW5zZm9ybWVyPEUxLCBFMj4gdHJhbnNmb3JtZXIpIHsKLQkJdGhpcy50cmFuc2Zvcm1lciA9IHRyYW5zZm9ybWVyOwotCQl0aGlzLnJlYnVpbGRUcmFuc2Zvcm1lZExpc3QoKTsKLQl9Ci0KLQkvKioKLQkgKiBTeW5jaHJvbml6ZSBvdXIgY2FjaGUgd2l0aCB0aGUgd3JhcHBlZCBjb2xsZWN0aW9uLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIHJlYnVpbGRUcmFuc2Zvcm1lZExpc3QoKSB7Ci0JCXRoaXMudHJhbnNmb3JtZWRMaXN0LmNsZWFyKCk7Ci0JCXRoaXMudHJhbnNmb3JtZWRMaXN0LmFkZEFsbCh0aGlzLnRyYW5zZm9ybUl0ZW1zKHRoaXMubGlzdEhvbGRlcikpOwotCQl0aGlzLmZpcmVMaXN0Q2hhbmdlZChMSVNUX1ZBTFVFUyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGxpc3QgY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JLyoqCi0JICogSXRlbXMgd2VyZSBhZGRlZCB0byB0aGUgd3JhcHBlZCBsaXN0IGhvbGRlci4KLQkgKiBUcmFuc2Zvcm0gdGhlbSwgYWRkIHRoZW0gdG8gb3VyIHRyYW5zZm9ybWF0aW9uIGxpc3QsCi0JICogYW5kIG5vdGlmeSBvdXIgbGlzdGVuZXJzLgotCSAqLwotICAgIEBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGl0ZW1zQWRkZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuYWRkSXRlbXNUb0xpc3QoZXZlbnQuZ2V0SW5kZXgoKSwgdGhpcy50cmFuc2Zvcm1JdGVtcyhldmVudCksIHRoaXMudHJhbnNmb3JtZWRMaXN0LCBMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JLyoqCi0JICogSXRlbXMgd2VyZSByZW1vdmVkIGZyb20gdGhlIHdyYXBwZWQgbGlzdCBob2xkZXIuCi0JICogUmVtb3ZlIHRoZSBjb3JyZXNwb25kaW5nIGl0ZW1zIGZyb20gb3VyIHRyYW5zZm9ybWF0aW9uIGxpc3QKLQkgKiBhbmQgbm90aWZ5IG91ciBsaXN0ZW5lcnMuCi0JICovCi0gICAgQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLnJlbW92ZUl0ZW1zRnJvbUxpc3QoZXZlbnQuZ2V0SW5kZXgoKSwgZXZlbnQuaXRlbXNTaXplKCksIHRoaXMudHJhbnNmb3JtZWRMaXN0LCBMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JLyoqCi0JICogSXRlbXMgd2VyZSByZXBsYWNlZCBpbiB0aGUgd3JhcHBlZCBsaXN0IGhvbGRlci4KLQkgKiBSZXBsYWNlIHRoZSBjb3JyZXNwb25kaW5nIGl0ZW1zIGluIG91ciB0cmFuc2Zvcm1hdGlvbiBsaXN0Ci0JICogYW5kIG5vdGlmeSBvdXIgbGlzdGVuZXJzLgotCSAqLwotICAgIEBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuc2V0SXRlbXNJbkxpc3QoZXZlbnQuZ2V0SW5kZXgoKSwgdGhpcy50cmFuc2Zvcm1JdGVtcyhldmVudCksIHRoaXMudHJhbnNmb3JtZWRMaXN0LCBMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JLyoqCi0JICogSXRlbXMgd2VyZSBtb3ZlZCBpbiB0aGUgd3JhcHBlZCBsaXN0IGhvbGRlci4KLQkgKiBNb3ZlIHRoZSBjb3JyZXNwb25kaW5nIGl0ZW1zIGluIG91ciB0cmFuc2Zvcm1hdGlvbiBsaXN0Ci0JICogYW5kIG5vdGlmeSBvdXIgbGlzdGVuZXJzLgotCSAqLwotICAgIEBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0gICAgCXRoaXMubW92ZUl0ZW1zSW5MaXN0KGV2ZW50LmdldFRhcmdldEluZGV4KCksIGV2ZW50LmdldFNvdXJjZUluZGV4KCksIGV2ZW50LmdldE1vdmVMZW5ndGgoKSwgdGhpcy50cmFuc2Zvcm1lZExpc3QsIExJU1RfVkFMVUVTKTsKLQl9Ci0KLQkvKioKLQkgKiBUaGUgd3JhcHBlZCBsaXN0IGhvbGRlciB3YXMgY2xlYXJlZC4KLQkgKiBDbGVhciBvdXIgdHJhbnNmb3JtYXRpb24gbGlzdCBhbmQgbm90aWZ5IG91ciBsaXN0ZW5lcnMuCi0JICovCi0gICAgQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgbGlzdENsZWFyZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0gICAgCXRoaXMuY2xlYXJMaXN0KHRoaXMudHJhbnNmb3JtZWRMaXN0LCBMSVNUX1ZBTFVFUyk7Ci0JfQotCi0JLyoqCi0JICogVGhlIHdyYXBwZWQgbGlzdCBob2xkZXIgaGFzIGNoYW5nZWQgaW4gc29tZSBkcmFtYXRpYyBmYXNoaW9uLgotCSAqIFJlYnVpbGQgb3VyIHRyYW5zZm9ybWF0aW9uIGxpc3QgYW5kIG5vdGlmeSBvdXIgbGlzdGVuZXJzLgotCSAqLwotICAgIEBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGxpc3RDaGFuZ2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLnJlYnVpbGRUcmFuc2Zvcm1lZExpc3QoKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1RyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJhODc4ZTUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1RyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMzEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlRyYW5zZm9ybWVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlByb3BlcnR5Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIEEgPGNvZGU+VHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8L2NvZGU+IHdyYXBzIGFub3RoZXIKLSAqIDxjb2RlPlByb3BlcnR5VmFsdWVNb2RlbDwvY29kZT4gYW5kIHVzZXMgYSA8Y29kZT5UcmFuc2Zvcm1lcjwvY29kZT4KLSAqIHRvIHRyYW5zZm9ybSB0aGUgd3JhcHBlZCB2YWx1ZSBiZWZvcmUgaXQgaXMgcmV0dXJuZWQgYnkgPGNvZGU+dmFsdWUoKTwvY29kZT4uCi0gKiA8cD4KLSAqIEFzIGFuIGFsdGVybmF0aXZlIHRvIGJ1aWxkaW5nIGEgPGNvZGU+VHJhbnNmb3JtZXI8L2NvZGU+LAotICogYSBzdWJjbGFzcyBvZiA8Y29kZT5UcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDwvY29kZT4gY2FuCi0gKiBlaXRoZXIgb3ZlcnJpZGUgdGhlIDxjb2RlPnRyYW5zZm9ybV8oT2JqZWN0KTwvY29kZT4gbWV0aG9kIG9yLAotICogaWYgc29tZXRoaW5nIG90aGVyIHRoYW4gbnVsbCBzaG91bGQgYmUgcmV0dXJuZWQgd2hlbiB0aGUgd3JhcHBlZCB2YWx1ZQotICogaXMgbnVsbCwgb3ZlcnJpZGUgdGhlIDxjb2RlPnRyYW5zZm9ybShPYmplY3QpPC9jb2RlPiBtZXRob2QuCi0gKi8KLXB1YmxpYyBjbGFzcyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbDxUMSwgVDI+Ci0JZXh0ZW5kcyBQcm9wZXJ0eVZhbHVlTW9kZWxXcmFwcGVyPFQxPgotCWltcGxlbWVudHMgUHJvcGVydHlWYWx1ZU1vZGVsPFQyPgotewotCXByb3RlY3RlZCBmaW5hbCBUcmFuc2Zvcm1lcjxUMSwgVDI+IHRyYW5zZm9ybWVyOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycy9pbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCB3aXRoIHRoZSBzcGVjaWZpZWQgbmVzdGVkCi0JICogcHJvcGVydHkgdmFsdWUgbW9kZWwgYW5kIHRoZSBkZWZhdWx0IHRyYW5zZm9ybWVyLgotCSAqIFVzZSB0aGlzIGNvbnN0cnVjdG9yIGlmIHlvdSB3YW50IHRvIG92ZXJyaWRlIHRoZQotCSAqIDxjb2RlPnRyYW5zZm9ybV8oT2JqZWN0KTwvY29kZT4gb3IgPGNvZGU+dHJhbnNmb3JtKE9iamVjdCk8L2NvZGU+Ci0JICogbWV0aG9kIGluc3RlYWQgb2YgYnVpbGRpbmcgYSA8Y29kZT5UcmFuc2Zvcm1lcjwvY29kZT4uCi0JICovCi0JcHVibGljIFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsKFByb3BlcnR5VmFsdWVNb2RlbDw/IGV4dGVuZHMgVDE+IHZhbHVlSG9sZGVyKSB7Ci0JCXN1cGVyKHZhbHVlSG9sZGVyKTsKLQkJdGhpcy50cmFuc2Zvcm1lciA9IHRoaXMuYnVpbGRUcmFuc2Zvcm1lcigpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBwcm9wZXJ0eSB2YWx1ZSBtb2RlbCB3aXRoIHRoZSBzcGVjaWZpZWQgbmVzdGVkCi0JICogcHJvcGVydHkgdmFsdWUgbW9kZWwgYW5kIHRyYW5zZm9ybWVyLgotCSAqLwotCXB1YmxpYyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbChQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFQxPiB2YWx1ZUhvbGRlciwgVHJhbnNmb3JtZXI8VDEsIFQyPiB0cmFuc2Zvcm1lcikgewotCQlzdXBlcih2YWx1ZUhvbGRlcik7Ci0JCXRoaXMudHJhbnNmb3JtZXIgPSB0cmFuc2Zvcm1lcjsKLQl9Ci0KLQlwcm90ZWN0ZWQgVHJhbnNmb3JtZXI8VDEsIFQyPiBidWlsZFRyYW5zZm9ybWVyKCkgewotCQlyZXR1cm4gbmV3IERlZmF1bHRUcmFuc2Zvcm1lcigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBQcm9wZXJ0eVZhbHVlTW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIFQyIGdldFZhbHVlKCkgewotCQkvLyB0cmFuc2Zvcm0gdGhlIG9iamVjdCByZXR1cm5lZCBieSB0aGUgbmVzdGVkIHZhbHVlIG1vZGVsIGJlZm9yZSByZXR1cm5pbmcgaXQKLQkJcmV0dXJuIHRoaXMudHJhbnNmb3JtKHRoaXMudmFsdWVIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIFByb3BlcnR5VmFsdWVNb2RlbFdyYXBwZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdmFsdWVDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gdHJhbnNmb3JtIHRoZSB2YWx1ZXMgYmVmb3JlIHByb3BhZ2F0aW5nIHRoZSBjaGFuZ2UgZXZlbnQKLQkgICAgQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCU9iamVjdCBvbGRWYWx1ZSA9IHRoaXMudHJhbnNmb3JtT2xkKChUMSkgZXZlbnQuZ2V0T2xkVmFsdWUoKSk7Ci0JICAgIEBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLnRyYW5zZm9ybU5ldygoVDEpIGV2ZW50LmdldE5ld1ZhbHVlKCkpOwotCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoVkFMVUUsIG9sZFZhbHVlLCBuZXdWYWx1ZSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCS8qKgotCSAqIFRyYW5zZm9ybSB0aGUgc3BlY2lmaWVkIHZhbHVlIGFuZCByZXR1cm4gdGhlIHJlc3VsdC4KLQkgKiBUaGlzIGlzIGNhbGxlZCBieSAjdmFsdWUoKSBhbmQgI3ZhbHVlQ2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50KS4KLQkgKi8KLQlwcm90ZWN0ZWQgVDIgdHJhbnNmb3JtKFQxIHZhbHVlKSB7Ci0JCXJldHVybiB0aGlzLnRyYW5zZm9ybWVyLnRyYW5zZm9ybSh2YWx1ZSk7Ci0JfQotCi0JLyoqCi0JICogVHJhbnNmb3JtIHRoZSBzcGVjaWZpZWQsIG5vbi1udWxsLCB2YWx1ZSBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICovCi0JcHJvdGVjdGVkIFQyIHRyYW5zZm9ybV8oQFN1cHByZXNzV2FybmluZ3MoInVudXNlZCIpIFQxIHZhbHVlKSB7Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQotCS8qKgotCSAqIFRyYW5zZm9ybSB0aGUgc3BlY2lmaWVkIG9sZCB2YWx1ZSBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogQnkgZGVmYXVsdCwgY2FsbCB7QGxpbmsgI3RyYW5zZm9ybShPYmplY3QpfS4KLQkgKiBUaGlzIGlzIGNhbGxlZCBieSB7QGxpbmsgI3ZhbHVlQ2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50KX0uCi0JICovCi0JcHJvdGVjdGVkIFQyIHRyYW5zZm9ybU9sZChUMSB2YWx1ZSkgewotCQlyZXR1cm4gdGhpcy50cmFuc2Zvcm0odmFsdWUpOwotCX0KLQkKLQkvKioKLQkgKiBUcmFuc2Zvcm0gdGhlIHNwZWNpZmllZCBuZXcgdmFsdWUgYW5kIHJldHVybiB0aGUgcmVzdWx0LgotCSAqIEJ5IGRlZmF1bHQsIGNhbGwge0BsaW5rICN0cmFuc2Zvcm0oT2JqZWN0KX0uCi0JICogVGhpcyBpcyBjYWxsZWQgYnkge0BsaW5rICN2YWx1ZUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCl9LgotCSAqLwotCXByb3RlY3RlZCBUMiB0cmFuc2Zvcm1OZXcoVDEgdmFsdWUpIHsKLQkJcmV0dXJuIHRoaXMudHJhbnNmb3JtKHZhbHVlKTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIGRlZmF1bHQgdHJhbnNmb3JtZXIgKioqKioqKioqKgotCi0JLyoqCi0JICogVGhlIGRlZmF1bHQgdHJhbnNmb3JtZXIgd2lsbCByZXR1cm4gbnVsbCBpZiB0aGUgd3JhcHBlZCB2YWx1ZSBpcyBudWxsLgotCSAqIElmIHRoZSB3cmFwcGVkIHZhbHVlIGlzIG5vdCBudWxsLCBpdCBpcyB0cmFuc2Zvcm1lZCBieSBhIHN1YmNsYXNzCi0JICogaW1wbGVtZW50YXRpb24gb2YgI3RyYW5zZm9ybV8oT2JqZWN0KS4KLQkgKi8KLQlwcm90ZWN0ZWQgY2xhc3MgRGVmYXVsdFRyYW5zZm9ybWVyIGltcGxlbWVudHMgVHJhbnNmb3JtZXI8VDEsIFQyPiB7Ci0JCXB1YmxpYyBUMiB0cmFuc2Zvcm0oVDEgdmFsdWUpIHsKLQkJCXJldHVybiAodmFsdWUgPT0gbnVsbCkgPyBudWxsIDogVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWwudGhpcy50cmFuc2Zvcm1fKHZhbHVlKTsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1RyYW5zZm9ybWF0aW9uV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9UcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDEyOTkwOTcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1RyYW5zZm9ybWF0aW9uV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEyNyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQmlkaVRyYW5zZm9ybWVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIEEgPGNvZGU+VHJhbnNmb3JtYXRpb25Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDwvY29kZT4gd3JhcHMgYW5vdGhlcgotICogPGNvZGU+V3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8L2NvZGU+IGFuZCB1c2VzIGEgPGNvZGU+QmlkaVRyYW5zZm9ybWVyPC9jb2RlPgotICogdG86PHVsPgotICogPGxpPnRyYW5zZm9ybSB0aGUgd3JhcHBlZCB2YWx1ZSBiZWZvcmUgaXQgaXMgcmV0dXJuZWQgYnkgPGNvZGU+dmFsdWUoKTwvY29kZT4KLSAqIDxsaT4icmV2ZXJzZS10cmFuc2Zvcm0iIHRoZSBuZXcgdmFsdWUgdGhhdCBjb21lcyBpbiB2aWEKLSAqIDxjb2RlPnNldFZhbHVlKE9iamVjdCk8L2NvZGU+Ci0gKiA8L3VsPgotICogQXMgYW4gYWx0ZXJuYXRpdmUgdG8gYnVpbGRpbmcgYSA8Y29kZT5CaWRpVHJhbnNmb3JtZXI8L2NvZGU+LAotICogYSBzdWJjbGFzcyBvZiA8Y29kZT5UcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPC9jb2RlPiBjYW4KLSAqIG92ZXJyaWRlIHRoZSA8Y29kZT50cmFuc2Zvcm1fKE9iamVjdCk8L2NvZGU+IGFuZCAKLSAqIDxjb2RlPnJldmVyc2VUcmFuc2Zvcm1fKE9iamVjdCk8L2NvZGU+IG1ldGhvZHM7IG9yLAotICogaWYgc29tZXRoaW5nIG90aGVyIHRoYW4gbnVsbCBzaG91bGQgYmUgcmV0dXJuZWQgd2hlbiB0aGUgd3JhcHBlZCB2YWx1ZQotICogaXMgbnVsbCBvciB0aGUgbmV3IHZhbHVlIGlzIG51bGwsIG92ZXJyaWRlIHRoZSA8Y29kZT50cmFuc2Zvcm0oT2JqZWN0KTwvY29kZT4KLSAqIGFuZCA8Y29kZT5yZXZlcnNlVHJhbnNmb3JtKE9iamVjdCk8L2NvZGU+IG1ldGhvZHMuCi0gKi8KLXB1YmxpYyBjbGFzcyBUcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQxLCBUMj4KLQlleHRlbmRzIFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsPFQxLCBUMj4KLQlpbXBsZW1lbnRzIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQyPgotewotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMvaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgd3JpdGFibGUgcHJvcGVydHkgdmFsdWUgbW9kZWwgd2l0aCB0aGUgc3BlY2lmaWVkIG5lc3RlZAotCSAqIHdyaXRhYmxlIHByb3BlcnR5IHZhbHVlIG1vZGVsIGFuZCB0aGUgZGVmYXVsdCBiaWRpIHRyYW5zZm9ybWVyLgotCSAqIFVzZSB0aGlzIGNvbnN0cnVjdG9yIGlmIHlvdSB3YW50IHRvIG92ZXJyaWRlIHRoZQotCSAqIDxjb2RlPnRyYW5zZm9ybV8oT2JqZWN0KTwvY29kZT4gYW5kIDxjb2RlPnJldmVyc2VUcmFuc2Zvcm1fKE9iamVjdCk8L2NvZGU+Ci0JICogKG9yIDxjb2RlPnRyYW5zZm9ybShPYmplY3QpPC9jb2RlPiBhbmQgPGNvZGU+cmV2ZXJzZVRyYW5zZm9ybShPYmplY3QpPC9jb2RlPikKLQkgKiBtZXRob2RzIGluc3RlYWQgb2YgYnVpbGRpbmcgYSA8Y29kZT5CaWRpVHJhbnNmb3JtZXI8L2NvZGU+LgotCSAqLwotCXB1YmxpYyBUcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQxPiB2YWx1ZUhvbGRlcikgewotCQlzdXBlcih2YWx1ZUhvbGRlcik7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgd3JpdGFibGUgcHJvcGVydHkgdmFsdWUgbW9kZWwgd2l0aCB0aGUgc3BlY2lmaWVkIG5lc3RlZAotCSAqIHdyaXRhYmxlIHByb3BlcnR5IHZhbHVlIG1vZGVsIGFuZCBiaWRpIHRyYW5zZm9ybWVyLgotCSAqLwotCXB1YmxpYyBUcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQxPiB2YWx1ZUhvbGRlciwgQmlkaVRyYW5zZm9ybWVyPFQxLCBUMj4gdHJhbnNmb3JtZXIpIHsKLQkJc3VwZXIodmFsdWVIb2xkZXIsIHRyYW5zZm9ybWVyKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgQmlkaVRyYW5zZm9ybWVyPFQxLCBUMj4gYnVpbGRUcmFuc2Zvcm1lcigpIHsKLQkJcmV0dXJuIG5ldyBEZWZhdWx0QmlkaVRyYW5zZm9ybWVyKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIHNldFZhbHVlKFQyIHZhbHVlKSB7Ci0JCS8vICJyZXZlcnNlLXRyYW5zZm9ybSIgdGhlIG9iamVjdCBiZWZvcmUgcGFzc2luZyBpdCB0byB0aGUgdGhlIG5lc3RlZCB2YWx1ZSBtb2RlbAotCQl0aGlzLnZhbHVlSG9sZGVyKCkuc2V0VmFsdWUodGhpcy5yZXZlcnNlVHJhbnNmb3JtKHZhbHVlKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCS8qKgotCSAqICJSZXZlcnNlLXRyYW5zZm9ybSIgdGhlIHNwZWNpZmllZCB2YWx1ZSBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICogVGhpcyBpcyBjYWxsZWQgYnkgI3NldFZhbHVlKE9iamVjdCkuCi0JICovCi0JcHJvdGVjdGVkIFQxIHJldmVyc2VUcmFuc2Zvcm0oVDIgdmFsdWUpIHsKLQkJcmV0dXJuIHRoaXMudHJhbnNmb3JtZXIoKS5yZXZlcnNlVHJhbnNmb3JtKHZhbHVlKTsKLQl9Ci0KLQkvKioKLQkgKiAiUmV2ZXJzZS10cmFuc2Zvcm0iIHRoZSBzcGVjaWZpZWQsIG5vbi1udWxsLCB2YWx1ZSBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCi0JICovCi0JcHJvdGVjdGVkIFQxIHJldmVyc2VUcmFuc2Zvcm1fKEBTdXBwcmVzc1dhcm5pbmdzKCJ1bnVzZWQiKSBUMiB2YWx1ZSkgewotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogcXVlcmllcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBPdXIgY29uc3RydWN0b3JzIGFjY2VwdCBvbmx5IGEgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VDE+LgotCSAqLwotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByb3RlY3RlZCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUMT4gdmFsdWVIb2xkZXIoKSB7Ci0JCXJldHVybiAoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VDE+KSB0aGlzLnZhbHVlSG9sZGVyOwotCX0KLQotCS8qKgotCSAqIE91ciBjb25zdHJ1Y3RvcnMgYWNjZXB0IG9ubHkgYSBiaWRpcmVjdGlvbmFsIHRyYW5zZm9ybWVyLgotCSAqLwotCXByb3RlY3RlZCBCaWRpVHJhbnNmb3JtZXI8VDEsIFQyPiB0cmFuc2Zvcm1lcigpIHsKLQkJcmV0dXJuIChCaWRpVHJhbnNmb3JtZXI8VDEsIFQyPikgdGhpcy50cmFuc2Zvcm1lcjsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogZGVmYXVsdCBiaWRpIHRyYW5zZm9ybWVyICoqKioqKioqKioKLQotCS8qKgotCSAqIFRoZSBkZWZhdWx0IGJpZGkgdHJhbnNmb3JtZXIgd2lsbCByZXR1cm4gbnVsbCBpZiB0aGUgd3JhcHBlZCB2YWx1ZSBpcyBudWxsLgotCSAqIElmIHRoZSB3cmFwcGVkIHZhbHVlIGlzIG5vdCBudWxsLCBpdCBpcyB0cmFuc2Zvcm1lZCBieSBhIHN1YmNsYXNzCi0JICogaW1wbGVtZW50YXRpb24gb2YgI3RyYW5zZm9ybV8oT2JqZWN0KS4KLQkgKiBUaGUgZGVmYXVsdCBiaWRpIHRyYW5zZm9ybWVyIHdpbGwgYWxzbyByZXR1cm4gbnVsbCBpZiB0aGUgbmV3IHZhbHVlIGlzIG51bGwuCi0JICogSWYgdGhlIG5ldyB2YWx1ZSBpcyBub3QgbnVsbCwgaXQgaXMgcmV2ZXJzZS10cmFuc2Zvcm1lZCBieSBhIHN1YmNsYXNzCi0JICogaW1wbGVtZW50YXRpb24gb2YgI3JldmVyc2VUcmFuc2Zvcm1fKE9iamVjdCkuCi0JICovCi0JcHJvdGVjdGVkIGNsYXNzIERlZmF1bHRCaWRpVHJhbnNmb3JtZXIKLQkJZXh0ZW5kcyBEZWZhdWx0VHJhbnNmb3JtZXIKLQkJaW1wbGVtZW50cyBCaWRpVHJhbnNmb3JtZXI8VDEsIFQyPgotCXsKLQkJcHVibGljIFQxIHJldmVyc2VUcmFuc2Zvcm0oVDIgdmFsdWUpIHsKLQkJCXJldHVybiAodmFsdWUgPT0gbnVsbCkgPyBudWxsIDogVHJhbnNmb3JtYXRpb25Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbC50aGlzLnJldmVyc2VUcmFuc2Zvcm1fKHZhbHVlKTsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1RyZWVBc3BlY3RBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVHJlZUFzcGVjdEFkYXB0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzM5YmI5Ny4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVHJlZUFzcGVjdEFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDIxNSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5czsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkVtcHR5SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuVHJlZUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlRyZWVDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuVHJlZVZhbHVlTW9kZWw7Ci0KLS8qKgotICogVGhpcyBleHRlbnNpb24gb2YgUHJvcGVydHlBZGFwdGVyIHByb3ZpZGVzIFRyZWVDaGFuZ2Ugc3VwcG9ydC4KLSAqIFRoaXMgYWxsb3dzIHVzIHRvIGNvbnZlcnQgYSBzZXQgb2Ygb25lIG9yIG1vcmUgdHJlZXMgaW50bwotICogYSBzaW5nbGUgdHJlZSwgTk9ERVMuCi0gKiAKLSAqIFRoZSB0eXBpY2FsIHN1YmNsYXNzIHdpbGwgb3ZlcnJpZGUgdGhlIGZvbGxvd2luZyBtZXRob2RzOgotICogI25vZGVzXygpCi0gKiAgICAgYXQgdGhlIHZlcnkgbWluaW11bSwgb3ZlcnJpZGUgdGhpcyBtZXRob2QgdG8gcmV0dXJuIGFuIGl0ZXJhdG9yCi0gKiAgICAgb24gdGhlIHN1YmplY3QncyB0cmVlIGFzcGVjdDsgaXQgZG9lcyBub3QgbmVlZCB0byBiZSBvdmVycmlkZGVuIGlmCi0gKiAgICAgI25vZGVzKCkgaXMgb3ZlcnJpZGRlbiBhbmQgaXRzIGJlaGF2aW9yIGNoYW5nZWQKLSAqICNub2RlcygpCi0gKiAgICAgb3ZlcnJpZGUgdGhpcyBtZXRob2Qgb25seSBpZiByZXR1cm5pbmcgYW4gZW1wdHkgaXRlcmF0b3Igd2hlbiB0aGUKLSAqICAgICBzdWJqZWN0IGlzIG51bGwgaXMgdW5hY2NlcHRhYmxlCi0gKi8KLXB1YmxpYyBhYnN0cmFjdCBjbGFzcyBUcmVlQXNwZWN0QWRhcHRlcjxTIGV4dGVuZHMgTW9kZWwsIEU+Ci0JZXh0ZW5kcyBBc3BlY3RBZGFwdGVyPFM+Ci0JaW1wbGVtZW50cyBUcmVlVmFsdWVNb2RlbDxFPgotewotCS8qKgotCSAqIFRoZSBuYW1lIG9mIHRoZSBzdWJqZWN0J3MgdHJlZXMgdGhhdCB3ZSB1c2UgZm9yIHRoZSB2YWx1ZS4KLQkgKi8KLQlwcm90ZWN0ZWQgZmluYWwgU3RyaW5nW10gdHJlZU5hbWVzOwotCQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIFN0cmluZ1tdIEVNUFRZX1RSRUVfTkFNRVMgPSBuZXcgU3RyaW5nWzBdOwotCi0JLyoqIEEgbGlzdGVuZXIgdGhhdCBsaXN0ZW5zIHRvIHRoZSBzdWJqZWN0J3MgdHJlZSBhc3BlY3QuICovCi0JcHJvdGVjdGVkIGZpbmFsIFRyZWVDaGFuZ2VMaXN0ZW5lciB0cmVlQ2hhbmdlTGlzdGVuZXI7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIFRyZWVBc3BlY3RBZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIHN1YmplY3QKLQkgKiBhbmQgdHJlZS4KLQkgKi8KLQlwcm90ZWN0ZWQgVHJlZUFzcGVjdEFkYXB0ZXIoU3RyaW5nIHRyZWVOYW1lLCBTIHN1YmplY3QpIHsKLQkJdGhpcyhuZXcgU3RyaW5nW10ge3RyZWVOYW1lfSwgc3ViamVjdCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgVHJlZUFzcGVjdEFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgc3ViamVjdAotCSAqIGFuZCB0cmVlcy4KLQkgKi8KLQlwcm90ZWN0ZWQgVHJlZUFzcGVjdEFkYXB0ZXIoU3RyaW5nW10gdHJlZU5hbWVzLCBTIHN1YmplY3QpIHsKLQkJdGhpcyhuZXcgU3RhdGljUHJvcGVydHlWYWx1ZU1vZGVsPFM+KHN1YmplY3QpLCB0cmVlTmFtZXMpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIFRyZWVBc3BlY3RBZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIHN1YmplY3QgaG9sZGVyCi0JICogYW5kIHRyZWVzLgotCSAqLwotCXByb3RlY3RlZCBUcmVlQXNwZWN0QWRhcHRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFM+IHN1YmplY3RIb2xkZXIsIFN0cmluZy4uLiB0cmVlTmFtZXMpIHsKLQkJc3VwZXIoc3ViamVjdEhvbGRlcik7Ci0JCXRoaXMudHJlZU5hbWVzID0gdHJlZU5hbWVzOwotCQl0aGlzLnRyZWVDaGFuZ2VMaXN0ZW5lciA9IHRoaXMuYnVpbGRUcmVlQ2hhbmdlTGlzdGVuZXIoKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBUcmVlQXNwZWN0QWRhcHRlciBmb3IgdGhlIHNwZWNpZmllZCBzdWJqZWN0IGhvbGRlcgotCSAqIGFuZCB0cmVlcy4KLQkgKi8KLQlwcm90ZWN0ZWQgVHJlZUFzcGVjdEFkYXB0ZXIoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBTPiBzdWJqZWN0SG9sZGVyLCBDb2xsZWN0aW9uPFN0cmluZz4gdHJlZU5hbWVzKSB7Ci0JCXRoaXMoc3ViamVjdEhvbGRlciwgdHJlZU5hbWVzLnRvQXJyYXkobmV3IFN0cmluZ1t0cmVlTmFtZXMuc2l6ZSgpXSkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIFRyZWVBc3BlY3RBZGFwdGVyIGZvciBhbiAidW5jaGFuZ2luZyIgdHJlZSBpbgotCSAqIHRoZSBzcGVjaWZpZWQgc3ViamVjdC4gVGhpcyBpcyB1c2VmdWwgZm9yIGEgdHJlZSBhc3BlY3QgdGhhdCBkb2VzIG5vdAotCSAqIGNoYW5nZSBmb3IgYSBwYXJ0aWN1bGFyIHN1YmplY3Q7IGJ1dCB0aGUgc3ViamVjdCB3aWxsIGNoYW5nZSwgcmVzdWx0aW5nIGluCi0JICogYSBuZXcgdHJlZS4KLQkgKi8KLQlwcm90ZWN0ZWQgVHJlZUFzcGVjdEFkYXB0ZXIoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBTPiBzdWJqZWN0SG9sZGVyKSB7Ci0JCXRoaXMoc3ViamVjdEhvbGRlciwgRU1QVFlfVFJFRV9OQU1FUyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIFRoZSBzdWJqZWN0J3MgdHJlZSBhc3BlY3QgaGFzIGNoYW5nZWQsIG5vdGlmeSB0aGUgbGlzdGVuZXJzLgotCSAqLwotCXByb3RlY3RlZCBUcmVlQ2hhbmdlTGlzdGVuZXIgYnVpbGRUcmVlQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCS8vIHRyYW5zZm9ybSB0aGUgc3ViamVjdCdzIHRyZWUgY2hhbmdlIGV2ZW50cyBpbnRvIFZBTFVFIHRyZWUgY2hhbmdlIGV2ZW50cwotCQlyZXR1cm4gbmV3IFRyZWVDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIG5vZGVBZGRlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlUcmVlQXNwZWN0QWRhcHRlci50aGlzLm5vZGVBZGRlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBub2RlUmVtb3ZlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlUcmVlQXNwZWN0QWRhcHRlci50aGlzLm5vZGVSZW1vdmVkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIHRyZWVDbGVhcmVkKFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCVRyZWVBc3BlY3RBZGFwdGVyLnRoaXMudHJlZUNsZWFyZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgdHJlZUNoYW5nZWQoVHJlZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJVHJlZUFzcGVjdEFkYXB0ZXIudGhpcy50cmVlQ2hhbmdlZChldmVudCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJ0cmVlIGNoYW5nZSBsaXN0ZW5lcjogIiArIEFycmF5cy5hc0xpc3QoVHJlZUFzcGVjdEFkYXB0ZXIudGhpcy50cmVlTmFtZXMpOwotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBUcmVlVmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG5vZGVzIG9mIHRoZSBzdWJqZWN0J3MgdHJlZSBhc3BlY3QuCi0JICovCi0JcHVibGljIEl0ZXJhdG9yPEU+IG5vZGVzKCkgewotCQlyZXR1cm4gKHRoaXMuc3ViamVjdCA9PSBudWxsKSA/IEVtcHR5SXRlcmF0b3IuPEU+aW5zdGFuY2UoKSA6IHRoaXMubm9kZXNfKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBub2RlcyBvZiB0aGUgc3ViamVjdCdzIHRyZWUgYXNwZWN0LgotCSAqIEF0IHRoaXMgcG9pbnQgd2UgY2FuIGJlIHN1cmUgdGhhdCB0aGUgc3ViamVjdCBpcyBub3QgbnVsbC4KLQkgKiBAc2VlICNub2RlcygpCi0JICovCi0JcHJvdGVjdGVkIEl0ZXJhdG9yPEU+IG5vZGVzXygpIHsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIEFzcGVjdEFkYXB0ZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIE9iamVjdCBnZXRWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMubm9kZXMoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgQ2xhc3M8PyBleHRlbmRzIENoYW5nZUxpc3RlbmVyPiBnZXRMaXN0ZW5lckNsYXNzKCkgewotCQlyZXR1cm4gVHJlZUNoYW5nZUxpc3RlbmVyLmNsYXNzOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0TGlzdGVuZXJBc3BlY3ROYW1lKCkgewotCQlyZXR1cm4gTk9ERVM7Ci0JfQotCi0gICAgQE92ZXJyaWRlCi0JcHJvdGVjdGVkIGJvb2xlYW4gaGFzTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gdGhpcy5oYXNBbnlUcmVlQ2hhbmdlTGlzdGVuZXJzKE5PREVTKTsKLQl9Ci0KLSAgICBAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBmaXJlQXNwZWN0Q2hhbmdlKE9iamVjdCBvbGRWYWx1ZSwgT2JqZWN0IG5ld1ZhbHVlKSB7Ci0JCXRoaXMuZmlyZVRyZWVDaGFuZ2VkKE5PREVTKTsKLQl9Ci0KLSAgICBAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VTdWJqZWN0XygpIHsKLSAgICAJZm9yIChTdHJpbmcgdHJlZU5hbWUgOiB0aGlzLnRyZWVOYW1lcykgewotCQkJKChNb2RlbCkgdGhpcy5zdWJqZWN0KS5hZGRUcmVlQ2hhbmdlTGlzdGVuZXIodHJlZU5hbWUsIHRoaXMudHJlZUNoYW5nZUxpc3RlbmVyKTsKLQkJfQotCX0KLQotICAgIEBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZVN1YmplY3RfKCkgewotICAgIAlmb3IgKFN0cmluZyB0cmVlTmFtZSA6IHRoaXMudHJlZU5hbWVzKSB7Ci0JCQkoKE1vZGVsKSB0aGlzLnN1YmplY3QpLnJlbW92ZVRyZWVDaGFuZ2VMaXN0ZW5lcih0cmVlTmFtZSwgdGhpcy50cmVlQ2hhbmdlTGlzdGVuZXIpOwotCQl9Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgdG9TdHJpbmcoU3RyaW5nQnVpbGRlciBzYikgewotCQlmb3IgKGludCBpID0gMDsgaSA8IHRoaXMudHJlZU5hbWVzLmxlbmd0aDsgaSsrKSB7Ci0JCQlpZiAoaSAhPSAwKSB7Ci0JCQkJc2IuYXBwZW5kKCIsICIpOwotCQkJfQotCQkJc2IuYXBwZW5kKHRoaXMudHJlZU5hbWVzW2ldKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQlwcm90ZWN0ZWQgdm9pZCBub2RlQWRkZWQoVHJlZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuZmlyZU5vZGVBZGRlZChOT0RFUywgZXZlbnQuZ2V0UGF0aCgpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBub2RlUmVtb3ZlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5maXJlTm9kZVJlbW92ZWQoTk9ERVMsIGV2ZW50LmdldFBhdGgoKSk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgdHJlZUNsZWFyZWQoVHJlZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuZmlyZVRyZWVDbGVhcmVkKE5PREVTKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCB0cmVlQ2hhbmdlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5maXJlVHJlZUNoYW5nZWQoTk9ERVMsIGV2ZW50LmdldFBhdGgoKSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVHJlZVByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9UcmVlUHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxMWI2ZjFhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9UcmVlUHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTM3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5UcmVlQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuVHJlZUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlRyZWVWYWx1ZU1vZGVsOwotCi0vKioKLSAqIFRoaXMgYWJzdHJhY3QgY2xhc3MgcHJvdmlkZXMgdGhlIGluZnJhc3RydWN0dXJlIG5lZWRlZCB0byB3cmFwCi0gKiBhIHRyZWUgdmFsdWUgbW9kZWwsICJsYXppbHkiIGxpc3RlbiB0byBpdCwgYW5kIGNvbnZlcnQKLSAqIGl0cyBjaGFuZ2Ugbm90aWZpY2F0aW9ucyBpbnRvIHByb3BlcnR5IHZhbHVlIG1vZGVsIGNoYW5nZQotICogbm90aWZpY2F0aW9ucy4KLSAqIAotICogU3ViY2xhc3NlcyBtdXN0IG92ZXJyaWRlOgotICogLSAjYnVpbGRWYWx1ZSgpCi0gKiAgICAgdG8gcmV0dXJuIHRoZSBjdXJyZW50IHByb3BlcnR5IHZhbHVlLCBhcyBkZXJpdmVkIGZyb20gdGhlCi0gKiAgICAgY3VycmVudCBjb2xsZWN0aW9uIHZhbHVlCi0gKiAKLSAqIFN1YmNsYXNzZXMgbWlnaHQgd2FudCB0byBvdmVycmlkZToKLSAqIC0gI3N0YXRlQ2hhbmdlZChTdGF0ZUNoYW5nZUV2ZW50IGV2ZW50KQotICogICAgIHRvIGltcHJvdmUgcGVyZm9ybWFuY2UgKGJ5IG5vdCByZWNhbGN1bGF0aW5nIHRoZSB2YWx1ZSwgaWYgcG9zc2libGUpCi0gKi8KLXB1YmxpYyBhYnN0cmFjdCBjbGFzcyBUcmVlUHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlcjxUPgotCWV4dGVuZHMgQXNwZWN0UHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlcjxUPgotewotCS8qKiBUaGUgd3JhcHBlZCB0cmVlIHZhbHVlIG1vZGVsLiAqLwotCXByb3RlY3RlZCBmaW5hbCBUcmVlVmFsdWVNb2RlbDw/PiB0cmVlSG9sZGVyOwotCi0JLyoqIEEgbGlzdGVuZXIgdGhhdCBhbGxvd3MgdXMgdG8gc3luY2ggd2l0aCBjaGFuZ2VzIHRvIHRoZSB3cmFwcGVkIHRyZWUgaG9sZGVyLiAqLwotCXByb3RlY3RlZCBmaW5hbCBUcmVlQ2hhbmdlTGlzdGVuZXIgdHJlZUNoYW5nZUxpc3RlbmVyOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9yL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHByb3BlcnR5IHZhbHVlIG1vZGVsIHdpdGggdGhlIHNwZWNpZmllZCB3cmFwcGVkCi0JICogdHJlZSB2YWx1ZSBtb2RlbC4KLQkgKi8KLQlwcm90ZWN0ZWQgVHJlZVByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIoVHJlZVZhbHVlTW9kZWw8Pz4gdHJlZUhvbGRlcikgewotCQlzdXBlcigpOwotCQl0aGlzLnRyZWVIb2xkZXIgPSB0cmVlSG9sZGVyOwotCQl0aGlzLnRyZWVDaGFuZ2VMaXN0ZW5lciA9IHRoaXMuYnVpbGRUcmVlQ2hhbmdlTGlzdGVuZXIoKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgVHJlZUNoYW5nZUxpc3RlbmVyIGJ1aWxkVHJlZUNoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFRyZWVDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIG5vZGVBZGRlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlUcmVlUHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlci50aGlzLm5vZGVBZGRlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBub2RlUmVtb3ZlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlUcmVlUHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlci50aGlzLm5vZGVSZW1vdmVkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIHRyZWVDbGVhcmVkKFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCVRyZWVQcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyLnRoaXMudHJlZUNsZWFyZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgdHJlZUNoYW5nZWQoVHJlZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJVHJlZVByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXIudGhpcy50cmVlQ2hhbmdlZChldmVudCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJ0cmVlIGNoYW5nZSBsaXN0ZW5lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCS8qKgotCSAqIFN0YXJ0IGxpc3RlbmluZyB0byB0aGUgdHJlZSBob2xkZXIuCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlTW9kZWxfKCkgewotCQl0aGlzLnRyZWVIb2xkZXIuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKHRoaXMudHJlZUNoYW5nZUxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBTdG9wIGxpc3RlbmluZyB0byB0aGUgdHJlZSBob2xkZXIuCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZGlzZW5nYWdlTW9kZWxfKCkgewotCQl0aGlzLnRyZWVIb2xkZXIucmVtb3ZlVHJlZUNoYW5nZUxpc3RlbmVyKHRoaXMudHJlZUNoYW5nZUxpc3RlbmVyKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0b1N0cmluZyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXNiLmFwcGVuZCh0aGlzLnRyZWVIb2xkZXIpOwotCX0KLQotCQotCS8vICoqKioqKioqKiogc3RhdGUgY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JLyoqCi0JICogTm9kZXMgd2VyZSBhZGRlZCB0byB0aGUgd3JhcHBlZCB0cmVlIGhvbGRlcjsKLQkgKiBwcm9wYWdhdGUgdGhlIGNoYW5nZSBub3RpZmljYXRpb24gYXBwcm9wcmlhdGVseS4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBub2RlQWRkZWQoVHJlZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIGJ5IGRlZmF1bHQsIHNpbXBseSByZWNhbGN1bGF0ZSB0aGUgdmFsdWUgYW5kIGZpcmUgYW4gZXZlbnQKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZWQoKTsKLQl9Ci0KLQkvKioKLQkgKiBOb2RlcyB3ZXJlIHJlbW92ZWQgZnJvbSB0aGUgd3JhcHBlZCB0cmVlIGhvbGRlcjsKLQkgKiBwcm9wYWdhdGUgdGhlIGNoYW5nZSBub3RpZmljYXRpb24gYXBwcm9wcmlhdGVseS4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBub2RlUmVtb3ZlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gYnkgZGVmYXVsdCwgc2ltcGx5IHJlY2FsY3VsYXRlIHRoZSB2YWx1ZSBhbmQgZmlyZSBhbiBldmVudAotCQl0aGlzLnByb3BlcnR5Q2hhbmdlZCgpOwotCX0KLQotCS8qKgotCSAqIFRoZSB3cmFwcGVkIHRyZWUgaG9sZGVyIHdhcyBjbGVhcmVkOwotCSAqIHByb3BhZ2F0ZSB0aGUgY2hhbmdlIG5vdGlmaWNhdGlvbiBhcHByb3ByaWF0ZWx5LgotCSAqLwotCXByb3RlY3RlZCB2b2lkIHRyZWVDbGVhcmVkKFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQkvLyBieSBkZWZhdWx0LCBzaW1wbHkgcmVjYWxjdWxhdGUgdGhlIHZhbHVlIGFuZCBmaXJlIGFuIGV2ZW50Ci0JCXRoaXMucHJvcGVydHlDaGFuZ2VkKCk7Ci0JfQotCi0JLyoqCi0JICogVGhlIHdyYXBwZWQgdHJlZSBob2xkZXIgY2hhbmdlZDsKLQkgKiBwcm9wYWdhdGUgdGhlIGNoYW5nZSBub3RpZmljYXRpb24gYXBwcm9wcmlhdGVseS4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCB0cmVlQ2hhbmdlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gYnkgZGVmYXVsdCwgc2ltcGx5IHJlY2FsY3VsYXRlIHRoZSB2YWx1ZSBhbmQgZmlyZSBhbiBldmVudAotCQl0aGlzLnByb3BlcnR5Q2hhbmdlZCgpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1ZhbHVlQXNwZWN0QWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1ZhbHVlQXNwZWN0QWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2ZmVhMmU4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9WYWx1ZUFzcGVjdEFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE1NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQ2hhbmdlU3VwcG9ydDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Qcm9wZXJ0eUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlN0YXRlQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci0KLS8qKgotICogQWJzdHJhY3QgbW9kZWwgdGhhdCBwcm92aWRlcyBiZWhhdmlvciBmb3Igd3JhcHBpbmcgYSBwcm9wZXJ0eQotICogdmFsdWUgbW9kZWwgYW5kIGxpc3RlbmluZyBmb3IgY2hhbmdlcyB0byBhc3BlY3RzIG9mIHRoZSAqdmFsdWUqIGNvbnRhaW5lZAotICogYnkgdGhlIHByb3BlcnR5IHZhbHVlIG1vZGVsLiBDaGFuZ2VzIHRvIHRoZSBhY3R1YWwgdmFsdWUgYXJlIGFsc28gbW9uaXRvcmVkLgotICogCi0gKiBUaGlzIGlzIHVzZWZ1bCBpZiB5b3UgaGF2ZSBhIHZhbHVlIHRoYXQgbWF5IGNoYW5nZSwgYnV0IHdob3NlIGFzcGVjdHMgY2FuIGFsc28KLSAqIGNoYW5nZSBpbiBhIGZhc2hpb24gdGhhdCBtaWdodCBiZSBvZiBpbnRlcmVzdCB0byB0aGUgY2xpZW50LgotICogCi0gKiBOQjogQ2xpZW50cyB3aWxsIG5lZWQgdG8gbGlzdGVuIGZvciB0d28gZGlmZmVyZW50IGNoYW5nZSBub3RpZmljYXRpb25zOiBhIHByb3BlcnR5Ci0gKiBjaGFuZ2UgZXZlbnQgd2lsbCBiZSBiZSBmaXJlZCB3aGVuIHRoZSB2YWx1ZSBjaGFuZ2VzOyBhIHN0YXRlIGNoYW5nZSBldmVudAotICogd2lsbCBiZSBmaXJlZCB3aGVuIGFuIGFzcGVjdCBvZiB0aGUgdmFsdWUgY2hhbmdlcy4KLSAqIAotICogU3ViY2xhc3NlcyBuZWVkIHRvIG92ZXJyaWRlIHR3byBtZXRob2RzOgotICogCi0gKiAjZW5nYWdlVmFsdWVfKCkKLSAqICAgICBiZWdpbiBsaXN0ZW5pbmcgdG8gdGhlIGFwcHJvcHJpYXRlIGFzcGVjdCBvZiB0aGUgdmFsdWUgYW5kIGNhbGwKLSAqICAgICAjdmFsdWVBc3BlY3RDaGFuZ2VkKE9iamVjdCkgd2hlbmV2ZXIgdGhlIGFzcGVjdCBjaGFuZ2VzCi0gKiAKLSAqICNkaXNlbmdhZ2VWYWx1ZV8oKQotICogICAgIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSBhcHByb3ByaWF0ZSBhc3BlY3Qgb2YgdGhlIHZhbHVlCi0gKi8KLXB1YmxpYyBhYnN0cmFjdCBjbGFzcyBWYWx1ZUFzcGVjdEFkYXB0ZXI8VD4KLQlleHRlbmRzIFByb3BlcnR5VmFsdWVNb2RlbFdyYXBwZXI8VD4KLQlpbXBsZW1lbnRzIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQ+Ci17Ci0JLyoqIENhY2hlIHRoZSB2YWx1ZSBzbyB3ZSBjYW4gZGlzZW5nYWdlLiBOdWxsIHVudGlsIHdlIGhhdmUgYSBsaXN0ZW5lciovCi0JcHJvdGVjdGVkIFQgdmFsdWU7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdG9yIC0gdGhlIHZhbHVlIGhvbGRlciBpcyByZXF1aXJlZC4KLQkgKi8KLQlwcm90ZWN0ZWQgVmFsdWVBc3BlY3RBZGFwdGVyKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQ+IHZhbHVlSG9sZGVyKSB7Ci0JCXN1cGVyKHZhbHVlSG9sZGVyKTsKLQl9Ci0KLQkvKioKLQkgKiBPdmVycmlkZSB0byBhbGxvdyBib3RoIHByb3BlcnR5IHZhbHVlIG1vZGVsIGNoYW5nZSBhbmQgc3RhdGUgY2hhbmdlCi0JICogbGlzdGVuZXJzLgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCBDaGFuZ2VTdXBwb3J0IGJ1aWxkQ2hhbmdlU3VwcG9ydCgpIHsKLQkJcmV0dXJuIG5ldyBDaGFuZ2VTdXBwb3J0KHRoaXMpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBQcm9wZXJ0eVZhbHVlTW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIFQgZ2V0VmFsdWUoKSB7Ci0JCXJldHVybiB0aGlzLnZhbHVlOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgdm9pZCBzZXRWYWx1ZShUIHZhbHVlKSB7Ci0JCXRoaXMudmFsdWVIb2xkZXIoKS5zZXRWYWx1ZSh2YWx1ZSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIFByb3BlcnR5VmFsdWVNb2RlbFdyYXBwZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdmFsdWVDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5kaXNlbmdhZ2VWYWx1ZSgpOwotCQl0aGlzLmVuZ2FnZVZhbHVlKCk7Ci0JCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChldmVudC5jbG9uZVdpdGhTb3VyY2UodGhpcykpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBleHRlbmQgY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIGFkZFN0YXRlQ2hhbmdlTGlzdGVuZXIoU3RhdGVDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlpZiAodGhpcy5oYXNOb1N0YXRlQ2hhbmdlTGlzdGVuZXJzKCkpIHsKLQkJCXRoaXMuZW5nYWdlVmFsdWUoKTsKLQkJfQotCQlzdXBlci5hZGRTdGF0ZUNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgcmVtb3ZlU3RhdGVDaGFuZ2VMaXN0ZW5lcihTdGF0ZUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXN1cGVyLnJlbW92ZVN0YXRlQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlpZiAodGhpcy5oYXNOb1N0YXRlQ2hhbmdlTGlzdGVuZXJzKCkpIHsKLQkJCXRoaXMuZGlzZW5nYWdlVmFsdWUoKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBTdGFydCBsaXN0ZW5pbmcgdG8gdGhlIGN1cnJlbnQgdmFsdWUuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlVmFsdWUoKSB7Ci0JCXRoaXMudmFsdWUgPSB0aGlzLnZhbHVlSG9sZGVyLmdldFZhbHVlKCk7Ci0JCWlmICh0aGlzLnZhbHVlICE9IG51bGwpIHsKLQkJCXRoaXMuZW5nYWdlVmFsdWVfKCk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBTdGFydCBsaXN0ZW5pbmcgdG8gdGhlIGN1cnJlbnQgdmFsdWUuCi0JICogQXQgdGhpcyBwb2ludCB3ZSBjYW4gYmUgc3VyZSB0aGF0IHRoZSB2YWx1ZSBpcyBub3QgbnVsbC4KLQkgKi8KLQlwcm90ZWN0ZWQgYWJzdHJhY3Qgdm9pZCBlbmdhZ2VWYWx1ZV8oKTsKLQotCS8qKgotCSAqIFN0b3AgbGlzdGVuaW5nIHRvIHRoZSBjdXJyZW50IHZhbHVlLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZVZhbHVlKCkgewotCQlpZiAodGhpcy52YWx1ZSAhPSBudWxsKSB7Ci0JCQl0aGlzLmRpc2VuZ2FnZVZhbHVlXygpOwotCQkJdGhpcy52YWx1ZSA9IG51bGw7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBTdG9wIGxpc3RlbmluZyB0byB0aGUgY3VycmVudCB2YWx1ZS4KLQkgKiBBdCB0aGlzIHBvaW50IHdlIGNhbiBiZSBzdXJlIHRoYXQgdGhlIHZhbHVlIGlzIG5vdCBudWxsLgotCSAqLwotCXByb3RlY3RlZCBhYnN0cmFjdCB2b2lkIGRpc2VuZ2FnZVZhbHVlXygpOwotCi0JLyoqCi0JICogU3ViY2xhc3NlcyBzaG91bGQgY2FsbCB0aGlzIG1ldGhvZCB3aGVuZXZlciB0aGUgdmFsdWUncyBhc3BlY3QgY2hhbmdlcy4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCB2YWx1ZUFzcGVjdENoYW5nZWQoKSB7Ci0JCXRoaXMuZmlyZVN0YXRlQ2hhbmdlZCgpOwotCX0KLQotCS8qKgotCSAqIE91ciBjb25zdHJ1Y3RvcnMgYWNjZXB0IG9ubHkgYSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUMT4uCi0JICovCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJvdGVjdGVkIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQ+IHZhbHVlSG9sZGVyKCkgewotCQlyZXR1cm4gKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQ+KSB0aGlzLnZhbHVlSG9sZGVyOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1ZhbHVlQ29sbGVjdGlvbkFkYXB0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9WYWx1ZUNvbGxlY3Rpb25BZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDA2OWZjMGUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1ZhbHVlQ29sbGVjdGlvbkFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDg2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLk1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LkNvbGxlY3Rpb25DaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Db2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci0KLS8qKgotICogRXh0ZW5kIFZhbHVlQXNwZWN0QWRhcHRlciB0byBsaXN0ZW4gdG8gb25lIG9yIG1vcmUgY29sbGVjdGlvbgotICogYXNwZWN0cyBvZiB0aGUgdmFsdWUgaW4gdGhlIHdyYXBwZWQgdmFsdWUgbW9kZWwuCi0gKi8KLXB1YmxpYyBjbGFzcyBWYWx1ZUNvbGxlY3Rpb25BZGFwdGVyPFQgZXh0ZW5kcyBNb2RlbD4KLQlleHRlbmRzIFZhbHVlQXNwZWN0QWRhcHRlcjxUPgotewotCi0JLyoqIFRoZSBuYW1lcyBvZiB0aGUgdmFsdWUncyBjb2xsZWN0aW9ucyB0aGF0IHdlIGxpc3RlbiB0by4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgU3RyaW5nW10gY29sbGVjdGlvbk5hbWVzOwotCi0JLyoqIExpc3RlbmVyIHRoYXQgbGlzdGVucyB0byB0aGUgdmFsdWUuICovCi0JcHJvdGVjdGVkIGZpbmFsIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciB2YWx1ZUNvbGxlY3Rpb25MaXN0ZW5lcjsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgdmFsdWUgY29sbGVjdGlvbnMuCi0JICovCi0JcHVibGljIFZhbHVlQ29sbGVjdGlvbkFkYXB0ZXIoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VD4gdmFsdWVIb2xkZXIsIFN0cmluZy4uLiBjb2xsZWN0aW9uTmFtZXMpIHsKLQkJc3VwZXIodmFsdWVIb2xkZXIpOwotCQl0aGlzLmNvbGxlY3Rpb25OYW1lcyA9IGNvbGxlY3Rpb25OYW1lczsKLQkJdGhpcy52YWx1ZUNvbGxlY3Rpb25MaXN0ZW5lciA9IHRoaXMuYnVpbGRWYWx1ZUNvbGxlY3Rpb25MaXN0ZW5lcigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0KLQkvKioKLQkgKiBBbGwgd2UgcmVhbGx5IGNhcmUgYWJvdXQgaXMgdGhlIGZhY3QgdGhhdCBhIENvbGxlY3Rpb24gYXNwZWN0IGhhcyAKLQkgKiBjaGFuZ2VkLiBEbyB0aGUgc2FtZSB0aGluZyBubyBtYXR0ZXIgd2hpY2ggZXZlbnQgb2NjdXJzLgotCSAqLwotCXByb3RlY3RlZCBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgYnVpbGRWYWx1ZUNvbGxlY3Rpb25MaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQkJCVZhbHVlQ29sbGVjdGlvbkFkYXB0ZXIudGhpcy52YWx1ZUFzcGVjdENoYW5nZWQoKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlWYWx1ZUNvbGxlY3Rpb25BZGFwdGVyLnRoaXMudmFsdWVBc3BlY3RDaGFuZ2VkKCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBjb2xsZWN0aW9uQ2xlYXJlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlWYWx1ZUNvbGxlY3Rpb25BZGFwdGVyLnRoaXMudmFsdWVBc3BlY3RDaGFuZ2VkKCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBjb2xsZWN0aW9uQ2hhbmdlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlWYWx1ZUNvbGxlY3Rpb25BZGFwdGVyLnRoaXMudmFsdWVBc3BlY3RDaGFuZ2VkKCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJ2YWx1ZSBjb2xsZWN0aW9uIGxpc3RlbmVyOiAiICsgQXJyYXlzLmFzTGlzdChWYWx1ZUNvbGxlY3Rpb25BZGFwdGVyLnRoaXMuY29sbGVjdGlvbk5hbWVzKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VWYWx1ZV8oKSB7Ci0JCWZvciAoU3RyaW5nIGNvbGxlY3Rpb25OYW1lIDogdGhpcy5jb2xsZWN0aW9uTmFtZXMpIHsKLQkJCXRoaXMudmFsdWUuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKGNvbGxlY3Rpb25OYW1lLCB0aGlzLnZhbHVlQ29sbGVjdGlvbkxpc3RlbmVyKTsKLQkJfQotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZVZhbHVlXygpIHsKLQkJZm9yIChTdHJpbmcgY29sbGVjdGlvbk5hbWUgOiB0aGlzLmNvbGxlY3Rpb25OYW1lcykgewotCQkJdGhpcy52YWx1ZS5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoY29sbGVjdGlvbk5hbWUsIHRoaXMudmFsdWVDb2xsZWN0aW9uTGlzdGVuZXIpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVmFsdWVMaXN0QWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1ZhbHVlTGlzdEFkYXB0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODVjYjQyOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVmFsdWVMaXN0QWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsOTIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuTGlzdENoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkxpc3RDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBFeHRlbmQgVmFsdWVBc3BlY3RBZGFwdGVyIHRvIGxpc3RlbiB0byBvbmUgb3IgbW9yZSBsaXN0Ci0gKiBhc3BlY3RzIG9mIHRoZSB2YWx1ZSBpbiB0aGUgd3JhcHBlZCB2YWx1ZSBtb2RlbC4KLSAqLwotcHVibGljIGNsYXNzIFZhbHVlTGlzdEFkYXB0ZXI8VCBleHRlbmRzIE1vZGVsPgotCWV4dGVuZHMgVmFsdWVBc3BlY3RBZGFwdGVyPFQ+Ci17Ci0KLQkvKiogVGhlIG5hbWVzIG9mIHRoZSB2YWx1ZSdzIGxpc3RzIHRoYXQgd2UgbGlzdGVuIHRvLiAqLwotCXByb3RlY3RlZCBmaW5hbCBTdHJpbmdbXSBsaXN0TmFtZXM7Ci0KLQkvKiogTGlzdGVuZXIgdGhhdCBsaXN0ZW5zIHRvIHRoZSB2YWx1ZS4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgTGlzdENoYW5nZUxpc3RlbmVyIHZhbHVlTGlzdExpc3RlbmVyOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gYWRhcHRlciBmb3IgdGhlIHNwZWNpZmllZCB2YWx1ZSBsaXN0cy4KLQkgKi8KLQlwdWJsaWMgVmFsdWVMaXN0QWRhcHRlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUPiB2YWx1ZUhvbGRlciwgU3RyaW5nLi4uIGxpc3ROYW1lcykgewotCQlzdXBlcih2YWx1ZUhvbGRlcik7Ci0JCXRoaXMubGlzdE5hbWVzID0gbGlzdE5hbWVzOwotCQl0aGlzLnZhbHVlTGlzdExpc3RlbmVyID0gdGhpcy5idWlsZFZhbHVlTGlzdExpc3RlbmVyKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIEFsbCB3ZSByZWFsbHkgY2FyZSBhYm91dCBpcyB0aGUgZmFjdCB0aGF0IGEgTGlzdCBhc3BlY3QgaGFzIAotCSAqIGNoYW5nZWQuIERvIHRoZSBzYW1lIHRoaW5nIG5vIG1hdHRlciB3aGljaCBldmVudCBvY2N1cnMuCi0JICovCi0JcHJvdGVjdGVkIExpc3RDaGFuZ2VMaXN0ZW5lciBidWlsZFZhbHVlTGlzdExpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IExpc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJVmFsdWVMaXN0QWRhcHRlci50aGlzLnZhbHVlQXNwZWN0Q2hhbmdlZCgpOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCVZhbHVlTGlzdEFkYXB0ZXIudGhpcy52YWx1ZUFzcGVjdENoYW5nZWQoKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJVmFsdWVMaXN0QWRhcHRlci50aGlzLnZhbHVlQXNwZWN0Q2hhbmdlZCgpOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNNb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlWYWx1ZUxpc3RBZGFwdGVyLnRoaXMudmFsdWVBc3BlY3RDaGFuZ2VkKCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlWYWx1ZUxpc3RBZGFwdGVyLnRoaXMudmFsdWVBc3BlY3RDaGFuZ2VkKCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBsaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlWYWx1ZUxpc3RBZGFwdGVyLnRoaXMudmFsdWVBc3BlY3RDaGFuZ2VkKCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJ2YWx1ZSBsaXN0IGxpc3RlbmVyOiAiICsgQXJyYXlzLmFzTGlzdChWYWx1ZUxpc3RBZGFwdGVyLnRoaXMubGlzdE5hbWVzKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VWYWx1ZV8oKSB7Ci0JCWZvciAoU3RyaW5nIGxpc3ROYW1lIDogdGhpcy5saXN0TmFtZXMpIHsKLQkJCXRoaXMudmFsdWUuYWRkTGlzdENoYW5nZUxpc3RlbmVyKGxpc3ROYW1lLCB0aGlzLnZhbHVlTGlzdExpc3RlbmVyKTsKLQkJfQotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZVZhbHVlXygpIHsKLQkJZm9yIChTdHJpbmcgbGlzdE5hbWUgOiB0aGlzLmxpc3ROYW1lcykgewotCQkJdGhpcy52YWx1ZS5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIobGlzdE5hbWUsIHRoaXMudmFsdWVMaXN0TGlzdGVuZXIpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVmFsdWVQcm9wZXJ0eUFkYXB0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9WYWx1ZVByb3BlcnR5QWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhM2Q3ZTAxLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9WYWx1ZVByb3BlcnR5QWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIEV4dGVuZCBWYWx1ZUFzcGVjdEFkYXB0ZXIgdG8gbGlzdGVuIHRvIG9uZSBvciBtb3JlCi0gKiBwcm9wZXJ0aWVzIG9mIHRoZSB2YWx1ZSBpbiB0aGUgd3JhcHBlZCB2YWx1ZSBtb2RlbC4KLSAqLwotcHVibGljIGNsYXNzIFZhbHVlUHJvcGVydHlBZGFwdGVyPFQgZXh0ZW5kcyBNb2RlbD4KLQlleHRlbmRzIFZhbHVlQXNwZWN0QWRhcHRlcjxUPgotewotCS8qKiBUaGUgbmFtZXMgb2YgdGhlIHZhbHVlJ3MgcHJvcGVydGllcyB0aGF0IHdlIGxpc3RlbiB0by4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgU3RyaW5nW10gcHJvcGVydHlOYW1lczsKLQotCS8qKiBMaXN0ZW5lciB0aGF0IGxpc3RlbnMgdG8gdGhlIHZhbHVlLiAqLwotCXByb3RlY3RlZCBmaW5hbCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIHZhbHVlUHJvcGVydHlMaXN0ZW5lcjsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgdmFsdWUgcHJvcGVydGllcy4KLQkgKi8KLQlwdWJsaWMgVmFsdWVQcm9wZXJ0eUFkYXB0ZXIoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VD4gdmFsdWVIb2xkZXIsIFN0cmluZy4uLiBwcm9wZXJ0eU5hbWVzKSB7Ci0JCXN1cGVyKHZhbHVlSG9sZGVyKTsKLQkJdGhpcy5wcm9wZXJ0eU5hbWVzID0gcHJvcGVydHlOYW1lczsKLQkJdGhpcy52YWx1ZVByb3BlcnR5TGlzdGVuZXIgPSB0aGlzLmJ1aWxkVmFsdWVQcm9wZXJ0eUxpc3RlbmVyKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkVmFsdWVQcm9wZXJ0eUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCVZhbHVlUHJvcGVydHlBZGFwdGVyLnRoaXMudmFsdWVBc3BlY3RDaGFuZ2VkKCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJ2YWx1ZSBwcm9wZXJ0eSBsaXN0ZW5lcjogIiArIEFycmF5cy5hc0xpc3QoVmFsdWVQcm9wZXJ0eUFkYXB0ZXIudGhpcy5wcm9wZXJ0eU5hbWVzKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGVuZ2FnZVZhbHVlXygpIHsKLQkJZm9yIChTdHJpbmcgcHJvcGVydHlOYW1lIDogdGhpcy5wcm9wZXJ0eU5hbWVzKSB7Ci0JCQl0aGlzLnZhbHVlLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIocHJvcGVydHlOYW1lLCB0aGlzLnZhbHVlUHJvcGVydHlMaXN0ZW5lcik7Ci0JCX0KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VWYWx1ZV8oKSB7Ci0JCWZvciAoU3RyaW5nIHByb3BlcnR5TmFtZSA6IHRoaXMucHJvcGVydHlOYW1lcykgewotCQkJdGhpcy52YWx1ZS5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHByb3BlcnR5TmFtZSwgdGhpcy52YWx1ZVByb3BlcnR5TGlzdGVuZXIpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVmFsdWVTdGF0ZUFkYXB0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9WYWx1ZVN0YXRlQWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkNTE2ZmRiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9WYWx1ZVN0YXRlQWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNjYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLk1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlN0YXRlQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuU3RhdGVDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBFeHRlbmQgVmFsdWVBc3BlY3RBZGFwdGVyIHRvIGxpc3RlbiB0byB0aGUKLSAqICJzdGF0ZSIgb2YgdGhlIHZhbHVlIGluIHRoZSB3cmFwcGVkIHZhbHVlIG1vZGVsLgotICovCi1wdWJsaWMgY2xhc3MgVmFsdWVTdGF0ZUFkYXB0ZXI8VCBleHRlbmRzIE1vZGVsPgotCWV4dGVuZHMgVmFsdWVBc3BlY3RBZGFwdGVyPFQ+Ci17Ci0JLyoqIExpc3RlbmVyIHRoYXQgbGlzdGVucyB0byB2YWx1ZS4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgU3RhdGVDaGFuZ2VMaXN0ZW5lciB2YWx1ZVN0YXRlTGlzdGVuZXI7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBhZGFwdGVyIGZvciB0aGUgdmFsdWUgc3RhdGUuCi0JICovCi0JcHVibGljIFZhbHVlU3RhdGVBZGFwdGVyKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQ+IHZhbHVlSG9sZGVyKSB7Ci0JCXN1cGVyKHZhbHVlSG9sZGVyKTsKLQkJdGhpcy52YWx1ZVN0YXRlTGlzdGVuZXIgPSB0aGlzLmJ1aWxkVmFsdWVTdGF0ZUxpc3RlbmVyKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCXByb3RlY3RlZCBTdGF0ZUNoYW5nZUxpc3RlbmVyIGJ1aWxkVmFsdWVTdGF0ZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFN0YXRlQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoU3RhdGVDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCVZhbHVlU3RhdGVBZGFwdGVyLnRoaXMudmFsdWVBc3BlY3RDaGFuZ2VkKCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJ2YWx1ZSBzdGF0ZSBsaXN0ZW5lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VWYWx1ZV8oKSB7Ci0JCXRoaXMudmFsdWUuYWRkU3RhdGVDaGFuZ2VMaXN0ZW5lcih0aGlzLnZhbHVlU3RhdGVMaXN0ZW5lcik7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZGlzZW5nYWdlVmFsdWVfKCkgewotCQl0aGlzLnZhbHVlLnJlbW92ZVN0YXRlQ2hhbmdlTGlzdGVuZXIodGhpcy52YWx1ZVN0YXRlTGlzdGVuZXIpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1ZhbHVlVHJlZUFkYXB0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9WYWx1ZVRyZWVBZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQxMzYxZWQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL1ZhbHVlVHJlZUFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDg0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLk1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlRyZWVDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5UcmVlQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci0KLS8qKgotICogRXh0ZW5kIFZhbHVlQXNwZWN0QWRhcHRlciB0byBsaXN0ZW4gdG8gb25lIG9yIG1vcmUKLSAqIHRyZWUgYXNwZWN0cyBvZiB0aGUgdmFsdWUgaW4gdGhlIHdyYXBwZWQgdmFsdWUgbW9kZWwuCi0gKi8KLXB1YmxpYyBjbGFzcyBWYWx1ZVRyZWVBZGFwdGVyPFQgZXh0ZW5kcyBNb2RlbD4KLQlleHRlbmRzIFZhbHVlQXNwZWN0QWRhcHRlcjxUPgotewotCS8qKiBUaGUgbmFtZXMgb2YgdGhlIHZhbHVlJ3MgdHJlZXMgdGhhdCB3ZSBsaXN0ZW4gdG8uICovCi0JcHJvdGVjdGVkIGZpbmFsIFN0cmluZ1tdIHRyZWVOYW1lczsKLQotCS8qKiBMaXN0ZW5lciB0aGF0IGxpc3RlbnMgdG8gdGhlIHZhbHVlLiAqLwotCXByb3RlY3RlZCBmaW5hbCBUcmVlQ2hhbmdlTGlzdGVuZXIgdmFsdWVUcmVlTGlzdGVuZXI7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBhZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIHZhbHVlIHRyZWVzLgotCSAqLwotCXB1YmxpYyBWYWx1ZVRyZWVBZGFwdGVyKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQ+IHZhbHVlSG9sZGVyLCBTdHJpbmcuLi4gdHJlZU5hbWVzKSB7Ci0JCXN1cGVyKHZhbHVlSG9sZGVyKTsKLQkJdGhpcy50cmVlTmFtZXMgPSB0cmVlTmFtZXM7Ci0JCXRoaXMudmFsdWVUcmVlTGlzdGVuZXIgPSB0aGlzLmJ1aWxkVmFsdWVUcmVlTGlzdGVuZXIoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JcHJvdGVjdGVkIFRyZWVDaGFuZ2VMaXN0ZW5lciBidWlsZFZhbHVlVHJlZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFRyZWVDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIG5vZGVBZGRlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlWYWx1ZVRyZWVBZGFwdGVyLnRoaXMudmFsdWVBc3BlY3RDaGFuZ2VkKCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBub2RlUmVtb3ZlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlWYWx1ZVRyZWVBZGFwdGVyLnRoaXMudmFsdWVBc3BlY3RDaGFuZ2VkKCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCB0cmVlQ2xlYXJlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlWYWx1ZVRyZWVBZGFwdGVyLnRoaXMudmFsdWVBc3BlY3RDaGFuZ2VkKCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCB0cmVlQ2hhbmdlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlWYWx1ZVRyZWVBZGFwdGVyLnRoaXMudmFsdWVBc3BlY3RDaGFuZ2VkKCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJ2YWx1ZSB0cmVlIGxpc3RlbmVyOiAiICsgQXJyYXlzLmFzTGlzdChWYWx1ZVRyZWVBZGFwdGVyLnRoaXMudHJlZU5hbWVzKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlVmFsdWVfKCkgewotCQlmb3IgKFN0cmluZyB0cmVlTmFtZSA6IHRoaXMudHJlZU5hbWVzKSB7Ci0JCQl0aGlzLnZhbHVlLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcih0cmVlTmFtZSwgdGhpcy52YWx1ZVRyZWVMaXN0ZW5lcik7Ci0JCX0KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VWYWx1ZV8oKSB7Ci0JCWZvciAoU3RyaW5nIHRyZWVOYW1lIDogdGhpcy50cmVlTmFtZXMpIHsKLQkJCXRoaXMudmFsdWUucmVtb3ZlVHJlZUNoYW5nZUxpc3RlbmVyKHRyZWVOYW1lLCB0aGlzLnZhbHVlVHJlZUxpc3RlbmVyKTsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3ByZWZzL1ByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9wcmVmcy9QcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQ0YTlkNTYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3ByZWZzL1ByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDM0NSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnByZWZzOwotCi1pbXBvcnQgamF2YS51dGlsLnByZWZzLlByZWZlcmVuY2VDaGFuZ2VFdmVudDsKLWltcG9ydCBqYXZhLnV0aWwucHJlZnMuUHJlZmVyZW5jZUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IGphdmEudXRpbC5wcmVmcy5QcmVmZXJlbmNlczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5CaWRpU3RyaW5nQ29udmVydGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU3RhdGljUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIFRoaXMgYWRhcHRlciB3cmFwcyBhIFByZWZlcmVuY2UgYW5kIGNvbnZlcnRzIGl0IGludG8gYSBQcm9wZXJ0eVZhbHVlTW9kZWwuCi0gKiBJdCBsaXN0ZW5zIGZvciB0aGUgYXBwcm9wcmlhdGUgInByZWZlcmVuY2UiIGNoYW5nZXMgYW5kIGNvbnZlcnRzIHRoZW0gaW50bwotICogVkFMVUUgcHJvcGVydHkgY2hhbmdlcy4gSXQgYWxzbyBhbGxvd3MgdGhlIHNwZWNpZmljYXRpb24gb2YgYSBkZWZhdWx0IHZhbHVlCi0gKiBmb3IgdGhlIFByZWZlcmVuY2UsIHdoaWNoLCBieSBkZWZhdWx0LCBpcyBudWxsIChhbmQgaXMgcHJvYmFibHkgKm5vdCogYSB2ZXJ5Ci0gKiBnb29kIGRlZmF1bHQpLgotICogCi0gKiBZb3UgY2FuIGNvbmZpZ3VyZSB3aGV0aGVyIHRoZSBwcmVmZXJlbmNlJ3MgdmFsdWUgaXMgcmV0dXJuZWQsCi0gKiB1bmNoYW5nZWQsIGFzIGEgc3RyaW5nIG9yIGFzIHNvbWUgb3RoZXIgb2JqZWN0IChlLmcuIGFuIEludGVnZXIpIGJ5Ci0gKiBzZXR0aW5nIHRoZSBhZGFwdGVyJ3MgY29udmVydGVyLiBJbnRlcm5hbGx5LCB0aGUgcHJlZmVyZW5jZSdzIHZhbHVlCi0gKiBpcyBzdG9yZWQgYXMgdGhlIGNvbnZlcnRlZCBvYmplY3Q7IGFuZCB0aGUgY29udmVyc2lvbnMgdGFrZSBwbGFjZQotICogd2hlbiByZWFkaW5nIG9yIHdyaXRpbmcgZnJvbSB0aGUgcHJlZmVyZW5jZXMgbm9kZSBvciByZXRyaWV2aW5nIHRoZQotICogdmFsdWUgZnJvbSBhbiBldmVudCBmaXJlZCBieSB0aGUgcHJlZmVyZW5jZXMgbm9kZS4KLSAqIAotICogVGhpcyBhZGFwdGVyIGlzIGEgYml0IGRpZmZlcmVudCBmcm9tIG1vc3Qgb3RoZXIgYWRhcHRlcnMgYmVjYXVzZSB0aGUKLSAqIGNoYW5nZSBldmVudHMgZmlyZWQgb2ZmIGJ5IGEgUHJlZmVyZW5jZXMgbm9kZSBhcmUgYXN5bmNocm9ub3VzIGZyb20KLSAqIHRoZSBjaGFuZ2UgaXRzZWxmLiAoQWJzdHJhY3RQcmVmZXJlbmNlcyB1c2VzIGFuIGV2ZW50IGRpc3BhdGNoIGRhZW1vbi4pCi0gKiBBcyBhIHJlc3VsdCwgYSBjbGllbnQgY2FuIHNldCBvdXIgdmFsdWUgd2l0aCAjc2V0VmFsdWUoT2JqZWN0KSBhbmQgd2UKLSAqIHdpbGwgcmV0dXJuIGZyb20gdGhhdCBtZXRob2QgYmVmb3JlIHdlIGV2ZXIgcmVjZWl2ZSBub3RpZmljYXRpb24gZnJvbQotICogdGhlIFByZWZlcmVuY2VzIG5vZGUgdGhhdCAqaXQqIGhhcyBjaGFuZ2VkLiBUaGlzIG1lYW5zIHdlIGNhbm5vdAotICogcmVseSBvbiB0aGF0IGV2ZW50IHRvIGtlZXAgb3VyIGludGVybmFsbHkgY2FjaGVkIHZhbHVlIGluIHN5bmNoLgotICovCi1wdWJsaWMgY2xhc3MgUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbDxQPgotCWV4dGVuZHMgQXNwZWN0QWRhcHRlcjxQcmVmZXJlbmNlcz4KLQlpbXBsZW1lbnRzIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFA+Ci17Ci0JLyoqIFRoZSBrZXkgdG8gdGhlIHByZWZlcmVuY2Ugd2UgdXNlIGZvciB0aGUgdmFsdWUuICovCi0JcHJvdGVjdGVkIGZpbmFsIFN0cmluZyBrZXk7Ci0KLQkvKioKLQkgKiBDYWNoZSB0aGUgY3VycmVudCAob2JqZWN0KSB2YWx1ZSBvZiB0aGUgcHJlZmVyZW5jZSBzbyB3ZQotCSAqIGNhbiBwYXNzIGFuICJvbGQgdmFsdWUiIHdoZW4gd2UgZmlyZSBhIHByb3BlcnR5IGNoYW5nZSBldmVudC4KLQkgKi8KLQlwcm90ZWN0ZWQgUCB2YWx1ZTsKLQotCS8qKgotCSAqIFRoZSBkZWZhdWx0IChvYmplY3QpIHZhbHVlIHJldHVybmVkIGlmIHRoZXJlIGlzIG5vIHZhbHVlCi0JICogYXNzb2NpYXRlZCB3aXRoIHRoZSBwcmVmZXJlbmNlLgotCSAqLwotCXByb3RlY3RlZCBmaW5hbCBQIGRlZmF1bHRWYWx1ZTsKLQotCS8qKgotCSAqIFRoaXMgY29udmVydGVyIGlzIHVzZWQgdG8gY29udmVydCB0aGUgcHJlZmVyZW5jZSdzCi0JICogc3RyaW5nIHZhbHVlIHRvIGFuZCBmcm9tIGFuIG9iamVjdC4KLQkgKi8KLQlwcm90ZWN0ZWQgZmluYWwgQmlkaVN0cmluZ0NvbnZlcnRlcjxQPiBjb252ZXJ0ZXI7Ci0KLQkvKiogQSBsaXN0ZW5lciB0aGF0IGxpc3RlbnMgdG8gdGhlIGFwcHJvcHJpYXRlIHByZWZlcmVuY2UuICovCi0JcHJvdGVjdGVkIGZpbmFsIFByZWZlcmVuY2VDaGFuZ2VMaXN0ZW5lciBwcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXI7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBhZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIHByZWZlcmVuY2UuCi0JICogVGhlIGRlZmF1bHQgdmFsdWUgb2YgdGhlIHByZWZlcmVuY2Ugd2lsbCBiZSBudWxsLgotCSAqLwotCXB1YmxpYyBQcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsKFByZWZlcmVuY2VzIHByZWZlcmVuY2VzLCBTdHJpbmcga2V5KSB7Ci0JCXRoaXMocHJlZmVyZW5jZXMsIGtleSwgbnVsbCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgcHJlZmVyZW5jZSB3aXRoCi0JICogdGhlIHNwZWNpZmllZCBkZWZhdWx0IHZhbHVlIGZvciB0aGUgcHJlZmVyZW5jZS4KLQkgKi8KLQlwdWJsaWMgUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbChQcmVmZXJlbmNlcyBwcmVmZXJlbmNlcywgU3RyaW5nIGtleSwgUCBkZWZhdWx0VmFsdWUpIHsKLQkJdGhpcyhwcmVmZXJlbmNlcywga2V5LCBkZWZhdWx0VmFsdWUsIEJpZGlTdHJpbmdDb252ZXJ0ZXIuRGVmYXVsdC48UD5pbnN0YW5jZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gYWRhcHRlciBmb3IgdGhlIHNwZWNpZmllZCBwcmVmZXJlbmNlIHdpdGgKLQkgKiB0aGUgc3BlY2lmaWVkIGRlZmF1bHQgdmFsdWUgZm9yIHRoZSBwcmVmZXJlbmNlLgotCSAqLwotCXB1YmxpYyBQcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsKFByZWZlcmVuY2VzIHByZWZlcmVuY2VzLCBTdHJpbmcga2V5LCBQIGRlZmF1bHRWYWx1ZSwgQmlkaVN0cmluZ0NvbnZlcnRlcjxQPiBjb252ZXJ0ZXIpIHsKLQkJdGhpcyhuZXcgU3RhdGljUHJvcGVydHlWYWx1ZU1vZGVsPFByZWZlcmVuY2VzPihwcmVmZXJlbmNlcyksIGtleSwgZGVmYXVsdFZhbHVlLCBjb252ZXJ0ZXIpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBhZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIHByZWZlcmVuY2Ugd2l0aAotCSAqIHRoZSBzcGVjaWZpZWQgZGVmYXVsdCB2YWx1ZSBmb3IgdGhlIHByZWZlcmVuY2UuCi0JICovCi0JcHVibGljIHN0YXRpYyBQcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGZvckJvb2xlYW4oUHJlZmVyZW5jZXMgcHJlZmVyZW5jZXMsIFN0cmluZyBrZXksIGJvb2xlYW4gZGVmYXVsdFZhbHVlKSB7Ci0JCXJldHVybiBuZXcgUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPigKLQkJCQlwcmVmZXJlbmNlcywKLQkJCQlrZXksCi0JCQkJZGVmYXVsdFZhbHVlID8gQm9vbGVhbi5UUlVFIDogQm9vbGVhbi5GQUxTRSwKLQkJCQlCaWRpU3RyaW5nQ29udmVydGVyLkJvb2xlYW5Db252ZXJ0ZXIuaW5zdGFuY2UoKQotCQkJKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gYWRhcHRlciBmb3IgdGhlIHNwZWNpZmllZCBwcmVmZXJlbmNlIHdpdGgKLQkgKiB0aGUgc3BlY2lmaWVkIGRlZmF1bHQgdmFsdWUgZm9yIHRoZSBwcmVmZXJlbmNlLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyPiBmb3JJbnRlZ2VyKFByZWZlcmVuY2VzIHByZWZlcmVuY2VzLCBTdHJpbmcga2V5LCBpbnQgZGVmYXVsdFZhbHVlKSB7Ci0JCXJldHVybiBuZXcgUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyPigKLQkJCQlwcmVmZXJlbmNlcywKLQkJCQlrZXksCi0JCQkJbmV3IEludGVnZXIoZGVmYXVsdFZhbHVlKSwKLQkJCQlCaWRpU3RyaW5nQ29udmVydGVyLkludGVnZXJDb252ZXJ0ZXIuaW5zdGFuY2UoKQotCQkJKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYW4gYWRhcHRlciBmb3IgdGhlIHNwZWNpZmllZCBwcmVmZXJlbmNlLgotCSAqIFRoZSBkZWZhdWx0IHZhbHVlIG9mIHRoZSBwcmVmZXJlbmNlIHdpbGwgYmUgbnVsbC4KLQkgKi8KLQlwdWJsaWMgUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbChQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFByZWZlcmVuY2VzPiBwcmVmZXJlbmNlc0hvbGRlciwgU3RyaW5nIGtleSkgewotCQl0aGlzKHByZWZlcmVuY2VzSG9sZGVyLCBrZXksIG51bGwpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBhZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIHByZWZlcmVuY2Ugd2l0aAotCSAqIHRoZSBzcGVjaWZpZWQgZGVmYXVsdCB2YWx1ZSBmb3IgdGhlIHByZWZlcmVuY2UuCi0JICovCi0JcHVibGljIFByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWwoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBQcmVmZXJlbmNlcz4gcHJlZmVyZW5jZXNIb2xkZXIsIFN0cmluZyBrZXksIFAgZGVmYXVsdFZhbHVlKSB7Ci0JCXRoaXMocHJlZmVyZW5jZXNIb2xkZXIsIGtleSwgZGVmYXVsdFZhbHVlLCBCaWRpU3RyaW5nQ29udmVydGVyLkRlZmF1bHQuPFA+aW5zdGFuY2UoKSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGFuIGFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgcHJlZmVyZW5jZSB3aXRoCi0JICogdGhlIHNwZWNpZmllZCBkZWZhdWx0IHZhbHVlIGZvciB0aGUgcHJlZmVyZW5jZS4KLQkgKi8KLQlwdWJsaWMgUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbChQcm9wZXJ0eVZhbHVlTW9kZWw8PyBleHRlbmRzIFByZWZlcmVuY2VzPiBwcmVmZXJlbmNlc0hvbGRlciwgU3RyaW5nIGtleSwgUCBkZWZhdWx0VmFsdWUsIEJpZGlTdHJpbmdDb252ZXJ0ZXI8UD4gY29udmVydGVyKSB7Ci0JCXN1cGVyKHByZWZlcmVuY2VzSG9sZGVyKTsKLQkJdGhpcy5rZXkgPSBrZXk7Ci0JCXRoaXMuZGVmYXVsdFZhbHVlID0gZGVmYXVsdFZhbHVlOwotCQl0aGlzLmNvbnZlcnRlciA9IGNvbnZlcnRlcjsKLQkJdGhpcy5wcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXIgPSB0aGlzLmJ1aWxkUHJlZmVyZW5jZUNoYW5nZUxpc3RlbmVyKCk7Ci0JCS8vIG91ciB2YWx1ZSBpcyBudWxsIHdoZW4gd2UgYXJlIG5vdCBsaXN0ZW5pbmcgdG8gdGhlIHByZWZlcmVuY2UKLQkJdGhpcy52YWx1ZSA9IG51bGw7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIEEgcHJlZmVyZW5jZSBoYXMgY2hhbmdlZCwgbm90aWZ5IHRoZSBsaXN0ZW5lcnMgaWYgbmVjZXNzYXJ5LgotCSAqLwotCXByb3RlY3RlZCBQcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXIgYnVpbGRQcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCS8vIHRyYW5zZm9ybSB0aGUgcHJlZmVyZW5jZSBjaGFuZ2UgZXZlbnRzIGludG8gVkFMVUUgcHJvcGVydHkgY2hhbmdlIGV2ZW50cwotCQlyZXR1cm4gbmV3IFByZWZlcmVuY2VDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByZWZlcmVuY2VDaGFuZ2UoUHJlZmVyZW5jZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbC50aGlzLnByZWZlcmVuY2VDaGFuZ2VkKGV2ZW50LmdldEtleSgpLCBldmVudC5nZXROZXdWYWx1ZSgpKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gInByZWZlcmVuY2UgY2hhbmdlIGxpc3RlbmVyIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogVmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNhY2hlZCAoY29udmVydGVkKSB2YWx1ZS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgc3luY2hyb25pemVkIFAgZ2V0VmFsdWUoKSB7Ci0JCXJldHVybiB0aGlzLnZhbHVlOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBQcm9wZXJ0eVZhbHVlTW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JLyoqCi0JICogU2V0IHRoZSBjYWNoZWQgdmFsdWUsIHRoZW4gc2V0IHRoZSBhcHByb3ByaWF0ZSBwcmVmZXJlbmNlIHZhbHVlLgotCSAqLwotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCBzZXRWYWx1ZShQIHZhbHVlKSB7Ci0JCWlmICh0aGlzLmhhc05vTGlzdGVuZXJzKCkpIHsKLQkJCXJldHVybjsJCS8vIG5vIGNoYW5nZXMgYWxsb3dlZCB3aGVuIHdlIGhhdmUgbm8gbGlzdGVuZXJzCi0JCX0KLQotCQlPYmplY3Qgb2xkID0gdGhpcy52YWx1ZTsKLQkJdGhpcy52YWx1ZSA9IHZhbHVlOwotCQl0aGlzLmZpcmVBc3BlY3RDaGFuZ2Uob2xkLCB2YWx1ZSk7Ci0KLQkJaWYgKCh0aGlzLnN1YmplY3QgIT0gbnVsbCkgJiYgdGhpcy5zaG91bGRTZXRQcmVmZXJlbmNlKG9sZCwgdmFsdWUpKSB7Ci0JCQl0aGlzLnNldFZhbHVlXyh2YWx1ZSk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogQXNwZWN0QWRhcHRlciBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgQ2xhc3M8PyBleHRlbmRzIENoYW5nZUxpc3RlbmVyPiBnZXRMaXN0ZW5lckNsYXNzKCkgewotCQlyZXR1cm4gUHJvcGVydHlDaGFuZ2VMaXN0ZW5lci5jbGFzczsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldExpc3RlbmVyQXNwZWN0TmFtZSgpIHsKLQkJcmV0dXJuIFZBTFVFOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBib29sZWFuIGhhc0xpc3RlbmVycygpIHsKLQkJcmV0dXJuIHRoaXMuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoVkFMVUUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGZpcmVBc3BlY3RDaGFuZ2UoT2JqZWN0IG9sZFZhbHVlLCBPYmplY3QgbmV3VmFsdWUpIHsKLQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKFZBTFVFLCBvbGRWYWx1ZSwgbmV3VmFsdWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGVuZ2FnZVN1YmplY3RfKCkgewotCQl0aGlzLnN1YmplY3QuYWRkUHJlZmVyZW5jZUNoYW5nZUxpc3RlbmVyKHRoaXMucHJlZmVyZW5jZUNoYW5nZUxpc3RlbmVyKTsKLQkJdGhpcy52YWx1ZSA9IHRoaXMuYnVpbGRWYWx1ZSgpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZVN1YmplY3RfKCkgewotCQl0cnkgewotCQkJdGhpcy5zdWJqZWN0LnJlbW92ZVByZWZlcmVuY2VDaGFuZ2VMaXN0ZW5lcih0aGlzLnByZWZlcmVuY2VDaGFuZ2VMaXN0ZW5lcik7Ci0JCX0gY2F0Y2ggKElsbGVnYWxTdGF0ZUV4Y2VwdGlvbiBleCkgewotCQkJLy8gZm9yIHNvbWUgb2RkIHJlYXNvbiwgd2UgYXJlIG5vdCBhbGxvd2VkIHRvIHJlbW92ZSBhIGxpc3RlbmVyIGZyb20gYSAiZGVhZCIKLQkJCS8vIHByZWZlcmVuY2VzIG5vZGU7IHNvIGhhbmRsZSB0aGUgZXhjZXB0aW9uIHRoYXQgZ2V0cyB0aHJvd24gaGVyZQotCQkJaWYgKCAhIGV4LmdldE1lc3NhZ2UoKS5lcXVhbHMoIk5vZGUgaGFzIGJlZW4gcmVtb3ZlZC4iKSkgewotCQkJCS8vIGlmIGl0IGlzIG5vdCB0aGUgZXhwZWN0ZWQgZXhjZXB0aW9uLCByZS10aHJvdyBpdAotCQkJCXRocm93IGV4OwotCQkJfQotCQl9Ci0JCXRoaXMudmFsdWUgPSBudWxsOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBBYnN0cmFjdE1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHRvU3RyaW5nKFN0cmluZ0J1aWxkZXIgc2IpIHsKLQkJc2IuYXBwZW5kKHRoaXMua2V5KTsKLQkJc2IuYXBwZW5kKCIgPT4gIik7Ci0JCXNiLmFwcGVuZCh0aGlzLnZhbHVlKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogcHVibGljIEFQSSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHByZWZlcmVuY2UncyBrZXkuCi0JICovCi0JcHVibGljIFN0cmluZyBnZXRLZXkoKSB7Ci0JCXJldHVybiB0aGlzLmtleTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW50ZXJuYWwgbWV0aG9kcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHByZWZlcmVuY2UncyB2YWx1ZS4KLQkgKiBBdCB0aGlzIHBvaW50IHRoZSBzdWJqZWN0IG1heSBiZSBudWxsLgotCSAqLwotCXByb3RlY3RlZCBQIGJ1aWxkVmFsdWUoKSB7Ci0JCXJldHVybiAodGhpcy5zdWJqZWN0ID09IG51bGwpID8gbnVsbCA6IHRoaXMuYnVpbGRWYWx1ZV8oKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFwcHJvcHJpYXRlIHByZWZlcmVuY2UsIGNvbnZlcnRlZCB0byB0aGUgYXBwcm9wcmlhdGUgb2JqZWN0LgotCSAqIEF0IHRoaXMgcG9pbnQgd2UgY2FuIGJlIHN1cmUgdGhhdCB0aGUgc3ViamVjdCBpcyBub3QgbnVsbC4KLQkgKi8KLQlwcm90ZWN0ZWQgUCBidWlsZFZhbHVlXygpIHsKLQkJcmV0dXJuIHRoaXMuY29udmVydFRvT2JqZWN0KHRoaXMuc3ViamVjdC5nZXQodGhpcy5rZXksIHRoaXMuY29udmVydFRvU3RyaW5nKHRoaXMuZGVmYXVsdFZhbHVlKSkpOwotCX0KLQotCS8qKgotCSAqIFNldCB0aGUgYXBwcm9wcmlhdGUgcHJlZmVyZW5jZSBhZnRlciBjb252ZXJ0aW5nIHRoZSB2YWx1ZSB0byBhIHN0cmluZy4KLQkgKiBBdCB0aGlzIHBvaW50IHdlIGNhbiBiZSBzdXJlIHRoYXQgdGhlIHN1YmplY3QgaXMgbm90IG51bGwuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFAgdmFsdWUpIHsKLQkJdGhpcy5zdWJqZWN0LnB1dCh0aGlzLmtleSwgdGhpcy5jb252ZXJ0VG9TdHJpbmcodmFsdWUpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIG5ldyB2YWx1ZSBzaG91bGQgYmUgcGFzc2VkCi0JICogdGhyb3VnaCB0byB0aGUgcHJlZmVyZW5jZS4gQnkgZGVmYXVsdCwgb25seSBpZiB0aGUgdmFsdWUgaGFzIGNoYW5nZWQsCi0JICogd2lsbCBpdCBiZSBwYXNzZWQgdGhyb3VnaCB0byB0aGUgcHJlZmVyZW5jZS4gVGhpcyBhbHNvIGhhcyB0aGUKLQkgKiBlZmZlY3Qgb2Ygbm90IGNyZWF0aW5nIG5ldyBwcmVmZXJlbmNlcyBpbiB0aGUgImJhY2tpbmcgc3RvcmUiCi0JICogaWYgdGhlIG5ldyB2YWx1ZSBpcyB0aGUgc2FtZSBhcyB0aGUgZGVmYXVsdCB2YWx1ZS4KLQkgKiAKLQkgKiBTdWJjbGFzc2VzIGNhbiBvdmVycmlkZSB0aGlzIG1ldGhvZCB0byByZXR1cm4gdHJ1ZSBpZiB0aGV5Ci0JICogd291bGQgbGlrZSB0byBBTFdBWVMgcGFzcyB0aHJvdWdoIHRoZSBuZXcgdmFsdWUgdG8gdGhlIHByZWZlcmVuY2UuCi0JICovCi0JcHJvdGVjdGVkIGJvb2xlYW4gc2hvdWxkU2V0UHJlZmVyZW5jZShPYmplY3Qgb2xkVmFsdWUsIE9iamVjdCBuZXdWYWx1ZSkgewotCQlyZXR1cm4gdGhpcy5hdHRyaWJ1dGVWYWx1ZUhhc0NoYW5nZWQob2xkVmFsdWUsIG5ld1ZhbHVlKTsKLQl9Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgb2JqZWN0IHRvIGEgc3RyaW5nIHRoYXQgY2FuIGJlIHN0b3JlZCBhcwotCSAqIHRoZSB2YWx1ZSBvZiB0aGUgcHJlZmVyZW5jZS4KLQkgKi8KLQlwcm90ZWN0ZWQgU3RyaW5nIGNvbnZlcnRUb1N0cmluZyhQIG8pIHsKLQkJcmV0dXJuIHRoaXMuY29udmVydGVyLmNvbnZlcnRUb1N0cmluZyhvKTsKLQl9Ci0KLQkvKioKLQkgKiBDb252ZXJ0IHRoZSBzcGVjaWZpZWQgcHJlZmVyZW5jZSB2YWx1ZSBzdHJpbmcgdG8gYW4KLQkgKiBhcHByb3ByaWF0ZWx5LXR5cGVkIG9iamVjdCB0byBiZSByZXR1cm5lZCB0byB0aGUgY2xpZW50LgotCSAqLwotCXByb3RlY3RlZCBQIGNvbnZlcnRUb09iamVjdChTdHJpbmcgcykgewotCQlyZXR1cm4gdGhpcy5jb252ZXJ0ZXIuY29udmVydFRvT2JqZWN0KHMpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIHByZWZlcmVuY2VDaGFuZ2VkKFN0cmluZyBwcmVmS2V5LCBTdHJpbmcgbmV3VmFsdWUpIHsKLQkJaWYgKHByZWZLZXkuZXF1YWxzKHRoaXMua2V5KSkgewotCQkJdGhpcy5wcmVmZXJlbmNlQ2hhbmdlZCgpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogVGhlIHVuZGVybHlpbmcgcHJlZmVyZW5jZSBjaGFuZ2VkOyBlaXRoZXIgYmVjYXVzZSB3ZSBjaGFuZ2VkIGl0Ci0JICogaW4gI3NldFZhbHVlXyhPYmplY3QpIG9yIGEgdGhpcmQtcGFydHkgY2hhbmdlZCBpdC4KLQkgKiBJZiB0aGlzIGlzIGNhbGxlZCBiZWNhdXNlIG9mIG91ciBvd24gY2hhbmdlLCB0aGUgZXZlbnQgd2lsbCBiZQotCSAqIHN3YWxsb3dlZCBiZWNhdXNlIHRoZSBvbGQgYW5kIG5ldyB2YWx1ZXMgYXJlIHRoZSBzYW1lLgotCSAqLwotCXByb3RlY3RlZCBzeW5jaHJvbml6ZWQgdm9pZCBwcmVmZXJlbmNlQ2hhbmdlZCgpIHsKLQkJT2JqZWN0IG9sZCA9IHRoaXMudmFsdWU7Ci0JCXRoaXMudmFsdWUgPSB0aGlzLmJ1aWxkVmFsdWUoKTsKLQkJdGhpcy5maXJlQXNwZWN0Q2hhbmdlKG9sZCwgdGhpcy52YWx1ZSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvcHJlZnMvUHJlZmVyZW5jZXNDb2xsZWN0aW9uVmFsdWVNb2RlbC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3ByZWZzL1ByZWZlcmVuY2VzQ29sbGVjdGlvblZhbHVlTW9kZWwuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNTQ2YTY2OC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvcHJlZnMvUHJlZmVyZW5jZXNDb2xsZWN0aW9uVmFsdWVNb2RlbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjAwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUucHJlZnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuSGFzaE1hcDsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLnByZWZzLkJhY2tpbmdTdG9yZUV4Y2VwdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwucHJlZnMuUHJlZmVyZW5jZUNoYW5nZUV2ZW50OwotaW1wb3J0IGphdmEudXRpbC5wcmVmcy5QcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgamF2YS51dGlsLnByZWZzLlByZWZlcmVuY2VzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5BcnJheUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5UcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU3RhdGljUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci0KLS8qKgotICogVGhpcyBhZGFwdGVyIHdyYXBzIGEgUHJlZmVyZW5jZXMgbm9kZSBhbmQgY29udmVydHMgaXRzIHByZWZlcmVuY2VzIGludG8gYQotICogQ29sbGVjdGlvblZhbHVlTW9kZWwgb2YgUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbHMuIEl0IGxpc3RlbnMgZm9yCi0gKiAicHJlZmVyZW5jZSIgY2hhbmdlcyBhbmQgY29udmVydHMgdGhlbSBpbnRvIFZBTFVFIGNvbGxlY3Rpb24gY2hhbmdlcy4KLSAqLwotcHVibGljIGNsYXNzIFByZWZlcmVuY2VzQ29sbGVjdGlvblZhbHVlTW9kZWw8UD4KLQlleHRlbmRzIEFzcGVjdEFkYXB0ZXI8UHJlZmVyZW5jZXM+Ci0JaW1wbGVtZW50cyBDb2xsZWN0aW9uVmFsdWVNb2RlbDxQcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsPFA+PgotewotCi0JLyoqIENhY2hlIHRoZSBjdXJyZW50IHByZWZlcmVuY2VzLCBzdG9yZWQgaW4gbW9kZWxzIGFuZCBrZXllZCBieSBuYW1lLiAqLwotCXByb3RlY3RlZCBmaW5hbCBIYXNoTWFwPFN0cmluZywgUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbDxQPj4gcHJlZmVyZW5jZXM7Ci0KLQkvKiogQSBsaXN0ZW5lciB0aGF0IGxpc3RlbnMgdG8gdGhlIHByZWZlcmVuY2VzIG5vZGUgZm9yIGFkZGVkIG9yIHJlbW92ZWQgcHJlZmVyZW5jZXMuICovCi0JcHJvdGVjdGVkIGZpbmFsIFByZWZlcmVuY2VDaGFuZ2VMaXN0ZW5lciBwcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXI7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBhZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIHByZWZlcmVuY2VzIG5vZGUuCi0JICovCi0JcHVibGljIFByZWZlcmVuY2VzQ29sbGVjdGlvblZhbHVlTW9kZWwoUHJlZmVyZW5jZXMgcHJlZmVyZW5jZXMpIHsKLQkJdGhpcyhuZXcgU3RhdGljUHJvcGVydHlWYWx1ZU1vZGVsPFByZWZlcmVuY2VzPihwcmVmZXJlbmNlcykpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhbiBhZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIHByZWZlcmVuY2VzIG5vZGUuCi0JICovCi0JcHVibGljIFByZWZlcmVuY2VzQ29sbGVjdGlvblZhbHVlTW9kZWwoUHJvcGVydHlWYWx1ZU1vZGVsPD8gZXh0ZW5kcyBQcmVmZXJlbmNlcz4gcHJlZmVyZW5jZXNIb2xkZXIpIHsKLQkJc3VwZXIocHJlZmVyZW5jZXNIb2xkZXIpOwotCQl0aGlzLnByZWZlcmVuY2VzID0gbmV3IEhhc2hNYXA8U3RyaW5nLCBQcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsPFA+PigpOwotCQl0aGlzLnByZWZlcmVuY2VDaGFuZ2VMaXN0ZW5lciA9IHRoaXMuYnVpbGRQcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXIoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JLyoqCi0JICogQSBwcmVmZXJlbmNlcyBoYXZlIGNoYW5nZWQsIG5vdGlmeSB0aGUgbGlzdGVuZXJzLgotCSAqLwotCXByb3RlY3RlZCBQcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXIgYnVpbGRQcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCS8vIHRyYW5zZm9ybSB0aGUgcHJlZmVyZW5jZSBjaGFuZ2UgZXZlbnRzIGludG8gVkFMVUUgY29sbGVjdGlvbiBjaGFuZ2UgZXZlbnRzCi0JCXJldHVybiBuZXcgUHJlZmVyZW5jZUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgcHJlZmVyZW5jZUNoYW5nZShQcmVmZXJlbmNlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlQcmVmZXJlbmNlc0NvbGxlY3Rpb25WYWx1ZU1vZGVsLnRoaXMucHJlZmVyZW5jZUNoYW5nZWQoZXZlbnQuZ2V0S2V5KCksIGV2ZW50LmdldE5ld1ZhbHVlKCkpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAicHJlZmVyZW5jZSBjaGFuZ2UgbGlzdGVuZXIiOwotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBDb2xsZWN0aW9uVmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gYW4gaXRlcmF0b3Igb24gdGhlIHByZWZlcmVuY2UgbW9kZWxzLgotCSAqLwotCXB1YmxpYyBzeW5jaHJvbml6ZWQgSXRlcmF0b3I8UHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbDxQPj4gaXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLnByZWZlcmVuY2VzLnZhbHVlcygpLml0ZXJhdG9yKCk7Ci0JfQotCi0JcHVibGljIHN5bmNocm9uaXplZCBpbnQgc2l6ZSgpIHsKLQkJcmV0dXJuIHRoaXMucHJlZmVyZW5jZXMuc2l6ZSgpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBBc3BlY3RBZGFwdGVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBPYmplY3QgZ2V0VmFsdWUoKSB7Ci0JCXJldHVybiB0aGlzLml0ZXJhdG9yKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIENsYXNzPD8gZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gZ2V0TGlzdGVuZXJDbGFzcygpIHsKLQkJcmV0dXJuIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lci5jbGFzczsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldExpc3RlbmVyQXNwZWN0TmFtZSgpIHsKLQkJcmV0dXJuIFZBTFVFUzsKLQl9Ci0KLSAgICBAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgYm9vbGVhbiBoYXNMaXN0ZW5lcnMoKSB7Ci0JCXJldHVybiB0aGlzLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoVkFMVUVTKTsKLQl9Ci0KLSAgICBAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBmaXJlQXNwZWN0Q2hhbmdlKE9iamVjdCBvbGRWYWx1ZSwgT2JqZWN0IG5ld1ZhbHVlKSB7Ci0JCXRoaXMuZmlyZUNvbGxlY3Rpb25DaGFuZ2VkKFZBTFVFUyk7Ci0JfQotCi0gICAgQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlU3ViamVjdF8oKSB7Ci0JCXRoaXMuc3ViamVjdC5hZGRQcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXIodGhpcy5wcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXIpOwotCQlmb3IgKEl0ZXJhdG9yPFByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWw8UD4+IHN0cmVhbSA9IHRoaXMucHJlZmVyZW5jZU1vZGVscygpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCVByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWw8UD4gcHJlZmVyZW5jZU1vZGVsID0gc3RyZWFtLm5leHQoKTsKLQkJCXRoaXMucHJlZmVyZW5jZXMucHV0KHByZWZlcmVuY2VNb2RlbC5nZXRLZXkoKSwgcHJlZmVyZW5jZU1vZGVsKTsKLQkJfQotCX0KLQotICAgIEBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZVN1YmplY3RfKCkgewotCQl0cnkgewotCQkJdGhpcy5zdWJqZWN0LnJlbW92ZVByZWZlcmVuY2VDaGFuZ2VMaXN0ZW5lcih0aGlzLnByZWZlcmVuY2VDaGFuZ2VMaXN0ZW5lcik7Ci0JCX0gY2F0Y2ggKElsbGVnYWxTdGF0ZUV4Y2VwdGlvbiBleCkgewotCQkJLy8gZm9yIHNvbWUgb2RkIHJlYXNvbiwgd2UgYXJlIG5vdCBhbGxvd2VkIHRvIHJlbW92ZSBhIGxpc3RlbmVyIGZyb20gYSAiZGVhZCIKLQkJCS8vIHByZWZlcmVuY2VzIG5vZGU7IHNvIGhhbmRsZSB0aGUgZXhjZXB0aW9uIHRoYXQgZ2V0cyB0aHJvd24gaGVyZQotCQkJaWYgKCAhIGV4LmdldE1lc3NhZ2UoKS5lcXVhbHMoIk5vZGUgaGFzIGJlZW4gcmVtb3ZlZC4iKSkgewotCQkJCS8vIGlmIGl0IGlzIG5vdCB0aGUgZXhwZWN0ZWQgZXhjZXB0aW9uLCByZS10aHJvdyBpdAotCQkJCXRocm93IGV4OwotCQkJfQotCQl9Ci0JCXRoaXMucHJlZmVyZW5jZXMuY2xlYXIoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogQWJzdHJhY3RNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0b1N0cmluZyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXNiLmFwcGVuZCh0aGlzLnN1YmplY3QpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbnRlcm5hbCBtZXRob2RzICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiBhbiBpdGVyYXRvciBvbiB0aGUgcHJlZmVyZW5jZSBtb2RlbHMuCi0JICogQXQgdGhpcyBwb2ludCB3ZSBjYW4gYmUgc3VyZSB0aGF0IHRoZSBzdWJqZWN0IGlzIG5vdCBudWxsLgotCSAqLwotCXByb3RlY3RlZCBJdGVyYXRvcjxQcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsPFA+PiBwcmVmZXJlbmNlTW9kZWxzKCkgewotCQlTdHJpbmdbXSBrZXlzOwotCQl0cnkgewotCQkJa2V5cyA9IHRoaXMuc3ViamVjdC5rZXlzKCk7Ci0JCX0gY2F0Y2ggKEJhY2tpbmdTdG9yZUV4Y2VwdGlvbiBleCkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oZXgpOwotCQl9Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25JdGVyYXRvcjxTdHJpbmcsIFByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWw8UD4+KG5ldyBBcnJheUl0ZXJhdG9yPFN0cmluZz4oa2V5cykpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWw8UD4gdHJhbnNmb3JtKFN0cmluZyBrZXkpIHsKLQkJCQlyZXR1cm4gUHJlZmVyZW5jZXNDb2xsZWN0aW9uVmFsdWVNb2RlbC50aGlzLmJ1aWxkUHJlZmVyZW5jZU1vZGVsKGtleSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JLyoqCi0JICogT3ZlcnJpZGUgdGhpcyBtZXRob2QgdG8gdHdlYWsgdGhlIG1vZGVsIHVzZWQgdG8gd3JhcCB0aGUKLQkgKiBzcGVjaWZpZWQgcHJlZmVyZW5jZSAoZS5nLiB0byBjdXN0b21pemUgdGhlIG1vZGVsJ3MgY29udmVydGVyKS4KLQkgKi8KLQlwcm90ZWN0ZWQgUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbDxQPiBidWlsZFByZWZlcmVuY2VNb2RlbChTdHJpbmcga2V5KSB7Ci0JCXJldHVybiBuZXcgUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbDxQPih0aGlzLnN1YmplY3RIb2xkZXIsIGtleSk7Ci0JfQotCi0JcHJvdGVjdGVkIHN5bmNocm9uaXplZCB2b2lkIHByZWZlcmVuY2VDaGFuZ2VkKFN0cmluZyBrZXksIFN0cmluZyBuZXdWYWx1ZSkgewotCQlpZiAobmV3VmFsdWUgPT0gbnVsbCkgewotCQkJLy8gYSBwcmVmZXJlbmNlIHdhcyByZW1vdmVkCi0JCQlQcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsPFA+IHByZWZlcmVuY2VNb2RlbCA9IHRoaXMucHJlZmVyZW5jZXMucmVtb3ZlKGtleSk7Ci0JCQl0aGlzLmZpcmVJdGVtUmVtb3ZlZChWQUxVRVMsIHByZWZlcmVuY2VNb2RlbCk7Ci0JCX0gZWxzZSBpZiAoICEgdGhpcy5wcmVmZXJlbmNlcy5jb250YWluc0tleShrZXkpKSB7Ci0JCQkvLyBhIHByZWZlcmVuY2Ugd2FzIGFkZGVkCi0JCQlQcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsPFA+IHByZWZlcmVuY2VNb2RlbCA9IHRoaXMuYnVpbGRQcmVmZXJlbmNlTW9kZWwoa2V5KTsKLQkJCXRoaXMucHJlZmVyZW5jZXMucHV0KGtleSwgcHJlZmVyZW5jZU1vZGVsKTsKLQkJCXRoaXMuZmlyZUl0ZW1BZGRlZChWQUxVRVMsIHByZWZlcmVuY2VNb2RlbCk7Ci0JCX0gZWxzZSB7Ci0JCQkvLyBhIHByZWZlcmVuY2UncyB2YWx1ZSBjaGFuZ2VkIC0gZG8gbm90aGluZwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvQWJzdHJhY3RUcmVlTW9kZWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9BYnN0cmFjdFRyZWVNb2RlbC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzMDJhODNmLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9BYnN0cmFjdFRyZWVNb2RlbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjE2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmc7Ci0KLWltcG9ydCBqYXZhLmlvLlNlcmlhbGl6YWJsZTsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5FdmVudExpc3RlbmVyTGlzdDsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5UcmVlTW9kZWxFdmVudDsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5UcmVlTW9kZWxMaXN0ZW5lcjsKLWltcG9ydCBqYXZheC5zd2luZy50cmVlLlRyZWVNb2RlbDsKLQotLyoqCi0gKiBBYnN0cmFjdCBjbGFzcyB0aGF0IHNob3VsZCBoYXZlIGJlZW4gcHJvdmlkZWQgYnkgdGhlIEpESwotICogKOAgbGEgamF2YXguc3dpbmcuQWJzdHJhY3RMaXN0TW9kZWwpLiBUaGlzIGNsYXNzIHByb3ZpZGVzOgotICogLSBzdXBwb3J0IGZvciBhIGNvbGxlY3Rpb24gb2YgbGlzdGVuZXJzCi0gKiAtIGEgbnVtYmVyIG9mIGNvbnZlbmllbmNlIG1ldGhvZHMgZm9yIGZpcmluZyBldmVudHMgZm9yIHRob3NlIGxpc3RlbmVycwotICovCi1wdWJsaWMgYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3RUcmVlTW9kZWwKLQlpbXBsZW1lbnRzIFRyZWVNb2RlbCwgU2VyaWFsaXphYmxlCi17Ci0JLyoqIE91ciBsaXN0ZW5lcnMuICovCi0JcHJvdGVjdGVkIGZpbmFsIEV2ZW50TGlzdGVuZXJMaXN0IGxpc3RlbmVyTGlzdDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMvaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JcHJvdGVjdGVkIEFic3RyYWN0VHJlZU1vZGVsKCkgewotCQlzdXBlcigpOwotCQl0aGlzLmxpc3RlbmVyTGlzdCA9IG5ldyBFdmVudExpc3RlbmVyTGlzdCgpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBwYXJ0aWFsIFRyZWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgdm9pZCBhZGRUcmVlTW9kZWxMaXN0ZW5lcihUcmVlTW9kZWxMaXN0ZW5lciBsKSB7Ci0JCXRoaXMubGlzdGVuZXJMaXN0LmFkZChUcmVlTW9kZWxMaXN0ZW5lci5jbGFzcywgbCk7Ci0JfQotCi0JcHVibGljIHZvaWQgcmVtb3ZlVHJlZU1vZGVsTGlzdGVuZXIoVHJlZU1vZGVsTGlzdGVuZXIgbCkgewotCQl0aGlzLmxpc3RlbmVyTGlzdC5yZW1vdmUoVHJlZU1vZGVsTGlzdGVuZXIuY2xhc3MsIGwpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBxdWVyaWVzICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB0aGUgbW9kZWwncyBjdXJyZW50IGNvbGxlY3Rpb24gb2YgbGlzdGVuZXJzLgotCSAqIChUaGVyZSBzZWVtcyB0byBiZSBhIHBhdHRlcm4gb2YgbWFraW5nIHRoaXMgdHlwZSBvZiBtZXRob2QgcHVibGljOwotCSAqIGFsdGhvdWdoIGl0IHNob3VsZCBwcm9iYWJseSBiZSBwcm90ZWN0ZWQuLi4uKQotCSAqLwotCXB1YmxpYyBUcmVlTW9kZWxMaXN0ZW5lcltdIHRyZWVNb2RlbExpc3RlbmVycygpIHsKLSAJCXJldHVybiB0aGlzLmxpc3RlbmVyTGlzdC5nZXRMaXN0ZW5lcnMoVHJlZU1vZGVsTGlzdGVuZXIuY2xhc3MpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoaXMgbW9kZWwgaGFzIG5vIGxpc3RlbmVycy4KLQkgKi8KLQlwcm90ZWN0ZWQgYm9vbGVhbiBoYXNOb1RyZWVNb2RlbExpc3RlbmVycygpIHsKLQkJcmV0dXJuIHRoaXMubGlzdGVuZXJMaXN0LmdldExpc3RlbmVyQ291bnQoVHJlZU1vZGVsTGlzdGVuZXIuY2xhc3MpID09IDA7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhpcyBtb2RlbCBoYXMgYW55IGxpc3RlbmVycy4KLQkgKi8KLQlwcm90ZWN0ZWQgYm9vbGVhbiBoYXNUcmVlTW9kZWxMaXN0ZW5lcnMoKSB7Ci0JCXJldHVybiAhIHRoaXMuaGFzTm9UcmVlTW9kZWxMaXN0ZW5lcnMoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCi0JLyoqCi0JICogTm90aWZ5IGxpc3RlbmVycyBvZiBhIG1vZGVsIGNoYW5nZS4KLQkgKiBBIHNpZ25pZmljYW50IHByb3BlcnR5IG9mIHRoZSBub2RlcyBjaGFuZ2VkLCBidXQgdGhlIG5vZGVzIHRoZW1zZWx2ZXMKLQkgKiBhcmUgc3RpbGwgdGhlIHNhbWUgb2JqZWN0cy4KLQkgKiBAc2VlIGphdmF4LnN3aW5nLmV2ZW50LlRyZWVNb2RlbEV2ZW50Ci0JICogQHNlZSBqYXZheC5zd2luZy5ldmVudC5UcmVlTW9kZWxMaXN0ZW5lcgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGZpcmVUcmVlTm9kZXNDaGFuZ2VkKE9iamVjdFtdIHBhdGgsIGludFtdIGNoaWxkSW5kaWNlcywgT2JqZWN0W10gY2hpbGRyZW4pIHsKLQkJLy8gZ3VhcmFudGVlZCB0byByZXR1cm4gYSBub24tbnVsbCBhcnJheQotCQlPYmplY3RbXSBsaXN0ZW5lcnMgPSB0aGlzLmxpc3RlbmVyTGlzdC5nZXRMaXN0ZW5lckxpc3QoKTsKLQkJVHJlZU1vZGVsRXZlbnQgZXZlbnQgPSBudWxsOwotCQkvLyBwcm9jZXNzIHRoZSBsaXN0ZW5lcnMgbGFzdCB0byBmaXJzdCwgbm90aWZ5aW5nCi0JCS8vIHRob3NlIHRoYXQgYXJlIGludGVyZXN0ZWQgaW4gdGhpcyBldmVudAotCQlmb3IgKGludCBpID0gbGlzdGVuZXJzLmxlbmd0aC0yOyBpPj0wOyBpLT0yKSB7Ci0JCQlpZiAobGlzdGVuZXJzW2ldPT1UcmVlTW9kZWxMaXN0ZW5lci5jbGFzcykgewotCQkJCS8vIGxhemlseSBjcmVhdGUgdGhlIGV2ZW50Ci0JCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQkJZXZlbnQgPSBuZXcgVHJlZU1vZGVsRXZlbnQodGhpcywgcGF0aCwgY2hpbGRJbmRpY2VzLCBjaGlsZHJlbik7Ci0JCQkJfQotCQkJCSgoVHJlZU1vZGVsTGlzdGVuZXIpIGxpc3RlbmVyc1tpKzFdKS50cmVlTm9kZXNDaGFuZ2VkKGV2ZW50KTsKLQkJCX0KLQkJfQotCX0KLQotCi0JLyoqCi0JICogTm90aWZ5IGxpc3RlbmVycyBvZiBhIG1vZGVsIGNoYW5nZS4KLQkgKiBBIHNpZ25pZmljYW50IHByb3BlcnR5IG9mIHRoZSBub2RlIGNoYW5nZWQsIGJ1dCB0aGUgbm9kZSBpdHNlbGYgaXMgdGhlIHNhbWUgb2JqZWN0LgotCSAqIEBzZWUgamF2YXguc3dpbmcuZXZlbnQuVHJlZU1vZGVsRXZlbnQKLQkgKiBAc2VlIGphdmF4LnN3aW5nLmV2ZW50LlRyZWVNb2RlbExpc3RlbmVyCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgZmlyZVRyZWVOb2RlQ2hhbmdlZChPYmplY3RbXSBwYXRoLCBpbnQgY2hpbGRJbmRleCwgT2JqZWN0IGNoaWxkKSB7Ci0JCXRoaXMuZmlyZVRyZWVOb2Rlc0NoYW5nZWQocGF0aCwgbmV3IGludFtdIHtjaGlsZEluZGV4fSwgbmV3IE9iamVjdFtdIHtjaGlsZH0pOwotCX0KLQotCS8qKgotCSAqIE5vdGlmeSBsaXN0ZW5lcnMgb2YgYSBtb2RlbCBjaGFuZ2UuCi0JICogQSBzaWduaWZpY2FudCBwcm9wZXJ0eSBvZiB0aGUgcm9vdCBjaGFuZ2VkLCBidXQgdGhlIHJvb3QgaXRzZWxmIGlzIHRoZSBzYW1lIG9iamVjdC4KLQkgKiBAc2VlIGphdmF4LnN3aW5nLmV2ZW50LlRyZWVNb2RlbEV2ZW50Ci0JICogQHNlZSBqYXZheC5zd2luZy5ldmVudC5UcmVlTW9kZWxMaXN0ZW5lcgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGZpcmVUcmVlUm9vdENoYW5nZWQoT2JqZWN0IHJvb3QpIHsKLQkJdGhpcy5maXJlVHJlZU5vZGVzQ2hhbmdlZChuZXcgT2JqZWN0W10ge3Jvb3R9LCBudWxsLCBudWxsKTsKLQl9Ci0KLQkvKioKLQkgKiBOb3RpZnkgbGlzdGVuZXJzIG9mIGEgbW9kZWwgY2hhbmdlLgotCSAqIEBzZWUgamF2YXguc3dpbmcuZXZlbnQuVHJlZU1vZGVsRXZlbnQKLQkgKiBAc2VlIGphdmF4LnN3aW5nLmV2ZW50LlRyZWVNb2RlbExpc3RlbmVyCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgZmlyZVRyZWVOb2Rlc0luc2VydGVkKE9iamVjdFtdIHBhdGgsIGludFtdIGNoaWxkSW5kaWNlcywgT2JqZWN0W10gY2hpbGRyZW4pIHsKLQkJLy8gZ3VhcmFudGVlZCB0byByZXR1cm4gYSBub24tbnVsbCBhcnJheQotCQlPYmplY3RbXSBsaXN0ZW5lcnMgPSB0aGlzLmxpc3RlbmVyTGlzdC5nZXRMaXN0ZW5lckxpc3QoKTsKLQkJVHJlZU1vZGVsRXZlbnQgZXZlbnQgPSBudWxsOwotCQkvLyBwcm9jZXNzIHRoZSBsaXN0ZW5lcnMgbGFzdCB0byBmaXJzdCwgbm90aWZ5aW5nCi0JCS8vIHRob3NlIHRoYXQgYXJlIGludGVyZXN0ZWQgaW4gdGhpcyBldmVudAotCQlmb3IgKGludCBpID0gbGlzdGVuZXJzLmxlbmd0aC0yOyBpPj0wOyBpLT0yKSB7Ci0JCQlpZiAobGlzdGVuZXJzW2ldPT1UcmVlTW9kZWxMaXN0ZW5lci5jbGFzcykgewotCQkJCS8vIGxhemlseSBjcmVhdGUgdGhlIGV2ZW50Ci0JCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQkJZXZlbnQgPSBuZXcgVHJlZU1vZGVsRXZlbnQodGhpcywgcGF0aCwgY2hpbGRJbmRpY2VzLCBjaGlsZHJlbik7Ci0JCQkJfQotCQkJCSgoVHJlZU1vZGVsTGlzdGVuZXIpIGxpc3RlbmVyc1tpKzFdKS50cmVlTm9kZXNJbnNlcnRlZChldmVudCk7Ci0JCQl9Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBOb3RpZnkgbGlzdGVuZXJzIG9mIGEgbW9kZWwgY2hhbmdlLgotCSAqIEBzZWUgamF2YXguc3dpbmcuZXZlbnQuVHJlZU1vZGVsRXZlbnQKLQkgKiBAc2VlIGphdmF4LnN3aW5nLmV2ZW50LlRyZWVNb2RlbExpc3RlbmVyCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgZmlyZVRyZWVOb2RlSW5zZXJ0ZWQoT2JqZWN0W10gcGF0aCwgaW50IGNoaWxkSW5kZXgsIE9iamVjdCBjaGlsZCkgewotCQl0aGlzLmZpcmVUcmVlTm9kZXNJbnNlcnRlZChwYXRoLCBuZXcgaW50W10ge2NoaWxkSW5kZXh9LCBuZXcgT2JqZWN0W10ge2NoaWxkfSk7Ci0JfQotCi0JLyoqCi0JICogTm90aWZ5IGxpc3RlbmVycyBvZiBhIG1vZGVsIGNoYW5nZS4KLQkgKiBAc2VlIGphdmF4LnN3aW5nLmV2ZW50LlRyZWVNb2RlbEV2ZW50Ci0JICogQHNlZSBqYXZheC5zd2luZy5ldmVudC5UcmVlTW9kZWxMaXN0ZW5lcgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGZpcmVUcmVlTm9kZXNSZW1vdmVkKE9iamVjdFtdIHBhdGgsIGludFtdIGNoaWxkSW5kaWNlcywgT2JqZWN0W10gY2hpbGRyZW4pIHsKLQkJLy8gZ3VhcmFudGVlZCB0byByZXR1cm4gYSBub24tbnVsbCBhcnJheQotCQlPYmplY3RbXSBsaXN0ZW5lcnMgPSB0aGlzLmxpc3RlbmVyTGlzdC5nZXRMaXN0ZW5lckxpc3QoKTsKLQkJVHJlZU1vZGVsRXZlbnQgZXZlbnQgPSBudWxsOwotCQkvLyBwcm9jZXNzIHRoZSBsaXN0ZW5lcnMgbGFzdCB0byBmaXJzdCwgbm90aWZ5aW5nCi0JCS8vIHRob3NlIHRoYXQgYXJlIGludGVyZXN0ZWQgaW4gdGhpcyBldmVudAotCQlmb3IgKGludCBpID0gbGlzdGVuZXJzLmxlbmd0aC0yOyBpPj0wOyBpLT0yKSB7Ci0JCQlpZiAobGlzdGVuZXJzW2ldPT1UcmVlTW9kZWxMaXN0ZW5lci5jbGFzcykgewotCQkJCS8vIGxhemlseSBjcmVhdGUgdGhlIGV2ZW50Ci0JCQkJaWYgKGV2ZW50ID09IG51bGwpIHsKLQkJCQkJZXZlbnQgPSBuZXcgVHJlZU1vZGVsRXZlbnQodGhpcywgcGF0aCwgY2hpbGRJbmRpY2VzLCBjaGlsZHJlbik7Ci0JCQkJfQotCQkJCSgoVHJlZU1vZGVsTGlzdGVuZXIpIGxpc3RlbmVyc1tpKzFdKS50cmVlTm9kZXNSZW1vdmVkKGV2ZW50KTsKLQkJCX0KLQkJfQotCX0KLQotCS8qKgotCSAqIE5vdGlmeSBsaXN0ZW5lcnMgb2YgYSBtb2RlbCBjaGFuZ2UuCi0JICogQHNlZSBqYXZheC5zd2luZy5ldmVudC5UcmVlTW9kZWxFdmVudAotCSAqIEBzZWUgamF2YXguc3dpbmcuZXZlbnQuVHJlZU1vZGVsTGlzdGVuZXIKLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBmaXJlVHJlZU5vZGVSZW1vdmVkKE9iamVjdFtdIHBhdGgsIGludCBjaGlsZEluZGV4LCBPYmplY3QgY2hpbGQpIHsKLQkJdGhpcy5maXJlVHJlZU5vZGVzUmVtb3ZlZChwYXRoLCBuZXcgaW50W10ge2NoaWxkSW5kZXh9LCBuZXcgT2JqZWN0W10ge2NoaWxkfSk7Ci0JfQotCi0JLyoqCi0JICogTm90aWZ5IGxpc3RlbmVycyBvZiBhIG1vZGVsIGNoYW5nZS4KLQkgKiBAc2VlIGphdmF4LnN3aW5nLmV2ZW50LlRyZWVNb2RlbEV2ZW50Ci0JICogQHNlZSBqYXZheC5zd2luZy5ldmVudC5UcmVlTW9kZWxMaXN0ZW5lcgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGZpcmVUcmVlU3RydWN0dXJlQ2hhbmdlZChPYmplY3RbXSBwYXRoKSB7Ci0JCS8vIGd1YXJhbnRlZWQgdG8gcmV0dXJuIGEgbm9uLW51bGwgYXJyYXkKLQkJT2JqZWN0W10gbGlzdGVuZXJzID0gdGhpcy5saXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJMaXN0KCk7Ci0JCVRyZWVNb2RlbEV2ZW50IGV2ZW50ID0gbnVsbDsKLQkJLy8gcHJvY2VzcyB0aGUgbGlzdGVuZXJzIGxhc3QgdG8gZmlyc3QsIG5vdGlmeWluZwotCQkvLyB0aG9zZSB0aGF0IGFyZSBpbnRlcmVzdGVkIGluIHRoaXMgZXZlbnQKLQkJZm9yIChpbnQgaSA9IGxpc3RlbmVycy5sZW5ndGgtMjsgaT49MDsgaS09MikgewotCQkJaWYgKGxpc3RlbmVyc1tpXT09VHJlZU1vZGVsTGlzdGVuZXIuY2xhc3MpIHsKLQkJCQkvLyBsYXppbHkgY3JlYXRlIHRoZSBldmVudAotCQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJCWV2ZW50ID0gbmV3IFRyZWVNb2RlbEV2ZW50KHRoaXMsIHBhdGgpOwotCQkJCX0KLQkJCQkoKFRyZWVNb2RlbExpc3RlbmVyKSBsaXN0ZW5lcnNbaSsxXSkudHJlZVN0cnVjdHVyZUNoYW5nZWQoZXZlbnQpOwotCQkJfQotCQl9Ci0JfQotCi0JLyoqCi0JICogTm90aWZ5IGxpc3RlbmVycyBvZiBhIG1vZGVsIGNoYW5nZS4KLQkgKiBAc2VlIGphdmF4LnN3aW5nLmV2ZW50LlRyZWVNb2RlbEV2ZW50Ci0JICogQHNlZSBqYXZheC5zd2luZy5ldmVudC5UcmVlTW9kZWxMaXN0ZW5lcgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGZpcmVUcmVlUm9vdFJlcGxhY2VkKE9iamVjdCBuZXdSb290KSB7Ci0JCXRoaXMuZmlyZVRyZWVTdHJ1Y3R1cmVDaGFuZ2VkKG5ldyBPYmplY3RbXSB7bmV3Um9vdH0pOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0NoZWNrQm94TW9kZWxBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvQ2hlY2tCb3hNb2RlbEFkYXB0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMTI2Y2JmYS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvQ2hlY2tCb3hNb2RlbEFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmc7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBUaGlzIGphdmF4LnN3aW5nLkJ1dHRvbk1vZGVsIGNhbiBiZSB1c2VkIHRvIGtlZXAgYSBsaXN0ZW5lcgotICogKGUuZy4gYSBKQ2hlY2tCb3gpIGluIHN5bmNoIHdpdGggYSBQcm9wZXJ0eVZhbHVlTW9kZWwgdGhhdAotICogaG9sZHMgYSBib29sZWFuLgotICogCi0gKiBNYXliZSBub3QgdGhlIHJpY2hlc3QgY2xhc3MgaW4gb3VyIHRvb2xib3gsIGJ1dCBpdCB3YXMgdGhlCi0gKiB2aWN0aW0gb2YgcmVmYWN0b3JpbmcuLi4uICB+Ymp2Ci0gKi8KLXB1YmxpYyBjbGFzcyBDaGVja0JveE1vZGVsQWRhcHRlcgotCWV4dGVuZHMgVG9nZ2xlQnV0dG9uTW9kZWxBZGFwdGVyCi17Ci0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3RvciAtIHRoZSBib29sZWFuIGhvbGRlciBpcyByZXF1aXJlZC4KLQkgKi8KLQlwdWJsaWMgQ2hlY2tCb3hNb2RlbEFkYXB0ZXIoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYm9vbGVhbkhvbGRlciwgYm9vbGVhbiBkZWZhdWx0VmFsdWUpIHsKLQkJc3VwZXIoYm9vbGVhbkhvbGRlciwgZGVmYXVsdFZhbHVlKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3RvciAtIHRoZSBib29sZWFuIGhvbGRlciBpcyByZXF1aXJlZC4KLQkgKiBUaGUgZGVmYXVsdCB2YWx1ZSB3aWxsIGJlIGZhbHNlLgotCSAqLwotCXB1YmxpYyBDaGVja0JveE1vZGVsQWRhcHRlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBib29sZWFuSG9sZGVyKSB7Ci0JCXN1cGVyKGJvb2xlYW5Ib2xkZXIpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0NvbHVtbkFkYXB0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9Db2x1bW5BZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQ4MmI1ZDIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0NvbHVtbkFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQ5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmc7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLQotCi0vKioKLSAqIFRoaXMgYWRhcHRlciBpcyB1c2VkIGJ5IHRoZSB0YWJsZSBtb2RlbCBhZGFwdGVyIHRvCi0gKiBjb252ZXJ0IGEgbW9kZWwgb2JqZWN0IGludG8gdGhlIG1vZGVscyB1c2VkIGZvciBlYWNoIG9mCi0gKiB0aGUgY2VsbHMgZm9yIHRoZSBvYmplY3QncyBjb3JyZXNwb25kaW5nIHJvdyBpbiB0aGUgdGFibGUuCi0gKi8KLXB1YmxpYyBpbnRlcmZhY2UgQ29sdW1uQWRhcHRlciB7Ci0JLyoqCi0JICogUmV0dXJuIHRoZSBudW1iZXIgb2YgY29sdW1ucyBpbiB0aGUgdGFibGUuCi0JICogVHlwaWNhbGx5IHRoaXMgaXMgc3RhdGljLgotCSAqLwotCWludCBjb2x1bW5Db3VudCgpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBuYW1lIG9mIHRoZSBzcGVjaWZpZWQgY29sdW1uLgotCSAqLwotCVN0cmluZyBjb2x1bW5OYW1lKGludCBpbmRleCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNsYXNzIG9mIHRoZSBzcGVjaWZpZWQgY29sdW1uLgotCSAqLwotCUNsYXNzPD8+IGNvbHVtbkNsYXNzKGludCBpbmRleCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGNvbHVtbiBpcyBlZGl0YWJsZS4KLQkgKiBUeXBpY2FsbHkgdGhpcyBpcyB0aGUgc2FtZSBmb3IgZXZlcnkgcm93LgotCSAqLwotCWJvb2xlYW4gY29sdW1uSXNFZGl0YWJsZShpbnQgaW5kZXgpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjZWxsIG1vZGVscyBmb3IgdGhlIHNwZWNpZmllZCBzdWJqZWN0Ci0JICogdGhhdCBjb3JyZXNwb25kcyB0byBhIHNpbmdsZSByb3cgaW4gdGhlIHRhYmxlLgotCSAqLwotCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD5bXSBjZWxsTW9kZWxzKE9iamVjdCBzdWJqZWN0KTsKLQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9Db21ib0JveE1vZGVsQWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0NvbWJvQm94TW9kZWxBZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGIzZTBjOTIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0NvbWJvQm94TW9kZWxBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNDAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZzsKLQotaW1wb3J0IGphdmF4LnN3aW5nLkNvbWJvQm94TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwubGlzdGVuZXIuYXd0LkFXVFByb3BlcnR5Q2hhbmdlTGlzdGVuZXJXcmFwcGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlByb3BlcnR5Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci0KLS8qKgotICogVGhpcyBqYXZheC5zd2luZy5Db21ib0JveE1vZGVsIGNhbiBiZSB1c2VkIHRvIGtlZXAgYSBMaXN0RGF0YUxpc3RlbmVyCi0gKiAoZS5nLiBhIEpDb21ib0JveCkgaW4gc3luY2ggd2l0aCBhIExpc3RWYWx1ZU1vZGVsIChvciBhIENvbGxlY3Rpb25WYWx1ZU1vZGVsKS4KLSAqIEZvciBjb21ibyBib3hlcywgdGhlIG1vZGVsIG9iamVjdCB0aGF0IGhvbGRzIHRoZSBjdXJyZW50IHNlbGVjdGlvbiBpcwotICogdHlwaWNhbGx5IGEgZGlmZmVyZW50IG1vZGVsIG9iamVjdCB0aGFuIHRoZSBvbmUgdGhhdCBob2xkcyB0aGUgY29sbGVjdGlvbgotICogb2YgY2hvaWNlcy4KLSAqIAotICogRm9yIGV4YW1wbGUsIGEgTVdSZWZlcmVuY2UgKHRoZSBzZWxlY3Rpb25Pd25lcikgaGFzIGFuIGF0dHJpYnV0ZQotICogInNvdXJjZVRhYmxlIiAodGhlIGNvbGxlY3Rpb25Pd25lcikKLSAqIHdoaWNoIGhvbGRzIG9uIHRvIGEgY29sbGVjdGlvbiBvZiBNV0RhdGFiYXNlRmllbGRzLiBXaGVuIHRoZSBzZWxlY3Rpb24KLSAqIGlzIGNoYW5nZWQgdGhpcyBtb2RlbCB3aWxsIGtlZXAgdGhlIGxpc3RlbmVycyBhd2FyZSBvZiB0aGUgY2hhbmdlcy4KLSAqIFRoZSBpbmhlcml0ZWQgbGlzdCBtb2RlbCB3aWxsIGtlZXAgaXRzIGxpc3RlbmVycyBhd2FyZSBvZiBjaGFuZ2VzIHRvIHRoZQotICogY29sbGVjdGlvbiBtb2RlbAotICogCi0gKiBJbiBhZGRpdGlvbiB0byB0aGUgY29sbGVjdGlvbiBob2xkZXIgcmVxdWlyZWQgYnkgdGhlIHN1cGVyY2xhc3MsCi0gKiBhbiBpbnN0YW5jZSBvZiB0aGlzIENvbWJvQm94TW9kZWwgbXVzdCBiZSBzdXBwbGllZCB3aXRoIGEKLSAqIHNlbGVjdGlvbiBob2xkZXIsIHdoaWNoIGlzIGEgUHJvcGVydHlWYWx1ZU1vZGVsIHRoYXQgcHJvdmlkZXMgYWNjZXNzCi0gKiB0byB0aGUgc2VsZWN0aW9uICh0eXBpY2FsbHkgYSBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXIpLgotICovCi1wdWJsaWMgY2xhc3MgQ29tYm9Cb3hNb2RlbEFkYXB0ZXIKLQlleHRlbmRzIExpc3RNb2RlbEFkYXB0ZXIKLQlpbXBsZW1lbnRzIENvbWJvQm94TW9kZWwKLXsKLQlwcm90ZWN0ZWQgZmluYWwgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBzZWxlY3Rpb25Ib2xkZXI7Ci0JcHJvdGVjdGVkIGZpbmFsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgc2VsZWN0aW9uTGlzdGVuZXI7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdG9yIC0gdGhlIGxpc3QgaG9sZGVyIGFuZCBzZWxlY3Rpb24gaG9sZGVyIGFyZSByZXF1aXJlZDsKLQkgKi8KLQlwdWJsaWMgQ29tYm9Cb3hNb2RlbEFkYXB0ZXIoTGlzdFZhbHVlTW9kZWw8Pz4gbGlzdEhvbGRlciwgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBzZWxlY3Rpb25Ib2xkZXIpIHsKLQkJc3VwZXIobGlzdEhvbGRlcik7Ci0JCWlmIChzZWxlY3Rpb25Ib2xkZXIgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy5zZWxlY3Rpb25Ib2xkZXIgPSBzZWxlY3Rpb25Ib2xkZXI7Ci0JCXRoaXMuc2VsZWN0aW9uTGlzdGVuZXIgPSB0aGlzLmJ1aWxkU2VsZWN0aW9uTGlzdGVuZXIoKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3RvciAtIHRoZSBjb2xsZWN0aW9uIGhvbGRlciBhbmQgc2VsZWN0aW9uIGhvbGRlciBhcmUgcmVxdWlyZWQ7Ci0JICovCi0JcHVibGljIENvbWJvQm94TW9kZWxBZGFwdGVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsPD8+IGNvbGxlY3Rpb25Ib2xkZXIsIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gc2VsZWN0aW9uSG9sZGVyKSB7Ci0JCXN1cGVyKGNvbGxlY3Rpb25Ib2xkZXIpOwotCQlpZiAoc2VsZWN0aW9uSG9sZGVyID09IG51bGwpIHsKLQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigpOwotCQl9Ci0JCXRoaXMuc2VsZWN0aW9uSG9sZGVyID0gc2VsZWN0aW9uSG9sZGVyOwotCQl0aGlzLnNlbGVjdGlvbkxpc3RlbmVyID0gdGhpcy5idWlsZFNlbGVjdGlvbkxpc3RlbmVyKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkU2VsZWN0aW9uTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgQVdUUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcldyYXBwZXIodGhpcy5idWlsZFNlbGVjdGlvbkxpc3RlbmVyXygpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZFNlbGVjdGlvbkxpc3RlbmVyXygpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQkvLyBub3RpZnkgbGlzdGVuZXJzIHRoYXQgdGhlIHNlbGVjdGlvbiBoYXMgY2hhbmdlZAotCQkJCUNvbWJvQm94TW9kZWxBZGFwdGVyLnRoaXMuZmlyZVNlbGVjdGlvbkNoYW5nZWQoKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gInNlbGVjdGlvbiBsaXN0ZW5lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIENvbWJvQm94TW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIE9iamVjdCBnZXRTZWxlY3RlZEl0ZW0oKSB7Ci0JCXJldHVybiB0aGlzLnNlbGVjdGlvbkhvbGRlci5nZXRWYWx1ZSgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHNldFNlbGVjdGVkSXRlbShPYmplY3Qgc2VsZWN0ZWRJdGVtKSB7Ci0JCXRoaXMuc2VsZWN0aW9uSG9sZGVyLnNldFZhbHVlKHNlbGVjdGVkSXRlbSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCS8qKgotCSAqIEV4dGVuZCB0byBlbmdhZ2UgdGhlIHNlbGVjdGlvbiBob2xkZXIuCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlTW9kZWwoKSB7Ci0JCXN1cGVyLmVuZ2FnZU1vZGVsKCk7Ci0JCXRoaXMuc2VsZWN0aW9uSG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLnNlbGVjdGlvbkxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gZGlzZW5nYWdlIHRoZSBzZWxlY3Rpb24gaG9sZGVyLgotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIGRpc2VuZ2FnZU1vZGVsKCkgewotCQl0aGlzLnNlbGVjdGlvbkhvbGRlci5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5zZWxlY3Rpb25MaXN0ZW5lcik7Ci0JCXN1cGVyLmRpc2VuZ2FnZU1vZGVsKCk7Ci0JfQotCi0JLyoqCi0JICogTm90aWZ5IHRoZSBsaXN0ZW5lcnMgdGhhdCB0aGUgc2VsZWN0aW9uIGhhcyBjaGFuZ2VkLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGZpcmVTZWxlY3Rpb25DaGFuZ2VkKCkgewotCQkvLyBJIGd1ZXNzIHRoaXMgd2lsbCB3b3JrLi4uCi0JCXRoaXMuZmlyZUNvbnRlbnRzQ2hhbmdlZCh0aGlzLCAtMSwgLTEpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuc2VsZWN0aW9uSG9sZGVyICsgIjoiICsgdGhpcy5saXN0SG9sZGVyKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9EYXRlU3Bpbm5lck1vZGVsQWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0RhdGVTcGlubmVyTW9kZWxBZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDY2ZDA5ZDIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0RhdGVTcGlubmVyTW9kZWxBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxOTggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZzsKLQotaW1wb3J0IGphdmEudXRpbC5DYWxlbmRhcjsKLWltcG9ydCBqYXZhLnV0aWwuRGF0ZTsKLWltcG9ydCBqYXZheC5zd2luZy5TcGlubmVyRGF0ZU1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLmxpc3RlbmVyLmF3dC5BV1RQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyV3JhcHBlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Qcm9wZXJ0eUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIFRoaXMgamF2YXguc3dpbmcuU3Bpbm5lckRhdGVNb2RlbCBjYW4gYmUgdXNlZCB0byBrZWVwIGEgQ2hhbmdlTGlzdGVuZXIKLSAqIChlLmcuIGEgSlNwaW5uZXIpIGluIHN5bmNoIHdpdGggYSBQcm9wZXJ0eVZhbHVlTW9kZWwgdGhhdCBob2xkcyBhIGRhdGUuCi0gKiAKLSAqIFRoaXMgY2xhc3MgbXVzdCBiZSBhIHN1Yi1jbGFzcyBvZiBTcGlubmVyRGF0ZU1vZGVsIGJlY2F1c2Ugb2Ygc29tZQotICogY3JhcHB5IGpkayBjb2RlLi4uLiAgfmJqdgotICogQHNlZSBqYXZheC5zd2luZy5KU3Bpbm5lciNjcmVhdGVFZGl0b3IoamF2YXguc3dpbmcuU3Bpbm5lck1vZGVsKQotICogCi0gKiBJZiB0aGlzIGNsYXNzIG5lZWRzIHRvIGJlIG1vZGlmaWVkLCBpdCB3b3VsZCBiZWhvb3ZlIHVzIHRvIHJldmlldyB0aGUKLSAqIG90aGVyLCBzaW1pbGFyIGNsYXNzZXM6Ci0gKiBAc2VlIExpc3RTcGlubmVyTW9kZWxBZGFwdGVyCi0gKiBAc2VlIE51bWJlclNwaW5uZXJNb2RlbEFkYXB0ZXIKLSAqLwotcHVibGljIGNsYXNzIERhdGVTcGlubmVyTW9kZWxBZGFwdGVyCi0JZXh0ZW5kcyBTcGlubmVyRGF0ZU1vZGVsCi17Ci0KLQkvKioKLQkgKiBUaGUgZGVmYXVsdCBzcGlubmVyIHZhbHVlOyB1c2VkIHdoZW4gdGhlIHVuZGVybHlpbmcgbW9kZWwgZGF0ZSB2YWx1ZSBpcyBudWxsLgotCSAqIFRoZSBkZWZhdWx0IGlzIHRoZSBjdXJyZW50IGRhdGUuCi0JICovCi0JcHJpdmF0ZSBmaW5hbCBEYXRlIGRlZmF1bHRWYWx1ZTsKLQotCS8qKiBBIHZhbHVlIG1vZGVsIG9uIHRoZSB1bmRlcmx5aW5nIGRhdGUuICovCi0JcHJpdmF0ZSBmaW5hbCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IGRhdGVIb2xkZXI7Ci0KLQkvKiogQSBsaXN0ZW5lciB0aGF0IGFsbG93cyB1cyB0byBzeW5jaHJvbml6ZSB3aXRoIGNoYW5nZXMgbWFkZSB0byB0aGUgdW5kZXJseWluZyBkYXRlLiAqLwotCXByaXZhdGUgZmluYWwgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBkYXRlQ2hhbmdlTGlzdGVuZXI7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdG9yIC0gdGhlIGRhdGUgaG9sZGVyIGlzIHJlcXVpcmVkLgotCSAqIFRoZSBkZWZhdWx0IHNwaW5uZXIgdmFsdWUgaXMgdGhlIGN1cnJlbnQgZGF0ZS4KLQkgKi8KLQlwdWJsaWMgRGF0ZVNwaW5uZXJNb2RlbEFkYXB0ZXIoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBkYXRlSG9sZGVyKSB7Ci0JCXRoaXMoZGF0ZUhvbGRlciwgbmV3IERhdGUoKSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0b3IgLSB0aGUgZGF0ZSBob2xkZXIgYW5kIGRlZmF1bHQgdmFsdWUgYXJlIHJlcXVpcmVkLgotCSAqLwotCXB1YmxpYyBEYXRlU3Bpbm5lck1vZGVsQWRhcHRlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IGRhdGVIb2xkZXIsIERhdGUgZGVmYXVsdFZhbHVlKSB7Ci0JCXRoaXMoZGF0ZUhvbGRlciwgbnVsbCwgbnVsbCwgQ2FsZW5kYXIuREFZX09GX01PTlRILCBkZWZhdWx0VmFsdWUpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdG9yIC0gdGhlIGRhdGUgaG9sZGVyIGlzIHJlcXVpcmVkLgotCSAqIFRoZSBkZWZhdWx0IHNwaW5uZXIgdmFsdWUgaXMgdGhlIGN1cnJlbnQgZGF0ZS4KLQkgKi8KLQlwdWJsaWMgRGF0ZVNwaW5uZXJNb2RlbEFkYXB0ZXIoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBkYXRlSG9sZGVyLCBDb21wYXJhYmxlPD8+IHN0YXJ0LCBDb21wYXJhYmxlPD8+IGVuZCwgaW50IGNhbGVuZGFyRmllbGQpIHsKLQkJdGhpcyhkYXRlSG9sZGVyLCBzdGFydCwgZW5kLCBjYWxlbmRhckZpZWxkLCBuZXcgRGF0ZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3RvciAtIHRoZSBkYXRlIGhvbGRlciBpcyByZXF1aXJlZC4KLQkgKi8KLQlwdWJsaWMgRGF0ZVNwaW5uZXJNb2RlbEFkYXB0ZXIoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBkYXRlSG9sZGVyLCBDb21wYXJhYmxlPD8+IHN0YXJ0LCBDb21wYXJhYmxlPD8+IGVuZCwgaW50IGNhbGVuZGFyRmllbGQsIERhdGUgZGVmYXVsdFZhbHVlKSB7Ci0JCXN1cGVyKGRhdGVIb2xkZXIuZ2V0VmFsdWUoKSA9PSBudWxsID8gZGVmYXVsdFZhbHVlIDogKERhdGUpIGRhdGVIb2xkZXIuZ2V0VmFsdWUoKSwgc3RhcnQsIGVuZCwgY2FsZW5kYXJGaWVsZCk7Ci0JCXRoaXMuZGF0ZUhvbGRlciA9IGRhdGVIb2xkZXI7Ci0JCXRoaXMuZGF0ZUNoYW5nZUxpc3RlbmVyID0gdGhpcy5idWlsZERhdGVDaGFuZ2VMaXN0ZW5lcigpOwotCQkvLyBwb3N0cG9uZSBsaXN0ZW5pbmcgdG8gdGhlIHVuZGVybHlpbmcgZGF0ZQotCQkvLyB1bnRpbCB3ZSBoYXZlIGxpc3RlbmVycyBvdXJzZWx2ZXMuLi4KLQkJdGhpcy5kZWZhdWx0VmFsdWUgPSBkZWZhdWx0VmFsdWU7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkRGF0ZUNoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IEFXVFByb3BlcnR5Q2hhbmdlTGlzdGVuZXJXcmFwcGVyKHRoaXMuYnVpbGREYXRlQ2hhbmdlTGlzdGVuZXJfKCkpOwotCX0KLQotCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkRGF0ZUNoYW5nZUxpc3RlbmVyXygpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlEYXRlU3Bpbm5lck1vZGVsQWRhcHRlci50aGlzLnN5bmNocm9uaXplKGV2ZW50LmdldE5ld1ZhbHVlKCkpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiZGF0ZSBsaXN0ZW5lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIFNwaW5uZXJNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQkvKioKLQkgKiBFeHRlbmQgdG8gY2hlY2sgd2hldGhlciB0aGlzIG1ldGhvZCBpcyBiZWluZyBjYWxsZWQgYmVmb3JlIHdlIAotCSAqIGhhdmUgYW55IGxpc3RlbmVycy4KLQkgKiBUaGlzIGlzIG5lY2Vzc2FyeSBiZWNhdXNlIHNvbWUgY3JhcHB5IGpkayBjb2RlIGdldHMgdGhlIHZhbHVlCi0JICogZnJvbSB0aGUgbW9kZWwgKmJlZm9yZSogbGlzdGVuaW5nIHRvIHRoZSBtb2RlbC4gIH5ianYKLQkgKiBAc2VlIGphdmF4LnN3aW5nLkpTcGlubmVyLkRlZmF1bHRFZGl0b3IoamF2YXguc3dpbmcuSlNwaW5uZXIpCi0JICovCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIE9iamVjdCBnZXRWYWx1ZSgpIHsKLQkJaWYgKHRoaXMuZ2V0Q2hhbmdlTGlzdGVuZXJzKCkubGVuZ3RoID09IDApIHsKLQkJCS8vIHNvcnJ5IGFib3V0IHRoaXMgImxhdGVyYWwiIGNhbGwgdG8gc3VwZXIgIH5ianYKLQkJCXN1cGVyLnNldFZhbHVlKHRoaXMuc3Bpbm5lclZhbHVlT2YodGhpcy5kYXRlSG9sZGVyLmdldFZhbHVlKCkpKTsKLQkJfQotCQlyZXR1cm4gc3VwZXIuZ2V0VmFsdWUoKTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gdXBkYXRlIHRoZSB1bmRlcmx5aW5nIGRhdGUgZGlyZWN0bHkuCi0JICogVGhlIHJlc3VsdGluZyBldmVudCB3aWxsIGJlIGlnbm9yZWQ6IEBzZWUgI3N5bmNocm9uaXplKE9iamVjdCkuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgc2V0VmFsdWUoT2JqZWN0IHZhbHVlKSB7Ci0JCXN1cGVyLnNldFZhbHVlKHZhbHVlKTsKLQkJdGhpcy5kYXRlSG9sZGVyLnNldFZhbHVlKHZhbHVlKTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSB1bmRlcmx5aW5nIGRhdGUgaWYgbmVjZXNzYXJ5LgotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGFkZENoYW5nZUxpc3RlbmVyKENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCWlmICh0aGlzLmdldENoYW5nZUxpc3RlbmVycygpLmxlbmd0aCA9PSAwKSB7Ci0JCQl0aGlzLmRhdGVIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMuZGF0ZUNoYW5nZUxpc3RlbmVyKTsKLQkJCXRoaXMuc3luY2hyb25pemUodGhpcy5kYXRlSG9sZGVyLmdldFZhbHVlKCkpOwotCQl9Ci0JCXN1cGVyLmFkZENoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RvcCBsaXN0ZW5pbmcgdG8gdGhlIHVuZGVybHlpbmcgZGF0ZSBpZiBhcHByb3ByaWF0ZS4KLQkgKi8KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCByZW1vdmVDaGFuZ2VMaXN0ZW5lcihDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlzdXBlci5yZW1vdmVDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWlmICh0aGlzLmdldENoYW5nZUxpc3RlbmVycygpLmxlbmd0aCA9PSAwKSB7Ci0JCQl0aGlzLmRhdGVIb2xkZXIucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMuZGF0ZUNoYW5nZUxpc3RlbmVyKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBxdWVyaWVzICoqKioqKioqKioKLQotCXByb3RlY3RlZCBEYXRlIGdldERlZmF1bHRWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMuZGVmYXVsdFZhbHVlOwotCX0KLQotCS8qKgotCSAqIENvbnZlcnQgdG8gYSBub24tbnVsbCB2YWx1ZS4KLQkgKi8KLQlwcm90ZWN0ZWQgT2JqZWN0IHNwaW5uZXJWYWx1ZU9mKE9iamVjdCB2YWx1ZSkgewotCQlyZXR1cm4gKHZhbHVlID09IG51bGwpID8gdGhpcy5nZXREZWZhdWx0VmFsdWUoKSA6IHZhbHVlOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBTZXQgdGhlIHNwaW5uZXIgdmFsdWUgaWYgaXQgaGFzIGNoYW5nZWQuCi0JICovCi0Jdm9pZCBzeW5jaHJvbml6ZShPYmplY3QgdmFsdWUpIHsKLQkJT2JqZWN0IG5ld1ZhbHVlID0gdGhpcy5zcGlubmVyVmFsdWVPZih2YWx1ZSk7Ci0JCS8vIGNoZWNrIHRvIHNlZSB3aGV0aGVyIHRoZSBzcGlubmVyIGRhdGUgaGFzIGFscmVhZHkgYmVlbiBzeW5jaHJvbml6ZWQKLQkJLy8gKHZpYSAjc2V0VmFsdWUoKSkKLQkJaWYgKCAhIHRoaXMuZ2V0VmFsdWUoKS5lcXVhbHMobmV3VmFsdWUpKSB7Ci0JCQl0aGlzLnNldFZhbHVlKG5ld1ZhbHVlKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBzdGFuZGFyZCBtZXRob2RzICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuZGF0ZUhvbGRlcik7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvRG9jdW1lbnRBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvRG9jdW1lbnRBZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVlYjY1YjQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0RvY3VtZW50QWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzYyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmc7Ci0KLWltcG9ydCBqYXZhLmlvLlNlcmlhbGl6YWJsZTsKLWltcG9ydCBqYXZhLnV0aWwuRXZlbnRPYmplY3Q7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuRG9jdW1lbnRFdmVudDsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5Eb2N1bWVudExpc3RlbmVyOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LkV2ZW50TGlzdGVuZXJMaXN0OwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LlVuZG9hYmxlRWRpdEV2ZW50OwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LlVuZG9hYmxlRWRpdExpc3RlbmVyOwotaW1wb3J0IGphdmF4LnN3aW5nLnRleHQuQXR0cmlidXRlU2V0OwotaW1wb3J0IGphdmF4LnN3aW5nLnRleHQuQmFkTG9jYXRpb25FeGNlcHRpb247Ci1pbXBvcnQgamF2YXguc3dpbmcudGV4dC5Eb2N1bWVudDsKLWltcG9ydCBqYXZheC5zd2luZy50ZXh0LkVsZW1lbnQ7Ci1pbXBvcnQgamF2YXguc3dpbmcudGV4dC5QbGFpbkRvY3VtZW50OwotaW1wb3J0IGphdmF4LnN3aW5nLnRleHQuUG9zaXRpb247Ci1pbXBvcnQgamF2YXguc3dpbmcudGV4dC5TZWdtZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLmxpc3RlbmVyLmF3dC5BV1RQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyV3JhcHBlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Qcm9wZXJ0eUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIFRoaXMgamF2YXguc3dpbmcudGV4dC5Eb2N1bWVudCBjYW4gYmUgdXNlZCB0byBrZWVwIGEgRG9jdW1lbnRMaXN0ZW5lcgotICogKGUuZy4gYSBKVGV4dEZpZWxkKSBpbiBzeW5jaCB3aXRoIGEgUHJvcGVydHlWYWx1ZU1vZGVsIHRoYXQgaG9sZHMgYSBzdHJpbmcuCi0gKiAKLSAqIE5COiBUaGlzIG1vZGVsIHNob3VsZCBvbmx5IGJlIHVzZWQgZm9yICJzbWFsbCIgZG9jdW1lbnRzOwotICogaS5lLiBkb2N1bWVudHMgdXNlZCBieSB0ZXh0IGZpZWxkcywgbm90IHRleHQgcGFuZXMuCi0gKiBAc2VlICNzeW5jaHJvbml6ZURlbGVnYXRlKFN0cmluZykKLSAqLwotcHVibGljIGNsYXNzIERvY3VtZW50QWRhcHRlcgotCWltcGxlbWVudHMgRG9jdW1lbnQsIFNlcmlhbGl6YWJsZQotewotCi0JLyoqIFRoZSBkZWxlZ2F0ZSBkb2N1bWVudCB3aG9zZSBiZWhhdmlvciB3ZSAiZW5oYW5jZSIuICovCi0JcHJvdGVjdGVkIGZpbmFsIERvY3VtZW50IGRlbGVnYXRlOwotCi0JLyoqIEEgbGlzdGVuZXIgdGhhdCBhbGxvd3MgdXMgdG8gZm9yd2FyZCBhbnkgY2hhbmdlcyBtYWRlIHRvIHRoZSBkZWxlZ2F0ZSBkb2N1bWVudC4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgQ29tYmluZWRMaXN0ZW5lciBkZWxlZ2F0ZUxpc3RlbmVyOwotCi0JLyoqIEEgdmFsdWUgbW9kZWwgb24gdGhlIHVuZGVybHlpbmcgbW9kZWwgc3RyaW5nLiAqLwotCXByb3RlY3RlZCBmaW5hbCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IHN0cmluZ0hvbGRlcjsKLQotCS8qKiBBIGxpc3RlbmVyIHRoYXQgYWxsb3dzIHVzIHRvIHN5bmNocm9uaXplIHdpdGggY2hhbmdlcyBtYWRlIHRvIHRoZSB1bmRlcmx5aW5nIG1vZGVsIHN0cmluZy4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBzdHJpbmdMaXN0ZW5lcjsKLQotICAgIC8qKiBUaGUgZXZlbnQgbGlzdGVuZXIgbGlzdCBmb3IgdGhlIGRvY3VtZW50LiAqLwotICAgIHByb3RlY3RlZCBmaW5hbCBFdmVudExpc3RlbmVyTGlzdCBsaXN0ZW5lckxpc3QgPSBuZXcgRXZlbnRMaXN0ZW5lckxpc3QoKTsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0b3IgLSB0aGUgc3RyaW5nIGhvbGRlciBpcyByZXF1aXJlZC4KLQkgKiBXcmFwIHRoZSBzcGVjaWZpZWQgZG9jdW1lbnQuCi0JICovCi0JcHVibGljIERvY3VtZW50QWRhcHRlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IHN0cmluZ0hvbGRlciwgRG9jdW1lbnQgZGVsZWdhdGUpIHsKLQkJc3VwZXIoKTsKLQkJaWYgKHN0cmluZ0hvbGRlciA9PSBudWxsIHx8IGRlbGVnYXRlID09IG51bGwpIHsKLQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigpOwotCQl9Ci0JCXRoaXMuc3RyaW5nSG9sZGVyID0gc3RyaW5nSG9sZGVyOwotCQkvLyBwb3N0cG9uZSBsaXN0ZW5pbmcgdG8gdGhlIHVuZGVybHlpbmcgbW9kZWwgc3RyaW5nCi0JCS8vIHVudGlsIHdlIGhhdmUgbGlzdGVuZXJzIG91cnNlbHZlcy4uLgotCQl0aGlzLmRlbGVnYXRlID0gZGVsZWdhdGU7Ci0JCXRoaXMuc3RyaW5nTGlzdGVuZXIgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdGVuZXIoKTsKLQkJdGhpcy5kZWxlZ2F0ZUxpc3RlbmVyID0gdGhpcy5idWlsZERlbGVnYXRlTGlzdGVuZXIoKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3RvciAtIHRoZSBzdHJpbmcgaG9sZGVyIGlzIHJlcXVpcmVkLgotCSAqIFdyYXAgYSBwbGFpbiBkb2N1bWVudC4KLQkgKi8KLQlwdWJsaWMgRG9jdW1lbnRBZGFwdGVyKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gc3RyaW5nSG9sZGVyKSB7Ci0JCXRoaXMoc3RyaW5nSG9sZGVyLCBuZXcgUGxhaW5Eb2N1bWVudCgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JcHJvdGVjdGVkIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGRTdHJpbmdMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBBV1RQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyV3JhcHBlcih0aGlzLmJ1aWxkU3RyaW5nTGlzdGVuZXJfKCkpOwotCX0KLQotCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkU3RyaW5nTGlzdGVuZXJfKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCURvY3VtZW50QWRhcHRlci50aGlzLnN0cmluZ0NoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAic3RyaW5nIGxpc3RlbmVyIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcm90ZWN0ZWQgQ29tYmluZWRMaXN0ZW5lciBidWlsZERlbGVnYXRlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgSW50ZXJuYWxMaXN0ZW5lcigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBEb2N1bWVudCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgaW50IGdldExlbmd0aCgpIHsKLQkJcmV0dXJuIHRoaXMuZGVsZWdhdGUuZ2V0TGVuZ3RoKCk7Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0YXJ0IGxpc3RlbmluZyB0byB0aGUgdW5kZXJseWluZyBtb2RlbHMgaWYgbmVjZXNzYXJ5LgotCSAqLwotCXB1YmxpYyB2b2lkIGFkZERvY3VtZW50TGlzdGVuZXIoRG9jdW1lbnRMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlpZiAodGhpcy5saXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJDb3VudChEb2N1bWVudExpc3RlbmVyLmNsYXNzKSA9PSAwKSB7Ci0JCQl0aGlzLmRlbGVnYXRlLmFkZERvY3VtZW50TGlzdGVuZXIodGhpcy5kZWxlZ2F0ZUxpc3RlbmVyKTsKLQkJCXRoaXMuZW5nYWdlU3RyaW5nSG9sZGVyKCk7Ci0JCX0KLQkJdGhpcy5saXN0ZW5lckxpc3QuYWRkKERvY3VtZW50TGlzdGVuZXIuY2xhc3MsIGxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RvcCBsaXN0ZW5pbmcgdG8gdGhlIHVuZGVybHlpbmcgbW9kZWxzIGlmIGFwcHJvcHJpYXRlLgotCSAqLwotCXB1YmxpYyB2b2lkIHJlbW92ZURvY3VtZW50TGlzdGVuZXIoRG9jdW1lbnRMaXN0ZW5lciBsaXN0ZW5lcikgewotCQl0aGlzLmxpc3RlbmVyTGlzdC5yZW1vdmUoRG9jdW1lbnRMaXN0ZW5lci5jbGFzcywgbGlzdGVuZXIpOwotCQlpZiAodGhpcy5saXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJDb3VudChEb2N1bWVudExpc3RlbmVyLmNsYXNzKSA9PSAwKSB7Ci0JCQl0aGlzLmRpc2VuZ2FnZVN0cmluZ0hvbGRlcigpOwotCQkJdGhpcy5kZWxlZ2F0ZS5yZW1vdmVEb2N1bWVudExpc3RlbmVyKHRoaXMuZGVsZWdhdGVMaXN0ZW5lcik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSBkZWxlZ2F0ZSBkb2N1bWVudCBpZiBuZWNlc3NhcnkuCi0JICovCi0JcHVibGljIHZvaWQgYWRkVW5kb2FibGVFZGl0TGlzdGVuZXIoVW5kb2FibGVFZGl0TGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJaWYgKHRoaXMubGlzdGVuZXJMaXN0LmdldExpc3RlbmVyQ291bnQoVW5kb2FibGVFZGl0TGlzdGVuZXIuY2xhc3MpID09IDApIHsKLQkJCXRoaXMuZGVsZWdhdGUuYWRkVW5kb2FibGVFZGl0TGlzdGVuZXIodGhpcy5kZWxlZ2F0ZUxpc3RlbmVyKTsKLQkJfQotCQl0aGlzLmxpc3RlbmVyTGlzdC5hZGQoVW5kb2FibGVFZGl0TGlzdGVuZXIuY2xhc3MsIGxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RvcCBsaXN0ZW5pbmcgdG8gdGhlIGRlbGVnYXRlIGRvY3VtZW50IGlmIGFwcHJvcHJpYXRlLgotCSAqLwotCXB1YmxpYyB2b2lkIHJlbW92ZVVuZG9hYmxlRWRpdExpc3RlbmVyKFVuZG9hYmxlRWRpdExpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXRoaXMubGlzdGVuZXJMaXN0LnJlbW92ZShVbmRvYWJsZUVkaXRMaXN0ZW5lci5jbGFzcywgbGlzdGVuZXIpOwotCQlpZiAodGhpcy5saXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJDb3VudChVbmRvYWJsZUVkaXRMaXN0ZW5lci5jbGFzcykgPT0gMCkgewotCQkJdGhpcy5kZWxlZ2F0ZS5yZW1vdmVVbmRvYWJsZUVkaXRMaXN0ZW5lcih0aGlzLmRlbGVnYXRlTGlzdGVuZXIpOwotCQl9Ci0JfQotCi0JcHVibGljIE9iamVjdCBnZXRQcm9wZXJ0eShPYmplY3Qga2V5KSB7Ci0JCXJldHVybiB0aGlzLmRlbGVnYXRlLmdldFByb3BlcnR5KGtleSk7Ci0JfQotCi0JcHVibGljIHZvaWQgcHV0UHJvcGVydHkoT2JqZWN0IGtleSwgT2JqZWN0IHZhbHVlKSB7Ci0JCXRoaXMuZGVsZWdhdGUucHV0UHJvcGVydHkoa2V5LCB2YWx1ZSk7Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRvIHVwZGF0ZSB0aGUgdW5kZXJseWluZyBtb2RlbCBzdHJpbmcgZGlyZWN0bHkuCi0JICogVGhlIHJlc3VsdGluZyBldmVudCB3aWxsIGJlIGlnbm9yZWQ6IEBzZWUgI3N5bmNocm9uaXplRGVsZWdhdGUoU3RyaW5nKS4KLQkgKi8KLQlwdWJsaWMgdm9pZCByZW1vdmUoaW50IG9mZnNldCwgaW50IGxlbikgdGhyb3dzIEJhZExvY2F0aW9uRXhjZXB0aW9uIHsKLQkJdGhpcy5kZWxlZ2F0ZS5yZW1vdmUob2Zmc2V0LCBsZW4pOwotCQl0aGlzLnN0cmluZ0hvbGRlci5zZXRWYWx1ZSh0aGlzLmRlbGVnYXRlLmdldFRleHQoMCwgdGhpcy5kZWxlZ2F0ZS5nZXRMZW5ndGgoKSkpOwotCX0KLQotCS8qKgotCSAqIEV4dGVuZCB0byB1cGRhdGUgdGhlIHVuZGVybHlpbmcgbW9kZWwgc3RyaW5nIGRpcmVjdGx5LgotCSAqIFRoZSByZXN1bHRpbmcgZXZlbnQgd2lsbCBiZSBpZ25vcmVkOiBAc2VlICNzeW5jaHJvbml6ZURlbGVnYXRlKFN0cmluZykuCi0JICovCi0JcHVibGljIHZvaWQgaW5zZXJ0U3RyaW5nKGludCBvZmZzZXQsIFN0cmluZyBpbnNlcnRlZFN0cmluZywgQXR0cmlidXRlU2V0IGEpIHRocm93cyBCYWRMb2NhdGlvbkV4Y2VwdGlvbiB7Ci0JCXRoaXMuZGVsZWdhdGUuaW5zZXJ0U3RyaW5nKG9mZnNldCwgaW5zZXJ0ZWRTdHJpbmcsIGEpOwotCQl0aGlzLnN0cmluZ0hvbGRlci5zZXRWYWx1ZSh0aGlzLmRlbGVnYXRlLmdldFRleHQoMCwgdGhpcy5kZWxlZ2F0ZS5nZXRMZW5ndGgoKSkpOwotCX0KLQotCXB1YmxpYyBTdHJpbmcgZ2V0VGV4dChpbnQgb2Zmc2V0LCBpbnQgbGVuZ3RoKSB0aHJvd3MgQmFkTG9jYXRpb25FeGNlcHRpb24gewotCQlyZXR1cm4gdGhpcy5kZWxlZ2F0ZS5nZXRUZXh0KG9mZnNldCwgbGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBnZXRUZXh0KGludCBvZmZzZXQsIGludCBsZW5ndGgsIFNlZ21lbnQgdHh0KSB0aHJvd3MgQmFkTG9jYXRpb25FeGNlcHRpb24gewotCQl0aGlzLmRlbGVnYXRlLmdldFRleHQob2Zmc2V0LCBsZW5ndGgsIHR4dCk7Ci0JfQotCi0JcHVibGljIFBvc2l0aW9uIGdldFN0YXJ0UG9zaXRpb24oKSB7Ci0JCXJldHVybiB0aGlzLmRlbGVnYXRlLmdldFN0YXJ0UG9zaXRpb24oKTsKLQl9Ci0KLQlwdWJsaWMgUG9zaXRpb24gZ2V0RW5kUG9zaXRpb24oKSB7Ci0JCXJldHVybiB0aGlzLmRlbGVnYXRlLmdldEVuZFBvc2l0aW9uKCk7Ci0JfQotCi0JcHVibGljIFBvc2l0aW9uIGNyZWF0ZVBvc2l0aW9uKGludCBvZmZzKSB0aHJvd3MgQmFkTG9jYXRpb25FeGNlcHRpb24gewotCQlyZXR1cm4gdGhpcy5kZWxlZ2F0ZS5jcmVhdGVQb3NpdGlvbihvZmZzKTsKLQl9Ci0KLQlwdWJsaWMgRWxlbWVudFtdIGdldFJvb3RFbGVtZW50cygpIHsKLQkJcmV0dXJuIHRoaXMuZGVsZWdhdGUuZ2V0Um9vdEVsZW1lbnRzKCk7Ci0JfQotCi0JcHVibGljIEVsZW1lbnQgZ2V0RGVmYXVsdFJvb3RFbGVtZW50KCkgewotCQlyZXR1cm4gdGhpcy5kZWxlZ2F0ZS5nZXREZWZhdWx0Um9vdEVsZW1lbnQoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCByZW5kZXIoUnVubmFibGUgcikgewotCQl0aGlzLmRlbGVnYXRlLnJlbmRlcihyKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogcXVlcmllcyAqKioqKioqKioqCi0KLQlwdWJsaWMgRG9jdW1lbnRMaXN0ZW5lcltdIGRvY3VtZW50TGlzdGVuZXJzKCkgewotCQlyZXR1cm4gdGhpcy5saXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJzKERvY3VtZW50TGlzdGVuZXIuY2xhc3MpOwotCX0KLQotCXB1YmxpYyBVbmRvYWJsZUVkaXRMaXN0ZW5lcltdIHVuZG9hYmxlRWRpdExpc3RlbmVycygpIHsKLQkJcmV0dXJuIHRoaXMubGlzdGVuZXJMaXN0LmdldExpc3RlbmVycyhVbmRvYWJsZUVkaXRMaXN0ZW5lci5jbGFzcyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCS8qKgotCSAqIEEgdGhpcmQgcGFydHkgaGFzIG1vZGlmaWVkIHRoZSB1bmRlcmx5aW5nIG1vZGVsIHN0cmluZy4KLQkgKiBTeW5jaHJvbml6ZSB0aGUgZGVsZWdhdGUgZG9jdW1lbnQgYWNjb3JkaW5nbHkuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgc3RyaW5nQ2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuc3luY2hyb25pemVEZWxlZ2F0ZSgoU3RyaW5nKSBldmVudC5nZXROZXdWYWx1ZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXBsYWNlIHRoZSBkb2N1bWVudCdzIGVudGlyZSB0ZXh0IHN0cmluZyB3aXRoIHRoZSBuZXcgc3RyaW5nLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIHN5bmNocm9uaXplRGVsZWdhdGUoU3RyaW5nIHMpIHsKLQkJdHJ5IHsKLQkJCWludCBsZW4gPSB0aGlzLmRlbGVnYXRlLmdldExlbmd0aCgpOwotCQkJLy8gY2hlY2sgdG8gc2VlIHdoZXRoZXIgdGhlIGRlbGVnYXRlIGhhcyBhbHJlYWR5IGJlZW4gc3luY2hyb25pemVkCi0JCQkvLyAodmlhICNpbnNlcnRTdHJpbmcoKSBvciAjcmVtb3ZlKCkpCi0JCQlpZiAoICEgdGhpcy5kZWxlZ2F0ZS5nZXRUZXh0KDAsIGxlbikuZXF1YWxzKHMpKSB7Ci0JCQkJdGhpcy5kZWxlZ2F0ZS5yZW1vdmUoMCwgbGVuKTsKLQkJCQl0aGlzLmRlbGVnYXRlLmluc2VydFN0cmluZygwLCBzLCBudWxsKTsKLQkJCX0KLQkJfSBjYXRjaCAoQmFkTG9jYXRpb25FeGNlcHRpb24gZXgpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oZXguZ2V0TWVzc2FnZSgpKTsJLy8gdGhpcyBzaG91bGQgbm90IGhhcHBlbi4uLgotCQl9Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlU3RyaW5nSG9sZGVyKCkgewotCQl0aGlzLnN0cmluZ0hvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5zdHJpbmdMaXN0ZW5lcik7Ci0JCXRoaXMuc3luY2hyb25pemVEZWxlZ2F0ZSh0aGlzLnN0cmluZ0hvbGRlci5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VTdHJpbmdIb2xkZXIoKSB7Ci0JCXRoaXMuc3RyaW5nSG9sZGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLnN0cmluZ0xpc3RlbmVyKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBkZWxlZ2F0ZUNoYW5nZWRVcGRhdGUoRG9jdW1lbnRFdmVudCBldmVudCkgewotCQkvLyBubyBuZWVkIHRvIGxhenktaW5pdGlhbGl6ZSB0aGUgZXZlbnQ7Ci0JCS8vIHdlIHdvdWxkbid0IGdldCBoZXJlIGlmIHdlIGRpZCBub3QgaGF2ZSBsaXN0ZW5lcnMuLi4KLQkJRG9jdW1lbnRFdmVudCBlZSA9IG5ldyBJbnRlcm5hbERvY3VtZW50RXZlbnQodGhpcywgZXZlbnQpOwotCQlEb2N1bWVudExpc3RlbmVyW10gbGlzdGVuZXJzID0gdGhpcy5kb2N1bWVudExpc3RlbmVycygpOwotCQlmb3IgKGludCBpID0gbGlzdGVuZXJzLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlsaXN0ZW5lcnNbaV0uY2hhbmdlZFVwZGF0ZShlZSk7Ci0JCX0KLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBkZWxlZ2F0ZUluc2VydFVwZGF0ZShEb2N1bWVudEV2ZW50IGV2ZW50KSB7Ci0JCS8vIG5vIG5lZWQgdG8gbGF6eS1pbml0aWFsaXplIHRoZSBldmVudDsKLQkJLy8gd2Ugd291bGRuJ3QgZ2V0IGhlcmUgaWYgd2UgZGlkIG5vdCBoYXZlIGxpc3RlbmVycy4uLgotCQlEb2N1bWVudEV2ZW50IGVlID0gbmV3IEludGVybmFsRG9jdW1lbnRFdmVudCh0aGlzLCBldmVudCk7Ci0JCURvY3VtZW50TGlzdGVuZXJbXSBsaXN0ZW5lcnMgPSB0aGlzLmRvY3VtZW50TGlzdGVuZXJzKCk7Ci0JCWZvciAoaW50IGkgPSBsaXN0ZW5lcnMubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCWxpc3RlbmVyc1tpXS5pbnNlcnRVcGRhdGUoZWUpOwotCQl9Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZGVsZWdhdGVSZW1vdmVVcGRhdGUoRG9jdW1lbnRFdmVudCBldmVudCkgewotCQkvLyBubyBuZWVkIHRvIGxhenktaW5pdGlhbGl6ZSB0aGUgZXZlbnQ7Ci0JCS8vIHdlIHdvdWxkbid0IGdldCBoZXJlIGlmIHdlIGRpZCBub3QgaGF2ZSBsaXN0ZW5lcnMuLi4KLQkJRG9jdW1lbnRFdmVudCBlZSA9IG5ldyBJbnRlcm5hbERvY3VtZW50RXZlbnQodGhpcywgZXZlbnQpOwotCQlEb2N1bWVudExpc3RlbmVyW10gbGlzdGVuZXJzID0gdGhpcy5kb2N1bWVudExpc3RlbmVycygpOwotCQlmb3IgKGludCBpID0gbGlzdGVuZXJzLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlsaXN0ZW5lcnNbaV0ucmVtb3ZlVXBkYXRlKGVlKTsKLQkJfQotCX0KLQotCXByb3RlY3RlZCB2b2lkIGRlbGVnYXRlVW5kb2FibGVFZGl0SGFwcGVuZWQoVW5kb2FibGVFZGl0RXZlbnQgZXZlbnQpIHsKLQkJLy8gbm8gbmVlZCB0byBsYXp5LWluaXRpYWxpemUgdGhlIGV2ZW50OwotCQkvLyB3ZSB3b3VsZG4ndCBnZXQgaGVyZSBpZiB3ZSBkaWQgbm90IGhhdmUgbGlzdGVuZXJzLi4uCi0JCVVuZG9hYmxlRWRpdEV2ZW50IGVlID0gbmV3IFVuZG9hYmxlRWRpdEV2ZW50KHRoaXMsIGV2ZW50LmdldEVkaXQoKSk7Ci0JCVVuZG9hYmxlRWRpdExpc3RlbmVyW10gbGlzdGVuZXJzID0gdGhpcy51bmRvYWJsZUVkaXRMaXN0ZW5lcnMoKTsKLQkJZm9yIChpbnQgaSA9IGxpc3RlbmVycy5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJbGlzdGVuZXJzW2ldLnVuZG9hYmxlRWRpdEhhcHBlbmVkKGVlKTsKLQkJfQotCX0KLQotCS8vICoqKioqKioqKiogc3RhbmRhcmQgbWV0aG9kcyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuYnVpbGRUb1N0cmluZ0Zvcih0aGlzLCB0aGlzLnN0cmluZ0hvbGRlcik7Ci0JfQotCi0KLS8vICoqKioqKioqKiogaW5uZXIgY2xhc3MgKioqKioqKioqKgotCi0JcHJvdGVjdGVkIGludGVyZmFjZSBDb21iaW5lZExpc3RlbmVyIGV4dGVuZHMgRG9jdW1lbnRMaXN0ZW5lciwgVW5kb2FibGVFZGl0TGlzdGVuZXIgewotCQkvLyBqdXN0IGNvbnNvbGlkYXRlIHRoZSB0d28gaW50ZXJmYWNlcwotCX0KLQotCXByb3RlY3RlZCBjbGFzcyBJbnRlcm5hbExpc3RlbmVyIGltcGxlbWVudHMgQ29tYmluZWRMaXN0ZW5lciB7Ci0JCXB1YmxpYyB2b2lkIGNoYW5nZWRVcGRhdGUoRG9jdW1lbnRFdmVudCBldmVudCkgewotCQkJRG9jdW1lbnRBZGFwdGVyLnRoaXMuZGVsZWdhdGVDaGFuZ2VkVXBkYXRlKGV2ZW50KTsKLQkJfQotCQlwdWJsaWMgdm9pZCBpbnNlcnRVcGRhdGUoRG9jdW1lbnRFdmVudCBldmVudCkgewotCQkJRG9jdW1lbnRBZGFwdGVyLnRoaXMuZGVsZWdhdGVJbnNlcnRVcGRhdGUoZXZlbnQpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHJlbW92ZVVwZGF0ZShEb2N1bWVudEV2ZW50IGV2ZW50KSB7Ci0JCQlEb2N1bWVudEFkYXB0ZXIudGhpcy5kZWxlZ2F0ZVJlbW92ZVVwZGF0ZShldmVudCk7Ci0JCX0KLQkJcHVibGljIHZvaWQgdW5kb2FibGVFZGl0SGFwcGVuZWQoVW5kb2FibGVFZGl0RXZlbnQgZXZlbnQpIHsKLQkJCURvY3VtZW50QWRhcHRlci50aGlzLmRlbGVnYXRlVW5kb2FibGVFZGl0SGFwcGVuZWQoZXZlbnQpOwotCQl9Ci0JfQotCQotCXByb3RlY3RlZCBzdGF0aWMgY2xhc3MgSW50ZXJuYWxEb2N1bWVudEV2ZW50Ci0JCWV4dGVuZHMgRXZlbnRPYmplY3QKLQkJaW1wbGVtZW50cyBEb2N1bWVudEV2ZW50Ci0JewotCQlwcm90ZWN0ZWQgRG9jdW1lbnRFdmVudCBkZWxlZ2F0ZTsKLQkKLQkJcHJvdGVjdGVkIEludGVybmFsRG9jdW1lbnRFdmVudChEb2N1bWVudCBkb2N1bWVudCwgRG9jdW1lbnRFdmVudCBkZWxlZ2F0ZSkgewotCQkJc3VwZXIoZG9jdW1lbnQpOwotCQkJdGhpcy5kZWxlZ2F0ZSA9IGRlbGVnYXRlOwotCQl9Ci0JCXB1YmxpYyBFbGVtZW50Q2hhbmdlIGdldENoYW5nZShFbGVtZW50IGVsZW0pIHsKLQkJCXJldHVybiB0aGlzLmRlbGVnYXRlLmdldENoYW5nZShlbGVtKTsKLQkJfQotCQlwdWJsaWMgRG9jdW1lbnQgZ2V0RG9jdW1lbnQoKSB7Ci0JCQlyZXR1cm4gKERvY3VtZW50KSB0aGlzLnNvdXJjZTsKLQkJfQotCQlwdWJsaWMgaW50IGdldExlbmd0aCgpIHsKLQkJCXJldHVybiB0aGlzLmRlbGVnYXRlLmdldExlbmd0aCgpOwotCQl9Ci0JCXB1YmxpYyBpbnQgZ2V0T2Zmc2V0KCkgewotCQkJcmV0dXJuIHRoaXMuZGVsZWdhdGUuZ2V0T2Zmc2V0KCk7Ci0JCX0KLQkJcHVibGljIEV2ZW50VHlwZSBnZXRUeXBlKCkgewotCQkJcmV0dXJuIHRoaXMuZGVsZWdhdGUuZ2V0VHlwZSgpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvTGlzdE1vZGVsQWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0xpc3RNb2RlbEFkYXB0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDJlOTUyZi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvTGlzdE1vZGVsQWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjg2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmc7Ci0KLWltcG9ydCBqYXZheC5zd2luZy5BYnN0cmFjdExpc3RNb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5MaXN0RGF0YUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLmxpc3RlbmVyLmF3dC5BV1RMaXN0Q2hhbmdlTGlzdGVuZXJXcmFwcGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuTGlzdENoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkxpc3RDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBUaGlzIGphdmF4LnN3aW5nLkxpc3RNb2RlbCBjYW4gYmUgdXNlZCB0byBrZWVwIGEgTGlzdERhdGFMaXN0ZW5lcgotICogKGUuZy4gYSBKTGlzdCkgaW4gc3luY2ggd2l0aCBhIExpc3RWYWx1ZU1vZGVsIChvciBhIENvbGxlY3Rpb25WYWx1ZU1vZGVsKS4KLSAqIAotICogQW4gaW5zdGFuY2Ugb2YgdGhpcyBMaXN0TW9kZWwgKm11c3QqIGJlIHN1cHBsaWVkIHdpdGggYSB2YWx1ZSBtb2RlbCwKLSAqIHdoaWNoIGlzIGEgTGlzdFZhbHVlTW9kZWwgb24gdGhlIGJvdW5kIGxpc3Qgb3IgYSBDb2xsZWN0aW9uVmFsdWVNb2RlbAotICogb24gdGhlIGJvdW5kIGNvbGxlY3Rpb24uIFRoaXMgaXMgcmVxdWlyZWQgLSB0aGUgbGlzdCAob3IgY29sbGVjdGlvbikKLSAqIGl0c2VsZiBjYW4gYmUgbnVsbCwgYnV0IHRoZSB2YWx1ZSBtb2RlbCB0aGF0IGhvbGRzIGl0IGNhbm5vdC4KLSAqLwotcHVibGljIGNsYXNzIExpc3RNb2RlbEFkYXB0ZXIKLQlleHRlbmRzIEFic3RyYWN0TGlzdE1vZGVsCi17Ci0JLyoqIEEgdmFsdWUgbW9kZWwgb24gdGhlIHVuZGVybHlpbmcgbW9kZWwgbGlzdC4gKi8KLQlwcm90ZWN0ZWQgTGlzdFZhbHVlTW9kZWw8Pz4gbGlzdEhvbGRlcjsKLQotCS8qKgotCSAqIENhY2hlIHRoZSBzaXplIG9mIHRoZSBsaXN0IGZvciAiZHJhbWF0aWMiIGNoYW5nZXMuCi0JICogQHNlZSAjbGlzdENoYW5nZWQoTGlzdENoYW5nZUV2ZW50KQotCSAqLwotCXByb3RlY3RlZCBpbnQgbGlzdFNpemU7Ci0KLQkvKiogQSBsaXN0ZW5lciB0aGF0IGFsbG93cyB1cyB0byBmb3J3YXJkIGNoYW5nZXMgbWFkZSB0byB0aGUgdW5kZXJseWluZyBtb2RlbCBsaXN0LiAqLwotCXByb3RlY3RlZCBmaW5hbCBMaXN0Q2hhbmdlTGlzdGVuZXIgbGlzdENoYW5nZUxpc3RlbmVyOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBEZWZhdWx0IGNvbnN0cnVjdG9yIC0gaW5pdGlhbGl6ZSBzdHVmZi4KLQkgKi8KLQlwcml2YXRlIExpc3RNb2RlbEFkYXB0ZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMubGlzdFNpemUgPSAwOwotCQl0aGlzLmxpc3RDaGFuZ2VMaXN0ZW5lciA9IHRoaXMuYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXIoKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3RvciAtIHRoZSBsaXN0IGhvbGRlciBpcyByZXF1aXJlZC4KLQkgKi8KLQlwdWJsaWMgTGlzdE1vZGVsQWRhcHRlcihMaXN0VmFsdWVNb2RlbDw/PiBsaXN0SG9sZGVyKSB7Ci0JCXRoaXMoKTsKLQkJdGhpcy5zZXRNb2RlbChsaXN0SG9sZGVyKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3RvciAtIHRoZSBjb2xsZWN0aW9uIGhvbGRlciBpcyByZXF1aXJlZC4KLQkgKi8KLQlwdWJsaWMgTGlzdE1vZGVsQWRhcHRlcihDb2xsZWN0aW9uVmFsdWVNb2RlbDw/PiBjb2xsZWN0aW9uSG9sZGVyKSB7Ci0JCXRoaXMoKTsKLQkJdGhpcy5zZXRNb2RlbChjb2xsZWN0aW9uSG9sZGVyKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JcHJvdGVjdGVkIExpc3RDaGFuZ2VMaXN0ZW5lciBidWlsZExpc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBBV1RMaXN0Q2hhbmdlTGlzdGVuZXJXcmFwcGVyKHRoaXMuYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXJfKCkpOwotCX0KLQotCXByb3RlY3RlZCBMaXN0Q2hhbmdlTGlzdGVuZXIgYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXJfKCkgewotCQlyZXR1cm4gbmV3IExpc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJTGlzdE1vZGVsQWRhcHRlci50aGlzLml0ZW1zQWRkZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUxpc3RNb2RlbEFkYXB0ZXIudGhpcy5pdGVtc1JlbW92ZWQoZXZlbnQpOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlMaXN0TW9kZWxBZGFwdGVyLnRoaXMuaXRlbXNSZXBsYWNlZChldmVudCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc01vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUxpc3RNb2RlbEFkYXB0ZXIudGhpcy5pdGVtc01vdmVkKGV2ZW50KTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGxpc3RDbGVhcmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUxpc3RNb2RlbEFkYXB0ZXIudGhpcy5saXN0Q2xlYXJlZCgpOwotCQkJfQotCQkJcHVibGljIHZvaWQgbGlzdENoYW5nZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJTGlzdE1vZGVsQWRhcHRlci50aGlzLmxpc3RDaGFuZ2VkKCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJsaXN0IGxpc3RlbmVyIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogTGlzdE1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBpbnQgZ2V0U2l6ZSgpIHsKLQkJcmV0dXJuIHRoaXMubGlzdEhvbGRlci5zaXplKCk7Ci0JfQotCi0JcHVibGljIE9iamVjdCBnZXRFbGVtZW50QXQoaW50IGluZGV4KSB7Ci0JCXJldHVybiB0aGlzLmxpc3RIb2xkZXIuZ2V0KGluZGV4KTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSB1bmRlcmx5aW5nIG1vZGVsIGxpc3QgaWYgbmVjZXNzYXJ5LgotCSAqLwotICAgIEBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGFkZExpc3REYXRhTGlzdGVuZXIoTGlzdERhdGFMaXN0ZW5lciBsKSB7Ci0JCWlmICh0aGlzLmhhc05vTGlzdERhdGFMaXN0ZW5lcnMoKSkgewotCQkJdGhpcy5lbmdhZ2VNb2RlbCgpOwotCQkJdGhpcy5saXN0U2l6ZSA9IHRoaXMubGlzdEhvbGRlci5zaXplKCk7Ci0JCX0KLQkJc3VwZXIuYWRkTGlzdERhdGFMaXN0ZW5lcihsKTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RvcCBsaXN0ZW5pbmcgdG8gdGhlIHVuZGVybHlpbmcgbW9kZWwgbGlzdCBpZiBhcHByb3ByaWF0ZS4KLQkgKi8KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCByZW1vdmVMaXN0RGF0YUxpc3RlbmVyKExpc3REYXRhTGlzdGVuZXIgbCkgewotCQlzdXBlci5yZW1vdmVMaXN0RGF0YUxpc3RlbmVyKGwpOwotCQlpZiAodGhpcy5oYXNOb0xpc3REYXRhTGlzdGVuZXJzKCkpIHsKLQkJCXRoaXMuZGlzZW5nYWdlTW9kZWwoKTsKLQkJCXRoaXMubGlzdFNpemUgPSAwOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHB1YmxpYyBBUEkgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSB1bmRlcmx5aW5nIGxpc3QgbW9kZWwuCi0JICovCi0JcHVibGljIExpc3RWYWx1ZU1vZGVsPD8+IG1vZGVsKCkgewotCQlyZXR1cm4gdGhpcy5saXN0SG9sZGVyOwotCX0KLQkKLQkvKioKLQkgKiBTZXQgdGhlIHVuZGVybHlpbmcgbGlzdCBtb2RlbC4KLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRNb2RlbChMaXN0VmFsdWVNb2RlbDw/PiBsaXN0SG9sZGVyKSB7Ci0JCWlmIChsaXN0SG9sZGVyID09IG51bGwpIHsKLQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigpOwotCQl9Ci0JCWJvb2xlYW4gaGFzTGlzdGVuZXJzID0gdGhpcy5oYXNMaXN0RGF0YUxpc3RlbmVycygpOwotCQlpZiAoaGFzTGlzdGVuZXJzKSB7Ci0JCQl0aGlzLmRpc2VuZ2FnZU1vZGVsKCk7Ci0JCX0KLQkJdGhpcy5saXN0SG9sZGVyID0gbGlzdEhvbGRlcjsKLQkJaWYgKGhhc0xpc3RlbmVycykgewotCQkJdGhpcy5lbmdhZ2VNb2RlbCgpOwotCQkJdGhpcy5saXN0Q2hhbmdlZCgpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSB1bmRlcmx5aW5nIGNvbGxlY3Rpb24gbW9kZWwuCi0JICovCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHVibGljIHZvaWQgc2V0TW9kZWwoQ29sbGVjdGlvblZhbHVlTW9kZWw8Pz4gY29sbGVjdGlvbkhvbGRlcikgewotCQl0aGlzLnNldE1vZGVsKG5ldyBDb2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyKGNvbGxlY3Rpb25Ib2xkZXIpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogcXVlcmllcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGlzIG1vZGVsIGhhcyBubyBsaXN0ZW5lcnMuCi0JICovCi0JcHJvdGVjdGVkIGJvb2xlYW4gaGFzTm9MaXN0RGF0YUxpc3RlbmVycygpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0TGlzdERhdGFMaXN0ZW5lcnMoKS5sZW5ndGggPT0gMDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGlzIG1vZGVsIGhhcyBhbnkgbGlzdGVuZXJzLgotCSAqLwotCXByb3RlY3RlZCBib29sZWFuIGhhc0xpc3REYXRhTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gISB0aGlzLmhhc05vTGlzdERhdGFMaXN0ZW5lcnMoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlTW9kZWwoKSB7Ci0JCXRoaXMubGlzdEhvbGRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMubGlzdENoYW5nZUxpc3RlbmVyKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VNb2RlbCgpIHsKLQkJdGhpcy5saXN0SG9sZGVyLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5saXN0Q2hhbmdlTGlzdGVuZXIpOwotCX0KLQotCi0KLQkvLyAqKioqKioqKioqIGxpc3QgY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JLyoqCi0JICogSXRlbXMgd2VyZSBhZGRlZCB0byB0aGUgdW5kZXJseWluZyBtb2RlbCBsaXN0LgotCSAqIE5vdGlmeSBsaXN0ZW5lcnMgb2YgdGhlIGNoYW5nZXMuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaW50IHN0YXJ0ID0gZXZlbnQuZ2V0SW5kZXgoKTsKLQkJaW50IGVuZCA9IHN0YXJ0ICsgZXZlbnQuaXRlbXNTaXplKCkgLSAxOwotCQl0aGlzLmZpcmVJbnRlcnZhbEFkZGVkKHRoaXMsIHN0YXJ0LCBlbmQpOwotCQl0aGlzLmxpc3RTaXplICs9IGV2ZW50Lml0ZW1zU2l6ZSgpOwotCX0KLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgcmVtb3ZlZCBmcm9tIHRoZSB1bmRlcmx5aW5nIG1vZGVsIGxpc3QuCi0JICogTm90aWZ5IGxpc3RlbmVycyBvZiB0aGUgY2hhbmdlcy4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBpdGVtc1JlbW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCWludCBzdGFydCA9IGV2ZW50LmdldEluZGV4KCk7Ci0JCWludCBlbmQgPSBzdGFydCArIGV2ZW50Lml0ZW1zU2l6ZSgpIC0gMTsKLQkJdGhpcy5maXJlSW50ZXJ2YWxSZW1vdmVkKHRoaXMsIHN0YXJ0LCBlbmQpOwotCQl0aGlzLmxpc3RTaXplIC09IGV2ZW50Lml0ZW1zU2l6ZSgpOwotCX0KLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgcmVwbGFjZWQgaW4gdGhlIHVuZGVybHlpbmcgbW9kZWwgbGlzdC4KLQkgKiBOb3RpZnkgbGlzdGVuZXJzIG9mIHRoZSBjaGFuZ2VzLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCWludCBzdGFydCA9IGV2ZW50LmdldEluZGV4KCk7Ci0JCWludCBlbmQgPSBzdGFydCArIGV2ZW50Lml0ZW1zU2l6ZSgpIC0gMTsKLQkJdGhpcy5maXJlQ29udGVudHNDaGFuZ2VkKHRoaXMsIHN0YXJ0LCBlbmQpOwotCX0KLQotCS8qKgotCSAqIEl0ZW1zIHdlcmUgbW92ZWQgaW4gdGhlIHVuZGVybHlpbmcgbW9kZWwgbGlzdC4KLQkgKiBOb3RpZnkgbGlzdGVuZXJzIG9mIHRoZSBjaGFuZ2VzLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCWludCBzdGFydCA9IE1hdGgubWluKGV2ZW50LmdldFNvdXJjZUluZGV4KCksIGV2ZW50LmdldFRhcmdldEluZGV4KCkpOwotCQlpbnQgZW5kID0gTWF0aC5tYXgoZXZlbnQuZ2V0U291cmNlSW5kZXgoKSwgZXZlbnQuZ2V0VGFyZ2V0SW5kZXgoKSkgKyBldmVudC5nZXRNb3ZlTGVuZ3RoKCkgLSAxOwotCQl0aGlzLmZpcmVDb250ZW50c0NoYW5nZWQodGhpcywgc3RhcnQsIGVuZCk7Ci0JfQotCi0JLyoqCi0JICogVGhlIHVuZGVybHlpbmcgbW9kZWwgbGlzdCB3YXMgY2xlYXJlZC4KLQkgKiBOb3RpZnkgbGlzdGVuZXJzIG9mIHRoZSBjaGFuZ2VzLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGxpc3RDbGVhcmVkKCkgewotCQlpZiAodGhpcy5saXN0U2l6ZSAhPSAwKSB7Ci0JCQl0aGlzLmZpcmVJbnRlcnZhbFJlbW92ZWQodGhpcywgMCwgdGhpcy5saXN0U2l6ZSAtIDEpOwotCQkJdGhpcy5saXN0U2l6ZSA9IDA7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBUaGUgdW5kZXJseWluZyBtb2RlbCBsaXN0IGhhcyBjaGFuZ2VkICJkcmFtYXRpY2FsbHkiLgotCSAqIE5vdGlmeSBsaXN0ZW5lcnMgb2YgdGhlIGNoYW5nZXMuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgbGlzdENoYW5nZWQoKSB7Ci0JCWlmICh0aGlzLmxpc3RTaXplICE9IDApIHsKLQkJCXRoaXMuZmlyZUludGVydmFsUmVtb3ZlZCh0aGlzLCAwLCB0aGlzLmxpc3RTaXplIC0gMSk7Ci0JCX0KLQkJdGhpcy5saXN0U2l6ZSA9IHRoaXMubGlzdEhvbGRlci5zaXplKCk7Ci0JCWlmICh0aGlzLmxpc3RTaXplICE9IDApIHsKLQkJCXRoaXMuZmlyZUludGVydmFsQWRkZWQodGhpcywgMCwgdGhpcy5saXN0U2l6ZSAtIDEpOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIE9iamVjdCBvdmVycmlkZXMgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5saXN0SG9sZGVyKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9MaXN0U3Bpbm5lck1vZGVsQWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0xpc3RTcGlubmVyTW9kZWxBZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDUyNzEyMDMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0xpc3RTcGlubmVyTW9kZWxBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyMTggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZzsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheXM7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YXguc3dpbmcuU3Bpbm5lckxpc3RNb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5saXN0ZW5lci5hd3QuQVdUUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcldyYXBwZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBUaGlzIGphdmF4LnN3aW5nLlNwaW5uZXJMaXN0TW9kZWwgY2FuIGJlIHVzZWQgdG8ga2VlcCBhIENoYW5nZUxpc3RlbmVyCi0gKiAoZS5nLiBhIEpTcGlubmVyKSBpbiBzeW5jaCB3aXRoIGEgUHJvcGVydHlWYWx1ZU1vZGVsIHRoYXQgaG9sZHMgYSB2YWx1ZQotICogaW4gdGhlIGxpc3QuCi0gKiAKLSAqIFRoaXMgY2xhc3MgbXVzdCBiZSBhIHN1Yi1jbGFzcyBvZiBTcGlubmVyTGlzdE1vZGVsIGJlY2F1c2Ugb2Ygc29tZQotICogY3JhcHB5IGpkayBjb2RlLi4uLiAgfmJqdgotICogQHNlZSBqYXZheC5zd2luZy5KU3Bpbm5lciNjcmVhdGVFZGl0b3IoamF2YXguc3dpbmcuU3Bpbm5lck1vZGVsKQotICogCi0gKiBOQjogVGhpcyBtb2RlbCBzaG91bGQgb25seSBiZSB1c2VkIGZvciB2YWx1ZXMgdGhhdCBoYXZlIGEgcmVhc29uYWJseQotICogaW5leHBlbnNpdmUgI2VxdWFscygpIGltcGxlbWVudGF0aW9uLgotICogQHNlZSAjc3luY2hyb25pemUoT2JqZWN0KQotICogCi0gKiBJZiB0aGlzIGNsYXNzIG5lZWRzIHRvIGJlIG1vZGlmaWVkLCBpdCB3b3VsZCBiZWhvb3ZlIHVzIHRvIHJldmlldyB0aGUKLSAqIG90aGVyLCBzaW1pbGFyIGNsYXNzZXM6Ci0gKiBAc2VlIERhdGVTcGlubmVyTW9kZWxBZGFwdGVyCi0gKiBAc2VlIE51bWJlclNwaW5uZXJNb2RlbEFkYXB0ZXIKLSAqLwotcHVibGljIGNsYXNzIExpc3RTcGlubmVyTW9kZWxBZGFwdGVyCi0JZXh0ZW5kcyBTcGlubmVyTGlzdE1vZGVsCi17Ci0KLQkvKioKLQkgKiBUaGUgZGVmYXVsdCBzcGlubmVyIHZhbHVlOyB1c2VkIHdoZW4gdGhlIHVuZGVybHlpbmcgbW9kZWwgdmFsdWUgaXMgbnVsbC4KLQkgKiBUaGUgZGVmYXVsdCBpcyB0aGUgZmlyc3QgaXRlbSBvbiB0aGUgbGlzdC4KLQkgKi8KLQlwcml2YXRlIGZpbmFsIE9iamVjdCBkZWZhdWx0VmFsdWU7Ci0KLQkvKiogQSB2YWx1ZSBtb2RlbCBvbiB0aGUgdW5kZXJseWluZyB2YWx1ZS4gKi8KLQlwcml2YXRlIGZpbmFsIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gdmFsdWVIb2xkZXI7Ci0KLQkvKiogQSBsaXN0ZW5lciB0aGF0IGFsbG93cyB1cyB0byBzeW5jaHJvbml6ZSB3aXRoIGNoYW5nZXMgbWFkZSB0byB0aGUgdW5kZXJseWluZyB2YWx1ZS4gKi8KLQlwcml2YXRlIGZpbmFsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgdmFsdWVDaGFuZ2VMaXN0ZW5lcjsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0b3IgLSB0aGUgdmFsdWUgaG9sZGVyIGlzIHJlcXVpcmVkLgotCSAqIFVzZSB0aGUgbW9kZWwgdmFsdWUgaXRzZWxmIGFzIHRoZSBkZWZhdWx0IHNwaW5uZXIgdmFsdWUuCi0JICovCi0JcHVibGljIExpc3RTcGlubmVyTW9kZWxBZGFwdGVyKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gdmFsdWVIb2xkZXIpIHsKLQkJdGhpcyh2YWx1ZUhvbGRlciwgdmFsdWVIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0b3IgLSB0aGUgdmFsdWUgaG9sZGVyIGlzIHJlcXVpcmVkLgotCSAqLwotCXB1YmxpYyBMaXN0U3Bpbm5lck1vZGVsQWRhcHRlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IHZhbHVlSG9sZGVyLCBPYmplY3QgZGVmYXVsdFZhbHVlKSB7Ci0JCXRoaXModmFsdWVIb2xkZXIsIG5ldyBPYmplY3RbXSB7ZGVmYXVsdFZhbHVlfSwgZGVmYXVsdFZhbHVlKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3RvciAtIHRoZSB2YWx1ZSBob2xkZXIgaXMgcmVxdWlyZWQuCi0JICogVXNlIHRoZSBmaXJzdCBpdGVtIGluIHRoZSBsaXN0IG9mIHZhbHVlcyBhcyB0aGUgZGVmYXVsdCBzcGlubmVyIHZhbHVlLgotCSAqLwotCXB1YmxpYyBMaXN0U3Bpbm5lck1vZGVsQWRhcHRlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IHZhbHVlSG9sZGVyLCBPYmplY3RbXSB2YWx1ZXMpIHsKLQkJdGhpcyh2YWx1ZUhvbGRlciwgdmFsdWVzLCB2YWx1ZXNbMF0pOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdG9yIC0gdGhlIHZhbHVlIGhvbGRlciBpcyByZXF1aXJlZC4KLQkgKi8KLQlwdWJsaWMgTGlzdFNwaW5uZXJNb2RlbEFkYXB0ZXIoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiB2YWx1ZUhvbGRlciwgT2JqZWN0W10gdmFsdWVzLCBPYmplY3QgZGVmYXVsdFZhbHVlKSB7Ci0JCXRoaXModmFsdWVIb2xkZXIsIEFycmF5cy5hc0xpc3QodmFsdWVzKSwgZGVmYXVsdFZhbHVlKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3RvciAtIHRoZSB2YWx1ZSBob2xkZXIgaXMgcmVxdWlyZWQuCi0JICogVXNlIHRoZSBmaXJzdCBpdGVtIGluIHRoZSBsaXN0IG9mIHZhbHVlcyBhcyB0aGUgZGVmYXVsdCBzcGlubmVyIHZhbHVlLgotCSAqLwotCXB1YmxpYyBMaXN0U3Bpbm5lck1vZGVsQWRhcHRlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IHZhbHVlSG9sZGVyLCBMaXN0PE9iamVjdD4gdmFsdWVzKSB7Ci0JCXRoaXModmFsdWVIb2xkZXIsIHZhbHVlcywgdmFsdWVzLmdldCgwKSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0b3IgLSB0aGUgdmFsdWUgaG9sZGVyIGlzIHJlcXVpcmVkLgotCSAqLwotCXB1YmxpYyBMaXN0U3Bpbm5lck1vZGVsQWRhcHRlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IHZhbHVlSG9sZGVyLCBMaXN0PE9iamVjdD4gdmFsdWVzLCBPYmplY3QgZGVmYXVsdFZhbHVlKSB7Ci0JCXN1cGVyKHZhbHVlcyk7Ci0JCXRoaXMudmFsdWVIb2xkZXIgPSB2YWx1ZUhvbGRlcjsKLQkJdGhpcy52YWx1ZUNoYW5nZUxpc3RlbmVyID0gdGhpcy5idWlsZFZhbHVlQ2hhbmdlTGlzdGVuZXIoKTsKLQkJLy8gcG9zdHBvbmUgbGlzdGVuaW5nIHRvIHRoZSB1bmRlcmx5aW5nIHZhbHVlCi0JCS8vIHVudGlsIHdlIGhhdmUgbGlzdGVuZXJzIG91cnNlbHZlcy4uLgotCQl0aGlzLmRlZmF1bHRWYWx1ZSA9IGRlZmF1bHRWYWx1ZTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JcHJvdGVjdGVkIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGRWYWx1ZUNoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IEFXVFByb3BlcnR5Q2hhbmdlTGlzdGVuZXJXcmFwcGVyKHRoaXMuYnVpbGRWYWx1ZUNoYW5nZUxpc3RlbmVyXygpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZFZhbHVlQ2hhbmdlTGlzdGVuZXJfKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCUxpc3RTcGlubmVyTW9kZWxBZGFwdGVyLnRoaXMuc3luY2hyb25pemUoZXZlbnQuZ2V0TmV3VmFsdWUoKSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJ2YWx1ZSBsaXN0ZW5lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIFNwaW5uZXJNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQkvKioKLQkgKiBFeHRlbmQgdG8gY2hlY2sgd2hldGhlciB0aGlzIG1ldGhvZCBpcyBiZWluZyBjYWxsZWQgYmVmb3JlIHdlIAotCSAqIGhhdmUgYW55IGxpc3RlbmVycy4KLQkgKiBUaGlzIGlzIG5lY2Vzc2FyeSBiZWNhdXNlIHNvbWUgY3JhcHB5IGpkayBjb2RlIGdldHMgdGhlIHZhbHVlCi0JICogZnJvbSB0aGUgbW9kZWwgKmJlZm9yZSogbGlzdGVuaW5nIHRvIHRoZSBtb2RlbC4gIH5ianYKLQkgKiBAc2VlIGphdmF4LnN3aW5nLkpTcGlubmVyLkRlZmF1bHRFZGl0b3IoamF2YXguc3dpbmcuSlNwaW5uZXIpCi0JICovCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIE9iamVjdCBnZXRWYWx1ZSgpIHsKLQkJaWYgKHRoaXMuZ2V0Q2hhbmdlTGlzdGVuZXJzKCkubGVuZ3RoID09IDApIHsKLQkJCS8vIHNvcnJ5IGFib3V0IHRoaXMgImxhdGVyYWwiIGNhbGwgdG8gc3VwZXIgIH5ianYKLQkJCXN1cGVyLnNldFZhbHVlKHRoaXMuc3Bpbm5lclZhbHVlT2YodGhpcy52YWx1ZUhvbGRlci5nZXRWYWx1ZSgpKSk7Ci0JCX0KLQkJcmV0dXJuIHN1cGVyLmdldFZhbHVlKCk7Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRvIHVwZGF0ZSB0aGUgdW5kZXJseWluZyB2YWx1ZSBkaXJlY3RseS4KLQkgKiBUaGUgcmVzdWx0aW5nIGV2ZW50IHdpbGwgYmUgaWdub3JlZDogQHNlZSAjc3luY2hyb25pemUoT2JqZWN0KS4KLQkgKi8KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBzZXRWYWx1ZShPYmplY3QgdmFsdWUpIHsKLQkJc3VwZXIuc2V0VmFsdWUodmFsdWUpOwotCQl0aGlzLnZhbHVlSG9sZGVyLnNldFZhbHVlKHZhbHVlKTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSB1bmRlcmx5aW5nIHZhbHVlIGlmIG5lY2Vzc2FyeS4KLQkgKi8KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBhZGRDaGFuZ2VMaXN0ZW5lcihDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQlpZiAodGhpcy5nZXRDaGFuZ2VMaXN0ZW5lcnMoKS5sZW5ndGggPT0gMCkgewotCQkJdGhpcy52YWx1ZUhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy52YWx1ZUNoYW5nZUxpc3RlbmVyKTsKLQkJCXRoaXMuc3luY2hyb25pemUodGhpcy52YWx1ZUhvbGRlci5nZXRWYWx1ZSgpKTsKLQkJfQotCQlzdXBlci5hZGRDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSB1bmRlcmx5aW5nIHZhbHVlIGlmIGFwcHJvcHJpYXRlLgotCSAqLwotICAgIEBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHJlbW92ZUNoYW5nZUxpc3RlbmVyKENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXN1cGVyLnJlbW92ZUNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJaWYgKHRoaXMuZ2V0Q2hhbmdlTGlzdGVuZXJzKCkubGVuZ3RoID09IDApIHsKLQkJCXRoaXMudmFsdWVIb2xkZXIucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMudmFsdWVDaGFuZ2VMaXN0ZW5lcik7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogcXVlcmllcyAqKioqKioqKioqCi0KLQlwcm90ZWN0ZWQgT2JqZWN0IGdldERlZmF1bHRWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMuZGVmYXVsdFZhbHVlOwotCX0KLQotCS8qKgotCSAqIENvbnZlcnQgdG8gYSBub24tbnVsbCB2YWx1ZS4KLQkgKi8KLQlwcm90ZWN0ZWQgT2JqZWN0IHNwaW5uZXJWYWx1ZU9mKE9iamVjdCB2YWx1ZSkgewotCQlyZXR1cm4gKHZhbHVlID09IG51bGwpID8gdGhpcy5nZXREZWZhdWx0VmFsdWUoKSA6IHZhbHVlOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBTZXQgdGhlIHNwaW5uZXIgdmFsdWUgaWYgaXQgaGFzIGNoYW5nZWQuCi0JICovCi0Jdm9pZCBzeW5jaHJvbml6ZShPYmplY3QgdmFsdWUpIHsKLQkJT2JqZWN0IG5ld1ZhbHVlID0gdGhpcy5zcGlubmVyVmFsdWVPZih2YWx1ZSk7Ci0JCS8vIGNoZWNrIHRvIHNlZSB3aGV0aGVyIHRoZSBzcGlubmVyIHZhbHVlIGhhcyBhbHJlYWR5IGJlZW4gc3luY2hyb25pemVkCi0JCS8vICh2aWEgI3NldFZhbHVlKCkpCi0JCWlmICggISB0aGlzLmdldFZhbHVlKCkuZXF1YWxzKG5ld1ZhbHVlKSkgewotCQkJdGhpcy5zZXRWYWx1ZShuZXdWYWx1ZSk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogc3RhbmRhcmQgbWV0aG9kcyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuYnVpbGRUb1N0cmluZ0Zvcih0aGlzLCB0aGlzLnZhbHVlSG9sZGVyKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9OdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvTnVtYmVyU3Bpbm5lck1vZGVsQWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0ODRmZjMzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9OdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyMjMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZzsKLQotaW1wb3J0IGphdmF4LnN3aW5nLlNwaW5uZXJOdW1iZXJNb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5saXN0ZW5lci5hd3QuQVdUUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcldyYXBwZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBUaGlzIGphdmF4LnN3aW5nLlNwaW5uZXJOdW1iZXJNb2RlbCBjYW4gYmUgdXNlZCB0byBrZWVwIGEgQ2hhbmdlTGlzdGVuZXIKLSAqIChlLmcuIGEgSlNwaW5uZXIpIGluIHN5bmNoIHdpdGggYSBQcm9wZXJ0eVZhbHVlTW9kZWwgdGhhdCBob2xkcyBhIG51bWJlci4KLSAqIAotICogVGhpcyBjbGFzcyBtdXN0IGJlIGEgc3ViLWNsYXNzIG9mIFNwaW5uZXJOdW1iZXJNb2RlbCBiZWNhdXNlIG9mIHNvbWUKLSAqIGNyYXBweSBqZGsgY29kZS4uLi4gIH5ianYKLSAqIEBzZWUgamF2YXguc3dpbmcuSlNwaW5uZXIjY3JlYXRlRWRpdG9yKGphdmF4LnN3aW5nLlNwaW5uZXJNb2RlbCkKLSAqIAotICogSWYgdGhpcyBjbGFzcyBuZWVkcyB0byBiZSBtb2RpZmllZCwgaXQgd291bGQgYmVob292ZSB1cyB0byByZXZpZXcgdGhlCi0gKiBvdGhlciwgc2ltaWxhciBjbGFzc2VzOgotICogQHNlZSBEYXRlU3Bpbm5lck1vZGVsQWRhcHRlcgotICogQHNlZSBMaXN0U3Bpbm5lck1vZGVsQWRhcHRlcgotICovCi1wdWJsaWMgY2xhc3MgTnVtYmVyU3Bpbm5lck1vZGVsQWRhcHRlcgotCWV4dGVuZHMgU3Bpbm5lck51bWJlck1vZGVsCi17Ci0KLQkvKioKLQkgKiBUaGUgZGVmYXVsdCBzcGlubmVyIHZhbHVlOyB1c2VkIHdoZW4gdGhlCi0JICogdW5kZXJseWluZyBtb2RlbCBudW1iZXIgdmFsdWUgaXMgbnVsbC4KLQkgKi8KLQlwcml2YXRlIGZpbmFsIE51bWJlciBkZWZhdWx0VmFsdWU7Ci0KLQkvKiogQSB2YWx1ZSBtb2RlbCBvbiB0aGUgdW5kZXJseWluZyBudW1iZXIuICovCi0JcHJpdmF0ZSBmaW5hbCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxOdW1iZXI+IG51bWJlckhvbGRlcjsKLQotCS8qKgotCSAqIEEgbGlzdGVuZXIgdGhhdCBhbGxvd3MgdXMgdG8gc3luY2hyb25pemUgd2l0aAotCSAqIGNoYW5nZXMgbWFkZSB0byB0aGUgdW5kZXJseWluZyBudW1iZXIuCi0JICovCi0JcHJpdmF0ZSBmaW5hbCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIG51bWJlckNoYW5nZUxpc3RlbmVyOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3RvciAtIHRoZSBudW1iZXIgaG9sZGVyIGlzIHJlcXVpcmVkLgotCSAqIFRoZSBkZWZhdWx0IHNwaW5uZXIgdmFsdWUgaXMgemVyby4KLQkgKiBUaGUgc3RlcCBzaXplIGlzIG9uZS4KLQkgKi8KLQlwdWJsaWMgTnVtYmVyU3Bpbm5lck1vZGVsQWRhcHRlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxOdW1iZXI+IG51bWJlckhvbGRlcikgewotCQl0aGlzKG51bWJlckhvbGRlciwgMCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0b3IgLSB0aGUgbnVtYmVyIGhvbGRlciBpcyByZXF1aXJlZC4KLQkgKiBUaGUgc3RlcCBzaXplIGlzIG9uZS4KLQkgKi8KLQlwdWJsaWMgTnVtYmVyU3Bpbm5lck1vZGVsQWRhcHRlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxOdW1iZXI+IG51bWJlckhvbGRlciwgaW50IGRlZmF1bHRWYWx1ZSkgewotCQl0aGlzKG51bWJlckhvbGRlciwgbnVsbCwgbnVsbCwgbmV3IEludGVnZXIoMSksIG5ldyBJbnRlZ2VyKGRlZmF1bHRWYWx1ZSkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdG9yIC0gdGhlIG51bWJlciBob2xkZXIgaXMgcmVxdWlyZWQuCi0JICogVXNlIHRoZSBtaW5pbXVtIHZhbHVlIGFzIHRoZSBkZWZhdWx0IHNwaW5uZXIgdmFsdWUuCi0JICovCi0JcHVibGljIE51bWJlclNwaW5uZXJNb2RlbEFkYXB0ZXIoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8TnVtYmVyPiBudW1iZXJIb2xkZXIsIGludCBtaW5pbXVtLCBpbnQgbWF4aW11bSwgaW50IHN0ZXBTaXplKSB7Ci0JCXRoaXMobnVtYmVySG9sZGVyLCBtaW5pbXVtLCBtYXhpbXVtLCBzdGVwU2l6ZSwgbWluaW11bSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0b3IgLSB0aGUgbnVtYmVyIGhvbGRlciBpcyByZXF1aXJlZC4KLQkgKi8KLQlwdWJsaWMgTnVtYmVyU3Bpbm5lck1vZGVsQWRhcHRlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxOdW1iZXI+IG51bWJlckhvbGRlciwgaW50IG1pbmltdW0sIGludCBtYXhpbXVtLCBpbnQgc3RlcFNpemUsIGludCBkZWZhdWx0VmFsdWUpIHsKLQkJdGhpcyhudW1iZXJIb2xkZXIsIG5ldyBJbnRlZ2VyKG1pbmltdW0pLCBuZXcgSW50ZWdlcihtYXhpbXVtKSwgbmV3IEludGVnZXIoc3RlcFNpemUpLCBuZXcgSW50ZWdlcihkZWZhdWx0VmFsdWUpKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3RvciAtIHRoZSBudW1iZXIgaG9sZGVyIGlzIHJlcXVpcmVkLgotCSAqIFVzZSB0aGUgbWluaW11bSB2YWx1ZSBhcyB0aGUgZGVmYXVsdCBzcGlubmVyIHZhbHVlLgotCSAqLwotCXB1YmxpYyBOdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE51bWJlcj4gbnVtYmVySG9sZGVyLCBkb3VibGUgdmFsdWUsIGRvdWJsZSBtaW5pbXVtLCBkb3VibGUgbWF4aW11bSwgZG91YmxlIHN0ZXBTaXplKSB7Ci0JCXRoaXMobnVtYmVySG9sZGVyLCB2YWx1ZSwgbWluaW11bSwgbWF4aW11bSwgc3RlcFNpemUsIG1pbmltdW0pOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdG9yIC0gdGhlIG51bWJlciBob2xkZXIgaXMgcmVxdWlyZWQuCi0JICovCi0JcHVibGljIE51bWJlclNwaW5uZXJNb2RlbEFkYXB0ZXIoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8TnVtYmVyPiBudW1iZXJIb2xkZXIsIGRvdWJsZSB2YWx1ZSwgZG91YmxlIG1pbmltdW0sIGRvdWJsZSBtYXhpbXVtLCBkb3VibGUgc3RlcFNpemUsIGRvdWJsZSBkZWZhdWx0VmFsdWUpIHsKLQkJdGhpcyhudW1iZXJIb2xkZXIsIG5ldyBEb3VibGUobWluaW11bSksIG5ldyBEb3VibGUobWF4aW11bSksIG5ldyBEb3VibGUoc3RlcFNpemUpLCBuZXcgRG91YmxlKGRlZmF1bHRWYWx1ZSkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdG9yIC0gdGhlIG51bWJlciBob2xkZXIgaXMgcmVxdWlyZWQuCi0JICovCi0JcHVibGljIE51bWJlclNwaW5uZXJNb2RlbEFkYXB0ZXIoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8TnVtYmVyPiBudW1iZXJIb2xkZXIsIENvbXBhcmFibGU8Pz4gbWluaW11bSwgQ29tcGFyYWJsZTw/PiBtYXhpbXVtLCBOdW1iZXIgc3RlcFNpemUsIE51bWJlciBkZWZhdWx0VmFsdWUpIHsKLQkJc3VwZXIobnVtYmVySG9sZGVyLmdldFZhbHVlKCkgPT0gbnVsbCA/IGRlZmF1bHRWYWx1ZSA6IChOdW1iZXIpIG51bWJlckhvbGRlci5nZXRWYWx1ZSgpLCBtaW5pbXVtLCBtYXhpbXVtLCBzdGVwU2l6ZSk7Ci0JCXRoaXMubnVtYmVySG9sZGVyID0gbnVtYmVySG9sZGVyOwotCQl0aGlzLm51bWJlckNoYW5nZUxpc3RlbmVyID0gdGhpcy5idWlsZE51bWJlckNoYW5nZUxpc3RlbmVyKCk7Ci0JCS8vIHBvc3Rwb25lIGxpc3RlbmluZyB0byB0aGUgdW5kZXJseWluZyBudW1iZXIKLQkJLy8gdW50aWwgd2UgaGF2ZSBsaXN0ZW5lcnMgb3Vyc2VsdmVzLi4uCi0JCXRoaXMuZGVmYXVsdFZhbHVlID0gZGVmYXVsdFZhbHVlOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0KLQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZE51bWJlckNoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IEFXVFByb3BlcnR5Q2hhbmdlTGlzdGVuZXJXcmFwcGVyKHRoaXMuYnVpbGROdW1iZXJDaGFuZ2VMaXN0ZW5lcl8oKSk7Ci0JfQotCi0JcHJvdGVjdGVkIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGROdW1iZXJDaGFuZ2VMaXN0ZW5lcl8oKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJTnVtYmVyU3Bpbm5lck1vZGVsQWRhcHRlci50aGlzLnN5bmNocm9uaXplKGV2ZW50LmdldE5ld1ZhbHVlKCkpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAibnVtYmVyIGxpc3RlbmVyIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogU3Bpbm5lck1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIEV4dGVuZCB0byBjaGVjayB3aGV0aGVyIHRoaXMgbWV0aG9kIGlzIGJlaW5nIGNhbGxlZCBiZWZvcmUgd2UgCi0JICogaGF2ZSBhbnkgbGlzdGVuZXJzLgotCSAqIFRoaXMgaXMgbmVjZXNzYXJ5IGJlY2F1c2Ugc29tZSBjcmFwcHkgamRrIGNvZGUgZ2V0cyB0aGUgdmFsdWUKLQkgKiBmcm9tIHRoZSBtb2RlbCAqYmVmb3JlKiBsaXN0ZW5pbmcgdG8gdGhlIG1vZGVsLiAgfmJqdgotCSAqIEBzZWUgamF2YXguc3dpbmcuSlNwaW5uZXIuRGVmYXVsdEVkaXRvcihqYXZheC5zd2luZy5KU3Bpbm5lcikKLQkgKi8KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgT2JqZWN0IGdldFZhbHVlKCkgewotCQlpZiAodGhpcy5nZXRDaGFuZ2VMaXN0ZW5lcnMoKS5sZW5ndGggPT0gMCkgewotCQkJLy8gc29ycnkgYWJvdXQgdGhpcyAibGF0ZXJhbCIgY2FsbCB0byBzdXBlciAgfmJqdgotCQkJc3VwZXIuc2V0VmFsdWUodGhpcy5zcGlubmVyVmFsdWVPZih0aGlzLm51bWJlckhvbGRlci5nZXRWYWx1ZSgpKSk7Ci0JCX0KLQkJcmV0dXJuIHN1cGVyLmdldFZhbHVlKCk7Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRvIHVwZGF0ZSB0aGUgdW5kZXJseWluZyBudW1iZXIgZGlyZWN0bHkuCi0JICogVGhlIHJlc3VsdGluZyBldmVudCB3aWxsIGJlIGlnbm9yZWQ6IEBzZWUgI3N5bmNocm9uaXplRGVsZWdhdGUoT2JqZWN0KS4KLQkgKi8KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBzZXRWYWx1ZShPYmplY3QgdmFsdWUpIHsKLQkJc3VwZXIuc2V0VmFsdWUodmFsdWUpOwotCQl0aGlzLm51bWJlckhvbGRlci5zZXRWYWx1ZSgoTnVtYmVyKSB2YWx1ZSk7Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0YXJ0IGxpc3RlbmluZyB0byB0aGUgdW5kZXJseWluZyBudW1iZXIgaWYgbmVjZXNzYXJ5LgotCSAqLwotICAgIEBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGFkZENoYW5nZUxpc3RlbmVyKENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCWlmICh0aGlzLmdldENoYW5nZUxpc3RlbmVycygpLmxlbmd0aCA9PSAwKSB7Ci0JCQl0aGlzLm51bWJlckhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5udW1iZXJDaGFuZ2VMaXN0ZW5lcik7Ci0JCQl0aGlzLnN5bmNocm9uaXplKHRoaXMubnVtYmVySG9sZGVyLmdldFZhbHVlKCkpOwotCQl9Ci0JCXN1cGVyLmFkZENoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RvcCBsaXN0ZW5pbmcgdG8gdGhlIHVuZGVybHlpbmcgbnVtYmVyIGlmIGFwcHJvcHJpYXRlLgotCSAqLwotICAgIEBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHJlbW92ZUNoYW5nZUxpc3RlbmVyKENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXN1cGVyLnJlbW92ZUNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJaWYgKHRoaXMuZ2V0Q2hhbmdlTGlzdGVuZXJzKCkubGVuZ3RoID09IDApIHsKLQkJCXRoaXMubnVtYmVySG9sZGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLm51bWJlckNoYW5nZUxpc3RlbmVyKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBxdWVyaWVzICoqKioqKioqKioKLQotCXByb3RlY3RlZCBOdW1iZXIgZ2V0RGVmYXVsdFZhbHVlKCkgewotCQlyZXR1cm4gdGhpcy5kZWZhdWx0VmFsdWU7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0byBhIG5vbi1udWxsIHZhbHVlLgotCSAqLwotCXByb3RlY3RlZCBPYmplY3Qgc3Bpbm5lclZhbHVlT2YoT2JqZWN0IHZhbHVlKSB7Ci0JCXJldHVybiAodmFsdWUgPT0gbnVsbCkgPyB0aGlzLmdldERlZmF1bHRWYWx1ZSgpIDogdmFsdWU7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCS8qKgotCSAqIFNldCB0aGUgc3Bpbm5lciB2YWx1ZSBpZiBpdCBoYXMgY2hhbmdlZC4KLQkgKi8KLQl2b2lkIHN5bmNocm9uaXplKE9iamVjdCB2YWx1ZSkgewotCQlPYmplY3QgbmV3VmFsdWUgPSB0aGlzLnNwaW5uZXJWYWx1ZU9mKHZhbHVlKTsKLQkJLy8gY2hlY2sgdG8gc2VlIHdoZXRoZXIgdGhlIGRhdGUgaGFzIGFscmVhZHkgYmVlbiBzeW5jaHJvbml6ZWQKLQkJLy8gKHZpYSAjc2V0VmFsdWUoKSkKLQkJaWYgKCAhIHRoaXMuZ2V0VmFsdWUoKS5lcXVhbHMobmV3VmFsdWUpKSB7Ci0JCQl0aGlzLnNldFZhbHVlKG5ld1ZhbHVlKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBzdGFuZGFyZCBtZXRob2RzICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMubnVtYmVySG9sZGVyKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9PYmplY3RMaXN0U2VsZWN0aW9uTW9kZWwuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9PYmplY3RMaXN0U2VsZWN0aW9uTW9kZWwuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjFkMmUzNy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0MjcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5czsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YXguc3dpbmcuRGVmYXVsdExpc3RTZWxlY3Rpb25Nb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy5MaXN0TW9kZWw7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuTGlzdERhdGFFdmVudDsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5MaXN0RGF0YUxpc3RlbmVyOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50Lkxpc3RTZWxlY3Rpb25MaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci0KLS8qKgotICogVGhpcyBMaXN0U2VsZWN0aW9uTW9kZWwgaXMgYXdhcmUgb2YgdGhlIExpc3RNb2RlbCBhbmQKLSAqIHByb3ZpZGVzIGNvbnZlbmllbmNlIG1ldGhvZHMgdG8gYWNjZXNzIGFuZCBzZXQgdGhlCi0gKiBzZWxlY3RlZCAqb2JqZWN0cyosIGFzIG9wcG9zZWQgdG8gdGhlIHNlbGVjdGVkICppbmRleGVzKi4KLSAqLwotcHVibGljIGNsYXNzIE9iamVjdExpc3RTZWxlY3Rpb25Nb2RlbAotCWV4dGVuZHMgRGVmYXVsdExpc3RTZWxlY3Rpb25Nb2RlbAotewotCS8qKiBUaGUgbGlzdCBtb2RlbCByZWZlcmVuY2VkIGJ5IHRoZSBsaXN0IHNlbGVjdGlvbiBtb2RlbC4gKi8KLQlwcml2YXRlIGZpbmFsIExpc3RNb2RlbCBsaXN0TW9kZWw7Ci0KLQkvKiogQSBsaXN0ZW5lciB0aGF0IGFsbG93cyB1cyB0byBjbGVhciB0aGUgc2VsZWN0aW9uIHdoZW4gdGhlIGxpc3QgbW9kZWwgaGFzIGNoYW5nZWQuICovCi0JcHJpdmF0ZSBmaW5hbCBMaXN0RGF0YUxpc3RlbmVyIGxpc3REYXRhTGlzdGVuZXI7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGxpc3Qgc2VsZWN0aW9uIG1vZGVsIGZvciB0aGUgc3BlY2lmaWVkIGxpc3QgbW9kZWwuCi0JICovCi0JcHVibGljIE9iamVjdExpc3RTZWxlY3Rpb25Nb2RlbChMaXN0TW9kZWwgbGlzdE1vZGVsKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMubGlzdE1vZGVsID0gbGlzdE1vZGVsOwotCQl0aGlzLmxpc3REYXRhTGlzdGVuZXIgPSB0aGlzLmJ1aWxkTGlzdERhdGFMaXN0ZW5lcigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0KLQlwcml2YXRlIExpc3REYXRhTGlzdGVuZXIgYnVpbGRMaXN0RGF0YUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IExpc3REYXRhTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBpbnRlcnZhbEFkZGVkKExpc3REYXRhRXZlbnQgZXZlbnQpIHsKLQkJCQkvLyB0aGlzIGRvZXMgbm90IGFmZmVjdCB0aGUgc2VsZWN0aW9uCi0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpbnRlcnZhbFJlbW92ZWQoTGlzdERhdGFFdmVudCBldmVudCkgewotCQkJCS8vIHRoaXMgZG9lcyBub3QgYWZmZWN0IHRoZSBzZWxlY3Rpb24KLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGNvbnRlbnRzQ2hhbmdlZChMaXN0RGF0YUV2ZW50IGV2ZW50KSB7Ci0JCQkJT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsLnRoaXMubGlzdE1vZGVsQ29udGVudHNDaGFuZ2VkKGV2ZW50KTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gImxpc3QgZGF0YSBsaXN0ZW5lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JLyoqCi0JICogVHlwaWNhbGx5LCB0aGUgc2VsZWN0aW9uIGRvZXMgbm90IG5lZWQgdG8gYmUgY2xlYXJlZCB3aGVuIHRoZQotCSAqIGNvbnRlbnRzIG9mIHRoZSBsaXN0IGhhdmUgY2hhbmdlZC4gTW9zdCBvZiB0aGUgdGltZSB0aGlzIGp1c3QKLQkgKiBtZWFucyBhbiBpdGVtIGhhcyBjaGFuZ2VkIGluIGEgd2F5IHRoYXQgYWZmZWN0cyBpdHMgZGlzcGxheSBzdHJpbmcKLQkgKiBvciBpY29uLiBXZSB0eXBpY2FsbHkgb25seSB1c2UgdGhlIGNsYXNzIGZvciBlZGl0cyBpbnZvbHZpbmcKLQkgKiBzaW5nbGUgc2VsZWN0aW9uLgotCSAqIEEgc3ViY2xhc3MgY2FuIG92ZXJyaWRlIHRoaXMgbWV0aG9kIGlmIHRoZSBzZWxlY3Rpb24KLQkgKiBzaG91bGQgYmUgY2xlYXJlZCBiZWNhdXNlIGEgY2hhbmdlIGNvdWxkIG1lYW4gdGhlIHNlbGVjdGlvbiBpcyBpbnZhbGlkLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGxpc3RNb2RlbENvbnRlbnRzQ2hhbmdlZChMaXN0RGF0YUV2ZW50IGV2ZW50KSB7Ci0JCS8qKnRoaXMuY2xlYXJTZWxlY3Rpb24oKTsqLwotCX0KLQotCi0JLy8gKioqKioqKioqKiBMaXN0U2VsZWN0aW9uTW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgYWRkTGlzdFNlbGVjdGlvbkxpc3RlbmVyKExpc3RTZWxlY3Rpb25MaXN0ZW5lciBsKSB7Ci0JCWlmICh0aGlzLmhhc05vTGlzdFNlbGVjdGlvbkxpc3RlbmVycygpKSB7Ci0JCQl0aGlzLmxpc3RNb2RlbC5hZGRMaXN0RGF0YUxpc3RlbmVyKHRoaXMubGlzdERhdGFMaXN0ZW5lcik7Ci0JCX0KLQkJc3VwZXIuYWRkTGlzdFNlbGVjdGlvbkxpc3RlbmVyKGwpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHJlbW92ZUxpc3RTZWxlY3Rpb25MaXN0ZW5lcihMaXN0U2VsZWN0aW9uTGlzdGVuZXIgbCkgewotCQlzdXBlci5yZW1vdmVMaXN0U2VsZWN0aW9uTGlzdGVuZXIobCk7Ci0JCWlmICh0aGlzLmhhc05vTGlzdFNlbGVjdGlvbkxpc3RlbmVycygpKSB7Ci0JCQl0aGlzLmxpc3RNb2RlbC5yZW1vdmVMaXN0RGF0YUxpc3RlbmVyKHRoaXMubGlzdERhdGFMaXN0ZW5lcik7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogcXVlcmllcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGlzIG1vZGVsIGhhcyBubyBsaXN0ZW5lcnMuCi0JICovCi0JcHJvdGVjdGVkIGJvb2xlYW4gaGFzTm9MaXN0U2VsZWN0aW9uTGlzdGVuZXJzKCkgewkvLyBwcml2YXRlLXByb3RlY3RlZAotCQlyZXR1cm4gdGhpcy5nZXRMaXN0U2VsZWN0aW9uTGlzdGVuZXJzKCkubGVuZ3RoID09IDA7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBsaXN0IG1vZGVsIHJlZmVyZW5jZWQgYnkgdGhlIGxpc3Qgc2VsZWN0aW9uIG1vZGVsLgotCSAqLwotCXB1YmxpYyBMaXN0TW9kZWwgZ2V0TGlzdE1vZGVsKCkgewotCQlyZXR1cm4gdGhpcy5saXN0TW9kZWw7Ci0JfQotCi0JcHVibGljIGludCBzZWxlY3RlZFZhbHVlc1NpemUoKSB7Ci0JCWludCBtaW4gPSB0aGlzLmdldE1pblNlbGVjdGlvbkluZGV4KCk7Ci0JCWludCBtYXggPSB0aGlzLmdldE1heFNlbGVjdGlvbkluZGV4KCk7Ci0KLQkJaWYgKChtaW4gPCAwKSB8fCAobWF4IDwgMCkpIHsKLQkJCXJldHVybiAwOwotCQl9Ci0KLQkJaW50IG4gPSAwOwotCQlpbnQgY291bnQgPSB0aGlzLmdldExpc3RNb2RlbCgpLmdldFNpemUoKTsKLQkJZm9yIChpbnQgaSA9IG1pbjsgaSA8PSBtYXg7IGkrKykgewotCQkJaWYgKHRoaXMuaXNTZWxlY3RlZEluZGV4KGkpICYmIChpIDwgY291bnQpKSB7Ci0JCQkJbisrOwotCQkJfQotCQl9Ci0JCXJldHVybiBuOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgZmlyc3Qgc2VsZWN0ZWQgdmFsdWUuCi0JICogUmV0dXJuIG51bGwgaWYgdGhlIHNlbGVjdGlvbiBpcyBlbXB0eS4KLQkgKi8KLQlwdWJsaWMgT2JqZWN0IHNlbGVjdGVkVmFsdWUoKSB7Ci0JCWludCBpbmRleCA9IHRoaXMuZ2V0TWluU2VsZWN0aW9uSW5kZXgoKTsKLQkJaWYgKGluZGV4ID09IC0xKSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQlpZiAodGhpcy5nZXRMaXN0TW9kZWwoKS5nZXRTaXplKCkgPD0gaW5kZXgpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCXJldHVybiB0aGlzLmdldExpc3RNb2RlbCgpLmdldEVsZW1lbnRBdChpbmRleCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGFuIGFycmF5IG9mIHRoZSBzZWxlY3RlZCB2YWx1ZXMuCi0JICovCi0JcHVibGljIE9iamVjdFtdIHNlbGVjdGVkVmFsdWVzKCkgewotCQlpbnQgbWluID0gdGhpcy5nZXRNaW5TZWxlY3Rpb25JbmRleCgpOwotCQlpbnQgbWF4ID0gdGhpcy5nZXRNYXhTZWxlY3Rpb25JbmRleCgpOwotCi0JCWlmICgobWluIDwgMCkgfHwgKG1heCA8IDApKSB7Ci0JCQlyZXR1cm4gbmV3IE9iamVjdFswXTsKLQkJfQotCi0JCWludCBtYXhTaXplID0gKG1heCAtIG1pbikgKyAxOwotCQlPYmplY3RbXSB0ZW1wID0gbmV3IE9iamVjdFttYXhTaXplXTsKLQkJaW50IG4gPSAwOwotCQlpbnQgY291bnQgPSB0aGlzLmdldExpc3RNb2RlbCgpLmdldFNpemUoKTsKLQkJZm9yIChpbnQgaSA9IG1pbjsgaSA8PSBtYXg7IGkrKykgewotCQkJaWYgKHRoaXMuaXNTZWxlY3RlZEluZGV4KGkpICYmIChpIDwgY291bnQpKSB7Ci0JCQkJdGVtcFtuKytdID0gdGhpcy5nZXRMaXN0TW9kZWwoKS5nZXRFbGVtZW50QXQoaSk7Ci0JCQl9Ci0JCX0KLQkJaWYgKG4gPT0gbWF4U2l6ZSkgewotCQkJLy8gYWxsIHRoZSBlbGVtZW50cyBpbiB0aGUgcmFuZ2Ugd2VyZSBzZWxlY3RlZAotCQkJcmV0dXJuIHRlbXA7Ci0JCX0KLQkJLy8gb25seSBzb21lIG9mIHRoZSBlbGVtZW50cyBpbiB0aGUgcmFuZ2Ugd2VyZSBzZWxlY3RlZAotCQlPYmplY3RbXSByZXN1bHQgPSBuZXcgT2JqZWN0W25dOwotCQlTeXN0ZW0uYXJyYXljb3B5KHRlbXAsIDAsIHJlc3VsdCwgMCwgbik7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGFuIGFycmF5IG9mIHRoZSBzZWxlY3RlZCBpbmRpY2VzIGluIG9yZGVyLgotCSAqLwotCXB1YmxpYyBpbnRbXSBzZWxlY3RlZEluZGljZXMoKSB7Ci0JCWludCBtaW4gPSB0aGlzLmdldE1pblNlbGVjdGlvbkluZGV4KCk7Ci0JCWludCBtYXggPSB0aGlzLmdldE1heFNlbGVjdGlvbkluZGV4KCk7Ci0KLQkJaWYgKChtaW4gPCAwKSB8fCAobWF4IDwgMCkpIHsKLQkJCXJldHVybiBuZXcgaW50WzBdOwotCQl9Ci0KLQkJaW50IG1heFNpemUgPSAobWF4IC0gbWluKSArIDE7Ci0JCWludFtdIHRlbXAgPSBuZXcgaW50W21heFNpemVdOwotCQlpbnQgbiA9IDA7Ci0JCWludCBjb3VudCA9IHRoaXMuZ2V0TGlzdE1vZGVsKCkuZ2V0U2l6ZSgpOwotCQlmb3IgKGludCBpID0gbWluOyBpIDw9IG1heDsgaSsrKSB7Ci0JCQlpZiAodGhpcy5pc1NlbGVjdGVkSW5kZXgoaSkgJiYgKGkgPCBjb3VudCkpIHsKLQkJCQl0ZW1wW24rK10gPSBpOwotCQkJfQotCQl9Ci0JCWlmIChuID09IG1heFNpemUpIHsKLQkJCS8vIGFsbCB0aGUgZWxlbWVudHMgaW4gdGhlIHJhbmdlIHdlcmUgc2VsZWN0ZWQKLQkJCUFycmF5cy5zb3J0KHRlbXApOwotCQkJcmV0dXJuIHRlbXA7Ci0JCX0KLQkJLy8gb25seSBzb21lIG9mIHRoZSBlbGVtZW50cyBpbiB0aGUgcmFuZ2Ugd2VyZSBzZWxlY3RlZAotCQlpbnRbXSByZXN1bHQgPSBuZXcgaW50W25dOwotCQlTeXN0ZW0uYXJyYXljb3B5KHRlbXAsIDAsIHJlc3VsdCwgMCwgbik7Ci0JCUFycmF5cy5zb3J0KHJlc3VsdCk7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSBzZWxlY3RlZCB2YWx1ZS4KLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRTZWxlY3RlZFZhbHVlKE9iamVjdCBvYmplY3QpIHsKLQkJdGhpcy5zZXRTZWxlY3RlZFZhbHVlcyhDb2xsZWN0aW9uVG9vbHMuc2luZ2xldG9uSXRlcmF0b3Iob2JqZWN0KSk7Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSBjdXJyZW50IHNldCBvZiBzZWxlY3RlZCBvYmplY3RzIHRvIHRoZSBzcGVjaWZpZWQgb2JqZWN0cy4KLQkgKiBAc2VlIGphdmF4LnN3aW5nLkxpc3RTZWxlY3Rpb25Nb2RlbCNzZXRTZWxlY3Rpb25JbnRlcnZhbChpbnQsIGludCkKLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRTZWxlY3RlZFZhbHVlcyhJdGVyYXRvcjw/PiBvYmplY3RzKSB7Ci0JCXRoaXMuc2V0VmFsdWVJc0FkanVzdGluZyh0cnVlKTsKLQkJdGhpcy5jbGVhclNlbGVjdGlvbigpOwotCQl0aGlzLmFkZFNlbGVjdGVkVmFsdWVzSW50ZXJuYWwob2JqZWN0cyk7Ci0JCXRoaXMuc2V0VmFsdWVJc0FkanVzdGluZyhmYWxzZSk7Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSBjdXJyZW50IHNldCBvZiBzZWxlY3RlZCBvYmplY3RzIHRvIHRoZSBzcGVjaWZpZWQgb2JqZWN0cy4KLQkgKiBAc2VlIGphdmF4LnN3aW5nLkxpc3RTZWxlY3Rpb25Nb2RlbCNzZXRTZWxlY3Rpb25JbnRlcnZhbChpbnQsIGludCkKLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRTZWxlY3RlZFZhbHVlcyhDb2xsZWN0aW9uPD8+IG9iamVjdHMpIHsKLQkJdGhpcy5zZXRTZWxlY3RlZFZhbHVlcyhvYmplY3RzLml0ZXJhdG9yKCkpOwotCX0KLQotCS8qKgotCSAqIFNldCB0aGUgY3VycmVudCBzZXQgb2Ygc2VsZWN0ZWQgb2JqZWN0cyB0byB0aGUgc3BlY2lmaWVkIG9iamVjdHMuCi0JICogQHNlZSBqYXZheC5zd2luZy5MaXN0U2VsZWN0aW9uTW9kZWwjc2V0U2VsZWN0aW9uSW50ZXJ2YWwoaW50LCBpbnQpCi0JICovCi0JcHVibGljIHZvaWQgc2V0U2VsZWN0ZWRWYWx1ZXMoT2JqZWN0W10gb2JqZWN0cykgewotCQl0aGlzLnNldFNlbGVjdGVkVmFsdWVzKENvbGxlY3Rpb25Ub29scy5pdGVyYXRvcihvYmplY3RzKSk7Ci0JfQotCi0JLyoqCi0JICogQWRkIHRoZSBzcGVjaWZpZWQgb2JqZWN0IHRvIHRoZSBjdXJyZW50IHNldCBvZiBzZWxlY3RlZCBvYmplY3RzLgotCSAqIEBzZWUgamF2YXguc3dpbmcuTGlzdFNlbGVjdGlvbk1vZGVsI2FkZFNlbGVjdGlvbkludGVydmFsKGludCwgaW50KQotCSAqLwotCXB1YmxpYyB2b2lkIGFkZFNlbGVjdGVkVmFsdWUoT2JqZWN0IG9iamVjdCkgewotCQl0aGlzLmFkZFNlbGVjdGVkVmFsdWVzKENvbGxlY3Rpb25Ub29scy5zaW5nbGV0b25JdGVyYXRvcihvYmplY3QpKTsKLQl9Ci0KLQkvKioKLQkgKiBBZGQgdGhlIHNwZWNpZmllZCBvYmplY3RzIHRvIHRoZSBjdXJyZW50IHNldCBvZiBzZWxlY3RlZCBvYmplY3RzLgotCSAqIEBzZWUgamF2YXguc3dpbmcuTGlzdFNlbGVjdGlvbk1vZGVsI2FkZFNlbGVjdGlvbkludGVydmFsKGludCwgaW50KQotCSAqLwotCXB1YmxpYyB2b2lkIGFkZFNlbGVjdGVkVmFsdWVzKEl0ZXJhdG9yPD8+IG9iamVjdHMpIHsKLQkJdGhpcy5zZXRWYWx1ZUlzQWRqdXN0aW5nKHRydWUpOwotCQl0aGlzLmFkZFNlbGVjdGVkVmFsdWVzSW50ZXJuYWwob2JqZWN0cyk7Ci0JCXRoaXMuc2V0VmFsdWVJc0FkanVzdGluZyhmYWxzZSk7Ci0JfQotCi0JLyoqCi0JICogQWRkIHRoZSBzcGVjaWZpZWQgb2JqZWN0cyB0byB0aGUgY3VycmVudCBzZXQgb2Ygc2VsZWN0ZWQgb2JqZWN0cy4KLQkgKiBAc2VlIGphdmF4LnN3aW5nLkxpc3RTZWxlY3Rpb25Nb2RlbCNhZGRTZWxlY3Rpb25JbnRlcnZhbChpbnQsIGludCkKLQkgKi8KLQlwdWJsaWMgdm9pZCBhZGRTZWxlY3RlZFZhbHVlcyhDb2xsZWN0aW9uPD8+IG9iamVjdHMpIHsKLQkJdGhpcy5hZGRTZWxlY3RlZFZhbHVlcyhvYmplY3RzLml0ZXJhdG9yKCkpOwotCX0KLQotCS8qKgotCSAqIEFkZCB0aGUgc3BlY2lmaWVkIG9iamVjdHMgdG8gdGhlIGN1cnJlbnQgc2V0IG9mIHNlbGVjdGVkIG9iamVjdHMuCi0JICogQHNlZSBqYXZheC5zd2luZy5MaXN0U2VsZWN0aW9uTW9kZWwjYWRkU2VsZWN0aW9uSW50ZXJ2YWwoaW50LCBpbnQpCi0JICovCi0JcHVibGljIHZvaWQgYWRkU2VsZWN0ZWRWYWx1ZXMoT2JqZWN0W10gb2JqZWN0cykgewotCQl0aGlzLmFkZFNlbGVjdGVkVmFsdWVzKENvbGxlY3Rpb25Ub29scy5pdGVyYXRvcihvYmplY3RzKSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgb2JqZWN0IGZyb20gdGhlIGN1cnJlbnQgc2V0IG9mIHNlbGVjdGVkIG9iamVjdHMuCi0JICogQHNlZSBqYXZheC5zd2luZy5MaXN0U2VsZWN0aW9uTW9kZWwjcmVtb3ZlU2VsZWN0aW9uSW50ZXJ2YWwoaW50LCBpbnQpCi0JICovCi0JcHVibGljIHZvaWQgcmVtb3ZlU2VsZWN0ZWRWYWx1ZShPYmplY3Qgb2JqZWN0KSB7Ci0JCXRoaXMucmVtb3ZlU2VsZWN0ZWRWYWx1ZXMoQ29sbGVjdGlvblRvb2xzLnNpbmdsZXRvbkl0ZXJhdG9yKG9iamVjdCkpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSB0aGUgc3BlY2lmaWVkIG9iamVjdHMgZnJvbSB0aGUgY3VycmVudCBzZXQgb2Ygc2VsZWN0ZWQgb2JqZWN0cy4KLQkgKiBAc2VlIGphdmF4LnN3aW5nLkxpc3RTZWxlY3Rpb25Nb2RlbCNyZW1vdmVTZWxlY3Rpb25JbnRlcnZhbChpbnQsIGludCkKLQkgKi8KLQlwdWJsaWMgdm9pZCByZW1vdmVTZWxlY3RlZFZhbHVlcyhJdGVyYXRvcjw/PiBvYmplY3RzKSB7Ci0JCXRoaXMuc2V0VmFsdWVJc0FkanVzdGluZyh0cnVlKTsKLQkJTGlzdE1vZGVsIGxtID0gdGhpcy5nZXRMaXN0TW9kZWwoKTsKLQkJaW50IGxtU2l6ZSA9IGxtLmdldFNpemUoKTsKLQkJd2hpbGUgKG9iamVjdHMuaGFzTmV4dCgpKSB7Ci0JCQlpbnQgaW5kZXggPSB0aGlzLmluZGV4T2Yob2JqZWN0cy5uZXh0KCksIGxtLCBsbVNpemUpOwotCQkJdGhpcy5yZW1vdmVTZWxlY3Rpb25JbnRlcnZhbChpbmRleCwgaW5kZXgpOwotCQl9Ci0JCXRoaXMuc2V0VmFsdWVJc0FkanVzdGluZyhmYWxzZSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgb2JqZWN0cyBmcm9tIHRoZSBjdXJyZW50IHNldCBvZiBzZWxlY3RlZCBvYmplY3RzLgotCSAqIEBzZWUgamF2YXguc3dpbmcuTGlzdFNlbGVjdGlvbk1vZGVsI3JlbW92ZVNlbGVjdGlvbkludGVydmFsKGludCwgaW50KQotCSAqLwotCXB1YmxpYyB2b2lkIHJlbW92ZVNlbGVjdGVkVmFsdWVzKENvbGxlY3Rpb248Pz4gb2JqZWN0cykgewotCQl0aGlzLnJlbW92ZVNlbGVjdGVkVmFsdWVzKG9iamVjdHMuaXRlcmF0b3IoKSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgb2JqZWN0cyBmcm9tIHRoZSBjdXJyZW50IHNldCBvZiBzZWxlY3RlZCBvYmplY3RzLgotCSAqIEBzZWUgamF2YXguc3dpbmcuTGlzdFNlbGVjdGlvbk1vZGVsI3JlbW92ZVNlbGVjdGlvbkludGVydmFsKGludCwgaW50KQotCSAqLwotCXB1YmxpYyB2b2lkIHJlbW92ZVNlbGVjdGVkVmFsdWVzKE9iamVjdFtdIG9iamVjdHMpIHsKLQkJdGhpcy5yZW1vdmVTZWxlY3RlZFZhbHVlcyhDb2xsZWN0aW9uVG9vbHMuaXRlcmF0b3Iob2JqZWN0cykpOwotCX0KLQotCS8qKgotCSAqIEBzZWUgamF2YXguc3dpbmcuTGlzdFNlbGVjdGlvbk1vZGVsI2dldEFuY2hvclNlbGVjdGlvbkluZGV4KCkKLQkgKiBSZXR1cm4gbnVsbCBpZiB0aGUgYW5jaG9yIHNlbGVjdGlvbiBpcyBlbXB0eS4KLQkgKi8KLQlwdWJsaWMgT2JqZWN0IGdldEFuY2hvclNlbGVjdGVkVmFsdWUoKSB7Ci0JCWludCBpbmRleCA9IHRoaXMuZ2V0QW5jaG9yU2VsZWN0aW9uSW5kZXgoKTsKLQkJaWYgKGluZGV4ID09IC0xKSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQlyZXR1cm4gdGhpcy5nZXRMaXN0TW9kZWwoKS5nZXRFbGVtZW50QXQoaW5kZXgpOwotCX0KLQotCS8qKgotCSAqIEBzZWUgamF2YXguc3dpbmcuTGlzdFNlbGVjdGlvbk1vZGVsI3NldEFuY2hvclNlbGVjdGlvbkluZGV4KGludCkKLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRBbmNob3JTZWxlY3RlZFZhbHVlKE9iamVjdCBvYmplY3QpIHsKLQkJdGhpcy5zZXRBbmNob3JTZWxlY3Rpb25JbmRleCh0aGlzLmluZGV4T2Yob2JqZWN0KSk7Ci0JfQotCi0JLyoqCi0JICogQHNlZSBqYXZheC5zd2luZy5MaXN0U2VsZWN0aW9uTW9kZWwjZ2V0TGVhZFNlbGVjdGlvbkluZGV4KCkKLQkgKiBSZXR1cm4gbnVsbCBpZiB0aGUgbGVhZCBzZWxlY3Rpb24gaXMgZW1wdHkuCi0JICovCi0JcHVibGljIE9iamVjdCBnZXRMZWFkU2VsZWN0ZWRWYWx1ZSgpIHsKLQkJaW50IGluZGV4ID0gdGhpcy5nZXRMZWFkU2VsZWN0aW9uSW5kZXgoKTsKLQkJaWYgKGluZGV4ID09IC0xKSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQlyZXR1cm4gdGhpcy5nZXRMaXN0TW9kZWwoKS5nZXRFbGVtZW50QXQoaW5kZXgpOwotCX0KLQotCS8qKgotCSAqIEBzZWUgamF2YXguc3dpbmcuTGlzdFNlbGVjdGlvbk1vZGVsI3NldExlYWRTZWxlY3Rpb25JbmRleChpbnQpCi0JICovCi0JcHVibGljIHZvaWQgc2V0TGVhZFNlbGVjdGVkVmFsdWUoT2JqZWN0IG9iamVjdCkgewotCQl0aGlzLnNldExlYWRTZWxlY3Rpb25JbmRleCh0aGlzLmluZGV4T2Yob2JqZWN0KSk7Ci0JfQotCi0JLyoqCi0JICogQHNlZSBqYXZheC5zd2luZy5MaXN0U2VsZWN0aW9uTW9kZWwjZ2V0TWF4U2VsZWN0aW9uSW5kZXgoKQotCSAqIFJldHVybiBudWxsIGlmIHRoZSBtYXggc2VsZWN0aW9uIGlzIGVtcHR5LgotCSAqLwotCXB1YmxpYyBPYmplY3QgZ2V0TWF4U2VsZWN0ZWRWYWx1ZSgpIHsKLQkJaW50IGluZGV4ID0gdGhpcy5nZXRNYXhTZWxlY3Rpb25JbmRleCgpOwotCQlpZiAoaW5kZXggPT0gLTEpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCXJldHVybiB0aGlzLmdldExpc3RNb2RlbCgpLmdldEVsZW1lbnRBdChpbmRleCk7Ci0JfQotCi0JLyoqCi0JICogQHNlZSBqYXZheC5zd2luZy5MaXN0U2VsZWN0aW9uTW9kZWwjZ2V0TWluU2VsZWN0aW9uSW5kZXgoKQotCSAqIFJldHVybiBudWxsIGlmIHRoZSBtaW4gc2VsZWN0aW9uIGlzIGVtcHR5LgotCSAqLwotCXB1YmxpYyBPYmplY3QgZ2V0TWluU2VsZWN0ZWRWYWx1ZSgpIHsKLQkJaW50IGluZGV4ID0gdGhpcy5nZXRNaW5TZWxlY3Rpb25JbmRleCgpOwotCQlpZiAoaW5kZXggPT0gLTEpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCXJldHVybiB0aGlzLmdldExpc3RNb2RlbCgpLmdldEVsZW1lbnRBdChpbmRleCk7Ci0JfQotCi0JLyoqCi0JICogQHNlZSBqYXZheC5zd2luZy5MaXN0U2VsZWN0aW9uTW9kZWwjaXNTZWxlY3RlZEluZGV4KGludCkKLQkgKi8KLQlwdWJsaWMgYm9vbGVhbiB2YWx1ZUlzU2VsZWN0ZWQoT2JqZWN0IG9iamVjdCkgewotCQlyZXR1cm4gdGhpcy5pc1NlbGVjdGVkSW5kZXgodGhpcy5pbmRleE9mKG9iamVjdCkpOwotCX0KLQotCS8qKgotCSAqIEFkZCB0aGUgc3BlY2lmaWVkIG9iamVjdHMgdG8gdGhlIGN1cnJlbnQgc2V0IG9mIHNlbGVjdGVkIG9iamVjdHMsCi0JICogd2l0aG91dCB3cmFwcGluZyB0aGUgYWN0aW9ucyBpbiAiYWRqdXN0aW5nIiBldmVudHMuCi0JICovCi0JcHJpdmF0ZSB2b2lkIGFkZFNlbGVjdGVkVmFsdWVzSW50ZXJuYWwoSXRlcmF0b3I8Pz4gb2JqZWN0cykgewotCQlMaXN0TW9kZWwgbG0gPSB0aGlzLmdldExpc3RNb2RlbCgpOwotCQlpbnQgbGlzdE1vZGVsU2l6ZSA9IGxtLmdldFNpemUoKTsKLQkJd2hpbGUgKG9iamVjdHMuaGFzTmV4dCgpKSB7Ci0JCQlpbnQgaW5kZXggPSB0aGlzLmluZGV4T2Yob2JqZWN0cy5uZXh0KCksIGxtLCBsaXN0TW9kZWxTaXplKTsKLQkJCXRoaXMuYWRkU2VsZWN0aW9uSW50ZXJ2YWwoaW5kZXgsIGluZGV4KTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaW5kZXggaW4gdGhlIGxpc3QgbW9kZWwgb2YgdGhlIHNwZWNpZmllZCBvYmplY3QuCi0JICogUmV0dXJuIC0xIGlmIHRoZSBvYmplY3QgaXMgbm90IGluIHRoZSBsaXN0IG1vZGVsLgotCSAqLwotCXByaXZhdGUgaW50IGluZGV4T2YoT2JqZWN0IG9iamVjdCkgewotCQlMaXN0TW9kZWwgbG0gPSB0aGlzLmdldExpc3RNb2RlbCgpOwotCQlyZXR1cm4gdGhpcy5pbmRleE9mKG9iamVjdCwgbG0sIGxtLmdldFNpemUoKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBpbmRleCBpbiB0aGUgbGlzdCBtb2RlbCBvZiB0aGUgc3BlY2lmaWVkIG9iamVjdC4KLQkgKiBSZXR1cm4gLTEgaWYgdGhlIG9iamVjdCBpcyBub3QgaW4gdGhlIGxpc3QgbW9kZWwuCi0JICovCi0JLy8gd2UncmUganVzdCBqZXJraW5nIGFyb3VuZCB3aXRoIHBlcmZvcm1hbmNlIG9wdGltaXphdGlvbnMgaGVyZQotCS8vIChpbiBtZW1vcnkgb2YgUGhpbC4uLik7Ci0JLy8gY2FsbCB0aGlzIG1ldGhvZCBpbnNpZGUgbG9vcHMgdGhhdCBkbyBub3QgbW9kaWZ5IHRoZSBsaXN0TW9kZWwKLQlwcml2YXRlIGludCBpbmRleE9mKE9iamVjdCBvYmplY3QsIExpc3RNb2RlbCBsbSwgaW50IGxpc3RNb2RlbFNpemUpIHsKLQkJZm9yIChpbnQgaSA9IGxpc3RNb2RlbFNpemU7IGktLSA+IDA7ICkgewotCQkJaWYgKGxtLmdldEVsZW1lbnRBdChpKSA9PSBvYmplY3QpIHsKLQkJCQlyZXR1cm4gaTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gLTE7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvUHJpbWl0aXZlTGlzdFRyZWVNb2RlbC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL1ByaW1pdGl2ZUxpc3RUcmVlTW9kZWwuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMmJjOGExNy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvUHJpbWl0aXZlTGlzdFRyZWVNb2RlbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjMzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmc7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LlRyZWVNb2RlbExpc3RlbmVyOwotaW1wb3J0IGphdmF4LnN3aW5nLnRyZWUuRGVmYXVsdE11dGFibGVUcmVlTm9kZTsKLWltcG9ydCBqYXZheC5zd2luZy50cmVlLkRlZmF1bHRUcmVlTW9kZWw7Ci1pbXBvcnQgamF2YXguc3dpbmcudHJlZS5NdXRhYmxlVHJlZU5vZGU7Ci1pbXBvcnQgamF2YXguc3dpbmcudHJlZS5UcmVlTm9kZTsKLWltcG9ydCBqYXZheC5zd2luZy50cmVlLlRyZWVQYXRoOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLmxpc3RlbmVyLmF3dC5BV1RMaXN0Q2hhbmdlTGlzdGVuZXJXcmFwcGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50Lkxpc3RDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5MaXN0Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci0KLS8qKgotICogVGhpcyBUcmVlTW9kZWwgaW1wbGVtZW50YXRpb24gcHJvdmlkZXMgYSB0cmVlIHdpdGggYSAibnVsbCIgcm9vdCB0aGF0Ci0gKiBoYXMgYSBzZXQgb2YgInByaW1pdGl2ZSIgY2hpbGRyZW4uIFRoZXNlICJwcmltaXRpdmUiIGNoaWxkcmVuIGRvIG5vdCBoYXZlCi0gKiBjaGlsZHJlbiB0aGVtc2VsdmVzLCBtYWtpbmcgdGhlIHRyZWUgYSBtYXhpbXVtIG9mIDIgbGV2ZWxzIGRlZXAuCi0gKiBUaGlzIG1vZGVsIGF1dG9tYXRpY2FsbHkgc3luY2hyb25pemVzIHRoZSByb290J3MgY2hpbGRyZW4gd2l0aCBhCi0gKiBMaXN0VmFsdWVNb2RlbCB0aGF0IGhvbGRzIGEgY29sbGVjdGlvbiBvZiBwcmltaXRpdmUgKG5vbi1tb2RlbCkgb2JqZWN0cwotICogKGUuZy4gU3RyaW5ncykuCi0gKiAKLSAqIFRoaXMgaXMgdXNlZnVsIGZvciBwcm92aWRpbmcgYW4gImVkaXRhYmxlIiBsaXN0IG9mIHByaW1pdGl2ZXMuIFNpbmNlIHRoZSBKREsKLSAqIGRvZXMgbm90IHByb3ZpZGUgdXMgd2l0aCBhbiBlZGl0YWJsZSBsaXN0Ym94LCB3ZSBtdXN0IHVzZSBhbiBlZGl0YWJsZSB0cmVlLgotICogV2Ugd3JhcCBldmVyeXRoaW5nIGluIERlZmF1bHRNdXRhYmxlVHJlZU5vZGVzLgotICogCi0gKiBTdWJjbGFzc2VzIG11c3QgaW1wbGVtZW50ICNwcmltaXRpdmVDaGFuZ2VkKGludCwgT2JqZWN0KSBhbmQgdXBkYXRlCi0gKiB0aGUgbW9kZWwgYXBwcm9wcmlhdGVseS4gVGhpcyBtZXRob2QgaXMgY2FsbGVkIHdoZW4gdGhlIHVzZXIgZWRpdHMgdGhlCi0gKiBsaXN0IGRpcmVjdGx5IGFuZCBwcmVzc2VzIDxFbnRlcj4uCi0gKiAKLSAqIFRoZSBKVHJlZSB1c2luZyB0aGlzIG1vZGVsIG11c3QgYmUgY29uZmlndXJlZCBhcyAiZWRpdGFibGUiOgotICogCXRyZWUuc2V0RWRpdGFibGUodHJ1ZSk7Ci0gKi8KLS8vIFRPRE8gY29udmVydCB0byB1c2UgYW4gYWRhcHRlciBpbnN0ZWFkIG9mIHJlcXVpcmluZyBzdWJjbGFzcwotcHVibGljIGFic3RyYWN0IGNsYXNzIFByaW1pdGl2ZUxpc3RUcmVlTW9kZWwKLQlleHRlbmRzIERlZmF1bHRUcmVlTW9kZWwKLXsKLQkvKiogYSBtb2RlbCBvbiB0aGUgbGlzdCBvZiBwcmltaXRpdmVzICovCi0JcHJpdmF0ZSBmaW5hbCBMaXN0VmFsdWVNb2RlbDw/PiBsaXN0SG9sZGVyOwotCi0JLyoqIGEgbGlzdGVuZXIgdGhhdCBoYW5kbGVzIHRoZSBhZGRpbmcsIHJlbW92aW5nLCBhbmQgcmVwbGFjaW5nIG9mIHRoZSBwcmltaXRpdmVzICovCi0JcHJpdmF0ZSBmaW5hbCBMaXN0Q2hhbmdlTGlzdGVuZXIgbGlzdENoYW5nZUxpc3RlbmVyOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0JCi0JLyoqCi0JICogUHVibGljIGNvbnN0cnVjdG9yIC0gdGhlIGxpc3QgaG9sZGVyIGlzIHJlcXVpcmVkCi0JICovCi0JcHVibGljIFByaW1pdGl2ZUxpc3RUcmVlTW9kZWwoTGlzdFZhbHVlTW9kZWw8Pz4gbGlzdEhvbGRlcikgewotCQlzdXBlcihuZXcgRGVmYXVsdE11dGFibGVUcmVlTm9kZShudWxsLCB0cnVlKSk7ICAvLyB0cnVlID0gdGhlIHJvb3QgY2FuIGhhdmUgY2hpbGRyZW4KLQkJaWYgKGxpc3RIb2xkZXIgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy5saXN0SG9sZGVyID0gbGlzdEhvbGRlcjsKLQkJdGhpcy5saXN0Q2hhbmdlTGlzdGVuZXIgPSB0aGlzLmJ1aWxkTGlzdENoYW5nZUxpc3RlbmVyKCk7Ci0JCS8vIHBvc3Rwb25lIGxpc3RlbmluZyB0byB0aGUgbW9kZWwgdW50aWwgd2UgaGF2ZSBsaXN0ZW5lcnMgb3Vyc2VsdmVzCi0JfQotCi0JcHJvdGVjdGVkIExpc3RDaGFuZ2VMaXN0ZW5lciBidWlsZExpc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBBV1RMaXN0Q2hhbmdlTGlzdGVuZXJXcmFwcGVyKHRoaXMuYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXJfKCkpOwotCX0KLQotCXByb3RlY3RlZCBMaXN0Q2hhbmdlTGlzdGVuZXIgYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXJfKCkgewotCQlyZXR1cm4gbmV3IFByaW1pdGl2ZUxpc3RDaGFuZ2VMaXN0ZW5lcigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBTdWJjbGFzc2VzIHNob3VsZCBvdmVycmlkZSB0aGlzIG1ldGhvZCB0byB1cGRhdGUgdGhlIAotCSAqIG1vZGVsIGFwcHJvcHJpYXRlbHkuIFRoZSBwcmltaXRpdmUgYXQgdGhlIHNwZWNpZmllZCBpbmRleCB3YXMKLQkgKiBlZGl0ZWQgZGlyZWN0bHkgYnkgdGhlIHVzZXIgYW5kIHRoZSBuZXcgdmFsdWUgaXMgYXMgc3BlY2lmaWVkLgotCSAqIENvbnZlcnQgdGhlIHZhbHVlIGFwcHJvcHJpYXRlbHkgYW5kIHBsYWNlIGl0IGluIHRoZSBtb2RlbC4KLQkgKi8KLQlwcm90ZWN0ZWQgYWJzdHJhY3Qgdm9pZCBwcmltaXRpdmVDaGFuZ2VkKGludCBpbmRleCwgT2JqZWN0IG5ld1ZhbHVlKTsKLQotCi0JLy8gKioqKioqKioqKiBUcmVlTW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JLyoqCi0JICogT3ZlcnJpZGUgdG8gY2hhbmdlIHRoZSB1bmRlcmx5aW5nIG1vZGVsIGluc3RlYWQgb2YgY2hhbmdpbmcgdGhlIG5vZGUgZGlyZWN0bHkuCi0JICovCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgdmFsdWVGb3JQYXRoQ2hhbmdlZChUcmVlUGF0aCBwYXRoLCBPYmplY3QgbmV3VmFsdWUpIHsKLQkJVHJlZU5vZGUgbm9kZSA9IChUcmVlTm9kZSkgcGF0aC5nZXRMYXN0UGF0aENvbXBvbmVudCgpOwotCQlpbnQgaW5kZXggPSAoKFRyZWVOb2RlKSB0aGlzLmdldFJvb3QoKSkuZ2V0SW5kZXgobm9kZSk7Ci0JCXRoaXMucHJpbWl0aXZlQ2hhbmdlZChpbmRleCwgbmV3VmFsdWUpOwotCX0KLQotCS8qKgotCSAqIEV4dGVuZCB0byBzdGFydCBsaXN0ZW5pbmcgdG8gdGhlIHVuZGVybHlpbmcgbW9kZWwgaWYgbmVjZXNzYXJ5LgotCSAqLwotICAgIEBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGFkZFRyZWVNb2RlbExpc3RlbmVyKFRyZWVNb2RlbExpc3RlbmVyIGwpIHsKLQkJaWYgKHRoaXMuZ2V0VHJlZU1vZGVsTGlzdGVuZXJzKCkubGVuZ3RoID09IDApIHsKLQkJCXRoaXMubGlzdEhvbGRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMubGlzdENoYW5nZUxpc3RlbmVyKTsKLQkJCXRoaXMuc3luY2hyb25pemVMaXN0KCk7Ci0JCX0KLQkJc3VwZXIuYWRkVHJlZU1vZGVsTGlzdGVuZXIobCk7Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSB1bmRlcmx5aW5nIG1vZGVsIGlmIGFwcHJvcHJpYXRlLgotCSAqLwotICAgIEBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHJlbW92ZVRyZWVNb2RlbExpc3RlbmVyKFRyZWVNb2RlbExpc3RlbmVyIGwpIHsKLQkJc3VwZXIucmVtb3ZlVHJlZU1vZGVsTGlzdGVuZXIobCk7Ci0JCWlmICh0aGlzLmdldFRyZWVNb2RlbExpc3RlbmVycygpLmxlbmd0aCA9PSAwKSB7Ci0JCQl0aGlzLmxpc3RIb2xkZXIucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmxpc3RDaGFuZ2VMaXN0ZW5lcik7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCi0JLyoqCi0JICogU3luY2hyb25pemUgb3VyIGxpc3Qgb2Ygbm9kZXMgd2l0aCB0aGUgbGlzdCBvZiBwcmltaXRpdmVzCi0JICovCi0Jdm9pZCBzeW5jaHJvbml6ZUxpc3QoKSB7Ci0JCXRoaXMuY2xlYXJMaXN0KCk7Ci0JCXRoaXMuYnVpbGRMaXN0KCk7Ci0JfQotCi0Jdm9pZCBjbGVhckxpc3QoKSB7Ci0JCWludCBjaGlsZGNvdW50ID0gdGhpcy5yb290LmdldENoaWxkQ291bnQoKTsKLQkJZm9yIChpbnQgaSA9IGNoaWxkY291bnQgLSAxOyBpID49IDA7IGktLSkgewotCQkJdGhpcy5yZW1vdmVOb2RlRnJvbVBhcmVudCgoTXV0YWJsZVRyZWVOb2RlKXRoaXMucm9vdC5nZXRDaGlsZEF0KGkpKTsKLQkJfQotCX0KLQkJCi0JcHJpdmF0ZSB2b2lkIGJ1aWxkTGlzdCgpIHsKLQkJZm9yIChJdGVyYXRvcjw/PiBzdHJlYW0gPSB0aGlzLmxpc3RIb2xkZXIuaXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQl0aGlzLmFkZFByaW1pdGl2ZShzdHJlYW0ubmV4dCgpKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIEFkZCB0aGUgc3BlY2lmaWVkIHByaW1pdGl2ZSB0byB0aGUgZW5kIG9mIHRoZSBsaXN0LgotCSAqLwotCXByaXZhdGUgdm9pZCBhZGRQcmltaXRpdmUoT2JqZWN0IHByaW1pdGl2ZSkgewotCQl0aGlzLmluc2VydFByaW1pdGl2ZSh0aGlzLnJvb3QuZ2V0Q2hpbGRDb3VudCgpLCBwcmltaXRpdmUpOwotCX0KLQotCS8qKgotCSAqIENyZWF0ZSBhIG5vZGUgZm9yIHRoZSBzcGVjaWZpZWQgcHJpbWl0aXZlCi0JICogYW5kIGluc2VydCBpdCBhcyBhIGNoaWxkIG9mIHRoZSByb290LgotCSAqLwotCXZvaWQgaW5zZXJ0UHJpbWl0aXZlKGludCBpbmRleCwgT2JqZWN0IHByaW1pdGl2ZSkgewotCQlEZWZhdWx0TXV0YWJsZVRyZWVOb2RlIG5vZGUgPSBuZXcgRGVmYXVsdE11dGFibGVUcmVlTm9kZShwcmltaXRpdmUsIGZhbHNlKTsgLy8gZG9uJ3QgYWxsb3cgY2hpbGRyZW4gb24gdGhlIGNoaWxkIG5vZGUKLQkJdGhpcy5pbnNlcnROb2RlSW50byhub2RlLCAoTXV0YWJsZVRyZWVOb2RlKSB0aGlzLnJvb3QsIGluZGV4KTsKLQl9Ci0KLQkvKioKLQkgKiBSZW1vdmUgbm9kZSBhdCB0aGUgc3BlY2lmaWVkIGluZGV4LgotCSAqLwotCU11dGFibGVUcmVlTm9kZSByZW1vdmVOb2RlKGludCBpbmRleCkgewotCQlNdXRhYmxlVHJlZU5vZGUgbm9kZSA9IChNdXRhYmxlVHJlZU5vZGUpIHRoaXMucm9vdC5nZXRDaGlsZEF0KGluZGV4KTsKLQkJdGhpcy5yZW1vdmVOb2RlRnJvbVBhcmVudChub2RlKTsKLQkJcmV0dXJuIG5vZGU7Ci0JfQotCi0JLyoqCi0JICogUmVwbGFjZSB0aGUgdXNlciBvYmplY3Qgb2YgdGhlIG5vZGUgYXQgY2hpbGRJbmRleC4KLQkgKi8KLQl2b2lkIHJlcGxhY2VQcmltaXRpdmUoaW50IGluZGV4LCBPYmplY3QgcHJpbWl0aXZlKSB7Ci0JCU11dGFibGVUcmVlTm9kZSBub2RlID0gKE11dGFibGVUcmVlTm9kZSkgdGhpcy5yb290LmdldENoaWxkQXQoaW5kZXgpOwotCQlub2RlLnNldFVzZXJPYmplY3QocHJpbWl0aXZlKTsKLQkJdGhpcy5ub2RlQ2hhbmdlZChub2RlKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5uZXIgY2xhc3MgKioqKioqKioqKgotCi0JcHJpdmF0ZSBjbGFzcyBQcmltaXRpdmVMaXN0Q2hhbmdlTGlzdGVuZXIgaW1wbGVtZW50cyBMaXN0Q2hhbmdlTGlzdGVuZXIgewotCQlQcmltaXRpdmVMaXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0KLQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCWludCBpID0gZXZlbnQuZ2V0SW5kZXgoKTsKLQkJCWZvciAoTGlzdEl0ZXJhdG9yPD8+IHN0cmVhbSA9IGV2ZW50Lml0ZW1zKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJCVByaW1pdGl2ZUxpc3RUcmVlTW9kZWwudGhpcy5pbnNlcnRQcmltaXRpdmUoaSsrLCBzdHJlYW0ubmV4dCgpKTsKLQkJCX0KLQkJfQotCi0JCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCWZvciAoaW50IGkgPSAwOyBpIDwgZXZlbnQuaXRlbXNTaXplKCk7IGkrKykgewotCQkJCVByaW1pdGl2ZUxpc3RUcmVlTW9kZWwudGhpcy5yZW1vdmVOb2RlKGV2ZW50LmdldEluZGV4KCkpOwotCQkJfQotCQl9Ci0KLQkJcHVibGljIHZvaWQgaXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCWludCBpID0gZXZlbnQuZ2V0SW5kZXgoKTsKLQkJCWZvciAoTGlzdEl0ZXJhdG9yPD8+IHN0cmVhbSA9IGV2ZW50Lml0ZW1zKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJCVByaW1pdGl2ZUxpc3RUcmVlTW9kZWwudGhpcy5yZXBsYWNlUHJpbWl0aXZlKGkrKywgc3RyZWFtLm5leHQoKSk7Ci0JCQl9Ci0JCX0KLQotCQlwdWJsaWMgdm9pZCBpdGVtc01vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJQXJyYXlMaXN0PE11dGFibGVUcmVlTm9kZT4gdGVtcCA9IG5ldyBBcnJheUxpc3Q8TXV0YWJsZVRyZWVOb2RlPihldmVudC5nZXRNb3ZlTGVuZ3RoKCkpOwotCQkJZm9yIChpbnQgaSA9IDA7IGkgPCBldmVudC5nZXRNb3ZlTGVuZ3RoKCk7IGkrKykgewotCQkJCXRlbXAuYWRkKFByaW1pdGl2ZUxpc3RUcmVlTW9kZWwudGhpcy5yZW1vdmVOb2RlKGV2ZW50LmdldFNvdXJjZUluZGV4KCkpKTsKLQkJCX0KLQkJCWludCBpID0gZXZlbnQuZ2V0VGFyZ2V0SW5kZXgoKTsKLQkJCWZvciAoTXV0YWJsZVRyZWVOb2RlIG5vZGUgOiB0ZW1wKSB7Ci0JCQkJUHJpbWl0aXZlTGlzdFRyZWVNb2RlbC50aGlzLmluc2VydFByaW1pdGl2ZShpKyssIG5vZGUpOwotCQkJfQotCQl9Ci0KLQkJcHVibGljIHZvaWQgbGlzdENsZWFyZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQlQcmltaXRpdmVMaXN0VHJlZU1vZGVsLnRoaXMuY2xlYXJMaXN0KCk7Ci0JCX0KLQotCQlwdWJsaWMgdm9pZCBsaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCVByaW1pdGl2ZUxpc3RUcmVlTW9kZWwudGhpcy5zeW5jaHJvbml6ZUxpc3QoKTsKLQkJfQotCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvUmFkaW9CdXR0b25Nb2RlbEFkYXB0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9SYWRpb0J1dHRvbk1vZGVsQWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxY2FlZTQ4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9SYWRpb0J1dHRvbk1vZGVsQWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTUxICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmc7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5CaWRpRmlsdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkJpZGlUcmFuc2Zvcm1lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5GaWx0ZXJpbmdXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIFRoaXMgamF2YXguc3dpbmcuQnV0dG9uTW9kZWwgY2FuIGJlIHVzZWQgdG8ga2VlcCBhIGxpc3RlbmVyCi0gKiAoZS5nLiBhIEpSYWRpb0J1dHRvbikgaW4gc3luY2ggd2l0aCBhICh0eXBpY2FsbHkgc2hhcmVkKQotICogUHJvcGVydHlWYWx1ZU1vZGVsIHRoYXQgaG9sZHMgb25lIHZhbHVlIG91dCBvZiBhIHNldCBvZiB2YWx1ZXMuCi0gKiAKLSAqIE5PVEU6IERvICpub3QqIHVzZSB0aGlzIG1vZGVsIHdpdGggYSBCdXR0b25Hcm91cCwgc2luY2UgdGhlCi0gKiBzaGFyZWQgdmFsdWUgaG9sZGVyIGFuZCB0aGUgd3JhcHBlcnMgYnVpbHQgYnkgdGhpcyBhZGFwdGVyIHdpbGwKLSAqIGtlZXAgdGhlIGFwcHJvcHJpYXRlIHJhZGlvIGJ1dHRvbiBjaGVja2VkLiBBbHNvLCB0aGlzIGFsbG93cwotICogdXMgdG8gdW5jaGVjayBhbGwgdGhlIHJhZGlvIGJ1dHRvbnMgaW4gYSBncm91cCB3aGVuIHRoZSBzaGFyZWQKLSAqIHZhbHVlIGlzIG51bGwuCi0gKi8KLXB1YmxpYyBjbGFzcyBSYWRpb0J1dHRvbk1vZGVsQWRhcHRlcgotCWV4dGVuZHMgVG9nZ2xlQnV0dG9uTW9kZWxBZGFwdGVyCi17Ci0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3RvciAtIHRoZSB2YWx1ZSBob2xkZXIgaXMgcmVxdWlyZWQuCi0JICovCi0JcHVibGljIFJhZGlvQnV0dG9uTW9kZWxBZGFwdGVyKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gdmFsdWVIb2xkZXIsIE9iamVjdCBidXR0b25WYWx1ZSwgYm9vbGVhbiBkZWZhdWx0VmFsdWUpIHsKLQkJc3VwZXIoYnVpbGRCb29sZWFuSG9sZGVyKHZhbHVlSG9sZGVyLCBidXR0b25WYWx1ZSksIGRlZmF1bHRWYWx1ZSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0b3IgLSB0aGUgdmFsdWUgaG9sZGVyIGlzIHJlcXVpcmVkLgotCSAqIFRoZSBkZWZhdWx0IHZhbHVlIHdpbGwgYmUgZmFsc2UuCi0JICovCi0JcHVibGljIFJhZGlvQnV0dG9uTW9kZWxBZGFwdGVyKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gdmFsdWVIb2xkZXIsIE9iamVjdCBidXR0b25WYWx1ZSkgewotCQlzdXBlcihidWlsZEJvb2xlYW5Ib2xkZXIodmFsdWVIb2xkZXIsIGJ1dHRvblZhbHVlKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHN0YXRpYyBtZXRob2RzICoqKioqKioqKioKLQotCS8qKgotCSAqIEJ1aWxkIHVwIGEgc2V0IG9mIHdyYXBwZXJzIHRoYXQgd2lsbCBjb252ZXJ0IHRoZQotCSAqIHNwZWNpZmllZCB2YWx1ZSBob2xkZXIgYW5kIGJ1dHRvbiB2YWx1ZSB0by9mcm9tIGEgYm9vbGVhbi4KLQkgKiAKLQkgKiBJZiB0aGUgdmFsdWUgaG9sZGVyJ3MgdmFsdWUgbWF0Y2hlcyB0aGUgYnV0dG9uIHZhbHVlLAotCSAqIHRoZSB3cmFwcGVyIHdpbGwgcmV0dXJuIHRydWUuIExpa2V3aXNlLCBpZiB0aGUgdmFsdWUgaG9sZGVyJ3MKLQkgKiB2YWx1ZSBpcyBzZXQgdG8gdHJ1ZSwgdGhlIHdyYXBwZXIgd2lsbCBzZXQgdGhlIHZhbHVlIGhvbGRlcidzCi0JICogdmFsdWUgdG8gdGhlIGJ1dHRvbiB2YWx1ZS4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkQm9vbGVhbkhvbGRlcihXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IHZhbHVlSG9sZGVyLCBPYmplY3QgYnV0dG9uVmFsdWUpIHsKLQkJV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBmaWx0ZXJpbmdQVk0gPSBuZXcgRmlsdGVyaW5nV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0Pih2YWx1ZUhvbGRlciwgbmV3IFJhZGlvQnV0dG9uRmlsdGVyKGJ1dHRvblZhbHVlKSk7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3QsIEJvb2xlYW4+KGZpbHRlcmluZ1BWTSwgbmV3IFJhZGlvQnV0dG9uVHJhbnNmb3JtZXIoYnV0dG9uVmFsdWUpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogb3ZlcnJpZGVzICoqKioqKioqKioKLQotCS8qKgotCSAqIFRoZSB1c2VyIGNhbm5vdCBkZS1zZWxlY3QgYSByYWRpbyBidXR0b24gLSB0aGUgdXNlcgotCSAqIGNhbiBvbmx5ICpzZWxlY3QqIGEgcmFkaW8gYnV0dG9uLiBPbmx5IHRoZSBtb2RlbCBjYW4KLQkgKiBjYXVzZSBhIHJhZGlvIGJ1dHRvbiB0byBiZSBkZS1zZWxlY3RlZC4gV2UgdXNlIHRoZQotCSAqIEFSTUVEIGZsYWcgdG8gaW5kaWNhdGUgd2hldGhlciB3ZSBhcmUgYmVpbmcgZGUtc2VsZWN0ZWQKLQkgKiBieSB0aGUgdXNlci4KLQkgKi8KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBzZXRTZWxlY3RlZChib29sZWFuIGIpIHsKLQkJLy8gZG8gbm90IGFsbG93IHRoZSB1c2VyIHRvIGRlLXNlbGVjdCBhIHJhZGlvIGJ1dHRvbgotCQkvLyByYWRpbyBidXR0b25zIGNhbgotCQlpZiAoKGIgPT0gZmFsc2UpICYmIHRoaXMuaXNBcm1lZCgpKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQkJc3VwZXIuc2V0U2VsZWN0ZWQoYik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGlubmVyIGNsYXNzZXMgKioqKioqKioqKgotCi0JLyoqCi0JICogVGhpcyBmaWx0ZXIgd2lsbCBvbmx5IHBhc3MgdGhyb3VnaCBhIG5ldyB2YWx1ZSB0byB0aGUgd3JhcHBlZAotCSAqIHZhbHVlIGhvbGRlciB3aGVuIGl0IG1hdGNoZXMgdGhlIGNvbmZpZ3VyZWQgYnV0dG9uIHZhbHVlLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2xhc3MgUmFkaW9CdXR0b25GaWx0ZXIgaW1wbGVtZW50cyBCaWRpRmlsdGVyPE9iamVjdD4gewotCQlwcml2YXRlIE9iamVjdCBidXR0b25WYWx1ZTsKLQotCQlwdWJsaWMgUmFkaW9CdXR0b25GaWx0ZXIoT2JqZWN0IGJ1dHRvblZhbHVlKSB7Ci0JCQlzdXBlcigpOwotCQkJdGhpcy5idXR0b25WYWx1ZSA9IGJ1dHRvblZhbHVlOwotCQl9Ci0KLQkJLyoqCi0JCSAqIGFsd2F5cyByZXR1cm4gdGhlIHdyYXBwZWQgdmFsdWUKLQkJICovCi0JCXB1YmxpYyBib29sZWFuIGFjY2VwdChPYmplY3QgdmFsdWUpIHsKLQkJCXJldHVybiB0cnVlOwotCQl9Ci0KLQkJLyoqCi0JCSAqIHBhc3MgdGhyb3VnaCB0aGUgdmFsdWUgdG8gdGhlIHdyYXBwZWQgcHJvcGVydHkgdmFsdWUgbW9kZWwKLQkJICogKm9ubHkqIHdoZW4gaXQgbWF0Y2hlcyBvdXIgYnV0dG9uIHZhbHVlCi0JCSAqLwotCQlwdWJsaWMgYm9vbGVhbiByZXZlcnNlQWNjZXB0KE9iamVjdCB2YWx1ZSkgewotCQkJcmV0dXJuIHZhbHVlID09IHRoaXMuYnV0dG9uVmFsdWU7Ci0JCX0KLQotCX0KLQotCS8qKgotCSAqIFRoaXMgdHJhbnNmb3JtZXIgd2lsbCBjb252ZXJ0IHRoZSB3cmFwcGVkIHZhbHVlIHRvIEJvb2xlYW4uVFJVRQotCSAqIHdoZW4gaXQgbWF0Y2hlcyB0aGUgY29uZmlndXJlZCBidXR0b24gdmFsdWUuCi0JICovCi0JcHVibGljIHN0YXRpYyBjbGFzcyBSYWRpb0J1dHRvblRyYW5zZm9ybWVyIGltcGxlbWVudHMgQmlkaVRyYW5zZm9ybWVyPE9iamVjdCwgQm9vbGVhbj4gewotCQlwcml2YXRlIE9iamVjdCBidXR0b25WYWx1ZTsKLQotCQlwdWJsaWMgUmFkaW9CdXR0b25UcmFuc2Zvcm1lcihPYmplY3QgYnV0dG9uVmFsdWUpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLmJ1dHRvblZhbHVlID0gYnV0dG9uVmFsdWU7Ci0JCX0KLQotCQkvKioKLQkJICogaWYgdGhlIHdyYXBwZWQgdmFsdWUgbWF0Y2hlcyBvdXIgYnV0dG9uIHZhbHVlIHJldHVybiB0cnVlLAotCQkgKiBpZiBpdCBpcyBzb21lIG90aGVyIHZhbHVlIHJldHVybiBmYWxzZTsKLQkJICogYnV0IGlmIGl0IGlzIG51bGwgc2ltcGx5IHBhc3MgaXQgdGhyb3VnaCBiZWNhdXNlIGl0IHdpbGwgY2F1c2UgdGhlCi0JCSAqIGJ1dHRvbiBtb2RlbCdzIGRlZmF1bHQgdmFsdWUgdG8gYmUgdXNlZAotCQkgKi8KLQkJcHVibGljIEJvb2xlYW4gdHJhbnNmb3JtKE9iamVjdCB2YWx1ZSkgewotCQkJcmV0dXJuICh2YWx1ZSA9PSBudWxsKSA/IG51bGwgOiBCb29sZWFuLnZhbHVlT2YodmFsdWUgPT0gdGhpcy5idXR0b25WYWx1ZSk7Ci0JCX0KLQotCQkvKioKLQkJICogaWYgdGhlIG5ldyB2YWx1ZSBpcyB0cnVlLCBwYXNzIHRocm91Z2ggdGhlIG91ciBidXR0b24gdmFsdWU7Ci0JCSAqIG90aGVyd2lzZSBwYXNzIHRocm91Z2ggbnVsbAotCQkgKi8KLQkJcHVibGljIE9iamVjdCByZXZlcnNlVHJhbnNmb3JtKEJvb2xlYW4gdmFsdWUpIHsKLQkJCXJldHVybiAodmFsdWUuYm9vbGVhblZhbHVlKCkpID8gdGhpcy5idXR0b25WYWx1ZSA6IG51bGw7Ci0JCX0KLQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL1NwaW5uZXJNb2RlbEFkYXB0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9TcGlubmVyTW9kZWxBZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGMyNmYxOGYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL1NwaW5uZXJNb2RlbEFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDIwNyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nOwotCi1pbXBvcnQgamF2YXguc3dpbmcuQWJzdHJhY3RTcGlubmVyTW9kZWw7Ci1pbXBvcnQgamF2YXguc3dpbmcuU3Bpbm5lck1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLlNwaW5uZXJOdW1iZXJNb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5DaGFuZ2VFdmVudDsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5saXN0ZW5lci5hd3QuQVdUUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcldyYXBwZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBUaGlzIGphdmF4LnN3aW5nLlNwaW5uZXJNb2RlbCBjYW4gYmUgdXNlZCB0byBrZWVwIGEgQ2hhbmdlTGlzdGVuZXIKLSAqIChlLmcuIGEgSlNwaW5uZXIpIGluIHN5bmNoIHdpdGggYSBQcm9wZXJ0eVZhbHVlTW9kZWwgdGhhdCBob2xkcyBhIHZhbHVlLgotICogCi0gKiBOb3RlOiBpdCBpcyBsaWtlbHkgeW91IHdhbnQgdG8gdXNlIG9uZSBvZiB0aGUgZm9sbG93aW5nIGNsYXNzZXMgaW5zdGVhZCBvZgotICogdGhpcyBvbmU6Ci0gKiAgICAgRGF0ZVNwaW5uZXJNb2RlbEFkYXB0ZXIKLSAqICAgICBOdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyCi0gKiAgICAgTGlzdFNwaW5uZXJNb2RlbEFkYXB0ZXIKLSAqIAotICogTkI6IFRoaXMgbW9kZWwgc2hvdWxkIG9ubHkgYmUgdXNlZCBmb3IgdmFsdWVzIHRoYXQgaGF2ZSBhIGZhaXJseQotICogaW5leHBlbnNpdmUgI2VxdWFscygpIGltcGxlbWVudGF0aW9uLgotICogQHNlZSAjc3luY2hyb25pemVEZWxlZ2F0ZShPYmplY3QpCi0gKi8KLXB1YmxpYyBjbGFzcyBTcGlubmVyTW9kZWxBZGFwdGVyCi0JZXh0ZW5kcyBBYnN0cmFjdFNwaW5uZXJNb2RlbAotewotCS8qKiBUaGUgZGVsZWdhdGUgc3Bpbm5lciBtb2RlbCB3aG9zZSBiZWhhdmlvciB3ZSAiZW5oYW5jZSIuICovCi0JcHJvdGVjdGVkIGZpbmFsIFNwaW5uZXJNb2RlbCBkZWxlZ2F0ZTsKLQotCS8qKiBBIGxpc3RlbmVyIHRoYXQgYWxsb3dzIHVzIHRvIGZvcndhcmQgYW55IGNoYW5nZXMgbWFkZSB0byB0aGUgZGVsZWdhdGUgc3Bpbm5lciBtb2RlbC4gKi8KLQlwcm90ZWN0ZWQgZmluYWwgQ2hhbmdlTGlzdGVuZXIgZGVsZWdhdGVMaXN0ZW5lcjsKLQotCS8qKiBBIHZhbHVlIG1vZGVsIG9uIHRoZSB1bmRlcmx5aW5nIHZhbHVlLiAqLwotCXByb3RlY3RlZCBmaW5hbCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IHZhbHVlSG9sZGVyOwotCi0JLyoqIEEgbGlzdGVuZXIgdGhhdCBhbGxvd3MgdXMgdG8gc3luY2hyb25pemUgd2l0aCBjaGFuZ2VzIG1hZGUgdG8gdGhlIHVuZGVybHlpbmcgdmFsdWUuICovCi0JcHJvdGVjdGVkIGZpbmFsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgdmFsdWVMaXN0ZW5lcjsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0b3IgLSB0aGUgdmFsdWUgaG9sZGVyIGFuZCBkZWxlZ2F0ZSBhcmUgcmVxdWlyZWQuCi0JICovCi0JcHVibGljIFNwaW5uZXJNb2RlbEFkYXB0ZXIoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiB2YWx1ZUhvbGRlciwgU3Bpbm5lck1vZGVsIGRlbGVnYXRlKSB7Ci0JCXN1cGVyKCk7Ci0JCWlmICh2YWx1ZUhvbGRlciA9PSBudWxsIHx8IGRlbGVnYXRlID09IG51bGwpIHsKLQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigpOwotCQl9Ci0JCXRoaXMudmFsdWVIb2xkZXIgPSB2YWx1ZUhvbGRlcjsKLQkJdGhpcy5kZWxlZ2F0ZSA9IGRlbGVnYXRlOwotCQkvLyBwb3N0cG9uZSBsaXN0ZW5pbmcgdG8gdGhlIHVuZGVybHlpbmcgdmFsdWUKLQkJLy8gdW50aWwgd2UgaGF2ZSBsaXN0ZW5lcnMgb3Vyc2VsdmVzLi4uCi0JCXRoaXMudmFsdWVMaXN0ZW5lciA9IHRoaXMuYnVpbGRWYWx1ZUxpc3RlbmVyKCk7Ci0JCXRoaXMuZGVsZWdhdGVMaXN0ZW5lciA9IHRoaXMuYnVpbGREZWxlZ2F0ZUxpc3RlbmVyKCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0b3IgLSB0aGUgdmFsdWUgaG9sZGVyIGlzIHJlcXVpcmVkLgotCSAqIFRoaXMgd2lsbCB3cmFwIGEgc2ltcGxlIG51bWJlciBzcGlubmVyIG1vZGVsLgotCSAqLwotCXB1YmxpYyBTcGlubmVyTW9kZWxBZGFwdGVyKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gdmFsdWVIb2xkZXIpIHsKLQkJdGhpcyh2YWx1ZUhvbGRlciwgbmV3IFNwaW5uZXJOdW1iZXJNb2RlbCgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JcHJvdGVjdGVkIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGRWYWx1ZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IEFXVFByb3BlcnR5Q2hhbmdlTGlzdGVuZXJXcmFwcGVyKHRoaXMuYnVpbGRWYWx1ZUxpc3RlbmVyXygpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZFZhbHVlTGlzdGVuZXJfKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCVNwaW5uZXJNb2RlbEFkYXB0ZXIudGhpcy52YWx1ZUNoYW5nZWQoZXZlbnQpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAidmFsdWUgbGlzdGVuZXIiOwotCQkJfQotCQl9OwotCX0KLQotCS8qKgotCSAqIGV4cGFuZCBhY2Nlc3MgYSBiaXQgZm9yIGlubmVyIGNsYXNzCi0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgZmlyZVN0YXRlQ2hhbmdlZCgpIHsKLQkJc3VwZXIuZmlyZVN0YXRlQ2hhbmdlZCgpOwotCX0KLQotCXByb3RlY3RlZCBDaGFuZ2VMaXN0ZW5lciBidWlsZERlbGVnYXRlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQkvLyBmb3J3YXJkIHRoZSBldmVudCwgd2l0aCB0aGlzIGFzIHRoZSBzb3VyY2UKLQkJCQlTcGlubmVyTW9kZWxBZGFwdGVyLnRoaXMuZmlyZVN0YXRlQ2hhbmdlZCgpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiZGVsZWdhdGUgbGlzdGVuZXIiOwotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBTcGlubmVyTW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIE9iamVjdCBnZXRWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMuZGVsZWdhdGUuZ2V0VmFsdWUoKTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gdXBkYXRlIHRoZSB1bmRlcmx5aW5nIHZhbHVlIGRpcmVjdGx5LgotCSAqIFRoZSByZXN1bHRpbmcgZXZlbnQgd2lsbCBiZSBpZ25vcmVkOiBAc2VlICNzeW5jaHJvbml6ZURlbGVnYXRlKE9iamVjdCkuCi0JICovCi0JcHVibGljIHZvaWQgc2V0VmFsdWUoT2JqZWN0IHZhbHVlKSB7Ci0JCXRoaXMuZGVsZWdhdGUuc2V0VmFsdWUodmFsdWUpOwotCQl0aGlzLnZhbHVlSG9sZGVyLnNldFZhbHVlKHZhbHVlKTsKLQl9Ci0KLQlwdWJsaWMgT2JqZWN0IGdldE5leHRWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMuZGVsZWdhdGUuZ2V0TmV4dFZhbHVlKCk7Ci0JfQotCi0JcHVibGljIE9iamVjdCBnZXRQcmV2aW91c1ZhbHVlKCkgewotCQlyZXR1cm4gdGhpcy5kZWxlZ2F0ZS5nZXRQcmV2aW91c1ZhbHVlKCk7Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0YXJ0IGxpc3RlbmluZyB0byB0aGUgdW5kZXJseWluZyB2YWx1ZSBpZiBuZWNlc3NhcnkuCi0JICovCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgYWRkQ2hhbmdlTGlzdGVuZXIoQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJaWYgKHRoaXMubGlzdGVuZXJMaXN0LmdldExpc3RlbmVyQ291bnQoQ2hhbmdlTGlzdGVuZXIuY2xhc3MpID09IDApIHsKLQkJCXRoaXMuZGVsZWdhdGUuYWRkQ2hhbmdlTGlzdGVuZXIodGhpcy5kZWxlZ2F0ZUxpc3RlbmVyKTsKLQkJCXRoaXMuZW5nYWdlVmFsdWVIb2xkZXIoKTsKLQkJfQotCQlzdXBlci5hZGRDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSB1bmRlcmx5aW5nIHZhbHVlIGlmIGFwcHJvcHJpYXRlLgotCSAqLwotICAgIEBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHJlbW92ZUNoYW5nZUxpc3RlbmVyKENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKSB7Ci0JCXN1cGVyLnJlbW92ZUNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJaWYgKHRoaXMubGlzdGVuZXJMaXN0LmdldExpc3RlbmVyQ291bnQoQ2hhbmdlTGlzdGVuZXIuY2xhc3MpID09IDApIHsKLQkJCXRoaXMuZGlzZW5nYWdlVmFsdWVIb2xkZXIoKTsKLQkJCXRoaXMuZGVsZWdhdGUucmVtb3ZlQ2hhbmdlTGlzdGVuZXIodGhpcy5kZWxlZ2F0ZUxpc3RlbmVyKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBBIHRoaXJkIHBhcnR5IGhhcyBtb2RpZmllZCB0aGUgdW5kZXJseWluZyB2YWx1ZS4KLQkgKiBTeW5jaHJvbml6ZSB0aGUgZGVsZWdhdGUgbW9kZWwgYWNjb3JkaW5nbHkuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgdmFsdWVDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5zeW5jaHJvbml6ZURlbGVnYXRlKGV2ZW50LmdldE5ld1ZhbHVlKCkpOwotCX0KLQotCS8qKgotCSAqIFNldCB0aGUgZGVsZWdhdGUncyB2YWx1ZSBpZiBpdCBoYXMgY2hhbmdlZC4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBzeW5jaHJvbml6ZURlbGVnYXRlKE9iamVjdCB2YWx1ZSkgewotCQkvLyBjaGVjayB0byBzZWUgd2hldGhlciB0aGUgZGVsZWdhdGUgaGFzIGFscmVhZHkgYmVlbiBzeW5jaHJvbml6ZWQKLQkJLy8gKHZpYSAjc2V0VmFsdWUoKSkKLQkJaWYgKCAhIHRoaXMuZGVsZWdhdGUuZ2V0VmFsdWUoKS5lcXVhbHModmFsdWUpKSB7Ci0JCQl0aGlzLmRlbGVnYXRlLnNldFZhbHVlKHZhbHVlKTsKLQkJfQotCX0KLQotCXByb3RlY3RlZCB2b2lkIGVuZ2FnZVZhbHVlSG9sZGVyKCkgewotCQl0aGlzLnZhbHVlSG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLnZhbHVlTGlzdGVuZXIpOwotCQl0aGlzLnN5bmNocm9uaXplRGVsZWdhdGUodGhpcy52YWx1ZUhvbGRlci5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VWYWx1ZUhvbGRlcigpIHsKLQkJdGhpcy52YWx1ZUhvbGRlci5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy52YWx1ZUxpc3RlbmVyKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogc3RhbmRhcmQgbWV0aG9kcyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gU3RyaW5nVG9vbHMuYnVpbGRUb1N0cmluZ0Zvcih0aGlzLCB0aGlzLnZhbHVlSG9sZGVyKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9UYWJsZU1vZGVsQWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL1RhYmxlTW9kZWxBZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDVlMDM5ZTIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL1RhYmxlTW9kZWxBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0MTAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZzsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LlRhYmxlTW9kZWxMaXN0ZW5lcjsKLWltcG9ydCBqYXZheC5zd2luZy50YWJsZS5BYnN0cmFjdFRhYmxlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwubGlzdGVuZXIuYXd0LkFXVExpc3RDaGFuZ2VMaXN0ZW5lcldyYXBwZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwubGlzdGVuZXIuYXd0LkFXVFByb3BlcnR5Q2hhbmdlTGlzdGVuZXJXcmFwcGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuTGlzdENoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlByb3BlcnR5Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuTGlzdENoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIFRoaXMgVGFibGVNb2RlbCBjYW4gYmUgdXNlZCB0byBrZWVwIGEgVGFibGVNb2RlbExpc3RlbmVyIChlLmcuIGEgSlRhYmxlKQotICogaW4gc3luY2ggd2l0aCBhIExpc3RWYWx1ZU1vZGVsIHRoYXQgaG9sZHMgYSBjb2xsZWN0aW9uIG9mIG1vZGVsIG9iamVjdHMsCi0gKiBlYWNoIG9mIHdoaWNoIGNvcnJlc3BvbmRzIHRvIGEgcm93IGluIHRoZSB0YWJsZS4KLSAqIFR5cGljYWxseSwgZWFjaCBjb2x1bW4gb2YgdGhlIHRhYmxlIHdpbGwgYmUgYm91bmQgdG8gYSBkaWZmZXJlbnQgYXNwZWN0Ci0gKiBvZiB0aGUgY29udGFpbmVkIG1vZGVsIG9iamVjdHMuCi0gKiAKLSAqIEZvciBleGFtcGxlLCBhIE1XVGFibGUgaGFzIGFuIGF0dHJpYnV0ZSAnZGF0YWJhc2VGaWVsZHMnIHRoYXQgaG9sZHMKLSAqIGEgY29sbGVjdGlvbiBvZiBNV0RhdGFiYXNlRmllbGRzIHRoYXQgd291bGQgY29ycmVzcG9uZCB0byB0aGUgcm93cyBvZgotICogYSBKVGFibGU7IGFuZCBlYWNoIE1XRGF0YWJhc2VGaWVsZCBoYXMgYSBudW1iZXIKLSAqIG9mIGF0dHJpYnV0ZXMgKGUuZy4gbmFtZSwgdHlwZSwgc2l6ZSkgdGhhdCBjYW4gYmUgYm91bmQgdG8gdGhlIGNvbHVtbnMgb2YKLSAqIGEgcm93IGluIHRoZSBKVGFibGUuIEFzIHRoZXNlIGRhdGFiYXNlIGZpZWxkcyBhcmUgYWRkZWQsIHJlbW92ZWQsIGFuZAotICogY2hhbmdlZCwgdGhpcyBtb2RlbCB3aWxsIGtlZXAgdGhlIGxpc3RlbmVycyBhd2FyZSBvZiB0aGUgY2hhbmdlcy4KLSAqIAotICogQW4gaW5zdGFuY2Ugb2YgdGhpcyBUYWJsZU1vZGVsIG11c3QgYmUgc3VwcGxpZWQgd2l0aCBhCi0gKiBsaXN0IGhvbGRlciAoZS5nLiB0aGUgJ2RhdGFiYXNlRmllbGRzJyksIHdoaWNoIGlzIGEgdmFsdWUKLSAqIG1vZGVsIG9uIHRoZSBib3VuZCBjb2xsZWN0aW9uIFRoaXMgaXMgcmVxdWlyZWQgLSB0aGUKLSAqIGNvbGxlY3Rpb24gaXRzZWxmIGNhbiBiZSBudWxsLCBidXQgdGhlIGxpc3QgdmFsdWUgbW9kZWwgdGhhdAotICogaG9sZHMgaXQgaXMgcmVxdWlyZWQuIFR5cGljYWxseSB0aGlzIGxpc3Qgd2lsbCBiZSBzb3J0ZWQgKEBzZWUKLSAqIFNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcikuCi0gKiAKLSAqIFRoaXMgVGFibGVNb2RlbCBtdXN0IGFsc28gYmUgc3VwcGxpZWQgd2l0aCBhIENvbHVtbkFkYXB0ZXIgdGhhdAotICogd2lsbCBiZSB1c2VkIHRvIGNvbmZpZ3VyZSB0aGUgaGVhZGVycywgcmVuZGVyZXJzLCBlZGl0b3JzLCBhbmQgY29udGVudHMKLSAqIG9mIHRoZSB2YXJpb3VzIGNvbHVtbnMuCi0gKiAKLSAqIERlc2lnbiBkZWNpc2lvbjoKLSAqIENlbGwgbGlzdGVuZXIgb3B0aW9ucyAoZnJvbSBsb3cgc3BhY2UvaGlnaCB0aW1lIHRvIGhpZ2ggc3BhY2UvbG93IHRpbWUpOgotICogCS0gMSBjZWxsIGxpc3RlbmVyIGxpc3RlbmluZyB0byBldmVyeSBjZWxsICh0aGlzIGlzIHRoZSBjdXJyZW50IGltcGxlbWVudGF0aW9uKQotICogCS0gMSBjZWxsIGxpc3RlbmVyIHBlciByb3cKLSAqIAktIDEgY2VsbCBsaXN0ZW5lciBwZXIgY2VsbAotICovCi1wdWJsaWMgY2xhc3MgVGFibGVNb2RlbEFkYXB0ZXI8RT4KLQlleHRlbmRzIEFic3RyYWN0VGFibGVNb2RlbAotewotCS8qKgotCSAqIGEgbGlzdCBvZiB1c2VyIG9iamVjdHMgdGhhdCBhcmUgY29udmVydGVkIHRvCi0JICogcm93cyB2aWEgdGhlIGNvbHVtbiBhZGFwdGVyCi0JICovCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gbGlzdEhvbGRlcjsKLQlwcml2YXRlIGZpbmFsIExpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0Q2hhbmdlTGlzdGVuZXI7Ci0KLQkvKioKLQkgKiBlYWNoIHJvdyBpcyBhbiBhcnJheSBvZiBjZWxsIG1vZGVscwotCSAqLwotCS8vIGRlY2xhcmUgYXMgQXJyYXlMaXN0IHNvIHdlIGNhbiB1c2UgI2Vuc3VyZUNhcGFjaXR5KGludCkKLQlwcml2YXRlIGZpbmFsIEFycmF5TGlzdDxXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+W10+IHJvd3M7Ci0KLQkvKioKLQkgKiBjbGllbnQtc3VwcGxpZWQgYWRhcHRlciB0aGF0IHByb3ZpZGVzIHdpdGggdGhlIHZhcmlvdXMgY29sdW1uCi0JICogc2V0dGluZ3MgYW5kIGNvbnZlcnRzIHRoZSBvYmplY3RzIGluIHRoZSBMVk0KLQkgKiBpbnRvIGFuIGFycmF5IG9mIGNlbGwgbW9kZWxzCi0JICovCi0JcHJpdmF0ZSBmaW5hbCBDb2x1bW5BZGFwdGVyIGNvbHVtbkFkYXB0ZXI7Ci0KLQkvKioKLQkgKiB0aGUgc2luZ2xlIGxpc3RlbmVyIHRoYXQgbGlzdGVucyB0byBldmVyeSBjZWxsJ3MgbW9kZWwKLQkgKi8KLQlwcml2YXRlIGZpbmFsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgY2VsbExpc3RlbmVyOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSB0YWJsZSBtb2RlbCBhZGFwdGVyIGZvciB0aGUgc3BlY2lmaWVkIG9iamVjdHMKLQkgKiBhbmQgYWRhcHRlci4KLQkgKi8KLQlwdWJsaWMgVGFibGVNb2RlbEFkYXB0ZXIoTGlzdFZhbHVlTW9kZWw8PyBleHRlbmRzIEU+IGxpc3RIb2xkZXIsIENvbHVtbkFkYXB0ZXIgY29sdW1uQWRhcHRlcikgewotCQlzdXBlcigpOwotCQlpZiAobGlzdEhvbGRlciA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLmxpc3RIb2xkZXIgPSBsaXN0SG9sZGVyOwotCQl0aGlzLmNvbHVtbkFkYXB0ZXIgPSBjb2x1bW5BZGFwdGVyOwotCQl0aGlzLmxpc3RDaGFuZ2VMaXN0ZW5lciA9IHRoaXMuYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXIoKTsKLQkJdGhpcy5yb3dzID0gbmV3IEFycmF5TGlzdDxXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+W10+KCk7Ci0JCXRoaXMuY2VsbExpc3RlbmVyID0gdGhpcy5idWlsZENlbGxMaXN0ZW5lcigpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHRhYmxlIG1vZGVsIGFkYXB0ZXIgZm9yIHRoZSBzcGVjaWZpZWQgb2JqZWN0cwotCSAqIGFuZCBhZGFwdGVyLgotCSAqLwotCXB1YmxpYyBUYWJsZU1vZGVsQWRhcHRlcihDb2xsZWN0aW9uVmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gY29sbGVjdGlvbkhvbGRlciwgQ29sdW1uQWRhcHRlciBjb2x1bW5BZGFwdGVyKSB7Ci0JCXRoaXMobmV3IENvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXI8RT4oY29sbGVjdGlvbkhvbGRlciksIGNvbHVtbkFkYXB0ZXIpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0KLQlwcm90ZWN0ZWQgTGlzdENoYW5nZUxpc3RlbmVyIGJ1aWxkTGlzdENoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IEFXVExpc3RDaGFuZ2VMaXN0ZW5lcldyYXBwZXIodGhpcy5idWlsZExpc3RDaGFuZ2VMaXN0ZW5lcl8oKSk7Ci0JfQotCi0JcHJvdGVjdGVkIExpc3RDaGFuZ2VMaXN0ZW5lciBidWlsZExpc3RDaGFuZ2VMaXN0ZW5lcl8oKSB7Ci0JCXJldHVybiBuZXcgTGlzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlUYWJsZU1vZGVsQWRhcHRlci50aGlzLmFkZFJvd3MoZXZlbnQuZ2V0SW5kZXgoKSwgZXZlbnQuaXRlbXNTaXplKCksIHRoaXMuaXRlbXMoZXZlbnQpKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlUYWJsZU1vZGVsQWRhcHRlci50aGlzLnJlbW92ZVJvd3MoZXZlbnQuZ2V0SW5kZXgoKSwgZXZlbnQuaXRlbXNTaXplKCkpOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlUYWJsZU1vZGVsQWRhcHRlci50aGlzLnJlcGxhY2VSb3dzKGV2ZW50LmdldEluZGV4KCksIHRoaXMuaXRlbXMoZXZlbnQpKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJVGFibGVNb2RlbEFkYXB0ZXIudGhpcy5tb3ZlUm93cyhldmVudC5nZXRUYXJnZXRJbmRleCgpLCBldmVudC5nZXRTb3VyY2VJbmRleCgpLCBldmVudC5nZXRNb3ZlTGVuZ3RoKCkpOwotCQkJfQotCQkJcHVibGljIHZvaWQgbGlzdENsZWFyZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJVGFibGVNb2RlbEFkYXB0ZXIudGhpcy5jbGVhclRhYmxlKCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBsaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlUYWJsZU1vZGVsQWRhcHRlci50aGlzLnJlYnVpbGRUYWJsZSgpOwotCQkJfQotCQkJLyoqCi0JCQkgKiBtaW5pbWl6ZSBzY29wZSBvZiBzdXBwcmVzc2VkIHdhcm5pbmdzCi0JCQkgKi8KLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHJvdGVjdGVkIEl0ZXJhdG9yPE9iamVjdD4gaXRlbXMoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJcmV0dXJuIChJdGVyYXRvcjxPYmplY3Q+KSBldmVudC5pdGVtcygpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAibGlzdCBsaXN0ZW5lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZENlbGxMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBBV1RQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyV3JhcHBlcih0aGlzLmJ1aWxkQ2VsbExpc3RlbmVyXygpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZENlbGxMaXN0ZW5lcl8oKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlUYWJsZU1vZGVsQWRhcHRlci50aGlzLmNlbGxDaGFuZ2VkKChXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+KSBldmVudC5nZXRTb3VyY2UoKSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJjZWxsIGxpc3RlbmVyIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogVGFibGVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgaW50IGdldENvbHVtbkNvdW50KCkgewotCQlyZXR1cm4gdGhpcy5jb2x1bW5BZGFwdGVyLmNvbHVtbkNvdW50KCk7Ci0JfQotCi0JcHVibGljIGludCBnZXRSb3dDb3VudCgpIHsKLQkJcmV0dXJuIHRoaXMucm93cy5zaXplKCk7Ci0JfQotCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyBnZXRDb2x1bW5OYW1lKGludCBjb2x1bW4pIHsKLQkJcmV0dXJuIHRoaXMuY29sdW1uQWRhcHRlci5jb2x1bW5OYW1lKGNvbHVtbik7Ci0JfQotCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIENsYXNzPD8+IGdldENvbHVtbkNsYXNzKGludCBjb2x1bW5JbmRleCkgewotCQlyZXR1cm4gdGhpcy5jb2x1bW5BZGFwdGVyLmNvbHVtbkNsYXNzKGNvbHVtbkluZGV4KTsKLQl9Ci0KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgYm9vbGVhbiBpc0NlbGxFZGl0YWJsZShpbnQgcm93SW5kZXgsIGludCBjb2x1bW5JbmRleCkgewotCQlyZXR1cm4gdGhpcy5jb2x1bW5BZGFwdGVyLmNvbHVtbklzRWRpdGFibGUoY29sdW1uSW5kZXgpOwotCX0KLQotCXB1YmxpYyBPYmplY3QgZ2V0VmFsdWVBdChpbnQgcm93SW5kZXgsIGludCBjb2x1bW5JbmRleCkgewotCQlXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+W10gcm93ID0gdGhpcy5yb3dzLmdldChyb3dJbmRleCk7Ci0JCXJldHVybiByb3dbY29sdW1uSW5kZXhdLmdldFZhbHVlKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgc2V0VmFsdWVBdChPYmplY3QgdmFsdWUsIGludCByb3dJbmRleCwgaW50IGNvbHVtbkluZGV4KSB7Ci0JCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD5bXSByb3cgPSB0aGlzLnJvd3MuZ2V0KHJvd0luZGV4KTsKLQkJcm93W2NvbHVtbkluZGV4XS5zZXRWYWx1ZSh2YWx1ZSk7Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0YXJ0IGxpc3RlbmluZyB0byB0aGUgdW5kZXJseWluZyBtb2RlbCBpZiBuZWNlc3NhcnkuCi0JICovCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgYWRkVGFibGVNb2RlbExpc3RlbmVyKFRhYmxlTW9kZWxMaXN0ZW5lciBsKSB7Ci0JCWlmICh0aGlzLmhhc05vVGFibGVNb2RlbExpc3RlbmVycygpKSB7Ci0JCQl0aGlzLmVuZ2FnZU1vZGVsKCk7Ci0JCX0KLQkJc3VwZXIuYWRkVGFibGVNb2RlbExpc3RlbmVyKGwpOwotCX0KLQotCS8qKgotCSAqIEV4dGVuZCB0byBzdG9wIGxpc3RlbmluZyB0byB0aGUgdW5kZXJseWluZyBtb2RlbCBpZiBuZWNlc3NhcnkuCi0JICovCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgcmVtb3ZlVGFibGVNb2RlbExpc3RlbmVyKFRhYmxlTW9kZWxMaXN0ZW5lciBsKSB7Ci0JCXN1cGVyLnJlbW92ZVRhYmxlTW9kZWxMaXN0ZW5lcihsKTsKLQkJaWYgKHRoaXMuaGFzTm9UYWJsZU1vZGVsTGlzdGVuZXJzKCkpIHsKLQkJCXRoaXMuZGlzZW5nYWdlTW9kZWwoKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBwdWJsaWMgQVBJICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB0aGUgdW5kZXJseWluZyBsaXN0IG1vZGVsLgotCSAqLwotCXB1YmxpYyBMaXN0VmFsdWVNb2RlbDw/IGV4dGVuZHMgRT4gZ2V0TW9kZWwoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3RIb2xkZXI7Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSB1bmRlcmx5aW5nIGxpc3QgbW9kZWwuCi0JICovCi0JcHVibGljIHZvaWQgc2V0TW9kZWwoTGlzdFZhbHVlTW9kZWw8RT4gbGlzdEhvbGRlcikgewotCQlpZiAobGlzdEhvbGRlciA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQlib29sZWFuIGhhc0xpc3RlbmVycyA9IHRoaXMuaGFzVGFibGVNb2RlbExpc3RlbmVycygpOwotCQlpZiAoaGFzTGlzdGVuZXJzKSB7Ci0JCQl0aGlzLmRpc2VuZ2FnZU1vZGVsKCk7Ci0JCX0KLQkJdGhpcy5saXN0SG9sZGVyID0gbGlzdEhvbGRlcjsKLQkJaWYgKGhhc0xpc3RlbmVycykgewotCQkJdGhpcy5lbmdhZ2VNb2RlbCgpOwotCQkJdGhpcy5maXJlVGFibGVEYXRhQ2hhbmdlZCgpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSB1bmRlcmx5aW5nIGNvbGxlY3Rpb24gbW9kZWwuCi0JICovCi0JcHVibGljIHZvaWQgc2V0TW9kZWwoQ29sbGVjdGlvblZhbHVlTW9kZWw8RT4gY29sbGVjdGlvbkhvbGRlcikgewotCQl0aGlzLnNldE1vZGVsKG5ldyBDb2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyPEU+KGNvbGxlY3Rpb25Ib2xkZXIpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogcXVlcmllcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGlzIG1vZGVsIGhhcyBubyBsaXN0ZW5lcnMuCi0JICovCi0JcHJvdGVjdGVkIGJvb2xlYW4gaGFzTm9UYWJsZU1vZGVsTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gdGhpcy5saXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJDb3VudChUYWJsZU1vZGVsTGlzdGVuZXIuY2xhc3MpID09IDA7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhpcyBtb2RlbCBoYXMgYW55IGxpc3RlbmVycy4KLQkgKi8KLQlwcm90ZWN0ZWQgYm9vbGVhbiBoYXNUYWJsZU1vZGVsTGlzdGVuZXJzKCkgewotCQlyZXR1cm4gISB0aGlzLmhhc05vVGFibGVNb2RlbExpc3RlbmVycygpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBTdGFydCBsaXN0ZW5pbmcgdG8gdGhlIGxpc3Qgb2Ygb2JqZWN0cyBhbmQgdGhlIHZhcmlvdXMgYXNwZWN0cwotCSAqIG9mIHRoZSBvYmplY3RzIHRoYXQgbWFrZSB1cCB0aGUgcm93cy4KLQkgKi8KLQlwcml2YXRlIHZvaWQgZW5nYWdlTW9kZWwoKSB7Ci0JCXRoaXMubGlzdEhvbGRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMubGlzdENoYW5nZUxpc3RlbmVyKTsKLQkJdGhpcy5lbmdhZ2VBbGxDZWxscygpOwotCX0KLQotCS8qKgotCSAqIENvbnZlcnQgdGhlIG9iamVjdHMgaW50byByb3dzIGFuZCBsaXN0ZW4gdG8gdGhlIGNlbGxzLgotCSAqLwotCXByaXZhdGUgdm9pZCBlbmdhZ2VBbGxDZWxscygpIHsKLQkJdGhpcy5yb3dzLmVuc3VyZUNhcGFjaXR5KHRoaXMubGlzdEhvbGRlci5zaXplKCkpOwotCQlmb3IgKEl0ZXJhdG9yPD8gZXh0ZW5kcyBFPiBzdHJlYW0gPSB0aGlzLmxpc3RIb2xkZXIuaXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQlXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+W10gcm93ID0gdGhpcy5jb2x1bW5BZGFwdGVyLmNlbGxNb2RlbHMoc3RyZWFtLm5leHQoKSk7Ci0JCQl0aGlzLmVuZ2FnZVJvdyhyb3cpOwotCQkJdGhpcy5yb3dzLmFkZChyb3cpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogTGlzdGVuIHRvIHRoZSBjZWxscyBpbiB0aGUgc3BlY2lmaWVkIHJvdy4KLQkgKi8KLQlwcml2YXRlIHZvaWQgZW5nYWdlUm93KFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD5bXSByb3cpIHsKLQkJZm9yIChpbnQgaSA9IHJvdy5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJcm93W2ldLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmNlbGxMaXN0ZW5lcik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBTdG9wIGxpc3RlbmluZy4KLQkgKi8KLQlwcml2YXRlIHZvaWQgZGlzZW5nYWdlTW9kZWwoKSB7Ci0JCXRoaXMuZGlzZW5nYWdlQWxsQ2VsbHMoKTsKLQkJdGhpcy5saXN0SG9sZGVyLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5saXN0Q2hhbmdlTGlzdGVuZXIpOwotCX0KLQotCXByaXZhdGUgdm9pZCBkaXNlbmdhZ2VBbGxDZWxscygpIHsKLQkJZm9yIChXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+W10gcm93IDogdGhpcy5yb3dzKSB7Ci0JCQl0aGlzLmRpc2VuZ2FnZVJvdyhyb3cpOwotCQl9Ci0JCXRoaXMucm93cy5jbGVhcigpOwotCX0KLQotCXByaXZhdGUgdm9pZCBkaXNlbmdhZ2VSb3coV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PltdIHJvdykgewotCQlmb3IgKGludCBpID0gcm93Lmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlyb3dbaV0ucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMuY2VsbExpc3RlbmVyKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIGJydXRlLWZvcmNlIHNlYXJjaCBmb3IgdGhlIGNlbGwocykgdGhhdCBjaGFuZ2VkLi4uCi0JICovCi0Jdm9pZCBjZWxsQ2hhbmdlZChXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IGNlbGxIb2xkZXIpIHsKLQkJZm9yIChpbnQgaSA9IHRoaXMucm93cy5zaXplKCk7IGktLSA+IDA7ICkgewotCQkJV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PltdIHJvdyA9IHRoaXMucm93cy5nZXQoaSk7Ci0JCQlmb3IgKGludCBqID0gcm93Lmxlbmd0aDsgai0tID4gMDsgKSB7Ci0JCQkJaWYgKHJvd1tqXSA9PSBjZWxsSG9sZGVyKSB7Ci0JCQkJCXRoaXMuZmlyZVRhYmxlQ2VsbFVwZGF0ZWQoaSwgaik7Ci0JCQkJfQotCQkJfQotCQl9Ci0JfQotCi0JLyoqCi0JICogY29udmVydCB0aGUgaXRlbXMgdG8gcm93cwotCSAqLwotCXZvaWQgYWRkUm93cyhpbnQgaW5kZXgsIGludCBzaXplLCBJdGVyYXRvcjxPYmplY3Q+IGl0ZW1zKSB7Ci0JCUxpc3Q8V3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PltdPiBuZXdSb3dzID0gbmV3IEFycmF5TGlzdDxXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+W10+KHNpemUpOwotCQl3aGlsZSAoaXRlbXMuaGFzTmV4dCgpKSB7Ci0JCQlXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+W10gcm93ID0gdGhpcy5jb2x1bW5BZGFwdGVyLmNlbGxNb2RlbHMoaXRlbXMubmV4dCgpKTsKLQkJCXRoaXMuZW5nYWdlUm93KHJvdyk7Ci0JCQluZXdSb3dzLmFkZChyb3cpOwotCQl9Ci0JCXRoaXMucm93cy5hZGRBbGwoaW5kZXgsIG5ld1Jvd3MpOwotCQl0aGlzLmZpcmVUYWJsZVJvd3NJbnNlcnRlZChpbmRleCwgaW5kZXggKyBzaXplIC0gMSk7Ci0JfQotCi0Jdm9pZCByZW1vdmVSb3dzKGludCBpbmRleCwgaW50IHNpemUpIHsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBzaXplOyBpKyspIHsKLQkJCXRoaXMuZGlzZW5nYWdlUm93KHRoaXMucm93cy5yZW1vdmUoaW5kZXgpKTsKLQkJfQotCQl0aGlzLmZpcmVUYWJsZVJvd3NEZWxldGVkKGluZGV4LCBpbmRleCArIHNpemUgLSAxKTsKLQl9Ci0KLQl2b2lkIHJlcGxhY2VSb3dzKGludCBpbmRleCwgSXRlcmF0b3I8T2JqZWN0PiBpdGVtcykgewotCQlpbnQgaSA9IGluZGV4OwotCQl3aGlsZSAoaXRlbXMuaGFzTmV4dCgpKSB7Ci0JCQlXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+W10gcm93ID0gdGhpcy5yb3dzLmdldChpKTsKLQkJCXRoaXMuZGlzZW5nYWdlUm93KHJvdyk7Ci0JCQlyb3cgPSB0aGlzLmNvbHVtbkFkYXB0ZXIuY2VsbE1vZGVscyhpdGVtcy5uZXh0KCkpOwotCQkJdGhpcy5lbmdhZ2VSb3cocm93KTsKLQkJCXRoaXMucm93cy5zZXQoaSwgcm93KTsKLQkJCWkrKzsKLQkJfQotCQl0aGlzLmZpcmVUYWJsZVJvd3NVcGRhdGVkKGluZGV4LCBpIC0gMSk7Ci0JfQotCi0Jdm9pZCBtb3ZlUm93cyhpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCwgaW50IGxlbmd0aCkgewotCQlBcnJheUxpc3Q8V3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PltdPiB0ZW1wID0gbmV3IEFycmF5TGlzdDxXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+W10+KGxlbmd0aCk7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuZ3RoOyBpKyspIHsKLQkJCXRlbXAuYWRkKHRoaXMucm93cy5yZW1vdmUoc291cmNlSW5kZXgpKTsKLQkJfQotCQl0aGlzLnJvd3MuYWRkQWxsKHRhcmdldEluZGV4LCB0ZW1wKTsKLQotCQlpbnQgc3RhcnQgPSBNYXRoLm1pbih0YXJnZXRJbmRleCwgc291cmNlSW5kZXgpOwotCQlpbnQgZW5kID0gTWF0aC5tYXgodGFyZ2V0SW5kZXgsIHNvdXJjZUluZGV4KSArIGxlbmd0aCAtIDE7Ci0JCXRoaXMuZmlyZVRhYmxlUm93c1VwZGF0ZWQoc3RhcnQsIGVuZCk7Ci0JfQotCi0Jdm9pZCBjbGVhclRhYmxlKCkgewotCQl0aGlzLmRpc2VuZ2FnZUFsbENlbGxzKCk7Ci0JCXRoaXMuZmlyZVRhYmxlRGF0YUNoYW5nZWQoKTsKLQl9Ci0KLQl2b2lkIHJlYnVpbGRUYWJsZSgpIHsKLQkJdGhpcy5kaXNlbmdhZ2VBbGxDZWxscygpOwotCQl0aGlzLmVuZ2FnZUFsbENlbGxzKCk7Ci0JCXRoaXMuZmlyZVRhYmxlRGF0YUNoYW5nZWQoKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9Ub2dnbGVCdXR0b25Nb2RlbEFkYXB0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9Ub2dnbGVCdXR0b25Nb2RlbEFkYXB0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggN2MwZTc0Mi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvVG9nZ2xlQnV0dG9uTW9kZWxBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyMjQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZzsKLQotaW1wb3J0IGphdmEuYXd0LmV2ZW50LkFjdGlvbkxpc3RlbmVyOwotaW1wb3J0IGphdmEuYXd0LmV2ZW50Lkl0ZW1MaXN0ZW5lcjsKLWltcG9ydCBqYXZheC5zd2luZy5KVG9nZ2xlQnV0dG9uLlRvZ2dsZUJ1dHRvbk1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLmxpc3RlbmVyLmF3dC5BV1RQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyV3JhcHBlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Qcm9wZXJ0eUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIFRoaXMgamF2YXguc3dpbmcuQnV0dG9uTW9kZWwgY2FuIGJlIHVzZWQgdG8ga2VlcCBhIGxpc3RlbmVyCi0gKiAoZS5nLiBhIEpDaGVja0JveCBvciBhIEpSYWRpb0J1dHRvbikgaW4gc3luY2ggd2l0aCBhIFByb3BlcnR5VmFsdWVNb2RlbAotICogb24gYSBib29sZWFuLgotICovCi1wdWJsaWMgY2xhc3MgVG9nZ2xlQnV0dG9uTW9kZWxBZGFwdGVyCi0JZXh0ZW5kcyBUb2dnbGVCdXR0b25Nb2RlbAotewotCS8qKgotCSAqIFRoZSBkZWZhdWx0IHNldHRpbmcgZm9yIHRoZSB0b2dnbGUgYnV0dG9uOyBmb3Igd2hlbiB0aGUgdW5kZXJseWluZyBtb2RlbCBpcyBudWxsLgotCSAqIFRoZSBkZWZhdWx0IFtkZWZhdWx0IHZhbHVlXSBpcyBmYWxzZSAoaS5lLiB0aGUgdG9nZ2xlIGJ1dHRvbiBpcyB1bmNoZWNrZWQvZW1wdHkpLgotCSAqLwotCXByb3RlY3RlZCBmaW5hbCBib29sZWFuIGRlZmF1bHRWYWx1ZTsKLQotCS8qKiBBIHZhbHVlIG1vZGVsIG9uIHRoZSB1bmRlcmx5aW5nIG1vZGVsIGJvb2xlYW4uICovCi0JcHJvdGVjdGVkIGZpbmFsIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJvb2xlYW5Ib2xkZXI7Ci0KLQkvKioKLQkgKiBBIGxpc3RlbmVyIHRoYXQgYWxsb3dzIHVzIHRvIHN5bmNocm9uaXplIHdpdGgKLQkgKiBjaGFuZ2VzIG1hZGUgdG8gdGhlIHVuZGVybHlpbmcgbW9kZWwgYm9vbGVhbi4KLQkgKi8KLQlwcm90ZWN0ZWQgZmluYWwgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBib29sZWFuQ2hhbmdlTGlzdGVuZXI7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdG9yIC0gdGhlIGJvb2xlYW4gaG9sZGVyIGlzIHJlcXVpcmVkLgotCSAqLwotCXB1YmxpYyBUb2dnbGVCdXR0b25Nb2RlbEFkYXB0ZXIoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYm9vbGVhbkhvbGRlciwgYm9vbGVhbiBkZWZhdWx0VmFsdWUpIHsKLQkJc3VwZXIoKTsKLQkJaWYgKGJvb2xlYW5Ib2xkZXIgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCX0KLQkJdGhpcy5ib29sZWFuSG9sZGVyID0gYm9vbGVhbkhvbGRlcjsKLQkJdGhpcy5ib29sZWFuQ2hhbmdlTGlzdGVuZXIgPSB0aGlzLmJ1aWxkQm9vbGVhbkNoYW5nZUxpc3RlbmVyKCk7Ci0JCS8vIHBvc3Rwb25lIGxpc3RlbmluZyB0byB0aGUgdW5kZXJseWluZyBtb2RlbAotCQkvLyB1bnRpbCB3ZSBoYXZlIGxpc3RlbmVycyBvdXJzZWx2ZXMuLi4KLQkJdGhpcy5kZWZhdWx0VmFsdWUgPSBkZWZhdWx0VmFsdWU7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0b3IgLSB0aGUgYm9vbGVhbiBob2xkZXIgaXMgcmVxdWlyZWQuCi0JICogVGhlIGRlZmF1bHQgdmFsdWUgd2lsbCBiZSBmYWxzZS4KLQkgKi8KLQlwdWJsaWMgVG9nZ2xlQnV0dG9uTW9kZWxBZGFwdGVyKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJvb2xlYW5Ib2xkZXIpIHsKLQkJdGhpcyhib29sZWFuSG9sZGVyLCBmYWxzZSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkQm9vbGVhbkNoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IEFXVFByb3BlcnR5Q2hhbmdlTGlzdGVuZXJXcmFwcGVyKHRoaXMuYnVpbGRCb29sZWFuQ2hhbmdlTGlzdGVuZXJfKCkpOwotCX0KLQotCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkQm9vbGVhbkNoYW5nZUxpc3RlbmVyXygpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlUb2dnbGVCdXR0b25Nb2RlbEFkYXB0ZXIudGhpcy5ib29sZWFuQ2hhbmdlZChldmVudCk7Ci0JCQl9Ci0JCSAgICBAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJib29sZWFuIGxpc3RlbmVyIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogQnV0dG9uTW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JLyoqCi0JICogRXh0ZW5kIHRvIHVwZGF0ZSB0aGUgdW5kZXJseWluZyBtb2RlbCBpZiBuZWNlc3NhcnkuCi0JICovCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgc2V0U2VsZWN0ZWQoYm9vbGVhbiBiKSB7Ci0JCWlmICh0aGlzLmlzU2VsZWN0ZWQoKSAhPSBiKSB7CS8vIHN0b3AgdGhlIHJlY3Vyc2lvbiEKLQkJCXN1cGVyLnNldFNlbGVjdGVkKGIpOy8vcHV0IHRoZSBzdXBlciBjYWxsIGZpcnN0LCBvdGhlcndpc2UgdGhlIGZvbGxvd2luZyBnZXRzIGNhbGxlZCB0d2ljZQotCQkJdGhpcy5ib29sZWFuSG9sZGVyLnNldFZhbHVlKEJvb2xlYW4udmFsdWVPZihiKSk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSB1bmRlcmx5aW5nIG1vZGVsIGlmIG5lY2Vzc2FyeS4KLQkgKi8KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBhZGRBY3Rpb25MaXN0ZW5lcihBY3Rpb25MaXN0ZW5lciBsKSB7Ci0JCWlmICh0aGlzLmhhc05vTGlzdGVuZXJzKCkpIHsKLQkJCXRoaXMuZW5nYWdlTW9kZWwoKTsKLQkJfQotCQlzdXBlci5hZGRBY3Rpb25MaXN0ZW5lcihsKTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RvcCBsaXN0ZW5pbmcgdG8gdGhlIHVuZGVybHlpbmcgbW9kZWwgaWYgYXBwcm9wcmlhdGUuCi0JICovCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgcmVtb3ZlQWN0aW9uTGlzdGVuZXIoQWN0aW9uTGlzdGVuZXIgbCkgewotCQlzdXBlci5yZW1vdmVBY3Rpb25MaXN0ZW5lcihsKTsKLQkJaWYgKHRoaXMuaGFzTm9MaXN0ZW5lcnMoKSkgewotCQkJdGhpcy5kaXNlbmdhZ2VNb2RlbCgpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0YXJ0IGxpc3RlbmluZyB0byB0aGUgdW5kZXJseWluZyBtb2RlbCBpZiBuZWNlc3NhcnkuCi0JICovCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgYWRkSXRlbUxpc3RlbmVyKEl0ZW1MaXN0ZW5lciBsKSB7Ci0JCWlmICh0aGlzLmhhc05vTGlzdGVuZXJzKCkpIHsKLQkJCXRoaXMuZW5nYWdlTW9kZWwoKTsKLQkJfQotCQlzdXBlci5hZGRJdGVtTGlzdGVuZXIobCk7Ci0JfQotCi0JLyoqCi0JICogRXh0ZW5kIHRvIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSB1bmRlcmx5aW5nIG1vZGVsIGlmIGFwcHJvcHJpYXRlLgotCSAqLwotICAgIEBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHJlbW92ZUl0ZW1MaXN0ZW5lcihJdGVtTGlzdGVuZXIgbCkgewotCQlzdXBlci5yZW1vdmVJdGVtTGlzdGVuZXIobCk7Ci0JCWlmICh0aGlzLmhhc05vTGlzdGVuZXJzKCkpIHsKLQkJCXRoaXMuZGlzZW5nYWdlTW9kZWwoKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIEV4dGVuZCB0byBzdGFydCBsaXN0ZW5pbmcgdG8gdGhlIHVuZGVybHlpbmcgbW9kZWwgaWYgbmVjZXNzYXJ5LgotCSAqLwotICAgIEBPdmVycmlkZQotCXB1YmxpYyB2b2lkIGFkZENoYW5nZUxpc3RlbmVyKENoYW5nZUxpc3RlbmVyIGwpIHsKLQkJaWYgKHRoaXMuaGFzTm9MaXN0ZW5lcnMoKSkgewotCQkJdGhpcy5lbmdhZ2VNb2RlbCgpOwotCQl9Ci0JCXN1cGVyLmFkZENoYW5nZUxpc3RlbmVyKGwpOwotCX0KLQotCS8qKgotCSAqIEV4dGVuZCB0byBzdG9wIGxpc3RlbmluZyB0byB0aGUgdW5kZXJseWluZyBtb2RlbCBpZiBhcHByb3ByaWF0ZS4KLQkgKi8KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCByZW1vdmVDaGFuZ2VMaXN0ZW5lcihDaGFuZ2VMaXN0ZW5lciBsKSB7Ci0JCXN1cGVyLnJlbW92ZUNoYW5nZUxpc3RlbmVyKGwpOwotCQlpZiAodGhpcy5oYXNOb0xpc3RlbmVycygpKSB7Ci0JCQl0aGlzLmRpc2VuZ2FnZU1vZGVsKCk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogcXVlcmllcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB3ZSBoYXZlIG5vIGxpc3RlbmVycyBhdCBhbGwuCi0JICovCi0JcHJvdGVjdGVkIGJvb2xlYW4gaGFzTm9MaXN0ZW5lcnMoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3RlbmVyTGlzdC5nZXRMaXN0ZW5lckNvdW50KCkgPT0gMDsKLQl9Ci0KLQlwcm90ZWN0ZWQgYm9vbGVhbiBnZXREZWZhdWx0VmFsdWUoKSB7Ci0JCXJldHVybiB0aGlzLmRlZmF1bHRWYWx1ZTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYmVoYXZpb3IgKioqKioqKioqKgotCi0JLyoqCi0JICogU3luY2hyb25pemUgd2l0aCB0aGUgc3BlY2lmaWVkIHZhbHVlLgotCSAqIElmIGl0IGlzIG51bGwsIHVzZSB0aGUgZGVmYXVsdCB2YWx1ZSAod2hpY2ggaXMgdHlwaWNhbGx5IGZhbHNlKS4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBzZXRTZWxlY3RlZChCb29sZWFuIHZhbHVlKSB7Ci0JCWlmICh2YWx1ZSA9PSBudWxsKSB7Ci0JCQl0aGlzLnNldFNlbGVjdGVkKHRoaXMuZ2V0RGVmYXVsdFZhbHVlKCkpOwotCQl9IGVsc2UgewotCQkJdGhpcy5zZXRTZWxlY3RlZCh2YWx1ZS5ib29sZWFuVmFsdWUoKSk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBUaGUgdW5kZXJseWluZyBtb2RlbCBoYXMgY2hhbmdlZCAtIHN5bmNocm9uaXplIGFjY29yZGluZ2x5LgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGJvb2xlYW5DaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5zZXRTZWxlY3RlZCgoQm9vbGVhbikgZXZlbnQuZ2V0TmV3VmFsdWUoKSk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZW5nYWdlTW9kZWwoKSB7Ci0JCXRoaXMuYm9vbGVhbkhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5ib29sZWFuQ2hhbmdlTGlzdGVuZXIpOwotCQl0aGlzLnNldFNlbGVjdGVkKHRoaXMuYm9vbGVhbkhvbGRlci5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VNb2RlbCgpIHsKLQkJdGhpcy5ib29sZWFuSG9sZGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmJvb2xlYW5DaGFuZ2VMaXN0ZW5lcik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHN0YW5kYXJkIG1ldGhvZHMgKioqKioqKioqKgotCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5ib29sZWFuSG9sZGVyKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9UcmVlTW9kZWxBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvVHJlZU1vZGVsQWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmOTRhNzIzLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9UcmVlTW9kZWxBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw3MjIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZzsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLklkZW50aXR5SGFzaE1hcDsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuVHJlZU1vZGVsTGlzdGVuZXI7Ci1pbXBvcnQgamF2YXguc3dpbmcudHJlZS5UcmVlUGF0aDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5saXN0ZW5lci5hd3QuQVdUTGlzdENoYW5nZUxpc3RlbmVyV3JhcHBlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5saXN0ZW5lci5hd3QuQVdUUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcldyYXBwZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwubGlzdGVuZXIuYXd0LkFXVFN0YXRlQ2hhbmdlTGlzdGVuZXJXcmFwcGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlN0YXRpY1Byb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5MaXN0Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5TdGF0ZUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkxpc3RDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlN0YXRlQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlRyZWVOb2RlVmFsdWVNb2RlbDsKLQotLyoqCi0gKiBUaGlzIGphdmF4LnN3aW5nLnRyZWUuVHJlZU1vZGVsIGNhbiBiZSB1c2VkIHRvIGtlZXAgYSBUcmVlTW9kZWxMaXN0ZW5lcgotICogKGUuZy4gYSBKVHJlZSkgaW4gc3luY2ggd2l0aCBhIHRyZWUgb2YgVHJlZU5vZGVWYWx1ZU1vZGVsIG9iamVjdHMuIFVubGlrZQotICogamF2YXguc3dpbmcudHJlZS5EZWZhdWx0VHJlZU1vZGVsLCB5b3UgZG8gbm90IGFkZCBhbmQgcmVtb3ZlIG5vZGVzIHdpdGgKLSAqIG1ldGhvZHMgaW1wbGVtZW50ZWQgaGVyZS4gWW91IGNhbiBhZGQgYW5kIHJlbW92ZSBub2RlcyBieSBhZGRpbmcgYW5kCi0gKiByZW1vdmluZyB0aGVtIGRpcmVjdGx5IHRvL2Zyb20gdGhlIG5vZGVzIChvciwgbW9yZSB0eXBpY2FsbHksIHRoZSBkb21haW4KLSAqIG9iamVjdHMgdGhlIG5vZGVzIGFyZSB3cmFwcGluZyBhbmQgbGlzdGVuaW5nIHRvKS4KLSAqIAotICogRHVlIHRvIGxpbWl0YXRpb25zIGluIEpUcmVlLCB0aGUgcm9vdCBvZiB0aGUgdHJlZSBjYW4gbmV2ZXIgYmUgbnVsbCwKLSAqIHdoaWNoLCB0eXBpY2FsbHksIHNob3VsZCBub3QgYmUgYSBwcm9ibGVtLiAoSWYgeW91IHdhbnQgdG8gZGlzcGxheSBhbiBlbXB0eQotICogdHJlZSB5b3UgY2FuIHNldCB0aGUgSlRyZWUncyB0cmVlTW9kZWwgdG8gbnVsbC4pCi0gKi8KLXB1YmxpYyBjbGFzcyBUcmVlTW9kZWxBZGFwdGVyPFQ+Ci0JZXh0ZW5kcyBBYnN0cmFjdFRyZWVNb2RlbAotewotCS8qKgotCSAqIEEgdmFsdWUgbW9kZWwgb24gdGhlIHVuZGVybHlpbmcgdHJlZSdzIHJvb3Qgbm9kZSBhbmQgaXRzCi0JICogY29ycmVzcG9uZGluZyBsaXN0ZW5lci4gVGhpcyBhbGxvd3MgY2xpZW50cyB0byBzd2FwIG91dAotCSAqIHRoZSBlbnRpcmUgdHJlZS4gRHVlIHRvIGxpbWl0YXRpb25zIGluIEpUcmVlLCB0aGUgcm9vdCBzaG91bGQKLQkgKiBuZXZlciBiZSBzZXQgdG8gbnVsbCB3aGlsZSB3ZSBoYXZlIGxpc3RlbmVycy4KLQkgKi8KLQlwcml2YXRlIGZpbmFsIFByb3BlcnR5VmFsdWVNb2RlbDxUcmVlTm9kZVZhbHVlTW9kZWw8VD4+IHJvb3RIb2xkZXI7Ci0JcHJpdmF0ZSBmaW5hbCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIHJvb3RMaXN0ZW5lcjsKLQotCS8qKgotCSAqIEEgbGlzdGVuZXIgdGhhdCBub3RpZmllcyB1cyB3aGVuIGEgbm9kZSdzIGludGVybmFsCi0JICogInN0YXRlIiBjaGFuZ2VzIChhcyBvcHBvc2VkIHRvIHRoZSBub2RlJ3MgdmFsdWUgb3IgbGlzdCBvZgotCSAqIGNoaWxkcmVuKSwgYWxsb3dpbmcgdXMgdG8gZm9yd2FyZCBub3RpZmljYXRpb24gdG8gb3VyIGxpc3RlbmVycy4KLQkgKi8KLQlwcml2YXRlIGZpbmFsIFN0YXRlQ2hhbmdlTGlzdGVuZXIgbm9kZVN0YXRlTGlzdGVuZXI7Ci0KLQkvKioKLQkgKiBBIGxpc3RlbmVyIHRoYXQgbm90aWZpZXMgdXMgd2hlbiBhIG5vZGUncyAidmFsdWUiCi0JICogY2hhbmdlcyAoYXMgb3Bwb3NlZCB0byB0aGUgbm9kZSdzIHN0YXRlIG9yIGxpc3Qgb2YKLQkgKiBjaGlsZHJlbiksIGFsbG93aW5nIHVzIHRvIGZvcndhcmQgbm90aWZpY2F0aW9uIHRvIG91ciBsaXN0ZW5lcnMuCi0JICogVHlwaWNhbGx5LCB0aGlzIHdpbGwgb25seSBoYXBwZW4gd2l0aCBub2RlcyB0aGF0IGhvbGQKLQkgKiBwcmltaXRpdmUgZGF0YS4KLQkgKi8KLQlwcml2YXRlIGZpbmFsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbm9kZVZhbHVlTGlzdGVuZXI7Ci0KLQkvKioKLQkgKiBBIGxpc3RlbmVyIHRoYXQgbm90aWZpZXMgdXMgd2hlbiBhbiB1bmRlcmx5aW5nIG5vZGUncwotCSAqICJsaXN0IiBvZiBjaGlsZHJlbiBjaGFuZ2VzLCBhbGxvd2luZyB1cyB0byBrZWVwIG91cgotCSAqIGludGVybmFsIHRyZWUgaW4gc3luY2ggd2l0aCB0aGUgdW5kZXJseWluZyB0cmVlIG1vZGVsLgotCSAqLwotCXByaXZhdGUgZmluYWwgTGlzdENoYW5nZUxpc3RlbmVyIGNoaWxkcmVuTGlzdGVuZXI7Ci0KLQkvKiB0aGVzZSBhdHRyaWJ1dGVzIG1ha2UgdXAgb3VyIGludGVybmFsIHRyZWUgKi8KLQkvKioKLQkgKiBUaGUgcm9vdCBjYW5ub3QgYmUgbnVsbCB3aGlsZSB3ZSBoYXZlIGxpc3RlbmVycywgd2hpY2ggaXMKLQkgKiBtb3N0IG9mIHRoZSB0aW1lLiBUaGUgcm9vdCBpcyBjYWNoZWQgc28gd2UgY2FuIGRpc2VuZ2FnZQotCSAqIGZyb20gaXQgd2hlbiBpdCBoYXMgYmVlbiBzd2FwcGVkIG91dC4KLQkgKi8KLQlwcml2YXRlIFRyZWVOb2RlVmFsdWVNb2RlbDxUPiByb290OwotCi0JLyoqCi0JICogTWFwIHRoZSBub2RlcyB0byB0aGVpciBsaXN0cyBvZiBjaGlsZHJlbi4KLQkgKiBXZSBjYWNoZSB0aGVzZSBzbyB3ZSBjYW4gc3dhcCBvdXQgdGhlIGVudGlyZSBsaXN0IG9mIGNoaWxkcmVuCi0JICogd2hlbiB3ZSByZWNlaXZlIGEgI2xpc3RDaGFuZ2VkKCkgZXZlbnQgKHdoaWNoIGRvZXMgbm90IGluY2x1ZGUKLQkgKiB0aGUgaXRlbXMgdGhhdCB3ZXJlIGFmZmVjdGVkKS4KLQkgKiBAc2VlIEV2ZW50Q2hhbmdlUG9saWN5I3JlYnVpbGRDaGlsZHJlbigpCi0JICovCi0JZmluYWwgSWRlbnRpdHlIYXNoTWFwPFRyZWVOb2RlVmFsdWVNb2RlbDxUPiwgTGlzdDxUcmVlTm9kZVZhbHVlTW9kZWw8VD4+PiBjaGlsZHJlbkxpc3RzOwotCi0JLyoqCi0JICogTWFwIHRoZSBjaGlsZHJlbiBtb2RlbHMgdG8gdGhlaXIgcGFyZW50cy4KLQkgKiBXZSBjYWNoZSB0aGVzZSBzbyB3ZSBjYW4gZmlndXJlIG91dCB0aGUgInJlYWwiIHNvdXJjZSBvZiB0aGUKLQkgKiBsaXN0IGNoYW5nZSBldmVudHMgKHRoZSBwYXJlbnQpLgotCSAqIEBzZWUgRXZlbnRDaGFuZ2VQb2xpY3kjcGFyZW50KCkKLQkgKi8KLQlmaW5hbCBJZGVudGl0eUhhc2hNYXA8TGlzdFZhbHVlTW9kZWw8VHJlZU5vZGVWYWx1ZU1vZGVsPFQ+PiwgVHJlZU5vZGVWYWx1ZU1vZGVsPFQ+PiBwYXJlbnRzOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSB0cmVlIG1vZGVsIGZvciB0aGUgc3BlY2lmaWVkIHJvb3QuCi0JICovCi0JcHVibGljIFRyZWVNb2RlbEFkYXB0ZXIoUHJvcGVydHlWYWx1ZU1vZGVsPFRyZWVOb2RlVmFsdWVNb2RlbDxUPj4gcm9vdEhvbGRlcikgewotCQlzdXBlcigpOwotCQlpZiAocm9vdEhvbGRlciA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLnJvb3RIb2xkZXIgPSByb290SG9sZGVyOwotCQl0aGlzLnJvb3RMaXN0ZW5lciA9IHRoaXMuYnVpbGRSb290TGlzdGVuZXIoKTsKLQkJdGhpcy5ub2RlU3RhdGVMaXN0ZW5lciA9IHRoaXMuYnVpbGROb2RlU3RhdGVMaXN0ZW5lcigpOwotCQl0aGlzLm5vZGVWYWx1ZUxpc3RlbmVyID0gdGhpcy5idWlsZE5vZGVWYWx1ZUxpc3RlbmVyKCk7Ci0JCXRoaXMuY2hpbGRyZW5MaXN0ZW5lciA9IHRoaXMuYnVpbGRDaGlsZHJlbkxpc3RlbmVyKCk7Ci0JCXRoaXMuY2hpbGRyZW5MaXN0cyA9IG5ldyBJZGVudGl0eUhhc2hNYXA8VHJlZU5vZGVWYWx1ZU1vZGVsPFQ+LCBMaXN0PFRyZWVOb2RlVmFsdWVNb2RlbDxUPj4+KCk7Ci0JCXRoaXMucGFyZW50cyA9IG5ldyBJZGVudGl0eUhhc2hNYXA8TGlzdFZhbHVlTW9kZWw8VHJlZU5vZGVWYWx1ZU1vZGVsPFQ+PiwgVHJlZU5vZGVWYWx1ZU1vZGVsPFQ+PigpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHRyZWUgbW9kZWwgZm9yIHRoZSBzcGVjaWZpZWQgcm9vdC4KLQkgKi8KLQlwdWJsaWMgVHJlZU1vZGVsQWRhcHRlcihUcmVlTm9kZVZhbHVlTW9kZWw8VD4gcm9vdCkgewotCQl0aGlzKG5ldyBTdGF0aWNQcm9wZXJ0eVZhbHVlTW9kZWw8VHJlZU5vZGVWYWx1ZU1vZGVsPFQ+Pihyb290KSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkUm9vdExpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IEFXVFByb3BlcnR5Q2hhbmdlTGlzdGVuZXJXcmFwcGVyKHRoaXMuYnVpbGRSb290TGlzdGVuZXJfKCkpOwotCX0KLQotCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkUm9vdExpc3RlbmVyXygpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlUcmVlTW9kZWxBZGFwdGVyLnRoaXMucm9vdENoYW5nZWQoKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gInJvb3QgbGlzdGVuZXIiOwotCQkJfQotCQl9OwotCX0KLQotCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkTm9kZVZhbHVlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgQVdUUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcldyYXBwZXIodGhpcy5idWlsZE5vZGVWYWx1ZUxpc3RlbmVyXygpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZE5vZGVWYWx1ZUxpc3RlbmVyXygpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCVRyZWVNb2RlbEFkYXB0ZXIudGhpcy5ub2RlQ2hhbmdlZCgoVHJlZU5vZGVWYWx1ZU1vZGVsPFQ+KSBldmVudC5nZXRTb3VyY2UoKSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJub2RlIHZhbHVlIGxpc3RlbmVyIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcm90ZWN0ZWQgU3RhdGVDaGFuZ2VMaXN0ZW5lciBidWlsZE5vZGVTdGF0ZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IEFXVFN0YXRlQ2hhbmdlTGlzdGVuZXJXcmFwcGVyKHRoaXMuYnVpbGROb2RlU3RhdGVMaXN0ZW5lcl8oKSk7Ci0JfQotCi0JcHJvdGVjdGVkIFN0YXRlQ2hhbmdlTGlzdGVuZXIgYnVpbGROb2RlU3RhdGVMaXN0ZW5lcl8oKSB7Ci0JCXJldHVybiBuZXcgU3RhdGVDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHVibGljIHZvaWQgc3RhdGVDaGFuZ2VkKFN0YXRlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQlUcmVlTW9kZWxBZGFwdGVyLnRoaXMubm9kZUNoYW5nZWQoKFRyZWVOb2RlVmFsdWVNb2RlbDxUPikgZXZlbnQuZ2V0U291cmNlKCkpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAibm9kZSBzdGF0ZSBsaXN0ZW5lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJvdGVjdGVkIExpc3RDaGFuZ2VMaXN0ZW5lciBidWlsZENoaWxkcmVuTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgQVdUTGlzdENoYW5nZUxpc3RlbmVyV3JhcHBlcih0aGlzLmJ1aWxkQ2hpbGRyZW5MaXN0ZW5lcl8oKSk7Ci0JfQotCi0JcHJvdGVjdGVkIExpc3RDaGFuZ2VMaXN0ZW5lciBidWlsZENoaWxkcmVuTGlzdGVuZXJfKCkgewotCQlyZXR1cm4gbmV3IExpc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJbmV3IEV2ZW50Q2hhbmdlUG9saWN5KGV2ZW50KS5hZGRDaGlsZHJlbigpOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCW5ldyBFdmVudENoYW5nZVBvbGljeShldmVudCkucmVtb3ZlQ2hpbGRyZW4oKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJbmV3IEV2ZW50Q2hhbmdlUG9saWN5KGV2ZW50KS5yZXBsYWNlQ2hpbGRyZW4oKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJbmV3IEV2ZW50Q2hhbmdlUG9saWN5KGV2ZW50KS5tb3ZlQ2hpbGRyZW4oKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGxpc3RDbGVhcmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCW5ldyBFdmVudENoYW5nZVBvbGljeShldmVudCkuY2xlYXJDaGlsZHJlbigpOwotCQkJfQotCQkJcHVibGljIHZvaWQgbGlzdENoYW5nZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkJbmV3IEV2ZW50Q2hhbmdlUG9saWN5KGV2ZW50KS5yZWJ1aWxkQ2hpbGRyZW4oKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gImNoaWxkcmVuIGxpc3RlbmVyIjsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogVHJlZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBPYmplY3QgZ2V0Um9vdCgpIHsKLQkJcmV0dXJuIHRoaXMucm9vdDsKLQl9Ci0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwdWJsaWMgT2JqZWN0IGdldENoaWxkKE9iamVjdCBwYXJlbnQsIGludCBpbmRleCkgewotCQlyZXR1cm4gKChUcmVlTm9kZVZhbHVlTW9kZWw8VD4pIHBhcmVudCkuY2hpbGQoaW5kZXgpOwotCX0KLQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXB1YmxpYyBpbnQgZ2V0Q2hpbGRDb3VudChPYmplY3QgcGFyZW50KSB7Ci0JCXJldHVybiAoKFRyZWVOb2RlVmFsdWVNb2RlbDxUPikgcGFyZW50KS5jaGlsZHJlblNpemUoKTsKLQl9Ci0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwdWJsaWMgYm9vbGVhbiBpc0xlYWYoT2JqZWN0IG5vZGUpIHsKLQkJcmV0dXJuICgoVHJlZU5vZGVWYWx1ZU1vZGVsPFQ+KSBub2RlKS5pc0xlYWYoKTsKLQl9Ci0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwdWJsaWMgdm9pZCB2YWx1ZUZvclBhdGhDaGFuZ2VkKFRyZWVQYXRoIHBhdGgsIE9iamVjdCBuZXdWYWx1ZSkgewotCQkoKFRyZWVOb2RlVmFsdWVNb2RlbDxUPikgcGF0aC5nZXRMYXN0UGF0aENvbXBvbmVudCgpKS5zZXRWYWx1ZSgoVCkgbmV3VmFsdWUpOwotCX0KLQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXB1YmxpYyBpbnQgZ2V0SW5kZXhPZkNoaWxkKE9iamVjdCBwYXJlbnQsIE9iamVjdCBjaGlsZCkgewotCQlyZXR1cm4gKChUcmVlTm9kZVZhbHVlTW9kZWw8VD4pIHBhcmVudCkuaW5kZXhPZkNoaWxkKChUcmVlTm9kZVZhbHVlTW9kZWw8VD4pIGNoaWxkKTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RhcnQgbGlzdGVuaW5nIHRvIHRoZSB1bmRlcmx5aW5nIG1vZGVsIGlmIG5lY2Vzc2FyeS4KLQkgKi8KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBhZGRUcmVlTW9kZWxMaXN0ZW5lcihUcmVlTW9kZWxMaXN0ZW5lciBsKSB7Ci0JCWlmICh0aGlzLmhhc05vVHJlZU1vZGVsTGlzdGVuZXJzKCkpIHsKLQkJCXRoaXMuZW5nYWdlTW9kZWwoKTsKLQkJfQotCQlzdXBlci5hZGRUcmVlTW9kZWxMaXN0ZW5lcihsKTsKLQl9Ci0KLQkvKioKLQkgKiBFeHRlbmQgdG8gc3RvcCBsaXN0ZW5pbmcgdG8gdGhlIHVuZGVybHlpbmcgbW9kZWwgaWYgYXBwcm9wcmlhdGUuCi0JICovCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgcmVtb3ZlVHJlZU1vZGVsTGlzdGVuZXIoVHJlZU1vZGVsTGlzdGVuZXIgbCkgewotCQlzdXBlci5yZW1vdmVUcmVlTW9kZWxMaXN0ZW5lcihsKTsKLQkJaWYgKHRoaXMuaGFzTm9UcmVlTW9kZWxMaXN0ZW5lcnMoKSkgewotCQkJdGhpcy5kaXNlbmdhZ2VNb2RlbCgpOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCS8qKgotCSAqIExpc3RlbiB0byB0aGUgcm9vdCBhbmQgYWxsIHRoZSBvdGhlciBub2RlcwotCSAqIGluIHRoZSB1bmRlcmx5aW5nIHRyZWUgbW9kZWwuCi0JICovCi0JcHJpdmF0ZSB2b2lkIGVuZ2FnZU1vZGVsKCkgewotCQl0aGlzLnJvb3RIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMucm9vdExpc3RlbmVyKTsKLQkJdGhpcy5yb290ID0gdGhpcy5yb290SG9sZGVyLmdldFZhbHVlKCk7Ci0JCWlmICh0aGlzLnJvb3QgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7CS8vIHRoZSByb290IGNhbm5vdCBiZSBudWxsIHdoaWxlIHdlIGhhdmUgbGlzdGVuZXJzCi0JCX0KLQkJdGhpcy5lbmdhZ2VOb2RlKHRoaXMucm9vdCk7Ci0JCXRoaXMuYWRkUm9vdCgpOwotCX0KLQotCS8qKgotCSAqIEFkZCB0aGUgcm9vdCBhbmQgYWxsIG9mIHRoZSBub2RlcyB0byB0aGUgdW5kZXJseWluZyB0cmVlLgotCSAqLwotCXByaXZhdGUgdm9pZCBhZGRSb290KCkgewotCQl0aGlzLmFkZE5vZGUoMCwgdGhpcy5yb290KTsKLQl9Ci0KLQkvKioKLQkgKiBTdG9wIGxpc3RlbmluZyB0byB0aGUgcm9vdCBhbmQgYWxsIHRoZSBvdGhlcgotCSAqIG5vZGVzIGluIHRoZSB1bmRlcmx5aW5nIHRyZWUgbW9kZWwuCi0JICovCi0JcHJpdmF0ZSB2b2lkIGRpc2VuZ2FnZU1vZGVsKCkgewotCQl0aGlzLnJlbW92ZVJvb3QoKTsKLQkJdGhpcy5kaXNlbmdhZ2VOb2RlKHRoaXMucm9vdCk7Ci0JCXRoaXMucm9vdCA9IG51bGw7Ci0JCXRoaXMucm9vdEhvbGRlci5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5yb290TGlzdGVuZXIpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSB0aGUgcm9vdCBhbmQgYWxsIG9mIHRoZSBub2RlcyBmcm9tIHRoZSB1bmRlcmx5aW5nIHRyZWUuCi0JICovCi0JcHJpdmF0ZSB2b2lkIHJlbW92ZVJvb3QoKSB7Ci0JCXRoaXMucmVtb3ZlTm9kZSgwLCB0aGlzLnJvb3QpOwotCX0KLQotCS8qKgotCSAqIFRoZSByb290IGhhcyBiZWVuIHN3YXBwZWQuCi0JICogVGhpcyBtZXRob2QgaXMgYSBiaXQgZ25hcmx5IGJlY2F1c2UgdGhlIEFQSSBmb3Igbm90aWZ5aW5nIGxpc3RlbmVycwotCSAqIHRoYXQgdGhlIHJvb3QgaGFzIGNoYW5nZWQgaXMgYSBiaXQgaW5jb25zaXN0ZW50IHdpdGggdGhhdCB1c2VkIGZvcgotCSAqIG5vbi1yb290IG5vZGVzLgotCSAqLwotCXZvaWQgcm9vdENoYW5nZWQoKSB7Ci0JCVRyZWVOb2RlVmFsdWVNb2RlbDxUPiBuZXdSb290ID0gdGhpcy5yb290SG9sZGVyLmdldFZhbHVlKCk7Ci0JCWlmIChuZXdSb290ID09IG51bGwpIHsKLQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigpOwkvLyB0aGUgcm9vdCBjYW5ub3QgYmUgbnVsbCB3aGlsZSB3ZSBoYXZlIGxpc3RlbmVycwotCQl9Ci0JCS8vIHJlbW92ZSBhbGwgdGhlIGN1cnJlbnQgcm9vdCdzIGNoaWxkcmVuIGZyb20gdGhlIHRyZWUKLQkJLy8gYW5kIHJlbW92ZSB0aGUgaXQgZnJvbSB0aGUgaW50ZXJuYWwgdHJlZQotCQl0aGlzLnJlbW92ZVJvb3QoKTsgCi0KLQkJLy8gc2F2ZSB0aGUgb2xkIHJvb3QgYW5kIHN3YXAgaW4gdGhlIG5ldyByb290Ci0JCVRyZWVOb2RlVmFsdWVNb2RlbDxUPiBvbGRSb290ID0gdGhpcy5yb290OwotCQl0aGlzLnJvb3QgPSBuZXdSb290OwotCi0JCS8vIHdlIG11c3QgYmUgbGlzdGVuaW5nIHRvIGJvdGggdGhlIG9sZCBhbmQgbmV3IHJvb3RzIHdoZW4gd2UgZmlyZSB0aGUgZXZlbnQKLQkJLy8gYmVjYXVzZSB0aGVpciB2YWx1ZXMgY2FuIGJlIGFmZmVjdGVkIGJ5IHdoZXRoZXIgdGhleSBoYXZlIGxpc3RlbmVycwotCQl0aGlzLmVuZ2FnZU5vZGUodGhpcy5yb290KTsKLQkJdGhpcy5maXJlVHJlZVJvb3RSZXBsYWNlZCh0aGlzLnJvb3QpOwotCQkvLyBub3cgd2UgY2FuIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSBvbGQgcm9vdAotCQl0aGlzLmRpc2VuZ2FnZU5vZGUob2xkUm9vdCk7Ci0KLQkJLy8gYWRkIHRoZSBuZXcgcm9vdCB0byB0aGUgaW50ZXJuYWwgdHJlZSBhbmQKLQkJLy8gYWRkIGFsbCBpdHMgY2hpbGRyZW4gdG8gdGhlIHRyZWUgYWxzbwotCQl0aGlzLmFkZFJvb3QoKTsKLQl9Ci0KLQkvKioKLQkgKiBFaXRoZXIgdGhlICJ2YWx1ZSIgb3IgdGhlICJzdGF0ZSIgb2YgdGhlIHNwZWNpZmllZCBub2RlIGhhcyBjaGFuZ2VkLAotCSAqIGZvcndhcmQgbm90aWZpY2F0aW9uIHRvIG91ciBsaXN0ZW5lcnMuCi0JICovCi0Jdm9pZCBub2RlQ2hhbmdlZChUcmVlTm9kZVZhbHVlTW9kZWw8VD4gbm9kZSkgewotCQlUcmVlTm9kZVZhbHVlTW9kZWw8VD4gcGFyZW50ID0gbm9kZS5wYXJlbnQoKTsKLQkJaWYgKHBhcmVudCA9PSBudWxsKSB7Ci0JCQl0aGlzLmZpcmVUcmVlUm9vdENoYW5nZWQobm9kZSk7Ci0JCX0gZWxzZSB7Ci0JCQl0aGlzLmZpcmVUcmVlTm9kZUNoYW5nZWQocGFyZW50LnBhdGgoKSwgcGFyZW50LmluZGV4T2ZDaGlsZChub2RlKSwgbm9kZSk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBMaXN0ZW4gdG8gdGhlIG5vZGVzLCBub3RpZnkgb3VyIGxpc3RlbmVycyB0aGF0IHRoZSBub2RlcyB3ZXJlIGFkZGVkLAotCSAqIGFuZCB0aGVuIGFkZCB0aGUgbm9kZXMgdG8gb3VyIGludGVybmFsIHRyZWUuCi0JICogV2UgbXVzdCBsaXN0ZW4gdG8gdGhlIG5vZGVzIGJlZm9yZSBub3RpZnlpbmcgYW55Ym9keSwgYmVjYXVzZQotCSAqIGFkZGluZyBhIGxpc3RlbmVyIGNhbiBjaGFuZ2UgdGhlIHZhbHVlIG9mIGEgbm9kZS4KLQkgKi8KLQl2b2lkIGFkZENoaWxkcmVuKFRyZWVOb2RlVmFsdWVNb2RlbDxUPltdIHBhdGgsIGludFtdIGNoaWxkSW5kaWNlcywgVHJlZU5vZGVWYWx1ZU1vZGVsPFQ+W10gY2hpbGRyZW4pIHsKLQkJaW50IGxlbiA9IGNoaWxkSW5kaWNlcy5sZW5ndGg7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKLQkJCXRoaXMuZW5nYWdlTm9kZShjaGlsZHJlbltpXSk7Ci0JCX0KLQkJdGhpcy5maXJlVHJlZU5vZGVzSW5zZXJ0ZWQocGF0aCwgY2hpbGRJbmRpY2VzLCBjaGlsZHJlbik7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKLQkJCXRoaXMuYWRkTm9kZShjaGlsZEluZGljZXNbaV0sIGNoaWxkcmVuW2ldKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIExpc3RlbiB0byB0aGUgbm9kZSBhbmQgaXRzIGNoaWxkcmVuIG1vZGVsLgotCSAqLwotCXByaXZhdGUgdm9pZCBlbmdhZ2VOb2RlKFRyZWVOb2RlVmFsdWVNb2RlbDxUPiBub2RlKSB7Ci0JCW5vZGUuYWRkU3RhdGVDaGFuZ2VMaXN0ZW5lcih0aGlzLm5vZGVTdGF0ZUxpc3RlbmVyKTsKLQkJbm9kZS5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5ub2RlVmFsdWVMaXN0ZW5lcik7Ci0JCW5vZGUuY2hpbGRyZW5Nb2RlbCgpLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5jaGlsZHJlbkxpc3RlbmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBBZGQgdGhlIG5vZGUgdG8gb3VyIGludGVybmFsIHRyZWU7Ci0JICogdGhlbiByZWN1cnNlIGRvd24gdGhyb3VnaCB0aGUgbm9kZSdzIGNoaWxkcmVuLAotCSAqIGFkZGluZyB0aGVtIHRvIHRoZSBpbnRlcm5hbCB0cmVlIGFsc28uCi0JICovCi0JcHJpdmF0ZSB2b2lkIGFkZE5vZGUoaW50IGluZGV4LCBUcmVlTm9kZVZhbHVlTW9kZWw8VD4gbm9kZSkgewotCQl0aGlzLmFkZE5vZGVUb0ludGVybmFsVHJlZShub2RlLnBhcmVudCgpLCBpbmRleCwgbm9kZSwgbm9kZS5jaGlsZHJlbk1vZGVsKCkpOwotCQluZXcgTm9kZUNoYW5nZVBvbGljeShub2RlKS5hZGRDaGlsZHJlbigpOwotCX0KLQotCS8qKgotCSAqIEFkZCB0aGUgc3BlY2lmaWVkIG5vZGUgdG8gb3VyIGludGVybmFsIHRyZWUuCi0JICovCi0JcHJpdmF0ZSB2b2lkIGFkZE5vZGVUb0ludGVybmFsVHJlZShUcmVlTm9kZVZhbHVlTW9kZWw8VD4gcGFyZW50LCBpbnQgaW5kZXgsIFRyZWVOb2RlVmFsdWVNb2RlbDxUPiBub2RlLCBMaXN0VmFsdWVNb2RlbDxUcmVlTm9kZVZhbHVlTW9kZWw8VD4+IGNoaWxkcmVuTW9kZWwpIHsKLQkJTGlzdDxUcmVlTm9kZVZhbHVlTW9kZWw8VD4+IHNpYmxpbmdzID0gdGhpcy5jaGlsZHJlbkxpc3RzLmdldChwYXJlbnQpOwotCQlpZiAoc2libGluZ3MgPT0gbnVsbCkgewotCQkJc2libGluZ3MgPSBuZXcgQXJyYXlMaXN0PFRyZWVOb2RlVmFsdWVNb2RlbDxUPj4oKTsKLQkJCXRoaXMuY2hpbGRyZW5MaXN0cy5wdXQocGFyZW50LCBzaWJsaW5ncyk7Ci0JCX0KLQkJc2libGluZ3MuYWRkKGluZGV4LCBub2RlKTsKLQotCQl0aGlzLnBhcmVudHMucHV0KGNoaWxkcmVuTW9kZWwsIG5vZGUpOwotCX0KLQotCS8qKgotCSAqIFJlbW92ZSBub2RlcyBmcm9tIG91ciBpbnRlcm5hbCB0cmVlLCBub3RpZnkgb3VyIGxpc3RlbmVycyB0aGF0IHRoZQotCSAqIG5vZGVzIHdlcmUgcmVtb3ZlZCwgdGhlbiBzdG9wIGxpc3RlbmluZyB0byB0aGUgbm9kZXMuCi0JICogV2UgbXVzdCBsaXN0ZW4gdG8gdGhlIG5vZGVzIHVudGlsIGFmdGVyIG5vdGlmeWluZyBhbnlib2R5LCBiZWNhdXNlCi0JICogcmVtb3ZpbmcgYSBsaXN0ZW5lciBjYW4gY2hhbmdlIHRoZSB2YWx1ZSBvZiBhIG5vZGUuCi0JICovCi0Jdm9pZCByZW1vdmVDaGlsZHJlbihUcmVlTm9kZVZhbHVlTW9kZWw8VD5bXSBwYXRoLCBpbnRbXSBjaGlsZEluZGljZXMsIFRyZWVOb2RlVmFsdWVNb2RlbDxUPltdIGNoaWxkcmVuKSB7Ci0JCWludCBsZW4gPSBjaGlsZEluZGljZXMubGVuZ3RoOwotCQlmb3IgKGludCBpID0gMDsgaSA8IGxlbjsgaSsrKSB7Ci0JCQkvLyB0aGUgaW5kaWNlcyBzbGlkZSBkb3duIGEgbm90Y2ggZWFjaCB0aW1lIHdlIHJlbW92ZSBhIGNoaWxkCi0JCQl0aGlzLnJlbW92ZU5vZGUoY2hpbGRJbmRpY2VzW2ldIC0gaSwgY2hpbGRyZW5baV0pOwotCQl9Ci0JCXRoaXMuZmlyZVRyZWVOb2Rlc1JlbW92ZWQocGF0aCwgY2hpbGRJbmRpY2VzLCBjaGlsZHJlbik7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKLQkJCXRoaXMuZGlzZW5nYWdlTm9kZShjaGlsZHJlbltpXSk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBGaXJzdCwgcmVjdXJzZSBkb3duIHRocm91Z2ggdGhlIG5vZGUncyBjaGlsZHJlbiwKLQkgKiByZW1vdmluZyB0aGVtIGZyb20gb3VyIGludGVybmFsIHRyZWU7Ci0JICogdGhlbiByZW1vdmUgdGhlIG5vZGUgaXRzZWxmIGZyb20gb3VyIGludGVybmFsIHRyZWUuCi0JICovCi0JcHJpdmF0ZSB2b2lkIHJlbW92ZU5vZGUoaW50IGluZGV4LCBUcmVlTm9kZVZhbHVlTW9kZWw8VD4gbm9kZSkgewotCQluZXcgTm9kZUNoYW5nZVBvbGljeShub2RlKS5yZW1vdmVDaGlsZHJlbigpOwotCQl0aGlzLnJlbW92ZU5vZGVGcm9tSW50ZXJuYWxUcmVlKG5vZGUucGFyZW50KCksIGluZGV4LCBub2RlLCBub2RlLmNoaWxkcmVuTW9kZWwoKSk7Ci0JfQotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgbm9kZSBmcm9tIG91ciBpbnRlcm5hbCB0cmVlLgotCSAqLwotCXByaXZhdGUgdm9pZCByZW1vdmVOb2RlRnJvbUludGVybmFsVHJlZShUcmVlTm9kZVZhbHVlTW9kZWw8VD4gcGFyZW50LCBpbnQgaW5kZXgsIFRyZWVOb2RlVmFsdWVNb2RlbDxUPiBub2RlLCBMaXN0VmFsdWVNb2RlbDxUcmVlTm9kZVZhbHVlTW9kZWw8VD4+IGNoaWxkcmVuTW9kZWwpIHsKLQkJdGhpcy5wYXJlbnRzLnJlbW92ZShjaGlsZHJlbk1vZGVsKTsKLQotCQlMaXN0PFRyZWVOb2RlVmFsdWVNb2RlbDxUPj4gc2libGluZ3MgPSB0aGlzLmNoaWxkcmVuTGlzdHMuZ2V0KHBhcmVudCk7Ci0JCXNpYmxpbmdzLnJlbW92ZShpbmRleCk7Ci0JCWlmIChzaWJsaW5ncy5pc0VtcHR5KCkpIHsKLQkJCXRoaXMuY2hpbGRyZW5MaXN0cy5yZW1vdmUocGFyZW50KTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFN0b3AgbGlzdGVuaW5nIHRvIHRoZSBub2RlIGFuZCBpdHMgY2hpbGRyZW4gbW9kZWwuCi0JICovCi0JcHJpdmF0ZSB2b2lkIGRpc2VuZ2FnZU5vZGUoVHJlZU5vZGVWYWx1ZU1vZGVsPFQ+IG5vZGUpIHsKLQkJbm9kZS5jaGlsZHJlbk1vZGVsKCkucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmNoaWxkcmVuTGlzdGVuZXIpOwotCQlub2RlLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLm5vZGVWYWx1ZUxpc3RlbmVyKTsKLQkJbm9kZS5yZW1vdmVTdGF0ZUNoYW5nZUxpc3RlbmVyKHRoaXMubm9kZVN0YXRlTGlzdGVuZXIpOwotCX0KLQotCXZvaWQgbW92ZUNoaWxkcmVuKFRyZWVOb2RlVmFsdWVNb2RlbDxUPiBwYXJlbnQsIGludCB0YXJnZXRJbmRleCwgaW50IHNvdXJjZUluZGV4LCBpbnQgbGVuZ3RoKSB7Ci0JCUxpc3Q8VHJlZU5vZGVWYWx1ZU1vZGVsPFQ+PiBjaGlsZHJlbkxpc3QgPSB0aGlzLmNoaWxkcmVuTGlzdHMuZ2V0KHBhcmVudCk7Ci0JCUFycmF5TGlzdDxUcmVlTm9kZVZhbHVlTW9kZWw8VD4+IHRlbXAgPSBuZXcgQXJyYXlMaXN0PFRyZWVOb2RlVmFsdWVNb2RlbDxUPj4obGVuZ3RoKTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsZW5ndGg7IGkrKykgewotCQkJdGVtcC5hZGQoY2hpbGRyZW5MaXN0LnJlbW92ZShzb3VyY2VJbmRleCkpOwotCQl9Ci0JCWNoaWxkcmVuTGlzdC5hZGRBbGwodGFyZ2V0SW5kZXgsIHRlbXApOwotCi0JCXRoaXMuZmlyZVRyZWVTdHJ1Y3R1cmVDaGFuZ2VkKHBhcmVudC5wYXRoKCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBzdGFuZGFyZCBtZXRob2RzICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMucm9vdCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGlubmVyIGNsYXNzZXMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29hbGVzY2Ugc29tZSBvZiB0aGUgY29tbW9uIGNoYW5nZSBwb2xpY3kgYmVoYXZpb3IuCi0JICovCi0JcHJpdmF0ZSBhYnN0cmFjdCBjbGFzcyBDaGFuZ2VQb2xpY3kgewotCi0JCUNoYW5nZVBvbGljeSgpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQotCQkvKioKLQkJICogQWRkIHRoZSBjdXJyZW50IHNldCBvZiBjaGlsZHJlbi4KLQkJICovCi0JCXZvaWQgYWRkQ2hpbGRyZW4oKSB7Ci0JCQlUcmVlTW9kZWxBZGFwdGVyLnRoaXMuYWRkQ2hpbGRyZW4odGhpcy5wYXJlbnQoKS5wYXRoKCksIHRoaXMuY2hpbGRJbmRpY2VzKCksIHRoaXMuY2hpbGRBcnJheSgpKTsKLQkJfQotCi0JCS8qKgotCQkgKiBSZW1vdmUgdGhlIGN1cnJlbnQgc2V0IG9mIGNoaWxkcmVuLgotCQkgKi8KLQkJdm9pZCByZW1vdmVDaGlsZHJlbigpIHsKLQkJCVRyZWVNb2RlbEFkYXB0ZXIudGhpcy5yZW1vdmVDaGlsZHJlbih0aGlzLnBhcmVudCgpLnBhdGgoKSwgdGhpcy5jaGlsZEluZGljZXMoKSwgdGhpcy5jaGlsZEFycmF5KCkpOwotCQl9Ci0KLQkJLyoqCi0JCSAqIFJldHVybiBhbiBhcnJheSBvZiB0aGUgaW5kaWNlcyBvZiB0aGUgY3VycmVudCBzZXQgb2YgY2hpbGRyZW4sCi0JCSAqIHdoaWNoIHNob3VsZCBiZSBjb250aWd1b3VzLgotCQkgKi8KLQkJaW50W10gY2hpbGRJbmRpY2VzKCkgewotCQkJcmV0dXJuIHRoaXMuYnVpbGRJbmRpY2VzKHRoaXMuY2hpbGRyZW5TdGFydEluZGV4KCksIHRoaXMuY2hpbGRyZW5TaXplKCkpOwotCQl9Ci0KLQkJLyoqCi0JCSAqIFJldHVybiBhbiBhcnJheSBvZiB0aGUgY3VycmVudCBzZXQgb2YgY2hpbGRyZW4uCi0JCSAqLwotCQlUcmVlTm9kZVZhbHVlTW9kZWw8VD5bXSBjaGlsZEFycmF5KCkgewotCQkJcmV0dXJuIHRoaXMuYnVpbGRBcnJheSh0aGlzLmNoaWxkcmVuKCksIHRoaXMuY2hpbGRyZW5TaXplKCkpOwotCQl9Ci0KLQkJLyoqCi0JCSAqIEJ1aWxkIGFuIGFycmF5IHRvIGhvbGQgdGhlIGVsZW1lbnRzIGluIHRoZSBzcGVjaWZpZWQgaXRlcmF0b3IuCi0JCSAqIElmIHRoZXkgYXJlIGRpZmZlcmVudCBzaXplcywgc29tZXRoaW5nIGlzIHNjcmV3ZWQgdXAuLi4KLQkJICovCi0JCVRyZWVOb2RlVmFsdWVNb2RlbDxUPltdIGJ1aWxkQXJyYXkoSXRlcmF0b3I8VHJlZU5vZGVWYWx1ZU1vZGVsPFQ+PiBzdHJlYW0sIGludCBzaXplKSB7Ci0JCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQkJCVRyZWVOb2RlVmFsdWVNb2RlbDxUPltdIGFycmF5ID0gbmV3IFRyZWVOb2RlVmFsdWVNb2RlbFtzaXplXTsKLQkJCWZvciAoaW50IGkgPSAwOyBzdHJlYW0uaGFzTmV4dCgpOyBpKyspIHsKLQkJCQlhcnJheVtpXSA9IHN0cmVhbS5uZXh0KCk7Ci0JCQl9Ci0JCQlyZXR1cm4gYXJyYXk7Ci0JCX0KLQotCQkvKioKLQkJICogUmV0dXJuIGEgc2V0IG9mIGluZGljZXMsIHN0YXJ0aW5nIGF0IHplcm8gYW5kCi0JCSAqIGNvbnRpbnVpbmcgZm9yIHRoZSBzcGVjaWZpZWQgc2l6ZS4KLQkJICovCi0JCWludFtdIGJ1aWxkSW5kaWNlcyhpbnQgc2l6ZSkgewotCQkJcmV0dXJuIGJ1aWxkSW5kaWNlcygwLCBzaXplKTsKLQkJfQotCi0JCS8qKgotCQkgKiBSZXR1cm4gYSBzZXQgb2YgaW5kaWNlcywgc3RhcnRpbmcgYXQgdGhlIHNwZWNpZmllZCBpbmRleCBhbmQKLQkJICogY29udGludWluZyBmb3IgdGhlIHNwZWNpZmllZCBzaXplLgotCQkgKi8KLQkJaW50W10gYnVpbGRJbmRpY2VzKGludCBzdGFydCwgaW50IHNpemUpIHsKLQkJCWludFtdIGluZGljZXMgPSBuZXcgaW50W3NpemVdOwotCQkJaW50IGluZGV4ID0gc3RhcnQ7Ci0JCQlmb3IgKGludCBpID0gMDsgaSA8IHNpemU7IGkrKykgewotCQkJCWluZGljZXNbaV0gPSBpbmRleCsrOwotCQkJfQotCQkJcmV0dXJuIGluZGljZXM7Ci0JCX0KLQotCQkvKioKLQkJICogUmV0dXJuIHRoZSBwYXJlbnQgb2YgdGhlIGN1cnJlbnQgc2V0IG9mIGNoaWxkcmVuLgotCQkgKi8KLQkJYWJzdHJhY3QgVHJlZU5vZGVWYWx1ZU1vZGVsPFQ+IHBhcmVudCgpOwotCi0JCS8qKgotCQkgKiBSZXR1cm4gdGhlIHN0YXJ0aW5nIGluZGV4IGZvciB0aGUgY3VycmVudCBzZXQgb2YgY2hpbGRyZW4uCi0JCSAqLwotCQlhYnN0cmFjdCBpbnQgY2hpbGRyZW5TdGFydEluZGV4KCk7Ci0KLQkJLyoqCi0JCSAqIFJldHVybiB0aGUgc2l6ZSBvZiB0aGUgY3VycmVudCBzZXQgb2YgY2hpbGRyZW4uCi0JCSAqLwotCQlhYnN0cmFjdCBpbnQgY2hpbGRyZW5TaXplKCk7Ci0KLQkJLyoqCi0JCSAqIFJldHVybiBhbiBpbnRlcmF0b3Igb24gdGhlIGN1cnJlbnQgc2V0IG9mIGNoaWxkcmVuLgotCQkgKi8KLQkJYWJzdHJhY3QgSXRlcmF0b3I8VHJlZU5vZGVWYWx1ZU1vZGVsPFQ+PiBjaGlsZHJlbigpOwotCi0JfQotCi0KLQkvKioKLQkgKiBXcmFwcyBhIExpc3RDaGFuZ2VFdmVudCBmb3IgYWRkaW5nLCByZW1vdmluZywgcmVwbGFjaW5nLAotCSAqIGFuZCBjaGFuZ2luZyBjaGlsZHJlbi4KLQkgKi8KLQlwcml2YXRlIGNsYXNzIEV2ZW50Q2hhbmdlUG9saWN5IGV4dGVuZHMgQ2hhbmdlUG9saWN5IHsKLQkJcHJpdmF0ZSBMaXN0Q2hhbmdlRXZlbnQgZXZlbnQ7Ci0KLQkJRXZlbnRDaGFuZ2VQb2xpY3koTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQl0aGlzLmV2ZW50ID0gZXZlbnQ7Ci0JCX0KLQotCQkvKioKLQkJICogTWFwIHRoZSBMaXN0Q2hhbmdlRXZlbnQncyBzb3VyY2UgdG8gdGhlIGNvcnJlc3BvbmRpbmcgcGFyZW50LgotCQkgKi8KLQkJQE92ZXJyaWRlCi0JCVRyZWVOb2RlVmFsdWVNb2RlbDxUPiBwYXJlbnQoKSB7Ci0JCQlyZXR1cm4gVHJlZU1vZGVsQWRhcHRlci50aGlzLnBhcmVudHMuZ2V0KHRoaXMuZXZlbnQuZ2V0U291cmNlKCkpOwotCQl9Ci0KLQkJLyoqCi0JCSAqIFRoZSBMaXN0Q2hhbmdlRXZlbnQncyBpdGVtIGluZGV4IGlzIHRoZSBjaGlsZHJlbiBzdGFydCBpbmRleC4KLQkJICovCi0JCUBPdmVycmlkZQotCQlpbnQgY2hpbGRyZW5TdGFydEluZGV4KCkgewotCQkJcmV0dXJuIHRoaXMuZXZlbnQuZ2V0SW5kZXgoKTsKLQkJfQotCi0JCS8qKgotCQkgKiBUaGUgTGlzdENoYW5nZUV2ZW50J3Mgc2l6ZSBpcyB0aGUgY2hpbGRyZW4gc2l6ZS4KLQkJICovCi0JCUBPdmVycmlkZQotCQlpbnQgY2hpbGRyZW5TaXplKCkgewotCQkJcmV0dXJuIHRoaXMuZXZlbnQuaXRlbXNTaXplKCk7Ci0JCX0KLQotCQkvKioKLQkJICogVGhlIExpc3RDaGFuZ2VFdmVudCdzIGl0ZW1zIGFyZSB0aGUgY2hpbGRyZW4uCi0JCSAqLwotCQlAT3ZlcnJpZGUKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCUl0ZXJhdG9yPFRyZWVOb2RlVmFsdWVNb2RlbDxUPj4gY2hpbGRyZW4oKSB7Ci0JCQlyZXR1cm4gKEl0ZXJhdG9yPFRyZWVOb2RlVmFsdWVNb2RlbDxUPj4pIHRoaXMuZXZlbnQuaXRlbXMoKTsKLQkJfQotCi0JCS8qKgotCQkgKiBSZW1vdmUgdGhlIG9sZCBub2RlcyBhbmQgYWRkIHRoZSBuZXcgb25lcy4KLQkJICovCi0JCXZvaWQgcmVwbGFjZUNoaWxkcmVuKCkgewotCQkJVHJlZU5vZGVWYWx1ZU1vZGVsPFQ+W10gcGFyZW50UGF0aCA9IHRoaXMucGFyZW50KCkucGF0aCgpOwotCQkJaW50W10gY2hpbGRJbmRpY2VzID0gdGhpcy5jaGlsZEluZGljZXMoKTsKLQkJCVRyZWVNb2RlbEFkYXB0ZXIudGhpcy5yZW1vdmVDaGlsZHJlbihwYXJlbnRQYXRoLCBjaGlsZEluZGljZXMsIHRoaXMucmVwbGFjZWRDaGlsZHJlbigpKTsKLQkJCVRyZWVNb2RlbEFkYXB0ZXIudGhpcy5hZGRDaGlsZHJlbihwYXJlbnRQYXRoLCBjaGlsZEluZGljZXMsIHRoaXMuY2hpbGRBcnJheSgpKTsKLQkJfQotCi0JCS8qKgotCQkgKiBSZW1vdmUgdGhlIG9sZCBub2RlcyBhbmQgYWRkIHRoZSBuZXcgb25lcy4KLQkJICovCi0JCXZvaWQgbW92ZUNoaWxkcmVuKCkgewotCQkJVHJlZU1vZGVsQWRhcHRlci50aGlzLm1vdmVDaGlsZHJlbih0aGlzLnBhcmVudCgpLCB0aGlzLmV2ZW50LmdldFRhcmdldEluZGV4KCksIHRoaXMuZXZlbnQuZ2V0U291cmNlSW5kZXgoKSwgdGhpcy5ldmVudC5nZXRNb3ZlTGVuZ3RoKCkpOwotCQl9Ci0KLQkJLyoqCi0JCSAqIENsZWFyIGFsbCB0aGUgbm9kZXMuCi0JCSAqLwotCQl2b2lkIGNsZWFyQ2hpbGRyZW4oKSB7Ci0JCQlUcmVlTm9kZVZhbHVlTW9kZWw8VD4gcGFyZW50ID0gdGhpcy5wYXJlbnQoKTsKLQkJCVRyZWVOb2RlVmFsdWVNb2RlbDxUPltdIHBhcmVudFBhdGggPSBwYXJlbnQucGF0aCgpOwotCQkJTGlzdDxUcmVlTm9kZVZhbHVlTW9kZWw8VD4+IGNoaWxkcmVuTGlzdCA9IFRyZWVNb2RlbEFkYXB0ZXIudGhpcy5jaGlsZHJlbkxpc3RzLmdldChwYXJlbnQpOwotCQkJaW50W10gY2hpbGRJbmRpY2VzID0gdGhpcy5idWlsZEluZGljZXMoY2hpbGRyZW5MaXN0LnNpemUoKSk7Ci0JCQlUcmVlTm9kZVZhbHVlTW9kZWw8VD5bXSBjaGlsZEFycmF5ID0gdGhpcy5idWlsZEFycmF5KGNoaWxkcmVuTGlzdC5pdGVyYXRvcigpLCBjaGlsZHJlbkxpc3Quc2l6ZSgpKTsKLQkJCVRyZWVNb2RlbEFkYXB0ZXIudGhpcy5yZW1vdmVDaGlsZHJlbihwYXJlbnRQYXRoLCBjaGlsZEluZGljZXMsIGNoaWxkQXJyYXkpOwotCQl9Ci0KLQkJLyoqCi0JCSAqIFJlbW92ZSBhbGwgdGhlIG9sZCBub2RlcyBhbmQgYWRkIGFsbCB0aGUgbmV3IG5vZGVzLgotCQkgKi8KLQkJdm9pZCByZWJ1aWxkQ2hpbGRyZW4oKSB7Ci0JCQlUcmVlTm9kZVZhbHVlTW9kZWw8VD4gcGFyZW50ID0gdGhpcy5wYXJlbnQoKTsKLQkJCVRyZWVOb2RlVmFsdWVNb2RlbDxUPltdIHBhcmVudFBhdGggPSBwYXJlbnQucGF0aCgpOwotCQkJTGlzdDxUcmVlTm9kZVZhbHVlTW9kZWw8VD4+IGNoaWxkcmVuTGlzdCA9IFRyZWVNb2RlbEFkYXB0ZXIudGhpcy5jaGlsZHJlbkxpc3RzLmdldChwYXJlbnQpOwotCQkJaW50W10gY2hpbGRJbmRpY2VzID0gdGhpcy5idWlsZEluZGljZXMoY2hpbGRyZW5MaXN0LnNpemUoKSk7Ci0JCQlUcmVlTm9kZVZhbHVlTW9kZWw8VD5bXSBjaGlsZEFycmF5ID0gdGhpcy5idWlsZEFycmF5KGNoaWxkcmVuTGlzdC5pdGVyYXRvcigpLCBjaGlsZHJlbkxpc3Quc2l6ZSgpKTsKLQkJCVRyZWVNb2RlbEFkYXB0ZXIudGhpcy5yZW1vdmVDaGlsZHJlbihwYXJlbnRQYXRoLCBjaGlsZEluZGljZXMsIGNoaWxkQXJyYXkpOwotCi0JCQljaGlsZEluZGljZXMgPSB0aGlzLmJ1aWxkSW5kaWNlcyhwYXJlbnQuY2hpbGRyZW5Nb2RlbCgpLnNpemUoKSk7Ci0JCQljaGlsZEFycmF5ID0gdGhpcy5idWlsZEFycmF5KHBhcmVudC5jaGlsZHJlbk1vZGVsKCkuaXRlcmF0b3IoKSwgcGFyZW50LmNoaWxkcmVuU2l6ZSgpKTsKLQkJCVRyZWVNb2RlbEFkYXB0ZXIudGhpcy5hZGRDaGlsZHJlbihwYXJlbnRQYXRoLCBjaGlsZEluZGljZXMsIGNoaWxkQXJyYXkpOwotCQl9Ci0KLQkJLyoqCi0JCSAqIFRoZSBMaXN0Q2hhbmdlRXZlbnQncyByZXBsYWNlZCBpdGVtcyBhcmUgdGhlIHJlcGxhY2VkIGNoaWxkcmVuLgotCQkgKi8KLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCVRyZWVOb2RlVmFsdWVNb2RlbDxUPltdIHJlcGxhY2VkQ2hpbGRyZW4oKSB7Ci0JCQlyZXR1cm4gdGhpcy5idWlsZEFycmF5KChJdGVyYXRvcjxUcmVlTm9kZVZhbHVlTW9kZWw8VD4+KSB0aGlzLmV2ZW50LnJlcGxhY2VkSXRlbXMoKSwgdGhpcy5ldmVudC5pdGVtc1NpemUoKSk7Ci0JCX0KLQotCX0KLQotCi0JLyoqCi0JICogV3JhcHMgYSBUcmVlTm9kZVZhbHVlTW9kZWwgZm9yIGFkZGluZyBhbmQgcmVtb3ZpbmcgaXRzIGNoaWxkcmVuLgotCSAqLwotCXByaXZhdGUgY2xhc3MgTm9kZUNoYW5nZVBvbGljeSBleHRlbmRzIENoYW5nZVBvbGljeSB7Ci0JCXByaXZhdGUgVHJlZU5vZGVWYWx1ZU1vZGVsPFQ+IG5vZGU7Ci0KLQkJTm9kZUNoYW5nZVBvbGljeShUcmVlTm9kZVZhbHVlTW9kZWw8VD4gbm9kZSkgewotCQkJdGhpcy5ub2RlID0gbm9kZTsKLQkJfQotCi0JCS8qKgotCQkgKiBUaGUgbm9kZSBpdHNlbGYgaXMgdGhlIHBhcmVudC4KLQkJICovCi0JCUBPdmVycmlkZQotCQlUcmVlTm9kZVZhbHVlTW9kZWw8VD4gcGFyZW50KCkgewotCQkJcmV0dXJuIHRoaXMubm9kZTsKLQkJfQotCi0JCS8qKgotCQkgKiBTaW5jZSB3ZSB3aWxsIGFsd2F5cyBiZSBkZWFsaW5nIHdpdGggYWxsIG9mIHRoZSBub2RlJ3MKLQkJICogY2hpbGRyZW4sIHRoZSBjaGlsZHJlbiBzdGFydCBpbmRleCBpcyBhbHdheXMgemVyby4KLQkJICovCi0JCUBPdmVycmlkZQotCQlpbnQgY2hpbGRyZW5TdGFydEluZGV4KCkgewotCQkJcmV0dXJuIDA7Ci0JCX0KLQotCQkvKioKLQkJICogU2luY2Ugd2Ugd2lsbCBhbHdheXMgYmUgZGVhbGluZyB3aXRoIGFsbCBvZiB0aGUgbm9kZSdzCi0JCSAqIGNoaWxkcmVuLCB0aGUgY2hpbGRyZW4gc2l6ZSBpcyBhbHdheXMgZXF1YWwgdG8gdGhlIHNpemUKLQkJICogb2YgdGhlIGNoaWxkcmVuIG1vZGVsLgotCQkgKi8KLQkJQE92ZXJyaWRlCi0JCWludCBjaGlsZHJlblNpemUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5ub2RlLmNoaWxkcmVuTW9kZWwoKS5zaXplKCk7Ci0JCX0KLQotCQkvKioKLQkJICogU2luY2Ugd2Ugd2lsbCBhbHdheXMgYmUgZGVhbGluZyB3aXRoIGFsbCBvZiB0aGUgbm9kZSdzCi0JCSAqIGNoaWxkcmVuLCB0aGUgY2hpbGRyZW4gYXJlIGFsbCB0aGUgb2JqZWN0cyBoZWxkIGJ5Ci0JCSAqIHRoZSBjaGlsZHJlbiBtb2RlbC4KLQkJICovCi0JCUBPdmVycmlkZQotCQlJdGVyYXRvcjxUcmVlTm9kZVZhbHVlTW9kZWw8VD4+IGNoaWxkcmVuKCkgewotCQkJcmV0dXJuIHRoaXMubm9kZS5jaGlsZHJlbk1vZGVsKCkuaXRlcmF0b3IoKTsKLQkJfQotCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbm9kZS9BYnN0cmFjdE5vZGUuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9ub2RlL0Fic3RyYWN0Tm9kZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0YTg0ZTE4Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9ub2RlL0Fic3RyYWN0Tm9kZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsOTQ4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubm9kZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkhhc2hNYXA7Ci1pbXBvcnQgamF2YS51dGlsLkhhc2hTZXQ7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLlNldDsKLWltcG9ydCBqYXZhLnV0aWwuVmVjdG9yOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkNsb25lSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkNsb25lTGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5GaWx0ZXJpbmdJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkNhbGxiYWNrQ2hhbmdlU3VwcG9ydDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5DaGFuZ2VTdXBwb3J0OwotCi0vKioKLSAqIEJhc2UgY2xhc3MgZm9yIE5vZGUgY2xhc3Nlcy4KLSAqIFByb3ZpZGVzIHN1cHBvcnQgZm9yIHRoZSBmb2xsb3dpbmc6Ci0gKiAgICAgaW5pdGlhbGl6YXRpb24KLSAqICAgICBlbmZvcmNlZCBvYmplY3QgaWRlbnRpdHkgd3J0ICNlcXVhbHMoKS8jaGFzaENvZGUoKQotICogICAgIGNvbnRhaW5tZW50IGhpZXJhcmNoeSAocGFyZW50L2NoaWxkKQotICogICAgIHVzZXIgY29tbWVudAotICogICAgIGRpcnR5IGZsYWcKLSAqICAgICBwcm9ibGVtcwotICogICAgIHNvcnRpbmcKLSAqIAotICogVHlwaWNhbGx5LCBzdWJjbGFzc2VzIHNob3VsZCBjb25zaWRlciBpbXBsZW1lbnRpbmcgdGhlIGZvbGxvd2luZyBtZXRob2RzOgotICogICAgIHRoZSBhcHByb3ByaWF0ZSBjb25zdHJ1Y3RvcnMKLSAqICAgICAgICAgKHdpdGggdGhlIGFwcHJvcHJpYXRlbHktcmVzdHJpY3RpdmUgdHlwZSBkZWNsYXJhdGlvbiBmb3IgcGFyZW50KQotICogICAgICNpbml0aWFsaXplKCkKLSAqICAgICAjaW5pdGlhbGl6ZShOb2RlIHBhcmVudE5vZGUpCi0gKiAgICAgI2NoZWNrUGFyZW50KE5vZGUgcGFyZW50Tm9kZSkKLSAqICAgICAjYWRkQ2hpbGRyZW5UbyhMaXN0IGxpc3QpCi0gKiAgICAgI25vZGVSZW1vdmVkKE5vZGUpCi0gKiAgICAgI3ZhbGlkYXRvcigpCi0gKiAgICAgI3RyYW5zaWVudEFzcGVjdE5hbWVzKCkgb3IKLSAqICAgICAgICAgI2FkZFRyYW5zaWVudEFzcGVjdE5hbWVzVG8oU2V0IHRyYW5zaWVudEFzcGVjdE5hbWVzKQotICogICAgICNhZGRQcm9ibGVtc1RvKExpc3QgY3VycmVudFByb2JsZW1zKQotICogICAgICNub25WYWxpZGF0ZWRBc3BlY3ROYW1lcygpCi0gKiAgICAgICAgICNhZGROb25WYWxpZGF0ZWRBc3BlY3ROYW1lc1RvKFNldCBub25WYWxpZGF0ZWRBc3BlY3ROYW1lcykKLSAqICAgICAjZGlzcGxheVN0cmluZygpCi0gKiAgICAgI3RvU3RyaW5nKFN0cmluZ0J1aWxkZXIgc2IpCi0gKi8KLXB1YmxpYyBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdE5vZGUgCi0JZXh0ZW5kcyBBYnN0cmFjdE1vZGVsCi0JaW1wbGVtZW50cyBOb2RlCi17Ci0KLQkvKiogQ29udGFpbm1lbnQgaGllcmFyY2h5LiAqLwotCXByaXZhdGUgTm9kZSBwYXJlbnQ7ICAvLyBwc2V1ZG8tZmluYWwKLQotCS8qKiBUcmFjayB3aGV0aGVyIHRoZSBub2RlIGhhcyBjaGFuZ2VkLiAqLwotCXByaXZhdGUgdm9sYXRpbGUgYm9vbGVhbiBkaXJ0eTsKLQlwcml2YXRlIHZvbGF0aWxlIGJvb2xlYW4gZGlydHlCcmFuY2g7Ci0KLQkvKioKLQkgKiBUaGUgbm9kZSdzIHByb2JsZW1zLCBhcyBjYWxjdWxhdGVkIGR1cmluZyB2YWxpZGF0aW9uLgotCSAqIFRoaXMgbGlzdCBzaG91bGQgb25seSBiZSBtb2RpZmllZCB2aWEgYSBQcm9ibGVtU3luY2hyb25pemVyLAotCSAqIGFsbG93aW5nIGZvciBhc3luY2hyb25vdXMgbW9kaWZpY2F0aW9uIGZyb20gYW5vdGhlciB0aHJlYWQuCi0JICovCi0JcHJpdmF0ZSBWZWN0b3I8UHJvYmxlbT4gcHJvYmxlbXM7CQkvLyBwc2V1ZG8tZmluYWwKLQkJcHJpdmF0ZSBzdGF0aWMgZmluYWwgT2JqZWN0W10gRU1QVFlfUFJPQkxFTV9NRVNTQUdFX0FSR1VNRU5UUyA9IG5ldyBPYmplY3RbMF07Ci0KLQkvKioKLQkgKiBDYWNoZSB0aGUgbm9kZSdzICJicmFuY2giIHByb2JsZW1zLCBhcyBjYWxjdWxhdGVkIGR1cmluZyB2YWxpZGF0aW9uLgotCSAqIFRoaXMgbGlzdCBzaG91bGQgb25seSBiZSBtb2RpZmllZCB2aWEgYSBQcm9ibGVtU3luY2hyb25pemVyLAotCSAqIGFsbG93aW5nIGZvciBhc3luY2hyb25vdXMgbW9kaWZpY2F0aW9uIGZyb20gYW5vdGhlciB0aHJlYWQuCi0JICogVGhpcyBtdXN0IGJlIHJlY2FsY3VsYXRlZCBldmVyeSB0aW1lIHRoaXMgbm9kZSBvciBvbmUgb2YgaXRzCi0JICogZGVzY2VuZGFudHMgY2hhbmdlcyBpdCBwcm9ibGVtcy4KLQkgKi8KLQlwcml2YXRlIFZlY3RvcjxQcm9ibGVtPiBicmFuY2hQcm9ibGVtczsJCS8vIHBzZXVkby1maW5hbAotCi0JLyoqIFVzZXIgY29tbWVudC4gKi8KLQlwcml2YXRlIHZvbGF0aWxlIFN0cmluZyBjb21tZW50OwotCi0KLQkvLyAqKioqKioqKioqIHN0YXRpYyBmaWVsZHMgKioqKioqKioqKgotCi0JLyoqCi0JICogU2V0cyBvZiB0cmFuc2llbnQgYXNwZWN0IG5hbWVzLCBrZXllZCBieSBjbGFzcy4KLQkgKiBUaGlzIGlzIGJ1aWx0IHVwIGxhemlseSwgYXMgdGhlIG9iamVjdHMgYXJlIG1vZGlmaWVkLgotCSAqLwotCXByaXZhdGUgc3RhdGljIGZpbmFsIEhhc2hNYXA8Q2xhc3M8PyBleHRlbmRzIEFic3RyYWN0Tm9kZT4sIEhhc2hTZXQ8U3RyaW5nPj4gdHJhbnNpZW50QXNwZWN0TmFtZVNldHMgPSBuZXcgSGFzaE1hcDxDbGFzczw/IGV4dGVuZHMgQWJzdHJhY3ROb2RlPiwgSGFzaFNldDxTdHJpbmc+PigpOwotCi0JLyoqCi0JICogU2V0cyBvZiBub24tdmFsaWRhdGVkIGFzcGVjdCBuYW1lcywga2V5ZWQgYnkgY2xhc3MuCi0JICogVGhpcyBpcyBidWlsdCB1cCBsYXppbHksIGFzIHRoZSBvYmplY3RzIGFyZSBtb2RpZmllZC4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBIYXNoTWFwPENsYXNzPD8gZXh0ZW5kcyBBYnN0cmFjdE5vZGU+LCBIYXNoU2V0PFN0cmluZz4+IG5vblZhbGlkYXRlZEFzcGVjdE5hbWVTZXRzID0gbmV3IEhhc2hNYXA8Q2xhc3M8PyBleHRlbmRzIEFic3RyYWN0Tm9kZT4sIEhhc2hTZXQ8U3RyaW5nPj4oKTsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogTW9zdCBvYmplY3RzIG11c3QgaGF2ZSBhIHBhcmVudC4KLQkgKiBVc2UgdGhpcyBjb25zdHJ1Y3RvciB0byBjcmVhdGUgYSBuZXcgbm9kZS4KLQkgKiBAc2VlICNpbml0aWFsaXplKE5vZGUpCi0JICovCi0JcHJvdGVjdGVkIEFic3RyYWN0Tm9kZShOb2RlIHBhcmVudCkgewotCQlzdXBlcigpOwotCQl0aGlzLmluaXRpYWxpemUoKTsKLQkJdGhpcy5pbml0aWFsaXplKHBhcmVudCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIEluaXRpYWxpemUgYSBuZXdseS1jcmVhdGVkIGluc3RhbmNlLgotCSAqIEBzZWUgI2luaXRpYWxpemUoTm9kZSkKLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplKCkgewotCQl0aGlzLmNvbW1lbnQgPSAiIjsgLy8kTk9OLU5MUy0xJAotCi0JCS8vIGEgbmV3IG9iamVjdCBpcyBkaXJ0eSwgYnkgZGVmaW5pdGlvbgotCQl0aGlzLmRpcnR5ID0gdHJ1ZTsKLQkJdGhpcy5kaXJ0eUJyYW5jaCA9IHRydWU7Ci0KLQkJdGhpcy5wcm9ibGVtcyA9IG5ldyBWZWN0b3I8UHJvYmxlbT4oKTsKLQkJdGhpcy5icmFuY2hQcm9ibGVtcyA9IG5ldyBWZWN0b3I8UHJvYmxlbT4oKTsKLQotCS8vIHdoZW4geW91IG92ZXJyaWRlIHRoaXMgbWV0aG9kLCBkb24ndCBmb3JnZXQgdG8gaW5jbHVkZToKLQkvLwlzdXBlci5pbml0aWFsaXplKCk7Ci0JfQotCi0JLyoqCi0JICogSW5pdGlhbGl6ZSBhIG5ld2x5LWNyZWF0ZWQgaW5zdGFuY2UuCi0JICogQHNlZSAjaW5pdGlhbGl6ZSgpCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZShOb2RlIHBhcmVudE5vZGUpIHsKLQkJdGhpcy5jaGVja1BhcmVudChwYXJlbnROb2RlKTsKLQkJdGhpcy5wYXJlbnQgPSBwYXJlbnROb2RlOwotCS8vIHdoZW4geW91IG92ZXJyaWRlIHRoaXMgbWV0aG9kLCBkb24ndCBmb3JnZXQgdG8gaW5jbHVkZToKLQkvLwlzdXBlci5pbml0aWFsaXplKHBhcmVudE5vZGUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBDaGFuZ2VTdXBwb3J0IGJ1aWxkQ2hhbmdlU3VwcG9ydCgpIHsKLQkJcmV0dXJuIG5ldyBDYWxsYmFja0NoYW5nZVN1cHBvcnQodGhpcywgdGhpcy5idWlsZENoYW5nZVN1cHBvcnRMaXN0ZW5lcigpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgQ2FsbGJhY2tDaGFuZ2VTdXBwb3J0Lkxpc3RlbmVyIGJ1aWxkQ2hhbmdlU3VwcG9ydExpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IENhbGxiYWNrQ2hhbmdlU3VwcG9ydC5MaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIGFzcGVjdENoYW5nZWQoU3RyaW5nIGFzcGVjdE5hbWUpIHsKLQkJCQlBYnN0cmFjdE5vZGUudGhpcy5hc3BlY3RDaGFuZ2VkKGFzcGVjdE5hbWUpOwotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBlcXVhbGl0eSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBFbmZvcmNlIG9iamVjdCBpZGVudGl0eSAtIGRvIG5vdCBhbGxvdyBvYmplY3RzIHRvIGJlIGVxdWFsIHVubGVzcwotCSAqIHRoZXkgYXJlIHRoZSBzYW1lIG9iamVjdC4KLQkgKiBEbyBOT1Qgb3ZlcnJpZGUgdGhpcyBtZXRob2QgLSB3ZSByZWx5IG9uIG9iamVjdCBpZGVudGl0eSBleHRlbnNpdmVseS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgZmluYWwgYm9vbGVhbiBlcXVhbHMoT2JqZWN0IG8pIHsKLQkJcmV0dXJuIHRoaXMgPT0gbzsKLQl9Ci0KLQkvKioKLQkgKiBFbmZvcmNlIG9iamVjdCBpZGVudGl0eSAtIGRvIG5vdCBhbGxvdyBvYmplY3RzIHRvIGJlIGVxdWFsIHVubGVzcwotCSAqIHRoZXkgYXJlIHRoZSBzYW1lIG9iamVjdC4KLQkgKiBEbyBOT1Qgb3ZlcnJpZGUgdGhpcyBtZXRob2QgLSB3ZSByZWx5IG9uIG9iamVjdCBpZGVudGl0eSBleHRlbnNpdmVseS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgZmluYWwgaW50IGhhc2hDb2RlKCkgewotCQlyZXR1cm4gc3VwZXIuaGFzaENvZGUoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY29udGFpbm1lbnQgaGllcmFyY2h5IChwYXJlbnQvY2hpbGRyZW4pICoqKioqKioqKioKLQotCS8qKgotCSAqIElOVFJBLVRSRUUgQVBJPwotCSAqIFJldHVybiB0aGUgbm9kZSdzIHBhcmVudCBpbiB0aGUgY29udGFpbm1lbnQgaGllcmFyY2h5LgotCSAqIE1vc3Qgbm9kZXMgbXVzdCBoYXZlIGEgcGFyZW50LgotCSAqIEBzZWUgI2NoaWxkcmVuKCkKLQkgKi8KLQlwdWJsaWMgTm9kZSBnZXRQYXJlbnQoKSB7Ci0JCXJldHVybiB0aGlzLnBhcmVudDsKLQl9Ci0KLQkvKioKLQkgKiBUaHJvdyBhbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gaWYgdGhlIHBhcmVudCBpcyBub3QgdmFsaWQKLQkgKiBmb3IgdGhlIG5vZGUuCi0JICogQnkgZGVmYXVsdCByZXF1aXJlIGEgbm9uLW51bGwgcGFyZW50LiBPdmVycmlkZSBpZiBvdGhlciByZXN0cmljdGlvbnMgZXhpc3QKLQkgKiBvciB0aGUgcGFyZW50IHNob3VsZCBiZSBudWxsLgotCSAqIE5COiBSb290IG5vZGUgbW9kZWwgaW1wbGVtZW50YXRpb25zIHdpbGwgbmVlZCB0byBvdmVycmlkZSB0aGlzIG1ldGhvZC4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBjaGVja1BhcmVudChOb2RlIHBhcmVudE5vZGUpIHsKLQkJaWYgKHBhcmVudE5vZGUgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiVGhlIHBhcmVudCBub2RlIGNhbm5vdCBiZSBudWxsIik7IC8vJE5PTi1OTFMtMSQKLQkJfQotCX0KLQotCS8qKgotCSAqIElOVFJBLVRSRUUgQVBJPwotCSAqIFJldHVybiB0aGUgbm9kZSdzIGNoaWxkcmVuLCB3aGljaCBhcmUgYWxzbyBub2Rlcy4KLQkgKiBEbyBOT1Qgb3ZlcnJpZGUgdGhpcyBtZXRob2QuCi0JICogT3ZlcnJpZGUgI2FkZENoaWxkcmVuVG8oTGlzdCkuCi0JICogQHNlZSAjZ2V0UGFyZW50KCkKLQkgKiBAc2VlICNhZGRDaGlsZHJlblRvKGphdmEudXRpbC5MaXN0KQotCSAqLwotCXB1YmxpYyBmaW5hbCBJdGVyYXRvcjxOb2RlPiBjaGlsZHJlbigpIHsKLQkJTGlzdDxOb2RlPiBjaGlsZHJlbiA9IG5ldyBBcnJheUxpc3Q8Tm9kZT4oKTsKLQkJdGhpcy5hZGRDaGlsZHJlblRvKGNoaWxkcmVuKTsKLQkJcmV0dXJuIGNoaWxkcmVuLml0ZXJhdG9yKCk7Ci0JfQotCi0JLyoqCi0JICogU3ViY2xhc3NlcyBzaG91bGQgb3ZlcnJpZGUgdGhpcyBtZXRob2QgdG8gYWRkIHRoZWlyIGNoaWxkcmVuCi0JICogdG8gdGhlIHNwZWNpZmllZCBsaXN0LgotCSAqIEBzZWUgI2NoaWxkcmVuKCkKLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBhZGRDaGlsZHJlblRvKEBTdXBwcmVzc1dhcm5pbmdzKCJ1bnVzZWQiKSBMaXN0PE5vZGU+IGxpc3QpIHsKLQkJLy8gdGhpcyBjbGFzcyBoYXMgbm8gY2hpbGRyZW4sIHN1YmNsYXNzZXMgd2lsbC4uLgotCS8vIHdoZW4geW91IG92ZXJyaWRlIHRoaXMgbWV0aG9kLCBkb24ndCBmb3JnZXQgdG8gaW5jbHVkZToKLQkvLwlzdXBlci5hZGRDaGlsZHJlblRvKGxpc3QpOwotCX0KLQotCS8qKgotCSAqIElOVFJBLVRSRUUgQVBJPwotCSAqIFJldHVybiB0aGUgY29udGFpbm1lbnQgaGllcmFyY2h5J3Mgcm9vdCBub2RlLgotCSAqIE1vc3Qgbm9kZXMgbXVzdCBoYXZlIGEgcm9vdC4KLQkgKiBAc2VlICNnZXRQYXJlbnQoKQotCSAqIE5COiBBc3N1bWUgdGhlIHJvb3QgaGFzIG5vIHBhcmVudC4KLQkgKi8KLQlwdWJsaWMgTm9kZSByb290KCkgewotCQlOb2RlIHAgPSB0aGlzLnBhcmVudDsKLQkJcmV0dXJuIChwID09IG51bGwpID8gdGhpcyA6IHAucm9vdCgpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBub2RlIGlzIGEgZGVzY2VuZGFudCBvZiB0aGUgc3BlY2lmaWVkIG5vZGUuCi0JICogQnkgZGVmaW5pdGlvbiwgYSBub2RlIGlzIGEgZGVzY2VuZGFudCBvZiBpdHNlbGYuCi0JICovCi0JcHVibGljIGJvb2xlYW4gaXNEZXNjZW5kYW50T2YoTm9kZSBub2RlKSB7Ci0JCXJldHVybiAodGhpcyA9PSBub2RlKSB8fCB0aGlzLnBhcmVudElzRGVzY2VuZGFudE9mKG5vZGUpOwotCX0KLQotCXByb3RlY3RlZCBib29sZWFuIHBhcmVudElzRGVzY2VuZGFudE9mKE5vZGUgbm9kZSkgewotCQlyZXR1cm4gKHRoaXMucGFyZW50ICE9IG51bGwpICYmIHRoaXMucGFyZW50LmlzRGVzY2VuZGFudE9mKG5vZGUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIGNvbGxlY3Rpb24gaG9sZGluZyBhbGwgdGhlIG5vZGUncyAicmVmZXJlbmNlcyIsIGFuZCBhbGwKLQkgKiB0aGUgbm9kZSdzIGRlc2NlbmRhbnRzJyAicmVmZXJlbmNlcyIuICJSZWZlcmVuY2VzIiBhcmUKLQkgKiBvYmplY3RzIHRoYXQgYXJlICJyZWZlcmVuY2VkIiBieSBhbm90aGVyIG9iamVjdCwgYXMgb3Bwb3NlZAotCSAqIHRvICJvd25lZCIgYnkgYW5vdGhlciBvYmplY3QuCi0JICovCi0JcHVibGljIEl0ZXJhdG9yPE5vZGUuUmVmZXJlbmNlPiBicmFuY2hSZWZlcmVuY2VzKCkgewotCQlDb2xsZWN0aW9uPE5vZGUuUmVmZXJlbmNlPiBicmFuY2hSZWZlcmVuY2VzID0gbmV3IEFycmF5TGlzdDxOb2RlLlJlZmVyZW5jZT4oMTAwMCk7CQkvLyBzdGFydCBiaWcKLQkJdGhpcy5hZGRCcmFuY2hSZWZlcmVuY2VzVG8oYnJhbmNoUmVmZXJlbmNlcyk7Ci0JCXJldHVybiBicmFuY2hSZWZlcmVuY2VzLml0ZXJhdG9yKCk7Ci0JfQotCi0JLyoqCi0JICogSU5UUkEtVFJFRSBBUEkKLQkgKiBBZGQgdGhlIG5vZGUncyAicmVmZXJlbmNlcyIsIGFuZCBhbGwgdGhlIG5vZGUncyBkZXNjZW5kYW50cycKLQkgKiAicmVmZXJlbmNlcyIsIHRvIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbi4gIlJlZmVyZW5jZXMiIGFyZQotCSAqIG9iamVjdHMgdGhhdCBhcmUgInJlZmVyZW5jZWQiIGJ5IGFub3RoZXIgb2JqZWN0LCBhcyBvcHBvc2VkCi0JICogdG8gIm93bmVkIiBieSBhbm90aGVyIG9iamVjdC4KLQkgKiBUaGlzIG1ldGhvZCBpcyBvZiBwYXJ0aWN1bGFyIGNvbmNlcm4gdG8gSGFuZGxlcywgc2luY2UgbW9zdAotCSAqIChob3BlZnVsbHkgYWxsKSAicmVmZXJlbmNlcyIgYXJlIGhlbGQgYnkgSGFuZGxlcy4KLQkgKiBAc2VlIFJlZmVyZW5jZQotCSAqIEBzZWUgI2NoaWxkcmVuKCkKLQkgKi8KLQlwdWJsaWMgdm9pZCBhZGRCcmFuY2hSZWZlcmVuY2VzVG8oQ29sbGVjdGlvbjxOb2RlLlJlZmVyZW5jZT4gYnJhbmNoUmVmZXJlbmNlcykgewotCQlmb3IgKEl0ZXJhdG9yPE5vZGU+IHN0cmVhbSA9IHRoaXMuY2hpbGRyZW4oKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQlOb2RlIGNoaWxkID0gc3RyZWFtLm5leHQoKTsJCS8vIHB1bGwgb3V0IHRoZSBjaGlsZCB0byBlYXNlIGRlYnVnZ2luZwotCQkJY2hpbGQuYWRkQnJhbmNoUmVmZXJlbmNlc1RvKGJyYW5jaFJlZmVyZW5jZXMpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGFsbCB0aGUgbm9kZXMgaW4gdGhlIG9iamVjdCdzIGJyYW5jaCBvZiB0aGUgdHJlZSwKLQkgKiBpbmNsdWRpbmcgdGhlIG5vZGUgaXRzZWxmLiBUaGUgbm9kZXMgd2lsbCBwcm9iYWJseSByZXR1cm5lZAotCSAqIGluICJkZXB0aC1maXJzdCIgb3JkZXIuCi0JICogT25seSByZWFsbHkgdXNlZCBmb3IgdGVzdGluZyBhbmQgZGVidWdnaW5nLgotCSAqLwotCXB1YmxpYyBJdGVyYXRvcjxOb2RlPiBhbGxOb2RlcygpIHsKLQkJQ29sbGVjdGlvbjxOb2RlPiBub2RlcyA9IG5ldyBBcnJheUxpc3Q8Tm9kZT4oMTAwMCk7CQkvLyBzdGFydCBiaWcKLQkJdGhpcy5hZGRBbGxOb2Rlc1RvKG5vZGVzKTsKLQkJcmV0dXJuIG5vZGVzLml0ZXJhdG9yKCk7Ci0JfQotCi0JLyoqCi0JICogSU5UUkEtVFJFRSBBUEk/Ci0JICogQWRkIGFsbCB0aGUgbm9kZXMgaW4gdGhlIG9iamVjdCdzIGJyYW5jaCBvZiB0aGUgdHJlZSwKLQkgKiBpbmNsdWRpbmcgdGhlIG5vZGUgaXRzZWxmLCB0byB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24uCi0JICogT25seSByZWFsbHkgdXNlZCBmb3IgdGVzdGluZyBhbmQgZGVidWdnaW5nLgotCSAqLwotCXB1YmxpYyB2b2lkIGFkZEFsbE5vZGVzVG8oQ29sbGVjdGlvbjxOb2RlPiBub2RlcykgewotCQlub2Rlcy5hZGQodGhpcyk7Ci0JCWZvciAoSXRlcmF0b3I8Tm9kZT4gc3RyZWFtID0gdGhpcy5jaGlsZHJlbigpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCU5vZGUgY2hpbGQgPSBzdHJlYW0ubmV4dCgpOwkJLy8gcHVsbCBvdXQgdGhlIGNoaWxkIHRvIGVhc2UgZGVidWdnaW5nCi0JCQljaGlsZC5hZGRBbGxOb2Rlc1RvKG5vZGVzKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBtb2RlbCBzeW5jaHJvbml6YXRpb24gc3VwcG9ydCAqKioqKioqKioqCi0KLQkvKioKLQkgKiBJTlRSQS1UUkVFIEFQSQotCSAqIFRoaXMgaXMgYSBnZW5lcmFsIG5vdGlmaWNhdGlvbiB0aGF0IHRoZSBzcGVjaWZpZWQgbm9kZSBoYXMgYmVlbgotCSAqIHJlbW92ZWQgZnJvbSB0aGUgdHJlZS4gVGhlIG5vZGUgcmVjZWl2aW5nIHRoaXMgbm90aWZpY2F0aW9uCi0JICogc2hvdWxkIHBlcmZvcm0gYW55IG5lY2Vzc2FyeSB1cGRhdGVzIHRvIHJlbWFpbiBpbiBzeW5jaAotCSAqIHdpdGggdGhlIHRyZWUgKGUuZy4gY2xlYXJpbmcgb3V0IG9yIHJlcGxhY2luZyBhbnkgcmVmZXJlbmNlcwotCSAqIHRvIHRoZSByZW1vdmVkIG5vZGUgb3IgYW55IG9mIHRoZSByZW1vdmVkIG5vZGUncyBkZXNjZW5kYW50cykuCi0JICogQHNlZSAjaXNEZXNjZW5kYW50T2YoTm9kZSkKLQkgKi8KLQlwdWJsaWMgdm9pZCBub2RlUmVtb3ZlZChOb2RlIG5vZGUpIHsKLQkJZm9yIChJdGVyYXRvcjxOb2RlPiBzdHJlYW0gPSB0aGlzLmNoaWxkcmVuKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJTm9kZSBjaGlsZCA9IHN0cmVhbS5uZXh0KCk7CQkvLyBwdWxsIG91dCB0aGUgY2hpbGQgdG8gZWFzZSBkZWJ1Z2dpbmcKLQkJCWNoaWxkLm5vZGVSZW1vdmVkKG5vZGUpOwotCQl9Ci0JLy8gd2hlbiB5b3Ugb3ZlcnJpZGUgdGhpcyBtZXRob2QsIGRvbid0IGZvcmdldCB0byBpbmNsdWRlOgotCS8vCXN1cGVyLm5vZGVSZW1vdmVkKG5vZGUpOwotCX0KLQotCS8qKgotCSAqIGNvbnZlbmllbmNlIG1ldGhvZAotCSAqIHJldHVybiB3aGV0aGVyIG5vZGUxIGlzIGEgZGVzY2VuZGFudCBvZiBub2RlMjsKLQkgKiBub2RlMSBjYW4gYmUgbnVsbAotCSAqLwotCXByb3RlY3RlZCBib29sZWFuIG5vZGVJc0Rlc2NlbmRhbnRPZihOb2RlIG5vZGUxLCBOb2RlIG5vZGUyKSB7Ci0JCXJldHVybiAobm9kZTEgIT0gbnVsbCkgJiYgbm9kZTEuaXNEZXNjZW5kYW50T2Yobm9kZTIpOwotCX0KLQotCS8qKgotCSAqIElOVFJBLVRSRUUgQVBJCi0JICogVGhpcyBpcyBhIGdlbmVyYWwgbm90aWZpY2F0aW9uIHRoYXQgdGhlIHNwZWNpZmllZCBub2RlIGhhcyBiZWVuCi0JICogcmVuYW1lZC4gVGhlIG5vZGUgcmVjZWl2aW5nIHRoaXMgbm90aWZpY2F0aW9uIHNob3VsZCBtYXJrIGl0cwotCSAqIGJyYW5jaCBkaXJ0eSBpZiBuZWNlc3NhcnkgKGkuZS4gaXQgcmVmZXJlbmNlcyB0aGUgcmVuYW1lZCBub2RlCi0JICogb3Igb25lIG9mIGl0cyBkZXNjZW5kYW50cykuIFRoaXMgbWV0aG9kIGlzIG9mIHBhcnRpY3VsYXIgY29uY2VybgotCSAqIHRvIEhhbmRsZXMuCi0JICogQHNlZSAjaXNEZXNjZW5kYW50T2YoTm9kZSkKLQkgKi8KLQlwdWJsaWMgdm9pZCBub2RlUmVuYW1lZChOb2RlIG5vZGUpIHsKLQkJZm9yIChJdGVyYXRvcjxOb2RlPiBzdHJlYW0gPSB0aGlzLmNoaWxkcmVuKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJTm9kZSBjaGlsZCA9IHN0cmVhbS5uZXh0KCk7CQkvLyBwdWxsIG91dCB0aGUgY2hpbGQgdG8gZWFzZSBkZWJ1Z2dpbmcKLQkJCWNoaWxkLm5vZGVSZW5hbWVkKG5vZGUpOwotCQl9Ci0JLy8gd2hlbiB5b3Ugb3ZlcnJpZGUgdGhpcyBtZXRob2QsIGRvbid0IGZvcmdldCB0byBpbmNsdWRlOgotCS8vCXN1cGVyLm5vZGVSZW5hbWVkKG5vZGUpOwotCX0KLQkKLQkKLQkvLyAqKioqKioqKioqIHVzZXIgY29tbWVudCAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG9iamVjdCdzIHVzZXIgY29tbWVudC4KLQkgKi8KLQlwdWJsaWMgZmluYWwgU3RyaW5nIGNvbW1lbnQoKSB7Ci0JCXJldHVybiB0aGlzLmNvbW1lbnQ7Ci0JfQotCi0JLyoqCi0JICogU2V0IHRoZSBvYmplY3QncyB1c2VyIGNvbW1lbnQuCi0JICovCi0JcHVibGljIGZpbmFsIHZvaWQgc2V0Q29tbWVudChTdHJpbmcgY29tbWVudCkgewotCQlPYmplY3Qgb2xkID0gdGhpcy5jb21tZW50OwotCQl0aGlzLmNvbW1lbnQgPSBjb21tZW50OwotCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoQ09NTUVOVF9QUk9QRVJUWSwgb2xkLCBjb21tZW50KTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY2hhbmdlIHN1cHBvcnQgKioqKioqKioqKgotCi0JLyoqCi0JICogQW4gYXNwZWN0IG9mIHRoZSBub2RlIGhhcyBjaGFuZ2VkOgotCSAqIAktIGlmIGl0IGlzIGEgcGVyc2lzdGVudCBhc3BlY3QsIG1hcmsgdGhlIG9iamVjdCBkaXJ0eQotCSAqIAktIGlmIGl0IGlzIGEgc2lnbmlmaWNhbnQgYXNwZWN0LCB2YWxpZGF0ZSB0aGUgb2JqZWN0Ci0JICovCi0JcHJvdGVjdGVkIHZvaWQgYXNwZWN0Q2hhbmdlZChTdHJpbmcgYXNwZWN0TmFtZSkgewotCQlpZiAodGhpcy5hc3BlY3RJc1BlcnNpc3RlbnQoYXNwZWN0TmFtZSkpIHsKLQkJCS8vIFN5c3RlbS5vdXQucHJpbnRsbihUaHJlYWQuY3VycmVudFRocmVhZCgpICsgIiBkaXJ0eSBjaGFuZ2U6ICIgKyB0aGlzICsgIjogIiArIGFzcGVjdE5hbWUpOwotCQkJdGhpcy5tYXJrRGlydHkoKTsKLQkJfQotCQlpZiAodGhpcy5hc3BlY3RDaGFuZ2VSZXF1aXJlc1ZhbGlkYXRpb24oYXNwZWN0TmFtZSkpIHsKLQkJCS8vIFN5c3RlbS5vdXQucHJpbnRsbihUaHJlYWQuY3VycmVudFRocmVhZCgpICsgIiB2YWxpZGF0aW9uIGNoYW5nZTogIiArIHRoaXMgKyAiOiAiICsgYXNwZWN0TmFtZSk7Ci0JCQl0aGlzLnZhbGlkYXRlKCk7Ci0JCX0KLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCB2YWxpZGF0ZSgpIHsKLQkJdGhpcy5nZXRWYWxpZGF0b3IoKS52YWxpZGF0ZSgpOwotCX0KLQotCS8qKgotCSAqIElOVFJBLVRSRUUgQVBJCi0JICogUmV0dXJuIGEgdmFsaWRhdG9yIHRoYXQgd2lsbCBiZSBpbnZva2VkIHdoZW5ldmVyIGEKLQkgKiAidmFsaWRhdGVkIiBhc3BlY3Qgb2YgdGhlIG5vZGUgdHJlZSBjaGFuZ2VzLgotCSAqIFR5cGljYWxseSBvbmx5IHRoZSByb290IG5vZGUgZGlyZWN0bHkgaG9sZHMgYSB2YWxpZGF0b3IuCi0JICogTkI6IFJvb3Qgbm9kZSBtb2RlbCBpbXBsZW1lbnRhdGlvbnMgd2lsbCBuZWVkIHRvIG92ZXJyaWRlIHRoaXMgbWV0aG9kLgotCSAqLwotCXB1YmxpYyBOb2RlLlZhbGlkYXRvciBnZXRWYWxpZGF0b3IoKSB7Ci0JCWlmICh0aGlzLnBhcmVudCA9PSBudWxsKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJUaGlzIG5vZGUgc2hvdWxkIG5vdCBiZSBmaXJpbmcgY2hhbmdlIGV2ZW50cyBkdXJpbmcgaXRzIGNvbnN0cnVjdGlvbi4iKTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCXJldHVybiB0aGlzLnBhcmVudC5nZXRWYWxpZGF0b3IoKTsKLQl9Ci0KLQkvKioKLQkgKiBTZXQgYSB2YWxpZGF0b3IgdGhhdCB3aWxsIGJlIGludm9rZWQgd2hlbmV2ZXIgYQotCSAqICJ2YWxpZGF0ZWQiIGFzcGVjdCBvZiB0aGUgbm9kZSB0cmVlIGNoYW5nZXMuCi0JICogVHlwaWNhbGx5IG9ubHkgdGhlIHJvb3Qgbm9kZSBkaXJlY3RseSBob2xkcyBhIHZhbGlkYXRvci4KLQkgKiBOQjogUm9vdCBub2RlIG1vZGVsIGltcGxlbWVudGF0aW9ucyB3aWxsIG5lZWQgdG8gb3ZlcnJpZGUgdGhpcyBtZXRob2QuCi0JICovCi0JcHVibGljIHZvaWQgc2V0VmFsaWRhdG9yKE5vZGUuVmFsaWRhdG9yIHZhbGlkYXRvcikgewotCQlpZiAodGhpcy5wYXJlbnQgPT0gbnVsbCkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigiVGhpcyByb290IG5vZGUgc2hvdWxkIGltcGxlbWVudCAjc2V0VmFsaWRhdG9yKE5vZGUuVmFsaWRhdG9yKS4iKTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigiT25seSByb290IG5vZGVzIGltcGxlbWVudCAjc2V0VmFsaWRhdG9yKE5vZGUuVmFsaWRhdG9yKS4iKTsgLy8kTk9OLU5MUy0xJAotCX0KLQotCi0JLy8gKioqKioqKioqKiBkaXJ0eSBmbGFnIHN1cHBvcnQgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgYW55IHBlcnNpc3RlbnQgYXNwZWN0cyBvZiB0aGUgb2JqZWN0Ci0JICogaGF2ZSBjaGFuZ2VkIHNpbmNlIHRoZSBvYmplY3Qgd2FzIGxhc3QgcmVhZCBvciBzYXZlZC4KLQkgKiBUaGlzIGRvZXMgTk9UIGluY2x1ZGUgY2hhbmdlcyB0byB0aGUgb2JqZWN0J3MgZGVzY2VuZGFudHMuCi0JICovCi0JcHVibGljIGZpbmFsIGJvb2xlYW4gaXNEaXJ0eSgpIHsKLQkJcmV0dXJuIHRoaXMuZGlydHk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgYW55IHBlcnNpc3RlbnQgYXNwZWN0cyBvZiB0aGUgb2JqZWN0LAotCSAqIG9yIGFueSBvZiBpdHMgZGVzY2VuZGFudHMsIGhhdmUgY2hhbmdlZCBzaW5jZSB0aGUgb2JqZWN0IGFuZAotCSAqIGl0cyBkZXNjZW5kYW50cyB3ZXJlIGxhc3QgcmVhZCBvciBzYXZlZC4KLQkgKi8KLQlwdWJsaWMgZmluYWwgYm9vbGVhbiBpc0RpcnR5QnJhbmNoKCkgewotCQlyZXR1cm4gdGhpcy5kaXJ0eUJyYW5jaDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgb2JqZWN0IGlzIHVubW9kaWZpZWQKLQkgKiBzaW5jZSBpdCB3YXMgbGFzdCByZWFkIG9yIHNhdmVkLgotCSAqIFRoaXMgZG9lcyBOT1QgaW5jbHVkZSBjaGFuZ2VzIHRvIHRoZSBvYmplY3QncyBkZXNjZW5kYW50cy4KLQkgKi8KLQlwdWJsaWMgZmluYWwgYm9vbGVhbiBpc0NsZWFuKCkgewotCQlyZXR1cm4gISB0aGlzLmRpcnR5OwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBvYmplY3QgYW5kIGFsbCBvZiBpdHMgZGVzY2VuZGFudHMKLQkgKiBhcmUgdW5tb2RpZmllZCBzaW5jZSB0aGUgb2JqZWN0IGFuZAotCSAqIGl0cyBkZXNjZW5kYW50cyB3ZXJlIGxhc3QgcmVhZCBvciBzYXZlZC4KLQkgKi8KLQlwdWJsaWMgZmluYWwgYm9vbGVhbiBpc0NsZWFuQnJhbmNoKCkgewotCQlyZXR1cm4gISB0aGlzLmRpcnR5QnJhbmNoOwotCX0KLQotCS8qKgotCSAqIFNldCB0aGUgZGlydHkgYnJhbmNoIGZsYWcgc2V0dGluZy4gVGhpcyBpcyBzZXQgdG8gdHJ1ZQotCSAqIHdoZW4gZWl0aGVyIHRoZSBvYmplY3Qgb3Igb25lIG9mIGl0cyBkZXNjZW5kYW50cyBiZWNvbWVzIGRpcnR5LgotCSAqLwotCXByaXZhdGUgdm9pZCBzZXRJc0RpcnR5QnJhbmNoKGJvb2xlYW4gZGlydHlCcmFuY2gpIHsKLQkJYm9vbGVhbiBvbGQgPSB0aGlzLmRpcnR5QnJhbmNoOwotCQl0aGlzLmRpcnR5QnJhbmNoID0gZGlydHlCcmFuY2g7Ci0JCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChESVJUWV9CUkFOQ0hfUFJPUEVSVFksIG9sZCwgZGlydHlCcmFuY2gpOwotCX0KLQotCS8qKgotCSAqIE1hcmsgdGhlIG9iamVjdCBhcyBkaXJ0eSBhbmQgYXMgYSBkaXJ0eSBicmFuY2guCi0JICogQW4gb2JqZWN0IGlzIG1hcmtlZCBkaXJ0eSB3aGVuIGVpdGhlciBhICJwZXJzaXN0ZW50IiBhdHRyaWJ1dGUKLQkgKiBoYXMgY2hhbmdlZCBvciBpdHMgc2F2ZSBsb2NhdGlvbiBoYXMgY2hhbmdlZC4KLQkgKi8KLQlwcml2YXRlIHZvaWQgbWFya0RpcnR5KCkgewotCQl0aGlzLmRpcnR5ID0gdHJ1ZTsKLQkJdGhpcy5tYXJrQnJhbmNoRGlydHkoKTsKLQl9Ci0KLQkvKioKLQkgKiBJTlRSQS1UUkVFIEFQSQotCSAqIE1hcmsgdGhlIG5vZGUgYW5kIGl0cyBwYXJlbnQgYXMgZGlydHkgYnJhbmNoZXMuCi0JICogVGhpcyBtZXNzYWdlIGlzIHByb3BhZ2F0ZWQgdXAgdGhlIGNvbnRhaW5tZW50Ci0JICogdHJlZSB3aGVuIGEgcGFydGljdWxhciBub2RlIGJlY29tZXMgZGlydHkuCi0JICovCi0JcHVibGljIHZvaWQgbWFya0JyYW5jaERpcnR5KCkgewotCQkvLyBzaG9ydC1jaXJjdWl0IGFueSB1bm5lY2Vzc2FyeSBwcm9wYWdhdGlvbgotCQlpZiAodGhpcy5kaXJ0eUJyYW5jaCkgewotCQkJLy8gaWYgdGhpcyBpcyBhbHJlYWR5IGEgZGlydHkgYnJhbmNoLCB0aGUgcGFyZW50IG11c3QgYmUgYWxzbwotCQkJcmV0dXJuOwotCQl9Ci0KLQkJdGhpcy5zZXRJc0RpcnR5QnJhbmNoKHRydWUpOwotCQl0aGlzLm1hcmtQYXJlbnRCcmFuY2hEaXJ0eSgpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIG1hcmtQYXJlbnRCcmFuY2hEaXJ0eSgpIHsKLQkJaWYgKHRoaXMucGFyZW50ICE9IG51bGwpIHsKLQkJCXRoaXMucGFyZW50Lm1hcmtCcmFuY2hEaXJ0eSgpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogTWFyayB0aGUgb2JqZWN0IGFuZCBhbGwgaXRzIGRlc2NlbmRhbnRzIGFzIGRpcnR5LgotCSAqIFRoaXMgaXMgdXNlZCB3aGVuIHRoZSBzYXZlIGxvY2F0aW9uIG9mIHNvbWUKLQkgKiB0b3AtbGV2ZWwgb2JqZWN0IGlzIGNoYW5nZWQgYW5kIHRoZSBlbnRpcmUKLQkgKiBjb250YWlubWVudCB0cmVlIG11c3QgYmUgbWFya2VkIGRpcnR5IHNvIGl0Ci0JICogd2lsbCBiZSB3cml0dGVuIG91dC4KLQkgKi8KLQlwdWJsaWMgZmluYWwgdm9pZCBtYXJrRW50aXJlQnJhbmNoRGlydHkoKSB7Ci0JCXRoaXMubWFya0RpcnR5KCk7Ci0JCWZvciAoSXRlcmF0b3I8Tm9kZT4gc3RyZWFtID0gdGhpcy5jaGlsZHJlbigpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCU5vZGUgY2hpbGQgPSBzdHJlYW0ubmV4dCgpOwkJLy8gcHVsbCBvdXQgdGhlIGNoaWxkIHRvIGVhc2UgZGVidWdnaW5nCi0JCQljaGlsZC5tYXJrRW50aXJlQnJhbmNoRGlydHkoKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIE1hcmsgdGhlIG9iamVjdCBhbmQgYWxsIGl0cyBkZXNjZW5kYW50cyBhcyBjbGVhbi4KLQkgKiBUaGVuIG5vdGlmeSB0aGUgb2JqZWN0J3MgcGFyZW50IHRoYXQgaXQgKHRoZSBwYXJlbnQpCi0JICogbWlnaHQgbm93IGJlIGEgY2xlYW4gYnJhbmNoIGFsc28uCi0JICogVHlwaWNhbGx5IHVzZWQgd2hlbiB0aGUgb2JqZWN0IGhhcyBqdXN0IGJlZW4KLQkgKiByZWFkIGluIG9yIHdyaXR0ZW4gb3V0LgotCSAqLwotCXB1YmxpYyBmaW5hbCB2b2lkIG1hcmtFbnRpcmVCcmFuY2hDbGVhbigpIHsKLQkJdGhpcy5jYXNjYWRlTWFya0VudGlyZUJyYW5jaENsZWFuKCk7Ci0JCXRoaXMubWFya1BhcmVudEJyYW5jaENsZWFuSWZQb3NzaWJsZSgpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIG1hcmtQYXJlbnRCcmFuY2hDbGVhbklmUG9zc2libGUoKSB7Ci0JCWlmICh0aGlzLnBhcmVudCAhPSBudWxsKSB7Ci0JCQl0aGlzLnBhcmVudC5tYXJrQnJhbmNoQ2xlYW5JZlBvc3NpYmxlKCk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBJTlRSQS1UUkVFIEFQSQotCSAqIE1hcmsgdGhlIG5vZGUgYW5kIGFsbCBpdHMgZGVzY2VuZGFudHMgYXMgY2xlYW4uCi0JICogVHlwaWNhbGx5IHVzZWQgd2hlbiB0aGUgbm9kZSBoYXMganVzdCBiZWVuCi0JICogcmVhZCBpbiBvciB3cml0dGVuIG91dC4KLQkgKiBUaGlzIG1ldGhvZCBpcyBmb3IgaW50ZXJuYWwgdXNlIG9ubHk7IGl0IGlzIG5vdCBmb3IKLQkgKiBjbGllbnQgdXNlLgotCSAqIE5vdCB0aGUgYmVzdCBvZiBtZXRob2QgbmFtZXMuLi4uIDotKAotCSAqLwotCXB1YmxpYyBmaW5hbCB2b2lkIGNhc2NhZGVNYXJrRW50aXJlQnJhbmNoQ2xlYW4oKSB7Ci0JCWZvciAoSXRlcmF0b3I8Tm9kZT4gc3RyZWFtID0gdGhpcy5jaGlsZHJlbigpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCU5vZGUgY2hpbGQgPSBzdHJlYW0ubmV4dCgpOwkJLy8gcHVsbCBvdXQgdGhlIGNoaWxkIHRvIGVhc2UgZGVidWdnaW5nCi0JCQljaGlsZC5jYXNjYWRlTWFya0VudGlyZUJyYW5jaENsZWFuKCk7Ci0JCX0KLQkJdGhpcy5kaXJ0eSA9IGZhbHNlOwotCQl0aGlzLnNldElzRGlydHlCcmFuY2goZmFsc2UpOwotCX0KLQotCS8qKgotCSAqIElOVFJBLVRSRUUgQVBJCi0JICogQSBjaGlsZCBub2RlJ3MgYnJhbmNoIGhhcyBiZWVuIG1hcmtlZCBjbGVhbi4gSWYgdGhlIG5vZGUKLQkgKiBpdHNlbGYgaXMgY2xlYW4gYW5kIGlmIGFsbCBvZiBpdHMgY2hpbGRyZW4gYXJlIGFsc28gY2xlYW4sIHRoZQotCSAqIG5vZGUncyBicmFuY2ggY2FuIGJlIG1hcmtlZCBjbGVhbi4gVGhlbiwgaWYgdGhlIG5vZGUncwotCSAqIGJyYW5jaCBpcyBjbGVhbiwgdGhlIG5vZGUgd2lsbCBub3RpZnkgaXRzIHBhcmVudCB0aGF0IGl0IG1pZ2h0Ci0JICogYmUgY2xlYW4gYWxzby4gVGhpcyBtZXNzYWdlIGlzIHByb3BhZ2F0ZWQgdXAgdGhlIGNvbnRhaW5tZW50Ci0JICogdHJlZSB3aGVuIGEgcGFydGljdWxhciBub2RlIGJlY29tZXMgY2xlYW4uCi0JICovCi0JcHVibGljIGZpbmFsIHZvaWQgbWFya0JyYW5jaENsZWFuSWZQb3NzaWJsZSgpIHsKLQkJLy8gc2hvcnQtY2lyY3VpdCBhbnkgdW5uZWNlc3NhcnkgcHJvcGFnYXRpb24KLQkJaWYgKHRoaXMuZGlydHkpIHsKLQkJCS8vIGlmIHRoZSBvYmplY3QgaXMgImxvY2FsbHkiIGRpcnR5LCBpdCBpcyBzdGlsbCBhIGRpcnR5IGJyYW5jaAotCQkJcmV0dXJuOwotCQl9Ci0KLQkJZm9yIChJdGVyYXRvcjxOb2RlPiBzdHJlYW0gPSB0aGlzLmNoaWxkcmVuKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJTm9kZSBjaGlsZCA9IHN0cmVhbS5uZXh0KCk7CQkvLyBwdWxsIG91dCB0aGUgY2hpbGQgdG8gZWFzZSBkZWJ1Z2dpbmcKLQkJCWlmIChjaGlsZC5pc0RpcnR5QnJhbmNoKCkpIHsKLQkJCQlyZXR1cm47Ci0JCQl9Ci0JCX0KLQotCQl0aGlzLnNldElzRGlydHlCcmFuY2goZmFsc2UpOwotCQl0aGlzLm1hcmtQYXJlbnRCcmFuY2hDbGVhbklmUG9zc2libGUoKTsKLQl9Ci0KLQlwcml2YXRlIGJvb2xlYW4gYXNwZWN0SXNQZXJzaXN0ZW50KFN0cmluZyBhc3BlY3ROYW1lKSB7Ci0JCXJldHVybiAhIHRoaXMuYXNwZWN0SXNUcmFuc2llbnQoYXNwZWN0TmFtZSk7Ci0JfQotCi0JcHJpdmF0ZSBib29sZWFuIGFzcGVjdElzVHJhbnNpZW50KFN0cmluZyBhc3BlY3ROYW1lKSB7Ci0JCXJldHVybiB0aGlzLnRyYW5zaWVudEFzcGVjdE5hbWVzKCkuY29udGFpbnMoYXNwZWN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgc2V0IG9mIHRoZSBvYmplY3QncyB0cmFuc2llbnQgYXNwZWN0IG5hbWVzLgotCSAqIFRoZXNlIGFyZSB0aGUgYXNwZWN0cyB0aGF0LCB3aGVuIHRoZXkgY2hhbmdlLCB3aWxsIE5PVCBjYXVzZSB0aGUKLQkgKiBvYmplY3QgdG8gYmUgbWFya2VkIGRpcnR5LgotCSAqIElmIHlvdSBuZWVkIGluc3RhbmNlLWJhc2VkIGNhbGN1bGF0aW9uIG9mIHlvdXIgdHJhbnNpZW50IGFzcGVjdHMsCi0JICogb3ZlcnJpZGUgdGhpcyBtZXRob2QuIElmIGNsYXNzLWJhc2VkIGNhbGN1bGF0aW9uIGlzIHN1ZmZpY2llbnQsCi0JICogb3ZlcnJpZGUgI2FkZFRyYW5zaWVudEFzcGVjdE5hbWVzVG8oU2V0KS4KLQkgKi8KLQlwcm90ZWN0ZWQgZmluYWwgU2V0PFN0cmluZz4gdHJhbnNpZW50QXNwZWN0TmFtZXMoKSB7Ci0JCXN5bmNocm9uaXplZCAodHJhbnNpZW50QXNwZWN0TmFtZVNldHMpIHsKLQkJCUhhc2hTZXQ8U3RyaW5nPiB0cmFuc2llbnRBc3BlY3ROYW1lcyA9IHRyYW5zaWVudEFzcGVjdE5hbWVTZXRzLmdldCh0aGlzLmdldENsYXNzKCkpOwotCQkJaWYgKHRyYW5zaWVudEFzcGVjdE5hbWVzID09IG51bGwpIHsKLQkJCQl0cmFuc2llbnRBc3BlY3ROYW1lcyA9IG5ldyBIYXNoU2V0PFN0cmluZz4oKTsKLQkJCQl0aGlzLmFkZFRyYW5zaWVudEFzcGVjdE5hbWVzVG8odHJhbnNpZW50QXNwZWN0TmFtZXMpOwotCQkJCXRyYW5zaWVudEFzcGVjdE5hbWVTZXRzLnB1dCh0aGlzLmdldENsYXNzKCksIHRyYW5zaWVudEFzcGVjdE5hbWVzKTsKLQkJCX0KLQkJCXJldHVybiB0cmFuc2llbnRBc3BlY3ROYW1lczsKLQkJfQotCX0KLQotCS8qKgotCSAqIEFkZCB0aGUgb2JqZWN0J3MgdHJhbnNpZW50IGFzcGVjdCBuYW1lcyB0byB0aGUgc3BlY2lmaWVkIHNldC4KLQkgKiBUaGVzZSBhcmUgdGhlIGFzcGVjdHMgdGhhdCwgd2hlbiB0aGV5IGNoYW5nZSwgd2lsbCBOT1QgY2F1c2UgdGhlCi0JICogb2JqZWN0IHRvIGJlIG1hcmtlZCBkaXJ0eS4KLQkgKiBJZiBjbGFzcy1iYXNlZCBjYWxjdWxhdGlvbiBvZiB5b3VyIHRyYW5zaWVudCBhc3BlY3RzIGlzIHN1ZmZpY2llbnQsCi0JICogb3ZlcnJpZGUgdGhpcyBtZXRob2QuIElmIHlvdSBuZWVkIGluc3RhbmNlLWJhc2VkIGNhbGN1bGF0aW9uLAotCSAqIG92ZXJyaWRlICN0cmFuc2llbnRBc3BlY3ROYW1lcygpLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIGFkZFRyYW5zaWVudEFzcGVjdE5hbWVzVG8oU2V0PFN0cmluZz4gdHJhbnNpZW50QXNwZWN0TmFtZXMpIHsKLQkJdHJhbnNpZW50QXNwZWN0TmFtZXMuYWRkKERJUlRZX0JSQU5DSF9QUk9QRVJUWSk7Ci0JCXRyYW5zaWVudEFzcGVjdE5hbWVzLmFkZChCUkFOQ0hfUFJPQkxFTVNfTElTVCk7Ci0JCXRyYW5zaWVudEFzcGVjdE5hbWVzLmFkZChIQVNfQlJBTkNIX1BST0JMRU1TX1BST1BFUlRZKTsKLQkvLyB3aGVuIHlvdSBvdmVycmlkZSB0aGlzIG1ldGhvZCwgZG9uJ3QgZm9yZ2V0IHRvIGluY2x1ZGU6Ci0JLy8Jc3VwZXIuYWRkVHJhbnNpZW50QXNwZWN0TmFtZXNUbyh0cmFuc2llbnRBc3BlY3ROYW1lcyk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBkaXJ0eSBub2RlcyBpbiB0aGUgb2JqZWN0J3MgYnJhbmNoIG9mIHRoZSB0cmVlLAotCSAqIGluY2x1ZGluZyB0aGUgbm9kZSBpdHNlbGYgKGlmIGFwcHJvcHJpYXRlKS4KLQkgKiBPbmx5IHJlYWxseSB1c2VkIGZvciB0ZXN0aW5nIGFuZCBkZWJ1Z2dpbmcuCi0JICovCi0JcHVibGljIGZpbmFsIEl0ZXJhdG9yPE5vZGU+IGFsbERpcnR5Tm9kZXMoKSB7Ci0JCXJldHVybiBuZXcgRmlsdGVyaW5nSXRlcmF0b3I8Tm9kZSwgTm9kZT4odGhpcy5hbGxOb2RlcygpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBib29sZWFuIGFjY2VwdChOb2RlIG5vZGUpIHsKLQkJCQlyZXR1cm4gKG5vZGUgaW5zdGFuY2VvZiBBYnN0cmFjdE5vZGUpICYmICgoQWJzdHJhY3ROb2RlKSBub2RlKS5pc0RpcnR5KCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHByb2JsZW1zICoqKioqKioqKioKLQotCS8qKgotCSAqIFJldHVybiB0aGUgbm9kZSdzIHByb2JsZW1zLgotCSAqIFRoaXMgZG9lcyBOT1QgaW5jbHVkZSB0aGUgcHJvYmxlbXMgb2YgdGhlIG5vZGUncyBkZXNjZW5kYW50cy4KLQkgKiBAc2VlICNicmFuY2hQcm9ibGVtcygpCi0JICovCi0JcHVibGljIGZpbmFsIEl0ZXJhdG9yPFByb2JsZW0+IHByb2JsZW1zKCkgewotCQlyZXR1cm4gbmV3IENsb25lSXRlcmF0b3I8UHJvYmxlbT4odGhpcy5wcm9ibGVtcyk7CS8vIHJlbW92ZXMgYXJlIG5vdCBhbGxvd2VkCi0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaXplIG9mIHRoZSBub2RlJ3MgcHJvYmxlbXMuCi0JICogVGhpcyBkb2VzIE5PVCBpbmNsdWRlIHRoZSBwcm9ibGVtcyBvZiB0aGUgbm9kZSdzIGRlc2NlbmRhbnRzLgotCSAqIEBzZWUgI2JyYW5jaFByb2JsZW1zU2l6ZSgpCi0JICovCi0JcHVibGljIGZpbmFsIGludCBwcm9ibGVtc1NpemUoKSB7Ci0JCXJldHVybiB0aGlzLnByb2JsZW1zLnNpemUoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgbm9kZSBoYXMgcHJvYmxlbXMKLQkgKiBUaGlzIGRvZXMgTk9UIGluY2x1ZGUgdGhlIHByb2JsZW1zIG9mIHRoZSBub2RlJ3MgZGVzY2VuZGFudHMuCi0JICogQHNlZSAjaGFzQnJhbmNoUHJvYmxlbXMoKQotCSAqLwotCXB1YmxpYyBmaW5hbCBib29sZWFuIGhhc1Byb2JsZW1zKCkgewotCQlyZXR1cm4gISB0aGlzLnByb2JsZW1zLmlzRW1wdHkoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYWxsIHRoZSBub2RlJ3MgcHJvYmxlbXMgYWxvbmcgd2l0aCBhbGwgdGhlCi0JICogbm9kZSdzIGRlc2NlbmRhbnRzJyBwcm9ibGVtcy4KLQkgKi8KLQlwdWJsaWMgZmluYWwgTGlzdEl0ZXJhdG9yPFByb2JsZW0+IGJyYW5jaFByb2JsZW1zKCkgewotCQlyZXR1cm4gbmV3IENsb25lTGlzdEl0ZXJhdG9yPFByb2JsZW0+KHRoaXMuYnJhbmNoUHJvYmxlbXMpOwkvLyByZW1vdmVzIGFyZSBub3QgYWxsb3dlZAotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2l6ZSBvZiBhbGwgdGhlIG5vZGUncyBwcm9ibGVtcyBhbG9uZyB3aXRoIGFsbCB0aGUKLQkgKiBub2RlJ3MgZGVzY2VuZGFudHMnIHByb2JsZW1zLgotCSAqLwotCXB1YmxpYyBmaW5hbCBpbnQgYnJhbmNoUHJvYmxlbXNTaXplKCkgewotCQlyZXR1cm4gdGhpcy5icmFuY2hQcm9ibGVtcy5zaXplKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIG5vZGUgb3IgYW55IG9mIGl0cyBkZXNjZW5kYW50cyBoYXZlIHByb2JsZW1zLgotCSAqLwotCXB1YmxpYyBmaW5hbCBib29sZWFuIGhhc0JyYW5jaFByb2JsZW1zKCkgewotCQlyZXR1cm4gISB0aGlzLmJyYW5jaFByb2JsZW1zLmlzRW1wdHkoKTsKLQl9Ci0KLQlwdWJsaWMgZmluYWwgYm9vbGVhbiBjb250YWluc0JyYW5jaFByb2JsZW0oUHJvYmxlbSBwcm9ibGVtKSB7Ci0JCXJldHVybiB0aGlzLmJyYW5jaFByb2JsZW1zLmNvbnRhaW5zKHByb2JsZW0pOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCBQcm9ibGVtIGJ1aWxkUHJvYmxlbShTdHJpbmcgbWVzc2FnZUtleSwgT2JqZWN0Li4uIG1lc3NhZ2VBcmd1bWVudHMpIHsKLQkJcmV0dXJuIG5ldyBEZWZhdWx0UHJvYmxlbSh0aGlzLCBtZXNzYWdlS2V5LCBtZXNzYWdlQXJndW1lbnRzKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgUHJvYmxlbSBidWlsZFByb2JsZW0oU3RyaW5nIG1lc3NhZ2VLZXkpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRQcm9ibGVtKG1lc3NhZ2VLZXksIEVNUFRZX1BST0JMRU1fTUVTU0FHRV9BUkdVTUVOVFMpOwotCX0KLQotCS8qKgotCSAqIFZhbGlkYXRlIHRoZSBub2RlIGFuZCBhbGwgb2YgaXRzIGRlc2NlbmRhbnRzLAotCSAqIGFuZCB1cGRhdGUgdGhlaXIgc2V0cyBvZiAiYnJhbmNoIiBwcm9ibGVtcy4KLQkgKiBJZiB0aGUgbm9kZSdzICJicmFuY2giIHByb2JsZW1zIGhhdmUgY2hhbmdlZCwKLQkgKiBub3RpZnkgdGhlIG5vZGUncyBwYXJlbnQuCi0JICovCi0JcHVibGljIHZvaWQgdmFsaWRhdGVCcmFuY2goKSB7Ci0JCWlmICh0aGlzLnZhbGlkYXRlQnJhbmNoSW50ZXJuYWwoKSkgewotCQkJLy8gaWYgb3VyICJicmFuY2giIHByb2JsZW1zIGhhdmUgY2hhbmdlZCwgdGhlbgotCQkJLy8gb3VyIHBhcmVudCBtdXN0IHJlYnVpbGQgaXRzICJicmFuY2giIHByb2JsZW1zIGFsc28KLQkJCXRoaXMucmVidWlsZFBhcmVudEJyYW5jaFByb2JsZW1zKCk7Ci0JCX0KLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCByZWJ1aWxkUGFyZW50QnJhbmNoUHJvYmxlbXMoKSB7Ci0JCWlmICh0aGlzLnBhcmVudCAhPSBudWxsKSB7Ci0JCQl0aGlzLnBhcmVudC5yZWJ1aWxkQnJhbmNoUHJvYmxlbXMoKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIElOVFJBLVRSRUUgQVBJCi0JICogVmFsaWRhdGUgdGhlIG5vZGUgYW5kIGFsbCBvZiBpdHMgZGVzY2VuZGFudHMsCi0JICogYW5kIHVwZGF0ZSB0aGVpciBzZXRzIG9mICJicmFuY2giIHByb2JsZW1zLgotCSAqIFJldHVybiB0cnVlIGlmIHRoZSBjb2xsZWN0aW9uIG9mICJicmFuY2giIHByb2JsZW1zIGhhcyBjaGFuZ2VkLgotCSAqIFRoaXMgbWV0aG9kIGlzIGZvciBpbnRlcm5hbCB1c2Ugb25seTsgaXQgaXMgbm90IGZvcgotCSAqIGNsaWVudCB1c2UuCi0JICovCi0JcHVibGljIGJvb2xlYW4gdmFsaWRhdGVCcmFuY2hJbnRlcm5hbCgpIHsKLQkJLy8gcmVidWlsZCAiYnJhbmNoIiBwcm9ibGVtcyBpbiBjaGlsZHJlbiBmaXJzdAotCQlmb3IgKEl0ZXJhdG9yPE5vZGU+IHN0cmVhbSA9IHRoaXMuY2hpbGRyZW4oKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQlOb2RlIGNoaWxkID0gc3RyZWFtLm5leHQoKTsJCS8vIHB1bGwgb3V0IHRoZSBjaGlsZCB0byBlYXNlIGRlYnVnZ2luZwotCQkJLy8gaWdub3JlIHRoZSByZXR1cm4gdmFsdWUgYmVjYXVzZSB3ZSBhcmUgZ29pbmcgdG8gcmVidWlsZCBvdXIgImJyYW5jaCIKLQkJCS8vIHByb2JsZW1zIG5vIG1hdHRlciB3aGF0LCB0byBzZWUgaWYgdGhleSBoYXZlIGNoYW5nZWQKLQkJCWNoaWxkLnZhbGlkYXRlQnJhbmNoSW50ZXJuYWwoKTsKLQkJfQotCi0JCXRoaXMucHJvYmxlbXMuY2xlYXIoKTsKLQkJdGhpcy5hZGRQcm9ibGVtc1RvKHRoaXMucHJvYmxlbXMpOwotCi0JCXJldHVybiB0aGlzLmNoZWNrQnJhbmNoUHJvYmxlbXMoKTsKLQl9Ci0KLQkvKioKLQkgKiBDaGVjayBmb3IgYW55IHByb2JsZW1zIGFuZCBhZGQgdGhlbSB0byB0aGUgc3BlY2lmaWVkIGxpc3QuCi0JICogVGhpcyBtZXRob2Qgc2hvdWxkIE9OTFkgYWRkIHByb2JsZW1zIGZvciB0aGlzIHBhcnRpY3VsYXIgbm9kZTsKLQkgKiBpdCBzaG91bGQgTk9UIGFkZCBwcm9ibGVtcyBmb3IgYW55IG9mIHRoaXMgbm9kZSdzIGRlc2NlbmRhbnRzCi0JICogb3IgYW5jZXN0b3JzLiAoQWx0aG91Z2ggdGhlcmUgd2lsbCBiZSB0aW1lcyB3aGVuIGl0IGlzIGRlYmF0YWJsZQotCSAqIGFzIHRvIHdoaWNoIG5vZGUgYSBwcm9ibGVtICJiZWxvbmdzIiB0by4uLi4pCi0JICogCi0JICogTkI6IFRoaXMgbWV0aG9kIHNob3VsZCBOT1QgbW9kaWZ5IEFOWSBwYXJ0IG9mIHRoZSBub2RlJ3Mgc3RhdGUhCi0JICogSXQgaXMgYSBSRUFELU9OTFkgYmVoYXZpb3IuIE9OTFkgdGhlIGxpc3Qgb2YgY3VycmVudCBwcm9ibGVtcwotCSAqIHBhc3NlZCBpbiB0byB0aGUgbWV0aG9kIHNob3VsZCBiZSBtb2RpZmllZC4KLQkgKi8KLQlwcm90ZWN0ZWQgdm9pZCBhZGRQcm9ibGVtc1RvKEBTdXBwcmVzc1dhcm5pbmdzKCJ1bnVzZWQiKSBMaXN0PFByb2JsZW0+IGN1cnJlbnRQcm9ibGVtcykgewotCQkvLyBUaGUgZGVmYXVsdCBpcyB0byBkbyBub3RoaW5nLgotCQkvLyBXaGVuIHlvdSBvdmVycmlkZSB0aGlzIG1ldGhvZCwgZG9uJ3QgZm9yZ2V0IHRvIGluY2x1ZGU6Ci0JLy8Jc3VwZXIuYWRkUHJvYmxlbXNUbyhjdXJyZW50UHJvYmxlbXMpOwotCX0KLQotCS8qKgotCSAqIFJlYnVpbGQgdGhlICJicmFuY2giIHByb2JsZW1zIGFuZCByZXR1cm4gd2hldGhlciB0aGV5IGhhdmUKLQkgKiBjaGFuZ2VkLgotCSAqIE5COiBUaGUgZW50aXJlIGNvbGxlY3Rpb24gb2YgImJyYW5jaCIgcHJvYmxlbXMgbXVzdCBiZSByZS1jYWxjdWxhdGVkCi0JICogd2l0aCBFVkVSWSAic2lnbmlmaWNhbnQiIGNoYW5nZSAtIHdlIGNhbm5vdCBrZWVwIGl0IGluIHN5bmNoIHZpYQotCSAqIGNoYW5nZSBub3RpZmljYXRpb25zIGJlY2F1c2UgaWYgYSBkZXNjZW5kYW50IHdpdGggcHJvYmxlbXMgaXMKLQkgKiByZW1vdmVkIG9yIHJlcGxhY2VkIHdlIHdpbGwgbm90IHJlY2VpdmUgbm90aWZpY2F0aW9uIHRoYXQgaXRzCi0JICogcHJvYmxlbXMgd2VyZSByZW1vdmVkIGZyb20gb3VyICJicmFuY2giIHByb2JsZW1zLgotCSAqLwotCXByaXZhdGUgYm9vbGVhbiBjaGVja0JyYW5jaFByb2JsZW1zKCkgewotCQlWZWN0b3I8UHJvYmxlbT4gb2xkQnJhbmNoUHJvYmxlbXMgPSBuZXcgVmVjdG9yPFByb2JsZW0+KHRoaXMuYnJhbmNoUHJvYmxlbXMpOwotCQlpbnQgb2xkU2l6ZSA9IHRoaXMuYnJhbmNoUHJvYmxlbXMuc2l6ZSgpOwotCi0JCXRoaXMuYnJhbmNoUHJvYmxlbXMuY2xlYXIoKTsKLQkJdGhpcy5icmFuY2hQcm9ibGVtcy5hZGRBbGwodGhpcy5wcm9ibGVtcyk7Ci0JCWZvciAoSXRlcmF0b3I8Tm9kZT4gc3RyZWFtID0gdGhpcy5jaGlsZHJlbigpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCU5vZGUgY2hpbGQgPSBzdHJlYW0ubmV4dCgpOwkJLy8gcHVsbCBvdXQgdGhlIGNoaWxkIHRvIGVhc2UgZGVidWdnaW5nCi0JCQljaGlsZC5hZGRCcmFuY2hQcm9ibGVtc1RvKHRoaXMuYnJhbmNoUHJvYmxlbXMpOwotCQl9Ci0KLQkJLy8gaWYgdGhlIHNpemUgaGFzIGNoYW5nZWQgdG8gb3IgZnJvbSB6ZXJvLCBvdXIgdmlydHVhbCBmbGFnIGhhcyBjaGFuZ2VkCi0JCWludCBuZXdTaXplID0gdGhpcy5icmFuY2hQcm9ibGVtcy5zaXplKCk7Ci0JCWlmICgob2xkU2l6ZSA9PSAwKSAmJiAobmV3U2l6ZSAhPSAwKSkgewotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKEhBU19CUkFOQ0hfUFJPQkxFTVNfUFJPUEVSVFksIGZhbHNlLCB0cnVlKTsKLQkJfSBlbHNlIGlmICgob2xkU2l6ZSAhPSAwKSAmJiAobmV3U2l6ZSA9PSAwKSkgewotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKEhBU19CUkFOQ0hfUFJPQkxFTVNfUFJPUEVSVFksIHRydWUsIGZhbHNlKTsKLQkJfQotCi0JCWlmIChvbGRCcmFuY2hQcm9ibGVtcy5lcXVhbHModGhpcy5icmFuY2hQcm9ibGVtcykpIHsKLQkJCXJldHVybiBmYWxzZTsJCS8vIG91ciAiYnJhbmNoIiBwcm9ibGVtcyBkaWQgbm90IGNoYW5nZQotCQl9Ci0JCS8vIG91ciAiYnJhbmNoIiBwcm9ibGVtcyBjaGFuZ2VkCi0JCXRoaXMuZmlyZUxpc3RDaGFuZ2VkKEJSQU5DSF9QUk9CTEVNU19MSVNUKTsKLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JLyoqCi0JICogSU5UUkEtVFJFRSBBUEkKLQkgKiBBZGQgYWxsIHRoZSBwcm9ibGVtcyBvZiB0aGUgbm9kZSBhbmQgYWxsCi0JICogdGhlIHByb2JsZW1zIG9mIGl0cyBkZXNjZW5kYW50cyB0byB0aGUKLQkgKiBzcGVjaWZpZWQgY29sbGVjdGlvbi4KLQkgKi8KLQlwdWJsaWMgZmluYWwgdm9pZCBhZGRCcmFuY2hQcm9ibGVtc1RvKExpc3Q8UHJvYmxlbT4gbGlzdCkgewotCQlsaXN0LmFkZEFsbCh0aGlzLmJyYW5jaFByb2JsZW1zKTsKLQl9Ci0KLQkvKioKLQkgKiBJTlRSQS1UUkVFIEFQSQotCSAqIEEgY2hpbGQgbm9kZSdzICJicmFuY2giIHByb2JsZW1zIGNoYW5nZWQ7Ci0JICogdGhlcmVmb3JlIHRoZSBub2RlJ3MgImJyYW5jaCIgcHJvYmxlbXMgaGF2ZSBjaGFuZ2VkIGFsc28gYW5kCi0JICogbXVzdCBiZSByZWJ1aWx0LgotCSAqLwotCXB1YmxpYyBmaW5hbCB2b2lkIHJlYnVpbGRCcmFuY2hQcm9ibGVtcygpIHsKLQkJaWYgKCAhIHRoaXMuY2hlY2tCcmFuY2hQcm9ibGVtcygpKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJ3ZSBzaG91bGQgbm90IGdldCBoZXJlIHVubGVzcyBvdXIgXCJicmFuY2hcIiBwcm9ibGVtcyBoYXZlIGNoYW5nZWQiKTsgLy8kTk9OLU5MUy0xJAotCQl9Ci0JCXRoaXMucmVidWlsZFBhcmVudEJyYW5jaFByb2JsZW1zKCk7Ci0JfQotCi0JLyoqCi0JICogQ2xlYXIgdGhlIG5vZGUncyAiYnJhbmNoIiBwcm9ibGVtcyBhbmQgdGhlICJicmFuY2giCi0JICogcHJvYmxlbXMgb2YgYWxsIG9mIGl0cyBkZXNjZW5kYW50cy4KLQkgKiBJZiB0aGUgbm9kZSdzICJicmFuY2giIHByb2JsZW1zIGhhdmUgY2hhbmdlZCwKLQkgKiBub3RpZnkgdGhlIG5vZGUncyBwYXJlbnQuCi0JICovCi0JcHVibGljIGZpbmFsIHZvaWQgY2xlYXJBbGxCcmFuY2hQcm9ibGVtcygpIHsKLQkJaWYgKHRoaXMuY2xlYXJBbGxCcmFuY2hQcm9ibGVtc0ludGVybmFsKCkpIHsKLQkJCS8vIGlmIG91ciAiYnJhbmNoIiBwcm9ibGVtcyBoYXZlIGNoYW5nZWQsIHRoZW4KLQkJCS8vIG91ciBwYXJlbnQgbXVzdCByZWJ1aWxkIGl0cyAiYnJhbmNoIiBwcm9ibGVtcyBhbHNvCi0JCQl0aGlzLnJlYnVpbGRQYXJlbnRCcmFuY2hQcm9ibGVtcygpOwotCQl9Ci0JfQotCi0JLyoqCi0JICogSU5UUkEtVFJFRSBBUEkKLQkgKiBDbGVhciB0aGUgbm9kZSdzICJicmFuY2giIHByb2JsZW1zIGFuZCB0aGUgImJyYW5jaCIKLQkgKiBwcm9ibGVtcyBvZiBhbGwgb2YgaXRzIGRlc2NlbmRhbnRzLgotCSAqIFJldHVybiB0cnVlIGlmIHRoZSBjb2xsZWN0aW9uIG9mICJicmFuY2giIHByb2JsZW1zIGhhcyBjaGFuZ2VkLgotCSAqIFRoaXMgbWV0aG9kIGlzIGZvciBpbnRlcm5hbCB1c2Ugb25seTsgaXQgaXMgbm90IGZvcgotCSAqIGNsaWVudCB1c2UuCi0JICovCi0JcHVibGljIGZpbmFsIGJvb2xlYW4gY2xlYXJBbGxCcmFuY2hQcm9ibGVtc0ludGVybmFsKCkgewotCQlpZiAodGhpcy5icmFuY2hQcm9ibGVtcy5pc0VtcHR5KCkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlmb3IgKEl0ZXJhdG9yPE5vZGU+IHN0cmVhbSA9IHRoaXMuY2hpbGRyZW4oKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQlOb2RlIGNoaWxkID0gc3RyZWFtLm5leHQoKTsJCS8vIHB1bGwgb3V0IHRoZSBjaGlsZCB0byBlYXNlIGRlYnVnZ2luZwotCQkJLy8gaWdub3JlIHRoZSByZXR1cm4gdmFsdWUgYmVjYXVzZSB3ZSBhcmUgZ29pbmcgdG8gY2xlYXIgb3VyICJicmFuY2giCi0JCQkvLyBwcm9ibGVtcyBubyBtYXR0ZXIgd2hhdAotCQkJY2hpbGQuY2xlYXJBbGxCcmFuY2hQcm9ibGVtc0ludGVybmFsKCk7Ci0JCX0KLQkJdGhpcy5wcm9ibGVtcy5jbGVhcigpOwotCQl0aGlzLmJyYW5jaFByb2JsZW1zLmNsZWFyKCk7Ci0JCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChIQVNfQlJBTkNIX1BST0JMRU1TX1BST1BFUlRZLCB0cnVlLCBmYWxzZSk7Ci0JCXRoaXMuZmlyZUxpc3RDaGFuZ2VkKEJSQU5DSF9QUk9CTEVNU19MSVNUKTsKLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgYSBjaGFuZ2UgdG8gc3BlY2lmaWVkIGFzcGVjdCByZXF1aXJlcyBhIHJlLXZhbGlkYXRpb24KLQkgKiBvZiB0aGUgbm9kZSdzIHRyZWUuCi0JICovCi0JcHJpdmF0ZSBib29sZWFuIGFzcGVjdENoYW5nZVJlcXVpcmVzVmFsaWRhdGlvbihTdHJpbmcgYXNwZWN0TmFtZSkgewotCQlyZXR1cm4gISB0aGlzLmFzcGVjdENoYW5nZURvZXNOb3RSZXF1aXJlVmFsaWRhdGlvbihhc3BlY3ROYW1lKTsKLQl9Ci0KLQlwcml2YXRlIGJvb2xlYW4gYXNwZWN0Q2hhbmdlRG9lc05vdFJlcXVpcmVWYWxpZGF0aW9uKFN0cmluZyBhc3BlY3ROYW1lKSB7Ci0JCXJldHVybiB0aGlzLm5vblZhbGlkYXRlZEFzcGVjdE5hbWVzKCkuY29udGFpbnMoYXNwZWN0TmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgc2V0IG9mIHRoZSBvYmplY3QncyAibm9uLXZhbGlkYXRlZCIgYXNwZWN0IG5hbWVzLgotCSAqIFRoZXNlIGFyZSB0aGUgYXNwZWN0cyB0aGF0LCB3aGVuIHRoZXkgY2hhbmdlLCB3aWxsIE5PVCBjYXVzZSB0aGUKLQkgKiBvYmplY3QgKG9yIGl0cyBjb250YWluaW5nIHRyZWUpIHRvIGJlIHZhbGlkYXRlZCwgaS5lLiBjaGVja2VkIGZvciBwcm9ibGVtcy4KLQkgKiBJZiB5b3UgbmVlZCBpbnN0YW5jZS1iYXNlZCBjYWxjdWxhdGlvbiBvZiB5b3VyICJub24tdmFsaWRhdGVkIiBhc3BlY3RzLAotCSAqIG92ZXJyaWRlIHRoaXMgbWV0aG9kLiBJZiBjbGFzcy1iYXNlZCBjYWxjdWxhdGlvbiBpcyBzdWZmaWNpZW50LAotCSAqIG92ZXJyaWRlICNhZGROb25WYWxpZGF0ZWRBc3BlY3ROYW1lc1RvKFNldCkuCi0JICovCi0JcHJvdGVjdGVkIGZpbmFsIFNldDxTdHJpbmc+IG5vblZhbGlkYXRlZEFzcGVjdE5hbWVzKCkgewotCQlzeW5jaHJvbml6ZWQgKG5vblZhbGlkYXRlZEFzcGVjdE5hbWVTZXRzKSB7Ci0JCQlIYXNoU2V0PFN0cmluZz4gbm9uVmFsaWRhdGVkQXNwZWN0TmFtZXMgPSBub25WYWxpZGF0ZWRBc3BlY3ROYW1lU2V0cy5nZXQodGhpcy5nZXRDbGFzcygpKTsKLQkJCWlmIChub25WYWxpZGF0ZWRBc3BlY3ROYW1lcyA9PSBudWxsKSB7Ci0JCQkJbm9uVmFsaWRhdGVkQXNwZWN0TmFtZXMgPSBuZXcgSGFzaFNldDxTdHJpbmc+KCk7Ci0JCQkJdGhpcy5hZGROb25WYWxpZGF0ZWRBc3BlY3ROYW1lc1RvKG5vblZhbGlkYXRlZEFzcGVjdE5hbWVzKTsKLQkJCQlub25WYWxpZGF0ZWRBc3BlY3ROYW1lU2V0cy5wdXQodGhpcy5nZXRDbGFzcygpLCBub25WYWxpZGF0ZWRBc3BlY3ROYW1lcyk7Ci0JCQl9Ci0JCQlyZXR1cm4gbm9uVmFsaWRhdGVkQXNwZWN0TmFtZXM7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBBZGQgdGhlIG9iamVjdCdzICJub24tdmFsaWRhdGVkIiBhc3BlY3QgbmFtZXMgdG8gdGhlIHNwZWNpZmllZCBzZXQuCi0JICogVGhlc2UgYXJlIHRoZSBhc3BlY3RzIHRoYXQsIHdoZW4gdGhleSBjaGFuZ2UsIHdpbGwgTk9UIGNhdXNlIHRoZQotCSAqIG9iamVjdCAob3IgaXRzIGNvbnRhaW5pbmcgdHJlZSkgdG8gYmUgdmFsaWRhdGVkLCBpLmUuIGNoZWNrZWQgZm9yIHByb2JsZW1zLgotCSAqIElmIGNsYXNzLWJhc2VkIGNhbGN1bGF0aW9uIG9mIHlvdXIgIm5vbi12YWxpZGF0ZWQiIGFzcGVjdHMgaXMgc3VmZmljaWVudCwKLQkgKiBvdmVycmlkZSB0aGlzIG1ldGhvZC4gSWYgeW91IG5lZWQgaW5zdGFuY2UtYmFzZWQgY2FsY3VsYXRpb24sCi0JICogb3ZlcnJpZGUgI25vblZhbGlkYXRlZEFzcGVjdE5hbWVzKCkuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgYWRkTm9uVmFsaWRhdGVkQXNwZWN0TmFtZXNUbyhTZXQ8U3RyaW5nPiBub25WYWxpZGF0ZWRBc3BlY3ROYW1lcykgewotCQlub25WYWxpZGF0ZWRBc3BlY3ROYW1lcy5hZGQoQ09NTUVOVF9QUk9QRVJUWSk7Ci0JCW5vblZhbGlkYXRlZEFzcGVjdE5hbWVzLmFkZChESVJUWV9CUkFOQ0hfUFJPUEVSVFkpOwotCQlub25WYWxpZGF0ZWRBc3BlY3ROYW1lcy5hZGQoQlJBTkNIX1BST0JMRU1TX0xJU1QpOwotCQlub25WYWxpZGF0ZWRBc3BlY3ROYW1lcy5hZGQoSEFTX0JSQU5DSF9QUk9CTEVNU19QUk9QRVJUWSk7Ci0JLy8gd2hlbiB5b3Ugb3ZlcnJpZGUgdGhpcyBtZXRob2QsIGRvbid0IGZvcmdldCB0byBpbmNsdWRlOgotCS8vCXN1cGVyLmFkZE5vblZhbGlkYXRlZEFzcGVjdE5hbWVzVG8obm9uVmFsaWRhdGVkQXNwZWN0TmFtZXMpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBkaXNwbGF5IG1ldGhvZHMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29tcGFyZSBkaXNwbGF5IHN0cmluZ3MuCi0JICovCi0JcHVibGljIGludCBjb21wYXJlVG8oTm9kZSBub2RlKSB7Ci0JCXJldHVybiBERUZBVUxUX0NPTVBBUkFUT1IuY29tcGFyZSh0aGlzLCBub2RlKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBkZXZlbG9wZXItZnJpZW5kbHkgU3RyaW5nLiBJZiB5b3Ugd2FudCBzb21ldGhpbmcgdXNlZnVsIGZvcgotCSAqIGRpc3BsYXlpbmcgaW4gYSB1c2VyIGludGVyZmFjZSwgdXNlICNkaXNwbGF5U3RyaW5nKCkuCi0JICogSWYgeW91IHdhbnQgdG8gZ2l2ZSBtb3JlIGluZm9ybWF0aW9uIGluIHlvdXIgI3RvU3RyaW5nKCksCi0JICogb3ZlcnJpZGUgI3RvU3RyaW5nKFN0cmluZ0J1aWxkZXIgc2IpLiAKLQkgKiBXaGF0ZXZlciB5b3UgYWRkIHRvIHRoYXQgc3RyaW5nIGJ1ZmZlciB3aWxsIHNob3cgdXAgYmV0d2VlbiB0aGUgcGFyZW50aGVzZXMuCi0JICogQHNlZSBBYnN0cmFjdE1vZGVsI3RvU3RyaW5nKFN0cmluZ0J1aWxkZXIgc2IpCi0JICogQHNlZSAjZGlzcGxheVN0cmluZygpCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIGZpbmFsIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIHN1cGVyLnRvU3RyaW5nKCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbm9kZS9Bc3luY2hyb25vdXNWYWxpZGF0b3IuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9ub2RlL0FzeW5jaHJvbm91c1ZhbGlkYXRvci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmZDIwNTljLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9ub2RlL0FzeW5jaHJvbm91c1ZhbGlkYXRvci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5ub2RlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3luY2hyb25pemVkQm9vbGVhbjsKLQotLyoqCi0gKiBUaGlzIGltcGxlbWVudGF0aW9uIG9mIHRoZSBQbHVnZ2FibGVWYWxpZGF0b3IuRGVsZWdhdGUgaW50ZXJmYWNlCi0gKiBzaW1wbHkgc2V0cyBhIHNoYXJlZCAidmFsaWRhdGUiIGZsYWcgdG8gdHJ1ZS4gVGhpcyBzaG91bGQgdHJpZ2dlciBhCi0gKiBzZXBhcmF0ZSAidmFsaWRhdGlvbiIgdGhyZWFkIHRvIGJlZ2luIHZhbGlkYXRpbmcgdGhlIGFwcHJvcHJpYXRlCi0gKiBicmFuY2ggb2Ygbm9kZXMuCi0gKi8KLXB1YmxpYyBjbGFzcyBBc3luY2hyb25vdXNWYWxpZGF0b3IKLQlpbXBsZW1lbnRzIFBsdWdnYWJsZVZhbGlkYXRvci5EZWxlZ2F0ZQotewotCXByaXZhdGUgU3luY2hyb25pemVkQm9vbGVhbiB2YWxpZGF0ZUZsYWc7Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSB2YWxpZGF0b3IgZGVsZWdhdGUgd2l0aCB0aGUgc3BlY2lmaWVkIHNoYXJlZAotCSAqICJ2YWxpZGF0ZSIgZmxhZy4gVGhpcyBmbGFnIHNob3VsZCBiZSBzaGFyZWQgd2l0aAotCSAqIGFub3RoZXIgdGhyZWFkIHRoYXQgd2lsbCBwZXJmb3JtIHRoZSBhY3R1YWwgdmFsaWRhdGlvbi4KLQkgKi8KLQlwdWJsaWMgQXN5bmNocm9ub3VzVmFsaWRhdG9yKFN5bmNocm9uaXplZEJvb2xlYW4gdmFsaWRhdGVGbGFnKSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMudmFsaWRhdGVGbGFnID0gdmFsaWRhdGVGbGFnOwotCX0KLQotCS8qKgotCSAqIFNldCB0aGUgc2hhcmVkICJ2YWxpZGF0ZSIgZmxhZyB0byB0cnVlLCB0cmlnZ2VyaW5nCi0JICogYW4gYXN5bmNocm9ub3VzIHZhbGlkYXRpb24gb2YgdGhlIGFwcHJvcHJpYXRlCi0JICogYnJhbmNoIG9mIG5vZGVzLgotCSAqLwotCXB1YmxpYyB2b2lkIHZhbGlkYXRlKCkgewotCQl0aGlzLnZhbGlkYXRlRmxhZy5zZXRUcnVlKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy52YWxpZGF0ZUZsYWcpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL25vZGUvRGVmYXVsdFByb2JsZW0uamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9ub2RlL0RlZmF1bHRQcm9ibGVtLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDlkMzg5OGMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL25vZGUvRGVmYXVsdFByb2JsZW0uamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDc5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubm9kZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci0KLS8qKgotICogVGhpcyBjbGFzcyBpcyBhIHN0cmFpZ2h0Zm9yd2FyZCBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgUHJvYmxlbSBpbnRlcmZhY2UuCi0gKi8KLXB1YmxpYyBjbGFzcyBEZWZhdWx0UHJvYmxlbQotCWltcGxlbWVudHMgUHJvYmxlbQotewotCXByaXZhdGUgZmluYWwgTm9kZSBzb3VyY2U7Ci0JcHJpdmF0ZSBmaW5hbCBTdHJpbmcgbWVzc2FnZUtleTsKLQlwcml2YXRlIGZpbmFsIE9iamVjdFtdIG1lc3NhZ2VBcmd1bWVudHM7Ci0KLQotCURlZmF1bHRQcm9ibGVtKE5vZGUgc291cmNlLCBTdHJpbmcgbWVzc2FnZUtleSwgT2JqZWN0W10gbWVzc2FnZUFyZ3VtZW50cykgewotCQlzdXBlcigpOwotCQl0aGlzLnNvdXJjZSA9IHNvdXJjZTsKLQkJdGhpcy5tZXNzYWdlS2V5ID0gbWVzc2FnZUtleTsKLQkJdGhpcy5tZXNzYWdlQXJndW1lbnRzID0gbWVzc2FnZUFyZ3VtZW50czsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogUHJvYmxlbSBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgTm9kZSBzb3VyY2UoKSB7Ci0JCXJldHVybiB0aGlzLnNvdXJjZTsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIG1lc3NhZ2VLZXkoKSB7Ci0JCXJldHVybiB0aGlzLm1lc3NhZ2VLZXk7Ci0JfQotCi0JcHVibGljIE9iamVjdFtdIG1lc3NhZ2VBcmd1bWVudHMoKSB7Ci0JCXJldHVybiB0aGlzLm1lc3NhZ2VBcmd1bWVudHM7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIE9iamVjdCBvdmVycmlkZXMgKioqKioqKioqKgotCi0JLyoqCi0JICogV2UgaW1wbGVtZW50ICNlcXVhbHMoT2JqZWN0KSBiZWNhdXNlIHByb2JsZW1zIGFyZSByZXBlYXRlZGx5Ci0JICogcmUtY2FsY3VsYXRlZCBhbmQgdGhlIHJlc3VsdGluZyBwcm9ibGVtcyBtZXJnZWQgd2l0aCB0aGUgZXhpc3RpbmcKLQkgKiBzZXQgb2YgcHJvYmxlbXM7IGFuZCB3ZSB3YW50IHRvIGtlZXAgdGhlIG9yaWdpbmFsIHByb2JsZW1zIGFuZAotCSAqIGlnbm9yZSBhbnkgZnJlc2hseS1nZW5lcmF0ZWQgZHVwbGljYXRlcy4KLQkgKiBBbHNvLCBwcm9ibGVtcyBhcmUgbm90IHNhdmVkIHRvIGRpc2suLi4uCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIGJvb2xlYW4gZXF1YWxzKE9iamVjdCBvKSB7Ci0JCWlmICggISAobyBpbnN0YW5jZW9mIFByb2JsZW0pKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJUHJvYmxlbSBvdGhlciA9IChQcm9ibGVtKSBvOwotCQlyZXR1cm4gdGhpcy5zb3VyY2UgPT0gb3RoZXIuc291cmNlKCkKLQkJCQkmJiB0aGlzLm1lc3NhZ2VLZXkuZXF1YWxzKG90aGVyLm1lc3NhZ2VLZXkoKSkKLQkJCQkmJiBBcnJheXMuZXF1YWxzKHRoaXMubWVzc2FnZUFyZ3VtZW50cywgb3RoZXIubWVzc2FnZUFyZ3VtZW50cygpKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgaW50IGhhc2hDb2RlKCkgewotCQlyZXR1cm4gdGhpcy5zb3VyY2UuaGFzaENvZGUoKSBeIHRoaXMubWVzc2FnZUtleS5oYXNoQ29kZSgpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMubWVzc2FnZUtleSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbm9kZS9Ob2RlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbm9kZS9Ob2RlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDI5MzY4ODMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL25vZGUvTm9kZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDE5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubm9kZTsKLQotaW1wb3J0IGphdmEudGV4dC5Db2xsYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuQ29tcGFyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5Nb2RlbDsKLQotLyoqCi0gKiBUaGlzIGludGVyZmFjZSBkZWZpbmVzIHRoZSBtZXRob2RzIHRoYXQgbXVzdCBiZSBpbXBsZW1lbnRlZAotICogYnkgYW55IGNsYXNzIHdob3NlIGluc3RhbmNlcyBhcmUgdG8gYmUgcGFydCBvZiBhIGNvbnRhaW5tZW50IGhpZXJhcmNoeQotICogdGhhdCBzdXBwb3J0cyBhICJkaXJ0eSIgc3RhdGUgYW5kIHZhbGlkYXRpb24gInByb2JsZW1zIi4KLSAqIAotICogTm90ZTogTWV0aG9kcyBtYXJrZWQgIklOVFJBLVRSRUUgQVBJIiBhcmUgdHlwaWNhbGx5IG9ubHkgdXNlZCBieQotICogdGhlIG5vZGVzIHRoZW1zZWx2ZXMsIGFzIG9wcG9zZWQgdG8gY2xpZW50cyBvZiB0aGUgbm9kZXMuIFRoZXNlCi0gKiBtZXRob2RzIGFyZSBjYWxsZWQgYnkgYSBub2RlIG9uIGVpdGhlciBpdHMgcGFyZW50IG9yIGl0cyBjaGlsZHJlbi4KLSAqLwotcHVibGljIGludGVyZmFjZSBOb2RlIGV4dGVuZHMgTW9kZWwsIENvbXBhcmFibGU8Tm9kZT4gewotCi0KLQkvLyAqKioqKioqKioqIGNvbnRhaW5tZW50IGhpZXJhcmNoeSAocGFyZW50L2NoaWxkcmVuKSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBJTlRSQS1UUkVFIEFQST8KLQkgKiBSZXR1cm4gdGhlIG5vZGUncyBwYXJlbnQgaW4gdGhlIGNvbnRhaW5tZW50IGhpZXJhcmNoeS4KLQkgKiBNb3N0IG5vZGVzIG11c3QgaGF2ZSBhIHBhcmVudC4gVGhlIHBhcmVudCBpcyBpbW11dGFibGUuCi0JICogQHNlZSAjY2hpbGRyZW4oKQotCSAqLwotCU5vZGUgZ2V0UGFyZW50KCk7Ci0KLQkvKioKLQkgKiBJTlRSQS1UUkVFIEFQST8KLQkgKiBSZXR1cm4gdGhlIG5vZGUncyBjaGlsZHJlbiwgd2hpY2ggYXJlIGFsc28gbm9kZXMuCi0JICogQHNlZSAjZ2V0UGFyZW50KCkKLQkgKi8KLQlJdGVyYXRvcjxOb2RlPiBjaGlsZHJlbigpOwotCi0JLyoqCi0JICogSU5UUkEtVFJFRSBBUEk/Ci0JICogUmV0dXJuIHRoZSBjb250YWlubWVudCBoaWVyYXJjaHkncyByb290IG5vZGUuCi0JICogTW9zdCBub2RlcyBtdXN0IGhhdmUgYSByb290LgotCSAqIEBzZWUgI2dldFBhcmVudCgpCi0JICovCi0JTm9kZSByb290KCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgbm9kZSBpcyBhIGRlc2NlbmRhbnQgb2YgdGhlIHNwZWNpZmllZCBub2RlLgotCSAqIEJ5IGRlZmluaXRpb24sIGEgbm9kZSBpcyBhIGRlc2NlbmRhbnQgb2YgaXRzZWxmLgotCSAqLwotCWJvb2xlYW4gaXNEZXNjZW5kYW50T2YoTm9kZSBub2RlKTsKLQotCS8qKgotCSAqIElOVFJBLVRSRUUgQVBJCi0JICogQWRkIHRoZSBub2RlJ3MgInJlZmVyZW5jZXMiLCBhbmQgYWxsIHRoZSBub2RlJ3MgZGVzY2VuZGFudHMnCi0JICogInJlZmVyZW5jZXMiLCB0byB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24uICJSZWZlcmVuY2VzIiBhcmUKLQkgKiBvYmplY3RzIHRoYXQgYXJlICJyZWZlcmVuY2VkIiBieSBhbm90aGVyIG9iamVjdCwgYXMgb3Bwb3NlZAotCSAqIHRvICJvd25lZCIgYnkgYW5vdGhlciBvYmplY3QuCi0JICogVGhpcyBtZXRob2QgaXMgb2YgcGFydGljdWxhciBjb25jZXJuIHRvIEhhbmRsZXMsIHNpbmNlIG1vc3QKLQkgKiAoaG9wZWZ1bGx5IGFsbCkgInJlZmVyZW5jZXMiIGFyZSBoZWxkIGJ5IEhhbmRsZXMuCi0JICogQHNlZSBSZWZlcmVuY2UKLQkgKiBAc2VlICNjaGlsZHJlbigpCi0JICovCi0Jdm9pZCBhZGRCcmFuY2hSZWZlcmVuY2VzVG8oQ29sbGVjdGlvbjxOb2RlLlJlZmVyZW5jZT4gYnJhbmNoUmVmZXJlbmNlcyk7Ci0KLQkvKioKLQkgKiBJTlRSQS1UUkVFIEFQST8KLQkgKiBBZGQgYWxsIHRoZSBub2RlcyBpbiB0aGUgb2JqZWN0J3MgYnJhbmNoIG9mIHRoZSB0cmVlLAotCSAqIGluY2x1ZGluZyB0aGUgbm9kZSBpdHNlbGYsIHRvIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbi4KLQkgKiBPbmx5IHJlYWxseSB1c2VkIGZvciB0ZXN0aW5nIGFuZCBkZWJ1Z2dpbmcuCi0JICovCi0Jdm9pZCBhZGRBbGxOb2Rlc1RvKENvbGxlY3Rpb248Tm9kZT4gbm9kZXMpOwotCi0KLQkvLyAqKioqKioqKioqIG1vZGVsIHN5bmNocm9uaXphdGlvbiBzdXBwb3J0ICoqKioqKioqKioKLQotCS8qKgotCSAqIElOVFJBLVRSRUUgQVBJCi0JICogVGhpcyBpcyBhIGdlbmVyYWwgbm90aWZpY2F0aW9uIHRoYXQgdGhlIHNwZWNpZmllZCBub2RlIGhhcyBiZWVuCi0JICogcmVtb3ZlZCBmcm9tIHRoZSB0cmVlLiBUaGUgbm9kZSByZWNlaXZpbmcgdGhpcyBub3RpZmljYXRpb24KLQkgKiBzaG91bGQgcGVyZm9ybSBhbnkgbmVjZXNzYXJ5IHVwZGF0ZXMgdG8gcmVtYWluIGluIHN5bmNoCi0JICogd2l0aCB0aGUgdHJlZSAoZS5nLiBjbGVhcmluZyBvdXQgb3IgcmVwbGFjaW5nIGFueSByZWZlcmVuY2VzCi0JICogdG8gdGhlIHJlbW92ZWQgbm9kZSBvciBhbnkgb2YgdGhlIHJlbW92ZWQgbm9kZSdzIGRlc2NlbmRhbnRzKS4KLQkgKiBAc2VlICNpc0Rlc2NlbmRhbnRPZihOb2RlKQotCSAqLwotCXZvaWQgbm9kZVJlbW92ZWQoTm9kZSBub2RlKTsKLQotCS8qKgotCSAqIElOVFJBLVRSRUUgQVBJCi0JICogVGhpcyBpcyBhIGdlbmVyYWwgbm90aWZpY2F0aW9uIHRoYXQgdGhlIHNwZWNpZmllZCBub2RlIGhhcyBiZWVuCi0JICogcmVuYW1lZC4gVGhlIG5vZGUgcmVjZWl2aW5nIHRoaXMgbm90aWZpY2F0aW9uIHNob3VsZCBtYXJrIGl0cwotCSAqIGJyYW5jaCBkaXJ0eSBpZiBuZWNlc3NhcnkgKGkuZS4gaXQgcmVmZXJlbmNlcyB0aGUgcmVuYW1lZCBub2RlCi0JICogb3Igb25lIG9mIGl0cyBkZXNjZW5kYW50cykuIFRoaXMgbWV0aG9kIGlzIG9mIHBhcnRpY3VsYXIgY29uY2VybgotCSAqIHRvIEhhbmRsZXMuCi0JICogQHNlZSAjaXNEZXNjZW5kYW50T2YoTm9kZSkKLQkgKi8KLQl2b2lkIG5vZGVSZW5hbWVkKE5vZGUgbm9kZSk7Ci0JCi0KLQkvLyAqKioqKioqKioqIGRpcnR5IGZsYWcgc3VwcG9ydCAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciBhbnkgcGVyc2lzdGVudCBhc3BlY3RzIG9mIHRoZSBub2RlLAotCSAqIG9yIGFueSBvZiBpdHMgZGVzY2VuZGFudHMsIGhhdmUgY2hhbmdlZCBzaW5jZSB0aGUgbm9kZSBhbmQKLQkgKiBpdHMgZGVzY2VuZGFudHMgd2VyZSBsYXN0IHJlYWQgb3Igc2F2ZWQuCi0JICovCi0JYm9vbGVhbiBpc0RpcnR5QnJhbmNoKCk7Ci0JCVN0cmluZyBESVJUWV9CUkFOQ0hfUFJPUEVSVFkgPSAiZGlydHlCcmFuY2giOwotCi0JLyoqCi0JICogSU5UUkEtVFJFRSBBUEkKLQkgKiBNYXJrIHRoZSBub2RlIGFuZCBpdHMgcGFyZW50IGFzIGRpcnR5IGJyYW5jaGVzLgotCSAqIFRoaXMgbWVzc2FnZSBpcyBwcm9wYWdhdGVkIHVwIHRoZSBjb250YWlubWVudAotCSAqIHRyZWUgd2hlbiBhIHBhcnRpY3VsYXIgbm9kZSBiZWNvbWVzIGRpcnR5LgotCSAqLwotCXZvaWQgbWFya0JyYW5jaERpcnR5KCk7Ci0KLQkvKioKLQkgKiBNYXJrIHRoZSBub2RlIGFuZCBhbGwgaXRzIGRlc2NlbmRhbnRzIGFzIGRpcnR5LgotCSAqIFRoaXMgaXMgdXNlZCB3aGVuIHRoZSBzYXZlIGxvY2F0aW9uIG9mIHNvbWUKLQkgKiB0b3AtbGV2ZWwgbm9kZSBpcyBjaGFuZ2VkIGFuZCB0aGUgZW50aXJlCi0JICogY29udGFpbm1lbnQgdHJlZSBtdXN0IGJlIG1hcmtlZCBkaXJ0eSBzbyBpdAotCSAqIHdpbGwgYmUgd3JpdHRlbiBvdXQuCi0JICovCi0Jdm9pZCBtYXJrRW50aXJlQnJhbmNoRGlydHkoKTsKLQotCS8qKgotCSAqIElOVFJBLVRSRUUgQVBJCi0JICogQSBjaGlsZCBub2RlJ3MgYnJhbmNoIGhhcyBiZWVuIG1hcmtlZCBjbGVhbi4gSWYgdGhlIG5vZGUKLQkgKiBpdHNlbGYgaXMgY2xlYW4gYW5kIGlmIGFsbCBvZiBpdHMgY2hpbGRyZW4gYXJlIGFsc28gY2xlYW4sIHRoZQotCSAqIG5vZGUncyBicmFuY2ggY2FuIGJlIG1hcmtlZCBjbGVhbi4gVGhlbiwgaWYgdGhlIG5vZGUncwotCSAqIGJyYW5jaCBpcyBjbGVhbiwgdGhlIG5vZGUgd2lsbCBub3RpZnkgaXRzIHBhcmVudCB0aGF0IGl0IG1pZ2h0Ci0JICogYmUgY2xlYW4gYWxzby4gVGhpcyBtZXNzYWdlIGlzIHByb3BhZ2F0ZWQgdXAgdGhlIGNvbnRhaW5tZW50Ci0JICogdHJlZSB3aGVuIGEgcGFydGljdWxhciBub2RlIGJlY29tZXMgY2xlYW4uCi0JICovCi0Jdm9pZCBtYXJrQnJhbmNoQ2xlYW5JZlBvc3NpYmxlKCk7Ci0KLQkvKioKLQkgKiBJTlRSQS1UUkVFIEFQSQotCSAqIE1hcmsgdGhlIG5vZGUgYW5kIGFsbCBpdHMgZGVzY2VuZGFudHMgYXMgY2xlYW4uCi0JICogVHlwaWNhbGx5IHVzZWQgd2hlbiB0aGUgbm9kZSBoYXMganVzdCBiZWVuCi0JICogcmVhZCBpbiBvciB3cml0dGVuIG91dC4KLQkgKiBUaGlzIG1ldGhvZCBpcyBmb3IgaW50ZXJuYWwgdXNlIG9ubHk7IGl0IGlzIG5vdCBmb3IKLQkgKiBjbGllbnQgdXNlLgotCSAqIE5vdCB0aGUgYmVzdCBvZiBtZXRob2QgbmFtZXMuLi4uIDotKAotCSAqLwotCXZvaWQgY2FzY2FkZU1hcmtFbnRpcmVCcmFuY2hDbGVhbigpOwotCi0KLQkvLyAqKioqKioqKioqIHByb2JsZW1zICoqKioqKioqKioKLQotCS8qKgotCSAqIElOVFJBLVRSRUUgQVBJCi0JICogUmV0dXJuIGEgdmFsaWRhdG9yIHRoYXQgd2lsbCBiZSBpbnZva2VkIHdoZW5ldmVyIGEKLQkgKiAidmFsaWRhdGVkIiBhc3BlY3Qgb2YgdGhlIG5vZGUgdHJlZSBjaGFuZ2VzLgotCSAqIFR5cGljYWxseSBvbmx5IHRoZSByb290IG5vZGUgZGlyZWN0bHkgaG9sZHMgYSB2YWxpZGF0b3IuCi0JICovCi0JVmFsaWRhdG9yIGdldFZhbGlkYXRvcigpOwotCi0JLyoqCi0JICogU2V0IGEgdmFsaWRhdG9yIHRoYXQgd2lsbCBiZSBpbnZva2VkIHdoZW5ldmVyIGEKLQkgKiAidmFsaWRhdGVkIiBhc3BlY3Qgb2YgdGhlIG5vZGUgdHJlZSBjaGFuZ2VzLgotCSAqIFR5cGljYWxseSBvbmx5IHRoZSByb290IG5vZGUgZGlyZWN0bHkgaG9sZHMgYSB2YWxpZGF0b3IuCi0JICovCi0Jdm9pZCBzZXRWYWxpZGF0b3IoVmFsaWRhdG9yIHZhbGlkYXRvcik7Ci0KLQkvKioKLQkgKiBWYWxpZGF0ZSB0aGUgbm9kZSBhbmQgaXRzIGRlc2NlbmRhbnRzLgotCSAqIFRoaXMgaXMgYW4gZXhwbGljaXQgcmVxdWVzdCBpbnZva2VkIGJ5IGEgY2xpZW50OyBhbmQgaXQgd2lsbAotCSAqIHR5cGljYWxseSBiZSBmb2xsb3dlZCBieSBhIGNhbGwgdG8gb25lIG9mIHRoZSBmb2xsb3dpbmcgbWV0aG9kczoKLQkgKiAJI2JyYW5jaFByb2JsZW1zKCkKLQkgKiAJI2hhc0JyYW5jaFByb2JsZW1zKCkKLQkgKiBXaGV0aGVyIHRoZSBub2RlIG1haW50YWlucyBpdHMgcHJvYmxlbXMgb24gdGhlIGZseQotCSAqIG9yIHdhaXRzIHVudGlsIHRoaXMgbWV0aG9kIGlzIGNhbGxlZCBpcyBkZXRlcm1pbmVkIGJ5IHRoZQotCSAqIGltcGxlbWVudGF0aW9uLgotCSAqIEBzZWUgUHJvYmxlbQotCSAqLwotCXZvaWQgdmFsaWRhdGVCcmFuY2goKTsKLQotCS8qKgotCSAqIElOVFJBLVRSRUUgQVBJCi0JICogVmFsaWRhdGUgdGhlIG5vZGUgYW5kIGFsbCBvZiBpdHMgZGVzY2VuZGFudHMsCi0JICogYW5kIHVwZGF0ZSB0aGVpciBzZXRzIG9mICJicmFuY2giIHByb2JsZW1zLgotCSAqIFJldHVybiB0cnVlIGlmIHRoZSBjb2xsZWN0aW9uIG9mICJicmFuY2giIHByb2JsZW1zIGhhcyBjaGFuZ2VkLgotCSAqIFRoaXMgbWV0aG9kIGlzIGZvciBpbnRlcm5hbCB1c2Ugb25seTsgaXQgaXMgbm90IGZvcgotCSAqIGNsaWVudCB1c2UuCi0JICovCi0JYm9vbGVhbiB2YWxpZGF0ZUJyYW5jaEludGVybmFsKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gYWxsIHRoZSBub2RlJ3MgcHJvYmxlbXMgYWxvbmcgd2l0aCBhbGwgdGhlCi0JICogbm9kZSdzIGRlc2NlbmRhbnRzJyBwcm9ibGVtcy4KLQkgKi8KLQlMaXN0SXRlcmF0b3I8UHJvYmxlbT4gYnJhbmNoUHJvYmxlbXMoKTsKLQkJU3RyaW5nIEJSQU5DSF9QUk9CTEVNU19MSVNUID0gImJyYW5jaFByb2JsZW1zIjsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2l6ZSBvZiBhbGwgdGhlIG5vZGUncyBwcm9ibGVtcyBhbG9uZyB3aXRoIGFsbCB0aGUKLQkgKiBub2RlJ3MgZGVzY2VuZGFudHMnIHByb2JsZW1zLgotCSAqLwotCWludCBicmFuY2hQcm9ibGVtc1NpemUoKTsKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBub2RlIG9yIGFueSBvZiBpdHMgZGVzY2VuZGFudHMgaGF2ZSBwcm9ibGVtcy4KLQkgKi8KLQlib29sZWFuIGhhc0JyYW5jaFByb2JsZW1zKCk7Ci0JCVN0cmluZyBIQVNfQlJBTkNIX1BST0JMRU1TX1BST1BFUlRZID0gImhhc0JyYW5jaFByb2JsZW1zIjsKLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBub2RlIGNvbnRhaW5zIHRoZSBzcGVjaWZpZWQgYnJhbmNoIHByb2JsZW0uCi0JICovCi0JYm9vbGVhbiBjb250YWluc0JyYW5jaFByb2JsZW0oUHJvYmxlbSBwcm9ibGVtKTsKLQotCS8qKgotCSAqIElOVFJBLVRSRUUgQVBJCi0JICogU29tZXRoaW5nIGNoYW5nZWQsIHJlYnVpbGQgdGhlIG5vZGUncyBjb2xsZWN0aW9uIG9mIGJyYW5jaCBwcm9ibGVtcy4KLQkgKi8KLQl2b2lkIHJlYnVpbGRCcmFuY2hQcm9ibGVtcygpOwotCi0JLyoqCi0JICogSU5UUkEtVFJFRSBBUEkKLQkgKiBBZGQgdGhlIG5vZGUncyBwcm9ibGVtcywgYW5kIGFsbCB0aGUgbm9kZSdzIGRlc2NlbmRhbnRzJwotCSAqIHByb2JsZW1zLCB0byB0aGUgc3BlY2lmaWVkIGxpc3QuCi0JICogQSBjYWxsIHRvIHRoaXMgbWV0aG9kIHNob3VsZCBiZSBpbW1lZGlhdGVseSBwcmVjZWRlZCBieSBhIGNhbGwgdG8KLQkgKiAjdmFsaWRhdGVCcmFuY2goKSBvciBhbGwgb2YgdGhlIHByb2JsZW1zIG1pZ2h0IG5vdCBiZQotCSAqIGFkZGVkIHRvIHRoZSBsaXN0LgotCSAqIEBzZWUgUHJvYmxlbQotCSAqLwotCXZvaWQgYWRkQnJhbmNoUHJvYmxlbXNUbyhMaXN0PFByb2JsZW0+IGJyYW5jaFByb2JsZW1zKTsKLQotCS8qKgotCSAqIENsZWFyIHRoZSBub2RlJ3MgImJyYW5jaCIgcHJvYmxlbXMgYW5kIHRoZSAiYnJhbmNoIgotCSAqIHByb2JsZW1zIG9mIGFsbCBvZiBpdHMgZGVzY2VuZGFudHMuCi0JICovCi0Jdm9pZCBjbGVhckFsbEJyYW5jaFByb2JsZW1zKCk7Ci0KLQkvKioKLQkgKiBJTlRSQS1UUkVFIEFQSQotCSAqIENsZWFyIHRoZSBub2RlJ3MgImJyYW5jaCIgcHJvYmxlbXMgYW5kIHRoZSAiYnJhbmNoIgotCSAqIHByb2JsZW1zIG9mIGFsbCBvZiBpdHMgZGVzY2VuZGFudHMuCi0JICogUmV0dXJuIHRydWUgaWYgdGhlIGNvbGxlY3Rpb24gb2YgImJyYW5jaCIgcHJvYmxlbXMgaGFzIGNoYW5nZWQuCi0JICogVGhpcyBtZXRob2QgaXMgZm9yIGludGVybmFsIHVzZSBvbmx5OyBpdCBpcyBub3QgZm9yCi0JICogY2xpZW50IHVzZS4KLQkgKi8KLQlib29sZWFuIGNsZWFyQWxsQnJhbmNoUHJvYmxlbXNJbnRlcm5hbCgpOwotCi0KLQkvLyAqKioqKioqKioqIGNvbW1lbnQgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSB1c2VyIGNvbW1lbnQgY29uY2VybmluZyB0aGUgbm9kZS4KLQkgKi8KLQlTdHJpbmcgY29tbWVudCgpOwotCQlTdHJpbmcgQ09NTUVOVF9QUk9QRVJUWSA9ICJjb21tZW50IjsKLQotCS8qKgotCSAqIFNldCB0aGUgdXNlciBjb21tZW50IGNvbmNlcm5pbmcgdGhlIG5vZGUuCi0JICovCi0Jdm9pZCBzZXRDb21tZW50KFN0cmluZyBjb21tZW50KTsKLQotCi0JLy8gKioqKioqKioqKiBkaXNwbGF5aW5nL3NvcnRpbmcgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIGEgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBtb2RlbCwgc3VpdGFibGUgZm9yIHNvcnRpbmcuCi0JICovCi0JU3RyaW5nIGRpc3BsYXlTdHJpbmcoKTsKLQotCi0JLy8gKioqKioqKioqKiBzdWItaW50ZXJmYWNlcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBTaW1wbGUgaW50ZXJmYWNlIGRlZmluaW5nIGEgInJlZmVyZW5jZSIgYmV0d2VlbiB0d28gbm9kZXMuCi0JICogQHNlZSBOb2RlI2FkZEJyYW5jaFJlZmVyZW5jZXNUbyhqYXZhLnV0aWwuQ29sbGVjdGlvbikKLQkgKi8KLQlpbnRlcmZhY2UgUmVmZXJlbmNlIHsKLQotCQkvKioKLQkJICogUmV0dXJuIHRoZSAic291cmNlIiBub2RlIG9mIHRoZSByZWZlcmVuY2UsIGkuZS4gdGhlIG5vZGUgdGhhdAotCQkgKiByZWZlcmVuY2VzIHRoZSAidGFyZ2V0IiBub2RlLgotCQkgKi8KLQkJTm9kZSBzb3VyY2UoKTsKLQotCQkvKioKLQkJICogUmV0dXJuIHRoZSAidGFyZ2V0IiBub2RlIG9mIHRoZSByZWZlcmVuY2UsIGkuZS4gdGhlIG5vZGUgdGhhdAotCQkgKiBpcyByZWZlcmVuY2VkIGJ5IHRoZSAic291cmNlIiBub2RlLgotCQkgKi8KLQkJTm9kZSB0YXJnZXQoKTsKLQotCX0KLQotCi0JLyoqCi0JICogQSB2YWxpZGF0b3Igd2lsbCB2YWxpZGF0ZSBhIG5vZGUgYXMgYXBwcm9wcmlhdGUuCi0JICogVHlwaWNhbGx5IHRoZSB2YWxpZGF0aW9uIHdpbGwKLQkgKiAJLSBvY2N1ciB3aGVuZXZlciBhIG5vZGUgaGFzIGNoYW5nZWQKLQkgKiAJLSBlbmNvbXBhc3MgdGhlIGVudGlyZSB0cmVlIGNvbnRhaW5pbmcgdGhlIG5vZGUKLQkgKiAJLSBleGVjdXRlIGFzeW5jaHJvbm91c2x5Ci0JICovCi0JaW50ZXJmYWNlIFZhbGlkYXRvciB7Ci0KLQkJLyoqCi0JCSAqIEEgInNpZ25pZmljYW50IiBhc3BlY3QgaGFzIGNoYW5nZWQ7Ci0JCSAqIHZhbGlkYXRlIHRoZSBub2RlIGFzIGFwcHJvcHJpYXRlCi0JCSAqLwotCQl2b2lkIHZhbGlkYXRlKCk7Ci0KLQkJLyoqCi0JCSAqIFN0b3AgYWxsIHZhbGlkYXRpb24gb2YgdGhlIG5vZGUgdW50aWwgI3Jlc3VtZSgpIGlzIGNhbGxlZC4KLQkJICogVGhpcyBjYW4gYmUgdXNlZCB0byBpbXByb3ZlIHRoZSBwZXJmb3JtYW5jZSBvZiBhbnkgbG9uZy1ydW5uaW5nCi0JCSAqIGFjdGlvbiB0aGF0IHRyaWdnZXJzIG51bWVyb3VzIGNoYW5nZXMgdG8gdGhlIG5vZGUuIEJlIHN1cmUgdG8KLQkJICogbWF0Y2ggYSBjYWxsIHRvIHRoaXMgbWV0aG9kIHdpdGggYSBjb3JyZXNwb25kaW5nIGNhbGwgdG8KLQkJICogI3Jlc3VtZSgpLgotCQkgKi8KLQkJdm9pZCBwYXVzZSgpOwotCi0JCS8qKgotCQkgKiBSZXN1bWUgdmFsaWRhdGlvbiBvZiB0aGUgbm9kZS4gVGhpcyBtZXRob2QgY2FuIG9ubHkgYmUKLQkJICogY2FsbGVkIGFmdGVyIGEgbWF0Y2hpbmcgY2FsbCB0byAjcGF1c2UoKS4KLQkJICovCi0JCXZvaWQgcmVzdW1lKCk7Ci0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogaGVscGVyIGltcGxlbWVudGF0aW9ucyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBTdHJhaWdodGZvcndhcmQgaW1wbGVtZW50YXRpb24gb2YgdGhlIFJlZmVyZW5jZSBpbnRlcmZhY2UKLQkgKiBkZWZpbmVkIGFib3ZlLgotCSAqLwotCXB1YmxpYyBjbGFzcyBTaW1wbGVSZWZlcmVuY2UgaW1wbGVtZW50cyBSZWZlcmVuY2UgewotCQlwcml2YXRlIE5vZGUgc291cmNlOwotCQlwcml2YXRlIE5vZGUgdGFyZ2V0OwotCQlwdWJsaWMgU2ltcGxlUmVmZXJlbmNlKE5vZGUgc291cmNlLCBOb2RlIHRhcmdldCkgewotCQkJc3VwZXIoKTsKLQkJCWlmIChzb3VyY2UgPT0gbnVsbCB8fCB0YXJnZXQgPT0gbnVsbCkgewotCQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigpOwotCQkJfQotCQkJdGhpcy5zb3VyY2UgPSBzb3VyY2U7Ci0JCQl0aGlzLnRhcmdldCA9IHRhcmdldDsKLQkJfQotCQlwdWJsaWMgTm9kZSBzb3VyY2UoKSB7Ci0JCQlyZXR1cm4gdGhpcy5zb3VyY2U7Ci0JCX0KLQkJcHVibGljIE5vZGUgdGFyZ2V0KCkgewotCQkJcmV0dXJuIHRoaXMudGFyZ2V0OwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5zb3VyY2UgKyAiID0+ICIgKyB0aGlzLnRhcmdldCk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBUeXBpY2FsIGNvbXBhcmF0b3IgdGhhdCBjYW4gYmUgdXNlZCB0byBzb3J0IGEgY29sbGVjdGlvbiBvZiBub2Rlcy4KLQkgKiBTb3J0IGJhc2VkIG9uIGRpc3BsYXkgc3RyaW5nOgotCSAqIAktIGlkZW50aWNhbCBvYmplY3RzIGFyZSBlcXVhbCAod2hpY2ggbWVhbnMgdGhhdCBjYW5ub3QKLQkgKiAJCWNvLWV4aXN0IGluIGEgU29ydGVkU2V0KQotCSAqIAktIHVzZSB0aGUgZGVmYXVsdCBjb2xsYXRvciAod2hpY2ggdHlwaWNhbGx5IGludGVybGVhdmVzCi0JICogCQlsb3dlci0gYW5kIHVwcGVyLWNhc2UgbGV0dGVycykKLQkgKiAJLSBhbGxvdyBkdXBsaWNhdGUgZGlzcGxheSBzdHJpbmdzIChmcm9tIGRpZmZlcmVudCBvYmplY3RzKQotCSAqIAktIHRyeSB0byByZXR1cm4gY29uc2lzdGVudCByZXN1bHRzIGZvciBzYW1lIG9iamVjdCBwYWlycwotCSAqLwotCUNvbXBhcmF0b3I8Tm9kZT4gREVGQVVMVF9DT01QQVJBVE9SID0KLQkJbmV3IENvbXBhcmF0b3I8Tm9kZT4oKSB7Ci0JCQlwdWJsaWMgaW50IGNvbXBhcmUoTm9kZSBub2RlMSwgTm9kZSBub2RlMikgewotCQkJCS8vIGRpc2FsbG93IGR1cGxpY2F0ZXMgYmFzZWQgb24gb2JqZWN0IGlkZW50aXR5Ci0JCQkJaWYgKG5vZGUxID09IG5vZGUyKSB7Ci0JCQkJCXJldHVybiAwOwotCQkJCX0KLQotCQkJCS8vIGZpcnN0IGNvbXBhcmUgZGlzcGxheSBzdHJpbmdzIHVzaW5nIHRoZSBkZWZhdWx0IGNvbGxhdG9yCi0JCQkJaW50IHJlc3VsdCA9IENvbGxhdG9yLmdldEluc3RhbmNlKCkuY29tcGFyZShub2RlMS5kaXNwbGF5U3RyaW5nKCksIG5vZGUyLmRpc3BsYXlTdHJpbmcoKSk7Ci0JCQkJaWYgKHJlc3VsdCAhPSAwKSB7Ci0JCQkJCXJldHVybiByZXN1bHQ7Ci0JCQkJfQotCi0JCQkJLy8gdGhlbiBjb21wYXJlIHVzaW5nIG9iamVjdC1pZAotCQkJCXJlc3VsdCA9IFN5c3RlbS5pZGVudGl0eUhhc2hDb2RlKG5vZGUxKSAtIFN5c3RlbS5pZGVudGl0eUhhc2hDb2RlKG5vZGUyKTsKLQkJCQlpZiAocmVzdWx0ICE9IDApIHsKLQkJCQkJcmV0dXJuIHJlc3VsdDsKLQkJCQl9Ci0KLQkJCQkvLyBJdCdzIHVubGlrZWx5IHRoYXQgd2UgZ2V0IHRvIHRoaXMgcG9pbnQ7IGJ1dCwganVzdCBpbiBjYXNlLCB3ZSB3aWxsIHJldHVybiAtMS4KLQkJCQkvLyBVbmZvcnR1bmF0ZWx5LCB0aGlzIGludHJvZHVjZXMgc29tZSBtaWxkIHVucHJlZGljdGFiaWxpdHkgdG8gdGhlIHNvcnQgb3JkZXIKLQkJCQkvLyAodW5sZXNzIHRoZSBvYmplY3RzIGFyZSBhbHdheXMgcGFzc2VkIGludG8gdGhpcyBtZXRob2QgaW4gdGhlIHNhbWUgb3JkZXIpLgotCQkJCXJldHVybiAtMTsJCS8vIGlmIGFsbCBlbHNlIGZhaWxzLCBpbmRpY2F0ZSB0aGF0IG8xIDwgbzIKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gIk5vZGUuREVGQVVMVF9DT01QQVJBVE9SIjsKLQkJCX0KLQkJfTsKLQotCi0JLyoqCi0JICogVGhpcyB2YWxpZGF0b3IgZG9lcyBub3RoaW5nIHRvIHZhbGlkYXRlIHRoZSBub2RlLgotCSAqLwotCVZhbGlkYXRvciBOVUxMX1ZBTElEQVRPUiA9Ci0JCW5ldyBQbHVnZ2FibGVWYWxpZGF0b3IoUGx1Z2dhYmxlVmFsaWRhdG9yLkRlbGVnYXRlLk51bGwuaW5zdGFuY2UoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAiTm9kZS5OVUxMX1ZBTElEQVRPUiI7Ci0JCQl9Ci0JCX07Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9ub2RlL1BsdWdnYWJsZVZhbGlkYXRvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL25vZGUvUGx1Z2dhYmxlVmFsaWRhdG9yLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGM0NGY4YWEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL25vZGUvUGx1Z2dhYmxlVmFsaWRhdG9yLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMjEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5ub2RlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3luY2hyb25pemVkQm9vbGVhbjsKLQotLyoqCi0gKiBUaGlzIGltcGxlbWVudGF0aW9uIG9mIHRoZSBWYWxpZGF0b3IgaW50ZXJmYWNlIGltcGxlbWVudHMgdGhlCi0gKiBwYXVzZS9yZXN1bWUgcG9ydGlvbiBvZiB0aGUgcHJvdG9jb2wsIGJ1dCBkZWxlZ2F0ZXMgdGhlIGFjdHVhbAotICogdmFsaWRhdGlvbiB0byBhICJwbHVnZ2FibGUiIGRlbGVnYXRlLgotICovCi1wdWJsaWMgY2xhc3MgUGx1Z2dhYmxlVmFsaWRhdG9yCi0JaW1wbGVtZW50cyBOb2RlLlZhbGlkYXRvcgotewotCXByaXZhdGUgYm9vbGVhbiBwYXVzZTsKLQlwcml2YXRlIGJvb2xlYW4gdmFsaWRhdGVPblJlc3VtZTsKLQlwcml2YXRlIGZpbmFsIERlbGVnYXRlIGRlbGVnYXRlOwotCi0KLQkvKioKLQkgKiBDb252ZW5pZW5jZSBmYWN0b3J5IG1ldGhvZC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE5vZGUuVmFsaWRhdG9yIGJ1aWxkQXN5bmNocm9ub3VzVmFsaWRhdG9yKFN5bmNocm9uaXplZEJvb2xlYW4gdmFsaWRhdGVGbGFnKSB7Ci0JCXJldHVybiBuZXcgUGx1Z2dhYmxlVmFsaWRhdG9yKG5ldyBBc3luY2hyb25vdXNWYWxpZGF0b3IodmFsaWRhdGVGbGFnKSk7Ci0JfQotCi0JLyoqCi0JICogQ29udmVuaWVuY2UgZmFjdG9yeSBtZXRob2QuCi0JICovCi0JcHVibGljIHN0YXRpYyBOb2RlLlZhbGlkYXRvciBidWlsZFN5bmNocm9ub3VzVmFsaWRhdG9yKE5vZGUgbm9kZSkgewotCQlyZXR1cm4gbmV3IFBsdWdnYWJsZVZhbGlkYXRvcihuZXcgU3luY2hyb25vdXNWYWxpZGF0b3Iobm9kZSkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHZhbGlkYXRvciB3aXRoIHRoZSBzcGVjaWZpZWQgZGVsZWdhdGUuCi0JICovCi0JcHVibGljIFBsdWdnYWJsZVZhbGlkYXRvcihEZWxlZ2F0ZSBkZWxlZ2F0ZSkgewotCQlzdXBlcigpOwotCQl0aGlzLnBhdXNlID0gZmFsc2U7Ci0JCXRoaXMudmFsaWRhdGVPblJlc3VtZSA9IGZhbHNlOwotCQl0aGlzLmRlbGVnYXRlID0gZGVsZWdhdGU7Ci0JfQotCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIHZhbGlkYXRlKCkgewotCQlpZiAodGhpcy5wYXVzZSkgewotCQkJdGhpcy52YWxpZGF0ZU9uUmVzdW1lID0gdHJ1ZTsKLQkJfSBlbHNlIHsKLQkJCXRoaXMuZGVsZWdhdGUudmFsaWRhdGUoKTsKLQkJfQotCX0KLQotCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCBwYXVzZSgpIHsKLQkJaWYgKHRoaXMucGF1c2UpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oImFscmVhZHkgcGF1c2VkIik7Ci0JCX0KLQkJdGhpcy5wYXVzZSA9IHRydWU7Ci0JfQotCi0JcHVibGljIHN5bmNocm9uaXplZCB2b2lkIHJlc3VtZSgpIHsKLQkJaWYgKCAhIHRoaXMucGF1c2UpIHsKLQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oIm5vdCBwYXVzZWQiKTsKLQkJfQotCQl0aGlzLnBhdXNlID0gZmFsc2U7Ci0JCS8vIHZhbGlkYXRlIGFueSBjaGFuZ2VzIHRoYXQgb2NjdXJyZWQgd2hpbGUgdGhlIHZhbGlkYXRpb24gd2FzIHBhdXNlZAotCQlpZiAodGhpcy52YWxpZGF0ZU9uUmVzdW1lKSB7Ci0JCQl0aGlzLnZhbGlkYXRlT25SZXN1bWUgPSBmYWxzZTsKLQkJCXRoaXMuZGVsZWdhdGUudmFsaWRhdGUoKTsKLQkJfQotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuZGVsZWdhdGUpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBtZW1iZXIgaW50ZXJmYWNlICoqKioqKioqKioKLQotCS8qKgotCSAqIEludGVyZmFjZSBpbXBsZW1lbnRlZCBieSBhbnkgZGVsZWdhdGVzIG9mIGEgcGx1Z2dhYmxlIHZhbGlkYXRvci4KLQkgKi8KLQlwdWJsaWMgaW50ZXJmYWNlIERlbGVnYXRlIHsKLQotCQkvKioKLQkJICogVGhlIHZhbGlkYXRvciBpcyBub3QgInBhdXNlZCIgLSBwZXJmb3JtIHRoZSBhcHByb3ByaWF0ZSB2YWxpZGF0aW9uLgotCQkgKi8KLQkJdm9pZCB2YWxpZGF0ZSgpOwotCi0KLQkJLyoqCi0JCSAqIFRoaXMgZGVsZWdhdGUgZG9lcyBub3RoaW5nLgotCQkgKi8KLQkJZmluYWwgY2xhc3MgTnVsbCBpbXBsZW1lbnRzIERlbGVnYXRlIHsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgRGVsZWdhdGUgSU5TVEFOQ0UgPSBuZXcgTnVsbCgpOwotCQkJcHVibGljIHN0YXRpYyBEZWxlZ2F0ZSBpbnN0YW5jZSgpIHsKLQkJCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JCQl9Ci0JCQkvLyBlbnN1cmUgc2luZ2xlIGluc3RhbmNlCi0JCQlwcml2YXRlIE51bGwoKSB7Ci0JCQkJc3VwZXIoKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIHZhbGlkYXRlKCkgewotCQkJCS8vIGRvIG5vdGhpbmcKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gIlBsdWdnYWJsZVZhbGlkYXRvci5EZWxlZ2F0ZS5OdWxsIjsKLQkJCX0KLQkJfQotCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbm9kZS9Qcm9ibGVtLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbm9kZS9Qcm9ibGVtLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDRmOGU3MzAuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL25vZGUvUHJvYmxlbS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5ub2RlOwotCi0vKioKLSAqIERlZmluZSBhbiBpbnRlcmZhY2UgZGVzY3JpYmluZyB0aGUgcHJvYmxlbXMgYXNzb2NpYXRlZCB3aXRoIGEgbm9kZS4KLSAqLwotcHVibGljIGludGVyZmFjZSBQcm9ibGVtIHsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgbm9kZSBtb3N0IGNsb3NlbHkgYXNzb2NpYXRlZCB3aXRoIHRoZSBwcm9ibGVtLgotCSAqLwotCU5vZGUgc291cmNlKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBrZXkgdGhhdCBjYW4gYmUgdXNlZCB0byB1bmlxdWVseSBpZGVudGlmeSB0aGUgcHJvYmxlbSdzIG1lc3NhZ2UuCi0JICovCi0JU3RyaW5nIG1lc3NhZ2VLZXkoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJndW1lbnRzIGFzc29jaWF0ZSB3aXRoIHRoZSBwcm9ibGVtJ3MgbWVzc2FnZS4KLQkgKi8KLQlPYmplY3RbXSBtZXNzYWdlQXJndW1lbnRzKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgcHJvYmxlbSBpcyBlcXVhbCB0byB0aGUgc3BlY2lmaWVkIG9iamVjdC4KLQkgKiBJdCBpcyBlcXVhbCBpZiB0aGUgc3BlY2lmaWVkIG9iamVjdCBpcyBhIGltcGxlbWVudGF0aW9uIG9mIHRoZQotCSAqIFByb2JsZW0gaW50ZXJmYWNlIGFuZCBpdHMgc291cmNlLCBtZXNzYWdlIGtleSwgYW5kIG1lc3NhZ2UKLQkgKiBhcmd1bWVudHMgYXJlIGFsbCBlcXVhbCB0byB0aGlzIHByb2JsZW0ncy4KLQkgKi8KLQlib29sZWFuIGVxdWFscyhPYmplY3Qgbyk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHByb2JsZW0ncyBoYXNoIGNvZGUsIHdoaWNoIHNob3VsZCBjYWxjdWxhdGVkIGFzIGFuCi0JICogWE9SIG9mIHRoZSBzb3VyY2UncyBoYXNoIGNvZGUgYW5kIHRoZSBtZXNzYWdlIGtleSdzIGhhc2ggY29kZS4KLQkgKi8KLQlpbnQgaGFzaENvZGUoKTsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL25vZGUvUnVubmFibGVWYWxpZGF0aW9uLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbm9kZS9SdW5uYWJsZVZhbGlkYXRpb24uamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzY3ZDU3YS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbm9kZS9SdW5uYWJsZVZhbGlkYXRpb24uamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEyOCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm5vZGU7Ci0KLWltcG9ydCBqYXZhLnV0aWwubG9nZ2luZy5MZXZlbDsKLWltcG9ydCBqYXZhLnV0aWwubG9nZ2luZy5Mb2dSZWNvcmQ7Ci1pbXBvcnQgamF2YS51dGlsLmxvZ2dpbmcuTG9nZ2VyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN5bmNocm9uaXplZEJvb2xlYW47Ci0KLS8qKgotICogVGhpcyBpbXBsZW1lbnRhdGlvbiBvZiBSdW5uYWJsZSB3aWxsIGFzeW5jaHJvbm91c2x5IHZhbGlkYXRlCi0gKiBhIGJyYW5jaCBvZiBub2Rlcy4gSXQgd2lsbCB3YWl0IHVudGlsIGEgc2hhcmVkICJ2YWxpZGF0ZSIgZmxhZyBpcwotICogc2V0IHRvIHZhbGlkYXRlIHRoZSBicmFuY2guIE9uY2UgdGhlIHRoZSBicmFuY2ggaXMgdmFsaWRhdGVkLAotICogdGhlIHRocmVhZCB3aWxsIHF1aWVzY2UgdW50aWwgdGhlIGZsYWcgaXMgc2V0IGFnYWluLgotICogCi0gKiBUaGVyZSBhcmUgdHdvIHdheXMgdG8gc3RvcCB0aGlzIHRocmVhZDoKLSAqIAktIFRocmVhZC5pbnRlcnJ1cHQoKQotICogCS0gc2V0IHRoZSAiY29udGludWUiIGZsYWcgdG8gZmFsc2UKLSAqIEZvciBub3csIHRoZXNlIHR3byBhcmUgZXF1aXZhbGVudDsgYnV0IGluIHRoZSBmdXR1cmUgd2UgbWlnaHQKLSAqIHBhc3MgdGhlICJjb250aW51ZSIgZmxhZyB0byB0aGUgTm9kZS52YWxpZGF0ZUJyYW5jaCgpCi0gKiBtZXRob2Qgc28gd2UgY2FuIHNob3J0LWNpcmN1aXQgdGhlIHZhbGlkYXRpb24gaW5zdGVhZCBvZiB3YWl0aW5nCi0gKiB1bnRpbCB0aGUgZW50aXJlIGJyYW5jaCBpcyB2YWxpZGF0ZWQuCi0gKi8KLXB1YmxpYyBjbGFzcyBSdW5uYWJsZVZhbGlkYXRpb24KLQlpbXBsZW1lbnRzIFJ1bm5hYmxlCi17Ci0JLyoqIFRoZSBub2RlIHdob3NlIGJyYW5jaCB0aGlzIHRocmVhZCB3aWxsIHZhbGlkYXRlLiAqLwotCXByaXZhdGUgZmluYWwgTm9kZSBub2RlOwotCi0JLyoqIFdoZW4gdGhpcyBmbGFnIGlzIHNldCB0byB0cnVlLCB3ZSBraWNrIG9mZiB0aGUgdmFsaWRhdGlvbiByb3V0aW5lLiAqLwotCXByaXZhdGUgZmluYWwgU3luY2hyb25pemVkQm9vbGVhbiB2YWxpZGF0ZUZsYWc7Ci0KLQkvKiogV2hlbiB0aGlzIGZsYWcgaXMgc2V0IHRvIGZhbHNlLCB3ZSBhbGxvdyB0aGlzIHRocmVhZCB0byBkaWUuICovCi0JcHJpdmF0ZSBmaW5hbCBTeW5jaHJvbml6ZWRCb29sZWFuIGNvbnRpbnVlRmxhZzsKLQotCS8qKiBMb2cgYW55IGV4Y2VwdGlvbnMgZW5jb3VudGVyZWQgZHVyaW5nIHZhbGlkYXRpb24gd2l0aCB0aGUgZm9sbG93aW5nIHNldHRpbmdzLiAqLwotCXByaXZhdGUgZmluYWwgTG9nZ2VyIGV4Y2VwdGlvbkxvZ2dlcjsKLQlwcml2YXRlIGZpbmFsIExldmVsIGV4Y2VwdGlvbkxldmVsOwotCXByaXZhdGUgZmluYWwgU3RyaW5nIGV4Y2VwdGlvbk1lc3NhZ2U7Ci0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHZhbGlkYXRpb24gdGhyZWFkLgotCSAqLwotCXB1YmxpYyBSdW5uYWJsZVZhbGlkYXRpb24oCi0JCQlOb2RlIG5vZGUsCi0JCQlTeW5jaHJvbml6ZWRCb29sZWFuIHZhbGlkYXRlRmxhZywKLQkJCVN5bmNocm9uaXplZEJvb2xlYW4gY29udGludWVGbGFnLAotCQkJTG9nZ2VyIGV4Y2VwdGlvbkxvZ2dlciwKLQkJCUxldmVsIGV4Y2VwdGlvbkxldmVsLAotCQkJU3RyaW5nIGV4Y2VwdGlvbk1lc3NhZ2UKLQkpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5ub2RlID0gbm9kZTsKLQkJdGhpcy52YWxpZGF0ZUZsYWcgPSB2YWxpZGF0ZUZsYWc7Ci0JCXRoaXMuY29udGludWVGbGFnID0gY29udGludWVGbGFnOwotCQl0aGlzLmV4Y2VwdGlvbkxvZ2dlciA9IGV4Y2VwdGlvbkxvZ2dlcjsKLQkJdGhpcy5leGNlcHRpb25MZXZlbCA9IGV4Y2VwdGlvbkxldmVsOwotCQl0aGlzLmV4Y2VwdGlvbk1lc3NhZ2UgPSBleGNlcHRpb25NZXNzYWdlOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBSdW5uYWJsZSBJbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQkvKioKLQkgKiBMb29wIHdoaWxlIHRoZSAiY29udGludWUiIGZsYWcgaXMgdHJ1ZSBhbmQgdGhlIHRocmVhZAotCSAqIGhhcyBub3QgYmVlbiBpbnRlcnJ1cHRlZCBieSBhbm90aGVyIHRocmVhZC4KLQkgKiBJbiBlYWNoIGxvb3A6IFdhaXQgdW50aWwgdGhlICJ2YWxpZGF0ZSIgZmxhZyBpcyBzZXQgdG8gdHJ1ZSwKLQkgKiB0aGVuIHNldCBpdCBiYWNrIHRvIGZhbHNlIGFuZCB2YWxpZGF0ZSB0aGUgYnJhbmNoIG9mIG5vZGVzLgotCSAqLwotCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJd2hpbGUgKHRoaXMuY29udGludWVGbGFnLmlzVHJ1ZSgpKSB7Ci0JCQl0cnkgewotCQkJCXRoaXMudmFsaWRhdGVGbGFnLndhaXRUb1NldEZhbHNlKCk7Ci0JCQl9IGNhdGNoIChJbnRlcnJ1cHRlZEV4Y2VwdGlvbiBleCkgewotCQkJCS8vIHdlIHdlcmUgaW50ZXJydXB0ZWQgd2hpbGUgd2FpdGluZywgbXVzdCBiZSBxdWl0dGluJyB0aW1lCi0JCQkJcmV0dXJuOwotCQkJfQotCQkJdGhpcy52YWxpZGF0ZU5vZGUoKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIFZhbGlkYXRlIHRoZSBub2RlLCBsb2dnaW5nIGFueSBleGNlcHRpb25zLgotCSAqIElmIGFuIGV4Y2VwdGlvbiBvY2N1cnMsIHdlIHRlcm1pbmF0ZSB0aGUgdmFsaWRhdGlvbiB1bnRpbCB0aGUKLQkgKiAidmFsaWRhdGlvbiIgZmxhZyBpcyBzZXQgYWdhaW4uIFNvbWUgZXhjZXB0aW9ucyBvY2N1ciBiZWNhdXNlCi0JICogb2YgY29uY3VycmVudCBjaGFuZ2VzIHRvIHRoZSBtb2RlbCB0aGF0IG9jY3VyICphZnRlciogdmFsaWRhdGlvbgotCSAqIHN0YXJ0cyBidXQgYmVmb3JlIGl0IGNvbXBsZXRlcyBhbiBlbnRpcmUgcGFzcyBvdmVyIHRoZSBtb2RlbC4gSWYgdGhhdAotCSAqIGlzIHRoZSBjYXNlLCB0aGluZ3Mgc2hvdWxkIGJlIE9LOyBiZWNhdXNlIHRoZSBleGNlcHRpb24gd2lsbCBiZQotCSAqIGNhdWdodCBhbmQgdGhlICJ2YWxpZGF0aW9uIiBmbGFnIHdpbGwgaGF2ZSBiZWVuIHNldCBhZ2FpbiAqZHVyaW5nKiB0aGUKLQkgKiBpbml0aWFsIHZhbGlkYXRpb24gcGFzcy4gU28gd2hlbiB3ZSByZXR1cm4gZnJvbSBjYXRjaGluZyB0aGUgZXhjZXB0aW9uCi0JICogd2Ugd2lsbCBzaW1wbHkgcmUtc3RhcnQgdGhlIHZhbGlkYXRpb24sIGhvcGVmdWxseSB3aXRoIHRoZSBtb2RlbCBpbgotCSAqIGEgY29uc2lzdGVudCBzdGF0ZSB0aGF0IHdpbGwgcHJldmVudCBhbm90aGVyIGV4Y2VwdGlvbiBmcm9tCi0JICogb2NjdXJyaW5nLiBPZiBjb3Vyc2UsIGlmIHdlIGhhdmUgYW55IGV4Y2VwdGlvbnMgdGhhdCBhcmUgKm5vdCoKLQkgKiB0aGUgcmVzdWx0IG9mIHRoZSBtb2RlbCBiZWluZyBpbiBhbiBpbmNvbnNpc3RlbnQgc3RhdGUsIHdlIHdpbGwKLQkgKiBwcm9iYWJseSBmaWxsIHRoZSBsb2c7IGFuZCB0aG9zZSBleGNlcHRpb25zIGFyZSBidWdzIHRoYXQgbmVlZAotCSAqIHRvIGJlIGZpeGVkLiAoISkgSG9wZWZ1bGx5IHRoZSB1c2VyIHdpbGwgbm90aWNlIHRoZSBlbm9ybW91cyBsb2cgYW5kCi0JICogY29udGFjdCBzdXBwb3J0Li4uLiAgfmJqdgotCSAqLwotCXByaXZhdGUgdm9pZCB2YWxpZGF0ZU5vZGUoKSB7Ci0JCXRyeSB7Ci0JCQl0aGlzLm5vZGUudmFsaWRhdGVCcmFuY2goKTsKLQkJfSBjYXRjaCAoVGhyb3dhYmxlIGV4KSB7Ci0JCQl0aGlzLmxvZ0V4Y2VwdGlvbihleCk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBXZSBuZWVkIHRvIGRvIGFsbCB0aGlzIGJlY2F1c2UgTG9nZ2VyI2xvZyhMb2dSZWNvcmQpIGRvZXMgbm90IHBhc3MgdGhyb3VnaAotCSAqIExvZ2dlciNkb0xvZyhMb2dSZWNvcmQpIGxpa2UgYWxsIHRoZSBvdGhlciBMb2dnZXIjbG9nKC4uLikgbWV0aG9kcy4KLQkgKi8KLQlwcml2YXRlIHZvaWQgbG9nRXhjZXB0aW9uKFRocm93YWJsZSBleCkgewotCQlMb2dSZWNvcmQgbG9nUmVjb3JkID0gbmV3IExvZ1JlY29yZCh0aGlzLmV4Y2VwdGlvbkxldmVsLCB0aGlzLmV4Y2VwdGlvbk1lc3NhZ2UpOwotCQlsb2dSZWNvcmQuc2V0UGFyYW1ldGVycyhuZXcgT2JqZWN0W10geyB0aGlzLm5vZGUuZGlzcGxheVN0cmluZygpIH0pOwotCQlsb2dSZWNvcmQuc2V0VGhyb3duKGV4KTsKLQkJbG9nUmVjb3JkLnNldExvZ2dlck5hbWUodGhpcy5leGNlcHRpb25Mb2dnZXIuZ2V0TmFtZSgpKTsKLQkJbG9nUmVjb3JkLnNldFJlc291cmNlQnVuZGxlKHRoaXMuZXhjZXB0aW9uTG9nZ2VyLmdldFJlc291cmNlQnVuZGxlKCkpOwotCQl0aGlzLmV4Y2VwdGlvbkxvZ2dlci5sb2cobG9nUmVjb3JkKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9ub2RlL1N5bmNocm9ub3VzVmFsaWRhdG9yLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvbm9kZS9TeW5jaHJvbm91c1ZhbGlkYXRvci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlZGU2YjhiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9ub2RlL1N5bmNocm9ub3VzVmFsaWRhdG9yLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0NCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm5vZGU7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotLyoqCi0gKiBUaGlzIGltcGxlbWVudGF0aW9uIG9mIHRoZSBQbHVnZ2FibGVWYWxpZGF0b3IuRGVsZWdhdGUgaW50ZXJmYWNlCi0gKiB3aWxsIHZhbGlkYXRlIHRoZSBub2RlIGltbWVkaWF0ZWx5LgotICogCi0gKiBUaGlzIGlzIHVzZWZ1bCBmb3IgZGVidWdnaW5nIGluIGEgc2luZ2xlIHRocmVhZCBvciBnZW5lcmF0aW5nCi0gKiBwcm9ibGVtIHJlcG9ydHMuCi0gKi8KLXB1YmxpYyBjbGFzcyBTeW5jaHJvbm91c1ZhbGlkYXRvcgotCWltcGxlbWVudHMgUGx1Z2dhYmxlVmFsaWRhdG9yLkRlbGVnYXRlCi17Ci0JcHJpdmF0ZSBmaW5hbCBOb2RlIG5vZGU7Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSB2YWxpZGF0b3IgdGhhdCB3aWxsIGltbWVkaWF0ZWx5IHZhbGlkYXRlIHRoZQotCSAqIHNwZWNpZmllZCBub2RlLgotCSAqLwotCXB1YmxpYyBTeW5jaHJvbm91c1ZhbGlkYXRvcihOb2RlIG5vZGUpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5ub2RlID0gbm9kZTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB2YWxpZGF0ZSgpIHsKLQkJdGhpcy5ub2RlLnZhbGlkYXRlQnJhbmNoKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJcmV0dXJuIFN0cmluZ1Rvb2xzLmJ1aWxkVG9TdHJpbmdGb3IodGhpcywgdGhpcy5ub2RlKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9DYWNoaW5nQ29tYm9Cb3hNb2RlbC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL0NhY2hpbmdDb21ib0JveE1vZGVsLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhlYmUyNjEuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL0NhY2hpbmdDb21ib0JveE1vZGVsLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLnN3aW5nOwotCi1pbXBvcnQgamF2YXguc3dpbmcuQ29tYm9Cb3hNb2RlbDsKLQotLyoqCi0gKiBUaGlzIGludGVyZmFjZSBhbGxvd3MgYSBjbGllbnQgdG8gYmV0dGVyIGNvbnRyb2wgdGhlIHBlcmZvcm1hbmNlIG9mCi0gKiBhIGNvbWJvIGJveCBtb2RlbCBieSBhbGxvd2luZyB0aGUgY2xpZW50IHRvIHNwZWNpZnkgd2hlbiBpdCBpcwotICogYWNjZXB0YWJsZSBmb3IgdGhlIG1vZGVsIHRvICJjYWNoZSIgYW5kICJ1bmNhY2hlIiBpdHMgbGlzdCBvZiBlbGVtZW50cy4KLSAqIFRoZSBtb2RlbCBtYXkgaWdub3JlIHRoZXNlIGhpbnRzIGlmIGFwcHJvcHJpYXRlLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIENhY2hpbmdDb21ib0JveE1vZGVsIGV4dGVuZHMgQ29tYm9Cb3hNb2RlbCB7Ci0gICAgCi0gICAgLyoqCi0gICAgICogQ2FjaGUgdGhlIGNvbWJvQm94TW9kZWwgTGlzdC4gIElmIHlvdSBjYWxsIHRoaXMsIHlvdQotICAgICAqIG11c3QgbWFrZSBzdXJlIHRvIGNhbGwgdW5jYWNoZUxpc3QoKSBhcyB3ZWxsLiAgT3RoZXJ3aXNlCi0gICAgICogc3RhbGUgZGF0YSB3aWxsIGJlIGluIHRoZSBDb21ib0JveCB1bnRpbCBjYWNoZUxpc3QoKSBpcyAKLSAgICAgKiBjYWxsZWQgYWdhaW4gb3IgdW5jYWNoZUxpc3QoKSBpcyBjYWxsZWQuCi0gICAgICovCi0gICAgdm9pZCBjYWNoZUxpc3QoKTsKLSAgICAKLSAgICAvKioKLSAgICAgKiBDbGVhciB0aGUgY2FjaGVkIGxpc3QuICBOZXh0IHRpbWUgdGhlIGxpc3QgaXMgbmVlZGVkIGl0IHdpbGwKLSAgICAgKiBiZSBidWlsdCB3aGVuIGl0IGlzIG5vdCBjYWNoZWQuCi0gICAgICovCi0gICAgdm9pZCB1bmNhY2hlTGlzdCgpOwotCi0gICAgLyoqCi0gICAgICogQ2hlY2sgdG8gc2VlIGlmIHRoZSBsaXN0IGlzIGFscmVhZHkgY2FjaGVkLiAgVGhpcyBjYW4gYmUgdXNlZCBmb3IgCi0gICAgICogTW91c2VFdmVudHMsIHNpbmNlIHRoZXkgYXJlIG5vdCB0ZXJyaWJseSBwcmVkaWN0YWJsZS4KLSAgICAgKi8KLSAgICBib29sZWFuIGlzQ2FjaGVkKCk7Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9DaGVja0JveFRhYmxlQ2VsbFJlbmRlcmVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvc3dpbmcvQ2hlY2tCb3hUYWJsZUNlbGxSZW5kZXJlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0NWVjNmJlLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9DaGVja0JveFRhYmxlQ2VsbFJlbmRlcmVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyMDYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZzsKLQotaW1wb3J0IGphdmEuYXd0LkNvbG9yOwotaW1wb3J0IGphdmEuYXd0LkNvbXBvbmVudDsKLWltcG9ydCBqYXZhLmF3dC5ldmVudC5BY3Rpb25FdmVudDsKLWltcG9ydCBqYXZhLmF3dC5ldmVudC5BY3Rpb25MaXN0ZW5lcjsKLWltcG9ydCBqYXZheC5zd2luZy5Cb3JkZXJGYWN0b3J5OwotaW1wb3J0IGphdmF4LnN3aW5nLkljb247Ci1pbXBvcnQgamF2YXguc3dpbmcuSkNoZWNrQm94OwotaW1wb3J0IGphdmF4LnN3aW5nLkpUYWJsZTsKLWltcG9ydCBqYXZheC5zd2luZy5Td2luZ0NvbnN0YW50czsKLWltcG9ydCBqYXZheC5zd2luZy5VSU1hbmFnZXI7Ci1pbXBvcnQgamF2YXguc3dpbmcuYm9yZGVyLkJvcmRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZy5UYWJsZUNlbGxFZGl0b3JBZGFwdGVyLkltbWVkaWF0ZUVkaXRMaXN0ZW5lcjsKLQotLyoqCi0gKiBNYWtlIHRoZSBjZWxsIGxvb2sgbGlrZSBhIGNoZWNrIGJveC4KLSAqLwotcHVibGljIGNsYXNzIENoZWNrQm94VGFibGVDZWxsUmVuZGVyZXIgaW1wbGVtZW50cyBUYWJsZUNlbGxFZGl0b3JBZGFwdGVyLlJlbmRlcmVyIHsKLQotCS8qKiB0aGUgY29tcG9uZW50IHVzZWQgdG8gcGFpbnQgdGhlIGNlbGwgKi8KLQlwcml2YXRlIGZpbmFsIEpDaGVja0JveCBjaGVja0JveDsKLQkKLQkvKiogdGhlIGxpc3RlbmVyIHRvIGJlIG5vdGlmaWVkIG9uIGFuIGltbWVkaWF0ZSBlZGl0ICovCi0JcHJvdGVjdGVkIFRhYmxlQ2VsbEVkaXRvckFkYXB0ZXIuSW1tZWRpYXRlRWRpdExpc3RlbmVyIGltbWVkaWF0ZUVkaXRMaXN0ZW5lcjsKLQotCS8qKiAibm9ybWFsIiBib3JkZXIgLSBhc3N1bWUgdGhlIGRlZmF1bHQgdGFibGUgImZvY3VzIiBib3JkZXIgaXMgMSBwaXhlbCB0aGljayAqLwotCXByaXZhdGUgc3RhdGljIGZpbmFsIEJvcmRlciBOT19GT0NVU19CT1JERVIgPSBCb3JkZXJGYWN0b3J5LmNyZWF0ZUVtcHR5Qm9yZGVyKDEsIDEsIDEsIDEpOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycy9pbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBjZWxsIHJlbmRlcmVyIHdpdGggbm8gbGFiZWwgb3IgaWNvbi4KLQkgKi8KLQlwdWJsaWMgQ2hlY2tCb3hUYWJsZUNlbGxSZW5kZXJlcigpIHsKLQkJc3VwZXIoKTsKLQkJdGhpcy5jaGVja0JveCA9IHRoaXMuYnVpbGRDaGVja0JveCgpOwotCQkvLyBieSBkZWZhdWx0LCBjaGVjayBib3hlcyBkbyBub3QgcGFpbnQgdGhlaXIgYm9yZGVycwotCQl0aGlzLmNoZWNrQm94LnNldEJvcmRlclBhaW50ZWQodHJ1ZSk7Ci0JCS8vIHRoaXMgc2V0dGluZyBpcyByZWNvbW1lbmRlZCBmb3IgY2hlY2sgYm94ZXMgaW5zaWRlIG9mIHRyZWVzIGFuZCB0YWJsZXMKLQkJdGhpcy5jaGVja0JveC5zZXRCb3JkZXJQYWludGVkRmxhdCh0cnVlKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBjZWxsIHJlbmRlcmVyIHdpdGggdGhlIHNwZWNpZmllZCB0ZXh0IGFuZCBpY29uLAotCSAqIGVpdGhlciBvZiB3aGljaCBtYXkgYmUgbnVsbC4KLQkgKi8KLQlwdWJsaWMgQ2hlY2tCb3hUYWJsZUNlbGxSZW5kZXJlcihTdHJpbmcgdGV4dCwgSWNvbiBpY29uKSB7Ci0JCXRoaXMoKTsKLQkJdGhpcy5zZXRUZXh0KHRleHQpOwotCQl0aGlzLnNldEljb24oaWNvbik7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgY2VsbCByZW5kZXJlciB3aXRoIHRoZSBzcGVjaWZpZWQgdGV4dC4KLQkgKi8KLQlwdWJsaWMgQ2hlY2tCb3hUYWJsZUNlbGxSZW5kZXJlcihTdHJpbmcgdGV4dCkgewotCQl0aGlzKHRleHQsIG51bGwpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGNlbGwgcmVuZGVyZXIgd2l0aCB0aGUgc3BlY2lmaWVkIGljb24uCi0JICovCi0JcHVibGljIENoZWNrQm94VGFibGVDZWxsUmVuZGVyZXIoSWNvbiBpY29uKSB7Ci0JCXRoaXMobnVsbCwgaWNvbik7Ci0JfQotCi0JcHJvdGVjdGVkIEpDaGVja0JveCBidWlsZENoZWNrQm94KCkgewotCQlKQ2hlY2tCb3ggY2IgPSBuZXcgSkNoZWNrQm94KCk7Ci0JCWNiLmFkZEFjdGlvbkxpc3RlbmVyKHRoaXMuYnVpbGRBY3Rpb25MaXN0ZW5lcigpKTsKLQkJcmV0dXJuIGNiOwotCX0KLQkKLQlwcml2YXRlIEFjdGlvbkxpc3RlbmVyIGJ1aWxkQWN0aW9uTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgQWN0aW9uTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZSkgewotCQkJCWlmIChDaGVja0JveFRhYmxlQ2VsbFJlbmRlcmVyLnRoaXMuaW1tZWRpYXRlRWRpdExpc3RlbmVyICE9IG51bGwpIHsKLQkJCQkJQ2hlY2tCb3hUYWJsZUNlbGxSZW5kZXJlci50aGlzLmltbWVkaWF0ZUVkaXRMaXN0ZW5lci5pbW1lZGlhdGVFZGl0KCk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBUYWJsZUNlbGxSZW5kZXJlciBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgQ29tcG9uZW50IGdldFRhYmxlQ2VsbFJlbmRlcmVyQ29tcG9uZW50KEpUYWJsZSB0YWJsZSwgT2JqZWN0IHZhbHVlLCBib29sZWFuIHNlbGVjdGVkLCBib29sZWFuIGhhc0ZvY3VzLCBpbnQgcm93LCBpbnQgY29sdW1uKSB7Ci0JICAgIHRoaXMuY2hlY2tCb3guc2V0SG9yaXpvbnRhbEFsaWdubWVudChTd2luZ0NvbnN0YW50cy5DRU5URVIpOwotCQl0aGlzLmNoZWNrQm94LnNldENvbXBvbmVudE9yaWVudGF0aW9uKHRhYmxlLmdldENvbXBvbmVudE9yaWVudGF0aW9uKCkpOwotCQl0aGlzLmNoZWNrQm94LnNldEZvbnQodGFibGUuZ2V0Rm9udCgpKTsKLQkJdGhpcy5jaGVja0JveC5zZXRFbmFibGVkKHRhYmxlLmlzRW5hYmxlZCgpKTsKLQotCQl0aGlzLmNoZWNrQm94LnNldEZvcmVncm91bmQodGhpcy5mb3JlZ3JvdW5kQ29sb3IodGFibGUsIHZhbHVlLCBzZWxlY3RlZCwgaGFzRm9jdXMsIHJvdywgY29sdW1uKSk7Ci0JCXRoaXMuY2hlY2tCb3guc2V0QmFja2dyb3VuZCh0aGlzLmJhY2tncm91bmRDb2xvcih0YWJsZSwgdmFsdWUsIHNlbGVjdGVkLCBoYXNGb2N1cywgcm93LCBjb2x1bW4pKTsKLQkJLy8gb25jZSB0aGUgY29sb3JzIGFyZSBzZXQsIGNhbGN1bGF0ZSBvcGFxdWUgc2V0dGluZwotCQl0aGlzLmNoZWNrQm94LnNldE9wYXF1ZSh0aGlzLmNlbGxJc09wYXF1ZUluKHRhYmxlLCB2YWx1ZSwgc2VsZWN0ZWQsIGhhc0ZvY3VzLCByb3csIGNvbHVtbikpOwotCQl0aGlzLmNoZWNrQm94LnNldEJvcmRlcih0aGlzLmJvcmRlcih0YWJsZSwgdmFsdWUsIHNlbGVjdGVkLCBoYXNGb2N1cywgcm93LCBjb2x1bW4pKTsKLQotCQl0aGlzLnNldFZhbHVlKHZhbHVlKTsKLQkJcmV0dXJuIHRoaXMuY2hlY2tCb3g7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjZWxsJ3MgZm9yZWdyb3VuZCBjb2xvci4KLQkgKi8KLQlwcm90ZWN0ZWQgQ29sb3IgZm9yZWdyb3VuZENvbG9yKEpUYWJsZSB0YWJsZSwgT2JqZWN0IHZhbHVlLCBib29sZWFuIHNlbGVjdGVkLCBib29sZWFuIGhhc0ZvY3VzLCBpbnQgcm93LCBpbnQgY29sdW1uKSB7Ci0JCWlmIChzZWxlY3RlZCkgewotCQkJaWYgKGhhc0ZvY3VzICYmIHRhYmxlLmlzQ2VsbEVkaXRhYmxlKHJvdywgY29sdW1uKSkgewotCQkJCXJldHVybiBVSU1hbmFnZXIuZ2V0Q29sb3IoIlRhYmxlLmZvY3VzQ2VsbEZvcmVncm91bmQiKTsKLQkJCX0KLQkJCXJldHVybiB0YWJsZS5nZXRTZWxlY3Rpb25Gb3JlZ3JvdW5kKCk7Ci0JCX0KLQkJcmV0dXJuIHRhYmxlLmdldEZvcmVncm91bmQoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNlbGwncyBiYWNrZ3JvdW5kIGNvbG9yLgotCSAqLwotCXByb3RlY3RlZCBDb2xvciBiYWNrZ3JvdW5kQ29sb3IoSlRhYmxlIHRhYmxlLCBPYmplY3QgdmFsdWUsIGJvb2xlYW4gc2VsZWN0ZWQsIGJvb2xlYW4gaGFzRm9jdXMsIGludCByb3csIGludCBjb2x1bW4pIHsKLQkJaWYgKHNlbGVjdGVkKSB7Ci0JCQlpZiAoaGFzRm9jdXMgJiYgdGFibGUuaXNDZWxsRWRpdGFibGUocm93LCBjb2x1bW4pKSB7Ci0JCQkJcmV0dXJuIFVJTWFuYWdlci5nZXRDb2xvcigiVGFibGUuZm9jdXNDZWxsQmFja2dyb3VuZCIpOwotCQkJfQotCQkJcmV0dXJuIHRhYmxlLmdldFNlbGVjdGlvbkJhY2tncm91bmQoKTsKLQkJfQotCQlyZXR1cm4gdGFibGUuZ2V0QmFja2dyb3VuZCgpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgY2VsbCdzIGJvcmRlci4KLQkgKi8KLQlwcm90ZWN0ZWQgQm9yZGVyIGJvcmRlcihKVGFibGUgdGFibGUsIE9iamVjdCB2YWx1ZSwgYm9vbGVhbiBzZWxlY3RlZCwgYm9vbGVhbiBoYXNGb2N1cywgaW50IHJvdywgaW50IGNvbHVtbikgewotCQlyZXR1cm4gaGFzRm9jdXMgPyAgVUlNYW5hZ2VyLmdldEJvcmRlcigiVGFibGUuZm9jdXNDZWxsSGlnaGxpZ2h0Qm9yZGVyIikgOiBOT19GT0NVU19CT1JERVI7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIGNlbGwgc2hvdWxkIGJlIG9wYXF1ZSBpbiB0aGUgdGFibGUuCi0JICogSWYgdGhlIGNlbGwncyBiYWNrZ3JvdW5kIGlzIHRoZSBzYW1lIGFzIHRoZSB0YWJsZSdzIGJhY2tncm91bmQKLQkgKiBhbmQgdGFibGUgaXMgb3BhcXVlLCB3ZSBkb24ndCBuZWVkIHRvIHBhaW50IHRoZSBiYWNrZ3JvdW5kIC0KLQkgKiB0aGUgdGFibGUgd2lsbCBkbyBpdC4KLQkgKi8KLQlwcm90ZWN0ZWQgYm9vbGVhbiBjZWxsSXNPcGFxdWVJbihKVGFibGUgdGFibGUsIE9iamVjdCB2YWx1ZSwgYm9vbGVhbiBzZWxlY3RlZCwgYm9vbGVhbiBoYXNGb2N1cywgaW50IHJvdywgaW50IGNvbHVtbikgewotCQlDb2xvciBjZWxsQmFja2dyb3VuZCA9IHRoaXMuY2hlY2tCb3guZ2V0QmFja2dyb3VuZCgpOwotCQlDb2xvciB0YWJsZUJhY2tncm91bmQgPSB0YWJsZS5nZXRCYWNrZ3JvdW5kKCk7Ci0JCXJldHVybiAhICh0YWJsZS5pc09wYXF1ZSgpICYmIGNlbGxCYWNrZ3JvdW5kLmVxdWFscyh0YWJsZUJhY2tncm91bmQpKTsKLQl9Ci0KLQkvKioKLQkgKiBTZXQgdGhlIGNoZWNrIGJveCdzIHZhbHVlLgotCSAqLwotCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlKE9iamVjdCB2YWx1ZSkgewotCQkvLyBDUiMzOTk5MzE4IC0gVGhpcyBudWxsIGNoZWNrIG5lZWRzIHRvIGJlIHJlbW92ZWQgb25jZSBKREsgYnVnIGlzIGZpeGVkCi0JCWlmICh2YWx1ZSA9PSBudWxsKSB7Ci0JCQl2YWx1ZSA9IEJvb2xlYW4uRkFMU0U7Ci0JCX0KLQkJdGhpcy5jaGVja0JveC5zZXRTZWxlY3RlZCgoKEJvb2xlYW4pIHZhbHVlKS5ib29sZWFuVmFsdWUoKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIFRhYmxlQ2VsbEVkaXRvckFkYXB0ZXIuUmVuZGVyZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIE9iamVjdCBnZXRWYWx1ZSgpIHsKLQkJcmV0dXJuIEJvb2xlYW4udmFsdWVPZih0aGlzLmNoZWNrQm94LmlzU2VsZWN0ZWQoKSk7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHNldEltbWVkaWF0ZUVkaXRMaXN0ZW5lcihJbW1lZGlhdGVFZGl0TGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJdGhpcy5pbW1lZGlhdGVFZGl0TGlzdGVuZXIgPSBsaXN0ZW5lcjsKLQl9Ci0KLQkvLyAqKioqKioqKioqIHB1YmxpYyBBUEkgKioqKioqKioqKgotCi0JLyoqCi0JICogU2V0IHRoZSBjaGVjayBib3gncyB0ZXh0OyB3aGljaCBieSBkZWZhdWx0IGlzIGJsYW5rLgotCSAqLwotCXB1YmxpYyB2b2lkIHNldFRleHQoU3RyaW5nIHRleHQpIHsKLQkJdGhpcy5jaGVja0JveC5zZXRUZXh0KHRleHQpOwotCX0KLQotCS8qKgotCSAqIFNldCB0aGUgY2hlY2sgYm94J3MgaWNvbjsgd2hpY2ggYnkgZGVmYXVsdCBpcyBub3QgcHJlc2VudC4KLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRJY29uKEljb24gaWNvbikgewotCQl0aGlzLmNoZWNrQm94LnNldEljb24oaWNvbik7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSByZW5kZXJlcidzIHByZWZlcnJlZCBoZWlnaHQuIFRoaXMgYWxsb3dzIHlvdQotCSAqIHRvIHNldCB0aGUgdGFibGUncyByb3cgaGVpZ2h0IHRvIHNvbWV0aGluZyB0aGUgY2hlY2sgYm94Ci0JICogd2lsbCBsb29rIGdvb2QgaW4uLi4uCi0JICovCi0JcHVibGljIGludCBwcmVmZXJyZWRIZWlnaHQoKSB7Ci0JCS8vIGFkZCBpbiBzcGFjZSBmb3IgdGhlIGJvcmRlciB0b3AgYW5kIGJvdHRvbQotCQlyZXR1cm4gKGludCkgdGhpcy5jaGVja0JveC5nZXRQcmVmZXJyZWRTaXplKCkuZ2V0SGVpZ2h0KCkgKyAyOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL0NvbWJvQm94VGFibGVDZWxsUmVuZGVyZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9Db21ib0JveFRhYmxlQ2VsbFJlbmRlcmVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDU1ZDhkMWYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL0NvbWJvQm94VGFibGVDZWxsUmVuZGVyZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDMyOCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLnN3aW5nOwotCi1pbXBvcnQgamF2YS5hd3QuQ29sb3I7Ci1pbXBvcnQgamF2YS5hd3QuQ29tcG9uZW50OwotaW1wb3J0IGphdmEuYXd0LkdyYXBoaWNzOwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LkFjdGlvbkV2ZW50OwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LkFjdGlvbkxpc3RlbmVyOwotaW1wb3J0IGphdmF4LnN3aW5nLkJvcmRlckZhY3Rvcnk7Ci1pbXBvcnQgamF2YXguc3dpbmcuQ29tYm9Cb3hNb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy5KQ29tYm9Cb3g7Ci1pbXBvcnQgamF2YXguc3dpbmcuSkxhYmVsOwotaW1wb3J0IGphdmF4LnN3aW5nLkpMaXN0OwotaW1wb3J0IGphdmF4LnN3aW5nLkpUYWJsZTsKLWltcG9ydCBqYXZheC5zd2luZy5MaXN0Q2VsbFJlbmRlcmVyOwotaW1wb3J0IGphdmF4LnN3aW5nLlN3aW5nQ29uc3RhbnRzOwotaW1wb3J0IGphdmF4LnN3aW5nLlVJTWFuYWdlcjsKLWltcG9ydCBqYXZheC5zd2luZy5ib3JkZXIuQm9yZGVyOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LlBvcHVwTWVudUV2ZW50OwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LlBvcHVwTWVudUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci0KLS8qKgotICogTWFrZSB0aGUgY2VsbCBsb29rIGxpa2UgYSBjb21iby1ib3guCi0gKi8KLXB1YmxpYyBjbGFzcyBDb21ib0JveFRhYmxlQ2VsbFJlbmRlcmVyIGltcGxlbWVudHMgVGFibGVDZWxsRWRpdG9yQWRhcHRlci5SZW5kZXJlciB7Ci0KLQkvKiBjYWNoaW5nIHRoZSBjb21ibyBib3ggYmVjYXVzZSB3ZSBhcmUgY2FjaGluZyB0aGUgY29tYm9Cb3hNb2RlbC4KLQkgKiBFdmVyeXRpbWUgd2UgcmVidWlsdCB0aGUgY29tYm9Cb3ggd2Ugd291bGQgc2V0IHRoZSBtb2RlbCBvbiBpdCBhbmQgbm90Ci0JICogcmVtb3ZlIHRoZSBtb2RlbCBmcm9tIHRoZSBvbGQgY29tYm8gYm94LiAgVGhpcyBtZWFudCB0aGF0IG5ldyBsaXN0ZW5lcnMKLQkgKiBrZXB0IGJlaW5nIGFkZGVkIHRvIHRoZSBjb21ib0JveE1vZGVsIGZvciBldmVyeSBjb21ib0JveCBidWlsZC4KLQkgKiBOb3Qgc3VyZSBpZiB0aGVyZSBpcyBhIHdheSB0byBjbGVhciBvdXQgdGhlIG9sZCBjb21ibyBib3gsIG9yIHdoeQotCSAqIHdlIHdlcmUgYnVpbGRpZyBhIG5ldyBjb21ibyBib3ggZXZlcnkgdGltZSBzbyBJIHdlbnQgd2l0aCBjYWNoaW5nIGl0LgotCSAqLwotCXByaXZhdGUgSkNvbWJvQm94IGNvbWJvQm94OwotCQotCS8qKiB0aGUgaXRlbXMgdXNlZCB0byBwb3B1bGF0ZSB0aGUgY29tYm8gYm94ICovCi0JcHJpdmF0ZSBDYWNoaW5nQ29tYm9Cb3hNb2RlbCBtb2RlbDsKLQlwcml2YXRlIExpc3RDZWxsUmVuZGVyZXIgcmVuZGVyZXI7Ci0JT2JqZWN0IHZhbHVlOwotCXByaXZhdGUgc3RhdGljIGludCBoZWlnaHQgPSAtMTsKLQlib29sZWFuIGZha2VGb2N1c0ZsYWc7Ci0KLQkvKiogdGhlIGxpc3RlbmVyIHRvIGJlIG5vdGlmaWVkIG9uIGFuIGltbWVkaWF0ZSBlZGl0ICovCi0JcHJvdGVjdGVkIFRhYmxlQ2VsbEVkaXRvckFkYXB0ZXIuSW1tZWRpYXRlRWRpdExpc3RlbmVyIGltbWVkaWF0ZUVkaXRMaXN0ZW5lcjsKLQkKLQkvKiogaG9sZCB0aGUgb3JpZ2luYWwgY29sb3JzIG9mIHRoZSBjb21iby1ib3ggKi8KLQlwcml2YXRlIHN0YXRpYyBDb2xvciBkZWZhdWx0Rm9yZWdyb3VuZDsKLQlwcml2YXRlIHN0YXRpYyBDb2xvciBkZWZhdWx0QmFja2dyb3VuZDsKLQotCS8qKiAibm9ybWFsIiBib3JkZXIgLSBhc3N1bWUgdGhlIGRlZmF1bHQgdGFibGUgImZvY3VzIiBib3JkZXIgaXMgMSBwaXhlbCB0aGljayAqLwotCXByaXZhdGUgc3RhdGljIGZpbmFsIEJvcmRlciBOT19GT0NVU19CT1JERVIgPSBCb3JkZXJGYWN0b3J5LmNyZWF0ZUVtcHR5Qm9yZGVyKDEsIDEsIDEsIDEpOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycy9pbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0KLQkvKioKLQkgKiBEZWZhdWx0IGNvbnN0cnVjdG9yLgotCSAqLwotCXByaXZhdGUgQ29tYm9Cb3hUYWJsZUNlbGxSZW5kZXJlcigpIHsKLQkJc3VwZXIoKTsKLQkJaW5pdGlhbGl6ZSgpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGNlbGwgcmVuZGVyZXIgdGhhdCB1c2VzIHRoZSBzcGVjaWZpZWQgY29tYm8tYm94IG1vZGVsLgotCSAqLwotCXB1YmxpYyBDb21ib0JveFRhYmxlQ2VsbFJlbmRlcmVyKENvbWJvQm94TW9kZWwgbW9kZWwpIHsKLQkJdGhpcyhuZXcgTm9uQ2FjaGluZ0NvbWJvQm94TW9kZWwobW9kZWwpKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29uc3RydWN0IGEgY2VsbCByZW5kZXJlciB0aGF0IHVzZXMgdGhlIHNwZWNpZmllZCBjYWNoaW5nIGNvbWJvLWJveCBtb2RlbC4KLQkgKi8KLQlwdWJsaWMgQ29tYm9Cb3hUYWJsZUNlbGxSZW5kZXJlcihDYWNoaW5nQ29tYm9Cb3hNb2RlbCBtb2RlbCkgewotCQl0aGlzKCk7Ci0JCXRoaXMubW9kZWwgPSBtb2RlbDsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBjZWxsIHJlbmRlcmVyIHRoYXQgdXNlcyB0aGUgc3BlY2lmaWVkCi0JICogY29tYm8tYm94IG1vZGVsIGFuZCByZW5kZXJlci4KLQkgKi8KLQlwdWJsaWMgQ29tYm9Cb3hUYWJsZUNlbGxSZW5kZXJlcihDb21ib0JveE1vZGVsIG1vZGVsLCBMaXN0Q2VsbFJlbmRlcmVyIHJlbmRlcmVyKSB7Ci0JCXRoaXMobmV3IE5vbkNhY2hpbmdDb21ib0JveE1vZGVsKG1vZGVsKSwgcmVuZGVyZXIpOwotCX0KLQkKLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBjZWxsIHJlbmRlcmVyIHRoYXQgdXNlcyB0aGUgc3BlY2lmaWVkCi0JICogY2FjaGluZyBjb21iby1ib3ggbW9kZWwgYW5kIHJlbmRlcmVyLgotCSAqLwotCXB1YmxpYyBDb21ib0JveFRhYmxlQ2VsbFJlbmRlcmVyKENhY2hpbmdDb21ib0JveE1vZGVsIG1vZGVsLCBMaXN0Q2VsbFJlbmRlcmVyIHJlbmRlcmVyKSB7Ci0JCXRoaXMobW9kZWwpOwotCQl0aGlzLnJlbmRlcmVyID0gcmVuZGVyZXI7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZSgpIHsKLQkJLy8gc2F2ZSB0aGUgb3JpZ2luYWwgY29sb3JzIG9mIHRoZSBjb21iby1ib3gsIHNvIHdlCi0JCS8vIGNhbiB1c2UgdGhlbSB0byBwYWludCBub24tc2VsZWN0ZWQgY2VsbHMKLQkJaWYgKGhlaWdodCA9PSAtMSkgewotCQkJSkNvbWJvQm94IGNiID0gbmV3IEpDb21ib0JveCgpOwotCQkJY2IuYWRkSXRlbSgibSIpOwotCi0JCQkvLyBhZGQgaW4gc3BhY2UgZm9yIHRoZSBib3JkZXIgdG9wIGFuZCBib3R0b20KLQkJCWhlaWdodCA9IGNiLmdldFByZWZlcnJlZFNpemUoKS5oZWlnaHQgKyAyOwotCi0JCQlkZWZhdWx0Rm9yZWdyb3VuZCA9IGNiLmdldEZvcmVncm91bmQoKTsKLQkJCWRlZmF1bHRCYWNrZ3JvdW5kID0gY2IuZ2V0QmFja2dyb3VuZCgpOwotCQl9Ci0JfQotCi0gICAgc3RhdGljIEpMYWJlbCBwcm90b3R5cGVMYWJlbCA9IG5ldyBKTGFiZWwoIlByb3RvdHlwZSIsIG5ldyBFbXB0eUljb24oMTYpLCBTd2luZ0NvbnN0YW50cy5MRUFESU5HKTsKLQotICAgIHByb3RlY3RlZCBKQ29tYm9Cb3ggYnVpbGRDb21ib0JveCgpIHsKLQotCQlmaW5hbCBKQ29tYm9Cb3ggcmVzdWx0ID0gbmV3IEpDb21ib0JveCgpIHsKLQkJCXByaXZhdGUgYm9vbGVhbiBmYWtlRm9jdXM7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBib29sZWFuIGhhc0ZvY3VzKCkgewotCQkJCXJldHVybiBmYWtlRm9jdXMgfHwgc3VwZXIuaGFzRm9jdXMoKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgcGFpbnQoR3JhcGhpY3MgZykgewotCQkJCWZha2VGb2N1cyA9IENvbWJvQm94VGFibGVDZWxsUmVuZGVyZXIudGhpcy5mYWtlRm9jdXNGbGFnOwotCQkJCXN1cGVyLnBhaW50KGcpOwotCQkJCWZha2VGb2N1cyA9IGZhbHNlOwotCQkJfQotCQkJLy93cmFwIHRoZSByZW5kZXJlciB0byBkZWFsIHdpdGggdGhlIHByb3RvdHlwZURpc3BsYXlWYWx1ZQotCQkgICAgQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBzZXRSZW5kZXJlcihmaW5hbCBMaXN0Q2VsbFJlbmRlcmVyIGFSZW5kZXJlcikgewotCQkgICAgICAgIHN1cGVyLnNldFJlbmRlcmVyKG5ldyBMaXN0Q2VsbFJlbmRlcmVyKCl7Ci0JCSAgICAgICAgICAgIHB1YmxpYyBDb21wb25lbnQgZ2V0TGlzdENlbGxSZW5kZXJlckNvbXBvbmVudChKTGlzdCBsaXN0LCBPYmplY3QgdiwgaW50IGluZGV4LCBib29sZWFuIGlzU2VsZWN0ZWQsIGJvb2xlYW4gY2VsbEhhc0ZvY3VzKSB7Ci0JCSAgICAgICAgICAgICAgICBpZiAodiA9PSBwcm90b3R5cGVMYWJlbCkgewotCQkgICAgICAgICAgICAgICAgICAgIHJldHVybiBwcm90b3R5cGVMYWJlbDsKLQkJICAgICAgICAgICAgICAgIH0KLQkJICAgICAgICAgICAgICAgIHJldHVybiBhUmVuZGVyZXIuZ2V0TGlzdENlbGxSZW5kZXJlckNvbXBvbmVudChsaXN0LCB2LCBpbmRleCwgaXNTZWxlY3RlZCwgY2VsbEhhc0ZvY3VzKTsKLQkJICAgICAgICAgICAgfQotCQkgICAgICAgIH0pOwotCQkgICAgfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgaW50IGdldFNlbGVjdGVkSW5kZXgoKSB7Ci0JCSAgICAgICAgYm9vbGVhbiBsaXN0Tm90Q2FjaGVkID0gIWxpc3RJc0NhY2hlZCgpOwotCQkgICAgICAgIGlmIChsaXN0Tm90Q2FjaGVkKSB7Ci0JCSAgICAgICAgICAgIGNhY2hlTGlzdCgpOwotCQkgICAgICAgIH0KLQkJICAgICAgICAKLQkJCQlpbnQgaW5kZXggPSBzdXBlci5nZXRTZWxlY3RlZEluZGV4KCk7Ci0KLQkJICAgICAgICBpZiAobGlzdE5vdENhY2hlZCkgewotCQkgICAgICAgICAgICB1bmNhY2hlTGlzdCgpOwotCQkgICAgICAgIH0KLQkJCQlyZXR1cm4gaW5kZXg7Ci0JCSAgIH0KLQotCQl9OwotCQkvLyBzdG9sZSB0aGlzIGNvZGUgZnJvbSBqYXZheC5zd2luZy5EZWZhdWx0Q2VsbEVkaXRvcgotCQlyZXN1bHQucHV0Q2xpZW50UHJvcGVydHkoIkpDb21ib0JveC5pc1RhYmxlQ2VsbEVkaXRvciIsIEJvb2xlYW4uVFJVRSk7Ci0JCXJlc3VsdC5hZGRBY3Rpb25MaXN0ZW5lcih0aGlzLmJ1aWxkQWN0aW9uTGlzdGVuZXIoKSk7Ci0JCXJlc3VsdC5hZGRQb3B1cE1lbnVMaXN0ZW5lcih0aGlzLmJ1aWxkUG9wdXBNZW51TGlzdGVuZXIoKSk7Ci0JCQotICAgICAgICAvL1RoZXNlIGFyZSB1c2VkIHRvIHdvcmthcm91bmQgcHJvYmxlbXMgd2l0aCBTd2luZyB0cnlpbmcgdG8gCi0gICAgICAgIC8vZGV0ZXJtaW5lIHRoZSBzaXplIG9mIGEgY29tYm9Cb3ggd2l0aCBhIGxhcmdlIG1vZGVsCi0gICAgICAgIHJlc3VsdC5zZXRQcm90b3R5cGVEaXNwbGF5VmFsdWUocHJvdG90eXBlTGFiZWwpOwotICAgICAgICBnZXRMaXN0Qm94KHJlc3VsdCkuc2V0UHJvdG90eXBlQ2VsbFZhbHVlKHByb3RvdHlwZUxhYmVsKTsKLSAgICAgICAgCi0JCXJldHVybiByZXN1bHQ7Ci0JfQotCQotICAgIAotICAgIHByaXZhdGUgSkxpc3QgZ2V0TGlzdEJveChKQ29tYm9Cb3ggcmVzdWx0KSB7Ci0gICAgICAgIHJldHVybiAoSkxpc3QpIENsYXNzVG9vbHMuZmllbGRWYWx1ZShyZXN1bHQuZ2V0VUkoKSwgImxpc3RCb3giKTsKLSAgICB9Ci0KLQkKLQlwcml2YXRlIEFjdGlvbkxpc3RlbmVyIGJ1aWxkQWN0aW9uTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgQWN0aW9uTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZSkgewotCQkJCUpDb21ib0JveCBjYiA9IChKQ29tYm9Cb3gpIGUuZ2V0U291cmNlKCk7Ci0JCQkJT2JqZWN0IHNlbGVjdGVkSXRlbSA9IGNiLmdldFNlbGVjdGVkSXRlbSgpOwotCi0JCQkJLy8gT25seSB1cGRhdGUgdGhlIHNlbGVjdGVkIGl0ZW0gYW5kIGludm9rZSBpbW1lZGlhdGVFZGl0KCkgaWYgdGhlCi0JCQkJLy8gc2VsZWN0ZWQgaXRlbSBhY3R1YWxseSBjaGFuZ2VkLCBkdXJpbmcgdGhlIGluaXRpYWxpemF0aW9uIG9mIHRoZQotCQkJCS8vIGVkaXRpbmcsIHRoZSBtb2RlbCBjaGFuZ2VzIGFuZCBjYXVzZXMgdGhpcyBtZXRob2QgdG8gYmUgaW52b2tlZCwKLQkJCQkvLyBpdCBjYXVzZXMgQ1IjMzk2MzY3NSB0byBvY2N1ciBiZWNhdXNlIGltbWVkaWF0ZUVkaXQoKSBzdG9wIHRoZQotCQkJCS8vIGVkaXRpbmcsIHdoaWNoIGlzIGRvbmUgYXQgdGhlIHdyb25nIHRpbWUKLQkJCQlpZiAoQ29tYm9Cb3hUYWJsZUNlbGxSZW5kZXJlci50aGlzLnZhbHVlICE9IHNlbGVjdGVkSXRlbSkgewotCQkJCQlDb21ib0JveFRhYmxlQ2VsbFJlbmRlcmVyLnRoaXMudmFsdWUgPSBjYi5nZXRTZWxlY3RlZEl0ZW0oKTsKLQkJCQkJQ29tYm9Cb3hUYWJsZUNlbGxSZW5kZXJlci50aGlzLmltbWVkaWF0ZUVkaXQoKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCi0Jdm9pZCBpbW1lZGlhdGVFZGl0KCkgewotCQlpZiAodGhpcy5pbW1lZGlhdGVFZGl0TGlzdGVuZXIgIT0gbnVsbCkgewotCQkJdGhpcy5pbW1lZGlhdGVFZGl0TGlzdGVuZXIuaW1tZWRpYXRlRWRpdCgpOwotCQl9Ci0JfQotCQotCXByaXZhdGUgUG9wdXBNZW51TGlzdGVuZXIgYnVpbGRQb3B1cE1lbnVMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBQb3B1cE1lbnVMaXN0ZW5lcigpIHsKLQkJCi0JCQlwdWJsaWMgdm9pZCBwb3B1cE1lbnVXaWxsQmVjb21lVmlzaWJsZShQb3B1cE1lbnVFdmVudCBlKSB7Ci0JCQkJaWYgKGxpc3RJc0NhY2hlZCgpKSB7Ci0JCQkJCXVuY2FjaGVMaXN0KCk7Ci0JCQkJfQotCQkJCWNhY2hlTGlzdCgpOwotCQkJfQotCQkKLQkJCXB1YmxpYyB2b2lkIHBvcHVwTWVudVdpbGxCZWNvbWVJbnZpc2libGUoUG9wdXBNZW51RXZlbnQgZSkgewotCSAgICAgICAgICAgIGlmIChsaXN0SXNDYWNoZWQoKSkgewotCSAgICAgICAgICAgICAgICB1bmNhY2hlTGlzdCgpOwotCSAgICAgICAgICAgIH0KLQotCQkJfQotCQkKLQkJCXB1YmxpYyB2b2lkIHBvcHVwTWVudUNhbmNlbGVkKFBvcHVwTWVudUV2ZW50IGUpIHsKLQkgICAgICAgICAgICBpZiAobGlzdElzQ2FjaGVkKCkpIHsKLQkgICAgICAgICAgICAgICAgdW5jYWNoZUxpc3QoKTsKLQkgICAgICAgICAgICB9Ci0JCQl9Ci0JCX07Ci0JfQotCi0JCi0Jdm9pZCBjYWNoZUxpc3QoKSB7Ci0JCXRoaXMubW9kZWwuY2FjaGVMaXN0KCk7Ci0JfQotCQotCXZvaWQgdW5jYWNoZUxpc3QoKSB7Ci0JCXRoaXMubW9kZWwudW5jYWNoZUxpc3QoKTsKLQl9CQotCQotCWJvb2xlYW4gbGlzdElzQ2FjaGVkKCkgewotCQlyZXR1cm4gdGhpcy5tb2RlbC5pc0NhY2hlZCgpOwotCX0KLQkvLyAqKioqKioqKioqIFRhYmxlQ2VsbFJlbmRlcmVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBDb21wb25lbnQgZ2V0VGFibGVDZWxsUmVuZGVyZXJDb21wb25lbnQoSlRhYmxlIHRhYmxlLCBPYmplY3QgdmFsLCBib29sZWFuIHNlbGVjdGVkLCBib29sZWFuIGhhc0ZvY3VzLCBpbnQgcm93LCBpbnQgY29sdW1uKSB7Ci0JCXRoaXMuZmFrZUZvY3VzRmxhZyA9IHNlbGVjdGVkIHx8IGhhc0ZvY3VzOwotCQlpZiAodGhpcy5jb21ib0JveCA9PSBudWxsKSB7Ci0JCQl0aGlzLmNvbWJvQm94ID0gdGhpcy5idWlsZENvbWJvQm94KCk7Ci0JCi0JCQl0aGlzLmNvbWJvQm94LnNldENvbXBvbmVudE9yaWVudGF0aW9uKHRhYmxlLmdldENvbXBvbmVudE9yaWVudGF0aW9uKCkpOwotCQkJdGhpcy5jb21ib0JveC5zZXRNb2RlbCh0aGlzLm1vZGVsKTsKLQkJCWlmICh0aGlzLnJlbmRlcmVyICE9IG51bGwpIHsKLQkJCQl0aGlzLmNvbWJvQm94LnNldFJlbmRlcmVyKHRoaXMucmVuZGVyZXIpOwotCQkJfQotCQkJdGhpcy5jb21ib0JveC5zZXRGb250KHRhYmxlLmdldEZvbnQoKSk7Ci0JCQl0aGlzLmNvbWJvQm94LnNldEVuYWJsZWQodGFibGUuaXNFbmFibGVkKCkpOwotCQkJdGhpcy5jb21ib0JveC5zZXRCb3JkZXIodGhpcy5ib3JkZXIodGFibGUsIHZhbCwgc2VsZWN0ZWQsIGhhc0ZvY3VzLCByb3csIGNvbHVtbikpOwotCQl9Ci0KLQkJLy8gV2UgbmVlZCB0byBnbyB0aHJvdWdoIHRoZSBtb2RlbCBzaW5jZSBKQ29tYm9Cb3ggbWlnaHQgcHJldmVudCB1cyBmcm9tCi0JCS8vIHNlbGVjdGluZyB0aGUgdmFsdWUuIFRoaXMgY2FuIGhhcHBlbiB3aGVuIHRoZSB2YWx1ZSBpcyBub3QgY29udGFpbmVkCi0JCS8vIGluIHRoZSBtb2RlbCwgc2VlIENSIzM5NTAwNDQgZm9yIGFuIGV4YW1wbGUKLQkJdGhpcy5tb2RlbC5zZXRTZWxlY3RlZEl0ZW0odmFsKTsKLQotCQlyZXR1cm4gdGhpcy5jb21ib0JveDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNlbGwncyBmb3JlZ3JvdW5kIGNvbG9yLgotCSAqLwotCXByb3RlY3RlZCBDb2xvciBmb3JlZ3JvdW5kQ29sb3IoSlRhYmxlIHRhYmxlLCBPYmplY3QgdmFsLCBib29sZWFuIHNlbGVjdGVkLCBib29sZWFuIGhhc0ZvY3VzLCBpbnQgcm93LCBpbnQgY29sdW1uKSB7Ci0JCWlmIChzZWxlY3RlZCkgewotCQkJaWYgKGhhc0ZvY3VzICYmIHRhYmxlLmlzQ2VsbEVkaXRhYmxlKHJvdywgY29sdW1uKSkgewotCQkJCXJldHVybiBkZWZhdWx0Rm9yZWdyb3VuZDsKLQkJCX0KLQkJCXJldHVybiB0YWJsZS5nZXRTZWxlY3Rpb25Gb3JlZ3JvdW5kKCk7Ci0JCX0KLQkJcmV0dXJuIGRlZmF1bHRGb3JlZ3JvdW5kOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgY2VsbCdzIGJhY2tncm91bmQgY29sb3IuCi0JICovCi0JcHJvdGVjdGVkIENvbG9yIGJhY2tncm91bmRDb2xvcihKVGFibGUgdGFibGUsIE9iamVjdCB2YWwsIGJvb2xlYW4gc2VsZWN0ZWQsIGJvb2xlYW4gaGFzRm9jdXMsIGludCByb3csIGludCBjb2x1bW4pIHsKLQkJaWYgKHNlbGVjdGVkKSB7Ci0JCQlpZiAoaGFzRm9jdXMgJiYgdGFibGUuaXNDZWxsRWRpdGFibGUocm93LCBjb2x1bW4pKSB7Ci0JCQkJcmV0dXJuIGRlZmF1bHRCYWNrZ3JvdW5kOwotCQkJfQotCQkJcmV0dXJuIHRhYmxlLmdldFNlbGVjdGlvbkJhY2tncm91bmQoKTsKLQkJfQotCQlyZXR1cm4gZGVmYXVsdEJhY2tncm91bmQ7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjZWxsJ3MgYm9yZGVyLgotCSAqLwotCXByb3RlY3RlZCBCb3JkZXIgYm9yZGVyKEpUYWJsZSB0YWJsZSwgT2JqZWN0IHZhbCwgYm9vbGVhbiBzZWxlY3RlZCwgYm9vbGVhbiBoYXNGb2N1cywgaW50IHJvdywgaW50IGNvbHVtbikgewotCQlyZXR1cm4gaGFzRm9jdXMgPwotCQkJVUlNYW5hZ2VyLmdldEJvcmRlcigiVGFibGUuZm9jdXNDZWxsSGlnaGxpZ2h0Qm9yZGVyIikKLQkJOgotCQkJTk9fRk9DVVNfQk9SREVSOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBUYWJsZUNlbGxFZGl0b3JBZGFwdGVyLlJlbmRlcmVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBPYmplY3QgZ2V0VmFsdWUoKSB7Ci0JCXJldHVybiB0aGlzLnZhbHVlOwotCX0KLQkKLQlwdWJsaWMgdm9pZCBzZXRJbW1lZGlhdGVFZGl0TGlzdGVuZXIoVGFibGVDZWxsRWRpdG9yQWRhcHRlci5JbW1lZGlhdGVFZGl0TGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJdGhpcy5pbW1lZGlhdGVFZGl0TGlzdGVuZXIgPSBsaXN0ZW5lcjsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogcHVibGljIEFQSSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHJlbmRlcmVyJ3MgcHJlZmVycmVkIGhlaWdodC4gVGhpcyBhbGxvd3MgeW91Ci0JICogdG8gc2V0IHRoZSByb3cgaGVpZ2h0IHRvIHNvbWV0aGluZyB0aGUgY29tYm8tYm94IHdpbGwgbG9vayBnb29kIGluLi4uLgotCSAqLwotCXB1YmxpYyBpbnQgcHJlZmVycmVkSGVpZ2h0KCkgewotCQlyZXR1cm4gaGVpZ2h0OwotCX0KLQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9EaXNwbGF5YWJsZS5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL0Rpc3BsYXlhYmxlLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGY1MTQ5Y2YuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL0Rpc3BsYXlhYmxlLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw5MyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLnN3aW5nOwotCi1pbXBvcnQgamF2YS50ZXh0LkNvbGxhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Db21wYXJhdG9yOwotaW1wb3J0IGphdmF4LnN3aW5nLkljb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci0KLS8qKgotICogVXNlZCBieSBnZW5lcmFsLXB1cnBvc2UgVUkgbW9kZWxzIGFuZCByZW5kZXJlcnMgdG8gY2FzdAotICogYXBwbGljYXRpb24gbW9kZWwgb2JqZWN0cyB0byBzb21ldGhpbmcgZGlzcGxheWFibGUuCi0gKi8KLXB1YmxpYyBpbnRlcmZhY2UgRGlzcGxheWFibGUKLQlleHRlbmRzIE1vZGVsLCBDb21wYXJhYmxlPERpc3BsYXlhYmxlPgotewotCi0JLyoqCi0JICogUmV0dXJuIGEgc3RyaW5nIHRoYXQgY2FuIGJlIHVzZWQgdG8gaWRlbnRpZnkgdGhlIG1vZGVsCi0JICogaW4gYSB0ZXh0dWFsIFVJIHNldHRpbmcgKHR5cGljYWxseSB0aGUgb2JqZWN0J3MgbmFtZSkuCi0JICogV2hlbiB0aGUgZGlzcGxheSBzdHJpbmcgY2hhbmdlcywgdGhlIG1vZGVsIHNob3VsZCBmaXJlCi0JICogdGhlIGFwcHJvcHJpYXRlIGNoYW5nZSBub3RpZmljYXRpb246Ci0JICogICAgIHRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChESVNQTEFZX1NUUklOR19QUk9QRVJUWSwgb2xkRGlzcGxheVN0cmluZywgdGhpcy5kaXNwbGF5U3RyaW5nKCkpOwotCSAqLwotCVN0cmluZyBkaXNwbGF5U3RyaW5nKCk7Ci0JCVN0cmluZyBESVNQTEFZX1NUUklOR19QUk9QRVJUWSA9ICJkaXNwbGF5U3RyaW5nIjsKLQotCS8qKgotCSAqIFJldHVybiBhbiBpY29uIHRoYXQgY2FuIGJlIHVzZWQgdG8gaWRlbnRpZnkgdGhlIG1vZGVsCi0JICogaW4gYSBVSSBjb21wb25lbnQgdGhhdCBzdXBwb3J0cyBpY29ucyAodGhlIGljb24gY2FuIGJlIG51bGwpLgotCSAqIFdoZW4gdGhlIGljb24gY2hhbmdlcywgdGhlIG1vZGVsIHNob3VsZCBmaXJlCi0JICogdGhlIGFwcHJvcHJpYXRlIGNoYW5nZSBub3RpZmljYXRpb246Ci0JICogICAgIHRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChJQ09OX1BST1BFUlRZLCBvbGRJY29uLCB0aGlzLmljb24oKSk7Ci0JICovCi0JSWNvbiBpY29uKCk7Ci0JCVN0cmluZyBJQ09OX1BST1BFUlRZID0gImljb24iOwotCi0KLQkvLyAqKioqKioqKioqIGhlbHBlciBpbXBsZW1lbnRhdGlvbnMgKioqKioqKioqKgotCi0JQ29sbGF0b3IgREVGQVVMVF9DT0xMQVRPUiA9IENvbGxhdG9yLmdldEluc3RhbmNlKCk7Ci0KLQkvKioKLQkgKiBTaW5jZSBhbGwgZGlzcGxheWFibGUgb2JqZWN0cyBtdXN0IGJlIGNvbXBhcmFibGUsIHByb3ZpZGUgYQotCSAqIHR5cGljYWwgY29tcGFyYXRvciB0aGF0IGNhbiBiZSB1c2VkIHRvIHNvcnQgYSBjb2xsZWN0aW9uIG9mCi0JICogZGlzcGxheWFibGUgb2JqZWN0cy4KLQkgKiBTb3J0IGJhc2VkIG9uIGRpc3BsYXkgc3RyaW5nOgotCSAqICAgICAtIGlkZW50aWNhbCBvYmplY3RzIGFyZSBlcXVhbCAod2hpY2ggbWVhbnMgdGhleSBjYW5ub3QKLQkgKiAgICAgICAgIGNvLWV4aXN0IGluIGEgU29ydGVkU2V0KQotCSAqICAgICAtIHVzZSB0aGUgZGVmYXVsdCBjb2xsYXRvciAod2hpY2ggdHlwaWNhbGx5IGludGVybGVhdmVzCi0JICogICAgICAgICBsb3dlci0gYW5kIHVwcGVyLWNhc2UgbGV0dGVycykKLQkgKiAgICAgLSBhbGxvdyBkdXBsaWNhdGUgZGlzcGxheSBzdHJpbmdzIChmcm9tIGRpZmZlcmVudCBvYmplY3RzKQotCSAqICAgICAtIHRyeSB0byByZXR1cm4gY29uc2lzdGVudCByZXN1bHRzIGZvciBzYW1lIG9iamVjdCBwYWlycwotCSAqLwotCUNvbXBhcmF0b3I8RGlzcGxheWFibGU+IERFRkFVTFRfQ09NUEFSQVRPUiA9Ci0JCW5ldyBDb21wYXJhdG9yPERpc3BsYXlhYmxlPigpIHsKLQkJCXB1YmxpYyBpbnQgY29tcGFyZShEaXNwbGF5YWJsZSBkMSwgRGlzcGxheWFibGUgZDIpIHsKLQkJCQkvLyBkaXNhbGxvdyBkdXBsaWNhdGVzIGJhc2VkIG9uIG9iamVjdCBpZGVudGl0eQotCQkJCWlmIChkMSA9PSBkMikgewotCQkJCQlyZXR1cm4gMDsKLQkJCQl9Ci0KLQkJCQkvLyBmaXJzdCBjb21wYXJlIGRpc3BsYXkgc3RyaW5ncyB1c2luZyB0aGUgZGVmYXVsdCBjb2xsYXRvcgotCQkJCWludCByZXN1bHQgPSBERUZBVUxUX0NPTExBVE9SLmNvbXBhcmUoZDEuZGlzcGxheVN0cmluZygpLCBkMi5kaXNwbGF5U3RyaW5nKCkpOwotCQkJCWlmIChyZXN1bHQgIT0gMCkgewotCQkJCQlyZXR1cm4gcmVzdWx0OwotCQkJCX0KLQotCQkJCS8vIHRoZW4gY29tcGFyZSB1c2luZyBvYmplY3QtaWQKLQkJCQlyZXN1bHQgPSBTeXN0ZW0uaWRlbnRpdHlIYXNoQ29kZShkMSkgLSBTeXN0ZW0uaWRlbnRpdHlIYXNoQ29kZShkMik7Ci0JCQkJaWYgKHJlc3VsdCAhPSAwKSB7Ci0JCQkJCXJldHVybiByZXN1bHQ7Ci0JCQkJfQotCi0JCQkJLy8gSXQncyB1bmxpa2VseSB0aGF0IHdlIGdldCB0byB0aGlzIHBvaW50OyBidXQsIGp1c3QgaW4gY2FzZSwgd2Ugd2lsbCByZXR1cm4gLTEuCi0JCQkJLy8gVW5mb3J0dW5hdGVseSwgdGhpcyBpbnRyb2R1Y2VzIHNvbWUgbWlsZCB1bnByZWRpY3RhYmlsaXR5IHRvIHRoZSBzb3J0IG9yZGVyCi0JCQkJLy8gKHVubGVzcyB0aGUgb2JqZWN0cyBhcmUgYWx3YXlzIHBhc3NlZCBpbnRvIHRoaXMgbWV0aG9kIGluIHRoZSBzYW1lIG9yZGVyKS4KLQkJCQlyZXR1cm4gLTE7CQkvLyBpZiBhbGwgZWxzZSBmYWlscywgaW5kaWNhdGUgdGhhdCBvMSA8IG8yCi0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJEaXNwbGF5YWJsZS5ERUZBVUxUX0NPTVBBUkFUT1IiOwotCQkJfQotCQl9OwotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvc3dpbmcvRW1wdHlJY29uLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvc3dpbmcvRW1wdHlJY29uLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDE0ODMwOGUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL0VtcHR5SWNvbi5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZzsKLQotaW1wb3J0IGphdmEuYXd0LkNvbXBvbmVudDsKLWltcG9ydCBqYXZhLmF3dC5HcmFwaGljczsKLWltcG9ydCBqYXZheC5zd2luZy5JY29uOwotCi0vKioKLSAqIEltcGxlbWVudCB0aGUgSWNvbiBpbnRlcmZhY2Ugd2l0aCBhbiBpY29uIHRoYXQgaGFzIGEgc2l6ZSBidXQKLSAqIGRvZXMgbm90IHBhaW50IGFueXRoaW5nIG9uIHRoZSBncmFwaGljcyBjb250ZXh0LgotICovCi1wdWJsaWMgY2xhc3MgRW1wdHlJY29uCi0JaW1wbGVtZW50cyBJY29uCi17Ci0JcHJpdmF0ZSBmaW5hbCBpbnQgd2lkdGg7Ci0JcHJpdmF0ZSBmaW5hbCBpbnQgaGVpZ2h0OwotCi0JcHVibGljIHN0YXRpYyBmaW5hbCBFbXB0eUljb24gTlVMTF9JTlNUQU5DRSA9IG5ldyBFbXB0eUljb24oMCk7Ci0KLQotCXB1YmxpYyBFbXB0eUljb24oaW50IHdpZHRoLCBpbnQgaGVpZ2h0KSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMud2lkdGggPSB3aWR0aDsKLQkJdGhpcy5oZWlnaHQgPSBoZWlnaHQ7Ci0JfQotCi0JcHVibGljIEVtcHR5SWNvbihpbnQgc2l6ZSkgewotCQl0aGlzKHNpemUsIHNpemUpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBJY29uIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIHBhaW50SWNvbihDb21wb25lbnQgYywgR3JhcGhpY3MgZywgaW50IHgsIGludCB5KSB7Ci0JCS8vIGRvbid0IHBhaW50IGFueXRoaW5nIGZvciBhbiBlbXB0eSBpY29uCi0JfQotCi0JcHVibGljIGludCBnZXRJY29uV2lkdGgoKSB7IAotCQlyZXR1cm4gdGhpcy53aWR0aDsKLQl9Ci0KLQlwdWJsaWMgaW50IGdldEljb25IZWlnaHQoKSB7Ci0JCXJldHVybiB0aGlzLmhlaWdodDsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9GaWx0ZXJpbmdMaXN0QnJvd3Nlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL0ZpbHRlcmluZ0xpc3RCcm93c2VyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQ1OWYzZTAuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL0ZpbHRlcmluZ0xpc3RCcm93c2VyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNDAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZzsKLQotaW1wb3J0IGphdmF4LnN3aW5nLkljb247Ci1pbXBvcnQgamF2YXguc3dpbmcuSkNvbWJvQm94OwotaW1wb3J0IGphdmF4LnN3aW5nLkpPcHRpb25QYW5lOwotaW1wb3J0IGphdmF4LnN3aW5nLkxpc3RNb2RlbDsKLQotLyoqCi0gKiBUaGlzIGltcGxlbWVudGF0aW9uIG9mIExvbmdMaXN0Q29tcG9uZW50LkJyb3dzZXIgdXNlcyBhCi0gKiBKT3B0aW9uUGFuZSB0byBwcm9tcHQgdGhlIHVzZXIgZm9yIHRoZSBzZWxlY3Rpb24uIFRoZSBKT1B0aW9uUGFuZQotICogaXMgcGFzc2VkIGEgRmlsdGVyaW5nTGlzdFBhbmVsIHRvIGFzc2lzdCB0aGUgdXNlciBpbiBtYWtpbmcKLSAqIGEgc2VsZWN0aW9uLgotICovCi1wdWJsaWMgY2xhc3MgRmlsdGVyaW5nTGlzdEJyb3dzZXI8VD4gCi0JaW1wbGVtZW50cyBMaXN0Q2hvb3Nlci5MaXN0QnJvd3NlciAKLXsKLQlwcml2YXRlIEZpbHRlcmluZ0xpc3RQYW5lbDxUPiBwYW5lbDsKLQotCS8qKgotCSAqIERlZmF1bHQgY29uc3RydWN0b3IuCi0JICovCi0JcHVibGljIEZpbHRlcmluZ0xpc3RCcm93c2VyKCkgewotCQlzdXBlcigpOwotCQl0aGlzLnBhbmVsID0gdGhpcy5idWlsZFBhbmVsKCk7Ci0JfQotCi0JcHJvdGVjdGVkIEZpbHRlcmluZ0xpc3RQYW5lbDxUPiBidWlsZFBhbmVsKCkgewotCQlyZXR1cm4gbmV3IExvY2FsRmlsdGVyaW5nTGlzdFBhbmVsPFQ+KCk7Ci0JfQotCi0JLyoqCi0JICogUHJvbXB0IHRoZSB1c2VyIHVzaW5nIGEgSk9wdGlvblBhbmUgd2l0aCBhIGZpbHRlcmluZwotCSAqIGxpc3QgcGFuZWwuCi0JICovCi0JcHVibGljIHZvaWQgYnJvd3NlKExpc3RDaG9vc2VyIGNob29zZXIpIHsJCi0JCXRoaXMuaW5pdGlhbGl6ZUNlbGxSZW5kZXJlcihjaG9vc2VyKTsKLQkJCi0JCWludCBvcHRpb24gPSAKLQkJCUpPcHRpb25QYW5lLnNob3dPcHRpb25EaWFsb2coCi0JCQkJY2hvb3NlciwgCi0JCQkJdGhpcy5tZXNzYWdlKGNob29zZXIpLCAKLQkJCQl0aGlzLnRpdGxlKGNob29zZXIpLCAKLQkJCQl0aGlzLm9wdGlvblR5cGUoY2hvb3NlciksIAotCQkJCXRoaXMubWVzc2FnZVR5cGUoY2hvb3NlciksIAotCQkJCXRoaXMuaWNvbihjaG9vc2VyKSwgCi0JCQkJdGhpcy5zZWxlY3Rpb25WYWx1ZXMoY2hvb3NlciksIAotCQkJCXRoaXMuaW5pdGlhbFNlbGVjdGlvblZhbHVlKGNob29zZXIpCi0JCSk7Ci0JCQotCQlpZiAob3B0aW9uID09IEpPcHRpb25QYW5lLk9LX09QVElPTikgewotCQkJY2hvb3Nlci5nZXRNb2RlbCgpLnNldFNlbGVjdGVkSXRlbSh0aGlzLnBhbmVsLnNlbGVjdGlvbigpKTsKLQkJfQotCQkKLQkJLy8gY2xlYXIgdGhlIHRleHQgZmllbGQgc28gdGhlIGxpc3QgYm94IGlzIHJlLWZpbHRlcmVkCi0JCXRoaXMucGFuZWwudGV4dEZpZWxkKCkuc2V0VGV4dCgiIik7Ci0JfQotCQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVDZWxsUmVuZGVyZXIoSkNvbWJvQm94IGNvbWJvQm94KSB7Ci0JCS8vIGRlZmF1bHQgYmVoYXZpb3Igc2hvdWxkIGJlIHRvIHVzZSB0aGUgY2VsbCByZW5kZXJlciBmcm9tIHRoZSBjb21ib2JveC4KLQkJdGhpcy5wYW5lbC5saXN0Qm94KCkuc2V0Q2VsbFJlbmRlcmVyKGNvbWJvQm94LmdldFJlbmRlcmVyKCkpOwotCX0KLQotCS8qKgotCSAqIHRoZSBtZXNzYWdlIGNhbiBiZSBhbnl0aGluZyAtIGhlcmUgd2UgYnVpbGQgYSBjb21wb25lbnQKLQkgKi8KLQlwcm90ZWN0ZWQgT2JqZWN0IG1lc3NhZ2UoSkNvbWJvQm94IGNvbWJvQm94KSB7Ci0JCXRoaXMucGFuZWwuc2V0Q29tcGxldGVMaXN0KHRoaXMuY29udmVydFRvQXJyYXkoY29tYm9Cb3guZ2V0TW9kZWwoKSkpOwotCQl0aGlzLnBhbmVsLnNldFNlbGVjdGlvbihjb21ib0JveC5nZXRNb2RlbCgpLmdldFNlbGVjdGVkSXRlbSgpKTsKLQkJcmV0dXJuIHRoaXMucGFuZWw7Ci0JfQotCi0JcHJvdGVjdGVkIFN0cmluZyB0aXRsZShKQ29tYm9Cb3ggY29tYm9Cb3gpIHsKLQkJcmV0dXJuIG51bGw7Ci0JfQotCi0JcHJvdGVjdGVkIGludCBvcHRpb25UeXBlKEpDb21ib0JveCBjb21ib0JveCkgewotCQlyZXR1cm4gSk9wdGlvblBhbmUuT0tfQ0FOQ0VMX09QVElPTjsKLQl9Ci0KLQlwcm90ZWN0ZWQgaW50IG1lc3NhZ2VUeXBlKEpDb21ib0JveCBjb21ib0JveCkgewotCQlyZXR1cm4gSk9wdGlvblBhbmUuUVVFU1RJT05fTUVTU0FHRTsKLQl9Ci0KLQlwcm90ZWN0ZWQgSWNvbiBpY29uKEpDb21ib0JveCBjb21ib0JveCkgewotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQlwcm90ZWN0ZWQgT2JqZWN0W10gc2VsZWN0aW9uVmFsdWVzKEpDb21ib0JveCBjb21ib0JveCkgewotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQlwcm90ZWN0ZWQgT2JqZWN0IGluaXRpYWxTZWxlY3Rpb25WYWx1ZShKQ29tYm9Cb3ggY29tYm9Cb3gpIHsKLQkJcmV0dXJuIG51bGw7Ci0JfQotCi0JLyoqCi0JICogQ29udmVydCB0aGUgbGlzdCBvZiBvYmplY3RzIGluIHRoZSBzcGVjaWZpZWQgbGlzdCBtb2RlbAotCSAqIGludG8gYW4gYXJyYXkuCi0JICovCi0JcHJvdGVjdGVkIE9iamVjdFtdIGNvbnZlcnRUb0FycmF5KExpc3RNb2RlbCBtb2RlbCkgewotCQlpbnQgc2l6ZSA9IG1vZGVsLmdldFNpemUoKTsKLQkJT2JqZWN0W10gcmVzdWx0ID0gbmV3IE9iamVjdFtzaXplXTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBzaXplOyBpKyspIHsKLQkJCXJlc3VsdFtpXSA9IG1vZGVsLmdldEVsZW1lbnRBdChpKTsKLQkJfQotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQkKLQkKLQkvLyAqKioqKioqKioqIGN1c3RvbSBwYW5lbCAqKioqKioqKioqCi0JCi0JcHJvdGVjdGVkIHN0YXRpYyBjbGFzcyBMb2NhbEZpbHRlcmluZ0xpc3RQYW5lbDxTPiBleHRlbmRzIEZpbHRlcmluZ0xpc3RQYW5lbDxTPiB7Ci0JCXByb3RlY3RlZCBzdGF0aWMgZmluYWwgT2JqZWN0W10gRU1QVFlfQVJSQVkgPSBuZXcgT2JqZWN0WzBdOwotCi0JCXByb3RlY3RlZCBMb2NhbEZpbHRlcmluZ0xpc3RQYW5lbCgpIHsKLQkJCXN1cGVyKEVNUFRZX0FSUkFZLCBudWxsKTsKLQkJfQotCQotCQkvKioKLQkJICogRGlzYWJsZSB0aGUgcGVyZm9ybWFuY2UgdHdlYWsgYmVjYXVzZSBKT3B0aW9uUGFuZQotCQkgKiB3aWxsIHRyeSBvcGVuIHdpZGUgZW5vdWdoIHRvIGRpc2FibGUgdGhlIGhvcml6b250YWwgc2Nyb2xsIGJhcjsKLQkJICogYW5kIGl0IGxvb2tzIGEgYml0IGNsdW1zeS4KLQkJICovCi0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgU3RyaW5nIHByb3RvdHlwZUNlbGxWYWx1ZSgpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvc3dpbmcvRmlsdGVyaW5nTGlzdFBhbmVsLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvc3dpbmcvRmlsdGVyaW5nTGlzdFBhbmVsLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZmMTdkZjMuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL0ZpbHRlcmluZ0xpc3RQYW5lbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDU1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuc3dpbmc7Ci0KLWltcG9ydCBqYXZhLmF3dC5Cb3JkZXJMYXlvdXQ7Ci1pbXBvcnQgamF2YS5hd3QuRm9udDsKLWltcG9ydCBqYXZheC5zd2luZy5BYnN0cmFjdExpc3RNb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy5Cb3JkZXJGYWN0b3J5OwotaW1wb3J0IGphdmF4LnN3aW5nLkpMYWJlbDsKLWltcG9ydCBqYXZheC5zd2luZy5KTGlzdDsKLWltcG9ydCBqYXZheC5zd2luZy5KUGFuZWw7Ci1pbXBvcnQgamF2YXguc3dpbmcuSlNjcm9sbFBhbmU7Ci1pbXBvcnQgamF2YXguc3dpbmcuSlRleHRGaWVsZDsKLWltcG9ydCBqYXZheC5zd2luZy5MaXN0Q2VsbFJlbmRlcmVyOwotaW1wb3J0IGphdmF4LnN3aW5nLkxpc3RNb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy5MaXN0U2VsZWN0aW9uTW9kZWw7Ci1pbXBvcnQgamF2YXguc3dpbmcuYm9yZGVyLkJvcmRlcjsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5Eb2N1bWVudEV2ZW50OwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LkRvY3VtZW50TGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU2ltcGxlU3RyaW5nTWF0Y2hlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nTWF0Y2hlcjsKLQotLyoqCi0gKiBUaGlzIHBhbmVsIHByZXNlbnRzIGFuIGVudHJ5IGZpZWxkIGFuZCBhIGxpc3QgYm94IG9mIGNob2ljZXMgdGhhdAotICogYWxsb3dzIHRoZSB1c2VyIHRvIGZpbHRlciB0aGUgZW50cmllcyBpbiB0aGUgbGlzdCBib3ggYnkgZW50ZXJpbmcKLSAqIGEgcGF0dGVybiBpbiB0aGUgZW50cnkgZmllbGQuCi0gKiAKLSAqIEJ5IGRlZmF1bHQsIHR3byB3aWxkY2FyZHMgYXJlIGFsbG93ZWQgaW4gdGhlIHBhdHRlcm46Ci0gKiAJJyonIHdpbGwgbWF0Y2ggYW55IHNldCBvZiB6ZXJvIG9yIG1vcmUgY2hhcmFjdGVycwotICogCSc/JyB3aWxsIG1hdGNoIGFueSBzaW5nbGUgY2hhcmFjdGVyCi0gKiAKLSAqIFRoZSBwYW5lbCBjb25zaXN0cyBvZiA0IGNvbXBvbmVudHMgdGhhdCBjYW4gYmUgY3VzdG9taXplZDoKLSAqIAktIDEgdGV4dCBmaWVsZAotICogCS0gMSBsaXN0IGJveAotICogCS0gMiBsYWJlbHMsIG9uZSBmb3IgZWFjaCBvZiB0aGUgYWJvdmUKLSAqIAotICogT3RoZXIgYXNwZWN0cyBvZiB0aGUgcGFuZWwncyBiZWhhdmlvciBjYW4gYmUgY2hhbmdlZDoKLSAqIAktIHRoZSBzdHJpbmcgY29udmVydGVyIGRldGVybWluZXMgaG93IHRoZSBvYmplY3RzIGluIHRoZQotICogCQlsaXN0IGFyZSBjb252ZXJ0ZWQgdG8gc3RyaW5ncyBhbmQgY29tcGFyZWQgdG8gdGhlIHBhdHRlcm4KLSAqIAkJZW50ZXJlZCBpbiB0aGUgdGV4dCBmaWVsZDsgYnkgZGVmYXVsdCB0aGUgY29udmVydGVyIHNpbXBseQotICogCQl1c2VzIHRoZSByZXN1bHQgb2YgdGhlIG9iamVjdCdzICN0b1N0cmluZygpIG1ldGhvZAotICogCQkoaWYgeW91IHJlcGxhY2UgdGhlIHN0cmluZyBjb252ZXJ0ZXIsIHlvdSB3aWxsIHByb2JhYmx5Ci0gKiAJCXdhbnQgdG8gcmVwbGFjZSB0aGUgbGlzdCBib3gncyBjZWxsIHJlbmRlcmVyIGFsc28pCi0gKiAJLSB0aGUgc3RyaW5nIG1hdGNoZXIgY2FuIGFsc28gYmUgY2hhbmdlZCBpZiB5b3Ugd291bGQKLSAqIAkJbGlrZSBkaWZmZXJlbnQgcGF0dGVybiBtYXRjaGluZyBiZWhhdmlvciB0aGFuIHRoYXQKLSAqIAkJZGVzY3JpYmVkIGFib3ZlCi0gKiAJLSB5b3UgY2FuIHNwZWNpZnkgdGhlIG1heGltdW0gc2l6ZSBvZiB0aGUgbGlzdCAtIHRoaXMgbWF5Ci0gKiAJCWZvcmNlIHRoZSB1c2VyIHRvIGVudGVyIGEgcGF0dGVybiByZXN0cmljdGl2ZSBlbm91Z2gKLSAqIAkJdG8gcmVzdWx0IGluIGEgbGlzdCBzbWFsbGVyIHRoYW4gdGhlIG1heGltdW0gc2l6ZTsgdGhlCi0gKiAJCWRlZmF1bHQgaXMgLTEsIHdoaWNoIGRpc2FibGVzIHRoZSByZXN0cmljdGlvbgotICogCi0gKiBUaGlzIHBhbmVsIGlzIG5vdCBhIHR5cGljYWwgcGFuZWwsIGluIHRoZSBzZW5zZSB0aGF0IGl0IGRvZXMgbm90IHNoYXJlCi0gKiBpdHMgbW9kZWwgd2l0aCBjbGllbnRzIHZpYSB2YWx1ZSBtb2RlbHMuIEluc3RlYWQsIHRoaXMgcGFuZWwncyBtb2RlbAotICogaXMgc2V0IGFuZCBxdWVyaWVkIGRpcmVjdGx5IGJlY2F1c2UgaXQgaXMgZGVzaWduZWQgdG8gYmUgdXNlZCBpbiBhCi0gKiBkaWFsb2cgdGhhdCBkaXJlY3RzIHRoZSB1c2VyJ3MgYmVoYXZpb3IgKGFzIG9wcG9zZWQgdG8gYSAibm9ybWFsIgotICogd2luZG93KS4KLSAqLwotcHVibGljIGNsYXNzIEZpbHRlcmluZ0xpc3RQYW5lbDxUPiBleHRlbmRzIEpQYW5lbCB7Ci0KLQkvKioKLQkgKiBUaGUgY29tcGxldGUgbGlzdCBvZiBhdmFpbGFibGUgY2hvaWNlcwotCSAqIChhcyBvcHBvc2VkIHRvIHRoZSBwYXJ0aWFsIGxpc3QgaGVsZCBieSB0aGUgbGlzdCBib3gpLgotCSAqLwotCXByaXZhdGUgT2JqZWN0W10gY29tcGxldGVMaXN0OwotCi0JLyoqCi0JICogQW4gYWRhcHRlciB1c2VkIHRvIGNvbnZlcnQgdGhlIG9iamVjdHMgaW4gdGhlIGxpc3QKLQkgKiB0byBzdHJpbmdzIHNvIHRoZXkgY2FuIGJlIHJ1biB0aHJvdWdoIHRoZSBtYXRjaGVyCi0JICogYW5kIGRpc3BsYXllZCBpbiB0aGUgdGV4dCBmaWVsZC4KLQkgKi8KLQlTdHJpbmdDb252ZXJ0ZXI8VD4gc3RyaW5nQ29udmVydGVyOwotCi0JLyoqIFRoZSB0ZXh0IGZpZWxkLiAqLwotCXByaXZhdGUgSlRleHRGaWVsZCB0ZXh0RmllbGQ7Ci0JcHJpdmF0ZSBKTGFiZWwgdGV4dEZpZWxkTGFiZWw7Ci0JcHJpdmF0ZSBEb2N1bWVudExpc3RlbmVyIHRleHRGaWVsZExpc3RlbmVyOwotCi0JLyoqIFRoZSBsaXN0IGJveC4gKi8KLQlwcml2YXRlIEpMaXN0IGxpc3RCb3g7Ci0JcHJpdmF0ZSBKTGFiZWwgbGlzdEJveExhYmVsOwotCi0JLyoqIFRoZSBtYXhpbXVtIG51bWJlciBvZiBlbnRyaWVzIGRpc3BsYXllZCBpbiB0aGUgbGlzdCBib3guICovCi0JcHJpdmF0ZSBpbnQgbWF4TGlzdFNpemU7Ci0KLQkvKioKLQkgKiBUaGUgbWF0Y2hlciB1c2VkIHRvIGZpbHRlciB0aGUgbGlzdCBhZ2FpbnN0Ci0JICogdGhlIHBhdHRlcm4gZW50ZXJlZCBpbiB0aGUgdGV4dCBmaWVsZC4gQnkgZGVmYXVsdCwKLQkgKiB0aGlzIGFsbG93cyB0aGUgdHdvIHdpbGRjYXJkIGNoYXJhY3RlcnMgZGVzY3JpYmVkIGluCi0JICogdGhlIGNsYXNzIGNvbW1lbnQuCi0JICovCi0JcHJpdmF0ZSBTdHJpbmdNYXRjaGVyIHN0cmluZ01hdGNoZXI7Ci0KLQkvKioKLQkgKiBQZXJmb3JtYW5jZSB0d2VhazogV2UgdXNlIHRoaXMgYnVmZmVyIGluc3RlYWQgb2YKLQkgKiBhIHRlbXBvcmFyeSB2YXJpYWJsZSBkdXJpbmcgZmlsdGVyaW5nIHNvIHdlIGRvbid0IGhhdmUKLQkgKiB0byBrZWVwIHJlLWFsbG9jYXRpbmcgaXQuCi0JICovCi0JcHJpdmF0ZSBPYmplY3RbXSBidWZmZXI7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBCb3JkZXIgVEVYVF9GSUVMRF9MQUJFTF9CT1JERVIgPSBCb3JkZXJGYWN0b3J5LmNyZWF0ZUVtcHR5Qm9yZGVyKDAsIDAsIDUsIDApOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIEJvcmRlciBMSVNUX0JPWF9MQUJFTF9CT1JERVIgPSBCb3JkZXJGYWN0b3J5LmNyZWF0ZUVtcHR5Qm9yZGVyKDUsIDAsIDUsIDApOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBGaWx0ZXJpbmdMaXN0UGFuZWwgd2l0aCB0aGUgc3BlY2lmaWVkIGxpc3Qgb2YgY2hvaWNlcwotCSAqIGFuZCBpbml0aWFsIHNlbGVjdGlvbi4gVXNlIHRoZSBkZWZhdWx0IHN0cmluZyBjb252ZXJ0ZXIgdG8gY29udmVydCB0aGUKLQkgKiBjaG9pY2VzIGFuZCBzZWxlY3Rpb24gdG8gc3RyaW5ncyAod2hpY2ggc2ltcGx5IGNhbGxzICN0b1N0cmluZygpIG9uCi0JICogdGhlIG9iamVjdHMpLgotCSAqLwotCXB1YmxpYyBGaWx0ZXJpbmdMaXN0UGFuZWwoT2JqZWN0W10gY29tcGxldGVMaXN0LCBPYmplY3QgaW5pdGlhbFNlbGVjdGlvbikgewotCQl0aGlzKGNvbXBsZXRlTGlzdCwgaW5pdGlhbFNlbGVjdGlvbiwgU3RyaW5nQ29udmVydGVyLkRlZmF1bHQuPFQ+aW5zdGFuY2UoKSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgRmlsdGVyaW5nTGlzdFBhbmVsIHdpdGggdGhlIHNwZWNpZmllZCBsaXN0IG9mIGNob2ljZXMKLQkgKiBhbmQgaW5pdGlhbCBzZWxlY3Rpb24uIFVzZSB0aGUgc3BlY2lmaWVkIHN0cmluZyBjb252ZXJ0ZXIgdG8gY29udmVydCB0aGUKLQkgKiBjaG9pY2VzIGFuZCBzZWxlY3Rpb24gdG8gc3RyaW5ncy4KLQkgKi8KLQlwdWJsaWMgRmlsdGVyaW5nTGlzdFBhbmVsKE9iamVjdFtdIGNvbXBsZXRlTGlzdCwgT2JqZWN0IGluaXRpYWxTZWxlY3Rpb24sIFN0cmluZ0NvbnZlcnRlcjxUPiBzdHJpbmdDb252ZXJ0ZXIpIHsKLQkJc3VwZXIobmV3IEJvcmRlckxheW91dCgpKTsKLQkJdGhpcy5jb21wbGV0ZUxpc3QgPSBjb21wbGV0ZUxpc3Q7Ci0JCXRoaXMuc3RyaW5nQ29udmVydGVyID0gc3RyaW5nQ29udmVydGVyOwotCQl0aGlzLmluaXRpYWxpemUoaW5pdGlhbFNlbGVjdGlvbik7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCXByaXZhdGUgdm9pZCBpbml0aWFsaXplKE9iamVjdCBpbml0aWFsU2VsZWN0aW9uKSB7Ci0JCXRoaXMubWF4TGlzdFNpemUgPSB0aGlzLmRlZmF1bHRNYXhMaXN0U2l6ZSgpOwotCQl0aGlzLmJ1ZmZlciA9IHRoaXMuYnVpbGRCdWZmZXIoKTsKLQotCQl0aGlzLnRleHRGaWVsZExpc3RlbmVyID0gdGhpcy5idWlsZFRleHRGaWVsZExpc3RlbmVyKCk7Ci0KLQkJdGhpcy5zdHJpbmdNYXRjaGVyID0gdGhpcy5idWlsZFN0cmluZ01hdGNoZXIoKTsKLQotCQl0aGlzLmluaXRpYWxpemVMYXlvdXQoaW5pdGlhbFNlbGVjdGlvbik7Ci0JfQotCi0JcHJpdmF0ZSBPYmplY3RbXSBidWlsZEJ1ZmZlcigpIHsKLQkJcmV0dXJuIG5ldyBPYmplY3RbdGhpcy5tYXgoKV07Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjdXJyZW50IG1heCBudW1iZXIgb2YgZW50cmllcyBhbGxvd2VkIGluIHRoZSBsaXN0IGJveC4KLQkgKi8KLQlwcml2YXRlIGludCBtYXgoKSB7Ci0JCWlmICh0aGlzLm1heExpc3RTaXplID09IC0xKSB7Ci0JCQlyZXR1cm4gdGhpcy5jb21wbGV0ZUxpc3QubGVuZ3RoOwotCQl9Ci0JCXJldHVybiBNYXRoLm1pbih0aGlzLm1heExpc3RTaXplLCB0aGlzLmNvbXBsZXRlTGlzdC5sZW5ndGgpOwotCX0KLQotCS8qKgotCSAqIEJ1aWxkIGEgbGlzdGVuZXIgdGhhdCB3aWxsIGxpc3RlbiB0byBjaGFuZ2VzIGluIHRoZSB0ZXh0IGZpZWxkCi0JICogYW5kIGZpbHRlciB0aGUgbGlzdCBhcHByb3ByaWF0ZWx5LgotCSAqLwotCXByaXZhdGUgRG9jdW1lbnRMaXN0ZW5lciBidWlsZFRleHRGaWVsZExpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IERvY3VtZW50TGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBpbnNlcnRVcGRhdGUoRG9jdW1lbnRFdmVudCBlKSB7Ci0JCQkJRmlsdGVyaW5nTGlzdFBhbmVsLnRoaXMuZmlsdGVyTGlzdCgpOwotCQkJfQotCQkJcHVibGljIHZvaWQgY2hhbmdlZFVwZGF0ZShEb2N1bWVudEV2ZW50IGUpIHsKLQkJCQlGaWx0ZXJpbmdMaXN0UGFuZWwudGhpcy5maWx0ZXJMaXN0KCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCByZW1vdmVVcGRhdGUoRG9jdW1lbnRFdmVudCBlKSB7Ci0JCQkJRmlsdGVyaW5nTGlzdFBhbmVsLnRoaXMuZmlsdGVyTGlzdCgpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAidGV4dCBmaWVsZCBsaXN0ZW5lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBpbnQgZGVmYXVsdE1heExpc3RTaXplKCkgewotCQlyZXR1cm4gLTE7Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmdNYXRjaGVyIGJ1aWxkU3RyaW5nTWF0Y2hlcigpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVTdHJpbmdNYXRjaGVyPFQ+KCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGluaXRpYWxpemVMYXlvdXQoT2JqZWN0IGluaXRpYWxTZWxlY3Rpb24pIHsKLQkJLy8gdGV4dCBmaWVsZAotCQlKUGFuZWwgdGV4dEZpZWxkUGFuZWwgPSBuZXcgSlBhbmVsKG5ldyBCb3JkZXJMYXlvdXQoKSk7Ci0JCXRoaXMudGV4dEZpZWxkTGFiZWwgPSBuZXcgSkxhYmVsKCk7Ci0JCXRoaXMudGV4dEZpZWxkTGFiZWwuc2V0Qm9yZGVyKFRFWFRfRklFTERfTEFCRUxfQk9SREVSKTsKLQkJdGV4dEZpZWxkUGFuZWwuYWRkKHRoaXMudGV4dEZpZWxkTGFiZWwsIEJvcmRlckxheW91dC5OT1JUSCk7Ci0KLQkJdGhpcy50ZXh0RmllbGQgPSBuZXcgSlRleHRGaWVsZCgpOwotCQl0aGlzLnRleHRGaWVsZC5nZXREb2N1bWVudCgpLmFkZERvY3VtZW50TGlzdGVuZXIodGhpcy50ZXh0RmllbGRMaXN0ZW5lcik7Ci0JCXRoaXMudGV4dEZpZWxkTGFiZWwuc2V0TGFiZWxGb3IodGhpcy50ZXh0RmllbGQpOwotCQl0ZXh0RmllbGRQYW5lbC5hZGQodGhpcy50ZXh0RmllbGQsIEJvcmRlckxheW91dC5DRU5URVIpOwotCi0JCXRoaXMuYWRkKHRleHRGaWVsZFBhbmVsLCBCb3JkZXJMYXlvdXQuTk9SVEgpOwotCi0JCS8vIGxpc3QgYm94Ci0JCUpQYW5lbCBsaXN0Qm94UGFuZWwgPSBuZXcgSlBhbmVsKG5ldyBCb3JkZXJMYXlvdXQoKSk7Ci0JCXRoaXMubGlzdEJveExhYmVsID0gbmV3IEpMYWJlbCgpOwotCQl0aGlzLmxpc3RCb3hMYWJlbC5zZXRCb3JkZXIoTElTVF9CT1hfTEFCRUxfQk9SREVSKTsKLQkJbGlzdEJveFBhbmVsLmFkZCh0aGlzLmxpc3RCb3hMYWJlbCwgQm9yZGVyTGF5b3V0Lk5PUlRIKTsKLQotCQl0aGlzLmxpc3RCb3ggPSBuZXcgSkxpc3QoKTsKLQkJdGhpcy5saXN0Qm94LnNldERvdWJsZUJ1ZmZlcmVkKHRydWUpOwotCQl0aGlzLmxpc3RCb3guc2V0TW9kZWwodGhpcy5idWlsZFBhcnRpYWxBcnJheUxpc3RNb2RlbCh0aGlzLmNvbXBsZXRlTGlzdCwgdGhpcy5tYXgoKSkpOwotCQl0aGlzLmxpc3RCb3guZ2V0U2VsZWN0aW9uTW9kZWwoKS5zZXRTZWxlY3Rpb25Nb2RlKExpc3RTZWxlY3Rpb25Nb2RlbC5TSU5HTEVfU0VMRUNUSU9OKTsKLQkJLy8gcGVyZm9ybWFuY2UgdHdlYWsoPykKLQkJdGhpcy5saXN0Qm94LnNldFByb3RvdHlwZUNlbGxWYWx1ZSh0aGlzLnByb3RvdHlwZUNlbGxWYWx1ZSgpKTsKLQkJdGhpcy5saXN0Qm94LnNldFByb3RvdHlwZUNlbGxWYWx1ZShudWxsKTsKLQkJdGhpcy5saXN0Qm94LnNldENlbGxSZW5kZXJlcih0aGlzLmJ1aWxkRGVmYXVsdENlbGxSZW5kZXJlcigpKTsKLQkJdGhpcy5saXN0Qm94TGFiZWwuc2V0TGFiZWxGb3IodGhpcy5saXN0Qm94KTsKLQkJLy8gYnVnIDI3Nzc4MDIgLSBzY3JvbGwgYmFycyBzaG91bGRuJ3QgYmUgb24gdGhlIHRhYiBzZXF1ZW5jZQotCQlKU2Nyb2xsUGFuZSBsaXN0Qm94U2Nyb2xsUGFuZSA9IG5ldyBKU2Nyb2xsUGFuZSh0aGlzLmxpc3RCb3gpOwotCQlsaXN0Qm94U2Nyb2xsUGFuZS5nZXRIb3Jpem9udGFsU2Nyb2xsQmFyKCkuc2V0Rm9jdXNhYmxlKGZhbHNlKTsKLQkJbGlzdEJveFNjcm9sbFBhbmUuZ2V0VmVydGljYWxTY3JvbGxCYXIoKS5zZXRGb2N1c2FibGUoZmFsc2UpOwotCQlsaXN0Qm94UGFuZWwuYWRkKGxpc3RCb3hTY3JvbGxQYW5lLCBCb3JkZXJMYXlvdXQuQ0VOVEVSKTsKLQotCQkvLyBpbml0aWFsaXplIHRoZSB3aWRnZXRzCi0JCXRoaXMubGlzdEJveC5zZXRTZWxlY3RlZFZhbHVlKGluaXRpYWxTZWxlY3Rpb24sIHRydWUpOwotCQl0aGlzLnRleHRGaWVsZC5zZWxlY3QoMCwgdGhpcy50ZXh0RmllbGQuZ2V0VGV4dCgpLmxlbmd0aCgpKTsKLQotCQl0aGlzLmFkZChsaXN0Qm94UGFuZWwsIEJvcmRlckxheW91dC5DRU5URVIpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBwdWJsaWMgQVBJICoqKioqKioqKioKLQotCXB1YmxpYyBPYmplY3Qgc2VsZWN0aW9uKCkgewotCQlyZXR1cm4gdGhpcy5saXN0Qm94LmdldFNlbGVjdGVkVmFsdWUoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBzZXRTZWxlY3Rpb24oT2JqZWN0IHNlbGVjdGlvbikgewotCQl0aGlzLmxpc3RCb3guc2V0U2VsZWN0ZWRWYWx1ZShzZWxlY3Rpb24sIHRydWUpOwotCX0KLQotCXB1YmxpYyBPYmplY3RbXSBjb21wbGV0ZUxpc3QoKSB7Ci0JCXJldHVybiB0aGlzLmNvbXBsZXRlTGlzdDsKLQl9Ci0KLQkvKioKLQkgKiByZWJ1aWxkIHRoZSBmaWx0ZXJpbmcgYnVmZmVyIGFuZCByZS1hcHBseSB0aGUgZmlsdGVyCi0JICogdG8gdGhlIG5ldyBsaXN0Ci0JICovCi0JcHVibGljIHZvaWQgc2V0Q29tcGxldGVMaXN0KE9iamVjdFtdIGNvbXBsZXRlTGlzdCkgewotCQl0aGlzLmNvbXBsZXRlTGlzdCA9IGNvbXBsZXRlTGlzdDsKLQkJaWYgKHRoaXMuYnVmZmVyLmxlbmd0aCA8IHRoaXMubWF4KCkpIHsKLQkJCS8vIHRoZSBidWZmZXIgd2lsbCBuZXZlciBzaHJpbmsgLSBtaWdodCB3YW50IHRvIHJlLWNvbnNpZGVyLi4uICB+Ymp2Ci0JCQl0aGlzLmJ1ZmZlciA9IHRoaXMuYnVpbGRCdWZmZXIoKTsKLQkJfQotCQl0aGlzLmZpbHRlckxpc3QoKTsKLQl9Ci0KLQlwdWJsaWMgaW50IG1heExpc3RTaXplKCkgewotCQlyZXR1cm4gdGhpcy5tYXhMaXN0U2l6ZTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBzZXRNYXhMaXN0U2l6ZShpbnQgbWF4TGlzdFNpemUpIHsKLQkJdGhpcy5tYXhMaXN0U2l6ZSA9IG1heExpc3RTaXplOwotCQlpZiAodGhpcy5idWZmZXIubGVuZ3RoIDwgdGhpcy5tYXgoKSkgewotCQkJLy8gdGhlIGJ1ZmZlciB3aWxsIG5ldmVyIHNocmluayAtIG1pZ2h0IHdhbnQgdG8gcmUtY29uc2lkZXIuLi4gIH5ianYKLQkJCXRoaXMuYnVmZmVyID0gdGhpcy5idWlsZEJ1ZmZlcigpOwotCQl9Ci0JCXRoaXMuZmlsdGVyTGlzdCgpOwotCX0KLQotCXB1YmxpYyBTdHJpbmdDb252ZXJ0ZXI8VD4gc3RyaW5nQ29udmVydGVyKCkgewotCQlyZXR1cm4gdGhpcy5zdHJpbmdDb252ZXJ0ZXI7Ci0JfQotCi0JLyoqCi0JICogYXBwbHkgdGhlIG5ldyBmaWx0ZXIgdG8gdGhlIGxpc3QKLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRTdHJpbmdDb252ZXJ0ZXIoU3RyaW5nQ29udmVydGVyPFQ+IHN0cmluZ0NvbnZlcnRlcikgewotCQl0aGlzLnN0cmluZ0NvbnZlcnRlciA9IHN0cmluZ0NvbnZlcnRlcjsKLQkJdGhpcy5maWx0ZXJMaXN0KCk7Ci0JfQotCi0JLyoqCi0JICogYWxsb3cgY2xpZW50IGNvZGUgdG8gYWNjZXNzIHRoZSB0ZXh0IGZpZWxkCi0JICogKHNvIHdlIGNhbiBzZXQgdGhlIGZvY3VzKQotCSAqLwotCXB1YmxpYyBKVGV4dEZpZWxkIHRleHRGaWVsZCgpIHsKLQkJcmV0dXJuIHRoaXMudGV4dEZpZWxkOwotCX0KLQotCS8qKgotCSAqIGFsbG93IGNsaWVudCBjb2RlIHRvIGFjY2VzcyB0aGUgdGV4dCBmaWVsZCBsYWJlbAotCSAqLwotCXB1YmxpYyBKTGFiZWwgdGV4dEZpZWxkTGFiZWwoKSB7Ci0JCXJldHVybiB0aGlzLnRleHRGaWVsZExhYmVsOwotCX0KLQotCS8qKgotCSAqIGNvbnZlbmllbmNlIG1ldGhvZAotCSAqLwotCXB1YmxpYyB2b2lkIHNldFRleHRGaWVsZExhYmVsVGV4dChTdHJpbmcgdGV4dCkgewotCQl0aGlzLnRleHRGaWVsZExhYmVsLnNldFRleHQodGV4dCk7Ci0JfQotCi0JLyoqCi0JICogYWxsb3cgY2xpZW50IGNvZGUgdG8gYWNjZXNzIHRoZSBsaXN0IGJveAotCSAqIChzbyB3ZSBjYW4gYWRkIG1vdXNlIGxpc3RlbmVycyBmb3IgZG91YmxlLWNsaWNraW5nKQotCSAqLwotCXB1YmxpYyBKTGlzdCBsaXN0Qm94KCkgewotCQlyZXR1cm4gdGhpcy5saXN0Qm94OwotCX0KLQotCS8qKgotCSAqIGNvbnZlbmllbmNlIG1ldGhvZAotCSAqLwotCXB1YmxpYyB2b2lkIHNldExpc3RCb3hDZWxsUmVuZGVyZXIoTGlzdENlbGxSZW5kZXJlciByZW5kZXJlcikgewotCQl0aGlzLmxpc3RCb3guc2V0Q2VsbFJlbmRlcmVyKHJlbmRlcmVyKTsKLQl9Ci0KLQkvKioKLQkgKiBhbGxvdyBjbGllbnQgY29kZSB0byBhY2Nlc3MgdGhlIGxpc3QgYm94IGxhYmVsCi0JICovCi0JcHVibGljIEpMYWJlbCBsaXN0Qm94TGFiZWwoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3RCb3hMYWJlbDsKLQl9Ci0KLQkvKioKLQkgKiBjb252ZW5pZW5jZSBtZXRob2QKLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRMaXN0Qm94TGFiZWxUZXh0KFN0cmluZyB0ZXh0KSB7Ci0JCXRoaXMubGlzdEJveExhYmVsLnNldFRleHQodGV4dCk7Ci0JfQotCi0JLyoqCi0JICogY29udmVuaWVuY2UgbWV0aG9kCi0JICovCi0JcHVibGljIHZvaWQgc2V0Q29tcG9uZW50c0ZvbnQoRm9udCBmb250KSB7Ci0JCXRoaXMudGV4dEZpZWxkTGFiZWwuc2V0Rm9udChmb250KTsKLQkJdGhpcy50ZXh0RmllbGQuc2V0Rm9udChmb250KTsKLQkJdGhpcy5saXN0Qm94TGFiZWwuc2V0Rm9udChmb250KTsKLQkJdGhpcy5saXN0Qm94LnNldEZvbnQoZm9udCk7Ci0JfQotCi0JcHVibGljIFN0cmluZ01hdGNoZXIgc3RyaW5nTWF0Y2hlcigpIHsKLQkJcmV0dXJuIHRoaXMuc3RyaW5nTWF0Y2hlcjsKLQl9Ci0KLQkvKioKLQkgKiByZS1hcHBseSB0aGUgZmlsdGVyIHRvIHRoZSBsaXN0Ci0JICovCi0JcHVibGljIHZvaWQgc2V0U3RyaW5nTWF0Y2hlcihTdHJpbmdNYXRjaGVyIHN0cmluZ01hdGNoZXIpIHsKLQkJdGhpcy5zdHJpbmdNYXRjaGVyID0gc3RyaW5nTWF0Y2hlcjsKLQkJdGhpcy5maWx0ZXJMaXN0KCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGludGVybmFsIG1ldGhvZHMgKioqKioqKioqKgotCi0JLyoqCi0JICogQWxsb3cgc3ViY2xhc3NlcyB0byBkaXNhYmxlIHBlcmZvcm1hbmNlIHR3ZWFrCi0JICogYnkgcmV0dXJuaW5nIG51bGwgaGVyZS4KLQkgKi8KLQlwcm90ZWN0ZWQgU3RyaW5nIHByb3RvdHlwZUNlbGxWYWx1ZSgpIHsKLQkJcmV0dXJuICI9PT09PT09PT09PiBBX1NUUklOR19USEFUX0lTX0RFRklOSVRFTFlfTE9OR0VSX1RIQU5fRVZFUllfU1RSSU5HX0lOX1RIRV9MSVNUIDw9PT09PT09PT09IjsKLQl9Ci0KLQkvKioKLQkgKiBCeSBkZWZhdWx0LCB1c2UgdGhlIHN0cmluZyBjb252ZXJ0ZXIgdG8gYnVpbGQgdGhlIHRleHQKLQkgKiB1c2VkIGJ5IHRoZSBsaXN0IGJveCdzIGNlbGwgcmVuZGVyZXIuCi0JICovCi0JcHJvdGVjdGVkIExpc3RDZWxsUmVuZGVyZXIgYnVpbGREZWZhdWx0Q2VsbFJlbmRlcmVyKCkgewotCQlyZXR1cm4gbmV3IFNpbXBsZUxpc3RDZWxsUmVuZGVyZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFRleHQoT2JqZWN0IHZhbHVlKSB7Ci0JCQkJcmV0dXJuIEZpbHRlcmluZ0xpc3RQYW5lbC50aGlzLnN0cmluZ0NvbnZlcnRlci5jb252ZXJ0VG9TdHJpbmcoKFQpIHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQkvKioKLQkgKiBTb21ldGhpbmcgaGFzIGNoYW5nZWQgdGhhdCByZXF1aXJlcyB1cyB0byBmaWx0ZXIgdGhlIGxpc3QuCi0JICogCi0JICogVGhpcyBtZXRob2QgaXMgc3luY2hyb25pemVkIGJlY2F1c2UgYSBmYXN0IHR5cGlzdCBjYW4KLQkgKiBnZW5lcmF0ZSBldmVudHMgcXVpY2tlciB0aGFuIHdlIGNhbiBmaWx0ZXIgdGhlIGxpc3QuICg/ICB+Ymp2KQotCSAqLwotCXN5bmNocm9uaXplZCB2b2lkIGZpbHRlckxpc3QoKSB7Ci0JCS8vIHRlbXBvcmFyaWx5IHN0b3AgbGlzdGVuaW5nIHRvIHRoZSBsaXN0IGJveCBzZWxlY3Rpb24sIHNpbmNlIHdlIHdpbGwKLQkJLy8gYmUgY2hhbmdpbmcgdGhlIHNlbGVjdGlvbiBkdXJpbmcgdGhlIGZpbHRlcmluZyBhbmQgZG9uJ3Qgd2FudAotCQkvLyB0aGF0IHRvIGFmZmVjdCB0aGUgdGV4dCBmaWVsZAotCQl0aGlzLmZpbHRlckxpc3QodGhpcy50ZXh0RmllbGQuZ2V0VGV4dCgpKTsKLQl9Ci0KLQkvKioKLQkgKiBGaWx0ZXIgdGhlIGNvbnRlbnRzIG9mIHRoZSBsaXN0IGJveCB0byBtYXRjaCB0aGUKLQkgKiBzcGVjaWZpZWQgcGF0dGVybi4KLQkgKi8KLQlwcml2YXRlIHZvaWQgZmlsdGVyTGlzdChTdHJpbmcgcGF0dGVybikgewotCQlpZiAocGF0dGVybi5sZW5ndGgoKSA9PSAwKSB7Ci0JCQl0aGlzLmxpc3RCb3guc2V0TW9kZWwodGhpcy5idWlsZFBhcnRpYWxBcnJheUxpc3RNb2RlbCh0aGlzLmNvbXBsZXRlTGlzdCwgdGhpcy5tYXgoKSkpOwotCQl9IGVsc2UgewotCQkJdGhpcy5zdHJpbmdNYXRjaGVyLnNldFBhdHRlcm5TdHJpbmcocGF0dGVybik7Ci0JCQlpbnQgaiA9IDA7Ci0JCQlpbnQgbGVuID0gdGhpcy5jb21wbGV0ZUxpc3QubGVuZ3RoOwotCQkJaW50IG1heCA9IHRoaXMubWF4KCk7Ci0JCQlmb3IgKGludCBpID0gMDsgaSA8IGxlbjsgaSsrKSB7Ci0JCQkJaWYgKHRoaXMuc3RyaW5nTWF0Y2hlci5tYXRjaGVzKHRoaXMuc3RyaW5nQ29udmVydGVyLmNvbnZlcnRUb1N0cmluZyh0aGlzLmVudHJ5KGkpKSkpIHsKLQkJCQkJdGhpcy5idWZmZXJbaisrXSA9IHRoaXMuY29tcGxldGVMaXN0W2ldOwotCQkJCX0KLQkJCQlpZiAoaiA9PSBtYXgpIHsKLQkJCQkJYnJlYWs7Ci0JCQkJfQotCQkJfQotCQkJdGhpcy5saXN0Qm94LnNldE1vZGVsKHRoaXMuYnVpbGRQYXJ0aWFsQXJyYXlMaXN0TW9kZWwodGhpcy5idWZmZXIsIGopKTsKLQkJfQotCi0JCS8vIGFmdGVyIGZpbHRlcmluZyB0aGUgbGlzdCwgZGV0ZXJtaW5lIHRoZSBhcHByb3ByaWF0ZSBzZWxlY3Rpb24KLQkJaWYgKHRoaXMubGlzdEJveC5nZXRNb2RlbCgpLmdldFNpemUoKSA9PSAwKSB7Ci0JCQl0aGlzLmxpc3RCb3guZ2V0U2VsZWN0aW9uTW9kZWwoKS5jbGVhclNlbGVjdGlvbigpOwotCQl9IGVsc2UgewotCQkJdGhpcy5saXN0Qm94LmdldFNlbGVjdGlvbk1vZGVsKCkuc2V0QW5jaG9yU2VsZWN0aW9uSW5kZXgoMCk7Ci0JCQl0aGlzLmxpc3RCb3guZ2V0U2VsZWN0aW9uTW9kZWwoKS5zZXRMZWFkU2VsZWN0aW9uSW5kZXgoMCk7Ci0JCQl0aGlzLmxpc3RCb3guZW5zdXJlSW5kZXhJc1Zpc2libGUoMCk7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBtaW5pbWl6ZSBzY29wZSBvZiBzdXBwcmVzc2VkIHdhcm5pbmdzCi0JICovCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJpdmF0ZSBUIGVudHJ5KGludCBpbmRleCkgewotCQlyZXR1cm4gKFQpIHRoaXMuY29tcGxldGVMaXN0W2luZGV4XTsKLQl9Ci0KLQkvKioKLQkgKiBCdWlsZCBhIGxpc3QgbW9kZWwgdGhhdCB3cmFwcyBvbmx5IGEgcG9ydGlvbiBvZiB0aGUgc3BlY2lmaWVkIGFycmF5LgotCSAqIFRoZSBtb2RlbCB3aWxsIGluY2x1ZGUgdGhlIGFycmF5IGVudHJpZXMgZnJvbSAwIHRvIChzaXplIC0gMSkuCi0JICovCi0JcHJpdmF0ZSBMaXN0TW9kZWwgYnVpbGRQYXJ0aWFsQXJyYXlMaXN0TW9kZWwoZmluYWwgT2JqZWN0W10gYXJyYXksIGZpbmFsIGludCBzaXplKSB7Ci0JCXJldHVybiBuZXcgQWJzdHJhY3RMaXN0TW9kZWwoKSB7Ci0JCQlwdWJsaWMgaW50IGdldFNpemUoKSB7Ci0JCQkJcmV0dXJuIHNpemU7Ci0JCQl9Ci0JCQlwdWJsaWMgT2JqZWN0IGdldEVsZW1lbnRBdChpbnQgaW5kZXgpIHsKLQkJCQlyZXR1cm4gYXJyYXlbaW5kZXhdOwotCQkJfQotCQl9OwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9MaXN0Q2hvb3Nlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL0xpc3RDaG9vc2VyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDlhYmMyZTUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL0xpc3RDaG9vc2VyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0MjUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZzsKLQotaW1wb3J0IGphdmEuYXd0LkFXVEV2ZW50OwotaW1wb3J0IGphdmEuYXd0LkFXVEV4Y2VwdGlvbjsKLWltcG9ydCBqYXZhLmF3dC5Db21wb25lbnQ7Ci1pbXBvcnQgamF2YS5hd3QuRXZlbnRRdWV1ZTsKLWltcG9ydCBqYXZhLmF3dC5Qb2ludDsKLWltcG9ydCBqYXZhLmF3dC5Sb2JvdDsKLWltcG9ydCBqYXZhLmF3dC5ldmVudC5LZXlBZGFwdGVyOwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LktleUV2ZW50OwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LktleUxpc3RlbmVyOwotaW1wb3J0IGphdmEuYXd0LmV2ZW50Lk1vdXNlRXZlbnQ7Ci1pbXBvcnQgamF2YXguc3dpbmcuQ29tYm9Cb3hNb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy5EZWZhdWx0TGlzdENlbGxSZW5kZXJlcjsKLWltcG9ydCBqYXZheC5zd2luZy5KQnV0dG9uOwotaW1wb3J0IGphdmF4LnN3aW5nLkpDb21ib0JveDsKLWltcG9ydCBqYXZheC5zd2luZy5KQ29tcG9uZW50OwotaW1wb3J0IGphdmF4LnN3aW5nLkpMYWJlbDsKLWltcG9ydCBqYXZheC5zd2luZy5KTGlzdDsKLWltcG9ydCBqYXZheC5zd2luZy5MaXN0Q2VsbFJlbmRlcmVyOwotaW1wb3J0IGphdmF4LnN3aW5nLlN3aW5nQ29uc3RhbnRzOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LlBvcHVwTWVudUV2ZW50OwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LlBvcHVwTWVudUxpc3RlbmVyOwotaW1wb3J0IGphdmF4LnN3aW5nLnBsYWYuYmFzaWMuQmFzaWNDb21ib0JveFVJOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci0KLS8qKgotICogVGhpcyBjb21wb25lbnQgcHJvdmlkZXMgYSB3YXkgdG8gaGFuZGxlIHNlbGVjdGluZyBhbiBpdGVtIGZyb20gYQotICogbGlzdCB0aGF0IG1heSBncm93IHRvbyBsYXJnZSB0byBiZSBoYW5kbGVkIGNvbnZlbmllbnRseSBieSBhIGNvbWJvLWJveC4gCi0gKiBJZiB0aGUgbGlzdCdzIHNpemUgaXMgbGVzcyB0aGFuIHRoZSBkZXNpZ25hdGVkICJsb25nIiBsaXN0IHNpemUsIAotICogdGhlIGNob2ljZSBsaXN0IHdpbGwgYmUgZGlzcGxheWVkIGluIGEgbm9ybWFsIGNvbWJvLWJveCBwb3B1cDsgCi0gKiBvdGhlcndpc2UsIGEgZGlhbG9nIHdpbGwgYmUgdXNlZCB0byBwcm9tcHQgdGhlIHVzZXIgdG8gY2hvb3NlIGEgc2VsZWN0aW9uLgotICogCi0gKiBUbyBjaGFuZ2UgdGhlIGJyb3dzZSBtZWNoYW5pc20sIHN1YmNsYXNzZXMgbWF5IAotICogCS0gb3ZlcnJpZGUgdGhlIG1ldGhvZCAjYnVpbGRCcm93c2VyKCkKLSAqICAtIG92ZXJyaWRlIHRoZSBtZXRob2QgI2Jyb3dzZSgpLCBpbiB3aGljaCBjYXNlIHRoZSBtZXRob2QgCi0gKiAJCSNidWlsZEJyb3dzZXIoKSBtYXkgYmUgaWdub3JlZC4KLSAqLwotcHVibGljIGNsYXNzIExpc3RDaG9vc2VyIAotCWV4dGVuZHMgSkNvbWJvQm94Ci17Ci0JCi0JLyoqIHRoZSBzaXplIG9mIGEgImxvbmciIGxpc3QgLSBhbnl0aGluZyBzbWFsbGVyIGlzIGEgInNob3J0IiBsaXN0ICovCi0JaW50IGxvbmdMaXN0U2l6ZSA9IERFRkFVTFRfTE9OR19MSVNUX1NJWkU7Ci0JCi0JLyoqIHRoZSBkZWZhdWx0IHNpemUgb2YgYSAibG9uZyIgbGlzdCwgd2hpY2ggaXMgMjAgKHRvIG1hdGNoIEpPcHRpb25QYW5lJ3MgYmVoYXZpb3IpICovCi0JcHVibGljIHN0YXRpYyBmaW5hbCBpbnQgREVGQVVMVF9MT05HX0xJU1RfU0laRSA9IDIwOwotCQotCS8qKiBwcm9wZXJ0eSBjaGFuZ2UgYXNzb2NpYXRlZCB3aXRoIGxvbmcgbGlzdCBzaXplICovCi0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgTE9OR19MSVNUX1NJWkVfUFJPUEVSVFkgPSAibG9uZ0xpc3RTaXplIjsKLQkKLSAgICBzdGF0aWMgSkxhYmVsIHByb3RvdHlwZUxhYmVsID0gbmV3IEpMYWJlbCgiUHJvdG90eXBlIiwgbmV3IEVtcHR5SWNvbigxNyksIFN3aW5nQ29uc3RhbnRzLkxFQURJTkcpOwotCi0gICAgLyoqIAotCSAqIHdoZXRoZXIgdGhlIGNob29zZXIgaXMgY2hvb3NhYmxlLiAgaWYgYSBjaG9vc2VyIGlzIG5vdCBjaG9vc2FibGUsCi0JICogaXQgb25seSBzZXJ2ZXMgYXMgYSBkaXNwbGF5IHdpZGdldC4gIGEgdXNlciBtYXkgbm90IGNoYW5nZSBpdHMgCi0JICogc2VsZWN0ZWQgdmFsdWUuCi0JICovCi0JYm9vbGVhbiBjaG9vc2FibGUgPSB0cnVlOwotCQotCS8qKiBwcm9wZXJ0eSBjaGFuZ2UgYXNzb2NpYXRlZCB3aXRoIGNob29zYWJsZSAqLwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIENIT09TQUJMRV9QUk9QRVJUWSA9ICJjaG9vc2FibGUiOwotCQotCS8qKiB0aGUgYnJvd3NlciB1c2VkIHRvIG1ha2UgYSBzZWxlY3Rpb24gZnJvbSB0aGUgbG9uZyBsaXN0IC0gdHlwaWNhbGx5IHZpYSBhIGRpYWxvZyAqLwotCXByaXZhdGUgTGlzdEJyb3dzZXIgYnJvd3NlcjsKLQkKLSAgICBwcml2YXRlIE5vZGVTZWxlY3RvciBub2RlU2VsZWN0b3I7Ci0gICAgCi0JLyoqIElOVEVSTkFMIC0gVGhlIHBvcHVwIGlzIGJlaW5nIHNob3duLiAgVXNlZCB0byBwcmV2ZW50IGluZmluaXRlIGxvb3AuICovCi0JYm9vbGVhbiBwb3B1cEFscmVhZHlJblByb2dyZXNzOwotCQotCQotCS8vICoqKioqKioqKioqKioqKiogQ29uc3RydWN0b3JzICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotCQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGxpc3QgY2hvb3NlciBmb3IgdGhlIHNwZWNpZmllZCBtb2RlbC4KLQkgKi8KLQlwdWJsaWMgTGlzdENob29zZXIoQ29tYm9Cb3hNb2RlbCBtb2RlbCkgewotCQl0aGlzKG1vZGVsLCBuZXcgTm9kZVNlbGVjdG9yLkRlZmF1bHROb2RlU2VsZWN0b3IoKSk7Ci0JfQotCQotICAgIHB1YmxpYyBMaXN0Q2hvb3NlcihDYWNoaW5nQ29tYm9Cb3hNb2RlbCBtb2RlbCkgewotICAgICAgICB0aGlzKG1vZGVsLCBuZXcgTm9kZVNlbGVjdG9yLkRlZmF1bHROb2RlU2VsZWN0b3IoKSk7Ci0gICAgfQotICAgIAotCXB1YmxpYyBMaXN0Q2hvb3NlcihDb21ib0JveE1vZGVsIG1vZGVsLCBOb2RlU2VsZWN0b3Igbm9kZVNlbGVjdG9yKSB7Ci0gICAgICAgIHRoaXMobmV3IE5vbkNhY2hpbmdDb21ib0JveE1vZGVsKG1vZGVsKSwgbm9kZVNlbGVjdG9yKTsKLSAgICB9Ci0gICAgCi0gICAgcHVibGljIExpc3RDaG9vc2VyKENhY2hpbmdDb21ib0JveE1vZGVsIG1vZGVsLCBOb2RlU2VsZWN0b3Igbm9kZVNlbGVjdG9yKSB7Ci0gICAgICAgIHN1cGVyKG1vZGVsKTsKLSAgICAgICAgdGhpcy5pbml0aWFsaXplKCk7Ci0gICAgICAgIHRoaXMubm9kZVNlbGVjdG9yID0gbm9kZVNlbGVjdG9yOwotICAgIH0KLQkvLyAqKioqKioqKioqKioqKioqIEluaXRpYWxpemF0aW9uICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLQkKLQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplKCkgewotCQl0aGlzLmFkZFBvcHVwTWVudUxpc3RlbmVyKHRoaXMuYnVpbGRQb3B1cE1lbnVMaXN0ZW5lcigpKTsKLQkJdGhpcy5zZXRSZW5kZXJlcihuZXcgRGVmYXVsdExpc3RDZWxsUmVuZGVyZXIoKSk7Ci0gICAgICAgIHRoaXMuYWRkS2V5TGlzdGVuZXIoYnVpbGRGM0tleUxpc3RlbmVyKCkpOwotICAgICAgICAKLSAgICAgICAgLy9UaGVzZSBhcmUgdXNlZCB0byB3b3JrYXJvdW5kIHByb2JsZW1zIHdpdGggU3dpbmcgdHJ5aW5nIHRvIAotICAgICAgICAvL2RldGVybWluZSB0aGUgc2l6ZSBvZiBhIGNvbWJvQm94IHdpdGggYSBsYXJnZSBtb2RlbAotICAgICAgICBzZXRQcm90b3R5cGVEaXNwbGF5VmFsdWUocHJvdG90eXBlTGFiZWwpOwotICAgICAgICBsaXN0Qm94KCkuc2V0UHJvdG90eXBlQ2VsbFZhbHVlKHByb3RvdHlwZUxhYmVsKTsKLQl9Ci0JCi0gICAgCi0gICAgcHJpdmF0ZSBKTGlzdCBsaXN0Qm94KCkgewotICAgICAgICByZXR1cm4gKEpMaXN0KSBDbGFzc1Rvb2xzLmZpZWxkVmFsdWUodGhpcy51aSwgImxpc3RCb3giKTsKLSAgICB9Ci0gICAgCi0JLyoqIAotCSAqIFdoZW4gdGhlIHBvcHVwIGlzIGFib3V0IHRvIGJlIHNob3duLCB0aGUgZXZlbnQgaXMgY29uc3VtZWQsIGFuZCAKLQkgKiBQb3B1cEhhbmRsZXIgZGV0ZXJtaW5lcyB3aGV0aGVyIHRvIHJlc2hvdyB0aGUgcG9wdXAgb3IgdG8gc2hvdwotCSAqIHRoZSBsb25nIGxpc3QgYnJvd3Nlci4KLQkgKi8KLQlwcml2YXRlIFBvcHVwTWVudUxpc3RlbmVyIGJ1aWxkUG9wdXBNZW51TGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUG9wdXBNZW51TGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwb3B1cE1lbnVXaWxsQmVjb21lVmlzaWJsZShQb3B1cE1lbnVFdmVudCBlKSB7Ci0JCQkJTGlzdENob29zZXIudGhpcy5hYm91dFRvU2hvd1BvcHVwKCk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBwb3B1cE1lbnVXaWxsQmVjb21lSW52aXNpYmxlKFBvcHVwTWVudUV2ZW50IGUpIHsKLQkJCQkvLyBkbyBub3RoaW5nCi0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBwb3B1cE1lbnVDYW5jZWxlZChQb3B1cE1lbnVFdmVudCBlKSB7Ci0JCQkJLy8gZG8gbm90aGluZwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJCXJldHVybiAicG9wLXVwIG1lbnUgbGlzdGVuZXIiOwotCQkJfQotCQl9OwotCX0KLQkKLQkvKioKLQkgKiBJZiB0aGlzIGNvZGUgaXMgYmVpbmcgcmVhY2hlZCBkdWUgdG8gdGhlIFBvcHVwSGFuZGxlciBhbHJlYWR5IGJlaW5nIGluIHByb2dyZXNzLAotCSAqIHRoZW4gZG8gbm90aGluZy4gIE90aGVyd2lzZSwgc2V0IHRoZSBmbGFnIHRvIHRydWUgYW5kIGxhdW5jaCB0aGUgUG9wdXBIYW5kbGVyLgotCSAqLwotCXZvaWQgYWJvdXRUb1Nob3dQb3B1cCgpIHsKLQkJaWYgKHRoaXMucG9wdXBBbHJlYWR5SW5Qcm9ncmVzcykgewotCQkJcmV0dXJuOwotCQl9Ci0JCQotCQl0aGlzLnBvcHVwQWxyZWFkeUluUHJvZ3Jlc3MgPSB0cnVlOwotCQlFdmVudFF1ZXVlLmludm9rZUxhdGVyKG5ldyBQb3B1cEhhbmRsZXIoKSk7Ci0JfQotIAotICAgIAotCXByaXZhdGUgS2V5TGlzdGVuZXIgYnVpbGRGM0tleUxpc3RlbmVyKCkgewotICAgICAgICByZXR1cm4gbmV3IEtleUFkYXB0ZXIoKSB7Ci0gICAgICAgICAgICBAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGtleVByZXNzZWQoS2V5RXZlbnQgZSkgewotICAgICAgICAgICAgICAgIGlmIChlLmdldEtleUNvZGUoKSA9PSBLZXlFdmVudC5WS19GMykgewotICAgICAgICAgICAgICAgICAgICBnb1RvU2VsZWN0ZWRJdGVtKCk7Ci0gICAgICAgICAgICAgICAgfSAgICAgICAgICAgICAgICAKLSAgICAgICAgICAgIH0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCQlyZXR1cm4gIkYzIGtleSBsaXN0ZW5lciI7Ci0JCQl9Ci0gICAgICAgIH07Ci0gICAgfQotICAgIAotICAgIHB1YmxpYyB2b2lkIGdvVG9TZWxlY3RlZEl0ZW0oKSB7Ci0gICAgICAgIGlmIChnZXRTZWxlY3RlZEl0ZW0oKSAhPSBudWxsKSB7Ci0gICAgICAgICAgICBMaXN0Q2hvb3Nlci50aGlzLm5vZGVTZWxlY3Rvci5zZWxlY3ROb2RlRm9yKGdldFNlbGVjdGVkSXRlbSgpKTsKLSAgICAgICAgfQotICAgIH0KLSAgICAKLQkvLyAqKioqKioqKioqKioqKioqIEJyb3dzaW5nICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLQkKLQkvKiogCi0JICogTGF6aWx5IGluaXRpYWxpemUgYmVjYXVzZSBzdWJjbGFzc2VzIG1heSBoYXZlIGZ1cnRoZXIgaW5pdGlhbGl6YXRpb24gdG8gZG8KLQkgKiBiZWZvcmUgYnJvd3NlciBjYW4gYmUgYnVpbHQuCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgYnJvd3NlKCkgewotCQlpZiAodGhpcy5icm93c2VyID09IG51bGwpIHsKLQkJCXRoaXMuYnJvd3NlciA9IHRoaXMuYnVpbGRCcm93c2VyKCk7Ci0JCX0KLQkJCi0JCXRoaXMuYnJvd3Nlci5icm93c2UodGhpcyk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgImJyb3dzZXIiIHVzZWQgdG8gbWFrZSBhIHNlbGVjdGlvbiBmcm9tIHRoZSBsb25nIGxpc3QsCi0JICogdHlwaWNhbGx5IHZpYSBhIGRpYWxvZy4KLQkgKi8KLQlwcm90ZWN0ZWQgTGlzdENob29zZXIuTGlzdEJyb3dzZXIgYnVpbGRCcm93c2VyKCkgewotCQlyZXR1cm4gbmV3IFNpbXBsZUxpc3RCcm93c2VyKCk7Ci0JfQotCQotCQotCS8vICoqKioqKioqKioqKioqKiogQ2hvb3NhYmxlIGZ1bmN0aW9uYWxpdHkgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotCQotCS8qKiBvdmVycmlkZSBiZWhhdmlvciAtIGNvbnN1bWUgc2VsZWN0aW9uIGlmIGNob29zZXIgaXMgbm90IGNob29zYWJsZSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHNldFNlbGVjdGVkSW5kZXgoaW50IGFuSW5kZXgpIHsKLQkJaWYgKHRoaXMuY2hvb3NhYmxlKSB7Ci0JCQlzdXBlci5zZXRTZWxlY3RlZEluZGV4KGFuSW5kZXgpOwotCQl9Ci0JfQotCQotCXByaXZhdGUgdm9pZCB1cGRhdGVBcnJvd0J1dHRvbigpIHsKLQkJdHJ5IHsKLQkJCUJhc2ljQ29tYm9Cb3hVSSBjb21ib0JveFVpID0gKEJhc2ljQ29tYm9Cb3hVSSkgTGlzdENob29zZXIudGhpcy5nZXRVSSgpOwotCQkJSkJ1dHRvbiBhcnJvd0J1dHRvbiA9IChKQnV0dG9uKSBDbGFzc1Rvb2xzLmZpZWxkVmFsdWUoY29tYm9Cb3hVaSwgImFycm93QnV0dG9uIik7Ci0JCQlhcnJvd0J1dHRvbi5zZXRFbmFibGVkKHRoaXMuaXNFbmFibGVkKCkgJiYgdGhpcy5jaG9vc2FibGUpOwotCQl9Ci0JCWNhdGNoIChFeGNlcHRpb24gZSkgewotCQkJLy8gdGhpcyBpcyBhIGh1Z2UgaGFjayB0byB0cnkgYW5kIG1ha2UgdGhlIGNvbWJvIGJveCBsb29rIHJpZ2h0LAotCQkJLy8gc28gaWYgaXQgZG9lc24ndCB3b3JrLCBqdXN0IHN3YWxsb3cgdGhlIGV4Y2VwdGlvbgotCQl9Ci0JfQotCQotCQotICAgIC8vICoqKioqKioqKioqKioqKiogTGlzdCBDYWNoaW5nICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLQotICAgIHZvaWQgY2FjaGVMaXN0KCkgewotICAgICAgICAoKENhY2hpbmdDb21ib0JveE1vZGVsKSBnZXRNb2RlbCgpKS5jYWNoZUxpc3QoKTsKLSAgICB9Ci0gICAgCi0gICAgdm9pZCB1bmNhY2hlTGlzdCgpIHsKLSAgICAgICAgKChDYWNoaW5nQ29tYm9Cb3hNb2RlbCkgZ2V0TW9kZWwoKSkudW5jYWNoZUxpc3QoKTsKLSAgICB9Ci0KLSAgICBib29sZWFuIGxpc3RJc0NhY2hlZCgpIHsKLSAgICAgICAgcmV0dXJuICgoQ2FjaGluZ0NvbWJvQm94TW9kZWwpIGdldE1vZGVsKCkpLmlzQ2FjaGVkKCk7Ci0gICAgfQotICAgIAotCS8vICoqKioqKioqKioqKioqKiogUHVibGljICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotCQotCXB1YmxpYyBpbnQgbG9uZ0xpc3RTaXplKCkgewotCQlyZXR1cm4gdGhpcy5sb25nTGlzdFNpemU7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHNldExvbmdMaXN0U2l6ZShpbnQgbmV3TG9uZ0xpc3RTaXplKSB7Ci0JCWludCBvbGRMb25nTGlzdFNpemUgPSB0aGlzLmxvbmdMaXN0U2l6ZTsKLQkJdGhpcy5sb25nTGlzdFNpemUgPSBuZXdMb25nTGlzdFNpemU7Ci0JCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlKExPTkdfTElTVF9TSVpFX1BST1BFUlRZLCBvbGRMb25nTGlzdFNpemUsIG5ld0xvbmdMaXN0U2l6ZSk7Ci0JfQotCQotCXB1YmxpYyBib29sZWFuIGlzQ2hvb3NhYmxlKCkgewotCQlyZXR1cm4gdGhpcy5jaG9vc2FibGU7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHNldENob29zYWJsZShib29sZWFuIG5ld1ZhbHVlKSB7Ci0JCWJvb2xlYW4gb2xkVmFsdWUgPSB0aGlzLmNob29zYWJsZTsKLQkJdGhpcy5jaG9vc2FibGUgPSBuZXdWYWx1ZTsKLQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2UoQ0hPT1NBQkxFX1BST1BFUlRZLCBvbGRWYWx1ZSwgbmV3VmFsdWUpOwotCQl0aGlzLnVwZGF0ZUFycm93QnV0dG9uKCk7Ci0JfQotCQotCS8vICoqKioqKioqKioqKioqKiogSGFuZGxlIHNlbGVjdGluZyBudWxsIGFzIGEgdmFsdWUgKioqKioqKioqKioqKioqKioqKioqKgotCi0JcHJpdmF0ZSBib29sZWFuIHNlbGVjdGVkSW5kZXhJc05vbmVTZWxlY3RlZEl0ZW0oaW50IGluZGV4KSB7Ci0JCXJldHVybiBpbmRleCA9PSAtMSAmJgotCQkJCSBnZXRNb2RlbCgpLmdldFNpemUoKSA+IDAgJiYKLQkJCQkgZ2V0TW9kZWwoKS5nZXRFbGVtZW50QXQoMCkgPT0gbnVsbDsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgaW50IGdldFNlbGVjdGVkSW5kZXgoKSB7Ci0gICAgICAgIGJvb2xlYW4gbGlzdE5vdENhY2hlZCA9ICFsaXN0SXNDYWNoZWQoKTsKLSAgICAgICAgaWYgKGxpc3ROb3RDYWNoZWQpIHsKLSAgICAgICAgICAgIGNhY2hlTGlzdCgpOwotICAgICAgICB9Ci0gICAgICAgIAotCQlpbnQgaW5kZXggPSBzdXBlci5nZXRTZWxlY3RlZEluZGV4KCk7Ci0KLQkJLy8gVXNlIGluZGV4IDAgdG8gc2hvdyB0aGUgPG5vbmUgc2VsZWN0ZWQ+IGl0ZW0gc2luY2UgdGhlIGFjdHVhbCB2YWx1ZSBpcwotCQkvLyBudWxsIGFuZCBKQ29tYm9Cb3ggZG9lcyBub3QgaGFuZGxlIG51bGwgdmFsdWVzCi0JCWlmIChzZWxlY3RlZEluZGV4SXNOb25lU2VsZWN0ZWRJdGVtKGluZGV4KSkgewotCQkJaW5kZXggPSAwOwotICAgICAgICB9Ci0KLSAgICAgICAgaWYgKGxpc3ROb3RDYWNoZWQpIHsKLSAgICAgICAgICAgIHVuY2FjaGVMaXN0KCk7Ci0gICAgICAgIH0KLQkJcmV0dXJuIGluZGV4OwotICAgfQotCQotCS8vd3JhcCB0aGUgcmVuZGVyZXIgdG8gZGVhbCB3aXRoIHRoZSBwcm90b3R5cGVEaXNwbGF5VmFsdWUKLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCBzZXRSZW5kZXJlcihmaW5hbCBMaXN0Q2VsbFJlbmRlcmVyIGFSZW5kZXJlcikgewotICAgICAgICBzdXBlci5zZXRSZW5kZXJlcihuZXcgTGlzdENlbGxSZW5kZXJlcigpewotICAgICAgICAgICAgcHVibGljIENvbXBvbmVudCBnZXRMaXN0Q2VsbFJlbmRlcmVyQ29tcG9uZW50KEpMaXN0IGxpc3QsIE9iamVjdCB2YWx1ZSwgaW50IGluZGV4LCBib29sZWFuIGlzU2VsZWN0ZWQsIGJvb2xlYW4gY2VsbEhhc0ZvY3VzKSB7Ci0gICAgICAgICAgICAgICAgaWYgKHZhbHVlID09IHByb3RvdHlwZUxhYmVsKSB7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBwcm90b3R5cGVMYWJlbDsKLSAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgcmV0dXJuIGFSZW5kZXJlci5nZXRMaXN0Q2VsbFJlbmRlcmVyQ29tcG9uZW50KGxpc3QsIHZhbHVlLCBpbmRleCwgaXNTZWxlY3RlZCwgY2VsbEhhc0ZvY3VzKTsKLSAgICAgICAgICAgIH0KLSAgICAgICAgfSk7Ci0gICAgfQotICAgIAotICAgIAotCS8vICoqKioqKioqKioqKioqKiogTWVtYmVyIGNsYXNzZXMgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotCQotCS8qKgotCSAqIERlZmluZSB0aGUgQVBJIHJlcXVpcmVkIGJ5IHRoaXMgTGlzdENob29zZXIgd2hlbiBpdCBtdXN0Ci0JICogcHJvbXB0IHRoZSB1c2VyIHRvIHNlbGVjdCBhbiBpdGVtIGZyb20gdGhlICJsb25nIiBsaXN0LgotCSAqLwotCXB1YmxpYyBpbnRlcmZhY2UgTGlzdEJyb3dzZXIgCi0JewotCQkvKioKLQkJICogUHJvbXB0IHRoZSB1c2VyIHRvIG1ha2UgYSBzZWxlY3Rpb24gZnJvbSB0aGUgc3BlY2lmaWVkCi0JCSAqIGNvbWJvLWJveCdzIG1vZGVsLgotCQkgKi8KLQkJdm9pZCBicm93c2UoTGlzdENob29zZXIgcGFyZW50Q2hvb3Nlcik7Ci0JfQotCQotCQotCS8qKgotCSAqIFJ1bm5hYmxlIGNsYXNzIHRoYXQgY29uc3VtZXMgcG9wdXAgd2luZG93IGFuZCBkZXRlcm1pbmVzIHdoZXRoZXIKLQkgKiB0byByZXNob3cgcG9wdXAgb3IgdG8gbGF1bmNoIGJyb3dzZXIsIGJhc2VkIG9uIHRoZSBzaXplIG9mIHRoZSBsaXN0LgotCSAqLwotCXByaXZhdGUgY2xhc3MgUG9wdXBIYW5kbGVyCi0JCWltcGxlbWVudHMgUnVubmFibGUKLQl7Ci0JCS8qKiBUaGUgbW91c2UgZXZlbnQgKi8KLQkJcHJpdmF0ZSBNb3VzZUV2ZW50IGxhc3RNb3VzZUV2ZW50OwotCQkKLQkJLyoqIFRoZSBjb21wb25lbnQgZnJvbSB3aGljaCB0aGUgbGFzdCBtb3VzZSBldmVudCB3YXMgdGhyb3duICovCi0JCXByaXZhdGUgSkNvbXBvbmVudCBldmVudENvbXBvbmVudDsKLQkJCi0JCS8qKiBUaGUgbG9jYXRpb24gb2YgdGhlIGNvbXBvbmVudCBhdCB0aGUgdGltZSB0aGUgbGFzdCBtb3VzZSBldmVudCB3YXMgdGhyb3duICovCi0JCXByaXZhdGUgUG9pbnQgY29tcG9uZW50TG9jYXRpb247Ci0JCQotCQkvKiogVGhlIGxvY2F0aW9uIG9mIHRoZSBtb3VzZSBhdCB0aGUgdGltZSB0aGUgbGFzdCBtb3VzZSBldmVudCB3YXMgdGhyb3duICovCi0JCXByaXZhdGUgUG9pbnQgbW91c2VMb2NhdGlvbjsKLQkJCi0JCQotCQlQb3B1cEhhbmRsZXIoKSB7Ci0JCQl0aGlzLmluaXRpYWxpemUoKTsKLQkJfQotCQkKLQkJcHJpdmF0ZSB2b2lkIGluaXRpYWxpemUoKSB7Ci0JCQlBV1RFdmVudCBldmVudCA9IEV2ZW50UXVldWUuZ2V0Q3VycmVudEV2ZW50KCk7Ci0JCQkKLQkJCWlmIChldmVudCBpbnN0YW5jZW9mIE1vdXNlRXZlbnQpIHsKLQkJCQl0aGlzLmxhc3RNb3VzZUV2ZW50ID0gKE1vdXNlRXZlbnQpIGV2ZW50OwotCQkJCXRoaXMuZXZlbnRDb21wb25lbnQgPSAoSkNvbXBvbmVudCkgdGhpcy5sYXN0TW91c2VFdmVudC5nZXRTb3VyY2UoKTsKLQkJCQl0aGlzLmNvbXBvbmVudExvY2F0aW9uID0gdGhpcy5ldmVudENvbXBvbmVudC5nZXRMb2NhdGlvbk9uU2NyZWVuKCk7Ci0JCQkJdGhpcy5tb3VzZUxvY2F0aW9uID0gdGhpcy5sYXN0TW91c2VFdmVudC5nZXRQb2ludCgpOwotCQkJfQotCQkJZWxzZSB7Ci0JCQkJdGhpcy5ldmVudENvbXBvbmVudCA9IG51bGw7Ci0JCQkJdGhpcy5jb21wb25lbnRMb2NhdGlvbiA9IG51bGw7Ci0JCQkJdGhpcy5tb3VzZUxvY2F0aW9uID0gbnVsbDsKLQkJCX0KLQkJfQotCQkKLQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJTGlzdENob29zZXIudGhpcy5oaWRlUG9wdXAoKTsKLQkJCQotICAgICAgICAgICAgY2FjaGVMaXN0KCk7Ci0JCQlpZiAoTGlzdENob29zZXIudGhpcy5jaG9vc2FibGUgPT0gdHJ1ZSkgewotCQkJCS8vIElmIHRoZSBjb21ibyBib3ggbW9kZWwgaXMgb2Ygc3VmZmljaWVudCBsZW5ndGgsIHRoZSBicm93c2VyIHdpbGwgYmUgc2hvd24uCi0JCQkJLy8gQXNraW5nIHRoZSBjb21ibyBib3ggbW9kZWwgZm9yIGl0cyBzaXplIHNob3VsZCBiZSBlbm91Z2ggdG8gZW5zdXJlIHRoYXQgCi0JCQkJLy8gIGl0cyBzaXplIGlzIHJlY2FsY3VsYXRlZC4KLQkJCQlpZiAoTGlzdENob29zZXIudGhpcy5nZXRNb2RlbCgpLmdldFNpemUoKSA+IExpc3RDaG9vc2VyLnRoaXMubG9uZ0xpc3RTaXplKSB7Ci0JCQkJCXRoaXMuY2hlY2tDb21ib0JveEJ1dHRvbigpOwotCQkJCQlMaXN0Q2hvb3Nlci50aGlzLmJyb3dzZSgpOwotCQkJCX0KLQkJCQllbHNlIHsKLQkJCQkJTGlzdENob29zZXIudGhpcy5zaG93UG9wdXAoKTsKLQkJCQkJdGhpcy5jaGVja01vdXNlUG9zaXRpb24oKTsKLQkJCQl9Ci0JCQl9Ci0gICAgICAgICAgICBpZiAobGlzdElzQ2FjaGVkKCkpIHsKLSAgICAgICAgICAgICAgICB1bmNhY2hlTGlzdCgpOwotICAgICAgICAgICAgfQotCQkJCi0JCQlMaXN0Q2hvb3Nlci50aGlzLnBvcHVwQWxyZWFkeUluUHJvZ3Jlc3MgPSBmYWxzZTsKLQkJfQotCQkKLQkJLyoqIElmIHRoaXMgaXMgbm90IGRvbmUsIHRoZSBidXR0b24gbmV2ZXIgYmVjb21lcyB1bi1wcmVzc2VkICovCi0JCXByaXZhdGUgdm9pZCBjaGVja0NvbWJvQm94QnV0dG9uKCkgewotCQkJdHJ5IHsKLQkJCQlCYXNpY0NvbWJvQm94VUkgY29tYm9Cb3hVaSA9IChCYXNpY0NvbWJvQm94VUkpIExpc3RDaG9vc2VyLnRoaXMuZ2V0VUkoKTsKLQkJCQlKQnV0dG9uIGFycm93QnV0dG9uID0gKEpCdXR0b24pIENsYXNzVG9vbHMuZmllbGRWYWx1ZShjb21ib0JveFVpLCAiYXJyb3dCdXR0b24iKTsKLQkJCQlhcnJvd0J1dHRvbi5nZXRNb2RlbCgpLnNldFByZXNzZWQoZmFsc2UpOwotCQkJfQotCQkJY2F0Y2ggKEV4Y2VwdGlvbiBlKSB7Ci0JCQkJLy8gdGhpcyBpcyBhIGh1Z2UgaGFjayB0byB0cnkgYW5kIG1ha2UgdGhlIGNvbWJvIGJveCBsb29rIHJpZ2h0LAotCQkJCS8vIHNvIGlmIGl0IGRvZXNuJ3Qgd29yaywganVzdCBzd2FsbG93IHRoZSBleGNlcHRpb24KLQkJCX0KLQkJfQotCQkKLQkJLyoqCi0JCSAqIE1vdmVzIHRoZSBtb3VzZSBiYWNrIHRvIGl0cyBvcmlnaW5hbCBwb3NpdGlvbiBiZWZvcmUgYW55IGppZ2dlcnkgcG9rZXJ5IHRoYXQgd2UndmUgZG9uZS4KLQkJICovCi0JCXByaXZhdGUgdm9pZCBjaGVja01vdXNlUG9zaXRpb24oKSB7Ci0JCQlpZiAodGhpcy5ldmVudENvbXBvbmVudCA9PSBudWxsKSB7Ci0JCQkJcmV0dXJuOwotCQkJfQotCQkJCi0JCQlmaW5hbCBQb2ludCBuZXdDb21wb25lbnRMb2NhdGlvbiA9IHRoaXMuZXZlbnRDb21wb25lbnQuZ2V0TG9jYXRpb25PblNjcmVlbigpOwotCQkJYm9vbGVhbiBjb21wb25lbnRNb3ZlZCA9IAotCQkJCW5ld0NvbXBvbmVudExvY2F0aW9uLnggLSB0aGlzLmNvbXBvbmVudExvY2F0aW9uLnggIT0gMAotCQkJCXx8IG5ld0NvbXBvbmVudExvY2F0aW9uLnkgLSB0aGlzLmNvbXBvbmVudExvY2F0aW9uLnkgIT0gMDsKLQkJCQotCQkJaWYgKGNvbXBvbmVudE1vdmVkKSB7Ci0JCQkJdHJ5IHsKLQkJCQkJbmV3IFJvYm90KCkubW91c2VNb3ZlKAotCQkJCQkJbmV3Q29tcG9uZW50TG9jYXRpb24ueCArIHRoaXMubW91c2VMb2NhdGlvbi54LAotCQkJCQkJbmV3Q29tcG9uZW50TG9jYXRpb24ueSArIHRoaXMubW91c2VMb2NhdGlvbi55Ci0JCQkJCSk7Ci0JCQkJfQotCQkJCWNhdGNoIChBV1RFeGNlcHRpb24gZXgpIHsKLQkJCQkJLy8gbW92ZSBmYWlsZWQgLSBkbyBub3RoaW5nCi0JCQkJfQotCQkJfQotCQl9Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL05vZGVTZWxlY3Rvci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL05vZGVTZWxlY3Rvci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmOGI0ZDE0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9Ob2RlU2VsZWN0b3IuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDMyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuc3dpbmc7Ci0KLS8qKgotICogVGhpcyB3aWxsIGJlIGNhbGxlZCB3aGVuIHRoZSB1c2VyIHByZXNzZXMgRjMgb3IgY2hvb3NlcwotICogJ0dvIFRvJyBpbiB0aGUgY29udGV4dCBtZW51Ci0gKi8KLXB1YmxpYyBpbnRlcmZhY2UgTm9kZVNlbGVjdG9yIAoteyAgICAgICAKLSAgICAvKioKLSAgICAgKiBTZWxlY3QgdGhlIGFwcHJvcHJpYXRlIE5vZGUgaW4gdGhlIHRyZWUgb3IgdGhlIGVkaXRvciBwYW5lbC4KLSAgICAgKi8KLSAgICB2b2lkIHNlbGVjdE5vZGVGb3IoT2JqZWN0IGl0ZW0pOwotICAgIAotICAgIC8qKgotICAgICAqIFRoaXMgTm9kZVNlbGVjdG9yIHdpbGwgZG8gbm90aGluZyB3aGVuIHNlbGVjdE5vZGVGb3IoT2JqZWN0KSBpcyBjYWxsZWQKLSAgICAgKi8KLSAgICBjbGFzcyBEZWZhdWx0Tm9kZVNlbGVjdG9yIGltcGxlbWVudHMgTm9kZVNlbGVjdG9yIHsKLSAgICAgICAgCi0gICAgICAgIHB1YmxpYyB2b2lkIHNlbGVjdE5vZGVGb3IoT2JqZWN0IGl0ZW0pIHsKLSAgICAgICAgICAgIC8vZGVmYXVsdCBpcyB0byBkbyBub3RoaW5nCi0gICAgICAgIH0KLSAgICB9Ci19ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL05vbkNhY2hpbmdDb21ib0JveE1vZGVsLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvc3dpbmcvTm9uQ2FjaGluZ0NvbWJvQm94TW9kZWwuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWU3MjI2NC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvc3dpbmcvTm9uQ2FjaGluZ0NvbWJvQm94TW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDczICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuc3dpbmc7Ci0KLWltcG9ydCBqYXZheC5zd2luZy5Db21ib0JveE1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50Lkxpc3REYXRhTGlzdGVuZXI7Ci0KLS8qKgotICogVGhpcyBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgQ2FjaGluZ0NvbWJvQm94TW9kZWwgaW50ZXJmYWNlIGNhbiBiZSB1c2VkCi0gKiB3aGVuZXZlciB0aGVyZSBpcyBubyBuZWVkIGZvciBjYWNoaW5nIChpLmUuIHRoZSBjb250ZW50cyBvZiB0aGUgc2VsZWN0aW9uCi0gKiBsaXN0IGNhbiBiZSBnZW5lcmF0ZWQgd2l0aCBsaXR0bGUgbGF0ZW5jeSkuIEFsbCB0aGUgbm9ybWFsIENvbWJvQm94TW9kZWwKLSAqIGJlaGF2aW9yIGlzIGRlbGVnYXRlZCB0byBhIGNsaWVudC1zdXBwbGllZCBDb21ib0JveE1vZGVsLgotICovCi1wdWJsaWMgY2xhc3MgTm9uQ2FjaGluZ0NvbWJvQm94TW9kZWwgaW1wbGVtZW50cyBDYWNoaW5nQ29tYm9Cb3hNb2RlbCB7Ci0JcHJpdmF0ZSBDb21ib0JveE1vZGVsIHdyYXBwZWRDb21ib0JveE1vZGVsOwotCi0JcHVibGljIE5vbkNhY2hpbmdDb21ib0JveE1vZGVsKENvbWJvQm94TW9kZWwgd3JhcHBlZENvbWJvQm94TW9kZWwpIHsKLQkJdGhpcy53cmFwcGVkQ29tYm9Cb3hNb2RlbCA9IHdyYXBwZWRDb21ib0JveE1vZGVsOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBDYWNoaW5nQ29tYm9Cb3hNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgdm9pZCBjYWNoZUxpc3QoKSB7Ci0JCS8vZG8gbm90aGluZwotCX0KLQotCXB1YmxpYyB2b2lkIHVuY2FjaGVMaXN0KCkgewotCQkvL2RvIG5vdGhpbmcKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBpc0NhY2hlZCgpIHsKLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBDb21ib0JveE1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIHNldFNlbGVjdGVkSXRlbShPYmplY3QgYW5JdGVtKSB7Ci0JCXRoaXMud3JhcHBlZENvbWJvQm94TW9kZWwuc2V0U2VsZWN0ZWRJdGVtKGFuSXRlbSk7Ci0JfQotCi0JcHVibGljIE9iamVjdCBnZXRTZWxlY3RlZEl0ZW0oKSB7Ci0JCXJldHVybiB0aGlzLndyYXBwZWRDb21ib0JveE1vZGVsLmdldFNlbGVjdGVkSXRlbSgpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBMaXN0TW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIGludCBnZXRTaXplKCkgewotCQlyZXR1cm4gdGhpcy53cmFwcGVkQ29tYm9Cb3hNb2RlbC5nZXRTaXplKCk7Ci0JfQotCi0JcHVibGljIE9iamVjdCBnZXRFbGVtZW50QXQoaW50IGluZGV4KSB7Ci0JCXJldHVybiB0aGlzLndyYXBwZWRDb21ib0JveE1vZGVsLmdldEVsZW1lbnRBdChpbmRleCk7Ci0JfQotCi0JcHVibGljIHZvaWQgYWRkTGlzdERhdGFMaXN0ZW5lcihMaXN0RGF0YUxpc3RlbmVyIGwpIHsKLQkJdGhpcy53cmFwcGVkQ29tYm9Cb3hNb2RlbC5hZGRMaXN0RGF0YUxpc3RlbmVyKGwpOwotCX0KLQotCXB1YmxpYyB2b2lkIHJlbW92ZUxpc3REYXRhTGlzdGVuZXIoTGlzdERhdGFMaXN0ZW5lciBsKSB7Ci0JCXRoaXMud3JhcHBlZENvbWJvQm94TW9kZWwucmVtb3ZlTGlzdERhdGFMaXN0ZW5lcihsKTsKLQl9ICAKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL1NpbXBsZURpc3BsYXlhYmxlLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvc3dpbmcvU2ltcGxlRGlzcGxheWFibGUuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOGQ1YWE0NS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvc3dpbmcvU2ltcGxlRGlzcGxheWFibGUuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE3NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLnN3aW5nOwotCi1pbXBvcnQgamF2YXguc3dpbmcuSWNvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotCi0vKioKLSAqIFRoaXMgaW1wbGVtZW50YXRpb24gb2YgRGlzcGxheWFibGUgY29udmVydHMgYW55IE9iamVjdAotICogdG8gYSBEaXNwbGF5YWJsZS4gU3ViY2xhc3MgaXQgdG8gb3ZlcnJpZGUgI2Rpc3BsYXlTdHJpbmcoKSBhbmQKLSAqICNpY29uKCkgaWYgbmVjZXNzYXJ5LiBDaGFuZ2Ugbm90aWZpY2F0aW9uIHdpbGwgYmUgZmlyZWQgaWYgdGhlCi0gKiBvYmplY3QgaXMgY2hhbmdlZC4KLSAqIAotICogVGhpcyBjYW4gYmUgdXNlZCBmb3IgU3RyaW5ncyAtIHRoZSBkaXNwbGF5IHN0cmluZwotICogd2lsbCBzaW1wbHkgYmUgdGhlIFN0cmluZyBpdHNlbGYuCi0gKi8KLXB1YmxpYyBjbGFzcyBTaW1wbGVEaXNwbGF5YWJsZQotCWV4dGVuZHMgQWJzdHJhY3RNb2RlbAotCWltcGxlbWVudHMgRGlzcGxheWFibGUKLXsKLQkvKiogVGhlIG9iamVjdCB0byBiZSBjb252ZXJ0ZWQgdG8gYSBEaXNwbGF5YWJsZS4gKi8KLQlwcm90ZWN0ZWQgT2JqZWN0IG9iamVjdDsKLQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgZGlzcGxheWFibGUgZm9yIHRoZSBzcGVjaWZpZWQgb2JqZWN0LgotCSAqLwotCXB1YmxpYyBTaW1wbGVEaXNwbGF5YWJsZShPYmplY3Qgb2JqZWN0KSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMub2JqZWN0ID0gb2JqZWN0OwotCX0KLQotCXB1YmxpYyBTaW1wbGVEaXNwbGF5YWJsZShib29sZWFuIGIpIHsKLQkJdGhpcyhCb29sZWFuLnZhbHVlT2YoYikpOwotCX0KLQotCXB1YmxpYyBTaW1wbGVEaXNwbGF5YWJsZShjaGFyIGMpIHsKLQkJdGhpcyhuZXcgQ2hhcmFjdGVyKGMpKTsKLQl9Ci0KLQlwdWJsaWMgU2ltcGxlRGlzcGxheWFibGUoYnl0ZSBiKSB7Ci0JCXRoaXMobmV3IEJ5dGUoYikpOwotCX0KLQotCXB1YmxpYyBTaW1wbGVEaXNwbGF5YWJsZShzaG9ydCBzKSB7Ci0JCXRoaXMobmV3IFNob3J0KHMpKTsKLQl9Ci0KLQlwdWJsaWMgU2ltcGxlRGlzcGxheWFibGUoaW50IGkpIHsKLQkJdGhpcyhuZXcgSW50ZWdlcihpKSk7Ci0JfQotCi0JcHVibGljIFNpbXBsZURpc3BsYXlhYmxlKGxvbmcgbCkgewotCQl0aGlzKG5ldyBMb25nKGwpKTsKLQl9Ci0KLQlwdWJsaWMgU2ltcGxlRGlzcGxheWFibGUoZmxvYXQgZikgewotCQl0aGlzKG5ldyBGbG9hdChmKSk7Ci0JfQotCi0JcHVibGljIFNpbXBsZURpc3BsYXlhYmxlKGRvdWJsZSBkKSB7Ci0JCXRoaXMobmV3IERvdWJsZShkKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIERpc3BsYXlhYmxlIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBTdHJpbmcgZGlzcGxheVN0cmluZygpIHsKLQkJcmV0dXJuIHRoaXMub2JqZWN0LnRvU3RyaW5nKCk7Ci0JfQotCi0JcHVibGljIEljb24gaWNvbigpIHsKLQkJcmV0dXJuIG51bGw7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIENvbXBhcmFibGUgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIGludCBjb21wYXJlVG8oRGlzcGxheWFibGUgbykgewotCQlyZXR1cm4gREVGQVVMVF9DT01QQVJBVE9SLmNvbXBhcmUodGhpcywgbyk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGFjY2Vzc29ycyAqKioqKioqKioqCi0KLQlwdWJsaWMgT2JqZWN0IGdldE9iamVjdCgpIHsKLQkJcmV0dXJuIHRoaXMub2JqZWN0OwotCX0KLQotCXB1YmxpYyB2b2lkIHNldE9iamVjdChPYmplY3Qgb2JqZWN0KSB7Ci0JCVN0cmluZyBvbGREaXNwbGF5U3RyaW5nID0gdGhpcy5kaXNwbGF5U3RyaW5nKCk7Ci0JCUljb24gb2xkSWNvbiA9IHRoaXMuaWNvbigpOwotCQl0aGlzLm9iamVjdCA9IG9iamVjdDsKLQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKERJU1BMQVlfU1RSSU5HX1BST1BFUlRZLCBvbGREaXNwbGF5U3RyaW5nLCB0aGlzLmRpc3BsYXlTdHJpbmcoKSk7Ci0JCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChJQ09OX1BST1BFUlRZLCBvbGRJY29uLCB0aGlzLmljb24oKSk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gZ2V0Qm9vbGVhbigpIHsKLQkJcmV0dXJuICgoQm9vbGVhbikgdGhpcy5vYmplY3QpLmJvb2xlYW5WYWx1ZSgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHNldEJvb2xlYW4oYm9vbGVhbiBiKSB7Ci0JCXRoaXMuc2V0T2JqZWN0KEJvb2xlYW4udmFsdWVPZihiKSk7Ci0JfQotCi0JcHVibGljIGNoYXIgZ2V0Q2hhcigpIHsKLQkJcmV0dXJuICgoQ2hhcmFjdGVyKSB0aGlzLm9iamVjdCkuY2hhclZhbHVlKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0Q2hhcihjaGFyIGMpIHsKLQkJdGhpcy5zZXRPYmplY3QobmV3IENoYXJhY3RlcihjKSk7Ci0JfQotCi0JcHVibGljIGJ5dGUgZ2V0Qnl0ZSgpIHsKLQkJcmV0dXJuICgoQnl0ZSkgdGhpcy5vYmplY3QpLmJ5dGVWYWx1ZSgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHNldEJ5dGUoYnl0ZSBiKSB7Ci0JCXRoaXMuc2V0T2JqZWN0KG5ldyBCeXRlKGIpKTsKLQl9Ci0KLQlwdWJsaWMgc2hvcnQgZ2V0U2hvcnQoKSB7Ci0JCXJldHVybiAoKFNob3J0KSB0aGlzLm9iamVjdCkuc2hvcnRWYWx1ZSgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHNldFNob3J0KHNob3J0IHMpIHsKLQkJdGhpcy5zZXRPYmplY3QobmV3IFNob3J0KHMpKTsKLQl9Ci0KLQlwdWJsaWMgaW50IGdldEludCgpIHsKLQkJcmV0dXJuICgoSW50ZWdlcikgdGhpcy5vYmplY3QpLmludFZhbHVlKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0SW50KGludCBpKSB7Ci0JCXRoaXMuc2V0T2JqZWN0KG5ldyBJbnRlZ2VyKGkpKTsKLQl9Ci0KLQlwdWJsaWMgbG9uZyBnZXRMb25nKCkgewotCQlyZXR1cm4gKChMb25nKSB0aGlzLm9iamVjdCkubG9uZ1ZhbHVlKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0TG9uZyhsb25nIGwpIHsKLQkJdGhpcy5zZXRPYmplY3QobmV3IExvbmcobCkpOwotCX0KLQotCXB1YmxpYyBmbG9hdCBnZXRGbG9hdCgpIHsKLQkJcmV0dXJuICgoRmxvYXQpIHRoaXMub2JqZWN0KS5mbG9hdFZhbHVlKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgc2V0RmxvYXQoZmxvYXQgZikgewotCQl0aGlzLnNldE9iamVjdChuZXcgRmxvYXQoZikpOwotCX0KLQotCXB1YmxpYyBkb3VibGUgZ2V0RG91YmxlKCkgewotCQlyZXR1cm4gKChEb3VibGUpIHRoaXMub2JqZWN0KS5kb3VibGVWYWx1ZSgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHNldERvdWJsZShkb3VibGUgZCkgewotCQl0aGlzLnNldE9iamVjdChuZXcgRG91YmxlKGQpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogb3ZlcnJpZGUgbWV0aG9kcyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0b1N0cmluZyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCXNiLmFwcGVuZCh0aGlzLm9iamVjdCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvc3dpbmcvU2ltcGxlTGlzdEJyb3dzZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9TaW1wbGVMaXN0QnJvd3Nlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3MjE1YzZhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9TaW1wbGVMaXN0QnJvd3Nlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZzsKLQotaW1wb3J0IGphdmF4LnN3aW5nLkljb247Ci1pbXBvcnQgamF2YXguc3dpbmcuSkNvbWJvQm94OwotaW1wb3J0IGphdmF4LnN3aW5nLkpPcHRpb25QYW5lOwotaW1wb3J0IGphdmF4LnN3aW5nLkxpc3RNb2RlbDsKLQotLyoqCi0gKiBUaGlzIGltcGxlbWVudGF0aW9uIG9mIExpc3RDaG9vc2VyLkJyb3dzZXIgdXNlcyBhCi0gKiBKT3B0aW9uUGFuZSB0byBwcm9tcHQgdGhlIHVzZXIgZm9yIHRoZSBzZWxlY3Rpb24uIFN1YmNsYXNzZXMgCi0gKiBjYW4gY2hhbmdlIHRoZSBkaWFsb2cncyB0aXRsZSwgbWVzc2FnZSwgYW5kL29yIGljb24uCi0gKi8KLXB1YmxpYyBjbGFzcyBTaW1wbGVMaXN0QnJvd3NlcgotCWltcGxlbWVudHMgTGlzdENob29zZXIuTGlzdEJyb3dzZXIgCi17Ci0JLyoqIERlZmF1bHQgY29uc3RydWN0b3IgKi8KLQlwcm90ZWN0ZWQgU2ltcGxlTGlzdEJyb3dzZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQotCS8qKgotCSAqIFByb21wdCB0aGUgdXNlciB1c2luZyBhIEpPcHRpb25QYW5lLgotCSAqLwotCXB1YmxpYyB2b2lkIGJyb3dzZShMaXN0Q2hvb3NlciBjaG9vc2VyKSB7Ci0JCU9iamVjdCBzZWxlY3Rpb24gPSAKLQkJCUpPcHRpb25QYW5lLnNob3dJbnB1dERpYWxvZygKLQkJCQljaG9vc2VyLCAKLQkJCQl0aGlzLm1lc3NhZ2UoY2hvb3NlciksIAotCQkJCXRoaXMudGl0bGUoY2hvb3NlciksIAotCQkJCXRoaXMubWVzc2FnZVR5cGUoY2hvb3NlciksIAotCQkJCXRoaXMuaWNvbihjaG9vc2VyKSwgCi0JCQkJdGhpcy5zZWxlY3Rpb25WYWx1ZXMoY2hvb3NlciksIAotCQkJCXRoaXMuaW5pdGlhbFNlbGVjdGlvblZhbHVlKGNob29zZXIpCi0JCQkpOwotCQkKLQkJaWYgKHNlbGVjdGlvbiAhPSBudWxsKSB7Ci0JCQljaG9vc2VyLmdldE1vZGVsKCkuc2V0U2VsZWN0ZWRJdGVtKHNlbGVjdGlvbik7Ci0JCX0KLQl9Ci0JCi0JcHJvdGVjdGVkIE9iamVjdCBtZXNzYWdlKEpDb21ib0JveCBjb21ib0JveCkgewotCQlyZXR1cm4gbnVsbDsKLQl9Ci0JCi0JcHJvdGVjdGVkIFN0cmluZyB0aXRsZShKQ29tYm9Cb3ggY29tYm9Cb3gpIHsKLQkJcmV0dXJuIG51bGw7Ci0JfQotCQotCXByb3RlY3RlZCBpbnQgbWVzc2FnZVR5cGUoSkNvbWJvQm94IGNvbWJvQm94KSB7Ci0JCXJldHVybiBKT3B0aW9uUGFuZS5RVUVTVElPTl9NRVNTQUdFOwotCX0KLQkKLQlwcm90ZWN0ZWQgSWNvbiBpY29uKEpDb21ib0JveCBjb21ib0JveCkgewotCQlyZXR1cm4gbnVsbDsKLQl9Ci0JCi0JcHJvdGVjdGVkIE9iamVjdFtdIHNlbGVjdGlvblZhbHVlcyhKQ29tYm9Cb3ggY29tYm9Cb3gpIHsKLQkJcmV0dXJuIHRoaXMuY29udmVydFRvQXJyYXkoY29tYm9Cb3guZ2V0TW9kZWwoKSk7Ci0JfQotCQotCXByb3RlY3RlZCBPYmplY3QgaW5pdGlhbFNlbGVjdGlvblZhbHVlKEpDb21ib0JveCBjb21ib0JveCkgewotCQlyZXR1cm4gY29tYm9Cb3guZ2V0TW9kZWwoKS5nZXRTZWxlY3RlZEl0ZW0oKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVydCB0aGUgbGlzdCBvZiBvYmplY3RzIGluIHRoZSBzcGVjaWZpZWQgbGlzdCBtb2RlbAotCSAqIGludG8gYW4gYXJyYXkuCi0JICovCi0JcHJvdGVjdGVkIE9iamVjdFtdIGNvbnZlcnRUb0FycmF5KExpc3RNb2RlbCBtb2RlbCkgewotCQlpbnQgc2l6ZSA9IG1vZGVsLmdldFNpemUoKTsKLQkJT2JqZWN0W10gcmVzdWx0ID0gbmV3IE9iamVjdFtzaXplXTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBzaXplOyBpKyspIHsKLQkJCXJlc3VsdFtpXSA9IG1vZGVsLmdldEVsZW1lbnRBdChpKTsKLQkJfQotCQlyZXR1cm4gcmVzdWx0OwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9TaW1wbGVMaXN0Q2VsbFJlbmRlcmVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvc3dpbmcvU2ltcGxlTGlzdENlbGxSZW5kZXJlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlYTY0OWJhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9TaW1wbGVMaXN0Q2VsbFJlbmRlcmVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMjggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZzsKLQotaW1wb3J0IGphdmEuYXd0LkNvbXBvbmVudDsKLWltcG9ydCBqYXZheC5zd2luZy5EZWZhdWx0TGlzdENlbGxSZW5kZXJlcjsKLWltcG9ydCBqYXZheC5zd2luZy5JY29uOwotaW1wb3J0IGphdmF4LnN3aW5nLkpMaXN0OwotCi0vKioKLSAqIFRoaXMgcmVuZGVyZXIgc2hvdWxkIGJlaGF2ZSB0aGUgc2FtZSBhcyB0aGUgRGVmYXVsdExpc3RDZWxsUmVuZGVyZXI7Ci0gKiBidXQgaXQgc2xpZ2h0bHkgcmVmYWN0b3JzIHRoZSBjYWxjdWxhdGlvbiBvZiB0aGUgaWNvbiBhbmQgdGV4dCBvZiB0aGUgbGlzdAotICogY2VsbCBzbyB0aGF0IHN1YmNsYXNzZXMgY2FuIGVhc2lseSBvdmVycmlkZSB0aGUgbWV0aG9kcyB0aGF0IGJ1aWxkCi0gKiB0aGUgaWNvbiBhbmQgdGV4dC4KLSAqIAotICogSW4gbW9zdCBjYXNlcywgeW91IG5lZWQgb25seSBvdmVycmlkZToKLSAqICAgICAjYnVpbGRJY29uKE9iamVjdCB2YWx1ZSkKLSAqICAgICAjYnVpbGRUZXh0KE9iamVjdCB2YWx1ZSkKLSAqLwotcHVibGljIGNsYXNzIFNpbXBsZUxpc3RDZWxsUmVuZGVyZXIKLQlleHRlbmRzIERlZmF1bHRMaXN0Q2VsbFJlbmRlcmVyCi17Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBzaW1wbGUgcmVuZGVyZXIuCi0JICovCi0JcHVibGljIFNpbXBsZUxpc3RDZWxsUmVuZGVyZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIENvbXBvbmVudCBnZXRMaXN0Q2VsbFJlbmRlcmVyQ29tcG9uZW50KEpMaXN0IGxpc3QsIE9iamVjdCB2YWx1ZSwgaW50IGluZGV4LCBib29sZWFuIGlzU2VsZWN0ZWQsIGJvb2xlYW4gY2VsbEhhc0ZvY3VzKSB7Ci0JCS8vIHN1YnN0aXR1dGUgbnVsbCBmb3IgdGhlIGNlbGwgdmFsdWUgc28gbm90aGluZyBpcyBkcmF3biBpbml0aWFsbHkuLi4KLQkJc3VwZXIuZ2V0TGlzdENlbGxSZW5kZXJlckNvbXBvbmVudChsaXN0LCBudWxsLCBpbmRleCwgaXNTZWxlY3RlZCwgY2VsbEhhc0ZvY3VzKTsKLQkJdGhpcy5zZXRPcGFxdWUodHJ1ZSk7Ci0KLQkJLy8gLi4udGhlbiBzZXQgdGhlIGljb24gYW5kIHRleHQgbWFudWFsbHkKLQkJdGhpcy5zZXRJY29uKHRoaXMuYnVpbGRJY29uKGxpc3QsIHZhbHVlLCBpbmRleCwgaXNTZWxlY3RlZCwgY2VsbEhhc0ZvY3VzKSk7Ci0JCXRoaXMuc2V0VGV4dCh0aGlzLmJ1aWxkVGV4dChsaXN0LCB2YWx1ZSwgaW5kZXgsIGlzU2VsZWN0ZWQsIGNlbGxIYXNGb2N1cykpOwotCi0JCXRoaXMuc2V0VG9vbFRpcFRleHQodGhpcy5idWlsZFRvb2xUaXBUZXh0KGxpc3QsIHZhbHVlLCBpbmRleCwgaXNTZWxlY3RlZCwgY2VsbEhhc0ZvY3VzKSk7Ci0KLQkJLy8gdGhlIGNvbnRleHQgd2lsbCBiZSBpbml0aWFsaXplZCBvbmx5IGlmIGEgcmVhZGVyIGlzIHJ1bm5pbmcKLQkJaWYgKHRoaXMuYWNjZXNzaWJsZUNvbnRleHQgIT0gbnVsbCkgewotCQkJdGhpcy5hY2Nlc3NpYmxlQ29udGV4dC5zZXRBY2Nlc3NpYmxlTmFtZSh0aGlzLmJ1aWxkQWNjZXNzaWJsZU5hbWUobGlzdCwgdmFsdWUsIGluZGV4LCBpc1NlbGVjdGVkLCBjZWxsSGFzRm9jdXMpKTsKLQkJfQotCi0JCXJldHVybiB0aGlzOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgaWNvbiByZXByZXNlbnRhdGlvbiBvZiB0aGUgc3BlY2lmaWVkIGNlbGwKLQkgKiB2YWx1ZSBhbmQgb3RoZXIgc2V0dGluZ3MuIChFdmVuIG1vcmUgc2V0dGluZ3MgYXJlCi0JICogYWNjZXNzaWJsZSB2aWEgaW5oZXJpdGVkIGdldHRlcnM6IGhhc0ZvY3VzLCBpc0VuYWJsZWQsIGV0Yy4pCi0JICovCi0JcHJvdGVjdGVkIEljb24gYnVpbGRJY29uKEpMaXN0IGxpc3QsIE9iamVjdCB2YWx1ZSwgaW50IGluZGV4LCBib29sZWFuIGlzU2VsZWN0ZWQsIGJvb2xlYW4gY2VsbEhhc0ZvY3VzKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkSWNvbih2YWx1ZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBpY29uIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBzcGVjaWZpZWQgY2VsbAotCSAqIHZhbHVlLiBUaGUgZGVmYXVsdCBpcyB0byBkaXNwbGF5IG5vIGljb24gYXQgYWxsIHVubGVzcyB0aGUKLQkgKiB2YWx1ZSBpdHNlbGYgaXMgYW4gaWNvbi4KLQkgKi8KLQlwcm90ZWN0ZWQgSWNvbiBidWlsZEljb24oT2JqZWN0IHZhbHVlKSB7Ci0JCS8vIHJlcGxpY2F0ZSB0aGUgZGVmYXVsdCBiZWhhdmlvcgotCQlyZXR1cm4gKHZhbHVlIGluc3RhbmNlb2YgSWNvbikgPyAoSWNvbikgdmFsdWUgOiBudWxsOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgdGV4dHVhbCByZXByZXNlbnRhdGlvbiBvZiB0aGUgc3BlY2lmaWVkIGNlbGwKLQkgKiB2YWx1ZSBhbmQgb3RoZXIgc2V0dGluZ3MuIChFdmVuIG1vcmUgc2V0dGluZ3MgYXJlCi0JICogYWNjZXNzaWJsZSB2aWEgaW5oZXJpdGVkIGdldHRlcnM6IGhhc0ZvY3VzLCBpc0VuYWJsZWQsIGV0Yy4pCi0JICovCi0JcHJvdGVjdGVkIFN0cmluZyBidWlsZFRleHQoSkxpc3QgbGlzdCwgT2JqZWN0IHZhbHVlLCBpbnQgaW5kZXgsIGJvb2xlYW4gaXNTZWxlY3RlZCwgYm9vbGVhbiBjZWxsSGFzRm9jdXMpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRUZXh0KHZhbHVlKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHRleHR1YWwgcmVwcmVzZW50YXRpb24gb2YgdGhlIHNwZWNpZmllZCBjZWxsCi0JICogdmFsdWUuIFRoZSBkZWZhdWx0IGlzIHRvIGRpc3BsYXkgdGhlIG9iamVjdCdzIGRlZmF1bHQgc3RyaW5nCi0JICogcmVwcmVzZW50YXRpb24gKGFzIHJldHVybmVkIGJ5ICN0b1N0cmluZygpKTsgdW5sZXNzIHRoZQotCSAqIHZhbHVlIGl0c2VsZiBpcyBhbiBpY29uLCBpbiB3aGljaCBjYXNlIG5vIHRleHQgaXMgZGlzcGxheWVkLgotCSAqLwotCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRUZXh0KE9iamVjdCB2YWx1ZSkgewotCQlyZXR1cm4gKHZhbHVlIGluc3RhbmNlb2YgSWNvbikgPyAiIiA6ICgodmFsdWUgPT0gbnVsbCkgPyAiIiA6IHZhbHVlLnRvU3RyaW5nKCkpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgdGV4dCBkaXNwbGF5ZWQgd2hlbiB0aGUgY3Vyc29yIGxpbmdlcnMgb3ZlciB0aGUgc3BlY2lmaWVkIGNlbGwuCi0JICogKEV2ZW4gbW9yZSBzZXR0aW5ncyBhcmUgYWNjZXNzaWJsZSB2aWEgaW5oZXJpdGVkIGdldHRlcnM6IGhhc0ZvY3VzLCBpc0VuYWJsZWQsIGV0Yy4pCi0JICovCi0JcHJvdGVjdGVkIFN0cmluZyBidWlsZFRvb2xUaXBUZXh0KEpMaXN0IGxpc3QsIE9iamVjdCB2YWx1ZSwgaW50IGluZGV4LCBib29sZWFuIGlzU2VsZWN0ZWQsIGJvb2xlYW4gY2VsbEhhc0ZvY3VzKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkVG9vbFRpcFRleHQodmFsdWUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgdGV4dCBkaXNwbGF5ZWQgd2hlbiB0aGUgY3Vyc29yIGxpbmdlcnMgb3ZlciB0aGUgc3BlY2lmaWVkIGNlbGwuCi0JICovCi0JcHJvdGVjdGVkIFN0cmluZyBidWlsZFRvb2xUaXBUZXh0KE9iamVjdCB2YWx1ZSkgewotCQlyZXR1cm4gbnVsbDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGFjY2Vzc2libGUgbmFtZSB0byBiZSBnaXZlbiB0byB0aGUgY29tcG9uZW50IHVzZWQgdG8gcmVuZGVyCi0JICogdGhlIGdpdmVuIHZhbHVlIGFuZCBvdGhlciBzZXR0aW5ncy4gKEV2ZW4gbW9yZSBzZXR0aW5ncyBhcmUgYWNjZXNzaWJsZSB2aWEKLQkgKiBpbmhlcml0ZWQgZ2V0dGVyczogaGFzRm9jdXMsIGlzRW5hYmxlZCwgZXRjLikKLQkgKi8KLQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkQWNjZXNzaWJsZU5hbWUoSkxpc3QgbGlzdCwgT2JqZWN0IHZhbHVlLCBpbnQgaW5kZXgsIGJvb2xlYW4gaXNTZWxlY3RlZCwgYm9vbGVhbiBjZWxsSGFzRm9jdXMpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRBY2Nlc3NpYmxlTmFtZSh2YWx1ZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBhY2Nlc3NpYmxlIG5hbWUgdG8gYmUgZ2l2ZW4gdG8gdGhlIGNvbXBvbmVudCB1c2VkIHRvIHJlbmRlcgotCSAqIHRoZSBnaXZlbiB2YWx1ZS4KLQkgKi8KLQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkQWNjZXNzaWJsZU5hbWUoT2JqZWN0IHZhbHVlKSB7Ci0JCXJldHVybiBudWxsOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL1NwaW5uZXJUYWJsZUNlbGxSZW5kZXJlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L2ludGVybmFsL3N3aW5nL1NwaW5uZXJUYWJsZUNlbGxSZW5kZXJlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhMTVlMTZhLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9TcGlubmVyVGFibGVDZWxsUmVuZGVyZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE4NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLnN3aW5nOwotCi1pbXBvcnQgamF2YS5hd3QuQ29sb3I7Ci1pbXBvcnQgamF2YS5hd3QuQ29tcG9uZW50OwotaW1wb3J0IGphdmF4LnN3aW5nLkJvcmRlckZhY3Rvcnk7Ci1pbXBvcnQgamF2YXguc3dpbmcuSkNvbXBvbmVudDsKLWltcG9ydCBqYXZheC5zd2luZy5KU3Bpbm5lcjsKLWltcG9ydCBqYXZheC5zd2luZy5KVGFibGU7Ci1pbXBvcnQgamF2YXguc3dpbmcuU3Bpbm5lck1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLlVJTWFuYWdlcjsKLWltcG9ydCBqYXZheC5zd2luZy5ib3JkZXIuQm9yZGVyOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LkNoYW5nZUV2ZW50OwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LkNoYW5nZUxpc3RlbmVyOwotCi0vKioKLSAqIE1ha2UgdGhlIGNlbGwgbG9vayBsaWtlIGEgc3Bpbm5lci4KLSAqLwotcHVibGljIGNsYXNzIFNwaW5uZXJUYWJsZUNlbGxSZW5kZXJlciBpbXBsZW1lbnRzIFRhYmxlQ2VsbEVkaXRvckFkYXB0ZXIuUmVuZGVyZXIgewotCi0JLyoqIHRoZSBjb21wb25lbnQgdXNlZCB0byBwYWludCB0aGUgY2VsbCAqLwotCXByb3RlY3RlZCBKU3Bpbm5lciBzcGlubmVyOwotCQotCS8qKiB0aGUgbGlzdGVuZXIgdG8gYmUgbm90aWZpZWQgb24gYW4gaW1tZWRpYXRlIGVkaXQgKi8KLQlwcm90ZWN0ZWQgVGFibGVDZWxsRWRpdG9yQWRhcHRlci5JbW1lZGlhdGVFZGl0TGlzdGVuZXIgaW1tZWRpYXRlRWRpdExpc3RlbmVyOwotCQotCQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGNlbGwgcmVuZGVyZXIgdGhhdCB1c2VzIHRoZSBkZWZhdWx0Ci0JICogc3Bpbm5lciBtb2RlbCwgd2hpY2ggaXMgYSAibnVtYmVyIiBtb2RlbC4KLQkgKi8KLQlwdWJsaWMgU3Bpbm5lclRhYmxlQ2VsbFJlbmRlcmVyKCkgewotCQlzdXBlcigpOwotCQl0aGlzLmluaXRpYWxpemUoKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBjZWxsIHJlbmRlcmVyIHRoYXQgdXNlcyB0aGUgc3BlY2lmaWVkCi0JICogc3Bpbm5lciBtb2RlbCwgd2hpY2ggd2lsbCBkZXRlcm1pbmUgaG93IHRoZSB2YWx1ZXMgYXJlIGRpc3BsYXllZC4KLQkgKi8KLQlwdWJsaWMgU3Bpbm5lclRhYmxlQ2VsbFJlbmRlcmVyKFNwaW5uZXJNb2RlbCBtb2RlbCkgewotCQl0aGlzKCk7Ci0JCXRoaXMuc2V0TW9kZWwobW9kZWwpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemUoKSB7Ci0JCXRoaXMuc3Bpbm5lciA9IHRoaXMuYnVpbGRTcGlubmVyKCk7Ci0JfQotCi0JcHJvdGVjdGVkIEpTcGlubmVyIGJ1aWxkU3Bpbm5lcigpIHsKLQkJSlNwaW5uZXIgcyA9IG5ldyBKU3Bpbm5lcigpOwotCQlzLmFkZENoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRDaGFuZ2VMaXN0ZW5lcigpKTsKLQkJcmV0dXJuIHM7Ci0JfQotCQotCXByaXZhdGUgQ2hhbmdlTGlzdGVuZXIgYnVpbGRDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHN0YXRlQ2hhbmdlZChDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJaWYgKFNwaW5uZXJUYWJsZUNlbGxSZW5kZXJlci50aGlzLmltbWVkaWF0ZUVkaXRMaXN0ZW5lciAhPSBudWxsKSB7Ci0JCQkJCVNwaW5uZXJUYWJsZUNlbGxSZW5kZXJlci50aGlzLmltbWVkaWF0ZUVkaXRMaXN0ZW5lci5pbW1lZGlhdGVFZGl0KCk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBUYWJsZUNlbGxSZW5kZXJlciBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgQ29tcG9uZW50IGdldFRhYmxlQ2VsbFJlbmRlcmVyQ29tcG9uZW50KEpUYWJsZSB0YWJsZSwgT2JqZWN0IHZhbHVlLCBib29sZWFuIHNlbGVjdGVkLCBib29sZWFuIGhhc0ZvY3VzLCBpbnQgcm93LCBpbnQgY29sdW1uKSB7Ci0JCXRoaXMuc3Bpbm5lci5zZXRDb21wb25lbnRPcmllbnRhdGlvbih0YWJsZS5nZXRDb21wb25lbnRPcmllbnRhdGlvbigpKTsKLQkJdGhpcy5zcGlubmVyLnNldEZvbnQodGFibGUuZ2V0Rm9udCgpKTsKLQkJdGhpcy5zcGlubmVyLnNldEVuYWJsZWQodGFibGUuaXNFbmFibGVkKCkpOwotCi0JCUpDb21wb25lbnQgZWRpdG9yID0gdGhpcy5lZGl0b3IoKTsKLQkJZWRpdG9yLnNldEZvcmVncm91bmQodGhpcy5mb3JlZ3JvdW5kQ29sb3IodGFibGUsIHZhbHVlLCBzZWxlY3RlZCwgaGFzRm9jdXMsIHJvdywgY29sdW1uKSk7Ci0JCWVkaXRvci5zZXRCYWNrZ3JvdW5kKHRoaXMuYmFja2dyb3VuZENvbG9yKHRhYmxlLCB2YWx1ZSwgc2VsZWN0ZWQsIGhhc0ZvY3VzLCByb3csIGNvbHVtbikpOwotCQl0aGlzLnNwaW5uZXIuc2V0Qm9yZGVyKHRoaXMuYm9yZGVyKHRhYmxlLCB2YWx1ZSwgc2VsZWN0ZWQsIGhhc0ZvY3VzLCByb3csIGNvbHVtbikpOwotCi0JCXRoaXMuc2V0VmFsdWUodmFsdWUpOwotCQlyZXR1cm4gdGhpcy5zcGlubmVyOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgY2VsbCdzIGZvcmVncm91bmQgY29sb3IuCi0JICovCi0JcHJvdGVjdGVkIENvbG9yIGZvcmVncm91bmRDb2xvcihKVGFibGUgdGFibGUsIE9iamVjdCB2YWx1ZSwgYm9vbGVhbiBzZWxlY3RlZCwgYm9vbGVhbiBoYXNGb2N1cywgaW50IHJvdywgaW50IGNvbHVtbikgewotCQlpZiAoc2VsZWN0ZWQpIHsKLQkJCWlmIChoYXNGb2N1cyAmJiB0YWJsZS5pc0NlbGxFZGl0YWJsZShyb3csIGNvbHVtbikpIHsKLQkJCQlyZXR1cm4gVUlNYW5hZ2VyLmdldENvbG9yKCJUYWJsZS5mb2N1c0NlbGxGb3JlZ3JvdW5kIik7Ci0JCQl9Ci0JCQlyZXR1cm4gdGFibGUuZ2V0U2VsZWN0aW9uRm9yZWdyb3VuZCgpOwotCQl9Ci0JCXJldHVybiB0YWJsZS5nZXRGb3JlZ3JvdW5kKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjZWxsJ3MgYmFja2dyb3VuZCBjb2xvci4KLQkgKi8KLQlwcm90ZWN0ZWQgQ29sb3IgYmFja2dyb3VuZENvbG9yKEpUYWJsZSB0YWJsZSwgT2JqZWN0IHZhbHVlLCBib29sZWFuIHNlbGVjdGVkLCBib29sZWFuIGhhc0ZvY3VzLCBpbnQgcm93LCBpbnQgY29sdW1uKSB7Ci0JCWlmIChzZWxlY3RlZCkgewotCQkJaWYgKGhhc0ZvY3VzICYmIHRhYmxlLmlzQ2VsbEVkaXRhYmxlKHJvdywgY29sdW1uKSkgewotCQkJCXJldHVybiBVSU1hbmFnZXIuZ2V0Q29sb3IoIlRhYmxlLmZvY3VzQ2VsbEJhY2tncm91bmQiKTsKLQkJCX0KLQkJCXJldHVybiB0YWJsZS5nZXRTZWxlY3Rpb25CYWNrZ3JvdW5kKCk7Ci0JCX0KLQkJcmV0dXJuIHRhYmxlLmdldEJhY2tncm91bmQoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNlbGwncyBib3JkZXIuCi0JICovCi0JcHJvdGVjdGVkIEJvcmRlciBib3JkZXIoSlRhYmxlIHRhYmxlLCBPYmplY3QgdmFsdWUsIGJvb2xlYW4gc2VsZWN0ZWQsIGJvb2xlYW4gaGFzRm9jdXMsIGludCByb3csIGludCBjb2x1bW4pIHsKLQkJaWYgKGhhc0ZvY3VzKSB7Ci0JCQlyZXR1cm4gVUlNYW5hZ2VyLmdldEJvcmRlcigiVGFibGUuZm9jdXNDZWxsSGlnaGxpZ2h0Qm9yZGVyIik7Ci0JCX0KLQkJaWYgKHNlbGVjdGVkKSB7Ci0JCQlyZXR1cm4gQm9yZGVyRmFjdG9yeS5jcmVhdGVMaW5lQm9yZGVyKHRhYmxlLmdldFNlbGVjdGlvbkJhY2tncm91bmQoKSwgMSk7Ci0JCX0KLQkJcmV0dXJuIEJvcmRlckZhY3RvcnkuY3JlYXRlTGluZUJvcmRlcih0YWJsZS5nZXRCYWNrZ3JvdW5kKCksIDEpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgZWRpdG9yIGNvbXBvbmVudCB3aG9zZSBjb2xvcnMgc2hvdWxkIGJlIHNldAotCSAqIGJ5IHRoZSByZW5kZXJlci4KLQkgKi8KLQlwcm90ZWN0ZWQgSkNvbXBvbmVudCBlZGl0b3IoKSB7Ci0JCUpDb21wb25lbnQgZWRpdG9yID0gdGhpcy5zcGlubmVyLmdldEVkaXRvcigpOwotCQlpZiAoZWRpdG9yIGluc3RhbmNlb2YgSlNwaW5uZXIuRGVmYXVsdEVkaXRvcikgewotCQkJLy8gdHlwaWNhbGx5LCB0aGUgZWRpdG9yIHdpbGwgYmUgdGhlIGRlZmF1bHQgb3Igb25lIG9mIGl0cyBzdWJjbGFzc2VzLi4uCi0JCQllZGl0b3IgPSAoKEpTcGlubmVyLkRlZmF1bHRFZGl0b3IpIGVkaXRvcikuZ2V0VGV4dEZpZWxkKCk7Ci0JCX0KLQkJcmV0dXJuIGVkaXRvcjsKLQl9Ci0KLQkvKioKLQkgKiBTZXQgdGhlIHNwaW5uZXIncyB2YWx1ZQotCSAqLwotCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlKE9iamVjdCB2YWx1ZSkgewotCQkvLyBDUiMzOTk5MzE4IC0gVGhpcyBudWxsIGNoZWNrIG5lZWRzIHRvIGJlIHJlbW92ZWQgb25jZSBKREsgYnVnIGlzIGZpeGVkCi0JCWlmICh2YWx1ZSA9PSBudWxsKSB7Ci0JCQl2YWx1ZSA9IG5ldyBJbnRlZ2VyKDApOwotCQl9Ci0JCXRoaXMuc3Bpbm5lci5zZXRWYWx1ZSh2YWx1ZSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIFRhYmxlQ2VsbEVkaXRvckFkYXB0ZXIuUmVuZGVyZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIE9iamVjdCBnZXRWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMuc3Bpbm5lci5nZXRWYWx1ZSgpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCBzZXRJbW1lZGlhdGVFZGl0TGlzdGVuZXIoVGFibGVDZWxsRWRpdG9yQWRhcHRlci5JbW1lZGlhdGVFZGl0TGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJdGhpcy5pbW1lZGlhdGVFZGl0TGlzdGVuZXIgPSBsaXN0ZW5lcjsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogcHVibGljIEFQSSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBTZXQgdGhlIHNwaW5uZXIncyBtb2RlbC4KLQkgKi8KLQlwdWJsaWMgdm9pZCBzZXRNb2RlbChTcGlubmVyTW9kZWwgbW9kZWwpIHsKLQkJdGhpcy5zcGlubmVyLnNldE1vZGVsKG1vZGVsKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHJlbmRlcmVyJ3MgcHJlZmVycmVkIGhlaWdodC4gVGhpcyBhbGxvd3MgeW91Ci0JICogdG8gc2V0IHRoZSByb3cgaGVpZ2h0IHRvIHNvbWV0aGluZyB0aGUgc3Bpbm5lciB3aWxsIGxvb2sgZ29vZCBpbi4uLi4KLQkgKi8KLQlwdWJsaWMgaW50IHByZWZlcnJlZEhlaWdodCgpIHsKLQkJLy8gYWRkIGluIHNwYWNlIGZvciB0aGUgYm9yZGVyIHRvcCBhbmQgYm90dG9tCi0JCXJldHVybiAoaW50KSB0aGlzLnNwaW5uZXIuZ2V0UHJlZmVycmVkU2l6ZSgpLmdldEhlaWdodCgpICsgMjsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9UYWJsZUNlbGxFZGl0b3JBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvaW50ZXJuYWwvc3dpbmcvVGFibGVDZWxsRWRpdG9yQWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiMTljODZmLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9pbnRlcm5hbC9zd2luZy9UYWJsZUNlbGxFZGl0b3JBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw5NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLnN3aW5nOwotCi1pbXBvcnQgamF2YS5hd3QuQ29tcG9uZW50OwotaW1wb3J0IGphdmF4LnN3aW5nLkFic3RyYWN0Q2VsbEVkaXRvcjsKLWltcG9ydCBqYXZheC5zd2luZy5KVGFibGU7Ci1pbXBvcnQgamF2YXguc3dpbmcudGFibGUuVGFibGVDZWxsRWRpdG9yOwotaW1wb3J0IGphdmF4LnN3aW5nLnRhYmxlLlRhYmxlQ2VsbFJlbmRlcmVyOwotCi0vKioKLSAqIEEgdGFibGUgY2VsbCBlZGl0b3IgdGhhdCB3cmFwcyBhIHRhYmxlIGNlbGwgcmVuZGVyZXIuCi0gKi8KLXB1YmxpYyBjbGFzcyBUYWJsZUNlbGxFZGl0b3JBZGFwdGVyIGV4dGVuZHMgQWJzdHJhY3RDZWxsRWRpdG9yIGltcGxlbWVudHMgVGFibGVDZWxsRWRpdG9yIHsKLQotCS8qKiBkZWxlZ2F0ZSB0byBhIHJlbmRlcmVyICovCi0JcHJpdmF0ZSBSZW5kZXJlciByZW5kZXJlcjsKLQkKLQkKLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycy9pbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0JCi0JcHJpdmF0ZSBUYWJsZUNlbGxFZGl0b3JBZGFwdGVyKCkgewotCQlzdXBlcigpOwotCX0KLQkKLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBjZWxsIGVkaXRvciB0aGF0IGJlaGF2ZXMgbGlrZSB0aGUgc3BlY2lmaWVkIHJlbmRlcmVyLgotCSAqLwotCXB1YmxpYyBUYWJsZUNlbGxFZGl0b3JBZGFwdGVyKFJlbmRlcmVyIHJlbmRlcmVyKSB7Ci0JCXRoaXMoKTsKLQkJdGhpcy5pbml0aWFsaXplKHJlbmRlcmVyKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZShSZW5kZXJlciByKSB7Ci0JCXRoaXMucmVuZGVyZXIgPSByOwotCQlyLnNldEltbWVkaWF0ZUVkaXRMaXN0ZW5lcih0aGlzLmJ1aWxkSW1tZWRpYXRlRWRpdExpc3RlbmVyKCkpOwotCX0KLQkKLQlwcml2YXRlIEltbWVkaWF0ZUVkaXRMaXN0ZW5lciBidWlsZEltbWVkaWF0ZUVkaXRMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBJbW1lZGlhdGVFZGl0TGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBpbW1lZGlhdGVFZGl0KCkgewotCQkJCVRhYmxlQ2VsbEVkaXRvckFkYXB0ZXIudGhpcy5zdG9wQ2VsbEVkaXRpbmcoKTsKLQkJCX0KLQkJfTsKLQl9Ci0JCi0JCi0JLy8gKioqKioqKioqKiBDZWxsRWRpdG9yIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQkKLQlwdWJsaWMgT2JqZWN0IGdldENlbGxFZGl0b3JWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMucmVuZGVyZXIuZ2V0VmFsdWUoKTsKLQl9Ci0JCi0JCi0JLy8gKioqKioqKioqKiBUYWJsZUNlbGxFZGl0b3IgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIENvbXBvbmVudCBnZXRUYWJsZUNlbGxFZGl0b3JDb21wb25lbnQoSlRhYmxlIHRhYmxlLCBPYmplY3QgdmFsdWUsIGJvb2xlYW4gc2VsZWN0ZWQsIGludCByb3csIGludCBjb2x1bW4pIHsKLQkJcmV0dXJuIHRoaXMucmVuZGVyZXIuZ2V0VGFibGVDZWxsUmVuZGVyZXJDb21wb25lbnQodGFibGUsIHZhbHVlLCBzZWxlY3RlZCwgdHJ1ZSwgcm93LCBjb2x1bW4pOwotCX0KLQkKLQkKLQkvLyAqKioqKioqKioqIE1lbWJlciBjbGFzc2VzICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLQkKLQkvKioKLQkgKiBUaGlzIGludGVyZmFjZSBkZWZpbmVzIHRoZSBtZXRob2RzIHRoYXQgbXVzdCBiZSBpbXBsZW1lbnRlZCBieSBhIHJlbmRlcmVyCi0JICogdGhhdCBjYW4gYmUgd3JhcHBlZCBieSBhIFRhYmxlQ2VsbEVkaXRvckFkYXB0ZXIuCi0JICovCi0JcHVibGljIGludGVyZmFjZSBSZW5kZXJlciBleHRlbmRzIFRhYmxlQ2VsbFJlbmRlcmVyIHsKLQkJCi0JCS8qKgotCQkgKiBSZXR1cm4gdGhlIGN1cnJlbnQgdmFsdWUgb2YgdGhlIHJlbmRlcmVyLgotCQkgKi8KLQkJT2JqZWN0IGdldFZhbHVlKCk7Ci0JCQotCQkvKioKLQkJICogU2V0IHRoZSBpbW1lZGlhdGUgZWRpdCBsaXN0ZW5lcgotCQkgKi8KLQkJdm9pZCBzZXRJbW1lZGlhdGVFZGl0TGlzdGVuZXIoSW1tZWRpYXRlRWRpdExpc3RlbmVyIGxpc3RlbmVyKTsKLQl9Ci0JCi0JCi0JcHVibGljIGludGVyZmFjZSBJbW1lZGlhdGVFZGl0TGlzdGVuZXIgewotCQkKLQkJLyoqCi0JCSAqIENhbGxlZCB3aGVuIHRoZSByZW5kZXJlciBkb2VzIGFuICJpbW1lZGlhdGUgZWRpdCIKLQkJICovCi0JCXZvaWQgaW1tZWRpYXRlRWRpdCgpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9Nb2RlbC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL01vZGVsLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDMzZjJmZDIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL01vZGVsLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxOTUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5MaXN0Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5TdGF0ZUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlRyZWVDaGFuZ2VMaXN0ZW5lcjsKLQotLyoqCi0gKiBJbnRlcmZhY2UgdG8gYmUgaW1wbGVtZW50ZWQgYnkgbW9kZWxzIHRoYXQgbm90aWZ5IGxpc3RlbmVycyBvZgotICogY2hhbmdlcyB0byBib3VuZCBwcm9wZXJ0aWVzLCBjb2xsZWN0aW9ucywgbGlzdHMsIGFuZC9vciB0cmVlcy4KLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKi8KLXB1YmxpYyBpbnRlcmZhY2UgTW9kZWwgewotCi0JLy8gKioqKioqKioqKiBzdGF0ZSBjaGFuZ2UgKioqKioqKioqKgotCi0JLyoqCi0JICogQWRkIGEgbGlzdGVuZXIgdGhhdCBsaXN0ZW5zIHRvIGFsbCBzdGF0ZSBjaGFuZ2UgZXZlbnRzLgotCSAqIFRoZSBzYW1lIGxpc3RlbmVyIG1heSBiZSBhZGRlZCBtb3JlIHRoYW4gb25jZSBhbmQgd2lsbCBiZSBjYWxsZWQKLQkgKiBhcyBtYW55IHRpbWVzIGFzIGl0IGlzIGFkZGVkLiBUaGUgbGlzdGVuZXIgY2Fubm90IGJlIG51bGwuCi0JICovCi0Jdm9pZCBhZGRTdGF0ZUNoYW5nZUxpc3RlbmVyKFN0YXRlQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpOwotCi0JLyoqCi0JICogUmVtb3ZlIHRoZSBzcGVjaWZpZWQgc3RhdGUgY2hhbmdlIGxpc3RlbmVyLiBJZiB0aGUgbGlzdGVuZXIKLQkgKiB3YXMgYWRkZWQgbW9yZSB0aGFuIG9uY2UsIGl0IHdpbGwgYmUgbm90aWZpZWQgb25lIGxlc3MgdGltZQotCSAqIGFmdGVyIGJlaW5nIHJlbW92ZWQuIEFuIGV4Y2VwdGlvbiB3aWxsIGJlIHRocm93biBpZiB0aGUKLQkgKiBsaXN0ZW5lciBpcyBudWxsIG9yIGlmIHRoZSBsaXN0ZW5lciB3YXMgbmV2ZXIgYWRkZWQuCi0JICovCi0Jdm9pZCByZW1vdmVTdGF0ZUNoYW5nZUxpc3RlbmVyKFN0YXRlQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpOwotCi0KLQkvLyAqKioqKioqKioqIHByb3BlcnR5IGNoYW5nZSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBBZGQgYSBsaXN0ZW5lciB0aGF0IGxpc3RlbnMgdG8gYWxsIHByb3BlcnR5IGNoYW5nZSBldmVudHMsCi0JICogcmVnYXJkbGVzcyBvZiB0aGUgcHJvcGVydHkgbmFtZSBhc3NvY2lhdGVkIHdpdGggdGhhdCBldmVudC4KLQkgKiBUaGUgc2FtZSBsaXN0ZW5lciBtYXkgYmUgYWRkZWQgbW9yZSB0aGFuIG9uY2UgYW5kIHdpbGwgYmUgY2FsbGVkCi0JICogYXMgbWFueSB0aW1lcyBhcyBpdCBpcyBhZGRlZC4gVGhlIGxpc3RlbmVyIGNhbm5vdCBiZSBudWxsLgotCSAqLwotCXZvaWQgYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKTsKLQotCS8qKgotCSAqIEFkZCBhIGxpc3RlbmVyIHRoYXQgbGlzdGVucyB0byBhbGwgcHJvcGVydHkgY2hhbmdlIGV2ZW50cyB3aXRoCi0JICogdGhlIHNwZWNpZmllZCBwcm9wZXJ0eSBuYW1lLgotCSAqIFRoZSBzYW1lIGxpc3RlbmVyIG1heSBiZSBhZGRlZCBtb3JlIHRoYW4gb25jZSBhbmQgd2lsbCBiZSBjYWxsZWQKLQkgKiBhcyBtYW55IHRpbWVzIGFzIGl0IGlzIGFkZGVkLiBUaGUgbGlzdGVuZXIgY2Fubm90IGJlIG51bGwuCi0JICovCi0Jdm9pZCBhZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFN0cmluZyBwcm9wZXJ0eU5hbWUsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpOwotCi0JLyoqCi0JICogUmVtb3ZlIGEgbGlzdGVuZXIgdGhhdCBsaXN0ZW5zIHRvIGFsbCBwcm9wZXJ0eSBjaGFuZ2UgZXZlbnRzLAotCSAqIHJlZ2FyZGxlc3Mgb2YgdGhlIHByb3BlcnR5IG5hbWUgYXNzb2NpYXRlZCB3aXRoIHRoYXQgZXZlbnQuCi0JICogSWYgdGhlIGxpc3RlbmVyIHdhcyBhZGRlZCBtb3JlIHRoYW4gb25jZSwgaXQgd2lsbCBiZSBub3RpZmllZCBvbmUgbGVzcwotCSAqIHRpbWUgYWZ0ZXIgYmVpbmcgcmVtb3ZlZC4gQW4gZXhjZXB0aW9uIHdpbGwgYmUgdGhyb3duIGlmIHRoZQotCSAqIGxpc3RlbmVyIGlzIG51bGwgb3IgaWYgdGhlIGxpc3RlbmVyIHdhcyBuZXZlciBhZGRlZC4KLQkgKi8KLQl2b2lkIHJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcik7Ci0KLQkvKioKLQkgKiBSZW1vdmUgYSBsaXN0ZW5lciB0aGF0IGxpc3RlbnMgdG8gYWxsIHByb3BlcnR5IGNoYW5nZSBldmVudHMsCi0JICogd2l0aCB0aGUgc3BlY2lmaWVkIHByb3BlcnR5IG5hbWUuCi0JICogSWYgdGhlIGxpc3RlbmVyIHdhcyBhZGRlZCBtb3JlIHRoYW4gb25jZSwgaXQgd2lsbCBiZSBub3RpZmllZCBvbmUgbGVzcwotCSAqIHRpbWUgYWZ0ZXIgYmVpbmcgcmVtb3ZlZC4gQW4gZXhjZXB0aW9uIHdpbGwgYmUgdGhyb3duIGlmIHRoZQotCSAqIGxpc3RlbmVyIGlzIG51bGwgb3IgaWYgdGhlIGxpc3RlbmVyIHdhcyBuZXZlciBhZGRlZC4KLQkgKi8KLQl2b2lkIHJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoU3RyaW5nIHByb3BlcnR5TmFtZSwgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcik7Ci0KLQotCS8vICoqKioqKioqKiogY29sbGVjdGlvbiBjaGFuZ2UgKioqKioqKioqKgotCi0JLyoqCi0JICogQWRkIGEgbGlzdGVuZXIgdGhhdCBsaXN0ZW5zIHRvIGFsbCBjb2xsZWN0aW9uIGNoYW5nZSBldmVudHMsCi0JICogcmVnYXJkbGVzcyBvZiB0aGUgY29sbGVjdGlvbiBuYW1lIGFzc29jaWF0ZWQgd2l0aCB0aGF0IGV2ZW50LgotCSAqIFRoZSBzYW1lIGxpc3RlbmVyIG1heSBiZSBhZGRlZCBtb3JlIHRoYW4gb25jZSBhbmQgd2lsbCBiZSBjYWxsZWQKLQkgKiBhcyBtYW55IHRpbWVzIGFzIGl0IGlzIGFkZGVkLiBUaGUgbGlzdGVuZXIgY2Fubm90IGJlIG51bGwuCi0JICovCi0Jdm9pZCBhZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKTsKLQotCS8qKgotCSAqIEFkZCBhIGxpc3RlbmVyIHRoYXQgbGlzdGVucyB0byBhbGwgY29sbGVjdGlvbiBjaGFuZ2UgZXZlbnRzIHdpdGgKLQkgKiB0aGUgc3BlY2lmaWVkIGNvbGxlY3Rpb24gbmFtZS4KLQkgKiBUaGUgc2FtZSBsaXN0ZW5lciBtYXkgYmUgYWRkZWQgbW9yZSB0aGFuIG9uY2UgYW5kIHdpbGwgYmUgY2FsbGVkCi0JICogYXMgbWFueSB0aW1lcyBhcyBpdCBpcyBhZGRlZC4gVGhlIGxpc3RlbmVyIGNhbm5vdCBiZSBudWxsLgotCSAqLwotCXZvaWQgYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKFN0cmluZyBjb2xsZWN0aW9uTmFtZSwgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKTsKLQotCS8qKgotCSAqIFJlbW92ZSBhIGxpc3RlbmVyIHRoYXQgbGlzdGVucyB0byBhbGwgY29sbGVjdGlvbiBjaGFuZ2UgZXZlbnRzLAotCSAqIHJlZ2FyZGxlc3Mgb2YgdGhlIGNvbGxlY3Rpb24gbmFtZSBhc3NvY2lhdGVkIHdpdGggdGhhdCBldmVudC4KLQkgKiBJZiB0aGUgbGlzdGVuZXIgd2FzIGFkZGVkIG1vcmUgdGhhbiBvbmNlLCBpdCB3aWxsIGJlIG5vdGlmaWVkIG9uZSBsZXNzCi0JICogdGltZSBhZnRlciBiZWluZyByZW1vdmVkLiBBbiBleGNlcHRpb24gd2lsbCBiZSB0aHJvd24gaWYgdGhlCi0JICogbGlzdGVuZXIgaXMgbnVsbCBvciBpZiB0aGUgbGlzdGVuZXIgd2FzIG5ldmVyIGFkZGVkLgotCSAqLwotCXZvaWQgcmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcik7Ci0KLQkvKioKLQkgKiBSZW1vdmUgYSBsaXN0ZW5lciB0aGF0IGxpc3RlbnMgdG8gYWxsIGNvbGxlY3Rpb24gY2hhbmdlIGV2ZW50cywKLQkgKiB3aXRoIHRoZSBzcGVjaWZpZWQgY29sbGVjdGlvbiBuYW1lLgotCSAqIElmIHRoZSBsaXN0ZW5lciB3YXMgYWRkZWQgbW9yZSB0aGFuIG9uY2UsIGl0IHdpbGwgYmUgbm90aWZpZWQgb25lIGxlc3MKLQkgKiB0aW1lIGFmdGVyIGJlaW5nIHJlbW92ZWQuIEFuIGV4Y2VwdGlvbiB3aWxsIGJlIHRocm93biBpZiB0aGUKLQkgKiBsaXN0ZW5lciBpcyBudWxsIG9yIGlmIHRoZSBsaXN0ZW5lciB3YXMgbmV2ZXIgYWRkZWQuCi0JICovCi0Jdm9pZCByZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoU3RyaW5nIGNvbGxlY3Rpb25OYW1lLCBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpOwotCi0KLQkvLyAqKioqKioqKioqIGxpc3QgY2hhbmdlICoqKioqKioqKioKLQotCS8qKgotCSAqIEFkZCBhIGxpc3RlbmVyIHRoYXQgbGlzdGVucyB0byBhbGwgbGlzdCBjaGFuZ2UgZXZlbnRzLAotCSAqIHJlZ2FyZGxlc3Mgb2YgdGhlIGxpc3QgbmFtZSBhc3NvY2lhdGVkIHdpdGggdGhhdCBldmVudC4KLQkgKiBUaGUgc2FtZSBsaXN0ZW5lciBtYXkgYmUgYWRkZWQgbW9yZSB0aGFuIG9uY2UgYW5kIHdpbGwgYmUgY2FsbGVkCi0JICogYXMgbWFueSB0aW1lcyBhcyBpdCBpcyBhZGRlZC4gVGhlIGxpc3RlbmVyIGNhbm5vdCBiZSBudWxsLgotCSAqLwotCXZvaWQgYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcik7Ci0KLQkvKioKLQkgKiBBZGQgYSBsaXN0ZW5lciB0aGF0IGxpc3RlbnMgdG8gYWxsIGxpc3QgY2hhbmdlIGV2ZW50cyB3aXRoCi0JICogdGhlIHNwZWNpZmllZCBsaXN0IG5hbWUuCi0JICogVGhlIHNhbWUgbGlzdGVuZXIgbWF5IGJlIGFkZGVkIG1vcmUgdGhhbiBvbmNlIGFuZCB3aWxsIGJlIGNhbGxlZAotCSAqIGFzIG1hbnkgdGltZXMgYXMgaXQgaXMgYWRkZWQuIFRoZSBsaXN0ZW5lciBjYW5ub3QgYmUgbnVsbC4KLQkgKi8KLQl2b2lkIGFkZExpc3RDaGFuZ2VMaXN0ZW5lcihTdHJpbmcgbGlzdE5hbWUsIExpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcik7Ci0KLQkvKioKLQkgKiBSZW1vdmUgYSBsaXN0ZW5lciB0aGF0IGxpc3RlbnMgdG8gYWxsIGxpc3QgY2hhbmdlIGV2ZW50cywKLQkgKiByZWdhcmRsZXNzIG9mIHRoZSBsaXN0IG5hbWUgYXNzb2NpYXRlZCB3aXRoIHRoYXQgZXZlbnQuCi0JICogSWYgdGhlIGxpc3RlbmVyIHdhcyBhZGRlZCBtb3JlIHRoYW4gb25jZSwgaXQgd2lsbCBiZSBub3RpZmllZCBvbmUgbGVzcwotCSAqIHRpbWUgYWZ0ZXIgYmVpbmcgcmVtb3ZlZC4gQW4gZXhjZXB0aW9uIHdpbGwgYmUgdGhyb3duIGlmIHRoZQotCSAqIGxpc3RlbmVyIGlzIG51bGwgb3IgaWYgdGhlIGxpc3RlbmVyIHdhcyBuZXZlciBhZGRlZC4KLQkgKi8KLQl2b2lkIHJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpOwotCi0JLyoqCi0JICogUmVtb3ZlIGEgbGlzdGVuZXIgdGhhdCBsaXN0ZW5zIHRvIGFsbCBsaXN0IGNoYW5nZSBldmVudHMsCi0JICogd2l0aCB0aGUgc3BlY2lmaWVkIGxpc3QgbmFtZS4KLQkgKiBJZiB0aGUgbGlzdGVuZXIgd2FzIGFkZGVkIG1vcmUgdGhhbiBvbmNlLCBpdCB3aWxsIGJlIG5vdGlmaWVkIG9uZSBsZXNzCi0JICogdGltZSBhZnRlciBiZWluZyByZW1vdmVkLiBBbiBleGNlcHRpb24gd2lsbCBiZSB0aHJvd24gaWYgdGhlCi0JICogbGlzdGVuZXIgaXMgbnVsbCBvciBpZiB0aGUgbGlzdGVuZXIgd2FzIG5ldmVyIGFkZGVkLgotCSAqLwotCXZvaWQgcmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKFN0cmluZyBsaXN0TmFtZSwgTGlzdENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKTsKLQotCi0JLy8gKioqKioqKioqKiB0cmVlIGNoYW5nZSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBBZGQgYSBsaXN0ZW5lciB0aGF0IGxpc3RlbnMgdG8gYWxsIHRyZWUgY2hhbmdlIGV2ZW50cywKLQkgKiByZWdhcmRsZXNzIG9mIHRoZSB0cmVlIG5hbWUgYXNzb2NpYXRlZCB3aXRoIHRoYXQgZXZlbnQuCi0JICogVGhlIHNhbWUgbGlzdGVuZXIgbWF5IGJlIGFkZGVkIG1vcmUgdGhhbiBvbmNlIGFuZCB3aWxsIGJlIGNhbGxlZAotCSAqIGFzIG1hbnkgdGltZXMgYXMgaXQgaXMgYWRkZWQuIFRoZSBsaXN0ZW5lciBjYW5ub3QgYmUgbnVsbC4KLQkgKi8KLQl2b2lkIGFkZFRyZWVDaGFuZ2VMaXN0ZW5lcihUcmVlQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpOwotCi0JLyoqCi0JICogQWRkIGEgbGlzdGVuZXIgdGhhdCBsaXN0ZW5zIHRvIGFsbCB0cmVlIGNoYW5nZSBldmVudHMgd2l0aAotCSAqIHRoZSBzcGVjaWZpZWQgdHJlZSBuYW1lLgotCSAqIFRoZSBzYW1lIGxpc3RlbmVyIG1heSBiZSBhZGRlZCBtb3JlIHRoYW4gb25jZSBhbmQgd2lsbCBiZSBjYWxsZWQKLQkgKiBhcyBtYW55IHRpbWVzIGFzIGl0IGlzIGFkZGVkLiBUaGUgbGlzdGVuZXIgY2Fubm90IGJlIG51bGwuCi0JICovCi0Jdm9pZCBhZGRUcmVlQ2hhbmdlTGlzdGVuZXIoU3RyaW5nIHRyZWVOYW1lLCBUcmVlQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpOwotCi0JLyoqCi0JICogUmVtb3ZlIGEgbGlzdGVuZXIgdGhhdCBsaXN0ZW5zIHRvIGFsbCB0cmVlIGNoYW5nZSBldmVudHMsCi0JICogcmVnYXJkbGVzcyBvZiB0aGUgdHJlZSBuYW1lIGFzc29jaWF0ZWQgd2l0aCB0aGF0IGV2ZW50LgotCSAqIElmIHRoZSBsaXN0ZW5lciB3YXMgYWRkZWQgbW9yZSB0aGFuIG9uY2UsIGl0IHdpbGwgYmUgbm90aWZpZWQgb25lIGxlc3MKLQkgKiB0aW1lIGFmdGVyIGJlaW5nIHJlbW92ZWQuIEFuIGV4Y2VwdGlvbiB3aWxsIGJlIHRocm93biBpZiB0aGUKLQkgKiBsaXN0ZW5lciBpcyBudWxsIG9yIGlmIHRoZSBsaXN0ZW5lciB3YXMgbmV2ZXIgYWRkZWQuCi0JICovCi0Jdm9pZCByZW1vdmVUcmVlQ2hhbmdlTGlzdGVuZXIoVHJlZUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKTsKLQotCS8qKgotCSAqIFJlbW92ZSBhIGxpc3RlbmVyIHRoYXQgbGlzdGVucyB0byBhbGwgdHJlZSBjaGFuZ2UgZXZlbnRzLAotCSAqIHdpdGggdGhlIHNwZWNpZmllZCB0cmVlIG5hbWUuCi0JICogSWYgdGhlIGxpc3RlbmVyIHdhcyBhZGRlZCBtb3JlIHRoYW4gb25jZSwgaXQgd2lsbCBiZSBub3RpZmllZCBvbmUgbGVzcwotCSAqIHRpbWUgYWZ0ZXIgYmVpbmcgcmVtb3ZlZC4gQW4gZXhjZXB0aW9uIHdpbGwgYmUgdGhyb3duIGlmIHRoZQotCSAqIGxpc3RlbmVyIGlzIG51bGwgb3IgaWYgdGhlIGxpc3RlbmVyIHdhcyBuZXZlciBhZGRlZC4KLQkgKi8KLQl2b2lkIHJlbW92ZVRyZWVDaGFuZ2VMaXN0ZW5lcihTdHJpbmcgdHJlZU5hbWUsIFRyZWVDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcik7Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9ldmVudC9DaGFuZ2VFdmVudC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2V2ZW50L0NoYW5nZUV2ZW50LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDUyMTdhYmIuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2V2ZW50L0NoYW5nZUV2ZW50LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw2NCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50OwotCi1pbXBvcnQgamF2YS51dGlsLkV2ZW50T2JqZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0cmluZ1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLk1vZGVsOwotCi0vKioKLSAqIEFic3RyYWN0IGNsYXNzIGZvciBhbGwgdGhlIGNoYW5nZSBldmVudHMgdGhhdCBjYW4gYmUgZmlyZWQgYnkgbW9kZWxzLgotICogCi0gKiBQcm92aXNpb25hbCBBUEk6IFRoaXMgY2xhc3MgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsCi0gKiB1bmRlciBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nCi0gKiBzdGFiaWxpdHkuIEl0IGlzIGF2YWlsYWJsZSBhdCB0aGlzIGVhcmx5IHN0YWdlIHRvIHNvbGljaXQgZmVlZGJhY2sgZnJvbQotICogcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyB0aGlzIEFQSQotICogd2lsbCBhbG1vc3QgY2VydGFpbmx5IGJlIGJyb2tlbiAocmVwZWF0ZWRseSkgYXMgdGhlIEFQSSBldm9sdmVzLgotICovCi1wdWJsaWMgYWJzdHJhY3QgY2xhc3MgQ2hhbmdlRXZlbnQgZXh0ZW5kcyBFdmVudE9iamVjdCB7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgbmV3IGNoYW5nZSBldmVudC4KLQkgKgotCSAqIEBwYXJhbSBzb3VyY2UgVGhlIG9iamVjdCBvbiB3aGljaCB0aGUgZXZlbnQgaW5pdGlhbGx5IG9jY3VycmVkLgotCSAqLwotCXByb3RlY3RlZCBDaGFuZ2VFdmVudChNb2RlbCBzb3VyY2UpIHsKLQkJc3VwZXIoc291cmNlKTsKLQl9Ci0KLQkvKioKLQkgKiBDb3ZhcmlhbnQgb3ZlcnJpZGUuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIE1vZGVsIGdldFNvdXJjZSgpIHsKLQkJcmV0dXJuIChNb2RlbCkgc3VwZXIuZ2V0U291cmNlKCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBuYW1lIG9mIHRoZSBhc3BlY3Qgb2YgdGhlIHNvdXJjZSB0aGF0IGNoYW5nZWQuCi0JICogTWF5IGJlIG51bGwgaWYgaW5hcHByb3ByaWF0ZS4KLQkgKi8KLQlwdWJsaWMgYWJzdHJhY3QgU3RyaW5nIGdldEFzcGVjdE5hbWUoKTsKLQotCS8qKgotCSAqIFJldHVybiBhIGNvcHkgb2YgdGhlIGV2ZW50IHdpdGggdGhlIHNwZWNpZmllZCBzb3VyY2UKLQkgKiByZXBsYWNpbmcgdGhlIGN1cnJlbnQgc291cmNlLgotCSAqLwotCXB1YmxpYyBhYnN0cmFjdCBDaGFuZ2VFdmVudCBjbG9uZVdpdGhTb3VyY2UoTW9kZWwgbmV3U291cmNlKTsKLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuZ2V0QXNwZWN0TmFtZSgpKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9ldmVudC9Db2xsZWN0aW9uQ2hhbmdlRXZlbnQuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9ldmVudC9Db2xsZWN0aW9uQ2hhbmdlRXZlbnQuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzg2MDI2Yy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvZXZlbnQvQ29sbGVjdGlvbkNoYW5nZUV2ZW50LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMzcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudDsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uczsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci0KLS8qKgotICogQSAiY29sbGVjdGlvbiBjaGFuZ2UiIGV2ZW50IGdldHMgZGVsaXZlcmVkIHdoZW5ldmVyIGEgbW9kZWwgY2hhbmdlcyBhICJib3VuZCIKLSAqIG9yICJjb25zdHJhaW5lZCIgY29sbGVjdGlvbi4gQSBDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgaXMgc2VudCBhcyBhbgotICogYXJndW1lbnQgdG8gdGhlIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lci4KLSAqIAotICogTm9ybWFsbHkgYSBDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgaXMgYWNjb21wYW5pZWQgYnkgdGhlIGNvbGxlY3Rpb24gbmFtZSBhbmQKLSAqIHRoZSBpdGVtcyB0aGF0IHdlcmUgYWRkZWQgdG8gb3IgcmVtb3ZlZCBmcm9tIHRoZSBjaGFuZ2VkIGNvbGxlY3Rpb24uCi0gKiAKLSAqIERlc2lnbiBvcHRpb25zOgotICogLSBjcmVhdGUgYSBjb2xsZWN0aW9uIHRvIHdyYXAgYSBzaW5nbGUgYWRkZWQgb3IgcmVtb3ZlZCBpdGVtCi0gKiAJKHRoaXMgaXMgdGhlIG9wdGlvbiB3ZSBpbXBsZW1lbnRlZCBiZWxvdyBhbmQgaW4gY29sbGFib3JhdGluZyBjb2RlKQotICogCXNpbmNlIHRoZXJlIGlzIG5vIHdheSB0byBvcHRpbWl6ZSBkb3duc3RyZWFtIGNvZGUgZm9yCi0gKiAJc2luZ2xlIGl0ZW1zLCB3ZSB0YWtlIGFub3RoZXIgcGVyZm9ybWFuY2UgaGl0IGJ5IGJ1aWxkaW5nCi0gKiAJYSBjb2xsZWN0aW9uIGVhY2ggdGltZSAgKEBzZWUgQ29sbGVjdGlvbnMjc2luZ2xldG9uKE9iamVjdCkpCi0gKiAJYW5kIGZvcmNpbmcgZG93bnN0cmVhbSBjb2RlIHRvIHVzZSBhbiBpdGVyYXRvciBldmVyeSB0aW1lCi0gKiAKLSAqIC0gZmlyZSBhIHNlcGFyYXRlIGV2ZW50IGZvciBlYWNoIGl0ZW0gYWRkZWQgb3IgcmVtb3ZlZAotICogCWVsaW1pbmF0ZXMgYW55IHBvdGVudGlhbCBmb3Igb3B0aW1pemF0aW9ucyB0byBkb3duc3RyZWFtIGNvZGUKLSAqIAotICogLSBhZGQgcHJvdG9jb2wgdG8gc3VwcG9ydCBib3RoIHNpbmdsZSBpdGVtcyBhbmQgY29sbGVjdGlvbnMKLSAqIAlhZGRzIGNvbmRpdGlvbmFsIGxvZ2ljIHRvIGRvd25zdHJlYW0gY29kZQotICogCi0gKiBQcm92aXNpb25hbCBBUEk6IFRoaXMgY2xhc3MgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsCi0gKiB1bmRlciBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nCi0gKiBzdGFiaWxpdHkuIEl0IGlzIGF2YWlsYWJsZSBhdCB0aGlzIGVhcmx5IHN0YWdlIHRvIHNvbGljaXQgZmVlZGJhY2sgZnJvbQotICogcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyB0aGlzIEFQSQotICogd2lsbCBhbG1vc3QgY2VydGFpbmx5IGJlIGJyb2tlbiAocmVwZWF0ZWRseSkgYXMgdGhlIEFQSSBldm9sdmVzLgotICovCi1wdWJsaWMgY2xhc3MgQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV4dGVuZHMgQ2hhbmdlRXZlbnQgewotCi0JLyoqIE5hbWUgb2YgdGhlIGNvbGxlY3Rpb24gdGhhdCBjaGFuZ2VkLiAqLwotCXByaXZhdGUgZmluYWwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lOwotCi0JLyoqIFRoZSBpdGVtcyB0aGF0IHdlcmUgYWRkZWQgdG8gb3IgcmVtb3ZlZCBmcm9tIHRoZSBjb2xsZWN0aW9uLiBNYXkgYmUgZW1wdHksIGlmIG5vdCBrbm93bi4gKi8KLQlwcml2YXRlIGZpbmFsIENvbGxlY3Rpb248Pz4gaXRlbXM7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgbmV3IGNvbGxlY3Rpb24gY2hhbmdlIGV2ZW50LgotCSAqCi0JICogQHBhcmFtIHNvdXJjZSBUaGUgb2JqZWN0IG9uIHdoaWNoIHRoZSBldmVudCBpbml0aWFsbHkgb2NjdXJyZWQuCi0JICogQHBhcmFtIGNvbGxlY3Rpb25OYW1lIFRoZSBwcm9ncmFtbWF0aWMgbmFtZSBvZiB0aGUgY29sbGVjdGlvbiB0aGF0IHdhcyBjaGFuZ2VkLgotCSAqIEBwYXJhbSBpdGVtcyBUaGUgaXRlbXMgdGhhdCB3ZXJlIGFkZGVkIHRvIG9yIHJlbW92ZWQgZnJvbSB0aGUgY29sbGVjdGlvbi4KLQkgKi8KLQlwdWJsaWMgQ29sbGVjdGlvbkNoYW5nZUV2ZW50KE1vZGVsIHNvdXJjZSwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lLCBDb2xsZWN0aW9uPD8+IGl0ZW1zKSB7Ci0JCXN1cGVyKHNvdXJjZSk7Ci0JCWlmICgoY29sbGVjdGlvbk5hbWUgPT0gbnVsbCkgfHwgKGl0ZW1zID09IG51bGwpKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLmNvbGxlY3Rpb25OYW1lID0gY29sbGVjdGlvbk5hbWU7Ci0JCXRoaXMuaXRlbXMgPSBDb2xsZWN0aW9ucy51bm1vZGlmaWFibGVDb2xsZWN0aW9uKGl0ZW1zKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBuZXcgY29sbGVjdGlvbiBjaGFuZ2UgZXZlbnQuCi0JICoKLQkgKiBAcGFyYW0gc291cmNlIFRoZSBvYmplY3Qgb24gd2hpY2ggdGhlIGV2ZW50IGluaXRpYWxseSBvY2N1cnJlZC4KLQkgKiBAcGFyYW0gY29sbGVjdGlvbk5hbWUgVGhlIHByb2dyYW1tYXRpYyBuYW1lIG9mIHRoZSBjb2xsZWN0aW9uIHRoYXQgd2FzIGNoYW5nZWQuCi0JICovCi0JcHVibGljIENvbGxlY3Rpb25DaGFuZ2VFdmVudChNb2RlbCBzb3VyY2UsIFN0cmluZyBjb2xsZWN0aW9uTmFtZSkgewotCQl0aGlzKHNvdXJjZSwgY29sbGVjdGlvbk5hbWUsIENvbGxlY3Rpb25zLmVtcHR5U2V0KCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBzdGFuZGFyZCBzdGF0ZSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHByb2dyYW1tYXRpYyBuYW1lIG9mIHRoZSBjb2xsZWN0aW9uIHRoYXQgd2FzIGNoYW5nZWQuCi0JICovCi0JcHVibGljIFN0cmluZyBnZXRDb2xsZWN0aW9uTmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMuY29sbGVjdGlvbk5hbWU7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyBnZXRBc3BlY3ROYW1lKCkgewotCQlyZXR1cm4gdGhpcy5jb2xsZWN0aW9uTmFtZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYW4gaXRlcmF0b3Igb24gdGhlIGl0ZW1zIHRoYXQgd2VyZSBhZGRlZCB0byBvcgotCSAqIHJlbW92ZWQgZnJvbSB0aGUgY29sbGVjdGlvbi4KLQkgKiBNYXkgYmUgZW1wdHkgaWYgaW5hcHByb3ByaWF0ZSBvciB1bmtub3duLgotCSAqLwotCXB1YmxpYyBJdGVyYXRvcjw/PiBpdGVtcygpIHsKLQkJcmV0dXJuIHRoaXMuaXRlbXMuaXRlcmF0b3IoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG51bWJlciBvZiBpdGVtcyB0aGF0IHdlcmUgYWRkZWQgdG8gb3IKLQkgKiByZW1vdmVkIGZyb20gdGhlIGNvbGxlY3Rpb24uCi0JICogTWF5IGJlIDAgaWYgaW5hcHByb3ByaWF0ZSBvciB1bmtub3duLgotCSAqLwotCXB1YmxpYyBpbnQgaXRlbXNTaXplKCkgewotCQlyZXR1cm4gdGhpcy5pdGVtcy5zaXplKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNsb25pbmcgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIGEgY29weSBvZiB0aGUgZXZlbnQgd2l0aCB0aGUgc3BlY2lmaWVkIHNvdXJjZQotCSAqIHJlcGxhY2luZyB0aGUgY3VycmVudCBzb3VyY2UuCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIENvbGxlY3Rpb25DaGFuZ2VFdmVudCBjbG9uZVdpdGhTb3VyY2UoTW9kZWwgbmV3U291cmNlKSB7Ci0JCXJldHVybiBuZXcgQ29sbGVjdGlvbkNoYW5nZUV2ZW50KG5ld1NvdXJjZSwgdGhpcy5jb2xsZWN0aW9uTmFtZSwgdGhpcy5pdGVtcyk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgY29weSBvZiB0aGUgZXZlbnQgd2l0aCB0aGUgc3BlY2lmaWVkIHNvdXJjZSBhbmQgY29sbGVjdGlvbiBuYW1lCi0JICogcmVwbGFjaW5nIHRoZSBjdXJyZW50IHNvdXJjZSBhbmQgY29sbGVjdGlvbiBuYW1lLgotCSAqLwotCXB1YmxpYyBDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgY2xvbmVXaXRoU291cmNlKE1vZGVsIG5ld1NvdXJjZSwgU3RyaW5nIG5ld0NvbGxlY3Rpb25OYW1lKSB7Ci0JCXJldHVybiBuZXcgQ29sbGVjdGlvbkNoYW5nZUV2ZW50KG5ld1NvdXJjZSwgbmV3Q29sbGVjdGlvbk5hbWUsIHRoaXMuaXRlbXMpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2V2ZW50L0xpc3RDaGFuZ2VFdmVudC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2V2ZW50L0xpc3RDaGFuZ2VFdmVudC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5ZWMxOGFlLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9ldmVudC9MaXN0Q2hhbmdlRXZlbnQuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI2MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50OwotCi1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb25zOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci0KLS8qKgotICogQSAibGlzdCBjaGFuZ2UiIGV2ZW50IGdldHMgZGVsaXZlcmVkIHdoZW5ldmVyIGEgbW9kZWwgY2hhbmdlcyBhICJib3VuZCIKLSAqIG9yICJjb25zdHJhaW5lZCIgbGlzdC4gQSBMaXN0Q2hhbmdlRXZlbnQgaXMgc2VudCBhcyBhbgotICogYXJndW1lbnQgdG8gdGhlIExpc3RDaGFuZ2VMaXN0ZW5lci4KLSAqIAotICogTm9ybWFsbHkgYSBMaXN0Q2hhbmdlRXZlbnQgaXMgYWNjb21wYW5pZWQgYnkgdGhlIGxpc3QgbmFtZSwKLSAqIHRoZSBpdGVtcyB0aGF0IHdlcmUgYWRkZWQgdG8gb3IgcmVtb3ZlZCBmcm9tIHRoZSBjaGFuZ2VkIGxpc3QsCi0gKiBhbmQgdGhlIGluZGV4IG9mIHdoZXJlIHRoZSBpdGVtcyBhcmUgb3Igd2VyZSBpbiB0aGUgbGlzdC4KLSAqIAotICogRGVzaWduIG9wdGlvbnM6Ci0gKiAtIGNyZWF0ZSBhIGxpc3QgdG8gd3JhcCBhIHNpbmdsZSBhZGRlZCBvciByZW1vdmVkIGl0ZW0KLSAqIAkodGhpcyBpcyB0aGUgb3B0aW9uIHdlIGltcGxlbWVudGVkIGJlbG93IGFuZCBpbiBjb2xsYWJvcmF0aW5nIGNvZGUpCi0gKiAJc2luY2UgdGhlcmUgaXMgbm8gd2F5IHRvIG9wdGltaXplIGRvd25zdHJlYW0gY29kZSBmb3IKLSAqIAlzaW5nbGUgaXRlbXMsIHdlIHRha2UgYW5vdGhlciBwZXJmb3JtYW5jZSBoaXQgYnkgYnVpbGRpbmcKLSAqIAlhIGxpc3QgZWFjaCB0aW1lICAoQHNlZSBDb2xsZWN0aW9ucyNzaW5nbGV0b25MaXN0KE9iamVjdCkpCi0gKiAJYW5kIGZvcmNpbmcgZG93bnN0cmVhbSBjb2RlIHRvIHVzZSBhIGxpc3QgaXRlcmF0b3IgZXZlcnkgdGltZQotICogCi0gKiAtIGZpcmUgYSBzZXBhcmF0ZSBldmVudCBmb3IgZWFjaCBpdGVtIGFkZGVkIG9yIHJlbW92ZWQKLSAqIAllbGltaW5hdGVzIGFueSBwb3RlbnRpYWwgZm9yIG9wdGltaXphdGlvbnMgdG8gZG93bnN0cmVhbSBjb2RlCi0gKiAKLSAqIC0gYWRkIHByb3RvY29sIHRvIHN1cHBvcnQgYm90aCBzaW5nbGUgaXRlbXMgYW5kIGNvbGxlY3Rpb25zCi0gKiAJYWRkcyBjb25kaXRpb25hbCBsb2dpYyB0byBkb3duc3RyZWFtIGNvZGUKLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGNsYXNzIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbAotICogdW5kZXIgZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZwotICogc3RhYmlsaXR5LiBJdCBpcyBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20KLSAqIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgdGhpcyBBUEkKLSAqIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KLSAqLwotcHVibGljIGNsYXNzIExpc3RDaGFuZ2VFdmVudCBleHRlbmRzIENoYW5nZUV2ZW50IHsKLQotCS8qKgotCSAqIE5hbWUgb2YgdGhlIGxpc3QgdGhhdCBjaGFuZ2VkLgotCSAqLwotCXByaXZhdGUgZmluYWwgU3RyaW5nIGxpc3ROYW1lOwotCi0JLyoqCi0JICogVGhlIGluZGV4IGF0IHdoaWNoIHRoZSBpdGVtcyB3ZXJlIGFkZGVkLCByZW1vdmVkLCBvciByZXBsYWNlZC4KLQkgKiBJbiB0aGUgY2FzZSBvZiAibW92ZWQiIGl0ZW1zLCB0aGlzIHdpbGwgYmUgdGhlICJ0YXJnZXQiIGluZGV4LgotCSAqIE1heSBiZSAtMSwgaWYgbm90IGtub3duLgotCSAqLwotCXByaXZhdGUgZmluYWwgaW50IGluZGV4OwotCi0JLyoqCi0JICogVGhlIGl0ZW1zIHRoYXQgd2VyZSBhZGRlZCB0byBvciByZW1vdmVkIGZyb20gdGhlIGxpc3QuIEluIHRoZSBjYXNlIG9mCi0JICogInJlcGxhY2VkIiBpdGVtcywgdGhlc2UgYXJlIHRoZSBuZXcgaXRlbXMgaW4gdGhlIGxpc3QuCi0JICogSW4gdGhlIGNhc2Ugb2YgIm1vdmVkIiBpdGVtcywgdGhpcyB3aWxsIGJlIGVtcHR5LgotCSAqIE1heSBiZSBlbXB0eSwgaWYgbm90IGtub3duLgotCSAqLwotCXByaXZhdGUgZmluYWwgTGlzdDw/PiBpdGVtczsKLQotCS8qKgotCSAqIFRoZSBpdGVtcyBpbiB0aGUgbGlzdCB0aGF0IHdlcmUgcmVwbGFjZWQgYnkgdGhlIGl0ZW1zIGxpc3RlZCBhYm92ZSwKLQkgKiBpbiAjaXRlbXMuIE1heSBiZSBlbXB0eSwgaWYgbm90IGtub3duLgotCSAqLwotCXByaXZhdGUgZmluYWwgTGlzdDw/PiByZXBsYWNlZEl0ZW1zOwotCi0JLyoqCi0JICogSW4gdGhlIGNhc2Ugb2YgIm1vdmVkIiBpdGVtcywgdGhpcyB3aWxsIGJlIHRoZSAic291cmNlIiBpbmRleC4KLQkgKiBNYXkgYmUgLTEsIGlmIG5vdCBrbm93bi4KLQkgKi8KLQlwcml2YXRlIGZpbmFsIGludCBzb3VyY2VJbmRleDsKLQotCS8qKgotCSAqIEluIHRoZSBjYXNlIG9mICJtb3ZlZCIgaXRlbXMsIHRoaXMgd2lsbCBiZSB0aGUgbnVtYmVyIG9mIGl0ZW1zIG1vdmVkLgotCSAqIE1heSBiZSAtMSwgaWYgbm90IGtub3duLgotCSAqLwotCXByaXZhdGUgZmluYWwgaW50IG1vdmVMZW5ndGg7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JcHJvdGVjdGVkIExpc3RDaGFuZ2VFdmVudChNb2RlbCBzb3VyY2UsIFN0cmluZyBsaXN0TmFtZSwgaW50IGluZGV4LCBMaXN0PD8+IGl0ZW1zLCBMaXN0PD8+IHJlcGxhY2VkSXRlbXMsIGludCBzb3VyY2VJbmRleCwgaW50IG1vdmVMZW5ndGgpIHsKLQkJc3VwZXIoc291cmNlKTsKLQkJaWYgKChsaXN0TmFtZSA9PSBudWxsKSB8fCAoaXRlbXMgPT0gbnVsbCkgfHwgKHJlcGxhY2VkSXRlbXMgPT0gbnVsbCkpIHsKLQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigpOwotCQl9Ci0JCXRoaXMubGlzdE5hbWUgPSBsaXN0TmFtZTsKLQkJdGhpcy5pbmRleCA9IGluZGV4OwotCQl0aGlzLml0ZW1zID0gQ29sbGVjdGlvbnMudW5tb2RpZmlhYmxlTGlzdChpdGVtcyk7Ci0JCXRoaXMucmVwbGFjZWRJdGVtcyA9IENvbGxlY3Rpb25zLnVubW9kaWZpYWJsZUxpc3QocmVwbGFjZWRJdGVtcyk7Ci0JCXRoaXMuc291cmNlSW5kZXggPSBzb3VyY2VJbmRleDsKLQkJdGhpcy5tb3ZlTGVuZ3RoID0gbW92ZUxlbmd0aDsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBuZXcgbGlzdCBjaGFuZ2UgZXZlbnQgZm9yIGEgbGlzdCBvZiByZXBsYWNlZCBpdGVtcy4KLQkgKgotCSAqIEBwYXJhbSBzb3VyY2UgVGhlIG9iamVjdCBvbiB3aGljaCB0aGUgZXZlbnQgaW5pdGlhbGx5IG9jY3VycmVkLgotCSAqIEBwYXJhbSBsaXN0TmFtZSBUaGUgcHJvZ3JhbW1hdGljIG5hbWUgb2YgdGhlIGxpc3QgdGhhdCB3YXMgY2hhbmdlZC4KLQkgKiBAcGFyYW0gaW5kZXggVGhlIGluZGV4IGF0IHdoaWNoIHRoZSBpdGVtcyBpbiB0aGUgbGlzdCB3ZXJlIHJlcGxhY2VkLgotCSAqIEBwYXJhbSBpdGVtcyBUaGUgbmV3IGl0ZW1zIGluIHRoZSBsaXN0LgotCSAqIEBwYXJhbSByZXBsYWNlZEl0ZW1zIFRoZSBpdGVtcyBpbiB0aGUgbGlzdCB0aGF0IHdlcmUgcmVwbGFjZWQuCi0JICovCi0JcHVibGljIExpc3RDaGFuZ2VFdmVudChNb2RlbCBzb3VyY2UsIFN0cmluZyBsaXN0TmFtZSwgaW50IGluZGV4LCBMaXN0PD8+IGl0ZW1zLCBMaXN0PD8+IHJlcGxhY2VkSXRlbXMpIHsKLQkJdGhpcyhzb3VyY2UsIGxpc3ROYW1lLCBpbmRleCwgaXRlbXMsIHJlcGxhY2VkSXRlbXMsIC0xLCAtMSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgbmV3IGxpc3QgY2hhbmdlIGV2ZW50IGZvciBhIGxpc3Qgb2YgYWRkZWQgb3IgcmVtb3ZlZCBpdGVtcy4KLQkgKgotCSAqIEBwYXJhbSBzb3VyY2UgVGhlIG9iamVjdCBvbiB3aGljaCB0aGUgZXZlbnQgaW5pdGlhbGx5IG9jY3VycmVkLgotCSAqIEBwYXJhbSBsaXN0TmFtZSBUaGUgcHJvZ3JhbW1hdGljIG5hbWUgb2YgdGhlIGxpc3QgdGhhdCB3YXMgY2hhbmdlZC4KLQkgKiBAcGFyYW0gaW5kZXggVGhlIGluZGV4IGF0IHdoaWNoIHRoZSBpdGVtcyB3ZXJlIGFkZGVkIHRvIG9yIHJlbW92ZWQgZnJvbSB0aGUgbGlzdC4KLQkgKiBAcGFyYW0gaXRlbXMgVGhlIGl0ZW1zIHRoYXQgd2VyZSBhZGRlZCB0byBvciByZW1vdmVkIGZyb20gdGhlIGxpc3QuCi0JICovCi0JcHVibGljIExpc3RDaGFuZ2VFdmVudChNb2RlbCBzb3VyY2UsIFN0cmluZyBsaXN0TmFtZSwgaW50IGluZGV4LCBMaXN0PD8+IGl0ZW1zKSB7Ci0JCXRoaXMoc291cmNlLCBsaXN0TmFtZSwgaW5kZXgsIGl0ZW1zLCBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKSwgLTEsIC0xKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBuZXcgbGlzdCBjaGFuZ2UgZXZlbnQgZm9yIGEgbGlzdCBvZiBtb3ZlZCBpdGVtcy4KLQkgKgotCSAqIEBwYXJhbSBzb3VyY2UgVGhlIG9iamVjdCBvbiB3aGljaCB0aGUgZXZlbnQgaW5pdGlhbGx5IG9jY3VycmVkLgotCSAqIEBwYXJhbSBsaXN0TmFtZSBUaGUgcHJvZ3JhbW1hdGljIG5hbWUgb2YgdGhlIGxpc3QgdGhhdCB3YXMgY2hhbmdlZC4KLQkgKiBAcGFyYW0gdGFyZ2V0SW5kZXggVGhlIGluZGV4IHRvIHdoaWNoIHRoZSBpdGVtcyB3ZXJlIG1vdmVkLgotCSAqIEBwYXJhbSBzb3VyY2VJbmRleCBUaGUgaW5kZXggZnJvbSB3aGljaCB0aGUgaXRlbXMgd2VyZSBtb3ZlZC4KLQkgKi8KLQlwdWJsaWMgTGlzdENoYW5nZUV2ZW50KE1vZGVsIHNvdXJjZSwgU3RyaW5nIGxpc3ROYW1lLCBpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCwgaW50IGxlbmd0aCkgewotCQl0aGlzKHNvdXJjZSwgbGlzdE5hbWUsIHRhcmdldEluZGV4LCBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKSwgQ29sbGVjdGlvbnMuZW1wdHlMaXN0KCksIHNvdXJjZUluZGV4LCBsZW5ndGgpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIG5ldyBsaXN0IGNoYW5nZSBldmVudC4KLQkgKgotCSAqIEBwYXJhbSBzb3VyY2UgVGhlIG9iamVjdCBvbiB3aGljaCB0aGUgZXZlbnQgaW5pdGlhbGx5IG9jY3VycmVkLgotCSAqIEBwYXJhbSBsaXN0TmFtZSBUaGUgcHJvZ3JhbW1hdGljIG5hbWUgb2YgdGhlIGxpc3QgdGhhdCB3YXMgY2hhbmdlZC4KLQkgKi8KLQlwdWJsaWMgTGlzdENoYW5nZUV2ZW50KE1vZGVsIHNvdXJjZSwgU3RyaW5nIGxpc3ROYW1lKSB7Ci0JCXRoaXMoc291cmNlLCBsaXN0TmFtZSwgLTEsIENvbGxlY3Rpb25zLmVtcHR5TGlzdCgpLCBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKSwgLTEsIC0xKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogc3RhbmRhcmQgc3RhdGUgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBwcm9ncmFtbWF0aWMgbmFtZSBvZiB0aGUgbGlzdCB0aGF0IHdhcyBjaGFuZ2VkLgotCSAqLwotCXB1YmxpYyBTdHJpbmcgZ2V0TGlzdE5hbWUoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3ROYW1lOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgZ2V0QXNwZWN0TmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMubGlzdE5hbWU7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBpbmRleCBhdCB3aGljaCB0aGUgaXRlbXMgd2VyZSBhZGRlZCB0bywgcmVtb3ZlZCBmcm9tLAotCSAqIG9yIHJlcGxhY2VkIGluIHRoZSBsaXN0LgotCSAqIEluIHRoZSBjYXNlIG9mICJtb3ZlZCIgaXRlbXMsIHRoaXMgd2lsbCBiZSB0aGUgInRhcmdldCIgaW5kZXguCi0JICogTWF5IGJlIC0xIGlmIGluYXBwcm9wcmlhdGUgb3IgdW5rbm93bi4KLQkgKi8KLQlwdWJsaWMgaW50IGdldEluZGV4KCkgewotCQlyZXR1cm4gdGhpcy5pbmRleDsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBsaXN0IGl0ZXJhdG9yIG9uIHRoZSBpdGVtcyB0aGF0IHdlcmUgYWRkZWQgdG8gb3IKLQkgKiByZW1vdmVkIGZyb20gdGhlIGxpc3QuIEluIHRoZSBjYXNlIG9mICJyZXBsYWNlZCIgaXRlbXMsIHRoZXNlCi0JICogYXJlIHRoZSBuZXcgaXRlbXMgaW4gdGhlIGxpc3QuCi0JICogTWF5IGJlIGVtcHR5IGlmIGluYXBwcm9wcmlhdGUgb3IgdW5rbm93bi4KLQkgKi8KLQlwdWJsaWMgTGlzdEl0ZXJhdG9yPD8+IGl0ZW1zKCkgewotCQlyZXR1cm4gdGhpcy5pdGVtcy5saXN0SXRlcmF0b3IoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG51bWJlciBvZiBpdGVtcyB0aGF0IHdlcmUgYWRkZWQgdG8sCi0JICogcmVtb3ZlZCBmcm9tLCBvciByZXBsYWNlZCBpbiB0aGUgbGlzdC4KLQkgKiBNYXkgYmUgMCBpZiBpbmFwcHJvcHJpYXRlIG9yIHVua25vd24uCi0JICovCi0JcHVibGljIGludCBpdGVtc1NpemUoKSB7Ci0JCXJldHVybiB0aGlzLml0ZW1zLnNpemUoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogcmVwbGFjZSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gYSBsaXN0IGl0ZXJhdG9yIG9uIHRoZSBpdGVtcyBpbiB0aGUgbGlzdCB0aGF0IHdlcmUgcmVwbGFjZWQuCi0JICogTWF5IGJlIGVtcHR5IGlmIGluYXBwcm9wcmlhdGUgb3IgdW5rbm93bi4KLQkgKi8KLQlwdWJsaWMgTGlzdEl0ZXJhdG9yPD8+IHJlcGxhY2VkSXRlbXMoKSB7Ci0JCXJldHVybiB0aGlzLnJlcGxhY2VkSXRlbXMubGlzdEl0ZXJhdG9yKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIG1vdmUgKioqKioqKioqKgotCi0JLyoqCi0JICogSW4gdGhlIGNhc2Ugb2YgIm1vdmVkIiBpdGVtcywgdGhpcyB3aWxsIGJlIHRoZSAidGFyZ2V0IiBpbmRleC4KLQkgKiBNYXkgYmUgLTEgaWYgaW5hcHByb3ByaWF0ZSBvciB1bmtub3duLgotCSAqLwotCXB1YmxpYyBpbnQgZ2V0VGFyZ2V0SW5kZXgoKSB7Ci0JCXJldHVybiB0aGlzLmluZGV4OwotCX0KLQotCS8qKgotCSAqIEluIHRoZSBjYXNlIG9mICJtb3ZlZCIgaXRlbXMsIHRoaXMgd2lsbCBiZSB0aGUgInNvdXJjZSIgaW5kZXguCi0JICogTWF5IGJlIC0xIGlmIGluYXBwcm9wcmlhdGUgb3IgdW5rbm93bi4KLQkgKi8KLQlwdWJsaWMgaW50IGdldFNvdXJjZUluZGV4KCkgewotCQlyZXR1cm4gdGhpcy5zb3VyY2VJbmRleDsKLQl9Ci0KLQkvKioKLQkgKiBJbiB0aGUgY2FzZSBvZiAibW92ZWQiIGl0ZW1zLCB0aGlzIHdpbGwgYmUgdGhlIG51bWJlciBvZiBpdGVtcyBtb3ZlZC4KLQkgKiBNYXkgYmUgLTEgaWYgaW5hcHByb3ByaWF0ZSBvciB1bmtub3duLgotCSAqLwotCXB1YmxpYyBpbnQgZ2V0TW92ZUxlbmd0aCgpIHsKLQkJcmV0dXJuIHRoaXMubW92ZUxlbmd0aDsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY2xvbmluZyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gYSBjb3B5IG9mIHRoZSBldmVudCB3aXRoIHRoZSBzcGVjaWZpZWQgc291cmNlCi0JICogcmVwbGFjaW5nIHRoZSBjdXJyZW50IHNvdXJjZS4KLQkgKi8KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgTGlzdENoYW5nZUV2ZW50IGNsb25lV2l0aFNvdXJjZShNb2RlbCBuZXdTb3VyY2UpIHsKLQkJcmV0dXJuIG5ldyBMaXN0Q2hhbmdlRXZlbnQobmV3U291cmNlLCB0aGlzLmxpc3ROYW1lLCB0aGlzLmluZGV4LCB0aGlzLml0ZW1zLCB0aGlzLnJlcGxhY2VkSXRlbXMsIHRoaXMuc291cmNlSW5kZXgsIHRoaXMubW92ZUxlbmd0aCk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgY29weSBvZiB0aGUgZXZlbnQgd2l0aCB0aGUgc3BlY2lmaWVkIHNvdXJjZSBhbmQgbGlzdCBuYW1lCi0JICogcmVwbGFjaW5nIHRoZSBjdXJyZW50IHNvdXJjZSBhbmQgbGlzdCBuYW1lLgotCSAqLwotCXB1YmxpYyBMaXN0Q2hhbmdlRXZlbnQgY2xvbmVXaXRoU291cmNlKE1vZGVsIG5ld1NvdXJjZSwgU3RyaW5nIG5ld0xpc3ROYW1lKSB7Ci0JCXJldHVybiBuZXcgTGlzdENoYW5nZUV2ZW50KG5ld1NvdXJjZSwgbmV3TGlzdE5hbWUsIHRoaXMuaW5kZXgsIHRoaXMuaXRlbXMsIHRoaXMucmVwbGFjZWRJdGVtcywgdGhpcy5zb3VyY2VJbmRleCwgdGhpcy5tb3ZlTGVuZ3RoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gYSBjb3B5IG9mIHRoZSBldmVudCB3aXRoIHRoZSBzcGVjaWZpZWQgc291cmNlIGFuZCBsaXN0IG5hbWUKLQkgKiByZXBsYWNpbmcgdGhlIGN1cnJlbnQgc291cmNlIGFuZCBsaXN0IG5hbWUgYW5kIGRpc3BsYWNpbmcKLQkgKiB0aGUgaW5kZXggYnkgdGhlIHNwZWNpZmllZCBhbW91bnQuCi0JICovCi0JcHVibGljIExpc3RDaGFuZ2VFdmVudCBjbG9uZVdpdGhTb3VyY2UoTW9kZWwgbmV3U291cmNlLCBTdHJpbmcgbmV3TGlzdE5hbWUsIGludCBvZmZzZXQpIHsKLQkJcmV0dXJuIG5ldyBMaXN0Q2hhbmdlRXZlbnQobmV3U291cmNlLCBuZXdMaXN0TmFtZSwgdGhpcy5pbmRleCArIG9mZnNldCwgdGhpcy5pdGVtcywgdGhpcy5yZXBsYWNlZEl0ZW1zLCB0aGlzLnNvdXJjZUluZGV4ICsgb2Zmc2V0LCB0aGlzLm1vdmVMZW5ndGgpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2V2ZW50L1Byb3BlcnR5Q2hhbmdlRXZlbnQuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9ldmVudC9Qcm9wZXJ0eUNoYW5nZUV2ZW50LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVlMmZhMmYuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2V2ZW50L1Byb3BlcnR5Q2hhbmdlRXZlbnQuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEwNCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50OwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci0KLS8qKgotICogQSAicHJvcGVydHkgY2hhbmdlIiBldmVudCBnZXRzIGRlbGl2ZXJlZCB3aGVuZXZlciBhIG1vZGVsIGNoYW5nZXMgYSAiYm91bmQiCi0gKiBvciAiY29uc3RyYWluZWQiIHByb3BlcnR5LiBBIFByb3BlcnR5Q2hhbmdlRXZlbnQgaXMgc2VudCBhcyBhbgotICogYXJndW1lbnQgdG8gdGhlIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIuCi0gKiAKLSAqIFByb3Zpc2lvbmFsIEFQSTogVGhpcyBjbGFzcyBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKi8KLXB1YmxpYyBjbGFzcyBQcm9wZXJ0eUNoYW5nZUV2ZW50IGV4dGVuZHMgQ2hhbmdlRXZlbnQgewotCi0JLyoqIE5hbWUgb2YgdGhlIHByb3BlcnR5IHRoYXQgY2hhbmdlZC4gKi8KLQlwcml2YXRlIGZpbmFsIFN0cmluZyBwcm9wZXJ0eU5hbWU7Ci0KLQkvKiogVGhlIHByb3BlcnR5J3Mgb2xkIHZhbHVlLCBiZWZvcmUgdGhlIGNoYW5nZS4gKi8KLQlwcml2YXRlIGZpbmFsIE9iamVjdCBvbGRWYWx1ZTsKLQotCS8qKiBUaGUgcHJvcGVydHkncyBuZXcgdmFsdWUsIGFmdGVyIHRoZSBjaGFuZ2UuICovCi0JcHJpdmF0ZSBmaW5hbCBPYmplY3QgbmV3VmFsdWU7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgbmV3IHByb3BlcnR5IGNoYW5nZSBldmVudC4KLQkgKgotCSAqIEBwYXJhbSBzb3VyY2UgVGhlIG9iamVjdCBvbiB3aGljaCB0aGUgZXZlbnQgaW5pdGlhbGx5IG9jY3VycmVkLgotCSAqIEBwYXJhbSBwcm9wZXJ0eU5hbWUgVGhlIHByb2dyYW1tYXRpYyBuYW1lIG9mIHRoZSBwcm9wZXJ0eSB0aGF0IHdhcyBjaGFuZ2VkLgotCSAqIEBwYXJhbSBvbGRWYWx1ZSBUaGUgb2xkIHZhbHVlIG9mIHRoZSBwcm9wZXJ0eS4KLQkgKiBAcGFyYW0gbmV3VmFsdWUgVGhlIG5ldyB2YWx1ZSBvZiB0aGUgcHJvcGVydHkuCi0JICovCi0JcHVibGljIFByb3BlcnR5Q2hhbmdlRXZlbnQoTW9kZWwgc291cmNlLCBTdHJpbmcgcHJvcGVydHlOYW1lLCBPYmplY3Qgb2xkVmFsdWUsIE9iamVjdCBuZXdWYWx1ZSkgewotCQlzdXBlcihzb3VyY2UpOwotCQlpZiAocHJvcGVydHlOYW1lID09IG51bGwpIHsKLQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigpOwotCQl9Ci0JCXRoaXMucHJvcGVydHlOYW1lID0gcHJvcGVydHlOYW1lOwotCQl0aGlzLm9sZFZhbHVlID0gb2xkVmFsdWU7Ci0JCXRoaXMubmV3VmFsdWUgPSBuZXdWYWx1ZTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogc3RhbmRhcmQgc3RhdGUgKioqKioqKioqKgotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBwcm9ncmFtbWF0aWMgbmFtZSBvZiB0aGUgcHJvcGVydHkgdGhhdCB3YXMgY2hhbmdlZC4KLQkgKi8KLQlwdWJsaWMgU3RyaW5nIGdldFByb3BlcnR5TmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMucHJvcGVydHlOYW1lOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyBTdHJpbmcgZ2V0QXNwZWN0TmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMucHJvcGVydHlOYW1lOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgb2xkIHZhbHVlIG9mIHRoZSBwcm9wZXJ0eS4KLQkgKi8KLQlwdWJsaWMgT2JqZWN0IGdldE9sZFZhbHVlKCkgewotCQlyZXR1cm4gdGhpcy5vbGRWYWx1ZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIG5ldyB2YWx1ZSBvZiB0aGUgcHJvcGVydHkuCi0JICovCi0JcHVibGljIE9iamVjdCBnZXROZXdWYWx1ZSgpIHsKLQkJcmV0dXJuIHRoaXMubmV3VmFsdWU7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNsb25pbmcgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHVibGljIFByb3BlcnR5Q2hhbmdlRXZlbnQgY2xvbmVXaXRoU291cmNlKE1vZGVsIG5ld1NvdXJjZSkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlRXZlbnQobmV3U291cmNlLCB0aGlzLnByb3BlcnR5TmFtZSwgdGhpcy5vbGRWYWx1ZSwgdGhpcy5uZXdWYWx1ZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIGEgY29weSBvZiB0aGUgZXZlbnQgd2l0aCB0aGUgc3BlY2lmaWVkIHNvdXJjZQotCSAqIHJlcGxhY2luZyB0aGUgY3VycmVudCBzb3VyY2UgYW5kIHRoZSBwcm9wZXJ0eSBuYW1lLgotCSAqLwotCXB1YmxpYyBQcm9wZXJ0eUNoYW5nZUV2ZW50IGNsb25lV2l0aFNvdXJjZShNb2RlbCBuZXdTb3VyY2UsIFN0cmluZyBuZXdQcm9wZXJ0eU5hbWUpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUNoYW5nZUV2ZW50KG5ld1NvdXJjZSwgbmV3UHJvcGVydHlOYW1lLCB0aGlzLm9sZFZhbHVlLCB0aGlzLm5ld1ZhbHVlKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9ldmVudC9TdGF0ZUNoYW5nZUV2ZW50LmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvZXZlbnQvU3RhdGVDaGFuZ2VFdmVudC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1MmUzNjkwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9ldmVudC9TdGF0ZUNoYW5nZUV2ZW50LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50OwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci0KLS8qKgotICogQSBnZW5lcmljICJzdGF0ZSBjaGFuZ2UiIGV2ZW50IGdldHMgZGVsaXZlcmVkIHdoZW5ldmVyIGEgbW9kZWwgY2hhbmdlcyB0byAKLSAqIHN1Y2ggZXh0ZW50IHRoYXQgaXQgY2Fubm90IGJlIGRlbGluZWF0ZWQgYWxsIGFzcGVjdHMgb2YgaXQgdGhhdCBoYXZlIGNoYW5nZWQuIAotICogQSBTdGF0ZUNoYW5nZUV2ZW50IGlzIHNlbnQgYXMgYW4gYXJndW1lbnQgdG8gdGhlIFN0YXRlQ2hhbmdlTGlzdGVuZXIuCi0gKiAKLSAqIFByb3Zpc2lvbmFsIEFQSTogVGhpcyBjbGFzcyBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKi8KLXB1YmxpYyBjbGFzcyBTdGF0ZUNoYW5nZUV2ZW50IGV4dGVuZHMgQ2hhbmdlRXZlbnQgewotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0KLQotCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIG5ldyBzdGF0ZSBjaGFuZ2UgZXZlbnQuCi0JICoKLQkgKiBAcGFyYW0gc291cmNlIFRoZSBvYmplY3Qgb24gd2hpY2ggdGhlIGV2ZW50IGluaXRpYWxseSBvY2N1cnJlZC4KLQkgKi8KLQlwdWJsaWMgU3RhdGVDaGFuZ2VFdmVudChNb2RlbCBzb3VyY2UpIHsKLQkJc3VwZXIoc291cmNlKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogc3RhbmRhcmQgc3RhdGUgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyBnZXRBc3BlY3ROYW1lKCkgewotCQlyZXR1cm4gbnVsbDsgIC8vIHRoZSBwb2ludCBvZiB0aGUgZXZlbnQgaXMgdGhhdCB0aGUgbmFtZSBpcyB1bmtub3duLi4uCi0JfQotCi0KLQkvLyAqKioqKioqKioqIGNsb25pbmcgKioqKioqKioqKgotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0YXRlQ2hhbmdlRXZlbnQgY2xvbmVXaXRoU291cmNlKE1vZGVsIG5ld1NvdXJjZSkgewotCQlyZXR1cm4gbmV3IFN0YXRlQ2hhbmdlRXZlbnQobmV3U291cmNlKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9ldmVudC9UcmVlQ2hhbmdlRXZlbnQuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9ldmVudC9UcmVlQ2hhbmdlRXZlbnQuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjI3MjAyMC4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvZXZlbnQvVHJlZUNoYW5nZUV2ZW50LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMTEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLk1vZGVsOwotCi0vKioKLSAqIEEgInRyZWUgY2hhbmdlIiBldmVudCBnZXRzIGRlbGl2ZXJlZCB3aGVuZXZlciBhIG1vZGVsIGNoYW5nZXMgYSAiYm91bmQiCi0gKiBvciAiY29uc3RyYWluZWQiIHRyZWUuIEEgVHJlZUNoYW5nZUV2ZW50IGlzIHNlbnQgYXMgYW4KLSAqIGFyZ3VtZW50IHRvIHRoZSBUcmVlQ2hhbmdlTGlzdGVuZXIuCi0gKiAKLSAqIE5vcm1hbGx5IGEgVHJlZUNoYW5nZUV2ZW50IGlzIGFjY29tcGFuaWVkIGJ5IHRoZSB0cmVlIG5hbWUgYW5kIGEgcGF0aAotICogdG8gdGhlIHBhcnQgb2YgdGhlIHRyZWUgdGhhdCB3YXMgY2hhbmdlZC4KLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGNsYXNzIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbAotICogdW5kZXIgZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZwotICogc3RhYmlsaXR5LiBJdCBpcyBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20KLSAqIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgdGhpcyBBUEkKLSAqIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KLSAqLwotcHVibGljIGNsYXNzIFRyZWVDaGFuZ2VFdmVudCBleHRlbmRzIENoYW5nZUV2ZW50IHsKLQotCS8qKiBOYW1lIG9mIHRoZSB0cmVlIHRoYXQgY2hhbmdlZC4gKi8KLQlwcml2YXRlIGZpbmFsIFN0cmluZyB0cmVlTmFtZTsKLQotICAgIC8qKgotICAgICAqIFBhdGggdG8gdGhlIHBhcmVudCBvZiB0aGUgcGFydCBvZiB0aGUgdHJlZSB0aGF0IHdhcyBjaGFuZ2VkLgotICAgICAqIE1heSBiZSBlbXB0eSwgaWYgbm90IGtub3duIG9yIGlmIHRoZSBlbnRpcmUgdHJlZSBjaGFuZ2VkLgotICAgICAqLwotCXByb3RlY3RlZCBmaW5hbCBPYmplY3RbXSBwYXRoOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgT2JqZWN0W10gRU1QVFlfUEFUSCA9IG5ldyBPYmplY3RbMF07Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgbmV3IHRyZWUgY2hhbmdlIGV2ZW50LgotCSAqCi0JICogQHBhcmFtIHNvdXJjZSBUaGUgb2JqZWN0IG9uIHdoaWNoIHRoZSBldmVudCBpbml0aWFsbHkgb2NjdXJyZWQuCi0JICogQHBhcmFtIHRyZWVOYW1lIFRoZSBwcm9ncmFtbWF0aWMgbmFtZSBvZiB0aGUgdHJlZSB0aGF0IHdhcyBjaGFuZ2VkLgotCSAqIEBwYXJhbSBwYXRoIFRoZSBwYXRoIHRvIHRoZSBwYXJ0IG9mIHRoZSB0cmVlIHRoYXQgd2FzIGNoYW5nZWQuCi0JICovCi0JcHVibGljIFRyZWVDaGFuZ2VFdmVudChNb2RlbCBzb3VyY2UsIFN0cmluZyB0cmVlTmFtZSwgT2JqZWN0W10gcGF0aCkgewotCQlzdXBlcihzb3VyY2UpOwotCQlpZiAoKHRyZWVOYW1lID09IG51bGwpIHx8IChwYXRoID09IG51bGwpKSB7Ci0JCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJfQotCQl0aGlzLnRyZWVOYW1lID0gdHJlZU5hbWU7Ci0JCXRoaXMucGF0aCA9IHBhdGg7Ci0JfQotCQotCS8qKgotCSAqIENvbnN0cnVjdCBhIG5ldyB0cmVlIGNoYW5nZSBldmVudC4KLQkgKgotCSAqIEBwYXJhbSBzb3VyY2UgVGhlIG9iamVjdCBvbiB3aGljaCB0aGUgZXZlbnQgaW5pdGlhbGx5IG9jY3VycmVkLgotCSAqIEBwYXJhbSB0cmVlTmFtZSBUaGUgcHJvZ3JhbW1hdGljIG5hbWUgb2YgdGhlIHRyZWUgdGhhdCB3YXMgY2hhbmdlZC4KLQkgKi8KLQlwdWJsaWMgVHJlZUNoYW5nZUV2ZW50KE1vZGVsIHNvdXJjZSwgU3RyaW5nIHRyZWVOYW1lKSB7Ci0JCXRoaXMoc291cmNlLCB0cmVlTmFtZSwgRU1QVFlfUEFUSCk7Ci0JfQotCQotCi0JLy8gKioqKioqKioqKiBzdGFuZGFyZCBzdGF0ZSAqKioqKioqKioqCi0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHByb2dyYW1tYXRpYyBuYW1lIG9mIHRoZSB0cmVlIHRoYXQgd2FzIGNoYW5nZWQuCi0JICovCi0JcHVibGljIFN0cmluZyBnZXRUcmVlTmFtZSgpIHsKLQkJcmV0dXJuIHRoaXMudHJlZU5hbWU7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyBnZXRBc3BlY3ROYW1lKCkgewotCQlyZXR1cm4gdGhpcy50cmVlTmFtZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHBhdGggdG8gdGhlIHBhcnQgb2YgdGhlIHRyZWUgdGhhdCB3YXMgY2hhbmdlZC4KLQkgKiBNYXkgYmUgZW1wdHksIGlmIG5vdCBrbm93bi4KLQkgKi8KLQlwdWJsaWMgT2JqZWN0W10gZ2V0UGF0aCgpIHsKLQkJcmV0dXJuIHRoaXMucGF0aDsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogY2xvbmluZyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgVHJlZUNoYW5nZUV2ZW50IGNsb25lV2l0aFNvdXJjZShNb2RlbCBuZXdTb3VyY2UpIHsKLQkJcmV0dXJuIG5ldyBUcmVlQ2hhbmdlRXZlbnQobmV3U291cmNlLCB0aGlzLnRyZWVOYW1lLCB0aGlzLnBhdGgpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiBhIGNvcHkgb2YgdGhlIGV2ZW50IHdpdGggdGhlIHNwZWNpZmllZCBzb3VyY2UKLQkgKiByZXBsYWNpbmcgdGhlIGN1cnJlbnQgc291cmNlIGFuZCB0aGUgdHJlZSBuYW1lLgotCSAqLwotCXB1YmxpYyBUcmVlQ2hhbmdlRXZlbnQgY2xvbmVXaXRoU291cmNlKE1vZGVsIG5ld1NvdXJjZSwgU3RyaW5nIG5ld1RyZWVOYW1lKSB7Ci0JCXJldHVybiBuZXcgVHJlZUNoYW5nZUV2ZW50KG5ld1NvdXJjZSwgbmV3VHJlZU5hbWUsIHRoaXMucGF0aCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvbGlzdGVuZXIvQ2hhbmdlTGlzdGVuZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9DaGFuZ2VMaXN0ZW5lci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkMjlhN2E3Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9DaGFuZ2VMaXN0ZW5lci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lcjsKLQotaW1wb3J0IGphdmEudXRpbC5FdmVudExpc3RlbmVyOwotCi0vKioKLSAqIE1hcmtlciBpbnRlcmZhY2UuCi0gKiAKLSAqIFByb3Zpc2lvbmFsIEFQSTogVGhpcyBpbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsCi0gKiB1bmRlciBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nCi0gKiBzdGFiaWxpdHkuIEl0IGlzIGF2YWlsYWJsZSBhdCB0aGlzIGVhcmx5IHN0YWdlIHRvIHNvbGljaXQgZmVlZGJhY2sgZnJvbQotICogcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyB0aGlzIEFQSQotICogd2lsbCBhbG1vc3QgY2VydGFpbmx5IGJlIGJyb2tlbiAocmVwZWF0ZWRseSkgYXMgdGhlIEFQSSBldm9sdmVzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIENoYW5nZUxpc3RlbmVyIGV4dGVuZHMgRXZlbnRMaXN0ZW5lciB7Ci0JLy8gbm90aGluZyBmb3Igbm93Ci19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvbGlzdGVuZXIvQ29sbGVjdGlvbkNoYW5nZUFkYXB0ZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9Db2xsZWN0aW9uQ2hhbmdlQWRhcHRlci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4OGIxMzU5Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9Db2xsZWN0aW9uQ2hhbmdlQWRhcHRlci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lcjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LkNvbGxlY3Rpb25DaGFuZ2VFdmVudDsKLQotLyoqCi0gKiBDb252ZW5pZW5jZSBpbXBsZW1lbnRhdGlvbiBvZiBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIuCi0gKiAKLSAqIFByb3Zpc2lvbmFsIEFQSTogVGhpcyBjbGFzcyBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKi8KLXB1YmxpYyBjbGFzcyBDb2xsZWN0aW9uQ2hhbmdlQWRhcHRlciBpbXBsZW1lbnRzIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciB7Ci0KLQkvKioKLQkgKiBEZWZhdWx0IGNvbnN0cnVjdG9yLgotCSAqLwotCXB1YmxpYyBDb2xsZWN0aW9uQ2hhbmdlQWRhcHRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQkvLyBkbyBub3RoaW5nCi0JfQotCi0JcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQkvLyBkbyBub3RoaW5nCi0JfQotCi0JcHVibGljIHZvaWQgY29sbGVjdGlvbkNsZWFyZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIGRvIG5vdGhpbmcKLQl9Ci0KLQlwdWJsaWMgdm9pZCBjb2xsZWN0aW9uQ2hhbmdlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gZG8gbm90aGluZwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2xpc3RlbmVyL0NvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2xpc3RlbmVyL0NvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyMTAzODhiLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9Db2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDYwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXI7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Db2xsZWN0aW9uQ2hhbmdlRXZlbnQ7Ci0KLS8qKgotICogQSAiY29sbGVjdGlvbiBjaGFuZ2UiIGV2ZW50IGdldHMgZmlyZWQgd2hlbmV2ZXIgYSBtb2RlbCBjaGFuZ2VzIGEgImJvdW5kIgotICogY29sbGVjdGlvbi4gWW91IGNhbiByZWdpc3RlciBhIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciB3aXRoIGEgc291cmNlCi0gKiBtb2RlbCBzbyBhcyB0byBiZSBub3RpZmllZCBvZiBhbnkgYm91bmQgY29sbGVjdGlvbiB1cGRhdGVzLgotICogCi0gKiBQcm92aXNpb25hbCBBUEk6IFRoaXMgaW50ZXJmYWNlIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbAotICogdW5kZXIgZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZwotICogc3RhYmlsaXR5LiBJdCBpcyBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20KLSAqIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgdGhpcyBBUEkKLSAqIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KLSAqLwotcHVibGljIGludGVyZmFjZSBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lciB7Ci0KLQkvKioKLQkgKiBUaGlzIG1ldGhvZCBnZXRzIGNhbGxlZCB3aGVuIGl0ZW1zIGFyZSBhZGRlZCB0byBhIGJvdW5kIGNvbGxlY3Rpb24uCi0JICogCi0JICogQHBhcmFtIGV2ZW50IEEgQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGRlc2NyaWJpbmcgdGhlIGV2ZW50IHNvdXJjZSwKLQkgKiB0aGUgY29sbGVjdGlvbiB0aGF0IGNoYW5nZWQsIGFuZCB0aGUgaXRlbXMgdGhhdCB3ZXJlIGFkZGVkLgotCSAqLwotCXZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpOwotCi0JLyoqCi0JICogVGhpcyBtZXRob2QgZ2V0cyBjYWxsZWQgd2hlbiBpdGVtcyBhcmUgcmVtb3ZlZCBmcm9tIGEgYm91bmQgY29sbGVjdGlvbi4KLQkgKiAKLQkgKiBAcGFyYW0gZXZlbnQgQSBDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZGVzY3JpYmluZyB0aGUgZXZlbnQgc291cmNlLAotCSAqIHRoZSBjb2xsZWN0aW9uIHRoYXQgY2hhbmdlZCwgYW5kIHRoZSBpdGVtcyB0aGF0IHdlcmUgcmVtb3ZlZC4KLQkgKi8KLQl2b2lkIGl0ZW1zUmVtb3ZlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpOwotCi0JLyoqCi0JICogVGhpcyBtZXRob2QgZ2V0cyBjYWxsZWQgd2hlbiBhIGJvdW5kIGNvbGxlY3Rpb24gaXMgY2xlYXJlZC4KLQkgKiAKLQkgKiBAcGFyYW0gZXZlbnQgQSBDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZGVzY3JpYmluZyB0aGUgZXZlbnQgc291cmNlIAotCSAqIGFuZCB0aGUgY29sbGVjdGlvbiB0aGF0IGNoYW5nZWQuCi0JICovCi0Jdm9pZCBjb2xsZWN0aW9uQ2xlYXJlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpOwotCi0JLyoqCi0JICogVGhpcyBtZXRob2QgZ2V0cyBjYWxsZWQgd2hlbiBhIGJvdW5kIGNvbGxlY3Rpb24gaXMgY2hhbmdlZCBpbiBhIG1hbm5lcgotCSAqIHRoYXQgaXMgbm90IGVhc2lseSBjaGFyYWN0ZXJpemVkIGJ5IHRoZSBvdGhlciBtZXRob2RzIGluIHRoaXMgaW50ZXJmYWNlLgotCSAqIAotCSAqIEBwYXJhbSBldmVudCBBIENvbGxlY3Rpb25DaGFuZ2VFdmVudCBkZXNjcmliaW5nIHRoZSBldmVudCBzb3VyY2UgCi0JICogYW5kIHRoZSBjb2xsZWN0aW9uIHRoYXQgY2hhbmdlZC4KLQkgKi8KLQl2b2lkIGNvbGxlY3Rpb25DaGFuZ2VkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCk7Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9MaXN0Q2hhbmdlQWRhcHRlci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2xpc3RlbmVyL0xpc3RDaGFuZ2VBZGFwdGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDA1MmFiYzUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2xpc3RlbmVyL0xpc3RDaGFuZ2VBZGFwdGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuTGlzdENoYW5nZUV2ZW50OwotCi0vKioKLSAqIENvbnZlbmllbmNlIGltcGxlbWVudGF0aW9uIG9mIExpc3RDaGFuZ2VMaXN0ZW5lci4KLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGNsYXNzIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbAotICogdW5kZXIgZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZwotICogc3RhYmlsaXR5LiBJdCBpcyBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20KLSAqIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgdGhpcyBBUEkKLSAqIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KLSAqLwotcHVibGljIGNsYXNzIExpc3RDaGFuZ2VBZGFwdGVyIGltcGxlbWVudHMgTGlzdENoYW5nZUxpc3RlbmVyIHsKLQotCS8qKgotCSAqIERlZmF1bHQgY29uc3RydWN0b3IuCi0JICovCi0JcHVibGljIExpc3RDaGFuZ2VBZGFwdGVyKCkgewotCQlzdXBlcigpOwotCX0KLQotCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIGRvIG5vdGhpbmcKLQl9Ci0KLQlwdWJsaWMgdm9pZCBpdGVtc1JlbW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIGRvIG5vdGhpbmcKLQl9Ci0KLQlwdWJsaWMgdm9pZCBpdGVtc1JlcGxhY2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkvLyBkbyBub3RoaW5nCi0JfQotCi0JcHVibGljIHZvaWQgaXRlbXNNb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gZG8gbm90aGluZwotCX0KLQotCXB1YmxpYyB2b2lkIGxpc3RDbGVhcmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkvLyBkbyBub3RoaW5nCi0JfQotCi0JcHVibGljIHZvaWQgbGlzdENoYW5nZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIGRvIG5vdGhpbmcKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9MaXN0Q2hhbmdlTGlzdGVuZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9MaXN0Q2hhbmdlTGlzdGVuZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzRlYWIzYS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvbGlzdGVuZXIvTGlzdENoYW5nZUxpc3RlbmVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw4MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuTGlzdENoYW5nZUV2ZW50OwotCi0vKioKLSAqIEEgImxpc3QgY2hhbmdlIiBldmVudCBnZXRzIGZpcmVkIHdoZW5ldmVyIGEgbW9kZWwgY2hhbmdlcyBhICJib3VuZCIKLSAqIGxpc3QuIFlvdSBjYW4gcmVnaXN0ZXIgYSBMaXN0Q2hhbmdlTGlzdGVuZXIgd2l0aCBhIHNvdXJjZQotICogbW9kZWwgc28gYXMgdG8gYmUgbm90aWZpZWQgb2YgYW55IGJvdW5kIGxpc3QgdXBkYXRlcy4KLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKi8KLXB1YmxpYyBpbnRlcmZhY2UgTGlzdENoYW5nZUxpc3RlbmVyIGV4dGVuZHMgQ2hhbmdlTGlzdGVuZXIgewotCi0JLyoqCi0JICogVGhpcyBtZXRob2QgZ2V0cyBjYWxsZWQgd2hlbiBpdGVtcyBhcmUgYWRkZWQgdG8gYSBib3VuZCBsaXN0LgotCSAqIAotCSAqIEBwYXJhbSBldmVudCBBIExpc3RDaGFuZ2VFdmVudCBkZXNjcmliaW5nIHRoZSBldmVudCBzb3VyY2UsCi0JICogdGhlIGxpc3QgdGhhdCBjaGFuZ2VkLCB0aGUgaXRlbXMgdGhhdCB3ZXJlIGFkZGVkLCBhbmQgdGhlIGluZGV4Ci0JICogYXQgd2hpY2ggdGhlIGl0ZW1zIHdlcmUgYWRkZWQuCi0JICovCi0Jdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCk7Ci0KLQkvKioKLQkgKiBUaGlzIG1ldGhvZCBnZXRzIGNhbGxlZCB3aGVuIGl0ZW1zIGFyZSByZW1vdmVkIGZyb20gYSBib3VuZCBsaXN0LgotCSAqIAotCSAqIEBwYXJhbSBldmVudCBBIExpc3RDaGFuZ2VFdmVudCBkZXNjcmliaW5nIHRoZSBldmVudCBzb3VyY2UsCi0JICogdGhlIGxpc3QgdGhhdCBjaGFuZ2VkLCB0aGUgaXRlbXMgdGhhdCB3ZXJlIHJlbW92ZWQsIGFuZCB0aGUgaW5kZXgKLQkgKiBhdCB3aGljaCB0aGUgaXRlbXMgd2VyZSByZW1vdmVkLgotCSAqLwotCXZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCk7Ci0KLQkvKioKLQkgKiBUaGlzIG1ldGhvZCBnZXRzIGNhbGxlZCB3aGVuIGl0ZW1zIGluIGEgYm91bmQgbGlzdCBhcmUgcmVwbGFjZWQuCi0JICogCi0JICogQHBhcmFtIGV2ZW50IEEgTGlzdENoYW5nZUV2ZW50IGRlc2NyaWJpbmcgdGhlIGV2ZW50IHNvdXJjZSwKLQkgKiB0aGUgbGlzdCB0aGF0IGNoYW5nZWQsIHRoZSBpdGVtcyB0aGF0IHdlcmUgYWRkZWQsIHRoZSBpdGVtcyB0aGF0IHdlcmUKLQkgKiByZXBsYWNlZCwgYW5kIHRoZSBpbmRleCBhdCB3aGljaCB0aGUgaXRlbXMgd2VyZSByZXBsYWNlZC4KLQkgKi8KLQl2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KTsKLQotCS8qKgotCSAqIFRoaXMgbWV0aG9kIGdldHMgY2FsbGVkIHdoZW4gaXRlbXMgaW4gYSBib3VuZCBsaXN0IGFyZSBtb3ZlZC4KLQkgKiAKLQkgKiBAcGFyYW0gZXZlbnQgQSBMaXN0Q2hhbmdlRXZlbnQgZGVzY3JpYmluZyB0aGUgZXZlbnQgc291cmNlLAotCSAqIHRoZSBsaXN0IHRoYXQgY2hhbmdlZCwgYW5kIHRoZSBpbmRpY2VzIG9mIHdoZXJlIGl0ZW1zIHdlcmUgbW92ZWQKLQkgKiBmcm9tIGFuZCB0by4KLQkgKi8KLQl2b2lkIGl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KTsKLQotCS8qKgotCSAqIFRoaXMgbWV0aG9kIGdldHMgY2FsbGVkIHdoZW4gYSBib3VuZCBsaXN0IGlzIGNsZWFyZWQuCi0JICogCi0JICogQHBhcmFtIGV2ZW50IEEgTGlzdENoYW5nZUV2ZW50IG9iamVjdCBkZXNjcmliaW5nIHRoZSBldmVudCBzb3VyY2UgCi0JICogYW5kIHRoZSBsaXN0IHRoYXQgY2hhbmdlZC4KLQkgKi8KLQl2b2lkIGxpc3RDbGVhcmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCk7Ci0KLQkvKioKLQkgKiBUaGlzIG1ldGhvZCBnZXRzIGNhbGxlZCB3aGVuIGEgYm91bmQgbGlzdCBpcyBjaGFuZ2VkIGluIGEgbWFubmVyCi0JICogdGhhdCBpcyBub3QgZWFzaWx5IGNoYXJhY3Rlcml6ZWQgYnkgdGhlIG90aGVyIG1ldGhvZHMgaW4gdGhpcyBpbnRlcmZhY2UuCi0JICogCi0JICogQHBhcmFtIGV2ZW50IEEgTGlzdENoYW5nZUV2ZW50IG9iamVjdCBkZXNjcmliaW5nIHRoZSBldmVudCBzb3VyY2UgCi0JICogYW5kIHRoZSBsaXN0IHRoYXQgY2hhbmdlZC4KLQkgKi8KLQl2b2lkIGxpc3RDaGFuZ2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCk7Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9NdWx0aU1ldGhvZFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2xpc3RlbmVyL011bHRpTWV0aG9kUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDliNjlkZTUuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2xpc3RlbmVyL011bHRpTWV0aG9kUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNDUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lcjsKLQotaW1wb3J0IGphdmEubGFuZy5yZWZsZWN0Lk1ldGhvZDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5DbGFzc1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LkNvbGxlY3Rpb25DaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5MaXN0Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuVHJlZUNoYW5nZUV2ZW50OwotCi0vKioKLSAqIFRoaXMgY2xhc3MgaXMgdXNlZCBieSBSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIgd2hlbiB0aGUgcmVxdWVzdGVkIGxpc3RlbmVyCi0gKiBuZWVkcyB0byBpbXBsZW1lbnQgbXVsdGlwbGUgbWV0aG9kcyAoaS5lLiBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIsCi0gKiBMaXN0Q2hhbmdlTGlzdGVuZXIsIG9yIFRyZWVDaGFuZ2VMaXN0ZW5lcikuCi0gKi8KLWNsYXNzIE11bHRpTWV0aG9kUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyCi0JZXh0ZW5kcyBSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIgCi0JaW1wbGVtZW50cyBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIsIExpc3RDaGFuZ2VMaXN0ZW5lciwgVHJlZUNoYW5nZUxpc3RlbmVyCi17Ci0JLyoqIHRoZSBtZXRob2RzIHdlIHdpbGwgaW52b2tlIG9uIHRoZSB0YXJnZXQgb2JqZWN0ICovCi0JcHJpdmF0ZSBmaW5hbCBNZXRob2QgYWRkTWV0aG9kOwotCXByaXZhdGUgZmluYWwgTWV0aG9kIHJlbW92ZU1ldGhvZDsKLQlwcml2YXRlIGZpbmFsIE1ldGhvZCByZXBsYWNlTWV0aG9kOwkvLyB0aGlzIGNhbiBiZSBudWxsCi0JcHJpdmF0ZSBmaW5hbCBNZXRob2QgbW92ZU1ldGhvZDsJLy8gdGhpcyBjYW4gYmUgbnVsbAotCXByaXZhdGUgZmluYWwgTWV0aG9kIGNsZWFyTWV0aG9kOwotCXByaXZhdGUgZmluYWwgTWV0aG9kIGNoYW5nZU1ldGhvZDsKLQotCi0JLyoqCi0JICogVGhlICJyZXBsYWNlIiBhbmQgIm1vdmUiIG1ldGhvZHMgYXJlIG9wdGlvbmFsLgotCSAqLwotCU11bHRpTWV0aG9kUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyKE9iamVjdCB0YXJnZXQsIE1ldGhvZCBhZGRNZXRob2QsIE1ldGhvZCByZW1vdmVNZXRob2QsIE1ldGhvZCByZXBsYWNlTWV0aG9kLCBNZXRob2QgbW92ZU1ldGhvZCwgTWV0aG9kIGNsZWFyTWV0aG9kLCBNZXRob2QgY2hhbmdlTWV0aG9kKSB7Ci0JCXN1cGVyKHRhcmdldCk7Ci0JCXRoaXMuYWRkTWV0aG9kID0gYWRkTWV0aG9kOwotCQl0aGlzLnJlbW92ZU1ldGhvZCA9IHJlbW92ZU1ldGhvZDsKLQkJdGhpcy5yZXBsYWNlTWV0aG9kID0gcmVwbGFjZU1ldGhvZDsKLQkJdGhpcy5tb3ZlTWV0aG9kID0gbW92ZU1ldGhvZDsKLQkJdGhpcy5jbGVhck1ldGhvZCA9IGNsZWFyTWV0aG9kOwotCQl0aGlzLmNoYW5nZU1ldGhvZCA9IGNoYW5nZU1ldGhvZDsKLQl9Ci0KLQkvKioKLQkgKiBObyAicmVwbGFjZSIgb3IgIm1vdmUiIG1ldGhvZHMuCi0JICovCi0JTXVsdGlNZXRob2RSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIoT2JqZWN0IHRhcmdldCwgTWV0aG9kIGFkZE1ldGhvZCwgTWV0aG9kIHJlbW92ZU1ldGhvZCwgTWV0aG9kIGNsZWFyTWV0aG9kLCBNZXRob2QgY2hhbmdlTWV0aG9kKSB7Ci0JCXRoaXModGFyZ2V0LCBhZGRNZXRob2QsIHJlbW92ZU1ldGhvZCwgbnVsbCwgbnVsbCwgY2xlYXJNZXRob2QsIGNoYW5nZU1ldGhvZCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwcml2YXRlIHZvaWQgaW52b2tlKE1ldGhvZCBtZXRob2QsIENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQlpZiAobWV0aG9kLmdldFBhcmFtZXRlclR5cGVzKCkubGVuZ3RoID09IDApIHsKLQkJCUNsYXNzVG9vbHMuZXhlY3V0ZU1ldGhvZChtZXRob2QsIHRoaXMudGFyZ2V0LCBFTVBUWV9DT0xMRUNUSU9OX0NIQU5HRV9FVkVOVF9BUlJBWSk7Ci0JCX0gZWxzZSB7Ci0JCQlDbGFzc1Rvb2xzLmV4ZWN1dGVNZXRob2QobWV0aG9kLCB0aGlzLnRhcmdldCwgbmV3IENvbGxlY3Rpb25DaGFuZ2VFdmVudFtdIHtldmVudH0pOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5pbnZva2UodGhpcy5hZGRNZXRob2QsIGV2ZW50KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBpdGVtc1JlbW92ZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuaW52b2tlKHRoaXMucmVtb3ZlTWV0aG9kLCBldmVudCk7Ci0JfQotCi0JcHVibGljIHZvaWQgY29sbGVjdGlvbkNsZWFyZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCXRoaXMuaW52b2tlKHRoaXMuY2xlYXJNZXRob2QsIGV2ZW50KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBjb2xsZWN0aW9uQ2hhbmdlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5pbnZva2UodGhpcy5jaGFuZ2VNZXRob2QsIGV2ZW50KTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogTGlzdENoYW5nZUxpc3RlbmVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXByaXZhdGUgdm9pZCBpbnZva2UoTWV0aG9kIG1ldGhvZCwgTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCWlmIChtZXRob2QuZ2V0UGFyYW1ldGVyVHlwZXMoKS5sZW5ndGggPT0gMCkgewotCQkJQ2xhc3NUb29scy5leGVjdXRlTWV0aG9kKG1ldGhvZCwgdGhpcy50YXJnZXQsIEVNUFRZX0xJU1RfQ0hBTkdFX0VWRU5UX0FSUkFZKTsKLQkJfSBlbHNlIHsKLQkJCUNsYXNzVG9vbHMuZXhlY3V0ZU1ldGhvZChtZXRob2QsIHRoaXMudGFyZ2V0LCBuZXcgTGlzdENoYW5nZUV2ZW50W10ge2V2ZW50fSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmludm9rZSh0aGlzLmFkZE1ldGhvZCwgZXZlbnQpOwotCX0KLQotCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5pbnZva2UodGhpcy5yZW1vdmVNZXRob2QsIGV2ZW50KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBpdGVtc1JlcGxhY2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmludm9rZSh0aGlzLnJlcGxhY2VNZXRob2QsIGV2ZW50KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBpdGVtc01vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmludm9rZSh0aGlzLm1vdmVNZXRob2QsIGV2ZW50KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5pbnZva2UodGhpcy5jbGVhck1ldGhvZCwgZXZlbnQpOwotCX0KLQotCXB1YmxpYyB2b2lkIGxpc3RDaGFuZ2VkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmludm9rZSh0aGlzLmNoYW5nZU1ldGhvZCwgZXZlbnQpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBUcmVlQ2hhbmdlTGlzdGVuZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHJpdmF0ZSB2b2lkIGludm9rZShNZXRob2QgbWV0aG9kLCBUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJaWYgKG1ldGhvZC5nZXRQYXJhbWV0ZXJUeXBlcygpLmxlbmd0aCA9PSAwKSB7Ci0JCQlDbGFzc1Rvb2xzLmV4ZWN1dGVNZXRob2QobWV0aG9kLCB0aGlzLnRhcmdldCwgRU1QVFlfVFJFRV9DSEFOR0VfRVZFTlRfQVJSQVkpOwotCQl9IGVsc2UgewotCQkJQ2xhc3NUb29scy5leGVjdXRlTWV0aG9kKG1ldGhvZCwgdGhpcy50YXJnZXQsIG5ldyBUcmVlQ2hhbmdlRXZlbnRbXSB7ZXZlbnR9KTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIG5vZGVBZGRlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5pbnZva2UodGhpcy5hZGRNZXRob2QsIGV2ZW50KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBub2RlUmVtb3ZlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5pbnZva2UodGhpcy5yZW1vdmVNZXRob2QsIGV2ZW50KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0cmVlQ2xlYXJlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJdGhpcy5pbnZva2UodGhpcy5jbGVhck1ldGhvZCwgZXZlbnQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRyZWVDaGFuZ2VkKFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQl0aGlzLmludm9rZSh0aGlzLmNoYW5nZU1ldGhvZCwgZXZlbnQpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2xpc3RlbmVyL1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGY3NmJlZDcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2xpc3RlbmVyL1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDM1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXI7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Qcm9wZXJ0eUNoYW5nZUV2ZW50OwotCi0vKioKLSAqIEEgInByb3BlcnR5IGNoYW5nZSIgZXZlbnQgZ2V0cyBmaXJlZCB3aGVuZXZlciBhIG1vZGVsIGNoYW5nZXMgYSAiYm91bmQiCi0gKiBwcm9wZXJ0eS4gWW91IGNhbiByZWdpc3RlciBhIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgd2l0aCBhIHNvdXJjZQotICogbW9kZWwgc28gYXMgdG8gYmUgbm90aWZpZWQgb2YgYW55IGJvdW5kIHByb3BlcnR5IHVwZGF0ZXMuCi0gKiAKLSAqIFByb3Zpc2lvbmFsIEFQSTogVGhpcyBpbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsCi0gKiB1bmRlciBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nCi0gKiBzdGFiaWxpdHkuIEl0IGlzIGF2YWlsYWJsZSBhdCB0aGlzIGVhcmx5IHN0YWdlIHRvIHNvbGljaXQgZmVlZGJhY2sgZnJvbQotICogcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyB0aGlzIEFQSQotICogd2lsbCBhbG1vc3QgY2VydGFpbmx5IGJlIGJyb2tlbiAocmVwZWF0ZWRseSkgYXMgdGhlIEFQSSBldm9sdmVzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lciB7Ci0KLQkvKioKLQkgKiBUaGlzIG1ldGhvZCBnZXRzIGNhbGxlZCB3aGVuIGEgbW9kZWwgaGFzIGNoYW5nZWQgYSBib3VuZCBwcm9wZXJ0eS4KLQkgKiAKLQkgKiBAcGFyYW0gZXZlbnQgQSBTdGF0ZUNoYW5nZUV2ZW50IGRlc2NyaWJpbmcgdGhlIGV2ZW50IHNvdXJjZQotCSAqIGFuZCB0aGUgcHJvcGVydHkncyBvbGQgYW5kIG5ldyB2YWx1ZXMuCi0JICovCi0Jdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCk7Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9SZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIuamF2YSBiL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9SZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMGNhYjdkNy4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvbGlzdGVuZXIvUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzMTIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lcjsKLQotaW1wb3J0IGphdmEubGFuZy5yZWZsZWN0Lk1ldGhvZDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5DbGFzc1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LkNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LkNvbGxlY3Rpb25DaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5MaXN0Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5TdGF0ZUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlRyZWVDaGFuZ2VFdmVudDsKLQotLyoqCi0gKiBUaGlzIGZhY3RvcnkgYnVpbGRzIGxpc3RlbmVycyB0aGF0IHJlZmxlY3RpdmVseSBmb3J3YXJkIENoYW5nZUV2ZW50cy4KLSAqIElmIHlvdSBhcmUgd29ycmllZCBhYm91dCBoYXZpbmcgdG9vIG1hbnkgbGl0dGxlIGNsYXNzZXMgdGhhdCBoYXZlIHRvIGJlCi0gKiBsb2FkZWQgYW5kIG1haW50YWluZWQgYnkgdGhlIGNsYXNzIGxvYWRlciwgeW91IGNhbiB1c2Ugb25lIG9mIHRoZXNlLgotICogT2YgY291cnNlLCB0aGlzIGNvbWVzIHdpdGggdGhlIGFkZGl0aW9uYWwgb3ZlcmhlYWQgb2YgcmVmbGVjdGlvbi4uLi4KLSAqIEFsc28gbm90ZSB0aGF0IHRoZSB2YWxpZGl0eSBvZiB0aGUgbWV0aG9kIG5hbWUgaXMgbm90IGNoZWNrZWQgYXQgY29tcGlsZQotICogdGltZSwgYnV0IGF0IHJ1bnRpbWU7IGFsdGhvdWdoIHdlICpkbyogY2hlY2sgdGhlIG1ldGhvZCBhcyBzb29uIGFzIHRoZQotICogbGlzdGVuZXIgaXMgaW5zdGFudGlhdGVkLgotICogCi0gKiBQcm92aXNpb25hbCBBUEk6IFRoaXMgY2xhc3MgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsCi0gKiB1bmRlciBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nCi0gKiBzdGFiaWxpdHkuIEl0IGlzIGF2YWlsYWJsZSBhdCB0aGlzIGVhcmx5IHN0YWdlIHRvIHNvbGljaXQgZmVlZGJhY2sgZnJvbQotICogcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyB0aGlzIEFQSQotICogd2lsbCBhbG1vc3QgY2VydGFpbmx5IGJlIGJyb2tlbiAocmVwZWF0ZWRseSkgYXMgdGhlIEFQSSBldm9sdmVzLgotICovCi1wdWJsaWMgYWJzdHJhY3QgY2xhc3MgUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyIHsKLQotCS8qKiB0aGUgdGFyZ2V0IG9iamVjdCBvbiB3aGljaCB3ZSB3aWxsIGludm9rZSB0aGUgbWV0aG9kICovCi0JcHJvdGVjdGVkIGZpbmFsIE9iamVjdCB0YXJnZXQ7Ci0KLQotCXByb3RlY3RlZCBzdGF0aWMgZmluYWwgQ2xhc3M8U3RhdGVDaGFuZ2VFdmVudD4gU1RBVEVfQ0hBTkdFX0VWRU5UX0NMQVNTID0gU3RhdGVDaGFuZ2VFdmVudC5jbGFzczsKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIENsYXNzPFN0YXRlQ2hhbmdlRXZlbnQ+W10gU1RBVEVfQ0hBTkdFX0VWRU5UX0NMQVNTX0FSUkFZID0gbmV3IENsYXNzW10ge1NUQVRFX0NIQU5HRV9FVkVOVF9DTEFTU307Ci0JcHJvdGVjdGVkIHN0YXRpYyBmaW5hbCBTdGF0ZUNoYW5nZUV2ZW50W10gRU1QVFlfU1RBVEVfQ0hBTkdFX0VWRU5UX0FSUkFZID0gbmV3IFN0YXRlQ2hhbmdlRXZlbnRbMF07Ci0KLQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIENsYXNzPFByb3BlcnR5Q2hhbmdlRXZlbnQ+IFBST1BFUlRZX0NIQU5HRV9FVkVOVF9DTEFTUyA9IFByb3BlcnR5Q2hhbmdlRXZlbnQuY2xhc3M7Ci0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJvdGVjdGVkIHN0YXRpYyBmaW5hbCBDbGFzczxQcm9wZXJ0eUNoYW5nZUV2ZW50PltdIFBST1BFUlRZX0NIQU5HRV9FVkVOVF9DTEFTU19BUlJBWSA9IG5ldyBDbGFzc1tdIHtQUk9QRVJUWV9DSEFOR0VfRVZFTlRfQ0xBU1N9OwotCXByb3RlY3RlZCBzdGF0aWMgZmluYWwgUHJvcGVydHlDaGFuZ2VFdmVudFtdIEVNUFRZX1BST1BFUlRZX0NIQU5HRV9FVkVOVF9BUlJBWSA9IG5ldyBQcm9wZXJ0eUNoYW5nZUV2ZW50WzBdOwotCi0JcHJvdGVjdGVkIHN0YXRpYyBmaW5hbCBDbGFzczxDb2xsZWN0aW9uQ2hhbmdlRXZlbnQ+IENPTExFQ1RJT05fQ0hBTkdFX0VWRU5UX0NMQVNTID0gQ29sbGVjdGlvbkNoYW5nZUV2ZW50LmNsYXNzOwotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByb3RlY3RlZCBzdGF0aWMgZmluYWwgQ2xhc3M8Q29sbGVjdGlvbkNoYW5nZUV2ZW50PltdIENPTExFQ1RJT05fQ0hBTkdFX0VWRU5UX0NMQVNTX0FSUkFZID0gbmV3IENsYXNzW10ge0NPTExFQ1RJT05fQ0hBTkdFX0VWRU5UX0NMQVNTfTsKLQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIENvbGxlY3Rpb25DaGFuZ2VFdmVudFtdIEVNUFRZX0NPTExFQ1RJT05fQ0hBTkdFX0VWRU5UX0FSUkFZID0gbmV3IENvbGxlY3Rpb25DaGFuZ2VFdmVudFswXTsKLQotCXByb3RlY3RlZCBzdGF0aWMgZmluYWwgQ2xhc3M8TGlzdENoYW5nZUV2ZW50PiBMSVNUX0NIQU5HRV9FVkVOVF9DTEFTUyA9IExpc3RDaGFuZ2VFdmVudC5jbGFzczsKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIENsYXNzPExpc3RDaGFuZ2VFdmVudD5bXSBMSVNUX0NIQU5HRV9FVkVOVF9DTEFTU19BUlJBWSA9IG5ldyBDbGFzc1tdIHtMSVNUX0NIQU5HRV9FVkVOVF9DTEFTU307Ci0JcHJvdGVjdGVkIHN0YXRpYyBmaW5hbCBMaXN0Q2hhbmdlRXZlbnRbXSBFTVBUWV9MSVNUX0NIQU5HRV9FVkVOVF9BUlJBWSA9IG5ldyBMaXN0Q2hhbmdlRXZlbnRbMF07Ci0KLQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIENsYXNzPFRyZWVDaGFuZ2VFdmVudD4gVFJFRV9DSEFOR0VfRVZFTlRfQ0xBU1MgPSBUcmVlQ2hhbmdlRXZlbnQuY2xhc3M7Ci0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJvdGVjdGVkIHN0YXRpYyBmaW5hbCBDbGFzczxUcmVlQ2hhbmdlRXZlbnQ+W10gVFJFRV9DSEFOR0VfRVZFTlRfQ0xBU1NfQVJSQVkgPSBuZXcgQ2xhc3NbXSB7VFJFRV9DSEFOR0VfRVZFTlRfQ0xBU1N9OwotCXByb3RlY3RlZCBzdGF0aWMgZmluYWwgVHJlZUNoYW5nZUV2ZW50W10gRU1QVFlfVFJFRV9DSEFOR0VfRVZFTlRfQVJSQVkgPSBuZXcgVHJlZUNoYW5nZUV2ZW50WzBdOwotCi0KLQotCS8vICoqKioqKioqKiogaGVscGVyIG1ldGhvZHMgKioqKioqKioqKgotCi0JLyoqCi0JICogRmluZCBhbmQgcmV0dXJuIGEgbWV0aG9kIGltcGxlbWVudGVkIGJ5IHRoZSB0YXJnZXQgdGhhdCBjYW4gYmUgaW52b2tlZAotCSAqIHJlZmxlY3RpdmVseSB3aGVuIGEgY2hhbmdlIGV2ZW50IG9jY3Vycy4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBNZXRob2QgZmluZENoYW5nZUxpc3RlbmVyTWV0aG9kKE9iamVjdCB0YXJnZXQsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/IGV4dGVuZHMgQ2hhbmdlRXZlbnQ+W10gZXZlbnRDbGFzc0FycmF5KSB7Ci0JCU1ldGhvZCBtZXRob2Q7Ci0JCXRyeSB7Ci0JCQltZXRob2QgPSBDbGFzc1Rvb2xzLm1ldGhvZCh0YXJnZXQsIG1ldGhvZE5hbWUsIGV2ZW50Q2xhc3NBcnJheSk7Ci0JCX0gY2F0Y2ggKE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiBleDEpIHsKLQkJCXRyeSB7Ci0JCQkJbWV0aG9kID0gQ2xhc3NUb29scy5tZXRob2QodGFyZ2V0LCBtZXRob2ROYW1lKTsKLQkJCX0gY2F0Y2ggKE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiBleDIpIHsKLQkJCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihleDIpOyAgLy8gImNoZWNrZWQiIGV4Y2VwdGlvbnMgYml0ZQotCQkJfQotCQl9Ci0JCXJldHVybiBtZXRob2Q7Ci0JfQotCi0JLyoqCi0JICogQ2hlY2sgd2hldGhlciB0aGUgc3BlY2lmaWVkIG1ldGhvZCBpcyBzdWl0YWJsZSBmb3IgYmVpbmcgaW52b2tlZCB3aGVuIGEKLQkgKiBjaGFuZ2UgZXZlbnQgaGFzIG9jY3VycmVkLiBUaHJvdyBhbiBleGNlcHRpb24gaWYgaXQgaXMgbm90IHN1aXRhYmxlLgotCSAqLwotCXByaXZhdGUgc3RhdGljIHZvaWQgY2hlY2tDaGFuZ2VMaXN0ZW5lck1ldGhvZChNZXRob2QgbWV0aG9kLCBDbGFzczw/IGV4dGVuZHMgQ2hhbmdlRXZlbnQ+IGV2ZW50Q2xhc3MpIHsKLQkJQ2xhc3M8Pz5bXSBwYXJtVHlwZXMgPSBtZXRob2QuZ2V0UGFyYW1ldGVyVHlwZXMoKTsKLQkJaW50IHBhcm1UeXBlc0xlbmd0aCA9IHBhcm1UeXBlcy5sZW5ndGg7Ci0JCWlmIChwYXJtVHlwZXNMZW5ndGggPT0gMCkgewotCQkJcmV0dXJuOwotCQl9Ci0JCWlmICgocGFybVR5cGVzTGVuZ3RoID09IDEpICYmIHBhcm1UeXBlc1swXS5pc0Fzc2lnbmFibGVGcm9tKGV2ZW50Q2xhc3MpKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbihtZXRob2QudG9TdHJpbmcoKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGZhY3RvcnkgbWV0aG9kczogU3RhdGVDaGFuZ2VMaXN0ZW5lciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBzdGF0ZSBjaGFuZ2UgbGlzdGVuZXIgdGhhdCB3aWxsIGludm9rZSB0aGUgc3BlY2lmaWVkIG1ldGhvZAotCSAqIG9uIHRoZSBzcGVjaWZpZWQgdGFyZ2V0LgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RhdGVDaGFuZ2VMaXN0ZW5lciBidWlsZFN0YXRlQ2hhbmdlTGlzdGVuZXIoT2JqZWN0IHRhcmdldCwgTWV0aG9kIG1ldGhvZCkgewotCQljaGVja0NoYW5nZUxpc3RlbmVyTWV0aG9kKG1ldGhvZCwgU1RBVEVfQ0hBTkdFX0VWRU5UX0NMQVNTKTsKLQkJcmV0dXJuIG5ldyBTaW5nbGVNZXRob2RSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIodGFyZ2V0LCBtZXRob2QpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHN0YXRlIGNoYW5nZSBsaXN0ZW5lciB0aGF0IHdpbGwgaW52b2tlIHRoZSBzcGVjaWZpZWQgbWV0aG9kCi0JICogb24gdGhlIHNwZWNpZmllZCB0YXJnZXQuIElmIGEgc2luZ2xlLWFyZ3VtZW50IG1ldGhvZCB3aXRoIHRoZSBzcGVjaWZpZWQKLQkgKiBuYW1lIGFuZCBhcHByb3ByaWF0ZSBhcmd1bWVudCBpcyBmb3VuZCwgaXQgd2lsbCBiZSBpbnZva2VkOyBvdGhlcndpc2UsCi0JICogYSB6ZXJvLWFyZ3VtZW50IG1ldGhvZCB3aXRoIHRoZSBzcGVjaWZpZWQgbmFtZSB3aWxsIGJlIGludm9rZWQuCi0JICovCi0JcHVibGljIHN0YXRpYyBTdGF0ZUNoYW5nZUxpc3RlbmVyIGJ1aWxkU3RhdGVDaGFuZ2VMaXN0ZW5lcihPYmplY3QgdGFyZ2V0LCBTdHJpbmcgbWV0aG9kTmFtZSkgewotCQlyZXR1cm4gYnVpbGRTdGF0ZUNoYW5nZUxpc3RlbmVyKHRhcmdldCwgZmluZENoYW5nZUxpc3RlbmVyTWV0aG9kKHRhcmdldCwgbWV0aG9kTmFtZSwgU1RBVEVfQ0hBTkdFX0VWRU5UX0NMQVNTX0FSUkFZKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGZhY3RvcnkgbWV0aG9kczogUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBwcm9wZXJ0eSBjaGFuZ2UgbGlzdGVuZXIgdGhhdCB3aWxsIGludm9rZSB0aGUgc3BlY2lmaWVkIG1ldGhvZAotCSAqIG9uIHRoZSBzcGVjaWZpZWQgdGFyZ2V0LgotCSAqLwotCXB1YmxpYyBzdGF0aWMgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoT2JqZWN0IHRhcmdldCwgTWV0aG9kIG1ldGhvZCkgewotCQljaGVja0NoYW5nZUxpc3RlbmVyTWV0aG9kKG1ldGhvZCwgUFJPUEVSVFlfQ0hBTkdFX0VWRU5UX0NMQVNTKTsKLQkJcmV0dXJuIG5ldyBTaW5nbGVNZXRob2RSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIodGFyZ2V0LCBtZXRob2QpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHByb3BlcnR5IGNoYW5nZSBsaXN0ZW5lciB0aGF0IHdpbGwgaW52b2tlIHRoZSBzcGVjaWZpZWQgbWV0aG9kCi0JICogb24gdGhlIHNwZWNpZmllZCB0YXJnZXQuIElmIGEgc2luZ2xlLWFyZ3VtZW50IG1ldGhvZCB3aXRoIHRoZSBzcGVjaWZpZWQKLQkgKiBuYW1lIGFuZCBhcHByb3ByaWF0ZSBhcmd1bWVudCBpcyBmb3VuZCwgaXQgd2lsbCBiZSBpbnZva2VkOyBvdGhlcndpc2UsCi0JICogYSB6ZXJvLWFyZ3VtZW50IG1ldGhvZCB3aXRoIHRoZSBzcGVjaWZpZWQgbmFtZSB3aWxsIGJlIGludm9rZWQuCi0JICovCi0JcHVibGljIHN0YXRpYyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihPYmplY3QgdGFyZ2V0LCBTdHJpbmcgbWV0aG9kTmFtZSkgewotCQlyZXR1cm4gYnVpbGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRhcmdldCwgZmluZENoYW5nZUxpc3RlbmVyTWV0aG9kKHRhcmdldCwgbWV0aG9kTmFtZSwgUFJPUEVSVFlfQ0hBTkdFX0VWRU5UX0NMQVNTX0FSUkFZKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGZhY3RvcnkgbWV0aG9kczogQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGNvbGxlY3Rpb24gY2hhbmdlIGxpc3RlbmVyIHRoYXQgd2lsbCBpbnZva2UgdGhlIHNwZWNpZmllZCBtZXRob2RzCi0JICogb24gdGhlIHNwZWNpZmllZCB0YXJnZXQuCi0JICovCi0JcHVibGljIHN0YXRpYyBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgYnVpbGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoT2JqZWN0IHRhcmdldCwgTWV0aG9kIGFkZE1ldGhvZCwgTWV0aG9kIHJlbW92ZU1ldGhvZCwgTWV0aG9kIGNsZWFyTWV0aG9kLCBNZXRob2QgY2hhbmdlTWV0aG9kKSB7Ci0JCWNoZWNrQ2hhbmdlTGlzdGVuZXJNZXRob2QoYWRkTWV0aG9kLCBDT0xMRUNUSU9OX0NIQU5HRV9FVkVOVF9DTEFTUyk7Ci0JCWNoZWNrQ2hhbmdlTGlzdGVuZXJNZXRob2QocmVtb3ZlTWV0aG9kLCBDT0xMRUNUSU9OX0NIQU5HRV9FVkVOVF9DTEFTUyk7Ci0JCWNoZWNrQ2hhbmdlTGlzdGVuZXJNZXRob2QoY2xlYXJNZXRob2QsIENPTExFQ1RJT05fQ0hBTkdFX0VWRU5UX0NMQVNTKTsKLQkJY2hlY2tDaGFuZ2VMaXN0ZW5lck1ldGhvZChjaGFuZ2VNZXRob2QsIENPTExFQ1RJT05fQ0hBTkdFX0VWRU5UX0NMQVNTKTsKLQkJcmV0dXJuIG5ldyBNdWx0aU1ldGhvZFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lcih0YXJnZXQsIGFkZE1ldGhvZCwgcmVtb3ZlTWV0aG9kLCBjbGVhck1ldGhvZCwgY2hhbmdlTWV0aG9kKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBjb2xsZWN0aW9uIGNoYW5nZSBsaXN0ZW5lciB0aGF0IHdpbGwgaW52b2tlIHRoZSBzcGVjaWZpZWQgbWV0aG9kCi0JICogb24gdGhlIHNwZWNpZmllZCB0YXJnZXQgZm9yIGFueSBjaGFuZ2UgZXZlbnQuCi0JICovCi0JcHVibGljIHN0YXRpYyBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgYnVpbGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoT2JqZWN0IHRhcmdldCwgTWV0aG9kIG1ldGhvZCkgewotCQlyZXR1cm4gYnVpbGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIodGFyZ2V0LCBtZXRob2QsIG1ldGhvZCwgbWV0aG9kLCBtZXRob2QpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGNvbGxlY3Rpb24gY2hhbmdlIGxpc3RlbmVyIHRoYXQgd2lsbCBpbnZva2UgdGhlIHNwZWNpZmllZCBtZXRob2RzCi0JICogb24gdGhlIHNwZWNpZmllZCB0YXJnZXQgZm9yIGNoYW5nZSBldmVudHMuIElmIGEgc2luZ2xlLWFyZ3VtZW50IG1ldGhvZAotCSAqIHdpdGggdGhlIHNwZWNpZmllZCBuYW1lIGFuZCBhcHByb3ByaWF0ZSBhcmd1bWVudCBpcyBmb3VuZCwgaXQgd2lsbCBiZSBpbnZva2VkOwotCSAqIG90aGVyd2lzZSwgYSB6ZXJvLWFyZ3VtZW50IG1ldGhvZCB3aXRoIHRoZSBzcGVjaWZpZWQgbmFtZSB3aWxsIGJlIGludm9rZWQuCi0JICovCi0JcHVibGljIHN0YXRpYyBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgYnVpbGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoT2JqZWN0IHRhcmdldCwgU3RyaW5nIGFkZE1ldGhvZE5hbWUsIFN0cmluZyByZW1vdmVNZXRob2ROYW1lLCBTdHJpbmcgY2xlYXJNZXRob2ROYW1lLCBTdHJpbmcgY2hhbmdlTWV0aG9kTmFtZSkgewotCQlyZXR1cm4gYnVpbGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoCi0JCQkJdGFyZ2V0LAotCQkJCWZpbmRDaGFuZ2VMaXN0ZW5lck1ldGhvZCh0YXJnZXQsIGFkZE1ldGhvZE5hbWUsIENPTExFQ1RJT05fQ0hBTkdFX0VWRU5UX0NMQVNTX0FSUkFZKSwKLQkJCQlmaW5kQ2hhbmdlTGlzdGVuZXJNZXRob2QodGFyZ2V0LCByZW1vdmVNZXRob2ROYW1lLCBDT0xMRUNUSU9OX0NIQU5HRV9FVkVOVF9DTEFTU19BUlJBWSksCi0JCQkJZmluZENoYW5nZUxpc3RlbmVyTWV0aG9kKHRhcmdldCwgY2xlYXJNZXRob2ROYW1lLCBDT0xMRUNUSU9OX0NIQU5HRV9FVkVOVF9DTEFTU19BUlJBWSksCi0JCQkJZmluZENoYW5nZUxpc3RlbmVyTWV0aG9kKHRhcmdldCwgY2hhbmdlTWV0aG9kTmFtZSwgQ09MTEVDVElPTl9DSEFOR0VfRVZFTlRfQ0xBU1NfQVJSQVkpCi0JCSk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgY29sbGVjdGlvbiBjaGFuZ2UgbGlzdGVuZXIgdGhhdCB3aWxsIGludm9rZSB0aGUgc3BlY2lmaWVkIG1ldGhvZAotCSAqIG9uIHRoZSBzcGVjaWZpZWQgdGFyZ2V0IGZvciBhbnkgY2hhbmdlIGV2ZW50LiBJZiBhIHNpbmdsZS1hcmd1bWVudCBtZXRob2QKLQkgKiB3aXRoIHRoZSBzcGVjaWZpZWQgbmFtZSBhbmQgYXBwcm9wcmlhdGUgYXJndW1lbnQgaXMgZm91bmQsIGl0IHdpbGwgYmUgaW52b2tlZDsKLQkgKiBvdGhlcndpc2UsIGEgemVyby1hcmd1bWVudCBtZXRob2Qgd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUgd2lsbCBiZSBpbnZva2VkLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGJ1aWxkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKE9iamVjdCB0YXJnZXQsIFN0cmluZyBtZXRob2ROYW1lKSB7Ci0JCXJldHVybiBidWlsZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcih0YXJnZXQsIGZpbmRDaGFuZ2VMaXN0ZW5lck1ldGhvZCh0YXJnZXQsIG1ldGhvZE5hbWUsIENPTExFQ1RJT05fQ0hBTkdFX0VWRU5UX0NMQVNTX0FSUkFZKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGZhY3RvcnkgbWV0aG9kczogTGlzdENoYW5nZUxpc3RlbmVyICoqKioqKioqKioKLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGxpc3QgY2hhbmdlIGxpc3RlbmVyIHRoYXQgd2lsbCBpbnZva2UgdGhlIHNwZWNpZmllZCBtZXRob2RzCi0JICogb24gdGhlIHNwZWNpZmllZCB0YXJnZXQuCi0JICovCi0JcHVibGljIHN0YXRpYyBMaXN0Q2hhbmdlTGlzdGVuZXIgYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXIoT2JqZWN0IHRhcmdldCwgTWV0aG9kIGFkZE1ldGhvZCwgTWV0aG9kIHJlbW92ZU1ldGhvZCwgTWV0aG9kIHJlcGxhY2VNZXRob2QsIE1ldGhvZCBtb3ZlTWV0aG9kLCBNZXRob2QgY2xlYXJNZXRob2QsIE1ldGhvZCBjaGFuZ2VNZXRob2QpIHsKLQkJY2hlY2tDaGFuZ2VMaXN0ZW5lck1ldGhvZChhZGRNZXRob2QsIExJU1RfQ0hBTkdFX0VWRU5UX0NMQVNTKTsKLQkJY2hlY2tDaGFuZ2VMaXN0ZW5lck1ldGhvZChyZW1vdmVNZXRob2QsIExJU1RfQ0hBTkdFX0VWRU5UX0NMQVNTKTsKLQkJY2hlY2tDaGFuZ2VMaXN0ZW5lck1ldGhvZChyZXBsYWNlTWV0aG9kLCBMSVNUX0NIQU5HRV9FVkVOVF9DTEFTUyk7Ci0JCWNoZWNrQ2hhbmdlTGlzdGVuZXJNZXRob2QobW92ZU1ldGhvZCwgTElTVF9DSEFOR0VfRVZFTlRfQ0xBU1MpOwotCQljaGVja0NoYW5nZUxpc3RlbmVyTWV0aG9kKGNsZWFyTWV0aG9kLCBMSVNUX0NIQU5HRV9FVkVOVF9DTEFTUyk7Ci0JCWNoZWNrQ2hhbmdlTGlzdGVuZXJNZXRob2QoY2hhbmdlTWV0aG9kLCBMSVNUX0NIQU5HRV9FVkVOVF9DTEFTUyk7Ci0JCXJldHVybiBuZXcgTXVsdGlNZXRob2RSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIodGFyZ2V0LCBhZGRNZXRob2QsIHJlbW92ZU1ldGhvZCwgcmVwbGFjZU1ldGhvZCwgbW92ZU1ldGhvZCwgY2xlYXJNZXRob2QsIGNoYW5nZU1ldGhvZCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgbGlzdCBjaGFuZ2UgbGlzdGVuZXIgdGhhdCB3aWxsIGludm9rZSB0aGUgc3BlY2lmaWVkIG1ldGhvZAotCSAqIG9uIHRoZSBzcGVjaWZpZWQgdGFyZ2V0IGZvciBhbnkgY2hhbmdlIGV2ZW50LgotCSAqLwotCXB1YmxpYyBzdGF0aWMgTGlzdENoYW5nZUxpc3RlbmVyIGJ1aWxkTGlzdENoYW5nZUxpc3RlbmVyKE9iamVjdCB0YXJnZXQsIE1ldGhvZCBtZXRob2QpIHsKLQkJcmV0dXJuIGJ1aWxkTGlzdENoYW5nZUxpc3RlbmVyKHRhcmdldCwgbWV0aG9kLCBtZXRob2QsIG1ldGhvZCwgbWV0aG9kLCBtZXRob2QsIG1ldGhvZCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgbGlzdCBjaGFuZ2UgbGlzdGVuZXIgdGhhdCB3aWxsIGludm9rZSB0aGUgc3BlY2lmaWVkIG1ldGhvZHMKLQkgKiBvbiB0aGUgc3BlY2lmaWVkIHRhcmdldCBmb3IgY2hhbmdlIGV2ZW50cy4gSWYgYSBzaW5nbGUtYXJndW1lbnQgbWV0aG9kCi0JICogd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUgYW5kIGFwcHJvcHJpYXRlIGFyZ3VtZW50IGlzIGZvdW5kLCBpdCB3aWxsIGJlIGludm9rZWQ7Ci0JICogb3RoZXJ3aXNlLCBhIHplcm8tYXJndW1lbnQgbWV0aG9kIHdpdGggdGhlIHNwZWNpZmllZCBuYW1lIHdpbGwgYmUgaW52b2tlZC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIExpc3RDaGFuZ2VMaXN0ZW5lciBidWlsZExpc3RDaGFuZ2VMaXN0ZW5lcihPYmplY3QgdGFyZ2V0LCBTdHJpbmcgYWRkTWV0aG9kTmFtZSwgU3RyaW5nIHJlbW92ZU1ldGhvZE5hbWUsIFN0cmluZyByZXBsYWNlTWV0aG9kTmFtZSwgU3RyaW5nIG1vdmVNZXRob2ROYW1lLCBTdHJpbmcgY2xlYXJNZXRob2ROYW1lLCBTdHJpbmcgY2hhbmdlTWV0aG9kTmFtZSkgewotCQlyZXR1cm4gYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXIoCi0JCQkJdGFyZ2V0LAotCQkJCWZpbmRDaGFuZ2VMaXN0ZW5lck1ldGhvZCh0YXJnZXQsIGFkZE1ldGhvZE5hbWUsIExJU1RfQ0hBTkdFX0VWRU5UX0NMQVNTX0FSUkFZKSwKLQkJCQlmaW5kQ2hhbmdlTGlzdGVuZXJNZXRob2QodGFyZ2V0LCByZW1vdmVNZXRob2ROYW1lLCBMSVNUX0NIQU5HRV9FVkVOVF9DTEFTU19BUlJBWSksCi0JCQkJZmluZENoYW5nZUxpc3RlbmVyTWV0aG9kKHRhcmdldCwgcmVwbGFjZU1ldGhvZE5hbWUsIExJU1RfQ0hBTkdFX0VWRU5UX0NMQVNTX0FSUkFZKSwKLQkJCQlmaW5kQ2hhbmdlTGlzdGVuZXJNZXRob2QodGFyZ2V0LCBtb3ZlTWV0aG9kTmFtZSwgTElTVF9DSEFOR0VfRVZFTlRfQ0xBU1NfQVJSQVkpLAotCQkJCWZpbmRDaGFuZ2VMaXN0ZW5lck1ldGhvZCh0YXJnZXQsIGNsZWFyTWV0aG9kTmFtZSwgTElTVF9DSEFOR0VfRVZFTlRfQ0xBU1NfQVJSQVkpLAotCQkJCWZpbmRDaGFuZ2VMaXN0ZW5lck1ldGhvZCh0YXJnZXQsIGNoYW5nZU1ldGhvZE5hbWUsIExJU1RfQ0hBTkdFX0VWRU5UX0NMQVNTX0FSUkFZKQotCQkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIGxpc3QgY2hhbmdlIGxpc3RlbmVyIHRoYXQgd2lsbCBpbnZva2UgdGhlIHNwZWNpZmllZCBtZXRob2QKLQkgKiBvbiB0aGUgc3BlY2lmaWVkIHRhcmdldCBmb3IgYW55IGNoYW5nZSBldmVudC4gSWYgYSBzaW5nbGUtYXJndW1lbnQgbWV0aG9kCi0JICogd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUgYW5kIGFwcHJvcHJpYXRlIGFyZ3VtZW50IGlzIGZvdW5kLCBpdCB3aWxsIGJlIGludm9rZWQ7Ci0JICogb3RoZXJ3aXNlLCBhIHplcm8tYXJndW1lbnQgbWV0aG9kIHdpdGggdGhlIHNwZWNpZmllZCBuYW1lIHdpbGwgYmUgaW52b2tlZC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIExpc3RDaGFuZ2VMaXN0ZW5lciBidWlsZExpc3RDaGFuZ2VMaXN0ZW5lcihPYmplY3QgdGFyZ2V0LCBTdHJpbmcgbWV0aG9kTmFtZSkgewotCQlyZXR1cm4gYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXIodGFyZ2V0LCBmaW5kQ2hhbmdlTGlzdGVuZXJNZXRob2QodGFyZ2V0LCBtZXRob2ROYW1lLCBMSVNUX0NIQU5HRV9FVkVOVF9DTEFTU19BUlJBWSkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBmYWN0b3J5IG1ldGhvZHM6IFRyZWVDaGFuZ2VMaXN0ZW5lciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSB0cmVlIGNoYW5nZSBsaXN0ZW5lciB0aGF0IHdpbGwgaW52b2tlIHRoZSBzcGVjaWZpZWQgbWV0aG9kcwotCSAqIG9uIHRoZSBzcGVjaWZpZWQgdGFyZ2V0LgotCSAqLwotCXB1YmxpYyBzdGF0aWMgVHJlZUNoYW5nZUxpc3RlbmVyIGJ1aWxkVHJlZUNoYW5nZUxpc3RlbmVyKE9iamVjdCB0YXJnZXQsIE1ldGhvZCBhZGRNZXRob2QsIE1ldGhvZCByZW1vdmVNZXRob2QsIE1ldGhvZCBjbGVhck1ldGhvZCwgTWV0aG9kIGNoYW5nZU1ldGhvZCkgewotCQljaGVja0NoYW5nZUxpc3RlbmVyTWV0aG9kKGFkZE1ldGhvZCwgVFJFRV9DSEFOR0VfRVZFTlRfQ0xBU1MpOwotCQljaGVja0NoYW5nZUxpc3RlbmVyTWV0aG9kKHJlbW92ZU1ldGhvZCwgVFJFRV9DSEFOR0VfRVZFTlRfQ0xBU1MpOwotCQljaGVja0NoYW5nZUxpc3RlbmVyTWV0aG9kKGNsZWFyTWV0aG9kLCBUUkVFX0NIQU5HRV9FVkVOVF9DTEFTUyk7Ci0JCWNoZWNrQ2hhbmdlTGlzdGVuZXJNZXRob2QoY2hhbmdlTWV0aG9kLCBUUkVFX0NIQU5HRV9FVkVOVF9DTEFTUyk7Ci0JCXJldHVybiBuZXcgTXVsdGlNZXRob2RSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIodGFyZ2V0LCBhZGRNZXRob2QsIHJlbW92ZU1ldGhvZCwgY2xlYXJNZXRob2QsIGNoYW5nZU1ldGhvZCk7Ci0JfQotCi0JLyoqCi0JICogQ29uc3RydWN0IGEgdHJlZSBjaGFuZ2UgbGlzdGVuZXIgdGhhdCB3aWxsIGludm9rZSB0aGUgc3BlY2lmaWVkIG1ldGhvZAotCSAqIG9uIHRoZSBzcGVjaWZpZWQgdGFyZ2V0IGZvciBhbnkgY2hhbmdlIGV2ZW50LgotCSAqLwotCXB1YmxpYyBzdGF0aWMgVHJlZUNoYW5nZUxpc3RlbmVyIGJ1aWxkVHJlZUNoYW5nZUxpc3RlbmVyKE9iamVjdCB0YXJnZXQsIE1ldGhvZCBtZXRob2QpIHsKLQkJcmV0dXJuIGJ1aWxkVHJlZUNoYW5nZUxpc3RlbmVyKHRhcmdldCwgbWV0aG9kLCBtZXRob2QsIG1ldGhvZCwgbWV0aG9kKTsKLQl9Ci0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSB0cmVlIGNoYW5nZSBsaXN0ZW5lciB0aGF0IHdpbGwgaW52b2tlIHRoZSBzcGVjaWZpZWQgbWV0aG9kcwotCSAqIG9uIHRoZSBzcGVjaWZpZWQgdGFyZ2V0IGZvciBjaGFuZ2UgZXZlbnRzLiBJZiBhIHNpbmdsZS1hcmd1bWVudCBtZXRob2QKLQkgKiB3aXRoIHRoZSBzcGVjaWZpZWQgbmFtZSBhbmQgYXBwcm9wcmlhdGUgYXJndW1lbnQgaXMgZm91bmQsIGl0IHdpbGwgYmUgaW52b2tlZDsKLQkgKiBvdGhlcndpc2UsIGEgemVyby1hcmd1bWVudCBtZXRob2Qgd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUgd2lsbCBiZSBpbnZva2VkLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgVHJlZUNoYW5nZUxpc3RlbmVyIGJ1aWxkVHJlZUNoYW5nZUxpc3RlbmVyKE9iamVjdCB0YXJnZXQsIFN0cmluZyBhZGRNZXRob2ROYW1lLCBTdHJpbmcgcmVtb3ZlTWV0aG9kTmFtZSwgU3RyaW5nIGNsZWFyTWV0aG9kTmFtZSwgU3RyaW5nIGNoYW5nZU1ldGhvZE5hbWUpIHsKLQkJcmV0dXJuIGJ1aWxkVHJlZUNoYW5nZUxpc3RlbmVyKAotCQkJCXRhcmdldCwKLQkJCQlmaW5kQ2hhbmdlTGlzdGVuZXJNZXRob2QodGFyZ2V0LCBhZGRNZXRob2ROYW1lLCBUUkVFX0NIQU5HRV9FVkVOVF9DTEFTU19BUlJBWSksCi0JCQkJZmluZENoYW5nZUxpc3RlbmVyTWV0aG9kKHRhcmdldCwgcmVtb3ZlTWV0aG9kTmFtZSwgVFJFRV9DSEFOR0VfRVZFTlRfQ0xBU1NfQVJSQVkpLAotCQkJCWZpbmRDaGFuZ2VMaXN0ZW5lck1ldGhvZCh0YXJnZXQsIGNsZWFyTWV0aG9kTmFtZSwgVFJFRV9DSEFOR0VfRVZFTlRfQ0xBU1NfQVJSQVkpLAotCQkJCWZpbmRDaGFuZ2VMaXN0ZW5lck1ldGhvZCh0YXJnZXQsIGNoYW5nZU1ldGhvZE5hbWUsIFRSRUVfQ0hBTkdFX0VWRU5UX0NMQVNTX0FSUkFZKQotCQkpOwotCX0KLQotCS8qKgotCSAqIENvbnN0cnVjdCBhIHRyZWUgY2hhbmdlIGxpc3RlbmVyIHRoYXQgd2lsbCBpbnZva2UgdGhlIHNwZWNpZmllZCBtZXRob2QKLQkgKiBvbiB0aGUgc3BlY2lmaWVkIHRhcmdldCBmb3IgYW55IGNoYW5nZSBldmVudC4gSWYgYSBzaW5nbGUtYXJndW1lbnQgbWV0aG9kCi0JICogd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUgYW5kIGFwcHJvcHJpYXRlIGFyZ3VtZW50IGlzIGZvdW5kLCBpdCB3aWxsIGJlIGludm9rZWQ7Ci0JICogb3RoZXJ3aXNlLCBhIHplcm8tYXJndW1lbnQgbWV0aG9kIHdpdGggdGhlIHNwZWNpZmllZCBuYW1lIHdpbGwgYmUgaW52b2tlZC4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFRyZWVDaGFuZ2VMaXN0ZW5lciBidWlsZFRyZWVDaGFuZ2VMaXN0ZW5lcihPYmplY3QgdGFyZ2V0LCBTdHJpbmcgbWV0aG9kTmFtZSkgewotCQlyZXR1cm4gYnVpbGRUcmVlQ2hhbmdlTGlzdGVuZXIodGFyZ2V0LCBmaW5kQ2hhbmdlTGlzdGVuZXJNZXRob2QodGFyZ2V0LCBtZXRob2ROYW1lLCBUUkVFX0NIQU5HRV9FVkVOVF9DTEFTU19BUlJBWSkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvciAqKioqKioqKioqCi0KLQkvKioKLQkgKiBDb25zdHJ1Y3QgYSBsaXN0ZW5lciB0aGF0IHdpbGwgaW52b2tlIHRoZSBzcGVjaWZpZWQgbWV0aG9kCi0JICogb24gdGhlIHNwZWNpZmllZCB0YXJnZXQuCi0JICovCi0JcHJvdGVjdGVkIFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lcihPYmplY3QgdGFyZ2V0KSB7Ci0JCXN1cGVyKCk7Ci0JCXRoaXMudGFyZ2V0ID0gdGFyZ2V0OwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2xpc3RlbmVyL1NpbmdsZU1ldGhvZFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lci5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2xpc3RlbmVyL1NpbmdsZU1ldGhvZFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiYTdlYTI0Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9TaW5nbGVNZXRob2RSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDYwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXI7Ci0KLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5NZXRob2Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Qcm9wZXJ0eUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlN0YXRlQ2hhbmdlRXZlbnQ7Ci0KLS8qKgotICogVGhpcyBjbGFzcyBpcyB1c2VkIGJ5IFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lciB3aGVuIHRoZSByZXF1ZXN0ZWQgbGlzdGVuZXIKLSAqIG5lZWQgb25seSBpbXBsZW1lbnQgYSBzaW5nbGUgbWV0aG9kIChpLmUuIFN0YXRlQ2hhbmdlTGlzdGVuZXIgb3IKLSAqIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIpLgotICovCi1jbGFzcyBTaW5nbGVNZXRob2RSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIKLQlleHRlbmRzIFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lcgotCWltcGxlbWVudHMgU3RhdGVDaGFuZ2VMaXN0ZW5lciwgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcgotewotCi0JLyoqIHRoZSBtZXRob2Qgd2Ugd2lsbCBpbnZva2Ugb24gdGhlIHRhcmdldCBvYmplY3QgKi8KLQlwcml2YXRlIGZpbmFsIE1ldGhvZCBtZXRob2Q7Ci0JLyoqIGNhY2hlIHRoZSBudW1iZXIgb2YgYXJndW1lbnRzICovCi0JcHJpdmF0ZSBmaW5hbCBib29sZWFuIG1ldGhvZElzWmVyb0FyZ3VtZW50OwotCi0JU2luZ2xlTWV0aG9kUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyKE9iamVjdCB0YXJnZXQsIE1ldGhvZCBtZXRob2QpIHsKLQkJc3VwZXIodGFyZ2V0KTsKLQkJdGhpcy5tZXRob2QgPSBtZXRob2Q7Ci0JCXRoaXMubWV0aG9kSXNaZXJvQXJndW1lbnQgPSBtZXRob2QuZ2V0UGFyYW1ldGVyVHlwZXMoKS5sZW5ndGggPT0gMDsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogU3RhdGVDaGFuZ2VMaXN0ZW5lciBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoU3RhdGVDaGFuZ2VFdmVudCBldmVudCkgewotCQlpZiAodGhpcy5tZXRob2RJc1plcm9Bcmd1bWVudCkgewotCQkJQ2xhc3NUb29scy5leGVjdXRlTWV0aG9kKHRoaXMubWV0aG9kLCB0aGlzLnRhcmdldCwgRU1QVFlfU1RBVEVfQ0hBTkdFX0VWRU5UX0FSUkFZKTsKLQkJfSBlbHNlIHsKLQkJCUNsYXNzVG9vbHMuZXhlY3V0ZU1ldGhvZCh0aGlzLm1ldGhvZCwgdGhpcy50YXJnZXQsIG5ldyBTdGF0ZUNoYW5nZUV2ZW50W10ge2V2ZW50fSk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCkgewotCQlpZiAodGhpcy5tZXRob2RJc1plcm9Bcmd1bWVudCkgewotCQkJQ2xhc3NUb29scy5leGVjdXRlTWV0aG9kKHRoaXMubWV0aG9kLCB0aGlzLnRhcmdldCwgRU1QVFlfUFJPUEVSVFlfQ0hBTkdFX0VWRU5UX0FSUkFZKTsKLQkJfSBlbHNlIHsKLQkJCUNsYXNzVG9vbHMuZXhlY3V0ZU1ldGhvZCh0aGlzLm1ldGhvZCwgdGhpcy50YXJnZXQsIG5ldyBQcm9wZXJ0eUNoYW5nZUV2ZW50W10ge2V2ZW50fSk7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9TdGF0ZUNoYW5nZUxpc3RlbmVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvbGlzdGVuZXIvU3RhdGVDaGFuZ2VMaXN0ZW5lci5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxY2U2YmE1Li4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC9saXN0ZW5lci9TdGF0ZUNoYW5nZUxpc3RlbmVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuU3RhdGVDaGFuZ2VFdmVudDsKLQotLyoqCi0gKiBBIGdlbmVyaWMgInN0YXRlIGNoYW5nZSIgZXZlbnQgZ2V0cyBkZWxpdmVyZWQgd2hlbmV2ZXIgYSBtb2RlbCBjaGFuZ2VzIHRvIAotICogc3VjaCBleHRlbnQgdGhhdCBpdCBjYW5ub3QgYmUgZGVsaW5lYXRlZCBhbGwgYXNwZWN0cyBvZiBpdCB0aGF0IGhhdmUgY2hhbmdlZC4gCi0gKiBZb3UgY2FuIHJlZ2lzdGVyIGEgU3RhdGVDaGFuZ2VMaXN0ZW5lciB3aXRoIGEgc291cmNlIG1vZGVsIHNvIGFzIHRvIGJlIG5vdGlmaWVkIAotICogb2YgYW55IHN1Y2ggY2hhbmdlcy4KLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKi8KLXB1YmxpYyBpbnRlcmZhY2UgU3RhdGVDaGFuZ2VMaXN0ZW5lciBleHRlbmRzIENoYW5nZUxpc3RlbmVyIHsKLQotCS8qKgotCSAqIFRoaXMgbWV0aG9kIGdldHMgY2FsbGVkIHdoZW4gYSBtb2RlbCBoYXMgY2hhbmdlZCBpbiBzb21lIGdlbmVyYWwgZmFzaGlvbi4KLQkgKiAKLQkgKiBAcGFyYW0gZXZlbnQgQSBTdGF0ZUNoYW5nZUV2ZW50IGRlc2NyaWJpbmcgdGhlIGV2ZW50IHNvdXJjZS4KLQkgKi8KLQl2b2lkIHN0YXRlQ2hhbmdlZChTdGF0ZUNoYW5nZUV2ZW50IGV2ZW50KTsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2xpc3RlbmVyL1RyZWVDaGFuZ2VBZGFwdGVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvbGlzdGVuZXIvVHJlZUNoYW5nZUFkYXB0ZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggM2I0NjIwMi4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvbGlzdGVuZXIvVHJlZUNoYW5nZUFkYXB0ZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQ4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXI7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5UcmVlQ2hhbmdlRXZlbnQ7Ci0KLS8qKgotICogQ29udmVuaWVuY2UgaW1wbGVtZW50YXRpb24gb2YgVHJlZUNoYW5nZUxpc3RlbmVyLgotICogCi0gKiBQcm92aXNpb25hbCBBUEk6IFRoaXMgY2xhc3MgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsCi0gKiB1bmRlciBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nCi0gKiBzdGFiaWxpdHkuIEl0IGlzIGF2YWlsYWJsZSBhdCB0aGlzIGVhcmx5IHN0YWdlIHRvIHNvbGljaXQgZmVlZGJhY2sgZnJvbQotICogcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyB0aGlzIEFQSQotICogd2lsbCBhbG1vc3QgY2VydGFpbmx5IGJlIGJyb2tlbiAocmVwZWF0ZWRseSkgYXMgdGhlIEFQSSBldm9sdmVzLgotICovCi1wdWJsaWMgY2xhc3MgVHJlZUNoYW5nZUFkYXB0ZXIgaW1wbGVtZW50cyBUcmVlQ2hhbmdlTGlzdGVuZXIgewotCi0JLyoqCi0JICogRGVmYXVsdCBjb25zdHJ1Y3Rvci4KLQkgKi8KLQlwdWJsaWMgVHJlZUNoYW5nZUFkYXB0ZXIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgbm9kZUFkZGVkKFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQkvLyBkbyBub3RoaW5nCi0JfQotCi0JcHVibGljIHZvaWQgbm9kZVJlbW92ZWQoVHJlZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCS8vIGRvIG5vdGhpbmcKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0cmVlQ2xlYXJlZChUcmVlQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJLy8gZG8gbm90aGluZwotCX0KLQotCXB1YmxpYyB2b2lkIHRyZWVDaGFuZ2VkKFRyZWVDaGFuZ2VFdmVudCBldmVudCkgewotCQkvLyBkbyBub3RoaW5nCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvbGlzdGVuZXIvVHJlZUNoYW5nZUxpc3RlbmVyLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvbGlzdGVuZXIvVHJlZUNoYW5nZUxpc3RlbmVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDc1OTFmOWQuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL2xpc3RlbmVyL1RyZWVDaGFuZ2VMaXN0ZW5lci5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNjIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lcjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlRyZWVDaGFuZ2VFdmVudDsKLQotLyoqCi0gKiBBICJ0cmVlIGNoYW5nZSIgZXZlbnQgZ2V0cyBmaXJlZCB3aGVuZXZlciBhIG1vZGVsIGNoYW5nZXMgYSAiYm91bmQiCi0gKiB0cmVlLiBZb3UgY2FuIHJlZ2lzdGVyIGEgVHJlZUNoYW5nZUxpc3RlbmVyIHdpdGggYSBzb3VyY2UKLSAqIG1vZGVsIHNvIGFzIHRvIGJlIG5vdGlmaWVkIG9mIGFueSBib3VuZCB0cmVlIHVwZGF0ZXMuCi0gKiAKLSAqIFByb3Zpc2lvbmFsIEFQSTogVGhpcyBpbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsCi0gKiB1bmRlciBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nCi0gKiBzdGFiaWxpdHkuIEl0IGlzIGF2YWlsYWJsZSBhdCB0aGlzIGVhcmx5IHN0YWdlIHRvIHNvbGljaXQgZmVlZGJhY2sgZnJvbQotICogcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyB0aGlzIEFQSQotICogd2lsbCBhbG1vc3QgY2VydGFpbmx5IGJlIGJyb2tlbiAocmVwZWF0ZWRseSkgYXMgdGhlIEFQSSBldm9sdmVzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIFRyZWVDaGFuZ2VMaXN0ZW5lciBleHRlbmRzIENoYW5nZUxpc3RlbmVyIHsKLQotCS8qKgotCSAqIFRoaXMgbWV0aG9kIGdldHMgY2FsbGVkIHdoZW4gYSBub2RlIGlzIGFkZGVkIHRvIGEgYm91bmQgdHJlZS4KLQkgKiAKLQkgKiBAcGFyYW0gZXZlbnQgQSBUcmVlQ2hhbmdlRXZlbnQgZGVzY3JpYmluZyB0aGUgZXZlbnQgc291cmNlLAotCSAqIHRoZSB0cmVlIHRoYXQgY2hhbmdlZCwgYW5kIHRoZSBwYXRoIHRvIHRoZSBub2RlIHRoYXQgd2FzIGFkZGVkLgotCSAqLwotCXZvaWQgbm9kZUFkZGVkKFRyZWVDaGFuZ2VFdmVudCBldmVudCk7Ci0KLQkvKioKLQkgKiBUaGlzIG1ldGhvZCBnZXRzIGNhbGxlZCB3aGVuIGEgbm9kZSBpcyByZW1vdmVkIGZyb20gYSBib3VuZCB0cmVlLgotCSAqIAotCSAqIEBwYXJhbSBldmVudCBBIFRyZWVDaGFuZ2VFdmVudCBkZXNjcmliaW5nIHRoZSBldmVudCBzb3VyY2UsCi0JICogdGhlIHRyZWUgdGhhdCBjaGFuZ2VkLCBhbmQgdGhlIHBhdGggdG8gdGhlIG5vZGUgdGhhdCB3YXMgcmVtb3ZlZC4KLQkgKi8KLQl2b2lkIG5vZGVSZW1vdmVkKFRyZWVDaGFuZ2VFdmVudCBldmVudCk7Ci0KLQkvKioKLQkgKiBUaGlzIG1ldGhvZCBnZXRzIGNhbGxlZCB3aGVuIGEgYm91bmQgdHJlZSBpcyBjbGVhcmVkLgotCSAqIAotCSAqIEBwYXJhbSBldmVudCBBIFRyZWVDaGFuZ2VFdmVudCBkZXNjcmliaW5nIHRoZSBldmVudCBzb3VyY2UsCi0JICogdGhlIHRyZWUgdGhhdCBjaGFuZ2VkLCBhbmQgYW4gZW1wdHkgcGF0aC4KLQkgKi8KLQl2b2lkIHRyZWVDbGVhcmVkKFRyZWVDaGFuZ2VFdmVudCBldmVudCk7Ci0KLQkvKioKLQkgKiBUaGlzIG1ldGhvZCBnZXRzIGNhbGxlZCB3aGVuIGEgcG9ydGlvbiBvZiBhIGJvdW5kIHRyZWUgaXMgY2hhbmdlZCBpbgotCSAqIGEgbWFubmVyIHRoYXQgaXMgbm90IGVhc2lseSBjaGFyYWN0ZXJpemVkIGJ5IHRoZSBvdGhlciBtZXRob2RzIGluIHRoaXMKLQkgKiBpbnRlcmZhY2UuCi0JICogCi0JICogQHBhcmFtIGV2ZW50IEEgVHJlZUNoYW5nZUV2ZW50IGRlc2NyaWJpbmcgdGhlIGV2ZW50IHNvdXJjZSwKLQkgKiB0aGUgdHJlZSB0aGF0IGNoYW5nZWQsIGFuZCB0aGUgcGF0aCB0byB0aGUgYnJhbmNoIG9mIHRoZQotCSAqIHRyZWUgdGhhdCBjaGFuZ2VkLgotCSAqLwotCXZvaWQgdHJlZUNoYW5nZWQoVHJlZUNoYW5nZUV2ZW50IGV2ZW50KTsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL3ZhbHVlL0NvbGxlY3Rpb25WYWx1ZU1vZGVsLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvdmFsdWUvQ29sbGVjdGlvblZhbHVlTW9kZWwuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmEyNWNmOS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvdmFsdWUvQ29sbGVjdGlvblZhbHVlTW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci0KLS8qKgotICogSW50ZXJmYWNlIHVzZWQgdG8gYWJzdHJhY3QgY29sbGVjdGlvbiBhY2Nlc3NpbmcgYW5kCi0gKiBjaGFuZ2Ugbm90aWZpY2F0aW9uIGFuZCBtYWtlIGl0IG1vcmUgcGx1Z2dhYmxlLgotICogCi0gKiBQcm92aXNpb25hbCBBUEk6IFRoaXMgaW50ZXJmYWNlIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbAotICogdW5kZXIgZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZwotICogc3RhYmlsaXR5LiBJdCBpcyBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20KLSAqIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgdGhpcyBBUEkKLSAqIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KLSAqLwotcHVibGljIGludGVyZmFjZSBDb2xsZWN0aW9uVmFsdWVNb2RlbDxFPgotCWV4dGVuZHMgTW9kZWwsIEl0ZXJhYmxlPEU+Ci17Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNvbGxlY3Rpb24ncyB2YWx1ZXMuCi0JICovCi0JSXRlcmF0b3I8RT4gaXRlcmF0b3IoKTsKLQkJU3RyaW5nIFZBTFVFUyA9ICJ2YWx1ZXMiOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaXplIG9mIHRoZSBjb2xsZWN0aW9uIHZhbHVlLgotCSAqLwotCWludCBzaXplKCk7Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC92YWx1ZS9MaXN0VmFsdWVNb2RlbC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL3ZhbHVlL0xpc3RWYWx1ZU1vZGVsLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDY1ZWFhNzcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL3ZhbHVlL0xpc3RWYWx1ZU1vZGVsLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuTW9kZWw7Ci0KLS8qKgotICogSW50ZXJmYWNlIHVzZWQgdG8gYWJzdHJhY3QgbGlzdCBhY2Nlc3NpbmcgYW5kCi0gKiBjaGFuZ2Ugbm90aWZpY2F0aW9uIGFuZCBtYWtlIGl0IG1vcmUgcGx1Z2dhYmxlLgotICogCi0gKiBQcm92aXNpb25hbCBBUEk6IFRoaXMgaW50ZXJmYWNlIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbAotICogdW5kZXIgZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZwotICogc3RhYmlsaXR5LiBJdCBpcyBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20KLSAqIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgdGhpcyBBUEkKLSAqIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KLSAqLwotcHVibGljIGludGVyZmFjZSBMaXN0VmFsdWVNb2RlbDxFPgotCWV4dGVuZHMgTW9kZWwsIEl0ZXJhYmxlPEU+Ci17Ci0JLyoqCi0JICogUmV0dXJuIHRoZSBsaXN0J3MgdmFsdWVzLgotCSAqLwotCUl0ZXJhdG9yPEU+IGl0ZXJhdG9yKCk7Ci0JCVN0cmluZyBMSVNUX1ZBTFVFUyA9ICJsaXN0IHZhbHVlcyI7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGxpc3QncyB2YWx1ZXMuCi0JICovCi0JTGlzdEl0ZXJhdG9yPEU+IGxpc3RJdGVyYXRvcigpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaXplIG9mIHRoZSBsaXN0LgotCSAqLwotCWludCBzaXplKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGl0ZW0gYXQgdGhlIHNwZWNpZmllZCBpbmRleCBvZiB0aGUgbGlzdC4KLQkgKi8KLQlFIGdldChpbnQgaW5kZXgpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBsaXN0J3MgdmFsdWVzLgotCSAqLwotCU9iamVjdFtdIHRvQXJyYXkoKTsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL3ZhbHVlL1Byb3BlcnR5VmFsdWVNb2RlbC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL3ZhbHVlL1Byb3BlcnR5VmFsdWVNb2RlbC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4MmVlM2MwLi4wMDAwMDAwCi0tLSBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC92YWx1ZS9Qcm9wZXJ0eVZhbHVlTW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDM0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5Nb2RlbDsKLQotLyoqCi0gKiBJbnRlcmZhY2UgdXNlZCB0byBhYnN0cmFjdCBwcm9wZXJ0eSBhY2Nlc3NpbmcgYW5kCi0gKiBjaGFuZ2Ugbm90aWZpY2F0aW9uIGFuZCBtYWtlIGl0IG1vcmUgcGx1Z2dhYmxlLgotICogCi0gKiBQcm92aXNpb25hbCBBUEk6IFRoaXMgaW50ZXJmYWNlIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbAotICogdW5kZXIgZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZwotICogc3RhYmlsaXR5LiBJdCBpcyBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20KLSAqIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgdGhpcyBBUEkKLSAqIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KLSAqLwotcHVibGljIGludGVyZmFjZSBQcm9wZXJ0eVZhbHVlTW9kZWw8VD4KLQlleHRlbmRzIE1vZGVsCi17Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHByb3BlcnR5J3MgdmFsdWUuCi0JICovCi0JVCBnZXRWYWx1ZSgpOwotCQlTdHJpbmcgVkFMVUUgPSAidmFsdWUiOwotCi19CmRpZmYgLS1naXQgYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvdmFsdWUvVHJlZU5vZGVWYWx1ZU1vZGVsLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvdmFsdWUvVHJlZU5vZGVWYWx1ZU1vZGVsLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGE2YmNlYTguLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL3ZhbHVlL1RyZWVOb2RlVmFsdWVNb2RlbC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZTsKLQotLyoqCi0gKiBFeHRlbmQgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWwgdG8gYmV0dGVyIHN1cHBvcnQgVHJlZU1vZGVsQWRhcHRlci4KLSAqIAotICogSW1wbGVtZW50b3JzIG9mIHRoaXMgaW50ZXJmYWNlIHNob3VsZCBmaXJlIGEgInN0YXRlIGNoYW5nZSIgZXZlbnQKLSAqIHdoZW5ldmVyIHRoZSBub2RlJ3MgaW50ZXJuYWwgc3RhdGUgY2hhbmdlcyBpbiBhIHdheSB0aGF0IHRoZQotICogdHJlZSBsaXN0ZW5lcnMgc2hvdWxkIGJlIG5vdGlmaWVkLgotICogCi0gKiBJbXBsZW1lbnRvcnMgb2YgdGhpcyBpbnRlcmZhY2Ugc2hvdWxkIGFsc28gZmlyZSBhICJ2YWx1ZSBwcm9wZXJ0eSBjaGFuZ2UiCi0gKiBldmVudCB3aGVuZXZlciB0aGUgbm9kZSdzIHZhbHVlIGNoYW5nZXMuIFR5cGljYWxseSwgb25seSBub2RlcyB0aGF0Ci0gKiBob2xkICJwcmltaXRpdmUiIGRhdGEgd2lsbCBmaXJlIHRoaXMgZXZlbnQuCi0gKiAKLSAqIEBzZWUgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuQWJzdHJhY3RUcmVlTm9kZVZhbHVlTW9kZWwKLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKi8KLXB1YmxpYyBpbnRlcmZhY2UgVHJlZU5vZGVWYWx1ZU1vZGVsPFQ+Ci0JZXh0ZW5kcyBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUPgotewotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBub2RlJ3MgcGFyZW50IG5vZGU7IG51bGwgaWYgdGhlIG5vZGUKLQkgKiBpcyB0aGUgcm9vdC4KLQkgKi8KLQlUcmVlTm9kZVZhbHVlTW9kZWw8VD4gcGFyZW50KCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHBhdGggdG8gdGhlIG5vZGUuCi0JICovCi0JVHJlZU5vZGVWYWx1ZU1vZGVsPFQ+W10gcGF0aCgpOwotCi0JLyoqCi0JICogUmV0dXJuIGEgbGlzdCB2YWx1ZSBtb2RlbCBvZiB0aGUgbm9kZSdzIGNoaWxkIG5vZGVzLgotCSAqLwotCUxpc3RWYWx1ZU1vZGVsPFRyZWVOb2RlVmFsdWVNb2RlbDxUPj4gY2hpbGRyZW5Nb2RlbCgpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBub2RlJ3MgY2hpbGQgYXQgdGhlIHNwZWNpZmllZCBpbmRleC4KLQkgKi8KLQlUcmVlTm9kZVZhbHVlTW9kZWw8VD4gY2hpbGQoaW50IGluZGV4KTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2l6ZSBvZiB0aGUgbm9kZSdzIGxpc3Qgb2YgY2hpbGRyZW4uCi0JICovCi0JaW50IGNoaWxkcmVuU2l6ZSgpOwotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBpbmRleCBpbiB0aGUgbm9kZSdzIGxpc3Qgb2YgY2hpbGRyZW4gb2YgdGhlIHNwZWNpZmllZCBjaGlsZC4KLQkgKi8KLQlpbnQgaW5kZXhPZkNoaWxkKFRyZWVOb2RlVmFsdWVNb2RlbDxUPiBjaGlsZCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgbm9kZSBpcyBhIGxlYWYgKGkuZS4gaXQgaGFzIG5vIGNoaWxkcmVuKQotCSAqLwotCWJvb2xlYW4gaXNMZWFmKCk7Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS9wbHVnaW5zL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5L3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS9tb2RlbC92YWx1ZS9UcmVlVmFsdWVNb2RlbC5qYXZhIGIvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL3ZhbHVlL1RyZWVWYWx1ZU1vZGVsLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVjODdhMjcuLjAwMDAwMDAKLS0tIGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL3ZhbHVlL1RyZWVWYWx1ZU1vZGVsLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLk1vZGVsOwotCi0vKioKLSAqIEludGVyZmFjZSB1c2VkIHRvIGFic3RyYWN0IHRyZWUgYWNjZXNzaW5nIGFuZAotICogY2hhbmdlIG5vdGlmaWNhdGlvbiBhbmQgbWFrZSBpdCBtb3JlIHBsdWdnYWJsZS4KLSAqIAotICogUHJvdmlzaW9uYWwgQVBJOiBUaGlzIGludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwKLSAqIHVuZGVyIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcKLSAqIHN0YWJpbGl0eS4gSXQgaXMgYXZhaWxhYmxlIGF0IHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tCi0gKiBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJCi0gKiB3aWxsIGFsbW9zdCBjZXJ0YWlubHkgYmUgYnJva2VuIChyZXBlYXRlZGx5KSBhcyB0aGUgQVBJIGV2b2x2ZXMuCi0gKi8KLXB1YmxpYyBpbnRlcmZhY2UgVHJlZVZhbHVlTW9kZWw8RT4KLQlleHRlbmRzIE1vZGVsCi17Ci0JLyoqCi0JICogUmV0dXJuIHRoZSB0cmVlJ3Mgbm9kZXMuCi0JICovCi0JSXRlcmF0b3I8RT4gbm9kZXMoKTsKLQkJU3RyaW5nIE5PREVTID0gIm5vZGVzIjsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3BsdWdpbnMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L21vZGVsL3ZhbHVlL1dyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsLmphdmEgYi9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvdmFsdWUvV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWwuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzJkZGFjZS4uMDAwMDAwMAotLS0gYS9qcGEvcGx1Z2lucy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvbW9kZWwvdmFsdWUvV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWwuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDMxICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWU7Ci0KLS8qKgotICogRXh0ZW5kIFZhbHVlTW9kZWwgdG8gYWxsb3cgdGhlIHNldHRpbmcgb2YgdGhlIHByb3BlcnR5J3MgdmFsdWUuCi0gKiAKLSAqIFByb3Zpc2lvbmFsIEFQSTogVGhpcyBpbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsCi0gKiB1bmRlciBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nCi0gKiBzdGFiaWxpdHkuIEl0IGlzIGF2YWlsYWJsZSBhdCB0aGlzIGVhcmx5IHN0YWdlIHRvIHNvbGljaXQgZmVlZGJhY2sgZnJvbQotICogcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyB0aGlzIEFQSQotICogd2lsbCBhbG1vc3QgY2VydGFpbmx5IGJlIGJyb2tlbiAocmVwZWF0ZWRseSkgYXMgdGhlIEFQSSBldm9sdmVzLgotICovCi1wdWJsaWMgaW50ZXJmYWNlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFQ+Ci0JZXh0ZW5kcyBQcm9wZXJ0eVZhbHVlTW9kZWw8VD4KLXsKLQotCS8qKgotCSAqIFNldCB0aGUgdmFsdWUgYW5kIGZpcmUgYSBwcm9wZXJ0eSBjaGFuZ2Ugbm90aWZpY2F0aW9uLgotCSAqIEBzZWUgUHJvcGVydHlWYWx1ZU1vZGVsI1ZBTFVFCi0JICovCi0Jdm9pZCBzZXRWYWx1ZShUIHZhbHVlKTsKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS8uY2xhc3NwYXRoIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS8uY2xhc3NwYXRoCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkMGVhNjg5Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2UvLmNsYXNzcGF0aAorKysgL2Rldi9udWxsCkBAIC0xLDEyICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08Y2xhc3NwYXRoPgotCTxjbGFzc3BhdGhlbnRyeSBraW5kPSJzcmMiIHBhdGg9InNyYyIvPgotCTxjbGFzc3BhdGhlbnRyeSBraW5kPSJjb24iIHBhdGg9Im9yZy5lY2xpcHNlLmpkdC5sYXVuY2hpbmcuSlJFX0NPTlRBSU5FUi9vcmcuZWNsaXBzZS5qZHQuaW50ZXJuYWwuZGVidWcudWkubGF1bmNoZXIuU3RhbmRhcmRWTVR5cGUvSjJTRS0xLjUiLz4KLQk8Y2xhc3NwYXRoZW50cnkga2luZD0iY29uIiBwYXRoPSJvcmcuZWNsaXBzZS5wZGUuY29yZS5yZXF1aXJlZFBsdWdpbnMiPgotCQk8YWNjZXNzcnVsZXM+Ci0JCQk8YWNjZXNzcnVsZSBraW5kPSJhY2Nlc3NpYmxlIiBwYXR0ZXJuPSJvcmcvZWNsaXBzZS9qcHQvY29yZS8qKiIvPgotCQkJPGFjY2Vzc3J1bGUga2luZD0iYWNjZXNzaWJsZSIgcGF0dGVybj0ib3JnL2VjbGlwc2UvanB0L3VpLyoqIi8+Ci0JCTwvYWNjZXNzcnVsZXM+Ci0JPC9jbGFzc3BhdGhlbnRyeT4KLQk8Y2xhc3NwYXRoZW50cnkga2luZD0ib3V0cHV0IiBwYXRoPSJiaW4iLz4KLTwvY2xhc3NwYXRoPgpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS8uY3ZzaWdub3JlIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS8uY3ZzaWdub3JlCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhMTk2ZGQ3Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2UvLmN2c2lnbm9yZQorKysgL2Rldi9udWxsCkBAIC0xLDYgKzAsMCBAQAotYmluCi1AZG90Ci10ZW1wLmZvbGRlcgotYnVpbGQueG1sCi1qYXZhQ29tcGlsZXIuLi5hcmdzCi1qYXZhQ29tcGlsZXIuLi5hcmdzLioKXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlLy5wcm9qZWN0IGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS8ucHJvamVjdApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmI2NTYxZS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlLy5wcm9qZWN0CisrKyAvZGV2L251bGwKQEAgLTEsMjggKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxwcm9qZWN0RGVzY3JpcHRpb24+Ci0JPG5hbWU+b3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlPC9uYW1lPgotCTxjb21tZW50PjwvY29tbWVudD4KLQk8cHJvamVjdHM+Ci0JPC9wcm9qZWN0cz4KLQk8YnVpbGRTcGVjPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UuamR0LmNvcmUuamF2YWJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLk1hbmlmZXN0QnVpbGRlcjwvbmFtZT4KLQkJCTxhcmd1bWVudHM+Ci0JCQk8L2FyZ3VtZW50cz4KLQkJPC9idWlsZENvbW1hbmQ+Ci0JCTxidWlsZENvbW1hbmQ+Ci0JCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuU2NoZW1hQnVpbGRlcjwvbmFtZT4KLQkJCTxhcmd1bWVudHM+Ci0JCQk8L2FyZ3VtZW50cz4KLQkJPC9idWlsZENvbW1hbmQ+Ci0JPC9idWlsZFNwZWM+Ci0JPG5hdHVyZXM+Ci0JCTxuYXR1cmU+b3JnLmVjbGlwc2UucGRlLlBsdWdpbk5hdHVyZTwvbmF0dXJlPgotCQk8bmF0dXJlPm9yZy5lY2xpcHNlLmpkdC5jb3JlLmphdmFuYXR1cmU8L25hdHVyZT4KLQk8L25hdHVyZXM+Ci08L3Byb2plY3REZXNjcmlwdGlvbj4KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2UvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDU1MDQ0YWEuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMKKysrIC9kZXYvbnVsbApAQCAtMSwzICswLDAgQEAKLSNNb24gQXByIDA3IDE0OjI2OjMyIEVEVCAyMDA4Ci1lY2xpcHNlLnByZWZlcmVuY2VzLnZlcnNpb249MQotZW5jb2RpbmcvPHByb2plY3Q+PUlTTy04ODU5LTEKZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2UvTUVUQS1JTkYvTUFOSUZFU1QuTUYgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL01FVEEtSU5GL01BTklGRVNULk1GCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1ZWNjYTU3Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2UvTUVUQS1JTkYvTUFOSUZFU1QuTUYKKysrIC9kZXYvbnVsbApAQCAtMSwyNSArMCwwIEBACi1NYW5pZmVzdC1WZXJzaW9uOiAxLjAKLUJ1bmRsZS1NYW5pZmVzdFZlcnNpb246IDIKLUJ1bmRsZS1OYW1lOiAlcGx1Z2luTmFtZQotQnVuZGxlLVZlbmRvcjogJXByb3ZpZGVyTmFtZQotQnVuZGxlLVN5bWJvbGljTmFtZTogb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlO3NpbmdsZXRvbjo9dHJ1ZQotQnVuZGxlLVZlcnNpb246IDIuMi4wLnF1YWxpZmllcgotQnVuZGxlLUFjdGl2YXRvcjogb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlLkV4dGVuc2lvblRlc3RQbHVnaW4KLUJ1bmRsZS1BY3RpdmF0aW9uUG9saWN5OiBsYXp5Ci1CdW5kbGUtTG9jYWxpemF0aW9uOiBwbHVnaW4KLVJlcXVpcmUtQnVuZGxlOiBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUsCi0gb3JnLmVjbGlwc2UuanB0LmNvcmUsCi0gb3JnLmVjbGlwc2UuanB0LnVpLAotIG9yZy5lY2xpcHNlLndzdC52YWxpZGF0aW9uLAotIG9yZy5lY2xpcHNlLmpwdC5jb3JlLAotIG9yZy5lY2xpcHNlLmpwdC5nZW4sCi0gb3JnLmVjbGlwc2UuamZhY2UsCi0gb3JnLmVjbGlwc2UuanB0LmRiLAotIG9yZy5lY2xpcHNlLmpkdC5jb3JlLAotIG9yZy5lY2xpcHNlLmVtZi5lY29yZSwKLSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eSwKLSBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcywKLSBvcmcuZWNsaXBzZS51aS5uYXZpZ2F0b3I7YnVuZGxlLXZlcnNpb249IjMuMy4xMDAiLAotIG9yZy5lY2xpcHNlLnVpLnZpZXdzLnByb3BlcnRpZXMudGFiYmVkO2J1bmRsZS12ZXJzaW9uPSIzLjQuMCIKLUJ1bmRsZS1SZXF1aXJlZEV4ZWN1dGlvbkVudmlyb25tZW50OiBKMlNFLTEuNQotRXhwb3J0LVBhY2thZ2U6IG9yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZTt4LWZyaWVuZHM6PSJvcmcuZWNsaXBzZS5qcHQudWkudGVzdHMsb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMiCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL2Fib3V0Lmh0bWwgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL2Fib3V0Lmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJlNTM0YmEuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS9hYm91dC5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsMzQgKzAsMCBAQAotPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMC8vRU4iPgotPEhUTUw+Ci0KLTxoZWFkPgotPHRpdGxlPkFib3V0PC90aXRsZT4KLTxtZXRhIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1JU08tODg1OS0xIj4KLTwvaGVhZD4KLQotPEJPRFkgbGFuZz0iRU4tVVMiPgotCi08SDM+QWJvdXQgVGhpcyBDb250ZW50PC9IMz4KLQotPFA+TWF5IDAyLCAyMDA4PC9QPgotCi08SDM+TGljZW5zZTwvSDM+Ci0KLTxQPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIGFsbCBjb250ZW50IGluIHRoaXMgcGx1Zy1pbiAKLSgiQ29udGVudCIpLiBVbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCBiZWxvdywgdGhlIENvbnRlbnQgaXMgcHJvdmlkZWQgdG8geW91IAotdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIAotKCJFUEwiKS4gQSBjb3B5IG9mIHRoZSBFUEwgaXMgYXZhaWxhYmxlIGF0Ci08QSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL29yZy9kb2N1bWVudHMvZXBsLXYxMC5waHAiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvb3JnL2RvY3VtZW50cy9lcGwtdjEwLnBocDwvQT4uIAotRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9QPgotCi08UD5JZiB5b3UgZGlkIG5vdCByZWNlaXZlIHRoaXMgQ29udGVudCBkaXJlY3RseSBmcm9tIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24sIHRoZSAKLUNvbnRlbnQgaXMgYmVpbmcgcmVkaXN0cmlidXRlZCBieSBhbm90aGVyIHBhcnR5ICgiUmVkaXN0cmlidXRvciIpIGFuZCBkaWZmZXJlbnQgCi10ZXJtcyBhbmQgY29uZGl0aW9ucyBtYXkgYXBwbHkgdG8geW91ciB1c2Ugb2YgYW55IG9iamVjdCBjb2RlIGluIHRoZSBDb250ZW50LiAKLUNoZWNrIHRoZSBSZWRpc3RyaWJ1dG9yJ3MgbGljZW5zZSB0aGF0IHdhcyBwcm92aWRlZCB3aXRoIHRoZSBDb250ZW50LiBJZiBubyBzdWNoIAotbGljZW5zZSBleGlzdHMsIGNvbnRhY3QgdGhlIFJlZGlzdHJpYnV0b3IuIFVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkIGJlbG93LCB0aGUgCi10ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRVBMIHN0aWxsIGFwcGx5IHRvIGFueSBzb3VyY2UgY29kZSBpbiB0aGUgQ29udGVudCAKLWFuZCBzdWNoIHNvdXJjZSBjb2RlIG1heSBiZSBvYnRhaW5lZCBhdAotPEEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy8iPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvPC9BPi48L1A+Ci0KLTwvQk9EWT4KLTwvSFRNTD4KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2UvYnVpbGQucHJvcGVydGllcyBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2UvYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjVlM2Y0MC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL2J1aWxkLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwxOSArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNyBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi1qYXZhY1NvdXJjZT0xLjUKLWphdmFjVGFyZ2V0PTEuNQotc291cmNlLi4gPSBzcmMvCi1vdXRwdXQuLiA9IGJpbi8KLWJpbi5pbmNsdWRlcyA9IC4sXAotICAgICAgICAgICAgICAgTUVUQS1JTkYvLFwKLSAgICAgICAgICAgICAgIHBsdWdpbi54bWwsXAotICAgICAgICAgICAgICAgcGx1Z2luLnByb3BlcnRpZXMKLWphcnMuY29tcGlsZS5vcmRlciA9IC4KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2UvcGx1Z2luLnByb3BlcnRpZXMgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3BsdWdpbi5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4M2Y3MjdmLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2UvcGx1Z2luLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwyNCArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNyBPcmFjbGUuCi0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCi0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0Ci0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0jIFRvIGNvZGUgZGV2ZWxvcGVyOgotIyAgIERvIE5PVCBjaGFuZ2UgdGhlIHByb3BlcnRpZXMgYmV0d2VlbiB0aGlzIGxpbmUgYW5kIHRoZQotIyAgICIlJSUgRU5EIE9GIFRSQU5TTEFURUQgUFJPUEVSVElFUyAlJSUiIGxpbmUuCi0jICAgTWFrZSBhIG5ldyBwcm9wZXJ0eSBuYW1lLCBhcHBlbmQgdG8gdGhlIGVuZCBvZiB0aGUgZmlsZSBhbmQgY2hhbmdlCi0jICAgdGhlIGNvZGUgdG8gdXNlIHRoZSBuZXcgcHJvcGVydHkuCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0KLSMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLSMgJSUlIEVORCBPRiBUUkFOU0xBVEVEIFBST1BFUlRJRVMgJSUlCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0KLXBsdWdpbk5hbWUgPSBKYXZhIFBlcnNpc3RlbmNlIEFQSSBUb29scyAtIEV4dGVuc2lvblRlc3RQbHVnaW4KLXByb3ZpZGVyTmFtZSA9IEVjbGlwc2Uub3JnCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3BsdWdpbi54bWwgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3BsdWdpbi54bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDdjOTg4MWUuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS9wbHVnaW4ueG1sCisrKyAvZGV2L251bGwKQEAgLTEsMjcgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTw/ZWNsaXBzZSB2ZXJzaW9uPSIzLjIiPz4KLTxwbHVnaW4+Ci0KLQk8ZXh0ZW5zaW9uCi0JCXBvaW50PSJvcmcuZWNsaXBzZS5qcHQuY29yZS5qcGFQbGF0Zm9ybXMiPgotCQkKLQkJPGpwYVBsYXRmb3JtCi0JCQlpZD0iY29yZS50ZXN0SnBhUGxhdGZvcm0iCi0JCQlsYWJlbD0iVGVzdCBKcGEgUGxhdGZvcm0iCi0JCQlmYWN0b3J5Q2xhc3M9Im9yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS5UZXN0SnBhUGxhdGZvcm1GYWN0b3J5IgotCQkJZGVmYXVsdD0idHJ1ZSI+Ci0JCTwvanBhUGxhdGZvcm0+Ci0JCQotCTwvZXh0ZW5zaW9uPgotCQotCTxleHRlbnNpb24KLQkJcG9pbnQ9Im9yZy5lY2xpcHNlLmpwdC51aS5qcGFQbGF0Zm9ybVVpcyI+Ci0JCQotCQk8anBhUGxhdGZvcm1VaQotCQkJaWQ9ImNvcmUudGVzdEpwYVBsYXRmb3JtLnVpIgotCQkJanBhUGxhdGZvcm09ImNvcmUudGVzdEpwYVBsYXRmb3JtIgotCQkJZmFjdG9yeUNsYXNzPSJvcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2UuVGVzdEpwYVBsYXRmb3JtVWlGYWN0b3J5Ii8+Ci0JCQotCTwvZXh0ZW5zaW9uPgotCi08L3BsdWdpbj4KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2Uvc3JjL29yZy9lY2xpcHNlL2pwdC9jb3JlL3Rlc3RzL2V4dGVuc2lvbi9yZXNvdXJjZS9FeHRlbnNpb25UZXN0UGx1Z2luLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3NyYy9vcmcvZWNsaXBzZS9qcHQvY29yZS90ZXN0cy9leHRlbnNpb24vcmVzb3VyY2UvRXh0ZW5zaW9uVGVzdFBsdWdpbi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1MTA3NWE2Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2Uvc3JjL29yZy9lY2xpcHNlL2pwdC9jb3JlL3Rlc3RzL2V4dGVuc2lvbi9yZXNvdXJjZS9FeHRlbnNpb25UZXN0UGx1Z2luLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKLSAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAotICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKLSAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5QbHVnaW47Ci1pbXBvcnQgb3JnLm9zZ2kuZnJhbWV3b3JrLkJ1bmRsZUNvbnRleHQ7Ci0KLS8qKgotICogVGhlIGFjdGl2YXRvciBjbGFzcyBjb250cm9scyB0aGUgcGx1Zy1pbiBsaWZlIGN5Y2xlCi0gKi8KLXB1YmxpYyBjbGFzcyBFeHRlbnNpb25UZXN0UGx1Z2luIGV4dGVuZHMgUGx1Z2luIHsKLQotCS8vIFRoZSBwbHVnLWluIElECi0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgUExVR0lOX0lEID0gIm9yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZSI7Ci0KLQkvLyBUaGUgc2hhcmVkIGluc3RhbmNlCi0JcHJpdmF0ZSBzdGF0aWMgRXh0ZW5zaW9uVGVzdFBsdWdpbiBwbHVnaW47Ci0JCi0JLyoqCi0JICogVGhlIGNvbnN0cnVjdG9yCi0JICovCi0JcHVibGljIEV4dGVuc2lvblRlc3RQbHVnaW4oKSB7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgc3RhcnQoQnVuZGxlQ29udGV4dCBjb250ZXh0KSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc3RhcnQoY29udGV4dCk7Ci0JCXBsdWdpbiA9IHRoaXM7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgc3RvcChCdW5kbGVDb250ZXh0IGNvbnRleHQpIHRocm93cyBFeGNlcHRpb24gewotCQlwbHVnaW4gPSBudWxsOwotCQlzdXBlci5zdG9wKGNvbnRleHQpOwotCX0KLQotCS8qKgotCSAqIFJldHVybnMgdGhlIHNoYXJlZCBpbnN0YW5jZQotCSAqCi0JICogQHJldHVybiB0aGUgc2hhcmVkIGluc3RhbmNlCi0JICovCi0JcHVibGljIHN0YXRpYyBFeHRlbnNpb25UZXN0UGx1Z2luIGdldERlZmF1bHQoKSB7Ci0JCXJldHVybiBwbHVnaW47Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3NyYy9vcmcvZWNsaXBzZS9qcHQvY29yZS90ZXN0cy9leHRlbnNpb24vcmVzb3VyY2UvSmF2YVRlc3RBdHRyaWJ1dGVNYXBwaW5nLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3NyYy9vcmcvZWNsaXBzZS9qcHQvY29yZS90ZXN0cy9leHRlbnNpb24vcmVzb3VyY2UvSmF2YVRlc3RBdHRyaWJ1dGVNYXBwaW5nLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZhYWZiYzMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS9zcmMvb3JnL2VjbGlwc2UvanB0L2NvcmUvdGVzdHMvZXh0ZW5zaW9uL3Jlc291cmNlL0phdmFUZXN0QXR0cmlidXRlTWFwcGluZy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZTsKLQotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LmphdmEuSmF2YVBlcnNpc3RlbnRBdHRyaWJ1dGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuaW50ZXJuYWwuY29udGV4dC5qYXZhLkFic3RyYWN0SmF2YUF0dHJpYnV0ZU1hcHBpbmc7Ci0KLXB1YmxpYyBjbGFzcyBKYXZhVGVzdEF0dHJpYnV0ZU1hcHBpbmcgZXh0ZW5kcyBBYnN0cmFjdEphdmFBdHRyaWJ1dGVNYXBwaW5nCi17Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgVEVTVF9BVFRSSUJVVEVfTUFQUElOR19LRVkgPSAidGVzdEF0dHJpYnV0ZSI7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgVEVTVF9BVFRSSUJVVEVfQU5OT1RBVElPTl9OQU1FID0gInRlc3QuVGVzdEF0dHJpYnV0ZSI7Ci0KLQotCXB1YmxpYyBKYXZhVGVzdEF0dHJpYnV0ZU1hcHBpbmcoSmF2YVBlcnNpc3RlbnRBdHRyaWJ1dGUgcGFyZW50KSB7Ci0JCXN1cGVyKHBhcmVudCk7Ci0JfQotCQotCXB1YmxpYyBTdHJpbmcgZ2V0S2V5KCkgewotCQlyZXR1cm4gSmF2YVRlc3RBdHRyaWJ1dGVNYXBwaW5nLlRFU1RfQVRUUklCVVRFX01BUFBJTkdfS0VZOwotCX0KLQotCXB1YmxpYyBTdHJpbmcgZ2V0QW5ub3RhdGlvbk5hbWUoKSB7Ci0JCXJldHVybiBKYXZhVGVzdEF0dHJpYnV0ZU1hcHBpbmcuVEVTVF9BVFRSSUJVVEVfQU5OT1RBVElPTl9OQU1FOwotCX0KLQotCXB1YmxpYyBJdGVyYXRvcjxTdHJpbmc+IHN1cHBvcnRpbmdBbm5vdGF0aW9uTmFtZXMoKSB7Ci0JCS8vIFRPRE8gQXV0by1nZW5lcmF0ZWQgbWV0aG9kIHN0dWIKLQkJcmV0dXJuIG51bGw7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS9zcmMvb3JnL2VjbGlwc2UvanB0L2NvcmUvdGVzdHMvZXh0ZW5zaW9uL3Jlc291cmNlL0phdmFUZXN0QXR0cmlidXRlTWFwcGluZ1Byb3ZpZGVyLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3NyYy9vcmcvZWNsaXBzZS9qcHQvY29yZS90ZXN0cy9leHRlbnNpb24vcmVzb3VyY2UvSmF2YVRlc3RBdHRyaWJ1dGVNYXBwaW5nUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNWVlZDkxMS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3NyYy9vcmcvZWNsaXBzZS9qcHQvY29yZS90ZXN0cy9leHRlbnNpb24vcmVzb3VyY2UvSmF2YVRlc3RBdHRyaWJ1dGVNYXBwaW5nUHJvdmlkZXIuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQ4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2U7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcGFGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5KYXZhQXR0cmlidXRlTWFwcGluZ1Byb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5KYXZhUGVyc2lzdGVudEF0dHJpYnV0ZTsKLQotcHVibGljIGNsYXNzIEphdmFUZXN0QXR0cmlidXRlTWFwcGluZ1Byb3ZpZGVyCi0JaW1wbGVtZW50cyBKYXZhQXR0cmlidXRlTWFwcGluZ1Byb3ZpZGVyCi17Ci0JLy8gc2luZ2xldG9uCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgSmF2YVRlc3RBdHRyaWJ1dGVNYXBwaW5nUHJvdmlkZXIgSU5TVEFOQ0UgPSBuZXcgSmF2YVRlc3RBdHRyaWJ1dGVNYXBwaW5nUHJvdmlkZXIoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgSmF2YUF0dHJpYnV0ZU1hcHBpbmdQcm92aWRlciBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBKYXZhVGVzdEF0dHJpYnV0ZU1hcHBpbmdQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGdldEtleSgpIHsKLQkJcmV0dXJuIEphdmFUZXN0QXR0cmlidXRlTWFwcGluZy5URVNUX0FUVFJJQlVURV9NQVBQSU5HX0tFWTsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGdldEFubm90YXRpb25OYW1lKCkgewotCQlyZXR1cm4gSmF2YVRlc3RBdHRyaWJ1dGVNYXBwaW5nLlRFU1RfQVRUUklCVVRFX0FOTk9UQVRJT05fTkFNRTsKLQl9Ci0KLQlwdWJsaWMgSmF2YVRlc3RBdHRyaWJ1dGVNYXBwaW5nIGJ1aWxkTWFwcGluZyhKYXZhUGVyc2lzdGVudEF0dHJpYnV0ZSBwYXJlbnQsIEpwYUZhY3RvcnkgZmFjdG9yeSkgewotCQlyZXR1cm4gKChUZXN0SnBhRmFjdG9yeSkgZmFjdG9yeSkuYnVpbGRKYXZhVGVzdEF0dHJpYnV0ZU1hcHBpbmcocGFyZW50KTsKLQl9CQkKLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS9zcmMvb3JnL2VjbGlwc2UvanB0L2NvcmUvdGVzdHMvZXh0ZW5zaW9uL3Jlc291cmNlL0phdmFUZXN0VHlwZU1hcHBpbmcuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2Uvc3JjL29yZy9lY2xpcHNlL2pwdC9jb3JlL3Rlc3RzL2V4dGVuc2lvbi9yZXNvdXJjZS9KYXZhVGVzdFR5cGVNYXBwaW5nLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQxMjljZGQuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS9zcmMvb3JnL2VjbGlwc2UvanB0L2NvcmUvdGVzdHMvZXh0ZW5zaW9uL3Jlc291cmNlL0phdmFUZXN0VHlwZU1hcHBpbmcuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDUwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDgsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2U7Ci0KLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5qYXZhLkphdmFQZXJzaXN0ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5pbnRlcm5hbC5jb250ZXh0LmphdmEuQWJzdHJhY3RKYXZhVHlwZU1hcHBpbmc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkVtcHR5SXRlcmF0b3I7Ci0KLXB1YmxpYyBjbGFzcyBKYXZhVGVzdFR5cGVNYXBwaW5nIGV4dGVuZHMgQWJzdHJhY3RKYXZhVHlwZU1hcHBpbmcKLXsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBURVNUX1RZUEVfTUFQUElOR19LRVkgPSAidGVzdCI7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgVEVTVF9UWVBFX0FOTk9UQVRJT05fTkFNRSA9ICJ0ZXN0LlRlc3QiOwotCi0KLQlwdWJsaWMgSmF2YVRlc3RUeXBlTWFwcGluZyhKYXZhUGVyc2lzdGVudFR5cGUgcGFyZW50KSB7Ci0JCXN1cGVyKHBhcmVudCk7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXRBbm5vdGF0aW9uTmFtZSgpIHsKLQkJcmV0dXJuIFRFU1RfVFlQRV9BTk5PVEFUSU9OX05BTUU7Ci0JfQotCi0JcHVibGljIFN0cmluZyBnZXRLZXkoKSB7Ci0JCXJldHVybiBURVNUX1RZUEVfTUFQUElOR19LRVk7Ci0JfQotCi0JcHVibGljIEl0ZXJhdG9yPFN0cmluZz4gY29ycmVzcG9uZGluZ0Fubm90YXRpb25OYW1lcygpIHsKLQkJcmV0dXJuIEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBpc01hcHBlZCgpIHsKLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gdGFibGVOYW1lSXNJbnZhbGlkKFN0cmluZyB0YWJsZU5hbWUpIHsKLQkJcmV0dXJuIGZhbHNlOwotCX0KLQkKLQlwdWJsaWMgYm9vbGVhbiBzaG91bGRWYWxpZGF0ZURiSW5mbygpIHsKLQkJcmV0dXJuIGZhbHNlOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2Uvc3JjL29yZy9lY2xpcHNlL2pwdC9jb3JlL3Rlc3RzL2V4dGVuc2lvbi9yZXNvdXJjZS9KYXZhVGVzdFR5cGVNYXBwaW5nUHJvdmlkZXIuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2Uvc3JjL29yZy9lY2xpcHNlL2pwdC9jb3JlL3Rlc3RzL2V4dGVuc2lvbi9yZXNvdXJjZS9KYXZhVGVzdFR5cGVNYXBwaW5nUHJvdmlkZXIuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNGViNjU2MC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3NyYy9vcmcvZWNsaXBzZS9qcHQvY29yZS90ZXN0cy9leHRlbnNpb24vcmVzb3VyY2UvSmF2YVRlc3RUeXBlTWFwcGluZ1Byb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1MSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuSnBhRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LmphdmEuSmF2YVBlcnNpc3RlbnRUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5KYXZhVHlwZU1hcHBpbmdQcm92aWRlcjsKLQotLyoqCi0gKiAKLSAqLwotcHVibGljIGNsYXNzIEphdmFUZXN0VHlwZU1hcHBpbmdQcm92aWRlcgotCWltcGxlbWVudHMgSmF2YVR5cGVNYXBwaW5nUHJvdmlkZXIKLXsKLQkvLyBzaW5nbGV0b24KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBKYXZhVGVzdFR5cGVNYXBwaW5nUHJvdmlkZXIgSU5TVEFOQ0UgPSBuZXcgSmF2YVRlc3RUeXBlTWFwcGluZ1Byb3ZpZGVyKCk7Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNpbmdsZXRvbi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEphdmFUeXBlTWFwcGluZ1Byb3ZpZGVyIGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCi0JLyoqCi0JICogRW5zdXJlIHNpbmdsZSBpbnN0YW5jZS4KLQkgKi8KLQlwcml2YXRlIEphdmFUZXN0VHlwZU1hcHBpbmdQcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQlwdWJsaWMgU3RyaW5nIGdldEtleSgpIHsKLQkJcmV0dXJuIEphdmFUZXN0VHlwZU1hcHBpbmcuVEVTVF9UWVBFX01BUFBJTkdfS0VZOwotCX0KLQkKLQlwdWJsaWMgU3RyaW5nIGdldEFubm90YXRpb25OYW1lKCkgewotCQlyZXR1cm4gSmF2YVRlc3RUeXBlTWFwcGluZy5URVNUX1RZUEVfQU5OT1RBVElPTl9OQU1FOwotCX0KLQotCXB1YmxpYyBKYXZhVGVzdFR5cGVNYXBwaW5nIGJ1aWxkTWFwcGluZyhKYXZhUGVyc2lzdGVudFR5cGUgcGFyZW50LCBKcGFGYWN0b3J5IGZhY3RvcnkpIHsKLQkJcmV0dXJuICgoVGVzdEpwYUZhY3RvcnkpIGZhY3RvcnkpLmJ1aWxkSmF2YVRlc3RUeXBlTWFwcGluZyhwYXJlbnQpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS9zcmMvb3JnL2VjbGlwc2UvanB0L2NvcmUvdGVzdHMvZXh0ZW5zaW9uL3Jlc291cmNlL1Rlc3RKYXZhQmFzaWNNYXBwaW5nLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3NyYy9vcmcvZWNsaXBzZS9qcHQvY29yZS90ZXN0cy9leHRlbnNpb24vcmVzb3VyY2UvVGVzdEphdmFCYXNpY01hcHBpbmcuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggY2NkMmY2YS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3NyYy9vcmcvZWNsaXBzZS9qcHQvY29yZS90ZXN0cy9leHRlbnNpb24vcmVzb3VyY2UvVGVzdEphdmFCYXNpY01hcHBpbmcuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDIwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2U7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LmphdmEuSmF2YVBlcnNpc3RlbnRBdHRyaWJ1dGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuaW50ZXJuYWwuY29udGV4dC5qYXZhLkdlbmVyaWNKYXZhQmFzaWNNYXBwaW5nOwotCi1wdWJsaWMgY2xhc3MgVGVzdEphdmFCYXNpY01hcHBpbmcgZXh0ZW5kcyBHZW5lcmljSmF2YUJhc2ljTWFwcGluZwotewotCXB1YmxpYyBUZXN0SmF2YUJhc2ljTWFwcGluZyhKYXZhUGVyc2lzdGVudEF0dHJpYnV0ZSBwYXJlbnQpIHsKLQkJc3VwZXIocGFyZW50KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3NyYy9vcmcvZWNsaXBzZS9qcHQvY29yZS90ZXN0cy9leHRlbnNpb24vcmVzb3VyY2UvVGVzdEphdmFFbnRpdHkuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2Uvc3JjL29yZy9lY2xpcHNlL2pwdC9jb3JlL3Rlc3RzL2V4dGVuc2lvbi9yZXNvdXJjZS9UZXN0SmF2YUVudGl0eS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1NWU4MjY1Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2Uvc3JjL29yZy9lY2xpcHNlL2pwdC9jb3JlL3Rlc3RzL2V4dGVuc2lvbi9yZXNvdXJjZS9UZXN0SmF2YUVudGl0eS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5KYXZhUGVyc2lzdGVudFR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuaW50ZXJuYWwuY29udGV4dC5qYXZhLkFic3RyYWN0SmF2YUVudGl0eTsKLQotcHVibGljIGNsYXNzIFRlc3RKYXZhRW50aXR5IGV4dGVuZHMgQWJzdHJhY3RKYXZhRW50aXR5Ci17Ci0JcHJvdGVjdGVkIFRlc3RKYXZhRW50aXR5KEphdmFQZXJzaXN0ZW50VHlwZSBwYXJlbnQpIHsKLQkJc3VwZXIocGFyZW50KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3NyYy9vcmcvZWNsaXBzZS9qcHQvY29yZS90ZXN0cy9leHRlbnNpb24vcmVzb3VyY2UvVGVzdEpwYUZhY3RvcnkuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2Uvc3JjL29yZy9lY2xpcHNlL2pwdC9jb3JlL3Rlc3RzL2V4dGVuc2lvbi9yZXNvdXJjZS9UZXN0SnBhRmFjdG9yeS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyMDNlNzUxLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2Uvc3JjL29yZy9lY2xpcHNlL2pwdC9jb3JlL3Rlc3RzL2V4dGVuc2lvbi9yZXNvdXJjZS9UZXN0SnBhRmFjdG9yeS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YKLSAqIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uIGFuZCBpcyBhdmFpbGFibGUgYXQKLSAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2U7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LmphdmEuSmF2YUJhc2ljTWFwcGluZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LmphdmEuSmF2YUVudGl0eTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LmphdmEuSmF2YVBlcnNpc3RlbnRBdHRyaWJ1dGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5qYXZhLkphdmFQZXJzaXN0ZW50VHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5pbnRlcm5hbC5wbGF0Zm9ybS5HZW5lcmljSnBhRmFjdG9yeTsKLQotcHVibGljIGNsYXNzIFRlc3RKcGFGYWN0b3J5IGV4dGVuZHMgR2VuZXJpY0pwYUZhY3RvcnkKLXsKLQlAT3ZlcnJpZGUKLQlwdWJsaWMgSmF2YUVudGl0eSBidWlsZEphdmFFbnRpdHkoSmF2YVBlcnNpc3RlbnRUeXBlIHBhcmVudCkgewotCQlyZXR1cm4gbmV3IFRlc3RKYXZhRW50aXR5KHBhcmVudCk7Ci0JfQotCQotCUBPdmVycmlkZQotCXB1YmxpYyBKYXZhQmFzaWNNYXBwaW5nIGJ1aWxkSmF2YUJhc2ljTWFwcGluZyhKYXZhUGVyc2lzdGVudEF0dHJpYnV0ZSBwYXJlbnQpIHsKLQkJcmV0dXJuIG5ldyBUZXN0SmF2YUJhc2ljTWFwcGluZyhwYXJlbnQpOwotCX0KLQkKLQlwdWJsaWMgSmF2YVRlc3RUeXBlTWFwcGluZyBidWlsZEphdmFUZXN0VHlwZU1hcHBpbmcoSmF2YVBlcnNpc3RlbnRUeXBlIHBhcmVudCkgewotCQlyZXR1cm4gbmV3IEphdmFUZXN0VHlwZU1hcHBpbmcocGFyZW50KTsKLQl9Ci0JCi0JcHVibGljIEphdmFUZXN0QXR0cmlidXRlTWFwcGluZyBidWlsZEphdmFUZXN0QXR0cmlidXRlTWFwcGluZyhKYXZhUGVyc2lzdGVudEF0dHJpYnV0ZSBwYXJlbnQpIHsKLQkJcmV0dXJuIG5ldyBKYXZhVGVzdEF0dHJpYnV0ZU1hcHBpbmcocGFyZW50KTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3NyYy9vcmcvZWNsaXBzZS9qcHQvY29yZS90ZXN0cy9leHRlbnNpb24vcmVzb3VyY2UvVGVzdEpwYVBsYXRmb3JtRmFjdG9yeS5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS9zcmMvb3JnL2VjbGlwc2UvanB0L2NvcmUvdGVzdHMvZXh0ZW5zaW9uL3Jlc291cmNlL1Rlc3RKcGFQbGF0Zm9ybUZhY3RvcnkuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzIxOWY0Yy4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3NyYy9vcmcvZWNsaXBzZS9qcHQvY29yZS90ZXN0cy9leHRlbnNpb24vcmVzb3VyY2UvVGVzdEpwYVBsYXRmb3JtRmFjdG9yeS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNjMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2U7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcGFBbm5vdGF0aW9uUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuSnBhRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcGFQbGF0Zm9ybTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcGFQbGF0Zm9ybUZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuSnBhVmFsaWRhdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5pbnRlcm5hbC5wbGF0Zm9ybS5HZW5lcmljSnBhQW5ub3RhdGlvbkRlZmluaXRpb25Qcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5pbnRlcm5hbC5wbGF0Zm9ybS5HZW5lcmljSnBhQW5ub3RhdGlvblByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmludGVybmFsLnBsYXRmb3JtLkdlbmVyaWNKcGFQbGF0Zm9ybTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5pbnRlcm5hbC5wbGF0Zm9ybS5HZW5lcmljSnBhUGxhdGZvcm1Qcm92aWRlcjsKLQotLyoqCi0gKiBBbGwgdGhlIHN0YXRlIGluIHRoZSBKUEEgcGxhdGZvcm0gc2hvdWxkIGJlICJzdGF0aWMiIChpLmUuIHVuY2hhbmdpbmcgb25jZQotICogaXQgaXMgaW5pdGlhbGl6ZWQpLgotICovCi1wdWJsaWMgY2xhc3MgVGVzdEpwYVBsYXRmb3JtRmFjdG9yeQotCWltcGxlbWVudHMgSnBhUGxhdGZvcm1GYWN0b3J5Ci17Ci0KLQkvKioKLQkgKiB6ZXJvLWFyZ3VtZW50IGNvbnN0cnVjdG9yCi0JICovCi0JcHVibGljIFRlc3RKcGFQbGF0Zm9ybUZhY3RvcnkoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCQotCXB1YmxpYyBKcGFQbGF0Zm9ybSBidWlsZEpwYVBsYXRmb3JtKFN0cmluZyBpZCkgewotCQlyZXR1cm4gbmV3IEdlbmVyaWNKcGFQbGF0Zm9ybSgKLQkJCWlkLAotCQkJYnVpbGRKcGFGYWN0b3J5KCksIAotCQkJYnVpbGRKcGFBbm5vdGF0aW9uUHJvdmlkZXIoKSwgCi0JCQlidWlsZEpwYVZhbGlkYXRpb24oKSwKLQkJCUdlbmVyaWNKcGFQbGF0Zm9ybVByb3ZpZGVyLmluc3RhbmNlKCksCi0JCQlUZXN0SnBhUGxhdGZvcm1Qcm92aWRlci5pbnN0YW5jZSgpKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIEpwYUZhY3RvcnkgYnVpbGRKcGFGYWN0b3J5KCkgewotCQlyZXR1cm4gbmV3IFRlc3RKcGFGYWN0b3J5KCk7Ci0JfQotCQotCXByb3RlY3RlZCBKcGFBbm5vdGF0aW9uUHJvdmlkZXIgYnVpbGRKcGFBbm5vdGF0aW9uUHJvdmlkZXIoKSB7Ci0JCXJldHVybiBuZXcgR2VuZXJpY0pwYUFubm90YXRpb25Qcm92aWRlcigKLQkJCUdlbmVyaWNKcGFBbm5vdGF0aW9uRGVmaW5pdGlvblByb3ZpZGVyLmluc3RhbmNlKCkpOwotCX0KLQkKLQlwcm90ZWN0ZWQgSnBhVmFsaWRhdGlvbiBidWlsZEpwYVZhbGlkYXRpb24oKSB7Ci0JCXJldHVybiBuZXcgSnBhVmFsaWRhdGlvbigpIHsKLQkJCXB1YmxpYyBTdXBwb3J0ZWQgZ2V0VGFibGVQZXJDb25jcmV0ZUNsYXNzSW5oZXJpdGFuY2VJc1N1cHBvcnRlZCgpIHsKLQkJCQlyZXR1cm4gU3VwcG9ydGVkLk1BWUJFOwotCQkJfQotCQl9OwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2Uvc3JjL29yZy9lY2xpcHNlL2pwdC9jb3JlL3Rlc3RzL2V4dGVuc2lvbi9yZXNvdXJjZS9UZXN0SnBhUGxhdGZvcm1Qcm92aWRlci5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS9zcmMvb3JnL2VjbGlwc2UvanB0L2NvcmUvdGVzdHMvZXh0ZW5zaW9uL3Jlc291cmNlL1Rlc3RKcGFQbGF0Zm9ybVByb3ZpZGVyLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDYzODBlOGQuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmV4dGVuc2lvbi5yZXNvdXJjZS9zcmMvb3JnL2VjbGlwc2UvanB0L2NvcmUvdGVzdHMvZXh0ZW5zaW9uL3Jlc291cmNlL1Rlc3RKcGFQbGF0Zm9ybVByb3ZpZGVyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw3OSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlOwotCi1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuSnBhUGxhdGZvcm1Qcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcGFSZXNvdXJjZU1vZGVsUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5NYXBwaW5nRmlsZVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQuamF2YS5EZWZhdWx0SmF2YUF0dHJpYnV0ZU1hcHBpbmdQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LmphdmEuSmF2YUF0dHJpYnV0ZU1hcHBpbmdQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5jb250ZXh0LmphdmEuSmF2YVR5cGVNYXBwaW5nUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuY29udGV4dC5vcm0uT3JtQXR0cmlidXRlTWFwcGluZ1Byb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmNvbnRleHQub3JtLk9ybVR5cGVNYXBwaW5nUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUuaW50ZXJuYWwucGxhdGZvcm0uQWJzdHJhY3RKcGFQbGF0Zm9ybVByb3ZpZGVyOwotCi1wdWJsaWMgY2xhc3MgVGVzdEpwYVBsYXRmb3JtUHJvdmlkZXIgZXh0ZW5kcyBBYnN0cmFjdEpwYVBsYXRmb3JtUHJvdmlkZXIKLXsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBJRCA9ICJjb3JlLnRlc3RKcGFQbGF0Zm9ybSI7IC8vJE5PTi1OTFMtMSQKLQotCS8vIHNpbmdsZXRvbgotCXByaXZhdGUgc3RhdGljIGZpbmFsIEpwYVBsYXRmb3JtUHJvdmlkZXIgSU5TVEFOQ0UgPSBuZXcgVGVzdEpwYVBsYXRmb3JtUHJvdmlkZXIoKTsKLQotCS8qKgotCSAqIFJldHVybiB0aGUgc2luZ2xldG9uLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgSnBhUGxhdGZvcm1Qcm92aWRlciBpbnN0YW5jZSgpIHsKLQkJcmV0dXJuIElOU1RBTkNFOwotCX0KLQotCS8qKgotCSAqIEVuc3VyZSBzaW5nbGUgaW5zdGFuY2UuCi0JICovCi0JcHJpdmF0ZSBUZXN0SnBhUGxhdGZvcm1Qcm92aWRlcigpIHsKLQkJc3VwZXIoKTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgYWRkSmF2YVR5cGVNYXBwaW5nUHJvdmlkZXJzVG8oTGlzdDxKYXZhVHlwZU1hcHBpbmdQcm92aWRlcj4gcHJvdmlkZXJzKSB7Ci0JCXByb3ZpZGVycy5hZGQoSmF2YVRlc3RUeXBlTWFwcGluZ1Byb3ZpZGVyLmluc3RhbmNlKCkpOwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBhZGRKYXZhQXR0cmlidXRlTWFwcGluZ1Byb3ZpZGVyc1RvKExpc3Q8SmF2YUF0dHJpYnV0ZU1hcHBpbmdQcm92aWRlcj4gcHJvdmlkZXJzKSB7Ci0JCXByb3ZpZGVycy5hZGQoSmF2YVRlc3RBdHRyaWJ1dGVNYXBwaW5nUHJvdmlkZXIuaW5zdGFuY2UoKSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgYWRkTWFwcGluZ0ZpbGVQcm92aWRlcnNUbyhMaXN0PE1hcHBpbmdGaWxlUHJvdmlkZXI+IHByb3ZpZGVycykgewotCQkvL25vbmUKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBhZGREZWZhdWx0SmF2YUF0dHJpYnV0ZU1hcHBpbmdQcm92aWRlcnNUbyhMaXN0PERlZmF1bHRKYXZhQXR0cmlidXRlTWFwcGluZ1Byb3ZpZGVyPiBwcm92aWRlcnMpIHsKLQkJLy9ub25lCi0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgYWRkT3JtQXR0cmlidXRlTWFwcGluZ1Byb3ZpZGVyc1RvKExpc3Q8T3JtQXR0cmlidXRlTWFwcGluZ1Byb3ZpZGVyPiBwcm92aWRlcnMpIHsKLQkJLy9ub25lCi0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgYWRkT3JtVHlwZU1hcHBpbmdQcm92aWRlcnNUbyhMaXN0PE9ybVR5cGVNYXBwaW5nUHJvdmlkZXI+IHByb3ZpZGVycykgewotCQkvL25vbmUKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBhZGRSZXNvdXJjZU1vZGVsUHJvdmlkZXJzVG8oTGlzdDxKcGFSZXNvdXJjZU1vZGVsUHJvdmlkZXI+IHByb3ZpZGVycykgewotCQkvL25vbmUKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2Uvc3JjL29yZy9lY2xpcHNlL2pwdC9jb3JlL3Rlc3RzL2V4dGVuc2lvbi9yZXNvdXJjZS9UZXN0SnBhUGxhdGZvcm1VaUZhY3RvcnkuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2Uvc3JjL29yZy9lY2xpcHNlL2pwdC9jb3JlL3Rlc3RzL2V4dGVuc2lvbi9yZXNvdXJjZS9UZXN0SnBhUGxhdGZvcm1VaUZhY3RvcnkuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWNhODU1NS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3NyYy9vcmcvZWNsaXBzZS9qcHQvY29yZS90ZXN0cy9leHRlbnNpb24vcmVzb3VyY2UvVGVzdEpwYVBsYXRmb3JtVWlGYWN0b3J5LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVBsYXRmb3JtVWk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVBsYXRmb3JtVWlGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5wbGF0Zm9ybS5nZW5lcmljLkdlbmVyaWNKcGFQbGF0Zm9ybVVpOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5wbGF0Zm9ybS5nZW5lcmljLkdlbmVyaWNOYXZpZ2F0b3JQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuc3RydWN0dXJlLkphdmFSZXNvdXJjZU1vZGVsU3RydWN0dXJlUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnN0cnVjdHVyZS5QZXJzaXN0ZW5jZVJlc291cmNlTW9kZWxTdHJ1Y3R1cmVQcm92aWRlcjsKLQotcHVibGljIGNsYXNzIFRlc3RKcGFQbGF0Zm9ybVVpRmFjdG9yeSBpbXBsZW1lbnRzIEpwYVBsYXRmb3JtVWlGYWN0b3J5Ci17Ci0KLQkvKioKLQkgKiBaZXJvIGFyZyBjb25zdHJ1Y3RvciBmb3IgZXh0ZW5zaW9uIHBvaW50Ci0JICovCi0JcHVibGljIFRlc3RKcGFQbGF0Zm9ybVVpRmFjdG9yeSgpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQlwdWJsaWMgSnBhUGxhdGZvcm1VaSBidWlsZEpwYVBsYXRmb3JtVWkoKSB7Ci0JCXJldHVybiBuZXcgR2VuZXJpY0pwYVBsYXRmb3JtVWkoCi0JCQluZXcgVGVzdEpwYVVpRmFjdG9yeSgpLAotCQkJbmV3IEdlbmVyaWNOYXZpZ2F0b3JQcm92aWRlcigpLAotCQkJSmF2YVJlc291cmNlTW9kZWxTdHJ1Y3R1cmVQcm92aWRlci5pbnN0YW5jZSgpLCAKLQkJCVBlcnNpc3RlbmNlUmVzb3VyY2VNb2RlbFN0cnVjdHVyZVByb3ZpZGVyLmluc3RhbmNlKCkpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2Uvc3JjL29yZy9lY2xpcHNlL2pwdC9jb3JlL3Rlc3RzL2V4dGVuc2lvbi9yZXNvdXJjZS9UZXN0SnBhVWlGYWN0b3J5LmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlL3NyYy9vcmcvZWNsaXBzZS9qcHQvY29yZS90ZXN0cy9leHRlbnNpb24vcmVzb3VyY2UvVGVzdEpwYVVpRmFjdG9yeS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiZmQ3N2YyLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2Uvc3JjL29yZy9lY2xpcHNlL2pwdC9jb3JlL3Rlc3RzL2V4dGVuc2lvbi9yZXNvdXJjZS9UZXN0SnBhVWlGYWN0b3J5LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyNyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLkpwYVVpRmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuQmFzZUpwYVVpRmFjdG9yeTsKLQotLyoqCi0gKiBUaGUgZGVmYXVsdCBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgVUkgZmFjdG9yeSByZXF1aXJlZCB0byBzaG93IHRoZSBpbmZvcm1hdGlvbgotICogcmVsYXRlZCB0byBhIEpQQSBtYXBwaW5nICh0eXBlIG9yIGF0dHJpYnV0ZSkuCi0gKgotICogQHNlZSBKcGFVaUZhY3RvcnkKLSAqCi0gKiBAdmVyc2lvbiAxLjAKLSAqIEBzaW5jZSAxLjAKLSAqLwotcHVibGljIGNsYXNzIFRlc3RKcGFVaUZhY3RvcnkgZXh0ZW5kcyBCYXNlSnBhVWlGYWN0b3J5Ci17Ci0KLX0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzLy5jbGFzc3BhdGggYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzLy5jbGFzc3BhdGgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVmOGQ5MWMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy8uY2xhc3NwYXRoCisrKyAvZGV2L251bGwKQEAgLTEsMTEgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxjbGFzc3BhdGg+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9InNyYyIgcGF0aD0ic3JjIi8+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9ImNvbiIgcGF0aD0ib3JnLmVjbGlwc2UuamR0LmxhdW5jaGluZy5KUkVfQ09OVEFJTkVSL29yZy5lY2xpcHNlLmpkdC5pbnRlcm5hbC5kZWJ1Zy51aS5sYXVuY2hlci5TdGFuZGFyZFZNVHlwZS9KMlNFLTEuNSIvPgotCTxjbGFzc3BhdGhlbnRyeSBraW5kPSJjb24iIHBhdGg9Im9yZy5lY2xpcHNlLnBkZS5jb3JlLnJlcXVpcmVkUGx1Z2lucyI+Ci0JCTxhY2Nlc3NydWxlcz4KLQkJCTxhY2Nlc3NydWxlIGtpbmQ9ImFjY2Vzc2libGUiIHBhdHRlcm49Im9yZy9lY2xpcHNlL2pwdC91dGlsaXR5LyoqIi8+Ci0JCTwvYWNjZXNzcnVsZXM+Ci0JPC9jbGFzc3BhdGhlbnRyeT4KLQk8Y2xhc3NwYXRoZW50cnkga2luZD0ib3V0cHV0IiBwYXRoPSJiaW4iLz4KLTwvY2xhc3NwYXRoPgpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy8uY3ZzaWdub3JlIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy8uY3ZzaWdub3JlCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiYTA3N2E0Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvLmN2c2lnbm9yZQorKysgL2Rldi9udWxsCkBAIC0xICswLDAgQEAKLWJpbgpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy8ucHJvamVjdCBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvLnByb2plY3QKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGY1YjAxMjcuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy8ucHJvamVjdAorKysgL2Rldi9udWxsCkBAIC0xLDI4ICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08cHJvamVjdERlc2NyaXB0aW9uPgotCTxuYW1lPm9yZy5lY2xpcHNlLmpwdC5kYi50ZXN0czwvbmFtZT4KLQk8Y29tbWVudD48L2NvbW1lbnQ+Ci0JPHByb2plY3RzPgotCTwvcHJvamVjdHM+Ci0JPGJ1aWxkU3BlYz4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLmpkdC5jb3JlLmphdmFidWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5NYW5pZmVzdEJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLlNjaGVtYUJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCTwvYnVpbGRTcGVjPgotCTxuYXR1cmVzPgotCQk8bmF0dXJlPm9yZy5lY2xpcHNlLnBkZS5QbHVnaW5OYXR1cmU8L25hdHVyZT4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5qZHQuY29yZS5qYXZhbmF0dXJlPC9uYXR1cmU+Ci0JPC9uYXR1cmVzPgotPC9wcm9qZWN0RGVzY3JpcHRpb24+CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcyBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiMjNkMGM3Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzCisrKyAvZGV2L251bGwKQEAgLTEsMyArMCwwIEBACi0jVHVlIEphbiAxNSAxMToxMToxMSBFU1QgMjAwOAotZWNsaXBzZS5wcmVmZXJlbmNlcy52ZXJzaW9uPTEKLWVuY29kaW5nLzxwcm9qZWN0Pj1JU08tODg1OS0xCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL01FVEEtSU5GL01BTklGRVNULk1GIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9NRVRBLUlORi9NQU5JRkVTVC5NRgpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNWJmMjQ1NS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL01FVEEtSU5GL01BTklGRVNULk1GCisrKyAvZGV2L251bGwKQEAgLTEsMjAgKzAsMCBAQAotTWFuaWZlc3QtVmVyc2lvbjogMS4wCi1CdW5kbGUtTWFuaWZlc3RWZXJzaW9uOiAyCi1CdW5kbGUtTmFtZTogJXBsdWdpbk5hbWUKLUJ1bmRsZS1WZW5kb3I6ICVwcm92aWRlck5hbWUKLUJ1bmRsZS1TeW1ib2xpY05hbWU6IG9yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cwotQnVuZGxlLVZlcnNpb246IDEuMC4xMDAucXVhbGlmaWVyCi1CdW5kbGUtQWN0aXZhdG9yOiBvcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMuaW50ZXJuYWwuSnB0RGJUZXN0c1BsdWdpbgotQnVuZGxlLUFjdGl2YXRpb25Qb2xpY3k6IGxhenkKLUJ1bmRsZS1Mb2NhbGl6YXRpb246IHBsdWdpbgotQnVuZGxlLVJlcXVpcmVkRXhlY3V0aW9uRW52aXJvbm1lbnQ6IEoyU0UtMS41Ci1SZXF1aXJlLUJ1bmRsZTogb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lO2J1bmRsZS12ZXJzaW9uPSJbMy40LjAsNC4wLjApIiwKLSBvcmcuanVuaXQ7YnVuZGxlLXZlcnNpb249IlszLjguMiw0LjAuMCkiLAotIG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHk7YnVuZGxlLXZlcnNpb249IlsxLjEuMCwxLjIuMCkiLAotIG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuZGIuZ2VuZXJpYztidW5kbGUtdmVyc2lvbj0iWzEuMC4wLDEuMi4wKSIsCi0gb3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5zcW0uY29yZTtidW5kbGUtdmVyc2lvbj0iMS4wLjEiLAotIG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsO2J1bmRsZS12ZXJzaW9uPSIxLjAuMCIsCi0gb3JnLmVjbGlwc2UuanB0LnV0aWxpdHk7YnVuZGxlLXZlcnNpb249IlsxLjIuMCwyLjAuMCkiLAotIG9yZy5lY2xpcHNlLmpwdC5kYjtidW5kbGUtdmVyc2lvbj0iWzEuMi4wLDIuMC4wKSIKLUV4cG9ydC1QYWNrYWdlOiBvcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMuaW50ZXJuYWw7eC1pbnRlcm5hbDo9dHJ1ZSwKLSBvcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMuaW50ZXJuYWwucGxhdGZvcm1zO3gtaW50ZXJuYWw6PXRydWUKZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvYWJvdXQuaHRtbCBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvYWJvdXQuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmU1MzRiYS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL2Fib3V0Lmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSwzNCArMCwwIEBACi08IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wLy9FTiI+Ci08SFRNTD4KLQotPGhlYWQ+Ci08dGl0bGU+QWJvdXQ8L3RpdGxlPgotPG1ldGEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiPgotPC9oZWFkPgotCi08Qk9EWSBsYW5nPSJFTi1VUyI+Ci0KLTxIMz5BYm91dCBUaGlzIENvbnRlbnQ8L0gzPgotCi08UD5NYXkgMDIsIDIwMDg8L1A+Ci0KLTxIMz5MaWNlbnNlPC9IMz4KLQotPFA+VGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYWtlcyBhdmFpbGFibGUgYWxsIGNvbnRlbnQgaW4gdGhpcyBwbHVnLWluIAotKCJDb250ZW50IikuIFVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkIGJlbG93LCB0aGUgQ29udGVudCBpcyBwcm92aWRlZCB0byB5b3UgCi11bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgCi0oIkVQTCIpLiBBIGNvcHkgb2YgdGhlIEVQTCBpcyBhdmFpbGFibGUgYXQKLTxBIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvb3JnL2RvY3VtZW50cy9lcGwtdjEwLnBocCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9vcmcvZG9jdW1lbnRzL2VwbC12MTAucGhwPC9BPi4gCi1Gb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC48L1A+Ci0KLTxQPklmIHlvdSBkaWQgbm90IHJlY2VpdmUgdGhpcyBDb250ZW50IGRpcmVjdGx5IGZyb20gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiwgdGhlIAotQ29udGVudCBpcyBiZWluZyByZWRpc3RyaWJ1dGVkIGJ5IGFub3RoZXIgcGFydHkgKCJSZWRpc3RyaWJ1dG9yIikgYW5kIGRpZmZlcmVudCAKLXRlcm1zIGFuZCBjb25kaXRpb25zIG1heSBhcHBseSB0byB5b3VyIHVzZSBvZiBhbnkgb2JqZWN0IGNvZGUgaW4gdGhlIENvbnRlbnQuIAotQ2hlY2sgdGhlIFJlZGlzdHJpYnV0b3IncyBsaWNlbnNlIHRoYXQgd2FzIHByb3ZpZGVkIHdpdGggdGhlIENvbnRlbnQuIElmIG5vIHN1Y2ggCi1saWNlbnNlIGV4aXN0cywgY29udGFjdCB0aGUgUmVkaXN0cmlidXRvci4gVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQgYmVsb3csIHRoZSAKLXRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFUEwgc3RpbGwgYXBwbHkgdG8gYW55IHNvdXJjZSBjb2RlIGluIHRoZSBDb250ZW50IAotYW5kIHN1Y2ggc291cmNlIGNvZGUgbWF5IGJlIG9idGFpbmVkIGF0Ci08QSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnLyI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy88L0E+LjwvUD4KLQotPC9CT0RZPgotPC9IVE1MPgpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9idWlsZC5wcm9wZXJ0aWVzIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9idWlsZC5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjZDBkMDEwLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvYnVpbGQucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDE1ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgIENvcHlyaWdodCAoYykgMjAwNyBPcmFjbGUuIAotIyAgQWxsIHJpZ2h0cyByZXNlcnZlZC4gIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgCi0jICBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgCi0jICB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAKLSMgIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCi0jICAKLSMgIENvbnRyaWJ1dG9yczogCi0jICAJT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi1zb3VyY2UuLiA9IHNyYy8KLW91dHB1dC4uID0gYmluLwotYmluLmluY2x1ZGVzID0gLixcCi0gICAgICAgICAgICAgICBNRVRBLUlORi8sXAotICAgICAgICAgICAgICAgcGx1Z2luLnByb3BlcnRpZXMKZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvY29uZmlnL2RlcmJ5LnByb3BlcnRpZXMgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL2NvbmZpZy9kZXJieS5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyNDJkMTU2Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvY29uZmlnL2RlcmJ5LnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwyNCArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotIyBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSMgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSMgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotIyBDb25maWd1cmUgdGhlIHdvcmtzcGFjZS0gYW5kIGRhdGFiYXNlIHNlcnZlci1zcGVjaWZpYyBzZXR0aW5ncyBoZXJlLgotCi0jIHVzZXIgYW5kIHBhc3N3b3JkIGFyZSBvcHRpb25hbCBmb3IgRGVyYnkKLXVzZXJJRCA9IAotcGFzc3dvcmQgPSAKLQotIyB0aGUgSkRCQyBkcml2ZXIgSkFSKHMpIG11c3QgYmUgc3BlY2lmaWVkOwotIyBpZiB0aGVyZSBhcmUgbXVsdGlwbGUgSkFScywgc2VwYXJhdGUgdGhlIG5hbWVzIHdpdGggY29tbWFzCi0jIGphcnMgPSBDOi9kZXJieS9saWIvZGVyYnkuamFyCi1qYXJzID0gCi0KLSMgdGhlIEpEQkMgVVJMIGlzIHJlcXVpcmVkIGZvciBEZXJieQotIyB1cmwgPSBqZGJjOmRlcmJ5OkM6L2RlcmJ5L2RhdGEvdGVzdGRiO2NyZWF0ZT10cnVlCi11cmwgPSAKZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvY29uZmlnL215c3FsLnByb3BlcnRpZXMgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL2NvbmZpZy9teXNxbC5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkNjQwN2RlLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvY29uZmlnL215c3FsLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwyMyArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotIyBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSMgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSMgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotIyBDb25maWd1cmUgdGhlIHdvcmtzcGFjZS0gYW5kIGRhdGFiYXNlIHNlcnZlci1zcGVjaWZpYyBzZXR0aW5ncyBoZXJlLgotCi0jIHVzZXIgYW5kIHBhc3N3b3JkIGFyZSBvcHRpb25hbCwgZGVwZW5kaW5nIG9uIHRoZSBwbGF0Zm9ybQotdXNlcklEID0gCi1wYXNzd29yZCA9IAotCi0jIHRoZSBKREJDIGRyaXZlciBKQVIocykgbXVzdCBiZSBzcGVjaWZpZWQ7Ci0jIGlmIHRoZXJlIGFyZSBtdWx0aXBsZSBKQVJzLCBzZXBhcmF0ZSB0aGUgbmFtZXMgd2l0aCBjb21tYXMKLSMgamFycyA9IEM6L215c3FsL215c3FsLWNvbm5lY3Rvci1qYXZhLTUuMC42LWJpbi5qYXIKLWphcnMgPSAKLQotIyB0aGUgSkRCQyBVUkwgaXMgb3B0aW9uYWwgZm9yIE15U1FMCi0jIHVybCA9IGpkYmM6bXlzcWw6Ly9sb2NhbGhvc3Q6MzMwNgpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9jb25maWcvb3JhY2xlMTBnLnByb3BlcnRpZXMgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL2NvbmZpZy9vcmFjbGUxMGcucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNGI5MTFiNC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL2NvbmZpZy9vcmFjbGUxMGcucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDI0ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0jIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotIyB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotIyBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotCi0jIENvbmZpZ3VyZSB0aGUgd29ya3NwYWNlLSBhbmQgZGF0YWJhc2Ugc2VydmVyLXNwZWNpZmljIHNldHRpbmdzIGhlcmUuCi0KLSMgdXNlciBhbmQgcGFzc3dvcmQgYXJlIG9wdGlvbmFsLCBkZXBlbmRpbmcgb24gdGhlIHBsYXRmb3JtCi11c2VySUQgPSBzY290dAotcGFzc3dvcmQgPSB0aWdlcgotCi0jIHRoZSBKREJDIGRyaXZlciBKQVIocykgbXVzdCBiZSBzcGVjaWZpZWQ7Ci0jIGlmIHRoZXJlIGFyZSBtdWx0aXBsZSBKQVJzLCBzZXBhcmF0ZSB0aGUgbmFtZXMgd2l0aCBjb21tYXMKLSMgamFycyA9IEM6L29yYWNsZS9qZGJjL2xpYi9vamRiYzUuamFyCi1qYXJzID0gCi0KLSMgdGhlIEpEQkMgVVJMIGlzIHJlcXVpcmVkCi0jIHVybCA9IGpkYmM6b3JhY2xlOnRoaW46QGxvY2FsaG9zdDoxNTIxOnRlc3RkYgotdXJsID0gCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL2NvbmZpZy9vcmFjbGUxMGdYRS5wcm9wZXJ0aWVzIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9jb25maWcvb3JhY2xlMTBnWEUucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTY3YzAxYS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL2NvbmZpZy9vcmFjbGUxMGdYRS5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMjQgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSMgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0jIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0jIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0KLSMgQ29uZmlndXJlIHRoZSB3b3Jrc3BhY2UtIGFuZCBkYXRhYmFzZSBzZXJ2ZXItc3BlY2lmaWMgc2V0dGluZ3MgaGVyZS4KLQotIyB1c2VyIGFuZCBwYXNzd29yZCBhcmUgb3B0aW9uYWwsIGRlcGVuZGluZyBvbiB0aGUgcGxhdGZvcm0KLXVzZXJJRCA9IHNjb3R0Ci1wYXNzd29yZCA9IHRpZ2VyCi0KLSMgdGhlIEpEQkMgZHJpdmVyIEpBUihzKSBtdXN0IGJlIHNwZWNpZmllZDsKLSMgaWYgdGhlcmUgYXJlIG11bHRpcGxlIEpBUnMsIHNlcGFyYXRlIHRoZSBuYW1lcyB3aXRoIGNvbW1hcwotIyBqYXJzID0gQzovb3JhY2xlL2pkYmMvbGliL29qZGJjNS5qYXIKLWphcnMgPSAKLQotIyB0aGUgSkRCQyBVUkwgaXMgcmVxdWlyZWQKLSMgdXJsID0gamRiYzpvcmFjbGU6dGhpbjpAbG9jYWxob3N0OjE1MjE6WEUKLXVybCA9IApkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9jb25maWcvb3JhY2xlOWkucHJvcGVydGllcyBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvY29uZmlnL29yYWNsZTlpLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDRiOTExYjQuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9jb25maWcvb3JhY2xlOWkucHJvcGVydGllcworKysgL2Rldi9udWxsCkBAIC0xLDI0ICswLDAgQEAKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0jIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotIyB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotIyBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotIyAKLSMgQ29udHJpYnV0b3JzOgotIyAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotCi0jIENvbmZpZ3VyZSB0aGUgd29ya3NwYWNlLSBhbmQgZGF0YWJhc2Ugc2VydmVyLXNwZWNpZmljIHNldHRpbmdzIGhlcmUuCi0KLSMgdXNlciBhbmQgcGFzc3dvcmQgYXJlIG9wdGlvbmFsLCBkZXBlbmRpbmcgb24gdGhlIHBsYXRmb3JtCi11c2VySUQgPSBzY290dAotcGFzc3dvcmQgPSB0aWdlcgotCi0jIHRoZSBKREJDIGRyaXZlciBKQVIocykgbXVzdCBiZSBzcGVjaWZpZWQ7Ci0jIGlmIHRoZXJlIGFyZSBtdWx0aXBsZSBKQVJzLCBzZXBhcmF0ZSB0aGUgbmFtZXMgd2l0aCBjb21tYXMKLSMgamFycyA9IEM6L29yYWNsZS9qZGJjL2xpYi9vamRiYzUuamFyCi1qYXJzID0gCi0KLSMgdGhlIEpEQkMgVVJMIGlzIHJlcXVpcmVkCi0jIHVybCA9IGpkYmM6b3JhY2xlOnRoaW46QGxvY2FsaG9zdDoxNTIxOnRlc3RkYgotdXJsID0gCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL2NvbmZpZy9wb3N0Z3Jlc3FsLnByb3BlcnRpZXMgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL2NvbmZpZy9wb3N0Z3Jlc3FsLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDMyZmFmZTQuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9jb25maWcvcG9zdGdyZXNxbC5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMjMgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSMgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0jIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0jIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0KLSMgQ29uZmlndXJlIHRoZSB3b3Jrc3BhY2UtIGFuZCBkYXRhYmFzZSBzZXJ2ZXItc3BlY2lmaWMgc2V0dGluZ3MgaGVyZS4KLQotIyB1c2VyIGFuZCBwYXNzd29yZCBhcmUgb3B0aW9uYWwsIGRlcGVuZGluZyBvbiB0aGUgcGxhdGZvcm0KLXVzZXJJRCA9IAotcGFzc3dvcmQgPSAKLQotIyB0aGUgSkRCQyBkcml2ZXIgSkFSKHMpIG11c3QgYmUgc3BlY2lmaWVkOwotIyBpZiB0aGVyZSBhcmUgbXVsdGlwbGUgSkFScywgc2VwYXJhdGUgdGhlIG5hbWVzIHdpdGggY29tbWFzCi0jIGphcnMgPSBDOi9wb3N0Z3Jlc3FsL2pkYmMvcG9zdGdyZXNxbC04LjItNTA1LmpkYmMzLmphcgotamFycyA9IAotCi0jIHRoZSBKREJDIFVSTCBpcyBvcHRpb25hbCBmb3IgUG9zdGdyZVNRTAotIyB1cmwgPSBqZGJjOnBvc3RncmVzcWwKZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvY29uZmlnL3NxbHNlcnZlci5wcm9wZXJ0aWVzIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9jb25maWcvc3Fsc2VydmVyLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGY3MmI2NDUuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9jb25maWcvc3Fsc2VydmVyLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwyNCArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotIyBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSMgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSMgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotIyBDb25maWd1cmUgdGhlIHdvcmtzcGFjZS0gYW5kIGRhdGFiYXNlIHNlcnZlci1zcGVjaWZpYyBzZXR0aW5ncyBoZXJlLgotCi0jIHVzZXIgYW5kIHBhc3N3b3JkIGFyZSBvcHRpb25hbCwgZGVwZW5kaW5nIG9uIHRoZSBwbGF0Zm9ybQotdXNlcklEID0gCi1wYXNzd29yZCA9IAotCi0jIHRoZSBKREJDIGRyaXZlciBKQVIocykgbXVzdCBiZSBzcGVjaWZpZWQ7Ci0jIGlmIHRoZXJlIGFyZSBtdWx0aXBsZSBKQVJzLCBzZXBhcmF0ZSB0aGUgbmFtZXMgd2l0aCBjb21tYXMKLSMgamFycyA9IEM6L3NxbHNlcnZlci9saWIvc3FsamRiYy5qYXIKLWphcnMgPSAKLQotIyB0aGUgSkRCQyBVUkwgaXMgcmVxdWlyZWQKLSMgdXJsID0gamRiYzpzcWxzZXJ2ZXI6Ly9sb2NhbGhvc3Q6MTQzMwotdXJsID0gCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL2NvbmZpZy9zeWJhc2UucHJvcGVydGllcyBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvY29uZmlnL3N5YmFzZS5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0OTNkNWQ0Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvY29uZmlnL3N5YmFzZS5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMjQgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSMgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0jIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0jIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0KLSMgQ29uZmlndXJlIHRoZSB3b3Jrc3BhY2UtIGFuZCBkYXRhYmFzZSBzZXJ2ZXItc3BlY2lmaWMgc2V0dGluZ3MgaGVyZS4KLQotIyB1c2VyIGFuZCBwYXNzd29yZCBhcmUgb3B0aW9uYWwsIGRlcGVuZGluZyBvbiB0aGUgcGxhdGZvcm0KLXVzZXJJRCA9IAotcGFzc3dvcmQgPSAKLQotIyB0aGUgSkRCQyBkcml2ZXIgSkFSKHMpIG11c3QgYmUgc3BlY2lmaWVkOwotIyBpZiB0aGVyZSBhcmUgbXVsdGlwbGUgSkFScywgc2VwYXJhdGUgdGhlIG5hbWVzIHdpdGggY29tbWFzCi0jIGphcnMgPSBDOi9zeWJhc2UvbGliL2pjb25uMy5qYXIKLWphcnMgPSAKLQotIyB0aGUgSkRCQyBVUkwgaXMgcmVxdWlyZWQKLSMgdXJsID0gamRiYzpzeWJhc2U6VGRzOmxvY2FsaG9zdDo1MDAwCi11cmwgPSAKZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvcGx1Z2luLnByb3BlcnRpZXMgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3BsdWdpbi5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiMDRmZTI3Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvcGx1Z2luLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwyNSArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jICBDb3B5cmlnaHQgKGMpIDIwMDcgT3JhY2xlLiAKLSMgIEFsbCByaWdodHMgcmVzZXJ2ZWQuICBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIAotIyAgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIAotIyAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgCi0jICBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotIyAgCi0jICBDb250cmlidXRvcnM6IAotIyAgCU9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotIyBUbyBjb2RlIGRldmVsb3BlcjoKLSMgICBEbyBOT1QgY2hhbmdlIHRoZSBwcm9wZXJ0aWVzIGJldHdlZW4gdGhpcyBsaW5lIGFuZCB0aGUKLSMgICAiJSUlIEVORCBPRiBUUkFOU0xBVEVEIFBST1BFUlRJRVMgJSUlIiBsaW5lLgotIyAgIE1ha2UgYSBuZXcgcHJvcGVydHkgbmFtZSwgYXBwZW5kIHRvIHRoZSBlbmQgb2YgdGhlIGZpbGUgYW5kIGNoYW5nZQotIyAgIHRoZSBjb2RlIHRvIHVzZSB0aGUgbmV3IHByb3BlcnR5LgotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0jICUlJSBFTkQgT0YgVFJBTlNMQVRFRCBQUk9QRVJUSUVTICUlJQotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotCi1wbHVnaW5OYW1lID0gSlBBIERCIFRlc3RzCi1wcm92aWRlck5hbWUgPSBFY2xpcHNlLm9yZwotCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvSkRCQ1Rlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvSkRCQ1Rlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGNlMDVkNzYuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3Rlc3RzL2ludGVybmFsL0pEQkNUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTM1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzLmludGVybmFsOwotCi1pbXBvcnQgamF2YS5zcWwuQ29ubmVjdGlvbjsKLWltcG9ydCBqYXZhLnNxbC5Ecml2ZXJNYW5hZ2VyOwotCi1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotCi0vKioKLSAqIFRoZXNlIGFyZW4ndCB0ZXN0cy4gVGhleSBhcmUganVzdCBhbiBlYXN5IHdheSB0byBkdW1wIEpEQkMgbWV0YWRhdGEgdG8gdGhlCi0gKiBjb25zb2xlLgotICovCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBKREJDVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQlwdWJsaWMgSkRCQ1Rlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3REZXJieSgpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmR1bXBNZXRhRGF0YShERVJCWSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE15U1FMKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuZHVtcE1ldGFEYXRhKE1ZU1FMKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0T3JhY2xlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuZHVtcE1ldGFEYXRhKE9SQUNMRSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFBvc3RncmVTUUwoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5kdW1wTWV0YURhdGEoUE9TVEdSRVNRTCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFN5YmFzZSgpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmR1bXBNZXRhRGF0YShTWUJBU0UpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGR1bXBNZXRhRGF0YShDb25uZWN0aW9uQ29uZmlnIGNvbmZpZykgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVN5c3RlbS5vdXQucHJpbnRsbigiKioqKiogUExBVEZPUk06ICIgKyBjb25maWcucGxhdGZvcm1OYW1lICsgIiAqKioqKiIpOwotCQlTeXN0ZW0ub3V0LnByaW50bG4oKTsKLQkJQ2xhc3MuZm9yTmFtZShjb25maWcuZHJpdmVyQ2xhc3NOYW1lKTsKLQkJQ29ubmVjdGlvbiBjb25uZWN0aW9uID0gRHJpdmVyTWFuYWdlci5nZXRDb25uZWN0aW9uKHRoaXMuYnVpbGRVUkwoY29uZmlnKSwgY29uZmlnLnVzZXIsIGNvbmZpZy5wYXNzd29yZCk7Ci0JCVN5c3RlbS5vdXQucHJpbnRsbigiQ0FUQUxPR1M6Iik7Ci0JCUpEQkNUb29scy5kdW1wKGNvbm5lY3Rpb24uZ2V0TWV0YURhdGEoKS5nZXRDYXRhbG9ncygpKTsKLQkJU3lzdGVtLm91dC5wcmludGxuKCk7Ci0JCVN5c3RlbS5vdXQucHJpbnRsbigiU0NIRU1BVEE6Iik7Ci0JCUpEQkNUb29scy5kdW1wKGNvbm5lY3Rpb24uZ2V0TWV0YURhdGEoKS5nZXRTY2hlbWFzKCkpOwotCQljb25uZWN0aW9uLmNsb3NlKCk7Ci0JCVN5c3RlbS5vdXQucHJpbnRsbigpOwotCX0KLQotCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRVUkwoQ29ubmVjdGlvbkNvbmZpZyBjb25maWcpIHsKLQkJcmV0dXJuICJqZGJjOiIgKyBjb25maWcuZGF0YWJhc2VVUkw7Ci0JfQotCi0JcHJvdGVjdGVkIHN0YXRpYyBmaW5hbCBDb25uZWN0aW9uQ29uZmlnIERFUkJZID0KLQkJbmV3IENvbm5lY3Rpb25Db25maWcoCi0JCQkiRGVyYnkiLAotCQkJIm9yZy5hcGFjaGUuZGVyYnkuamRiYy5FbWJlZGRlZERyaXZlciIsCi0JCQkiZGVyYnk6QzovZGVyYnkvZGF0YS90ZXN0IiwKLQkJCW51bGwsCi0JCQludWxsCi0JCSk7Ci0KLQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIENvbm5lY3Rpb25Db25maWcgTVlTUUwgPQotCQluZXcgQ29ubmVjdGlvbkNvbmZpZygKLQkJCSJNeVNRTCIsCi0JCQkiY29tLm15c3FsLmpkYmMuRHJpdmVyIiwKLQkJCSJteXNxbDovL2xvY2FsaG9zdDozMzA2IiwKLQkJCSJyb290IiwKLQkJCSJvcmFjbGUiCi0JCSk7Ci0KLQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIENvbm5lY3Rpb25Db25maWcgT1JBQ0xFID0KLQkJbmV3IENvbm5lY3Rpb25Db25maWcoCi0JCQkiT3JhY2xlIiwKLQkJCSJvcmFjbGUuamRiYy5PcmFjbGVEcml2ZXIiLAotCQkJIm9yYWNsZTp0aGluOkBsb2NhbGhvc3Q6MTUyMTpvcmNsIiwKLQkJCSJzY290dCIsCi0JCQkidGlnZXIiCi0JCSk7Ci0KLQlwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIENvbm5lY3Rpb25Db25maWcgUE9TVEdSRVNRTCA9Ci0JCW5ldyBDb25uZWN0aW9uQ29uZmlnKAotCQkJIlBvc3RncmVTUUwiLAotCQkJIm9yZy5wb3N0Z3Jlc3FsLkRyaXZlciIsCi0JCQkicG9zdGdyZXNxbDpwb3N0Z3JlcyIsCi0JCQkicG9zdGdyZXMiLAotCQkJIm9yYWNsZSIKLQkJKTsKLQotCS8vIHRoZSBTeWJhc2Ugc2VydmVyIG11c3QgYmUgY29uZmlndXJlZCBleHBsaWNpdGx5IHRvICJsb2NhbGhvc3QiCi0JLy8gaW4gdGhlIGNvbmZpZyBmaWxlIFtTWUJBU0VdL2luaS9zcWwuaW5pCi0JcHJvdGVjdGVkIHN0YXRpYyBmaW5hbCBDb25uZWN0aW9uQ29uZmlnIFNZQkFTRSA9Ci0JCW5ldyBDb25uZWN0aW9uQ29uZmlnKAotCQkJIlN5YmFzZSIsCi0JCQkiY29tLnN5YmFzZS5qZGJjMy5qZGJjLlN5YkRyaXZlciIsCi0JCQkic3liYXNlOlRkczpsb2NhbGhvc3Q6NTAwMCIsCi0JCQkic2EiLAotCQkJIm9yYWNsZSIKLQkJKTsKLQotCXByb3RlY3RlZCBzdGF0aWMgY2xhc3MgQ29ubmVjdGlvbkNvbmZpZyB7Ci0JCXByb3RlY3RlZCBmaW5hbCBTdHJpbmcgcGxhdGZvcm1OYW1lOwotCQlwcm90ZWN0ZWQgZmluYWwgU3RyaW5nIGRyaXZlckNsYXNzTmFtZTsKLQkJcHJvdGVjdGVkIGZpbmFsIFN0cmluZyBkYXRhYmFzZVVSTDsKLQkJcHJvdGVjdGVkIGZpbmFsIFN0cmluZyB1c2VyOwotCQlwcm90ZWN0ZWQgZmluYWwgU3RyaW5nIHBhc3N3b3JkOwotCQlwcm90ZWN0ZWQgQ29ubmVjdGlvbkNvbmZpZygKLQkJCQlTdHJpbmcgcGxhdGZvcm1OYW1lLAotCQkJCVN0cmluZyBkcml2ZXJDbGFzc05hbWUsCi0JCQkJU3RyaW5nIGRhdGFiYXNlVVJMLAotCQkJCVN0cmluZyB1c2VyLAotCQkJCVN0cmluZyBwYXNzd29yZAotCQkpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLnBsYXRmb3JtTmFtZSA9IHBsYXRmb3JtTmFtZTsKLQkJCXRoaXMuZHJpdmVyQ2xhc3NOYW1lID0gZHJpdmVyQ2xhc3NOYW1lOwotCQkJdGhpcy5kYXRhYmFzZVVSTCA9IGRhdGFiYXNlVVJMOwotCQkJdGhpcy51c2VyID0gdXNlcjsKLQkJCXRoaXMucGFzc3dvcmQgPSBwYXNzd29yZDsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3Rlc3RzL2ludGVybmFsL0pEQkNUb29scy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3Rlc3RzL2ludGVybmFsL0pEQkNUb29scy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1N2M5OGZlLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi90ZXN0cy9pbnRlcm5hbC9KREJDVG9vbHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEwNSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uT3V0cHV0U3RyZWFtV3JpdGVyOwotaW1wb3J0IGphdmEuaW8uUHJpbnRXcml0ZXI7Ci1pbXBvcnQgamF2YS5zcWwuQ29ubmVjdGlvbjsKLWltcG9ydCBqYXZhLnNxbC5SZXN1bHRTZXQ7Ci1pbXBvcnQgamF2YS5zcWwuU1FMRXhjZXB0aW9uOwotaW1wb3J0IGphdmEuc3FsLlN0YXRlbWVudDsKLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5IYXNoTWFwOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTWFwOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlJlc3VsdFNldEl0ZXJhdG9yOwotCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBKREJDVG9vbHMgewotCi0JcHVibGljIHN0YXRpYyB2b2lkIGR1bXAoQ29ubmVjdGlvbiBjb25uZWN0aW9uLCBTdHJpbmcgc3FsKSB0aHJvd3MgU1FMRXhjZXB0aW9uIHsKLQkJZHVtcChleGVjdXRlKGNvbm5lY3Rpb24sIHNxbCkpOwotCX0KLQotCXB1YmxpYyBzdGF0aWMgdm9pZCBkdW1wKFJlc3VsdFNldCByZXN1bHRTZXQpIHRocm93cyBTUUxFeGNlcHRpb24gewotCQlQcmludFdyaXRlciBwdyA9IG5ldyBQcmludFdyaXRlcihuZXcgT3V0cHV0U3RyZWFtV3JpdGVyKFN5c3RlbS5vdXQpKTsKLQkJLy8gc3luY2hyb25pemUgdGhlIGNvbnNvbGUgc28gZXZlcnl0aGluZyBpcyBjb250aWd1b3VzCi0JCXN5bmNocm9uaXplZCAoU3lzdGVtLm91dCkgewotCQkJZHVtcE9uKHJlc3VsdFNldCwgcHcpOwotCQl9Ci0JCXB3LmZsdXNoKCk7Ci0JfQotCi0JcHVibGljIHN0YXRpYyB2b2lkIGR1bXBPbihSZXN1bHRTZXQgcmVzdWx0U2V0LCBQcmludFdyaXRlciBwdykgdGhyb3dzIFNRTEV4Y2VwdGlvbiB7Ci0JCUFycmF5TGlzdDxIYXNoTWFwPFN0cmluZywgT2JqZWN0Pj4gbWFwcyA9IGNvbnZlcnRUb01hcHMocmVzdWx0U2V0KTsKLQkJZm9yIChJdGVyYXRvcjxIYXNoTWFwPFN0cmluZywgT2JqZWN0Pj4gbWFwU3RyZWFtID0gbWFwcy5pdGVyYXRvcigpOyBtYXBTdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCWZvciAoSXRlcmF0b3I8TWFwLkVudHJ5PFN0cmluZywgT2JqZWN0Pj4gZW50cnlTdHJlYW0gPSBtYXBTdHJlYW0ubmV4dCgpLmVudHJ5U2V0KCkuaXRlcmF0b3IoKTsgZW50cnlTdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCQlNYXAuRW50cnk8U3RyaW5nLCBPYmplY3Q+IGVudHJ5ID0gZW50cnlTdHJlYW0ubmV4dCgpOwotCQkJCXB3LnByaW50KGVudHJ5LmdldEtleSgpKTsKLQkJCQlwdy5wcmludCgiID0gIik7Ci0JCQkJcHcucHJpbnQoZW50cnkuZ2V0VmFsdWUoKSk7Ci0JCQkJcHcucHJpbnRsbigpOwotCQkJfQotCQkJaWYgKG1hcFN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCQlwdy5wcmludGxuKCk7Ci0JCQl9Ci0JCX0KLQkJcHcucHJpbnRsbigidG90YWwgcm93czogIiArIG1hcHMuc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgc3RhdGljIEFycmF5TGlzdDxIYXNoTWFwPFN0cmluZywgT2JqZWN0Pj4gY29udmVydFRvTWFwcyhDb25uZWN0aW9uIGNvbm5lY3Rpb24sIFN0cmluZyBzcWwpIHRocm93cyBTUUxFeGNlcHRpb24gewotCQlyZXR1cm4gY29udmVydFRvTWFwcyhleGVjdXRlKGNvbm5lY3Rpb24sIHNxbCkpOwotCX0KLQotCXB1YmxpYyBzdGF0aWMgUmVzdWx0U2V0IGV4ZWN1dGUoQ29ubmVjdGlvbiBjb25uZWN0aW9uLCBTdHJpbmcgc3FsKSB0aHJvd3MgU1FMRXhjZXB0aW9uIHsKLQkJU3RhdGVtZW50IHN0YXRlbWVudCA9IGNvbm5lY3Rpb24uY3JlYXRlU3RhdGVtZW50KCk7Ci0JCXN0YXRlbWVudC5leGVjdXRlKHNxbCk7Ci0JCVJlc3VsdFNldCByZXN1bHRTZXQgPSBzdGF0ZW1lbnQuZ2V0UmVzdWx0U2V0KCk7Ci0JCXN0YXRlbWVudC5jbG9zZSgpOwotCQlyZXR1cm4gcmVzdWx0U2V0OwotCX0KLQotCXB1YmxpYyBzdGF0aWMgQXJyYXlMaXN0PEhhc2hNYXA8U3RyaW5nLCBPYmplY3Q+PiBjb252ZXJ0VG9NYXBzKFJlc3VsdFNldCByZXN1bHRTZXQpIHRocm93cyBTUUxFeGNlcHRpb24gewotCQlBcnJheUxpc3Q8SGFzaE1hcDxTdHJpbmcsIE9iamVjdD4+IHJvd3MgPSBuZXcgQXJyYXlMaXN0PEhhc2hNYXA8U3RyaW5nLCBPYmplY3Q+PigpOwotCQlmb3IgKEl0ZXJhdG9yPEhhc2hNYXA8U3RyaW5nLCBPYmplY3Q+PiBzdHJlYW0gPSBidWlsZE1hcEl0ZXJhdG9yKHJlc3VsdFNldCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJcm93cy5hZGQoc3RyZWFtLm5leHQoKSk7Ci0JCX0KLQkJcmV0dXJuIHJvd3M7Ci0JfQotCi0JcHVibGljIHN0YXRpYyBJdGVyYXRvcjxIYXNoTWFwPFN0cmluZywgT2JqZWN0Pj4gYnVpbGRNYXBJdGVyYXRvcihSZXN1bHRTZXQgcmVzdWx0U2V0KSB0aHJvd3MgU1FMRXhjZXB0aW9uIHsKLQkJcmV0dXJuIG5ldyBSZXN1bHRTZXRJdGVyYXRvcjxIYXNoTWFwPFN0cmluZywgT2JqZWN0Pj4ocmVzdWx0U2V0LCBuZXcgTWFwUmVzdWx0U2V0SXRlcmF0b3JBZGFwdGVyKGJ1aWxkQ29sdW1uTmFtZXMocmVzdWx0U2V0KSkpOwotCX0KLQotCXB1YmxpYyBzdGF0aWMgU3RyaW5nW10gYnVpbGRDb2x1bW5OYW1lcyhSZXN1bHRTZXQgcmVzdWx0U2V0KSB0aHJvd3MgU1FMRXhjZXB0aW9uIHsKLQkJU3RyaW5nW10gbmFtZXMgPSBuZXcgU3RyaW5nW3Jlc3VsdFNldC5nZXRNZXRhRGF0YSgpLmdldENvbHVtbkNvdW50KCldOwotCQlmb3IgKGludCBpID0gMDsgaSA8IG5hbWVzLmxlbmd0aDsgaSsrKSB7Ci0JCQluYW1lc1tpXSA9IHJlc3VsdFNldC5nZXRNZXRhRGF0YSgpLmdldENvbHVtbk5hbWUoaSArIDEpOyAgLy8gTkI6IFJlc3VsdFNldCBpbmRleC9zdWJzY3JpcHQgaXMgMS1iYXNlZAotCQl9Ci0JCXJldHVybiBuYW1lczsKLQl9Ci0KLQlwdWJsaWMgc3RhdGljIGNsYXNzIE1hcFJlc3VsdFNldEl0ZXJhdG9yQWRhcHRlciBpbXBsZW1lbnRzIFJlc3VsdFNldEl0ZXJhdG9yLkFkYXB0ZXI8SGFzaE1hcDxTdHJpbmcsIE9iamVjdD4+IHsKLQkJcHJpdmF0ZSBmaW5hbCBTdHJpbmdbXSBjb2x1bW5OYW1lczsKLQkJcHVibGljIE1hcFJlc3VsdFNldEl0ZXJhdG9yQWRhcHRlcihTdHJpbmdbXSBjb2x1bW5OYW1lcykgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMuY29sdW1uTmFtZXMgPSBjb2x1bW5OYW1lczsKLQkJfQotCQlwdWJsaWMgSGFzaE1hcDxTdHJpbmcsIE9iamVjdD4gYnVpbGROZXh0KFJlc3VsdFNldCBycykgdGhyb3dzIFNRTEV4Y2VwdGlvbiB7Ci0JCQlIYXNoTWFwPFN0cmluZywgT2JqZWN0PiBtYXAgPSBuZXcgSGFzaE1hcDxTdHJpbmcsIE9iamVjdD4odGhpcy5jb2x1bW5OYW1lcy5sZW5ndGgpOwotCQkJZm9yIChpbnQgaSA9IDA7IGkgPCB0aGlzLmNvbHVtbk5hbWVzLmxlbmd0aDsgaSsrKSB7Ci0JCQkJbWFwLnB1dCh0aGlzLmNvbHVtbk5hbWVzW2ldLCBycy5nZXRPYmplY3QoaSArIDEpKTsgIC8vIE5COiBSZXN1bHRTZXQgaW5kZXgvc3Vic2NyaXB0IGlzIDEtYmFzZWQKLQkJCX0KLQkJCXJldHVybiBtYXA7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi90ZXN0cy9pbnRlcm5hbC9KcHREYlRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvSnB0RGJUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlYTM0ZDA4Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi90ZXN0cy9pbnRlcm5hbC9KcHREYlRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0OwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0U3VpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzLmludGVybmFsLnBsYXRmb3Jtcy5BbGxQbGF0Zm9ybVRlc3RzOwotCi0vKioKLSAqICBKUFQgREIgVGVzdHMKLSAqLwotcHVibGljIGNsYXNzIEpwdERiVGVzdHMgewotCi0gICAgcHVibGljIHN0YXRpYyBUZXN0IHN1aXRlKCkgewotCQlUZXN0U3VpdGUgc3VpdGUgPSBuZXcgVGVzdFN1aXRlKEpwdERiVGVzdHMuY2xhc3MuZ2V0UGFja2FnZSgpLmdldE5hbWUoKSk7Ci0gICAgCi0gICAgICAgIHN1aXRlLmFkZFRlc3QoIEFsbFBsYXRmb3JtVGVzdHMuc3VpdGUoKSk7Ci0gICAgCi0gICAgICAgIHJldHVybiBzdWl0ZTsKLSAgICB9Ci0gICAgCi0gICAgcHJpdmF0ZSBKcHREYlRlc3RzKCkgewotICAgICAgICBzdXBlcigpOwotICAgICAgICB0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLSAgICB9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi90ZXN0cy9pbnRlcm5hbC9KcHREYlRlc3RzUGx1Z2luLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvSnB0RGJUZXN0c1BsdWdpbi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2ZDUxN2I1Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi90ZXN0cy9pbnRlcm5hbC9KcHREYlRlc3RzUGx1Z2luLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5QbHVnaW47Ci1pbXBvcnQgb3JnLm9zZ2kuZnJhbWV3b3JrLkJ1bmRsZUNvbnRleHQ7Ci0KLS8qKgotICogIEpwdERiVGVzdHNQbHVnaW4KLSAqLwotcHVibGljIGNsYXNzIEpwdERiVGVzdHNQbHVnaW4gZXh0ZW5kcyBQbHVnaW4gewotCi0JLy8gVGhlIHNoYXJlZCBpbnN0YW5jZQotCXByaXZhdGUgc3RhdGljIEpwdERiVGVzdHNQbHVnaW4gSU5TVEFOQ0U7Ci0KLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBCVU5ETEVfSUQgPSAib3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzIjsgLy8kTk9OLU5MUy0xJAotCi0JLyoqCi0JICogUmV0dXJucyB0aGUgc2hhcmVkIGluc3RhbmNlCi0JICovCi0JcHVibGljIHN0YXRpYyBKcHREYlRlc3RzUGx1Z2luIGluc3RhbmNlKCkgewotCQlyZXR1cm4gSU5TVEFOQ0U7Ci0JfQotCQotCS8qKgotCSAqIFRoZSBjb25zdHJ1Y3RvcgotCSAqLwotCXB1YmxpYyBKcHREYlRlc3RzUGx1Z2luKCkgewotCQlzdXBlcigpOwotCQlJTlNUQU5DRSA9IHRoaXM7Ci0JfQotCi0JLyoqCi0JICogVGhpcyBtZXRob2QgaXMgY2FsbGVkIHVwb24gcGx1Zy1pbiBhY3RpdmF0aW9uCi0JICovCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgc3RhcnQoQnVuZGxlQ29udGV4dCBjb250ZXh0KSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc3RhcnQoY29udGV4dCk7Ci0JfQotCi0JLyoqCi0JICogVGhpcyBtZXRob2QgaXMgY2FsbGVkIHdoZW4gdGhlIHBsdWctaW4gaXMgc3RvcHBlZAotCSAqLwotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHN0b3AoQnVuZGxlQ29udGV4dCBjb250ZXh0KSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJSU5TVEFOQ0UgPSBudWxsOwotCQlzdXBlci5zdG9wKGNvbnRleHQpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi90ZXN0cy9pbnRlcm5hbC9wbGF0Zm9ybXMvQWxsUGxhdGZvcm1UZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3Rlc3RzL2ludGVybmFsL3BsYXRmb3Jtcy9BbGxQbGF0Zm9ybVRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDIyZWNlN2UuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3Rlc3RzL2ludGVybmFsL3BsYXRmb3Jtcy9BbGxQbGF0Zm9ybVRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy5pbnRlcm5hbC5wbGF0Zm9ybXM7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdFN1aXRlOwotCi1wdWJsaWMgY2xhc3MgQWxsUGxhdGZvcm1UZXN0cyB7Ci0KLSAgICBwdWJsaWMgc3RhdGljIFRlc3Qgc3VpdGUoKSB7Ci0JCVRlc3RTdWl0ZSBzdWl0ZSA9IG5ldyBUZXN0U3VpdGUoQWxsUGxhdGZvcm1UZXN0cy5jbGFzcy5nZXRQYWNrYWdlKCkuZ2V0TmFtZSgpKTsKLQotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoRGVyYnlUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShNeVNRTFRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKE9yYWNsZTEwZ1Rlc3RzLmNsYXNzKTsKLS8vCQlzdWl0ZS5hZGRUZXN0U3VpdGUoT3JhY2xlMTBnWEVUZXN0cy5jbGFzcyk7Ci0vLwkJc3VpdGUuYWRkVGVzdFN1aXRlKE9yYWNsZTlpVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoUG9zdGdyZVNRTFRlc3RzLmNsYXNzKTsKLS8vCQlzdWl0ZS5hZGRUZXN0U3VpdGUoU1FMU2VydmVyVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoU3liYXNlVGVzdHMuY2xhc3MpOwotCi0gICAgICAgIHJldHVybiBzdWl0ZTsKLSAgICB9Ci0KLSAgICBwcml2YXRlIEFsbFBsYXRmb3JtVGVzdHMoKSB7Ci0gICAgICAgIHN1cGVyKCk7Ci0gICAgICAgIHRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotICAgIH0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3Rlc3RzL2ludGVybmFsL3BsYXRmb3Jtcy9EVFBQbGF0Zm9ybVRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm1zL0RUUFBsYXRmb3JtVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzA4MGJkYi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm1zL0RUUFBsYXRmb3JtVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEwMjAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMuaW50ZXJuYWwucGxhdGZvcm1zOwotCi1pbXBvcnQgamF2YS5pby5GaWxlOwotaW1wb3J0IGphdmEuaW8uSU9FeGNlcHRpb247Ci1pbXBvcnQgamF2YS5pby5PdXRwdXRTdHJlYW1Xcml0ZXI7Ci1pbXBvcnQgamF2YS5uZXQuVVJMOwotaW1wb3J0IGphdmEuc3FsLkNvbm5lY3Rpb247Ci1pbXBvcnQgamF2YS5zcWwuRGF0YWJhc2VNZXRhRGF0YTsKLWltcG9ydCBqYXZhLnNxbC5SZXN1bHRTZXQ7Ci1pbXBvcnQgamF2YS5zcWwuU1FMRXhjZXB0aW9uOwotaW1wb3J0IGphdmEuc3FsLlN0YXRlbWVudDsKLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuUHJvcGVydGllczsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5Db3JlRXhjZXB0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5JUGF0aDsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuSVN0YXR1czsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuUGxhdGZvcm07Ci1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5Db25uZWN0aW9uUHJvZmlsZUV4Y2VwdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LklDb25uZWN0aW9uUHJvZmlsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LklNYW5hZ2VkQ29ubmVjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LlByb2ZpbGVNYW5hZ2VyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuZHJpdmVycy5JRHJpdmVyTWdtdENvbnN0YW50czsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LmRyaXZlcnMuSVByb3BlcnR5U2V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuZHJpdmVycy5Qcm9wZXJ0eVNldEltcGw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5kcml2ZXJzLlhNTEZpbGVNYW5hZ2VyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuZHJpdmVycy5qZGJjLklKREJDRHJpdmVyRGVmaW5pdGlvbkNvbnN0YW50czsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LmludGVybmFsLkNvbm5lY3Rpdml0eVBsdWdpbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LnNxbS5jb3JlLmNvbm5lY3Rpb24uQ29ubmVjdGlvbkluZm87Ci1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5zcW0uY29yZS5ydGUuSUNhdGFsb2dPYmplY3Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkNhdGFsb2c7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkNvbHVtbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuQ29ubmVjdGlvbkxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5Db25uZWN0aW9uUHJvZmlsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuQ29ubmVjdGlvblByb2ZpbGVGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5Db25uZWN0aW9uUHJvZmlsZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5EYXRhYmFzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuRGF0YWJhc2VGaW5kZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkZvcmVpZ25LZXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkpwdERiUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5TY2hlbWE7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLlNjaGVtYUNvbnRhaW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuU2VxdWVuY2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLlRhYmxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5Gb3JlaWduS2V5LkNvbHVtblBhaXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzLmludGVybmFsLkpwdERiVGVzdHNQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5JbmRlbnRpbmdQcmludFdyaXRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuUmVzdWx0U2V0SXRlcmF0b3I7Ci0KLS8qKgotICogQmFzZSBjbGFzcyBmb3IgdGVzdGluZyBEVFAgd3JhcHBlcnMgb24gdmFyaW91cyBkYXRhYmFzZXMuCi0gKi8KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGFic3RyYWN0IGNsYXNzIERUUFBsYXRmb3JtVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQkvKioKLQkgKiBUaGUgcGxhdGZvcm0gcHJvcGVydGllcyBhcmUgbG9hZGVkIGZyb20gYSBKYXZhIHByb3BlcnRpZXMgZmlsZSBpbiB0aGUKLQkgKiAnb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL2NvbmZpZycgZGlyZWN0b3J5LiBFYWNoIGRhdGFiYXNlIHBsYXRmb3JtIGhhcwotCSAqIGl0cyBvd24gcHJvcGVydGllcyBmaWxlIChlLmcuICdkZXJieS5wcm9wZXJ0aWVzJykuCi0JICovCi0JcHJpdmF0ZSBQcm9wZXJ0aWVzIHBsYXRmb3JtUHJvcGVydGllczsKLQotCS8qKgotCSAqIFRoaXMgaXMgdGhlIERhbGkgY29ubmVjdGlvbiBwcm9maWxlIHdyYXBwZXIuCi0JICovCi0JcHJvdGVjdGVkIENvbm5lY3Rpb25Qcm9maWxlIGNvbm5lY3Rpb25Qcm9maWxlOwotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0YW50cyAqKioqKioqKioqCi0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgUExBVEZPUk1fQ09ORklHX0RJUkVDVE9SWSA9ICJjb25maWciOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIERCX1VTRVJfSURfUFJPUEVSVFkgPSAidXNlcklEIjsKLQkJcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIERCX1VTRVJfSURfREVGQVVMVCA9ICJ1c2VyIjsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBEQl9QQVNTV09SRF9QUk9QRVJUWSA9ICJwYXNzd29yZCI7Ci0JCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBEQl9QQVNTV09SRF9ERUZBVUxUID0gIiI7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgREJfRFJJVkVSX0pBUlNfUFJPUEVSVFkgPSAiamFycyI7Ci0JCS8vIHJlcXVpcmVkIC0gbm8gZGVmYXVsdAotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIERCX1VSTF9QUk9QRVJUWSA9ICJ1cmwiOwotCQkvLyByZXF1aXJlZCAtIG5vIGRlZmF1bHQKLQotCi0KLQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9yICoqKioqKioqKioKLQotCXByb3RlY3RlZCBEVFBQbGF0Zm9ybVRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBzZXQtdXAvdGVhci1kb3duICoqKioqKioqKioKLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0KLQkJdGhpcy5wbGF0Zm9ybVByb3BlcnRpZXMgPSB0aGlzLmxvYWRQbGF0Zm9ybVByb3BlcnRpZXMoKTsKLQkJdGhpcy5idWlsZERUUERyaXZlckRlZmluaXRpb25GaWxlKCk7Ci0JCXRoaXMuYnVpbGREVFBDb25uZWN0aW9uUHJvZmlsZSgpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlID0gdGhpcy5nZXRDb25uZWN0aW9uUHJvZmlsZUZhY3RvcnkoKS5idWlsZENvbm5lY3Rpb25Qcm9maWxlKHRoaXMuZ2V0UHJvZmlsZU5hbWUoKSwgRGF0YWJhc2VGaW5kZXIuRGVmYXVsdC5pbnN0YW5jZSgpKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlID0gbnVsbDsKLQkJdGhpcy5wbGF0Zm9ybVByb3BlcnRpZXMgPSBudWxsOwotCi0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JLy8gKioqKiogcGxhdGZvcm0gcHJvcGVydGllcyBmaWxlCi0JcHJpdmF0ZSBQcm9wZXJ0aWVzIGxvYWRQbGF0Zm9ybVByb3BlcnRpZXMoKSB0aHJvd3MgSU9FeGNlcHRpb24gewotCQlQcm9wZXJ0aWVzIHAgPSBuZXcgUHJvcGVydGllcygpOwotCQlwLmxvYWQodGhpcy5idWlsZFBsYXRmb3JtUHJvcGVydGllc0ZpbGVVUkwoKS5vcGVuU3RyZWFtKCkpOwotCQlyZXR1cm4gcDsKLQl9Ci0KLQlwcml2YXRlIFVSTCBidWlsZFBsYXRmb3JtUHJvcGVydGllc0ZpbGVVUkwoKSB7Ci0JCXJldHVybiBQbGF0Zm9ybS5nZXRCdW5kbGUodGhpcy5nZXRUZXN0UGx1Z2luQnVuZGxlSUQoKSkuZ2V0RW50cnkodGhpcy5nZXRQbGF0Zm9ybVByb3BlcnRpZXNGaWxlUGF0aCgpKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBnZXRUZXN0UGx1Z2luQnVuZGxlSUQoKSB7Ci0JCXJldHVybiBKcHREYlRlc3RzUGx1Z2luLkJVTkRMRV9JRDsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBnZXRQbGF0Zm9ybVByb3BlcnRpZXNGaWxlUGF0aCgpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0UGxhdGZvcm1Qcm9wZXJ0aWVzRGlyZWN0b3J5TmFtZSgpICsgJy8nICsgdGhpcy5nZXRQbGF0Zm9ybVByb3BlcnRpZXNGaWxlTmFtZSgpOwotCX0KLQotCXByaXZhdGUgU3RyaW5nIGdldFBsYXRmb3JtUHJvcGVydGllc0RpcmVjdG9yeU5hbWUoKSB7Ci0JCXJldHVybiBQTEFURk9STV9DT05GSUdfRElSRUNUT1JZOwotCX0KLQotCS8qKgotCSAqIEVhY2ggZGF0YWJhc2UgcGxhdGZvcm0gaGFzIGEgc2VwYXJhdGUgcHJvcGVydGllcyBmaWxlIGluIHRoZSAnY29uZmlnJwotCSAqIGRpcmVjdG9yeSB0aGF0IG11c3QgYmUgY3VzdG9taXplZCBieSB3aG9tZXZlciBpcyBleGVjdXRpbmcgdGhlIHRlc3RzLgotCSAqLwotCXByb3RlY3RlZCBhYnN0cmFjdCBTdHJpbmcgZ2V0UGxhdGZvcm1Qcm9wZXJ0aWVzRmlsZU5hbWUoKTsKLQotCS8vICoqKioqIGRyaXZlciBkZWZpbml0aW9uIGZpbGUKLQlwcml2YXRlIHZvaWQgYnVpbGREVFBEcml2ZXJEZWZpbml0aW9uRmlsZSgpIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKLQkJWE1MRmlsZU1hbmFnZXIuc2V0U3RvcmFnZUxvY2F0aW9uKHRoaXMuZ2V0RFRQRHJpdmVyRGVmaW5pdGlvbkxvY2F0aW9uKCkpOwotCQlYTUxGaWxlTWFuYWdlci5zZXRGaWxlTmFtZSh0aGlzLmdldERUUERyaXZlckZpbGVOYW1lKCkpOwotCi0JCUlQcm9wZXJ0eVNldFtdIHNldHMgPSBYTUxGaWxlTWFuYWdlci5sb2FkUHJvcGVydHlTZXRzKCk7Ci0JCWZvciAoSVByb3BlcnR5U2V0IHNldCA6IHNldHMpIHsKLQkJCWlmIChzZXQuZ2V0SUQoKS5lcXVhbHModGhpcy5nZXREcml2ZXJEZWZpbml0aW9uSUQoKSkpIHsKLQkJCQlyZXR1cm47ICAvLyBwcm9wZXJ0eSBzZXRzIGxpdmUgYWNyb3NzIHRlc3RzCi0JCQl9Ci0JCX0KLQotCQlYTUxGaWxlTWFuYWdlci5zYXZlTmFtZWRQcm9wZXJ0eVNldCh0aGlzLmJ1aWxkRFRQRHJpdmVyRGVmaW5pdGlvblByb3BlcnR5U2V0cygpKTsKLQotCQkvLyB2ZXJpZnkgdGhlIGZpbGUgd2FzIGNyZWF0ZWQ6Ci0JCUZpbGUgZHJpdmVyRGVmaW5pdGlvbmVGaWxlID0gdGhpcy5nZXREVFBEcml2ZXJEZWZpbml0aW9uTG9jYXRpb24oKS5hcHBlbmQodGhpcy5nZXREVFBEcml2ZXJGaWxlTmFtZSgpKS50b0ZpbGUoKTsKLQkJYXNzZXJ0VHJ1ZShkcml2ZXJEZWZpbml0aW9uZUZpbGUuZXhpc3RzKCkpOwotCX0KLQotCXByaXZhdGUgSVBhdGggZ2V0RFRQRHJpdmVyRGVmaW5pdGlvbkxvY2F0aW9uKCkgewotCQlyZXR1cm4gQ29ubmVjdGl2aXR5UGx1Z2luLmdldERlZmF1bHQoKS5nZXRTdGF0ZUxvY2F0aW9uKCk7Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmcgZ2V0RFRQRHJpdmVyRmlsZU5hbWUoKSB7Ci0JCXJldHVybiBJRHJpdmVyTWdtdENvbnN0YW50cy5EUklWRVJfRklMRTsKLQl9Ci0KLQlwcml2YXRlIElQcm9wZXJ0eVNldFtdIGJ1aWxkRFRQRHJpdmVyRGVmaW5pdGlvblByb3BlcnR5U2V0cygpIHsKLQkJSVByb3BlcnR5U2V0W10gcHJvcGVydHlTZXRzID0gbmV3IElQcm9wZXJ0eVNldFsxXTsKLQkJUHJvcGVydHlTZXRJbXBsIHByb3BlcnR5U2V0ID0gbmV3IFByb3BlcnR5U2V0SW1wbCh0aGlzLmdldERyaXZlck5hbWUoKSwgdGhpcy5nZXREcml2ZXJEZWZpbml0aW9uSUQoKSk7Ci0JCXByb3BlcnR5U2V0LnNldFByb3BlcnRpZXModGhpcy5nZXREcml2ZXJEZWZpbml0aW9uSUQoKSwgdGhpcy5idWlsZERUUERyaXZlckRlZmluaXRpb25Qcm9wZXJ0aWVzKCkpOwotCQlwcm9wZXJ0eVNldHNbMF0gPSBwcm9wZXJ0eVNldDsKLQkJcmV0dXJuIHByb3BlcnR5U2V0czsKLQl9Ci0KLQlwcm90ZWN0ZWQgYWJzdHJhY3QgU3RyaW5nIGdldERyaXZlck5hbWUoKTsKLQotCXByb3RlY3RlZCBhYnN0cmFjdCBTdHJpbmcgZ2V0RHJpdmVyRGVmaW5pdGlvbklEKCk7Ci0KLQlwcml2YXRlIFByb3BlcnRpZXMgYnVpbGREVFBEcml2ZXJEZWZpbml0aW9uUHJvcGVydGllcygpIHsKLQkJUHJvcGVydGllcyBwID0gbmV3IFByb3BlcnRpZXMoKTsKLQkJcC5zZXRQcm9wZXJ0eShDb25uZWN0aW9uUHJvZmlsZS5EUklWRVJfREVGSU5JVElPTl9UWVBFX1BST1BfSUQsIHRoaXMuZ2V0RHJpdmVyRGVmaW5pdGlvblR5cGUoKSk7Ci0JCXAuc2V0UHJvcGVydHkoQ29ubmVjdGlvblByb2ZpbGUuRFJJVkVSX0pBUl9MSVNUX1BST1BfSUQsIHRoaXMuZ2V0SkRCQ0RyaXZlckphckxpc3QoKSk7Ci0JCXAuc2V0UHJvcGVydHkoSUpEQkNEcml2ZXJEZWZpbml0aW9uQ29uc3RhbnRzLkRBVEFCQVNFX1ZFTkRPUl9QUk9QX0lELCB0aGlzLmdldERhdGFiYXNlVmVuZG9yKCkpOwotCQlwLnNldFByb3BlcnR5KElKREJDRHJpdmVyRGVmaW5pdGlvbkNvbnN0YW50cy5EQVRBQkFTRV9WRVJTSU9OX1BST1BfSUQsIHRoaXMuZ2V0RGF0YWJhc2VWZXJzaW9uKCkpOwotCQlwLnNldFByb3BlcnR5KElKREJDRHJpdmVyRGVmaW5pdGlvbkNvbnN0YW50cy5EUklWRVJfQ0xBU1NfUFJPUF9JRCwgdGhpcy5nZXREcml2ZXJDbGFzcygpKTsKLQkJcC5zZXRQcm9wZXJ0eShJSkRCQ0RyaXZlckRlZmluaXRpb25Db25zdGFudHMuVVJMX1BST1BfSUQsIHRoaXMuZ2V0SkRCQ1VSTCgpKTsKLQkJcC5zZXRQcm9wZXJ0eShJSkRCQ0RyaXZlckRlZmluaXRpb25Db25zdGFudHMuVVNFUk5BTUVfUFJPUF9JRCwgdGhpcy5nZXRVc2VySUQoKSk7Ci0JCXAuc2V0UHJvcGVydHkoSUpEQkNEcml2ZXJEZWZpbml0aW9uQ29uc3RhbnRzLlBBU1NXT1JEX1BST1BfSUQsIHRoaXMuZ2V0UGFzc3dvcmQoKSk7Ci0JCXJldHVybiBwOwotCX0KLQotCXByb3RlY3RlZCBhYnN0cmFjdCBTdHJpbmcgZ2V0RHJpdmVyRGVmaW5pdGlvblR5cGUoKTsKLQotCS8qKgotCSAqIFRoZSBKQVIgbGlzdCBpcyB3b3Jrc3BhY2Utc3BlY2lmaWMgYW5kIGlzIHNldCBpbiB0aGUgcHJvcGVydGllcyBmaWxlLgotCSAqLwotCXByaXZhdGUgU3RyaW5nIGdldEpEQkNEcml2ZXJKYXJMaXN0KCkgewotCQlyZXR1cm4gdGhpcy5nZXRSZXF1aXJlZFBsYXRmb3JtUHJvcGVydHkoREJfRFJJVkVSX0pBUlNfUFJPUEVSVFkpOwotCX0KLQotCXByb3RlY3RlZCBhYnN0cmFjdCBTdHJpbmcgZ2V0RGF0YWJhc2VWZW5kb3IoKTsKLQotCXByb3RlY3RlZCBhYnN0cmFjdCBTdHJpbmcgZ2V0RGF0YWJhc2VWZXJzaW9uKCk7Ci0KLQlwcm90ZWN0ZWQgYWJzdHJhY3QgU3RyaW5nIGdldERyaXZlckNsYXNzKCk7Ci0KLQkvKioKLQkgKiBUaGUgZGF0YWJhc2UgVVJMIGlzIHdvcmtzcGFjZS1zcGVjaWZpYyBhbmQgaXMgc2V0IGluIHRoZSBwcm9wZXJ0aWVzIGZpbGUKLQkgKiBmb3Igc29tZSBkYXRhYmFzZXMuCi0JICovCi0JcHJpdmF0ZSBTdHJpbmcgZ2V0SkRCQ1VSTCgpIHsKLQkJcmV0dXJuIHRoaXMucGxhdGZvcm1Qcm9wZXJ0aWVzLmdldFByb3BlcnR5KERCX1VSTF9QUk9QRVJUWSwgdGhpcy5nZXREZWZhdWx0SkRCQ1VSTCgpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERlZmF1bHRKREJDVVJMKCkgewotCQlyZXR1cm4gIiI7Ci0JfQotCi0JLyoqCi0JICogVGhlIHVzZXIgSUQgaXMgb3B0aW9uYWwgYW5kIGNhbiBiZSBzZXQgaW4gdGhlIHByb3BlcnRpZXMgZmlsZS4KLQkgKi8KLQlwcm90ZWN0ZWQgU3RyaW5nIGdldFVzZXJJRCgpIHsKLQkJcmV0dXJuIHRoaXMucGxhdGZvcm1Qcm9wZXJ0aWVzLmdldFByb3BlcnR5KERCX1VTRVJfSURfUFJPUEVSVFksIERCX1VTRVJfSURfREVGQVVMVCk7Ci0JfQotCi0JLyoqCi0JICogVGhlIHBhc3N3b3JkIGlzIG9wdGlvbmFsIGFuZCBjYW4gYmUgc2V0IGluIHRoZSBwcm9wZXJ0aWVzIGZpbGUuCi0JICovCi0JcHJpdmF0ZSBTdHJpbmcgZ2V0UGFzc3dvcmQoKSB7Ci0JCXJldHVybiB0aGlzLnBsYXRmb3JtUHJvcGVydGllcy5nZXRQcm9wZXJ0eShEQl9QQVNTV09SRF9QUk9QRVJUWSwgREJfUEFTU1dPUkRfREVGQVVMVCk7Ci0JfQotCi0JLy8gKioqKiogRFRQIGNvbm5lY3Rpb24gcHJvZmlsZQotCXByaXZhdGUgdm9pZCBidWlsZERUUENvbm5lY3Rpb25Qcm9maWxlKCkgdGhyb3dzIENvbm5lY3Rpb25Qcm9maWxlRXhjZXB0aW9uIHsKLQkJaWYgKHRoaXMuZ2V0RFRQUHJvZmlsZU1hbmFnZXIoKS5nZXRQcm9maWxlQnlOYW1lKHRoaXMuZ2V0UHJvZmlsZU5hbWUoKSkgIT0gbnVsbCkgewotCQkJcmV0dXJuOyAgLy8gcHJvZmlsZXMgbGl2ZSBhY3Jvc3MgdGVzdHMKLQkJfQotCQl0aGlzLmNyZWF0ZVByb2ZpbGUodGhpcy5nZXRQcm9maWxlTmFtZSgpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmdldERUUFByb2ZpbGVNYW5hZ2VyKCkuZ2V0UHJvZmlsZUJ5TmFtZSh0aGlzLmdldFByb2ZpbGVOYW1lKCkpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBjcmVhdGVQcm9maWxlKFN0cmluZyBwcm9maWxlTmFtZSkgdGhyb3dzIENvbm5lY3Rpb25Qcm9maWxlRXhjZXB0aW9uIHsKLQkJdGhpcy5nZXREVFBQcm9maWxlTWFuYWdlcigpLmNyZWF0ZVByb2ZpbGUoCi0JCQkJcHJvZmlsZU5hbWUsCi0JCQkJdGhpcy5nZXRQcm9maWxlRGVzY3JpcHRpb24oKSwKLQkJCQl0aGlzLmdldFByb3ZpZGVySUQoKSwKLQkJCQl0aGlzLmJ1aWxkRFRQQ29ubmVjdGlvblByb2ZpbGVQcm9wZXJ0aWVzKCkKLQkJKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgYWJzdHJhY3QgU3RyaW5nIGdldFByb2ZpbGVOYW1lKCk7Ci0KLQlwcm90ZWN0ZWQgYWJzdHJhY3QgU3RyaW5nIGdldFByb2ZpbGVEZXNjcmlwdGlvbigpOwotCi0JcHJvdGVjdGVkIFN0cmluZyBnZXRQcm92aWRlcklEKCkgewotCQlyZXR1cm4gQ29ubmVjdGlvblByb2ZpbGUuQ09OTkVDVElPTl9QUk9GSUxFX1RZUEU7Ci0JfQotCSAKLQlwcm90ZWN0ZWQgUHJvcGVydGllcyBidWlsZERUUENvbm5lY3Rpb25Qcm9maWxlUHJvcGVydGllcygpIHsKLQkJUHJvcGVydGllcyBwID0gbmV3IFByb3BlcnRpZXMoKTsKLQkJcC5zZXRQcm9wZXJ0eShJSkRCQ0RyaXZlckRlZmluaXRpb25Db25zdGFudHMuVVNFUk5BTUVfUFJPUF9JRCwgdGhpcy5nZXRVc2VySUQoKSk7Ci0JCXAuc2V0UHJvcGVydHkoSUpEQkNEcml2ZXJEZWZpbml0aW9uQ29uc3RhbnRzLlBBU1NXT1JEX1BST1BfSUQsIHRoaXMuZ2V0UGFzc3dvcmQoKSk7Ci0JCXAuc2V0UHJvcGVydHkoQ29ubmVjdGlvblByb2ZpbGUuRFJJVkVSX0RFRklOSVRJT05fUFJPUF9JRCwgdGhpcy5nZXREcml2ZXJEZWZpbml0aW9uSUQoKSk7Ci0KLQkJcC5zZXRQcm9wZXJ0eShJSkRCQ0RyaXZlckRlZmluaXRpb25Db25zdGFudHMuRFJJVkVSX0NMQVNTX1BST1BfSUQsIHRoaXMuZ2V0RHJpdmVyQ2xhc3MoKSk7Ci0JCXAuc2V0UHJvcGVydHkoSUpEQkNEcml2ZXJEZWZpbml0aW9uQ29uc3RhbnRzLlVSTF9QUk9QX0lELCB0aGlzLmdldEpEQkNVUkwoKSk7Ci0JCXAuc2V0UHJvcGVydHkoSUpEQkNEcml2ZXJEZWZpbml0aW9uQ29uc3RhbnRzLkRBVEFCQVNFX1ZFTkRPUl9QUk9QX0lELCB0aGlzLmdldERhdGFiYXNlVmVuZG9yKCkpOwotCQlwLnNldFByb3BlcnR5KElKREJDRHJpdmVyRGVmaW5pdGlvbkNvbnN0YW50cy5EQVRBQkFTRV9WRVJTSU9OX1BST1BfSUQsIHRoaXMuZ2V0RGF0YWJhc2VWZXJzaW9uKCkpOwotCi0JCXAuc2V0UHJvcGVydHkoQ29ubmVjdGlvblByb2ZpbGUuREFUQUJBU0VfU0FWRV9QV0RfUFJPUF9JRCwgdGhpcy5wYXNzd29yZElzU2F2ZWQoKSk7Ci0JCXJldHVybiBwOwotCX0KLQotCXByaXZhdGUgU3RyaW5nIHBhc3N3b3JkSXNTYXZlZCgpIHsKLQkJcmV0dXJuICJ0cnVlIjsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogdGVzdHMgKioqKioqKioqKgotCi0JcHVibGljIHZvaWQgdGVzdENvbm5lY3Rpb25Qcm9maWxlTGlzdGVuZXIoKSB0aHJvd3MgQ29ubmVjdGlvblByb2ZpbGVFeGNlcHRpb24gewotCQlUZXN0Q29ubmVjdGlvblByb2ZpbGVMaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBUZXN0Q29ubmVjdGlvblByb2ZpbGVMaXN0ZW5lcigpOwotCQl0aGlzLmdldENvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeSgpLmFkZENvbm5lY3Rpb25Qcm9maWxlTGlzdGVuZXIobGlzdGVuZXIpOwotCi0JCVN0cmluZyBjcE5hbWUxID0gdGhpcy5nZXRQcm9maWxlTmFtZSgpICsgIjEiOwotCQl0aGlzLmNyZWF0ZVByb2ZpbGUoY3BOYW1lMSk7Ci0JCUlDb25uZWN0aW9uUHJvZmlsZSBkdHBDUCA9IHRoaXMuZ2V0RFRQUHJvZmlsZU1hbmFnZXIoKS5nZXRQcm9maWxlQnlOYW1lKGNwTmFtZTEpOwotCQlhc3NlcnROb3ROdWxsKGR0cENQKTsKLQotCQlhc3NlcnRFcXVhbHMoY3BOYW1lMSwgbGlzdGVuZXIuYWRkZWROYW1lKTsKLQkJbGlzdGVuZXIuY2xlYXIoKTsKLQotCQlTdHJpbmcgY3BOYW1lMiA9IHRoaXMuZ2V0UHJvZmlsZU5hbWUoKSArICIyIjsKLQkJdGhpcy5nZXREVFBQcm9maWxlTWFuYWdlcigpLm1vZGlmeVByb2ZpbGUoZHRwQ1AsIGNwTmFtZTIsIG51bGwpOwotCQlhc3NlcnRFcXVhbHMoY3BOYW1lMSwgbGlzdGVuZXIucmVuYW1lZE9sZE5hbWUpOwotCQlhc3NlcnRFcXVhbHMoY3BOYW1lMiwgbGlzdGVuZXIucmVuYW1lZE5ld05hbWUpOwotCQlsaXN0ZW5lci5jbGVhcigpOwotCi0JCUNvbm5lY3Rpb25Qcm9maWxlIGNwID0gdGhpcy5nZXRDb25uZWN0aW9uUHJvZmlsZUZhY3RvcnkoKS5idWlsZENvbm5lY3Rpb25Qcm9maWxlKGNwTmFtZTIpOwotCQlhc3NlcnROb3ROdWxsKGNwKTsKLQotCQl0aGlzLmdldERUUFByb2ZpbGVNYW5hZ2VyKCkuZGVsZXRlUHJvZmlsZShkdHBDUCk7Ci0JCWFzc2VydEVxdWFscyhjcE5hbWUyLCBsaXN0ZW5lci5yZW1vdmVkTmFtZSk7Ci0JCWxpc3RlbmVyLmNsZWFyKCk7Ci0KLQkJY3AgPSB0aGlzLmdldENvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeSgpLmJ1aWxkQ29ubmVjdGlvblByb2ZpbGUoY3BOYW1lMik7Ci0JCWFzc2VydE51bGwoY3ApOwotCi0JCXRoaXMuZ2V0Q29ubmVjdGlvblByb2ZpbGVGYWN0b3J5KCkucmVtb3ZlQ29ubmVjdGlvblByb2ZpbGVMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5hbWUoKSB7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmdldFByb2ZpbGVOYW1lKCksIHRoaXMuY29ubmVjdGlvblByb2ZpbGUuZ2V0TmFtZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29ubmVjdGlvbigpIHRocm93cyBFeGNlcHRpb24gewotCQlhc3NlcnRUcnVlKHRoaXMuY29ubmVjdGlvblByb2ZpbGUuaXNJbmFjdGl2ZSgpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmlzRGlzY29ubmVjdGVkKCkpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmNvbm5lY3QoKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmlzQWN0aXZlKCkpOwotCQlhc3NlcnRUcnVlKHRoaXMuY29ubmVjdGlvblByb2ZpbGUuaXNDb25uZWN0ZWQoKSk7Ci0KLQkJdGhpcy52ZXJpZnlEYXRhYmFzZVZlcnNpb25OdW1iZXIoKTsKLQkJdGhpcy52ZXJpZnlEYXRhYmFzZVZlbmRvcigpOwotCQl0aGlzLnZlcmlmeURhdGFiYXNlQ29udGVudCgpOwotCi0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCQlhc3NlcnRUcnVlKHRoaXMuY29ubmVjdGlvblByb2ZpbGUuaXNJbmFjdGl2ZSgpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmlzRGlzY29ubmVjdGVkKCkpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlEYXRhYmFzZVZlcnNpb25OdW1iZXIoKSB7Ci0JCURhdGFiYXNlIGRhdGFiYXNlID0gdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5nZXREYXRhYmFzZSgpOwotCQlhc3NlcnROb3ROdWxsKGRhdGFiYXNlKTsKLQotCQlTdHJpbmcgYWN0dWFsID0gZGF0YWJhc2UuZ2V0VmVyc2lvbigpOwotCQlTdHJpbmcgZXhwZWN0ZWQgPSB0aGlzLmdldERhdGFiYXNlVmVyc2lvbigpOwotCQlTdHJpbmcgZXJyb3JNZXNzYWdlID0gImV4cGVjdGVkOiAiICsgZXhwZWN0ZWQgKyAiIC0gYWN0dWFsOiAiICsgYWN0dWFsOwotCQkvLyBwYXJ0aWFsIG1hdGNoIGlzIGdvb2QgZW5vdWdoCi0JCWFzc2VydFRydWUoZXJyb3JNZXNzYWdlLCBhY3R1YWwuaW5kZXhPZihleHBlY3RlZCkgIT0gLTEpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlEYXRhYmFzZVZlbmRvcigpIHsKLQkJRGF0YWJhc2UgZGF0YWJhc2UgPSB0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmdldERhdGFiYXNlKCk7Ci0JCVN0cmluZyBhY3R1YWwgPSBkYXRhYmFzZS5nZXRWZW5kb3JOYW1lKCk7Ci0JCVN0cmluZyBleHBlY3RlZCA9IHRoaXMuZ2V0RGF0YWJhc2VWZW5kb3IoKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBhY3R1YWwpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlEYXRhYmFzZUNvbnRlbnQoKSB7Ci0JCURhdGFiYXNlIGRhdGFiYXNlID0gdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5nZXREYXRhYmFzZSgpOwotCQlhc3NlcnRUcnVlKGRhdGFiYXNlLnNjaGVtYXRhU2l6ZSgpID49IDApOwotCi0JCVNjaGVtYSBzY2hlbWEgPSBkYXRhYmFzZS5nZXREZWZhdWx0U2NoZW1hKCk7Ci0JCWlmIChzY2hlbWEgIT0gbnVsbCkgewotCQkJaWYgKHNjaGVtYS50YWJsZXNTaXplKCkgPiAwKSB7Ci0JCQkJVGFibGUgdGFibGUgPSBzY2hlbWEudGFibGVzKCkubmV4dCgpOwotCQkJCWFzc2VydFRydWUodGFibGUuY29sdW1uc1NpemUoKSA+PSAwKTsKLQkJCQlhc3NlcnRUcnVlKHRhYmxlLnByaW1hcnlLZXlDb2x1bW5zU2l6ZSgpID49IDApOwotCQkJCWFzc2VydFRydWUodGFibGUuZm9yZWlnbktleXNTaXplKCkgPj0gMCk7Ci0JCQl9Ci0JCX0KLQl9Ci0KLQlwcm90ZWN0ZWQgYWJzdHJhY3QgYm9vbGVhbiBleGVjdXRlT2ZmbGluZVRlc3RzKCk7Ci0KLQlwdWJsaWMgZmluYWwgdm9pZCB0ZXN0T2ZmbGluZSgpIHsKLQkJaWYgKCAhIHRoaXMuZXhlY3V0ZU9mZmxpbmVUZXN0cygpKSB7Ci0JCQlyZXR1cm47Ci0JCX0KLQkJaWYgKCAhIHRoaXMuY29ubmVjdGlvblByb2ZpbGUuc3VwcG9ydHNXb3JrT2ZmbGluZU1vZGUoKSkgewotCQkJcmV0dXJuOwotCQl9Ci0KLQkJdGhpcy5wcmVwYXJlRm9yT2ZmbGluZVdvcmsoKTsKLQotCQlJU3RhdHVzIHN0YXR1cyA9IHRoaXMuY29ubmVjdGlvblByb2ZpbGUud29ya09mZmxpbmUoKTsKLQkJYXNzZXJ0VHJ1ZShzdGF0dXMuaXNPSygpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmlzQWN0aXZlKCkpOwotCQlhc3NlcnRUcnVlKHRoaXMuY29ubmVjdGlvblByb2ZpbGUuaXNXb3JraW5nT2ZmbGluZSgpKTsKLQotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmRpc2Nvbm5lY3QoKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmlzSW5hY3RpdmUoKSk7Ci0JCWFzc2VydFRydWUodGhpcy5jb25uZWN0aW9uUHJvZmlsZS5pc0Rpc2Nvbm5lY3RlZCgpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBwcmVwYXJlRm9yT2ZmbGluZVdvcmsoKSB7Ci0JCWlmICggISB0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmNhbldvcmtPZmZsaW5lKCkpIHsKLQkJCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpOwotCQkJSVN0YXR1cyBzdGF0dXMgPSB0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnNhdmVXb3JrT2ZmbGluZURhdGEoKTsKLQkJCWFzc2VydFRydWUoc3RhdHVzLmlzT0soKSk7Ci0JCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmRpc2Nvbm5lY3QoKTsKLQkJCWFzc2VydFRydWUodGhpcy5jb25uZWN0aW9uUHJvZmlsZS5jYW5Xb3JrT2ZmbGluZSgpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb25uZWN0aW9uTGlzdGVuZXJDb25uZWN0KCkgewotCQlhc3NlcnRUcnVlKHRoaXMuY29ubmVjdGlvblByb2ZpbGVIYXNOb0xpc3RlbmVycygpKTsKLQkJVGVzdENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBUZXN0Q29ubmVjdGlvbkxpc3RlbmVyKCk7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuYWRkQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmNvbm5lY3Rpb25Qcm9maWxlSGFzQW55TGlzdGVuZXJzKCkpOwotCi0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpOwotCQlhc3NlcnRTYW1lKHRoaXMuY29ubmVjdGlvblByb2ZpbGUsIGxpc3RlbmVyLm9wZW5lZFByb2ZpbGUpOwotCQlsaXN0ZW5lci5jbGVhcigpOwotCi0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCQlhc3NlcnRTYW1lKHRoaXMuY29ubmVjdGlvblByb2ZpbGUsIGxpc3RlbmVyLm9rVG9DbG9zZVByb2ZpbGUpOwotCQlhc3NlcnRTYW1lKHRoaXMuY29ubmVjdGlvblByb2ZpbGUsIGxpc3RlbmVyLmFib3V0VG9DbG9zZVByb2ZpbGUpOwotCQlhc3NlcnRTYW1lKHRoaXMuY29ubmVjdGlvblByb2ZpbGUsIGxpc3RlbmVyLmNsb3NlZFByb2ZpbGUpOwotCi0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUucmVtb3ZlQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmNvbm5lY3Rpb25Qcm9maWxlSGFzTm9MaXN0ZW5lcnMoKSk7Ci0JfQotCi0JcHVibGljIGZpbmFsIHZvaWQgdGVzdENvbm5lY3Rpb25MaXN0ZW5lck9mZmxpbmUoKSB7Ci0JCWlmICggISB0aGlzLmV4ZWN1dGVPZmZsaW5lVGVzdHMoKSkgewotCQkJcmV0dXJuOwotCQl9Ci0JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJdGhpcy5wcmVwYXJlRm9yT2ZmbGluZVdvcmsoKTsKLQkJbGlzdGVuZXIuY2xlYXIoKTsKLQotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLndvcmtPZmZsaW5lKCk7Ci0JCWFzc2VydFNhbWUodGhpcy5jb25uZWN0aW9uUHJvZmlsZSwgbGlzdGVuZXIub3BlbmVkUHJvZmlsZSk7Ci0JCWxpc3RlbmVyLmNsZWFyKCk7Ci0KLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5kaXNjb25uZWN0KCk7Ci0JCWFzc2VydFNhbWUodGhpcy5jb25uZWN0aW9uUHJvZmlsZSwgbGlzdGVuZXIub2tUb0Nsb3NlUHJvZmlsZSk7Ci0JCWFzc2VydFNhbWUodGhpcy5jb25uZWN0aW9uUHJvZmlsZSwgbGlzdGVuZXIuYWJvdXRUb0Nsb3NlUHJvZmlsZSk7Ci0JCWFzc2VydFNhbWUodGhpcy5jb25uZWN0aW9uUHJvZmlsZSwgbGlzdGVuZXIuY2xvc2VkUHJvZmlsZSk7Ci0JCWxpc3RlbmVyLmNsZWFyKCk7Ci0KLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5yZW1vdmVDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb25uZWN0aW9uTGlzdGVuZXJEYXRhYmFzZSgpIHsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5jb25uZWN0KCk7Ci0JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0JCWFzc2VydFNhbWUodGhpcy5jb25uZWN0aW9uUHJvZmlsZS5nZXREYXRhYmFzZSgpLCBsaXN0ZW5lci5jaGFuZ2VkRGF0YWJhc2UpOwotCi0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUucmVtb3ZlQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5kaXNjb25uZWN0KCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbm5lY3Rpb25MaXN0ZW5lckNhdGFsb2coKSB7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpOwotCQlpZiAoICEgdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5nZXREYXRhYmFzZSgpLnN1cHBvcnRzQ2F0YWxvZ3MoKSkgewotCQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5kaXNjb25uZWN0KCk7Ci0JCQlyZXR1cm47Ci0JCX0KLQkJCQotCQlUZXN0Q29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IFRlc3RDb25uZWN0aW9uTGlzdGVuZXIoKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5hZGRDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCi0JCS8vIHRha2UgdGhlIGZpcnN0IGNhdGFsb2cKLQkJb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLkNhdGFsb2cgZHRwQ2F0YWxvZyA9IHRoaXMuZ2V0Rmlyc3REVFBDYXRhbG9nKCk7Ci0JCUNhdGFsb2cgY2F0YWxvZyA9IHRoaXMuZ2V0Q2F0YWxvZ05hbWVkKGR0cENhdGFsb2cuZ2V0TmFtZSgpKTsKLQkJKChJQ2F0YWxvZ09iamVjdCkgZHRwQ2F0YWxvZykucmVmcmVzaCgpOwotCQlhc3NlcnRTYW1lKGNhdGFsb2csIGxpc3RlbmVyLmNoYW5nZWRDYXRhbG9nKTsKLQotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb25uZWN0aW9uTGlzdGVuZXJTY2hlbWEoKSB7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpOwotCQlUZXN0Q29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IFRlc3RDb25uZWN0aW9uTGlzdGVuZXIoKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5hZGRDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCi0JCUxpc3Q8b3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLkNhdGFsb2c+IGR0cENhdGFsb2dzID0gdGhpcy5nZXREVFBDYXRhbG9ncygpOwotCQlvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuQ2F0YWxvZyBkdHBDYXRhbG9nID0gbnVsbDsKLQkJb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLlNjaGVtYSBkdHBTY2hlbWEgPSBudWxsOwotCQlTY2hlbWEgc2NoZW1hID0gbnVsbDsKLQkJaWYgKHRoaXMuY29ubmVjdGlvblByb2ZpbGUuZ2V0RGF0YWJhc2UoKS5zdXBwb3J0c0NhdGFsb2dzKCkpIHsKLQkJCWR0cENhdGFsb2cgPSBkdHBDYXRhbG9ncy5nZXQoMCk7Ci0JCQlkdHBTY2hlbWEgPSAob3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLlNjaGVtYSkgZHRwQ2F0YWxvZy5nZXRTY2hlbWFzKCkuZ2V0KDApOwotCQkJc2NoZW1hID0gdGhpcy5nZXRDYXRhbG9nTmFtZWQoZHRwQ2F0YWxvZy5nZXROYW1lKCkpLmdldFNjaGVtYU5hbWVkKGR0cFNjaGVtYS5nZXROYW1lKCkpOwotCQl9IGVsc2UgewotCQkJaWYgKGR0cENhdGFsb2dzLmlzRW1wdHkoKSkgewotCQkJCWR0cFNjaGVtYSA9IChvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuU2NoZW1hKSB0aGlzLmdldERUUERhdGFiYXNlKCkuZ2V0U2NoZW1hcygpLmdldCgwKTsKLQkJCQlzY2hlbWEgPSB0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hTmFtZWQoZHRwU2NoZW1hLmdldE5hbWUoKSk7Ci0JCQl9IGVsc2UgewotCQkJCWR0cENhdGFsb2cgPSBkdHBDYXRhbG9ncy5nZXQoMCk7ICAvLyBzaG91bGQgYmUgdGhlICJ2aXJ0dWFsIiBjYXRhbG9nCi0JCQkJYXNzZXJ0RXF1YWxzKCIiLCBkdHBDYXRhbG9nLmdldE5hbWUoKSk7Ci0JCQkJZHRwU2NoZW1hID0gKG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5TY2hlbWEpIGR0cENhdGFsb2cuZ2V0U2NoZW1hcygpLmdldCgwKTsKLQkJCQkvLyB0aGUgc2NoZW1hdGEgYXJlIGhlbGQgZGlyZWN0bHkgYnkgdGhlIGRhdGFiYXNlIGluIHRoaXMgc2l0dWF0aW9uCi0JCQkJc2NoZW1hID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldFNjaGVtYU5hbWVkKGR0cFNjaGVtYS5nZXROYW1lKCkpOwotCQkJfQotCQl9Ci0JCWFzc2VydFRydWUoc2NoZW1hLnRhYmxlc1NpemUoKSA+PSAwKTsgIC8vIGZvcmNlIHRhYmxlcyB0byBiZSBsb2FkZWQKLQkJKChJQ2F0YWxvZ09iamVjdCkgZHRwU2NoZW1hKS5yZWZyZXNoKCk7Ci0JCWFzc2VydFNhbWUoc2NoZW1hLCBsaXN0ZW5lci5jaGFuZ2VkU2NoZW1hKTsKLQotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTdXBwb3J0c0NhdGFsb2dzKCkgewotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmNvbm5lY3QoKTsKLQkJVGVzdENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBUZXN0Q29ubmVjdGlvbkxpc3RlbmVyKCk7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuYWRkQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQotCQlib29sZWFuIHN1cHBvcnRzQ2F0YWxvZ3MgPSB0aGlzLnN1cHBvcnRzQ2F0YWxvZ3MoKTsKLQkJYXNzZXJ0RXF1YWxzKHN1cHBvcnRzQ2F0YWxvZ3MsIHRoaXMuY29ubmVjdGlvblByb2ZpbGUuZ2V0RGF0YWJhc2UoKS5zdXBwb3J0c0NhdGFsb2dzKCkpOwotCQlpZiAoc3VwcG9ydHNDYXRhbG9ncykgewotCQkJYXNzZXJ0VHJ1ZSh0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmdldERhdGFiYXNlKCkuY2F0YWxvZ3NTaXplKCkgPiAwKTsKLQkJCWFzc2VydEVxdWFscygwLCB0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmdldERhdGFiYXNlKCkuc2NoZW1hdGFTaXplKCkpOwotCQl9IGVsc2UgewotCQkJYXNzZXJ0RXF1YWxzKDAsIHRoaXMuY29ubmVjdGlvblByb2ZpbGUuZ2V0RGF0YWJhc2UoKS5jYXRhbG9nc1NpemUoKSk7Ci0JCQlhc3NlcnRUcnVlKHRoaXMuY29ubmVjdGlvblByb2ZpbGUuZ2V0RGF0YWJhc2UoKS5zY2hlbWF0YVNpemUoKSA+IDApOwotCQl9Ci0KLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5yZW1vdmVDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmRpc2Nvbm5lY3QoKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgYWJzdHJhY3QgYm9vbGVhbiBzdXBwb3J0c0NhdGFsb2dzKCk7Ci0KLS8vCXB1YmxpYyB2b2lkIHRlc3RERUJVRygpIHRocm93cyBFeGNlcHRpb24gewotLy8JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpOwotLy8JCXRoaXMuZHVtcEpEQkNDYXRhbG9ncygpOwotLy8JCXRoaXMuZHVtcEpEQkNTY2hlbWF0YSgpOwotLy8JCXRoaXMuZHVtcERhdGFiYXNlQ29udGFpbmVycygpOwotLy8JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotLy8JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbnZlbmllbmNlIG1ldGhvZHMgKioqKioqKioqKgotCi0JcHJvdGVjdGVkIENvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeSBnZXRDb25uZWN0aW9uUHJvZmlsZUZhY3RvcnkoKSB7Ci0JCXJldHVybiBKcHREYlBsdWdpbi5pbnN0YW5jZSgpLmdldENvbm5lY3Rpb25Qcm9maWxlRmFjdG9yeSgpOwotCX0KLQotCXByb3RlY3RlZCBDb25uZWN0aW9uUHJvZmlsZSBnZXRDb25uZWN0aW9uUHJvZmlsZSgpIHsKLQkJcmV0dXJuIHRoaXMuY29ubmVjdGlvblByb2ZpbGU7Ci0JfQotCi0JcHJvdGVjdGVkIERhdGFiYXNlIGdldERhdGFiYXNlKCkgewotCQlyZXR1cm4gdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5nZXREYXRhYmFzZSgpOwotCX0KLQotCXByb3RlY3RlZCBDYXRhbG9nIGdldERlZmF1bHRDYXRhbG9nKCkgewotCQlyZXR1cm4gdGhpcy5nZXREYXRhYmFzZSgpLmdldERlZmF1bHRDYXRhbG9nKCk7Ci0JfQotCi0JcHJvdGVjdGVkIENhdGFsb2cgZ2V0Q2F0YWxvZ05hbWVkKFN0cmluZyBjYXRhbG9nTmFtZSkgewotCQlyZXR1cm4gdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5nZXREYXRhYmFzZSgpLmdldENhdGFsb2dOYW1lZChjYXRhbG9nTmFtZSk7Ci0JfQotCi0JcHJvdGVjdGVkIFN0cmluZyBnZXRSZXF1aXJlZFBsYXRmb3JtUHJvcGVydHkoU3RyaW5nIHByb3BlcnR5S2V5KSB7Ci0JCVN0cmluZyBwcm9wZXJ0eVZhbHVlID0gdGhpcy5wbGF0Zm9ybVByb3BlcnRpZXMuZ2V0UHJvcGVydHkocHJvcGVydHlLZXkpOwotCQlpZiAoU3RyaW5nVG9vbHMuc3RyaW5nSXNFbXB0eShwcm9wZXJ0eVZhbHVlKSkgewotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiVGhlIGRhdGFiYXNlIHBsYXRmb3JtIHByb3BlcnRpZXMgZmlsZSAnIiArIHRoaXMuZ2V0UGxhdGZvcm1Qcm9wZXJ0aWVzRmlsZVBhdGgoKQotCQkJCQkrICInIGlzIG1pc3NpbmcgYSB2YWx1ZSBmb3IgdGhlIHByb3BlcnR5ICciICsgcHJvcGVydHlLZXkgKyAiJy4iKTsKLQkJfQotCQlyZXR1cm4gcHJvcGVydHlWYWx1ZTsKLQl9Ci0KLQlwcm90ZWN0ZWQgYm9vbGVhbiBjb25uZWN0aW9uUHJvZmlsZUhhc0FueUxpc3RlbmVycygpIHsKLQkJcmV0dXJuIGNvbm5lY3Rpb25Qcm9maWxlSGFzQW55TGlzdGVuZXJzKHRoaXMuY29ubmVjdGlvblByb2ZpbGUpOwotCX0KLQotCXByb3RlY3RlZCBzdGF0aWMgYm9vbGVhbiBjb25uZWN0aW9uUHJvZmlsZUhhc0FueUxpc3RlbmVycyhDb25uZWN0aW9uUHJvZmlsZSBjcCkgewotCQlyZXR1cm4gKChCb29sZWFuKSBDbGFzc1Rvb2xzLmV4ZWN1dGVNZXRob2QoY3AsICJoYXNBbnlMaXN0ZW5lcnMiKSkuYm9vbGVhblZhbHVlKCk7Ci0JfQotCi0JcHJvdGVjdGVkIGJvb2xlYW4gY29ubmVjdGlvblByb2ZpbGVIYXNOb0xpc3RlbmVycygpIHsKLQkJcmV0dXJuIGNvbm5lY3Rpb25Qcm9maWxlSGFzTm9MaXN0ZW5lcnModGhpcy5jb25uZWN0aW9uUHJvZmlsZSk7Ci0JfQotCi0JcHJvdGVjdGVkIHN0YXRpYyBib29sZWFuIGNvbm5lY3Rpb25Qcm9maWxlSGFzTm9MaXN0ZW5lcnMoQ29ubmVjdGlvblByb2ZpbGUgY3ApIHsKLQkJcmV0dXJuICgoQm9vbGVhbikgQ2xhc3NUb29scy5leGVjdXRlTWV0aG9kKGNwLCAiaGFzTm9MaXN0ZW5lcnMiKSkuYm9vbGVhblZhbHVlKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIERUUCBtb2RlbCAqKioqKioqKioqCi0KLQlwcm90ZWN0ZWQgUHJvZmlsZU1hbmFnZXIgZ2V0RFRQUHJvZmlsZU1hbmFnZXIoKSB7Ci0JCXJldHVybiBQcm9maWxlTWFuYWdlci5nZXRJbnN0YW5jZSgpOwotCX0KLQotCXByb3RlY3RlZCBJQ29ubmVjdGlvblByb2ZpbGUgZ2V0RFRQQ29ubmVjdGlvblByb2ZpbGUoKSB7Ci0JCXJldHVybiBnZXREVFBDb25uZWN0aW9uUHJvZmlsZSh0aGlzLmNvbm5lY3Rpb25Qcm9maWxlKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgc3RhdGljIElDb25uZWN0aW9uUHJvZmlsZSBnZXREVFBDb25uZWN0aW9uUHJvZmlsZShDb25uZWN0aW9uUHJvZmlsZSBjcCkgewotCQlyZXR1cm4gKElDb25uZWN0aW9uUHJvZmlsZSkgQ2xhc3NUb29scy5maWVsZFZhbHVlKGNwLCAiZHRwQ29ubmVjdGlvblByb2ZpbGUiKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgSU1hbmFnZWRDb25uZWN0aW9uIGdldERUUE1hbmFnZWRDb25uZWN0aW9uKCkgewotCQlyZXR1cm4gKElNYW5hZ2VkQ29ubmVjdGlvbikgQ2xhc3NUb29scy5maWVsZFZhbHVlKHRoaXMuY29ubmVjdGlvblByb2ZpbGUsICJkdHBNYW5hZ2VkQ29ubmVjdGlvbiIpOwotCX0KLQotCXByb3RlY3RlZCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuRGF0YWJhc2UgZ2V0RFRQRGF0YWJhc2UoKSB7Ci0JCXJldHVybiBnZXREVFBEYXRhYmFzZSh0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmdldERhdGFiYXNlKCkpOwotCX0KLQotCXByb3RlY3RlZCBzdGF0aWMgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLkRhdGFiYXNlIGdldERUUERhdGFiYXNlKERhdGFiYXNlIGRhdGFiYXNlKSB7Ci0JCXJldHVybiAob3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLkRhdGFiYXNlKSBDbGFzc1Rvb2xzLmZpZWxkVmFsdWUoZGF0YWJhc2UsICJkdHBEYXRhYmFzZSIpOwotCX0KLQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByb3RlY3RlZCBMaXN0PG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5DYXRhbG9nPiBnZXREVFBDYXRhbG9ncygpIHsKLQkJcmV0dXJuIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKS5nZXRDYXRhbG9ncygpOwotCX0KLQotCXByb3RlY3RlZCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuQ2F0YWxvZyBnZXRGaXJzdERUUENhdGFsb2coKSB7Ci0JCXJldHVybiB0aGlzLmdldERUUENhdGFsb2dzKCkuZ2V0KDApOwotCX0KLQotCXByb3RlY3RlZCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuQ2F0YWxvZyBnZXREVFBDYXRhbG9nTmFtZWQoU3RyaW5nIG5hbWUpIHsKLQkJcmV0dXJuIGdldERUUENhdGFsb2codGhpcy5nZXREYXRhYmFzZSgpLmdldENhdGFsb2dOYW1lZChuYW1lKSk7Ci0JfQotCi0JcHJvdGVjdGVkIHN0YXRpYyBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuQ2F0YWxvZyBnZXREVFBDYXRhbG9nKENhdGFsb2cgY2F0YWxvZykgewotCQlyZXR1cm4gKG9yZy5lY2xpcHNlLmRhdGF0b29scy5tb2RlbGJhc2Uuc3FsLnNjaGVtYS5DYXRhbG9nKSBDbGFzc1Rvb2xzLmZpZWxkVmFsdWUoY2F0YWxvZywgImR0cENhdGFsb2ciKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLlNjaGVtYSBnZXREVFBTY2hlbWFOYW1lZChTdHJpbmcgbmFtZSkgewotCQlyZXR1cm4gZ2V0RFRQU2NoZW1hKHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRTY2hlbWFOYW1lZChuYW1lKSk7Ci0JfQotCi0JcHJvdGVjdGVkIHN0YXRpYyBvcmcuZWNsaXBzZS5kYXRhdG9vbHMubW9kZWxiYXNlLnNxbC5zY2hlbWEuU2NoZW1hIGdldERUUFNjaGVtYShTY2hlbWEgc2NoZW1hKSB7Ci0JCXJldHVybiAob3JnLmVjbGlwc2UuZGF0YXRvb2xzLm1vZGVsYmFzZS5zcWwuc2NoZW1hLlNjaGVtYSkgQ2xhc3NUb29scy5maWVsZFZhbHVlKHNjaGVtYSwgImR0cFNjaGVtYSIpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBleGVjdXRlIFNRTCAqKioqKioqKioqCi0KLQkvKioKLQkgKiBpZ25vcmUgYW55IGVycm9ycyAodXNlZnVsIGZvciBkcm9wcGluZyBkYXRhYmFzZSBvYmplY3RzIHRoYXQgbWlnaHQKLQkgKiBub3QgYmUgdGhlcmUpCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgZXhlY3V0ZVVwZGF0ZUlnbm9yZUVycm9ycyhTdHJpbmcgc3FsKSB7Ci0JCXRyeSB7Ci0JCQl0aGlzLmV4ZWN1dGVVcGRhdGUoc3FsKTsKLQkJfSBjYXRjaCAoRXhjZXB0aW9uIGV4KSB7Ci0vLwkJCVN5c3RlbS5lcnIucHJpbnRsbigiU1FMOiAiICsgc3FsKTsKLS8vCQkJZXgucHJpbnRTdGFja1RyYWNlKCk7Ci0JCX0KLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBleGVjdXRlVXBkYXRlKFN0cmluZyBzcWwpIHRocm93cyBTUUxFeGNlcHRpb24gewotCQlTdGF0ZW1lbnQgamRiY1N0YXRlbWVudCA9IHRoaXMuY3JlYXRlSkRCQ1N0YXRlbWVudCgpOwotCQl0cnkgewotCQkJamRiY1N0YXRlbWVudC5leGVjdXRlVXBkYXRlKHNxbCk7Ci0JCX0gZmluYWxseSB7Ci0JCQlqZGJjU3RhdGVtZW50LmNsb3NlKCk7Ci0JCX0KLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBkdW1wKFN0cmluZyBzcWwpIHRocm93cyBTUUxFeGNlcHRpb24gewotCQl0aGlzLmR1bXAoc3FsLCAyMCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZHVtcChTdHJpbmcgc3FsLCBpbnQgY29sdW1uV2lkdGgpIHRocm93cyBTUUxFeGNlcHRpb24gewotCQlJbmRlbnRpbmdQcmludFdyaXRlciBwdyA9IG5ldyBJbmRlbnRpbmdQcmludFdyaXRlcihuZXcgT3V0cHV0U3RyZWFtV3JpdGVyKFN5c3RlbS5vdXQpKTsKLQkJLy8gc3luY2hyb25pemUgdGhlIGNvbnNvbGUgc28gZXZlcnl0aGluZyBpcyBjb250aWd1b3VzCi0JCXN5bmNocm9uaXplZCAoU3lzdGVtLm91dCkgewotCQkJdGhpcy5kdW1wT24oc3FsLCBwdywgY29sdW1uV2lkdGgpOwotCQl9Ci0JCXB3LmZsdXNoKCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZHVtcE9uKFN0cmluZyBzcWwsIEluZGVudGluZ1ByaW50V3JpdGVyIHB3LCBpbnQgY29sdW1uV2lkdGgpIHRocm93cyBTUUxFeGNlcHRpb24gewotCQlwdy5wcmludGxuKHNxbCk7Ci0JCWZvciAoQXJyYXlMaXN0PE9iamVjdD4gcm93IDogdGhpcy5leGVjdXRlKHNxbCkpIHsKLQkJCWZvciAoT2JqZWN0IGNvbHVtblZhbHVlIDogcm93KSB7Ci0JCQkJU3RyaW5nVG9vbHMucGFkT3JUcnVuY2F0ZU9uKFN0cmluZy52YWx1ZU9mKGNvbHVtblZhbHVlKSwgY29sdW1uV2lkdGgsIHB3KTsKLQkJCQlwdy5wcmludCgnICcpOwotCQkJfQotCQkJcHcucHJpbnRsbigpOwotCQl9Ci0JfQotCi0JcHJvdGVjdGVkIEFycmF5TGlzdDxBcnJheUxpc3Q8T2JqZWN0Pj4gZXhlY3V0ZShTdHJpbmcgc3FsKSB0aHJvd3MgU1FMRXhjZXB0aW9uIHsKLQkJU3RhdGVtZW50IGpkYmNTdGF0ZW1lbnQgPSB0aGlzLmNyZWF0ZUpEQkNTdGF0ZW1lbnQoKTsKLQkJamRiY1N0YXRlbWVudC5leGVjdXRlKHNxbCk7Ci0JCUFycmF5TGlzdDxBcnJheUxpc3Q8T2JqZWN0Pj4gcm93cyA9IHRoaXMuYnVpbGRSb3dzKGpkYmNTdGF0ZW1lbnQuZ2V0UmVzdWx0U2V0KCkpOwotCQlqZGJjU3RhdGVtZW50LmNsb3NlKCk7Ci0JCXJldHVybiByb3dzOwotCX0KLQotCXByb3RlY3RlZCBBcnJheUxpc3Q8QXJyYXlMaXN0PE9iamVjdD4+IGJ1aWxkUm93cyhSZXN1bHRTZXQgcmVzdWx0U2V0KSB0aHJvd3MgU1FMRXhjZXB0aW9uIHsKLQkJQXJyYXlMaXN0PEFycmF5TGlzdDxPYmplY3Q+PiByb3dzID0gbmV3IEFycmF5TGlzdDxBcnJheUxpc3Q8T2JqZWN0Pj4oKTsKLQkJZm9yIChJdGVyYXRvcjxBcnJheUxpc3Q8T2JqZWN0Pj4gc3RyZWFtID0gdGhpcy5idWlsZEFycmF5SXRlcmF0b3IocmVzdWx0U2V0KTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQlyb3dzLmFkZChzdHJlYW0ubmV4dCgpKTsKLQkJfQotCQlyZXR1cm4gcm93czsKLQl9Ci0KLQlwcm90ZWN0ZWQgSXRlcmF0b3I8QXJyYXlMaXN0PE9iamVjdD4+IGJ1aWxkQXJyYXlJdGVyYXRvcihSZXN1bHRTZXQgcmVzdWx0U2V0KSB0aHJvd3MgU1FMRXhjZXB0aW9uIHsKLQkJcmV0dXJuIG5ldyBSZXN1bHRTZXRJdGVyYXRvcjxBcnJheUxpc3Q8T2JqZWN0Pj4ocmVzdWx0U2V0LCBuZXcgTGlzdFJlc3VsdFNldEl0ZXJhdG9yQWRhcHRlcihyZXN1bHRTZXQuZ2V0TWV0YURhdGEoKS5nZXRDb2x1bW5Db3VudCgpKSk7Ci0JfQotCi0JcHVibGljIHN0YXRpYyBjbGFzcyBMaXN0UmVzdWx0U2V0SXRlcmF0b3JBZGFwdGVyIGltcGxlbWVudHMgUmVzdWx0U2V0SXRlcmF0b3IuQWRhcHRlcjxBcnJheUxpc3Q8T2JqZWN0Pj4gewotCQlwcml2YXRlIGZpbmFsIGludCBjb2x1bW5Db3VudDsKLQkJcHVibGljIExpc3RSZXN1bHRTZXRJdGVyYXRvckFkYXB0ZXIoaW50IGNvbHVtbkNvdW50KSB7Ci0JCQlzdXBlcigpOwotCQkJdGhpcy5jb2x1bW5Db3VudCA9IGNvbHVtbkNvdW50OwotCQl9Ci0JCXB1YmxpYyBBcnJheUxpc3Q8T2JqZWN0PiBidWlsZE5leHQoUmVzdWx0U2V0IHJzKSB0aHJvd3MgU1FMRXhjZXB0aW9uIHsKLQkJCUFycmF5TGlzdDxPYmplY3Q+IGxpc3QgPSBuZXcgQXJyYXlMaXN0PE9iamVjdD4odGhpcy5jb2x1bW5Db3VudCk7Ci0JCQlmb3IgKGludCBpID0gMTsgaSA8PSB0aGlzLmNvbHVtbkNvdW50OyBpKyspIHsgIC8vIE5COiBSZXN1bHRTZXQgaW5kZXgvc3Vic2NyaXB0IGlzIDEtYmFzZWQKLQkJCQlsaXN0LmFkZChycy5nZXRPYmplY3QoaSkpOwotCQkJfQotCQkJcmV0dXJuIGxpc3Q7Ci0JCX0KLQl9Ci0KLQlwcm90ZWN0ZWQgU3RhdGVtZW50IGNyZWF0ZUpEQkNTdGF0ZW1lbnQoKSB0aHJvd3MgU1FMRXhjZXB0aW9uIHsKLQkJcmV0dXJuIHRoaXMuZ2V0SkRCQ0Nvbm5lY3Rpb24oKS5jcmVhdGVTdGF0ZW1lbnQoKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgQ29ubmVjdGlvbiBnZXRKREJDQ29ubmVjdGlvbigpIHsKLQkJcmV0dXJuICgoQ29ubmVjdGlvbkluZm8pIHRoaXMuZ2V0RFRQTWFuYWdlZENvbm5lY3Rpb24oKS5nZXRDb25uZWN0aW9uKCkuZ2V0UmF3Q29ubmVjdGlvbigpKS5nZXRTaGFyZWRDb25uZWN0aW9uKCk7Ci0JfQotCi0JcHJvdGVjdGVkIERhdGFiYXNlTWV0YURhdGEgZ2V0RGF0YWJhc2VNZXRhRGF0YSgpIHRocm93cyBTUUxFeGNlcHRpb24gewotCQlyZXR1cm4gdGhpcy5nZXRKREJDQ29ubmVjdGlvbigpLmdldE1ldGFEYXRhKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGR1bXAgRFRQIG1ldGFkYXRhICoqKioqKioqKioKLQotCS8qKgotCSAqIGR1bXAgYWxsIHRoZSBkYXRhYmFzZSBtZXRhZGF0YSB0byB0aGUgY29uc29sZQotCSAqLwotCXByb3RlY3RlZCB2b2lkIGR1bXBEYXRhYmFzZSgpIHsKLQkJdGhpcy5kdW1wRGF0YWJhc2UodHJ1ZSk7Ci0JfQotCi0JLyoqCi0JICogZHVtcCB0aGUgZGF0YWJhc2UgY2F0YWxvZ3MgYW5kIHNjaGVtYXRhIHRvIHRoZSBjb25zb2xlCi0JICovCi0JcHJvdGVjdGVkIHZvaWQgZHVtcERhdGFiYXNlQ29udGFpbmVycygpIHsKLQkJdGhpcy5kdW1wRGF0YWJhc2UoZmFsc2UpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGR1bXBEYXRhYmFzZShib29sZWFuIGRlZXApIHsKLQkJSW5kZW50aW5nUHJpbnRXcml0ZXIgcHcgPSBuZXcgSW5kZW50aW5nUHJpbnRXcml0ZXIobmV3IE91dHB1dFN0cmVhbVdyaXRlcihTeXN0ZW0ub3V0KSk7Ci0JCS8vIHN5bmNocm9uaXplIHRoZSBjb25zb2xlIHNvIGV2ZXJ5dGhpbmcgaXMgY29udGlndW91cwotCQlzeW5jaHJvbml6ZWQgKFN5c3RlbS5vdXQpIHsKLQkJCXRoaXMuZHVtcERhdGFiYXNlT24ocHcsIGRlZXApOwotCQl9Ci0JCXB3LmZsdXNoKCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZHVtcERhdGFiYXNlT24oSW5kZW50aW5nUHJpbnRXcml0ZXIgcHcsIGJvb2xlYW4gZGVlcCkgewotCQlEYXRhYmFzZSBkYXRhYmFzZSA9IHRoaXMuY29ubmVjdGlvblByb2ZpbGUuZ2V0RGF0YWJhc2UoKTsKLQkJcHcucHJpbnQoImRhdGFiYXNlOiAiKTsKLQkJcHcucHJpbnRsbihkYXRhYmFzZS5nZXROYW1lKCkpOwotCQlpZiAoZGF0YWJhc2Uuc3VwcG9ydHNDYXRhbG9ncygpKSB7Ci0JCQlmb3IgKEl0ZXJhdG9yPENhdGFsb2c+IHN0cmVhbSA9IGRhdGFiYXNlLmNhdGFsb2dzKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJCXRoaXMuZHVtcENhdGFsb2dPbihzdHJlYW0ubmV4dCgpLCBwdywgZGVlcCk7Ci0JCQl9Ci0JCX0gZWxzZSB7Ci0JCQl0aGlzLmR1bXBTY2hlbWFDb250YWluZXJPbihkYXRhYmFzZSwgcHcsIGRlZXApOwotCQl9Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZHVtcENhdGFsb2dPbihDYXRhbG9nIGNhdGFsb2csIEluZGVudGluZ1ByaW50V3JpdGVyIHB3LCBib29sZWFuIGRlZXApIHsKLQkJcHcucHJpbnQoImNhdGFsb2c6ICIpOwotCQlwdy5wcmludGxuKGNhdGFsb2cuZ2V0TmFtZSgpKTsKLQkJcHcuaW5kZW50KCk7Ci0JCQl0aGlzLmR1bXBTY2hlbWFDb250YWluZXJPbihjYXRhbG9nLCBwdywgZGVlcCk7Ci0JCXB3LnVuZGVudCgpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGR1bXBTY2hlbWFDb250YWluZXJPbihTY2hlbWFDb250YWluZXIgc2NoZW1hQ29udGFpbmVyLCBJbmRlbnRpbmdQcmludFdyaXRlciBwdywgYm9vbGVhbiBkZWVwKSB7Ci0JCWZvciAoSXRlcmF0b3I8U2NoZW1hPiBzdHJlYW0gPSBzY2hlbWFDb250YWluZXIuc2NoZW1hdGEoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQl0aGlzLmR1bXBTY2hlbWFPbihzdHJlYW0ubmV4dCgpLCBwdywgZGVlcCk7Ci0JCX0KLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBkdW1wU2NoZW1hKFNjaGVtYSBzY2hlbWEpIHsKLQkJdGhpcy5kdW1wU2NoZW1hKHNjaGVtYSwgdHJ1ZSk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZHVtcFNjaGVtYShTY2hlbWEgc2NoZW1hLCBib29sZWFuIGRlZXApIHsKLQkJSW5kZW50aW5nUHJpbnRXcml0ZXIgcHcgPSBuZXcgSW5kZW50aW5nUHJpbnRXcml0ZXIobmV3IE91dHB1dFN0cmVhbVdyaXRlcihTeXN0ZW0ub3V0KSk7Ci0JCS8vIHN5bmNocm9uaXplIHRoZSBjb25zb2xlIHNvIGV2ZXJ5dGhpbmcgaXMgY29udGlndW91cwotCQlzeW5jaHJvbml6ZWQgKFN5c3RlbS5vdXQpIHsKLQkJCXRoaXMuZHVtcFNjaGVtYU9uKHNjaGVtYSwgcHcsIGRlZXApOwotCQl9Ci0JCXB3LmZsdXNoKCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZHVtcFNjaGVtYU9uKFNjaGVtYSBzY2hlbWEsIEluZGVudGluZ1ByaW50V3JpdGVyIHB3LCBib29sZWFuIGRlZXApIHsKLQkJcHcucHJpbnQoInNjaGVtYTogIik7Ci0JCXB3LnByaW50bG4oc2NoZW1hLmdldE5hbWUoKSk7Ci0JCWlmIChkZWVwKSB7Ci0JCQlwdy5pbmRlbnQoKTsKLQkJCQlmb3IgKEl0ZXJhdG9yPFRhYmxlPiBzdHJlYW0gPSBzY2hlbWEudGFibGVzKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJCQl0aGlzLmR1bXBUYWJsZU9uKHN0cmVhbS5uZXh0KCksIHB3KTsKLQkJCQl9Ci0JCQkJZm9yIChJdGVyYXRvcjxTZXF1ZW5jZT4gc3RyZWFtID0gc2NoZW1hLnNlcXVlbmNlcygpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCQkJdGhpcy5kdW1wU2VxdWVuY2VPbihzdHJlYW0ubmV4dCgpLCBwdyk7Ci0JCQkJfQotCQkJcHcudW5kZW50KCk7Ci0JCX0KLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBkdW1wVGFibGVPbihUYWJsZSB0YWJsZSwgSW5kZW50aW5nUHJpbnRXcml0ZXIgcHcpIHsKLQkJcHcucHJpbnQoInRhYmxlOiAiKTsKLQkJcHcucHJpbnRsbih0YWJsZS5nZXROYW1lKCkpOwotCQlwdy5pbmRlbnQoKTsKLQkJCWZvciAoSXRlcmF0b3I8Q29sdW1uPiBzdHJlYW0gPSB0YWJsZS5jb2x1bW5zKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJCXRoaXMuZHVtcENvbHVtbk9uKHN0cmVhbS5uZXh0KCksIHB3KTsKLQkJCX0KLQkJCWZvciAoSXRlcmF0b3I8Rm9yZWlnbktleT4gc3RyZWFtID0gdGFibGUuZm9yZWlnbktleXMoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQkJdGhpcy5kdW1wRm9yZWlnbktleU9uKHN0cmVhbS5uZXh0KCksIHB3KTsKLQkJCX0KLQkJcHcudW5kZW50KCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZHVtcENvbHVtbk9uKENvbHVtbiBjb2x1bW4sIEluZGVudGluZ1ByaW50V3JpdGVyIHB3KSB7Ci0JCXB3LnByaW50KCJjb2x1bW46ICIpOwotCQlwdy5wcmludChjb2x1bW4uZ2V0TmFtZSgpKTsKLQkJcHcucHJpbnQoIiA6ICIpOwotCQlwdy5wcmludChjb2x1bW4uZ2V0RGF0YVR5cGVOYW1lKCkpOwotCQlpZiAoY29sdW1uLmlzUGFydE9mUHJpbWFyeUtleSgpKSB7Ci0JCQlwdy5wcmludCgiIFtwcmltYXJ5IGtleV0iKTsKLQkJfQotCQlwdy5wcmludGxuKCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZHVtcEZvcmVpZ25LZXlPbihGb3JlaWduS2V5IGZvcmVpZ25LZXksIEluZGVudGluZ1ByaW50V3JpdGVyIHB3KSB7Ci0JCXB3LnByaW50KCJmb3JlaWduIGtleTogIik7Ci0JCXB3LnByaW50KGZvcmVpZ25LZXkuZ2V0TmFtZSgpKTsKLQkJcHcucHJpbnQoIj0+Iik7Ci0JCXB3LnByaW50KGZvcmVpZ25LZXkuZ2V0UmVmZXJlbmNlZFRhYmxlKCkuZ2V0TmFtZSgpKTsKLQkJcHcucHJpbnQoIiAoIik7Ci0JCWZvciAoSXRlcmF0b3I8Q29sdW1uUGFpcj4gc3RyZWFtID0gZm9yZWlnbktleS5jb2x1bW5QYWlycygpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCUNvbHVtblBhaXIgY3AgPSBzdHJlYW0ubmV4dCgpOwotCQkJcHcucHJpbnQoY3AuZ2V0QmFzZUNvbHVtbigpLmdldE5hbWUoKSk7Ci0JCQlwdy5wcmludCgiPT4iKTsKLQkJCXB3LnByaW50KGNwLmdldFJlZmVyZW5jZWRDb2x1bW4oKS5nZXROYW1lKCkpOwotCQkJaWYgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCQlwdy5wcmludCgiLCAiKTsKLQkJCX0KLQkJfQotCQlwdy5wcmludCgnKScpOwotCQlwdy5wcmludGxuKCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZHVtcFNlcXVlbmNlT24oU2VxdWVuY2Ugc2VxdWVuY2UsIEluZGVudGluZ1ByaW50V3JpdGVyIHB3KSB7Ci0JCXB3LnByaW50KCJzZXF1ZW5jZTogIik7Ci0JCXB3LnByaW50bG4oc2VxdWVuY2UuZ2V0TmFtZSgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogZHVtcCBKREJDIG1ldGFkYXRhICoqKioqKioqKioKLQotCXByb3RlY3RlZCB2b2lkIGR1bXBKREJDQ2F0YWxvZ3MoKSB0aHJvd3MgU1FMRXhjZXB0aW9uIHsKLQkJSW5kZW50aW5nUHJpbnRXcml0ZXIgcHcgPSBuZXcgSW5kZW50aW5nUHJpbnRXcml0ZXIobmV3IE91dHB1dFN0cmVhbVdyaXRlcihTeXN0ZW0ub3V0KSk7Ci0JCS8vIHN5bmNocm9uaXplIHRoZSBjb25zb2xlIHNvIGV2ZXJ5dGhpbmcgaXMgY29udGlndW91cwotCQlzeW5jaHJvbml6ZWQgKFN5c3RlbS5vdXQpIHsKLQkJCXRoaXMuZHVtcEpEQkNDYXRhbG9nc09uKHB3KTsKLQkJfQotCQlwdy5mbHVzaCgpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGR1bXBKREJDQ2F0YWxvZ3NPbihJbmRlbnRpbmdQcmludFdyaXRlciBwdykgdGhyb3dzIFNRTEV4Y2VwdGlvbiB7Ci0JCXB3LnByaW50bG4oIkpEQkMgY2F0YWxvZ3M6ICIpOwotCQlwdy5pbmRlbnQoKTsKLQkJCUFycmF5TGlzdDxBcnJheUxpc3Q8T2JqZWN0Pj4gcm93cyA9IHRoaXMuYnVpbGRSb3dzKHRoaXMuZ2V0RGF0YWJhc2VNZXRhRGF0YSgpLmdldENhdGFsb2dzKCkpOwotCQkJZm9yIChJdGVyYXRvcjxBcnJheUxpc3Q8T2JqZWN0Pj4gc3RyZWFtID0gcm93cy5pdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCQlwdy5wcmludGxuKHN0cmVhbS5uZXh0KCkuZ2V0KDApKTsKLQkJCX0KLQkJcHcudW5kZW50KCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZHVtcEpEQkNTY2hlbWF0YSgpIHRocm93cyBTUUxFeGNlcHRpb24gewotCQlJbmRlbnRpbmdQcmludFdyaXRlciBwdyA9IG5ldyBJbmRlbnRpbmdQcmludFdyaXRlcihuZXcgT3V0cHV0U3RyZWFtV3JpdGVyKFN5c3RlbS5vdXQpKTsKLQkJLy8gc3luY2hyb25pemUgdGhlIGNvbnNvbGUgc28gZXZlcnl0aGluZyBpcyBjb250aWd1b3VzCi0JCXN5bmNocm9uaXplZCAoU3lzdGVtLm91dCkgewotCQkJdGhpcy5kdW1wSkRCQ1NjaGVtYXRhT24ocHcpOwotCQl9Ci0JCXB3LmZsdXNoKCk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgZHVtcEpEQkNTY2hlbWF0YU9uKEluZGVudGluZ1ByaW50V3JpdGVyIHB3KSB0aHJvd3MgU1FMRXhjZXB0aW9uIHsKLQkJcHcucHJpbnRsbigiSkRCQyBzY2hlbWF0YTogIik7Ci0JCXB3LmluZGVudCgpOwotCQkJQXJyYXlMaXN0PEFycmF5TGlzdDxPYmplY3Q+PiByb3dzID0gdGhpcy5idWlsZFJvd3ModGhpcy5nZXREYXRhYmFzZU1ldGFEYXRhKCkuZ2V0U2NoZW1hcygpKTsKLQkJCWZvciAoQXJyYXlMaXN0PE9iamVjdD4gcm93IDogcm93cykgewotCQkJCWlmIChyb3cuc2l6ZSgpID09IDIpIHsgIC8vIGNhdGFsb2dzIHdlcmUgYWRkZWQgaW4gamRrIDEuNAotCQkJCQlPYmplY3QgY2F0YWxvZyA9IHJvdy5nZXQoMSk7Ci0JCQkJCXB3LnByaW50KGNhdGFsb2cpOwotCQkJCQlwdy5wcmludCgnLicpOwotCQkJCX0KLQkJCQlPYmplY3Qgc2NoZW1hID0gcm93LmdldCgwKTsKLQkJCQlwdy5wcmludGxuKHNjaGVtYSk7Ci0JCQl9Ci0JCXB3LnVuZGVudCgpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBjb25uZWN0aW9uIHByb2ZpbGUgbGlzdGVuZXIgKioqKioqKioqKgotCi0JcHJvdGVjdGVkIHN0YXRpYyBjbGFzcyBUZXN0Q29ubmVjdGlvblByb2ZpbGVMaXN0ZW5lciBpbXBsZW1lbnRzIENvbm5lY3Rpb25Qcm9maWxlTGlzdGVuZXIgewotCQlwdWJsaWMgU3RyaW5nIGFkZGVkTmFtZTsKLQkJcHVibGljIFN0cmluZyByZW1vdmVkTmFtZTsKLQkJcHVibGljIFN0cmluZyByZW5hbWVkT2xkTmFtZTsKLQkJcHVibGljIFN0cmluZyByZW5hbWVkTmV3TmFtZTsKLQotCQlwdWJsaWMgdm9pZCBjb25uZWN0aW9uUHJvZmlsZUFkZGVkKFN0cmluZyBuYW1lKSB7Ci0JCQl0aGlzLmFkZGVkTmFtZSA9IG5hbWU7Ci0JCX0KLQkJcHVibGljIHZvaWQgY29ubmVjdGlvblByb2ZpbGVSZW1vdmVkKFN0cmluZyBuYW1lKSB7Ci0JCQl0aGlzLnJlbW92ZWROYW1lID0gbmFtZTsKLQkJfQotCQlwdWJsaWMgdm9pZCBjb25uZWN0aW9uUHJvZmlsZVJlbmFtZWQoU3RyaW5nIG9sZE5hbWUsIFN0cmluZyBuZXdOYW1lKSB7Ci0JCQl0aGlzLnJlbmFtZWRPbGROYW1lID0gb2xkTmFtZTsKLQkJCXRoaXMucmVuYW1lZE5ld05hbWUgPSBuZXdOYW1lOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGNsZWFyKCkgewotCQkJdGhpcy5hZGRlZE5hbWUgPSBudWxsOwotCQkJdGhpcy5yZW1vdmVkTmFtZSA9IG51bGw7Ci0JCQl0aGlzLnJlbmFtZWRPbGROYW1lID0gbnVsbDsKLQkJCXRoaXMucmVuYW1lZE5ld05hbWUgPSBudWxsOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNvbm5lY3Rpb24gbGlzdGVuZXIgKioqKioqKioqKgotCi0JcHJvdGVjdGVkIHN0YXRpYyBjbGFzcyBUZXN0Q29ubmVjdGlvbkxpc3RlbmVyIGltcGxlbWVudHMgQ29ubmVjdGlvbkxpc3RlbmVyIHsKLQkJcHVibGljIENvbm5lY3Rpb25Qcm9maWxlIG9wZW5lZFByb2ZpbGU7Ci0JCXB1YmxpYyBDb25uZWN0aW9uUHJvZmlsZSBtb2RpZmllZFByb2ZpbGU7Ci0JCXB1YmxpYyBDb25uZWN0aW9uUHJvZmlsZSBva1RvQ2xvc2VQcm9maWxlOwotCQlwdWJsaWMgQ29ubmVjdGlvblByb2ZpbGUgYWJvdXRUb0Nsb3NlUHJvZmlsZTsKLQkJcHVibGljIENvbm5lY3Rpb25Qcm9maWxlIGNsb3NlZFByb2ZpbGU7Ci0JCXB1YmxpYyBEYXRhYmFzZSBjaGFuZ2VkRGF0YWJhc2U7Ci0JCXB1YmxpYyBDYXRhbG9nIGNoYW5nZWRDYXRhbG9nOwotCQlwdWJsaWMgU2NoZW1hIGNoYW5nZWRTY2hlbWE7Ci0JCXB1YmxpYyBTZXF1ZW5jZSBjaGFuZ2VkU2VxdWVuY2U7Ci0JCXB1YmxpYyBUYWJsZSBjaGFuZ2VkVGFibGU7Ci0JCXB1YmxpYyBDb2x1bW4gY2hhbmdlZENvbHVtbjsKLQkJcHVibGljIEZvcmVpZ25LZXkgY2hhbmdlZEZvcmVpZ25LZXk7Ci0KLQkJcHVibGljIHZvaWQgb3BlbmVkKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUpIHsKLQkJCXRoaXMub3BlbmVkUHJvZmlsZSA9IHByb2ZpbGU7Ci0JCX0KLQkJcHVibGljIHZvaWQgbW9kaWZpZWQoQ29ubmVjdGlvblByb2ZpbGUgcHJvZmlsZSkgewotCQkJdGhpcy5tb2RpZmllZFByb2ZpbGUgPSBwcm9maWxlOwotCQl9Ci0JCXB1YmxpYyBib29sZWFuIG9rVG9DbG9zZShDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlKSB7Ci0JCQl0aGlzLm9rVG9DbG9zZVByb2ZpbGUgPSBwcm9maWxlOwotCQkJcmV0dXJuIHRydWU7Ci0JCX0KLQkJcHVibGljIHZvaWQgYWJvdXRUb0Nsb3NlKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUpIHsKLQkJCXRoaXMuYWJvdXRUb0Nsb3NlUHJvZmlsZSA9IHByb2ZpbGU7Ci0JCX0KLQkJcHVibGljIHZvaWQgY2xvc2VkKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUpIHsKLQkJCXRoaXMuY2xvc2VkUHJvZmlsZSA9IHByb2ZpbGU7Ci0JCX0KLQkJcHVibGljIHZvaWQgZGF0YWJhc2VDaGFuZ2VkKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUsIERhdGFiYXNlIGRhdGFiYXNlKSB7Ci0JCQl0aGlzLmNoYW5nZWREYXRhYmFzZSA9IGRhdGFiYXNlOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGNhdGFsb2dDaGFuZ2VkKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUsIENhdGFsb2cgY2F0YWxvZykgewotCQkJdGhpcy5jaGFuZ2VkQ2F0YWxvZyA9IGNhdGFsb2c7Ci0JCX0KLQkJcHVibGljIHZvaWQgc2NoZW1hQ2hhbmdlZChDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlLCBTY2hlbWEgc2NoZW1hKSB7Ci0JCQl0aGlzLmNoYW5nZWRTY2hlbWEgPSBzY2hlbWE7Ci0JCX0KLQkJcHVibGljIHZvaWQgc2VxdWVuY2VDaGFuZ2VkKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUsIFNlcXVlbmNlIHNlcXVlbmNlKSB7Ci0JCQl0aGlzLmNoYW5nZWRTZXF1ZW5jZSA9IHNlcXVlbmNlOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHRhYmxlQ2hhbmdlZChDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlLCBUYWJsZSB0YWJsZSkgewotCQkJdGhpcy5jaGFuZ2VkVGFibGUgPSB0YWJsZTsKLQkJfQotCQlwdWJsaWMgdm9pZCBjb2x1bW5DaGFuZ2VkKENvbm5lY3Rpb25Qcm9maWxlIHByb2ZpbGUsIENvbHVtbiBjb2x1bW4pIHsKLQkJCXRoaXMuY2hhbmdlZENvbHVtbiA9IGNvbHVtbjsKLQkJfQotCQlwdWJsaWMgdm9pZCBmb3JlaWduS2V5Q2hhbmdlZChDb25uZWN0aW9uUHJvZmlsZSBwcm9maWxlLCBGb3JlaWduS2V5IGZvcmVpZ25LZXkpIHsKLQkJCXRoaXMuY2hhbmdlZEZvcmVpZ25LZXkgPSBmb3JlaWduS2V5OwotCQl9Ci0JCXB1YmxpYyB2b2lkIGNsZWFyKCkgewotCQkJdGhpcy5vcGVuZWRQcm9maWxlID0gbnVsbDsKLQkJCXRoaXMubW9kaWZpZWRQcm9maWxlID0gbnVsbDsKLQkJCXRoaXMub2tUb0Nsb3NlUHJvZmlsZSA9IG51bGw7Ci0JCQl0aGlzLmFib3V0VG9DbG9zZVByb2ZpbGUgPSBudWxsOwotCQkJdGhpcy5jbG9zZWRQcm9maWxlID0gbnVsbDsKLQkJCXRoaXMuY2hhbmdlZERhdGFiYXNlID0gbnVsbDsKLQkJCXRoaXMuY2hhbmdlZENhdGFsb2cgPSBudWxsOwotCQkJdGhpcy5jaGFuZ2VkU2NoZW1hID0gbnVsbDsKLQkJCXRoaXMuY2hhbmdlZFNlcXVlbmNlID0gbnVsbDsKLQkJCXRoaXMuY2hhbmdlZFRhYmxlID0gbnVsbDsKLQkJCXRoaXMuY2hhbmdlZENvbHVtbiA9IG51bGw7Ci0JCQl0aGlzLmNoYW5nZWRGb3JlaWduS2V5ID0gbnVsbDsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3Rlc3RzL2ludGVybmFsL3BsYXRmb3Jtcy9EZXJieVRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm1zL0RlcmJ5VGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTJhYWNkOC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm1zL0RlcmJ5VGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQ4MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy5pbnRlcm5hbC5wbGF0Zm9ybXM7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5kYXRhdG9vbHMuY29ubmVjdGl2aXR5LnNxbS5jb3JlLnJ0ZS5JQ2F0YWxvZ09iamVjdDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuQ29sdW1uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5Gb3JlaWduS2V5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5TY2hlbWE7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLlRhYmxlOwotCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBEZXJieVRlc3RzIGV4dGVuZHMgRFRQUGxhdGZvcm1UZXN0cyB7Ci0KLQlwdWJsaWMgRGVyYnlUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXRQbGF0Zm9ybVByb3BlcnRpZXNGaWxlTmFtZSgpIHsKLQkJcmV0dXJuICJkZXJieS5wcm9wZXJ0aWVzIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERyaXZlck5hbWUoKSB7Ci0JCXJldHVybiAiRGVyYnkgRW1iZWRkZWQgSkRCQyBEcml2ZXIiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RHJpdmVyRGVmaW5pdGlvbklEKCkgewotCQlyZXR1cm4gIkRyaXZlckRlZm4uRGVyYnkgRW1iZWRkZWQgSkRCQyBEcml2ZXIiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RHJpdmVyRGVmaW5pdGlvblR5cGUoKSB7Ci0JCXJldHVybiAib3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5kYi5kZXJieTEwMS5nZW5lcmljRHJpdmVyVGVtcGxhdGUiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RGF0YWJhc2VWZW5kb3IoKSB7Ci0JCXJldHVybiAiRGVyYnkiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RGF0YWJhc2VWZXJzaW9uKCkgewotCQlyZXR1cm4gIjEwLjEiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RHJpdmVyQ2xhc3MoKSB7Ci0JCXJldHVybiAib3JnLmFwYWNoZS5kZXJieS5qZGJjLkVtYmVkZGVkRHJpdmVyIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldFByb2ZpbGVOYW1lKCkgewotCQlyZXR1cm4gIkRlcmJ5XzEwLjFfRW1iZWRkZWQiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0UHJvZmlsZURlc2NyaXB0aW9uKCkgewotCQlyZXR1cm4gIkRlcmJ5IDEwLjEgRW1iZWRkZWQgSkRCQyBQcm9maWxlIFtUZXN0XSI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXRQcm92aWRlcklEKCkgewotCQlyZXR1cm4gIm9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuZGIuZGVyYnkuZW1iZWRkZWQuY29ubmVjdGlvblByb2ZpbGUiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBib29sZWFuIHN1cHBvcnRzQ2F0YWxvZ3MoKSB7Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgYm9vbGVhbiBleGVjdXRlT2ZmbGluZVRlc3RzKCkgewotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2NoZW1hKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpOwotCQlUZXN0Q29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IFRlc3RDb25uZWN0aW9uTGlzdGVuZXIoKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5hZGRDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCi0JCXRoaXMuZHJvcFNjaGVtYSgiVEVTVDEiKTsKLQkJdGhpcy5kcm9wU2NoZW1hKCJURVNUMiIpOwotCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFNDSEVNQSBURVNUMSIpOwotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQotCQlTY2hlbWEgc2NoZW1hMSA9IHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRTY2hlbWFOYW1lZCgiVEVTVDEiKTsKLQkJYXNzZXJ0Tm90TnVsbChzY2hlbWExKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBTQ0hFTUEgVEVTVDIiKTsKLQkJU2NoZW1hIHNjaGVtYTIgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hTmFtZWQoIlRFU1QyIik7Ci0JCWFzc2VydE51bGwoc2NoZW1hMik7ICAvLyBzaG91bGQgYmUgbnVsbCB1bnRpbCByZWZyZXNoCi0KLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0JCWFzc2VydFNhbWUodGhpcy5nZXREYXRhYmFzZSgpLCBsaXN0ZW5lci5jaGFuZ2VkRGF0YWJhc2UpOwotCi0JCXNjaGVtYTIgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hTmFtZWQoIlRFU1QyIik7Ci0JCWFzc2VydE5vdE51bGwoc2NoZW1hMik7Ci0JCWFzc2VydE5vdFNhbWUoc2NoZW1hMSwgdGhpcy5nZXREYXRhYmFzZSgpLmdldFNjaGVtYU5hbWVkKCJURVNUMSIpKTsgIC8vIHdlIHNob3VsZCBoYXZlIGEgbmV3IHNjaGVtYSBhZnRlciB0aGUgcmVmcmVzaAotCi0JCXRoaXMuZHJvcFNjaGVtYSgiVEVTVDIiKTsKLQkJdGhpcy5kcm9wU2NoZW1hKCJURVNUMSIpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTY2hlbWFMb29rdXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5jb25uZWN0KCk7Ci0JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJdGhpcy5kcm9wU2NoZW1hKCJMT09LVVBfVEVTVCIpOwotCQl0aGlzLmRyb3BTY2hlbWEoIlwibG9va3VwX1RFU1RcIiIpOwotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBTQ0hFTUEgTE9PS1VQX1RFU1QiKTsKLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0KLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hTmFtZWQoIkxPT0tVUF9URVNUIikpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKCJMT09LVVBfVEVTVCIpKTsKLQotCQlhc3NlcnROdWxsKHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRTY2hlbWFOYW1lZCgibG9va3VwX3Rlc3QiKSk7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5nZXREYXRhYmFzZSgpLmdldFNjaGVtYUZvcklkZW50aWZpZXIoImxvb2t1cF90ZXN0IikpOwotCi0JCWFzc2VydE51bGwodGhpcy5nZXREYXRhYmFzZSgpLmdldFNjaGVtYU5hbWVkKCJsb29rdXBfVEVTVCIpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcigibG9va3VwX1RFU1QiKSk7Ci0KLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcigiXCJMT09LVVBfVEVTVFwiIikpOwotCQlhc3NlcnROdWxsKHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKCJcImxvb2t1cF9URVNUXCIiKSk7Ci0KLQkJdGhpcy5kcm9wU2NoZW1hKCJMT09LVVBfVEVTVCIpOwotCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFNDSEVNQSBcImxvb2t1cF9URVNUXCIiKTsKLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0KLQkJYXNzZXJ0TnVsbCh0aGlzLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hTmFtZWQoIkxPT0tVUF9URVNUIikpOwotCQlhc3NlcnROdWxsKHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKCJMT09LVVBfVEVTVCIpKTsKLQotCQlhc3NlcnROdWxsKHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRTY2hlbWFOYW1lZCgibG9va3VwX3Rlc3QiKSk7Ci0JCWFzc2VydE51bGwodGhpcy5nZXREYXRhYmFzZSgpLmdldFNjaGVtYUZvcklkZW50aWZpZXIoImxvb2t1cF90ZXN0IikpOwotCi0JCWFzc2VydE5vdE51bGwodGhpcy5nZXREYXRhYmFzZSgpLmdldFNjaGVtYU5hbWVkKCJsb29rdXBfVEVTVCIpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcigibG9va3VwX1RFU1QiKSk7Ci0KLQkJYXNzZXJ0TnVsbCh0aGlzLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcigiXCJMT09LVVBfVEVTVFwiIikpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKCJcImxvb2t1cF9URVNUXCIiKSk7Ci0KLQkJdGhpcy5kcm9wU2NoZW1hKCJcImxvb2t1cF9URVNUXCIiKTsKLQotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTY2hlbWFJZGVudGlmaWVyKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpOwotCQlUZXN0Q29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IFRlc3RDb25uZWN0aW9uTGlzdGVuZXIoKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5hZGRDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCi0JCXRoaXMuZHJvcFNjaGVtYSgiTE9PS1VQX1RFU1QiKTsKLQkJdGhpcy5kcm9wU2NoZW1hKCJcImxvb2t1cF9URVNUXCIiKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBTQ0hFTUEgbG9va3VwX3Rlc3QiKTsgIC8vIHRoaXMgZ2V0cyBmb2xkZWQgdG8gdXBwZXJjYXNlCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFNDSEVNQSBcImxvb2t1cF9URVNUXCIiKTsKLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0KLQkJU2NoZW1hIHNjaGVtYSA9IHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKCJMT09LVVBfVEVTVCIpOwotCQlhc3NlcnRFcXVhbHMoIkxPT0tVUF9URVNUIiwgc2NoZW1hLmdldElkZW50aWZpZXIoKSk7Ci0JCWFzc2VydEVxdWFscygiTE9PS1VQX1RFU1QiLCBzY2hlbWEuZ2V0SWRlbnRpZmllcigiTG9va3VwVGVzdCIpKTsKLQkJYXNzZXJ0TnVsbChzY2hlbWEuZ2V0SWRlbnRpZmllcigiTG9va3VwX1Rlc3QiKSk7Ci0KLQkJc2NoZW1hID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldFNjaGVtYUZvcklkZW50aWZpZXIoImxvb2t1cF90ZXN0Iik7Ci0JCWFzc2VydEVxdWFscygiTE9PS1VQX1RFU1QiLCBzY2hlbWEuZ2V0SWRlbnRpZmllcigpKTsKLQotCQlzY2hlbWEgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcigiXCJsb29rdXBfVEVTVFwiIik7Ci0JCWFzc2VydEVxdWFscygiXCJsb29rdXBfVEVTVFwiIiwgc2NoZW1hLmdldElkZW50aWZpZXIoKSk7Ci0JCWFzc2VydEVxdWFscygiXCJsb29rdXBfVEVTVFwiIiwgc2NoZW1hLmdldElkZW50aWZpZXIoImxvb2t1cF9URVNUIikpOwotCi0JCXRoaXMuZHJvcFNjaGVtYSgiXCJsb29rdXBfVEVTVFwiIik7Ci0JCXRoaXMuZHJvcFNjaGVtYSgiTE9PS1VQX1RFU1QiKTsKLQotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RUYWJsZSgpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmNvbm5lY3QoKTsKLQkJVGVzdENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBUZXN0Q29ubmVjdGlvbkxpc3RlbmVyKCk7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuYWRkQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQotCQl0aGlzLmRyb3BUYWJsZSgiVEFCTEVfVEVTVCIsICJGT09fQkFaIik7Ci0JCXRoaXMuZHJvcFRhYmxlKCJUQUJMRV9URVNUIiwgIkJBWiIpOwotCQl0aGlzLmRyb3BUYWJsZSgiVEFCTEVfVEVTVCIsICJGT08iKTsKLQkJdGhpcy5kcm9wVGFibGUoIlRBQkxFX1RFU1QiLCAiQkFSIik7Ci0JCXRoaXMuZHJvcFNjaGVtYSgiVEFCTEVfVEVTVCIpOwotCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFNDSEVNQSBUQUJMRV9URVNUIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiU0VUIFNDSEVNQSA9IFRBQkxFX1RFU1QiKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUodGhpcy5idWlsZEJhckRETCgpKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKHRoaXMuYnVpbGRGb29EREwoKSk7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSh0aGlzLmJ1aWxkQmF6RERMKCkpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUodGhpcy5idWlsZEZvb0JhekRETCgpKTsKLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0KLQkJU2NoZW1hIHNjaGVtYSA9IHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRTY2hlbWFOYW1lZCgiVEFCTEVfVEVTVCIpOwotCi0JCS8vIEZPTwotCQlUYWJsZSBmb29UYWJsZSA9IHNjaGVtYS5nZXRUYWJsZU5hbWVkKCJGT08iKTsKLQkJYXNzZXJ0RXF1YWxzKDQsIGZvb1RhYmxlLmNvbHVtbnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgZm9vVGFibGUucHJpbWFyeUtleUNvbHVtbnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgZm9vVGFibGUuZm9yZWlnbktleXNTaXplKCkpOwotCi0JCUNvbHVtbiBwa0NvbHVtbiA9IGZvb1RhYmxlLmdldFByaW1hcnlLZXlDb2x1bW4oKTsKLQkJYXNzZXJ0RXF1YWxzKCJJRCIsIHBrQ29sdW1uLmdldE5hbWUoKSk7Ci0JCUNvbHVtbiBpZENvbHVtbiA9IGZvb1RhYmxlLmdldENvbHVtbk5hbWVkKCJJRCIpOwotCQlhc3NlcnRTYW1lKHBrQ29sdW1uLCBpZENvbHVtbik7Ci0JCWFzc2VydEVxdWFscygiSU5URUdFUiIsIGlkQ29sdW1uLmdldERhdGFUeXBlTmFtZSgpKTsKLQkJYXNzZXJ0U2FtZShmb29UYWJsZSwgaWRDb2x1bW4uZ2V0VGFibGUoKSk7Ci0JCWFzc2VydFRydWUoaWRDb2x1bW4uaXNQYXJ0T2ZQcmltYXJ5S2V5KCkpOwotCQlhc3NlcnRGYWxzZShpZENvbHVtbi5pc1BhcnRPZkZvcmVpZ25LZXkoKSk7Ci0JCWFzc2VydEVxdWFscygiaW50IiwgaWRDb2x1bW4uZ2V0SmF2YVR5cGVEZWNsYXJhdGlvbigpKTsKLQotCQlDb2x1bW4gbmFtZUNvbHVtbiA9IGZvb1RhYmxlLmdldENvbHVtbk5hbWVkKCJOQU1FIik7Ci0JCWFzc2VydEVxdWFscygiVkFSQ0hBUiIsIG5hbWVDb2x1bW4uZ2V0RGF0YVR5cGVOYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoImphdmEubGFuZy5TdHJpbmciLCBuYW1lQ29sdW1uLmdldEphdmFUeXBlRGVjbGFyYXRpb24oKSk7Ci0JCWFzc2VydEVxdWFscygyMCwgbmFtZUNvbHVtbi5nZXRMZW5ndGgoKSk7Ci0JCWFzc2VydEZhbHNlKG5hbWVDb2x1bW4uaXNQYXJ0T2ZQcmltYXJ5S2V5KCkpOwotCQlhc3NlcnRGYWxzZShuYW1lQ29sdW1uLmlzTnVtZXJpYygpKTsKLQkJYXNzZXJ0VHJ1ZShuYW1lQ29sdW1uLmlzTnVsbGFibGUoKSk7Ci0KLQkJQ29sdW1uIGJhckNvbHVtbiA9IGZvb1RhYmxlLmdldENvbHVtbk5hbWVkKCJCQVJfSUQiKTsKLQkJYXNzZXJ0RXF1YWxzKCJJTlRFR0VSIiwgYmFyQ29sdW1uLmdldERhdGFUeXBlTmFtZSgpKTsKLQkJYXNzZXJ0VHJ1ZShiYXJDb2x1bW4uaXNQYXJ0T2ZGb3JlaWduS2V5KCkpOwotCQlhc3NlcnRGYWxzZShiYXJDb2x1bW4uaXNQYXJ0T2ZQcmltYXJ5S2V5KCkpOwotCi0JCUNvbHVtbiBzYWxhcnlDb2x1bW4gPSBmb29UYWJsZS5nZXRDb2x1bW5OYW1lZCgiU0FMQVJZIik7Ci0JCWFzc2VydEVxdWFscygiREVDSU1BTCIsIHNhbGFyeUNvbHVtbi5nZXREYXRhVHlwZU5hbWUoKSk7Ci0JCWFzc2VydFRydWUoc2FsYXJ5Q29sdW1uLmlzTnVsbGFibGUoKSk7Ci0JCWFzc2VydFRydWUoc2FsYXJ5Q29sdW1uLmlzTnVtZXJpYygpKTsKLQkJYXNzZXJ0RXF1YWxzKDExLCBzYWxhcnlDb2x1bW4uZ2V0UHJlY2lzaW9uKCkpOwotCQlhc3NlcnRFcXVhbHMoMiwgc2FsYXJ5Q29sdW1uLmdldFNjYWxlKCkpOwotCQlhc3NlcnRFcXVhbHMoLTEsIHNhbGFyeUNvbHVtbi5nZXRMZW5ndGgoKSk7Ci0KLQkJRm9yZWlnbktleSBiYXJGSyA9IGZvb1RhYmxlLmZvcmVpZ25LZXlzKCkubmV4dCgpOyAgLy8gdGhlcmUgc2hvdWxkIG9ubHkgYmUgMSBmb3JlaWduIGtleQotCQlhc3NlcnRFcXVhbHMoMSwgYmFyRksuY29sdW1uUGFpcnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoIkJBUiIsIGJhckZLLmdldEF0dHJpYnV0ZU5hbWUoKSk7Ci0JCWFzc2VydE51bGwoYmFyRksuZ2V0Sm9pbkNvbHVtbkFubm90YXRpb25JZGVudGlmaWVyKCJiYXIiKSk7Ci0JCWFzc2VydEVxdWFscygiQkFSX0lEIiwgYmFyRksuZ2V0Sm9pbkNvbHVtbkFubm90YXRpb25JZGVudGlmaWVyKCJwcmltYXJ5QmFyIikpOwotCQlhc3NlcnRTYW1lKGZvb1RhYmxlLCBiYXJGSy5nZXRCYXNlVGFibGUoKSk7Ci0KLQkJYXNzZXJ0RmFsc2UoZm9vVGFibGUuaXNQb3NzaWJsZUpvaW5UYWJsZSgpKTsKLQkJYXNzZXJ0U2FtZShzY2hlbWEsIGZvb1RhYmxlLmdldFNjaGVtYSgpKTsKLQotCQkvLyBCQVIKLQkJVGFibGUgYmFyVGFibGUgPSBzY2hlbWEuZ2V0VGFibGVOYW1lZCgiQkFSIik7Ci0JCWFzc2VydEVxdWFscygzLCBiYXJUYWJsZS5jb2x1bW5zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIGJhclRhYmxlLnByaW1hcnlLZXlDb2x1bW5zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGJhclRhYmxlLmZvcmVpZ25LZXlzU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJJRCIsIGJhclRhYmxlLmdldFByaW1hcnlLZXlDb2x1bW4oKS5nZXROYW1lKCkpOwotCQlhc3NlcnRGYWxzZShiYXJUYWJsZS5pc1Bvc3NpYmxlSm9pblRhYmxlKCkpOwotCi0JCUNvbHVtbiBpZDJDb2x1bW4gPSBiYXJUYWJsZS5nZXRDb2x1bW5OYW1lZCgiSUQyIik7Ci0JCWFzc2VydEVxdWFscygiSU5URUdFUiIsIGlkMkNvbHVtbi5nZXREYXRhVHlwZU5hbWUoKSk7Ci0vLwkJYXNzZXJ0VHJ1ZShpZDJDb2x1bW4uaXNQYXJ0T2ZVbmlxdWVDb25zdHJhaW50KCkpOyAgLy8gZG9lc24ndCB3b3JrKD8pCi0JCWFzc2VydEZhbHNlKGlkMkNvbHVtbi5pc051bGxhYmxlKCkpOwotCQlhc3NlcnRUcnVlKGlkMkNvbHVtbi5pc051bWVyaWMoKSk7Ci0JCWFzc2VydEVxdWFscygwLCBpZDJDb2x1bW4uZ2V0UHJlY2lzaW9uKCkpOyAgLy8gbm90IHN1cmUgd2hhdCB0byBleHBlY3QgaGVyZS4uLgotCQlhc3NlcnRFcXVhbHMoMCwgaWQyQ29sdW1uLmdldFNjYWxlKCkpOyAgLy8gbm90IHN1cmUgd2hhdCB0byBleHBlY3QgaGVyZSBlaXRoZXIuLi4KLQkJYXNzZXJ0RXF1YWxzKCJCTE9CIiwgYmFyVGFibGUuZ2V0Q29sdW1uTmFtZWQoIkNIVU5LIikuZ2V0RGF0YVR5cGVOYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoImJ5dGVbXSIsIGJhclRhYmxlLmdldENvbHVtbk5hbWVkKCJDSFVOSyIpLmdldEphdmFUeXBlRGVjbGFyYXRpb24oKSk7Ci0JCWFzc2VydFRydWUoYmFyVGFibGUuZ2V0Q29sdW1uTmFtZWQoIkNIVU5LIikuaXNMT0IoKSk7Ci0JCWFzc2VydFNhbWUoYmFyVGFibGUsIGJhckZLLmdldFJlZmVyZW5jZWRUYWJsZSgpKTsKLQotCQkvLyBCQVoKLQkJVGFibGUgYmF6VGFibGUgPSBzY2hlbWEuZ2V0VGFibGVOYW1lZCgiQkFaIik7Ci0JCUNvbHVtbiBuaWNrbmFtZUNvbHVtbiA9IGJhelRhYmxlLmdldENvbHVtbk5hbWVkKCJOSUNLTkFNRSIpOwotCQlhc3NlcnRFcXVhbHMoMjAsIG5pY2tuYW1lQ29sdW1uLmdldExlbmd0aCgpKTsKLS8vCQlhc3NlcnRUcnVlKG5pY2tuYW1lQ29sdW1uLmlzUGFydE9mVW5pcXVlQ29uc3RyYWludCgpKTsgIC8vIGRvZXNuJ3Qgd29yayg/KQotCi0JCS8vIEZPT19CQVoKLQkJVGFibGUgZm9vX2JhelRhYmxlID0gc2NoZW1hLmdldFRhYmxlTmFtZWQoIkZPT19CQVoiKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGZvb19iYXpUYWJsZS5jb2x1bW5zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGZvb19iYXpUYWJsZS5wcmltYXJ5S2V5Q29sdW1uc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygyLCBmb29fYmF6VGFibGUuZm9yZWlnbktleXNTaXplKCkpOwotCQlhc3NlcnRUcnVlKGZvb19iYXpUYWJsZS5pc1Bvc3NpYmxlSm9pblRhYmxlKCkpOwotCQlhc3NlcnRUcnVlKGZvb19iYXpUYWJsZS5qb2luVGFibGVOYW1lSXNEZWZhdWx0KCkpOwotCQlhc3NlcnRUcnVlKGZvb19iYXpUYWJsZS5nZXRDb2x1bW5OYW1lZCgiRk9PX0lEIikuaXNQYXJ0T2ZGb3JlaWduS2V5KCkpOwotCi0JCXRoaXMuZHJvcFRhYmxlKCJUQUJMRV9URVNUIiwgIkZPT19CQVoiKTsKLQkJdGhpcy5kcm9wVGFibGUoIlRBQkxFX1RFU1QiLCAiQkFaIik7Ci0JCXRoaXMuZHJvcFRhYmxlKCJUQUJMRV9URVNUIiwgIkZPTyIpOwotCQl0aGlzLmRyb3BUYWJsZSgiVEFCTEVfVEVTVCIsICJCQVIiKTsKLQkJdGhpcy5kcm9wU2NoZW1hKCJUQUJMRV9URVNUIik7Ci0KLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5yZW1vdmVDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmRpc2Nvbm5lY3QoKTsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQ1IgPSBTeXN0ZW0uZ2V0UHJvcGVydHkoImxpbmUuc2VwYXJhdG9yIik7ICAvLyROT04tTkxTLTEkCi0KLQlwcml2YXRlIFN0cmluZyBidWlsZEJhckRETCgpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXNiLmFwcGVuZCgiQ1JFQVRFIFRBQkxFIEJBUiAoIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgSUQgSU5UIFBSSU1BUlkgS0VZLCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIElEMiBJTlQgVU5JUVVFIE5PVCBOVUxMLCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIENIVU5LIEJMT0IoMTAwSykiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIikiKS5hcHBlbmQoQ1IpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBidWlsZEZvb0RETCgpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXNiLmFwcGVuZCgiQ1JFQVRFIFRBQkxFIEZPTyAoIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgSUQgSU5UIFBSSU1BUlkgS0VZLCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIE5BTUUgVkFSQ0hBUigyMCksIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgU0FMQVJZIERFQ0lNQUwoMTEsIDIpLCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIEJBUl9JRCBJTlQgUkVGRVJFTkNFUyBCQVIoSUQpIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIpIikuYXBwZW5kKENSKTsKLQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmcgYnVpbGRCYXpEREwoKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigyMDApOwotCQlzYi5hcHBlbmQoIkNSRUFURSBUQUJMRSBCQVogKCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIElEIElOVCBQUklNQVJZIEtFWSwiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBOSUNLTkFNRSBWQVJDSEFSKDIwKSBOT1QgTlVMTCBVTklRVUUiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIikiKS5hcHBlbmQoQ1IpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBidWlsZEZvb0JhekRETCgpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXNiLmFwcGVuZCgiQ1JFQVRFIFRBQkxFIEZPT19CQVogKCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIEZPT19JRCBJTlQgUkVGRVJFTkNFUyBGT08oSUQpLCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIEJBWl9JRCBJTlQgUkVGRVJFTkNFUyBCQVooSUQpIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIpIikuYXBwZW5kKENSKTsKLQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbHVtbkxvb2t1cCgpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmNvbm5lY3QoKTsKLQkJVGVzdENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBUZXN0Q29ubmVjdGlvbkxpc3RlbmVyKCk7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuYWRkQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQotCQl0aGlzLmRyb3BUYWJsZSgiQ09MVU1OX1RFU1QiLCAidGVzdCIpOwotCQl0aGlzLmRyb3BTY2hlbWEoIkNPTFVNTl9URVNUIik7Ci0KLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgU0NIRU1BIENPTFVNTl9URVNUIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiU0VUIFNDSEVNQSA9IENPTFVNTl9URVNUIik7Ci0KLQkJLy8gbG93ZXJjYXNlCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFRBQkxFIHRlc3QgKGlkIElOVEVHRVIsIG5hbWUgVkFSQ0hBUigyMCkpIik7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCVRhYmxlIHRhYmxlID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldFNjaGVtYU5hbWVkKCJDT0xVTU5fVEVTVCIpLmdldFRhYmxlRm9ySWRlbnRpZmllcigidGVzdCIpOwotCQlhc3NlcnROb3ROdWxsKHRhYmxlLmdldENvbHVtbkZvcklkZW50aWZpZXIoImlkIikpOwotCQlhc3NlcnROb3ROdWxsKHRhYmxlLmdldENvbHVtbkZvcklkZW50aWZpZXIoIm5hbWUiKSk7Ci0KLQkJdGhpcy5kcm9wVGFibGUoIkNPTFVNTl9URVNUIiwgInRlc3QiKTsKLQotCQkvLyB1cHBlcmNhc2UKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgVEFCTEUgdGVzdCAoSUQgSU5URUdFUiwgTkFNRSBWQVJDSEFSKDIwKSkiKTsKLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0KLQkJdGFibGUgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hTmFtZWQoIkNPTFVNTl9URVNUIikuZ2V0VGFibGVGb3JJZGVudGlmaWVyKCJ0ZXN0Iik7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiSUQiKSk7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiTkFNRSIpKTsKLQotCQl0aGlzLmRyb3BUYWJsZSgiQ09MVU1OX1RFU1QiLCAidGVzdCIpOwotCi0JCS8vIG1peGVkIGNhc2UKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgVEFCTEUgdGVzdCAoSWQgSU5URUdFUiwgTmFtZSBWQVJDSEFSKDIwKSkiKTsKLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0KLQkJdGFibGUgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hTmFtZWQoIkNPTFVNTl9URVNUIikuZ2V0VGFibGVGb3JJZGVudGlmaWVyKCJ0ZXN0Iik7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiSWQiKSk7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiTmFtZSIpKTsKLQotCQl0aGlzLmRyb3BUYWJsZSgiQ09MVU1OX1RFU1QiLCAidGVzdCIpOwotCi0JCS8vIGRlbGltaXRlZAotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBUQUJMRSB0ZXN0IChcIklkXCIgSU5URUdFUiwgXCJOYW1lXCIgVkFSQ0hBUigyMCkpIik7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCXRhYmxlID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldFNjaGVtYU5hbWVkKCJDT0xVTU5fVEVTVCIpLmdldFRhYmxlRm9ySWRlbnRpZmllcigidGVzdCIpOwotCQlhc3NlcnROb3ROdWxsKHRhYmxlLmdldENvbHVtbkZvcklkZW50aWZpZXIoIlwiSWRcIiIpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0YWJsZS5nZXRDb2x1bW5Gb3JJZGVudGlmaWVyKCJcIk5hbWVcIiIpKTsKLQotCQl0aGlzLmRyb3BUYWJsZSgiQ09MVU1OX1RFU1QiLCAidGVzdCIpOwotCQl0aGlzLmRyb3BTY2hlbWEoIkNPTFVNTl9URVNUIik7Ci0KLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5yZW1vdmVDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmRpc2Nvbm5lY3QoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q3Jvc3NTY2hlbWFSZWZlcmVuY2UoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5jb25uZWN0KCk7Ci0JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJdGhpcy5kcm9wVGFibGUoIlhSRUZfVEVTVDIiLCAiRU1QIik7Ci0JCXRoaXMuZHJvcFNjaGVtYSgiWFJFRl9URVNUMiIpOwotCQl0aGlzLmRyb3BUYWJsZSgiWFJFRl9URVNUMSIsICJPUkciKTsKLQkJdGhpcy5kcm9wU2NoZW1hKCJYUkVGX1RFU1QxIik7Ci0KLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgU0NIRU1BIFhSRUZfVEVTVDEiKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJTRVQgU0NIRU1BID0gWFJFRl9URVNUMSIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBUQUJMRSBPUkcgKElEIElOVEVHRVIgUFJJTUFSWSBLRVksIE5BTUUgVkFSQ0hBUigyMCkpIik7Ci0KLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgU0NIRU1BIFhSRUZfVEVTVDIiKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJTRVQgU0NIRU1BID0gWFJFRl9URVNUMiIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBUQUJMRSBFTVAgKElEIElOVEVHRVIgUFJJTUFSWSBLRVksIE5BTUUgVkFSQ0hBUigyMCksICIgKwotCQkJCSJPUkdfSUQgSU5URUdFUiBSRUZFUkVOQ0VTIFhSRUZfVEVTVDEuT1JHKElEKSkiKTsKLQotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQkJU2NoZW1hIHNjaGVtYTEgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hTmFtZWQoIlhSRUZfVEVTVDEiKTsKLQkJYXNzZXJ0Tm90TnVsbChzY2hlbWExKTsKLQkJVGFibGUgb3JnVGFibGUgPSBzY2hlbWExLmdldFRhYmxlTmFtZWQoIk9SRyIpOwotCQlhc3NlcnROb3ROdWxsKG9yZ1RhYmxlKTsKLQotCQlTY2hlbWEgc2NoZW1hMiA9IHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRTY2hlbWFOYW1lZCgiWFJFRl9URVNUMiIpOwotCQlhc3NlcnROb3ROdWxsKHNjaGVtYTIpOwotCQlUYWJsZSBlbXBUYWJsZSA9IHNjaGVtYTIuZ2V0VGFibGVOYW1lZCgiRU1QIik7Ci0JCWFzc2VydE5vdE51bGwoZW1wVGFibGUpOwotCQlhc3NlcnRFcXVhbHMoMSwgZW1wVGFibGUuZm9yZWlnbktleXNTaXplKCkpOwotCQlGb3JlaWduS2V5IGZrID0gZW1wVGFibGUuZm9yZWlnbktleXMoKS5uZXh0KCk7Ci0JCVRhYmxlIHJlZlRhYmxlID0gZmsuZ2V0UmVmZXJlbmNlZFRhYmxlKCk7Ci0JCWFzc2VydE5vdE51bGwocmVmVGFibGUpOwotCQlhc3NlcnRFcXVhbHMoIk9SRyIsIHJlZlRhYmxlLmdldE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBmay5jb2x1bW5QYWlyc1NpemUoKSk7Ci0JCUZvcmVpZ25LZXkuQ29sdW1uUGFpciBjcCA9IGZrLmNvbHVtblBhaXJzKCkubmV4dCgpOwotCQlDb2x1bW4gYmFzZUNvbHVtbiA9IGNwLmdldEJhc2VDb2x1bW4oKTsKLQkJYXNzZXJ0RXF1YWxzKCJPUkdfSUQiLCBiYXNlQ29sdW1uLmdldE5hbWUoKSk7Ci0JCUNvbHVtbiByZWZDb2x1bW4gPSBjcC5nZXRSZWZlcmVuY2VkQ29sdW1uKCk7Ci0JCWFzc2VydEVxdWFscygiSUQiLCByZWZDb2x1bW4uZ2V0TmFtZSgpKTsKLQotCQl0aGlzLmRyb3BUYWJsZSgiWFJFRl9URVNUMiIsICJFTVAiKTsKLQkJdGhpcy5kcm9wU2NoZW1hKCJYUkVGX1RFU1QyIik7Ci0JCXRoaXMuZHJvcFRhYmxlKCJYUkVGX1RFU1QxIiwgIk9SRyIpOwotCQl0aGlzLmRyb3BTY2hlbWEoIlhSRUZfVEVTVDEiKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5yZW1vdmVDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmRpc2Nvbm5lY3QoKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgZHJvcFRhYmxlKFN0cmluZyBzY2hlbWFOYW1lLCBTdHJpbmcgdGFibGVOYW1lKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJU2NoZW1hIHNjaGVtYT0gdGhpcy5nZXREYXRhYmFzZSgpLmdldFNjaGVtYUZvcklkZW50aWZpZXIoc2NoZW1hTmFtZSk7Ci0JCWlmIChzY2hlbWEgIT0gbnVsbCkgewotCQkJaWYgKHNjaGVtYS5nZXRUYWJsZUZvcklkZW50aWZpZXIodGFibGVOYW1lKSAhPSBudWxsKSB7Ci0JCQkJdGhpcy5leGVjdXRlVXBkYXRlKCJEUk9QIFRBQkxFICIgKyBzY2hlbWFOYW1lICsgJy4nICsgdGFibGVOYW1lKTsKLQkJCX0KLQkJfQotCX0KLQotCS8qKgotCSAqIE5COiBBIERlcmJ5IHNjaGVtYSBtdXN0IGJlIGVtcHR5IGJlZm9yZSBpdCBjYW4gYmUgZHJvcHBlZC4KLQkgKi8KLQlwcml2YXRlIHZvaWQgZHJvcFNjaGVtYShTdHJpbmcgbmFtZSkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWlmICh0aGlzLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcihuYW1lKSAhPSBudWxsKSB7Ci0JCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkRST1AgU0NIRU1BICIgKyBuYW1lICsgIiBSRVNUUklDVCIpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm1zL015U1FMVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi90ZXN0cy9pbnRlcm5hbC9wbGF0Zm9ybXMvTXlTUUxUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0YjY1MTQyLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi90ZXN0cy9pbnRlcm5hbC9wbGF0Zm9ybXMvTXlTUUxUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDA0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzLmludGVybmFsLnBsYXRmb3JtczsKLQotaW1wb3J0IGphdmEudXRpbC5Qcm9wZXJ0aWVzOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5kcml2ZXJzLmpkYmMuSUpEQkNEcml2ZXJEZWZpbml0aW9uQ29uc3RhbnRzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuc3FtLmNvcmUucnRlLklDYXRhbG9nT2JqZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5Db2x1bW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkZvcmVpZ25LZXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLlNjaGVtYTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuVGFibGU7Ci0KLS8qKgotICogTXlTUUwKLSAqIAotICogTm90ZXM6Ci0gKiAtIFdlIGNhbiBvbmx5IGdldCBkYXRhYmFzZSBvYmplY3RzIGZyb20gdGhlIGRhdGFiYXNlIGFzc29jaWF0ZWQgd2l0aCBvdXIKLSAqICAgICBjb25uZWN0aW9uIHByb2ZpbGUuCi0gKiAtIFdlIGNhbiByZWZlcmVuY2Ugb2JqZWN0cyBhY3Jvc3MgbXVsdGlwbGUgZGF0YWJhc2VzLCBzbyB0aGV5IGFyZSBzb3J0YSBsaWtlCi0gKiAgICAgc2NoZW1hcy4uLi4KLSAqIC0gRm9yZWlnbiBrZXlzIG11c3QgYmUgZGVmaW5lZCBhcyB0YWJsZS1sZXZlbCBjb25zdHJhaW50czsgdGhleSBjYW5ub3QgYmUKLSAqICAgICBkZWZpbmVkIGFzIHBhcnQgb2YgdGhlIGNvbHVtbiBjbGF1c2UuCi0gKiAtIENhc2Utc2Vuc2l0aXZpdHkgYW5kIC1mb2xkaW5nIGlzIHdoYWNrZWQgb24gTXlTUUwuLi4uCi0gKi8KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIE15U1FMVGVzdHMgZXh0ZW5kcyBEVFBQbGF0Zm9ybVRlc3RzIHsKLQotCXB1YmxpYyBNeVNRTFRlc3RzKCBTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldFBsYXRmb3JtUHJvcGVydGllc0ZpbGVOYW1lKCkgewotCQlyZXR1cm4gIm15c3FsLnByb3BlcnRpZXMiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RHJpdmVyTmFtZSgpIHsKLQkJcmV0dXJuICJNeVNRTCBKREJDIERyaXZlciI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXREcml2ZXJEZWZpbml0aW9uSUQoKSB7Ci0JCXJldHVybiAiRHJpdmVyRGVmbi5NeVNRTCBKREJDIERyaXZlciI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXREcml2ZXJEZWZpbml0aW9uVHlwZSgpIHsKLQkJcmV0dXJuICJvcmcuZWNsaXBzZS5kYXRhdG9vbHMuZW5hYmxlbWVudC5teXNxbC40XzEuZHJpdmVyVGVtcGxhdGUiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RGF0YWJhc2VWZW5kb3IoKSB7Ci0JCXJldHVybiAiTXlTcWwiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RGF0YWJhc2VWZXJzaW9uKCkgewotCQlyZXR1cm4gIjQuMSI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXREcml2ZXJDbGFzcygpIHsKLQkJcmV0dXJuICJjb20ubXlzcWwuamRiYy5Ecml2ZXIiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RGVmYXVsdEpEQkNVUkwoKSB7Ci0JCXJldHVybiAiamRiYzpteXNxbDovL2xvY2FsaG9zdDozMzA2IjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldFByb2ZpbGVOYW1lKCkgewotCQlyZXR1cm4gIk15U1FMXzQuMSI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXRQcm9maWxlRGVzY3JpcHRpb24oKSB7Ci0JCXJldHVybiAiTXlTUUwgNC4xIEpEQkMgUHJvZmlsZSBbVGVzdF0iOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBib29sZWFuIHN1cHBvcnRzQ2F0YWxvZ3MoKSB7Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgUHJvcGVydGllcyBidWlsZERUUENvbm5lY3Rpb25Qcm9maWxlUHJvcGVydGllcygpIHsKLQkJUHJvcGVydGllcyBwID0gc3VwZXIuYnVpbGREVFBDb25uZWN0aW9uUHJvZmlsZVByb3BlcnRpZXMoKTsKLQkJcC5zZXRQcm9wZXJ0eShJSkRCQ0RyaXZlckRlZmluaXRpb25Db25zdGFudHMuREFUQUJBU0VfTkFNRV9QUk9QX0lELCB0aGlzLmdldERhdGFiYXNlTmFtZSgpKTsKLQkJcmV0dXJuIHA7Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmcgZ2V0RGF0YWJhc2VOYW1lKCkgewotCQlyZXR1cm4gImRhbGl0ZXN0IjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgYm9vbGVhbiBleGVjdXRlT2ZmbGluZVRlc3RzKCkgewotCQlyZXR1cm4gdHJ1ZTsgIC8vIHNlZW1zIHRvIHdvcmsuLi4KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGF0YWJhc2UoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5jb25uZWN0KCk7Ci0JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJLy8gRFRQOiBNeVNRTCBoYXMgYSBzaW5nbGUgc2NoZW1hIHdpdGggdGhlIHNhbWUgbmFtZSBhcyB0aGUgZGF0YWJhc2UKLQkJU2NoZW1hIHNjaGVtYSA9IHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRTY2hlbWFOYW1lZCh0aGlzLmdldERhdGFiYXNlTmFtZSgpKTsKLQkJYXNzZXJ0Tm90TnVsbChzY2hlbWEpOwotCQlhc3NlcnRTYW1lKHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXREZWZhdWx0U2NoZW1hKCksIHNjaGVtYSk7Ci0KLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5yZW1vdmVDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmRpc2Nvbm5lY3QoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VGFibGUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5jb25uZWN0KCk7Ci0JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJdGhpcy5kcm9wRGF0YWJhc2UodGhpcy5nZXREYXRhYmFzZU5hbWUoKSk7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIERBVEFCQVNFICIgKyB0aGlzLmdldERhdGFiYXNlTmFtZSgpKTsKLQkJdGhpcy5nZXRKREJDQ29ubmVjdGlvbigpLnNldENhdGFsb2codGhpcy5nZXREYXRhYmFzZU5hbWUoKSk7Ci0KLQkJdGhpcy5kcm9wVGFibGUodGhpcy5nZXREYXRhYmFzZU5hbWUoKSwgImZvb19iYXoiKTsKLQkJdGhpcy5kcm9wVGFibGUodGhpcy5nZXREYXRhYmFzZU5hbWUoKSwgImJheiIpOwotCQl0aGlzLmRyb3BUYWJsZSh0aGlzLmdldERhdGFiYXNlTmFtZSgpLCAiZm9vIik7Ci0JCXRoaXMuZHJvcFRhYmxlKHRoaXMuZ2V0RGF0YWJhc2VOYW1lKCksICJiYXIiKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUodGhpcy5idWlsZEJhckRETCgpKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKHRoaXMuYnVpbGRGb29EREwoKSk7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSh0aGlzLmJ1aWxkQmF6RERMKCkpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUodGhpcy5idWlsZEZvb0JhekRETCgpKTsKLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0KLQkJU2NoZW1hIHNjaGVtYSA9IHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXREZWZhdWx0U2NoZW1hKCk7Ci0KLQkJLy8gZm9vCi0JCVRhYmxlIGZvb1RhYmxlID0gc2NoZW1hLmdldFRhYmxlTmFtZWQoImZvbyIpOwotCQlhc3NlcnRFcXVhbHMoMywgZm9vVGFibGUuY29sdW1uc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBmb29UYWJsZS5wcmltYXJ5S2V5Q29sdW1uc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBmb29UYWJsZS5mb3JlaWduS2V5c1NpemUoKSk7Ci0KLQkJQ29sdW1uIHBrQ29sdW1uID0gZm9vVGFibGUuZ2V0UHJpbWFyeUtleUNvbHVtbigpOwotCQlhc3NlcnRFcXVhbHMoImlkIiwgcGtDb2x1bW4uZ2V0TmFtZSgpKTsKLQkJQ29sdW1uIGlkQ29sdW1uID0gZm9vVGFibGUuZ2V0Q29sdW1uTmFtZWQoImlkIik7Ci0JCWFzc2VydFNhbWUocGtDb2x1bW4sIGlkQ29sdW1uKTsKLQkJYXNzZXJ0RXF1YWxzKCJJTlQiLCBpZENvbHVtbi5nZXREYXRhVHlwZU5hbWUoKSk7Ci0JCWFzc2VydFNhbWUoZm9vVGFibGUsIGlkQ29sdW1uLmdldFRhYmxlKCkpOwotCQlhc3NlcnRUcnVlKGlkQ29sdW1uLmlzUGFydE9mUHJpbWFyeUtleSgpKTsKLQkJYXNzZXJ0RmFsc2UoaWRDb2x1bW4uaXNQYXJ0T2ZGb3JlaWduS2V5KCkpOwotCQlhc3NlcnRFcXVhbHMoImludCIsIGlkQ29sdW1uLmdldEphdmFUeXBlRGVjbGFyYXRpb24oKSk7Ci0KLQkJQ29sdW1uIG5hbWVDb2x1bW4gPSBmb29UYWJsZS5nZXRDb2x1bW5OYW1lZCgibmFtZSIpOwotCQlhc3NlcnRFcXVhbHMoIlZBUkNIQVIiLCBuYW1lQ29sdW1uLmdldERhdGFUeXBlTmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJqYXZhLmxhbmcuU3RyaW5nIiwgbmFtZUNvbHVtbi5nZXRKYXZhVHlwZURlY2xhcmF0aW9uKCkpOwotCQlhc3NlcnRGYWxzZShuYW1lQ29sdW1uLmlzUGFydE9mUHJpbWFyeUtleSgpKTsKLQotCQlDb2x1bW4gYmFyQ29sdW1uID0gZm9vVGFibGUuZ2V0Q29sdW1uTmFtZWQoImJhcl9pZCIpOwotCQlhc3NlcnRFcXVhbHMoIklOVCIsIGJhckNvbHVtbi5nZXREYXRhVHlwZU5hbWUoKSk7Ci0JCWFzc2VydFRydWUoYmFyQ29sdW1uLmlzUGFydE9mRm9yZWlnbktleSgpKTsKLQkJYXNzZXJ0RmFsc2UoYmFyQ29sdW1uLmlzUGFydE9mUHJpbWFyeUtleSgpKTsKLQotCQlGb3JlaWduS2V5IGJhckZLID0gZm9vVGFibGUuZm9yZWlnbktleXMoKS5uZXh0KCk7ICAvLyB0aGVyZSBzaG91bGQgb25seSBiZSAxIGZvcmVpZ24ga2V5Ci0JCWFzc2VydEVxdWFscygxLCBiYXJGSy5jb2x1bW5QYWlyc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygiYmFyIiwgYmFyRksuZ2V0QXR0cmlidXRlTmFtZSgpKTsKLQkJYXNzZXJ0TnVsbChiYXJGSy5nZXRKb2luQ29sdW1uQW5ub3RhdGlvbklkZW50aWZpZXIoImJhciIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXJfaWQiLCBiYXJGSy5nZXRKb2luQ29sdW1uQW5ub3RhdGlvbklkZW50aWZpZXIoInByaW1hcnlCYXIiKSk7Ci0JCWFzc2VydFNhbWUoZm9vVGFibGUsIGJhckZLLmdldEJhc2VUYWJsZSgpKTsKLQotCQlhc3NlcnRGYWxzZShmb29UYWJsZS5pc1Bvc3NpYmxlSm9pblRhYmxlKCkpOwotCQlhc3NlcnRTYW1lKHNjaGVtYSwgZm9vVGFibGUuZ2V0U2NoZW1hKCkpOwotCi0JCS8vIEJBUgotCQlUYWJsZSBiYXJUYWJsZSA9IHNjaGVtYS5nZXRUYWJsZU5hbWVkKCJiYXIiKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGJhclRhYmxlLmNvbHVtbnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgYmFyVGFibGUucHJpbWFyeUtleUNvbHVtbnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgYmFyVGFibGUuZm9yZWlnbktleXNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoImlkIiwgYmFyVGFibGUuZ2V0UHJpbWFyeUtleUNvbHVtbigpLmdldE5hbWUoKSk7Ci0JCWFzc2VydEZhbHNlKGJhclRhYmxlLmlzUG9zc2libGVKb2luVGFibGUoKSk7Ci0JCWFzc2VydEVxdWFscygiQkxPQiIsIGJhclRhYmxlLmdldENvbHVtbk5hbWVkKCJjaHVuayIpLmdldERhdGFUeXBlTmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJieXRlW10iLCBiYXJUYWJsZS5nZXRDb2x1bW5OYW1lZCgiY2h1bmsiKS5nZXRKYXZhVHlwZURlY2xhcmF0aW9uKCkpOwotCQlhc3NlcnRUcnVlKGJhclRhYmxlLmdldENvbHVtbk5hbWVkKCJjaHVuayIpLmlzTE9CKCkpOwotCQlhc3NlcnRTYW1lKGJhclRhYmxlLCBiYXJGSy5nZXRSZWZlcmVuY2VkVGFibGUoKSk7Ci0KLQkJLy8gRk9PX0JBWgotCQlUYWJsZSBmb29fYmF6VGFibGUgPSBzY2hlbWEuZ2V0VGFibGVOYW1lZCgiZm9vX2JheiIpOwotCQlhc3NlcnRFcXVhbHMoMiwgZm9vX2JhelRhYmxlLmNvbHVtbnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgZm9vX2JhelRhYmxlLnByaW1hcnlLZXlDb2x1bW5zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGZvb19iYXpUYWJsZS5mb3JlaWduS2V5c1NpemUoKSk7Ci0JCWFzc2VydFRydWUoZm9vX2JhelRhYmxlLmlzUG9zc2libGVKb2luVGFibGUoKSk7Ci0JCWFzc2VydFRydWUoZm9vX2JhelRhYmxlLmpvaW5UYWJsZU5hbWVJc0RlZmF1bHQoKSk7Ci0JCWFzc2VydFRydWUoZm9vX2JhelRhYmxlLmdldENvbHVtbk5hbWVkKCJmb29faWQiKS5pc1BhcnRPZkZvcmVpZ25LZXkoKSk7Ci0KLQkJdGhpcy5kcm9wVGFibGUodGhpcy5nZXREYXRhYmFzZU5hbWUoKSwgImZvb19iYXoiKTsKLQkJdGhpcy5kcm9wVGFibGUodGhpcy5nZXREYXRhYmFzZU5hbWUoKSwgImJheiIpOwotCQl0aGlzLmRyb3BUYWJsZSh0aGlzLmdldERhdGFiYXNlTmFtZSgpLCAiZm9vIik7Ci0JCXRoaXMuZHJvcFRhYmxlKHRoaXMuZ2V0RGF0YWJhc2VOYW1lKCksICJiYXIiKTsKLQotCQl0aGlzLmRyb3BEYXRhYmFzZSh0aGlzLmdldERhdGFiYXNlTmFtZSgpKTsKLQotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCX0KLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBDUiA9IFN5c3RlbS5nZXRQcm9wZXJ0eSgibGluZS5zZXBhcmF0b3IiKTsgIC8vJE5PTi1OTFMtMSQKLQotCXByaXZhdGUgU3RyaW5nIGJ1aWxkQmFyRERMKCkgewotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoMjAwKTsKLQkJc2IuYXBwZW5kKCJDUkVBVEUgVEFCTEUgYmFyICgiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBpZCBJTlRFR0VSIFBSSU1BUlkgS0VZLCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIGNodW5rIEJMT0IiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIikiKS5hcHBlbmQoQ1IpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBidWlsZEZvb0RETCgpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXNiLmFwcGVuZCgiQ1JFQVRFIFRBQkxFIGZvbyAoIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgaWQgSU5URUdFUiBQUklNQVJZIEtFWSwiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBuYW1lIFZBUkNIQVIoMjApLCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIGJhcl9pZCBJTlRFR0VSLCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIEZPUkVJR04gS0VZIChiYXJfaWQpIFJFRkVSRU5DRVMgYmFyKGlkKSIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiKSIpLmFwcGVuZChDUik7Ci0JCXJldHVybiBzYi50b1N0cmluZygpOwotCX0KLQotCXByaXZhdGUgU3RyaW5nIGJ1aWxkQmF6RERMKCkgewotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoMjAwKTsKLQkJc2IuYXBwZW5kKCJDUkVBVEUgVEFCTEUgYmF6ICgiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBpZCBJTlRFR0VSIFBSSU1BUlkgS0VZLCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIG5hbWUgVkFSQ0hBUigyMCkiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIikiKS5hcHBlbmQoQ1IpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBidWlsZEZvb0JhekRETCgpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXNiLmFwcGVuZCgiQ1JFQVRFIFRBQkxFIGZvb19iYXogKCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIGZvb19pZCBJTlQsIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgYmF6X2lkIElOVCwiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBGT1JFSUdOIEtFWSAoZm9vX2lkKSBSRUZFUkVOQ0VTIGZvbyhpZCksIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgRk9SRUlHTiBLRVkgKGJhel9pZCkgUkVGRVJFTkNFUyBiYXooaWQpIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIpIikuYXBwZW5kKENSKTsKLQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7Ci0JfQotCi0JLyoqCi0JICogT24gV2luZG93cywgdGFibGUgbmFtZXMgZ2V0IGZvbGRlZCB0byBsb3dlcmNhc2UgYnkgZGVmYXVsdDsKLQkgKiBldmVuIGlmIHRoZSBuYW1lIGlzIGRlbGltaXRlZCAoYXBwYXJlbnRseSkuCi0JICovCi0JcHVibGljIHZvaWQgdGVzdFRhYmxlTG9va3VwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpOwotCQlUZXN0Q29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IFRlc3RDb25uZWN0aW9uTGlzdGVuZXIoKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5hZGRDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCi0JCXRoaXMuZHJvcERhdGFiYXNlKHRoaXMuZ2V0RGF0YWJhc2VOYW1lKCkpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBEQVRBQkFTRSAiICsgdGhpcy5nZXREYXRhYmFzZU5hbWUoKSk7Ci0JCXRoaXMuZ2V0SkRCQ0Nvbm5lY3Rpb24oKS5zZXRDYXRhbG9nKHRoaXMuZ2V0RGF0YWJhc2VOYW1lKCkpOwotCi0JCXRoaXMuZHJvcFRhYmxlKHRoaXMuZ2V0RGF0YWJhc2VOYW1lKCksICJ0ZXN0MSIpOwotCQl0aGlzLmRyb3BUYWJsZSh0aGlzLmdldERhdGFiYXNlTmFtZSgpLCAiVEVTVDIiKTsKLQkJdGhpcy5kcm9wVGFibGUodGhpcy5nZXREYXRhYmFzZU5hbWUoKSwgImBURVNUM2AiKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBUQUJMRSB0ZXN0MSAoaWQgSU5URUdFUiwgbmFtZSBWQVJDSEFSKDIwKSkiKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgVEFCTEUgVEVTVDIgKGlkIElOVEVHRVIsIG5hbWUgVkFSQ0hBUigyMCkpIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFRBQkxFIGBURVNUM2AgKGlkIElOVEVHRVIsIG5hbWUgVkFSQ0hBUigyMCkpIik7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCVNjaGVtYSBzY2hlbWEgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0RGVmYXVsdFNjaGVtYSgpOwotCi0JCVRhYmxlIHRlc3QxVGFibGUgPSBzY2hlbWEuZ2V0VGFibGVGb3JJZGVudGlmaWVyKCJ0ZXN0MSIpOwotCQlhc3NlcnROb3ROdWxsKHRlc3QxVGFibGUpOwotCi0JCS8vIHRoaXMgcHJvYmFibHkgb25seSB3b3JrcyBvbiBXaW5kb3dzCi0JCVRhYmxlIHRlc3QyVGFibGUgPSBzY2hlbWEuZ2V0VGFibGVGb3JJZGVudGlmaWVyKCJ0ZXN0MiIpOwotCQlhc3NlcnROb3ROdWxsKHRlc3QyVGFibGUpOwotCi0JCS8vIHRoaXMgcHJvYmFibHkgb25seSB3b3JrcyBvbiBXaW5kb3dzCi0JCVRhYmxlIHRlc3QzVGFibGUgPSBzY2hlbWEuZ2V0VGFibGVGb3JJZGVudGlmaWVyKCJgdGVzdDNgIik7Ci0JCWFzc2VydE5vdE51bGwodGVzdDNUYWJsZSk7Ci0KLQkJdGhpcy5kcm9wVGFibGUodGhpcy5nZXREYXRhYmFzZU5hbWUoKSwgInRlc3QxIik7Ci0JCXRoaXMuZHJvcFRhYmxlKHRoaXMuZ2V0RGF0YWJhc2VOYW1lKCksICJURVNUMiIpOwotCQl0aGlzLmRyb3BUYWJsZSh0aGlzLmdldERhdGFiYXNlTmFtZSgpLCAiYFRFU1QzYCIpOwotCi0JCXRoaXMuZHJvcERhdGFiYXNlKHRoaXMuZ2V0RGF0YWJhc2VOYW1lKCkpOwotCi0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUucmVtb3ZlQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5kaXNjb25uZWN0KCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbHVtbkxvb2t1cCgpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmNvbm5lY3QoKTsKLQkJVGVzdENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBUZXN0Q29ubmVjdGlvbkxpc3RlbmVyKCk7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuYWRkQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQotCQl0aGlzLmRyb3BEYXRhYmFzZSh0aGlzLmdldERhdGFiYXNlTmFtZSgpKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgREFUQUJBU0UgIiArIHRoaXMuZ2V0RGF0YWJhc2VOYW1lKCkpOwotCQl0aGlzLmdldEpEQkNDb25uZWN0aW9uKCkuc2V0Q2F0YWxvZyh0aGlzLmdldERhdGFiYXNlTmFtZSgpKTsKLQotCQl0aGlzLmRyb3BUYWJsZSh0aGlzLmdldERhdGFiYXNlTmFtZSgpLCAidGVzdCIpOwotCi0JCS8vIGxvd2VyY2FzZQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBUQUJMRSB0ZXN0IChpZCBJTlRFR0VSLCBuYW1lIFZBUkNIQVIoMjApKSIpOwotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQotCQlUYWJsZSB0YWJsZSA9IHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXREZWZhdWx0U2NoZW1hKCkuZ2V0VGFibGVOYW1lZCgidGVzdCIpOwotCQlhc3NlcnROb3ROdWxsKHRhYmxlLmdldENvbHVtbk5hbWVkKCJpZCIpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0YWJsZS5nZXRDb2x1bW5OYW1lZCgibmFtZSIpKTsKLQotCQl0aGlzLmRyb3BUYWJsZSh0aGlzLmdldERhdGFiYXNlTmFtZSgpLCAidGVzdCIpOwotCi0JCS8vIHVwcGVyY2FzZQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBUQUJMRSB0ZXN0IChJRCBJTlRFR0VSLCBOQU1FIFZBUkNIQVIoMjApKSIpOwotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQotCQl0YWJsZSA9IHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXREZWZhdWx0U2NoZW1hKCkuZ2V0VGFibGVOYW1lZCgidGVzdCIpOwotCQlhc3NlcnROb3ROdWxsKHRhYmxlLmdldENvbHVtbk5hbWVkKCJJRCIpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0YWJsZS5nZXRDb2x1bW5OYW1lZCgiTkFNRSIpKTsKLQotCQl0aGlzLmRyb3BUYWJsZSh0aGlzLmdldERhdGFiYXNlTmFtZSgpLCAidGVzdCIpOwotCi0JCS8vIG1peGVkIGNhc2UKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgVEFCTEUgdGVzdCAoSWQgSU5URUdFUiwgTmFtZSBWQVJDSEFSKDIwKSkiKTsKLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0KLQkJdGFibGUgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0RGVmYXVsdFNjaGVtYSgpLmdldFRhYmxlTmFtZWQoInRlc3QiKTsKLQkJYXNzZXJ0Tm90TnVsbCh0YWJsZS5nZXRDb2x1bW5OYW1lZCgiSWQiKSk7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uTmFtZWQoIk5hbWUiKSk7Ci0KLQkJdGhpcy5kcm9wVGFibGUodGhpcy5nZXREYXRhYmFzZU5hbWUoKSwgInRlc3QiKTsKLQotCQkvLyBkZWxpbWl0ZWQKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgVEFCTEUgdGVzdCAoYElkYCBJTlRFR0VSLCBgTmFtZWAgVkFSQ0hBUigyMCkpIik7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCXRhYmxlID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldERlZmF1bHRTY2hlbWEoKS5nZXRUYWJsZU5hbWVkKCJ0ZXN0Iik7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiYElkYCIpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0YWJsZS5nZXRDb2x1bW5Gb3JJZGVudGlmaWVyKCJgTmFtZWAiKSk7Ci0KLQkJdGhpcy5kcm9wVGFibGUodGhpcy5nZXREYXRhYmFzZU5hbWUoKSwgInRlc3QiKTsKLQotCQl0aGlzLmRyb3BEYXRhYmFzZSh0aGlzLmdldERhdGFiYXNlTmFtZSgpKTsKLQotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCX0KLQotCS8qKgotCSAqIFdlIGNhbiBvbmx5IGdldCBhIHNpbmdsZSAic2NoZW1hIiBwZXIgY29ubmVjdGlvbiB2aWEgRFRQLAotCSAqIHNvIGNyb3NzLXNjaGVtYSByZWZlcmVuY2VzIGFyZSBub3QgdmlzaWJsZS4KLQkgKi8KLQlwdWJsaWMgdm9pZCB0ZXN0Q3Jvc3NTY2hlbWFSZWZlcmVuY2UoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5jb25uZWN0KCk7Ci0JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJdGhpcy5kcm9wRGF0YWJhc2UoInhyZWZfdGVzdDIiKTsKLQkJdGhpcy5kcm9wRGF0YWJhc2UoInhyZWZfdGVzdDEiKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBEQVRBQkFTRSB4cmVmX3Rlc3QxIik7Ci0JCXRoaXMuZ2V0SkRCQ0Nvbm5lY3Rpb24oKS5zZXRDYXRhbG9nKCJ4cmVmX3Rlc3QxIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFRBQkxFIG9yZyAoaWQgSU5URUdFUiBQUklNQVJZIEtFWSwgbmFtZSBWQVJDSEFSKDIwKSkiKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBEQVRBQkFTRSB4cmVmX3Rlc3QyIik7Ci0JCXRoaXMuZ2V0SkRCQ0Nvbm5lY3Rpb24oKS5zZXRDYXRhbG9nKCJ4cmVmX3Rlc3QyIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFRBQkxFIGVtcCAoaWQgSU5URUdFUiBQUklNQVJZIEtFWSwgbmFtZSBWQVJDSEFSKDIwKSwgIiArCi0JCQkJIm9yZ19pZCBJTlRFR0VSLCBGT1JFSUdOIEtFWSAob3JnX2lkKSBSRUZFUkVOQ0VTIHhyZWZfdGVzdDEub3JnKGlkKSkiKTsKLQotCQl0aGlzLmdldEpEQkNDb25uZWN0aW9uKCkuc2V0Q2F0YWxvZygieHJlZl90ZXN0MiIpOwotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQkJU2NoZW1hIHNjaGVtYTIgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0RGVmYXVsdFNjaGVtYSgpOwotCQlhc3NlcnROb3ROdWxsKHNjaGVtYTIpOwotCQlUYWJsZSBlbXBUYWJsZSA9IHNjaGVtYTIuZ2V0VGFibGVOYW1lZCgiZW1wIik7Ci0JCWFzc2VydE5vdE51bGwoZW1wVGFibGUpOwotCQkvLyBubyBmb3JlaWduIGtleXMKLQkJYXNzZXJ0RXF1YWxzKDAsIGVtcFRhYmxlLmZvcmVpZ25LZXlzU2l6ZSgpKTsKLQotCQl0aGlzLmRyb3BEYXRhYmFzZSgieHJlZl90ZXN0MiIpOwotCQl0aGlzLmRyb3BEYXRhYmFzZSgieHJlZl90ZXN0MSIpOwotCi0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUucmVtb3ZlQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5kaXNjb25uZWN0KCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGRyb3BUYWJsZShTdHJpbmcgZGJOYW1lLCBTdHJpbmcgdGFibGVOYW1lKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJEUk9QIFRBQkxFIElGIEVYSVNUUyAiICsgZGJOYW1lICsgJy4nICsgdGFibGVOYW1lKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgZHJvcERhdGFiYXNlKFN0cmluZyBuYW1lKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJEUk9QIERBVEFCQVNFIElGIEVYSVNUUyAiICsgbmFtZSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm1zL09yYWNsZTEwZ1Rlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm1zL09yYWNsZTEwZ1Rlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJkNzA4MjUuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3Rlc3RzL2ludGVybmFsL3BsYXRmb3Jtcy9PcmFjbGUxMGdUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzk3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzLmludGVybmFsLnBsYXRmb3JtczsKLQotaW1wb3J0IGphdmEuc3FsLlNRTEV4Y2VwdGlvbjsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuc3FtLmNvcmUucnRlLklDYXRhbG9nT2JqZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5Db2x1bW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkZvcmVpZ25LZXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLlNjaGVtYTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuVGFibGU7Ci0KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIE9yYWNsZTEwZ1Rlc3RzIGV4dGVuZHMgRFRQUGxhdGZvcm1UZXN0cyB7Ci0KLQlwdWJsaWMgT3JhY2xlMTBnVGVzdHMoIFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKCBuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldFBsYXRmb3JtUHJvcGVydGllc0ZpbGVOYW1lKCkgewotCQlyZXR1cm4gIm9yYWNsZTEwZy5wcm9wZXJ0aWVzIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERyaXZlck5hbWUoKSB7Ci0JCXJldHVybiAiT3JhY2xlIDEwZyBUaGluIERyaXZlciI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXREcml2ZXJEZWZpbml0aW9uSUQoKSB7Ci0JCXJldHVybiAiRHJpdmVyRGVmbi5PcmFjbGUgVGhpbiBEcml2ZXIiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RHJpdmVyRGVmaW5pdGlvblR5cGUoKSB7Ci0JCXJldHVybiAib3JnLmVjbGlwc2UuZGF0YXRvb2xzLmVuYWJsZW1lbnQub3JhY2xlLjEwLmRyaXZlclRlbXBsYXRlIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERhdGFiYXNlVmVuZG9yKCkgewotCQlyZXR1cm4gIk9yYWNsZSI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXREYXRhYmFzZVZlcnNpb24oKSB7Ci0JCXJldHVybiAiMTAiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RHJpdmVyQ2xhc3MoKSB7Ci0JCXJldHVybiAib3JhY2xlLmpkYmMuT3JhY2xlRHJpdmVyIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldFByb2ZpbGVOYW1lKCkgewotCQlyZXR1cm4gIk9yYWNsZTEwZ18xMC4xLjAuNCI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXRQcm9maWxlRGVzY3JpcHRpb24oKSB7Ci0JCXJldHVybiAiT3JhY2xlMTBnICgxMC4xLjAuNCkgSkRCQyBQcm9maWxlIFtUZXN0XSI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIGJvb2xlYW4gc3VwcG9ydHNDYXRhbG9ncygpIHsKLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBib29sZWFuIGV4ZWN1dGVPZmZsaW5lVGVzdHMoKSB7Ci0JCS8vIHdvcmtpbmcgb2ZmbGluZSBpcyBwcmV0dHkgdWdseQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdERhdGFiYXNlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWlmICh0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmdldFVzZXJOYW1lKCkudG9VcHBlckNhc2UoKS5lcXVhbHMoIlNZUyIpKSB7Ci0JCQlTeXN0ZW0ub3V0LnByaW50bG4oInNraXBwZWQgdGVzdDogIiArIHRoaXMuZ2V0Q2xhc3MoKSArICcuJyArIHRoaXMuZ2V0TmFtZSgpKTsKLQkJCXJldHVybjsgIC8vIFNZUyBkb2VzIG5vdCBoYXZlIGEgc2NoZW1hCi0JCX0KLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5jb25uZWN0KCk7Ci0JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJLy8gT3JhY2xlIHNob3VsZCBoYXZlIGEgc2NoZW1hIHdpdGggdGhlIHNhbWUgbmFtZSBhcyB0aGUgdXNlcgotCQlTY2hlbWEgc2NoZW1hID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldFNjaGVtYUZvcklkZW50aWZpZXIodGhpcy5nZXRVc2VySUQoKSk7Ci0JCWFzc2VydE5vdE51bGwoc2NoZW1hKTsKLQkJYXNzZXJ0U2FtZSh0aGlzLmdldERhdGFiYXNlKCkuZ2V0RGVmYXVsdFNjaGVtYSgpLCBzY2hlbWEpOwotCi0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUucmVtb3ZlQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5kaXNjb25uZWN0KCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFRhYmxlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpOwotCQlUZXN0Q29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IFRlc3RDb25uZWN0aW9uTGlzdGVuZXIoKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5hZGRDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCi0JCXRoaXMuZHJvcFRhYmxlKCJmb29fYmF6Iik7Ci0JCXRoaXMuZHJvcFRhYmxlKCJiYXoiKTsKLQkJdGhpcy5kcm9wVGFibGUoImZvbyIpOwotCQl0aGlzLmRyb3BUYWJsZSgiYmFyIik7Ci0KLQkJdGhpcy5leGVjdXRlVXBkYXRlKHRoaXMuYnVpbGRCYXJEREwoKSk7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSh0aGlzLmJ1aWxkRm9vRERMKCkpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUodGhpcy5idWlsZEJhekRETCgpKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKHRoaXMuYnVpbGRGb29CYXpEREwoKSk7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCVNjaGVtYSBzY2hlbWEgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0RGVmYXVsdFNjaGVtYSgpOwotCi0JCS8vIGZvbwotCQlUYWJsZSBmb29UYWJsZSA9IHNjaGVtYS5nZXRUYWJsZUZvcklkZW50aWZpZXIoImZvbyIpOwotCQlhc3NlcnRFcXVhbHMoMywgZm9vVGFibGUuY29sdW1uc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBmb29UYWJsZS5wcmltYXJ5S2V5Q29sdW1uc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBmb29UYWJsZS5mb3JlaWduS2V5c1NpemUoKSk7Ci0KLQkJQ29sdW1uIHBrQ29sdW1uID0gZm9vVGFibGUuZ2V0UHJpbWFyeUtleUNvbHVtbigpOwotCQlhc3NlcnRFcXVhbHMoIklEIiwgcGtDb2x1bW4uZ2V0TmFtZSgpKTsKLQkJQ29sdW1uIGlkQ29sdW1uID0gZm9vVGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiaWQiKTsKLQkJYXNzZXJ0U2FtZShwa0NvbHVtbiwgaWRDb2x1bW4pOwotCQlhc3NlcnRFcXVhbHMoIk5VTUJFUiIsIGlkQ29sdW1uLmdldERhdGFUeXBlTmFtZSgpKTsKLQkJYXNzZXJ0U2FtZShmb29UYWJsZSwgaWRDb2x1bW4uZ2V0VGFibGUoKSk7Ci0JCWFzc2VydFRydWUoaWRDb2x1bW4uaXNQYXJ0T2ZQcmltYXJ5S2V5KCkpOwotCQlhc3NlcnRGYWxzZShpZENvbHVtbi5pc1BhcnRPZkZvcmVpZ25LZXkoKSk7Ci0JCWFzc2VydEVxdWFscygiamF2YS5tYXRoLkJpZ0RlY2ltYWwiLCBpZENvbHVtbi5nZXRKYXZhVHlwZURlY2xhcmF0aW9uKCkpOwotCi0JCUNvbHVtbiBuYW1lQ29sdW1uID0gZm9vVGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigibmFtZSIpOwotCQlhc3NlcnRFcXVhbHMoIlZBUkNIQVIyIiwgbmFtZUNvbHVtbi5nZXREYXRhVHlwZU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygiamF2YS5sYW5nLlN0cmluZyIsIG5hbWVDb2x1bW4uZ2V0SmF2YVR5cGVEZWNsYXJhdGlvbigpKTsKLQkJYXNzZXJ0RmFsc2UobmFtZUNvbHVtbi5pc1BhcnRPZlByaW1hcnlLZXkoKSk7Ci0KLQkJQ29sdW1uIGJhckNvbHVtbiA9IGZvb1RhYmxlLmdldENvbHVtbkZvcklkZW50aWZpZXIoImJhcl9pZCIpOwotCQlhc3NlcnRFcXVhbHMoIk5VTUJFUiIsIGJhckNvbHVtbi5nZXREYXRhVHlwZU5hbWUoKSk7Ci0JCWFzc2VydFRydWUoYmFyQ29sdW1uLmlzUGFydE9mRm9yZWlnbktleSgpKTsKLQkJYXNzZXJ0RmFsc2UoYmFyQ29sdW1uLmlzUGFydE9mUHJpbWFyeUtleSgpKTsKLQotCQlGb3JlaWduS2V5IGJhckZLID0gZm9vVGFibGUuZm9yZWlnbktleXMoKS5uZXh0KCk7ICAvLyB0aGVyZSBzaG91bGQgb25seSBiZSAxIGZvcmVpZ24ga2V5Ci0JCWFzc2VydEVxdWFscygxLCBiYXJGSy5jb2x1bW5QYWlyc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygiQkFSIiwgYmFyRksuZ2V0QXR0cmlidXRlTmFtZSgpKTsKLQkJYXNzZXJ0TnVsbChiYXJGSy5nZXRKb2luQ29sdW1uQW5ub3RhdGlvbklkZW50aWZpZXIoImJhciIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJCQVJfSUQiLCBiYXJGSy5nZXRKb2luQ29sdW1uQW5ub3RhdGlvbklkZW50aWZpZXIoInByaW1hcnlCYXIiKSk7Ci0JCWFzc2VydFNhbWUoZm9vVGFibGUsIGJhckZLLmdldEJhc2VUYWJsZSgpKTsKLQotCQlhc3NlcnRGYWxzZShmb29UYWJsZS5pc1Bvc3NpYmxlSm9pblRhYmxlKCkpOwotCQlhc3NlcnRTYW1lKHNjaGVtYSwgZm9vVGFibGUuZ2V0U2NoZW1hKCkpOwotCi0JCS8vIEJBUgotCQlUYWJsZSBiYXJUYWJsZSA9IHNjaGVtYS5nZXRUYWJsZUZvcklkZW50aWZpZXIoImJhciIpOwotCQlhc3NlcnRFcXVhbHMoMiwgYmFyVGFibGUuY29sdW1uc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBiYXJUYWJsZS5wcmltYXJ5S2V5Q29sdW1uc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygwLCBiYXJUYWJsZS5mb3JlaWduS2V5c1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygiSUQiLCBiYXJUYWJsZS5nZXRQcmltYXJ5S2V5Q29sdW1uKCkuZ2V0TmFtZSgpKTsKLQkJYXNzZXJ0RmFsc2UoYmFyVGFibGUuaXNQb3NzaWJsZUpvaW5UYWJsZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJCTE9CIiwgYmFyVGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiY2h1bmsiKS5nZXREYXRhVHlwZU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygiYnl0ZVtdIiwgYmFyVGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiY2h1bmsiKS5nZXRKYXZhVHlwZURlY2xhcmF0aW9uKCkpOwotCQlhc3NlcnRUcnVlKGJhclRhYmxlLmdldENvbHVtbkZvcklkZW50aWZpZXIoImNodW5rIikuaXNMT0IoKSk7Ci0JCWFzc2VydFNhbWUoYmFyVGFibGUsIGJhckZLLmdldFJlZmVyZW5jZWRUYWJsZSgpKTsKLQotCQkvLyBGT09fQkFaCi0JCVRhYmxlIGZvb19iYXpUYWJsZSA9IHNjaGVtYS5nZXRUYWJsZUZvcklkZW50aWZpZXIoImZvb19iYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGZvb19iYXpUYWJsZS5jb2x1bW5zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGZvb19iYXpUYWJsZS5wcmltYXJ5S2V5Q29sdW1uc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygyLCBmb29fYmF6VGFibGUuZm9yZWlnbktleXNTaXplKCkpOwotCQlhc3NlcnRUcnVlKGZvb19iYXpUYWJsZS5pc1Bvc3NpYmxlSm9pblRhYmxlKCkpOwotCQlhc3NlcnRUcnVlKGZvb19iYXpUYWJsZS5qb2luVGFibGVOYW1lSXNEZWZhdWx0KCkpOwotCQlhc3NlcnRUcnVlKGZvb19iYXpUYWJsZS5nZXRDb2x1bW5Gb3JJZGVudGlmaWVyKCJmb29faWQiKS5pc1BhcnRPZkZvcmVpZ25LZXkoKSk7Ci0KLQkJdGhpcy5kcm9wVGFibGUoImZvb19iYXoiKTsKLQkJdGhpcy5kcm9wVGFibGUoImJheiIpOwotCQl0aGlzLmRyb3BUYWJsZSgiZm9vIik7Ci0JCXRoaXMuZHJvcFRhYmxlKCJiYXIiKTsKLQotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCX0KLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBDUiA9IFN5c3RlbS5nZXRQcm9wZXJ0eSgibGluZS5zZXBhcmF0b3IiKTsgIC8vJE5PTi1OTFMtMSQKLQotCXByaXZhdGUgU3RyaW5nIGJ1aWxkQmFyRERMKCkgewotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoMjAwKTsKLQkJc2IuYXBwZW5kKCJDUkVBVEUgVEFCTEUgYmFyICgiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBpZCBOVU1CRVIoMTApIFBSSU1BUlkgS0VZLCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIGNodW5rIEJMT0IiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIikiKS5hcHBlbmQoQ1IpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBidWlsZEZvb0RETCgpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXNiLmFwcGVuZCgiQ1JFQVRFIFRBQkxFIGZvbyAoIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgaWQgTlVNQkVSKDEwKSBQUklNQVJZIEtFWSwiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBuYW1lIFZBUkNIQVIyKDIwKSwiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBiYXJfaWQgUkVGRVJFTkNFUyBiYXIoaWQpIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIpIikuYXBwZW5kKENSKTsKLQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmcgYnVpbGRCYXpEREwoKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigyMDApOwotCQlzYi5hcHBlbmQoIkNSRUFURSBUQUJMRSBiYXogKCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIGlkIE5VTUJFUigxMCkgUFJJTUFSWSBLRVksIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgbmFtZSBWQVJDSEFSMigyMCkiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIikiKS5hcHBlbmQoQ1IpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBidWlsZEZvb0JhekRETCgpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXNiLmFwcGVuZCgiQ1JFQVRFIFRBQkxFIGZvb19iYXogKCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIGZvb19pZCBOVU1CRVIoMTApIFJFRkVSRU5DRVMgZm9vKGlkKSwiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBiYXpfaWQgTlVNQkVSKDEwKSBSRUZFUkVOQ0VTIGJheihpZCkiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIikiKS5hcHBlbmQoQ1IpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VGFibGVMb29rdXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5jb25uZWN0KCk7Ci0JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJdGhpcy5kcm9wVGFibGUoInRlc3QxIik7Ci0JCXRoaXMuZHJvcFRhYmxlKCJURVNUMiIpOwotCQl0aGlzLmRyb3BUYWJsZSgiXCJ0ZXN0M1wiIik7Ci0KLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgVEFCTEUgdGVzdDEgKGlkIE5VTUJFUigxMCksIG5hbWUgVkFSQ0hBUjIoMjApKSIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBUQUJMRSBURVNUMiAoaWQgTlVNQkVSKDEwKSwgbmFtZSBWQVJDSEFSMigyMCkpIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFRBQkxFIFwidGVzdDNcIiAoaWQgTlVNQkVSKDEwKSwgbmFtZSBWQVJDSEFSMigyMCkpIik7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCVNjaGVtYSBzY2hlbWEgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0RGVmYXVsdFNjaGVtYSgpOwotCi0JCVRhYmxlIHRlc3QxVGFibGUgPSBzY2hlbWEuZ2V0VGFibGVGb3JJZGVudGlmaWVyKCJ0ZXN0MSIpOwotCQlhc3NlcnROb3ROdWxsKHRlc3QxVGFibGUpOwotCQl0ZXN0MVRhYmxlID0gc2NoZW1hLmdldFRhYmxlRm9ySWRlbnRpZmllcigiVEVTVDEiKTsKLQkJYXNzZXJ0Tm90TnVsbCh0ZXN0MVRhYmxlKTsKLQotCQlUYWJsZSB0ZXN0MlRhYmxlID0gc2NoZW1hLmdldFRhYmxlRm9ySWRlbnRpZmllcigidGVzdDIiKTsKLQkJYXNzZXJ0Tm90TnVsbCh0ZXN0MlRhYmxlKTsKLQkJdGVzdDJUYWJsZSA9IHNjaGVtYS5nZXRUYWJsZUZvcklkZW50aWZpZXIoIlRFU1QyIik7Ci0JCWFzc2VydE5vdE51bGwodGVzdDJUYWJsZSk7Ci0KLQkJVGFibGUgdGVzdDNUYWJsZSA9IHNjaGVtYS5nZXRUYWJsZUZvcklkZW50aWZpZXIoIlwidGVzdDNcIiIpOwotCQlhc3NlcnROb3ROdWxsKHRlc3QzVGFibGUpOwotCQl0ZXN0M1RhYmxlID0gc2NoZW1hLmdldFRhYmxlRm9ySWRlbnRpZmllcigidGVzdDMiKTsKLQkJYXNzZXJ0TnVsbCh0ZXN0M1RhYmxlKTsKLQotCQl0aGlzLmRyb3BUYWJsZSgidGVzdDEiKTsKLQkJdGhpcy5kcm9wVGFibGUoIlRFU1QyIik7Ci0JCXRoaXMuZHJvcFRhYmxlKCJcInRlc3QzXCIiKTsKLQotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb2x1bW5Mb29rdXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5jb25uZWN0KCk7Ci0JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJdGhpcy5kcm9wVGFibGUoInRlc3QiKTsKLQotCQkvLyBsb3dlcmNhc2UKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgVEFCTEUgdGVzdCAoaWQgTlVNQkVSKDEwKSwgbmFtZSBWQVJDSEFSMigyMCkpIik7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCVRhYmxlIHRhYmxlID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldERlZmF1bHRTY2hlbWEoKS5nZXRUYWJsZUZvcklkZW50aWZpZXIoInRlc3QiKTsKLQkJYXNzZXJ0Tm90TnVsbCh0YWJsZS5nZXRDb2x1bW5Gb3JJZGVudGlmaWVyKCJpZCIpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0YWJsZS5nZXRDb2x1bW5Gb3JJZGVudGlmaWVyKCJuYW1lIikpOwotCi0JCXRoaXMuZHJvcFRhYmxlKCJ0ZXN0Iik7Ci0KLQkJLy8gdXBwZXJjYXNlCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFRBQkxFIHRlc3QgKElEIE5VTUJFUigxMCksIE5BTUUgVkFSQ0hBUjIoMjApKSIpOwotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQotCQl0YWJsZSA9IHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXREZWZhdWx0U2NoZW1hKCkuZ2V0VGFibGVGb3JJZGVudGlmaWVyKCJ0ZXN0Iik7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiSUQiKSk7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiTkFNRSIpKTsKLQotCQl0aGlzLmRyb3BUYWJsZSgidGVzdCIpOwotCi0JCS8vIG1peGVkIGNhc2UKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgVEFCTEUgdGVzdCAoSWQgTlVNQkVSKDEwKSwgTmFtZSBWQVJDSEFSMigyMCkpIik7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCXRhYmxlID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldERlZmF1bHRTY2hlbWEoKS5nZXRUYWJsZUZvcklkZW50aWZpZXIoInRlc3QiKTsKLQkJYXNzZXJ0Tm90TnVsbCh0YWJsZS5nZXRDb2x1bW5Gb3JJZGVudGlmaWVyKCJJZCIpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0YWJsZS5nZXRDb2x1bW5Gb3JJZGVudGlmaWVyKCJOYW1lIikpOwotCi0JCXRoaXMuZHJvcFRhYmxlKCJ0ZXN0Iik7Ci0KLQkJLy8gZGVsaW1pdGVkCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFRBQkxFIHRlc3QgKFwiSWRcIiBOVU1CRVIoMTApLCBcIk5hbWVcIiBWQVJDSEFSMigyMCkpIik7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCXRhYmxlID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldERlZmF1bHRTY2hlbWEoKS5nZXRUYWJsZUZvcklkZW50aWZpZXIoInRlc3QiKTsKLQkJYXNzZXJ0Tm90TnVsbCh0YWJsZS5nZXRDb2x1bW5Gb3JJZGVudGlmaWVyKCJcIklkXCIiKSk7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiXCJOYW1lXCIiKSk7Ci0KLQkJdGhpcy5kcm9wVGFibGUoInRlc3QiKTsKLQotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDcm9zc1NjaGVtYVJlZmVyZW5jZSgpIHRocm93cyBFeGNlcHRpb24gewotCQlpZiAoICEgdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5nZXRVc2VyTmFtZSgpLnRvVXBwZXJDYXNlKCkuZXF1YWxzKCJTWVMiKSkgewotCQkJU3lzdGVtLm91dC5wcmludGxuKCJza2lwcGVkIHRlc3Q6ICIgKyB0aGlzLmdldENsYXNzKCkgKyAnLicgKyB0aGlzLmdldE5hbWUoKSk7Ci0JCQlyZXR1cm47ICAvLyBTWVMgZG9lcyBub3QgaGF2ZSBhIHNjaGVtYQotCQl9Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpOwotCQlUZXN0Q29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IFRlc3RDb25uZWN0aW9uTGlzdGVuZXIoKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5hZGRDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZUlnbm9yZUVycm9ycygiRFJPUCBVU0VSIFhSRUZfVEVTVDIgQ0FTQ0FERSIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGVJZ25vcmVFcnJvcnMoIkRST1AgVVNFUiBYUkVGX1RFU1QxIENBU0NBREUiKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBVU0VSIFhSRUZfVEVTVDEgSURFTlRJRklFRCBCWSBmb28iKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJBTFRFUiBVU0VSIFhSRUZfVEVTVDEgUVVPVEEgVU5MSU1JVEVEIE9OIFVTRVJTIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFRBQkxFIFhSRUZfVEVTVDEuT1JHIChJRCBOVU1CRVIoMTApIFBSSU1BUlkgS0VZLCBOQU1FIFZBUkNIQVIyKDIwKSkiKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBVU0VSIFhSRUZfVEVTVDIgSURFTlRJRklFRCBCWSBmb28iKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJBTFRFUiBVU0VSIFhSRUZfVEVTVDIgUVVPVEEgVU5MSU1JVEVEIE9OIFVTRVJTIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiR1JBTlQgQUxMIE9OIFhSRUZfVEVTVDEuT1JHIFRPIFhSRUZfVEVTVDIiKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgVEFCTEUgWFJFRl9URVNUMi5FTVAgKElEIE5VTUJFUigxMCkgUFJJTUFSWSBLRVksIE5BTUUgVkFSQ0hBUjIoMjApLCAiICsKLQkJCQkiT1JHX0lEIE5VTUJFUigxMCkgUkVGRVJFTkNFUyBYUkVGX1RFU1QxLk9SRyhJRCkpIik7Ci0KLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0JCVNjaGVtYSBzY2hlbWExID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldFNjaGVtYU5hbWVkKCJYUkVGX1RFU1QxIik7Ci0JCWFzc2VydE5vdE51bGwoc2NoZW1hMSk7Ci0JCVRhYmxlIG9yZ1RhYmxlID0gc2NoZW1hMS5nZXRUYWJsZU5hbWVkKCJPUkciKTsKLQkJYXNzZXJ0Tm90TnVsbChvcmdUYWJsZSk7Ci0KLQkJU2NoZW1hIHNjaGVtYTIgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0U2NoZW1hTmFtZWQoIlhSRUZfVEVTVDIiKTsKLQkJYXNzZXJ0Tm90TnVsbChzY2hlbWEyKTsKLQkJVGFibGUgZW1wVGFibGUgPSBzY2hlbWEyLmdldFRhYmxlTmFtZWQoIkVNUCIpOwotCQlhc3NlcnROb3ROdWxsKGVtcFRhYmxlKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIGVtcFRhYmxlLmZvcmVpZ25LZXlzU2l6ZSgpKTsKLQkJRm9yZWlnbktleSBmayA9IGVtcFRhYmxlLmZvcmVpZ25LZXlzKCkubmV4dCgpOwotCQlUYWJsZSByZWZUYWJsZSA9IGZrLmdldFJlZmVyZW5jZWRUYWJsZSgpOwotCQlhc3NlcnROb3ROdWxsKHJlZlRhYmxlKTsKLQkJYXNzZXJ0RXF1YWxzKCJPUkciLCByZWZUYWJsZS5nZXROYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgZmsuY29sdW1uUGFpcnNTaXplKCkpOwotCQlGb3JlaWduS2V5LkNvbHVtblBhaXIgY3AgPSBmay5jb2x1bW5QYWlycygpLm5leHQoKTsKLQkJQ29sdW1uIGJhc2VDb2x1bW4gPSBjcC5nZXRCYXNlQ29sdW1uKCk7Ci0JCWFzc2VydEVxdWFscygiT1JHX0lEIiwgYmFzZUNvbHVtbi5nZXROYW1lKCkpOwotCQlDb2x1bW4gcmVmQ29sdW1uID0gY3AuZ2V0UmVmZXJlbmNlZENvbHVtbigpOwotCQlhc3NlcnRFcXVhbHMoIklEIiwgcmVmQ29sdW1uLmdldE5hbWUoKSk7Ci0KLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJEUk9QIFVTRVIgWFJFRl9URVNUMiBDQVNDQURFIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiRFJPUCBVU0VSIFhSRUZfVEVTVDEgQ0FTQ0FERSIpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCX0KLQotCXByaXZhdGUgdm9pZCBkcm9wVGFibGUoU3RyaW5nIHRhYmxlTmFtZSkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZUlnbm9yZUVycm9ycygiRFJPUCBUQUJMRSAiICsgdGFibGVOYW1lICsgIiBDQVNDQURFIENPTlNUUkFJTlRTIik7Ci0JfQotCi0vLyBuZWVkIE9yYWNsZSBlbmFibGVtZW50IHBsdWctaW4KLS8vCXB1YmxpYyB2b2lkIHRlc3RTZXF1ZW5jZSgpIHRocm93cyBFeGNlcHRpb24gewotLy8JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpOwotLy8JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotLy8JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuYWRkQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLS8vCi0vLwkJdGhpcy5kcm9wU2VxdWVuY2UoIkZPT19TRVEiKTsKLS8vCi0vLwkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgU0VRVUVOQ0UgRk9PX1NFUSIpOwotLy8JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotLy8KLS8vCQlTZXF1ZW5jZSBzZXF1ZW5jZSA9IHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXREZWZhdWx0U2NoZW1hKCkuZ2V0U2VxdWVuY2VGb3JJZGVudGlmaWVyKCJGT08iKTsKLS8vCQlhc3NlcnROb3ROdWxsKHNlcXVlbmNlKTsKLS8vCQlhc3NlcnRFcXVhbHMoIkZPT19TRVEiLCBzZXF1ZW5jZS5nZXROYW1lKCkpOwotLy8KLS8vCQl0aGlzLmRyb3BTZXF1ZW5jZSgiRk9PX1NFUSIpOwotLy8KLS8vCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0vLwkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5kaXNjb25uZWN0KCk7Ci0vLwl9Ci0vLwotLy8JcHJpdmF0ZSB2b2lkIGRyb3BTZXF1ZW5jZShTdHJpbmcgc2VxdWVuY2VOYW1lKSB0aHJvd3MgRXhjZXB0aW9uIHsKLS8vCQl0aGlzLmV4ZWN1dGVVcGRhdGVJZ25vcmVFcnJvcnMoIkRST1AgU0VRVUVOQ0UgIiArIHNlcXVlbmNlTmFtZSk7Ci0vLwl9Ci0vLwotCXByb3RlY3RlZCB2b2lkIGR1bXBVc2VyT2JqZWN0cygpIHRocm93cyBTUUxFeGNlcHRpb24gewotCQl0aGlzLmR1bXAoInNlbGVjdCAqIGZyb20gdXNlcl9vYmplY3RzIik7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm1zL09yYWNsZTEwZ1hFVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi90ZXN0cy9pbnRlcm5hbC9wbGF0Zm9ybXMvT3JhY2xlMTBnWEVUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3ZjMwOWY4Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi90ZXN0cy9pbnRlcm5hbC9wbGF0Zm9ybXMvT3JhY2xlMTBnWEVUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMuaW50ZXJuYWwucGxhdGZvcm1zOwotCi0KLS8qKgotICogIE9yYWNsZSAxMGcgVGhpbiBEcml2ZXIgVGVzdAotICovCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBPcmFjbGUxMGdYRVRlc3RzIGV4dGVuZHMgRFRQUGxhdGZvcm1UZXN0cyB7Ci0KLQlwdWJsaWMgT3JhY2xlMTBnWEVUZXN0cyggU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIoIG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0UGxhdGZvcm1Qcm9wZXJ0aWVzRmlsZU5hbWUoKSB7Ci0JCXJldHVybiAib3JhY2xlMTBnWEUucHJvcGVydGllcyI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXREcml2ZXJOYW1lKCkgewotCQlyZXR1cm4gIk9yYWNsZSAxMGcgVGhpbiBEcml2ZXIiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RHJpdmVyRGVmaW5pdGlvbklEKCkgewotCQlyZXR1cm4gIkRyaXZlckRlZm4uT3JhY2xlIFRoaW4gRHJpdmVyIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERyaXZlckRlZmluaXRpb25UeXBlKCkgewotCQlyZXR1cm4gIm9yZy5lY2xpcHNlLmRhdGF0b29scy5lbmFibGVtZW50Lm9yYWNsZS4xMC5kcml2ZXJUZW1wbGF0ZSI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXREYXRhYmFzZVZlbmRvcigpIHsKLQkJcmV0dXJuICJPcmFjbGUiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RGF0YWJhc2VWZXJzaW9uKCkgewotCQlyZXR1cm4gIjEwIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERyaXZlckNsYXNzKCkgewotCQlyZXR1cm4gIm9yYWNsZS5qZGJjLk9yYWNsZURyaXZlciI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXRQcm9maWxlTmFtZSgpIHsKLQkJcmV0dXJuICJPcmFjbGUxMGdfWEUiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0UHJvZmlsZURlc2NyaXB0aW9uKCkgewotCQlyZXR1cm4gIk9yYWNsZTEwZyBYRSBSZWxlYXNlIDIgKDEwLjIpIEpEQkMgUHJvZmlsZSBbVGVzdF0iOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBib29sZWFuIHN1cHBvcnRzQ2F0YWxvZ3MoKSB7Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgYm9vbGVhbiBleGVjdXRlT2ZmbGluZVRlc3RzKCkgewotCQkvLyB3b3JraW5nIG9mZmxpbmUgaXMgcHJldHR5IHVnbHkKLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3Rlc3RzL2ludGVybmFsL3BsYXRmb3Jtcy9PcmFjbGU5aVRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm1zL09yYWNsZTlpVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOWQxYzQ3NC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm1zL09yYWNsZTlpVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDc5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzLmludGVybmFsLnBsYXRmb3JtczsKLQotCi0vKioKLSAqICBPcmFjbGUgOWkgVGhpbiBEcml2ZXIgVGVzdAotICovCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBPcmFjbGU5aVRlc3RzIGV4dGVuZHMgRFRQUGxhdGZvcm1UZXN0cyB7Ci0KLQlwdWJsaWMgT3JhY2xlOWlUZXN0cyggU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIoIG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0UGxhdGZvcm1Qcm9wZXJ0aWVzRmlsZU5hbWUoKSB7Ci0JCXJldHVybiAib3JhY2xlOWkucHJvcGVydGllcyI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXREcml2ZXJOYW1lKCkgewotCQlyZXR1cm4gIk9yYWNsZSA5aSBUaGluIERyaXZlciI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXREcml2ZXJEZWZpbml0aW9uSUQoKSB7Ci0JCXJldHVybiAiRHJpdmVyRGVmbi5PcmFjbGUgVGhpbiBEcml2ZXIiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RHJpdmVyRGVmaW5pdGlvblR5cGUoKSB7Ci0JCXJldHVybiAib3JnLmVjbGlwc2UuZGF0YXRvb2xzLmVuYWJsZW1lbnQub3JhY2xlLjkuZHJpdmVyVGVtcGxhdGUiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RGF0YWJhc2VWZW5kb3IoKSB7Ci0JCXJldHVybiAiT3JhY2xlIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERhdGFiYXNlVmVyc2lvbigpIHsKLQkJcmV0dXJuICI5IjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERyaXZlckNsYXNzKCkgewotCQlyZXR1cm4gIm9yYWNsZS5qZGJjLk9yYWNsZURyaXZlciI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXRQcm9maWxlTmFtZSgpIHsKLQkJcmV0dXJuICJPcmFjbGU5aSI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXRQcm9maWxlRGVzY3JpcHRpb24oKSB7Ci0JCXJldHVybiAiT3JhY2xlOWkgSkRCQyBQcm9maWxlIFtUZXN0XSI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIGJvb2xlYW4gc3VwcG9ydHNDYXRhbG9ncygpIHsKLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBib29sZWFuIGV4ZWN1dGVPZmZsaW5lVGVzdHMoKSB7Ci0JCS8vIHdvcmtpbmcgb2ZmbGluZSBpcyBwcmV0dHkgdWdseQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm1zL1Bvc3RncmVTUUxUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3Rlc3RzL2ludGVybmFsL3BsYXRmb3Jtcy9Qb3N0Z3JlU1FMVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzA2NjE0MS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm1zL1Bvc3RncmVTUUxUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDg2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzLmludGVybmFsLnBsYXRmb3JtczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuc3FtLmNvcmUucnRlLklDYXRhbG9nT2JqZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5Db2x1bW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkZvcmVpZ25LZXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLlNjaGVtYTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuVGFibGU7Ci0KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIFBvc3RncmVTUUxUZXN0cyBleHRlbmRzIERUUFBsYXRmb3JtVGVzdHMgewotCi0JcHVibGljIFBvc3RncmVTUUxUZXN0cyggU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIoIG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0UGxhdGZvcm1Qcm9wZXJ0aWVzRmlsZU5hbWUoKSB7Ci0JCXJldHVybiAicG9zdGdyZXNxbC5wcm9wZXJ0aWVzIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERyaXZlck5hbWUoKSB7Ci0JCXJldHVybiAiUG9zdGdyZVNRTCBKREJDIERyaXZlciI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXREcml2ZXJEZWZpbml0aW9uSUQoKSB7Ci0JCXJldHVybiAiRHJpdmVyRGVmbi5Qb3N0Z3JlU1FMIEpEQkMgRHJpdmVyIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERyaXZlckRlZmluaXRpb25UeXBlKCkgewotCQlyZXR1cm4gIm9yZy5lY2xpcHNlLmRhdGF0b29scy5lbmFibGVtZW50LnBvc3RncmVzcWwucG9zdGdyZXNxbERyaXZlclRlbXBsYXRlIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERhdGFiYXNlVmVuZG9yKCkgewotCQlyZXR1cm4gInBvc3RncmVzIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERhdGFiYXNlVmVyc2lvbigpIHsKLQkJcmV0dXJuICI4LngiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RHJpdmVyQ2xhc3MoKSB7Ci0JCXJldHVybiAib3JnLnBvc3RncmVzcWwuRHJpdmVyIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERlZmF1bHRKREJDVVJMKCkgewotCQkvLyB1c2luZyB0aGlzIFVSTCB3aWxsIHJlc3VsdCBpbiB0aGUgRFRQIGRhdGFiYXNlIGNvbnRhaW5pbmcgYSBzaW5nbGUKLQkJLy8gY2F0YWxvZyBuYW1lZCAiIiAtIHdoaWNoLCB1bmZvcnR1bmF0ZWx5LCByZXNlbWJsZXMgdGhlIHBzZXVkby1jYXRhbG9nCi0JCS8vIGdlbmVyYXRlZCBieSBEVFAgZm9yIGRhdGFiYXNlcyB0aGF0IGRvIG5vdCByZXR1cm4gYW55IGNhdGFsb2dzIHZpYQotCQkvLyBKREJDIG1ldGFkYXRhIGNhbGxzLi4uCi0JCXJldHVybiAiamRiYzpwb3N0Z3Jlc3FsIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldFByb2ZpbGVOYW1lKCkgewotCQlyZXR1cm4gIlBvc3RncmVTUUwiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0UHJvZmlsZURlc2NyaXB0aW9uKCkgewotCQlyZXR1cm4gIlBvc3RncmVTUUwgOC4yIEpEQkMgUHJvZmlsZSBbVGVzdF0iOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBib29sZWFuIHN1cHBvcnRzQ2F0YWxvZ3MoKSB7Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBib29sZWFuIGV4ZWN1dGVPZmZsaW5lVGVzdHMoKSB7Ci0JCS8vIERUUCBkb2VzIG5vdCBzdXBwb3J0IFBvc3RncmVTUUwgb2ZmLWxpbmUgLSBzZWUgMjI2NzA0LzI0MTU1OAotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNjaGVtYSgpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmNvbm5lY3QoKTsKLQkJVGVzdENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBUZXN0Q29ubmVjdGlvbkxpc3RlbmVyKCk7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuYWRkQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQotCQl0aGlzLmRyb3BTY2hlbWEoIlRFU1QxIik7Ci0JCXRoaXMuZHJvcFNjaGVtYSgiVEVTVDIiKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBTQ0hFTUEgVEVTVDEiKTsKLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0KLQkJU2NoZW1hIHNjaGVtYTEgPSB0aGlzLmdldERlZmF1bHRDYXRhbG9nKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcigiVEVTVDEiKTsKLQkJYXNzZXJ0Tm90TnVsbChzY2hlbWExKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBTQ0hFTUEgVEVTVDIiKTsKLQkJU2NoZW1hIHNjaGVtYTIgPSB0aGlzLmdldERlZmF1bHRDYXRhbG9nKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcigiVEVTVDIiKTsKLQkJYXNzZXJ0TnVsbChzY2hlbWEyKTsgIC8vIHNob3VsZCBiZSBudWxsIHVudGlsIHJlZnJlc2gKLQotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQkJYXNzZXJ0U2FtZSh0aGlzLmdldERhdGFiYXNlKCksIGxpc3RlbmVyLmNoYW5nZWREYXRhYmFzZSk7Ci0KLQkJc2NoZW1hMiA9IHRoaXMuZ2V0RGVmYXVsdENhdGFsb2coKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKCJURVNUMiIpOwotCQlhc3NlcnROb3ROdWxsKHNjaGVtYTIpOwotCQlhc3NlcnROb3RTYW1lKHNjaGVtYTEsIHRoaXMuZ2V0RGVmYXVsdENhdGFsb2coKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKCJURVNUMSIpKTsgIC8vIHdlIHNob3VsZCBoYXZlIGEgbmV3IHNjaGVtYSBhZnRlciB0aGUgcmVmcmVzaAotCi0JCXRoaXMuZHJvcFNjaGVtYSgiVEVTVDIiKTsKLQkJdGhpcy5kcm9wU2NoZW1hKCJURVNUMSIpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTY2hlbWFMb29rdXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5jb25uZWN0KCk7Ci0JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJdGhpcy5kcm9wU2NoZW1hKCJMT09LVVBfVEVTVCIpOwotCQl0aGlzLmRyb3BTY2hlbWEoIlwibG9va3VwX1RFU1RcIiIpOwotCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFNDSEVNQSBMT09LVVBfVEVTVCIpOwotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQotCQlhc3NlcnROdWxsKHRoaXMuZ2V0RGVmYXVsdENhdGFsb2coKS5nZXRTY2hlbWFOYW1lZCgiTE9PS1VQX1RFU1QiKSk7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5nZXREZWZhdWx0Q2F0YWxvZygpLmdldFNjaGVtYUZvcklkZW50aWZpZXIoIkxPT0tVUF9URVNUIikpOwotCi0JCWFzc2VydE5vdE51bGwodGhpcy5nZXREZWZhdWx0Q2F0YWxvZygpLmdldFNjaGVtYU5hbWVkKCJsb29rdXBfdGVzdCIpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmdldERlZmF1bHRDYXRhbG9nKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcigibG9va3VwX3Rlc3QiKSk7Ci0KLQkJYXNzZXJ0TnVsbCh0aGlzLmdldERlZmF1bHRDYXRhbG9nKCkuZ2V0U2NoZW1hTmFtZWQoImxvb2t1cF9URVNUIikpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZ2V0RGVmYXVsdENhdGFsb2coKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKCJsb29rdXBfVEVTVCIpKTsKLQotCQlhc3NlcnROb3ROdWxsKHRoaXMuZ2V0RGVmYXVsdENhdGFsb2coKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKCJcImxvb2t1cF90ZXN0XCIiKSk7Ci0JCWFzc2VydE51bGwodGhpcy5nZXREZWZhdWx0Q2F0YWxvZygpLmdldFNjaGVtYUZvcklkZW50aWZpZXIoIlwibG9va3VwX1RFU1RcIiIpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmdldERlZmF1bHRDYXRhbG9nKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcigiXCJMT09LVVBfVEVTVFwiIikpOwotCi0JCXRoaXMuZHJvcFNjaGVtYSgiTE9PS1VQX1RFU1QiKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBTQ0hFTUEgXCJsb29rdXBfVEVTVFwiIik7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCWFzc2VydE51bGwodGhpcy5nZXREZWZhdWx0Q2F0YWxvZygpLmdldFNjaGVtYU5hbWVkKCJMT09LVVBfVEVTVCIpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmdldERlZmF1bHRDYXRhbG9nKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcigiTE9PS1VQX1RFU1QiKSk7Ci0KLQkJYXNzZXJ0TnVsbCh0aGlzLmdldERlZmF1bHRDYXRhbG9nKCkuZ2V0U2NoZW1hTmFtZWQoImxvb2t1cF90ZXN0IikpOwotCQlhc3NlcnROdWxsKHRoaXMuZ2V0RGVmYXVsdENhdGFsb2coKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKCJsb29rdXBfdGVzdCIpKTsKLQotCQlhc3NlcnROb3ROdWxsKHRoaXMuZ2V0RGVmYXVsdENhdGFsb2coKS5nZXRTY2hlbWFOYW1lZCgibG9va3VwX1RFU1QiKSk7Ci0JCWFzc2VydE51bGwodGhpcy5nZXREZWZhdWx0Q2F0YWxvZygpLmdldFNjaGVtYUZvcklkZW50aWZpZXIoImxvb2t1cF9URVNUIikpOwotCi0JCWFzc2VydE51bGwodGhpcy5nZXREZWZhdWx0Q2F0YWxvZygpLmdldFNjaGVtYUZvcklkZW50aWZpZXIoIlwiTE9PS1VQX1RFU1RcIiIpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmdldERlZmF1bHRDYXRhbG9nKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcigiXCJsb29rdXBfVEVTVFwiIikpOwotCi0JCXRoaXMuZHJvcFNjaGVtYSgiXCJsb29rdXBfVEVTVFwiIik7Ci0KLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5yZW1vdmVDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmRpc2Nvbm5lY3QoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2NoZW1hSWRlbnRpZmllcigpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmNvbm5lY3QoKTsKLQkJVGVzdENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBUZXN0Q29ubmVjdGlvbkxpc3RlbmVyKCk7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuYWRkQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQotCQl0aGlzLmRyb3BTY2hlbWEoIkxPT0tVUF9URVNUIik7Ci0JCXRoaXMuZHJvcFNjaGVtYSgiXCJsb29rdXBfVEVTVFwiIik7Ci0KLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgU0NIRU1BIGxvb2t1cF90ZXN0Iik7ICAvLyB0aGlzIGdldHMgZm9sZGVkIHRvIGxvd2VyY2FzZQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBTQ0hFTUEgXCJsb29rdXBfVEVTVFwiIik7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCVNjaGVtYSBzY2hlbWEgPSB0aGlzLmdldERlZmF1bHRDYXRhbG9nKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcigiTE9PS1VQX1RFU1QiKTsKLQkJYXNzZXJ0RXF1YWxzKCJsb29rdXBfdGVzdCIsIHNjaGVtYS5nZXRJZGVudGlmaWVyKCkpOwotCQlhc3NlcnRFcXVhbHMoImxvb2t1cF90ZXN0Iiwgc2NoZW1hLmdldElkZW50aWZpZXIoIkxvb2t1cFRlc3QiKSk7Ci0JCWFzc2VydE51bGwoc2NoZW1hLmdldElkZW50aWZpZXIoIkxvb2t1cF9UZXN0IikpOwotCi0JCXNjaGVtYSA9IHRoaXMuZ2V0RGVmYXVsdENhdGFsb2coKS5nZXRTY2hlbWFOYW1lZCgibG9va3VwX3Rlc3QiKTsKLQkJYXNzZXJ0RXF1YWxzKCJsb29rdXBfdGVzdCIsIHNjaGVtYS5nZXRJZGVudGlmaWVyKCkpOwotCi0JCXNjaGVtYSA9IHRoaXMuZ2V0RGVmYXVsdENhdGFsb2coKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKCJcImxvb2t1cF9URVNUXCIiKTsKLQkJYXNzZXJ0RXF1YWxzKCJcImxvb2t1cF9URVNUXCIiLCBzY2hlbWEuZ2V0SWRlbnRpZmllcigpKTsKLQkJYXNzZXJ0RXF1YWxzKCJcImxvb2t1cF9URVNUXCIiLCBzY2hlbWEuZ2V0SWRlbnRpZmllcigibG9va3VwX1RFU1QiKSk7Ci0KLQkJdGhpcy5kcm9wU2NoZW1hKCJcImxvb2t1cF9URVNUXCIiKTsKLQkJdGhpcy5kcm9wU2NoZW1hKCJMT09LVVBfVEVTVCIpOwotCi0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUucmVtb3ZlQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5kaXNjb25uZWN0KCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFRhYmxlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpOwotCQlUZXN0Q29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IFRlc3RDb25uZWN0aW9uTGlzdGVuZXIoKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5hZGRDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCi0JCXRoaXMuZHJvcFRhYmxlKCJUQUJMRV9URVNUIiwgIkZPT19CQVoiKTsKLQkJdGhpcy5kcm9wVGFibGUoIlRBQkxFX1RFU1QiLCAiQkFaIik7Ci0JCXRoaXMuZHJvcFRhYmxlKCJUQUJMRV9URVNUIiwgIkZPTyIpOwotCQl0aGlzLmRyb3BUYWJsZSgiVEFCTEVfVEVTVCIsICJCQVIiKTsKLQkJdGhpcy5kcm9wU2NoZW1hKCJUQUJMRV9URVNUIik7Ci0KLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgU0NIRU1BIFRBQkxFX1RFU1QiKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJTRVQgc2VhcmNoX3BhdGggVE8gVEFCTEVfVEVTVCIpOwotCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSh0aGlzLmJ1aWxkQmFyRERMKCkpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUodGhpcy5idWlsZEZvb0RETCgpKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKHRoaXMuYnVpbGRCYXpEREwoKSk7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSh0aGlzLmJ1aWxkRm9vQmF6RERMKCkpOwotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQotCQlTY2hlbWEgc2NoZW1hID0gdGhpcy5nZXREZWZhdWx0Q2F0YWxvZygpLmdldFNjaGVtYUZvcklkZW50aWZpZXIoIlRBQkxFX1RFU1QiKTsKLQotCQkvLyBGT08KLQkJVGFibGUgZm9vVGFibGUgPSBzY2hlbWEuZ2V0VGFibGVGb3JJZGVudGlmaWVyKCJGT08iKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGZvb1RhYmxlLmNvbHVtbnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgZm9vVGFibGUucHJpbWFyeUtleUNvbHVtbnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgZm9vVGFibGUuZm9yZWlnbktleXNTaXplKCkpOwotCi0JCUNvbHVtbiBwa0NvbHVtbiA9IGZvb1RhYmxlLmdldFByaW1hcnlLZXlDb2x1bW4oKTsKLQkJYXNzZXJ0RXF1YWxzKCJpZCIsIHBrQ29sdW1uLmdldE5hbWUoKSk7Ci0JCUNvbHVtbiBpZENvbHVtbiA9IGZvb1RhYmxlLmdldENvbHVtbkZvcklkZW50aWZpZXIoIklEIik7Ci0JCWFzc2VydFNhbWUocGtDb2x1bW4sIGlkQ29sdW1uKTsKLQkJYXNzZXJ0RXF1YWxzKCJJTlQ0IiwgaWRDb2x1bW4uZ2V0RGF0YVR5cGVOYW1lKCkpOwotCQlhc3NlcnRTYW1lKGZvb1RhYmxlLCBpZENvbHVtbi5nZXRUYWJsZSgpKTsKLQkJYXNzZXJ0VHJ1ZShpZENvbHVtbi5pc1BhcnRPZlByaW1hcnlLZXkoKSk7Ci0JCWFzc2VydEZhbHNlKGlkQ29sdW1uLmlzUGFydE9mRm9yZWlnbktleSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJqYXZhLmxhbmcuSW50ZWdlciIsIGlkQ29sdW1uLmdldEphdmFUeXBlRGVjbGFyYXRpb24oKSk7Ci0KLQkJQ29sdW1uIG5hbWVDb2x1bW4gPSBmb29UYWJsZS5nZXRDb2x1bW5Gb3JJZGVudGlmaWVyKCJOQU1FIik7Ci0JCWFzc2VydEVxdWFscygiVkFSQ0hBUiIsIG5hbWVDb2x1bW4uZ2V0RGF0YVR5cGVOYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoImphdmEubGFuZy5TdHJpbmciLCBuYW1lQ29sdW1uLmdldEphdmFUeXBlRGVjbGFyYXRpb24oKSk7Ci0JCWFzc2VydEZhbHNlKG5hbWVDb2x1bW4uaXNQYXJ0T2ZQcmltYXJ5S2V5KCkpOwotCi0JCUNvbHVtbiBiYXJDb2x1bW4gPSBmb29UYWJsZS5nZXRDb2x1bW5Gb3JJZGVudGlmaWVyKCJCQVJfSUQiKTsKLQkJYXNzZXJ0RXF1YWxzKCJJTlQ0IiwgYmFyQ29sdW1uLmdldERhdGFUeXBlTmFtZSgpKTsKLQkJYXNzZXJ0VHJ1ZShiYXJDb2x1bW4uaXNQYXJ0T2ZGb3JlaWduS2V5KCkpOwotCQlhc3NlcnRGYWxzZShiYXJDb2x1bW4uaXNQYXJ0T2ZQcmltYXJ5S2V5KCkpOwotCi0JCUZvcmVpZ25LZXkgYmFyRksgPSBmb29UYWJsZS5mb3JlaWduS2V5cygpLm5leHQoKTsgIC8vIHRoZXJlIHNob3VsZCBvbmx5IGJlIDEgZm9yZWlnbiBrZXkKLQkJYXNzZXJ0RXF1YWxzKDEsIGJhckZLLmNvbHVtblBhaXJzU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXIiLCBiYXJGSy5nZXRBdHRyaWJ1dGVOYW1lKCkpOwotCQlhc3NlcnROdWxsKGJhckZLLmdldEpvaW5Db2x1bW5Bbm5vdGF0aW9uSWRlbnRpZmllcigiYmFyIikpOwotCQlhc3NlcnRFcXVhbHMoImJhcl9pZCIsIGJhckZLLmdldEpvaW5Db2x1bW5Bbm5vdGF0aW9uSWRlbnRpZmllcigicHJpbWFyeUJhciIpKTsKLQkJYXNzZXJ0U2FtZShmb29UYWJsZSwgYmFyRksuZ2V0QmFzZVRhYmxlKCkpOwotCi0JCWFzc2VydEZhbHNlKGZvb1RhYmxlLmlzUG9zc2libGVKb2luVGFibGUoKSk7Ci0JCWFzc2VydFNhbWUoc2NoZW1hLCBmb29UYWJsZS5nZXRTY2hlbWEoKSk7Ci0KLQkJLy8gQkFSCi0JCVRhYmxlIGJhclRhYmxlID0gc2NoZW1hLmdldFRhYmxlRm9ySWRlbnRpZmllcigiQkFSIik7Ci0JCWFzc2VydEVxdWFscygyLCBiYXJUYWJsZS5jb2x1bW5zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIGJhclRhYmxlLnByaW1hcnlLZXlDb2x1bW5zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGJhclRhYmxlLmZvcmVpZ25LZXlzU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJpZCIsIGJhclRhYmxlLmdldFByaW1hcnlLZXlDb2x1bW4oKS5nZXROYW1lKCkpOwotCQlhc3NlcnRGYWxzZShiYXJUYWJsZS5pc1Bvc3NpYmxlSm9pblRhYmxlKCkpOwotCQlhc3NlcnRFcXVhbHMoIkJZVEVBIiwgYmFyVGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiQ0hVTksiKS5nZXREYXRhVHlwZU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygiYnl0ZVtdIiwgYmFyVGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiQ0hVTksiKS5nZXRKYXZhVHlwZURlY2xhcmF0aW9uKCkpOwotCQkvLyBhc3NlcnRUcnVlKGJhclRhYmxlLmdldENvbHVtbkZvcklkZW50aWZpZXIoIkNIVU5LIikuZGF0YVR5cGVJc0xPQigpKTsKLQkJYXNzZXJ0U2FtZShiYXJUYWJsZSwgYmFyRksuZ2V0UmVmZXJlbmNlZFRhYmxlKCkpOwotCi0JCS8vIEZPT19CQVoKLQkJVGFibGUgZm9vX2JhelRhYmxlID0gc2NoZW1hLmdldFRhYmxlRm9ySWRlbnRpZmllcigiRk9PX0JBWiIpOwotCQlhc3NlcnRFcXVhbHMoMiwgZm9vX2JhelRhYmxlLmNvbHVtbnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgZm9vX2JhelRhYmxlLnByaW1hcnlLZXlDb2x1bW5zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGZvb19iYXpUYWJsZS5mb3JlaWduS2V5c1NpemUoKSk7Ci0JCWFzc2VydFRydWUoZm9vX2JhelRhYmxlLmlzUG9zc2libGVKb2luVGFibGUoKSk7Ci0JCWFzc2VydFRydWUoZm9vX2JhelRhYmxlLmpvaW5UYWJsZU5hbWVJc0RlZmF1bHQoKSk7Ci0JCWFzc2VydFRydWUoZm9vX2JhelRhYmxlLmdldENvbHVtbkZvcklkZW50aWZpZXIoIkZPT19JRCIpLmlzUGFydE9mRm9yZWlnbktleSgpKTsKLQotCQl0aGlzLmRyb3BUYWJsZSgiVEFCTEVfVEVTVCIsICJGT09fQkFaIik7Ci0JCXRoaXMuZHJvcFRhYmxlKCJUQUJMRV9URVNUIiwgIkJBWiIpOwotCQl0aGlzLmRyb3BUYWJsZSgiVEFCTEVfVEVTVCIsICJGT08iKTsKLQkJdGhpcy5kcm9wVGFibGUoIlRBQkxFX1RFU1QiLCAiQkFSIik7Ci0JCXRoaXMuZHJvcFNjaGVtYSgiVEFCTEVfVEVTVCIpOwotCi0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUucmVtb3ZlQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5kaXNjb25uZWN0KCk7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIENSID0gU3lzdGVtLmdldFByb3BlcnR5KCJsaW5lLnNlcGFyYXRvciIpOyAgLy8kTk9OLU5MUy0xJAotCi0JcHJpdmF0ZSBTdHJpbmcgYnVpbGRCYXJEREwoKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigyMDApOwotCQlzYi5hcHBlbmQoIkNSRUFURSBUQUJMRSBCQVIgKCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIElEIGludGVnZXIgUFJJTUFSWSBLRVksIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgQ0hVTksgYnl0ZWEiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIikiKS5hcHBlbmQoQ1IpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBidWlsZEZvb0RETCgpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXNiLmFwcGVuZCgiQ1JFQVRFIFRBQkxFIEZPTyAoIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgSUQgaW50ZWdlciBQUklNQVJZIEtFWSwiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBOQU1FIHZhcmNoYXIoMjApLCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIEJBUl9JRCBpbnRlZ2VyIFJFRkVSRU5DRVMgQkFSKElEKSIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiKSIpLmFwcGVuZChDUik7Ci0JCXJldHVybiBzYi50b1N0cmluZygpOwotCX0KLQotCXByaXZhdGUgU3RyaW5nIGJ1aWxkQmF6RERMKCkgewotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoMjAwKTsKLQkJc2IuYXBwZW5kKCJDUkVBVEUgVEFCTEUgQkFaICgiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBJRCBpbnRlZ2VyIFBSSU1BUlkgS0VZLCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIE5BTUUgdmFyY2hhcigyMCkiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIikiKS5hcHBlbmQoQ1IpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBidWlsZEZvb0JhekRETCgpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXNiLmFwcGVuZCgiQ1JFQVRFIFRBQkxFIEZPT19CQVogKCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIEZPT19JRCBpbnQgUkVGRVJFTkNFUyBGT08oSUQpLCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIEJBWl9JRCBpbnQgUkVGRVJFTkNFUyBCQVooSUQpIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIpIikuYXBwZW5kKENSKTsKLQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbHVtbkxvb2t1cCgpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmNvbm5lY3QoKTsKLQkJVGVzdENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBUZXN0Q29ubmVjdGlvbkxpc3RlbmVyKCk7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuYWRkQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQotCQl0aGlzLmRyb3BUYWJsZSgiVEFCTEVfVEVTVCIsICJ0ZXN0Iik7Ci0JCXRoaXMuZHJvcFNjaGVtYSgiVEFCTEVfVEVTVCIpOwotCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFNDSEVNQSBUQUJMRV9URVNUIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiU0VUIHNlYXJjaF9wYXRoIFRPIFRBQkxFX1RFU1QiKTsKLQotCQkvLyBsb3dlcmNhc2UKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgVEFCTEUgdGVzdCAoaWQgaW50LCBuYW1lIHZhcmNoYXIoMjApKSIpOwotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQotCQlUYWJsZSB0YWJsZSA9IHRoaXMuZ2V0RGVmYXVsdENhdGFsb2coKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKCJUQUJMRV9URVNUIikuZ2V0VGFibGVGb3JJZGVudGlmaWVyKCJ0ZXN0Iik7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiaWQiKSk7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigibmFtZSIpKTsKLQotCQl0aGlzLmRyb3BUYWJsZSgiVEFCTEVfVEVTVCIsICJ0ZXN0Iik7Ci0KLQkJLy8gdXBwZXJjYXNlCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFRBQkxFIHRlc3QgKElEIGludCwgTkFNRSB2YXJjaGFyKDIwKSkiKTsKLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0KLQkJdGFibGUgPSB0aGlzLmdldERlZmF1bHRDYXRhbG9nKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcigiVEFCTEVfVEVTVCIpLmdldFRhYmxlRm9ySWRlbnRpZmllcigidGVzdCIpOwotCQlhc3NlcnROb3ROdWxsKHRhYmxlLmdldENvbHVtbkZvcklkZW50aWZpZXIoIklEIikpOwotCQlhc3NlcnROb3ROdWxsKHRhYmxlLmdldENvbHVtbkZvcklkZW50aWZpZXIoIk5BTUUiKSk7Ci0KLQkJdGhpcy5kcm9wVGFibGUoIlRBQkxFX1RFU1QiLCAidGVzdCIpOwotCi0JCS8vIG1peGVkIGNhc2UKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgVEFCTEUgdGVzdCAoSWQgaW50LCBOYW1lIHZhcmNoYXIoMjApKSIpOwotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQotCQl0YWJsZSA9IHRoaXMuZ2V0RGVmYXVsdENhdGFsb2coKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKCJUQUJMRV9URVNUIikuZ2V0VGFibGVGb3JJZGVudGlmaWVyKCJ0ZXN0Iik7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiSWQiKSk7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiTmFtZSIpKTsKLQotCQl0aGlzLmRyb3BUYWJsZSgiVEFCTEVfVEVTVCIsICJ0ZXN0Iik7Ci0KLQkJLy8gZGVsaW1pdGVkCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiQ1JFQVRFIFRBQkxFIHRlc3QgKFwiSWRcIiBpbnQsIFwiTmFtZVwiIHZhcmNoYXIoMjApKSIpOwotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQotCQl0YWJsZSA9IHRoaXMuZ2V0RGVmYXVsdENhdGFsb2coKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKCJUQUJMRV9URVNUIikuZ2V0VGFibGVGb3JJZGVudGlmaWVyKCJ0ZXN0Iik7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiXCJJZFwiIikpOwotCQlhc3NlcnROb3ROdWxsKHRhYmxlLmdldENvbHVtbkZvcklkZW50aWZpZXIoIlwiTmFtZVwiIikpOwotCi0JCXRoaXMuZHJvcFRhYmxlKCJUQUJMRV9URVNUIiwgInRlc3QiKTsKLQkJdGhpcy5kcm9wU2NoZW1hKCJUQUJMRV9URVNUIik7Ci0KLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5yZW1vdmVDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmRpc2Nvbm5lY3QoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q3Jvc3NTY2hlbWFSZWZlcmVuY2UoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5jb25uZWN0KCk7Ci0JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJdGhpcy5kcm9wVGFibGUoIlhSRUZfVEVTVDIiLCAiRU1QIik7Ci0JCXRoaXMuZHJvcFNjaGVtYSgiWFJFRl9URVNUMiIpOwotCQl0aGlzLmRyb3BUYWJsZSgiWFJFRl9URVNUMSIsICJPUkciKTsKLQkJdGhpcy5kcm9wU2NoZW1hKCJYUkVGX1RFU1QxIik7Ci0KLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgU0NIRU1BIFhSRUZfVEVTVDEiKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJTRVQgc2VhcmNoX3BhdGggVE8gWFJFRl9URVNUMSIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBUQUJMRSBPUkcgKElEIGludGVnZXIgUFJJTUFSWSBLRVksIE5BTUUgdmFyY2hhcigyMCkpIik7Ci0KLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgU0NIRU1BIFhSRUZfVEVTVDIiKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJTRVQgc2VhcmNoX3BhdGggVE8gWFJFRl9URVNUMiIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBUQUJMRSBFTVAgKElEIGludGVnZXIgUFJJTUFSWSBLRVksIE5BTUUgdmFyY2hhcigyMCksICIgKwotCQkJCSJPUkdfSUQgaW50ZWdlciBSRUZFUkVOQ0VTIFhSRUZfVEVTVDEuT1JHKElEKSkiKTsKLQotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQkJU2NoZW1hIHNjaGVtYTEgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0RGVmYXVsdENhdGFsb2coKS5nZXRTY2hlbWFOYW1lZCgieHJlZl90ZXN0MSIpOwotCQlhc3NlcnROb3ROdWxsKHNjaGVtYTEpOwotCQlUYWJsZSBvcmdUYWJsZSA9IHNjaGVtYTEuZ2V0VGFibGVOYW1lZCgib3JnIik7Ci0JCWFzc2VydE5vdE51bGwob3JnVGFibGUpOwotCi0JCVNjaGVtYSBzY2hlbWEyID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldERlZmF1bHRDYXRhbG9nKCkuZ2V0U2NoZW1hTmFtZWQoInhyZWZfdGVzdDIiKTsKLQkJYXNzZXJ0Tm90TnVsbChzY2hlbWEyKTsKLQkJVGFibGUgZW1wVGFibGUgPSBzY2hlbWEyLmdldFRhYmxlTmFtZWQoImVtcCIpOwotCQlhc3NlcnROb3ROdWxsKGVtcFRhYmxlKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIGVtcFRhYmxlLmZvcmVpZ25LZXlzU2l6ZSgpKTsKLQkJRm9yZWlnbktleSBmayA9IGVtcFRhYmxlLmZvcmVpZ25LZXlzKCkubmV4dCgpOwotCQlUYWJsZSByZWZUYWJsZSA9IGZrLmdldFJlZmVyZW5jZWRUYWJsZSgpOwotCQlhc3NlcnROb3ROdWxsKHJlZlRhYmxlKTsKLQkJYXNzZXJ0RXF1YWxzKCJvcmciLCByZWZUYWJsZS5nZXROYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgZmsuY29sdW1uUGFpcnNTaXplKCkpOwotCQlGb3JlaWduS2V5LkNvbHVtblBhaXIgY3AgPSBmay5jb2x1bW5QYWlycygpLm5leHQoKTsKLQkJQ29sdW1uIGJhc2VDb2x1bW4gPSBjcC5nZXRCYXNlQ29sdW1uKCk7Ci0JCWFzc2VydEVxdWFscygib3JnX2lkIiwgYmFzZUNvbHVtbi5nZXROYW1lKCkpOwotCQlDb2x1bW4gcmVmQ29sdW1uID0gY3AuZ2V0UmVmZXJlbmNlZENvbHVtbigpOwotCQlhc3NlcnRFcXVhbHMoImlkIiwgcmVmQ29sdW1uLmdldE5hbWUoKSk7Ci0KLQkJdGhpcy5kcm9wVGFibGUoIlhSRUZfVEVTVDIiLCAiRU1QIik7Ci0JCXRoaXMuZHJvcFNjaGVtYSgiWFJFRl9URVNUMiIpOwotCQl0aGlzLmRyb3BUYWJsZSgiWFJFRl9URVNUMSIsICJPUkciKTsKLQkJdGhpcy5kcm9wU2NoZW1hKCJYUkVGX1RFU1QxIik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUucmVtb3ZlQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5kaXNjb25uZWN0KCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGRyb3BUYWJsZShTdHJpbmcgc2NoZW1hTmFtZSwgU3RyaW5nIHRhYmxlTmFtZSkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVNjaGVtYSBzY2hlbWE9IHRoaXMuZ2V0RGVmYXVsdENhdGFsb2coKS5nZXRTY2hlbWFGb3JJZGVudGlmaWVyKHNjaGVtYU5hbWUpOwotCQlpZiAoc2NoZW1hICE9IG51bGwpIHsKLQkJCWlmIChzY2hlbWEuZ2V0VGFibGVGb3JJZGVudGlmaWVyKHRhYmxlTmFtZSkgIT0gbnVsbCkgewotCQkJCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiRFJPUCBUQUJMRSAiICsgc2NoZW1hTmFtZSArICcuJyArIHRhYmxlTmFtZSk7Ci0JCQl9Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgZHJvcFNjaGVtYShTdHJpbmcgbmFtZSkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWlmICh0aGlzLmdldERlZmF1bHRDYXRhbG9nKCkuZ2V0U2NoZW1hRm9ySWRlbnRpZmllcihuYW1lKSAhPSBudWxsKSB7Ci0JCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkRST1AgU0NIRU1BICIgKyBuYW1lICsgIiBDQVNDQURFIik7Ci0JCX0KLQl9Ci0KLS8vIHNlZSAyNDE1NzgvMjQxNTU3Ci0vLwlwdWJsaWMgdm9pZCB0ZXN0U2VxdWVuY2UoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLS8vCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmNvbm5lY3QoKTsKLS8vCQlUZXN0Q29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IFRlc3RDb25uZWN0aW9uTGlzdGVuZXIoKTsKLS8vCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0vLwotLy8JCXRoaXMuZHJvcFNlcXVlbmNlKCJTRVFVRU5DRV9URVNUIiwgIkZPTyIpOwotLy8JCXRoaXMuZHJvcFNjaGVtYSgiU0VRVUVOQ0VfVEVTVCIpOwotLy8KLS8vCQl0aGlzLmV4ZWN1dGVVcGRhdGUoIkNSRUFURSBTQ0hFTUEgU0VRVUVOQ0VfVEVTVCIpOwotLy8JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiU0VUIHNlYXJjaF9wYXRoIFRPIFNFUVVFTkNFX1RFU1QiKTsKLS8vCi0vLwkJdGhpcy5leGVjdXRlVXBkYXRlKHRoaXMuYnVpbGRCYXJEREwoKSk7Ci0vLwkJdGhpcy5leGVjdXRlVXBkYXRlKCJDUkVBVEUgU0VRVUVOQ0UgRk9PIFNUQVJUIDEiKTsKLS8vLy8JCUxpc3Q8T2JqZWN0W10+IGxpc3QgPSB0aGlzLmV4ZWN1dGUoIlNFTEVDVCBuZXh0dmFsKCdmb28nKSIpOwotLy8vLwkJU3lzdGVtLm91dC5wcmludGxuKGxpc3QpOwotLy8JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotLy8KLS8vCQlTY2hlbWEgc2NoZW1hID0gdGhpcy5nZXREZWZhdWx0Q2F0YWxvZygpLmdldFNjaGVtYU5hbWVkKCJTRVFVRU5DRV9URVNUIik7Ci0vLwkJU2VxdWVuY2Ugc2VxdWVuY2UgPSBzY2hlbWEuZ2V0U2VxdWVuY2VOYW1lZCgiRk9PIik7Ci0vLwkJYXNzZXJ0Tm90TnVsbChzZXF1ZW5jZSk7Ci0vLwkJYXNzZXJ0RXF1YWxzKCJmb29fc2VxIiwgc2VxdWVuY2UuZ2V0TmFtZSgpKTsKLS8vCi0vLwkJdGhpcy5kcm9wU2VxdWVuY2UoIlNFUVVFTkNFX1RFU1QiLCAiRk9PIik7Ci0vLwkJdGhpcy5kcm9wU2NoZW1hKCJTRVFVRU5DRV9URVNUIik7Ci0vLwotLy8JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUucmVtb3ZlQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLS8vCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmRpc2Nvbm5lY3QoKTsKLS8vCX0KLS8vCi0vLwlwcml2YXRlIHZvaWQgZHJvcFNlcXVlbmNlKFN0cmluZyBzY2hlbWFOYW1lLCBTdHJpbmcgc2VxdWVuY2VOYW1lKSB0aHJvd3MgRXhjZXB0aW9uIHsKLS8vCQlTY2hlbWEgc2NoZW1hPSB0aGlzLmdldERlZmF1bHRDYXRhbG9nKCkuZ2V0U2NoZW1hTmFtZWQoc2NoZW1hTmFtZSk7Ci0vLwkJaWYgKHNjaGVtYSAhPSBudWxsKSB7Ci0vLwkJCWlmIChzY2hlbWEuZ2V0U2VxdWVuY2VOYW1lZChzZXF1ZW5jZU5hbWUpICE9IG51bGwpIHsKLS8vCQkJCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiRFJPUCBTRVFVRU5DRSAiICsgc2NoZW1hTmFtZSArICcuJyArIHNlcXVlbmNlTmFtZSk7Ci0vLwkJCX0KLS8vCQl9Ci0vLwl9Ci0vLwotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3Rlc3RzL2ludGVybmFsL3BsYXRmb3Jtcy9TUUxTZXJ2ZXJUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3Rlc3RzL2ludGVybmFsL3BsYXRmb3Jtcy9TUUxTZXJ2ZXJUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjZWRkZTVkLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZGIudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC9kYi90ZXN0cy9pbnRlcm5hbC9wbGF0Zm9ybXMvU1FMU2VydmVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDgzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzLmludGVybmFsLnBsYXRmb3JtczsKLQotCi0vKioKLSAqICBTUUwgU2VydmVyIDIwMDUgRHJpdmVyIFRlc3QKLSAqLwotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgY2xhc3MgU1FMU2VydmVyVGVzdHMgZXh0ZW5kcyBEVFBQbGF0Zm9ybVRlc3RzIHsKLQotCXB1YmxpYyBTUUxTZXJ2ZXJUZXN0cyggU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIoIG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0UGxhdGZvcm1Qcm9wZXJ0aWVzRmlsZU5hbWUoKSB7Ci0JCXJldHVybiAic3Fsc2VydmVyLnByb3BlcnRpZXMiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RHJpdmVyTmFtZSgpIHsKLQkJcmV0dXJuICJNaWNyb3NvZnQgU1FMIFNlcnZlciAyMDA1IEpEQkMgRHJpdmVyIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERyaXZlckRlZmluaXRpb25JRCgpIHsKLQkJcmV0dXJuICJEcml2ZXJEZWZuLk1pY3Jvc29mdCBTUUwgU2VydmVyIDIwMDUgSkRCQyBEcml2ZXIiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RHJpdmVyRGVmaW5pdGlvblR5cGUoKSB7Ci0JCXJldHVybiAib3JnLmVjbGlwc2UuZGF0YXRvb2xzLmVuYWJsZW1lbnQubXNmdC5zcWxzZXJ2ZXIuMjAwNS5kcml2ZXJUZW1wbGF0ZSI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXREYXRhYmFzZVZlbmRvcigpIHsKLQkJcmV0dXJuICJTUUxTZXJ2ZXIiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RGF0YWJhc2VWZXJzaW9uKCkgewotCQlyZXR1cm4gIjIwMDUiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RHJpdmVyQ2xhc3MoKSB7Ci0JCXJldHVybiAiY29tLm1pY3Jvc29mdC5zcWxzZXJ2ZXIuamRiYy5TUUxTZXJ2ZXJEcml2ZXIiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0UHJvZmlsZU5hbWUoKSB7Ci0JCXJldHVybiAiU1FMU2VydmVyXzIwMDUiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0UHJvZmlsZURlc2NyaXB0aW9uKCkgewotCQlyZXR1cm4gIk1pY3Jvc29mdCBTUUwgU2VydmVyIDIwMDUgSkRCQyBQcm9maWxlIFtUZXN0XSI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXRQcm92aWRlcklEKCkgewotCQlyZXR1cm4gIm9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuZGIuZ2VuZXJpYy5jb25uZWN0aW9uUHJvZmlsZSI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIGJvb2xlYW4gc3VwcG9ydHNDYXRhbG9ncygpIHsKLQkJcmV0dXJuIHRydWU7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIGJvb2xlYW4gZXhlY3V0ZU9mZmxpbmVUZXN0cygpIHsKLQkJcmV0dXJuIHRydWU7ICAvLyBoYXZlbid0IGFjdHVhbGx5IHRyaWVkIHRoaXMgeWV0Li4uCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm1zL1N5YmFzZVRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZGIvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm1zL1N5YmFzZVRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQ4MjJlNTEuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5kYi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2RiL3Rlc3RzL2ludGVybmFsL3BsYXRmb3Jtcy9TeWJhc2VUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDQ0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzLmludGVybmFsLnBsYXRmb3JtczsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmRhdGF0b29scy5jb25uZWN0aXZpdHkuc3FtLmNvcmUucnRlLklDYXRhbG9nT2JqZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5DYXRhbG9nOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5kYi5Db2x1bW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLkZvcmVpZ25LZXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLlNjaGVtYTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuZGIuVGFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmRiLnRlc3RzLmludGVybmFsLnBsYXRmb3Jtcy5EVFBQbGF0Zm9ybVRlc3RzLlRlc3RDb25uZWN0aW9uTGlzdGVuZXI7Ci0KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIFN5YmFzZVRlc3RzIGV4dGVuZHMgRFRQUGxhdGZvcm1UZXN0cyB7Ci0KLQlwdWJsaWMgU3liYXNlVGVzdHMoIFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKCBuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldFBsYXRmb3JtUHJvcGVydGllc0ZpbGVOYW1lKCkgewotCQlyZXR1cm4gInN5YmFzZS5wcm9wZXJ0aWVzIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERyaXZlck5hbWUoKSB7Ci0JCXJldHVybiAiU3liYXNlIEpEQkMgRHJpdmVyIGZvciBTeWJhc2UgQVNFIDE1LngiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RHJpdmVyRGVmaW5pdGlvbklEKCkgewotCQlyZXR1cm4gIkRyaXZlckRlZm4uU3liYXNlIEpEQkMgRHJpdmVyIGZvciBTeWJhc2UgQVNFIDE1LngiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0RHJpdmVyRGVmaW5pdGlvblR5cGUoKSB7Ci0JCXJldHVybiAib3JnLmVjbGlwc2UuZGF0YXRvb2xzLmNvbm5lY3Rpdml0eS5kYi5zeWJhc2UuYXNlLmdlbmVyaWNEcml2ZXJUZW1wbGF0ZV8xNSI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIFN0cmluZyBnZXREYXRhYmFzZVZlbmRvcigpIHsKLQkJcmV0dXJuICJTeWJhc2VfQVNFIjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERhdGFiYXNlVmVyc2lvbigpIHsKLQkJcmV0dXJuICIxNS54IjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldERyaXZlckNsYXNzKCkgewotCQlyZXR1cm4gImNvbS5zeWJhc2UuamRiYzMuamRiYy5TeWJEcml2ZXIiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgZ2V0UHJvZmlsZU5hbWUoKSB7Ci0JCXJldHVybiAiU3liYXNlXzE1IjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgU3RyaW5nIGdldFByb2ZpbGVEZXNjcmlwdGlvbigpIHsKLQkJcmV0dXJuICJTeWJhc2UgQVNFIDE1IGpDb25uZWN0IEpEQkMgUHJvZmlsZSBbVGVzdF0iOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBib29sZWFuIHN1cHBvcnRzQ2F0YWxvZ3MoKSB7Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBib29sZWFuIGV4ZWN1dGVPZmZsaW5lVGVzdHMoKSB7Ci0JCS8vIHdvcmtpbmcgb2ZmbGluZSBpcyBwcmV0dHkgdWdseQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JLyoqCi0JICogU3liYXNlICJkYXRhYmFzZXMiIGJlY29tZSBEVFAgImNhdGFsb2dzIgotCSAqLwotCXB1YmxpYyB2b2lkIHRlc3RDYXRhbG9nKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpOwotCQlUZXN0Q29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IFRlc3RDb25uZWN0aW9uTGlzdGVuZXIoKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5hZGRDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCi0JCXRoaXMuZ2V0SkRCQ0Nvbm5lY3Rpb24oKS5zZXRDYXRhbG9nKCJtYXN0ZXIiKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlSWdub3JlRXJyb3JzKCJkcm9wIGRhdGFiYXNlIHRlc3QxIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZUlnbm9yZUVycm9ycygiZHJvcCBkYXRhYmFzZSB0ZXN0MiIpOwotCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiY3JlYXRlIGRhdGFiYXNlIHRlc3QxIik7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCUNhdGFsb2cgY2F0YWxvZzEgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0Q2F0YWxvZ05hbWVkKCJ0ZXN0MSIpOwotCQlhc3NlcnROb3ROdWxsKGNhdGFsb2cxKTsKLQkJU2NoZW1hIHNjaGVtYTEgPSBjYXRhbG9nMS5nZXRTY2hlbWFOYW1lZCgiZGJvIik7Ci0JCWFzc2VydE5vdE51bGwoc2NoZW1hMSk7Ci0JCWFzc2VydFNhbWUoc2NoZW1hMSwgY2F0YWxvZzEuZ2V0RGVmYXVsdFNjaGVtYSgpKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoImNyZWF0ZSBkYXRhYmFzZSB0ZXN0MiIpOwotCQlDYXRhbG9nIGNhdGFsb2cyID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldENhdGFsb2dOYW1lZCgidGVzdDIiKTsKLQkJYXNzZXJ0TnVsbChjYXRhbG9nMik7ICAvLyBzaG91bGQgYmUgbnVsbCB1bnRpbCByZWZyZXNoCi0KLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0JCWFzc2VydFNhbWUodGhpcy5nZXREYXRhYmFzZSgpLCBsaXN0ZW5lci5jaGFuZ2VkRGF0YWJhc2UpOwotCi0JCWNhdGFsb2cyID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldENhdGFsb2dOYW1lZCgidGVzdDIiKTsKLQkJYXNzZXJ0Tm90TnVsbChjYXRhbG9nMik7Ci0JCVNjaGVtYSBzY2hlbWEyID0gY2F0YWxvZzIuZ2V0RGVmYXVsdFNjaGVtYSgpOwotCQlhc3NlcnROb3ROdWxsKHNjaGVtYTIpOwotCi0JCWFzc2VydE5vdFNhbWUoY2F0YWxvZzEsIHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRDYXRhbG9nTmFtZWQoInRlc3QxIikpOyAgLy8gd2Ugc2hvdWxkIGhhdmUgYSBuZXcgY2F0YWxvZyBhZnRlciB0aGUgcmVmcmVzaAotCQlhc3NlcnROb3RTYW1lKHNjaGVtYTEsIHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRDYXRhbG9nTmFtZWQoInRlc3QxIikuZ2V0RGVmYXVsdFNjaGVtYSgpKTsgIC8vIHdlIHNob3VsZCBoYXZlIGEgbmV3IHNjaGVtYSBhZnRlciB0aGUgcmVmcmVzaAotCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiZHJvcCBkYXRhYmFzZSB0ZXN0MiIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoImRyb3AgZGF0YWJhc2UgdGVzdDEiKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5yZW1vdmVDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmRpc2Nvbm5lY3QoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VGFibGUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5jb25uZWN0KCk7Ci0JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJdGhpcy5nZXRKREJDQ29ubmVjdGlvbigpLnNldENhdGFsb2coIm1hc3RlciIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGVJZ25vcmVFcnJvcnMoImRyb3AgZGF0YWJhc2UgdGFibGVfdGVzdCIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoImNyZWF0ZSBkYXRhYmFzZSB0YWJsZV90ZXN0Iik7Ci0JCXRoaXMuZ2V0SkRCQ0Nvbm5lY3Rpb24oKS5zZXRDYXRhbG9nKCJ0YWJsZV90ZXN0Iik7Ci0KLQkJdGhpcy5leGVjdXRlVXBkYXRlKHRoaXMuYnVpbGRCYXJEREwoKSk7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSh0aGlzLmJ1aWxkRm9vRERMKCkpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUodGhpcy5idWlsZEJhekRETCgpKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKHRoaXMuYnVpbGRGb29CYXpEREwoKSk7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCVNjaGVtYSBzY2hlbWEgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0Q2F0YWxvZ05hbWVkKCJ0YWJsZV90ZXN0IikuZ2V0RGVmYXVsdFNjaGVtYSgpOwotCi0JCS8vIGZvbwotCQlUYWJsZSBmb29UYWJsZSA9IHNjaGVtYS5nZXRUYWJsZU5hbWVkKCJmb28iKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGZvb1RhYmxlLmNvbHVtbnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgZm9vVGFibGUucHJpbWFyeUtleUNvbHVtbnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgZm9vVGFibGUuZm9yZWlnbktleXNTaXplKCkpOwotCi0JCUNvbHVtbiBwa0NvbHVtbiA9IGZvb1RhYmxlLmdldFByaW1hcnlLZXlDb2x1bW4oKTsKLQkJYXNzZXJ0RXF1YWxzKCJpZCIsIHBrQ29sdW1uLmdldE5hbWUoKSk7Ci0JCUNvbHVtbiBpZENvbHVtbiA9IGZvb1RhYmxlLmdldENvbHVtbk5hbWVkKCJpZCIpOwotCQlhc3NlcnRTYW1lKGZvb1RhYmxlLCBpZENvbHVtbi5nZXRUYWJsZSgpKTsKLQkJYXNzZXJ0U2FtZShwa0NvbHVtbiwgaWRDb2x1bW4pOwotCQlhc3NlcnRUcnVlKGlkQ29sdW1uLmlzUGFydE9mUHJpbWFyeUtleSgpKTsKLQkJYXNzZXJ0RmFsc2UoaWRDb2x1bW4uaXNQYXJ0T2ZGb3JlaWduS2V5KCkpOwotCQlhc3NlcnRUcnVlKGlkQ29sdW1uLmlzUGFydE9mVW5pcXVlQ29uc3RyYWludCgpKTsKLQkJYXNzZXJ0RmFsc2UoaWRDb2x1bW4uaXNOdWxsYWJsZSgpKTsKLQotCQlhc3NlcnRFcXVhbHMoIklOVCIsIGlkQ29sdW1uLmdldERhdGFUeXBlTmFtZSgpKTsKLQkJYXNzZXJ0VHJ1ZShpZENvbHVtbi5pc051bWVyaWMoKSk7Ci0JCWFzc2VydEVxdWFscygwLCBpZENvbHVtbi5nZXRQcmVjaXNpb24oKSk7Ci0JCWFzc2VydEVxdWFscygwLCBpZENvbHVtbi5nZXRTY2FsZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKC0xLCBpZENvbHVtbi5nZXRMZW5ndGgoKSk7Ci0JCWFzc2VydEZhbHNlKGlkQ29sdW1uLmlzTE9CKCkpOwotCQlhc3NlcnRFcXVhbHMoImludCIsIGlkQ29sdW1uLmdldEphdmFUeXBlRGVjbGFyYXRpb24oKSk7Ci0KLQkJQ29sdW1uIG5hbWVDb2x1bW4gPSBmb29UYWJsZS5nZXRDb2x1bW5OYW1lZCgibmFtZSIpOwotCQlhc3NlcnRGYWxzZShuYW1lQ29sdW1uLmlzUGFydE9mUHJpbWFyeUtleSgpKTsKLQkJYXNzZXJ0RmFsc2UobmFtZUNvbHVtbi5pc1BhcnRPZkZvcmVpZ25LZXkoKSk7Ci0JCWFzc2VydFRydWUobmFtZUNvbHVtbi5pc1BhcnRPZlVuaXF1ZUNvbnN0cmFpbnQoKSk7Ci0JCWFzc2VydEZhbHNlKG5hbWVDb2x1bW4uaXNOdWxsYWJsZSgpKTsgIC8vIGltcGxpZWQgIk5PVCBOVUxMIiA/Ci0KLQkJYXNzZXJ0RXF1YWxzKCJWQVJDSEFSIiwgbmFtZUNvbHVtbi5nZXREYXRhVHlwZU5hbWUoKSk7Ci0JCWFzc2VydEZhbHNlKG5hbWVDb2x1bW4uaXNOdW1lcmljKCkpOwotCQlhc3NlcnRFcXVhbHMoLTEsIG5hbWVDb2x1bW4uZ2V0UHJlY2lzaW9uKCkpOwotCQlhc3NlcnRFcXVhbHMoLTEsIG5hbWVDb2x1bW4uZ2V0U2NhbGUoKSk7Ci0JCWFzc2VydEVxdWFscygyMCwgbmFtZUNvbHVtbi5nZXRMZW5ndGgoKSk7Ci0JCWFzc2VydEZhbHNlKG5hbWVDb2x1bW4uaXNMT0IoKSk7Ci0JCWFzc2VydEVxdWFscygiamF2YS5sYW5nLlN0cmluZyIsIG5hbWVDb2x1bW4uZ2V0SmF2YVR5cGVEZWNsYXJhdGlvbigpKTsKLQotCQlDb2x1bW4gYmFyQ29sdW1uID0gZm9vVGFibGUuZ2V0Q29sdW1uTmFtZWQoImJhcl9pZCIpOwotCQlhc3NlcnRFcXVhbHMoIklOVCIsIGJhckNvbHVtbi5nZXREYXRhVHlwZU5hbWUoKSk7Ci0JCWFzc2VydFRydWUoYmFyQ29sdW1uLmlzUGFydE9mRm9yZWlnbktleSgpKTsKLQkJYXNzZXJ0RmFsc2UoYmFyQ29sdW1uLmlzUGFydE9mUHJpbWFyeUtleSgpKTsKLQotCQlGb3JlaWduS2V5IGJhckZLID0gZm9vVGFibGUuZm9yZWlnbktleXMoKS5uZXh0KCk7ICAvLyB0aGVyZSBzaG91bGQgb25seSBiZSAxIGZvcmVpZ24ga2V5Ci0JCWFzc2VydEVxdWFscygxLCBiYXJGSy5jb2x1bW5QYWlyc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygiYmFyIiwgYmFyRksuZ2V0QXR0cmlidXRlTmFtZSgpKTsKLQkJYXNzZXJ0TnVsbChiYXJGSy5nZXRKb2luQ29sdW1uQW5ub3RhdGlvbklkZW50aWZpZXIoImJhciIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXJfaWQiLCBiYXJGSy5nZXRKb2luQ29sdW1uQW5ub3RhdGlvbklkZW50aWZpZXIoInByaW1hcnlCYXIiKSk7Ci0JCWFzc2VydFNhbWUoZm9vVGFibGUsIGJhckZLLmdldEJhc2VUYWJsZSgpKTsKLQotCQlhc3NlcnRGYWxzZShmb29UYWJsZS5pc1Bvc3NpYmxlSm9pblRhYmxlKCkpOwotCQlhc3NlcnRTYW1lKHNjaGVtYSwgZm9vVGFibGUuZ2V0U2NoZW1hKCkpOwotCi0JCS8vIEJBUgotCQlUYWJsZSBiYXJUYWJsZSA9IHNjaGVtYS5nZXRUYWJsZU5hbWVkKCJiYXIiKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGJhclRhYmxlLmNvbHVtbnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgYmFyVGFibGUucHJpbWFyeUtleUNvbHVtbnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgYmFyVGFibGUuZm9yZWlnbktleXNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoImlkIiwgYmFyVGFibGUuZ2V0UHJpbWFyeUtleUNvbHVtbigpLmdldE5hbWUoKSk7Ci0JCWFzc2VydEZhbHNlKGJhclRhYmxlLmlzUG9zc2libGVKb2luVGFibGUoKSk7Ci0JCUNvbHVtbiBjaHVua0NvbHVtbiA9IGJhclRhYmxlLmdldENvbHVtbk5hbWVkKCJjaHVuayIpOwotCQlhc3NlcnRFcXVhbHMoIklNQUdFIiwgY2h1bmtDb2x1bW4uZ2V0RGF0YVR5cGVOYW1lKCkpOwotCQlhc3NlcnRGYWxzZShjaHVua0NvbHVtbi5pc051bWVyaWMoKSk7Ci0JCWFzc2VydFRydWUoY2h1bmtDb2x1bW4uaXNMT0IoKSk7Ci0JCWFzc2VydEVxdWFscygiYnl0ZVtdIiwgY2h1bmtDb2x1bW4uZ2V0SmF2YVR5cGVEZWNsYXJhdGlvbigpKTsKLQkJYXNzZXJ0U2FtZShiYXJUYWJsZSwgYmFyRksuZ2V0UmVmZXJlbmNlZFRhYmxlKCkpOwotCi0JCS8vIEJBWgotCQlUYWJsZSBiYXpUYWJsZSA9IHNjaGVtYS5nZXRUYWJsZU5hbWVkKCJiYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKDQsIGJhelRhYmxlLmNvbHVtbnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgYmF6VGFibGUucHJpbWFyeUtleUNvbHVtbnNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgYmF6VGFibGUuZm9yZWlnbktleXNTaXplKCkpOwotCi0JCUNvbHVtbiBuaWNrbmFtZUNvbHVtbiA9IGJhelRhYmxlLmdldENvbHVtbk5hbWVkKCJuaWNrbmFtZSIpOwotCQlhc3NlcnRUcnVlKG5pY2tuYW1lQ29sdW1uLmlzTnVsbGFibGUoKSk7Ci0KLQkJQ29sdW1uIHNvbmdDb2x1bW4gPSBiYXpUYWJsZS5nZXRDb2x1bW5OYW1lZCgic29uZyIpOwotCQlhc3NlcnRGYWxzZShzb25nQ29sdW1uLmlzTnVsbGFibGUoKSk7Ci0KLQkJQ29sdW1uIHNhbGFyeUNvbHVtbiA9IGJhelRhYmxlLmdldENvbHVtbk5hbWVkKCJzYWxhcnkiKTsKLQkJYXNzZXJ0RmFsc2Uoc2FsYXJ5Q29sdW1uLmlzUGFydE9mVW5pcXVlQ29uc3RyYWludCgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJERUNJTUFMIiwgc2FsYXJ5Q29sdW1uLmdldERhdGFUeXBlTmFtZSgpKTsKLQkJYXNzZXJ0VHJ1ZShzYWxhcnlDb2x1bW4uaXNOdW1lcmljKCkpOwotCQlhc3NlcnRFcXVhbHMoMTAsIHNhbGFyeUNvbHVtbi5nZXRQcmVjaXNpb24oKSk7Ci0JCWFzc2VydEVxdWFscygyLCBzYWxhcnlDb2x1bW4uZ2V0U2NhbGUoKSk7Ci0JCWFzc2VydEVxdWFscygtMSwgc2FsYXJ5Q29sdW1uLmdldExlbmd0aCgpKTsKLQkJYXNzZXJ0RmFsc2Uoc2FsYXJ5Q29sdW1uLmlzTE9CKCkpOwotCi0JCS8vIEZPT19CQVoKLQkJVGFibGUgZm9vX2JhelRhYmxlID0gc2NoZW1hLmdldFRhYmxlTmFtZWQoImZvb19iYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGZvb19iYXpUYWJsZS5jb2x1bW5zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGZvb19iYXpUYWJsZS5wcmltYXJ5S2V5Q29sdW1uc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygyLCBmb29fYmF6VGFibGUuZm9yZWlnbktleXNTaXplKCkpOwotCQlhc3NlcnRUcnVlKGZvb19iYXpUYWJsZS5pc1Bvc3NpYmxlSm9pblRhYmxlKCkpOwotCQlhc3NlcnRUcnVlKGZvb19iYXpUYWJsZS5qb2luVGFibGVOYW1lSXNEZWZhdWx0KCkpOwotCQlhc3NlcnRUcnVlKGZvb19iYXpUYWJsZS5nZXRDb2x1bW5OYW1lZCgiZm9vX2lkIikuaXNQYXJ0T2ZGb3JlaWduS2V5KCkpOwotCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiZHJvcCB0YWJsZSBmb29fYmF6Iik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiZHJvcCB0YWJsZSBiYXoiKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJkcm9wIHRhYmxlIGZvbyIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoImRyb3AgdGFibGUgYmFyIik7Ci0KLQkJdGhpcy5nZXRKREJDQ29ubmVjdGlvbigpLnNldENhdGFsb2coIm1hc3RlciIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoImRyb3AgZGF0YWJhc2UgdGFibGVfdGVzdCIpOwotCi0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUucmVtb3ZlQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5kaXNjb25uZWN0KCk7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIENSID0gU3lzdGVtLmdldFByb3BlcnR5KCJsaW5lLnNlcGFyYXRvciIpOyAgLy8kTk9OLU5MUy0xJAotCi0JcHJpdmF0ZSBTdHJpbmcgYnVpbGRCYXJEREwoKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigyMDApOwotCQlzYi5hcHBlbmQoImNyZWF0ZSB0YWJsZSBiYXIgKCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIGlkIGludGVnZXIgcHJpbWFyeSBrZXksIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgY2h1bmsgaW1hZ2UiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIikiKS5hcHBlbmQoQ1IpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBidWlsZEZvb0RETCgpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXNiLmFwcGVuZCgiY3JlYXRlIHRhYmxlIGZvbyAoIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgaWQgaW50ZWdlciBwcmltYXJ5IGtleSwiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBuYW1lIHZhcmNoYXIoMjApIHVuaXF1ZSwiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBiYXJfaWQgaW50ZWdlciByZWZlcmVuY2VzIGJhcihpZCkiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIikiKS5hcHBlbmQoQ1IpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBidWlsZEJhekRETCgpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXNiLmFwcGVuZCgiY3JlYXRlIHRhYmxlIGJheiAoIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgaWQgaW50ZWdlciBwcmltYXJ5IGtleSwiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBuaWNrbmFtZSB2YXJjaGFyKDIwKSBudWxsLCIpLmFwcGVuZChDUik7Ci0JCXNiLmFwcGVuZCgiICAgIHNvbmcgdmFyY2hhcigyMCkgbm90IG51bGwsIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgc2FsYXJ5IGRlY2ltYWwoMTAsIDIpIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIpIikuYXBwZW5kKENSKTsKLQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmcgYnVpbGRGb29CYXpEREwoKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigyMDApOwotCQlzYi5hcHBlbmQoImNyZWF0ZSB0YWJsZSBmb29fYmF6ICgiKS5hcHBlbmQoQ1IpOwotCQlzYi5hcHBlbmQoIiAgICBmb29faWQgaW50ZWdlciByZWZlcmVuY2VzIGZvbyhpZCksIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIgICAgYmF6X2lkIGludGVnZXIgcmVmZXJlbmNlcyBiYXooaWQpIikuYXBwZW5kKENSKTsKLQkJc2IuYXBwZW5kKCIpIikuYXBwZW5kKENSKTsKLQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFRhYmxlTG9va3VwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuY29ubmVjdCgpOwotCQlUZXN0Q29ubmVjdGlvbkxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IFRlc3RDb25uZWN0aW9uTGlzdGVuZXIoKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5hZGRDb25uZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCi0JCXRoaXMuZ2V0SkRCQ0Nvbm5lY3Rpb24oKS5zZXRDYXRhbG9nKCJtYXN0ZXIiKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlSWdub3JlRXJyb3JzKCJkcm9wIGRhdGFiYXNlIHRhYmxlX2xvb2t1cF90ZXN0Iik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiY3JlYXRlIGRhdGFiYXNlIHRhYmxlX2xvb2t1cF90ZXN0Iik7Ci0JCXRoaXMuZ2V0SkRCQ0Nvbm5lY3Rpb24oKS5zZXRDYXRhbG9nKCJ0YWJsZV9sb29rdXBfdGVzdCIpOwotCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiY3JlYXRlIHRhYmxlIHRlc3QxIChpZCBpbnRlZ2VyLCBuYW1lIHZhcmNoYXIoMjApKSIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoImNyZWF0ZSB0YWJsZSBURVNUMiAoaWQgaW50ZWdlciwgbmFtZSB2YXJjaGFyKDIwKSkiKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJjcmVhdGUgdGFibGUgW1Rlc3QzXSAoaWQgaW50ZWdlciwgbmFtZSB2YXJjaGFyKDIwKSkiKTsKLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0KLQkJU2NoZW1hIHNjaGVtYSA9IHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRDYXRhbG9nTmFtZWQoInRhYmxlX2xvb2t1cF90ZXN0IikuZ2V0RGVmYXVsdFNjaGVtYSgpOwotCi0JCWFzc2VydE5vdE51bGwoc2NoZW1hLmdldFRhYmxlTmFtZWQoInRlc3QxIikpOwotCQlhc3NlcnROb3ROdWxsKHNjaGVtYS5nZXRUYWJsZUZvcklkZW50aWZpZXIoInRlc3QxIikpOwotCi0JCWFzc2VydE5vdE51bGwoc2NoZW1hLmdldFRhYmxlTmFtZWQoIlRFU1QyIikpOwotCQlhc3NlcnROb3ROdWxsKHNjaGVtYS5nZXRUYWJsZUZvcklkZW50aWZpZXIoIlRFU1QyIikpOwotCi0JCWFzc2VydE5vdE51bGwoc2NoZW1hLmdldFRhYmxlRm9ySWRlbnRpZmllcigiW1Rlc3QzXSIpKTsKLQotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoImRyb3AgdGFibGUgW1Rlc3QzXSIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoImRyb3AgdGFibGUgVEVTVDIiKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJkcm9wIHRhYmxlIHRlc3QxIik7Ci0KLQkJdGhpcy5nZXRKREJDQ29ubmVjdGlvbigpLnNldENhdGFsb2coIm1hc3RlciIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoImRyb3AgZGF0YWJhc2UgdGFibGVfbG9va3VwX3Rlc3QiKTsKLQotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb2x1bW5Mb29rdXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5jb25uZWN0KCk7Ci0JCVRlc3RDb25uZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENvbm5lY3Rpb25MaXN0ZW5lcigpOwotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmFkZENvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0KLQkJdGhpcy5nZXRKREJDQ29ubmVjdGlvbigpLnNldENhdGFsb2coIm1hc3RlciIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGVJZ25vcmVFcnJvcnMoImRyb3AgZGF0YWJhc2UgY29sdW1uX2xvb2t1cF90ZXN0Iik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiY3JlYXRlIGRhdGFiYXNlIGNvbHVtbl9sb29rdXBfdGVzdCIpOwotCQl0aGlzLmdldEpEQkNDb25uZWN0aW9uKCkuc2V0Q2F0YWxvZygiY29sdW1uX2xvb2t1cF90ZXN0Iik7Ci0KLQkJLy8gbG93ZXJjYXNlCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiY3JlYXRlIHRhYmxlIHRlc3QgKGlkIGludGVnZXIsIG5hbWUgdmFyY2hhcigyMCkpIik7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCVRhYmxlIHRhYmxlID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldENhdGFsb2dOYW1lZCgiY29sdW1uX2xvb2t1cF90ZXN0IikuZ2V0RGVmYXVsdFNjaGVtYSgpLmdldFRhYmxlTmFtZWQoInRlc3QiKTsKLQkJYXNzZXJ0Tm90TnVsbCh0YWJsZS5nZXRDb2x1bW5OYW1lZCgiaWQiKSk7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uTmFtZWQoIm5hbWUiKSk7Ci0KLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJkcm9wIHRhYmxlIHRlc3QiKTsKLQotCQkvLyB1cHBlcmNhc2UKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJjcmVhdGUgdGFibGUgdGVzdCAoSUQgaW50ZWdlciwgTkFNRSB2YXJjaGFyKDIwKSkiKTsKLQkJKChJQ2F0YWxvZ09iamVjdCkgdGhpcy5nZXREVFBEYXRhYmFzZSgpKS5yZWZyZXNoKCk7Ci0KLQkJdGFibGUgPSB0aGlzLmdldERhdGFiYXNlKCkuZ2V0Q2F0YWxvZ05hbWVkKCJjb2x1bW5fbG9va3VwX3Rlc3QiKS5nZXREZWZhdWx0U2NoZW1hKCkuZ2V0VGFibGVOYW1lZCgidGVzdCIpOwotCQlhc3NlcnROb3ROdWxsKHRhYmxlLmdldENvbHVtbkZvcklkZW50aWZpZXIoIklEIikpOwotCQlhc3NlcnROb3ROdWxsKHRhYmxlLmdldENvbHVtbkZvcklkZW50aWZpZXIoIk5BTUUiKSk7Ci0KLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJkcm9wIHRhYmxlIHRlc3QiKTsKLQotCQkvLyBtaXhlZCBjYXNlCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiY3JlYXRlIHRhYmxlIHRlc3QgKElkIGludGVnZXIsIE5hbWUgdmFyY2hhcigyMCkpIik7Ci0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCi0JCXRhYmxlID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldENhdGFsb2dOYW1lZCgiY29sdW1uX2xvb2t1cF90ZXN0IikuZ2V0RGVmYXVsdFNjaGVtYSgpLmdldFRhYmxlTmFtZWQoInRlc3QiKTsKLQkJYXNzZXJ0Tm90TnVsbCh0YWJsZS5nZXRDb2x1bW5Gb3JJZGVudGlmaWVyKCJJZCIpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0YWJsZS5nZXRDb2x1bW5Gb3JJZGVudGlmaWVyKCJOYW1lIikpOwotCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiZHJvcCB0YWJsZSB0ZXN0Iik7Ci0KLQkJLy8gZGVsaW1pdGVkCi0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiY3JlYXRlIHRhYmxlIHRlc3QgKFtJZF0gaW50ZWdlciwgW05hbWVdIHZhcmNoYXIoMjApKSIpOwotCQkoKElDYXRhbG9nT2JqZWN0KSB0aGlzLmdldERUUERhdGFiYXNlKCkpLnJlZnJlc2goKTsKLQotCQl0YWJsZSA9IHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRDYXRhbG9nTmFtZWQoImNvbHVtbl9sb29rdXBfdGVzdCIpLmdldERlZmF1bHRTY2hlbWEoKS5nZXRUYWJsZU5hbWVkKCJ0ZXN0Iik7Ci0JCWFzc2VydE5vdE51bGwodGFibGUuZ2V0Q29sdW1uRm9ySWRlbnRpZmllcigiW0lkXSIpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0YWJsZS5nZXRDb2x1bW5Gb3JJZGVudGlmaWVyKCJbTmFtZV0iKSk7Ci0KLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJkcm9wIHRhYmxlIHRlc3QiKTsKLQotCQl0aGlzLmdldEpEQkNDb25uZWN0aW9uKCkuc2V0Q2F0YWxvZygibWFzdGVyIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiZHJvcCBkYXRhYmFzZSBjb2x1bW5fbG9va3VwX3Rlc3QiKTsKLQotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLnJlbW92ZUNvbm5lY3Rpb25MaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuZGlzY29ubmVjdCgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDcm9zc1NjaGVtYVJlZmVyZW5jZSgpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmNvbm5lY3Rpb25Qcm9maWxlLmNvbm5lY3QoKTsKLQkJVGVzdENvbm5lY3Rpb25MaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBUZXN0Q29ubmVjdGlvbkxpc3RlbmVyKCk7Ci0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUuYWRkQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQotCQl0aGlzLmdldEpEQkNDb25uZWN0aW9uKCkuc2V0Q2F0YWxvZygibWFzdGVyIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZUlnbm9yZUVycm9ycygiZHJvcCBkYXRhYmFzZSB4cmVmX3Rlc3QyIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZUlnbm9yZUVycm9ycygiZHJvcCBkYXRhYmFzZSB4cmVmX3Rlc3QxIik7Ci0KLQkJdGhpcy5nZXRKREJDQ29ubmVjdGlvbigpLnNldENhdGFsb2coIm1hc3RlciIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoImNyZWF0ZSBkYXRhYmFzZSB4cmVmX3Rlc3QxIik7Ci0JCXRoaXMuZ2V0SkRCQ0Nvbm5lY3Rpb24oKS5zZXRDYXRhbG9nKCJ4cmVmX3Rlc3QxIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiY3JlYXRlIHRhYmxlIG9yZyAoaWQgaW50ZWdlciBwcmltYXJ5IGtleSwgbmFtZSB2YXJjaGFyKDIwKSkiKTsKLQotCQl0aGlzLmdldEpEQkNDb25uZWN0aW9uKCkuc2V0Q2F0YWxvZygibWFzdGVyIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiY3JlYXRlIGRhdGFiYXNlIHhyZWZfdGVzdDIiKTsKLQkJdGhpcy5nZXRKREJDQ29ubmVjdGlvbigpLnNldENhdGFsb2coInhyZWZfdGVzdDIiKTsKLQkJdGhpcy5leGVjdXRlVXBkYXRlKCJjcmVhdGUgdGFibGUgZW1wIChpZCBpbnRlZ2VyIHByaW1hcnkga2V5LCBuYW1lIHZhcmNoYXIoMjApLCAiICsKLQkJCQkib3JnX2lkIGludGVnZXIgcmVmZXJlbmNlcyB4cmVmX3Rlc3QxLi5vcmcoaWQpKSIpOwotCi0JCSgoSUNhdGFsb2dPYmplY3QpIHRoaXMuZ2V0RFRQRGF0YWJhc2UoKSkucmVmcmVzaCgpOwotCQlDYXRhbG9nIGNhdGFsb2cxID0gdGhpcy5nZXREYXRhYmFzZSgpLmdldENhdGFsb2dOYW1lZCgieHJlZl90ZXN0MSIpOwotCQlhc3NlcnROb3ROdWxsKGNhdGFsb2cxKTsKLQkJU2NoZW1hIHNjaGVtYTEgPSBjYXRhbG9nMS5nZXRTY2hlbWFOYW1lZCgiZGJvIik7Ci0JCWFzc2VydE5vdE51bGwoc2NoZW1hMSk7Ci0JCVRhYmxlIG9yZ1RhYmxlID0gc2NoZW1hMS5nZXRUYWJsZU5hbWVkKCJvcmciKTsKLQkJYXNzZXJ0Tm90TnVsbChvcmdUYWJsZSk7Ci0KLQkJQ2F0YWxvZyBjYXRhbG9nMiA9IHRoaXMuZ2V0RGF0YWJhc2UoKS5nZXRDYXRhbG9nTmFtZWQoInhyZWZfdGVzdDIiKTsKLQkJYXNzZXJ0Tm90TnVsbChjYXRhbG9nMik7Ci0JCVNjaGVtYSBzY2hlbWEyID0gY2F0YWxvZzIuZ2V0U2NoZW1hTmFtZWQoImRibyIpOwotCQlhc3NlcnROb3ROdWxsKHNjaGVtYTIpOwotCQlUYWJsZSBlbXBUYWJsZSA9IHNjaGVtYTIuZ2V0VGFibGVOYW1lZCgiZW1wIik7Ci0JCWFzc2VydE5vdE51bGwoZW1wVGFibGUpOwotCQlhc3NlcnRFcXVhbHMoMSwgZW1wVGFibGUuZm9yZWlnbktleXNTaXplKCkpOwotCQlGb3JlaWduS2V5IGZrID0gZW1wVGFibGUuZm9yZWlnbktleXMoKS5uZXh0KCk7Ci0JCVRhYmxlIHJlZlRhYmxlID0gZmsuZ2V0UmVmZXJlbmNlZFRhYmxlKCk7Ci0JCWFzc2VydE5vdE51bGwocmVmVGFibGUpOwotCQlhc3NlcnRFcXVhbHMoIm9yZyIsIHJlZlRhYmxlLmdldE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBmay5jb2x1bW5QYWlyc1NpemUoKSk7Ci0JCUZvcmVpZ25LZXkuQ29sdW1uUGFpciBjcCA9IGZrLmNvbHVtblBhaXJzKCkubmV4dCgpOwotCQlDb2x1bW4gYmFzZUNvbHVtbiA9IGNwLmdldEJhc2VDb2x1bW4oKTsKLQkJYXNzZXJ0RXF1YWxzKCJvcmdfaWQiLCBiYXNlQ29sdW1uLmdldE5hbWUoKSk7Ci0JCUNvbHVtbiByZWZDb2x1bW4gPSBjcC5nZXRSZWZlcmVuY2VkQ29sdW1uKCk7Ci0JCWFzc2VydEVxdWFscygiaWQiLCByZWZDb2x1bW4uZ2V0TmFtZSgpKTsKLQotCQl0aGlzLmdldEpEQkNDb25uZWN0aW9uKCkuc2V0Q2F0YWxvZygieHJlZl90ZXN0MiIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoImRyb3AgdGFibGUgZW1wIik7Ci0JCXRoaXMuZ2V0SkRCQ0Nvbm5lY3Rpb24oKS5zZXRDYXRhbG9nKCJ4cmVmX3Rlc3QxIik7Ci0JCXRoaXMuZXhlY3V0ZVVwZGF0ZSgiZHJvcCB0YWJsZSBvcmciKTsKLQkJdGhpcy5nZXRKREJDQ29ubmVjdGlvbigpLnNldENhdGFsb2coIm1hc3RlciIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoImRyb3AgZGF0YWJhc2UgeHJlZl90ZXN0MiIpOwotCQl0aGlzLmV4ZWN1dGVVcGRhdGUoImRyb3AgZGF0YWJhc2UgeHJlZl90ZXN0MSIpOwotCi0JCXRoaXMuY29ubmVjdGlvblByb2ZpbGUucmVtb3ZlQ29ubmVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJdGhpcy5jb25uZWN0aW9uUHJvZmlsZS5kaXNjb25uZWN0KCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy8uY2xhc3NwYXRoIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5nZW4udGVzdHMvLmNsYXNzcGF0aApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODQ3NDRlNy4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy8uY2xhc3NwYXRoCisrKyAvZGV2L251bGwKQEAgLTEsMTEgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxjbGFzc3BhdGg+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9ImNvbiIgcGF0aD0ib3JnLmVjbGlwc2UuamR0LmxhdW5jaGluZy5KUkVfQ09OVEFJTkVSL29yZy5lY2xpcHNlLmpkdC5pbnRlcm5hbC5kZWJ1Zy51aS5sYXVuY2hlci5TdGFuZGFyZFZNVHlwZS9KMlNFLTEuNSIvPgotCTxjbGFzc3BhdGhlbnRyeSBraW5kPSJjb24iIHBhdGg9Im9yZy5lY2xpcHNlLnBkZS5jb3JlLnJlcXVpcmVkUGx1Z2lucyI+Ci0JCTxhY2Nlc3NydWxlcz4KLQkJCTxhY2Nlc3NydWxlIGtpbmQ9ImFjY2Vzc2libGUiIHBhdHRlcm49Im9yZy9lY2xpcHNlL2pwdC9nZW4vKioiLz4KLQkJPC9hY2Nlc3NydWxlcz4KLQk8L2NsYXNzcGF0aGVudHJ5PgotCTxjbGFzc3BhdGhlbnRyeSBraW5kPSJzcmMiIHBhdGg9InNyYyIvPgotCTxjbGFzc3BhdGhlbnRyeSBraW5kPSJvdXRwdXQiIHBhdGg9ImJpbiIvPgotPC9jbGFzc3BhdGg+CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy8ucHJvamVjdCBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZ2VuLnRlc3RzLy5wcm9qZWN0CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyMTU5ZmViLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZ2VuLnRlc3RzLy5wcm9qZWN0CisrKyAvZGV2L251bGwKQEAgLTEsMjggKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxwcm9qZWN0RGVzY3JpcHRpb24+Ci0JPG5hbWU+b3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0czwvbmFtZT4KLQk8Y29tbWVudD48L2NvbW1lbnQ+Ci0JPHByb2plY3RzPgotCTwvcHJvamVjdHM+Ci0JPGJ1aWxkU3BlYz4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLmpkdC5jb3JlLmphdmFidWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5NYW5pZmVzdEJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLlNjaGVtYUJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCTwvYnVpbGRTcGVjPgotCTxuYXR1cmVzPgotCQk8bmF0dXJlPm9yZy5lY2xpcHNlLnBkZS5QbHVnaW5OYXR1cmU8L25hdHVyZT4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5qZHQuY29yZS5qYXZhbmF0dXJlPC9uYXR1cmU+Ci0JPC9uYXR1cmVzPgotPC9wcm9qZWN0RGVzY3JpcHRpb24+CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuamR0LmNvcmUucHJlZnMgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuamR0LmNvcmUucHJlZnMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhiYWI5MTMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5nZW4udGVzdHMvLnNldHRpbmdzL29yZy5lY2xpcHNlLmpkdC5jb3JlLnByZWZzCisrKyAvZGV2L251bGwKQEAgLTEsNyArMCwwIEBACi0jTW9uIEp1bCAwNyAyMDoxMzoyNCBFRFQgMjAwOAotZWNsaXBzZS5wcmVmZXJlbmNlcy52ZXJzaW9uPTEKLW9yZy5lY2xpcHNlLmpkdC5jb3JlLmNvbXBpbGVyLmNvZGVnZW4udGFyZ2V0UGxhdGZvcm09MS41Ci1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5jb21wbGlhbmNlPTEuNQotb3JnLmVjbGlwc2UuamR0LmNvcmUuY29tcGlsZXIucHJvYmxlbS5hc3NlcnRJZGVudGlmaWVyPWVycm9yCi1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5wcm9ibGVtLmVudW1JZGVudGlmaWVyPWVycm9yCi1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5zb3VyY2U9MS41CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy9NRVRBLUlORi9NQU5JRkVTVC5NRiBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZ2VuLnRlc3RzL01FVEEtSU5GL01BTklGRVNULk1GCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1ZmU0NDVhLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZ2VuLnRlc3RzL01FVEEtSU5GL01BTklGRVNULk1GCisrKyAvZGV2L251bGwKQEAgLTEsMTQgKzAsMCBAQAotTWFuaWZlc3QtVmVyc2lvbjogMS4wCi1CdW5kbGUtTWFuaWZlc3RWZXJzaW9uOiAyCi1CdW5kbGUtTmFtZTogJXBsdWdpbk5hbWUKLUJ1bmRsZS1TeW1ib2xpY05hbWU6IG9yZy5lY2xpcHNlLmpwdC5nZW4udGVzdHMKLUJ1bmRsZS1WZXJzaW9uOiAyLjAuMAotQnVuZGxlLVJlcXVpcmVkRXhlY3V0aW9uRW52aXJvbm1lbnQ6IEoyU0UtMS41Ci1CdW5kbGUtVmVuZG9yOiAlcHJvdmlkZXJOYW1lCi1SZXF1aXJlLUJ1bmRsZTogb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lO2J1bmRsZS12ZXJzaW9uPSIzLjQuMCIsCi0gb3JnLmVjbGlwc2UuamR0LmNvcmU7YnVuZGxlLXZlcnNpb249IjMuNC4wIiwKLSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eTtidW5kbGUtdmVyc2lvbj0iMS4yLjAiLAotIG9yZy5lY2xpcHNlLmpwdC5kYjtidW5kbGUtdmVyc2lvbj0iMS4xLjEiLAotIG9yZy5lY2xpcHNlLmpwdC5nZW47YnVuZGxlLXZlcnNpb249IjEuMS4wIiwKLSBvcmcuanVuaXQ7YnVuZGxlLXZlcnNpb249IjMuOC4yIgotRXhwb3J0LVBhY2thZ2U6IG9yZy5lY2xpcHNlLmpwdC5nZW4udGVzdHMuaW50ZXJuYWw7eC1pbnRlcm5hbDo9dHJ1ZQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5nZW4udGVzdHMvYWJvdXQuaHRtbCBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZ2VuLnRlc3RzL2Fib3V0Lmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJlNTM0YmEuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5nZW4udGVzdHMvYWJvdXQuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDM0ICswLDAgQEAKLTwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAvL0VOIj4KLTxIVE1MPgotCi08aGVhZD4KLTx0aXRsZT5BYm91dDwvdGl0bGU+Ci08bWV0YSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9SVNPLTg4NTktMSI+Ci08L2hlYWQ+Ci0KLTxCT0RZIGxhbmc9IkVOLVVTIj4KLQotPEgzPkFib3V0IFRoaXMgQ29udGVudDwvSDM+Ci0KLTxQPk1heSAwMiwgMjAwODwvUD4KLQotPEgzPkxpY2Vuc2U8L0gzPgotCi08UD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBhbGwgY29udGVudCBpbiB0aGlzIHBsdWctaW4gCi0oIkNvbnRlbnQiKS4gVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQgYmVsb3csIHRoZSBDb250ZW50IGlzIHByb3ZpZGVkIHRvIHlvdSAKLXVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAKLSgiRVBMIikuIEEgY29weSBvZiB0aGUgRVBMIGlzIGF2YWlsYWJsZSBhdAotPEEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9vcmcvZG9jdW1lbnRzL2VwbC12MTAucGhwIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL29yZy9kb2N1bWVudHMvZXBsLXYxMC5waHA8L0E+LiAKLUZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAiUHJvZ3JhbSIgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvUD4KLQotPFA+SWYgeW91IGRpZCBub3QgcmVjZWl2ZSB0aGlzIENvbnRlbnQgZGlyZWN0bHkgZnJvbSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uLCB0aGUgCi1Db250ZW50IGlzIGJlaW5nIHJlZGlzdHJpYnV0ZWQgYnkgYW5vdGhlciBwYXJ0eSAoIlJlZGlzdHJpYnV0b3IiKSBhbmQgZGlmZmVyZW50IAotdGVybXMgYW5kIGNvbmRpdGlvbnMgbWF5IGFwcGx5IHRvIHlvdXIgdXNlIG9mIGFueSBvYmplY3QgY29kZSBpbiB0aGUgQ29udGVudC4gCi1DaGVjayB0aGUgUmVkaXN0cmlidXRvcidzIGxpY2Vuc2UgdGhhdCB3YXMgcHJvdmlkZWQgd2l0aCB0aGUgQ29udGVudC4gSWYgbm8gc3VjaCAKLWxpY2Vuc2UgZXhpc3RzLCBjb250YWN0IHRoZSBSZWRpc3RyaWJ1dG9yLiBVbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCBiZWxvdywgdGhlIAotdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVQTCBzdGlsbCBhcHBseSB0byBhbnkgc291cmNlIGNvZGUgaW4gdGhlIENvbnRlbnQgCi1hbmQgc3VjaCBzb3VyY2UgY29kZSBtYXkgYmUgb2J0YWluZWQgYXQKLTxBIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnLzwvQT4uPC9QPgotCi08L0JPRFk+Ci08L0hUTUw+CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy9idWlsZC5wcm9wZXJ0aWVzIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5nZW4udGVzdHMvYnVpbGQucHJvcGVydGllcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTY4ZDRiZi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy9idWlsZC5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTggKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSMgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0jIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0jIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi1qYXZhY1NvdXJjZSA9IDEuNQotamF2YWNUYXJnZXQgPSAxLjUKLWJpbi5pbmNsdWRlcyA9IC4sXAotICAgICAgICAgICAgICAgTUVUQS1JTkYvLFwKLSAgICAgICAgICAgICAgIGFib3V0Lmh0bWwsXAotICAgICAgICAgICAgICAgdGVzdC54bWwsXAotICAgICAgICAgICAgICAgcGx1Z2luLnByb3BlcnRpZXMKLXNvdXJjZS4uID0gc3JjLwotb3V0cHV0Li4gPSBiaW4vCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy9wbHVnaW4ucHJvcGVydGllcyBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZ2VuLnRlc3RzL3BsdWdpbi5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyNjlhNWRjLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZ2VuLnRlc3RzL3BsdWdpbi5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMjIgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyAgQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcwotIyAgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZgotIyAgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzCi0jICBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKLSMgIAotIyAgQ29udHJpYnV0b3JzOiBPcmFjbGUuIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0jIFRvIGNvZGUgZGV2ZWxvcGVyOgotIyAgIERvIE5PVCBjaGFuZ2UgdGhlIHByb3BlcnRpZXMgYmV0d2VlbiB0aGlzIGxpbmUgYW5kIHRoZQotIyAgICIlJSUgRU5EIE9GIFRSQU5TTEFURUQgUFJPUEVSVElFUyAlJSUiIGxpbmUuCi0jICAgTWFrZSBhIG5ldyBwcm9wZXJ0eSBuYW1lLCBhcHBlbmQgdG8gdGhlIGVuZCBvZiB0aGUgZmlsZSBhbmQgY2hhbmdlCi0jICAgdGhlIGNvZGUgdG8gdXNlIHRoZSBuZXcgcHJvcGVydHkuCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0KLSMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLSMgJSUlIEVORCBPRiBUUkFOU0xBVEVEIFBST1BFUlRJRVMgJSUlCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0KLXBsdWdpbk5hbWU9SmF2YSBQZXJzaXN0ZW5jZSBUb29scyBFbnRpdHkgR2VuZXJhdGlvbiBUZXN0cwotcHJvdmlkZXJOYW1lPUVjbGlwc2Uub3JnCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi90ZXN0cy9pbnRlcm5hbC9FbnRpdHlHZW5Ub29sc1Rlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi90ZXN0cy9pbnRlcm5hbC9FbnRpdHlHZW5Ub29sc1Rlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDlmZjIyMWMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC5nZW4udGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC9nZW4vdGVzdHMvaW50ZXJuYWwvRW50aXR5R2VuVG9vbHNUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTQ0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEudXRpbC5IYXNoU2V0OwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0Lmdlbi5pbnRlcm5hbC5FbnRpdHlHZW5Ub29sczsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLQotLyoqCi0gKiAKLSAqLwotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgY2xhc3MgRW50aXR5R2VuVG9vbHNUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBFbnRpdHlHZW5Ub29sc1Rlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUxKCkgewotCQlIYXNoU2V0PFN0cmluZz4gbmFtZXMgPSBuZXcgSGFzaFNldDxTdHJpbmc+KCk7Ci0JCWFzc2VydEVxdWFscygiRm9vIiwgRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQ2xhc3NOYW1lKCJGb28iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIkZvbyIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUNsYXNzTmFtZSgiZm9vIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJGb28iLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUoIkZPTyIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiRm9vIiwgRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQ2xhc3NOYW1lKCJGT09fIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJGb28iLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUoIl9GT08iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIkZvb18iLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUoIkZPTyoiLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIl9vbyIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUNsYXNzTmFtZSgiNW9vIiwgbmFtZXMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udmVydFRvVW5pcXVlSmF2YVN0eWxlQ2xhc3NOYW1lMigpIHsKLQkJSGFzaFNldDxTdHJpbmc+IG5hbWVzID0gbmV3IEhhc2hTZXQ8U3RyaW5nPigpOwotCQluYW1lcy5hZGQoIkZvbyIpOwotCQlhc3NlcnRFcXVhbHMoIkZvbzIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUoIkZvbyIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiRm9vMiIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUNsYXNzTmFtZSgiZm9vIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJGb28yIiwgRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQ2xhc3NOYW1lKCJGT08iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIkZvbzIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUoIkZPT18iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIkZvbzIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUoIl9GT08iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIkZvb18iLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUoIkZPTyoiLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIl9vbyIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUNsYXNzTmFtZSgiNU9PIiwgbmFtZXMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udmVydFRvVW5pcXVlSmF2YVN0eWxlQ2xhc3NOYW1lMygpIHsKLQkJSGFzaFNldDxTdHJpbmc+IG5hbWVzID0gbmV3IEhhc2hTZXQ8U3RyaW5nPigpOwotCQluYW1lcy5hZGQoImZvbyIpOwotCQlhc3NlcnRFcXVhbHMoIkZvbzIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUoIkZvbyIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiRm9vMiIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUNsYXNzTmFtZSgiZm9vIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJGb28yIiwgRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQ2xhc3NOYW1lKCJGT08iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIkZvbzIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUoIkZPT18iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIkZvbzIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUoIl9GT08iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIkZvb18iLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUoIkZPTyoiLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIl9vbyIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUNsYXNzTmFtZSgiNU9PIiwgbmFtZXMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udmVydFRvVW5pcXVlSmF2YVN0eWxlQ2xhc3NOYW1lNCgpIHsKLQkJSGFzaFNldDxTdHJpbmc+IG5hbWVzID0gbmV3IEhhc2hTZXQ8U3RyaW5nPigpOwotCQlhc3NlcnRFcXVhbHMoIkZvb0JhciIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUNsYXNzTmFtZSgiRm9vQmFyIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJGb29fYmFyIiwgRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQ2xhc3NOYW1lKCJmb29fYmFyIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJGb29CYXIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUoIkZPT19CQVIiLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIkZvb0JhciIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUNsYXNzTmFtZSgiX0ZPT19CQVIiLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIkZvb0JhciIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUNsYXNzTmFtZSgiRk9PX0JBUl8iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIkZvb0Jhcl8iLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUoIkZPT19CQVJfKiIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiX2Zvb0JhciIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUNsYXNzTmFtZSgiNEZPT19CQVIiLCBuYW1lcykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWU1KCkgewotCQlIYXNoU2V0PFN0cmluZz4gbmFtZXMgPSBuZXcgSGFzaFNldDxTdHJpbmc+KCk7Ci0JCW5hbWVzLmFkZCgiRm9vQmFyIik7Ci0JCWFzc2VydEVxdWFscygiRm9vQmFyMiIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUNsYXNzTmFtZSgiRm9vQmFyIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJGb29fYmFyIiwgRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQ2xhc3NOYW1lKCJmb29fYmFyIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJGb29CYXIyIiwgRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQ2xhc3NOYW1lKCJGT09fQkFSIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJGb29CYXIyIiwgRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQ2xhc3NOYW1lKCJfRk9PX0JBUiIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiRm9vQmFyMiIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUNsYXNzTmFtZSgiRk9PX0JBUl8iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIkZvb0Jhcl8iLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVDbGFzc05hbWUoIkZPT19CQVJfKiIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiX2Zvb0JhciIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUNsYXNzTmFtZSgiNEZPT19CQVIiLCBuYW1lcykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lMSgpIHsKLQkJSGFzaFNldDxTdHJpbmc+IG5hbWVzID0gbmV3IEhhc2hTZXQ8U3RyaW5nPigpOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUoIkZvbyIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQXR0cmlidXRlTmFtZSgiZm9vIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCJGT08iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUoIkZPT18iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUoIl9GT08iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoImZvb18iLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCJGT08qIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJfb28iLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCI1b28iLCBuYW1lcykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lMigpIHsKLQkJSGFzaFNldDxTdHJpbmc+IG5hbWVzID0gbmV3IEhhc2hTZXQ8U3RyaW5nPigpOwotCQluYW1lcy5hZGQoIkZvbyIpOwotCQlhc3NlcnRFcXVhbHMoImZvbzIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCJGb28iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoImZvbzIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCJmb28iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoImZvbzIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCJGT08iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoImZvbzIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCJGT09fIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28yIiwgRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQXR0cmlidXRlTmFtZSgiX0ZPTyIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vXyIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUoIkZPTyoiLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIl9vbyIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUoIjVPTyIsIG5hbWVzKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUzKCkgewotCQlIYXNoU2V0PFN0cmluZz4gbmFtZXMgPSBuZXcgSGFzaFNldDxTdHJpbmc+KCk7Ci0JCW5hbWVzLmFkZCgiZm9vIik7Ci0JCWFzc2VydEVxdWFscygiZm9vMiIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUoIkZvbyIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vMiIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUoImZvbyIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vMiIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUoIkZPTyIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vMiIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUoIkZPT18iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoImZvbzIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCJfRk9PIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb29fIiwgRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQXR0cmlidXRlTmFtZSgiRk9PKiIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiX29vIiwgRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQXR0cmlidXRlTmFtZSgiNU9PIiwgbmFtZXMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udmVydFRvVW5pcXVlSmF2YVN0eWxlQXR0cmlidXRlTmFtZTQoKSB7Ci0JCUhhc2hTZXQ8U3RyaW5nPiBuYW1lcyA9IG5ldyBIYXNoU2V0PFN0cmluZz4oKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb29CYXIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCJGb29CYXIiLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoImZvb19iYXIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCJmb29fYmFyIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb29CYXIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCJGT09fQkFSIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb29CYXIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCJfRk9PX0JBUiIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vQmFyIiwgRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQXR0cmlidXRlTmFtZSgiRk9PX0JBUl8iLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoImZvb0Jhcl8iLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCJGT09fQkFSXyoiLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoIl9mb29CYXIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCI0Rk9PX0JBUiIsIG5hbWVzKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWU1KCkgewotCQlIYXNoU2V0PFN0cmluZz4gbmFtZXMgPSBuZXcgSGFzaFNldDxTdHJpbmc+KCk7Ci0JCW5hbWVzLmFkZCgiRm9vQmFyIik7Ci0JCWFzc2VydEVxdWFscygiZm9vQmFyMiIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUoIkZvb0JhciIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vX2JhciIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUoImZvb19iYXIiLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoImZvb0JhcjIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCJGT09fQkFSIiwgbmFtZXMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb29CYXIyIiwgRW50aXR5R2VuVG9vbHMuY29udmVydFRvVW5pcXVlSmF2YVN0eWxlQXR0cmlidXRlTmFtZSgiX0ZPT19CQVIiLCBuYW1lcykpOwotCQlhc3NlcnRFcXVhbHMoImZvb0JhcjIiLCBFbnRpdHlHZW5Ub29scy5jb252ZXJ0VG9VbmlxdWVKYXZhU3R5bGVBdHRyaWJ1dGVOYW1lKCJGT09fQkFSXyIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vQmFyXyIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUoIkZPT19CQVJfKiIsIG5hbWVzKSk7Ci0JCWFzc2VydEVxdWFscygiX2Zvb0JhciIsIEVudGl0eUdlblRvb2xzLmNvbnZlcnRUb1VuaXF1ZUphdmFTdHlsZUF0dHJpYnV0ZU5hbWUoIjRGT09fQkFSIiwgbmFtZXMpKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZ2VuLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL3Rlc3RzL2ludGVybmFsL0pwdEdlblRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L2dlbi90ZXN0cy9pbnRlcm5hbC9KcHRHZW5UZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxZTc5ZDdkLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZ2VuLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvZ2VuL3Rlc3RzL2ludGVybmFsL0pwdEdlblRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzMiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC5nZW4udGVzdHMuaW50ZXJuYWw7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdFN1aXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5nZW4udGVzdHMuaW50ZXJuYWwuRW50aXR5R2VuVG9vbHNUZXN0czsKLQotLyoqCi0gKiAKLSAqLwotcHVibGljIGNsYXNzIEpwdEdlblRlc3RzIHsKLQotCXB1YmxpYyBzdGF0aWMgVGVzdCBzdWl0ZSgpIHsKLQkJVGVzdFN1aXRlIHN1aXRlID0gbmV3IFRlc3RTdWl0ZSgiSlBUIEVudGl0eSBHZW5lcmF0aW9uIFRlc3RzIik7IC8vJE5PTi1OTFMtMSQKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKEVudGl0eUdlblRvb2xzVGVzdHMuY2xhc3MpOwotCQlyZXR1cm4gc3VpdGU7Ci0JfQotCi0JcHJpdmF0ZSBKcHRHZW5UZXN0cygpIHsKLQkJc3VwZXIoKTsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy90ZXN0LnhtbCBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZ2VuLnRlc3RzL3Rlc3QueG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxMWQzMTFhLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQuZ2VuLnRlc3RzL3Rlc3QueG1sCisrKyAvZGV2L251bGwKQEAgLTEsNDAgKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIj8+Ci08cHJvamVjdCBuYW1lPSJ0ZXN0c3VpdGUiIGRlZmF1bHQ9InJ1biIgYmFzZWRpcj0iLiI+Ci0JPCEtLSBUaGUgcHJvcGVydHkgJHtlY2xpcHNlLWhvbWV9IHNob3VsZCBiZSBwYXNzZWQgaW50byB0aGlzIHNjcmlwdCAtLT4KLQk8IS0tIFNldCBhIG1lYW5pbmdmdWwgZGVmYXVsdCB2YWx1ZSBmb3Igd2hlbiBpdCBpcyBub3QuIC0tPgotCTxlY2hvIG1lc3NhZ2U9ImJhc2VkaXIgJHtiYXNlZGlyfSIgLz4KLQk8ZWNobyBtZXNzYWdlPSJlY2xpcHNlIHBsYWNlICR7ZWNsaXBzZS1ob21lfSIgLz4KLQk8IS0tIHNldHMgdGhlIHByb3BlcnRpZXMgcGx1Z2luLW5hbWUgLS0+Ci0JPHByb3BlcnR5IG5hbWU9InBsdWdpbi1uYW1lIiB2YWx1ZT0ib3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cyIvPgotCi0JPCEtLSBUaGlzIHRhcmdldCBob2xkcyBhbGwgaW5pdGlhbGl6YXRpb24gY29kZSB0aGF0IG5lZWRzIHRvIGJlIGRvbmUgZm9yIC0tPgotCTwhLS0gYWxsIHRlc3RzIHRoYXQgYXJlIHRvIGJlIHJ1bi4gSW5pdGlhbGl6YXRpb24gZm9yIGluZGl2aWR1YWwgdGVzdHMgLS0+Ci0JPCEtLSBzaG91bGQgYmUgZG9uZSB3aXRoaW4gdGhlIGJvZHkgb2YgdGhlIHN1aXRlIHRhcmdldC4gLS0+Ci0JPHRhcmdldCBuYW1lPSJpbml0Ij4KLQkJPHRzdGFtcC8+Ci0JCTxkZWxldGU+Ci0JCQk8ZmlsZXNldCBkaXI9IiR7ZWNsaXBzZS1ob21lfSIgaW5jbHVkZXM9Im9yZyoueG1sIi8+Ci0JCTwvZGVsZXRlPgotCTwvdGFyZ2V0PgotCi0JPCEtLSBUaGlzIHRhcmdldCBkZWZpbmVzIHRoZSB0ZXN0cyB0aGF0IG5lZWQgdG8gYmUgcnVuLiAtLT4KLQk8dGFyZ2V0IG5hbWU9InN1aXRlIj4KLQkJPGFudCB0YXJnZXQ9Imdlbi10ZXN0IiBhbnRmaWxlPSIke2xpYnJhcnktZmlsZX0iIGRpcj0iJHtlY2xpcHNlLWhvbWV9Ij4KLQkJCTxwcm9wZXJ0eSBuYW1lPSJwbHVnaW4tbmFtZSIgdmFsdWU9IiR7cGx1Z2luLW5hbWV9Ii8+Ci0JCQk8cHJvcGVydHkgbmFtZT0iY2xhc3NuYW1lIiB2YWx1ZT0ib3JnLmVjbGlwc2UuanB0Lmdlbi50ZXN0cy5pbnRlcm5hbC5KcHRHZW5UZXN0cyIgLz4KLQkJCTxwcm9wZXJ0eSBuYW1lPSJwbHVnaW4tcGF0aCIgdmFsdWU9IiR7ZWNsaXBzZS1ob21lfS9wbHVnaW5zLyR7cGx1Z2luLW5hbWV9Ii8+Ci0JCQk8cHJvcGVydHkgbmFtZT0iZXh0cmFWTWFyZ3MiIHZhbHVlPSIiLz4KLQkJPC9hbnQ+Ci0JPC90YXJnZXQ+Ci0KLQk8IS0tIFRoaXMgdGFyZ2V0IGhvbGRzIGNvZGUgdG8gY2xlYW51cCB0aGUgdGVzdGluZyBlbnZpcm9ubWVudCBhZnRlciAtLT4KLQk8IS0tIGFmdGVyIGFsbCBvZiB0aGUgdGVzdHMgaGF2ZSBiZWVuIHJ1bi4gWW91IGNhbiB1c2UgdGhpcyB0YXJnZXQgdG8gLS0+Ci0JPCEtLSBkZWxldGUgdGVtcG9yYXJ5IGZpbGVzIHRoYXQgaGF2ZSBiZWVuIGNyZWF0ZWQuIC0tPgotCTx0YXJnZXQgbmFtZT0iY2xlYW51cCI+Ci0JPC90YXJnZXQ+Ci0KLQk8IS0tIFRoaXMgdGFyZ2V0IHJ1bnMgdGhlIHRlc3Qgc3VpdGUuIEFueSBhY3Rpb25zIHRoYXQgbmVlZCB0byBoYXBwZW4gLS0+Ci0JPCEtLSBhZnRlciBhbGwgdGhlIHRlc3RzIGhhdmUgYmVlbiBydW4gc2hvdWxkIGdvIGhlcmUuIC0tPgotCTx0YXJnZXQgbmFtZT0icnVuIiBkZXBlbmRzPSJpbml0LCBzdWl0ZSwgY2xlYW51cCI+Ci0JPC90YXJnZXQ+Ci08L3Byb2plY3Q+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy8uY2xhc3NwYXRoIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy8uY2xhc3NwYXRoCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzNzA4NzdiLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvLmNsYXNzcGF0aAorKysgL2Rldi9udWxsCkBAIC0xLDEzICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08Y2xhc3NwYXRoPgotCTxjbGFzc3BhdGhlbnRyeSBraW5kPSJzcmMiIHBhdGg9InNyYyIvPgotCTxjbGFzc3BhdGhlbnRyeSBraW5kPSJjb24iIHBhdGg9Im9yZy5lY2xpcHNlLmpkdC5sYXVuY2hpbmcuSlJFX0NPTlRBSU5FUiIvPgotCTxjbGFzc3BhdGhlbnRyeSBraW5kPSJjb24iIHBhdGg9Im9yZy5lY2xpcHNlLnBkZS5jb3JlLnJlcXVpcmVkUGx1Z2lucyI+Ci0JCTxhY2Nlc3NydWxlcz4KLQkJCTxhY2Nlc3NydWxlIGtpbmQ9ImFjY2Vzc2libGUiIHBhdHRlcm49Im9yZy9lY2xpcHNlL2pwdC91aS8qKiIvPgotCQkJPGFjY2Vzc3J1bGUga2luZD0iYWNjZXNzaWJsZSIgcGF0dGVybj0ib3JnL2VjbGlwc2UvanB0L2NvcmUvKioiLz4KLQkJCTxhY2Nlc3NydWxlIGtpbmQ9ImFjY2Vzc2libGUiIHBhdHRlcm49Im9yZy9lY2xpcHNlL2pwdC91dGlsaXR5LyoqIi8+Ci0JCTwvYWNjZXNzcnVsZXM+Ci0JPC9jbGFzc3BhdGhlbnRyeT4KLQk8Y2xhc3NwYXRoZW50cnkga2luZD0ib3V0cHV0IiBwYXRoPSJiaW4iLz4KLTwvY2xhc3NwYXRoPgpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy8ucHJvamVjdCBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvLnByb2plY3QKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAyNDA3NzQuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy8ucHJvamVjdAorKysgL2Rldi9udWxsCkBAIC0xLDI4ICswLDAgQEAKLTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Ci08cHJvamVjdERlc2NyaXB0aW9uPgotCTxuYW1lPm9yZy5lY2xpcHNlLmpwdC51aS50ZXN0czwvbmFtZT4KLQk8Y29tbWVudD48L2NvbW1lbnQ+Ci0JPHByb2plY3RzPgotCTwvcHJvamVjdHM+Ci0JPGJ1aWxkU3BlYz4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLmpkdC5jb3JlLmphdmFidWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5NYW5pZmVzdEJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCQk8YnVpbGRDb21tYW5kPgotCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLlNjaGVtYUJ1aWxkZXI8L25hbWU+Ci0JCQk8YXJndW1lbnRzPgotCQkJPC9hcmd1bWVudHM+Ci0JCTwvYnVpbGRDb21tYW5kPgotCTwvYnVpbGRTcGVjPgotCTxuYXR1cmVzPgotCQk8bmF0dXJlPm9yZy5lY2xpcHNlLnBkZS5QbHVnaW5OYXR1cmU8L25hdHVyZT4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5qZHQuY29yZS5qYXZhbmF0dXJlPC9uYXR1cmU+Ci0JPC9uYXR1cmVzPgotPC9wcm9qZWN0RGVzY3JpcHRpb24+CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcyBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkMzY0YTBmLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvLnNldHRpbmdzL29yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLnByZWZzCisrKyAvZGV2L251bGwKQEAgLTEsMyArMCwwIEBACi0jTW9uIEFwciAwNyAxNDoyNzoxNiBFRFQgMjAwOAotZWNsaXBzZS5wcmVmZXJlbmNlcy52ZXJzaW9uPTEKLWVuY29kaW5nLzxwcm9qZWN0Pj1JU08tODg1OS0xCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL01FVEEtSU5GL01BTklGRVNULk1GIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9NRVRBLUlORi9NQU5JRkVTVC5NRgpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggM2Y1ZDVjYy4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL01FVEEtSU5GL01BTklGRVNULk1GCisrKyAvZGV2L251bGwKQEAgLTEsMjMgKzAsMCBAQAotTWFuaWZlc3QtVmVyc2lvbjogMS4wCi1CdW5kbGUtTWFuaWZlc3RWZXJzaW9uOiAyCi1CdW5kbGUtTmFtZTogJXBsdWdpbk5hbWUKLUJ1bmRsZS1WZW5kb3I6ICVwcm92aWRlck5hbWUKLUJ1bmRsZS1TeW1ib2xpY05hbWU6IG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0cwotQnVuZGxlLVZlcnNpb246IDEuMC4xCi1SZXF1aXJlLUJ1bmRsZTogCi0gb3JnLmp1bml0NDtidW5kbGUtdmVyc2lvbj0iNC4zLjEiLAotIG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLAotIG9yZy5lY2xpcHNlLmNvcmUucnVudGltZSwKLSBvcmcuZWNsaXBzZS5qZmFjZSwKLSBvcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cywKLSBvcmcuZWNsaXBzZS5qcHQuY29yZS50ZXN0cy5leHRlbnNpb24ucmVzb3VyY2UsCi0gb3JnLmVjbGlwc2UuanB0LnV0aWxpdHksCi0gb3JnLmVjbGlwc2UuanB0LmNvcmUsCi0gb3JnLmVjbGlwc2UuanB0LnVpLAotIG9yZy5lY2xpcHNlLnVpLndvcmtiZW5jaDtidW5kbGUtdmVyc2lvbj0iMy40LjAiLAotIG9yZy5lY2xpcHNlLnVpLmZvcm1zO2J1bmRsZS12ZXJzaW9uPSIzLjMuMTAwIgotRXhwb3J0LVBhY2thZ2U6IG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0czt4LWludGVybmFsOj10cnVlLAotIG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy5pbnRlcm5hbC5qZmFjZTt4LWludGVybmFsOj10cnVlLAotIG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy5pbnRlcm5hbC5wbGF0Zm9ybTt4LWludGVybmFsOj10cnVlLAotIG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy5pbnRlcm5hbC5zd3Q7eC1pbnRlcm5hbDo9dHJ1ZSwKLSBvcmcuZWNsaXBzZS5qcHQudWkudGVzdHMuaW50ZXJuYWwudXRpbDt4LWludGVybmFsOj10cnVlCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL2J1aWxkLnByb3BlcnRpZXMgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL2J1aWxkLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDM0ZDJlNGQuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9idWlsZC5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsNCArMCwwIEBACi1zb3VyY2UuLiA9IHNyYy8KLW91dHB1dC4uID0gYmluLwotYmluLmluY2x1ZGVzID0gTUVUQS1JTkYvLFwKLSAgICAgICAgICAgICAgIC4KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvcGx1Z2luLnByb3BlcnRpZXMgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3BsdWdpbi5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjYThhYjg3Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvcGx1Z2luLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwyMiArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jICBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzCi0jICBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mCi0jICB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMKLSMgIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAotIyAgCi0jICBDb250cmlidXRvcnM6IE9yYWNsZS4gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLSMgVG8gY29kZSBkZXZlbG9wZXI6Ci0jICAgRG8gTk9UIGNoYW5nZSB0aGUgcHJvcGVydGllcyBiZXR3ZWVuIHRoaXMgbGluZSBhbmQgdGhlCi0jICAgIiUlJSBFTkQgT0YgVFJBTlNMQVRFRCBQUk9QRVJUSUVTICUlJSIgbGluZS4KLSMgICBNYWtlIGEgbmV3IHByb3BlcnR5IG5hbWUsIGFwcGVuZCB0byB0aGUgZW5kIG9mIHRoZSBmaWxlIGFuZCBjaGFuZ2UKLSMgICB0aGUgY29kZSB0byB1c2UgdGhlIG5ldyBwcm9wZXJ0eS4KLSMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLQotIyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotIyAlJSUgRU5EIE9GIFRSQU5TTEFURUQgUFJPUEVSVElFUyAlJSUKLSMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLQotcGx1Z2luTmFtZT1KYXZhIFBlcnNpc3RlbmNlIEFQSSBVSSBUZXN0cwotcHJvdmlkZXJOYW1lPUVjbGlwc2Uub3JnCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvSnB0VWlUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL0pwdFVpVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzEwYWJiNy4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvSnB0VWlUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0czsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0OwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0U3VpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzLmludGVybmFsLnBsYXRmb3JtLkpwdFVpUGxhdGZvcm1UZXN0czsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkudGVzdHMuaW50ZXJuYWwuc3d0LkpwdFVpU1dUVGVzdHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzLmludGVybmFsLnV0aWwuSnB0VWlVdGlsVGVzdHM7Ci0KLS8qKgotICogUnVucyBhbGwgSlBUIFVJIFRlc3RzCi0gKi8KLXB1YmxpYyBjbGFzcyBKcHRVaVRlc3RzIHsKLQotCXB1YmxpYyBzdGF0aWMgVGVzdCBzdWl0ZSgpIHsKLQkJVGVzdFN1aXRlIHN1aXRlID0gbmV3IFRlc3RTdWl0ZShKcHRVaVRlc3RzLmNsYXNzLmdldFBhY2thZ2UoKS5nZXROYW1lKCkpOwotCQlzdWl0ZS5hZGRUZXN0KEpwdFVpUGxhdGZvcm1UZXN0cy5zdWl0ZSgpKTsKLQkJc3VpdGUuYWRkVGVzdChKcHRVaVNXVFRlc3RzLnN1aXRlKCkpOwotCQlzdWl0ZS5hZGRUZXN0KEpwdFVpVXRpbFRlc3RzLnN1aXRlKCkpOwotCQlyZXR1cm4gc3VpdGU7Ci0JfQotCi0JcHJpdmF0ZSBKcHRVaVRlc3RzKCkgewotCQlzdXBlcigpOwotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC9qZmFjZS9EZWxlZ2F0aW5nTGFiZWxQcm92aWRlclVpVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL2pmYWNlL0RlbGVnYXRpbmdMYWJlbFByb3ZpZGVyVWlUZXN0LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGMxZWY0MGUuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL2pmYWNlL0RlbGVnYXRpbmdMYWJlbFByb3ZpZGVyVWlUZXN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1OTkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCwgMjAwOSBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudWkudGVzdHMuaW50ZXJuYWwuamZhY2U7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS5hY3Rpb24uQWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLmFjdGlvbi5BY3Rpb25Db250cmlidXRpb25JdGVtOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLmFjdGlvbi5JQWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuQXJyYXlDb250ZW50UHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5CYXNlTGFiZWxQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLkNvbWJvVmlld2VyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuSUxhYmVsUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5JU2VsZWN0aW9uQ2hhbmdlZExpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuSVN0cnVjdHVyZWRTZWxlY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5TZWxlY3Rpb25DaGFuZ2VkRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5TdHJ1Y3R1cmVkU2VsZWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuVHJlZVZpZXdlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS53aW5kb3cuQXBwbGljYXRpb25XaW5kb3c7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uud2luZG93LldpbmRvdzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuamZhY2UuQWJzdHJhY3RJdGVtTGFiZWxQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuamZhY2UuQWJzdHJhY3RUcmVlSXRlbUNvbnRlbnRQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuamZhY2UuRGVsZWdhdGluZ1RyZWVDb250ZW50QW5kTGFiZWxQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuamZhY2UuRGVsZWdhdGluZ0NvbnRlbnRBbmRMYWJlbFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5qZmFjZS5JdGVtTGFiZWxQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuamZhY2UuSXRlbUxhYmVsUHJvdmlkZXJGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5qZmFjZS5UcmVlSXRlbUNvbnRlbnRQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuamZhY2UuVHJlZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuTnVsbENvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU3RhdGljQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU3RhdGljUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlByb3BlcnR5Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LlNXVDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuZXZlbnRzLlNlbGVjdGlvbkFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmV2ZW50cy5TZWxlY3Rpb25FdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuZ3JhcGhpY3MuSW1hZ2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLkltYWdlRGF0YTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuZ3JhcGhpY3MuUGFsZXR0ZURhdGE7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLlJHQjsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWREYXRhOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuR3JpZExheW91dDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5CdXR0b247Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbnRyb2w7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuRGlzcGxheTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5MYWJlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5TaGVsbDsKLQotcHVibGljIGNsYXNzIERlbGVnYXRpbmdMYWJlbFByb3ZpZGVyVWlUZXN0IGV4dGVuZHMgQXBwbGljYXRpb25XaW5kb3cKLXsKLQlwcml2YXRlIFRyZWVWaWV3ZXIgdHJlZTsKLQkKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFZlaGljbGU+IHNlbGVjdGVkVmVoaWNsZTsKLQkKLQkKLQlwdWJsaWMgc3RhdGljIHZvaWQgbWFpbihTdHJpbmdbXSBhcmdzKSB7Ci0JCVdpbmRvdyB3aW5kb3cgPSBuZXcgRGVsZWdhdGluZ0xhYmVsUHJvdmlkZXJVaVRlc3QoYXJncyk7Ci0JCXdpbmRvdy5zZXRCbG9ja09uT3Blbih0cnVlKTsKLQkJd2luZG93Lm9wZW4oKTsKLQkJRGlzcGxheS5nZXRDdXJyZW50KCkuZGlzcG9zZSgpOwotCQlTeXN0ZW0uZXhpdCgwKTsKLQl9Ci0JCi0JCi0JcHJpdmF0ZSBEZWxlZ2F0aW5nTGFiZWxQcm92aWRlclVpVGVzdChTdHJpbmdbXSBhcmdzKSB7Ci0JCXN1cGVyKG51bGwpOwotCQl0aGlzLnNlbGVjdGVkVmVoaWNsZSA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8VmVoaWNsZT4oKTsKLQl9Ci0JCi0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIENvbnRyb2wgY3JlYXRlQ29udGVudHMoQ29tcG9zaXRlIHBhcmVudCkgewotCQkoKFNoZWxsKSBwYXJlbnQpLnNldFRleHQoQ2xhc3NUb29scy5zaG9ydENsYXNzTmFtZUZvck9iamVjdCh0aGlzKSk7Ci0JCXBhcmVudC5zZXRTaXplKDQwMCwgNDAwKTsKLQkJcGFyZW50LnNldExheW91dChuZXcgR3JpZExheW91dCgpKTsKLQkJQ29tcG9zaXRlIG1haW5QYW5lbCA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTk9ORSk7Ci0JCW1haW5QYW5lbC5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5GSUxMX0JPVEgpKTsKLQkJbWFpblBhbmVsLnNldExheW91dChuZXcgR3JpZExheW91dCgpKTsKLQkJYnVpbGRUcmVlUGFuZWwobWFpblBhbmVsKTsKLQkJYnVpbGRDb250cm9sUGFuZWwobWFpblBhbmVsKTsKLQkJcmV0dXJuIG1haW5QYW5lbDsKLQl9Ci0JCi0JcHJpdmF0ZSB2b2lkIGJ1aWxkVHJlZVBhbmVsKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJQ29tcG9zaXRlIHBhbmVsID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OT05FKTsKLQkJcGFuZWwuc2V0TGF5b3V0RGF0YShuZXcgR3JpZERhdGEoR3JpZERhdGEuRklMTF9CT1RIKSk7Ci0JCXBhbmVsLnNldExheW91dChuZXcgR3JpZExheW91dCgpKTsKLQkJCi0JCUxhYmVsIGxhYmVsID0gbmV3IExhYmVsKHBhbmVsLCBTV1QuTk9ORSk7Ci0JCWxhYmVsLnNldExheW91dERhdGEobmV3IEdyaWREYXRhKEdyaWREYXRhLkJFR0lOTklORywgR3JpZERhdGEuQ0VOVEVSLCBmYWxzZSwgZmFsc2UpKTsKLQkJbGFiZWwuc2V0VGV4dCgiTXkgVmVoaWNsZXMiKTsKLQkJCi0JCXRyZWUgPSBuZXcgVHJlZVZpZXdlcihwYW5lbCwgU1dULlNJTkdMRSB8IFNXVC5IX1NDUk9MTCB8IFNXVC5WX1NDUk9MTCB8IFNXVC5CT1JERVIpOwotCQl0cmVlLmdldFRyZWUoKS5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5GSUxMLCBHcmlkRGF0YS5GSUxMLCB0cnVlLCB0cnVlKSk7Ci0JCURlbGVnYXRpbmdDb250ZW50QW5kTGFiZWxQcm92aWRlciBjb250ZW50QW5kTGFiZWxQcm92aWRlciA9IAotCQkJbmV3IERlbGVnYXRpbmdUcmVlQ29udGVudEFuZExhYmVsUHJvdmlkZXIoCi0JCQkJbmV3IFZlaGljbGVDb250ZW50UHJvdmlkZXJGYWN0b3J5KCksCi0JCQkJbmV3IFZlaGljbGVMYWJlbFByb3ZpZGVyRmFjdG9yeSgpKTsKLQkJdHJlZS5zZXRDb250ZW50UHJvdmlkZXIoY29udGVudEFuZExhYmVsUHJvdmlkZXIpOwotCQl0cmVlLnNldExhYmVsUHJvdmlkZXIoY29udGVudEFuZExhYmVsUHJvdmlkZXIpOwotCQl0cmVlLnNldElucHV0KG5ldyBSb290KCkpOwotCQl0cmVlLmFkZFNlbGVjdGlvbkNoYW5nZWRMaXN0ZW5lcihidWlsZFRyZWVTZWxlY3Rpb25DaGFuZ2VkTGlzdGVuZXIoKSk7Ci0JfQotCQotCXByaXZhdGUgSVNlbGVjdGlvbkNoYW5nZWRMaXN0ZW5lciBidWlsZFRyZWVTZWxlY3Rpb25DaGFuZ2VkTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgSVNlbGVjdGlvbkNoYW5nZWRMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHNlbGVjdGlvbkNoYW5nZWQoU2VsZWN0aW9uQ2hhbmdlZEV2ZW50IGV2ZW50KSB7Ci0JCQkJc2VsZWN0ZWRWZWhpY2xlLnNldFZhbHVlKChWZWhpY2xlKSAoKElTdHJ1Y3R1cmVkU2VsZWN0aW9uKSBldmVudC5nZXRTZWxlY3Rpb24oKSkuZ2V0Rmlyc3RFbGVtZW50KCkpOwotCQkJfQotCQl9OwotCX0KLQkKLQlwcml2YXRlIHZvaWQgYnVpbGRDb250cm9sUGFuZWwoQ29tcG9zaXRlIHBhcmVudCkgewotCQlDb21wb3NpdGUgcGFuZWwgPSBuZXcgQ29tcG9zaXRlKHBhcmVudCwgU1dULk5PTkUpOwotCQlwYW5lbC5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5GSUxMLCBHcmlkRGF0YS5DRU5URVIsIHRydWUsIGZhbHNlKSk7Ci0JCXBhbmVsLnNldExheW91dChuZXcgR3JpZExheW91dCgpKTsKLQkJYnVpbGRVcHBlckNvbnRyb2xQYW5lbChwYW5lbCk7Ci0JCWJ1aWxkTG93ZXJDb250cm9sUGFuZWwocGFuZWwpOwotCX0KLQkKLQlwcml2YXRlIHZvaWQgYnVpbGRVcHBlckNvbnRyb2xQYW5lbChDb21wb3NpdGUgcGFyZW50KSB7Ci0JCUNvbXBvc2l0ZSBwYW5lbCA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTk9ORSk7Ci0JCXBhbmVsLnNldExheW91dERhdGEobmV3IEdyaWREYXRhKEdyaWREYXRhLkZJTEwsIEdyaWREYXRhLkNFTlRFUiwgdHJ1ZSwgZmFsc2UpKTsKLQkJcGFuZWwuc2V0TGF5b3V0KG5ldyBHcmlkTGF5b3V0KDIsIHRydWUpKTsKLQkJYnVpbGRWZWhpY2xlQ29tYm8ocGFuZWwpOwotCQlidWlsZENvbG9yQ29tYm8ocGFuZWwpOwotCX0KLQkKLQlwcml2YXRlIHZvaWQgYnVpbGRWZWhpY2xlQ29tYm8oQ29tcG9zaXRlIHBhcmVudCkgewotCQlmaW5hbCBDb21ib1ZpZXdlciBjb21ibyA9IG5ldyBDb21ib1ZpZXdlcihwYXJlbnQsIFNXVC5SRUFEX09OTFkpOwotCQljb21iby5nZXRDb21ibygpLnNldExheW91dERhdGEobmV3IEdyaWREYXRhKEdyaWREYXRhLkZJTEwsIEdyaWREYXRhLkNFTlRFUiwgdHJ1ZSwgZmFsc2UpKTsKLQkJY29tYm8uc2V0Q29udGVudFByb3ZpZGVyKG5ldyBBcnJheUNvbnRlbnRQcm92aWRlcigpKTsKLQkJY29tYm8uc2V0TGFiZWxQcm92aWRlcihuZXcgVmVoaWNsZVR5cGVMYWJlbFByb3ZpZGVyKCkpOwotCQljb21iby5zZXRJbnB1dCgKLQkJCW5ldyBWZWhpY2xlVHlwZVtdIHsKLQkJCQlWZWhpY2xlVHlwZS5CSUNZQ0xFLCBWZWhpY2xlVHlwZS5DQVIsIAotCQkJCVZlaGljbGVUeXBlLlRSVUNLLCBWZWhpY2xlVHlwZS5CT0FUCi0JCQl9KTsKLQkJY29tYm8uZ2V0Q29tYm8oKS5zZXRFbmFibGVkKGZhbHNlKTsKLQkJY29tYm8uYWRkU2VsZWN0aW9uQ2hhbmdlZExpc3RlbmVyKAotCQkJbmV3IElTZWxlY3Rpb25DaGFuZ2VkTGlzdGVuZXIoKSB7Ci0JCQkJcHVibGljIHZvaWQgc2VsZWN0aW9uQ2hhbmdlZChTZWxlY3Rpb25DaGFuZ2VkRXZlbnQgZXZlbnQpIHsKLQkJCQkJc2VsZWN0ZWRWZWhpY2xlKCkuc2V0VmVoaWNsZVR5cGUoKFZlaGljbGVUeXBlKSAoKFN0cnVjdHVyZWRTZWxlY3Rpb24pIGV2ZW50LmdldFNlbGVjdGlvbigpKS5nZXRGaXJzdEVsZW1lbnQoKSk7IAotCQkJCX0KLQkJCX0pOwotCQlzZWxlY3RlZFZlaGljbGUuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigKLQkJCVByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgCi0JCQluZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCQlWZWhpY2xlIHZlaGljbGUgPSBzZWxlY3RlZFZlaGljbGUoKTsKLQkJCQkJY29tYm8uZ2V0Q29tYm8oKS5zZXRFbmFibGVkKHZlaGljbGUgIT0gbnVsbCk7Ci0JCQkJCWNvbWJvLnNldFNlbGVjdGlvbihuZXcgU3RydWN0dXJlZFNlbGVjdGlvbigodmVoaWNsZSA9PSBudWxsKSA/IG51bGwgOiB2ZWhpY2xlLnZlaGljbGVUeXBlKCkpKTsKLQkJCQl9Ci0JCQl9KTsKLQl9Ci0JCi0JcHJpdmF0ZSB2b2lkIGJ1aWxkQ29sb3JDb21ibyhDb21wb3NpdGUgcGFyZW50KSB7Ci0JCWZpbmFsIENvbWJvVmlld2VyIGNvbWJvID0gbmV3IENvbWJvVmlld2VyKHBhcmVudCwgU1dULlJFQURfT05MWSk7Ci0JCWNvbWJvLmdldENvbWJvKCkuc2V0TGF5b3V0RGF0YShuZXcgR3JpZERhdGEoR3JpZERhdGEuRklMTCwgR3JpZERhdGEuQ0VOVEVSLCB0cnVlLCBmYWxzZSkpOwotCQljb21iby5zZXRDb250ZW50UHJvdmlkZXIobmV3IEFycmF5Q29udGVudFByb3ZpZGVyKCkpOwotCQljb21iby5zZXRMYWJlbFByb3ZpZGVyKG5ldyBDb2xvckxhYmVsUHJvdmlkZXIoKSk7Ci0JCWNvbWJvLnNldElucHV0KG5ldyBDb2xvcltdIHtDb2xvci5SRUQsIENvbG9yLkJMVUUsIENvbG9yLllFTExPVywgQ29sb3IuR1JFRU59KTsKLQkJY29tYm8uYWRkU2VsZWN0aW9uQ2hhbmdlZExpc3RlbmVyKAotCQkJbmV3IElTZWxlY3Rpb25DaGFuZ2VkTGlzdGVuZXIoKSB7Ci0JCQkJcHVibGljIHZvaWQgc2VsZWN0aW9uQ2hhbmdlZChTZWxlY3Rpb25DaGFuZ2VkRXZlbnQgZXZlbnQpIHsKLQkJCQkJc2VsZWN0ZWRWZWhpY2xlKCkuc2V0Q29sb3IoKENvbG9yKSAoKFN0cnVjdHVyZWRTZWxlY3Rpb24pIGV2ZW50LmdldFNlbGVjdGlvbigpKS5nZXRGaXJzdEVsZW1lbnQoKSk7IAotCQkJCX0KLQkJCX0pOwotCQlzZWxlY3RlZFZlaGljbGUuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigKLQkJCVByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgCi0JCQluZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCQlWZWhpY2xlIHZlaGljbGUgPSBzZWxlY3RlZFZlaGljbGUoKTsKLQkJCQkJY29tYm8uZ2V0Q29tYm8oKS5zZXRFbmFibGVkKHZlaGljbGUgIT0gbnVsbCk7Ci0JCQkJCWNvbWJvLnNldFNlbGVjdGlvbihuZXcgU3RydWN0dXJlZFNlbGVjdGlvbigodmVoaWNsZSA9PSBudWxsKSA/IG51bGwgOiB2ZWhpY2xlLmNvbG9yKCkpKTsKLQkJCQl9Ci0JCQl9KTsKLQl9Ci0JCi0JcHJpdmF0ZSB2b2lkIGJ1aWxkTG93ZXJDb250cm9sUGFuZWwoQ29tcG9zaXRlIHBhcmVudCkgewotCQlDb21wb3NpdGUgcGFuZWwgPSBuZXcgQ29tcG9zaXRlKHBhcmVudCwgU1dULk5PTkUpOwotCQlwYW5lbC5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5GSUxMLCBHcmlkRGF0YS5DRU5URVIsIHRydWUsIGZhbHNlKSk7Ci0JCXBhbmVsLnNldExheW91dChuZXcgR3JpZExheW91dCgzLCBmYWxzZSkpOwotCQlidWlsZEVmZmVjdHNMYWJlbChwYW5lbCk7Ci0JCWJ1aWxkR3JleWVkQ2hlY2tCb3gocGFuZWwpOwotCQlidWlsZFRyYW5zbHVjZW50Q2hlY2tCb3gocGFuZWwpOwotCQlidWlsZEFjdGlvblBhbmVsKHBhbmVsKTsKLQl9Ci0JCi0JcHJpdmF0ZSB2b2lkIGJ1aWxkRWZmZWN0c0xhYmVsKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJTGFiZWwgbGFiZWwgPSBuZXcgTGFiZWwocGFyZW50LCBTV1QuTEVGVCk7Ci0JCWxhYmVsLnNldFRleHQoIkNvbG9yIGVmZmVjdHM6ICIpOwotCQlsYWJlbC5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5CRUdJTk5JTkcsIEdyaWREYXRhLkNFTlRFUiwgZmFsc2UsIGZhbHNlLCAzLCAxKSk7Ci0JfQotCQotCXByaXZhdGUgdm9pZCBidWlsZEdyZXllZENoZWNrQm94KENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJZmluYWwgQnV0dG9uIGJ1dHRvbiA9IG5ldyBCdXR0b24ocGFyZW50LCBTV1QuQ0hFQ0spOwotCQlidXR0b24uc2V0TGF5b3V0RGF0YShuZXcgR3JpZERhdGEoR3JpZERhdGEuQkVHSU5OSU5HLCBHcmlkRGF0YS5DRU5URVIsIGZhbHNlLCBmYWxzZSkpOwotCQlidXR0b24uc2V0VGV4dCgiZ3JleWVkIik7Ci0JCWJ1dHRvbi5zZXRFbmFibGVkKGZhbHNlKTsKLQkJYnV0dG9uLmFkZFNlbGVjdGlvbkxpc3RlbmVyKAotCQkJbmV3IFNlbGVjdGlvbkFkYXB0ZXIoKSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHVibGljIHZvaWQgd2lkZ2V0U2VsZWN0ZWQoU2VsZWN0aW9uRXZlbnQgZSkgewotCQkJCQlzZWxlY3RlZFZlaGljbGUoKS5zZXRHcmV5ZWQoYnV0dG9uLmdldFNlbGVjdGlvbigpKTsKLQkJCQl9Ci0JCQl9KTsKLQkJc2VsZWN0ZWRWZWhpY2xlLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoCi0JCQlQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIAotCQkJbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQkJVmVoaWNsZSB2ZWhpY2xlID0gc2VsZWN0ZWRWZWhpY2xlKCk7Ci0JCQkJCWJ1dHRvbi5zZXRFbmFibGVkKHZlaGljbGUgIT0gbnVsbCk7Ci0JCQkJCWJ1dHRvbi5zZXRTZWxlY3Rpb24odmVoaWNsZSAhPSBudWxsICYmIHZlaGljbGUuaXNHcmV5ZWQoKSk7Ci0JCQkJfQotCQkJfSk7Ci0JfQotCQotCXByaXZhdGUgdm9pZCBidWlsZFRyYW5zbHVjZW50Q2hlY2tCb3goQ29tcG9zaXRlIHBhcmVudCkgewotCQlmaW5hbCBCdXR0b24gYnV0dG9uID0gbmV3IEJ1dHRvbihwYXJlbnQsIFNXVC5DSEVDSyk7Ci0JCWJ1dHRvbi5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5CRUdJTk5JTkcsIEdyaWREYXRhLkNFTlRFUiwgdHJ1ZSwgZmFsc2UpKTsKLQkJYnV0dG9uLnNldFRleHQoInRyYW5zbHVjZW50Iik7Ci0JCWJ1dHRvbi5zZXRFbmFibGVkKGZhbHNlKTsKLQkJYnV0dG9uLmFkZFNlbGVjdGlvbkxpc3RlbmVyKAotCQkJbmV3IFNlbGVjdGlvbkFkYXB0ZXIoKSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHVibGljIHZvaWQgd2lkZ2V0U2VsZWN0ZWQoU2VsZWN0aW9uRXZlbnQgZSkgewotCQkJCQlzZWxlY3RlZFZlaGljbGUoKS5zZXRUcmFuc2x1Y2VudChidXR0b24uZ2V0U2VsZWN0aW9uKCkpOwotCQkJCX0KLQkJCX0pOwotCQlzZWxlY3RlZFZlaGljbGUuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigKLQkJCVByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgCi0JCQluZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCQlWZWhpY2xlIHZlaGljbGUgPSBzZWxlY3RlZFZlaGljbGUoKTsKLQkJCQkJYnV0dG9uLnNldEVuYWJsZWQodmVoaWNsZSAhPSBudWxsKTsKLQkJCQkJYnV0dG9uLnNldFNlbGVjdGlvbih2ZWhpY2xlICE9IG51bGwgJiYgdmVoaWNsZS5pc1RyYW5zbHVjZW50KCkpOwotCQkJCX0KLQkJCX0pOwotCX0KLQkKLQlwcml2YXRlIHZvaWQgYnVpbGRBY3Rpb25QYW5lbChDb21wb3NpdGUgcGFyZW50KSB7Ci0JCUNvbXBvc2l0ZSBwYW5lbCA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTk9ORSk7Ci0JCXBhbmVsLnNldExheW91dERhdGEobmV3IEdyaWREYXRhKEdyaWREYXRhLkVORCwgR3JpZERhdGEuRklMTCwgZmFsc2UsIGZhbHNlKSk7Ci0JCXBhbmVsLnNldExheW91dChuZXcgR3JpZExheW91dCgpKTsKLQkJYnVpbGRSZWZyZXNoVHJlZUFDSSgpLmZpbGwocGFuZWwpOwotCX0KLQkKLQlwcml2YXRlIEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0gYnVpbGRSZWZyZXNoVHJlZUFDSSgpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBY3Rpb24oIlJlZnJlc2ggdHJlZSIsIElBY3Rpb24uQVNfUFVTSF9CVVRUT04pIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJCXJlZnJlc2hUcmVlKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRUb29sVGlwVGV4dCgiUmVmcmVzaCB0aGUgdHJlZSdzIGxhYmVscyIpOwotCQlyZXR1cm4gbmV3IEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0oYWN0aW9uKTsKLQl9Ci0JCi0Jdm9pZCByZWZyZXNoVHJlZSgpIHsKLQkJdHJlZS5yZWZyZXNoKCk7Ci0JfQotCQotCXByaXZhdGUgVmVoaWNsZSBzZWxlY3RlZFZlaGljbGUoKSB7Ci0JCXJldHVybiBzZWxlY3RlZFZlaGljbGUuZ2V0VmFsdWUoKTsKLQl9Ci0JCi0JCi0JcHJpdmF0ZSBzdGF0aWMgY2xhc3MgVmVoaWNsZVR5cGVMYWJlbFByb3ZpZGVyIGV4dGVuZHMgQmFzZUxhYmVsUHJvdmlkZXIKLQkJaW1wbGVtZW50cyBJTGFiZWxQcm92aWRlcgotCXsKLQkJcHVibGljIEltYWdlIGdldEltYWdlKE9iamVjdCBlbGVtZW50KSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQkKLQkJcHVibGljIFN0cmluZyBnZXRUZXh0KE9iamVjdCBlbGVtZW50KSB7Ci0JCQlyZXR1cm4gKChWZWhpY2xlVHlwZSkgZWxlbWVudCkuZGVzY3JpcHRpb24oKTsKLQkJfQotCX0KLQkKLQkKLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBDb2xvckxhYmVsUHJvdmlkZXIgZXh0ZW5kcyBCYXNlTGFiZWxQcm92aWRlcgotCQlpbXBsZW1lbnRzIElMYWJlbFByb3ZpZGVyCi0JewotCQlwdWJsaWMgSW1hZ2UgZ2V0SW1hZ2UoT2JqZWN0IGVsZW1lbnQpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCQotCQlwdWJsaWMgU3RyaW5nIGdldFRleHQoT2JqZWN0IGVsZW1lbnQpIHsKLQkJCXJldHVybiAoKENvbG9yKSBlbGVtZW50KS5kZXNjcmlwdGlvbigpOwotCQl9Ci0JfQotCQotCQotCXByaXZhdGUgc3RhdGljIGNsYXNzIFZlaGljbGVDb250ZW50UHJvdmlkZXJGYWN0b3J5Ci0JCWltcGxlbWVudHMgVHJlZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5Ci0JewotCQlwdWJsaWMgVHJlZUl0ZW1Db250ZW50UHJvdmlkZXIgYnVpbGRJdGVtQ29udGVudFByb3ZpZGVyKE9iamVjdCBpdGVtLCBEZWxlZ2F0aW5nQ29udGVudEFuZExhYmVsUHJvdmlkZXIgY29udGVudEFuZExhYmVsUHJvdmlkZXIpIHsKLQkJCWlmIChpdGVtIGluc3RhbmNlb2YgUm9vdCkgewotCQkJCXJldHVybiBuZXcgUm9vdENvbnRlbnRQcm92aWRlcigKLQkJCQkJKFJvb3QpIGl0ZW0sIChEZWxlZ2F0aW5nVHJlZUNvbnRlbnRBbmRMYWJlbFByb3ZpZGVyKSBjb250ZW50QW5kTGFiZWxQcm92aWRlcik7Ci0JCQl9Ci0JCQlyZXR1cm4gbmV3IFZlaGljbGVDb250ZW50UHJvdmlkZXIoCi0JCQkJKFZlaGljbGUpIGl0ZW0sIChEZWxlZ2F0aW5nVHJlZUNvbnRlbnRBbmRMYWJlbFByb3ZpZGVyKSBjb250ZW50QW5kTGFiZWxQcm92aWRlcik7Ci0JCX0KLQl9Ci0JCi0JCi0JcHJpdmF0ZSBzdGF0aWMgY2xhc3MgUm9vdENvbnRlbnRQcm92aWRlciBleHRlbmRzIEFic3RyYWN0VHJlZUl0ZW1Db250ZW50UHJvdmlkZXI8VmVoaWNsZT4KLQl7Ci0JCXB1YmxpYyBSb290Q29udGVudFByb3ZpZGVyKFJvb3QgaXRlbSwgRGVsZWdhdGluZ1RyZWVDb250ZW50QW5kTGFiZWxQcm92aWRlciBjb250ZW50QW5kTGFiZWxQcm92aWRlcikgewotCQkJc3VwZXIoaXRlbSwgY29udGVudEFuZExhYmVsUHJvdmlkZXIpOwotCQl9Ci0JCQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFJvb3QgZ2V0TW9kZWwoKSB7Ci0JCQlyZXR1cm4gKFJvb3QpIHN1cGVyLmdldE1vZGVsKCk7Ci0JCX0KLQkJCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgT2JqZWN0IGdldFBhcmVudCgpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCQotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIENvbGxlY3Rpb25WYWx1ZU1vZGVsPFZlaGljbGU+IGJ1aWxkQ2hpbGRyZW5Nb2RlbCgpIHsKLQkJCXJldHVybiBuZXcgU3RhdGljQ29sbGVjdGlvblZhbHVlTW9kZWw8VmVoaWNsZT4odGhpcy5nZXRNb2RlbCgpLnZlaGljbGVzKCkpOwotCQl9Ci0JfQotCQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByaXZhdGUgc3RhdGljIGNsYXNzIFZlaGljbGVDb250ZW50UHJvdmlkZXIgZXh0ZW5kcyBBYnN0cmFjdFRyZWVJdGVtQ29udGVudFByb3ZpZGVyCi0JewotCQlwdWJsaWMgVmVoaWNsZUNvbnRlbnRQcm92aWRlcihWZWhpY2xlIGl0ZW0sIERlbGVnYXRpbmdUcmVlQ29udGVudEFuZExhYmVsUHJvdmlkZXIgY29udGVudEFuZExhYmVsUHJvdmlkZXIpIHsKLQkJCXN1cGVyKGl0ZW0sIGNvbnRlbnRBbmRMYWJlbFByb3ZpZGVyKTsKLQkJfQotCQkKLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBWZWhpY2xlIGdldE1vZGVsKCkgewotCQkJcmV0dXJuIChWZWhpY2xlKSBzdXBlci5nZXRNb2RlbCgpOwotCQl9Ci0JCQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIE9iamVjdCBnZXRQYXJlbnQoKSB7Ci0JCQlyZXR1cm4gZ2V0TW9kZWwoKS5wYXJlbnQoKTsKLQkJfQotCQkKLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCBDb2xsZWN0aW9uVmFsdWVNb2RlbCBidWlsZENoaWxkcmVuTW9kZWwoKSB7Ci0JCQlyZXR1cm4gbmV3IE51bGxDb2xsZWN0aW9uVmFsdWVNb2RlbCgpOwotCQl9Ci0JfQotCQotCQotCXByaXZhdGUgc3RhdGljIGNsYXNzIFZlaGljbGVMYWJlbFByb3ZpZGVyRmFjdG9yeQotCQlpbXBsZW1lbnRzIEl0ZW1MYWJlbFByb3ZpZGVyRmFjdG9yeQotCXsKLQkJcHVibGljIEl0ZW1MYWJlbFByb3ZpZGVyIGJ1aWxkSXRlbUxhYmVsUHJvdmlkZXIoT2JqZWN0IGVsZW1lbnQsIERlbGVnYXRpbmdDb250ZW50QW5kTGFiZWxQcm92aWRlciBsYWJlbFByb3ZpZGVyKSB7Ci0JCQlyZXR1cm4gbmV3IFZlaGljbGVMYWJlbFByb3ZpZGVyKChWZWhpY2xlKSBlbGVtZW50LCBsYWJlbFByb3ZpZGVyKTsKLQkJfQotCX0KLQkKLQkKLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBWZWhpY2xlTGFiZWxQcm92aWRlciBleHRlbmRzIEFic3RyYWN0SXRlbUxhYmVsUHJvdmlkZXIKLQl7Ci0JCXB1YmxpYyBWZWhpY2xlTGFiZWxQcm92aWRlcihWZWhpY2xlIHZlaGljbGUsIERlbGVnYXRpbmdDb250ZW50QW5kTGFiZWxQcm92aWRlciBsYWJlbFByb3ZpZGVyKSB7Ci0JCQlzdXBlcih2ZWhpY2xlLCBsYWJlbFByb3ZpZGVyKTsKLQkJfQotCQkKLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCBQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFRleHRNb2RlbCgpIHsKLQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFZlaGljbGUsIFN0cmluZz4oCi0JCQkJCW5ldyBTdGF0aWNQcm9wZXJ0eVZhbHVlTW9kZWw8VmVoaWNsZT4oKFZlaGljbGUpIG1vZGVsKCkpLCAKLQkJCQkJVmVoaWNsZS5WRUhJQ0xFX1RZUEVfUFJPUEVSVFksIFZlaGljbGUuQ09MT1JfUFJPUEVSVFkpIHsKLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCQlyZXR1cm4gc3ViamVjdC5jb2xvcigpLmRlc2NyaXB0aW9uKCkgKyAnICcgKyBzdWJqZWN0LnZlaGljbGVUeXBlKCkuZGVzY3JpcHRpb24oKTsKLQkJCQl9Ci0JCQl9OwotCQl9Ci0JCQotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIFByb3BlcnR5VmFsdWVNb2RlbDxJbWFnZT4gYnVpbGRJbWFnZU1vZGVsKCkgewotCQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VmVoaWNsZSwgSW1hZ2U+KAotCQkJCQluZXcgU3RhdGljUHJvcGVydHlWYWx1ZU1vZGVsPFZlaGljbGU+KChWZWhpY2xlKSBtb2RlbCgpKSwgCi0JCQkJCVZlaGljbGUuQ09MT1JfUFJPUEVSVFksIFZlaGljbGUuR1JFWUVEX1BST1BFUlRZLCBWZWhpY2xlLlRSQU5TTFVDRU5UX1BST1BFUlRZKSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIEltYWdlIGJ1aWxkVmFsdWVfKCkgewotCQkJCQlyZXR1cm4gc3ViamVjdC5pbWFnZSgpOwotCQkJCX0KLQkJCX07Ci0JCX0KLQl9Ci0JCi0JCi0JcHJpdmF0ZSBzdGF0aWMgYWJzdHJhY3QgY2xhc3MgVHJlZU5vZGUgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsCi0JewotCQlwcml2YXRlIFRyZWVOb2RlIHBhcmVudDsKLQkJCi0JCQotCQlwdWJsaWMgVHJlZU5vZGUoVHJlZU5vZGUgcGFyZW50KSB7Ci0JCQl0aGlzLnBhcmVudCA9IHBhcmVudDsKLQkJfQotCQkKLQkJCi0JCXB1YmxpYyBUcmVlTm9kZSBwYXJlbnQoKSB7Ci0JCQlyZXR1cm4gcGFyZW50OwotCQl9Ci0JfQotCQotCQotCXByaXZhdGUgc3RhdGljIGNsYXNzIFJvb3QgZXh0ZW5kcyBUcmVlTm9kZQotCXsKLQkJcHJvdGVjdGVkIGZpbmFsIFZlaGljbGVbXSB2ZWhpY2xlczsKLQkJCi0JCQotCQlwdWJsaWMgUm9vdCgpIHsKLQkJCXN1cGVyKG51bGwpOwotCQkJdmVoaWNsZXMgPSBuZXcgVmVoaWNsZVtdIHsKLQkJCQluZXcgVmVoaWNsZSh0aGlzLCBWZWhpY2xlVHlwZS5CSUNZQ0xFLCBDb2xvci5CTFVFKSwKLQkJCQluZXcgVmVoaWNsZSh0aGlzLCBWZWhpY2xlVHlwZS5DQVIsIENvbG9yLllFTExPVyksCi0JCQkJbmV3IFZlaGljbGUodGhpcywgVmVoaWNsZVR5cGUuVFJVQ0ssIENvbG9yLlJFRCksCi0JCQkJbmV3IFZlaGljbGUodGhpcywgVmVoaWNsZVR5cGUuQk9BVCwgQ29sb3IuR1JFRU4pfTsKLQkJfQotCQkKLQkJcHVibGljIFZlaGljbGVbXSB2ZWhpY2xlcygpIHsKLQkJCXJldHVybiB2ZWhpY2xlczsKLQkJfQotCX0KLQkKLQkKLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBWZWhpY2xlIGV4dGVuZHMgVHJlZU5vZGUKLQl7Ci0JCXByaXZhdGUgVmVoaWNsZVR5cGUgdmVoaWNsZVR5cGU7Ci0JCXB1YmxpYyBmaW5hbCBzdGF0aWMgU3RyaW5nIFZFSElDTEVfVFlQRV9QUk9QRVJUWSA9ICJ2ZWhpY2xlVHlwZSI7Ci0JCQotCQlwcml2YXRlIENvbG9yIGNvbG9yOwotCQlwdWJsaWMgZmluYWwgc3RhdGljIFN0cmluZyBDT0xPUl9QUk9QRVJUWSA9ICJjb2xvciI7Ci0JCQotCQlwcml2YXRlIGJvb2xlYW4gZ3JleWVkID0gZmFsc2U7Ci0JCXB1YmxpYyBmaW5hbCBzdGF0aWMgU3RyaW5nIEdSRVlFRF9QUk9QRVJUWSA9ICJncmV5ZWQiOwotCQkKLQkJcHJpdmF0ZSBib29sZWFuIHRyYW5zbHVjZW50ID0gZmFsc2U7Ci0JCXB1YmxpYyBmaW5hbCBzdGF0aWMgU3RyaW5nIFRSQU5TTFVDRU5UX1BST1BFUlRZID0gInRyYW5zbHVjZW50IjsKLQkJCi0JCXByaXZhdGUgSW1hZ2UgaW1hZ2U7Ci0JCQotCQkJCi0JCXB1YmxpYyBWZWhpY2xlKFRyZWVOb2RlIHBhcmVudCwgVmVoaWNsZVR5cGUgdmVoaWNsZVR5cGUsIENvbG9yIGNvbG9yKSB7Ci0JCQlzdXBlcihwYXJlbnQpOwotCQkJdGhpcy52ZWhpY2xlVHlwZSA9IHZlaGljbGVUeXBlOwotCQkJdGhpcy5jb2xvciA9IGNvbG9yOwotCQl9Ci0JCQotCQlwdWJsaWMgVmVoaWNsZVR5cGUgdmVoaWNsZVR5cGUoKSB7Ci0JCQlyZXR1cm4gdmVoaWNsZVR5cGU7Ci0JCX0KLQkJCi0JCXB1YmxpYyB2b2lkIHNldFZlaGljbGVUeXBlKFZlaGljbGVUeXBlIG5ld1ZlaGljbGVUeXBlKSB7Ci0JCQlWZWhpY2xlVHlwZSBvbGRWZWhpY2xlVHlwZSA9IHZlaGljbGVUeXBlOwotCQkJdmVoaWNsZVR5cGUgPSBuZXdWZWhpY2xlVHlwZTsKLQkJCWZpcmVQcm9wZXJ0eUNoYW5nZWQoVkVISUNMRV9UWVBFX1BST1BFUlRZLCBvbGRWZWhpY2xlVHlwZSwgbmV3VmVoaWNsZVR5cGUpOwotCQl9Ci0JCQotCQlwdWJsaWMgQ29sb3IgY29sb3IoKSB7Ci0JCQlyZXR1cm4gY29sb3I7Ci0JCX0KLQkJCi0JCXB1YmxpYyB2b2lkIHNldENvbG9yKENvbG9yIG5ld0NvbG9yKSB7Ci0JCQlDb2xvciBvbGRDb2xvciA9IGNvbG9yOwotCQkJY29sb3IgPSBuZXdDb2xvcjsKLQkJCWZpcmVQcm9wZXJ0eUNoYW5nZWQoQ09MT1JfUFJPUEVSVFksIG9sZENvbG9yLCBuZXdDb2xvcik7Ci0JCX0KLQkJCi0JCXB1YmxpYyBib29sZWFuIGlzR3JleWVkKCkgewotCQkJcmV0dXJuIGdyZXllZDsKLQkJfQotCQkKLQkJcHVibGljIHZvaWQgc2V0R3JleWVkKGJvb2xlYW4gbmV3R3JleWVkKSB7Ci0JCQlib29sZWFuIG9sZEdyZXllZCA9IGdyZXllZDsKLQkJCWdyZXllZCA9IG5ld0dyZXllZDsKLQkJCWZpcmVQcm9wZXJ0eUNoYW5nZWQoR1JFWUVEX1BST1BFUlRZLCBvbGRHcmV5ZWQsIG5ld0dyZXllZCk7Ci0JCX0KLQkJCi0JCXB1YmxpYyBib29sZWFuIGlzVHJhbnNsdWNlbnQoKSB7Ci0JCQlyZXR1cm4gdHJhbnNsdWNlbnQ7Ci0JCX0KLQkJCi0JCXB1YmxpYyB2b2lkIHNldFRyYW5zbHVjZW50KGJvb2xlYW4gbmV3VHJhbnNsdWNlbnQpIHsKLQkJCWJvb2xlYW4gb2xkVHJhbnNsdWNlbnQgPSB0cmFuc2x1Y2VudDsKLQkJCXRyYW5zbHVjZW50ID0gbmV3VHJhbnNsdWNlbnQ7Ci0JCQlmaXJlUHJvcGVydHlDaGFuZ2VkKFRSQU5TTFVDRU5UX1BST1BFUlRZLCBvbGRUcmFuc2x1Y2VudCwgbmV3VHJhbnNsdWNlbnQpOwotCQl9Ci0JCQotCQlwdWJsaWMgSW1hZ2UgaW1hZ2UoKSB7Ci0JCQlpZiAoaW1hZ2UgIT0gbnVsbCkgewotCQkJCWltYWdlLmRpc3Bvc2UoKTsKLQkJCX0KLQkJCQotCQkJcmV0dXJuIEltYWdlRmFjdG9yeS5pbWFnZShjb2xvcigpLCBncmV5ZWQsIHRyYW5zbHVjZW50KTsKLQkJfQotCX0KLQkKLQkKLQlwcml2YXRlIHN0YXRpYyBlbnVtIFZlaGljbGVUeXBlCi0JewotCQlCSUNZQ0xFKCJiaWN5Y2xlIiksCi0JCUNBUigiY2FyIiksCi0JCVRSVUNLKCJ0cnVjayIpLAotCQlCT0FUKCJib2F0Iik7Ci0JCQotCQlwcml2YXRlIGZpbmFsIFN0cmluZyBkZXNjcmlwdGlvbjsKLQkJCi0JCXByaXZhdGUgVmVoaWNsZVR5cGUoU3RyaW5nIGRlc2NyaXB0aW9uKSB7Ci0JCQl0aGlzLmRlc2NyaXB0aW9uID0gZGVzY3JpcHRpb247Ci0JCX0KLQkJCi0JCXB1YmxpYyBTdHJpbmcgZGVzY3JpcHRpb24oKSB7Ci0JCQlyZXR1cm4gZGVzY3JpcHRpb247Ci0JCX0KLQkJCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuIGRlc2NyaXB0aW9uKCk7Ci0JCX0KLQl9Ci0JCi0JCi0JcHJpdmF0ZSBzdGF0aWMgZW51bSBDb2xvcgotCXsKLQkJUkVEKCJyZWQiLCBuZXcgUkdCKDI1NSwgMCwgMCkpLAotCQlCTFVFKCJibHVlIiwgbmV3IFJHQigwLCAwLCAyNTUpKSwKLQkJWUVMTE9XKCJ5ZWxsb3ciLCBuZXcgUkdCKDI1NSwgMjU1LCAwKSksCi0JCUdSRUVOKCJncmVlbiIsIG5ldyBSR0IoMCwgMjU1LCAwKSk7Ci0JCQotCQlwcml2YXRlIGZpbmFsIFN0cmluZyBkZXNjcmlwdGlvbjsKLQkJCi0JCXByaXZhdGUgZmluYWwgUkdCIHJnYjsKLQkJCi0JCXByaXZhdGUgQ29sb3IoU3RyaW5nIGRlc2NyaXB0aW9uLCBSR0IgcmdiKSB7Ci0JCQl0aGlzLmRlc2NyaXB0aW9uID0gZGVzY3JpcHRpb247Ci0JCQl0aGlzLnJnYiA9IHJnYjsKLQkJfQotCQkKLQkJcHVibGljIFN0cmluZyBkZXNjcmlwdGlvbigpIHsKLQkJCXJldHVybiBkZXNjcmlwdGlvbjsKLQkJfQotCQkKLQkJcHVibGljIFJHQiByZ2IoKSB7Ci0JCQlyZXR1cm4gcmdiOwotCQl9Ci0JCQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiBkZXNjcmlwdGlvbigpOwotCQl9Ci0JfQotCQotCQotCXByaXZhdGUgc3RhdGljIGNsYXNzIEltYWdlRmFjdG9yeQotCXsKLQkJcHJpdmF0ZSBzdGF0aWMgUkdCIHJnYihDb2xvciBjb2xvciwgYm9vbGVhbiBncmV5ZWQsIGJvb2xlYW4gdHJhbnNsdWNlbnQpIHsKLQkJCVJHQiByZ2IgPSAoZ3JleWVkKSA/IG5ldyBSR0IoMTI3LCAxMjcsIDEyNykgOiBjb2xvci5yZ2IoKTsKLQkJCWlmICh0cmFuc2x1Y2VudCkgewotCQkJCXJnYiA9IG5ldyBSR0IodHJhbnNsdWNpZnkocmdiLnJlZCksIHRyYW5zbHVjaWZ5KHJnYi5ncmVlbiksIHRyYW5zbHVjaWZ5KHJnYi5ibHVlKSk7Ci0JCQl9Ci0JCQlyZXR1cm4gcmdiOwotCQl9Ci0JCQotCQlwcml2YXRlIHN0YXRpYyBpbnQgdHJhbnNsdWNpZnkoaW50IGNvbG9yKSB7Ci0JCQlyZXR1cm4gMjU1IC0gKGludCkgKCgyNTUgLSBjb2xvcikgKiAwLjMpOwotCQl9Ci0JCQotCQlwdWJsaWMgc3RhdGljIEltYWdlIGltYWdlKENvbG9yIGNvbG9yLCBib29sZWFuIGdyZXllZCwgYm9vbGVhbiB0cmFuc2x1Y2VudCkgewotCQkJUGFsZXR0ZURhdGEgcGQgPSBuZXcgUGFsZXR0ZURhdGEobmV3IFJHQltdIHtyZ2IoY29sb3IsIGdyZXllZCwgdHJhbnNsdWNlbnQpfSk7Ci0JCQlJbWFnZURhdGEgaWQgPSBuZXcgSW1hZ2VEYXRhKDIwLCAyMCwgMSwgcGQpOwotCQkJZm9yIChpbnQgeCA9IDA7IHggPCAyMDsgeCArKykgewotCQkJCWZvciAoaW50IHkgPSAwOyB5IDwgMjA7IHkgKyspIHsKLQkJCQkJaWQuc2V0UGl4ZWwoeCwgeSwgMCk7Ci0JCQkJfQotCQkJfQotCQkJcmV0dXJuIG5ldyBJbWFnZShEaXNwbGF5LmdldEN1cnJlbnQoKSwgaWQpOwotCQl9Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL2pmYWNlL0RlbGVnYXRpbmdUcmVlQ29udGVudFByb3ZpZGVyVWlUZXN0LmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvamZhY2UvRGVsZWdhdGluZ1RyZWVDb250ZW50UHJvdmlkZXJVaVRlc3QuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMTlhYzY3MS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvamZhY2UvRGVsZWdhdGluZ1RyZWVDb250ZW50UHJvdmlkZXJVaVRlc3QuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU2NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy5pbnRlcm5hbC5qZmFjZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2UuYWN0aW9uLkFjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS5hY3Rpb24uQWN0aW9uQ29udHJpYnV0aW9uSXRlbTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS5hY3Rpb24uSUFjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLkJhc2VMYWJlbFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuSUxhYmVsUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5JU2VsZWN0aW9uQ2hhbmdlZExpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuSVN0cnVjdHVyZWRTZWxlY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5JVHJlZUNvbnRlbnRQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLlNlbGVjdGlvbkNoYW5nZWRFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLlN0cnVjdHVyZWRTZWxlY3Rpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5UcmVlVmlld2VyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLndpbmRvdy5BcHBsaWNhdGlvbldpbmRvdzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS53aW5kb3cuV2luZG93OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5qZmFjZS5BYnN0cmFjdFRyZWVJdGVtQ29udGVudFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5qZmFjZS5EZWxlZ2F0aW5nVHJlZUNvbnRlbnRBbmRMYWJlbFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5qZmFjZS5EZWxlZ2F0aW5nQ29udGVudEFuZExhYmVsUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmpmYWNlLlRyZWVJdGVtQ29udGVudFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5qZmFjZS5UcmVlSXRlbUNvbnRlbnRQcm92aWRlckZhY3Rvcnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkZpbHRlcmluZ0l0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5SZWFkT25seUxpc3RJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuVHJhbnNmb3JtYXRpb25JdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkNvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkxpc3RBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkxpc3RDb2xsZWN0aW9uVmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlN0YXRpY0NvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlByb3BlcnR5Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LlNXVDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuZ3JhcGhpY3MuSW1hZ2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkRGF0YTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWRMYXlvdXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbnRyb2w7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuRGlzcGxheTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5MYWJlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5TaGVsbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5UZXh0OwotCi1wdWJsaWMgY2xhc3MgRGVsZWdhdGluZ1RyZWVDb250ZW50UHJvdmlkZXJVaVRlc3QgZXh0ZW5kcyBBcHBsaWNhdGlvbldpbmRvdwotewotCXByaXZhdGUgZmluYWwgUm9vdCByb290OwotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUcmVlTm9kZT4gc2VsZWN0ZWROb2RlOwotCi0JcHJpdmF0ZSBUcmVlVmlld2VyIGNvbnRyb2xUcmVlOwotCi0JcHJpdmF0ZSBUcmVlVmlld2VyIHZpZXdUcmVlOwotCi0JcHJpdmF0ZSBUZXh0IG5vZGVOYW1lVGV4dDsKLQotCi0JcHVibGljIHN0YXRpYyB2b2lkIG1haW4oU3RyaW5nW10gYXJncykgewotCQlXaW5kb3cgd2luZG93ID0gbmV3IERlbGVnYXRpbmdUcmVlQ29udGVudFByb3ZpZGVyVWlUZXN0KGFyZ3MpOwotCQl3aW5kb3cuc2V0QmxvY2tPbk9wZW4odHJ1ZSk7Ci0JCXdpbmRvdy5vcGVuKCk7Ci0JCURpc3BsYXkuZ2V0Q3VycmVudCgpLmRpc3Bvc2UoKTsKLQkJU3lzdGVtLmV4aXQoMCk7Ci0JfQotCi0JcHJpdmF0ZSBEZWxlZ2F0aW5nVHJlZUNvbnRlbnRQcm92aWRlclVpVGVzdChTdHJpbmdbXSBhcmdzKSB7Ci0JCXN1cGVyKG51bGwpOwotCQl0aGlzLnJvb3QgPSBuZXcgUm9vdCgpOwotCQl0aGlzLnJvb3QuYWRkQ2hpbGQoIlBhcmVudF8xIik7Ci0JCXRoaXMuc2VsZWN0ZWROb2RlID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxUcmVlTm9kZT4odGhpcy5yb290KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgQ29udHJvbCBjcmVhdGVDb250ZW50cyhDb21wb3NpdGUgcGFyZW50KSB7Ci0JCSgoU2hlbGwpIHBhcmVudCkuc2V0VGV4dChDbGFzc1Rvb2xzLnNob3J0Q2xhc3NOYW1lRm9yT2JqZWN0KHRoaXMpKTsKLQkJcGFyZW50LnNldFNpemUoODAwLCA0MDApOwotCQlwYXJlbnQuc2V0TGF5b3V0KG5ldyBHcmlkTGF5b3V0KCkpOwotCQlDb21wb3NpdGUgbWFpblBhbmVsID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OT05FKTsKLQkJbWFpblBhbmVsLnNldExheW91dERhdGEobmV3IEdyaWREYXRhKEdyaWREYXRhLkZJTExfQk9USCkpOwotCQltYWluUGFuZWwuc2V0TGF5b3V0KG5ldyBHcmlkTGF5b3V0KCkpOwotCQlidWlsZFRyZWVQYW5lbChtYWluUGFuZWwpOwotCQlidWlsZENvbnRyb2xQYW5lbChtYWluUGFuZWwpOwotCQlyZXR1cm4gbWFpblBhbmVsOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZFRyZWVQYW5lbChDb21wb3NpdGUgcGFyZW50KSB7Ci0JCUNvbXBvc2l0ZSBwYW5lbCA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTk9ORSk7Ci0JCXBhbmVsLnNldExheW91dERhdGEobmV3IEdyaWREYXRhKEdyaWREYXRhLkZJTExfQk9USCkpOwotCQlwYW5lbC5zZXRMYXlvdXQobmV3IEdyaWRMYXlvdXQoMiwgdHJ1ZSkpOwotCQlidWlsZENvbnRyb2xUcmVlUGFuZWwocGFuZWwpOwotCQlidWlsZFZpZXdUcmVlUGFuZWwocGFuZWwpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZENvbnRyb2xUcmVlUGFuZWwoQ29tcG9zaXRlIHBhcmVudCkgewotCQljb250cm9sVHJlZSA9IGJ1aWxkVHJlZVBhbmVsKAotCQkJCXBhcmVudCwgIkNvbnRyb2wgdHJlZSIsCi0JCQkJbmV3IERlbGVnYXRpbmdUcmVlQ29udGVudEFuZExhYmVsUHJvdmlkZXIobmV3IENvbnRyb2xUcmVlSXRlbUNvbnRlbnRQcm92aWRlckZhY3RvcnkoKSksCi0JCQkJbmV3IExhYmVsUHJvdmlkZXIoKSk7Ci0JCWNvbnRyb2xUcmVlLmFkZFNlbGVjdGlvbkNoYW5nZWRMaXN0ZW5lcihidWlsZFRyZWVTZWxlY3Rpb25DaGFuZ2VkTGlzdGVuZXIoKSk7Ci0JCXNlbGVjdGVkTm9kZS5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKAotCQkJCVByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwKLQkJCQluZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQkJCWNvbnRyb2xUcmVlLnNldFNlbGVjdGlvbihuZXcgU3RydWN0dXJlZFNlbGVjdGlvbihldmVudC5nZXROZXdWYWx1ZSgpKSk7Ci0JCQkJCX0KLQkJCQl9Ci0JCQkpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZFZpZXdUcmVlUGFuZWwoQ29tcG9zaXRlIHBhcmVudCkgewotCQl2aWV3VHJlZSA9IGJ1aWxkVHJlZVBhbmVsKAotCQkJCXBhcmVudCwgIlZpZXcgdHJlZSIsCi0JCQkJbmV3IERlbGVnYXRpbmdUcmVlQ29udGVudEFuZExhYmVsUHJvdmlkZXIobmV3IFZpZXdUcmVlSXRlbUNvbnRlbnRQcm92aWRlckZhY3RvcnkoKSksCi0JCQkJbmV3IExhYmVsUHJvdmlkZXIoKSk7Ci0JfQotCi0JcHJpdmF0ZSBUcmVlVmlld2VyIGJ1aWxkVHJlZVBhbmVsKENvbXBvc2l0ZSBwYXJlbnQsIFN0cmluZyBsYWJlbFRleHQsIElUcmVlQ29udGVudFByb3ZpZGVyIGNvbnRlbnRQcm92aWRlciwgSUxhYmVsUHJvdmlkZXIgbGFiZWxQcm92aWRlcikgewotCQlDb21wb3NpdGUgcGFuZWwgPSBuZXcgQ29tcG9zaXRlKHBhcmVudCwgU1dULk5PTkUpOwotCQlwYW5lbC5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5GSUxMX0JPVEgpKTsKLQkJcGFuZWwuc2V0TGF5b3V0KG5ldyBHcmlkTGF5b3V0KCkpOwotCi0JCUxhYmVsIGxhYmVsID0gbmV3IExhYmVsKHBhbmVsLCBTV1QuTEVGVCk7Ci0JCWxhYmVsLnNldExheW91dERhdGEobmV3IEdyaWREYXRhKEdyaWREYXRhLkJFR0lOTklORywgR3JpZERhdGEuQ0VOVEVSLCBmYWxzZSwgZmFsc2UpKTsKLQkJbGFiZWwuc2V0VGV4dChsYWJlbFRleHQpOwotCi0JCWZpbmFsIFRyZWVWaWV3ZXIgdHJlZSA9IG5ldyBUcmVlVmlld2VyKHBhbmVsLCBTV1QuU0lOR0xFIHwgU1dULkhfU0NST0xMIHwgU1dULlZfU0NST0xMIHwgU1dULkJPUkRFUik7Ci0JCXRyZWUuZ2V0VHJlZSgpLnNldExheW91dERhdGEobmV3IEdyaWREYXRhKEdyaWREYXRhLkZJTEwsIEdyaWREYXRhLkZJTEwsIHRydWUsIHRydWUpKTsKLQkJdHJlZS5zZXRDb250ZW50UHJvdmlkZXIoY29udGVudFByb3ZpZGVyKTsKLQkJdHJlZS5zZXRMYWJlbFByb3ZpZGVyKGxhYmVsUHJvdmlkZXIpOwotCQl0cmVlLnNldElucHV0KHJvb3QpOwotCi0JCXJldHVybiB0cmVlOwotCX0KLQotCXByaXZhdGUgSVNlbGVjdGlvbkNoYW5nZWRMaXN0ZW5lciBidWlsZFRyZWVTZWxlY3Rpb25DaGFuZ2VkTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgSVNlbGVjdGlvbkNoYW5nZWRMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHNlbGVjdGlvbkNoYW5nZWQoU2VsZWN0aW9uQ2hhbmdlZEV2ZW50IGV2ZW50KSB7Ci0JCQkJVHJlZU5vZGUgc2VsZWN0aW9uID0gKFRyZWVOb2RlKSAoKElTdHJ1Y3R1cmVkU2VsZWN0aW9uKSBldmVudC5nZXRTZWxlY3Rpb24oKSkuZ2V0Rmlyc3RFbGVtZW50KCk7Ci0JCQkJc2VsZWN0ZWROb2RlLnNldFZhbHVlKChzZWxlY3Rpb24gPT0gbnVsbCkgPyByb290IDogc2VsZWN0aW9uKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRDb250cm9sUGFuZWwoQ29tcG9zaXRlIHBhcmVudCkgewotCQlDb21wb3NpdGUgcGFuZWwgPSBuZXcgQ29tcG9zaXRlKHBhcmVudCwgU1dULk5PTkUpOwotCQlwYW5lbC5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5GSUxMLCBHcmlkRGF0YS5GSUxMLCB0cnVlLCBmYWxzZSkpOwotCQlwYW5lbC5zZXRMYXlvdXQobmV3IEdyaWRMYXlvdXQoNiwgZmFsc2UpKTsKLQkJYnVpbGROb2RlTmFtZVRleHQocGFuZWwpOwotCQlidWlsZEFkZENoaWxkQUNJKCkuZmlsbChwYW5lbCk7Ci0JCWJ1aWxkQWRkTmVzdGVkQ2hpbGRBQ0koKS5maWxsKHBhbmVsKTsKLQkJYnVpbGRSZW1vdmVBQ0koKS5maWxsKHBhbmVsKTsKLQkJYnVpbGRDbGVhck1vZGVsQUNJKCkuZmlsbChwYW5lbCk7Ci0JCWJ1aWxkUmVzdG9yZU1vZGVsQUNJKCkuZmlsbChwYW5lbCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGJ1aWxkTm9kZU5hbWVUZXh0KENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJbm9kZU5hbWVUZXh0ID0gbmV3IFRleHQocGFyZW50LCBTV1QuU0lOR0xFIHwgU1dULkJPUkRFUik7Ci0JCW5vZGVOYW1lVGV4dC5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5GSUxMLCBHcmlkRGF0YS5DRU5URVIsIHRydWUsIGZhbHNlKSk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb25Db250cmlidXRpb25JdGVtIGJ1aWxkQWRkQ2hpbGRBQ0koKSB7Ci0JCWZpbmFsIEFjdGlvbiBhY3Rpb24gPSBuZXcgQWN0aW9uKCJBZGQgY2hpbGQiLCBJQWN0aW9uLkFTX1BVU0hfQlVUVE9OKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlhZGRDaGlsZCgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0VG9vbFRpcFRleHQoIkFkZCBhIGNoaWxkIHdpdGggdGhlIGdpdmVuIG5hbWUiKTsKLQkJc2VsZWN0ZWROb2RlLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoCi0JCQkJUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLAotCQkJCW5ldyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCkgewotCQkJCQkJYWN0aW9uLnNldEVuYWJsZWQoKChUcmVlTm9kZSkgZXZlbnQuZ2V0TmV3VmFsdWUoKSkuY2FuSGF2ZUNoaWxkcmVuKCkpOwotCQkJCQl9Ci0JCQkJfQotCQkJKTsKLQkJcmV0dXJuIG5ldyBBY3Rpb25Db250cmlidXRpb25JdGVtKGFjdGlvbik7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb25Db250cmlidXRpb25JdGVtIGJ1aWxkQWRkTmVzdGVkQ2hpbGRBQ0koKSB7Ci0JCWZpbmFsIEFjdGlvbiBhY3Rpb24gPSBuZXcgQWN0aW9uKCJBZGQgbmVzdGVkIGNoaWxkIiwgSUFjdGlvbi5BU19QVVNIX0JVVFRPTikgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBydW4oKSB7Ci0JCQkJYWRkTmVzdGVkQ2hpbGQoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldFRvb2xUaXBUZXh0KCJBZGQgYSBuZXN0ZWQgY2hpbGQgd2l0aCB0aGUgZ2l2ZW4gbmFtZSIpOwotCQlhY3Rpb24uc2V0RW5hYmxlZChmYWxzZSk7Ci0JCXNlbGVjdGVkTm9kZS5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKAotCQkJCVByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwKLQkJCQluZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQkJCWFjdGlvbi5zZXRFbmFibGVkKCgoVHJlZU5vZGUpIGV2ZW50LmdldE5ld1ZhbHVlKCkpLmNhbkhhdmVOZXN0ZWRDaGlsZHJlbigpKTsKLQkJCQkJfQotCQkJCX0KLQkJCSk7Ci0JCXJldHVybiBuZXcgQWN0aW9uQ29udHJpYnV0aW9uSXRlbShhY3Rpb24pOwotCX0KLQotCXByaXZhdGUgQWN0aW9uQ29udHJpYnV0aW9uSXRlbSBidWlsZFJlbW92ZUFDSSgpIHsKLQkJZmluYWwgQWN0aW9uIGFjdGlvbiA9IG5ldyBBY3Rpb24oIlJlbW92ZSIsIElBY3Rpb24uQVNfUFVTSF9CVVRUT04pIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJCXJlbW92ZSgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0VG9vbFRpcFRleHQoIlJlbW92ZSB0aGUgc2VsZWN0ZWQgbm9kZSIpOwotCQlhY3Rpb24uc2V0RW5hYmxlZChmYWxzZSk7Ci0JCXNlbGVjdGVkTm9kZS5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKAotCQkJCVByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwKLQkJCQluZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCQkJCWFjdGlvbi5zZXRFbmFibGVkKGV2ZW50LmdldE5ld1ZhbHVlKCkgIT0gcm9vdCk7Ci0JCQkJCX0KLQkJCQl9Ci0JCQkpOwotCQlyZXR1cm4gbmV3IEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0oYWN0aW9uKTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0gYnVpbGRDbGVhck1vZGVsQUNJKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFjdGlvbigiQ2xlYXIgbW9kZWwiLCBJQWN0aW9uLkFTX1BVU0hfQlVUVE9OKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQljbGVhck1vZGVsKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRUb29sVGlwVGV4dCgiQ2xlYXIgdGhlIG1vZGVsIik7Ci0JCXJldHVybiBuZXcgQWN0aW9uQ29udHJpYnV0aW9uSXRlbShhY3Rpb24pOwotCX0KLQotCXByaXZhdGUgQWN0aW9uQ29udHJpYnV0aW9uSXRlbSBidWlsZFJlc3RvcmVNb2RlbEFDSSgpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBY3Rpb24oIlJlc3RvcmUgbW9kZWwiLCBJQWN0aW9uLkFTX1BVU0hfQlVUVE9OKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlyZXN0b3JlTW9kZWwoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldFRvb2xUaXBUZXh0KCJSZXN0b3JlIHRoZSBtb2RlbCIpOwotCQlyZXR1cm4gbmV3IEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0oYWN0aW9uKTsKLQl9Ci0KLQl2b2lkIGFkZENoaWxkKCkgewotCQlTdHJpbmcgbm9kZU5hbWUgPSBub2RlTmFtZVRleHQuZ2V0VGV4dCgpOwotCQlpZiAobm9kZU5hbWUubGVuZ3RoKCkgIT0gMCkgewotCQkJc2VsZWN0ZWROb2RlLmdldFZhbHVlKCkuYWRkQ2hpbGQobm9kZU5hbWUpOwotCQl9Ci0JfQotCi0Jdm9pZCBhZGROZXN0ZWRDaGlsZCgpIHsKLQkJU3RyaW5nIG5vZGVOYW1lID0gbm9kZU5hbWVUZXh0LmdldFRleHQoKTsKLQkJaWYgKG5vZGVOYW1lLmxlbmd0aCgpICE9IDApIHsKLQkJCXNlbGVjdGVkTm9kZS5nZXRWYWx1ZSgpLmFkZE5lc3RlZENoaWxkKG5vZGVOYW1lKTsKLQkJfQotCX0KLQotCXZvaWQgcmVtb3ZlKCkgewotCQlUcmVlTm9kZSBub2RlID0gc2VsZWN0ZWROb2RlLmdldFZhbHVlKCk7Ci0JCW5vZGUucGFyZW50KCkucmVtb3ZlQ2hpbGQobm9kZSk7Ci0JfQotCi0Jdm9pZCBjbGVhck1vZGVsKCkgewotCQljb250cm9sVHJlZS5zZXRJbnB1dChudWxsKTsKLQkJdmlld1RyZWUuc2V0SW5wdXQobnVsbCk7Ci0JfQotCi0Jdm9pZCByZXN0b3JlTW9kZWwoKSB7Ci0JCWNvbnRyb2xUcmVlLnNldElucHV0KHJvb3QpOwotCQl2aWV3VHJlZS5zZXRJbnB1dChyb290KTsKLQl9Ci0KLQotCXByaXZhdGUgc3RhdGljIGFic3RyYWN0IGNsYXNzIEFic3RyYWN0VHJlZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5Ci0JCWltcGxlbWVudHMgVHJlZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5Ci0JewotCQlwdWJsaWMgVHJlZUl0ZW1Db250ZW50UHJvdmlkZXIgYnVpbGRJdGVtQ29udGVudFByb3ZpZGVyKAotCQkJT2JqZWN0IGl0ZW0sIERlbGVnYXRpbmdDb250ZW50QW5kTGFiZWxQcm92aWRlciBjb250ZW50QW5kTGFiZWxQcm92aWRlcikgewotCQkJcmV0dXJuIG5ldyBHZW5lcmljVHJlZUl0ZW1Db250ZW50UHJvdmlkZXIoCi0JCQkJKFRyZWVOb2RlKSBpdGVtLCAoRGVsZWdhdGluZ1RyZWVDb250ZW50QW5kTGFiZWxQcm92aWRlcikgY29udGVudEFuZExhYmVsUHJvdmlkZXIpOwotCQl9Ci0JfQotCi0KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBDb250cm9sVHJlZUl0ZW1Db250ZW50UHJvdmlkZXJGYWN0b3J5IGV4dGVuZHMgQWJzdHJhY3RUcmVlSXRlbUNvbnRlbnRQcm92aWRlckZhY3RvcnkKLQl7Ci0KLQl9Ci0KLQotCXByaXZhdGUgc3RhdGljIGNsYXNzIFZpZXdUcmVlSXRlbUNvbnRlbnRQcm92aWRlckZhY3RvcnkKLQkJZXh0ZW5kcyBBYnN0cmFjdFRyZWVJdGVtQ29udGVudFByb3ZpZGVyRmFjdG9yeQotCXsKLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBUcmVlSXRlbUNvbnRlbnRQcm92aWRlciBidWlsZEl0ZW1Db250ZW50UHJvdmlkZXIoCi0JCQkJT2JqZWN0IGl0ZW0sIERlbGVnYXRpbmdDb250ZW50QW5kTGFiZWxQcm92aWRlciBjb250ZW50QW5kTGFiZWxQcm92aWRlcikgewotCQkJaWYgKGl0ZW0gaW5zdGFuY2VvZiBQYXJlbnQpIHsKLQkJCQlyZXR1cm4gbmV3IFZpZXdUcmVlUGFyZW50SXRlbUNvbnRlbnRQcm92aWRlcigKLQkJCQkJCShQYXJlbnQpIGl0ZW0sIChEZWxlZ2F0aW5nVHJlZUNvbnRlbnRBbmRMYWJlbFByb3ZpZGVyKSBjb250ZW50QW5kTGFiZWxQcm92aWRlcik7Ci0JCQl9Ci0JCQlyZXR1cm4gc3VwZXIuYnVpbGRJdGVtQ29udGVudFByb3ZpZGVyKGl0ZW0sIGNvbnRlbnRBbmRMYWJlbFByb3ZpZGVyKTsKLQkJfQotCX0KLQotCi0JcHJpdmF0ZSBzdGF0aWMgY2xhc3MgR2VuZXJpY1RyZWVJdGVtQ29udGVudFByb3ZpZGVyIGV4dGVuZHMgQWJzdHJhY3RUcmVlSXRlbUNvbnRlbnRQcm92aWRlcjxUcmVlTm9kZT4KLQl7Ci0JCXB1YmxpYyBHZW5lcmljVHJlZUl0ZW1Db250ZW50UHJvdmlkZXIoCi0JCQkJVHJlZU5vZGUgdHJlZU5vZGUsIERlbGVnYXRpbmdUcmVlQ29udGVudEFuZExhYmVsUHJvdmlkZXIgdHJlZUNvbnRlbnRBbmRMYWJlbFByb3ZpZGVyKSB7Ci0JCQlzdXBlcih0cmVlTm9kZSwgdHJlZUNvbnRlbnRBbmRMYWJlbFByb3ZpZGVyKTsKLQkJfQotCi0JCXByb3RlY3RlZCBUcmVlTm9kZSB0cmVlTm9kZSgpIHsKLQkJCXJldHVybiAoVHJlZU5vZGUpIGdldE1vZGVsKCk7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFRyZWVOb2RlIGdldFBhcmVudCgpIHsKLQkJCXJldHVybiB0cmVlTm9kZSgpLnBhcmVudCgpOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCBDb2xsZWN0aW9uVmFsdWVNb2RlbDxUcmVlTm9kZT4gYnVpbGRDaGlsZHJlbk1vZGVsKCkgewotCQkJcmV0dXJuIG5ldyBMaXN0Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyPFRyZWVOb2RlPigKLQkJCW5ldyBMaXN0QXNwZWN0QWRhcHRlcjxUcmVlTm9kZSwgVHJlZU5vZGU+KFRyZWVOb2RlLkNISUxEUkVOX0xJU1QsIHRyZWVOb2RlKCkpIHsKLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgTGlzdEl0ZXJhdG9yPFRyZWVOb2RlPiBsaXN0SXRlcmF0b3JfKCkgewotCQkJCQlyZXR1cm4gdHJlZU5vZGUoKS5jaGlsZHJlbigpOwotCQkJCX0KLQkJCX0pOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgY2xhc3MgVmlld1RyZWVQYXJlbnRJdGVtQ29udGVudFByb3ZpZGVyIGV4dGVuZHMgR2VuZXJpY1RyZWVJdGVtQ29udGVudFByb3ZpZGVyCi0JewotCQlwdWJsaWMgVmlld1RyZWVQYXJlbnRJdGVtQ29udGVudFByb3ZpZGVyKAotCQkJCVRyZWVOb2RlIHRyZWVOb2RlLCBEZWxlZ2F0aW5nVHJlZUNvbnRlbnRBbmRMYWJlbFByb3ZpZGVyIHRyZWVDb250ZW50QW5kTGFiZWxQcm92aWRlcikgewotCQkJc3VwZXIodHJlZU5vZGUsIHRyZWVDb250ZW50QW5kTGFiZWxQcm92aWRlcik7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFRyZWVOb2RlIGdldFBhcmVudCgpIHsKLQkJCVRyZWVOb2RlIHBhcmVudCA9IHN1cGVyLmdldFBhcmVudCgpOwotCQkJaWYgKHBhcmVudCBpbnN0YW5jZW9mIE5lc3QpIHsKLQkJCQlwYXJlbnQgPSBwYXJlbnQucGFyZW50KCk7Ci0JCQl9Ci0JCQlyZXR1cm4gcGFyZW50OwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCBDb2xsZWN0aW9uVmFsdWVNb2RlbDxUcmVlTm9kZT4gYnVpbGRDaGlsZHJlbk1vZGVsKCkgewotCQkJCXJldHVybiBuZXcgQ29tcG9zaXRlQ29sbGVjdGlvblZhbHVlTW9kZWw8VHJlZU5vZGUsIFRyZWVOb2RlPihzdXBlci5idWlsZENoaWxkcmVuTW9kZWwoKSkgewotCQkJCQkJQE92ZXJyaWRlCi0JCQkJCQlwcm90ZWN0ZWQgQ29sbGVjdGlvblZhbHVlTW9kZWw8VHJlZU5vZGU+IHRyYW5zZm9ybShUcmVlTm9kZSB2YWx1ZSkgewotCQkJCQkJCWlmICh2YWx1ZSBpbnN0YW5jZW9mIE5lc3QpIHsKLQkJCQkJCQkJZmluYWwgTmVzdCBuZXN0ID0gKE5lc3QpIHZhbHVlOwotCQkJCQkJCQlyZXR1cm4gbmV3IExpc3RDb2xsZWN0aW9uVmFsdWVNb2RlbEFkYXB0ZXI8VHJlZU5vZGU+KAotCQkJCQkJCQkJCW5ldyBMaXN0QXNwZWN0QWRhcHRlcjxUcmVlTm9kZSwgVHJlZU5vZGU+KFRyZWVOb2RlLkNISUxEUkVOX0xJU1QsIG5lc3QpIHsKLQkJCQkJCQkJCQkJQE92ZXJyaWRlCi0JCQkJCQkJCQkJCXByb3RlY3RlZCBMaXN0SXRlcmF0b3I8VHJlZU5vZGU+IGxpc3RJdGVyYXRvcl8oKSB7Ci0JCQkJCQkJCQkJCQlyZXR1cm4gbmVzdC5jaGlsZHJlbigpOwotCQkJCQkJCQkJCQl9Ci0JCQkJCQkJCQkJfQotCQkJCQkJCQkJKTsKLQkJCQkJCQl9Ci0JCQkJCQkJcmV0dXJuIG5ldyBTdGF0aWNDb2xsZWN0aW9uVmFsdWVNb2RlbDxUcmVlTm9kZT4oQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24odmFsdWUpKTsKLQkJCQkJCX0KLQkJCQkJfTsKLQkJfQotCX0KLQotCi0JcHJpdmF0ZSBzdGF0aWMgY2xhc3MgTGFiZWxQcm92aWRlciBleHRlbmRzIEJhc2VMYWJlbFByb3ZpZGVyCi0JCWltcGxlbWVudHMgSUxhYmVsUHJvdmlkZXIKLQl7Ci0JCXB1YmxpYyBJbWFnZSBnZXRJbWFnZShPYmplY3QgZWxlbWVudCkgewotCQkJcmV0dXJuIG51bGw7Ci0JCX0KLQotCQlwdWJsaWMgU3RyaW5nIGdldFRleHQoT2JqZWN0IGVsZW1lbnQpIHsKLQkJCXJldHVybiAoKFRyZWVOb2RlKSBlbGVtZW50KS5nZXROYW1lKCk7Ci0JCX0KLQl9Ci0KLQotCXByaXZhdGUgc3RhdGljIGFic3RyYWN0IGNsYXNzIFRyZWVOb2RlIGV4dGVuZHMgQWJzdHJhY3RNb2RlbAotCXsKLQkJcHJpdmF0ZSBUcmVlTm9kZSBwYXJlbnQ7Ci0KLQkJcHJvdGVjdGVkIGZpbmFsIExpc3Q8VHJlZU5vZGU+IGNoaWxkcmVuOwotCQlwdWJsaWMgZmluYWwgc3RhdGljIFN0cmluZyBDSElMRFJFTl9MSVNUID0gImNoaWxkcmVuIjsKLQotCQlwcm90ZWN0ZWQgU3RyaW5nIG5hbWU7Ci0JCXB1YmxpYyBmaW5hbCBzdGF0aWMgU3RyaW5nIE5BTUVfUFJPUEVSVFkgPSAibmFtZSI7Ci0KLQotCQlwdWJsaWMgVHJlZU5vZGUoVHJlZU5vZGUgcGFyZW50LCBTdHJpbmcgbmFtZSkgewotCQkJdGhpcy5wYXJlbnQgPSBwYXJlbnQ7Ci0JCQl0aGlzLmNoaWxkcmVuID0gbmV3IEFycmF5TGlzdDxUcmVlTm9kZT4oKTsKLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCX0KLQotCQlwdWJsaWMgVHJlZU5vZGUgcGFyZW50KCkgewotCQkJcmV0dXJuIHBhcmVudDsKLQkJfQotCi0JCXB1YmxpYyBMaXN0SXRlcmF0b3I8VHJlZU5vZGU+IGNoaWxkcmVuKCkgewotCQkJcmV0dXJuIG5ldyBSZWFkT25seUxpc3RJdGVyYXRvcjxUcmVlTm9kZT4oY2hpbGRyZW4pOwotCQl9Ci0KLQkJcHJvdGVjdGVkIHZvaWQgYWRkQ2hpbGQoVHJlZU5vZGUgY2hpbGQpIHsKLQkJCWFkZEl0ZW1Ub0xpc3QoY2hpbGQsIGNoaWxkcmVuLCBDSElMRFJFTl9MSVNUKTsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIHJlbW92ZUNoaWxkKFRyZWVOb2RlIGNoaWxkKSB7Ci0JCQlyZW1vdmVJdGVtRnJvbUxpc3QoY2hpbGQsIGNoaWxkcmVuLCBDSElMRFJFTl9MSVNUKTsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIHJlbW92ZUNoaWxkKGludCBpbmRleCkgewotCQkJcmVtb3ZlSXRlbUZyb21MaXN0KGluZGV4LCBjaGlsZHJlbiwgQ0hJTERSRU5fTElTVCk7Ci0JCX0KLQotCQlwdWJsaWMgU3RyaW5nIGdldE5hbWUoKSB7Ci0JCQlyZXR1cm4gbmFtZTsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIHNldE5hbWUoU3RyaW5nIG5ld05hbWUpIHsKLQkJCVN0cmluZyBvbGROYW1lID0gbmFtZTsKLQkJCW5hbWUgPSBuZXdOYW1lOwotCQkJZmlyZVByb3BlcnR5Q2hhbmdlZChOQU1FX1BST1BFUlRZLCBvbGROYW1lLCBuZXdOYW1lKTsKLQkJfQotCi0JCXB1YmxpYyBib29sZWFuIGNhbkhhdmVDaGlsZHJlbigpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIGFkZENoaWxkKFN0cmluZyBuYW1lKSB7Ci0JCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQkJfQotCi0JCXB1YmxpYyBib29sZWFuIGNhbkhhdmVOZXN0ZWRDaGlsZHJlbigpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIGFkZE5lc3RlZENoaWxkKFN0cmluZyBuYW1lKSB7Ci0JCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgdm9pZCB0b1N0cmluZyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCQlzYi5hcHBlbmQoZ2V0TmFtZSgpKTsKLQkJfQotCX0KLQotCi0JcHJpdmF0ZSBzdGF0aWMgY2xhc3MgUm9vdCBleHRlbmRzIFRyZWVOb2RlCi0JewotCQlwdWJsaWMgUm9vdCgpIHsKLQkJCXN1cGVyKG51bGwsIG51bGwpOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBib29sZWFuIGNhbkhhdmVDaGlsZHJlbigpIHsKLQkJCXJldHVybiB0cnVlOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyB2b2lkIGFkZENoaWxkKFN0cmluZyBuYW1lKSB7Ci0JCQlhZGRDaGlsZChuZXcgUGFyZW50KHRoaXMsIG5hbWUpKTsKLQkJfQotCX0KLQotCi0JcHJpdmF0ZSBzdGF0aWMgY2xhc3MgUGFyZW50IGV4dGVuZHMgVHJlZU5vZGUKLQl7Ci0JCXB1YmxpYyBQYXJlbnQoVHJlZU5vZGUgcGFyZW50LCBTdHJpbmcgbmFtZSkgewotCQkJc3VwZXIocGFyZW50LCBuYW1lKTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgYm9vbGVhbiBjYW5IYXZlQ2hpbGRyZW4oKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgdm9pZCBhZGRDaGlsZChTdHJpbmcgbmFtZSkgewotCQkJYWRkQ2hpbGQobmV3IENoaWxkKHRoaXMsIG5hbWUpKTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgYm9vbGVhbiBjYW5IYXZlTmVzdGVkQ2hpbGRyZW4oKSB7Ci0JCQlyZXR1cm4gdHJ1ZTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgdm9pZCBhZGROZXN0ZWRDaGlsZChTdHJpbmcgbmFtZSkgewotCQkJVHJlZU5vZGUgbmVzdCA9IG5ldyBOZXN0KHRoaXMpOwotCQkJYWRkQ2hpbGQobmVzdCk7Ci0JCQluZXN0LmFkZENoaWxkKG5hbWUpOwotCQl9Ci0KLQkJcHVibGljIEl0ZXJhdG9yPENoaWxkPiBuZXN0bGVzc0NoaWxkcmVuKCkgewotCQkJcmV0dXJuIG5ldyBGaWx0ZXJpbmdJdGVyYXRvcjxDaGlsZCwgQ2hpbGQ+KAotCQkJCQluZXcgVHJhbnNmb3JtYXRpb25JdGVyYXRvcjxUcmVlTm9kZSwgQ2hpbGQ+KGNoaWxkcmVuKCkpIHsKLQkJCQkJCUBPdmVycmlkZQotCQkJCQkJcHJvdGVjdGVkIENoaWxkIHRyYW5zZm9ybShUcmVlTm9kZSBuZXh0KSB7Ci0JCQkJCQkJaWYgKG5leHQgaW5zdGFuY2VvZiBOZXN0KSB7Ci0JCQkJCQkJCXJldHVybiAoKE5lc3QpIG5leHQpLmNoaWxkKCk7Ci0JCQkJCQkJfQotCQkJCQkJCXJldHVybiAoQ2hpbGQpIG5leHQ7Ci0JCQkJCQl9Ci0JCQkJCX0pIHsKLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgYm9vbGVhbiBhY2NlcHQoQ2hpbGQgYykgewotCQkJCQlyZXR1cm4gYyAhPSBudWxsOwotCQkJCX0KLQkJCX07Ci0JCX0KLQl9Ci0KLQotCXByaXZhdGUgc3RhdGljIGNsYXNzIE5lc3QgZXh0ZW5kcyBUcmVlTm9kZQotCXsKLQkJcHVibGljIE5lc3QoVHJlZU5vZGUgcGFyZW50KSB7Ci0JCQlzdXBlcihwYXJlbnQsICJuZXN0Iik7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIGJvb2xlYW4gY2FuSGF2ZUNoaWxkcmVuKCkgewotCQkJcmV0dXJuIGNoaWxkcmVuLnNpemUoKSA9PSAwOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyB2b2lkIGFkZENoaWxkKFN0cmluZyBuYW1lKSB7Ci0JCQlhZGRDaGlsZChuZXcgQ2hpbGQodGhpcywgbmFtZSkpOwotCQl9Ci0KLQkJLyogY2FuIG9ubHkgaGF2ZSBvbmUgY2hpbGQgKi8KLQkJcHVibGljIENoaWxkIGNoaWxkKCkgewotCQkJcmV0dXJuIChjaGlsZHJlbi5pc0VtcHR5KCkpID8gbnVsbCA6IChDaGlsZCkgY2hpbGRyZW4uZ2V0KDApOwotCQl9Ci0JfQotCi0KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBDaGlsZCBleHRlbmRzIFRyZWVOb2RlCi0JewotCQlwdWJsaWMgQ2hpbGQoVHJlZU5vZGUgcGFyZW50LCBTdHJpbmcgbmFtZSkgewotCQkJc3VwZXIocGFyZW50LCBuYW1lKTsKLQkJfQotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC9wbGF0Zm9ybS9KcGFQbGF0Zm9ybVVpRXh0ZW5zaW9uVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC9wbGF0Zm9ybS9KcGFQbGF0Zm9ybVVpRXh0ZW5zaW9uVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzA3MWM1My4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm0vSnBhUGxhdGZvcm1VaUV4dGVuc2lvblRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NiArMCwwIEBACi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy5pbnRlcm5hbC5wbGF0Zm9ybTsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQuY29yZS5KcGFQcm9qZWN0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLmludGVybmFsLnBsYXRmb3JtLkpwYVBsYXRmb3JtUmVnaXN0cnk7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlLkV4dGVuc2lvblRlc3RQbHVnaW47Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LmNvcmUudGVzdHMuZXh0ZW5zaW9uLnJlc291cmNlLlRlc3RKcGFQbGF0Zm9ybVByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC5jb3JlLnRlc3RzLmludGVybmFsLnByb2plY3RzLlRlc3RKcGFQcm9qZWN0OwotCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBKcGFQbGF0Zm9ybVVpRXh0ZW5zaW9uVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZQotewotCXByb3RlY3RlZCBUZXN0SnBhUHJvamVjdCB0ZXN0UHJvamVjdDsKLQotCXByb3RlY3RlZCBzdGF0aWMgZmluYWwgU3RyaW5nIFBST0pFQ1RfTkFNRSA9ICJFeHRlbnNpb25UZXN0UHJvamVjdCI7Ci0JcHJvdGVjdGVkIHN0YXRpYyBmaW5hbCBTdHJpbmcgUEFDS0FHRV9OQU1FID0gImV4dGVuc2lvbi50ZXN0IjsKLQotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFRFU1RfUExVR0lOX0NMQVNTID0gRXh0ZW5zaW9uVGVzdFBsdWdpbi5jbGFzcy5nZXROYW1lKCk7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgVEVTVF9QTFVHSU5fSUQgPSBFeHRlbnNpb25UZXN0UGx1Z2luLlBMVUdJTl9JRDsKLQotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFRFU1RfUExBVEZPUk1fSUQgPSBUZXN0SnBhUGxhdGZvcm1Qcm92aWRlci5JRDsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBURVNUX1BMQVRGT1JNX0NMQVNTID0gVGVzdEpwYVBsYXRmb3JtUHJvdmlkZXIuY2xhc3MuZ2V0TmFtZSgpOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFRFU1RfUExBVEZPUk1fTEFCRUwgPSAiVGVzdCBKcGEgUGxhdGZvcm0iOwotCi0JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgVEVTVF9VSV9QTEFURk9STV9JRCA9IFRFU1RfUExBVEZPUk1fSUQ7Ci0KLQlwdWJsaWMgSnBhUGxhdGZvcm1VaUV4dGVuc2lvblRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMudGVzdFByb2plY3QgPSB0aGlzLmJ1aWxkSnBhUHJvamVjdChQUk9KRUNUX05BTUUsIGZhbHNlKTsgIC8vIGZhbHNlID0gbm8gYXV0by1idWlsZAotCX0KLQotCXByb3RlY3RlZCBUZXN0SnBhUHJvamVjdCBidWlsZEpwYVByb2plY3QoU3RyaW5nIHByb2plY3ROYW1lLCBib29sZWFuIGF1dG9CdWlsZCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBuZXcgVGVzdEpwYVByb2plY3QocHJvamVjdE5hbWUsIGF1dG9CdWlsZCk7ICAvLyBmYWxzZSA9IG5vIGF1dG8tYnVpbGQKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLnRlc3RQcm9qZWN0LmdldFByb2plY3QoKS5kZWxldGUodHJ1ZSwgdHJ1ZSwgbnVsbCk7Ci0JCXRoaXMudGVzdFByb2plY3QgPSBudWxsOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXByb3RlY3RlZCBKcGFQcm9qZWN0IGpwYVByb2plY3QoKSB7Ci0JCXJldHVybiB0aGlzLnRlc3RQcm9qZWN0LmdldEpwYVByb2plY3QoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SnBhUGxhdGZvcm0oKSB7Ci0JCWFzc2VydE5vdE51bGwoSnBhUGxhdGZvcm1SZWdpc3RyeS5pbnN0YW5jZSgpLmdldEpwYVBsYXRmb3JtKHRoaXMudGVzdFByb2plY3QuZ2V0UHJvamVjdCgpKSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm0vSnB0VWlQbGF0Zm9ybVRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvcGxhdGZvcm0vSnB0VWlQbGF0Zm9ybVRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDUwYmNjOTkuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3BsYXRmb3JtL0pwdFVpUGxhdGZvcm1UZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudWkudGVzdHMuaW50ZXJuYWwucGxhdGZvcm07Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdFN1aXRlOwotCi1wdWJsaWMgY2xhc3MgSnB0VWlQbGF0Zm9ybVRlc3RzCi17Ci0JcHVibGljIHN0YXRpYyBUZXN0IHN1aXRlKCkgewotCQlUZXN0U3VpdGUgc3VpdGUgPSBuZXcgVGVzdFN1aXRlKEpwdFVpUGxhdGZvcm1UZXN0cy5jbGFzcy5nZXRQYWNrYWdlKCkuZ2V0TmFtZSgpKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKEpwYVBsYXRmb3JtVWlFeHRlbnNpb25UZXN0cy5jbGFzcyk7Ci0JCXJldHVybiBzdWl0ZTsKLQl9Ci0KLQlwcml2YXRlIEpwdFVpUGxhdGZvcm1UZXN0cygpIHsKLQkJc3VwZXIoKTsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3N3dC9BYnN0cmFjdENvbWJvTW9kZWxBZGFwdGVyVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3N3dC9BYnN0cmFjdENvbWJvTW9kZWxBZGFwdGVyVGVzdC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkNmQxMmVhLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC9zd3QvQWJzdHJhY3RDb21ib01vZGVsQWRhcHRlclRlc3QuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDc3MyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzLmludGVybmFsLnN3dDsKLQotaW1wb3J0IHN0YXRpYyBvcmcuanVuaXQuQXNzZXJ0Lio7Ci1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuc3d0LkFic3RyYWN0Q29tYm9Nb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnN3dC5BYnN0cmFjdENvbWJvTW9kZWxBZGFwdGVyLlNlbGVjdGlvbkNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5zd3QuQWJzdHJhY3RDb21ib01vZGVsQWRhcHRlci5TZWxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdDb252ZXJ0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5MaXN0QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLnN3aW5nLlNpbXBsZURpc3BsYXlhYmxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkRpc3BsYXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuU2hlbGw7Ci1pbXBvcnQgb3JnLmp1bml0LkFmdGVyOwotaW1wb3J0IG9yZy5qdW5pdC5CZWZvcmU7Ci1pbXBvcnQgb3JnLmp1bml0LlRlc3Q7Ci0KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGFic3RyYWN0IGNsYXNzIEFic3RyYWN0Q29tYm9Nb2RlbEFkYXB0ZXJUZXN0IHsKLQotCXByaXZhdGUgTW9kZWwgbW9kZWw7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTaW1wbGVEaXNwbGF5YWJsZT4gc2VsZWN0ZWRJdGVtSG9sZGVyOwotCXByaXZhdGUgU2hlbGwgc2hlbGw7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxNb2RlbD4gc3ViamVjdEhvbGRlcjsKLQotCXByb3RlY3RlZCBhYnN0cmFjdCBBYnN0cmFjdENvbWJvTW9kZWxBZGFwdGVyPFNpbXBsZURpc3BsYXlhYmxlPiBidWlsZEVkaXRhYmxlQ29tYm9Nb2RlbEFkYXB0ZXIoKTsKLQotCXByb3RlY3RlZCBmaW5hbCBMaXN0VmFsdWVNb2RlbDxTaW1wbGVEaXNwbGF5YWJsZT4gYnVpbGRFbXB0eUxpc3RIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U2ltcGxlRGlzcGxheWFibGU+KCk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0PFNpbXBsZURpc3BsYXlhYmxlPiBidWlsZExpc3QoKSB7Ci0JCUxpc3Q8U2ltcGxlRGlzcGxheWFibGU+IGxpc3QgPSBuZXcgQXJyYXlMaXN0PFNpbXBsZURpc3BsYXlhYmxlPigpOwotCQlwb3B1bGF0ZUNvbGxlY3Rpb24obGlzdCk7Ci0JCXJldHVybiBsaXN0OwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCBMaXN0VmFsdWVNb2RlbDxTaW1wbGVEaXNwbGF5YWJsZT4gYnVpbGRMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IExpc3RBc3BlY3RBZGFwdGVyPE1vZGVsLCBTaW1wbGVEaXNwbGF5YWJsZT4oc3ViamVjdEhvbGRlciwgTW9kZWwuSVRFTVNfTElTVCkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgTGlzdEl0ZXJhdG9yPFNpbXBsZURpc3BsYXlhYmxlPiBsaXN0SXRlcmF0b3JfKCkgewotCQkJCXJldHVybiBzdWJqZWN0Lml0ZW1zKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGludCBzaXplXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5pdGVtc1NpemUoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcm90ZWN0ZWQgYWJzdHJhY3QgQWJzdHJhY3RDb21ib01vZGVsQWRhcHRlcjxTaW1wbGVEaXNwbGF5YWJsZT4gYnVpbGRSZWFkT25seUNvbWJvTW9kZWxBZGFwdGVyKCk7Ci0KLQlwcml2YXRlIFNpbXBsZURpc3BsYXlhYmxlIGJ1aWxkU2VsZWN0ZWRJdGVtKCkgewotCQlyZXR1cm4gbmV3IFNpbXBsZURpc3BsYXlhYmxlKCJiYXoiKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFNpbXBsZURpc3BsYXlhYmxlPiBidWlsZFNlbGVjdGVkSXRlbUhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8TW9kZWwsIFNpbXBsZURpc3BsYXlhYmxlPihzdWJqZWN0SG9sZGVyLCBNb2RlbC5JVEVNX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTaW1wbGVEaXNwbGF5YWJsZSBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRJdGVtKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFNpbXBsZURpc3BsYXlhYmxlIHZhbHVlKSB7Ci0JCQkJc3ViamVjdC5zZXRJdGVtKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgU3RyaW5nQ29udmVydGVyPFNpbXBsZURpc3BsYXlhYmxlPiBidWlsZFN0cmluZ0NvbnZlcnRlcigpIHsKLQkJcmV0dXJuIG5ldyBTdHJpbmdDb252ZXJ0ZXI8U2ltcGxlRGlzcGxheWFibGU+KCkgewotCQkJcHVibGljIFN0cmluZyBjb252ZXJ0VG9TdHJpbmcoU2ltcGxlRGlzcGxheWFibGUgdmFsdWUpIHsKLQkJCQlyZXR1cm4gKHZhbHVlID09IG51bGwpID8gIiIgOiB2YWx1ZS5kaXNwbGF5U3RyaW5nKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxNb2RlbD4gYnVpbGRTdWJqZWN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxNb2RlbD4oKTsKLQl9Ci0KLQlwdWJsaWMgYWJzdHJhY3QgU3RyaW5nIGNvbWJvU2VsZWN0ZWRJdGVtKCk7Ci0KLQlwcm90ZWN0ZWQgYWJzdHJhY3QgYm9vbGVhbiBlbXB0eUNvbWJvQ2FuSGF2ZVNlbGVjdGVkVmFsdWUoKTsKLQotCXByb3RlY3RlZCBhYnN0cmFjdCBTdHJpbmcgaXRlbUF0KGludCBpbmRleCk7Ci0KLQlwcm90ZWN0ZWQgYWJzdHJhY3QgaW50IGl0ZW1Db3VudHMoKTsKLQotCXByaXZhdGUgdm9pZCBwb3B1bGF0ZUNvbGxlY3Rpb24oQ29sbGVjdGlvbjxTaW1wbGVEaXNwbGF5YWJsZT4gYykgewotCQljLmFkZChuZXcgU2ltcGxlRGlzcGxheWFibGUoImZvbyIpKTsKLQkJYy5hZGQobmV3IFNpbXBsZURpc3BsYXlhYmxlKCJiYXIiKSk7Ci0JCWMuYWRkKG5ldyBTaW1wbGVEaXNwbGF5YWJsZSgiYmF6IikpOwotCQljLmFkZChuZXcgU2ltcGxlRGlzcGxheWFibGUoImpvbyIpKTsKLQkJYy5hZGQobmV3IFNpbXBsZURpc3BsYXlhYmxlKCJqYXIiKSk7Ci0JCWMuYWRkKG5ldyBTaW1wbGVEaXNwbGF5YWJsZSgiamF6IikpOwotCX0KLQotCXByb3RlY3RlZCBmaW5hbCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTaW1wbGVEaXNwbGF5YWJsZT4gc2VsZWN0ZWRJdGVtSG9sZGVyKCkgewotCQlyZXR1cm4gc2VsZWN0ZWRJdGVtSG9sZGVyOwotCX0KLQotCUBCZWZvcmUKLQlwdWJsaWMgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCi0JCXNoZWxsICAgICAgICAgICAgICA9IG5ldyBTaGVsbChEaXNwbGF5LmdldEN1cnJlbnQoKSk7Ci0JCW1vZGVsICAgICAgICAgICAgICA9IG5ldyBNb2RlbCgpOwotCQlzdWJqZWN0SG9sZGVyICAgICAgPSBidWlsZFN1YmplY3RIb2xkZXIoKTsKLQkJc2VsZWN0ZWRJdGVtSG9sZGVyID0gYnVpbGRTZWxlY3RlZEl0ZW1Ib2xkZXIoKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgU2hlbGwgc2hlbGwoKSB7Ci0JCXJldHVybiBzaGVsbDsKLQl9Ci0KLQlwcm90ZWN0ZWQgZmluYWwgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8TW9kZWw+IHN1YmplY3RIb2xkZXIoKSB7Ci0JCXJldHVybiBzdWJqZWN0SG9sZGVyOwotCX0KLQotCUBBZnRlcgotCXB1YmxpYyB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJaWYgKCFzaGVsbC5pc0Rpc3Bvc2VkKCkpIHsKLQkJCXNoZWxsLmRpc3Bvc2UoKTsKLQkJfQotCi0JCXNoZWxsICAgICAgICAgICAgICA9IG51bGw7Ci0JCXN1YmplY3RIb2xkZXIgICAgICA9IG51bGw7Ci0JCXNlbGVjdGVkSXRlbUhvbGRlciA9IG51bGw7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHRlc3RJdGVtcygpIHsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIGNvdW50IG9mIGl0ZW1zIGlzIG5vdCBpbiBzeW5jIHdpdGggdGhlIG1vZGVsIiwKLQkJCW1vZGVsLml0ZW1zU2l6ZSgpLAotCQkJaXRlbUNvdW50cygpCi0JCSk7Ci0KLQkJZm9yIChpbnQgaW5kZXggPSAwOyBpbmRleCA8IG1vZGVsLml0ZW1zU2l6ZSgpOyBpbmRleCsrKSB7Ci0JCQlhc3NlcnRFcXVhbHMoCi0JCQkJIlRoZSBpdGVtIGF0IGluZGV4ICIgKyBpbmRleCArICIgaXMgbm90IHRoZSBzYW1lIGJldHdlZW4gdGhlIG1vZGVsIGFuZCB0aGUgY29tYm8iLAotCQkJCW1vZGVsLml0ZW1BdChpbmRleCkuZGlzcGxheVN0cmluZygpLAotCQkJCWl0ZW1BdChpbmRleCkKLQkJCSk7Ci0JCX0KLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROb25OdWxsU3ViamVjdEFmdGVyX0FkZGVkQWZ0ZXJfUmVhZE9ubHkoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQlidWlsZFJlYWRPbmx5Q29tYm9Nb2RlbEFkYXB0ZXIoKTsKLQkJdGVzdFJlbW92ZUl0ZW1zX0FkZGVkQWZ0ZXIoKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROb25OdWxsU3ViamVjdEFmdGVyX0FkZGVkQWZ0ZXJfUmVtb3ZlSXRlbXNfRWRpdGFibGUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQlidWlsZEVkaXRhYmxlQ29tYm9Nb2RlbEFkYXB0ZXIoKTsKLQkJdGVzdFJlbW92ZUl0ZW1zX0FkZGVkQWZ0ZXIoKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROb25OdWxsU3ViamVjdEFmdGVyX0FkZGVkQmVmb3JlX1JlbW92ZUl0ZW1zX0VkaXRhYmxlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJc3ViamVjdEhvbGRlci5zZXRWYWx1ZShtb2RlbCk7Ci0JCW1vZGVsLmFkZEl0ZW1zKGJ1aWxkTGlzdCgpKTsKLQotCQlidWlsZEVkaXRhYmxlQ29tYm9Nb2RlbEFkYXB0ZXIoKTsKLQkJdGVzdFNlbGVjdGVkSXRlbShudWxsKTsKLQkJdGVzdEl0ZW1zKCk7Ci0KLQkJQXJyYXlMaXN0PFNpbXBsZURpc3BsYXlhYmxlPiBpdGVtcyA9IG5ldyBBcnJheUxpc3Q8U2ltcGxlRGlzcGxheWFibGU+KCk7Ci0JCWl0ZW1zLmFkZChtb2RlbC5pdGVtQXQoMCkpOwotCQlpdGVtcy5hZGQobW9kZWwuaXRlbUF0KDMpKTsKLQkJbW9kZWwucmVtb3ZlSXRlbXMoaXRlbXMuaXRlcmF0b3IoKSk7Ci0JCXRlc3RJdGVtcygpOwotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdE5vbk51bGxTdWJqZWN0QWZ0ZXJfQWRkZWRCZWZvcmVfUmVtb3ZlSXRlbXNfUmVhZE9ubHkoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQlzdWJqZWN0SG9sZGVyLnNldFZhbHVlKG1vZGVsKTsKLQkJbW9kZWwuYWRkSXRlbXMoYnVpbGRMaXN0KCkpOwotCi0JCWJ1aWxkUmVhZE9ubHlDb21ib01vZGVsQWRhcHRlcigpOwotCQl0ZXN0U2VsZWN0ZWRJdGVtKG51bGwpOwotCQl0ZXN0SXRlbXMoKTsKLQotCQlBcnJheUxpc3Q8U2ltcGxlRGlzcGxheWFibGU+IGl0ZW1zID0gbmV3IEFycmF5TGlzdDxTaW1wbGVEaXNwbGF5YWJsZT4oKTsKLQkJaXRlbXMuYWRkKG1vZGVsLml0ZW1BdCgwKSk7Ci0JCWl0ZW1zLmFkZChtb2RlbC5pdGVtQXQoMykpOwotCQltb2RlbC5yZW1vdmVJdGVtcyhpdGVtcy5pdGVyYXRvcigpKTsKLQkJdGVzdEl0ZW1zKCk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0Tm9uTnVsbFN1YmplY3RBZnRlcl9OdWxsU2VsZWN0ZWRJdGVtX0l0ZW1zQWZ0ZXJBZnRlcl9FZGl0YWJsZSgpIHRocm93cyBFeGNlcHRpb24gewotCi0JCWJ1aWxkRWRpdGFibGVDb21ib01vZGVsQWRhcHRlcigpOwotCi0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCQltb2RlbC5hZGRJdGVtcyhidWlsZExpc3QoKSk7Ci0KLQkJdGVzdFNlbGVjdGVkSXRlbShudWxsKTsKLQkJdGVzdEl0ZW1zKCk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0Tm9uTnVsbFN1YmplY3RBZnRlcl9OdWxsU2VsZWN0ZWRJdGVtX0l0ZW1zQWZ0ZXJBZnRlcl9SZWFkT25seSgpIHRocm93cyBFeGNlcHRpb24gewotCi0JCWJ1aWxkUmVhZE9ubHlDb21ib01vZGVsQWRhcHRlcigpOwotCi0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCQltb2RlbC5hZGRJdGVtcyhidWlsZExpc3QoKSk7Ci0KLQkJdGVzdFNlbGVjdGVkSXRlbShudWxsKTsKLQkJdGVzdEl0ZW1zKCk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0Tm9uTnVsbFN1YmplY3RBZnRlcl9OdWxsU2VsZWN0ZWRJdGVtX0l0ZW1zQWZ0ZXJCZWZvcmVfRWRpdGFibGUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQlidWlsZEVkaXRhYmxlQ29tYm9Nb2RlbEFkYXB0ZXIoKTsKLQotCQltb2RlbC5hZGRJdGVtcyhidWlsZExpc3QoKSk7Ci0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCi0JCXRlc3RTZWxlY3RlZEl0ZW0obnVsbCk7Ci0JCXRlc3RJdGVtcygpOwotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdE5vbk51bGxTdWJqZWN0QWZ0ZXJfTnVsbFNlbGVjdGVkSXRlbV9JdGVtc0FmdGVyQmVmb3JlX1JlYWRPbmx5KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJYnVpbGRSZWFkT25seUNvbWJvTW9kZWxBZGFwdGVyKCk7Ci0KLQkJbW9kZWwuYWRkSXRlbXMoYnVpbGRMaXN0KCkpOwotCQlzdWJqZWN0SG9sZGVyLnNldFZhbHVlKG1vZGVsKTsKLQotCQl0ZXN0U2VsZWN0ZWRJdGVtKG51bGwpOwotCQl0ZXN0SXRlbXMoKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROb25OdWxsU3ViamVjdEFmdGVyX051bGxTZWxlY3RlZEl0ZW1fSXRlbXNCZWZvcmVfRWRpdGFibGUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQltb2RlbC5hZGRJdGVtcyhidWlsZExpc3QoKSk7Ci0JCWJ1aWxkRWRpdGFibGVDb21ib01vZGVsQWRhcHRlcigpOwotCi0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCQl0ZXN0U2VsZWN0ZWRJdGVtKG51bGwpOwotCQl0ZXN0SXRlbXMoKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROb25OdWxsU3ViamVjdEFmdGVyX051bGxTZWxlY3RlZEl0ZW1fSXRlbXNCZWZvcmVfUmVhZE9ubHkoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQltb2RlbC5hZGRJdGVtcyhidWlsZExpc3QoKSk7Ci0JCWJ1aWxkUmVhZE9ubHlDb21ib01vZGVsQWRhcHRlcigpOwotCi0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCQl0ZXN0U2VsZWN0ZWRJdGVtKG51bGwpOwotCQl0ZXN0SXRlbXMoKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROb25OdWxsU3ViamVjdEFmdGVyX051bGxTZWxlY3RlZEl0ZW1fTm9JdGVtc19FZGl0YWJsZSgpIHRocm93cyBFeGNlcHRpb24gewotCi0JCWJ1aWxkRWRpdGFibGVDb21ib01vZGVsQWRhcHRlcigpOwotCi0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCQl0ZXN0U2VsZWN0ZWRJdGVtKG51bGwpOwotCQl0ZXN0SXRlbXMoKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROb25OdWxsU3ViamVjdEFmdGVyX051bGxTZWxlY3RlZEl0ZW1fTm9JdGVtc19SZWFkT25seSgpIHRocm93cyBFeGNlcHRpb24gewotCi0JCWJ1aWxkUmVhZE9ubHlDb21ib01vZGVsQWRhcHRlcigpOwotCi0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCQl0ZXN0U2VsZWN0ZWRJdGVtKG51bGwpOwotCQl0ZXN0SXRlbXMoKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROb25OdWxsU3ViamVjdEFmdGVyX1NlbGVjdGVkSXRlbUNoYW5nZWRfUmVhZE9ubHkoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQlzdWJqZWN0SG9sZGVyLnNldFZhbHVlKG1vZGVsKTsKLQkJbW9kZWwuYWRkSXRlbXMoYnVpbGRMaXN0KCkpOwotCi0JCVNpbXBsZURpc3BsYXlhYmxlIHNlbGVjdGVkSXRlbSA9IG1vZGVsLml0ZW1BdCgwKTsKLQotCQlBYnN0cmFjdENvbWJvTW9kZWxBZGFwdGVyPFNpbXBsZURpc3BsYXlhYmxlPiBhZGFwdGVyID0gYnVpbGRFZGl0YWJsZUNvbWJvTW9kZWxBZGFwdGVyKCk7Ci0JCVNlbGVjdGlvbkxpc3RlbmVyIHNlbGVjdGlvbkxpc3RlbmVyID0gbmV3IFNlbGVjdGlvbkxpc3RlbmVyKCk7Ci0JCWFkYXB0ZXIuYWRkU2VsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoc2VsZWN0aW9uTGlzdGVuZXIpOwotCi0JCWFzc2VydEZhbHNlKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXNuJ3Qgc3VwcG9zZWQgdG8gYmUgbW9kaWZpZWQiLCBtb2RlbC5pc1NldEl0ZW1DYWxsZWQoKSk7Ci0JCXRlc3RTZWxlY3RlZEl0ZW0obnVsbCk7Ci0KLQkJdGVzdFNlbGVjdGVkSXRlbUNoYW5nZWQoc2VsZWN0ZWRJdGVtLCBzZWxlY3Rpb25MaXN0ZW5lcik7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0Tm9uTnVsbFN1YmplY3RCZWZvcmVfTm9uTnVsbFNlbGVjdGVkSXRlbUFmdGVyX0VkaXRhYmxlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJU2ltcGxlRGlzcGxheWFibGUgc2VsZWN0ZWRJdGVtID0gYnVpbGRTZWxlY3RlZEl0ZW0oKTsKLQkJc3ViamVjdEhvbGRlci5zZXRWYWx1ZShtb2RlbCk7Ci0KLQkJYnVpbGRFZGl0YWJsZUNvbWJvTW9kZWxBZGFwdGVyKCk7Ci0JCWFzc2VydEZhbHNlKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXNuJ3Qgc3VwcG9zZWQgdG8gYmUgbW9kaWZpZWQiLCBtb2RlbC5pc1NldEl0ZW1DYWxsZWQoKSk7Ci0KLQkJbW9kZWwuc2V0SXRlbShzZWxlY3RlZEl0ZW0pOwotCQlhc3NlcnRUcnVlKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXMgc3VwcG9zZWQgdG8gYmUgbW9kaWZpZWQiLCBtb2RlbC5pc1NldEl0ZW1DYWxsZWQoKSk7Ci0JCWFzc2VydFNhbWUoIlRoZSBzZWxlY3RlZCBpdGVtIHdhc24ndCBzZXQgcHJvcGVybHkiLCBzZWxlY3RlZEl0ZW0sIG1vZGVsLmdldEl0ZW0oKSk7Ci0KLQkJdGVzdFNlbGVjdGVkSXRlbShzZWxlY3RlZEl0ZW0pOwotCQl0ZXN0SXRlbXMoKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROb25OdWxsU3ViamVjdEJlZm9yZV9Ob25OdWxsU2VsZWN0ZWRJdGVtQWZ0ZXJfSXRlbXNfRWRpdGFibGUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQlTaW1wbGVEaXNwbGF5YWJsZSBzZWxlY3RlZEl0ZW0gPSBidWlsZFNlbGVjdGVkSXRlbSgpOwotCQlzdWJqZWN0SG9sZGVyLnNldFZhbHVlKG1vZGVsKTsKLQotCQlidWlsZEVkaXRhYmxlQ29tYm9Nb2RlbEFkYXB0ZXIoKTsKLQkJYXNzZXJ0RmFsc2UoIlRoZSBzZWxlY3RlZCBpdGVtIHdhc24ndCBzdXBwb3NlZCB0byBiZSBtb2RpZmllZCIsIG1vZGVsLmlzU2V0SXRlbUNhbGxlZCgpKTsKLQotCQltb2RlbC5zZXRJdGVtKHNlbGVjdGVkSXRlbSk7Ci0JCWFzc2VydFRydWUoIlRoZSBzZWxlY3RlZCBpdGVtIHdhcyBzdXBwb3NlZCB0byBiZSBtb2RpZmllZCIsIG1vZGVsLmlzU2V0SXRlbUNhbGxlZCgpKTsKLQkJYXNzZXJ0U2FtZSgiVGhlIHNlbGVjdGVkIGl0ZW0gd2Fzbid0IHNldCBwcm9wZXJseSIsIHNlbGVjdGVkSXRlbSwgbW9kZWwuZ2V0SXRlbSgpKTsKLQotCQl0ZXN0U2VsZWN0ZWRJdGVtKHNlbGVjdGVkSXRlbSk7Ci0JCXRlc3RJdGVtcygpOwotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdE5vbk51bGxTdWJqZWN0QmVmb3JlX05vbk51bGxTZWxlY3RlZEl0ZW1BZnRlcl9JdGVtc19SZWFkT25seSgpIHRocm93cyBFeGNlcHRpb24gewotCi0JCUxpc3Q8U2ltcGxlRGlzcGxheWFibGU+IGxpc3QgPSBidWlsZExpc3QoKTsKLQkJU2ltcGxlRGlzcGxheWFibGUgc2VsZWN0ZWRJdGVtID0gbGlzdC5nZXQoMCk7Ci0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCi0JCWJ1aWxkUmVhZE9ubHlDb21ib01vZGVsQWRhcHRlcigpOwotCQlhc3NlcnRGYWxzZSgiVGhlIHNlbGVjdGVkIGl0ZW0gd2Fzbid0IHN1cHBvc2VkIHRvIGJlIG1vZGlmaWVkIiwgbW9kZWwuaXNTZXRJdGVtQ2FsbGVkKCkpOwotCi0JCW1vZGVsLnNldEl0ZW0oc2VsZWN0ZWRJdGVtKTsKLQkJYXNzZXJ0VHJ1ZSgiVGhlIHNlbGVjdGVkIGl0ZW0gd2FzIHN1cHBvc2VkIHRvIGJlIG1vZGlmaWVkIiwgbW9kZWwuaXNTZXRJdGVtQ2FsbGVkKCkpOwotCQlhc3NlcnRTYW1lKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXNuJ3Qgc2V0IHByb3Blcmx5Iiwgc2VsZWN0ZWRJdGVtLCBtb2RlbC5nZXRJdGVtKCkpOwotCi0JCXRlc3RTZWxlY3RlZEl0ZW0oc2VsZWN0ZWRJdGVtKTsKLQkJdGVzdEl0ZW1zKCk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0Tm9uTnVsbFN1YmplY3RCZWZvcmVfTm9uTnVsbFNlbGVjdGVkSXRlbUFmdGVyX1JlYWRPbmx5KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJTGlzdDxTaW1wbGVEaXNwbGF5YWJsZT4gbGlzdCA9IGJ1aWxkTGlzdCgpOwotCQlTaW1wbGVEaXNwbGF5YWJsZSBzZWxlY3RlZEl0ZW0gPSBsaXN0LmdldCgwKTsKLQkJc3ViamVjdEhvbGRlci5zZXRWYWx1ZShtb2RlbCk7Ci0KLQkJYnVpbGRSZWFkT25seUNvbWJvTW9kZWxBZGFwdGVyKCk7Ci0JCWFzc2VydEZhbHNlKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXNuJ3Qgc3VwcG9zZWQgdG8gYmUgbW9kaWZpZWQiLCBtb2RlbC5pc1NldEl0ZW1DYWxsZWQoKSk7Ci0KLQkJbW9kZWwuc2V0SXRlbShzZWxlY3RlZEl0ZW0pOwotCQlhc3NlcnRUcnVlKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXMgc3VwcG9zZWQgdG8gYmUgbW9kaWZpZWQiLCBtb2RlbC5pc1NldEl0ZW1DYWxsZWQoKSk7Ci0JCWFzc2VydFNhbWUoIlRoZSBzZWxlY3RlZCBpdGVtIHdhc24ndCBzZXQgcHJvcGVybHkiLCBzZWxlY3RlZEl0ZW0sIG1vZGVsLmdldEl0ZW0oKSk7Ci0KLQkJdGVzdFNlbGVjdGVkSXRlbShzZWxlY3RlZEl0ZW0pOwotCQl0ZXN0SXRlbXMoKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROb25OdWxsU3ViamVjdEJlZm9yZV9Ob25OdWxsU2VsZWN0ZWRJdGVtQmVmb3JlX0VkaXRhYmxlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJbW9kZWwuYWRkSXRlbXMoYnVpbGRMaXN0KCkpOwotCQlTaW1wbGVEaXNwbGF5YWJsZSBzZWxlY3RlZEl0ZW0gPSBtb2RlbC5pdGVtQXQoMCk7Ci0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCi0JCW1vZGVsLnNldEl0ZW0oc2VsZWN0ZWRJdGVtKTsKLQkJYXNzZXJ0VHJ1ZSgiVGhlIHNlbGVjdGVkIGl0ZW0gd2FzIHN1cHBvc2VkIHRvIGJlIG1vZGlmaWVkIiwgbW9kZWwuaXNTZXRJdGVtQ2FsbGVkKCkpOwotCQlhc3NlcnRTYW1lKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXNuJ3Qgc2V0IHByb3Blcmx5Iiwgc2VsZWN0ZWRJdGVtLCBtb2RlbC5nZXRJdGVtKCkpOwotCi0JCW1vZGVsLmNsZWFySXRlbUNhbGxlZEZsYWcoKTsKLQkJYnVpbGRFZGl0YWJsZUNvbWJvTW9kZWxBZGFwdGVyKCk7Ci0JCWFzc2VydEZhbHNlKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXNuJ3Qgc3VwcG9zZWQgdG8gYmUgbW9kaWZpZWQiLCBtb2RlbC5pc1NldEl0ZW1DYWxsZWQoKSk7Ci0KLQkJdGVzdFNlbGVjdGVkSXRlbShzZWxlY3RlZEl0ZW0pOwotCQl0ZXN0SXRlbXMoKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROb25OdWxsU3ViamVjdEJlZm9yZV9Ob25OdWxsU2VsZWN0ZWRJdGVtQmVmb3JlX0l0ZW1zX0VkaXRhYmxlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJbW9kZWwuYWRkSXRlbXMoYnVpbGRMaXN0KCkpOwotCQlTaW1wbGVEaXNwbGF5YWJsZSBzZWxlY3RlZEl0ZW0gPSBtb2RlbC5pdGVtQXQoMCk7Ci0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCi0JCW1vZGVsLnNldEl0ZW0oc2VsZWN0ZWRJdGVtKTsKLQkJYXNzZXJ0VHJ1ZSgiVGhlIHNlbGVjdGVkIGl0ZW0gd2FzIHN1cHBvc2VkIHRvIGJlIG1vZGlmaWVkIiwgbW9kZWwuaXNTZXRJdGVtQ2FsbGVkKCkpOwotCQlhc3NlcnRTYW1lKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXNuJ3Qgc2V0IHByb3Blcmx5Iiwgc2VsZWN0ZWRJdGVtLCBtb2RlbC5nZXRJdGVtKCkpOwotCi0JCW1vZGVsLmNsZWFySXRlbUNhbGxlZEZsYWcoKTsKLQkJYnVpbGRFZGl0YWJsZUNvbWJvTW9kZWxBZGFwdGVyKCk7Ci0JCWFzc2VydEZhbHNlKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXNuJ3Qgc3VwcG9zZWQgdG8gYmUgbW9kaWZpZWQiLCBtb2RlbC5pc1NldEl0ZW1DYWxsZWQoKSk7Ci0KLQkJdGVzdFNlbGVjdGVkSXRlbShzZWxlY3RlZEl0ZW0pOwotCQl0ZXN0SXRlbXMoKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROb25OdWxsU3ViamVjdEJlZm9yZV9Ob25OdWxsU2VsZWN0ZWRJdGVtQmVmb3JlX0l0ZW1zX1JlYWRPbmx5KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJTGlzdDxTaW1wbGVEaXNwbGF5YWJsZT4gbGlzdCA9IGJ1aWxkTGlzdCgpOwotCQlTaW1wbGVEaXNwbGF5YWJsZSBzZWxlY3RlZEl0ZW0gPSBsaXN0LmdldCgwKTsKLQkJc3ViamVjdEhvbGRlci5zZXRWYWx1ZShtb2RlbCk7Ci0KLQkJbW9kZWwuc2V0SXRlbShzZWxlY3RlZEl0ZW0pOwotCQlhc3NlcnRUcnVlKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXMgc3VwcG9zZWQgdG8gYmUgbW9kaWZpZWQiLCBtb2RlbC5pc1NldEl0ZW1DYWxsZWQoKSk7Ci0JCWFzc2VydFNhbWUoIlRoZSBzZWxlY3RlZCBpdGVtIHdhc24ndCBzZXQgcHJvcGVybHkiLCBzZWxlY3RlZEl0ZW0sIG1vZGVsLmdldEl0ZW0oKSk7Ci0KLQkJbW9kZWwuY2xlYXJJdGVtQ2FsbGVkRmxhZygpOwotCQlidWlsZFJlYWRPbmx5Q29tYm9Nb2RlbEFkYXB0ZXIoKTsKLQkJYXNzZXJ0RmFsc2UoIlRoZSBzZWxlY3RlZCBpdGVtIHdhc24ndCBzdXBwb3NlZCB0byBiZSBtb2RpZmllZCIsIG1vZGVsLmlzU2V0SXRlbUNhbGxlZCgpKTsKLQotCQl0ZXN0U2VsZWN0ZWRJdGVtKHNlbGVjdGVkSXRlbSk7Ci0JCXRlc3RJdGVtcygpOwotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdE5vbk51bGxTdWJqZWN0QmVmb3JlX05vbk51bGxTZWxlY3RlZEl0ZW1CZWZvcmVfUmVhZE9ubHkoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQlMaXN0PFNpbXBsZURpc3BsYXlhYmxlPiBsaXN0ID0gYnVpbGRMaXN0KCk7Ci0JCVNpbXBsZURpc3BsYXlhYmxlIHNlbGVjdGVkSXRlbSA9IGxpc3QuZ2V0KDApOwotCQlzdWJqZWN0SG9sZGVyLnNldFZhbHVlKG1vZGVsKTsKLQotCQltb2RlbC5zZXRJdGVtKHNlbGVjdGVkSXRlbSk7Ci0JCWFzc2VydFRydWUoIlRoZSBzZWxlY3RlZCBpdGVtIHdhcyBzdXBwb3NlZCB0byBiZSBtb2RpZmllZCIsIG1vZGVsLmlzU2V0SXRlbUNhbGxlZCgpKTsKLQkJYXNzZXJ0U2FtZSgiVGhlIHNlbGVjdGVkIGl0ZW0gd2Fzbid0IHNldCBwcm9wZXJseSIsIHNlbGVjdGVkSXRlbSwgbW9kZWwuZ2V0SXRlbSgpKTsKLQotCQltb2RlbC5jbGVhckl0ZW1DYWxsZWRGbGFnKCk7Ci0JCWJ1aWxkUmVhZE9ubHlDb21ib01vZGVsQWRhcHRlcigpOwotCQlhc3NlcnRGYWxzZSgiVGhlIHNlbGVjdGVkIGl0ZW0gd2Fzbid0IHN1cHBvc2VkIHRvIGJlIG1vZGlmaWVkIiwgbW9kZWwuaXNTZXRJdGVtQ2FsbGVkKCkpOwotCi0JCXRlc3RTZWxlY3RlZEl0ZW0oc2VsZWN0ZWRJdGVtKTsKLQkJdGVzdEl0ZW1zKCk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0Tm9uTnVsbFN1YmplY3RCZWZvcmVfTnVsbFNlbGVjdGVkSXRlbV9JdGVtc19FZGl0YWJsZSgpIHRocm93cyBFeGNlcHRpb24gewotCi0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCi0JCWJ1aWxkRWRpdGFibGVDb21ib01vZGVsQWRhcHRlcigpOwotCi0JCWFzc2VydEZhbHNlKCJUaGUgaXRlbSB3YXNuJ3Qgc3VwcG9zZWQgdG8gYmUgbW9kaWZpZWQiLCBtb2RlbC5pc1NldEl0ZW1DYWxsZWQoKSk7Ci0JCWFzc2VydE51bGwoIlRoZSBzZWxlY3RlZCBpdGVtIGlzIHN1cHBvc2VkIHRvIHJlbWFpbiBudWxsIiwgbW9kZWwuZ2V0SXRlbSgpKTsKLQkJdGVzdFNlbGVjdGVkSXRlbShudWxsKTsKLQkJdGVzdEl0ZW1zKCk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0Tm9uTnVsbFN1YmplY3RCZWZvcmVfTnVsbFNlbGVjdGVkSXRlbV9JdGVtc19SZWFkT25seSgpIHRocm93cyBFeGNlcHRpb24gewotCi0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCi0JCWJ1aWxkRWRpdGFibGVDb21ib01vZGVsQWRhcHRlcigpOwotCi0JCWFzc2VydEZhbHNlKCJUaGUgaXRlbSB3YXNuJ3Qgc3VwcG9zZWQgdG8gYmUgbW9kaWZpZWQiLCBtb2RlbC5pc1NldEl0ZW1DYWxsZWQoKSk7Ci0JCWFzc2VydE51bGwoIlRoZSBzZWxlY3RlZCBpdGVtIGlzIHN1cHBvc2VkIHRvIHJlbWFpbiBudWxsIiwgbW9kZWwuZ2V0SXRlbSgpKTsKLQkJdGVzdFNlbGVjdGVkSXRlbShudWxsKTsKLQkJdGVzdEl0ZW1zKCk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0Tm9uTnVsbFN1YmplY3RCZWZvcmVfTnVsbFNlbGVjdGVkSXRlbV9Ob0l0ZW1zX0VkaXRhYmxlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJc3ViamVjdEhvbGRlci5zZXRWYWx1ZShtb2RlbCk7Ci0KLQkJYnVpbGRFZGl0YWJsZUNvbWJvTW9kZWxBZGFwdGVyKCk7Ci0KLQkJYXNzZXJ0RmFsc2UoIlRoZSBpdGVtIHdhc24ndCBzdXBwb3NlZCB0byBiZSBtb2RpZmllZCIsIG1vZGVsLmlzU2V0SXRlbUNhbGxlZCgpKTsKLQkJYXNzZXJ0TnVsbCgiVGhlIHNlbGVjdGVkIGl0ZW0gaXMgc3VwcG9zZWQgdG8gcmVtYWluIG51bGwiLCBtb2RlbC5nZXRJdGVtKCkpOwotCQl0ZXN0U2VsZWN0ZWRJdGVtKG51bGwpOwotCQl0ZXN0SXRlbXMoKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROb25OdWxsU3ViamVjdEJlZm9yZV9OdWxsU2VsZWN0ZWRJdGVtX05vSXRlbXNfUmVhZE9ubHkoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQlzdWJqZWN0SG9sZGVyLnNldFZhbHVlKG1vZGVsKTsKLQotCQlidWlsZEVkaXRhYmxlQ29tYm9Nb2RlbEFkYXB0ZXIoKTsKLQotCQlhc3NlcnRGYWxzZSgiVGhlIGl0ZW0gd2Fzbid0IHN1cHBvc2VkIHRvIGJlIG1vZGlmaWVkIiwgbW9kZWwuaXNTZXRJdGVtQ2FsbGVkKCkpOwotCQlhc3NlcnROdWxsKCJUaGUgc2VsZWN0ZWQgaXRlbSBpcyBzdXBwb3NlZCB0byByZW1haW4gbnVsbCIsIG1vZGVsLmdldEl0ZW0oKSk7Ci0JCXRlc3RTZWxlY3RlZEl0ZW0obnVsbCk7Ci0JCXRlc3RJdGVtcygpOwotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdE5vbk51bGxTdWJqZWN0QmVmb3JlX1NlbGVjdGVkSXRlbUNoYW5nZWRfRWRpdGFibGUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQltb2RlbC5hZGRJdGVtcyhidWlsZExpc3QoKSk7Ci0KLQkJU2ltcGxlRGlzcGxheWFibGUgc2VsZWN0ZWRJdGVtID0gbW9kZWwuaXRlbUF0KDMpOwotCQlzdWJqZWN0SG9sZGVyLnNldFZhbHVlKG1vZGVsKTsKLQotCQlBYnN0cmFjdENvbWJvTW9kZWxBZGFwdGVyPFNpbXBsZURpc3BsYXlhYmxlPiBhZGFwdGVyID0gYnVpbGRFZGl0YWJsZUNvbWJvTW9kZWxBZGFwdGVyKCk7Ci0JCVNlbGVjdGlvbkxpc3RlbmVyIHNlbGVjdGlvbkxpc3RlbmVyID0gbmV3IFNlbGVjdGlvbkxpc3RlbmVyKCk7Ci0JCWFkYXB0ZXIuYWRkU2VsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoc2VsZWN0aW9uTGlzdGVuZXIpOwotCi0JCWFzc2VydEZhbHNlKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXNuJ3Qgc3VwcG9zZWQgdG8gYmUgbW9kaWZpZWQiLCBtb2RlbC5pc1NldEl0ZW1DYWxsZWQoKSk7Ci0JCXRlc3RTZWxlY3RlZEl0ZW0obnVsbCk7Ci0KLQkJdGVzdFNlbGVjdGVkSXRlbUNoYW5nZWQoc2VsZWN0ZWRJdGVtLCBzZWxlY3Rpb25MaXN0ZW5lcik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHRlc3ROdWxsU3ViamVjdCgpIHRocm93cyBFeGNlcHRpb24gewotCi0JCWFzc2VydE51bGwoIlRoZSBzZWxlY3RlZCBpdGVtIHNob3VsZCBiZSBudWxsIiwgc2VsZWN0ZWRJdGVtSG9sZGVyLmdldFZhbHVlKCkpOwotCi0JCXNlbGVjdGVkSXRlbUhvbGRlci5zZXRWYWx1ZShidWlsZFNlbGVjdGVkSXRlbSgpKTsKLQkJYXNzZXJ0RmFsc2UoIlRoZSBpdGVtIHdhc24ndCBzdXBwb3NlZCB0byBiZSBtb2RpZmllZCIsIG1vZGVsLmlzU2V0SXRlbUNhbGxlZCgpKTsKLQotCQkvLyBOdWxsIGJlY2F1c2UgdGhlIHN1YmplY3QgaG9sZGVyIGRvZXNuJ3QgaGF2ZSB0aGUgc3ViamVjdCBzZXQKLQkJdGVzdFNlbGVjdGVkSXRlbShudWxsKTsKLQkJdGVzdEl0ZW1zKCk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0TnVsbFN1YmplY3RfTnVsbFNlbGVjdGVkSXRlbV9JdGVtc19FZGl0YWJsZSgpIHRocm93cyBFeGNlcHRpb24gewotCQlidWlsZEVkaXRhYmxlQ29tYm9Nb2RlbEFkYXB0ZXIoKTsKLQkJdGVzdE51bGxTdWJqZWN0KCk7Ci0JCXRlc3RJdGVtcygpOwotCQl0ZXN0U2VsZWN0ZWRJdGVtKG51bGwpOwotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdE51bGxTdWJqZWN0X051bGxTZWxlY3RlZEl0ZW1fSXRlbXNfUmVhZE9ubHkoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYnVpbGRSZWFkT25seUNvbWJvTW9kZWxBZGFwdGVyKCk7Ci0JCXRlc3ROdWxsU3ViamVjdCgpOwotCQl0ZXN0SXRlbXMoKTsKLQkJdGVzdFNlbGVjdGVkSXRlbShudWxsKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROdWxsU3ViamVjdF9OdWxsU2VsZWN0ZWRJdGVtX05vSXRlbXNfRWRpdGFibGUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYnVpbGRFZGl0YWJsZUNvbWJvTW9kZWxBZGFwdGVyKCk7Ci0JCXRlc3ROdWxsU3ViamVjdCgpOwotCQl0ZXN0SXRlbXMoKTsKLQkJdGVzdFNlbGVjdGVkSXRlbShudWxsKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3ROdWxsU3ViamVjdF9OdWxsU2VsZWN0ZWRJdGVtX05vSXRlbXNfUmVhZE9ubHkoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYnVpbGRSZWFkT25seUNvbWJvTW9kZWxBZGFwdGVyKCk7Ci0JCXRlc3ROdWxsU3ViamVjdCgpOwotCQl0ZXN0SXRlbXMoKTsKLQkJdGVzdFNlbGVjdGVkSXRlbShudWxsKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdGVzdFJlbW92ZUl0ZW1zX0FkZGVkQWZ0ZXIoKSB7Ci0KLQkJc3ViamVjdEhvbGRlci5zZXRWYWx1ZShtb2RlbCk7Ci0JCW1vZGVsLmFkZEl0ZW1zKGJ1aWxkTGlzdCgpKTsKLQotCQl0ZXN0U2VsZWN0ZWRJdGVtKG51bGwpOwotCQl0ZXN0SXRlbXMoKTsKLQkJdGVzdFNlbGVjdGVkSXRlbShudWxsKTsKLQotCQlBcnJheUxpc3Q8U2ltcGxlRGlzcGxheWFibGU+IGl0ZW1zID0gbmV3IEFycmF5TGlzdDxTaW1wbGVEaXNwbGF5YWJsZT4oKTsKLQkJaXRlbXMuYWRkKG1vZGVsLml0ZW1BdCgwKSk7Ci0JCWl0ZW1zLmFkZChtb2RlbC5pdGVtQXQoMykpOwotCQltb2RlbC5yZW1vdmVJdGVtcyhpdGVtcy5pdGVyYXRvcigpKTsKLQotCQl0ZXN0SXRlbXMoKTsKLQkJdGVzdFNlbGVjdGVkSXRlbShudWxsKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdGVzdFNlbGVjdGVkSXRlbShTaW1wbGVEaXNwbGF5YWJsZSBzZWxlY3RlZEl0ZW0pIHsKLQotCQlpZiAoc2VsZWN0ZWRJdGVtID09IG51bGwpIHsKLQotCQkJYXNzZXJ0TnVsbCgKLQkJCQkiVGhlIHNlbGVjdGVkIGl0ZW0gaXMgc3VwcG9zZWQgdG8gYmUgbnVsbCIsCi0JCQkJbW9kZWwuZ2V0SXRlbSgpCi0JCQkpOwotCi0JCQlhc3NlcnRFcXVhbHMoCi0JCQkJIlRoZSBjb21ibydzIHNlbGVjdGVkIGl0ZW0gc2hvdWxkIGJlIG51bGwiLAotCQkJCSIiLAotCQkJCWNvbWJvU2VsZWN0ZWRJdGVtKCkKLQkJCSk7Ci0JCX0KLQkJZWxzZSBpZiAoIWVtcHR5Q29tYm9DYW5IYXZlU2VsZWN0ZWRWYWx1ZSgpKSB7Ci0KLQkJCWFzc2VydEVxdWFscygKLQkJCQkiVGhlIHNlbGVjdGVkIGl0ZW0gd2Fzbid0IHNldCBjb3JyZWN0bHkiLAotCQkJCXNlbGVjdGVkSXRlbSwKLQkJCQltb2RlbC5nZXRJdGVtKCkKLQkJCSk7Ci0KLQkJCWFzc2VydEVxdWFscygKLQkJCQkiVGhlIGNvbWJvJ3Mgc2VsZWN0ZWQgaXRlbSBzaG91bGQgYmUgbnVsbCIsCi0JCQkJIiIsCi0JCQkJY29tYm9TZWxlY3RlZEl0ZW0oKQotCQkJKTsKLQkJfQotCQllbHNlIHsKLQotCQkJYXNzZXJ0RXF1YWxzKAotCQkJCSJUaGUgc2VsZWN0ZWQgaXRlbSB3YXNuJ3Qgc2V0IGNvcnJlY3RseSIsCi0JCQkJc2VsZWN0ZWRJdGVtLAotCQkJCW1vZGVsLmdldEl0ZW0oKQotCQkJKTsKLQotCQkJYXNzZXJ0RXF1YWxzKAotCQkJCSJUaGUgc2VsZWN0ZWQgaXRlbSB3YXNuJ3Qgc2V0IGNvcnJlY3RseSIsCi0JCQkJc2VsZWN0ZWRJdGVtLmRpc3BsYXlTdHJpbmcoKSwKLQkJCQljb21ib1NlbGVjdGVkSXRlbSgpCi0JCQkpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHRlc3RTZWxlY3RlZEl0ZW1DaGFuZ2VkKFNpbXBsZURpc3BsYXlhYmxlIHNlbGVjdGVkSXRlbSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU2VsZWN0aW9uTGlzdGVuZXIgc2VsZWN0aW9uTGlzdGVuZXIpIHsKLQotCQkvLyBUZXN0IDEKLQkJbW9kZWwuc2V0SXRlbShzZWxlY3RlZEl0ZW0pOwotCQlhc3NlcnRUcnVlKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXMgc3VwcG9zZWQgdG8gYmUgbW9kaWZpZWQiLCBtb2RlbC5pc1NldEl0ZW1DYWxsZWQoKSk7Ci0JCWFzc2VydFNhbWUoIlRoZSBzZWxlY3RlZCBpdGVtIHdhc24ndCBzZXQgcHJvcGVybHkiLCBzZWxlY3RlZEl0ZW0sIG1vZGVsLmdldEl0ZW0oKSk7Ci0JCWFzc2VydFRydWUoIlRoZSBTZWxlY3Rpb25MaXN0ZW5lciB3YXMgc3VwcG9zZWQgdG8gYmUgbm90aWZpZWQiLCBzZWxlY3Rpb25MaXN0ZW5lci5pc0xpc3RlbmVyTm90aWZpZWQoKSk7Ci0JCWFzc2VydFNhbWUoIlRoZSBTZWxlY3Rpb25MaXN0ZW5lciB3YXMgc3VwcG9zZWQgdG8gYmUgbm90aWZpZWQiLCBzZWxlY3RlZEl0ZW0sIHNlbGVjdGlvbkxpc3RlbmVyLmdldEl0ZW0oKSk7Ci0JCXRlc3RTZWxlY3RlZEl0ZW0oc2VsZWN0ZWRJdGVtKTsKLQotCQkvLyBUZXN0IDIKLQkJc2VsZWN0ZWRJdGVtID0gbW9kZWwuaXRlbUF0KDEpOwotCQltb2RlbC5jbGVhckl0ZW1DYWxsZWRGbGFnKCk7Ci0JCXNlbGVjdGlvbkxpc3RlbmVyLmNsZWFySW5mbygpOwotCi0JCW1vZGVsLnNldEl0ZW0oc2VsZWN0ZWRJdGVtKTsKLQkJYXNzZXJ0VHJ1ZSgiVGhlIHNlbGVjdGVkIGl0ZW0gd2FzIHN1cHBvc2VkIHRvIGJlIG1vZGlmaWVkIiwgbW9kZWwuaXNTZXRJdGVtQ2FsbGVkKCkpOwotCQlhc3NlcnRTYW1lKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXNuJ3Qgc2V0IHByb3Blcmx5Iiwgc2VsZWN0ZWRJdGVtLCBtb2RlbC5nZXRJdGVtKCkpOwotCQlhc3NlcnRUcnVlKCJUaGUgU2VsZWN0aW9uTGlzdGVuZXIgd2FzIHN1cHBvc2VkIHRvIGJlIG5vdGlmaWVkIiwgc2VsZWN0aW9uTGlzdGVuZXIuaXNMaXN0ZW5lck5vdGlmaWVkKCkpOwotCQlhc3NlcnRTYW1lKCJUaGUgU2VsZWN0aW9uTGlzdGVuZXIgd2FzIHN1cHBvc2VkIHRvIGJlIG5vdGlmaWVkIiwgc2VsZWN0ZWRJdGVtLCBzZWxlY3Rpb25MaXN0ZW5lci5nZXRJdGVtKCkpOwotCQl0ZXN0U2VsZWN0ZWRJdGVtKHNlbGVjdGVkSXRlbSk7Ci0KLQkJLy8gVGVzdCAzCi0JCXNlbGVjdGVkSXRlbSA9IG51bGw7Ci0JCW1vZGVsLmNsZWFySXRlbUNhbGxlZEZsYWcoKTsKLQkJc2VsZWN0aW9uTGlzdGVuZXIuY2xlYXJJbmZvKCk7Ci0KLQkJbW9kZWwuc2V0SXRlbShzZWxlY3RlZEl0ZW0pOwotCQlhc3NlcnRUcnVlKCJUaGUgc2VsZWN0ZWQgaXRlbSB3YXMgc3VwcG9zZWQgdG8gYmUgbW9kaWZpZWQiLCBtb2RlbC5pc1NldEl0ZW1DYWxsZWQoKSk7Ci0JCWFzc2VydE51bGwoIlRoZSBzZWxlY3RlZCBpdGVtIHdhc24ndCBzZXQgcHJvcGVybHkiLCBtb2RlbC5nZXRJdGVtKCkpOwotCQlhc3NlcnRUcnVlKCJUaGUgU2VsZWN0aW9uTGlzdGVuZXIgd2FzIHN1cHBvc2VkIHRvIGJlIG5vdGlmaWVkIiwgc2VsZWN0aW9uTGlzdGVuZXIuaXNMaXN0ZW5lck5vdGlmaWVkKCkpOwotCQlhc3NlcnRTYW1lKCJUaGUgU2VsZWN0aW9uTGlzdGVuZXIgd2FzIHN1cHBvc2VkIHRvIGJlIG5vdGlmaWVkIiwgc2VsZWN0ZWRJdGVtLCBzZWxlY3Rpb25MaXN0ZW5lci5nZXRJdGVtKCkpOwotCQl0ZXN0U2VsZWN0ZWRJdGVtKHNlbGVjdGVkSXRlbSk7Ci0KLQkJLy8gVGVzdCAzCi0JCXNlbGVjdGVkSXRlbSA9IG1vZGVsLml0ZW1BdCgyKTsKLQkJbW9kZWwuY2xlYXJJdGVtQ2FsbGVkRmxhZygpOwotCQlzZWxlY3Rpb25MaXN0ZW5lci5jbGVhckluZm8oKTsKLQotCQltb2RlbC5zZXRJdGVtKHNlbGVjdGVkSXRlbSk7Ci0JCWFzc2VydFRydWUoIlRoZSBzZWxlY3RlZCBpdGVtIHdhcyBzdXBwb3NlZCB0byBiZSBtb2RpZmllZCIsIG1vZGVsLmlzU2V0SXRlbUNhbGxlZCgpKTsKLQkJYXNzZXJ0U2FtZSgiVGhlIHNlbGVjdGVkIGl0ZW0gd2Fzbid0IHNldCBwcm9wZXJseSIsIHNlbGVjdGVkSXRlbSwgbW9kZWwuZ2V0SXRlbSgpKTsKLQkJYXNzZXJ0VHJ1ZSgiVGhlIFNlbGVjdGlvbkxpc3RlbmVyIHdhcyBzdXBwb3NlZCB0byBiZSBub3RpZmllZCIsIHNlbGVjdGlvbkxpc3RlbmVyLmlzTGlzdGVuZXJOb3RpZmllZCgpKTsKLQkJYXNzZXJ0U2FtZSgiVGhlIFNlbGVjdGlvbkxpc3RlbmVyIHdhcyBzdXBwb3NlZCB0byBiZSBub3RpZmllZCIsIHNlbGVjdGVkSXRlbSwgc2VsZWN0aW9uTGlzdGVuZXIuZ2V0SXRlbSgpKTsKLQkJdGVzdFNlbGVjdGVkSXRlbShzZWxlY3RlZEl0ZW0pOwotCX0KLQotCXByaXZhdGUgc3RhdGljIGNsYXNzIE1vZGVsIGV4dGVuZHMgQWJzdHJhY3RNb2RlbCB7Ci0KLQkJcHJpdmF0ZSBTaW1wbGVEaXNwbGF5YWJsZSBpdGVtOwotCQlwcml2YXRlIExpc3Q8U2ltcGxlRGlzcGxheWFibGU+IGl0ZW1zID0gbmV3IEFycmF5TGlzdDxTaW1wbGVEaXNwbGF5YWJsZT4oKTsKLQkJcHJpdmF0ZSBib29sZWFuIHNldEl0ZW1DYWxsZWQ7Ci0KLQkJc3RhdGljIGZpbmFsIFN0cmluZyBJVEVNX1BST1BFUlRZID0gIml0ZW0iOwotCQlzdGF0aWMgZmluYWwgU3RyaW5nIElURU1TX0xJU1QgPSAiaXRlbXMiOwotCi0JCXZvaWQgYWRkSXRlbXMoSXRlcmF0b3I8U2ltcGxlRGlzcGxheWFibGU+IGl0ZW1zKSB7Ci0JCQlhZGRJdGVtc1RvTGlzdChpdGVtcywgdGhpcy5pdGVtcywgSVRFTVNfTElTVCk7Ci0JCX0KLQotCQl2b2lkIGFkZEl0ZW1zKExpc3Q8U2ltcGxlRGlzcGxheWFibGU+IGl0ZW1zKSB7Ci0JCQlhZGRJdGVtc1RvTGlzdChpdGVtcywgdGhpcy5pdGVtcywgSVRFTVNfTElTVCk7Ci0JCX0KLQotCQl2b2lkIGNsZWFySXRlbUNhbGxlZEZsYWcoKSB7Ci0JCQlzZXRJdGVtQ2FsbGVkID0gZmFsc2U7Ci0JCX0KLQotCQlTaW1wbGVEaXNwbGF5YWJsZSBnZXRJdGVtKCkgewotCQkJcmV0dXJuIGl0ZW07Ci0JCX0KLQotCQlib29sZWFuIGlzU2V0SXRlbUNhbGxlZCgpIHsKLQkJCXJldHVybiBzZXRJdGVtQ2FsbGVkOwotCQl9Ci0KLQkJU2ltcGxlRGlzcGxheWFibGUgaXRlbUF0KGludCBpbmRleCkgewotCQkJcmV0dXJuIHRoaXMuaXRlbXMuZ2V0KGluZGV4KTsKLQkJfQotCi0JCUxpc3RJdGVyYXRvcjxTaW1wbGVEaXNwbGF5YWJsZT4gaXRlbXMoKSB7Ci0JCQlyZXR1cm4gaXRlbXMubGlzdEl0ZXJhdG9yKCk7Ci0JCX0KLQotCQlpbnQgaXRlbXNTaXplKCkgewotCQkJcmV0dXJuIGl0ZW1zLnNpemUoKTsKLQkJfQotCi0JCXZvaWQgcmVtb3ZlSXRlbXMoSXRlcmF0b3I8U2ltcGxlRGlzcGxheWFibGU+IGl0ZW1zKSB7Ci0JCQlyZW1vdmVJdGVtc0Zyb21MaXN0KGl0ZW1zLCB0aGlzLml0ZW1zLCBJVEVNU19MSVNUKTsKLQkJfQotCi0JCXZvaWQgc2V0SXRlbShTaW1wbGVEaXNwbGF5YWJsZSBpdGVtKSB7Ci0JCQlzZXRJdGVtQ2FsbGVkID0gdHJ1ZTsKLQotCQkJU2ltcGxlRGlzcGxheWFibGUgb2xkSXRlbSA9IHRoaXMuaXRlbTsKLQkJCXRoaXMuaXRlbSA9IGl0ZW07Ci0JCQlmaXJlUHJvcGVydHlDaGFuZ2VkKElURU1fUFJPUEVSVFksIG9sZEl0ZW0sIGl0ZW0pOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBjbGFzcyBTZWxlY3Rpb25MaXN0ZW5lciBpbXBsZW1lbnRzIFNlbGVjdGlvbkNoYW5nZUxpc3RlbmVyPFNpbXBsZURpc3BsYXlhYmxlPiB7Ci0KLQkJcHJpdmF0ZSBTaW1wbGVEaXNwbGF5YWJsZSBpdGVtOwotCQlwcml2YXRlIGJvb2xlYW4gbGlzdGVuZXJOb3RpZmllZDsKLQotCQl2b2lkIGNsZWFySW5mbygpIHsKLQkJCXRoaXMubGlzdGVuZXJOb3RpZmllZCA9IGZhbHNlOwotCQkJdGhpcy5pdGVtID0gbnVsbDsKLQkJfQotCi0JCVNpbXBsZURpc3BsYXlhYmxlIGdldEl0ZW0oKSB7Ci0JCQlyZXR1cm4gaXRlbTsKLQkJfQotCi0JCXB1YmxpYyBib29sZWFuIGlzTGlzdGVuZXJOb3RpZmllZCgpIHsKLQkJCXJldHVybiBsaXN0ZW5lck5vdGlmaWVkOwotCQl9Ci0KLQkJcHVibGljIHZvaWQgc2VsZWN0aW9uQ2hhbmdlZChTZWxlY3Rpb25DaGFuZ2VFdmVudDxTaW1wbGVEaXNwbGF5YWJsZT4gZSkgewotCQkJbGlzdGVuZXJOb3RpZmllZCA9IHRydWU7Ci0JCQlpdGVtID0gZS5zZWxlY3RlZEl0ZW0oKTsKLQkJfQotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC9zd3QvQ0NvbWJvTW9kZWxBZGFwdGVyVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3N3dC9DQ29tYm9Nb2RlbEFkYXB0ZXJUZXN0LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDRjZjE0M2UuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3N3dC9DQ29tYm9Nb2RlbEFkYXB0ZXJUZXN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw3NSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzLmludGVybmFsLnN3dDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5zd3QuQWJzdHJhY3RDb21ib01vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuc3d0LkNDb21ib01vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZy5TaW1wbGVEaXNwbGF5YWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuU1dUOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5jdXN0b20uQ0NvbWJvOwotaW1wb3J0IG9yZy5qdW5pdC5BZnRlcjsKLQotcHVibGljIGNsYXNzIENDb21ib01vZGVsQWRhcHRlclRlc3QgZXh0ZW5kcyBBYnN0cmFjdENvbWJvTW9kZWxBZGFwdGVyVGVzdCB7Ci0KLQlwcml2YXRlIENDb21ibyBjb21ibzsKLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBBYnN0cmFjdENvbWJvTW9kZWxBZGFwdGVyPFNpbXBsZURpc3BsYXlhYmxlPiBidWlsZEVkaXRhYmxlQ29tYm9Nb2RlbEFkYXB0ZXIoKSB7Ci0KLQkJY29tYm8gPSBuZXcgQ0NvbWJvKHNoZWxsKCksIFNXVC5OVUxMKTsKLQotCQlyZXR1cm4gQ0NvbWJvTW9kZWxBZGFwdGVyLmFkYXB0KAotCQkJYnVpbGRMaXN0SG9sZGVyKCksCi0JCQlzZWxlY3RlZEl0ZW1Ib2xkZXIoKSwKLQkJCWNvbWJvLAotCQkJYnVpbGRTdHJpbmdDb252ZXJ0ZXIoKQotCQkpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBBYnN0cmFjdENvbWJvTW9kZWxBZGFwdGVyPFNpbXBsZURpc3BsYXlhYmxlPiBidWlsZFJlYWRPbmx5Q29tYm9Nb2RlbEFkYXB0ZXIoKSB7Ci0KLQkJY29tYm8gPSBuZXcgQ0NvbWJvKHNoZWxsKCksIFNXVC5SRUFEX09OTFkpOwotCi0JCXJldHVybiBDQ29tYm9Nb2RlbEFkYXB0ZXIuYWRhcHQoCi0JCQlidWlsZExpc3RIb2xkZXIoKSwKLQkJCXNlbGVjdGVkSXRlbUhvbGRlcigpLAotCQkJY29tYm8sCi0JCQlidWlsZFN0cmluZ0NvbnZlcnRlcigpCi0JCSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIFN0cmluZyBjb21ib1NlbGVjdGVkSXRlbSgpIHsKLQkJcmV0dXJuIGNvbWJvLmdldFRleHQoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgYm9vbGVhbiBlbXB0eUNvbWJvQ2FuSGF2ZVNlbGVjdGVkVmFsdWUoKSB7Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgaXRlbUF0KGludCBpbmRleCkgewotCQlyZXR1cm4gdGhpcy5jb21iby5nZXRJdGVtKGluZGV4KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgaW50IGl0ZW1Db3VudHMoKSB7Ci0JCXJldHVybiBjb21iby5nZXRJdGVtQ291bnQoKTsKLQl9Ci0KLQlAQWZ0ZXIKLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci50ZWFyRG93bigpOwotCQljb21ibyA9IG51bGw7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3N3dC9DaGVja0JveE1vZGVsQWRhcHRlclVJVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3N3dC9DaGVja0JveE1vZGVsQWRhcHRlclVJVGVzdC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkMmNmMTM5Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC9zd3QvQ2hlY2tCb3hNb2RlbEFkYXB0ZXJVSVRlc3QuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDMxOCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy5pbnRlcm5hbC5zd3Q7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS5hY3Rpb24uQWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLmFjdGlvbi5BY3Rpb25Db250cmlidXRpb25JdGVtOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLmFjdGlvbi5JQWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLndpbmRvdy5BcHBsaWNhdGlvbldpbmRvdzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS53aW5kb3cuV2luZG93OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5zd3QuQm9vbGVhbkJ1dHRvbk1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5DbGFzc1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LlNXVDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuZXZlbnRzLlNlbGVjdGlvbkV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5ldmVudHMuU2VsZWN0aW9uTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5GaWxsTGF5b3V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuRm9ybUF0dGFjaG1lbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5Gb3JtRGF0YTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkZvcm1MYXlvdXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQnV0dG9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db250cm9sOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkRpc3BsYXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuU2hlbGw7Ci0KLS8qKgotICogUGxheSBhcm91bmQgd2l0aCBhIHNldCBvZiBjaGVjayBib3hlcy4KLSAqLwotcHVibGljIGNsYXNzIENoZWNrQm94TW9kZWxBZGFwdGVyVUlUZXN0Ci0JZXh0ZW5kcyBBcHBsaWNhdGlvbldpbmRvdwotewotCXByaXZhdGUgZmluYWwgVGVzdE1vZGVsIHRlc3RNb2RlbDsKLQlwcml2YXRlIGZpbmFsIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4gdGVzdE1vZGVsSG9sZGVyOwotCXByaXZhdGUgZmluYWwgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gZmxhZzFIb2xkZXI7Ci0JcHJpdmF0ZSBmaW5hbCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBmbGFnMkhvbGRlcjsKLQlwcml2YXRlIGZpbmFsIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IG5vdEZsYWcySG9sZGVyOwotCi0JcHVibGljIHN0YXRpYyB2b2lkIG1haW4oU3RyaW5nW10gYXJncykgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVdpbmRvdyB3aW5kb3cgPSBuZXcgQ2hlY2tCb3hNb2RlbEFkYXB0ZXJVSVRlc3QoYXJncyk7Ci0JCXdpbmRvdy5zZXRCbG9ja09uT3Blbih0cnVlKTsKLQkJd2luZG93Lm9wZW4oKTsKLQkJRGlzcGxheS5nZXRDdXJyZW50KCkuZGlzcG9zZSgpOwotCQlTeXN0ZW0uZXhpdCgwKTsKLQl9Ci0KLQlwcml2YXRlIENoZWNrQm94TW9kZWxBZGFwdGVyVUlUZXN0KFN0cmluZ1tdIGFyZ3MpIHsKLQkJc3VwZXIobnVsbCk7Ci0JCXRoaXMudGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCh0cnVlLCB0cnVlKTsKLQkJdGhpcy50ZXN0TW9kZWxIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4odGhpcy50ZXN0TW9kZWwpOwotCQl0aGlzLmZsYWcxSG9sZGVyID0gdGhpcy5idWlsZEZsYWcxSG9sZGVyKHRoaXMudGVzdE1vZGVsSG9sZGVyKTsKLQkJdGhpcy5mbGFnMkhvbGRlciA9IHRoaXMuYnVpbGRGbGFnMkhvbGRlcih0aGlzLnRlc3RNb2RlbEhvbGRlcik7Ci0JCXRoaXMubm90RmxhZzJIb2xkZXIgPSB0aGlzLmJ1aWxkTm90RmxhZzJIb2xkZXIodGhpcy50ZXN0TW9kZWxIb2xkZXIpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRGbGFnMUhvbGRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdE1vZGVsPiBzdWJqZWN0SG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFRlc3RNb2RlbCwgQm9vbGVhbj4oc3ViamVjdEhvbGRlciwgVGVzdE1vZGVsLkZMQUcxX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBCb29sZWFuLnZhbHVlT2YodGhpcy5zdWJqZWN0LmlzRmxhZzEoKSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldEZsYWcxKHZhbHVlLmJvb2xlYW5WYWx1ZSgpKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkRmxhZzJIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4gc3ViamVjdEhvbGRlcikgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxUZXN0TW9kZWwsIEJvb2xlYW4+KHN1YmplY3RIb2xkZXIsIFRlc3RNb2RlbC5GTEFHMl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gQm9vbGVhbi52YWx1ZU9mKHRoaXMuc3ViamVjdC5pc0ZsYWcyKCkpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCXRoaXMuc3ViamVjdC5zZXRGbGFnMih2YWx1ZS5ib29sZWFuVmFsdWUoKSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZE5vdEZsYWcySG9sZGVyKFByb3BlcnR5VmFsdWVNb2RlbDxUZXN0TW9kZWw+IHN1YmplY3RIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VGVzdE1vZGVsLCBCb29sZWFuPihzdWJqZWN0SG9sZGVyLCBUZXN0TW9kZWwuTk9UX0ZMQUcyX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBCb29sZWFuLnZhbHVlT2YodGhpcy5zdWJqZWN0LmlzTm90RmxhZzIoKSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldE5vdEZsYWcyKHZhbHVlLmJvb2xlYW5WYWx1ZSgpKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgQ29udHJvbCBjcmVhdGVDb250ZW50cyhDb21wb3NpdGUgcGFyZW50KSB7Ci0JCSgoU2hlbGwpIHBhcmVudCkuc2V0VGV4dChDbGFzc1Rvb2xzLnNob3J0Q2xhc3NOYW1lRm9yT2JqZWN0KHRoaXMpKTsKLQkJcGFyZW50LnNldFNpemUoNDAwLCAxMDApOwotCQlDb21wb3NpdGUgbWFpblBhbmVsID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OT05FKTsKLQkJbWFpblBhbmVsLnNldExheW91dChuZXcgRm9ybUxheW91dCgpKTsKLQkJQ29udHJvbCBjaGVja0JveFBhbmVsID0gdGhpcy5idWlsZENoZWNrQm94UGFuZWwobWFpblBhbmVsKTsKLQkJdGhpcy5idWlsZENvbnRyb2xQYW5lbChtYWluUGFuZWwsIGNoZWNrQm94UGFuZWwpOwotCQlyZXR1cm4gbWFpblBhbmVsOwotCX0KLQotCXByaXZhdGUgQ29udHJvbCBidWlsZENoZWNrQm94UGFuZWwoQ29tcG9zaXRlIHBhcmVudCkgewotCQlDb21wb3NpdGUgcGFuZWwgPSBuZXcgQ29tcG9zaXRlKHBhcmVudCwgU1dULk5PTkUpOwotCi0JCUZvcm1EYXRhIGZkID0gbmV3IEZvcm1EYXRhKCk7Ci0JCQlmZC50b3AgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMCk7Ci0JCQlmZC5ib3R0b20gPSBuZXcgRm9ybUF0dGFjaG1lbnQoMTAwLCAtMzUpOwotCQkJZmQubGVmdCA9IG5ldyBGb3JtQXR0YWNobWVudCgwKTsKLQkJCWZkLnJpZ2h0ID0gbmV3IEZvcm1BdHRhY2htZW50KDEwMCk7Ci0JCXBhbmVsLnNldExheW91dERhdGEoZmQpOwotCi0JCXBhbmVsLnNldExheW91dChuZXcgRmlsbExheW91dCgpKTsKLQkJdGhpcy5idWlsZEZsYWcxQ2hlY2tCb3gocGFuZWwpOwotCQl0aGlzLmJ1aWxkRmxhZzJDaGVja0JveChwYW5lbCk7Ci0JCXRoaXMuYnVpbGROb3RGbGFnMkNoZWNrQm94KHBhbmVsKTsKLQkJdGhpcy5idWlsZFVuYXR0YWNoZWRDaGVja0JveChwYW5lbCk7Ci0KLQkJcmV0dXJuIHBhbmVsOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZEZsYWcxQ2hlY2tCb3goQ29tcG9zaXRlIHBhcmVudCkgewotCQlCdXR0b24gY2hlY2tCb3ggPSBuZXcgQnV0dG9uKHBhcmVudCwgU1dULkNIRUNLKTsKLQkJY2hlY2tCb3guc2V0VGV4dCgiZmxhZyAxIik7Ci0JCUJvb2xlYW5CdXR0b25Nb2RlbEFkYXB0ZXIuYWRhcHQodGhpcy5mbGFnMUhvbGRlciwgY2hlY2tCb3gpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZEZsYWcyQ2hlY2tCb3goQ29tcG9zaXRlIHBhcmVudCkgewotCQlCdXR0b24gY2hlY2tCb3ggPSBuZXcgQnV0dG9uKHBhcmVudCwgU1dULkNIRUNLKTsKLQkJY2hlY2tCb3guc2V0VGV4dCgiZmxhZyAyIik7Ci0JCUJvb2xlYW5CdXR0b25Nb2RlbEFkYXB0ZXIuYWRhcHQodGhpcy5mbGFnMkhvbGRlciwgY2hlY2tCb3gpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZE5vdEZsYWcyQ2hlY2tCb3goQ29tcG9zaXRlIHBhcmVudCkgewotCQlCdXR0b24gY2hlY2tCb3ggPSBuZXcgQnV0dG9uKHBhcmVudCwgU1dULkNIRUNLKTsKLQkJY2hlY2tCb3guc2V0VGV4dCgibm90IGZsYWcgMiIpOwotCQlCb29sZWFuQnV0dG9uTW9kZWxBZGFwdGVyLmFkYXB0KHRoaXMubm90RmxhZzJIb2xkZXIsIGNoZWNrQm94KTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRVbmF0dGFjaGVkQ2hlY2tCb3goQ29tcG9zaXRlIHBhcmVudCkgewotCQlCdXR0b24gY2hlY2tCb3ggPSBuZXcgQnV0dG9uKHBhcmVudCwgU1dULkNIRUNLKTsKLQkJY2hlY2tCb3guc2V0VGV4dCgidW5hdHRhY2hlZCIpOwotCQljaGVja0JveC5hZGRTZWxlY3Rpb25MaXN0ZW5lcih0aGlzLmJ1aWxkVW5hdHRhY2hlZFNlbGVjdGlvbkxpc3RlbmVyKCkpOwotCX0KLQotCXByaXZhdGUgU2VsZWN0aW9uTGlzdGVuZXIgYnVpbGRVbmF0dGFjaGVkU2VsZWN0aW9uTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgU2VsZWN0aW9uTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCB3aWRnZXREZWZhdWx0U2VsZWN0ZWQoU2VsZWN0aW9uRXZlbnQgZSkgewotCQkJCVN5c3RlbS5vdXQucHJpbnRsbigidW5hdHRhY2hlZCBkZWZhdWx0IHNlbGVjdGVkOiAiICsgZSk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCB3aWRnZXRTZWxlY3RlZChTZWxlY3Rpb25FdmVudCBlKSB7Ci0JCQkJU3lzdGVtLm91dC5wcmludGxuKCJ1bmF0dGFjaGVkIHNlbGVjdGVkOiAiICsgZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGJ1aWxkQ29udHJvbFBhbmVsKENvbXBvc2l0ZSBwYXJlbnQsIENvbnRyb2wgY2hlY2tCb3hQYW5lbCkgewotCQlDb21wb3NpdGUgcGFuZWwgPSBuZXcgQ29tcG9zaXRlKHBhcmVudCwgU1dULk5PTkUpOwotCQlGb3JtRGF0YSBmZCA9IG5ldyBGb3JtRGF0YSgpOwotCQkJZmQudG9wID0gbmV3IEZvcm1BdHRhY2htZW50KGNoZWNrQm94UGFuZWwpOwotCQkJZmQuYm90dG9tID0gbmV3IEZvcm1BdHRhY2htZW50KDEwMCk7Ci0JCQlmZC5sZWZ0ID0gbmV3IEZvcm1BdHRhY2htZW50KDApOwotCQkJZmQucmlnaHQgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMTAwKTsKLQkJcGFuZWwuc2V0TGF5b3V0RGF0YShmZCk7Ci0KLQkJcGFuZWwuc2V0TGF5b3V0KG5ldyBGaWxsTGF5b3V0KCkpOwotCQl0aGlzLmJ1aWxkRmxpcEZsYWcxQnV0dG9uKHBhbmVsKTsKLQkJdGhpcy5idWlsZE5vdEZsYWcyVG9nZ2xlQnV0dG9uKHBhbmVsKTsKLQkJdGhpcy5idWlsZENsZWFyTW9kZWxCdXR0b24ocGFuZWwpOwotCQl0aGlzLmJ1aWxkUmVzdG9yZU1vZGVsQnV0dG9uKHBhbmVsKTsKLQkJdGhpcy5idWlsZFByaW50TW9kZWxCdXR0b24ocGFuZWwpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZEZsaXBGbGFnMUJ1dHRvbihDb21wb3NpdGUgcGFyZW50KSB7Ci0JCXRoaXMuYnVpbGRGbGlwRmxhZzFBQ0koKS5maWxsKHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb25Db250cmlidXRpb25JdGVtIGJ1aWxkRmxpcEZsYWcxQUNJKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFjdGlvbigiZmxpcCBmbGFnIDEiLCBJQWN0aW9uLkFTX1BVU0hfQlVUVE9OKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlDaGVja0JveE1vZGVsQWRhcHRlclVJVGVzdC50aGlzLmZsaXBGbGFnMSgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0VG9vbFRpcFRleHQoImZsaXAgZmxhZyAxIik7Ci0JCXJldHVybiBuZXcgQWN0aW9uQ29udHJpYnV0aW9uSXRlbShhY3Rpb24pOwotCX0KLQotCXZvaWQgZmxpcEZsYWcxKCkgewotCQl0aGlzLnRlc3RNb2RlbC5zZXRGbGFnMSggISB0aGlzLnRlc3RNb2RlbC5pc0ZsYWcxKCkpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZE5vdEZsYWcyVG9nZ2xlQnV0dG9uKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJQnV0dG9uIGNoZWNrQm94ID0gbmV3IEJ1dHRvbihwYXJlbnQsIFNXVC5UT0dHTEUpOwotCQljaGVja0JveC5zZXRUZXh0KCJub3QgZmxhZyAyIik7Ci0JCUJvb2xlYW5CdXR0b25Nb2RlbEFkYXB0ZXIuYWRhcHQodGhpcy5ub3RGbGFnMkhvbGRlciwgY2hlY2tCb3gpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZENsZWFyTW9kZWxCdXR0b24oQ29tcG9zaXRlIHBhcmVudCkgewotCQl0aGlzLmJ1aWxkQ2xlYXJNb2RlbEFDSSgpLmZpbGwocGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0gYnVpbGRDbGVhck1vZGVsQUNJKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFjdGlvbigiY2xlYXIgbW9kZWwiLCBJQWN0aW9uLkFTX1BVU0hfQlVUVE9OKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlDaGVja0JveE1vZGVsQWRhcHRlclVJVGVzdC50aGlzLmNsZWFyTW9kZWwoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldFRvb2xUaXBUZXh0KCJjbGVhciBtb2RlbCIpOwotCQlyZXR1cm4gbmV3IEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0oYWN0aW9uKTsKLQl9Ci0KLQl2b2lkIGNsZWFyTW9kZWwoKSB7Ci0JCXRoaXMudGVzdE1vZGVsSG9sZGVyLnNldFZhbHVlKG51bGwpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZFJlc3RvcmVNb2RlbEJ1dHRvbihDb21wb3NpdGUgcGFyZW50KSB7Ci0JCXRoaXMuYnVpbGRSZXN0b3JlTW9kZWxBQ0koKS5maWxsKHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb25Db250cmlidXRpb25JdGVtIGJ1aWxkUmVzdG9yZU1vZGVsQUNJKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFjdGlvbigicmVzdG9yZSBtb2RlbCIsIElBY3Rpb24uQVNfUFVTSF9CVVRUT04pIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJCUNoZWNrQm94TW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMucmVzdG9yZU1vZGVsKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRUb29sVGlwVGV4dCgicmVzdG9yZSBtb2RlbCIpOwotCQlyZXR1cm4gbmV3IEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0oYWN0aW9uKTsKLQl9Ci0KLQl2b2lkIHJlc3RvcmVNb2RlbCgpIHsKLQkJdGhpcy50ZXN0TW9kZWxIb2xkZXIuc2V0VmFsdWUodGhpcy50ZXN0TW9kZWwpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZFByaW50TW9kZWxCdXR0b24oQ29tcG9zaXRlIHBhcmVudCkgewotCQl0aGlzLmJ1aWxkUHJpbnRNb2RlbEFDSSgpLmZpbGwocGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0gYnVpbGRQcmludE1vZGVsQUNJKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFjdGlvbigicHJpbnQgbW9kZWwiLCBJQWN0aW9uLkFTX1BVU0hfQlVUVE9OKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlDaGVja0JveE1vZGVsQWRhcHRlclVJVGVzdC50aGlzLnByaW50TW9kZWwoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldFRvb2xUaXBUZXh0KCJwcmludCBtb2RlbCIpOwotCQlyZXR1cm4gbmV3IEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0oYWN0aW9uKTsKLQl9Ci0KLQl2b2lkIHByaW50TW9kZWwoKSB7Ci0JCVN5c3RlbS5vdXQucHJpbnRsbigiZmxhZyAxOiAiICsgdGhpcy50ZXN0TW9kZWwuaXNGbGFnMSgpKTsKLQkJU3lzdGVtLm91dC5wcmludGxuKCJmbGFnIDI6ICIgKyB0aGlzLnRlc3RNb2RlbC5pc0ZsYWcyKCkpOwotCQlTeXN0ZW0ub3V0LnByaW50bG4oIm5vdCBmbGFnIDI6ICIgKyB0aGlzLnRlc3RNb2RlbC5pc05vdEZsYWcyKCkpOwotCQlTeXN0ZW0ub3V0LnByaW50bG4oIioqKiIpOwotCX0KLQotCi0JcHJpdmF0ZSBjbGFzcyBUZXN0TW9kZWwgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIHsKLQkJcHJpdmF0ZSBib29sZWFuIGZsYWcxOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgRkxBRzFfUFJPUEVSVFkgPSAiZmxhZzEiOwotCQlwcml2YXRlIGJvb2xlYW4gZmxhZzI7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBGTEFHMl9QUk9QRVJUWSA9ICJmbGFnMiI7Ci0JCXByaXZhdGUgYm9vbGVhbiBub3RGbGFnMjsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIE5PVF9GTEFHMl9QUk9QRVJUWSA9ICJub3RGbGFnMiI7Ci0JCi0JCXB1YmxpYyBUZXN0TW9kZWwoYm9vbGVhbiBmbGFnMSwgYm9vbGVhbiBmbGFnMikgewotCQkJdGhpcy5mbGFnMSA9IGZsYWcxOwotCQkJdGhpcy5mbGFnMiA9IGZsYWcyOwotCQkJdGhpcy5ub3RGbGFnMiA9ICEgZmxhZzI7Ci0JCX0KLQkJcHVibGljIGJvb2xlYW4gaXNGbGFnMSgpIHsKLQkJCXJldHVybiB0aGlzLmZsYWcxOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldEZsYWcxKGJvb2xlYW4gZmxhZzEpIHsKLQkJCWJvb2xlYW4gb2xkID0gdGhpcy5mbGFnMTsKLQkJCXRoaXMuZmxhZzEgPSBmbGFnMTsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChGTEFHMV9QUk9QRVJUWSwgb2xkLCBmbGFnMSk7Ci0JCX0KLQkJcHVibGljIGJvb2xlYW4gaXNGbGFnMigpIHsKLQkJCXJldHVybiB0aGlzLmZsYWcyOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldEZsYWcyKGJvb2xlYW4gZmxhZzIpIHsKLQkJCWJvb2xlYW4gb2xkID0gdGhpcy5mbGFnMjsKLQkJCXRoaXMuZmxhZzIgPSBmbGFnMjsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChGTEFHMl9QUk9QRVJUWSwgb2xkLCBmbGFnMik7Ci0JCi0JCQlvbGQgPSB0aGlzLm5vdEZsYWcyOwotCQkJdGhpcy5ub3RGbGFnMiA9ICEgZmxhZzI7Ci0JCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoTk9UX0ZMQUcyX1BST1BFUlRZLCBvbGQsIHRoaXMubm90RmxhZzIpOwotCQl9Ci0JCXB1YmxpYyBib29sZWFuIGlzTm90RmxhZzIoKSB7Ci0JCQlyZXR1cm4gdGhpcy5ub3RGbGFnMjsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXROb3RGbGFnMihib29sZWFuIG5vdEZsYWcyKSB7Ci0JCQl0aGlzLnNldEZsYWcyKCAhIG5vdEZsYWcyKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiVGVzdE1vZGVsKCIgKyB0aGlzLmlzRmxhZzEoKSArICIgLSAiICsgdGhpcy5pc0ZsYWcyKCkgKyAiKSI7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC9zd3QvQ29tYm9Nb2RlbEFkYXB0ZXJUZXN0LmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvc3d0L0NvbWJvTW9kZWxBZGFwdGVyVGVzdC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwZmIxNTJhLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC9zd3QvQ29tYm9Nb2RlbEFkYXB0ZXJUZXN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw3OCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzLmludGVybmFsLnN3dDsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5zd3QuQWJzdHJhY3RDb21ib01vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuc3d0LkNvbWJvTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLnN3aW5nLlNpbXBsZURpc3BsYXlhYmxlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5TV1Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tYm87Ci1pbXBvcnQgb3JnLmp1bml0LkFmdGVyOwotCi1wdWJsaWMgY2xhc3MgQ29tYm9Nb2RlbEFkYXB0ZXJUZXN0IGV4dGVuZHMgQWJzdHJhY3RDb21ib01vZGVsQWRhcHRlclRlc3QgewotCi0JcHJpdmF0ZSBDb21ibyBjb21ibzsKLQlwcml2YXRlIGJvb2xlYW4gZWRpdGFibGU7Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgQWJzdHJhY3RDb21ib01vZGVsQWRhcHRlcjxTaW1wbGVEaXNwbGF5YWJsZT4gYnVpbGRFZGl0YWJsZUNvbWJvTW9kZWxBZGFwdGVyKCkgewotCi0JCWNvbWJvID0gbmV3IENvbWJvKHNoZWxsKCksIFNXVC5OVUxMKTsKLQkJZWRpdGFibGUgPSB0cnVlOwotCi0JCXJldHVybiBDb21ib01vZGVsQWRhcHRlci5hZGFwdCgKLQkJCWJ1aWxkTGlzdEhvbGRlcigpLAotCQkJc2VsZWN0ZWRJdGVtSG9sZGVyKCksCi0JCQljb21ibywKLQkJCWJ1aWxkU3RyaW5nQ29udmVydGVyKCkKLQkJKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgQWJzdHJhY3RDb21ib01vZGVsQWRhcHRlcjxTaW1wbGVEaXNwbGF5YWJsZT4gYnVpbGRSZWFkT25seUNvbWJvTW9kZWxBZGFwdGVyKCkgewotCi0JCWNvbWJvID0gbmV3IENvbWJvKHNoZWxsKCksIFNXVC5SRUFEX09OTFkpOwotCQllZGl0YWJsZSA9IGZhbHNlOwotCi0JCXJldHVybiBDb21ib01vZGVsQWRhcHRlci5hZGFwdCgKLQkJCWJ1aWxkTGlzdEhvbGRlcigpLAotCQkJc2VsZWN0ZWRJdGVtSG9sZGVyKCksCi0JCQljb21ibywKLQkJCWJ1aWxkU3RyaW5nQ29udmVydGVyKCkKLQkJKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIGNvbWJvU2VsZWN0ZWRJdGVtKCkgewotCQlyZXR1cm4gY29tYm8uZ2V0VGV4dCgpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBib29sZWFuIGVtcHR5Q29tYm9DYW5IYXZlU2VsZWN0ZWRWYWx1ZSgpIHsKLQkJcmV0dXJuIGVkaXRhYmxlOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBTdHJpbmcgaXRlbUF0KGludCBpbmRleCkgewotCQlyZXR1cm4gdGhpcy5jb21iby5nZXRJdGVtKGluZGV4KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgaW50IGl0ZW1Db3VudHMoKSB7Ci0JCXJldHVybiBjb21iby5nZXRJdGVtQ291bnQoKTsKLQl9Ci0KLQlAQWZ0ZXIKLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci50ZWFyRG93bigpOwotCQljb21ibyA9IG51bGw7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3N3dC9KcHRVaVNXVFRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvc3d0L0pwdFVpU1dUVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMTJhOGMyZi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvc3d0L0pwdFVpU1dUVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDM5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudWkudGVzdHMuaW50ZXJuYWwuc3d0OwotCi1pbXBvcnQganVuaXQuZnJhbWV3b3JrLkpVbml0NFRlc3RBZGFwdGVyOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0OwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0U3VpdGU7Ci1pbXBvcnQgb3JnLmp1bml0LnJ1bm5lci5SdW5XaXRoOwotaW1wb3J0IG9yZy5qdW5pdC5ydW5uZXJzLlN1aXRlOwotaW1wb3J0IG9yZy5qdW5pdC5ydW5uZXJzLlN1aXRlLlN1aXRlQ2xhc3NlczsKLQotQFN1aXRlQ2xhc3NlcwotKHsKLQlDQ29tYm9Nb2RlbEFkYXB0ZXJUZXN0LmNsYXNzLAotCUNvbWJvTW9kZWxBZGFwdGVyVGVzdC5jbGFzcywKLQlTcGlubmVyTW9kZWxBZGFwdGVyVGVzdC5jbGFzcywKLQlUYWJsZU1vZGVsQWRhcHRlclRlc3QuY2xhc3MKLX0pCi1AUnVuV2l0aChTdWl0ZS5jbGFzcykKLXB1YmxpYyBmaW5hbCBjbGFzcyBKcHRVaVNXVFRlc3RzIHsKLQotCXByaXZhdGUgSnB0VWlTV1RUZXN0cygpIHsKLQkJc3VwZXIoKTsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0JcHVibGljIHN0YXRpYyBUZXN0IHN1aXRlKCkgewotCQlUZXN0U3VpdGUgc3VpdGUgPSBuZXcgVGVzdFN1aXRlKCk7Ci0JCXN1aXRlLmFkZFRlc3QobmV3IEpVbml0NFRlc3RBZGFwdGVyKEpwdFVpU1dUVGVzdHMuY2xhc3MpKTsKLQkJcmV0dXJuIHN1aXRlOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC9zd3QvTGlzdEJveE1vZGVsQWRhcHRlclVJVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3N3dC9MaXN0Qm94TW9kZWxBZGFwdGVyVUlUZXN0LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDBmMmRhZmUuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3N3dC9MaXN0Qm94TW9kZWxBZGFwdGVyVUlUZXN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw2NDAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudWkudGVzdHMuaW50ZXJuYWwuc3d0OwotCi1pbXBvcnQgamF2YS50ZXh0LkNvbGxhdG9yOwotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkNvbXBhcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkRhdGU7Ci1pbXBvcnQgamF2YS51dGlsLkhhc2hTZXQ7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2UuYWN0aW9uLkFjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS5hY3Rpb24uQWN0aW9uQ29udHJpYnV0aW9uSXRlbTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS5hY3Rpb24uSUFjdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS53aW5kb3cuQXBwbGljYXRpb25XaW5kb3c7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uud2luZG93LldpbmRvdzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuc3d0Lkxpc3RCb3hNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnN3dC5MaXN0Qm94TW9kZWxBZGFwdGVyLlNlbGVjdGlvbkNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uQXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5MaXN0QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLk1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5TV1Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5GaWxsTGF5b3V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuRm9ybUF0dGFjaG1lbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5Gb3JtRGF0YTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkZvcm1MYXlvdXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbnRyb2w7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuRGlzcGxheTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5MYWJlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5TaGVsbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5UZXh0OwotCi0vKioKLSAqIGFuIGV4YW1wbGUgVUkgZm9yIHRlc3RpbmcgdmFyaW91cyBwZXJtdXRhdGlvbnMgb2YgdGhlCi0gKiBTdHJ1Y3R1cmVkQ29udGVudFByb3ZpZGVyQWRhcHRlcgotICovCi1wdWJsaWMgY2xhc3MgTGlzdEJveE1vZGVsQWRhcHRlclVJVGVzdAotCWV4dGVuZHMgQXBwbGljYXRpb25XaW5kb3cKLXsKLQlmaW5hbCBUYXNrTGlzdCB0YXNrTGlzdDsKLQlwcml2YXRlIGZpbmFsIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFRhc2tMaXN0PiB0YXNrTGlzdEhvbGRlcjsKLQlwcml2YXRlIFRleHQgdGFza1RleHRGaWVsZDsKLQotCXB1YmxpYyBzdGF0aWMgdm9pZCBtYWluKFN0cmluZ1tdIGFyZ3MpIHRocm93cyBFeGNlcHRpb24gewotCQlXaW5kb3cgd2luZG93ID0gbmV3IExpc3RCb3hNb2RlbEFkYXB0ZXJVSVRlc3QoYXJncyk7Ci0JCXdpbmRvdy5zZXRCbG9ja09uT3Blbih0cnVlKTsKLQkJd2luZG93Lm9wZW4oKTsKLQkJRGlzcGxheS5nZXRDdXJyZW50KCkuZGlzcG9zZSgpOwotCQlTeXN0ZW0uZXhpdCgwKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RCb3hNb2RlbEFkYXB0ZXJVSVRlc3QoU3RyaW5nW10gYXJncykgewotCQlzdXBlcihudWxsKTsKLQkJdGhpcy50YXNrTGlzdCA9IG5ldyBUYXNrTGlzdCgpOwotCQl0aGlzLnRhc2tMaXN0SG9sZGVyID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxUYXNrTGlzdD4odGhpcy50YXNrTGlzdCk7Ci0JCXRoaXMudGFza0xpc3QuYWRkVGFzaygic3dpbSIpOwotCQl0aGlzLnRhc2tMaXN0LmFkZFRhc2soImJpa2UiKTsKLQkJdGhpcy50YXNrTGlzdC5hZGRUYXNrKCJydW4iKTsKLQkJVGFzayByZXN0ID0gdGhpcy50YXNrTGlzdC5hZGRUYXNrKCJyZXN0Iik7Ci0JCXRoaXMudGFza0xpc3QuYWRkUHJpb3JpdHlUYXNrKHJlc3QpOwotCQlUYXNrIHJlcGVhdCA9IHRoaXMudGFza0xpc3QuYWRkVGFzaygicmVwZWF0Iik7Ci0JCXRoaXMudGFza0xpc3QuYWRkUHJpb3JpdHlUYXNrKHJlcGVhdCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIENvbnRyb2wgY3JlYXRlQ29udGVudHMoQ29tcG9zaXRlIHBhcmVudCkgewotCQkoKFNoZWxsKSBwYXJlbnQpLnNldFRleHQoQ2xhc3NUb29scy5zaG9ydENsYXNzTmFtZUZvck9iamVjdCh0aGlzKSk7Ci0JCXBhcmVudC5zZXRTaXplKDgwMCwgNDAwKTsKLQkJQ29tcG9zaXRlIG1haW5QYW5lbCA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTk9ORSk7Ci0JCW1haW5QYW5lbC5zZXRMYXlvdXQobmV3IEZvcm1MYXlvdXQoKSk7Ci0JCUNvbnRyb2wgdGFza0xpc3RQYW5lbCA9IHRoaXMuYnVpbGRUYXNrTGlzdFBhbmVsKG1haW5QYW5lbCk7Ci0JCXRoaXMuYnVpbGRDb250cm9sUGFuZWwobWFpblBhbmVsLCB0YXNrTGlzdFBhbmVsKTsKLQkJcmV0dXJuIG1haW5QYW5lbDsKLQl9Ci0KLQlwcml2YXRlIENvbnRyb2wgYnVpbGRUYXNrTGlzdFBhbmVsKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJQ29tcG9zaXRlIHBhbmVsID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OT05FKTsKLQotCQlGb3JtRGF0YSBmZCA9IG5ldyBGb3JtRGF0YSgpOwotCQkJZmQudG9wID0gbmV3IEZvcm1BdHRhY2htZW50KDApOwotCQkJZmQuYm90dG9tID0gbmV3IEZvcm1BdHRhY2htZW50KDEwMCwgLTMwKTsKLQkJCWZkLmxlZnQgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMCk7Ci0JCQlmZC5yaWdodCA9IG5ldyBGb3JtQXR0YWNobWVudCgxMDApOwotCQlwYW5lbC5zZXRMYXlvdXREYXRhKGZkKTsKLQotCQlwYW5lbC5zZXRMYXlvdXQobmV3IEZvcm1MYXlvdXQoKSk7Ci0JCXRoaXMuYnVpbGRQcmltaXRpdmVUYXNrTGlzdFBhbmVsKHBhbmVsKTsKLQkJdGhpcy5idWlsZE9iamVjdFRhc2tMaXN0UGFuZWwocGFuZWwpOwotCi0JCXJldHVybiBwYW5lbDsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRQcmltaXRpdmVUYXNrTGlzdFBhbmVsKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJQ29tcG9zaXRlIHBhbmVsID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OT05FKTsKLQotCQlGb3JtRGF0YSBmZCA9IG5ldyBGb3JtRGF0YSgpOwotCQkJZmQudG9wID0gbmV3IEZvcm1BdHRhY2htZW50KDApOwotCQkJZmQuYm90dG9tID0gbmV3IEZvcm1BdHRhY2htZW50KDUwKTsKLQkJCWZkLmxlZnQgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMCk7Ci0JCQlmZC5yaWdodCA9IG5ldyBGb3JtQXR0YWNobWVudCgxMDApOwotCQlwYW5lbC5zZXRMYXlvdXREYXRhKGZkKTsKLQotCQlwYW5lbC5zZXRMYXlvdXQobmV3IEZpbGxMYXlvdXQoKSk7Ci0JCXRoaXMuYnVpbGRVbnNvcnRlZFByaW1pdGl2ZUxpc3RQYW5lbChwYW5lbCk7Ci0JCXRoaXMuYnVpbGRTdGFuZGFyZFNvcnRlZFByaW1pdGl2ZUxpc3RQYW5lbChwYW5lbCk7Ci0JCXRoaXMuYnVpbGRDdXN0b21Tb3J0ZWRQcmltaXRpdmVMaXN0UGFuZWwocGFuZWwpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZE9iamVjdFRhc2tMaXN0UGFuZWwoQ29tcG9zaXRlIHBhcmVudCkgewotCQlDb21wb3NpdGUgcGFuZWwgPSBuZXcgQ29tcG9zaXRlKHBhcmVudCwgU1dULk5PTkUpOwotCi0JCUZvcm1EYXRhIGZkID0gbmV3IEZvcm1EYXRhKCk7Ci0JCQlmZC50b3AgPSBuZXcgRm9ybUF0dGFjaG1lbnQoNTApOwotCQkJZmQuYm90dG9tID0gbmV3IEZvcm1BdHRhY2htZW50KDEwMCk7Ci0JCQlmZC5sZWZ0ID0gbmV3IEZvcm1BdHRhY2htZW50KDApOwotCQkJZmQucmlnaHQgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMTAwKTsKLQkJcGFuZWwuc2V0TGF5b3V0RGF0YShmZCk7Ci0KLQkJcGFuZWwuc2V0TGF5b3V0KG5ldyBGaWxsTGF5b3V0KCkpOwotCQl0aGlzLmJ1aWxkVW5zb3J0ZWRPYmplY3RMaXN0UGFuZWwocGFuZWwpOwotCQl0aGlzLmJ1aWxkU3RhbmRhcmRTb3J0ZWRPYmplY3RMaXN0UGFuZWwocGFuZWwpOwotCQl0aGlzLmJ1aWxkQ3VzdG9tU29ydGVkT2JqZWN0TGlzdFBhbmVsKHBhbmVsKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRVbnNvcnRlZFByaW1pdGl2ZUxpc3RQYW5lbChDb21wb3NpdGUgcGFyZW50KSB7Ci0JCXRoaXMuYnVpbGRMaXN0UGFuZWwocGFyZW50LCAicHJpbWl0aXZlIHVuc29ydGVkIiwgdGhpcy5idWlsZFVuc29ydGVkUHJpbWl0aXZlTGlzdE1vZGVsKCksIG5ldyBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+KCkpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZFN0YW5kYXJkU29ydGVkUHJpbWl0aXZlTGlzdFBhbmVsKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJdGhpcy5idWlsZExpc3RQYW5lbChwYXJlbnQsICJwcmltaXRpdmUgc29ydGVkIiwgdGhpcy5idWlsZFN0YW5kYXJkU29ydGVkUHJpbWl0aXZlTGlzdE1vZGVsKCksIG5ldyBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+KCkpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZEN1c3RvbVNvcnRlZFByaW1pdGl2ZUxpc3RQYW5lbChDb21wb3NpdGUgcGFyZW50KSB7Ci0JCXRoaXMuYnVpbGRMaXN0UGFuZWwocGFyZW50LCAicHJpbWl0aXZlIHJldmVyc2Ugc29ydGVkIiwgdGhpcy5idWlsZEN1c3RvbVNvcnRlZFByaW1pdGl2ZUxpc3RNb2RlbCgpLCBuZXcgU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8U3RyaW5nPigpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRVbnNvcnRlZE9iamVjdExpc3RQYW5lbChDb21wb3NpdGUgcGFyZW50KSB7Ci0JCXRoaXMuYnVpbGRMaXN0UGFuZWwyKHBhcmVudCwgIm9iamVjdCB1bnNvcnRlZCIsIHRoaXMuYnVpbGRVbnNvcnRlZE9iamVjdExpc3RNb2RlbCgpLCB0aGlzLmJ1aWxkUHJpb3JpdHlUYXNrTGlzdEFkYXB0ZXIoKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGJ1aWxkU3RhbmRhcmRTb3J0ZWRPYmplY3RMaXN0UGFuZWwoQ29tcG9zaXRlIHBhcmVudCkgewotCQl0aGlzLmJ1aWxkTGlzdFBhbmVsMihwYXJlbnQsICJvYmplY3Qgc29ydGVkIiwgdGhpcy5idWlsZFN0YW5kYXJkU29ydGVkT2JqZWN0TGlzdE1vZGVsKCksIHRoaXMuYnVpbGRQcmlvcml0eVRhc2tMaXN0QWRhcHRlcigpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRDdXN0b21Tb3J0ZWRPYmplY3RMaXN0UGFuZWwoQ29tcG9zaXRlIHBhcmVudCkgewotCQl0aGlzLmJ1aWxkTGlzdFBhbmVsMihwYXJlbnQsICJvYmplY3QgcmV2ZXJzZSBzb3J0ZWQiLCB0aGlzLmJ1aWxkQ3VzdG9tU29ydGVkT2JqZWN0TGlzdE1vZGVsKCksIHRoaXMuYnVpbGRQcmlvcml0eVRhc2tMaXN0QWRhcHRlcigpKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRVbnNvcnRlZFByaW1pdGl2ZUxpc3RNb2RlbCgpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRQcmltaXRpdmVUYXNrTGlzdEFkYXB0ZXIoKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRTdGFuZGFyZFNvcnRlZFByaW1pdGl2ZUxpc3RNb2RlbCgpIHsKLQkJcmV0dXJuIG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8U3RyaW5nPih0aGlzLmJ1aWxkUHJpbWl0aXZlVGFza0xpc3RBZGFwdGVyKCkpOwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZEN1c3RvbVNvcnRlZFByaW1pdGl2ZUxpc3RNb2RlbCgpIHsKLQkJcmV0dXJuIG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8U3RyaW5nPih0aGlzLmJ1aWxkUHJpbWl0aXZlVGFza0xpc3RBZGFwdGVyKCksIHRoaXMuYnVpbGRDdXN0b21TdHJpbmdDb21wYXJhdG9yKCkpOwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8VGFzaz4gYnVpbGRVbnNvcnRlZE9iamVjdExpc3RNb2RlbCgpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRPYmplY3RUYXNrTGlzdEFkYXB0ZXIoKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPFRhc2s+IGJ1aWxkU3RhbmRhcmRTb3J0ZWRPYmplY3RMaXN0TW9kZWwoKSB7Ci0JCXJldHVybiBuZXcgU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyPFRhc2s+KHRoaXMuYnVpbGRPYmplY3RUYXNrTGlzdEFkYXB0ZXIoKSk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxUYXNrPiBidWlsZEN1c3RvbVNvcnRlZE9iamVjdExpc3RNb2RlbCgpIHsKLQkJcmV0dXJuIG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8VGFzaz4odGhpcy5idWlsZE9iamVjdFRhc2tMaXN0QWRhcHRlcigpLCB0aGlzLmJ1aWxkQ3VzdG9tVGFza0NvbXBhcmF0b3IoKSk7Ci0JfQotCi0JcHJpdmF0ZSA8RT4gTGlzdEJveE1vZGVsQWRhcHRlcjxFPiBidWlsZExpc3RQYW5lbChDb21wb3NpdGUgcGFyZW50LCBTdHJpbmcgbGFiZWwsIExpc3RWYWx1ZU1vZGVsPEU+IG1vZGVsLCBDb2xsZWN0aW9uVmFsdWVNb2RlbDxFPiBzZWxlY3RlZEl0ZW1zTW9kZWwpIHsKLQkJQ29tcG9zaXRlIHBhbmVsID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OT05FKTsKLQkJcGFuZWwuc2V0TGF5b3V0KG5ldyBGb3JtTGF5b3V0KCkpOwotCi0JCUxhYmVsIGxpc3RMYWJlbCA9IG5ldyBMYWJlbChwYW5lbCwgU1dULkxFRlQgfCBTV1QuVkVSVElDQUwpOwotCQlsaXN0TGFiZWwuc2V0VGV4dChsYWJlbCk7Ci0JCUZvcm1EYXRhIGZkID0gbmV3IEZvcm1EYXRhKCk7Ci0JCQlmZC50b3AgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMCwgMyk7Ci0JCQlmZC5ib3R0b20gPSBuZXcgRm9ybUF0dGFjaG1lbnQoMCwgMjApOwotCQkJZmQubGVmdCA9IG5ldyBGb3JtQXR0YWNobWVudCgwLCA1KTsKLQkJCWZkLnJpZ2h0ID0gbmV3IEZvcm1BdHRhY2htZW50KDEwMCk7Ci0JCWxpc3RMYWJlbC5zZXRMYXlvdXREYXRhKGZkKTsKLQotCQlvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5MaXN0IGxpc3RCb3ggPSBuZXcgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuTGlzdChwYW5lbCwgU1dULk1VTFRJIHwgU1dULkJPUkRFUik7Ci0JCWZkID0gbmV3IEZvcm1EYXRhKCk7Ci0JCQlmZC50b3AgPSBuZXcgRm9ybUF0dGFjaG1lbnQobGlzdExhYmVsKTsKLQkJCWZkLmJvdHRvbSA9IG5ldyBGb3JtQXR0YWNobWVudCgxMDApOwotCQkJZmQubGVmdCA9IG5ldyBGb3JtQXR0YWNobWVudCgwKTsKLQkJCWZkLnJpZ2h0ID0gbmV3IEZvcm1BdHRhY2htZW50KDEwMCk7Ci0JCWxpc3RCb3guc2V0TGF5b3V0RGF0YShmZCk7Ci0JCXJldHVybiBMaXN0Qm94TW9kZWxBZGFwdGVyLmFkYXB0KG1vZGVsLCBzZWxlY3RlZEl0ZW1zTW9kZWwsIGxpc3RCb3gpOyAgLy8gdXNlICN0b1N0cmluZygpCi0JfQotCi0JcHJpdmF0ZSB2b2lkIGJ1aWxkTGlzdFBhbmVsMihDb21wb3NpdGUgcGFyZW50LCBTdHJpbmcgbGFiZWwsIExpc3RWYWx1ZU1vZGVsPFRhc2s+IG1vZGVsLCBDb2xsZWN0aW9uVmFsdWVNb2RlbDxUYXNrPiBzZWxlY3RlZEl0ZW1zTW9kZWwpIHsKLQkJTGlzdEJveE1vZGVsQWRhcHRlcjxUYXNrPiBhZGFwdGVyID0gdGhpcy5idWlsZExpc3RQYW5lbChwYXJlbnQsIGxhYmVsLCBtb2RlbCwgc2VsZWN0ZWRJdGVtc01vZGVsKTsKLQkJYWRhcHRlci5hZGREb3VibGVDbGlja0xpc3RlbmVyKHRoaXMuYnVpbGREb3VibGVDbGlja0xpc3RlbmVyKCkpOwotCQlhZGFwdGVyLmFkZFNlbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRTZWxlY3Rpb25DaGFuZ2VMaXN0ZW5lcigpKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RCb3hNb2RlbEFkYXB0ZXIuRG91YmxlQ2xpY2tMaXN0ZW5lcjxUYXNrPiBidWlsZERvdWJsZUNsaWNrTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgTGlzdEJveE1vZGVsQWRhcHRlci5Eb3VibGVDbGlja0xpc3RlbmVyPFRhc2s+KCkgewotCQkJcHVibGljIHZvaWQgZG91YmxlQ2xpY2soTGlzdEJveE1vZGVsQWRhcHRlci5Eb3VibGVDbGlja0V2ZW50PFRhc2s+IGV2ZW50KSB7Ci0JCQkJU3lzdGVtLm91dC5wcmludGxuKCJkb3VibGUtY2xpY2s6ICIgKyBldmVudC5zZWxlY3Rpb24oKSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0Qm94TW9kZWxBZGFwdGVyLlNlbGVjdGlvbkNoYW5nZUxpc3RlbmVyPFRhc2s+IGJ1aWxkU2VsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgTGlzdEJveE1vZGVsQWRhcHRlci5TZWxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjxUYXNrPigpIHsKLQkJCXB1YmxpYyB2b2lkIHNlbGVjdGlvbkNoYW5nZWQoU2VsZWN0aW9uQ2hhbmdlRXZlbnQ8VGFzaz4gZXZlbnQpIHsKLQkJCQlMaXN0Qm94TW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMudGFza0xpc3Quc2V0UHJpb3JpdHlUYXNrcyhldmVudC5zZWxlY3Rpb24oKSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBDb21wYXJhdG9yPFN0cmluZz4gYnVpbGRDdXN0b21TdHJpbmdDb21wYXJhdG9yKCkgewotCQlyZXR1cm4gbmV3IENvbXBhcmF0b3I8U3RyaW5nPigpIHsKLQkJCXB1YmxpYyBpbnQgY29tcGFyZShTdHJpbmcgczEsIFN0cmluZyBzMikgewotCQkJCXJldHVybiBzMi5jb21wYXJlVG8oczEpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgQ29tcGFyYXRvcjxUYXNrPiBidWlsZEN1c3RvbVRhc2tDb21wYXJhdG9yKCkgewotCQlyZXR1cm4gbmV3IENvbXBhcmF0b3I8VGFzaz4oKSB7Ci0JCQlwdWJsaWMgaW50IGNvbXBhcmUoVGFzayB0bzEsIFRhc2sgdG8yKSB7Ci0JCQkJcmV0dXJuIHRvMi5jb21wYXJlVG8odG8xKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRQcmltaXRpdmVUYXNrTGlzdEFkYXB0ZXIoKSB7Ci0JCXJldHVybiBuZXcgTGlzdEFzcGVjdEFkYXB0ZXI8VGFza0xpc3QsIFN0cmluZz4odGhpcy50YXNrTGlzdEhvbGRlciwgVGFza0xpc3QuVEFTS19OQU1FU19MSVNUKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBMaXN0SXRlcmF0b3I8U3RyaW5nPiBsaXN0SXRlcmF0b3JfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QudGFza05hbWVzKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxUYXNrPiBidWlsZE9iamVjdFRhc2tMaXN0QWRhcHRlcigpIHsKLQkJcmV0dXJuIG5ldyBMaXN0QXNwZWN0QWRhcHRlcjxUYXNrTGlzdCwgVGFzaz4odGhpcy50YXNrTGlzdEhvbGRlciwgVGFza0xpc3QuVEFTS1NfTElTVCkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgTGlzdEl0ZXJhdG9yPFRhc2s+IGxpc3RJdGVyYXRvcl8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC50YXNrcygpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgQ29sbGVjdGlvblZhbHVlTW9kZWw8VGFzaz4gYnVpbGRQcmlvcml0eVRhc2tMaXN0QWRhcHRlcigpIHsKLQkJcmV0dXJuIG5ldyBDb2xsZWN0aW9uQXNwZWN0QWRhcHRlcjxUYXNrTGlzdCwgVGFzaz4odGhpcy50YXNrTGlzdEhvbGRlciwgVGFza0xpc3QuUFJJT1JJVFlfVEFTS1NfQ09MTEVDVElPTikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSXRlcmF0b3I8VGFzaz4gaXRlcmF0b3JfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QucHJpb3JpdHlUYXNrcygpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZENvbnRyb2xQYW5lbChDb21wb3NpdGUgcGFyZW50LCBDb250cm9sIHRhc2tMaXN0UGFuZWwpIHsKLQkJQ29tcG9zaXRlIHBhbmVsID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OT05FKTsKLQkJRm9ybURhdGEgZmQgPSBuZXcgRm9ybURhdGEoKTsKLQkJCWZkLnRvcCA9IG5ldyBGb3JtQXR0YWNobWVudCh0YXNrTGlzdFBhbmVsKTsKLQkJCWZkLmJvdHRvbSA9IG5ldyBGb3JtQXR0YWNobWVudCgxMDApOwotCQkJZmQubGVmdCA9IG5ldyBGb3JtQXR0YWNobWVudCgwKTsKLQkJCWZkLnJpZ2h0ID0gbmV3IEZvcm1BdHRhY2htZW50KDEwMCk7Ci0JCXBhbmVsLnNldExheW91dERhdGEoZmQpOwotCi0JCXBhbmVsLnNldExheW91dChuZXcgRm9ybUxheW91dCgpKTsKLQkJQ29udHJvbCBtaXNjID0gdGhpcy5idWlsZE1pc2NUYXNrUGFuZWwocGFuZWwpOwotCQl0aGlzLmJ1aWxkQWRkUmVtb3ZlVGFza1BhbmVsKHBhbmVsLCBtaXNjKTsKLQl9Ci0KLQkvLyBpcyB0aGVyZSBhIGJldHRlciB3YXkgdG8gYXNzb2NpYXRlIGFuIEFDSSB3aXRoIGZvcm0gZGF0YT8KLQlwcml2YXRlIENvbnRyb2wgYnVpbGRNaXNjVGFza1BhbmVsKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJQ29tcG9zaXRlIHBhbmVsID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OT05FKTsKLQkJRm9ybURhdGEgZmQgPSBuZXcgRm9ybURhdGEoKTsKLQkJCWZkLnRvcCA9IG5ldyBGb3JtQXR0YWNobWVudCgwKTsKLQkJCWZkLmJvdHRvbSA9IG5ldyBGb3JtQXR0YWNobWVudCgxMDApOwotCQkJZmQubGVmdCA9IG5ldyBGb3JtQXR0YWNobWVudCgxMDAsIC00MDApOwotCQkJZmQucmlnaHQgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMTAwKTsKLQkJcGFuZWwuc2V0TGF5b3V0RGF0YShmZCk7Ci0KLQkJcGFuZWwuc2V0TGF5b3V0KG5ldyBGaWxsTGF5b3V0KCkpOwotCQl0aGlzLmJ1aWxkQ2xlYXJMaXN0QUNJKCkuZmlsbChwYW5lbCk7Ci0JCXRoaXMuYnVpbGRDbGVhck1vZGVsQUNJKCkuZmlsbChwYW5lbCk7Ci0JCXRoaXMuYnVpbGRSZXN0b3JlTW9kZWxBQ0koKS5maWxsKHBhbmVsKTsKLQkJdGhpcy5idWlsZEFkZFByaW9yaXR5VGFza0FDSSgpLmZpbGwocGFuZWwpOwotCQl0aGlzLmJ1aWxkUmVtb3ZlUHJpb3JpdHlUYXNrQUNJKCkuZmlsbChwYW5lbCk7Ci0JCXRoaXMuYnVpbGRDbGVhclByaW9yaXR5VGFza3NBQ0koKS5maWxsKHBhbmVsKTsKLQkJcmV0dXJuIHBhbmVsOwotCX0KLQotCXByaXZhdGUgQWN0aW9uQ29udHJpYnV0aW9uSXRlbSBidWlsZENsZWFyTGlzdEFDSSgpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBY3Rpb24oImNsZWFyIGxpc3QiLCBJQWN0aW9uLkFTX1BVU0hfQlVUVE9OKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlMaXN0Qm94TW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMuY2xlYXJUYXNrcygpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0VG9vbFRpcFRleHQoImNsZWFyIGFsbCB0aGUgdGFza3MiKTsKLQkJcmV0dXJuIG5ldyBBY3Rpb25Db250cmlidXRpb25JdGVtKGFjdGlvbik7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb25Db250cmlidXRpb25JdGVtIGJ1aWxkQ2xlYXJNb2RlbEFDSSgpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBY3Rpb24oImNsZWFyIG1vZGVsIiwgSUFjdGlvbi5BU19QVVNIX0JVVFRPTikgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBydW4oKSB7Ci0JCQkJTGlzdEJveE1vZGVsQWRhcHRlclVJVGVzdC50aGlzLmNsZWFyTW9kZWwoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldFRvb2xUaXBUZXh0KCJjbGVhciB0aGUgdGFzayBsaXN0IG1vZGVsIik7Ci0JCXJldHVybiBuZXcgQWN0aW9uQ29udHJpYnV0aW9uSXRlbShhY3Rpb24pOwotCX0KLQotCXByaXZhdGUgQWN0aW9uQ29udHJpYnV0aW9uSXRlbSBidWlsZFJlc3RvcmVNb2RlbEFDSSgpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBY3Rpb24oInJlc3RvcmUgbW9kZWwiLCBJQWN0aW9uLkFTX1BVU0hfQlVUVE9OKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlMaXN0Qm94TW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMucmVzdG9yZU1vZGVsKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRUb29sVGlwVGV4dCgicmVzdG9yZSB0aGUgdGFzayBsaXN0IG1vZGVsIik7Ci0JCXJldHVybiBuZXcgQWN0aW9uQ29udHJpYnV0aW9uSXRlbShhY3Rpb24pOwotCX0KLQotCXByaXZhdGUgQWN0aW9uQ29udHJpYnV0aW9uSXRlbSBidWlsZEFkZFByaW9yaXR5VGFza0FDSSgpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBY3Rpb24oImFkZCBwcmlvcml0eSIsIElBY3Rpb24uQVNfUFVTSF9CVVRUT04pIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJCUxpc3RCb3hNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5hZGRQcmlvcml0eVRhc2soKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldFRvb2xUaXBUZXh0KCJhZGQgYSB0YXNrIHRvIHRoZSBwcmlvcml0eSB0YXNrcyIpOwotCQlyZXR1cm4gbmV3IEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0oYWN0aW9uKTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0gYnVpbGRSZW1vdmVQcmlvcml0eVRhc2tBQ0koKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWN0aW9uKCJyZW1vdmUgcHJpb3JpdHkiLCBJQWN0aW9uLkFTX1BVU0hfQlVUVE9OKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlMaXN0Qm94TW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMucmVtb3ZlUHJpb3JpdHlUYXNrKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRUb29sVGlwVGV4dCgicmVtb3ZlIGEgdGFzayBmcm9tIHRoZSBwcmlvcml0eSB0YXNrcyIpOwotCQlyZXR1cm4gbmV3IEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0oYWN0aW9uKTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0gYnVpbGRDbGVhclByaW9yaXR5VGFza3NBQ0koKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWN0aW9uKCJjbGVhciBwcmlvcml0eSIsIElBY3Rpb24uQVNfUFVTSF9CVVRUT04pIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJCUxpc3RCb3hNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5jbGVhclByaW9yaXR5VGFza3MoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldFRvb2xUaXBUZXh0KCJjbGVhciB0aGUgcHJpb3JpdHkgdGFza3MiKTsKLQkJcmV0dXJuIG5ldyBBY3Rpb25Db250cmlidXRpb25JdGVtKGFjdGlvbik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGJ1aWxkQWRkUmVtb3ZlVGFza1BhbmVsKENvbXBvc2l0ZSBwYXJlbnQsIENvbnRyb2wgY2xlYXJCdXR0b24pIHsKLQkJQ29tcG9zaXRlIHBhbmVsID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OT05FKTsKLQkJRm9ybURhdGEgZmQgPSBuZXcgRm9ybURhdGEoKTsKLQkJCWZkLnRvcCA9IG5ldyBGb3JtQXR0YWNobWVudCgwKTsKLQkJCWZkLmJvdHRvbSA9IG5ldyBGb3JtQXR0YWNobWVudCgxMDApOwotCQkJZmQubGVmdCA9IG5ldyBGb3JtQXR0YWNobWVudCgwKTsKLQkJCWZkLnJpZ2h0ID0gbmV3IEZvcm1BdHRhY2htZW50KGNsZWFyQnV0dG9uKTsKLQkJcGFuZWwuc2V0TGF5b3V0RGF0YShmZCk7Ci0KLQkJcGFuZWwuc2V0TGF5b3V0KG5ldyBGb3JtTGF5b3V0KCkpOwotCQlDb250cm9sIGFkZEJ1dHRvbiA9IHRoaXMuYnVpbGRBZGRCdXR0b24ocGFuZWwpOwotCQlDb250cm9sIHJlbW92ZUJ1dHRvbiA9IHRoaXMuYnVpbGRSZW1vdmVCdXR0b24ocGFuZWwpOwotCQl0aGlzLmJ1aWxkVGFza1RleHRGaWVsZChwYW5lbCwgYWRkQnV0dG9uLCByZW1vdmVCdXR0b24pOwotCX0KLQotCS8vIGlzIHRoZXJlIGEgYmV0dGVyIHdheSB0byBhc3NvY2lhdGUgYW4gQUNJIHdpdGggZm9ybSBkYXRhPwotCXByaXZhdGUgQ29udHJvbCBidWlsZEFkZEJ1dHRvbihDb21wb3NpdGUgcGFyZW50KSB7Ci0JCUNvbXBvc2l0ZSBwYW5lbCA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTk9ORSk7Ci0JCUZvcm1EYXRhIGZkID0gbmV3IEZvcm1EYXRhKCk7Ci0JCQlmZC50b3AgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMCk7Ci0JCQlmZC5ib3R0b20gPSBuZXcgRm9ybUF0dGFjaG1lbnQoMTAwKTsKLQkJCWZkLmxlZnQgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMCk7Ci0JCQlmZC5yaWdodCA9IG5ldyBGb3JtQXR0YWNobWVudCgwLCA1MCk7Ci0JCXBhbmVsLnNldExheW91dERhdGEoZmQpOwotCi0JCXBhbmVsLnNldExheW91dChuZXcgRmlsbExheW91dCgpKTsKLQkJdGhpcy5idWlsZEFkZEFDSSgpLmZpbGwocGFuZWwpOwotCQlyZXR1cm4gcGFuZWw7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb25Db250cmlidXRpb25JdGVtIGJ1aWxkQWRkQUNJKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFjdGlvbigiYWRkIiwgSUFjdGlvbi5BU19QVVNIX0JVVFRPTikgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBydW4oKSB7Ci0JCQkJTGlzdEJveE1vZGVsQWRhcHRlclVJVGVzdC50aGlzLmFkZFRhc2soKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldFRvb2xUaXBUZXh0KCJhZGQgYSB0YXNrIHdpdGggdGhlIG5hbWUgaW4gdGhlIGVudHJ5IGZpZWxkIik7Ci0JCXJldHVybiBuZXcgQWN0aW9uQ29udHJpYnV0aW9uSXRlbShhY3Rpb24pOwotCX0KLQotCS8vIGlzIHRoZXJlIGEgYmV0dGVyIHdheSB0byBhc3NvY2lhdGUgYW4gQUNJIHdpdGggZm9ybSBkYXRhPwotCXByaXZhdGUgQ29udHJvbCBidWlsZFJlbW92ZUJ1dHRvbihDb21wb3NpdGUgcGFyZW50KSB7Ci0JCUNvbXBvc2l0ZSBwYW5lbCA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTk9ORSk7Ci0JCUZvcm1EYXRhIGZkID0gbmV3IEZvcm1EYXRhKCk7Ci0JCQlmZC50b3AgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMCk7Ci0JCQlmZC5ib3R0b20gPSBuZXcgRm9ybUF0dGFjaG1lbnQoMTAwKTsKLQkJCWZkLmxlZnQgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMTAwLCAtNTApOwotCQkJZmQucmlnaHQgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMTAwKTsKLQkJcGFuZWwuc2V0TGF5b3V0RGF0YShmZCk7Ci0KLQkJcGFuZWwuc2V0TGF5b3V0KG5ldyBGaWxsTGF5b3V0KCkpOwotCQl0aGlzLmJ1aWxkUmVtb3ZlQUNJKCkuZmlsbChwYW5lbCk7Ci0JCXJldHVybiBwYW5lbDsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0gYnVpbGRSZW1vdmVBQ0koKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWN0aW9uKCJyZW1vdmUiLCBJQWN0aW9uLkFTX1BVU0hfQlVUVE9OKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlMaXN0Qm94TW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMucmVtb3ZlVGFzaygpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0VG9vbFRpcFRleHQoInJlbW92ZSB0aGUgdGFzayB3aXRoIHRoZSBuYW1lIGluIHRoZSBlbnRyeSBmaWVsZCIpOwotCQlyZXR1cm4gbmV3IEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0oYWN0aW9uKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRUYXNrVGV4dEZpZWxkKENvbXBvc2l0ZSBwYXJlbnQsIENvbnRyb2wgYWRkQnV0dG9uLCBDb250cm9sIHJlbW92ZUJ1dHRvbikgewotCQl0aGlzLnRhc2tUZXh0RmllbGQgPSBuZXcgVGV4dChwYXJlbnQsIFNXVC5TSU5HTEUgfCBTV1QuQk9SREVSKTsKLQkJRm9ybURhdGEgZmQgPSBuZXcgRm9ybURhdGEoKTsKLQkJCWZkLnRvcCA9IG5ldyBGb3JtQXR0YWNobWVudCgwKTsKLQkJCWZkLmJvdHRvbSA9IG5ldyBGb3JtQXR0YWNobWVudCgxMDApOwotCQkJZmQubGVmdCA9IG5ldyBGb3JtQXR0YWNobWVudChhZGRCdXR0b24pOwotCQkJZmQucmlnaHQgPSBuZXcgRm9ybUF0dGFjaG1lbnQocmVtb3ZlQnV0dG9uKTsKLQkJdGhpcy50YXNrVGV4dEZpZWxkLnNldExheW91dERhdGEoZmQpOwotCX0KLQotCXByaXZhdGUgU3RyaW5nIHRhc2tUZXh0RmllbGRUZXh0KCkgewotCQlyZXR1cm4gdGhpcy50YXNrVGV4dEZpZWxkLmdldFRleHQoKTsKLQl9Ci0KLQl2b2lkIGFkZFRhc2soKSB7Ci0JCVN0cmluZyB0YXNrVGV4dCA9IHRoaXMudGFza1RleHRGaWVsZFRleHQoKTsKLQkJaWYgKHRhc2tUZXh0Lmxlbmd0aCgpICE9IDApIHsKLQkJCXRoaXMudGFza0xpc3QuYWRkVGFzayh0YXNrVGV4dCk7Ci0JCX0KLQl9Ci0KLQl2b2lkIHJlbW92ZVRhc2soKSB7Ci0JCVN0cmluZyB0YXNrID0gdGhpcy50YXNrVGV4dEZpZWxkVGV4dCgpOwotCQlpZiAodGFzay5sZW5ndGgoKSAhPSAwKSB7Ci0JCQl0aGlzLnRhc2tMaXN0LnJlbW92ZVRhc2sodGFzayk7Ci0JCX0KLQl9Ci0KLQl2b2lkIGNsZWFyVGFza3MoKSB7Ci0JCXRoaXMudGFza0xpc3QuY2xlYXJUYXNrcygpOwotCX0KLQotCXZvaWQgY2xlYXJNb2RlbCgpIHsKLQkJdGhpcy50YXNrTGlzdEhvbGRlci5zZXRWYWx1ZShudWxsKTsKLQl9Ci0KLQl2b2lkIHJlc3RvcmVNb2RlbCgpIHsKLQkJdGhpcy50YXNrTGlzdEhvbGRlci5zZXRWYWx1ZSh0aGlzLnRhc2tMaXN0KTsKLQl9Ci0KLQl2b2lkIGFkZFByaW9yaXR5VGFzaygpIHsKLQkJSXRlcmF0b3I8VGFzaz4gdGFza3MgPSB0aGlzLnRhc2tMaXN0LnRhc2tzKCk7Ci0JCXdoaWxlICh0YXNrcy5oYXNOZXh0KCkpIHsKLQkJCWlmICh0aGlzLnRhc2tMaXN0LmFkZFByaW9yaXR5VGFzayh0YXNrcy5uZXh0KCkpKSB7Ci0JCQkJcmV0dXJuOwotCQkJfQotCQl9Ci0JfQotCi0Jdm9pZCByZW1vdmVQcmlvcml0eVRhc2soKSB7Ci0JCUl0ZXJhdG9yPFRhc2s+IHBUYXNrcyA9IHRoaXMudGFza0xpc3QucHJpb3JpdHlUYXNrcygpOwotCQlpZiAocFRhc2tzLmhhc05leHQoKSkgewotCQkJdGhpcy50YXNrTGlzdC5yZW1vdmVQcmlvcml0eVRhc2socFRhc2tzLm5leHQoKSk7Ci0JCX0KLQl9Ci0KLQl2b2lkIGNsZWFyUHJpb3JpdHlUYXNrcygpIHsKLQkJdGhpcy50YXNrTGlzdC5jbGVhclByaW9yaXR5VGFza3MoKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogVGFza0xpc3QgKioqKioqKioqKgotCi0JLy8gbm90ZSBhYnNlbmNlIG9mIHZhbGlkYXRpb24uLi4KLQlwcml2YXRlIGNsYXNzIFRhc2tMaXN0IGV4dGVuZHMgQWJzdHJhY3RNb2RlbCB7Ci0JCXByaXZhdGUgZmluYWwgTGlzdDxTdHJpbmc+IHRhc2tOYW1lcyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgVEFTS19OQU1FU19MSVNUID0gInRhc2tOYW1lcyI7Ci0JCXByaXZhdGUgZmluYWwgTGlzdDxUYXNrPiB0YXNrcyA9IG5ldyBBcnJheUxpc3Q8VGFzaz4oKTsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFRBU0tTX0xJU1QgPSAidGFza3MiOwotCQlwcml2YXRlIGZpbmFsIENvbGxlY3Rpb248VGFzaz4gcHJpb3JpdHlUYXNrcyA9IG5ldyBIYXNoU2V0PFRhc2s+KCk7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBQUklPUklUWV9UQVNLU19DT0xMRUNUSU9OID0gInByaW9yaXR5VGFza3MiOwotCQlUYXNrTGlzdCgpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQkJcHVibGljIExpc3RJdGVyYXRvcjxTdHJpbmc+IHRhc2tOYW1lcygpIHsKLQkJCXJldHVybiB0aGlzLnRhc2tOYW1lcy5saXN0SXRlcmF0b3IoKTsKLQkJfQotCQlwdWJsaWMgTGlzdEl0ZXJhdG9yPFRhc2s+IHRhc2tzKCkgewotCQkJcmV0dXJuIHRoaXMudGFza3MubGlzdEl0ZXJhdG9yKCk7Ci0JCX0KLQkJcHVibGljIEl0ZXJhdG9yPFRhc2s+IHByaW9yaXR5VGFza3MoKSB7Ci0JCQlyZXR1cm4gdGhpcy5wcmlvcml0eVRhc2tzLml0ZXJhdG9yKCk7Ci0JCX0KLQkJcHVibGljIFRhc2sgYWRkVGFzayhTdHJpbmcgdGFza05hbWUpIHsKLQkJCXRoaXMuYWRkSXRlbVRvTGlzdCh0YXNrTmFtZSwgdGhpcy50YXNrTmFtZXMsIFRBU0tfTkFNRVNfTElTVCk7Ci0JCQlUYXNrIHRhc2sgPSBuZXcgVGFzayh0YXNrTmFtZSk7Ci0JCQl0aGlzLmFkZEl0ZW1Ub0xpc3QodGFzaywgdGhpcy50YXNrcywgVEFTS1NfTElTVCk7Ci0JCQlyZXR1cm4gdGFzazsKLQkJfQkJCi0JCXB1YmxpYyB2b2lkIHJlbW92ZVRhc2soU3RyaW5nIHRhc2tOYW1lKSB7Ci0JCQlpbnQgaW5kZXggPSB0aGlzLnRhc2tOYW1lcy5pbmRleE9mKHRhc2tOYW1lKTsKLQkJCWlmIChpbmRleCAhPSAtMSkgewotCQkJCXRoaXMucmVtb3ZlSXRlbUZyb21MaXN0KGluZGV4LCB0aGlzLnRhc2tOYW1lcywgVEFTS19OQU1FU19MSVNUKTsKLQkJCQkvLyBhc3N1bWUgdGhlIGluZGV4ZXMgbWF0Y2guLi4KLQkJCQlUYXNrIHJlbW92ZWRUYXNrID0gdGhpcy5yZW1vdmVJdGVtRnJvbUxpc3QoaW5kZXgsIHRoaXMudGFza3MsIFRBU0tTX0xJU1QpOwotCQkJCXRoaXMucmVtb3ZlSXRlbUZyb21Db2xsZWN0aW9uKHJlbW92ZWRUYXNrLCB0aGlzLnByaW9yaXR5VGFza3MsIFBSSU9SSVRZX1RBU0tTX0NPTExFQ1RJT04pOwotCQkJfQotCQl9Ci0JCXB1YmxpYyB2b2lkIGNsZWFyVGFza3MoKSB7Ci0JCQl0aGlzLnRhc2tOYW1lcy5jbGVhcigpOwotCQkJdGhpcy5maXJlTGlzdENsZWFyZWQoVEFTS19OQU1FU19MSVNUKTsKLQkJCXRoaXMudGFza3MuY2xlYXIoKTsKLQkJCXRoaXMuZmlyZUxpc3RDbGVhcmVkKFRBU0tTX0xJU1QpOwotCQl9Ci0JCXB1YmxpYyBib29sZWFuIGFkZFByaW9yaXR5VGFzayhUYXNrIHRhc2spIHsKLQkJCXJldHVybiB0aGlzLmFkZEl0ZW1Ub0NvbGxlY3Rpb24odGFzaywgdGhpcy5wcmlvcml0eVRhc2tzLCBQUklPUklUWV9UQVNLU19DT0xMRUNUSU9OKTsKLQkJfQkJCi0JCXB1YmxpYyB2b2lkIHJlbW92ZVByaW9yaXR5VGFzayhUYXNrIHRhc2spIHsKLQkJCXRoaXMucmVtb3ZlSXRlbUZyb21Db2xsZWN0aW9uKHRhc2ssIHRoaXMucHJpb3JpdHlUYXNrcywgUFJJT1JJVFlfVEFTS1NfQ09MTEVDVElPTik7Ci0JCX0KLQkJcHVibGljIHZvaWQgY2xlYXJQcmlvcml0eVRhc2tzKCkgewotCQkJdGhpcy5jbGVhckNvbGxlY3Rpb24odGhpcy5wcmlvcml0eVRhc2tzLCBQUklPUklUWV9UQVNLU19DT0xMRUNUSU9OKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXRQcmlvcml0eVRhc2tzKEl0ZXJhdG9yPFRhc2s+IHRhc2tzKSB7Ci0JCQl0aGlzLnByaW9yaXR5VGFza3MuY2xlYXIoKTsKLQkJCXdoaWxlICh0YXNrcy5oYXNOZXh0KCkpIHsKLQkJCQl0aGlzLnByaW9yaXR5VGFza3MuYWRkKHRhc2tzLm5leHQoKSk7Ci0JCQl9Ci0JCQl0aGlzLmZpcmVDb2xsZWN0aW9uQ2hhbmdlZChQUklPUklUWV9UQVNLU19DT0xMRUNUSU9OKTsKLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBUYXNrICoqKioqKioqKioKLQotCXByaXZhdGUgY2xhc3MgVGFzayBleHRlbmRzIEFic3RyYWN0TW9kZWwgaW1wbGVtZW50cyBEaXNwbGF5YWJsZSB7Ci0JCXByaXZhdGUgU3RyaW5nIG5hbWU7Ci0JCXByaXZhdGUgRGF0ZSBjcmVhdGlvblRpbWVTdGFtcDsKLQkJcHVibGljIFRhc2soU3RyaW5nIG5hbWUpIHsKLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCQl0aGlzLmNyZWF0aW9uVGltZVN0YW1wID0gbmV3IERhdGUoKTsKLQkJfQotCQlwdWJsaWMgU3RyaW5nIGRpc3BsYXlTdHJpbmcoKSB7Ci0JCQlyZXR1cm4gdGhpcy5uYW1lICsgIjogIiArIHRoaXMuY3JlYXRpb25UaW1lU3RhbXAuZ2V0VGltZSgpOwotCQl9Ci0JCXB1YmxpYyBpbnQgY29tcGFyZVRvKERpc3BsYXlhYmxlIG8pIHsKLQkJCXJldHVybiBERUZBVUxUX0NPTVBBUkFUT1IuY29tcGFyZSh0aGlzLCBvKTsKLQkJfQotCQlwdWJsaWMgU3RyaW5nIGdldE5hbWUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5uYW1lOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldE5hbWUoU3RyaW5nIG5hbWUpIHsKLQkJCU9iamVjdCBvbGQgPSB0aGlzLm5hbWU7Ci0JCQl0aGlzLm5hbWUgPSBuYW1lOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKERJU1BMQVlfU1RSSU5HX1BST1BFUlRZLCBvbGQsIG5hbWUpOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuIHRoaXMuZGlzcGxheVN0cmluZygpOwotCQl9Ci0JfQotCi0JcHVibGljIGludGVyZmFjZSBEaXNwbGF5YWJsZSBleHRlbmRzIE1vZGVsLCBDb21wYXJhYmxlPERpc3BsYXlhYmxlPiB7Ci0JCi0JCVN0cmluZyBkaXNwbGF5U3RyaW5nKCk7Ci0JCQlTdHJpbmcgRElTUExBWV9TVFJJTkdfUFJPUEVSVFkgPSAiZGlzcGxheVN0cmluZyI7Ci0JCi0JCi0JCS8vICoqKioqKioqKiogaGVscGVyIGltcGxlbWVudGF0aW9ucyAqKioqKioqKioqCi0JCi0JCUNvbGxhdG9yIERFRkFVTFRfQ09MTEFUT1IgPSBDb2xsYXRvci5nZXRJbnN0YW5jZSgpOwotCQotCQlDb21wYXJhdG9yPERpc3BsYXlhYmxlPiBERUZBVUxUX0NPTVBBUkFUT1IgPQotCQkJbmV3IENvbXBhcmF0b3I8RGlzcGxheWFibGU+KCkgewotCQkJCXB1YmxpYyBpbnQgY29tcGFyZShEaXNwbGF5YWJsZSBkMSwgRGlzcGxheWFibGUgZDIpIHsKLQkJCQkJLy8gZGlzYWxsb3cgZHVwbGljYXRlcyBiYXNlZCBvbiBvYmplY3QgaWRlbnRpdHkKLQkJCQkJaWYgKGQxID09IGQyKSB7Ci0JCQkJCQlyZXR1cm4gMDsKLQkJCQkJfQotCQotCQkJCQkvLyBmaXJzdCBjb21wYXJlIGRpc3BsYXkgc3RyaW5ncyB1c2luZyB0aGUgZGVmYXVsdCBjb2xsYXRvcgotCQkJCQlpbnQgcmVzdWx0ID0gREVGQVVMVF9DT0xMQVRPUi5jb21wYXJlKGQxLmRpc3BsYXlTdHJpbmcoKSwgZDIuZGlzcGxheVN0cmluZygpKTsKLQkJCQkJaWYgKHJlc3VsdCAhPSAwKSB7Ci0JCQkJCQlyZXR1cm4gcmVzdWx0OwotCQkJCQl9Ci0JCi0JCQkJCS8vIHRoZW4gY29tcGFyZSB1c2luZyBvYmplY3QtaWQKLQkJCQkJcmVzdWx0ID0gU3lzdGVtLmlkZW50aXR5SGFzaENvZGUoZDEpIC0gU3lzdGVtLmlkZW50aXR5SGFzaENvZGUoZDIpOwotCQkJCQlpZiAocmVzdWx0ICE9IDApIHsKLQkJCQkJCXJldHVybiByZXN1bHQ7Ci0JCQkJCX0KLQkKLQkJCQkJLy8gSXQncyB1bmxpa2VseSB0aGF0IHdlIGdldCB0byB0aGlzIHBvaW50OyBidXQsIGp1c3QgaW4gY2FzZSwgd2Ugd2lsbCByZXR1cm4gLTEuCi0JCQkJCS8vIFVuZm9ydHVuYXRlbHksIHRoaXMgaW50cm9kdWNlcyBzb21lIG1pbGQgdW5wcmVkaWN0YWJpbGl0eSB0byB0aGUgc29ydCBvcmRlcgotCQkJCQkvLyAodW5sZXNzIHRoZSBvYmplY3RzIGFyZSBhbHdheXMgcGFzc2VkIGludG8gdGhpcyBtZXRob2QgaW4gdGhlIHNhbWUgb3JkZXIpLgotCQkJCQlyZXR1cm4gLTE7CQkvLyBpZiBhbGwgZWxzZSBmYWlscywgaW5kaWNhdGUgdGhhdCBvMSA8IG8yCi0JCQkJfQotCQkJCUBPdmVycmlkZQotCQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJCXJldHVybiAiRGlzcGxheWFibGUuREVGQVVMVF9DT01QQVJBVE9SIjsKLQkJCQl9Ci0JCQl9OwotCQotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC9zd3QvU3Bpbm5lck1vZGVsQWRhcHRlclRlc3QuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC9zd3QvU3Bpbm5lck1vZGVsQWRhcHRlclRlc3QuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggY2YxNjI5Zi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvc3d0L1NwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNDAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy5pbnRlcm5hbC5zd3Q7Ci0KLWltcG9ydCBzdGF0aWMgb3JnLmp1bml0LkFzc2VydC4qOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5zd3QuU3Bpbm5lck1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LlNXVDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5EaXNwbGF5OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLlNoZWxsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLlNwaW5uZXI7Ci1pbXBvcnQgb3JnLmp1bml0LkFmdGVyOwotaW1wb3J0IG9yZy5qdW5pdC5CZWZvcmU7Ci1pbXBvcnQgb3JnLmp1bml0LlRlc3Q7Ci0KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIFNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0IHsKLQotCXByaXZhdGUgTW9kZWwgbW9kZWw7Ci0JcHJpdmF0ZSBTaGVsbCBzaGVsbDsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE1vZGVsPiBzdWJqZWN0SG9sZGVyOwotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxNb2RlbD4gYnVpbGRTdWJqZWN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxNb2RlbD4oKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXI+IGJ1aWxkVmFsdWVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPE1vZGVsLCBJbnRlZ2VyPihzdWJqZWN0SG9sZGVyLCBNb2RlbC5WQUxVRV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSW50ZWdlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5nZXRWYWx1ZSgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhJbnRlZ2VyIHZhbHVlKSB7Ci0JCQkJc3ViamVjdC5zZXRWYWx1ZSh2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQEJlZm9yZQotCXB1YmxpYyB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJc2hlbGwgICAgICAgICAgICAgID0gbmV3IFNoZWxsKERpc3BsYXkuZ2V0Q3VycmVudCgpKTsKLQkJbW9kZWwgICAgICAgICAgICAgID0gbmV3IE1vZGVsKCk7Ci0JCXN1YmplY3RIb2xkZXIgICAgICA9IGJ1aWxkU3ViamVjdEhvbGRlcigpOwotCX0KLQotCUBBZnRlcgotCXB1YmxpYyB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJaWYgKCFzaGVsbC5pc0Rpc3Bvc2VkKCkpIHsKLQkJCXNoZWxsLmRpc3Bvc2UoKTsKLQkJfQotCi0JCXNoZWxsICAgICAgICAgPSBudWxsOwotCQlzdWJqZWN0SG9sZGVyID0gbnVsbDsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3REaXNwb3NlZCgpIHsKLQotCQlpbnQgdmFsdWUgPSAyOwotCQltb2RlbC5zZXRWYWx1ZSh2YWx1ZSk7Ci0JCW1vZGVsLmNsZWFyU2V0VmFsdWVDYWxsZWRGbGFnKCk7Ci0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCi0JCVNwaW5uZXIgc3Bpbm5lciA9IG5ldyBTcGlubmVyKHNoZWxsLCBTV1QuTlVMTCk7Ci0JCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXI+IG51bWJlckhvbGRlciA9IGJ1aWxkVmFsdWVIb2xkZXIoKTsKLQkJaW50IGRlZmF1bHRWYWx1ZSA9IDE7Ci0KLQkJU3Bpbm5lck1vZGVsQWRhcHRlci5hZGFwdCgKLQkJCW51bWJlckhvbGRlciwKLQkJCXNwaW5uZXIsCi0JCQlkZWZhdWx0VmFsdWUKLQkJKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHNwaW5uZXIncyB2YWx1ZSBzaG91bGQgYmUgY29taW5nIGZyb20gdGhlIG1vZGVsIiwKLQkJCXZhbHVlLAotCQkJc3Bpbm5lci5nZXRTZWxlY3Rpb24oKQotCQkpOwotCi0JCWFzc2VydEVxdWFscygKLQkJCSJUaGUgbnVtYmVyIGhvbGRlcidzIHZhbHVlIHNob3VsZCBiZSB0aGUgbW9kZWwncyB2YWx1ZSIsCi0JCQltb2RlbC5nZXRWYWx1ZSgpLAotCQkJbnVtYmVySG9sZGVyLmdldFZhbHVlKCkKLQkJKTsKLQotCQlhc3NlcnRGYWxzZSgKLQkJCSJUaGUgbW9kZWwgc2hvdWxkIG5vdCBoYXZlIHJlY2VpdmVkIHRoZSB2YWx1ZSBkdXJpbmcgaW5pdGlhbGl6YXRpb24iLAotCQkJbW9kZWwuaXNTZXRWYWx1ZUNhbGxlZCgpCi0JCSk7Ci0KLQkJLy8gQ2hhbmdlIHRoZSB2YWx1ZSBpbiB0aGUgbW9kZWwKLQkJc3Bpbm5lci5kaXNwb3NlKCk7Ci0KLQkJdmFsdWUgPSA0OwotCQltb2RlbC5zZXRWYWx1ZSh2YWx1ZSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSBtb2RlbCdzIHZhbHVlIHdhcyBzb21laG93IGNoYW5nZWQiLAotCQkJSW50ZWdlci52YWx1ZU9mKHZhbHVlKSwKLQkJCW1vZGVsLmdldFZhbHVlKCkKLQkJKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3RJbml0aWFsaXphdGlvbl8xKCkgewotCi0JCVNwaW5uZXIgc3Bpbm5lciA9IG5ldyBTcGlubmVyKHNoZWxsLCBTV1QuTlVMTCk7Ci0JCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXI+IG51bWJlckhvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4oKTsKLQkJaW50IGRlZmF1bHRWYWx1ZSA9IDE7Ci0KLQkJU3Bpbm5lck1vZGVsQWRhcHRlci5hZGFwdCgKLQkJCW51bWJlckhvbGRlciwKLQkJCXNwaW5uZXIsCi0JCQlkZWZhdWx0VmFsdWUKLQkJKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHNwaW5uZXIncyB2YWx1ZSBzaG91bGQgYmUgdGhlIGRlZmF1bHQgdmFsdWUiLAotCQkJZGVmYXVsdFZhbHVlLAotCQkJc3Bpbm5lci5nZXRTZWxlY3Rpb24oKQotCQkpOwotCi0JCWFzc2VydE51bGwoCi0JCQkiVGhlIG51bWJlciBob2xkZXIncyB2YWx1ZSBzaG91bGQgYmUgbnVsbCIsCi0JCQludW1iZXJIb2xkZXIuZ2V0VmFsdWUoKQotCQkpOwotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdEluaXRpYWxpemF0aW9uXzIoKSB7Ci0KLQkJU3Bpbm5lciBzcGlubmVyID0gbmV3IFNwaW5uZXIoc2hlbGwsIFNXVC5OVUxMKTsKLQkJV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4gbnVtYmVySG9sZGVyID0gYnVpbGRWYWx1ZUhvbGRlcigpOwotCQlpbnQgZGVmYXVsdFZhbHVlID0gMTsKLQotCQlTcGlubmVyTW9kZWxBZGFwdGVyLmFkYXB0KAotCQkJbnVtYmVySG9sZGVyLAotCQkJc3Bpbm5lciwKLQkJCWRlZmF1bHRWYWx1ZQotCQkpOwotCi0JCWFzc2VydEVxdWFscygKLQkJCSJUaGUgc3Bpbm5lcidzIHZhbHVlIHNob3VsZCBiZSB0aGUgZGVmYXVsdCB2YWx1ZSIsCi0JCQlkZWZhdWx0VmFsdWUsCi0JCQlzcGlubmVyLmdldFNlbGVjdGlvbigpCi0JCSk7Ci0KLQkJYXNzZXJ0TnVsbCgKLQkJCSJUaGUgbnVtYmVyIGhvbGRlcidzIHZhbHVlIHNob3VsZCBiZSBudWxsIiwKLQkJCW51bWJlckhvbGRlci5nZXRWYWx1ZSgpCi0JCSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0SW5pdGlhbGl6YXRpb25fMygpIHsKLQotCQlzdWJqZWN0SG9sZGVyLnNldFZhbHVlKG1vZGVsKTsKLQotCQlTcGlubmVyIHNwaW5uZXIgPSBuZXcgU3Bpbm5lcihzaGVsbCwgU1dULk5VTEwpOwotCQlXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyPiBudW1iZXJIb2xkZXIgPSBidWlsZFZhbHVlSG9sZGVyKCk7Ci0JCWludCBkZWZhdWx0VmFsdWUgPSAxOwotCi0JCVNwaW5uZXJNb2RlbEFkYXB0ZXIuYWRhcHQoCi0JCQludW1iZXJIb2xkZXIsCi0JCQlzcGlubmVyLAotCQkJZGVmYXVsdFZhbHVlCi0JCSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSBzcGlubmVyJ3MgdmFsdWUgc2hvdWxkIGJlIHRoZSBkZWZhdWx0IHZhbHVlIiwKLQkJCWRlZmF1bHRWYWx1ZSwKLQkJCXNwaW5uZXIuZ2V0U2VsZWN0aW9uKCkKLQkJKTsKLQotCQlhc3NlcnROdWxsKAotCQkJIlRoZSBudW1iZXIgaG9sZGVyJ3MgdmFsdWUgc2hvdWxkIGJlIG51bGwiLAotCQkJbnVtYmVySG9sZGVyLmdldFZhbHVlKCkKLQkJKTsKLQotCQlhc3NlcnRGYWxzZSgKLQkJCSJUaGUgbW9kZWwgc2hvdWxkIG5vdCBoYXZlIHJlY2VpdmVkIHRoZSB2YWx1ZSBkdXJpbmcgaW5pdGlhbGl6YXRpb24iLAotCQkJbW9kZWwuaXNTZXRWYWx1ZUNhbGxlZCgpCi0JCSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0SW5pdGlhbGl6YXRpb25fNCgpIHsKLQotCQlpbnQgdmFsdWUgPSAyOwotCQltb2RlbC5zZXRWYWx1ZSh2YWx1ZSk7Ci0JCW1vZGVsLmNsZWFyU2V0VmFsdWVDYWxsZWRGbGFnKCk7Ci0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCi0JCVNwaW5uZXIgc3Bpbm5lciA9IG5ldyBTcGlubmVyKHNoZWxsLCBTV1QuTlVMTCk7Ci0JCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXI+IG51bWJlckhvbGRlciA9IGJ1aWxkVmFsdWVIb2xkZXIoKTsKLQkJaW50IGRlZmF1bHRWYWx1ZSA9IDE7Ci0KLQkJU3Bpbm5lck1vZGVsQWRhcHRlci5hZGFwdCgKLQkJCW51bWJlckhvbGRlciwKLQkJCXNwaW5uZXIsCi0JCQlkZWZhdWx0VmFsdWUKLQkJKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHNwaW5uZXIncyB2YWx1ZSBzaG91bGQgYmUgdGhlIHZhbHVlIGNvbWluZyBmcm9tIHRoZSBtb2RlbCIsCi0JCQl2YWx1ZSwKLQkJCXNwaW5uZXIuZ2V0U2VsZWN0aW9uKCkKLQkJKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIG51bWJlciBob2xkZXIncyB2YWx1ZSBzaG91bGQgYmUgIiArIHZhbHVlLAotCQkJSW50ZWdlci52YWx1ZU9mKHZhbHVlKSwKLQkJCW51bWJlckhvbGRlci5nZXRWYWx1ZSgpCi0JCSk7Ci0KLQkJYXNzZXJ0RmFsc2UoCi0JCQkiVGhlIG1vZGVsIHNob3VsZCBub3QgaGF2ZSByZWNlaXZlZCB0aGUgdmFsdWUgZHVyaW5nIGluaXRpYWxpemF0aW9uIiwKLQkJCW1vZGVsLmlzU2V0VmFsdWVDYWxsZWQoKQotCQkpOwotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdFZhbHVlQ2hhbmdlZCgpIHsKLQotCQlpbnQgdmFsdWUgPSAyOwotCQltb2RlbC5zZXRWYWx1ZSh2YWx1ZSk7Ci0JCW1vZGVsLmNsZWFyU2V0VmFsdWVDYWxsZWRGbGFnKCk7Ci0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobW9kZWwpOwotCi0JCVNwaW5uZXIgc3Bpbm5lciA9IG5ldyBTcGlubmVyKHNoZWxsLCBTV1QuTlVMTCk7Ci0JCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEludGVnZXI+IG51bWJlckhvbGRlciA9IGJ1aWxkVmFsdWVIb2xkZXIoKTsKLQkJaW50IGRlZmF1bHRWYWx1ZSA9IDE7Ci0KLQkJU3Bpbm5lck1vZGVsQWRhcHRlci5hZGFwdCgKLQkJCW51bWJlckhvbGRlciwKLQkJCXNwaW5uZXIsCi0JCQlkZWZhdWx0VmFsdWUKLQkJKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHNwaW5uZXIncyB2YWx1ZSBzaG91bGQgYmUgY29taW5nIGZyb20gdGhlIG1vZGVsIiwKLQkJCXZhbHVlLAotCQkJc3Bpbm5lci5nZXRTZWxlY3Rpb24oKQotCQkpOwotCi0JCWFzc2VydEVxdWFscygKLQkJCSJUaGUgbnVtYmVyIGhvbGRlcidzIHZhbHVlIHNob3VsZCBiZSB0aGUgbW9kZWwncyB2YWx1ZSIsCi0JCQltb2RlbC5nZXRWYWx1ZSgpLAotCQkJbnVtYmVySG9sZGVyLmdldFZhbHVlKCkKLQkJKTsKLQotCQlhc3NlcnRGYWxzZSgKLQkJCSJUaGUgbW9kZWwgc2hvdWxkIG5vdCBoYXZlIHJlY2VpdmVkIHRoZSB2YWx1ZSBkdXJpbmcgaW5pdGlhbGl6YXRpb24iLAotCQkJbW9kZWwuaXNTZXRWYWx1ZUNhbGxlZCgpCi0JCSk7Ci0KLQkJLy8gQ2hhbmdlIHRoZSB2YWx1ZSBpbiB0aGUgbW9kZWwKLQkJdmFsdWUgPSA0OwotCQltb2RlbC5zZXRWYWx1ZSh2YWx1ZSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSBzcGlubmVyJ3MgdmFsdWUgc2hvdWxkIGJlIGNvbWluZyBmcm9tIHRoZSBtb2RlbCIsCi0JCQl2YWx1ZSwKLQkJCXNwaW5uZXIuZ2V0U2VsZWN0aW9uKCkKLQkJKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIG1vZGVsJ3MgdmFsdWUgd2FzIHNvbWVob3cgY2hhbmdlZCIsCi0JCQlJbnRlZ2VyLnZhbHVlT2YodmFsdWUpLAotCQkJbW9kZWwuZ2V0VmFsdWUoKQotCQkpOwotCi0JCS8vIENoYW5nZSB0aGUgdmFsdWUgZnJvbSB0aGUgc3Bpbm5lcgotCQl2YWx1ZSA9IDY7Ci0JCXNwaW5uZXIuc2V0U2VsZWN0aW9uKHZhbHVlKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHNwaW5uZXIncyB2YWx1ZSBzaG91bGQgYmUgdGhlIG5ldyB2YWx1ZSBzZXQiLAotCQkJdmFsdWUsCi0JCQlzcGlubmVyLmdldFNlbGVjdGlvbigpCi0JCSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSBtb2RlbCdzIHZhbHVlIHdhcyBzdXBwb3NlZCB0byBiZSB1cGRhdGVkIiwKLQkJCUludGVnZXIudmFsdWVPZih2YWx1ZSksCi0JCQltb2RlbC5nZXRWYWx1ZSgpCi0JCSk7Ci0KLQkJLy8gRGlzY29ubmVjdCBmcm9tIG1vZGVsCi0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobnVsbCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSBzcGlubmVyJ3MgdmFsdWUgc2hvdWxkIGJlIHRoZSBkZWZhdWx0IHZhbHVlIiwKLQkJCWRlZmF1bHRWYWx1ZSwKLQkJCXNwaW5uZXIuZ2V0U2VsZWN0aW9uKCkKLQkJKTsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBNb2RlbCBleHRlbmRzIEFic3RyYWN0TW9kZWwgewotCi0JCXByaXZhdGUgYm9vbGVhbiBzZXRWYWx1ZUNhbGxlZDsKLQkJcHJpdmF0ZSBJbnRlZ2VyIHZhbHVlOwotCi0JCXN0YXRpYyBmaW5hbCBTdHJpbmcgVkFMVUVfUFJPUEVSVFkgPSAidmFsdWUiOwotCi0JCXZvaWQgY2xlYXJTZXRWYWx1ZUNhbGxlZEZsYWcoKSB7Ci0JCQlzZXRWYWx1ZUNhbGxlZCA9IGZhbHNlOwotCQl9Ci0KLQkJSW50ZWdlciBnZXRWYWx1ZSgpIHsKLQkJCXJldHVybiB2YWx1ZTsKLQkJfQotCi0JCWJvb2xlYW4gaXNTZXRWYWx1ZUNhbGxlZCgpIHsKLQkJCXJldHVybiBzZXRWYWx1ZUNhbGxlZDsKLQkJfQotCi0JCXZvaWQgc2V0VmFsdWUoSW50ZWdlciB2YWx1ZSkgewotCQkJc2V0VmFsdWVDYWxsZWQgPSB0cnVlOwotCi0JCQlJbnRlZ2VyIG9sZFZhbHVlID0gdGhpcy52YWx1ZTsKLQkJCXRoaXMudmFsdWUgPSB2YWx1ZTsKLQkJCWZpcmVQcm9wZXJ0eUNoYW5nZWQoVkFMVUVfUFJPUEVSVFksIG9sZFZhbHVlLCB2YWx1ZSk7Ci0JCX0KLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvc3d0L1RhYmxlTW9kZWxBZGFwdGVyVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3N3dC9UYWJsZU1vZGVsQWRhcHRlclRlc3QuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTRkYTk5MC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvc3d0L1RhYmxlTW9kZWxBZGFwdGVyVGVzdC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTIwMyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzLmludGVybmFsLnN3dDsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLklUYWJsZUxhYmVsUHJvdmlkZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5MYWJlbFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5zd3QuQ29sdW1uQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwuc3d0LlRhYmxlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5zd3QuVGFibGVNb2RlbEFkYXB0ZXIuU2VsZWN0aW9uQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnN3dC5UYWJsZU1vZGVsQWRhcHRlci5TZWxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkNsb25lTGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuTGlzdEFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuU1dUOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5ldmVudHMuU2VsZWN0aW9uRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLkltYWdlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkRpc3BsYXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuU2hlbGw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuVGFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuVGFibGVJdGVtOwotaW1wb3J0IG9yZy5qdW5pdC5BZnRlcjsKLWltcG9ydCBvcmcuanVuaXQuQXNzZXJ0OwotaW1wb3J0IG9yZy5qdW5pdC5CZWZvcmU7Ci1pbXBvcnQgb3JnLmp1bml0LlRlc3Q7Ci0KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIFRhYmxlTW9kZWxBZGFwdGVyVGVzdCB7Ci0KLQlwcml2YXRlIFNoZWxsIHNoZWxsOwotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8TWFuYWdlcj4gc3ViamVjdEhvbGRlcjsKLQotCXByaXZhdGUgQ29sdW1uQWRhcHRlcjxFbXBsb3llZT4gYnVpbGRDb2x1bW5BZGFwdGVyKCkgewotCQlyZXR1cm4gbmV3IFRhYmxlQ29sdW1uQWRhcHRlcigpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8RW1wbG95ZWU+IGJ1aWxkRW1wbG95ZWVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPEVtcGxveWVlPigpOwotCX0KLQotCXByaXZhdGUgU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8RW1wbG95ZWU+IGJ1aWxkRW1wbG95ZWVIb2xkZXJzKCkgewotCQlyZXR1cm4gbmV3IFNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPEVtcGxveWVlPigpOwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8RW1wbG95ZWU+IGJ1aWxkRW1wbG95ZWVMaXN0SG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IExpc3RBc3BlY3RBZGFwdGVyPE1hbmFnZXIsIEVtcGxveWVlPihzdWJqZWN0SG9sZGVyLCBNYW5hZ2VyLkVNUExPWUVFU19MSVNUKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBMaXN0SXRlcmF0b3I8RW1wbG95ZWU+IGxpc3RJdGVyYXRvcl8oKSB7Ci0JCQkJcmV0dXJuIHN1YmplY3QuZW1wbG95ZWVzKCk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGludCBzaXplXygpIHsKLQkJCQlyZXR1cm4gc3ViamVjdC5lbXBsb3llZXNTaXplKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBJVGFibGVMYWJlbFByb3ZpZGVyIGJ1aWxkTGFiZWxQcm92aWRlcigpIHsKLQkJcmV0dXJuIG5ldyBUYWJsZUxhYmVsUHJvdmlkZXIoKTsKLQl9Ci0KLQlwcml2YXRlIFNlbGVjdGlvbkNoYW5nZUxpc3RlbmVyPEVtcGxveWVlPiBidWlsZFNlbGVjdGlvbkNoYW5nZUxpc3RlbmVyKGZpbmFsIENvbGxlY3Rpb248RW1wbG95ZWU+IGVtcGxveWVlcykgewotCQlyZXR1cm4gbmV3IFNlbGVjdGlvbkNoYW5nZUxpc3RlbmVyPEVtcGxveWVlPigpIHsKLQkJCXB1YmxpYyB2b2lkIHNlbGVjdGlvbkNoYW5nZWQoU2VsZWN0aW9uQ2hhbmdlRXZlbnQ8RW1wbG95ZWU+IGUpIHsKLQkJCQllbXBsb3llZXMuY2xlYXIoKTsKLQkJCQlDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGVtcGxveWVlcywgZS5zZWxlY3Rpb24oKSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxNYW5hZ2VyPiBidWlsZFN1YmplY3RIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPE1hbmFnZXI+KCk7Ci0JfQotCi0JQEJlZm9yZQotCXB1YmxpYyB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJc2hlbGwgICAgICAgICA9IG5ldyBTaGVsbChEaXNwbGF5LmdldEN1cnJlbnQoKSk7Ci0JCXN1YmplY3RIb2xkZXIgPSBidWlsZFN1YmplY3RIb2xkZXIoKTsKLQl9Ci0KLQlAQWZ0ZXIKLQlwdWJsaWMgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCi0JCWlmICghc2hlbGwuaXNEaXNwb3NlZCgpKSB7Ci0JCQlzaGVsbC5kaXNwb3NlKCk7Ci0JCX0KLQotCQlzaGVsbCAgICAgICAgID0gbnVsbDsKLQkJc3ViamVjdEhvbGRlciA9IG51bGw7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0Q2hhbmdlZCgpIHsKLQotCQlUYWJsZSB0YWJsZSA9IG5ldyBUYWJsZShzaGVsbCwgU1dULlZfU0NST0xMIHwgU1dULkhfU0NST0xMIHwgU1dULkZVTExfU0VMRUNUSU9OIHwgU1dULk1VTFRJKTsKLQotCQlMaXN0VmFsdWVNb2RlbDxFbXBsb3llZT4gbGlzdEhvbGRlciA9IGJ1aWxkRW1wbG95ZWVMaXN0SG9sZGVyKCk7Ci0JCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEVtcGxveWVlPiBzZWxlY3RlZEl0ZW1Ib2xkZXIgPSBidWlsZEVtcGxveWVlSG9sZGVyKCk7Ci0KLQkJTWFuYWdlciBtYW5hZ2VyID0gbmV3IE1hbmFnZXIoKTsKLQkJc3ViamVjdEhvbGRlci5zZXRWYWx1ZShtYW5hZ2VyKTsKLQotCQluZXcgVGFibGVNb2RlbCgKLQkJCWxpc3RIb2xkZXIsCi0JCQlzZWxlY3RlZEl0ZW1Ib2xkZXIsCi0JCQl0YWJsZSwKLQkJCWJ1aWxkQ29sdW1uQWRhcHRlcigpLAotCQkJYnVpbGRMYWJlbFByb3ZpZGVyKCkKLQkJKTsKLQotCQkvLyBDcmVhdGUgRW1wbG95ZWVzCi0JCVN0cmluZyBleHBlY3RlZE5hbWUxICAgID0gIkRhbGlfMSI7Ci0JCVN0cmluZyBleHBlY3RlZE1hbmFnZXIxID0gIldUUF8xIjsKLQkJU3RyaW5nIGV4cGVjdGVkVGl0bGUxICAgPSAicGx1Zy1pbl8xIjsKLQotCQlTdHJpbmcgZXhwZWN0ZWROYW1lMiAgICA9ICJEYWxpXzIiOwotCQlTdHJpbmcgZXhwZWN0ZWRNYW5hZ2VyMiA9ICJXVFBfMiI7Ci0JCVN0cmluZyBleHBlY3RlZFRpdGxlMiAgID0gInBsdWctaW5fMiI7Ci0KLQkJU3RyaW5nIGV4cGVjdGVkTmFtZTMgICAgPSAiRGFsaV8zIjsKLQkJU3RyaW5nIGV4cGVjdGVkTWFuYWdlcjMgPSAiV1RQXzMiOwotCQlTdHJpbmcgZXhwZWN0ZWRUaXRsZTMgICA9ICJwbHVnLWluXzMiOwotCi0JCUVtcGxveWVlIGVtcGxveWVlMSA9IG5ldyBFbXBsb3llZShleHBlY3RlZE5hbWUxLCBleHBlY3RlZFRpdGxlMSwgZXhwZWN0ZWRNYW5hZ2VyMSk7Ci0JCUVtcGxveWVlIGVtcGxveWVlMiA9IG5ldyBFbXBsb3llZShleHBlY3RlZE5hbWUyLCBleHBlY3RlZFRpdGxlMiwgZXhwZWN0ZWRNYW5hZ2VyMik7Ci0JCUVtcGxveWVlIGVtcGxveWVlMyA9IG5ldyBFbXBsb3llZShleHBlY3RlZE5hbWUzLCBleHBlY3RlZFRpdGxlMywgZXhwZWN0ZWRNYW5hZ2VyMyk7Ci0KLQkJbWFuYWdlci5hZGRFbXBsb3llZShlbXBsb3llZTEpOwotCQltYW5hZ2VyLmFkZEVtcGxveWVlKGVtcGxveWVlMik7Ci0JCW1hbmFnZXIuYWRkRW1wbG95ZWUoZW1wbG95ZWUzKTsKLQotCQkvLyBNYWtlIHN1cmUgdGhlIFRhYmxlIHdhcyBwb3B1bGF0ZWQKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIG51bWJlciBvZiBUYWJsZUl0ZW1zIHNob3VsZCBiZSAzIiwgMywgdGFibGUuZ2V0SXRlbUNvdW50KCkpOwotCi0JCS8vIENoYW5nZSB0aGUgbGlzdCBvZiBFbXBsb3llZXMKLQkJQXJyYXlMaXN0PEVtcGxveWVlPiBlbXBsb3llZXMgPSBuZXcgQXJyYXlMaXN0PEVtcGxveWVlPigzKTsKLQkJZW1wbG95ZWVzLmFkZChlbXBsb3llZTMpOwotCQllbXBsb3llZXMuYWRkKGVtcGxveWVlMik7Ci0JCWVtcGxveWVlcy5hZGQoZW1wbG95ZWUxKTsKLQkJbWFuYWdlci5jaGFuZ2VFbXBsb3llZXMoZW1wbG95ZWVzKTsKLQotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgbnVtYmVyIG9mIFRhYmxlSXRlbXMgc2hvdWxkIGJlIDMiLCAzLCB0YWJsZS5nZXRJdGVtQ291bnQoKSk7Ci0KLQkJdGVzdFRhYmxlSXRlbVByb3BlcnRpZXModGFibGUsIDAsIGV4cGVjdGVkTmFtZTMsIGV4cGVjdGVkTWFuYWdlcjMsIGV4cGVjdGVkVGl0bGUzKTsKLQkJdGVzdFRhYmxlSXRlbVByb3BlcnRpZXModGFibGUsIDEsIGV4cGVjdGVkTmFtZTIsIGV4cGVjdGVkTWFuYWdlcjIsIGV4cGVjdGVkVGl0bGUyKTsKLQkJdGVzdFRhYmxlSXRlbVByb3BlcnRpZXModGFibGUsIDIsIGV4cGVjdGVkTmFtZTEsIGV4cGVjdGVkTWFuYWdlcjEsIGV4cGVjdGVkVGl0bGUxKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3RDbGVhcmVkKCkgewotCi0JCVRhYmxlIHRhYmxlID0gbmV3IFRhYmxlKHNoZWxsLCBTV1QuVl9TQ1JPTEwgfCBTV1QuSF9TQ1JPTEwgfCBTV1QuRlVMTF9TRUxFQ1RJT04gfCBTV1QuTVVMVEkpOwotCi0JCUxpc3RWYWx1ZU1vZGVsPEVtcGxveWVlPiBsaXN0SG9sZGVyID0gYnVpbGRFbXBsb3llZUxpc3RIb2xkZXIoKTsKLQkJV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8RW1wbG95ZWU+IHNlbGVjdGVkSXRlbUhvbGRlciA9IGJ1aWxkRW1wbG95ZWVIb2xkZXIoKTsKLQotCQlNYW5hZ2VyIG1hbmFnZXIgPSBuZXcgTWFuYWdlcigpOwotCQlzdWJqZWN0SG9sZGVyLnNldFZhbHVlKG1hbmFnZXIpOwotCi0JCW5ldyBUYWJsZU1vZGVsKAotCQkJbGlzdEhvbGRlciwKLQkJCXNlbGVjdGVkSXRlbUhvbGRlciwKLQkJCXRhYmxlLAotCQkJYnVpbGRDb2x1bW5BZGFwdGVyKCksCi0JCQlidWlsZExhYmVsUHJvdmlkZXIoKQotCQkpOwotCi0JCS8vIENyZWF0ZSBFbXBsb3llZXMKLQkJU3RyaW5nIGV4cGVjdGVkTmFtZTEgICAgPSAiRGFsaV8xIjsKLQkJU3RyaW5nIGV4cGVjdGVkTWFuYWdlcjEgPSAiV1RQXzEiOwotCQlTdHJpbmcgZXhwZWN0ZWRUaXRsZTEgICA9ICJwbHVnLWluXzEiOwotCi0JCVN0cmluZyBleHBlY3RlZE5hbWUyICAgID0gIkRhbGlfMiI7Ci0JCVN0cmluZyBleHBlY3RlZE1hbmFnZXIyID0gIldUUF8yIjsKLQkJU3RyaW5nIGV4cGVjdGVkVGl0bGUyICAgPSAicGx1Zy1pbl8yIjsKLQotCQlTdHJpbmcgZXhwZWN0ZWROYW1lMyAgICA9ICJEYWxpXzMiOwotCQlTdHJpbmcgZXhwZWN0ZWRNYW5hZ2VyMyA9ICJXVFBfMyI7Ci0JCVN0cmluZyBleHBlY3RlZFRpdGxlMyAgID0gInBsdWctaW5fMyI7Ci0KLQkJRW1wbG95ZWUgZW1wbG95ZWUxID0gbmV3IEVtcGxveWVlKGV4cGVjdGVkTmFtZTEsIGV4cGVjdGVkVGl0bGUxLCBleHBlY3RlZE1hbmFnZXIxKTsKLQkJRW1wbG95ZWUgZW1wbG95ZWUyID0gbmV3IEVtcGxveWVlKGV4cGVjdGVkTmFtZTIsIGV4cGVjdGVkVGl0bGUyLCBleHBlY3RlZE1hbmFnZXIyKTsKLQkJRW1wbG95ZWUgZW1wbG95ZWUzID0gbmV3IEVtcGxveWVlKGV4cGVjdGVkTmFtZTMsIGV4cGVjdGVkVGl0bGUzLCBleHBlY3RlZE1hbmFnZXIzKTsKLQotCQltYW5hZ2VyLmFkZEVtcGxveWVlKGVtcGxveWVlMSk7Ci0JCW1hbmFnZXIuYWRkRW1wbG95ZWUoZW1wbG95ZWUyKTsKLQkJbWFuYWdlci5hZGRFbXBsb3llZShlbXBsb3llZTMpOwotCi0JCS8vIE1ha2Ugc3VyZSB0aGUgVGFibGUgd2FzIHBvcHVsYXRlZAotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgbnVtYmVyIG9mIFRhYmxlSXRlbXMgc2hvdWxkIGJlIDMiLCAzLCB0YWJsZS5nZXRJdGVtQ291bnQoKSk7Ci0KLQkJLy8gVGVzdCByZW1vdmluZyB0aGVtIGFsbAotCQltYW5hZ2VyLnJlbW92ZUFsbEVtcGxveWVlcygpOwotCi0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBsaXN0IGhvbGRlciBzaG91bGQgaGF2ZSBiZWVuIGNsZWFyZWQiLCAwLCBsaXN0SG9sZGVyLnNpemUoKSk7Ci0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBUYWJsZSBzaG91bGQgaGF2ZSBiZWVuIGNsZWFyZWQiLCAwLCB0YWJsZS5nZXRJdGVtQ291bnQoKSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0SXRlbUFkZGVkKCkgewotCi0JCVRhYmxlIHRhYmxlID0gbmV3IFRhYmxlKHNoZWxsLCBTV1QuVl9TQ1JPTEwgfCBTV1QuSF9TQ1JPTEwgfCBTV1QuRlVMTF9TRUxFQ1RJT04gfCBTV1QuTVVMVEkpOwotCi0JCUxpc3RWYWx1ZU1vZGVsPEVtcGxveWVlPiBsaXN0SG9sZGVyID0gYnVpbGRFbXBsb3llZUxpc3RIb2xkZXIoKTsKLQkJV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8RW1wbG95ZWU+IHNlbGVjdGVkSXRlbUhvbGRlciA9IGJ1aWxkRW1wbG95ZWVIb2xkZXIoKTsKLQotCQlNYW5hZ2VyIG1hbmFnZXIgPSBuZXcgTWFuYWdlcigpOwotCQlzdWJqZWN0SG9sZGVyLnNldFZhbHVlKG1hbmFnZXIpOwotCi0JCVRhYmxlTW9kZWwgdGFibGVNb2RlbCA9IG5ldyBUYWJsZU1vZGVsKAotCQkJbGlzdEhvbGRlciwKLQkJCXNlbGVjdGVkSXRlbUhvbGRlciwKLQkJCXRhYmxlLAotCQkJYnVpbGRDb2x1bW5BZGFwdGVyKCksCi0JCQlidWlsZExhYmVsUHJvdmlkZXIoKQotCQkpOwotCi0JCS8vIENyZWF0ZSBhIG5ldyBFbXBsb3llZQotCQlTdHJpbmcgZXhwZWN0ZWROYW1lICAgID0gIkRhbGkiOwotCQlTdHJpbmcgZXhwZWN0ZWRNYW5hZ2VyID0gIldUUCI7Ci0JCVN0cmluZyBleHBlY3RlZFRpdGxlICAgPSAicGx1Zy1pbiI7Ci0KLQkJRW1wbG95ZWUgZW1wbG95ZWUgPSBtYW5hZ2VyLmFkZEVtcGxveWVlKGV4cGVjdGVkTmFtZSwgZXhwZWN0ZWRUaXRsZSwgZXhwZWN0ZWRNYW5hZ2VyKTsKLQkJQXNzZXJ0LmFzc2VydE5vdE51bGwoIlRoZSBuZXcgRW1wbG95ZWUgd2FzIG5vdCBjcmVhdGVkIiwgZW1wbG95ZWUpOwotCi0JCS8vIFJldHJpZXZlIHRoZSBUYWJsZUl0ZW0gcmVwcmVzZW50aW5nIHRoZSBuZXcgRW1wbG95ZWUKLQkJaW50IGluZGV4ID0gdGFibGVNb2RlbC5pbmRleE9mKGVtcGxveWVlKTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIG5ldyBFbXBsb3llZSB3YXMgbm90IGFkZGVkIHRvIHRoZSB0YWJsZSBtb2RlbCIsIDAsIGluZGV4KTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIG51bWJlciBvZiBUYWJsZUl0ZW0gc2hvdWxkIGJlIDEiLCAxLCB0YWJsZS5nZXRJdGVtQ291bnQoKSk7Ci0KLQkJdGVzdFRhYmxlSXRlbVByb3BlcnRpZXModGFibGUsIGluZGV4LCBleHBlY3RlZE5hbWUsIGV4cGVjdGVkTWFuYWdlciwgZXhwZWN0ZWRUaXRsZSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0SXRlbU1vdmVkKCkgewotCi0JCVRhYmxlIHRhYmxlID0gbmV3IFRhYmxlKHNoZWxsLCBTV1QuVl9TQ1JPTEwgfCBTV1QuSF9TQ1JPTEwgfCBTV1QuRlVMTF9TRUxFQ1RJT04gfCBTV1QuTVVMVEkpOwotCi0JCUxpc3RWYWx1ZU1vZGVsPEVtcGxveWVlPiBsaXN0SG9sZGVyID0gYnVpbGRFbXBsb3llZUxpc3RIb2xkZXIoKTsKLQkJV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8RW1wbG95ZWU+IHNlbGVjdGVkSXRlbUhvbGRlciA9IGJ1aWxkRW1wbG95ZWVIb2xkZXIoKTsKLQotCQlNYW5hZ2VyIG1hbmFnZXIgPSBuZXcgTWFuYWdlcigpOwotCQlzdWJqZWN0SG9sZGVyLnNldFZhbHVlKG1hbmFnZXIpOwotCi0JCVRhYmxlTW9kZWwgdGFibGVNb2RlbCA9IG5ldyBUYWJsZU1vZGVsKAotCQkJbGlzdEhvbGRlciwKLQkJCXNlbGVjdGVkSXRlbUhvbGRlciwKLQkJCXRhYmxlLAotCQkJYnVpbGRDb2x1bW5BZGFwdGVyKCksCi0JCQlidWlsZExhYmVsUHJvdmlkZXIoKQotCQkpOwotCi0JCS8vIENyZWF0ZSBFbXBsb3llZXMKLQkJU3RyaW5nIGV4cGVjdGVkTmFtZTEgICAgPSAiRGFsaV8xIjsKLQkJU3RyaW5nIGV4cGVjdGVkTWFuYWdlcjEgPSAiV1RQXzEiOwotCQlTdHJpbmcgZXhwZWN0ZWRUaXRsZTEgICA9ICJwbHVnLWluXzEiOwotCi0JCVN0cmluZyBleHBlY3RlZE5hbWUyICAgID0gIkRhbGlfMiI7Ci0JCVN0cmluZyBleHBlY3RlZE1hbmFnZXIyID0gIldUUF8yIjsKLQkJU3RyaW5nIGV4cGVjdGVkVGl0bGUyICAgPSAicGx1Zy1pbl8yIjsKLQotCQlTdHJpbmcgZXhwZWN0ZWROYW1lMyAgICA9ICJEYWxpXzMiOwotCQlTdHJpbmcgZXhwZWN0ZWRNYW5hZ2VyMyA9ICJXVFBfMyI7Ci0JCVN0cmluZyBleHBlY3RlZFRpdGxlMyAgID0gInBsdWctaW5fMyI7Ci0KLQkJRW1wbG95ZWUgZW1wbG95ZWUxID0gbmV3IEVtcGxveWVlKGV4cGVjdGVkTmFtZTEsIGV4cGVjdGVkVGl0bGUxLCBleHBlY3RlZE1hbmFnZXIxKTsKLQkJRW1wbG95ZWUgZW1wbG95ZWUyID0gbmV3IEVtcGxveWVlKGV4cGVjdGVkTmFtZTIsIGV4cGVjdGVkVGl0bGUyLCBleHBlY3RlZE1hbmFnZXIyKTsKLQkJRW1wbG95ZWUgZW1wbG95ZWUzID0gbmV3IEVtcGxveWVlKGV4cGVjdGVkTmFtZTMsIGV4cGVjdGVkVGl0bGUzLCBleHBlY3RlZE1hbmFnZXIzKTsKLQotCQltYW5hZ2VyLmFkZEVtcGxveWVlKGVtcGxveWVlMSk7Ci0JCW1hbmFnZXIuYWRkRW1wbG95ZWUoZW1wbG95ZWUyKTsKLQkJbWFuYWdlci5hZGRFbXBsb3llZShlbXBsb3llZTMpOwotCi0JCS8vIE1ha2Ugc3VyZSB0aGUgRW1wbG95ZWVzIHdlcmUgYWRkZWQgdG8gdGhlIFRhYmxlCi0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBudW1iZXIgb2YgVGFibGVJdGVtIHNob3VsZCBiZSAzIiwgMywgdGFibGUuZ2V0SXRlbUNvdW50KCkpOwotCi0JCS8vIE1vdmUgYW4gRW1wbG95ZWUgdXAgdGhlIGxpc3QKLQkJbWFuYWdlci5tb3ZlRW1wbG95ZWVVcChlbXBsb3llZTIpOwotCi0JCWludCBpbmRleDEgPSB0YWJsZU1vZGVsLmluZGV4T2YoZW1wbG95ZWUxKTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIEVtcGxveWVlIDEgd2FzIG5vdCBtb3ZlZCBpbiB0aGUgdGFibGUgbW9kZWwiLCAxLCBpbmRleDEpOwotCi0JCWludCBpbmRleDIgPSB0YWJsZU1vZGVsLmluZGV4T2YoZW1wbG95ZWUyKTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIEVtcGxveWVlIDIgd2FzIG5vdCBtb3ZlZCBpbiB0aGUgdGFibGUgbW9kZWwiLCAwLCBpbmRleDIpOwotCi0JCWludCBpbmRleDMgPSB0YWJsZU1vZGVsLmluZGV4T2YoZW1wbG95ZWUzKTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIEVtcGxveWVlIDMgc2hvdWxkIG5vdCBoYXZlIGJlZW4gbW92ZWQgaW4gdGhlIHRhYmxlIG1vZGVsIiwgMiwgaW5kZXgzKTsKLQotCQl0ZXN0VGFibGVJdGVtUHJvcGVydGllcyh0YWJsZSwgaW5kZXgxLCBleHBlY3RlZE5hbWUxLCBleHBlY3RlZE1hbmFnZXIxLCBleHBlY3RlZFRpdGxlMSk7Ci0JCXRlc3RUYWJsZUl0ZW1Qcm9wZXJ0aWVzKHRhYmxlLCBpbmRleDIsIGV4cGVjdGVkTmFtZTIsIGV4cGVjdGVkTWFuYWdlcjIsIGV4cGVjdGVkVGl0bGUyKTsKLQkJdGVzdFRhYmxlSXRlbVByb3BlcnRpZXModGFibGUsIGluZGV4MywgZXhwZWN0ZWROYW1lMywgZXhwZWN0ZWRNYW5hZ2VyMywgZXhwZWN0ZWRUaXRsZTMpOwotCi0JCS8vIE1vdmUgYW4gRW1wbG95ZWUgZG93biB0aGUgbGlzdAotCQltYW5hZ2VyLm1vdmVFbXBsb3llZURvd24oZW1wbG95ZWUxKTsKLQotCQlpbmRleDEgPSB0YWJsZU1vZGVsLmluZGV4T2YoZW1wbG95ZWUxKTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIEVtcGxveWVlIDEgc2hvdWxkIG5vdCBoYXZlIGJlZW4gbW92ZWQgaW4gdGhlIHRhYmxlIG1vZGVsIiwgMiwgaW5kZXgxKTsKLQotCQlpbmRleDIgPSB0YWJsZU1vZGVsLmluZGV4T2YoZW1wbG95ZWUyKTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIEVtcGxveWVlIDIgd2FzIG5vdCBtb3ZlZCBpbiB0aGUgdGFibGUgbW9kZWwiLCAwLCBpbmRleDIpOwotCi0JCWluZGV4MyA9IHRhYmxlTW9kZWwuaW5kZXhPZihlbXBsb3llZTMpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgRW1wbG95ZWUgMyB3YXMgbm90IG1vdmVkIGluIHRoZSB0YWJsZSBtb2RlbCIsIDEsIGluZGV4Myk7Ci0KLQkJdGVzdFRhYmxlSXRlbVByb3BlcnRpZXModGFibGUsIGluZGV4MSwgZXhwZWN0ZWROYW1lMSwgZXhwZWN0ZWRNYW5hZ2VyMSwgZXhwZWN0ZWRUaXRsZTEpOwotCQl0ZXN0VGFibGVJdGVtUHJvcGVydGllcyh0YWJsZSwgaW5kZXgyLCBleHBlY3RlZE5hbWUyLCBleHBlY3RlZE1hbmFnZXIyLCBleHBlY3RlZFRpdGxlMik7Ci0JCXRlc3RUYWJsZUl0ZW1Qcm9wZXJ0aWVzKHRhYmxlLCBpbmRleDMsIGV4cGVjdGVkTmFtZTMsIGV4cGVjdGVkTWFuYWdlcjMsIGV4cGVjdGVkVGl0bGUzKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3RJdGVtUmVtb3ZlZCgpIHsKLQotCQlUYWJsZSB0YWJsZSA9IG5ldyBUYWJsZShzaGVsbCwgU1dULlZfU0NST0xMIHwgU1dULkhfU0NST0xMIHwgU1dULkZVTExfU0VMRUNUSU9OIHwgU1dULk1VTFRJKTsKLQotCQlMaXN0VmFsdWVNb2RlbDxFbXBsb3llZT4gbGlzdEhvbGRlciA9IGJ1aWxkRW1wbG95ZWVMaXN0SG9sZGVyKCk7Ci0JCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEVtcGxveWVlPiBzZWxlY3RlZEl0ZW1Ib2xkZXIgPSBidWlsZEVtcGxveWVlSG9sZGVyKCk7Ci0KLQkJTWFuYWdlciBtYW5hZ2VyID0gbmV3IE1hbmFnZXIoKTsKLQkJc3ViamVjdEhvbGRlci5zZXRWYWx1ZShtYW5hZ2VyKTsKLQotCQlUYWJsZU1vZGVsIHRhYmxlTW9kZWwgPSBuZXcgVGFibGVNb2RlbCgKLQkJCWxpc3RIb2xkZXIsCi0JCQlzZWxlY3RlZEl0ZW1Ib2xkZXIsCi0JCQl0YWJsZSwKLQkJCWJ1aWxkQ29sdW1uQWRhcHRlcigpLAotCQkJYnVpbGRMYWJlbFByb3ZpZGVyKCkKLQkJKTsKLQotCQkvLyBDcmVhdGUgYSBuZXcgRW1wbG95ZWUKLQkJU3RyaW5nIGV4cGVjdGVkTmFtZSAgICA9ICJEYWxpIjsKLQkJU3RyaW5nIGV4cGVjdGVkTWFuYWdlciA9ICJXVFAiOwotCQlTdHJpbmcgZXhwZWN0ZWRUaXRsZSAgID0gInBsdWctaW4iOwotCi0JCUVtcGxveWVlIGVtcGxveWVlID0gbWFuYWdlci5hZGRFbXBsb3llZShleHBlY3RlZE5hbWUsIGV4cGVjdGVkVGl0bGUsIGV4cGVjdGVkTWFuYWdlcik7Ci0JCUFzc2VydC5hc3NlcnROb3ROdWxsKCJUaGUgbmV3IEVtcGxveWVlIHdhcyBub3QgY3JlYXRlZCIsIGVtcGxveWVlKTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIG51bWJlciBvZiBUYWJsZUl0ZW0gc2hvdWxkIGJlIDEiLCAxLCB0YWJsZS5nZXRJdGVtQ291bnQoKSk7Ci0KLQkJLy8gTWFrZSBzdXJlIGl0IHdhcyBhZGRlZCB0byB0aGUgbW9kZWwKLQkJaW50IGluZGV4ID0gdGFibGVNb2RlbC5pbmRleE9mKGVtcGxveWVlKTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIG5ldyBFbXBsb3llZSB3YXMgbm90IGFkZGVkIHRvIHRoZSB0YWJsZSBtb2RlbCIsIDAsIGluZGV4KTsKLQkJdGVzdFRhYmxlSXRlbVByb3BlcnRpZXModGFibGUsIGluZGV4LCBleHBlY3RlZE5hbWUsIGV4cGVjdGVkTWFuYWdlciwgZXhwZWN0ZWRUaXRsZSk7Ci0KLQkJLy8gUmV0cmlldmUgdGhlIFRhYmxlSXRlbSByZXByZXNlbnRpbmcgdGhlIG5ldyBFbXBsb3llZQotCQlUYWJsZUl0ZW0gdGFibGVJdGVtID0gdGFibGUuZ2V0SXRlbShpbmRleCk7Ci0JCUFzc2VydC5hc3NlcnROb3ROdWxsKCJObyBUYWJsZUl0ZW0gd2FzIGZvdW5kIGZvciB0aGUgbmV3IEVtcGxveWVlIiwgdGFibGVJdGVtKTsKLQotCQkvLyBOb3cgdGVzdCB0aGUgaXRlbSBiZWluZyByZW1vdmVkCi0JCW1hbmFnZXIucmVtb3ZlRW1wbG95ZWUoZW1wbG95ZWUpOwotCQlpbmRleCA9IHRhYmxlTW9kZWwuaW5kZXhPZihlbXBsb3llZSk7Ci0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBFbXBsb3llZSB3YXMgbm90IHJlbW92ZWQgZnJvbSB0aGUgdGFibGUgbW9kZWwiLCAtMSwgaW5kZXgpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgbnVtYmVyIG9mIFRhYmxlSXRlbSBzaG91bGQgYmUgMCIsIDAsIHRhYmxlLmdldEl0ZW1Db3VudCgpKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3RJdGVtUmVwbGFjZWQoKSB7Ci0KLQkJVGFibGUgdGFibGUgPSBuZXcgVGFibGUoc2hlbGwsIFNXVC5WX1NDUk9MTCB8IFNXVC5IX1NDUk9MTCB8IFNXVC5GVUxMX1NFTEVDVElPTiB8IFNXVC5NVUxUSSk7Ci0KLQkJTGlzdFZhbHVlTW9kZWw8RW1wbG95ZWU+IGxpc3RIb2xkZXIgPSBidWlsZEVtcGxveWVlTGlzdEhvbGRlcigpOwotCQlXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxFbXBsb3llZT4gc2VsZWN0ZWRJdGVtSG9sZGVyID0gYnVpbGRFbXBsb3llZUhvbGRlcigpOwotCi0JCU1hbmFnZXIgbWFuYWdlciA9IG5ldyBNYW5hZ2VyKCk7Ci0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobWFuYWdlcik7Ci0KLQkJVGFibGVNb2RlbCB0YWJsZU1vZGVsID0gbmV3IFRhYmxlTW9kZWwoCi0JCQlsaXN0SG9sZGVyLAotCQkJc2VsZWN0ZWRJdGVtSG9sZGVyLAotCQkJdGFibGUsCi0JCQlidWlsZENvbHVtbkFkYXB0ZXIoKSwKLQkJCWJ1aWxkTGFiZWxQcm92aWRlcigpCi0JCSk7Ci0KLQkJLy8gQ3JlYXRlIGEgbmV3IEVtcGxveWVlCi0JCVN0cmluZyBleHBlY3RlZE5hbWUxICAgID0gIkRhbGlfMSI7Ci0JCVN0cmluZyBleHBlY3RlZE1hbmFnZXIxID0gIldUUF8xIjsKLQkJU3RyaW5nIGV4cGVjdGVkVGl0bGUxICAgPSAicGx1Zy1pbl8xIjsKLQotCQlFbXBsb3llZSBlbXBsb3llZTEgPSBtYW5hZ2VyLmFkZEVtcGxveWVlKGV4cGVjdGVkTmFtZTEsIGV4cGVjdGVkVGl0bGUxLCBleHBlY3RlZE1hbmFnZXIxKTsKLQkJQXNzZXJ0LmFzc2VydE5vdE51bGwoIlRoZSBuZXcgRW1wbG95ZWUgd2FzIG5vdCBjcmVhdGVkIiwgZW1wbG95ZWUxKTsKLQotCQkvLyBNYWtlIHN1cmUgaXQgd2FzIGFkZGVkIHRvIHRoZSBtb2RlbAotCQlpbnQgaW5kZXgxID0gdGFibGVNb2RlbC5pbmRleE9mKGVtcGxveWVlMSk7Ci0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBuZXcgRW1wbG95ZWUgd2FzIG5vdCBhZGRlZCB0byB0aGUgdGFibGUgbW9kZWwiLCAwLCBpbmRleDEpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgbnVtYmVyIG9mIFRhYmxlSXRlbSBzaG91bGQgYmUgMSIsIDEsIHRhYmxlLmdldEl0ZW1Db3VudCgpKTsKLQotCQkvLyBSZXRyaWV2ZSB0aGUgVGFibGVJdGVtIHJlcHJlc2VudGluZyB0aGUgbmV3IEVtcGxveWVlCi0JCVRhYmxlSXRlbSB0YWJsZUl0ZW0gPSB0YWJsZS5nZXRJdGVtKGluZGV4MSk7Ci0JCUFzc2VydC5hc3NlcnROb3ROdWxsKCJObyBUYWJsZUl0ZW0gd2FzIGZvdW5kIGZvciB0aGUgbmV3IEVtcGxveWVlIiwgdGFibGVJdGVtKTsKLQotCQl0ZXN0VGFibGVJdGVtUHJvcGVydGllcyh0YWJsZSwgaW5kZXgxLCBleHBlY3RlZE5hbWUxLCBleHBlY3RlZE1hbmFnZXIxLCBleHBlY3RlZFRpdGxlMSk7Ci0KLQkJLy8gUmVwbGFjZSB0aGUgRW1wbG95ZWUKLQkJU3RyaW5nIGV4cGVjdGVkTmFtZTIgICAgPSAiRGFsaV8yIjsKLQkJU3RyaW5nIGV4cGVjdGVkTWFuYWdlcjIgPSAiV1RQXzIiOwotCQlTdHJpbmcgZXhwZWN0ZWRUaXRsZTIgICA9ICJwbHVnLWluXzIiOwotCi0JCUVtcGxveWVlIGVtcGxveWVlMiA9IG5ldyBFbXBsb3llZShleHBlY3RlZE5hbWUyLCBleHBlY3RlZFRpdGxlMiwgZXhwZWN0ZWRNYW5hZ2VyMik7Ci0JCW1hbmFnZXIucmVwbGFjZShlbXBsb3llZTEsIGVtcGxveWVlMik7Ci0KLQkJaW50IGluZGV4MiA9IHRhYmxlTW9kZWwuaW5kZXhPZihlbXBsb3llZTIpOwotCQlBc3NlcnQuYXNzZXJ0U2FtZSgiVGhlIEVtcGxveWVlIHRoYXQgZ290IHJlcGxhY2VkIHNob3VsZCBiZSBhdCBpbmRleCAiICsgaW5kZXgxLCBpbmRleDEsIGluZGV4Mik7Ci0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBudW1iZXIgb2YgVGFibGVJdGVtIHNob3VsZCBiZSAxIiwgMSwgdGFibGUuZ2V0SXRlbUNvdW50KCkpOwotCi0JCXRlc3RUYWJsZUl0ZW1Qcm9wZXJ0aWVzKHRhYmxlLCBpbmRleDIsIGV4cGVjdGVkTmFtZTIsIGV4cGVjdGVkTWFuYWdlcjIsIGV4cGVjdGVkVGl0bGUyKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3RJdGVtc0FkZGVkKCkgewotCi0JCVRhYmxlIHRhYmxlID0gbmV3IFRhYmxlKHNoZWxsLCBTV1QuVl9TQ1JPTEwgfCBTV1QuSF9TQ1JPTEwgfCBTV1QuRlVMTF9TRUxFQ1RJT04gfCBTV1QuTVVMVEkpOwotCi0JCUxpc3RWYWx1ZU1vZGVsPEVtcGxveWVlPiBsaXN0SG9sZGVyID0gYnVpbGRFbXBsb3llZUxpc3RIb2xkZXIoKTsKLQkJV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8RW1wbG95ZWU+IHNlbGVjdGVkSXRlbUhvbGRlciA9IGJ1aWxkRW1wbG95ZWVIb2xkZXIoKTsKLQotCQlNYW5hZ2VyIG1hbmFnZXIgPSBuZXcgTWFuYWdlcigpOwotCQlzdWJqZWN0SG9sZGVyLnNldFZhbHVlKG1hbmFnZXIpOwotCi0JCVRhYmxlTW9kZWwgdGFibGVNb2RlbCA9IG5ldyBUYWJsZU1vZGVsKAotCQkJbGlzdEhvbGRlciwKLQkJCXNlbGVjdGVkSXRlbUhvbGRlciwKLQkJCXRhYmxlLAotCQkJYnVpbGRDb2x1bW5BZGFwdGVyKCksCi0JCQlidWlsZExhYmVsUHJvdmlkZXIoKQotCQkpOwotCi0JCS8vIENyZWF0ZSBFbXBsb3llZXMKLQkJU3RyaW5nIGV4cGVjdGVkTmFtZTEgICAgPSAiRGFsaV8xIjsKLQkJU3RyaW5nIGV4cGVjdGVkTWFuYWdlcjEgPSAiV1RQXzEiOwotCQlTdHJpbmcgZXhwZWN0ZWRUaXRsZTEgICA9ICJwbHVnLWluXzEiOwotCi0JCVN0cmluZyBleHBlY3RlZE5hbWUyICAgID0gIkRhbGlfMiI7Ci0JCVN0cmluZyBleHBlY3RlZE1hbmFnZXIyID0gIldUUF8yIjsKLQkJU3RyaW5nIGV4cGVjdGVkVGl0bGUyICAgPSAicGx1Zy1pbl8yIjsKLQotCQlTdHJpbmcgZXhwZWN0ZWROYW1lMyAgICA9ICJEYWxpXzMiOwotCQlTdHJpbmcgZXhwZWN0ZWRNYW5hZ2VyMyA9ICJXVFBfMyI7Ci0JCVN0cmluZyBleHBlY3RlZFRpdGxlMyAgID0gInBsdWctaW5fMyI7Ci0KLQkJRW1wbG95ZWUgZW1wbG95ZWUxID0gbmV3IEVtcGxveWVlKGV4cGVjdGVkTmFtZTEsIGV4cGVjdGVkVGl0bGUxLCBleHBlY3RlZE1hbmFnZXIxKTsKLQkJRW1wbG95ZWUgZW1wbG95ZWUyID0gbmV3IEVtcGxveWVlKGV4cGVjdGVkTmFtZTIsIGV4cGVjdGVkVGl0bGUyLCBleHBlY3RlZE1hbmFnZXIyKTsKLQkJRW1wbG95ZWUgZW1wbG95ZWUzID0gbmV3IEVtcGxveWVlKGV4cGVjdGVkTmFtZTMsIGV4cGVjdGVkVGl0bGUzLCBleHBlY3RlZE1hbmFnZXIzKTsKLQotCQltYW5hZ2VyLmFkZEVtcGxveWVlKGVtcGxveWVlMSk7Ci0JCW1hbmFnZXIuYWRkRW1wbG95ZWUoZW1wbG95ZWUyKTsKLQkJbWFuYWdlci5hZGRFbXBsb3llZShlbXBsb3llZTMpOwotCi0JCS8vIFJldHJpZXZlIHRoZSBUYWJsZUl0ZW1zIHJlcHJlc2VudGluZyB0aGUgZW1wbG95ZWVzCi0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBudW1iZXIgb2YgVGFibGVJdGVtIHNob3VsZCBiZSAzIiwgMywgdGFibGUuZ2V0SXRlbUNvdW50KCkpOwotCi0JCWludCBpbmRleCA9IHRhYmxlTW9kZWwuaW5kZXhPZihlbXBsb3llZTEpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgRW1wbG95ZWUgMSB3YXMgbm90IGFkZGVkIHRvIHRoZSB0YWJsZSBtb2RlbCIsIDAsIGluZGV4KTsKLQotCQlpbmRleCA9IHRhYmxlTW9kZWwuaW5kZXhPZihlbXBsb3llZTIpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgRW1wbG95ZWUgMiB3YXMgbm90IGFkZGVkIHRvIHRoZSB0YWJsZSBtb2RlbCIsIDEsIGluZGV4KTsKLQotCQlpbmRleCA9IHRhYmxlTW9kZWwuaW5kZXhPZihlbXBsb3llZTMpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgRW1wbG95ZWUgMyB3YXMgbm90IGFkZGVkIHRvIHRoZSB0YWJsZSBtb2RlbCIsIDIsIGluZGV4KTsKLQotCQkvLyBNYWtlIHN1cmUgdGhlIFRhYmxlSXRlbSB3YXMgY29ycmVjdGx5IHBvcHVsYXRlZAotCQl0ZXN0VGFibGVJdGVtUHJvcGVydGllcyh0YWJsZSwgMCwgZXhwZWN0ZWROYW1lMSwgZXhwZWN0ZWRNYW5hZ2VyMSwgZXhwZWN0ZWRUaXRsZTEpOwotCQl0ZXN0VGFibGVJdGVtUHJvcGVydGllcyh0YWJsZSwgMSwgZXhwZWN0ZWROYW1lMiwgZXhwZWN0ZWRNYW5hZ2VyMiwgZXhwZWN0ZWRUaXRsZTIpOwotCQl0ZXN0VGFibGVJdGVtUHJvcGVydGllcyh0YWJsZSwgMiwgZXhwZWN0ZWROYW1lMywgZXhwZWN0ZWRNYW5hZ2VyMywgZXhwZWN0ZWRUaXRsZTMpOwotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdEl0ZW1zTW92ZWQoKSB7Ci0KLQkJVGFibGUgdGFibGUgPSBuZXcgVGFibGUoc2hlbGwsIFNXVC5WX1NDUk9MTCB8IFNXVC5IX1NDUk9MTCB8IFNXVC5GVUxMX1NFTEVDVElPTiB8IFNXVC5NVUxUSSk7Ci0KLQkJTGlzdFZhbHVlTW9kZWw8RW1wbG95ZWU+IGxpc3RIb2xkZXIgPSBidWlsZEVtcGxveWVlTGlzdEhvbGRlcigpOwotCQlXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxFbXBsb3llZT4gc2VsZWN0ZWRJdGVtSG9sZGVyID0gYnVpbGRFbXBsb3llZUhvbGRlcigpOwotCi0JCU1hbmFnZXIgbWFuYWdlciA9IG5ldyBNYW5hZ2VyKCk7Ci0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobWFuYWdlcik7Ci0KLQkJVGFibGVNb2RlbCB0YWJsZU1vZGVsID0gbmV3IFRhYmxlTW9kZWwoCi0JCQlsaXN0SG9sZGVyLAotCQkJc2VsZWN0ZWRJdGVtSG9sZGVyLAotCQkJdGFibGUsCi0JCQlidWlsZENvbHVtbkFkYXB0ZXIoKSwKLQkJCWJ1aWxkTGFiZWxQcm92aWRlcigpCi0JCSk7Ci0KLQkJLy8gQ3JlYXRlIEVtcGxveWVlcwotCQlTdHJpbmcgZXhwZWN0ZWROYW1lMSAgICA9ICJEYWxpXzEiOwotCQlTdHJpbmcgZXhwZWN0ZWRNYW5hZ2VyMSA9ICJXVFBfMSI7Ci0JCVN0cmluZyBleHBlY3RlZFRpdGxlMSAgID0gInBsdWctaW5fMSI7Ci0KLQkJU3RyaW5nIGV4cGVjdGVkTmFtZTIgICAgPSAiRGFsaV8yIjsKLQkJU3RyaW5nIGV4cGVjdGVkTWFuYWdlcjIgPSAiV1RQXzIiOwotCQlTdHJpbmcgZXhwZWN0ZWRUaXRsZTIgICA9ICJwbHVnLWluXzIiOwotCi0JCVN0cmluZyBleHBlY3RlZE5hbWUzICAgID0gIkRhbGlfMyI7Ci0JCVN0cmluZyBleHBlY3RlZE1hbmFnZXIzID0gIldUUF8zIjsKLQkJU3RyaW5nIGV4cGVjdGVkVGl0bGUzICAgPSAicGx1Zy1pbl8zIjsKLQotCQlTdHJpbmcgZXhwZWN0ZWROYW1lNCAgICA9ICJEYWxpXzQiOwotCQlTdHJpbmcgZXhwZWN0ZWRNYW5hZ2VyNCA9ICJXVFBfNCI7Ci0JCVN0cmluZyBleHBlY3RlZFRpdGxlNCAgID0gInBsdWctaW5fNCI7Ci0KLQkJU3RyaW5nIGV4cGVjdGVkTmFtZTUgICAgPSAiRGFsaV81IjsKLQkJU3RyaW5nIGV4cGVjdGVkTWFuYWdlcjUgPSAiV1RQXzUiOwotCQlTdHJpbmcgZXhwZWN0ZWRUaXRsZTUgICA9ICJwbHVnLWluXzUiOwotCi0JCVN0cmluZyBleHBlY3RlZE5hbWU2ICAgID0gIkRhbGlfNiI7Ci0JCVN0cmluZyBleHBlY3RlZE1hbmFnZXI2ID0gIldUUF82IjsKLQkJU3RyaW5nIGV4cGVjdGVkVGl0bGU2ICAgPSAicGx1Zy1pbl82IjsKLQotCQlFbXBsb3llZSBlbXBsb3llZTEgPSBuZXcgRW1wbG95ZWUoZXhwZWN0ZWROYW1lMSwgZXhwZWN0ZWRUaXRsZTEsIGV4cGVjdGVkTWFuYWdlcjEpOwotCQlFbXBsb3llZSBlbXBsb3llZTIgPSBuZXcgRW1wbG95ZWUoZXhwZWN0ZWROYW1lMiwgZXhwZWN0ZWRUaXRsZTIsIGV4cGVjdGVkTWFuYWdlcjIpOwotCQlFbXBsb3llZSBlbXBsb3llZTMgPSBuZXcgRW1wbG95ZWUoZXhwZWN0ZWROYW1lMywgZXhwZWN0ZWRUaXRsZTMsIGV4cGVjdGVkTWFuYWdlcjMpOwotCQlFbXBsb3llZSBlbXBsb3llZTQgPSBuZXcgRW1wbG95ZWUoZXhwZWN0ZWROYW1lNCwgZXhwZWN0ZWRUaXRsZTQsIGV4cGVjdGVkTWFuYWdlcjQpOwotCQlFbXBsb3llZSBlbXBsb3llZTUgPSBuZXcgRW1wbG95ZWUoZXhwZWN0ZWROYW1lNSwgZXhwZWN0ZWRUaXRsZTUsIGV4cGVjdGVkTWFuYWdlcjUpOwotCQlFbXBsb3llZSBlbXBsb3llZTYgPSBuZXcgRW1wbG95ZWUoZXhwZWN0ZWROYW1lNiwgZXhwZWN0ZWRUaXRsZTYsIGV4cGVjdGVkTWFuYWdlcjYpOwotCi0JCW1hbmFnZXIuYWRkRW1wbG95ZWUoZW1wbG95ZWUxKTsKLQkJbWFuYWdlci5hZGRFbXBsb3llZShlbXBsb3llZTIpOwotCQltYW5hZ2VyLmFkZEVtcGxveWVlKGVtcGxveWVlMyk7Ci0JCW1hbmFnZXIuYWRkRW1wbG95ZWUoZW1wbG95ZWU0KTsKLQkJbWFuYWdlci5hZGRFbXBsb3llZShlbXBsb3llZTUpOwotCQltYW5hZ2VyLmFkZEVtcGxveWVlKGVtcGxveWVlNik7Ci0KLQkJLy8gTWFrZSBzdXJlIHRoZSBFbXBsb3llZXMgd2VyZSBhZGRlZCB0byB0aGUgVGFibGUKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIG51bWJlciBvZiBUYWJsZUl0ZW0gc2hvdWxkIGJlIDYiLCA2LCB0YWJsZS5nZXRJdGVtQ291bnQoKSk7Ci0KLQkJLy8gTW92ZSBhbiBFbXBsb3llZSB1cCB0aGUgbGlzdAotCQlBcnJheUxpc3Q8RW1wbG95ZWU+IGVtcGxveWVlcyA9IG5ldyBBcnJheUxpc3Q8RW1wbG95ZWU+KDMpOwotCQllbXBsb3llZXMuYWRkKGVtcGxveWVlMyk7Ci0JCWVtcGxveWVlcy5hZGQoZW1wbG95ZWU0KTsKLQkJZW1wbG95ZWVzLmFkZChlbXBsb3llZTUpOwotCQltYW5hZ2VyLm1vdmVFbXBsb3llZXMoZW1wbG95ZWVzLCAwKTsKLQotCQlpbnQgaW5kZXgxID0gdGFibGVNb2RlbC5pbmRleE9mKGVtcGxveWVlMSk7Ci0JCWludCBpbmRleDIgPSB0YWJsZU1vZGVsLmluZGV4T2YoZW1wbG95ZWUyKTsKLQkJaW50IGluZGV4MyA9IHRhYmxlTW9kZWwuaW5kZXhPZihlbXBsb3llZTMpOwotCQlpbnQgaW5kZXg0ID0gdGFibGVNb2RlbC5pbmRleE9mKGVtcGxveWVlNCk7Ci0JCWludCBpbmRleDUgPSB0YWJsZU1vZGVsLmluZGV4T2YoZW1wbG95ZWU1KTsKLQkJaW50IGluZGV4NiA9IHRhYmxlTW9kZWwuaW5kZXhPZihlbXBsb3llZTYpOwotCi0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBFbXBsb3llZSAxIGlzIG5vdCBhdCB0aGUgcmlnaHQgaW5kZXgiLCAzLCBpbmRleDEpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgRW1wbG95ZWUgMiBpcyBub3QgYXQgdGhlIHJpZ2h0IGluZGV4IiwgNCwgaW5kZXgyKTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIEVtcGxveWVlIDMgaXMgbm90IGF0IHRoZSByaWdodCBpbmRleCIsIDAsIGluZGV4Myk7Ci0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBFbXBsb3llZSA0IGlzIG5vdCBhdCB0aGUgcmlnaHQgaW5kZXgiLCAxLCBpbmRleDQpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgRW1wbG95ZWUgNSBpcyBub3QgYXQgdGhlIHJpZ2h0IGluZGV4IiwgMiwgaW5kZXg1KTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIEVtcGxveWVlIDYgaXMgbm90IGF0IHRoZSByaWdodCBpbmRleCIsIDUsIGluZGV4Nik7Ci0KLQkJdGVzdFRhYmxlSXRlbVByb3BlcnRpZXModGFibGUsIGluZGV4MSwgZXhwZWN0ZWROYW1lMSwgZXhwZWN0ZWRNYW5hZ2VyMSwgZXhwZWN0ZWRUaXRsZTEpOwotCQl0ZXN0VGFibGVJdGVtUHJvcGVydGllcyh0YWJsZSwgaW5kZXgyLCBleHBlY3RlZE5hbWUyLCBleHBlY3RlZE1hbmFnZXIyLCBleHBlY3RlZFRpdGxlMik7Ci0JCXRlc3RUYWJsZUl0ZW1Qcm9wZXJ0aWVzKHRhYmxlLCBpbmRleDMsIGV4cGVjdGVkTmFtZTMsIGV4cGVjdGVkTWFuYWdlcjMsIGV4cGVjdGVkVGl0bGUzKTsKLQkJdGVzdFRhYmxlSXRlbVByb3BlcnRpZXModGFibGUsIGluZGV4NCwgZXhwZWN0ZWROYW1lNCwgZXhwZWN0ZWRNYW5hZ2VyNCwgZXhwZWN0ZWRUaXRsZTQpOwotCQl0ZXN0VGFibGVJdGVtUHJvcGVydGllcyh0YWJsZSwgaW5kZXg1LCBleHBlY3RlZE5hbWU1LCBleHBlY3RlZE1hbmFnZXI1LCBleHBlY3RlZFRpdGxlNSk7Ci0JCXRlc3RUYWJsZUl0ZW1Qcm9wZXJ0aWVzKHRhYmxlLCBpbmRleDYsIGV4cGVjdGVkTmFtZTYsIGV4cGVjdGVkTWFuYWdlcjYsIGV4cGVjdGVkVGl0bGU2KTsKLQotCQkvLyBNb3ZlIGFuIEVtcGxveWVlIGRvd24gdGhlIGxpc3QKLQkJZW1wbG95ZWVzID0gbmV3IEFycmF5TGlzdDxFbXBsb3llZT4oMik7Ci0JCWVtcGxveWVlcy5hZGQoZW1wbG95ZWUxKTsKLQkJZW1wbG95ZWVzLmFkZChlbXBsb3llZTIpOwotCQltYW5hZ2VyLm1vdmVFbXBsb3llZXMoZW1wbG95ZWVzLCA0KTsKLQotCQlpbmRleDEgPSB0YWJsZU1vZGVsLmluZGV4T2YoZW1wbG95ZWUxKTsKLQkJaW5kZXgyID0gdGFibGVNb2RlbC5pbmRleE9mKGVtcGxveWVlMik7Ci0JCWluZGV4MyA9IHRhYmxlTW9kZWwuaW5kZXhPZihlbXBsb3llZTMpOwotCQlpbmRleDQgPSB0YWJsZU1vZGVsLmluZGV4T2YoZW1wbG95ZWU0KTsKLQkJaW5kZXg1ID0gdGFibGVNb2RlbC5pbmRleE9mKGVtcGxveWVlNSk7Ci0JCWluZGV4NiA9IHRhYmxlTW9kZWwuaW5kZXhPZihlbXBsb3llZTYpOwotCi0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBFbXBsb3llZSAxIGlzIG5vdCBhdCB0aGUgcmlnaHQgaW5kZXgiLCA0LCBpbmRleDEpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgRW1wbG95ZWUgMiBpcyBub3QgYXQgdGhlIHJpZ2h0IGluZGV4IiwgNSwgaW5kZXgyKTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIEVtcGxveWVlIDMgaXMgbm90IGF0IHRoZSByaWdodCBpbmRleCIsIDAsIGluZGV4Myk7Ci0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBFbXBsb3llZSA0IGlzIG5vdCBhdCB0aGUgcmlnaHQgaW5kZXgiLCAxLCBpbmRleDQpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgRW1wbG95ZWUgNSBpcyBub3QgYXQgdGhlIHJpZ2h0IGluZGV4IiwgMiwgaW5kZXg1KTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIEVtcGxveWVlIDYgaXMgbm90IGF0IHRoZSByaWdodCBpbmRleCIsIDMsIGluZGV4Nik7Ci0KLQkJdGVzdFRhYmxlSXRlbVByb3BlcnRpZXModGFibGUsIGluZGV4MSwgZXhwZWN0ZWROYW1lMSwgZXhwZWN0ZWRNYW5hZ2VyMSwgZXhwZWN0ZWRUaXRsZTEpOwotCQl0ZXN0VGFibGVJdGVtUHJvcGVydGllcyh0YWJsZSwgaW5kZXgyLCBleHBlY3RlZE5hbWUyLCBleHBlY3RlZE1hbmFnZXIyLCBleHBlY3RlZFRpdGxlMik7Ci0JCXRlc3RUYWJsZUl0ZW1Qcm9wZXJ0aWVzKHRhYmxlLCBpbmRleDMsIGV4cGVjdGVkTmFtZTMsIGV4cGVjdGVkTWFuYWdlcjMsIGV4cGVjdGVkVGl0bGUzKTsKLQkJdGVzdFRhYmxlSXRlbVByb3BlcnRpZXModGFibGUsIGluZGV4NCwgZXhwZWN0ZWROYW1lNCwgZXhwZWN0ZWRNYW5hZ2VyNCwgZXhwZWN0ZWRUaXRsZTQpOwotCQl0ZXN0VGFibGVJdGVtUHJvcGVydGllcyh0YWJsZSwgaW5kZXg1LCBleHBlY3RlZE5hbWU1LCBleHBlY3RlZE1hbmFnZXI1LCBleHBlY3RlZFRpdGxlNSk7Ci0JCXRlc3RUYWJsZUl0ZW1Qcm9wZXJ0aWVzKHRhYmxlLCBpbmRleDYsIGV4cGVjdGVkTmFtZTYsIGV4cGVjdGVkTWFuYWdlcjYsIGV4cGVjdGVkVGl0bGU2KTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3RJdGVtc1JlbW92ZWQoKSB7Ci0KLQkJVGFibGUgdGFibGUgPSBuZXcgVGFibGUoc2hlbGwsIFNXVC5WX1NDUk9MTCB8IFNXVC5IX1NDUk9MTCB8IFNXVC5GVUxMX1NFTEVDVElPTiB8IFNXVC5NVUxUSSk7Ci0KLQkJTGlzdFZhbHVlTW9kZWw8RW1wbG95ZWU+IGxpc3RIb2xkZXIgPSBidWlsZEVtcGxveWVlTGlzdEhvbGRlcigpOwotCQlXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxFbXBsb3llZT4gc2VsZWN0ZWRJdGVtSG9sZGVyID0gYnVpbGRFbXBsb3llZUhvbGRlcigpOwotCi0JCU1hbmFnZXIgbWFuYWdlciA9IG5ldyBNYW5hZ2VyKCk7Ci0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobWFuYWdlcik7Ci0KLQkJVGFibGVNb2RlbCB0YWJsZU1vZGVsID0gbmV3IFRhYmxlTW9kZWwoCi0JCQlsaXN0SG9sZGVyLAotCQkJc2VsZWN0ZWRJdGVtSG9sZGVyLAotCQkJdGFibGUsCi0JCQlidWlsZENvbHVtbkFkYXB0ZXIoKSwKLQkJCWJ1aWxkTGFiZWxQcm92aWRlcigpCi0JCSk7Ci0KLQkJLy8gQ3JlYXRlIEVtcGxveWVlcwotCQlTdHJpbmcgZXhwZWN0ZWROYW1lMSAgICA9ICJEYWxpXzEiOwotCQlTdHJpbmcgZXhwZWN0ZWRNYW5hZ2VyMSA9ICJXVFBfMSI7Ci0JCVN0cmluZyBleHBlY3RlZFRpdGxlMSAgID0gInBsdWctaW5fMSI7Ci0KLQkJU3RyaW5nIGV4cGVjdGVkTmFtZTIgICAgPSAiRGFsaV8yIjsKLQkJU3RyaW5nIGV4cGVjdGVkTWFuYWdlcjIgPSAiV1RQXzIiOwotCQlTdHJpbmcgZXhwZWN0ZWRUaXRsZTIgICA9ICJwbHVnLWluXzIiOwotCi0JCVN0cmluZyBleHBlY3RlZE5hbWUzICAgID0gIkRhbGlfMyI7Ci0JCVN0cmluZyBleHBlY3RlZE1hbmFnZXIzID0gIldUUF8zIjsKLQkJU3RyaW5nIGV4cGVjdGVkVGl0bGUzICAgPSAicGx1Zy1pbl8zIjsKLQotCQlFbXBsb3llZSBlbXBsb3llZTEgPSBuZXcgRW1wbG95ZWUoZXhwZWN0ZWROYW1lMSwgZXhwZWN0ZWRUaXRsZTEsIGV4cGVjdGVkTWFuYWdlcjEpOwotCQlFbXBsb3llZSBlbXBsb3llZTIgPSBuZXcgRW1wbG95ZWUoZXhwZWN0ZWROYW1lMiwgZXhwZWN0ZWRUaXRsZTIsIGV4cGVjdGVkTWFuYWdlcjIpOwotCQlFbXBsb3llZSBlbXBsb3llZTMgPSBuZXcgRW1wbG95ZWUoZXhwZWN0ZWROYW1lMywgZXhwZWN0ZWRUaXRsZTMsIGV4cGVjdGVkTWFuYWdlcjMpOwotCi0JCW1hbmFnZXIuYWRkRW1wbG95ZWUoZW1wbG95ZWUxKTsKLQkJbWFuYWdlci5hZGRFbXBsb3llZShlbXBsb3llZTIpOwotCQltYW5hZ2VyLmFkZEVtcGxveWVlKGVtcGxveWVlMyk7Ci0KLQkJLy8gUmV0cmlldmUgdGhlIFRhYmxlSXRlbXMgcmVwcmVzZW50aW5nIHRoZSBlbXBsb3llZXMKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGhlIG51bWJlciBvZiBUYWJsZUl0ZW0gc2hvdWxkIGJlIDMiLCAzLCB0YWJsZS5nZXRJdGVtQ291bnQoKSk7Ci0KLQkJaW50IGluZGV4ID0gdGFibGVNb2RlbC5pbmRleE9mKGVtcGxveWVlMSk7Ci0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBFbXBsb3llZSAxIHdhcyBub3QgYWRkZWQgdG8gdGhlIHRhYmxlIG1vZGVsIiwgMCwgaW5kZXgpOwotCi0JCWluZGV4ID0gdGFibGVNb2RlbC5pbmRleE9mKGVtcGxveWVlMik7Ci0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBFbXBsb3llZSAyIHdhcyBub3QgYWRkZWQgdG8gdGhlIHRhYmxlIG1vZGVsIiwgMSwgaW5kZXgpOwotCi0JCWluZGV4ID0gdGFibGVNb2RlbC5pbmRleE9mKGVtcGxveWVlMyk7Ci0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBFbXBsb3llZSAzIHdhcyBub3QgYWRkZWQgdG8gdGhlIHRhYmxlIG1vZGVsIiwgMiwgaW5kZXgpOwotCi0JCS8vIFJlbW92ZSAyIGl0ZW1zCi0JCUFycmF5TGlzdDxFbXBsb3llZT4gZW1wbG95ZWVzID0gbmV3IEFycmF5TGlzdDxFbXBsb3llZT4oMik7Ci0JCWVtcGxveWVlcy5hZGQoZW1wbG95ZWUxKTsKLQkJZW1wbG95ZWVzLmFkZChlbXBsb3llZTMpOwotCQltYW5hZ2VyLnJlbW92ZUVtcGxveWVlcyhlbXBsb3llZXMpOwotCi0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBudW1iZXIgb2YgVGFibGVJdGVtIHNob3VsZCBiZSAxIiwgMSwgdGFibGUuZ2V0SXRlbUNvdW50KCkpOwotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdFByb3BlcnR5Q2hhbmdlZCgpIHsKLQotCQlUYWJsZSB0YWJsZSA9IG5ldyBUYWJsZShzaGVsbCwgU1dULlZfU0NST0xMIHwgU1dULkhfU0NST0xMIHwgU1dULkZVTExfU0VMRUNUSU9OIHwgU1dULk1VTFRJKTsKLQotCQlMaXN0VmFsdWVNb2RlbDxFbXBsb3llZT4gbGlzdEhvbGRlciA9IGJ1aWxkRW1wbG95ZWVMaXN0SG9sZGVyKCk7Ci0JCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEVtcGxveWVlPiBzZWxlY3RlZEl0ZW1Ib2xkZXIgPSBidWlsZEVtcGxveWVlSG9sZGVyKCk7Ci0KLQkJTWFuYWdlciBtYW5hZ2VyID0gbmV3IE1hbmFnZXIoKTsKLQkJc3ViamVjdEhvbGRlci5zZXRWYWx1ZShtYW5hZ2VyKTsKLQotCQlUYWJsZU1vZGVsIHRhYmxlTW9kZWwgPSBuZXcgVGFibGVNb2RlbCgKLQkJCWxpc3RIb2xkZXIsCi0JCQlzZWxlY3RlZEl0ZW1Ib2xkZXIsCi0JCQl0YWJsZSwKLQkJCWJ1aWxkQ29sdW1uQWRhcHRlcigpLAotCQkJYnVpbGRMYWJlbFByb3ZpZGVyKCkKLQkJKTsKLQotCQkvLyBDcmVhdGUgYSBuZXcgRW1wbG95ZWUKLQkJU3RyaW5nIGV4cGVjdGVkTmFtZSAgICA9ICJEYWxpIjsKLQkJU3RyaW5nIGV4cGVjdGVkTWFuYWdlciA9ICJXVFAiOwotCQlTdHJpbmcgZXhwZWN0ZWRUaXRsZSAgID0gInBsdWctaW4iOwotCi0JCUVtcGxveWVlIGVtcGxveWVlID0gbWFuYWdlci5hZGRFbXBsb3llZShleHBlY3RlZE5hbWUsIGV4cGVjdGVkVGl0bGUsIGV4cGVjdGVkTWFuYWdlcik7Ci0JCUFzc2VydC5hc3NlcnROb3ROdWxsKCJUaGUgbmV3IEVtcGxveWVlIHdhcyBub3QgY3JlYXRlZCIsIGVtcGxveWVlKTsKLQotCQkvLyBNYWtlIHN1cmUgaXQgd2FzIGFkZGVkIHRvIHRoZSBtb2RlbAotCQlpbnQgaW5kZXggPSB0YWJsZU1vZGVsLmluZGV4T2YoZW1wbG95ZWUpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgbmV3IEVtcGxveWVlIHdhcyBub3QgYWRkZWQgdG8gdGhlIHRhYmxlIG1vZGVsIiwgMCwgaW5kZXgpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgbnVtYmVyIG9mIFRhYmxlSXRlbSBzaG91bGQgYmUgMSIsIDEsIHRhYmxlLmdldEl0ZW1Db3VudCgpKTsKLQotCQkvLyBSZXRyaWV2ZSB0aGUgVGFibGVJdGVtIHJlcHJlc2VudGluZyB0aGUgbmV3IEVtcGxveWVlCi0JCVRhYmxlSXRlbSB0YWJsZUl0ZW0gPSB0YWJsZS5nZXRJdGVtKGluZGV4KTsKLQkJQXNzZXJ0LmFzc2VydE5vdE51bGwoIk5vIFRhYmxlSXRlbSB3YXMgZm91bmQgZm9yIHRoZSBuZXcgRW1wbG95ZWUiLCB0YWJsZUl0ZW0pOwotCi0JCS8vIE5hbWUgcHJvcGVydHkKLQkJU3RyaW5nIGFjdHVhbE5hbWUgPSB0YWJsZUl0ZW0uZ2V0VGV4dChUYWJsZUNvbHVtbkFkYXB0ZXIuTkFNRV9DT0xVTU4pOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUYWJsZUl0ZW1bTkFNRV9DT0xVTU5dIHdhcyBub3Qgc2V0IGNvcnJlY3RseSIsIGV4cGVjdGVkTmFtZSwgYWN0dWFsTmFtZSk7Ci0KLQkJZXhwZWN0ZWROYW1lID0gIkpwdCI7Ci0JCWVtcGxveWVlLnNldE5hbWUoZXhwZWN0ZWROYW1lKTsKLQotCQlhY3R1YWxOYW1lID0gdGFibGVJdGVtLmdldFRleHQoVGFibGVDb2x1bW5BZGFwdGVyLk5BTUVfQ09MVU1OKTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGFibGVJdGVtW05BTUVfQ09MVU1OXSB3YXMgbm90IHNldCBjb3JyZWN0bHkiLCBleHBlY3RlZE5hbWUsIGFjdHVhbE5hbWUpOwotCi0JCS8vIE1hbmFnZXIgcHJvcGVydHkKLQkJU3RyaW5nIGFjdHVhbE1hbmFnZXIgPSB0YWJsZUl0ZW0uZ2V0VGV4dChUYWJsZUNvbHVtbkFkYXB0ZXIuTUFOQUdFUl9DT0xVTU4pOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUYWJsZUl0ZW1bTUFOQUdFUl9DT0xVTU5dIHdhcyBub3Qgc2V0IGNvcnJlY3RseSIsIGV4cGVjdGVkTWFuYWdlciwgYWN0dWFsTWFuYWdlcik7Ci0KLQkJZXhwZWN0ZWRNYW5hZ2VyID0gImJvc3MiOwotCQllbXBsb3llZS5zZXRNYW5hZ2VyKGV4cGVjdGVkTWFuYWdlcik7Ci0KLQkJYWN0dWFsTWFuYWdlciA9IHRhYmxlSXRlbS5nZXRUZXh0KFRhYmxlQ29sdW1uQWRhcHRlci5NQU5BR0VSX0NPTFVNTik7Ci0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRhYmxlSXRlbVtNQU5BR0VSX0NPTFVNTl0gd2FzIG5vdCBzZXQgY29ycmVjdGx5IiwgZXhwZWN0ZWRNYW5hZ2VyLCBhY3R1YWxNYW5hZ2VyKTsKLQotCQkvLyBUaXRsZSBwcm9wZXJ0eQotCQlTdHJpbmcgYWN0dWFsVGl0bGUgPSB0YWJsZUl0ZW0uZ2V0VGV4dChUYWJsZUNvbHVtbkFkYXB0ZXIuVElUTEVfQ09MVU1OKTsKLQkJQXNzZXJ0LmFzc2VydEVxdWFscygiVGFibGVJdGVtW1RJVExFX0NPTFVNTl0gd2FzIG5vdCBzZXQgY29ycmVjdGx5IiwgZXhwZWN0ZWRUaXRsZSwgYWN0dWFsVGl0bGUpOwotCi0JCWV4cGVjdGVkVGl0bGUgPSAiRWNsaXBzZUxpbmsiOwotCQllbXBsb3llZS5zZXRUaXRsZShleHBlY3RlZFRpdGxlKTsKLQotCQlhY3R1YWxUaXRsZSA9IHRhYmxlSXRlbS5nZXRUZXh0KFRhYmxlQ29sdW1uQWRhcHRlci5USVRMRV9DT0xVTU4pOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUYWJsZUl0ZW1bVElUTEVfQ09MVU1OXSB3YXMgbm90IHNldCBjb3JyZWN0bHkiLCBleHBlY3RlZFRpdGxlLCBhY3R1YWxUaXRsZSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0U2VsZWN0ZWRJdGVtc0FkZGVkUmVtb3ZlZCgpIHsKLQotCQlUYWJsZSB0YWJsZSA9IG5ldyBUYWJsZShzaGVsbCwgU1dULlZfU0NST0xMIHwgU1dULkhfU0NST0xMIHwgU1dULkZVTExfU0VMRUNUSU9OIHwgU1dULk1VTFRJKTsKLQotCQlMaXN0VmFsdWVNb2RlbDxFbXBsb3llZT4gbGlzdEhvbGRlciA9IGJ1aWxkRW1wbG95ZWVMaXN0SG9sZGVyKCk7Ci0JCVNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPEVtcGxveWVlPiBzZWxlY3RlZEl0ZW1zSG9sZGVyID0gYnVpbGRFbXBsb3llZUhvbGRlcnMoKTsKLQotCQlNYW5hZ2VyIG1hbmFnZXIgPSBuZXcgTWFuYWdlcigpOwotCQlzdWJqZWN0SG9sZGVyLnNldFZhbHVlKG1hbmFnZXIpOwotCi0JCVRhYmxlTW9kZWwgdGFibGVNb2RlbCA9IG5ldyBUYWJsZU1vZGVsKAotCQkJbGlzdEhvbGRlciwKLQkJCXNlbGVjdGVkSXRlbXNIb2xkZXIsCi0JCQl0YWJsZSwKLQkJCWJ1aWxkQ29sdW1uQWRhcHRlcigpLAotCQkJYnVpbGRMYWJlbFByb3ZpZGVyKCkKLQkJKTsKLQotCQkvLyBDcmVhdGUgRW1wbG95ZWVzCi0JCVN0cmluZyBleHBlY3RlZE5hbWUxICAgID0gIkRhbGlfMSI7Ci0JCVN0cmluZyBleHBlY3RlZE1hbmFnZXIxID0gIldUUF8xIjsKLQkJU3RyaW5nIGV4cGVjdGVkVGl0bGUxICAgPSAicGx1Zy1pbl8xIjsKLQotCQlTdHJpbmcgZXhwZWN0ZWROYW1lMiAgICA9ICJEYWxpXzIiOwotCQlTdHJpbmcgZXhwZWN0ZWRNYW5hZ2VyMiA9ICJXVFBfMiI7Ci0JCVN0cmluZyBleHBlY3RlZFRpdGxlMiAgID0gInBsdWctaW5fMiI7Ci0KLQkJU3RyaW5nIGV4cGVjdGVkTmFtZTMgICAgPSAiRGFsaV8zIjsKLQkJU3RyaW5nIGV4cGVjdGVkTWFuYWdlcjMgPSAiV1RQXzMiOwotCQlTdHJpbmcgZXhwZWN0ZWRUaXRsZTMgICA9ICJwbHVnLWluXzMiOwotCi0JCUVtcGxveWVlIGVtcGxveWVlMSA9IG5ldyBFbXBsb3llZShleHBlY3RlZE5hbWUxLCBleHBlY3RlZFRpdGxlMSwgZXhwZWN0ZWRNYW5hZ2VyMSk7Ci0JCUVtcGxveWVlIGVtcGxveWVlMiA9IG5ldyBFbXBsb3llZShleHBlY3RlZE5hbWUyLCBleHBlY3RlZFRpdGxlMiwgZXhwZWN0ZWRNYW5hZ2VyMik7Ci0JCUVtcGxveWVlIGVtcGxveWVlMyA9IG5ldyBFbXBsb3llZShleHBlY3RlZE5hbWUzLCBleHBlY3RlZFRpdGxlMywgZXhwZWN0ZWRNYW5hZ2VyMyk7Ci0KLQkJbWFuYWdlci5hZGRFbXBsb3llZShlbXBsb3llZTEpOwotCQltYW5hZ2VyLmFkZEVtcGxveWVlKGVtcGxveWVlMik7Ci0JCW1hbmFnZXIuYWRkRW1wbG95ZWUoZW1wbG95ZWUzKTsKLQotCQkvLyBUZXN0IGFkZGluZyBzZWxlY3RlZCBpdGVtcwotCQlBcnJheUxpc3Q8RW1wbG95ZWU+IGVtcGxveWVlcyA9IG5ldyBBcnJheUxpc3Q8RW1wbG95ZWU+KDIpOwotCQllbXBsb3llZXMuYWRkKGVtcGxveWVlMSk7Ci0JCWVtcGxveWVlcy5hZGQoZW1wbG95ZWUzKTsKLQkJc2VsZWN0ZWRJdGVtc0hvbGRlci5hZGRBbGwoZW1wbG95ZWVzKTsKLQotCQlDb2xsZWN0aW9uPEVtcGxveWVlPiBhY3R1YWxFbXBsb3llZXMgPSB0YWJsZU1vZGVsLnNlbGVjdGVkSXRlbXMoKTsKLQkJQXNzZXJ0LmFzc2VydE5vdE51bGwoIlRoZSBjb2xsZWN0aW9uIG9mIHNlbGVjdGVkIGl0ZW1zIGNhbid0IGJlIG51bGwiLCBhY3R1YWxFbXBsb3llZXMpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgY291bnQgb2Ygc2VsZWN0ZWQgaXRlbXMgc2hvdWxkIGJlIDIiLCAyLCBhY3R1YWxFbXBsb3llZXMuc2l6ZSgpKTsKLQotCQlhY3R1YWxFbXBsb3llZXMucmVtb3ZlKGVtcGxveWVlMSk7Ci0JCWFjdHVhbEVtcGxveWVlcy5yZW1vdmUoZW1wbG95ZWUzKTsKLQotCQlBc3NlcnQuYXNzZXJ0VHJ1ZSgiVGhlIHNlbGVjdGVkIGl0ZW1zIHdhcyBub3QgcmV0cmlldmVkIGNvcnJlY3RseSIsIGFjdHVhbEVtcGxveWVlcy5pc0VtcHR5KCkpOwotCi0JCS8vIFRlc3QgcmVtb3Zpbmcgc2VsZWN0ZWQgaXRlbXMKLQkJc2VsZWN0ZWRJdGVtc0hvbGRlci5yZW1vdmUoZW1wbG95ZWUxKTsKLQotCQlhY3R1YWxFbXBsb3llZXMgPSB0YWJsZU1vZGVsLnNlbGVjdGVkSXRlbXMoKTsKLQkJQXNzZXJ0LmFzc2VydE5vdE51bGwoIlRoZSBjb2xsZWN0aW9uIG9mIHNlbGVjdGVkIGl0ZW1zIGNhbid0IGJlIG51bGwiLCBhY3R1YWxFbXBsb3llZXMpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgY291bnQgb2Ygc2VsZWN0ZWQgaXRlbXMgc2hvdWxkIGJlIDEiLCAxLCBhY3R1YWxFbXBsb3llZXMuc2l6ZSgpKTsKLQotCQlhY3R1YWxFbXBsb3llZXMucmVtb3ZlKGVtcGxveWVlMyk7Ci0KLQkJQXNzZXJ0LmFzc2VydFRydWUoIlRoZSBzZWxlY3RlZCBpdGVtcyB3YXMgbm90IHJldHJpZXZlZCBjb3JyZWN0bHkiLCBhY3R1YWxFbXBsb3llZXMuaXNFbXB0eSgpKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3RTZWxlY3RlZEl0ZW1zQ2xlYXJlZCgpIHsKLQotCQlUYWJsZSB0YWJsZSA9IG5ldyBUYWJsZShzaGVsbCwgU1dULlZfU0NST0xMIHwgU1dULkhfU0NST0xMIHwgU1dULkZVTExfU0VMRUNUSU9OIHwgU1dULk1VTFRJKTsKLQotCQlMaXN0VmFsdWVNb2RlbDxFbXBsb3llZT4gbGlzdEhvbGRlciA9IGJ1aWxkRW1wbG95ZWVMaXN0SG9sZGVyKCk7Ci0JCVNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPEVtcGxveWVlPiBzZWxlY3RlZEl0ZW1zSG9sZGVyID0gYnVpbGRFbXBsb3llZUhvbGRlcnMoKTsKLQotCQlNYW5hZ2VyIG1hbmFnZXIgPSBuZXcgTWFuYWdlcigpOwotCQlzdWJqZWN0SG9sZGVyLnNldFZhbHVlKG1hbmFnZXIpOwotCi0JCVRhYmxlTW9kZWwgdGFibGVNb2RlbCA9IG5ldyBUYWJsZU1vZGVsKAotCQkJbGlzdEhvbGRlciwKLQkJCXNlbGVjdGVkSXRlbXNIb2xkZXIsCi0JCQl0YWJsZSwKLQkJCWJ1aWxkQ29sdW1uQWRhcHRlcigpLAotCQkJYnVpbGRMYWJlbFByb3ZpZGVyKCkKLQkJKTsKLQotCQkvLyBDcmVhdGUgRW1wbG95ZWVzCi0JCVN0cmluZyBleHBlY3RlZE5hbWUxICAgID0gIkRhbGlfMSI7Ci0JCVN0cmluZyBleHBlY3RlZE1hbmFnZXIxID0gIldUUF8xIjsKLQkJU3RyaW5nIGV4cGVjdGVkVGl0bGUxICAgPSAicGx1Zy1pbl8xIjsKLQotCQlTdHJpbmcgZXhwZWN0ZWROYW1lMiAgICA9ICJEYWxpXzIiOwotCQlTdHJpbmcgZXhwZWN0ZWRNYW5hZ2VyMiA9ICJXVFBfMiI7Ci0JCVN0cmluZyBleHBlY3RlZFRpdGxlMiAgID0gInBsdWctaW5fMiI7Ci0KLQkJU3RyaW5nIGV4cGVjdGVkTmFtZTMgICAgPSAiRGFsaV8zIjsKLQkJU3RyaW5nIGV4cGVjdGVkTWFuYWdlcjMgPSAiV1RQXzMiOwotCQlTdHJpbmcgZXhwZWN0ZWRUaXRsZTMgICA9ICJwbHVnLWluXzMiOwotCi0JCUVtcGxveWVlIGVtcGxveWVlMSA9IG5ldyBFbXBsb3llZShleHBlY3RlZE5hbWUxLCBleHBlY3RlZFRpdGxlMSwgZXhwZWN0ZWRNYW5hZ2VyMSk7Ci0JCUVtcGxveWVlIGVtcGxveWVlMiA9IG5ldyBFbXBsb3llZShleHBlY3RlZE5hbWUyLCBleHBlY3RlZFRpdGxlMiwgZXhwZWN0ZWRNYW5hZ2VyMik7Ci0JCUVtcGxveWVlIGVtcGxveWVlMyA9IG5ldyBFbXBsb3llZShleHBlY3RlZE5hbWUzLCBleHBlY3RlZFRpdGxlMywgZXhwZWN0ZWRNYW5hZ2VyMyk7Ci0KLQkJbWFuYWdlci5hZGRFbXBsb3llZShlbXBsb3llZTEpOwotCQltYW5hZ2VyLmFkZEVtcGxveWVlKGVtcGxveWVlMik7Ci0JCW1hbmFnZXIuYWRkRW1wbG95ZWUoZW1wbG95ZWUzKTsKLQotCQkvLyBUZXN0IGFkZGluZyBzZWxlY3RlZCBpdGVtcwotCQlBcnJheUxpc3Q8RW1wbG95ZWU+IGVtcGxveWVlcyA9IG5ldyBBcnJheUxpc3Q8RW1wbG95ZWU+KDIpOwotCQllbXBsb3llZXMuYWRkKGVtcGxveWVlMSk7Ci0JCWVtcGxveWVlcy5hZGQoZW1wbG95ZWUzKTsKLQkJc2VsZWN0ZWRJdGVtc0hvbGRlci5hZGRBbGwoZW1wbG95ZWVzKTsKLQotCQlDb2xsZWN0aW9uPEVtcGxveWVlPiBhY3R1YWxFbXBsb3llZXMgPSB0YWJsZU1vZGVsLnNlbGVjdGVkSXRlbXMoKTsKLQkJQXNzZXJ0LmFzc2VydE5vdE51bGwoIlRoZSBjb2xsZWN0aW9uIG9mIHNlbGVjdGVkIGl0ZW1zIGNhbid0IGJlIG51bGwiLCBhY3R1YWxFbXBsb3llZXMpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgY291bnQgb2Ygc2VsZWN0ZWQgaXRlbXMgc2hvdWxkIGJlIDIiLCAyLCBhY3R1YWxFbXBsb3llZXMuc2l6ZSgpKTsKLQotCQlhY3R1YWxFbXBsb3llZXMucmVtb3ZlKGVtcGxveWVlMSk7Ci0JCWFjdHVhbEVtcGxveWVlcy5yZW1vdmUoZW1wbG95ZWUzKTsKLQkJQXNzZXJ0LmFzc2VydFRydWUoIlRoZSBzZWxlY3RlZCBpdGVtcyB3YXMgbm90IHJldHJpZXZlZCBjb3JyZWN0bHkiLCBhY3R1YWxFbXBsb3llZXMuaXNFbXB0eSgpKTsKLQotCQkvLyBUZXN0IHJlbW92aW5nIHNlbGVjdGVkIGl0ZW1zCi0JCXNlbGVjdGVkSXRlbXNIb2xkZXIuY2xlYXIoKTsKLQotCQlhY3R1YWxFbXBsb3llZXMgPSB0YWJsZU1vZGVsLnNlbGVjdGVkSXRlbXMoKTsKLQkJQXNzZXJ0LmFzc2VydE5vdE51bGwoIlRoZSBjb2xsZWN0aW9uIG9mIHNlbGVjdGVkIGl0ZW1zIGNhbid0IGJlIG51bGwiLCBhY3R1YWxFbXBsb3llZXMpOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUaGUgY291bnQgb2Ygc2VsZWN0ZWQgaXRlbXMgc2hvdWxkIGJlICIsIDAsIGFjdHVhbEVtcGxveWVlcy5zaXplKCkpOwotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdFNlbGVjdGlvbkNoYW5nZUxpc3RlbmVyKCkgewotCi0JCVRhYmxlIHRhYmxlID0gbmV3IFRhYmxlKHNoZWxsLCBTV1QuVl9TQ1JPTEwgfCBTV1QuSF9TQ1JPTEwgfCBTV1QuRlVMTF9TRUxFQ1RJT04gfCBTV1QuTVVMVEkpOwotCi0JCU1hbmFnZXIgbWFuYWdlciA9IG5ldyBNYW5hZ2VyKCk7Ci0JCXN1YmplY3RIb2xkZXIuc2V0VmFsdWUobWFuYWdlcik7Ci0KLQkJVGFibGVNb2RlbCB0YWJsZU1vZGVsID0gbmV3IFRhYmxlTW9kZWwoCi0JCQlidWlsZEVtcGxveWVlTGlzdEhvbGRlcigpLAotCQkJYnVpbGRFbXBsb3llZUhvbGRlcigpLAotCQkJdGFibGUsCi0JCQlidWlsZENvbHVtbkFkYXB0ZXIoKSwKLQkJCWJ1aWxkTGFiZWxQcm92aWRlcigpCi0JCSk7Ci0KLQkJQ29sbGVjdGlvbjxFbXBsb3llZT4gZW1wbG95ZWVzID0gbmV3IEFycmF5TGlzdDxFbXBsb3llZT4oKTsKLQkJdGFibGVNb2RlbC5hZGRTZWxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihidWlsZFNlbGVjdGlvbkNoYW5nZUxpc3RlbmVyKGVtcGxveWVlcykpOwotCi0JCS8vIENyZWF0ZSBFbXBsb3llZXMKLQkJU3RyaW5nIGV4cGVjdGVkTmFtZTEgICAgPSAiRGFsaV8xIjsKLQkJU3RyaW5nIGV4cGVjdGVkTWFuYWdlcjEgPSAiV1RQXzEiOwotCQlTdHJpbmcgZXhwZWN0ZWRUaXRsZTEgICA9ICJwbHVnLWluXzEiOwotCi0JCVN0cmluZyBleHBlY3RlZE5hbWUyICAgID0gIkRhbGlfMiI7Ci0JCVN0cmluZyBleHBlY3RlZE1hbmFnZXIyID0gIldUUF8yIjsKLQkJU3RyaW5nIGV4cGVjdGVkVGl0bGUyICAgPSAicGx1Zy1pbl8yIjsKLQotCQlTdHJpbmcgZXhwZWN0ZWROYW1lMyAgICA9ICJEYWxpXzMiOwotCQlTdHJpbmcgZXhwZWN0ZWRNYW5hZ2VyMyA9ICJXVFBfMyI7Ci0JCVN0cmluZyBleHBlY3RlZFRpdGxlMyAgID0gInBsdWctaW5fMyI7Ci0KLQkJRW1wbG95ZWUgZW1wbG95ZWUxID0gbmV3IEVtcGxveWVlKGV4cGVjdGVkTmFtZTEsIGV4cGVjdGVkVGl0bGUxLCBleHBlY3RlZE1hbmFnZXIxKTsKLQkJRW1wbG95ZWUgZW1wbG95ZWUyID0gbmV3IEVtcGxveWVlKGV4cGVjdGVkTmFtZTIsIGV4cGVjdGVkVGl0bGUyLCBleHBlY3RlZE1hbmFnZXIyKTsKLQkJRW1wbG95ZWUgZW1wbG95ZWUzID0gbmV3IEVtcGxveWVlKGV4cGVjdGVkTmFtZTMsIGV4cGVjdGVkVGl0bGUzLCBleHBlY3RlZE1hbmFnZXIzKTsKLQotCQltYW5hZ2VyLmFkZEVtcGxveWVlKGVtcGxveWVlMSk7Ci0JCW1hbmFnZXIuYWRkRW1wbG95ZWUoZW1wbG95ZWUyKTsKLQkJbWFuYWdlci5hZGRFbXBsb3llZShlbXBsb3llZTMpOwotCi0JCS8vIFRlc3QgYWRkaW5nIHNlbGVjdGVkIGl0ZW1zCi0JCXRhYmxlLnNldFNlbGVjdGlvbihuZXcgaW50W10geyAwLCAyIH0pOwotCi0JCS8vIEl0IHNlZW1zIGEgbWFudWFsIHNlbGVjdGlvbiBkb2Vzbid0IHNlbmQgYW55IHNlbGVjdGlvbiBldmVudAotCQl0YWJsZU1vZGVsLnRhYmxlU2VsZWN0aW9uQ2hhbmdlZChudWxsKTsKLQotCQlBc3NlcnQuYXNzZXJ0Tm90TnVsbCgiVGhlIGNvbGxlY3Rpb24gb2Ygc2VsZWN0ZWQgaXRlbXMgY2FuJ3QgYmUgbnVsbCIsIGVtcGxveWVlcyk7Ci0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBjb3VudCBvZiBzZWxlY3RlZCBpdGVtcyBzaG91bGQgYmUgMiIsIDIsIGVtcGxveWVlcy5zaXplKCkpOwotCi0JCWVtcGxveWVlcy5yZW1vdmUoZW1wbG95ZWUxKTsKLQkJZW1wbG95ZWVzLnJlbW92ZShlbXBsb3llZTMpOwotCQlBc3NlcnQuYXNzZXJ0VHJ1ZSgiVGhlIHNlbGVjdGVkIGl0ZW1zIHdhcyBub3QgcmV0cmlldmVkIGNvcnJlY3RseSIsIGVtcGxveWVlcy5pc0VtcHR5KCkpOwotCi0JCS8vIFRlc3QgYWRkaW5nIHNlbGVjdGVkIGl0ZW1zCi0JCWVtcGxveWVlcy5hZGQoZW1wbG95ZWUxKTsKLQkJZW1wbG95ZWVzLmFkZChlbXBsb3llZTMpOwotCQl0YWJsZS5kZXNlbGVjdEFsbCgpOwotCi0JCS8vIEl0IHNlZW1zIGEgbWFudWFsIHNlbGVjdGlvbiBkb2Vzbid0IHNlbmQgYW55IHNlbGVjdGlvbiBldmVudAotCQl0YWJsZU1vZGVsLnRhYmxlU2VsZWN0aW9uQ2hhbmdlZChudWxsKTsKLQotCQlBc3NlcnQuYXNzZXJ0Tm90TnVsbCgiVGhlIGNvbGxlY3Rpb24gb2Ygc2VsZWN0ZWQgaXRlbXMgY2FuJ3QgYmUgbnVsbCIsIGVtcGxveWVlcyk7Ci0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRoZSBjb3VudCBvZiBzZWxlY3RlZCBpdGVtcyBzaG91bGQgYmUgMCIsIDAsIGVtcGxveWVlcy5zaXplKCkpOwotCX0KLQotCXByaXZhdGUgdm9pZCB0ZXN0VGFibGVJdGVtUHJvcGVydGllcyhUYWJsZSB0YWJsZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW50IGluZGV4LAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTdHJpbmcgZXhwZWN0ZWROYW1lLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTdHJpbmcgZXhwZWN0ZWRNYW5hZ2VyLAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTdHJpbmcgZXhwZWN0ZWRUaXRsZSkKLQl7Ci0JCVRhYmxlSXRlbSB0YWJsZUl0ZW0gPSB0YWJsZS5nZXRJdGVtKGluZGV4KTsKLQkJQXNzZXJ0LmFzc2VydE5vdE51bGwoIk5vIFRhYmxlSXRlbSB3YXMgZm91bmQgZm9yIHRoZSBFbXBsb3llZSIsIHRhYmxlSXRlbSk7Ci0KLQkJU3RyaW5nIGFjdHVhbE5hbWUgPSB0YWJsZUl0ZW0uZ2V0VGV4dChUYWJsZUNvbHVtbkFkYXB0ZXIuTkFNRV9DT0xVTU4pOwotCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKCJUYWJsZUl0ZW1bTkFNRV9DT0xVTU5dIHdhcyBub3Qgc2V0IGNvcnJlY3RseSIsIGV4cGVjdGVkTmFtZSwgYWN0dWFsTmFtZSk7Ci0KLQkJU3RyaW5nIGFjdHVhbFRpdGxlID0gdGFibGVJdGVtLmdldFRleHQoVGFibGVDb2x1bW5BZGFwdGVyLlRJVExFX0NPTFVNTik7Ci0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRhYmxlSXRlbVtUSVRMRV9DT0xVTU5dIHdhcyBub3Qgc2V0IGNvcnJlY3RseSIsIGV4cGVjdGVkVGl0bGUsIGFjdHVhbFRpdGxlKTsKLQotCQlTdHJpbmcgYWN0dWFsTWFuYWdlciA9IHRhYmxlSXRlbS5nZXRUZXh0KFRhYmxlQ29sdW1uQWRhcHRlci5NQU5BR0VSX0NPTFVNTik7Ci0JCUFzc2VydC5hc3NlcnRFcXVhbHMoIlRhYmxlSXRlbVtNQU5BR0VSX0NPTFVNTl0gd2FzIG5vdCBzZXQgY29ycmVjdGx5IiwgZXhwZWN0ZWRNYW5hZ2VyLCBhY3R1YWxNYW5hZ2VyKTsKLQl9Ci0KLQlwcml2YXRlIGNsYXNzIEVtcGxveWVlIGV4dGVuZHMgQWJzdHJhY3RNb2RlbCB7Ci0KLQkJcHJpdmF0ZSBTdHJpbmcgbWFuYWdlcjsKLQkJcHJpdmF0ZSBTdHJpbmcgbmFtZTsKLQkJcHJpdmF0ZSBTdHJpbmcgdGl0bGU7Ci0KLQkJc3RhdGljIGZpbmFsIFN0cmluZyBNQU5BR0VSX1BST1BFUlRZID0gIm1hbmFnZXIiOwotCQlzdGF0aWMgZmluYWwgU3RyaW5nIE5BTUVfUFJPUEVSVFkgPSAibmFtZSI7Ci0JCXN0YXRpYyBmaW5hbCBTdHJpbmcgVElUTEVfUFJPUEVSVFkgPSAidGl0bGUiOwotCi0JCUVtcGxveWVlKFN0cmluZyBuYW1lLCBTdHJpbmcgdGl0bGUsIFN0cmluZyBtYW5hZ2VyKSB7Ci0JCQlzdXBlcigpOwotCi0JCQl0aGlzLm5hbWUgICAgPSBuYW1lOwotCQkJdGhpcy50aXRsZSAgID0gdGl0bGU7Ci0JCQl0aGlzLm1hbmFnZXIgPSBtYW5hZ2VyOwotCQl9Ci0KLQkJU3RyaW5nIGdldE1hbmFnZXIoKSB7Ci0JCQlyZXR1cm4gbWFuYWdlcjsKLQkJfQotCi0JCVN0cmluZyBnZXROYW1lKCkgewotCQkJcmV0dXJuIG5hbWU7Ci0JCX0KLQotCQlTdHJpbmcgZ2V0VGl0bGUoKSB7Ci0JCQlyZXR1cm4gdGl0bGU7Ci0JCX0KLQotCQl2b2lkIHNldE1hbmFnZXIoU3RyaW5nIG1hbmFnZXIpIHsKLQkJCVN0cmluZyBvbGRNYW5hZ2VyID0gdGhpcy5tYW5hZ2VyOwotCQkJdGhpcy5tYW5hZ2VyID0gbWFuYWdlcjsKLQkJCWZpcmVQcm9wZXJ0eUNoYW5nZWQoTUFOQUdFUl9QUk9QRVJUWSwgb2xkTWFuYWdlciwgbWFuYWdlcik7Ci0JCX0KLQotCQl2b2lkIHNldE5hbWUoU3RyaW5nIG5hbWUpIHsKLQkJCVN0cmluZyBvbGROYW1lID0gdGhpcy5uYW1lOwotCQkJdGhpcy5uYW1lID0gbmFtZTsKLQkJCWZpcmVQcm9wZXJ0eUNoYW5nZWQoTkFNRV9QUk9QRVJUWSwgb2xkTmFtZSwgbmFtZSk7Ci0JCX0KLQotCQl2b2lkIHNldFRpdGxlKFN0cmluZyB0aXRsZSkgewotCQkJU3RyaW5nIG9sZFRpdGxlID0gdGhpcy50aXRsZTsKLQkJCXRoaXMudGl0bGUgPSB0aXRsZTsKLQkJCWZpcmVQcm9wZXJ0eUNoYW5nZWQoVElUTEVfUFJPUEVSVFksIG9sZFRpdGxlLCB0aXRsZSk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIGNsYXNzIE1hbmFnZXIgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIHsKLQotCQlwcml2YXRlIExpc3Q8RW1wbG95ZWU+IGVtcGxveWVlczsKLQotCQlzdGF0aWMgZmluYWwgU3RyaW5nIEVNUExPWUVFU19MSVNUID0gImVtcGxveWVlcyI7Ci0KLQkJTWFuYWdlcigpIHsKLQkJCXN1cGVyKCk7Ci0JCQllbXBsb3llZXMgPSBuZXcgQXJyYXlMaXN0PEVtcGxveWVlPigpOwotCQl9Ci0KLQkJRW1wbG95ZWUgYWRkRW1wbG95ZWUoRW1wbG95ZWUgZW1wbG95ZWUpIHsKLQkJCWFkZEl0ZW1Ub0xpc3QoZW1wbG95ZWUsIGVtcGxveWVlcywgRU1QTE9ZRUVTX0xJU1QpOwotCQkJcmV0dXJuIGVtcGxveWVlOwotCQl9Ci0KLQkJRW1wbG95ZWUgYWRkRW1wbG95ZWUoU3RyaW5nIG5hbWUsIFN0cmluZyB0aXRsZSwgU3RyaW5nIG1hbmFnZXIpIHsKLQkJCUVtcGxveWVlIGVtcGxveWVlID0gbmV3IEVtcGxveWVlKG5hbWUsIHRpdGxlLCBtYW5hZ2VyKTsKLQkJCXJldHVybiBhZGRFbXBsb3llZShlbXBsb3llZSk7Ci0JCX0KLQotCQl2b2lkIGNoYW5nZUVtcGxveWVlcyhMaXN0PEVtcGxveWVlPiBlbXBsb3llZXMpIHsKLQkJCXRoaXMuZW1wbG95ZWVzLmNsZWFyKCk7Ci0JCQl0aGlzLmVtcGxveWVlcy5hZGRBbGwoZW1wbG95ZWVzKTsKLQkJCWZpcmVMaXN0Q2hhbmdlZChFTVBMT1lFRVNfTElTVCk7Ci0JCX0KLQotCQlMaXN0SXRlcmF0b3I8RW1wbG95ZWU+IGVtcGxveWVlcygpIHsKLQkJCXJldHVybiBuZXcgQ2xvbmVMaXN0SXRlcmF0b3I8RW1wbG95ZWU+KGVtcGxveWVlcyk7Ci0JCX0KLQotCQlpbnQgZW1wbG95ZWVzU2l6ZSgpIHsKLQkJCXJldHVybiBlbXBsb3llZXMuc2l6ZSgpOwotCQl9Ci0KLQkJdm9pZCBtb3ZlRW1wbG95ZWVEb3duKEVtcGxveWVlIGVtcGxveWVlKSB7Ci0JCQlpbnQgaW5kZXggPSBlbXBsb3llZXMuaW5kZXhPZihlbXBsb3llZSk7Ci0JCQltb3ZlSXRlbUluTGlzdChpbmRleCArIDEsIGluZGV4LCBlbXBsb3llZXMsIEVNUExPWUVFU19MSVNUKTsKLQkJfQotCi0JCXZvaWQgbW92ZUVtcGxveWVlcyhDb2xsZWN0aW9uPEVtcGxveWVlPiBlbXBsb3llZXMsIGludCB0YXJnZXRJbmRleCkgewotCi0JCQlpbnQgc291cmNlSW5kZXggPSBJbnRlZ2VyLk1BWF9WQUxVRTsKLQotCQkJZm9yIChFbXBsb3llZSBlbXBsb3llZSA6IGVtcGxveWVlcykgewotCQkJCXNvdXJjZUluZGV4ID0gTWF0aC5taW4oc291cmNlSW5kZXgsIHRoaXMuZW1wbG95ZWVzLmluZGV4T2YoZW1wbG95ZWUpKTsKLQkJCX0KLQotCQkJbW92ZUl0ZW1zSW5MaXN0KAotCQkJCXRhcmdldEluZGV4LAotCQkJCXNvdXJjZUluZGV4LAotCQkJCWVtcGxveWVlcy5zaXplKCksCi0JCQkJdGhpcy5lbXBsb3llZXMsCi0JCQkJRU1QTE9ZRUVTX0xJU1QKLQkJCSk7Ci0JCX0KLQotCQl2b2lkIG1vdmVFbXBsb3llZVVwKEVtcGxveWVlIGVtcGxveWVlKSB7Ci0JCQlpbnQgaW5kZXggPSBlbXBsb3llZXMuaW5kZXhPZihlbXBsb3llZSk7Ci0JCQltb3ZlSXRlbUluTGlzdChpbmRleCAtIDEsIGluZGV4LCBlbXBsb3llZXMsIEVNUExPWUVFU19MSVNUKTsKLQkJfQotCi0JCXZvaWQgcmVtb3ZlQWxsRW1wbG95ZWVzKCkgewotCQkJY2xlYXJMaXN0KGVtcGxveWVlcywgRU1QTE9ZRUVTX0xJU1QpOwotCQl9Ci0KLQkJdm9pZCByZW1vdmVFbXBsb3llZShFbXBsb3llZSBlbXBsb3llZSkgewotCQkJcmVtb3ZlSXRlbUZyb21MaXN0KGVtcGxveWVlLCBlbXBsb3llZXMsIEVNUExPWUVFU19MSVNUKTsKLQkJfQotCi0JCXZvaWQgcmVtb3ZlRW1wbG95ZWVzKENvbGxlY3Rpb248RW1wbG95ZWU+IGVtcGxveWVlcykgewotCQkJcmVtb3ZlSXRlbXNGcm9tTGlzdChlbXBsb3llZXMuaXRlcmF0b3IoKSwgdGhpcy5lbXBsb3llZXMsIEVNUExPWUVFU19MSVNUKTsKLQkJfQotCi0JCXZvaWQgcmVwbGFjZShFbXBsb3llZSBvbGRFbXBsb3llZSwgRW1wbG95ZWUgbmV3RW1wbG95ZWUpIHsKLQkJCXJlcGxhY2VJdGVtSW5MaXN0KG9sZEVtcGxveWVlLCBuZXdFbXBsb3llZSwgZW1wbG95ZWVzLCBFTVBMT1lFRVNfTElTVCk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIGNsYXNzIFRhYmxlQ29sdW1uQWRhcHRlciBpbXBsZW1lbnRzIENvbHVtbkFkYXB0ZXI8RW1wbG95ZWU+IHsKLQotCQlzdGF0aWMgZmluYWwgaW50IENPTFVNTl9DT1VOVCA9IDM7Ci0JCXN0YXRpYyBmaW5hbCBpbnQgTUFOQUdFUl9DT0xVTU4gPSAyOwotCQlzdGF0aWMgZmluYWwgaW50IE5BTUVfQ09MVU1OID0gMDsKLQkJc3RhdGljIGZpbmFsIGludCBUSVRMRV9DT0xVTU4gPSAxOwotCi0JCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZE1hbmFnZXJIb2xkZXIoRW1wbG95ZWUgc3ViamVjdCkgewotCQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8RW1wbG95ZWUsIFN0cmluZz4oRW1wbG95ZWUuTUFOQUdFUl9QUk9QRVJUWSwgc3ViamVjdCkgewotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCXJldHVybiBzdWJqZWN0LmdldE1hbmFnZXIoKTsKLQkJCQl9Ci0KLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0JCQkJCXN1YmplY3Quc2V0TWFuYWdlcih2YWx1ZSk7Ci0JCQkJfQotCQkJfTsKLQkJfQotCi0JCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZE5hbWVIb2xkZXIoRW1wbG95ZWUgc3ViamVjdCkgewotCQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8RW1wbG95ZWUsIFN0cmluZz4oRW1wbG95ZWUuTkFNRV9QUk9QRVJUWSwgc3ViamVjdCkgewotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCXJldHVybiBzdWJqZWN0LmdldE5hbWUoKTsKLQkJCQl9Ci0KLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0JCQkJCXN1YmplY3Quc2V0TmFtZSh2YWx1ZSk7Ci0JCQkJfQotCQkJfTsKLQkJfQotCi0JCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZFRpdGxlSG9sZGVyKEVtcGxveWVlIHN1YmplY3QpIHsKLQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEVtcGxveWVlLCBTdHJpbmc+KEVtcGxveWVlLlRJVExFX1BST1BFUlRZLCBzdWJqZWN0KSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQkJcmV0dXJuIHN1YmplY3QuZ2V0VGl0bGUoKTsKLQkJCQl9Ci0KLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0JCQkJCXN1YmplY3Quc2V0VGl0bGUodmFsdWUpOwotCQkJCX0KLQkJCX07Ci0JCX0KLQotCQlwdWJsaWMgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Pz5bXSBjZWxsTW9kZWxzKEVtcGxveWVlIHN1YmplY3QpIHsKLQkJCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPD8+W10gaG9sZGVycyA9IG5ldyBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDw/PlszXTsKLQkJCWhvbGRlcnNbTkFNRV9DT0xVTU5dID0gYnVpbGROYW1lSG9sZGVyKHN1YmplY3QpOwotCQkJaG9sZGVyc1tUSVRMRV9DT0xVTU5dID0gYnVpbGRUaXRsZUhvbGRlcihzdWJqZWN0KTsKLQkJCWhvbGRlcnNbTUFOQUdFUl9DT0xVTU5dID0gYnVpbGRNYW5hZ2VySG9sZGVyKHN1YmplY3QpOwotCQkJcmV0dXJuIGhvbGRlcnM7Ci0JCX0KLQotCQlwdWJsaWMgaW50IGNvbHVtbkNvdW50KCkgewotCQkJcmV0dXJuIENPTFVNTl9DT1VOVDsKLQkJfQotCi0JCXB1YmxpYyBTdHJpbmcgY29sdW1uTmFtZShpbnQgY29sdW1uSW5kZXgpIHsKLQkJCXJldHVybiBTdHJpbmcudmFsdWVPZihjb2x1bW5JbmRleCk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIGNsYXNzIFRhYmxlTGFiZWxQcm92aWRlciBleHRlbmRzIExhYmVsUHJvdmlkZXIKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbXBsZW1lbnRzIElUYWJsZUxhYmVsUHJvdmlkZXIgewotCi0KLQkJcHVibGljIEltYWdlIGdldENvbHVtbkltYWdlKE9iamVjdCBlbGVtZW50LCBpbnQgY29sdW1uSW5kZXgpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0KLQkJcHVibGljIFN0cmluZyBnZXRDb2x1bW5UZXh0KE9iamVjdCBlbGVtZW50LCBpbnQgY29sdW1uSW5kZXgpIHsKLQkJCUVtcGxveWVlIGVtcGxveWVlID0gKEVtcGxveWVlKSBlbGVtZW50OwotCi0JCQlpZiAoY29sdW1uSW5kZXggPT0gVGFibGVDb2x1bW5BZGFwdGVyLk5BTUVfQ09MVU1OKSB7Ci0JCQkJcmV0dXJuIGVtcGxveWVlLmdldE5hbWUoKTsKLQkJCX0KLQotCQkJaWYgKGNvbHVtbkluZGV4ID09IFRhYmxlQ29sdW1uQWRhcHRlci5USVRMRV9DT0xVTU4pIHsKLQkJCQlyZXR1cm4gZW1wbG95ZWUuZ2V0VGl0bGUoKTsKLQkJCX0KLQotCQkJcmV0dXJuIGVtcGxveWVlLmdldE1hbmFnZXIoKTsKLQkJfQotCX0KLQotCXByaXZhdGUgY2xhc3MgVGFibGVNb2RlbCBleHRlbmRzIFRhYmxlTW9kZWxBZGFwdGVyPEVtcGxveWVlPiB7Ci0KLQkJVGFibGVNb2RlbChMaXN0VmFsdWVNb2RlbDxFbXBsb3llZT4gbGlzdEhvbGRlciwKLQkJICAgICAgICAgICBDb2xsZWN0aW9uVmFsdWVNb2RlbDxFbXBsb3llZT4gc2VsZWN0ZWRJdGVtc0hvbGRlciwKLQkJICAgICAgICAgICBUYWJsZSB0YWJsZSwKLQkJICAgICAgICAgICBDb2x1bW5BZGFwdGVyPEVtcGxveWVlPiBjb2x1bW5BZGFwdGVyLAotCQkgICAgICAgICAgIElUYWJsZUxhYmVsUHJvdmlkZXIgbGFiZWxQcm92aWRlcikgewotCi0JCQlzdXBlcihsaXN0SG9sZGVyLAotCQkJICAgICAgc2VsZWN0ZWRJdGVtc0hvbGRlciwKLQkJCSAgICAgIHRhYmxlLAotCQkJICAgICAgY29sdW1uQWRhcHRlciwKLQkJCSAgICAgIGxhYmVsUHJvdmlkZXIpOwotCQl9Ci0KLQkJVGFibGVNb2RlbChMaXN0VmFsdWVNb2RlbDxFbXBsb3llZT4gbGlzdEhvbGRlciwKLQkJICAgICAgICAgICBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxFbXBsb3llZT4gc2VsZWN0ZWRJdGVtSG9sZGVyLAotCQkgICAgICAgICAgIFRhYmxlIHRhYmxlLAotCQkgICAgICAgICAgIENvbHVtbkFkYXB0ZXI8RW1wbG95ZWU+IGNvbHVtbkFkYXB0ZXIsCi0JCSAgICAgICAgICAgSVRhYmxlTGFiZWxQcm92aWRlciBsYWJlbFByb3ZpZGVyKSB7Ci0KLQkJCXN1cGVyKGxpc3RIb2xkZXIsCi0JCQkJCW5ldyBQcm9wZXJ0eUNvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlcjxFbXBsb3llZT4oc2VsZWN0ZWRJdGVtSG9sZGVyKSwKLQkJCSAgICAgIHRhYmxlLAotCQkJICAgICAgY29sdW1uQWRhcHRlciwKLQkJCSAgICAgIGxhYmVsUHJvdmlkZXIpOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCBpbnQgaW5kZXhPZihFbXBsb3llZSBpdGVtKSB7Ci0JCQlyZXR1cm4gc3VwZXIuaW5kZXhPZihpdGVtKTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgQ29sbGVjdGlvbjxFbXBsb3llZT4gc2VsZWN0ZWRJdGVtcygpIHsKLQkJCXJldHVybiBzdXBlci5zZWxlY3RlZEl0ZW1zKCk7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIHZvaWQgdGFibGVTZWxlY3Rpb25DaGFuZ2VkKFNlbGVjdGlvbkV2ZW50IGV2ZW50KSB7Ci0JCQlzdXBlci50YWJsZVNlbGVjdGlvbkNoYW5nZWQoZXZlbnQpOwotCQl9Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3N3dC9UZXh0RmllbGRNb2RlbEFkYXB0ZXJVSVRlc3QuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC9zd3QvVGV4dEZpZWxkTW9kZWxBZGFwdGVyVUlUZXN0LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDZmODEyODAuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3N3dC9UZXh0RmllbGRNb2RlbEFkYXB0ZXJVSVRlc3QuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI1MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy5pbnRlcm5hbC5zd3Q7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS5hY3Rpb24uQWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLmFjdGlvbi5BY3Rpb25Db250cmlidXRpb25JdGVtOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLmFjdGlvbi5JQWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLndpbmRvdy5BcHBsaWNhdGlvbldpbmRvdzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS53aW5kb3cuV2luZG93OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5zd3QuVGV4dEZpZWxkTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuU1dUOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuRmlsbExheW91dDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkZvcm1BdHRhY2htZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuRm9ybURhdGE7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5Gb3JtTGF5b3V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db250cm9sOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkRpc3BsYXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuU2hlbGw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuVGV4dDsKLQotLyoqCi0gKiBQbGF5IGFyb3VuZCB3aXRoIGEgc2V0IG9mIGVudHJ5IGZpZWxkcy4KLSAqLwotcHVibGljIGNsYXNzIFRleHRGaWVsZE1vZGVsQWRhcHRlclVJVGVzdAotCWV4dGVuZHMgQXBwbGljYXRpb25XaW5kb3cKLXsKLQlwcml2YXRlIGZpbmFsIFRlc3RNb2RlbCB0ZXN0TW9kZWw7Ci0JCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBERUZBVUxUX05BTUUgPSAiU2Nvb2J5IERvbyI7Ci0JcHJpdmF0ZSBmaW5hbCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUZXN0TW9kZWw+IHRlc3RNb2RlbEhvbGRlcjsKLQlwcml2YXRlIGZpbmFsIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gbmFtZUhvbGRlcjsKLQlwcml2YXRlIGZpbmFsIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYWxsQ2Fwc05hbWVIb2xkZXI7Ci0KLQotCXB1YmxpYyBzdGF0aWMgdm9pZCBtYWluKFN0cmluZ1tdIGFyZ3MpIHRocm93cyBFeGNlcHRpb24gewotCQlXaW5kb3cgd2luZG93ID0gbmV3IFRleHRGaWVsZE1vZGVsQWRhcHRlclVJVGVzdChhcmdzKTsKLQkJd2luZG93LnNldEJsb2NrT25PcGVuKHRydWUpOwotCQl3aW5kb3cub3BlbigpOwotCQlEaXNwbGF5LmdldEN1cnJlbnQoKS5kaXNwb3NlKCk7Ci0JCVN5c3RlbS5leGl0KDApOwotCX0KLQotCXByaXZhdGUgVGV4dEZpZWxkTW9kZWxBZGFwdGVyVUlUZXN0KFN0cmluZ1tdIGFyZ3MpIHsKLQkJc3VwZXIobnVsbCk7Ci0JCXRoaXMudGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbChERUZBVUxUX05BTUUpOwotCQl0aGlzLnRlc3RNb2RlbEhvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdE1vZGVsPih0aGlzLnRlc3RNb2RlbCk7Ci0JCXRoaXMubmFtZUhvbGRlciA9IHRoaXMuYnVpbGROYW1lSG9sZGVyKHRoaXMudGVzdE1vZGVsSG9sZGVyKTsKLQkJdGhpcy5hbGxDYXBzTmFtZUhvbGRlciA9IHRoaXMuYnVpbGRBbGxDYXBzTmFtZUhvbGRlcih0aGlzLnRlc3RNb2RlbEhvbGRlcik7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkTmFtZUhvbGRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdE1vZGVsPiB2bSkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxUZXN0TW9kZWwsIFN0cmluZz4odm0sIFRlc3RNb2RlbC5OQU1FX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5uYW1lKCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhTdHJpbmcgdmFsdWUpIHsKLQkJCQl0aGlzLnN1YmplY3Quc2V0TmFtZSh2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkQWxsQ2Fwc05hbWVIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4gdm0pIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VGVzdE1vZGVsLCBTdHJpbmc+KHZtLCBUZXN0TW9kZWwuTkFNRV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QubmFtZSgpLnRvVXBwZXJDYXNlKCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhTdHJpbmcgdmFsdWUpIHsKLQkJCQkvLyBkbyBub3RoaW5nCi0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIENvbnRyb2wgY3JlYXRlQ29udGVudHMoQ29tcG9zaXRlIHBhcmVudCkgewotCQkoKFNoZWxsKSBwYXJlbnQpLnNldFRleHQoQ2xhc3NUb29scy5zaG9ydENsYXNzTmFtZUZvck9iamVjdCh0aGlzKSk7Ci0JCXBhcmVudC5zZXRTaXplKDQwMCwgMTAwKTsKLQkJQ29tcG9zaXRlIG1haW5QYW5lbCA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTk9ORSk7Ci0JCW1haW5QYW5lbC5zZXRMYXlvdXQobmV3IEZvcm1MYXlvdXQoKSk7Ci0JCUNvbnRyb2wgdGV4dEZpZWxkUGFuZWwgPSB0aGlzLmJ1aWxkVGV4dEZpZWxkUGFuZWwobWFpblBhbmVsKTsKLQkJdGhpcy5idWlsZENvbnRyb2xQYW5lbChtYWluUGFuZWwsIHRleHRGaWVsZFBhbmVsKTsKLQkJcmV0dXJuIG1haW5QYW5lbDsKLQl9Ci0KLQlwcml2YXRlIENvbnRyb2wgYnVpbGRUZXh0RmllbGRQYW5lbChDb21wb3NpdGUgcGFyZW50KSB7Ci0JCUNvbXBvc2l0ZSBwYW5lbCA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTk9ORSk7Ci0KLQkJRm9ybURhdGEgZmQgPSBuZXcgRm9ybURhdGEoKTsKLQkJCWZkLnRvcCA9IG5ldyBGb3JtQXR0YWNobWVudCgwKTsKLQkJCWZkLmJvdHRvbSA9IG5ldyBGb3JtQXR0YWNobWVudCgxMDAsIC0zNSk7Ci0JCQlmZC5sZWZ0ID0gbmV3IEZvcm1BdHRhY2htZW50KDApOwotCQkJZmQucmlnaHQgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMTAwKTsKLQkJcGFuZWwuc2V0TGF5b3V0RGF0YShmZCk7Ci0KLQkJcGFuZWwuc2V0TGF5b3V0KG5ldyBGaWxsTGF5b3V0KCkpOwotCQl0aGlzLmJ1aWxkTmFtZVRleHRGaWVsZChwYW5lbCk7Ci0JCXRoaXMuYnVpbGRSZWFkT25seU5hbWVUZXh0RmllbGQocGFuZWwpOwotCQl0aGlzLmJ1aWxkQWxsQ2Fwc05hbWVUZXh0RmllbGQocGFuZWwpOwotCi0JCXJldHVybiBwYW5lbDsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGROYW1lVGV4dEZpZWxkKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJVGV4dCB0ZXh0RmllbGQgPSBuZXcgVGV4dChwYXJlbnQsIFNXVC5TSU5HTEUpOwotCQlUZXh0RmllbGRNb2RlbEFkYXB0ZXIuYWRhcHQodGhpcy5uYW1lSG9sZGVyLCB0ZXh0RmllbGQpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZFJlYWRPbmx5TmFtZVRleHRGaWVsZChDb21wb3NpdGUgcGFyZW50KSB7Ci0JCVRleHQgdGV4dEZpZWxkID0gbmV3IFRleHQocGFyZW50LCBTV1QuU0lOR0xFKTsKLQkJdGV4dEZpZWxkLnNldEVuYWJsZWQoZmFsc2UpOwotCQlUZXh0RmllbGRNb2RlbEFkYXB0ZXIuYWRhcHQodGhpcy5uYW1lSG9sZGVyLCB0ZXh0RmllbGQpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZEFsbENhcHNOYW1lVGV4dEZpZWxkKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJVGV4dCB0ZXh0RmllbGQgPSBuZXcgVGV4dChwYXJlbnQsIFNXVC5TSU5HTEUpOwotCQl0ZXh0RmllbGQuc2V0RW5hYmxlZChmYWxzZSk7Ci0JCVRleHRGaWVsZE1vZGVsQWRhcHRlci5hZGFwdCh0aGlzLmFsbENhcHNOYW1lSG9sZGVyLCB0ZXh0RmllbGQpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZENvbnRyb2xQYW5lbChDb21wb3NpdGUgcGFyZW50LCBDb250cm9sIGNoZWNrQm94UGFuZWwpIHsKLQkJQ29tcG9zaXRlIHBhbmVsID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OT05FKTsKLQkJRm9ybURhdGEgZmQgPSBuZXcgRm9ybURhdGEoKTsKLQkJCWZkLnRvcCA9IG5ldyBGb3JtQXR0YWNobWVudChjaGVja0JveFBhbmVsKTsKLQkJCWZkLmJvdHRvbSA9IG5ldyBGb3JtQXR0YWNobWVudCgxMDApOwotCQkJZmQubGVmdCA9IG5ldyBGb3JtQXR0YWNobWVudCgwKTsKLQkJCWZkLnJpZ2h0ID0gbmV3IEZvcm1BdHRhY2htZW50KDEwMCk7Ci0JCXBhbmVsLnNldExheW91dERhdGEoZmQpOwotCi0JCXBhbmVsLnNldExheW91dChuZXcgRmlsbExheW91dCgpKTsKLQkJdGhpcy5idWlsZFJlc2V0TmFtZUJ1dHRvbihwYW5lbCk7Ci0JCXRoaXMuYnVpbGRDbGVhck1vZGVsQnV0dG9uKHBhbmVsKTsKLQkJdGhpcy5idWlsZFJlc3RvcmVNb2RlbEJ1dHRvbihwYW5lbCk7Ci0JCXRoaXMuYnVpbGRQcmludE1vZGVsQnV0dG9uKHBhbmVsKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRSZXNldE5hbWVCdXR0b24oQ29tcG9zaXRlIHBhcmVudCkgewotCQl0aGlzLmJ1aWxkUmVzZXROYW1lQUNJKCkuZmlsbChwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uQ29udHJpYnV0aW9uSXRlbSBidWlsZFJlc2V0TmFtZUFDSSgpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBY3Rpb24oInJlc2V0IG5hbWUiLCBJQWN0aW9uLkFTX1BVU0hfQlVUVE9OKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlUZXh0RmllbGRNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5yZXNldE5hbWUoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldFRvb2xUaXBUZXh0KCJyZXNldCBuYW1lIik7Ci0JCXJldHVybiBuZXcgQWN0aW9uQ29udHJpYnV0aW9uSXRlbShhY3Rpb24pOwotCX0KLQotCXZvaWQgcmVzZXROYW1lKCkgewotCQl0aGlzLnRlc3RNb2RlbC5zZXROYW1lKERFRkFVTFRfTkFNRSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGJ1aWxkQ2xlYXJNb2RlbEJ1dHRvbihDb21wb3NpdGUgcGFyZW50KSB7Ci0JCXRoaXMuYnVpbGRDbGVhck1vZGVsQUNJKCkuZmlsbChwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uQ29udHJpYnV0aW9uSXRlbSBidWlsZENsZWFyTW9kZWxBQ0koKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWN0aW9uKCJjbGVhciBtb2RlbCIsIElBY3Rpb24uQVNfUFVTSF9CVVRUT04pIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJCVRleHRGaWVsZE1vZGVsQWRhcHRlclVJVGVzdC50aGlzLmNsZWFyTW9kZWwoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldFRvb2xUaXBUZXh0KCJjbGVhciBtb2RlbCIpOwotCQlyZXR1cm4gbmV3IEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0oYWN0aW9uKTsKLQl9Ci0KLQl2b2lkIGNsZWFyTW9kZWwoKSB7Ci0JCXRoaXMudGVzdE1vZGVsSG9sZGVyLnNldFZhbHVlKG51bGwpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZFJlc3RvcmVNb2RlbEJ1dHRvbihDb21wb3NpdGUgcGFyZW50KSB7Ci0JCXRoaXMuYnVpbGRSZXN0b3JlTW9kZWxBQ0koKS5maWxsKHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb25Db250cmlidXRpb25JdGVtIGJ1aWxkUmVzdG9yZU1vZGVsQUNJKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFjdGlvbigicmVzdG9yZSBtb2RlbCIsIElBY3Rpb24uQVNfUFVTSF9CVVRUT04pIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJCVRleHRGaWVsZE1vZGVsQWRhcHRlclVJVGVzdC50aGlzLnJlc3RvcmVNb2RlbCgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0VG9vbFRpcFRleHQoInJlc3RvcmUgbW9kZWwiKTsKLQkJcmV0dXJuIG5ldyBBY3Rpb25Db250cmlidXRpb25JdGVtKGFjdGlvbik7Ci0JfQotCi0Jdm9pZCByZXN0b3JlTW9kZWwoKSB7Ci0JCXRoaXMudGVzdE1vZGVsSG9sZGVyLnNldFZhbHVlKHRoaXMudGVzdE1vZGVsKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRQcmludE1vZGVsQnV0dG9uKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJdGhpcy5idWlsZFByaW50TW9kZWxBQ0koKS5maWxsKHBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb25Db250cmlidXRpb25JdGVtIGJ1aWxkUHJpbnRNb2RlbEFDSSgpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBY3Rpb24oInByaW50IG1vZGVsIiwgSUFjdGlvbi5BU19QVVNIX0JVVFRPTikgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBydW4oKSB7Ci0JCQkJVGV4dEZpZWxkTW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMucHJpbnRNb2RlbCgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0VG9vbFRpcFRleHQoInByaW50IG1vZGVsIik7Ci0JCXJldHVybiBuZXcgQWN0aW9uQ29udHJpYnV0aW9uSXRlbShhY3Rpb24pOwotCX0KLQotCXZvaWQgcHJpbnRNb2RlbCgpIHsKLQkJU3lzdGVtLm91dC5wcmludGxuKCJuYW1lOiAiICsgdGhpcy50ZXN0TW9kZWwubmFtZSgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogbW9kZWwgY2xhc3MgKioqKioqKioqKgotCi0JY2xhc3MgVGVzdE1vZGVsIGV4dGVuZHMgQWJzdHJhY3RNb2RlbCB7Ci0JCXByaXZhdGUgU3RyaW5nIG5hbWU7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBOQU1FX1BST1BFUlRZID0gIm5hbWUiOwotCi0JCXB1YmxpYyBUZXN0TW9kZWwoU3RyaW5nIG5hbWUpIHsKLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCX0KLQkJcHVibGljIFN0cmluZyBuYW1lKCkgewotCQkJcmV0dXJuIHRoaXMubmFtZTsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXROYW1lKFN0cmluZyBuYW1lKSB7Ci0JCQlPYmplY3Qgb2xkID0gdGhpcy5uYW1lOwotCQkJdGhpcy5uYW1lID0gbmFtZTsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChOQU1FX1BST1BFUlRZLCBvbGQsIG5hbWUpOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuICJUZXN0TW9kZWwoIiArIHRoaXMubmFtZSArICIpIjsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3N3dC9UcmlTdGF0ZUNoZWNrQm94TW9kZWxBZGFwdGVyVUlUZXN0LmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvc3d0L1RyaVN0YXRlQ2hlY2tCb3hNb2RlbEFkYXB0ZXJVSVRlc3QuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODBiODg0MC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvc3d0L1RyaVN0YXRlQ2hlY2tCb3hNb2RlbEFkYXB0ZXJVSVRlc3QuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDMyMCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy5pbnRlcm5hbC5zd3Q7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS5hY3Rpb24uQWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLmFjdGlvbi5BY3Rpb25Db250cmlidXRpb25JdGVtOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLmFjdGlvbi5JQWN0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLndpbmRvdy5BcHBsaWNhdGlvbldpbmRvdzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS53aW5kb3cuV2luZG93OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC5zd3QuVHJpU3RhdGVDaGVja0JveE1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5EZWZhdWx0V2lkZ2V0RmFjdG9yeTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5UcmlTdGF0ZUNoZWNrQm94OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuU1dUOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5ldmVudHMuU2VsZWN0aW9uRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmV2ZW50cy5TZWxlY3Rpb25MaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkZpbGxMYXlvdXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5Gb3JtQXR0YWNobWVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkZvcm1EYXRhOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuRm9ybUxheW91dDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29udHJvbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5EaXNwbGF5OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLlNoZWxsOwotCi0vKioKLSAqIFBsYXkgYXJvdW5kIHdpdGggYSBzZXQgb2YgdHJpLXN0YXRlIGNoZWNrIGJveGVzLgotICovCi1wdWJsaWMgY2xhc3MgVHJpU3RhdGVDaGVja0JveE1vZGVsQWRhcHRlclVJVGVzdAotCWV4dGVuZHMgQXBwbGljYXRpb25XaW5kb3cKLXsKLQlwcml2YXRlIGZpbmFsIFRlc3RNb2RlbCB0ZXN0TW9kZWw7Ci0JcHJpdmF0ZSBmaW5hbCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUZXN0TW9kZWw+IHRlc3RNb2RlbEhvbGRlcjsKLQlwcml2YXRlIGZpbmFsIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGZsYWcxSG9sZGVyOwotCXByaXZhdGUgZmluYWwgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gZmxhZzJIb2xkZXI7Ci0JcHJpdmF0ZSBmaW5hbCBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBub3RGbGFnMkhvbGRlcjsKLQotCXB1YmxpYyBzdGF0aWMgdm9pZCBtYWluKFN0cmluZ1tdIGFyZ3MpIHRocm93cyBFeGNlcHRpb24gewotCQlXaW5kb3cgd2luZG93ID0gbmV3IFRyaVN0YXRlQ2hlY2tCb3hNb2RlbEFkYXB0ZXJVSVRlc3QoYXJncyk7Ci0JCXdpbmRvdy5zZXRCbG9ja09uT3Blbih0cnVlKTsKLQkJd2luZG93Lm9wZW4oKTsKLQkJRGlzcGxheS5nZXRDdXJyZW50KCkuZGlzcG9zZSgpOwotCQlTeXN0ZW0uZXhpdCgwKTsKLQl9Ci0KLQlwcml2YXRlIFRyaVN0YXRlQ2hlY2tCb3hNb2RlbEFkYXB0ZXJVSVRlc3QoU3RyaW5nW10gYXJncykgewotCQlzdXBlcihudWxsKTsKLQkJdGhpcy50ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKEJvb2xlYW4uVFJVRSwgQm9vbGVhbi5GQUxTRSk7Ci0JCXRoaXMudGVzdE1vZGVsSG9sZGVyID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxUZXN0TW9kZWw+KHRoaXMudGVzdE1vZGVsKTsKLQkJdGhpcy5mbGFnMUhvbGRlciA9IHRoaXMuYnVpbGRGbGFnMUhvbGRlcih0aGlzLnRlc3RNb2RlbEhvbGRlcik7Ci0JCXRoaXMuZmxhZzJIb2xkZXIgPSB0aGlzLmJ1aWxkRmxhZzJIb2xkZXIodGhpcy50ZXN0TW9kZWxIb2xkZXIpOwotCQl0aGlzLm5vdEZsYWcySG9sZGVyID0gdGhpcy5idWlsZE5vdEZsYWcySG9sZGVyKHRoaXMudGVzdE1vZGVsSG9sZGVyKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkRmxhZzFIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4gc3ViamVjdEhvbGRlcikgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxUZXN0TW9kZWwsIEJvb2xlYW4+KHN1YmplY3RIb2xkZXIsIFRlc3RNb2RlbC5GTEFHMV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmlzRmxhZzEoKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKEJvb2xlYW4gdmFsdWUpIHsKLQkJCQl0aGlzLnN1YmplY3Quc2V0RmxhZzEodmFsdWUpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRGbGFnMkhvbGRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdE1vZGVsPiBzdWJqZWN0SG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFRlc3RNb2RlbCwgQm9vbGVhbj4oc3ViamVjdEhvbGRlciwgVGVzdE1vZGVsLkZMQUcyX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuaXNGbGFnMigpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCXRoaXMuc3ViamVjdC5zZXRGbGFnMih2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBidWlsZE5vdEZsYWcySG9sZGVyKFByb3BlcnR5VmFsdWVNb2RlbDxUZXN0TW9kZWw+IHN1YmplY3RIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VGVzdE1vZGVsLCBCb29sZWFuPihzdWJqZWN0SG9sZGVyLCBUZXN0TW9kZWwuTk9UX0ZMQUcyX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuaXNOb3RGbGFnMigpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCXRoaXMuc3ViamVjdC5zZXROb3RGbGFnMih2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIENvbnRyb2wgY3JlYXRlQ29udGVudHMoQ29tcG9zaXRlIHBhcmVudCkgewotCQkoKFNoZWxsKSBwYXJlbnQpLnNldFRleHQoQ2xhc3NUb29scy5zaG9ydENsYXNzTmFtZUZvck9iamVjdCh0aGlzKSk7Ci0JCXBhcmVudC5zZXRTaXplKDQwMCwgMTAwKTsKLQkJQ29tcG9zaXRlIG1haW5QYW5lbCA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTk9ORSk7Ci0JCW1haW5QYW5lbC5zZXRMYXlvdXQobmV3IEZvcm1MYXlvdXQoKSk7Ci0JCUNvbnRyb2wgY2hlY2tCb3hQYW5lbCA9IHRoaXMuYnVpbGRDaGVja0JveFBhbmVsKG1haW5QYW5lbCk7Ci0JCXRoaXMuYnVpbGRDb250cm9sUGFuZWwobWFpblBhbmVsLCBjaGVja0JveFBhbmVsKTsKLQkJcmV0dXJuIG1haW5QYW5lbDsKLQl9Ci0KLQlwcml2YXRlIENvbnRyb2wgYnVpbGRDaGVja0JveFBhbmVsKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJQ29tcG9zaXRlIHBhbmVsID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OT05FKTsKLQotCQlGb3JtRGF0YSBmZCA9IG5ldyBGb3JtRGF0YSgpOwotCQkJZmQudG9wID0gbmV3IEZvcm1BdHRhY2htZW50KDApOwotCQkJZmQuYm90dG9tID0gbmV3IEZvcm1BdHRhY2htZW50KDEwMCwgLTM1KTsKLQkJCWZkLmxlZnQgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMCk7Ci0JCQlmZC5yaWdodCA9IG5ldyBGb3JtQXR0YWNobWVudCgxMDApOwotCQlwYW5lbC5zZXRMYXlvdXREYXRhKGZkKTsKLQotCQlwYW5lbC5zZXRMYXlvdXQobmV3IEZpbGxMYXlvdXQoKSk7Ci0JCXRoaXMuYnVpbGRGbGFnMUNoZWNrQm94KHBhbmVsKTsKLQkJdGhpcy5idWlsZEZsYWcyQ2hlY2tCb3gocGFuZWwpOwotCQl0aGlzLmJ1aWxkTm90RmxhZzJDaGVja0JveChwYW5lbCk7Ci0JCXRoaXMuYnVpbGRVbmF0dGFjaGVkQ2hlY2tCb3gocGFuZWwpOwotCi0JCXJldHVybiBwYW5lbDsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRGbGFnMUNoZWNrQm94KENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJVHJpU3RhdGVDaGVja0JveCBjaGVja0JveCA9IG5ldyBUcmlTdGF0ZUNoZWNrQm94KHBhcmVudCwgImZsYWcgMSIsIERlZmF1bHRXaWRnZXRGYWN0b3J5Lmluc3RhbmNlKCkpOwotCQlUcmlTdGF0ZUNoZWNrQm94TW9kZWxBZGFwdGVyLmFkYXB0KHRoaXMuZmxhZzFIb2xkZXIsIGNoZWNrQm94KTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRGbGFnMkNoZWNrQm94KENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJVHJpU3RhdGVDaGVja0JveCBjaGVja0JveCA9IG5ldyBUcmlTdGF0ZUNoZWNrQm94KHBhcmVudCwgImZsYWcgMiIsIERlZmF1bHRXaWRnZXRGYWN0b3J5Lmluc3RhbmNlKCkpOwotCQlUcmlTdGF0ZUNoZWNrQm94TW9kZWxBZGFwdGVyLmFkYXB0KHRoaXMuZmxhZzJIb2xkZXIsIGNoZWNrQm94KTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGROb3RGbGFnMkNoZWNrQm94KENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJVHJpU3RhdGVDaGVja0JveCBjaGVja0JveCA9IG5ldyBUcmlTdGF0ZUNoZWNrQm94KHBhcmVudCwgIm5leHQgZmxhZyAyIiwgRGVmYXVsdFdpZGdldEZhY3RvcnkuaW5zdGFuY2UoKSk7Ci0JCVRyaVN0YXRlQ2hlY2tCb3hNb2RlbEFkYXB0ZXIuYWRhcHQodGhpcy5ub3RGbGFnMkhvbGRlciwgY2hlY2tCb3gpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZFVuYXR0YWNoZWRDaGVja0JveChDb21wb3NpdGUgcGFyZW50KSB7Ci0JCVRyaVN0YXRlQ2hlY2tCb3ggY2hlY2tCb3ggPSBuZXcgVHJpU3RhdGVDaGVja0JveChwYXJlbnQsICJ1bmF0dGFjaGVkIiwgRGVmYXVsdFdpZGdldEZhY3RvcnkuaW5zdGFuY2UoKSk7Ci0JCWNoZWNrQm94LmFkZFNlbGVjdGlvbkxpc3RlbmVyKHRoaXMuYnVpbGRVbmF0dGFjaGVkU2VsZWN0aW9uTGlzdGVuZXIoKSk7Ci0JfQotCi0JcHJpdmF0ZSBTZWxlY3Rpb25MaXN0ZW5lciBidWlsZFVuYXR0YWNoZWRTZWxlY3Rpb25MaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBTZWxlY3Rpb25MaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHdpZGdldERlZmF1bHRTZWxlY3RlZChTZWxlY3Rpb25FdmVudCBlKSB7Ci0JCQkJU3lzdGVtLm91dC5wcmludGxuKCJ1bmF0dGFjaGVkIGRlZmF1bHQgc2VsZWN0ZWQ6ICIgKyBlKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIHdpZGdldFNlbGVjdGVkKFNlbGVjdGlvbkV2ZW50IGUpIHsKLQkJCQlTeXN0ZW0ub3V0LnByaW50bG4oInVuYXR0YWNoZWQgc2VsZWN0ZWQ6ICIgKyBlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRDb250cm9sUGFuZWwoQ29tcG9zaXRlIHBhcmVudCwgQ29udHJvbCBjaGVja0JveFBhbmVsKSB7Ci0JCUNvbXBvc2l0ZSBwYW5lbCA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTk9ORSk7Ci0JCUZvcm1EYXRhIGZkID0gbmV3IEZvcm1EYXRhKCk7Ci0JCQlmZC50b3AgPSBuZXcgRm9ybUF0dGFjaG1lbnQoY2hlY2tCb3hQYW5lbCk7Ci0JCQlmZC5ib3R0b20gPSBuZXcgRm9ybUF0dGFjaG1lbnQoMTAwKTsKLQkJCWZkLmxlZnQgPSBuZXcgRm9ybUF0dGFjaG1lbnQoMCk7Ci0JCQlmZC5yaWdodCA9IG5ldyBGb3JtQXR0YWNobWVudCgxMDApOwotCQlwYW5lbC5zZXRMYXlvdXREYXRhKGZkKTsKLQotCQlwYW5lbC5zZXRMYXlvdXQobmV3IEZpbGxMYXlvdXQoKSk7Ci0JCXRoaXMuYnVpbGRGbGlwRmxhZzFCdXR0b24ocGFuZWwpOwotCQl0aGlzLmJ1aWxkQ2xlYXJNb2RlbEJ1dHRvbihwYW5lbCk7Ci0JCXRoaXMuYnVpbGRSZXN0b3JlTW9kZWxCdXR0b24ocGFuZWwpOwotCQl0aGlzLmJ1aWxkUHJpbnRNb2RlbEJ1dHRvbihwYW5lbCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGJ1aWxkRmxpcEZsYWcxQnV0dG9uKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQkJdGhpcy5idWlsZEZsaXBGbGFnMUFDSSgpLmZpbGwocGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0gYnVpbGRGbGlwRmxhZzFBQ0koKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWN0aW9uKCJuZXh0IGZsYWcgMSIsIElBY3Rpb24uQVNfUFVTSF9CVVRUT04pIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJCVRyaVN0YXRlQ2hlY2tCb3hNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5uZXh0RmxhZzEoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldFRvb2xUaXBUZXh0KCJuZXh0IGZsYWcgMSIpOwotCQlyZXR1cm4gbmV3IEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0oYWN0aW9uKTsKLQl9Ci0KLQl2b2lkIG5leHRGbGFnMSgpIHsKLQkJdGhpcy50ZXN0TW9kZWwubmV4dEZsYWcxKCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGJ1aWxkQ2xlYXJNb2RlbEJ1dHRvbihDb21wb3NpdGUgcGFyZW50KSB7Ci0JCXRoaXMuYnVpbGRDbGVhck1vZGVsQUNJKCkuZmlsbChwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uQ29udHJpYnV0aW9uSXRlbSBidWlsZENsZWFyTW9kZWxBQ0koKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWN0aW9uKCJjbGVhciBtb2RlbCIsIElBY3Rpb24uQVNfUFVTSF9CVVRUT04pIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJCVRyaVN0YXRlQ2hlY2tCb3hNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5jbGVhck1vZGVsKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRUb29sVGlwVGV4dCgiY2xlYXIgbW9kZWwiKTsKLQkJcmV0dXJuIG5ldyBBY3Rpb25Db250cmlidXRpb25JdGVtKGFjdGlvbik7Ci0JfQotCi0Jdm9pZCBjbGVhck1vZGVsKCkgewotCQl0aGlzLnRlc3RNb2RlbEhvbGRlci5zZXRWYWx1ZShudWxsKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgYnVpbGRSZXN0b3JlTW9kZWxCdXR0b24oQ29tcG9zaXRlIHBhcmVudCkgewotCQl0aGlzLmJ1aWxkUmVzdG9yZU1vZGVsQUNJKCkuZmlsbChwYXJlbnQpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uQ29udHJpYnV0aW9uSXRlbSBidWlsZFJlc3RvcmVNb2RlbEFDSSgpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBY3Rpb24oInJlc3RvcmUgbW9kZWwiLCBJQWN0aW9uLkFTX1BVU0hfQlVUVE9OKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlUcmlTdGF0ZUNoZWNrQm94TW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMucmVzdG9yZU1vZGVsKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRUb29sVGlwVGV4dCgicmVzdG9yZSBtb2RlbCIpOwotCQlyZXR1cm4gbmV3IEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0oYWN0aW9uKTsKLQl9Ci0KLQl2b2lkIHJlc3RvcmVNb2RlbCgpIHsKLQkJdGhpcy50ZXN0TW9kZWxIb2xkZXIuc2V0VmFsdWUodGhpcy50ZXN0TW9kZWwpOwotCX0KLQotCXByaXZhdGUgdm9pZCBidWlsZFByaW50TW9kZWxCdXR0b24oQ29tcG9zaXRlIHBhcmVudCkgewotCQl0aGlzLmJ1aWxkUHJpbnRNb2RlbEFDSSgpLmZpbGwocGFyZW50KTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbkNvbnRyaWJ1dGlvbkl0ZW0gYnVpbGRQcmludE1vZGVsQUNJKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFjdGlvbigicHJpbnQgbW9kZWwiLCBJQWN0aW9uLkFTX1BVU0hfQlVUVE9OKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlUcmlTdGF0ZUNoZWNrQm94TW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMucHJpbnRNb2RlbCgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0VG9vbFRpcFRleHQoInByaW50IG1vZGVsIik7Ci0JCXJldHVybiBuZXcgQWN0aW9uQ29udHJpYnV0aW9uSXRlbShhY3Rpb24pOwotCX0KLQotCXZvaWQgcHJpbnRNb2RlbCgpIHsKLQkJU3lzdGVtLm91dC5wcmludGxuKCJmbGFnIDE6ICIgKyB0aGlzLnRlc3RNb2RlbC5pc0ZsYWcxKCkpOwotCQlTeXN0ZW0ub3V0LnByaW50bG4oImZsYWcgMjogIiArIHRoaXMudGVzdE1vZGVsLmlzRmxhZzIoKSk7Ci0JCVN5c3RlbS5vdXQucHJpbnRsbigibm90IGZsYWcgMjogIiArIHRoaXMudGVzdE1vZGVsLmlzTm90RmxhZzIoKSk7Ci0JCVN5c3RlbS5vdXQucHJpbnRsbigiKioqIik7Ci0JfQotCi0KLQlwcml2YXRlIGNsYXNzIFRlc3RNb2RlbCBleHRlbmRzIEFic3RyYWN0TW9kZWwgewotCQlwcml2YXRlIEJvb2xlYW4gZmxhZzE7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBGTEFHMV9QUk9QRVJUWSA9ICJmbGFnMSI7Ci0JCXByaXZhdGUgQm9vbGVhbiBmbGFnMjsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIEZMQUcyX1BST1BFUlRZID0gImZsYWcyIjsKLQkJcHJpdmF0ZSBCb29sZWFuIG5vdEZsYWcyOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgTk9UX0ZMQUcyX1BST1BFUlRZID0gIm5vdEZsYWcyIjsKLQkKLQkJcHVibGljIFRlc3RNb2RlbChCb29sZWFuIGZsYWcxLCBCb29sZWFuIGZsYWcyKSB7Ci0JCQl0aGlzLmZsYWcxID0gZmxhZzE7Ci0JCQl0aGlzLmZsYWcyID0gZmxhZzI7Ci0JCQl0aGlzLm5vdEZsYWcyID0gdGhpcy5uZXh0KGZsYWcyKTsKLQkJfQotCQlwcml2YXRlIEJvb2xlYW4gbmV4dChCb29sZWFuIGIpIHsKLQkJCXJldHVybiAoYiA9PSBudWxsKSA/IEJvb2xlYW4uVFJVRSA6IGIuYm9vbGVhblZhbHVlKCkgPyBCb29sZWFuLkZBTFNFIDogbnVsbDsKLQkJfQotCQlwdWJsaWMgQm9vbGVhbiBpc0ZsYWcxKCkgewotCQkJcmV0dXJuIHRoaXMuZmxhZzE7Ci0JCX0KLQkJcHVibGljIHZvaWQgc2V0RmxhZzEoQm9vbGVhbiBmbGFnMSkgewotCQkJQm9vbGVhbiBvbGQgPSB0aGlzLmZsYWcxOwotCQkJdGhpcy5mbGFnMSA9IGZsYWcxOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKEZMQUcxX1BST1BFUlRZLCBvbGQsIGZsYWcxKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBuZXh0RmxhZzEoKSB7Ci0JCQl0aGlzLnNldEZsYWcxKHRoaXMubmV4dCh0aGlzLmZsYWcxKSk7Ci0JCX0KLQkJcHVibGljIEJvb2xlYW4gaXNGbGFnMigpIHsKLQkJCXJldHVybiB0aGlzLmZsYWcyOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldEZsYWcyKEJvb2xlYW4gZmxhZzIpIHsKLQkJCUJvb2xlYW4gb2xkID0gdGhpcy5mbGFnMjsKLQkJCXRoaXMuZmxhZzIgPSBmbGFnMjsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChGTEFHMl9QUk9QRVJUWSwgb2xkLCBmbGFnMik7Ci0KLQkJCW9sZCA9IHRoaXMubm90RmxhZzI7Ci0JCQl0aGlzLm5vdEZsYWcyID0gdGhpcy5uZXh0KGZsYWcyKTsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChOT1RfRkxBRzJfUFJPUEVSVFksIG9sZCwgdGhpcy5ub3RGbGFnMik7Ci0JCX0KLQkJcHVibGljIHZvaWQgbmV4dEZsYWcyKCkgewotCQkJdGhpcy5zZXRGbGFnMih0aGlzLm5leHQodGhpcy5mbGFnMikpOwotCQl9Ci0JCXB1YmxpYyBCb29sZWFuIGlzTm90RmxhZzIoKSB7Ci0JCQlyZXR1cm4gdGhpcy5ub3RGbGFnMjsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXROb3RGbGFnMihCb29sZWFuIG5vdEZsYWcyKSB7Ci0JCQl0aGlzLnNldEZsYWcyKHRoaXMubmV4dChmbGFnMikpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIG5leHROb3RGbGFnMigpIHsKLQkJCXRoaXMuc2V0Tm90RmxhZzIodGhpcy5uZXh0KHRoaXMubm90RmxhZzIpKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiVGVzdE1vZGVsKCIgKyB0aGlzLmlzRmxhZzEoKSArICIgLSAiICsgdGhpcy5pc0ZsYWcyKCkgKyAiKSI7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC91dGlsL0NvbnRyb2xBbGlnbmVyVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3V0aWwvQ29udHJvbEFsaWduZXJUZXN0LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVjY2Q0NGUuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3V0aWwvQ29udHJvbEFsaWduZXJUZXN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw4MDAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy5pbnRlcm5hbC51dGlsOwotCi1pbXBvcnQgc3RhdGljIG9yZy5qdW5pdC5Bc3NlcnQuKjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS5kaWFsb2dzLlRpdGxlQXJlYURpYWxvZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwudXRpbC5Db250cm9sQWxpZ25lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwudXRpbC5TV1RVdGlsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LlNXVDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuZ3JhcGhpY3MuUG9pbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkRGF0YTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWRMYXlvdXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQnV0dG9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db250cm9sOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkRpc3BsYXk7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuTGFiZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuTGF5b3V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLlNoZWxsOwotaW1wb3J0IG9yZy5qdW5pdC5BZnRlcjsKLWltcG9ydCBvcmcuanVuaXQuQmVmb3JlOwotaW1wb3J0IG9yZy5qdW5pdC5UZXN0OwotCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBmaW5hbCBjbGFzcyBDb250cm9sQWxpZ25lclRlc3QgewotCi0JcHJpdmF0ZSBDb250cm9sQWxpZ25lciBjb250cm9sQWxpZ25lcjsKLQlwcml2YXRlIENvbXBvc2l0ZSBwYXJlbnQ7Ci0JcHJpdmF0ZSBTaGVsbCBzaGVsbDsKLQotCXByaXZhdGUgTGF5b3V0IGJ1aWxkU3BhY2VyTGF5b3V0KCkgewotCQlyZXR1cm4gbmV3IExheW91dCgpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFBvaW50IGNvbXB1dGVTaXplKENvbXBvc2l0ZSBjb21wb3NpdGUsCi0JCQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW50IHdpZHRoSGludCwKLQkJCSAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbnQgaGVpZ2h0SGludCwKLQkJCSAgICAgICAgICAgICAgICAgICAgICAgICAgICBib29sZWFuIGZsdXNoQ2FjaGUpIHsKLQotCQkJCXJldHVybiBuZXcgUG9pbnQod2lkdGhIaW50LCBoZWlnaHRIaW50KTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBsYXlvdXQoQ29tcG9zaXRlIGNvbXBvc2l0ZSwgYm9vbGVhbiBmbHVzaENhY2hlKSB7Ci0JCQkJR3JpZERhdGEgZGF0YSA9IChHcmlkRGF0YSkgY29tcG9zaXRlLmdldExheW91dERhdGEoKTsKLQkJCQljb21wb3NpdGUuc2V0Qm91bmRzKDAsIDAsIGRhdGEud2lkdGhIaW50LCBkYXRhLmhlaWdodEhpbnQpOwotCQkJfQotCQl9OwotCX0KLQotCUBCZWZvcmUKLQlwdWJsaWMgdm9pZCBzZXRVcCgpIHsKLQotCQljb250cm9sQWxpZ25lciA9IG5ldyBDb250cm9sQWxpZ25lcigpOwotCi0JCXNoZWxsICA9IG5ldyBTaGVsbChEaXNwbGF5LmdldEN1cnJlbnQoKSk7Ci0JCXNoZWxsLnNldExheW91dChuZXcgR3JpZExheW91dCgxLCBmYWxzZSkpOwotCi0JCXBhcmVudCA9IG5ldyBDb21wb3NpdGUoc2hlbGwsIFNXVC5OT05FKTsKLQkJcGFyZW50LnNldExheW91dChuZXcgR3JpZExheW91dCgxLCBmYWxzZSkpOwotCQlwYXJlbnQuc2V0TGF5b3V0RGF0YShuZXcgR3JpZERhdGEoR3JpZERhdGEuSE9SSVpPTlRBTF9BTElHTl9CRUdJTk5JTkcpKTsKLQl9Ci0KLQlAQWZ0ZXIKLQlwdWJsaWMgdm9pZCB0ZWFyRG93bigpIHsKLQotCQlpZiAoY29udHJvbEFsaWduZXIgIT0gbnVsbCkgewotCQkJY29udHJvbEFsaWduZXIuZGlzcG9zZSgpOwotCQkJY29udHJvbEFsaWduZXIgPSBudWxsOwotCQl9Ci0KLQkJaWYgKHNoZWxsICE9IG51bGwpIHsKLQkJCXNoZWxsLmRpc3Bvc2UoKTsKLQkJCXNoZWxsID0gbnVsbDsKLQkJfQotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdEFkZENvbnRyb2wxKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJQ29tcG9zaXRlIHBhbmUgPSBuZXcgQ29tcG9zaXRlKHBhcmVudCwgU1dULk5VTEwpOwotCQlwYW5lLnNldExheW91dChuZXcgR3JpZExheW91dCgzLCBmYWxzZSkpOwotCQlwYW5lLnNldExheW91dERhdGEobmV3IEdyaWREYXRhKEdyaWREYXRhLkZJTExfSE9SSVpPTlRBTCkpOwotCi0JCUxhYmVsIGxhYmVsID0gbmV3IExhYmVsKHBhbmUsIFNXVC5OVUxMKTsKLQkJdXBkYXRlR3JpZERhdGEobGFiZWwpOwotCi0JCWNvbnRyb2xBbGlnbmVyLmFkZChsYWJlbCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSBtYXhpbXVtIHdpZHRoIHNob3VsZCBiZSAwLCIsCi0JCQkwLAotCQkJY29udHJvbEFsaWduZXIuZ2V0TWF4aW11bVdpZHRoKCkKLQkJKTsKLQotCQlsYWJlbC5zZXRUZXh0KCJUaGlzIGlzIGEgQ29udHJvbEFsaWduZXIiKTsKLS8vCQlwYXJlbnQubGF5b3V0KHRydWUsIHRydWUpOwotCi0JCVBvaW50IHNpemUgPSBsYWJlbC5nZXRTaXplKCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSB3aWR0aCBzaG91bGQgYmUgIiArIHNpemUueCArICIsIiwKLQkJCXNpemUueCwKLQkJCWNvbnRyb2xBbGlnbmVyLmdldE1heGltdW1XaWR0aCgpCi0JCSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQ29udHJvbDIoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQlDb21wb3NpdGUgcGFuZSA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTlVMTCk7Ci0JCXBhbmUuc2V0TGF5b3V0KG5ldyBHcmlkTGF5b3V0KDMsIGZhbHNlKSk7Ci0JCXBhbmUuc2V0TGF5b3V0RGF0YShuZXcgR3JpZERhdGEoR3JpZERhdGEuRklMTF9IT1JJWk9OVEFMKSk7Ci0KLQkJQnV0dG9uIGJ1dHRvbiA9IG5ldyBCdXR0b24ocGFuZSwgU1dULk5VTEwpOwotCQlidXR0b24uc2V0VGV4dCgiVGhpcyBpcyBhIENvbnRyb2xBbGlnbmVyIik7Ci0JCXVwZGF0ZUdyaWREYXRhKGJ1dHRvbik7Ci0KLQkJY29udHJvbEFsaWduZXIuYWRkKGJ1dHRvbik7Ci0JCXBhcmVudC5sYXlvdXQodHJ1ZSwgdHJ1ZSk7Ci0KLQkJUG9pbnQgc2l6ZSA9IGJ1dHRvbi5nZXRTaXplKCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSB3aWR0aCBzaG91bGQgYmUgIiArIHNpemUueCArICIsIiwKLQkJCXNpemUueCwKLQkJCWNvbnRyb2xBbGlnbmVyLmdldE1heGltdW1XaWR0aCgpCi0JCSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQ29udHJvbDMoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQlDb21wb3NpdGUgcGFuZSA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTlVMTCk7Ci0JCXBhbmUuc2V0TGF5b3V0KG5ldyBHcmlkTGF5b3V0KDMsIGZhbHNlKSk7Ci0JCXBhbmUuc2V0TGF5b3V0RGF0YShuZXcgR3JpZERhdGEoR3JpZERhdGEuRklMTF9IT1JJWk9OVEFMKSk7Ci0KLQkJTGFiZWwgbGFiZWwgPSBuZXcgTGFiZWwocGFuZSwgU1dULk5VTEwpOwotCQlsYWJlbC5zZXRUZXh0KCJUaGlzIGlzIHZlcnkgbG9uZyB0ZXh0Iik7Ci0JCXVwZGF0ZUdyaWREYXRhKGxhYmVsKTsKLQotCQlCdXR0b24gYnV0dG9uID0gbmV3IEJ1dHRvbihwYW5lLCBTV1QuTlVMTCk7Ci0JCWJ1dHRvbi5zZXRUZXh0KCJTaG9ydCB0ZXh0Iik7Ci0JCXVwZGF0ZUdyaWREYXRhKGJ1dHRvbik7Ci0KLS8vCQlwYXJlbnQubGF5b3V0KHRydWUsIHRydWUpOwotCi0JCWNvbnRyb2xBbGlnbmVyLmFkZChsYWJlbCk7Ci0JCWNvbnRyb2xBbGlnbmVyLmFkZChidXR0b24pOwotCi0JCVBvaW50IGxhYmVsU2l6ZSAgPSBsYWJlbC5nZXRTaXplKCk7Ci0JCVBvaW50IGJ1dHRvblNpemUgPSBidXR0b24uZ2V0U2l6ZSgpOwotCQlpbnQgbWF4ID0gTWF0aC5tYXgobGFiZWxTaXplLngsIGJ1dHRvblNpemUueCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSB3aWR0aCBzaG91bGQgYmUgIiArIG1heCArICIsIiwKLQkJCW1heCwKLQkJCWNvbnRyb2xBbGlnbmVyLmdldE1heGltdW1XaWR0aCgpCi0JCSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQ29udHJvbEFsaWduZXIxKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJTGFiZWwgbGFiZWwxID0gbmV3IExhYmVsKHBhcmVudCwgU1dULk5VTEwpOwotCQlMYWJlbCBsYWJlbDIgPSBuZXcgTGFiZWwocGFyZW50LCBTV1QuTlVMTCk7Ci0KLQkJdXBkYXRlR3JpZERhdGEobGFiZWwxKTsKLQkJdXBkYXRlR3JpZERhdGEobGFiZWwyKTsKLQotCQljb250cm9sQWxpZ25lci5hZGQobGFiZWwxKTsKLQotCQlDb250cm9sQWxpZ25lciBjb250cm9sQWxpZ25lcjIgPSBuZXcgQ29udHJvbEFsaWduZXIoKTsKLQkJY29udHJvbEFsaWduZXIuYWRkKGNvbnRyb2xBbGlnbmVyMik7Ci0JCWNvbnRyb2xBbGlnbmVyMi5hZGQobGFiZWwyKTsKLQotCQlsYWJlbDEuc2V0VGV4dCgiVGhpcyBpcyBhIENvbnRyb2xBbGlnbmVyIik7Ci0JCWxhYmVsMi5zZXRUZXh0KCJUaGlzIGlzIGEgdmVyeSBsb25nIENvbnRyb2xBbGlnbmVyIik7Ci0vLwkJcGFyZW50LmxheW91dCh0cnVlLCB0cnVlKTsKLQotCQlQb2ludCBzaXplMSA9IGxhYmVsMS5nZXRTaXplKCk7Ci0JCVBvaW50IHNpemUyID0gbGFiZWwyLmdldFNpemUoKTsKLQkJaW50IHdpZHRoID0gTWF0aC5tYXgoc2l6ZTEueCwgc2l6ZTIueCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSB3aWR0aCBzaG91bGQgYmUgIiArIHdpZHRoICsgIiwiLAotCQkJd2lkdGgsCi0JCQljb250cm9sQWxpZ25lci5nZXRNYXhpbXVtV2lkdGgoKQotCQkpOwotCi0JCWFzc2VydEVxdWFscygKLQkJCSJUaGUgd2lkdGggc2hvdWxkIGJlICIgKyB3aWR0aCArICIsIiwKLQkJCXdpZHRoLAotCQkJY29udHJvbEFsaWduZXIyLmdldE1heGltdW1XaWR0aCgpCi0JCSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQ29udHJvbEFsaWduZXIyKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJTGFiZWwgbGFiZWwxID0gbmV3IExhYmVsKHBhcmVudCwgU1dULk5VTEwpOwotCQlMYWJlbCBsYWJlbDIgPSBuZXcgTGFiZWwocGFyZW50LCBTV1QuTlVMTCk7Ci0KLQkJdXBkYXRlR3JpZERhdGEobGFiZWwxKTsKLQkJdXBkYXRlR3JpZERhdGEobGFiZWwyKTsKLQotCQljb250cm9sQWxpZ25lci5hZGQobGFiZWwxKTsKLQotCQlDb250cm9sQWxpZ25lciBjb250cm9sQWxpZ25lcjIgPSBuZXcgQ29udHJvbEFsaWduZXIoKTsKLQkJY29udHJvbEFsaWduZXIyLmFkZChsYWJlbDIpOwotCi0JCWxhYmVsMS5zZXRUZXh0KCJUaGlzIGlzIGEgQ29udHJvbEFsaWduZXIiKTsKLQkJbGFiZWwyLnNldFRleHQoIlRoaXMgaXMgYSB2ZXJ5IGxvbmcgQ29udHJvbEFsaWduZXIiKTsKLQotCQljb250cm9sQWxpZ25lci5hZGQoY29udHJvbEFsaWduZXIyKTsKLS8vCQlwYXJlbnQubGF5b3V0KHRydWUsIHRydWUpOwotCi0JCVBvaW50IHNpemUxID0gbGFiZWwxLmdldFNpemUoKTsKLQkJUG9pbnQgc2l6ZTIgPSBsYWJlbDIuZ2V0U2l6ZSgpOwotCQlpbnQgd2lkdGggPSBNYXRoLm1heChzaXplMS54LCBzaXplMi54KTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHdpZHRoIHNob3VsZCBiZSAiICsgd2lkdGggKyAiLCIsCi0JCQl3aWR0aCwKLQkJCWNvbnRyb2xBbGlnbmVyLmdldE1heGltdW1XaWR0aCgpCi0JCSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSB3aWR0aCBzaG91bGQgYmUgIiArIHdpZHRoICsgIiwiLAotCQkJd2lkdGgsCi0JCQljb250cm9sQWxpZ25lcjIuZ2V0TWF4aW11bVdpZHRoKCkKLQkJKTsKLQl9Ci0KLQlAVGVzdChleHBlY3RlZD1JbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24uY2xhc3MpCi0JcHVibGljIHZvaWQgdGVzdEFkZENvbnRyb2xBbGlnbmVyVG9JdHNlbGYoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJY29udHJvbEFsaWduZXIuYWRkKGNvbnRyb2xBbGlnbmVyKTsKLQkJZmFpbCgiQSBDb250cm9sQWxpZ25lciBjYW4ndCBiZSBhZGRlZCB0byBpdHNlbGYiKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3REaWFsb2dfQWRkQ29udHJvbDEoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQlmaW5hbCBpbnRbXSBtYXhpbXVtV2lkdGggPSBuZXcgaW50WzFdOwotCQlmaW5hbCBpbnRbXSBzaXplID0gbmV3IGludFsxXTsKLQotCQlUaXRsZUFyZWFEaWFsb2cgZGlhbG9nID0gbmV3IFRpdGxlQXJlYURpYWxvZyhTV1RVdGlsLmdldFNoZWxsKCkpIHsKLQotCQkJcHJpdmF0ZSBMYWJlbCBsYWJlbDsKLQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ29udHJvbCBjcmVhdGVEaWFsb2dBcmVhKENvbXBvc2l0ZSBwYXJlbnQpIHsKLQotCQkJCUNvbXBvc2l0ZSBwYW5lID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OVUxMKTsKLQkJCQlwYW5lLnNldExheW91dChuZXcgR3JpZExheW91dCgzLCBmYWxzZSkpOwotCQkJCXBhbmUuc2V0TGF5b3V0RGF0YShuZXcgR3JpZERhdGEoR3JpZERhdGEuRklMTF9IT1JJWk9OVEFMKSk7Ci0KLQkJCQlsYWJlbCA9IG5ldyBMYWJlbChwYW5lLCBTV1QuTEVGVCk7Ci0JCQkJbGFiZWwuc2V0VGV4dCgiVGhpcyBpcyBhIENvbnRyb2xBbGlnbmVyIik7Ci0JCQkJdXBkYXRlR3JpZERhdGEobGFiZWwpOwotCi0JCQkJY29udHJvbEFsaWduZXIuYWRkKGxhYmVsKTsKLQotCQkJCXJldHVybiBwYXJlbnQ7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUJvdW5kcygpIHsKLQkJCQlzdXBlci5pbml0aWFsaXplQm91bmRzKCk7Ci0JCQkJc2l6ZVswXSA9IGxhYmVsLmdldFNpemUoKS54OwotCQkJCW1heGltdW1XaWR0aFswXSA9IGNvbnRyb2xBbGlnbmVyLmdldE1heGltdW1XaWR0aCgpOwotCQkJfQotCQl9OwotCi0JCWRpYWxvZy5jcmVhdGUoKTsKLQkJZGlhbG9nLmNsb3NlKCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSB3aWR0aCBzaG91bGQgYmUgIiArIHNpemVbMF0gKyAiLCIsCi0JCQlzaXplWzBdLAotCQkJbWF4aW11bVdpZHRoWzBdCi0JCSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0RGlhbG9nX0FkZENvbnRyb2wyKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJZmluYWwgaW50W10gbWF4aW11bVdpZHRoID0gbmV3IGludFsxXTsKLQkJZmluYWwgaW50W10gc2l6ZXMgPSBuZXcgaW50WzJdOwotCi0JCVRpdGxlQXJlYURpYWxvZyBkaWFsb2cgPSBuZXcgVGl0bGVBcmVhRGlhbG9nKFNXVFV0aWwuZ2V0U2hlbGwoKSkgewotCi0JCQlwcml2YXRlIEJ1dHRvbiBidXR0b247Ci0JCQlwcml2YXRlIExhYmVsIGxhYmVsOwotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDb250cm9sIGNyZWF0ZURpYWxvZ0FyZWEoQ29tcG9zaXRlIHBhcmVudCkgewotCi0JCQkJQ29tcG9zaXRlIHBhbmUgPSBuZXcgQ29tcG9zaXRlKHBhcmVudCwgU1dULk5VTEwpOwotCQkJCXBhbmUuc2V0TGF5b3V0KG5ldyBHcmlkTGF5b3V0KDMsIGZhbHNlKSk7Ci0JCQkJcGFuZS5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5GSUxMX0hPUklaT05UQUwpKTsKLQotCQkJCWxhYmVsID0gbmV3IExhYmVsKHBhbmUsIFNXVC5OVUxMKTsKLQkJCQlsYWJlbC5zZXRUZXh0KCJUaGlzIGlzIGEgQ29udHJvbEFsaWduZXIiKTsKLQkJCQl1cGRhdGVHcmlkRGF0YShsYWJlbCk7Ci0KLQkJCQljb250cm9sQWxpZ25lci5hZGQobGFiZWwpOwotCi0JCQkJYnV0dG9uID0gbmV3IEJ1dHRvbihwYW5lLCBTV1QuTlVMTCk7Ci0JCQkJYnV0dG9uLnNldFRleHQoIlNob3J0IHRleHQiKTsKLQkJCQl1cGRhdGVHcmlkRGF0YShidXR0b24pOwotCi0JCQkJY29udHJvbEFsaWduZXIuYWRkKGJ1dHRvbik7Ci0KLQkJCQlyZXR1cm4gcGFyZW50OwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemVCb3VuZHMoKSB7Ci0JCQkJc3VwZXIuaW5pdGlhbGl6ZUJvdW5kcygpOwotCQkJCXNpemVzWzBdID0gbGFiZWwuZ2V0U2l6ZSgpLng7Ci0JCQkJc2l6ZXNbMV0gPSBidXR0b24uZ2V0U2l6ZSgpLng7Ci0JCQkJbWF4aW11bVdpZHRoWzBdID0gY29udHJvbEFsaWduZXIuZ2V0TWF4aW11bVdpZHRoKCk7Ci0JCQl9Ci0JCX07Ci0KLQkJZGlhbG9nLmNyZWF0ZSgpOwotCQlkaWFsb2cuY2xvc2UoKTsKLQotCQlpbnQgbGFiZWxTaXplICA9IHNpemVzWzBdOwotCQlpbnQgYnV0dG9uU2l6ZSA9IHNpemVzWzFdOwotCQlpbnQgbWF4ID0gTWF0aC5tYXgobGFiZWxTaXplLCBidXR0b25TaXplKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHdpZHRoIHNob3VsZCBiZSAiICsgbWF4ICsgIiwiLAotCQkJbWF4LAotCQkJbWF4aW11bVdpZHRoWzBdCi0JCSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0RGlzcG9zZSgpIHRocm93cyBFeGNlcHRpb24gewotCi0JCUNvbXBvc2l0ZSBwYW5lID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OVUxMKTsKLQkJcGFuZS5zZXRMYXlvdXQobmV3IEdyaWRMYXlvdXQoMywgZmFsc2UpKTsKLQkJcGFuZS5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5GSUxMX0hPUklaT05UQUwpKTsKLQotCQlMYWJlbCBsYWJlbCA9IG5ldyBMYWJlbChwYW5lLCBTV1QuTlVMTCk7Ci0JCWxhYmVsLnNldFRleHQoIlRoaXMgaXMgdmVyeSBsb25nIHRleHQiKTsKLQkJdXBkYXRlR3JpZERhdGEobGFiZWwpOwotCi0JCUJ1dHRvbiBidXR0b24gPSBuZXcgQnV0dG9uKHBhbmUsIFNXVC5OVUxMKTsKLQkJYnV0dG9uLnNldFRleHQoIlNob3J0IHRleHQiKTsKLQkJdXBkYXRlR3JpZERhdGEoYnV0dG9uKTsKLQotCQljb250cm9sQWxpZ25lci5hZGQobGFiZWwpOwotCQljb250cm9sQWxpZ25lci5hZGQoYnV0dG9uKTsKLQotCQlQb2ludCBsYWJlbFNpemUgID0gbGFiZWwuZ2V0U2l6ZSgpOwotCQlQb2ludCBidXR0b25TaXplID0gYnV0dG9uLmdldFNpemUoKTsKLQkJaW50IG1heCA9IE1hdGgubWF4KGxhYmVsU2l6ZS54LCBidXR0b25TaXplLngpOwotCi0JCWFzc2VydEVxdWFscygKLQkJCSJUaGUgd2lkdGggc2hvdWxkIGJlICIgKyBtYXggKyAiLCIsCi0JCQltYXgsCi0JCQljb250cm9sQWxpZ25lci5nZXRNYXhpbXVtV2lkdGgoKQotCQkpOwotCi0JCWxhYmVsLmRpc3Bvc2UoKTsKLQotCQlQb2ludCBuZXdCdXR0b25TaXplID0gYnV0dG9uLmdldFNpemUoKTsKLQotCQlhc3NlcnROb3RTYW1lKAotCQkJIlRoZSBvbGQgbWF4IGFuZCBuZXcgbWF4IHNob3VsZCBub3QgYmUgdGhlIHNhbWUiLAotCQkJbWF4LAotCQkJbmV3QnV0dG9uU2l6ZS54Ci0JCSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSBDb250cm9sQWxpZ25lciBkb2Vzbid0IGhhdmUgdGhlIHJpZ2h0IG1heGltdW0gd2lkdGgiLAotCQkJbmV3QnV0dG9uU2l6ZS54LAotCQkJY29udHJvbEFsaWduZXIuZ2V0TWF4aW11bVdpZHRoKCkKLQkJKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3RIaWVyYXJjaHlPZkNvbnRyb2xBbGlnbmVycygpIHRocm93cyBFeGNlcHRpb24gewotCi0JCS8vIEFsaWduZXIxCi0JCS8vICBeCi0JCS8vICB8LUFsaWduZXIyCi0JCS8vICAgICBeCi0JCS8vICAgICB8LUFsaWduZXIzCi0JCUNvbnRyb2xBbGlnbmVyIGNvbnRyb2xBbGlnbmVyMiA9IG5ldyBDb250cm9sQWxpZ25lcigpOwotCQljb250cm9sQWxpZ25lci5hZGQoY29udHJvbEFsaWduZXIyKTsKLQotCQlDb250cm9sQWxpZ25lciBjb250cm9sQWxpZ25lcjMgPSBuZXcgQ29udHJvbEFsaWduZXIoKTsKLQkJY29udHJvbEFsaWduZXIyLmFkZChjb250cm9sQWxpZ25lcjMpOwotCi0JCS8vIFRlc3QgMQotCQlMYWJlbCBsYWJlbDEgPSBuZXcgTGFiZWwocGFyZW50LCBTV1QuTlVMTCk7Ci0JCWxhYmVsMS5zZXRUZXh0KCJUaGlzIGlzIGEgbGFiZWwgd2lkZ2V0Iik7Ci0JCXBhcmVudC5sYXlvdXQodHJ1ZSwgdHJ1ZSk7Ci0KLQkJaW50IGxhYmVsV2lkdGgxID0gbGFiZWwxLmdldFNpemUoKS54OwotCQljb250cm9sQWxpZ25lcjMuYWRkKGxhYmVsMSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKGNvbnRyb2xBbGlnbmVyMy5nZXRNYXhpbXVtV2lkdGgoKSwgbGFiZWxXaWR0aDEpOwotCQlhc3NlcnRFcXVhbHMoY29udHJvbEFsaWduZXIyLmdldE1heGltdW1XaWR0aCgpLCBsYWJlbFdpZHRoMSk7Ci0JCWFzc2VydEVxdWFscyhjb250cm9sQWxpZ25lci5nZXRNYXhpbXVtV2lkdGgoKSwgbGFiZWxXaWR0aDEpOwotCi0JCS8vIFRlc3QgMgotCQlMYWJlbCBsYWJlbDIgPSBuZXcgTGFiZWwocGFyZW50LCBTV1QuTlVMTCk7Ci0JCWxhYmVsMi5zZXRUZXh0KCJTaG9ydExhYmVsIik7Ci0JCWNvbnRyb2xBbGlnbmVyMi5hZGQobGFiZWwyKTsKLQkJcGFyZW50LmxheW91dCh0cnVlKTsKLQotCQlpbnQgbmV3TGFiZWxXaWR0aDEgPSBsYWJlbDEuZ2V0U2l6ZSgpLng7Ci0JCWludCBuZXdMYWJlbFdpZHRoMiA9IGxhYmVsMi5nZXRTaXplKCkueDsKLQotCQlhc3NlcnRFcXVhbHMoY29udHJvbEFsaWduZXIzLmdldE1heGltdW1XaWR0aCgpLCBjb250cm9sQWxpZ25lcjIuZ2V0TWF4aW11bVdpZHRoKCkpOwotCQlhc3NlcnRFcXVhbHMoY29udHJvbEFsaWduZXIyLmdldE1heGltdW1XaWR0aCgpLCBjb250cm9sQWxpZ25lci5nZXRNYXhpbXVtV2lkdGgoKSk7Ci0JCWFzc2VydEVxdWFscyhuZXdMYWJlbFdpZHRoMSwgbmV3TGFiZWxXaWR0aDIpOwotCQlhc3NlcnRFcXVhbHMobmV3TGFiZWxXaWR0aDEsIGNvbnRyb2xBbGlnbmVyLmdldE1heGltdW1XaWR0aCgpKTsKLQotCQkvLyBUZXN0IDMKLQkJTGFiZWwgbGFiZWwzID0gbmV3IExhYmVsKHBhcmVudCwgU1dULk5VTEwpOwotCQlsYWJlbDMuc2V0VGV4dCgiQSB2ZXJ5IGxvbmcgbGFiZWwgdGhhdCB0YWtlcyBhIGxvdCBvZiBob3Jpem9udGFsIHNwYWNlIik7Ci0vLwkJcGFyZW50LmxheW91dCh0cnVlKTsKLQkJY29udHJvbEFsaWduZXIuYWRkKGxhYmVsMyk7Ci0KLQkJbmV3TGFiZWxXaWR0aDEgPSBsYWJlbDEuZ2V0U2l6ZSgpLng7Ci0JCW5ld0xhYmVsV2lkdGgyID0gbGFiZWwyLmdldFNpemUoKS54OwotCQlpbnQgbmV3TGFiZWxXaWR0aDMgPSBsYWJlbDMuZ2V0U2l6ZSgpLng7Ci0KLQkJYXNzZXJ0RXF1YWxzKGNvbnRyb2xBbGlnbmVyMy5nZXRNYXhpbXVtV2lkdGgoKSwgY29udHJvbEFsaWduZXIyLmdldE1heGltdW1XaWR0aCgpKTsKLQkJYXNzZXJ0RXF1YWxzKGNvbnRyb2xBbGlnbmVyMi5nZXRNYXhpbXVtV2lkdGgoKSwgY29udHJvbEFsaWduZXIuZ2V0TWF4aW11bVdpZHRoKCkpOwotCQlhc3NlcnRFcXVhbHMobmV3TGFiZWxXaWR0aDEsIG5ld0xhYmVsV2lkdGgyKTsKLQkJYXNzZXJ0RXF1YWxzKG5ld0xhYmVsV2lkdGgyLCBuZXdMYWJlbFdpZHRoMyk7Ci0JCWFzc2VydEVxdWFscyhuZXdMYWJlbFdpZHRoMSwgY29udHJvbEFsaWduZXIuZ2V0TWF4aW11bVdpZHRoKCkpOwotCi0JCS8vIE1ha2Ugc3VyZSBhbGwgdGhlIGxvY2tlZCBhcmUgcmVtb3ZlZAotCQlhc3NlcnRFcXVhbHMoQ2xhc3NUb29scy5hdHRlbXB0VG9HZXRGaWVsZFZhbHVlKGNvbnRyb2xBbGlnbmVyLCAibG9ja2VkIiksIEJvb2xlYW4uRkFMU0UpOwotCQlhc3NlcnRFcXVhbHMoQ2xhc3NUb29scy5hdHRlbXB0VG9HZXRGaWVsZFZhbHVlKGNvbnRyb2xBbGlnbmVyMiwgImxvY2tlZCIpLCBCb29sZWFuLkZBTFNFKTsKLQkJYXNzZXJ0RXF1YWxzKENsYXNzVG9vbHMuYXR0ZW1wdFRvR2V0RmllbGRWYWx1ZShjb250cm9sQWxpZ25lcjMsICJsb2NrZWQiKSwgQm9vbGVhbi5GQUxTRSk7Ci0KLQkJLy8gQ2hhbmdlIHRoZSB0ZXh0IG9mIGxhYmVsMgotCQlsYWJlbDIuc2V0VGV4dCgibW0iKTsKLS8vCQlwYXJlbnQubGF5b3V0KHRydWUpOwotCi0JCW5ld0xhYmVsV2lkdGgxID0gbGFiZWwxLmdldFNpemUoKS54OwotCQluZXdMYWJlbFdpZHRoMiA9IGxhYmVsMi5nZXRTaXplKCkueDsKLQkJbmV3TGFiZWxXaWR0aDMgPSBsYWJlbDMuZ2V0U2l6ZSgpLng7Ci0KLQkJYXNzZXJ0RXF1YWxzKGNvbnRyb2xBbGlnbmVyMy5nZXRNYXhpbXVtV2lkdGgoKSwgY29udHJvbEFsaWduZXIyLmdldE1heGltdW1XaWR0aCgpKTsKLQkJYXNzZXJ0RXF1YWxzKGNvbnRyb2xBbGlnbmVyMi5nZXRNYXhpbXVtV2lkdGgoKSwgY29udHJvbEFsaWduZXIuZ2V0TWF4aW11bVdpZHRoKCkpOwotCQlhc3NlcnRFcXVhbHMobmV3TGFiZWxXaWR0aDEsIG5ld0xhYmVsV2lkdGgyKTsKLQkJYXNzZXJ0RXF1YWxzKG5ld0xhYmVsV2lkdGgyLCBuZXdMYWJlbFdpZHRoMyk7Ci0JCWFzc2VydEVxdWFscyhuZXdMYWJlbFdpZHRoMSwgY29udHJvbEFsaWduZXIuZ2V0TWF4aW11bVdpZHRoKCkpOwotCi0JCWFzc2VydEVxdWFscyhDbGFzc1Rvb2xzLmF0dGVtcHRUb0dldEZpZWxkVmFsdWUoY29udHJvbEFsaWduZXIsICJsb2NrZWQiKSwgQm9vbGVhbi5GQUxTRSk7Ci0JCWFzc2VydEVxdWFscyhDbGFzc1Rvb2xzLmF0dGVtcHRUb0dldEZpZWxkVmFsdWUoY29udHJvbEFsaWduZXIyLCAibG9ja2VkIiksIEJvb2xlYW4uRkFMU0UpOwotCQlhc3NlcnRFcXVhbHMoQ2xhc3NUb29scy5hdHRlbXB0VG9HZXRGaWVsZFZhbHVlKGNvbnRyb2xBbGlnbmVyMywgImxvY2tlZCIpLCBCb29sZWFuLkZBTFNFKTsKLQotCQkvLyBDaGFuZ2UgdGhlIHRleHQgb2YgbGFiZWwxCi0JCWxhYmVsMS5zZXRUZXh0KCJhIik7Ci0vLwkJcGFyZW50LmxheW91dCh0cnVlKTsKLQotCQlDb21wb3NpdGUgcGFyZW50MSA9IG5ldyBDb21wb3NpdGUoU1dUVXRpbC5nZXRTaGVsbCgpLCBTV1QuTlVMTCk7Ci0JCXBhcmVudDEuc2V0TGF5b3V0KG5ldyBHcmlkTGF5b3V0KCkpOwotCi0JCUxhYmVsIHRlbXBMYWJlbCA9IG5ldyBMYWJlbChwYXJlbnQxLCBTV1QuTlVMTCk7Ci0JCXRlbXBMYWJlbC5zZXRUZXh0KCJhIik7Ci0vLwkJcGFyZW50MS5sYXlvdXQodHJ1ZSk7Ci0KLQkJaW50IHJlYWxXaWR0aCA9IHRlbXBMYWJlbC5nZXRTaXplKCkueDsKLQotCQluZXdMYWJlbFdpZHRoMSA9IGxhYmVsMS5nZXRTaXplKCkueDsKLQkJbmV3TGFiZWxXaWR0aDIgPSBsYWJlbDIuZ2V0U2l6ZSgpLng7Ci0JCW5ld0xhYmVsV2lkdGgzID0gbGFiZWwzLmdldFNpemUoKS54OwotCi0JCWFzc2VydEVxdWFscyhjb250cm9sQWxpZ25lcjMuZ2V0TWF4aW11bVdpZHRoKCksIGNvbnRyb2xBbGlnbmVyMi5nZXRNYXhpbXVtV2lkdGgoKSk7Ci0JCWFzc2VydEVxdWFscyhjb250cm9sQWxpZ25lcjIuZ2V0TWF4aW11bVdpZHRoKCksIGNvbnRyb2xBbGlnbmVyLmdldE1heGltdW1XaWR0aCgpKTsKLQkJYXNzZXJ0RXF1YWxzKG5ld0xhYmVsV2lkdGgxLCBuZXdMYWJlbFdpZHRoMik7Ci0JCWFzc2VydEVxdWFscyhuZXdMYWJlbFdpZHRoMiwgbmV3TGFiZWxXaWR0aDMpOwotCQlhc3NlcnRFcXVhbHMobmV3TGFiZWxXaWR0aDEsIGNvbnRyb2xBbGlnbmVyLmdldE1heGltdW1XaWR0aCgpKTsKLQkJYXNzZXJ0RmFsc2UobmV3TGFiZWxXaWR0aDEgPT0gcmVhbFdpZHRoKTsKLQotCQlhc3NlcnRFcXVhbHMoQ2xhc3NUb29scy5hdHRlbXB0VG9HZXRGaWVsZFZhbHVlKGNvbnRyb2xBbGlnbmVyLCAibG9ja2VkIiksIEJvb2xlYW4uRkFMU0UpOwotCQlhc3NlcnRFcXVhbHMoQ2xhc3NUb29scy5hdHRlbXB0VG9HZXRGaWVsZFZhbHVlKGNvbnRyb2xBbGlnbmVyMiwgImxvY2tlZCIpLCBCb29sZWFuLkZBTFNFKTsKLQkJYXNzZXJ0RXF1YWxzKENsYXNzVG9vbHMuYXR0ZW1wdFRvR2V0RmllbGRWYWx1ZShjb250cm9sQWxpZ25lcjMsICJsb2NrZWQiKSwgQm9vbGVhbi5GQUxTRSk7Ci0KLQkJLy8gQ2hhbmdlIHRoZSB0ZXh0IG9mIGxhYmVsMQotCQlsYWJlbDEuc2V0VGV4dCgiWWVzIGFub3RoZXIgYmlnIGxvbmcgbG9uZyB0ZXh0IHNvIHRoYXQgYWxsIHRoZSBsYWJlbHMgd2lsbCBoYXZlIHRvIHRha2UgdGhlIHNpemUgb2YgdGhpcyBsYWJlbCB0byBtYWtlIHN1cmUgQ29udHJvbEFsaWduZXIgd29ya3MgY29ycmVjdGx5Iik7Ci0vLwkJcGFyZW50LmxheW91dCh0cnVlKTsKLQotCQkvLyBXZWlyZDogSXQgc2VlbXMgbm8gbm90aWZpY2F0aW9uIGlzIHNlbnQsIGZpcmUgb25lIG1hbnVhbGx5Ci0JCUV2ZW50IGV2ZW50ICA9IG5ldyBFdmVudCgpOwotCQlldmVudC53aWRnZXQgPSBsYWJlbDE7Ci0JCWV2ZW50LnR5cGUgICA9IFNXVC5SZXNpemU7Ci0JCWxhYmVsMS5ub3RpZnlMaXN0ZW5lcnMoU1dULlJlc2l6ZSwgZXZlbnQpOwotCi0JCUNvbXBvc2l0ZSBwYXJlbnQyID0gbmV3IENvbXBvc2l0ZShTV1RVdGlsLmdldFNoZWxsKCksIFNXVC5OVUxMKTsKLQkJcGFyZW50Mi5zZXRMYXlvdXQobmV3IEdyaWRMYXlvdXQoKSk7Ci0KLQkJdGVtcExhYmVsID0gbmV3IExhYmVsKHBhcmVudDIsIFNXVC5OVUxMKTsKLQkJdGVtcExhYmVsLnNldFRleHQobGFiZWwxLmdldFRleHQoKSk7Ci0JCXBhcmVudDIubGF5b3V0KHRydWUpOwotCi0JCXJlYWxXaWR0aCA9IHRlbXBMYWJlbC5nZXRTaXplKCkueDsKLQotCQluZXdMYWJlbFdpZHRoMSA9IGxhYmVsMS5nZXRTaXplKCkueDsKLQkJbmV3TGFiZWxXaWR0aDIgPSBsYWJlbDIuZ2V0U2l6ZSgpLng7Ci0JCW5ld0xhYmVsV2lkdGgzID0gbGFiZWwzLmdldFNpemUoKS54OwotCi0JCWFzc2VydEVxdWFscyhjb250cm9sQWxpZ25lcjMuZ2V0TWF4aW11bVdpZHRoKCksIGNvbnRyb2xBbGlnbmVyMi5nZXRNYXhpbXVtV2lkdGgoKSk7Ci0JCWFzc2VydEVxdWFscyhjb250cm9sQWxpZ25lcjIuZ2V0TWF4aW11bVdpZHRoKCksIGNvbnRyb2xBbGlnbmVyLmdldE1heGltdW1XaWR0aCgpKTsKLQkJYXNzZXJ0RXF1YWxzKG5ld0xhYmVsV2lkdGgxLCBuZXdMYWJlbFdpZHRoMik7Ci0JCWFzc2VydEVxdWFscyhuZXdMYWJlbFdpZHRoMiwgbmV3TGFiZWxXaWR0aDMpOwotCQlhc3NlcnRFcXVhbHMoY29udHJvbEFsaWduZXIuZ2V0TWF4aW11bVdpZHRoKCksIG5ld0xhYmVsV2lkdGgxKTsKLQkJYXNzZXJ0RXF1YWxzKHJlYWxXaWR0aCwgbmV3TGFiZWxXaWR0aDEpOwotCi0JCWFzc2VydEVxdWFscyhDbGFzc1Rvb2xzLmF0dGVtcHRUb0dldEZpZWxkVmFsdWUoY29udHJvbEFsaWduZXIsICJsb2NrZWQiKSwgQm9vbGVhbi5GQUxTRSk7Ci0JCWFzc2VydEVxdWFscyhDbGFzc1Rvb2xzLmF0dGVtcHRUb0dldEZpZWxkVmFsdWUoY29udHJvbEFsaWduZXIyLCAibG9ja2VkIiksIEJvb2xlYW4uRkFMU0UpOwotCQlhc3NlcnRFcXVhbHMoQ2xhc3NUb29scy5hdHRlbXB0VG9HZXRGaWVsZFZhbHVlKGNvbnRyb2xBbGlnbmVyMywgImxvY2tlZCIpLCBCb29sZWFuLkZBTFNFKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVDb250cm9sMSgpIHRocm93cyBFeGNlcHRpb24gewotCi0JCUNvbXBvc2l0ZSBwYW5lID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OVUxMKTsKLQkJcGFuZS5zZXRMYXlvdXQobmV3IEdyaWRMYXlvdXQoMywgZmFsc2UpKTsKLQkJcGFuZS5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5GSUxMX0hPUklaT05UQUwpKTsKLQotCQlCdXR0b24gYnV0dG9uID0gbmV3IEJ1dHRvbihwYW5lLCBTV1QuTlVMTCk7Ci0JCWJ1dHRvbi5zZXRUZXh0KCJUaGlzIGlzIGEgQ29udHJvbEFsaWduZXIiKTsKLQkJdXBkYXRlR3JpZERhdGEoYnV0dG9uKTsKLQotCQljb250cm9sQWxpZ25lci5hZGQoYnV0dG9uKTsKLQkJcGFyZW50LmxheW91dCh0cnVlLCB0cnVlKTsKLQotCQlQb2ludCBzaXplID0gYnV0dG9uLmdldFNpemUoKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHdpZHRoIHNob3VsZCBiZSAiICsgc2l6ZS54ICsgIiwiLAotCQkJc2l6ZS54LAotCQkJY29udHJvbEFsaWduZXIuZ2V0TWF4aW11bVdpZHRoKCkKLQkJKTsKLQotCQljb250cm9sQWxpZ25lci5yZW1vdmUoYnV0dG9uKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHdpZHRoIHNob3VsZCBiZSAwLCAiLAotCQkJMCwKLQkJCWNvbnRyb2xBbGlnbmVyLmdldE1heGltdW1XaWR0aCgpCi0JCSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQ29udHJvbDIoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQlDb21wb3NpdGUgcGFuZSA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTlVMTCk7Ci0JCXBhbmUuc2V0TGF5b3V0KG5ldyBHcmlkTGF5b3V0KDMsIGZhbHNlKSk7Ci0JCXBhbmUuc2V0TGF5b3V0RGF0YShuZXcgR3JpZERhdGEoR3JpZERhdGEuRklMTF9IT1JJWk9OVEFMKSk7Ci0KLQkJTGFiZWwgbGFiZWwgPSBuZXcgTGFiZWwocGFuZSwgU1dULk5VTEwpOwotCQlsYWJlbC5zZXRUZXh0KCJUaGlzIGlzIHZlcnkgbG9uZyB0ZXh0Iik7Ci0JCXVwZGF0ZUdyaWREYXRhKGxhYmVsKTsKLQotCQlCdXR0b24gYnV0dG9uID0gbmV3IEJ1dHRvbihwYW5lLCBTV1QuTlVMTCk7Ci0JCWJ1dHRvbi5zZXRUZXh0KCJTaG9ydCB0ZXh0Iik7Ci0JCXVwZGF0ZUdyaWREYXRhKGJ1dHRvbik7Ci0vLwkJcGFyZW50LmxheW91dCh0cnVlLCB0cnVlKTsKLQotCQljb250cm9sQWxpZ25lci5hZGQobGFiZWwpOwotCQljb250cm9sQWxpZ25lci5hZGQoYnV0dG9uKTsKLQotCQlQb2ludCBsYWJlbFNpemUgID0gbGFiZWwuZ2V0U2l6ZSgpOwotCQlQb2ludCBidXR0b25TaXplID0gYnV0dG9uLmdldFNpemUoKTsKLQkJaW50IG1heCA9IE1hdGgubWF4KGxhYmVsU2l6ZS54LCBidXR0b25TaXplLngpOwotCi0JCWFzc2VydEVxdWFscygKLQkJCSJUaGUgd2lkdGggc2hvdWxkIGJlICIgKyBtYXggKyAiLCIsCi0JCQltYXgsCi0JCQljb250cm9sQWxpZ25lci5nZXRNYXhpbXVtV2lkdGgoKQotCQkpOwotCi0JCWNvbnRyb2xBbGlnbmVyLnJlbW92ZShsYWJlbCk7Ci0KLQkJUG9pbnQgbmV3QnV0dG9uU2l6ZSA9IGJ1dHRvbi5nZXRTaXplKCk7Ci0KLQkJYXNzZXJ0Tm90U2FtZSgKLQkJCSJUaGUgb2xkIG1heCBhbmQgbmV3IG1heCBzaG91bGQgbm90IGJlIHRoZSBzYW1lIiwKLQkJCW1heCwKLQkJCW5ld0J1dHRvblNpemUueAotCQkpOwotCi0JCWFzc2VydEVxdWFscygKLQkJCSJUaGUgQ29udHJvbEFsaWduZXIgZG9lc24ndCBoYXZlIHRoZSByaWdodCBtYXhpbXVtIHdpZHRoIiwKLQkJCW5ld0J1dHRvblNpemUueCwKLQkJCWNvbnRyb2xBbGlnbmVyLmdldE1heGltdW1XaWR0aCgpCi0JCSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQ29udHJvbDQoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQotCQlDb21wb3NpdGUgcGFuZSA9IG5ldyBDb21wb3NpdGUocGFyZW50LCBTV1QuTlVMTCk7Ci0JCXBhbmUuc2V0TGF5b3V0KG5ldyBHcmlkTGF5b3V0KDMsIGZhbHNlKSk7Ci0JCXBhbmUuc2V0TGF5b3V0RGF0YShuZXcgR3JpZERhdGEoR3JpZERhdGEuRklMTF9IT1JJWk9OVEFMKSk7Ci0KLQkJLy8gV2lkZ2V0IDEKLQkJTGFiZWwgbGFiZWwgPSBuZXcgTGFiZWwocGFuZSwgU1dULk5VTEwpOwotCQlsYWJlbC5zZXRUZXh0KCJUaGlzIGlzIHZlcnkgbG9uZyB0ZXh0Iik7Ci0JCXVwZGF0ZUdyaWREYXRhKGxhYmVsKTsKLQkJY29udHJvbEFsaWduZXIuYWRkKGxhYmVsKTsKLQotCQkvLyBXaWRnZXQgMgotCQlDb21wb3NpdGUgc3BhY2VyID0gbmV3IENvbXBvc2l0ZShwYW5lLCBTV1QuTlVMTCk7Ci0JCXNwYWNlci5zZXRMYXlvdXQoYnVpbGRTcGFjZXJMYXlvdXQoKSk7Ci0JCXVwZGF0ZUdyaWREYXRhKHNwYWNlcik7Ci0JCWNvbnRyb2xBbGlnbmVyLmFkZChzcGFjZXIpOwotCi0JCS8vIFdpZGdldCAzCi0JCUJ1dHRvbiBidXR0b24gPSBuZXcgQnV0dG9uKHBhbmUsIFNXVC5OVUxMKTsKLQkJYnV0dG9uLnNldFRleHQoIlNob3J0IHRleHQiKTsKLQkJdXBkYXRlR3JpZERhdGEoYnV0dG9uKTsKLQkJY29udHJvbEFsaWduZXIuYWRkKGJ1dHRvbik7Ci0KLS8vCQlwYXJlbnQubGF5b3V0KHRydWUsIHRydWUpOwotCi0JCS8vIE1ha2Ugc3VyZSB0aGUgMyB3aWRnZXRzIGhhdmUgdGhlIHNhbWUgd2lkdGgKLQkJUG9pbnQgbGFiZWxTaXplICA9IGxhYmVsLmdldFNpemUoKTsKLQkJUG9pbnQgc3BhY2VyU2l6ZSA9IHNwYWNlci5nZXRTaXplKCk7Ci0JCVBvaW50IGJ1dHRvblNpemUgPSBidXR0b24uZ2V0U2l6ZSgpOwotCQlpbnQgbWF4ID0gTWF0aC5tYXgobGFiZWxTaXplLngsIGJ1dHRvblNpemUueCk7Ci0JCW1heCA9IE1hdGgubWF4KG1heCwgc3BhY2VyU2l6ZS54KTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHdpZHRoIHNob3VsZCBiZSAiICsgbWF4ICsgIiwiLAotCQkJbWF4LAotCQkJY29udHJvbEFsaWduZXIuZ2V0TWF4aW11bVdpZHRoKCkKLQkJKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHNwYWNlcidzIHdpZHRoIHNob3VsZCBiZSAiICsgbWF4ICsgIiwiLAotCQkJbWF4LAotCQkJc3BhY2VyU2l6ZS54Ci0JCSk7Ci0KLQkJLy8gUmVtb3ZlIHRoZSBsYWJlbCAodGhlIHdpZGVzdCB3aWRnZXQpIGFuZCBtYWtlIHN1cmUgdGhlIHdpZHRoIHdhcwotCQkvLyBjb3JyZWN0bHkgY2FsY3VsYXRlZAotCQljb250cm9sQWxpZ25lci5yZW1vdmUobGFiZWwpOwotCi0JCXNwYWNlclNpemUgPSBzcGFjZXIuZ2V0U2l6ZSgpOwotCQlidXR0b25TaXplID0gYnV0dG9uLmdldFNpemUoKTsKLQkJaW50IG1heDIgPSBNYXRoLm1heChzcGFjZXJTaXplLngsIGJ1dHRvblNpemUueCk7Ci0KLQkJYXNzZXJ0Tm90U2FtZSgKLQkJCSJUaGUgb2xkIG1heCBhbmQgbmV3IG1heCBzaG91bGQgbm90IGJlIHRoZSBzYW1lIiwKLQkJCW1heCwKLQkJCW1heDIKLQkJKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIENvbnRyb2xBbGlnbmVyIGRvZXNuJ3QgaGF2ZSB0aGUgcmlnaHQgbWF4aW11bSB3aWR0aCIsCi0JCQltYXgyLAotCQkJY29udHJvbEFsaWduZXIuZ2V0TWF4aW11bVdpZHRoKCkKLQkJKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHNwYWNlcidzIHdpZHRoIHNob3VsZCBoYXZlIGJlZW4gYWRqdXN0ZWQiLAotCQkJbWF4MiwKLQkJCXNwYWNlclNpemUueAotCQkpOwotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUNvbnRyb2xBbGlnbmVyMSgpIHRocm93cyBFeGNlcHRpb24gewotCi0JCUxhYmVsIGxhYmVsMSA9IG5ldyBMYWJlbChwYXJlbnQsIFNXVC5OVUxMKTsKLQkJTGFiZWwgbGFiZWwyID0gbmV3IExhYmVsKHBhcmVudCwgU1dULk5VTEwpOwotCi0JCXVwZGF0ZUdyaWREYXRhKGxhYmVsMSk7Ci0JCXVwZGF0ZUdyaWREYXRhKGxhYmVsMik7Ci0KLQkJY29udHJvbEFsaWduZXIuYWRkKGxhYmVsMSk7Ci0KLQkJQ29udHJvbEFsaWduZXIgY29udHJvbEFsaWduZXIyID0gbmV3IENvbnRyb2xBbGlnbmVyKCk7Ci0JCWNvbnRyb2xBbGlnbmVyLmFkZChjb250cm9sQWxpZ25lcjIpOwotCQljb250cm9sQWxpZ25lcjIuYWRkKGxhYmVsMik7Ci0KLQkJbGFiZWwxLnNldFRleHQoIlRoaXMgaXMgYSBDb250cm9sQWxpZ25lciIpOwotCQlsYWJlbDIuc2V0VGV4dCgiVGhpcyBpcyBhIHZlcnkgbG9uZyBDb250cm9sQWxpZ25lciIpOwotLy8JCXBhcmVudC5sYXlvdXQodHJ1ZSwgdHJ1ZSk7Ci0KLQkJUG9pbnQgc2l6ZTEgPSBsYWJlbDEuZ2V0U2l6ZSgpOwotCQlQb2ludCBzaXplMiA9IGxhYmVsMi5nZXRTaXplKCk7Ci0JCWludCB3aWR0aCA9IE1hdGgubWF4KHNpemUxLngsIHNpemUyLngpOwotCi0JCS8vIFRlc3QgMQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHdpZHRoIHNob3VsZCBiZSAiICsgd2lkdGggKyAiLCIsCi0JCQl3aWR0aCwKLQkJCWNvbnRyb2xBbGlnbmVyLmdldE1heGltdW1XaWR0aCgpCi0JCSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSB3aWR0aCBzaG91bGQgYmUgIiArIHdpZHRoICsgIiwiLAotCQkJd2lkdGgsCi0JCQljb250cm9sQWxpZ25lcjIuZ2V0TWF4aW11bVdpZHRoKCkKLQkJKTsKLQotCQkvLyBUZXN0IDIKLQkJY29udHJvbEFsaWduZXIucmVtb3ZlKGxhYmVsMSk7Ci0KLQkJd2lkdGggPSBsYWJlbDIuZ2V0U2l6ZSgpLng7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSB3aWR0aCBzaG91bGQgYmUgIiArIHdpZHRoICsgIiwiLAotCQkJd2lkdGgsCi0JCQljb250cm9sQWxpZ25lci5nZXRNYXhpbXVtV2lkdGgoKQotCQkpOwotCi0JCWFzc2VydEVxdWFscygKLQkJCSJUaGUgd2lkdGggc2hvdWxkIGJlICIgKyB3aWR0aCArICIsIiwKLQkJCXdpZHRoLAotCQkJY29udHJvbEFsaWduZXIyLmdldE1heGltdW1XaWR0aCgpCi0JCSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQ29udHJvbEFsaWduZXIyKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0KLQkJTGFiZWwgbGFiZWwxID0gbmV3IExhYmVsKHBhcmVudCwgU1dULk5VTEwpOwotCQlMYWJlbCBsYWJlbDIgPSBuZXcgTGFiZWwocGFyZW50LCBTV1QuTlVMTCk7Ci0KLQkJdXBkYXRlR3JpZERhdGEobGFiZWwxKTsKLQkJdXBkYXRlR3JpZERhdGEobGFiZWwyKTsKLQotCQljb250cm9sQWxpZ25lci5hZGQobGFiZWwxKTsKLQotCQlDb250cm9sQWxpZ25lciBjb250cm9sQWxpZ25lcjIgPSBuZXcgQ29udHJvbEFsaWduZXIoKTsKLQkJY29udHJvbEFsaWduZXIuYWRkKGNvbnRyb2xBbGlnbmVyMik7Ci0JCWNvbnRyb2xBbGlnbmVyMi5hZGQobGFiZWwyKTsKLQotCQlsYWJlbDEuc2V0VGV4dCgiVGhpcyBpcyBhIENvbnRyb2xBbGlnbmVyIik7Ci0JCWxhYmVsMi5zZXRUZXh0KCJUaGlzIGlzIGEgdmVyeSBsb25nIENvbnRyb2xBbGlnbmVyIik7Ci0vLwkJcGFyZW50LmxheW91dCh0cnVlLCB0cnVlKTsKLQotCQlQb2ludCBzaXplMSA9IGxhYmVsMS5nZXRTaXplKCk7Ci0JCVBvaW50IHNpemUyID0gbGFiZWwyLmdldFNpemUoKTsKLQkJaW50IHdpZHRoID0gTWF0aC5tYXgoc2l6ZTEueCwgc2l6ZTIueCk7Ci0KLQkJLy8gVGVzdCAxCi0JCWFzc2VydEVxdWFscygKLQkJCSJUaGUgd2lkdGggc2hvdWxkIGJlICIgKyB3aWR0aCArICIsIiwKLQkJCXdpZHRoLAotCQkJY29udHJvbEFsaWduZXIuZ2V0TWF4aW11bVdpZHRoKCkKLQkJKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHdpZHRoIHNob3VsZCBiZSAiICsgd2lkdGggKyAiLCIsCi0JCQl3aWR0aCwKLQkJCWNvbnRyb2xBbGlnbmVyMi5nZXRNYXhpbXVtV2lkdGgoKQotCQkpOwotCi0JCS8vIFRlc3QgMgotCQljb250cm9sQWxpZ25lcjIucmVtb3ZlKGxhYmVsMik7Ci0KLQkJd2lkdGggPSBsYWJlbDEuZ2V0U2l6ZSgpLng7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSB3aWR0aCBzaG91bGQgYmUgIiArIHdpZHRoICsgIiwiLAotCQkJd2lkdGgsCi0JCQljb250cm9sQWxpZ25lci5nZXRNYXhpbXVtV2lkdGgoKQotCQkpOwotCi0JCWFzc2VydEVxdWFscygKLQkJCSJUaGUgd2lkdGggc2hvdWxkIGJlICIgKyB3aWR0aCArICIsIiwKLQkJCXdpZHRoLAotCQkJY29udHJvbEFsaWduZXIyLmdldE1heGltdW1XaWR0aCgpCi0JCSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHVwZGF0ZUdyaWREYXRhKENvbnRyb2wgY29udHJvbCkgewotCQlHcmlkRGF0YSBkYXRhID0gbmV3IEdyaWREYXRhKCk7Ci0JCWRhdGEuaG9yaXpvbnRhbEFsaWdubWVudCAgICAgICA9IEdyaWREYXRhLkZJTEw7Ci0JCWRhdGEuZ3JhYkV4Y2Vzc0hvcml6b250YWxTcGFjZSA9IGZhbHNlOwotCQljb250cm9sLnNldExheW91dERhdGEoZGF0YSk7Ci0JfQotfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC91dGlsL0NvbnRyb2xFbmFibGVyVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3V0aWwvQ29udHJvbEVuYWJsZXJUZXN0LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDU4ZThlNjcuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3V0aWwvQ29udHJvbEVuYWJsZXJUZXN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw4NCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzLmludGVybmFsLnV0aWw7Ci0KLWltcG9ydCBzdGF0aWMgb3JnLmp1bml0LkFzc2VydC4qOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLkNvbnRyb2xFbmFibGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLlNXVFV0aWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5TV1Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkTGF5b3V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbWJvOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuanVuaXQuQWZ0ZXI7Ci1pbXBvcnQgb3JnLmp1bml0LkJlZm9yZTsKLWltcG9ydCBvcmcuanVuaXQuVGVzdDsKLQotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgZmluYWwgY2xhc3MgQ29udHJvbEVuYWJsZXJUZXN0IHsKLQlwcml2YXRlIENvbXBvc2l0ZSBwYXJlbnQ7Ci0KLQlAQmVmb3JlCi0JcHVibGljIHZvaWQgc2V0VXAoKSB7Ci0JCXBhcmVudCA9IG5ldyBDb21wb3NpdGUoU1dUVXRpbC5nZXRTaGVsbCgpLCBTV1QuTk9ORSk7Ci0JCXBhcmVudC5zZXRMYXlvdXQobmV3IEdyaWRMYXlvdXQoKSk7Ci0JfQotCi0JQEFmdGVyCi0JcHVibGljIHZvaWQgdGVhckRvd24oKSB7Ci0JCWlmIChwYXJlbnQgIT0gbnVsbCkgewotCQkJcGFyZW50LmRpc3Bvc2UoKTsKLQkJfQotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdFN3aXRjaFN0YXRlKCkgewotCi0JCVNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBib29sZWFuSG9sZGVyID0KLQkJCW5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4odHJ1ZSk7Ci0KLQkJQ29tYm8gY29tYm8gPSBuZXcgQ29tYm8ocGFyZW50LCBTV1QuQk9SREVSKTsKLQotCQluZXcgQ29udHJvbEVuYWJsZXIoYm9vbGVhbkhvbGRlciwgY29tYm8pOwotCi0JCWFzc2VydFRydWUoCi0JCQkiVGhlIENvbWJvIHNob3VsZCBiZSBlbmFibGVkIiwKLQkJCWNvbWJvLmlzRW5hYmxlZCgpCi0JCSk7Ci0KLQkJLy8gQ2hhbmdlIHN0YXRlIChudWxsKQotCQlib29sZWFuSG9sZGVyLnNldFZhbHVlKG51bGwpOwotCi0JCWFzc2VydEZhbHNlKAotCQkJIlRoZSBDb21ibyBzaG91bGQgbm90IGJlIGVuYWJsZWQiLAotCQkJY29tYm8uaXNFbmFibGVkKCkKLQkJKTsKLQotCQkvLyBDaGFuZ2Ugc3RhdGUgKHRydWUpCi0JCWJvb2xlYW5Ib2xkZXIuc2V0VmFsdWUodHJ1ZSk7Ci0KLQkJYXNzZXJ0VHJ1ZSgKLQkJCSJUaGUgQ29tYm8gc2hvdWxkIGJlIGVuYWJsZWQiLAotCQkJY29tYm8uaXNFbmFibGVkKCkKLQkJKTsKLQotCQkvLyBDaGFuZ2Ugc3RhdGUgKGZhbHNlKQotCQlib29sZWFuSG9sZGVyLnNldFZhbHVlKGZhbHNlKTsKLQotCQlhc3NlcnRGYWxzZSgKLQkJCSJUaGUgQ29tYm8gc2hvdWxkIG5vdCBiZSBlbmFibGVkIiwKLQkJCWNvbWJvLmlzRW5hYmxlZCgpCi0JCSk7Ci0KLQkJLy8gRGlzcG9zZQotCQljb21iby5kaXNwb3NlKCk7Ci0JCWJvb2xlYW5Ib2xkZXIuc2V0VmFsdWUodHJ1ZSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3V0aWwvQ29udHJvbFN3aXRjaGVyVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3V0aWwvQ29udHJvbFN3aXRjaGVyVGVzdC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2NThjZTBiLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC91dGlsL0NvbnRyb2xTd2l0Y2hlclRlc3QuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE4NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzLmludGVybmFsLnV0aWw7Ci0KLWltcG9ydCBzdGF0aWMgb3JnLmp1bml0LkFzc2VydC4qOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLkNvbnRyb2xTd2l0Y2hlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwudXRpbC5TV1RVdGlsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuVHJhbnNmb3JtZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5TV1Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLlBvaW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5sYXlvdXQuR3JpZERhdGE7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkTGF5b3V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbWJvOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db250cm9sOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkxhYmVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLlRleHQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UudWkucGFydC5QYWdlQm9vazsKLWltcG9ydCBvcmcuanVuaXQuQWZ0ZXI7Ci1pbXBvcnQgb3JnLmp1bml0LkJlZm9yZTsKLWltcG9ydCBvcmcuanVuaXQuVGVzdDsKLQotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgZmluYWwgY2xhc3MgQ29udHJvbFN3aXRjaGVyVGVzdCB7Ci0KLQlwcml2YXRlIFBhZ2VCb29rIHBhZ2VCb29rOwotCXByaXZhdGUgQ29tcG9zaXRlIHBhbmUxOwotCXByaXZhdGUgQ29tcG9zaXRlIHBhbmUyOwotCXByaXZhdGUgQ29tcG9zaXRlIHBhcmVudDsKLQotCXByaXZhdGUgQ29tcG9zaXRlIGJ1aWxkUGFuZTEoKSB7Ci0KLQkJaWYgKHBhbmUxID09IG51bGwpIHsKLQotCQkJcGFuZTEgPSBuZXcgQ29tcG9zaXRlKHBhZ2VCb29rLCBTV1QuTlVMTCk7Ci0JCQlwYW5lMS5zZXRMYXlvdXQobmV3IEdyaWRMYXlvdXQoMiwgZmFsc2UpKTsKLQotCQkJTGFiZWwgbGFiZWwgPSBuZXcgTGFiZWwocGFuZTEsIFNXVC5OVUxMKTsKLQkJCWxhYmVsLnNldFRleHQoIiZUZXN0MjoiKTsKLQotCQkJVGV4dCB0ZXh0ID0gbmV3IFRleHQocGFuZTEsIFNXVC5CT1JERVIpOwotCQkJdGV4dC5zZXRMYXlvdXREYXRhKG5ldyBHcmlkRGF0YShHcmlkRGF0YS5GSUxMX0hPUklaT05UQUwpKTsKLQotCQkJQ29tYm8gY29tYm8gPSBuZXcgQ29tYm8ocGFuZTEsIFNXVC5CT1JERVIpOwotCi0JCQlHcmlkRGF0YSBkYXRhID0gbmV3IEdyaWREYXRhKEdyaWREYXRhLkZJTExfSE9SSVpPTlRBTCk7Ci0JCQlkYXRhLmhvcml6b250YWxTcGFuID0gMjsKLQkJCWNvbWJvLnNldExheW91dERhdGEoZGF0YSk7Ci0JCX0KLQotCQlyZXR1cm4gcGFuZTE7Ci0JfQotCi0JcHJpdmF0ZSBDb21wb3NpdGUgYnVpbGRQYW5lMigpIHsKLQotCQlpZiAocGFuZTIgPT0gbnVsbCkgewotCi0JCQlwYW5lMiA9IG5ldyBDb21wb3NpdGUocGFnZUJvb2ssIFNXVC5OVUxMKTsKLQkJCXBhbmUyLnNldExheW91dChuZXcgR3JpZExheW91dCgyLCBmYWxzZSkpOwotCi0JCQlMYWJlbCBsYWJlbCA9IG5ldyBMYWJlbChwYW5lMiwgU1dULk5VTEwpOwotCQkJbGFiZWwuc2V0VGV4dCgiJlRlc3QxOiIpOwotCi0JCQlUZXh0IHRleHQgPSBuZXcgVGV4dChwYW5lMiwgU1dULkJPUkRFUik7Ci0JCQl0ZXh0LnNldExheW91dERhdGEobmV3IEdyaWREYXRhKEdyaWREYXRhLkZJTExfSE9SSVpPTlRBTCkpOwotCQl9Ci0KLQkJcmV0dXJuIHBhbmUyOwotCX0KLQotCXByaXZhdGUgVHJhbnNmb3JtZXI8Qm9vbGVhbiwgQ29udHJvbD4gYnVpbGRUcmFuc2Zvcm1lcigpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1lcjxCb29sZWFuLCBDb250cm9sPigpIHsKLQkJCXB1YmxpYyBDb250cm9sIHRyYW5zZm9ybShCb29sZWFuIHZhbHVlKSB7Ci0JCQkJcmV0dXJuICh2YWx1ZSA9PSBudWxsKSA/IG51bGwgOiAodmFsdWUgPyBwYW5lMSA6IHBhbmUyKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAQmVmb3JlCi0JcHVibGljIHZvaWQgc2V0VXAoKSB7Ci0JCXBhcmVudCA9IG5ldyBDb21wb3NpdGUoU1dUVXRpbC5nZXRTaGVsbCgpLCBTV1QuTk9ORSk7Ci0JCXBhcmVudC5zZXRMYXlvdXQobmV3IEdyaWRMYXlvdXQoKSk7Ci0KLQkJcGFnZUJvb2sgPSBuZXcgUGFnZUJvb2socGFyZW50LCBTV1QuTlVMTCk7Ci0JCXBhZ2VCb29rLnNldExheW91dERhdGEobmV3IEdyaWREYXRhKCkpOwotCX0KLQotCUBBZnRlcgotCXB1YmxpYyB2b2lkIHRlYXJEb3duKCkgewotCi0JCWlmIChwYXJlbnQgIT0gbnVsbCkgewotCi0JCQlwYXJlbnQuZGlzcG9zZSgpOwotCi0JCQlwYXJlbnQgICA9IG51bGw7Ci0JCQlwYWdlQm9vayA9IG51bGw7Ci0JCX0KLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3RTd2l0Y2goKSB7Ci0KLQkJU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IHN3aXRjaEhvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4oKTsKLQkJVHJhbnNmb3JtZXI8Qm9vbGVhbiwgQ29udHJvbD4gdHJhbnNmb3JtZXIgPSBidWlsZFRyYW5zZm9ybWVyKCk7Ci0KLQkJcGFuZTEgPSBidWlsZFBhbmUxKCk7Ci0JCXBhbmUxLnNldFZpc2libGUoZmFsc2UpOwotCi0JCXBhbmUyID0gYnVpbGRQYW5lMigpOwotCQlwYW5lMi5zZXRWaXNpYmxlKGZhbHNlKTsKLQotCQluZXcgQ29udHJvbFN3aXRjaGVyKAotCQkJc3dpdGNoSG9sZGVyLAotCQkJdHJhbnNmb3JtZXIsCi0JCQlwYWdlQm9vawotCQkpOwotCi0JCS8vIFRlc3QgMQotCQlzd2l0Y2hIb2xkZXIuc2V0VmFsdWUodHJ1ZSk7Ci0JCUNvbnRyb2wgY29udHJvbCA9IChDb250cm9sKSBDbGFzc1Rvb2xzLmZpZWxkVmFsdWUocGFnZUJvb2ssICJjdXJyZW50UGFnZSIpOwotCi0JCWFzc2VydE5vdE51bGwoCi0JCQkiVGhlIHBhZ2UgYm9vaydzIHBhZ2Ugc2hvdWxkbid0IGJlIG51bGwiLAotCQkJY29udHJvbAotCQkpOwotCi0JCWFzc2VydFNhbWUoCi0JCQkiVGhlIGN1cnJlbnQgcGFuZSBzaG91bGQgYmUgcGFuZTEiLAotCQkJcGFuZTEsCi0JCQljb250cm9sCi0JCSk7Ci0KLQkJUG9pbnQgcGFuZTFTaXplID0gcGFuZTEuY29tcHV0ZVNpemUoU1dULkRFRkFVTFQsIFNXVC5ERUZBVUxUKTsKLQkJUG9pbnQgcGFnZUJvb2tTaXplID0gcGFnZUJvb2suY29tcHV0ZVNpemUoU1dULkRFRkFVTFQsIFNXVC5ERUZBVUxUKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIHdpZHRoIG9mIHRoZSBQYWdlQm9vayBzaG91bGQgYmUgdGhlIHNhbWUgYXMgdGhlIHdpZHRoIG9mIHBhbmUxIiwKLQkJCXBhbmUxU2l6ZS54LAotCQkJcGFnZUJvb2tTaXplLngKLQkJKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIGhlaWdodCBvZiB0aGUgUGFnZUJvb2sgc2hvdWxkIGJlIHRoZSBzYW1lIGFzIHRoZSBoZWlnaHQgb2YgcGFuZTEiLAotCQkJcGFuZTFTaXplLnksCi0JCQlwYWdlQm9va1NpemUueQotCQkpOwotCi0JCS8vIFRlc3QgMgotCQlzd2l0Y2hIb2xkZXIuc2V0VmFsdWUoZmFsc2UpOwotCQljb250cm9sID0gKENvbnRyb2wpIENsYXNzVG9vbHMuZmllbGRWYWx1ZShwYWdlQm9vaywgImN1cnJlbnRQYWdlIik7Ci0KLQkJYXNzZXJ0Tm90TnVsbCgKLQkJCSJUaGUgcGFnZSBib29rJ3MgcGFnZSBzaG91bGRuJ3QgYmUgbnVsbCIsCi0JCQljb250cm9sCi0JCSk7Ci0KLQkJYXNzZXJ0U2FtZSgKLQkJCSJUaGUgY3VycmVudCBwYW5lIHNob3VsZCBiZSBwYW5lMiIsCi0JCQlwYW5lMiwKLQkJCWNvbnRyb2wKLQkJKTsKLQotCQlQb2ludCBwYW5lMlNpemUgPSBwYW5lMi5jb21wdXRlU2l6ZShTV1QuREVGQVVMVCwgU1dULkRFRkFVTFQpOwotCQlwYWdlQm9va1NpemUgPSBwYWdlQm9vay5jb21wdXRlU2l6ZShTV1QuREVGQVVMVCwgU1dULkRFRkFVTFQpOwotCi0JCWFzc2VydEVxdWFscygKLQkJCSJUaGUgd2lkdGggb2YgdGhlIFBhZ2VCb29rIHNob3VsZCBiZSB0aGUgc2FtZSBhcyB0aGUgd2lkdGggb2YgcGFuZTIiLAotCQkJcGFuZTJTaXplLngsCi0JCQlwYWdlQm9va1NpemUueAotCQkpOwotCi0JCWFzc2VydEVxdWFscygKLQkJCSJUaGUgaGVpZ2h0IG9mIHRoZSBQYWdlQm9vayBzaG91bGQgYmUgdGhlIHNhbWUgYXMgdGhlIGhlaWdodCBvZiBwYW5lMiIsCi0JCQlwYW5lMlNpemUueSwKLQkJCXBhZ2VCb29rU2l6ZS55Ci0JCSk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3V0aWwvQ29udHJvbFZpc2liaWxpdHlFbmFibGVyVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3V0aWwvQ29udHJvbFZpc2liaWxpdHlFbmFibGVyVGVzdC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjMGNkMzljLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC91dGlsL0NvbnRyb2xWaXNpYmlsaXR5RW5hYmxlclRlc3QuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDg0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudWkudGVzdHMuaW50ZXJuYWwudXRpbDsKLQotaW1wb3J0IHN0YXRpYyBvcmcuanVuaXQuQXNzZXJ0Lio7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuQ29udHJvbFZpc2liaWxpdHlFbmFibGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLlNXVFV0aWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5TV1Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkTGF5b3V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbWJvOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuanVuaXQuQWZ0ZXI7Ci1pbXBvcnQgb3JnLmp1bml0LkJlZm9yZTsKLWltcG9ydCBvcmcuanVuaXQuVGVzdDsKLQotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgZmluYWwgY2xhc3MgQ29udHJvbFZpc2liaWxpdHlFbmFibGVyVGVzdCB7Ci0JcHJpdmF0ZSBDb21wb3NpdGUgcGFyZW50OwotCi0JQEJlZm9yZQotCXB1YmxpYyB2b2lkIHNldFVwKCkgewotCQlwYXJlbnQgPSBuZXcgQ29tcG9zaXRlKFNXVFV0aWwuZ2V0U2hlbGwoKSwgU1dULk5PTkUpOwotCQlwYXJlbnQuc2V0TGF5b3V0KG5ldyBHcmlkTGF5b3V0KCkpOwotCX0KLQotCUBBZnRlcgotCXB1YmxpYyB2b2lkIHRlYXJEb3duKCkgewotCQlpZiAocGFyZW50ICE9IG51bGwpIHsKLQkJCXBhcmVudC5kaXNwb3NlKCk7Ci0JCX0KLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3RTd2l0Y2hTdGF0ZSgpIHsKLQotCQlTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYm9vbGVhbkhvbGRlciA9Ci0JCQluZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+KHRydWUpOwotCi0JCUNvbWJvIGNvbWJvID0gbmV3IENvbWJvKHBhcmVudCwgU1dULkJPUkRFUik7Ci0KLQkJbmV3IENvbnRyb2xWaXNpYmlsaXR5RW5hYmxlcihib29sZWFuSG9sZGVyLCBjb21ibyk7Ci0KLQkJYXNzZXJ0VHJ1ZSgKLQkJCSJUaGUgQ29tYm8gc2hvdWxkIGJlIHZpc2libGUiLAotCQkJY29tYm8uaXNWaXNpYmxlKCkKLQkJKTsKLQotCQkvLyBDaGFuZ2Ugc3RhdGUgKG51bGwpCi0JCWJvb2xlYW5Ib2xkZXIuc2V0VmFsdWUobnVsbCk7Ci0KLQkJYXNzZXJ0RmFsc2UoCi0JCQkiVGhlIENvbWJvIHNob3VsZCBub3QgYmUgdmlzaWJsZSIsCi0JCQljb21iby5pc1Zpc2libGUoKQotCQkpOwotCi0JCS8vIENoYW5nZSBzdGF0ZSAodHJ1ZSkKLQkJYm9vbGVhbkhvbGRlci5zZXRWYWx1ZSh0cnVlKTsKLQotCQlhc3NlcnRUcnVlKAotCQkJIlRoZSBDb21ibyBzaG91bGQgYmUgdmlzaWJsZSIsCi0JCQljb21iby5pc1Zpc2libGUoKQotCQkpOwotCi0JCS8vIENoYW5nZSBzdGF0ZSAoZmFsc2UpCi0JCWJvb2xlYW5Ib2xkZXIuc2V0VmFsdWUoZmFsc2UpOwotCi0JCWFzc2VydEZhbHNlKAotCQkJIlRoZSBDb21ibyBzaG91bGQgbm90IGJlIHZpc2libGUiLAotCQkJY29tYm8uaXNWaXNpYmxlKCkKLQkJKTsKLQotCQkvLyBEaXNwb3NlCi0JCWNvbWJvLmRpc3Bvc2UoKTsKLQkJYm9vbGVhbkhvbGRlci5zZXRWYWx1ZSh0cnVlKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvdXRpbC9KcHRVaVV0aWxUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3V0aWwvSnB0VWlVdGlsVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODFjZmIwOC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvdXRpbC9KcHRVaVV0aWxUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy5pbnRlcm5hbC51dGlsOwotCi1pbXBvcnQganVuaXQuZnJhbWV3b3JrLkpVbml0NFRlc3RBZGFwdGVyOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0OwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0U3VpdGU7Ci1pbXBvcnQgb3JnLmp1bml0LnJ1bm5lci5SdW5XaXRoOwotaW1wb3J0IG9yZy5qdW5pdC5ydW5uZXJzLlN1aXRlOwotaW1wb3J0IG9yZy5qdW5pdC5ydW5uZXJzLlN1aXRlLlN1aXRlQ2xhc3NlczsKLQotQFN1aXRlQ2xhc3NlcwotKHsKLQlDb250cm9sQWxpZ25lclRlc3QuY2xhc3MsCi0JQ29udHJvbFN3aXRjaGVyVGVzdC5jbGFzcywKLQlDb250cm9sRW5hYmxlclRlc3QuY2xhc3MsCi0JQ29udHJvbFZpc2liaWxpdHlFbmFibGVyVGVzdC5jbGFzcywKLQlMYWJlbGVkQnV0dG9uVGVzdC5jbGFzcywKLQlMYWJlbGVkTGFiZWxUZXN0LmNsYXNzLAotCUxhYmVsZWRDb250cm9sVXBkYXRlclRlc3QuY2xhc3MsCi0JUGFuZUVuYWJsZXJUZXN0LmNsYXNzLAotCVBhbmVWaXNpYmlsaXR5RW5hYmxlclRlc3QuY2xhc3MsCi19KQotQFJ1bldpdGgoU3VpdGUuY2xhc3MpCi1wdWJsaWMgZmluYWwgY2xhc3MgSnB0VWlVdGlsVGVzdHMgewotCi0JcHJpdmF0ZSBKcHRVaVV0aWxUZXN0cygpIHsKLQkJc3VwZXIoKTsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi0JcHVibGljIHN0YXRpYyBUZXN0IHN1aXRlKCkgewotCQlUZXN0U3VpdGUgc3VpdGUgPSBuZXcgVGVzdFN1aXRlKCk7Ci0JCXN1aXRlLmFkZFRlc3QobmV3IEpVbml0NFRlc3RBZGFwdGVyKEpwdFVpVXRpbFRlc3RzLmNsYXNzKSk7Ci0JCXJldHVybiBzdWl0ZTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvdXRpbC9MYWJlbGVkQnV0dG9uVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3V0aWwvTGFiZWxlZEJ1dHRvblRlc3QuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZGRlMzAzMS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvdXRpbC9MYWJlbGVkQnV0dG9uVGVzdC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTIyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudWkudGVzdHMuaW50ZXJuYWwudXRpbDsKLQotaW1wb3J0IHN0YXRpYyBvcmcuanVuaXQuQXNzZXJ0LmFzc2VydEVxdWFsczsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuQXNzZXJ0aW9uRmFpbGVkRXhjZXB0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLkxhYmVsZWRCdXR0b247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuU1dUVXRpbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuU1dUOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5ncmFwaGljcy5JbWFnZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWRMYXlvdXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQnV0dG9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuanVuaXQuQWZ0ZXI7Ci1pbXBvcnQgb3JnLmp1bml0LkJlZm9yZTsKLWltcG9ydCBvcmcuanVuaXQuVGVzdDsKLQotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgZmluYWwgY2xhc3MgTGFiZWxlZEJ1dHRvblRlc3QgewotCi0JcHJpdmF0ZSBDb21wb3NpdGUgcGFyZW50OwotCi0JQEJlZm9yZQotCXB1YmxpYyB2b2lkIHNldFVwKCkgewotCQlwYXJlbnQgPSBuZXcgQ29tcG9zaXRlKFNXVFV0aWwuZ2V0U2hlbGwoKSwgU1dULk5PTkUpOwotCQlwYXJlbnQuc2V0TGF5b3V0KG5ldyBHcmlkTGF5b3V0KCkpOwotCX0KLQotCUBBZnRlcgotCXB1YmxpYyB2b2lkIHRlYXJEb3duKCkgewotCQlpZiAocGFyZW50ICE9IG51bGwpIHsKLQkJCXBhcmVudC5kaXNwb3NlKCk7Ci0JCQlwYXJlbnQgPSBudWxsOwotCQl9Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0TGFiZWxlZEJ1dHRvbjEoKSB7Ci0JCUJ1dHRvbiBidXR0b24gPSBuZXcgQnV0dG9uKHBhcmVudCwgU1dULk5VTEwpOwotCQluZXcgTGFiZWxlZEJ1dHRvbihidXR0b24pOwotCX0KLQotCUBUZXN0KGV4cGVjdGVkPUFzc2VydGlvbkZhaWxlZEV4Y2VwdGlvbi5jbGFzcykKLQlwdWJsaWMgdm9pZCB0ZXN0TGFiZWxlZEJ1dHRvbjIoKSB7Ci0JCW5ldyBMYWJlbGVkQnV0dG9uKG51bGwpOwotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdFNldEltYWdlKCkgewotCi0JCUltYWdlIGV4cGVjdGVkID0gbmV3IEltYWdlKHBhcmVudC5nZXREaXNwbGF5KCksIDE2LCAxNik7Ci0KLQkJdHJ5IHsKLQkJCUJ1dHRvbiBidXR0b24gPSBuZXcgQnV0dG9uKHBhcmVudCwgU1dULk5VTEwpOwotCQkJTGFiZWxlZEJ1dHRvbiBsYWJlbGVkQnV0dG9uID0gbmV3IExhYmVsZWRCdXR0b24oYnV0dG9uKTsKLQotCQkJbGFiZWxlZEJ1dHRvbi5zZXRJbWFnZShleHBlY3RlZCk7Ci0KLQkJCWFzc2VydEVxdWFscygKLQkJCQkiVGhlIEJ1dHRvbiBkaWRuJ3QgcmVjZWl2ZSB0aGUgSW1hZ2UiLAotCQkJCWV4cGVjdGVkLAotCQkJCWJ1dHRvbi5nZXRJbWFnZSgpCi0JCQkpOwotCQl9Ci0JCWZpbmFsbHkgewotCQkJZXhwZWN0ZWQuZGlzcG9zZSgpOwotCQl9Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0U2V0SW1hZ2VEaXNwb3NlKCkgewotCi0JCUltYWdlIGV4cGVjdGVkID0gbmV3IEltYWdlKHBhcmVudC5nZXREaXNwbGF5KCksIDE2LCAxNik7Ci0KLQkJdHJ5IHsKLQkJCUJ1dHRvbiBidXR0b24gPSBuZXcgQnV0dG9uKHBhcmVudCwgU1dULk5VTEwpOwotCQkJTGFiZWxlZEJ1dHRvbiBsYWJlbGVkQnV0dG9uID0gbmV3IExhYmVsZWRCdXR0b24oYnV0dG9uKTsKLQotCQkJYnV0dG9uLmRpc3Bvc2UoKTsKLQotCQkJLy8gVGhpcyBzaG91bGQgbm90IGZhaWwgYnV0IHNpbXBseSBkbyBub3RoaW5nCi0JCQlsYWJlbGVkQnV0dG9uLnNldEltYWdlKGV4cGVjdGVkKTsKLQkJfQotCQlmaW5hbGx5IHsKLQkJCWV4cGVjdGVkLmRpc3Bvc2UoKTsKLQkJfQotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdFNldFRleHQoKSB7Ci0JCUJ1dHRvbiBidXR0b24gPSBuZXcgQnV0dG9uKHBhcmVudCwgU1dULk5VTEwpOwotCQlMYWJlbGVkQnV0dG9uIGxhYmVsZWRCdXR0b24gPSBuZXcgTGFiZWxlZEJ1dHRvbihidXR0b24pOwotCi0JCVN0cmluZyBleHBlY3RlZCA9ICJUaGlzIGlzIGEgdGVzdCI7Ci0JCWxhYmVsZWRCdXR0b24uc2V0VGV4dChleHBlY3RlZCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKAotCQkJIlRoZSBCdXR0b24gZGlkbid0IHJlY2VpdmUgdGhlIHRleHQiLAotCQkJZXhwZWN0ZWQsCi0JCQlidXR0b24uZ2V0VGV4dCgpCi0JCSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0U2V0VGV4dERpc3Bvc2UoKSB7Ci0JCUJ1dHRvbiBidXR0b24gPSBuZXcgQnV0dG9uKHBhcmVudCwgU1dULk5VTEwpOwotCQlMYWJlbGVkQnV0dG9uIGxhYmVsZWRCdXR0b24gPSBuZXcgTGFiZWxlZEJ1dHRvbihidXR0b24pOwotCi0JCWJ1dHRvbi5kaXNwb3NlKCk7Ci0KLQkJLy8gVGhpcyBzaG91bGQgbm90IGZhaWwgYnV0IHNpbXBseSBkbyBub3RoaW5nCi0JCVN0cmluZyBleHBlY3RlZCA9ICJUaGlzIGlzIGEgdGVzdCI7Ci0JCWxhYmVsZWRCdXR0b24uc2V0VGV4dChleHBlY3RlZCk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3V0aWwvTGFiZWxlZENvbnRyb2xVcGRhdGVyVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3V0aWwvTGFiZWxlZENvbnRyb2xVcGRhdGVyVGVzdC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiZDJjZTUwLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC91dGlsL0xhYmVsZWRDb250cm9sVXBkYXRlclRlc3QuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEyNCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKgotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzLmludGVybmFsLnV0aWw7Ci0KLWltcG9ydCBzdGF0aWMgb3JnLmp1bml0LkFzc2VydC5hc3NlcnRFcXVhbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuTGFiZWxlZENvbnRyb2xVcGRhdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLkxhYmVsZWRMYWJlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwudXRpbC5TV1RVdGlsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuU1dUOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5ncmFwaGljcy5JbWFnZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWRMYXlvdXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkxhYmVsOwotaW1wb3J0IG9yZy5qdW5pdC5BZnRlcjsKLWltcG9ydCBvcmcuanVuaXQuQmVmb3JlOwotaW1wb3J0IG9yZy5qdW5pdC5UZXN0OwotCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBmaW5hbCBjbGFzcyBMYWJlbGVkQ29udHJvbFVwZGF0ZXJUZXN0IHsKLQotCXByaXZhdGUgQ29tcG9zaXRlIHBhcmVudDsKLQotCUBCZWZvcmUKLQlwdWJsaWMgdm9pZCBzZXRVcCgpIHsKLQkJcGFyZW50ID0gbmV3IENvbXBvc2l0ZShTV1RVdGlsLmdldFNoZWxsKCksIFNXVC5OT05FKTsKLQkJcGFyZW50LnNldExheW91dChuZXcgR3JpZExheW91dCgpKTsKLQl9Ci0KLQlAQWZ0ZXIKLQlwdWJsaWMgdm9pZCB0ZWFyRG93bigpIHsKLQkJaWYgKHBhcmVudCAhPSBudWxsKSB7Ci0JCQlwYXJlbnQuZGlzcG9zZSgpOwotCQkJcGFyZW50ID0gbnVsbDsKLQkJfQotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdFNldEltYWdlKCkgewotCi0JCUltYWdlIGV4cGVjdGVkID0gbmV3IEltYWdlKHBhcmVudC5nZXREaXNwbGF5KCksIDE2LCAxNik7Ci0KLQkJdHJ5IHsKLQkJCUxhYmVsIGxhYmVsID0gbmV3IExhYmVsKHBhcmVudCwgU1dULk5VTEwpOwotCQkJTGFiZWxlZExhYmVsIGxhYmVsZWRMYWJlbCA9IG5ldyBMYWJlbGVkTGFiZWwobGFiZWwpOwotCi0JCQlXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxJbWFnZT4gaW1hZ2VIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPEltYWdlPigpOwotCQkJbmV3IExhYmVsZWRDb250cm9sVXBkYXRlcihsYWJlbGVkTGFiZWwsIG51bGwsIGltYWdlSG9sZGVyKTsKLQotCQkJbGFiZWxlZExhYmVsLnNldEltYWdlKGV4cGVjdGVkKTsKLQotCQkJYXNzZXJ0RXF1YWxzKAotCQkJCSJUaGUgTGFiZWwgZGlkbid0IHJlY2VpdmUgdGhlIEltYWdlIiwKLQkJCQlleHBlY3RlZCwKLQkJCQlsYWJlbC5nZXRJbWFnZSgpCi0JCQkpOwotCQl9Ci0JCWZpbmFsbHkgewotCQkJZXhwZWN0ZWQuZGlzcG9zZSgpOwotCQl9Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0U2V0SW1hZ2VEaXNwb3NlKCkgewotCi0JCUltYWdlIGV4cGVjdGVkID0gbmV3IEltYWdlKHBhcmVudC5nZXREaXNwbGF5KCksIDE2LCAxNik7Ci0KLQkJdHJ5IHsKLQkJCUxhYmVsIGxhYmVsID0gbmV3IExhYmVsKHBhcmVudCwgU1dULk5VTEwpOwotCQkJTGFiZWxlZExhYmVsIGxhYmVsZWRMYWJlbCA9IG5ldyBMYWJlbGVkTGFiZWwobGFiZWwpOwotCi0JCQlXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxJbWFnZT4gaW1hZ2VIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPEltYWdlPigpOwotCQkJbmV3IExhYmVsZWRDb250cm9sVXBkYXRlcihsYWJlbGVkTGFiZWwsIG51bGwsIGltYWdlSG9sZGVyKTsKLQotCQkJbGFiZWwuZGlzcG9zZSgpOwotCQkJbGFiZWxlZExhYmVsLnNldEltYWdlKGV4cGVjdGVkKTsKLQkJfQotCQlmaW5hbGx5IHsKLQkJCWV4cGVjdGVkLmRpc3Bvc2UoKTsKLQkJfQotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdFNldFRleHQoKSB7Ci0KLQkJTGFiZWwgbGFiZWwgPSBuZXcgTGFiZWwocGFyZW50LCBTV1QuTlVMTCk7Ci0JCUxhYmVsZWRMYWJlbCBsYWJlbGVkTGFiZWwgPSBuZXcgTGFiZWxlZExhYmVsKGxhYmVsKTsKLQotCQlXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IHRleHRIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4oKTsKLQkJbmV3IExhYmVsZWRDb250cm9sVXBkYXRlcihsYWJlbGVkTGFiZWwsIHRleHRIb2xkZXIpOwotCi0JCVN0cmluZyBleHBlY3RlZCA9ICJUaGlzIGlzIGEgdGVzdCI7Ci0JCXRleHRIb2xkZXIuc2V0VmFsdWUoZXhwZWN0ZWQpOwotCi0JCWFzc2VydEVxdWFscygKLQkJCSJUaGUgTGFiZWwgZGlkbid0IHJlY2VpdmUgdGhlIHRleHQiLAotCQkJZXhwZWN0ZWQsCi0JCQlsYWJlbC5nZXRUZXh0KCkKLQkJKTsKLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3RTZXRUZXh0RGlzcG9zZSgpIHsKLQotCQlMYWJlbCBsYWJlbCA9IG5ldyBMYWJlbChwYXJlbnQsIFNXVC5OVUxMKTsKLQkJTGFiZWxlZExhYmVsIGxhYmVsZWRMYWJlbCA9IG5ldyBMYWJlbGVkTGFiZWwobGFiZWwpOwotCi0JCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gdGV4dEhvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPigpOwotCQluZXcgTGFiZWxlZENvbnRyb2xVcGRhdGVyKGxhYmVsZWRMYWJlbCwgdGV4dEhvbGRlcik7Ci0KLQkJbGFiZWwuZGlzcG9zZSgpOwotCi0JCVN0cmluZyBleHBlY3RlZCA9ICJUaGlzIGlzIGEgdGVzdCI7Ci0JCXRleHRIb2xkZXIuc2V0VmFsdWUoZXhwZWN0ZWQpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC91dGlsL0xhYmVsZWRMYWJlbFRlc3QuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudWkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91aS90ZXN0cy9pbnRlcm5hbC91dGlsL0xhYmVsZWRMYWJlbFRlc3QuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjk2MjI4NC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvdXRpbC9MYWJlbGVkTGFiZWxUZXN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMjIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy5pbnRlcm5hbC51dGlsOwotCi1pbXBvcnQgc3RhdGljIG9yZy5qdW5pdC5Bc3NlcnQuYXNzZXJ0RXF1YWxzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5Bc3NlcnRpb25GYWlsZWRFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuTGFiZWxlZExhYmVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51aS5pbnRlcm5hbC51dGlsLlNXVFV0aWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LlNXVDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QuZ3JhcGhpY3MuSW1hZ2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmxheW91dC5HcmlkTGF5b3V0OwotaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkNvbXBvc2l0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5MYWJlbDsKLWltcG9ydCBvcmcuanVuaXQuQWZ0ZXI7Ci1pbXBvcnQgb3JnLmp1bml0LkJlZm9yZTsKLWltcG9ydCBvcmcuanVuaXQuVGVzdDsKLQotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgZmluYWwgY2xhc3MgTGFiZWxlZExhYmVsVGVzdCB7Ci0KLQlwcml2YXRlIENvbXBvc2l0ZSBwYXJlbnQ7Ci0KLQlAQmVmb3JlCi0JcHVibGljIHZvaWQgc2V0VXAoKSB7Ci0JCXBhcmVudCA9IG5ldyBDb21wb3NpdGUoU1dUVXRpbC5nZXRTaGVsbCgpLCBTV1QuTk9ORSk7Ci0JCXBhcmVudC5zZXRMYXlvdXQobmV3IEdyaWRMYXlvdXQoKSk7Ci0JfQotCi0JQEFmdGVyCi0JcHVibGljIHZvaWQgdGVhckRvd24oKSB7Ci0JCWlmIChwYXJlbnQgIT0gbnVsbCkgewotCQkJcGFyZW50LmRpc3Bvc2UoKTsKLQkJCXBhcmVudCA9IG51bGw7Ci0JCX0KLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3RMYWJlbGVkQnV0dG9uMSgpIHsKLQkJTGFiZWwgbGFiZWwgPSBuZXcgTGFiZWwocGFyZW50LCBTV1QuTlVMTCk7Ci0JCW5ldyBMYWJlbGVkTGFiZWwobGFiZWwpOwotCX0KLQotCUBUZXN0KGV4cGVjdGVkPUFzc2VydGlvbkZhaWxlZEV4Y2VwdGlvbi5jbGFzcykKLQlwdWJsaWMgdm9pZCB0ZXN0TGFiZWxlZEJ1dHRvbjIoKSB7Ci0JCW5ldyBMYWJlbGVkTGFiZWwobnVsbCk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0U2V0SW1hZ2UoKSB7Ci0KLQkJSW1hZ2UgZXhwZWN0ZWQgPSBuZXcgSW1hZ2UocGFyZW50LmdldERpc3BsYXkoKSwgMTYsIDE2KTsKLQotCQl0cnkgewotCQkJTGFiZWwgbGFiZWwgPSBuZXcgTGFiZWwocGFyZW50LCBTV1QuTlVMTCk7Ci0JCQlMYWJlbGVkTGFiZWwgbGFiZWxlZExhYmVsID0gbmV3IExhYmVsZWRMYWJlbChsYWJlbCk7Ci0KLQkJCWxhYmVsZWRMYWJlbC5zZXRJbWFnZShleHBlY3RlZCk7Ci0KLQkJCWFzc2VydEVxdWFscygKLQkJCQkiVGhlIExhYmVsIGRpZG4ndCByZWNlaXZlIHRoZSBJbWFnZSIsCi0JCQkJZXhwZWN0ZWQsCi0JCQkJbGFiZWwuZ2V0SW1hZ2UoKQotCQkJKTsKLQkJfQotCQlmaW5hbGx5IHsKLQkJCWV4cGVjdGVkLmRpc3Bvc2UoKTsKLQkJfQotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdFNldEltYWdlRGlzcG9zZSgpIHsKLQotCQlJbWFnZSBleHBlY3RlZCA9IG5ldyBJbWFnZShwYXJlbnQuZ2V0RGlzcGxheSgpLCAxNiwgMTYpOwotCi0JCXRyeSB7Ci0JCQlMYWJlbCBsYWJlbCA9IG5ldyBMYWJlbChwYXJlbnQsIFNXVC5OVUxMKTsKLQkJCUxhYmVsZWRMYWJlbCBsYWJlbGVkTGFiZWwgPSBuZXcgTGFiZWxlZExhYmVsKGxhYmVsKTsKLQotCQkJbGFiZWwuZGlzcG9zZSgpOwotCi0JCQkvLyBUaGlzIHNob3VsZCBub3QgZmFpbCBidXQgc2ltcGx5IGRvIG5vdGhpbmcKLQkJCWxhYmVsZWRMYWJlbC5zZXRJbWFnZShleHBlY3RlZCk7Ci0JCX0KLQkJZmluYWxseSB7Ci0JCQlleHBlY3RlZC5kaXNwb3NlKCk7Ci0JCX0KLQl9Ci0KLQlAVGVzdAotCXB1YmxpYyB2b2lkIHRlc3RTZXRUZXh0KCkgewotCQlMYWJlbCBsYWJlbCA9IG5ldyBMYWJlbChwYXJlbnQsIFNXVC5OVUxMKTsKLQkJTGFiZWxlZExhYmVsIGxhYmVsZWRMYWJlbCA9IG5ldyBMYWJlbGVkTGFiZWwobGFiZWwpOwotCi0JCVN0cmluZyBleHBlY3RlZCA9ICJUaGlzIGlzIGEgdGVzdCI7Ci0JCWxhYmVsZWRMYWJlbC5zZXRUZXh0KGV4cGVjdGVkKTsKLQotCQlhc3NlcnRFcXVhbHMoCi0JCQkiVGhlIExhYmVsIGRpZG4ndCByZWNlaXZlIHRoZSB0ZXh0IiwKLQkJCWV4cGVjdGVkLAotCQkJbGFiZWwuZ2V0VGV4dCgpCi0JCSk7Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0U2V0VGV4dERpc3Bvc2UoKSB7Ci0JCUxhYmVsIGxhYmVsID0gbmV3IExhYmVsKHBhcmVudCwgU1dULk5VTEwpOwotCQlMYWJlbGVkTGFiZWwgbGFiZWxlZExhYmVsID0gbmV3IExhYmVsZWRMYWJlbChsYWJlbCk7Ci0KLQkJbGFiZWwuZGlzcG9zZSgpOwotCi0JCS8vIFRoaXMgc2hvdWxkIG5vdCBmYWlsIGJ1dCBzaW1wbHkgZG8gbm90aGluZwotCQlTdHJpbmcgZXhwZWN0ZWQgPSAiVGhpcyBpcyBhIHRlc3QiOwotCQlsYWJlbGVkTGFiZWwuc2V0VGV4dChleHBlY3RlZCk7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3V0aWwvUGFuZUVuYWJsZXJUZXN0LmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvdXRpbC9QYW5lRW5hYmxlclRlc3QuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDcyNjg2YS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvdXRpbC9QYW5lRW5hYmxlclRlc3QuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDkzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudWkudGVzdHMuaW50ZXJuYWwudXRpbDsKLQotaW1wb3J0IHN0YXRpYyBvcmcuanVuaXQuQXNzZXJ0Lio7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuUGFuZUVuYWJsZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuU1dUVXRpbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5EaWFsb2dQYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5ub2RlLk5vZGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LlNXVDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWRMYXlvdXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5qdW5pdC5BZnRlcjsKLWltcG9ydCBvcmcuanVuaXQuQmVmb3JlOwotaW1wb3J0IG9yZy5qdW5pdC5UZXN0OwotCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBmaW5hbCBjbGFzcyBQYW5lRW5hYmxlclRlc3QgewotCXByaXZhdGUgQ29tcG9zaXRlIHBhcmVudDsKLQotCUBCZWZvcmUKLQlwdWJsaWMgdm9pZCBzZXRVcCgpIHsKLQkJcGFyZW50ID0gbmV3IENvbXBvc2l0ZShTV1RVdGlsLmdldFNoZWxsKCksIFNXVC5OT05FKTsKLQkJcGFyZW50LnNldExheW91dChuZXcgR3JpZExheW91dCgpKTsKLQl9Ci0KLQlAQWZ0ZXIKLQlwdWJsaWMgdm9pZCB0ZWFyRG93bigpIHsKLQkJaWYgKHBhcmVudCAhPSBudWxsKSB7Ci0JCQlwYXJlbnQuZGlzcG9zZSgpOwotCQl9Ci0JfQotCi0JQFRlc3QKLQlwdWJsaWMgdm9pZCB0ZXN0U3dpdGNoU3RhdGUoKSB7Ci0KLQkJU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJvb2xlYW5Ib2xkZXIgPQotCQkJbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPih0cnVlKTsKLQotCQlEaWFsb2dQYW5lPE5vZGU+IHBhbmUgPSBuZXcgRGlhbG9nUGFuZTxOb2RlPigKLQkJCW5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8Tm9kZT4oKSwKLQkJCXBhcmVudCkKLQkJewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBpbml0aWFsaXplTGF5b3V0KENvbXBvc2l0ZSBjb250YWluZXIpIHsKLQkJCX0KLQkJfTsKLQotCQlwYW5lLnBvcHVsYXRlKCk7Ci0JCW5ldyBQYW5lRW5hYmxlcihib29sZWFuSG9sZGVyLCBwYW5lKTsKLQotCQlhc3NlcnRUcnVlKAotCQkJIlRoZSBwYW5lIHNob3VsZCBiZSBlbmFibGVkIiwKLQkJCXBhbmUuZ2V0Q29udHJvbCgpLmlzRW5hYmxlZCgpCi0JCSk7Ci0KLQkJLy8gQ2hhbmdlIHN0YXRlIChudWxsKQotCQlib29sZWFuSG9sZGVyLnNldFZhbHVlKG51bGwpOwotCi0JCWFzc2VydEZhbHNlKAotCQkJIlRoZSBwYW5lIHNob3VsZCBub3QgYmUgZW5hYmxlZCIsCi0JCQlwYW5lLmdldENvbnRyb2woKS5pc0VuYWJsZWQoKQotCQkpOwotCi0JCS8vIENoYW5nZSBzdGF0ZSAodHJ1ZSkKLQkJYm9vbGVhbkhvbGRlci5zZXRWYWx1ZSh0cnVlKTsKLQotCQlhc3NlcnRUcnVlKAotCQkJIlRoZSBwYW5lIHNob3VsZCBiZSBlbmFibGVkIiwKLQkJCXBhbmUuZ2V0Q29udHJvbCgpLmlzRW5hYmxlZCgpCi0JCSk7Ci0KLQkJLy8gQ2hhbmdlIHN0YXRlIChmYWxzZSkKLQkJYm9vbGVhbkhvbGRlci5zZXRWYWx1ZShmYWxzZSk7Ci0KLQkJYXNzZXJ0RmFsc2UoCi0JCQkiVGhlIHBhbmUgc2hvdWxkIG5vdCBiZSBlbmFibGVkIiwKLQkJCXBhbmUuZ2V0Q29udHJvbCgpLmlzRW5hYmxlZCgpCi0JCSk7Ci0KLQkJLy8gRGlzcG9zZQotCQlwYW5lLmRpc3Bvc2UoKTsKLQkJYm9vbGVhbkhvbGRlci5zZXRWYWx1ZSh0cnVlKTsKLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvdXRpbC9QYW5lVmlzaWJpbGl0eUVuYWJsZXJUZXN0LmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnVpLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdWkvdGVzdHMvaW50ZXJuYWwvdXRpbC9QYW5lVmlzaWJpbGl0eUVuYWJsZXJUZXN0LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDY0NGFjZmMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3VpL3Rlc3RzL2ludGVybmFsL3V0aWwvUGFuZVZpc2liaWxpdHlFbmFibGVyVGVzdC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsOTMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICoKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51aS50ZXN0cy5pbnRlcm5hbC51dGlsOwotCi1pbXBvcnQgc3RhdGljIG9yZy5qdW5pdC5Bc3NlcnQuKjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwudXRpbC5QYW5lVmlzaWJpbGl0eUVuYWJsZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnVpLmludGVybmFsLnV0aWwuU1dUVXRpbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudWkuaW50ZXJuYWwud2lkZ2V0cy5EaWFsb2dQYW5lOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5ub2RlLk5vZGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LlNXVDsKLWltcG9ydCBvcmcuZWNsaXBzZS5zd3QubGF5b3V0LkdyaWRMYXlvdXQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOwotaW1wb3J0IG9yZy5qdW5pdC5BZnRlcjsKLWltcG9ydCBvcmcuanVuaXQuQmVmb3JlOwotaW1wb3J0IG9yZy5qdW5pdC5UZXN0OwotCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBmaW5hbCBjbGFzcyBQYW5lVmlzaWJpbGl0eUVuYWJsZXJUZXN0IHsKLQlwcml2YXRlIENvbXBvc2l0ZSBwYXJlbnQ7Ci0KLQlAQmVmb3JlCi0JcHVibGljIHZvaWQgc2V0VXAoKSB7Ci0JCXBhcmVudCA9IG5ldyBDb21wb3NpdGUoU1dUVXRpbC5nZXRTaGVsbCgpLCBTV1QuTk9ORSk7Ci0JCXBhcmVudC5zZXRMYXlvdXQobmV3IEdyaWRMYXlvdXQoKSk7Ci0JfQotCi0JQEFmdGVyCi0JcHVibGljIHZvaWQgdGVhckRvd24oKSB7Ci0JCWlmIChwYXJlbnQgIT0gbnVsbCkgewotCQkJcGFyZW50LmRpc3Bvc2UoKTsKLQkJfQotCX0KLQotCUBUZXN0Ci0JcHVibGljIHZvaWQgdGVzdFN3aXRjaFN0YXRlKCkgewotCi0JCVNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBib29sZWFuSG9sZGVyID0KLQkJCW5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4odHJ1ZSk7Ci0KLQkJRGlhbG9nUGFuZTxOb2RlPiBwYW5lID0gbmV3IERpYWxvZ1BhbmU8Tm9kZT4oCi0JCQluZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPE5vZGU+KCksCi0JCQlwYXJlbnQpCi0JCXsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZUxheW91dChDb21wb3NpdGUgY29udGFpbmVyKSB7Ci0JCQl9Ci0JCX07Ci0KLQkJcGFuZS5wb3B1bGF0ZSgpOwotCQluZXcgUGFuZVZpc2liaWxpdHlFbmFibGVyKGJvb2xlYW5Ib2xkZXIsIHBhbmUpOwotCi0JCWFzc2VydFRydWUoCi0JCQkiVGhlIHBhbmUgc2hvdWxkIGJlIHZpc2libGUiLAotCQkJcGFuZS5nZXRDb250cm9sKCkuaXNWaXNpYmxlKCkKLQkJKTsKLQotCQkvLyBDaGFuZ2Ugc3RhdGUgKG51bGwpCi0JCWJvb2xlYW5Ib2xkZXIuc2V0VmFsdWUobnVsbCk7Ci0KLQkJYXNzZXJ0RmFsc2UoCi0JCQkiVGhlIHBhbmUgc2hvdWxkIG5vdCBiZSB2aXNpYmxlIiwKLQkJCXBhbmUuZ2V0Q29udHJvbCgpLmlzVmlzaWJsZSgpCi0JCSk7Ci0KLQkJLy8gQ2hhbmdlIHN0YXRlICh0cnVlKQotCQlib29sZWFuSG9sZGVyLnNldFZhbHVlKHRydWUpOwotCi0JCWFzc2VydFRydWUoCi0JCQkiVGhlIHBhbmUgc2hvdWxkIGJlIHZpc2libGUiLAotCQkJcGFuZS5nZXRDb250cm9sKCkuaXNWaXNpYmxlKCkKLQkJKTsKLQotCQkvLyBDaGFuZ2Ugc3RhdGUgKGZhbHNlKQotCQlib29sZWFuSG9sZGVyLnNldFZhbHVlKGZhbHNlKTsKLQotCQlhc3NlcnRGYWxzZSgKLQkJCSJUaGUgcGFuZSBzaG91bGQgbm90IGJlIHZpc2libGUiLAotCQkJcGFuZS5nZXRDb250cm9sKCkuaXNWaXNpYmxlKCkKLQkJKTsKLQotCQkvLyBEaXNwb3NlCi0JCXBhbmUuZGlzcG9zZSgpOwotCQlib29sZWFuSG9sZGVyLnNldFZhbHVlKHRydWUpOwotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy8uY2xhc3NwYXRoIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLy5jbGFzc3BhdGgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVmOGQ5MWMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLy5jbGFzc3BhdGgKKysrIC9kZXYvbnVsbApAQCAtMSwxMSArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPGNsYXNzcGF0aD4KLQk8Y2xhc3NwYXRoZW50cnkga2luZD0ic3JjIiBwYXRoPSJzcmMiLz4KLQk8Y2xhc3NwYXRoZW50cnkga2luZD0iY29uIiBwYXRoPSJvcmcuZWNsaXBzZS5qZHQubGF1bmNoaW5nLkpSRV9DT05UQUlORVIvb3JnLmVjbGlwc2UuamR0LmludGVybmFsLmRlYnVnLnVpLmxhdW5jaGVyLlN0YW5kYXJkVk1UeXBlL0oyU0UtMS41Ii8+Ci0JPGNsYXNzcGF0aGVudHJ5IGtpbmQ9ImNvbiIgcGF0aD0ib3JnLmVjbGlwc2UucGRlLmNvcmUucmVxdWlyZWRQbHVnaW5zIj4KLQkJPGFjY2Vzc3J1bGVzPgotCQkJPGFjY2Vzc3J1bGUga2luZD0iYWNjZXNzaWJsZSIgcGF0dGVybj0ib3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvKioiLz4KLQkJPC9hY2Nlc3NydWxlcz4KLQk8L2NsYXNzcGF0aGVudHJ5PgotCTxjbGFzc3BhdGhlbnRyeSBraW5kPSJvdXRwdXQiIHBhdGg9ImJpbiIvPgotPC9jbGFzc3BhdGg+CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvLmN2c2lnbm9yZSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy8uY3ZzaWdub3JlCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjNGJhNjEyLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy8uY3ZzaWdub3JlCisrKyAvZGV2L251bGwKQEAgLTEsNSArMCwwIEBACi1iaW4KLUBkb3QKLXRlbXAuZm9sZGVyCi1idWlsZC54bWwKLWphdmFDb21waWxlci4uLmFyZ3MKXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvLnByb2plY3QgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvLnByb2plY3QKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGFhNTI3MWUuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLy5wcm9qZWN0CisrKyAvZGV2L251bGwKQEAgLTEsMjggKzAsMCBAQAotPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KLTxwcm9qZWN0RGVzY3JpcHRpb24+Ci0JPG5hbWU+b3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHM8L25hbWU+Ci0JPGNvbW1lbnQ+PC9jb21tZW50PgotCTxwcm9qZWN0cz4KLQk8L3Byb2plY3RzPgotCTxidWlsZFNwZWM+Ci0JCTxidWlsZENvbW1hbmQ+Ci0JCQk8bmFtZT5vcmcuZWNsaXBzZS5qZHQuY29yZS5qYXZhYnVpbGRlcjwvbmFtZT4KLQkJCTxhcmd1bWVudHM+Ci0JCQk8L2FyZ3VtZW50cz4KLQkJPC9idWlsZENvbW1hbmQ+Ci0JCTxidWlsZENvbW1hbmQ+Ci0JCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuTWFuaWZlc3RCdWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQkJPGJ1aWxkQ29tbWFuZD4KLQkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5TY2hlbWFCdWlsZGVyPC9uYW1lPgotCQkJPGFyZ3VtZW50cz4KLQkJCTwvYXJndW1lbnRzPgotCQk8L2J1aWxkQ29tbWFuZD4KLQk8L2J1aWxkU3BlYz4KLQk8bmF0dXJlcz4KLQkJPG5hdHVyZT5vcmcuZWNsaXBzZS5wZGUuUGx1Z2luTmF0dXJlPC9uYXR1cmU+Ci0JCTxuYXR1cmU+b3JnLmVjbGlwc2UuamR0LmNvcmUuamF2YW5hdHVyZTwvbmF0dXJlPgotCTwvbmF0dXJlcz4KLTwvcHJvamVjdERlc2NyaXB0aW9uPgpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcyBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMucHJlZnMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGY2OGY5YzIuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5wcmVmcworKysgL2Rldi9udWxsCkBAIC0xLDMgKzAsMCBAQAotI1R1ZSBKYW4gMTUgMTE6MTI6MjYgRVNUIDIwMDgKLWVjbGlwc2UucHJlZmVyZW5jZXMudmVyc2lvbj0xCi1lbmNvZGluZy88cHJvamVjdD49SVNPLTg4NTktMQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5qZHQuY29yZS5wcmVmcyBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuamR0LmNvcmUucHJlZnMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDg0YjVjNGMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLy5zZXR0aW5ncy9vcmcuZWNsaXBzZS5qZHQuY29yZS5wcmVmcworKysgL2Rldi9udWxsCkBAIC0xLDcgKzAsMCBAQAotI1N1biBNYXkgMjcgMTQ6NTU6NTggRURUIDIwMDcKLWVjbGlwc2UucHJlZmVyZW5jZXMudmVyc2lvbj0xCi1vcmcuZWNsaXBzZS5qZHQuY29yZS5jb21waWxlci5jb2RlZ2VuLnRhcmdldFBsYXRmb3JtPTEuNQotb3JnLmVjbGlwc2UuamR0LmNvcmUuY29tcGlsZXIuY29tcGxpYW5jZT0xLjUKLW9yZy5lY2xpcHNlLmpkdC5jb3JlLmNvbXBpbGVyLnByb2JsZW0uYXNzZXJ0SWRlbnRpZmllcj1lcnJvcgotb3JnLmVjbGlwc2UuamR0LmNvcmUuY29tcGlsZXIucHJvYmxlbS5lbnVtSWRlbnRpZmllcj1lcnJvcgotb3JnLmVjbGlwc2UuamR0LmNvcmUuY29tcGlsZXIuc291cmNlPTEuNQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL01FVEEtSU5GL01BTklGRVNULk1GIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL01FVEEtSU5GL01BTklGRVNULk1GCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhNWE3MTk3Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9NRVRBLUlORi9NQU5JRkVTVC5NRgorKysgL2Rldi9udWxsCkBAIC0xLDE4ICswLDAgQEAKLU1hbmlmZXN0LVZlcnNpb246IDEuMAotQnVuZGxlLU1hbmlmZXN0VmVyc2lvbjogMgotQnVuZGxlLU5hbWU6ICVwbHVnaW5OYW1lCi1CdW5kbGUtVmVuZG9yOiAlcHJvdmlkZXJOYW1lCi1CdW5kbGUtU3ltYm9saWNOYW1lOiBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cwotQnVuZGxlLVZlcnNpb246IDEuMy4wCi1CdW5kbGUtTG9jYWxpemF0aW9uOiBwbHVnaW4KLVJlcXVpcmUtQnVuZGxlOiBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eTtidW5kbGUtdmVyc2lvbj0iWzEuMi4wLDIuMC4wKSIsCi0gb3JnLmp1bml0O2J1bmRsZS12ZXJzaW9uPSJbMy4wLjAsNC4wLjApIgotQnVuZGxlLVJlcXVpcmVkRXhlY3V0aW9uRW52aXJvbm1lbnQ6IEoyU0UtMS41Ci1FeHBvcnQtUGFja2FnZTogb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWw7eC1pbnRlcm5hbDo9dHJ1ZSwKLSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5pdGVyYXRvcnM7eC1pbnRlcm5hbDo9dHJ1ZSwKLSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbDt4LWludGVybmFsOj10cnVlLAotIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLmxpc3RlbmVyO3gtaW50ZXJuYWw6PXRydWUsCi0gb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWU7eC1pbnRlcm5hbDo9dHJ1ZSwKLSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZS5wcmVmczt4LWludGVybmFsOj10cnVlLAotIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nO3gtaW50ZXJuYWw6PXRydWUsCi0gb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubm9kZTt4LWludGVybmFsOj10cnVlCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvYWJvdXQuaHRtbCBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9hYm91dC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiZTUzNGJhLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9hYm91dC5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsMzQgKzAsMCBAQAotPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMC8vRU4iPgotPEhUTUw+Ci0KLTxoZWFkPgotPHRpdGxlPkFib3V0PC90aXRsZT4KLTxtZXRhIGh0dHAtZXF1aXY9Q29udGVudC1UeXBlIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1JU08tODg1OS0xIj4KLTwvaGVhZD4KLQotPEJPRFkgbGFuZz0iRU4tVVMiPgotCi08SDM+QWJvdXQgVGhpcyBDb250ZW50PC9IMz4KLQotPFA+TWF5IDAyLCAyMDA4PC9QPgotCi08SDM+TGljZW5zZTwvSDM+Ci0KLTxQPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIGFsbCBjb250ZW50IGluIHRoaXMgcGx1Zy1pbiAKLSgiQ29udGVudCIpLiBVbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCBiZWxvdywgdGhlIENvbnRlbnQgaXMgcHJvdmlkZWQgdG8geW91IAotdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIAotKCJFUEwiKS4gQSBjb3B5IG9mIHRoZSBFUEwgaXMgYXZhaWxhYmxlIGF0Ci08QSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL29yZy9kb2N1bWVudHMvZXBsLXYxMC5waHAiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvb3JnL2RvY3VtZW50cy9lcGwtdjEwLnBocDwvQT4uIAotRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9QPgotCi08UD5JZiB5b3UgZGlkIG5vdCByZWNlaXZlIHRoaXMgQ29udGVudCBkaXJlY3RseSBmcm9tIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24sIHRoZSAKLUNvbnRlbnQgaXMgYmVpbmcgcmVkaXN0cmlidXRlZCBieSBhbm90aGVyIHBhcnR5ICgiUmVkaXN0cmlidXRvciIpIGFuZCBkaWZmZXJlbnQgCi10ZXJtcyBhbmQgY29uZGl0aW9ucyBtYXkgYXBwbHkgdG8geW91ciB1c2Ugb2YgYW55IG9iamVjdCBjb2RlIGluIHRoZSBDb250ZW50LiAKLUNoZWNrIHRoZSBSZWRpc3RyaWJ1dG9yJ3MgbGljZW5zZSB0aGF0IHdhcyBwcm92aWRlZCB3aXRoIHRoZSBDb250ZW50LiBJZiBubyBzdWNoIAotbGljZW5zZSBleGlzdHMsIGNvbnRhY3QgdGhlIFJlZGlzdHJpYnV0b3IuIFVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkIGJlbG93LCB0aGUgCi10ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRVBMIHN0aWxsIGFwcGx5IHRvIGFueSBzb3VyY2UgY29kZSBpbiB0aGUgQ29udGVudCAKLWFuZCBzdWNoIHNvdXJjZSBjb2RlIG1heSBiZSBvYnRhaW5lZCBhdAotPEEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy8iPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvPC9BPi48L1A+Ci0KLTwvQk9EWT4KLTwvSFRNTD4KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9idWlsZC5wcm9wZXJ0aWVzIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL2J1aWxkLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGViZTljMDguLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL2J1aWxkLnByb3BlcnRpZXMKKysrIC9kZXYvbnVsbApAQCAtMSwxNiArMCwwIEBACi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotIyBDb3B5cmlnaHQgKGMpIDIwMDYsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotIyBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSMgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSMgYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSMgCi0jIENvbnRyaWJ1dG9yczoKLSMgICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLXNvdXJjZS4uID0gc3JjLwotb3V0cHV0Li4gPSBiaW4vCi1iaW4uaW5jbHVkZXMgPSAuLFwKLSAgICAgICAgICAgICAgIE1FVEEtSU5GLyxcCi0gICAgICAgICAgICAgICBhYm91dC5odG1sLFwKLSAgICAgICAgICAgICAgIHRlc3QueG1sLFwKLSAgICAgICAgICAgICAgIHBsdWdpbi5wcm9wZXJ0aWVzCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvcGx1Z2luLnByb3BlcnRpZXMgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvcGx1Z2luLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDk5OTU3NjguLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3BsdWdpbi5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMjQgKzAsMCBAQAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSMgQ29weXJpZ2h0IChjKSAyMDA2LCAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSMgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0jIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0jIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0jIAotIyBDb250cmlidXRvcnM6Ci0jICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0jIFRvIGNvZGUgZGV2ZWxvcGVyOgotIyAgIERvIE5PVCBjaGFuZ2UgdGhlIHByb3BlcnRpZXMgYmV0d2VlbiB0aGlzIGxpbmUgYW5kIHRoZQotIyAgICIlJSUgRU5EIE9GIFRSQU5TTEFURUQgUFJPUEVSVElFUyAlJSUiIGxpbmUuCi0jICAgTWFrZSBhIG5ldyBwcm9wZXJ0eSBuYW1lLCBhcHBlbmQgdG8gdGhlIGVuZCBvZiB0aGUgZmlsZSBhbmQgY2hhbmdlCi0jICAgdGhlIGNvZGUgdG8gdXNlIHRoZSBuZXcgcHJvcGVydHkuCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0KLSMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLSMgJSUlIEVORCBPRiBUUkFOU0xBVEVEIFBST1BFUlRJRVMgJSUlCi0jID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0KLXBsdWdpbk5hbWUgPSBKYXZhIFBlcnNpc3RlbmNlIEFQSSBVdGlsaXR5IFRlc3RzCi1wcm92aWRlck5hbWUgPSBFY2xpcHNlLm9yZwotCmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvcmVzb3VyY2UvQ2xhc3NUb29scy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3Jlc291cmNlL0NsYXNzVG9vbHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYWFjMTdiNi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvcmVzb3VyY2UvQ2xhc3NUb29scy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTY4MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIHRlc3Q7Ci0KLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5Db25zdHJ1Y3RvcjsKLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5GaWVsZDsKLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5JbnZvY2F0aW9uVGFyZ2V0RXhjZXB0aW9uOwotaW1wb3J0IGphdmEubGFuZy5yZWZsZWN0Lk1ldGhvZDsKLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5Nb2RpZmllcjsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbnM7Ci1pbXBvcnQgamF2YS51dGlsLlN0YWNrOwotCi0vKioKLSAqIENvbnZlbmllbmNlIG1ldGhvZHMgcmVsYXRlZCB0byB0aGUgamF2YS5sYW5nLnJlZmxlY3QgcGFja2FnZS4KLSAqIFRoZXNlIG1ldGhvZHMgcHJvdmlkZSBzaG9ydGN1dHMgZm9yIG1hbmlwdWxhdGluZyBvYmplY3RzIHZpYQotICogcmVmbGVjdGlvbjsgcGFydGljdWxhcmx5IHdoZW4gZGVhbGluZyB3aXRoIGZpZWxkcyBhbmQvb3IgbWV0aG9kcyB0aGF0Ci0gKiBhcmUgbm90IHB1YmxpY2x5IGFjY2Vzc2libGUgb3IgYXJlIGluaGVyaXRlZC4KLSAqIAotICogSW4gbW9zdCBjYXNlcywgYWxsIHRoZSBleGNlcHRpb25zIGFyZSBoYW5kbGVkIGFuZAotICogd3JhcHBlZCBpbiBqYXZhLmxhbmcuUnVudGltZUV4Y2VwdGlvbnM7IHNvIHRoZXNlIG1ldGhvZHMgc2hvdWxkCi0gKiBiZSB1c2VkIHdoZW4geW91IGFyZSBjb25maWRlbnQgdGhhdCB5b3Ugd2lsbCBub3QgaGF2aW5nIGFueSBwcm9ibGVtcwotICogdXNpbmcgcmVmbGVjdGlvbi4KLSAqIAotICogVGhlcmUgYXJlIGFsc28gYSBudW1iZXIgb2YgbWV0aG9kcyB3aG9zZSBuYW1lcwotICogYmVnaW4gd2l0aCAiYXR0ZW1wdCIuIFRoZXNlIG1ldGhvZHMgd2lsbCB0aHJvdyBhIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbgotICogb3IgTm9TdWNoRmllbGRFeGNlcHRpb24gd2hlbiBhcHByb3ByaWF0ZSwgYWxsb3dpbmcgeW91IHRvIHByb2JlCi0gKiBmb3IgbWV0aG9kcyB0aGF0IHNob3VsZCBiZSBwcmVzZW50IGJ1dCBtaWdodCBub3QuCi0gKi8KLXB1YmxpYyBmaW5hbCBjbGFzcyBDbGFzc1Rvb2xzIHsKLQotCXB1YmxpYyBzdGF0aWMgZmluYWwgQ2xhc3M8Pz5bXSBaRVJPX1BBUkFNRVRFUl9UWVBFUyA9IG5ldyBDbGFzc1swXTsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIE9iamVjdFtdIFpFUk9fUEFSQU1FVEVSUyA9IG5ldyBPYmplY3RbMF07Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIENSID0gU3RyaW5nVG9vbHMuQ1I7Ci0KLQlwdWJsaWMgc3RhdGljIGZpbmFsIGNoYXIgTkVTVEVEX0NMQVNTX05BTUVfU0VQQVJBVE9SID0gJyQnOwotCi0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIEFSUkFZX0lORElDQVRPUiA9ICdbJzsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIGNoYXIgVFlQRV9ERUNMQVJBVElPTl9BUlJBWV9PUEVOID0gJ1snOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgY2hhciBUWVBFX0RFQ0xBUkFUSU9OX0FSUkFZX0NMT1NFID0gJ10nOwotCi0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIFJFRkVSRU5DRV9DTEFTU19DT0RFID0gJ0wnOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgY2hhciBSRUZFUkVOQ0VfQ0xBU1NfTkFNRV9ERUxJTUlURVIgPSAnOyc7Ci0JCi0JcHJpdmF0ZSBzdGF0aWMgUHJpbWl0aXZlW10gUFJJTUlUSVZFUzsgIC8vIHBzZXVkby0nZmluYWwnIC0gbGF6eS1pbml0aWFsaXplZAotCXB1YmxpYyBzdGF0aWMgZmluYWwgY2hhciBCWVRFX0NPREUgPSAnQic7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIENIQVJfQ09ERSA9ICdDJzsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIGNoYXIgRE9VQkxFX0NPREUgPSAnRCc7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIEZMT0FUX0NPREUgPSAnRic7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIElOVF9DT0RFID0gJ0knOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgY2hhciBMT05HX0NPREUgPSAnSic7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIFNIT1JUX0NPREUgPSAnUyc7Ci0JcHVibGljIHN0YXRpYyBmaW5hbCBjaGFyIEJPT0xFQU5fQ09ERSA9ICdaJzsKLQlwdWJsaWMgc3RhdGljIGZpbmFsIGNoYXIgVk9JRF9DT0RFID0gJ1YnOwotCXByaXZhdGUgc3RhdGljIGludCBNQVhfUFJJTUlUSVZFX0NMQVNTX05BTUVfTEVOR1RIID0gLTE7ICAvLyBwc2V1ZG8tJ2ZpbmFsJyAtIGxhenktaW5pdGlhbGl6ZWQKLQlwcml2YXRlIHN0YXRpYyBpbnQgTUFYX1BSSU1JVElWRV9XUkFQUEVSX0NMQVNTX05BTUVfTEVOR1RIID0gLTE7ICAvLyBwc2V1ZG8tJ2ZpbmFsJyAtIGxhenktaW5pdGlhbGl6ZWQKLQotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFZPSURfQ0xBU1NfTkFNRSA9IHZvaWQuY2xhc3MuZ2V0TmFtZSgpOwotCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFZPSURfV1JBUFBFUl9DTEFTU19OQU1FID0gamF2YS5sYW5nLlZvaWQuY2xhc3MuZ2V0TmFtZSgpOwotCi0KLQkvKioKLQkgKiBSZXR1cm4gYWxsIHRoZSBmaWVsZHMgZm9yIHRoZQotCSAqIHNwZWNpZmllZCBjbGFzcywgaW5jbHVkaW5nIGluaGVyaXRlZCBmaWVsZHMuCi0JICogQ2xhc3MjYWxsRmllbGRzKCkKLQkgKi8KLQlARGVwcmVjYXRlZAotCXB1YmxpYyBzdGF0aWMgRmllbGRbXSBhbGxGaWVsZHMoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCVN0YWNrPEZpZWxkPiBzdGFjayA9IG5ldyBTdGFjazxGaWVsZD4oKTsKLQkJZm9yIChDbGFzczw/PiB0ZW1wQ2xhc3MgPSBqYXZhQ2xhc3M7IHRlbXBDbGFzcyAhPSBudWxsOyB0ZW1wQ2xhc3MgPSB0ZW1wQ2xhc3MuZ2V0U3VwZXJjbGFzcygpKSB7Ci0JCQlwdXNoRGVjbGFyZWRGaWVsZHModGVtcENsYXNzLCBzdGFjayk7Ci0JCX0KLQkJQ29sbGVjdGlvbnMucmV2ZXJzZShzdGFjayk7Ci0JCXJldHVybiBzdGFjay50b0FycmF5KG5ldyBGaWVsZFtzdGFjay5zaXplKCldKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIGFsbCB0aGUgbWV0aG9kcyBmb3IgdGhlCi0JICogc3BlY2lmaWVkIGNsYXNzLCBpbmNsdWRpbmcgaW5oZXJpdGVkIG1ldGhvZHMuCi0JICogQ2xhc3MjYWxsTWV0aG9kcygpCi0JICovCi0JcHVibGljIHN0YXRpYyBNZXRob2RbXSBhbGxNZXRob2RzKENsYXNzPD8+IGphdmFDbGFzcykgewotCQlTdGFjazxNZXRob2Q+IHN0YWNrID0gbmV3IFN0YWNrPE1ldGhvZD4oKTsKLQkJZm9yIChDbGFzczw/PiB0ZW1wQ2xhc3MgPSBqYXZhQ2xhc3M7IHRlbXBDbGFzcyAhPSBudWxsOyB0ZW1wQ2xhc3MgPSB0ZW1wQ2xhc3MuZ2V0U3VwZXJjbGFzcygpKSB7Ci0JCQlwdXNoRGVjbGFyZWRNZXRob2RzKHRlbXBDbGFzcywgc3RhY2spOwotCQl9Ci0JCUNvbGxlY3Rpb25zLnJldmVyc2Uoc3RhY2spOwotCQlyZXR1cm4gc3RhY2sudG9BcnJheShuZXcgTWV0aG9kW3N0YWNrLnNpemUoKV0pOwotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogUmV0dXJuIGEgbmV3IGluc3RhbmNlIG9mIHRoZSBzcGVjaWZpZWQgY2xhc3MsCi0JICogdXNpbmcgdGhlIGNsYXNzJ3MgZGVmYXVsdCAoemVyby1hcmd1bWVudCkgY29uc3RydWN0b3IuCi0JICogVGhyb3cgYW4gZXhjZXB0aW9uIGlmIHRoZSBkZWZhdWx0IGNvbnN0cnVjdG9yIGlzIG5vdCBkZWZpbmVkLgotCSAqIENsYXNzI25ld0luc3RhbmNlKCkgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbgotCSAqLwotCUBEZXByZWNhdGVkCi0JcHVibGljIHN0YXRpYyA8VD4gVCBhdHRlbXB0TmV3SW5zdGFuY2UoQ2xhc3M8VD4gamF2YUNsYXNzKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIGF0dGVtcHROZXdJbnN0YW5jZShqYXZhQ2xhc3MsIFpFUk9fUEFSQU1FVEVSX1RZUEVTLCBaRVJPX1BBUkFNRVRFUlMpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgaW5zdGFuY2Ugb2YgdGhlIHNwZWNpZmllZCBjbGFzcywKLQkgKiBnaXZlbiB0aGUgY29uc3RydWN0b3IgcGFyYW1ldGVyIHR5cGVzIGFuZCBwYXJhbWV0ZXJzLgotCSAqIFRocm93IGFuIGV4Y2VwdGlvbiBpZiB0aGUgY29uc3RydWN0b3IgaXMgbm90IGRlZmluZWQuCi0JICogQ2xhc3MjbmV3SW5zdGFuY2UoQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbgotCSAqLwotCXB1YmxpYyBzdGF0aWMgPFQ+IFQgYXR0ZW1wdE5ld0luc3RhbmNlKENsYXNzPFQ+IGphdmFDbGFzcywgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gY29uc3RydWN0b3IoamF2YUNsYXNzLCBwYXJhbWV0ZXJUeXBlcykubmV3SW5zdGFuY2UocGFyYW1ldGVycyk7Ci0JCX0gY2F0Y2ggKEluc3RhbnRpYXRpb25FeGNlcHRpb24gaWUpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGllICsgQ1IgKyBmdWxseVF1YWxpZmllZENvbnN0cnVjdG9yU2lnbmF0dXJlKGphdmFDbGFzcywgcGFyYW1ldGVyVHlwZXMpLCBpZSk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBY2Nlc3NFeGNlcHRpb24gaWFlKSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihpYWUgKyBDUiArIGZ1bGx5UXVhbGlmaWVkQ29uc3RydWN0b3JTaWduYXR1cmUoamF2YUNsYXNzLCBwYXJhbWV0ZXJUeXBlcyksIGlhZSk7Ci0JCX0gY2F0Y2ggKEludm9jYXRpb25UYXJnZXRFeGNlcHRpb24gaXRlKSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihmdWxseVF1YWxpZmllZENvbnN0cnVjdG9yU2lnbmF0dXJlKGphdmFDbGFzcywgcGFyYW1ldGVyVHlwZXMpICsgQ1IgKyBpdGUuZ2V0VGFyZ2V0RXhjZXB0aW9uKCksIGl0ZSk7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIFJldHVybiBhIG5ldyBpbnN0YW5jZSBvZiB0aGUgc3BlY2lmaWVkIGNsYXNzLAotCSAqIGdpdmVuIHRoZSBjb25zdHJ1Y3RvciBwYXJhbWV0ZXIgdHlwZSBhbmQgcGFyYW1ldGVyLgotCSAqIFRocm93IGFuIGV4Y2VwdGlvbiBpZiB0aGUgY29uc3RydWN0b3IgaXMgbm90IGRlZmluZWQuCi0JICogQ2xhc3MjbmV3SW5zdGFuY2UoQ2xhc3M8Pz4gcGFyYW1ldGVyVHlwZSwgT2JqZWN0IHBhcmFtZXRlcikgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbgotCSAqLwotCXB1YmxpYyBzdGF0aWMgPFQ+IFQgYXR0ZW1wdE5ld0luc3RhbmNlKENsYXNzPFQ+IGphdmFDbGFzcywgQ2xhc3M8Pz4gcGFyYW1ldGVyVHlwZSwgT2JqZWN0IHBhcmFtZXRlcikgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBhdHRlbXB0TmV3SW5zdGFuY2UoamF2YUNsYXNzLCBuZXcgQ2xhc3NbXSB7cGFyYW1ldGVyVHlwZX0sIG5ldyBPYmplY3RbXSB7cGFyYW1ldGVyfSk7Ci0JfQotCQotCS8qKgotCSAqIEF0dGVtcHQgdG8gZ2V0IGEgZmllbGQgdmFsdWUsIGdpdmVuIHRoZSBjb250YWluaW5nIG9iamVjdCBhbmQgZmllbGQgbmFtZS4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBVc2VmdWwgZm9yIGFjY2Vzc2luZyBwcml2YXRlLCBwYWNrYWdlLCBvciBwcm90ZWN0ZWQgZmllbGRzLgotCSAqIFRocm93IGFuIGV4Y2VwdGlvbiBpZiB0aGUgZmllbGQgaXMgbm90IGRlZmluZWQuCi0JICogT2JqZWN0I2dldEZpZWxkVmFsdWUoU3RyaW5nIGZpZWxkTmFtZSkgdGhyb3dzIE5vU3VjaEZpZWxkRXhjZXB0aW9uCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgYXR0ZW1wdFRvR2V0RmllbGRWYWx1ZShPYmplY3Qgb2JqZWN0LCBTdHJpbmcgZmllbGROYW1lKSB0aHJvd3MgTm9TdWNoRmllbGRFeGNlcHRpb24gewotCQl0cnkgewotCQkJcmV0dXJuIGZpZWxkKG9iamVjdCwgZmllbGROYW1lKS5nZXQob2JqZWN0KTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFjY2Vzc0V4Y2VwdGlvbiBpYWUpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGlhZSArIENSICsgZnVsbHlRdWFsaWZpZWRGaWVsZE5hbWUob2JqZWN0LCBmaWVsZE5hbWUpLCBpYWUpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIEF0dGVtcHQgdG8gZ2V0IGEgc3RhdGljIGZpZWxkIHZhbHVlLCBnaXZlbiB0aGUgY29udGFpbmluZyBvYmplY3QgYW5kIGZpZWxkIG5hbWUuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogVXNlZnVsIGZvciBhY2Nlc3NpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIGZpZWxkcy4KLQkgKiBUaHJvdyBhbiBleGNlcHRpb24gaWYgdGhlIGZpZWxkIGlzIG5vdCBkZWZpbmVkLgotCSAqIENsYXNzI2dldFN0YXRpY0ZpZWxkVmFsdWUoU3RyaW5nIGZpZWxkTmFtZSkgdGhyb3dzIE5vU3VjaEZpZWxkRXhjZXB0aW9uCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgYXR0ZW1wdFRvR2V0U3RhdGljRmllbGRWYWx1ZShDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBmaWVsZE5hbWUpIHRocm93cyBOb1N1Y2hGaWVsZEV4Y2VwdGlvbiB7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gZmllbGQoamF2YUNsYXNzLCBmaWVsZE5hbWUpLmdldChudWxsKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFjY2Vzc0V4Y2VwdGlvbiBpYWUpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGlhZSArIENSICsgZnVsbHlRdWFsaWZpZWRGaWVsZE5hbWUoamF2YUNsYXNzLCBmaWVsZE5hbWUpLCBpYWUpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBBdHRlbXB0IHRvIGV4ZWN1dGUgYSB6ZXJvLWFyZ3VtZW50IG1ldGhvZCwKLQkgKiBnaXZlbiB0aGUgcmVjZWl2ZXIgYW5kIG1ldGhvZCBuYW1lLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIFRocm93IGFuIGV4Y2VwdGlvbiBpZiB0aGUgbWV0aG9kIGlzIG5vdCBmb3VuZC4KLQkgKiBVc2VmdWwgZm9yIGludm9raW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBtZXRob2RzLgotCSAqIE9iamVjdCNleGVjdXRlKFN0cmluZyBtZXRob2ROYW1lKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgYXR0ZW1wdFRvRXhlY3V0ZU1ldGhvZChPYmplY3QgcmVjZWl2ZXIsIFN0cmluZyBtZXRob2ROYW1lKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIGF0dGVtcHRUb0V4ZWN1dGVNZXRob2QocmVjZWl2ZXIsIG1ldGhvZE5hbWUsIFpFUk9fUEFSQU1FVEVSX1RZUEVTLCBaRVJPX1BBUkFNRVRFUlMpOwotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogQXR0ZW1wdCB0byBleGVjdXRlIGEgbWV0aG9kLCBnaXZlbiB0aGUgcmVjZWl2ZXIsCi0JICogbWV0aG9kIG5hbWUsIHBhcmFtZXRlciB0eXBlLCBhbmQgcGFyYW1ldGVyLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIFRocm93IGFuIGV4Y2VwdGlvbiBpZiB0aGUgbWV0aG9kIGlzIG5vdCBmb3VuZC4KLQkgKiBVc2VmdWwgZm9yIGludm9raW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBtZXRob2RzLgotCSAqIE9iamVjdCNleGVjdXRlKFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgYXR0ZW1wdFRvRXhlY3V0ZU1ldGhvZChPYmplY3QgcmVjZWl2ZXIsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIGF0dGVtcHRUb0V4ZWN1dGVNZXRob2QocmVjZWl2ZXIsIG1ldGhvZE5hbWUsIG5ldyBDbGFzc1tdIHtwYXJhbWV0ZXJUeXBlfSwgbmV3IE9iamVjdFtdIHtwYXJhbWV0ZXJ9KTsKLQl9Ci0JCi0JLyoqCi0JICogQXR0ZW1wdCB0byBleGVjdXRlIGEgbWV0aG9kLCBnaXZlbiB0aGUgcmVjZWl2ZXIsCi0JICogbWV0aG9kIG5hbWUsIHBhcmFtZXRlciB0eXBlcywgYW5kIHBhcmFtZXRlcnMuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogVGhyb3cgYW4gZXhjZXB0aW9uIGlmIHRoZSBtZXRob2QgaXMgbm90IGZvdW5kLgotCSAqIFVzZWZ1bCBmb3IgaW52b2tpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIG1ldGhvZHMuCi0JICogT2JqZWN0I2V4ZWN1dGUoU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMsIE9iamVjdFtdIHBhcmFtZXRlcnMpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBhdHRlbXB0VG9FeGVjdXRlTWV0aG9kKE9iamVjdCByZWNlaXZlciwgU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMsIE9iamVjdFtdIHBhcmFtZXRlcnMpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24gewotCQlyZXR1cm4gZXhlY3V0ZU1ldGhvZChtZXRob2QocmVjZWl2ZXIsIG1ldGhvZE5hbWUsIHBhcmFtZXRlclR5cGVzKSwgcmVjZWl2ZXIsIHBhcmFtZXRlcnMpOwotCX0KLQkKLQkvKioKLQkgKiBBdHRlbXB0IHRvIGV4ZWN1dGUgYSBtZXRob2QsIGdpdmVuIHRoZSByZWNlaXZlciwKLQkgKiBtZXRob2QgbmFtZSwgcGFyYW1ldGVyIHR5cGVzLCBhbmQgcGFyYW1ldGVycy4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBUaHJvdyBhbiBleGNlcHRpb24gaWYgdGhlIG1ldGhvZCBpcyBub3QgZm91bmQuCi0JICogSWYgdGhlIGV4ZWN1dGVkIG1ldGhvZCB0aHJvd3MgYW4gZXhjZXB0aW9uLCByZXRocm93IHRoYXQgZXhjZXB0aW9uLgotCSAqIFVzZWZ1bCBmb3IgaW52b2tpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIG1ldGhvZHMuCi0JICogT2JqZWN0I2V4ZWN1dGUoU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMsIE9iamVjdFtdIHBhcmFtZXRlcnMpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBhdHRlbXB0VG9FeGVjdXRlTWV0aG9kV2l0aEV4Y2VwdGlvbihPYmplY3QgcmVjZWl2ZXIsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzLCBPYmplY3RbXSBwYXJhbWV0ZXJzKSAKLQkJdGhyb3dzIFRocm93YWJsZSwgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIAotCXsKLQkJcmV0dXJuIGV4ZWN1dGVNZXRob2RXaXRoRXhjZXB0aW9uKG1ldGhvZChyZWNlaXZlciwgbWV0aG9kTmFtZSwgcGFyYW1ldGVyVHlwZXMpLCByZWNlaXZlciwgcGFyYW1ldGVycyk7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBBdHRlbXB0IHRvIGV4ZWN1dGUgYSB6ZXJvLWFyZ3VtZW50IHN0YXRpYyBtZXRob2QsCi0JICogZ2l2ZW4gdGhlIGNsYXNzIGFuZCBtZXRob2QgbmFtZS4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBUaHJvdyBhbiBleGNlcHRpb24gaWYgdGhlIG1ldGhvZCBpcyBub3QgZm91bmQuCi0JICogVXNlZnVsIGZvciBpbnZva2luZyBwcml2YXRlLCBwYWNrYWdlLCBvciBwcm90ZWN0ZWQgbWV0aG9kcy4KLQkgKiBDbGFzcyNleGVjdXRlU3RhdGljTWV0aG9kKFN0cmluZyBtZXRob2ROYW1lKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgYXR0ZW1wdFRvRXhlY3V0ZVN0YXRpY01ldGhvZChDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBtZXRob2ROYW1lKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIGF0dGVtcHRUb0V4ZWN1dGVTdGF0aWNNZXRob2QoamF2YUNsYXNzLCBtZXRob2ROYW1lLCBaRVJPX1BBUkFNRVRFUl9UWVBFUywgWkVST19QQVJBTUVURVJTKTsKLQl9Ci0JCi0JLyoqCi0JICogQXR0ZW1wdCB0byBleGVjdXRlIGEgc3RhdGljIG1ldGhvZCwgZ2l2ZW4gdGhlIGNsYXNzLAotCSAqIG1ldGhvZCBuYW1lLCBwYXJhbWV0ZXIgdHlwZXMsIGFuZCBwYXJhbWV0ZXJzLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIFRocm93IGFuIGV4Y2VwdGlvbiBpZiB0aGUgbWV0aG9kIGlzIG5vdCBmb3VuZC4KLQkgKiBVc2VmdWwgZm9yIGludm9raW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBtZXRob2RzLgotCSAqIENsYXNzI2V4ZWN1dGVTdGF0aWNNZXRob2QoU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMsIE9iamVjdFtdIHBhcmFtZXRlcnMpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBhdHRlbXB0VG9FeGVjdXRlU3RhdGljTWV0aG9kKENsYXNzPD8+IGphdmFDbGFzcywgU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMsIE9iamVjdFtdIHBhcmFtZXRlcnMpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24gewotCQlyZXR1cm4gZXhlY3V0ZVN0YXRpY01ldGhvZChzdGF0aWNNZXRob2QoamF2YUNsYXNzLCBtZXRob2ROYW1lLCBwYXJhbWV0ZXJUeXBlcyksIHBhcmFtZXRlcnMpOwotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogQXR0ZW1wdCB0byBleGVjdXRlIGEgc3RhdGljIG1ldGhvZCwgZ2l2ZW4gdGhlIGNsYXNzLAotCSAqIG1ldGhvZCBuYW1lLCBwYXJhbWV0ZXIgdHlwZSwgYW5kIHBhcmFtZXRlci4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBUaHJvdyBhbiBleGNlcHRpb24gaWYgdGhlIG1ldGhvZCBpcyBub3QgZm91bmQuCi0JICogVXNlZnVsIGZvciBpbnZva2luZyBwcml2YXRlLCBwYWNrYWdlLCBvciBwcm90ZWN0ZWQgbWV0aG9kcy4KLQkgKiBDbGFzcyNleGVjdXRlU3RhdGljTWV0aG9kKFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgYXR0ZW1wdFRvRXhlY3V0ZVN0YXRpY01ldGhvZChDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIGF0dGVtcHRUb0V4ZWN1dGVTdGF0aWNNZXRob2QoamF2YUNsYXNzLCBtZXRob2ROYW1lLCBuZXcgQ2xhc3NbXSB7cGFyYW1ldGVyVHlwZX0sIG5ldyBPYmplY3RbXSB7cGFyYW1ldGVyfSk7Ci0JfQotCQotCS8qKgotCSAqIEF0dGVtcHQgdG8gc2V0IGEgZmllbGQgdmFsdWUsIGdpdmVuIHRoZQotCSAqIGNvbnRhaW5pbmcgb2JqZWN0LCBmaWVsZCBuYW1lLCBhbmQgbmV3IGZpZWxkIHZhbHVlLgotCSAqIFVzZWZ1bCBmb3IgYWNjZXNzaW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBmaWVsZHMuCi0JICogVGhyb3cgYW4gZXhjZXB0aW9uIGlmIHRoZSBmaWVsZCBpcyBub3QgZGVmaW5lZC4KLQkgKiBPYmplY3Qjc2V0RmllbGRWYWx1ZShTdHJpbmcgZmllbGROYW1lLCBPYmplY3QgZmllbGRWYWx1ZSkgdGhyb3dzIE5vU3VjaEZpZWxkRXhjZXB0aW9uCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGF0dGVtcHRUb1NldEZpZWxkVmFsdWUoT2JqZWN0IG9iamVjdCwgU3RyaW5nIGZpZWxkTmFtZSwgT2JqZWN0IGZpZWxkVmFsdWUpIHRocm93cyBOb1N1Y2hGaWVsZEV4Y2VwdGlvbiB7Ci0JCXRyeSB7Ci0JCQlmaWVsZChvYmplY3QsIGZpZWxkTmFtZSkuc2V0KG9iamVjdCwgZmllbGRWYWx1ZSk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBY2Nlc3NFeGNlcHRpb24gaWFlKSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihpYWUgKyBDUiArIGZ1bGx5UXVhbGlmaWVkRmllbGROYW1lKG9iamVjdCwgZmllbGROYW1lKSwgaWFlKTsKLQkJfQotCX0KLQkKLQkvKioKLQkgKiBBdHRlbXB0IHRvIHNldCBhIHN0YXRpYyBmaWVsZCB2YWx1ZSwgZ2l2ZW4gdGhlCi0JICogY29udGFpbmluZyBjbGFzcywgZmllbGQgbmFtZSwgYW5kIG5ldyBmaWVsZCB2YWx1ZS4KLQkgKiBVc2VmdWwgZm9yIGFjY2Vzc2luZyBwcml2YXRlLCBwYWNrYWdlLCBvciBwcm90ZWN0ZWQgZmllbGRzLgotCSAqIFRocm93IGFuIGV4Y2VwdGlvbiBpZiB0aGUgZmllbGQgaXMgbm90IGRlZmluZWQuCi0JICogQ2xhc3Mjc2V0U3RhdGljRmllbGRWYWx1ZShTdHJpbmcgZmllbGROYW1lLCBPYmplY3QgZmllbGRWYWx1ZSkgdGhyb3dzIE5vU3VjaEZpZWxkRXhjZXB0aW9uCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGF0dGVtcHRUb1NldFN0YXRpY0ZpZWxkVmFsdWUoQ2xhc3M8Pz4gamF2YUNsYXNzLCBTdHJpbmcgZmllbGROYW1lLCBPYmplY3QgZmllbGRWYWx1ZSkgdGhyb3dzIE5vU3VjaEZpZWxkRXhjZXB0aW9uIHsKLQkJdHJ5IHsKLQkJCWZpZWxkKGphdmFDbGFzcywgZmllbGROYW1lKS5zZXQobnVsbCwgZmllbGRWYWx1ZSk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBY2Nlc3NFeGNlcHRpb24gaWFlKSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihpYWUgKyBDUiArIGZ1bGx5UXVhbGlmaWVkRmllbGROYW1lKGphdmFDbGFzcywgZmllbGROYW1lKSwgaWFlKTsKLQkJfQotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogUmV0dXJuIHRoZSBkZWZhdWx0ICh6ZXJvLWFyZ3VtZW50KSBjb25zdHJ1Y3RvcgotCSAqIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzLgotCSAqIFNldCBhY2Nlc3NpYmxlIHRvIHRydWUsIHNvIHdlIGNhbiBhY2Nlc3MKLQkgKiBwcml2YXRlL3BhY2thZ2UvcHJvdGVjdGVkIGNvbnN0cnVjdG9ycy4KLQkgKiBDbGFzcyNjb25zdHJ1Y3RvcigpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24KLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxUPiBDb25zdHJ1Y3RvcjxUPiBjb25zdHJ1Y3RvcihDbGFzczxUPiBqYXZhQ2xhc3MpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24gewotCQlyZXR1cm4gY29uc3RydWN0b3IoamF2YUNsYXNzLCBaRVJPX1BBUkFNRVRFUl9UWVBFUyk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgY29uc3RydWN0b3IgZm9yIHRoZSBzcGVjaWZpZWQgY2xhc3MKLQkgKiBhbmQgZm9ybWFsIHBhcmFtZXRlciB0eXBlcy4KLQkgKiBTZXQgYWNjZXNzaWJsZSB0byB0cnVlLCBzbyB3ZSBjYW4gYWNjZXNzCi0JICogcHJpdmF0ZS9wYWNrYWdlL3Byb3RlY3RlZCBjb25zdHJ1Y3RvcnMuCi0JICogQ2xhc3MjY29uc3RydWN0b3IoQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbgotCSAqLwotCXB1YmxpYyBzdGF0aWMgPFQ+IENvbnN0cnVjdG9yPFQ+IGNvbnN0cnVjdG9yKENsYXNzPFQ+IGphdmFDbGFzcywgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCUNvbnN0cnVjdG9yPFQ+IGNvbnN0cnVjdG9yID0gamF2YUNsYXNzLmdldERlY2xhcmVkQ29uc3RydWN0b3IocGFyYW1ldGVyVHlwZXMpOwotCQljb25zdHJ1Y3Rvci5zZXRBY2Nlc3NpYmxlKHRydWUpOwotCQlyZXR1cm4gY29uc3RydWN0b3I7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBSZXR1cm4gdGhlIGNvbnN0cnVjdG9yIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzCi0JICogYW5kIGZvcm1hbCBwYXJhbWV0ZXIgdHlwZS4KLQkgKiBTZXQgYWNjZXNzaWJsZSB0byB0cnVlLCBzbyB3ZSBjYW4gYWNjZXNzCi0JICogcHJpdmF0ZS9wYWNrYWdlL3Byb3RlY3RlZCBjb25zdHJ1Y3RvcnMuCi0JICogQ2xhc3MjY29uc3RydWN0b3IoQ2xhc3M8Pz4gcGFyYW1ldGVyVHlwZSkgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbgotCSAqLwotCXB1YmxpYyBzdGF0aWMgPFQ+IENvbnN0cnVjdG9yPFQ+IGNvbnN0cnVjdG9yKENsYXNzPFQ+IGphdmFDbGFzcywgQ2xhc3M8Pz4gcGFyYW1ldGVyVHlwZSkgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBjb25zdHJ1Y3RvcihqYXZhQ2xhc3MsIG5ldyBDbGFzc1tdIHtwYXJhbWV0ZXJUeXBlfSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgZGVjbGFyZWQgZmllbGRzIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzLgotCSAqIFNldCBhY2Nlc3NpYmxlIHRvIHRydWUsIHNvIHdlIGNhbiBhY2Nlc3MKLQkgKiBwcml2YXRlL3BhY2thZ2UvcHJvdGVjdGVkIGZpZWxkcy4KLQkgKiBDbGFzcyNhY2Nlc3NpYmxlRGVjbGFyZWRGaWVsZHMoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgRmllbGRbXSBkZWNsYXJlZEZpZWxkcyhDbGFzczw/PiBqYXZhQ2xhc3MpIHsKLQkJRmllbGRbXSBmaWVsZHMgPSBqYXZhQ2xhc3MuZ2V0RGVjbGFyZWRGaWVsZHMoKTsKLQkJZm9yIChGaWVsZCBmaWVsZCA6IGZpZWxkcykgewotCQkJZmllbGQuc2V0QWNjZXNzaWJsZSh0cnVlKTsKLQkJfQotCQlyZXR1cm4gZmllbGRzOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIGRlY2xhcmVkIG1ldGhvZHMgZm9yIHRoZQotCSAqIHNwZWNpZmllZCBjbGFzcy4KLQkgKiBTZXQgYWNjZXNzaWJsZSB0byB0cnVlLCBzbyB3ZSBjYW4gYWNjZXNzCi0JICogcHJpdmF0ZS9wYWNrYWdlL3Byb3RlY3RlZCBtZXRob2RzLgotCSAqIENsYXNzI2FjY2Vzc2libGVEZWNsYXJlZE1ldGhvZHMoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgTWV0aG9kW10gZGVjbGFyZWRNZXRob2RzKENsYXNzPD8+IGphdmFDbGFzcykgewotCQlNZXRob2RbXSBtZXRob2RzID0gamF2YUNsYXNzLmdldERlY2xhcmVkTWV0aG9kcygpOwotCQlmb3IgKE1ldGhvZCBtZXRob2QgOiBtZXRob2RzKSB7Ci0JCQltZXRob2Quc2V0QWNjZXNzaWJsZSh0cnVlKTsKLQkJfQotCQlyZXR1cm4gbWV0aG9kczsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBkZWZhdWx0ICh6ZXJvLWFyZ3VtZW50KSBjb25zdHJ1Y3RvcgotCSAqIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzLgotCSAqIFNldCBhY2Nlc3NpYmxlIHRvIHRydWUsIHNvIHdlIGNhbiBhY2Nlc3MKLQkgKiBwcml2YXRlL3BhY2thZ2UvcHJvdGVjdGVkIGNvbnN0cnVjdG9ycy4KLQkgKiBDbGFzcyNkZWZhdWx0Q29uc3RydWN0b3IoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPFQ+IENvbnN0cnVjdG9yPFQ+IGRlZmF1bHRDb25zdHJ1Y3RvcihDbGFzczxUPiBqYXZhQ2xhc3MpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24gewotCQlyZXR1cm4gY29uc3RydWN0b3IoamF2YUNsYXNzKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIGEgZmllbGQgZm9yIHRoZSBzcGVjaWZpZWQgY2xhc3MgYW5kIGZpZWxkIG5hbWUuCi0JICogSWYgdGhlIGNsYXNzIGRvZXMgbm90IGRpcmVjdGx5Ci0JICogZGVmaW5lIHRoZSBmaWVsZCwgbG9vayBmb3IgaXQgaW4gdGhlIGNsYXNzJ3Mgc3VwZXJjbGFzc2VzLgotCSAqIFNldCBhY2Nlc3NpYmxlIHRvIHRydWUsIHNvIHdlIGNhbiBhY2Nlc3MKLQkgKiBwcml2YXRlL3BhY2thZ2UvcHJvdGVjdGVkIGZpZWxkcy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEZpZWxkIGZpZWxkKENsYXNzPD8+IGphdmFDbGFzcywgU3RyaW5nIGZpZWxkTmFtZSkgdGhyb3dzIE5vU3VjaEZpZWxkRXhjZXB0aW9uIHsKLQkJRmllbGQgZmllbGQgPSBudWxsOwotCQl0cnkgewotCQkJZmllbGQgPSBqYXZhQ2xhc3MuZ2V0RGVjbGFyZWRGaWVsZChmaWVsZE5hbWUpOwotCQl9IGNhdGNoIChOb1N1Y2hGaWVsZEV4Y2VwdGlvbiBleCkgewotCQkJQ2xhc3M8Pz4gc3VwZXJjbGFzcyA9IGphdmFDbGFzcy5nZXRTdXBlcmNsYXNzKCk7Ci0JCQlpZiAoc3VwZXJjbGFzcyA9PSBudWxsKSB7Ci0JCQkJdGhyb3cgZXg7Ci0JCQl9Ci0JCQkvLyByZWN1cnNlCi0JCQlyZXR1cm4gZmllbGQoc3VwZXJjbGFzcywgZmllbGROYW1lKTsKLQkJfQotCQlmaWVsZC5zZXRBY2Nlc3NpYmxlKHRydWUpOwotCQlyZXR1cm4gZmllbGQ7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBSZXR1cm4gYSBmaWVsZCBmb3IgdGhlIHNwZWNpZmllZCBvYmplY3QgYW5kIGZpZWxkIG5hbWUuCi0JICogSWYgdGhlIG9iamVjdCdzIGNsYXNzIGRvZXMgbm90IGRpcmVjdGx5Ci0JICogZGVmaW5lIHRoZSBmaWVsZCwgbG9vayBmb3IgaXQgaW4gdGhlIGNsYXNzJ3Mgc3VwZXJjbGFzc2VzLgotCSAqIFNldCBhY2Nlc3NpYmxlIHRvIHRydWUsIHNvIHdlIGNhbiBhY2Nlc3MKLQkgKiBwcml2YXRlL3BhY2thZ2UvcHJvdGVjdGVkIGZpZWxkcy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIEZpZWxkIGZpZWxkKE9iamVjdCBvYmplY3QsIFN0cmluZyBmaWVsZE5hbWUpIHRocm93cyBOb1N1Y2hGaWVsZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBmaWVsZChvYmplY3QuZ2V0Q2xhc3MoKSwgZmllbGROYW1lKTsKLQl9Ci0JCi0JLyoKLQkgKiBSZXR1cm4gYSBzdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgdGhlIHNwZWNpZmllZCBjb25zdHJ1Y3Rvci4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBTdHJpbmcgZnVsbHlRdWFsaWZpZWRDb25zdHJ1Y3RvclNpZ25hdHVyZShDbGFzczw/PiBqYXZhQ2xhc3MsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMpIHsKLQkJcmV0dXJuIGZ1bGx5UXVhbGlmaWVkTWV0aG9kU2lnbmF0dXJlKGphdmFDbGFzcywgbnVsbCwgcGFyYW1ldGVyVHlwZXMpOwotCX0KLQkKLQkvKgotCSAqIFJldHVybiBhIHN0cmluZyByZXByZXNlbnRhdGlvbiBvZiB0aGUgc3BlY2lmaWVkIGZpZWxkLgotCSAqLwotCXByaXZhdGUgc3RhdGljIFN0cmluZyBmdWxseVF1YWxpZmllZEZpZWxkTmFtZShDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBmaWVsZE5hbWUpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDIwMCk7Ci0JCXNiLmFwcGVuZChqYXZhQ2xhc3MuZ2V0TmFtZSgpKTsKLQkJc2IuYXBwZW5kKCcuJyk7Ci0JCXNiLmFwcGVuZChmaWVsZE5hbWUpOwotCQlyZXR1cm4gc2IudG9TdHJpbmcoKTsKLQl9Ci0JCi0JLyoKLQkgKiBSZXR1cm4gYSBzdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgdGhlIHNwZWNpZmllZCBmaWVsZC4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBTdHJpbmcgZnVsbHlRdWFsaWZpZWRGaWVsZE5hbWUoT2JqZWN0IG9iamVjdCwgU3RyaW5nIGZpZWxkTmFtZSkgewotCQlyZXR1cm4gZnVsbHlRdWFsaWZpZWRGaWVsZE5hbWUob2JqZWN0LmdldENsYXNzKCksIGZpZWxkTmFtZSk7Ci0JfQotCQotCS8qCi0JICogUmV0dXJuIGEgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBzcGVjaWZpZWQgbWV0aG9kLgotCSAqLwotCXByaXZhdGUgc3RhdGljIFN0cmluZyBmdWxseVF1YWxpZmllZE1ldGhvZFNpZ25hdHVyZShDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigyMDApOwotCQlzYi5hcHBlbmQoamF2YUNsYXNzLmdldE5hbWUoKSk7Ci0JCS8vIHRoaXMgY2hlY2sgYWxsb3dzIHVzIHRvIHVzZSB0aGlzIGNvZGUgZm9yIGNvbnN0cnVjdG9ycywgd2hlcmUgdGhlIG1ldGhvZE5hbWUgaXMgbnVsbAotCQlpZiAobWV0aG9kTmFtZSAhPSBudWxsKSB7Ci0JCQlzYi5hcHBlbmQoJy4nKTsKLQkJCXNiLmFwcGVuZChtZXRob2ROYW1lKTsKLQkJfQotCQlzYi5hcHBlbmQoJygnKTsKLQkJaW50IG1heCA9IHBhcmFtZXRlclR5cGVzLmxlbmd0aCAtIDE7Ci0JCWlmIChtYXggIT0gLTEpIHsKLQkJCS8vIHN0b3Agb25lIHNob3J0IG9mIHRoZSBlbmQgb2YgdGhlIGFycmF5Ci0JCQlmb3IgKGludCBpID0gMDsgaSA8IG1heDsgaSsrKSB7Ci0JCQkJc2IuYXBwZW5kKHBhcmFtZXRlclR5cGVzW2ldLmdldE5hbWUoKSk7Ci0JCQkJc2IuYXBwZW5kKCIsICIpOwotCQkJfQotCQkJc2IuYXBwZW5kKHBhcmFtZXRlclR5cGVzW21heF0uZ2V0TmFtZSgpKTsKLQkJfQotCQlzYi5hcHBlbmQoJyknKTsKLQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7Ci0JfQotCQotCS8qCi0JICogUmV0dXJuIGEgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBzcGVjaWZpZWQgbWV0aG9kLgotCSAqLwotCXByaXZhdGUgc3RhdGljIFN0cmluZyBmdWxseVF1YWxpZmllZE1ldGhvZFNpZ25hdHVyZShPYmplY3QgcmVjZWl2ZXIsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzKSB7Ci0JCXJldHVybiBmdWxseVF1YWxpZmllZE1ldGhvZFNpZ25hdHVyZShyZWNlaXZlci5nZXRDbGFzcygpLCBtZXRob2ROYW1lLCBwYXJhbWV0ZXJUeXBlcyk7Ci0JfQotCQotCS8qKgotCSAqIEdldCBhIGZpZWxkIHZhbHVlLCBnaXZlbiB0aGUgY29udGFpbmluZyBvYmplY3QgYW5kIGZpZWxkIG5hbWUuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogVXNlZnVsIGZvciBhY2Nlc3NpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIGZpZWxkcy4KLQkgKiBPYmplY3QjZ2V0RmllbGRWYWx1ZShTdHJpbmcgZmllbGROYW1lKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IGZpZWxkVmFsdWUoT2JqZWN0IG9iamVjdCwgU3RyaW5nIGZpZWxkTmFtZSkgewotCQl0cnkgewotCQkJcmV0dXJuIGF0dGVtcHRUb0dldEZpZWxkVmFsdWUob2JqZWN0LCBmaWVsZE5hbWUpOwotCQl9IGNhdGNoIChOb1N1Y2hGaWVsZEV4Y2VwdGlvbiBuc2ZlKSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihuc2ZlICsgQ1IgKyBmdWxseVF1YWxpZmllZEZpZWxkTmFtZShvYmplY3QsIGZpZWxkTmFtZSksIG5zZmUpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIEdldCBhIHN0YXRpYyBmaWVsZCB2YWx1ZSwgZ2l2ZW4gdGhlIGNvbnRhaW5pbmcgY2xhc3MgYW5kIGZpZWxkIG5hbWUuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogVXNlZnVsIGZvciBhY2Nlc3NpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIGZpZWxkcy4KLQkgKiBDbGFzcyNnZXRTdGF0aWNGaWVsZFZhbHVlKFN0cmluZyBmaWVsZE5hbWUpCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3Qgc3RhdGljRmllbGRWYWx1ZShDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBmaWVsZE5hbWUpIHsKLQkJdHJ5IHsKLQkJCXJldHVybiBhdHRlbXB0VG9HZXRTdGF0aWNGaWVsZFZhbHVlKGphdmFDbGFzcywgZmllbGROYW1lKTsKLQkJfSBjYXRjaCAoTm9TdWNoRmllbGRFeGNlcHRpb24gbnNmZSkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24obnNmZSArIENSICsgZnVsbHlRdWFsaWZpZWRGaWVsZE5hbWUoamF2YUNsYXNzLCBmaWVsZE5hbWUpLCBuc2ZlKTsKLQkJfQotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogRXhlY3V0ZSBhIHplcm8tYXJndW1lbnQgbWV0aG9kLCBnaXZlbiB0aGUgcmVjZWl2ZXIgYW5kIG1ldGhvZCBuYW1lLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIFVzZWZ1bCBmb3IgaW52b2tpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIG1ldGhvZHMuCi0JICogT2JqZWN0I2V4ZWN1dGUoU3RyaW5nIG1ldGhvZE5hbWUpCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgZXhlY3V0ZU1ldGhvZChPYmplY3QgcmVjZWl2ZXIsIFN0cmluZyBtZXRob2ROYW1lKSB7Ci0JCXJldHVybiBleGVjdXRlTWV0aG9kKHJlY2VpdmVyLCBtZXRob2ROYW1lLCBaRVJPX1BBUkFNRVRFUl9UWVBFUywgWkVST19QQVJBTUVURVJTKTsKLQl9Ci0JCi0JLyoqCi0JICogRXhlY3V0ZSBhIG1ldGhvZCwgZ2l2ZW4gdGhlIHJlY2VpdmVyLAotCSAqIG1ldGhvZCBuYW1lLCBwYXJhbWV0ZXIgdHlwZXMsIGFuZCBwYXJhbWV0ZXJzLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIFVzZWZ1bCBmb3IgaW52b2tpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIG1ldGhvZHMuCi0JICogT2JqZWN0I2V4ZWN1dGUoU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMsIE9iamVjdFtdIHBhcmFtZXRlcnMpCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgZXhlY3V0ZU1ldGhvZChPYmplY3QgcmVjZWl2ZXIsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzLCBPYmplY3RbXSBwYXJhbWV0ZXJzKSB7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gYXR0ZW1wdFRvRXhlY3V0ZU1ldGhvZChyZWNlaXZlciwgbWV0aG9kTmFtZSwgcGFyYW1ldGVyVHlwZXMsIHBhcmFtZXRlcnMpOwotCQl9IGNhdGNoIChOb1N1Y2hNZXRob2RFeGNlcHRpb24gbnNtZSkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24obnNtZSArIENSICsgZnVsbHlRdWFsaWZpZWRNZXRob2RTaWduYXR1cmUocmVjZWl2ZXIsIG1ldGhvZE5hbWUsIHBhcmFtZXRlclR5cGVzKSwgbnNtZSk7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIEV4ZWN1dGUgYSBvbmUtYXJndW1lbnQgbWV0aG9kLCBnaXZlbiB0aGUgcmVjZWl2ZXIsCi0JICogbWV0aG9kIG5hbWUsIHBhcmFtZXRlciB0eXBlLCBhbmQgcGFyYW1ldGVyLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIFVzZWZ1bCBmb3IgaW52b2tpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIG1ldGhvZHMuCi0JICogT2JqZWN0I2V4ZWN1dGUoU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+IHBhcmFtZXRlclR5cGUsIE9iamVjdCBwYXJhbWV0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgZXhlY3V0ZU1ldGhvZChPYmplY3QgcmVjZWl2ZXIsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKSB7Ci0JCXJldHVybiBleGVjdXRlTWV0aG9kKHJlY2VpdmVyLCBtZXRob2ROYW1lLCBuZXcgQ2xhc3NbXSB7cGFyYW1ldGVyVHlwZX0sIG5ldyBPYmplY3RbXSB7cGFyYW1ldGVyfSk7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBFeGVjdXRlIGEgemVyby1hcmd1bWVudCBtZXRob2QsIGdpdmVuIHRoZSByZWNlaXZlciBhbmQgbWV0aG9kIG5hbWUuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogSWYgdGhlIG1ldGhvZCB0aHJvd3MgYW4gZXhjZXB0aW9uLCByZXRocm93IHRoYXQgZXhjZXB0aW9uLgotCSAqIFVzZWZ1bCBmb3IgaW52b2tpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIG1ldGhvZHMuCi0JICogT2JqZWN0I2V4ZWN1dGUoU3RyaW5nIG1ldGhvZE5hbWUpCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgZXhlY3V0ZU1ldGhvZFdpdGhFeGNlcHRpb24oT2JqZWN0IHJlY2VpdmVyLCBTdHJpbmcgbWV0aG9kTmFtZSkgCi0JCXRocm93cyBUaHJvd2FibGUKLQl7Ci0JCXJldHVybiBleGVjdXRlTWV0aG9kV2l0aEV4Y2VwdGlvbihyZWNlaXZlciwgbWV0aG9kTmFtZSwgWkVST19QQVJBTUVURVJfVFlQRVMsIFpFUk9fUEFSQU1FVEVSUyk7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBFeGVjdXRlIGEgb25lLWFyZ3VtZW50IG1ldGhvZCwgZ2l2ZW4gdGhlIHJlY2VpdmVyLAotCSAqIG1ldGhvZCBuYW1lLCBwYXJhbWV0ZXIgdHlwZSwgYW5kIHBhcmFtZXRlci4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBJZiB0aGUgbWV0aG9kIHRocm93cyBhbiBleGNlcHRpb24sIHJldGhyb3cgdGhhdCBleGNlcHRpb24uCi0JICogVXNlZnVsIGZvciBpbnZva2luZyBwcml2YXRlLCBwYWNrYWdlLCBvciBwcm90ZWN0ZWQgbWV0aG9kcy4KLQkgKiBPYmplY3QjZXhlY3V0ZShTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz4gcGFyYW1ldGVyVHlwZSwgT2JqZWN0IHBhcmFtZXRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBleGVjdXRlTWV0aG9kV2l0aEV4Y2VwdGlvbihPYmplY3QgcmVjZWl2ZXIsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKSAKLQkJdGhyb3dzIFRocm93YWJsZQotCXsKLQkJcmV0dXJuIGV4ZWN1dGVNZXRob2RXaXRoRXhjZXB0aW9uKHJlY2VpdmVyLCBtZXRob2ROYW1lLCBuZXcgQ2xhc3NbXSB7cGFyYW1ldGVyVHlwZX0sIG5ldyBPYmplY3RbXSB7cGFyYW1ldGVyfSk7Ci0JfQotCQotCS8qKgotCSAqIEV4ZWN1dGUgYSBtZXRob2QsIGdpdmVuIHRoZSByZWNlaXZlciwKLQkgKiBtZXRob2QgbmFtZSwgcGFyYW1ldGVyIHR5cGVzLCBhbmQgcGFyYW1ldGVycy4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBJZiB0aGUgbWV0aG9kIHRocm93cyBhbiBleGNlcHRpb24sIHJldGhyb3cgdGhhdCBleGNlcHRpb24uCi0JICogVXNlZnVsIGZvciBpbnZva2luZyBwcml2YXRlLCBwYWNrYWdlLCBvciBwcm90ZWN0ZWQgbWV0aG9kcy4KLQkgKiBPYmplY3QjZXhlY3V0ZShTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBleGVjdXRlTWV0aG9kV2l0aEV4Y2VwdGlvbihPYmplY3QgcmVjZWl2ZXIsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzLCBPYmplY3RbXSBwYXJhbWV0ZXJzKSAKLQkJdGhyb3dzIFRocm93YWJsZQotCXsKLQkJdHJ5IHsKLQkJCXJldHVybiBhdHRlbXB0VG9FeGVjdXRlTWV0aG9kV2l0aEV4Y2VwdGlvbihyZWNlaXZlciwgbWV0aG9kTmFtZSwgcGFyYW1ldGVyVHlwZXMsIHBhcmFtZXRlcnMpOwotCQl9IGNhdGNoIChOb1N1Y2hNZXRob2RFeGNlcHRpb24gbnNtZSkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24obnNtZSArIENSICsgZnVsbHlRdWFsaWZpZWRNZXRob2RTaWduYXR1cmUocmVjZWl2ZXIsIG1ldGhvZE5hbWUsIHBhcmFtZXRlclR5cGVzKSwgbnNtZSk7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogRXhlY3V0ZSB0aGUgc3BlY2lmaWVkIG1ldGhvZCB3aXRoIHRoZSBzcGVjaWZpZWQgcGFyYW1ldGVycy4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBDb252ZXJ0IGV4Y2VwdGlvbnMgdG8gUnVudGltZUV4Y2VwdGlvbnMuCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgZXhlY3V0ZU1ldGhvZChNZXRob2QgbWV0aG9kLCBPYmplY3QgcmVjZWl2ZXIsIE9iamVjdFtdIHBhcmFtZXRlcnMpIHsKLQkJdHJ5IHsKLQkJCXJldHVybiBtZXRob2QuaW52b2tlKHJlY2VpdmVyLCBwYXJhbWV0ZXJzKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFjY2Vzc0V4Y2VwdGlvbiBpYWUpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGlhZSArIENSICsgbWV0aG9kLCBpYWUpOwotCQl9IGNhdGNoIChJbnZvY2F0aW9uVGFyZ2V0RXhjZXB0aW9uIGl0ZSkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24obWV0aG9kICsgQ1IgKyBpdGUuZ2V0VGFyZ2V0RXhjZXB0aW9uKCksIGl0ZSk7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogRXhlY3V0ZSB0aGUgc3BlY2lmaWVkIG1ldGhvZCB3aXRoIHRoZSBzcGVjaWZpZWQgcGFyYW1ldGVycy4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBJZiB0aGUgbWV0aG9kIHRocm93cyBhbiBleGNlcHRpb24sIHJldGhyb3cgdGhhdCBleGNlcHRpb24uCi0JICogQ29udmVydCBhbGwgb3RoZXIgZXhjZXB0aW9ucyB0byBSdW50aW1lRXhjZXB0aW9ucy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBleGVjdXRlTWV0aG9kV2l0aEV4Y2VwdGlvbihNZXRob2QgbWV0aG9kLCBPYmplY3QgcmVjZWl2ZXIsIE9iamVjdFtdIHBhcmFtZXRlcnMpCi0JCXRocm93cyBUaHJvd2FibGUKLQl7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gbWV0aG9kLmludm9rZShyZWNlaXZlciwgcGFyYW1ldGVycyk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBY2Nlc3NFeGNlcHRpb24gaWFlKSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihpYWUgKyBDUiArIG1ldGhvZCwgaWFlKTsKLQkJfSBjYXRjaCAoSW52b2NhdGlvblRhcmdldEV4Y2VwdGlvbiBpdGUpIHsKLQkJCVRocm93YWJsZSBjYXVzZSA9IGl0ZS5nZXRDYXVzZSgpOwotCQkJaWYgKGNhdXNlID09IG51bGwpIHsKLQkJCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihtZXRob2QudG9TdHJpbmcoKSwgaXRlKTsKLQkJCX0KLQkJCXRocm93IGNhdXNlOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBFeGVjdXRlIGEgemVyby1hcmd1bWVudCBzdGF0aWMgbWV0aG9kLAotCSAqIGdpdmVuIHRoZSBjbGFzcyBhbmQgbWV0aG9kIG5hbWUuCi0JICogUmV0dXJuIGl0cyByZXN1bHQuCi0JICogVXNlZnVsIGZvciBpbnZva2luZyBwcml2YXRlLCBwYWNrYWdlLCBvciBwcm90ZWN0ZWQgbWV0aG9kcy4KLQkgKiBDbGFzcyNleGVjdXRlU3RhdGljTWV0aG9kKFN0cmluZyBtZXRob2ROYW1lKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IGV4ZWN1dGVTdGF0aWNNZXRob2QoQ2xhc3M8Pz4gamF2YUNsYXNzLCBTdHJpbmcgbWV0aG9kTmFtZSkgewotCQlyZXR1cm4gZXhlY3V0ZVN0YXRpY01ldGhvZChqYXZhQ2xhc3MsIG1ldGhvZE5hbWUsIFpFUk9fUEFSQU1FVEVSX1RZUEVTLCBaRVJPX1BBUkFNRVRFUlMpOwotCX0KLQkKLQkvKioKLQkgKiBFeGVjdXRlIGEgc3RhdGljIG1ldGhvZCwgZ2l2ZW4gdGhlIGNsYXNzLAotCSAqIG1ldGhvZCBuYW1lLCBwYXJhbWV0ZXIgdHlwZXMsIGFuZCBwYXJhbWV0ZXJzLgotCSAqIFJldHVybiBpdHMgcmVzdWx0LgotCSAqIFVzZWZ1bCBmb3IgaW52b2tpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIG1ldGhvZHMuCi0JICogQ2xhc3MjZXhlY3V0ZVN0YXRpY01ldGhvZChTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycykKLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBleGVjdXRlU3RhdGljTWV0aG9kKENsYXNzPD8+IGphdmFDbGFzcywgU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMsIE9iamVjdFtdIHBhcmFtZXRlcnMpIHsKLQkJdHJ5IHsKLQkJCXJldHVybiBhdHRlbXB0VG9FeGVjdXRlU3RhdGljTWV0aG9kKGphdmFDbGFzcywgbWV0aG9kTmFtZSwgcGFyYW1ldGVyVHlwZXMsIHBhcmFtZXRlcnMpOwotCQl9IGNhdGNoIChOb1N1Y2hNZXRob2RFeGNlcHRpb24gbnNtZSkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24obnNtZSArIENSICsgZnVsbHlRdWFsaWZpZWRNZXRob2RTaWduYXR1cmUoamF2YUNsYXNzLCBtZXRob2ROYW1lLCBwYXJhbWV0ZXJUeXBlcyksIG5zbWUpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBFeGVjdXRlIGEgc3RhdGljIG1ldGhvZCwgZ2l2ZW4gdGhlIGNsYXNzLAotCSAqIG1ldGhvZCBuYW1lLCBwYXJhbWV0ZXIgdHlwZSwgYW5kIHBhcmFtZXRlci4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBVc2VmdWwgZm9yIGludm9raW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBtZXRob2RzLgotCSAqIENsYXNzI2V4ZWN1dGVTdGF0aWNNZXRob2QoU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+IHBhcmFtZXRlclR5cGUsIE9iamVjdCBwYXJhbWV0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgZXhlY3V0ZVN0YXRpY01ldGhvZChDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKSB7Ci0JCXJldHVybiBleGVjdXRlU3RhdGljTWV0aG9kKGphdmFDbGFzcywgbWV0aG9kTmFtZSwgbmV3IENsYXNzW10ge3BhcmFtZXRlclR5cGV9LCBuZXcgT2JqZWN0W10ge3BhcmFtZXRlcn0pOwotCX0KLQkKLQkvKioKLQkgKiBFeGVjdXRlIHRoZSBzcGVjaWZpZWQgc3RhdGljIG1ldGhvZCB3aXRoIHRoZSBzcGVjaWZpZWQgcGFyYW1ldGVycy4KLQkgKiBSZXR1cm4gaXRzIHJlc3VsdC4KLQkgKiBDb252ZXJ0IGV4Y2VwdGlvbnMgdG8gUnVudGltZUV4Y2VwdGlvbnMuCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgZXhlY3V0ZVN0YXRpY01ldGhvZChNZXRob2QgbWV0aG9kLCBPYmplY3RbXSBwYXJhbWV0ZXJzKSB7Ci0JCXJldHVybiBleGVjdXRlTWV0aG9kKG1ldGhvZCwgbnVsbCwgcGFyYW1ldGVycyk7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBSZXR1cm4gYSB6ZXJvLWFyZ3VtZW50IG1ldGhvZCBmb3IgdGhlIHNwZWNpZmllZCBjbGFzcwotCSAqIGFuZCBtZXRob2QgbmFtZS4gSWYgdGhlIGNsYXNzIGRvZXMgbm90IGRpcmVjdGx5Ci0JICogaW1wbGVtZW50IHRoZSBtZXRob2QsIGxvb2sgZm9yIGl0IGluIHRoZSBjbGFzcydzIHN1cGVyY2xhc3Nlcy4KLQkgKiBTZXQgYWNjZXNzaWJsZSB0byB0cnVlLCBzbyB3ZSBjYW4gYWNjZXNzCi0JICogcHJpdmF0ZS9wYWNrYWdlL3Byb3RlY3RlZCBtZXRob2RzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgTWV0aG9kIG1ldGhvZChDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBtZXRob2ROYW1lKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIG1ldGhvZChqYXZhQ2xhc3MsIG1ldGhvZE5hbWUsIFpFUk9fUEFSQU1FVEVSX1RZUEVTKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIGEgbWV0aG9kIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzLCBtZXRob2QgbmFtZSwKLQkgKiBhbmQgZm9ybWFsIHBhcmFtZXRlciB0eXBlcy4gSWYgdGhlIGNsYXNzIGRvZXMgbm90IGRpcmVjdGx5Ci0JICogaW1wbGVtZW50IHRoZSBtZXRob2QsIGxvb2sgZm9yIGl0IGluIHRoZSBjbGFzcydzIHN1cGVyY2xhc3Nlcy4KLQkgKiBTZXQgYWNjZXNzaWJsZSB0byB0cnVlLCBzbyB3ZSBjYW4gYWNjZXNzCi0JICogcHJpdmF0ZS9wYWNrYWdlL3Byb3RlY3RlZCBtZXRob2RzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgTWV0aG9kIG1ldGhvZChDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJTWV0aG9kIG1ldGhvZCA9IG51bGw7Ci0JCXRyeSB7Ci0JCQltZXRob2QgPSBqYXZhQ2xhc3MuZ2V0RGVjbGFyZWRNZXRob2QobWV0aG9kTmFtZSwgcGFyYW1ldGVyVHlwZXMpOwotCQl9IGNhdGNoIChOb1N1Y2hNZXRob2RFeGNlcHRpb24gZXgpIHsKLQkJCUNsYXNzPD8+IHN1cGVyY2xhc3MgPSBqYXZhQ2xhc3MuZ2V0U3VwZXJjbGFzcygpOwotCQkJaWYgKHN1cGVyY2xhc3MgPT0gbnVsbCkgewotCQkJCXRocm93IGV4OwotCQkJfQotCQkJLy8gcmVjdXJzZQotCQkJcmV0dXJuIG1ldGhvZChzdXBlcmNsYXNzLCBtZXRob2ROYW1lLCBwYXJhbWV0ZXJUeXBlcyk7Ci0JCX0KLQkJbWV0aG9kLnNldEFjY2Vzc2libGUodHJ1ZSk7Ci0JCXJldHVybiBtZXRob2Q7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBSZXR1cm4gYSBtZXRob2QgZm9yIHRoZSBzcGVjaWZpZWQgY2xhc3MsIG1ldGhvZCBuYW1lLAotCSAqIGFuZCBmb3JtYWwgcGFyYW1ldGVyIHR5cGUuIElmIHRoZSBjbGFzcyBkb2VzIG5vdCBkaXJlY3RseQotCSAqIGltcGxlbWVudCB0aGUgbWV0aG9kLCBsb29rIGZvciBpdCBpbiB0aGUgY2xhc3MncyBzdXBlcmNsYXNzZXMuCi0JICogU2V0IGFjY2Vzc2libGUgdG8gdHJ1ZSwgc28gd2UgY2FuIGFjY2VzcwotCSAqIHByaXZhdGUvcGFja2FnZS9wcm90ZWN0ZWQgbWV0aG9kcy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE1ldGhvZCBtZXRob2QoQ2xhc3M8Pz4gamF2YUNsYXNzLCBTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz4gcGFyYW1ldGVyVHlwZSkgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBtZXRob2QoamF2YUNsYXNzLCBtZXRob2ROYW1lLCBuZXcgQ2xhc3NbXSB7cGFyYW1ldGVyVHlwZX0pOwotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogUmV0dXJuIGEgemVyby1hcmd1bWVudCBtZXRob2QgZm9yIHRoZSBzcGVjaWZpZWQgb2JqZWN0Ci0JICogYW5kIG1ldGhvZCBuYW1lLiBJZiB0aGUgb2JqZWN0J3MgY2xhc3MgZG9lcyBub3QgZGlyZWN0bHkKLQkgKiBpbXBsZW1lbnQgdGhlIG1ldGhvZCwgbG9vayBmb3IgaXQgaW4gdGhlIGNsYXNzJ3Mgc3VwZXJjbGFzc2VzLgotCSAqIFNldCBhY2Nlc3NpYmxlIHRvIHRydWUsIHNvIHdlIGNhbiBhY2Nlc3MKLQkgKiBwcml2YXRlL3BhY2thZ2UvcHJvdGVjdGVkIG1ldGhvZHMuCi0JICovCi0JcHVibGljIHN0YXRpYyBNZXRob2QgbWV0aG9kKE9iamVjdCBvYmplY3QsIFN0cmluZyBtZXRob2ROYW1lKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIG1ldGhvZChvYmplY3QuZ2V0Q2xhc3MoKSwgbWV0aG9kTmFtZSk7Ci0JfQotCQotCS8qKgotCSAqIENvbnZlbmllbmNlIG1ldGhvZC4KLQkgKiBSZXR1cm4gYSBtZXRob2QgZm9yIHRoZSBzcGVjaWZpZWQgb2JqZWN0LCBtZXRob2QgbmFtZSwKLQkgKiBhbmQgZm9ybWFsIHBhcmFtZXRlciB0eXBlcy4gSWYgdGhlIG9iamVjdCdzIGNsYXNzIGRvZXMgbm90IGRpcmVjdGx5Ci0JICogaW1wbGVtZW50IHRoZSBtZXRob2QsIGxvb2sgZm9yIGl0IGluIHRoZSBjbGFzcydzIHN1cGVyY2xhc3Nlcy4KLQkgKiBTZXQgYWNjZXNzaWJsZSB0byB0cnVlLCBzbyB3ZSBjYW4gYWNjZXNzCi0JICogcHJpdmF0ZS9wYWNrYWdlL3Byb3RlY3RlZCBtZXRob2RzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgTWV0aG9kIG1ldGhvZChPYmplY3Qgb2JqZWN0LCBTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBtZXRob2Qob2JqZWN0LmdldENsYXNzKCksIG1ldGhvZE5hbWUsIHBhcmFtZXRlclR5cGVzKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIFJldHVybiBhIG1ldGhvZCBmb3IgdGhlIHNwZWNpZmllZCBvYmplY3QsIG1ldGhvZCBuYW1lLAotCSAqIGFuZCBmb3JtYWwgcGFyYW1ldGVyIHR5cGUuIElmIHRoZSBvYmplY3QncyBjbGFzcyBkb2VzIG5vdCBkaXJlY3RseQotCSAqIGltcGxlbWVudCB0aGUgbWV0aG9kLCBsb29rIGZvciBpdCBpbiB0aGUgY2xhc3MncyBzdXBlcmNsYXNzZXMuCi0JICogU2V0IGFjY2Vzc2libGUgdG8gdHJ1ZSwgc28gd2UgY2FuIGFjY2VzcwotCSAqIHByaXZhdGUvcGFja2FnZS9wcm90ZWN0ZWQgbWV0aG9kcy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE1ldGhvZCBtZXRob2QoT2JqZWN0IG9iamVjdCwgU3RyaW5nIG1ldGhvZE5hbWUsIENsYXNzPD8+IHBhcmFtZXRlclR5cGUpIHRocm93cyBOb1N1Y2hNZXRob2RFeGNlcHRpb24gewotCQlyZXR1cm4gbWV0aG9kKG9iamVjdC5nZXRDbGFzcygpLCBtZXRob2ROYW1lLCBwYXJhbWV0ZXJUeXBlKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIFJldHVybiB0aGUgc3BlY2lmaWVkIGNsYXNzICh3aXRob3V0IHRoZSBjaGVja2VkIGV4Y2VwdGlvbikuCi0JICovCi0JcHVibGljIHN0YXRpYyBDbGFzczw/PiBjbGFzc0Zvck5hbWUoU3RyaW5nIGNsYXNzTmFtZSkgewotCQl0cnkgewotCQkJcmV0dXJuIENsYXNzLmZvck5hbWUoY2xhc3NOYW1lKTsKLQkJfSBjYXRjaCAoQ2xhc3NOb3RGb3VuZEV4Y2VwdGlvbiBleCkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oY2xhc3NOYW1lLCBleCk7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIFJldHVybiBhIG5ldyBpbnN0YW5jZSBvZiB0aGUgc3BlY2lmaWVkIGNsYXNzLAotCSAqIHVzaW5nIHRoZSBjbGFzcydzIGRlZmF1bHQgKHplcm8tYXJndW1lbnQpIGNvbnN0cnVjdG9yLgotCSAqIENsYXNzI25ld0luc3RhbmNlKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIDxUPiBUIG5ld0luc3RhbmNlKENsYXNzPFQ+IGphdmFDbGFzcykgewotCQlyZXR1cm4gbmV3SW5zdGFuY2UoamF2YUNsYXNzLCBaRVJPX1BBUkFNRVRFUl9UWVBFUywgWkVST19QQVJBTUVURVJTKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIFJldHVybiBhIG5ldyBpbnN0YW5jZSBvZiB0aGUgc3BlY2lmaWVkIGNsYXNzLAotCSAqIHVzaW5nIHRoZSBjbGFzcydzIGRlZmF1bHQgKHplcm8tYXJndW1lbnQpIGNvbnN0cnVjdG9yLgotCSAqIENsYXNzI25ld0luc3RhbmNlKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBuZXdJbnN0YW5jZShTdHJpbmcgY2xhc3NOYW1lKSB0aHJvd3MgQ2xhc3NOb3RGb3VuZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBuZXdJbnN0YW5jZShjbGFzc05hbWUsIG51bGwpOwotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogUmV0dXJuIGEgbmV3IGluc3RhbmNlIG9mIHRoZSBzcGVjaWZpZWQgY2xhc3MsCi0JICogdXNpbmcgdGhlIGNsYXNzJ3MgZGVmYXVsdCAoemVyby1hcmd1bWVudCkgY29uc3RydWN0b3IuCi0JICogQ2xhc3MjbmV3SW5zdGFuY2UoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IG5ld0luc3RhbmNlKFN0cmluZyBjbGFzc05hbWUsIENsYXNzTG9hZGVyIGNsYXNzTG9hZGVyKSB0aHJvd3MgQ2xhc3NOb3RGb3VuZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBuZXdJbnN0YW5jZShDbGFzcy5mb3JOYW1lKGNsYXNzTmFtZSwgdHJ1ZSwgY2xhc3NMb2FkZXIpKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIGEgbmV3IGluc3RhbmNlIG9mIHRoZSBzcGVjaWZpZWQgY2xhc3MsCi0JICogZ2l2ZW4gdGhlIGNvbnN0cnVjdG9yIHBhcmFtZXRlciB0eXBlcyBhbmQgcGFyYW1ldGVycy4KLQkgKiBDbGFzcyNuZXdJbnN0YW5jZShDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzLCBPYmplY3RbXSBwYXJhbWV0ZXJzKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgPFQ+IFQgbmV3SW5zdGFuY2UoQ2xhc3M8VD4gamF2YUNsYXNzLCBDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzLCBPYmplY3RbXSBwYXJhbWV0ZXJzKSB7Ci0JCXRyeSB7Ci0JCQlyZXR1cm4gYXR0ZW1wdE5ld0luc3RhbmNlKGphdmFDbGFzcywgcGFyYW1ldGVyVHlwZXMsIHBhcmFtZXRlcnMpOwotCQl9IGNhdGNoIChOb1N1Y2hNZXRob2RFeGNlcHRpb24gbnNtZSkgewotCQkJdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24obnNtZSArIENSICsgZnVsbHlRdWFsaWZpZWRDb25zdHJ1Y3RvclNpZ25hdHVyZShqYXZhQ2xhc3MsIHBhcmFtZXRlclR5cGVzKSwgbnNtZSk7Ci0JCX0KLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIGEgbmV3IGluc3RhbmNlIG9mIHRoZSBzcGVjaWZpZWQgY2xhc3MsCi0JICogZ2l2ZW4gdGhlIGNvbnN0cnVjdG9yIHBhcmFtZXRlciB0eXBlcyBhbmQgcGFyYW1ldGVycy4KLQkgKiBDbGFzcyNuZXdJbnN0YW5jZShDbGFzczw/PltdIHBhcmFtZXRlclR5cGVzLCBPYmplY3RbXSBwYXJhbWV0ZXJzKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IG5ld0luc3RhbmNlKFN0cmluZyBjbGFzc05hbWUsIENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMsIE9iamVjdFtdIHBhcmFtZXRlcnMpIHRocm93cyBDbGFzc05vdEZvdW5kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIG5ld0luc3RhbmNlKGNsYXNzTmFtZSwgcGFyYW1ldGVyVHlwZXMsIHBhcmFtZXRlcnMsIG51bGwpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgaW5zdGFuY2Ugb2YgdGhlIHNwZWNpZmllZCBjbGFzcywKLQkgKiBnaXZlbiB0aGUgY29uc3RydWN0b3IgcGFyYW1ldGVyIHR5cGVzIGFuZCBwYXJhbWV0ZXJzLgotCSAqIENsYXNzI25ld0luc3RhbmNlKENsYXNzPD8+W10gcGFyYW1ldGVyVHlwZXMsIE9iamVjdFtdIHBhcmFtZXRlcnMpCi0JICovCi0JcHVibGljIHN0YXRpYyBPYmplY3QgbmV3SW5zdGFuY2UoU3RyaW5nIGNsYXNzTmFtZSwgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcywgT2JqZWN0W10gcGFyYW1ldGVycywgQ2xhc3NMb2FkZXIgY2xhc3NMb2FkZXIpIHRocm93cyBDbGFzc05vdEZvdW5kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIG5ld0luc3RhbmNlKENsYXNzLmZvck5hbWUoY2xhc3NOYW1lLCB0cnVlLCBjbGFzc0xvYWRlciksIHBhcmFtZXRlclR5cGVzLCBwYXJhbWV0ZXJzKTsKLQl9Ci0JCi0JLyoqCi0JICogQ29udmVuaWVuY2UgbWV0aG9kLgotCSAqIFJldHVybiBhIG5ldyBpbnN0YW5jZSBvZiB0aGUgc3BlY2lmaWVkIGNsYXNzLAotCSAqIGdpdmVuIHRoZSBjb25zdHJ1Y3RvciBwYXJhbWV0ZXIgdHlwZSBhbmQgcGFyYW1ldGVyLgotCSAqIENsYXNzI25ld0luc3RhbmNlKENsYXNzPD8+IHBhcmFtZXRlclR5cGUsIE9iamVjdCBwYXJhbWV0ZXIpCi0JICovCi0JcHVibGljIHN0YXRpYyA8VD4gVCBuZXdJbnN0YW5jZShDbGFzczxUPiBqYXZhQ2xhc3MsIENsYXNzPD8+IHBhcmFtZXRlclR5cGUsIE9iamVjdCBwYXJhbWV0ZXIpIHsKLQkJcmV0dXJuIG5ld0luc3RhbmNlKGphdmFDbGFzcywgbmV3IENsYXNzW10ge3BhcmFtZXRlclR5cGV9LCBuZXcgT2JqZWN0W10ge3BhcmFtZXRlcn0pOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gYSBuZXcgaW5zdGFuY2Ugb2YgdGhlIHNwZWNpZmllZCBjbGFzcywKLQkgKiBnaXZlbiB0aGUgY29uc3RydWN0b3IgcGFyYW1ldGVyIHR5cGUgYW5kIHBhcmFtZXRlci4KLQkgKiBDbGFzcyNuZXdJbnN0YW5jZShDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgT2JqZWN0IG5ld0luc3RhbmNlKFN0cmluZyBjbGFzc05hbWUsIENsYXNzPD8+IHBhcmFtZXRlclR5cGUsIE9iamVjdCBwYXJhbWV0ZXIpIHRocm93cyBDbGFzc05vdEZvdW5kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIG5ld0luc3RhbmNlKGNsYXNzTmFtZSwgcGFyYW1ldGVyVHlwZSwgcGFyYW1ldGVyLCBudWxsKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIGEgbmV3IGluc3RhbmNlIG9mIHRoZSBzcGVjaWZpZWQgY2xhc3MsCi0JICogZ2l2ZW4gdGhlIGNvbnN0cnVjdG9yIHBhcmFtZXRlciB0eXBlIGFuZCBwYXJhbWV0ZXIuCi0JICogQ2xhc3MjbmV3SW5zdGFuY2UoQ2xhc3M8Pz4gcGFyYW1ldGVyVHlwZSwgT2JqZWN0IHBhcmFtZXRlcikKLQkgKi8KLQlwdWJsaWMgc3RhdGljIE9iamVjdCBuZXdJbnN0YW5jZShTdHJpbmcgY2xhc3NOYW1lLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlLCBPYmplY3QgcGFyYW1ldGVyLCBDbGFzc0xvYWRlciBjbGFzc0xvYWRlcikgdGhyb3dzIENsYXNzTm90Rm91bmRFeGNlcHRpb24gewotCQlyZXR1cm4gbmV3SW5zdGFuY2UoQ2xhc3MuZm9yTmFtZShjbGFzc05hbWUsIGZhbHNlLCBjbGFzc0xvYWRlciksIHBhcmFtZXRlclR5cGUsIHBhcmFtZXRlcik7Ci0JfQotCQotCS8qCi0JICogUHVzaCB0aGUgZGVjbGFyZWQgZmllbGRzIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzCi0JICogb250byB0aGUgdG9wIG9mIHRoZSBzdGFjay4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyB2b2lkIHB1c2hEZWNsYXJlZEZpZWxkcyhDbGFzczw/PiBqYXZhQ2xhc3MsIFN0YWNrPEZpZWxkPiBzdGFjaykgewotCQlGaWVsZFtdIGZpZWxkcyA9IGRlY2xhcmVkRmllbGRzKGphdmFDbGFzcyk7Ci0JCWZvciAoaW50IGkgPSBmaWVsZHMubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCXN0YWNrLnB1c2goZmllbGRzW2ldKTsKLQkJfQotCX0KLQkKLQkvKgotCSAqIFB1c2ggdGhlIGRlY2xhcmVkIG1ldGhvZHMgZm9yIHRoZSBzcGVjaWZpZWQgY2xhc3MKLQkgKiBvbnRvIHRoZSB0b3Agb2YgdGhlIHN0YWNrLgotCSAqLwotCXByaXZhdGUgc3RhdGljIHZvaWQgcHVzaERlY2xhcmVkTWV0aG9kcyhDbGFzczw/PiBqYXZhQ2xhc3MsIFN0YWNrPE1ldGhvZD4gc3RhY2spIHsKLQkJTWV0aG9kW10gbWV0aG9kcyA9IGRlY2xhcmVkTWV0aG9kcyhqYXZhQ2xhc3MpOwotCQlmb3IgKGludCBpID0gbWV0aG9kcy5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJc3RhY2sucHVzaChtZXRob2RzW2ldKTsKLQkJfQotCX0KLQkKLQkvKioKLQkgKiBTZXQgYSBmaWVsZCB2YWx1ZSwgZ2l2ZW4gdGhlIGNvbnRhaW5pbmcgb2JqZWN0LCBmaWVsZCBuYW1lLCBhbmQgbmV3IGZpZWxkIHZhbHVlLgotCSAqIFVzZWZ1bCBmb3IgYWNjZXNzaW5nIHByaXZhdGUsIHBhY2thZ2UsIG9yIHByb3RlY3RlZCBmaWVsZHMuCi0JICogT2JqZWN0I3NldEZpZWxkVmFsdWUoU3RyaW5nIGZpZWxkTmFtZSwgT2JqZWN0IGZpZWxkVmFsdWUpCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHNldEZpZWxkVmFsdWUoT2JqZWN0IG9iamVjdCwgU3RyaW5nIGZpZWxkTmFtZSwgT2JqZWN0IGZpZWxkVmFsdWUpIHsKLQkJdHJ5IHsKLQkJCWF0dGVtcHRUb1NldEZpZWxkVmFsdWUob2JqZWN0LCBmaWVsZE5hbWUsIGZpZWxkVmFsdWUpOwotCQl9IGNhdGNoIChOb1N1Y2hGaWVsZEV4Y2VwdGlvbiBuc2ZlKSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihuc2ZlICsgQ1IgKyBmdWxseVF1YWxpZmllZEZpZWxkTmFtZShvYmplY3QsIGZpZWxkTmFtZSksIG5zZmUpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIFNldCBhIHN0YXRpYyBmaWVsZCB2YWx1ZSwgZ2l2ZW4gdGhlIGNvbnRhaW5pbmcgY2xhc3MsIGZpZWxkIG5hbWUsIGFuZCBuZXcgZmllbGQgdmFsdWUuCi0JICogVXNlZnVsIGZvciBhY2Nlc3NpbmcgcHJpdmF0ZSwgcGFja2FnZSwgb3IgcHJvdGVjdGVkIGZpZWxkcy4KLQkgKiBDbGFzcyNzZXRTdGF0aWNGaWVsZFZhbHVlKFN0cmluZyBmaWVsZE5hbWUsIE9iamVjdCBmaWVsZFZhbHVlKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCBzZXRTdGF0aWNGaWVsZFZhbHVlKENsYXNzPD8+IGphdmFDbGFzcywgU3RyaW5nIGZpZWxkTmFtZSwgT2JqZWN0IGZpZWxkVmFsdWUpIHsKLQkJdHJ5IHsKLQkJCWF0dGVtcHRUb1NldFN0YXRpY0ZpZWxkVmFsdWUoamF2YUNsYXNzLCBmaWVsZE5hbWUsIGZpZWxkVmFsdWUpOwotCQl9IGNhdGNoIChOb1N1Y2hGaWVsZEV4Y2VwdGlvbiBuc2ZlKSB7Ci0JCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihuc2ZlICsgQ1IgKyBmdWxseVF1YWxpZmllZEZpZWxkTmFtZShqYXZhQ2xhc3MsIGZpZWxkTmFtZSksIG5zZmUpOwotCQl9Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgc2hvcnQgbmFtZSBvZiB0aGUgb2JqZWN0J3MgY2xhc3MuCi0JICogQ2xhc3MjZ2V0U2hvcnROYW1lKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBzaG9ydENsYXNzTmFtZUZvck9iamVjdChPYmplY3Qgb2JqZWN0KSB7Ci0JCXJldHVybiBzaG9ydE5hbWVGb3Iob2JqZWN0LmdldENsYXNzKCkpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNob3J0IG5hbWUgb2YgdGhlIGNsYXNzIChlLmcuICJPYmplY3QiKS4KLQkgKiBDbGFzcyNnZXRTaG9ydE5hbWUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHNob3J0TmFtZUZvckNsYXNzTmFtZWQoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlyZXR1cm4gY2xhc3NOYW1lLnN1YnN0cmluZyhjbGFzc05hbWUubGFzdEluZGV4T2YoJy4nKSArIDEpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIHNob3J0IG5hbWUgb2YgdGhlIGNsYXNzIChlLmcuICJPYmplY3QiKS4KLQkgKiBDbGFzcyNnZXRTaG9ydE5hbWUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHNob3J0TmFtZUZvcihDbGFzczw/PiBqYXZhQ2xhc3MpIHsKLQkJcmV0dXJuIHNob3J0TmFtZUZvckNsYXNzTmFtZWQoamF2YUNsYXNzLmdldE5hbWUoKSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgbmVzdGVkIG5hbWUgb2YgdGhlIG9iamVjdCdzIGNsYXNzLgotCSAqIENsYXNzI2dldE5lc3RlZE5hbWUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIG5lc3RlZENsYXNzTmFtZUZvck9iamVjdChPYmplY3Qgb2JqZWN0KSB7Ci0JCXJldHVybiBuZXN0ZWROYW1lRm9yKG9iamVjdC5nZXRDbGFzcygpKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBuZXN0ZWQgbmFtZSBvZiB0aGUgY2xhc3MgKGUuZy4gIkVudHJ5IikuCi0JICogQ2xhc3MjZ2V0TmVzdGVkTmFtZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgbmVzdGVkTmFtZUZvckNsYXNzTmFtZWQoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlyZXR1cm4gY2xhc3NOYW1lLnN1YnN0cmluZyhjbGFzc05hbWUubGFzdEluZGV4T2YoTkVTVEVEX0NMQVNTX05BTUVfU0VQQVJBVE9SKSArIDEpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIG5lc3RlZCBuYW1lIG9mIHRoZSBjbGFzcyAoZS5nLiAiRW50cnkiKS4KLQkgKiBDbGFzcyNnZXROZXN0ZWROYW1lKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBuZXN0ZWROYW1lRm9yKENsYXNzPD8+IGphdmFDbGFzcykgewotCQlyZXR1cm4gbmVzdGVkTmFtZUZvckNsYXNzTmFtZWQoamF2YUNsYXNzLmdldE5hbWUoKSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgInRvU3RyaW5nKCkiIG5hbWUgb2YgdGhlIG9iamVjdCdzIGNsYXNzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nQ2xhc3NOYW1lRm9yT2JqZWN0KE9iamVjdCBvYmplY3QpIHsKLQkJcmV0dXJuIHRvU3RyaW5nTmFtZUZvcihvYmplY3QuZ2V0Q2xhc3MoKSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgInRvU3RyaW5nKCkiIG5hbWUgb2YgdGhlIGNsYXNzLgotCSAqICJNZW1iZXIiIGNsYXNzZXMgd2lsbCByZXR1cm4gb25seSB0aGUgZmluYWwgbmFtZToKLQkgKiAgICAgImNvbS5mb28uYmFyLlRvcExldmVsQ2xhc3MkTWVtYmVyQ2xhc3MkTmVzdGVkTWVtYmVyQ2xhc3MiCi0JICogICAgICAgICA9PiAiTmVzdGVkTWVtYmVyQ2xhc3MiCi0JICogIkxvY2FsIiBhbmQgImFub255bW91cyIgY2xhc3NlcyB3aWxsIHN0aWxsIHJldHVybiB0aGUgZW1iZWRkZWQgJyQnczoKLQkgKiAgICAgImNvbS5mb28uYmFyLlRvcExldmVsQ2xhc3MkMUxvY2FsQ2xhc3MiCi0JICogICAgICAgICA9PiAiVG9wTGV2ZWxDbGFzcyQxTG9jYWxDbGFzcyIKLQkgKiAgICAgImNvbS5mb28uYmFyLlRvcExldmVsQ2xhc3MkMSIKLQkgKiAgICAgICAgID0+ICJUb3BMZXZlbENsYXNzJDEiCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgdG9TdHJpbmdOYW1lRm9yQ2xhc3NOYW1lZChTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCXJldHVybiBjbGFzc05hbWVkSXNNZW1iZXIoY2xhc3NOYW1lKSA/Ci0JCQljbGFzc05hbWUuc3Vic3RyaW5nKGNsYXNzTmFtZS5sYXN0SW5kZXhPZihORVNURURfQ0xBU1NfTkFNRV9TRVBBUkFUT1IpICsgMSkKLQkJOgotCQkJY2xhc3NOYW1lLnN1YnN0cmluZyhjbGFzc05hbWUubGFzdEluZGV4T2YoJy4nKSArIDEpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlICJ0b1N0cmluZygpIiBuYW1lIG9mIHRoZSBjbGFzcy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyB0b1N0cmluZ05hbWVGb3IoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCXJldHVybiB0b1N0cmluZ05hbWVGb3JDbGFzc05hbWVkKGphdmFDbGFzcy5nZXROYW1lKCkpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIHBhY2thZ2UgbmFtZSBvZiB0aGUgY2xhc3MgKGUuZy4gImphdmEubGFuZyIpLgotCSAqIENsYXNzI2dldFBhY2thZ2VOYW1lKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBwYWNrYWdlTmFtZUZvcihDbGFzczw/PiBqYXZhQ2xhc3MpIHsKLQkJcmV0dXJuIHBhY2thZ2VOYW1lRm9yQ2xhc3NOYW1lZChqYXZhQ2xhc3MuZ2V0TmFtZSgpKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBwYWNrYWdlIG5hbWUgb2YgdGhlIGNsYXNzIChlLmcuICJqYXZhLmxhbmciKS4KLQkgKiBDbGFzcyNnZXRQYWNrYWdlTmFtZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgcGFja2FnZU5hbWVGb3JDbGFzc05hbWVkKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJaW50IGxhc3RQZXJpb2QgPSBjbGFzc05hbWUubGFzdEluZGV4T2YoJy4nKTsKLQkJaWYgKGxhc3RQZXJpb2QgPT0gLTEpIHsKLQkJCXJldHVybiAiIjsKLQkJfQotCQlyZXR1cm4gY2xhc3NOYW1lLnN1YnN0cmluZygwLCBsYXN0UGVyaW9kKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBzaG9ydCBuYW1lIG9mIHRoZSBjbGFzcywKLQkgKiBmb2xsb3dlZCBieSBpdHMgcGFja2FnZSBuYW1lIChlLmcuICJPYmplY3QgKGphdmEubGFuZykiKS4KLQkgKiBDbGFzcyNnZXRTaG9ydE5hbWVXaXRoUGFja2FnZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgc2hvcnROYW1lV2l0aFBhY2thZ2UoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigyMDApOwotCQlzYi5hcHBlbmQoc2hvcnROYW1lRm9yKGphdmFDbGFzcykpOwotCQlpZiAoICEgamF2YUNsYXNzLmlzUHJpbWl0aXZlKCkpIHsKLQkJCXNiLmFwcGVuZCgiICgiKTsKLQkJCXNiLmFwcGVuZChwYWNrYWdlTmFtZUZvcihqYXZhQ2xhc3MpKTsKLQkJCXNiLmFwcGVuZCgnKScpOwotCQl9Ci0JCXJldHVybiBzYi50b1N0cmluZygpOwotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogUmV0dXJuIGEgemVyby1hcmd1bWVudCwgc3RhdGljIG1ldGhvZCBmb3IgdGhlIHNwZWNpZmllZCBjbGFzcwotCSAqIGFuZCBtZXRob2QgbmFtZS4gSWYgdGhlIGNsYXNzIGRvZXMgbm90IGRpcmVjdGx5Ci0JICogaW1wbGVtZW50IHRoZSBtZXRob2QsIGxvb2sgZm9yIGl0IGluIHRoZSBjbGFzcydzIHN1cGVyY2xhc3Nlcy4KLQkgKiBTZXQgYWNjZXNzaWJsZSB0byB0cnVlLCBzbyB3ZSBjYW4gYWNjZXNzCi0JICogcHJpdmF0ZS9wYWNrYWdlL3Byb3RlY3RlZCBtZXRob2RzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgTWV0aG9kIHN0YXRpY01ldGhvZChDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBtZXRob2ROYW1lKSB0aHJvd3MgTm9TdWNoTWV0aG9kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIHN0YXRpY01ldGhvZChqYXZhQ2xhc3MsIG1ldGhvZE5hbWUsIFpFUk9fUEFSQU1FVEVSX1RZUEVTKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIGEgc3RhdGljIG1ldGhvZCBmb3IgdGhlIHNwZWNpZmllZCBjbGFzcywgbWV0aG9kIG5hbWUsCi0JICogYW5kIGZvcm1hbCBwYXJhbWV0ZXIgdHlwZXMuIElmIHRoZSBjbGFzcyBkb2VzIG5vdCBkaXJlY3RseQotCSAqIGltcGxlbWVudCB0aGUgbWV0aG9kLCBsb29rIGZvciBpdCBpbiB0aGUgY2xhc3MncyBzdXBlcmNsYXNzZXMuCi0JICogU2V0IGFjY2Vzc2libGUgdG8gdHJ1ZSwgc28gd2UgY2FuIGFjY2VzcwotCSAqIHByaXZhdGUvcGFja2FnZS9wcm90ZWN0ZWQgbWV0aG9kcy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIE1ldGhvZCBzdGF0aWNNZXRob2QoQ2xhc3M8Pz4gamF2YUNsYXNzLCBTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz5bXSBwYXJhbWV0ZXJUeXBlcykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCU1ldGhvZCBtZXRob2QgPSBtZXRob2QoamF2YUNsYXNzLCBtZXRob2ROYW1lLCBwYXJhbWV0ZXJUeXBlcyk7Ci0JCWlmIChNb2RpZmllci5pc1N0YXRpYyhtZXRob2QuZ2V0TW9kaWZpZXJzKCkpKSB7Ci0JCQlyZXR1cm4gbWV0aG9kOwotCQl9Ci0JCXRocm93IG5ldyBOb1N1Y2hNZXRob2RFeGNlcHRpb24oZnVsbHlRdWFsaWZpZWRNZXRob2RTaWduYXR1cmUoamF2YUNsYXNzLCBtZXRob2ROYW1lLCBwYXJhbWV0ZXJUeXBlcykpOwotCX0KLQkKLQkvKioKLQkgKiBDb252ZW5pZW5jZSBtZXRob2QuCi0JICogUmV0dXJuIGEgc3RhdGljIG1ldGhvZCBmb3IgdGhlIHNwZWNpZmllZCBjbGFzcywgbWV0aG9kIG5hbWUsCi0JICogYW5kIGZvcm1hbCBwYXJhbWV0ZXIgdHlwZS4gSWYgdGhlIGNsYXNzIGRvZXMgbm90IGRpcmVjdGx5Ci0JICogaW1wbGVtZW50IHRoZSBtZXRob2QsIGxvb2sgZm9yIGl0IGluIHRoZSBjbGFzcydzIHN1cGVyY2xhc3Nlcy4KLQkgKiBTZXQgYWNjZXNzaWJsZSB0byB0cnVlLCBzbyB3ZSBjYW4gYWNjZXNzCi0JICogcHJpdmF0ZS9wYWNrYWdlL3Byb3RlY3RlZCBtZXRob2RzLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgTWV0aG9kIHN0YXRpY01ldGhvZChDbGFzczw/PiBqYXZhQ2xhc3MsIFN0cmluZyBtZXRob2ROYW1lLCBDbGFzczw/PiBwYXJhbWV0ZXJUeXBlcykgdGhyb3dzIE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBzdGF0aWNNZXRob2QoamF2YUNsYXNzLCBtZXRob2ROYW1lLCBuZXcgQ2xhc3NbXSB7cGFyYW1ldGVyVHlwZXN9KTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGNsYXNzIGNhbiBiZSAiZGVjbGFyZWQiIGluIGNvZGU7Ci0JICogaS5lLiBpdCBpcyBlaXRoZXIgYSAidG9wLWxldmVsIiBjbGFzcyBvciBhICJtZW1iZXIiIGNsYXNzLCBidXQgaXQKLQkgKiBpcyBub3QgYW4gImFycmF5IiBjbGFzcy4gVGhpcyBtZXRob2Qgcm9sbHMgdG9nZXRoZXIgYWxsIHRoZSBjaGVja3MKLQkgKiBmcm9tIHRoZSBvdGhlciBtZXRob2RzIGZvciBhIGJpdCBvZiBhIHBlcmZvcm1hbmNlIHR3ZWFrLgotCSAqIENsYXNzI2lzRGVjbGFyYWJsZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNsYXNzTmFtZWRJc0RlY2xhcmFibGUoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlpZiAoY2xhc3NOYW1lLmNoYXJBdCgwKSA9PSBBUlJBWV9JTkRJQ0FUT1IpIHsKLQkJCXJldHVybiBmYWxzZTsJCS8vIGl0IGlzIGFuICJhcnJheSIgY2xhc3MKLQkJfQotCQlpbnQgaW5kZXggPSBjbGFzc05hbWUuaW5kZXhPZihORVNURURfQ0xBU1NfTkFNRV9TRVBBUkFUT1IpOwotCQlpZiAoaW5kZXggPT0gLTEpIHsKLQkJCXJldHVybiB0cnVlOwkJLy8gaXQgaXMgYSAidG9wLWxldmVsIiBjbGFzcwotCQl9Ci0JCWRvIHsKLQkJCS8vIHRoZSBjaGFyYWN0ZXIgaW1tZWRpYXRlbHkgYWZ0ZXIgZWFjaCBkb2xsYXIgc2lnbiBjYW5ub3QgYmUgYSBkaWdpdAotCQkJaW5kZXgrKzsKLQkJCWlmIChDaGFyYWN0ZXIuaXNEaWdpdChjbGFzc05hbWUuY2hhckF0KGluZGV4KSkpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCQlpbmRleCA9IGNsYXNzTmFtZS5pbmRleE9mKE5FU1RFRF9DTEFTU19OQU1FX1NFUEFSQVRPUiwgaW5kZXgpOwotCQl9IHdoaWxlIChpbmRleCAhPSAtMSk7Ci0JCXJldHVybiB0cnVlOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGNsYXNzIGlzIGEgInRvcC1sZXZlbCIgY2xhc3MsCi0JICogYXMgb3Bwb3NlZCB0byBhICJtZW1iZXIiLCAibG9jYWwiLCBvciAiYW5vbnltb3VzIiBjbGFzcywKLQkgKiB1c2luZyB0aGUgc3RhbmRhcmQgamRrIG5hbWluZyBjb252ZW50aW9ucyAoaS5lLiB0aGUgY2xhc3MKLQkgKiBuYW1lIGRvZXMgTk9UIGNvbnRhaW4gYSAnJCc6ICJUb3BMZXZlbENsYXNzIikuCi0JICogQ2xhc3MjaXNUb3BMZXZlbCgpCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNsYXNzTmFtZWRJc1RvcExldmVsKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJaWYgKGNsYXNzTmFtZWRJc0FycmF5KGNsYXNzTmFtZSkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlyZXR1cm4gY2xhc3NOYW1lLmluZGV4T2YoTkVTVEVEX0NMQVNTX05BTUVfU0VQQVJBVE9SKSA9PSAtMTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGNsYXNzIGlzIGEgIm1lbWJlciIgY2xhc3MsCi0JICogYXMgb3Bwb3NlZCB0byBhICJ0b3AtbGV2ZWwiLCAibG9jYWwiLCBvciAiYW5vbnltb3VzIiBjbGFzcywKLQkgKiB1c2luZyB0aGUgc3RhbmRhcmQgamRrIG5hbWluZyBjb252ZW50aW9ucyAoaS5lLiB0aGUgY2xhc3MKLQkgKiBuYW1lIGNvbnRhaW5zIGF0IGxlYXN0IG9uZSAnJCcgYW5kIGFsbCB0aGUgbmFtZXMgYmV0d2VlbgotCSAqIGVhY2ggJyQnIGFyZSBsZWdhbCBjbGFzcyBuYW1lczoKLQkgKiAiVG9wTGV2ZWxDbGFzcyRNZW1iZXJDbGFzcyROZXN0ZWRNZW1iZXJDbGFzcyIpLgotCSAqIENsYXNzI2lzTWVtYmVyKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY2xhc3NOYW1lZElzTWVtYmVyKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJaWYgKGNsYXNzTmFtZWRJc0FycmF5KGNsYXNzTmFtZSkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlpbnQgaW5kZXggPSBjbGFzc05hbWUuaW5kZXhPZihORVNURURfQ0xBU1NfTkFNRV9TRVBBUkFUT1IpOwotCQlpZiAoaW5kZXggPT0gLTEpIHsKLQkJCXJldHVybiBmYWxzZTsJLy8gaXQgaXMgYSAidG9wLWxldmVsIiBjbGFzcwotCQl9Ci0JCWRvIHsKLQkJCS8vIHRoZSBjaGFyYWN0ZXIgaW1tZWRpYXRlbHkgYWZ0ZXIgZWFjaCBkb2xsYXIgc2lnbiBjYW5ub3QgYmUgYSBkaWdpdAotCQkJaW5kZXgrKzsKLQkJCWlmIChDaGFyYWN0ZXIuaXNEaWdpdChjbGFzc05hbWUuY2hhckF0KGluZGV4KSkpIHsKLQkJCQlyZXR1cm4gZmFsc2U7Ci0JCQl9Ci0JCQlpbmRleCA9IGNsYXNzTmFtZS5pbmRleE9mKE5FU1RFRF9DTEFTU19OQU1FX1NFUEFSQVRPUiwgaW5kZXgpOwotCQl9IHdoaWxlIChpbmRleCAhPSAtMSk7Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgY2xhc3MgaXMgYSAibG9jYWwiIGNsYXNzLAotCSAqIGFzIG9wcG9zZWQgdG8gYSAidG9wLWxldmVsIiwgIm1lbWJlciIsIG9yICJhbm9ueW1vdXMiIGNsYXNzLAotCSAqIHVzaW5nIHRoZSBzdGFuZGFyZCBqZGsgKG9yIEVjbGlwc2UpIG5hbWluZyBjb252ZW50aW9ucy4KLQkgKiBJbiB0aGUgamRrLCB0aGUgY2xhc3MgbmFtZSBlbmRzIHdpdGggJyRubm5YWFgnIHdoZXJlIHRoZSAnJCcgaXMKLQkgKiBmb2xsb3dlZCBieSBhIHNlcmllcyBvZiBudW1lcmljIGRpZ2l0cyB3aGljaCBhcmUgZm9sbG93ZWQgYnkgdGhlCi0JICogbG9jYWwgY2xhc3MgbmFtZTogIlRvcExldmVsQ2xhc3MkMUxvY2FsQ2xhc3MiLgotCSAqIEluIEVjbGlwc2UsIHRoZSBjbGFzcyBuYW1lIGVuZHMgd2l0aCAnJG5ubiRYWFgnIHdoZXJlIHRoZSAnJCcgaXMKLQkgKiBmb2xsb3dlZCBieSBhIHNlcmllcyBvZiBudW1lcmljIGRpZ2l0cyB3aGljaCBhcmUgc2VwYXJhdGVkIGZyb20KLQkgKiB0aGUgbG9jYWwgY2xhc3MgbmFtZSBieSBhbm90aGVyICckJzogIlRvcExldmVsQ2xhc3MkMSRMb2NhbENsYXNzIi4KLQkgKiBDbGFzcyNpc0xvY2FsKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY2xhc3NOYW1lZElzTG9jYWwoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlpZiAoY2xhc3NOYW1lZElzQXJyYXkoY2xhc3NOYW1lKSkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCWludCBkb2xsYXIgPSBjbGFzc05hbWUuaW5kZXhPZihORVNURURfQ0xBU1NfTkFNRV9TRVBBUkFUT1IpOwotCQlpZiAoZG9sbGFyID09IC0xKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJaWYgKCAhIENoYXJhY3Rlci5pc0RpZ2l0KGNsYXNzTmFtZS5jaGFyQXQoZG9sbGFyICsgMSkpKSB7Ci0JCQlyZXR1cm4gZmFsc2U7Ci0JCX0KLQkJaW50IGxlbiA9IGNsYXNzTmFtZS5sZW5ndGgoKTsKLQkJZm9yIChpbnQgaSA9IGRvbGxhciArIDI7IGkgPCBsZW47IGkrKykgewotCQkJaWYgKENoYXJhY3Rlci5pc0phdmFJZGVudGlmaWVyU3RhcnQoY2xhc3NOYW1lLmNoYXJBdChpKSkpIHsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQkJfQotCQkvLyBhbGwgdGhlIGNoYXJhY3RlcnMgcGFzdCB0aGUgJCBhcmUgZGlnaXRzIChhbm9ueW1vdXMpCi0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGNsYXNzIGlzIGFuICJhbm9ueW1vdXMiIGNsYXNzLAotCSAqIGFzIG9wcG9zZWQgdG8gYSAidG9wLWxldmVsIiwgIm1lbWJlciIsIG9yICJsb2NhbCIgY2xhc3MsCi0JICogdXNpbmcgdGhlIHN0YW5kYXJkIGpkayBuYW1pbmcgY29udmVudGlvbnMgKGkuZS4gdGhlIGNsYXNzCi0JICogbmFtZSBlbmRzIHdpdGggJyRubm4nIHdoZXJlIGFsbCB0aGUgY2hhcmFjdGVycyBwYXN0IHRoZQotCSAqIGxhc3QgJyQnIGFyZSBudW1lcmljIGRpZ2l0czogIlRvcExldmVsQ2xhc3MkMSIpLgotCSAqIENsYXNzI2lzQW5vbnltb3VzKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY2xhc3NOYW1lZElzQW5vbnltb3VzKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJaWYgKGNsYXNzTmFtZWRJc0FycmF5KGNsYXNzTmFtZSkpIHsKLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCQlpbnQgZG9sbGFyID0gY2xhc3NOYW1lLmluZGV4T2YoTkVTVEVEX0NMQVNTX05BTUVfU0VQQVJBVE9SKTsKLQkJaWYgKGRvbGxhciA9PSAtMSkgewotCQkJcmV0dXJuIGZhbHNlOwotCQl9Ci0JCWludCBzdGFydCA9IGRvbGxhciArIDE7Ci0JCWZvciAoaW50IGkgPSBjbGFzc05hbWUubGVuZ3RoKCk7IGktLSA+IHN0YXJ0OyApIHsKLQkJCWlmICggISBDaGFyYWN0ZXIuaXNEaWdpdChjbGFzc05hbWUuY2hhckF0KGkpKSkgewotCQkJCXJldHVybiBmYWxzZTsKLQkJCX0KLQkJfQotCQkvLyBhbGwgdGhlIGNoYXJhY3RlcnMgcGFzdCB0aGUgJCBhcmUgZGlnaXRzCi0JCXJldHVybiB0cnVlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgImFycmF5IGRlcHRoIiBvZiB0aGUgc3BlY2lmaWVkIGNsYXNzLgotCSAqIFRoZSBkZXB0aCBpcyB0aGUgbnVtYmVyIG9mIGRpbWVuc2lvbnMgZm9yIGFuIGFycmF5IHR5cGUuCi0JICogTm9uLWFycmF5IHR5cGVzIGhhdmUgYSBkZXB0aCBvZiB6ZXJvLgotCSAqIENsYXNzI2dldEFycmF5RGVwdGgoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50IGFycmF5RGVwdGhGb3IoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCWludCBkZXB0aCA9IDA7Ci0JCXdoaWxlIChqYXZhQ2xhc3MuaXNBcnJheSgpKSB7Ci0JCQlkZXB0aCsrOwotCQkJamF2YUNsYXNzID0gamF2YUNsYXNzLmdldENvbXBvbmVudFR5cGUoKTsKLQkJfQotCQlyZXR1cm4gZGVwdGg7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgImFycmF5IGRlcHRoIiBvZiB0aGUgc3BlY2lmaWVkIG9iamVjdC4KLQkgKiBUaGUgZGVwdGggaXMgdGhlIG51bWJlciBvZiBkaW1lbnNpb25zIGZvciBhbiBhcnJheS4KLQkgKiBOb24tYXJyYXlzIGhhdmUgYSBkZXB0aCBvZiB6ZXJvLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50IGFycmF5RGVwdGhGb3JPYmplY3QoT2JqZWN0IG9iamVjdCkgewotCQlyZXR1cm4gYXJyYXlEZXB0aEZvcihvYmplY3QuZ2V0Q2xhc3MoKSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgImFycmF5IGRlcHRoIiBvZiB0aGUgc3BlY2lmaWVkIGNsYXNzLgotCSAqIFRoZSBkZXB0aCBpcyB0aGUgbnVtYmVyIG9mIGRpbWVuc2lvbnMgZm9yIGFuIGFycmF5IHR5cGUuCi0JICogTm9uLWFycmF5IHR5cGVzIGhhdmUgYSBkZXB0aCBvZiB6ZXJvLgotCSAqIEBzZWUgamF2YS5sYW5nLkNsYXNzI2dldE5hbWUoKQotCSAqIENsYXNzI2dldEFycmF5RGVwdGgoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50IGFycmF5RGVwdGhGb3JDbGFzc05hbWVkKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJaW50IGRlcHRoID0gMDsKLQkJd2hpbGUgKGNsYXNzTmFtZS5jaGFyQXQoZGVwdGgpID09IEFSUkFZX0lORElDQVRPUikgewotCQkJZGVwdGgrKzsKLQkJfQotCQlyZXR1cm4gZGVwdGg7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBjbGFzcyBpcyBhbiBhcnJheSB0eXBlLgotCSAqIEBzZWUgamF2YS5sYW5nLkNsYXNzI2dldE5hbWUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjbGFzc05hbWVkSXNBcnJheShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCXJldHVybiBjbGFzc05hbWUuY2hhckF0KDApID09IEFSUkFZX0lORElDQVRPUjsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlICJlbGVtZW50IHR5cGUiIG9mIHRoZSBzcGVjaWZpZWQgY2xhc3MuCi0JICogVGhlIGVsZW1lbnQgdHlwZSBpcyB0aGUgYmFzZSB0eXBlIGhlbGQgYnkgYW4gYXJyYXkgdHlwZS4KLQkgKiBBIG5vbi1hcnJheSB0eXBlIHNpbXBseSByZXR1cm5zIGl0c2VsZi4KLQkgKiBDbGFzcyNnZXRFbGVtZW50VHlwZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBDbGFzczw/PiBlbGVtZW50VHlwZUZvcihDbGFzczw/PiBqYXZhQ2xhc3MpIHsKLQkJd2hpbGUgKGphdmFDbGFzcy5pc0FycmF5KCkpIHsKLQkJCWphdmFDbGFzcyA9IGphdmFDbGFzcy5nZXRDb21wb25lbnRUeXBlKCk7Ci0JCX0KLQkJcmV0dXJuIGphdmFDbGFzczsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlICJlbGVtZW50IHR5cGUiIG9mIHRoZSBzcGVjaWZpZWQgb2JqZWN0LgotCSAqIFRoZSBlbGVtZW50IHR5cGUgaXMgdGhlIGJhc2UgdHlwZSBoZWxkIGJ5IGFuIGFycmF5LgotCSAqIEEgbm9uLWFycmF5IHNpbXBseSByZXR1cm5zIGl0cyBjbGFzcy4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIENsYXNzPD8+IGVsZW1lbnRUeXBlRm9yT2JqZWN0KE9iamVjdCBvYmplY3QpIHsKLQkJcmV0dXJuIGVsZW1lbnRUeXBlRm9yKG9iamVjdC5nZXRDbGFzcygpKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlICJlbGVtZW50IHR5cGUiIG9mIHRoZSBzcGVjaWZpZWQgY2xhc3MuCi0JICogVGhlIGVsZW1lbnQgdHlwZSBpcyB0aGUgYmFzZSB0eXBlIGhlbGQgYnkgYW4gYXJyYXkgdHlwZS4KLQkgKiBOb24tYXJyYXkgdHlwZXMgc2ltcGx5IHJldHVybiB0aGVtc2VsdmVzLgotCSAqIENsYXNzI2dldEVsZW1lbnRUeXBlKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBlbGVtZW50VHlwZU5hbWVGb3IoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCXJldHVybiBlbGVtZW50VHlwZUZvcihqYXZhQ2xhc3MpLmdldE5hbWUoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlICJlbGVtZW50IHR5cGUiIG9mIHRoZSBzcGVjaWZpZWQgY2xhc3MuCi0JICogVGhlIGVsZW1lbnQgdHlwZSBpcyB0aGUgYmFzZSB0eXBlIGhlbGQgYnkgYW4gYXJyYXkgdHlwZS4KLQkgKiBOb24tYXJyYXkgdHlwZXMgc2ltcGx5IHJldHVybiB0aGVtc2VsdmVzLgotCSAqIEBzZWUgamF2YS5sYW5nLkNsYXNzI2dldE5hbWUoKQotCSAqIENsYXNzI2dldEVsZW1lbnRUeXBlKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBlbGVtZW50VHlwZU5hbWVGb3JDbGFzc05hbWVkKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJaW50IGRlcHRoID0gYXJyYXlEZXB0aEZvckNsYXNzTmFtZWQoY2xhc3NOYW1lKTsKLQkJaWYgKGRlcHRoID09IDApIHsKLQkJCS8vIHRoZSBuYW1lIGlzIGluIHRoZSBmb3JtOiAiamF2YS5sYW5nLk9iamVjdCIgb3IgImludCIKLQkJCXJldHVybiBjbGFzc05hbWU7Ci0JCX0KLQkJaW50IGxhc3QgPSBjbGFzc05hbWUubGVuZ3RoKCkgLSAxOwotCQlpZiAoY2xhc3NOYW1lLmNoYXJBdChkZXB0aCkgPT0gUkVGRVJFTkNFX0NMQVNTX0NPREUpIHsKLQkJCS8vIHRoZSBuYW1lIGlzIGluIHRoZSBmb3JtOiAiW1tbTGphdmEubGFuZy5PYmplY3Q7IgotCQkJcmV0dXJuIGNsYXNzTmFtZS5zdWJzdHJpbmcoZGVwdGggKyAxLCBsYXN0KTsJLy8gZHJvcCB0aGUgdHJhaWxpbmcgJzsnCi0JCX0KLQkJLy8gdGhlIG5hbWUgaXMgaW4gdGhlIGZvcm06ICJbW1tJIgotCQlyZXR1cm4gY2xhc3NOYW1lRm9yQ29kZShjbGFzc05hbWUuY2hhckF0KGxhc3QpKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBjbGFzcyBpcyBhICJyZWZlcmVuY2UiCi0JICogY2xhc3MgKGkuZS4gbmVpdGhlciAndm9pZCcgbm9yIG9uZSBvZiB0aGUgcHJpbWl0aXZlIHZhcmlhYmxlIGNsYXNzZXMsCi0JICogWydib29sZWFuJywgJ2ludCcsICdmbG9hdCcsIGV0Yy5dKS4KLQkgKiBOQjogdm9pZC5jbGFzcy5pc1ByaW1pdGl2ZSgpID09IHRydWUKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY2xhc3NOYW1lZElzUmVmZXJlbmNlKFN0cmluZyBjbGFzc05hbWUpIHsKLQkJcmV0dXJuICEgY2xhc3NOYW1lZElzUHJpbWl0aXZlKGNsYXNzTmFtZSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBjbGFzcyBpcyBhIHByaW1pdGl2ZQotCSAqIGNsYXNzIChpLmUuICd2b2lkJyBvciBvbmUgb2YgdGhlIHByaW1pdGl2ZSB2YXJpYWJsZSBjbGFzc2VzLAotCSAqIFsnYm9vbGVhbicsICdpbnQnLCAnZmxvYXQnLCBldGMuXSkuCi0JICogTkI6IHZvaWQuY2xhc3MuaXNQcmltaXRpdmUoKSA9PSB0cnVlCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNsYXNzTmFtZWRJc1ByaW1pdGl2ZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCWlmIChjbGFzc05hbWVkSXNBcnJheShjbGFzc05hbWUpIHx8IChjbGFzc05hbWUubGVuZ3RoKCkgPiBtYXhQcmltaXRpdmVDbGFzc05hbWVMZW5ndGgoKSkpIHsKLQkJCXJldHVybiBmYWxzZTsgIC8vIHBlcmZvcm1hbmNlIHR3ZWFrCi0JCX0KLQkJUHJpbWl0aXZlW10gY29kZXMgPSBwcmltaXRpdmVzKCk7Ci0JCWZvciAoaW50IGkgPSBjb2Rlcy5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJaWYgKGNvZGVzW2ldLmphdmFDbGFzcy5nZXROYW1lKCkuZXF1YWxzKGNsYXNzTmFtZSkpIHsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBjbGFzcyBpcyBhICJ2YXJpYWJsZSIgcHJpbWl0aXZlCi0JICogY2xhc3MgKGkuZS4gJ2Jvb2xlYW4nLCAnaW50JywgJ2Zsb2F0JywgZXRjLiwgYnV0IG5vdCAndm9pZCcpLgotCSAqIE5COiB2b2lkLmNsYXNzLmlzUHJpbWl0aXZlKCkgPT0gdHJ1ZQotCSAqLwotCXB1YmxpYyBzdGF0aWMgYm9vbGVhbiBjbGFzc05hbWVkSXNWYXJpYWJsZVByaW1pdGl2ZShTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCXJldHVybiBjbGFzc05hbWVkSXNQcmltaXRpdmUoY2xhc3NOYW1lKQotCQkJJiYgKCAhIGNsYXNzTmFtZS5lcXVhbHMoVk9JRF9DTEFTU19OQU1FKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBjbGFzcyBpcyBhIHByaW1pdGl2ZSB3cmFwcGVyCi0JICogY2xhc3MgKGkuZS4gJ2phdmEubGFuZy5Wb2lkJyBvciBvbmUgb2YgdGhlIHByaW1pdGl2ZSB2YXJpYWJsZSB3cmFwcGVyIGNsYXNzZXMsCi0JICogWydqYXZhLmxhbmcuQm9vbGVhbicsICdqYXZhLmxhbmcuSW50ZWdlcicsICdqYXZhLmxhbmcuRmxvYXQnLCBldGMuXSkuCi0JICogTkI6IHZvaWQuY2xhc3MuaXNQcmltaXRpdmUoKSA9PSB0cnVlCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNsYXNzTmFtZWRJc1ByaW1pdGl2ZVdyYXBwZXJDbGFzcyhTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCWlmIChjbGFzc05hbWVkSXNBcnJheShjbGFzc05hbWUpIHx8IChjbGFzc05hbWUubGVuZ3RoKCkgPiBtYXhQcmltaXRpdmVXcmFwcGVyQ2xhc3NOYW1lTGVuZ3RoKCkpKSB7Ci0JCQlyZXR1cm4gZmFsc2U7ICAvLyBwZXJmb3JtYW5jZSB0d2VhawotCQl9Ci0JCVByaW1pdGl2ZVtdIGNvZGVzID0gcHJpbWl0aXZlcygpOwotCQlmb3IgKGludCBpID0gY29kZXMubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCWlmIChjb2Rlc1tpXS53cmFwcGVyQ2xhc3MuZ2V0TmFtZSgpLmVxdWFscyhjbGFzc05hbWUpKSB7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgY2xhc3MgaXMgYSAidmFyaWFibGUiIHByaW1pdGl2ZQotCSAqIGNsYXNzIChpLmUuICdib29sZWFuJywgJ2ludCcsICdmbG9hdCcsIGV0Yy4sIGJ1dCBub3QgJ3ZvaWQnKS4KLQkgKiBOQjogdm9pZC5jbGFzcy5pc1ByaW1pdGl2ZSgpID09IHRydWUKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGJvb2xlYW4gY2xhc3NOYW1lZElzVmFyaWFibGVQcmltaXRpdmVXcmFwcGVyQ2xhc3MoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlyZXR1cm4gY2xhc3NOYW1lZElzUHJpbWl0aXZlV3JhcHBlckNsYXNzKGNsYXNzTmFtZSkKLQkJCSYmICggISBjbGFzc05hbWUuZXF1YWxzKFZPSURfV1JBUFBFUl9DTEFTU19OQU1FKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBjbGFzcyBpcyBhIHByaW1pdGl2ZSB3cmFwcGVyCi0JICogY2xhc3MgKGkuZS4gJ2phdmEubGFuZy5Wb2lkJyBvciBvbmUgb2YgdGhlIHByaW1pdGl2ZSB2YXJpYWJsZSB3cmFwcGVyIGNsYXNzZXMsCi0JICogWydqYXZhLmxhbmcuQm9vbGVhbicsICdqYXZhLmxhbmcuSW50ZWdlcicsICdqYXZhLmxhbmcuRmxvYXQnLCBldGMuXSkuCi0JICogTkI6IHZvaWQuY2xhc3MuaXNQcmltaXRpdmUoKSA9PSB0cnVlCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNsYXNzSXNQcmltaXRpdmVXcmFwcGVyQ2xhc3MoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCWlmIChqYXZhQ2xhc3MuaXNBcnJheSgpIHx8IChqYXZhQ2xhc3MuZ2V0TmFtZSgpLmxlbmd0aCgpID4gbWF4UHJpbWl0aXZlV3JhcHBlckNsYXNzTmFtZUxlbmd0aCgpKSkgewotCQkJcmV0dXJuIGZhbHNlOyAgLy8gcGVyZm9ybWFuY2UgdHdlYWsKLQkJfQotCQlQcmltaXRpdmVbXSBjb2RlcyA9IHByaW1pdGl2ZXMoKTsKLQkJZm9yIChpbnQgaSA9IGNvZGVzLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlpZiAoY29kZXNbaV0ud3JhcHBlckNsYXNzID09IGphdmFDbGFzcykgewotCQkJCXJldHVybiB0cnVlOwotCQkJfQotCQl9Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gd2hldGhlciB0aGUgc3BlY2lmaWVkIGNsYXNzIGlzIGEgInZhcmlhYmxlIiBwcmltaXRpdmUKLQkgKiBjbGFzcyAoaS5lLiAnYm9vbGVhbicsICdpbnQnLCAnZmxvYXQnLCBldGMuLCBidXQgbm90ICd2b2lkJykuCi0JICogTkI6IHZvaWQuY2xhc3MuaXNQcmltaXRpdmUoKSA9PSB0cnVlCi0JICovCi0JcHVibGljIHN0YXRpYyBib29sZWFuIGNsYXNzSXNWYXJpYWJsZVByaW1pdGl2ZVdyYXBwZXJDbGFzcyhDbGFzczw/PiBqYXZhQ2xhc3MpIHsKLQkJcmV0dXJuIGNsYXNzSXNQcmltaXRpdmVXcmFwcGVyQ2xhc3MoamF2YUNsYXNzKQotCQkJJiYgKGphdmFDbGFzcyAhPSBqYXZhLmxhbmcuVm9pZC5jbGFzcyk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjbGFzcyBuYW1lIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzIGNvZGUuCi0JICogQHNlZSBqYXZhLmxhbmcuQ2xhc3MjZ2V0TmFtZSgpCi0JICovCi0JcHVibGljIHN0YXRpYyBTdHJpbmcgY2xhc3NOYW1lRm9yQ29kZShjaGFyIGNsYXNzQ29kZSkgewotCQlyZXR1cm4gY2xhc3NGb3JDb2RlKGNsYXNzQ29kZSkuZ2V0TmFtZSgpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNsYXNzIG5hbWUgZm9yIHRoZSBzcGVjaWZpZWQgY2xhc3MgY29kZS4KLQkgKiBAc2VlIGphdmEubGFuZy5DbGFzcyNnZXROYW1lKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBjbGFzc05hbWVGb3JDb2RlKGludCBjbGFzc0NvZGUpIHsKLQkJcmV0dXJuIGNsYXNzTmFtZUZvckNvZGUoKGNoYXIpIGNsYXNzQ29kZSk7Ci0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgY2xhc3MgZm9yIHRoZSBzcGVjaWZpZWQgY2xhc3MgY29kZS4KLQkgKiBAc2VlIGphdmEubGFuZy5DbGFzcyNnZXROYW1lKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIENsYXNzPD8+IGNsYXNzRm9yQ29kZShjaGFyIGNsYXNzQ29kZSkgewotCQlQcmltaXRpdmVbXSBjb2RlcyA9IHByaW1pdGl2ZXMoKTsKLQkJZm9yIChpbnQgaSA9IGNvZGVzLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlpZiAoY29kZXNbaV0uY29kZSA9PSBjbGFzc0NvZGUpIHsKLQkJCQlyZXR1cm4gY29kZXNbaV0uamF2YUNsYXNzOwotCQkJfQotCQl9Ci0JCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oU3RyaW5nLnZhbHVlT2YoY2xhc3NDb2RlKSk7Ci0JfQotCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjbGFzcyBmb3IgdGhlIHNwZWNpZmllZCBjbGFzcyBjb2RlLgotCSAqIEBzZWUgamF2YS5sYW5nLkNsYXNzI2dldE5hbWUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgQ2xhc3M8Pz4gY2xhc3NGb3JDb2RlKGludCBjbGFzc0NvZGUpIHsKLQkJcmV0dXJuIGNsYXNzRm9yQ29kZSgoY2hhcikgY2xhc3NDb2RlKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjbGFzcyBjb2RlIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzLgotCSAqIEBzZWUgamF2YS5sYW5nLkNsYXNzI2dldE5hbWUoKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2hhciBjb2RlRm9yQ2xhc3MoQ2xhc3M8Pz4gamF2YUNsYXNzKSB7Ci0JCWlmICgoICEgamF2YUNsYXNzLmlzQXJyYXkoKSkgJiYgKGphdmFDbGFzcy5nZXROYW1lKCkubGVuZ3RoKCkgPD0gbWF4UHJpbWl0aXZlQ2xhc3NOYW1lTGVuZ3RoKCkpKSB7Ci0JCQlQcmltaXRpdmVbXSBjb2RlcyA9IHByaW1pdGl2ZXMoKTsKLQkJCWZvciAoaW50IGkgPSBjb2Rlcy5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJCWlmIChjb2Rlc1tpXS5qYXZhQ2xhc3MgPT0gamF2YUNsYXNzKSB7Ci0JCQkJCXJldHVybiBjb2Rlc1tpXS5jb2RlOwotCQkJCX0KLQkJCX0KLQkJfQotCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKGphdmFDbGFzcy5nZXROYW1lKCkpOwkJCi0JfQotCQotCS8qKgotCSAqIFJldHVybiB0aGUgY2xhc3MgY29kZSBmb3IgdGhlIHNwZWNpZmllZCBjbGFzcy4KLQkgKiBAc2VlIGphdmEubGFuZy5DbGFzcyNnZXROYW1lKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNoYXIgY29kZUZvckNsYXNzTmFtZWQoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlpZiAoKCAhIGNsYXNzTmFtZWRJc0FycmF5KGNsYXNzTmFtZSkpICYmIChjbGFzc05hbWUubGVuZ3RoKCkgPD0gbWF4UHJpbWl0aXZlQ2xhc3NOYW1lTGVuZ3RoKCkpKSB7Ci0JCQlQcmltaXRpdmVbXSBjb2RlcyA9IHByaW1pdGl2ZXMoKTsKLQkJCWZvciAoaW50IGkgPSBjb2Rlcy5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJCWlmIChjb2Rlc1tpXS5qYXZhQ2xhc3MuZ2V0TmFtZSgpLmVxdWFscyhjbGFzc05hbWUpKSB7Ci0JCQkJCXJldHVybiBjb2Rlc1tpXS5jb2RlOwotCQkJCX0KLQkJCX0KLQkJfQotCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKGNsYXNzTmFtZSk7CQkKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNsYXNzIGZvciB0aGUgc3BlY2lmaWVkICJ0eXBlIGRlY2xhcmF0aW9uIi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIENsYXNzPD8+IGNsYXNzRm9yVHlwZURlY2xhcmF0aW9uKFN0cmluZyB0eXBlRGVjbGFyYXRpb24pIHRocm93cyBDbGFzc05vdEZvdW5kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIGNsYXNzRm9yVHlwZURlY2xhcmF0aW9uKHR5cGVEZWNsYXJhdGlvbiwgQ2xhc3NUb29scy5jbGFzcy5nZXRDbGFzc0xvYWRlcigpKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjbGFzcyBmb3IgdGhlIHNwZWNpZmllZCAidHlwZSBkZWNsYXJhdGlvbiIsCi0JICogdXNpbmcgdGhlIHNwZWNpZmllZCBjbGFzcyBsb2FkZXIuCi0JICovCi0JcHVibGljIHN0YXRpYyBDbGFzczw/PiBjbGFzc0ZvclR5cGVEZWNsYXJhdGlvbihTdHJpbmcgdHlwZURlY2xhcmF0aW9uLCBDbGFzc0xvYWRlciBjbGFzc0xvYWRlcikgdGhyb3dzIENsYXNzTm90Rm91bmRFeGNlcHRpb24gewotCQlUeXBlRGVjbGFyYXRpb24gdGQgPSB0eXBlRGVjbGFyYXRpb24odHlwZURlY2xhcmF0aW9uKTsKLQkJcmV0dXJuIGNsYXNzRm9yVHlwZURlY2xhcmF0aW9uKHRkLmVsZW1lbnRUeXBlTmFtZSwgdGQuYXJyYXlEZXB0aCk7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgVHlwZURlY2xhcmF0aW9uIHR5cGVEZWNsYXJhdGlvbihTdHJpbmcgdHlwZURlY2xhcmF0aW9uKSB7Ci0JCXR5cGVEZWNsYXJhdGlvbiA9IFN0cmluZ1Rvb2xzLnJlbW92ZUFsbFdoaXRlc3BhY2UodHlwZURlY2xhcmF0aW9uKTsKLQkJaW50IGFycmF5RGVwdGggPSBhcnJheURlcHRoRm9yVHlwZURlY2xhcmF0aW9uXyh0eXBlRGVjbGFyYXRpb24pOwotCQlTdHJpbmcgZWxlbWVudFR5cGVOYW1lID0gdHlwZURlY2xhcmF0aW9uLnN1YnN0cmluZygwLCB0eXBlRGVjbGFyYXRpb24ubGVuZ3RoKCkgLSAoYXJyYXlEZXB0aCAqIDIpKTsKLQkJcmV0dXJuIG5ldyBUeXBlRGVjbGFyYXRpb24oZWxlbWVudFR5cGVOYW1lLCBhcnJheURlcHRoKTsKLQl9Ci0KLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNsYXNzIGZvciB0aGUgc3BlY2lmaWVkICJ0eXBlIGRlY2xhcmF0aW9uIi4KLQkgKi8KLQlwdWJsaWMgc3RhdGljIENsYXNzPD8+IGNsYXNzRm9yVHlwZURlY2xhcmF0aW9uKFN0cmluZyBlbGVtZW50VHlwZU5hbWUsIGludCBhcnJheURlcHRoKSB0aHJvd3MgQ2xhc3NOb3RGb3VuZEV4Y2VwdGlvbiB7Ci0JCXJldHVybiBjbGFzc0ZvclR5cGVEZWNsYXJhdGlvbihlbGVtZW50VHlwZU5hbWUsIGFycmF5RGVwdGgsIG51bGwpOwotCX0KLQkKLQkvKioKLQkgKiBSZXR1cm4gdGhlIGNsYXNzIGZvciB0aGUgc3BlY2lmaWVkICJ0eXBlIGRlY2xhcmF0aW9uIiwKLQkgKiB1c2luZyB0aGUgc3BlY2lmaWVkIGNsYXNzIGxvYWRlci4KLQkgKi8KLQkvLyBzZWUgdGhlICJFdmFsdWF0aW9uIiBvZiBqZGsgYnVnIDY0NDY2MjcgZm9yIGEgZGlzY3Vzc2lvbiBvZiBsb2FkaW5nIGNsYXNzZXMKLQlwdWJsaWMgc3RhdGljIENsYXNzPD8+IGNsYXNzRm9yVHlwZURlY2xhcmF0aW9uKFN0cmluZyBlbGVtZW50VHlwZU5hbWUsIGludCBhcnJheURlcHRoLCBDbGFzc0xvYWRlciBjbGFzc0xvYWRlcikgdGhyb3dzIENsYXNzTm90Rm91bmRFeGNlcHRpb24gewotCQkvLyBwcmltaXRpdmVzIGNhbm5vdCBiZSBsb2FkZWQgdmlhIENsYXNzI2Zvck5hbWUoKSwKLQkJLy8gc28gY2hlY2sgZm9yIGEgcHJpbWl0aXZlIGNsYXNzIG5hbWUgZmlyc3QKLQkJUHJpbWl0aXZlIHBjYyA9IG51bGw7Ci0JCWlmIChlbGVtZW50VHlwZU5hbWUubGVuZ3RoKCkgPD0gbWF4UHJpbWl0aXZlQ2xhc3NOYW1lTGVuZ3RoKCkpIHsgIC8vIHBlcmZvcm1hbmNlIHR3ZWFrCi0JCQlQcmltaXRpdmVbXSBjb2RlcyA9IHByaW1pdGl2ZXMoKTsKLQkJCWZvciAoaW50IGkgPSBjb2Rlcy5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJCWlmIChjb2Rlc1tpXS5qYXZhQ2xhc3MuZ2V0TmFtZSgpLmVxdWFscyhlbGVtZW50VHlwZU5hbWUpKSB7Ci0JCQkJCXBjYyA9IGNvZGVzW2ldOwotCQkJCQlicmVhazsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQotCQkvLyBub24tYXJyYXkKLQkJaWYgKGFycmF5RGVwdGggPT0gMCkgewotCQkJcmV0dXJuIChwY2MgPT0gbnVsbCkgPyBDbGFzcy5mb3JOYW1lKGVsZW1lbnRUeXBlTmFtZSwgZmFsc2UsIGNsYXNzTG9hZGVyKSA6IHBjYy5qYXZhQ2xhc3M7Ci0JCX0KLQotCQkvLyBhcnJheQotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoMTAwKTsKLQkJZm9yIChpbnQgaSA9IGFycmF5RGVwdGg7IGktLSA+IDA7ICkgewotCQkJc2IuYXBwZW5kKEFSUkFZX0lORElDQVRPUik7Ci0JCX0KLQkJaWYgKHBjYyA9PSBudWxsKSB7Ci0JCQlzYi5hcHBlbmQoUkVGRVJFTkNFX0NMQVNTX0NPREUpOwotCQkJc2IuYXBwZW5kKGVsZW1lbnRUeXBlTmFtZSk7Ci0JCQlzYi5hcHBlbmQoUkVGRVJFTkNFX0NMQVNTX05BTUVfREVMSU1JVEVSKTsKLQkJfSBlbHNlIHsKLQkJCXNiLmFwcGVuZChwY2MuY29kZSk7Ci0JCX0KLQkJcmV0dXJuIENsYXNzLmZvck5hbWUoc2IudG9TdHJpbmcoKSwgZmFsc2UsIGNsYXNzTG9hZGVyKTsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjbGFzcyBuYW1lIGZvciB0aGUgc3BlY2lmaWVkICJ0eXBlIGRlY2xhcmF0aW9uIjsgZS5nLgotCSAqICAgICAiaW50W10iIC0+ICJbSSIKLQkgKiBAc2VlIGphdmEubGFuZy5DbGFzcyNnZXROYW1lKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBjbGFzc05hbWVGb3JUeXBlRGVjbGFyYXRpb24oU3RyaW5nIHR5cGVEZWNsYXJhdGlvbikgewotCQlUeXBlRGVjbGFyYXRpb24gdGQgPSB0eXBlRGVjbGFyYXRpb24odHlwZURlY2xhcmF0aW9uKTsKLQkJcmV0dXJuIGNsYXNzTmFtZUZvclR5cGVEZWNsYXJhdGlvbih0ZC5lbGVtZW50VHlwZU5hbWUsIHRkLmFycmF5RGVwdGgpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgYXJyYXkgZGVwdGggZm9yIHRoZSBzcGVjaWZpZWQgInR5cGUgZGVjbGFyYXRpb24iOyBlLmcuCi0JICogICAgICJpbnRbXSIgLT4gMQotCSAqLwotCXB1YmxpYyBzdGF0aWMgaW50IGFycmF5RGVwdGhGb3JUeXBlRGVjbGFyYXRpb24oU3RyaW5nIHR5cGVEZWNsYXJhdGlvbikgewotCQlyZXR1cm4gYXJyYXlEZXB0aEZvclR5cGVEZWNsYXJhdGlvbl8oU3RyaW5nVG9vbHMucmVtb3ZlQWxsV2hpdGVzcGFjZSh0eXBlRGVjbGFyYXRpb24pKTsKLQl9Ci0KLQkvKgotCSAqIEFzc3VtZSBubyB3aGl0ZXNwYWNlIGluIHRoZSB0eXBlIGRlY2xhcmF0aW9uLgotCSAqLwotCXByaXZhdGUgc3RhdGljIGludCBhcnJheURlcHRoRm9yVHlwZURlY2xhcmF0aW9uXyhTdHJpbmcgdHlwZURlY2xhcmF0aW9uKSB7Ci0JCWludCBsYXN0ID0gdHlwZURlY2xhcmF0aW9uLmxlbmd0aCgpIC0gMTsKLQkJaW50IGRlcHRoID0gMDsKLQkJaW50IGNsb3NlID0gbGFzdDsKLQkJd2hpbGUgKHR5cGVEZWNsYXJhdGlvbi5jaGFyQXQoY2xvc2UpID09IFRZUEVfREVDTEFSQVRJT05fQVJSQVlfQ0xPU0UpIHsKLQkJCWlmICh0eXBlRGVjbGFyYXRpb24uY2hhckF0KGNsb3NlIC0gMSkgPT0gVFlQRV9ERUNMQVJBVElPTl9BUlJBWV9PUEVOKSB7Ci0JCQkJZGVwdGgrKzsKLQkJCX0gZWxzZSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigiaW52YWxpZCB0eXBlIGRlY2xhcmF0aW9uOiAiICsgdHlwZURlY2xhcmF0aW9uKTsKLQkJCX0KLQkJCWNsb3NlID0gbGFzdCAtIChkZXB0aCAqIDIpOwotCQl9Ci0JCXJldHVybiBkZXB0aDsKLQl9Ci0JCi0JLyoqCi0JICogUmV0dXJuIHRoZSBjbGFzcyBuYW1lIGZvciB0aGUgc3BlY2lmaWVkICJ0eXBlIGRlY2xhcmF0aW9uIi4KLQkgKiBAc2VlIGphdmEubGFuZy5DbGFzcyNnZXROYW1lKCkKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBjbGFzc05hbWVGb3JUeXBlRGVjbGFyYXRpb24oU3RyaW5nIGVsZW1lbnRUeXBlTmFtZSwgaW50IGFycmF5RGVwdGgpIHsKLQkJLy8gbm9uLWFycmF5Ci0JCWlmIChhcnJheURlcHRoID09IDApIHsKLQkJCXJldHVybiBlbGVtZW50VHlwZU5hbWU7Ci0JCX0KLQotCQlpZiAoZWxlbWVudFR5cGVOYW1lLmVxdWFscyhWT0lEX0NMQVNTX05BTUUpKSB7Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCInIiArIFZPSURfQ0xBU1NfTkFNRSArICInIG11c3QgaGF2ZSBhbiBhcnJheSBkZXB0aCBvZiB6ZXJvOiAiICsgYXJyYXlEZXB0aCArICcuJyk7Ci0JCX0KLQkJLy8gYXJyYXkKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKDEwMCk7Ci0JCWZvciAoaW50IGkgPSBhcnJheURlcHRoOyBpLS0gPiAwOyApIHsKLQkJCXNiLmFwcGVuZChBUlJBWV9JTkRJQ0FUT1IpOwotCQl9Ci0KLQkJLy8gbG9vayBmb3IgYSBwcmltaXRpdmUgZmlyc3QKLQkJUHJpbWl0aXZlIHBjYyA9IG51bGw7Ci0JCWlmIChlbGVtZW50VHlwZU5hbWUubGVuZ3RoKCkgPD0gbWF4UHJpbWl0aXZlQ2xhc3NOYW1lTGVuZ3RoKCkpIHsgIC8vIHBlcmZvcm1hbmNlIHR3ZWFrCi0JCQlQcmltaXRpdmVbXSBjb2RlcyA9IHByaW1pdGl2ZXMoKTsKLQkJCWZvciAoaW50IGkgPSBjb2Rlcy5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJCWlmIChjb2Rlc1tpXS5qYXZhQ2xhc3MuZ2V0TmFtZSgpLmVxdWFscyhlbGVtZW50VHlwZU5hbWUpKSB7Ci0JCQkJCXBjYyA9IGNvZGVzW2ldOwotCQkJCQlicmVhazsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQotCQlpZiAocGNjID09IG51bGwpIHsKLQkJCXNiLmFwcGVuZChSRUZFUkVOQ0VfQ0xBU1NfQ09ERSk7Ci0JCQlzYi5hcHBlbmQoZWxlbWVudFR5cGVOYW1lKTsKLQkJCXNiLmFwcGVuZChSRUZFUkVOQ0VfQ0xBU1NfTkFNRV9ERUxJTUlURVIpOwotCQl9IGVsc2UgewotCQkJc2IuYXBwZW5kKHBjYy5jb2RlKTsKLQkJfQotCi0JCXJldHVybiBzYi50b1N0cmluZygpOwotCX0KLQotCXByaXZhdGUgc3RhdGljIGludCBtYXhQcmltaXRpdmVDbGFzc05hbWVMZW5ndGgoKSB7Ci0JCWlmIChNQVhfUFJJTUlUSVZFX0NMQVNTX05BTUVfTEVOR1RIID09IC0xKSB7Ci0JCQlNQVhfUFJJTUlUSVZFX0NMQVNTX05BTUVfTEVOR1RIID0gY2FsY3VsYXRlTWF4UHJpbWl0aXZlQ2xhc3NOYW1lTGVuZ3RoKCk7Ci0JCX0KLQkJcmV0dXJuIE1BWF9QUklNSVRJVkVfQ0xBU1NfTkFNRV9MRU5HVEg7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgaW50IGNhbGN1bGF0ZU1heFByaW1pdGl2ZUNsYXNzTmFtZUxlbmd0aCgpIHsKLQkJaW50IG1heCA9IC0xOwotCQlQcmltaXRpdmVbXSBjb2RlcyA9IHByaW1pdGl2ZXMoKTsKLQkJZm9yIChpbnQgaSA9IGNvZGVzLmxlbmd0aDsgaS0tID4gMDsgKSB7Ci0JCQlpbnQgbGVuID0gY29kZXNbaV0uamF2YUNsYXNzLmdldE5hbWUoKS5sZW5ndGgoKTsKLQkJCWlmIChsZW4gPiBtYXgpIHsKLQkJCQltYXggPSBsZW47Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIG1heDsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBpbnQgbWF4UHJpbWl0aXZlV3JhcHBlckNsYXNzTmFtZUxlbmd0aCgpIHsKLQkJaWYgKE1BWF9QUklNSVRJVkVfV1JBUFBFUl9DTEFTU19OQU1FX0xFTkdUSCA9PSAtMSkgewotCQkJTUFYX1BSSU1JVElWRV9XUkFQUEVSX0NMQVNTX05BTUVfTEVOR1RIID0gY2FsY3VsYXRlTWF4UHJpbWl0aXZlV3JhcHBlckNsYXNzTmFtZUxlbmd0aCgpOwotCQl9Ci0JCXJldHVybiBNQVhfUFJJTUlUSVZFX1dSQVBQRVJfQ0xBU1NfTkFNRV9MRU5HVEg7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgaW50IGNhbGN1bGF0ZU1heFByaW1pdGl2ZVdyYXBwZXJDbGFzc05hbWVMZW5ndGgoKSB7Ci0JCWludCBtYXggPSAtMTsKLQkJUHJpbWl0aXZlW10gY29kZXMgPSBwcmltaXRpdmVzKCk7Ci0JCWZvciAoaW50IGkgPSBjb2Rlcy5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJaW50IGxlbiA9IGNvZGVzW2ldLndyYXBwZXJDbGFzcy5nZXROYW1lKCkubGVuZ3RoKCk7Ci0JCQlpZiAobGVuID4gbWF4KSB7Ci0JCQkJbWF4ID0gbGVuOwotCQkJfQotCQl9Ci0JCXJldHVybiBtYXg7Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgUHJpbWl0aXZlW10gcHJpbWl0aXZlcygpIHsKLQkJaWYgKFBSSU1JVElWRVMgPT0gbnVsbCkgewotCQkJUFJJTUlUSVZFUyA9IGJ1aWxkUHJpbWl0aXZlcygpOwotCQl9Ci0JCXJldHVybiBQUklNSVRJVkVTOwotCX0KLQkKLQkvKioKLQkgKiBOQjogdm9pZC5jbGFzcy5pc1ByaW1pdGl2ZSgpID09IHRydWUKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBQcmltaXRpdmVbXSBidWlsZFByaW1pdGl2ZXMoKSB7Ci0JCVByaW1pdGl2ZVtdIHJlc3VsdCA9IG5ldyBQcmltaXRpdmVbOV07Ci0JCXJlc3VsdFswXSA9IG5ldyBQcmltaXRpdmUoQllURV9DT0RFLCBqYXZhLmxhbmcuQnl0ZS5jbGFzcyk7Ci0JCXJlc3VsdFsxXSA9IG5ldyBQcmltaXRpdmUoQ0hBUl9DT0RFLCBqYXZhLmxhbmcuQ2hhcmFjdGVyLmNsYXNzKTsKLQkJcmVzdWx0WzJdID0gbmV3IFByaW1pdGl2ZShET1VCTEVfQ09ERSwgamF2YS5sYW5nLkRvdWJsZS5jbGFzcyk7Ci0JCXJlc3VsdFszXSA9IG5ldyBQcmltaXRpdmUoRkxPQVRfQ09ERSwgamF2YS5sYW5nLkZsb2F0LmNsYXNzKTsKLQkJcmVzdWx0WzRdID0gbmV3IFByaW1pdGl2ZShJTlRfQ09ERSwgamF2YS5sYW5nLkludGVnZXIuY2xhc3MpOwotCQlyZXN1bHRbNV0gPSBuZXcgUHJpbWl0aXZlKExPTkdfQ09ERSwgamF2YS5sYW5nLkxvbmcuY2xhc3MpOwotCQlyZXN1bHRbNl0gPSBuZXcgUHJpbWl0aXZlKFNIT1JUX0NPREUsIGphdmEubGFuZy5TaG9ydC5jbGFzcyk7Ci0JCXJlc3VsdFs3XSA9IG5ldyBQcmltaXRpdmUoQk9PTEVBTl9DT0RFLCBqYXZhLmxhbmcuQm9vbGVhbi5jbGFzcyk7Ci0JCXJlc3VsdFs4XSA9IG5ldyBQcmltaXRpdmUoVk9JRF9DT0RFLCBqYXZhLmxhbmcuVm9pZC5jbGFzcyk7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JLyoqCi0JICogU3VwcHJlc3MgZGVmYXVsdCBjb25zdHJ1Y3RvciwgZW5zdXJpbmcgbm9uLWluc3RhbnRpYWJpbGl0eS4KLQkgKi8KLQlwcml2YXRlIENsYXNzVG9vbHMoKSB7Ci0JCXN1cGVyKCk7Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBtZW1iZXIgY2xhc3NlcyAqKioqKioqKioqCi0KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBQcmltaXRpdmUgewotCQlmaW5hbCBjaGFyIGNvZGU7Ci0JCWZpbmFsIENsYXNzPD8+IGphdmFDbGFzczsKLQkJZmluYWwgQ2xhc3M8Pz4gd3JhcHBlckNsYXNzOwotCQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgV1JBUFBFUl9DTEFTU19UWVBFX0ZJRUxEX05BTUUgPSAiVFlQRSI7Ci0JCS8vIGUuZy4gamF2YS5sYW5nLkJvb2xlYW4uVFlQRSA9PiBib29sZWFuLmNsYXNzCi0JCVByaW1pdGl2ZShjaGFyIGNvZGUsIENsYXNzPD8+IHdyYXBwZXJDbGFzcykgewotCQkJdGhpcy5jb2RlID0gY29kZTsKLQkJCXRoaXMud3JhcHBlckNsYXNzID0gd3JhcHBlckNsYXNzOwotCQkJdGhpcy5qYXZhQ2xhc3MgPSAoQ2xhc3M8Pz4pIHN0YXRpY0ZpZWxkVmFsdWUod3JhcHBlckNsYXNzLCBXUkFQUEVSX0NMQVNTX1RZUEVfRklFTERfTkFNRSk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBUeXBlRGVjbGFyYXRpb24gewotCQlmaW5hbCBTdHJpbmcgZWxlbWVudFR5cGVOYW1lOwotCQlmaW5hbCBpbnQgYXJyYXlEZXB0aDsKLQkJVHlwZURlY2xhcmF0aW9uKFN0cmluZyBlbGVtZW50VHlwZU5hbWUsIGludCBhcnJheURlcHRoKSB7Ci0JCQl0aGlzLmVsZW1lbnRUeXBlTmFtZSA9IGVsZW1lbnRUeXBlTmFtZTsKLQkJCXRoaXMuYXJyYXlEZXB0aCA9IGFycmF5RGVwdGg7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvQml0VG9vbHNUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9CaXRUb29sc1Rlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhmMmU5YjguLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9CaXRUb29sc1Rlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyNDMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNiwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5CaXRUb29sczsKLQotcHVibGljIGNsYXNzIEJpdFRvb2xzVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQlwdWJsaWMgQml0VG9vbHNUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RmxhZ0lzU2V0SW50SW50KCkgewotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmZsYWdJc1NldCgweDAwMDMsIDB4MDAwMSkpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmZsYWdJc1NldCgweDAzMDMsIDB4MDAwMSkpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmZsYWdJc1NldCgweDAzMDMsIDB4MDEwMSkpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmZsYWdJc1NldCgweDAzMDMsIDB4MDEwMykpOwotCi0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLmZsYWdJc1NldCgweDAzMDMsIDB4MTEwMykpOwotCQlhc3NlcnRGYWxzZShCaXRUb29scy5mbGFnSXNTZXQoMHgwMDAwLCAweDExMDMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RmxhZ0lzT2ZmSW50SW50KCkgewotCQlhc3NlcnRGYWxzZShCaXRUb29scy5mbGFnSXNPZmYoMHgwMDAzLCAweDAwMDEpKTsKLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMuZmxhZ0lzT2ZmKDB4MDMwMywgMHgwMDAxKSk7Ci0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLmZsYWdJc09mZigweDAzMDMsIDB4MDEwMSkpOwotCQlhc3NlcnRGYWxzZShCaXRUb29scy5mbGFnSXNPZmYoMHgwMzAzLCAweDAxMDMpKTsKLQotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmZsYWdJc09mZigweDIyMDQsIDB4MTEwMykpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmZsYWdJc09mZigweDAwMDAsIDB4MTEwMykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RPbmx5RmxhZ0lzU2V0SW50SW50KCkgewotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ0lzU2V0KDB4MDAwMywgMHgwMDAxKSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMub25seUZsYWdJc1NldCgweDAwMDEsIDB4MDAwMSkpOwotCi0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLm9ubHlGbGFnSXNTZXQoMHgwMzAzLCAweDAwMDEpKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5vbmx5RmxhZ0lzU2V0KDB4MDAwMSwgMHgwMDAxKSk7Ci0KLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMub25seUZsYWdJc1NldCgweDAzMDMsIDB4MDEwMSkpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLm9ubHlGbGFnSXNTZXQoMHgwMTAxLCAweDAxMDEpKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ0lzU2V0KDB4MDMwMywgMHgwMTAzKSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMub25seUZsYWdJc1NldCgweDAxMDMsIDB4MDEwMykpOwotCi0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLm9ubHlGbGFnSXNTZXQoMHgwMzAzLCAweDExMDMpKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5vbmx5RmxhZ0lzU2V0KDB4MTEwMywgMHgxMTAzKSk7Ci0KLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMub25seUZsYWdJc1NldCgweDAwMDAsIDB4MTEwMykpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLm9ubHlGbGFnSXNTZXQoMHgwMTAzLCAweDAxMDMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0T25seUZsYWdJc09mZkludEludCgpIHsKLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMub25seUZsYWdJc09mZigweDAwMDMsIDB4MDAwMSkpOwotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ0lzT2ZmKDB4MDMwMywgMHgwMDAxKSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMub25seUZsYWdJc09mZigweEZGRkZGRkZFLCAweDAwMDEpKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ0lzT2ZmKDB4MDMwMywgMHgwMTAxKSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMub25seUZsYWdJc09mZigweEZGRkZGRUZFLCAweDAxMDEpKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ0lzT2ZmKDB4MDMwMywgMHgwMTAzKSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMub25seUZsYWdJc09mZigweEZGRkZGRUZDLCAweDAxMDMpKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ0lzT2ZmKDB4MDMwMywgMHgxMTAzKSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMub25seUZsYWdJc09mZigweEZGRkZFRUZDLCAweDExMDMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWxsRmxhZ3NBcmVTZXRJbnRJbnQoKSB7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMuYWxsRmxhZ3NBcmVTZXQoMHgwMDAzLCAweDAwMDEpKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5hbGxGbGFnc0FyZVNldCgweDAzMDMsIDB4MDAwMSkpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmFsbEZsYWdzQXJlU2V0KDB4MDMwMywgMHgwMTAxKSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMuYWxsRmxhZ3NBcmVTZXQoMHgwMzAzLCAweDAxMDMpKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5hbGxGbGFnc0FyZVNldCgweDAzMDMsIDB4MTEwMykpOwotCQlhc3NlcnRGYWxzZShCaXRUb29scy5hbGxGbGFnc0FyZVNldCgweDAwMDAsIDB4MTEwMykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBbGxGbGFnc0FyZU9mZkludEludCgpIHsKLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMuYWxsRmxhZ3NBcmVPZmYoMHgwMDAzLCAweDAwMDEpKTsKLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMuYWxsRmxhZ3NBcmVPZmYoMHgwMzAzLCAweDAwMDEpKTsKLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMuYWxsRmxhZ3NBcmVPZmYoMHgwMzAzLCAweDAxMDEpKTsKLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMuYWxsRmxhZ3NBcmVPZmYoMHgwMzAzLCAweDAxMDMpKTsKLQotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmFsbEZsYWdzQXJlT2ZmKDB4MjIwNCwgMHgxMTAzKSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMuYWxsRmxhZ3NBcmVPZmYoMHgwMDAwLCAweDExMDMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0T25seUZsYWdzQXJlU2V0SW50SW50KCkgewotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgwMDAzLCAweDAwMDEpKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgwMDAxLCAweDAwMDEpKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgwMzAzLCAweDAwMDEpKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgwMDAxLCAweDAwMDEpKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgwMzAzLCAweDAxMDEpKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgwMTAxLCAweDAxMDEpKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgwMzAzLCAweDAxMDMpKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgwMTAzLCAweDAxMDMpKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgwMzAzLCAweDExMDMpKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgxMTAzLCAweDExMDMpKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgwMDAwLCAweDExMDMpKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgwMTAzLCAweDAxMDMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0T25seUZsYWdzQXJlT2ZmSW50SW50KCkgewotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ3NBcmVPZmYoMHgwMDAzLCAweDAwMDEpKTsKLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMub25seUZsYWdzQXJlT2ZmKDB4MDMwMywgMHgwMDAxKSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMub25seUZsYWdzQXJlT2ZmKDB4RkZGRkZGRkUsIDB4MDAwMSkpOwotCi0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLm9ubHlGbGFnc0FyZU9mZigweDAzMDMsIDB4MDEwMSkpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLm9ubHlGbGFnc0FyZU9mZigweEZGRkZGRUZFLCAweDAxMDEpKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ3NBcmVPZmYoMHgwMzAzLCAweDAxMDMpKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5vbmx5RmxhZ3NBcmVPZmYoMHhGRkZGRkVGQywgMHgwMTAzKSk7Ci0KLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMub25seUZsYWdzQXJlT2ZmKDB4MDMwMywgMHgxMTAzKSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMub25seUZsYWdzQXJlT2ZmKDB4RkZGRkVFRkMsIDB4MTEwMykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBbnlGbGFnc0FyZVNldEludEludCgpIHsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5hbnlGbGFnc0FyZVNldCgweDAwMDMsIDB4MDAwMSkpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmFueUZsYWdzQXJlU2V0KDB4RkZGRiwgMHgwMDAxKSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMuYW55RmxhZ3NBcmVTZXQoMHgwMDAzLCAweEZGRkYpKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5hbnlGbGFnc0FyZVNldCgweDAzMDMsIDB4MTAxMCkpOwotCQlhc3NlcnRGYWxzZShCaXRUb29scy5hbnlGbGFnc0FyZVNldCgweDAwMDAsIDB4RkZGRikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBbnlGbGFnc0FyZU9mZkludEludCgpIHsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5hbnlGbGFnc0FyZU9mZigweDMzM0UsIDB4MDAwMSkpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmFueUZsYWdzQXJlT2ZmKDB4RkZGRSwgMHgwMDAxKSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMuYW55RmxhZ3NBcmVPZmYoMHgwMDAzLCAweEZGRkYpKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5hbnlGbGFnc0FyZU9mZigweDczNzMsIDB4MTAxMCkpOwotCQlhc3NlcnRGYWxzZShCaXRUb29scy5hbnlGbGFnc0FyZU9mZigweEZGRkYsIDB4RkZGRikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBbGxGbGFnc0FyZVNldEludEludEFycmF5KCkgewotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmFsbEZsYWdzQXJlU2V0KDB4MDAwMywgbmV3IGludFtdIHsgMHgwMDAxIH0pKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5hbGxGbGFnc0FyZVNldCgweDAzMDMsIG5ldyBpbnRbXSB7IDB4MDAwMSB9KSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMuYWxsRmxhZ3NBcmVTZXQoMHgwMzAzLCBuZXcgaW50W10geyAweDAxMDAsIDB4MDAwMSB9KSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMuYWxsRmxhZ3NBcmVTZXQoMHgwMzAzLCBuZXcgaW50W10geyAweDAxMDAsIDB4MDAwMiwgMHgwMDAxIH0pKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5hbGxGbGFnc0FyZVNldCgweDAzMDMsIG5ldyBpbnRbXSB7IDB4MTAwMCwgMHgwMTAwLCAweDAwMDIsIDB4MDAwMSB9KSk7Ci0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLmFsbEZsYWdzQXJlU2V0KDB4MDAwMCwgbmV3IGludFtdIHsgMHgxMDAwLCAweDAxMDAsIDB4MDAwMiwgMHgwMDAxIH0pKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWxsRmxhZ3NBcmVPZmZJbnRJbnRBcnJheSgpIHsKLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMuYWxsRmxhZ3NBcmVPZmYoMHgwMDAzLCBuZXcgaW50W10geyAweDAwMDEgfSkpOwotCQlhc3NlcnRGYWxzZShCaXRUb29scy5hbGxGbGFnc0FyZU9mZigweDAzMDMsIG5ldyBpbnRbXSB7IDB4MDAwMSB9KSk7Ci0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLmFsbEZsYWdzQXJlT2ZmKDB4MDMwMywgbmV3IGludFtdIHsgMHgwMTAwLCAweDAwMDEgfSkpOwotCQlhc3NlcnRGYWxzZShCaXRUb29scy5hbGxGbGFnc0FyZU9mZigweDAzMDMsIG5ldyBpbnRbXSB7IDB4MDEwMCwgMHgwMDAyLCAweDAwMDEgfSkpOwotCi0JCWFzc2VydFRydWUoQml0VG9vbHMuYWxsRmxhZ3NBcmVPZmYoMHgwMzAzLCBuZXcgaW50W10geyAweDEwMDAsIDB4MDQwMCwgMHgwMDIwLCAweDAwMDAgfSkpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmFsbEZsYWdzQXJlT2ZmKDB4MDAwMCwgbmV3IGludFtdIHsgMHgxMDAwLCAweDAxMDAsIDB4MDAwMiwgMHgwMDAxIH0pKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0T25seUZsYWdzQXJlU2V0SW50SW50QXJyYXkoKSB7Ci0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLm9ubHlGbGFnc0FyZVNldCgweDAwMDMsIG5ldyBpbnRbXSB7IDB4MDAxLCAweDAwMDAsIDB4MDAwMCwgMHgwMDAxIH0pKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgwMDAxLCBuZXcgaW50W10geyAweDAwMSwgMHgwMDAwLCAweDAwMDAsIDB4MDAwMSB9KSk7Ci0KLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMub25seUZsYWdzQXJlU2V0KDB4MDMwMywgbmV3IGludFtdIHsgMHgwMDEsIDB4MDAwMCwgMHgwMDAwLCAweDAwMDEgfSkpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLm9ubHlGbGFnc0FyZVNldCgweDAwMDEsIG5ldyBpbnRbXSB7IDB4MDAxLCAweDAwMDAsIDB4MDAwMCwgMHgwMDAxIH0pKTsKLQotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgwMzAzLCBuZXcgaW50W10geyAweDAwMSwgMHgwMTAwLCAweDAwMDAsIDB4MDAwMSB9KSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMub25seUZsYWdzQXJlU2V0KDB4MDEwMSwgbmV3IGludFtdIHsgMHgwMDEsIDB4MDEwMCwgMHgwMDAwLCAweDAwMDEgfSkpOwotCi0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLm9ubHlGbGFnc0FyZVNldCgweDAzMDMsIG5ldyBpbnRbXSB7IDB4MDAxLCAweDAxMDAsIDB4MDAwMiwgMHgwMDAxIH0pKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5vbmx5RmxhZ3NBcmVTZXQoMHgwMTAzLCBuZXcgaW50W10geyAweDAwMSwgMHgwMTAwLCAweDAwMDIsIDB4MDAwMSB9KSk7Ci0KLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMub25seUZsYWdzQXJlU2V0KDB4MDMwMywgbmV3IGludFtdIHsgMHgwMTEsIDB4MDEwMCwgMHgwMDAyLCAweDAwMDEgfSkpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLm9ubHlGbGFnc0FyZVNldCgweDExMDMsIG5ldyBpbnRbXSB7IDB4MTEwMCwgMHgwMTAwLCAweDAwMDIsIDB4MDAwMSB9KSk7Ci0KLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMub25seUZsYWdzQXJlU2V0KDB4MDAwMCwgbmV3IGludFtdIHsgMHgwMTEsIDB4MDEwMCwgMHgwMDAyLCAweDAwMDEgfSkpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLm9ubHlGbGFnc0FyZVNldCgweDAxMDMsIG5ldyBpbnRbXSB7IDB4MDEwMSwgMHgwMTAwLCAweDAwMDIsIDB4MDAwMSB9KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE9ubHlGbGFnc0FyZU9mZkludEludEFycmF5KCkgewotCQlhc3NlcnRGYWxzZShCaXRUb29scy5vbmx5RmxhZ3NBcmVPZmYoMHgwMDAzLCBuZXcgaW50W10geyAweDAwMSwgMHgwMDAwLCAweDAwMDAsIDB4MDAwMSB9KSk7Ci0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLm9ubHlGbGFnc0FyZU9mZigweDAzMDMsIG5ldyBpbnRbXSB7IDB4MDAxLCAweDAwMDAsIDB4MDAwMCwgMHgwMDAxIH0pKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5vbmx5RmxhZ3NBcmVPZmYoMHhGRkZGRkZGRSwgbmV3IGludFtdIHsgMHgwMDEsIDB4MDAwMCwgMHgwMDAwLCAweDAwMDEgfSkpOwotCi0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLm9ubHlGbGFnc0FyZU9mZigweDAzMDMsIG5ldyBpbnRbXSB7IDB4MDAxLCAweDAxMDAsIDB4MDAwMCwgMHgwMDAxIH0pKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5vbmx5RmxhZ3NBcmVPZmYoMHhGRkZGRkVGRSwgbmV3IGludFtdIHsgMHgwMDEsIDB4MDEwMCwgMHgwMDAwLCAweDAwMDEgfSkpOwotCi0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLm9ubHlGbGFnc0FyZU9mZigweDAzMDMsIG5ldyBpbnRbXSB7IDB4MDAxLCAweDAxMDAsIDB4MDAwMiwgMHgwMDAxIH0pKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5vbmx5RmxhZ3NBcmVPZmYoMHhGRkZGRkVGQywgbmV3IGludFtdIHsgMHgwMDEsIDB4MDEwMCwgMHgwMDAyLCAweDAwMDEgfSkpOwotCi0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLm9ubHlGbGFnc0FyZU9mZigweDAzMDMsIG5ldyBpbnRbXSB7IDB4MTEwMCwgMHgwMTAwLCAweDAwMDIsIDB4MDAwMSB9KSk7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMub25seUZsYWdzQXJlT2ZmKDB4RkZGRkVFRkMsIG5ldyBpbnRbXSB7IDB4MTEwMCwgMHgwMTAwLCAweDAwMDIsIDB4MDAwMSB9KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFueUZsYWdzQXJlU2V0SW50SW50QXJyYXkoKSB7Ci0JCWFzc2VydFRydWUoQml0VG9vbHMuYW55RmxhZ3NBcmVTZXQoMHgwMDAzLCBuZXcgaW50W10geyAweDAwMDEgfSkpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmFueUZsYWdzQXJlU2V0KDB4RkZGRiwgbmV3IGludFtdIHsgMHgwMDAxIH0pKTsKLQkJYXNzZXJ0VHJ1ZShCaXRUb29scy5hbnlGbGFnc0FyZVNldCgweDAzMDMsIG5ldyBpbnRbXSB7IDB4RjAwMCwgMHgwRjAwLCAweDAwRjAsIDB4MDAwRiB9KSk7Ci0KLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMuYW55RmxhZ3NBcmVTZXQoMHgwMzAzLCBuZXcgaW50W10geyAweDEwMDAsIDB4MDAxMCB9KSk7Ci0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLmFueUZsYWdzQXJlU2V0KDB4MDAwMCwgbmV3IGludFtdIHsgMHhGMDAwLCAweDBGMDAsIDB4MDBGMCwgMHgwMDBGIH0pKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QW55RmxhZ3NBcmVPZmZJbnRJbnRBcnJheSgpIHsKLQkJYXNzZXJ0RmFsc2UoQml0VG9vbHMuYW55RmxhZ3NBcmVPZmYoMHgwMDAzLCBuZXcgaW50W10geyAweDAwMDEgfSkpOwotCQlhc3NlcnRGYWxzZShCaXRUb29scy5hbnlGbGFnc0FyZU9mZigweEZGRkYsIG5ldyBpbnRbXSB7IDB4MDAwMSB9KSk7Ci0JCWFzc2VydEZhbHNlKEJpdFRvb2xzLmFueUZsYWdzQXJlT2ZmKDB4MDMwMywgbmV3IGludFtdIHsgMHgwMTAwLCAweDAyMDAsIDB4MDAwMywgMHgwMDAyIH0pKTsKLQotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmFueUZsYWdzQXJlT2ZmKDB4MDMwMywgbmV3IGludFtdIHsgMHgwMTAwLCAweDAwMTAgfSkpOwotCQlhc3NlcnRUcnVlKEJpdFRvb2xzLmFueUZsYWdzQXJlT2ZmKDB4MDAwMCwgbmV3IGludFtdIHsgMHhGMDAwLCAweDBGMDAsIDB4MDBGMCwgMHgwMDBGIH0pKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0T3JGbGFncygpIHsKLQkJYXNzZXJ0RXF1YWxzKDB4MDAwMSwgQml0VG9vbHMub3JGbGFncyhuZXcgaW50W10geyAweDAwMDEsIDB4MDAwMCB9KSk7Ci0JCWFzc2VydEVxdWFscygweDAwMTEsIEJpdFRvb2xzLm9yRmxhZ3MobmV3IGludFtdIHsgMHgwMDAxLCAweDAwMTEgfSkpOwotCQlhc3NlcnRFcXVhbHMoMHhGMDExLCBCaXRUb29scy5vckZsYWdzKG5ldyBpbnRbXSB7IDB4MDAwMSwgMHgwMDExLCAweEYwMDAgfSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBbmRGbGFncygpIHsKLQkJYXNzZXJ0RXF1YWxzKDB4MDAwMSwgQml0VG9vbHMuYW5kRmxhZ3MobmV3IGludFtdIHsgMHgwMDAxLCAweDAwMDEgfSkpOwotCQlhc3NlcnRFcXVhbHMoMHgwMDAxLCBCaXRUb29scy5hbmRGbGFncyhuZXcgaW50W10geyAweDAwMDEsIDB4MDAxMSB9KSk7Ci0JCWFzc2VydEVxdWFscygweDAwMDAsIEJpdFRvb2xzLmFuZEZsYWdzKG5ldyBpbnRbXSB7IDB4MDAwMSwgMHgwMDExLCAweEYwMDAgfSkpOwotCQlhc3NlcnRFcXVhbHMoMHgwMDAxLCBCaXRUb29scy5hbmRGbGFncyhuZXcgaW50W10geyAweDAwMDEsIDB4MDAxMSwgMHhGMDAxIH0pKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0WG9yRmxhZ3MoKSB7Ci0JCWFzc2VydEVxdWFscygweDAwMDEsIEJpdFRvb2xzLnhvckZsYWdzKG5ldyBpbnRbXSB7IDB4MDAwMSwgMHgwMDAwIH0pKTsKLQkJYXNzZXJ0RXF1YWxzKDB4MDAxMCwgQml0VG9vbHMueG9yRmxhZ3MobmV3IGludFtdIHsgMHgwMDAxLCAweDAwMTEgfSkpOwotCQlhc3NlcnRFcXVhbHMoMHhGMDEwLCBCaXRUb29scy54b3JGbGFncyhuZXcgaW50W10geyAweDAwMDEsIDB4MDAxMSwgMHhGMDAwIH0pKTsKLQkJYXNzZXJ0RXF1YWxzKDB4RkYxMSwgQml0VG9vbHMueG9yRmxhZ3MobmV3IGludFtdIHsgMHgwMDAxLCAweDAwMTEsIDB4RjAwMCwgMHgwRjAxIH0pKTsKLQkJYXNzZXJ0RXF1YWxzKDB4RjAxMCwgQml0VG9vbHMueG9yRmxhZ3MobmV3IGludFtdIHsgMHgwMDAxLCAweDAwMTEsIDB4RjAwMCwgMHgwRjAxLCAweDBGMDEgfSkpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9Cb29sZWFuSG9sZGVyVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvQm9vbGVhbkhvbGRlclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDEwNmVhZTEuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9Cb29sZWFuSG9sZGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDgwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWw7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQm9vbGVhbkhvbGRlcjsKLQotcHVibGljIGNsYXNzIEJvb2xlYW5Ib2xkZXJUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBCb29sZWFuSG9sZGVyVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEdldFZhbHVlKCkgewotCQlCb29sZWFuSG9sZGVyIGJoID0gbmV3IEJvb2xlYW5Ib2xkZXIodHJ1ZSk7Ci0JCWFzc2VydFRydWUoYmguZ2V0VmFsdWUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdElzVHJ1ZSgpIHsKLQkJQm9vbGVhbkhvbGRlciBiaCA9IG5ldyBCb29sZWFuSG9sZGVyKHRydWUpOwotCQlhc3NlcnRUcnVlKGJoLmlzVHJ1ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SXNGYWxzZSgpIHsKLQkJQm9vbGVhbkhvbGRlciBiaCA9IG5ldyBCb29sZWFuSG9sZGVyKHRydWUpOwotCQlhc3NlcnRGYWxzZShiaC5pc0ZhbHNlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJcygpIHsKLQkJQm9vbGVhbkhvbGRlciBiaCA9IG5ldyBCb29sZWFuSG9sZGVyKHRydWUpOwotCQlhc3NlcnRUcnVlKGJoLmlzKHRydWUpKTsKLQkJYXNzZXJ0RmFsc2UoYmguaXMoZmFsc2UpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2V0VmFsdWUoKSB7Ci0JCUJvb2xlYW5Ib2xkZXIgYmggPSBuZXcgQm9vbGVhbkhvbGRlcih0cnVlKTsKLQkJYXNzZXJ0VHJ1ZShiaC5nZXRWYWx1ZSgpKTsKLQkJYmguc2V0VmFsdWUoZmFsc2UpOwotCQlhc3NlcnRGYWxzZShiaC5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2V0VHJ1ZSgpIHsKLQkJQm9vbGVhbkhvbGRlciBiaCA9IG5ldyBCb29sZWFuSG9sZGVyKGZhbHNlKTsKLQkJYXNzZXJ0RmFsc2UoYmguZ2V0VmFsdWUoKSk7Ci0JCWJoLnNldFRydWUoKTsKLQkJYXNzZXJ0VHJ1ZShiaC5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRGYWxzZSgpIHsKLQkJQm9vbGVhbkhvbGRlciBiaCA9IG5ldyBCb29sZWFuSG9sZGVyKHRydWUpOwotCQlhc3NlcnRUcnVlKGJoLmdldFZhbHVlKCkpOwotCQliaC5zZXRGYWxzZSgpOwotCQlhc3NlcnRGYWxzZShiaC5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2xvbmUoKSB7Ci0JCUJvb2xlYW5Ib2xkZXIgYmggPSBuZXcgQm9vbGVhbkhvbGRlcih0cnVlKTsKLQkJQm9vbGVhbkhvbGRlciBjbG9uZSA9IChCb29sZWFuSG9sZGVyKSBiaC5jbG9uZSgpOwotCQlhc3NlcnRUcnVlKGNsb25lLmdldFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMoYmgsIGNsb25lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RXF1YWxzKCkgewotCQlCb29sZWFuSG9sZGVyIGJoMSA9IG5ldyBCb29sZWFuSG9sZGVyKHRydWUpOwotCQlCb29sZWFuSG9sZGVyIGJoMiA9IG5ldyBCb29sZWFuSG9sZGVyKHRydWUpOwotCQlhc3NlcnRFcXVhbHMoYmgxLCBiaDIpOwotCi0JCUJvb2xlYW5Ib2xkZXIgYmgzID0gbmV3IEJvb2xlYW5Ib2xkZXIoZmFsc2UpOwotCQlhc3NlcnRGYWxzZShiaDEuZXF1YWxzKGJoMykpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9DbGFzc1Rvb2xzVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvQ2xhc3NUb29sc1Rlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGE1YmU4ZTMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9DbGFzc1Rvb2xzVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDY0OCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA5IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsOwotCi1pbXBvcnQgamF2YS5sYW5nLnJlZmxlY3QuQXJyYXk7Ci1pbXBvcnQgamF2YS5sYW5nLnJlZmxlY3QuRmllbGQ7Ci1pbXBvcnQgamF2YS5sYW5nLnJlZmxlY3QuTWV0aG9kOwotaW1wb3J0IGphdmEudXRpbC5IYXNoTWFwOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTWFwOwotaW1wb3J0IGphdmEudXRpbC5WZWN0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk1hcC5FbnRyeTsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlRyYW5zZm9ybWF0aW9uSXRlcmF0b3I7Ci0KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIENsYXNzVG9vbHNUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXByaXZhdGUgc3RhdGljIFN0cmluZyB0ZXN0U3RhdGljRmllbGQ7Ci0KLQlwdWJsaWMgQ2xhc3NUb29sc1Rlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCS8qKgotCSAqIFJldHVybiB0aGUgY29tcGlsZXItZ2VuZXJhdGVkIGNsYXNzIG5hbWUuIFRoZSBFY2xpcHNlIGNvbXBpbGVyIGdlbmVyYXRlcwotCSAqICJsb2NhbCIgY2xhc3NlcyB3aXRoIG5hbWVzIGluIHRoZSBmb3JtICJjb20uZm9vLk91dGVyJDEkTG9jYWwiOyB3aGlsZSB0aGUKLQkgKiBKREsgY29tcGlsZXIgZ2VuZXJhdGVzICJjb20uZm9vLk91dGVyJDFMb2NhbCIuIFRoZXJlIG1pZ2h0IGJlIG90aGVyCi0JICogZGlmZmVyZW5jZXMuLi4uIH5ianYKLQkgKi8KLQlwdWJsaWMgc3RhdGljIFN0cmluZyBjb21waWxlckRlcGVuZGVudENsYXNzTmFtZUZvcihTdHJpbmcgY2xhc3NOYW1lKSB7Ci0JCWludCBpbmRleCA9IGNsYXNzTmFtZS5pbmRleE9mKCIkMSQiKTsKLQkJaWYgKGluZGV4ID09IC0xKSB7Ci0JCQlyZXR1cm4gY2xhc3NOYW1lOwotCQl9Ci0JCXRyeSB7Ci0JCQlDbGFzcy5mb3JOYW1lKGNsYXNzTmFtZSk7Ci0JCX0gY2F0Y2ggKENsYXNzTm90Rm91bmRFeGNlcHRpb24gZXgpIHsKLQkJCXJldHVybiBjbGFzc05hbWUuc3Vic3RyaW5nKDAsIGluZGV4ICsgMikgKyBjbGFzc05hbWUuc3Vic3RyaW5nKGluZGV4ICsgMyk7Ci0JCX0KLQkJcmV0dXJuIGNsYXNzTmFtZTsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBTdHJpbmcgbXVuZ2UoU3RyaW5nIGNsYXNzTmFtZSkgewotCQlyZXR1cm4gY29tcGlsZXJEZXBlbmRlbnRDbGFzc05hbWVGb3IoY2xhc3NOYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWxsRmllbGRzKCkgewotCQlpbnQgZmllbGRDb3VudCA9IDA7Ci0JCWZpZWxkQ291bnQgKz0gamF2YS51dGlsLlZlY3Rvci5jbGFzcy5nZXREZWNsYXJlZEZpZWxkcygpLmxlbmd0aDsKLQkJZmllbGRDb3VudCArPSBqYXZhLnV0aWwuQWJzdHJhY3RMaXN0LmNsYXNzLmdldERlY2xhcmVkRmllbGRzKCkubGVuZ3RoOwotCQlmaWVsZENvdW50ICs9IGphdmEudXRpbC5BYnN0cmFjdENvbGxlY3Rpb24uY2xhc3MuZ2V0RGVjbGFyZWRGaWVsZHMoKS5sZW5ndGg7Ci0JCWZpZWxkQ291bnQgKz0gamF2YS5sYW5nLk9iamVjdC5jbGFzcy5nZXREZWNsYXJlZEZpZWxkcygpLmxlbmd0aDsKLQkJRmllbGRbXSBmaWVsZHMgPSBDbGFzc1Rvb2xzLmFsbEZpZWxkcyhqYXZhLnV0aWwuVmVjdG9yLmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKGZpZWxkQ291bnQsIGZpZWxkcy5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLm5hbWVzKGZpZWxkcyksICJtb2RDb3VudCIpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5uYW1lcyhmaWVsZHMpLCAic2VyaWFsVmVyc2lvblVJRCIpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5uYW1lcyhmaWVsZHMpLCAiY2FwYWNpdHlJbmNyZW1lbnQiKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMubmFtZXMoZmllbGRzKSwgImVsZW1lbnRDb3VudCIpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5uYW1lcyhmaWVsZHMpLCAiZWxlbWVudERhdGEiKSk7Ci0JCWFzc2VydFRydWUoZmllbGRzWzBdLmlzQWNjZXNzaWJsZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWxsTWV0aG9kcygpIHsKLQkJaW50IG1ldGhvZENvdW50ID0gMDsKLQkJbWV0aG9kQ291bnQgKz0gamF2YS51dGlsLlZlY3Rvci5jbGFzcy5nZXREZWNsYXJlZE1ldGhvZHMoKS5sZW5ndGg7Ci0JCW1ldGhvZENvdW50ICs9IGphdmEudXRpbC5BYnN0cmFjdExpc3QuY2xhc3MuZ2V0RGVjbGFyZWRNZXRob2RzKCkubGVuZ3RoOwotCQltZXRob2RDb3VudCArPSBqYXZhLnV0aWwuQWJzdHJhY3RDb2xsZWN0aW9uLmNsYXNzLmdldERlY2xhcmVkTWV0aG9kcygpLmxlbmd0aDsKLQkJbWV0aG9kQ291bnQgKz0gamF2YS5sYW5nLk9iamVjdC5jbGFzcy5nZXREZWNsYXJlZE1ldGhvZHMoKS5sZW5ndGg7Ci0JCU1ldGhvZFtdIG1ldGhvZHMgPSBDbGFzc1Rvb2xzLmFsbE1ldGhvZHMoamF2YS51dGlsLlZlY3Rvci5jbGFzcyk7Ci0JCWFzc2VydEVxdWFscyhtZXRob2RDb3VudCwgbWV0aG9kcy5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLm5hbWVzKG1ldGhvZHMpLCAid2FpdCIpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5uYW1lcyhtZXRob2RzKSwgImFkZEVsZW1lbnQiKSk7Ci0JCWFzc2VydFRydWUobWV0aG9kc1swXS5pc0FjY2Vzc2libGUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5ld0luc3RhbmNlQ2xhc3MoKSB7Ci0JCVZlY3Rvcjw/PiB2ID0gQ2xhc3NUb29scy5uZXdJbnN0YW5jZShqYXZhLnV0aWwuVmVjdG9yLmNsYXNzKTsKLQkJYXNzZXJ0Tm90TnVsbCh2KTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHYuc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TmV3SW5zdGFuY2VDbGFzc0NsYXNzT2JqZWN0KCkgewotCQlpbnQgaW5pdGlhbENhcGFjaXR5ID0gMjAwOwotCQlWZWN0b3I8Pz4gdiA9IENsYXNzVG9vbHMubmV3SW5zdGFuY2UoamF2YS51dGlsLlZlY3Rvci5jbGFzcywgaW50LmNsYXNzLCBuZXcgSW50ZWdlcihpbml0aWFsQ2FwYWNpdHkpKTsKLQkJYXNzZXJ0Tm90TnVsbCh2KTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHYuc2l6ZSgpKTsKLQkJT2JqZWN0W10gZWxlbWVudERhdGEgPSAoT2JqZWN0W10pIENsYXNzVG9vbHMuZmllbGRWYWx1ZSh2LCAiZWxlbWVudERhdGEiKTsKLQkJYXNzZXJ0RXF1YWxzKGluaXRpYWxDYXBhY2l0eSwgZWxlbWVudERhdGEubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TmV3SW5zdGFuY2VDbGFzc0NsYXNzQXJyYXlPYmplY3RBcnJheSgpIHsKLQkJaW50IGluaXRpYWxDYXBhY2l0eSA9IDIwMDsKLQkJQ2xhc3M8Pz5bXSBwYXJtVHlwZXMgPSBuZXcgQ2xhc3NbMV07Ci0JCXBhcm1UeXBlc1swXSA9IGludC5jbGFzczsKLQkJT2JqZWN0W10gcGFybXMgPSBuZXcgT2JqZWN0WzFdOwotCQlwYXJtc1swXSA9IG5ldyBJbnRlZ2VyKGluaXRpYWxDYXBhY2l0eSk7Ci0JCVZlY3Rvcjw/PiB2ID0gQ2xhc3NUb29scy5uZXdJbnN0YW5jZShqYXZhLnV0aWwuVmVjdG9yLmNsYXNzLCBwYXJtVHlwZXMsIHBhcm1zKTsKLQkJYXNzZXJ0Tm90TnVsbCh2KTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHYuc2l6ZSgpKTsKLQkJT2JqZWN0W10gZWxlbWVudERhdGEgPSAoT2JqZWN0W10pIENsYXNzVG9vbHMuZmllbGRWYWx1ZSh2LCAiZWxlbWVudERhdGEiKTsKLQkJYXNzZXJ0RXF1YWxzKGluaXRpYWxDYXBhY2l0eSwgZWxlbWVudERhdGEubGVuZ3RoKTsKLQotCQlwYXJtc1swXSA9IG5ldyBJbnRlZ2VyKC0xKTsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdiA9IENsYXNzVG9vbHMubmV3SW5zdGFuY2UoamF2YS51dGlsLlZlY3Rvci5jbGFzcywgcGFybVR5cGVzLCBwYXJtcyk7Ci0JCX0gY2F0Y2ggKFJ1bnRpbWVFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJSdW50aW1lRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0KLQkJcGFybVR5cGVzWzBdID0gamF2YS5sYW5nLlN0cmluZy5jbGFzczsKLQkJcGFybXNbMF0gPSAiZm9vIjsKLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXYgPSBDbGFzc1Rvb2xzLmF0dGVtcHROZXdJbnN0YW5jZShqYXZhLnV0aWwuVmVjdG9yLmNsYXNzLCBwYXJtVHlwZXMsIHBhcm1zKTsKLQkJfSBjYXRjaCAoTm9TdWNoTWV0aG9kRXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiTm9TdWNoTWV0aG9kRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEZpZWxkVmFsdWUoKSB7Ci0JCWludCBpbml0aWFsQ2FwYWNpdHkgPSAyMDA7Ci0JCVZlY3Rvcjw/PiB2ID0gbmV3IFZlY3RvcjxPYmplY3Q+KGluaXRpYWxDYXBhY2l0eSk7Ci0JCU9iamVjdFtdIGVsZW1lbnREYXRhID0gKE9iamVjdFtdKSBDbGFzc1Rvb2xzLmZpZWxkVmFsdWUodiwgImVsZW1lbnREYXRhIik7Ci0JCWFzc2VydEVxdWFscyhpbml0aWFsQ2FwYWNpdHksIGVsZW1lbnREYXRhLmxlbmd0aCk7Ci0KLQkJLy8gdGVzdCBpbmhlcml0ZWQgZmllbGQKLQkJSW50ZWdlciBtb2RDb3VudEludGVnZXIgPSAoSW50ZWdlcikgQ2xhc3NUb29scy5maWVsZFZhbHVlKHYsICJtb2RDb3VudCIpOwotCQlpbnQgbW9kQ291bnQgPSBtb2RDb3VudEludGVnZXIuaW50VmFsdWUoKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIG1vZENvdW50KTsKLQotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCU9iamVjdCBib2d1c0ZpZWxkVmFsdWUgPSBudWxsOwotCQl0cnkgewotCQkJYm9ndXNGaWVsZFZhbHVlID0gQ2xhc3NUb29scy5hdHRlbXB0VG9HZXRGaWVsZFZhbHVlKHYsICJib2d1c0ZpZWxkIik7Ci0JCX0gY2F0Y2ggKE5vU3VjaEZpZWxkRXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiTm9TdWNoRmllbGRFeGNlcHRpb24gbm90IHRocm93bjogIiArIGJvZ3VzRmllbGRWYWx1ZSwgZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RFeGVjdXRlTWV0aG9kT2JqZWN0U3RyaW5nKCkgewotCQlWZWN0b3I8U3RyaW5nPiB2ID0gbmV3IFZlY3RvcjxTdHJpbmc+KCk7Ci0JCWludCBzaXplID0gKChJbnRlZ2VyKSBDbGFzc1Rvb2xzLmV4ZWN1dGVNZXRob2QodiwgInNpemUiKSkuaW50VmFsdWUoKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHNpemUpOwotCi0JCXYuYWRkRWxlbWVudCgiZm9vIik7Ci0JCXNpemUgPSAoKEludGVnZXIpIENsYXNzVG9vbHMuZXhlY3V0ZU1ldGhvZCh2LCAic2l6ZSIpKS5pbnRWYWx1ZSgpOwotCQlhc3NlcnRFcXVhbHMoMSwgc2l6ZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEV4ZWN1dGVNZXRob2RPYmplY3RTdHJpbmdDbGFzc09iamVjdCgpIHsKLQkJVmVjdG9yPFN0cmluZz4gdiA9IG5ldyBWZWN0b3I8U3RyaW5nPigpOwotCQlib29sZWFuIGJvb2xlYW5SZXN1bHQgPSAoKEJvb2xlYW4pIENsYXNzVG9vbHMuZXhlY3V0ZU1ldGhvZCh2LCAiYWRkIiwgT2JqZWN0LmNsYXNzLCAiZm9vIikpLmJvb2xlYW5WYWx1ZSgpOwotCQlhc3NlcnRUcnVlKGJvb2xlYW5SZXN1bHQpOwotCQlhc3NlcnRUcnVlKHYuY29udGFpbnMoImZvbyIpKTsKLQkJT2JqZWN0IHZvaWRSZXN1bHQgPSBDbGFzc1Rvb2xzLmV4ZWN1dGVNZXRob2QodiwgImFkZEVsZW1lbnQiLCBPYmplY3QuY2xhc3MsICJiYXIiKTsKLQkJYXNzZXJ0TnVsbCh2b2lkUmVzdWx0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RXhlY3V0ZU1ldGhvZE9iamVjdFN0cmluZ0NsYXNzQXJyYXlPYmplY3RBcnJheSgpIHsKLQkJVmVjdG9yPFN0cmluZz4gdiA9IG5ldyBWZWN0b3I8U3RyaW5nPigpOwotCQlDbGFzczw/PltdIHBhcm1UeXBlcyA9IG5ldyBDbGFzc1sxXTsKLQkJcGFybVR5cGVzWzBdID0gamF2YS5sYW5nLk9iamVjdC5jbGFzczsKLQkJT2JqZWN0W10gcGFybXMgPSBuZXcgT2JqZWN0WzFdOwotCQlwYXJtc1swXSA9ICJmb28iOwotCQlib29sZWFuIGJvb2xlYW5SZXN1bHQgPSAoKEJvb2xlYW4pIENsYXNzVG9vbHMuZXhlY3V0ZU1ldGhvZCh2LCAiYWRkIiwgcGFybVR5cGVzLCBwYXJtcykpLmJvb2xlYW5WYWx1ZSgpOwotCQlhc3NlcnRUcnVlKGJvb2xlYW5SZXN1bHQpOwotCQlhc3NlcnRUcnVlKHYuY29udGFpbnMoImZvbyIpKTsKLQotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCU9iamVjdCBib2d1c01ldGhvZFJldHVyblZhbHVlID0gbnVsbDsKLQkJdHJ5IHsKLQkJCWJvZ3VzTWV0aG9kUmV0dXJuVmFsdWUgPSBDbGFzc1Rvb2xzLmF0dGVtcHRUb0V4ZWN1dGVNZXRob2QodiwgImJvZ3VzTWV0aG9kIiwgcGFybVR5cGVzLCBwYXJtcyk7Ci0JCX0gY2F0Y2ggKE5vU3VjaE1ldGhvZEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIk5vU3VjaE1ldGhvZEV4Y2VwdGlvbiBub3QgdGhyb3duOiAiICsgYm9ndXNNZXRob2RSZXR1cm5WYWx1ZSwgZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RFeGVjdXRlU3RhdGljTWV0aG9kQ2xhc3NTdHJpbmcoKSB7Ci0JCURvdWJsZSByYW5kb21PYmplY3QgPSAoRG91YmxlKSBDbGFzc1Rvb2xzLmV4ZWN1dGVTdGF0aWNNZXRob2QoamF2YS5sYW5nLk1hdGguY2xhc3MsICJyYW5kb20iKTsKLQkJYXNzZXJ0Tm90TnVsbChyYW5kb21PYmplY3QpOwotCQlkb3VibGUgcmFuZG9tID0gcmFuZG9tT2JqZWN0LmRvdWJsZVZhbHVlKCk7Ci0JCWFzc2VydFRydWUocmFuZG9tID49IDApOwotCQlhc3NlcnRUcnVlKHJhbmRvbSA8IDEpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RFeGVjdXRlU3RhdGljTWV0aG9kQ2xhc3NTdHJpbmdDbGFzc09iamVjdCgpIHsKLQkJU3RyaW5nIHMgPSAoU3RyaW5nKSBDbGFzc1Rvb2xzLmV4ZWN1dGVTdGF0aWNNZXRob2QoamF2YS5sYW5nLlN0cmluZy5jbGFzcywgInZhbHVlT2YiLCBib29sZWFuLmNsYXNzLCBCb29sZWFuLlRSVUUpOwotCQlhc3NlcnROb3ROdWxsKHMpOwotCQlhc3NlcnRFcXVhbHMoInRydWUiLCBzKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RXhlY3V0ZVN0YXRpY01ldGhvZENsYXNzU3RyaW5nQ2xhc3NBcnJheU9iamVjdEFycmF5KCkgewotCQlDbGFzczw/PltdIHBhcm1UeXBlcyA9IG5ldyBDbGFzc1sxXTsKLQkJcGFybVR5cGVzWzBdID0gYm9vbGVhbi5jbGFzczsKLQkJT2JqZWN0W10gcGFybXMgPSBuZXcgT2JqZWN0WzFdOwotCQlwYXJtc1swXSA9IEJvb2xlYW4uVFJVRTsKLQkJU3RyaW5nIHMgPSAoU3RyaW5nKSBDbGFzc1Rvb2xzLmV4ZWN1dGVTdGF0aWNNZXRob2QoamF2YS5sYW5nLlN0cmluZy5jbGFzcywgInZhbHVlT2YiLCBwYXJtVHlwZXMsIHBhcm1zKTsKLQkJYXNzZXJ0Tm90TnVsbChzKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0cnVlIiwgcyk7Ci0KLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlPYmplY3QgYm9ndXNTdGF0aWNNZXRob2RSZXR1cm5WYWx1ZSA9IG51bGw7Ci0JCXRyeSB7Ci0JCQlib2d1c1N0YXRpY01ldGhvZFJldHVyblZhbHVlID0gQ2xhc3NUb29scy5hdHRlbXB0VG9FeGVjdXRlU3RhdGljTWV0aG9kKGphdmEubGFuZy5TdHJpbmcuY2xhc3MsICJib2d1c1N0YXRpY01ldGhvZCIsIHBhcm1UeXBlcywgcGFybXMpOwotCQl9IGNhdGNoIChOb1N1Y2hNZXRob2RFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJOb1N1Y2hNZXRob2RFeGNlcHRpb24gbm90IHRocm93bjogIiArIGJvZ3VzU3RhdGljTWV0aG9kUmV0dXJuVmFsdWUsIGV4Q2F1Z2h0KTsKLQotCQkvLyB0ZXN0IG5vbi1zdGF0aWMgbWV0aG9kCi0JCWV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlib2d1c1N0YXRpY01ldGhvZFJldHVyblZhbHVlID0gQ2xhc3NUb29scy5hdHRlbXB0VG9FeGVjdXRlU3RhdGljTWV0aG9kKGphdmEubGFuZy5TdHJpbmcuY2xhc3MsICJ0b1N0cmluZyIpOwotCQl9IGNhdGNoIChOb1N1Y2hNZXRob2RFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJOb1N1Y2hNZXRob2RFeGNlcHRpb24gbm90IHRocm93bjogIiArIGJvZ3VzU3RhdGljTWV0aG9kUmV0dXJuVmFsdWUsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2V0RmllbGRWYWx1ZSgpIHsKLQkJVmVjdG9yPFN0cmluZz4gdiA9IG5ldyBWZWN0b3I8U3RyaW5nPigpOwotCQlPYmplY3RbXSBuZXdFbGVtZW50RGF0YSA9IG5ldyBPYmplY3RbNV07Ci0JCW5ld0VsZW1lbnREYXRhWzBdID0gImZvbyI7Ci0JCUNsYXNzVG9vbHMuc2V0RmllbGRWYWx1ZSh2LCAiZWxlbWVudERhdGEiLCBuZXdFbGVtZW50RGF0YSk7Ci0JCUNsYXNzVG9vbHMuc2V0RmllbGRWYWx1ZSh2LCAiZWxlbWVudENvdW50IiwgbmV3IEludGVnZXIoMSkpOwotCQkvLyB0ZXN0IGluaGVyaXRlZCBmaWVsZAotCQlDbGFzc1Rvb2xzLnNldEZpZWxkVmFsdWUodiwgIm1vZENvdW50IiwgbmV3IEludGVnZXIoMSkpOwotCQlhc3NlcnRUcnVlKHYuY29udGFpbnMoImZvbyIpKTsKLQotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlDbGFzc1Rvb2xzLmF0dGVtcHRUb1NldEZpZWxkVmFsdWUodiwgImJvZ3VzRmllbGQiLCAiZm9vIik7Ci0JCX0gY2F0Y2ggKE5vU3VjaEZpZWxkRXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiTm9TdWNoRmllbGRFeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2V0U3RhdGljRmllbGRWYWx1ZSgpIHsKLQkJQ2xhc3NUb29scy5zZXRTdGF0aWNGaWVsZFZhbHVlKHRoaXMuZ2V0Q2xhc3MoKSwgInRlc3RTdGF0aWNGaWVsZCIsICJuZXcgdmFsdWUiKTsKLQkJYXNzZXJ0RXF1YWxzKHRlc3RTdGF0aWNGaWVsZCwgIm5ldyB2YWx1ZSIpOwotCi0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCUNsYXNzVG9vbHMuYXR0ZW1wdFRvU2V0U3RhdGljRmllbGRWYWx1ZSh0aGlzLmdldENsYXNzKCksICJib2d1c1N0YXRpY0ZpZWxkIiwgIm5ldyB2YWx1ZSIpOwotCQl9IGNhdGNoIChOb1N1Y2hGaWVsZEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIk5vU3VjaEZpZWxkRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNob3J0TmFtZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKCJWZWN0b3IiLCBDbGFzc1Rvb2xzLnNob3J0Q2xhc3NOYW1lRm9yT2JqZWN0KG5ldyBqYXZhLnV0aWwuVmVjdG9yPE9iamVjdD4oKSkpOwotCQlhc3NlcnRFcXVhbHMoIlZlY3RvciIsIENsYXNzVG9vbHMuc2hvcnROYW1lRm9yKGphdmEudXRpbC5WZWN0b3IuY2xhc3MpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TmVzdGVkTmFtZSgpIHsKLQkJTWFwPFN0cmluZywgU3RyaW5nPiBtYXAgPSBuZXcgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4oKTsKLQkJbWFwLnB1dCgiZm9vIiwgImJhciIpOwotCQlFbnRyeTxTdHJpbmcsIFN0cmluZz4gZW50cnkgPSBtYXAuZW50cnlTZXQoKS5pdGVyYXRvcigpLm5leHQoKTsKLQkJYXNzZXJ0RXF1YWxzKCJFbnRyeSIsIENsYXNzVG9vbHMubmVzdGVkQ2xhc3NOYW1lRm9yT2JqZWN0KGVudHJ5KSk7Ci0JCWFzc2VydEVxdWFscygiRW50cnkiLCBDbGFzc1Rvb2xzLm5lc3RlZE5hbWVGb3IoamF2YS51dGlsLk1hcC5FbnRyeS5jbGFzcykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RQYWNrYWdlTmFtZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKCJqYXZhLnV0aWwiLCBDbGFzc1Rvb2xzLnBhY2thZ2VOYW1lRm9yKGphdmEudXRpbC5WZWN0b3IuY2xhc3MpKTsKLQkJYXNzZXJ0RXF1YWxzKCJqYXZhLnV0aWwiLCBDbGFzc1Rvb2xzLnBhY2thZ2VOYW1lRm9yKGphdmEudXRpbC5NYXAuRW50cnkuY2xhc3MpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QXJyYXlEZXB0aEZvcigpIHsKLQkJYXNzZXJ0RXF1YWxzKDAsIENsYXNzVG9vbHMuYXJyYXlEZXB0aEZvcihqYXZhLnV0aWwuVmVjdG9yLmNsYXNzKSk7Ci0JCWFzc2VydEVxdWFscygwLCBDbGFzc1Rvb2xzLmFycmF5RGVwdGhGb3IoaW50LmNsYXNzKSk7Ci0JCWFzc2VydEVxdWFscygwLCBDbGFzc1Rvb2xzLmFycmF5RGVwdGhGb3Iodm9pZC5jbGFzcykpOwotCQlhc3NlcnRFcXVhbHMoMSwgQ2xhc3NUb29scy5hcnJheURlcHRoRm9yKGphdmEudXRpbC5WZWN0b3JbXS5jbGFzcykpOwotCQlhc3NlcnRFcXVhbHMoMSwgQ2xhc3NUb29scy5hcnJheURlcHRoRm9yKGludFtdLmNsYXNzKSk7Ci0JCWFzc2VydEVxdWFscygzLCBDbGFzc1Rvb2xzLmFycmF5RGVwdGhGb3IoamF2YS51dGlsLlZlY3RvcltdW11bXS5jbGFzcykpOwotCQlhc3NlcnRFcXVhbHMoMywgQ2xhc3NUb29scy5hcnJheURlcHRoRm9yKGludFtdW11bXS5jbGFzcykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBcnJheURlcHRoRm9yT2JqZWN0KCkgewotCQlhc3NlcnRFcXVhbHMoMCwgQ2xhc3NUb29scy5hcnJheURlcHRoRm9yT2JqZWN0KG5ldyBqYXZhLnV0aWwuVmVjdG9yPE9iamVjdD4oKSkpOwotCQlhc3NlcnRFcXVhbHMoMSwgQ2xhc3NUb29scy5hcnJheURlcHRoRm9yT2JqZWN0KG5ldyBqYXZhLnV0aWwuVmVjdG9yWzBdKSk7Ci0JCWFzc2VydEVxdWFscygxLCBDbGFzc1Rvb2xzLmFycmF5RGVwdGhGb3JPYmplY3QobmV3IGludFswXSkpOwotCQlhc3NlcnRFcXVhbHMoMywgQ2xhc3NUb29scy5hcnJheURlcHRoRm9yT2JqZWN0KG5ldyBqYXZhLnV0aWwuVmVjdG9yWzBdWzBdWzBdKSk7Ci0JCWFzc2VydEVxdWFscygzLCBDbGFzc1Rvb2xzLmFycmF5RGVwdGhGb3JPYmplY3QobmV3IGludFswXVswXVswXSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBcnJheURlcHRoRm9yQ2xhc3NOYW1lZCgpIHsKLQkJYXNzZXJ0RXF1YWxzKDAsIENsYXNzVG9vbHMuYXJyYXlEZXB0aEZvckNsYXNzTmFtZWQoamF2YS51dGlsLlZlY3Rvci5jbGFzcy5nZXROYW1lKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIENsYXNzVG9vbHMuYXJyYXlEZXB0aEZvckNsYXNzTmFtZWQoaW50LmNsYXNzLmdldE5hbWUoKSkpOwotCQlhc3NlcnRFcXVhbHMoMCwgQ2xhc3NUb29scy5hcnJheURlcHRoRm9yQ2xhc3NOYW1lZCh2b2lkLmNsYXNzLmdldE5hbWUoKSkpOwotCQlhc3NlcnRFcXVhbHMoMSwgQ2xhc3NUb29scy5hcnJheURlcHRoRm9yQ2xhc3NOYW1lZChqYXZhLnV0aWwuVmVjdG9yW10uY2xhc3MuZ2V0TmFtZSgpKSk7Ci0JCWFzc2VydEVxdWFscygxLCBDbGFzc1Rvb2xzLmFycmF5RGVwdGhGb3JDbGFzc05hbWVkKGludFtdLmNsYXNzLmdldE5hbWUoKSkpOwotCQlhc3NlcnRFcXVhbHMoMywgQ2xhc3NUb29scy5hcnJheURlcHRoRm9yQ2xhc3NOYW1lZChqYXZhLnV0aWwuVmVjdG9yW11bXVtdLmNsYXNzLmdldE5hbWUoKSkpOwotCQlhc3NlcnRFcXVhbHMoMywgQ2xhc3NUb29scy5hcnJheURlcHRoRm9yQ2xhc3NOYW1lZChpbnRbXVtdW10uY2xhc3MuZ2V0TmFtZSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEVsZW1lbnRUeXBlRm9yKCkgewotCQlhc3NlcnRFcXVhbHMoamF2YS51dGlsLlZlY3Rvci5jbGFzcywgQ2xhc3NUb29scy5lbGVtZW50VHlwZUZvcihqYXZhLnV0aWwuVmVjdG9yLmNsYXNzKSk7Ci0JCWFzc2VydEVxdWFscyhpbnQuY2xhc3MsIENsYXNzVG9vbHMuZWxlbWVudFR5cGVGb3IoaW50LmNsYXNzKSk7Ci0JCWFzc2VydEVxdWFscyh2b2lkLmNsYXNzLCBDbGFzc1Rvb2xzLmVsZW1lbnRUeXBlRm9yKHZvaWQuY2xhc3MpKTsKLQkJYXNzZXJ0RXF1YWxzKGphdmEudXRpbC5WZWN0b3IuY2xhc3MsIENsYXNzVG9vbHMuZWxlbWVudFR5cGVGb3IoamF2YS51dGlsLlZlY3RvcltdLmNsYXNzKSk7Ci0JCWFzc2VydEVxdWFscyhpbnQuY2xhc3MsIENsYXNzVG9vbHMuZWxlbWVudFR5cGVGb3IoaW50W10uY2xhc3MpKTsKLQkJYXNzZXJ0RXF1YWxzKGphdmEudXRpbC5WZWN0b3IuY2xhc3MsIENsYXNzVG9vbHMuZWxlbWVudFR5cGVGb3IoamF2YS51dGlsLlZlY3RvcltdW11bXS5jbGFzcykpOwotCQlhc3NlcnRFcXVhbHMoaW50LmNsYXNzLCBDbGFzc1Rvb2xzLmVsZW1lbnRUeXBlRm9yKGludFtdW11bXS5jbGFzcykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RFbGVtZW50VHlwZUZvck9iamVjdCgpIHsKLQkJYXNzZXJ0RXF1YWxzKGphdmEudXRpbC5WZWN0b3IuY2xhc3MsIENsYXNzVG9vbHMuZWxlbWVudFR5cGVGb3JPYmplY3QobmV3IGphdmEudXRpbC5WZWN0b3I8T2JqZWN0PigpKSk7Ci0JCWFzc2VydEVxdWFscyhqYXZhLnV0aWwuVmVjdG9yLmNsYXNzLCBDbGFzc1Rvb2xzLmVsZW1lbnRUeXBlRm9yT2JqZWN0KG5ldyBqYXZhLnV0aWwuVmVjdG9yWzBdKSk7Ci0JCWFzc2VydEVxdWFscyhpbnQuY2xhc3MsIENsYXNzVG9vbHMuZWxlbWVudFR5cGVGb3JPYmplY3QobmV3IGludFswXSkpOwotCQlhc3NlcnRFcXVhbHMoamF2YS51dGlsLlZlY3Rvci5jbGFzcywgQ2xhc3NUb29scy5lbGVtZW50VHlwZUZvck9iamVjdChuZXcgamF2YS51dGlsLlZlY3RvclswXVswXVswXSkpOwotCQlhc3NlcnRFcXVhbHMoaW50LmNsYXNzLCBDbGFzc1Rvb2xzLmVsZW1lbnRUeXBlRm9yT2JqZWN0KG5ldyBpbnRbMF1bMF1bMF0pKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RWxlbWVudFR5cGVOYW1lRm9yKCkgewotCQlhc3NlcnRFcXVhbHMoamF2YS51dGlsLlZlY3Rvci5jbGFzcy5nZXROYW1lKCksIENsYXNzVG9vbHMuZWxlbWVudFR5cGVOYW1lRm9yKGphdmEudXRpbC5WZWN0b3IuY2xhc3MpKTsKLQkJYXNzZXJ0RXF1YWxzKGludC5jbGFzcy5nZXROYW1lKCksIENsYXNzVG9vbHMuZWxlbWVudFR5cGVOYW1lRm9yKGludC5jbGFzcykpOwotCQlhc3NlcnRFcXVhbHModm9pZC5jbGFzcy5nZXROYW1lKCksIENsYXNzVG9vbHMuZWxlbWVudFR5cGVOYW1lRm9yKHZvaWQuY2xhc3MpKTsKLQkJYXNzZXJ0RXF1YWxzKGphdmEudXRpbC5WZWN0b3IuY2xhc3MuZ2V0TmFtZSgpLCBDbGFzc1Rvb2xzLmVsZW1lbnRUeXBlTmFtZUZvcihqYXZhLnV0aWwuVmVjdG9yW10uY2xhc3MpKTsKLQkJYXNzZXJ0RXF1YWxzKGludC5jbGFzcy5nZXROYW1lKCksIENsYXNzVG9vbHMuZWxlbWVudFR5cGVOYW1lRm9yKGludFtdLmNsYXNzKSk7Ci0JCWFzc2VydEVxdWFscyhqYXZhLnV0aWwuVmVjdG9yLmNsYXNzLmdldE5hbWUoKSwgQ2xhc3NUb29scy5lbGVtZW50VHlwZU5hbWVGb3IoamF2YS51dGlsLlZlY3RvcltdW11bXS5jbGFzcykpOwotCQlhc3NlcnRFcXVhbHMoaW50LmNsYXNzLmdldE5hbWUoKSwgQ2xhc3NUb29scy5lbGVtZW50VHlwZU5hbWVGb3IoaW50W11bXVtdLmNsYXNzKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEVsZW1lbnRUeXBlTmFtZUZvckNsYXNzTmFtZWQoKSB7Ci0JCWFzc2VydEVxdWFscyhqYXZhLnV0aWwuVmVjdG9yLmNsYXNzLmdldE5hbWUoKSwgQ2xhc3NUb29scy5lbGVtZW50VHlwZU5hbWVGb3JDbGFzc05hbWVkKGphdmEudXRpbC5WZWN0b3IuY2xhc3MuZ2V0TmFtZSgpKSk7Ci0JCWFzc2VydEVxdWFscyhpbnQuY2xhc3MuZ2V0TmFtZSgpLCBDbGFzc1Rvb2xzLmVsZW1lbnRUeXBlTmFtZUZvckNsYXNzTmFtZWQoaW50LmNsYXNzLmdldE5hbWUoKSkpOwotCQlhc3NlcnRFcXVhbHModm9pZC5jbGFzcy5nZXROYW1lKCksIENsYXNzVG9vbHMuZWxlbWVudFR5cGVOYW1lRm9yQ2xhc3NOYW1lZCh2b2lkLmNsYXNzLmdldE5hbWUoKSkpOwotCQlhc3NlcnRFcXVhbHMoamF2YS51dGlsLlZlY3Rvci5jbGFzcy5nZXROYW1lKCksIENsYXNzVG9vbHMuZWxlbWVudFR5cGVOYW1lRm9yQ2xhc3NOYW1lZChqYXZhLnV0aWwuVmVjdG9yW10uY2xhc3MuZ2V0TmFtZSgpKSk7Ci0JCWFzc2VydEVxdWFscyhpbnQuY2xhc3MuZ2V0TmFtZSgpLCBDbGFzc1Rvb2xzLmVsZW1lbnRUeXBlTmFtZUZvckNsYXNzTmFtZWQoaW50W10uY2xhc3MuZ2V0TmFtZSgpKSk7Ci0JCWFzc2VydEVxdWFscyhqYXZhLnV0aWwuVmVjdG9yLmNsYXNzLmdldE5hbWUoKSwgQ2xhc3NUb29scy5lbGVtZW50VHlwZU5hbWVGb3JDbGFzc05hbWVkKGphdmEudXRpbC5WZWN0b3JbXVtdW10uY2xhc3MuZ2V0TmFtZSgpKSk7Ci0JCWFzc2VydEVxdWFscyhpbnQuY2xhc3MuZ2V0TmFtZSgpLCBDbGFzc1Rvb2xzLmVsZW1lbnRUeXBlTmFtZUZvckNsYXNzTmFtZWQoaW50W11bXVtdLmNsYXNzLmdldE5hbWUoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDbGFzc0NvZGVzKCkgewotCQlhc3NlcnRFcXVhbHMoImJ5dGUiLCBDbGFzc1Rvb2xzLmNsYXNzTmFtZUZvckNvZGUoJ0InKSk7Ci0JCWFzc2VydEVxdWFscygiY2hhciIsIENsYXNzVG9vbHMuY2xhc3NOYW1lRm9yQ29kZSgnQycpKTsKLQkJYXNzZXJ0RXF1YWxzKCJkb3VibGUiLCBDbGFzc1Rvb2xzLmNsYXNzTmFtZUZvckNvZGUoJ0QnKSk7Ci0JCWFzc2VydEVxdWFscygiZmxvYXQiLCBDbGFzc1Rvb2xzLmNsYXNzTmFtZUZvckNvZGUoJ0YnKSk7Ci0JCWFzc2VydEVxdWFscygiaW50IiwgQ2xhc3NUb29scy5jbGFzc05hbWVGb3JDb2RlKCdJJykpOwotCQlhc3NlcnRFcXVhbHMoImxvbmciLCBDbGFzc1Rvb2xzLmNsYXNzTmFtZUZvckNvZGUoJ0onKSk7Ci0JCWFzc2VydEVxdWFscygic2hvcnQiLCBDbGFzc1Rvb2xzLmNsYXNzTmFtZUZvckNvZGUoJ1MnKSk7Ci0JCWFzc2VydEVxdWFscygiYm9vbGVhbiIsIENsYXNzVG9vbHMuY2xhc3NOYW1lRm9yQ29kZSgnWicpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ2b2lkIiwgQ2xhc3NUb29scy5jbGFzc05hbWVGb3JDb2RlKCdWJykpOwotCi0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCUNsYXNzVG9vbHMuY2xhc3NOYW1lRm9yQ29kZSgnWCcpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2xhc3NOYW1lZElzVG9wTGV2ZWwoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc1RvcExldmVsKGphdmEudXRpbC5NYXAuY2xhc3MuZ2V0TmFtZSgpKSk7IC8vIHRvcC1sZXZlbAotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc1RvcExldmVsKGphdmEudXRpbC5NYXAuRW50cnkuY2xhc3MuZ2V0TmFtZSgpKSk7IC8vIG1lbWJlcgotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc1RvcExldmVsKENsYXNzLmZvck5hbWUobXVuZ2UodGhpcy5nZXRDbGFzcygpLmdldE5hbWUoKSArICIkMSRMb2NhbENsYXNzIikpLmdldE5hbWUoKSkpOyAvLyBsb2NhbAotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc1RvcExldmVsKENsYXNzLmZvck5hbWUoImphdmEudXRpbC5WZWN0b3IkMSIpLmdldE5hbWUoKSkpOyAvLyBhbm9ueW1vdXMKLQotCQlPYmplY3RbXSBhcnJheSA9IG5ldyBqYXZhLnV0aWwuTWFwWzBdOyAvLyB0b3AtbGV2ZWwKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNUb3BMZXZlbChhcnJheS5nZXRDbGFzcygpLmdldE5hbWUoKSkpOwotCQlhcnJheSA9IG5ldyBqYXZhLnV0aWwuTWFwLkVudHJ5WzBdOyAvLyBtZW1iZXIKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNUb3BMZXZlbChhcnJheS5nZXRDbGFzcygpLmdldE5hbWUoKSkpOwotCQlDbGFzczw/PiBsb2NhbENsYXNzID0gQ2xhc3MuZm9yTmFtZShtdW5nZSh0aGlzLmdldENsYXNzKCkuZ2V0TmFtZSgpICsgIiQxJExvY2FsQ2xhc3MiKSk7IC8vIGxvY2FsCi0JCWFycmF5ID0gKE9iamVjdFtdKSBBcnJheS5uZXdJbnN0YW5jZShsb2NhbENsYXNzLCAwKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNUb3BMZXZlbChhcnJheS5nZXRDbGFzcygpLmdldE5hbWUoKSkpOwotCQlDbGFzczw/PiBhbm9uQ2xhc3MgPSBDbGFzcy5mb3JOYW1lKCJqYXZhLnV0aWwuVmVjdG9yJDEiKTsgLy8gbG9jYWwKLQkJYXJyYXkgPSAoT2JqZWN0W10pIEFycmF5Lm5ld0luc3RhbmNlKGFub25DbGFzcywgMCk7Ci0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzVG9wTGV2ZWwoYXJyYXkuZ2V0Q2xhc3MoKS5nZXROYW1lKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2xhc3NOYW1lZElzTWVtYmVyKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTWVtYmVyKGphdmEudXRpbC5NYXAuY2xhc3MuZ2V0TmFtZSgpKSk7IC8vIHRvcC1sZXZlbAotCQlhc3NlcnRUcnVlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTWVtYmVyKGphdmEudXRpbC5NYXAuRW50cnkuY2xhc3MuZ2V0TmFtZSgpKSk7IC8vIG1lbWJlcgotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc01lbWJlcihDbGFzcy5mb3JOYW1lKG11bmdlKHRoaXMuZ2V0Q2xhc3MoKS5nZXROYW1lKCkgKyAiJDEkTG9jYWxDbGFzcyIpKS5nZXROYW1lKCkpKTsgLy8gbG9jYWwKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNNZW1iZXIoQ2xhc3MuZm9yTmFtZSgiamF2YS51dGlsLlZlY3RvciQxIikuZ2V0TmFtZSgpKSk7IC8vIGFub255bW91cwotCi0JCU9iamVjdFtdIGFycmF5ID0gbmV3IGphdmEudXRpbC5NYXBbMF07IC8vIHRvcC1sZXZlbAotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc01lbWJlcihhcnJheS5nZXRDbGFzcygpLmdldE5hbWUoKSkpOwotCQlhcnJheSA9IG5ldyBqYXZhLnV0aWwuTWFwLkVudHJ5WzBdOyAvLyBtZW1iZXIKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNNZW1iZXIoYXJyYXkuZ2V0Q2xhc3MoKS5nZXROYW1lKCkpKTsKLQkJQ2xhc3M8Pz4gbG9jYWxDbGFzcyA9IENsYXNzLmZvck5hbWUobXVuZ2UodGhpcy5nZXRDbGFzcygpLmdldE5hbWUoKSArICIkMSRMb2NhbENsYXNzIikpOyAvLyBsb2NhbAotCQlhcnJheSA9IChPYmplY3RbXSkgQXJyYXkubmV3SW5zdGFuY2UobG9jYWxDbGFzcywgMCk7Ci0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTWVtYmVyKGFycmF5LmdldENsYXNzKCkuZ2V0TmFtZSgpKSk7Ci0JCUNsYXNzPD8+IGFub25DbGFzcyA9IENsYXNzLmZvck5hbWUoImphdmEudXRpbC5WZWN0b3IkMSIpOyAvLyBsb2NhbAotCQlhcnJheSA9IChPYmplY3RbXSkgQXJyYXkubmV3SW5zdGFuY2UoYW5vbkNsYXNzLCAwKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNNZW1iZXIoYXJyYXkuZ2V0Q2xhc3MoKS5nZXROYW1lKCkpKTsKLQotCQkvLyB0ZXN0IGEgZmV3IGVkZ2UgY2FzZXMKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc01lbWJlcigiamF2YS51dGlsLk1hcCRhMSIpKTsKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc01lbWJlcigiamF2YS51dGlsLk1hcCRhMSRhYWEkYmJiIikpOwotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc01lbWJlcigiamF2YS51dGlsLk1hcCQxYTEkYWFhIikpOwotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc01lbWJlcigiamF2YS51dGlsLk1hcCQxYSIpKTsKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc01lbWJlcigiamF2YS51dGlsLk1hcCRhMTIzNDUkYjEyMzQ1IikpOwotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc01lbWJlcigiamF2YS51dGlsLk1hcCQxMjM0NWEiKSk7Ci0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTWVtYmVyKCJqYXZhLnV0aWwuTWFwJDMzMyIpKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNNZW1iZXIoImphdmEudXRpbC5NYXAzJDMzMyIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2xhc3NOYW1lZElzTG9jYWwoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJY2xhc3MgTG9jYWxDbGFzcyB7Ci0JCQl2b2lkIGZvbygpIHsKLQkJCQlTeXN0ZW0uZ2V0UHJvcGVydHkoImZvbyIpOwotCQkJfQotCQl9Ci0JCW5ldyBMb2NhbENsYXNzKCkuZm9vKCk7Ci0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTG9jYWwoamF2YS51dGlsLk1hcC5jbGFzcy5nZXROYW1lKCkpKTsgLy8gdG9wLWxldmVsCi0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTG9jYWwoamF2YS51dGlsLk1hcC5FbnRyeS5jbGFzcy5nZXROYW1lKCkpKTsgLy8gbWVtYmVyCi0JCWFzc2VydFRydWUoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNMb2NhbChDbGFzcy5mb3JOYW1lKG11bmdlKHRoaXMuZ2V0Q2xhc3MoKS5nZXROYW1lKCkgKyAiJDEkTG9jYWxDbGFzcyIpKS5nZXROYW1lKCkpKTsgLy8gbG9jYWwKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNMb2NhbChDbGFzcy5mb3JOYW1lKCJqYXZhLnV0aWwuVmVjdG9yJDEiKS5nZXROYW1lKCkpKTsgLy8gYW5vbnltb3VzCi0KLQkJT2JqZWN0W10gYXJyYXkgPSBuZXcgamF2YS51dGlsLk1hcFswXTsgLy8gdG9wLWxldmVsCi0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTG9jYWwoYXJyYXkuZ2V0Q2xhc3MoKS5nZXROYW1lKCkpKTsKLQkJYXJyYXkgPSBuZXcgamF2YS51dGlsLk1hcC5FbnRyeVswXTsgLy8gbWVtYmVyCi0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTG9jYWwoYXJyYXkuZ2V0Q2xhc3MoKS5nZXROYW1lKCkpKTsKLQkJQ2xhc3M8Pz4gbG9jYWxDbGFzcyA9IENsYXNzLmZvck5hbWUobXVuZ2UodGhpcy5nZXRDbGFzcygpLmdldE5hbWUoKSArICIkMSRMb2NhbENsYXNzIikpOyAvLyBsb2NhbAotCQlhcnJheSA9IChPYmplY3RbXSkgQXJyYXkubmV3SW5zdGFuY2UobG9jYWxDbGFzcywgMCk7Ci0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTG9jYWwoYXJyYXkuZ2V0Q2xhc3MoKS5nZXROYW1lKCkpKTsKLQkJQ2xhc3M8Pz4gYW5vbkNsYXNzID0gQ2xhc3MuZm9yTmFtZSgiamF2YS51dGlsLlZlY3RvciQxIik7IC8vIGxvY2FsCi0JCWFycmF5ID0gKE9iamVjdFtdKSBBcnJheS5uZXdJbnN0YW5jZShhbm9uQ2xhc3MsIDApOwotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc0xvY2FsKGFycmF5LmdldENsYXNzKCkuZ2V0TmFtZSgpKSk7Ci0KLQkJLy8gdGVzdCBhIGZldyBlZGdlIGNhc2VzCi0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTG9jYWwoImphdmEudXRpbC5NYXAkYTEiKSk7Ci0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTG9jYWwoImphdmEudXRpbC5NYXAkYTEkYWFhJGJiYiIpKTsKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc0xvY2FsKCJqYXZhLnV0aWwuTWFwJDExJGFhYSIpKTsKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc0xvY2FsKCJqYXZhLnV0aWwuTWFwJDEkYSIpKTsgLy8gZWNsaXBzZSBuYW1pbmcgY29udmVudGlvbgotCQlhc3NlcnRUcnVlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTG9jYWwoImphdmEudXRpbC5NYXAkMiRhYmMiKSk7IC8vIGVjbGlwc2UgbmFtaW5nIGNvbnZlbnRpb24KLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc0xvY2FsKCJqYXZhLnV0aWwuTWFwJDIkYWJjMSIpKTsgLy8gZWNsaXBzZSBuYW1pbmcgY29udmVudGlvbgotCQlhc3NlcnRUcnVlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTG9jYWwoImphdmEudXRpbC5NYXAkMWEiKSk7IC8vIGpkayBuYW1pbmcgY29udmVudGlvbgotCQlhc3NlcnRUcnVlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTG9jYWwoImphdmEudXRpbC5NYXAkMmFiYyIpKTsgLy8gamRrIG5hbWluZyBjb252ZW50aW9uCi0JCWFzc2VydFRydWUoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNMb2NhbCgiamF2YS51dGlsLk1hcCQyYWJjMSIpKTsgLy8gamRrIG5hbWluZyBjb252ZW50aW9uCi0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzTG9jYWwoImphdmEudXRpbC5NYXAkYTEyMzQ1JGIxMjM0NSIpKTsKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc0xvY2FsKCJqYXZhLnV0aWwuTWFwJDEyMzQ1JGExMjM0IikpOwotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc0xvY2FsKCJqYXZhLnV0aWwuTWFwJDMzMyIpKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNMb2NhbCgiamF2YS51dGlsLk1hcDMkMzMzIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDbGFzc05hbWVkSXNBbm9ueW1vdXMoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNBbm9ueW1vdXMoamF2YS51dGlsLk1hcC5jbGFzcy5nZXROYW1lKCkpKTsgLy8gdG9wLWxldmVsCi0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzQW5vbnltb3VzKGphdmEudXRpbC5NYXAuRW50cnkuY2xhc3MuZ2V0TmFtZSgpKSk7IC8vIG1lbWJlcgotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc0Fub255bW91cyhDbGFzcy5mb3JOYW1lKG11bmdlKHRoaXMuZ2V0Q2xhc3MoKS5nZXROYW1lKCkgKyAiJDEkTG9jYWxDbGFzcyIpKS5nZXROYW1lKCkpKTsgLy8gbG9jYWwKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc0Fub255bW91cyhDbGFzcy5mb3JOYW1lKCJqYXZhLnV0aWwuVmVjdG9yJDEiKS5nZXROYW1lKCkpKTsgLy8gYW5vbnltb3VzCi0KLQkJT2JqZWN0W10gYXJyYXkgPSBuZXcgamF2YS51dGlsLk1hcFswXTsgLy8gdG9wLWxldmVsCi0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzQW5vbnltb3VzKGFycmF5LmdldENsYXNzKCkuZ2V0TmFtZSgpKSk7Ci0JCWFycmF5ID0gbmV3IGphdmEudXRpbC5NYXAuRW50cnlbMF07IC8vIG1lbWJlcgotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc0Fub255bW91cyhhcnJheS5nZXRDbGFzcygpLmdldE5hbWUoKSkpOwotCQlDbGFzczw/PiBsb2NhbENsYXNzID0gQ2xhc3MuZm9yTmFtZShtdW5nZSh0aGlzLmdldENsYXNzKCkuZ2V0TmFtZSgpICsgIiQxJExvY2FsQ2xhc3MiKSk7IC8vIGxvY2FsCi0JCWFycmF5ID0gKE9iamVjdFtdKSBBcnJheS5uZXdJbnN0YW5jZShsb2NhbENsYXNzLCAwKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNBbm9ueW1vdXMoYXJyYXkuZ2V0Q2xhc3MoKS5nZXROYW1lKCkpKTsKLQkJQ2xhc3M8Pz4gYW5vbkNsYXNzID0gQ2xhc3MuZm9yTmFtZSgiamF2YS51dGlsLlZlY3RvciQxIik7IC8vIGxvY2FsCi0JCWFycmF5ID0gKE9iamVjdFtdKSBBcnJheS5uZXdJbnN0YW5jZShhbm9uQ2xhc3MsIDApOwotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc0Fub255bW91cyhhcnJheS5nZXRDbGFzcygpLmdldE5hbWUoKSkpOwotCi0JCS8vIHRlc3QgYSBmZXcgZWRnZSBjYXNlcwotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc0Fub255bW91cygiamF2YS51dGlsLk1hcCRhMSIpKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNBbm9ueW1vdXMoImphdmEudXRpbC5NYXAkYTEkYWFhJGJiYiIpKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNBbm9ueW1vdXMoImphdmEudXRpbC5NYXAkMWExJGFhYSIpKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNBbm9ueW1vdXMoImphdmEudXRpbC5NYXAkMSRhIikpOwotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc0Fub255bW91cygiamF2YS51dGlsLk1hcCQxYSIpKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNBbm9ueW1vdXMoImphdmEudXRpbC5NYXAkYTEyMzQ1JGIxMjM0NSIpKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNBbm9ueW1vdXMoImphdmEudXRpbC5NYXAkMTIzNDUkYTEyMzQiKSk7Ci0JCWFzc2VydFRydWUoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNBbm9ueW1vdXMoImphdmEudXRpbC5NYXAkMzMzIikpOwotCQlhc3NlcnRUcnVlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzQW5vbnltb3VzKCJqYXZhLnV0aWwuTWFwMyQzMzMiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvZGVGb3JDbGFzcygpIHsKLQkJYXNzZXJ0RXF1YWxzKCdJJywgQ2xhc3NUb29scy5jb2RlRm9yQ2xhc3MoaW50LmNsYXNzKSk7Ci0JCWFzc2VydEVxdWFscygnQicsIENsYXNzVG9vbHMuY29kZUZvckNsYXNzKGJ5dGUuY2xhc3MpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29kZUZvckNsYXNzTmFtZWQoKSB7Ci0JCWFzc2VydEVxdWFscygnSScsIENsYXNzVG9vbHMuY29kZUZvckNsYXNzTmFtZWQoaW50LmNsYXNzLmdldE5hbWUoKSkpOwotCQlhc3NlcnRFcXVhbHMoJ0knLCBDbGFzc1Rvb2xzLmNvZGVGb3JDbGFzc05hbWVkKCJpbnQiKSk7Ci0JCWFzc2VydEVxdWFscygnQicsIENsYXNzVG9vbHMuY29kZUZvckNsYXNzTmFtZWQoYnl0ZS5jbGFzcy5nZXROYW1lKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCdCJywgQ2xhc3NUb29scy5jb2RlRm9yQ2xhc3NOYW1lZCgiYnl0ZSIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2xhc3NJc1ByaW1pdGl2ZVdyYXBwZXJDbGFzcygpIHsKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzSXNQcmltaXRpdmVXcmFwcGVyQ2xhc3MoamF2YS5sYW5nLlZvaWQuY2xhc3MpKTsKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzSXNQcmltaXRpdmVXcmFwcGVyQ2xhc3MoamF2YS5sYW5nLkJvb2xlYW4uY2xhc3MpKTsKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzSXNQcmltaXRpdmVXcmFwcGVyQ2xhc3MoamF2YS5sYW5nLkludGVnZXIuY2xhc3MpKTsKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzSXNQcmltaXRpdmVXcmFwcGVyQ2xhc3MoamF2YS5sYW5nLkZsb2F0LmNsYXNzKSk7Ci0KLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc0lzUHJpbWl0aXZlV3JhcHBlckNsYXNzKGphdmEubGFuZy5TdHJpbmcuY2xhc3MpKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc0lzUHJpbWl0aXZlV3JhcHBlckNsYXNzKHZvaWQuY2xhc3MpKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc0lzUHJpbWl0aXZlV3JhcHBlckNsYXNzKGludC5jbGFzcykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDbGFzc0lzVmFyaWFibGVQcmltaXRpdmVXcmFwcGVyQ2xhc3MoKSB7Ci0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NJc1ZhcmlhYmxlUHJpbWl0aXZlV3JhcHBlckNsYXNzKGphdmEubGFuZy5Wb2lkLmNsYXNzKSk7Ci0KLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzSXNWYXJpYWJsZVByaW1pdGl2ZVdyYXBwZXJDbGFzcyhqYXZhLmxhbmcuQm9vbGVhbi5jbGFzcykpOwotCQlhc3NlcnRUcnVlKENsYXNzVG9vbHMuY2xhc3NJc1ZhcmlhYmxlUHJpbWl0aXZlV3JhcHBlckNsYXNzKGphdmEubGFuZy5JbnRlZ2VyLmNsYXNzKSk7Ci0JCWFzc2VydFRydWUoQ2xhc3NUb29scy5jbGFzc0lzVmFyaWFibGVQcmltaXRpdmVXcmFwcGVyQ2xhc3MoamF2YS5sYW5nLkZsb2F0LmNsYXNzKSk7Ci0KLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc0lzVmFyaWFibGVQcmltaXRpdmVXcmFwcGVyQ2xhc3MoamF2YS5sYW5nLlN0cmluZy5jbGFzcykpOwotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzSXNWYXJpYWJsZVByaW1pdGl2ZVdyYXBwZXJDbGFzcyh2b2lkLmNsYXNzKSk7Ci0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NJc1ZhcmlhYmxlUHJpbWl0aXZlV3JhcHBlckNsYXNzKGludC5jbGFzcykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDbGFzc05hbWVkSXNQcmltaXRpdmUoKSB7Ci0JCWFzc2VydFRydWUodm9pZC5jbGFzcy5pc1ByaW1pdGl2ZSgpKTsKLQotCQlhc3NlcnRUcnVlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzUHJpbWl0aXZlKHZvaWQuY2xhc3MuZ2V0TmFtZSgpKSk7Ci0JCWFzc2VydFRydWUoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNQcmltaXRpdmUoaW50LmNsYXNzLmdldE5hbWUoKSkpOwotCQlhc3NlcnRUcnVlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzUHJpbWl0aXZlKGZsb2F0LmNsYXNzLmdldE5hbWUoKSkpOwotCQlhc3NlcnRUcnVlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzUHJpbWl0aXZlKGJvb2xlYW4uY2xhc3MuZ2V0TmFtZSgpKSk7Ci0KLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNQcmltaXRpdmUoamF2YS5sYW5nLk51bWJlci5jbGFzcy5nZXROYW1lKCkpKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNQcmltaXRpdmUoamF2YS5sYW5nLlN0cmluZy5jbGFzcy5nZXROYW1lKCkpKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNQcmltaXRpdmUoamF2YS5sYW5nLkJvb2xlYW4uY2xhc3MuZ2V0TmFtZSgpKSk7Ci0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzUHJpbWl0aXZlKGphdmEubGFuZy5JbnRlZ2VyLmNsYXNzLmdldE5hbWUoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDbGFzc05hbWVkSXNWYXJpYWJsZVByaW1pdGl2ZSgpIHsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNWYXJpYWJsZVByaW1pdGl2ZSh2b2lkLmNsYXNzLmdldE5hbWUoKSkpOwotCi0JCWFzc2VydFRydWUoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNWYXJpYWJsZVByaW1pdGl2ZShpbnQuY2xhc3MuZ2V0TmFtZSgpKSk7Ci0JCWFzc2VydFRydWUoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNWYXJpYWJsZVByaW1pdGl2ZShmbG9hdC5jbGFzcy5nZXROYW1lKCkpKTsKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc1ZhcmlhYmxlUHJpbWl0aXZlKGJvb2xlYW4uY2xhc3MuZ2V0TmFtZSgpKSk7Ci0KLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNWYXJpYWJsZVByaW1pdGl2ZShqYXZhLmxhbmcuTnVtYmVyLmNsYXNzLmdldE5hbWUoKSkpOwotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc1ZhcmlhYmxlUHJpbWl0aXZlKGphdmEubGFuZy5TdHJpbmcuY2xhc3MuZ2V0TmFtZSgpKSk7Ci0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzVmFyaWFibGVQcmltaXRpdmUoamF2YS5sYW5nLkJvb2xlYW4uY2xhc3MuZ2V0TmFtZSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENsYXNzTmFtZWRJc1ZhcmlhYmxlUHJpbWl0aXZlV3JhcHBlckNsYXNzKCkgewotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc1ZhcmlhYmxlUHJpbWl0aXZlV3JhcHBlckNsYXNzKGphdmEubGFuZy5Wb2lkLmNsYXNzLmdldE5hbWUoKSkpOwotCi0JCWFzc2VydFRydWUoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNWYXJpYWJsZVByaW1pdGl2ZVdyYXBwZXJDbGFzcyhqYXZhLmxhbmcuSW50ZWdlci5jbGFzcy5nZXROYW1lKCkpKTsKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc1ZhcmlhYmxlUHJpbWl0aXZlV3JhcHBlckNsYXNzKGphdmEubGFuZy5GbG9hdC5jbGFzcy5nZXROYW1lKCkpKTsKLQkJYXNzZXJ0VHJ1ZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc1ZhcmlhYmxlUHJpbWl0aXZlV3JhcHBlckNsYXNzKGphdmEubGFuZy5Cb29sZWFuLmNsYXNzLmdldE5hbWUoKSkpOwotCi0JCWFzc2VydEZhbHNlKENsYXNzVG9vbHMuY2xhc3NOYW1lZElzVmFyaWFibGVQcmltaXRpdmVXcmFwcGVyQ2xhc3MoamF2YS5sYW5nLk51bWJlci5jbGFzcy5nZXROYW1lKCkpKTsKLQkJYXNzZXJ0RmFsc2UoQ2xhc3NUb29scy5jbGFzc05hbWVkSXNWYXJpYWJsZVByaW1pdGl2ZVdyYXBwZXJDbGFzcyhqYXZhLmxhbmcuU3RyaW5nLmNsYXNzLmdldE5hbWUoKSkpOwotCQlhc3NlcnRGYWxzZShDbGFzc1Rvb2xzLmNsYXNzTmFtZWRJc1ZhcmlhYmxlUHJpbWl0aXZlV3JhcHBlckNsYXNzKGphdmEubGFuZy5PYmplY3QuY2xhc3MuZ2V0TmFtZSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENsYXNzRm9yVHlwZURlY2xhcmF0aW9uU3RyaW5nSW50KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWFzc2VydEVxdWFscyhpbnQuY2xhc3MsIENsYXNzVG9vbHMuY2xhc3NGb3JUeXBlRGVjbGFyYXRpb24oImludCIsIDApKTsKLQkJYXNzZXJ0RXF1YWxzKGludFtdLmNsYXNzLCBDbGFzc1Rvb2xzLmNsYXNzRm9yVHlwZURlY2xhcmF0aW9uKCJpbnQiLCAxKSk7Ci0JCWFzc2VydEVxdWFscyhpbnRbXVtdW10uY2xhc3MsIENsYXNzVG9vbHMuY2xhc3NGb3JUeXBlRGVjbGFyYXRpb24oImludCIsIDMpKTsKLQotCQlhc3NlcnRFcXVhbHMoT2JqZWN0LmNsYXNzLCBDbGFzc1Rvb2xzLmNsYXNzRm9yVHlwZURlY2xhcmF0aW9uKCJqYXZhLmxhbmcuT2JqZWN0IiwgMCkpOwotCQlhc3NlcnRFcXVhbHMoT2JqZWN0W11bXVtdLmNsYXNzLCBDbGFzc1Rvb2xzLmNsYXNzRm9yVHlwZURlY2xhcmF0aW9uKCJqYXZhLmxhbmcuT2JqZWN0IiwgMykpOwotCi0JCWFzc2VydEVxdWFscyh2b2lkLmNsYXNzLCBDbGFzc1Rvb2xzLmNsYXNzRm9yVHlwZURlY2xhcmF0aW9uKCJ2b2lkIiwgMCkpOwotCQl0cnkgewotCQkJQ2xhc3NUb29scy5jbGFzc0ZvclR5cGVEZWNsYXJhdGlvbih2b2lkLmNsYXNzLmdldE5hbWUoKSwgMSk7Ci0JCQlmYWlsKCJzaG91bGQgbm90IGdldCBoZXJlLi4uIik7Ci0JCX0gY2F0Y2ggKENsYXNzTm90Rm91bmRFeGNlcHRpb24gZXgpIHsKLQkJCS8vIGV4cGVjdGVkCi0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2xhc3NOYW1lRm9yVHlwZURlY2xhcmF0aW9uU3RyaW5nKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWFzc2VydEVxdWFscygiaW50IiwgQ2xhc3NUb29scy5jbGFzc05hbWVGb3JUeXBlRGVjbGFyYXRpb24oImludCIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJbSSIsIENsYXNzVG9vbHMuY2xhc3NOYW1lRm9yVHlwZURlY2xhcmF0aW9uKCJpbnRbXSIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJbW0kiLCBDbGFzc1Rvb2xzLmNsYXNzTmFtZUZvclR5cGVEZWNsYXJhdGlvbigiaW50IFsgXSBbIF0iKSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKCJqYXZhLmxhbmcuT2JqZWN0IiwgQ2xhc3NUb29scy5jbGFzc05hbWVGb3JUeXBlRGVjbGFyYXRpb24oImphdmEubGFuZy5PYmplY3QiKSk7Ci0JCWFzc2VydEVxdWFscygiW0xqYXZhLmxhbmcuT2JqZWN0OyIsIENsYXNzVG9vbHMuY2xhc3NOYW1lRm9yVHlwZURlY2xhcmF0aW9uKCJqYXZhLmxhbmcuT2JqZWN0XHRbXSIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJbW0xqYXZhLmxhbmcuT2JqZWN0OyIsIENsYXNzVG9vbHMuY2xhc3NOYW1lRm9yVHlwZURlY2xhcmF0aW9uKCJqYXZhLmxhbmcuT2JqZWN0XHRbXVx0W10iKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFycmF5RGVwdGhGb3JUeXBlRGVjbGFyYXRpb25TdHJpbmcoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0RXF1YWxzKDAsIENsYXNzVG9vbHMuYXJyYXlEZXB0aEZvclR5cGVEZWNsYXJhdGlvbigiamF2YS5sYW5nLk9iamVjdCIpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIENsYXNzVG9vbHMuYXJyYXlEZXB0aEZvclR5cGVEZWNsYXJhdGlvbigiamF2YS5sYW5nLk9iamVjdFtdIikpOwotCQlhc3NlcnRFcXVhbHMoMywgQ2xhc3NUb29scy5hcnJheURlcHRoRm9yVHlwZURlY2xhcmF0aW9uKCJqYXZhLmxhbmcuT2JqZWN0W11bXVtdIikpOwotCi0JCWFzc2VydEVxdWFscygwLCBDbGFzc1Rvb2xzLmFycmF5RGVwdGhGb3JUeXBlRGVjbGFyYXRpb24oImludCIpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIENsYXNzVG9vbHMuYXJyYXlEZXB0aEZvclR5cGVEZWNsYXJhdGlvbigiaW50W10iKSk7Ci0JCWFzc2VydEVxdWFscygzLCBDbGFzc1Rvb2xzLmFycmF5RGVwdGhGb3JUeXBlRGVjbGFyYXRpb24oImludFtdW11bXSIpKTsKLQotCQlhc3NlcnRFcXVhbHMoMCwgQ2xhc3NUb29scy5hcnJheURlcHRoRm9yVHlwZURlY2xhcmF0aW9uKCJmbG9hdCIpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIENsYXNzVG9vbHMuYXJyYXlEZXB0aEZvclR5cGVEZWNsYXJhdGlvbigiZmxvYXQgWyBdIikpOwotCQlhc3NlcnRFcXVhbHMoMywgQ2xhc3NUb29scy5hcnJheURlcHRoRm9yVHlwZURlY2xhcmF0aW9uKCJmbG9hdFtdIFtdIFtdIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RFbGVtZW50VHlwZU5hbWVGb3JUeXBlRGVjbGFyYXRpb25TdHJpbmcoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0RXF1YWxzKCJqYXZhLmxhbmcuT2JqZWN0IiwgQ2xhc3NUb29scy5lbGVtZW50VHlwZU5hbWVGb3JUeXBlRGVjbGFyYXRpb24oImphdmEubGFuZy5PYmplY3QiKSk7Ci0JCWFzc2VydEVxdWFscygiamF2YS5sYW5nLk9iamVjdCIsIENsYXNzVG9vbHMuZWxlbWVudFR5cGVOYW1lRm9yVHlwZURlY2xhcmF0aW9uKCJqYXZhLmxhbmcuT2JqZWN0W10iKSk7Ci0JCWFzc2VydEVxdWFscygiamF2YS5sYW5nLk9iamVjdCIsIENsYXNzVG9vbHMuZWxlbWVudFR5cGVOYW1lRm9yVHlwZURlY2xhcmF0aW9uKCJqYXZhLmxhbmcuT2JqZWN0W11bXVtdIikpOwotCi0JCWFzc2VydEVxdWFscygiaW50IiwgQ2xhc3NUb29scy5lbGVtZW50VHlwZU5hbWVGb3JUeXBlRGVjbGFyYXRpb24oImludCIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJpbnQiLCBDbGFzc1Rvb2xzLmVsZW1lbnRUeXBlTmFtZUZvclR5cGVEZWNsYXJhdGlvbigiaW50W10iKSk7Ci0JCWFzc2VydEVxdWFscygiaW50IiwgQ2xhc3NUb29scy5lbGVtZW50VHlwZU5hbWVGb3JUeXBlRGVjbGFyYXRpb24oImludFtdW11bXSIpKTsKLQotCQlhc3NlcnRFcXVhbHMoImZsb2F0IiwgQ2xhc3NUb29scy5lbGVtZW50VHlwZU5hbWVGb3JUeXBlRGVjbGFyYXRpb24oImZsb2F0IikpOwotCQlhc3NlcnRFcXVhbHMoImZsb2F0IiwgQ2xhc3NUb29scy5lbGVtZW50VHlwZU5hbWVGb3JUeXBlRGVjbGFyYXRpb24oImZsb2F0IFsgXSIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmbG9hdCIsIENsYXNzVG9vbHMuZWxlbWVudFR5cGVOYW1lRm9yVHlwZURlY2xhcmF0aW9uKCJmbG9hdFtdIFtdIFtdIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDbGFzc05hbWVGb3JUeXBlRGVjbGFyYXRpb25TdHJpbmdJbnQoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0RXF1YWxzKGludC5jbGFzcy5nZXROYW1lKCksIENsYXNzVG9vbHMuY2xhc3NOYW1lRm9yVHlwZURlY2xhcmF0aW9uKCJpbnQiLCAwKSk7Ci0JCWFzc2VydEVxdWFscyhpbnRbXS5jbGFzcy5nZXROYW1lKCksIENsYXNzVG9vbHMuY2xhc3NOYW1lRm9yVHlwZURlY2xhcmF0aW9uKCJpbnQiLCAxKSk7Ci0JCWFzc2VydEVxdWFscyhpbnRbXVtdW10uY2xhc3MuZ2V0TmFtZSgpLCBDbGFzc1Rvb2xzLmNsYXNzTmFtZUZvclR5cGVEZWNsYXJhdGlvbigiaW50IiwgMykpOwotCi0JCWFzc2VydEVxdWFscyhPYmplY3QuY2xhc3MuZ2V0TmFtZSgpLCBDbGFzc1Rvb2xzLmNsYXNzTmFtZUZvclR5cGVEZWNsYXJhdGlvbigiamF2YS5sYW5nLk9iamVjdCIsIDApKTsKLQkJYXNzZXJ0RXF1YWxzKE9iamVjdFtdW11bXS5jbGFzcy5nZXROYW1lKCksIENsYXNzVG9vbHMuY2xhc3NOYW1lRm9yVHlwZURlY2xhcmF0aW9uKCJqYXZhLmxhbmcuT2JqZWN0IiwgMykpOwotCi0JCWFzc2VydEVxdWFscyh2b2lkLmNsYXNzLmdldE5hbWUoKSwgQ2xhc3NUb29scy5jbGFzc05hbWVGb3JUeXBlRGVjbGFyYXRpb24oInZvaWQiLCAwKSk7Ci0JCXRyeSB7Ci0JCQlDbGFzc1Rvb2xzLmNsYXNzTmFtZUZvclR5cGVEZWNsYXJhdGlvbih2b2lkLmNsYXNzLmdldE5hbWUoKSwgMSk7Ci0JCQlmYWlsKCJzaG91bGQgbm90IGdldCBoZXJlLi4uIik7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJLy8gZXhwZWN0ZWQKLQkJfQotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8U3RyaW5nPiBuYW1lcyhGaWVsZFtdIGZpZWxkcykgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8RmllbGQsIFN0cmluZz4oQ29sbGVjdGlvblRvb2xzLml0ZXJhdG9yKGZpZWxkcykpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyB0cmFuc2Zvcm0oRmllbGQgZmllbGQpIHsKLQkJCQlyZXR1cm4gZmllbGQuZ2V0TmFtZSgpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8U3RyaW5nPiBuYW1lcyhNZXRob2RbXSBtZXRob2RzKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25JdGVyYXRvcjxNZXRob2QsIFN0cmluZz4oQ29sbGVjdGlvblRvb2xzLml0ZXJhdG9yKG1ldGhvZHMpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKE1ldGhvZCBtZXRob2QpIHsKLQkJCQlyZXR1cm4gbWV0aG9kLmdldE5hbWUoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvQ2xhc3NwYXRoVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvQ2xhc3NwYXRoVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNGUxOWRhYy4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0NsYXNzcGF0aFRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyODkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uRmlsZTsKLWltcG9ydCBqYXZhLmlvLklPRXhjZXB0aW9uOwotaW1wb3J0IGphdmEubmV0LlVSTDsKLWltcG9ydCBqYXZhLnV0aWwuamFyLkphckVudHJ5OwotaW1wb3J0IGphdmEudXRpbC5qYXIuSmFyRmlsZTsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NwYXRoOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLQotcHVibGljIGNsYXNzIENsYXNzcGF0aFRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBKQVZBX0hPTUUgPSBTeXN0ZW0uZ2V0UHJvcGVydHkoImphdmEuaG9tZSIpOwotCi0JcHVibGljIENsYXNzcGF0aFRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb21wcmVzc2VkKCkgewotCQlTdHJpbmcgcGF0aCA9ICIiOwotCi0JCS8vIG5vIGNoYW5nZXMKLQkJcGF0aCA9IG5ldyBDbGFzc3BhdGgodGhpcy5tb3JwaCgiQzpcXGpka1xcaTE4bi5qYXI7QzpcXGpka1xccnQuamFyO0M6XFxqZGtcXGphd3MuamFyIikpLmNvbXByZXNzZWQoKS5wYXRoKCk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLm1vcnBoKCJDOlxcamRrXFxpMThuLmphcjtDOlxcamRrXFxydC5qYXI7QzpcXGpka1xcamF3cy5qYXIiKSwgcGF0aCk7Ci0KLQkJcGF0aCA9IG5ldyBDbGFzc3BhdGgodGhpcy5tb3JwaCgiQzpcXGpka1xcaTE4bi5qYXI7QzpcXGpka1xccnQuamFyO0M6XFxqZGtcXGphd3MuamFyO0M6XFxqZGtcXHJ0LmphcjtDOlxcamRrXFxqYXdzLmphciIpKS5jb21wcmVzc2VkKCkucGF0aCgpOwotCQlhc3NlcnRFcXVhbHModGhpcy5tb3JwaCgiQzpcXGpka1xcaTE4bi5qYXI7QzpcXGpka1xccnQuamFyO0M6XFxqZGtcXGphd3MuamFyIiksIHBhdGgpOwotCi0JCXBhdGggPSBuZXcgQ2xhc3NwYXRoKHRoaXMubW9ycGgoIkM6XFxqZGtcXGkxOG4uamFyO0M6XFxqZGtcXHJ0LmphcjtDOlxcamRrXFxpMThuLmphcjtDOlxcamRrXFxqYXdzLmphciIpKS5jb21wcmVzc2VkKCkucGF0aCgpOwotCQlhc3NlcnRFcXVhbHModGhpcy5tb3JwaCgiQzpcXGpka1xcaTE4bi5qYXI7QzpcXGpka1xccnQuamFyO0M6XFxqZGtcXGphd3MuamFyIiksIHBhdGgpOwotCi0JCXBhdGggPSBuZXcgQ2xhc3NwYXRoKHRoaXMubW9ycGgoIkM6XFxqZGtcXGkxOG4uamFyO0M6XFxqZGtcXHJ0LmphcjtDOlxcamRrXFxqYXdzLmphcjtDOlxcamRrXFxpMThuLmphcjtDOlxcamRrXFxydC5qYXI7QzpcXGpka1xcamF3cy5qYXIiKSkuY29tcHJlc3NlZCgpLnBhdGgoKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMubW9ycGgoIkM6XFxqZGtcXGkxOG4uamFyO0M6XFxqZGtcXHJ0LmphcjtDOlxcamRrXFxqYXdzLmphciIpLCBwYXRoKTsKLQotCQlwYXRoID0gbmV3IENsYXNzcGF0aCh0aGlzLm1vcnBoKCJDOlxcamRrXFxpMThuLmphcjtDOlxcamRrXFxpMThuLmphcjtDOlxcamRrXFxpMThuLmphcjtDOlxcamRrXFxpMThuLmphcjtDOlxcamRrXFxydC5qYXI7QzpcXGpka1xcamF3cy5qYXI7QzpcXGpka1xccnQuamFyO0M6XFxqZGtcXGphd3MuamFyIikpLmNvbXByZXNzZWQoKS5wYXRoKCk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLm1vcnBoKCJDOlxcamRrXFxpMThuLmphcjtDOlxcamRrXFxydC5qYXI7QzpcXGpka1xcamF3cy5qYXIiKSwgcGF0aCk7Ci0KLQkJcGF0aCA9IG5ldyBDbGFzc3BhdGgodGhpcy5tb3JwaCgiQzpcXGpka1xcaTE4bi5qYXI7QzpcXGpka1xccnQuamFyO0M6XFxqZGtcXGphd3MuamFyO0M6XFxqZGtcXHJ0Lmphcjs7OztDOlxcamRrXFxqYXdzLmphcjtDOlxcamRrXFxqYXdzLmphcjtDOlxcamRrXFxydC5qYXI7OzsiKSkuY29tcHJlc3NlZCgpLnBhdGgoKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMubW9ycGgoIkM6XFxqZGtcXGkxOG4uamFyO0M6XFxqZGtcXHJ0LmphcjtDOlxcamRrXFxqYXdzLmphciIpLCBwYXRoKTsKLQotCQkvLyBubyBjaGFuZ2VzCi0JCXBhdGggPSBuZXcgQ2xhc3NwYXRoKHRoaXMubW9ycGgoIkM6XFxqZGtcXGkxOG4uamFyO0M6XFxqZGtcXHJ0LmphcjtDOlxcamRrXFxqYXdzLmphciIpKS5jb21wcmVzc2VkKCkucGF0aCgpOwotCQlhc3NlcnRFcXVhbHModGhpcy5tb3JwaCgiQzpcXGpka1xcaTE4bi5qYXI7QzpcXGpka1xccnQuamFyO0M6XFxqZGtcXGphd3MuamFyIiksIHBhdGgpOwotCi0JCXBhdGggPSBuZXcgQ2xhc3NwYXRoKHRoaXMubW9ycGgoIkM6XFxqZGtcXGkxOG4uamFyO0M6XFxqZGtcXHJ0LmphcjtDOlxcamRrXFxqYXdzLmphcjtDOlxcamRrXFxydC5qYXI7QzpcXGpka1xcamF3cy5qYXIiKSkuY29tcHJlc3NlZCgpLnBhdGgoKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMubW9ycGgoIkM6XFxqZGtcXGkxOG4uamFyO0M6XFxqZGtcXHJ0LmphcjtDOlxcamRrXFxqYXdzLmphciIpLCBwYXRoKTsKLQotCQlwYXRoID0gbmV3IENsYXNzcGF0aCh0aGlzLm1vcnBoKCJDOlxcamRrXFxpMThuLmphcjtDOlxcamRrXFxydC5qYXI7QzpcXGpka1xcLi5cXGpka1xcaTE4bi5qYXI7QzpcXGpka1xcamF3cy5qYXIiKSkuY29tcHJlc3NlZCgpLnBhdGgoKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMubW9ycGgoIkM6XFxqZGtcXGkxOG4uamFyO0M6XFxqZGtcXHJ0LmphcjtDOlxcamRrXFxqYXdzLmphciIpLCBwYXRoKTsKLQotCQlwYXRoID0gbmV3IENsYXNzcGF0aCh0aGlzLm1vcnBoKCJDOlxcamRrMVxcamRrMlxcamRrM1xcaTE4bi5qYXI7QzpcXGpka1xccnQuamFyO0M6XFxqZGsxXFxqZGsyXFxqZGszXFwuLlxcLi5cXC4uXFxqZGsxXFxqZGsyXFxqZGszXFxpMThuLmphcjtDOlxcamRrXFxqYXdzLmphciIpKS5jb21wcmVzc2VkKCkucGF0aCgpOwotCQlhc3NlcnRFcXVhbHModGhpcy5tb3JwaCgiQzpcXGpkazFcXGpkazJcXGpkazNcXGkxOG4uamFyO0M6XFxqZGtcXHJ0LmphcjtDOlxcamRrXFxqYXdzLmphciIpLCBwYXRoKTsKLQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb252ZXJ0VG9DbGFzc05hbWUoKSB7Ci0JCVN0cmluZyBmaWxlTmFtZSA9ICJqYXZhL2xhbmcvU3RyaW5nLmNsYXNzIjsKLQkJRmlsZSBmaWxlID0gbmV3IEZpbGUoZmlsZU5hbWUpOwotCQlTdHJpbmcgY2xhc3NOYW1lID0gQ2xhc3NwYXRoLmNvbnZlcnRUb0NsYXNzTmFtZShmaWxlKTsKLQkJYXNzZXJ0RXF1YWxzKGphdmEubGFuZy5TdHJpbmcuY2xhc3MuZ2V0TmFtZSgpLCBjbGFzc05hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb252ZXJ0VG9DbGFzcygpIHRocm93cyBDbGFzc05vdEZvdW5kRXhjZXB0aW9uIHsKLQkJU3RyaW5nIGZpbGVOYW1lID0gImphdmEvbGFuZy9TdHJpbmcuY2xhc3MiOwotCQlGaWxlIGZpbGUgPSBuZXcgRmlsZShmaWxlTmFtZSk7Ci0JCUNsYXNzPD8+IGphdmFDbGFzcyA9IENsYXNzcGF0aC5jb252ZXJ0VG9DbGFzcyhmaWxlKTsKLQkJYXNzZXJ0RXF1YWxzKGphdmEubGFuZy5TdHJpbmcuY2xhc3MsIGphdmFDbGFzcyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnZlcnRUb0FyY2hpdmVDbGFzc0ZpbGVFbnRyeU5hbWUoKSB7Ci0JCVN0cmluZyBmaWxlTmFtZSA9IENsYXNzcGF0aC5jb252ZXJ0VG9BcmNoaXZlQ2xhc3NGaWxlRW50cnlOYW1lKGphdmEubGFuZy5TdHJpbmcuY2xhc3MpOwotCQlhc3NlcnRFcXVhbHMoImphdmEvbGFuZy9TdHJpbmcuY2xhc3MiLCBmaWxlTmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnZlcnRUb0NsYXNzRmlsZU5hbWUoKSB7Ci0JCWNoYXIgc2MgPSBGaWxlLnNlcGFyYXRvckNoYXI7Ci0JCVN0cmluZyBmaWxlTmFtZSA9IENsYXNzcGF0aC5jb252ZXJ0VG9DbGFzc0ZpbGVOYW1lKGphdmEubGFuZy5TdHJpbmcuY2xhc3MpOwotCQlhc3NlcnRFcXVhbHMoImphdmEiICsgc2MgKyAibGFuZyIgKyBzYyArICJTdHJpbmcuY2xhc3MiLCBmaWxlTmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnZlcnRUb0phdmFGaWxlTmFtZSgpIHsKLQkJY2hhciBzYyA9IEZpbGUuc2VwYXJhdG9yQ2hhcjsKLQkJU3RyaW5nIGZpbGVOYW1lID0gQ2xhc3NwYXRoLmNvbnZlcnRUb0phdmFGaWxlTmFtZShqYXZhLmxhbmcuU3RyaW5nLmNsYXNzLmdldE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygiamF2YSIgKyBzYyArICJsYW5nIiArIHNjICsgIlN0cmluZy5qYXZhIiwgZmlsZU5hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb252ZXJ0VG9VUkxzKCkgewotCQlVUkxbXSBlbnRyaWVzID0gbmV3IENsYXNzcGF0aCh0aGlzLm1vcnBoKCJDOlxcamRrXFxydC5qYXI7QzpcXGpka1xcaTE4bi5qYXI7QzpcXGpka1xcamF3cy5qYXI7QzpcXGZvb1xcY2xhc3NlcztDOlxcYmFyXFxiYXIuamFyIikpLnVybHMoKTsKLQkJaW50IGkgPSAwOwotCQlhc3NlcnRFcXVhbHModGhpcy5tb3JwaFVSTCgiL0M6L2pkay9ydC5qYXIiKSwgZW50cmllc1tpKytdLmdldFBhdGgoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLm1vcnBoVVJMKCIvQzovamRrL2kxOG4uamFyIiksIGVudHJpZXNbaSsrXS5nZXRQYXRoKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5tb3JwaFVSTCgiL0M6L2pkay9qYXdzLmphciIpLCBlbnRyaWVzW2krK10uZ2V0UGF0aCgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMubW9ycGhVUkwoIi9DOi9mb28vY2xhc3NlcyIpLCBlbnRyaWVzW2krK10uZ2V0UGF0aCgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMubW9ycGhVUkwoIi9DOi9iYXIvYmFyLmphciIpLCBlbnRyaWVzW2krK10uZ2V0UGF0aCgpKTsKLQkJYXNzZXJ0RXF1YWxzKGksIGVudHJpZXMubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RW50cmllcygpIHsKLQkJQ2xhc3NwYXRoIGNwID0gbmV3IENsYXNzcGF0aCh0aGlzLm1vcnBoKCJDOlxcamRrXFxydC5qYXI7Oy47QzpcXGpka1xcaTE4bi5qYXI7OztDOlxcamRrXFxqYXdzLmphcjs7QzpcXGZvb1xcY2xhc3NlcztDOlxcYmFyXFxiYXIuamFyO0M6XFxiYXJcXGJhci5qYXI7IikpOwotCQlDbGFzc3BhdGguRW50cnlbXSBlbnRyaWVzID0gY3AuZW50cmllcygpOwotCQlpbnQgaSA9IDA7Ci0JCWFzc2VydEVxdWFscyh0aGlzLm1vcnBoKCJDOlxcamRrXFxydC5qYXIiKSwgZW50cmllc1tpKytdLmZpbGVOYW1lKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5tb3JwaCgiLiIpLCBlbnRyaWVzW2krK10uZmlsZU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLm1vcnBoKCJDOlxcamRrXFxpMThuLmphciIpLCBlbnRyaWVzW2krK10uZmlsZU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLm1vcnBoKCJDOlxcamRrXFxqYXdzLmphciIpLCBlbnRyaWVzW2krK10uZmlsZU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLm1vcnBoKCJDOlxcZm9vXFxjbGFzc2VzIiksIGVudHJpZXNbaSsrXS5maWxlTmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMubW9ycGgoIkM6XFxiYXJcXGJhci5qYXIiKSwgZW50cmllc1tpKytdLmZpbGVOYW1lKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5tb3JwaCgiQzpcXGJhclxcYmFyLmphciIpLCBlbnRyaWVzW2krK10uZmlsZU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscyhpLCBlbnRyaWVzLmxlbmd0aCk7Ci0KLQkJY3AgPSBjcC5jb21wcmVzc2VkKCk7Ci0JCWVudHJpZXMgPSBjcC5lbnRyaWVzKCk7Ci0JCWkgPSAwOwotCQlhc3NlcnRFcXVhbHModGhpcy5tb3JwaCgiQzpcXGpka1xccnQuamFyIiksIGVudHJpZXNbaSsrXS5maWxlTmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMubW9ycGgoIi4iKSwgZW50cmllc1tpKytdLmZpbGVOYW1lKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5tb3JwaCgiQzpcXGpka1xcaTE4bi5qYXIiKSwgZW50cmllc1tpKytdLmZpbGVOYW1lKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5tb3JwaCgiQzpcXGpka1xcamF3cy5qYXIiKSwgZW50cmllc1tpKytdLmZpbGVOYW1lKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5tb3JwaCgiQzpcXGZvb1xcY2xhc3NlcyIpLCBlbnRyaWVzW2krK10uZmlsZU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLm1vcnBoKCJDOlxcYmFyXFxiYXIuamFyIiksIGVudHJpZXNbaSsrXS5maWxlTmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGksIGVudHJpZXMubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RW50cnlGb3JGaWxlTmFtZWQoKSB7Ci0JCUNsYXNzcGF0aC5FbnRyeSBlbnRyeSA9IG51bGw7Ci0KLQkJLy8gaW4gdGhlIG1pZGRsZSAtIHF1YWxpZmllZAotCQllbnRyeSA9IG5ldyBDbGFzc3BhdGgodGhpcy5tb3JwaCgiQzpcXGpka1xcaTE4bi5qYXI7QzpcXGpka1xccnQuamFyO0M6XFxqZGtcXGphd3MuamFyO0M6XFxmb29cXGNsYXNzZXM7QzpcXGJhclxcYmFyLmphciIpKS5lbnRyeUZvckZpbGVOYW1lZCgicnQuamFyIik7Ci0JCWFzc2VydEVxdWFscyh0aGlzLm1vcnBoKCJDOlxcamRrXFxydC5qYXIiKSwgZW50cnkuZmlsZU5hbWUoKSk7Ci0KLQkJLy8gaW4gdGhlIG1pZGRsZSAtIHVucXVhbGlmaWVkCi0JCWVudHJ5ID0gbmV3IENsYXNzcGF0aCh0aGlzLm1vcnBoKCJDOlxcamRrXFxpMThuLmphcjtDOlxcamRrXFxqYXdzLmphcjtydC5qYXI7QzpcXGZvb1xcY2xhc3NlcztDOlxcYmFyXFxiYXIuamFyIikpLmVudHJ5Rm9yRmlsZU5hbWVkKCJydC5qYXIiKTsKLQkJYXNzZXJ0RXF1YWxzKCJydC5qYXIiLCBlbnRyeS5maWxlTmFtZSgpKTsKLQotCQkvLyBhdCB0aGUgYmVnaW5uaW5nIC0gcXVhbGlmaWVkCi0JCWVudHJ5ID0gbmV3IENsYXNzcGF0aCh0aGlzLm1vcnBoKCJDOlxcamRrXFxydC5qYXI7QzpcXGpka1xcaTE4bi5qYXI7QzpcXGpka1xcamF3cy5qYXI7QzpcXGZvb1xcY2xhc3NlcztDOlxcYmFyXFxiYXIuamFyIikpLmVudHJ5Rm9yRmlsZU5hbWVkKCJydC5qYXIiKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMubW9ycGgoIkM6XFxqZGtcXHJ0LmphciIpLCBlbnRyeS5maWxlTmFtZSgpKTsKLQotCQkvLyBhdCB0aGUgYmVnaW5uaW5nIC0gdW5xdWFsaWZpZWQKLQkJZW50cnkgPSBuZXcgQ2xhc3NwYXRoKHRoaXMubW9ycGgoInJ0LmphcjtDOlxcamRrXFxpMThuLmphcjtDOlxcamRrXFxqYXdzLmphcjtDOlxcZm9vXFxjbGFzc2VzO0M6XFxiYXJcXGJhci5qYXIiKSkuZW50cnlGb3JGaWxlTmFtZWQoInJ0LmphciIpOwotCQlhc3NlcnRFcXVhbHMoInJ0LmphciIsIGVudHJ5LmZpbGVOYW1lKCkpOwotCi0JCS8vIGF0IHRoZSBlbmQgLSBxdWFsaWZpZWQKLQkJZW50cnkgPSBuZXcgQ2xhc3NwYXRoKHRoaXMubW9ycGgoIkM6XFxqZGtcXGkxOG4uamFyO0M6XFxqZGtcXGphd3MuamFyO0M6XFxmb29cXGNsYXNzZXM7QzpcXGJhclxcYmFyLmphcjtDOlxcamRrXFxydC5qYXIiKSkuZW50cnlGb3JGaWxlTmFtZWQoInJ0LmphciIpOwotCQlhc3NlcnRFcXVhbHModGhpcy5tb3JwaCgiQzpcXGpka1xccnQuamFyIiksIGVudHJ5LmZpbGVOYW1lKCkpOwotCi0JCS8vIGF0IHRoZSBlbmQgLSB1bnF1YWxpZmllZAotCQllbnRyeSA9IG5ldyBDbGFzc3BhdGgodGhpcy5tb3JwaCgiQzpcXGpka1xcaTE4bi5qYXI7QzpcXGpka1xcamF3cy5qYXI7QzpcXGZvb1xcY2xhc3NlcztDOlxcYmFyXFxiYXIuamFyO3J0LmphciIpKS5lbnRyeUZvckZpbGVOYW1lZCgicnQuamFyIik7Ci0JCWFzc2VydEVxdWFscygicnQuamFyIiwgZW50cnkuZmlsZU5hbWUoKSk7Ci0KLQkJLy8gYWxvbmUgLSBxdWFsaWZpZWQKLQkJZW50cnkgPSBuZXcgQ2xhc3NwYXRoKHRoaXMubW9ycGgoIkM6XFxqZGtcXHJ0LmphciIpKS5lbnRyeUZvckZpbGVOYW1lZCgicnQuamFyIik7Ci0JCWFzc2VydEVxdWFscyh0aGlzLm1vcnBoKCJDOlxcamRrXFxydC5qYXIiKSwgZW50cnkuZmlsZU5hbWUoKSk7Ci0KLQkJLy8gYWxvbmUgLSB1bnF1YWxpZmllZAotCQllbnRyeSA9IG5ldyBDbGFzc3BhdGgoInJ0LmphciIpLmVudHJ5Rm9yRmlsZU5hbWVkKCJydC5qYXIiKTsKLQkJYXNzZXJ0RXF1YWxzKCJydC5qYXIiLCBlbnRyeS5maWxlTmFtZSgpKTsKLQotCQkvLyB0cmljayBlbnRyeSBhdCB0aGUgYmVnaW5uaW5nCi0JCWVudHJ5ID0gbmV3IENsYXNzcGF0aCh0aGlzLm1vcnBoKCJydC5qYXIubmV3O0M6XFxqZGtcXHJ0LmphcjtDOlxcamRrXFxpMThuLmphcjtDOlxcamRrXFxqYXdzLmphcjtDOlxcZm9vXFxjbGFzc2VzO0M6XFxiYXJcXGJhci5qYXIiKSkuZW50cnlGb3JGaWxlTmFtZWQoInJ0LmphciIpOwotCQlhc3NlcnRFcXVhbHModGhpcy5tb3JwaCgiQzpcXGpka1xccnQuamFyIiksIGVudHJ5LmZpbGVOYW1lKCkpOwotCi0JCS8vIHRyaWNrIGVudHJ5IGluIHRoZSBtaWRkbGUKLQkJZW50cnkgPSBuZXcgQ2xhc3NwYXRoKHRoaXMubW9ycGgoInJ0Lmphci5uZXc7QzpcXGpka1xccnRydHJ0LmphcjtDOlxcamRrXFxydC5qYXI7QzpcXGpka1xcaTE4bi5qYXI7QzpcXGpka1xcamF3cy5qYXI7QzpcXGZvb1xcY2xhc3NlcztDOlxcYmFyXFxiYXIuamFyIikpLmVudHJ5Rm9yRmlsZU5hbWVkKCJydC5qYXIiKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMubW9ycGgoIkM6XFxqZGtcXHJ0LmphciIpLCBlbnRyeS5maWxlTmFtZSgpKTsKLQotCQkvLyB0cmljayBlbnRyeSBhdCB0aGUgZW5kCi0JCWVudHJ5ID0gbmV3IENsYXNzcGF0aCh0aGlzLm1vcnBoKCJydC5qYXIubmV3O0M6XFxqZGtcXHJ0cnRydC5qYXI7QzpcXGpka1xccnQuamFyO0M6XFxqZGtcXGkxOG4uamFyO0M6XFxqZGtcXGphd3MuamFyO0M6XFxmb29cXGNsYXNzZXM7QzpcXGJhclxcYmFyLmphcjtDOlxcamRrXFxydHJ0cnQuamFyIikpLmVudHJ5Rm9yRmlsZU5hbWVkKCJydC5qYXIiKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMubW9ycGgoIkM6XFxqZGtcXHJ0LmphciIpLCBlbnRyeS5maWxlTmFtZSgpKTsKLQotCQkvLyBtaXNzaW5nCi0JCWVudHJ5ID0gbmV3IENsYXNzcGF0aCh0aGlzLm1vcnBoKCJydC5qYXIubmV3O0M6XFxqZGtcXHJ0cnRydC5qYXI7QzpcXGpka1xcaTE4bi5qYXI7QzpcXGpka1xcamF3cy5qYXI7QzpcXGZvb1xcY2xhc3NlcztDOlxcYmFyXFxiYXIuamFyO0M6XFxqZGtcXHJ0cnRydC5qYXIiKSkuZW50cnlGb3JGaWxlTmFtZWQoInJ0LmphciIpOwotCQlhc3NlcnRFcXVhbHMoInBhdGggZW50cnkgc2hvdWxkIG5vdCBiZSBmb3VuZCIsIG51bGwsIGVudHJ5KTsKLQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMb2NhdGlvbkZvckNsYXNzKCkgewotCQlDbGFzczw/PiBqYXZhQ2xhc3MgPSBDbGFzc3BhdGguY2xhc3M7Ci0JCUZpbGUgZW50cnkgPSBuZXcgRmlsZShDbGFzc3BhdGgubG9jYXRpb25Gb3IoamF2YUNsYXNzKSk7Ci0JCWlmIChlbnRyeS5pc0ZpbGUoKSB8fCBlbnRyeS5pc0RpcmVjdG9yeSgpKSB7Ci0JCQlhc3NlcnRUcnVlKGVudHJ5LmV4aXN0cygpKTsKLQkJfQotCQlpZiAoZW50cnkuaXNEaXJlY3RvcnkoKSkgewotCQkJYXNzZXJ0VHJ1ZShuZXcgRmlsZShlbnRyeSwgQ2xhc3NwYXRoLmNvbnZlcnRUb0NsYXNzRmlsZU5hbWUoamF2YUNsYXNzKSkuZXhpc3RzKCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJ0SmFyTmFtZSgpIHRocm93cyBJT0V4Y2VwdGlvbiB7Ci0JCUZpbGUgcnRGaWxlID0gbmV3IEZpbGUoQ2xhc3NwYXRoLnJ0SmFyTmFtZSgpKTsKLQkJYXNzZXJ0VHJ1ZSgicnQuamFyIGRvZXMgbm90IGV4aXN0IiwgcnRGaWxlLmV4aXN0cygpKTsKLQotCQlKYXJGaWxlIHJ0SmFyRmlsZSA9IG5ldyBKYXJGaWxlKHJ0RmlsZSk7Ci0JCUphckVudHJ5IGVudHJ5ID0gcnRKYXJGaWxlLmdldEphckVudHJ5KCJqYXZhL2xhbmcvT2JqZWN0LmNsYXNzIik7Ci0JCXJ0SmFyRmlsZS5jbG9zZSgpOwotCQlhc3NlcnRUcnVlKCJib2d1cyBydC5qYXIiLCBlbnRyeSAhPSBudWxsKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SlJFQ2xhc3NOYW1lcygpIHsKLQkJYXNzZXJ0VHJ1ZSgiVmVjdG9yIGlzIG1pc3NpbmcgZnJvbSBKUkUgY2xhc3MgbmFtZXMiLCBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoQ2xhc3NwYXRoLmJvb3RDbGFzc3BhdGgoKS5jbGFzc05hbWVzKCksIGphdmEudXRpbC5WZWN0b3IuY2xhc3MuZ2V0TmFtZSgpKSk7Ci0JCWFzc2VydFRydWUoIkZpbGUgaXMgbWlzc2luZyBmcm9tIEpSRSBjbGFzcyBuYW1lcyIsIENvbGxlY3Rpb25Ub29scy5jb250YWlucyhDbGFzc3BhdGguYm9vdENsYXNzcGF0aCgpLmNsYXNzTmFtZXMoKSwgamF2YS5pby5GaWxlLmNsYXNzLmdldE5hbWUoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RKYXZhRXh0ZW5zaW9uRGlyZWN0b3J5TmFtZXMoKSB7Ci0JCWNoYXIgc2VwID0gRmlsZS5zZXBhcmF0b3JDaGFyOwotCQlTdHJpbmcgc3RkRXh0RGlyTmFtZSA9IEpBVkFfSE9NRSArIHNlcCArICJsaWIiICsgc2VwICsgImV4dCI7Ci0JCWFzc2VydFRydWUoInN0YW5kYXJkIGV4dGVuc2lvbiBkaXIgbmFtZSBtaXNzaW5nOiAiICsgc3RkRXh0RGlyTmFtZSwgQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKENsYXNzcGF0aC5qYXZhRXh0ZW5zaW9uRGlyZWN0b3J5TmFtZXMoKSwgc3RkRXh0RGlyTmFtZSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RKYXZhRXh0ZW5zaW9uRGlyZWN0b3JpZXMoKSB7Ci0JCWNoYXIgc2VwID0gRmlsZS5zZXBhcmF0b3JDaGFyOwotCQlGaWxlIHN0ZEV4dERpciA9IG5ldyBGaWxlKEpBVkFfSE9NRSArIHNlcCArICJsaWIiICsgc2VwICsgImV4dCIpOwotCQlhc3NlcnRUcnVlKCJzdGFuZGFyZCBleHRlbnNpb24gZGlyIG1pc3Npbmc6ICIgKyBzdGRFeHREaXIuZ2V0UGFyZW50KCksIENvbGxlY3Rpb25Ub29scy5jb250YWlucyhDbGFzc3BhdGguamF2YUV4dGVuc2lvbkRpcmVjdG9yaWVzKCksIHN0ZEV4dERpcikpOwotCX0KLQotCS8vQ29tbWVudGVkIG91dCBkdWUgdG8gaW5jb21wYXRpYmlsaXR5IHdpdGggSUJNIEpESyAodXNlZCBpbiBFY2xpcHNlIFdUUCBCdWlsZCkKLQkvL1RPRE8gVGVzdCBzaG91bGQgYmUgcmV2aXNlZCB0byBiZSBjb21wYXRpYmxlIHdpdGggSUJNIEpESwotCS8vCXB1YmxpYyB2b2lkIHRlc3RKYXZhRXh0ZW5zaW9uQ2xhc3NwYXRoRW50cmllcygpIHsKLQkvLwkJY2hhciBzZXAgPSBGaWxlLnNlcGFyYXRvckNoYXI7Ci0JLy8JCVN0cmluZyBqZGsgPSBTeXN0ZW0uZ2V0UHJvcGVydHkoImphdmEudmVyc2lvbiIpOwotCS8vCQlpZiAoamRrLnN0YXJ0c1dpdGgoIjEuNCIpIHx8IGpkay5zdGFydHNXaXRoKCIxLjUiKSkgewotCS8vCQkJQ29sbGVjdGlvbiBqYXJOYW1lcyA9IG5ldyBBcnJheUxpc3QoKTsKLQkvLwkJCUNsYXNzcGF0aC5FbnRyeVtdIGVudHJpZXMgPSBDbGFzc3BhdGguamF2YUV4dGVuc2lvbkNsYXNzcGF0aCgpLmdldEVudHJpZXMoKTsKLQkvLwkJCWZvciAoaW50IGkgPSAwOyBpIDwgZW50cmllcy5sZW5ndGg7IGkrKykgewotCS8vCQkJCWphck5hbWVzLmFkZChlbnRyaWVzW2ldLmZpbGVOYW1lKCkpOwotCS8vCQkJfQotCS8vCQkJU3RyaW5nIHN0ZEV4dEphck5hbWUgPSBKQVZBX0hPTUUgKyBzZXAgKyAibGliIiArIHNlcCArICJleHQiICsgc2VwICsgImRuc25zLmphciI7Ci0JLy8JCQlhc3NlcnRUcnVlKCJqZGsgMS40Lnggc3RhbmRhcmQgZXh0ZW5zaW9uIGphciBtaXNzaW5nOiAiICsgc3RkRXh0SmFyTmFtZSwgamFyTmFtZXMuY29udGFpbnMoc3RkRXh0SmFyTmFtZSkpOwotCS8vCQl9IGVsc2UgewotCS8vCQkJZmFpbCgid2UgbmVlZCB0byB1cGRhdGUgdGhpcyB0ZXN0IGZvciB0aGUgY3VycmVudCBqZGsiKTsKLQkvLwkJfQotCS8vCX0KLQotCS8vQ29tbWVudGVkIG91dCBkdWUgdG8gaW5jb21wYXRpYmlsaXR5IHdpdGggSUJNIEpESyAodXNlZCBpbiBFY2xpcHNlIFdUUCBCdWlsZCkKLQkvL1RPRE8gVGVzdCBzaG91bGQgYmUgcmV2aXNlZCB0byBiZSBjb21wYXRpYmxlIHdpdGggSUJNIEpESwotCS8vCXB1YmxpYyB2b2lkIHRlc3RKYXZhRXh0ZW5zaW9uQ2xhc3NOYW1lcygpIHsKLQkvLwkJU3RyaW5nIGpkayA9IFN5c3RlbS5nZXRQcm9wZXJ0eSgiamF2YS52ZXJzaW9uIik7Ci0JLy8JCWlmIChqZGsuc3RhcnRzV2l0aCgiMS40IikgfHwgamRrLnN0YXJ0c1dpdGgoIjEuNSIpKSB7Ci0JLy8JCQlTdHJpbmcgY2xhc3NOYW1lID0gInN1bi5uZXQuc3BpLm5hbWVzZXJ2aWNlLmRucy5ETlNOYW1lU2VydmljZSI7Ci0JLy8JCQlhc3NlcnRUcnVlKCJqZGsgMS40Lnggc3RhbmRhcmQgZXh0ZW5zaW9uIGNsYXNzIG1pc3Npbmc6ICIgKyBjbGFzc05hbWUsCi0JLy8JCQkJCUNvbGxlY3Rpb25Ub29scy5jb250YWlucyhDbGFzc3BhdGguamF2YUV4dGVuc2lvbkNsYXNzcGF0aCgpLmNsYXNzTmFtZXMoKSwgY2xhc3NOYW1lKSk7Ci0JLy8JCX0gZWxzZSB7Ci0JLy8JCQlmYWlsKCJ3ZSBuZWVkIHRvIHVwZGF0ZSB0aGlzIHRlc3QgZm9yIHRoZSBjdXJyZW50IGpkayIpOwotCS8vCQl9Ci0JLy8JfQotCi0JcHVibGljIHZvaWQgdGVzdEphdmFDbGFzc3BhdGhDbGFzc05hbWVzKCkgewotCQlTdHJpbmcgY2xhc3NOYW1lID0gdGhpcy5nZXRDbGFzcygpLmdldE5hbWUoKTsKLQkJQ2xhc3NMb2FkZXIgY2wgPSB0aGlzLmdldENsYXNzKCkuZ2V0Q2xhc3NMb2FkZXIoKTsKLQkJLy8gbWFrZSBzdXJlIHdlIGFyZSBydW5uaW5nIHVuZGVyIHRoZSAibm9ybWFsIiBjbGFzcyBsb2FkZXI7Ci0JCS8vIHdoZW4gdGhlIHRlc3RzIGFyZSBleGVjdXRlZCBhcyBhbiBBTlQgdGFzaywgdGhleSBhcmUgcnVuIHVuZGVyCi0JCS8vIGFuIEFOVCBjbGFzcyBsb2FkZXIgYW5kIHRoZSAiSmF2YSIgY2xhc3NwYXRoIGRvZXMgbm90IGluY2x1ZGUgdGhpcyBjbGFzcwotCQlpZiAoY2wuZ2V0Q2xhc3MoKS5nZXROYW1lKCkuc3RhcnRzV2l0aCgic3VuLm1pc2MiKSkgewotCQkJYXNzZXJ0VHJ1ZSgiY2xhc3MgbWlzc2luZzogIiArIGNsYXNzTmFtZSwgQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKENsYXNzcGF0aC5qYXZhQ2xhc3NwYXRoKCkuY2xhc3NOYW1lcygpLCBjbGFzc05hbWUpKTsKLQkJfQotCX0KLQotCS8qKgotCSAqIG1vcnBoIHRoZSBzcGVjaWZpZWQgcGF0aCB0byBhIHBsYXRmb3JtLWluZGVwZW5kZW50IHBhdGgKLQkgKi8KLQlwcml2YXRlIFN0cmluZyBtb3JwaChTdHJpbmcgcGF0aCkgewotCQlTdHJpbmcgcmVzdWx0ID0gcGF0aDsKLQkJcmVzdWx0ID0gcmVzdWx0LnJlcGxhY2UoJ1xcJywgRmlsZS5zZXBhcmF0b3JDaGFyKTsKLQkJcmVzdWx0ID0gcmVzdWx0LnJlcGxhY2UoJzsnLCBGaWxlLnBhdGhTZXBhcmF0b3JDaGFyKTsKLQkJaWYgKCFDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoRmlsZS5saXN0Um9vdHMoKSwgbmV3IEZpbGUoIkM6XFwiKSkpIHsKLQkJCXJlc3VsdCA9IHJlc3VsdC5yZXBsYWNlQWxsKCJDOiIsICIiKTsKLQkJfQotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCS8qKgotCSAqIG1vcnBoIHRoZSBzcGVjaWZpZWQgVVJMIHRvIGEgcGxhdGZvcm0taW5kZXBlbmRlbnQgcGF0aAotCSAqLwotCXByaXZhdGUgU3RyaW5nIG1vcnBoVVJMKFN0cmluZyB1cmwpIHsKLQkJU3RyaW5nIHJlc3VsdCA9IHVybDsKLQkJaWYgKCFDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoRmlsZS5saXN0Um9vdHMoKSwgbmV3IEZpbGUoIkM6XFwiKSkpIHsKLQkJCXJlc3VsdCA9IHJlc3VsdC5yZXBsYWNlQWxsKCIvQzoiLCAiIik7Ci0JCX0KLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvQ29sbGVjdGlvblRvb2xzVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvQ29sbGVjdGlvblRvb2xzVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMmYxMDE4NC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0NvbGxlY3Rpb25Ub29sc1Rlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzOTM2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5BcnJheXM7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb25zOwotaW1wb3J0IGphdmEudXRpbC5Db21wYXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5IYXNoU2V0OwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlua2VkTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5TZXQ7Ci1pbXBvcnQgamF2YS51dGlsLlNvcnRlZFNldDsKLWltcG9ydCBqYXZhLnV0aWwuVHJlZVNldDsKLWltcG9ydCBqYXZhLnV0aWwuVmVjdG9yOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5CYWc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkVtcHR5SXRlcmFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuSGFzaEJhZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5SYW5nZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5SZXZlcnNlQ29tcGFyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuQXJyYXlJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuRW1wdHlFbnVtZXJhdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuRW1wdHlJdGVyYXRvcjsKLQotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgY2xhc3MgQ29sbGVjdGlvblRvb2xzVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQlwdWJsaWMgQ29sbGVjdGlvblRvb2xzVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZE9iamVjdEFycmF5T2JqZWN0X09iamVjdCgpIHsKLQkJT2JqZWN0W10gYSA9IENvbGxlY3Rpb25Ub29scy5hZGQodGhpcy5idWlsZE9iamVjdEFycmF5MSgpLCAidHdlbnR5Iik7Ci0JCWFzc2VydEVxdWFscyg0LCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICJ0d2VudHkiKSk7Ci0JCWFzc2VydEVxdWFscygidHdlbnR5IiwgYVthLmxlbmd0aC0xXSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZE9iamVjdEFycmF5T2JqZWN0X1N0cmluZygpIHsKLQkJU3RyaW5nW10gYSA9IENvbGxlY3Rpb25Ub29scy5hZGQodGhpcy5idWlsZFN0cmluZ0FycmF5MSgpLCAidHdlbnR5Iik7Ci0JCWFzc2VydEVxdWFscyg0LCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICJ0d2VudHkiKSk7Ci0JCWFzc2VydEVxdWFscygidHdlbnR5IiwgYVthLmxlbmd0aC0xXSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZE9iamVjdEFycmF5T2JqZWN0X0VtcHR5QXJyYXkoKSB7Ci0JCVN0cmluZ1tdIGEgPSBuZXcgU3RyaW5nWzBdOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCAidHdlbnR5Iik7Ci0JCWFzc2VydEVxdWFscygxLCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICJ0d2VudHkiKSk7Ci0JCWFzc2VydEVxdWFscygidHdlbnR5IiwgYVswXSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZE9iamVjdEFycmF5SW50T2JqZWN0X09iamVjdCgpIHsKLQkJT2JqZWN0W10gYSA9IG5ldyBPYmplY3RbXSB7ICJhIiwgImIiLCAiYyIsICJkIiB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCAyLCAiWCIpOwotCQlhc3NlcnRFcXVhbHMoNSwgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAiWCIpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBPYmplY3RbXSB7ICJhIiwgImIiLCAiWCIsICJjIiwgImQiIH0sIGEpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkT2JqZWN0QXJyYXlJbnRPYmplY3RfU3RyaW5nKCkgewotCQlTdHJpbmdbXSBhID0gbmV3IFN0cmluZ1tdIHsgImEiLCAiYiIsICJjIiwgImQiIH07Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsIDIsICJYIik7Ci0JCWFzc2VydEVxdWFscyg1LCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICJYIikpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgImEiLCAiYiIsICJYIiwgImMiLCAiZCIgfSwgYSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRPYmplY3RBcnJheUludE9iamVjdF9FbmQoKSB7Ci0JCVN0cmluZ1tdIGEgPSBuZXcgU3RyaW5nW10geyAiYSIsICJiIiwgImMiLCAiZCIgfTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGQoYSwgNCwgIlgiKTsKLQkJYXNzZXJ0RXF1YWxzKDUsIGEubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgIlgiKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiYSIsICJiIiwgImMiLCAiZCIsICJYIiB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZE9iamVjdEFycmF5SW50T2JqZWN0X1plcm8oKSB7Ci0JCVN0cmluZ1tdIGEgPSBuZXcgU3RyaW5nW10geyAiYSIsICJiIiwgImMiLCAiZCIgfTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGQoYSwgMCwgIlgiKTsKLQkJYXNzZXJ0RXF1YWxzKDUsIGEubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgIlgiKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiWCIsICJhIiwgImIiLCAiYyIsICJkIiB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZE9iamVjdEFycmF5SW50T2JqZWN0X0V4Y2VwdGlvbigpIHsKLQkJT2JqZWN0W10gYSA9IG5ldyBPYmplY3RbXSB7ICJhIiwgImIiLCAiYyIsICJkIiB9OwotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCAzMywgIlgiKTsKLQkJfSBjYXRjaCAoSW5kZXhPdXRPZkJvdW5kc0V4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb25jYXRlbmF0ZU9iamVjdEFycmF5QXJyYXkoKSB7Ci0JCVN0cmluZ1tdIGFBcnJheSA9IG5ldyBTdHJpbmdbXSB7ICJhIiwgImIiLCAiYyIsICJkIiB9OwotCQlTdHJpbmdbXSBlQXJyYXkgPSBuZXcgU3RyaW5nW10geyAiZSIsICJmIiwgImciLCAiaCIgfTsKLQkJU3RyaW5nW10gaUFycmF5ID0gbmV3IFN0cmluZ1tdIHsgImkiLCAiaiIsICJrIiwgImwiIH07Ci0KLQkJU3RyaW5nW10gZXhwZWN0ZWQgPSBuZXcgU3RyaW5nW10geyAiYSIsICJiIiwgImMiLCAiZCIsICJlIiwgImYiLCAiZyIsICJoIiwgImkiLCAiaiIsICJrIiwgImwiIH07Ci0JCVN0cmluZ1tdIGFjdHVhbCA9IENvbGxlY3Rpb25Ub29scy5jb25jYXRlbmF0ZShhQXJyYXksIGVBcnJheSwgaUFycmF5KTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBhY3R1YWwpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQ2hhckFycmF5Q2hhcigpIHsKLQkJY2hhcltdIGEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKHRoaXMuYnVpbGRDaGFyQXJyYXkoKSwgJ2QnKTsKLQkJYXNzZXJ0RXF1YWxzKDQsIGEubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgJ2QnKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZENoYXJBcnJheUNoYXJfRW1wdHkoKSB7Ci0JCWNoYXJbXSBhID0gbmV3IGNoYXJbMF07Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsICdkJyk7Ci0JCWFzc2VydEVxdWFscygxLCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICdkJykpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGNoYXJbXSB7ICdkJyB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZENoYXJBcnJheUludENoYXIoKSB7Ci0JCWNoYXJbXSBhID0gbmV3IGNoYXJbXSB7ICdhJywgJ2InLCAnYycsICdkJyB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCAyLCAnWCcpOwotCQlhc3NlcnRFcXVhbHMoNSwgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAnWCcpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBjaGFyW10geyAnYScsICdiJywgJ1gnLCAnYycsICdkJyB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZENoYXJBcnJheUludENoYXJfWmVybygpIHsKLQkJY2hhcltdIGEgPSBuZXcgY2hhcltdIHsgJ2EnLCAnYicsICdjJywgJ2QnIH07Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsIDAsICdYJyk7Ci0JCWFzc2VydEVxdWFscyg1LCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICdYJykpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGNoYXJbXSB7ICdYJywgJ2EnLCAnYicsICdjJywgJ2QnIH0sIGEpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQ2hhckFycmF5SW50Q2hhcl9FbmQoKSB7Ci0JCWNoYXJbXSBhID0gbmV3IGNoYXJbXSB7ICdhJywgJ2InLCAnYycsICdkJyB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCA0LCAnWCcpOwotCQlhc3NlcnRFcXVhbHMoNSwgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAnWCcpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBjaGFyW10geyAnYScsICdiJywgJ2MnLCAnZCcsICdYJyB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbmNhdGVuYXRlQ2hhckFycmF5QXJyYXkoKSB7Ci0JCWNoYXJbXSBhQXJyYXkgPSBuZXcgY2hhcltdIHsgJ2EnLCAnYicsICdjJywgJ2QnIH07Ci0JCWNoYXJbXSBlQXJyYXkgPSBuZXcgY2hhcltdIHsgJ2UnLCAnZicsICdnJywgJ2gnIH07Ci0JCWNoYXJbXSBpQXJyYXkgPSBuZXcgY2hhcltdIHsgJ2knLCAnaicsICdrJywgJ2wnIH07Ci0KLQkJY2hhcltdIGV4cGVjdGVkID0gbmV3IGNoYXJbXSB7ICdhJywgJ2InLCAnYycsICdkJywgJ2UnLCAnZicsICdnJywgJ2gnLCAnaScsICdqJywgJ2snLCAnbCcgfTsKLQkJY2hhcltdIGFjdHVhbCA9IENvbGxlY3Rpb25Ub29scy5jb25jYXRlbmF0ZShhQXJyYXksIGVBcnJheSwgaUFycmF5KTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBhY3R1YWwpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkSW50QXJyYXlJbnQoKSB7Ci0JCWludFtdIGEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKHRoaXMuYnVpbGRJbnRBcnJheSgpLCAzMCk7Ci0JCWFzc2VydEVxdWFscyg0LCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsIDMwKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEludEFycmF5SW50X0VtcHR5KCkgewotCQlpbnRbXSBhID0gbmV3IGludFswXTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGQoYSwgMzApOwotCQlhc3NlcnRFcXVhbHMoMSwgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAzMCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGludFtdIHsgMzAgfSwgYSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRJbnRBcnJheUludEludCgpIHsKLQkJaW50W10gYSA9IG5ldyBpbnRbXSB7IDEsIDIsIDMsIDQgfTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGQoYSwgMiwgOTkpOwotCQlhc3NlcnRFcXVhbHMoNSwgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCA5OSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGludFtdIHsgMSwgMiwgOTksIDMsIDQgfSwgYSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRJbnRBcnJheUludEludF9aZXJvKCkgewotCQlpbnRbXSBhID0gbmV3IGludFtdIHsgMSwgMiwgMywgNCB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCAwLCA5OSk7Ci0JCWFzc2VydEVxdWFscyg1LCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsIDk5KSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgaW50W10geyA5OSwgMSwgMiwgMywgNCB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEludEFycmF5SW50SW50X0VuZCgpIHsKLQkJaW50W10gYSA9IG5ldyBpbnRbXSB7IDEsIDIsIDMsIDQgfTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGQoYSwgNCwgOTkpOwotCQlhc3NlcnRFcXVhbHMoNSwgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCA5OSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGludFtdIHsgMSwgMiwgMywgNCwgOTkgfSwgYSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb25jYXRlbmF0ZUludEFycmF5QXJyYXkoKSB7Ci0JCWludFtdIGFBcnJheSA9IG5ldyBpbnRbXSB7ICdhJywgJ2InLCAnYycsICdkJyB9OwotCQlpbnRbXSBlQXJyYXkgPSBuZXcgaW50W10geyAnZScsICdmJywgJ2cnLCAnaCcgfTsKLQkJaW50W10gaUFycmF5ID0gbmV3IGludFtdIHsgJ2knLCAnaicsICdrJywgJ2wnIH07Ci0KLQkJaW50W10gZXhwZWN0ZWQgPSBuZXcgaW50W10geyAnYScsICdiJywgJ2MnLCAnZCcsICdlJywgJ2YnLCAnZycsICdoJywgJ2knLCAnaicsICdrJywgJ2wnIH07Ci0JCWludFtdIGFjdHVhbCA9IENvbGxlY3Rpb25Ub29scy5jb25jYXRlbmF0ZShhQXJyYXksIGVBcnJheSwgaUFycmF5KTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBhY3R1YWwpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ29sbGVjdGlvbkl0ZXJhYmxlX1N0cmluZ01vZGlmaWVkKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdDEgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZTIgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGxpc3QxLCBpdGVyYWJsZTIuaXRlcmF0b3IoKSkpOwotCQlhc3NlcnRFcXVhbHMoNiwgbGlzdDEuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShsaXN0MS5jb250YWluc0FsbCh0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxDb2xsZWN0aW9uSXRlcmFibGVfU3RyaW5nVW5tb2RpZmllZCgpIHsKLQkJU2V0PFN0cmluZz4gc2V0MSA9IHRoaXMuYnVpbGRTdHJpbmdTZXQxKCk7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUzID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7IC8vIHNhbWUgZWxlbWVudHMgYXMgc2V0MQotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKHNldDEsIGl0ZXJhYmxlMy5pdGVyYXRvcigpKSk7Ci0JCWFzc2VydEVxdWFscygzLCBzZXQxLnNpemUoKSk7Ci0JCWFzc2VydFRydWUoc2V0MS5jb250YWluc0FsbCh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxDb2xsZWN0aW9uSXRlcmFibGVfT2JqZWN0TW9kaWZpZWQoKSB7Ci0JCUxpc3Q8T2JqZWN0PiBsaXN0MSA9IHRoaXMuYnVpbGRPYmplY3RMaXN0MSgpOwotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlMiA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MigpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5hZGRBbGwobGlzdDEsIGl0ZXJhYmxlMikpOwotCQlhc3NlcnRFcXVhbHMoNiwgbGlzdDEuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShsaXN0MS5jb250YWluc0FsbCgoTGlzdDxTdHJpbmc+KSBpdGVyYWJsZTIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ29sbGVjdGlvbkl0ZXJhYmxlX09iamVjdFVubW9kaWZpZWQoKSB7Ci0JCVNldDxPYmplY3Q+IHNldDEgPSB0aGlzLmJ1aWxkT2JqZWN0U2V0MSgpOwotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlMyA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOyAvLyBzYW1lIGVsZW1lbnRzIGFzIHNldDEKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmFkZEFsbChzZXQxLCBpdGVyYWJsZTMpKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIHNldDEuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShzZXQxLmNvbnRhaW5zQWxsKChMaXN0PFN0cmluZz4pIGl0ZXJhYmxlMykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxDb2xsZWN0aW9uSXRlcmFibGVfRW1wdHlJdGVyYWJsZSgpIHsKLQkJU2V0PE9iamVjdD4gc2V0MSA9IHRoaXMuYnVpbGRPYmplY3RTZXQxKCk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5hZGRBbGwoc2V0MSwgRW1wdHlJdGVyYWJsZS5pbnN0YW5jZSgpKSk7Ci0JCWFzc2VydEVxdWFscygzLCBzZXQxLnNpemUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbENvbGxlY3Rpb25JdGVyYWJsZUludF9Nb2RpZmllZCgpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QxID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0MiA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MigpOwotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlMiA9IGxpc3QyOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5hZGRBbGwobGlzdDEsIGl0ZXJhYmxlMi5pdGVyYXRvcigpLCBsaXN0Mi5zaXplKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIGxpc3QxLnNpemUoKSk7Ci0JCWFzc2VydFRydWUobGlzdDEuY29udGFpbnNBbGwodGhpcy5idWlsZFN0cmluZ0xpc3QyKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ29sbGVjdGlvbkl0ZXJhYmxlSW50X1VubW9kaWZpZWQoKSB7Ci0JCVNldDxTdHJpbmc+IHNldDEgPSB0aGlzLmJ1aWxkU3RyaW5nU2V0MSgpOwotCQlMaXN0PFN0cmluZz4gbGlzdDEgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsgLy8gc2FtZSBlbGVtZW50cyBhcyBzZXQxCi0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUzID0gbGlzdDE7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5hZGRBbGwoc2V0MSwgaXRlcmFibGUzLml0ZXJhdG9yKCksIGxpc3QxLnNpemUoKSkpOwotCQlhc3NlcnRFcXVhbHMoMywgc2V0MS5zaXplKCkpOwotCQlhc3NlcnRUcnVlKHNldDEuY29udGFpbnNBbGwodGhpcy5idWlsZFN0cmluZ0xpc3QxKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ29sbGVjdGlvbkl0ZXJhdG9yX1N0cmluZ01vZGlmaWVkKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdDEgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJTGlzdDxTdHJpbmc+IGxpc3QyID0gdGhpcy5idWlsZFN0cmluZ0xpc3QyKCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmFkZEFsbChsaXN0MSwgbGlzdDIuaXRlcmF0b3IoKSkpOwotCQlhc3NlcnRFcXVhbHMoNiwgbGlzdDEuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShsaXN0MS5jb250YWluc0FsbChsaXN0MikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxDb2xsZWN0aW9uSXRlcmF0b3JfU3RyaW5nVW5tb2RpZmllZCgpIHsKLQkJU2V0PFN0cmluZz4gc2V0MSA9IHRoaXMuYnVpbGRTdHJpbmdTZXQxKCk7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0MyA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOyAvLyBzYW1lIGVsZW1lbnRzIGFzIHMxCi0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5hZGRBbGwoc2V0MSwgbGlzdDMuaXRlcmF0b3IoKSkpOwotCQlhc3NlcnRFcXVhbHMoMywgc2V0MS5zaXplKCkpOwotCQlhc3NlcnRUcnVlKHNldDEuY29udGFpbnNBbGwobGlzdDMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ29sbGVjdGlvbkl0ZXJhdG9yX09iamVjdE1vZGlmaWVkKCkgewotCQlMaXN0PE9iamVjdD4gbGlzdDEgPSB0aGlzLmJ1aWxkT2JqZWN0TGlzdDEoKTsKLQkJTGlzdDxTdHJpbmc+IGxpc3QyID0gdGhpcy5idWlsZFN0cmluZ0xpc3QyKCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmFkZEFsbChsaXN0MSwgbGlzdDIuaXRlcmF0b3IoKSkpOwotCQlhc3NlcnRFcXVhbHMoNiwgbGlzdDEuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShsaXN0MS5jb250YWluc0FsbChsaXN0MikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxDb2xsZWN0aW9uSXRlcmF0b3JfT2JqZWN0VW5tb2RpZmllZCgpIHsKLQkJU2V0PE9iamVjdD4gc2V0MSA9IHRoaXMuYnVpbGRPYmplY3RTZXQxKCk7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0MyA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOyAvLyBzYW1lIGVsZW1lbnRzIGFzIHMxCi0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5hZGRBbGwoc2V0MSwgbGlzdDMuaXRlcmF0b3IoKSkpOwotCQlhc3NlcnRFcXVhbHMoMywgc2V0MS5zaXplKCkpOwotCQlhc3NlcnRUcnVlKHNldDEuY29udGFpbnNBbGwobGlzdDMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ29sbGVjdGlvbkl0ZXJhdG9yX0VtcHR5SXRlcmF0b3IoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0MSA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGxpc3QxLCBFbXB0eUl0ZXJhdG9yLjxTdHJpbmc+aW5zdGFuY2UoKSkpOwotCQlhc3NlcnRFcXVhbHMoMywgbGlzdDEuc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ29sbGVjdGlvbkl0ZXJhdG9ySW50X01vZGlmaWVkKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdDEgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJTGlzdDxTdHJpbmc+IGxpc3QyID0gdGhpcy5idWlsZFN0cmluZ0xpc3QyKCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmFkZEFsbChsaXN0MSwgbGlzdDIuaXRlcmF0b3IoKSwgMykpOwotCQlhc3NlcnRFcXVhbHMoNiwgbGlzdDEuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShsaXN0MS5jb250YWluc0FsbChsaXN0MikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxDb2xsZWN0aW9uSXRlcmF0b3JJbnRfVW5tb2RpZmllZCgpIHsKLQkJU2V0PFN0cmluZz4gc2V0MSA9IHRoaXMuYnVpbGRTdHJpbmdTZXQxKCk7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0MyA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOyAvLyBzYW1lIGVsZW1lbnRzIGFzIHMxCi0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5hZGRBbGwoc2V0MSwgbGlzdDMuaXRlcmF0b3IoKSwgMykpOwotCQlhc3NlcnRFcXVhbHMoMywgc2V0MS5zaXplKCkpOwotCQlhc3NlcnRUcnVlKHNldDEuY29udGFpbnNBbGwobGlzdDMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ29sbGVjdGlvbkl0ZXJhdG9ySW50X0VtcHR5SXRlcmF0b3IoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0MSA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGxpc3QxLCBFbXB0eUl0ZXJhdG9yLjxTdHJpbmc+aW5zdGFuY2UoKSwgMCkpOwotCQlhc3NlcnRFcXVhbHMoMywgbGlzdDEuc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ29sbGVjdGlvbk9iamVjdEFycmF5X1N0cmluZ01vZGlmaWVkKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlTdHJpbmdbXSBhID0gdGhpcy5idWlsZFN0cmluZ0FycmF5MSgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5hZGRBbGwobGlzdCwgYSkpOwotCQlhc3NlcnRFcXVhbHMoNiwgbGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKGxpc3QuY29udGFpbnNBbGwoQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24oYSkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ29sbGVjdGlvbk9iamVjdEFycmF5X1N0cmluZ0xpc3RFbXB0eUFycmF5KCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGxpc3QsIG5ldyBTdHJpbmdbMF0pKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ29sbGVjdGlvbk9iamVjdEFycmF5X1N0cmluZ1VubW9kaWZpZWQoKSB7Ci0JCVNldDxTdHJpbmc+IHNldCA9IHRoaXMuYnVpbGRTdHJpbmdTZXQxKCk7Ci0JCVN0cmluZ1tdIGEgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5hZGRBbGwoc2V0LCBhKSk7Ci0JCWFzc2VydEVxdWFscygzLCBzZXQuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShzZXQuY29udGFpbnNBbGwoQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24oYSkpKTsKLQotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKHNldCwgbmV3IFN0cmluZ1swXSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxDb2xsZWN0aW9uT2JqZWN0QXJyYXlfU3RyaW5nU2V0RW1wdHlBcnJheSgpIHsKLQkJU2V0PFN0cmluZz4gc2V0ID0gdGhpcy5idWlsZFN0cmluZ1NldDEoKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmFkZEFsbChzZXQsIG5ldyBTdHJpbmdbMF0pKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ29sbGVjdGlvbk9iamVjdEFycmF5X09iamVjdE1vZGlmaWVkKCkgewotCQlMaXN0PE9iamVjdD4gbGlzdCA9IHRoaXMuYnVpbGRPYmplY3RMaXN0MSgpOwotCQlTdHJpbmdbXSBhID0gdGhpcy5idWlsZFN0cmluZ0FycmF5MSgpOwotCi0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmFkZEFsbChsaXN0LCBhKSk7Ci0JCWFzc2VydEVxdWFscyg2LCBsaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUobGlzdC5jb250YWluc0FsbChDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbihhKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxDb2xsZWN0aW9uT2JqZWN0QXJyYXlfT2JqZWN0VW5tb2RpZmllZCgpIHsKLQkJU3RyaW5nW10gYSA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJU2V0PE9iamVjdD4gc2V0ID0gdGhpcy5idWlsZE9iamVjdFNldDEoKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmFkZEFsbChzZXQsIGEpKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIHNldC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKHNldC5jb250YWluc0FsbChDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbihhKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxMaXN0SW50T2JqZWN0QXJyYXkoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0ID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCUNvbGxlY3Rpb25Ub29scy5hZGRBbGwobGlzdCwgMiwgbmV3IFN0cmluZ1tdIHsgIlgiLCAiWCIsICJYIiB9KTsKLQkJYXNzZXJ0RXF1YWxzKDYsIGxpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShsaXN0LmNvbnRhaW5zKCJYIikpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IE9iamVjdFtdIHsgInplcm8iLCAib25lIiwgIlgiLCAiWCIsICJYIiwgInR3byIgfSwgbGlzdC50b0FycmF5KCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsTGlzdEludE9iamVjdEFycmF5X1plcm8oKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0ID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCUNvbGxlY3Rpb25Ub29scy5hZGRBbGwobGlzdCwgMCwgbmV3IFN0cmluZ1tdIHsgIlgiLCAiWCIsICJYIiB9KTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGxpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShsaXN0LmNvbnRhaW5zKCJYIikpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IE9iamVjdFtdIHsgIlgiLCAiWCIsICJYIiB9LCBsaXN0LnRvQXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxMaXN0SW50T2JqZWN0QXJyYXlfRW1wdHlBcnJheSgpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJQ29sbGVjdGlvblRvb2xzLmFkZEFsbChsaXN0LCAyLCBuZXcgU3RyaW5nWzBdKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGxpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBPYmplY3RbXSB7ICJ6ZXJvIiwgIm9uZSIsICJ0d28iIH0sIGxpc3QudG9BcnJheSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbExpc3RJbnRJdGVyYWJsZSgpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgIlgiLCAiWCIsICJYIiB9KTsKLQkJQ29sbGVjdGlvblRvb2xzLmFkZEFsbChsaXN0LCAyLCBpdGVyYWJsZSk7Ci0JCWFzc2VydEVxdWFscyg2LCBsaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUobGlzdC5jb250YWlucygiWCIpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBPYmplY3RbXSB7ICJ6ZXJvIiwgIm9uZSIsICJYIiwgIlgiLCAiWCIsICJ0d28iIH0sIGxpc3QudG9BcnJheSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbExpc3RJbnRJdGVyYWJsZV9aZXJvKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlID0gQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAiWCIsICJYIiwgIlgiIH0pOwotCQlDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGxpc3QsIDAsIGl0ZXJhYmxlKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGxpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShsaXN0LmNvbnRhaW5zKCJYIikpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IE9iamVjdFtdIHsgIlgiLCAiWCIsICJYIiB9LCBsaXN0LnRvQXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxMaXN0SW50SXRlcmFibGVfRW1wdHlJdGVyYWJsZSgpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IEVtcHR5SXRlcmFibGUuaW5zdGFuY2UoKTsKLQkJQ29sbGVjdGlvblRvb2xzLmFkZEFsbChsaXN0LCAyLCBpdGVyYWJsZSk7Ci0JCWFzc2VydEVxdWFscygzLCBsaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgT2JqZWN0W10geyAiemVybyIsICJvbmUiLCAidHdvIiB9LCBsaXN0LnRvQXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxMaXN0SW50SXRlcmFibGVJbnQoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0ID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSBBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJYIiwgIlgiLCAiWCIgfSk7Ci0JCUNvbGxlY3Rpb25Ub29scy5hZGRBbGwobGlzdCwgMiwgaXRlcmFibGUsIDMpOwotCQlhc3NlcnRFcXVhbHMoNiwgbGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKGxpc3QuY29udGFpbnMoIlgiKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgT2JqZWN0W10geyAiemVybyIsICJvbmUiLCAiWCIsICJYIiwgIlgiLCAidHdvIiB9LCBsaXN0LnRvQXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxMaXN0SW50SXRlcmFibGVJbnRfWmVybygpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgIlgiLCAiWCIsICJYIiB9KTsKLQkJQ29sbGVjdGlvblRvb2xzLmFkZEFsbChsaXN0LCAwLCBpdGVyYWJsZSwgMyk7Ci0JCWFzc2VydEVxdWFscygzLCBsaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUobGlzdC5jb250YWlucygiWCIpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBPYmplY3RbXSB7ICJYIiwgIlgiLCAiWCIgfSwgbGlzdC50b0FycmF5KCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsTGlzdEludEl0ZXJhYmxlSW50X0VtcHR5SXRlcmFibGUoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0ID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSBFbXB0eUl0ZXJhYmxlLmluc3RhbmNlKCk7Ci0JCUNvbGxlY3Rpb25Ub29scy5hZGRBbGwobGlzdCwgMiwgaXRlcmFibGUsIDApOwotCQlhc3NlcnRFcXVhbHMoMywgbGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IE9iamVjdFtdIHsgInplcm8iLCAib25lIiwgInR3byIgfSwgbGlzdC50b0FycmF5KCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsTGlzdEludEl0ZXJhdG9yKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlJdGVyYXRvcjxTdHJpbmc+IGl0ZXJhdG9yID0gQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAiWCIsICJYIiwgIlgiIH0pLml0ZXJhdG9yKCk7Ci0JCUNvbGxlY3Rpb25Ub29scy5hZGRBbGwobGlzdCwgMiwgaXRlcmF0b3IpOwotCQlhc3NlcnRFcXVhbHMoNiwgbGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKGxpc3QuY29udGFpbnMoIlgiKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgT2JqZWN0W10geyAiemVybyIsICJvbmUiLCAiWCIsICJYIiwgIlgiLCAidHdvIiB9LCBsaXN0LnRvQXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxMaXN0SW50SXRlcmF0b3JfWmVybygpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgIlgiLCAiWCIsICJYIiB9KS5pdGVyYXRvcigpOwotCQlDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGxpc3QsIDAsIGl0ZXJhdG9yKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGxpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShsaXN0LmNvbnRhaW5zKCJYIikpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IE9iamVjdFtdIHsgIlgiLCAiWCIsICJYIiB9LCBsaXN0LnRvQXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxMaXN0SW50SXRlcmF0b3JfRW1wdHlJdGVyYXRvcigpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQkJQ29sbGVjdGlvblRvb2xzLmFkZEFsbChsaXN0LCAyLCBpdGVyYXRvcik7Ci0JCWFzc2VydEVxdWFscygzLCBsaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgT2JqZWN0W10geyAiemVybyIsICJvbmUiLCAidHdvIiB9LCBsaXN0LnRvQXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxMaXN0SW50SXRlcmF0b3JJbnQoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0ID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IgPSBBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJYIiwgIlgiLCAiWCIgfSkuaXRlcmF0b3IoKTsKLQkJQ29sbGVjdGlvblRvb2xzLmFkZEFsbChsaXN0LCAyLCBpdGVyYXRvciwgMyk7Ci0JCWFzc2VydEVxdWFscyg2LCBsaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUobGlzdC5jb250YWlucygiWCIpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBPYmplY3RbXSB7ICJ6ZXJvIiwgIm9uZSIsICJYIiwgIlgiLCAiWCIsICJ0d28iIH0sIGxpc3QudG9BcnJheSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbExpc3RJbnRJdGVyYXRvckludF9aZXJvKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlJdGVyYXRvcjxTdHJpbmc+IGl0ZXJhdG9yID0gQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAiWCIsICJYIiwgIlgiIH0pLml0ZXJhdG9yKCk7Ci0JCUNvbGxlY3Rpb25Ub29scy5hZGRBbGwobGlzdCwgMCwgaXRlcmF0b3IsIDMpOwotCQlhc3NlcnRFcXVhbHMoMywgbGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKGxpc3QuY29udGFpbnMoIlgiKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgT2JqZWN0W10geyAiWCIsICJYIiwgIlgiIH0sIGxpc3QudG9BcnJheSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbExpc3RJbnRJdGVyYXRvckludF9FbXB0eUl0ZXJhdG9yKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlJdGVyYXRvcjxTdHJpbmc+IGl0ZXJhdG9yID0gRW1wdHlJdGVyYXRvci5pbnN0YW5jZSgpOwotCQlDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGxpc3QsIDIsIGl0ZXJhdG9yLCAwKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGxpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBPYmplY3RbXSB7ICJ6ZXJvIiwgIm9uZSIsICJ0d28iIH0sIGxpc3QudG9BcnJheSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5Q29sbGVjdGlvbl9TdHJpbmcoKSB7Ci0JCVN0cmluZ1tdIGEgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCk7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gdGhpcy5idWlsZFN0cmluZ0xpc3QyKCk7Ci0JCVN0cmluZ1tdIG5ld0FycmF5ID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCBjKTsKLQotCQlhc3NlcnRFcXVhbHMoNiwgbmV3QXJyYXkubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwobmV3QXJyYXksIGMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsT2JqZWN0QXJyYXlDb2xsZWN0aW9uX09iamVjdCgpIHsKLQkJT2JqZWN0W10gYSA9IHRoaXMuYnVpbGRPYmplY3RBcnJheTEoKTsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKTsKLQkJT2JqZWN0W10gbmV3QXJyYXkgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIGMpOwotCi0JCWFzc2VydEVxdWFscyg2LCBuZXdBcnJheS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChuZXdBcnJheSwgYykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUNvbGxlY3Rpb25fRW1wdHlBcnJheSgpIHsKLQkJU3RyaW5nW10gYSA9IG5ldyBTdHJpbmdbMF07Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gdGhpcy5idWlsZFN0cmluZ0xpc3QyKCk7Ci0JCVN0cmluZ1tdIG5ld0FycmF5ID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCBjKTsKLQotCQlhc3NlcnRFcXVhbHMoMywgbmV3QXJyYXkubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwobmV3QXJyYXksIGMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsT2JqZWN0QXJyYXlDb2xsZWN0aW9uX0VtcHR5Q29sbGVjdGlvbigpIHsKLQkJU3RyaW5nW10gYSA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJU3RyaW5nW10gbmV3QXJyYXkgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIGMpOwotCi0JCWFzc2VydEVxdWFscygzLCBuZXdBcnJheS5sZW5ndGgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUludENvbGxlY3Rpb25fU3RyaW5nKCkgewotCQlTdHJpbmdbXSBhID0gdGhpcy5idWlsZFN0cmluZ0FycmF5MSgpOwotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MigpOwotCQlTdHJpbmdbXSBuZXdBcnJheSA9IENvbGxlY3Rpb25Ub29scy5hZGRBbGwoYSwgMSwgYyk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDYsIG5ld0FycmF5Lmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKG5ld0FycmF5LCBjKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5SW50Q29sbGVjdGlvbl9FbXB0eUFycmF5KCkgewotCQlTdHJpbmdbXSBhID0gbmV3IFN0cmluZ1swXTsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKTsKLQkJU3RyaW5nW10gbmV3QXJyYXkgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIDAsIGMpOwotCi0JCWFzc2VydEVxdWFscygzLCBuZXdBcnJheS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChuZXdBcnJheSwgYykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUludENvbGxlY3Rpb25fRW1wdHlDb2xsZWN0aW9uKCkgewotCQlTdHJpbmdbXSBhID0gdGhpcy5idWlsZFN0cmluZ0FycmF5MSgpOwotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlTdHJpbmdbXSBuZXdBcnJheSA9IENvbGxlY3Rpb25Ub29scy5hZGRBbGwoYSwgMSwgYyk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDMsIG5ld0FycmF5Lmxlbmd0aCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5SW50SXRlcmFibGVfU3RyaW5nKCkgewotCQlTdHJpbmdbXSBhID0gdGhpcy5idWlsZFN0cmluZ0FycmF5MSgpOwotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlID0gdGhpcy5idWlsZFN0cmluZ0xpc3QyKCk7Ci0JCVN0cmluZ1tdIG5ld0FycmF5ID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCAxLCBpdGVyYWJsZSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDYsIG5ld0FycmF5Lmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKG5ld0FycmF5LCBpdGVyYWJsZSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUludEl0ZXJhYmxlX0VtcHR5QXJyYXkoKSB7Ci0JCVN0cmluZ1tdIGEgPSBuZXcgU3RyaW5nWzBdOwotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlID0gdGhpcy5idWlsZFN0cmluZ0xpc3QyKCk7Ci0JCVN0cmluZ1tdIG5ld0FycmF5ID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCAwLCBpdGVyYWJsZSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDMsIG5ld0FycmF5Lmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKG5ld0FycmF5LCBpdGVyYWJsZSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUludEl0ZXJhYmxlX0VtcHR5SXRlcmFibGUoKSB7Ci0JCVN0cmluZ1tdIGEgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCk7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJU3RyaW5nW10gbmV3QXJyYXkgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIDEsIGl0ZXJhYmxlKTsKLQotCQlhc3NlcnRFcXVhbHMoMywgbmV3QXJyYXkubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsT2JqZWN0QXJyYXlJbnRJdGVyYWJsZUludF9TdHJpbmcoKSB7Ci0JCVN0cmluZ1tdIGEgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCk7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKTsKLQkJU3RyaW5nW10gbmV3QXJyYXkgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIDEsIGl0ZXJhYmxlLCAzKTsKLQotCQlhc3NlcnRFcXVhbHMoNiwgbmV3QXJyYXkubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwobmV3QXJyYXksIGl0ZXJhYmxlKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5SW50SXRlcmFibGVJbnRfRW1wdHlBcnJheSgpIHsKLQkJU3RyaW5nW10gYSA9IG5ldyBTdHJpbmdbMF07Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKTsKLQkJU3RyaW5nW10gbmV3QXJyYXkgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIDAsIGl0ZXJhYmxlLCAzKTsKLQotCQlhc3NlcnRFcXVhbHMoMywgbmV3QXJyYXkubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwobmV3QXJyYXksIGl0ZXJhYmxlKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5SW50SXRlcmFibGVJbnRfRW1wdHlJdGVyYWJsZSgpIHsKLQkJU3RyaW5nW10gYSA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlTdHJpbmdbXSBuZXdBcnJheSA9IENvbGxlY3Rpb25Ub29scy5hZGRBbGwoYSwgMSwgaXRlcmFibGUsIDApOwotCi0JCWFzc2VydEVxdWFscygzLCBuZXdBcnJheS5sZW5ndGgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUludEl0ZXJhdG9yX1N0cmluZygpIHsKLQkJU3RyaW5nW10gYSA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MigpLml0ZXJhdG9yKCk7Ci0JCVN0cmluZ1tdIG5ld0FycmF5ID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCAxLCBpdGVyYXRvcik7Ci0KLQkJYXNzZXJ0RXF1YWxzKDYsIG5ld0FycmF5Lmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKG5ld0FycmF5LCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUludEl0ZXJhdG9yX0VtcHR5QXJyYXkoKSB7Ci0JCVN0cmluZ1tdIGEgPSBuZXcgU3RyaW5nWzBdOwotCQlJdGVyYXRvcjxTdHJpbmc+IGl0ZXJhdG9yID0gdGhpcy5idWlsZFN0cmluZ0xpc3QyKCkuaXRlcmF0b3IoKTsKLQkJU3RyaW5nW10gbmV3QXJyYXkgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIDAsIGl0ZXJhdG9yKTsKLQotCQlhc3NlcnRFcXVhbHMoMywgbmV3QXJyYXkubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwobmV3QXJyYXksIHRoaXMuYnVpbGRTdHJpbmdMaXN0MigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5SW50SXRlcmF0b3JfRW1wdHlJdGVyYWJsZSgpIHsKLQkJU3RyaW5nW10gYSA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQkJU3RyaW5nW10gbmV3QXJyYXkgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIDEsIGl0ZXJhdG9yKTsKLQotCQlhc3NlcnRFcXVhbHMoMywgbmV3QXJyYXkubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsT2JqZWN0QXJyYXlJbnRJdGVyYXRvckludF9TdHJpbmcoKSB7Ci0JCVN0cmluZ1tdIGEgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCk7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKS5pdGVyYXRvcigpOwotCQlTdHJpbmdbXSBuZXdBcnJheSA9IENvbGxlY3Rpb25Ub29scy5hZGRBbGwoYSwgMSwgaXRlcmF0b3IsIDMpOwotCi0JCWFzc2VydEVxdWFscyg2LCBuZXdBcnJheS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChuZXdBcnJheSwgdGhpcy5idWlsZFN0cmluZ0xpc3QyKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsT2JqZWN0QXJyYXlJbnRJdGVyYXRvckludF9FbXB0eUFycmF5KCkgewotCQlTdHJpbmdbXSBhID0gbmV3IFN0cmluZ1swXTsKLQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MigpLml0ZXJhdG9yKCk7Ci0JCVN0cmluZ1tdIG5ld0FycmF5ID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCAwLCBpdGVyYXRvciwgMyk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDMsIG5ld0FycmF5Lmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKG5ld0FycmF5LCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUludEl0ZXJhdG9ySW50X0VtcHR5SXRlcmF0b3IoKSB7Ci0JCVN0cmluZ1tdIGEgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCk7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IgPSBFbXB0eUl0ZXJhdG9yLmluc3RhbmNlKCk7Ci0JCVN0cmluZ1tdIG5ld0FycmF5ID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCAxLCBpdGVyYXRvciwgMCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDMsIG5ld0FycmF5Lmxlbmd0aCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5SXRlcmFibGUoKSB7Ci0JCVN0cmluZ1tdIGEgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCk7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJU3RyaW5nW10gbmV3QXJyYXkgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIGl0ZXJhYmxlKTsKLQotCQlhc3NlcnRFcXVhbHMoNiwgbmV3QXJyYXkubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwobmV3QXJyYXksIHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5SXRlcmFibGVJbnQoKSB7Ci0JCVN0cmluZ1tdIGEgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCk7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJU3RyaW5nW10gbmV3QXJyYXkgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIGl0ZXJhYmxlLCAzMyk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDYsIG5ld0FycmF5Lmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKG5ld0FycmF5LCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUl0ZXJhdG9yX1N0cmluZygpIHsKLQkJU3RyaW5nW10gYSA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCk7Ci0JCVN0cmluZ1tdIG5ld0FycmF5ID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCBpdGVyYXRvcik7Ci0KLQkJYXNzZXJ0RXF1YWxzKDYsIG5ld0FycmF5Lmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKG5ld0FycmF5LCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUl0ZXJhdG9yX09iamVjdCgpIHsKLQkJU3RyaW5nW10gYSA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJSXRlcmF0b3I8T2JqZWN0PiBpdGVyYXRvciA9IHRoaXMuYnVpbGRPYmplY3RMaXN0MSgpLml0ZXJhdG9yKCk7Ci0JCU9iamVjdFtdIG5ld0FycmF5ID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCBpdGVyYXRvcik7Ci0KLQkJYXNzZXJ0RXF1YWxzKDYsIG5ld0FycmF5Lmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKG5ld0FycmF5LCB0aGlzLmJ1aWxkT2JqZWN0TGlzdDEoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUl0ZXJhdG9yX0VtcHR5SXRlcmF0b3IoKSB7Ci0JCVN0cmluZ1tdIGEgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCk7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IgPSBFbXB0eUl0ZXJhdG9yLmluc3RhbmNlKCk7Ci0JCVN0cmluZ1tdIG5ld0FycmF5ID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCBpdGVyYXRvcik7Ci0KLQkJYXNzZXJ0RXF1YWxzKDMsIG5ld0FycmF5Lmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKG5ld0FycmF5LCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUl0ZXJhdG9ySW50KCkgewotCQlTdHJpbmdbXSBhID0gdGhpcy5idWlsZFN0cmluZ0FycmF5MSgpOwotCQlJdGVyYXRvcjxPYmplY3Q+IGl0ZXJhdG9yID0gdGhpcy5idWlsZE9iamVjdExpc3QxKCkuaXRlcmF0b3IoKTsKLQkJT2JqZWN0W10gbmV3QXJyYXkgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIGl0ZXJhdG9yLCAzKTsKLQotCQlhc3NlcnRFcXVhbHMoNiwgbmV3QXJyYXkubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwobmV3QXJyYXksIHRoaXMuYnVpbGRPYmplY3RMaXN0MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5SXRlcmF0b3JJbnRfRW1wdHlJdGVyYXRvcigpIHsKLQkJU3RyaW5nW10gYSA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQkJU3RyaW5nW10gbmV3QXJyYXkgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIGl0ZXJhdG9yLCAwKTsKLQotCQlhc3NlcnRFcXVhbHMoMywgbmV3QXJyYXkubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwobmV3QXJyYXksIHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5T2JqZWN0QXJyYXlfT2JqZWN0KCkgewotCQlPYmplY3RbXSBhMSA9IHRoaXMuYnVpbGRPYmplY3RBcnJheTEoKTsKLQkJT2JqZWN0W10gYTIgPSB0aGlzLmJ1aWxkT2JqZWN0QXJyYXkyKCk7Ci0JCU9iamVjdFtdIG5ld0FycmF5ID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhMSwgYTIpOwotCi0JCWFzc2VydEVxdWFscyg2LCBuZXdBcnJheS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChuZXdBcnJheSwgYTEpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwobmV3QXJyYXksIGEyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5T2JqZWN0QXJyYXlfU3RyaW5nKCkgewotCQlTdHJpbmdbXSBhMSA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJU3RyaW5nW10gYTIgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkyKCk7Ci0JCVN0cmluZ1tdIG5ld0FycmF5ID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhMSwgYTIpOwotCi0JCWFzc2VydEVxdWFscyg2LCBuZXdBcnJheS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChuZXdBcnJheSwgYTEpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwobmV3QXJyYXksIGEyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5T2JqZWN0QXJyYXlfT2JqZWN0U3RyaW5nKCkgewotCQlPYmplY3RbXSBhMSA9IHRoaXMuYnVpbGRPYmplY3RBcnJheTEoKTsKLQkJU3RyaW5nW10gYTIgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkyKCk7Ci0JCU9iamVjdFtdIG5ld0FycmF5ID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhMSwgYTIpOwotCi0JCWFzc2VydEVxdWFscyg2LCBuZXdBcnJheS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChuZXdBcnJheSwgYTEpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwobmV3QXJyYXksIGEyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5T2JqZWN0QXJyYXlfRW1wdHlBcnJheTEoKSB7Ci0JCU9iamVjdFtdIGExID0gbmV3IE9iamVjdFswXTsKLQkJT2JqZWN0W10gYTIgPSB0aGlzLmJ1aWxkT2JqZWN0QXJyYXkyKCk7Ci0JCU9iamVjdFtdIG5ld0FycmF5ID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhMSwgYTIpOwotCi0JCWFzc2VydEVxdWFscygzLCBuZXdBcnJheS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChuZXdBcnJheSwgYTIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsT2JqZWN0QXJyYXlPYmplY3RBcnJheV9FbXB0eUFycmF5MigpIHsKLQkJT2JqZWN0W10gYTEgPSB0aGlzLmJ1aWxkT2JqZWN0QXJyYXkxKCk7Ci0JCU9iamVjdFtdIGEyID0gbmV3IE9iamVjdFswXTsKLQkJT2JqZWN0W10gbmV3QXJyYXkgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGExLCBhMik7Ci0KLQkJYXNzZXJ0RXF1YWxzKDMsIG5ld0FycmF5Lmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKG5ld0FycmF5LCBhMSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUludE9iamVjdEFycmF5X09iamVjdCgpIHsKLQkJT2JqZWN0W10gYSA9IG5ldyBPYmplY3RbXSB7ICJhIiwgImIiLCAiYyIsICJkIiB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCAyLCBuZXcgT2JqZWN0W10geyAiWCIsICJYIiwgIlgiIH0pOwotCQlhc3NlcnRFcXVhbHMoNywgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAiWCIpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBPYmplY3RbXSB7ICJhIiwgImIiLCAiWCIsICJYIiwgIlgiLCAiYyIsICJkIiB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5SW50T2JqZWN0QXJyYXlfU3RyaW5nKCkgewotCQlTdHJpbmdbXSBhID0gbmV3IFN0cmluZ1tdIHsgImEiLCAiYiIsICJjIiwgImQiIH07Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIDIsIG5ldyBTdHJpbmdbXSB7ICJYIiwgIlgiLCAiWCIgfSk7Ci0JCWFzc2VydEVxdWFscyg3LCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICJYIikpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgImEiLCAiYiIsICJYIiwgIlgiLCAiWCIsICJjIiwgImQiIH0sIGEpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsT2JqZWN0QXJyYXlJbnRPYmplY3RBcnJheV9PYmplY3RTdHJpbmcoKSB7Ci0JCU9iamVjdFtdIGEgPSBuZXcgT2JqZWN0W10geyAiYSIsICJiIiwgImMiLCAiZCIgfTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGRBbGwoYSwgMiwgbmV3IFN0cmluZ1tdIHsgIlgiLCAiWCIsICJYIiB9KTsKLQkJYXNzZXJ0RXF1YWxzKDcsIGEubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgIlgiKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgT2JqZWN0W10geyAiYSIsICJiIiwgIlgiLCAiWCIsICJYIiwgImMiLCAiZCIgfSwgYSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUludE9iamVjdEFycmF5X0VuZCgpIHsKLQkJT2JqZWN0W10gYSA9IG5ldyBPYmplY3RbXSB7ICJhIiwgImIiLCAiYyIsICJkIiB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCA0LCBuZXcgU3RyaW5nW10geyAiWCIsICJYIiwgIlgiIH0pOwotCQlhc3NlcnRFcXVhbHMoNywgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAiWCIpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBPYmplY3RbXSB7ICJhIiwgImIiLCAiYyIsICJkIiwgIlgiLCAiWCIsICJYIiB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5SW50T2JqZWN0QXJyYXlfWmVybygpIHsKLQkJT2JqZWN0W10gYSA9IG5ldyBPYmplY3RbMF07Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIDAsIG5ldyBTdHJpbmdbXSB7ICJYIiwgIlgiLCAiWCIgfSk7Ci0JCWFzc2VydEVxdWFscygzLCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICJYIikpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IE9iamVjdFtdIHsgIlgiLCAiWCIsICJYIiB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbE9iamVjdEFycmF5SW50T2JqZWN0QXJyYXlfRW1wdHlBcnJheTIoKSB7Ci0JCU9iamVjdFtdIGEgPSBuZXcgT2JqZWN0W10geyAiYSIsICJiIiwgImMiLCAiZCIgfTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGRBbGwoYSwgNCwgbmV3IFN0cmluZ1swXSk7Ci0JCWFzc2VydEVxdWFscyg0LCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgT2JqZWN0W10geyAiYSIsICJiIiwgImMiLCAiZCIgfSwgYSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxPYmplY3RBcnJheUludE9iamVjdEFycmF5X0VtcHR5QXJyYXkxKCkgewotCQlPYmplY3RbXSBhID0gbmV3IFN0cmluZ1swXTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGRBbGwoYSwgMCwgbmV3IE9iamVjdFtdIHsgImEiLCAiYiIsICJjIiwgImQiIH0pOwotCQlhc3NlcnRFcXVhbHMoNCwgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IE9iamVjdFtdIHsgImEiLCAiYiIsICJjIiwgImQiIH0sIGEpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ2hhckFycmF5Q2hhckFycmF5KCkgewotCQljaGFyW10gYSA9IENvbGxlY3Rpb25Ub29scy5hZGRBbGwodGhpcy5idWlsZENoYXJBcnJheSgpLCBuZXcgY2hhcltdIHsgJ2QnLCAnZScgfSk7Ci0JCWFzc2VydEVxdWFscyg1LCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICdkJykpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAnZScpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ2hhckFycmF5Q2hhckFycmF5X0VtcHR5QXJyYXkyKCkgewotCQljaGFyW10gYSA9IENvbGxlY3Rpb25Ub29scy5hZGRBbGwodGhpcy5idWlsZENoYXJBcnJheSgpLCBuZXcgY2hhclswXSk7Ci0JCWFzc2VydEVxdWFscygzLCBhLmxlbmd0aCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbENoYXJBcnJheUNoYXJBcnJheUVtcHR5QXJyYXkxKCkgewotCQljaGFyW10gYSA9IENvbGxlY3Rpb25Ub29scy5hZGRBbGwobmV3IGNoYXJbMF0sIG5ldyBjaGFyW10geyAnZCcsICdlJyB9KTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGEubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgJ2QnKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICdlJykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxDaGFyQXJyYXlJbnRDaGFyQXJyYXkoKSB7Ci0JCWNoYXJbXSBhID0gbmV3IGNoYXJbXSB7ICdhJywgJ2InLCAnYycsICdkJyB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCAyLCBuZXcgY2hhcltdIHsgJ1gnLCAnWCcsICdYJyB9KTsKLQkJYXNzZXJ0RXF1YWxzKDcsIGEubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgJ1gnKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgY2hhcltdIHsgJ2EnLCAnYicsICdYJywgJ1gnLCAnWCcsICdjJywgJ2QnIH0sIGEpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ2hhckFycmF5SW50Q2hhckFycmF5X0VuZCgpIHsKLQkJY2hhcltdIGEgPSBuZXcgY2hhcltdIHsgJ2EnLCAnYicsICdjJywgJ2QnIH07Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIDQsIG5ldyBjaGFyW10geyAnWCcsICdYJywgJ1gnIH0pOwotCQlhc3NlcnRFcXVhbHMoNywgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAnWCcpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBjaGFyW10geyAnYScsICdiJywgJ2MnLCAnZCcsICdYJywgJ1gnLCAnWCcgfSwgYSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxDaGFyQXJyYXlJbnRDaGFyQXJyYXlfRW1wdHlBcnJheTEoKSB7Ci0JCWNoYXJbXSBhID0gbmV3IGNoYXJbMF07Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIDAsIG5ldyBjaGFyW10geyAnWCcsICdYJywgJ1gnIH0pOwotCQlhc3NlcnRFcXVhbHMoMywgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAnWCcpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBjaGFyW10geyAnWCcsICdYJywgJ1gnIH0sIGEpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsQ2hhckFycmF5SW50Q2hhckFycmF5X0VtcHR5QXJyYXkyKCkgewotCQljaGFyW10gYSA9IG5ldyBjaGFyW10geyAnYScsICdiJywgJ2MnLCAnZCcgfTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGRBbGwoYSwgMiwgbmV3IGNoYXJbMF0pOwotCQlhc3NlcnRFcXVhbHMoNCwgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGNoYXJbXSB7ICdhJywgJ2InLCAnYycsICdkJyB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbEludEFycmF5SW50QXJyYXkoKSB7Ci0JCWludFtdIGEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKHRoaXMuYnVpbGRJbnRBcnJheSgpLCBuZXcgaW50W10geyAzMCwgNDAgfSk7Ci0JCWFzc2VydEVxdWFscyg1LCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsIDMwKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsIDQwKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbEludEFycmF5SW50QXJyYXlfRW1wdHlBcnJheTIoKSB7Ci0JCWludFtdIGEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKHRoaXMuYnVpbGRJbnRBcnJheSgpLCBuZXcgaW50WzBdKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGEubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsSW50QXJyYXlJbnRBcnJheV9FbXB0eUFycmF5MSgpIHsKLQkJaW50W10gYSA9IENvbGxlY3Rpb25Ub29scy5hZGRBbGwobmV3IGludFswXSwgbmV3IGludFtdIHsgMzAsIDQwIH0pOwotCQlhc3NlcnRFcXVhbHMoMiwgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAzMCkpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCA0MCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGxJbnRBcnJheUludEludEFycmF5KCkgewotCQlpbnRbXSBhID0gbmV3IGludFtdIHsgMSwgMiwgMywgNCB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCAyLCBuZXcgaW50W10geyA5OSwgOTksIDk5IH0pOwotCQlhc3NlcnRFcXVhbHMoNywgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCA5OSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGludFtdIHsgMSwgMiwgOTksIDk5LCA5OSwgMywgNCB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbEludEFycmF5SW50SW50QXJyYXlfRW5kKCkgewotCQlpbnRbXSBhID0gbmV3IGludFtdIHsgMSwgMiwgMywgNCB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCA0LCBuZXcgaW50W10geyA5OSwgOTksIDk5IH0pOwotCQlhc3NlcnRFcXVhbHMoNywgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCA5OSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGludFtdIHsgMSwgMiwgMywgNCwgOTksIDk5LCA5OSB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbEludEFycmF5SW50SW50QXJyYXlfRW1wdHlBcnJheTIoKSB7Ci0JCWludFtdIGEgPSBuZXcgaW50W10geyAxLCAyLCAzLCA0IH07Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGEsIDIsIG5ldyBpbnRbMF0pOwotCQlhc3NlcnRFcXVhbHMoNCwgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGludFtdIHsgMSwgMiwgMywgNCB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbEludEFycmF5SW50SW50QXJyYXlfRW1wdHlBcnJheTEoKSB7Ci0JCWludFtdIGEgPSBuZXcgaW50WzBdOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZEFsbChhLCAwLCBuZXcgaW50W10geyA5OSwgOTksIDk5IH0pOwotCQlhc3NlcnRFcXVhbHMoMywgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCA5OSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGludFtdIHsgOTksIDk5LCA5OSB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFycmF5SXRlcmFibGUoKSB7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJT2JqZWN0W10gYSA9IENvbGxlY3Rpb25Ub29scy5hcnJheShpdGVyYWJsZSk7Ci0JCWFzc2VydEVxdWFscygzLCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKGEsIHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QXJyYXlJdGVyYWJsZUludCgpIHsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlPYmplY3RbXSBhID0gQ29sbGVjdGlvblRvb2xzLmFycmF5KGl0ZXJhYmxlLCAzKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGEubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwoYSwgdGhpcy5idWlsZFN0cmluZ0xpc3QxKCkuaXRlcmF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBcnJheUl0ZXJhYmxlT2JqZWN0QXJyYXlfU3RyaW5nKCkgewotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCVN0cmluZ1tdIGEgPSBDb2xsZWN0aW9uVG9vbHMuYXJyYXkoaXRlcmFibGUsIG5ldyBTdHJpbmdbMF0pOwotCQlhc3NlcnRFcXVhbHMoMywgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChhLCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFycmF5SXRlcmFibGVPYmplY3RBcnJheV9PYmplY3QoKSB7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJT2JqZWN0W10gYSA9IENvbGxlY3Rpb25Ub29scy5hcnJheShpdGVyYWJsZSwgbmV3IE9iamVjdFswXSk7Ci0JCWFzc2VydEVxdWFscygzLCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKGEsIHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QXJyYXlJdGVyYWJsZUludE9iamVjdEFycmF5KCkgewotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCVN0cmluZ1tdIGEgPSBDb2xsZWN0aW9uVG9vbHMuYXJyYXkoaXRlcmFibGUsIDMsIG5ldyBTdHJpbmdbMF0pOwotCQlhc3NlcnRFcXVhbHMoMywgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChhLCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFycmF5SXRlcmF0b3IoKSB7Ci0JCU9iamVjdFtdIGEgPSBDb2xsZWN0aW9uVG9vbHMuYXJyYXkodGhpcy5idWlsZFN0cmluZ0xpc3QxKCkuaXRlcmF0b3IoKSk7Ci0JCWFzc2VydEVxdWFscygzLCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKGEsIHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QXJyYXlJdGVyYXRvcl9FbXB0eSgpIHsKLQkJT2JqZWN0W10gYSA9IENvbGxlY3Rpb25Ub29scy5hcnJheShFbXB0eUl0ZXJhdG9yLmluc3RhbmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgYS5sZW5ndGgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBcnJheUl0ZXJhdG9ySW50KCkgewotCQlPYmplY3RbXSBhID0gQ29sbGVjdGlvblRvb2xzLmFycmF5KHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCksIDMpOwotCQlhc3NlcnRFcXVhbHMoMywgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChhLCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFycmF5SXRlcmF0b3JJbnRfRW1wdHkoKSB7Ci0JCU9iamVjdFtdIGEgPSBDb2xsZWN0aW9uVG9vbHMuYXJyYXkoRW1wdHlJdGVyYXRvci5pbnN0YW5jZSgpLCAzKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGEubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QXJyYXlJdGVyYXRvck9iamVjdEFycmF5X1N0cmluZygpIHsKLQkJU3RyaW5nW10gYSA9IENvbGxlY3Rpb25Ub29scy5hcnJheSh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpLCBuZXcgU3RyaW5nWzBdKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGEubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwoYSwgdGhpcy5idWlsZFN0cmluZ0xpc3QxKCkuaXRlcmF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBcnJheUl0ZXJhdG9yT2JqZWN0QXJyYXlfRW1wdHkoKSB7Ci0JCVN0cmluZ1tdIGEgPSBDb2xsZWN0aW9uVG9vbHMuYXJyYXkoRW1wdHlJdGVyYXRvci48U3RyaW5nPmluc3RhbmNlKCksIG5ldyBTdHJpbmdbMF0pOwotCQlhc3NlcnRFcXVhbHMoMCwgYS5sZW5ndGgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBcnJheUl0ZXJhdG9yT2JqZWN0QXJyYXlfT2JqZWN0KCkgewotCQlPYmplY3RbXSBhID0gQ29sbGVjdGlvblRvb2xzLmFycmF5KHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCksIG5ldyBPYmplY3RbMF0pOwotCQlhc3NlcnRFcXVhbHMoMywgYS5sZW5ndGgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChhLCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFycmF5SXRlcmF0b3JJbnRPYmplY3RBcnJheSgpIHsKLQkJU3RyaW5nW10gYSA9IENvbGxlY3Rpb25Ub29scy5hcnJheSh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpLCAzLCBuZXcgU3RyaW5nWzBdKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGEubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwoYSwgdGhpcy5idWlsZFN0cmluZ0xpc3QxKCkuaXRlcmF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBcnJheUl0ZXJhdG9ySW50T2JqZWN0QXJyYXlfRW1wdHkoKSB7Ci0JCVN0cmluZ1tdIGEgPSBDb2xsZWN0aW9uVG9vbHMuYXJyYXkoRW1wdHlJdGVyYXRvci48U3RyaW5nPmluc3RhbmNlKCksIDMsIG5ldyBTdHJpbmdbMF0pOwotCQlhc3NlcnRFcXVhbHMoMCwgYS5sZW5ndGgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RCYWdFbnVtZXJhdGlvbl9TdHJpbmcoKSB7Ci0JCUJhZzxTdHJpbmc+IGIgPSBDb2xsZWN0aW9uVG9vbHMuYmFnKHRoaXMuYnVpbGRTdHJpbmdWZWN0b3IxKCkuZWxlbWVudHMoKSk7Ci0JCWFzc2VydEVxdWFscygzLCBiLnNpemUoKSk7Ci0JCWFzc2VydFRydWUoYi5jb250YWluc0FsbCh0aGlzLmJ1aWxkU3RyaW5nVmVjdG9yMSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEJhZ0VudW1lcmF0aW9uX09iamVjdCgpIHsKLQkJQmFnPE9iamVjdD4gYiA9IENvbGxlY3Rpb25Ub29scy48T2JqZWN0PmJhZyh0aGlzLmJ1aWxkU3RyaW5nVmVjdG9yMSgpLmVsZW1lbnRzKCkpOwotCQlhc3NlcnRFcXVhbHMoMywgYi5zaXplKCkpOwotCQlhc3NlcnRUcnVlKGIuY29udGFpbnNBbGwodGhpcy5idWlsZFN0cmluZ1ZlY3RvcjEoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RCYWdFbnVtZXJhdGlvbl9FbXB0eSgpIHsKLQkJQmFnPE9iamVjdD4gYiA9IENvbGxlY3Rpb25Ub29scy48T2JqZWN0PmJhZyhFbXB0eUVudW1lcmF0aW9uLmluc3RhbmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgYi5zaXplKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RCYWdFbnVtZXJhdGlvbkludCgpIHsKLQkJQmFnPFN0cmluZz4gYiA9IENvbGxlY3Rpb25Ub29scy5iYWcodGhpcy5idWlsZFN0cmluZ1ZlY3RvcjEoKS5lbGVtZW50cygpLCAzKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGIuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShiLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdWZWN0b3IxKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QmFnRW51bWVyYXRpb25JbnRfRW1wdHkoKSB7Ci0JCUJhZzxTdHJpbmc+IGIgPSBDb2xsZWN0aW9uVG9vbHMuYmFnKEVtcHR5RW51bWVyYXRpb24uPFN0cmluZz5pbnN0YW5jZSgpLCAzKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGIuc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QmFnSXRlcmFibGUoKSB7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJQmFnPFN0cmluZz4gYiA9IENvbGxlY3Rpb25Ub29scy5iYWcoaXRlcmFibGUpOwotCQlhc3NlcnRFcXVhbHMoMywgYi5zaXplKCkpOwotCQlhc3NlcnRUcnVlKGIuY29udGFpbnNBbGwodGhpcy5idWlsZFN0cmluZ0xpc3QxKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QmFnSXRlcmFibGVJbnQoKSB7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJQmFnPFN0cmluZz4gYiA9IENvbGxlY3Rpb25Ub29scy5iYWcoaXRlcmFibGUsIDMpOwotCQlhc3NlcnRFcXVhbHMoMywgYi5zaXplKCkpOwotCQlhc3NlcnRUcnVlKGIuY29udGFpbnNBbGwodGhpcy5idWlsZFN0cmluZ0xpc3QxKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QmFnSXRlcmF0b3JfU3RyaW5nKCkgewotCQlCYWc8U3RyaW5nPiBiID0gQ29sbGVjdGlvblRvb2xzLmJhZyh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGIuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShiLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEJhZ0l0ZXJhdG9yX1N0cmluZ09iamVjdCgpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJYy5hZGQoInplcm8iKTsKLQkJYy5hZGQoIm9uZSIpOwotCQljLmFkZCgidHdvIik7Ci0JCWMuYWRkKCJ0aHJlZSIpOwotCQlCYWc8T2JqZWN0PiBiID0gQ29sbGVjdGlvblRvb2xzLjxPYmplY3Q+YmFnKGMuaXRlcmF0b3IoKSk7Ci0JCWFzc2VydEVxdWFscyg0LCBiLnNpemUoKSk7Ci0JCWFzc2VydFRydWUoYi5jb250YWluc0FsbChjKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEJhZ0l0ZXJhdG9yX0VtcHR5KCkgewotCQlCYWc8U3RyaW5nPiBiID0gQ29sbGVjdGlvblRvb2xzLmJhZyhFbXB0eUl0ZXJhdG9yLjxTdHJpbmc+aW5zdGFuY2UoKSk7Ci0JCWFzc2VydEVxdWFscygwLCBiLnNpemUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEJhZ0l0ZXJhdG9ySW50KCkgewotCQlCYWc8U3RyaW5nPiBiID0gQ29sbGVjdGlvblRvb2xzLmJhZyh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpLCAzKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGIuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShiLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEJhZ0l0ZXJhdG9ySW50X0VtcHR5KCkgewotCQlCYWc8U3RyaW5nPiBiID0gQ29sbGVjdGlvblRvb2xzLmJhZyhFbXB0eUl0ZXJhdG9yLjxTdHJpbmc+aW5zdGFuY2UoKSwgMyk7Ci0JCWFzc2VydEVxdWFscygwLCBiLnNpemUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEJhZ09iamVjdEFycmF5KCkgewotCQlCYWc8U3RyaW5nPiBiID0gQ29sbGVjdGlvblRvb2xzLmJhZyh0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCkpOwotCQlhc3NlcnRFcXVhbHMoMywgYi5zaXplKCkpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChiLCB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QmFnT2JqZWN0QXJyYXlfVmFyYXJnKCkgewotCQlCYWc8U3RyaW5nPiBiID0gQ29sbGVjdGlvblRvb2xzLmJhZygiZm9vIiwgImJhciIsICJiYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGIuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwoYiwgbmV3IE9iamVjdFtdeyJmb28iLCAiYmFyIiwgImJheiJ9KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEJhZ09iamVjdEFycmF5X0VtcHR5KCkgewotCQlCYWc8U3RyaW5nPiBiID0gQ29sbGVjdGlvblRvb2xzLmJhZyhCYWcuRW1wdHkuPFN0cmluZz5pbnN0YW5jZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGIuc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2xlYXJPYmplY3RBcnJheSgpIHsKLQkJU3RyaW5nW10gYSA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGEubGVuZ3RoKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5jbGVhcihhKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGEubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2xlYXJPYmplY3RBcnJheV9FbXB0eSgpIHsKLQkJU3RyaW5nW10gYSA9IG5ldyBTdHJpbmdbMF07Ci0JCWFzc2VydEVxdWFscygwLCBhLmxlbmd0aCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuY2xlYXIoYSk7Ci0JCWFzc2VydEVxdWFscygwLCBhLmxlbmd0aCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25FbnVtZXJhdGlvbigpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbih0aGlzLmJ1aWxkU3RyaW5nVmVjdG9yMSgpLmVsZW1lbnRzKCkpOwotCQlhc3NlcnRFcXVhbHMoMywgYy5zaXplKCkpOwotCQlhc3NlcnRUcnVlKGMuY29udGFpbnNBbGwodGhpcy5idWlsZFN0cmluZ1ZlY3RvcjEoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb2xsZWN0aW9uRW51bWVyYXRpb25fT2JqZWN0U3RyaW5nKCkgewotCQlDb2xsZWN0aW9uPE9iamVjdD4gYyA9IENvbGxlY3Rpb25Ub29scy48T2JqZWN0PmNvbGxlY3Rpb24odGhpcy5idWlsZFN0cmluZ1ZlY3RvcjEoKS5lbGVtZW50cygpKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShjLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdWZWN0b3IxKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29sbGVjdGlvbkVudW1lcmF0aW9uSW50KCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IENvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKHRoaXMuYnVpbGRTdHJpbmdWZWN0b3IxKCkuZWxlbWVudHMoKSwgMyk7Ci0JCWFzc2VydEVxdWFscygzLCBjLnNpemUoKSk7Ci0JCWFzc2VydFRydWUoYy5jb250YWluc0FsbCh0aGlzLmJ1aWxkU3RyaW5nVmVjdG9yMSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25JdGVyYWJsZSgpIHsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IENvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKGl0ZXJhYmxlKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShjLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25JdGVyYWJsZUludCgpIHsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IENvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKGl0ZXJhYmxlLCAzKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShjLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25JdGVyYXRvcigpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbih0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShjLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25JdGVyYXRvcl9PYmplY3RTdHJpbmcoKSB7Ci0JCUNvbGxlY3Rpb248T2JqZWN0PiBjID0gQ29sbGVjdGlvblRvb2xzLjxPYmplY3Q+Y29sbGVjdGlvbih0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShjLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25JdGVyYXRvckludCgpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbih0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpLCAzKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShjLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25PYmplY3RBcnJheSgpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbih0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCkpOwotCQlhc3NlcnRFcXVhbHMoMywgYy5zaXplKCkpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChjLCB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNFbnVtZXJhdGlvbk9iamVjdF9TdHJpbmcoKSB7Ci0JCVZlY3RvcjxTdHJpbmc+IHYgPSB0aGlzLmJ1aWxkU3RyaW5nVmVjdG9yMSgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyh2LmVsZW1lbnRzKCksICJvbmUiKSk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyh2LmVsZW1lbnRzKCksIG51bGwpKTsKLQkJdi5hZGQobnVsbCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHYuZWxlbWVudHMoKSwgbnVsbCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb250YWluc0VudW1lcmF0aW9uT2JqZWN0X09iamVjdCgpIHsKLQkJVmVjdG9yPE9iamVjdD4gYyA9IG5ldyBWZWN0b3I8T2JqZWN0PigpOwotCQljLmFkZCgiemVybyIpOwotCQljLmFkZCgib25lIik7Ci0JCWMuYWRkKCJ0d28iKTsKLQkJYy5hZGQoInRocmVlIik7Ci0JCVN0cmluZyBvbmUgPSAib25lIjsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYy5lbGVtZW50cygpLCBvbmUpKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGMuZWxlbWVudHMoKSwgbnVsbCkpOwotCQljLmFkZChudWxsKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYy5lbGVtZW50cygpLCBudWxsKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zSXRlcmFibGVPYmplY3QoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSBjOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhpdGVyYWJsZSwgIm9uZSIpKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGl0ZXJhYmxlLCBudWxsKSk7Ci0JCWMuYWRkKG51bGwpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhpdGVyYWJsZSwgbnVsbCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb250YWluc0l0ZXJhdG9yT2JqZWN0X1N0cmluZygpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYy5pdGVyYXRvcigpLCAib25lIikpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYy5pdGVyYXRvcigpLCBudWxsKSk7Ci0JCWMuYWRkKG51bGwpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhjLml0ZXJhdG9yKCksIG51bGwpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNJdGVyYXRvck9iamVjdF9PYmplY3QoKSB7Ci0JCUNvbGxlY3Rpb248T2JqZWN0PiBjID0gbmV3IEhhc2hCYWc8T2JqZWN0PigpOwotCQljLmFkZCgiemVybyIpOwotCQljLmFkZCgib25lIik7Ci0JCWMuYWRkKCJ0d28iKTsKLQkJYy5hZGQoInRocmVlIik7Ci0JCVN0cmluZyBvbmUgPSAib25lIjsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYy5pdGVyYXRvcigpLCBvbmUpKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGMuaXRlcmF0b3IoKSwgbnVsbCkpOwotCQljLmFkZChudWxsKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYy5pdGVyYXRvcigpLCBudWxsKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zT2JqZWN0QXJyYXlPYmplY3QoKSB7Ci0JCU9iamVjdFtdIGEgPSB0aGlzLmJ1aWxkT2JqZWN0QXJyYXkxKCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICJvbmUiKSk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCBudWxsKSk7Ci0JCU9iamVjdFtdIGEyID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCBudWxsKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYTIsIG51bGwpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNDaGFyQXJyYXlDaGFyKCkgewotCQljaGFyW10gYSA9IHRoaXMuYnVpbGRDaGFyQXJyYXkoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgJ2EnKSk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAneicpKTsKLQkJY2hhcltdIGEyID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCAneicpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhMiwgJ3onKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zSW50QXJyYXlJbnQoKSB7Ci0JCWludFtdIGEgPSB0aGlzLmJ1aWxkSW50QXJyYXkoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgMTApKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsIDU1KSk7Ci0JCWludFtdIGEyID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCA1NSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEyLCA1NSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb250YWluc0FsbENvbGxlY3Rpb25JdGVyYWJsZSgpIHsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbCh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKSwgaXRlcmFibGUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNBbGxDb2xsZWN0aW9uSXRlcmF0b3JfU3RyaW5nKCkgewotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbCh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKSwgdGhpcy5idWlsZFN0cmluZ0xpc3QxKCkuaXRlcmF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb250YWluc0FsbENvbGxlY3Rpb25JdGVyYXRvcl9PYmplY3QoKSB7Ci0JCUNvbGxlY3Rpb248T2JqZWN0PiBjMSA9IG5ldyBBcnJheUxpc3Q8T2JqZWN0PigpOwotCQljMS5hZGQoInplcm8iKTsKLQkJYzEuYWRkKCJvbmUiKTsKLQkJYzEuYWRkKCJ0d28iKTsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMyID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWMyLmFkZCgidHdvIik7Ci0JCWMyLmFkZCgiemVybyIpOwotCQljMi5hZGQoIm9uZSIpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChjMSwgYzIuaXRlcmF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb250YWluc0FsbENvbGxlY3Rpb25PYmplY3RBcnJheV9TdHJpbmdPYmplY3QoKSB7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLCB0aGlzLmJ1aWxkT2JqZWN0QXJyYXkxKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNBbGxDb2xsZWN0aW9uT2JqZWN0QXJyYXkoKSB7Ci0JCU9iamVjdFtdIGEgPSBuZXcgT2JqZWN0W10geyAiemVybyIsICJvbmUiLCAidHdvIiB9OwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbCh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKSwgYSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb250YWluc0FsbEl0ZXJhYmxlQ29sbGVjdGlvbigpIHsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChpdGVyYWJsZSwgdGhpcy5idWlsZFN0cmluZ0xpc3QxKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNBbGxJdGVyYWJsZUludENvbGxlY3Rpb24oKSB7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwoaXRlcmFibGUsIDMsIHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zQWxsSXRlcmFibGVJdGVyYWJsZSgpIHsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZTEgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZTIgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwoaXRlcmFibGUxLCBpdGVyYWJsZTIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNBbGxJdGVyYWJsZUludEl0ZXJhYmxlKCkgewotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlMSA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlMiA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChpdGVyYWJsZTEsIDMsIGl0ZXJhYmxlMikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb250YWluc0FsbEl0ZXJhYmxlSXRlcmF0b3IoKSB7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwoaXRlcmFibGUsIHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNBbGxJdGVyYWJsZUludEl0ZXJhdG9yKCkgewotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKGl0ZXJhYmxlLCAzLCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zQWxsSXRlcmFibGVPYmplY3RBcnJheSgpIHsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChpdGVyYWJsZSwgdGhpcy5idWlsZE9iamVjdEFycmF5MSgpKSk7Ci0JCWl0ZXJhYmxlID0gdGhpcy5idWlsZFN0cmluZ0xpc3QyKCk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChpdGVyYWJsZSwgdGhpcy5idWlsZE9iamVjdEFycmF5MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zQWxsSXRlcmFibGVJbnRPYmplY3RBcnJheSgpIHsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChpdGVyYWJsZSwgMywgdGhpcy5idWlsZE9iamVjdEFycmF5MSgpKSk7Ci0JCWl0ZXJhYmxlID0gdGhpcy5idWlsZFN0cmluZ0xpc3QyKCk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbChpdGVyYWJsZSwgMywgdGhpcy5idWlsZE9iamVjdEFycmF5MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zQWxsSXRlcmF0b3JDb2xsZWN0aW9uX1N0cmluZ1N0cmluZygpIHsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwodGhpcy5idWlsZFN0cmluZ0xpc3QxKCkuaXRlcmF0b3IoKSwgdGhpcy5idWlsZFN0cmluZ0xpc3QxKCkpKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCksIHRoaXMuYnVpbGRTdHJpbmdMaXN0MigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zQWxsSXRlcmF0b3JDb2xsZWN0aW9uX09iamVjdFN0cmluZygpIHsKLQkJQ29sbGVjdGlvbjxPYmplY3Q+IGMxID0gbmV3IEFycmF5TGlzdDxPYmplY3Q+KCk7Ci0JCWMxLmFkZCgiemVybyIpOwotCQljMS5hZGQoIm9uZSIpOwotCQljMS5hZGQoInR3byIpOwotCQlDb2xsZWN0aW9uPFN0cmluZz4gYzIgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJYzIuYWRkKCJ6ZXJvIik7Ci0JCWMyLmFkZCgib25lIik7Ci0JCWMyLmFkZCgidHdvIik7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKGMxLml0ZXJhdG9yKCksIGMyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zQWxsSXRlcmF0b3JJbnRDb2xsZWN0aW9uKCkgewotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbCh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpLCA1LCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKSkpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwodGhpcy5idWlsZFN0cmluZ0xpc3QxKCkuaXRlcmF0b3IoKSwgNSwgdGhpcy5idWlsZFN0cmluZ0xpc3QyKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNBbGxJdGVyYXRvckl0ZXJhYmxlKCkgewotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCksIGl0ZXJhYmxlKSk7Ci0JCWl0ZXJhYmxlID0gdGhpcy5idWlsZFN0cmluZ0xpc3QyKCk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbCh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpLCBpdGVyYWJsZSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb250YWluc0FsbEl0ZXJhdG9ySW50SXRlcmFibGUoKSB7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwodGhpcy5idWlsZFN0cmluZ0xpc3QxKCkuaXRlcmF0b3IoKSwgMywgaXRlcmFibGUpKTsKLQkJaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCksIDMsIGl0ZXJhYmxlKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zQWxsSXRlcmF0b3JJdGVyYXRvcl9TdHJpbmdTdHJpbmcoKSB7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCksIHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCksIHRoaXMuYnVpbGRTdHJpbmdMaXN0MigpLml0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNBbGxJdGVyYXRvckl0ZXJhdG9yX09iamVjdFN0cmluZygpIHsKLQkJQ29sbGVjdGlvbjxPYmplY3Q+IGMxID0gbmV3IEFycmF5TGlzdDxPYmplY3Q+KCk7Ci0JCWMxLmFkZCgiemVybyIpOwotCQljMS5hZGQoIm9uZSIpOwotCQljMS5hZGQoInR3byIpOwotCQlDb2xsZWN0aW9uPFN0cmluZz4gYzIgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJYzIuYWRkKCJ6ZXJvIik7Ci0JCWMyLmFkZCgib25lIik7Ci0JCWMyLmFkZCgidHdvIik7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKGMxLml0ZXJhdG9yKCksIGMyLml0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNBbGxJdGVyYXRvckludEl0ZXJhdG9yKCkgewotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbCh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpLCAzLCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpKSk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbCh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpLCAzLCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKS5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zQWxsSXRlcmF0b3JPYmplY3RBcnJheSgpIHsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwodGhpcy5idWlsZFN0cmluZ0xpc3QxKCkuaXRlcmF0b3IoKSwgdGhpcy5idWlsZE9iamVjdEFycmF5MSgpKSk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbCh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpLCB0aGlzLmJ1aWxkT2JqZWN0QXJyYXkyKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNBbGxJdGVyYXRvckludE9iamVjdEFycmF5KCkgewotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbCh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpLCAzLCB0aGlzLmJ1aWxkT2JqZWN0QXJyYXkxKCkpKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCksIDMsIHRoaXMuYnVpbGRPYmplY3RBcnJheTIoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb250YWluc0FsbE9iamVjdEFycmF5Q29sbGVjdGlvbigpIHsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwodGhpcy5idWlsZE9iamVjdEFycmF5MSgpLCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKSkpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwodGhpcy5idWlsZE9iamVjdEFycmF5MSgpLCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb250YWluc0FsbE9iamVjdEFycmF5SXRlcmFibGUoKSB7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwodGhpcy5idWlsZE9iamVjdEFycmF5MSgpLCBpdGVyYWJsZSkpOwotCQlpdGVyYWJsZSA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MigpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwodGhpcy5idWlsZE9iamVjdEFycmF5MSgpLCBpdGVyYWJsZSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb250YWluc0FsbE9iamVjdEFycmF5SXRlcmF0b3IoKSB7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRPYmplY3RBcnJheTEoKSwgdGhpcy5idWlsZFN0cmluZ0xpc3QxKCkuaXRlcmF0b3IoKSkpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwodGhpcy5idWlsZE9iamVjdEFycmF5MSgpLCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKS5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zQWxsT2JqZWN0QXJyYXlJdGVyYXRvcl9FbXB0eSgpIHsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwodGhpcy5idWlsZE9iamVjdEFycmF5MSgpLCBFbXB0eUl0ZXJhdG9yLmluc3RhbmNlKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNBbGxPYmplY3RBcnJheU9iamVjdEFycmF5KCkgewotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbCh0aGlzLmJ1aWxkT2JqZWN0QXJyYXkxKCksIHRoaXMuYnVpbGRPYmplY3RBcnJheTEoKSkpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwodGhpcy5idWlsZE9iamVjdEFycmF5MSgpLCB0aGlzLmJ1aWxkT2JqZWN0QXJyYXkyKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNBbGxDaGFyQXJyYXlDaGFyQXJyYXkoKSB7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRDaGFyQXJyYXkoKSwgdGhpcy5idWlsZENoYXJBcnJheSgpKSk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbCh0aGlzLmJ1aWxkQ2hhckFycmF5KCksIG5ldyBjaGFyW10geyAneCcsICd5JyB9KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zQWxsSW50QXJyYXlJbnRBcnJheSgpIHsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwodGhpcy5idWlsZEludEFycmF5KCksIHRoaXMuYnVpbGRJbnRBcnJheSgpKSk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbCh0aGlzLmJ1aWxkSW50QXJyYXkoKSwgbmV3IGludFtdIHsgNDQ0LCA4ODggfSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3REaWZmRW5kKCkgewotCQlTdHJpbmcgYSA9ICJhIjsKLQkJU3RyaW5nIGIgPSAiYiI7Ci0JCVN0cmluZyBjID0gImMiOwotCQlTdHJpbmcgZCA9ICJkIjsKLQkJU3RyaW5nIGUgPSAiZSI7Ci0JCVN0cmluZyBhXyA9IG5ldyBTdHJpbmcoImEiKTsKLQkJU3RyaW5nIGJfID0gbmV3IFN0cmluZygiYiIpOwotCQlTdHJpbmcgY18gPSBuZXcgU3RyaW5nKCJjIik7Ci0JCVN0cmluZyBkXyA9IG5ldyBTdHJpbmcoImQiKTsKLQkJU3RyaW5nIGVfID0gbmV3IFN0cmluZygiZSIpOwotCQlhc3NlcnRUcnVlKChhICE9IGFfKSAmJiBhLmVxdWFscyhhXykpOwotCQlhc3NlcnRUcnVlKChiICE9IGJfKSAmJiBiLmVxdWFscyhiXykpOwotCQlhc3NlcnRUcnVlKChjICE9IGNfKSAmJiBjLmVxdWFscyhjXykpOwotCQlhc3NlcnRUcnVlKChkICE9IGRfKSAmJiBkLmVxdWFscyhkXykpOwotCQlhc3NlcnRUcnVlKChlICE9IGVfKSAmJiBlLmVxdWFscyhlXykpOwotCQlTdHJpbmdbXSBhcnJheTE7Ci0JCVN0cmluZ1tdIGFycmF5MjsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY18sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMoLTEsIENvbGxlY3Rpb25Ub29scy5kaWZmRW5kKGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXyB9OwotCQlhc3NlcnRFcXVhbHMoLTEsIENvbGxlY3Rpb25Ub29scy5kaWZmRW5kKGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYiwgYywgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIGNfLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKDQsIENvbGxlY3Rpb25Ub29scy5kaWZmRW5kKGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgYywgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBiXywgY18sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMoNCwgQ29sbGVjdGlvblRvb2xzLmRpZmZFbmQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nWzBdOwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIGNfLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKDQsIENvbGxlY3Rpb25Ub29scy5kaWZmRW5kKGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgYywgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nWzBdOwotCQlhc3NlcnRFcXVhbHMoNCwgQ29sbGVjdGlvblRvb2xzLmRpZmZFbmQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nWzBdOwotCQlhcnJheTIgPSBuZXcgU3RyaW5nWzBdOwotCQlhc3NlcnRFcXVhbHMoLTEsIENvbGxlY3Rpb25Ub29scy5kaWZmRW5kKGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgYywgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBiXywgY18sIGFfLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKDIsIENvbGxlY3Rpb25Ub29scy5kaWZmRW5kKGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYiwgYywgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgY18sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMoMCwgQ29sbGVjdGlvblRvb2xzLmRpZmZFbmQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY18sIGRfIH07Ci0JCWFzc2VydEVxdWFscygzLCBDb2xsZWN0aW9uVG9vbHMuZGlmZkVuZChhcnJheTEsIGFycmF5MikpOwotCi0JCVN0cmluZyBjX18gPSBuZXcgU3RyaW5nKGMpOwotCQlhc3NlcnRUcnVlKChjICE9IGNfXykgJiYgYy5lcXVhbHMoY18pKTsKLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgYywgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIGNfXywgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscygtMSwgQ29sbGVjdGlvblRvb2xzLmRpZmZFbmQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBudWxsLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY18sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMoMiwgQ29sbGVjdGlvblRvb2xzLmRpZmZFbmQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBudWxsLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgbnVsbCwgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscygtMSwgQ29sbGVjdGlvblRvb2xzLmRpZmZFbmQoYXJyYXkxLCBhcnJheTIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGlmZlJhbmdlKCkgewotCQlTdHJpbmcgYSA9ICJhIjsKLQkJU3RyaW5nIGIgPSAiYiI7Ci0JCVN0cmluZyBjID0gImMiOwotCQlTdHJpbmcgZCA9ICJkIjsKLQkJU3RyaW5nIGUgPSAiZSI7Ci0JCVN0cmluZyBhXyA9IGE7Ci0JCVN0cmluZyBiXyA9IGI7Ci0JCVN0cmluZyBjXyA9IGM7Ci0JCVN0cmluZyBkXyA9IGQ7Ci0JCVN0cmluZyBlXyA9IGU7Ci0JCWFzc2VydFRydWUoKGEgPT0gYV8pICYmIGEuZXF1YWxzKGFfKSk7Ci0JCWFzc2VydFRydWUoKGIgPT0gYl8pICYmIGIuZXF1YWxzKGJfKSk7Ci0JCWFzc2VydFRydWUoKGMgPT0gY18pICYmIGMuZXF1YWxzKGNfKSk7Ci0JCWFzc2VydFRydWUoKGQgPT0gZF8pICYmIGQuZXF1YWxzKGRfKSk7Ci0JCWFzc2VydFRydWUoKGUgPT0gZV8pICYmIGUuZXF1YWxzKGVfKSk7Ci0JCVN0cmluZ1tdIGFycmF5MTsKLQkJU3RyaW5nW10gYXJyYXkyOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGEsIGIsIGMsIGQsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGJfLCBjXywgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscyhuZXcgUmFuZ2UoNSwgLTEpLCBDb2xsZWN0aW9uVG9vbHMuZGlmZlJhbmdlKGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXyB9OwotCQlhc3NlcnRFcXVhbHMobmV3IFJhbmdlKDEsIC0xKSwgQ29sbGVjdGlvblRvb2xzLmRpZmZSYW5nZShhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGIsIGMsIGQsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGJfLCBjXywgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscyhuZXcgUmFuZ2UoMCwgNCksIENvbGxlY3Rpb25Ub29scy5kaWZmUmFuZ2UoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGJfLCBjXywgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscyhuZXcgUmFuZ2UoMCwgNCksIENvbGxlY3Rpb25Ub29scy5kaWZmUmFuZ2UoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nWzBdOwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIGNfLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBSYW5nZSgwLCA0KSwgQ29sbGVjdGlvblRvb2xzLmRpZmZSYW5nZShhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGEsIGIsIGMsIGQsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1swXTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBSYW5nZSgwLCA0KSwgQ29sbGVjdGlvblRvb2xzLmRpZmZSYW5nZShhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbMF07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbMF07Ci0JCWFzc2VydEVxdWFscyhuZXcgUmFuZ2UoMCwgLTEpLCBDb2xsZWN0aW9uVG9vbHMuZGlmZlJhbmdlKGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgYywgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBiXywgY18sIGFfLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBSYW5nZSgwLCAyKSwgQ29sbGVjdGlvblRvb2xzLmRpZmZSYW5nZShhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGIsIGMsIGQsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGNfLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBSYW5nZSgwLCAwKSwgQ29sbGVjdGlvblRvb2xzLmRpZmZSYW5nZShhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGEsIGIsIGMsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGJfLCBjXywgZF8gfTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBSYW5nZSgzLCAzKSwgQ29sbGVjdGlvblRvb2xzLmRpZmZSYW5nZShhcnJheTEsIGFycmF5MikpOwotCi0JCVN0cmluZyBjX18gPSBuZXcgU3RyaW5nKGMpOwotCQlhc3NlcnRUcnVlKChjICE9IGNfXykgJiYgYy5lcXVhbHMoY18pKTsKLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgYywgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIGNfXywgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscyhuZXcgUmFuZ2UoNSwgLTEpLCBDb2xsZWN0aW9uVG9vbHMuZGlmZlJhbmdlKGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgbnVsbCwgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIGNfLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBSYW5nZSgyLCAyKSwgQ29sbGVjdGlvblRvb2xzLmRpZmZSYW5nZShhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGEsIGIsIG51bGwsIGQsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGJfLCBudWxsLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBSYW5nZSg1LCAtMSksIENvbGxlY3Rpb25Ub29scy5kaWZmUmFuZ2UoYXJyYXkxLCBhcnJheTIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGlmZlN0YXJ0KCkgewotCQlTdHJpbmcgYSA9ICJhIjsKLQkJU3RyaW5nIGIgPSAiYiI7Ci0JCVN0cmluZyBjID0gImMiOwotCQlTdHJpbmcgZCA9ICJkIjsKLQkJU3RyaW5nIGUgPSAiZSI7Ci0JCVN0cmluZyBhXyA9IG5ldyBTdHJpbmcoImEiKTsKLQkJU3RyaW5nIGJfID0gbmV3IFN0cmluZygiYiIpOwotCQlTdHJpbmcgY18gPSBuZXcgU3RyaW5nKCJjIik7Ci0JCVN0cmluZyBkXyA9IG5ldyBTdHJpbmcoImQiKTsKLQkJU3RyaW5nIGVfID0gbmV3IFN0cmluZygiZSIpOwotCQlhc3NlcnRUcnVlKChhICE9IGFfKSAmJiBhLmVxdWFscyhhXykpOwotCQlhc3NlcnRUcnVlKChiICE9IGJfKSAmJiBiLmVxdWFscyhiXykpOwotCQlhc3NlcnRUcnVlKChjICE9IGNfKSAmJiBjLmVxdWFscyhjXykpOwotCQlhc3NlcnRUcnVlKChkICE9IGRfKSAmJiBkLmVxdWFscyhkXykpOwotCQlhc3NlcnRUcnVlKChlICE9IGVfKSAmJiBlLmVxdWFscyhlXykpOwotCQlTdHJpbmdbXSBhcnJheTE7Ci0JCVN0cmluZ1tdIGFycmF5MjsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY18sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMoNSwgQ29sbGVjdGlvblRvb2xzLmRpZmZTdGFydChhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGEgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8gfTsKLQkJYXNzZXJ0RXF1YWxzKDEsIENvbGxlY3Rpb25Ub29scy5kaWZmU3RhcnQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY18sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMoNCwgQ29sbGVjdGlvblRvb2xzLmRpZmZTdGFydChhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGEsIGIsIGMsIGQsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGJfLCBjXywgZF8gfTsKLQkJYXNzZXJ0RXF1YWxzKDQsIENvbGxlY3Rpb25Ub29scy5kaWZmU3RhcnQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nWzBdOwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIGNfLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKDAsIENvbGxlY3Rpb25Ub29scy5kaWZmU3RhcnQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbMF07Ci0JCWFzc2VydEVxdWFscygwLCBDb2xsZWN0aW9uVG9vbHMuZGlmZlN0YXJ0KGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1swXTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1swXTsKLQkJYXNzZXJ0RXF1YWxzKDAsIENvbGxlY3Rpb25Ub29scy5kaWZmU3RhcnQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgZV8sIGNfLCBkXyB9OwotCQlhc3NlcnRFcXVhbHMoMiwgQ29sbGVjdGlvblRvb2xzLmRpZmZTdGFydChhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGEsIGIsIGMsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGJfLCBjXywgZF8gfTsKLQkJYXNzZXJ0RXF1YWxzKDMsIENvbGxlY3Rpb25Ub29scy5kaWZmU3RhcnQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBjXywgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscygwLCBDb2xsZWN0aW9uVG9vbHMuZGlmZlN0YXJ0KGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJU3RyaW5nIGNfXyA9IG5ldyBTdHJpbmcoYyk7Ci0JCWFzc2VydFRydWUoKGMgIT0gY19fKSAmJiBjLmVxdWFscyhjX18pKTsKLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgYywgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIGNfXywgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscyg1LCBDb2xsZWN0aW9uVG9vbHMuZGlmZlN0YXJ0KGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgbnVsbCwgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIGNfLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKDIsIENvbGxlY3Rpb25Ub29scy5kaWZmU3RhcnQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBudWxsLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgbnVsbCwgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscyg1LCBDb2xsZWN0aW9uVG9vbHMuZGlmZlN0YXJ0KGFycmF5MSwgYXJyYXkyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEVxdWFsc0l0ZXJhdG9ySXRlcmF0b3IoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0MSA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlsaXN0MS5hZGQoIjEwMDAiKTsKLQkJbGlzdDEuYWRkKCIyMDAwIik7Ci0JCWxpc3QxLmFkZCgiMzAwMCIpOwotCQlsaXN0MS5hZGQoIjQwMDAiKTsKLQotCQlMaXN0PFN0cmluZz4gbGlzdDIgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsaXN0MS5zaXplKCk7IGkrKykgewotCQkJbGlzdDIuYWRkKFN0cmluZy52YWx1ZU9mKChpICsgMSkgKiAxMDAwKSk7Ci0JCX0KLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmlkZW50aWNhbChsaXN0MS5saXN0SXRlcmF0b3IoKSwgbGlzdDIubGlzdEl0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuZXF1YWxzKGxpc3QxLmxpc3RJdGVyYXRvcigpLCBsaXN0Mi5saXN0SXRlcmF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRMaXN0SXRlcmF0b3JJbnQoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0ID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCVN0cmluZyBvID0gQ29sbGVjdGlvblRvb2xzLmdldChsaXN0Lmxpc3RJdGVyYXRvcigpLCAxKTsKLQkJYXNzZXJ0RXF1YWxzKCJvbmUiLCBvKTsKLQkJbGlzdC5hZGQobnVsbCk7Ci0JCW8gPSBDb2xsZWN0aW9uVG9vbHMuZ2V0KGxpc3QubGlzdEl0ZXJhdG9yKCksIGxpc3Quc2l6ZSgpIC0gMSk7Ci0JCWFzc2VydE51bGwobyk7Ci0KLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJQ29sbGVjdGlvblRvb2xzLmdldChsaXN0Lmxpc3RJdGVyYXRvcigpLCBsaXN0LnNpemUoKSk7Ci0JCX0gY2F0Y2ggKEluZGV4T3V0T2ZCb3VuZHNFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SWRlbnRpY2FsT2JqZWN0QXJyYXlPYmplY3RBcnJheSgpIHsKLQkJT2JqZWN0W10gYTEgPSBuZXcgT2JqZWN0WzRdOwotCQlmb3IgKGludCBpID0gMDsgaSA8IGExLmxlbmd0aDsgaSsrKSB7Ci0JCQlhMVtpXSA9IFN0cmluZy52YWx1ZU9mKGkgKiAxMDAwKTsKLQkJfQotCi0JCU9iamVjdFtdIGEyID0gbmV3IE9iamVjdFthMS5sZW5ndGhdOwotCQlmb3IgKGludCBpID0gMDsgaSA8IGEyLmxlbmd0aDsgaSsrKSB7Ci0JCQlhMltpXSA9IGExW2ldOwotCQl9Ci0KLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuaWRlbnRpY2FsKGExLCBhMikpOwotCQlhMlsyXSA9ICIyMDAwIjsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmlkZW50aWNhbChhMSwgYTIpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGExLCBhMikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJZGVudGljYWxPYmplY3RBcnJheU9iamVjdEFycmF5X0JvdGhOdWxsKCkgewotCQlPYmplY3RbXSBhMSA9IG51bGw7Ci0JCU9iamVjdFtdIGEyID0gbnVsbDsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuaWRlbnRpY2FsKGExLCBhMikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJZGVudGljYWxPYmplY3RBcnJheU9iamVjdEFycmF5X09uZU51bGwoKSB7Ci0JCU9iamVjdFtdIGExID0gbnVsbDsKLQkJT2JqZWN0W10gYTIgPSBuZXcgT2JqZWN0WzBdOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuaWRlbnRpY2FsKGExLCBhMikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJZGVudGljYWxPYmplY3RBcnJheU9iamVjdEFycmF5X0RpZmZlcmVudExlbmd0aHMoKSB7Ci0JCU9iamVjdFtdIGExID0gbmV3IFN0cmluZ1tdIHsiZm9vIiwgImJhciJ9OwotCQlPYmplY3RbXSBhMiA9IG5ldyBTdHJpbmdbXSB7ImZvbyIsICJiYXIiLCAiYmF6In07Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5pZGVudGljYWwoYTEsIGEyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdElkZW50aWNhbExpc3RJdGVyYXRvckxpc3RJdGVyYXRvcigpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QxID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWxpc3QxLmFkZCgiMCIpOwotCQlsaXN0MS5hZGQoIjEiKTsKLQkJbGlzdDEuYWRkKCIyIik7Ci0JCWxpc3QxLmFkZCgiMyIpOwotCi0JCUxpc3Q8U3RyaW5nPiBsaXN0MiA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlmb3IgKFN0cmluZyBzIDogbGlzdDEpIHsKLQkJCWxpc3QyLmFkZChzKTsKLQkJfQotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5pZGVudGljYWwobGlzdDEubGlzdEl0ZXJhdG9yKCksIGxpc3QyLmxpc3RJdGVyYXRvcigpKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmVxdWFscyhsaXN0MS5saXN0SXRlcmF0b3IoKSwgbGlzdDIubGlzdEl0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SWRlbnRpY2FsTGlzdEl0ZXJhdG9yTGlzdEl0ZXJhdG9yX05vdCgpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QxID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWxpc3QxLmFkZCgiMCIpOwotCQlsaXN0MS5hZGQoIjEiKTsKLQkJbGlzdDEuYWRkKCIyIik7Ci0JCWxpc3QxLmFkZCgiMyIpOwotCi0JCUxpc3Q8U3RyaW5nPiBsaXN0MiA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlmb3IgKFN0cmluZyBzIDogbGlzdDEpIHsKLQkJCWxpc3QyLmFkZChzKTsKLQkJfQotCQlsaXN0Mi5yZW1vdmUoMCk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5pZGVudGljYWwobGlzdDEubGlzdEl0ZXJhdG9yKCksIGxpc3QyLmxpc3RJdGVyYXRvcigpKSk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5lcXVhbHMobGlzdDEubGlzdEl0ZXJhdG9yKCksIGxpc3QyLmxpc3RJdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdElkZW50aWNhbExpc3RJdGVyYXRvckxpc3RJdGVyYXRvcl9EaWZmZXJlbnRTaXplcygpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QxID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWxpc3QxLmFkZCgiMCIpOwotCQlsaXN0MS5hZGQoIjEiKTsKLQkJbGlzdDEuYWRkKCIyIik7Ci0JCWxpc3QxLmFkZCgiMyIpOwotCi0JCUxpc3Q8U3RyaW5nPiBsaXN0MiA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlmb3IgKFN0cmluZyBzIDogbGlzdDEpIHsKLQkJCWxpc3QyLmFkZChzKTsKLQkJfQotCQlsaXN0Mi5yZW1vdmUoMyk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5pZGVudGljYWwobGlzdDEubGlzdEl0ZXJhdG9yKCksIGxpc3QyLmxpc3RJdGVyYXRvcigpKSk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5lcXVhbHMobGlzdDEubGlzdEl0ZXJhdG9yKCksIGxpc3QyLmxpc3RJdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdElkZW50aXR5RGlmZkVuZCgpIHsKLQkJU3RyaW5nIGEgPSAiYSI7Ci0JCVN0cmluZyBiID0gImIiOwotCQlTdHJpbmcgYyA9ICJjIjsKLQkJU3RyaW5nIGQgPSAiZCI7Ci0JCVN0cmluZyBlID0gImUiOwotCQlTdHJpbmcgYV8gPSBhOwotCQlTdHJpbmcgYl8gPSBiOwotCQlTdHJpbmcgY18gPSBjOwotCQlTdHJpbmcgZF8gPSBkOwotCQlTdHJpbmcgZV8gPSBlOwotCQlhc3NlcnRUcnVlKChhID09IGFfKSAmJiBhLmVxdWFscyhhXykpOwotCQlhc3NlcnRUcnVlKChiID09IGJfKSAmJiBiLmVxdWFscyhiXykpOwotCQlhc3NlcnRUcnVlKChjID09IGNfKSAmJiBjLmVxdWFscyhjXykpOwotCQlhc3NlcnRUcnVlKChkID09IGRfKSAmJiBkLmVxdWFscyhkXykpOwotCQlhc3NlcnRUcnVlKChlID09IGVfKSAmJiBlLmVxdWFscyhlXykpOwotCQlTdHJpbmdbXSBhcnJheTE7Ci0JCVN0cmluZ1tdIGFycmF5MjsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY18sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMoLTEsIENvbGxlY3Rpb25Ub29scy5pZGVudGl0eURpZmZFbmQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfIH07Ci0JCWFzc2VydEVxdWFscygtMSwgQ29sbGVjdGlvblRvb2xzLmlkZW50aXR5RGlmZkVuZChhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGIsIGMsIGQsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGJfLCBjXywgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscyg0LCBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmRW5kKGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgYywgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBiXywgY18sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMoNCwgQ29sbGVjdGlvblRvb2xzLmlkZW50aXR5RGlmZkVuZChhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbMF07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY18sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMoNCwgQ29sbGVjdGlvblRvb2xzLmlkZW50aXR5RGlmZkVuZChhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGEsIGIsIGMsIGQsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1swXTsKLQkJYXNzZXJ0RXF1YWxzKDQsIENvbGxlY3Rpb25Ub29scy5pZGVudGl0eURpZmZFbmQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nWzBdOwotCQlhcnJheTIgPSBuZXcgU3RyaW5nWzBdOwotCQlhc3NlcnRFcXVhbHMoLTEsIENvbGxlY3Rpb25Ub29scy5pZGVudGl0eURpZmZFbmQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGJfLCBjXywgYV8sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMoMiwgQ29sbGVjdGlvblRvb2xzLmlkZW50aXR5RGlmZkVuZChhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGIsIGMsIGQsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGNfLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKDAsIENvbGxlY3Rpb25Ub29scy5pZGVudGl0eURpZmZFbmQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY18sIGRfIH07Ci0JCWFzc2VydEVxdWFscygzLCBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmRW5kKGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJU3RyaW5nIGNfXyA9IG5ldyBTdHJpbmcoYyk7Ci0JCWFzc2VydFRydWUoKGMgIT0gY19fKSAmJiBjLmVxdWFscyhjXykpOwotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY19fLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKDIsIENvbGxlY3Rpb25Ub29scy5pZGVudGl0eURpZmZFbmQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBudWxsLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY18sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMoMiwgQ29sbGVjdGlvblRvb2xzLmlkZW50aXR5RGlmZkVuZChhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGEsIGIsIG51bGwsIGQsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGJfLCBudWxsLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKC0xLCBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmRW5kKGFycmF5MSwgYXJyYXkyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdElkZW50aXR5RGlmZlJhbmdlKCkgewotCQlTdHJpbmcgYSA9ICJhIjsKLQkJU3RyaW5nIGIgPSAiYiI7Ci0JCVN0cmluZyBjID0gImMiOwotCQlTdHJpbmcgZCA9ICJkIjsKLQkJU3RyaW5nIGUgPSAiZSI7Ci0JCVN0cmluZyBhXyA9IGE7Ci0JCVN0cmluZyBiXyA9IGI7Ci0JCVN0cmluZyBjXyA9IGM7Ci0JCVN0cmluZyBkXyA9IGQ7Ci0JCVN0cmluZyBlXyA9IGU7Ci0JCWFzc2VydFRydWUoKGEgPT0gYV8pICYmIGEuZXF1YWxzKGFfKSk7Ci0JCWFzc2VydFRydWUoKGIgPT0gYl8pICYmIGIuZXF1YWxzKGJfKSk7Ci0JCWFzc2VydFRydWUoKGMgPT0gY18pICYmIGMuZXF1YWxzKGNfKSk7Ci0JCWFzc2VydFRydWUoKGQgPT0gZF8pICYmIGQuZXF1YWxzKGRfKSk7Ci0JCWFzc2VydFRydWUoKGUgPT0gZV8pICYmIGUuZXF1YWxzKGVfKSk7Ci0JCVN0cmluZ1tdIGFycmF5MTsKLQkJU3RyaW5nW10gYXJyYXkyOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGEsIGIsIGMsIGQsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGJfLCBjXywgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscyhuZXcgUmFuZ2UoNSwgLTEpLCBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmUmFuZ2UoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfIH07Ci0JCWFzc2VydEVxdWFscyhuZXcgUmFuZ2UoMSwgLTEpLCBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmUmFuZ2UoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY18sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMobmV3IFJhbmdlKDAsIDQpLCBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmUmFuZ2UoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGJfLCBjXywgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscyhuZXcgUmFuZ2UoMCwgNCksIENvbGxlY3Rpb25Ub29scy5pZGVudGl0eURpZmZSYW5nZShhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbMF07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY18sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMobmV3IFJhbmdlKDAsIDQpLCBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmUmFuZ2UoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbMF07Ci0JCWFzc2VydEVxdWFscyhuZXcgUmFuZ2UoMCwgNCksIENvbGxlY3Rpb25Ub29scy5pZGVudGl0eURpZmZSYW5nZShhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbMF07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbMF07Ci0JCWFzc2VydEVxdWFscyhuZXcgUmFuZ2UoMCwgLTEpLCBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmUmFuZ2UoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGJfLCBjXywgYV8sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMobmV3IFJhbmdlKDAsIDIpLCBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmUmFuZ2UoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBjXywgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscyhuZXcgUmFuZ2UoMCwgMCksIENvbGxlY3Rpb25Ub29scy5pZGVudGl0eURpZmZSYW5nZShhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGEsIGIsIGMsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGJfLCBjXywgZF8gfTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBSYW5nZSgzLCAzKSwgQ29sbGVjdGlvblRvb2xzLmlkZW50aXR5RGlmZlJhbmdlKGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJU3RyaW5nIGNfXyA9IG5ldyBTdHJpbmcoYyk7Ci0JCWFzc2VydFRydWUoKGMgIT0gY19fKSAmJiBjLmVxdWFscyhjXykpOwotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY19fLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBSYW5nZSgyLCAyKSwgQ29sbGVjdGlvblRvb2xzLmlkZW50aXR5RGlmZlJhbmdlKGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgbnVsbCwgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIGNfLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBSYW5nZSgyLCAyKSwgQ29sbGVjdGlvblRvb2xzLmlkZW50aXR5RGlmZlJhbmdlKGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgbnVsbCwgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIG51bGwsIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMobmV3IFJhbmdlKDUsIC0xKSwgQ29sbGVjdGlvblRvb2xzLmlkZW50aXR5RGlmZlJhbmdlKGFycmF5MSwgYXJyYXkyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdElkZW50aXR5RGlmZlN0YXJ0KCkgewotCQlTdHJpbmcgYSA9ICJhIjsKLQkJU3RyaW5nIGIgPSAiYiI7Ci0JCVN0cmluZyBjID0gImMiOwotCQlTdHJpbmcgZCA9ICJkIjsKLQkJU3RyaW5nIGUgPSAiZSI7Ci0JCVN0cmluZyBhXyA9IGE7Ci0JCVN0cmluZyBiXyA9IGI7Ci0JCVN0cmluZyBjXyA9IGM7Ci0JCVN0cmluZyBkXyA9IGQ7Ci0JCVN0cmluZyBlXyA9IGU7Ci0JCWFzc2VydFRydWUoKGEgPT0gYV8pICYmIGEuZXF1YWxzKGFfKSk7Ci0JCWFzc2VydFRydWUoKGIgPT0gYl8pICYmIGIuZXF1YWxzKGJfKSk7Ci0JCWFzc2VydFRydWUoKGMgPT0gY18pICYmIGMuZXF1YWxzKGNfKSk7Ci0JCWFzc2VydFRydWUoKGQgPT0gZF8pICYmIGQuZXF1YWxzKGRfKSk7Ci0JCWFzc2VydFRydWUoKGUgPT0gZV8pICYmIGUuZXF1YWxzKGVfKSk7Ci0JCVN0cmluZ1tdIGFycmF5MTsKLQkJU3RyaW5nW10gYXJyYXkyOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGEsIGIsIGMsIGQsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGJfLCBjXywgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscyg1LCBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmU3RhcnQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfIH07Ci0JCWFzc2VydEVxdWFscygxLCBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmU3RhcnQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY18sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMoNCwgQ29sbGVjdGlvblRvb2xzLmlkZW50aXR5RGlmZlN0YXJ0KGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgYywgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIGNfLCBkXyB9OwotCQlhc3NlcnRFcXVhbHMoNCwgQ29sbGVjdGlvblRvb2xzLmlkZW50aXR5RGlmZlN0YXJ0KGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1swXTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGJfLCBjXywgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscygwLCBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmU3RhcnQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBjLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbMF07Ci0JCWFzc2VydEVxdWFscygwLCBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmU3RhcnQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nWzBdOwotCQlhcnJheTIgPSBuZXcgU3RyaW5nWzBdOwotCQlhc3NlcnRFcXVhbHMoMCwgQ29sbGVjdGlvblRvb2xzLmlkZW50aXR5RGlmZlN0YXJ0KGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgYywgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIGVfLCBjXywgZF8gfTsKLQkJYXNzZXJ0RXF1YWxzKDIsIENvbGxlY3Rpb25Ub29scy5pZGVudGl0eURpZmZTdGFydChhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGEsIGIsIGMsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGJfLCBjXywgZF8gfTsKLQkJYXNzZXJ0RXF1YWxzKDMsIENvbGxlY3Rpb25Ub29scy5pZGVudGl0eURpZmZTdGFydChhcnJheTEsIGFycmF5MikpOwotCi0JCWFycmF5MSA9IG5ldyBTdHJpbmdbXSB7IGIsIGMsIGQsIGUgfTsKLQkJYXJyYXkyID0gbmV3IFN0cmluZ1tdIHsgYV8sIGNfLCBkXywgZV8gfTsKLQkJYXNzZXJ0RXF1YWxzKDAsIENvbGxlY3Rpb25Ub29scy5pZGVudGl0eURpZmZTdGFydChhcnJheTEsIGFycmF5MikpOwotCi0JCVN0cmluZyBjX18gPSBuZXcgU3RyaW5nKGMpOwotCQlhc3NlcnRUcnVlKChjICE9IGNfXykgJiYgYy5lcXVhbHMoY18pKTsKLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgYywgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIGNfXywgZF8sIGVfIH07Ci0JCWFzc2VydEVxdWFscygyLCBDb2xsZWN0aW9uVG9vbHMuaWRlbnRpdHlEaWZmU3RhcnQoYXJyYXkxLCBhcnJheTIpKTsKLQotCQlhcnJheTEgPSBuZXcgU3RyaW5nW10geyBhLCBiLCBudWxsLCBkLCBlIH07Ci0JCWFycmF5MiA9IG5ldyBTdHJpbmdbXSB7IGFfLCBiXywgY18sIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMoMiwgQ29sbGVjdGlvblRvb2xzLmlkZW50aXR5RGlmZlN0YXJ0KGFycmF5MSwgYXJyYXkyKSk7Ci0KLQkJYXJyYXkxID0gbmV3IFN0cmluZ1tdIHsgYSwgYiwgbnVsbCwgZCwgZSB9OwotCQlhcnJheTIgPSBuZXcgU3RyaW5nW10geyBhXywgYl8sIG51bGwsIGRfLCBlXyB9OwotCQlhc3NlcnRFcXVhbHMoNSwgQ29sbGVjdGlvblRvb2xzLmlkZW50aXR5RGlmZlN0YXJ0KGFycmF5MSwgYXJyYXkyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEluZGV4T2ZMaXN0SXRlcmF0b3JPYmplY3RfU3RyaW5nKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlhc3NlcnRFcXVhbHMoMSwgQ29sbGVjdGlvblRvb2xzLmluZGV4T2YobGlzdC5saXN0SXRlcmF0b3IoKSwgIm9uZSIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW5kZXhPZkxpc3RJdGVyYXRvck9iamVjdF9OdWxsKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlsaXN0LmFkZChudWxsKTsKLQkJYXNzZXJ0RXF1YWxzKGxpc3Quc2l6ZSgpIC0gMSwgQ29sbGVjdGlvblRvb2xzLmluZGV4T2YobGlzdC5saXN0SXRlcmF0b3IoKSwgbnVsbCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbmRleE9mTGlzdEl0ZXJhdG9yT2JqZWN0X09iamVjdCgpIHsKLQkJTGlzdDxPYmplY3Q+IGxpc3QgPSBuZXcgQXJyYXlMaXN0PE9iamVjdD4oKTsKLQkJbGlzdC5hZGQoIjAiKTsKLQkJbGlzdC5hZGQoIjEiKTsKLQkJbGlzdC5hZGQoIjIiKTsKLQkJbGlzdC5hZGQoIjMiKTsKLQotCQlTdHJpbmcgb25lID0gIjEiOwotCQlhc3NlcnRFcXVhbHMoMSwgQ29sbGVjdGlvblRvb2xzLmluZGV4T2YobGlzdC5saXN0SXRlcmF0b3IoKSwgb25lKSk7Ci0JCWxpc3QuYWRkKG51bGwpOwotCQlhc3NlcnRFcXVhbHMobGlzdC5zaXplKCkgLSAxLCBDb2xsZWN0aW9uVG9vbHMuaW5kZXhPZihsaXN0Lmxpc3RJdGVyYXRvcigpLCBudWxsKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEluZGV4T2ZPYmplY3RBcnJheU9iamVjdCgpIHsKLQkJT2JqZWN0W10gYSA9IHRoaXMuYnVpbGRPYmplY3RBcnJheTEoKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIENvbGxlY3Rpb25Ub29scy5pbmRleE9mKGEsICJvbmUiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEluZGV4T2ZPYmplY3RBcnJheU9iamVjdF9OdWxsKCkgewotCQlPYmplY3RbXSBhID0gdGhpcy5idWlsZE9iamVjdEFycmF5MSgpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCBudWxsKTsKLQkJYXNzZXJ0RXF1YWxzKGEubGVuZ3RoIC0gMSwgQ29sbGVjdGlvblRvb2xzLmluZGV4T2YoYSwgbnVsbCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbmRleE9mQ2hhckFycmF5Q2hhcigpIHsKLQkJY2hhcltdIGEgPSB0aGlzLmJ1aWxkQ2hhckFycmF5KCk7Ci0JCWFzc2VydEVxdWFscygxLCBDb2xsZWN0aW9uVG9vbHMuaW5kZXhPZihhLCAnYicpKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGQoYSwgJ2QnKTsKLQkJYXNzZXJ0RXF1YWxzKGEubGVuZ3RoIC0gMSwgQ29sbGVjdGlvblRvb2xzLmluZGV4T2YoYSwgJ2QnKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEluZGV4T2ZJbnRBcnJheUludCgpIHsKLQkJaW50W10gYSA9IHRoaXMuYnVpbGRJbnRBcnJheSgpOwotCQlhc3NlcnRFcXVhbHMoMSwgQ29sbGVjdGlvblRvb2xzLmluZGV4T2YoYSwgMTApKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGQoYSwgMzApOwotCQlhc3NlcnRFcXVhbHMoYS5sZW5ndGggLSAxLCBDb2xsZWN0aW9uVG9vbHMuaW5kZXhPZihhLCAzMCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbnNlcnRpb25JbmRleE9mTGlzdENvbXBhcmFibGUoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0ID0gQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAiQSIsICJDIiwgIkQiIH0pOwotCQlhc3NlcnRFcXVhbHMoMSwgQ29sbGVjdGlvblRvb2xzLmluc2VydGlvbkluZGV4T2YobGlzdCwgIkIiKSk7Ci0KLQkJbGlzdCA9IEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgIkEiLCAiQiIsICJDIiwgIkQiIH0pOwotCQlhc3NlcnRFcXVhbHMoMiwgQ29sbGVjdGlvblRvb2xzLmluc2VydGlvbkluZGV4T2YobGlzdCwgIkIiKSk7Ci0KLQkJbGlzdCA9IEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgIkEiLCAiQiIsICJCIiwgIkIiLCAiQyIsICJEIiB9KTsKLQkJYXNzZXJ0RXF1YWxzKDQsIENvbGxlY3Rpb25Ub29scy5pbnNlcnRpb25JbmRleE9mKGxpc3QsICJCIikpOwotCi0JCWxpc3QgPSBBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJBIiwgIkIiLCAiQiIsICJCIiwgIkMiLCAiRCIgfSk7Ci0JCWFzc2VydEVxdWFscyg2LCBDb2xsZWN0aW9uVG9vbHMuaW5zZXJ0aW9uSW5kZXhPZihsaXN0LCAiRSIpKTsKLQotCQlsaXN0ID0gQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAiQiIsICJCIiwgIkIiLCAiQyIsICJEIiB9KTsKLQkJYXNzZXJ0RXF1YWxzKDAsIENvbGxlY3Rpb25Ub29scy5pbnNlcnRpb25JbmRleE9mKGxpc3QsICJBIikpOwotCi0JCWxpc3QgPSBBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJBIiwgIkEiLCAiQiIsICJCIiwgIkMiLCAiRCIgfSk7Ci0JCWFzc2VydEVxdWFscygyLCBDb2xsZWN0aW9uVG9vbHMuaW5zZXJ0aW9uSW5kZXhPZihsaXN0LCAiQSIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW5zZXJ0aW9uSW5kZXhPZkxpc3RPYmplY3RDb21wYXJhdG9yKCkgewotCQlDb21wYXJhdG9yPFN0cmluZz4gYyA9IG5ldyBSZXZlcnNlQ29tcGFyYXRvcjxTdHJpbmc+KCk7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0ID0gQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAiRCIsICJDIiwgIkEiIH0pOwotCQlhc3NlcnRFcXVhbHMoMiwgQ29sbGVjdGlvblRvb2xzLmluc2VydGlvbkluZGV4T2YobGlzdCwgIkIiLCBjKSk7Ci0KLQkJbGlzdCA9IEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgIkQiLCAiQyIsICJCIiwgIkEiIH0pOwotCQlhc3NlcnRFcXVhbHMoMywgQ29sbGVjdGlvblRvb2xzLmluc2VydGlvbkluZGV4T2YobGlzdCwgIkIiLCBjKSk7Ci0KLQkJbGlzdCA9IEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgIkQiLCAiQyIsICJCIiwgIkIiLCAiQiIsICJBIiB9KTsKLQkJYXNzZXJ0RXF1YWxzKDUsIENvbGxlY3Rpb25Ub29scy5pbnNlcnRpb25JbmRleE9mKGxpc3QsICJCIiwgYykpOwotCi0JCWxpc3QgPSBBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJEIiwgIkMiLCAiQiIsICJCIiwgIkIiLCAiQSIgfSk7Ci0JCWFzc2VydEVxdWFscygwLCBDb2xsZWN0aW9uVG9vbHMuaW5zZXJ0aW9uSW5kZXhPZihsaXN0LCAiRSIsIGMpKTsKLQotCQlsaXN0ID0gQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAiRCIsICJDIiwgIkIiLCAiQiIsICJCIiB9KTsKLQkJYXNzZXJ0RXF1YWxzKDUsIENvbGxlY3Rpb25Ub29scy5pbnNlcnRpb25JbmRleE9mKGxpc3QsICJBIiwgYykpOwotCi0JCWxpc3QgPSBBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJEIiwgIkMiLCAiQiIsICJCIiwgIkEiLCAiQSIgfSk7Ci0JCWFzc2VydEVxdWFscyg2LCBDb2xsZWN0aW9uVG9vbHMuaW5zZXJ0aW9uSW5kZXhPZihsaXN0LCAiQSIsIGMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW5zZXJ0aW9uSW5kZXhPZk9iamVjdEFycmF5Q29tcGFyYWJsZSgpIHsKLQkJU3RyaW5nW10gYSA9IG5ldyBTdHJpbmdbXSB7ICJBIiwgIkMiLCAiRCIgfTsKLQkJYXNzZXJ0RXF1YWxzKDEsIENvbGxlY3Rpb25Ub29scy5pbnNlcnRpb25JbmRleE9mKGEsICJCIikpOwotCi0JCWEgPSBuZXcgU3RyaW5nW10geyAiQSIsICJCIiwgIkMiLCAiRCIgfTsKLQkJYXNzZXJ0RXF1YWxzKDIsIENvbGxlY3Rpb25Ub29scy5pbnNlcnRpb25JbmRleE9mKGEsICJCIikpOwotCi0JCWEgPSBuZXcgU3RyaW5nW10geyAiQSIsICJCIiwgIkIiLCAiQiIsICJDIiwgIkQiIH07Ci0JCWFzc2VydEVxdWFscyg0LCBDb2xsZWN0aW9uVG9vbHMuaW5zZXJ0aW9uSW5kZXhPZihhLCAiQiIpKTsKLQotCQlhID0gbmV3IFN0cmluZ1tdIHsgIkEiLCAiQiIsICJCIiwgIkIiLCAiQyIsICJEIiB9OwotCQlhc3NlcnRFcXVhbHMoNiwgQ29sbGVjdGlvblRvb2xzLmluc2VydGlvbkluZGV4T2YoYSwgIkUiKSk7Ci0KLQkJYSA9IG5ldyBTdHJpbmdbXSB7ICJCIiwgIkIiLCAiQiIsICJDIiwgIkQiIH07Ci0JCWFzc2VydEVxdWFscygwLCBDb2xsZWN0aW9uVG9vbHMuaW5zZXJ0aW9uSW5kZXhPZihhLCAiQSIpKTsKLQotCQlhID0gbmV3IFN0cmluZ1tdIHsgIkEiLCAiQSIsICJCIiwgIkIiLCAiQyIsICJEIiB9OwotCQlhc3NlcnRFcXVhbHMoMiwgQ29sbGVjdGlvblRvb2xzLmluc2VydGlvbkluZGV4T2YoYSwgIkEiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEluc2VydGlvbkluZGV4T2ZPYmplY3RBcnJheU9iamVjdENvbXBhcmF0b3IoKSB7Ci0JCUNvbXBhcmF0b3I8U3RyaW5nPiBjID0gbmV3IFJldmVyc2VDb21wYXJhdG9yPFN0cmluZz4oKTsKLQkJU3RyaW5nW10gYSA9IG5ldyBTdHJpbmdbXSB7ICJEIiwgIkMiLCAiQSIgfTsKLQkJYXNzZXJ0RXF1YWxzKDIsIENvbGxlY3Rpb25Ub29scy5pbnNlcnRpb25JbmRleE9mKGEsICJCIiwgYykpOwotCi0JCWEgPSBuZXcgU3RyaW5nW10geyAiRCIsICJDIiwgIkIiLCAiQSIgfTsKLQkJYXNzZXJ0RXF1YWxzKDMsIENvbGxlY3Rpb25Ub29scy5pbnNlcnRpb25JbmRleE9mKGEsICJCIiwgYykpOwotCi0JCWEgPSBuZXcgU3RyaW5nW10geyAiRCIsICJDIiwgIkIiLCAiQiIsICJCIiwgIkEiIH07Ci0JCWFzc2VydEVxdWFscyg1LCBDb2xsZWN0aW9uVG9vbHMuaW5zZXJ0aW9uSW5kZXhPZihhLCAiQiIsIGMpKTsKLQotCQlhID0gbmV3IFN0cmluZ1tdIHsgIkQiLCAiQyIsICJCIiwgIkIiLCAiQiIsICJBIiB9OwotCQlhc3NlcnRFcXVhbHMoMCwgQ29sbGVjdGlvblRvb2xzLmluc2VydGlvbkluZGV4T2YoYSwgIkUiLCBjKSk7Ci0KLQkJYSA9IG5ldyBTdHJpbmdbXSB7ICJEIiwgIkMiLCAiQiIsICJCIiwgIkIiIH07Ci0JCWFzc2VydEVxdWFscyg1LCBDb2xsZWN0aW9uVG9vbHMuaW5zZXJ0aW9uSW5kZXhPZihhLCAiQSIsIGMpKTsKLQotCQlhID0gbmV3IFN0cmluZ1tdIHsgIkQiLCAiQyIsICJCIiwgIkIiLCAiQSIsICJBIiB9OwotCQlhc3NlcnRFcXVhbHMoNiwgQ29sbGVjdGlvblRvb2xzLmluc2VydGlvbkluZGV4T2YoYSwgIkEiLCBjKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZXJhYmxlSXRlcmF0b3IoKSB7Ci0JCUl0ZXJhdG9yPE9iamVjdD4gZW1wdHlJdGVyYXRvciA9IEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQkJSXRlcmFibGU8T2JqZWN0PiBlbXB0eUl0ZXJhYmxlID0gQ29sbGVjdGlvblRvb2xzLml0ZXJhYmxlKGVtcHR5SXRlcmF0b3IpOwotCQkKLQkJYXNzZXJ0RmFsc2UoZW1wdHlJdGVyYWJsZS5pdGVyYXRvcigpLmhhc05leHQoKSk7Ci0JCQotCQlib29sZWFuIGV4Y2VwdGlvblRocm93biA9IGZhbHNlOwotCQl0cnkgewotCQkJZW1wdHlJdGVyYXRvciA9IGVtcHR5SXRlcmFibGUuaXRlcmF0b3IoKTsKLQkJCWZhaWwoImludmFsaWQgaXRlcmF0b3I6ICIgKyBlbXB0eUl0ZXJhdG9yKTsKLQkJfSBjYXRjaCAoSWxsZWdhbFN0YXRlRXhjZXB0aW9uIGlzZSkgewotCQkJZXhjZXB0aW9uVGhyb3duID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJJbGxlZ2FsU3RhdGVFeGNlcHRpb24gbm90IHRocm93bi4iLCBleGNlcHRpb25UaHJvd24pOwotCQkKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SXRlcmFibGVPYmplY3RBcnJheSgpIHsKLQkJU3RyaW5nW10gc3RyaW5ncyA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJaW50IGkgPSAwOwotCQlmb3IgKFN0cmluZyBzdHJpbmcgOiBDb2xsZWN0aW9uVG9vbHMuaXRlcmFibGUoc3RyaW5ncykpIHsKLQkJCWFzc2VydEVxdWFscyhzdHJpbmdzW2krK10sIHN0cmluZyk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SXRlcmF0b3JPYmplY3RBcnJheSgpIHsKLQkJU3RyaW5nW10gYSA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJaW50IGkgPSAwOwotCQlmb3IgKEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gQ29sbGVjdGlvblRvb2xzLml0ZXJhdG9yKGEpOyBzdHJlYW0uaGFzTmV4dCgpOyBpKyspIHsKLQkJCWFzc2VydEVxdWFscyhhW2ldLCBzdHJlYW0ubmV4dCgpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMYXN0SW5kZXhPZkl0ZXJhdG9yT2JqZWN0KCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlhc3NlcnRFcXVhbHMoMSwgQ29sbGVjdGlvblRvb2xzLmxhc3RJbmRleE9mKGxpc3QubGlzdEl0ZXJhdG9yKCksICJvbmUiKSk7Ci0JCWxpc3QuYWRkKG51bGwpOwotCQlhc3NlcnRFcXVhbHMobGlzdC5zaXplKCkgLSAxLCBDb2xsZWN0aW9uVG9vbHMubGFzdEluZGV4T2YobGlzdC5saXN0SXRlcmF0b3IoKSwgbnVsbCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMYXN0SW5kZXhPZkl0ZXJhdG9yT2JqZWN0X0VtcHR5KCkgewotCQlhc3NlcnRFcXVhbHMoLTEsIENvbGxlY3Rpb25Ub29scy5sYXN0SW5kZXhPZihFbXB0eUl0ZXJhdG9yLmluc3RhbmNlKCksICJmb28iKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExhc3RJbmRleE9mT2JqZWN0QXJyYXlPYmplY3QoKSB7Ci0JCU9iamVjdFtdIGEgPSB0aGlzLmJ1aWxkT2JqZWN0QXJyYXkxKCk7Ci0JCWFzc2VydEVxdWFscygxLCBDb2xsZWN0aW9uVG9vbHMubGFzdEluZGV4T2YoYSwgIm9uZSIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGFzdEluZGV4T2ZPYmplY3RBcnJheU9iamVjdF9OdWxsKCkgewotCQlPYmplY3RbXSBhID0gdGhpcy5idWlsZE9iamVjdEFycmF5MSgpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCBudWxsKTsKLQkJYXNzZXJ0RXF1YWxzKGEubGVuZ3RoIC0gMSwgQ29sbGVjdGlvblRvb2xzLmxhc3RJbmRleE9mKGEsIG51bGwpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGFzdEluZGV4T2ZDaGFyQXJyYXlDaGFyKCkgewotCQljaGFyW10gYSA9IHRoaXMuYnVpbGRDaGFyQXJyYXkoKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIENvbGxlY3Rpb25Ub29scy5sYXN0SW5kZXhPZihhLCAnYicpKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGQoYSwgJ2QnKTsKLQkJYXNzZXJ0RXF1YWxzKGEubGVuZ3RoIC0gMSwgQ29sbGVjdGlvblRvb2xzLmxhc3RJbmRleE9mKGEsICdkJykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMYXN0SW5kZXhPZkludEFycmF5SW50KCkgewotCQlpbnRbXSBhID0gdGhpcy5idWlsZEludEFycmF5KCk7Ci0JCWFzc2VydEVxdWFscygxLCBDb2xsZWN0aW9uVG9vbHMubGFzdEluZGV4T2YoYSwgMTApKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGQoYSwgMzApOwotCQlhc3NlcnRFcXVhbHMoYS5sZW5ndGggLSAxLCBDb2xsZWN0aW9uVG9vbHMubGFzdEluZGV4T2YoYSwgMzApKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdEl0ZXJhYmxlKCkgewotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKSwgQ29sbGVjdGlvblRvb2xzLmxpc3QoaXRlcmFibGUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdEl0ZXJhYmxlSW50KCkgewotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKSwgQ29sbGVjdGlvblRvb2xzLmxpc3QoaXRlcmFibGUsIDMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdEl0ZXJhdG9yX1N0cmluZygpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QgPSBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLCBsaXN0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdEl0ZXJhdG9yX1N0cmluZ09iamVjdCgpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QxID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWxpc3QxLmFkZCgiMCIpOwotCQlsaXN0MS5hZGQoIjEiKTsKLQkJbGlzdDEuYWRkKCIyIik7Ci0JCWxpc3QxLmFkZCgiMyIpOwotCi0JCUxpc3Q8T2JqZWN0PiBsaXN0MiA9IENvbGxlY3Rpb25Ub29scy48T2JqZWN0Pmxpc3QobGlzdDEuaXRlcmF0b3IoKSk7Ci0JCWFzc2VydEVxdWFscyhsaXN0MSwgbGlzdDIpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0SXRlcmF0b3JfRW1wdHkoKSB7Ci0JCWFzc2VydEVxdWFscygwLCBDb2xsZWN0aW9uVG9vbHMubGlzdChFbXB0eUl0ZXJhdG9yLmluc3RhbmNlKCkpLnNpemUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RJdGVyYXRvckludCgpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QgPSBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpLCAzKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLCBsaXN0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdEl0ZXJhdG9ySW50X0VtcHR5KCkgewotCQlhc3NlcnRFcXVhbHMoMCwgQ29sbGVjdGlvblRvb2xzLmxpc3QoRW1wdHlJdGVyYXRvci5pbnN0YW5jZSgpLCA1KS5zaXplKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0T2JqZWN0QXJyYXkoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0ID0gQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5idWlsZFN0cmluZ0FycmF5MSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLCBsaXN0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdEl0ZXJhdG9yT2JqZWN0QXJyYXkoKSB7Ci0JCVN0cmluZ1tdIGEgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCk7Ci0JCWludCBpID0gMDsKLQkJZm9yIChMaXN0SXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSBDb2xsZWN0aW9uVG9vbHMubGlzdEl0ZXJhdG9yKGEpOyBzdHJlYW0uaGFzTmV4dCgpOyBpKyspIHsKLQkJCWFzc2VydEVxdWFscyhhW2ldLCBzdHJlYW0ubmV4dCgpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0SXRlcmF0b3JPYmplY3RBcnJheUludCgpIHsKLQkJU3RyaW5nW10gYSA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJaW50IGkgPSAxOwotCQlmb3IgKExpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IENvbGxlY3Rpb25Ub29scy5saXN0SXRlcmF0b3IoYSwgMSk7IHN0cmVhbS5oYXNOZXh0KCk7IGkrKykgewotCQkJYXNzZXJ0RXF1YWxzKGFbaV0sIHN0cmVhbS5uZXh0KCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE1heENoYXJBcnJheSgpIHsKLQkJYXNzZXJ0RXF1YWxzKCdjJywgQ29sbGVjdGlvblRvb2xzLm1heCh0aGlzLmJ1aWxkQ2hhckFycmF5KCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TWF4SW50QXJyYXkoKSB7Ci0JCWFzc2VydEVxdWFscygyMCwgQ29sbGVjdGlvblRvb2xzLm1heCh0aGlzLmJ1aWxkSW50QXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RNaW5DaGFyQXJyYXkoKSB7Ci0JCWFzc2VydEVxdWFscygnYScsIENvbGxlY3Rpb25Ub29scy5taW4odGhpcy5idWlsZENoYXJBcnJheSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE1pbkludEFycmF5KCkgewotCQlhc3NlcnRFcXVhbHMoMCwgQ29sbGVjdGlvblRvb2xzLm1pbih0aGlzLmJ1aWxkSW50QXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RNb3ZlT2JqZWN0QXJyYXlJbnRJbnQoKSB7Ci0JCVN0cmluZ1tdIGFycmF5ID0gbmV3IFN0cmluZ1tdIHsgIjAiLCAiMSIsICIyIiwgIjMiLCAiNCIsICI1IiB9OwotCi0JCVN0cmluZ1tdIHJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGFycmF5LCA0LCAyKTsKLQkJYXNzZXJ0U2FtZShhcnJheSwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICIwIiwgIjEiLCAiMyIsICI0IiwgIjIiLCAiNSIgfSwgcmVzdWx0KSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDAsIDUpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIjUiLCAiMCIsICIxIiwgIjMiLCAiNCIsICIyIiB9LCByZXN1bHQpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShhcnJheSwgMiwgNCk7Ci0JCWFzc2VydFNhbWUoYXJyYXksIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiNSIsICIwIiwgIjQiLCAiMSIsICIzIiwgIjIiIH0sIHJlc3VsdCkpOwotCi0JCXJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGFycmF5LCA0LCA0KTsKLQkJYXNzZXJ0U2FtZShhcnJheSwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICI1IiwgIjAiLCAiNCIsICIxIiwgIjMiLCAiMiIgfSwgcmVzdWx0KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE1vdmVPYmplY3RBcnJheUludEludEludCgpIHsKLQkJU3RyaW5nW10gYXJyYXkgPSBuZXcgU3RyaW5nW10geyAiMCIsICIxIiwgIjIiLCAiMyIsICI0IiwgIjUiIH07Ci0KLQkJU3RyaW5nW10gcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDQsIDIsIDEpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIjAiLCAiMSIsICIzIiwgIjQiLCAiMiIsICI1IiB9LCByZXN1bHQpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShhcnJheSwgMCwgNSwgMSk7Ci0JCWFzc2VydFNhbWUoYXJyYXksIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiNSIsICIwIiwgIjEiLCAiMyIsICI0IiwgIjIiIH0sIHJlc3VsdCkpOwotCi0JCXJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGFycmF5LCAyLCA0LCAxKTsKLQkJYXNzZXJ0U2FtZShhcnJheSwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICI1IiwgIjAiLCAiNCIsICIxIiwgIjMiLCAiMiIgfSwgcmVzdWx0KSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDIsIDQsIDIpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIjUiLCAiMCIsICIzIiwgIjIiLCAiNCIsICIxIiB9LCByZXN1bHQpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShhcnJheSwgMCwgMSwgNCk7Ci0JCWFzc2VydFNhbWUoYXJyYXksIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiMCIsICIzIiwgIjIiLCAiNCIsICI1IiwgIjEiIH0sIHJlc3VsdCkpOwotCi0JCXJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGFycmF5LCAxLCAwLCA0KTsKLQkJYXNzZXJ0U2FtZShhcnJheSwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICI1IiwgIjAiLCAiMyIsICIyIiwgIjQiLCAiMSIgfSwgcmVzdWx0KSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDEsIDEsIDQpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIjUiLCAiMCIsICIzIiwgIjIiLCAiNCIsICIxIiB9LCByZXN1bHQpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShhcnJheSwgMSwgMCwgMCk7Ci0JCWFzc2VydFNhbWUoYXJyYXksIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiNSIsICIwIiwgIjMiLCAiMiIsICI0IiwgIjEiIH0sIHJlc3VsdCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RNb3ZlSW50QXJyYXlJbnRJbnQoKSB7Ci0JCWludFtdIGFycmF5ID0gbmV3IGludFtdIHsgMCwgMSwgMiwgMywgNCwgNSB9OwotCi0JCWludFtdIHJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGFycmF5LCA0LCAyKTsKLQkJYXNzZXJ0U2FtZShhcnJheSwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBpbnRbXSB7IDAsIDEsIDMsIDQsIDIsIDUgfSwgcmVzdWx0KSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDAsIDUpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGludFtdIHsgNSwgMCwgMSwgMywgNCwgMiB9LCByZXN1bHQpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShhcnJheSwgMiwgNCk7Ci0JCWFzc2VydFNhbWUoYXJyYXksIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgaW50W10geyA1LCAwLCA0LCAxLCAzLCAyIH0sIHJlc3VsdCkpOwotCi0JCXJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGFycmF5LCAyLCAyKTsKLQkJYXNzZXJ0U2FtZShhcnJheSwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBpbnRbXSB7IDUsIDAsIDQsIDEsIDMsIDIgfSwgcmVzdWx0KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE1vdmVJbnRBcnJheUludEludEludCgpIHsKLQkJaW50W10gYXJyYXkgPSBuZXcgaW50W10geyAwLCAxLCAyLCAzLCA0LCA1IH07Ci0KLQkJaW50W10gcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDQsIDIsIDEpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGludFtdIHsgMCwgMSwgMywgNCwgMiwgNSB9LCByZXN1bHQpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShhcnJheSwgMCwgNSwgMSk7Ci0JCWFzc2VydFNhbWUoYXJyYXksIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgaW50W10geyA1LCAwLCAxLCAzLCA0LCAyIH0sIHJlc3VsdCkpOwotCi0JCXJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGFycmF5LCAyLCA0LCAxKTsKLQkJYXNzZXJ0U2FtZShhcnJheSwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBpbnRbXSB7IDUsIDAsIDQsIDEsIDMsIDIgfSwgcmVzdWx0KSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDIsIDQsIDIpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGludFtdIHsgNSwgMCwgMywgMiwgNCwgMSB9LCByZXN1bHQpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShhcnJheSwgMCwgMSwgNCk7Ci0JCWFzc2VydFNhbWUoYXJyYXksIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgaW50W10geyAwLCAzLCAyLCA0LCA1LCAxIH0sIHJlc3VsdCkpOwotCi0JCXJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGFycmF5LCAxLCAwLCA0KTsKLQkJYXNzZXJ0U2FtZShhcnJheSwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBpbnRbXSB7IDUsIDAsIDMsIDIsIDQsIDEgfSwgcmVzdWx0KSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDEsIDEsIDQpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGludFtdIHsgNSwgMCwgMywgMiwgNCwgMSB9LCByZXN1bHQpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShhcnJheSwgMSwgMCwgMCk7Ci0JCWFzc2VydFNhbWUoYXJyYXksIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgaW50W10geyA1LCAwLCAzLCAyLCA0LCAxIH0sIHJlc3VsdCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RNb3ZlQ2hhckFycmF5SW50SW50KCkgewotCQljaGFyW10gYXJyYXkgPSBuZXcgY2hhcltdIHsgJ2EnLCAnYicsICdjJywgJ2QnLCAnZScsICdmJyB9OwotCi0JCWNoYXJbXSByZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShhcnJheSwgNCwgMik7Ci0JCWFzc2VydFNhbWUoYXJyYXksIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgY2hhcltdIHsgJ2EnLCAnYicsICdkJywgJ2UnLCAnYycsICdmJyB9LCByZXN1bHQpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShhcnJheSwgMCwgNSk7Ci0JCWFzc2VydFNhbWUoYXJyYXksIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgY2hhcltdIHsgJ2YnLCAnYScsICdiJywgJ2QnLCAnZScsICdjJyB9LCByZXN1bHQpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShhcnJheSwgMiwgNCk7Ci0JCWFzc2VydFNhbWUoYXJyYXksIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgY2hhcltdIHsgJ2YnLCAnYScsICdlJywgJ2InLCAnZCcsICdjJyB9LCByZXN1bHQpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShhcnJheSwgMiwgMik7Ci0JCWFzc2VydFNhbWUoYXJyYXksIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgY2hhcltdIHsgJ2YnLCAnYScsICdlJywgJ2InLCAnZCcsICdjJyB9LCByZXN1bHQpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TW92ZUNoYXJBcnJheUludEludEludCgpIHsKLQkJY2hhcltdIGFycmF5ID0gbmV3IGNoYXJbXSB7ICdhJywgJ2InLCAnYicsICdjJywgJ2QnLCAnZScgfTsKLQotCQljaGFyW10gcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDQsIDIsIDEpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGNoYXJbXSB7ICdhJywgJ2InLCAnYycsICdkJywgJ2InLCAnZScgfSwgcmVzdWx0KSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDAsIDUsIDEpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGNoYXJbXSB7ICdlJywgJ2EnLCAnYicsICdjJywgJ2QnLCAnYicgfSwgcmVzdWx0KSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDIsIDQsIDEpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGNoYXJbXSB7ICdlJywgJ2EnLCAnZCcsICdiJywgJ2MnLCAnYicgfSwgcmVzdWx0KSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDIsIDQsIDIpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGNoYXJbXSB7ICdlJywgJ2EnLCAnYycsICdiJywgJ2QnLCAnYicgfSwgcmVzdWx0KSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDAsIDEsIDQpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGNoYXJbXSB7ICdhJywgJ2MnLCAnYicsICdkJywgJ2UnLCAnYicgfSwgcmVzdWx0KSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDEsIDAsIDQpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGNoYXJbXSB7ICdlJywgJ2EnLCAnYycsICdiJywgJ2QnLCAnYicgfSwgcmVzdWx0KSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDEsIDEsIDQpOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGNoYXJbXSB7ICdlJywgJ2EnLCAnYycsICdiJywgJ2QnLCAnYicgfSwgcmVzdWx0KSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUoYXJyYXksIDEsIDAsIDApOwotCQlhc3NlcnRTYW1lKGFycmF5LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGNoYXJbXSB7ICdlJywgJ2EnLCAnYycsICdiJywgJ2QnLCAnYicgfSwgcmVzdWx0KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE1vdmVMaXN0SW50SW50UmFuZG9tQWNjZXNzKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKGxpc3QsIG5ldyBTdHJpbmdbXSB7ICIwIiwgIjEiLCAiMiIsICIzIiwgIjQiLCAiNSIgfSk7Ci0KLQkJTGlzdDxTdHJpbmc+IHJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGxpc3QsIDQsIDIpOwotCQlhc3NlcnRTYW1lKGxpc3QsIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiMCIsICIxIiwgIjMiLCAiNCIsICIyIiwgIjUiIH0sIHJlc3VsdC50b0FycmF5KCkpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShsaXN0LCAwLCA1KTsKLQkJYXNzZXJ0U2FtZShsaXN0LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIjUiLCAiMCIsICIxIiwgIjMiLCAiNCIsICIyIiB9LCByZXN1bHQudG9BcnJheSgpKSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUobGlzdCwgMiwgNCk7Ci0JCWFzc2VydFNhbWUobGlzdCwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICI1IiwgIjAiLCAiNCIsICIxIiwgIjMiLCAiMiIgfSwgcmVzdWx0LnRvQXJyYXkoKSkpOwotCi0JCXJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGxpc3QsIDIsIDIpOwotCQlhc3NlcnRTYW1lKGxpc3QsIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiNSIsICIwIiwgIjQiLCAiMSIsICIzIiwgIjIiIH0sIHJlc3VsdC50b0FycmF5KCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TW92ZUxpc3RJbnRJbnRTZXF1ZW50aWFsQWNjZXNzKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IG5ldyBMaW5rZWRMaXN0PFN0cmluZz4oKTsKLQkJQ29sbGVjdGlvblRvb2xzLmFkZEFsbChsaXN0LCBuZXcgU3RyaW5nW10geyAiMCIsICIxIiwgIjIiLCAiMyIsICI0IiwgIjUiIH0pOwotCi0JCUxpc3Q8U3RyaW5nPiByZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShsaXN0LCA0LCAyKTsKLQkJYXNzZXJ0U2FtZShsaXN0LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIjAiLCAiMSIsICIzIiwgIjQiLCAiMiIsICI1IiB9LCByZXN1bHQudG9BcnJheSgpKSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUobGlzdCwgMCwgNSk7Ci0JCWFzc2VydFNhbWUobGlzdCwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICI1IiwgIjAiLCAiMSIsICIzIiwgIjQiLCAiMiIgfSwgcmVzdWx0LnRvQXJyYXkoKSkpOwotCi0JCXJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGxpc3QsIDIsIDQpOwotCQlhc3NlcnRTYW1lKGxpc3QsIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiNSIsICIwIiwgIjQiLCAiMSIsICIzIiwgIjIiIH0sIHJlc3VsdC50b0FycmF5KCkpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShsaXN0LCAyLCAyKTsKLQkJYXNzZXJ0U2FtZShsaXN0LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIjUiLCAiMCIsICI0IiwgIjEiLCAiMyIsICIyIiB9LCByZXN1bHQudG9BcnJheSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE1vdmVMaXN0SW50SW50SW50UmFuZG9tQWNjZXNzKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPihBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICIwIiwgIjEiLCAiMiIsICIzIiwgIjQiLCAiNSIgfSkpOwotCi0JCUxpc3Q8U3RyaW5nPiByZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShsaXN0LCA0LCAyLCAxKTsKLQkJYXNzZXJ0U2FtZShsaXN0LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIjAiLCAiMSIsICIzIiwgIjQiLCAiMiIsICI1IiB9LCByZXN1bHQudG9BcnJheSgpKSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUobGlzdCwgMCwgNSwgMSk7Ci0JCWFzc2VydFNhbWUobGlzdCwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICI1IiwgIjAiLCAiMSIsICIzIiwgIjQiLCAiMiIgfSwgcmVzdWx0LnRvQXJyYXkoKSkpOwotCi0JCXJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGxpc3QsIDIsIDQsIDEpOwotCQlhc3NlcnRTYW1lKGxpc3QsIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiNSIsICIwIiwgIjQiLCAiMSIsICIzIiwgIjIiIH0sIHJlc3VsdC50b0FycmF5KCkpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShsaXN0LCAyLCA0LCAyKTsKLQkJYXNzZXJ0U2FtZShsaXN0LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIjUiLCAiMCIsICIzIiwgIjIiLCAiNCIsICIxIiB9LCByZXN1bHQudG9BcnJheSgpKSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUobGlzdCwgMCwgMSwgNCk7Ci0JCWFzc2VydFNhbWUobGlzdCwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICIwIiwgIjMiLCAiMiIsICI0IiwgIjUiLCAiMSIgfSwgcmVzdWx0LnRvQXJyYXkoKSkpOwotCi0JCXJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGxpc3QsIDEsIDAsIDQpOwotCQlhc3NlcnRTYW1lKGxpc3QsIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiNSIsICIwIiwgIjMiLCAiMiIsICI0IiwgIjEiIH0sIHJlc3VsdC50b0FycmF5KCkpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShsaXN0LCAxLCAxLCA0KTsKLQkJYXNzZXJ0U2FtZShsaXN0LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIjUiLCAiMCIsICIzIiwgIjIiLCAiNCIsICIxIiB9LCByZXN1bHQudG9BcnJheSgpKSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUobGlzdCwgMSwgMCwgMCk7Ci0JCWFzc2VydFNhbWUobGlzdCwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICI1IiwgIjAiLCAiMyIsICIyIiwgIjQiLCAiMSIgfSwgcmVzdWx0LnRvQXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RNb3ZlTGlzdEludEludEludFNlcXVlbnRpYWxBY2Nlc3MoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0ID0gbmV3IExpbmtlZExpc3Q8U3RyaW5nPihBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICIwIiwgIjEiLCAiMiIsICIzIiwgIjQiLCAiNSIgfSkpOwotCi0JCUxpc3Q8U3RyaW5nPiByZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShsaXN0LCA0LCAyLCAxKTsKLQkJYXNzZXJ0U2FtZShsaXN0LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIjAiLCAiMSIsICIzIiwgIjQiLCAiMiIsICI1IiB9LCByZXN1bHQudG9BcnJheSgpKSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUobGlzdCwgMCwgNSwgMSk7Ci0JCWFzc2VydFNhbWUobGlzdCwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICI1IiwgIjAiLCAiMSIsICIzIiwgIjQiLCAiMiIgfSwgcmVzdWx0LnRvQXJyYXkoKSkpOwotCi0JCXJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGxpc3QsIDIsIDQsIDEpOwotCQlhc3NlcnRTYW1lKGxpc3QsIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiNSIsICIwIiwgIjQiLCAiMSIsICIzIiwgIjIiIH0sIHJlc3VsdC50b0FycmF5KCkpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShsaXN0LCAyLCA0LCAyKTsKLQkJYXNzZXJ0U2FtZShsaXN0LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIjUiLCAiMCIsICIzIiwgIjIiLCAiNCIsICIxIiB9LCByZXN1bHQudG9BcnJheSgpKSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUobGlzdCwgMCwgMSwgNCk7Ci0JCWFzc2VydFNhbWUobGlzdCwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICIwIiwgIjMiLCAiMiIsICI0IiwgIjUiLCAiMSIgfSwgcmVzdWx0LnRvQXJyYXkoKSkpOwotCi0JCXJlc3VsdCA9IENvbGxlY3Rpb25Ub29scy5tb3ZlKGxpc3QsIDEsIDAsIDQpOwotCQlhc3NlcnRTYW1lKGxpc3QsIHJlc3VsdCk7ICAvLyB0aGUgYXJyYXkgaXMgbW9kaWZpZWQgaW4gcGxhY2UgYW5kIHJldHVybmVkCi0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiNSIsICIwIiwgIjMiLCAiMiIsICI0IiwgIjEiIH0sIHJlc3VsdC50b0FycmF5KCkpKTsKLQotCQlyZXN1bHQgPSBDb2xsZWN0aW9uVG9vbHMubW92ZShsaXN0LCAxLCAxLCA0KTsKLQkJYXNzZXJ0U2FtZShsaXN0LCByZXN1bHQpOyAgLy8gdGhlIGFycmF5IGlzIG1vZGlmaWVkIGluIHBsYWNlIGFuZCByZXR1cm5lZAotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIjUiLCAiMCIsICIzIiwgIjIiLCAiNCIsICIxIiB9LCByZXN1bHQudG9BcnJheSgpKSk7Ci0KLQkJcmVzdWx0ID0gQ29sbGVjdGlvblRvb2xzLm1vdmUobGlzdCwgMSwgMCwgMCk7Ci0JCWFzc2VydFNhbWUobGlzdCwgcmVzdWx0KTsgIC8vIHRoZSBhcnJheSBpcyBtb2RpZmllZCBpbiBwbGFjZSBhbmQgcmV0dXJuZWQKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICI1IiwgIjAiLCAiMyIsICIyIiwgIjQiLCAiMSIgfSwgcmVzdWx0LnRvQXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVBbGxPYmplY3RBcnJheU9iamVjdEFycmF5KCkgewotCQlTdHJpbmdbXSBhMSA9IG5ldyBTdHJpbmdbXSB7ICJBIiwgIkEiLCAiQiIsICJCIiwgIkMiLCAiQyIsICJEIiwgIkQiLCAiRSIsICJFIiwgIkYiLCAiRiIgfTsKLQkJU3RyaW5nW10gYTIgPSBuZXcgU3RyaW5nW10geyAiRSIsICJCIiB9OwotCQlTdHJpbmdbXSBhMyA9IENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGwoYTEsIGEyKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICJBIiwgIkEiLCAiQyIsICJDIiwgIkQiLCAiRCIsICJGIiwgIkYiIH0sIGEzKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbE9iamVjdEFycmF5T2JqZWN0QXJyYXlfRW1wdHkoKSB7Ci0JCVN0cmluZ1tdIGExID0gbmV3IFN0cmluZ1tdIHsgIkEiLCAiQSIsICJCIiwgIkIiLCAiQyIsICJDIiwgIkQiLCAiRCIsICJFIiwgIkUiLCAiRiIsICJGIiB9OwotCQlTdHJpbmdbXSBhMiA9IG5ldyBTdHJpbmdbMF07Ci0JCVN0cmluZ1tdIGEzID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbChhMSwgYTIpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoYTEsIGEzKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbE9iamVjdEFycmF5T2JqZWN0QXJyYXlfTm9NYXRjaGVzKCkgewotCQlTdHJpbmdbXSBhMSA9IG5ldyBTdHJpbmdbXSB7ICJBIiwgIkEiLCAiQiIsICJCIiwgIkMiLCAiQyIsICJEIiwgIkQiLCAiRSIsICJFIiwgIkYiLCAiRiIgfTsKLQkJU3RyaW5nW10gYTIgPSBuZXcgU3RyaW5nW10geyAiWCIsICJZIiwgIloiIH07Ci0JCVN0cmluZ1tdIGEzID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbChhMSwgYTIpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoYTEsIGEzKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbE9iamVjdEFycmF5SXRlcmFibGUoKSB7Ci0JCVN0cmluZ1tdIGExID0gbmV3IFN0cmluZ1tdIHsgIkEiLCAiQSIsICJCIiwgIkIiLCAiQyIsICJDIiwgIkQiLCAiRCIsICJFIiwgIkUiLCAiRiIsICJGIiB9OwotCQlJdGVyYWJsZTw/PiBpdGVyYWJsZSA9IEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgIkUiLCAiQiIgfSk7Ci0JCVN0cmluZ1tdIGEzID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbChhMSwgaXRlcmFibGUpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIkEiLCAiQSIsICJDIiwgIkMiLCAiRCIsICJEIiwgIkYiLCAiRiIgfSwgYTMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQWxsT2JqZWN0QXJyYXlJdGVyYWJsZUludCgpIHsKLQkJU3RyaW5nW10gYTEgPSBuZXcgU3RyaW5nW10geyAiQSIsICJBIiwgIkIiLCAiQiIsICJDIiwgIkMiLCAiRCIsICJEIiwgIkUiLCAiRSIsICJGIiwgIkYiIH07Ci0JCUl0ZXJhYmxlPD8+IGl0ZXJhYmxlID0gQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAiRSIsICJCIiB9KTsKLQkJU3RyaW5nW10gYTMgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsKGExLCBpdGVyYWJsZSwgNyk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiQSIsICJBIiwgIkMiLCAiQyIsICJEIiwgIkQiLCAiRiIsICJGIiB9LCBhMykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVBbGxPYmplY3RBcnJheUl0ZXJhdG9yKCkgewotCQlTdHJpbmdbXSBhMSA9IG5ldyBTdHJpbmdbXSB7ICJBIiwgIkEiLCAiQiIsICJCIiwgIkMiLCAiQyIsICJEIiwgIkQiLCAiRSIsICJFIiwgIkYiLCAiRiIgfTsKLQkJSXRlcmFibGU8Pz4gaXRlcmFibGUgPSBBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJFIiwgIkIiIH0pOwotCQlTdHJpbmdbXSBhMyA9IENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGwoYTEsIGl0ZXJhYmxlLml0ZXJhdG9yKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIkEiLCAiQSIsICJDIiwgIkMiLCAiRCIsICJEIiwgIkYiLCAiRiIgfSwgYTMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQWxsT2JqZWN0QXJyYXlJdGVyYXRvckludCgpIHsKLQkJU3RyaW5nW10gYTEgPSBuZXcgU3RyaW5nW10geyAiQSIsICJBIiwgIkIiLCAiQiIsICJDIiwgIkMiLCAiRCIsICJEIiwgIkUiLCAiRSIsICJGIiwgIkYiIH07Ci0JCUl0ZXJhYmxlPD8+IGl0ZXJhYmxlID0gQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAiRSIsICJCIiB9KTsKLQkJU3RyaW5nW10gYTMgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsKGExLCBpdGVyYWJsZS5pdGVyYXRvcigpLCA3KTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICJBIiwgIkEiLCAiQyIsICJDIiwgIkQiLCAiRCIsICJGIiwgIkYiIH0sIGEzKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbE9iamVjdEFycmF5Q29sbGVjdGlvbigpIHsKLQkJU3RyaW5nW10gYTEgPSBuZXcgU3RyaW5nW10geyAiQSIsICJBIiwgIkIiLCAiQiIsICJDIiwgIkMiLCAiRCIsICJEIiwgIkUiLCAiRSIsICJGIiwgIkYiIH07Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjb2xsZWN0aW9uID0gQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAiRSIsICJCIiB9KTsKLQkJU3RyaW5nW10gYTMgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsKGExLCBjb2xsZWN0aW9uKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICJBIiwgIkEiLCAiQyIsICJDIiwgIkQiLCAiRCIsICJGIiwgIkYiIH0sIGEzKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbE9iamVjdEFycmF5Q29sbGVjdGlvbl9FbXB0eSgpIHsKLQkJU3RyaW5nW10gYTEgPSBuZXcgU3RyaW5nW10geyAiQSIsICJBIiwgIkIiLCAiQiIsICJDIiwgIkMiLCAiRCIsICJEIiwgIkUiLCAiRSIsICJGIiwgIkYiIH07Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjb2xsZWN0aW9uID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCVN0cmluZ1tdIGEzID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbChhMSwgY29sbGVjdGlvbik7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhhMSwgYTMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQWxsT2JqZWN0QXJyYXlDb2xsZWN0aW9uX05vTWF0Y2hlcygpIHsKLQkJU3RyaW5nW10gYTEgPSBuZXcgU3RyaW5nW10geyAiQSIsICJBIiwgIkIiLCAiQiIsICJDIiwgIkMiLCAiRCIsICJEIiwgIkUiLCAiRSIsICJGIiwgIkYiIH07Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjb2xsZWN0aW9uID0gQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAiWCIsICJZIiwgIloiIH0pOwotCQlTdHJpbmdbXSBhMyA9IENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGwoYTEsIGNvbGxlY3Rpb24pOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoYTEsIGEzKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbENoYXJBcnJheUNoYXJBcnJheSgpIHsKLQkJY2hhcltdIGExID0gbmV3IGNoYXJbXSB7ICdBJywgJ0EnLCAnQicsICdCJywgJ0MnLCAnQycsICdEJywgJ0QnLCAnRScsICdFJywgJ0YnLCAnRicgfTsKLQkJY2hhcltdIGEyID0gbmV3IGNoYXJbXSB7ICdFJywgJ0InIH07Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgY2hhcltdIHsgJ0EnLCAnQScsICdDJywgJ0MnLCAnRCcsICdEJywgJ0YnLCAnRicgfSwgQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbChhMSwgYTIpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbENoYXJBcnJheUNoYXJBcnJheV9FbXB0eSgpIHsKLQkJY2hhcltdIGExID0gbmV3IGNoYXJbXSB7ICdBJywgJ0EnLCAnQicsICdCJywgJ0MnLCAnQycsICdEJywgJ0QnLCAnRScsICdFJywgJ0YnLCAnRicgfTsKLQkJY2hhcltdIGEyID0gbmV3IGNoYXJbMF07Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhhMSwgQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbChhMSwgYTIpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbENoYXJBcnJheUNoYXJBcnJheV9Ob01hdGNoZXMoKSB7Ci0JCWNoYXJbXSBhMSA9IG5ldyBjaGFyW10geyAnQScsICdBJywgJ0InLCAnQicsICdDJywgJ0MnLCAnRCcsICdEJywgJ0UnLCAnRScsICdGJywgJ0YnIH07Ci0JCWNoYXJbXSBhMiA9IG5ldyBjaGFyW10geyAnWCcsICdaJyB9OwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoYTEsIENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGwoYTEsIGEyKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVBbGxJbnRBcnJheUludEFycmF5KCkgewotCQlpbnRbXSBhMSA9IG5ldyBpbnRbXSB7IDEsIDEsIDIsIDIsIDMsIDMsIDQsIDQsIDUsIDUsIDYsIDYgfTsKLQkJaW50W10gYTIgPSBuZXcgaW50W10geyA1LCAyIH07Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgaW50W10geyAxLCAxLCAzLCAzLCA0LCA0LCA2LCA2IH0sIENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGwoYTEsIGEyKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVBbGxJbnRBcnJheUludEFycmF5X0VtcHR5KCkgewotCQlpbnRbXSBhMSA9IG5ldyBpbnRbXSB7IDEsIDEsIDIsIDIsIDMsIDMsIDQsIDQsIDUsIDUsIDYsIDYgfTsKLQkJaW50W10gYTIgPSBuZXcgaW50WzBdOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoYTEsIENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGwoYTEsIGEyKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVBbGxJbnRBcnJheUludEFycmF5X05vTWF0Y2hlcygpIHsKLQkJaW50W10gYTEgPSBuZXcgaW50W10geyAxLCAxLCAyLCAyLCAzLCAzLCA0LCA0LCA1LCA1LCA2LCA2IH07Ci0JCWludFtdIGEyID0gbmV3IGludFtdIHsgNTIsIDY3IH07Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhhMSwgQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbChhMSwgYTIpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZU9iamVjdEFycmF5T2JqZWN0X09iamVjdCgpIHsKLQkJT2JqZWN0W10gYSA9IHRoaXMuYnVpbGRPYmplY3RBcnJheTEoKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGQoYSwgInRocmVlIik7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsICJmb3VyIik7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsICJmaXZlIik7Ci0KLQkJYXNzZXJ0RXF1YWxzKDYsIGEubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgInRocmVlIikpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZShhLCAidGhyZWUiKTsKLQkJYXNzZXJ0RXF1YWxzKDUsIGEubGVuZ3RoKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICJ0aHJlZSIpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgImZvdXIiKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICJmaXZlIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVPYmplY3RBcnJheU9iamVjdF9TdHJpbmcoKSB7Ci0JCVN0cmluZ1tdIGEgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsICJ0aHJlZSIpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCAiZm91ciIpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCAiZml2ZSIpOwotCi0JCWFzc2VydEVxdWFscyg2LCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICJ0aHJlZSIpKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5yZW1vdmUoYSwgInRocmVlIik7Ci0JCWFzc2VydEVxdWFscyg1LCBhLmxlbmd0aCk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAidGhyZWUiKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICJmb3VyIikpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAiZml2ZSIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQ2hhckFycmF5Q2hhcigpIHsKLQkJY2hhcltdIGEgPSB0aGlzLmJ1aWxkQ2hhckFycmF5KCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsICdkJyk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsICdlJyk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsICdmJyk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDYsIGEubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgJ2QnKSk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlKGEsICdkJyk7Ci0JCWFzc2VydEVxdWFscyg1LCBhLmxlbmd0aCk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAnZCcpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgJ2UnKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsICdmJykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVJbnRBcnJheUludCgpIHsKLQkJaW50W10gYSA9IHRoaXMuYnVpbGRJbnRBcnJheSgpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCAzMCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsIDQwKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGQoYSwgNTApOwotCi0JCWFzc2VydEVxdWFscyg2LCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsIDMwKSk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlKGEsIDMwKTsKLQkJYXNzZXJ0RXF1YWxzKDUsIGEubGVuZ3RoKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsIDMwKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsIDQwKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsIDUwKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbENvbGxlY3Rpb25JdGVyYWJsZSgpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGwoYywgaXRlcmFibGUpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0RmFsc2UoYy5jb250YWlucygib25lIikpOwotCQlhc3NlcnRGYWxzZShjLmNvbnRhaW5zKCJ0d28iKSk7Ci0JCWFzc2VydEZhbHNlKGMuY29udGFpbnMoInRocmVlIikpOwotCi0JCWMgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbChjLCBpdGVyYWJsZSkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5idWlsZFN0cmluZ0xpc3QxKCkuc2l6ZSgpLCBjLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKSwgYyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbENvbGxlY3Rpb25JdGVyYWJsZUludCgpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGwoYywgaXRlcmFibGUsIDMpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0RmFsc2UoYy5jb250YWlucygib25lIikpOwotCQlhc3NlcnRGYWxzZShjLmNvbnRhaW5zKCJ0d28iKSk7Ci0JCWFzc2VydEZhbHNlKGMuY29udGFpbnMoInRocmVlIikpOwotCi0JCWMgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbChjLCBpdGVyYWJsZSwgMykpOwotCQlhc3NlcnRFcXVhbHModGhpcy5idWlsZFN0cmluZ0xpc3QxKCkuc2l6ZSgpLCBjLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKSwgYyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbENvbGxlY3Rpb25JdGVyYXRvcl9FbXB0eSgpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsKGMsIHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0RmFsc2UoYy5jb250YWlucygib25lIikpOwotCQlhc3NlcnRGYWxzZShjLmNvbnRhaW5zKCJ0d28iKSk7Ci0JCWFzc2VydEZhbHNlKGMuY29udGFpbnMoInRocmVlIikpOwotCi0JCWMgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbChjLCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKS5pdGVyYXRvcigpKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5zaXplKCksIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLCBjKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQWxsQ29sbGVjdGlvbkl0ZXJhdG9yX0R1cGxpY2F0ZXMoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWMuYWRkKCJhIik7Ci0JCWMuYWRkKCJhIik7Ci0JCWMuYWRkKCJiIik7Ci0JCWMuYWRkKCJjIik7Ci0JCWMuYWRkKCJkIik7Ci0JCWMuYWRkKCJkIik7Ci0JCVN0cmluZ1tdIGEgPSBuZXcgU3RyaW5nW10geyAiYSIsICJkIiB9OwotCQlJdGVyYXRvcjxTdHJpbmc+IGl0ZXJhdG9yID0gbmV3IEFycmF5SXRlcmF0b3I8U3RyaW5nPihhKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsKGMsIGl0ZXJhdG9yKSk7Ci0JCWFzc2VydEVxdWFscygyLCBjLnNpemUoKSk7Ci0JCWFzc2VydEZhbHNlKGMuY29udGFpbnMoImEiKSk7Ci0JCWFzc2VydFRydWUoYy5jb250YWlucygiYiIpKTsKLQkJYXNzZXJ0VHJ1ZShjLmNvbnRhaW5zKCJjIikpOwotCQlhc3NlcnRGYWxzZShjLmNvbnRhaW5zKCJkIikpOwotCi0JCWl0ZXJhdG9yID0gbmV3IEFycmF5SXRlcmF0b3I8U3RyaW5nPihhKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbChjLCBpdGVyYXRvcikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVBbGxDb2xsZWN0aW9uSXRlcmF0b3JfT2JqZWN0U3RyaW5nKCkgewotCQlDb2xsZWN0aW9uPE9iamVjdD4gYyA9IG5ldyBBcnJheUxpc3Q8T2JqZWN0PigpOwotCQljLmFkZCgiYSIpOwotCQljLmFkZCgiYSIpOwotCQljLmFkZCgiYiIpOwotCQljLmFkZCgiYyIpOwotCQljLmFkZCgiZCIpOwotCQljLmFkZCgiZCIpOwotCQlTdHJpbmdbXSBhID0gbmV3IFN0cmluZ1tdIHsgImEiLCAiZCIgfTsKLQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IG5ldyBBcnJheUl0ZXJhdG9yPFN0cmluZz4oYSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbChjLCBpdGVyYXRvcikpOwotCQlhc3NlcnRFcXVhbHMoMiwgYy5zaXplKCkpOwotCQlhc3NlcnRGYWxzZShjLmNvbnRhaW5zKCJhIikpOwotCQlhc3NlcnRUcnVlKGMuY29udGFpbnMoImIiKSk7Ci0JCWFzc2VydFRydWUoYy5jb250YWlucygiYyIpKTsKLQkJYXNzZXJ0RmFsc2UoYy5jb250YWlucygiZCIpKTsKLQotCQlpdGVyYXRvciA9IG5ldyBBcnJheUl0ZXJhdG9yPFN0cmluZz4oYSk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGwoYywgaXRlcmF0b3IpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQWxsQ29sbGVjdGlvbkl0ZXJhdG90SW50KCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQljLmFkZCgiYSIpOwotCQljLmFkZCgiYSIpOwotCQljLmFkZCgiYiIpOwotCQljLmFkZCgiYyIpOwotCQljLmFkZCgiZCIpOwotCQljLmFkZCgiZCIpOwotCQlTdHJpbmdbXSBhID0gbmV3IFN0cmluZ1tdIHsgImEiLCAiZCIgfTsKLQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IG5ldyBBcnJheUl0ZXJhdG9yPFN0cmluZz4oYSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbChjLCBpdGVyYXRvciwgMikpOwotCQlhc3NlcnRFcXVhbHMoMiwgYy5zaXplKCkpOwotCQlhc3NlcnRGYWxzZShjLmNvbnRhaW5zKCJhIikpOwotCQlhc3NlcnRUcnVlKGMuY29udGFpbnMoImIiKSk7Ci0JCWFzc2VydFRydWUoYy5jb250YWlucygiYyIpKTsKLQkJYXNzZXJ0RmFsc2UoYy5jb250YWlucygiZCIpKTsKLQotCQlpdGVyYXRvciA9IG5ldyBBcnJheUl0ZXJhdG9yPFN0cmluZz4oYSk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGwoYywgaXRlcmF0b3IpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQWxsQ29sbGVjdGlvbk9iamVjdEFycmF5X0VtcHR5KCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGwoYywgdGhpcy5idWlsZE9iamVjdEFycmF5MSgpKSk7Ci0JCWFzc2VydEVxdWFscygwLCBjLnNpemUoKSk7Ci0JCWFzc2VydEZhbHNlKGMuY29udGFpbnMoIm9uZSIpKTsKLQkJYXNzZXJ0RmFsc2UoYy5jb250YWlucygidHdvIikpOwotCQlhc3NlcnRGYWxzZShjLmNvbnRhaW5zKCJ0aHJlZSIpKTsKLQotCQljID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGwoYywgdGhpcy5idWlsZE9iamVjdEFycmF5MigpKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5zaXplKCksIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLCBjKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQWxsQ29sbGVjdGlvbk9iamVjdEFycmF5X0R1cGxpY2F0ZXMoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWMuYWRkKCJhIik7Ci0JCWMuYWRkKCJhIik7Ci0JCWMuYWRkKCJiIik7Ci0JCWMuYWRkKCJjIik7Ci0JCWMuYWRkKCJkIik7Ci0JCWMuYWRkKCJkIik7Ci0JCVN0cmluZ1tdIGEgPSBuZXcgU3RyaW5nW10geyAiYSIsICJkIiB9OwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGwoYywgYSkpOwotCQlhc3NlcnRFcXVhbHMoMiwgYy5zaXplKCkpOwotCQlhc3NlcnRGYWxzZShjLmNvbnRhaW5zKCJhIikpOwotCQlhc3NlcnRUcnVlKGMuY29udGFpbnMoImIiKSk7Ci0JCWFzc2VydFRydWUoYy5jb250YWlucygiYyIpKTsKLQkJYXNzZXJ0RmFsc2UoYy5jb250YWlucygiZCIpKTsKLQotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsKGMsIGEpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQWxsQ29sbGVjdGlvbk9iamVjdEFycmF5X01vcmVEdXBsaWNhdGVzKCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQljLmFkZCgiYSIpOwotCQljLmFkZCgiYiIpOwotCQljLmFkZCgiYyIpOwotCQljLmFkZCgiZCIpOwotCQljLmFkZCgiYSIpOwotCQljLmFkZCgiZCIpOwotCQljLmFkZCgiZCIpOwotCQljLmFkZCgiYSIpOwotCQljLmFkZCgiYyIpOwotCQlTdHJpbmdbXSBhID0gbmV3IFN0cmluZ1tdIHsgImEiLCAiZCIgfTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsKGMsIGEpKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0RmFsc2UoYy5jb250YWlucygiYSIpKTsKLQkJYXNzZXJ0VHJ1ZShjLmNvbnRhaW5zKCJiIikpOwotCQlhc3NlcnRUcnVlKGMuY29udGFpbnMoImMiKSk7Ci0JCWFzc2VydEZhbHNlKGMuY29udGFpbnMoImQiKSk7Ci0KLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbChjLCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbE9jY3VycmVuY2VzQ29sbGVjdGlvbk9iamVjdCgpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbE9jY3VycmVuY2VzKGMsICJ0aHJlZSIpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsT2NjdXJyZW5jZXMoYywgInR3byIpKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbE9jY3VycmVuY2VzKGMsICJ0d28iKSk7Ci0JCWFzc2VydEVxdWFscygyLCBjLnNpemUoKSk7Ci0KLQkJYy5hZGQoImZpdmUiKTsKLQkJYy5hZGQoImZpdmUiKTsKLQkJYy5hZGQoImZpdmUiKTsKLQkJYXNzZXJ0RXF1YWxzKDUsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsT2NjdXJyZW5jZXMoYywgImZpdmUiKSk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGxPY2N1cnJlbmNlcyhjLCAiZml2ZSIpKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGMuc2l6ZSgpKTsKLQotCQljLmFkZChudWxsKTsKLQkJYy5hZGQobnVsbCk7Ci0JCWMuYWRkKG51bGwpOwotCQlhc3NlcnRFcXVhbHMoNSwgYy5zaXplKCkpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGxPY2N1cnJlbmNlcyhjLCBudWxsKSk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGxPY2N1cnJlbmNlcyhjLCBudWxsKSk7Ci0JCWFzc2VydEVxdWFscygyLCBjLnNpemUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbE9jY3VycmVuY2VzT2JqZWN0QXJyYXlPYmplY3QoKSB7Ci0JCVN0cmluZ1tdIGEgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCk7Ci0JCWFzc2VydEVxdWFscygzLCBhLmxlbmd0aCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsT2NjdXJyZW5jZXMoYSwgInRocmVlIik7Ci0JCWFzc2VydEVxdWFscygzLCBhLmxlbmd0aCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsT2NjdXJyZW5jZXMoYSwgInR3byIpOwotCQlhc3NlcnRFcXVhbHMoMiwgYS5sZW5ndGgpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbE9jY3VycmVuY2VzKGEsICJ0d28iKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGEubGVuZ3RoKTsKLQotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCAiZml2ZSIpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCAiZml2ZSIpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCAiZml2ZSIpOwotCQlhc3NlcnRFcXVhbHMoNSwgYS5sZW5ndGgpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbE9jY3VycmVuY2VzKGEsICJmaXZlIik7Ci0JCWFzc2VydEVxdWFscygyLCBhLmxlbmd0aCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsT2NjdXJyZW5jZXMoYSwgImZpdmUiKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGEubGVuZ3RoKTsKLQotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCBudWxsKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGQoYSwgbnVsbCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsIG51bGwpOwotCQlhc3NlcnRFcXVhbHMoNSwgYS5sZW5ndGgpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbE9jY3VycmVuY2VzKGEsIG51bGwpOwotCQlhc3NlcnRFcXVhbHMoMiwgYS5sZW5ndGgpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbE9jY3VycmVuY2VzKGEsIG51bGwpOwotCQlhc3NlcnRFcXVhbHMoMiwgYS5sZW5ndGgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVBbGxPY2N1cnJlbmNlc0NoYXJBcnJheUNoYXIoKSB7Ci0JCWNoYXJbXSBhID0gdGhpcy5idWlsZENoYXJBcnJheSgpOwotCQlhc3NlcnRFcXVhbHMoMywgYS5sZW5ndGgpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbE9jY3VycmVuY2VzKGEsICdkJyk7Ci0JCWFzc2VydEVxdWFscygzLCBhLmxlbmd0aCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsT2NjdXJyZW5jZXMoYSwgJ2InKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGEubGVuZ3RoKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGxPY2N1cnJlbmNlcyhhLCAnYicpOwotCQlhc3NlcnRFcXVhbHMoMiwgYS5sZW5ndGgpOwotCi0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsICdnJyk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsICdnJyk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsICdnJyk7Ci0JCWFzc2VydEVxdWFscyg1LCBhLmxlbmd0aCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsT2NjdXJyZW5jZXMoYSwgJ2cnKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGEubGVuZ3RoKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGxPY2N1cnJlbmNlcyhhLCAnZycpOwotCQlhc3NlcnRFcXVhbHMoMiwgYS5sZW5ndGgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVBbGxPY2N1cnJlbmNlc0ludEFycmF5SW50KCkgewotCQlpbnRbXSBhID0gdGhpcy5idWlsZEludEFycmF5KCk7Ci0JCWFzc2VydEVxdWFscygzLCBhLmxlbmd0aCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsT2NjdXJyZW5jZXMoYSwgNTUpOwotCQlhc3NlcnRFcXVhbHMoMywgYS5sZW5ndGgpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUFsbE9jY3VycmVuY2VzKGEsIDEwKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGEubGVuZ3RoKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGxPY2N1cnJlbmNlcyhhLCAxMCk7Ci0JCWFzc2VydEVxdWFscygyLCBhLmxlbmd0aCk7Ci0KLQkJYSA9IENvbGxlY3Rpb25Ub29scy5hZGQoYSwgNzcpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLmFkZChhLCA3Nyk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMuYWRkKGEsIDc3KTsKLQkJYXNzZXJ0RXF1YWxzKDUsIGEubGVuZ3RoKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5yZW1vdmVBbGxPY2N1cnJlbmNlcyhhLCA3Nyk7Ci0JCWFzc2VydEVxdWFscygyLCBhLmxlbmd0aCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlQWxsT2NjdXJyZW5jZXMoYSwgNzcpOwotCQlhc3NlcnRFcXVhbHMoMiwgYS5sZW5ndGgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVFbGVtZW50QXRJbmRleE9iamVjdEFycmF5SW50KCkgewotCQlTdHJpbmdbXSBhID0gbmV3IFN0cmluZ1tdIHsgIkEiLCAiQiIsICJBIiwgIkMiLCAiQSIsICJEIiB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUVsZW1lbnRBdEluZGV4KGEsIDMpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIkEiLCAiQiIsICJBIiwgIkEiLCAiRCIgfSwgYSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVFbGVtZW50QXRJbmRleENoYXJBcnJheUludCgpIHsKLQkJY2hhcltdIGEgPSBuZXcgY2hhcltdIHsgJ0EnLCAnQicsICdBJywgJ0MnLCAnQScsICdEJyB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUVsZW1lbnRBdEluZGV4KGEsIDMpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGNoYXJbXSB7ICdBJywgJ0InLCAnQScsICdBJywgJ0QnIH0sIGEpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlRWxlbWVudEF0SW5kZXhJbnRBcnJheUludCgpIHsKLQkJaW50W10gYSA9IG5ldyBpbnRbXSB7IDgsIDYsIDcsIDMzLCAyLCAxMSB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUVsZW1lbnRzQXRJbmRleChhLCAzLCAzKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBpbnRbXSB7IDgsIDYsIDcgfSwgYSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVFbGVtZW50c0F0SW5kZXhMaXN0SW50SW50KCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPihBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJBIiwgIkIiLCAiQSIsICJDIiwgIkEiLCAiRCIgfSkpOwotCQlMaXN0PFN0cmluZz4gcmVtb3ZlZCA9IENvbGxlY3Rpb25Ub29scy5yZW1vdmVFbGVtZW50c0F0SW5kZXgobGlzdCwgMywgMik7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiQSIsICJCIiwgIkEiLCAiRCIgfSwgbGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICJDIiwgIkEiIH0sIHJlbW92ZWQudG9BcnJheSgpKSk7Ci0KLQkJbGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPihBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJBIiwgIkIiLCAiQyIsICJEIiwgIkUiLCAiRiIgfSkpOwotCQlyZW1vdmVkID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUVsZW1lbnRzQXRJbmRleChsaXN0LCAzLCAzKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICJBIiwgIkIiLCAiQyIgfSwgbGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICJEIiwgIkUiLCAiRiIgfSwgcmVtb3ZlZC50b0FycmF5KCkpKTsKLQotCQlsaXN0ID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgIkEiLCAiQiIsICJDIiwgIkQiLCAiRSIsICJGIiB9KSk7Ci0JCXJlbW92ZWQgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlRWxlbWVudHNBdEluZGV4KGxpc3QsIDAsIDMpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIkQiLCAiRSIsICJGIiB9LCBsaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIkEiLCAiQiIsICJDIiB9LCByZW1vdmVkLnRvQXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVFbGVtZW50c0F0SW5kZXhPYmplY3RBcnJheUludEludCgpIHsKLQkJU3RyaW5nW10gYSA9IG5ldyBTdHJpbmdbXSB7ICJBIiwgIkIiLCAiQSIsICJDIiwgIkEiLCAiRCIgfTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5yZW1vdmVFbGVtZW50c0F0SW5kZXgoYSwgMywgMik7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiQSIsICJCIiwgIkEiLCAiRCIgfSwgYSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVFbGVtZW50c0F0SW5kZXhPYmplY3RBcnJheUludEludF9FbXB0eSgpIHsKLQkJU3RyaW5nW10gYSA9IG5ldyBTdHJpbmdbXSB7ICJBIiwgIkIiLCAiQSIsICJDIiwgIkEiLCAiRCIgfTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5yZW1vdmVFbGVtZW50c0F0SW5kZXgoYSwgMCwgNik7Ci0JCWFzc2VydEVxdWFscygwLCBhLmxlbmd0aCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUVsZW1lbnRzQXRJbmRleENoYXJBcnJheUludEludCgpIHsKLQkJY2hhcltdIGEgPSBuZXcgY2hhcltdIHsgJ0EnLCAnQicsICdBJywgJ0MnLCAnQScsICdEJyB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUVsZW1lbnRzQXRJbmRleChhLCAwLCA1KTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBjaGFyW10geyAnRCcgfSwgYSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVFbGVtZW50c0F0SW5kZXhDaGFyQXJyYXlJbnRJbnRfRW1wdHkoKSB7Ci0JCWNoYXJbXSBhID0gbmV3IGNoYXJbXSB7ICdBJywgJ0InLCAnQScsICdDJywgJ0EnLCAnRCcgfTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5yZW1vdmVFbGVtZW50c0F0SW5kZXgoYSwgMCwgNik7Ci0JCWFzc2VydEVxdWFscygwLCBhLmxlbmd0aCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUVsZW1lbnRzQXRJbmRleEludEFycmF5SW50SW50KCkgewotCQlpbnRbXSBhID0gbmV3IGludFtdIHsgOCwgNiwgNywgMzMsIDIsIDExIH07Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlRWxlbWVudHNBdEluZGV4KGEsIDMsIDMpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGludFtdIHsgOCwgNiwgNyB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUVsZW1lbnRzQXRJbmRleEludEFycmF5SW50SW50X0VtcHR5KCkgewotCQlpbnRbXSBhID0gbmV3IGludFtdIHsgOCwgNiwgNywgMzMsIDIsIDExIH07Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlRWxlbWVudHNBdEluZGV4KGEsIDAsIDYpOwotCQlhc3NlcnRFcXVhbHMoMCwgYS5sZW5ndGgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXBsYWNlQWxsT2JqZWN0QXJyYXlPYmplY3RPYmplY3RfT2JqZWN0KCkgewotCQlPYmplY3RbXSBhID0gbmV3IE9iamVjdFtdIHsgIkEiLCAiQiIsICJBIiwgIkMiLCAiQSIsICJEIiB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJlcGxhY2VBbGwoYSwgIkEiLCAiWiIpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IE9iamVjdFtdIHsgIloiLCAiQiIsICJaIiwgIkMiLCAiWiIsICJEIiB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlcGxhY2VBbGxPYmplY3RBcnJheU9iamVjdE9iamVjdF9TdHJpbmcoKSB7Ci0JCVN0cmluZ1tdIGEgPSBuZXcgU3RyaW5nW10geyAiQSIsICJCIiwgIkEiLCAiQyIsICJBIiwgIkQiIH07Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmVwbGFjZUFsbChhLCAiQSIsICJaIik7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiWiIsICJCIiwgIloiLCAiQyIsICJaIiwgIkQiIH0sIGEpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVwbGFjZUFsbE9iamVjdEFycmF5T2JqZWN0T2JqZWN0X051bGwoKSB7Ci0JCVN0cmluZ1tdIGEgPSBuZXcgU3RyaW5nW10geyBudWxsLCAiQiIsIG51bGwsICJDIiwgbnVsbCwgIkQiIH07Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmVwbGFjZUFsbChhLCBudWxsLCAiWiIpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIloiLCAiQiIsICJaIiwgIkMiLCAiWiIsICJEIiB9LCBhKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlcGxhY2VBbGxDaGFyQXJyYXlDaGFyQ2hhcigpIHsKLQkJY2hhcltdIGEgPSBuZXcgY2hhcltdIHsgJ0EnLCAnQicsICdBJywgJ0MnLCAnQScsICdEJyB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJlcGxhY2VBbGwoYSwgJ0EnLCAnWicpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGNoYXJbXSB7ICdaJywgJ0InLCAnWicsICdDJywgJ1onLCAnRCcgfSwgYSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXBsYWNlQWxsSW50QXJyYXlJbnRJbnQoKSB7Ci0JCWludFtdIGEgPSBuZXcgaW50W10geyAwLCAxLCAwLCA3LCAwLCA5OSB9OwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJlcGxhY2VBbGwoYSwgMCwgMTMpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IGludFtdIHsgMTMsIDEsIDEzLCA3LCAxMywgOTkgfSwgYSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGxDb2xsZWN0aW9uSXRlcmFibGUoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChjLCBpdGVyYWJsZSkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5idWlsZFN0cmluZ0xpc3QxKCkuc2l6ZSgpLCBjLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKSwgYyk7Ci0KLQkJaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMucmV0YWluQWxsKGMsIGl0ZXJhYmxlKSk7Ci0JCWFzc2VydEVxdWFscygwLCBjLnNpemUoKSk7Ci0JCWFzc2VydEZhbHNlKGMuY29udGFpbnMoIm9uZSIpKTsKLQkJYXNzZXJ0RmFsc2UoYy5jb250YWlucygidHdvIikpOwotCQlhc3NlcnRGYWxzZShjLmNvbnRhaW5zKCJ0aHJlZSIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV0YWluQWxsQ29sbGVjdGlvbkl0ZXJhYmxlSW50KCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5yZXRhaW5BbGwoYywgaXRlcmFibGUpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLnNpemUoKSwgYy5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5idWlsZFN0cmluZ0xpc3QxKCksIGMpOwotCi0JCWl0ZXJhYmxlID0gdGhpcy5idWlsZFN0cmluZ0xpc3QyKCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChjLCBpdGVyYWJsZSwgNykpOwotCQlhc3NlcnRFcXVhbHMoMCwgYy5zaXplKCkpOwotCQlhc3NlcnRGYWxzZShjLmNvbnRhaW5zKCJvbmUiKSk7Ci0JCWFzc2VydEZhbHNlKGMuY29udGFpbnMoInR3byIpKTsKLQkJYXNzZXJ0RmFsc2UoYy5jb250YWlucygidGhyZWUiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldGFpbkFsbENvbGxlY3Rpb25JdGVyYXRvcigpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChjLCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5zaXplKCksIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLCBjKTsKLQotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5yZXRhaW5BbGwoYywgdGhpcy5idWlsZFN0cmluZ0xpc3QyKCkuaXRlcmF0b3IoKSkpOwotCQlhc3NlcnRFcXVhbHMoMCwgYy5zaXplKCkpOwotCQlhc3NlcnRGYWxzZShjLmNvbnRhaW5zKCJvbmUiKSk7Ci0JCWFzc2VydEZhbHNlKGMuY29udGFpbnMoInR3byIpKTsKLQkJYXNzZXJ0RmFsc2UoYy5jb250YWlucygidGhyZWUiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldGFpbkFsbENvbGxlY3Rpb25JdGVyYXRvcl9PYmplY3RTdHJpbmcoKSB7Ci0JCUNvbGxlY3Rpb248T2JqZWN0PiBjMSA9IG5ldyBBcnJheUxpc3Q8T2JqZWN0PigpOwotCQljMS5hZGQoInplcm8iKTsKLQkJYzEuYWRkKCJvbmUiKTsKLQkJYzEuYWRkKCJ0d28iKTsKLQkJCi0JCUNvbGxlY3Rpb248U3RyaW5nPiBjMiA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQljMi5hZGQoInplcm8iKTsKLQkJYzIuYWRkKCJvbmUiKTsKLQkJYzIuYWRkKCJ0d28iKTsKLQkJCi0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5yZXRhaW5BbGwoYzEsIGMyLml0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKGMyLnNpemUoKSwgYzEuc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGMyLCBjMSk7Ci0KLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMzID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWMzLmFkZCgidGhyZWUiKTsKLQkJYzMuYWRkKCJmb3VyIik7Ci0JCWMzLmFkZCgiZml2ZSIpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGxDb2xsZWN0aW9uSXRlcmF0b3JfRW1wdHlJdGVyYXRvcigpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMucmV0YWluQWxsKGMsIEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKSkpOwotCQlhc3NlcnRFcXVhbHMoMCwgYy5zaXplKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGxDb2xsZWN0aW9uSXRlcmF0b3JfRW1wdHlDb2xsZWN0aW9uKCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMucmV0YWluQWxsKGMsIHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGMuc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV0YWluQWxsQ29sbGVjdGlvbkl0ZXJhdG9ySW50KCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMucmV0YWluQWxsKGMsIHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCksIDgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLnNpemUoKSwgYy5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5idWlsZFN0cmluZ0xpc3QxKCksIGMpOwotCi0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChjLCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDIoKS5pdGVyYXRvcigpLCA5KSk7Ci0JCWFzc2VydEVxdWFscygwLCBjLnNpemUoKSk7Ci0JCWFzc2VydEZhbHNlKGMuY29udGFpbnMoIm9uZSIpKTsKLQkJYXNzZXJ0RmFsc2UoYy5jb250YWlucygidHdvIikpOwotCQlhc3NlcnRGYWxzZShjLmNvbnRhaW5zKCJ0aHJlZSIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV0YWluQWxsQ29sbGVjdGlvbkl0ZXJhdG9ySW50X0VtcHR5SXRlcmF0b3IoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChjLCBFbXB0eUl0ZXJhdG9yLmluc3RhbmNlKCksIDApKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGMuc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV0YWluQWxsQ29sbGVjdGlvbkl0ZXJhdG9ySW50X0VtcHR5Q29sbGVjdGlvbigpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChjLCB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpLCAzKSk7Ci0JCWFzc2VydEVxdWFscygwLCBjLnNpemUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldGFpbkFsbENvbGxlY3Rpb25PYmplY3RBcnJheSgpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChjLCB0aGlzLmJ1aWxkT2JqZWN0QXJyYXkxKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLnNpemUoKSwgYy5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5idWlsZFN0cmluZ0xpc3QxKCksIGMpOwotCi0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChjLCB0aGlzLmJ1aWxkT2JqZWN0QXJyYXkyKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0RmFsc2UoYy5jb250YWlucygib25lIikpOwotCQlhc3NlcnRGYWxzZShjLmNvbnRhaW5zKCJ0d28iKSk7Ci0JCWFzc2VydEZhbHNlKGMuY29udGFpbnMoInRocmVlIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGxDb2xsZWN0aW9uT2JqZWN0QXJyYXlfRW1wdHlPYmplY3RBcnJheSgpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMucmV0YWluQWxsKGMsIG5ldyBPYmplY3RbMF0pKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGMuc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV0YWluQWxsQ29sbGVjdGlvbk9iamVjdEFycmF5X0VtcHR5Q29sbGVjdGlvbigpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChjLCBuZXcgU3RyaW5nW10geyAiZm9vIiB9KSk7Ci0JCWFzc2VydEVxdWFscygwLCBjLnNpemUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldGFpbkFsbE9iamVjdEFycmF5T2JqZWN0QXJyYXkoKSB7Ci0JCVN0cmluZ1tdIGExID0gbmV3IFN0cmluZ1tdIHsgIkEiLCAiQSIsICJCIiwgIkIiLCAiQyIsICJDIiwgIkQiLCAiRCIsICJFIiwgIkUiLCAiRiIsICJGIiB9OwotCQlPYmplY3RbXSBhMiA9IG5ldyBPYmplY3RbXSB7ICJFIiwgIkIiLCBuZXcgSW50ZWdlcig3KSB9OwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIkIiLCAiQiIsICJFIiwgIkUiIH0sIENvbGxlY3Rpb25Ub29scy5yZXRhaW5BbGwoYTEsIGEyKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGxPYmplY3RBcnJheU9iamVjdEFycmF5X0VtcHR5T2JqZWN0QXJyYXkxKCkgewotCQlTdHJpbmdbXSBhMSA9IG5ldyBTdHJpbmdbMF07Ci0JCVN0cmluZ1tdIGEyID0gbmV3IFN0cmluZ1tdIHsgIkUiLCAiQiIsICIiIH07Ci0JCVN0cmluZ1tdIGEzID0gQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChhMSwgYTIpOwotCQlhc3NlcnRFcXVhbHMoMCwgYTMubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV0YWluQWxsT2JqZWN0QXJyYXlPYmplY3RBcnJheV9FbXB0eU9iamVjdEFycmF5MigpIHsKLQkJU3RyaW5nW10gYTEgPSBuZXcgU3RyaW5nW10geyAiRSIsICJCIiwgIiIgfTsKLQkJU3RyaW5nW10gYTIgPSBuZXcgU3RyaW5nWzBdOwotCQlTdHJpbmdbXSBhMyA9IENvbGxlY3Rpb25Ub29scy5yZXRhaW5BbGwoYTEsIGEyKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGEzLmxlbmd0aCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldGFpbkFsbE9iamVjdEFycmF5T2JqZWN0QXJyYXlfQm90aEVtcHR5KCkgewotCQlTdHJpbmdbXSBhMSA9IG5ldyBTdHJpbmdbMF07Ci0JCVN0cmluZ1tdIGEyID0gbmV3IFN0cmluZ1swXTsKLQkJU3RyaW5nW10gYTMgPSBDb2xsZWN0aW9uVG9vbHMucmV0YWluQWxsKGExLCBhMik7Ci0JCWFzc2VydEVxdWFscygwLCBhMy5sZW5ndGgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGxPYmplY3RBcnJheUl0ZXJhYmxlKCkgewotCQlTdHJpbmdbXSBhMSA9IG5ldyBTdHJpbmdbXSB7ICJBIiwgIkEiLCAiQiIsICJCIiwgIkMiLCAiQyIsICJEIiwgIkQiLCAiRSIsICJFIiwgIkYiLCAiRiIgfTsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgIkUiLCAiQiIsICIiIH0pOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIkIiLCAiQiIsICJFIiwgIkUiIH0sIENvbGxlY3Rpb25Ub29scy5yZXRhaW5BbGwoYTEsIGl0ZXJhYmxlKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGxPYmplY3RBcnJheUl0ZXJhYmxlX0VtcHR5T2JqZWN0QXJyYXkoKSB7Ci0JCVN0cmluZ1tdIGExID0gbmV3IFN0cmluZ1swXTsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgIkUiLCAiQiIsICIiIH0pOwotCQlTdHJpbmdbXSBhMyA9IENvbGxlY3Rpb25Ub29scy5yZXRhaW5BbGwoYTEsIGl0ZXJhYmxlKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGEzLmxlbmd0aCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldGFpbkFsbE9iamVjdEFycmF5SXRlcmFibGVJbnQoKSB7Ci0JCVN0cmluZ1tdIGExID0gbmV3IFN0cmluZ1tdIHsgIkEiLCAiQSIsICJCIiwgIkIiLCAiQyIsICJDIiwgIkQiLCAiRCIsICJFIiwgIkUiLCAiRiIsICJGIiB9OwotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlID0gQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAiRSIsICJCIiwgIiIgfSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgU3RyaW5nW10geyAiQiIsICJCIiwgIkUiLCAiRSIgfSwgQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChhMSwgaXRlcmFibGUsIDMpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldGFpbkFsbE9iamVjdEFycmF5SXRlcmFibGVJbnRfRW1wdHlPYmplY3RBcnJheSgpIHsKLQkJU3RyaW5nW10gYTEgPSBuZXcgU3RyaW5nWzBdOwotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlID0gQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAiRSIsICJCIiwgIiIgfSk7Ci0JCVN0cmluZ1tdIGEzID0gQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChhMSwgaXRlcmFibGUsIDMpOwotCQlhc3NlcnRFcXVhbHMoMCwgYTMubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV0YWluQWxsT2JqZWN0QXJyYXlJdGVyYXRvcigpIHsKLQkJU3RyaW5nW10gYTEgPSBuZXcgU3RyaW5nW10geyAiQSIsICJBIiwgIkIiLCAiQiIsICJDIiwgIkMiLCAiRCIsICJEIiwgIkUiLCAiRSIsICJGIiwgIkYiIH07Ci0JCUl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IgPSBBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJFIiwgIkIiLCAiIiB9KS5pdGVyYXRvcigpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIkIiLCAiQiIsICJFIiwgIkUiIH0sIENvbGxlY3Rpb25Ub29scy5yZXRhaW5BbGwoYTEsIGl0ZXJhdG9yKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGxPYmplY3RBcnJheUl0ZXJhdG9yX0VtcHR5T2JqZWN0QXJyYXkoKSB7Ci0JCVN0cmluZ1tdIGExID0gbmV3IFN0cmluZ1swXTsKLQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgIkUiLCAiQiIsICIiIH0pLml0ZXJhdG9yKCk7Ci0JCVN0cmluZ1tdIGEzID0gQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChhMSwgaXRlcmF0b3IpOwotCQlhc3NlcnRFcXVhbHMoMCwgYTMubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV0YWluQWxsT2JqZWN0QXJyYXlJdGVyYXRvckludCgpIHsKLQkJU3RyaW5nW10gYTEgPSBuZXcgU3RyaW5nW10geyAiQSIsICJBIiwgIkIiLCAiQiIsICJDIiwgIkMiLCAiRCIsICJEIiwgIkUiLCAiRSIsICJGIiwgIkYiIH07Ci0JCUl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IgPSBBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJFIiwgIkIiLCAiIiB9KS5pdGVyYXRvcigpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMobmV3IFN0cmluZ1tdIHsgIkIiLCAiQiIsICJFIiwgIkUiIH0sIENvbGxlY3Rpb25Ub29scy5yZXRhaW5BbGwoYTEsIGl0ZXJhdG9yLCAzKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGxPYmplY3RBcnJheUl0ZXJhdG9ySW50X0VtcHR5T2JqZWN0QXJyYXkoKSB7Ci0JCVN0cmluZ1tdIGExID0gbmV3IFN0cmluZ1swXTsKLQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgIkUiLCAiQiIsICIiIH0pLml0ZXJhdG9yKCk7Ci0JCVN0cmluZ1tdIGEzID0gQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChhMSwgaXRlcmF0b3IsIDMpOwotCQlhc3NlcnRFcXVhbHMoMCwgYTMubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV0YWluQWxsT2JqZWN0QXJyYXlDb2xsZWN0aW9uKCkgewotCQlTdHJpbmdbXSBhMSA9IG5ldyBTdHJpbmdbXSB7ICJBIiwgIkEiLCAiQiIsICJCIiwgIkMiLCAiQyIsICJEIiwgIkQiLCAiRSIsICJFIiwgIkYiLCAiRiIgfTsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGNvbGxlY3Rpb24gPSBBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJFIiwgIkIiLCAiIiB9KTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBTdHJpbmdbXSB7ICJCIiwgIkIiLCAiRSIsICJFIiB9LCBDb2xsZWN0aW9uVG9vbHMucmV0YWluQWxsKGExLCBjb2xsZWN0aW9uKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGxPYmplY3RBcnJheUNvbGxlY3Rpb25fRW1wdHlPYmplY3RBcnJheSgpIHsKLQkJU3RyaW5nW10gYTEgPSBuZXcgU3RyaW5nWzBdOwotCQlDb2xsZWN0aW9uPFN0cmluZz4gY29sbGVjdGlvbiA9IEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgIkUiLCAiQiIsICIiIH0pOwotCQlTdHJpbmdbXSBhMyA9IENvbGxlY3Rpb25Ub29scy5yZXRhaW5BbGwoYTEsIGNvbGxlY3Rpb24pOwotCQlhc3NlcnRFcXVhbHMoMCwgYTMubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV0YWluQWxsT2JqZWN0QXJyYXlDb2xsZWN0aW9uX0VtcHR5Q29sbGVjdGlvbigpIHsKLQkJU3RyaW5nW10gYTEgPSBuZXcgU3RyaW5nW10geyAiQSIsICJBIiwgIkIiLCAiQiIsICJDIiwgIkMiLCAiRCIsICJEIiwgIkUiLCAiRSIsICJGIiwgIkYiIH07Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjb2xsZWN0aW9uID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCVN0cmluZ1tdIGEzID0gQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChhMSwgY29sbGVjdGlvbik7Ci0JCWFzc2VydEVxdWFscygwLCBhMy5sZW5ndGgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGxPYmplY3RBcnJheUNvbGxlY3Rpb25fQWxsKCkgewotCQlTdHJpbmdbXSBhMSA9IG5ldyBTdHJpbmdbXSB7ICJBIiwgIkEiLCAiQiIsICJCIiwgIkMiLCAiQyIsICJEIiwgIkQiLCAiRSIsICJFIiwgIkYiLCAiRiIgfTsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGNvbGxlY3Rpb24gPSBBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJBIiwgIkIiLCAiQyIsICJEIiwgIkUiLCAiRiIgfSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhhMSwgQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChhMSwgY29sbGVjdGlvbikpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV0YWluQWxsQ2hhckFycmF5Q2hhckFycmF5KCkgewotCQljaGFyW10gYTEgPSBuZXcgY2hhcltdIHsgJ0EnLCAnQScsICdCJywgJ0InLCAnQycsICdDJywgJ0QnLCAnRCcsICdFJywgJ0UnLCAnRicsICdGJyB9OwotCQljaGFyW10gYTIgPSBuZXcgY2hhcltdIHsgJ0UnLCAnQicgfTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKG5ldyBjaGFyW10geyAnQicsICdCJywgJ0UnLCAnRScgfSwgQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChhMSwgYTIpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldGFpbkFsbENoYXJBcnJheUNoYXJBcnJheV9FbXB0eUNoYXJBcnJheTEoKSB7Ci0JCWNoYXJbXSBhMSA9IG5ldyBjaGFyWzBdOwotCQljaGFyW10gYTIgPSBuZXcgY2hhcltdIHsgJ0UnLCAnQicgfTsKLQkJYXNzZXJ0U2FtZShhMSwgQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChhMSwgYTIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV0YWluQWxsQ2hhckFycmF5Q2hhckFycmF5X0VtcHR5Q2hhckFycmF5MigpIHsKLQkJY2hhcltdIGExID0gbmV3IGNoYXJbXSB7ICdFJywgJ0InIH07Ci0JCWNoYXJbXSBhMiA9IG5ldyBjaGFyWzBdOwotCQlhc3NlcnRFcXVhbHMoMCwgQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChhMSwgYTIpLmxlbmd0aCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldGFpbkFsbENoYXJBcnJheUNoYXJBcnJheV9SZXRhaW5BbGwoKSB7Ci0JCWNoYXJbXSBhMSA9IG5ldyBjaGFyW10geyAnRScsICdCJywgJ0UnLCAnQicsICdFJywgJ0InLCAnRScsICdCJywgJ0UnIH07Ci0JCWNoYXJbXSBhMiA9IG5ldyBjaGFyW10geyAnRScsICdCJyB9OwotCQlhc3NlcnRTYW1lKGExLCBDb2xsZWN0aW9uVG9vbHMucmV0YWluQWxsKGExLCBhMikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGxJbnRBcnJheUludEFycmF5KCkgewotCQlpbnRbXSBhMSA9IG5ldyBpbnRbXSB7IDEsIDEsIDIsIDIsIDMsIDMsIDQsIDQsIDUsIDUsIDYsIDYgfTsKLQkJaW50W10gYTIgPSBuZXcgaW50W10geyA1LCAyIH07Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhuZXcgaW50W10geyAyLCAyLCA1LCA1IH0sIENvbGxlY3Rpb25Ub29scy5yZXRhaW5BbGwoYTEsIGEyKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGxJbnRBcnJheUludEFycmF5X0VtcHR5SW50QXJyYXkxKCkgewotCQlpbnRbXSBhMSA9IG5ldyBpbnRbMF07Ci0JCWludFtdIGEyID0gbmV3IGludFtdIHsgNSwgMiB9OwotCQlhc3NlcnRTYW1lKGExLCBDb2xsZWN0aW9uVG9vbHMucmV0YWluQWxsKGExLCBhMikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGxJbnRBcnJheUludEFycmF5X0VtcHR5SW50QXJyYXkyKCkgewotCQlpbnRbXSBhMSA9IG5ldyBpbnRbXSB7IDUsIDIgfTsKLQkJaW50W10gYTIgPSBuZXcgaW50WzBdOwotCQlhc3NlcnRFcXVhbHMoMCwgQ29sbGVjdGlvblRvb2xzLnJldGFpbkFsbChhMSwgYTIpLmxlbmd0aCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldGFpbkFsbEludEFycmF5SW50QXJyYXlfUmV0YWluQWxsKCkgewotCQlpbnRbXSBhMSA9IG5ldyBpbnRbXSB7IDUsIDIsIDUsIDIsIDUsIDIsIDUsIDIsIDUsIDIsIDUgfTsKLQkJaW50W10gYTIgPSBuZXcgaW50W10geyA1LCAyIH07Ci0JCWFzc2VydFNhbWUoYTEsIENvbGxlY3Rpb25Ub29scy5yZXRhaW5BbGwoYTEsIGEyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldmVyc2VPYmplY3RBcnJheV9PYmplY3QoKSB7Ci0JCU9iamVjdFtdIGEgPSB0aGlzLmJ1aWxkT2JqZWN0QXJyYXkxKCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmV2ZXJzZShhKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0d28iLCBhWzBdKTsKLQkJYXNzZXJ0RXF1YWxzKCJvbmUiLCBhWzFdKTsKLQkJYXNzZXJ0RXF1YWxzKCJ6ZXJvIiwgYVsyXSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldmVyc2VPYmplY3RBcnJheV9TdHJpbmcoKSB7Ci0JCVN0cmluZ1tdIGEgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucmV2ZXJzZShhKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0d28iLCBhWzBdKTsKLQkJYXNzZXJ0RXF1YWxzKCJvbmUiLCBhWzFdKTsKLQkJYXNzZXJ0RXF1YWxzKCJ6ZXJvIiwgYVsyXSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldmVyc2VDaGFyQXJyYXkoKSB7Ci0JCWNoYXJbXSBhID0gdGhpcy5idWlsZENoYXJBcnJheSgpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJldmVyc2UoYSk7Ci0JCWFzc2VydEVxdWFscygnYycsIGFbMF0pOwotCQlhc3NlcnRFcXVhbHMoJ2InLCBhWzFdKTsKLQkJYXNzZXJ0RXF1YWxzKCdhJywgYVsyXSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldmVyc2VJbnRBcnJheSgpIHsKLQkJaW50W10gYSA9IHRoaXMuYnVpbGRJbnRBcnJheSgpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnJldmVyc2UoYSk7Ci0JCWFzc2VydEVxdWFscygyMCwgYVswXSk7Ci0JCWFzc2VydEVxdWFscygxMCwgYVsxXSk7Ci0JCWFzc2VydEVxdWFscygwLCBhWzJdKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV2ZXJzZUxpc3RJdGVyYWJsZSgpIHsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlMaXN0PFN0cmluZz4gYWN0dWFsID0gQ29sbGVjdGlvblRvb2xzLnJldmVyc2VMaXN0KGl0ZXJhYmxlKTsKLQkJTGlzdDxTdHJpbmc+IGV4cGVjdGVkID0gdGhpcy5idWlsZFN0cmluZ0xpc3QxKCk7Ci0JCUNvbGxlY3Rpb25zLnJldmVyc2UoZXhwZWN0ZWQpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIGFjdHVhbCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJldmVyc2VMaXN0SXRlcmFibGVJbnQoKSB7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJTGlzdDxTdHJpbmc+IGFjdHVhbCA9IENvbGxlY3Rpb25Ub29scy5yZXZlcnNlTGlzdChpdGVyYWJsZSwgMTApOwotCQlMaXN0PFN0cmluZz4gZXhwZWN0ZWQgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJQ29sbGVjdGlvbnMucmV2ZXJzZShleHBlY3RlZCk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgYWN0dWFsKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV2ZXJzZUxpc3RJdGVyYXRvcl9TdHJpbmcoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBhY3R1YWwgPSBDb2xsZWN0aW9uVG9vbHMucmV2ZXJzZUxpc3QodGhpcy5idWlsZFN0cmluZ0xpc3QxKCkuaXRlcmF0b3IoKSk7Ci0JCUxpc3Q8U3RyaW5nPiBleHBlY3RlZCA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlDb2xsZWN0aW9ucy5yZXZlcnNlKGV4cGVjdGVkKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBhY3R1YWwpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXZlcnNlTGlzdEl0ZXJhdG9yX09iamVjdCgpIHsKLQkJTGlzdDxPYmplY3Q+IGFjdHVhbCA9IENvbGxlY3Rpb25Ub29scy48T2JqZWN0PnJldmVyc2VMaXN0KHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpLml0ZXJhdG9yKCkpOwotCQlMaXN0PE9iamVjdD4gZXhwZWN0ZWQgPSB0aGlzLmJ1aWxkT2JqZWN0TGlzdDEoKTsKLQkJQ29sbGVjdGlvbnMucmV2ZXJzZShleHBlY3RlZCk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgYWN0dWFsKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV2ZXJzZUxpc3RJdGVyYXRvckludCgpIHsKLQkJTGlzdDxTdHJpbmc+IGFjdHVhbCA9IENvbGxlY3Rpb25Ub29scy5yZXZlcnNlTGlzdCh0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpLCAzMyk7Ci0JCUxpc3Q8U3RyaW5nPiBleHBlY3RlZCA9IHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpOwotCQlDb2xsZWN0aW9ucy5yZXZlcnNlKGV4cGVjdGVkKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBhY3R1YWwpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSb3RhdGVPYmplY3RBcnJheSgpIHsKLQkJU3RyaW5nW10gYSA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5yb3RhdGUoYSk7Ci0JCWFzc2VydEVxdWFscygidHdvIiwgYVswXSk7Ci0JCWFzc2VydEVxdWFscygiemVybyIsIGFbMV0pOwotCQlhc3NlcnRFcXVhbHMoIm9uZSIsIGFbMl0pOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSb3RhdGVPYmplY3RBcnJheV9aZXJvKCkgewotCQlTdHJpbmdbXSBhMSA9IG5ldyBTdHJpbmdbMF07Ci0JCVN0cmluZ1tdIGEyID0gQ29sbGVjdGlvblRvb2xzLnJvdGF0ZShhMSk7Ci0JCWFzc2VydFNhbWUoYTEsIGEyKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Um90YXRlT2JqZWN0QXJyYXlfT25lKCkgewotCQlTdHJpbmdbXSBhMSA9IG5ldyBTdHJpbmdbXSB7ICJmb28gICIgfTsKLQkJU3RyaW5nW10gYTIgPSBDb2xsZWN0aW9uVG9vbHMucm90YXRlKGExKTsKLQkJYXNzZXJ0U2FtZShhMSwgYTIpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSb3RhdGVPYmplY3RBcnJheUludCgpIHsKLQkJU3RyaW5nW10gYSA9IHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5yb3RhdGUoYSwgMik7Ci0JCWFzc2VydEVxdWFscygib25lIiwgYVswXSk7Ci0JCWFzc2VydEVxdWFscygidHdvIiwgYVsxXSk7Ci0JCWFzc2VydEVxdWFscygiemVybyIsIGFbMl0pOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSb3RhdGVPYmplY3RBcnJheUludF9aZXJvRGlzdGFuY2UoKSB7Ci0JCVN0cmluZ1tdIGExID0gdGhpcy5idWlsZFN0cmluZ0FycmF5MSgpOwotCQlTdHJpbmdbXSBhMiA9IENvbGxlY3Rpb25Ub29scy5yb3RhdGUoYTEsIDApOwotCQlhc3NlcnRTYW1lKGExLCBhMik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJvdGF0ZU9iamVjdEFycmF5SW50X1plcm8oKSB7Ci0JCVN0cmluZ1tdIGExID0gbmV3IFN0cmluZ1swXTsKLQkJU3RyaW5nW10gYTIgPSBDb2xsZWN0aW9uVG9vbHMucm90YXRlKGExLCA3KTsKLQkJYXNzZXJ0U2FtZShhMSwgYTIpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSb3RhdGVPYmplY3RBcnJheUludF9PbmUoKSB7Ci0JCVN0cmluZ1tdIGExID0gbmV3IFN0cmluZ1tdIHsgImZvbyAgIiB9OwotCQlTdHJpbmdbXSBhMiA9IENvbGxlY3Rpb25Ub29scy5yb3RhdGUoYTEsIDgpOwotCQlhc3NlcnRTYW1lKGExLCBhMik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJvdGF0ZUNoYXJBcnJheSgpIHsKLQkJY2hhcltdIGEgPSB0aGlzLmJ1aWxkQ2hhckFycmF5KCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucm90YXRlKGEpOwotCQlhc3NlcnRFcXVhbHMoJ2MnLCBhWzBdKTsKLQkJYXNzZXJ0RXF1YWxzKCdhJywgYVsxXSk7Ci0JCWFzc2VydEVxdWFscygnYicsIGFbMl0pOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSb3RhdGVDaGFyQXJyYXlfWmVybygpIHsKLQkJY2hhcltdIGExID0gbmV3IGNoYXJbMF07Ci0JCWNoYXJbXSBhMiA9IENvbGxlY3Rpb25Ub29scy5yb3RhdGUoYTEpOwotCQlhc3NlcnRTYW1lKGExLCBhMik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJvdGF0ZUNoYXJBcnJheV9PbmUoKSB7Ci0JCWNoYXJbXSBhMSA9IG5ldyBjaGFyW10geyAnYScgfTsKLQkJY2hhcltdIGEyID0gQ29sbGVjdGlvblRvb2xzLnJvdGF0ZShhMSk7Ci0JCWFzc2VydFNhbWUoYTEsIGEyKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Um90YXRlQ2hhckFycmF5SW50KCkgewotCQljaGFyW10gYSA9IHRoaXMuYnVpbGRDaGFyQXJyYXkoKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5yb3RhdGUoYSwgMik7Ci0JCWFzc2VydEVxdWFscygnYicsIGFbMF0pOwotCQlhc3NlcnRFcXVhbHMoJ2MnLCBhWzFdKTsKLQkJYXNzZXJ0RXF1YWxzKCdhJywgYVsyXSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJvdGF0ZUNoYXJBcnJheUludF9aZXJvRGlzdGFuY2UoKSB7Ci0JCWNoYXJbXSBhMSA9IG5ldyBjaGFyW10geyAnYScsICdiJywgJ2MnIH07Ci0JCWNoYXJbXSBhMiA9IENvbGxlY3Rpb25Ub29scy5yb3RhdGUoYTEsIDApOwotCQlhc3NlcnRTYW1lKGExLCBhMik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJvdGF0ZUNoYXJBcnJheUludF9aZXJvKCkgewotCQljaGFyW10gYTEgPSBuZXcgY2hhclswXTsKLQkJY2hhcltdIGEyID0gQ29sbGVjdGlvblRvb2xzLnJvdGF0ZShhMSwgMjAwMSk7Ci0JCWFzc2VydFNhbWUoYTEsIGEyKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Um90YXRlQ2hhckFycmF5SW50X09uZSgpIHsKLQkJY2hhcltdIGExID0gbmV3IGNoYXJbXSB7ICdhJyB9OwotCQljaGFyW10gYTIgPSBDb2xsZWN0aW9uVG9vbHMucm90YXRlKGExLCAyMik7Ci0JCWFzc2VydFNhbWUoYTEsIGEyKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Um90YXRlSW50QXJyYXkoKSB7Ci0JCWludFtdIGEgPSB0aGlzLmJ1aWxkSW50QXJyYXkoKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5yb3RhdGUoYSk7Ci0JCWFzc2VydEVxdWFscygyMCwgYVswXSk7Ci0JCWFzc2VydEVxdWFscygwLCBhWzFdKTsKLQkJYXNzZXJ0RXF1YWxzKDEwLCBhWzJdKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Um90YXRlSW50QXJyYXlfWmVybygpIHsKLQkJaW50W10gYTEgPSBuZXcgaW50WzBdOwotCQlpbnRbXSBhMiA9IENvbGxlY3Rpb25Ub29scy5yb3RhdGUoYTEpOwotCQlhc3NlcnRTYW1lKGExLCBhMik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJvdGF0ZUludEFycmF5X09uZSgpIHsKLQkJaW50W10gYTEgPSBuZXcgaW50W10geyA3NyB9OwotCQlpbnRbXSBhMiA9IENvbGxlY3Rpb25Ub29scy5yb3RhdGUoYTEpOwotCQlhc3NlcnRTYW1lKGExLCBhMik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJvdGF0ZUludEFycmF5SW50KCkgewotCQlpbnRbXSBhID0gdGhpcy5idWlsZEludEFycmF5KCk7Ci0JCWEgPSBDb2xsZWN0aW9uVG9vbHMucm90YXRlKGEsIDIpOwotCQlhc3NlcnRFcXVhbHMoMTAsIGFbMF0pOwotCQlhc3NlcnRFcXVhbHMoMjAsIGFbMV0pOwotCQlhc3NlcnRFcXVhbHMoMCwgYVsyXSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJvdGF0ZUludEFycmF5SW50X1plcm9EaXN0YW5jZSgpIHsKLQkJaW50W10gYTEgPSBuZXcgaW50W10geyAzLCAyLCAxIH07Ci0JCWludFtdIGEyID0gQ29sbGVjdGlvblRvb2xzLnJvdGF0ZShhMSwgMCk7Ci0JCWFzc2VydFNhbWUoYTEsIGEyKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Um90YXRlSW50QXJyYXlJbnRfWmVybygpIHsKLQkJaW50W10gYTEgPSBuZXcgaW50WzBdOwotCQlpbnRbXSBhMiA9IENvbGxlY3Rpb25Ub29scy5yb3RhdGUoYTEsIDMpOwotCQlhc3NlcnRTYW1lKGExLCBhMik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJvdGF0ZUludEFycmF5SW50X09uZSgpIHsKLQkJaW50W10gYTEgPSBuZXcgaW50W10geyA3NyB9OwotCQlpbnRbXSBhMiA9IENvbGxlY3Rpb25Ub29scy5yb3RhdGUoYTEsIDQ0KTsKLQkJYXNzZXJ0U2FtZShhMSwgYTIpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRJdGVyYWJsZSgpIHsKLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IHRoaXMuYnVpbGRTdHJpbmdTZXQxKCk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkU3RyaW5nU2V0MSgpLCBDb2xsZWN0aW9uVG9vbHMuc2V0KGl0ZXJhYmxlKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNldEl0ZXJhYmxlSW50KCkgewotCQlJdGVyYWJsZTxTdHJpbmc+IGl0ZXJhYmxlID0gdGhpcy5idWlsZFN0cmluZ1NldDEoKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTdHJpbmdTZXQxKCksIENvbGxlY3Rpb25Ub29scy5zZXQoaXRlcmFibGUsIDIyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNldEl0ZXJhdG9yX1N0cmluZygpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTdHJpbmdTZXQxKCksIENvbGxlY3Rpb25Ub29scy5zZXQodGhpcy5idWlsZFN0cmluZ1NldDEoKS5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNldEl0ZXJhdG9yX09iamVjdCgpIHsKLQkJU2V0PFN0cmluZz4gc2V0MSA9IG5ldyBIYXNoU2V0PFN0cmluZz4oKTsKLQkJc2V0MS5hZGQoIjAiKTsKLQkJc2V0MS5hZGQoIjEiKTsKLQkJc2V0MS5hZGQoIjIiKTsKLQkJc2V0MS5hZGQoIjMiKTsKLQotCQlTZXQ8T2JqZWN0PiBzZXQyID0gQ29sbGVjdGlvblRvb2xzLjxPYmplY3Q+c2V0KHNldDEuaXRlcmF0b3IoKSk7Ci0JCWFzc2VydEVxdWFscyhzZXQxLCBzZXQyKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2V0SXRlcmF0b3JJbnQoKSB7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkU3RyaW5nU2V0MSgpLCBDb2xsZWN0aW9uVG9vbHMuc2V0KHRoaXMuYnVpbGRTdHJpbmdTZXQxKCkuaXRlcmF0b3IoKSwgMykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRPYmplY3RBcnJheSgpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTdHJpbmdTZXQxKCksIENvbGxlY3Rpb25Ub29scy5zZXQodGhpcy5idWlsZFN0cmluZ1NldDEoKS50b0FycmF5KCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2h1ZmZsZU9iamVjdEFycmF5KCkgewotCQlTdHJpbmdbXSBhcnJheTEgPSB0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCk7Ci0JCVN0cmluZ1tdIGFycmF5MiA9IENvbGxlY3Rpb25Ub29scy5zaHVmZmxlKHRoaXMuYnVpbGRTdHJpbmdBcnJheTEoKSk7Ci0JCWFzc2VydEVxdWFscyhhcnJheTEubGVuZ3RoLCBhcnJheTIubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwoYXJyYXkxLCBhcnJheTIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2h1ZmZsZUNoYXJBcnJheSgpIHsKLQkJY2hhcltdIGFycmF5MSA9IHRoaXMuYnVpbGRDaGFyQXJyYXkoKTsKLQkJY2hhcltdIGFycmF5MiA9IENvbGxlY3Rpb25Ub29scy5zaHVmZmxlKHRoaXMuYnVpbGRDaGFyQXJyYXkoKSk7Ci0JCWFzc2VydEVxdWFscyhhcnJheTEubGVuZ3RoLCBhcnJheTIubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwoYXJyYXkxLCBhcnJheTIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2h1ZmZsZUludEFycmF5KCkgewotCQlpbnRbXSBhcnJheTEgPSB0aGlzLmJ1aWxkSW50QXJyYXkoKTsKLQkJaW50W10gYXJyYXkyID0gQ29sbGVjdGlvblRvb2xzLnNodWZmbGUodGhpcy5idWlsZEludEFycmF5KCkpOwotCQlhc3NlcnRFcXVhbHMoYXJyYXkxLmxlbmd0aCwgYXJyYXkyLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKGFycmF5MSwgYXJyYXkyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNpbmdsZXRvbkl0ZXJhdG9yX1N0cmluZygpIHsKLQkJSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSBDb2xsZWN0aW9uVG9vbHMuc2luZ2xldG9uSXRlcmF0b3IoImZvbyIpOwotCQlhc3NlcnRUcnVlKHN0cmVhbS5oYXNOZXh0KCkpOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIHN0cmVhbS5uZXh0KCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTaW5nbGV0b25JdGVyYXRvcl9PYmplY3QoKSB7Ci0JCUl0ZXJhdG9yPE9iamVjdD4gc3RyZWFtID0gQ29sbGVjdGlvblRvb2xzLjxPYmplY3Q+c2luZ2xldG9uSXRlcmF0b3IoImZvbyIpOwotCQlhc3NlcnRUcnVlKHN0cmVhbS5oYXNOZXh0KCkpOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIHN0cmVhbS5uZXh0KCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTaW5nbGV0b25JdGVyYXRvcl9DYXN0KCkgewotCQlJdGVyYXRvcjxPYmplY3Q+IHN0cmVhbSA9IENvbGxlY3Rpb25Ub29scy5zaW5nbGV0b25JdGVyYXRvcigoT2JqZWN0KSAiZm9vIik7Ci0JCWFzc2VydFRydWUoc3RyZWFtLmhhc05leHQoKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgc3RyZWFtLm5leHQoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNpemVJdGVyYWJsZSgpIHsKLQkJSXRlcmFibGU8T2JqZWN0PiBpdGVyYWJsZSA9IHRoaXMuYnVpbGRPYmplY3RMaXN0MSgpOwotCQlhc3NlcnRFcXVhbHMoMywgQ29sbGVjdGlvblRvb2xzLnNpemUoaXRlcmFibGUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2l6ZUl0ZXJhdG9yKCkgewotCQlhc3NlcnRFcXVhbHMoMywgQ29sbGVjdGlvblRvb2xzLnNpemUodGhpcy5idWlsZE9iamVjdExpc3QxKCkuaXRlcmF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTb3J0ZWRTZXRJdGVyYWJsZSgpIHsKLQkJU29ydGVkU2V0PFN0cmluZz4gc3MxID0gbmV3IFRyZWVTZXQ8U3RyaW5nPigpOwotCQlzczEuYWRkKCIwIik7Ci0JCXNzMS5hZGQoIjIiKTsKLQkJc3MxLmFkZCgiMyIpOwotCQlzczEuYWRkKCIxIik7Ci0KLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IHNzMTsKLQkJU29ydGVkU2V0PFN0cmluZz4gc2V0MiA9IENvbGxlY3Rpb25Ub29scy48U3RyaW5nPnNvcnRlZFNldChpdGVyYWJsZSk7Ci0JCWFzc2VydEVxdWFscyhzczEsIHNldDIpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTb3J0ZWRTZXRJdGVyYWJsZUludCgpIHsKLQkJU29ydGVkU2V0PFN0cmluZz4gc3MxID0gbmV3IFRyZWVTZXQ8U3RyaW5nPigpOwotCQlzczEuYWRkKCIwIik7Ci0JCXNzMS5hZGQoIjIiKTsKLQkJc3MxLmFkZCgiMyIpOwotCQlzczEuYWRkKCIxIik7Ci0KLQkJSXRlcmFibGU8U3RyaW5nPiBpdGVyYWJsZSA9IHNzMTsKLQkJU29ydGVkU2V0PFN0cmluZz4gc2V0MiA9IENvbGxlY3Rpb25Ub29scy48U3RyaW5nPnNvcnRlZFNldChpdGVyYWJsZSwgNSk7Ci0JCWFzc2VydEVxdWFscyhzczEsIHNldDIpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTb3J0ZWRTZXRJdGVyYXRvcigpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTb3J0ZWRTdHJpbmdTZXQxKCksIENvbGxlY3Rpb25Ub29scy5zb3J0ZWRTZXQodGhpcy5idWlsZFNvcnRlZFN0cmluZ1NldDEoKS5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNvcnRlZFNldEl0ZXJhdG9yX1RyZWVTZXQoKSB7Ci0JCVNvcnRlZFNldDxTdHJpbmc+IHNzMSA9IG5ldyBUcmVlU2V0PFN0cmluZz4oKTsKLQkJc3MxLmFkZCgiMCIpOwotCQlzczEuYWRkKCIyIik7Ci0JCXNzMS5hZGQoIjMiKTsKLQkJc3MxLmFkZCgiMSIpOwotCi0JCVNvcnRlZFNldDxTdHJpbmc+IHNldDIgPSBDb2xsZWN0aW9uVG9vbHMuPFN0cmluZz5zb3J0ZWRTZXQoc3MxLml0ZXJhdG9yKCkpOwotCQlhc3NlcnRFcXVhbHMoc3MxLCBzZXQyKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U29ydGVkU2V0SXRlcmF0b3JJbnQoKSB7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkU29ydGVkU3RyaW5nU2V0MSgpLCBDb2xsZWN0aW9uVG9vbHMuc29ydGVkU2V0KHRoaXMuYnVpbGRTb3J0ZWRTdHJpbmdTZXQxKCkuaXRlcmF0b3IoKSwgOCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTb3J0ZWRTZXRPYmplY3RBcnJheSgpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTb3J0ZWRTdHJpbmdTZXQxKCksIENvbGxlY3Rpb25Ub29scy5zZXQodGhpcy5idWlsZFNvcnRlZFN0cmluZ1NldDEoKS50b0FycmF5KCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3ViQXJyYXlPYmplY3RBcnJheUludEludCgpIHsKLQkJU3RyaW5nW10gYXJyYXkgPSBuZXcgU3RyaW5nW10geyJmb28iLCAiYmFyIiwgImJheiIsICJqb28iLCAiamFyIiwgImpheiJ9OwotCQlTdHJpbmdbXSByZXN1bHQgPSBuZXcgU3RyaW5nW10geyJmb28iLCAiYmFyIiwgImJheiIsICJqb28ifTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKHJlc3VsdCwgQ29sbGVjdGlvblRvb2xzLnN1YkFycmF5KGFycmF5LCAwLCA0KSkpOwotCi0JCXJlc3VsdCA9IG5ldyBTdHJpbmdbXSB7ImphciJ9OwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMocmVzdWx0LCBDb2xsZWN0aW9uVG9vbHMuc3ViQXJyYXkoYXJyYXksIDQsIDEpKSk7Ci0KLQkJcmVzdWx0ID0gbmV3IFN0cmluZ1swXTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKHJlc3VsdCwgQ29sbGVjdGlvblRvb2xzLnN1YkFycmF5KGFycmF5LCA1LCAwKSkpOwotCi0JCXJlc3VsdCA9IG5ldyBTdHJpbmdbXSB7ImpvbyIsICJqYXIiLCAiamF6In07Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhyZXN1bHQsIENvbGxlY3Rpb25Ub29scy5zdWJBcnJheShhcnJheSwgMywgMykpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3ViQXJyYXlJbnRBcnJheUludEludCgpIHsKLQkJaW50W10gYXJyYXkgPSBuZXcgaW50W10gezc3LCA5OSwgMzMzLCA0LCA5MDkwLCA0Mn07Ci0JCWludFtdIHJlc3VsdCA9IG5ldyBpbnRbXSB7NzcsIDk5LCAzMzMsIDR9OwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMocmVzdWx0LCBDb2xsZWN0aW9uVG9vbHMuc3ViQXJyYXkoYXJyYXksIDAsIDQpKSk7Ci0KLQkJcmVzdWx0ID0gbmV3IGludFtdIHs5MDkwfTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKHJlc3VsdCwgQ29sbGVjdGlvblRvb2xzLnN1YkFycmF5KGFycmF5LCA0LCAxKSkpOwotCi0JCXJlc3VsdCA9IG5ldyBpbnRbMF07Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhyZXN1bHQsIENvbGxlY3Rpb25Ub29scy5zdWJBcnJheShhcnJheSwgNSwgMCkpKTsKLQotCQlyZXN1bHQgPSBuZXcgaW50W10gezQsIDkwOTAsIDQyfTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKHJlc3VsdCwgQ29sbGVjdGlvblRvb2xzLnN1YkFycmF5KGFycmF5LCAzLCAzKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTdWJBcnJheUNoYXJBcnJheUludEludCgpIHsKLQkJY2hhcltdIGFycmF5ID0gbmV3IGNoYXJbXSB7J2EnLCAnYicsICdjJywgJ2QnLCAnZScsICdmJ307Ci0JCWNoYXJbXSByZXN1bHQgPSBuZXcgY2hhcltdIHsnYScsICdiJywgJ2MnLCAnZCd9OwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMocmVzdWx0LCBDb2xsZWN0aW9uVG9vbHMuc3ViQXJyYXkoYXJyYXksIDAsIDQpKSk7Ci0KLQkJcmVzdWx0ID0gbmV3IGNoYXJbXSB7J2UnfTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKHJlc3VsdCwgQ29sbGVjdGlvblRvb2xzLnN1YkFycmF5KGFycmF5LCA0LCAxKSkpOwotCi0JCXJlc3VsdCA9IG5ldyBjaGFyWzBdOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMocmVzdWx0LCBDb2xsZWN0aW9uVG9vbHMuc3ViQXJyYXkoYXJyYXksIDUsIDApKSk7Ci0KLQkJcmVzdWx0ID0gbmV3IGNoYXJbXSB7J2QnLCAnZScsICdmJ307Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhyZXN1bHQsIENvbGxlY3Rpb25Ub29scy5zdWJBcnJheShhcnJheSwgMywgMykpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3dhcE9iamVjdEFycmF5KCkgewotCQlTdHJpbmdbXSBhID0gdGhpcy5idWlsZFN0cmluZ0FycmF5MSgpOwotCQlhID0gQ29sbGVjdGlvblRvb2xzLnN3YXAoYSwgMSwgMik7Ci0JCWFzc2VydEVxdWFscygiemVybyIsIGFbMF0pOwotCQlhc3NlcnRFcXVhbHMoInR3byIsIGFbMV0pOwotCQlhc3NlcnRFcXVhbHMoIm9uZSIsIGFbMl0pOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTd2FwQ2hhckFycmF5KCkgewotCQljaGFyW10gYSA9IHRoaXMuYnVpbGRDaGFyQXJyYXkoKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5zd2FwKGEsIDEsIDIpOwotCQlhc3NlcnRFcXVhbHMoJ2EnLCBhWzBdKTsKLQkJYXNzZXJ0RXF1YWxzKCdjJywgYVsxXSk7Ci0JCWFzc2VydEVxdWFscygnYicsIGFbMl0pOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTd2FwSW50QXJyYXkoKSB7Ci0JCWludFtdIGEgPSB0aGlzLmJ1aWxkSW50QXJyYXkoKTsKLQkJYSA9IENvbGxlY3Rpb25Ub29scy5zd2FwKGEsIDEsIDIpOwotCQlhc3NlcnRFcXVhbHMoMCwgYVswXSk7Ci0JCWFzc2VydEVxdWFscygyMCwgYVsxXSk7Ci0JCWFzc2VydEVxdWFscygxMCwgYVsyXSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUR1cGxpY2F0ZUVsZW1lbnRzTGlzdDEoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0ID0gdGhpcy5idWlsZFN0cmluZ1ZlY3RvcjEoKTsKLQkJbGlzdC5hZGQoInplcm8iKTsKLQkJbGlzdC5hZGQoInplcm8iKTsKLQkJbGlzdC5hZGQoInR3byIpOwotCQlsaXN0LmFkZCgiemVybyIpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5yZW1vdmVEdXBsaWNhdGVFbGVtZW50cyhsaXN0KSk7Ci0JCWludCBpID0gMDsKLQkJYXNzZXJ0RXF1YWxzKCJ6ZXJvIiwgbGlzdC5nZXQoaSsrKSk7Ci0JCWFzc2VydEVxdWFscygib25lIiwgbGlzdC5nZXQoaSsrKSk7Ci0JCWFzc2VydEVxdWFscygidHdvIiwgbGlzdC5nZXQoaSsrKSk7Ci0JCWFzc2VydEVxdWFscyhpLCBsaXN0LnNpemUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUR1cGxpY2F0ZUVsZW1lbnRzTGlzdDIoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0ID0gdGhpcy5idWlsZFN0cmluZ1ZlY3RvcjEoKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLnJlbW92ZUR1cGxpY2F0ZUVsZW1lbnRzKGxpc3QpKTsKLQkJaW50IGkgPSAwOwotCQlhc3NlcnRFcXVhbHMoInplcm8iLCBsaXN0LmdldChpKyspKTsKLQkJYXNzZXJ0RXF1YWxzKCJvbmUiLCBsaXN0LmdldChpKyspKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0d28iLCBsaXN0LmdldChpKyspKTsKLQkJYXNzZXJ0RXF1YWxzKGksIGxpc3Quc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlRHVwbGljYXRlRWxlbWVudHNMaXN0X0VtcHR5KCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMucmVtb3ZlRHVwbGljYXRlRWxlbWVudHMobGlzdCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgbGlzdC5zaXplKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVEdXBsaWNhdGVFbGVtZW50c0xpc3RfU2luZ2xlRWxlbWVudCgpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJbGlzdC5hZGQoInplcm8iKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLnJlbW92ZUR1cGxpY2F0ZUVsZW1lbnRzKGxpc3QpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIGxpc3Quc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlRHVwbGljYXRlRWxlbWVudHNPYmplY3RBcnJheSgpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QgPSB0aGlzLmJ1aWxkU3RyaW5nVmVjdG9yMSgpOwotCQlsaXN0LmFkZCgiemVybyIpOwotCQlsaXN0LmFkZCgiemVybyIpOwotCQlsaXN0LmFkZCgidHdvIik7Ci0JCWxpc3QuYWRkKCJ6ZXJvIik7Ci0JCVN0cmluZ1tdIGFycmF5ID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUR1cGxpY2F0ZUVsZW1lbnRzKGxpc3QudG9BcnJheShuZXcgU3RyaW5nW2xpc3Quc2l6ZSgpXSkpOwotCQlpbnQgaSA9IDA7Ci0JCWFzc2VydEVxdWFscygiemVybyIsIGFycmF5W2krK10pOwotCQlhc3NlcnRFcXVhbHMoIm9uZSIsIGFycmF5W2krK10pOwotCQlhc3NlcnRFcXVhbHMoInR3byIsIGFycmF5W2krK10pOwotCQlhc3NlcnRFcXVhbHMoaSwgYXJyYXkubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlRHVwbGljYXRlRWxlbWVudHNPYmplY3RBcnJheV9FbXB0eSgpIHsKLQkJU3RyaW5nW10gYXJyYXkgPSBDb2xsZWN0aW9uVG9vbHMucmVtb3ZlRHVwbGljYXRlRWxlbWVudHMobmV3IFN0cmluZ1swXSk7Ci0JCWFzc2VydEVxdWFscygwLCBhcnJheS5sZW5ndGgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVEdXBsaWNhdGVFbGVtZW50c09iamVjdEFycmF5X1NpbmdsZUVsZW1lbnQoKSB7Ci0JCVN0cmluZ1tdIGFycmF5ID0gQ29sbGVjdGlvblRvb2xzLnJlbW92ZUR1cGxpY2F0ZUVsZW1lbnRzKG5ldyBTdHJpbmdbXSB7ICJmb28iIH0pOwotCQlhc3NlcnRFcXVhbHMoMSwgYXJyYXkubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VmVjdG9ySXRlcmFibGUoKSB7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJVmVjdG9yPFN0cmluZz4gdiA9IENvbGxlY3Rpb25Ub29scy52ZWN0b3IoaXRlcmFibGUpOwotCQlhc3NlcnRFcXVhbHMoMywgdi5zaXplKCkpOwotCQlhc3NlcnRUcnVlKHYuY29udGFpbnNBbGwodGhpcy5idWlsZFN0cmluZ0xpc3QxKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VmVjdG9ySXRlcmFibGVJbnQoKSB7Ci0JCUl0ZXJhYmxlPFN0cmluZz4gaXRlcmFibGUgPSB0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKTsKLQkJVmVjdG9yPFN0cmluZz4gdiA9IENvbGxlY3Rpb25Ub29scy52ZWN0b3IoaXRlcmFibGUsIDgpOwotCQlhc3NlcnRFcXVhbHMoMywgdi5zaXplKCkpOwotCQlhc3NlcnRUcnVlKHYuY29udGFpbnNBbGwodGhpcy5idWlsZFN0cmluZ0xpc3QxKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VmVjdG9ySXRlcmF0b3JfU3RyaW5nKCkgewotCQlWZWN0b3I8U3RyaW5nPiB2ID0gQ29sbGVjdGlvblRvb2xzLnZlY3Rvcih0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIHYuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZSh2LmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFZlY3Rvckl0ZXJhdG9yX09iamVjdCgpIHsKLQkJVmVjdG9yPE9iamVjdD4gdiA9IENvbGxlY3Rpb25Ub29scy48T2JqZWN0PnZlY3Rvcih0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIHYuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZSh2LmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFZlY3Rvckl0ZXJhdG9ySW50KCkgewotCQlWZWN0b3I8U3RyaW5nPiB2ID0gQ29sbGVjdGlvblRvb2xzLnZlY3Rvcih0aGlzLmJ1aWxkU3RyaW5nTGlzdDEoKS5pdGVyYXRvcigpLCA3KTsKLQkJYXNzZXJ0RXF1YWxzKDMsIHYuc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZSh2LmNvbnRhaW5zQWxsKHRoaXMuYnVpbGRTdHJpbmdMaXN0MSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFZlY3Rvck9iamVjdEFycmF5KCkgewotCQlWZWN0b3I8U3RyaW5nPiB2ID0gQ29sbGVjdGlvblRvb2xzLnZlY3Rvcih0aGlzLmJ1aWxkU3RyaW5nQXJyYXkxKCkpOwotCQlhc3NlcnRFcXVhbHMoMywgdi5zaXplKCkpOwotCQlhc3NlcnRUcnVlKHYuY29udGFpbnNBbGwodGhpcy5idWlsZFN0cmluZ0xpc3QxKCkpKTsKLQl9Ci0KLQlwcml2YXRlIE9iamVjdFtdIGJ1aWxkT2JqZWN0QXJyYXkxKCkgewotCQlyZXR1cm4gbmV3IE9iamVjdFtdIHsgInplcm8iLCAib25lIiwgInR3byIgfTsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZ1tdIGJ1aWxkU3RyaW5nQXJyYXkxKCkgewotCQlyZXR1cm4gbmV3IFN0cmluZ1tdIHsgInplcm8iLCAib25lIiwgInR3byIgfTsKLQl9Ci0KLQlwcml2YXRlIGNoYXJbXSBidWlsZENoYXJBcnJheSgpIHsKLQkJcmV0dXJuIG5ldyBjaGFyW10geyAnYScsICdiJywgJ2MnIH07Ci0JfQotCi0JcHJpdmF0ZSBpbnRbXSBidWlsZEludEFycmF5KCkgewotCQlyZXR1cm4gbmV3IGludFtdIHsgMCwgMTAsIDIwIH07Ci0JfQotCi0JcHJpdmF0ZSBPYmplY3RbXSBidWlsZE9iamVjdEFycmF5MigpIHsKLQkJcmV0dXJuIG5ldyBPYmplY3RbXSB7ICJ0aHJlZSIsICJmb3VyIiwgImZpdmUiIH07Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmdbXSBidWlsZFN0cmluZ0FycmF5MigpIHsKLQkJcmV0dXJuIG5ldyBTdHJpbmdbXSB7ICJ0aHJlZSIsICJmb3VyIiwgImZpdmUiIH07Ci0JfQotCi0JcHJpdmF0ZSBWZWN0b3I8U3RyaW5nPiBidWlsZFN0cmluZ1ZlY3RvcjEoKSB7Ci0JCVZlY3RvcjxTdHJpbmc+IHYgPSBuZXcgVmVjdG9yPFN0cmluZz4oKTsKLQkJdGhpcy5hZGRUb0NvbGxlY3Rpb24xKHYpOwotCQlyZXR1cm4gdjsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBidWlsZFN0cmluZ0xpc3QxKCkgewotCQlMaXN0PFN0cmluZz4gbCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQl0aGlzLmFkZFRvQ29sbGVjdGlvbjEobCk7Ci0JCXJldHVybiBsOwotCX0KLQotCXByaXZhdGUgTGlzdDxPYmplY3Q+IGJ1aWxkT2JqZWN0TGlzdDEoKSB7Ci0JCUxpc3Q8T2JqZWN0PiBsID0gbmV3IEFycmF5TGlzdDxPYmplY3Q+KCk7Ci0JCXRoaXMuYWRkVG9Db2xsZWN0aW9uMShsKTsKLQkJcmV0dXJuIGw7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGFkZFRvQ29sbGVjdGlvbjEoQ29sbGVjdGlvbjw/IHN1cGVyIFN0cmluZz4gYykgewotCQljLmFkZCgiemVybyIpOwotCQljLmFkZCgib25lIik7Ci0JCWMuYWRkKCJ0d28iKTsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBidWlsZFN0cmluZ0xpc3QyKCkgewotCQlMaXN0PFN0cmluZz4gbCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQl0aGlzLmFkZFRvQ29sbGVjdGlvbjIobCk7Ci0JCXJldHVybiBsOwotCX0KLQotCXByaXZhdGUgdm9pZCBhZGRUb0NvbGxlY3Rpb24yKENvbGxlY3Rpb248PyBzdXBlciBTdHJpbmc+IGMpIHsKLQkJYy5hZGQoInRocmVlIik7Ci0JCWMuYWRkKCJmb3VyIik7Ci0JCWMuYWRkKCJmaXZlIik7Ci0JfQotCi0JcHJpdmF0ZSBTZXQ8U3RyaW5nPiBidWlsZFN0cmluZ1NldDEoKSB7Ci0JCVNldDxTdHJpbmc+IHMgPSBuZXcgSGFzaFNldDxTdHJpbmc+KCk7Ci0JCXRoaXMuYWRkVG9Db2xsZWN0aW9uMShzKTsKLQkJcmV0dXJuIHM7Ci0JfQotCi0JcHJpdmF0ZSBTZXQ8T2JqZWN0PiBidWlsZE9iamVjdFNldDEoKSB7Ci0JCVNldDxPYmplY3Q+IHMgPSBuZXcgSGFzaFNldDxPYmplY3Q+KCk7Ci0JCXRoaXMuYWRkVG9Db2xsZWN0aW9uMShzKTsKLQkJcmV0dXJuIHM7Ci0JfQotCi0JcHJpdmF0ZSBTb3J0ZWRTZXQ8U3RyaW5nPiBidWlsZFNvcnRlZFN0cmluZ1NldDEoKSB7Ci0JCVNvcnRlZFNldDxTdHJpbmc+IHMgPSBuZXcgVHJlZVNldDxTdHJpbmc+KCk7Ci0JCXRoaXMuYWRkVG9Db2xsZWN0aW9uMShzKTsKLQkJcmV0dXJuIHM7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0NvbW1hbmRFeGVjdXRvclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0NvbW1hbmRFeGVjdXRvclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGYyN2Y4ODMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9Db21tYW5kRXhlY3V0b3JUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LkNvbW1hbmQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuQ29tbWFuZEV4ZWN1dG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlRocmVhZExvY2FsQ29tbWFuZEV4ZWN1dG9yOwotCi1wdWJsaWMgY2xhc3MgQ29tbWFuZEV4ZWN1dG9yVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQlwdWJsaWMgQ29tbWFuZEV4ZWN1dG9yVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdERlZmF1bHRDb21tYW5kRXhlY3V0b3IoKSB7Ci0JCVRlc3RDb21tYW5kIHRlc3RDb21tYW5kID0gbmV3IFRlc3RDb21tYW5kKCk7Ci0JCWFzc2VydEVxdWFscygwLCB0ZXN0Q29tbWFuZC5jb3VudCk7Ci0JCUNvbW1hbmRFeGVjdXRvciBjb21tYW5kRXhlY3V0b3IgPSBDb21tYW5kRXhlY3V0b3IuRGVmYXVsdC5pbnN0YW5jZSgpOwotCQljb21tYW5kRXhlY3V0b3IuZXhlY3V0ZSh0ZXN0Q29tbWFuZCk7Ci0JCWFzc2VydEVxdWFscygxLCB0ZXN0Q29tbWFuZC5jb3VudCk7Ci0JfQotCi0Jc3RhdGljIGNsYXNzIFRlc3RDb21tYW5kIGltcGxlbWVudHMgQ29tbWFuZCB7Ci0JCWludCBjb3VudCA9IDA7Ci0JCXB1YmxpYyB2b2lkIGV4ZWN1dGUoKSB7Ci0JCQl0aGlzLmNvdW50Kys7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VGhyZWFkTG9jYWxDb21tYW5kRXhlY3V0b3IoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGhyZWFkTG9jYWxDb21tYW5kRXhlY3V0b3IgdGhyZWFkTG9jYWxDb21tYW5kRXhlY3V0b3IgPSBuZXcgVGhyZWFkTG9jYWxDb21tYW5kRXhlY3V0b3IoKTsKLQkJVGVzdFJ1bm5hYmxlIHRlc3RSdW5uYWJsZTEgPSBuZXcgVGVzdFJ1bm5hYmxlKHRocmVhZExvY2FsQ29tbWFuZEV4ZWN1dG9yLCAxKTsKLQkJVGhyZWFkIHRocmVhZDEgPSBuZXcgVGhyZWFkKHRlc3RSdW5uYWJsZTEpOwotCQl0aHJlYWQxLnJ1bigpOwotCi0JCVRlc3RSdW5uYWJsZSB0ZXN0UnVubmFibGUyID0gbmV3IFRlc3RSdW5uYWJsZSh0aHJlYWRMb2NhbENvbW1hbmRFeGVjdXRvciwgMik7Ci0JCVRocmVhZCB0aHJlYWQyID0gbmV3IFRocmVhZCh0ZXN0UnVubmFibGUyKTsKLQkJdGhyZWFkMi5ydW4oKTsKLQotCQl0aHJlYWQxLmpvaW4oKTsKLQkJdGhyZWFkMi5qb2luKCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDEsIHRlc3RSdW5uYWJsZTEudGVzdENvbW1hbmQuY291bnQpOwotCQlhc3NlcnRFcXVhbHMoMSwgdGVzdFJ1bm5hYmxlMS50ZXN0Q29tbWFuZEV4ZWN1dG9yLmNvdW50KTsKLQotCQlhc3NlcnRFcXVhbHMoMiwgdGVzdFJ1bm5hYmxlMi50ZXN0Q29tbWFuZC5jb3VudCk7Ci0JCWFzc2VydEVxdWFscygyLCB0ZXN0UnVubmFibGUyLnRlc3RDb21tYW5kRXhlY3V0b3IuY291bnQpOwotCX0KLQotCXN0YXRpYyBjbGFzcyBUZXN0Q29tbWFuZEV4ZWN1dG9yIGltcGxlbWVudHMgQ29tbWFuZEV4ZWN1dG9yIHsKLQkJaW50IGNvdW50ID0gMDsKLQkJcHVibGljIHZvaWQgZXhlY3V0ZShDb21tYW5kIGNvbW1hbmQpIHsKLQkJCXRoaXMuY291bnQrKzsKLQkJCWNvbW1hbmQuZXhlY3V0ZSgpOwotCQl9Ci0JfQotCi0Jc3RhdGljIGNsYXNzIFRlc3RSdW5uYWJsZSBpbXBsZW1lbnRzIFJ1bm5hYmxlIHsKLQkJZmluYWwgVGhyZWFkTG9jYWxDb21tYW5kRXhlY3V0b3IgdGhyZWFkTG9jYWxDb21tYW5kRXhlY3V0b3I7Ci0JCWZpbmFsIGludCBleGVjdXRpb25Db3VudDsKLQkJZmluYWwgVGVzdENvbW1hbmQgdGVzdENvbW1hbmQgPSBuZXcgVGVzdENvbW1hbmQoKTsKLQkJZmluYWwgVGVzdENvbW1hbmRFeGVjdXRvciB0ZXN0Q29tbWFuZEV4ZWN1dG9yID0gbmV3IFRlc3RDb21tYW5kRXhlY3V0b3IoKTsKLQkJVGVzdFJ1bm5hYmxlKFRocmVhZExvY2FsQ29tbWFuZEV4ZWN1dG9yIHRocmVhZExvY2FsQ29tbWFuZEV4ZWN1dG9yLCBpbnQgZXhlY3V0aW9uQ291bnQpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLnRocmVhZExvY2FsQ29tbWFuZEV4ZWN1dG9yID0gdGhyZWFkTG9jYWxDb21tYW5kRXhlY3V0b3I7Ci0JCQl0aGlzLmV4ZWN1dGlvbkNvdW50ID0gZXhlY3V0aW9uQ291bnQ7Ci0JCX0KLQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJdGhpcy50aHJlYWRMb2NhbENvbW1hbmRFeGVjdXRvci5zZXQodGhpcy50ZXN0Q29tbWFuZEV4ZWN1dG9yKTsKLQkJCWZvciAoaW50IGkgPSAwOyBpIDwgdGhpcy5leGVjdXRpb25Db3VudDsgaSsrKSB7Ci0JCQkJdGhpcy50aHJlYWRMb2NhbENvbW1hbmRFeGVjdXRvci5leGVjdXRlKHRoaXMudGVzdENvbW1hbmQpOwotCQkJfQotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0NvbW1hbmRUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9Db21tYW5kVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMTYwYzc3Zi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0NvbW1hbmRUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTE2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWw7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci0KLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5Db21tYW5kOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LkNvbW1hbmRFeGVjdXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db21tYW5kUnVubmFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuUnVubmFibGVDb21tYW5kOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlRocmVhZExvY2FsQ29tbWFuZDsKLQotcHVibGljIGNsYXNzIENvbW1hbmRUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBDb21tYW5kVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE51bGxDb21tYW5kKCkgewotCQlDb21tYW5kIGNvbW1hbmQgPSBDb21tYW5kLk51bGwuaW5zdGFuY2UoKTsKLQkJY29tbWFuZC5leGVjdXRlKCk7ICAvLyBqdXN0IG1ha2Ugc3VyZSBpdCBkb2Vzbid0IGJsb3cgdXA/Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdERpc2FibGVkQ29tbWFuZCgpIHsKLQkJQ29tbWFuZCBjb21tYW5kID0gQ29tbWFuZC5EaXNhYmxlZC5pbnN0YW5jZSgpOwotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQljb21tYW5kLmV4ZWN1dGUoKTsKLQkJCWZhaWwoKTsKLQkJfSBjYXRjaCAoVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UnVubmFibGVDb21tYW5kKCkgewotCQlTaW1wbGVUZXN0UnVubmFibGUgdGVzdFJ1bm5hYmxlID0gbmV3IFNpbXBsZVRlc3RSdW5uYWJsZSgpOwotCQlhc3NlcnRGYWxzZSh0ZXN0UnVubmFibGUucmFuKTsKLQkJQ29tbWFuZCBjb21tYW5kID0gbmV3IFJ1bm5hYmxlQ29tbWFuZCh0ZXN0UnVubmFibGUpOwotCQljb21tYW5kLmV4ZWN1dGUoKTsKLQkJYXNzZXJ0VHJ1ZSh0ZXN0UnVubmFibGUucmFuKTsKLQl9Ci0KLQlzdGF0aWMgY2xhc3MgU2ltcGxlVGVzdFJ1bm5hYmxlIGltcGxlbWVudHMgUnVubmFibGUgewotCQlib29sZWFuIHJhbiA9IGZhbHNlOwotCQlwdWJsaWMgdm9pZCBydW4oKSB7Ci0JCQl0aGlzLnJhbiA9IHRydWU7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29tbWFuZFJ1bm5hYmxlKCkgewotCQlUZXN0Q29tbWFuZCB0ZXN0Q29tbWFuZCA9IG5ldyBUZXN0Q29tbWFuZCgpOwotCQlhc3NlcnRFcXVhbHMoMCwgdGVzdENvbW1hbmQuY291bnQpOwotCQlSdW5uYWJsZSBydW5uYWJsZSA9IG5ldyBDb21tYW5kUnVubmFibGUodGVzdENvbW1hbmQpOwotCQlydW5uYWJsZS5ydW4oKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIHRlc3RDb21tYW5kLmNvdW50KTsKLQl9Ci0KLQlzdGF0aWMgY2xhc3MgVGVzdENvbW1hbmQgaW1wbGVtZW50cyBDb21tYW5kIHsKLQkJaW50IGNvdW50ID0gMDsKLQkJcHVibGljIHZvaWQgZXhlY3V0ZSgpIHsKLQkJCXRoaXMuY291bnQrKzsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RUaHJlYWRMb2NhbENvbW1hbmQoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGhyZWFkTG9jYWxDb21tYW5kIHRocmVhZExvY2FsQ29tbWFuZCA9IG5ldyBUaHJlYWRMb2NhbENvbW1hbmQoKTsKLQkJVGVzdFJ1bm5hYmxlIHRlc3RSdW5uYWJsZTEgPSBuZXcgVGVzdFJ1bm5hYmxlKHRocmVhZExvY2FsQ29tbWFuZCwgMSk7Ci0JCVRocmVhZCB0aHJlYWQxID0gbmV3IFRocmVhZCh0ZXN0UnVubmFibGUxKTsKLQkJdGhyZWFkMS5ydW4oKTsKLQotCQlUZXN0UnVubmFibGUgdGVzdFJ1bm5hYmxlMiA9IG5ldyBUZXN0UnVubmFibGUodGhyZWFkTG9jYWxDb21tYW5kLCAyKTsKLQkJVGhyZWFkIHRocmVhZDIgPSBuZXcgVGhyZWFkKHRlc3RSdW5uYWJsZTIpOwotCQl0aHJlYWQyLnJ1bigpOwotCi0JCXRocmVhZDEuam9pbigpOwotCQl0aHJlYWQyLmpvaW4oKTsKLQotCQlhc3NlcnRFcXVhbHMoMSwgdGVzdFJ1bm5hYmxlMS50ZXN0Q29tbWFuZC5jb3VudCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDIsIHRlc3RSdW5uYWJsZTIudGVzdENvbW1hbmQuY291bnQpOwotCX0KLQotCXN0YXRpYyBjbGFzcyBUZXN0Q29tbWFuZEV4ZWN1dG9yIGltcGxlbWVudHMgQ29tbWFuZEV4ZWN1dG9yIHsKLQkJaW50IGNvdW50ID0gMDsKLQkJcHVibGljIHZvaWQgZXhlY3V0ZShDb21tYW5kIGNvbW1hbmQpIHsKLQkJCXRoaXMuY291bnQrKzsKLQkJCWNvbW1hbmQuZXhlY3V0ZSgpOwotCQl9Ci0JfQotCi0Jc3RhdGljIGNsYXNzIFRlc3RSdW5uYWJsZSBpbXBsZW1lbnRzIFJ1bm5hYmxlIHsKLQkJZmluYWwgVGhyZWFkTG9jYWxDb21tYW5kIHRocmVhZExvY2FsQ29tbWFuZDsKLQkJZmluYWwgaW50IGV4ZWN1dGlvbkNvdW50OwotCQlmaW5hbCBUZXN0Q29tbWFuZCB0ZXN0Q29tbWFuZCA9IG5ldyBUZXN0Q29tbWFuZCgpOwotCQlUZXN0UnVubmFibGUoVGhyZWFkTG9jYWxDb21tYW5kIHRocmVhZExvY2FsQ29tbWFuZCwgaW50IGV4ZWN1dGlvbkNvdW50KSB7Ci0JCQlzdXBlcigpOwotCQkJdGhpcy50aHJlYWRMb2NhbENvbW1hbmQgPSB0aHJlYWRMb2NhbENvbW1hbmQ7Ci0JCQl0aGlzLmV4ZWN1dGlvbkNvdW50ID0gZXhlY3V0aW9uQ291bnQ7Ci0JCX0KLQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJdGhpcy50aHJlYWRMb2NhbENvbW1hbmQuc2V0KHRoaXMudGVzdENvbW1hbmQpOwotCQkJZm9yIChpbnQgaSA9IDA7IGkgPCB0aGlzLmV4ZWN1dGlvbkNvdW50OyBpKyspIHsKLQkJCQl0aGlzLnRocmVhZExvY2FsQ29tbWFuZC5leGVjdXRlKCk7Ci0JCQl9Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvQ291bnRlclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0NvdW50ZXJUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5OTUzZTBlLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvQ291bnRlclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw5MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsOwotCi1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvdW50ZXI7Ci0KLXB1YmxpYyBjbGFzcyBDb3VudGVyVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQlwdWJsaWMgQ291bnRlclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDdG9ycygpIHsKLQkJQ291bnRlciBjb3VudGVyOwotCQljb3VudGVyID0gbmV3IENvdW50ZXIoKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGNvdW50ZXIuY291bnQoKSk7Ci0JCWNvdW50ZXIgPSBuZXcgQ291bnRlcig3KTsKLQkJYXNzZXJ0RXF1YWxzKDcsIGNvdW50ZXIuY291bnQoKSk7Ci0JCWNvdW50ZXIgPSBuZXcgQ291bnRlcigtNyk7Ci0JCWFzc2VydEVxdWFscygtNywgY291bnRlci5jb3VudCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW5jcmVtZW50KCkgewotCQlDb3VudGVyIGNvdW50ZXI7Ci0JCWludCBjb3VudDsKLQkJY291bnRlciA9IG5ldyBDb3VudGVyKCk7Ci0JCWFzc2VydEVxdWFscygwLCBjb3VudGVyLmNvdW50KCkpOwotCi0JCWNvdW50ID0gY291bnRlci5pbmNyZW1lbnQoMyk7Ci0JCWFzc2VydEVxdWFscygzLCBjb3VudCk7Ci0JCWFzc2VydEVxdWFscygzLCBjb3VudGVyLmNvdW50KCkpOwotCi0JCWNvdW50ID0gY291bnRlci5pbmNyZW1lbnQoKTsKLQkJYXNzZXJ0RXF1YWxzKDQsIGNvdW50KTsKLQkJYXNzZXJ0RXF1YWxzKDQsIGNvdW50ZXIuY291bnQoKSk7Ci0KLQkJY291bnQgPSBjb3VudGVyLmluY3JlbWVudCgtNyk7Ci0JCWFzc2VydEVxdWFscygtMywgY291bnQpOwotCQlhc3NlcnRFcXVhbHMoLTMsIGNvdW50ZXIuY291bnQoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdERlY3JlbWVudCgpIHsKLQkJQ291bnRlciBjb3VudGVyOwotCQlpbnQgY291bnQ7Ci0JCWNvdW50ZXIgPSBuZXcgQ291bnRlcigpOwotCQlhc3NlcnRFcXVhbHMoMCwgY291bnRlci5jb3VudCgpKTsKLQotCQljb3VudCA9IGNvdW50ZXIuZGVjcmVtZW50KDMpOwotCQlhc3NlcnRFcXVhbHMoLTMsIGNvdW50KTsKLQkJYXNzZXJ0RXF1YWxzKC0zLCBjb3VudGVyLmNvdW50KCkpOwotCi0JCWNvdW50ID0gY291bnRlci5kZWNyZW1lbnQoKTsKLQkJYXNzZXJ0RXF1YWxzKC00LCBjb3VudCk7Ci0JCWFzc2VydEVxdWFscygtNCwgY291bnRlci5jb3VudCgpKTsKLQotCQljb3VudCA9IGNvdW50ZXIuZGVjcmVtZW50KC03KTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGNvdW50KTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGNvdW50ZXIuY291bnQoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENsb25lKCkgewotCQlDb3VudGVyIGNvdW50ZXIgPSBuZXcgQ291bnRlcig0NCk7Ci0JCUNvdW50ZXIgY291bnRlcjIgPSAoQ291bnRlcikgY291bnRlci5jbG9uZSgpOwotCQlhc3NlcnRFcXVhbHMoNDQsIGNvdW50ZXIyLmNvdW50KCkpOwotCQlhc3NlcnRFcXVhbHMoY291bnRlciwgY291bnRlcjIpOwotCQlhc3NlcnROb3RTYW1lKGNvdW50ZXIsIGNvdW50ZXIyKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RXF1YWxzKCkgewotCQlDb3VudGVyIGNvdW50ZXIgPSBuZXcgQ291bnRlcig0NCk7Ci0JCUNvdW50ZXIgY291bnRlcjIgPSBuZXcgQ291bnRlcig0NCk7Ci0JCWFzc2VydEVxdWFscyhjb3VudGVyLCBjb3VudGVyMik7Ci0JCWFzc2VydEVxdWFscyhjb3VudGVyLmhhc2hDb2RlKCksIGNvdW50ZXIyLmhhc2hDb2RlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXJpYWxpemF0aW9uKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCUNvdW50ZXIgY291bnRlciA9IG5ldyBDb3VudGVyKDQ0KTsKLQkJQ291bnRlciBjb3VudGVyMiA9IFRlc3RUb29scy5zZXJpYWxpemUoY291bnRlcik7Ci0JCWFzc2VydEVxdWFscyg0NCwgY291bnRlcjIuY291bnQoKSk7Ci0JCWFzc2VydEVxdWFscyhjb3VudGVyLCBjb3VudGVyMik7Ci0JCWFzc2VydE5vdFNhbWUoY291bnRlciwgY291bnRlcjIpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9FbXB0eUl0ZXJhYmxlVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvRW1wdHlJdGVyYWJsZVRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGFkNmYxNDUuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9FbXB0eUl0ZXJhYmxlVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDMwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWw7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuRW1wdHlJdGVyYWJsZTsKLQotcHVibGljIGNsYXNzIEVtcHR5SXRlcmFibGVUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBFbXB0eUl0ZXJhYmxlVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZXJhdG9yKCkgewotCQlpbnQgaSA9IDA7Ci0JCWZvciAoU3RyaW5nIHN0cmluZyA6IEVtcHR5SXRlcmFibGUuPFN0cmluZz5pbnN0YW5jZSgpKSB7Ci0JCQlmYWlsKCJib2d1cyBzdHJpbmc6ICIgKyBzdHJpbmcpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscygwLCBpKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvRmlsZVRvb2xzVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvRmlsZVRvb2xzVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYWRjY2NmMC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0ZpbGVUb29sc1Rlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1OTQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uRmlsZTsKLWltcG9ydCBqYXZhLmlvLkZpbGVGaWx0ZXI7Ci1pbXBvcnQgamF2YS5pby5GaWxlSW5wdXRTdHJlYW07Ci1pbXBvcnQgamF2YS5pby5GaWxlT3V0cHV0U3RyZWFtOwotaW1wb3J0IGphdmEuaW8uSU9FeGNlcHRpb247Ci1pbXBvcnQgamF2YS5pby5JbnB1dFN0cmVhbVJlYWRlcjsKLWltcG9ydCBqYXZhLmlvLk91dHB1dFN0cmVhbVdyaXRlcjsKLWltcG9ydCBqYXZhLmlvLlJlYWRlcjsKLWltcG9ydCBqYXZhLmlvLldyaXRlcjsKLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5JbnZvY2F0aW9uVGFyZ2V0RXhjZXB0aW9uOwotaW1wb3J0IGphdmEubmV0LlVSTDsKLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlzOwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuRmlsZVRvb2xzOwotCi1wdWJsaWMgY2xhc3MgRmlsZVRvb2xzVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBGaWxlIHRlbXBEaXI7Ci0KLQlwdWJsaWMgRmlsZVRvb2xzVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy50ZW1wRGlyID0gdGhpcy5idWlsZFRlbXBEaXIoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci50ZWFyRG93bigpOwotCQl0aGlzLmRlbGV0ZURpcih0aGlzLnRlbXBEaXIpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RGaWxlc0luKCkgewotCQlDb2xsZWN0aW9uPEZpbGU+IGZpbGVzID0gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24oRmlsZVRvb2xzLmZpbGVzSW4odGhpcy50ZW1wRGlyLmdldFBhdGgoKSkpOwotCQlhc3NlcnRFcXVhbHMoImludmFsaWQgZmlsZSBjb3VudCIsIDMsIGZpbGVzLnNpemUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdERpcmVjdG9yaWVzSW4oKSB7Ci0JCUNvbGxlY3Rpb248RmlsZT4gZmlsZXMgPSBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbihGaWxlVG9vbHMuZGlyZWN0b3JpZXNJbih0aGlzLnRlbXBEaXIuZ2V0UGF0aCgpKSk7Ci0JCWFzc2VydEVxdWFscygiaW52YWxpZCBkaXJlY3RvcnkgY291bnQiLCAyLCBmaWxlcy5zaXplKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RGaWxlc0luVHJlZSgpIHsKLQkJQ29sbGVjdGlvbjxGaWxlPiBmaWxlcyA9IENvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKEZpbGVUb29scy5maWxlc0luVHJlZSh0aGlzLnRlbXBEaXIuZ2V0UGF0aCgpKSk7Ci0JCWFzc2VydEVxdWFscygiaW52YWxpZCBmaWxlIGNvdW50IiwgOSwgZmlsZXMuc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGlyZWN0b3JpZXNJblRyZWUoKSB7Ci0JCUNvbGxlY3Rpb248RmlsZT4gZmlsZXMgPSBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbihGaWxlVG9vbHMuZGlyZWN0b3JpZXNJblRyZWUodGhpcy50ZW1wRGlyLmdldFBhdGgoKSkpOwotCQlhc3NlcnRFcXVhbHMoImludmFsaWQgZGlyZWN0b3J5IGNvdW50IiwgMywgZmlsZXMuc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGVsZXRlRGlyZWN0b3J5KCkgdGhyb3dzIElPRXhjZXB0aW9uIHsKLQkJLy8gYnVpbGQgYW5vdGhlciB0ZW1wb3JhcnkgZGlyZWN0b3J5IGp1c3QgZm9yIHRoaXMgdGVzdAotCQlGaWxlIGRpciA9IHRoaXMuYnVpbGRUZW1wRGlyKCk7Ci0JCWFzc2VydFRydWUoInRlbXBvcmFyeSBkaXJlY3Rvcnkgbm90IGNyZWF0ZWQiLCBkaXIuZXhpc3RzKCkpOwotCQlGaWxlVG9vbHMuZGVsZXRlRGlyZWN0b3J5KGRpci5nZXRQYXRoKCkpOwotCQlhc3NlcnRGYWxzZSgidGVtcG9yYXJ5IGRpcmVjdG9yeSBub3QgZGVsZXRlZCIsIGRpci5leGlzdHMoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdERlbGV0ZURpcmVjdG9yeUNvbnRlbnRzKCkgdGhyb3dzIElPRXhjZXB0aW9uIHsKLQkJLy8gYnVpbGQgYW5vdGhlciB0ZW1wb3JhcnkgZGlyZWN0b3J5IGp1c3QgZm9yIHRoaXMgdGVzdAotCQlGaWxlIGRpciA9IHRoaXMuYnVpbGRUZW1wRGlyKCk7Ci0JCWFzc2VydFRydWUoInRlbXBvcmFyeSBkaXJlY3Rvcnkgbm90IGNyZWF0ZWQiLCBkaXIuZXhpc3RzKCkpOwotCQlGaWxlVG9vbHMuZGVsZXRlRGlyZWN0b3J5Q29udGVudHMoZGlyLmdldFBhdGgoKSk7Ci0JCWFzc2VydFRydWUoInRlbXBvcmFyeSBkaXJlY3Rvcnkgc2hvdWxkIG5vdCBoYXZlIGJlZW4gZGVsZXRlZCIsIGRpci5leGlzdHMoKSk7Ci0JCWFzc2VydFRydWUoInRlbXBvcmFyeSBkaXJlY3RvcnkgY29udGVudHMgbm90IGRlbGV0ZWQiLCBkaXIubGlzdEZpbGVzKCkubGVuZ3RoID09IDApOwotCQlkaXIuZGVsZXRlKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvcHlUb0ZpbGUoKSB0aHJvd3MgSU9FeGNlcHRpb24gewotCQlGaWxlIGRlc3RGaWxlID0gbmV3IEZpbGUodGhpcy50ZW1wRGlyLCAiZGVzdGZpbGUudHh0Iik7Ci0JCXRoaXMuY29weVRvRmlsZShkZXN0RmlsZSwgInRlc3RDb3B5VG9GaWxlIik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvcHlUb1ByZUV4aXN0aW5nRmlsZSgpIHRocm93cyBJT0V4Y2VwdGlvbiB7Ci0JCUZpbGUgZGVzdEZpbGUgPSBuZXcgRmlsZSh0aGlzLnRlbXBEaXIsICJkZXN0ZmlsZS50eHQiKTsKLQkJV3JpdGVyIHdyaXRlciA9IG5ldyBPdXRwdXRTdHJlYW1Xcml0ZXIobmV3IEZpbGVPdXRwdXRTdHJlYW0oZGVzdEZpbGUpKTsKLQkJd3JpdGVyLndyaXRlKCJ0aGlzIHRleHQgc2hvdWxkIGJlIHJlcGxhY2VkLi4uIik7Ci0JCXdyaXRlci5jbG9zZSgpOwotCQl0aGlzLmNvcHlUb0ZpbGUoZGVzdEZpbGUsICJ0ZXN0Q29weVRvUHJlRXhpc3RpbmdGaWxlIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGNvcHlUb0ZpbGUoRmlsZSBkZXN0RmlsZSwgU3RyaW5nIHdyaXRlU3RyaW5nKSB0aHJvd3MgSU9FeGNlcHRpb24gewotCQlGaWxlIHNvdXJjZUZpbGUgPSBuZXcgRmlsZSh0aGlzLnRlbXBEaXIsICJzb3VyY2VmaWxlLnR4dCIpOwotCQljaGFyW10gcmVhZEJ1ZmZlciA9IG5ldyBjaGFyW3dyaXRlU3RyaW5nLmxlbmd0aCgpXTsKLQotCQlXcml0ZXIgd3JpdGVyID0gbmV3IE91dHB1dFN0cmVhbVdyaXRlcihuZXcgRmlsZU91dHB1dFN0cmVhbShzb3VyY2VGaWxlKSk7Ci0JCXdyaXRlci53cml0ZSh3cml0ZVN0cmluZyk7Ci0JCXdyaXRlci5jbG9zZSgpOwotCi0JCUZpbGVUb29scy5jb3B5VG9GaWxlKHNvdXJjZUZpbGUsIGRlc3RGaWxlKTsKLQotCQlSZWFkZXIgcmVhZGVyID0gbmV3IElucHV0U3RyZWFtUmVhZGVyKG5ldyBGaWxlSW5wdXRTdHJlYW0oZGVzdEZpbGUpKTsKLQkJcmVhZGVyLnJlYWQocmVhZEJ1ZmZlcik7Ci0JCXJlYWRlci5jbG9zZSgpOwotCQlTdHJpbmcgcmVhZFN0cmluZyA9IG5ldyBTdHJpbmcocmVhZEJ1ZmZlcik7Ci0JCWFzc2VydEVxdWFscyh3cml0ZVN0cmluZywgcmVhZFN0cmluZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvcHlUb0RpcmVjdG9yeSgpIHRocm93cyBJT0V4Y2VwdGlvbiB7Ci0JCUZpbGUgc291cmNlRmlsZSA9IG5ldyBGaWxlKHRoaXMudGVtcERpciwgInNvdXJjZWZpbGUudHh0Iik7Ci0JCVN0cmluZyB3cml0ZVN0cmluZyA9ICJ0ZXN0Q29weVRvRGlyZWN0b3J5IjsKLQotCQlGaWxlIGRlc3REaXIgPSBuZXcgRmlsZSh0aGlzLnRlbXBEaXIsICJkZXN0ZGlyIik7Ci0JCWRlc3REaXIubWtkaXIoKTsKLQkJRmlsZSBkZXN0RmlsZSA9IG5ldyBGaWxlKGRlc3REaXIsICJzb3VyY2VmaWxlLnR4dCIpOwotCQljaGFyW10gcmVhZEJ1ZmZlciA9IG5ldyBjaGFyW3dyaXRlU3RyaW5nLmxlbmd0aCgpXTsKLQotCQlXcml0ZXIgd3JpdGVyID0gbmV3IE91dHB1dFN0cmVhbVdyaXRlcihuZXcgRmlsZU91dHB1dFN0cmVhbShzb3VyY2VGaWxlKSk7Ci0JCXdyaXRlci53cml0ZSh3cml0ZVN0cmluZyk7Ci0JCXdyaXRlci5jbG9zZSgpOwotCi0JCUZpbGVUb29scy5jb3B5VG9EaXJlY3Rvcnkoc291cmNlRmlsZSwgZGVzdERpcik7Ci0KLQkJUmVhZGVyIHJlYWRlciA9IG5ldyBJbnB1dFN0cmVhbVJlYWRlcihuZXcgRmlsZUlucHV0U3RyZWFtKGRlc3RGaWxlKSk7Ci0JCXJlYWRlci5yZWFkKHJlYWRCdWZmZXIpOwotCQlyZWFkZXIuY2xvc2UoKTsKLQkJU3RyaW5nIHJlYWRTdHJpbmcgPSBuZXcgU3RyaW5nKHJlYWRCdWZmZXIpOwotCQlhc3NlcnRFcXVhbHMod3JpdGVTdHJpbmcsIHJlYWRTdHJpbmcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RGaWx0ZXIoKSB0aHJvd3MgSU9FeGNlcHRpb24gewotCQlTdHJpbmcgcHJlZml4ID0gIlhYWHRlc3RGaWxlWFhYIjsKLQkJRmlsZSB0ZXN0RmlsZTEgPSBuZXcgRmlsZSh0aGlzLnRlbXBEaXIsIHByZWZpeCArICIxIik7Ci0JCXRlc3RGaWxlMS5jcmVhdGVOZXdGaWxlKCk7Ci0JCUZpbGUgdGVzdEZpbGUyID0gbmV3IEZpbGUodGhpcy50ZW1wRGlyLCBwcmVmaXggKyAiMiIpOwotCQl0ZXN0RmlsZTIuY3JlYXRlTmV3RmlsZSgpOwotCi0JCUZpbGVGaWx0ZXIgZmlsdGVyID0gdGhpcy5idWlsZEZpbGVGaWx0ZXIocHJlZml4KTsKLQkJSXRlcmF0b3I8RmlsZT4gZmlsdGVyZWRGaWxlc0l0ZXJhdG9yID0gRmlsZVRvb2xzLmZpbHRlcihGaWxlVG9vbHMuZmlsZXNJbih0aGlzLnRlbXBEaXIpLCBmaWx0ZXIpOwotCQlDb2xsZWN0aW9uPEZpbGU+IGZpbHRlcmVkRmlsZXMgPSBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbihmaWx0ZXJlZEZpbGVzSXRlcmF0b3IpOwotCQlhc3NlcnRFcXVhbHMoMiwgZmlsdGVyZWRGaWxlcy5zaXplKCkpOwotCQlhc3NlcnRUcnVlKGZpbHRlcmVkRmlsZXMuY29udGFpbnModGVzdEZpbGUxKSk7Ci0JCWFzc2VydFRydWUoZmlsdGVyZWRGaWxlcy5jb250YWlucyh0ZXN0RmlsZTIpKTsKLQl9Ci0KLQlwcml2YXRlIEZpbGVGaWx0ZXIgYnVpbGRGaWxlRmlsdGVyKGZpbmFsIFN0cmluZyBwcmVmaXgpIHsKLQkJcmV0dXJuIG5ldyBGaWxlRmlsdGVyKCkgewotCQkJcHVibGljIGJvb2xlYW4gYWNjZXB0KEZpbGUgZmlsZSkgewotCQkJCXJldHVybiBmaWxlLmdldE5hbWUoKS5zdGFydHNXaXRoKHByZWZpeCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFN0cmlwRXh0ZW5zaW9uKCkgewotCQlhc3NlcnRFcXVhbHMoImZvbyIsIEZpbGVUb29scy5zdHJpcEV4dGVuc2lvbigiZm9vLnhtbCIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28uYmFyIiwgRmlsZVRvb2xzLnN0cmlwRXh0ZW5zaW9uKCJmb28uYmFyLnhtbCIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCBGaWxlVG9vbHMuc3RyaXBFeHRlbnNpb24oImZvbyIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCBGaWxlVG9vbHMuc3RyaXBFeHRlbnNpb24oImZvby4iKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEV4dGVuc2lvbigpIHsKLQkJYXNzZXJ0RXF1YWxzKCIueG1sIiwgRmlsZVRvb2xzLmV4dGVuc2lvbigiZm9vLnhtbCIpKTsKLQkJYXNzZXJ0RXF1YWxzKCIueG1sIiwgRmlsZVRvb2xzLmV4dGVuc2lvbigiZm9vLmJhci54bWwiKSk7Ci0JCWFzc2VydEVxdWFscygiIiwgRmlsZVRvb2xzLmV4dGVuc2lvbigiZm9vIikpOwotCQlhc3NlcnRFcXVhbHMoIiIsIEZpbGVUb29scy5leHRlbnNpb24oImZvbyx4bWwiKSk7Ci0JCWFzc2VydEVxdWFscygiLiIsIEZpbGVUb29scy5leHRlbnNpb24oImZvby4iKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEVtcHR5VGVtcG9yYXJ5RGlyZWN0b3J5KCkgdGhyb3dzIElPRXhjZXB0aW9uIHsKLQkJRmlsZSB0ZW1wRGlyMSA9IEZpbGVUb29scy50ZW1wb3JhcnlEaXJlY3RvcnkoKTsKLQkJRmlsZSB0ZXN0RmlsZTEgPSBuZXcgRmlsZSh0ZW1wRGlyMSwgImp1bmsiKTsKLQkJdGVzdEZpbGUxLmNyZWF0ZU5ld0ZpbGUoKTsKLQotCQlGaWxlIHRlbXBEaXIyID0gRmlsZVRvb2xzLmVtcHR5VGVtcG9yYXJ5RGlyZWN0b3J5KCk7Ci0JCWFzc2VydEVxdWFscyh0ZW1wRGlyMSwgdGVtcERpcjIpOwotCQlhc3NlcnRUcnVlKHRlbXBEaXIyLmlzRGlyZWN0b3J5KCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgdGVtcERpcjIubGlzdEZpbGVzKCkubGVuZ3RoKTsKLQkJdGVtcERpcjIuZGVsZXRlKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENhbm9uaWNhbEZpbGVOYW1lKCkgewotCQlGaWxlIGZpbGUxID0gbmV3IEZpbGUoImZvbyIpOwotCQlmaWxlMSA9IG5ldyBGaWxlKGZpbGUxLCAiYmFyIik7Ci0JCWZpbGUxID0gbmV3IEZpbGUoZmlsZTEsICJiYXoiKTsKLQkJZmlsZTEgPSBuZXcgRmlsZShmaWxlMSwgIi4uIik7Ci0JCWZpbGUxID0gbmV3IEZpbGUoZmlsZTEsICIuLiIpOwotCQlmaWxlMSA9IG5ldyBGaWxlKGZpbGUxLCAiYmFyIik7Ci0JCWZpbGUxID0gbmV3IEZpbGUoZmlsZTEsICJiYXoiKTsKLQkJRmlsZSBmaWxlMiA9IG5ldyBGaWxlKFN5c3RlbS5nZXRQcm9wZXJ0eSgidXNlci5kaXIiKSk7Ci0JCWZpbGUyID0gbmV3IEZpbGUoZmlsZTIsICJmb28iKTsKLQkJZmlsZTIgPSBuZXcgRmlsZShmaWxlMiwgImJhciIpOwotCQlmaWxlMiA9IG5ldyBGaWxlKGZpbGUyLCAiYmF6Iik7Ci0JCUZpbGUgZmlsZTMgPSBGaWxlVG9vbHMuY2Fub25pY2FsRmlsZShmaWxlMSk7Ci0JCWFzc2VydEVxdWFscyhmaWxlMiwgZmlsZTMpOwotCX0KLQotCXByaXZhdGUgYm9vbGVhbiBpc0V4ZWN1dGluZ09uV2luZG93cygpIHsKLQkJcmV0dXJuIHRoaXMuaXNFeGVjdXRpbmdPbigiV2luZG93cyIpOwotCX0KLQotCS8vCXByaXZhdGUgYm9vbGVhbiBpc0V4ZWN1dGluZ09uTGludXgoKSB7Ci0JLy8JCXJldHVybiB0aGlzLmlzRXhlY3V0aW5nT24oIkxpbnV4Iik7Ci0JLy8JfQotCS8vCi0JcHJpdmF0ZSBib29sZWFuIGlzRXhlY3V0aW5nT24oU3RyaW5nIG9zTmFtZSkgewotCQlyZXR1cm4gU3lzdGVtLmdldFByb3BlcnR5KCJvcy5uYW1lIikuaW5kZXhPZihvc05hbWUpICE9IC0xOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RQYXRoRmlsZXMoKSB7Ci0JCUZpbGVbXSBleHBlY3RlZDsKLQkJRmlsZVtdIGFjdHVhbDsKLQotCQlpZiAodGhpcy5pc0V4ZWN1dGluZ09uV2luZG93cygpKSB7Ci0JCQlleHBlY3RlZCA9IG5ldyBGaWxlW10geyBuZXcgRmlsZSgiQzovIiksIG5ldyBGaWxlKCJDOi9mb28iKSwgbmV3IEZpbGUoIkM6L2Zvby9iYXIiKSwgbmV3IEZpbGUoIkM6L2Zvby9iYXIvYmF6LnR4dCIpIH07Ci0JCQlhY3R1YWwgPSB0aGlzLnBhdGhGaWxlcyhuZXcgRmlsZSgiQzovZm9vL2Jhci9iYXoudHh0IikpOwotCQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBhY3R1YWwpKTsKLQkJfQotCi0JCWV4cGVjdGVkID0gbmV3IEZpbGVbXSB7IG5ldyBGaWxlKCIvIiksIG5ldyBGaWxlKCIvZm9vIiksIG5ldyBGaWxlKCIvZm9vL2JhciIpLCBuZXcgRmlsZSgiL2Zvby9iYXIvYmF6LnR4dCIpIH07Ci0JCWFjdHVhbCA9IHRoaXMucGF0aEZpbGVzKG5ldyBGaWxlKCIvZm9vL2Jhci9iYXoudHh0IikpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGFjdHVhbCkpOwotCi0JCWV4cGVjdGVkID0gbmV3IEZpbGVbXSB7IG5ldyBGaWxlKCJmb28iKSwgbmV3IEZpbGUoImZvby9iYXIiKSwgbmV3IEZpbGUoImZvby9iYXIvYmF6LnR4dCIpIH07Ci0JCWFjdHVhbCA9IHRoaXMucGF0aEZpbGVzKG5ldyBGaWxlKCJmb28vYmFyL2Jhei50eHQiKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgYWN0dWFsKSk7Ci0KLQkJZXhwZWN0ZWQgPSBuZXcgRmlsZVtdIHsgbmV3IEZpbGUoIi4uIiksIG5ldyBGaWxlKCIuLi9mb28iKSwgbmV3IEZpbGUoIi4uL2Zvby9iYXIiKSwgbmV3IEZpbGUoIi4uL2Zvby9iYXIvYmF6LnR4dCIpIH07Ci0JCWFjdHVhbCA9IHRoaXMucGF0aEZpbGVzKG5ldyBGaWxlKCIuLi9mb28vYmFyL2Jhei50eHQiKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgYWN0dWFsKSk7Ci0KLQkJZXhwZWN0ZWQgPSBuZXcgRmlsZVtdIHsgbmV3IEZpbGUoIi4iKSwgbmV3IEZpbGUoIi4vZm9vIiksIG5ldyBGaWxlKCIuL2Zvby9iYXIiKSwgbmV3IEZpbGUoIi4vZm9vL2Jhci9iYXoudHh0IikgfTsKLQkJYWN0dWFsID0gdGhpcy5wYXRoRmlsZXMobmV3IEZpbGUoIi4vZm9vL2Jhci9iYXoudHh0IikpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGFjdHVhbCkpOwotCX0KLQotCXByaXZhdGUgRmlsZVtdIHBhdGhGaWxlcyhGaWxlIGZpbGUpIHsKLQkJcmV0dXJuIChGaWxlW10pIENsYXNzVG9vbHMuZXhlY3V0ZVN0YXRpY01ldGhvZChGaWxlVG9vbHMuY2xhc3MsICJwYXRoRmlsZXMiLCBGaWxlLmNsYXNzLCBmaWxlKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVsYXRpdmVQYXJlbnRGaWxlKCkgewotCQlhc3NlcnRFcXVhbHMobmV3IEZpbGUoIi4uIiksIHRoaXMucmVsYXRpdmVQYXJlbnRGaWxlKDEpKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBGaWxlKCIuLi8uLiIpLCB0aGlzLnJlbGF0aXZlUGFyZW50RmlsZSgyKSk7Ci0JCWFzc2VydEVxdWFscyhuZXcgRmlsZSgiLi4vLi4vLi4iKSwgdGhpcy5yZWxhdGl2ZVBhcmVudEZpbGUoMykpOwotCi0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCUZpbGUgZmlsZSA9IHRoaXMucmVsYXRpdmVQYXJlbnRGaWxlKDApOwotCQkJZmFpbCgiaW52YWxpZCByZXR1cm46ICIgKyBmaWxlKTsKLQkJfSBjYXRjaCAoUnVudGltZUV4Y2VwdGlvbiBleCkgewotCQkJaWYgKGV4LmdldENhdXNlKCkgaW5zdGFuY2VvZiBJbnZvY2F0aW9uVGFyZ2V0RXhjZXB0aW9uKSB7Ci0JCQkJSW52b2NhdGlvblRhcmdldEV4Y2VwdGlvbiBpdGUgPSAoSW52b2NhdGlvblRhcmdldEV4Y2VwdGlvbikgZXguZ2V0Q2F1c2UoKTsKLQkJCQlpZiAoaXRlLmdldFRhcmdldEV4Y2VwdGlvbigpIGluc3RhbmNlb2YgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKSB7Ci0JCQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHJpdmF0ZSBGaWxlIHJlbGF0aXZlUGFyZW50RmlsZShpbnQgbGVuKSB7Ci0JCXJldHVybiAoRmlsZSkgQ2xhc3NUb29scy5leGVjdXRlU3RhdGljTWV0aG9kKEZpbGVUb29scy5jbGFzcywgInJlbGF0aXZlUGFyZW50RmlsZSIsIGludC5jbGFzcywgbmV3IEludGVnZXIobGVuKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnZlcnRUb1JlbGF0aXZlRmlsZSgpIHsKLQkJU3RyaW5nIHByZWZpeCA9IHRoaXMuaXNFeGVjdXRpbmdPbldpbmRvd3MoKSA/ICJDOiIgOiAiIjsKLQkJRmlsZSBmaWxlOwotCQlGaWxlIGRpcjsKLQkJRmlsZSByZWxhdGl2ZUZpbGU7Ci0KLQkJaWYgKHRoaXMuaXNFeGVjdXRpbmdPbldpbmRvd3MoKSkgewotCQkJLy8gb24gV2luZG93cywgYSBkcml2ZSBtdXN0IGJlIHNwZWNpZmllZCBmb3IgYSBmaWxlIHRvIGJlIGFic29sdXRlIChpLmUuIG5vdCByZWxhdGl2ZSkKLQkJCXRoaXMudmVyaWZ5VW5jaGFuZ2VkUmVsYXRpdmVGaWxlKCIvZGlyMS9kaXIyL2ZpbGUudHh0IiwgIkM6L2RpcjEvZGlyMiIpOwotCQkJLy8gZGlmZmVyZW50IGRyaXZlcwotCQkJdGhpcy52ZXJpZnlVbmNoYW5nZWRSZWxhdGl2ZUZpbGUoIkQ6L2RpcjEvZGlyMi9maWxlLnR4dCIsICJDOi9kaXIxL2RpcjIiKTsKLQkJfQotCQl0aGlzLnZlcmlmeVVuY2hhbmdlZFJlbGF0aXZlRmlsZSgiZGlyMS9kaXIyL2ZpbGUudHh0IiwgcHJlZml4ICsgIi9kaXIxL2RpcjIiKTsKLQkJdGhpcy52ZXJpZnlVbmNoYW5nZWRSZWxhdGl2ZUZpbGUoIi4vZGlyMS9kaXIyL2ZpbGUudHh0IiwgcHJlZml4ICsgIi9kaXIxL2RpcjIiKTsKLQkJdGhpcy52ZXJpZnlVbmNoYW5nZWRSZWxhdGl2ZUZpbGUoIi4uLy4uL2RpcjEvZGlyMi9maWxlLnR4dCIsIHByZWZpeCArICIvZGlyMS9kaXIyIik7Ci0KLQkJZmlsZSA9IG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyIik7Ci0JCWRpciA9IG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyIik7Ci0JCXJlbGF0aXZlRmlsZSA9IEZpbGVUb29scy5jb252ZXJ0VG9SZWxhdGl2ZUZpbGUoZmlsZSwgZGlyKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBGaWxlKCIuIiksIHJlbGF0aXZlRmlsZSk7Ci0KLQkJZmlsZSA9IG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyL2ZpbGUudHh0Iik7Ci0JCWRpciA9IG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyIik7Ci0JCXJlbGF0aXZlRmlsZSA9IEZpbGVUb29scy5jb252ZXJ0VG9SZWxhdGl2ZUZpbGUoZmlsZSwgZGlyKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBGaWxlKCJmaWxlLnR4dCIpLCByZWxhdGl2ZUZpbGUpOwotCi0JCWZpbGUgPSBuZXcgRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMi8uLi9kaXIyL2ZpbGUudHh0Iik7Ci0JCWRpciA9IG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyIik7Ci0JCXJlbGF0aXZlRmlsZSA9IEZpbGVUb29scy5jb252ZXJ0VG9SZWxhdGl2ZUZpbGUoZmlsZSwgZGlyKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBGaWxlKCJmaWxlLnR4dCIpLCByZWxhdGl2ZUZpbGUpOwotCi0JCWZpbGUgPSBuZXcgRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMi9kaXIzL2RpcjQvZGlyNS9maWxlLnR4dCIpOwotCQlkaXIgPSBuZXcgRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMiIpOwotCQlyZWxhdGl2ZUZpbGUgPSBGaWxlVG9vbHMuY29udmVydFRvUmVsYXRpdmVGaWxlKGZpbGUsIGRpcik7Ci0JCWFzc2VydEVxdWFscyhuZXcgRmlsZSgiZGlyMy9kaXI0L2RpcjUvZmlsZS50eHQiKSwgcmVsYXRpdmVGaWxlKTsKLQotCQlmaWxlID0gbmV3IEZpbGUocHJlZml4ICsgIi9kaXIxL2RpcjIvZmlsZS50eHQiKTsKLQkJZGlyID0gbmV3IEZpbGUocHJlZml4ICsgIi9kaXIxL2RpcjIvZGlyMy9kaXI0L2RpcjUiKTsKLQkJcmVsYXRpdmVGaWxlID0gRmlsZVRvb2xzLmNvbnZlcnRUb1JlbGF0aXZlRmlsZShmaWxlLCBkaXIpOwotCQlhc3NlcnRFcXVhbHMobmV3IEZpbGUoIi4uLy4uLy4uL2ZpbGUudHh0IiksIHJlbGF0aXZlRmlsZSk7Ci0KLQkJZmlsZSA9IG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyL2ZpbGUudHh0Iik7Ci0JCWRpciA9IG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyL2RpcjMiKTsKLQkJcmVsYXRpdmVGaWxlID0gRmlsZVRvb2xzLmNvbnZlcnRUb1JlbGF0aXZlRmlsZShmaWxlLCBkaXIpOwotCQlhc3NlcnRFcXVhbHMobmV3IEZpbGUoIi4uL2ZpbGUudHh0IiksIHJlbGF0aXZlRmlsZSk7Ci0KLQkJZmlsZSA9IG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyL2RpckEvZGlyQi9kaXJDL2ZpbGUudHh0Iik7Ci0JCWRpciA9IG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyL2RpcjMvZGlyNC9kaXI1Iik7Ci0JCXJlbGF0aXZlRmlsZSA9IEZpbGVUb29scy5jb252ZXJ0VG9SZWxhdGl2ZUZpbGUoZmlsZSwgZGlyKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBGaWxlKCIuLi8uLi8uLi9kaXJBL2RpckIvZGlyQy9maWxlLnR4dCIpLCByZWxhdGl2ZUZpbGUpOwotCi0JCWZpbGUgPSBuZXcgRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMiIpOwotCQlkaXIgPSBuZXcgRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMi9kaXIzL2RpcjQvZGlyNSIpOwotCQlyZWxhdGl2ZUZpbGUgPSBGaWxlVG9vbHMuY29udmVydFRvUmVsYXRpdmVGaWxlKGZpbGUsIGRpcik7Ci0JCWFzc2VydEVxdWFscyhuZXcgRmlsZSgiLi4vLi4vLi4iKSwgcmVsYXRpdmVGaWxlKTsKLQotCQlmaWxlID0gbmV3IEZpbGUocHJlZml4ICsgIi9NeSBEb2N1bWVudHMvTXkgV29ya3NwYWNlL1Byb2plY3QgMS9saWIvdG9wbGluay5qYXIiKTsKLQkJZGlyID0gbmV3IEZpbGUocHJlZml4ICsgIi9NeSBEb2N1bWVudHMvTXkgV29ya3NwYWNlL1Byb2plY3QgMSIpOwotCQlyZWxhdGl2ZUZpbGUgPSBGaWxlVG9vbHMuY29udmVydFRvUmVsYXRpdmVGaWxlKGZpbGUsIGRpcik7Ci0JCWFzc2VydEVxdWFscyhuZXcgRmlsZSgibGliL3RvcGxpbmsuamFyIiksIHJlbGF0aXZlRmlsZSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVVuY2hhbmdlZFJlbGF0aXZlRmlsZShTdHJpbmcgZmlsZU5hbWUsIFN0cmluZyBkaXJOYW1lKSB7Ci0JCUZpbGUgZmlsZSA9IG5ldyBGaWxlKGZpbGVOYW1lKTsKLQkJRmlsZSBkaXIgPSBuZXcgRmlsZShkaXJOYW1lKTsKLQkJRmlsZSByZWxhdGl2ZUZpbGUgPSBGaWxlVG9vbHMuY29udmVydFRvUmVsYXRpdmVGaWxlKGZpbGUsIGRpcik7Ci0JCWFzc2VydEVxdWFscyhmaWxlLCByZWxhdGl2ZUZpbGUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb252ZXJ0VG9BYnNvbHV0ZUZpbGUoKSB7Ci0JCVN0cmluZyBwcmVmaXggPSB0aGlzLmlzRXhlY3V0aW5nT25XaW5kb3dzKCkgPyAiQzoiIDogIiI7Ci0JCUZpbGUgZmlsZTsKLQkJRmlsZSBkaXI7Ci0JCUZpbGUgYWJzb2x1dGVGaWxlOwotCi0JCWlmICh0aGlzLmlzRXhlY3V0aW5nT25XaW5kb3dzKCkpIHsKLQkJCS8vIG9uIFdpbmRvd3MsIGEgZHJpdmUgbXVzdCBiZSBzcGVjaWZpZWQgZm9yIGEgZmlsZSB0byBiZSBhYnNvbHV0ZSAoaS5lLiBub3QgcmVsYXRpdmUpCi0JCQl0aGlzLnZlcmlmeVVuY2hhbmdlZEFic29sdXRlRmlsZSgiQzovZGlyMS9kaXIyL2ZpbGUudHh0IiwgIkM6L2RpcjEvZGlyMiIpOwotCQkJLy8gZGlmZmVyZW50IGRyaXZlcwotCQkJdGhpcy52ZXJpZnlVbmNoYW5nZWRBYnNvbHV0ZUZpbGUoIkQ6L2RpcjEvZGlyMi9maWxlLnR4dCIsICJDOi9kaXIxL2RpcjIiKTsKLQkJfQotCQl0aGlzLnZlcmlmeVVuY2hhbmdlZEFic29sdXRlRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMi9maWxlLnR4dCIsIHByZWZpeCArICIvZGlyMS9kaXIyIik7Ci0JCXRoaXMudmVyaWZ5VW5jaGFuZ2VkQWJzb2x1dGVGaWxlKHByZWZpeCArICIvLi9kaXIxL2RpcjIvZmlsZS50eHQiLCBwcmVmaXggKyAiL2RpcjEvZGlyMiIpOwotCQl0aGlzLnZlcmlmeVVuY2hhbmdlZEFic29sdXRlRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMi8uLi8uLi9kaXIxL2RpcjIvZmlsZS50eHQiLCBwcmVmaXggKyAiL2RpcjEvZGlyMiIpOwotCi0JCWZpbGUgPSBuZXcgRmlsZSgiLiIpOwotCQlkaXIgPSBuZXcgRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMiIpOwotCQlhYnNvbHV0ZUZpbGUgPSBGaWxlVG9vbHMuY29udmVydFRvQWJzb2x1dGVGaWxlKGZpbGUsIGRpcik7Ci0JCWFzc2VydEVxdWFscyhuZXcgRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMiIpLCBhYnNvbHV0ZUZpbGUpOwotCi0JCWZpbGUgPSBuZXcgRmlsZSgiLi9maWxlLnR4dCIpOwotCQlkaXIgPSBuZXcgRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMiIpOwotCQlhYnNvbHV0ZUZpbGUgPSBGaWxlVG9vbHMuY29udmVydFRvQWJzb2x1dGVGaWxlKGZpbGUsIGRpcik7Ci0JCWFzc2VydEVxdWFscyhuZXcgRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMi9maWxlLnR4dCIpLCBhYnNvbHV0ZUZpbGUpOwotCi0JCWZpbGUgPSBuZXcgRmlsZSgiZmlsZS50eHQiKTsKLQkJZGlyID0gbmV3IEZpbGUocHJlZml4ICsgIi9kaXIxL2RpcjIiKTsKLQkJYWJzb2x1dGVGaWxlID0gRmlsZVRvb2xzLmNvbnZlcnRUb0Fic29sdXRlRmlsZShmaWxlLCBkaXIpOwotCQlhc3NlcnRFcXVhbHMobmV3IEZpbGUocHJlZml4ICsgIi9kaXIxL2RpcjIvZmlsZS50eHQiKSwgYWJzb2x1dGVGaWxlKTsKLQotCQlmaWxlID0gbmV3IEZpbGUoIi4uL2RpcjIvZmlsZS50eHQiKTsKLQkJZGlyID0gbmV3IEZpbGUocHJlZml4ICsgIi9kaXIxL2RpcjIiKTsKLQkJYWJzb2x1dGVGaWxlID0gRmlsZVRvb2xzLmNvbnZlcnRUb0Fic29sdXRlRmlsZShmaWxlLCBkaXIpOwotCQlhc3NlcnRFcXVhbHMobmV3IEZpbGUocHJlZml4ICsgIi9kaXIxL2RpcjIvZmlsZS50eHQiKSwgYWJzb2x1dGVGaWxlKTsKLQotCQlmaWxlID0gbmV3IEZpbGUoImRpcjMvZGlyNC9kaXI1L2ZpbGUudHh0Iik7Ci0JCWRpciA9IG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyIik7Ci0JCWFic29sdXRlRmlsZSA9IEZpbGVUb29scy5jb252ZXJ0VG9BYnNvbHV0ZUZpbGUoZmlsZSwgZGlyKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyL2RpcjMvZGlyNC9kaXI1L2ZpbGUudHh0IiksIGFic29sdXRlRmlsZSk7Ci0KLQkJZmlsZSA9IG5ldyBGaWxlKCIuLi8uLi8uLi9maWxlLnR4dCIpOwotCQlkaXIgPSBuZXcgRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMi9kaXIzL2RpcjQvZGlyNSIpOwotCQlhYnNvbHV0ZUZpbGUgPSBGaWxlVG9vbHMuY29udmVydFRvQWJzb2x1dGVGaWxlKGZpbGUsIGRpcik7Ci0JCWFzc2VydEVxdWFscyhuZXcgRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMi9maWxlLnR4dCIpLCBhYnNvbHV0ZUZpbGUpOwotCi0JCS8vIHRvbyBtYW55ICIuLiIgZGlyZWN0b3JpZXMgd2lsbCByZXNvbHZlIHRvIHRoZSByb290OwotCQkvLyB0aGlzIGlzIGNvbnNpc3RlbnQgd2l0aCBXaW5kb3dzIGFuZCBMaW51eCBjb21tYW5kIHNoZWxscwotCQlmaWxlID0gbmV3IEZpbGUoIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2ZpbGUudHh0Iik7Ci0JCWRpciA9IG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyIik7Ci0JCWFic29sdXRlRmlsZSA9IEZpbGVUb29scy5jb252ZXJ0VG9BYnNvbHV0ZUZpbGUoZmlsZSwgZGlyKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBGaWxlKHByZWZpeCArICIvZmlsZS50eHQiKSwgYWJzb2x1dGVGaWxlKTsKLQotCQlmaWxlID0gbmV3IEZpbGUoIi4uL2ZpbGUudHh0Iik7Ci0JCWRpciA9IG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyL2RpcjMiKTsKLQkJYWJzb2x1dGVGaWxlID0gRmlsZVRvb2xzLmNvbnZlcnRUb0Fic29sdXRlRmlsZShmaWxlLCBkaXIpOwotCQlhc3NlcnRFcXVhbHMobmV3IEZpbGUocHJlZml4ICsgIi9kaXIxL2RpcjIvZmlsZS50eHQiKSwgYWJzb2x1dGVGaWxlKTsKLQotCQlmaWxlID0gbmV3IEZpbGUoIi4uLy4uLy4uL2RpckEvZGlyQi9kaXJDL2ZpbGUudHh0Iik7Ci0JCWRpciA9IG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyL2RpcjMvZGlyNC9kaXI1Iik7Ci0JCWFic29sdXRlRmlsZSA9IEZpbGVUb29scy5jb252ZXJ0VG9BYnNvbHV0ZUZpbGUoZmlsZSwgZGlyKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBGaWxlKHByZWZpeCArICIvZGlyMS9kaXIyL2RpckEvZGlyQi9kaXJDL2ZpbGUudHh0IiksIGFic29sdXRlRmlsZSk7Ci0KLQkJZmlsZSA9IG5ldyBGaWxlKCIuLi8uLi8uLiIpOwotCQlkaXIgPSBuZXcgRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMi9kaXIzL2RpcjQvZGlyNSIpOwotCQlhYnNvbHV0ZUZpbGUgPSBGaWxlVG9vbHMuY29udmVydFRvQWJzb2x1dGVGaWxlKGZpbGUsIGRpcik7Ci0JCWFzc2VydEVxdWFscyhuZXcgRmlsZShwcmVmaXggKyAiL2RpcjEvZGlyMiIpLCBhYnNvbHV0ZUZpbGUpOwotCi0JCWZpbGUgPSBuZXcgRmlsZSgibGliL3RvcGxpbmsuamFyIik7Ci0JCWRpciA9IG5ldyBGaWxlKHByZWZpeCArICIvTXkgRG9jdW1lbnRzL015IFdvcmtzcGFjZS9Qcm9qZWN0IDEiKTsKLQkJYWJzb2x1dGVGaWxlID0gRmlsZVRvb2xzLmNvbnZlcnRUb0Fic29sdXRlRmlsZShmaWxlLCBkaXIpOwotCQlhc3NlcnRFcXVhbHMobmV3IEZpbGUocHJlZml4ICsgIi9NeSBEb2N1bWVudHMvTXkgV29ya3NwYWNlL1Byb2plY3QgMS9saWIvdG9wbGluay5qYXIiKSwgYWJzb2x1dGVGaWxlKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RmlsZU5hbWVJc1Jlc2VydmVkKCkgewotCQlib29sZWFuIGV4cGVjdGVkID0gdGhpcy5pc0V4ZWN1dGluZ09uV2luZG93cygpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIEZpbGVUb29scy5maWxlTmFtZUlzUmVzZXJ2ZWQoIkNPTiIpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBGaWxlVG9vbHMuZmlsZU5hbWVJc1Jlc2VydmVkKCJjb24iKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgRmlsZVRvb2xzLmZpbGVOYW1lSXNSZXNlcnZlZCgiY09OIikpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIEZpbGVUb29scy5maWxlTmFtZUlzUmVzZXJ2ZWQoIkFVWCIpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBGaWxlVG9vbHMuZmlsZU5hbWVJc1Jlc2VydmVkKCJDT00zIikpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIEZpbGVUb29scy5maWxlTmFtZUlzUmVzZXJ2ZWQoIkxQVDMiKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgRmlsZVRvb2xzLmZpbGVOYW1lSXNSZXNlcnZlZCgiblVMIikpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIEZpbGVUb29scy5maWxlTmFtZUlzUmVzZXJ2ZWQoIlBybiIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RmlsZUhhc0FueVJlc2VydmVkQ29tcG9uZW50cygpIHsKLQkJYm9vbGVhbiBleHBlY3RlZCA9IHRoaXMuaXNFeGVjdXRpbmdPbldpbmRvd3MoKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBGaWxlVG9vbHMuZmlsZUhhc0FueVJlc2VydmVkQ29tcG9uZW50cyhuZXcgRmlsZSgiQzovQ09OIikpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBGaWxlVG9vbHMuZmlsZUhhc0FueVJlc2VydmVkQ29tcG9uZW50cyhuZXcgRmlsZSgiL2Nvbi9mb28iKSkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIEZpbGVUb29scy5maWxlSGFzQW55UmVzZXJ2ZWRDb21wb25lbnRzKG5ldyBGaWxlKCJjOi90ZW1wL2NPTiIpKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgRmlsZVRvb2xzLmZpbGVIYXNBbnlSZXNlcnZlZENvbXBvbmVudHMobmV3IEZpbGUoImJhci8vYmF6Ly9BVVgiKSkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIEZpbGVUb29scy5maWxlSGFzQW55UmVzZXJ2ZWRDb21wb25lbnRzKG5ldyBGaWxlKCJDT00zLy90dHQiKSkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIEZpbGVUb29scy5maWxlSGFzQW55UmVzZXJ2ZWRDb21wb25lbnRzKG5ldyBGaWxlKCJkOi9MUFQzL3h4eCIpKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgRmlsZVRvb2xzLmZpbGVIYXNBbnlSZXNlcnZlZENvbXBvbmVudHMobmV3IEZpbGUoImM6L215IGRvY3MgYW5kIHN0dWZmL3R1ZXNkYXkvblVMIikpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBGaWxlVG9vbHMuZmlsZUhhc0FueVJlc2VydmVkQ29tcG9uZW50cyhuZXcgRmlsZSgiUHJuIikpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2hvcnRlbkZpbGVOYW1lRmlsZSgpIHsKLQkJaWYgKHRoaXMuaXNFeGVjdXRpbmdPbldpbmRvd3MoKSkgewotCQkJdGhpcy52ZXJpZnlTaG9ydGVuRmlsZU5hbWVGaWxlV2luKCk7Ci0JCX0gZWxzZSB7Ci0JCQl0aGlzLnZlcmlmeVNob3J0ZW5GaWxlTmFtZUZpbGVOb25XaW4oKTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlTaG9ydGVuRmlsZU5hbWVGaWxlV2luKCkgewotCQlGaWxlIGZpbGUgPSBuZXcgRmlsZSgiQzpcXERvY3VtZW50cyBhbmQgU2V0dGluZ3NcXEFkbWluaXN0cmF0b3JcXERlc2t0b3BcXFByb2plY3RcXFRleHQudHh0Iik7Ci0JCVN0cmluZyBmaWxlTmFtZSA9IEZpbGVUb29scy5zaG9ydGVuRmlsZU5hbWUoZmlsZSk7Ci0JCWFzc2VydEVxdWFscygiQzpcXERvY3VtZW50cyBhbmQgU2V0dGluZ3NcXC4uLlxcRGVza3RvcFxcUHJvamVjdFxcVGV4dC50eHQiLCBmaWxlTmFtZSk7Ci0JCWFzc2VydFRydWUoZmlsZU5hbWUubGVuZ3RoKCkgPD0gRmlsZVRvb2xzLk1BWElNVU1fU0hPUlRFTkVEX0ZJTEVfTkFNRV9MRU5HVEgpOwotCi0JCWZpbGUgPSBuZXcgRmlsZSgiQzovIik7Ci0JCWZpbGVOYW1lID0gRmlsZVRvb2xzLnNob3J0ZW5GaWxlTmFtZShmaWxlKTsKLQkJYXNzZXJ0RXF1YWxzKCJDOlxcIiwgZmlsZU5hbWUpOwotCQlhc3NlcnRUcnVlKGZpbGVOYW1lLmxlbmd0aCgpIDw9IEZpbGVUb29scy5NQVhJTVVNX1NIT1JURU5FRF9GSUxFX05BTUVfTEVOR1RIKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5U2hvcnRlbkZpbGVOYW1lRmlsZU5vbldpbigpIHsKLQkJRmlsZSBmaWxlID0gbmV3IEZpbGUoIi9ob21lL2FkbWluaXN0cmF0b3IvZG9jdW1lbnRzIGFuZCBzZXR0aW5ncy9kZXNrdG9wL1Byb2plY3QvVGV4dC50eHQiKTsKLQkJU3RyaW5nIGZpbGVOYW1lID0gRmlsZVRvb2xzLnNob3J0ZW5GaWxlTmFtZShmaWxlKTsKLQkJYXNzZXJ0RXF1YWxzKCIvaG9tZS9hZG1pbmlzdHJhdG9yLy4uLi9kZXNrdG9wL1Byb2plY3QvVGV4dC50eHQiLCBmaWxlTmFtZSk7Ci0JCWFzc2VydFRydWUoZmlsZU5hbWUubGVuZ3RoKCkgPD0gRmlsZVRvb2xzLk1BWElNVU1fU0hPUlRFTkVEX0ZJTEVfTkFNRV9MRU5HVEgpOwotCi0JCWZpbGUgPSBuZXcgRmlsZSgiL2hvbWUiKTsKLQkJZmlsZU5hbWUgPSBGaWxlVG9vbHMuc2hvcnRlbkZpbGVOYW1lKGZpbGUpOwotCQlhc3NlcnRFcXVhbHMoIi9ob21lIiwgZmlsZU5hbWUpOwotCQlhc3NlcnRUcnVlKGZpbGVOYW1lLmxlbmd0aCgpIDw9IEZpbGVUb29scy5NQVhJTVVNX1NIT1JURU5FRF9GSUxFX05BTUVfTEVOR1RIKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2hvcnRlbkZpbGVOYW1lRmlsZUludCgpIHsKLQkJaWYgKHRoaXMuaXNFeGVjdXRpbmdPbldpbmRvd3MoKSkgewotCQkJdGhpcy52ZXJpZnlTaG9ydGVuRmlsZU5hbWVGaWxlSW50V2luKCk7Ci0JCX0gZWxzZSB7Ci0JCQl0aGlzLnZlcmlmeVNob3J0ZW5GaWxlTmFtZUZpbGVJbnROb25XaW4oKTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlTaG9ydGVuRmlsZU5hbWVGaWxlSW50V2luKCkgewotCQlGaWxlIGZpbGUgPSBuZXcgRmlsZSgiQzpcXERvY3VtZW50cyBhbmQgU2V0dGluZ3NcXEFkbWluaXN0cmF0b3JcXERlc2t0b3BcXFByb2plY3RcXFRleHQudHh0Iik7Ci0JCVN0cmluZyBmaWxlTmFtZSA9IEZpbGVUb29scy5zaG9ydGVuRmlsZU5hbWUoZmlsZSwgMzEpOwotCQlhc3NlcnRFcXVhbHMoIkM6XFwuLi5cXERlc2t0b3BcXFByb2plY3RcXFRleHQudHh0IiwgZmlsZU5hbWUpOwotCQlhc3NlcnRFcXVhbHMoMzEsIGZpbGVOYW1lLmxlbmd0aCgpKTsKLQotCQlmaWxlID0gbmV3IEZpbGUoIkM6L1RoaXMgaXMgdGhlIGZpbGUgbmFtZS50eHQiKTsKLQkJZmlsZU5hbWUgPSBGaWxlVG9vbHMuc2hvcnRlbkZpbGVOYW1lKGZpbGUsIDEwKTsKLQkJYXNzZXJ0RXF1YWxzKCJDOlxcVGhpcyBpcyB0aGUgZmlsZSBuYW1lLnR4dCIsIGZpbGVOYW1lKTsKLQkJYXNzZXJ0RXF1YWxzKDI4LCBmaWxlTmFtZS5sZW5ndGgoKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVNob3J0ZW5GaWxlTmFtZUZpbGVJbnROb25XaW4oKSB7Ci0JCUZpbGUgZmlsZSA9IG5ldyBGaWxlKCIvaG9tZS9hZG1pbmlzdHJhdG9yL2RvY3VtZW50cyBhbmQgc2V0dGluZ3MvZGVza3RvcC9Qcm9qZWN0L1RleHQudHh0Iik7Ci0JCVN0cmluZyBmaWxlTmFtZSA9IEZpbGVUb29scy5zaG9ydGVuRmlsZU5hbWUoZmlsZSwgMzEpOwotCQlhc3NlcnRFcXVhbHMoIi9ob21lLy4uLi9kZXNrdG9wL1Byb2plY3QvVGV4dC50eHQiLCBmaWxlTmFtZSk7Ci0JCWFzc2VydEVxdWFscygzNCwgZmlsZU5hbWUubGVuZ3RoKCkpOwotCi0JCWZpbGUgPSBuZXcgRmlsZSgiL1RoaXMgaXMgdGhlIGZpbGUgbmFtZS50eHQiKTsKLQkJZmlsZU5hbWUgPSBGaWxlVG9vbHMuc2hvcnRlbkZpbGVOYW1lKGZpbGUsIDEwKTsKLQkJYXNzZXJ0RXF1YWxzKCIvVGhpcyBpcyB0aGUgZmlsZSBuYW1lLnR4dCIsIGZpbGVOYW1lKTsKLQkJYXNzZXJ0RXF1YWxzKDI2LCBmaWxlTmFtZS5sZW5ndGgoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNob3J0ZW5GaWxlTmFtZVVSTCgpIHRocm93cyBFeGNlcHRpb24gewotCQlpZiAodGhpcy5pc0V4ZWN1dGluZ09uV2luZG93cygpKSB7Ci0JCQl0aGlzLnZlcmlmeVNob3J0ZW5GaWxlTmFtZVVSTFdpbigpOwotCQl9IGVsc2UgewotCQkJdGhpcy52ZXJpZnlTaG9ydGVuRmlsZU5hbWVVUkxOb25XaW4oKTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlTaG9ydGVuRmlsZU5hbWVVUkxXaW4oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVVJMIHVybCA9IG5ldyBVUkwoImZpbGUiLCAiIiwgIkM6L0RvY3VtZW50cyBhbmQgU2V0dGluZ3MvQWRtaW5pc3RyYXRvci9EZXNrdG9wL1Byb2plY3QvVGV4dC50eHQiKTsKLQkJU3RyaW5nIGZpbGVOYW1lID0gRmlsZVRvb2xzLnNob3J0ZW5GaWxlTmFtZSh1cmwpOwotCQlhc3NlcnRFcXVhbHMoIkM6XFxEb2N1bWVudHMgYW5kIFNldHRpbmdzXFwuLi5cXERlc2t0b3BcXFByb2plY3RcXFRleHQudHh0IiwgZmlsZU5hbWUpOwotCQlhc3NlcnRUcnVlKGZpbGVOYW1lLmxlbmd0aCgpIDw9IEZpbGVUb29scy5NQVhJTVVNX1NIT1JURU5FRF9GSUxFX05BTUVfTEVOR1RIKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5U2hvcnRlbkZpbGVOYW1lVVJMTm9uV2luKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVVSTCB1cmwgPSBuZXcgVVJMKCJmaWxlIiwgIiIsICIvaG9tZS9hZG1pbmlzdHJhdG9yL2RvY3VtZW50cyBhbmQgc2V0dGluZ3MvZGVza3RvcC9Qcm9qZWN0L1RleHQudHh0Iik7Ci0JCVN0cmluZyBmaWxlTmFtZSA9IEZpbGVUb29scy5zaG9ydGVuRmlsZU5hbWUodXJsKTsKLQkJYXNzZXJ0RXF1YWxzKCIvaG9tZS9hZG1pbmlzdHJhdG9yLy4uLi9kZXNrdG9wL1Byb2plY3QvVGV4dC50eHQiLCBmaWxlTmFtZSk7Ci0JCWFzc2VydFRydWUoZmlsZU5hbWUubGVuZ3RoKCkgPD0gRmlsZVRvb2xzLk1BWElNVU1fU0hPUlRFTkVEX0ZJTEVfTkFNRV9MRU5HVEgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTaG9ydGVuRmlsZU5hbWVVUkxJbnQoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJaWYgKHRoaXMuaXNFeGVjdXRpbmdPbldpbmRvd3MoKSkgewotCQkJdGhpcy52ZXJpZnlTaG9ydGVuRmlsZU5hbWVVUkxJbnRXaW4oKTsKLQkJfSBlbHNlIHsKLQkJCXRoaXMudmVyaWZ5U2hvcnRlbkZpbGVOYW1lVVJMSW50Tm9uV2luKCk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5U2hvcnRlbkZpbGVOYW1lVVJMSW50V2luKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVVSTCB1cmwgPSBuZXcgVVJMKCJmaWxlIiwgIiIsICIvQzovRG9jdW1lbnRzIGFuZCBTZXR0aW5ncy9BZG1pbmlzdHJhdG9yL0Rlc2t0b3AvUHJvamVjdC9UZXh0LnR4dCIpOwotCQlTdHJpbmcgZmlsZU5hbWUgPSBGaWxlVG9vbHMuc2hvcnRlbkZpbGVOYW1lKHVybCwgMzEpOwotCQlhc3NlcnRFcXVhbHMoIkM6XFwuLi5cXERlc2t0b3BcXFByb2plY3RcXFRleHQudHh0IiwgZmlsZU5hbWUpOwotCQlhc3NlcnRFcXVhbHMoMzEsIGZpbGVOYW1lLmxlbmd0aCgpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5U2hvcnRlbkZpbGVOYW1lVVJMSW50Tm9uV2luKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVVSTCB1cmwgPSBuZXcgVVJMKCJmaWxlIiwgIiIsICIvaG9tZS9hZG1pbmlzdHJhdG9yL2RvY3VtZW50cyBhbmQgc2V0dGluZ3MvZGVza3RvcC9Qcm9qZWN0L1RleHQudHh0Iik7Ci0JCVN0cmluZyBmaWxlTmFtZSA9IEZpbGVUb29scy5zaG9ydGVuRmlsZU5hbWUodXJsLCAzMSk7Ci0JCWFzc2VydEVxdWFscygiL2hvbWUvLi4uL2Rlc2t0b3AvUHJvamVjdC9UZXh0LnR4dCIsIGZpbGVOYW1lKTsKLQkJYXNzZXJ0RXF1YWxzKDM0LCBmaWxlTmFtZS5sZW5ndGgoKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVVuY2hhbmdlZEFic29sdXRlRmlsZShTdHJpbmcgZmlsZU5hbWUsIFN0cmluZyBkaXJOYW1lKSB7Ci0JCUZpbGUgZmlsZSA9IG5ldyBGaWxlKGZpbGVOYW1lKTsKLQkJRmlsZSBkaXIgPSBuZXcgRmlsZShkaXJOYW1lKTsKLQkJRmlsZSBhYnNvbHV0ZUZpbGUgPSBGaWxlVG9vbHMuY29udmVydFRvQWJzb2x1dGVGaWxlKGZpbGUsIGRpcik7Ci0JCWFzc2VydEVxdWFscyhmaWxlLCBhYnNvbHV0ZUZpbGUpOwotCX0KLQotCXByaXZhdGUgRmlsZSBidWlsZFRlbXBEaXIoKSB0aHJvd3MgSU9FeGNlcHRpb24gewotCQkvLyBidWlsZCBhIG5ldyBkaXJlY3RvcnkgZm9yIGVhY2ggdGVzdCwgdG8gcHJldmVudCBhbnkgY3Jvc3MtdGVzdCBlZmZlY3RzCi0JCUZpbGUgZGlyID0gRmlsZVRvb2xzLm5ld1RlbXBvcmFyeURpcmVjdG9yeShDbGFzc1Rvb2xzLnNob3J0Q2xhc3NOYW1lRm9yT2JqZWN0KHRoaXMpICsgIi4iICsgdGhpcy5nZXROYW1lKCkpOwotCi0JCUZpbGUgZmlsZTBhID0gbmV3IEZpbGUoZGlyLCAiZmlsZTBhIik7Ci0JCWZpbGUwYS5jcmVhdGVOZXdGaWxlKCk7Ci0JCUZpbGUgZmlsZTBiID0gbmV3IEZpbGUoZGlyLCAiZmlsZTBiIik7Ci0JCWZpbGUwYi5jcmVhdGVOZXdGaWxlKCk7Ci0JCUZpbGUgZmlsZTBjID0gbmV3IEZpbGUoZGlyLCAiZmlsZTBjIik7Ci0JCWZpbGUwYy5jcmVhdGVOZXdGaWxlKCk7Ci0KLQkJRmlsZSBzdWJkaXIxID0gbmV3IEZpbGUoZGlyLCAic3ViZGlyMSIpOwotCQlzdWJkaXIxLm1rZGlyKCk7Ci0JCUZpbGUgZmlsZTFhID0gbmV3IEZpbGUoc3ViZGlyMSwgImZpbGUxYSIpOwotCQlmaWxlMWEuY3JlYXRlTmV3RmlsZSgpOwotCQlGaWxlIGZpbGUxYiA9IG5ldyBGaWxlKHN1YmRpcjEsICJmaWxlMWIiKTsKLQkJZmlsZTFiLmNyZWF0ZU5ld0ZpbGUoKTsKLQotCQlGaWxlIHN1YmRpcjIgPSBuZXcgRmlsZShkaXIsICJzdWJkaXIyIik7Ci0JCXN1YmRpcjIubWtkaXIoKTsKLQkJRmlsZSBmaWxlMmEgPSBuZXcgRmlsZShzdWJkaXIyLCAiZmlsZTJhIik7Ci0JCWZpbGUyYS5jcmVhdGVOZXdGaWxlKCk7Ci0JCUZpbGUgZmlsZTJiID0gbmV3IEZpbGUoc3ViZGlyMiwgImZpbGUyYiIpOwotCQlmaWxlMmIuY3JlYXRlTmV3RmlsZSgpOwotCi0JCUZpbGUgc3ViZGlyMyA9IG5ldyBGaWxlKHN1YmRpcjIsICJzdWJkaXIzIik7Ci0JCXN1YmRpcjMubWtkaXIoKTsKLQkJRmlsZSBmaWxlM2EgPSBuZXcgRmlsZShzdWJkaXIzLCAiZmlsZTNhIik7Ci0JCWZpbGUzYS5jcmVhdGVOZXdGaWxlKCk7Ci0JCUZpbGUgZmlsZTNiID0gbmV3IEZpbGUoc3ViZGlyMywgImZpbGUzYiIpOwotCQlmaWxlM2IuY3JlYXRlTmV3RmlsZSgpOwotCi0JCXJldHVybiBkaXI7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGRlbGV0ZURpcihGaWxlIGRpcikgewotCQlGaWxlVG9vbHMuZGVsZXRlRGlyZWN0b3J5KGRpcik7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0ZpbHRlclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0ZpbHRlclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDM1ODY1YWUuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9GaWx0ZXJUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLQotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LkZpbHRlcjsKLQotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgY2xhc3MgRmlsdGVyVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQlwdWJsaWMgRmlsdGVyVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE51bGxGaWx0ZXIoKSB7Ci0JCUZpbHRlcjxTdHJpbmc+IGZpbHRlciA9IEZpbHRlci5OdWxsLmluc3RhbmNlKCk7Ci0JCWFzc2VydFRydWUoZmlsdGVyLmFjY2VwdCgiIikpOwotCQlhc3NlcnRUcnVlKGZpbHRlci5hY2NlcHQoImZvbyIpKTsKLQkJYXNzZXJ0VHJ1ZShmaWx0ZXIuYWNjZXB0KCJiYXIiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE9wYXF1ZUZpbHRlcigpIHsKLQkJRmlsdGVyPFN0cmluZz4gZmlsdGVyID0gRmlsdGVyLk9wYXF1ZS5pbnN0YW5jZSgpOwotCQlhc3NlcnRGYWxzZShmaWx0ZXIuYWNjZXB0KCIiKSk7Ci0JCWFzc2VydEZhbHNlKGZpbHRlci5hY2NlcHQoImZvbyIpKTsKLQkJYXNzZXJ0RmFsc2UoZmlsdGVyLmFjY2VwdCgiYmFyIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3REaXNhYmxlZEZpbHRlcigpIHsKLQkJRmlsdGVyPFN0cmluZz4gZmlsdGVyID0gRmlsdGVyLkRpc2FibGVkLmluc3RhbmNlKCk7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCWFzc2VydEZhbHNlKGZpbHRlci5hY2NlcHQoImZvbyIpKTsKLQkJCWZhaWwoKTsKLQkJfSBjYXRjaCAoVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvSGFzaEJhZ1Rlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0hhc2hCYWdUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxMGUzMWM3Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvSGFzaEJhZ1Rlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NDUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkNvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb247Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Ob1N1Y2hFbGVtZW50RXhjZXB0aW9uOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5CYWc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkhhc2hCYWc7Ci0KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIEhhc2hCYWdUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIEhhc2hCYWc8U3RyaW5nPiBiYWc7Ci0KLQlwdWJsaWMgSGFzaEJhZ1Rlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMuYmFnID0gdGhpcy5idWlsZEJhZygpOwotCX0KLQotCXByaXZhdGUgSGFzaEJhZzxTdHJpbmc+IGJ1aWxkQmFnKCkgewotCQlIYXNoQmFnPFN0cmluZz4gYiA9IG5ldyBIYXNoQmFnPFN0cmluZz4oKTsKLQkJYi5hZGQobnVsbCk7Ci0JCWIuYWRkKG5ldyBTdHJpbmcoIm9uZSIpKTsKLQkJYi5hZGQobmV3IFN0cmluZygidHdvIikpOwotCQliLmFkZChuZXcgU3RyaW5nKCJ0d28iKSk7Ci0JCWIuYWRkKG5ldyBTdHJpbmcoInRocmVlIikpOwotCQliLmFkZChuZXcgU3RyaW5nKCJ0aHJlZSIpKTsKLQkJYi5hZGQobmV3IFN0cmluZygidGhyZWUiKSk7Ci0JCWIuYWRkKG5ldyBTdHJpbmcoImZvdXIiKSk7Ci0JCWIuYWRkKG5ldyBTdHJpbmcoImZvdXIiKSk7Ci0JCWIuYWRkKG5ldyBTdHJpbmcoImZvdXIiKSk7Ci0JCWIuYWRkKG5ldyBTdHJpbmcoImZvdXIiKSk7Ci0JCXJldHVybiBiOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb248U3RyaW5nPiBidWlsZENvbGxlY3Rpb24oKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWMuYWRkKG5ldyBTdHJpbmcoImZvbyIpKTsKLQkJYy5hZGQobmV3IFN0cmluZygiZm9vIikpOwotCQljLmFkZChuZXcgU3RyaW5nKCJiYXIiKSk7Ci0JCWMuYWRkKG5ldyBTdHJpbmcoImJhciIpKTsKLQkJYy5hZGQobmV3IFN0cmluZygiYmFyIikpOwotCQlyZXR1cm4gYzsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q3RvckNvbGxlY3Rpb24oKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gdGhpcy5idWlsZENvbGxlY3Rpb24oKTsKLQkJQmFnPFN0cmluZz4gYiA9IG5ldyBIYXNoQmFnPFN0cmluZz4oYyk7Ci0JCWZvciAoU3RyaW5nIHMgOiBjKSB7Ci0JCQlhc3NlcnRUcnVlKGIuY29udGFpbnMocykpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEN0b3JJbnRGbG9hdCgpIHsKLQkJYm9vbGVhbiBleENhdWdodDsKLQotCQlleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy5iYWcgPSBuZXcgSGFzaEJhZzxTdHJpbmc+KC0yMCwgMC42NmYpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQotCQlleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy5iYWcgPSBuZXcgSGFzaEJhZzxTdHJpbmc+KDIwLCAtMC42NmYpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkKCkgewotCQkvLyB0aGUgb3RoZXIgYWRkcyB0b29rIHBsYWNlIGluIHNldFVwCi0JCWFzc2VydFRydWUodGhpcy5iYWcuYWRkKCJmaXZlIikpOwotCi0JCWFzc2VydFRydWUodGhpcy5iYWcuY29udGFpbnMoIm9uZSIpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucygidHdvIikpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKCJ0aHJlZSIpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucygiZm91ciIpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucygiZml2ZSIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQ291bnQoKSB7Ci0JCS8vIHRoZSBvdGhlciBhZGRzIHRvb2sgcGxhY2UgaW4gc2V0VXAKLQkJdGhpcy5iYWcuYWRkKCJtaW51czMiLCAtMyk7Ci0JCXRoaXMuYmFnLmFkZCgiemVybyIsIDApOwotCQl0aGlzLmJhZy5hZGQoImZpdmUiLCA1KTsKLQotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucygibWludXMzIikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucygiemVybyIpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIHRoaXMuYmFnLmNvdW50KCJvbmUiKSk7Ci0JCWFzc2VydEVxdWFscygyLCB0aGlzLmJhZy5jb3VudCgidHdvIikpOwotCQlhc3NlcnRFcXVhbHMoMywgdGhpcy5iYWcuY291bnQoInRocmVlIikpOwotCQlhc3NlcnRFcXVhbHMoNCwgdGhpcy5iYWcuY291bnQoImZvdXIiKSk7Ci0JCWFzc2VydEVxdWFscyg1LCB0aGlzLmJhZy5jb3VudCgiZml2ZSIpKTsKLQotCQl0aGlzLmJhZy5hZGQoInRocmVlIiwgMik7Ci0JCWFzc2VydEVxdWFscyg1LCB0aGlzLmJhZy5jb3VudCgidGhyZWUiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbCgpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSB0aGlzLmJ1aWxkQ29sbGVjdGlvbigpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmFkZEFsbChjKSk7Ci0JCWZvciAoU3RyaW5nIHMgOiBjKSB7Ci0JCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKHMpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDbGVhcigpIHsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucygib25lIikpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKCJ0d28iKSk7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcuY29udGFpbnMoInRocmVlIikpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKCJmb3VyIikpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKG51bGwpKTsKLQkJYXNzZXJ0RXF1YWxzKDExLCB0aGlzLmJhZy5zaXplKCkpOwotCQl0aGlzLmJhZy5jbGVhcigpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucygib25lIikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucygidHdvIikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucygidGhyZWUiKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLmNvbnRhaW5zKCJmb3VyIikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucyhudWxsKSk7Ci0JCWFzc2VydEVxdWFscygwLCB0aGlzLmJhZy5zaXplKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDbG9uZSgpIHsKLQkJQmFnPFN0cmluZz4gYmFnMiA9IHRoaXMuYmFnLmNsb25lKCk7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcgIT0gYmFnMik7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJhZywgYmFnMik7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcuaGFzaENvZGUoKSA9PSBiYWcyLmhhc2hDb2RlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb250YWlucygpIHsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucyhudWxsKSk7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcuY29udGFpbnMoIm9uZSIpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucygidHdvIikpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKCJ0aHJlZSIpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucygiZm91ciIpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucyhuZXcgU3RyaW5nKCJmb3VyIikpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucygiZm8iICsgInVyIikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucygiZml2ZSIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNBbGwoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWMuYWRkKG51bGwpOwotCQljLmFkZChuZXcgU3RyaW5nKCJvbmUiKSk7Ci0JCWMuYWRkKG5ldyBTdHJpbmcoInR3byIpKTsKLQkJYy5hZGQobmV3IFN0cmluZygidGhyZWUiKSk7Ci0JCWMuYWRkKG5ldyBTdHJpbmcoImZvdXIiKSk7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcuY29udGFpbnNBbGwoYykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb3VudCgpIHsKLQkJYXNzZXJ0RXF1YWxzKDAsIHRoaXMuYmFnLmNvdW50KCJ6ZXJvIikpOwotCQlhc3NlcnRFcXVhbHMoMSwgdGhpcy5iYWcuY291bnQoIm9uZSIpKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIHRoaXMuYmFnLmNvdW50KCJ0d28iKSk7Ci0JCWFzc2VydEVxdWFscygzLCB0aGlzLmJhZy5jb3VudCgidGhyZWUiKSk7Ci0JCWFzc2VydEVxdWFscyg0LCB0aGlzLmJhZy5jb3VudCgiZm91ciIpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHRoaXMuYmFnLmNvdW50KCJmaXZlIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RFcXVhbHMoKSB7Ci0JCUJhZzxTdHJpbmc+IGJhZzIgPSB0aGlzLmJ1aWxkQmFnKCk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJhZywgYmFnMik7Ci0JCWJhZzIuYWRkKCJmaXZlIik7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLmVxdWFscyhiYWcyKSk7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KHRoaXMuYmFnKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcuZXF1YWxzKGMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzaENvZGUoKSB7Ci0JCUJhZzxTdHJpbmc+IGJhZzIgPSB0aGlzLmJ1aWxkQmFnKCk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJhZy5oYXNoQ29kZSgpLCBiYWcyLmhhc2hDb2RlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJc0VtcHR5KCkgewotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5pc0VtcHR5KCkpOwotCQl0aGlzLmJhZy5jbGVhcigpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmlzRW1wdHkoKSk7Ci0JCXRoaXMuYmFnLmFkZCgiZm9vIik7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLmlzRW1wdHkoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEVtcHR5SXRlcmF0b3IoKSB7Ci0JCXRoaXMuYmFnLmNsZWFyKCk7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IgPSB0aGlzLmJhZy5pdGVyYXRvcigpOwotCQlhc3NlcnRGYWxzZShpdGVyYXRvci5oYXNOZXh0KCkpOwotCi0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJT2JqZWN0IGVsZW1lbnQgPSBudWxsOwotCQl0cnkgewotCQkJZWxlbWVudCA9IGl0ZXJhdG9yLm5leHQoKTsKLQkJCWZhaWwoZWxlbWVudC50b1N0cmluZygpKTsKLQkJfSBjYXRjaCAoTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCi0JCWV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlpdGVyYXRvci5yZW1vdmUoKTsKLQkJfSBjYXRjaCAoSWxsZWdhbFN0YXRlRXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZXJhdG9yKCkgewotCQlpbnQgaSA9IDA7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IgPSB0aGlzLmJhZy5pdGVyYXRvcigpOwotCQlhc3NlcnRUcnVlKGl0ZXJhdG9yLmhhc05leHQoKSk7Ci0JCXdoaWxlIChpdGVyYXRvci5oYXNOZXh0KCkpIHsKLQkJCWl0ZXJhdG9yLm5leHQoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHMoMTEsIGkpOwotCQlhc3NlcnRGYWxzZShpdGVyYXRvci5oYXNOZXh0KCkpOwotCi0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJT2JqZWN0IGVsZW1lbnQgPSBudWxsOwotCQl0cnkgewotCQkJZWxlbWVudCA9IGl0ZXJhdG9yLm5leHQoKTsKLQkJCWZhaWwoZWxlbWVudC50b1N0cmluZygpKTsKLQkJfSBjYXRjaCAoTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCi0JCWl0ZXJhdG9yLnJlbW92ZSgpOwotCQlhc3NlcnRFcXVhbHMoMTAsIHRoaXMuYmFnLnNpemUoKSk7Ci0KLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCWl0ZXJhdG9yLnJlbW92ZSgpOwotCQl9IGNhdGNoIChJbGxlZ2FsU3RhdGVFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQotCQkvLyBzdGFydCBvdmVyCi0JCWl0ZXJhdG9yID0gdGhpcy5iYWcuaXRlcmF0b3IoKTsKLQkJdGhpcy5iYWcuYWRkKCJmaXZlIik7Ci0JCWV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlpdGVyYXRvci5uZXh0KCk7Ci0JCX0gY2F0Y2ggKENvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VW5pcXVlSXRlcmF0b3IoKSB7Ci0JCWludCBpID0gMDsKLQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IHRoaXMuYmFnLnVuaXF1ZUl0ZXJhdG9yKCk7Ci0JCWFzc2VydFRydWUoaXRlcmF0b3IuaGFzTmV4dCgpKTsKLQkJd2hpbGUgKGl0ZXJhdG9yLmhhc05leHQoKSkgewotCQkJaXRlcmF0b3IubmV4dCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyg1LCBpKTsKLQkJYXNzZXJ0RmFsc2UoaXRlcmF0b3IuaGFzTmV4dCgpKTsKLQotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCU9iamVjdCBlbGVtZW50ID0gbnVsbDsKLQkJdHJ5IHsKLQkJCWVsZW1lbnQgPSBpdGVyYXRvci5uZXh0KCk7Ci0JCQlmYWlsKGVsZW1lbnQudG9TdHJpbmcoKSk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQotCQkvLyBzdGFydCBvdmVyCi0JCWl0ZXJhdG9yID0gdGhpcy5iYWcudW5pcXVlSXRlcmF0b3IoKTsKLQkJT2JqZWN0IG5leHQgPSBudWxsOwotCQl3aGlsZSAoaXRlcmF0b3IuaGFzTmV4dCgpICYmICEiZm91ciIuZXF1YWxzKG5leHQpKSB7Ci0JCQluZXh0ID0gaXRlcmF0b3IubmV4dCgpOwotCQl9Ci0JCWl0ZXJhdG9yLnJlbW92ZSgpOwotCQlhc3NlcnRFcXVhbHMoNywgdGhpcy5iYWcuc2l6ZSgpKTsKLQotCQlleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJaXRlcmF0b3IucmVtb3ZlKCk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxTdGF0ZUV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCi0JCS8vIHN0YXJ0IG92ZXIKLQkJaXRlcmF0b3IgPSB0aGlzLmJhZy51bmlxdWVJdGVyYXRvcigpOwotCQl0aGlzLmJhZy5hZGQoImZpdmUiKTsKLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCWl0ZXJhdG9yLm5leHQoKTsKLQkJfSBjYXRjaCAoQ29uY3VycmVudE1vZGlmaWNhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RFbnRyaWVzKCkgewotCQlpbnQgaSA9IDA7Ci0JCUl0ZXJhdG9yPEJhZy5FbnRyeTxTdHJpbmc+PiBpdGVyYXRvciA9IHRoaXMuYmFnLmVudHJpZXMoKTsKLQkJYXNzZXJ0VHJ1ZShpdGVyYXRvci5oYXNOZXh0KCkpOwotCQl3aGlsZSAoaXRlcmF0b3IuaGFzTmV4dCgpKSB7Ci0JCQlpdGVyYXRvci5uZXh0KCk7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDUsIGkpOwotCQlhc3NlcnRGYWxzZShpdGVyYXRvci5oYXNOZXh0KCkpOwotCi0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJT2JqZWN0IGVsZW1lbnQgPSBudWxsOwotCQl0cnkgewotCQkJZWxlbWVudCA9IGl0ZXJhdG9yLm5leHQoKTsKLQkJCWZhaWwoZWxlbWVudC50b1N0cmluZygpKTsKLQkJfSBjYXRjaCAoTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCi0JCS8vIHN0YXJ0IG92ZXIKLQkJaXRlcmF0b3IgPSB0aGlzLmJhZy5lbnRyaWVzKCk7Ci0JCUJhZy5FbnRyeTxTdHJpbmc+IG5leHQgPSBudWxsOwotCQl3aGlsZSAoaXRlcmF0b3IuaGFzTmV4dCgpKSB7Ci0JCQluZXh0ID0gaXRlcmF0b3IubmV4dCgpOwotCQkJaWYgKG5leHQuZ2V0RWxlbWVudCgpLmVxdWFscygiZm91ciIpKSB7Ci0JCQkJaXRlcmF0b3IucmVtb3ZlKCk7Ci0JCQkJYnJlYWs7Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDcsIHRoaXMuYmFnLnNpemUoKSk7Ci0KLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCWl0ZXJhdG9yLnJlbW92ZSgpOwotCQl9IGNhdGNoIChJbGxlZ2FsU3RhdGVFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQotCQkvLyBzdGFydCBvdmVyCi0JCWl0ZXJhdG9yID0gdGhpcy5iYWcuZW50cmllcygpOwotCQl0aGlzLmJhZy5hZGQoImZpdmUiKTsKLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCWl0ZXJhdG9yLm5leHQoKTsKLQkJfSBjYXRjaCAoQ29uY3VycmVudE1vZGlmaWNhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotLy9UT0RPIC0gcG9vciBsb2FkIGZhY3RvciBpcyBzZWVuIGluIHRoZSBFY2xpcHNlIGJ1aWxkIGVudmlyb25tZW50IGZvciBzb21lIHJlYXNvbgotLy8JcHVibGljIHZvaWQgdGVzdEhhc2hpbmdEaXN0cmlidXRpb24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLS8vCQlCYWc8U3RyaW5nPiBiaWdCYWcgPSBuZXcgSGFzaEJhZzxTdHJpbmc+KCk7Ci0vLwkJZm9yIChpbnQgaSA9IDA7IGkgPCAxMDAwMDsgaSsrKSB7Ci0vLwkJCWJpZ0JhZy5hZGQoIm9iamVjdCIgKyBpKTsKLS8vCQl9Ci0vLwotLy8JCWphdmEubGFuZy5yZWZsZWN0LkZpZWxkIGZpZWxkID0gYmlnQmFnLmdldENsYXNzKCkuZ2V0RGVjbGFyZWRGaWVsZCgidGFibGUiKTsKLS8vCQlmaWVsZC5zZXRBY2Nlc3NpYmxlKHRydWUpOwotLy8JCU9iamVjdFtdIHRhYmxlID0gKE9iamVjdFtdKSBmaWVsZC5nZXQoYmlnQmFnKTsKLS8vCQlpbnQgYnVja2V0Q291bnQgPSB0YWJsZS5sZW5ndGg7Ci0vLwkJaW50IGZpbGxlZEJ1Y2tldENvdW50ID0gMDsKLS8vCQlmb3IgKE9iamVjdCBvIDogdGFibGUpIHsKLS8vCQkJaWYgKG8gIT0gbnVsbCkgewotLy8JCQkJZmlsbGVkQnVja2V0Q291bnQrKzsKLS8vCQkJfQotLy8JCX0KLS8vCQlmbG9hdCBsb2FkRmFjdG9yID0gKChmbG9hdCkgZmlsbGVkQnVja2V0Q291bnQpIC8gKChmbG9hdCkgYnVja2V0Q291bnQpOwotLy8JCWFzc2VydFRydWUoIldBUk5JTkcgLSBwb29yIGxvYWQgZmFjdG9yOiAiICsgbG9hZEZhY3RvciwgbG9hZEZhY3RvciA+IDAuMjApOwotLy8JCWFzc2VydFRydWUoIldBUk5JTkcgLSBwb29yIGxvYWQgZmFjdG9yOiAiICsgbG9hZEZhY3RvciwgbG9hZEZhY3RvciA8IDAuNzUpOwotLy8JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZSgpIHsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5yZW1vdmUoIm9uZSIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcuY29udGFpbnMoIm9uZSIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcucmVtb3ZlKCJvbmUiKSk7Ci0KLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5yZW1vdmUoInR3byIpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5yZW1vdmUoInR3byIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcuY29udGFpbnMoInR3byIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcucmVtb3ZlKCJ0d28iKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUNvdW50KCkgewotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5yZW1vdmUoIm9uZSIsIDApKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucygib25lIikpOwotCi0JCWFzc2VydFRydWUodGhpcy5iYWcucmVtb3ZlKCJvbmUiLCAxKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLmNvbnRhaW5zKCJvbmUiKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLnJlbW92ZSgib25lIikpOwotCi0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLnJlbW92ZSgidHdvIiwgLTMpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5yZW1vdmUoInR3byIsIDEpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucygidHdvIikpOwotCi0JCWFzc2VydFRydWUodGhpcy5iYWcucmVtb3ZlKCJ0d28iLCAxKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLmNvbnRhaW5zKCJ0d28iKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLnJlbW92ZSgidHdvIikpOwotCi0JCWFzc2VydFRydWUodGhpcy5iYWcucmVtb3ZlKCJ0aHJlZSIsIDMpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcuY29udGFpbnMoInRocmVlIikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5yZW1vdmUoInRocmVlIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVBbGwoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWMuYWRkKCJvbmUiKTsKLQkJYy5hZGQoInRocmVlIik7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcucmVtb3ZlQWxsKGMpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcuY29udGFpbnMoIm9uZSIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcuY29udGFpbnMoInRocmVlIikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5yZW1vdmUoIm9uZSIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcucmVtb3ZlKCJ0aHJlZSIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcucmVtb3ZlQWxsKGMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmV0YWluQWxsKCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQljLmFkZCgib25lIik7Ci0JCWMuYWRkKCJ0aHJlZSIpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLnJldGFpbkFsbChjKSk7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcuY29udGFpbnMoIm9uZSIpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucygidGhyZWUiKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLmNvbnRhaW5zKCJ0d28iKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLmNvbnRhaW5zKCJmb3VyIikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5yZW1vdmUoInR3byIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcucmVtb3ZlKCJmb3VyIikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5yZXRhaW5BbGwoYykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTaXplKCkgewotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLnNpemUoKSA9PSAxMSk7Ci0JCXRoaXMuYmFnLmFkZCgiZml2ZSIpOwotCQl0aGlzLmJhZy5hZGQoImZpdmUiKTsKLQkJdGhpcy5iYWcuYWRkKCJmaXZlIik7Ci0JCXRoaXMuYmFnLmFkZCgiZml2ZSIpOwotCQl0aGlzLmJhZy5hZGQoImZpdmUiKTsKLQkJYXNzZXJ0RXF1YWxzKDE2LCB0aGlzLmJhZy5zaXplKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXJpYWxpemF0aW9uKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCUJhZzxTdHJpbmc+IGJhZzIgPSBUZXN0VG9vbHMuc2VyaWFsaXplKHRoaXMuYmFnKTsKLQotCQlhc3NlcnRUcnVlKCJzYW1lIG9iamVjdD8iLCB0aGlzLmJhZyAhPSBiYWcyKTsKLQkJYXNzZXJ0RXF1YWxzKDExLCBiYWcyLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJhZywgYmFnMik7Ci0JCS8vIGxvb2sgZm9yIHNpbWlsYXIgZWxlbWVudHMKLQkJYXNzZXJ0VHJ1ZShiYWcyLmNvbnRhaW5zKG51bGwpKTsKLQkJYXNzZXJ0VHJ1ZShiYWcyLmNvbnRhaW5zKCJvbmUiKSk7Ci0JCWFzc2VydFRydWUoYmFnMi5jb250YWlucygidHdvIikpOwotCQlhc3NlcnRUcnVlKGJhZzIuY29udGFpbnMoInRocmVlIikpOwotCQlhc3NlcnRUcnVlKGJhZzIuY29udGFpbnMoImZvdXIiKSk7Ci0KLQkJaW50IG51bGxDb3VudCA9IDAsIG9uZUNvdW50ID0gMCwgdHdvQ291bnQgPSAwLCB0aHJlZUNvdW50ID0gMCwgZm91ckNvdW50ID0gMDsKLQkJZm9yIChTdHJpbmcgcyA6IGJhZzIpIHsKLQkJCWlmIChzID09IG51bGwpIHsKLQkJCQludWxsQ291bnQrKzsKLQkJCX0gZWxzZSBpZiAocy5lcXVhbHMoIm9uZSIpKSB7Ci0JCQkJb25lQ291bnQrKzsKLQkJCX0gZWxzZSBpZiAocy5lcXVhbHMoInR3byIpKSB7Ci0JCQkJdHdvQ291bnQrKzsKLQkJCX0gZWxzZSBpZiAocy5lcXVhbHMoInRocmVlIikpIHsKLQkJCQl0aHJlZUNvdW50Kys7Ci0JCQl9IGVsc2UgaWYgKHMuZXF1YWxzKCJmb3VyIikpIHsKLQkJCQlmb3VyQ291bnQrKzsKLQkJCX0KLQkJfQotCQlhc3NlcnRFcXVhbHMoMSwgbnVsbENvdW50KTsKLQkJYXNzZXJ0RXF1YWxzKDEsIG9uZUNvdW50KTsKLQkJYXNzZXJ0RXF1YWxzKDIsIHR3b0NvdW50KTsKLQkJYXNzZXJ0RXF1YWxzKDMsIHRocmVlQ291bnQpOwotCQlhc3NlcnRFcXVhbHMoNCwgZm91ckNvdW50KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VG9BcnJheSgpIHsKLQkJT2JqZWN0W10gYSA9IHRoaXMuYmFnLnRvQXJyYXkoKTsKLQkJYXNzZXJ0RXF1YWxzKDExLCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsIG51bGwpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgIm9uZSIpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgInR3byIpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgInRocmVlIikpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAiZm91ciIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VG9BcnJheU9iamVjdEFycmF5KCkgewotCQlTdHJpbmdbXSBhID0gbmV3IFN0cmluZ1sxMl07Ci0JCWFbMTFdID0gIm5vdCBudWxsIjsKLQkJU3RyaW5nW10gYiA9IHRoaXMuYmFnLnRvQXJyYXkoYSk7Ci0JCWFzc2VydEVxdWFscyhhLCBiKTsKLQkJYXNzZXJ0RXF1YWxzKDEyLCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsIG51bGwpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgIm9uZSIpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgInR3byIpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgInRocmVlIikpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCAiZm91ciIpKTsKLQkJYXNzZXJ0VHJ1ZShhWzExXSA9PSBudWxsKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VG9TdHJpbmcoKSB7Ci0JCVN0cmluZyBzID0gdGhpcy5iYWcudG9TdHJpbmcoKTsKLQkJYXNzZXJ0VHJ1ZShzLnN0YXJ0c1dpdGgoIlsiKSk7Ci0JCWFzc2VydFRydWUocy5lbmRzV2l0aCgiXSIpKTsKLQkJaW50IGNvbW1hQ291bnQgPSAwOwotCQlmb3IgKGludCBpID0gMDsgaSA8IHMubGVuZ3RoKCk7IGkrKykgewotCQkJaWYgKHMuY2hhckF0KGkpID09ICcsJykgewotCQkJCWNvbW1hQ291bnQrKzsKLQkJCX0KLQkJfQotCQlhc3NlcnRFcXVhbHMoMTAsIGNvbW1hQ291bnQpOwotCQlhc3NlcnRUcnVlKHMuaW5kZXhPZigib25lIikgIT0gLTEpOwotCQlhc3NlcnRUcnVlKHMuaW5kZXhPZigidHdvIikgIT0gLTEpOwotCQlhc3NlcnRUcnVlKHMuaW5kZXhPZigidGhyZWUiKSAhPSAtMSk7Ci0JCWFzc2VydFRydWUocy5pbmRleE9mKCJmb3VyIikgIT0gLTEpOwotCQlhc3NlcnRUcnVlKHMuaW5kZXhPZigibnVsbCIpICE9IC0xKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvSWRlbnRpdHlIYXNoQmFnVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvSWRlbnRpdHlIYXNoQmFnVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOGQ3ZjM5NC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0lkZW50aXR5SGFzaEJhZ1Rlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1NjQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkNvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb247Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Ob1N1Y2hFbGVtZW50RXhjZXB0aW9uOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuSWRlbnRpdHlIYXNoQmFnOwotCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBJZGVudGl0eUhhc2hCYWdUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIElkZW50aXR5SGFzaEJhZzxTdHJpbmc+IGJhZzsKLQlwcml2YXRlIFN0cmluZyBvbmUgPSAib25lIjsKLQlwcml2YXRlIFN0cmluZyB0d28gPSAidHdvIjsKLQlwcml2YXRlIFN0cmluZyB0aHJlZSA9ICJ0aHJlZSI7Ci0JcHJpdmF0ZSBTdHJpbmcgZm91ciA9ICJmb3VyIjsKLQlwcml2YXRlIFN0cmluZyBmb28gPSAiZm9vIjsKLQlwcml2YXRlIFN0cmluZyBiYXIgPSAiYmFyIjsKLQotCXB1YmxpYyBJZGVudGl0eUhhc2hCYWdUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLmJhZyA9IHRoaXMuYnVpbGRCYWcoKTsKLQl9Ci0JCi0JcHJvdGVjdGVkIElkZW50aXR5SGFzaEJhZzxTdHJpbmc+IGJ1aWxkQmFnKCkgewotCQlJZGVudGl0eUhhc2hCYWc8U3RyaW5nPiByZXN1bHQgPSBuZXcgSWRlbnRpdHlIYXNoQmFnPFN0cmluZz4oKTsKLQkJcmVzdWx0LmFkZChudWxsKTsKLQkJcmVzdWx0LmFkZCh0aGlzLm9uZSk7Ci0JCXJlc3VsdC5hZGQodGhpcy50d28pOwotCQlyZXN1bHQuYWRkKHRoaXMudHdvKTsKLQkJcmVzdWx0LmFkZCh0aGlzLnRocmVlKTsKLQkJcmVzdWx0LmFkZCh0aGlzLnRocmVlKTsKLQkJcmVzdWx0LmFkZCh0aGlzLnRocmVlKTsKLQkJcmVzdWx0LmFkZCh0aGlzLmZvdXIpOwotCQlyZXN1bHQuYWRkKHRoaXMuZm91cik7Ci0JCXJlc3VsdC5hZGQodGhpcy5mb3VyKTsKLQkJcmVzdWx0LmFkZCh0aGlzLmZvdXIpOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQkKLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uPFN0cmluZz4gYnVpbGRDb2xsZWN0aW9uKCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQljLmFkZCh0aGlzLmZvbyk7Ci0JCWMuYWRkKHRoaXMuZm9vKTsKLQkJYy5hZGQodGhpcy5iYXIpOwotCQljLmFkZCh0aGlzLmJhcik7Ci0JCWMuYWRkKHRoaXMuYmFyKTsKLQkJcmV0dXJuIGM7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHRlc3RDdG9yQ29sbGVjdGlvbigpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSB0aGlzLmJ1aWxkQ29sbGVjdGlvbigpOwotCQlJZGVudGl0eUhhc2hCYWc8U3RyaW5nPiBsb2NhbEJhZyA9IG5ldyBJZGVudGl0eUhhc2hCYWc8U3RyaW5nPihjKTsKLQkJZm9yIChTdHJpbmcgcyA6IGMpIHsKLQkJCWFzc2VydFRydWUobG9jYWxCYWcuY29udGFpbnMocykpOwotCQl9Ci0JfQotCQotCXB1YmxpYyB2b2lkIHRlc3RDdG9ySW50RmxvYXQoKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQ7Ci0JCi0JCWV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0aGlzLmJhZyA9IG5ldyBJZGVudGl0eUhhc2hCYWc8U3RyaW5nPigtMjAsIDAuNjZmKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JCi0JCWV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0aGlzLmJhZyA9IG5ldyBJZGVudGl0eUhhc2hCYWc8U3RyaW5nPigyMCwgLTAuNjZmKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHRlc3RBZGQoKSB7Ci0JCS8vIHRoZSBvdGhlciBhZGRzIHRvb2sgcGxhY2UgaW4gc2V0VXAKLQkJU3RyaW5nIGZpdmUgPSAiZml2ZSI7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcuYWRkKGZpdmUpKTsKLQkKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucyh0aGlzLm9uZSkpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKHRoaXMudHdvKSk7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcuY29udGFpbnModGhpcy50aHJlZSkpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKHRoaXMuZm91cikpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKGZpdmUpKTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgdGVzdEFkZENvdW50KCkgewotCQlTdHJpbmcgbWludXMzID0gIm1pbnVzMyI7Ci0JCVN0cmluZyB6ZXJvID0gInplcm8iOwotCQlTdHJpbmcgZml2ZSA9ICJmaXZlIjsKLQkJLy8gdGhlIG90aGVyIGFkZHMgdG9vayBwbGFjZSBpbiBzZXRVcAotCQl0aGlzLmJhZy5hZGQobWludXMzLCAtMyk7Ci0JCXRoaXMuYmFnLmFkZCh6ZXJvLCAwKTsKLQkJdGhpcy5iYWcuYWRkKGZpdmUsIDUpOwotCi0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLmNvbnRhaW5zKG1pbnVzMykpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucyh6ZXJvKSk7Ci0JCWFzc2VydEVxdWFscygxLCB0aGlzLmJhZy5jb3VudCh0aGlzLm9uZSkpOwotCQlhc3NlcnRFcXVhbHMoMiwgdGhpcy5iYWcuY291bnQodGhpcy50d28pKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIHRoaXMuYmFnLmNvdW50KHRoaXMudGhyZWUpKTsKLQkJYXNzZXJ0RXF1YWxzKDQsIHRoaXMuYmFnLmNvdW50KHRoaXMuZm91cikpOwotCQlhc3NlcnRFcXVhbHMoNSwgdGhpcy5iYWcuY291bnQoZml2ZSkpOwotCi0JCXRoaXMuYmFnLmFkZCh0aGlzLnRocmVlLCAyKTsKLQkJYXNzZXJ0RXF1YWxzKDUsIHRoaXMuYmFnLmNvdW50KHRoaXMudGhyZWUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsKCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IHRoaXMuYnVpbGRDb2xsZWN0aW9uKCk7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcuYWRkQWxsKGMpKTsKLQkJZm9yIChTdHJpbmcgcyA6IGMpIHsKLQkJCWFzc2VydFRydWUodGhpcy5iYWcuY29udGFpbnMocykpOwotCQl9Ci0JfQotCQotCXB1YmxpYyB2b2lkIHRlc3RDbGVhcigpIHsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucyh0aGlzLm9uZSkpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKHRoaXMudHdvKSk7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcuY29udGFpbnModGhpcy50aHJlZSkpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKHRoaXMuZm91cikpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKG51bGwpKTsKLQkJYXNzZXJ0RXF1YWxzKDExLCB0aGlzLmJhZy5zaXplKCkpOwotCQl0aGlzLmJhZy5jbGVhcigpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucyh0aGlzLm9uZSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucyh0aGlzLnR3bykpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucyh0aGlzLnRocmVlKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLmNvbnRhaW5zKHRoaXMuZm91cikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucyhudWxsKSk7Ci0JCWFzc2VydEVxdWFscygwLCB0aGlzLmJhZy5zaXplKCkpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0Q2xvbmUoKSB7Ci0JCUlkZW50aXR5SGFzaEJhZzxTdHJpbmc+IGJhZzIgPSB0aGlzLmJhZy5jbG9uZSgpOwotCQlhc3NlcnRUcnVlKCJiYWQgY2xvbmUiLCB0aGlzLmJhZyAhPSBiYWcyKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYWQgY2xvbmUiLCB0aGlzLmJhZywgYmFnMik7Ci0JCWFzc2VydFRydWUoImJhZCBjbG9uZSIsIHRoaXMuYmFnLmhhc2hDb2RlKCkgPT0gYmFnMi5oYXNoQ29kZSgpKTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zKCkgewotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKG51bGwpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucyh0aGlzLm9uZSkpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKHRoaXMudHdvKSk7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcuY29udGFpbnModGhpcy50aHJlZSkpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKHRoaXMuZm91cikpOwotCi0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLmNvbnRhaW5zKG5ldyBTdHJpbmcoImZvdXIiKSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucygiZml2ZSIpKTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zQWxsKCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQljLmFkZChudWxsKTsKLQkJYy5hZGQodGhpcy5vbmUpOwotCQljLmFkZCh0aGlzLnR3byk7Ci0JCWMuYWRkKHRoaXMudGhyZWUpOwotCQljLmFkZCh0aGlzLmZvdXIpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zQWxsKGMpKTsKLQkJYy5hZGQobmV3IFN0cmluZyh0aGlzLmZvdXIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcuY29udGFpbnNBbGwoYykpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0Q291bnQoKSB7Ci0JCWFzc2VydEVxdWFscygwLCB0aGlzLmJhZy5jb3VudCgiemVybyIpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIHRoaXMuYmFnLmNvdW50KCJvbmUiKSk7Ci0JCWFzc2VydEVxdWFscygyLCB0aGlzLmJhZy5jb3VudCgidHdvIikpOwotCQlhc3NlcnRFcXVhbHMoMywgdGhpcy5iYWcuY291bnQoInRocmVlIikpOwotCQlhc3NlcnRFcXVhbHMoNCwgdGhpcy5iYWcuY291bnQoImZvdXIiKSk7Ci0JCWFzc2VydEVxdWFscygwLCB0aGlzLmJhZy5jb3VudCgiZml2ZSIpKTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgdGVzdEVxdWFscygpIHsKLQkJSWRlbnRpdHlIYXNoQmFnPFN0cmluZz4gYmFnMiA9IHRoaXMuYnVpbGRCYWcoKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYmFnLCBiYWcyKTsKLQkJYmFnMi5hZGQoImZpdmUiKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcuZXF1YWxzKGJhZzIpKTsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4odGhpcy5iYWcpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5lcXVhbHMoYykpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0SGFzaENvZGUoKSB7Ci0JCUlkZW50aXR5SGFzaEJhZzxTdHJpbmc+IGJhZzIgPSB0aGlzLmJ1aWxkQmFnKCk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJhZy5oYXNoQ29kZSgpLCBiYWcyLmhhc2hDb2RlKCkpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0SXNFbXB0eSgpIHsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcuaXNFbXB0eSgpKTsKLQkJdGhpcy5iYWcuY2xlYXIoKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5pc0VtcHR5KCkpOwotCQl0aGlzLmJhZy5hZGQoImZvbyIpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5pc0VtcHR5KCkpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0RW1wdHlJdGVyYXRvcigpIHsKLQkJdGhpcy5iYWcuY2xlYXIoKTsKLQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IHRoaXMuYmFnLml0ZXJhdG9yKCk7Ci0JCWFzc2VydEZhbHNlKGl0ZXJhdG9yLmhhc05leHQoKSk7Ci0JCi0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJT2JqZWN0IGVsZW1lbnQgPSBudWxsOwotCQl0cnkgewotCQkJZWxlbWVudCA9IGl0ZXJhdG9yLm5leHQoKTsKLQkJfSBjYXRjaCAoTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIk5vU3VjaEVsZW1lbnRFeGNlcHRpb24gbm90IHRocm93bjogIiArIGVsZW1lbnQsIGV4Q2F1Z2h0KTsKLQkKLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCWl0ZXJhdG9yLnJlbW92ZSgpOwotCQl9IGNhdGNoIChJbGxlZ2FsU3RhdGVFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJJbGxlZ2FsU3RhdGVFeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgdGVzdEl0ZXJhdG9yKCkgewotCQlpbnQgaSA9IDA7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IgPSB0aGlzLmJhZy5pdGVyYXRvcigpOwotCQlhc3NlcnRUcnVlKGl0ZXJhdG9yLmhhc05leHQoKSk7Ci0JCXdoaWxlIChpdGVyYXRvci5oYXNOZXh0KCkpIHsKLQkJCWl0ZXJhdG9yLm5leHQoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHMoMTEsIGkpOwotCQlhc3NlcnRGYWxzZShpdGVyYXRvci5oYXNOZXh0KCkpOwotCQotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCU9iamVjdCBlbGVtZW50ID0gbnVsbDsKLQkJdHJ5IHsKLQkJCWVsZW1lbnQgPSBpdGVyYXRvci5uZXh0KCk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIG5vdCB0aHJvd246ICIgKyBlbGVtZW50LCBleENhdWdodCk7Ci0JCi0JCWl0ZXJhdG9yLnJlbW92ZSgpOwotCQlhc3NlcnRFcXVhbHMoMTAsIHRoaXMuYmFnLnNpemUoKSk7Ci0JCi0JCWV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlpdGVyYXRvci5yZW1vdmUoKTsKLQkJfSBjYXRjaCAoSWxsZWdhbFN0YXRlRXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiSWxsZWdhbFN0YXRlRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JCi0JCS8vIHN0YXJ0IG92ZXIKLQkJaXRlcmF0b3IgPSB0aGlzLmJhZy5pdGVyYXRvcigpOwotCQl0aGlzLmJhZy5hZGQoImZpdmUiKTsKLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCWl0ZXJhdG9yLm5leHQoKTsKLQkJfSBjYXRjaCAoQ29uY3VycmVudE1vZGlmaWNhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIkNvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgdGVzdFVuaXF1ZUl0ZXJhdG9yKCkgewotCQlpbnQgaSA9IDA7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IgPSB0aGlzLmJhZy51bmlxdWVJdGVyYXRvcigpOwotCQlhc3NlcnRUcnVlKGl0ZXJhdG9yLmhhc05leHQoKSk7Ci0JCXdoaWxlIChpdGVyYXRvci5oYXNOZXh0KCkpIHsKLQkJCWl0ZXJhdG9yLm5leHQoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHMoNSwgaSk7Ci0JCWFzc2VydEZhbHNlKGl0ZXJhdG9yLmhhc05leHQoKSk7Ci0KLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlPYmplY3QgZWxlbWVudCA9IG51bGw7Ci0JCXRyeSB7Ci0JCQllbGVtZW50ID0gaXRlcmF0b3IubmV4dCgpOwotCQkJZmFpbChlbGVtZW50LnRvU3RyaW5nKCkpOwotCQl9IGNhdGNoIChOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQkJLy8gc3RhcnQgb3ZlcgotCQlpdGVyYXRvciA9IHRoaXMuYmFnLnVuaXF1ZUl0ZXJhdG9yKCk7Ci0JCU9iamVjdCBuZXh0ID0gbnVsbDsKLQkJd2hpbGUgKGl0ZXJhdG9yLmhhc05leHQoKSAmJiAhdGhpcy5mb3VyLmVxdWFscyhuZXh0KSkgewotCQkJbmV4dCA9IGl0ZXJhdG9yLm5leHQoKTsKLQkJfQotCQlpdGVyYXRvci5yZW1vdmUoKTsKLQkJYXNzZXJ0RXF1YWxzKDcsIHRoaXMuYmFnLnNpemUoKSk7Ci0KLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCWl0ZXJhdG9yLnJlbW92ZSgpOwotCQl9IGNhdGNoIChJbGxlZ2FsU3RhdGVFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQotCQkvLyBzdGFydCBvdmVyCi0JCWl0ZXJhdG9yID0gdGhpcy5iYWcudW5pcXVlSXRlcmF0b3IoKTsKLQkJU3RyaW5nIGZpdmUgPSAiZml2ZSI7Ci0JCXRoaXMuYmFnLmFkZChmaXZlKTsKLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCWl0ZXJhdG9yLm5leHQoKTsKLQkJfSBjYXRjaCAoQ29uY3VycmVudE1vZGlmaWNhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RFbnRyaWVzKCkgewotCQlpbnQgaSA9IDA7Ci0JCUl0ZXJhdG9yPG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkJhZy5FbnRyeTxTdHJpbmc+PiBpdGVyYXRvciA9IHRoaXMuYmFnLmVudHJpZXMoKTsKLQkJYXNzZXJ0VHJ1ZShpdGVyYXRvci5oYXNOZXh0KCkpOwotCQl3aGlsZSAoaXRlcmF0b3IuaGFzTmV4dCgpKSB7Ci0JCQlpdGVyYXRvci5uZXh0KCk7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDUsIGkpOwotCQlhc3NlcnRGYWxzZShpdGVyYXRvci5oYXNOZXh0KCkpOwotCi0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJT2JqZWN0IGVsZW1lbnQgPSBudWxsOwotCQl0cnkgewotCQkJZWxlbWVudCA9IGl0ZXJhdG9yLm5leHQoKTsKLQkJCWZhaWwoZWxlbWVudC50b1N0cmluZygpKTsKLQkJfSBjYXRjaCAoTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCi0JCS8vIHN0YXJ0IG92ZXIKLQkJaXRlcmF0b3IgPSB0aGlzLmJhZy5lbnRyaWVzKCk7Ci0JCW9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkJhZy5FbnRyeTxTdHJpbmc+IG5leHQgPSBudWxsOwotCQl3aGlsZSAoaXRlcmF0b3IuaGFzTmV4dCgpKSB7Ci0JCQluZXh0ID0gaXRlcmF0b3IubmV4dCgpOwotCQkJaWYgKG5leHQuZ2V0RWxlbWVudCgpLmVxdWFscyh0aGlzLmZvdXIpKSB7Ci0JCQkJaXRlcmF0b3IucmVtb3ZlKCk7Ci0JCQkJYnJlYWs7Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDcsIHRoaXMuYmFnLnNpemUoKSk7Ci0KLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCWl0ZXJhdG9yLnJlbW92ZSgpOwotCQl9IGNhdGNoIChJbGxlZ2FsU3RhdGVFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQotCQkvLyBzdGFydCBvdmVyCi0JCWl0ZXJhdG9yID0gdGhpcy5iYWcuZW50cmllcygpOwotCQlTdHJpbmcgZml2ZSA9ICJmaXZlIjsKLQkJdGhpcy5iYWcuYWRkKGZpdmUpOwotCQlleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJaXRlcmF0b3IubmV4dCgpOwotCQl9IGNhdGNoIChDb25jdXJyZW50TW9kaWZpY2F0aW9uRXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JLy8gQ29tbWVudGluZyBvdXQgdGhpcyB0ZXN0IGFzIGl0IGlzIGFsc28gZmFpbGluZyBpbiB0aGUgRWNsaXBzZSBidWlsZAotCS8vIGFwcGFyZW5seSB0aGVyZSBhcmUgc29tZSBoYXNoaW5nIGlzc3VlcyB0aGF0IG5lZWQgdG8gYmUgbG9va2VkIGludG8uCi0vLwlwdWJsaWMgdm9pZCB0ZXN0SGFzaGluZ0Rpc3RyaWJ1dGlvbigpIHRocm93cyBFeGNlcHRpb24gewotLy8JCUlkZW50aXR5SGFzaEJhZzxTdHJpbmc+IGJpZ0JhZyA9IG5ldyBJZGVudGl0eUhhc2hCYWc8U3RyaW5nPigpOwotLy8JCWZvciAoaW50IGkgPSAwOyBpIDwgMTAwMDA7IGkrKykgewotLy8JCQliaWdCYWcuYWRkKCJvYmplY3QiICsgaSk7Ci0vLwkJfQotLy8JCi0vLwkJamF2YS5sYW5nLnJlZmxlY3QuRmllbGQgZmllbGQgPSBiaWdCYWcuZ2V0Q2xhc3MoKS5nZXREZWNsYXJlZEZpZWxkKCJ0YWJsZSIpOwotLy8JCWZpZWxkLnNldEFjY2Vzc2libGUodHJ1ZSk7Ci0vLwkJT2JqZWN0W10gdGFibGUgPSAoT2JqZWN0W10pIGZpZWxkLmdldChiaWdCYWcpOwotLy8JCWludCBidWNrZXRDb3VudCA9IHRhYmxlLmxlbmd0aDsKLS8vCQlpbnQgZmlsbGVkQnVja2V0Q291bnQgPSAwOwotLy8JCWZvciAoaW50IGkgPSAwOyBpIDwgYnVja2V0Q291bnQ7IGkrKykgewotLy8JCQlpZiAodGFibGVbaV0gIT0gbnVsbCkgewotLy8JCQkJZmlsbGVkQnVja2V0Q291bnQrKzsKLS8vCQkJfQotLy8JCX0KLS8vCQlmbG9hdCBsb2FkRmFjdG9yID0gKChmbG9hdCkgZmlsbGVkQnVja2V0Q291bnQpLygoZmxvYXQpIGJ1Y2tldENvdW50KTsKLS8vCQkvLyBTeXN0ZW0ub3V0LnByaW50bG4oImxvYWQgZmFjdG9yOiAiICsgbG9hZEZhY3RvciArICIgKCIgKyBmaWxsZWRCdWNrZXRDb3VudCArICIvIiArIGJ1Y2tldENvdW50ICsgIikiKTsKLS8vCQlhc3NlcnRUcnVlKCJXQVJOSU5HIC0gcG9vciBsb2FkIGZhY3RvcjogIiArIGxvYWRGYWN0b3IsIGxvYWRGYWN0b3IgPiAwLjIwKTsKLS8vCQlhc3NlcnRUcnVlKCJXQVJOSU5HIC0gcG9vciBsb2FkIGZhY3RvcjogIiArIGxvYWRGYWN0b3IsIGxvYWRGYWN0b3IgPCAwLjc1KTsKLS8vCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlKCkgewotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLnJlbW92ZSh0aGlzLm9uZSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucyh0aGlzLm9uZSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5yZW1vdmUodGhpcy5vbmUpKTsKLQkKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5yZW1vdmUodGhpcy50d28pKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5yZW1vdmUodGhpcy50d28pKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcuY29udGFpbnModGhpcy50d28pKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcucmVtb3ZlKHRoaXMudHdvKSk7Ci0KLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcucmVtb3ZlKG5ldyBTdHJpbmcodGhpcy50aHJlZSkpKTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUNvdW50KCkgewotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5yZW1vdmUodGhpcy5vbmUsIDApKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucyh0aGlzLm9uZSkpOwotCi0JCWFzc2VydFRydWUodGhpcy5iYWcucmVtb3ZlKHRoaXMub25lLCAxKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLmNvbnRhaW5zKHRoaXMub25lKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLnJlbW92ZSh0aGlzLm9uZSkpOwotCi0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLnJlbW92ZSh0aGlzLnR3bywgLTMpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5yZW1vdmUodGhpcy50d28sIDEpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5jb250YWlucyh0aGlzLnR3bykpOwotCi0JCWFzc2VydFRydWUodGhpcy5iYWcucmVtb3ZlKHRoaXMudHdvLCAxKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLmNvbnRhaW5zKHRoaXMudHdvKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLnJlbW92ZSh0aGlzLnR3bykpOwotCi0JCWFzc2VydFRydWUodGhpcy5iYWcucmVtb3ZlKHRoaXMudGhyZWUsIDMpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcuY29udGFpbnModGhpcy50aHJlZSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5yZW1vdmUodGhpcy50aHJlZSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVBbGwoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWMuYWRkKHRoaXMub25lKTsKLQkJYy5hZGQobmV3IFN0cmluZyh0aGlzLnR3bykpOwotCQljLmFkZCh0aGlzLnRocmVlKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5yZW1vdmVBbGwoYykpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucyh0aGlzLm9uZSkpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKHRoaXMudHdvKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLmNvbnRhaW5zKHRoaXMudGhyZWUpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcucmVtb3ZlKHRoaXMub25lKSk7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcucmVtb3ZlKHRoaXMudHdvKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLnJlbW92ZSh0aGlzLnRocmVlKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLnJlbW92ZUFsbChjKSk7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHRlc3RSZXRhaW5BbGwoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWMuYWRkKHRoaXMub25lKTsKLQkJYy5hZGQobmV3IFN0cmluZyh0aGlzLnR3bykpOwotCQljLmFkZCh0aGlzLnRocmVlKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZy5yZXRhaW5BbGwoYykpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnLmNvbnRhaW5zKHRoaXMub25lKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLmNvbnRhaW5zKHRoaXMudHdvKSk7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcuY29udGFpbnModGhpcy50aHJlZSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZy5jb250YWlucyh0aGlzLmZvdXIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcucmVtb3ZlKHRoaXMudHdvKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnLnJlbW92ZSh0aGlzLmZvdXIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWcucmV0YWluQWxsKGMpKTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgdGVzdFNpemUoKSB7Ci0JCWFzc2VydFRydWUodGhpcy5iYWcuc2l6ZSgpID09IDExKTsKLQkJU3RyaW5nIGZpdmUgPSAiZml2ZSI7Ci0JCXRoaXMuYmFnLmFkZChmaXZlKTsKLQkJdGhpcy5iYWcuYWRkKGZpdmUpOwotCQl0aGlzLmJhZy5hZGQoZml2ZSk7Ci0JCXRoaXMuYmFnLmFkZChmaXZlKTsKLQkJdGhpcy5iYWcuYWRkKG5ldyBTdHJpbmcoZml2ZSkpOwotCQlhc3NlcnRFcXVhbHMoMTYsIHRoaXMuYmFnLnNpemUoKSk7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHRlc3RTZXJpYWxpemF0aW9uKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCUlkZW50aXR5SGFzaEJhZzxTdHJpbmc+IGJhZzIgPSBUZXN0VG9vbHMuc2VyaWFsaXplKHRoaXMuYmFnKTsKLQkKLQkJYXNzZXJ0VHJ1ZSgic2FtZSBvYmplY3Q/IiwgdGhpcy5iYWcgIT0gYmFnMik7Ci0JCWFzc2VydEVxdWFscygxMSwgYmFnMi5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoQ29sbGVjdGlvblRvb2xzLmJhZyh0aGlzLmJhZy5pdGVyYXRvcigpKSwgQ29sbGVjdGlvblRvb2xzLmJhZyhiYWcyLml0ZXJhdG9yKCkpKTsKLQkJLy8gbG9vayBmb3Igc2ltaWxhciBlbGVtZW50cwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5iYWcoYmFnMi5pdGVyYXRvcigpKS5jb250YWlucyhudWxsKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmJhZyhiYWcyLml0ZXJhdG9yKCkpLmNvbnRhaW5zKCJvbmUiKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmJhZyhiYWcyLml0ZXJhdG9yKCkpLmNvbnRhaW5zKCJ0d28iKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmJhZyhiYWcyLml0ZXJhdG9yKCkpLmNvbnRhaW5zKCJ0aHJlZSIpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuYmFnKGJhZzIuaXRlcmF0b3IoKSkuY29udGFpbnMoImZvdXIiKSk7Ci0JCi0JCWludCBudWxsQ291bnQgPSAwLCBvbmVDb3VudCA9IDAsIHR3b0NvdW50ID0gMCwgdGhyZWVDb3VudCA9IDAsIGZvdXJDb3VudCA9IDA7Ci0JCWZvciAoU3RyaW5nIG5leHQgOiBiYWcyKSB7Ci0JCQlpZiAobmV4dCA9PSBudWxsKQotCQkJCW51bGxDb3VudCsrOwotCQkJZWxzZSBpZiAobmV4dC5lcXVhbHMoIm9uZSIpKQotCQkJCW9uZUNvdW50Kys7Ci0JCQllbHNlIGlmIChuZXh0LmVxdWFscygidHdvIikpCi0JCQkJdHdvQ291bnQrKzsKLQkJCWVsc2UgaWYgKG5leHQuZXF1YWxzKCJ0aHJlZSIpKQotCQkJCXRocmVlQ291bnQrKzsKLQkJCWVsc2UgaWYgKG5leHQuZXF1YWxzKCJmb3VyIikpCi0JCQkJZm91ckNvdW50Kys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDEsIG51bGxDb3VudCk7Ci0JCWFzc2VydEVxdWFscygxLCBvbmVDb3VudCk7Ci0JCWFzc2VydEVxdWFscygyLCB0d29Db3VudCk7Ci0JCWFzc2VydEVxdWFscygzLCB0aHJlZUNvdW50KTsKLQkJYXNzZXJ0RXF1YWxzKDQsIGZvdXJDb3VudCk7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHRlc3RUb0FycmF5KCkgewotCQlPYmplY3RbXSBhID0gdGhpcy5iYWcudG9BcnJheSgpOwotCQlhc3NlcnRFcXVhbHMoMTEsIGEubGVuZ3RoKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgbnVsbCkpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCB0aGlzLm9uZSkpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCB0aGlzLnR3bykpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCB0aGlzLnRocmVlKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsIHRoaXMuZm91cikpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0VG9BcnJheU9iamVjdEFycmF5KCkgewotCQlTdHJpbmdbXSBhID0gbmV3IFN0cmluZ1sxMl07Ci0JCWFbMTFdID0gIm5vdCBudWxsIjsKLQkJU3RyaW5nW10gYiA9IHRoaXMuYmFnLnRvQXJyYXkoYSk7Ci0JCWFzc2VydEVxdWFscyhhLCBiKTsKLQkJYXNzZXJ0RXF1YWxzKDEyLCBhLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGEsIG51bGwpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgdGhpcy5vbmUpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgdGhpcy50d28pKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoYSwgdGhpcy50aHJlZSkpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhhLCB0aGlzLmZvdXIpKTsKLQkJYXNzZXJ0VHJ1ZShhWzExXSA9PSBudWxsKTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgdGVzdFRvU3RyaW5nKCkgewotCQlTdHJpbmcgcyA9IHRoaXMuYmFnLnRvU3RyaW5nKCk7Ci0JCWFzc2VydFRydWUocy5zdGFydHNXaXRoKCJbIikpOwotCQlhc3NlcnRUcnVlKHMuZW5kc1dpdGgoIl0iKSk7Ci0JCWludCBjb21tYUNvdW50ID0gMDsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBzLmxlbmd0aCgpOyBpKyspIHsKLQkJCWlmIChzLmNoYXJBdChpKSA9PSAnLCcpIHsKLQkJCQljb21tYUNvdW50Kys7Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKCJpbnZhbGlkIG51bWJlciBvZiBjb21tYXMiLCAxMCwgY29tbWFDb3VudCk7Ci0JCWFzc2VydFRydWUocy5pbmRleE9mKCJvbmUiKSAhPSAtMSk7Ci0JCWFzc2VydFRydWUocy5pbmRleE9mKCJ0d28iKSAhPSAtMSk7Ci0JCWFzc2VydFRydWUocy5pbmRleE9mKCJ0aHJlZSIpICE9IC0xKTsKLQkJYXNzZXJ0VHJ1ZShzLmluZGV4T2YoImZvdXIiKSAhPSAtMSk7Ci0JCWFzc2VydFRydWUocy5pbmRleE9mKCJudWxsIikgIT0gLTEpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9JbmRlbnRpbmdQcmludFdyaXRlclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0luZGVudGluZ1ByaW50V3JpdGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYjk3MTg5NS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0luZGVudGluZ1ByaW50V3JpdGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEwNyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsOwotCi1pbXBvcnQgamF2YS5pby5TdHJpbmdXcml0ZXI7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkluZGVudGluZ1ByaW50V3JpdGVyOwotCi1wdWJsaWMgY2xhc3MgSW5kZW50aW5nUHJpbnRXcml0ZXJUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlTdHJpbmdXcml0ZXIgc3cxOwotCVN0cmluZ1dyaXRlciBzdzI7Ci0JSW5kZW50aW5nUHJpbnRXcml0ZXIgaXB3MTsKLQlJbmRlbnRpbmdQcmludFdyaXRlciBpcHcyOwotCi0Jc3RhdGljIGZpbmFsIFN0cmluZyBDUiA9IFN5c3RlbS5nZXRQcm9wZXJ0eSgibGluZS5zZXBhcmF0b3IiKTsKLQotCXB1YmxpYyBJbmRlbnRpbmdQcmludFdyaXRlclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMuc3cxID0gbmV3IFN0cmluZ1dyaXRlcigpOwotCQl0aGlzLmlwdzEgPSBuZXcgSW5kZW50aW5nUHJpbnRXcml0ZXIodGhpcy5zdzEpOwotCQl0aGlzLnN3MiA9IG5ldyBTdHJpbmdXcml0ZXIoKTsKLQkJdGhpcy5pcHcyID0gbmV3IEluZGVudGluZ1ByaW50V3JpdGVyKHRoaXMuc3cyLCAiICAgICIpOyAvLyBpbmRlbnQgd2l0aCA0IHNwYWNlcyBpbnN0ZWFkIG9mIGEgdGFiCi0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbmRlbnQoKSB7Ci0JCWFzc2VydEVxdWFscygid3JvbmcgaW5kZW50IGxldmVsIiwgMCwgdGhpcy5pcHcxLmluZGVudExldmVsKCkpOwotCQl0aGlzLmlwdzEuaW5kZW50KCk7Ci0JCWFzc2VydEVxdWFscygid3JvbmcgaW5kZW50IGxldmVsIiwgMSwgdGhpcy5pcHcxLmluZGVudExldmVsKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbmRlbnQoKSB7Ci0JCWFzc2VydEVxdWFscygid3JvbmcgaW5kZW50IGxldmVsIiwgMCwgdGhpcy5pcHcxLmluZGVudExldmVsKCkpOwotCQl0aGlzLmlwdzEuaW5kZW50KCk7Ci0JCWFzc2VydEVxdWFscygid3JvbmcgaW5kZW50IGxldmVsIiwgMSwgdGhpcy5pcHcxLmluZGVudExldmVsKCkpOwotCQl0aGlzLmlwdzEudW5kZW50KCk7Ci0JCWFzc2VydEVxdWFscygid3JvbmcgaW5kZW50IGxldmVsIiwgMCwgdGhpcy5pcHcxLmluZGVudExldmVsKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbmNyZW1lbnRJbmRlbnRMZXZlbCgpIHsKLQkJYXNzZXJ0RXF1YWxzKCJ3cm9uZyBpbmRlbnQgbGV2ZWwiLCAwLCB0aGlzLmlwdzEuaW5kZW50TGV2ZWwoKSk7Ci0JCXRoaXMuaXB3MS5pbmNyZW1lbnRJbmRlbnRMZXZlbCgpOwotCQlhc3NlcnRFcXVhbHMoIndyb25nIGluZGVudCBsZXZlbCIsIDEsIHRoaXMuaXB3MS5pbmRlbnRMZXZlbCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGVjcmVtZW50SW5kZW50TGV2ZWwoKSB7Ci0JCWFzc2VydEVxdWFscygid3JvbmcgaW5kZW50IGxldmVsIiwgMCwgdGhpcy5pcHcxLmluZGVudExldmVsKCkpOwotCQl0aGlzLmlwdzEuaW5jcmVtZW50SW5kZW50TGV2ZWwoKTsKLQkJYXNzZXJ0RXF1YWxzKCJ3cm9uZyBpbmRlbnQgbGV2ZWwiLCAxLCB0aGlzLmlwdzEuaW5kZW50TGV2ZWwoKSk7Ci0JCXRoaXMuaXB3MS5kZWNyZW1lbnRJbmRlbnRMZXZlbCgpOwotCQlhc3NlcnRFcXVhbHMoIndyb25nIGluZGVudCBsZXZlbCIsIDAsIHRoaXMuaXB3MS5pbmRlbnRMZXZlbCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UHJpbnRUYWIoKSB7Ci0JCVN0cmluZyBleHBlY3RlZCA9ICJmb28wIiArIENSICsgIlx0Zm9vMSIgKyBDUiArICJcdGZvbzEiICsgQ1IgKyAiXHRcdGZvbzIiICsgQ1IgKyAiXHRmb28xIiArIENSICsgIlx0Zm9vMSIgKyBDUiArICJmb28wIiArIENSOwotCi0JCXRoaXMuaXB3MS5wcmludGxuKCJmb28wIik7Ci0JCXRoaXMuaXB3MS5pbmRlbnQoKTsKLQkJdGhpcy5pcHcxLnByaW50bG4oImZvbzEiKTsKLQkJdGhpcy5pcHcxLnByaW50bG4oImZvbzEiKTsKLQkJdGhpcy5pcHcxLmluZGVudCgpOwotCQl0aGlzLmlwdzEucHJpbnRsbigiZm9vMiIpOwotCQl0aGlzLmlwdzEudW5kZW50KCk7Ci0JCXRoaXMuaXB3MS5wcmludGxuKCJmb28xIik7Ci0JCXRoaXMuaXB3MS5wcmludGxuKCJmb28xIik7Ci0JCXRoaXMuaXB3MS51bmRlbnQoKTsKLQkJdGhpcy5pcHcxLnByaW50bG4oImZvbzAiKTsKLQotCQlhc3NlcnRFcXVhbHMoImJvZ3VzIG91dHB1dCIsIGV4cGVjdGVkLCB0aGlzLnN3MS50b1N0cmluZygpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UHJpbnRTcGFjZXMoKSB7Ci0JCVN0cmluZyBleHBlY3RlZCA9ICJmb28wIiArIENSICsgIiAgICBmb28xIiArIENSICsgIiAgICBmb28xIiArIENSICsgIiAgICAgICAgZm9vMiIgKyBDUiArICIgICAgZm9vMSIgKyBDUiArICIgICAgZm9vMSIgKyBDUiArICJmb28wIiArIENSOwotCi0JCXRoaXMuaXB3Mi5wcmludGxuKCJmb28wIik7Ci0JCXRoaXMuaXB3Mi5pbmRlbnQoKTsKLQkJdGhpcy5pcHcyLnByaW50bG4oImZvbzEiKTsKLQkJdGhpcy5pcHcyLnByaW50bG4oImZvbzEiKTsKLQkJdGhpcy5pcHcyLmluZGVudCgpOwotCQl0aGlzLmlwdzIucHJpbnRsbigiZm9vMiIpOwotCQl0aGlzLmlwdzIudW5kZW50KCk7Ci0JCXRoaXMuaXB3Mi5wcmludGxuKCJmb28xIik7Ci0JCXRoaXMuaXB3Mi5wcmludGxuKCJmb28xIik7Ci0JCXRoaXMuaXB3Mi51bmRlbnQoKTsKLQkJdGhpcy5pcHcyLnByaW50bG4oImZvbzAiKTsKLQotCQlhc3NlcnRFcXVhbHMoImJvZ3VzIG91dHB1dCIsIGV4cGVjdGVkLCB0aGlzLnN3Mi50b1N0cmluZygpKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvSkRCQ1R5cGVUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9KREJDVHlwZVRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDA3ZGFkMTkuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9KREJDVHlwZVRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw2NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsOwotCi1pbXBvcnQgamF2YS5zcWwuVHlwZXM7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkpEQkNUeXBlOwotCi1wdWJsaWMgY2xhc3MgSkRCQ1R5cGVUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBKREJDVHlwZVRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RUeXBlc1NpemUoKSB7Ci0JCWFzc2VydEVxdWFscyhUeXBlcy5jbGFzcy5nZXREZWNsYXJlZEZpZWxkcygpLmxlbmd0aCwgSkRCQ1R5cGUudHlwZXMoKS5sZW5ndGgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROYW1lKCkgewotCQlKREJDVHlwZSBqZGJjVHlwZTsKLQkJamRiY1R5cGUgPSBKREJDVHlwZS50eXBlKFR5cGVzLlZBUkNIQVIpOwotCQlhc3NlcnRFcXVhbHMoIlZBUkNIQVIiLCBqZGJjVHlwZS5uYW1lKCkpOwotCi0JCWpkYmNUeXBlID0gSkRCQ1R5cGUudHlwZShUeXBlcy5JTlRFR0VSKTsKLQkJYXNzZXJ0RXF1YWxzKCJJTlRFR0VSIiwgamRiY1R5cGUubmFtZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29kZSgpIHsKLQkJSkRCQ1R5cGUgamRiY1R5cGU7Ci0JCWpkYmNUeXBlID0gSkRCQ1R5cGUudHlwZShUeXBlcy5WQVJDSEFSKTsKLQkJYXNzZXJ0RXF1YWxzKFR5cGVzLlZBUkNIQVIsIGpkYmNUeXBlLmNvZGUoKSk7Ci0KLQkJamRiY1R5cGUgPSBKREJDVHlwZS50eXBlKFR5cGVzLklOVEVHRVIpOwotCQlhc3NlcnRFcXVhbHMoVHlwZXMuSU5URUdFUiwgamRiY1R5cGUuY29kZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZFR5cGVDb2RlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCUpEQkNUeXBlIGpkYmNUeXBlID0gSkRCQ1R5cGUudHlwZSg1NSk7Ci0JCQlmYWlsKCJpbnZhbGlkIEpEQkNUeXBlOiAiICsgamRiY1R5cGUpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZFR5cGVOYW1lKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCUpEQkNUeXBlIGpkYmNUeXBlID0gSkRCQ1R5cGUudHlwZSgiVkFSQ0hBUjIiKTsKLQkJCWZhaWwoImludmFsaWQgSkRCQ1R5cGU6ICIgKyBqZGJjVHlwZSk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9KYXZhVHlwZVRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0phdmFUeXBlVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWRhMTk1Yi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0phdmFUeXBlVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI1MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsOwotCi1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LkphdmFUeXBlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlNpbXBsZUphdmFUeXBlOwotCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBKYXZhVHlwZVRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCi0JcHVibGljIEphdmFUeXBlVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEludmFsaWRFbGVtZW50VHlwZU51bGwoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJSmF2YVR5cGUgamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUobnVsbCwgMCk7Ci0JCQlmYWlsKCJpbnZhbGlkIEphdmFUeXBlOiAiICsgamF2YVR5cGUpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZEVsZW1lbnRUeXBlRW1wdHkoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJSmF2YVR5cGUgamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoIiIsIDApOwotCQkJZmFpbCgiaW52YWxpZCBKYXZhVHlwZTogIiArIGphdmFUeXBlKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEludmFsaWRFbGVtZW50VHlwZUFycmF5KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCUphdmFUeXBlIGphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEubGFuZy5PYmplY3RbXS5jbGFzcy5nZXROYW1lKCksIDApOwotCQkJZmFpbCgiaW52YWxpZCBKYXZhVHlwZTogIiArIGphdmFUeXBlKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEludmFsaWRBcnJheURlcHRoTmVnYXRpdmUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJSmF2YVR5cGUgamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoamF2YS5sYW5nLk9iamVjdC5jbGFzcy5nZXROYW1lKCksIC0yKTsKLQkJCWZhaWwoImludmFsaWQgSmF2YVR5cGU6ICIgKyBqYXZhVHlwZSk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbnZhbGlkVm9pZEFycmF5KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCUphdmFUeXBlIGphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKHZvaWQuY2xhc3MuZ2V0TmFtZSgpLCAyKTsKLQkJCWZhaWwoImludmFsaWQgSmF2YVR5cGU6ICIgKyBqYXZhVHlwZSk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RFbGVtZW50VHlwZU5hbWUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJSmF2YVR5cGUgamF2YVR5cGU7Ci0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEubGFuZy5PYmplY3QuY2xhc3MpOwotCQlhc3NlcnRFcXVhbHMoImphdmEubGFuZy5PYmplY3QiLCBqYXZhVHlwZS5nZXRFbGVtZW50VHlwZU5hbWUoKSk7Ci0KLQkJamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoamF2YS5sYW5nLk9iamVjdFtdLmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKCJqYXZhLmxhbmcuT2JqZWN0IiwgamF2YVR5cGUuZ2V0RWxlbWVudFR5cGVOYW1lKCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGludC5jbGFzcyk7Ci0JCWFzc2VydEVxdWFscygiaW50IiwgamF2YVR5cGUuZ2V0RWxlbWVudFR5cGVOYW1lKCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGludFtdLmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKCJpbnQiLCBqYXZhVHlwZS5nZXRFbGVtZW50VHlwZU5hbWUoKSk7Ci0KLQkJamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUodm9pZC5jbGFzcyk7Ci0JCWFzc2VydEVxdWFscygidm9pZCIsIGphdmFUeXBlLmdldEVsZW1lbnRUeXBlTmFtZSgpKTsKLQotCQlqYXZhVHlwZSA9IG5ldyBTaW1wbGVKYXZhVHlwZShqYXZhLnV0aWwuTWFwLkVudHJ5LmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKCJqYXZhLnV0aWwuTWFwJEVudHJ5IiwgamF2YVR5cGUuZ2V0RWxlbWVudFR5cGVOYW1lKCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEudXRpbC5NYXAuRW50cnlbXVtdLmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKCJqYXZhLnV0aWwuTWFwJEVudHJ5IiwgamF2YVR5cGUuZ2V0RWxlbWVudFR5cGVOYW1lKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBcnJheURlcHRoKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCUphdmFUeXBlIGphdmFUeXBlOwotCQlqYXZhVHlwZSA9IG5ldyBTaW1wbGVKYXZhVHlwZShqYXZhLmxhbmcuT2JqZWN0LmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGphdmFUeXBlLmdldEFycmF5RGVwdGgoKSk7Ci0KLQkJamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoamF2YS5sYW5nLk9iamVjdFtdLmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIGphdmFUeXBlLmdldEFycmF5RGVwdGgoKSk7Ci0KLQkJamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoaW50LmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGphdmFUeXBlLmdldEFycmF5RGVwdGgoKSk7Ci0KLQkJamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoaW50W10uY2xhc3MpOwotCQlhc3NlcnRFcXVhbHMoMSwgamF2YVR5cGUuZ2V0QXJyYXlEZXB0aCgpKTsKLQotCQlqYXZhVHlwZSA9IG5ldyBTaW1wbGVKYXZhVHlwZSh2b2lkLmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGphdmFUeXBlLmdldEFycmF5RGVwdGgoKSk7Ci0KLQkJamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoamF2YS51dGlsLk1hcC5FbnRyeS5jbGFzcyk7Ci0JCWFzc2VydEVxdWFscygwLCBqYXZhVHlwZS5nZXRBcnJheURlcHRoKCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEudXRpbC5NYXAuRW50cnlbXVtdLmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGphdmFUeXBlLmdldEFycmF5RGVwdGgoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdElzQXJyYXkoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJSmF2YVR5cGUgamF2YVR5cGU7Ci0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEubGFuZy5PYmplY3QuY2xhc3MpOwotCQlhc3NlcnRGYWxzZShqYXZhVHlwZS5pc0FycmF5KCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEubGFuZy5PYmplY3RbXS5jbGFzcyk7Ci0JCWFzc2VydFRydWUoamF2YVR5cGUuaXNBcnJheSgpKTsKLQotCQlqYXZhVHlwZSA9IG5ldyBTaW1wbGVKYXZhVHlwZShpbnQuY2xhc3MpOwotCQlhc3NlcnRGYWxzZShqYXZhVHlwZS5pc0FycmF5KCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGludFtdLmNsYXNzKTsKLQkJYXNzZXJ0VHJ1ZShqYXZhVHlwZS5pc0FycmF5KCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKHZvaWQuY2xhc3MpOwotCQlhc3NlcnRGYWxzZShqYXZhVHlwZS5pc0FycmF5KCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEudXRpbC5NYXAuRW50cnkuY2xhc3MpOwotCQlhc3NlcnRGYWxzZShqYXZhVHlwZS5pc0FycmF5KCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEudXRpbC5NYXAuRW50cnlbXVtdLmNsYXNzKTsKLQkJYXNzZXJ0VHJ1ZShqYXZhVHlwZS5pc0FycmF5KCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RKYXZhQ2xhc3MoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy52ZXJpZnlKYXZhQ2xhc3MoamF2YS5sYW5nLk9iamVjdC5jbGFzcyk7Ci0JCXRoaXMudmVyaWZ5SmF2YUNsYXNzKGphdmEubGFuZy5PYmplY3RbXS5jbGFzcyk7Ci0JCXRoaXMudmVyaWZ5SmF2YUNsYXNzKGludC5jbGFzcyk7Ci0JCXRoaXMudmVyaWZ5SmF2YUNsYXNzKGludFtdLmNsYXNzKTsKLQkJdGhpcy52ZXJpZnlKYXZhQ2xhc3Modm9pZC5jbGFzcyk7Ci0JCXRoaXMudmVyaWZ5SmF2YUNsYXNzKGphdmEudXRpbC5NYXAuRW50cnkuY2xhc3MpOwotCQl0aGlzLnZlcmlmeUphdmFDbGFzcyhqYXZhLnV0aWwuTWFwLkVudHJ5W11bXS5jbGFzcyk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUphdmFDbGFzcyhDbGFzczw/PiBqYXZhQ2xhc3MpIHRocm93cyBFeGNlcHRpb24gewotCQlKYXZhVHlwZSBqYXZhVHlwZSA9IG5ldyBTaW1wbGVKYXZhVHlwZShqYXZhQ2xhc3MpOwotCQlhc3NlcnRFcXVhbHMoamF2YUNsYXNzLCBqYXZhVHlwZS5nZXRKYXZhQ2xhc3MoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEphdmFDbGFzc05hbWUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJSmF2YVR5cGUgamF2YVR5cGU7Ci0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEubGFuZy5PYmplY3QuY2xhc3MpOwotCQlhc3NlcnRFcXVhbHMoImphdmEubGFuZy5PYmplY3QiLCBqYXZhVHlwZS5nZXRKYXZhQ2xhc3NOYW1lKCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEubGFuZy5PYmplY3RbXS5jbGFzcyk7Ci0JCWFzc2VydEVxdWFscygiW0xqYXZhLmxhbmcuT2JqZWN0OyIsIGphdmFUeXBlLmdldEphdmFDbGFzc05hbWUoKSk7Ci0KLQkJamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoaW50LmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKCJpbnQiLCBqYXZhVHlwZS5nZXRKYXZhQ2xhc3NOYW1lKCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGludFtdLmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKCJbSSIsIGphdmFUeXBlLmdldEphdmFDbGFzc05hbWUoKSk7Ci0KLQkJamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUodm9pZC5jbGFzcyk7Ci0JCWFzc2VydEVxdWFscygidm9pZCIsIGphdmFUeXBlLmdldEphdmFDbGFzc05hbWUoKSk7Ci0KLQkJamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoamF2YS51dGlsLk1hcC5FbnRyeS5jbGFzcyk7Ci0JCWFzc2VydEVxdWFscygiamF2YS51dGlsLk1hcCRFbnRyeSIsIGphdmFUeXBlLmdldEphdmFDbGFzc05hbWUoKSk7Ci0KLQkJamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoamF2YS51dGlsLk1hcC5FbnRyeVtdW10uY2xhc3MpOwotCQlhc3NlcnRFcXVhbHMoIltbTGphdmEudXRpbC5NYXAkRW50cnk7IiwgamF2YVR5cGUuZ2V0SmF2YUNsYXNzTmFtZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGVzY3JpYmVzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMudmVyaWZ5RGVzY3JpYmVzKGphdmEubGFuZy5PYmplY3QuY2xhc3MpOwotCQl0aGlzLnZlcmlmeURlc2NyaWJlcyhqYXZhLmxhbmcuT2JqZWN0W10uY2xhc3MpOwotCQl0aGlzLnZlcmlmeURlc2NyaWJlcyhpbnQuY2xhc3MpOwotCQl0aGlzLnZlcmlmeURlc2NyaWJlcyhpbnRbXS5jbGFzcyk7Ci0JCXRoaXMudmVyaWZ5RGVzY3JpYmVzKHZvaWQuY2xhc3MpOwotCQl0aGlzLnZlcmlmeURlc2NyaWJlcyhqYXZhLnV0aWwuTWFwLkVudHJ5LmNsYXNzKTsKLQkJdGhpcy52ZXJpZnlEZXNjcmliZXMoamF2YS51dGlsLk1hcC5FbnRyeVtdW10uY2xhc3MpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlEZXNjcmliZXMoQ2xhc3M8Pz4gamF2YUNsYXNzKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJSmF2YVR5cGUgamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoamF2YUNsYXNzKTsKLQkJYXNzZXJ0VHJ1ZShqYXZhVHlwZS5kZXNjcmliZXMoamF2YUNsYXNzKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdERlY2xhcmF0aW9uKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCUphdmFUeXBlIGphdmFUeXBlOwotCQlqYXZhVHlwZSA9IG5ldyBTaW1wbGVKYXZhVHlwZShqYXZhLmxhbmcuT2JqZWN0LmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKCJqYXZhLmxhbmcuT2JqZWN0IiwgamF2YVR5cGUuZGVjbGFyYXRpb24oKSk7Ci0KLQkJamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoamF2YS5sYW5nLk9iamVjdFtdLmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKCJqYXZhLmxhbmcuT2JqZWN0W10iLCBqYXZhVHlwZS5kZWNsYXJhdGlvbigpKTsKLQotCQlqYXZhVHlwZSA9IG5ldyBTaW1wbGVKYXZhVHlwZShpbnQuY2xhc3MpOwotCQlhc3NlcnRFcXVhbHMoImludCIsIGphdmFUeXBlLmRlY2xhcmF0aW9uKCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGludFtdLmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKCJpbnRbXSIsIGphdmFUeXBlLmRlY2xhcmF0aW9uKCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKHZvaWQuY2xhc3MpOwotCQlhc3NlcnRFcXVhbHMoInZvaWQiLCBqYXZhVHlwZS5kZWNsYXJhdGlvbigpKTsKLQotCQlqYXZhVHlwZSA9IG5ldyBTaW1wbGVKYXZhVHlwZShqYXZhLnV0aWwuTWFwLkVudHJ5LmNsYXNzKTsKLQkJYXNzZXJ0RXF1YWxzKCJqYXZhLnV0aWwuTWFwLkVudHJ5IiwgamF2YVR5cGUuZGVjbGFyYXRpb24oKSk7Ci0KLQkJamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoamF2YS51dGlsLk1hcC5FbnRyeVtdW10uY2xhc3MpOwotCQlhc3NlcnRFcXVhbHMoImphdmEudXRpbC5NYXAuRW50cnlbXVtdIiwgamF2YVR5cGUuZGVjbGFyYXRpb24oKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdElzUHJpbWl0aXZlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCUphdmFUeXBlIGphdmFUeXBlOwotCQlqYXZhVHlwZSA9IG5ldyBTaW1wbGVKYXZhVHlwZShqYXZhLmxhbmcuT2JqZWN0LmNsYXNzKTsKLQkJYXNzZXJ0RmFsc2UoamF2YVR5cGUuaXNQcmltaXRpdmUoKSk7Ci0KLQkJamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoamF2YS5sYW5nLk9iamVjdFtdLmNsYXNzKTsKLQkJYXNzZXJ0RmFsc2UoamF2YVR5cGUuaXNQcmltaXRpdmUoKSk7Ci0KLQkJamF2YVR5cGUgPSBuZXcgU2ltcGxlSmF2YVR5cGUoaW50LmNsYXNzKTsKLQkJYXNzZXJ0VHJ1ZShqYXZhVHlwZS5pc1ByaW1pdGl2ZSgpKTsKLQotCQlqYXZhVHlwZSA9IG5ldyBTaW1wbGVKYXZhVHlwZShpbnRbXS5jbGFzcyk7Ci0JCWFzc2VydEZhbHNlKGphdmFUeXBlLmlzUHJpbWl0aXZlKCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKHZvaWQuY2xhc3MpOwotCQlhc3NlcnRUcnVlKGphdmFUeXBlLmlzUHJpbWl0aXZlKCkpOwotCi0JCWphdmFUeXBlID0gbmV3IFNpbXBsZUphdmFUeXBlKGphdmEudXRpbC5NYXAuRW50cnkuY2xhc3MpOwotCQlhc3NlcnRGYWxzZShqYXZhVHlwZS5pc1ByaW1pdGl2ZSgpKTsKLQotCQlqYXZhVHlwZSA9IG5ldyBTaW1wbGVKYXZhVHlwZShqYXZhLnV0aWwuTWFwLkVudHJ5W11bXS5jbGFzcyk7Ci0JCWFzc2VydEZhbHNlKGphdmFUeXBlLmlzUHJpbWl0aXZlKCkpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9KcHRVdGlsaXR5VGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvSnB0VXRpbGl0eVRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDk1NmZmYmUuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9KcHRVdGlsaXR5VGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDY3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWw7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdFN1aXRlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLml0ZXJhdG9ycy5KcHRVdGlsaXR5SXRlcmF0b3JzVGVzdHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwuSnB0VXRpbGl0eU1vZGVsVGVzdHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubm9kZS5KcHRVdGlsaXR5Tm9kZVRlc3RzOwotCi0vKioKLSAqIGRlY2VudHJhbGl6ZSB0ZXN0IGNyZWF0aW9uIGNvZGUKLSAqLwotcHVibGljIGNsYXNzIEpwdFV0aWxpdHlUZXN0cyB7Ci0KLQlwdWJsaWMgc3RhdGljIFRlc3Qgc3VpdGUoKSB7Ci0JCVRlc3RTdWl0ZSBzdWl0ZSA9IG5ldyBUZXN0U3VpdGUoSnB0VXRpbGl0eVRlc3RzLmNsYXNzLmdldFBhY2thZ2UoKS5nZXROYW1lKCkpOwotCi0JCXN1aXRlLmFkZFRlc3QoSnB0VXRpbGl0eUl0ZXJhdG9yc1Rlc3RzLnN1aXRlKCkpOwotCQlzdWl0ZS5hZGRUZXN0KEpwdFV0aWxpdHlNb2RlbFRlc3RzLnN1aXRlKCkpOwotCQlzdWl0ZS5hZGRUZXN0KEpwdFV0aWxpdHlOb2RlVGVzdHMuc3VpdGUoKSk7Ci0KLQkJc3VpdGUuYWRkVGVzdFN1aXRlKEJpdFRvb2xzVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoQm9vbGVhbkhvbGRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKENsYXNzcGF0aFRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKENsYXNzVG9vbHNUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShDb2xsZWN0aW9uVG9vbHNUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShDb21tYW5kRXhlY3V0b3JUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShDb21tYW5kVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoQ291bnRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKEVtcHR5SXRlcmFibGVUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShGaWxlVG9vbHNUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShGaWx0ZXJUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShIYXNoQmFnVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoSWRlbnRpdHlIYXNoQmFnVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoSW5kZW50aW5nUHJpbnRXcml0ZXJUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShKYXZhVHlwZVRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKEpEQkNUeXBlVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoTGlzdGVuZXJMaXN0VGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoTWV0aG9kU2lnbmF0dXJlVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoTmFtZVRvb2xzVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoUmFuZ2VUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShSZXZlcnNlQ29tcGFyYXRvclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFNpbXBsZUFzc29jaWF0aW9uVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoU2ltcGxlU3RhY2tUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShTdHJpbmdUb29sc1Rlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFN5bmNocm9uaXplZEJvb2xlYW5UZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShTeW5jaHJvbml6ZWRPYmplY3RUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShTeW5jaHJvbml6ZWRTdGFja1Rlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFhNTFN0cmluZ0VuY29kZXJUZXN0cy5jbGFzcyk7Ci0KLQkJcmV0dXJuIHN1aXRlOwotCX0KLQotCXByaXZhdGUgSnB0VXRpbGl0eVRlc3RzKCkgewotCQlzdXBlcigpOwotCQl0aHJvdyBuZXcgVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvTGlzdGVuZXJMaXN0VGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvTGlzdGVuZXJMaXN0VGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjQxNmY2My4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL0xpc3RlbmVyTGlzdFRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNzkgKzAsMCBAQAotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uU2VyaWFsaXphYmxlOwotaW1wb3J0IGphdmEudXRpbC5FdmVudExpc3RlbmVyOwotCi1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkxpc3RlbmVyTGlzdDsKLQotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgY2xhc3MgTGlzdGVuZXJMaXN0VGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQlwdWJsaWMgTGlzdGVuZXJMaXN0VGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEdldExpc3RlbmVycygpIHRocm93cyBFeGNlcHRpb24gewotCQlMaXN0ZW5lckxpc3Q8TGlzdGVuZXI+IGxpc3RlbmVyTGlzdCA9IG5ldyBMaXN0ZW5lckxpc3Q8TGlzdGVuZXI+KExpc3RlbmVyLmNsYXNzKTsKLQkJTGlzdGVuZXIgbGlzdGVuZXIxID0gbmV3IExvY2FsTGlzdGVuZXIoKTsKLQkJTGlzdGVuZXIgbGlzdGVuZXIyID0gbmV3IExvY2FsTGlzdGVuZXIoKTsKLQkJTGlzdGVuZXJbXSBsaXN0ZW5lcnMgPSBsaXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJzKCk7Ci0JCWFzc2VydEVxdWFscygwLCBsaXN0ZW5lcnMubGVuZ3RoKTsKLQotCQlsaXN0ZW5lckxpc3QuYWRkKGxpc3RlbmVyMSk7Ci0JCWxpc3RlbmVyTGlzdC5hZGQobGlzdGVuZXIyKTsKLQkJbGlzdGVuZXJzID0gbGlzdGVuZXJMaXN0LmdldExpc3RlbmVycygpOwotCQlhc3NlcnRFcXVhbHMoMiwgbGlzdGVuZXJzLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGxpc3RlbmVycywgbGlzdGVuZXIxKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGxpc3RlbmVycywgbGlzdGVuZXIyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNpemUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJTGlzdGVuZXJMaXN0PExpc3RlbmVyPiBsaXN0ZW5lckxpc3QgPSBuZXcgTGlzdGVuZXJMaXN0PExpc3RlbmVyPihMaXN0ZW5lci5jbGFzcyk7Ci0JCUxpc3RlbmVyIGxpc3RlbmVyMSA9IG5ldyBMb2NhbExpc3RlbmVyKCk7Ci0JCUxpc3RlbmVyIGxpc3RlbmVyMiA9IG5ldyBMb2NhbExpc3RlbmVyKCk7Ci0JCWFzc2VydEVxdWFscygwLCBsaXN0ZW5lckxpc3Quc2l6ZSgpKTsKLQotCQlsaXN0ZW5lckxpc3QuYWRkKGxpc3RlbmVyMSk7Ci0JCWxpc3RlbmVyTGlzdC5hZGQobGlzdGVuZXIyKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIGxpc3RlbmVyTGlzdC5zaXplKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJc0VtcHR5KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCUxpc3RlbmVyTGlzdDxMaXN0ZW5lcj4gbGlzdGVuZXJMaXN0ID0gbmV3IExpc3RlbmVyTGlzdDxMaXN0ZW5lcj4oTGlzdGVuZXIuY2xhc3MpOwotCQlMaXN0ZW5lciBsaXN0ZW5lcjEgPSBuZXcgTG9jYWxMaXN0ZW5lcigpOwotCQlMaXN0ZW5lciBsaXN0ZW5lcjIgPSBuZXcgTG9jYWxMaXN0ZW5lcigpOwotCQlhc3NlcnRUcnVlKGxpc3RlbmVyTGlzdC5pc0VtcHR5KCkpOwotCi0JCWxpc3RlbmVyTGlzdC5hZGQobGlzdGVuZXIxKTsKLQkJbGlzdGVuZXJMaXN0LmFkZChsaXN0ZW5lcjIpOwotCQlhc3NlcnRGYWxzZShsaXN0ZW5lckxpc3QuaXNFbXB0eSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkX251bGwoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJTGlzdGVuZXJMaXN0PExpc3RlbmVyPiBsaXN0ZW5lckxpc3QgPSBuZXcgTGlzdGVuZXJMaXN0PExpc3RlbmVyPihMaXN0ZW5lci5jbGFzcyk7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCWxpc3RlbmVyTGlzdC5hZGQobnVsbCk7Ci0JCQlmYWlsKCJpbnZhbGlkIGxpc3RlbmVyIGxpc3Q6ICIgKyBsaXN0ZW5lckxpc3QpOwotCQl9IGNhdGNoIChOdWxsUG9pbnRlckV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotLy9UT0RPIGZpeCBidWcgMjUyMDY2IGFuZCB0aGVuIHVuY29tbWVudCB0aGlzCi0vLwlwdWJsaWMgdm9pZCB0ZXN0QWRkX2R1cGxpY2F0ZSgpIHRocm93cyBFeGNlcHRpb24gewotLy8JCUxpc3RlbmVyTGlzdDxMaXN0ZW5lcj4gbGlzdGVuZXJMaXN0ID0gbmV3IExpc3RlbmVyTGlzdDxMaXN0ZW5lcj4oTGlzdGVuZXIuY2xhc3MpOwotLy8JCUxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IExvY2FsTGlzdGVuZXIoKTsKLS8vCQlsaXN0ZW5lckxpc3QuYWRkKGxpc3RlbmVyKTsKLS8vCi0vLwkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotLy8JCXRyeSB7Ci0vLwkJCWxpc3RlbmVyTGlzdC5hZGQobGlzdGVuZXIpOwotLy8JCQlmYWlsKCJpbnZhbGlkIGxpc3RlbmVyIGxpc3Q6ICIgKyBsaXN0ZW5lckxpc3QpOwotLy8JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotLy8JCQlleENhdWdodCA9IHRydWU7Ci0vLwkJfQotLy8JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotLy8JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZSgpIHRocm93cyBFeGNlcHRpb24gewotCQlMaXN0ZW5lckxpc3Q8TGlzdGVuZXI+IGxpc3RlbmVyTGlzdCA9IG5ldyBMaXN0ZW5lckxpc3Q8TGlzdGVuZXI+KExpc3RlbmVyLmNsYXNzKTsKLQkJTGlzdGVuZXIgbGlzdGVuZXIxID0gbmV3IExvY2FsTGlzdGVuZXIoKTsKLQkJTGlzdGVuZXIgbGlzdGVuZXIyID0gbmV3IExvY2FsTGlzdGVuZXIoKTsKLQkJbGlzdGVuZXJMaXN0LmFkZChsaXN0ZW5lcjEpOwotCQlsaXN0ZW5lckxpc3QuYWRkKGxpc3RlbmVyMik7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGxpc3RlbmVyTGlzdC5nZXRMaXN0ZW5lcnMoKSwgbGlzdGVuZXIxKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGxpc3RlbmVyTGlzdC5nZXRMaXN0ZW5lcnMoKSwgbGlzdGVuZXIyKSk7Ci0KLQkJbGlzdGVuZXJMaXN0LnJlbW92ZShsaXN0ZW5lcjEpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMobGlzdGVuZXJMaXN0LmdldExpc3RlbmVycygpLCBsaXN0ZW5lcjEpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMobGlzdGVuZXJMaXN0LmdldExpc3RlbmVycygpLCBsaXN0ZW5lcjIpKTsKLQotCQlsaXN0ZW5lckxpc3QucmVtb3ZlKGxpc3RlbmVyMik7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhsaXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJzKCksIGxpc3RlbmVyMikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVfbnVsbCgpIHRocm93cyBFeGNlcHRpb24gewotCQlMaXN0ZW5lckxpc3Q8TGlzdGVuZXI+IGxpc3RlbmVyTGlzdCA9IG5ldyBMaXN0ZW5lckxpc3Q8TGlzdGVuZXI+KExpc3RlbmVyLmNsYXNzKTsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJbGlzdGVuZXJMaXN0LnJlbW92ZShudWxsKTsKLQkJCWZhaWwoImludmFsaWQgbGlzdGVuZXIgbGlzdDogIiArIGxpc3RlbmVyTGlzdCk7Ci0JCX0gY2F0Y2ggKE51bGxQb2ludGVyRXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotLy9UT0RPIGZpeCBidWcgMjUyMDY2IGFuZCB0aGVuIHVuY29tbWVudCB0aGlzCi0vLwlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlX3VucmVnaXN0ZXJlZCgpIHRocm93cyBFeGNlcHRpb24gewotLy8JCUxpc3RlbmVyTGlzdDxMaXN0ZW5lcj4gbGlzdGVuZXJMaXN0ID0gbmV3IExpc3RlbmVyTGlzdDxMaXN0ZW5lcj4oTGlzdGVuZXIuY2xhc3MpOwotLy8JCUxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IExvY2FsTGlzdGVuZXIoKTsKLS8vCQlsaXN0ZW5lckxpc3QuYWRkKGxpc3RlbmVyKTsKLS8vCQlsaXN0ZW5lckxpc3QucmVtb3ZlKGxpc3RlbmVyKTsKLS8vCi0vLwkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotLy8JCXRyeSB7Ci0vLwkJCWxpc3RlbmVyTGlzdC5yZW1vdmUobGlzdGVuZXIpOwotLy8JCQlmYWlsKCJpbnZhbGlkIGxpc3RlbmVyIGxpc3Q6ICIgKyBsaXN0ZW5lckxpc3QpOwotLy8JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotLy8JCQlleENhdWdodCA9IHRydWU7Ci0vLwkJfQotLy8JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotLy8JfQotCi0JcHVibGljIHZvaWQgdGVzdENsZWFyKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCUxpc3RlbmVyTGlzdDxMaXN0ZW5lcj4gbGlzdGVuZXJMaXN0ID0gbmV3IExpc3RlbmVyTGlzdDxMaXN0ZW5lcj4oTGlzdGVuZXIuY2xhc3MpOwotCQlMaXN0ZW5lciBsaXN0ZW5lcjEgPSBuZXcgTG9jYWxMaXN0ZW5lcigpOwotCQlMaXN0ZW5lciBsaXN0ZW5lcjIgPSBuZXcgTG9jYWxMaXN0ZW5lcigpOwotCQlsaXN0ZW5lckxpc3QuYWRkKGxpc3RlbmVyMSk7Ci0JCWxpc3RlbmVyTGlzdC5hZGQobGlzdGVuZXIyKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMobGlzdGVuZXJMaXN0LmdldExpc3RlbmVycygpLCBsaXN0ZW5lcjEpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMobGlzdGVuZXJMaXN0LmdldExpc3RlbmVycygpLCBsaXN0ZW5lcjIpKTsKLQotCQlsaXN0ZW5lckxpc3QuY2xlYXIoKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKGxpc3RlbmVyTGlzdC5nZXRMaXN0ZW5lcnMoKSwgbGlzdGVuZXIxKSk7Ci0JCWFzc2VydEZhbHNlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyhsaXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJzKCksIGxpc3RlbmVyMikpOwotCX0KLQotLy9UT0RPIC0gVGhpcyB0ZXN0IGRvZXNuJ3QgcGFzcyBpbiB0aGUgRWNsaXBzZSBidWlsZCBlbnZpcm9ubWVudCAoTGludXgpIGZvciBzb21lIHJlYXNvbgotLy8JcHVibGljIHZvaWQgdGVzdFNlcmlhbGl6YXRpb24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLS8vCQlMaXN0ZW5lckxpc3Q8TGlzdGVuZXI+IGxpc3RlbmVyTGlzdCA9IG5ldyBMaXN0ZW5lckxpc3Q8TGlzdGVuZXI+KExpc3RlbmVyLmNsYXNzKTsKLS8vCQlMaXN0ZW5lciBsaXN0ZW5lcjEgPSBuZXcgTG9jYWxMaXN0ZW5lcigpOwotLy8JCUxpc3RlbmVyIGxpc3RlbmVyMiA9IG5ldyBMb2NhbExpc3RlbmVyKCk7Ci0vLwkJbGlzdGVuZXJMaXN0LmFkZChsaXN0ZW5lcjEpOwotLy8JCWxpc3RlbmVyTGlzdC5hZGQobGlzdGVuZXIyKTsKLS8vCi0vLwkJTGlzdGVuZXJMaXN0PExpc3RlbmVyPiBsaXN0ZW5lckxpc3QyID0gVGVzdFRvb2xzLnNlcmlhbGl6ZShsaXN0ZW5lckxpc3QpOwotLy8JCWFzc2VydE5vdFNhbWUobGlzdGVuZXJMaXN0LCBsaXN0ZW5lckxpc3QyKTsKLS8vCQlhc3NlcnRFcXVhbHMoMiwgbGlzdGVuZXJMaXN0Mi5zaXplKCkpOwotLy8KLS8vCQlMaXN0ZW5lciBsaXN0ZW5lcjMgPSBuZXcgTm9uU2VyaWFsaXphYmxlTGlzdGVuZXIoKTsKLS8vCQlsaXN0ZW5lckxpc3QuYWRkKGxpc3RlbmVyMyk7Ci0vLwotLy8JCWxpc3RlbmVyTGlzdDIgPSBUZXN0VG9vbHMuc2VyaWFsaXplKGxpc3RlbmVyTGlzdCk7Ci0vLwkJYXNzZXJ0Tm90U2FtZShsaXN0ZW5lckxpc3QsIGxpc3RlbmVyTGlzdDIpOwotLy8JCWFzc2VydEVxdWFscygyLCBsaXN0ZW5lckxpc3QyLnNpemUoKSk7Ci0vLwotLy8JfQotCi0JaW50ZXJmYWNlIExpc3RlbmVyIGV4dGVuZHMgRXZlbnRMaXN0ZW5lciB7Ci0JCXZvaWQgc29tZXRoaW5nSGFwcGVuZWQoKTsKLQl9Ci0JCi0Jc3RhdGljIGNsYXNzIExvY2FsTGlzdGVuZXIgaW1wbGVtZW50cyBMaXN0ZW5lciwgU2VyaWFsaXphYmxlIHsKLQkJcHVibGljIHZvaWQgc29tZXRoaW5nSGFwcGVuZWQoKSB7Ci0JCQkvLyBkbyBub3RoaW5nCi0JCX0KLQl9Ci0JCi0Jc3RhdGljIGNsYXNzIE5vblNlcmlhbGl6YWJsZUxpc3RlbmVyIGltcGxlbWVudHMgTGlzdGVuZXIgewotCQlwdWJsaWMgdm9pZCBzb21ldGhpbmdIYXBwZW5lZCgpIHsKLQkJCS8vIGRvIG5vdGhpbmcKLQkJfQotCX0KLQkKLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvTWV0aG9kU2lnbmF0dXJlVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvTWV0aG9kU2lnbmF0dXJlVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYjQ0ZjNhNC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL01ldGhvZFNpZ25hdHVyZVRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyMzYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEubGFuZy5yZWZsZWN0Lk1ldGhvZDsKLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlzOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5KYXZhVHlwZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5NZXRob2RTaWduYXR1cmU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU2ltcGxlSmF2YVR5cGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU2ltcGxlTWV0aG9kU2lnbmF0dXJlOwotCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBNZXRob2RTaWduYXR1cmVUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBNZXRob2RTaWduYXR1cmVUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZE5hbWVOdWxsKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCU1ldGhvZFNpZ25hdHVyZSBtZXRob2RTaWduYXR1cmUgPSBuZXcgU2ltcGxlTWV0aG9kU2lnbmF0dXJlKChTdHJpbmcpIG51bGwpOwotCQkJZmFpbCgiaW52YWxpZCBNZXRob2RTaWduYXR1cmU6ICIgKyBtZXRob2RTaWduYXR1cmUpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZE5hbWVFbXB0eSgpIHRocm93cyBFeGNlcHRpb24gewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlNZXRob2RTaWduYXR1cmUgbWV0aG9kU2lnbmF0dXJlID0gbmV3IFNpbXBsZU1ldGhvZFNpZ25hdHVyZSgiIik7Ci0JCQlmYWlsKCJpbnZhbGlkIE1ldGhvZFNpZ25hdHVyZTogIiArIG1ldGhvZFNpZ25hdHVyZSk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbnZhbGlkUGFyYW1ldGVyVHlwZXNOdWxsKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCU1ldGhvZFNpZ25hdHVyZSBtZXRob2RTaWduYXR1cmUgPSBuZXcgU2ltcGxlTWV0aG9kU2lnbmF0dXJlKCJmb28iLCAoSmF2YVR5cGVbXSkgbnVsbCk7Ci0JCQlmYWlsKCJpbnZhbGlkIE1ldGhvZFNpZ25hdHVyZTogIiArIG1ldGhvZFNpZ25hdHVyZSk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbnZhbGlkUGFyYW1ldGVyVHlwZXNOdWxsSXRlbSgpIHRocm93cyBFeGNlcHRpb24gewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlNZXRob2RTaWduYXR1cmUgbWV0aG9kU2lnbmF0dXJlID0gbmV3IFNpbXBsZU1ldGhvZFNpZ25hdHVyZSgiZm9vIiwgbmV3IEphdmFUeXBlWzFdKTsKLQkJCWZhaWwoImludmFsaWQgTWV0aG9kU2lnbmF0dXJlOiAiICsgbWV0aG9kU2lnbmF0dXJlKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEludmFsaWRQYXJhbWV0ZXJUeXBlc1ZvaWRJdGVtKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCUphdmFUeXBlIGp0ID0gbmV3IFNpbXBsZUphdmFUeXBlKHZvaWQuY2xhc3MuZ2V0TmFtZSgpKTsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJTWV0aG9kU2lnbmF0dXJlIG1ldGhvZFNpZ25hdHVyZSA9IG5ldyBTaW1wbGVNZXRob2RTaWduYXR1cmUoImZvbyIsIG5ldyBKYXZhVHlwZVtdIHtqdH0pOwotCQkJZmFpbCgiaW52YWxpZCBNZXRob2RTaWduYXR1cmU6ICIgKyBtZXRob2RTaWduYXR1cmUpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZFBhcmFtZXRlclR5cGVOYW1lc051bGwoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJTWV0aG9kU2lnbmF0dXJlIG1ldGhvZFNpZ25hdHVyZSA9IG5ldyBTaW1wbGVNZXRob2RTaWduYXR1cmUoImZvbyIsIChTdHJpbmdbXSkgbnVsbCk7Ci0JCQlmYWlsKCJpbnZhbGlkIE1ldGhvZFNpZ25hdHVyZTogIiArIG1ldGhvZFNpZ25hdHVyZSk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbnZhbGlkUGFyYW1ldGVyVHlwZU5hbWVzTnVsbEl0ZW0oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJTWV0aG9kU2lnbmF0dXJlIG1ldGhvZFNpZ25hdHVyZSA9IG5ldyBTaW1wbGVNZXRob2RTaWduYXR1cmUoImZvbyIsIG5ldyBTdHJpbmdbMV0pOwotCQkJZmFpbCgiaW52YWxpZCBNZXRob2RTaWduYXR1cmU6ICIgKyBtZXRob2RTaWduYXR1cmUpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZFBhcmFtZXRlckphdmFDbGFzc2VzTnVsbCgpIHRocm93cyBFeGNlcHRpb24gewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlNZXRob2RTaWduYXR1cmUgbWV0aG9kU2lnbmF0dXJlID0gbmV3IFNpbXBsZU1ldGhvZFNpZ25hdHVyZSgiZm9vIiwgKENsYXNzPD8+W10pIG51bGwpOwotCQkJZmFpbCgiaW52YWxpZCBNZXRob2RTaWduYXR1cmU6ICIgKyBtZXRob2RTaWduYXR1cmUpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZFBhcmFtZXRlckphdmFDbGFzc2VzTnVsbEl0ZW0oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJTWV0aG9kU2lnbmF0dXJlIG1ldGhvZFNpZ25hdHVyZSA9IG5ldyBTaW1wbGVNZXRob2RTaWduYXR1cmUoImZvbyIsIG5ldyBDbGFzc1sxXSk7Ci0JCQlmYWlsKCJpbnZhbGlkIE1ldGhvZFNpZ25hdHVyZTogIiArIG1ldGhvZFNpZ25hdHVyZSk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRTaWduYXR1cmUwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCU1ldGhvZFNpZ25hdHVyZSBtcyA9IG5ldyBTaW1wbGVNZXRob2RTaWduYXR1cmUodGhpcy5nZXRNZXRob2QoIm1ldGhvZDAiKSk7Ci0JCWFzc2VydEVxdWFscygibWV0aG9kMCgpIiwgbXMuZ2V0U2lnbmF0dXJlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRTaWduYXR1cmUxKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCU1ldGhvZFNpZ25hdHVyZSBtcyA9IG5ldyBTaW1wbGVNZXRob2RTaWduYXR1cmUodGhpcy5nZXRNZXRob2QoIm1ldGhvZDEiKSk7Ci0JCWFzc2VydEVxdWFscygibWV0aG9kMShpbnQpIiwgbXMuZ2V0U2lnbmF0dXJlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRTaWduYXR1cmUyKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCU1ldGhvZFNpZ25hdHVyZSBtcyA9IG5ldyBTaW1wbGVNZXRob2RTaWduYXR1cmUodGhpcy5nZXRNZXRob2QoIm1ldGhvZDIiKSk7Ci0JCWFzc2VydEVxdWFscygibWV0aG9kMihpbnQsIGphdmEubGFuZy5TdHJpbmcpIiwgbXMuZ2V0U2lnbmF0dXJlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRTaWduYXR1cmUzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCU1ldGhvZFNpZ25hdHVyZSBtcyA9IG5ldyBTaW1wbGVNZXRob2RTaWduYXR1cmUodGhpcy5nZXRNZXRob2QoIm1ldGhvZDMiKSk7Ci0JCWFzc2VydEVxdWFscygibWV0aG9kMyhpbnQsIGphdmEubGFuZy5TdHJpbmcsIGphdmEubGFuZy5PYmplY3RbXVtdKSIsIG1zLmdldFNpZ25hdHVyZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0R2V0TmFtZSgpIHRocm93cyBFeGNlcHRpb24gewotCQlNZXRob2RTaWduYXR1cmUgbXMgPSBuZXcgU2ltcGxlTWV0aG9kU2lnbmF0dXJlKHRoaXMuZ2V0TWV0aG9kKCJtZXRob2QyIikpOwotCQlhc3NlcnRFcXVhbHMoIm1ldGhvZDIiLCBtcy5nZXROYW1lKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRQYXJhbWV0ZXJUeXBlcygpIHRocm93cyBFeGNlcHRpb24gewotCQlNZXRob2RTaWduYXR1cmUgbXMgPSBuZXcgU2ltcGxlTWV0aG9kU2lnbmF0dXJlKHRoaXMuZ2V0TWV0aG9kKCJtZXRob2QzIikpOwotCQlKYXZhVHlwZVtdIGV4cGVjdGVkID0gbmV3IEphdmFUeXBlWzNdOwotCQlleHBlY3RlZFswXSA9IG5ldyBTaW1wbGVKYXZhVHlwZSgiaW50Iik7Ci0JCWV4cGVjdGVkWzFdID0gbmV3IFNpbXBsZUphdmFUeXBlKCJqYXZhLmxhbmcuU3RyaW5nIik7Ci0JCWV4cGVjdGVkWzJdID0gbmV3IFNpbXBsZUphdmFUeXBlKCJqYXZhLmxhbmcuT2JqZWN0IiwgMik7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgbXMuZ2V0UGFyYW1ldGVyVHlwZXMoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RFcXVhbHMoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJT2JqZWN0IG1zMSA9IG5ldyBTaW1wbGVNZXRob2RTaWduYXR1cmUodGhpcy5nZXRNZXRob2QoIm1ldGhvZDMiKSk7Ci0JCU9iamVjdCBtczIgPSBuZXcgU2ltcGxlTWV0aG9kU2lnbmF0dXJlKHRoaXMuZ2V0TWV0aG9kKCJtZXRob2QzIikpOwotCQlhc3NlcnROb3RTYW1lKG1zMSwgbXMyKTsKLQkJYXNzZXJ0RXF1YWxzKG1zMSwgbXMxKTsKLQkJYXNzZXJ0RXF1YWxzKG1zMSwgbXMyKTsKLQkJYXNzZXJ0RXF1YWxzKG1zMS5oYXNoQ29kZSgpLCBtczIuaGFzaENvZGUoKSk7Ci0KLQkJT2JqZWN0IG1zMyA9IG5ldyBTaW1wbGVNZXRob2RTaWduYXR1cmUodGhpcy5nZXRNZXRob2QoIm1ldGhvZDIiKSk7Ci0JCWFzc2VydE5vdFNhbWUobXMxLCBtczMpOwotCQlhc3NlcnRGYWxzZShtczEuZXF1YWxzKG1zMykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb21wYXJlVG8xKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCU1ldGhvZFNpZ25hdHVyZSBtczEgPSBuZXcgU2ltcGxlTWV0aG9kU2lnbmF0dXJlKHRoaXMuZ2V0TWV0aG9kKCJtZXRob2QzIikpOwotCQlNZXRob2RTaWduYXR1cmUgbXMyID0gbmV3IFNpbXBsZU1ldGhvZFNpZ25hdHVyZSh0aGlzLmdldE1ldGhvZCgibWV0aG9kMyIpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIG1zMS5jb21wYXJlVG8obXMyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbXBhcmVUbzIoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJTWV0aG9kU2lnbmF0dXJlIG1zMSA9IG5ldyBTaW1wbGVNZXRob2RTaWduYXR1cmUodGhpcy5nZXRNZXRob2QoIm1ldGhvZDMiKSk7Ci0JCU1ldGhvZFNpZ25hdHVyZSBtczIgPSBuZXcgU2ltcGxlTWV0aG9kU2lnbmF0dXJlKHRoaXMuZ2V0TWV0aG9kKCJtZXRob2QyIikpOwotCQlhc3NlcnRUcnVlKG1zMS5jb21wYXJlVG8obXMyKSA+IDApOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb21wYXJlVG8zKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCU1ldGhvZFNpZ25hdHVyZSBtc0ExID0gbmV3IFNpbXBsZU1ldGhvZFNpZ25hdHVyZSh0aGlzLmdldE1ldGhvZCgibWV0aG9kQSIsIG5ldyBDbGFzc1tdIHtpbnQuY2xhc3MsIFN0cmluZy5jbGFzc30pKTsKLQkJTWV0aG9kU2lnbmF0dXJlIG1zQTIgPSBuZXcgU2ltcGxlTWV0aG9kU2lnbmF0dXJlKHRoaXMuZ2V0TWV0aG9kKCJtZXRob2RBIiwgbmV3IENsYXNzW10ge2ludC5jbGFzcywgU3RyaW5nLmNsYXNzLCBTdHJpbmcuY2xhc3N9KSk7Ci0JCWFzc2VydFRydWUobXNBMS5jb21wYXJlVG8obXNBMikgPCAwKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29tcGFyZVRvNCgpIHRocm93cyBFeGNlcHRpb24gewotCQlNZXRob2RTaWduYXR1cmUgbXNCMSA9IG5ldyBTaW1wbGVNZXRob2RTaWduYXR1cmUodGhpcy5nZXRNZXRob2QoIm1ldGhvZEIiLCBuZXcgQ2xhc3NbXSB7aW50LmNsYXNzLCBPYmplY3QuY2xhc3N9KSk7Ci0JCU1ldGhvZFNpZ25hdHVyZSBtc0IyID0gbmV3IFNpbXBsZU1ldGhvZFNpZ25hdHVyZSh0aGlzLmdldE1ldGhvZCgibWV0aG9kQiIsIG5ldyBDbGFzc1tdIHtpbnQuY2xhc3MsIFN0cmluZy5jbGFzc30pKTsKLQkJYXNzZXJ0VHJ1ZShtc0IxLmNvbXBhcmVUbyhtc0IyKSA8IDApOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDbG9uZSgpIHRocm93cyBFeGNlcHRpb24gewotCQlTaW1wbGVNZXRob2RTaWduYXR1cmUgbXMxID0gbmV3IFNpbXBsZU1ldGhvZFNpZ25hdHVyZSh0aGlzLmdldE1ldGhvZCgibWV0aG9kMyIpKTsKLQkJU2ltcGxlTWV0aG9kU2lnbmF0dXJlIG1zMiA9IChTaW1wbGVNZXRob2RTaWduYXR1cmUpIG1zMS5jbG9uZSgpOwotCQlhc3NlcnROb3RTYW1lKG1zMSwgbXMyKTsKLQkJYXNzZXJ0RXF1YWxzKG1zMSwgbXMyKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2VyaWFsaXphdGlvbigpIHRocm93cyBFeGNlcHRpb24gewotCQlTaW1wbGVNZXRob2RTaWduYXR1cmUgbXMxID0gbmV3IFNpbXBsZU1ldGhvZFNpZ25hdHVyZSh0aGlzLmdldE1ldGhvZCgibWV0aG9kMyIpKTsKLQkJU2ltcGxlTWV0aG9kU2lnbmF0dXJlIG1zMiA9IFRlc3RUb29scy5zZXJpYWxpemUobXMxKTsKLQkJYXNzZXJ0Tm90U2FtZShtczEsIG1zMik7Ci0JCWFzc2VydEVxdWFscyhtczEsIG1zMik7Ci0JfQotCi0JcHJpdmF0ZSBNZXRob2QgZ2V0TWV0aG9kKFN0cmluZyBtZXRob2ROYW1lKSB7Ci0JCWZvciAoTWV0aG9kIG1ldGhvZCA6IHRoaXMuZ2V0Q2xhc3MoKS5nZXRNZXRob2RzKCkpIHsKLQkJCWlmIChtZXRob2QuZ2V0TmFtZSgpLmVxdWFscyhtZXRob2ROYW1lKSkgewotCQkJCXJldHVybiBtZXRob2Q7Ci0JCQl9Ci0JCX0KLQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigibWV0aG9kIG5vdCBmb3VuZDogIiArIG1ldGhvZE5hbWUpOwotCX0KLQotCXByaXZhdGUgTWV0aG9kIGdldE1ldGhvZChTdHJpbmcgbWV0aG9kTmFtZSwgQ2xhc3M8Pz4uLi4gcGFyYW1ldGVyVHlwZXMpIHRocm93cyBFeGNlcHRpb24gewotCQlyZXR1cm4gdGhpcy5nZXRDbGFzcygpLmdldE1ldGhvZChtZXRob2ROYW1lLCBwYXJhbWV0ZXJUeXBlcyk7Ci0JfQotCi0JcHVibGljIHZvaWQgbWV0aG9kMCgpIHsgLyogdXNlZCBieSB0ZXN0cyAqLyB9Ci0JQFN1cHByZXNzV2FybmluZ3MoInVudXNlZCIpIHB1YmxpYyB2b2lkIG1ldGhvZDEoaW50IGZvbykgeyAvKiB1c2VkIGJ5IHRlc3RzICovIH0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW51c2VkIikgcHVibGljIHZvaWQgbWV0aG9kMihpbnQgZm9vLCBTdHJpbmcgYmFyKSB7IC8qIHVzZWQgYnkgdGVzdHMgKi8gfQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bnVzZWQiKSBwdWJsaWMgdm9pZCBtZXRob2QzKGludCBmb28sIFN0cmluZyBiYXIsIE9iamVjdFtdW10gYmF6KSB7IC8qIHVzZWQgYnkgdGVzdHMgKi8gfQotCi0JQFN1cHByZXNzV2FybmluZ3MoInVudXNlZCIpIHB1YmxpYyB2b2lkIG1ldGhvZEEoaW50IGZvbywgU3RyaW5nIGJhcikgeyAvKiB1c2VkIGJ5IHRlc3RzICovIH0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW51c2VkIikgcHVibGljIHZvaWQgbWV0aG9kQShpbnQgZm9vLCBTdHJpbmcgYmFyLCBTdHJpbmcgYmF6KSB7IC8qIHVzZWQgYnkgdGVzdHMgKi8gfQotCi0JQFN1cHByZXNzV2FybmluZ3MoInVudXNlZCIpIHB1YmxpYyB2b2lkIG1ldGhvZEIoaW50IGZvbywgT2JqZWN0IGJhcikgeyAvKiB1c2VkIGJ5IHRlc3RzICovIH0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW51c2VkIikgcHVibGljIHZvaWQgbWV0aG9kQihpbnQgZm9vLCBTdHJpbmcgYmFyKSB7IC8qIHVzZWQgYnkgdGVzdHMgKi8gfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL05hbWVUb29sc1Rlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL05hbWVUb29sc1Rlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGEzODk1ODMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9OYW1lVG9vbHNUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjI2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuTmFtZVRvb2xzOwotCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBOYW1lVG9vbHNUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBOYW1lVG9vbHNUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3RyaW5nQWJzZW50SWdub3JlQ2FzZSgpIHsKLQkJTGlzdDxTdHJpbmc+IGNvbG9yQ29sbGVjdGlvbiA9IHRoaXMuYnVpbGRDb2xvckNvbGxlY3Rpb24oKTsKLQkJU3RyaW5nIHJldHVybmVkID0gTmFtZVRvb2xzLnVuaXF1ZU5hbWVGb3JJZ25vcmVDYXNlKCJUYXVwZSIsIGNvbG9yQ29sbGVjdGlvbik7Ci0JCWFzc2VydEVxdWFscygiVGF1cGUiLCByZXR1cm5lZCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFN0cmluZ1ByZXNlbnRDYXNlRGlmZmVycygpIHsKLQkJTGlzdDxTdHJpbmc+IGNvbG9yQ29sbGVjdGlvbiA9IHRoaXMuYnVpbGRDb2xvckNvbGxlY3Rpb24oKTsKLQkJU3RyaW5nIHJldHVybmVkID0gTmFtZVRvb2xzLnVuaXF1ZU5hbWVGb3IoImdyZWVuIiwgY29sb3JDb2xsZWN0aW9uKTsKLQkJYXNzZXJ0RXF1YWxzKCJncmVlbiIsIHJldHVybmVkKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3RyaW5nUHJlc2VudElnbm9yZUNhc2UoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBjb2xvckNvbGxlY3Rpb24gPSB0aGlzLmJ1aWxkQ29sb3JDb2xsZWN0aW9uKCk7Ci0JCVN0cmluZyByZXR1cm5lZCA9IE5hbWVUb29scy51bmlxdWVOYW1lRm9ySWdub3JlQ2FzZSgiZ3JlZW4iLCBjb2xvckNvbGxlY3Rpb24pOwotCQlhc3NlcnRFcXVhbHMoImdyZWVuMiIsIHJldHVybmVkKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3RyaW5nUHJlc2VudFdpdGhBcHBlbmRpY2VzKCkgewotCQlMaXN0PFN0cmluZz4gY29sb3JDb2xsZWN0aW9uID0gdGhpcy5idWlsZENvbG9yQ29sbGVjdGlvbigpOwotCQljb2xvckNvbGxlY3Rpb24uYWRkKCJSZWQxIik7Ci0JCWNvbG9yQ29sbGVjdGlvbi5hZGQoInJlZDIiKTsKLQkJU3RyaW5nIHJldHVybmVkID0gTmFtZVRvb2xzLnVuaXF1ZU5hbWVGb3JJZ25vcmVDYXNlKCJyZWQiLCBjb2xvckNvbGxlY3Rpb24pOwotCQljb2xvckNvbGxlY3Rpb24ucmVtb3ZlKCJSZWQxIik7Ci0JCWNvbG9yQ29sbGVjdGlvbi5yZW1vdmUoInJlZDIiKTsKLQkJYXNzZXJ0RXF1YWxzKCJyZWQzIiwgcmV0dXJuZWQpOwotCX0KLQotCXByaXZhdGUgTGlzdDxTdHJpbmc+IGJ1aWxkQ29sb3JDb2xsZWN0aW9uKCkgewotCQlMaXN0PFN0cmluZz4gY29sb3JDb2xsZWN0aW9uID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWNvbG9yQ29sbGVjdGlvbi5hZGQoIlJlZCIpOwotCQljb2xvckNvbGxlY3Rpb24uYWRkKCJPcmFuZ2UiKTsKLQkJY29sb3JDb2xsZWN0aW9uLmFkZCgiWWVsbG93Iik7Ci0JCWNvbG9yQ29sbGVjdGlvbi5hZGQoIkdyZWVuIik7Ci0JCWNvbG9yQ29sbGVjdGlvbi5hZGQoIkJsdWUiKTsKLQkJY29sb3JDb2xsZWN0aW9uLmFkZCgiSW5kaWdvIik7Ci0JCWNvbG9yQ29sbGVjdGlvbi5hZGQoIlZpb2xldCIpOwotCQlyZXR1cm4gY29sb3JDb2xsZWN0aW9uOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbmlxdWVOYW1lRm9yQ29sbGVjdGlvbjEoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBzdHJpbmdzID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCXN0cmluZ3MuYWRkKCJPcmFjbGUiKTsKLQkJc3RyaW5ncy5hZGQoIk9yYWNsZSBDb3Jwb3JhdGlvbiIpOwotCQlzdHJpbmdzLmFkZCgiT3JhY2xlMiIpOwotCQlzdHJpbmdzLmFkZCgib3JhY2xlMSIpOwotCQlzdHJpbmdzLmFkZCgiT3JhY2wiKTsKLQotCQlhc3NlcnRFcXVhbHMoIk9yYWNsZTMiLCBOYW1lVG9vbHMudW5pcXVlTmFtZUZvcigiT3JhY2xlIiwgc3RyaW5ncykpOwotCQlhc3NlcnRFcXVhbHMoIlRlc3QiLCBOYW1lVG9vbHMudW5pcXVlTmFtZUZvcigiVGVzdCIsIHN0cmluZ3MpKTsKLQotCQlhc3NlcnRFcXVhbHMoIk9yYWNsZTMiLCBOYW1lVG9vbHMudW5pcXVlTmFtZUZvcklnbm9yZUNhc2UoIk9yYWNsZSIsIHN0cmluZ3MpKTsKLQkJYXNzZXJ0RXF1YWxzKCJvcmFjbGUzIiwgTmFtZVRvb2xzLnVuaXF1ZU5hbWVGb3JJZ25vcmVDYXNlKCJvcmFjbGUiLCBzdHJpbmdzKSk7Ci0JCWFzc2VydEVxdWFscygiVGVzdCIsIE5hbWVUb29scy51bmlxdWVOYW1lRm9ySWdub3JlQ2FzZSgiVGVzdCIsIHN0cmluZ3MpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VW5pcXVlTmFtZUZvckNvbGxlY3Rpb24yKCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gc3RyaW5ncyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlzdHJpbmdzLmFkZCgiT3JhY2xlIik7Ci0JCXN0cmluZ3MuYWRkKCJvcmFjbGUiKTsKLQkJc3RyaW5ncy5hZGQoIk9yYWNsZTIiKTsKLQkJc3RyaW5ncy5hZGQoIk9yYWNsZTEiKTsKLQotCQlhc3NlcnRFcXVhbHMoIk9yYWNsZTMiLCBOYW1lVG9vbHMudW5pcXVlTmFtZUZvcigiT3JhY2xlIiwgc3RyaW5ncykpOwotCQlhc3NlcnRFcXVhbHMoIlRlc3QiLCBOYW1lVG9vbHMudW5pcXVlTmFtZUZvcigiVGVzdCIsIHN0cmluZ3MpKTsKLQotCQlzdHJpbmdzLmFkZCgiT3JhY2xlIENvcnBvcmF0aW9uIik7Ci0JCWFzc2VydEVxdWFscygiT3JhY2xlMyIsIE5hbWVUb29scy51bmlxdWVOYW1lRm9ySWdub3JlQ2FzZSgiT3JhY2xlIiwgc3RyaW5ncykpOwotCQlhc3NlcnRFcXVhbHMoIm9yYWNsZTMiLCBOYW1lVG9vbHMudW5pcXVlTmFtZUZvcklnbm9yZUNhc2UoIm9yYWNsZSIsIHN0cmluZ3MpKTsKLQkJYXNzZXJ0RXF1YWxzKCJUZXN0IiwgTmFtZVRvb2xzLnVuaXF1ZU5hbWVGb3JJZ25vcmVDYXNlKCJUZXN0Iiwgc3RyaW5ncykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbmlxdWVOYW1lRm9yQ29sbGVjdGlvbjMoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBzdHJpbmdzID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCXN0cmluZ3MuYWRkKCJPcmFjbGUiKTsKLQkJc3RyaW5ncy5hZGQoIk9yYWNsZSIpOwotCQlzdHJpbmdzLmFkZCgiT3JhY2xlMiIpOwotCQlzdHJpbmdzLmFkZCgiT3JhY2xlMSIpOwotCi0JCWFzc2VydEVxdWFscygiT3JhY2xlMyIsIE5hbWVUb29scy51bmlxdWVOYW1lRm9yKCJPcmFjbGUiLCBzdHJpbmdzKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFVuaXF1ZU5hbWVGb3JJdGVyYXRvcjEoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBzdHJpbmdzID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCXN0cmluZ3MuYWRkKCJPcmFjbGUiKTsKLQkJc3RyaW5ncy5hZGQoIk9yYWNsZSBDb3Jwb3JhdGlvbiIpOwotCQlzdHJpbmdzLmFkZCgiT3JhY2xlMiIpOwotCQlzdHJpbmdzLmFkZCgib3JhY2xlMSIpOwotCQlzdHJpbmdzLmFkZCgiT3JhY2wiKTsKLQotCQlhc3NlcnRFcXVhbHMoIk9yYWNsZTMiLCBOYW1lVG9vbHMudW5pcXVlTmFtZUZvcigiT3JhY2xlIiwgc3RyaW5ncy5pdGVyYXRvcigpKSk7Ci0JCWFzc2VydEVxdWFscygiVGVzdCIsIE5hbWVUb29scy51bmlxdWVOYW1lRm9yKCJUZXN0Iiwgc3RyaW5ncy5pdGVyYXRvcigpKSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKCJPcmFjbGUzIiwgTmFtZVRvb2xzLnVuaXF1ZU5hbWVGb3JJZ25vcmVDYXNlKCJPcmFjbGUiLCBzdHJpbmdzLml0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJvcmFjbGUzIiwgTmFtZVRvb2xzLnVuaXF1ZU5hbWVGb3JJZ25vcmVDYXNlKCJvcmFjbGUiLCBzdHJpbmdzLml0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJUZXN0IiwgTmFtZVRvb2xzLnVuaXF1ZU5hbWVGb3JJZ25vcmVDYXNlKCJUZXN0Iiwgc3RyaW5ncy5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFVuaXF1ZU5hbWVGb3JJdGVyYXRvcjIoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBzdHJpbmdzID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCXN0cmluZ3MuYWRkKCJPcmFjbGUiKTsKLQkJc3RyaW5ncy5hZGQoIm9yYWNsZSIpOwotCQlzdHJpbmdzLmFkZCgiT3JhY2xlMiIpOwotCQlzdHJpbmdzLmFkZCgiT3JhY2xlMSIpOwotCi0JCWFzc2VydEVxdWFscygiT3JhY2xlMyIsIE5hbWVUb29scy51bmlxdWVOYW1lRm9yKCJPcmFjbGUiLCBzdHJpbmdzLml0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJUZXN0IiwgTmFtZVRvb2xzLnVuaXF1ZU5hbWVGb3IoIlRlc3QiLCBzdHJpbmdzLml0ZXJhdG9yKCkpKTsKLQotCQlzdHJpbmdzLmFkZCgiT3JhY2xlIENvcnBvcmF0aW9uIik7Ci0JCWFzc2VydEVxdWFscygiT3JhY2xlMyIsIE5hbWVUb29scy51bmlxdWVOYW1lRm9ySWdub3JlQ2FzZSgiT3JhY2xlIiwgc3RyaW5ncy5pdGVyYXRvcigpKSk7Ci0JCWFzc2VydEVxdWFscygib3JhY2xlMyIsIE5hbWVUb29scy51bmlxdWVOYW1lRm9ySWdub3JlQ2FzZSgib3JhY2xlIiwgc3RyaW5ncy5pdGVyYXRvcigpKSk7Ci0JCWFzc2VydEVxdWFscygiVGVzdCIsIE5hbWVUb29scy51bmlxdWVOYW1lRm9ySWdub3JlQ2FzZSgiVGVzdCIsIHN0cmluZ3MuaXRlcmF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbmlxdWVOYW1lRm9ySXRlcmF0b3IzKCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gc3RyaW5ncyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlzdHJpbmdzLmFkZCgiT3JhY2xlIik7Ci0JCXN0cmluZ3MuYWRkKCJPcmFjbGUiKTsKLQkJc3RyaW5ncy5hZGQoIk9yYWNsZTIiKTsKLQkJc3RyaW5ncy5hZGQoIk9yYWNsZTEiKTsKLQotCQlhc3NlcnRFcXVhbHMoIk9yYWNsZTMiLCBOYW1lVG9vbHMudW5pcXVlTmFtZUZvcigiT3JhY2xlIiwgc3RyaW5ncy5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEJ1aWxkUXVhbGlmaWVkRGF0YWJhc2VPYmplY3ROYW1lKCkgewotCQlhc3NlcnRFcXVhbHMoImNhdGFsb2cuc2NoZW1hLm5hbWUiLCBOYW1lVG9vbHMuYnVpbGRRdWFsaWZpZWREYXRhYmFzZU9iamVjdE5hbWUoImNhdGFsb2ciLCAic2NoZW1hIiwgIm5hbWUiKSk7Ci0JCWFzc2VydEVxdWFscygiY2F0YWxvZy4ubmFtZSIsIE5hbWVUb29scy5idWlsZFF1YWxpZmllZERhdGFiYXNlT2JqZWN0TmFtZSgiY2F0YWxvZyIsIG51bGwsICJuYW1lIikpOwotCQlhc3NlcnRFcXVhbHMoInNjaGVtYS5uYW1lIiwgTmFtZVRvb2xzLmJ1aWxkUXVhbGlmaWVkRGF0YWJhc2VPYmplY3ROYW1lKG51bGwsICJzY2hlbWEiLCAibmFtZSIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJuYW1lIiwgTmFtZVRvb2xzLmJ1aWxkUXVhbGlmaWVkRGF0YWJhc2VPYmplY3ROYW1lKG51bGwsIG51bGwsICJuYW1lIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RKYXZhUmVzZXJ2ZWRXb3JkcygpIHsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoTmFtZVRvb2xzLmphdmFSZXNlcnZlZFdvcmRzKCksICJjbGFzcyIpKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKE5hbWVUb29scy5qYXZhUmVzZXJ2ZWRXb3JkcygpLCAiQ2xhc3MiKSk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKE5hbWVUb29scy5qYXZhUmVzZXJ2ZWRXb3JkcygpLCAicHJpdmF0ZSIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Y29udmVydFRvSmF2YUlkZW50aWZpZXJTdHJpbmcoKSB7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgTmFtZVRvb2xzLmNvbnZlcnRUb0phdmFJZGVudGlmaWVyKCJmb28iKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vMSIsIE5hbWVUb29scy5jb252ZXJ0VG9KYXZhSWRlbnRpZmllcigiZm9vMSIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJwcml2YXRlXyIsIE5hbWVUb29scy5jb252ZXJ0VG9KYXZhSWRlbnRpZmllcigicHJpdmF0ZSIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0aHJvd18iLCBOYW1lVG9vbHMuY29udmVydFRvSmF2YUlkZW50aWZpZXIoInRocm93IikpOwotCQlhc3NlcnRFcXVhbHMoIl9mb28iLCBOYW1lVG9vbHMuY29udmVydFRvSmF2YUlkZW50aWZpZXIoIjFmb28iKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vXyIsIE5hbWVUb29scy5jb252ZXJ0VG9KYXZhSWRlbnRpZmllcigiZm9vJSIpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb29fX2Jhcl9fIiwgTmFtZVRvb2xzLmNvbnZlcnRUb0phdmFJZGVudGlmaWVyKCJmb28gIGJhciAgIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3Rjb252ZXJ0VG9KYXZhSWRlbnRpZmllclN0cmluZ0NoYXIoKSB7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgTmFtZVRvb2xzLmNvbnZlcnRUb0phdmFJZGVudGlmaWVyKCJmb28iLCAnJCcpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28xIiwgTmFtZVRvb2xzLmNvbnZlcnRUb0phdmFJZGVudGlmaWVyKCJmb28xIiwgJyQnKSk7Ci0JCWFzc2VydEVxdWFscygicHJpdmF0ZSQiLCBOYW1lVG9vbHMuY29udmVydFRvSmF2YUlkZW50aWZpZXIoInByaXZhdGUiLCAnJCcpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0aHJvd3NzIiwgTmFtZVRvb2xzLmNvbnZlcnRUb0phdmFJZGVudGlmaWVyKCJ0aHJvdyIsICdzJykpOwotCQlhc3NlcnRFcXVhbHMoIiRmb28iLCBOYW1lVG9vbHMuY29udmVydFRvSmF2YUlkZW50aWZpZXIoIjFmb28iLCAnJCcpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28kIiwgTmFtZVRvb2xzLmNvbnZlcnRUb0phdmFJZGVudGlmaWVyKCJmb28lIiwgJyQnKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vJCRiYXIkJCIsIE5hbWVUb29scy5jb252ZXJ0VG9KYXZhSWRlbnRpZmllcigiZm9vICBiYXIgICIsICckJykpOwotCi0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCVN0cmluZyBzID0gTmFtZVRvb2xzLmNvbnZlcnRUb0phdmFJZGVudGlmaWVyKCIxZm9vIiwgJzcnKTsKLQkJCWZhaWwoImludmFsaWQgc3RyaW5nOiBcIiIgKyBzICsgIlwiIik7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJaWYgKGV4LmdldE1lc3NhZ2UoKS5pbmRleE9mKCc3JykgIT0gLTEpIHsKLQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCVN0cmluZyBzID0gTmFtZVRvb2xzLmNvbnZlcnRUb0phdmFJZGVudGlmaWVyKCJmb28lIiwgJ14nKTsKLQkJCWZhaWwoImludmFsaWQgc3RyaW5nOiBcIiIgKyBzICsgIlwiIik7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJaWYgKGV4LmdldE1lc3NhZ2UoKS5pbmRleE9mKCdeJykgIT0gLTEpIHsKLQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCVN0cmluZyBzID0gTmFtZVRvb2xzLmNvbnZlcnRUb0phdmFJZGVudGlmaWVyKCJwcml2YXRlIiwgJ14nKTsKLQkJCWZhaWwoImludmFsaWQgc3RyaW5nOiBcIiIgKyBzICsgIlwiIik7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJaWYgKGV4LmdldE1lc3NhZ2UoKS5pbmRleE9mKCdeJykgIT0gLTEpIHsKLQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3RyaW5nSXNMZWdhbEphdmFJZGVudGlmaWVyKCkgewotCQlhc3NlcnRGYWxzZShOYW1lVG9vbHMuc3RyaW5nSXNMZWdhbEphdmFJZGVudGlmaWVyKCJjbGFzcyIpKTsKLQkJYXNzZXJ0VHJ1ZShOYW1lVG9vbHMuc3RyaW5nSXNMZWdhbEphdmFJZGVudGlmaWVyKCJjbGFzUyIpKTsKLQotCQlhc3NlcnRGYWxzZShOYW1lVG9vbHMuc3RyaW5nSXNMZWdhbEphdmFJZGVudGlmaWVyKCI3Zm9vIikpOwotCQlhc3NlcnRGYWxzZShOYW1lVG9vbHMuc3RyaW5nSXNMZWdhbEphdmFJZGVudGlmaWVyKCJmb29AYmFyIikpOwotCQlhc3NlcnRUcnVlKE5hbWVUb29scy5zdHJpbmdJc0xlZ2FsSmF2YUlkZW50aWZpZXIoIl9mb28iKSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1JhbmdlVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvUmFuZ2VUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkN2YyY2NlLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvUmFuZ2VUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5SYW5nZTsKLQotcHVibGljIGNsYXNzIFJhbmdlVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQlwdWJsaWMgUmFuZ2VUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW5jbHVkZXMoKSB7Ci0JCVJhbmdlIHJhbmdlID0gbmV3IFJhbmdlKDUsIDE3KTsKLQkJYXNzZXJ0RmFsc2UocmFuZ2UuaW5jbHVkZXMoLTU1KSk7Ci0JCWFzc2VydEZhbHNlKHJhbmdlLmluY2x1ZGVzKDApKTsKLQkJYXNzZXJ0RmFsc2UocmFuZ2UuaW5jbHVkZXMoNCkpOwotCQlhc3NlcnRUcnVlKHJhbmdlLmluY2x1ZGVzKDUpKTsKLQkJYXNzZXJ0VHJ1ZShyYW5nZS5pbmNsdWRlcyg2KSk7Ci0JCWFzc2VydFRydWUocmFuZ2UuaW5jbHVkZXMoMTYpKTsKLQkJYXNzZXJ0VHJ1ZShyYW5nZS5pbmNsdWRlcygxNykpOwotCQlhc3NlcnRGYWxzZShyYW5nZS5pbmNsdWRlcygxOCkpOwotCQlhc3NlcnRGYWxzZShyYW5nZS5pbmNsdWRlcygyMDApKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RXF1YWxzKCkgewotCQlSYW5nZSByYW5nZTEgPSBuZXcgUmFuZ2UoNSwgMTcpOwotCQlSYW5nZSByYW5nZTIgPSBuZXcgUmFuZ2UoNSwgMTcpOwotCQlhc3NlcnROb3RTYW1lKHJhbmdlMSwgcmFuZ2UyKTsKLQkJYXNzZXJ0RXF1YWxzKHJhbmdlMSwgcmFuZ2UxKTsKLQkJYXNzZXJ0RXF1YWxzKHJhbmdlMSwgcmFuZ2UyKTsKLQkJYXNzZXJ0RXF1YWxzKHJhbmdlMiwgcmFuZ2UxKTsKLQkJYXNzZXJ0RXF1YWxzKHJhbmdlMS5oYXNoQ29kZSgpLCByYW5nZTIuaGFzaENvZGUoKSk7Ci0KLQkJcmFuZ2UyID0gbmV3IFJhbmdlKDE3LCA1KTsKLQkJYXNzZXJ0RmFsc2UocmFuZ2UxLmVxdWFscyhyYW5nZTIpKTsKLQkJYXNzZXJ0RmFsc2UocmFuZ2UyLmVxdWFscyhyYW5nZTEpKTsKLQkJLy8gYWx0aG91Z2ggdGhleSBhcmUgdW5lcXVhbCwgdGhleSBjYW4gaGF2ZSB0aGUgc2FtZSBoYXNoIGNvZGUKLQkJYXNzZXJ0RXF1YWxzKHJhbmdlMS5oYXNoQ29kZSgpLCByYW5nZTIuaGFzaENvZGUoKSk7Ci0KLQkJcmFuZ2UyID0gbmV3IFJhbmdlKDUsIDE1KTsKLQkJYXNzZXJ0RmFsc2UocmFuZ2UxLmVxdWFscyhyYW5nZTIpKTsKLQkJYXNzZXJ0RmFsc2UocmFuZ2UyLmVxdWFscyhyYW5nZTEpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2xvbmUoKSB7Ci0JCVJhbmdlIHJhbmdlMSA9IG5ldyBSYW5nZSg1LCAxNyk7Ci0JCVJhbmdlIHJhbmdlMiA9IHJhbmdlMS5jbG9uZSgpOwotCQlhc3NlcnROb3RTYW1lKHJhbmdlMSwgcmFuZ2UyKTsKLQkJYXNzZXJ0RXF1YWxzKHJhbmdlMSwgcmFuZ2UxKTsKLQkJYXNzZXJ0RXF1YWxzKHJhbmdlMSwgcmFuZ2UyKTsKLQkJYXNzZXJ0RXF1YWxzKHJhbmdlMiwgcmFuZ2UxKTsKLQkJYXNzZXJ0RXF1YWxzKHJhbmdlMS5oYXNoQ29kZSgpLCByYW5nZTIuaGFzaENvZGUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNlcmlhbGl6YXRpb24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJUmFuZ2UgcmFuZ2UxID0gbmV3IFJhbmdlKDUsIDE3KTsKLQkJUmFuZ2UgcmFuZ2UyID0gVGVzdFRvb2xzLnNlcmlhbGl6ZShyYW5nZTEpOwotCQlhc3NlcnROb3RTYW1lKHJhbmdlMSwgcmFuZ2UyKTsKLQkJYXNzZXJ0RXF1YWxzKHJhbmdlMSwgcmFuZ2UxKTsKLQkJYXNzZXJ0RXF1YWxzKHJhbmdlMSwgcmFuZ2UyKTsKLQkJYXNzZXJ0RXF1YWxzKHJhbmdlMiwgcmFuZ2UxKTsKLQkJYXNzZXJ0RXF1YWxzKHJhbmdlMS5oYXNoQ29kZSgpLCByYW5nZTIuaGFzaENvZGUoKSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1JldmVyc2VDb21wYXJhdG9yVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvUmV2ZXJzZUNvbXBhcmF0b3JUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3YWUwMGZkLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvUmV2ZXJzZUNvbXBhcmF0b3JUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTAxICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uczsKLWltcG9ydCBqYXZhLnV0aWwuQ29tcGFyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuUmV2ZXJzZUNvbXBhcmF0b3I7Ci0KLXB1YmxpYyBjbGFzcyBSZXZlcnNlQ29tcGFyYXRvclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgQ29tcGFyYXRvcjxTdHJpbmc+IG5hdHVyYWxSZXZlcnNlQ29tcGFyYXRvcjsKLQlwcml2YXRlIENvbXBhcmF0b3I8U3RyaW5nPiBjdXN0b21Db21wYXJhdG9yOwotCXByaXZhdGUgQ29tcGFyYXRvcjxTdHJpbmc+IGN1c3RvbVJldmVyc2VDb21wYXJhdG9yOwotCi0JcHVibGljIFJldmVyc2VDb21wYXJhdG9yVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy5uYXR1cmFsUmV2ZXJzZUNvbXBhcmF0b3IgPSBuZXcgUmV2ZXJzZUNvbXBhcmF0b3I8U3RyaW5nPigpOwotCQl0aGlzLmN1c3RvbUNvbXBhcmF0b3IgPSB0aGlzLmJ1aWxkQ3VzdG9tQ29tcGFyYXRvcigpOwotCQl0aGlzLmN1c3RvbVJldmVyc2VDb21wYXJhdG9yID0gbmV3IFJldmVyc2VDb21wYXJhdG9yPFN0cmluZz4odGhpcy5jdXN0b21Db21wYXJhdG9yKTsKLQl9Ci0KLQlwcml2YXRlIENvbXBhcmF0b3I8U3RyaW5nPiBidWlsZEN1c3RvbUNvbXBhcmF0b3IoKSB7Ci0JCXJldHVybiBuZXcgQ29tcGFyYXRvcjxTdHJpbmc+KCkgewotCQkJcHVibGljIGludCBjb21wYXJlKFN0cmluZyBzMSwgU3RyaW5nIHMyKSB7Ci0JCQkJU3RyaW5nIGxvd2VyMSA9IHMxLnRvTG93ZXJDYXNlKCk7Ci0JCQkJU3RyaW5nIGxvd2VyMiA9IHMyLnRvTG93ZXJDYXNlKCk7Ci0JCQkJaW50IHJlc3VsdCA9IGxvd2VyMS5jb21wYXJlVG8obG93ZXIyKTsKLQkJCQlpZiAocmVzdWx0ID09IDApIHsKLQkJCQkJcmV0dXJuIHMxLmNvbXBhcmVUbyhzMik7IC8vIHVzZSBjYXNlIHRvIGRpZmZlcmVudGlhdGUgImVxdWFsIiBzdHJpbmdzCi0JCQkJfQotCQkJCXJldHVybiByZXN1bHQ7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0PFN0cmluZz4gYnVpbGRVbnNvcnRlZExpc3QoKSB7Ci0JCUxpc3Q8U3RyaW5nPiByZXN1bHQgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJcmVzdWx0LmFkZCgiVCIpOwotCQlyZXN1bHQuYWRkKCJaIik7Ci0JCXJlc3VsdC5hZGQoIlkiKTsKLQkJcmVzdWx0LmFkZCgiTSIpOwotCQlyZXN1bHQuYWRkKCJtIik7Ci0JCXJlc3VsdC5hZGQoImEiKTsKLQkJcmVzdWx0LmFkZCgiQiIpOwotCQlyZXN1bHQuYWRkKCJiIik7Ci0JCXJlc3VsdC5hZGQoIkEiKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBidWlsZE5hdHVyYWxseVNvcnRlZExpc3QoKSB7Ci0JCUxpc3Q8U3RyaW5nPiByZXN1bHQgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4odGhpcy5idWlsZFVuc29ydGVkTGlzdCgpKTsKLQkJQ29sbGVjdGlvbnMuc29ydChyZXN1bHQpOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCXByaXZhdGUgTGlzdDxTdHJpbmc+IGJ1aWxkQ3VzdG9tU29ydGVkTGlzdCgpIHsKLQkJTGlzdDxTdHJpbmc+IHJlc3VsdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPih0aGlzLmJ1aWxkVW5zb3J0ZWRMaXN0KCkpOwotCQlDb2xsZWN0aW9ucy5zb3J0KHJlc3VsdCwgdGhpcy5jdXN0b21Db21wYXJhdG9yKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5hdHVyYWwoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0ID0gdGhpcy5idWlsZFVuc29ydGVkTGlzdCgpOwotCQlDb2xsZWN0aW9ucy5zb3J0KGxpc3QsIHRoaXMubmF0dXJhbFJldmVyc2VDb21wYXJhdG9yKTsKLQkJdGhpcy52ZXJpZnlMaXN0KHRoaXMuYnVpbGROYXR1cmFsbHlTb3J0ZWRMaXN0KCksIGxpc3QpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDdXN0b20oKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0ID0gdGhpcy5idWlsZFVuc29ydGVkTGlzdCgpOwotCQlDb2xsZWN0aW9ucy5zb3J0KGxpc3QsIHRoaXMuY3VzdG9tUmV2ZXJzZUNvbXBhcmF0b3IpOwotCQl0aGlzLnZlcmlmeUxpc3QodGhpcy5idWlsZEN1c3RvbVNvcnRlZExpc3QoKSwgbGlzdCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUxpc3QoTGlzdDxTdHJpbmc+IG5vcm1hbCwgTGlzdDxTdHJpbmc+IHJldmVyc2UpIHsKLQkJaW50IHNpemUgPSBub3JtYWwuc2l6ZSgpOwotCQlpbnQgbWF4ID0gc2l6ZSAtIDE7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgc2l6ZTsgaSsrKSB7Ci0JCQlhc3NlcnRFcXVhbHMobm9ybWFsLmdldChpKSwgcmV2ZXJzZS5nZXQobWF4IC0gaSkpOwotCQl9Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9TaW1wbGVBc3NvY2lhdGlvblRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1NpbXBsZUFzc29jaWF0aW9uVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWU1ZjUzNy4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1NpbXBsZUFzc29jaWF0aW9uVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDk4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWw7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RTdWl0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Bc3NvY2lhdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TaW1wbGVBc3NvY2lhdGlvbjsKLQotcHVibGljIGNsYXNzIFNpbXBsZUFzc29jaWF0aW9uVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBTaW1wbGVBc3NvY2lhdGlvbjxTdHJpbmcsIFN0cmluZz4gYXNzb2M7Ci0KLQlwdWJsaWMgc3RhdGljIFRlc3Qgc3VpdGUoKSB7Ci0JCXJldHVybiBuZXcgVGVzdFN1aXRlKFNpbXBsZUFzc29jaWF0aW9uVGVzdHMuY2xhc3MpOwotCX0KLQkKLQlwdWJsaWMgU2ltcGxlQXNzb2NpYXRpb25UZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLmFzc29jID0gbmV3IFNpbXBsZUFzc29jaWF0aW9uPFN0cmluZywgU3RyaW5nPigiZm9vIiwgImJhciIpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0R2V0S2V5KCkgewotCQlhc3NlcnRFcXVhbHMoImZvbyIsIHRoaXMuYXNzb2Mua2V5KCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRWYWx1ZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKCJiYXIiLCB0aGlzLmFzc29jLnZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRWYWx1ZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKCJiYXIiLCB0aGlzLmFzc29jLnZhbHVlKCkpOwotCQl0aGlzLmFzc29jLnNldFZhbHVlKCJiYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXoiLCB0aGlzLmFzc29jLnZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RFcXVhbHMoKSB7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmFzc29jLCB0aGlzLmNvcHkodGhpcy5hc3NvYykpOwotCi0JCVNpbXBsZUFzc29jaWF0aW9uPFN0cmluZywgU3RyaW5nPiBhc3NvYzIgPSBuZXcgU2ltcGxlQXNzb2NpYXRpb248U3RyaW5nLCBTdHJpbmc+KCJmb28iLCAiYmF6Iik7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYXNzb2MuZXF1YWxzKGFzc29jMikpOwotCi0JCWFzc29jMiA9IG5ldyBTaW1wbGVBc3NvY2lhdGlvbjxTdHJpbmcsIFN0cmluZz4oImZvcCIsICJiYXIiKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5hc3NvYy5lcXVhbHMoYXNzb2MyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc2hDb2RlKCkgewotCQlhc3NlcnRFcXVhbHModGhpcy5hc3NvYy5oYXNoQ29kZSgpLCB0aGlzLmNvcHkodGhpcy5hc3NvYykuaGFzaENvZGUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENsb25lKCkgewotCQl0aGlzLnZlcmlmeUNsb25lKHRoaXMuYXNzb2MsIHRoaXMuYXNzb2MuY2xvbmUoKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUNsb25lKEFzc29jaWF0aW9uPFN0cmluZywgU3RyaW5nPiBleHBlY3RlZCwgQXNzb2NpYXRpb248U3RyaW5nLCBTdHJpbmc+IGFjdHVhbCkgewotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIGFjdHVhbCk7Ci0JCWFzc2VydE5vdFNhbWUoZXhwZWN0ZWQsIGFjdHVhbCk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5rZXkoKSwgYWN0dWFsLmtleSgpKTsKLQkJYXNzZXJ0U2FtZShleHBlY3RlZC5rZXkoKSwgYWN0dWFsLmtleSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLnZhbHVlKCksIGFjdHVhbC52YWx1ZSgpKTsKLQkJYXNzZXJ0U2FtZShleHBlY3RlZC52YWx1ZSgpLCBhY3R1YWwudmFsdWUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNlcmlhbGl6YXRpb24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJQFN1cHByZXNzV2FybmluZ3MoImNhc3QiKQotCQlBc3NvY2lhdGlvbjxTdHJpbmcsIFN0cmluZz4gYXNzb2MyID0gKEFzc29jaWF0aW9uPFN0cmluZywgU3RyaW5nPikgVGVzdFRvb2xzLnNlcmlhbGl6ZSh0aGlzLmFzc29jKTsKLQotCQlhc3NlcnRFcXVhbHModGhpcy5hc3NvYywgYXNzb2MyKTsKLQkJYXNzZXJ0Tm90U2FtZSh0aGlzLmFzc29jLCBhc3NvYzIpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hc3NvYy5rZXkoKSwgYXNzb2MyLmtleSgpKTsKLQkJYXNzZXJ0Tm90U2FtZSh0aGlzLmFzc29jLmtleSgpLCBhc3NvYzIua2V5KCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hc3NvYy52YWx1ZSgpLCBhc3NvYzIudmFsdWUoKSk7Ci0JCWFzc2VydE5vdFNhbWUodGhpcy5hc3NvYy52YWx1ZSgpLCBhc3NvYzIudmFsdWUoKSk7Ci0JfQotCi0JcHJpdmF0ZSBTaW1wbGVBc3NvY2lhdGlvbjxTdHJpbmcsIFN0cmluZz4gY29weShTaW1wbGVBc3NvY2lhdGlvbjxTdHJpbmcsIFN0cmluZz4gc2EpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVBc3NvY2lhdGlvbjxTdHJpbmcsIFN0cmluZz4oc2Eua2V5KCksIHNhLnZhbHVlKCkpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9TaW1wbGVTdGFja1Rlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1NpbXBsZVN0YWNrVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjFlOTc4OS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1NpbXBsZVN0YWNrVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE0MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsOwotCi1pbXBvcnQgamF2YS51dGlsLkVtcHR5U3RhY2tFeGNlcHRpb247Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlNpbXBsZVN0YWNrOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlN0YWNrOwotCi1wdWJsaWMgY2xhc3MgU2ltcGxlU3RhY2tUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBTaW1wbGVTdGFja1Rlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJc0VtcHR5KCkgewotCQlTdGFjazxTdHJpbmc+IHN0YWNrID0gbmV3IFNpbXBsZVN0YWNrPFN0cmluZz4oKTsKLQkJYXNzZXJ0VHJ1ZShzdGFjay5pc0VtcHR5KCkpOwotCQlzdGFjay5wdXNoKCJmaXJzdCIpOwotCQlhc3NlcnRGYWxzZShzdGFjay5pc0VtcHR5KCkpOwotCQlzdGFjay5wdXNoKCJzZWNvbmQiKTsKLQkJYXNzZXJ0RmFsc2Uoc3RhY2suaXNFbXB0eSgpKTsKLQkJc3RhY2sucG9wKCk7Ci0JCWFzc2VydEZhbHNlKHN0YWNrLmlzRW1wdHkoKSk7Ci0JCXN0YWNrLnBvcCgpOwotCQlhc3NlcnRUcnVlKHN0YWNrLmlzRW1wdHkoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFB1c2hBbmRQb3AoKSB7Ci0JCVN0YWNrPFN0cmluZz4gc3RhY2sgPSBuZXcgU2ltcGxlU3RhY2s8U3RyaW5nPigpOwotCQlTdHJpbmcgZmlyc3QgPSAiZmlyc3QiOwotCQlTdHJpbmcgc2Vjb25kID0gInNlY29uZCI7Ci0KLQkJc3RhY2sucHVzaChmaXJzdCk7Ci0JCXN0YWNrLnB1c2goc2Vjb25kKTsKLQkJYXNzZXJ0RXF1YWxzKHNlY29uZCwgc3RhY2sucG9wKCkpOwotCQlhc3NlcnRFcXVhbHMoZmlyc3QsIHN0YWNrLnBvcCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UHVzaEFuZFBlZWsoKSB7Ci0JCVN0YWNrPFN0cmluZz4gc3RhY2sgPSBuZXcgU2ltcGxlU3RhY2s8U3RyaW5nPigpOwotCQlTdHJpbmcgZmlyc3QgPSAiZmlyc3QiOwotCQlTdHJpbmcgc2Vjb25kID0gInNlY29uZCI7Ci0KLQkJc3RhY2sucHVzaChmaXJzdCk7Ci0JCXN0YWNrLnB1c2goc2Vjb25kKTsKLQkJYXNzZXJ0RXF1YWxzKHNlY29uZCwgc3RhY2sucGVlaygpKTsKLQkJYXNzZXJ0RXF1YWxzKHNlY29uZCwgc3RhY2sucGVlaygpKTsKLQkJYXNzZXJ0RXF1YWxzKHNlY29uZCwgc3RhY2sucG9wKCkpOwotCQlhc3NlcnRFcXVhbHMoZmlyc3QsIHN0YWNrLnBlZWsoKSk7Ci0JCWFzc2VydEVxdWFscyhmaXJzdCwgc3RhY2sucGVlaygpKTsKLQkJYXNzZXJ0RXF1YWxzKGZpcnN0LCBzdGFjay5wb3AoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEVtcHR5U3RhY2tFeGNlcHRpb25QZWVrKCkgewotCQlTdGFjazxTdHJpbmc+IHN0YWNrID0gbmV3IFNpbXBsZVN0YWNrPFN0cmluZz4oKTsKLQkJU3RyaW5nIGZpcnN0ID0gImZpcnN0IjsKLQkJU3RyaW5nIHNlY29uZCA9ICJzZWNvbmQiOwotCi0JCXN0YWNrLnB1c2goZmlyc3QpOwotCQlzdGFjay5wdXNoKHNlY29uZCk7Ci0JCWFzc2VydEVxdWFscyhzZWNvbmQsIHN0YWNrLnBlZWsoKSk7Ci0JCWFzc2VydEVxdWFscyhzZWNvbmQsIHN0YWNrLnBvcCgpKTsKLQkJYXNzZXJ0RXF1YWxzKGZpcnN0LCBzdGFjay5wZWVrKCkpOwotCQlhc3NlcnRFcXVhbHMoZmlyc3QsIHN0YWNrLnBvcCgpKTsKLQotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlzdGFjay5wZWVrKCk7Ci0JCX0gY2F0Y2ggKEVtcHR5U3RhY2tFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RW1wdHlTdGFja0V4Y2VwdGlvblBvcCgpIHsKLQkJU3RhY2s8U3RyaW5nPiBzdGFjayA9IG5ldyBTaW1wbGVTdGFjazxTdHJpbmc+KCk7Ci0JCVN0cmluZyBmaXJzdCA9ICJmaXJzdCI7Ci0JCVN0cmluZyBzZWNvbmQgPSAic2Vjb25kIjsKLQotCQlzdGFjay5wdXNoKGZpcnN0KTsKLQkJc3RhY2sucHVzaChzZWNvbmQpOwotCQlhc3NlcnRFcXVhbHMoc2Vjb25kLCBzdGFjay5wZWVrKCkpOwotCQlhc3NlcnRFcXVhbHMoc2Vjb25kLCBzdGFjay5wb3AoKSk7Ci0JCWFzc2VydEVxdWFscyhmaXJzdCwgc3RhY2sucGVlaygpKTsKLQkJYXNzZXJ0RXF1YWxzKGZpcnN0LCBzdGFjay5wb3AoKSk7Ci0KLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJc3RhY2sucG9wKCk7Ci0JCX0gY2F0Y2ggKEVtcHR5U3RhY2tFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2xvbmUoKSB7Ci0JCVNpbXBsZVN0YWNrPFN0cmluZz4gc3RhY2sgPSBuZXcgU2ltcGxlU3RhY2s8U3RyaW5nPigpOwotCQlzdGFjay5wdXNoKCJmaXJzdCIpOwotCQlzdGFjay5wdXNoKCJzZWNvbmQiKTsKLQkJc3RhY2sucHVzaCgidGhpcmQiKTsKLQotCQl0aGlzLnZlcmlmeUNsb25lKHN0YWNrLCBzdGFjay5jbG9uZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2VyaWFsaXphdGlvbigpIHRocm93cyBFeGNlcHRpb24gewotCQlTaW1wbGVTdGFjazxTdHJpbmc+IHN0YWNrID0gbmV3IFNpbXBsZVN0YWNrPFN0cmluZz4oKTsKLQkJc3RhY2sucHVzaCgiZmlyc3QiKTsKLQkJc3RhY2sucHVzaCgic2Vjb25kIik7Ci0JCXN0YWNrLnB1c2goInRoaXJkIik7Ci0KLQkJdGhpcy52ZXJpZnlDbG9uZShzdGFjaywgVGVzdFRvb2xzLnNlcmlhbGl6ZShzdGFjaykpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlDbG9uZShTdGFjazxTdHJpbmc+IG9yaWdpbmFsLCBTdGFjazxTdHJpbmc+IGNsb25lKSB7Ci0JCWFzc2VydE5vdFNhbWUob3JpZ2luYWwsIGNsb25lKTsKLQkJYXNzZXJ0RXF1YWxzKG9yaWdpbmFsLnBlZWsoKSwgY2xvbmUucGVlaygpKTsKLQkJYXNzZXJ0RXF1YWxzKG9yaWdpbmFsLnBvcCgpLCBjbG9uZS5wb3AoKSk7Ci0JCWFzc2VydEVxdWFscyhvcmlnaW5hbC5wZWVrKCksIGNsb25lLnBlZWsoKSk7Ci0JCWFzc2VydEVxdWFscyhvcmlnaW5hbC5wb3AoKSwgY2xvbmUucG9wKCkpOwotCQlhc3NlcnRFcXVhbHMob3JpZ2luYWwuaXNFbXB0eSgpLCBjbG9uZS5pc0VtcHR5KCkpOwotCQlhc3NlcnRFcXVhbHMob3JpZ2luYWwucGVlaygpLCBjbG9uZS5wZWVrKCkpOwotCQlhc3NlcnRFcXVhbHMob3JpZ2luYWwucG9wKCksIGNsb25lLnBvcCgpKTsKLQkJYXNzZXJ0VHJ1ZShvcmlnaW5hbC5pc0VtcHR5KCkpOwotCQlhc3NlcnRFcXVhbHMob3JpZ2luYWwuaXNFbXB0eSgpLCBjbG9uZS5pc0VtcHR5KCkpOwotCi0JCW9yaWdpbmFsLnB1c2goImZvdXJ0aCIpOwotCQlhc3NlcnRGYWxzZShvcmlnaW5hbC5pc0VtcHR5KCkpOwotCQkvLyBjbG9uZSBzaG91bGQgc3RpbGwgYmUgZW1wdHkKLQkJYXNzZXJ0VHJ1ZShjbG9uZS5pc0VtcHR5KCkpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9TdHJpbmdUb29sc1Rlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1N0cmluZ1Rvb2xzVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMGVjMWE1Ni4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1N0cmluZ1Rvb2xzVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE2NTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGphdmEuaW8uU3RyaW5nV3JpdGVyOwotaW1wb3J0IGphdmEuaW8uV3JpdGVyOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLQotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgY2xhc3MgU3RyaW5nVG9vbHNUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBTdHJpbmdUb29sc1Rlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCXByaXZhdGUgc3RhdGljIHZvaWQgYXNzZXJ0RXF1YWxzKFN0cmluZyBleHBlY3RlZCwgY2hhcltdIGFjdHVhbCkgewotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIG5ldyBTdHJpbmcoYWN0dWFsKSk7Ci0JfQotCi0JLy8gKioqKioqKioqKiBwYWRkaW5nL3RydW5jYXRpbmcgKioqKioqKioqKgotCi0JcHVibGljIHZvaWQgdGVzdFBhZCgpIHsKLQkJYXNzZXJ0RXF1YWxzKCJmcmVkIiwgU3RyaW5nVG9vbHMucGFkKCJmcmVkIiwgNCkpOwotCQlhc3NlcnRFcXVhbHMoImZyZWQgICIsIFN0cmluZ1Rvb2xzLnBhZCgiZnJlZCIsIDYpKTsKLQkJYm9vbGVhbiBleFRocm93biA9IGZhbHNlOwotCQl0cnkgewotCQkJYXNzZXJ0RXF1YWxzKCJmciIsIFN0cmluZ1Rvb2xzLnBhZCgiZnJlZCIsIDIpKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleFRocm93biA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleFRocm93bik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFBhZENoYXJBcnJheSgpIHsKLQkJYXNzZXJ0RXF1YWxzKCJmcmVkIiwgU3RyaW5nVG9vbHMucGFkKG5ldyBjaGFyW10geyAnZicsICdyJywgJ2UnLCAnZCcgfSwgNCkpOwotCQlhc3NlcnRFcXVhbHMoImZyZWQgICIsIFN0cmluZ1Rvb2xzLnBhZChuZXcgY2hhcltdIHsgJ2YnLCAncicsICdlJywgJ2QnIH0sIDYpKTsKLQkJYm9vbGVhbiBleFRocm93biA9IGZhbHNlOwotCQl0cnkgewotCQkJYXNzZXJ0RXF1YWxzKCJmciIsIFN0cmluZ1Rvb2xzLnBhZChuZXcgY2hhcltdIHsgJ2YnLCAncicsICdlJywgJ2QnIH0sIDIpKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleFRocm93biA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleFRocm93bik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFBhZE9uV3JpdGVyKCkgewotCQlXcml0ZXIgd3JpdGVyOwotCQl3cml0ZXIgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnBhZE9uKCJmcmVkIiwgNCwgd3JpdGVyKTsKLQkJYXNzZXJ0RXF1YWxzKCJmcmVkIiwgd3JpdGVyLnRvU3RyaW5nKCkpOwotCi0JCXdyaXRlciA9IG5ldyBTdHJpbmdXcml0ZXIoKTsKLQkJU3RyaW5nVG9vbHMucGFkT24oImZyZWQiLCA2LCB3cml0ZXIpOwotCQlhc3NlcnRFcXVhbHMoImZyZWQgICIsIHdyaXRlci50b1N0cmluZygpKTsKLQotCQl3cml0ZXIgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCWJvb2xlYW4gZXhUaHJvd24gPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCVN0cmluZ1Rvb2xzLnBhZE9uKCJmcmVkIiwgMiwgd3JpdGVyKTsKLQkJCWZhaWwoKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleFRocm93biA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleFRocm93bik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFBhZE9uU3RyaW5nQnVmZmVyKCkgewotCQlTdHJpbmdCdWZmZXIgc2I7Ci0JCXNiID0gbmV3IFN0cmluZ0J1ZmZlcigpOwotCQlTdHJpbmdUb29scy5wYWRPbigiZnJlZCIsIDQsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKCJmcmVkIiwgc2IudG9TdHJpbmcoKSk7Ci0KLQkJc2IgPSBuZXcgU3RyaW5nQnVmZmVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnBhZE9uKCJmcmVkIiwgNiwgc2IpOwotCQlhc3NlcnRFcXVhbHMoImZyZWQgICIsIHNiLnRvU3RyaW5nKCkpOwotCi0JCXNiID0gbmV3IFN0cmluZ0J1ZmZlcigpOwotCQlib29sZWFuIGV4VGhyb3duID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlTdHJpbmdUb29scy5wYWRPbigiZnJlZCIsIDIsIHNiKTsKLQkJCWZhaWwoKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleFRocm93biA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleFRocm93bik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFBhZE9uU3RyaW5nQnVpbGRlcigpIHsKLQkJU3RyaW5nQnVpbGRlciBzYjsKLQkJc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQlTdHJpbmdUb29scy5wYWRPbigiZnJlZCIsIDQsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKCJmcmVkIiwgc2IudG9TdHJpbmcoKSk7Ci0KLQkJc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQlTdHJpbmdUb29scy5wYWRPbigiZnJlZCIsIDYsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKCJmcmVkICAiLCBzYi50b1N0cmluZygpKTsKLQotCQlzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7Ci0JCWJvb2xlYW4gZXhUaHJvd24gPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCVN0cmluZ1Rvb2xzLnBhZE9uKCJmcmVkIiwgMiwgc2IpOwotCQkJZmFpbCgpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4VGhyb3duID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4VGhyb3duKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UGFkT3JUcnVuY2F0ZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKCJmcmVkIiwgU3RyaW5nVG9vbHMucGFkT3JUcnVuY2F0ZSgiZnJlZCIsIDQpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmcmVkICAiLCBTdHJpbmdUb29scy5wYWRPclRydW5jYXRlKCJmcmVkIiwgNikpOwotCQlhc3NlcnRFcXVhbHMoImZyIiwgU3RyaW5nVG9vbHMucGFkT3JUcnVuY2F0ZSgiZnJlZCIsIDIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UGFkT3JUcnVuY2F0ZUNoYXJBcnJheSgpIHsKLQkJYXNzZXJ0RXF1YWxzKCJmcmVkIiwgU3RyaW5nVG9vbHMucGFkT3JUcnVuY2F0ZShuZXcgY2hhcltdIHsgJ2YnLCAncicsICdlJywgJ2QnIH0sIDQpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmcmVkICAiLCBTdHJpbmdUb29scy5wYWRPclRydW5jYXRlKG5ldyBjaGFyW10geyAnZicsICdyJywgJ2UnLCAnZCcgfSwgNikpOwotCQlhc3NlcnRFcXVhbHMoImZyIiwgU3RyaW5nVG9vbHMucGFkT3JUcnVuY2F0ZShuZXcgY2hhcltdIHsgJ2YnLCAncicsICdlJywgJ2QnIH0sIDIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UGFkT3JUcnVuY2F0ZU9uV3JpdGVyKCkgewotCQl0aGlzLnZlcmlmeVBhZE9yVHJ1bmNhdGVPbldyaXRlcigiZnJlZCIsICJmcmVkIiwgNCk7Ci0JCXRoaXMudmVyaWZ5UGFkT3JUcnVuY2F0ZU9uV3JpdGVyKCJmcmVkICAiLCAiZnJlZCIsIDYpOwotCQl0aGlzLnZlcmlmeVBhZE9yVHJ1bmNhdGVPbldyaXRlcigiZnIiLCAiZnJlZCIsIDIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlQYWRPclRydW5jYXRlT25Xcml0ZXIoU3RyaW5nIGV4cGVjdGVkLCBTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoKSB7Ci0JCVdyaXRlciB3cml0ZXIgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnBhZE9yVHJ1bmNhdGVPbihzdHJpbmcsIGxlbmd0aCwgd3JpdGVyKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCB3cml0ZXIudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFBhZE9yVHJ1bmNhdGVPblN0cmluZ0J1ZmZlcigpIHsKLQkJdGhpcy52ZXJpZnlQYWRPclRydW5jYXRlT25TdHJpbmdCdWZmZXIoImZyZWQiLCAiZnJlZCIsIDQpOwotCQl0aGlzLnZlcmlmeVBhZE9yVHJ1bmNhdGVPblN0cmluZ0J1ZmZlcigiZnJlZCAgIiwgImZyZWQiLCA2KTsKLQkJdGhpcy52ZXJpZnlQYWRPclRydW5jYXRlT25TdHJpbmdCdWZmZXIoImZyIiwgImZyZWQiLCAyKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UGFkT3JUcnVuY2F0ZU9uU3RyaW5nQnVmZmVyKFN0cmluZyBleHBlY3RlZCwgU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCkgewotCQlTdHJpbmdCdWZmZXIgc2IgPSBuZXcgU3RyaW5nQnVmZmVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnBhZE9yVHJ1bmNhdGVPbihzdHJpbmcsIGxlbmd0aCwgc2IpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHNiLnRvU3RyaW5nKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RQYWRPclRydW5jYXRlT25TdHJpbmdCdWlsZGVyKCkgewotCQl0aGlzLnZlcmlmeVBhZE9yVHJ1bmNhdGVPblN0cmluZ0J1aWxkZXIoImZyZWQiLCAiZnJlZCIsIDQpOwotCQl0aGlzLnZlcmlmeVBhZE9yVHJ1bmNhdGVPblN0cmluZ0J1aWxkZXIoImZyZWQgICIsICJmcmVkIiwgNik7Ci0JCXRoaXMudmVyaWZ5UGFkT3JUcnVuY2F0ZU9uU3RyaW5nQnVpbGRlcigiZnIiLCAiZnJlZCIsIDIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlQYWRPclRydW5jYXRlT25TdHJpbmdCdWlsZGVyKFN0cmluZyBleHBlY3RlZCwgU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCkgewotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKLQkJU3RyaW5nVG9vbHMucGFkT3JUcnVuY2F0ZU9uKHN0cmluZywgbGVuZ3RoLCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgc2IudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFplcm9QYWQoKSB7Ci0JCWFzc2VydEVxdWFscygiMTIzNCIsIFN0cmluZ1Rvb2xzLnplcm9QYWQoIjEyMzQiLCA0KSk7Ci0JCWFzc2VydEVxdWFscygiMDAxMjM0IiwgU3RyaW5nVG9vbHMuemVyb1BhZCgiMTIzNCIsIDYpKTsKLQkJYm9vbGVhbiBleFRocm93biA9IGZhbHNlOwotCQl0cnkgewotCQkJYXNzZXJ0RXF1YWxzKCIxMiIsIFN0cmluZ1Rvb2xzLnplcm9QYWQoIjEyMzQiLCAyKSk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhUaHJvd24gPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhUaHJvd24pOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RaZXJvUGFkQ2hhckFycmF5KCkgewotCQlhc3NlcnRFcXVhbHMoIjEyMzQiLCBTdHJpbmdUb29scy56ZXJvUGFkKG5ldyBjaGFyW10geyAnMScsICcyJywgJzMnLCAnNCcgfSwgNCkpOwotCQlhc3NlcnRFcXVhbHMoIjAwMTIzNCIsIFN0cmluZ1Rvb2xzLnplcm9QYWQobmV3IGNoYXJbXSB7ICcxJywgJzInLCAnMycsICc0JyB9LCA2KSk7Ci0JCWJvb2xlYW4gZXhUaHJvd24gPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCWFzc2VydEVxdWFscygiMTIiLCBTdHJpbmdUb29scy56ZXJvUGFkKG5ldyBjaGFyW10geyAnMScsICcyJywgJzMnLCAnNCcgfSwgMikpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4VGhyb3duID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4VGhyb3duKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0WmVyb1BhZE9uV3JpdGVyKCkgewotCQlXcml0ZXIgd3JpdGVyOwotCQl3cml0ZXIgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnplcm9QYWRPbigiMTIzNCIsIDQsIHdyaXRlcik7Ci0JCWFzc2VydEVxdWFscygiMTIzNCIsIHdyaXRlci50b1N0cmluZygpKTsKLQotCQl3cml0ZXIgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnplcm9QYWRPbigiMTIzNCIsIDYsIHdyaXRlcik7Ci0JCWFzc2VydEVxdWFscygiMDAxMjM0Iiwgd3JpdGVyLnRvU3RyaW5nKCkpOwotCi0JCXdyaXRlciA9IG5ldyBTdHJpbmdXcml0ZXIoKTsKLQkJYm9vbGVhbiBleFRocm93biA9IGZhbHNlOwotCQl0cnkgewotCQkJU3RyaW5nVG9vbHMuemVyb1BhZE9uKCIxMjM0IiwgMiwgd3JpdGVyKTsKLQkJCWZhaWwoKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleFRocm93biA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleFRocm93bik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFplcm9QYWRPblN0cmluZ0J1ZmZlcigpIHsKLQkJU3RyaW5nQnVmZmVyIHNiOwotCQlzYiA9IG5ldyBTdHJpbmdCdWZmZXIoKTsKLQkJU3RyaW5nVG9vbHMuemVyb1BhZE9uKCIxMjM0IiwgNCwgc2IpOwotCQlhc3NlcnRFcXVhbHMoIjEyMzQiLCBzYi50b1N0cmluZygpKTsKLQotCQlzYiA9IG5ldyBTdHJpbmdCdWZmZXIoKTsKLQkJU3RyaW5nVG9vbHMuemVyb1BhZE9uKCIxMjM0IiwgNiwgc2IpOwotCQlhc3NlcnRFcXVhbHMoIjAwMTIzNCIsIHNiLnRvU3RyaW5nKCkpOwotCi0JCXNiID0gbmV3IFN0cmluZ0J1ZmZlcigpOwotCQlib29sZWFuIGV4VGhyb3duID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlTdHJpbmdUb29scy56ZXJvUGFkT24oIjEyMzQiLCAyLCBzYik7Ci0JCQlmYWlsKCk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhUaHJvd24gPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhUaHJvd24pOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RaZXJvUGFkT25TdHJpbmdCdWlsZGVyKCkgewotCQlTdHJpbmdCdWlsZGVyIHNiOwotCQlzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnplcm9QYWRPbigiMTIzNCIsIDQsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKCIxMjM0Iiwgc2IudG9TdHJpbmcoKSk7Ci0KLQkJc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQlTdHJpbmdUb29scy56ZXJvUGFkT24oIjEyMzQiLCA2LCBzYik7Ci0JCWFzc2VydEVxdWFscygiMDAxMjM0Iiwgc2IudG9TdHJpbmcoKSk7Ci0KLQkJc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQlib29sZWFuIGV4VGhyb3duID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlTdHJpbmdUb29scy56ZXJvUGFkT24oIjEyMzQiLCAyLCBzYik7Ci0JCQlmYWlsKCk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhUaHJvd24gPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhUaHJvd24pOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RaZXJvUGFkT3JUcnVuY2F0ZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKCIxMjM0IiwgU3RyaW5nVG9vbHMuemVyb1BhZE9yVHJ1bmNhdGUoIjEyMzQiLCA0KSk7Ci0JCWFzc2VydEVxdWFscygiMDAxMjM0IiwgU3RyaW5nVG9vbHMuemVyb1BhZE9yVHJ1bmNhdGUoIjEyMzQiLCA2KSk7Ci0JCWFzc2VydEVxdWFscygiMzQiLCBTdHJpbmdUb29scy56ZXJvUGFkT3JUcnVuY2F0ZSgiMTIzNCIsIDIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0WmVyb1BhZE9yVHJ1bmNhdGVDaGFyQXJyYXkoKSB7Ci0JCWFzc2VydEVxdWFscygiMTIzNCIsIFN0cmluZ1Rvb2xzLnplcm9QYWRPclRydW5jYXRlKG5ldyBjaGFyW10geyAnMScsICcyJywgJzMnLCAnNCcgfSwgNCkpOwotCQlhc3NlcnRFcXVhbHMoIjAwMTIzNCIsIFN0cmluZ1Rvb2xzLnplcm9QYWRPclRydW5jYXRlKG5ldyBjaGFyW10geyAnMScsICcyJywgJzMnLCAnNCcgfSwgNikpOwotCQlhc3NlcnRFcXVhbHMoIjM0IiwgU3RyaW5nVG9vbHMuemVyb1BhZE9yVHJ1bmNhdGUobmV3IGNoYXJbXSB7ICcxJywgJzInLCAnMycsICc0JyB9LCAyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFplcm9QYWRPclRydW5jYXRlT25Xcml0ZXIoKSB7Ci0JCXRoaXMudmVyaWZ5WmVyb1BhZE9yVHJ1bmNhdGVPbldyaXRlcigiMTIzNCIsICIxMjM0IiwgNCk7Ci0JCXRoaXMudmVyaWZ5WmVyb1BhZE9yVHJ1bmNhdGVPbldyaXRlcigiMDAxMjM0IiwgIjEyMzQiLCA2KTsKLQkJdGhpcy52ZXJpZnlaZXJvUGFkT3JUcnVuY2F0ZU9uV3JpdGVyKCIzNCIsICIxMjM0IiwgMik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVplcm9QYWRPclRydW5jYXRlT25Xcml0ZXIoU3RyaW5nIGV4cGVjdGVkLCBTdHJpbmcgc3RyaW5nLCBpbnQgbGVuZ3RoKSB7Ci0JCVdyaXRlciB3cml0ZXIgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnplcm9QYWRPclRydW5jYXRlT24oc3RyaW5nLCBsZW5ndGgsIHdyaXRlcik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgd3JpdGVyLnRvU3RyaW5nKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RaZXJvUGFkT3JUcnVuY2F0ZU9uU3RyaW5nQnVmZmVyKCkgewotCQl0aGlzLnZlcmlmeVplcm9QYWRPclRydW5jYXRlT25TdHJpbmdCdWZmZXIoIjEyMzQiLCAiMTIzNCIsIDQpOwotCQl0aGlzLnZlcmlmeVplcm9QYWRPclRydW5jYXRlT25TdHJpbmdCdWZmZXIoIjAwMTIzNCIsICIxMjM0IiwgNik7Ci0JCXRoaXMudmVyaWZ5WmVyb1BhZE9yVHJ1bmNhdGVPblN0cmluZ0J1ZmZlcigiMzQiLCAiMTIzNCIsIDIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlaZXJvUGFkT3JUcnVuY2F0ZU9uU3RyaW5nQnVmZmVyKFN0cmluZyBleHBlY3RlZCwgU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCkgewotCQlTdHJpbmdCdWZmZXIgc2IgPSBuZXcgU3RyaW5nQnVmZmVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnplcm9QYWRPclRydW5jYXRlT24oc3RyaW5nLCBsZW5ndGgsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBzYi50b1N0cmluZygpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0WmVyb1BhZE9yVHJ1bmNhdGVPblN0cmluZ0J1aWxkZXIoKSB7Ci0JCXRoaXMudmVyaWZ5WmVyb1BhZE9yVHJ1bmNhdGVPblN0cmluZ0J1aWxkZXIoIjEyMzQiLCAiMTIzNCIsIDQpOwotCQl0aGlzLnZlcmlmeVplcm9QYWRPclRydW5jYXRlT25TdHJpbmdCdWlsZGVyKCIwMDEyMzQiLCAiMTIzNCIsIDYpOwotCQl0aGlzLnZlcmlmeVplcm9QYWRPclRydW5jYXRlT25TdHJpbmdCdWlsZGVyKCIzNCIsICIxMjM0IiwgMik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVplcm9QYWRPclRydW5jYXRlT25TdHJpbmdCdWlsZGVyKFN0cmluZyBleHBlY3RlZCwgU3RyaW5nIHN0cmluZywgaW50IGxlbmd0aCkgewotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKLQkJU3RyaW5nVG9vbHMuemVyb1BhZE9yVHJ1bmNhdGVPbihzdHJpbmcsIGxlbmd0aCwgc2IpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHNiLnRvU3RyaW5nKCkpOwotCX0KLQotCS8vICoqKioqKioqKiogZGVsaW1pdGluZyAqKioqKioqKioqCi0KLQlwdWJsaWMgdm9pZCB0ZXN0RGVsaW1pdCgpIHsKLQkJdGhpcy52ZXJpZnlEZWxpbWl0KCJFbXBsb3llZSIsICIxMjMiLCAiMTIzRW1wbG95ZWUxMjMiKTsKLQkJdGhpcy52ZXJpZnlEZWxpbWl0KCIxMjMiLCAiMTIzIiwgIjEyMzEyMzEyMyIpOwotCQl0aGlzLnZlcmlmeURlbGltaXQoIiIsICIxMjMiLCAiMTIzMTIzIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeURlbGltaXQoU3RyaW5nIHN0cmluZywgU3RyaW5nIGRlbGltaXRlciwgU3RyaW5nIGV4cGVjdGVkU3RyaW5nKSB7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZFN0cmluZywgU3RyaW5nVG9vbHMuZGVsaW1pdChzdHJpbmcsIGRlbGltaXRlcikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3REZWxpbWl0T25Xcml0ZXIoKSB7Ci0JCXRoaXMudmVyaWZ5RGVsaW1pdE9uV3JpdGVyKCJFbXBsb3llZSIsICIxMjMiLCAiMTIzRW1wbG95ZWUxMjMiKTsKLQkJdGhpcy52ZXJpZnlEZWxpbWl0T25Xcml0ZXIoIjEyMyIsICIxMjMiLCAiMTIzMTIzMTIzIik7Ci0JCXRoaXMudmVyaWZ5RGVsaW1pdE9uV3JpdGVyKCIiLCAiMTIzIiwgIjEyMzEyMyIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlEZWxpbWl0T25Xcml0ZXIoU3RyaW5nIHN0cmluZywgU3RyaW5nIGRlbGltaXRlciwgU3RyaW5nIGV4cGVjdGVkU3RyaW5nKSB7Ci0JCVdyaXRlciB3cml0ZXIgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLmRlbGltaXRPbihzdHJpbmcsIGRlbGltaXRlciwgd3JpdGVyKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkU3RyaW5nLCB3cml0ZXIudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdERlbGltaXRPblN0cmluZ0J1ZmZlcigpIHsKLQkJdGhpcy52ZXJpZnlEZWxpbWl0T25TdHJpbmdCdWZmZXIoIkVtcGxveWVlIiwgIjEyMyIsICIxMjNFbXBsb3llZTEyMyIpOwotCQl0aGlzLnZlcmlmeURlbGltaXRPblN0cmluZ0J1ZmZlcigiMTIzIiwgIjEyMyIsICIxMjMxMjMxMjMiKTsKLQkJdGhpcy52ZXJpZnlEZWxpbWl0T25TdHJpbmdCdWZmZXIoIiIsICIxMjMiLCAiMTIzMTIzIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeURlbGltaXRPblN0cmluZ0J1ZmZlcihTdHJpbmcgc3RyaW5nLCBTdHJpbmcgZGVsaW1pdGVyLCBTdHJpbmcgZXhwZWN0ZWRTdHJpbmcpIHsKLQkJU3RyaW5nQnVmZmVyIHNiID0gbmV3IFN0cmluZ0J1ZmZlcigpOwotCQlTdHJpbmdUb29scy5kZWxpbWl0T24oc3RyaW5nLCBkZWxpbWl0ZXIsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkU3RyaW5nLCBzYi50b1N0cmluZygpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGVsaW1pdE9uU3RyaW5nQnVpbGRlcigpIHsKLQkJdGhpcy52ZXJpZnlEZWxpbWl0T25TdHJpbmdCdWlsZGVyKCJFbXBsb3llZSIsICIxMjMiLCAiMTIzRW1wbG95ZWUxMjMiKTsKLQkJdGhpcy52ZXJpZnlEZWxpbWl0T25TdHJpbmdCdWlsZGVyKCIxMjMiLCAiMTIzIiwgIjEyMzEyMzEyMyIpOwotCQl0aGlzLnZlcmlmeURlbGltaXRPblN0cmluZ0J1aWxkZXIoIiIsICIxMjMiLCAiMTIzMTIzIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeURlbGltaXRPblN0cmluZ0J1aWxkZXIoU3RyaW5nIHN0cmluZywgU3RyaW5nIGRlbGltaXRlciwgU3RyaW5nIGV4cGVjdGVkU3RyaW5nKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQlTdHJpbmdUb29scy5kZWxpbWl0T24oc3RyaW5nLCBkZWxpbWl0ZXIsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkU3RyaW5nLCBzYi50b1N0cmluZygpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UXVvdGUoKSB7Ci0JCXRoaXMudmVyaWZ5UXVvdGUoIkVtcGxveWVlIiwgIlwiRW1wbG95ZWVcIiIpOwotCQl0aGlzLnZlcmlmeVF1b3RlKCIxMjMiLCAiXCIxMjNcIiIpOwotCQl0aGlzLnZlcmlmeVF1b3RlKCIiLCAiXCJcIiIpOwotCQl0aGlzLnZlcmlmeVF1b3RlKCJFbXBcImxveWVlIiwgIlwiRW1wXCJcImxveWVlXCIiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UXVvdGUoU3RyaW5nIHN0cmluZywgU3RyaW5nIGV4cGVjdGVkU3RyaW5nKSB7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZFN0cmluZywgU3RyaW5nVG9vbHMucXVvdGUoc3RyaW5nKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFF1b3RlT25Xcml0ZXIoKSB7Ci0JCXRoaXMudmVyaWZ5UXVvdGVPbldyaXRlcigiRW1wbG95ZWUiLCAiXCJFbXBsb3llZVwiIik7Ci0JCXRoaXMudmVyaWZ5UXVvdGVPbldyaXRlcigiMTIzIiwgIlwiMTIzXCIiKTsKLQkJdGhpcy52ZXJpZnlRdW90ZU9uV3JpdGVyKCIiLCAiXCJcIiIpOwotCQl0aGlzLnZlcmlmeVF1b3RlT25Xcml0ZXIoIkVtcFwibG95ZWUiLCAiXCJFbXBcIlwibG95ZWVcIiIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlRdW90ZU9uV3JpdGVyKFN0cmluZyBzdHJpbmcsIFN0cmluZyBleHBlY3RlZFN0cmluZykgewotCQlXcml0ZXIgd3JpdGVyID0gbmV3IFN0cmluZ1dyaXRlcigpOwotCQlTdHJpbmdUb29scy5xdW90ZU9uKHN0cmluZywgd3JpdGVyKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkU3RyaW5nLCB3cml0ZXIudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFF1b3RlT25TdHJpbmdCdWZmZXIoKSB7Ci0JCXRoaXMudmVyaWZ5UXVvdGVPblN0cmluZ0J1ZmZlcigiRW1wbG95ZWUiLCAiXCJFbXBsb3llZVwiIik7Ci0JCXRoaXMudmVyaWZ5UXVvdGVPblN0cmluZ0J1ZmZlcigiMTIzIiwgIlwiMTIzXCIiKTsKLQkJdGhpcy52ZXJpZnlRdW90ZU9uU3RyaW5nQnVmZmVyKCIiLCAiXCJcIiIpOwotCQl0aGlzLnZlcmlmeVF1b3RlT25TdHJpbmdCdWZmZXIoIkVtcFwibG95ZWUiLCAiXCJFbXBcIlwibG95ZWVcIiIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlRdW90ZU9uU3RyaW5nQnVmZmVyKFN0cmluZyBzdHJpbmcsIFN0cmluZyBleHBlY3RlZFN0cmluZykgewotCQlTdHJpbmdCdWZmZXIgc2IgPSBuZXcgU3RyaW5nQnVmZmVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnF1b3RlT24oc3RyaW5nLCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZFN0cmluZywgc2IudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFF1b3RlT25TdHJpbmdCdWlsZGVyKCkgewotCQl0aGlzLnZlcmlmeVF1b3RlT25TdHJpbmdCdWlsZGVyKCJFbXBsb3llZSIsICJcIkVtcGxveWVlXCIiKTsKLQkJdGhpcy52ZXJpZnlRdW90ZU9uU3RyaW5nQnVpbGRlcigiMTIzIiwgIlwiMTIzXCIiKTsKLQkJdGhpcy52ZXJpZnlRdW90ZU9uU3RyaW5nQnVpbGRlcigiIiwgIlwiXCIiKTsKLQkJdGhpcy52ZXJpZnlRdW90ZU9uU3RyaW5nQnVpbGRlcigiRW1wXCJsb3llZSIsICJcIkVtcFwiXCJsb3llZVwiIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVF1b3RlT25TdHJpbmdCdWlsZGVyKFN0cmluZyBzdHJpbmcsIFN0cmluZyBleHBlY3RlZFN0cmluZykgewotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKLQkJU3RyaW5nVG9vbHMucXVvdGVPbihzdHJpbmcsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkU3RyaW5nLCBzYi50b1N0cmluZygpKTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIHJlbW92aW5nIGNoYXJhY3RlcnMgKioqKioqKioqKgotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUZpcnN0T2NjdXJyZW5jZSgpIHsKLQkJdGhpcy52ZXJpZnlSZW1vdmVGaXJzdE9jY3VycmVuY2UoIkVtcGxvJnllZSIsICcmJywgIkVtcGxveWVlIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlRmlyc3RPY2N1cnJlbmNlKCJFbXBsbyZ5ZWUmIiwgJyYnLCAiRW1wbG95ZWUmIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlRmlyc3RPY2N1cnJlbmNlKCJFbXBsb3llZSAmRm9vIiwgJyYnLCAiRW1wbG95ZWUgRm9vIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlRmlyc3RPY2N1cnJlbmNlKCJFbXBsb3llZSYiLCAnJicsICJFbXBsb3llZSIpOwotCQl0aGlzLnZlcmlmeVJlbW92ZUZpcnN0T2NjdXJyZW5jZSgiJkVtcGxveWVlIiwgJyYnLCAiRW1wbG95ZWUiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UmVtb3ZlRmlyc3RPY2N1cnJlbmNlKFN0cmluZyBzdHJpbmcsIGNoYXIgY2hhclRvUmVtb3ZlLCBTdHJpbmcgZXhwZWN0ZWRTdHJpbmcpIHsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkU3RyaW5nLCBTdHJpbmdUb29scy5yZW1vdmVGaXJzdE9jY3VycmVuY2Uoc3RyaW5nLCBjaGFyVG9SZW1vdmUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlRmlyc3RPY2N1cnJlbmNlQ2hhckFycmF5KCkgewotCQl0aGlzLnZlcmlmeVJlbW92ZUZpcnN0T2NjdXJyZW5jZUNoYXJBcnJheSgiRW1wbG8meWVlIiwgJyYnLCAiRW1wbG95ZWUiKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVGaXJzdE9jY3VycmVuY2VDaGFyQXJyYXkoIkVtcGxvJnllZSYiLCAnJicsICJFbXBsb3llZSYiKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVGaXJzdE9jY3VycmVuY2VDaGFyQXJyYXkoIkVtcGxveWVlICZGb28iLCAnJicsICJFbXBsb3llZSBGb28iKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVGaXJzdE9jY3VycmVuY2VDaGFyQXJyYXkoIkVtcGxveWVlJiIsICcmJywgIkVtcGxveWVlIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlRmlyc3RPY2N1cnJlbmNlQ2hhckFycmF5KCImRW1wbG95ZWUiLCAnJicsICJFbXBsb3llZSIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlSZW1vdmVGaXJzdE9jY3VycmVuY2VDaGFyQXJyYXkoU3RyaW5nIHN0cmluZywgY2hhciBjaGFyVG9SZW1vdmUsIFN0cmluZyBleHBlY3RlZFN0cmluZykgewotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWRTdHJpbmcsIFN0cmluZ1Rvb2xzLnJlbW92ZUZpcnN0T2NjdXJyZW5jZShzdHJpbmcudG9DaGFyQXJyYXkoKSwgY2hhclRvUmVtb3ZlKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUZpcnN0T2NjdXJyZW5jZU9uV3JpdGVyKCkgewotCQl0aGlzLnZlcmlmeVJlbW92ZUZpcnN0T2NjdXJyZW5jZU9uV3JpdGVyKCJFbXBsbyZ5ZWUiLCAnJicsICJFbXBsb3llZSIpOwotCQl0aGlzLnZlcmlmeVJlbW92ZUZpcnN0T2NjdXJyZW5jZU9uV3JpdGVyKCJFbXBsbyZ5ZWUmIiwgJyYnLCAiRW1wbG95ZWUmIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlRmlyc3RPY2N1cnJlbmNlT25Xcml0ZXIoIkVtcGxveWVlICZGb28iLCAnJicsICJFbXBsb3llZSBGb28iKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVGaXJzdE9jY3VycmVuY2VPbldyaXRlcigiRW1wbG95ZWUmIiwgJyYnLCAiRW1wbG95ZWUiKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVGaXJzdE9jY3VycmVuY2VPbldyaXRlcigiJkVtcGxveWVlIiwgJyYnLCAiRW1wbG95ZWUiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UmVtb3ZlRmlyc3RPY2N1cnJlbmNlT25Xcml0ZXIoU3RyaW5nIHN0cmluZywgY2hhciBjaGFyVG9SZW1vdmUsIFN0cmluZyBleHBlY3RlZFN0cmluZykgewotCQlXcml0ZXIgd3JpdGVyID0gbmV3IFN0cmluZ1dyaXRlcigpOwotCQlTdHJpbmdUb29scy5yZW1vdmVGaXJzdE9jY3VycmVuY2VPbihzdHJpbmcsIGNoYXJUb1JlbW92ZSwgd3JpdGVyKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkU3RyaW5nLCB3cml0ZXIudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUZpcnN0T2NjdXJyZW5jZU9uU3RyaW5nQnVmZmVyKCkgewotCQl0aGlzLnZlcmlmeVJlbW92ZUZpcnN0T2NjdXJyZW5jZU9uU3RyaW5nQnVmZmVyKCJFbXBsbyZ5ZWUiLCAnJicsICJFbXBsb3llZSIpOwotCQl0aGlzLnZlcmlmeVJlbW92ZUZpcnN0T2NjdXJyZW5jZU9uU3RyaW5nQnVmZmVyKCJFbXBsbyZ5ZWUmIiwgJyYnLCAiRW1wbG95ZWUmIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlRmlyc3RPY2N1cnJlbmNlT25TdHJpbmdCdWZmZXIoIkVtcGxveWVlICZGb28iLCAnJicsICJFbXBsb3llZSBGb28iKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVGaXJzdE9jY3VycmVuY2VPblN0cmluZ0J1ZmZlcigiRW1wbG95ZWUmIiwgJyYnLCAiRW1wbG95ZWUiKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVGaXJzdE9jY3VycmVuY2VPblN0cmluZ0J1ZmZlcigiJkVtcGxveWVlIiwgJyYnLCAiRW1wbG95ZWUiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UmVtb3ZlRmlyc3RPY2N1cnJlbmNlT25TdHJpbmdCdWZmZXIoU3RyaW5nIHN0cmluZywgY2hhciBjaGFyVG9SZW1vdmUsIFN0cmluZyBleHBlY3RlZFN0cmluZykgewotCQlTdHJpbmdCdWZmZXIgc2IgPSBuZXcgU3RyaW5nQnVmZmVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnJlbW92ZUZpcnN0T2NjdXJyZW5jZU9uKHN0cmluZywgY2hhclRvUmVtb3ZlLCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZFN0cmluZywgc2IudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUZpcnN0T2NjdXJyZW5jZU9uU3RyaW5nQnVpbGRlcigpIHsKLQkJdGhpcy52ZXJpZnlSZW1vdmVGaXJzdE9jY3VycmVuY2VPblN0cmluZ0J1aWxkZXIoIkVtcGxvJnllZSIsICcmJywgIkVtcGxveWVlIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlRmlyc3RPY2N1cnJlbmNlT25TdHJpbmdCdWlsZGVyKCJFbXBsbyZ5ZWUmIiwgJyYnLCAiRW1wbG95ZWUmIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlRmlyc3RPY2N1cnJlbmNlT25TdHJpbmdCdWlsZGVyKCJFbXBsb3llZSAmRm9vIiwgJyYnLCAiRW1wbG95ZWUgRm9vIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlRmlyc3RPY2N1cnJlbmNlT25TdHJpbmdCdWlsZGVyKCJFbXBsb3llZSYiLCAnJicsICJFbXBsb3llZSIpOwotCQl0aGlzLnZlcmlmeVJlbW92ZUZpcnN0T2NjdXJyZW5jZU9uU3RyaW5nQnVpbGRlcigiJkVtcGxveWVlIiwgJyYnLCAiRW1wbG95ZWUiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UmVtb3ZlRmlyc3RPY2N1cnJlbmNlT25TdHJpbmdCdWlsZGVyKFN0cmluZyBzdHJpbmcsIGNoYXIgY2hhclRvUmVtb3ZlLCBTdHJpbmcgZXhwZWN0ZWRTdHJpbmcpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnJlbW92ZUZpcnN0T2NjdXJyZW5jZU9uKHN0cmluZywgY2hhclRvUmVtb3ZlLCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZFN0cmluZywgc2IudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbE9jY3VycmVuY2VzKCkgewotCQl0aGlzLnZlcmlmeVJlbW92ZUFsbE9jY3VycmVuY2VzKCJFbXBsb3llZSBGcmVkIiwgJyAnLCAiRW1wbG95ZWVGcmVkIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsT2NjdXJyZW5jZXMoIiBFbXBsb3llZSAiLCAnICcsICJFbXBsb3llZSIpOwotCQl0aGlzLnZlcmlmeVJlbW92ZUFsbE9jY3VycmVuY2VzKCJFbXBsb3llZSAgIEZvbyIsICcgJywgIkVtcGxveWVlRm9vIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsT2NjdXJyZW5jZXMoIiBFbXAgbG95ZWUgICBGb28iLCAnICcsICJFbXBsb3llZUZvbyIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlSZW1vdmVBbGxPY2N1cnJlbmNlcyhTdHJpbmcgc3RyaW5nLCBjaGFyIGNoYXJUb1JlbW92ZSwgU3RyaW5nIGV4cGVjdGVkU3RyaW5nKSB7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZFN0cmluZywgU3RyaW5nVG9vbHMucmVtb3ZlQWxsT2NjdXJyZW5jZXMoc3RyaW5nLCBjaGFyVG9SZW1vdmUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQWxsT2NjdXJyZW5jZXNDaGFyQXJyYXkoKSB7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsT2NjdXJyZW5jZXNDaGFyQXJyYXkoIkVtcGxveWVlIEZyZWQiLCAnICcsICJFbXBsb3llZUZyZWQiKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVBbGxPY2N1cnJlbmNlc0NoYXJBcnJheSgiIEVtcGxveWVlICIsICcgJywgIkVtcGxveWVlIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsT2NjdXJyZW5jZXNDaGFyQXJyYXkoIkVtcGxveWVlICAgRm9vIiwgJyAnLCAiRW1wbG95ZWVGb28iKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVBbGxPY2N1cnJlbmNlc0NoYXJBcnJheSgiIEVtcCBsb3llZSAgIEZvbyIsICcgJywgIkVtcGxveWVlRm9vIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVJlbW92ZUFsbE9jY3VycmVuY2VzQ2hhckFycmF5KFN0cmluZyBzdHJpbmcsIGNoYXIgY2hhclRvUmVtb3ZlLCBTdHJpbmcgZXhwZWN0ZWRTdHJpbmcpIHsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkU3RyaW5nLCBTdHJpbmdUb29scy5yZW1vdmVBbGxPY2N1cnJlbmNlcyhzdHJpbmcudG9DaGFyQXJyYXkoKSwgY2hhclRvUmVtb3ZlKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbE9jY3VycmVuY2VzT25Xcml0ZXIoKSB7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsT2NjdXJyZW5jZXNPbldyaXRlcigiRW1wbG95ZWUgRnJlZCIsICcgJywgIkVtcGxveWVlRnJlZCIpOwotCQl0aGlzLnZlcmlmeVJlbW92ZUFsbE9jY3VycmVuY2VzT25Xcml0ZXIoIiBFbXBsb3llZSAiLCAnICcsICJFbXBsb3llZSIpOwotCQl0aGlzLnZlcmlmeVJlbW92ZUFsbE9jY3VycmVuY2VzT25Xcml0ZXIoIkVtcGxveWVlICAgRm9vIiwgJyAnLCAiRW1wbG95ZWVGb28iKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVBbGxPY2N1cnJlbmNlc09uV3JpdGVyKCIgRW1wIGxveWVlICAgRm9vIiwgJyAnLCAiRW1wbG95ZWVGb28iKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UmVtb3ZlQWxsT2NjdXJyZW5jZXNPbldyaXRlcihTdHJpbmcgc3RyaW5nLCBjaGFyIGNoYXJUb1JlbW92ZSwgU3RyaW5nIGV4cGVjdGVkU3RyaW5nKSB7Ci0JCVdyaXRlciB3cml0ZXIgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnJlbW92ZUFsbE9jY3VycmVuY2VzT24oc3RyaW5nLCBjaGFyVG9SZW1vdmUsIHdyaXRlcik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZFN0cmluZywgd3JpdGVyLnRvU3RyaW5nKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVBbGxPY2N1cnJlbmNlc09uU3RyaW5nQnVmZmVyKCkgewotCQl0aGlzLnZlcmlmeVJlbW92ZUFsbE9jY3VycmVuY2VzT25TdHJpbmdCdWZmZXIoIkVtcGxveWVlIEZyZWQiLCAnICcsICJFbXBsb3llZUZyZWQiKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVBbGxPY2N1cnJlbmNlc09uU3RyaW5nQnVmZmVyKCIgRW1wbG95ZWUgIiwgJyAnLCAiRW1wbG95ZWUiKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVBbGxPY2N1cnJlbmNlc09uU3RyaW5nQnVmZmVyKCJFbXBsb3llZSAgIEZvbyIsICcgJywgIkVtcGxveWVlRm9vIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsT2NjdXJyZW5jZXNPblN0cmluZ0J1ZmZlcigiIEVtcCBsb3llZSAgIEZvbyIsICcgJywgIkVtcGxveWVlRm9vIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVJlbW92ZUFsbE9jY3VycmVuY2VzT25TdHJpbmdCdWZmZXIoU3RyaW5nIHN0cmluZywgY2hhciBjaGFyVG9SZW1vdmUsIFN0cmluZyBleHBlY3RlZFN0cmluZykgewotCQlTdHJpbmdCdWZmZXIgc2IgPSBuZXcgU3RyaW5nQnVmZmVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnJlbW92ZUFsbE9jY3VycmVuY2VzT24oc3RyaW5nLCBjaGFyVG9SZW1vdmUsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkU3RyaW5nLCBzYi50b1N0cmluZygpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQWxsT2NjdXJyZW5jZXNPblN0cmluZ0J1aWxkZXIoKSB7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsT2NjdXJyZW5jZXNPblN0cmluZ0J1aWxkZXIoIkVtcGxveWVlIEZyZWQiLCAnICcsICJFbXBsb3llZUZyZWQiKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVBbGxPY2N1cnJlbmNlc09uU3RyaW5nQnVpbGRlcigiIEVtcGxveWVlICIsICcgJywgIkVtcGxveWVlIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsT2NjdXJyZW5jZXNPblN0cmluZ0J1aWxkZXIoIkVtcGxveWVlICAgRm9vIiwgJyAnLCAiRW1wbG95ZWVGb28iKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVBbGxPY2N1cnJlbmNlc09uU3RyaW5nQnVpbGRlcigiIEVtcCBsb3llZSAgIEZvbyIsICcgJywgIkVtcGxveWVlRm9vIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVJlbW92ZUFsbE9jY3VycmVuY2VzT25TdHJpbmdCdWlsZGVyKFN0cmluZyBzdHJpbmcsIGNoYXIgY2hhclRvUmVtb3ZlLCBTdHJpbmcgZXhwZWN0ZWRTdHJpbmcpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnJlbW92ZUFsbE9jY3VycmVuY2VzT24oc3RyaW5nLCBjaGFyVG9SZW1vdmUsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkU3RyaW5nLCBzYi50b1N0cmluZygpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQWxsV2hpdGVzcGFjZSgpIHsKLQkJdGhpcy52ZXJpZnlSZW1vdmVBbGxXaGl0ZXNwYWNlKCJFbXBsb3llZSBGcmVkXHQiLCAiRW1wbG95ZWVGcmVkIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsV2hpdGVzcGFjZSgiXHRFbXBsb3llZVxuIiwgIkVtcGxveWVlIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsV2hpdGVzcGFjZSgiRW1wbG95ZWUgXHQgRm9vIiwgIkVtcGxveWVlRm9vIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsV2hpdGVzcGFjZSgiIEVtcFx0bG95ZWUgXG4gRm9vIiwgIkVtcGxveWVlRm9vIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVJlbW92ZUFsbFdoaXRlc3BhY2UoU3RyaW5nIHN0cmluZywgU3RyaW5nIGV4cGVjdGVkU3RyaW5nKSB7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZFN0cmluZywgU3RyaW5nVG9vbHMucmVtb3ZlQWxsV2hpdGVzcGFjZShzdHJpbmcpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQWxsV2hpdGVzcGFjZUNoYXJBcnJheSgpIHsKLQkJdGhpcy52ZXJpZnlSZW1vdmVBbGxXaGl0ZXNwYWNlQ2hhckFycmF5KCJFbXBsb3llZSBGcmVkXHQiLCAiRW1wbG95ZWVGcmVkIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsV2hpdGVzcGFjZUNoYXJBcnJheSgiXHRFbXBsb3llZVxuIiwgIkVtcGxveWVlIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsV2hpdGVzcGFjZUNoYXJBcnJheSgiRW1wbG95ZWUgXHQgRm9vIiwgIkVtcGxveWVlRm9vIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsV2hpdGVzcGFjZUNoYXJBcnJheSgiIEVtcFx0bG95ZWUgXG4gRm9vIiwgIkVtcGxveWVlRm9vIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVJlbW92ZUFsbFdoaXRlc3BhY2VDaGFyQXJyYXkoU3RyaW5nIHN0cmluZywgU3RyaW5nIGV4cGVjdGVkU3RyaW5nKSB7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZFN0cmluZywgU3RyaW5nVG9vbHMucmVtb3ZlQWxsV2hpdGVzcGFjZShzdHJpbmcudG9DaGFyQXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVBbGxXaGl0ZXNwYWNlT25Xcml0ZXIoKSB7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsV2hpdGVzcGFjZU9uV3JpdGVyKCJFbXBsb3llZSBGcmVkXHQiLCAiRW1wbG95ZWVGcmVkIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsV2hpdGVzcGFjZU9uV3JpdGVyKCJcdEVtcGxveWVlXG4iLCAiRW1wbG95ZWUiKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVBbGxXaGl0ZXNwYWNlT25Xcml0ZXIoIkVtcGxveWVlIFx0IEZvbyIsICJFbXBsb3llZUZvbyIpOwotCQl0aGlzLnZlcmlmeVJlbW92ZUFsbFdoaXRlc3BhY2VPbldyaXRlcigiIEVtcFx0bG95ZWUgXG4gRm9vIiwgIkVtcGxveWVlRm9vIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVJlbW92ZUFsbFdoaXRlc3BhY2VPbldyaXRlcihTdHJpbmcgc3RyaW5nLCBTdHJpbmcgZXhwZWN0ZWRTdHJpbmcpIHsKLQkJV3JpdGVyIHdyaXRlciA9IG5ldyBTdHJpbmdXcml0ZXIoKTsKLQkJU3RyaW5nVG9vbHMucmVtb3ZlQWxsV2hpdGVzcGFjZU9uKHN0cmluZywgd3JpdGVyKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkU3RyaW5nLCB3cml0ZXIudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbFdoaXRlc3BhY2VPblN0cmluZ0J1ZmZlcigpIHsKLQkJdGhpcy52ZXJpZnlSZW1vdmVBbGxXaGl0ZXNwYWNlT25TdHJpbmdCdWZmZXIoIkVtcGxveWVlIEZyZWRcdCIsICJFbXBsb3llZUZyZWQiKTsKLQkJdGhpcy52ZXJpZnlSZW1vdmVBbGxXaGl0ZXNwYWNlT25TdHJpbmdCdWZmZXIoIlx0RW1wbG95ZWVcbiIsICJFbXBsb3llZSIpOwotCQl0aGlzLnZlcmlmeVJlbW92ZUFsbFdoaXRlc3BhY2VPblN0cmluZ0J1ZmZlcigiRW1wbG95ZWUgXHQgRm9vIiwgIkVtcGxveWVlRm9vIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsV2hpdGVzcGFjZU9uU3RyaW5nQnVmZmVyKCIgRW1wXHRsb3llZSBcbiBGb28iLCAiRW1wbG95ZWVGb28iKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UmVtb3ZlQWxsV2hpdGVzcGFjZU9uU3RyaW5nQnVmZmVyKFN0cmluZyBzdHJpbmcsIFN0cmluZyBleHBlY3RlZFN0cmluZykgewotCQlTdHJpbmdCdWZmZXIgc2IgPSBuZXcgU3RyaW5nQnVmZmVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnJlbW92ZUFsbFdoaXRlc3BhY2VPbihzdHJpbmcsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkU3RyaW5nLCBzYi50b1N0cmluZygpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQWxsV2hpdGVzcGFjZU9uU3RyaW5nQnVpbGRlcigpIHsKLQkJdGhpcy52ZXJpZnlSZW1vdmVBbGxXaGl0ZXNwYWNlT25TdHJpbmdCdWlsZGVyKCJFbXBsb3llZSBGcmVkXHQiLCAiRW1wbG95ZWVGcmVkIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsV2hpdGVzcGFjZU9uU3RyaW5nQnVpbGRlcigiXHRFbXBsb3llZVxuIiwgIkVtcGxveWVlIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsV2hpdGVzcGFjZU9uU3RyaW5nQnVpbGRlcigiRW1wbG95ZWUgXHQgRm9vIiwgIkVtcGxveWVlRm9vIik7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlQWxsV2hpdGVzcGFjZU9uU3RyaW5nQnVpbGRlcigiIEVtcFx0bG95ZWUgXG4gRm9vIiwgIkVtcGxveWVlRm9vIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVJlbW92ZUFsbFdoaXRlc3BhY2VPblN0cmluZ0J1aWxkZXIoU3RyaW5nIHN0cmluZywgU3RyaW5nIGV4cGVjdGVkU3RyaW5nKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQlTdHJpbmdUb29scy5yZW1vdmVBbGxXaGl0ZXNwYWNlT24oc3RyaW5nLCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZFN0cmluZywgc2IudG9TdHJpbmcoKSk7Ci0JfQotCi0JLy8gKioqKioqKioqKiBjb21tb24gcHJlZml4ICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIHRlc3RDb21tb25QcmVmaXhMZW5ndGgoKSB7Ci0JCWFzc2VydEVxdWFscygzLCBTdHJpbmdUb29scy5jb21tb25QcmVmaXhMZW5ndGgoImZvb1paWiIsICJmb29CQkIiKSk7Ci0JCWFzc2VydEVxdWFscygzLCBTdHJpbmdUb29scy5jb21tb25QcmVmaXhMZW5ndGgoImZvbyIsICJmb29CQkIiKSk7Ci0JCWFzc2VydEVxdWFscygzLCBTdHJpbmdUb29scy5jb21tb25QcmVmaXhMZW5ndGgoImZvb1paWiIsICJmb28iKSk7Ci0JCWFzc2VydEVxdWFscygzLCBTdHJpbmdUb29scy5jb21tb25QcmVmaXhMZW5ndGgoImZvbyIsICJmb28iKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbW1vblByZWZpeExlbmd0aE1heCgpIHsKLQkJYXNzZXJ0RXF1YWxzKDIsIFN0cmluZ1Rvb2xzLmNvbW1vblByZWZpeExlbmd0aCgiZm9vWlpaIiwgImZvb0JCQiIsIDIpKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIFN0cmluZ1Rvb2xzLmNvbW1vblByZWZpeExlbmd0aCgiZm9vIiwgImZvb0JCQiIsIDIpKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIFN0cmluZ1Rvb2xzLmNvbW1vblByZWZpeExlbmd0aCgiZm9vWlpaIiwgImZvbyIsIDIpKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIFN0cmluZ1Rvb2xzLmNvbW1vblByZWZpeExlbmd0aCgiZm9vIiwgImZvbyIsIDIpKTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIGNhcGl0YWxpemF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIHRlc3RDYXBpdGFsaXplQ2hhckFycmF5KCkgewotCQl0aGlzLnZlcmlmeUNhcGl0YWxpemVDaGFyQXJyYXkoIk9yYWNsZSIsIG5ldyBjaGFyW10geyAnTycsICdyJywgJ2EnLCAnYycsICdsJywgJ2UnIH0pOwotCQl0aGlzLnZlcmlmeUNhcGl0YWxpemVDaGFyQXJyYXkoIk9yYWNsZSIsIG5ldyBjaGFyW10geyAnbycsICdyJywgJ2EnLCAnYycsICdsJywgJ2UnIH0pOwotCQl0aGlzLnZlcmlmeUNhcGl0YWxpemVDaGFyQXJyYXkoIiAgICIsIG5ldyBjaGFyW10geyAnICcsICcgJywgJyAnIH0pOwotCQl0aGlzLnZlcmlmeUNhcGl0YWxpemVDaGFyQXJyYXkoIk9SQUNMRSIsIG5ldyBjaGFyW10geyAnTycsICdSJywgJ0EnLCAnQycsICdMJywgJ0UnIH0pOwotCQl0aGlzLnZlcmlmeUNhcGl0YWxpemVDaGFyQXJyYXkoIiIsIG5ldyBjaGFyWzBdKTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplQ2hhckFycmF5KCJBIiwgbmV3IGNoYXJbXSB7ICdhJyB9KTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplQ2hhckFycmF5KCJcdTAwQzljb2xlIiwgbmV3IGNoYXJbXSB7ICdcdTAwRTknLCAnYycsICdvJywgJ2wnLCAnZScgfSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUNhcGl0YWxpemVDaGFyQXJyYXkoU3RyaW5nIGV4cGVjdGVkLCBjaGFyW10gc3RyaW5nKSB7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgU3RyaW5nVG9vbHMuY2FwaXRhbGl6ZShzdHJpbmcpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2FwaXRhbGl6ZVN0cmluZygpIHsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplU3RyaW5nKCJPcmFjbGUiLCAiT3JhY2xlIik7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZVN0cmluZygiT3JhY2xlIiwgIm9yYWNsZSIpOwotCQl0aGlzLnZlcmlmeUNhcGl0YWxpemVTdHJpbmcoIiAgICIsICIgICAiKTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplU3RyaW5nKCJPUkFDTEUiLCAiT1JBQ0xFIik7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZVN0cmluZygiIiwgIiIpOwotCQl0aGlzLnZlcmlmeUNhcGl0YWxpemVTdHJpbmcoIkEiLCAiYSIpOwotCQl0aGlzLnZlcmlmeUNhcGl0YWxpemVTdHJpbmcoIlx1MDBDOWNvbGUiLCAiXHUwMEU5Y29sZSIpOyAvLyDvv71jb2xlLT7vv71DT0xFCi0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUNhcGl0YWxpemVTdHJpbmcoU3RyaW5nIGV4cGVjdGVkLCBTdHJpbmcgc3RyaW5nKSB7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgU3RyaW5nVG9vbHMuY2FwaXRhbGl6ZShzdHJpbmcpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2FwaXRhbGl6ZU9uQ2hhckFycmF5U3RyaW5nQnVmZmVyKCkgewotCQl0aGlzLnZlcmlmeUNhcGl0YWxpemVPbkNoYXJBcnJheVN0cmluZ0J1ZmZlcigiT3JhY2xlIiwgbmV3IGNoYXJbXSB7ICdPJywgJ3InLCAnYScsICdjJywgJ2wnLCAnZScgfSk7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uQ2hhckFycmF5U3RyaW5nQnVmZmVyKCJPcmFjbGUiLCBuZXcgY2hhcltdIHsgJ28nLCAncicsICdhJywgJ2MnLCAnbCcsICdlJyB9KTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25DaGFyQXJyYXlTdHJpbmdCdWZmZXIoIiAgICIsIG5ldyBjaGFyW10geyAnICcsICcgJywgJyAnIH0pOwotCQl0aGlzLnZlcmlmeUNhcGl0YWxpemVPbkNoYXJBcnJheVN0cmluZ0J1ZmZlcigiT1JBQ0xFIiwgbmV3IGNoYXJbXSB7ICdPJywgJ1InLCAnQScsICdDJywgJ0wnLCAnRScgfSk7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uQ2hhckFycmF5U3RyaW5nQnVmZmVyKCIiLCBuZXcgY2hhclswXSk7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uQ2hhckFycmF5U3RyaW5nQnVmZmVyKCJBIiwgbmV3IGNoYXJbXSB7ICdhJyB9KTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25DaGFyQXJyYXlTdHJpbmdCdWZmZXIoIlx1MDBDOWNvbGUiLCBuZXcgY2hhcltdIHsgJ1x1MDBFOScsICdjJywgJ28nLCAnbCcsICdlJyB9KTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5Q2FwaXRhbGl6ZU9uQ2hhckFycmF5U3RyaW5nQnVmZmVyKFN0cmluZyBleHBlY3RlZCwgY2hhcltdIHN0cmluZykgewotCQlTdHJpbmdCdWZmZXIgc2IgPSBuZXcgU3RyaW5nQnVmZmVyKCk7Ci0JCVN0cmluZ1Rvb2xzLmNhcGl0YWxpemVPbihzdHJpbmcsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBzYi50b1N0cmluZygpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2FwaXRhbGl6ZU9uQ2hhckFycmF5U3RyaW5nQnVpbGRlcigpIHsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25DaGFyQXJyYXlTdHJpbmdCdWlsZGVyKCJPcmFjbGUiLCBuZXcgY2hhcltdIHsgJ08nLCAncicsICdhJywgJ2MnLCAnbCcsICdlJyB9KTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25DaGFyQXJyYXlTdHJpbmdCdWlsZGVyKCJPcmFjbGUiLCBuZXcgY2hhcltdIHsgJ28nLCAncicsICdhJywgJ2MnLCAnbCcsICdlJyB9KTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25DaGFyQXJyYXlTdHJpbmdCdWlsZGVyKCIgICAiLCBuZXcgY2hhcltdIHsgJyAnLCAnICcsICcgJyB9KTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25DaGFyQXJyYXlTdHJpbmdCdWlsZGVyKCJPUkFDTEUiLCBuZXcgY2hhcltdIHsgJ08nLCAnUicsICdBJywgJ0MnLCAnTCcsICdFJyB9KTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25DaGFyQXJyYXlTdHJpbmdCdWlsZGVyKCIiLCBuZXcgY2hhclswXSk7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uQ2hhckFycmF5U3RyaW5nQnVpbGRlcigiQSIsIG5ldyBjaGFyW10geyAnYScgfSk7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uQ2hhckFycmF5U3RyaW5nQnVpbGRlcigiXHUwMEM5Y29sZSIsIG5ldyBjaGFyW10geyAnXHUwMEU5JywgJ2MnLCAnbycsICdsJywgJ2UnIH0pOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlDYXBpdGFsaXplT25DaGFyQXJyYXlTdHJpbmdCdWlsZGVyKFN0cmluZyBleHBlY3RlZCwgY2hhcltdIHN0cmluZykgewotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKLQkJU3RyaW5nVG9vbHMuY2FwaXRhbGl6ZU9uKHN0cmluZywgc2IpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHNiLnRvU3RyaW5nKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDYXBpdGFsaXplT25TdHJpbmdTdHJpbmdCdWZmZXIoKSB7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVmZmVyKCJPcmFjbGUiLCAiT3JhY2xlIik7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVmZmVyKCJPcmFjbGUiLCAib3JhY2xlIik7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVmZmVyKCIgICAiLCAiICAgIik7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVmZmVyKCJPUkFDTEUiLCAiT1JBQ0xFIik7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVmZmVyKCIiLCAiIik7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVmZmVyKCJBIiwgImEiKTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25TdHJpbmdTdHJpbmdCdWZmZXIoIlx1MDBDOWNvbGUiLCAiXHUwMEU5Y29sZSIpOyAvLyDvv71jb2xlLT7vv71DT0xFCi0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUNhcGl0YWxpemVPblN0cmluZ1N0cmluZ0J1ZmZlcihTdHJpbmcgZXhwZWN0ZWQsIFN0cmluZyBzdHJpbmcpIHsKLQkJU3RyaW5nQnVmZmVyIHNiID0gbmV3IFN0cmluZ0J1ZmZlcigpOwotCQlTdHJpbmdUb29scy5jYXBpdGFsaXplT24oc3RyaW5nLCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgc2IudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENhcGl0YWxpemVPblN0cmluZ1N0cmluZ0J1aWxkZXIoKSB7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVpbGRlcigiT3JhY2xlIiwgIk9yYWNsZSIpOwotCQl0aGlzLnZlcmlmeUNhcGl0YWxpemVPblN0cmluZ1N0cmluZ0J1aWxkZXIoIk9yYWNsZSIsICJvcmFjbGUiKTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25TdHJpbmdTdHJpbmdCdWlsZGVyKCIgICAiLCAiICAgIik7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVpbGRlcigiT1JBQ0xFIiwgIk9SQUNMRSIpOwotCQl0aGlzLnZlcmlmeUNhcGl0YWxpemVPblN0cmluZ1N0cmluZ0J1aWxkZXIoIiIsICIiKTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25TdHJpbmdTdHJpbmdCdWlsZGVyKCJBIiwgImEiKTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25TdHJpbmdTdHJpbmdCdWlsZGVyKCJcdTAwQzljb2xlIiwgIlx1MDBFOWNvbGUiKTsgLy8g77+9Y29sZS0+77+9Q09MRQotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlDYXBpdGFsaXplT25TdHJpbmdTdHJpbmdCdWlsZGVyKFN0cmluZyBleHBlY3RlZCwgU3RyaW5nIHN0cmluZykgewotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKLQkJU3RyaW5nVG9vbHMuY2FwaXRhbGl6ZU9uKHN0cmluZywgc2IpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHNiLnRvU3RyaW5nKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDYXBpdGFsaXplT25DaGFyQXJyYXlXcml0ZXIoKSB7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uQ2hhckFycmF5V3JpdGVyKCJPcmFjbGUiLCBuZXcgY2hhcltdIHsgJ08nLCAncicsICdhJywgJ2MnLCAnbCcsICdlJyB9KTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25DaGFyQXJyYXlXcml0ZXIoIk9yYWNsZSIsIG5ldyBjaGFyW10geyAnbycsICdyJywgJ2EnLCAnYycsICdsJywgJ2UnIH0pOwotCQl0aGlzLnZlcmlmeUNhcGl0YWxpemVPbkNoYXJBcnJheVdyaXRlcigiICAgIiwgbmV3IGNoYXJbXSB7ICcgJywgJyAnLCAnICcgfSk7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uQ2hhckFycmF5V3JpdGVyKCJPUkFDTEUiLCBuZXcgY2hhcltdIHsgJ08nLCAnUicsICdBJywgJ0MnLCAnTCcsICdFJyB9KTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25DaGFyQXJyYXlXcml0ZXIoIiIsIG5ldyBjaGFyWzBdKTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25DaGFyQXJyYXlXcml0ZXIoIkEiLCBuZXcgY2hhcltdIHsgJ2EnIH0pOwotCQl0aGlzLnZlcmlmeUNhcGl0YWxpemVPbkNoYXJBcnJheVdyaXRlcigiXHUwMEM5Y29sZSIsIG5ldyBjaGFyW10geyAnXHUwMEU5JywgJ2MnLCAnbycsICdsJywgJ2UnIH0pOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlDYXBpdGFsaXplT25DaGFyQXJyYXlXcml0ZXIoU3RyaW5nIGV4cGVjdGVkLCBjaGFyW10gc3RyaW5nKSB7Ci0JCVdyaXRlciB3cml0ZXIgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLmNhcGl0YWxpemVPbihzdHJpbmcsIHdyaXRlcik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgd3JpdGVyLnRvU3RyaW5nKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDYXBpdGFsaXplT25TdHJpbmdXcml0ZXIoKSB7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uU3RyaW5nV3JpdGVyKCJPcmFjbGUiLCAiT3JhY2xlIik7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uU3RyaW5nV3JpdGVyKCJPcmFjbGUiLCAib3JhY2xlIik7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uU3RyaW5nV3JpdGVyKCIgICAiLCAiICAgIik7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uU3RyaW5nV3JpdGVyKCJPUkFDTEUiLCAiT1JBQ0xFIik7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uU3RyaW5nV3JpdGVyKCIiLCAiIik7Ci0JCXRoaXMudmVyaWZ5Q2FwaXRhbGl6ZU9uU3RyaW5nV3JpdGVyKCJBIiwgImEiKTsKLQkJdGhpcy52ZXJpZnlDYXBpdGFsaXplT25TdHJpbmdXcml0ZXIoIlx1MDBDOWNvbGUiLCAiXHUwMEU5Y29sZSIpOyAvLyDvv71jb2xlLT7vv71DT0xFCi0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUNhcGl0YWxpemVPblN0cmluZ1dyaXRlcihTdHJpbmcgZXhwZWN0ZWQsIFN0cmluZyBzdHJpbmcpIHsKLQkJV3JpdGVyIHdyaXRlciA9IG5ldyBTdHJpbmdXcml0ZXIoKTsKLQkJU3RyaW5nVG9vbHMuY2FwaXRhbGl6ZU9uKHN0cmluZywgd3JpdGVyKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCB3cml0ZXIudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFVuYXBpdGFsaXplQ2hhckFycmF5KCkgewotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZUNoYXJBcnJheSgib3JhY2xlIiwgbmV3IGNoYXJbXSB7ICdPJywgJ3InLCAnYScsICdjJywgJ2wnLCAnZScgfSk7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplQ2hhckFycmF5KCJvcmFjbGUiLCBuZXcgY2hhcltdIHsgJ28nLCAncicsICdhJywgJ2MnLCAnbCcsICdlJyB9KTsKLQkJdGhpcy52ZXJpZnlVbmNhcGl0YWxpemVDaGFyQXJyYXkoIiAgICIsIG5ldyBjaGFyW10geyAnICcsICcgJywgJyAnIH0pOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZUNoYXJBcnJheSgiT1JBQ0xFIiwgbmV3IGNoYXJbXSB7ICdPJywgJ1InLCAnQScsICdDJywgJ0wnLCAnRScgfSk7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplQ2hhckFycmF5KCIiLCBuZXcgY2hhclswXSk7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplQ2hhckFycmF5KCJhIiwgbmV3IGNoYXJbXSB7ICdBJyB9KTsKLQkJdGhpcy52ZXJpZnlVbmNhcGl0YWxpemVDaGFyQXJyYXkoIlx1MDBFOWNvbGUiLCBuZXcgY2hhcltdIHsgJ1x1MDBDOScsICdjJywgJ28nLCAnbCcsICdlJyB9KTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5VW5jYXBpdGFsaXplQ2hhckFycmF5KFN0cmluZyBleHBlY3RlZCwgY2hhcltdIHN0cmluZykgewotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIFN0cmluZ1Rvb2xzLnVuY2FwaXRhbGl6ZShzdHJpbmcpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VW5jYXBpdGFsaXplU3RyaW5nKCkgewotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZVN0cmluZygib3JhY2xlIiwgIk9yYWNsZSIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZVN0cmluZygib3JhY2xlIiwgIm9yYWNsZSIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZVN0cmluZygiICAgIiwgIiAgICIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZVN0cmluZygiT1JBQ0xFIiwgIk9SQUNMRSIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZVN0cmluZygiIiwgIiIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZVN0cmluZygiYSIsICJBIik7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplU3RyaW5nKCJcdTAwRTljb2xlIiwgIlx1MDBDOWNvbGUiKTsgLy8g77+9Y29sZS0+77+9Q09MRQotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlVbmNhcGl0YWxpemVTdHJpbmcoU3RyaW5nIGV4cGVjdGVkLCBTdHJpbmcgc3RyaW5nKSB7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgU3RyaW5nVG9vbHMudW5jYXBpdGFsaXplKHN0cmluZykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbmNhcGl0YWxpemVPbkNoYXJBcnJheVN0cmluZ0J1ZmZlcigpIHsKLQkJdGhpcy52ZXJpZnlVbmNhcGl0YWxpemVPbkNoYXJBcnJheVN0cmluZ0J1ZmZlcigib3JhY2xlIiwgbmV3IGNoYXJbXSB7ICdPJywgJ3InLCAnYScsICdjJywgJ2wnLCAnZScgfSk7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplT25DaGFyQXJyYXlTdHJpbmdCdWZmZXIoIm9yYWNsZSIsIG5ldyBjaGFyW10geyAnbycsICdyJywgJ2EnLCAnYycsICdsJywgJ2UnIH0pOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uQ2hhckFycmF5U3RyaW5nQnVmZmVyKCIgICAiLCBuZXcgY2hhcltdIHsgJyAnLCAnICcsICcgJyB9KTsKLQkJdGhpcy52ZXJpZnlVbmNhcGl0YWxpemVPbkNoYXJBcnJheVN0cmluZ0J1ZmZlcigiT1JBQ0xFIiwgbmV3IGNoYXJbXSB7ICdPJywgJ1InLCAnQScsICdDJywgJ0wnLCAnRScgfSk7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplT25DaGFyQXJyYXlTdHJpbmdCdWZmZXIoIiIsIG5ldyBjaGFyWzBdKTsKLQkJdGhpcy52ZXJpZnlVbmNhcGl0YWxpemVPbkNoYXJBcnJheVN0cmluZ0J1ZmZlcigiYSIsIG5ldyBjaGFyW10geyAnQScgfSk7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplT25DaGFyQXJyYXlTdHJpbmdCdWZmZXIoIlx1MDBFOWNvbGUiLCBuZXcgY2hhcltdIHsgJ1x1MDBDOScsICdjJywgJ28nLCAnbCcsICdlJyB9KTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5VW5jYXBpdGFsaXplT25DaGFyQXJyYXlTdHJpbmdCdWZmZXIoU3RyaW5nIGV4cGVjdGVkLCBjaGFyW10gc3RyaW5nKSB7Ci0JCVN0cmluZ0J1ZmZlciBzYiA9IG5ldyBTdHJpbmdCdWZmZXIoKTsKLQkJU3RyaW5nVG9vbHMudW5jYXBpdGFsaXplT24oc3RyaW5nLCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgc2IudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFVuY2FwaXRhbGl6ZU9uQ2hhckFycmF5U3RyaW5nQnVpbGRlcigpIHsKLQkJdGhpcy52ZXJpZnlVbmNhcGl0YWxpemVPbkNoYXJBcnJheVN0cmluZ0J1aWxkZXIoIm9yYWNsZSIsIG5ldyBjaGFyW10geyAnTycsICdyJywgJ2EnLCAnYycsICdsJywgJ2UnIH0pOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uQ2hhckFycmF5U3RyaW5nQnVpbGRlcigib3JhY2xlIiwgbmV3IGNoYXJbXSB7ICdvJywgJ3InLCAnYScsICdjJywgJ2wnLCAnZScgfSk7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplT25DaGFyQXJyYXlTdHJpbmdCdWlsZGVyKCIgICAiLCBuZXcgY2hhcltdIHsgJyAnLCAnICcsICcgJyB9KTsKLQkJdGhpcy52ZXJpZnlVbmNhcGl0YWxpemVPbkNoYXJBcnJheVN0cmluZ0J1aWxkZXIoIk9SQUNMRSIsIG5ldyBjaGFyW10geyAnTycsICdSJywgJ0EnLCAnQycsICdMJywgJ0UnIH0pOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uQ2hhckFycmF5U3RyaW5nQnVpbGRlcigiIiwgbmV3IGNoYXJbMF0pOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uQ2hhckFycmF5U3RyaW5nQnVpbGRlcigiYSIsIG5ldyBjaGFyW10geyAnQScgfSk7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplT25DaGFyQXJyYXlTdHJpbmdCdWlsZGVyKCJcdTAwRTljb2xlIiwgbmV3IGNoYXJbXSB7ICdcdTAwQzknLCAnYycsICdvJywgJ2wnLCAnZScgfSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVVuY2FwaXRhbGl6ZU9uQ2hhckFycmF5U3RyaW5nQnVpbGRlcihTdHJpbmcgZXhwZWN0ZWQsIGNoYXJbXSBzdHJpbmcpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnVuY2FwaXRhbGl6ZU9uKHN0cmluZywgc2IpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHNiLnRvU3RyaW5nKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbmNhcGl0YWxpemVPblN0cmluZ1N0cmluZ0J1ZmZlcigpIHsKLQkJdGhpcy52ZXJpZnlVbmNhcGl0YWxpemVPblN0cmluZ1N0cmluZ0J1ZmZlcigib3JhY2xlIiwgIk9yYWNsZSIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVmZmVyKCJvcmFjbGUiLCAib3JhY2xlIik7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplT25TdHJpbmdTdHJpbmdCdWZmZXIoIiAgICIsICIgICAiKTsKLQkJdGhpcy52ZXJpZnlVbmNhcGl0YWxpemVPblN0cmluZ1N0cmluZ0J1ZmZlcigiT1JBQ0xFIiwgIk9SQUNMRSIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVmZmVyKCIiLCAiIik7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplT25TdHJpbmdTdHJpbmdCdWZmZXIoImEiLCAiQSIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVmZmVyKCJcdTAwRTljb2xlIiwgIlx1MDBDOWNvbGUiKTsgLy8g77+9Y29sZS0+77+9Q09MRQotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlVbmNhcGl0YWxpemVPblN0cmluZ1N0cmluZ0J1ZmZlcihTdHJpbmcgZXhwZWN0ZWQsIFN0cmluZyBzdHJpbmcpIHsKLQkJU3RyaW5nQnVmZmVyIHNiID0gbmV3IFN0cmluZ0J1ZmZlcigpOwotCQlTdHJpbmdUb29scy51bmNhcGl0YWxpemVPbihzdHJpbmcsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBzYi50b1N0cmluZygpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VW5jYXBpdGFsaXplT25TdHJpbmdTdHJpbmdCdWlsZGVyKCkgewotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVpbGRlcigib3JhY2xlIiwgIk9yYWNsZSIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVpbGRlcigib3JhY2xlIiwgIm9yYWNsZSIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVpbGRlcigiICAgIiwgIiAgICIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVpbGRlcigiT1JBQ0xFIiwgIk9SQUNMRSIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVpbGRlcigiIiwgIiIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uU3RyaW5nU3RyaW5nQnVpbGRlcigiYSIsICJBIik7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplT25TdHJpbmdTdHJpbmdCdWlsZGVyKCJcdTAwRTljb2xlIiwgIlx1MDBDOWNvbGUiKTsgLy8g77+9Y29sZS0+77+9Q09MRQotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlVbmNhcGl0YWxpemVPblN0cmluZ1N0cmluZ0J1aWxkZXIoU3RyaW5nIGV4cGVjdGVkLCBTdHJpbmcgc3RyaW5nKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQlTdHJpbmdUb29scy51bmNhcGl0YWxpemVPbihzdHJpbmcsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBzYi50b1N0cmluZygpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VW5jYXBpdGFsaXplT25DaGFyQXJyYXlXcml0ZXIoKSB7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplT25DaGFyQXJyYXlXcml0ZXIoIm9yYWNsZSIsIG5ldyBjaGFyW10geyAnTycsICdyJywgJ2EnLCAnYycsICdsJywgJ2UnIH0pOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uQ2hhckFycmF5V3JpdGVyKCJvcmFjbGUiLCBuZXcgY2hhcltdIHsgJ28nLCAncicsICdhJywgJ2MnLCAnbCcsICdlJyB9KTsKLQkJdGhpcy52ZXJpZnlVbmNhcGl0YWxpemVPbkNoYXJBcnJheVdyaXRlcigiICAgIiwgbmV3IGNoYXJbXSB7ICcgJywgJyAnLCAnICcgfSk7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplT25DaGFyQXJyYXlXcml0ZXIoIk9SQUNMRSIsIG5ldyBjaGFyW10geyAnTycsICdSJywgJ0EnLCAnQycsICdMJywgJ0UnIH0pOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uQ2hhckFycmF5V3JpdGVyKCIiLCBuZXcgY2hhclswXSk7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplT25DaGFyQXJyYXlXcml0ZXIoImEiLCBuZXcgY2hhcltdIHsgJ0EnIH0pOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uQ2hhckFycmF5V3JpdGVyKCJcdTAwRTljb2xlIiwgbmV3IGNoYXJbXSB7ICdcdTAwQzknLCAnYycsICdvJywgJ2wnLCAnZScgfSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVVuY2FwaXRhbGl6ZU9uQ2hhckFycmF5V3JpdGVyKFN0cmluZyBleHBlY3RlZCwgY2hhcltdIHN0cmluZykgewotCQlXcml0ZXIgd3JpdGVyID0gbmV3IFN0cmluZ1dyaXRlcigpOwotCQlTdHJpbmdUb29scy51bmNhcGl0YWxpemVPbihzdHJpbmcsIHdyaXRlcik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgd3JpdGVyLnRvU3RyaW5nKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbmNhcGl0YWxpemVPblN0cmluZ1dyaXRlcigpIHsKLQkJdGhpcy52ZXJpZnlVbmNhcGl0YWxpemVPblN0cmluZ1dyaXRlcigib3JhY2xlIiwgIk9yYWNsZSIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uU3RyaW5nV3JpdGVyKCJvcmFjbGUiLCAib3JhY2xlIik7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplT25TdHJpbmdXcml0ZXIoIiAgICIsICIgICAiKTsKLQkJdGhpcy52ZXJpZnlVbmNhcGl0YWxpemVPblN0cmluZ1dyaXRlcigiT1JBQ0xFIiwgIk9SQUNMRSIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uU3RyaW5nV3JpdGVyKCIiLCAiIik7Ci0JCXRoaXMudmVyaWZ5VW5jYXBpdGFsaXplT25TdHJpbmdXcml0ZXIoImEiLCAiQSIpOwotCQl0aGlzLnZlcmlmeVVuY2FwaXRhbGl6ZU9uU3RyaW5nV3JpdGVyKCJcdTAwRTljb2xlIiwgIlx1MDBDOWNvbGUiKTsgLy8g77+9Y29sZS0+77+9Q09MRQotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlVbmNhcGl0YWxpemVPblN0cmluZ1dyaXRlcihTdHJpbmcgZXhwZWN0ZWQsIFN0cmluZyBzdHJpbmcpIHsKLQkJV3JpdGVyIHdyaXRlciA9IG5ldyBTdHJpbmdXcml0ZXIoKTsKLQkJU3RyaW5nVG9vbHMudW5jYXBpdGFsaXplT24oc3RyaW5nLCB3cml0ZXIpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHdyaXRlci50b1N0cmluZygpKTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIHF1ZXJpZXMgKioqKioqKioqKgotCi0JcHVibGljIHZvaWQgdGVzdFN0cmluZ0lzRW1wdHlTdHJpbmcoKSB7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuc3RyaW5nSXNFbXB0eSgoU3RyaW5nKSBudWxsKSk7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuc3RyaW5nSXNFbXB0eSgiIikpOwotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzRW1wdHkoIiAgICAgICIpKTsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdJc0VtcHR5KCIgICAgICBcdFx0ICAgIikpOwotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzRW1wdHkoIiAgICAgIFx0XHQgICAiICsgU3RyaW5nVG9vbHMuQ1IpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3RyaW5nSXNFbXB0eUNoYXJBcnJheSgpIHsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdJc0VtcHR5KChjaGFyW10pIG51bGwpKTsKLQkJdGhpcy52ZXJpZnlTdHJpbmdJc0VtcHR5Q2hhckFycmF5KCIiKTsKLQkJdGhpcy52ZXJpZnlTdHJpbmdJc0VtcHR5Q2hhckFycmF5KCIgICAgICBcdFx0ICAgIik7Ci0JCXRoaXMudmVyaWZ5U3RyaW5nSXNFbXB0eUNoYXJBcnJheSgiICAgICAgIik7Ci0JCXRoaXMudmVyaWZ5U3RyaW5nSXNFbXB0eUNoYXJBcnJheSgiICAgICAgXHRcdCAgICIgKyBTdHJpbmdUb29scy5DUik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVN0cmluZ0lzRW1wdHlDaGFyQXJyYXkoU3RyaW5nIHN0cmluZykgewotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzRW1wdHkoc3RyaW5nLnRvQ2hhckFycmF5KCkpKTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgdGVzdFN0cmluZ3NBcmVFcXVhbFN0cmluZ1N0cmluZygpIHsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdzQXJlRXF1YWwoKFN0cmluZykgbnVsbCwgKFN0cmluZykgbnVsbCkpOwotCQlhc3NlcnRGYWxzZShTdHJpbmdUb29scy5zdHJpbmdzQXJlRXF1YWwobnVsbCwgImFzZGYiKSk7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ3NBcmVFcXVhbCgiYXNkZiIsIG51bGwpKTsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdzQXJlRXF1YWwoImFzZGYiLCAiYXNkZiIpKTsKLQkJYXNzZXJ0RmFsc2UoU3RyaW5nVG9vbHMuc3RyaW5nc0FyZUVxdWFsKCJhc2RmIiwgIkFTREYiKSk7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHRlc3RTdHJpbmdzQXJlRXF1YWxDaGFyQXJyYXlDaGFyQXJyYXkoKSB7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuc3RyaW5nc0FyZUVxdWFsKChjaGFyW10pIG51bGwsIChjaGFyW10pIG51bGwpKTsKLQkJYXNzZXJ0RmFsc2UoU3RyaW5nVG9vbHMuc3RyaW5nc0FyZUVxdWFsKChjaGFyW10pIG51bGwsICJhc2RmIi50b0NoYXJBcnJheSgpKSk7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ3NBcmVFcXVhbCgiYXNkZiIudG9DaGFyQXJyYXkoKSwgKGNoYXJbXSkgbnVsbCkpOwotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ3NBcmVFcXVhbCgiYXNkZiIudG9DaGFyQXJyYXkoKSwgImFzZGYiLnRvQ2hhckFycmF5KCkpKTsKLQkJYXNzZXJ0RmFsc2UoU3RyaW5nVG9vbHMuc3RyaW5nc0FyZUVxdWFsKCJhc2RmIi50b0NoYXJBcnJheSgpLCAiQVNERiIudG9DaGFyQXJyYXkoKSkpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0U3RyaW5nc0FyZUVxdWFsSWdub3JlQ2FzZVN0cmluZ1N0cmluZygpIHsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdzQXJlRXF1YWxJZ25vcmVDYXNlKChTdHJpbmcpIG51bGwsIChTdHJpbmcpIG51bGwpKTsKLQkJYXNzZXJ0RmFsc2UoU3RyaW5nVG9vbHMuc3RyaW5nc0FyZUVxdWFsSWdub3JlQ2FzZShudWxsLCAiYXNkZiIpKTsKLQkJYXNzZXJ0RmFsc2UoU3RyaW5nVG9vbHMuc3RyaW5nc0FyZUVxdWFsSWdub3JlQ2FzZSgiYXNkZiIsIG51bGwpKTsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdzQXJlRXF1YWxJZ25vcmVDYXNlKCJhc2RmIiwgImFzZGYiKSk7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuc3RyaW5nc0FyZUVxdWFsSWdub3JlQ2FzZSgiYXNkZiIsICJBU0RGIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTdHJpbmdzQXJlRXF1YWxJZ25vcmVDYXNlQ2hhckFycmF5Q2hhckFycmF5KCkgewotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ3NBcmVFcXVhbElnbm9yZUNhc2UoKGNoYXJbXSkgbnVsbCwgKGNoYXJbXSkgbnVsbCkpOwotCQlhc3NlcnRGYWxzZShTdHJpbmdUb29scy5zdHJpbmdzQXJlRXF1YWxJZ25vcmVDYXNlKChjaGFyW10pIG51bGwsICJhc2RmIi50b0NoYXJBcnJheSgpKSk7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ3NBcmVFcXVhbElnbm9yZUNhc2UoImFzZGYiLnRvQ2hhckFycmF5KCksIChjaGFyW10pIG51bGwpKTsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdzQXJlRXF1YWxJZ25vcmVDYXNlKCJhc2RmIi50b0NoYXJBcnJheSgpLCAiYXNkZiIudG9DaGFyQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ3NBcmVFcXVhbElnbm9yZUNhc2UoImFzZGYiLnRvQ2hhckFycmF5KCksICJBU0RGIi50b0NoYXJBcnJheSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFN0cmluZ1N0YXJ0c1dpdGhJZ25vcmVDYXNlU3RyaW5nU3RyaW5nKCkgewotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ1N0YXJ0c1dpdGhJZ25vcmVDYXNlKCJhc2RmIiwgImFzIikpOwotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ1N0YXJ0c1dpdGhJZ25vcmVDYXNlKCJhc2RmIiwgImFTIikpOwotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ1N0YXJ0c1dpdGhJZ25vcmVDYXNlKCJhc2RmIiwgIiIpKTsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdTdGFydHNXaXRoSWdub3JlQ2FzZSgiYXNkZiIsICJBIikpOwotCi0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ1N0YXJ0c1dpdGhJZ25vcmVDYXNlKCJhc2RmIiwgImJzZGYiKSk7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ1N0YXJ0c1dpdGhJZ25vcmVDYXNlKCJhc2RmIiwgImciKSk7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ1N0YXJ0c1dpdGhJZ25vcmVDYXNlKCJhc2RmIiwgImFzZGciKSk7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ1N0YXJ0c1dpdGhJZ25vcmVDYXNlKCJhc2RmIiwgImFzZGZnIikpOwotCQlhc3NlcnRGYWxzZShTdHJpbmdUb29scy5zdHJpbmdTdGFydHNXaXRoSWdub3JlQ2FzZSgiYXNkZiIsICJhc2RmZ2dnZ2dnIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTdHJpbmdTdGFydHNXaXRoSWdub3JlQ2FzZUNoYXJBcnJheUNoYXJBcnJheSgpIHsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdTdGFydHNXaXRoSWdub3JlQ2FzZSgiYXNkZiIudG9DaGFyQXJyYXkoKSwgImFzIi50b0NoYXJBcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuc3RyaW5nU3RhcnRzV2l0aElnbm9yZUNhc2UoImFzZGYiLnRvQ2hhckFycmF5KCksICJhUyIudG9DaGFyQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ1N0YXJ0c1dpdGhJZ25vcmVDYXNlKCJhc2RmIi50b0NoYXJBcnJheSgpLCAiIi50b0NoYXJBcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuc3RyaW5nU3RhcnRzV2l0aElnbm9yZUNhc2UoImFzZGYiLnRvQ2hhckFycmF5KCksICJBIi50b0NoYXJBcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuc3RyaW5nU3RhcnRzV2l0aElnbm9yZUNhc2UoImFzZGYiLnRvQ2hhckFycmF5KCksICJBU0RGIi50b0NoYXJBcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuc3RyaW5nU3RhcnRzV2l0aElnbm9yZUNhc2UoImFzZGYiLnRvQ2hhckFycmF5KCksICJhc2RmIi50b0NoYXJBcnJheSgpKSk7Ci0KLQkJYXNzZXJ0RmFsc2UoU3RyaW5nVG9vbHMuc3RyaW5nU3RhcnRzV2l0aElnbm9yZUNhc2UoImFzZGYiLnRvQ2hhckFycmF5KCksICJic2RmIi50b0NoYXJBcnJheSgpKSk7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ1N0YXJ0c1dpdGhJZ25vcmVDYXNlKCJhc2RmIi50b0NoYXJBcnJheSgpLCAiZyIudG9DaGFyQXJyYXkoKSkpOwotCQlhc3NlcnRGYWxzZShTdHJpbmdUb29scy5zdHJpbmdTdGFydHNXaXRoSWdub3JlQ2FzZSgiYXNkZiIudG9DaGFyQXJyYXkoKSwgImFzZGciLnRvQ2hhckFycmF5KCkpKTsKLQkJYXNzZXJ0RmFsc2UoU3RyaW5nVG9vbHMuc3RyaW5nU3RhcnRzV2l0aElnbm9yZUNhc2UoImFzZGYiLnRvQ2hhckFycmF5KCksICJhc2RmZyIudG9DaGFyQXJyYXkoKSkpOwotCQlhc3NlcnRGYWxzZShTdHJpbmdUb29scy5zdHJpbmdTdGFydHNXaXRoSWdub3JlQ2FzZSgiYXNkZiIudG9DaGFyQXJyYXkoKSwgImFzZGZnZ2dnZ2ciLnRvQ2hhckFycmF5KCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2hhcmFjdGVyc0FyZUVxdWFsSWdub3JlQ2FzZSgpIHsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5jaGFyYWN0ZXJzQXJlRXF1YWxJZ25vcmVDYXNlKCdhJywgJ2EnKSk7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuY2hhcmFjdGVyc0FyZUVxdWFsSWdub3JlQ2FzZSgnYScsICdBJykpOwotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLmNoYXJhY3RlcnNBcmVFcXVhbElnbm9yZUNhc2UoJ0EnLCAnYScpKTsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5jaGFyYWN0ZXJzQXJlRXF1YWxJZ25vcmVDYXNlKCdBJywgJ0EnKSk7Ci0JCQotCQlhc3NlcnRGYWxzZShTdHJpbmdUb29scy5jaGFyYWN0ZXJzQXJlRXF1YWxJZ25vcmVDYXNlKCdhJywgJ2InKSk7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLmNoYXJhY3RlcnNBcmVFcXVhbElnbm9yZUNhc2UoJ0EnLCAnYicpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3RyaW5nSXNVcHBlcmNhc2UoKSB7Ci0JCXRoaXMudmVyaWZ5U3RyaW5nSXNVcHBlcmNhc2UoIkZPTyIpOwotCQl0aGlzLnZlcmlmeVN0cmluZ0lzVXBwZXJjYXNlKCJGT08yIik7Ci0JCXRoaXMudmVyaWZ5U3RyaW5nSXNVcHBlcmNhc2UoIkYgTyBPIik7Ci0JCXRoaXMuZGVueVN0cmluZ0lzVXBwZXJjYXNlKCJGb28iKTsKLQkJdGhpcy5kZW55U3RyaW5nSXNVcHBlcmNhc2UoIiIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlTdHJpbmdJc1VwcGVyY2FzZShTdHJpbmcgcykgewotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzVXBwZXJjYXNlKHMpKTsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdJc1VwcGVyY2FzZShzLnRvQ2hhckFycmF5KCkpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgZGVueVN0cmluZ0lzVXBwZXJjYXNlKFN0cmluZyBzKSB7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzVXBwZXJjYXNlKHMpKTsKLQkJYXNzZXJ0RmFsc2UoU3RyaW5nVG9vbHMuc3RyaW5nSXNVcHBlcmNhc2Uocy50b0NoYXJBcnJheSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFN0cmluZ0lzTG93ZXJjYXNlKCkgewotCQl0aGlzLnZlcmlmeVN0cmluZ0lzTG93ZXJjYXNlKCJmb28iKTsKLQkJdGhpcy52ZXJpZnlTdHJpbmdJc0xvd2VyY2FzZSgiZm9vMiIpOwotCQl0aGlzLnZlcmlmeVN0cmluZ0lzTG93ZXJjYXNlKCJmIG8gbyIpOwotCQl0aGlzLmRlbnlTdHJpbmdJc0xvd2VyY2FzZSgiRm9vIik7Ci0JCXRoaXMuZGVueVN0cmluZ0lzTG93ZXJjYXNlKCIiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5U3RyaW5nSXNMb3dlcmNhc2UoU3RyaW5nIHMpIHsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdJc0xvd2VyY2FzZShzKSk7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuc3RyaW5nSXNMb3dlcmNhc2Uocy50b0NoYXJBcnJheSgpKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGRlbnlTdHJpbmdJc0xvd2VyY2FzZShTdHJpbmcgcykgewotCQlhc3NlcnRGYWxzZShTdHJpbmdUb29scy5zdHJpbmdJc0xvd2VyY2FzZShzKSk7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzTG93ZXJjYXNlKHMudG9DaGFyQXJyYXkoKSkpOwotCX0KLQotCS8vICoqKioqKioqKiogY29udmVydCBjYW1lbC1jYXNlIHRvIGFsbC1jYXBzICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIHRlc3RDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzKCkgewotCQlhc3NlcnRFcXVhbHMoIlRFU1QiLCBTdHJpbmdUb29scy5jb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzKCJ0ZXN0IikpOwotCQlhc3NlcnRFcXVhbHMoIlRFU1QiLCBTdHJpbmdUb29scy5jb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzKCJURVNUIikpOwotCQlhc3NlcnRFcXVhbHMoIlRFU1RfVEVTVCIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHMoInRlc3RUZXN0IikpOwotCQlhc3NlcnRFcXVhbHMoIlRFU1RfVEVTVCIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHMoIlRlc3RUZXN0IikpOwotCQlhc3NlcnRFcXVhbHMoIlRFU1RfVEVTVF9URVNUIiwgU3RyaW5nVG9vbHMuY29udmVydENhbWVsQ2FzZVRvQWxsQ2FwcygidGVzdFRFU1RUZXN0IikpOwotCQlhc3NlcnRFcXVhbHMoIlRFU1RfVEVTVF9URVNUIiwgU3RyaW5nVG9vbHMuY29udmVydENhbWVsQ2FzZVRvQWxsQ2FwcygiVGVzdFRFU1RUZXN0IikpOwotCQlhc3NlcnRFcXVhbHMoIlRFU1RfVEVTVF9URVNUX1QiLCBTdHJpbmdUb29scy5jb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzKCJUZXN0VEVTVFRlc3RUIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT25Xcml0ZXIoKSB7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uV3JpdGVyKCJURVNUIiwgInRlc3QiKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT25Xcml0ZXIoIlRFU1QiLCAiVEVTVCIpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPbldyaXRlcigiVEVTVF9URVNUIiwgInRlc3RUZXN0Iik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uV3JpdGVyKCJURVNUX1RFU1QiLCAiVGVzdFRlc3QiKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT25Xcml0ZXIoIlRFU1RfVEVTVF9URVNUIiwgInRlc3RURVNUVGVzdCIpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPbldyaXRlcigiVEVTVF9URVNUX1RFU1QiLCAiVGVzdFRFU1RUZXN0Iik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uV3JpdGVyKCJURVNUX1RFU1RfVEVTVF9UIiwgIlRlc3RURVNUVGVzdFQiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uV3JpdGVyKFN0cmluZyBleHBlY3RlZCwgU3RyaW5nIHN0cmluZykgewotCQlXcml0ZXIgd3JpdGVyID0gbmV3IFN0cmluZ1dyaXRlcigpOwotCQlTdHJpbmdUb29scy5jb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT24oc3RyaW5nLCB3cml0ZXIpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHdyaXRlci50b1N0cmluZygpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uU3RyaW5nQnVmZmVyKCkgewotCQl0aGlzLnZlcmlmeUNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPblN0cmluZ0J1ZmZlcigiVEVTVCIsICJ0ZXN0Iik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uU3RyaW5nQnVmZmVyKCJURVNUIiwgIlRFU1QiKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT25TdHJpbmdCdWZmZXIoIlRFU1RfVEVTVCIsICJ0ZXN0VGVzdCIpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPblN0cmluZ0J1ZmZlcigiVEVTVF9URVNUIiwgIlRlc3RUZXN0Iik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uU3RyaW5nQnVmZmVyKCJURVNUX1RFU1RfVEVTVCIsICJ0ZXN0VEVTVFRlc3QiKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT25TdHJpbmdCdWZmZXIoIlRFU1RfVEVTVF9URVNUIiwgIlRlc3RURVNUVGVzdCIpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPblN0cmluZ0J1ZmZlcigiVEVTVF9URVNUX1RFU1RfVCIsICJUZXN0VEVTVFRlc3RUIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPblN0cmluZ0J1ZmZlcihTdHJpbmcgZXhwZWN0ZWQsIFN0cmluZyBzdHJpbmcpIHsKLQkJU3RyaW5nQnVmZmVyIHNiID0gbmV3IFN0cmluZ0J1ZmZlcigpOwotCQlTdHJpbmdUb29scy5jb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT24oc3RyaW5nLCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgc2IudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPblN0cmluZ0J1aWxkZXIoKSB7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uU3RyaW5nQnVpbGRlcigiVEVTVCIsICJ0ZXN0Iik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uU3RyaW5nQnVpbGRlcigiVEVTVCIsICJURVNUIik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uU3RyaW5nQnVpbGRlcigiVEVTVF9URVNUIiwgInRlc3RUZXN0Iik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uU3RyaW5nQnVpbGRlcigiVEVTVF9URVNUIiwgIlRlc3RUZXN0Iik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uU3RyaW5nQnVpbGRlcigiVEVTVF9URVNUX1RFU1QiLCAidGVzdFRFU1RUZXN0Iik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uU3RyaW5nQnVpbGRlcigiVEVTVF9URVNUX1RFU1QiLCAiVGVzdFRFU1RUZXN0Iik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uU3RyaW5nQnVpbGRlcigiVEVTVF9URVNUX1RFU1RfVCIsICJUZXN0VEVTVFRlc3RUIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNPblN0cmluZ0J1aWxkZXIoU3RyaW5nIGV4cGVjdGVkLCBTdHJpbmcgc3RyaW5nKSB7Ci0JCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQlTdHJpbmdUb29scy5jb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT24oc3RyaW5nLCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgc2IudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNNYXhMZW5ndGgoKSB7Ci0JCWFzc2VydEVxdWFscygiVEVTVCIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHMoInRlc3QiLCA0NCkpOwotCQlhc3NlcnRFcXVhbHMoIlRFU1QiLCBTdHJpbmdUb29scy5jb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzKCJ0ZXN0IiwgNCkpOwotCQlhc3NlcnRFcXVhbHMoIlRFUyIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHMoInRlc3QiLCAzKSk7Ci0JCWFzc2VydEVxdWFscygiVEVTVCIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHMoIlRFU1QiLCA1KSk7Ci0JCWFzc2VydEVxdWFscygiVEUiLCBTdHJpbmdUb29scy5jb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzKCJURVNUIiwgMikpOwotCQlhc3NlcnRFcXVhbHMoIlRFU1RfVEVTVCIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHMoInRlc3RUZXN0IiwgOSkpOwotCQlhc3NlcnRFcXVhbHMoIlRFU1RfVEVTIiwgU3RyaW5nVG9vbHMuY29udmVydENhbWVsQ2FzZVRvQWxsQ2FwcygidGVzdFRlc3QiLCA4KSk7Ci0JCWFzc2VydEVxdWFscygiVEVTVF9UIiwgU3RyaW5nVG9vbHMuY29udmVydENhbWVsQ2FzZVRvQWxsQ2FwcygidGVzdFRlc3QiLCA2KSk7Ci0JCWFzc2VydEVxdWFscygiVEVTVF8iLCBTdHJpbmdUb29scy5jb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzKCJ0ZXN0VGVzdCIsIDUpKTsKLQkJYXNzZXJ0RXF1YWxzKCJURVNUIiwgU3RyaW5nVG9vbHMuY29udmVydENhbWVsQ2FzZVRvQWxsQ2FwcygidGVzdFRlc3QiLCA0KSk7Ci0JCWFzc2VydEVxdWFscygiVEVTVF9URVNUIiwgU3RyaW5nVG9vbHMuY29udmVydENhbWVsQ2FzZVRvQWxsQ2FwcygiVGVzdFRlc3QiLCA5KSk7Ci0JCWFzc2VydEVxdWFscygiVEVTVF9URVNUIiwgU3RyaW5nVG9vbHMuY29udmVydENhbWVsQ2FzZVRvQWxsQ2FwcygiVGVzdFRlc3QiLCAxMTAwKSk7Ci0JCWFzc2VydEVxdWFscygiVEVTVF9URVNUXyIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHMoInRlc3RURVNUVGVzdCIsIDEwKSk7Ci0JCWFzc2VydEVxdWFscygiVEVTVF9URVNUX1RFU1QiLCBTdHJpbmdUb29scy5jb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzKCJUZXN0VEVTVFRlc3QiLCAxNCkpOwotCQlhc3NlcnRFcXVhbHMoIlRFU1RfVEVTVF9URVNUX1QiLCBTdHJpbmdUb29scy5jb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzKCJUZXN0VEVTVFRlc3RUIiwgMTYpKTsKLQkJYXNzZXJ0RXF1YWxzKCJURVNUX1RFU1RfVEVTVF8iLCBTdHJpbmdUb29scy5jb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzKCJUZXN0VEVTVFRlc3RUIiwgMTUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uV3JpdGVyKCkgewotCQl0aGlzLnZlcmlmeUNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNNYXhMZW5ndGhPbldyaXRlcigiVEVTVCIsICJ0ZXN0IiwgNDQpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNNYXhMZW5ndGhPbldyaXRlcigiVEVTVCIsICJ0ZXN0IiwgNCk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uV3JpdGVyKCJURVMiLCAidGVzdCIsIDMpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNNYXhMZW5ndGhPbldyaXRlcigiVEVTVCIsICJURVNUIiwgNSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uV3JpdGVyKCJURSIsICJURVNUIiwgMik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uV3JpdGVyKCJURVNUX1RFU1QiLCAidGVzdFRlc3QiLCA5KTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzTWF4TGVuZ3RoT25Xcml0ZXIoIlRFU1RfVEVTIiwgInRlc3RUZXN0IiwgOCk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uV3JpdGVyKCJURVNUX1QiLCAidGVzdFRlc3QiLCA2KTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzTWF4TGVuZ3RoT25Xcml0ZXIoIlRFU1RfIiwgInRlc3RUZXN0IiwgNSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uV3JpdGVyKCJURVNUIiwgInRlc3RUZXN0IiwgNCk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uV3JpdGVyKCJURVNUX1RFU1QiLCAiVGVzdFRlc3QiLCA5KTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzTWF4TGVuZ3RoT25Xcml0ZXIoIlRFU1RfVEVTVCIsICJUZXN0VGVzdCIsIDExMDApOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNNYXhMZW5ndGhPbldyaXRlcigiVEVTVF9URVNUXyIsICJ0ZXN0VEVTVFRlc3QiLCAxMCk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uV3JpdGVyKCJURVNUX1RFU1RfVEVTVCIsICJUZXN0VEVTVFRlc3QiLCAxNCk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uV3JpdGVyKCJURVNUX1RFU1RfVEVTVF9UIiwgIlRlc3RURVNUVGVzdFQiLCAxNik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uV3JpdGVyKCJURVNUX1RFU1RfVEVTVF8iLCAiVGVzdFRFU1RUZXN0VCIsIDE1KTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uV3JpdGVyKFN0cmluZyBleHBlY3RlZCwgU3RyaW5nIHN0cmluZywgaW50IG1heCkgewotCQlXcml0ZXIgd3JpdGVyID0gbmV3IFN0cmluZ1dyaXRlcigpOwotCQlTdHJpbmdUb29scy5jb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzT24oc3RyaW5nLCBtYXgsIHdyaXRlcik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgd3JpdGVyLnRvU3RyaW5nKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzTWF4TGVuZ3RoT25TdHJpbmdCdWZmZXIoKSB7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uU3RyaW5nQnVmZmVyKCJURVNUIiwgInRlc3QiLCA0NCk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uU3RyaW5nQnVmZmVyKCJURVNUIiwgInRlc3QiLCA0KTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzTWF4TGVuZ3RoT25TdHJpbmdCdWZmZXIoIlRFUyIsICJ0ZXN0IiwgMyk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uU3RyaW5nQnVmZmVyKCJURVNUIiwgIlRFU1QiLCA1KTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzTWF4TGVuZ3RoT25TdHJpbmdCdWZmZXIoIlRFIiwgIlRFU1QiLCAyKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzTWF4TGVuZ3RoT25TdHJpbmdCdWZmZXIoIlRFU1RfVEVTVCIsICJ0ZXN0VGVzdCIsIDkpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNNYXhMZW5ndGhPblN0cmluZ0J1ZmZlcigiVEVTVF9URVMiLCAidGVzdFRlc3QiLCA4KTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzTWF4TGVuZ3RoT25TdHJpbmdCdWZmZXIoIlRFU1RfVCIsICJ0ZXN0VGVzdCIsIDYpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNNYXhMZW5ndGhPblN0cmluZ0J1ZmZlcigiVEVTVF8iLCAidGVzdFRlc3QiLCA1KTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzTWF4TGVuZ3RoT25TdHJpbmdCdWZmZXIoIlRFU1QiLCAidGVzdFRlc3QiLCA0KTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzTWF4TGVuZ3RoT25TdHJpbmdCdWZmZXIoIlRFU1RfVEVTVCIsICJUZXN0VGVzdCIsIDkpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRDYW1lbENhc2VUb0FsbENhcHNNYXhMZW5ndGhPblN0cmluZ0J1ZmZlcigiVEVTVF9URVNUIiwgIlRlc3RUZXN0IiwgMTEwMCk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc01heExlbmd0aE9uU3RyaW5nQnVmZmVyKCJURVNUX1RFU1RfIiwgInRlc3RURVNUVGVzdCIsIDEwKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzTWF4TGVuZ3RoT25TdHJpbmdCdWZmZXIoIlRFU1RfVEVTVF9URVNUIiwgIlRlc3RURVNUVGVzdCIsIDE0KTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzTWF4TGVuZ3RoT25TdHJpbmdCdWZmZXIoIlRFU1RfVEVTVF9URVNUX1QiLCAiVGVzdFRFU1RUZXN0VCIsIDE2KTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzTWF4TGVuZ3RoT25TdHJpbmdCdWZmZXIoIlRFU1RfVEVTVF9URVNUXyIsICJUZXN0VEVTVFRlc3RUIiwgMTUpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlDb252ZXJ0Q2FtZWxDYXNlVG9BbGxDYXBzTWF4TGVuZ3RoT25TdHJpbmdCdWZmZXIoU3RyaW5nIGV4cGVjdGVkLCBTdHJpbmcgc3RyaW5nLCBpbnQgbWF4KSB7Ci0JCVN0cmluZ0J1ZmZlciBzYiA9IG5ldyBTdHJpbmdCdWZmZXIoKTsKLQkJU3RyaW5nVG9vbHMuY29udmVydENhbWVsQ2FzZVRvQWxsQ2Fwc09uKHN0cmluZywgbWF4LCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgc2IudG9TdHJpbmcoKSk7Ci0JfQotCi0JLy8gKioqKioqKioqKiBjb252ZXJ0IHVuZGVyc2NvcmVzIHRvIGFsbC1jYXBzICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIHRlc3RDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKCJ0ZXN0IiwgU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UoIlRFU1QiLCBmYWxzZSkpOwotCQlhc3NlcnRFcXVhbHMoInRlc3QiLCBTdHJpbmdUb29scy5jb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZSgiVEVTVF8iLCBmYWxzZSkpOwotCQlhc3NlcnRFcXVhbHMoInRlc3QiLCBTdHJpbmdUb29scy5jb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZSgiVEVTVF9fX18iLCBmYWxzZSkpOwotCQlhc3NlcnRFcXVhbHMoIlRlc3QiLCBTdHJpbmdUb29scy5jb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZSgiVEVTVCIsIHRydWUpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0ZXN0IiwgU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UoIlRlU1QiLCBmYWxzZSkpOwotCQlhc3NlcnRFcXVhbHMoInRlc3RUZXN0IiwgU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UoIlRFU1RfVEVTVCIsIGZhbHNlKSk7Ci0JCWFzc2VydEVxdWFscygidGVzdFRlc3QiLCBTdHJpbmdUb29scy5jb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZSgiVEVTVF9fX1RFU1QiLCBmYWxzZSkpOwotCQlhc3NlcnRFcXVhbHMoIlRlc3RUZXN0IiwgU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UoIlRFU1RfVEVTVCIsIHRydWUpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0ZXN0VGVzdFRlc3QiLCBTdHJpbmdUb29scy5jb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZSgiVEVTVF9URVNUX1RFU1QiLCBmYWxzZSkpOwotCQlhc3NlcnRFcXVhbHMoIlRlc3RUZXN0VGVzdCIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlKCJURVNUX1RFU1RfVEVTVCIsIHRydWUpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0ZXN0VGVzdFRlc3RUIiwgU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UoIlRFU1RfVEVTVF9URVNUX1QiLCBmYWxzZSkpOwotCQlhc3NlcnRFcXVhbHMoInRlc3RUZXN0VGVzdFQiLCBTdHJpbmdUb29scy5jb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZSgiX1RFU1RfVEVTVF9URVNUX1QiLCBmYWxzZSkpOwotCQlhc3NlcnRFcXVhbHMoInRlc3RUZXN0VGVzdFQiLCBTdHJpbmdUb29scy5jb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZSgiX19URVNUX1RFU1RfVEVTVF9UIiwgZmFsc2UpKTsKLQkJYXNzZXJ0RXF1YWxzKCJUZXN0VGVzdFRlc3RUIiwgU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UoIlRFU1RfVEVTVF9URVNUX1QiLCB0cnVlKSk7Ci0JCWFzc2VydEVxdWFscygiVGVzdFRlc3RUZXN0VCIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlKCJfVEVTVF9URVNUX1RFU1RfVCIsIHRydWUpKTsKLQkJYXNzZXJ0RXF1YWxzKCJUZXN0VGVzdFRlc3RUIiwgU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UoIl9fVEVTVF9URVNUX1RFU1RfVCIsIHRydWUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VMb3dlcmNhc2UoKSB7Ci0JCWFzc2VydEVxdWFscygidGVzdCIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlKCJ0ZXN0IiwgZmFsc2UpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0ZXN0IiwgU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UoInRlc3RfIiwgZmFsc2UpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0ZXN0IiwgU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UoInRlc3RfX19fIiwgZmFsc2UpKTsKLQkJYXNzZXJ0RXF1YWxzKCJUZXN0IiwgU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UoInRlc3QiLCB0cnVlKSk7Ci0JCWFzc2VydEVxdWFscygidGVzdCIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlKCJ0ZXN0IiwgZmFsc2UpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0ZXN0VGVzdCIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlKCJ0ZXN0X3Rlc3QiLCBmYWxzZSkpOwotCQlhc3NlcnRFcXVhbHMoInRlc3RUZXN0IiwgU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UoInRlc3RfX190ZXN0IiwgZmFsc2UpKTsKLQkJYXNzZXJ0RXF1YWxzKCJUZXN0VGVzdCIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlKCJ0ZXN0X3Rlc3QiLCB0cnVlKSk7Ci0JCWFzc2VydEVxdWFscygidGVzdFRlc3RUZXN0IiwgU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UoInRlc3RfdGVzdF90ZXN0IiwgZmFsc2UpKTsKLQkJYXNzZXJ0RXF1YWxzKCJUZXN0VGVzdFRlc3QiLCBTdHJpbmdUb29scy5jb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZSgidGVzdF90ZXN0X3Rlc3QiLCB0cnVlKSk7Ci0JCWFzc2VydEVxdWFscygidGVzdFRlc3RUZXN0VCIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlKCJ0ZXN0X3Rlc3RfdGVzdF90IiwgZmFsc2UpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0ZXN0VGVzdFRlc3RUIiwgU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UoIl90ZXN0X3Rlc3RfdGVzdF90IiwgZmFsc2UpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0ZXN0VGVzdFRlc3RUIiwgU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2UoIl9fdGVzdF90ZXN0X3Rlc3RfdCIsIGZhbHNlKSk7Ci0JCWFzc2VydEVxdWFscygiVGVzdFRlc3RUZXN0VCIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlKCJ0ZXN0X3Rlc3RfdGVzdF90IiwgdHJ1ZSkpOwotCQlhc3NlcnRFcXVhbHMoIlRlc3RUZXN0VGVzdFQiLCBTdHJpbmdUb29scy5jb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZSgiX3Rlc3RfdGVzdF90ZXN0X3QiLCB0cnVlKSk7Ci0JCWFzc2VydEVxdWFscygiVGVzdFRlc3RUZXN0VCIsIFN0cmluZ1Rvb2xzLmNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlKCJfX3Rlc3RfdGVzdF90ZXN0X3QiLCB0cnVlKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25Xcml0ZXIoKSB7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbldyaXRlcigidGVzdCIsICJURVNUIiwgZmFsc2UpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25Xcml0ZXIoInRlc3QiLCAiVEVTVF8iLCBmYWxzZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbldyaXRlcigidGVzdCIsICJURVNUX19fXyIsIGZhbHNlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uV3JpdGVyKCJUZXN0IiwgIlRFU1QiLCB0cnVlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uV3JpdGVyKCJ0ZXN0IiwgIlRlU1QiLCBmYWxzZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbldyaXRlcigidGVzdFRlc3QiLCAiVEVTVF9URVNUIiwgZmFsc2UpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25Xcml0ZXIoInRlc3RUZXN0IiwgIlRFU1RfX19URVNUIiwgZmFsc2UpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25Xcml0ZXIoIlRlc3RUZXN0IiwgIlRFU1RfVEVTVCIsIHRydWUpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25Xcml0ZXIoInRlc3RUZXN0VGVzdCIsICJURVNUX1RFU1RfVEVTVCIsIGZhbHNlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uV3JpdGVyKCJUZXN0VGVzdFRlc3QiLCAiVEVTVF9URVNUX1RFU1QiLCB0cnVlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uV3JpdGVyKCJ0ZXN0VGVzdFRlc3RUIiwgIlRFU1RfVEVTVF9URVNUX1QiLCBmYWxzZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbldyaXRlcigidGVzdFRlc3RUZXN0VCIsICJfVEVTVF9URVNUX1RFU1RfVCIsIGZhbHNlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uV3JpdGVyKCJ0ZXN0VGVzdFRlc3RUIiwgIl9fVEVTVF9URVNUX1RFU1RfVCIsIGZhbHNlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uV3JpdGVyKCJUZXN0VGVzdFRlc3RUIiwgIlRFU1RfVEVTVF9URVNUX1QiLCB0cnVlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uV3JpdGVyKCJUZXN0VGVzdFRlc3RUIiwgIl9URVNUX1RFU1RfVEVTVF9UIiwgdHJ1ZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbldyaXRlcigiVGVzdFRlc3RUZXN0VCIsICJfX1RFU1RfVEVTVF9URVNUX1QiLCB0cnVlKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbldyaXRlckxvd2VyY2FzZSgpIHsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uV3JpdGVyKCJ0ZXN0IiwgInRlc3QiLCBmYWxzZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbldyaXRlcigidGVzdCIsICJ0ZXN0XyIsIGZhbHNlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uV3JpdGVyKCJ0ZXN0IiwgInRlc3RfX19fIiwgZmFsc2UpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25Xcml0ZXIoIlRlc3QiLCAidGVzdCIsIHRydWUpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25Xcml0ZXIoInRlc3QiLCAidGVzdCIsIGZhbHNlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uV3JpdGVyKCJ0ZXN0VGVzdCIsICJ0ZXN0X3Rlc3QiLCBmYWxzZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbldyaXRlcigidGVzdFRlc3QiLCAidGVzdF9fX3Rlc3QiLCBmYWxzZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbldyaXRlcigiVGVzdFRlc3QiLCAidGVzdF90ZXN0IiwgdHJ1ZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbldyaXRlcigidGVzdFRlc3RUZXN0IiwgInRlc3RfdGVzdF90ZXN0IiwgZmFsc2UpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25Xcml0ZXIoIlRlc3RUZXN0VGVzdCIsICJ0ZXN0X3Rlc3RfdGVzdCIsIHRydWUpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25Xcml0ZXIoInRlc3RUZXN0VGVzdFQiLCAidGVzdF90ZXN0X3Rlc3RfdCIsIGZhbHNlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uV3JpdGVyKCJ0ZXN0VGVzdFRlc3RUIiwgIl90ZXN0X3Rlc3RfdGVzdF90IiwgZmFsc2UpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25Xcml0ZXIoInRlc3RUZXN0VGVzdFQiLCAiX190ZXN0X3Rlc3RfdGVzdF90IiwgZmFsc2UpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25Xcml0ZXIoIlRlc3RUZXN0VGVzdFQiLCAidGVzdF90ZXN0X3Rlc3RfdCIsIHRydWUpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25Xcml0ZXIoIlRlc3RUZXN0VGVzdFQiLCAiX3Rlc3RfdGVzdF90ZXN0X3QiLCB0cnVlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uV3JpdGVyKCJUZXN0VGVzdFRlc3RUIiwgIl9fdGVzdF90ZXN0X3Rlc3RfdCIsIHRydWUpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uV3JpdGVyKFN0cmluZyBleHBlY3RlZCwgU3RyaW5nIHN0cmluZywgYm9vbGVhbiBjYXBpdGFsaXplRmlyc3RMZXR0ZXIpIHsKLQkJV3JpdGVyIHdyaXRlciA9IG5ldyBTdHJpbmdXcml0ZXIoKTsKLQkJU3RyaW5nVG9vbHMuY29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPbihzdHJpbmcsIGNhcGl0YWxpemVGaXJzdExldHRlciwgd3JpdGVyKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCB3cml0ZXIudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25TdHJpbmdCdWZmZXIoKSB7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPblN0cmluZ0J1ZmZlcigidGVzdCIsICJURVNUIiwgZmFsc2UpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25TdHJpbmdCdWZmZXIoInRlc3QiLCAiVEVTVF8iLCBmYWxzZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPblN0cmluZ0J1ZmZlcigidGVzdCIsICJURVNUX19fXyIsIGZhbHNlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uU3RyaW5nQnVmZmVyKCJUZXN0IiwgIlRFU1QiLCB0cnVlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uU3RyaW5nQnVmZmVyKCJ0ZXN0IiwgIlRlU1QiLCBmYWxzZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPblN0cmluZ0J1ZmZlcigidGVzdFRlc3QiLCAiVEVTVF9URVNUIiwgZmFsc2UpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25TdHJpbmdCdWZmZXIoInRlc3RUZXN0IiwgIlRFU1RfX19URVNUIiwgZmFsc2UpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25TdHJpbmdCdWZmZXIoIlRlc3RUZXN0IiwgIlRFU1RfVEVTVCIsIHRydWUpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25TdHJpbmdCdWZmZXIoInRlc3RUZXN0VGVzdCIsICJURVNUX1RFU1RfVEVTVCIsIGZhbHNlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uU3RyaW5nQnVmZmVyKCJUZXN0VGVzdFRlc3QiLCAiVEVTVF9URVNUX1RFU1QiLCB0cnVlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uU3RyaW5nQnVmZmVyKCJ0ZXN0VGVzdFRlc3RUIiwgIlRFU1RfVEVTVF9URVNUX1QiLCBmYWxzZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPblN0cmluZ0J1ZmZlcigidGVzdFRlc3RUZXN0VCIsICJfVEVTVF9URVNUX1RFU1RfVCIsIGZhbHNlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uU3RyaW5nQnVmZmVyKCJ0ZXN0VGVzdFRlc3RUIiwgIl9fVEVTVF9URVNUX1RFU1RfVCIsIGZhbHNlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uU3RyaW5nQnVmZmVyKCJUZXN0VGVzdFRlc3RUIiwgIlRFU1RfVEVTVF9URVNUX1QiLCB0cnVlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uU3RyaW5nQnVmZmVyKCJUZXN0VGVzdFRlc3RUIiwgIl9URVNUX1RFU1RfVEVTVF9UIiwgdHJ1ZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPblN0cmluZ0J1ZmZlcigiVGVzdFRlc3RUZXN0VCIsICJfX1RFU1RfVEVTVF9URVNUX1QiLCB0cnVlKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPblN0cmluZ0J1ZmZlckxvd2VyY2FzZSgpIHsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uU3RyaW5nQnVmZmVyKCJ0ZXN0IiwgInRlc3QiLCBmYWxzZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPblN0cmluZ0J1ZmZlcigidGVzdCIsICJ0ZXN0XyIsIGZhbHNlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uU3RyaW5nQnVmZmVyKCJ0ZXN0IiwgInRlc3RfX19fIiwgZmFsc2UpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25TdHJpbmdCdWZmZXIoIlRlc3QiLCAidGVzdCIsIHRydWUpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25TdHJpbmdCdWZmZXIoInRlc3QiLCAidGVzdCIsIGZhbHNlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uU3RyaW5nQnVmZmVyKCJ0ZXN0VGVzdCIsICJ0ZXN0X3Rlc3QiLCBmYWxzZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPblN0cmluZ0J1ZmZlcigidGVzdFRlc3QiLCAidGVzdF9fX3Rlc3QiLCBmYWxzZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPblN0cmluZ0J1ZmZlcigiVGVzdFRlc3QiLCAidGVzdF90ZXN0IiwgdHJ1ZSk7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFVuZGVyc2NvcmVzVG9DYW1lbENhc2VPblN0cmluZ0J1ZmZlcigidGVzdFRlc3RUZXN0IiwgInRlc3RfdGVzdF90ZXN0IiwgZmFsc2UpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25TdHJpbmdCdWZmZXIoIlRlc3RUZXN0VGVzdCIsICJ0ZXN0X3Rlc3RfdGVzdCIsIHRydWUpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25TdHJpbmdCdWZmZXIoInRlc3RUZXN0VGVzdFQiLCAidGVzdF90ZXN0X3Rlc3RfdCIsIGZhbHNlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uU3RyaW5nQnVmZmVyKCJ0ZXN0VGVzdFRlc3RUIiwgIl90ZXN0X3Rlc3RfdGVzdF90IiwgZmFsc2UpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25TdHJpbmdCdWZmZXIoInRlc3RUZXN0VGVzdFQiLCAiX190ZXN0X3Rlc3RfdGVzdF90IiwgZmFsc2UpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25TdHJpbmdCdWZmZXIoIlRlc3RUZXN0VGVzdFQiLCAidGVzdF90ZXN0X3Rlc3RfdCIsIHRydWUpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRVbmRlcnNjb3Jlc1RvQ2FtZWxDYXNlT25TdHJpbmdCdWZmZXIoIlRlc3RUZXN0VGVzdFQiLCAiX3Rlc3RfdGVzdF90ZXN0X3QiLCB0cnVlKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uU3RyaW5nQnVmZmVyKCJUZXN0VGVzdFRlc3RUIiwgIl9fdGVzdF90ZXN0X3Rlc3RfdCIsIHRydWUpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlDb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uU3RyaW5nQnVmZmVyKFN0cmluZyBleHBlY3RlZCwgU3RyaW5nIHN0cmluZywgYm9vbGVhbiBjYXBpdGFsaXplRmlyc3RMZXR0ZXIpIHsKLQkJU3RyaW5nQnVmZmVyIHNiID0gbmV3IFN0cmluZ0J1ZmZlcigpOwotCQlTdHJpbmdUb29scy5jb252ZXJ0VW5kZXJzY29yZXNUb0NhbWVsQ2FzZU9uKHN0cmluZywgY2FwaXRhbGl6ZUZpcnN0TGV0dGVyLCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgc2IudG9TdHJpbmcoKSk7Ci0JfQotCi0JLy8gKioqKioqKioqKiBkZWxpbWl0aW5nICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIHRlc3RTdHJpbmdJc1F1b3RlZCgpIHsKLQkJdGhpcy5kZW55U3RyaW5nSXNRdW90ZWQoImZvbyIpOwotCQl0aGlzLnZlcmlmeVN0cmluZ0lzUXVvdGVkKCJcImZvb1wiIik7Ci0KLQkJdGhpcy5kZW55U3RyaW5nSXNRdW90ZWQoIiIpOwotCQl0aGlzLnZlcmlmeVN0cmluZ0lzUXVvdGVkKCJcIlwiIik7Ci0KLQkJdGhpcy5kZW55U3RyaW5nSXNRdW90ZWQoIlwiIik7Ci0JCXRoaXMuZGVueVN0cmluZ0lzUXVvdGVkKCIgIik7Ci0JCXRoaXMuZGVueVN0cmluZ0lzUXVvdGVkKCInJyIpOwotCQl0aGlzLmRlbnlTdHJpbmdJc1F1b3RlZCgiJ2ZvbyciKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5U3RyaW5nSXNRdW90ZWQoU3RyaW5nIHMpIHsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdJc1F1b3RlZChzKSk7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuc3RyaW5nSXNRdW90ZWQocy50b0NoYXJBcnJheSgpKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGRlbnlTdHJpbmdJc1F1b3RlZChTdHJpbmcgcykgewotCQlhc3NlcnRGYWxzZShTdHJpbmdUb29scy5zdHJpbmdJc1F1b3RlZChzKSk7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzUXVvdGVkKHMudG9DaGFyQXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTdHJpbmdJc1BhcmVudGhldGljYWwoKSB7Ci0JCXRoaXMuZGVueVN0cmluZ0lzUGFyZW50aGV0aWNhbCgiZm9vIik7Ci0JCXRoaXMudmVyaWZ5U3RyaW5nSXNQYXJlbnRoZXRpY2FsKCIoZm9vKSIpOwotCi0JCXRoaXMuZGVueVN0cmluZ0lzUGFyZW50aGV0aWNhbCgiIik7Ci0JCXRoaXMudmVyaWZ5U3RyaW5nSXNQYXJlbnRoZXRpY2FsKCIoKSIpOwotCi0JCXRoaXMuZGVueVN0cmluZ0lzUGFyZW50aGV0aWNhbCgiKCIpOwotCQl0aGlzLmRlbnlTdHJpbmdJc1BhcmVudGhldGljYWwoIiAiKTsKLQkJdGhpcy5kZW55U3RyaW5nSXNQYXJlbnRoZXRpY2FsKCInJyIpOwotCQl0aGlzLmRlbnlTdHJpbmdJc1BhcmVudGhldGljYWwoIidmb28nIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVN0cmluZ0lzUGFyZW50aGV0aWNhbChTdHJpbmcgcykgewotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzUGFyZW50aGV0aWNhbChzKSk7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuc3RyaW5nSXNQYXJlbnRoZXRpY2FsKHMudG9DaGFyQXJyYXkoKSkpOwotCX0KLQotCXByaXZhdGUgdm9pZCBkZW55U3RyaW5nSXNQYXJlbnRoZXRpY2FsKFN0cmluZyBzKSB7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzUGFyZW50aGV0aWNhbChzKSk7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzUGFyZW50aGV0aWNhbChzLnRvQ2hhckFycmF5KCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3RyaW5nSXNCcmFja2V0ZWQoKSB7Ci0JCXRoaXMuZGVueVN0cmluZ0lzQnJhY2tldGVkKCJmb28iKTsKLQkJdGhpcy52ZXJpZnlTdHJpbmdJc0JyYWNrZXRlZCgiW2Zvb10iKTsKLQotCQl0aGlzLmRlbnlTdHJpbmdJc0JyYWNrZXRlZCgiIik7Ci0JCXRoaXMudmVyaWZ5U3RyaW5nSXNCcmFja2V0ZWQoIltdIik7Ci0KLQkJdGhpcy5kZW55U3RyaW5nSXNCcmFja2V0ZWQoIlsiKTsKLQkJdGhpcy5kZW55U3RyaW5nSXNCcmFja2V0ZWQoIiAiKTsKLQkJdGhpcy5kZW55U3RyaW5nSXNCcmFja2V0ZWQoIicnIik7Ci0JCXRoaXMuZGVueVN0cmluZ0lzQnJhY2tldGVkKCInZm9vJyIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlTdHJpbmdJc0JyYWNrZXRlZChTdHJpbmcgcykgewotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzQnJhY2tldGVkKHMpKTsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdJc0JyYWNrZXRlZChzLnRvQ2hhckFycmF5KCkpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgZGVueVN0cmluZ0lzQnJhY2tldGVkKFN0cmluZyBzKSB7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzQnJhY2tldGVkKHMpKTsKLQkJYXNzZXJ0RmFsc2UoU3RyaW5nVG9vbHMuc3RyaW5nSXNCcmFja2V0ZWQocy50b0NoYXJBcnJheSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFN0cmluZ0lzQnJhY2VkKCkgewotCQl0aGlzLmRlbnlTdHJpbmdJc0JyYWNlZCgiZm9vIik7Ci0JCXRoaXMudmVyaWZ5U3RyaW5nSXNCcmFjZWQoIntmb299Iik7Ci0KLQkJdGhpcy5kZW55U3RyaW5nSXNCcmFjZWQoIiIpOwotCQl0aGlzLnZlcmlmeVN0cmluZ0lzQnJhY2VkKCJ7fSIpOwotCi0JCXRoaXMuZGVueVN0cmluZ0lzQnJhY2VkKCJ7Iik7Ci0JCXRoaXMuZGVueVN0cmluZ0lzQnJhY2VkKCIgIik7Ci0JCXRoaXMuZGVueVN0cmluZ0lzQnJhY2VkKCInJyIpOwotCQl0aGlzLmRlbnlTdHJpbmdJc0JyYWNlZCgiJ2ZvbyciKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5U3RyaW5nSXNCcmFjZWQoU3RyaW5nIHMpIHsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdJc0JyYWNlZChzKSk7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuc3RyaW5nSXNCcmFjZWQocy50b0NoYXJBcnJheSgpKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGRlbnlTdHJpbmdJc0JyYWNlZChTdHJpbmcgcykgewotCQlhc3NlcnRGYWxzZShTdHJpbmdUb29scy5zdHJpbmdJc0JyYWNlZChzKSk7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzQnJhY2VkKHMudG9DaGFyQXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTdHJpbmdJc0NoZXZyb25lZCgpIHsKLQkJdGhpcy5kZW55U3RyaW5nSXNDaGV2cm9uZWQoImZvbyIpOwotCQl0aGlzLnZlcmlmeVN0cmluZ0lzQ2hldnJvbmVkKCI8Zm9vPiIpOwotCi0JCXRoaXMuZGVueVN0cmluZ0lzQ2hldnJvbmVkKCIiKTsKLQkJdGhpcy52ZXJpZnlTdHJpbmdJc0NoZXZyb25lZCgiPD4iKTsKLQotCQl0aGlzLmRlbnlTdHJpbmdJc0NoZXZyb25lZCgieyIpOwotCQl0aGlzLmRlbnlTdHJpbmdJc0NoZXZyb25lZCgiICIpOwotCQl0aGlzLmRlbnlTdHJpbmdJc0NoZXZyb25lZCgiJyciKTsKLQkJdGhpcy5kZW55U3RyaW5nSXNDaGV2cm9uZWQoIidmb28nIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVN0cmluZ0lzQ2hldnJvbmVkKFN0cmluZyBzKSB7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuc3RyaW5nSXNDaGV2cm9uZWQocykpOwotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzQ2hldnJvbmVkKHMudG9DaGFyQXJyYXkoKSkpOwotCX0KLQotCXByaXZhdGUgdm9pZCBkZW55U3RyaW5nSXNDaGV2cm9uZWQoU3RyaW5nIHMpIHsKLQkJYXNzZXJ0RmFsc2UoU3RyaW5nVG9vbHMuc3RyaW5nSXNDaGV2cm9uZWQocykpOwotCQlhc3NlcnRGYWxzZShTdHJpbmdUb29scy5zdHJpbmdJc0NoZXZyb25lZChzLnRvQ2hhckFycmF5KCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3RyaW5nSXNEZWxpbWl0ZWQoKSB7Ci0JCXRoaXMuZGVueVN0cmluZ0lzRGVsaW1pdGVkKCJmb28iLCAnPycpOwotCQl0aGlzLnZlcmlmeVN0cmluZ0lzRGVsaW1pdGVkKCI/Zm9vPyIsICc/Jyk7Ci0KLQkJdGhpcy5kZW55U3RyaW5nSXNEZWxpbWl0ZWQoIiIsICc/Jyk7Ci0JCXRoaXMudmVyaWZ5U3RyaW5nSXNEZWxpbWl0ZWQoIlwiXCIiLCAnIicpOwotCQl0aGlzLnZlcmlmeVN0cmluZ0lzRGVsaW1pdGVkKCI/eHg/IiwgJz8nKTsKLQkJdGhpcy5kZW55U3RyaW5nSXNEZWxpbWl0ZWQoIj94eF0iLCAnPycpOwotCi0JCXRoaXMuZGVueVN0cmluZ0lzRGVsaW1pdGVkKCJcIiIsICciJyk7Ci0JCXRoaXMuZGVueVN0cmluZ0lzRGVsaW1pdGVkKCIgIiwgJyAnKTsKLQkJdGhpcy5kZW55U3RyaW5nSXNEZWxpbWl0ZWQoIicnIiwgJyInKTsKLQkJdGhpcy5kZW55U3RyaW5nSXNEZWxpbWl0ZWQoIidmb28nIiwgJz8nKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5U3RyaW5nSXNEZWxpbWl0ZWQoU3RyaW5nIHMsIGNoYXIgYykgewotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzRGVsaW1pdGVkKHMsIGMpKTsKLQkJYXNzZXJ0VHJ1ZShTdHJpbmdUb29scy5zdHJpbmdJc0RlbGltaXRlZChzLnRvQ2hhckFycmF5KCksIGMpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgZGVueVN0cmluZ0lzRGVsaW1pdGVkKFN0cmluZyBzLCBjaGFyIGMpIHsKLQkJYXNzZXJ0RmFsc2UoU3RyaW5nVG9vbHMuc3RyaW5nSXNEZWxpbWl0ZWQocywgYykpOwotCQlhc3NlcnRGYWxzZShTdHJpbmdUb29scy5zdHJpbmdJc0RlbGltaXRlZChzLnRvQ2hhckFycmF5KCksIGMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3RyaW5nSXNEZWxpbWl0ZWQyKCkgewotCQl0aGlzLmRlbnlTdHJpbmdJc0RlbGltaXRlZDIoImZvbyIsICdbJywgJ10nKTsKLQkJdGhpcy52ZXJpZnlTdHJpbmdJc0RlbGltaXRlZDIoIntmb299IiwgJ3snLCAnfScpOwotCi0JCXRoaXMuZGVueVN0cmluZ0lzRGVsaW1pdGVkMigiIiwgJ1snLCAnXScpOwotCQl0aGlzLnZlcmlmeVN0cmluZ0lzRGVsaW1pdGVkMigiW10iLCAnWycsICddJyk7Ci0JCXRoaXMudmVyaWZ5U3RyaW5nSXNEZWxpbWl0ZWQyKCJbeHhdIiwgJ1snLCAnXScpOwotCQl0aGlzLmRlbnlTdHJpbmdJc0RlbGltaXRlZDIoIj94eF0iLCAnWycsICddJyk7Ci0KLQkJdGhpcy5kZW55U3RyaW5nSXNEZWxpbWl0ZWQyKCJcIiIsICdbJywgJ10nKTsKLQkJdGhpcy5kZW55U3RyaW5nSXNEZWxpbWl0ZWQyKCIgIiwgJ1snLCAnXScpOwotCQl0aGlzLmRlbnlTdHJpbmdJc0RlbGltaXRlZDIoIicnIiwgJ1snLCAnXScpOwotCQl0aGlzLmRlbnlTdHJpbmdJc0RlbGltaXRlZDIoIidmb28nIiwgJ1snLCAnXScpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlTdHJpbmdJc0RlbGltaXRlZDIoU3RyaW5nIHMsIGNoYXIgc3RhcnQsIGNoYXIgZW5kKSB7Ci0JCWFzc2VydFRydWUoU3RyaW5nVG9vbHMuc3RyaW5nSXNEZWxpbWl0ZWQocywgc3RhcnQsIGVuZCkpOwotCQlhc3NlcnRUcnVlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzRGVsaW1pdGVkKHMudG9DaGFyQXJyYXkoKSwgc3RhcnQsIGVuZCkpOwotCX0KLQotCXByaXZhdGUgdm9pZCBkZW55U3RyaW5nSXNEZWxpbWl0ZWQyKFN0cmluZyBzLCBjaGFyIHN0YXJ0LCBjaGFyIGVuZCkgewotCQlhc3NlcnRGYWxzZShTdHJpbmdUb29scy5zdHJpbmdJc0RlbGltaXRlZChzLCBzdGFydCwgZW5kKSk7Ci0JCWFzc2VydEZhbHNlKFN0cmluZ1Rvb2xzLnN0cmluZ0lzRGVsaW1pdGVkKHMudG9DaGFyQXJyYXkoKSwgc3RhcnQsIGVuZCkpOwotCX0KLQotCS8vICoqKioqKioqKiogdW5kZWxpbWl0aW5nICoqKioqKioqKioKLQotCXB1YmxpYyB2b2lkIHRlc3RVbmRlbGltaXQoKSB7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0KCJcImZvb1wiIiwgImZvbyIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdCgiXCJcIiIsICIiKTsKLQkJdGhpcy52ZXJpZnlVbmRlbGltaXQoIidmb28nIiwgImZvbyIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdCgiXCJmb1wiXCJvXCIiLCAiZm9cIm8iKTsKLQkJdGhpcy52ZXJpZnlVbmRlbGltaXQoIlwiZm9vXCJcIlwiIiwgImZvb1wiIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0KCJcIlwiXCJmb29cIiIsICJcImZvbyIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdCgiW2Zvb10iLCAiZm9vIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0KCJcIlwiXCIiLCAiXCIiKTsKLQkJdGhpcy52ZXJpZnlVbmRlbGltaXQoIlwiZm9vXCJiYXJcIiIsICJmb29cIiIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdCgiXCJmb29cIlwiIiwgImZvb1wiIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVVuZGVsaW1pdChTdHJpbmcgcywgU3RyaW5nIGV4cGVjdGVkKSB7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgU3RyaW5nVG9vbHMudW5kZWxpbWl0KHMpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBTdHJpbmdUb29scy51bmRlbGltaXQocy50b0NoYXJBcnJheSgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFVuZGVsaW1pdEludCgpIHsKLQkJdGhpcy52ZXJpZnlVbmRlbGltaXRJbnQoIlwiZm9vXCIiLCAyLCAibyIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdEludCgiXCJcImZvb1wiXCIiLCAyLCAiZm9vIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0SW50KCInZm9vJyIsIDIsICJvIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVVuZGVsaW1pdEludChTdHJpbmcgcywgaW50IGNvdW50LCBTdHJpbmcgZXhwZWN0ZWQpIHsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBTdHJpbmdUb29scy51bmRlbGltaXQocywgY291bnQpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBTdHJpbmdUb29scy51bmRlbGltaXQocy50b0NoYXJBcnJheSgpLCBjb3VudCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbmRlbGltaXRJbnRFeGNlcHRpb24oKSB7Ci0JCXRoaXMuZGVueVVuZGVsaW1pdEludCgiXCJcIiIsIDIpOwotCQl0aGlzLmRlbnlVbmRlbGltaXRJbnQoIidvJyIsIDIpOwotCX0KLQotCXByaXZhdGUgdm9pZCBkZW55VW5kZWxpbWl0SW50KFN0cmluZyBzLCBpbnQgY291bnQpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJU3RyaW5nIGJvZ3VzID0gU3RyaW5nVG9vbHMudW5kZWxpbWl0KHMsIGNvdW50KTsKLQkJCWZhaWwoImludmFsaWQgc3RyaW5nOiAiICsgYm9ndXMpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQotCQlleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJY2hhcltdIGJvZ3VzID0gU3RyaW5nVG9vbHMudW5kZWxpbWl0KHMudG9DaGFyQXJyYXkoKSwgY291bnQpOwotCQkJZmFpbCgiaW52YWxpZCBzdHJpbmc6ICIgKyBuZXcgU3RyaW5nKGJvZ3VzKSk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbmRlbGltaXRPbldyaXRlcigpIHsKLQkJdGhpcy52ZXJpZnlVbmRlbGltaXRPbldyaXRlcigiXCJmb29cIiIsICJmb28iKTsKLQkJdGhpcy52ZXJpZnlVbmRlbGltaXRPbldyaXRlcigiXCJcIiIsICIiKTsKLQkJdGhpcy52ZXJpZnlVbmRlbGltaXRPbldyaXRlcigiJ2ZvbyciLCAiZm9vIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0T25Xcml0ZXIoIlwiZm9cIlwib1wiIiwgImZvXCJvIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0T25Xcml0ZXIoIlwiZm9vXCJcIlwiIiwgImZvb1wiIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0T25Xcml0ZXIoIlwiXCJcImZvb1wiIiwgIlwiZm9vIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0T25Xcml0ZXIoIltmb29dIiwgImZvbyIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uV3JpdGVyKCJcIlwiXCIiLCAiXCIiKTsKLQkJdGhpcy52ZXJpZnlVbmRlbGltaXRPbldyaXRlcigiXCJmb29cImJhclwiIiwgImZvb1wiIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0T25Xcml0ZXIoIlwiZm9vXCJcIiIsICJmb29cIiIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlVbmRlbGltaXRPbldyaXRlcihTdHJpbmcgcywgU3RyaW5nIGV4cGVjdGVkKSB7Ci0JCVdyaXRlciB3cml0ZXIgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnVuZGVsaW1pdE9uKHMsIHdyaXRlcik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgd3JpdGVyLnRvU3RyaW5nKCkpOwotCi0JCXdyaXRlciA9IG5ldyBTdHJpbmdXcml0ZXIoKTsKLQkJU3RyaW5nVG9vbHMudW5kZWxpbWl0T24ocy50b0NoYXJBcnJheSgpLCB3cml0ZXIpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHdyaXRlci50b1N0cmluZygpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VW5kZWxpbWl0T25TdHJpbmdCdWZmZXIoKSB7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0T25TdHJpbmdCdWZmZXIoIlwiZm9vXCIiLCAiZm9vIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0T25TdHJpbmdCdWZmZXIoIlwiXCIiLCAiIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0T25TdHJpbmdCdWZmZXIoIidmb28nIiwgImZvbyIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uU3RyaW5nQnVmZmVyKCJcImZvXCJcIm9cIiIsICJmb1wibyIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uU3RyaW5nQnVmZmVyKCJcImZvb1wiXCJcIiIsICJmb29cIiIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uU3RyaW5nQnVmZmVyKCJcIlwiXCJmb29cIiIsICJcImZvbyIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uU3RyaW5nQnVmZmVyKCJbZm9vXSIsICJmb28iKTsKLQkJdGhpcy52ZXJpZnlVbmRlbGltaXRPblN0cmluZ0J1ZmZlcigiXCJcIlwiIiwgIlwiIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0T25TdHJpbmdCdWZmZXIoIlwiZm9vXCJiYXJcIiIsICJmb29cIiIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uU3RyaW5nQnVmZmVyKCJcImZvb1wiXCIiLCAiZm9vXCIiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5VW5kZWxpbWl0T25TdHJpbmdCdWZmZXIoU3RyaW5nIHMsIFN0cmluZyBleHBlY3RlZCkgewotCQlTdHJpbmdCdWZmZXIgc2IgPSBuZXcgU3RyaW5nQnVmZmVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnVuZGVsaW1pdE9uKHMsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBzYi50b1N0cmluZygpKTsKLQotCQlzYiA9IG5ldyBTdHJpbmdCdWZmZXIoKTsKLQkJU3RyaW5nVG9vbHMudW5kZWxpbWl0T24ocy50b0NoYXJBcnJheSgpLCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgc2IudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFVuZGVsaW1pdE9uU3RyaW5nQnVpbGRlcigpIHsKLQkJdGhpcy52ZXJpZnlVbmRlbGltaXRPblN0cmluZ0J1aWxkZXIoIlwiZm9vXCIiLCAiZm9vIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0T25TdHJpbmdCdWlsZGVyKCJcIlwiIiwgIiIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uU3RyaW5nQnVpbGRlcigiJ2ZvbyciLCAiZm9vIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0T25TdHJpbmdCdWlsZGVyKCJcImZvXCJcIm9cIiIsICJmb1wibyIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uU3RyaW5nQnVpbGRlcigiXCJmb29cIlwiXCIiLCAiZm9vXCIiKTsKLQkJdGhpcy52ZXJpZnlVbmRlbGltaXRPblN0cmluZ0J1aWxkZXIoIlwiXCJcImZvb1wiIiwgIlwiZm9vIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0T25TdHJpbmdCdWlsZGVyKCJbZm9vXSIsICJmb28iKTsKLQkJdGhpcy52ZXJpZnlVbmRlbGltaXRPblN0cmluZ0J1aWxkZXIoIlwiXCJcIiIsICJcIiIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uU3RyaW5nQnVpbGRlcigiXCJmb29cImJhclwiIiwgImZvb1wiIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0T25TdHJpbmdCdWlsZGVyKCJcImZvb1wiXCIiLCAiZm9vXCIiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5VW5kZWxpbWl0T25TdHJpbmdCdWlsZGVyKFN0cmluZyBzLCBTdHJpbmcgZXhwZWN0ZWQpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnVuZGVsaW1pdE9uKHMsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBzYi50b1N0cmluZygpKTsKLQotCQlzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnVuZGVsaW1pdE9uKHMudG9DaGFyQXJyYXkoKSwgc2IpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHNiLnRvU3RyaW5nKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbmRlbGltaXRPbldyaXRlckNvdW50KCkgewotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uV3JpdGVyQ291bnQoIlwiZm9vXCIiLCAyLCAibyIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uV3JpdGVyQ291bnQoIlwiXCJcIlwiIiwgMiwgIiIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uV3JpdGVyQ291bnQoIlhYZm9vWFgiLCAyLCAiZm9vIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVVuZGVsaW1pdE9uV3JpdGVyQ291bnQoU3RyaW5nIHMsIGludCBjb3VudCwgU3RyaW5nIGV4cGVjdGVkKSB7Ci0JCVdyaXRlciB3cml0ZXIgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnVuZGVsaW1pdE9uKHMsIGNvdW50LCB3cml0ZXIpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHdyaXRlci50b1N0cmluZygpKTsKLQotCQl3cml0ZXIgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnVuZGVsaW1pdE9uKHMudG9DaGFyQXJyYXkoKSwgY291bnQsIHdyaXRlcik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgd3JpdGVyLnRvU3RyaW5nKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbmRlbGltaXRPblN0cmluZ0J1ZmZlckNvdW50KCkgewotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uU3RyaW5nQnVmZmVyQ291bnQoIlwiZm9vXCIiLCAyLCAibyIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uU3RyaW5nQnVmZmVyQ291bnQoIlwiXCJcIlwiIiwgMiwgIiIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uU3RyaW5nQnVmZmVyQ291bnQoIlhYZm9vWFgiLCAyLCAiZm9vIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVVuZGVsaW1pdE9uU3RyaW5nQnVmZmVyQ291bnQoU3RyaW5nIHMsIGludCBjb3VudCwgU3RyaW5nIGV4cGVjdGVkKSB7Ci0JCVN0cmluZ0J1ZmZlciBzYiA9IG5ldyBTdHJpbmdCdWZmZXIoKTsKLQkJU3RyaW5nVG9vbHMudW5kZWxpbWl0T24ocywgY291bnQsIHNiKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBzYi50b1N0cmluZygpKTsKLQotCQlzYiA9IG5ldyBTdHJpbmdCdWZmZXIoKTsKLQkJU3RyaW5nVG9vbHMudW5kZWxpbWl0T24ocy50b0NoYXJBcnJheSgpLCBjb3VudCwgc2IpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHNiLnRvU3RyaW5nKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbmRlbGltaXRPblN0cmluZ0J1aWxkZXJDb3VudCgpIHsKLQkJdGhpcy52ZXJpZnlVbmRlbGltaXRPblN0cmluZ0J1aWxkZXJDb3VudCgiXCJmb29cIiIsIDIsICJvIik7Ci0JCXRoaXMudmVyaWZ5VW5kZWxpbWl0T25TdHJpbmdCdWlsZGVyQ291bnQoIlwiXCJcIlwiIiwgMiwgIiIpOwotCQl0aGlzLnZlcmlmeVVuZGVsaW1pdE9uU3RyaW5nQnVpbGRlckNvdW50KCJYWGZvb1hYIiwgMiwgImZvbyIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlVbmRlbGltaXRPblN0cmluZ0J1aWxkZXJDb3VudChTdHJpbmcgcywgaW50IGNvdW50LCBTdHJpbmcgZXhwZWN0ZWQpIHsKLQkJU3RyaW5nQnVpbGRlciBzYiA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLnVuZGVsaW1pdE9uKHMsIGNvdW50LCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgc2IudG9TdHJpbmcoKSk7Ci0KLQkJc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQlTdHJpbmdUb29scy51bmRlbGltaXRPbihzLnRvQ2hhckFycmF5KCksIGNvdW50LCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgc2IudG9TdHJpbmcoKSk7Ci0JfQotCi0JLy8gKioqKioqKioqKiBjb252ZXJ0aW5nIHRvIEphdmEgc3RyaW5nIGxpdGVyYWwgKioqKioqKioqKgotCi0JcHVibGljIHZvaWQgdGVzdENvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsKCkgewotCQl0aGlzLnZlcmlmeUNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsKCIiLCAiXCJcIiIpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsKCJcIlwiIiwgIlwiXFxcIlxcXCJcIiIpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsKCInZm9vJyIsICJcIidmb28nXCIiKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbCgiZm9vXGJiYXIiLCAiXCJmb29cXGJiYXJcIiIpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsKCJmb29cblx0YmFyIiwgIlwiZm9vXFxuXFx0YmFyXCIiKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbCgiZm9vXCJiYXIiLCAiXCJmb29cXFwiYmFyXCIiKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbCgiZm9vXFxiYXIiLCAiXCJmb29cXFxcYmFyXCIiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5Q29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWwoU3RyaW5nIHMsIFN0cmluZyBleHBlY3RlZCkgewotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIFN0cmluZ1Rvb2xzLmNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsKHMpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBTdHJpbmdUb29scy5jb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbChzLnRvQ2hhckFycmF5KCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPblN0cmluZ0J1ZmZlcigpIHsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbE9uU3RyaW5nQnVmZmVyKCIiLCAiXCJcIiIpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT25TdHJpbmdCdWZmZXIoIlwiXCIiLCAiXCJcXFwiXFxcIlwiIik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPblN0cmluZ0J1ZmZlcigiJ2ZvbyciLCAiXCInZm9vJ1wiIik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPblN0cmluZ0J1ZmZlcigiZm9vXGJiYXIiLCAiXCJmb29cXGJiYXJcIiIpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT25TdHJpbmdCdWZmZXIoImZvb1xuXHRiYXIiLCAiXCJmb29cXG5cXHRiYXJcIiIpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT25TdHJpbmdCdWZmZXIoImZvb1wiYmFyIiwgIlwiZm9vXFxcImJhclwiIik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPblN0cmluZ0J1ZmZlcigiZm9vXFxiYXIiLCAiXCJmb29cXFxcYmFyXCIiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5Q29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPblN0cmluZ0J1ZmZlcihTdHJpbmcgcywgU3RyaW5nIGV4cGVjdGVkKSB7Ci0JCVN0cmluZ0J1ZmZlciBzYiA9IG5ldyBTdHJpbmdCdWZmZXIoKTsKLQkJU3RyaW5nVG9vbHMuY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbihzLCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgc2IudG9TdHJpbmcoKSk7Ci0KLQkJc2IgPSBuZXcgU3RyaW5nQnVmZmVyKCk7Ci0JCVN0cmluZ1Rvb2xzLmNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT24ocy50b0NoYXJBcnJheSgpLCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgc2IudG9TdHJpbmcoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT25TdHJpbmdCdWlsZGVyKCkgewotCQl0aGlzLnZlcmlmeUNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT25TdHJpbmdCdWlsZGVyKCIiLCAiXCJcIiIpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT25TdHJpbmdCdWlsZGVyKCJcIlwiIiwgIlwiXFxcIlxcXCJcIiIpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT25TdHJpbmdCdWlsZGVyKCInZm9vJyIsICJcIidmb28nXCIiKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbE9uU3RyaW5nQnVpbGRlcigiZm9vXGJiYXIiLCAiXCJmb29cXGJiYXJcIiIpOwotCQl0aGlzLnZlcmlmeUNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT25TdHJpbmdCdWlsZGVyKCJmb29cblx0YmFyIiwgIlwiZm9vXFxuXFx0YmFyXCIiKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbE9uU3RyaW5nQnVpbGRlcigiZm9vXCJiYXIiLCAiXCJmb29cXFwiYmFyXCIiKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbE9uU3RyaW5nQnVpbGRlcigiZm9vXFxiYXIiLCAiXCJmb29cXFxcYmFyXCIiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5Q29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPblN0cmluZ0J1aWxkZXIoU3RyaW5nIHMsIFN0cmluZyBleHBlY3RlZCkgewotCQlTdHJpbmdCdWlsZGVyIHNiID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKLQkJU3RyaW5nVG9vbHMuY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbihzLCBzYik7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgc2IudG9TdHJpbmcoKSk7Ci0KLQkJc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOwotCQlTdHJpbmdUb29scy5jb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbE9uKHMudG9DaGFyQXJyYXkoKSwgc2IpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHNiLnRvU3RyaW5nKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbE9uV3JpdGVyKCkgewotCQl0aGlzLnZlcmlmeUNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT25Xcml0ZXIoIiIsICJcIlwiIik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbldyaXRlcigiXCJcIiIsICJcIlxcXCJcXFwiXCIiKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbE9uV3JpdGVyKCInZm9vJyIsICJcIidmb28nXCIiKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbE9uV3JpdGVyKCJmb29cYmJhciIsICJcImZvb1xcYmJhclwiIik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbldyaXRlcigiZm9vXG5cdGJhciIsICJcImZvb1xcblxcdGJhclwiIik7Ci0JCXRoaXMudmVyaWZ5Q29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbldyaXRlcigiZm9vXCJiYXIiLCAiXCJmb29cXFwiYmFyXCIiKTsKLQkJdGhpcy52ZXJpZnlDb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbE9uV3JpdGVyKCJmb29cXGJhciIsICJcImZvb1xcXFxiYXJcIiIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlDb252ZXJ0VG9KYXZhU3RyaW5nTGl0ZXJhbE9uV3JpdGVyKFN0cmluZyBzLCBTdHJpbmcgZXhwZWN0ZWQpIHsKLQkJV3JpdGVyIHdyaXRlciA9IG5ldyBTdHJpbmdXcml0ZXIoKTsKLQkJU3RyaW5nVG9vbHMuY29udmVydFRvSmF2YVN0cmluZ0xpdGVyYWxPbihzLCB3cml0ZXIpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHdyaXRlci50b1N0cmluZygpKTsKLQotCQl3cml0ZXIgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCVN0cmluZ1Rvb2xzLmNvbnZlcnRUb0phdmFTdHJpbmdMaXRlcmFsT24ocy50b0NoYXJBcnJheSgpLCB3cml0ZXIpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHdyaXRlci50b1N0cmluZygpKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvU3luY2hyb25pemVkQm9vbGVhblRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1N5bmNocm9uaXplZEJvb2xlYW5UZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1NDRiN2E1Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvU3luY2hyb25pemVkQm9vbGVhblRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyMjUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TeW5jaHJvbml6ZWRCb29sZWFuOwotCi1wdWJsaWMgY2xhc3MgU3luY2hyb25pemVkQm9vbGVhblRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgdm9sYXRpbGUgU3luY2hyb25pemVkQm9vbGVhbiBzYjsKLQlwcml2YXRlIHZvbGF0aWxlIGJvb2xlYW4gZXhDYXVnaHQ7Ci0JcHJpdmF0ZSB2b2xhdGlsZSBib29sZWFuIHRpbWVvdXRPY2N1cnJlZDsKLQlwcml2YXRlIHZvbGF0aWxlIGxvbmcgc3RhcnRUaW1lOwotCXByaXZhdGUgdm9sYXRpbGUgbG9uZyBlbmRUaW1lOwotCi0KLQlwdWJsaWMgU3luY2hyb25pemVkQm9vbGVhblRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMuc2IgPSBuZXcgU3luY2hyb25pemVkQm9vbGVhbigpOwotCQl0aGlzLmV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRoaXMudGltZW91dE9jY3VycmVkID0gZmFsc2U7Ci0JCXRoaXMuc3RhcnRUaW1lID0gMDsKLQkJdGhpcy5lbmRUaW1lID0gMDsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFjY2Vzc29ycygpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLnNiLnNldFZhbHVlKGZhbHNlKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zYi52YWx1ZSgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zYi5pc1RydWUoKSk7Ci0JCWFzc2VydFRydWUodGhpcy5zYi5pc0ZhbHNlKCkpOwotCi0JCXRoaXMuc2Iuc2V0VmFsdWUodHJ1ZSk7Ci0JCWFzc2VydFRydWUodGhpcy5zYi52YWx1ZSgpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnNiLmlzVHJ1ZSgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zYi5pc0ZhbHNlKCkpOwotCi0JCXRoaXMuc2Iuc2V0RmFsc2UoKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zYi52YWx1ZSgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zYi5pc1RydWUoKSk7Ci0JCWFzc2VydFRydWUodGhpcy5zYi5pc0ZhbHNlKCkpOwotCi0JCXRoaXMuc2Iuc2V0VHJ1ZSgpOwotCQlhc3NlcnRUcnVlKHRoaXMuc2IudmFsdWUoKSk7Ci0JCWFzc2VydFRydWUodGhpcy5zYi5pc1RydWUoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc2IuaXNGYWxzZSgpKTsKLQotCQlhc3NlcnRTYW1lKHRoaXMuc2IsIHRoaXMuc2IubXV0ZXgoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEVxdWFscygpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLnNiLnNldFZhbHVlKGZhbHNlKTsKLQkJU3luY2hyb25pemVkQm9vbGVhbiBzYjIgPSBuZXcgU3luY2hyb25pemVkQm9vbGVhbihmYWxzZSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnNiLCBzYjIpOwotCi0JCXRoaXMuc2Iuc2V0VmFsdWUodHJ1ZSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc2IuZXF1YWxzKHNiMikpOwotCi0JCXNiMi5zZXRWYWx1ZSh0cnVlKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc2IsIHNiMik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc2hDb2RlKCkgewotCQl0aGlzLnNiLnNldFZhbHVlKGZhbHNlKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHRoaXMuc2IuaGFzaENvZGUoKSk7Ci0KLQkJdGhpcy5zYi5zZXRWYWx1ZSh0cnVlKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIHRoaXMuc2IuaGFzaENvZGUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFdhaXRVbnRpbFRydWUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy52ZXJpZnlXYWl0VW50aWxUcnVlKDApOwotCQkvLyBubyB0aW1lb3V0IG9jY3Vycy4uLgotCQlhc3NlcnRGYWxzZSh0aGlzLnRpbWVvdXRPY2N1cnJlZCk7Ci0JCS8vIC4uLmFuZCB0aGUgdmFsdWUgc2hvdWxkIGJlIHNldCB0byB0cnVlIGJ5IHQyCi0JCWFzc2VydFRydWUodGhpcy5zYi52YWx1ZSgpKTsKLQkJLy8gbWFrZSBhIHJlYXNvbmFibGUgZ3Vlc3MgYWJvdXQgaG93IGxvbmcgdDIgdG9vawotCQlhc3NlcnRUcnVlKHRoaXMuZWxhcHNlZFRpbWUoKSA+IDE1MCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFdhaXRVbnRpbFRydWVUaW1lb3V0KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMudmVyaWZ5V2FpdFVudGlsVHJ1ZSgyMCk7Ci0JCS8vIHRpbWVvdXQgb2NjdXJzLi4uCi0JCWFzc2VydFRydWUodGhpcy50aW1lb3V0T2NjdXJyZWQpOwotCQkvLyAuLi5hbmQgdGhlIHZhbHVlIHdpbGwgZXZlbnR1YWxseSBiZSBzZXQgdG8gdHJ1ZSBieSB0MQotCQlhc3NlcnRUcnVlKHRoaXMuc2IudmFsdWUoKSk7Ci0JCS8vIG1ha2UgYSByZWFzb25hYmxlIGd1ZXNzIGFib3V0IGhvdyBsb25nIHQyIHRvb2sKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmVsYXBzZWRUaW1lKCkgPCAxNTApOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlXYWl0VW50aWxUcnVlKGxvbmcgdGltZW91dCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuc2Iuc2V0RmFsc2UoKTsKLQkJUnVubmFibGUgcjEgPSB0aGlzLmJ1aWxkUnVubmFibGUodGhpcy5idWlsZFNldFRydWVDb21tYW5kKCksIHRoaXMuc2IsIDIwMCk7Ci0JCVJ1bm5hYmxlIHIyID0gdGhpcy5idWlsZFJ1bm5hYmxlKHRoaXMuYnVpbGRXYWl0VW50aWxUcnVlQ29tbWFuZCh0aW1lb3V0KSwgdGhpcy5zYiwgMCk7Ci0JCVRocmVhZCB0MSA9IG5ldyBUaHJlYWQocjEpOwotCQlUaHJlYWQgdDIgPSBuZXcgVGhyZWFkKHIyKTsKLQkJdDEuc3RhcnQoKTsKLQkJdDIuc3RhcnQoKTsKLQkJd2hpbGUgKHQxLmlzQWxpdmUoKSB8fCB0Mi5pc0FsaXZlKCkpIHsKLQkJCVRocmVhZC5zbGVlcCg1MCk7Ci0JCX0KLQkJYXNzZXJ0RmFsc2UodGhpcy5leENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFdhaXRUb1NldEZhbHNlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMudmVyaWZ5V2FpdFRvU2V0RmFsc2UoMCk7Ci0JCS8vIG5vIHRpbWVvdXQgb2NjdXJzLi4uCi0JCWFzc2VydEZhbHNlKHRoaXMudGltZW91dE9jY3VycmVkKTsKLQkJLy8gLi4uYW5kIHRoZSB2YWx1ZSBzaG91bGQgYmUgc2V0IHRvIGZhbHNlIGJ5IHQyCi0JCWFzc2VydEZhbHNlKHRoaXMuc2IudmFsdWUoKSk7Ci0JCS8vIG1ha2UgYSByZWFzb25hYmxlIGd1ZXNzIGFib3V0IGhvdyBsb25nIHQyIHRvb2sKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmVsYXBzZWRUaW1lKCkgPiAxNTApOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RXYWl0VG9TZXRGYWxzZVRpbWVvdXQoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy52ZXJpZnlXYWl0VG9TZXRGYWxzZSgyMCk7Ci0JCS8vIHRpbWVvdXQgb2NjdXJzLi4uCi0JCWFzc2VydFRydWUodGhpcy50aW1lb3V0T2NjdXJyZWQpOwotCQkvLyAuLi5hbmQgdGhlIHZhbHVlIHdpbGwgZXZlbnR1YWxseSBiZSBzZXQgdG8gdHJ1ZSBieSB0MQotCQlhc3NlcnRUcnVlKHRoaXMuc2IudmFsdWUoKSk7Ci0JCS8vIG1ha2UgYSByZWFzb25hYmxlIGd1ZXNzIGFib3V0IGhvdyBsb25nIHQyIHRvb2sKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmVsYXBzZWRUaW1lKCkgPCAxNTApOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlXYWl0VG9TZXRGYWxzZShsb25nIHRpbWVvdXQpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLnNiLnNldEZhbHNlKCk7Ci0JCVJ1bm5hYmxlIHIxID0gdGhpcy5idWlsZFJ1bm5hYmxlKHRoaXMuYnVpbGRTZXRUcnVlQ29tbWFuZCgpLCB0aGlzLnNiLCAyMDApOwotCQlSdW5uYWJsZSByMiA9IHRoaXMuYnVpbGRSdW5uYWJsZSh0aGlzLmJ1aWxkV2FpdFRvU2V0RmFsc2VDb21tYW5kKHRpbWVvdXQpLCB0aGlzLnNiLCAwKTsKLQkJVGhyZWFkIHQxID0gbmV3IFRocmVhZChyMSk7Ci0JCVRocmVhZCB0MiA9IG5ldyBUaHJlYWQocjIpOwotCQl0MS5zdGFydCgpOwotCQl0Mi5zdGFydCgpOwotCQl3aGlsZSAodDEuaXNBbGl2ZSgpIHx8IHQyLmlzQWxpdmUoKSkgewotCQkJVGhyZWFkLnNsZWVwKDUwKTsKLQkJfQotCQlhc3NlcnRGYWxzZSh0aGlzLmV4Q2F1Z2h0KTsKLQl9Ci0KLQlwcml2YXRlIENvbW1hbmQgYnVpbGRTZXRUcnVlQ29tbWFuZCgpIHsKLQkJcmV0dXJuIG5ldyBDb21tYW5kKCkgewotCQkJcHVibGljIHZvaWQgZXhlY3V0ZShTeW5jaHJvbml6ZWRCb29sZWFuIHN5bmNCb29sKSB7Ci0JCQkJc3luY0Jvb2wuc2V0VHJ1ZSgpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgQ29tbWFuZCBidWlsZFdhaXRVbnRpbFRydWVDb21tYW5kKGZpbmFsIGxvbmcgdGltZW91dCkgewotCQlyZXR1cm4gbmV3IENvbW1hbmQoKSB7Ci0JCQlwdWJsaWMgdm9pZCBleGVjdXRlKFN5bmNocm9uaXplZEJvb2xlYW4gc3luY0Jvb2wpIHRocm93cyBFeGNlcHRpb24gewotCQkJCVN5bmNocm9uaXplZEJvb2xlYW5UZXN0cy50aGlzLnNldFN0YXJ0VGltZShTeXN0ZW0uY3VycmVudFRpbWVNaWxsaXMoKSk7Ci0JCQkJU3luY2hyb25pemVkQm9vbGVhblRlc3RzLnRoaXMuc2V0VGltZW91dE9jY3VycmVkKCAhIHN5bmNCb29sLndhaXRVbnRpbFRydWUodGltZW91dCkpOwotCQkJCVN5bmNocm9uaXplZEJvb2xlYW5UZXN0cy50aGlzLnNldEVuZFRpbWUoU3lzdGVtLmN1cnJlbnRUaW1lTWlsbGlzKCkpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgQ29tbWFuZCBidWlsZFdhaXRUb1NldEZhbHNlQ29tbWFuZChmaW5hbCBsb25nIHRpbWVvdXQpIHsKLQkJcmV0dXJuIG5ldyBDb21tYW5kKCkgewotCQkJcHVibGljIHZvaWQgZXhlY3V0ZShTeW5jaHJvbml6ZWRCb29sZWFuIHN5bmNCb29sKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJCQlTeW5jaHJvbml6ZWRCb29sZWFuVGVzdHMudGhpcy5zZXRTdGFydFRpbWUoU3lzdGVtLmN1cnJlbnRUaW1lTWlsbGlzKCkpOwotCQkJCVN5bmNocm9uaXplZEJvb2xlYW5UZXN0cy50aGlzLnNldFRpbWVvdXRPY2N1cnJlZCggISBzeW5jQm9vbC53YWl0VG9TZXRGYWxzZSh0aW1lb3V0KSk7Ci0JCQkJU3luY2hyb25pemVkQm9vbGVhblRlc3RzLnRoaXMuc2V0RW5kVGltZShTeXN0ZW0uY3VycmVudFRpbWVNaWxsaXMoKSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBSdW5uYWJsZSBidWlsZFJ1bm5hYmxlKGZpbmFsIENvbW1hbmQgY29tbWFuZCwgZmluYWwgU3luY2hyb25pemVkQm9vbGVhbiBzeW5jQm9vbCwgZmluYWwgbG9uZyBzbGVlcCkgewotCQlyZXR1cm4gbmV3IFJ1bm5hYmxlKCkgewotCQkJcHVibGljIHZvaWQgcnVuKCkgewotCQkJCXRyeSB7Ci0JCQkJCWlmIChzbGVlcCAhPSAwKSB7Ci0JCQkJCQlUaHJlYWQuc2xlZXAoc2xlZXApOwotCQkJCQl9Ci0JCQkJCWNvbW1hbmQuZXhlY3V0ZShzeW5jQm9vbCk7Ci0JCQkJfSBjYXRjaCAoRXhjZXB0aW9uIGV4KSB7Ci0JCQkJCVN5bmNocm9uaXplZEJvb2xlYW5UZXN0cy50aGlzLnNldEV4Q2F1Z2h0KHRydWUpOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQl2b2lkIHNldEV4Q2F1Z2h0KGJvb2xlYW4gZXhDYXVnaHQpIHsKLQkJdGhpcy5leENhdWdodCA9IGV4Q2F1Z2h0OwotCX0KLQotCXZvaWQgc2V0VGltZW91dE9jY3VycmVkKGJvb2xlYW4gdGltZW91dE9jY3VycmVkKSB7Ci0JCXRoaXMudGltZW91dE9jY3VycmVkID0gdGltZW91dE9jY3VycmVkOwotCX0KLQotCXZvaWQgc2V0U3RhcnRUaW1lKGxvbmcgc3RhcnRUaW1lKSB7Ci0JCXRoaXMuc3RhcnRUaW1lID0gc3RhcnRUaW1lOwotCX0KLQotCXZvaWQgc2V0RW5kVGltZShsb25nIGVuZFRpbWUpIHsKLQkJdGhpcy5lbmRUaW1lID0gZW5kVGltZTsKLQl9Ci0KLQlsb25nIGVsYXBzZWRUaW1lKCkgewotCQlyZXR1cm4gdGhpcy5lbmRUaW1lIC0gdGhpcy5zdGFydFRpbWU7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIENvbW1hbmQgaW50ZXJmYWNlICoqKioqKioqKioKLQotCXByaXZhdGUgaW50ZXJmYWNlIENvbW1hbmQgewotCQl2b2lkIGV4ZWN1dGUoU3luY2hyb25pemVkQm9vbGVhbiBzeW5jQm9vbCkgdGhyb3dzIEV4Y2VwdGlvbjsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvU3luY2hyb25pemVkT2JqZWN0VGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvU3luY2hyb25pemVkT2JqZWN0VGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjJjZDEwOS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1N5bmNocm9uaXplZE9iamVjdFRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyOTIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbDsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TeW5jaHJvbml6ZWRPYmplY3Q7Ci0KLXB1YmxpYyBjbGFzcyBTeW5jaHJvbml6ZWRPYmplY3RUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIHZvbGF0aWxlIFN5bmNocm9uaXplZE9iamVjdDxPYmplY3Q+IHNvOwotCXByaXZhdGUgdm9sYXRpbGUgYm9vbGVhbiBleENhdWdodDsKLQlwcml2YXRlIHZvbGF0aWxlIGJvb2xlYW4gdGltZW91dE9jY3VycmVkOwotCXZvbGF0aWxlIE9iamVjdCB2YWx1ZSA9IG5ldyBPYmplY3QoKTsKLQlwcml2YXRlIHZvbGF0aWxlIGxvbmcgc3RhcnRUaW1lOwotCXByaXZhdGUgdm9sYXRpbGUgbG9uZyBlbmRUaW1lOwotCXByaXZhdGUgdm9sYXRpbGUgT2JqZWN0IHNvVmFsdWU7Ci0KLQotCXB1YmxpYyBTeW5jaHJvbml6ZWRPYmplY3RUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLnNvID0gbmV3IFN5bmNocm9uaXplZE9iamVjdDxPYmplY3Q+KCk7Ci0JCXRoaXMuZXhDYXVnaHQgPSBmYWxzZTsKLQkJdGhpcy50aW1lb3V0T2NjdXJyZWQgPSBmYWxzZTsKLQkJdGhpcy5zdGFydFRpbWUgPSAwOwotCQl0aGlzLmVuZFRpbWUgPSAwOwotCQl0aGlzLnNvVmFsdWUgPSBudWxsOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWNjZXNzb3JzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuc28uc2V0VmFsdWUobnVsbCk7Ci0JCWFzc2VydE51bGwodGhpcy5zby52YWx1ZSgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zby5pc05vdE51bGwoKSk7Ci0JCWFzc2VydFRydWUodGhpcy5zby5pc051bGwoKSk7Ci0KLQkJdGhpcy5zby5zZXRWYWx1ZSh0aGlzLnZhbHVlKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMudmFsdWUsIHRoaXMuc28udmFsdWUoKSk7Ci0JCWFzc2VydFRydWUodGhpcy5zby5pc05vdE51bGwoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc28uaXNOdWxsKCkpOwotCi0JCXRoaXMuc28uc2V0TnVsbCgpOwotCQlhc3NlcnROdWxsKHRoaXMuc28udmFsdWUoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc28uaXNOb3ROdWxsKCkpOwotCQlhc3NlcnRUcnVlKHRoaXMuc28uaXNOdWxsKCkpOwotCi0JCWFzc2VydFNhbWUodGhpcy5zbywgdGhpcy5zby5tdXRleCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RXF1YWxzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuc28uc2V0VmFsdWUobnVsbCk7Ci0JCVN5bmNocm9uaXplZE9iamVjdDxPYmplY3Q+IHNvMiA9IG5ldyBTeW5jaHJvbml6ZWRPYmplY3Q8T2JqZWN0PihudWxsKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc28sIHNvMik7Ci0KLQkJdGhpcy5zby5zZXRWYWx1ZSh0aGlzLnZhbHVlKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zby5lcXVhbHMoc28yKSk7Ci0KLQkJc28yLnNldFZhbHVlKHRoaXMudmFsdWUpOwotCQlhc3NlcnRFcXVhbHModGhpcy5zbywgc28yKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzaENvZGUoKSB7Ci0JCXRoaXMuc28uc2V0VmFsdWUodGhpcy52YWx1ZSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnZhbHVlLmhhc2hDb2RlKCksIHRoaXMuc28uaGFzaENvZGUoKSk7Ci0KLQkJdGhpcy5zby5zZXRWYWx1ZShudWxsKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHRoaXMuc28uaGFzaENvZGUoKSk7Ci0JfQotCi0JLyoqCi0JICogdDIgd2lsbCB3YWl0IGluZGVmaW5pdGVseSB1bnRpbCB0MSBzZXRzIHRoZSB2YWx1ZSB0byBudWxsCi0JICovCi0JcHVibGljIHZvaWQgdGVzdFdhaXRVbnRpbE51bGwoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy52ZXJpZnlXYWl0VW50aWxOdWxsKDApOwotCQkvLyBubyB0aW1lb3V0IG9jY3Vycy4uLgotCQlhc3NlcnRGYWxzZSh0aGlzLnRpbWVvdXRPY2N1cnJlZCk7Ci0JCS8vIC4uLmFuZCB0aGUgdmFsdWUgc2hvdWxkIGJlIHNldCB0byBudWxsIGJ5IHQyCi0JCWFzc2VydE51bGwodGhpcy5zby52YWx1ZSgpKTsKLQkJLy8gbWFrZSBhIHJlYXNvbmFibGUgZ3Vlc3MgYWJvdXQgaG93IGxvbmcgdDIgdG9vawotCQlsb25nIHRpbWUgPSB0aGlzLmVsYXBzZWRUaW1lKCk7Ci0JCWFzc2VydFRydWUoInQyIGZpbmlzaGVkIGEgYml0IGVhcmx5IChleHBlY3RlZCB2YWx1ZSBzaG91bGQgYmUgPiAxNTApOiAiICsgdGltZSwgdGltZSA+IDE1MCk7Ci0JfQotCi0JLyoqCi0JICogdDIgd2lsbCB0aW1lIG91dCB3YWl0aW5nIGZvciB0MSB0byBzZXQgdGhlIHZhbHVlIHRvIG51bGwKLQkgKi8KLQlwdWJsaWMgdm9pZCB0ZXN0V2FpdFVudGlsTnVsbFRpbWVvdXQoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy52ZXJpZnlXYWl0VW50aWxOdWxsKDIwKTsKLQkJLy8gdGltZW91dCBvY2N1cnMuLi4KLQkJYXNzZXJ0VHJ1ZSh0aGlzLnRpbWVvdXRPY2N1cnJlZCk7Ci0JCS8vIC4uLmFuZCB0aGUgdmFsdWUgd2lsbCBldmVudHVhbGx5IGJlIHNldCB0byBudWxsIGJ5IHQxCi0JCWFzc2VydE51bGwodGhpcy5zby52YWx1ZSgpKTsKLQkJLy8gbWFrZSBhIHJlYXNvbmFibGUgZ3Vlc3MgYWJvdXQgaG93IGxvbmcgdDIgdG9vawotCQlsb25nIHRpbWUgPSB0aGlzLmVsYXBzZWRUaW1lKCk7Ci0JCWFzc2VydFRydWUoInQyIGZpbmlzaGVkIGEgYml0IGxhdGUgKGV4cGVjdGVkIHZhbHVlIHNob3VsZCBiZSA8IDE1MCk6ICIgKyB0aW1lLCB0aW1lIDwgMTUwKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5V2FpdFVudGlsTnVsbChsb25nIHQyVGltZW91dCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuZXhlY3V0ZVRocmVhZHModGhpcy5idWlsZFNldE51bGxDb21tYW5kKCksIHRoaXMuYnVpbGRXYWl0VW50aWxOdWxsQ29tbWFuZCh0MlRpbWVvdXQpKTsKLQl9Ci0KLQkvKioKLQkgKiB0MiB3aWxsIHdhaXQgaW5kZWZpbml0ZWx5IHVudGlsIHQxIHNldHMgdGhlIHZhbHVlIHRvIG51bGw7Ci0JICogdGhlbiB0MiB3aWxsIHNldCB0aGUgdmFsdWUgdG8gYW4gb2JqZWN0Ci0JICovCi0JcHVibGljIHZvaWQgdGVzdFdhaXRUb1NldFZhbHVlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMudmVyaWZ5V2FpdFRvU2V0VmFsdWUoMCk7Ci0JCS8vIG5vIHRpbWVvdXQgb2NjdXJzLi4uCi0JCWFzc2VydEZhbHNlKHRoaXMudGltZW91dE9jY3VycmVkKTsKLQkJLy8gLi4uYW5kIHRoZSB2YWx1ZSBzaG91bGQgYmUgc2V0IHRvIGFuIG9iamVjdCBieSB0MgotCQlhc3NlcnRUcnVlKHRoaXMuc28uaXNOb3ROdWxsKCkpOwotCQkvLyBtYWtlIGEgcmVhc29uYWJsZSBndWVzcyBhYm91dCBob3cgbG9uZyB0MiB0b29rCi0JCWxvbmcgdGltZSA9IHRoaXMuZWxhcHNlZFRpbWUoKTsKLQkJYXNzZXJ0VHJ1ZSgidDIgZmluaXNoZWQgYSBiaXQgZWFybHkgKGV4cGVjdGVkIHZhbHVlIHNob3VsZCBiZSA+IDE1MCk6ICIgKyB0aW1lLCB0aW1lID4gMTUwKTsKLQl9Ci0KLQkvKioKLQkgKiB0MiB3aWxsIHRpbWUgb3V0IHdhaXRpbmcgZm9yIHQxIHRvIHNldCB0aGUgdmFsdWUgdG8gbnVsbAotCSAqLwotCXB1YmxpYyB2b2lkIHRlc3RXYWl0VG9TZXRWYWx1ZVRpbWVvdXQoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy52ZXJpZnlXYWl0VG9TZXRWYWx1ZSgyMCk7Ci0JCS8vIHRpbWVvdXQgb2NjdXJzLi4uCi0JCWFzc2VydFRydWUodGhpcy50aW1lb3V0T2NjdXJyZWQpOwotCQkvLyAuLi5hbmQgdGhlIHZhbHVlIHdpbGwgZXZlbnR1YWxseSBiZSBzZXQgdG8gbnVsbCBieSB0MQotCQlhc3NlcnRUcnVlKHRoaXMuc28uaXNOdWxsKCkpOwotCQkvLyBtYWtlIGEgcmVhc29uYWJsZSBndWVzcyBhYm91dCBob3cgbG9uZyB0MiB0b29rCi0JCWxvbmcgdGltZSA9IHRoaXMuZWxhcHNlZFRpbWUoKTsKLQkJYXNzZXJ0VHJ1ZSgidDIgZmluaXNoZWQgYSBiaXQgbGF0ZSAoZXhwZWN0ZWQgdmFsdWUgc2hvdWxkIGJlIDwgMTUwKTogIiArIHRpbWUsIHRpbWUgPCAxNTApOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlXYWl0VG9TZXRWYWx1ZShsb25nIHQyVGltZW91dCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuZXhlY3V0ZVRocmVhZHModGhpcy5idWlsZFNldE51bGxDb21tYW5kKCksIHRoaXMuYnVpbGRXYWl0VG9TZXRWYWx1ZUNvbW1hbmQodDJUaW1lb3V0KSk7Ci0JfQotCi0JLyoqCi0JICogdDIgd2lsbCB3YWl0IHVudGlsIHQxIGlzIGZpbmlzaGVkICJpbml0aWFsaXppbmciIHRoZSB2YWx1ZTsKLQkgKiB0aGVuIHQyIHdpbGwgZ2V0IHRoZSBuZXdseS1pbml0aWFsaXplZCB2YWx1ZSAoImZvbyIpCi0JICovCi0JcHVibGljIHZvaWQgdGVzdEV4ZWN1dGUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5zby5zZXRWYWx1ZShudWxsKTsKLQkJUnVubmFibGUgcjEgPSB0aGlzLmJ1aWxkUnVubmFibGUodGhpcy5idWlsZEluaXRpYWxpemVWYWx1ZUNvbW1hbmQoKSwgdGhpcy5zbywgMCk7Ci0JCS8vIGdpdmUgdDEgYSBoZWFkIHN0YXJ0IG9mIDEwMCBtcwotCQlSdW5uYWJsZSByMiA9IHRoaXMuYnVpbGRSdW5uYWJsZSh0aGlzLmJ1aWxkR2V0VmFsdWVDb21tYW5kKCksIHRoaXMuc28sIDEwMCk7Ci0JCVRocmVhZCB0MSA9IG5ldyBUaHJlYWQocjEpOwotCQlUaHJlYWQgdDIgPSBuZXcgVGhyZWFkKHIyKTsKLQkJdDEuc3RhcnQoKTsKLQkJdDIuc3RhcnQoKTsKLQkJd2hpbGUgKHQxLmlzQWxpdmUoKSB8fCB0Mi5pc0FsaXZlKCkpIHsKLQkJCVRocmVhZC5zbGVlcCg1MCk7Ci0JCX0KLQkJYXNzZXJ0RmFsc2UodGhpcy5leENhdWdodCk7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy5zby52YWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCB0aGlzLnNvVmFsdWUpOwotCQkvLyBtYWtlIGEgcmVhc29uYWJsZSBndWVzcyBhYm91dCBob3cgbG9uZyB0MiB0b29rCi0JCWxvbmcgdGltZSA9IHRoaXMuZWxhcHNlZFRpbWUoKTsKLQkJYXNzZXJ0VHJ1ZSgidDIgZmluaXNoZWQgYSBiaXQgZWFybHkgKGV4cGVjdGVkIHZhbHVlIHNob3VsZCBiZSA+IDEwMCk6ICIgKyB0aW1lLCB0aW1lID4gMzAwKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgZXhlY3V0ZVRocmVhZHMoQ29tbWFuZCB0MUNvbW1hbmQsIENvbW1hbmQgdDJDb21tYW5kKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5zby5zZXRWYWx1ZSh0aGlzLnZhbHVlKTsKLQkJUnVubmFibGUgcjEgPSB0aGlzLmJ1aWxkUnVubmFibGUodDFDb21tYW5kLCB0aGlzLnNvLCAyMDApOwotCQlSdW5uYWJsZSByMiA9IHRoaXMuYnVpbGRSdW5uYWJsZSh0MkNvbW1hbmQsIHRoaXMuc28sIDApOwotCQlUaHJlYWQgdDEgPSBuZXcgVGhyZWFkKHIxKTsKLQkJVGhyZWFkIHQyID0gbmV3IFRocmVhZChyMik7Ci0JCXQxLnN0YXJ0KCk7Ci0JCXQyLnN0YXJ0KCk7Ci0JCXdoaWxlICh0MS5pc0FsaXZlKCkgfHwgdDIuaXNBbGl2ZSgpKSB7Ci0JCQlUaHJlYWQuc2xlZXAoNTApOwotCQl9Ci0JCWFzc2VydEZhbHNlKHRoaXMuZXhDYXVnaHQpOwotCX0KLQotCXByaXZhdGUgQ29tbWFuZCBidWlsZFNldE51bGxDb21tYW5kKCkgewotCQlyZXR1cm4gbmV3IENvbW1hbmQoKSB7Ci0JCQlwdWJsaWMgdm9pZCBleGVjdXRlKFN5bmNocm9uaXplZE9iamVjdDxPYmplY3Q+IHNPYmplY3QpIHsKLQkJCQlzT2JqZWN0LnNldE51bGwoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbW1hbmQgYnVpbGRXYWl0VW50aWxOdWxsQ29tbWFuZChmaW5hbCBsb25nIHRpbWVvdXQpIHsKLQkJcmV0dXJuIG5ldyBDb21tYW5kKCkgewotCQkJcHVibGljIHZvaWQgZXhlY3V0ZShTeW5jaHJvbml6ZWRPYmplY3Q8T2JqZWN0PiBzT2JqZWN0KSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJCQlTeW5jaHJvbml6ZWRPYmplY3RUZXN0cy50aGlzLnNldFN0YXJ0VGltZShTeXN0ZW0uY3VycmVudFRpbWVNaWxsaXMoKSk7Ci0JCQkJU3luY2hyb25pemVkT2JqZWN0VGVzdHMudGhpcy5zZXRUaW1lb3V0T2NjdXJyZWQoICEgc09iamVjdC53YWl0VW50aWxOdWxsKHRpbWVvdXQpKTsKLQkJCQlTeW5jaHJvbml6ZWRPYmplY3RUZXN0cy50aGlzLnNldEVuZFRpbWUoU3lzdGVtLmN1cnJlbnRUaW1lTWlsbGlzKCkpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgQ29tbWFuZCBidWlsZFdhaXRUb1NldFZhbHVlQ29tbWFuZChmaW5hbCBsb25nIHRpbWVvdXQpIHsKLQkJcmV0dXJuIG5ldyBDb21tYW5kKCkgewotCQkJcHVibGljIHZvaWQgZXhlY3V0ZShTeW5jaHJvbml6ZWRPYmplY3Q8T2JqZWN0PiBzT2JqZWN0KSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJCQlTeW5jaHJvbml6ZWRPYmplY3RUZXN0cy50aGlzLnNldFN0YXJ0VGltZShTeXN0ZW0uY3VycmVudFRpbWVNaWxsaXMoKSk7Ci0JCQkJU3luY2hyb25pemVkT2JqZWN0VGVzdHMudGhpcy5zZXRUaW1lb3V0T2NjdXJyZWQoICEgc09iamVjdC53YWl0VG9TZXRWYWx1ZShTeW5jaHJvbml6ZWRPYmplY3RUZXN0cy50aGlzLnZhbHVlLCB0aW1lb3V0KSk7Ci0JCQkJU3luY2hyb25pemVkT2JqZWN0VGVzdHMudGhpcy5zZXRFbmRUaW1lKFN5c3RlbS5jdXJyZW50VGltZU1pbGxpcygpKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbW1hbmQgYnVpbGRJbml0aWFsaXplVmFsdWVDb21tYW5kKCkgewotCQlyZXR1cm4gbmV3IENvbW1hbmQoKSB7Ci0JCQlwdWJsaWMgdm9pZCBleGVjdXRlKGZpbmFsIFN5bmNocm9uaXplZE9iamVjdDxPYmplY3Q+IHNPYmplY3QpIHRocm93cyBFeGNlcHRpb24gewotCQkJCXNPYmplY3QuZXhlY3V0ZSgKLQkJCQkJbmV3IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LkNvbW1hbmQoKSB7Ci0JCQkJCQlwdWJsaWMgdm9pZCBleGVjdXRlKCkgewotCQkJCQkJCS8vIHByZXRlbmQgdG8gcGVyZm9ybSBzb21lIGxvbmcgaW5pdGlhbGl6YXRpb24gcHJvY2VzcwotCQkJCQkJCXRyeSB7Ci0JCQkJCQkJCVRocmVhZC5zbGVlcCg1MDApOwotCQkJCQkJCX0gY2F0Y2ggKEV4Y2VwdGlvbiBleCkgewotCQkJCQkJCQlTeW5jaHJvbml6ZWRPYmplY3RUZXN0cy50aGlzLnNldEV4Q2F1Z2h0KHRydWUpOwotCQkJCQkJCX0KLQkJCQkJCQlzT2JqZWN0LnNldFZhbHVlKCJmb28iKTsKLQkJCQkJCX0KLQkJCQkJfQotCQkJCSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBDb21tYW5kIGJ1aWxkR2V0VmFsdWVDb21tYW5kKCkgewotCQlyZXR1cm4gbmV3IENvbW1hbmQoKSB7Ci0JCQlwdWJsaWMgdm9pZCBleGVjdXRlKFN5bmNocm9uaXplZE9iamVjdDxPYmplY3Q+IHNPYmplY3QpIHRocm93cyBFeGNlcHRpb24gewotCQkJCVN5bmNocm9uaXplZE9iamVjdFRlc3RzLnRoaXMuc2V0U3RhcnRUaW1lKFN5c3RlbS5jdXJyZW50VGltZU1pbGxpcygpKTsKLQkJCQlTeW5jaHJvbml6ZWRPYmplY3RUZXN0cy50aGlzLnNldFNPVmFsdWUoc09iamVjdC52YWx1ZSgpKTsKLQkJCQlTeW5jaHJvbml6ZWRPYmplY3RUZXN0cy50aGlzLnNldEVuZFRpbWUoU3lzdGVtLmN1cnJlbnRUaW1lTWlsbGlzKCkpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUnVubmFibGUgYnVpbGRSdW5uYWJsZShmaW5hbCBDb21tYW5kIGNvbW1hbmQsIGZpbmFsIFN5bmNocm9uaXplZE9iamVjdDxPYmplY3Q+IHNPYmplY3QsIGZpbmFsIGxvbmcgc2xlZXApIHsKLQkJcmV0dXJuIG5ldyBSdW5uYWJsZSgpIHsKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQl0cnkgewotCQkJCQlpZiAoc2xlZXAgIT0gMCkgewotCQkJCQkJVGhyZWFkLnNsZWVwKHNsZWVwKTsKLQkJCQkJfQotCQkJCQljb21tYW5kLmV4ZWN1dGUoc09iamVjdCk7Ci0JCQkJfSBjYXRjaCAoRXhjZXB0aW9uIGV4KSB7Ci0JCQkJCVN5bmNocm9uaXplZE9iamVjdFRlc3RzLnRoaXMuc2V0RXhDYXVnaHQodHJ1ZSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXZvaWQgc2V0RXhDYXVnaHQoYm9vbGVhbiBleENhdWdodCkgewotCQl0aGlzLmV4Q2F1Z2h0ID0gZXhDYXVnaHQ7Ci0JfQotCi0Jdm9pZCBzZXRUaW1lb3V0T2NjdXJyZWQoYm9vbGVhbiB0aW1lb3V0T2NjdXJyZWQpIHsKLQkJdGhpcy50aW1lb3V0T2NjdXJyZWQgPSB0aW1lb3V0T2NjdXJyZWQ7Ci0JfQotCi0Jdm9pZCBzZXRTdGFydFRpbWUobG9uZyBzdGFydFRpbWUpIHsKLQkJdGhpcy5zdGFydFRpbWUgPSBzdGFydFRpbWU7Ci0JfQotCi0Jdm9pZCBzZXRFbmRUaW1lKGxvbmcgZW5kVGltZSkgewotCQl0aGlzLmVuZFRpbWUgPSBlbmRUaW1lOwotCX0KLQotCXByaXZhdGUgbG9uZyBlbGFwc2VkVGltZSgpIHsKLQkJcmV0dXJuIHRoaXMuZW5kVGltZSAtIHRoaXMuc3RhcnRUaW1lOwotCX0KLQotCXZvaWQgc2V0U09WYWx1ZShPYmplY3Qgc29WYWx1ZSkgewotCQl0aGlzLnNvVmFsdWUgPSBzb1ZhbHVlOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBDb21tYW5kIGludGVyZmFjZSAqKioqKioqKioqCi0KLQlwcml2YXRlIGludGVyZmFjZSBDb21tYW5kIHsKLQkJdm9pZCBleGVjdXRlKFN5bmNocm9uaXplZE9iamVjdDxPYmplY3Q+IHNvKSB0aHJvd3MgRXhjZXB0aW9uOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9TeW5jaHJvbml6ZWRTdGFja1Rlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1N5bmNocm9uaXplZFN0YWNrVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNTBjMzUzYy4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1N5bmNocm9uaXplZFN0YWNrVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI3MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsOwotCi1pbXBvcnQgamF2YS51dGlsLkVtcHR5U3RhY2tFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU2ltcGxlU3RhY2s7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RhY2s7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3luY2hyb25pemVkU3RhY2s7Ci0KLXB1YmxpYyBjbGFzcyBTeW5jaHJvbml6ZWRTdGFja1Rlc3RzIGV4dGVuZHMgU2ltcGxlU3RhY2tUZXN0cyB7Ci0JcHJpdmF0ZSB2b2xhdGlsZSBTeW5jaHJvbml6ZWRTdGFjazxTdHJpbmc+IHNzOwotCXByaXZhdGUgdm9sYXRpbGUgYm9vbGVhbiBleENhdWdodDsKLQlwcml2YXRlIHZvbGF0aWxlIGJvb2xlYW4gdGltZW91dE9jY3VycmVkOwotCXByaXZhdGUgdm9sYXRpbGUgbG9uZyBzdGFydFRpbWU7Ci0JcHJpdmF0ZSB2b2xhdGlsZSBsb25nIGVuZFRpbWU7Ci0JcHJpdmF0ZSB2b2xhdGlsZSBPYmplY3QgcG9wcGVkT2JqZWN0OwotCi0Jc3RhdGljIGZpbmFsIFN0cmluZyBJVEVNXzEgPSBuZXcgU3RyaW5nKCk7Ci0Jc3RhdGljIGZpbmFsIFN0cmluZyBJVEVNXzIgPSBuZXcgU3RyaW5nKCk7Ci0KLQlwdWJsaWMgU3luY2hyb25pemVkU3RhY2tUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLnNzID0gbmV3IFN5bmNocm9uaXplZFN0YWNrPFN0cmluZz4oKTsKLQkJdGhpcy5leENhdWdodCA9IGZhbHNlOwotCQl0aGlzLnRpbWVvdXRPY2N1cnJlZCA9IGZhbHNlOwotCQl0aGlzLnN0YXJ0VGltZSA9IDA7Ci0JCXRoaXMuZW5kVGltZSA9IDA7Ci0JCXRoaXMucG9wcGVkT2JqZWN0ID0gbnVsbDsKLQl9Ci0KLQkvKioKLQkgKiB0ZXN0IGZpcnN0IHdpdGggYW4gdW5zeW5jaHJvbml6ZWQgc3RhY2ssCi0JICogdGhlbiB3aXRoIGEgc3luY2hyb25pemVkIHN0YWNrCi0JICovCi0JcHVibGljIHZvaWQgdGVzdENvbmN1cnJlbnRBY2Nlc3MoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy52ZXJpZnlDb25jdXJyZW50QWNjZXNzKG5ldyBTbG93U2ltcGxlU3RhY2s8U3RyaW5nPigpLCAic2Vjb25kIik7Ci0JCXRoaXMudmVyaWZ5Q29uY3VycmVudEFjY2VzcyhuZXcgU2xvd1N5bmNocm9uaXplZFN0YWNrPFN0cmluZz4oKSwgImZpcnN0Iik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUNvbmN1cnJlbnRBY2Nlc3MoU2xvd1N0YWNrPFN0cmluZz4gc2xvd1N0YWNrLCBTdHJpbmcgZXhwZWN0ZWQpIHRocm93cyBFeGNlcHRpb24gewotCQlzbG93U3RhY2sucHVzaCgiZmlyc3QiKTsKLQkJc2xvd1N0YWNrLnB1c2goInNlY29uZCIpOwotCi0JCW5ldyBUaHJlYWQodGhpcy5idWlsZFJ1bm5hYmxlKHNsb3dTdGFjaykpLnN0YXJ0KCk7Ci0JCVRocmVhZC5zbGVlcCgyMDApOwotCi0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgc2xvd1N0YWNrLnBvcCgpKTsKLQl9Ci0KLQlwcml2YXRlIFJ1bm5hYmxlIGJ1aWxkUnVubmFibGUoZmluYWwgU2xvd1N0YWNrPFN0cmluZz4gc2xvd1N0YWNrKSB7Ci0JCXJldHVybiBuZXcgUnVubmFibGUoKSB7Ci0JCQlwdWJsaWMgdm9pZCBydW4oKSB7Ci0JCQkJc2xvd1N0YWNrLnNsb3dQb3AoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCXByaXZhdGUgaW50ZXJmYWNlIFNsb3dTdGFjazxFPiBleHRlbmRzIFN0YWNrPEU+IHsKLQkJT2JqZWN0IHNsb3dQb3AoKTsKLQl9Ci0KLQlwcml2YXRlIGNsYXNzIFNsb3dTaW1wbGVTdGFjazxFPiBleHRlbmRzIFNpbXBsZVN0YWNrPEU+IGltcGxlbWVudHMgU2xvd1N0YWNrPEU+IHsKLQkJU2xvd1NpbXBsZVN0YWNrKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQlwdWJsaWMgT2JqZWN0IHNsb3dQb3AoKSB7Ci0JCQl0cnkgewotCQkJCVRocmVhZC5zbGVlcCg1MDApOwotCQkJfSBjYXRjaCAoSW50ZXJydXB0ZWRFeGNlcHRpb24gZXgpIHsKLQkJCQl0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbihleCk7Ci0JCQl9Ci0JCQlyZXR1cm4gdGhpcy5wb3AoKTsKLQkJfQotCi0JfQotCi0JcHJpdmF0ZSBjbGFzcyBTbG93U3luY2hyb25pemVkU3RhY2s8RT4gZXh0ZW5kcyBTeW5jaHJvbml6ZWRTdGFjazxFPiBpbXBsZW1lbnRzIFNsb3dTdGFjazxFPiB7Ci0JCVNsb3dTeW5jaHJvbml6ZWRTdGFjaygpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQkJcHVibGljIHN5bmNocm9uaXplZCBPYmplY3Qgc2xvd1BvcCgpIHsKLQkJCXRyeSB7Ci0JCQkJVGhyZWFkLnNsZWVwKDEwMCk7Ci0JCQl9IGNhdGNoIChJbnRlcnJ1cHRlZEV4Y2VwdGlvbiBleCkgewotCQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGV4KTsKLQkJCX0KLQkJCXJldHVybiB0aGlzLnBvcCgpOwotCQl9Ci0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogd2FpdHMgKioqKioqKioqKgotCi0JcHVibGljIHZvaWQgdGVzdFdhaXRUb1BvcCgpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLnZlcmlmeVdhaXRUb1BvcCgwKTsKLQkJLy8gbm8gdGltZW91dCBvY2N1cnMuLi4KLQkJYXNzZXJ0RmFsc2UodGhpcy50aW1lb3V0T2NjdXJyZWQpOwotCQkvLyAuLi5hbmQgYW4gaXRlbSBzaG91bGQgaGF2ZSBiZWVuIHBvcHBlZCBieSB0Mi4uLgotCQlhc3NlcnRTYW1lKElURU1fMSwgdGhpcy5wb3BwZWRPYmplY3QpOwotCQkvLyAuLi5hbmQgdGhlIHN0YWNrIHNob3VsZCBiZSBlbXB0eQotCQlhc3NlcnRUcnVlKHRoaXMuc3MuaXNFbXB0eSgpKTsKLQkJLy8gbWFrZSBhIHJlYXNvbmFibGUgZ3Vlc3MgYWJvdXQgaG93IGxvbmcgdDIgdG9vawotCQlhc3NlcnRUcnVlKHRoaXMuZWxhcHNlZFRpbWUoKSA+IDE1MCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFdhaXRUb1BvcFRpbWVvdXQoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy52ZXJpZnlXYWl0VG9Qb3AoMjApOwotCQkvLyB0aW1lb3V0IG9jY3Vycy4uLgotCQlhc3NlcnRUcnVlKHRoaXMudGltZW91dE9jY3VycmVkKTsKLQkJLy8gLi4uYW5kIHRoZSBzdGFjayB3YXMgbmV2ZXIgcG9wcGVkLi4uCi0JCWFzc2VydE51bGwodGhpcy5wb3BwZWRPYmplY3QpOwotCQkvLyAuLi5hbmQgaXQgc3RpbGwgaG9sZHMgdGhlIGl0ZW0KLQkJYXNzZXJ0U2FtZShJVEVNXzEsIHRoaXMuc3MucGVlaygpKTsKLQkJLy8gbWFrZSBhIHJlYXNvbmFibGUgZ3Vlc3MgYWJvdXQgaG93IGxvbmcgdDIgdG9vawotCQlhc3NlcnRUcnVlKHRoaXMuZWxhcHNlZFRpbWUoKSA8IDE1MCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVdhaXRUb1BvcChsb25nIHRpbWVvdXQpIHRocm93cyBFeGNlcHRpb24gewotCQlSdW5uYWJsZSByMSA9IHRoaXMuYnVpbGRSdW5uYWJsZSh0aGlzLmJ1aWxkUHVzaENvbW1hbmQoKSwgdGhpcy5zcywgMjAwKTsKLQkJUnVubmFibGUgcjIgPSB0aGlzLmJ1aWxkUnVubmFibGUodGhpcy5idWlsZFdhaXRUb1BvcENvbW1hbmQodGltZW91dCksIHRoaXMuc3MsIDApOwotCQlUaHJlYWQgdDEgPSBuZXcgVGhyZWFkKHIxKTsKLQkJVGhyZWFkIHQyID0gbmV3IFRocmVhZChyMik7Ci0JCXQxLnN0YXJ0KCk7Ci0JCXQyLnN0YXJ0KCk7Ci0JCXdoaWxlICh0MS5pc0FsaXZlKCkgfHwgdDIuaXNBbGl2ZSgpKSB7Ci0JCQlUaHJlYWQuc2xlZXAoNTApOwotCQl9Ci0JCWFzc2VydEZhbHNlKHRoaXMuZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RXYWl0VG9QdXNoKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMudmVyaWZ5V2FpdFRvUHVzaCgwKTsKLQkJLy8gbm8gdGltZW91dCBvY2N1cnMuLi4KLQkJYXNzZXJ0RmFsc2UodGhpcy50aW1lb3V0T2NjdXJyZWQpOwotCQkvLyAuLi5hbmQgdGhlIHN0YWNrIGdldHMgcG9wcGVkIGJ5IHQxLi4uCi0JCWFzc2VydFNhbWUoSVRFTV8xLCB0aGlzLnBvcHBlZE9iamVjdCk7Ci0JCS8vIC4uLmFuZCBhbiBpdGVtIGlzIHB1c2hlZCBvbiB0byB0aGUgc3RhY2sgYnkgdDIKLQkJYXNzZXJ0RmFsc2UodGhpcy5zcy5pc0VtcHR5KCkpOwotCQlhc3NlcnRTYW1lKElURU1fMiwgdGhpcy5zcy5wZWVrKCkpOwotCQkvLyBtYWtlIGEgcmVhc29uYWJsZSBndWVzcyBhYm91dCBob3cgbG9uZyB0MiB0b29rCi0JCWFzc2VydFRydWUodGhpcy5lbGFwc2VkVGltZSgpID4gMTUwKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0V2FpdFRvUHVzaFRpbWVvdXQoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy52ZXJpZnlXYWl0VG9QdXNoKDIwKTsKLQkJLy8gdGltZW91dCBvY2N1cnMuLi4KLQkJYXNzZXJ0VHJ1ZSh0aGlzLnRpbWVvdXRPY2N1cnJlZCk7Ci0JCS8vIC4uLmFuZCB0aGUgc3RhY2sgaXMgZXZlbnR1YWxseSBwb3BwZWQgYnkgdDEuLi4KLQkJYXNzZXJ0U2FtZShJVEVNXzEsIHRoaXMucG9wcGVkT2JqZWN0KTsKLQkJLy8gLi4uYnV0IG5vdGhpbmcgaXMgcHVzaGVkIG9uIHRvIHRoZSBzdGFjayBieSB0MgotCQlhc3NlcnRUcnVlKHRoaXMuc3MuaXNFbXB0eSgpKTsKLQkJLy8gbWFrZSBhIHJlYXNvbmFibGUgZ3Vlc3MgYWJvdXQgaG93IGxvbmcgdDIgdG9vawotCQlhc3NlcnRUcnVlKHRoaXMuZWxhcHNlZFRpbWUoKSA8IDE1MCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVdhaXRUb1B1c2gobG9uZyB0aW1lb3V0KSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5zcy5wdXNoKElURU1fMSk7Ci0JCVJ1bm5hYmxlIHIxID0gdGhpcy5idWlsZFJ1bm5hYmxlKHRoaXMuYnVpbGRQb3BDb21tYW5kKCksIHRoaXMuc3MsIDIwMCk7Ci0JCVJ1bm5hYmxlIHIyID0gdGhpcy5idWlsZFJ1bm5hYmxlKHRoaXMuYnVpbGRXYWl0VG9QdXNoQ29tbWFuZCh0aW1lb3V0KSwgdGhpcy5zcywgMCk7Ci0JCVRocmVhZCB0MSA9IG5ldyBUaHJlYWQocjEpOwotCQlUaHJlYWQgdDIgPSBuZXcgVGhyZWFkKHIyKTsKLQkJdDEuc3RhcnQoKTsKLQkJdDIuc3RhcnQoKTsKLQkJd2hpbGUgKHQxLmlzQWxpdmUoKSB8fCB0Mi5pc0FsaXZlKCkpIHsKLQkJCVRocmVhZC5zbGVlcCg1MCk7Ci0JCX0KLQkJYXNzZXJ0RmFsc2UodGhpcy5leENhdWdodCk7Ci0JfQotCi0JcHJpdmF0ZSBDb21tYW5kIGJ1aWxkUHVzaENvbW1hbmQoKSB7Ci0JCXJldHVybiBuZXcgQ29tbWFuZCgpIHsKLQkJCXB1YmxpYyB2b2lkIGV4ZWN1dGUoU3luY2hyb25pemVkU3RhY2s8U3RyaW5nPiBzeW5jaHJvbml6ZWRTdGFjaykgewotCQkJCXN5bmNocm9uaXplZFN0YWNrLnB1c2goSVRFTV8xKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbW1hbmQgYnVpbGRXYWl0VG9Qb3BDb21tYW5kKGZpbmFsIGxvbmcgdGltZW91dCkgewotCQlyZXR1cm4gbmV3IENvbW1hbmQoKSB7Ci0JCQlwdWJsaWMgdm9pZCBleGVjdXRlKFN5bmNocm9uaXplZFN0YWNrPFN0cmluZz4gc3luY2hyb25pemVkU3RhY2spIHRocm93cyBFeGNlcHRpb24gewotCQkJCVN5bmNocm9uaXplZFN0YWNrVGVzdHMudGhpcy5zZXRTdGFydFRpbWUoU3lzdGVtLmN1cnJlbnRUaW1lTWlsbGlzKCkpOwotCQkJCXRyeSB7Ci0JCQkJCVN5bmNocm9uaXplZFN0YWNrVGVzdHMudGhpcy5zZXRQb3BwZWRPYmplY3Qoc3luY2hyb25pemVkU3RhY2sud2FpdFRvUG9wKHRpbWVvdXQpKTsKLQkJCQl9IGNhdGNoIChFbXB0eVN0YWNrRXhjZXB0aW9uIGV4KSB7Ci0JCQkJCVN5bmNocm9uaXplZFN0YWNrVGVzdHMudGhpcy5zZXRUaW1lb3V0T2NjdXJyZWQodHJ1ZSk7Ci0JCQkJfQotCQkJCVN5bmNocm9uaXplZFN0YWNrVGVzdHMudGhpcy5zZXRFbmRUaW1lKFN5c3RlbS5jdXJyZW50VGltZU1pbGxpcygpKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbW1hbmQgYnVpbGRQb3BDb21tYW5kKCkgewotCQlyZXR1cm4gbmV3IENvbW1hbmQoKSB7Ci0JCQlwdWJsaWMgdm9pZCBleGVjdXRlKFN5bmNocm9uaXplZFN0YWNrPFN0cmluZz4gc3luY2hyb25pemVkU3RhY2spIHsKLQkJCQlTeW5jaHJvbml6ZWRTdGFja1Rlc3RzLnRoaXMuc2V0UG9wcGVkT2JqZWN0KHN5bmNocm9uaXplZFN0YWNrLnBvcCgpKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbW1hbmQgYnVpbGRXYWl0VG9QdXNoQ29tbWFuZChmaW5hbCBsb25nIHRpbWVvdXQpIHsKLQkJcmV0dXJuIG5ldyBDb21tYW5kKCkgewotCQkJcHVibGljIHZvaWQgZXhlY3V0ZShTeW5jaHJvbml6ZWRTdGFjazxTdHJpbmc+IHN5bmNocm9uaXplZFN0YWNrKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJCQlTeW5jaHJvbml6ZWRTdGFja1Rlc3RzLnRoaXMuc2V0U3RhcnRUaW1lKFN5c3RlbS5jdXJyZW50VGltZU1pbGxpcygpKTsKLQkJCQlTeW5jaHJvbml6ZWRTdGFja1Rlc3RzLnRoaXMuc2V0VGltZW91dE9jY3VycmVkKCAhIHN5bmNocm9uaXplZFN0YWNrLndhaXRUb1B1c2goSVRFTV8yLCB0aW1lb3V0KSk7Ci0JCQkJU3luY2hyb25pemVkU3RhY2tUZXN0cy50aGlzLnNldEVuZFRpbWUoU3lzdGVtLmN1cnJlbnRUaW1lTWlsbGlzKCkpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUnVubmFibGUgYnVpbGRSdW5uYWJsZShmaW5hbCBDb21tYW5kIGNvbW1hbmQsIGZpbmFsIFN5bmNocm9uaXplZFN0YWNrPFN0cmluZz4gc3luY2hyb25pemVkU3RhY2ssIGZpbmFsIGxvbmcgc2xlZXApIHsKLQkJcmV0dXJuIG5ldyBSdW5uYWJsZSgpIHsKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQl0cnkgewotCQkJCQlpZiAoc2xlZXAgIT0gMCkgewotCQkJCQkJVGhyZWFkLnNsZWVwKHNsZWVwKTsKLQkJCQkJfQotCQkJCQljb21tYW5kLmV4ZWN1dGUoc3luY2hyb25pemVkU3RhY2spOwotCQkJCX0gY2F0Y2ggKEV4Y2VwdGlvbiBleCkgewotCQkJCQlTeW5jaHJvbml6ZWRTdGFja1Rlc3RzLnRoaXMuc2V0RXhDYXVnaHQodHJ1ZSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXZvaWQgc2V0RXhDYXVnaHQoYm9vbGVhbiBleENhdWdodCkgewotCQl0aGlzLmV4Q2F1Z2h0ID0gZXhDYXVnaHQ7Ci0JfQotCi0Jdm9pZCBzZXRUaW1lb3V0T2NjdXJyZWQoYm9vbGVhbiB0aW1lb3V0T2NjdXJyZWQpIHsKLQkJdGhpcy50aW1lb3V0T2NjdXJyZWQgPSB0aW1lb3V0T2NjdXJyZWQ7Ci0JfQotCi0Jdm9pZCBzZXRTdGFydFRpbWUobG9uZyBzdGFydFRpbWUpIHsKLQkJdGhpcy5zdGFydFRpbWUgPSBzdGFydFRpbWU7Ci0JfQotCi0Jdm9pZCBzZXRFbmRUaW1lKGxvbmcgZW5kVGltZSkgewotCQl0aGlzLmVuZFRpbWUgPSBlbmRUaW1lOwotCX0KLQotCXZvaWQgc2V0UG9wcGVkT2JqZWN0KE9iamVjdCBwb3BwZWRPYmplY3QpIHsKLQkJdGhpcy5wb3BwZWRPYmplY3QgPSBwb3BwZWRPYmplY3Q7Ci0JfQotCi0JbG9uZyBlbGFwc2VkVGltZSgpIHsKLQkJcmV0dXJuIHRoaXMuZW5kVGltZSAtIHRoaXMuc3RhcnRUaW1lOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBDb21tYW5kIGludGVyZmFjZSAqKioqKioqKioqCi0KLQlwcml2YXRlIGludGVyZmFjZSBDb21tYW5kIHsKLQkJdm9pZCBleGVjdXRlKFN5bmNocm9uaXplZFN0YWNrPFN0cmluZz4gc3luY2hyb25pemVkU3RhY2spIHRocm93cyBFeGNlcHRpb247Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1Rlc3RUb29scy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9UZXN0VG9vbHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNTdmZTE5OC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1Rlc3RUb29scy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTQyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWw7Ci0KLWltcG9ydCBqYXZhLmlvLkJ5dGVBcnJheUlucHV0U3RyZWFtOwotaW1wb3J0IGphdmEuaW8uQnl0ZUFycmF5T3V0cHV0U3RyZWFtOwotaW1wb3J0IGphdmEuaW8uSU9FeGNlcHRpb247Ci1pbXBvcnQgamF2YS5pby5PYmplY3RJbnB1dDsKLWltcG9ydCBqYXZhLmlvLk9iamVjdElucHV0U3RyZWFtOwotaW1wb3J0IGphdmEuaW8uT2JqZWN0T3V0cHV0U3RyZWFtOwotaW1wb3J0IGphdmEuaW8uT3V0cHV0U3RyZWFtOwotaW1wb3J0IGphdmEuaW8uUHJpbnRTdHJlYW07Ci1pbXBvcnQgamF2YS5pby5QcmludFdyaXRlcjsKLWltcG9ydCBqYXZhLmlvLlN0cmluZ1dyaXRlcjsKLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5GaWVsZDsKLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5Nb2RpZmllcjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RGYWlsdXJlOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0UmVzdWx0OwotCi0vKioKLSAqIHZhcmlvdXMgdG9vbHMgdGhhdCBjYW4gYmUgdXNlZCBieSB0ZXN0IGNhc2VzCi0gKi8KLXB1YmxpYyBmaW5hbCBjbGFzcyBUZXN0VG9vbHMgewotCi0JLyoqCi0JICogdGVzdCBhbiBvYmplY3QncyBpbXBsZW1lbnRhdGlvbiBvZiBTZXJpYWxpemFibGUgYnkgc2VyaWFsaXppbmcgdGhlCi0JICogc3BlY2lmaWVkIG9iamVjdCB0byBhIGJ5dGUgYXJyYXk7IHRoZW4gZGUtc2VyaWFsaXppbmcgdGhlIGJ5dGUgYXJyYXkgYW5kCi0JICogcmV0dXJuaW5nIHRoZSByZXN1bHRhbnQgb2JqZWN0Ci0JICovCi0JcHVibGljIHN0YXRpYyA8VD4gVCBzZXJpYWxpemUoVCBvKSB0aHJvd3MgSU9FeGNlcHRpb24sIENsYXNzTm90Rm91bmRFeGNlcHRpb24gewotCQlCeXRlQXJyYXlPdXRwdXRTdHJlYW0gYmFPdXRTdHJlYW0gPSBuZXcgQnl0ZUFycmF5T3V0cHV0U3RyZWFtKDIwMDApOwotCQlPYmplY3RPdXRwdXRTdHJlYW0gb3V0U3RyZWFtID0gbmV3IE9iamVjdE91dHB1dFN0cmVhbShiYU91dFN0cmVhbSk7Ci0JCW91dFN0cmVhbS53cml0ZU9iamVjdChvKTsKLQkJb3V0U3RyZWFtLmNsb3NlKCk7Ci0KLQkJQnl0ZUFycmF5SW5wdXRTdHJlYW0gYmFJblN0cmVhbSA9IG5ldyBCeXRlQXJyYXlJbnB1dFN0cmVhbShiYU91dFN0cmVhbS50b0J5dGVBcnJheSgpKTsKLQkJT2JqZWN0SW5wdXRTdHJlYW0gaW5TdHJlYW0gPSBuZXcgT2JqZWN0SW5wdXRTdHJlYW0oYmFJblN0cmVhbSk7Ci0JCVQgbzIgPSByZWFkT2JqZWN0KGluU3RyZWFtKTsKLQkJaW5TdHJlYW0uY2xvc2UoKTsKLQotCQlyZXR1cm4gbzI7Ci0JfQotCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJpdmF0ZSBzdGF0aWMgPFQ+IFQgcmVhZE9iamVjdChPYmplY3RJbnB1dCBvYmplY3RJbnB1dCkgdGhyb3dzIElPRXhjZXB0aW9uLCBDbGFzc05vdEZvdW5kRXhjZXB0aW9uIHsKLQkJcmV0dXJuIChUKSBvYmplY3RJbnB1dC5yZWFkT2JqZWN0KCk7Ci0JfQotCi0JLyoqCi0JICogcmVkaXJlY3Qgc3RkIG91dCBhbmQgc3RkIGVyciB0byB0aGUgc3BlY2lmaWVkIHN0cmVhbQotCSAqLwotCXB1YmxpYyBzdGF0aWMgdm9pZCByZWRpcmVjdFN5c3RlbVN0cmVhbXNUbyhPdXRwdXRTdHJlYW0gb3V0cHV0U3RyZWFtKSB7Ci0JCXJlZGlyZWN0U3lzdGVtU3RyZWFtc1RvKG5ldyBQcmludFN0cmVhbShvdXRwdXRTdHJlYW0pKTsKLQl9Ci0KLQkvKioKLQkgKiByZWRpcmVjdCBzdGQgb3V0IGFuZCBzdGQgZXJyIHRvIHRoZSBzcGVjaWZpZWQgc3RyZWFtCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHJlZGlyZWN0U3lzdGVtU3RyZWFtc1RvKFByaW50U3RyZWFtIHByaW50U3RyZWFtKSB7Ci0JCVN5c3RlbS5zZXRPdXQocHJpbnRTdHJlYW0pOwotCQlTeXN0ZW0uc2V0RXJyKHByaW50U3RyZWFtKTsKLQl9Ci0KLQkvKioKLQkgKiBleGVjdXRlIHRoZSBzcGVjaWZpZWQgdGVzdCBhbmQgZHVtcCB0aGUgcmVzdWx0cyB0byB0aGUgY29uc29sZQotCSAqLwotCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGV4ZWN1dGUoVGVzdENhc2UgdGVzdENhc2UpIHsKLQkJbG9uZyBzdGFydCA9IFN5c3RlbS5jdXJyZW50VGltZU1pbGxpcygpOwotCQlUZXN0UmVzdWx0IHJlc3VsdCA9IHRlc3RDYXNlLnJ1bigpOwotCQlsb25nIGVuZCA9IFN5c3RlbS5jdXJyZW50VGltZU1pbGxpcygpOwotCi0JCVN0cmluZ1dyaXRlciBzdHJpbmdXcml0ZXIgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCVByaW50V3JpdGVyIHdyaXRlciA9IG5ldyBQcmludFdyaXRlcihzdHJpbmdXcml0ZXIpOwotCQl3cml0ZXIucHJpbnQodGVzdENhc2UuZ2V0TmFtZSgpKTsKLQkJd3JpdGVyLnByaW50KCI6ICIpOwotCQlpZiAocmVzdWx0Lndhc1N1Y2Nlc3NmdWwoKSkgewotCQkJd3JpdGVyLnByaW50bG4oIk9LIik7Ci0JCX0gZWxzZSB7Ci0JCQlUZXN0RmFpbHVyZSBmYWlsdXJlID0gbnVsbDsKLQkJCWlmIChyZXN1bHQuZmFpbHVyZXMoKS5oYXNNb3JlRWxlbWVudHMoKSkgewotCQkJCWZhaWx1cmUgPSAoVGVzdEZhaWx1cmUpIHJlc3VsdC5mYWlsdXJlcygpLm5leHRFbGVtZW50KCk7Ci0JCQl9IGVsc2UgewotCQkJCWZhaWx1cmUgPSAoVGVzdEZhaWx1cmUpIHJlc3VsdC5lcnJvcnMoKS5uZXh0RWxlbWVudCgpOwotCQkJfQotCQkJZmFpbHVyZS50aHJvd25FeGNlcHRpb24oKS5wcmludFN0YWNrVHJhY2Uod3JpdGVyKTsKLQkJfQotCQl3cml0ZXIucHJpbnQoImVsYXBzZWQgdGltZTogIik7Ci0JCWxvbmcgZWxhcHNlZCA9IGVuZCAtIHN0YXJ0OwotCQl3cml0ZXIucHJpbnQoZWxhcHNlZCAvIDEwMDBMKTsKLQkJd3JpdGVyLnByaW50bG4oIiBzZWMuIik7Ci0JCXJldHVybiBzdHJpbmdXcml0ZXIudG9TdHJpbmcoKTsKLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBDbGFzczxUZXN0Q2FzZT4gVGVzdENhc2VfY2xhc3MgPSBUZXN0Q2FzZS5jbGFzczsKLQotCS8qKgotCSAqIENsZWFyIG91dCBhbGwgdGhlIGluc3RhbmNlIHZhcmlhYmxlIG9mIHRoZSBzcGVjaWZpZWQgdGVzdCBjYXNlLCBhbGxvd2luZwotCSAqIHRoZSB2YXJpb3VzIHRlc3QgZml4dHVyZXMgdG8gYmUgZ2FyYmFnZS1jb2xsZWN0ZWQuIFR5cGljYWxseSB0aGlzIGlzCi0JICogY2FsbGVkIGluIHRoZSAjdGVhckRvd24oKSBtZXRob2QuCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIGNsZWFyKFRlc3RDYXNlIHRlc3RDYXNlKSB0aHJvd3MgSWxsZWdhbEFjY2Vzc0V4Y2VwdGlvbiB7Ci0JCWZvciAoQ2xhc3M8Pz4gdGVtcENsYXNzID0gdGVzdENhc2UuZ2V0Q2xhc3MoKTsgdGVtcENsYXNzICE9IFRlc3RDYXNlX2NsYXNzOyB0ZW1wQ2xhc3MgPSB0ZW1wQ2xhc3MuZ2V0U3VwZXJjbGFzcygpKSB7Ci0JCQlGaWVsZFtdIGZpZWxkcyA9IHRlbXBDbGFzcy5nZXREZWNsYXJlZEZpZWxkcygpOwotCQkJZm9yIChpbnQgaSA9IGZpZWxkcy5sZW5ndGg7IGktLSA+IDA7KSB7Ci0JCQkJRmllbGQgZmllbGQgPSBmaWVsZHNbaV07Ci0JCQkJLy8gbGVhdmUgcHJpbWl0aXZlcyBhbG9uZSAtIHRoZXkgZG9uJ3QgZ2V0IGdhcmJhZ2UtY29sbGVjdGVkLCBhbmQgd2UgY2FuJ3Qgc2V0IHRoZW0gdG8gbnVsbC4uLgotCQkJCWlmIChmaWVsZC5nZXRUeXBlKCkuaXNQcmltaXRpdmUoKSkgewotCQkJCQljb250aW51ZTsKLQkJCQl9Ci0JCQkJLy8gbGVhdmUgc3RhdGljIGZpZWxkcyBhbG9uZSAoPykKLQkJCQlpZiAoTW9kaWZpZXIuaXNTdGF0aWMoZmllbGQuZ2V0TW9kaWZpZXJzKCkpKSB7Ci0JCQkJCWNvbnRpbnVlOwotCQkJCX0KLQkJCQlmaWVsZC5zZXRBY2Nlc3NpYmxlKHRydWUpOwotCQkJCWZpZWxkLnNldCh0ZXN0Q2FzZSwgbnVsbCk7Ci0JCQl9Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBXb3JrYXJvdW5kIGZvciBhIEpVbml0IGJ1ZzogSlVuaXQgZG9lcyBub3QgY29uZmlndXJlIHRoZSB0ZXN0aW5nIFRocmVhZAotCSAqIHdpdGggYSBjb250ZXh0IGNsYXNzIGxvYWRlci4gVGhpcyBzaG91bGQgcHJvYmFibHkgaGFwcGVuIGluCi0JICogVGVzdFJ1bm5lci5kb1J1blRlc3QoVGVzdCksIGp1c3QgYmVmb3JlIHN0YXJ0aW5nIHRoZSB0aHJlYWQuCi0JICovCi0JcHVibGljIHN0YXRpYyB2b2lkIHNldFVwSlVuaXRUaHJlYWRDb250ZXh0Q2xhc3NMb2FkZXIoKSB7Ci0JCVRocmVhZC5jdXJyZW50VGhyZWFkKCkuc2V0Q29udGV4dENsYXNzTG9hZGVyKFRlc3RUb29scy5jbGFzcy5nZXRDbGFzc0xvYWRlcigpKTsKLQl9Ci0KLQlwcml2YXRlIFRlc3RUb29scygpIHsKLQkJc3VwZXIoKTsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1hNTFN0cmluZ0VuY29kZXJUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9YTUxTdHJpbmdFbmNvZGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggM2IxMDRiOS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL1hNTFN0cmluZ0VuY29kZXJUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTM1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWw7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuRmlsZVRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlhNTFN0cmluZ0VuY29kZXI7Ci0KLXB1YmxpYyBjbGFzcyBYTUxTdHJpbmdFbmNvZGVyVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQlwdWJsaWMgWE1MU3RyaW5nRW5jb2RlclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RFbmNvZGVOb0NoYXJhY3RlclNlcXVlbmNlcygpIHsKLQkJWE1MU3RyaW5nRW5jb2RlciBlbmNvZGVyID0gbmV3IFhNTFN0cmluZ0VuY29kZXIoRmlsZVRvb2xzLklOVkFMSURfRklMRU5BTUVfQ0hBUkFDVEVSUyk7Ci0KLQkJU3RyaW5nIHMgPSAiZm9vIjsKLQkJYXNzZXJ0RXF1YWxzKHMsIGVuY29kZXIuZW5jb2RlKHMpKTsKLQotCQlzID0gIjEyM2ZvbzEyMyI7Ci0JCWFzc2VydEVxdWFscyhzLCBlbmNvZGVyLmVuY29kZShzKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEVuY29kZUNoYXJhY3RlclNlcXVlbmNlcygpIHsKLQkJWE1MU3RyaW5nRW5jb2RlciBlbmNvZGVyID0gbmV3IFhNTFN0cmluZ0VuY29kZXIoRmlsZVRvb2xzLklOVkFMSURfRklMRU5BTUVfQ0hBUkFDVEVSUyk7Ci0KLQkJU3RyaW5nIHMgPSAiP2Zvbz8iOwotCQlTdHJpbmcgZXhwZWN0ZWQgPSAiJiN4M2Y7Zm9vJiN4M2Y7IjsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBlbmNvZGVyLmVuY29kZShzKSk7Ci0KLQkJcyA9ICI/Zm9vJjEyMyI7Ci0JCWV4cGVjdGVkID0gIiYjeDNmO2ZvbyYjeDI2OzEyMyI7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgZW5jb2Rlci5lbmNvZGUocykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3REZW5vcm1hbGl6ZVZhbGlkRmlsZU5hbWUoKSB7Ci0JCVhNTFN0cmluZ0VuY29kZXIgZW5jb2RlciA9IG5ldyBYTUxTdHJpbmdFbmNvZGVyKEZpbGVUb29scy5JTlZBTElEX0ZJTEVOQU1FX0NIQVJBQ1RFUlMpOwotCi0JCVN0cmluZyBzID0gImZvbyI7Ci0JCWFzc2VydEVxdWFscyhzLCBlbmNvZGVyLmRlY29kZShzKSk7Ci0KLQkJcyA9ICIxMjNmb28xMjMiOwotCQlhc3NlcnRFcXVhbHMocywgZW5jb2Rlci5kZWNvZGUocykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3REZW5vcm1hbGl6ZUludmFsaWRGaWxlTmFtZSgpIHsKLQkJWE1MU3RyaW5nRW5jb2RlciBlbmNvZGVyID0gbmV3IFhNTFN0cmluZ0VuY29kZXIoRmlsZVRvb2xzLklOVkFMSURfRklMRU5BTUVfQ0hBUkFDVEVSUyk7Ci0KLQkJU3RyaW5nIHMgPSAiJiN4M2Y7Zm9vJiN4M2Y7IjsKLQkJU3RyaW5nIGV4cGVjdGVkID0gIj9mb28/IjsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBlbmNvZGVyLmRlY29kZShzKSk7Ci0KLQkJcyA9ICImI3gzZjtmb28mI3gyNjsxMjMiOwotCQlleHBlY3RlZCA9ICI/Zm9vJjEyMyI7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgZW5jb2Rlci5kZWNvZGUocykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSb3VuZFRyaXBOb0NoYXJhY3RlclNlcXVlbmNlcygpIHsKLQkJdGhpcy52ZXJpZnlSb3VuZFRyaXAoImZvbyIpOwotCQl0aGlzLnZlcmlmeVJvdW5kVHJpcCgiMTIzZm9vNDU2Iik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJvdW5kVHJpcENoYXJhY3RlclNlcXVlbmNlcygpIHsKLQkJdGhpcy52ZXJpZnlSb3VuZFRyaXAoIj9mb28/Iik7Ci0JCXRoaXMudmVyaWZ5Um91bmRUcmlwKCI/Zm9vJjEyMyYmJiYmJj4+Pj4iKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5Um91bmRUcmlwKFN0cmluZyBzKSB7Ci0JCVhNTFN0cmluZ0VuY29kZXIgZW5jb2RlciA9IG5ldyBYTUxTdHJpbmdFbmNvZGVyKEZpbGVUb29scy5JTlZBTElEX0ZJTEVOQU1FX0NIQVJBQ1RFUlMpOwotCQlTdHJpbmcgYWN0dWFsID0gZW5jb2Rlci5lbmNvZGUocyk7Ci0JCWFzc2VydEVxdWFscyhzLCBlbmNvZGVyLmRlY29kZShhY3R1YWwpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZENoYXJhY3RlclNlcXVlbmNlMSgpIHsKLQkJdGhpcy52ZXJpZnlJbGxlZ2FsU3RhdGVFeGNlcHRpb24oImZvbyYiKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZENoYXJhY3RlclNlcXVlbmNlMigpIHsKLQkJdGhpcy52ZXJpZnlJbGxlZ2FsU3RhdGVFeGNlcHRpb24oImZvbyYjIik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEludmFsaWRDaGFyYWN0ZXJTZXF1ZW5jZTMoKSB7Ci0JCXRoaXMudmVyaWZ5SWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJmb28mI3giKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZENoYXJhY3RlclNlcXVlbmNlNCgpIHsKLQkJdGhpcy52ZXJpZnlJbGxlZ2FsU3RhdGVFeGNlcHRpb24oImZvbyYjeDMiKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZENoYXJhY3RlclNlcXVlbmNlNSgpIHsKLQkJdGhpcy52ZXJpZnlJbGxlZ2FsU3RhdGVFeGNlcHRpb24oImZvbyYjeDsiKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZENoYXJhY3RlclNlcXVlbmNlNigpIHsKLQkJdGhpcy52ZXJpZnlJbGxlZ2FsU3RhdGVFeGNlcHRpb24oImZvbyZBIik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEludmFsaWRDaGFyYWN0ZXJTZXF1ZW5jZTcoKSB7Ci0JCXRoaXMudmVyaWZ5SWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJmb28mI0EiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5SWxsZWdhbFN0YXRlRXhjZXB0aW9uKFN0cmluZyBzKSB7Ci0JCVhNTFN0cmluZ0VuY29kZXIgZW5jb2RlciA9IG5ldyBYTUxTdHJpbmdFbmNvZGVyKEZpbGVUb29scy5JTlZBTElEX0ZJTEVOQU1FX0NIQVJBQ1RFUlMpOwotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlzID0gZW5jb2Rlci5kZWNvZGUocyk7Ci0JCQlmYWlsKHMpOwotCQl9IGNhdGNoIChJbGxlZ2FsU3RhdGVFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZENoYXJhY3RlclNlcXVlbmNlOCgpIHsKLQkJU3RyaW5nIHMgPSAiZm9vJiN4WlpaWjsiOwotCQlYTUxTdHJpbmdFbmNvZGVyIGVuY29kZXIgPSBuZXcgWE1MU3RyaW5nRW5jb2RlcihGaWxlVG9vbHMuSU5WQUxJRF9GSUxFTkFNRV9DSEFSQUNURVJTKTsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJcyA9IGVuY29kZXIuZGVjb2RlKHMpOwotCQkJZmFpbChzKTsKLQkJfSBjYXRjaCAoTnVtYmVyRm9ybWF0RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9BcnJheUl0ZXJhdG9yVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL0FycmF5SXRlcmF0b3JUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkMjMwOWMzLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL0FycmF5SXRlcmF0b3JUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTI2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Ob1N1Y2hFbGVtZW50RXhjZXB0aW9uOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuQXJyYXlJdGVyYXRvcjsKLQotcHVibGljIGNsYXNzIEFycmF5SXRlcmF0b3JUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBBcnJheUl0ZXJhdG9yVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc05leHQoKSB7Ci0JCWludCBpID0gMDsKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHModGhpcy5idWlsZEFycmF5KCkubGVuZ3RoLCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TmV4dCgpIHsKLQkJaW50IGkgPSAwOwotCQlmb3IgKEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZEl0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlhc3NlcnRFcXVhbHMoImJvZ3VzIGVsZW1lbnQiLCArK2ksIEludGVnZXIucGFyc2VJbnQoc3RyZWFtLm5leHQoKSkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5vU3VjaEVsZW1lbnRFeGNlcHRpb24oKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkSXRlcmF0b3IoKTsKLQkJU3RyaW5nIHN0cmluZyA9IG51bGw7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlzdHJpbmcgPSBzdHJlYW0ubmV4dCgpOwotCQl9Ci0JCXRyeSB7Ci0JCQlzdHJpbmcgPSBzdHJlYW0ubmV4dCgpOwotCQl9IGNhdGNoIChOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBub3QgdGhyb3duOiAiICsgc3RyaW5nLCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCWZvciAoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkSXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCWlmIChzdHJlYW0ubmV4dCgpLmVxdWFscygiMyIpKSB7Ci0JCQkJdHJ5IHsKLQkJCQkJc3RyZWFtLnJlbW92ZSgpOwotCQkJCX0gY2F0Y2ggKFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIGV4KSB7Ci0JCQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKCkgewotCQl0aGlzLnRyaWdnZXJJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oLTEsIDEpOwotCQl0aGlzLnRyaWdnZXJJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oOCwgMSk7Ci0JCXRoaXMudHJpZ2dlcklsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigwLCAtMSk7Ci0JCXRoaXMudHJpZ2dlcklsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbigwLCA5KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0R2VuZXJpY3MoKSB7Ci0JCUludGVnZXJbXSBpbnRlZ2VycyA9IG5ldyBJbnRlZ2VyWzNdOwotCQlpbnRlZ2Vyc1swXSA9IG5ldyBJbnRlZ2VyKDApOwotCQlpbnRlZ2Vyc1sxXSA9IG5ldyBJbnRlZ2VyKDEpOwotCQlpbnRlZ2Vyc1syXSA9IG5ldyBJbnRlZ2VyKDIpOwotCQlpbnQgaSA9IDA7Ci0JCWZvciAoSXRlcmF0b3I8TnVtYmVyPiBzdHJlYW0gPSBuZXcgQXJyYXlJdGVyYXRvcjxOdW1iZXI+KGludGVnZXJzKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCWFzc2VydEVxdWFscyhpKyssIHN0cmVhbS5uZXh0KCkuaW50VmFsdWUoKSk7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKGludGVnZXJzLmxlbmd0aCwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFZhcmFyZ3MoKSB7Ci0JCWludCBpID0gMDsKLQkJZm9yIChJdGVyYXRvcjxOdW1iZXI+IHN0cmVhbSA9IG5ldyBBcnJheUl0ZXJhdG9yPE51bWJlcj4obmV3IEludGVnZXIoMCksIG5ldyBJbnRlZ2VyKDEpLCBuZXcgSW50ZWdlcigyKSk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlhc3NlcnRFcXVhbHMoaSsrLCBzdHJlYW0ubmV4dCgpLmludFZhbHVlKCkpOwotCQl9Ci0JCWFzc2VydEVxdWFscygzLCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0cmlnZ2VySWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKGludCBzdGFydCwgaW50IGxlbmd0aCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gbnVsbDsKLQkJdHJ5IHsKLQkJCXN0cmVhbSA9IHRoaXMuYnVpbGRJdGVyYXRvcihzdGFydCwgbGVuZ3RoKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIG5vdCB0aHJvd246ICIgKyBzdHJlYW0sIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkSXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkSXRlcmF0b3IodGhpcy5idWlsZEFycmF5KCkpOwotCX0KLQotCUl0ZXJhdG9yPFN0cmluZz4gYnVpbGRJdGVyYXRvcihTdHJpbmdbXSBhcnJheSkgewotCQlyZXR1cm4gbmV3IEFycmF5SXRlcmF0b3I8U3RyaW5nPihhcnJheSk7Ci0JfQotCi0JSXRlcmF0b3I8U3RyaW5nPiBidWlsZEl0ZXJhdG9yKGludCBzdGFydCwgaW50IGxlbmd0aCkgewotCQlyZXR1cm4gdGhpcy5idWlsZEl0ZXJhdG9yKHRoaXMuYnVpbGRBcnJheSgpLCBzdGFydCwgbGVuZ3RoKTsKLQl9Ci0KLQlJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkSXRlcmF0b3IoU3RyaW5nW10gYXJyYXksIGludCBzdGFydCwgaW50IGxlbmd0aCkgewotCQlyZXR1cm4gbmV3IEFycmF5SXRlcmF0b3I8U3RyaW5nPihhcnJheSwgc3RhcnQsIGxlbmd0aCk7Ci0JfQotCi0JU3RyaW5nW10gYnVpbGRBcnJheSgpIHsKLQkJcmV0dXJuIG5ldyBTdHJpbmdbXSB7ICIxIiwgIjIiLCAiMyIsICI0IiwgIjUiLCAiNiIsICI3IiwgIjgiIH07Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9BcnJheUxpc3RJdGVyYXRvclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9BcnJheUxpc3RJdGVyYXRvclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDJjY2FiODcuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvQXJyYXlMaXN0SXRlcmF0b3JUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTUwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkFycmF5TGlzdEl0ZXJhdG9yOwotCi1wdWJsaWMgY2xhc3MgQXJyYXlMaXN0SXRlcmF0b3JUZXN0cyBleHRlbmRzIEFycmF5SXRlcmF0b3JUZXN0cyB7Ci0KLQlwdWJsaWMgQXJyYXlMaXN0SXRlcmF0b3JUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzUHJldmlvdXMoKSB7Ci0JCUxpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRMaXN0SXRlcmF0b3IoKTsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCXN0cmVhbS5uZXh0KCk7Ci0JCX0KLQkJaW50IGkgPSAwOwotCQl3aGlsZSAoc3RyZWFtLmhhc1ByZXZpb3VzKCkpIHsKLQkJCXN0cmVhbS5wcmV2aW91cygpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkQXJyYXkoKS5sZW5ndGgsIGkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RQcmV2aW91cygpIHsKLQkJTGlzdEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZExpc3RJdGVyYXRvcigpOwotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJfQotCQlpbnQgaSA9IHRoaXMuYnVpbGRBcnJheSgpLmxlbmd0aDsKLQkJd2hpbGUgKHN0cmVhbS5oYXNQcmV2aW91cygpKSB7Ci0JCQlhc3NlcnRFcXVhbHMoImJvZ3VzIGVsZW1lbnQiLCBpLS0sIEludGVnZXIucGFyc2VJbnQoc3RyZWFtLnByZXZpb3VzKCkpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROZXh0SW5kZXgoKSB7Ci0JCWludCBpID0gMDsKLQkJTGlzdEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZExpc3RJdGVyYXRvcigpOwotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJYXNzZXJ0RXF1YWxzKGksIHN0cmVhbS5uZXh0SW5kZXgoKSk7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyhpLCBzdHJlYW0ubmV4dEluZGV4KCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RQcmV2aW91c0luZGV4KCkgewotCQlpbnQgaSA9IDA7Ci0JCUxpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRMaXN0SXRlcmF0b3IoKTsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCWFzc2VydEVxdWFscyhpIC0gMSwgc3RyZWFtLnByZXZpb3VzSW5kZXgoKSk7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyhpIC0gMSwgc3RyZWFtLnByZXZpb3VzSW5kZXgoKSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgdGVzdE5vU3VjaEVsZW1lbnRFeGNlcHRpb24oKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJTGlzdEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZExpc3RJdGVyYXRvcigpOwotCQlTdHJpbmcgc3RyaW5nID0gbnVsbDsKLQkJdHJ5IHsKLQkJCXN0cmluZyA9IHN0cmVhbS5wcmV2aW91cygpOwotCQl9IGNhdGNoIChOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBub3QgdGhyb3duOiAiICsgc3RyaW5nLCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uQWRkKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCWZvciAoTGlzdEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZExpc3RJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJaWYgKHN0cmVhbS5uZXh0KCkuZXF1YWxzKCIzIikpIHsKLQkJCQl0cnkgewotCQkJCQlzdHJlYW0uYWRkKCIzLjUiKTsKLQkJCQl9IGNhdGNoIChVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWFzc2VydFRydWUoIlVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uU2V0KCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCWZvciAoTGlzdEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZExpc3RJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJaWYgKHN0cmVhbS5uZXh0KCkuZXF1YWxzKCIzIikpIHsKLQkJCQl0cnkgewotCQkJCQlzdHJlYW0uc2V0KCJ0aHJlZSIpOwotCQkJCX0gY2F0Y2ggKFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIGV4KSB7Ci0JCQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0ZXN0R2VuZXJpY3MoKSB7Ci0JCUludGVnZXJbXSBpbnRlZ2VycyA9IG5ldyBJbnRlZ2VyWzNdOwotCQlpbnRlZ2Vyc1swXSA9IG5ldyBJbnRlZ2VyKDApOwotCQlpbnRlZ2Vyc1sxXSA9IG5ldyBJbnRlZ2VyKDEpOwotCQlpbnRlZ2Vyc1syXSA9IG5ldyBJbnRlZ2VyKDIpOwotCQlpbnQgaSA9IDA7Ci0JCWZvciAoSXRlcmF0b3I8TnVtYmVyPiBzdHJlYW0gPSBuZXcgQXJyYXlMaXN0SXRlcmF0b3I8TnVtYmVyPihpbnRlZ2Vycyk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlhc3NlcnRFcXVhbHMoaSsrLCBzdHJlYW0ubmV4dCgpLmludFZhbHVlKCkpOwotCQl9Ci0JCWFzc2VydEVxdWFscyhpbnRlZ2Vycy5sZW5ndGgsIGkpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHRlc3RWYXJhcmdzKCkgewotCQlpbnQgaSA9IDA7Ci0JCWZvciAoSXRlcmF0b3I8TnVtYmVyPiBzdHJlYW0gPSBuZXcgQXJyYXlMaXN0SXRlcmF0b3I8TnVtYmVyPihuZXcgSW50ZWdlcigwKSwgbmV3IEludGVnZXIoMSksIG5ldyBJbnRlZ2VyKDIpKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCWFzc2VydEVxdWFscyhpKyssIHN0cmVhbS5uZXh0KCkuaW50VmFsdWUoKSk7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDMsIGkpOwotCX0KLQotCXByaXZhdGUgTGlzdEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRMaXN0SXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkTGlzdEl0ZXJhdG9yKHRoaXMuYnVpbGRBcnJheSgpKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkTGlzdEl0ZXJhdG9yKFN0cmluZ1tdIGFycmF5KSB7Ci0JCXJldHVybiBuZXcgQXJyYXlMaXN0SXRlcmF0b3I8U3RyaW5nPihhcnJheSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JSXRlcmF0b3I8U3RyaW5nPiBidWlsZEl0ZXJhdG9yKFN0cmluZ1tdIGFycmF5KSB7Ci0JCXJldHVybiBuZXcgQXJyYXlMaXN0SXRlcmF0b3I8U3RyaW5nPihhcnJheSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JSXRlcmF0b3I8U3RyaW5nPiBidWlsZEl0ZXJhdG9yKFN0cmluZ1tdIGFycmF5LCBpbnQgc3RhcnQsIGludCBsZW5ndGgpIHsKLQkJcmV0dXJuIG5ldyBBcnJheUxpc3RJdGVyYXRvcjxTdHJpbmc+KGFycmF5LCBzdGFydCwgbGVuZ3RoKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL0NoYWluSXRlcmF0b3JUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvQ2hhaW5JdGVyYXRvclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDE4YjNkYjIuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvQ2hhaW5JdGVyYXRvclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMzIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQWJzdHJhY3RDb2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5BYnN0cmFjdExpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Ob1N1Y2hFbGVtZW50RXhjZXB0aW9uOwotaW1wb3J0IGphdmEudXRpbC5WZWN0b3I7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5DaGFpbkl0ZXJhdG9yOwotCi1wdWJsaWMgY2xhc3MgQ2hhaW5JdGVyYXRvclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgZmluYWwgc3RhdGljIENsYXNzPD8+W10gVkVDVE9SX0hJRVJBUkNIWSA9IHsgVmVjdG9yLmNsYXNzLCBBYnN0cmFjdExpc3QuY2xhc3MsIEFic3RyYWN0Q29sbGVjdGlvbi5jbGFzcywgT2JqZWN0LmNsYXNzIH07Ci0KLQlwdWJsaWMgQ2hhaW5JdGVyYXRvclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNOZXh0KCkgewotCQlpbnQgaSA9IDA7Ci0JCWZvciAoSXRlcmF0b3I8Q2xhc3M8Pz4+IHN0cmVhbSA9IHRoaXMuYnVpbGRJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHMoVkVDVE9SX0hJRVJBUkNIWS5sZW5ndGgsIGkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbm5lckhhc05leHQoKSB7Ci0JCWludCBpID0gMDsKLQkJZm9yIChJdGVyYXRvcjxDbGFzczw/Pj4gc3RyZWFtID0gdGhpcy5idWlsZElubmVySXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCXN0cmVhbS5uZXh0KCk7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKFZFQ1RPUl9ISUVSQVJDSFkubGVuZ3RoLCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TmV4dCgpIHsKLQkJaW50IGkgPSAwOwotCQlmb3IgKEl0ZXJhdG9yPENsYXNzPD8+PiBzdHJlYW0gPSB0aGlzLmJ1aWxkSXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTsgaSsrKSB7Ci0JCQlhc3NlcnRFcXVhbHMoImJvZ3VzIGxpbmsiLCBWRUNUT1JfSElFUkFSQ0hZW2ldLCBzdHJlYW0ubmV4dCgpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbm5lck5leHQoKSB7Ci0JCWludCBpID0gMDsKLQkJZm9yIChJdGVyYXRvcjxDbGFzczw/Pj4gc3RyZWFtID0gdGhpcy5idWlsZElubmVySXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTsgaSsrKSB7Ci0JCQlhc3NlcnRFcXVhbHMoImJvZ3VzIGxpbmsiLCBWRUNUT1JfSElFUkFSQ0hZW2ldLCBzdHJlYW0ubmV4dCgpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROb1N1Y2hFbGVtZW50RXhjZXB0aW9uKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCUl0ZXJhdG9yPENsYXNzPD8+PiBzdHJlYW0gPSB0aGlzLmJ1aWxkSXRlcmF0b3IoKTsKLQkJQ2xhc3M8Pz4gamF2YUNsYXNzID0gbnVsbDsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCWphdmFDbGFzcyA9IHN0cmVhbS5uZXh0KCk7Ci0JCX0KLQkJdHJ5IHsKLQkJCWphdmFDbGFzcyA9IHN0cmVhbS5uZXh0KCk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIG5vdCB0aHJvd246ICIgKyBqYXZhQ2xhc3MsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJZm9yIChJdGVyYXRvcjxDbGFzczw/Pj4gc3RyZWFtID0gdGhpcy5idWlsZEl0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlpZiAoc3RyZWFtLm5leHQoKSA9PSBBYnN0cmFjdENvbGxlY3Rpb24uY2xhc3MpIHsKLQkJCQl0cnkgewotCQkJCQlzdHJlYW0ucmVtb3ZlKCk7Ci0JCQkJfSBjYXRjaCAoVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gZXgpIHsKLQkJCQkJZXhDYXVnaHQgPSB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfQotCQlhc3NlcnRUcnVlKCJVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBub3QgdGhyb3duIiwgZXhDYXVnaHQpOwotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8Q2xhc3M8Pz4+IGJ1aWxkSXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkQ2hhaW5JdGVyYXRvcihWZWN0b3IuY2xhc3MsIHRoaXMuYnVpbGRMaW5rZXIoKSk7Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxDbGFzczw/Pj4gYnVpbGRJbm5lckl0ZXJhdG9yKCkgewotCQlyZXR1cm4gdGhpcy5idWlsZElubmVyQ2hhaW5JdGVyYXRvcihWZWN0b3IuY2xhc3MpOwotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8Q2xhc3M8Pz4+IGJ1aWxkQ2hhaW5JdGVyYXRvcihDbGFzczw/PiBzdGFydExpbmssIENoYWluSXRlcmF0b3IuTGlua2VyPENsYXNzPD8+PiBsaW5rZXIpIHsKLQkJcmV0dXJuIG5ldyBDaGFpbkl0ZXJhdG9yPENsYXNzPD8+PihzdGFydExpbmssIGxpbmtlcik7Ci0JfQotCi0JcHJpdmF0ZSBDaGFpbkl0ZXJhdG9yLkxpbmtlcjxDbGFzczw/Pj4gYnVpbGRMaW5rZXIoKSB7Ci0JCS8vIGNoYWluIHVwIHRoZSBjbGFzcydzIGhpZXJhcmNoeQotCQlyZXR1cm4gbmV3IENoYWluSXRlcmF0b3IuTGlua2VyPENsYXNzPD8+PigpIHsKLQkJCXB1YmxpYyBDbGFzczw/PiBuZXh0TGluayhDbGFzczw/PiBjdXJyZW50TGluaykgewotCQkJCXJldHVybiBjdXJyZW50TGluay5nZXRTdXBlcmNsYXNzKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxDbGFzczw/Pj4gYnVpbGRJbm5lckNoYWluSXRlcmF0b3IoQ2xhc3M8Pz4gc3RhcnRMaW5rKSB7Ci0JCS8vIGNoYWluIHVwIHRoZSBjbGFzcydzIGhpZXJhcmNoeQotCQlyZXR1cm4gbmV3IENoYWluSXRlcmF0b3I8Q2xhc3M8Pz4+KHN0YXJ0TGluaykgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQ2xhc3M8Pz4gbmV4dExpbmsoQ2xhc3M8Pz4gY3VycmVudExpbmspIHsKLQkJCQlyZXR1cm4gY3VycmVudExpbmsuZ2V0U3VwZXJjbGFzcygpOwotCQkJfQotCQl9OwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbnZhbGlkQ2hhaW5JdGVyYXRvcigpIHsKLQkJLy8gbWlzc2luZyBtZXRob2Qgb3ZlcnJpZGUKLQkJSXRlcmF0b3I8Q2xhc3M8Pz4+IGl0ZXJhdG9yID0gbmV3IENoYWluSXRlcmF0b3I8Q2xhc3M8Pz4+KFZlY3Rvci5jbGFzcyk7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCUNsYXNzPD8+IGMgPSBpdGVyYXRvci5uZXh0KCk7Ci0JCQlmYWlsKCJpbnZhbGlkIGNsYXNzOiAiICsgYy5nZXROYW1lKCkpOwotCQl9IGNhdGNoIChVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIk5vU3VjaEVsZW1lbnRFeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL0Nsb25lSXRlcmF0b3JUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvQ2xvbmVJdGVyYXRvclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGUzYWZkYjUuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvQ2xvbmVJdGVyYXRvclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyNTIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uczsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5DbG9uZUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIENsb25lSXRlcmF0b3JUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlDb2xsZWN0aW9uPFN0cmluZz4gb3JpZ2luYWxDb2xsZWN0aW9uOwotCi0JcHJpdmF0ZSBib29sZWFuIGNvbmN1cnJlbnRQcm9ibGVtOwotCXByaXZhdGUgQ29sbGVjdGlvbjxTdHJpbmc+IGNvbmN1cnJlbnRDb2xsZWN0aW9uOwotCi0JcHVibGljIENsb25lSXRlcmF0b3JUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLm9yaWdpbmFsQ29sbGVjdGlvbiA9IHRoaXMuYnVpbGRDb2xsZWN0aW9uKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNOZXh0KCkgewotCQlpbnQgb3JpZ2luYWxTaXplID0gdGhpcy5vcmlnaW5hbENvbGxlY3Rpb24uc2l6ZSgpOwotCQlpbnQgaSA9IDA7Ci0JCWZvciAoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkQ2xvbmVJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJCS8vIHNob3VsZCBhbGxvdyBjb25jdXJyZW50IG1vZGlmaWNhdGlvbgotCQkJdGhpcy5vcmlnaW5hbENvbGxlY3Rpb24uYWRkKCJmb28iKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRUcnVlKG9yaWdpbmFsU2l6ZSAhPSB0aGlzLm9yaWdpbmFsQ29sbGVjdGlvbi5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMob3JpZ2luYWxTaXplLCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TmV4dCgpIHsKLQkJSXRlcmF0b3I8U3RyaW5nPiBuZXN0ZWRJdGVyYXRvciA9IHRoaXMub3JpZ2luYWxDb2xsZWN0aW9uLml0ZXJhdG9yKCk7Ci0JCWZvciAoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkQ2xvbmVJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyBlbGVtZW50IiwgbmVzdGVkSXRlcmF0b3IubmV4dCgpLCBzdHJlYW0ubmV4dCgpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROb1N1Y2hFbGVtZW50RXhjZXB0aW9uKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZENsb25lSXRlcmF0b3IoKTsKLQkJU3RyaW5nIHN0cmluZyA9IG51bGw7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlzdHJpbmcgPSBzdHJlYW0ubmV4dCgpOwotCQl9Ci0JCXRyeSB7Ci0JCQlzdHJpbmcgPSBzdHJlYW0ubmV4dCgpOwotCQl9IGNhdGNoIChOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBub3QgdGhyb3duOiAiICsgc3RyaW5nLCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZURlZmF1bHQoKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRDbG9uZUl0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlpZiAoc3RyZWFtLm5leHQoKS5lcXVhbHMoInRocmVlIikpIHsKLQkJCQl0cnkgewotCQkJCQlzdHJlYW0ucmVtb3ZlKCk7Ci0JCQkJfSBjYXRjaCAoVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gZXgpIHsKLQkJCQkJZXhDYXVnaHQgPSB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfQotCQlhc3NlcnRUcnVlKCJVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBub3QgdGhyb3duIiwgZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVFbGltaW5hdG9yKCkgewotCQlDbG9uZUl0ZXJhdG9yLk11dGF0b3I8U3RyaW5nPiBlbGltaW5hdG9yID0gbmV3IENsb25lSXRlcmF0b3IuTXV0YXRvcjxTdHJpbmc+KCkgewotCQkJcHVibGljIHZvaWQgcmVtb3ZlKFN0cmluZyBjdXJyZW50KSB7Ci0JCQkJQ2xvbmVJdGVyYXRvclRlc3RzLnRoaXMub3JpZ2luYWxDb2xsZWN0aW9uLnJlbW92ZShjdXJyZW50KTsKLQkJCX0KLQkJfTsKLQkJdGhpcy52ZXJpZnlSZW1vdmUobmV3IENsb25lSXRlcmF0b3I8U3RyaW5nPih0aGlzLm9yaWdpbmFsQ29sbGVjdGlvbiwgZWxpbWluYXRvcikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVTdWJjbGFzcygpIHsKLQkJdGhpcy52ZXJpZnlSZW1vdmUobmV3IENsb25lSXRlcmF0b3I8U3RyaW5nPih0aGlzLm9yaWdpbmFsQ29sbGVjdGlvbikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCByZW1vdmUoU3RyaW5nIGN1cnJlbnQpIHsKLQkJCQlDbG9uZUl0ZXJhdG9yVGVzdHMudGhpcy5vcmlnaW5hbENvbGxlY3Rpb24ucmVtb3ZlKGN1cnJlbnQpOwotCQkJfQotCQl9KTsKLQl9Ci0KLQkvKioKLQkgKiBUZXN0IGNvbmN1cnJlbnQgYWNjZXNzOiBGaXJzdCBidWlsZCBhIGNsb25lIGl0ZXJhdG9yIGluIGEgc2VwYXJhdGUgdGhyZWFkCi0JICogdGhhdCBoYW5ncyBtb21lbnRhcmlseSBkdXJpbmcgaXRzIGNvbnN0cnVjdGlvbjsgdGhlbiBtb2RpZnkgdGhlIHNoYXJlZAotCSAqIGNvbGxlY3Rpb24gaW4gdGhpcyB0aHJlYWQuIFRoaXMgd291bGQgY2F1c2UgYQotCSAqIENvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24gaW4gdGhlIG90aGVyIHRocmVhZCBpZiB0aGUgY2xvbmUgaXRlcmF0b3IKLQkgKiB3ZXJlIG5vdCBzeW5jaHJvbml6ZWQgb24gdGhlIG9yaWdpbmFsIGNvbGxlY3Rpb24uCi0JICovCi0JcHVibGljIHZvaWQgdGVzdENvbmN1cnJlbnRBY2Nlc3MoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJU2xvd0NvbGxlY3Rpb248U3RyaW5nPiBzbG93ID0gbmV3IFNsb3dDb2xsZWN0aW9uPFN0cmluZz4oKTsKLQkJdGhpcy5wb3B1bGF0ZUNvbGxlY3Rpb24oc2xvdyk7Ci0JCS8vIHVzaW5nIHRoZSB1bnN5bmNocm9uaXplZCBjb2xsZWN0aW9uIHdpbGwgY2F1c2UgdGhlIHRlc3QgdG8gZmFpbAotCQkvLwkJdGhpcy5vcmlnaW5hbENvbGxlY3Rpb24gPSBzbG93OwotCQl0aGlzLm9yaWdpbmFsQ29sbGVjdGlvbiA9IENvbGxlY3Rpb25zLnN5bmNocm9uaXplZENvbGxlY3Rpb24oc2xvdyk7Ci0KLQkJdGhpcy5jb25jdXJyZW50UHJvYmxlbSA9IGZhbHNlOwotCQl0aGlzLmNvbmN1cnJlbnRDb2xsZWN0aW9uID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCVRocmVhZCB0aHJlYWQgPSBuZXcgVGhyZWFkKHRoaXMuYnVpbGRSdW5uYWJsZSgpKTsKLQkJdGhyZWFkLnN0YXJ0KCk7Ci0JCXdoaWxlICghc2xvdy5oYXNTdGFydGVkQ2xvbmUoKSkgewotCQkJLy8gd2FpdCBmb3IgdGhlIG90aGVyIHRocmVhZCB0byBzdGFydCB0aGUgY2xvbmUuLi4KLQkJCVRocmVhZC55aWVsZCgpOwotCQl9Ci0JCS8vIC4uLnRoZW4gc25lYWsgaW4gYW4gZXh0cmEgZWxlbWVudAotCQl0aGlzLm9yaWdpbmFsQ29sbGVjdGlvbi5hZGQoInNldmVudGVlbiIpOwotCQl3aGlsZSAodGhyZWFkLmlzQWxpdmUoKSkgewotCQkJLy8gd2FpdCBmb3IgdGhlIG90aGVyIHRocmVhZCB0byBmaW5pc2gKLQkJCVRocmVhZC55aWVsZCgpOwotCQl9Ci0JCWFzc2VydEZhbHNlKHRoaXMuY29uY3VycmVudFByb2JsZW0pOwotCQlDb2xsZWN0aW9uPFN0cmluZz4gZXhwZWN0ZWQgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJdGhpcy5wb3B1bGF0ZUNvbGxlY3Rpb24oZXhwZWN0ZWQpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29uY3VycmVudENvbGxlY3Rpb24pOwotCX0KLQotCXByaXZhdGUgUnVubmFibGUgYnVpbGRSdW5uYWJsZSgpIHsKLQkJcmV0dXJuIG5ldyBSdW5uYWJsZSgpIHsKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlDbG9uZUl0ZXJhdG9yVGVzdHMudGhpcy5sb29wV2l0aENsb25lSXRlcmF0b3IoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQkvKioKLQkgKiB1c2UgYSBjbG9uZSBpdGVyYXRvciB0byBsb29wIG92ZXIgdGhlICJzbG93IiBjb2xsZWN0aW9uIGFuZCBjb3B5IGl0cwotCSAqIGNvbnRlbnRzIHRvIHRoZSBjb25jdXJyZW50IGNvbGxlY3Rpb24KLQkgKi8KLQl2b2lkIGxvb3BXaXRoQ2xvbmVJdGVyYXRvcigpIHsKLQkJdHJ5IHsKLQkJCWZvciAoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkQ2xvbmVJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJCXRoaXMuY29uY3VycmVudENvbGxlY3Rpb24uYWRkKHN0cmVhbS5uZXh0KCkpOwotCQkJfQotCQl9IGNhdGNoIChUaHJvd2FibGUgdCkgewotCQkJdGhpcy5jb25jdXJyZW50UHJvYmxlbSA9IHRydWU7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UmVtb3ZlKEl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IpIHsKLQkJT2JqZWN0IHJlbW92ZWQgPSAidGhyZWUiOwotCQlhc3NlcnRUcnVlKHRoaXMub3JpZ2luYWxDb2xsZWN0aW9uLmNvbnRhaW5zKHJlbW92ZWQpKTsKLQkJLy8gdHJ5IHRvIHJlbW92ZSBiZWZvcmUgY2FsbGluZyAjbmV4dCgpCi0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCWl0ZXJhdG9yLnJlbW92ZSgpOwotCQl9IGNhdGNoIChJbGxlZ2FsU3RhdGVFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJJbGxlZ2FsU3RhdGVFeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQkJd2hpbGUgKGl0ZXJhdG9yLmhhc05leHQoKSkgewotCQkJaWYgKGl0ZXJhdG9yLm5leHQoKS5lcXVhbHMocmVtb3ZlZCkpIHsKLQkJCQlpdGVyYXRvci5yZW1vdmUoKTsKLQkJCQkvLyB0cnkgdG8gcmVtb3ZlIHR3aWNlCi0JCQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJCQl0cnkgewotCQkJCQlpdGVyYXRvci5yZW1vdmUoKTsKLQkJCQl9IGNhdGNoIChJbGxlZ2FsU3RhdGVFeGNlcHRpb24gZXgpIHsKLQkJCQkJZXhDYXVnaHQgPSB0cnVlOwotCQkJCX0KLQkJCQlhc3NlcnRUcnVlKCJJbGxlZ2FsU3RhdGVFeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQkJCX0KLQkJfQotCQlhc3NlcnRGYWxzZSh0aGlzLm9yaWdpbmFsQ29sbGVjdGlvbi5jb250YWlucyhyZW1vdmVkKSk7Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkQ2xvbmVJdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRDbG9uZUl0ZXJhdG9yKHRoaXMub3JpZ2luYWxDb2xsZWN0aW9uKTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRDbG9uZUl0ZXJhdG9yKENvbGxlY3Rpb248U3RyaW5nPiBjKSB7Ci0JCXJldHVybiBuZXcgQ2xvbmVJdGVyYXRvcjxTdHJpbmc+KGMpOwotCX0KLQotCXByaXZhdGUgQ29sbGVjdGlvbjxTdHJpbmc+IGJ1aWxkQ29sbGVjdGlvbigpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSB0aGlzLmJ1aWxkRW1wdHlDb2xsZWN0aW9uKCk7Ci0JCXRoaXMucG9wdWxhdGVDb2xsZWN0aW9uKGMpOwotCQlyZXR1cm4gYzsKLQl9Ci0KLQlwcm90ZWN0ZWQgQ29sbGVjdGlvbjxTdHJpbmc+IGJ1aWxkRW1wdHlDb2xsZWN0aW9uKCkgewotCQlyZXR1cm4gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHBvcHVsYXRlQ29sbGVjdGlvbihDb2xsZWN0aW9uPFN0cmluZz4gYykgewotCQljLmFkZCgib25lIik7Ci0JCWMuYWRkKCJ0d28iKTsKLQkJYy5hZGQoInRocmVlIik7Ci0JCWMuYWRkKCJmb3VyIik7Ci0JCWMuYWRkKCJmaXZlIik7Ci0JCWMuYWRkKCJzaXgiKTsKLQkJYy5hZGQoInNldmVuIik7Ci0JCWMuYWRkKCJlaWdodCIpOwotCX0KLQotCS8vICoqKioqKioqKiogY3VzdG9tIGNvbGxlY3Rpb24gKioqKioqKioqKgotCXN0YXRpYyBjbGFzcyBTbG93Q29sbGVjdGlvbjxFPiBleHRlbmRzIEFycmF5TGlzdDxFPiB7Ci0JCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDFMOwotCQlwcml2YXRlIGJvb2xlYW4gaGFzU3RhcnRlZENsb25lID0gZmFsc2U7Ci0KLQkJcHVibGljIFNsb3dDb2xsZWN0aW9uKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgT2JqZWN0W10gdG9BcnJheSgpIHsKLQkJCXRoaXMuc2V0SGFzU3RhcnRlZENsb25lKHRydWUpOwotCQkJLy8gdGFrZSBhIGxpdHRsZSBzbm9vemUgYmVmb3JlIHJldHVybmluZyB0aGUgYXJyYXkKLQkJCXRyeSB7Ci0JCQkJVGhyZWFkLnNsZWVwKDEwMCk7Ci0JCQl9IGNhdGNoIChJbnRlcnJ1cHRlZEV4Y2VwdGlvbiBleCkgewotCQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGV4KTsKLQkJCX0KLQkJCXJldHVybiBzdXBlci50b0FycmF5KCk7Ci0JCX0KLQotCQlzeW5jaHJvbml6ZWQgdm9pZCBzZXRIYXNTdGFydGVkQ2xvbmUoYm9vbGVhbiBoYXNTdGFydGVkQ2xvbmUpIHsKLQkJCXRoaXMuaGFzU3RhcnRlZENsb25lID0gaGFzU3RhcnRlZENsb25lOwotCQl9Ci0KLQkJc3luY2hyb25pemVkIGJvb2xlYW4gaGFzU3RhcnRlZENsb25lKCkgewotCQkJcmV0dXJuIHRoaXMuaGFzU3RhcnRlZENsb25lOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9DbG9uZUxpc3RJdGVyYXRvclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9DbG9uZUxpc3RJdGVyYXRvclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGM2MDQ1YTkuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvQ2xvbmVMaXN0SXRlcmF0b3JUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDA4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbnM7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTm9TdWNoRWxlbWVudEV4Y2VwdGlvbjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkNsb25lTGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIENsb25lTGlzdEl0ZXJhdG9yVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JTGlzdDxTdHJpbmc+IG9yaWdpbmFsTGlzdDsKLQotCXByaXZhdGUgYm9vbGVhbiBjb25jdXJyZW50UHJvYmxlbTsKLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBjb25jdXJyZW50TGlzdDsKLQotCXB1YmxpYyBDbG9uZUxpc3RJdGVyYXRvclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMub3JpZ2luYWxMaXN0ID0gdGhpcy5idWlsZExpc3QoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc05leHQoKSB7Ci0JCWludCBvcmlnaW5hbFNpemUgPSB0aGlzLm9yaWdpbmFsTGlzdC5zaXplKCk7Ci0JCWludCBpID0gMDsKLQkJZm9yIChMaXN0SXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkQ2xvbmVMaXN0SXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCXN0cmVhbS5uZXh0KCk7Ci0JCQkvLyBzaG91bGQgYWxsb3cgY29uY3VycmVudCBtb2RpZmljYXRpb24KLQkJCXRoaXMub3JpZ2luYWxMaXN0LmFkZCgiZm9vIik7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShvcmlnaW5hbFNpemUgIT0gdGhpcy5vcmlnaW5hbExpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKG9yaWdpbmFsU2l6ZSwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5leHQoKSB7Ci0JCUxpc3RJdGVyYXRvcjxTdHJpbmc+IG5lc3RlZExpc3RJdGVyYXRvciA9IHRoaXMuYnVpbGROZXN0ZWRMaXN0SXRlcmF0b3IoKTsKLQkJZm9yIChMaXN0SXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkQ2xvbmVMaXN0SXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCWFzc2VydEVxdWFscygiYm9ndXMgZWxlbWVudCIsIG5lc3RlZExpc3RJdGVyYXRvci5uZXh0KCksIHN0cmVhbS5uZXh0KCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEluZGV4KCkgewotCQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBjbG9uZUxpc3RJdGVyYXRvciA9IHRoaXMuYnVpbGRDbG9uZUxpc3RJdGVyYXRvcigpOwotCQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBuZXN0ZWRMaXN0SXRlcmF0b3IgPSB0aGlzLmJ1aWxkTmVzdGVkTGlzdEl0ZXJhdG9yKCk7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgNzsgaSsrKSB7Ci0JCQluZXN0ZWRMaXN0SXRlcmF0b3IubmV4dCgpOwotCQkJY2xvbmVMaXN0SXRlcmF0b3IubmV4dCgpOwotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyBpbmRleCIsIG5lc3RlZExpc3RJdGVyYXRvci5uZXh0SW5kZXgoKSwgY2xvbmVMaXN0SXRlcmF0b3IubmV4dEluZGV4KCkpOwotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyBpbmRleCIsIG5lc3RlZExpc3RJdGVyYXRvci5wcmV2aW91c0luZGV4KCksIGNsb25lTGlzdEl0ZXJhdG9yLnByZXZpb3VzSW5kZXgoKSk7Ci0JCX0KLQotCQlmb3IgKGludCBpID0gMDsgaSA8IDM7IGkrKykgewotCQkJbmVzdGVkTGlzdEl0ZXJhdG9yLnByZXZpb3VzKCk7Ci0JCQljbG9uZUxpc3RJdGVyYXRvci5wcmV2aW91cygpOwotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyBpbmRleCIsIG5lc3RlZExpc3RJdGVyYXRvci5uZXh0SW5kZXgoKSwgY2xvbmVMaXN0SXRlcmF0b3IubmV4dEluZGV4KCkpOwotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyBpbmRleCIsIG5lc3RlZExpc3RJdGVyYXRvci5wcmV2aW91c0luZGV4KCksIGNsb25lTGlzdEl0ZXJhdG9yLnByZXZpb3VzSW5kZXgoKSk7Ci0JCX0KLQotCQl3aGlsZSAobmVzdGVkTGlzdEl0ZXJhdG9yLmhhc05leHQoKSkgewotCQkJbmVzdGVkTGlzdEl0ZXJhdG9yLm5leHQoKTsKLQkJCWNsb25lTGlzdEl0ZXJhdG9yLm5leHQoKTsKLQkJCWFzc2VydEVxdWFscygiYm9ndXMgaW5kZXgiLCBuZXN0ZWRMaXN0SXRlcmF0b3IubmV4dEluZGV4KCksIGNsb25lTGlzdEl0ZXJhdG9yLm5leHRJbmRleCgpKTsKLQkJCWFzc2VydEVxdWFscygiYm9ndXMgaW5kZXgiLCBuZXN0ZWRMaXN0SXRlcmF0b3IucHJldmlvdXNJbmRleCgpLCBjbG9uZUxpc3RJdGVyYXRvci5wcmV2aW91c0luZGV4KCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc1ByZXZpb3VzKCkgewotCQlpbnQgb3JpZ2luYWxTaXplID0gdGhpcy5vcmlnaW5hbExpc3Quc2l6ZSgpOwotCQlpbnQgaSA9IDA7Ci0JCUxpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRDbG9uZUxpc3RJdGVyYXRvcigpOwotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJCXRoaXMub3JpZ2luYWxMaXN0LmFkZCgiZm9vIik7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShvcmlnaW5hbFNpemUgIT0gdGhpcy5vcmlnaW5hbExpc3Quc2l6ZSgpKTsKLQkJb3JpZ2luYWxTaXplID0gdGhpcy5vcmlnaW5hbExpc3Quc2l6ZSgpOwotCQl3aGlsZSAoc3RyZWFtLmhhc1ByZXZpb3VzKCkpIHsKLQkJCXN0cmVhbS5wcmV2aW91cygpOwotCQkJLy8gc2hvdWxkIGFsbG93IGNvbmN1cnJlbnQgbW9kaWZpY2F0aW9uCi0JCQl0aGlzLm9yaWdpbmFsTGlzdC5hZGQoImJhciIpOwotCQkJaS0tOwotCQl9Ci0JCWFzc2VydFRydWUob3JpZ2luYWxTaXplICE9IHRoaXMub3JpZ2luYWxMaXN0LnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscygwLCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UHJldmlvdXMoKSB7Ci0JCUxpc3RJdGVyYXRvcjxTdHJpbmc+IG5lc3RlZExpc3RJdGVyYXRvciA9IHRoaXMuYnVpbGROZXN0ZWRMaXN0SXRlcmF0b3IoKTsKLQkJTGlzdEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZENsb25lTGlzdEl0ZXJhdG9yKCk7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQluZXN0ZWRMaXN0SXRlcmF0b3IubmV4dCgpOwotCQkJc3RyZWFtLm5leHQoKTsKLQkJfQotCQl3aGlsZSAoc3RyZWFtLmhhc1ByZXZpb3VzKCkpIHsKLQkJCWFzc2VydEVxdWFscygiYm9ndXMgZWxlbWVudCIsIG5lc3RlZExpc3RJdGVyYXRvci5wcmV2aW91cygpLCBzdHJlYW0ucHJldmlvdXMoKSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Tm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkQ2xvbmVMaXN0SXRlcmF0b3IoKTsKLQkJU3RyaW5nIHN0cmluZyA9IG51bGw7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlzdHJpbmcgPSBzdHJlYW0ubmV4dCgpOwotCQl9Ci0JCXRyeSB7Ci0JCQlzdHJpbmcgPSBzdHJlYW0ubmV4dCgpOwotCQl9IGNhdGNoIChOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBub3QgdGhyb3duOiAiICsgc3RyaW5nLCBleENhdWdodCk7Ci0KLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJd2hpbGUgKHN0cmVhbS5oYXNQcmV2aW91cygpKSB7Ci0JCQlzdHJpbmcgPSBzdHJlYW0ucHJldmlvdXMoKTsKLQkJfQotCQl0cnkgewotCQkJc3RyaW5nID0gc3RyZWFtLnByZXZpb3VzKCk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIG5vdCB0aHJvd246ICIgKyBzdHJpbmcsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TW9kaWZ5RGVmYXVsdCgpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlmb3IgKExpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRDbG9uZUxpc3RJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJaWYgKHN0cmVhbS5uZXh0KCkuZXF1YWxzKCJ0aHJlZSIpKSB7Ci0JCQkJdHJ5IHsKLQkJCQkJc3RyZWFtLnJlbW92ZSgpOwotCQkJCX0gY2F0Y2ggKFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIGV4KSB7Ci0JCQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQotCQlleENhdWdodCA9IGZhbHNlOwotCQlmb3IgKExpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRDbG9uZUxpc3RJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJaWYgKHN0cmVhbS5uZXh0KCkuZXF1YWxzKCJ0aHJlZSIpKSB7Ci0JCQkJdHJ5IHsKLQkJCQkJc3RyZWFtLmFkZCgidGhyZWUgYW5kIGEgaGFsZiIpOwotCQkJCX0gY2F0Y2ggKFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIGV4KSB7Ci0JCQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQotCQlleENhdWdodCA9IGZhbHNlOwotCQlmb3IgKExpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRDbG9uZUxpc3RJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJaWYgKHN0cmVhbS5uZXh0KCkuZXF1YWxzKCJ0aHJlZSIpKSB7Ci0JCQkJdHJ5IHsKLQkJCQkJc3RyZWFtLnNldCgiYW5vdGhlciB0aHJlZSIpOwotCQkJCX0gY2F0Y2ggKFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIGV4KSB7Ci0JCQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TW9kaWZ5TXV0YXRvck5leHQoKSB7Ci0JCXRoaXMudmVyaWZ5TW9kaWZ5TmV4dChuZXcgQ2xvbmVMaXN0SXRlcmF0b3I8U3RyaW5nPih0aGlzLm9yaWdpbmFsTGlzdCwgdGhpcy5idWlsZE11dGF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RNb2RpZnlNdXRhdG9yUHJldmlvdXMoKSB7Ci0JCXRoaXMudmVyaWZ5TW9kaWZ5UHJldmlvdXMobmV3IENsb25lTGlzdEl0ZXJhdG9yPFN0cmluZz4odGhpcy5vcmlnaW5hbExpc3QsIHRoaXMuYnVpbGRNdXRhdG9yKCkpKTsKLQl9Ci0KLQlwcml2YXRlIENsb25lTGlzdEl0ZXJhdG9yLk11dGF0b3I8U3RyaW5nPiBidWlsZE11dGF0b3IoKSB7Ci0JCXJldHVybiBuZXcgQ2xvbmVMaXN0SXRlcmF0b3IuTXV0YXRvcjxTdHJpbmc+KCkgewotCQkJcHVibGljIHZvaWQgYWRkKGludCBpbmRleCwgU3RyaW5nIG8pIHsKLQkJCQlDbG9uZUxpc3RJdGVyYXRvclRlc3RzLnRoaXMub3JpZ2luYWxMaXN0LmFkZChpbmRleCwgbyk7Ci0JCQl9Ci0KLQkJCXB1YmxpYyB2b2lkIHJlbW92ZShpbnQgaW5kZXgpIHsKLQkJCQlDbG9uZUxpc3RJdGVyYXRvclRlc3RzLnRoaXMub3JpZ2luYWxMaXN0LnJlbW92ZShpbmRleCk7Ci0JCQl9Ci0KLQkJCXB1YmxpYyB2b2lkIHNldChpbnQgaW5kZXgsIFN0cmluZyBvKSB7Ci0JCQkJQ2xvbmVMaXN0SXRlcmF0b3JUZXN0cy50aGlzLm9yaWdpbmFsTGlzdC5zZXQoaW5kZXgsIG8pOwotCQkJfQotCQl9OwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RNb2RpZnlTdWJjbGFzc05leHQoKSB7Ci0JCXRoaXMudmVyaWZ5TW9kaWZ5TmV4dCh0aGlzLmJ1aWxkU3ViY2xhc3MoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE1vZGlmeVN1YmNsYXNzUHJldmlvdXMoKSB7Ci0JCXRoaXMudmVyaWZ5TW9kaWZ5UHJldmlvdXModGhpcy5idWlsZFN1YmNsYXNzKCkpOwotCX0KLQotCXByaXZhdGUgTGlzdEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRTdWJjbGFzcygpIHsKLQkJcmV0dXJuIG5ldyBDbG9uZUxpc3RJdGVyYXRvcjxTdHJpbmc+KHRoaXMub3JpZ2luYWxMaXN0KSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIGFkZChpbnQgY3VycmVudEluZGV4LCBTdHJpbmcgbykgewotCQkJCUNsb25lTGlzdEl0ZXJhdG9yVGVzdHMudGhpcy5vcmlnaW5hbExpc3QuYWRkKGN1cnJlbnRJbmRleCwgbyk7Ci0JCQl9Ci0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgcmVtb3ZlKGludCBjdXJyZW50SW5kZXgpIHsKLQkJCQlDbG9uZUxpc3RJdGVyYXRvclRlc3RzLnRoaXMub3JpZ2luYWxMaXN0LnJlbW92ZShjdXJyZW50SW5kZXgpOwotCQkJfQotCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldChpbnQgY3VycmVudEluZGV4LCBTdHJpbmcgbykgewotCQkJCUNsb25lTGlzdEl0ZXJhdG9yVGVzdHMudGhpcy5vcmlnaW5hbExpc3Quc2V0KGN1cnJlbnRJbmRleCwgbyk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeU1vZGlmeU5leHQoTGlzdEl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IpIHsKLQkJU3RyaW5nIHJlbW92ZWQgPSAidGhyZWUiOwotCQlTdHJpbmcgYWRkZWRBZnRlciA9ICJmaXZlIjsKLQkJU3RyaW5nIGFkZGVkID0gImZpdmUgYW5kIGEgaGFsZiI7Ci0JCVN0cmluZyByZXBsYWNlZCA9ICJzZXZlbiI7Ci0JCVN0cmluZyByZXBsYWNlbWVudCA9ICJhbm90aGVyIHNldmVuIjsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLm9yaWdpbmFsTGlzdC5jb250YWlucyhyZW1vdmVkKSk7Ci0JCWFzc2VydFRydWUodGhpcy5vcmlnaW5hbExpc3QuY29udGFpbnMoYWRkZWRBZnRlcikpOwotCQlhc3NlcnRUcnVlKHRoaXMub3JpZ2luYWxMaXN0LmNvbnRhaW5zKHJlcGxhY2VkKSk7Ci0JCS8vIHRyeSB0byByZW1vdmUgYmVmb3JlIGNhbGxpbmcgI25leHQoKQotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlpdGVyYXRvci5yZW1vdmUoKTsKLQkJfSBjYXRjaCAoSWxsZWdhbFN0YXRlRXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiSWxsZWdhbFN0YXRlRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JCXdoaWxlIChpdGVyYXRvci5oYXNOZXh0KCkpIHsKLQkJCVN0cmluZyBuZXh0ID0gaXRlcmF0b3IubmV4dCgpOwotCQkJaWYgKG5leHQuZXF1YWxzKGFkZGVkQWZ0ZXIpKSB7Ci0JCQkJaXRlcmF0b3IuYWRkKGFkZGVkKTsKLQkJCX0KLQkJCWlmIChuZXh0LmVxdWFscyhyZW1vdmVkKSkgewotCQkJCWl0ZXJhdG9yLnJlbW92ZSgpOwotCQkJCS8vIHRyeSB0byByZW1vdmUgdHdpY2UKLQkJCQlleENhdWdodCA9IGZhbHNlOwotCQkJCXRyeSB7Ci0JCQkJCWl0ZXJhdG9yLnJlbW92ZSgpOwotCQkJCX0gY2F0Y2ggKElsbGVnYWxTdGF0ZUV4Y2VwdGlvbiBleCkgewotCQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQkJfQotCQkJCWFzc2VydFRydWUoIklsbGVnYWxTdGF0ZUV4Y2VwdGlvbiBub3QgdGhyb3duIiwgZXhDYXVnaHQpOwotCQkJfQotCQkJaWYgKG5leHQuZXF1YWxzKHJlcGxhY2VkKSkgewotCQkJCWl0ZXJhdG9yLnNldChyZXBsYWNlbWVudCk7Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSh0aGlzLm9yaWdpbmFsTGlzdC5jb250YWlucyhhZGRlZCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLm9yaWdpbmFsTGlzdC5jb250YWlucyhyZW1vdmVkKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMub3JpZ2luYWxMaXN0LmNvbnRhaW5zKHJlcGxhY2VkKSk7Ci0JCWFzc2VydFRydWUodGhpcy5vcmlnaW5hbExpc3QuY29udGFpbnMocmVwbGFjZW1lbnQpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5TW9kaWZ5UHJldmlvdXMoTGlzdEl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IpIHsKLQkJU3RyaW5nIHJlbW92ZWQgPSAidGhyZWUiOwotCQlTdHJpbmcgYWRkZWRCZWZvcmUgPSAiZml2ZSI7Ci0JCVN0cmluZyBhZGRlZCA9ICJmb3VyIGFuZCBhIGhhbGYiOwotCQlTdHJpbmcgcmVwbGFjZWQgPSAic2V2ZW4iOwotCQlTdHJpbmcgcmVwbGFjZW1lbnQgPSAiYW5vdGhlciBzZXZlbiI7Ci0JCWFzc2VydFRydWUodGhpcy5vcmlnaW5hbExpc3QuY29udGFpbnMocmVtb3ZlZCkpOwotCQlhc3NlcnRUcnVlKHRoaXMub3JpZ2luYWxMaXN0LmNvbnRhaW5zKGFkZGVkQmVmb3JlKSk7Ci0JCWFzc2VydFRydWUodGhpcy5vcmlnaW5hbExpc3QuY29udGFpbnMocmVwbGFjZWQpKTsKLQkJd2hpbGUgKGl0ZXJhdG9yLmhhc05leHQoKSkgewotCQkJaXRlcmF0b3IubmV4dCgpOwotCQl9Ci0JCXdoaWxlIChpdGVyYXRvci5oYXNQcmV2aW91cygpKSB7Ci0JCQlPYmplY3QgcHJldmlvdXMgPSBpdGVyYXRvci5wcmV2aW91cygpOwotCQkJaWYgKHByZXZpb3VzLmVxdWFscyhhZGRlZEJlZm9yZSkpIHsKLQkJCQlpdGVyYXRvci5hZGQoYWRkZWQpOwotCQkJfQotCQkJaWYgKHByZXZpb3VzLmVxdWFscyhyZW1vdmVkKSkgewotCQkJCWl0ZXJhdG9yLnJlbW92ZSgpOwotCQkJCS8vIHRyeSB0byByZW1vdmUgdHdpY2UKLQkJCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCQkJdHJ5IHsKLQkJCQkJaXRlcmF0b3IucmVtb3ZlKCk7Ci0JCQkJfSBjYXRjaCAoSWxsZWdhbFN0YXRlRXhjZXB0aW9uIGV4KSB7Ci0JCQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJCQl9Ci0JCQkJYXNzZXJ0VHJ1ZSgiSWxsZWdhbFN0YXRlRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JCQl9Ci0JCQlpZiAocHJldmlvdXMuZXF1YWxzKHJlcGxhY2VkKSkgewotCQkJCWl0ZXJhdG9yLnNldChyZXBsYWNlbWVudCk7Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSh0aGlzLm9yaWdpbmFsTGlzdC5jb250YWlucyhhZGRlZCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLm9yaWdpbmFsTGlzdC5jb250YWlucyhyZW1vdmVkKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMub3JpZ2luYWxMaXN0LmNvbnRhaW5zKHJlcGxhY2VkKSk7Ci0JCWFzc2VydFRydWUodGhpcy5vcmlnaW5hbExpc3QuY29udGFpbnMocmVwbGFjZW1lbnQpKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkQ2xvbmVMaXN0SXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkQ2xvbmVMaXN0SXRlcmF0b3IodGhpcy5vcmlnaW5hbExpc3QpOwotCX0KLQotCXByaXZhdGUgTGlzdEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRDbG9uZUxpc3RJdGVyYXRvcihMaXN0PFN0cmluZz4gbGlzdCkgewotCQlyZXR1cm4gbmV3IENsb25lTGlzdEl0ZXJhdG9yPFN0cmluZz4obGlzdCk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0SXRlcmF0b3I8U3RyaW5nPiBidWlsZE5lc3RlZExpc3RJdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMub3JpZ2luYWxMaXN0Lmxpc3RJdGVyYXRvcigpOwotCX0KLQotCXByaXZhdGUgTGlzdDxTdHJpbmc+IGJ1aWxkTGlzdCgpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QgPSB0aGlzLmJ1aWxkRW1wdHlMaXN0KCk7Ci0JCXRoaXMucG9wdWxhdGVMaXN0KGxpc3QpOwotCQlyZXR1cm4gbGlzdDsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgcG9wdWxhdGVMaXN0KExpc3Q8U3RyaW5nPiBsaXN0KSB7Ci0JCWxpc3QuYWRkKCJ6ZXJvIik7Ci0JCWxpc3QuYWRkKCJvbmUiKTsKLQkJbGlzdC5hZGQoInR3byIpOwotCQlsaXN0LmFkZCgidGhyZWUiKTsKLQkJbGlzdC5hZGQoImZvdXIiKTsKLQkJbGlzdC5hZGQoImZpdmUiKTsKLQkJbGlzdC5hZGQoInNpeCIpOwotCQlsaXN0LmFkZCgic2V2ZW4iKTsKLQkJbGlzdC5hZGQoImVpZ2h0Iik7Ci0JCWxpc3QuYWRkKCJuaW5lIik7Ci0JfQotCi0JcHJvdGVjdGVkIExpc3Q8U3RyaW5nPiBidWlsZEVtcHR5TGlzdCgpIHsKLQkJcmV0dXJuIG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCX0KLQotCS8qKgotCSAqIFRlc3QgY29uY3VycmVudCBhY2Nlc3M6IEZpcnN0IGJ1aWxkIGEgY2xvbmUgaXRlcmF0b3IgaW4gYSBzZXBhcmF0ZSB0aHJlYWQKLQkgKiB0aGF0IGhhbmdzIG1vbWVudGFyaWx5IGR1cmluZyBpdHMgY29uc3RydWN0aW9uOyB0aGVuIG1vZGlmeSB0aGUgc2hhcmVkCi0JICogY29sbGVjdGlvbiBpbiB0aGlzIHRocmVhZC4gVGhpcyB3b3VsZCBjYXVzZSBhCi0JICogQ29uY3VycmVudE1vZGlmaWNhdGlvbkV4Y2VwdGlvbiBpbiB0aGUgb3RoZXIgdGhyZWFkIGlmIHRoZSBjbG9uZSBpdGVyYXRvcgotCSAqIHdlcmUgbm90IHN5bmNocm9uaXplZCBvbiB0aGUgb3JpZ2luYWwgY29sbGVjdGlvbi4KLQkgKi8KLQlwdWJsaWMgdm9pZCB0ZXN0Q29uY3VycmVudEFjY2VzcygpIHRocm93cyBFeGNlcHRpb24gewotCQlDbG9uZUl0ZXJhdG9yVGVzdHMuU2xvd0NvbGxlY3Rpb248U3RyaW5nPiBzbG93ID0gbmV3IENsb25lSXRlcmF0b3JUZXN0cy5TbG93Q29sbGVjdGlvbjxTdHJpbmc+KCk7Ci0JCXRoaXMucG9wdWxhdGVMaXN0KHNsb3cpOwotCQkvLyB1c2luZyB0aGUgdW5zeW5jaHJvbml6ZWQgbGlzdCB3aWxsIGNhdXNlIHRoZSB0ZXN0IHRvIGZhaWwKLQkJLy8gdGhpcy5vcmlnaW5hbExpc3QgPSBzbG93OwotCQl0aGlzLm9yaWdpbmFsTGlzdCA9IENvbGxlY3Rpb25zLnN5bmNocm9uaXplZExpc3Qoc2xvdyk7Ci0KLQkJdGhpcy5jb25jdXJyZW50UHJvYmxlbSA9IGZhbHNlOwotCQl0aGlzLmNvbmN1cnJlbnRMaXN0ID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCVRocmVhZCB0aHJlYWQgPSBuZXcgVGhyZWFkKHRoaXMuYnVpbGRSdW5uYWJsZSgpKTsKLQkJdGhyZWFkLnN0YXJ0KCk7Ci0JCXdoaWxlICghc2xvdy5oYXNTdGFydGVkQ2xvbmUoKSkgewotCQkJLy8gd2FpdCBmb3IgdGhlIG90aGVyIHRocmVhZCB0byBzdGFydCB0aGUgY2xvbmUuLi4KLQkJCVRocmVhZC55aWVsZCgpOwotCQl9Ci0JCS8vIC4uLnRoZW4gc25lYWsgaW4gYW4gZXh0cmEgZWxlbWVudAotCQl0aGlzLm9yaWdpbmFsTGlzdC5hZGQoInNldmVudGVlbiIpOwotCQl3aGlsZSAodGhyZWFkLmlzQWxpdmUoKSkgewotCQkJLy8gd2FpdCBmb3IgdGhlIG90aGVyIHRocmVhZCB0byBmaW5pc2gKLQkJCVRocmVhZC55aWVsZCgpOwotCQl9Ci0JCWFzc2VydEZhbHNlKHRoaXMuY29uY3VycmVudFByb2JsZW0pOwotCQlMaXN0PFN0cmluZz4gZXhwZWN0ZWQgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJdGhpcy5wb3B1bGF0ZUxpc3QoZXhwZWN0ZWQpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29uY3VycmVudExpc3QpOwotCX0KLQotCXByaXZhdGUgUnVubmFibGUgYnVpbGRSdW5uYWJsZSgpIHsKLQkJcmV0dXJuIG5ldyBSdW5uYWJsZSgpIHsKLQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKLQkJCQlDbG9uZUxpc3RJdGVyYXRvclRlc3RzLnRoaXMubG9vcFdpdGhDbG9uZUxpc3RJdGVyYXRvcigpOwotCQkJfQotCQl9OwotCX0KLQotCS8qKgotCSAqIHVzZSBhIGNsb25lIGl0ZXJhdG9yIHRvIGxvb3Agb3ZlciB0aGUgInNsb3ciIGNvbGxlY3Rpb24gYW5kIGNvcHkgaXRzCi0JICogY29udGVudHMgdG8gdGhlIGNvbmN1cnJlbnQgY29sbGVjdGlvbgotCSAqLwotCXZvaWQgbG9vcFdpdGhDbG9uZUxpc3RJdGVyYXRvcigpIHsKLQkJdHJ5IHsKLQkJCWZvciAoTGlzdEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZENsb25lTGlzdEl0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQkJdGhpcy5jb25jdXJyZW50TGlzdC5hZGQoc3RyZWFtLm5leHQoKSk7Ci0JCQl9Ci0JCX0gY2F0Y2ggKFRocm93YWJsZSB0KSB7Ci0JCQl0aGlzLmNvbmN1cnJlbnRQcm9ibGVtID0gdHJ1ZTsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvQ29tcG9zaXRlSXRlcmF0b3JUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvQ29tcG9zaXRlSXRlcmF0b3JUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1OGMzOTc2Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL0NvbXBvc2l0ZUl0ZXJhdG9yVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDM1MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLml0ZXJhdG9yczsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb25zOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Ob1N1Y2hFbGVtZW50RXhjZXB0aW9uOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuQ29tcG9zaXRlSXRlcmF0b3I7Ci0KLXB1YmxpYyBjbGFzcyBDb21wb3NpdGVJdGVyYXRvclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCi0JcHVibGljIENvbXBvc2l0ZUl0ZXJhdG9yVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc0Fub3RoZXIoKSB7Ci0JCXRoaXMudmVyaWZ5SGFzQW5vdGhlcih0aGlzLmJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc0Fub3RoZXIyKCkgewotCQl0aGlzLnZlcmlmeUhhc0Fub3RoZXIodGhpcy5idWlsZENvbXBvc2l0ZUl0ZXJhdG9yMigpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzQW5vdGhlcjMoKSB7Ci0JCXRoaXMudmVyaWZ5SGFzQW5vdGhlcih0aGlzLmJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IzKCkpOwotCX0KLQotCXZvaWQgdmVyaWZ5SGFzQW5vdGhlcihJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSkgewotCQl0aGlzLnZlcmlmeUhhc0Fub3RoZXIoOCwgc3RyZWFtKTsKLQl9Ci0KLQl2b2lkIHZlcmlmeUhhc0Fub3RoZXIoaW50IGV4cGVjdGVkLCBJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSkgewotCQlpbnQgaSA9IDA7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZCwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFub3RoZXIoKSB7Ci0JCXRoaXMudmVyaWZ5QW5vdGhlcih0aGlzLmJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFub3RoZXIyKCkgewotCQl0aGlzLnZlcmlmeUFub3RoZXIodGhpcy5idWlsZENvbXBvc2l0ZUl0ZXJhdG9yMigpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QW5vdGhlcjMoKSB7Ci0JCXRoaXMudmVyaWZ5QW5vdGhlcih0aGlzLmJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IzKCkpOwotCX0KLQotCXZvaWQgdmVyaWZ5QW5vdGhlcihJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSkgewotCQl0aGlzLnZlcmlmeUFub3RoZXIoMSwgc3RyZWFtKTsKLQl9Ci0KLQl2b2lkIHZlcmlmeUFub3RoZXIoaW50IHN0YXJ0LCBJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSkgewotCQlpbnQgaW5kZXggPSBzdGFydDsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCWFzc2VydEVxdWFscygiYm9ndXMgZWxlbWVudCIsIFN0cmluZy52YWx1ZU9mKGluZGV4KyspLCBzdHJlYW0ubmV4dCgpLnN1YnN0cmluZygwLCAxKSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlKCkgewotCQl0aGlzLnZlcmlmeVJlbW92ZSgpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIHZlcmlmeVJlbW92ZSgpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QxID0gdGhpcy5idWlsZExpc3QxKCk7Ci0JCU9iamVjdCBsYXN0RWxlbWVudDEgPSBsaXN0MS5nZXQobGlzdDEuc2l6ZSgpIC0gMSk7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0MiA9IHRoaXMuYnVpbGRMaXN0MigpOwotCQlMaXN0PFN0cmluZz4gbGlzdDMgPSB0aGlzLmJ1aWxkTGlzdDMoKTsKLQotCQlMaXN0PEl0ZXJhdG9yPFN0cmluZz4+IGxpc3QgPSBuZXcgQXJyYXlMaXN0PEl0ZXJhdG9yPFN0cmluZz4+KCk7Ci0JCWxpc3QuYWRkKGxpc3QxLmxpc3RJdGVyYXRvcigpKTsKLQkJbGlzdC5hZGQobGlzdDIubGlzdEl0ZXJhdG9yKCkpOwotCQlsaXN0LmFkZChsaXN0My5saXN0SXRlcmF0b3IoKSk7Ci0KLQkJSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IobGlzdC5saXN0SXRlcmF0b3IoKSk7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlPYmplY3QgbmV4dCA9IHN0cmVhbS5uZXh0KCk7Ci0JCQlpZiAobmV4dC5lcXVhbHMoIjMzMyIpKSB7Ci0JCQkJc3RyZWFtLnJlbW92ZSgpOwotCQkJfQotCQkJLy8gdGVzdCBzcGVjaWFsIGNhc2UgLSB3aGVyZSB3ZSBhcmUgYmV0d2VlbiBpdGVyYXRvcnMKLQkJCWlmIChuZXh0LmVxdWFscyhsYXN0RWxlbWVudDEpKSB7Ci0JCQkJLy8gdGhpcyB3aWxsIHRyaWdnZXIgdGhlIG5leHQgaXRlcmF0b3IgdG8gYmUgbG9hZGVkCi0JCQkJc3RyZWFtLmhhc05leHQoKTsKLQkJCQkvLyBub3cgdHJ5IHRvIHJlbW92ZSBmcm9tIHRoZSBwcmV2aW91cyBpdGVyYXRvcgotCQkJCXN0cmVhbS5yZW1vdmUoKTsKLQkJCX0KLQkJfQotCQlzdHJlYW0ucmVtb3ZlKCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKCJub3RoaW5nIHJlbW92ZWQgZnJvbSBjb2xsZWN0aW9uIDEiLCB0aGlzLmJ1aWxkTGlzdDEoKS5zaXplKCkgLSAyLCBsaXN0MS5zaXplKCkpOwotCQlhc3NlcnRGYWxzZSgiZWxlbWVudCBzdGlsbCBpbiBjb2xsZWN0aW9uIDEiLCBsaXN0MS5jb250YWlucygiMzMzIikpOwotCQlhc3NlcnRGYWxzZSgibGFzdCBlbGVtZW50IHN0aWxsIGluIGNvbGxlY3Rpb24gMSIsIGxpc3QxLmNvbnRhaW5zKGxhc3RFbGVtZW50MSkpOwotCQlhc3NlcnRUcnVlKCJ3cm9uZyBlbGVtZW50IHJlbW92ZWQgZnJvbSBjb2xsZWN0aW9uIDEiLCBsaXN0MS5jb250YWlucygiMjIiKSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKCJub3RoaW5nIHJlbW92ZWQgZnJvbSBjb2xsZWN0aW9uIDMiLCB0aGlzLmJ1aWxkTGlzdDMoKS5zaXplKCkgLSAxLCBsaXN0My5zaXplKCkpOwotCQlhc3NlcnRGYWxzZSgiZWxlbWVudCBzdGlsbCBpbiBjb2xsZWN0aW9uIDMiLCBsaXN0My5jb250YWlucygiODg4ODg4ODgiKSk7Ci0JCWFzc2VydFRydWUoIndyb25nIGVsZW1lbnQgcmVtb3ZlZCBmcm9tIGNvbGxlY3Rpb24gMyIsIGxpc3QzLmNvbnRhaW5zKCI2NjY2NjYiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNpbmdsZUVsZW1lbnQoKSB7Ci0JCVN0cmluZyBpdGVtID0gIjAiOwotCQl0aGlzLnZlcmlmeUhhc0Fub3RoZXIoOSwgdGhpcy5idWlsZENvbXBvc2l0ZUl0ZXJhdG9yKGl0ZW0sIHRoaXMuYnVpbGRDb21wb3NpdGVJdGVyYXRvcigpKSk7Ci0JCXRoaXMudmVyaWZ5QW5vdGhlcigwLCB0aGlzLmJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IoaXRlbSwgdGhpcy5idWlsZENvbXBvc2l0ZUl0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Tm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpIHsKLQkJdGhpcy52ZXJpZnlOb1N1Y2hFbGVtZW50RXhjZXB0aW9uKHRoaXMuYnVpbGRDb21wb3NpdGVJdGVyYXRvcigpKTsKLQl9Ci0KLQl2b2lkIHZlcmlmeU5vU3VjaEVsZW1lbnRFeGNlcHRpb24oSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0pIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlTdHJpbmcgc3RyaW5nID0gbnVsbDsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCXN0cmluZyA9IHN0cmVhbS5uZXh0KCk7Ci0JCX0KLQkJdHJ5IHsKLQkJCXN0cmluZyA9IHN0cmVhbS5uZXh0KCk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIG5vdCB0aHJvd246ICIgKyBzdHJpbmcsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKSB7Ci0JCXRoaXMudmVyaWZ5VW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24odGhpcy5idWlsZFVubW9kaWZpYWJsZUNvbXBvc2l0ZUl0ZXJhdG9yKCkpOwotCX0KLQotCXZvaWQgdmVyaWZ5VW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0pIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJT2JqZWN0IHN0cmluZyA9IHN0cmVhbS5uZXh0KCk7Ci0JCQlpZiAoc3RyaW5nLmVxdWFscygiMzMzIikpIHsKLQkJCQl0cnkgewotCQkJCQlzdHJlYW0ucmVtb3ZlKCk7Ci0JCQkJfSBjYXRjaCAoVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gZXgpIHsKLQkJCQkJZXhDYXVnaHQgPSB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfQotCQlhc3NlcnRUcnVlKCJVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBub3QgdGhyb3duIiwgZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbGxlZ2FsU3RhdGVFeGNlcHRpb24oKSB7Ci0JCXRoaXMudmVyaWZ5SWxsZWdhbFN0YXRlRXhjZXB0aW9uKCk7Ci0JfQotCi0Jdm9pZCB2ZXJpZnlJbGxlZ2FsU3RhdGVFeGNlcHRpb24oKSB7Ci0JCXRoaXMudmVyaWZ5SWxsZWdhbFN0YXRlRXhjZXB0aW9uKHRoaXMuYnVpbGRDb21wb3NpdGVJdGVyYXRvcigpKTsKLQl9Ci0KLQl2b2lkIHZlcmlmeUlsbGVnYWxTdGF0ZUV4Y2VwdGlvbihJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlzdHJlYW0ucmVtb3ZlKCk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxTdGF0ZUV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIklsbGVnYWxTdGF0ZUV4Y2VwdGlvbiBub3QgdGhyb3duIiwgZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RFbXB0eUhhc0Fub3RoZXIxKCkgewotCQl0aGlzLnZlcmlmeUVtcHR5SGFzQW5vdGhlcih0aGlzLmJ1aWxkRW1wdHlDb21wb3NpdGVJdGVyYXRvcjEoKSk7Ci0JfQotCi0Jdm9pZCB2ZXJpZnlFbXB0eUhhc0Fub3RoZXIoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0pIHsKLQkJaW50IGkgPSAwOwotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHMoMCwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEVtcHR5Tm9TdWNoRWxlbWVudEV4Y2VwdGlvbjEoKSB7Ci0JCXRoaXMudmVyaWZ5Tm9TdWNoRWxlbWVudEV4Y2VwdGlvbih0aGlzLmJ1aWxkRW1wdHlDb21wb3NpdGVJdGVyYXRvcjEoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEVtcHR5SWxsZWdhbFN0YXRlRXhjZXB0aW9uMSgpIHsKLQkJdGhpcy52ZXJpZnlFbXB0eUlsbGVnYWxTdGF0ZUV4Y2VwdGlvbjEoKTsKLQl9Ci0KLQl2b2lkIHZlcmlmeUVtcHR5SWxsZWdhbFN0YXRlRXhjZXB0aW9uMSgpIHsKLQkJdGhpcy52ZXJpZnlJbGxlZ2FsU3RhdGVFeGNlcHRpb24odGhpcy5idWlsZEVtcHR5Q29tcG9zaXRlSXRlcmF0b3IxKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RFbXB0eUhhc0Fub3RoZXIyKCkgewotCQl0aGlzLnZlcmlmeUVtcHR5SGFzQW5vdGhlcih0aGlzLmJ1aWxkRW1wdHlDb21wb3NpdGVJdGVyYXRvcjIoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEVtcHR5Tm9TdWNoRWxlbWVudEV4Y2VwdGlvbjIoKSB7Ci0JCXRoaXMudmVyaWZ5Tm9TdWNoRWxlbWVudEV4Y2VwdGlvbih0aGlzLmJ1aWxkRW1wdHlDb21wb3NpdGVJdGVyYXRvcjIoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEVtcHR5SWxsZWdhbFN0YXRlRXhjZXB0aW9uMigpIHsKLQkJdGhpcy52ZXJpZnlFbXB0eUlsbGVnYWxTdGF0ZUV4Y2VwdGlvbjIoKTsKLQl9Ci0KLQl2b2lkIHZlcmlmeUVtcHR5SWxsZWdhbFN0YXRlRXhjZXB0aW9uMigpIHsKLQkJdGhpcy52ZXJpZnlJbGxlZ2FsU3RhdGVFeGNlcHRpb24odGhpcy5idWlsZEVtcHR5Q29tcG9zaXRlSXRlcmF0b3IyKCkpOwotCX0KLQotCUl0ZXJhdG9yPFN0cmluZz4gYnVpbGRDb21wb3NpdGVJdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRDb21wb3NpdGVJdGVyYXRvcih0aGlzLmJ1aWxkSXRlcmF0b3JzKCkpOwotCX0KLQotCUl0ZXJhdG9yPFN0cmluZz4gYnVpbGRFbXB0eUNvbXBvc2l0ZUl0ZXJhdG9yMSgpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRDb21wb3NpdGVJdGVyYXRvcih0aGlzLmJ1aWxkRW1wdHlJdGVyYXRvcnMxKCkpOwotCX0KLQotCUl0ZXJhdG9yPFN0cmluZz4gYnVpbGRFbXB0eUNvbXBvc2l0ZUl0ZXJhdG9yMigpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRDb21wb3NpdGVJdGVyYXRvcih0aGlzLmJ1aWxkRW1wdHlJdGVyYXRvcnMyKCkpOwotCX0KLQotCUl0ZXJhdG9yPFN0cmluZz4gYnVpbGRVbm1vZGlmaWFibGVDb21wb3NpdGVJdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRDb21wb3NpdGVJdGVyYXRvcih0aGlzLmJ1aWxkVW5tb2RpZmlhYmxlSXRlcmF0b3JzKCkpOwotCX0KLQotCS8vIGxlYXZlIHVuY2hlY2tlZCBzbyB3ZSBjYW4gb3ZlcnJpZGUgaW4gc3ViY2xhc3MKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IoSXRlcmF0b3IgaXRlcmF0b3JzKSB7Ci0JCXJldHVybiBuZXcgQ29tcG9zaXRlSXRlcmF0b3I8U3RyaW5nPihpdGVyYXRvcnMpOwotCX0KLQotCS8vIHVzZSB2YXJhcmcgY29uc3RydWN0b3IKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IyKCkgewotCQlyZXR1cm4gbmV3IENvbXBvc2l0ZUl0ZXJhdG9yPFN0cmluZz4odGhpcy5idWlsZEl0ZXJhdG9yMSgpLCB0aGlzLmJ1aWxkSXRlcmF0b3IyKCksIHRoaXMuYnVpbGRJdGVyYXRvcjMoKSk7Ci0JfQotCi0JLy8gdXNlIHZhcmFyZyBjb25zdHJ1Y3RvcgotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCUl0ZXJhdG9yPFN0cmluZz4gYnVpbGRDb21wb3NpdGVJdGVyYXRvcjMoKSB7Ci0JCXJldHVybiBuZXcgQ29tcG9zaXRlSXRlcmF0b3I8U3RyaW5nPihuZXcgSXRlcmF0b3JbXSB7IHRoaXMuYnVpbGRJdGVyYXRvcjEoKSwgdGhpcy5idWlsZEl0ZXJhdG9yMigpLCB0aGlzLmJ1aWxkSXRlcmF0b3IzKCkgfSk7Ci0JfQotCi0JSXRlcmF0b3I8U3RyaW5nPiBidWlsZENvbXBvc2l0ZUl0ZXJhdG9yKFN0cmluZyBzdHJpbmcsIEl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IpIHsKLQkJcmV0dXJuIG5ldyBDb21wb3NpdGVJdGVyYXRvcjxTdHJpbmc+KHN0cmluZywgaXRlcmF0b3IpOwotCX0KLQotCUxpc3RJdGVyYXRvcjxJdGVyYXRvcjxTdHJpbmc+PiBidWlsZEl0ZXJhdG9ycygpIHsKLQkJTGlzdDxJdGVyYXRvcjxTdHJpbmc+PiBsaXN0ID0gbmV3IEFycmF5TGlzdDxJdGVyYXRvcjxTdHJpbmc+PigpOwotCQlsaXN0LmFkZCh0aGlzLmJ1aWxkSXRlcmF0b3IxKCkpOwotCQlsaXN0LmFkZCh0aGlzLmJ1aWxkSXRlcmF0b3IyKCkpOwotCQlsaXN0LmFkZCh0aGlzLmJ1aWxkSXRlcmF0b3IzKCkpOwotCQlyZXR1cm4gbGlzdC5saXN0SXRlcmF0b3IoKTsKLQl9Ci0KLQlMaXN0SXRlcmF0b3I8SXRlcmF0b3I8U3RyaW5nPj4gYnVpbGRFbXB0eUl0ZXJhdG9yczEoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkRW1wdHlJdGVyYXRvckl0ZXJhdG9yKCk7Ci0JfQotCi0JTGlzdEl0ZXJhdG9yPEl0ZXJhdG9yPFN0cmluZz4+IGJ1aWxkRW1wdHlJdGVyYXRvcnMyKCkgewotCQlMaXN0PEl0ZXJhdG9yPFN0cmluZz4+IGxpc3QgPSBuZXcgQXJyYXlMaXN0PEl0ZXJhdG9yPFN0cmluZz4+KCk7Ci0JCWxpc3QuYWRkKHRoaXMuYnVpbGRFbXB0eVN0cmluZ0l0ZXJhdG9yKCkpOwotCQlsaXN0LmFkZCh0aGlzLmJ1aWxkRW1wdHlTdHJpbmdJdGVyYXRvcigpKTsKLQkJbGlzdC5hZGQodGhpcy5idWlsZEVtcHR5U3RyaW5nSXRlcmF0b3IoKSk7Ci0JCXJldHVybiBsaXN0Lmxpc3RJdGVyYXRvcigpOwotCX0KLQotCUxpc3RJdGVyYXRvcjxJdGVyYXRvcjxTdHJpbmc+PiBidWlsZFVubW9kaWZpYWJsZUl0ZXJhdG9ycygpIHsKLQkJTGlzdDxJdGVyYXRvcjxTdHJpbmc+PiBsaXN0ID0gbmV3IEFycmF5TGlzdDxJdGVyYXRvcjxTdHJpbmc+PigpOwotCQlsaXN0LmFkZCh0aGlzLmJ1aWxkVW5tb2RpZmlhYmxlSXRlcmF0b3IxKCkpOwotCQlsaXN0LmFkZCh0aGlzLmJ1aWxkVW5tb2RpZmlhYmxlSXRlcmF0b3IyKCkpOwotCQlsaXN0LmFkZCh0aGlzLmJ1aWxkVW5tb2RpZmlhYmxlSXRlcmF0b3IzKCkpOwotCQlyZXR1cm4gbGlzdC5saXN0SXRlcmF0b3IoKTsKLQl9Ci0KLQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBidWlsZEl0ZXJhdG9yMSgpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRMaXN0MSgpLmxpc3RJdGVyYXRvcigpOwotCX0KLQotCUxpc3RJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkSXRlcmF0b3IyKCkgewotCQlyZXR1cm4gdGhpcy5idWlsZExpc3QyKCkubGlzdEl0ZXJhdG9yKCk7Ci0JfQotCi0JTGlzdEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRJdGVyYXRvcjMoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkTGlzdDMoKS5saXN0SXRlcmF0b3IoKTsKLQl9Ci0KLQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBidWlsZFVubW9kaWZpYWJsZUl0ZXJhdG9yMSgpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRVbm1vZGlmaWFibGVMaXN0MSgpLmxpc3RJdGVyYXRvcigpOwotCX0KLQotCUxpc3RJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkVW5tb2RpZmlhYmxlSXRlcmF0b3IyKCkgewotCQlyZXR1cm4gdGhpcy5idWlsZFVubW9kaWZpYWJsZUxpc3QyKCkubGlzdEl0ZXJhdG9yKCk7Ci0JfQotCi0JTGlzdEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRVbm1vZGlmaWFibGVJdGVyYXRvcjMoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkVW5tb2RpZmlhYmxlTGlzdDMoKS5saXN0SXRlcmF0b3IoKTsKLQl9Ci0KLQlMaXN0SXRlcmF0b3I8SXRlcmF0b3I8U3RyaW5nPj4gYnVpbGRFbXB0eUl0ZXJhdG9ySXRlcmF0b3IoKSB7Ci0JCXJldHVybiAobmV3IEFycmF5TGlzdDxJdGVyYXRvcjxTdHJpbmc+PigpKS5saXN0SXRlcmF0b3IoKTsKLQl9Ci0KLQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBidWlsZEVtcHR5U3RyaW5nSXRlcmF0b3IoKSB7Ci0JCXJldHVybiAobmV3IEFycmF5TGlzdDxTdHJpbmc+KCkpLmxpc3RJdGVyYXRvcigpOwotCX0KLQotCUxpc3Q8U3RyaW5nPiBidWlsZExpc3QxKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlsaXN0LmFkZCgiMSIpOwotCQlsaXN0LmFkZCgiMjIiKTsKLQkJbGlzdC5hZGQoIjMzMyIpOwotCQlsaXN0LmFkZCgiNDQ0NCIpOwotCQlyZXR1cm4gbGlzdDsKLQl9Ci0KLQlMaXN0PFN0cmluZz4gYnVpbGRMaXN0MigpIHsKLQkJcmV0dXJuIG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCX0KLQotCUxpc3Q8U3RyaW5nPiBidWlsZExpc3QzKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlsaXN0LmFkZCgiNTU1NTUiKTsKLQkJbGlzdC5hZGQoIjY2NjY2NiIpOwotCQlsaXN0LmFkZCgiNzc3Nzc3NyIpOwotCQlsaXN0LmFkZCgiODg4ODg4ODgiKTsKLQkJcmV0dXJuIGxpc3Q7Ci0JfQotCi0JTGlzdDxTdHJpbmc+IGJ1aWxkVW5tb2RpZmlhYmxlTGlzdDEoKSB7Ci0JCXJldHVybiBDb2xsZWN0aW9ucy51bm1vZGlmaWFibGVMaXN0KHRoaXMuYnVpbGRMaXN0MSgpKTsKLQl9Ci0KLQlMaXN0PFN0cmluZz4gYnVpbGRVbm1vZGlmaWFibGVMaXN0MigpIHsKLQkJcmV0dXJuIENvbGxlY3Rpb25zLnVubW9kaWZpYWJsZUxpc3QodGhpcy5idWlsZExpc3QyKCkpOwotCX0KLQotCUxpc3Q8U3RyaW5nPiBidWlsZFVubW9kaWZpYWJsZUxpc3QzKCkgewotCQlyZXR1cm4gQ29sbGVjdGlvbnMudW5tb2RpZmlhYmxlTGlzdCh0aGlzLmJ1aWxkTGlzdDMoKSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9Db21wb3NpdGVMaXN0SXRlcmF0b3JUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvQ29tcG9zaXRlTGlzdEl0ZXJhdG9yVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDNhYTFkMS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9Db21wb3NpdGVMaXN0SXRlcmF0b3JUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzMwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuQ29tcG9zaXRlTGlzdEl0ZXJhdG9yOwotCi1wdWJsaWMgY2xhc3MgQ29tcG9zaXRlTGlzdEl0ZXJhdG9yVGVzdHMgZXh0ZW5kcyBSZWFkT25seUNvbXBvc2l0ZUxpc3RJdGVyYXRvclRlc3RzIHsKLQotCXB1YmxpYyBDb21wb3NpdGVMaXN0SXRlcmF0b3JUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlKCkgewotCQlzdXBlci50ZXN0UmVtb3ZlKCk7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0MSA9IHRoaXMuYnVpbGRMaXN0MSgpOwotCQlMaXN0PFN0cmluZz4gbGlzdDIgPSB0aGlzLmJ1aWxkTGlzdDIoKTsKLQkJTGlzdDxTdHJpbmc+IGxpc3QzID0gdGhpcy5idWlsZExpc3QzKCk7Ci0JCU9iamVjdCBmaXJzdEVsZW1lbnQzID0gbGlzdDMuZ2V0KDApOwotCi0JCUxpc3Q8SXRlcmF0b3I8U3RyaW5nPj4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8SXRlcmF0b3I8U3RyaW5nPj4oKTsKLQkJbGlzdC5hZGQobGlzdDEubGlzdEl0ZXJhdG9yKCkpOwotCQlsaXN0LmFkZChsaXN0Mi5saXN0SXRlcmF0b3IoKSk7Ci0JCWxpc3QuYWRkKGxpc3QzLmxpc3RJdGVyYXRvcigpKTsKLQotCQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSAoTGlzdEl0ZXJhdG9yPFN0cmluZz4pIHRoaXMuYnVpbGRDb21wb3NpdGVJdGVyYXRvcihsaXN0Lmxpc3RJdGVyYXRvcigpKTsKLQkJLy8gcG9zaXRpb24gdG8gZW5kIG9mIHN0cmVhbQotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJfQotCQl3aGlsZSAoc3RyZWFtLmhhc1ByZXZpb3VzKCkpIHsKLQkJCU9iamVjdCBwcmV2aW91cyA9IHN0cmVhbS5wcmV2aW91cygpOwotCQkJaWYgKHByZXZpb3VzLmVxdWFscygiMzMzIikpIHsKLQkJCQlzdHJlYW0ucmVtb3ZlKCk7Ci0JCQl9Ci0JCQkvLyB0ZXN0IHNwZWNpYWwgY2FzZSAtIHdoZXJlIHdlIGFyZSBiZXR3ZWVuIGl0ZXJhdG9ycwotCQkJaWYgKHByZXZpb3VzLmVxdWFscyhmaXJzdEVsZW1lbnQzKSkgewotCQkJCS8vIHRoaXMgd2lsbCB0cmlnZ2VyIHRoZSBuZXh0IGl0ZXJhdG9yIHRvIGJlIGxvYWRlZAotCQkJCXN0cmVhbS5oYXNQcmV2aW91cygpOwotCQkJCS8vIG5vdyB0cnkgdG8gcmVtb3ZlIGZyb20gdGhlIHByZXZpb3VzIGl0ZXJhdG9yCi0JCQkJc3RyZWFtLnJlbW92ZSgpOwotCQkJfQotCQl9Ci0JCXN0cmVhbS5yZW1vdmUoKTsKLQotCQlhc3NlcnRFcXVhbHMoIm5vdGhpbmcgcmVtb3ZlZCBmcm9tIGNvbGxlY3Rpb24gMSIsIHRoaXMuYnVpbGRMaXN0MSgpLnNpemUoKSAtIDIsIGxpc3QxLnNpemUoKSk7Ci0JCWFzc2VydEZhbHNlKCJlbGVtZW50IHN0aWxsIGluIGNvbGxlY3Rpb24gMSIsIGxpc3QxLmNvbnRhaW5zKCIxIikpOwotCQlhc3NlcnRGYWxzZSgiZWxlbWVudCBzdGlsbCBpbiBjb2xsZWN0aW9uIDEiLCBsaXN0MS5jb250YWlucygiMzMzIikpOwotCi0JCWFzc2VydEVxdWFscygibm90aGluZyByZW1vdmVkIGZyb20gY29sbGVjdGlvbiAzIiwgdGhpcy5idWlsZExpc3QzKCkuc2l6ZSgpIC0gMSwgbGlzdDMuc2l6ZSgpKTsKLQkJYXNzZXJ0RmFsc2UoImZpcnN0IGVsZW1lbnQgc3RpbGwgaW4gY29sbGVjdGlvbiAzIiwgbGlzdDMuY29udGFpbnMoZmlyc3RFbGVtZW50MykpOwotCQlhc3NlcnRUcnVlKCJ3cm9uZyBlbGVtZW50IHJlbW92ZWQgZnJvbSBjb2xsZWN0aW9uIDMiLCBsaXN0My5jb250YWlucygiNjY2NjY2IikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGQoKSB7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0MSA9IHRoaXMuYnVpbGRMaXN0MSgpOwotCQlPYmplY3QgbGFzdEVsZW1lbnQxID0gbGlzdDEuZ2V0KGxpc3QxLnNpemUoKSAtIDEpOwotCQlMaXN0PFN0cmluZz4gbGlzdDIgPSB0aGlzLmJ1aWxkTGlzdDIoKTsKLQkJTGlzdDxTdHJpbmc+IGxpc3QzID0gdGhpcy5idWlsZExpc3QzKCk7Ci0JCU9iamVjdCBmaXJzdEVsZW1lbnQzID0gbGlzdDMuZ2V0KDApOwotCi0JCUxpc3Q8SXRlcmF0b3I8U3RyaW5nPj4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8SXRlcmF0b3I8U3RyaW5nPj4oKTsKLQkJbGlzdC5hZGQobGlzdDEubGlzdEl0ZXJhdG9yKCkpOwotCQlsaXN0LmFkZChsaXN0Mi5saXN0SXRlcmF0b3IoKSk7Ci0JCWxpc3QuYWRkKGxpc3QzLmxpc3RJdGVyYXRvcigpKTsKLQotCQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSAoTGlzdEl0ZXJhdG9yPFN0cmluZz4pIHRoaXMuYnVpbGRDb21wb3NpdGVJdGVyYXRvcihsaXN0Lmxpc3RJdGVyYXRvcigpKTsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCU9iamVjdCBuZXh0ID0gc3RyZWFtLm5leHQoKTsKLQkJCWlmIChuZXh0LmVxdWFscygiMzMzIikpIHsKLQkJCQlzdHJlYW0uYWRkKCIzLjUiKTsKLQkJCX0KLQkJCS8vIHRlc3Qgc3BlY2lhbCBjYXNlIC0gd2hlcmUgd2UgYXJlIGJldHdlZW4gaXRlcmF0b3JzCi0JCQlpZiAobmV4dC5lcXVhbHMobGFzdEVsZW1lbnQxKSkgewotCQkJCS8vIHRoaXMgd2lsbCB0cmlnZ2VyIHRoZSBuZXh0IGl0ZXJhdG9yIHRvIGJlIGxvYWRlZAotCQkJCXN0cmVhbS5oYXNOZXh0KCk7Ci0JCQkJLy8gbm93IHRyeSB0byBhZGQgdG8gdGhlIGl0ZXJhdG9yCi0JCQkJc3RyZWFtLmFkZCgic29tZXRoaW5nIGluIDMiKTsKLQkJCX0KLQkJfQotCQlzdHJlYW0uYWRkKCJmaW5hbGUiKTsKLQkJYm9vbGVhbiBjaGVja0ZvckZpbmFsZSA9IHRydWU7Ci0JCXdoaWxlIChzdHJlYW0uaGFzUHJldmlvdXMoKSkgewotCQkJT2JqZWN0IHByZXZpb3VzID0gc3RyZWFtLnByZXZpb3VzKCk7Ci0JCQlpZiAoY2hlY2tGb3JGaW5hbGUpIHsKLQkJCQljaGVja0ZvckZpbmFsZSA9IGZhbHNlOwotCQkJCWFzc2VydEVxdWFscygiYWRkZWQgZWxlbWVudCBkcm9wcGVkIiwgImZpbmFsZSIsIHByZXZpb3VzKTsKLQkJCX0KLQkJCWlmIChwcmV2aW91cy5lcXVhbHMoIjMzMyIpKSB7Ci0JCQkJc3RyZWFtLmFkZCgiMi41Iik7Ci0JCQl9Ci0JCQkvLyB0ZXN0IHNwZWNpYWwgY2FzZSAtIHdoZXJlIHdlIGFyZSBiZXR3ZWVuIGl0ZXJhdG9ycwotCQkJaWYgKHByZXZpb3VzLmVxdWFscyhmaXJzdEVsZW1lbnQzKSkgewotCQkJCS8vIHRoaXMgd2lsbCB0cmlnZ2VyIHRoZSBuZXh0IGl0ZXJhdG9yIHRvIGJlIGxvYWRlZAotCQkJCXN0cmVhbS5oYXNQcmV2aW91cygpOwotCQkJCS8vIG5vdyB0cnkgdG8gcmVtb3ZlIGZyb20gdGhlIHByZXZpb3VzIGl0ZXJhdG9yCi0JCQkJc3RyZWFtLmFkZCgib2xkIHN0YXJ0IG9mIDMiKTsKLQkJCX0KLQkJfQotCQlzdHJlYW0uYWRkKCJwcmVsdWRlIik7Ci0JCWFzc2VydEVxdWFscygiYWRkZWQgZWxlbWVudCBkcm9wcGVkIiwgInByZWx1ZGUiLCBzdHJlYW0ucHJldmlvdXMoKSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKCJlbGVtZW50cyBub3QgYWRkZWQgdG8gY29sbGVjdGlvbiAxIiwgdGhpcy5idWlsZExpc3QxKCkuc2l6ZSgpICsgMywgbGlzdDEuc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJlbGVtZW50IG5vdCBhZGRlZCB0byBjb2xsZWN0aW9uIDEiLCAicHJlbHVkZSIsIGxpc3QxLmdldCgwKSk7Ci0JCWFzc2VydEVxdWFscygiZWxlbWVudCBub3QgYWRkZWQgdG8gY29sbGVjdGlvbiAxIiwgIjIuNSIsIGxpc3QxLmdldCgzKSk7Ci0JCWFzc2VydEVxdWFscygiZWxlbWVudCBub3QgYWRkZWQgdG8gY29sbGVjdGlvbiAxIiwgIjMuNSIsIGxpc3QxLmdldCg1KSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKCJlbGVtZW50cyBub3QgYWRkZWQgdG8gY29sbGVjdGlvbiAzIiwgdGhpcy5idWlsZExpc3QzKCkuc2l6ZSgpICsgMywgbGlzdDMuc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJlbGVtZW50IG5vdCBhZGRlZCB0byBjb2xsZWN0aW9uIDMiLCAic29tZXRoaW5nIGluIDMiLCBsaXN0My5nZXQoMCkpOwotCQlhc3NlcnRFcXVhbHMoImVsZW1lbnQgbm90IGFkZGVkIHRvIGNvbGxlY3Rpb24gMyIsICJvbGQgc3RhcnQgb2YgMyIsIGxpc3QzLmdldCgxKSk7Ci0JCWFzc2VydEVxdWFscygiZWxlbWVudCBub3QgYWRkZWQgdG8gY29sbGVjdGlvbiAzIiwgImZpbmFsZSIsIGxpc3QzLmdldChsaXN0My5zaXplKCkgLSAxKSk7Ci0KLQkJLy8gYWRkIHRvIHRoZSBmcm9udAotCQlzdHJlYW0gPSAoTGlzdEl0ZXJhdG9yPFN0cmluZz4pIHRoaXMuYnVpbGRDb21wb3NpdGVJdGVyYXRvcigpOwotCQlzdHJlYW0uYWRkKCJibGFoIik7Ci0JCWFzc2VydEZhbHNlKCJhZGRlZCBlbGVtZW50IHNob3VsZCBiZSBwbGFjZWQgQkVGT1JFIHRoZSBcImN1cnNvclwiIiwgc3RyZWFtLm5leHQoKS5lcXVhbHMoImJsYWgiKSk7Ci0KLQkJc3RyZWFtID0gKExpc3RJdGVyYXRvcjxTdHJpbmc+KSB0aGlzLmJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IoKTsKLQkJc3RyZWFtLmFkZCgiYmxhaCIpOwotCQlhc3NlcnRUcnVlKCJhZGRlZCBlbGVtZW50IHNob3VsZCBiZSBwbGFjZWQgQkVGT1JFIHRoZSBcImN1cnNvclwiIiwgc3RyZWFtLnByZXZpb3VzKCkuZXF1YWxzKCJibGFoIikpOwotCi0JCXN0cmVhbSA9IChMaXN0SXRlcmF0b3I8U3RyaW5nPikgdGhpcy5idWlsZENvbXBvc2l0ZUl0ZXJhdG9yKCk7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQl9Ci0JCXdoaWxlIChzdHJlYW0uaGFzUHJldmlvdXMoKSkgewotCQkJc3RyZWFtLnByZXZpb3VzKCk7Ci0JCX0KLQkJc3RyZWFtLmFkZCgiYmxhaCIpOwotCQlhc3NlcnRGYWxzZSgiYWRkZWQgZWxlbWVudCBzaG91bGQgYmUgcGxhY2VkIEJFRk9SRSB0aGUgXCJjdXJzb3JcIiIsIHN0cmVhbS5uZXh0KCkuZXF1YWxzKCJibGFoIikpOwotCi0JCXN0cmVhbSA9IChMaXN0SXRlcmF0b3I8U3RyaW5nPikgdGhpcy5idWlsZENvbXBvc2l0ZUl0ZXJhdG9yKCk7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQl9Ci0JCXdoaWxlIChzdHJlYW0uaGFzUHJldmlvdXMoKSkgewotCQkJc3RyZWFtLnByZXZpb3VzKCk7Ci0JCX0KLQkJc3RyZWFtLmFkZCgiYmxhaCIpOwotCQlhc3NlcnRUcnVlKCJhZGRlZCBlbGVtZW50IHNob3VsZCBiZSBwbGFjZWQgQkVGT1JFIHRoZSBcImN1cnNvclwiIiwgc3RyZWFtLnByZXZpb3VzKCkuZXF1YWxzKCJibGFoIikpOwotCi0JCS8vIGFkZCB0byB0aGUgbWlkZGxlCi0JCXN0cmVhbSA9IChMaXN0SXRlcmF0b3I8U3RyaW5nPikgdGhpcy5idWlsZENvbXBvc2l0ZUl0ZXJhdG9yKCk7Ci0JCXN0cmVhbS5uZXh0KCk7Ci0JCXN0cmVhbS5hZGQoImJsYWgiKTsKLQkJYXNzZXJ0RmFsc2UoImFkZGVkIGVsZW1lbnQgc2hvdWxkIGJlIHBsYWNlZCBCRUZPUkUgdGhlIFwiY3Vyc29yXCIiLCBzdHJlYW0ubmV4dCgpLmVxdWFscygiYmxhaCIpKTsKLQotCQlzdHJlYW0gPSAoTGlzdEl0ZXJhdG9yPFN0cmluZz4pIHRoaXMuYnVpbGRDb21wb3NpdGVJdGVyYXRvcigpOwotCQlzdHJlYW0ubmV4dCgpOwotCQlzdHJlYW0uYWRkKCJibGFoIik7Ci0JCWFzc2VydFRydWUoImFkZGVkIGVsZW1lbnQgc2hvdWxkIGJlIHBsYWNlZCBCRUZPUkUgdGhlIFwiY3Vyc29yXCIiLCBzdHJlYW0ucHJldmlvdXMoKS5lcXVhbHMoImJsYWgiKSk7Ci0KLQkJc3RyZWFtID0gKExpc3RJdGVyYXRvcjxTdHJpbmc+KSB0aGlzLmJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IoKTsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCXN0cmVhbS5uZXh0KCk7Ci0JCX0KLQkJc3RyZWFtLnByZXZpb3VzKCk7Ci0JCXN0cmVhbS5hZGQoImJsYWgiKTsKLQkJYXNzZXJ0RmFsc2UoImFkZGVkIGVsZW1lbnQgc2hvdWxkIGJlIHBsYWNlZCBCRUZPUkUgdGhlIFwiY3Vyc29yXCIiLCBzdHJlYW0ubmV4dCgpLmVxdWFscygiYmxhaCIpKTsKLQotCQlzdHJlYW0gPSAoTGlzdEl0ZXJhdG9yPFN0cmluZz4pIHRoaXMuYnVpbGRDb21wb3NpdGVJdGVyYXRvcigpOwotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJfQotCQlzdHJlYW0ucHJldmlvdXMoKTsKLQkJc3RyZWFtLmFkZCgiYmxhaCIpOwotCQlhc3NlcnRUcnVlKCJhZGRlZCBlbGVtZW50IHNob3VsZCBiZSBwbGFjZWQgQkVGT1JFIHRoZSBcImN1cnNvclwiIiwgc3RyZWFtLnByZXZpb3VzKCkuZXF1YWxzKCJibGFoIikpOwotCi0JCS8vIGFkZCB0byB0aGUgZW5kCi0JCXN0cmVhbSA9IChMaXN0SXRlcmF0b3I8U3RyaW5nPikgdGhpcy5idWlsZENvbXBvc2l0ZUl0ZXJhdG9yKCk7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQl9Ci0JCXN0cmVhbS5hZGQoImJsYWgiKTsKLQkJYXNzZXJ0RmFsc2UoImFkZGVkIGVsZW1lbnQgc2hvdWxkIGJlIHBsYWNlZCBCRUZPUkUgdGhlIFwiY3Vyc29yXCIiLCBzdHJlYW0uaGFzTmV4dCgpKTsKLQotCQlzdHJlYW0gPSAoTGlzdEl0ZXJhdG9yPFN0cmluZz4pIHRoaXMuYnVpbGRDb21wb3NpdGVJdGVyYXRvcigpOwotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJfQotCQlzdHJlYW0uYWRkKCJibGFoIik7Ci0JCWFzc2VydFRydWUoImFkZGVkIGVsZW1lbnQgc2hvdWxkIGJlIHBsYWNlZCBCRUZPUkUgdGhlIFwiY3Vyc29yXCIiLCBzdHJlYW0ucHJldmlvdXMoKS5lcXVhbHMoImJsYWgiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNldCgpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QxID0gdGhpcy5idWlsZExpc3QxKCk7Ci0JCU9iamVjdCBsYXN0RWxlbWVudDEgPSBsaXN0MS5nZXQobGlzdDEuc2l6ZSgpIC0gMSk7Ci0JCUxpc3Q8U3RyaW5nPiBsaXN0MiA9IHRoaXMuYnVpbGRMaXN0MigpOwotCQlMaXN0PFN0cmluZz4gbGlzdDMgPSB0aGlzLmJ1aWxkTGlzdDMoKTsKLQkJT2JqZWN0IGZpcnN0RWxlbWVudDMgPSBsaXN0My5nZXQoMCk7Ci0KLQkJTGlzdDxJdGVyYXRvcjxTdHJpbmc+PiBsaXN0ID0gbmV3IEFycmF5TGlzdDxJdGVyYXRvcjxTdHJpbmc+PigpOwotCQlsaXN0LmFkZChsaXN0MS5saXN0SXRlcmF0b3IoKSk7Ci0JCWxpc3QuYWRkKGxpc3QyLmxpc3RJdGVyYXRvcigpKTsKLQkJbGlzdC5hZGQobGlzdDMubGlzdEl0ZXJhdG9yKCkpOwotCi0JCUxpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IChMaXN0SXRlcmF0b3I8U3RyaW5nPikgdGhpcy5idWlsZENvbXBvc2l0ZUl0ZXJhdG9yKGxpc3QubGlzdEl0ZXJhdG9yKCkpOwotCQkvLyBwb3NpdGlvbiB0byBlbmQgb2Ygc3RyZWFtCi0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlPYmplY3QgbmV4dCA9IHN0cmVhbS5uZXh0KCk7Ci0JCQlpZiAobmV4dC5lcXVhbHMoIjMzMyIpKSB7Ci0JCQkJc3RyZWFtLnNldCgiMzMzYSIpOwotCQkJfQotCQkJLy8gdGVzdCBzcGVjaWFsIGNhc2UgLSB3aGVyZSB3ZSBhcmUgYmV0d2VlbiBpdGVyYXRvcnMKLQkJCWlmIChuZXh0LmVxdWFscyhsYXN0RWxlbWVudDEpKSB7Ci0JCQkJLy8gdGhpcyB3aWxsIHRyaWdnZXIgdGhlIG5leHQgaXRlcmF0b3IgdG8gYmUgbG9hZGVkCi0JCQkJc3RyZWFtLmhhc05leHQoKTsKLQkJCQkvLyBub3cgdHJ5IHRvIHJlbW92ZSBmcm9tIHRoZSBwcmV2aW91cyBpdGVyYXRvcgotCQkJCXN0cmVhbS5zZXQoImVuZCBvZiAxIik7Ci0JCQl9Ci0JCX0KLQkJd2hpbGUgKHN0cmVhbS5oYXNQcmV2aW91cygpKSB7Ci0JCQlPYmplY3QgcHJldmlvdXMgPSBzdHJlYW0ucHJldmlvdXMoKTsKLQkJCWlmIChwcmV2aW91cy5lcXVhbHMoIjIyIikpIHsKLQkJCQlzdHJlYW0uc2V0KCIyMmEiKTsKLQkJCX0KLQkJCS8vIHRlc3Qgc3BlY2lhbCBjYXNlIC0gd2hlcmUgd2UgYXJlIGJldHdlZW4gaXRlcmF0b3JzCi0JCQlpZiAocHJldmlvdXMuZXF1YWxzKGZpcnN0RWxlbWVudDMpKSB7Ci0JCQkJLy8gdGhpcyB3aWxsIHRyaWdnZXIgdGhlIG5leHQgaXRlcmF0b3IgdG8gYmUgbG9hZGVkCi0JCQkJc3RyZWFtLmhhc1ByZXZpb3VzKCk7Ci0JCQkJLy8gbm93IHRyeSB0byByZW1vdmUgZnJvbSB0aGUgcHJldmlvdXMgaXRlcmF0b3IKLQkJCQlzdHJlYW0uc2V0KCJzdGFydCBvZiAzIik7Ci0JCQl9Ci0JCX0KLQotCQlhc3NlcnRFcXVhbHMoImVsZW1lbnQocykgYWRkZWQgdG8gY29sbGVjdGlvbiAxIiwgdGhpcy5idWlsZExpc3QxKCkuc2l6ZSgpLCBsaXN0MS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoImVsZW1lbnQgbm90IHNldCBpbiBjb2xsZWN0aW9uIDEiLCAiMjJhIiwgbGlzdDEuZ2V0KDEpKTsKLQkJYXNzZXJ0RmFsc2UoImVsZW1lbnQgbm90IHNldCBpbiBjb2xsZWN0aW9uIDEiLCBsaXN0MS5jb250YWlucygiMjIiKSk7Ci0JCWFzc2VydEVxdWFscygiZWxlbWVudCBub3Qgc2V0IGluIGNvbGxlY3Rpb24gMSIsICIzMzNhIiwgbGlzdDEuZ2V0KDIpKTsKLQkJYXNzZXJ0RmFsc2UoImVsZW1lbnQgbm90IHNldCBpbiBjb2xsZWN0aW9uIDEiLCBsaXN0MS5jb250YWlucygiMzMzIikpOwotCQlhc3NlcnRFcXVhbHMoImVsZW1lbnQgbm90IHNldCBpbiBjb2xsZWN0aW9uIDEiLCAiZW5kIG9mIDEiLCBsaXN0MS5nZXQobGlzdDEuc2l6ZSgpIC0gMSkpOwotCQlhc3NlcnRGYWxzZSgiZWxlbWVudCBub3Qgc2V0IGluIGNvbGxlY3Rpb24gMSIsIGxpc3QxLmNvbnRhaW5zKGxhc3RFbGVtZW50MSkpOwotCi0JCWFzc2VydEVxdWFscygiZWxlbWVudChzKSBhZGRlZCB0byBjb2xsZWN0aW9uIDMiLCB0aGlzLmJ1aWxkTGlzdDMoKS5zaXplKCksIGxpc3QzLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscygiZWxlbWVudCBub3Qgc2V0IGluIGNvbGxlY3Rpb24gMyIsICJzdGFydCBvZiAzIiwgbGlzdDMuZ2V0KDApKTsKLQkJYXNzZXJ0RmFsc2UoImVsZW1lbnQgbm90IHNldCBpbiBjb2xsZWN0aW9uIDMiLCBsaXN0My5jb250YWlucyhmaXJzdEVsZW1lbnQzKSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgdGVzdE5leHRJbmRleFByZXZpb3VzSW5kZXgoKSB7Ci0JCWludCBpID0gMDsKLQkJTGlzdEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gKExpc3RJdGVyYXRvcjxTdHJpbmc+KSB0aGlzLmJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IoKTsKLQkJYXNzZXJ0RXF1YWxzKGksIHN0cmVhbS5uZXh0SW5kZXgoKSk7Ci0JCWFzc2VydEVxdWFscyhpIC0gMSwgc3RyZWFtLnByZXZpb3VzSW5kZXgoKSk7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlPYmplY3QgbmV4dCA9IHN0cmVhbS5uZXh0KCk7Ci0JCQlpKys7Ci0JCQlpZiAobmV4dC5lcXVhbHMoIjMzMyIpKSB7Ci0JCQkJc3RyZWFtLnJlbW92ZSgpOwotCQkJCWktLTsKLQkJCX0KLQkJCWlmIChuZXh0LmVxdWFscygiNzc3Nzc3NyIpKSB7Ci0JCQkJc3RyZWFtLmFkZCgiNy41Iik7Ci0JCQkJaSsrOwotCQkJfQotCQkJYXNzZXJ0RXF1YWxzKGksIHN0cmVhbS5uZXh0SW5kZXgoKSk7Ci0JCQlhc3NlcnRFcXVhbHMoaSAtIDEsIHN0cmVhbS5wcmV2aW91c0luZGV4KCkpOwotCQl9Ci0JCWFzc2VydEVxdWFscygiaW5kZXggaXMgY29ycnVwdCIsIDgsIGkpOwotCi0JCWFzc2VydEVxdWFscyhpLCBzdHJlYW0ubmV4dEluZGV4KCkpOwotCQlhc3NlcnRFcXVhbHMoaSAtIDEsIHN0cmVhbS5wcmV2aW91c0luZGV4KCkpOwotCQl3aGlsZSAoc3RyZWFtLmhhc1ByZXZpb3VzKCkpIHsKLQkJCU9iamVjdCBwcmV2aW91cyA9IHN0cmVhbS5wcmV2aW91cygpOwotCQkJaS0tOwotCQkJaWYgKHByZXZpb3VzLmVxdWFscygiNjY2NjY2IikpIHsKLQkJCQlzdHJlYW0ucmVtb3ZlKCk7Ci0JCQkJLy8gcmVtb3ZpbmcgYSBwcmV2aW91cyBlbGVtZW50LCBkb2VzIG5vdCBjaGFuZ2UgdGhlIGN1cnNvcgotCQkJfQotCQkJaWYgKHByZXZpb3VzLmVxdWFscygiMjIiKSkgewotCQkJCXN0cmVhbS5hZGQoIjEuNSIpOwotCQkJCWkrKzsKLQkJCX0KLQkJCWFzc2VydEVxdWFscyhpLCBzdHJlYW0ubmV4dEluZGV4KCkpOwotCQkJYXNzZXJ0RXF1YWxzKGkgLSAxLCBzdHJlYW0ucHJldmlvdXNJbmRleCgpKTsKLQkJfQotCQlhc3NlcnRFcXVhbHMoImluZGV4IGlzIGNvcnJ1cHQiLCAwLCBpKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0ZXN0SWxsZWdhbFN0YXRlRXhjZXB0aW9uKCkgewotCQl0aGlzLnZlcmlmeUlsbGVnYWxTdGF0ZUV4Y2VwdGlvbigpOwotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHRlc3RFbXB0eUlsbGVnYWxTdGF0ZUV4Y2VwdGlvbjEoKSB7Ci0JCXRoaXMudmVyaWZ5RW1wdHlJbGxlZ2FsU3RhdGVFeGNlcHRpb24xKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgdGVzdEVtcHR5SWxsZWdhbFN0YXRlRXhjZXB0aW9uMigpIHsKLQkJdGhpcy52ZXJpZnlFbXB0eUlsbGVnYWxTdGF0ZUV4Y2VwdGlvbjIoKTsKLQl9Ci0KLQkvLyB1bmNoZWNrZWQgc28gd2UgY2FuIG92ZXJyaWRlIHRoZSB1bmNoZWNrZWQgbWV0aG9kIGluIHN1cGVyY2xhc3MKLQlAT3ZlcnJpZGUKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IoSXRlcmF0b3IgaXRlcmF0b3JzKSB7Ci0JCXJldHVybiBuZXcgQ29tcG9zaXRlTGlzdEl0ZXJhdG9yPFN0cmluZz4oKExpc3RJdGVyYXRvcjxMaXN0SXRlcmF0b3I8U3RyaW5nPj4pIGl0ZXJhdG9ycyk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JSXRlcmF0b3I8U3RyaW5nPiBidWlsZENvbXBvc2l0ZUl0ZXJhdG9yMigpIHsKLQkJcmV0dXJuIG5ldyBDb21wb3NpdGVMaXN0SXRlcmF0b3I8U3RyaW5nPih0aGlzLmJ1aWxkSXRlcmF0b3IxKCksIHRoaXMuYnVpbGRJdGVyYXRvcjIoKSwgdGhpcy5idWlsZEl0ZXJhdG9yMygpKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IzKCkgewotCQlyZXR1cm4gbmV3IENvbXBvc2l0ZUxpc3RJdGVyYXRvcjxTdHJpbmc+KG5ldyBMaXN0SXRlcmF0b3JbXSB7IHRoaXMuYnVpbGRJdGVyYXRvcjEoKSwgdGhpcy5idWlsZEl0ZXJhdG9yMigpLCB0aGlzLmJ1aWxkSXRlcmF0b3IzKCkgfSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JTGlzdEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRDb21wb3NpdGVMaXN0SXRlcmF0b3IoU3RyaW5nIHN0cmluZywgTGlzdEl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IpIHsKLQkJcmV0dXJuIG5ldyBDb21wb3NpdGVMaXN0SXRlcmF0b3I8U3RyaW5nPihzdHJpbmcsIGl0ZXJhdG9yKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL0VtcHR5RW51bWVyYXRpb25UZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvRW1wdHlFbnVtZXJhdGlvblRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDk4Njk3ODkuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvRW1wdHlFbnVtZXJhdGlvblRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1MyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLml0ZXJhdG9yczsKLQotaW1wb3J0IGphdmEudXRpbC5FbnVtZXJhdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuTm9TdWNoRWxlbWVudEV4Y2VwdGlvbjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkVtcHR5RW51bWVyYXRpb247Ci0KLXB1YmxpYyBjbGFzcyBFbXB0eUVudW1lcmF0aW9uVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQlwdWJsaWMgRW1wdHlFbnVtZXJhdGlvblRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNNb3JlRWxlbWVudHMoKSB7Ci0JCWludCBpID0gMDsKLQkJZm9yIChFbnVtZXJhdGlvbjxPYmplY3Q+IHN0cmVhbSA9IEVtcHR5RW51bWVyYXRpb24uaW5zdGFuY2UoKTsgc3RyZWFtLmhhc01vcmVFbGVtZW50cygpOykgewotCQkJc3RyZWFtLm5leHRFbGVtZW50KCk7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDAsIGkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROZXh0RWxlbWVudCgpIHsKLQkJZm9yIChFbnVtZXJhdGlvbjxPYmplY3Q+IHN0cmVhbSA9IEVtcHR5RW51bWVyYXRpb24uaW5zdGFuY2UoKTsgc3RyZWFtLmhhc01vcmVFbGVtZW50cygpOykgewotCQkJZmFpbCgiYm9ndXMgZWxlbWVudDogIiArIHN0cmVhbS5uZXh0RWxlbWVudCgpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROb1N1Y2hFbGVtZW50RXhjZXB0aW9uKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCUVudW1lcmF0aW9uPE9iamVjdD4gc3RyZWFtID0gRW1wdHlFbnVtZXJhdGlvbi5pbnN0YW5jZSgpOwotCQlPYmplY3QgZWxlbWVudCA9IG51bGw7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTW9yZUVsZW1lbnRzKCkpIHsKLQkJCWVsZW1lbnQgPSBzdHJlYW0ubmV4dEVsZW1lbnQoKTsKLQkJfQotCQl0cnkgewotCQkJZWxlbWVudCA9IHN0cmVhbS5uZXh0RWxlbWVudCgpOwotCQl9IGNhdGNoIChOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBub3QgdGhyb3duOiAiICsgZWxlbWVudCwgZXhDYXVnaHQpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvRW1wdHlJdGVyYXRvclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9FbXB0eUl0ZXJhdG9yVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjk4NWFkNC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9FbXB0eUl0ZXJhdG9yVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDYzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Ob1N1Y2hFbGVtZW50RXhjZXB0aW9uOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuRW1wdHlJdGVyYXRvcjsKLQotcHVibGljIGNsYXNzIEVtcHR5SXRlcmF0b3JUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBFbXB0eUl0ZXJhdG9yVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc05leHQoKSB7Ci0JCWludCBpID0gMDsKLQkJZm9yIChJdGVyYXRvcjxPYmplY3Q+IHN0cmVhbSA9IEVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCXN0cmVhbS5uZXh0KCk7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDAsIGkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROZXh0KCkgewotCQlmb3IgKEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gRW1wdHlJdGVyYXRvci5pbnN0YW5jZSgpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJZmFpbCgiYm9ndXMgZWxlbWVudDogIiArIHN0cmVhbS5uZXh0KCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5vU3VjaEVsZW1lbnRFeGNlcHRpb24oKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJSXRlcmF0b3I8TnVtYmVyPiBzdHJlYW0gPSBFbXB0eUl0ZXJhdG9yLmluc3RhbmNlKCk7Ci0JCU9iamVjdCBlbGVtZW50ID0gbnVsbDsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCWVsZW1lbnQgPSBzdHJlYW0ubmV4dCgpOwotCQl9Ci0JCXRyeSB7Ci0JCQllbGVtZW50ID0gc3RyZWFtLm5leHQoKTsKLQkJfSBjYXRjaCAoTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIk5vU3VjaEVsZW1lbnRFeGNlcHRpb24gbm90IHRocm93bjogIiArIGVsZW1lbnQsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCUVtcHR5SXRlcmF0b3IuaW5zdGFuY2UoKS5yZW1vdmUoKTsKLQkJfSBjYXRjaCAoVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBub3QgdGhyb3duIiwgZXhDYXVnaHQpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvRW1wdHlMaXN0SXRlcmF0b3JUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvRW1wdHlMaXN0SXRlcmF0b3JUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzNWM4ZWZjLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL0VtcHR5TGlzdEl0ZXJhdG9yVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEyNyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLml0ZXJhdG9yczsKLQotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5FbXB0eUxpc3RJdGVyYXRvcjsKLQotcHVibGljIGNsYXNzIEVtcHR5TGlzdEl0ZXJhdG9yVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQlwdWJsaWMgRW1wdHlMaXN0SXRlcmF0b3JUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTmV4dCgpIHsKLQkJaW50IGkgPSAwOwotCQlmb3IgKExpc3RJdGVyYXRvcjxPYmplY3Q+IHN0cmVhbSA9IEVtcHR5TGlzdEl0ZXJhdG9yLmluc3RhbmNlKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscygwLCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TmV4dCgpIHsKLQkJZm9yIChMaXN0SXRlcmF0b3I8T2JqZWN0PiBzdHJlYW0gPSBFbXB0eUxpc3RJdGVyYXRvci5pbnN0YW5jZSgpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJZmFpbCgiYm9ndXMgZWxlbWVudDogIiArIHN0cmVhbS5uZXh0KCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5leHRJbmRleCgpIHsKLQkJTGlzdEl0ZXJhdG9yPE9iamVjdD4gc3RyZWFtID0gRW1wdHlMaXN0SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHN0cmVhbS5uZXh0SW5kZXgoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc1ByZXZpb3VzKCkgewotCQlMaXN0SXRlcmF0b3I8T2JqZWN0PiBzdHJlYW0gPSBFbXB0eUxpc3RJdGVyYXRvci5pbnN0YW5jZSgpOwotCQlpbnQgaSA9IDA7Ci0JCXdoaWxlIChzdHJlYW0uaGFzUHJldmlvdXMoKSkgewotCQkJc3RyZWFtLnByZXZpb3VzKCk7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDAsIGkpOwotCi0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQl9Ci0JCWkgPSAwOwotCQl3aGlsZSAoc3RyZWFtLmhhc1ByZXZpb3VzKCkpIHsKLQkJCXN0cmVhbS5wcmV2aW91cygpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscygwLCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UHJldmlvdXMoKSB7Ci0JCUxpc3RJdGVyYXRvcjxPYmplY3Q+IHN0cmVhbSA9IEVtcHR5TGlzdEl0ZXJhdG9yLmluc3RhbmNlKCk7Ci0JCXdoaWxlIChzdHJlYW0uaGFzUHJldmlvdXMoKSkgewotCQkJZmFpbCgiYm9ndXMgZWxlbWVudDogIiArIHN0cmVhbS5wcmV2aW91cygpKTsKLQkJfQotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJfQotCQl3aGlsZSAoc3RyZWFtLmhhc1ByZXZpb3VzKCkpIHsKLQkJCWZhaWwoImJvZ3VzIGVsZW1lbnQ6ICIgKyBzdHJlYW0ucHJldmlvdXMoKSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UHJldmlvdXNJbmRleCgpIHsKLQkJTGlzdEl0ZXJhdG9yPE9iamVjdD4gc3RyZWFtID0gRW1wdHlMaXN0SXRlcmF0b3IuaW5zdGFuY2UoKTsKLQkJYXNzZXJ0RXF1YWxzKC0xLCBzdHJlYW0ucHJldmlvdXNJbmRleCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Tm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlMaXN0SXRlcmF0b3I8T2JqZWN0PiBzdHJlYW0gPSBFbXB0eUxpc3RJdGVyYXRvci5pbnN0YW5jZSgpOwotCQlPYmplY3QgZWxlbWVudCA9IG51bGw7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQllbGVtZW50ID0gc3RyZWFtLm5leHQoKTsKLQkJfQotCQl0cnkgewotCQkJZWxlbWVudCA9IHN0cmVhbS5uZXh0KCk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIG5vdCB0aHJvd24gKG5leHQpOiAiICsgZWxlbWVudCwgZXhDYXVnaHQpOwotCQl3aGlsZSAoc3RyZWFtLmhhc1ByZXZpb3VzKCkpIHsKLQkJCWVsZW1lbnQgPSBzdHJlYW0ucHJldmlvdXMoKTsKLQkJfQotCQl0cnkgewotCQkJZWxlbWVudCA9IHN0cmVhbS5wcmV2aW91cygpOwotCQl9IGNhdGNoIChOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBub3QgdGhyb3duIChwcmV2aW91cyk6ICIgKyBlbGVtZW50LCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlFbXB0eUxpc3RJdGVyYXRvci5pbnN0YW5jZSgpLnJlbW92ZSgpOwotCQl9IGNhdGNoIChVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIlVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIG5vdCB0aHJvd24gKHJlbW92ZSkiLCBleENhdWdodCk7Ci0JCXRyeSB7Ci0JCQlFbXB0eUxpc3RJdGVyYXRvci5pbnN0YW5jZSgpLnNldChuZXcgT2JqZWN0KCkpOwotCQl9IGNhdGNoIChVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIlVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIG5vdCB0aHJvd24gKHNldCkiLCBleENhdWdodCk7Ci0JCXRyeSB7Ci0JCQlFbXB0eUxpc3RJdGVyYXRvci5pbnN0YW5jZSgpLmFkZChuZXcgT2JqZWN0KCkpOwotCQl9IGNhdGNoIChVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIlVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIG5vdCB0aHJvd24gKGFkZCkiLCBleENhdWdodCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9FbnVtZXJhdGlvbkl0ZXJhdG9yVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL0VudW1lcmF0aW9uSXRlcmF0b3JUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1MjhmMTAxLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL0VudW1lcmF0aW9uSXRlcmF0b3JUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTE5ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkVudW1lcmF0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTm9TdWNoRWxlbWVudEV4Y2VwdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuVmVjdG9yOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuRW51bWVyYXRpb25JdGVyYXRvcjsKLQotcHVibGljIGNsYXNzIEVudW1lcmF0aW9uSXRlcmF0b3JUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBFbnVtZXJhdGlvbkl0ZXJhdG9yVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc05leHQoKSB7Ci0JCWludCBpID0gMDsKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHModGhpcy5idWlsZFZlY3RvcigpLnNpemUoKSwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc05leHRVcGNhc3QoKSB7Ci0JCWludCBpID0gMDsKLQkJZm9yIChJdGVyYXRvcjxPYmplY3Q+IHN0cmVhbSA9IHRoaXMuYnVpbGRJdGVyYXRvclVwY2FzdCgpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHModGhpcy5idWlsZFZlY3RvcigpLnNpemUoKSwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5leHQoKSB7Ci0JCUVudW1lcmF0aW9uPFN0cmluZz4gZW51bWVyYXRpb24gPSB0aGlzLmJ1aWxkRW51bWVyYXRpb24oKTsKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyBlbGVtZW50IiwgZW51bWVyYXRpb24ubmV4dEVsZW1lbnQoKSwgc3RyZWFtLm5leHQoKSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TmV4dFVwY2FzdCgpIHsKLQkJRW51bWVyYXRpb248U3RyaW5nPiBlbnVtZXJhdGlvbiA9IHRoaXMuYnVpbGRFbnVtZXJhdGlvbigpOwotCQlmb3IgKEl0ZXJhdG9yPE9iamVjdD4gc3RyZWFtID0gdGhpcy5idWlsZEl0ZXJhdG9yVXBjYXN0KCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlhc3NlcnRFcXVhbHMoImJvZ3VzIGVsZW1lbnQiLCBlbnVtZXJhdGlvbi5uZXh0RWxlbWVudCgpLCBzdHJlYW0ubmV4dCgpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROb1N1Y2hFbGVtZW50RXhjZXB0aW9uKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZEl0ZXJhdG9yKCk7Ci0JCVN0cmluZyBzdHJpbmcgPSBudWxsOwotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJc3RyaW5nID0gc3RyZWFtLm5leHQoKTsKLQkJfQotCQl0cnkgewotCQkJc3RyaW5nID0gc3RyZWFtLm5leHQoKTsKLQkJfSBjYXRjaCAoTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIk5vU3VjaEVsZW1lbnRFeGNlcHRpb24gbm90IHRocm93bjogIiArIHN0cmluZywgZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlmb3IgKEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZEl0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlpZiAoc3RyZWFtLm5leHQoKS5lcXVhbHMoInRocmVlIikpIHsKLQkJCQl0cnkgewotCQkJCQlzdHJlYW0ucmVtb3ZlKCk7Ci0JCQkJfSBjYXRjaCAoVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gZXgpIHsKLQkJCQkJZXhDYXVnaHQgPSB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfQotCQlhc3NlcnRUcnVlKCJVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBub3QgdGhyb3duIiwgZXhDYXVnaHQpOwotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8U3RyaW5nPiBidWlsZEl0ZXJhdG9yKCkgewotCQlyZXR1cm4gdGhpcy5idWlsZEl0ZXJhdG9yKHRoaXMuYnVpbGRFbnVtZXJhdGlvbigpKTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRJdGVyYXRvcihFbnVtZXJhdGlvbjxTdHJpbmc+IGVudW1lcmF0aW9uKSB7Ci0JCXJldHVybiBuZXcgRW51bWVyYXRpb25JdGVyYXRvcjxTdHJpbmc+KGVudW1lcmF0aW9uKTsKLQl9Ci0KLQlwcml2YXRlIEVudW1lcmF0aW9uPFN0cmluZz4gYnVpbGRFbnVtZXJhdGlvbigpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRWZWN0b3IoKS5lbGVtZW50cygpOwotCX0KLQotCXByaXZhdGUgVmVjdG9yPFN0cmluZz4gYnVpbGRWZWN0b3IoKSB7Ci0JCVZlY3RvcjxTdHJpbmc+IHYgPSBuZXcgVmVjdG9yPFN0cmluZz4oKTsKLQkJdi5hZGRFbGVtZW50KCJvbmUiKTsKLQkJdi5hZGRFbGVtZW50KCJ0d28iKTsKLQkJdi5hZGRFbGVtZW50KCJ0aHJlZSIpOwotCQl2LmFkZEVsZW1lbnQoImZvdXIiKTsKLQkJdi5hZGRFbGVtZW50KCJmaXZlIik7Ci0JCXYuYWRkRWxlbWVudCgic2l4Iik7Ci0JCXYuYWRkRWxlbWVudCgic2V2ZW4iKTsKLQkJdi5hZGRFbGVtZW50KCJlaWdodCIpOwotCQlyZXR1cm4gdjsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPE9iamVjdD4gYnVpbGRJdGVyYXRvclVwY2FzdCgpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRJdGVyYXRvclVwY2FzdCh0aGlzLmJ1aWxkRW51bWVyYXRpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxPYmplY3Q+IGJ1aWxkSXRlcmF0b3JVcGNhc3QoRW51bWVyYXRpb248U3RyaW5nPiBlbnVtZXJhdGlvbikgewotCQlyZXR1cm4gbmV3IEVudW1lcmF0aW9uSXRlcmF0b3I8T2JqZWN0PihlbnVtZXJhdGlvbik7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9GaWx0ZXJpbmdJdGVyYXRvclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9GaWx0ZXJpbmdJdGVyYXRvclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGM4ODA1YzkuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvRmlsdGVyaW5nSXRlcmF0b3JUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjk4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LkZpbHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU2ltcGxlRmlsdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5GaWx0ZXJpbmdJdGVyYXRvcjsKLQotcHVibGljIGNsYXNzIEZpbHRlcmluZ0l0ZXJhdG9yVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgUFJFRklYID0gInByZWZpeCI7Ci0KLQlwdWJsaWMgRmlsdGVyaW5nSXRlcmF0b3JUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRBY2NlcHRJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJU3RyaW5nIHN0cmluZyA9IHN0cmVhbS5uZXh0KCk7Ci0JCQlpZiAoc3RyaW5nLmVxdWFscyhQUkVGSVggKyAiMyIpKSB7Ci0JCQkJdHJ5IHsKLQkJCQkJc3RyZWFtLnJlbW92ZSgpOwotCQkJCX0gY2F0Y2ggKFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIGV4KSB7Ci0JCQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Tm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRBY2NlcHRJdGVyYXRvcigpOwotCQlTdHJpbmcgc3RyaW5nID0gbnVsbDsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCXN0cmluZyA9IHN0cmVhbS5uZXh0KCk7Ci0JCX0KLQkJdHJ5IHsKLQkJCXN0cmluZyA9IHN0cmVhbS5uZXh0KCk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIG5vdCB0aHJvd246ICIgKyBzdHJpbmcsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWNjZXB0SGFzTmV4dCgpIHsKLQkJaW50IGkgPSAwOwotCQlmb3IgKEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZEFjY2VwdEl0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyg2LCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWNjZXB0TmV4dCgpIHsKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRBY2NlcHRJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJYXNzZXJ0VHJ1ZSgiYm9ndXMgYWNjZXB0Iiwgc3RyZWFtLm5leHQoKS5zdGFydHNXaXRoKFBSRUZJWCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdElubmVySGFzTmV4dCgpIHsKLQkJaW50IGkgPSAwOwotCQlmb3IgKEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZElubmVySXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCXN0cmVhbS5uZXh0KCk7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDYsIGkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbm5lck5leHQoKSB7Ci0JCWZvciAoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkSW5uZXJJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJYXNzZXJ0VHJ1ZSgiYm9ndXMgYWNjZXB0Iiwgc3RyZWFtLm5leHQoKS5zdGFydHNXaXRoKFBSRUZJWCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlamVjdEhhc05leHQoKSB7Ci0JCWludCBpID0gMDsKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRSZWplY3RJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHMoMiwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlamVjdE5leHQoKSB7Ci0JCWZvciAoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkUmVqZWN0SXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCWFzc2VydEZhbHNlKCJib2d1cyByZWplY3QiLCBzdHJlYW0ubmV4dCgpLnN0YXJ0c1dpdGgoUFJFRklYKSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Qm90aEhhc05leHQoKSB7Ci0JCS8vIGlmIGJvdGggYWNjZXB0KCkgYW5kIHJlamVjdCgpIGFyZSBvdmVycmlkZGVuLCBhY2NlcHQoKSBpcyB1c2VkCi0JCWludCBpID0gMDsKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRCb3RoSXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCXN0cmVhbS5uZXh0KCk7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDYsIGkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMb2FkTmV4dCgpIHsKLQkJLy8gbG9hZE5leHQoKSB1c2VkIHRvIGNhdXNlIGEgTlBFIHdoZW4gZXhlY3V0aW5nIGR1cmluZyB0aGUKLQkJLy8gY29uc3RydWN0b3IgYmVjYXVzZSB0aGUgIm91dGVyIiBjbGFzcyBpcyBub3QgYm91bmQgdW50aWwgY29tcGxldGlvbgotCQkvLyBvZiB0aGUgY29uc3RydWN0b3IKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRJbm5lckl0ZXJhdG9yMigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJYXNzZXJ0VHJ1ZSgiYm9ndXMgYWNjZXB0Iiwgc3RyZWFtLm5leHQoKS5zdGFydHNXaXRoKFBSRUZJWCkpOwotCQl9Ci0JfQotCi0JLy8gdGVzdCBhIGZpbHRlcmVkIGl0ZXJhdG9yIHdpdGggYSBuZXN0ZWQgaXRlcmF0b3Igb2YgYSBzdWItdHlwZSAoTnVtYmVyIHZzLiBJbnRlZ2VyKQotCXB1YmxpYyB2b2lkIHRlc3RHZW5lcmljczEoKSB7Ci0JCUxpc3Q8SW50ZWdlcj4gaW50ZWdlcnMgPSBuZXcgQXJyYXlMaXN0PEludGVnZXI+KCk7Ci0JCWludGVnZXJzLmFkZChuZXcgSW50ZWdlcigwKSk7Ci0JCWludGVnZXJzLmFkZChuZXcgSW50ZWdlcigxKSk7Ci0JCWludGVnZXJzLmFkZChuZXcgSW50ZWdlcigyKSk7Ci0JCWludGVnZXJzLmFkZChuZXcgSW50ZWdlcigzKSk7Ci0JCUl0ZXJhdG9yPE51bWJlcj4gc3RyZWFtID0gbmV3IEZpbHRlcmluZ0l0ZXJhdG9yPEludGVnZXIsIE51bWJlcj4oaW50ZWdlcnMuaXRlcmF0b3IoKSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgYm9vbGVhbiBhY2NlcHQoSW50ZWdlciBvKSB7Ci0JCQkJcmV0dXJuIG8uaW50VmFsdWUoKSA+IDE7Ci0JCQl9Ci0JCX07Ci0JCWFzc2VydEVxdWFscygyLCBDb2xsZWN0aW9uVG9vbHMuc2l6ZShzdHJlYW0pKTsKLQl9Ci0KLQkvLyB0ZXN0IGEgZmlsdGVyZWQgaXRlcmF0b3Igd2l0aCBhIG5lc3RlZCBpdGVyYXRvciBvZiBhIHN1cGVyLXR5cGUgKEludGVnZXIgdnMuIE51bWJlcikKLQkvLyBpLmUuIHRydXN0IHRoYXQgRmlsdGVyIHdpbGwgb25seSByZXR1cm4gdGhlIGFwcHJvcHJpYXRlIHN1Yi10eXBlIG9iamVjdHMKLQlwdWJsaWMgdm9pZCB0ZXN0R2VuZXJpY3MyKCkgewotCQlMaXN0PE51bWJlcj4gbnVtYmVycyA9IG5ldyBBcnJheUxpc3Q8TnVtYmVyPigpOwotCQludW1iZXJzLmFkZChuZXcgSW50ZWdlcigwKSk7Ci0JCW51bWJlcnMuYWRkKG5ldyBMb25nKDEpKTsKLQkJbnVtYmVycy5hZGQobmV3IEludGVnZXIoMikpOwotCQludW1iZXJzLmFkZChuZXcgRmxvYXQoMykpOwotCQlJdGVyYXRvcjxJbnRlZ2VyPiBzdHJlYW0gPSBuZXcgRmlsdGVyaW5nSXRlcmF0b3I8TnVtYmVyLCBJbnRlZ2VyPihudW1iZXJzLml0ZXJhdG9yKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGJvb2xlYW4gYWNjZXB0KE51bWJlciBvKSB7Ci0JCQkJcmV0dXJuIG8gaW5zdGFuY2VvZiBJbnRlZ2VyOwotCQkJfQotCQl9OwotCQlhc3NlcnRFcXVhbHMoMiwgQ29sbGVjdGlvblRvb2xzLnNpemUoc3RyZWFtKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEZpbHRlckhhc05leHQoKSB7Ci0JCWludCBpID0gMDsKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRGaWx0ZXJJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHMoNiwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEZpbHRlck5leHQoKSB7Ci0JCWZvciAoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkRmlsdGVySXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCWFzc2VydFRydWUoImJvZ3VzIGFjY2VwdCIsIHN0cmVhbS5uZXh0KCkuc3RhcnRzV2l0aChQUkVGSVgpKTsKLQkJfQotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8U3RyaW5nPiBidWlsZEZpbHRlcmVkSXRlcmF0b3IoSXRlcmF0b3I8U3RyaW5nPiBuZXN0ZWRJdGVyYXRvciwgRmlsdGVyPFN0cmluZz4gZmlsdGVyKSB7Ci0JCXJldHVybiBuZXcgRmlsdGVyaW5nSXRlcmF0b3I8U3RyaW5nLCBTdHJpbmc+KG5lc3RlZEl0ZXJhdG9yLCBmaWx0ZXIpOwotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8U3RyaW5nPiBidWlsZElubmVyRmlsdGVyZWRJdGVyYXRvcihJdGVyYXRvcjxTdHJpbmc+IG5lc3RlZEl0ZXJhdG9yKSB7Ci0JCXJldHVybiBuZXcgRmlsdGVyaW5nSXRlcmF0b3I8U3RyaW5nLCBTdHJpbmc+KG5lc3RlZEl0ZXJhdG9yKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBib29sZWFuIGFjY2VwdChTdHJpbmcgcykgewotCQkJCXJldHVybiBzLnN0YXJ0c1dpdGgoUFJFRklYKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlTdHJpbmcgZ2V0UHJlZml4KCkgewotCQlyZXR1cm4gUFJFRklYOwotCX0KLQotCS8vIHRoaXMgaW5uZXIgaXRlcmF0b3Igd2lsbCBjYWxsIHRoZSAib3V0ZXIiIG9iamVjdAotCXByaXZhdGUgSXRlcmF0b3I8U3RyaW5nPiBidWlsZElubmVyRmlsdGVyZWRJdGVyYXRvcjIoSXRlcmF0b3I8U3RyaW5nPiBuZXN0ZWRJdGVyYXRvcikgewotCQlyZXR1cm4gbmV3IEZpbHRlcmluZ0l0ZXJhdG9yPFN0cmluZywgU3RyaW5nPihuZXN0ZWRJdGVyYXRvcikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgYm9vbGVhbiBhY2NlcHQoU3RyaW5nIHMpIHsKLQkJCQlyZXR1cm4gcy5zdGFydHNXaXRoKEZpbHRlcmluZ0l0ZXJhdG9yVGVzdHMudGhpcy5nZXRQcmVmaXgoKSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkTmVzdGVkSXRlcmF0b3IoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWMuYWRkKFBSRUZJWCArICIxIik7Ci0JCWMuYWRkKFBSRUZJWCArICIyIik7Ci0JCWMuYWRkKFBSRUZJWCArICIzIik7Ci0JCWMuYWRkKCI0Iik7Ci0JCWMuYWRkKFBSRUZJWCArICI1Iik7Ci0JCWMuYWRkKFBSRUZJWCArICI2Iik7Ci0JCWMuYWRkKFBSRUZJWCArICI3Iik7Ci0JCWMuYWRkKCI4Iik7Ci0JCXJldHVybiBjLml0ZXJhdG9yKCk7Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkQWNjZXB0SXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkRmlsdGVyZWRJdGVyYXRvcih0aGlzLmJ1aWxkTmVzdGVkSXRlcmF0b3IoKSwgdGhpcy5idWlsZEFjY2VwdEZpbHRlcihQUkVGSVgpKTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRJbm5lckl0ZXJhdG9yKCkgewotCQlyZXR1cm4gdGhpcy5idWlsZElubmVyRmlsdGVyZWRJdGVyYXRvcih0aGlzLmJ1aWxkTmVzdGVkSXRlcmF0b3IoKSk7Ci0JfQotCi0JLy8gdGhpcyBpbm5lciBpdGVyYXRvciB3aWxsIGNhbGwgdGhlICJvdXRlciIgb2JqZWN0Ci0JcHJpdmF0ZSBJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkSW5uZXJJdGVyYXRvcjIoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkSW5uZXJGaWx0ZXJlZEl0ZXJhdG9yMih0aGlzLmJ1aWxkTmVzdGVkSXRlcmF0b3IoKSk7Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkRmlsdGVySXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkRmlsdGVyZWRJdGVyYXRvcih0aGlzLmJ1aWxkTmVzdGVkSXRlcmF0b3IoKSwgdGhpcy5idWlsZEZpbHRlckZpbHRlcihQUkVGSVgpKTsKLQl9Ci0KLQlwcml2YXRlIEZpbHRlcjxTdHJpbmc+IGJ1aWxkQWNjZXB0RmlsdGVyKFN0cmluZyBwcmVmaXgpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVGaWx0ZXI8U3RyaW5nLCBTdHJpbmc+KHByZWZpeCkgewotCQkJcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIGJvb2xlYW4gYWNjZXB0KFN0cmluZyBzKSB7Ci0JCQkJcmV0dXJuIHMuc3RhcnRzV2l0aCh0aGlzLmNyaXRlcmlvbik7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkUmVqZWN0SXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkRmlsdGVyZWRJdGVyYXRvcih0aGlzLmJ1aWxkTmVzdGVkSXRlcmF0b3IoKSwgdGhpcy5idWlsZFJlamVjdEZpbHRlcihQUkVGSVgpKTsKLQl9Ci0KLQlwcml2YXRlIEZpbHRlcjxTdHJpbmc+IGJ1aWxkUmVqZWN0RmlsdGVyKFN0cmluZyBwcmVmaXgpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVGaWx0ZXI8U3RyaW5nLCBTdHJpbmc+KHByZWZpeCkgewotCQkJcHJpdmF0ZSBzdGF0aWMgZmluYWwgbG9uZyBzZXJpYWxWZXJzaW9uVUlEID0gMUw7Ci0KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIGJvb2xlYW4gcmVqZWN0KFN0cmluZyBzKSB7Ci0JCQkJcmV0dXJuIHMuc3RhcnRzV2l0aCh0aGlzLmNyaXRlcmlvbik7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JLy8gdXNlIGFub255bW91cyBpbm5lciBGaWx0ZXIKLQlwcml2YXRlIEZpbHRlcjxTdHJpbmc+IGJ1aWxkRmlsdGVyRmlsdGVyKGZpbmFsIFN0cmluZyBwcmVmaXgpIHsKLQkJcmV0dXJuIG5ldyBGaWx0ZXI8U3RyaW5nPigpIHsKLQkJCXB1YmxpYyBib29sZWFuIGFjY2VwdChTdHJpbmcgcykgewotCQkJCXJldHVybiBzLnN0YXJ0c1dpdGgocHJlZml4KTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRCb3RoSXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkRmlsdGVyZWRJdGVyYXRvcih0aGlzLmJ1aWxkTmVzdGVkSXRlcmF0b3IoKSwgdGhpcy5idWlsZEJvdGhGaWx0ZXIoUFJFRklYKSk7Ci0JfQotCi0JcHJpdmF0ZSBGaWx0ZXI8U3RyaW5nPiBidWlsZEJvdGhGaWx0ZXIoU3RyaW5nIHByZWZpeCkgewotCQlyZXR1cm4gbmV3IFNpbXBsZUZpbHRlcjxTdHJpbmcsIFN0cmluZz4ocHJlZml4KSB7Ci0JCQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgYm9vbGVhbiByZWplY3QoU3RyaW5nIHMpIHsKLQkJCQlyZXR1cm4gcy5zdGFydHNXaXRoKHRoaXMuY3JpdGVyaW9uKTsKLQkJCX0KLQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgYm9vbGVhbiBhY2NlcHQoU3RyaW5nIHMpIHsKLQkJCQlyZXR1cm4gcy5zdGFydHNXaXRoKHRoaXMuY3JpdGVyaW9uKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZEZpbHRlcmluZ0l0ZXJhdG9yKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQkvLyBtaXNzaW5nIG1ldGhvZCBvdmVycmlkZQotCQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IG5ldyBGaWx0ZXJpbmdJdGVyYXRvcjxTdHJpbmcsIFN0cmluZz4odGhpcy5idWlsZE5lc3RlZEl0ZXJhdG9yKCkpOwotCQkJU3RyaW5nIHMgPSBpdGVyYXRvci5uZXh0KCk7Ci0JCQlmYWlsKCJpbnZhbGlkIHN0cmluZzogIiArIHMpOwotCQl9IGNhdGNoIChVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIk5vU3VjaEVsZW1lbnRFeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL0dyYXBoSXRlcmF0b3JUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvR3JhcGhJdGVyYXRvclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDRlNGM4MGQuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvR3JhcGhJdGVyYXRvclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxOTcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTm9TdWNoRWxlbWVudEV4Y2VwdGlvbjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5HcmFwaEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgY2xhc3MgR3JhcGhJdGVyYXRvclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCS8qKiB0aGlzIHdpbGwgYmUgcG9wdWxhdGVkIHdpdGggYWxsIHRoZSBub2RlcyBjcmVhdGVkIGZvciB0aGUgdGVzdCAqLwotCUNvbGxlY3Rpb248R3JhcGhOb2RlPiBub2RlcyA9IG5ldyBBcnJheUxpc3Q8R3JhcGhOb2RlPigpOwotCi0JcHVibGljIEdyYXBoSXRlcmF0b3JUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc05leHQxKCkgewotCQl0aGlzLnZlcmlmeUhhc05leHQodGhpcy5idWlsZEdyYXBoSXRlcmF0b3IxKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNOZXh0MigpIHsKLQkJdGhpcy52ZXJpZnlIYXNOZXh0KHRoaXMuYnVpbGRHcmFwaEl0ZXJhdG9yMigpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5SGFzTmV4dChJdGVyYXRvcjxHcmFwaE5vZGU+IGl0ZXJhdG9yKSB7Ci0JCWludCBpID0gMDsKLQkJd2hpbGUgKGl0ZXJhdG9yLmhhc05leHQoKSkgewotCQkJaXRlcmF0b3IubmV4dCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyh0aGlzLm5vZGVzLnNpemUoKSwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5leHQxKCkgewotCQl0aGlzLnZlcmlmeU5leHQodGhpcy5idWlsZEdyYXBoSXRlcmF0b3IxKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROZXh0MigpIHsKLQkJdGhpcy52ZXJpZnlOZXh0KHRoaXMuYnVpbGRHcmFwaEl0ZXJhdG9yMigpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5TmV4dChJdGVyYXRvcjxHcmFwaE5vZGU+IGl0ZXJhdG9yKSB7Ci0JCXdoaWxlIChpdGVyYXRvci5oYXNOZXh0KCkpIHsKLQkJCWFzc2VydFRydWUoImJvZ3VzIGVsZW1lbnQiLCB0aGlzLm5vZGVzLmNvbnRhaW5zKGl0ZXJhdG9yLm5leHQoKSkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5vU3VjaEVsZW1lbnRFeGNlcHRpb24xKCkgewotCQl0aGlzLnZlcmlmeU5vU3VjaEVsZW1lbnRFeGNlcHRpb24odGhpcy5idWlsZEdyYXBoSXRlcmF0b3IxKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROb1N1Y2hFbGVtZW50RXhjZXB0aW9uMigpIHsKLQkJdGhpcy52ZXJpZnlOb1N1Y2hFbGVtZW50RXhjZXB0aW9uKHRoaXMuYnVpbGRHcmFwaEl0ZXJhdG9yMigpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5Tm9TdWNoRWxlbWVudEV4Y2VwdGlvbihJdGVyYXRvcjxHcmFwaE5vZGU+IGl0ZXJhdG9yKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJd2hpbGUgKGl0ZXJhdG9yLmhhc05leHQoKSkgewotCQkJaXRlcmF0b3IubmV4dCgpOwotCQl9Ci0JCXRyeSB7Ci0JCQlpdGVyYXRvci5uZXh0KCk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNpemUxKCkgewotCQl0aGlzLnZlcmlmeVNpemUodGhpcy5idWlsZEdyYXBoSXRlcmF0b3IxKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTaXplMigpIHsKLQkJdGhpcy52ZXJpZnlTaXplKHRoaXMuYnVpbGRHcmFwaEl0ZXJhdG9yMigpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5U2l6ZShJdGVyYXRvcjxHcmFwaE5vZGU+IGl0ZXJhdG9yKSB7Ci0JCWludCBpdGVyYXRvclNpemUgPSBDb2xsZWN0aW9uVG9vbHMuc2l6ZShpdGVyYXRvcik7Ci0JCWludCBhY3R1YWxTaXplID0gdGhpcy5ub2Rlcy5zaXplKCk7Ci0JCWFzc2VydFRydWUoIlRvbyBmZXcgaXRlbXMgaW4gaXRlcmF0b3IuIiwgaXRlcmF0b3JTaXplID49IGFjdHVhbFNpemUpOwotCQlhc3NlcnRUcnVlKCJUb28gbWFueSBpdGVtcyBpbiBpdGVyYXRvci4iLCBpdGVyYXRvclNpemUgPD0gYWN0dWFsU2l6ZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEludmFsaWRHcmFwaEl0ZXJhdG9yKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQkvLyBtaXNzaW5nIG1ldGhvZCBvdmVycmlkZQotCQkJSXRlcmF0b3I8R3JhcGhOb2RlPiBpdGVyYXRvciA9IG5ldyBHcmFwaEl0ZXJhdG9yPEdyYXBoTm9kZT4odGhpcy5idWlsZEdyYXBoUm9vdCgpKTsKLQkJCUdyYXBoTm9kZSBnbiA9IGl0ZXJhdG9yLm5leHQoKTsKLQkJCWZhaWwoImludmFsaWQgZ3JhcGggbm9kZTogIiArIGduKTsKLQkJfSBjYXRjaCAoVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCi0JLyoqCi0JICogYnVpbGQgYSBncmFwaCBpdGVyYXRvciB3aXRoIGFuIGV4cGxpY2l0IG1pc3RlclJvZ2VycwotCSAqLwotCXByaXZhdGUgSXRlcmF0b3I8R3JhcGhOb2RlPiBidWlsZEdyYXBoSXRlcmF0b3IxKCkgewotCQlyZXR1cm4gbmV3IEdyYXBoSXRlcmF0b3I8R3JhcGhOb2RlPih0aGlzLmJ1aWxkR3JhcGhSb290KCksIHRoaXMuYnVpbGRNaXN0ZXJSb2dlcnMoKSk7Ci0JfQotCi0JcHJpdmF0ZSBHcmFwaEl0ZXJhdG9yLk1pc3RlclJvZ2VyczxHcmFwaE5vZGU+IGJ1aWxkTWlzdGVyUm9nZXJzKCkgewotCQlyZXR1cm4gbmV3IEdyYXBoSXRlcmF0b3IuTWlzdGVyUm9nZXJzPEdyYXBoTm9kZT4oKSB7Ci0JCQlwdWJsaWMgSXRlcmF0b3I8R3JhcGhOb2RlPiBuZWlnaGJvcnMoR3JhcGhOb2RlIG5leHQpIHsKLQkJCQlyZXR1cm4gbmV4dC5uZWlnaGJvcnMoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQkvKioKLQkgKiBidWlsZCBhIGdyYXBoIGl0ZXJhdG9yIHdpdGggYW4gb3ZlcnJpZGUKLQkgKi8KLQlwcml2YXRlIEl0ZXJhdG9yPEdyYXBoTm9kZT4gYnVpbGRHcmFwaEl0ZXJhdG9yMigpIHsKLQkJcmV0dXJuIG5ldyBHcmFwaEl0ZXJhdG9yPEdyYXBoTm9kZT4odGhpcy5idWlsZEdyYXBoUm9vdCgpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBJdGVyYXRvcjxHcmFwaE5vZGU+IG5laWdoYm9ycyhHcmFwaE5vZGUgbmV4dCkgewotCQkJCXJldHVybiBuZXh0Lm5laWdoYm9ycygpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgR3JhcGhOb2RlIGJ1aWxkR3JhcGhSb290KCkgewotCQlHcmFwaE5vZGUgbmNOb2RlID0gbmV3IEdyYXBoTm9kZSgiTm9ydGggQ2Fyb2xpbmEiKTsKLQkJR3JhcGhOb2RlIHZhTm9kZSA9IG5ldyBHcmFwaE5vZGUoIlZpcmdpbmlhIik7Ci0JCUdyYXBoTm9kZSBzY05vZGUgPSBuZXcgR3JhcGhOb2RlKCJTb3V0aCBDYXJvbGluYSIpOwotCQlHcmFwaE5vZGUgZ2FOb2RlID0gbmV3IEdyYXBoTm9kZSgiR2VvcmdpYSIpOwotCQlHcmFwaE5vZGUgZmxOb2RlID0gbmV3IEdyYXBoTm9kZSgiRmxvcmlkYSIpOwotCQlHcmFwaE5vZGUgYWxOb2RlID0gbmV3IEdyYXBoTm9kZSgiQWxhYmFtYSIpOwotCQlHcmFwaE5vZGUgbXNOb2RlID0gbmV3IEdyYXBoTm9kZSgiTWlzc2lzc2lwcGkiKTsKLQkJR3JhcGhOb2RlIHRuTm9kZSA9IG5ldyBHcmFwaE5vZGUoIlRlbm5lc3NlZSIpOwotCi0JCW5jTm9kZS5zZXROZWlnaGJvcnMobmV3IEdyYXBoTm9kZVtdIHsgdmFOb2RlLCBzY05vZGUsIGdhTm9kZSwgdG5Ob2RlIH0pOwotCQl2YU5vZGUuc2V0TmVpZ2hib3JzKG5ldyBHcmFwaE5vZGVbXSB7IG5jTm9kZSwgdG5Ob2RlIH0pOwotCQlzY05vZGUuc2V0TmVpZ2hib3JzKG5ldyBHcmFwaE5vZGVbXSB7IG5jTm9kZSwgZ2FOb2RlIH0pOwotCQlnYU5vZGUuc2V0TmVpZ2hib3JzKG5ldyBHcmFwaE5vZGVbXSB7IG5jTm9kZSwgc2NOb2RlLCBmbE5vZGUsIGFsTm9kZSwgdG5Ob2RlIH0pOwotCQlmbE5vZGUuc2V0TmVpZ2hib3JzKG5ldyBHcmFwaE5vZGVbXSB7IGdhTm9kZSB9KTsKLQkJYWxOb2RlLnNldE5laWdoYm9ycyhuZXcgR3JhcGhOb2RlW10geyBnYU5vZGUsIG1zTm9kZSwgdG5Ob2RlIH0pOwotCQltc05vZGUuc2V0TmVpZ2hib3JzKG5ldyBHcmFwaE5vZGVbXSB7IGFsTm9kZSwgdG5Ob2RlIH0pOwotCQl0bk5vZGUuc2V0TmVpZ2hib3JzKG5ldyBHcmFwaE5vZGVbXSB7IHZhTm9kZSwgbmNOb2RlLCBnYU5vZGUsIGFsTm9kZSwgbXNOb2RlIH0pOwotCi0JCXJldHVybiBuY05vZGU7Ci0JfQotCi0JcHJpdmF0ZSBjbGFzcyBHcmFwaE5vZGUgewotCQlwcml2YXRlIFN0cmluZyBuYW1lOwotCi0JCXByaXZhdGUgQ29sbGVjdGlvbjxHcmFwaE5vZGU+IG5laWdoYm9ycyA9IG5ldyBBcnJheUxpc3Q8R3JhcGhOb2RlPigpOwotCi0JCXB1YmxpYyBHcmFwaE5vZGUoU3RyaW5nIG5hbWUpIHsKLQkJCXN1cGVyKCk7Ci0JCQlHcmFwaEl0ZXJhdG9yVGVzdHMudGhpcy5ub2Rlcy5hZGQodGhpcyk7IC8vIGxvZyBub2RlCi0JCQl0aGlzLm5hbWUgPSBuYW1lOwotCQl9Ci0KLQkJcHVibGljIFN0cmluZyBnZXROYW1lKCkgewotCQkJcmV0dXJuIHRoaXMubmFtZTsKLQkJfQotCi0JCXZvaWQgc2V0TmVpZ2hib3JzKEdyYXBoTm9kZVtdIG5laWdoYm9ycykgewotCQkJdGhpcy5uZWlnaGJvcnMgPSBDb2xsZWN0aW9uVG9vbHMubGlzdChuZWlnaGJvcnMpOwotCQl9Ci0KLQkJcHVibGljIEl0ZXJhdG9yPEdyYXBoTm9kZT4gbmVpZ2hib3JzKCkgewotCQkJcmV0dXJuIHRoaXMubmVpZ2hib3JzLml0ZXJhdG9yKCk7Ci0JCX0KLQotCQlwdWJsaWMgaW50IG5laWdoYm9yc1NpemUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5uZWlnaGJvcnMuc2l6ZSgpOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gIkdyYXBoTm9kZSgiICsgdGhpcy5uYW1lICsgIikiOwotCQl9Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvSXRlcmF0b3JFbnVtZXJhdGlvblRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9JdGVyYXRvckVudW1lcmF0aW9uVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDJkOGViNC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9JdGVyYXRvckVudW1lcmF0aW9uVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDk4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkVudW1lcmF0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTm9TdWNoRWxlbWVudEV4Y2VwdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuVmVjdG9yOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuSXRlcmF0b3JFbnVtZXJhdGlvbjsKLQotcHVibGljIGNsYXNzIEl0ZXJhdG9yRW51bWVyYXRpb25UZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBJdGVyYXRvckVudW1lcmF0aW9uVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc01vcmVFbGVtZW50cygpIHsKLQkJaW50IGkgPSAwOwotCQlmb3IgKEVudW1lcmF0aW9uPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZEVudW1lcmF0aW9uKCk7IHN0cmVhbS5oYXNNb3JlRWxlbWVudHMoKTspIHsKLQkJCXN0cmVhbS5uZXh0RWxlbWVudCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkVmVjdG9yKCkuc2l6ZSgpLCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTW9yZUVsZW1lbnRzVXBjYXN0KCkgewotCQlpbnQgaSA9IDA7Ci0JCWZvciAoRW51bWVyYXRpb248T2JqZWN0PiBzdHJlYW0gPSB0aGlzLmJ1aWxkRW51bWVyYXRpb25VcGNhc3QoKTsgc3RyZWFtLmhhc01vcmVFbGVtZW50cygpOykgewotCQkJc3RyZWFtLm5leHRFbGVtZW50KCk7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRWZWN0b3IoKS5zaXplKCksIGkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROZXh0RWxlbWVudCgpIHsKLQkJSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvciA9IHRoaXMuYnVpbGRJdGVyYXRvcigpOwotCQlmb3IgKEVudW1lcmF0aW9uPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZEVudW1lcmF0aW9uKCk7IHN0cmVhbS5oYXNNb3JlRWxlbWVudHMoKTspIHsKLQkJCWFzc2VydEVxdWFscygiYm9ndXMgZWxlbWVudCIsIGl0ZXJhdG9yLm5leHQoKSwgc3RyZWFtLm5leHRFbGVtZW50KCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5vU3VjaEVsZW1lbnRFeGNlcHRpb24oKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJRW51bWVyYXRpb248U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkRW51bWVyYXRpb24oKTsKLQkJU3RyaW5nIHN0cmluZyA9IG51bGw7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTW9yZUVsZW1lbnRzKCkpIHsKLQkJCXN0cmluZyA9IHN0cmVhbS5uZXh0RWxlbWVudCgpOwotCQl9Ci0JCXRyeSB7Ci0JCQlzdHJpbmcgPSBzdHJlYW0ubmV4dEVsZW1lbnQoKTsKLQkJfSBjYXRjaCAoTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIk5vU3VjaEVsZW1lbnRFeGNlcHRpb24gbm90IHRocm93bjogIiArIHN0cmluZywgZXhDYXVnaHQpOwotCX0KLQotCXByaXZhdGUgRW51bWVyYXRpb248U3RyaW5nPiBidWlsZEVudW1lcmF0aW9uKCkgewotCQlyZXR1cm4gdGhpcy5idWlsZEVudW1lcmF0aW9uKHRoaXMuYnVpbGRJdGVyYXRvcigpKTsKLQl9Ci0KLQlwcml2YXRlIEVudW1lcmF0aW9uPE9iamVjdD4gYnVpbGRFbnVtZXJhdGlvblVwY2FzdCgpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRFbnVtZXJhdGlvblVwY2FzdCh0aGlzLmJ1aWxkSXRlcmF0b3IoKSk7Ci0JfQotCi0JcHJpdmF0ZSBFbnVtZXJhdGlvbjxTdHJpbmc+IGJ1aWxkRW51bWVyYXRpb24oSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvcikgewotCQlyZXR1cm4gbmV3IEl0ZXJhdG9yRW51bWVyYXRpb248U3RyaW5nPihpdGVyYXRvcik7Ci0JfQotCi0JcHJpdmF0ZSBFbnVtZXJhdGlvbjxPYmplY3Q+IGJ1aWxkRW51bWVyYXRpb25VcGNhc3QoSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvcikgewotCQlyZXR1cm4gbmV3IEl0ZXJhdG9yRW51bWVyYXRpb248T2JqZWN0PihpdGVyYXRvcik7Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkSXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkVmVjdG9yKCkuaXRlcmF0b3IoKTsKLQl9Ci0KLQlwcml2YXRlIFZlY3RvcjxTdHJpbmc+IGJ1aWxkVmVjdG9yKCkgewotCQlWZWN0b3I8U3RyaW5nPiB2ID0gbmV3IFZlY3RvcjxTdHJpbmc+KCk7Ci0JCXYuYWRkRWxlbWVudCgib25lIik7Ci0JCXYuYWRkRWxlbWVudCgidHdvIik7Ci0JCXYuYWRkRWxlbWVudCgidGhyZWUiKTsKLQkJdi5hZGRFbGVtZW50KCJmb3VyIik7Ci0JCXYuYWRkRWxlbWVudCgiZml2ZSIpOwotCQl2LmFkZEVsZW1lbnQoInNpeCIpOwotCQl2LmFkZEVsZW1lbnQoInNldmVuIik7Ci0JCXYuYWRkRWxlbWVudCgiZWlnaHQiKTsKLQkJcmV0dXJuIHY7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9KcHRVdGlsaXR5SXRlcmF0b3JzVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL0pwdFV0aWxpdHlJdGVyYXRvcnNUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4ZDlkM2Y3Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL0pwdFV0aWxpdHlJdGVyYXRvcnNUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNTUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdFN1aXRlOwotCi0vKioKLSAqIGRlY2VudHJhbGl6ZSB0ZXN0IGNyZWF0aW9uIGNvZGUKLSAqLwotcHVibGljIGNsYXNzIEpwdFV0aWxpdHlJdGVyYXRvcnNUZXN0cyB7Ci0KLQlwdWJsaWMgc3RhdGljIFRlc3Qgc3VpdGUoKSB7Ci0JCVRlc3RTdWl0ZSBzdWl0ZSA9IG5ldyBUZXN0U3VpdGUoSnB0VXRpbGl0eUl0ZXJhdG9yc1Rlc3RzLmNsYXNzLmdldFBhY2thZ2UoKS5nZXROYW1lKCkpOwotCi0JCXN1aXRlLmFkZFRlc3RTdWl0ZShBcnJheUl0ZXJhdG9yVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoQXJyYXlMaXN0SXRlcmF0b3JUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShDaGFpbkl0ZXJhdG9yVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoQ2xvbmVJdGVyYXRvclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKENsb25lTGlzdEl0ZXJhdG9yVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoQ29tcG9zaXRlSXRlcmF0b3JUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShDb21wb3NpdGVMaXN0SXRlcmF0b3JUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShFbXB0eUVudW1lcmF0aW9uVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoRW1wdHlJdGVyYXRvclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKEVtcHR5TGlzdEl0ZXJhdG9yVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoRW51bWVyYXRpb25JdGVyYXRvclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKEZpbHRlcmluZ0l0ZXJhdG9yVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoR3JhcGhJdGVyYXRvclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKEl0ZXJhdG9yRW51bWVyYXRpb25UZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShQZWVrYWJsZUl0ZXJhdG9yVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoUmVhZE9ubHlDb21wb3NpdGVMaXN0SXRlcmF0b3JUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShSZWFkT25seUl0ZXJhdG9yVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoUmVhZE9ubHlMaXN0SXRlcmF0b3JUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShTaW5nbGVFbGVtZW50SXRlcmF0b3JUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShTaW5nbGVFbGVtZW50TGlzdEl0ZXJhdG9yVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoVHJhbnNmb3JtYXRpb25JdGVyYXRvclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFRyYW5zZm9ybWF0aW9uTGlzdEl0ZXJhdG9yVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoVHJlZUl0ZXJhdG9yVGVzdHMuY2xhc3MpOwotCi0JCXJldHVybiBzdWl0ZTsKLQl9Ci0KLQlwcml2YXRlIEpwdFV0aWxpdHlJdGVyYXRvcnNUZXN0cygpIHsKLQkJc3VwZXIoKTsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9QZWVrYWJsZUl0ZXJhdG9yVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL1BlZWthYmxlSXRlcmF0b3JUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxYTNiNDdiLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL1BlZWthYmxlSXRlcmF0b3JUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTQwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5QZWVrYWJsZUl0ZXJhdG9yOwotCi1wdWJsaWMgY2xhc3MgUGVla2FibGVJdGVyYXRvclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCi0JcHVibGljIFBlZWthYmxlSXRlcmF0b3JUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRQZWVrYWJsZUl0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlTdHJpbmcgc3RyaW5nID0gc3RyZWFtLm5leHQoKTsKLQkJCWlmIChzdHJpbmcuZXF1YWxzKCJ0aHJlZSIpKSB7Ci0JCQkJdHJ5IHsKLQkJCQkJc3RyZWFtLnJlbW92ZSgpOwotCQkJCX0gY2F0Y2ggKFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIGV4KSB7Ci0JCQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Tm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRQZWVrYWJsZUl0ZXJhdG9yKCk7Ci0JCVN0cmluZyBzdHJpbmcgPSBudWxsOwotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJc3RyaW5nID0gc3RyZWFtLm5leHQoKTsKLQkJfQotCQl0cnkgewotCQkJc3RyaW5nID0gc3RyZWFtLm5leHQoKTsKLQkJfSBjYXRjaCAoTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIk5vU3VjaEVsZW1lbnRFeGNlcHRpb24gbm90IHRocm93bjogIiArIHN0cmluZywgZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNOZXh0KCkgewotCQlpbnQgaSA9IDA7Ci0JCWZvciAoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkUGVla2FibGVJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHMoNiwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc05leHRVcGNhc3QoKSB7Ci0JCWludCBpID0gMDsKLQkJZm9yIChJdGVyYXRvcjxPYmplY3Q+IHN0cmVhbSA9IHRoaXMuYnVpbGRQZWVrYWJsZUl0ZXJhdG9yVXBjYXN0KCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyg2LCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TmV4dCgpIHsKLQkJSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkUGVla2FibGVJdGVyYXRvcigpOwotCQlhc3NlcnRFcXVhbHMoInplcm8iLCBzdHJlYW0ubmV4dCgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJvbmUiLCBzdHJlYW0ubmV4dCgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0d28iLCBzdHJlYW0ubmV4dCgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ0aHJlZSIsIHN0cmVhbS5uZXh0KCkpOwotCQlhc3NlcnRFcXVhbHMoImZvdXIiLCBzdHJlYW0ubmV4dCgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmaXZlIiwgc3RyZWFtLm5leHQoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5leHRVcGNhc3QoKSB7Ci0JCUl0ZXJhdG9yPE9iamVjdD4gc3RyZWFtID0gdGhpcy5idWlsZFBlZWthYmxlSXRlcmF0b3JVcGNhc3QoKTsKLQkJYXNzZXJ0RXF1YWxzKCJ6ZXJvIiwgc3RyZWFtLm5leHQoKSk7Ci0JCWFzc2VydEVxdWFscygib25lIiwgc3RyZWFtLm5leHQoKSk7Ci0JCWFzc2VydEVxdWFscygidHdvIiwgc3RyZWFtLm5leHQoKSk7Ci0JCWFzc2VydEVxdWFscygidGhyZWUiLCBzdHJlYW0ubmV4dCgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb3VyIiwgc3RyZWFtLm5leHQoKSk7Ci0JCWFzc2VydEVxdWFscygiZml2ZSIsIHN0cmVhbS5uZXh0KCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RQZWVrKCkgewotCQlPYmplY3QgbmV4dCA9IG51bGw7Ci0JCWZvciAoUGVla2FibGVJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRQZWVrYWJsZUl0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlPYmplY3QgcGVlayA9IHN0cmVhbS5wZWVrKCk7Ci0JCQlhc3NlcnRUcnVlKCJwZWVrIGFuZCBuZXh0IGFyZSBwcmVtYXR1cmVseSBpZGVudGljYWwiLCBwZWVrICE9IG5leHQpOwotCQkJbmV4dCA9IHN0cmVhbS5uZXh0KCk7Ci0JCQlhc3NlcnRUcnVlKCJwZWVrIGFuZCBuZXh0IGFyZSBub3QgaWRlbnRpY2FsIiwgcGVlayA9PSBuZXh0KTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RQZWVrVXBjYXN0KCkgewotCQlPYmplY3QgbmV4dCA9IG51bGw7Ci0JCWZvciAoUGVla2FibGVJdGVyYXRvcjxPYmplY3Q+IHN0cmVhbSA9IHRoaXMuYnVpbGRQZWVrYWJsZUl0ZXJhdG9yVXBjYXN0KCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlPYmplY3QgcGVlayA9IHN0cmVhbS5wZWVrKCk7Ci0JCQlhc3NlcnRUcnVlKCJwZWVrIGFuZCBuZXh0IGFyZSBwcmVtYXR1cmVseSBpZGVudGljYWwiLCBwZWVrICE9IG5leHQpOwotCQkJbmV4dCA9IHN0cmVhbS5uZXh0KCk7Ci0JCQlhc3NlcnRUcnVlKCJwZWVrIGFuZCBuZXh0IGFyZSBub3QgaWRlbnRpY2FsIiwgcGVlayA9PSBuZXh0KTsKLQkJfQotCX0KLQotCXByaXZhdGUgUGVla2FibGVJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkUGVla2FibGVJdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRQZWVrYWJsZUl0ZXJhdG9yKHRoaXMuYnVpbGROZXN0ZWRJdGVyYXRvcigpKTsKLQl9Ci0KLQlwcml2YXRlIFBlZWthYmxlSXRlcmF0b3I8T2JqZWN0PiBidWlsZFBlZWthYmxlSXRlcmF0b3JVcGNhc3QoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkUGVla2FibGVJdGVyYXRvclVwY2FzdCh0aGlzLmJ1aWxkTmVzdGVkSXRlcmF0b3IoKSk7Ci0JfQotCi0JcHJpdmF0ZSBQZWVrYWJsZUl0ZXJhdG9yPFN0cmluZz4gYnVpbGRQZWVrYWJsZUl0ZXJhdG9yKEl0ZXJhdG9yPFN0cmluZz4gbmVzdGVkSXRlcmF0b3IpIHsKLQkJcmV0dXJuIG5ldyBQZWVrYWJsZUl0ZXJhdG9yPFN0cmluZz4obmVzdGVkSXRlcmF0b3IpOwotCX0KLQotCXByaXZhdGUgUGVla2FibGVJdGVyYXRvcjxPYmplY3Q+IGJ1aWxkUGVla2FibGVJdGVyYXRvclVwY2FzdChJdGVyYXRvcjxTdHJpbmc+IG5lc3RlZEl0ZXJhdG9yKSB7Ci0JCXJldHVybiBuZXcgUGVla2FibGVJdGVyYXRvcjxPYmplY3Q+KG5lc3RlZEl0ZXJhdG9yKTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPFN0cmluZz4gYnVpbGROZXN0ZWRJdGVyYXRvcigpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGMgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJYy5hZGQoInplcm8iKTsKLQkJYy5hZGQoIm9uZSIpOwotCQljLmFkZCgidHdvIik7Ci0JCWMuYWRkKCJ0aHJlZSIpOwotCQljLmFkZCgiZm91ciIpOwotCQljLmFkZCgiZml2ZSIpOwotCQlyZXR1cm4gYy5pdGVyYXRvcigpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvUmVhZE9ubHlDb21wb3NpdGVMaXN0SXRlcmF0b3JUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvUmVhZE9ubHlDb21wb3NpdGVMaXN0SXRlcmF0b3JUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmYzc5OTI1Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL1JlYWRPbmx5Q29tcG9zaXRlTGlzdEl0ZXJhdG9yVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDIwNSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLml0ZXJhdG9yczsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlJlYWRPbmx5Q29tcG9zaXRlTGlzdEl0ZXJhdG9yOwotCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBSZWFkT25seUNvbXBvc2l0ZUxpc3RJdGVyYXRvclRlc3RzIGV4dGVuZHMgQ29tcG9zaXRlSXRlcmF0b3JUZXN0cyB7Ci0KLQlwdWJsaWMgUmVhZE9ubHlDb21wb3NpdGVMaXN0SXRlcmF0b3JUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQl2b2lkIHZlcmlmeUhhc0Fub3RoZXIoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0pIHsKLQkJc3VwZXIudmVyaWZ5SGFzQW5vdGhlcihzdHJlYW0pOwotCQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0yID0gKExpc3RJdGVyYXRvcjxTdHJpbmc+KSBzdHJlYW07Ci0JCWludCBpID0gMDsKLQkJd2hpbGUgKHN0cmVhbTIuaGFzUHJldmlvdXMoKSkgewotCQkJc3RyZWFtMi5wcmV2aW91cygpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyg4LCBpKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQl2b2lkIHZlcmlmeUFub3RoZXIoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0pIHsKLQkJc3VwZXIudmVyaWZ5QW5vdGhlcihzdHJlYW0pOwotCQlpbnQgaSA9IDg7Ci0JCUxpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbTIgPSAoTGlzdEl0ZXJhdG9yPFN0cmluZz4pIHN0cmVhbTsKLQkJd2hpbGUgKHN0cmVhbTIuaGFzUHJldmlvdXMoKSkgewotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyBlbGVtZW50IiwgU3RyaW5nLnZhbHVlT2YoaS0tKSwgc3RyZWFtMi5wcmV2aW91cygpLnN1YnN0cmluZygwLCAxKSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TmV4dEluZGV4UHJldmlvdXNJbmRleCgpIHsKLQkJaW50IGkgPSAwOwotCQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSAoTGlzdEl0ZXJhdG9yPFN0cmluZz4pIHRoaXMuYnVpbGRDb21wb3NpdGVJdGVyYXRvcigpOwotCQlhc3NlcnRFcXVhbHMoaSwgc3RyZWFtLm5leHRJbmRleCgpKTsKLQkJYXNzZXJ0RXF1YWxzKGkgLSAxLCBzdHJlYW0ucHJldmlvdXNJbmRleCgpKTsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCXN0cmVhbS5uZXh0KCk7Ci0JCQlpKys7Ci0JCQlhc3NlcnRFcXVhbHMoaSwgc3RyZWFtLm5leHRJbmRleCgpKTsKLQkJCWFzc2VydEVxdWFscyhpIC0gMSwgc3RyZWFtLnByZXZpb3VzSW5kZXgoKSk7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKCJpbmRleCBpcyBjb3JydXB0IiwgOCwgaSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKGksIHN0cmVhbS5uZXh0SW5kZXgoKSk7Ci0JCWFzc2VydEVxdWFscyhpIC0gMSwgc3RyZWFtLnByZXZpb3VzSW5kZXgoKSk7Ci0JCXdoaWxlIChzdHJlYW0uaGFzUHJldmlvdXMoKSkgewotCQkJc3RyZWFtLnByZXZpb3VzKCk7Ci0JCQlpLS07Ci0JCQlhc3NlcnRFcXVhbHMoaSwgc3RyZWFtLm5leHRJbmRleCgpKTsKLQkJCWFzc2VydEVxdWFscyhpIC0gMSwgc3RyZWFtLnByZXZpb3VzSW5kZXgoKSk7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKCJpbmRleCBpcyBjb3JydXB0IiwgMCwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFByZXZpb3VzSW5kZXgoKSB7Ci0JCS8vIFRPRE8KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlKCkgewotCQkvLyAjcmVtb3ZlKCkgaXMgbm90IHN1cHBvcnRlZAotCX0KLQotCUBPdmVycmlkZQotCXB1YmxpYyB2b2lkIHRlc3RJbGxlZ2FsU3RhdGVFeGNlcHRpb24oKSB7Ci0JCS8vICNyZW1vdmUoKSBpcyBub3Qgc3VwcG9ydGVkCi0JfQotCi0JQE92ZXJyaWRlCi0JcHVibGljIHZvaWQgdGVzdEVtcHR5SWxsZWdhbFN0YXRlRXhjZXB0aW9uMSgpIHsKLQkJLy8gI3JlbW92ZSgpIGlzIG5vdCBzdXBwb3J0ZWQKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgdm9pZCB0ZXN0RW1wdHlJbGxlZ2FsU3RhdGVFeGNlcHRpb24yKCkgewotCQkvLyAjcmVtb3ZlKCkgaXMgbm90IHN1cHBvcnRlZAotCX0KLQotCUBPdmVycmlkZQotCXZvaWQgdmVyaWZ5Tm9TdWNoRWxlbWVudEV4Y2VwdGlvbihJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSkgewotCQlzdXBlci52ZXJpZnlOb1N1Y2hFbGVtZW50RXhjZXB0aW9uKHN0cmVhbSk7Ci0JCUxpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbTIgPSAoTGlzdEl0ZXJhdG9yPFN0cmluZz4pIHN0cmVhbTsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlTdHJpbmcgc3RyaW5nID0gbnVsbDsKLQkJd2hpbGUgKHN0cmVhbTIuaGFzUHJldmlvdXMoKSkgewotCQkJc3RyaW5nID0gc3RyZWFtMi5wcmV2aW91cygpOwotCQl9Ci0JCXRyeSB7Ci0JCQlzdHJpbmcgPSBzdHJlYW0yLnByZXZpb3VzKCk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIG5vdCB0aHJvd246ICIgKyBzdHJpbmcsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQl2b2lkIHZlcmlmeVVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtKSB7Ci0JCXN1cGVyLnZlcmlmeVVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKHN0cmVhbSk7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJTGlzdEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtMiA9IChMaXN0SXRlcmF0b3I8U3RyaW5nPikgc3RyZWFtOwotCQl3aGlsZSAoc3RyZWFtMi5oYXNQcmV2aW91cygpKSB7Ci0JCQlPYmplY3Qgc3RyaW5nID0gc3RyZWFtMi5wcmV2aW91cygpOwotCQkJaWYgKHN0cmluZy5lcXVhbHMoIjMzMyIpKSB7Ci0JCQkJdHJ5IHsKLQkJCQkJc3RyZWFtMi5yZW1vdmUoKTsKLQkJCQl9IGNhdGNoIChVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWFzc2VydFRydWUoIlVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0Jdm9pZCB2ZXJpZnlJbGxlZ2FsU3RhdGVFeGNlcHRpb24oSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0pIHsKLQkJc3VwZXIudmVyaWZ5SWxsZWdhbFN0YXRlRXhjZXB0aW9uKHN0cmVhbSk7Ci0JCUxpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbTIgPSAoTGlzdEl0ZXJhdG9yPFN0cmluZz4pIHN0cmVhbTsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJc3RyZWFtMi5zZXQoImp1bmsiKTsKLQkJfSBjYXRjaCAoSWxsZWdhbFN0YXRlRXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiSWxsZWdhbFN0YXRlRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0Jdm9pZCB2ZXJpZnlFbXB0eUhhc0Fub3RoZXIoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0pIHsKLQkJc3VwZXIudmVyaWZ5RW1wdHlIYXNBbm90aGVyKHN0cmVhbSk7Ci0JCUxpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbTIgPSAoTGlzdEl0ZXJhdG9yPFN0cmluZz4pIHN0cmVhbTsKLQkJaW50IGkgPSAwOwotCQl3aGlsZSAoc3RyZWFtMi5oYXNQcmV2aW91cygpKSB7Ci0JCQlzdHJlYW0yLnByZXZpb3VzKCk7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDAsIGkpOwotCX0KLQotCS8vIHVuY2hlY2tlZCBzbyB3ZSBjYW4gb3ZlcnJpZGUgdGhlIHVuY2hlY2tlZCBtZXRob2QgaW4gc3VwZXJjbGFzcwotCUBPdmVycmlkZQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCUl0ZXJhdG9yPFN0cmluZz4gYnVpbGRDb21wb3NpdGVJdGVyYXRvcihJdGVyYXRvciBpdGVyYXRvcnMpIHsKLQkJcmV0dXJuIG5ldyBSZWFkT25seUNvbXBvc2l0ZUxpc3RJdGVyYXRvcjxTdHJpbmc+KChMaXN0SXRlcmF0b3I8TGlzdEl0ZXJhdG9yPFN0cmluZz4+KSBpdGVyYXRvcnMpOwotCX0KLQotCUBPdmVycmlkZQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCUl0ZXJhdG9yPFN0cmluZz4gYnVpbGRDb21wb3NpdGVJdGVyYXRvcjIoKSB7Ci0JCXJldHVybiBuZXcgUmVhZE9ubHlDb21wb3NpdGVMaXN0SXRlcmF0b3I8U3RyaW5nPih0aGlzLmJ1aWxkSXRlcmF0b3IxKCksIHRoaXMuYnVpbGRJdGVyYXRvcjIoKSwgdGhpcy5idWlsZEl0ZXJhdG9yMygpKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IzKCkgewotCQlyZXR1cm4gbmV3IFJlYWRPbmx5Q29tcG9zaXRlTGlzdEl0ZXJhdG9yPFN0cmluZz4obmV3IExpc3RJdGVyYXRvcltdIHsgdGhpcy5idWlsZEl0ZXJhdG9yMSgpLCB0aGlzLmJ1aWxkSXRlcmF0b3IyKCksIHRoaXMuYnVpbGRJdGVyYXRvcjMoKSB9KTsKLQl9Ci0KLQlJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkQ29tcG9zaXRlSXRlcmF0b3IoU3RyaW5nIHN0cmluZywgTGlzdEl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRDb21wb3NpdGVMaXN0SXRlcmF0b3Ioc3RyaW5nLCBpdGVyYXRvcik7Ci0JfQotCi0JTGlzdEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRDb21wb3NpdGVMaXN0SXRlcmF0b3IoU3RyaW5nIHN0cmluZywgTGlzdEl0ZXJhdG9yPFN0cmluZz4gaXRlcmF0b3IpIHsKLQkJcmV0dXJuIG5ldyBSZWFkT25seUNvbXBvc2l0ZUxpc3RJdGVyYXRvcjxTdHJpbmc+KHN0cmluZywgaXRlcmF0b3IpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RWYXJpZWROZXN0ZWRJdGVyYXRvcnMoKSB7Ci0JCUxpc3Q8SW50ZWdlcj4gaW50ZWdlckxpc3QgPSBuZXcgQXJyYXlMaXN0PEludGVnZXI+KCk7Ci0JCWludGVnZXJMaXN0LmFkZChuZXcgSW50ZWdlcig0MikpOwotCQlpbnRlZ2VyTGlzdC5hZGQobmV3IEludGVnZXIoNDIpKTsKLQkJaW50ZWdlckxpc3QuYWRkKG5ldyBJbnRlZ2VyKDExMSkpOwotCQlpbnRlZ2VyTGlzdC5hZGQobmV3IEludGVnZXIoNzcpKTsKLQotCQlMaXN0PEZsb2F0PiBmbG9hdExpc3QgPSBuZXcgQXJyYXlMaXN0PEZsb2F0PigpOwotCQlmbG9hdExpc3QuYWRkKG5ldyBGbG9hdCg0Mi40MmYpKTsKLQkJZmxvYXRMaXN0LmFkZChuZXcgRmxvYXQoMjIuMjJmKSk7Ci0JCWZsb2F0TGlzdC5hZGQobmV3IEZsb2F0KDExMS4xMTFmKSk7Ci0JCWZsb2F0TGlzdC5hZGQobmV3IEZsb2F0KDc3Ljc3ZikpOwotCi0JCUxpc3Q8TGlzdEl0ZXJhdG9yPD8gZXh0ZW5kcyBOdW1iZXI+PiBsaXN0ID0gbmV3IEFycmF5TGlzdDxMaXN0SXRlcmF0b3I8PyBleHRlbmRzIE51bWJlcj4+KCk7Ci0JCWxpc3QuYWRkKGludGVnZXJMaXN0Lmxpc3RJdGVyYXRvcigpKTsKLQkJbGlzdC5hZGQoZmxvYXRMaXN0Lmxpc3RJdGVyYXRvcigpKTsKLQkJTGlzdEl0ZXJhdG9yPE51bWJlcj4gbGkgPSBuZXcgUmVhZE9ubHlDb21wb3NpdGVMaXN0SXRlcmF0b3I8TnVtYmVyPihsaXN0KTsKLQkJd2hpbGUgKGxpLmhhc05leHQoKSkgewotCQkJYXNzZXJ0VHJ1ZShsaS5uZXh0KCkuaW50VmFsdWUoKSA+IDApOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9SZWFkT25seUl0ZXJhdG9yVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL1JlYWRPbmx5SXRlcmF0b3JUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0ZGVmYTJlLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL1JlYWRPbmx5SXRlcmF0b3JUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTE4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuaXRlcmF0b3JzOwotCi1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Ob1N1Y2hFbGVtZW50RXhjZXB0aW9uOwotaW1wb3J0IGphdmEudXRpbC5WZWN0b3I7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5SZWFkT25seUl0ZXJhdG9yOwotCi1wdWJsaWMgY2xhc3MgUmVhZE9ubHlJdGVyYXRvclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCi0JcHVibGljIFJlYWRPbmx5SXRlcmF0b3JUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTmV4dCgpIHsKLQkJaW50IGkgPSAwOwotCQlmb3IgKEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZFJlYWRPbmx5SXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCXN0cmVhbS5uZXh0KCk7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRWZWN0b3IoKS5zaXplKCksIGkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNOZXh0VXBjYXN0KCkgewotCQlpbnQgaSA9IDA7Ci0JCWZvciAoSXRlcmF0b3I8T2JqZWN0PiBzdHJlYW0gPSB0aGlzLmJ1aWxkUmVhZE9ubHlJdGVyYXRvclVwY2FzdCgpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHModGhpcy5idWlsZFZlY3RvcigpLnNpemUoKSwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5leHQoKSB7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gbmVzdGVkSXRlcmF0b3IgPSB0aGlzLmJ1aWxkTmVzdGVkSXRlcmF0b3IoKTsKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRSZWFkT25seUl0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlhc3NlcnRFcXVhbHMoImJvZ3VzIGVsZW1lbnQiLCBuZXN0ZWRJdGVyYXRvci5uZXh0KCksIHN0cmVhbS5uZXh0KCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5leHRVcGNhc3QoKSB7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gbmVzdGVkSXRlcmF0b3IgPSB0aGlzLmJ1aWxkTmVzdGVkSXRlcmF0b3IoKTsKLQkJZm9yIChJdGVyYXRvcjxPYmplY3Q+IHN0cmVhbSA9IHRoaXMuYnVpbGRSZWFkT25seUl0ZXJhdG9yVXBjYXN0KCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlhc3NlcnRFcXVhbHMoImJvZ3VzIGVsZW1lbnQiLCBuZXN0ZWRJdGVyYXRvci5uZXh0KCksIHN0cmVhbS5uZXh0KCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5vU3VjaEVsZW1lbnRFeGNlcHRpb24oKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkUmVhZE9ubHlJdGVyYXRvcigpOwotCQlTdHJpbmcgc3RyaW5nID0gbnVsbDsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCXN0cmluZyA9IHN0cmVhbS5uZXh0KCk7Ci0JCX0KLQkJdHJ5IHsKLQkJCXN0cmluZyA9IHN0cmVhbS5uZXh0KCk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIG5vdCB0aHJvd246ICIgKyBzdHJpbmcsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCWZvciAoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkUmVhZE9ubHlJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJaWYgKHN0cmVhbS5uZXh0KCkuZXF1YWxzKCJ0aHJlZSIpKSB7Ci0JCQkJdHJ5IHsKLQkJCQkJc3RyZWFtLnJlbW92ZSgpOwotCQkJCX0gY2F0Y2ggKFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIGV4KSB7Ci0JCQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRSZWFkT25seUl0ZXJhdG9yKCkgewotCQlyZXR1cm4gdGhpcy5idWlsZFJlYWRPbmx5SXRlcmF0b3IodGhpcy5idWlsZE5lc3RlZEl0ZXJhdG9yKCkpOwotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8T2JqZWN0PiBidWlsZFJlYWRPbmx5SXRlcmF0b3JVcGNhc3QoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkUmVhZE9ubHlJdGVyYXRvclVwY2FzdCh0aGlzLmJ1aWxkTmVzdGVkSXRlcmF0b3IoKSk7Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkUmVhZE9ubHlJdGVyYXRvcihJdGVyYXRvcjxTdHJpbmc+IG5lc3RlZEl0ZXJhdG9yKSB7Ci0JCXJldHVybiBuZXcgUmVhZE9ubHlJdGVyYXRvcjxTdHJpbmc+KG5lc3RlZEl0ZXJhdG9yKTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPE9iamVjdD4gYnVpbGRSZWFkT25seUl0ZXJhdG9yVXBjYXN0KEl0ZXJhdG9yPFN0cmluZz4gbmVzdGVkSXRlcmF0b3IpIHsKLQkJcmV0dXJuIG5ldyBSZWFkT25seUl0ZXJhdG9yPE9iamVjdD4obmVzdGVkSXRlcmF0b3IpOwotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8U3RyaW5nPiBidWlsZE5lc3RlZEl0ZXJhdG9yKCkgewotCQlyZXR1cm4gdGhpcy5idWlsZFZlY3RvcigpLml0ZXJhdG9yKCk7Ci0JfQotCi0JcHJpdmF0ZSBWZWN0b3I8U3RyaW5nPiBidWlsZFZlY3RvcigpIHsKLQkJVmVjdG9yPFN0cmluZz4gdiA9IG5ldyBWZWN0b3I8U3RyaW5nPigpOwotCQl2LmFkZEVsZW1lbnQoIm9uZSIpOwotCQl2LmFkZEVsZW1lbnQoInR3byIpOwotCQl2LmFkZEVsZW1lbnQoInRocmVlIik7Ci0JCXYuYWRkRWxlbWVudCgiZm91ciIpOwotCQl2LmFkZEVsZW1lbnQoImZpdmUiKTsKLQkJdi5hZGRFbGVtZW50KCJzaXgiKTsKLQkJdi5hZGRFbGVtZW50KCJzZXZlbiIpOwotCQl2LmFkZEVsZW1lbnQoImVpZ2h0Iik7Ci0JCXJldHVybiB2OwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvUmVhZE9ubHlMaXN0SXRlcmF0b3JUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvUmVhZE9ubHlMaXN0SXRlcmF0b3JUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0ZGI3MmY2Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL1JlYWRPbmx5TGlzdEl0ZXJhdG9yVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDIwMyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLml0ZXJhdG9yczsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTm9TdWNoRWxlbWVudEV4Y2VwdGlvbjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlJlYWRPbmx5TGlzdEl0ZXJhdG9yOwotCi1wdWJsaWMgY2xhc3MgUmVhZE9ubHlMaXN0SXRlcmF0b3JUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBSZWFkT25seUxpc3RJdGVyYXRvclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNOZXh0QW5kSGFzUHJldmlvdXMoKSB7Ci0JCWludCBpID0gMDsKLQkJTGlzdEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZFJlYWRPbmx5TGlzdEl0ZXJhdG9yKCk7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkTGlzdCgpLnNpemUoKSwgaSk7Ci0KLQkJd2hpbGUgKHN0cmVhbS5oYXNQcmV2aW91cygpKSB7Ci0JCQlzdHJlYW0ucHJldmlvdXMoKTsKLQkJCWktLTsKLQkJfQotCQlhc3NlcnRFcXVhbHMoMCwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc05leHRBbmRIYXNQcmV2aW91c1VwY2FzdCgpIHsKLQkJaW50IGkgPSAwOwotCQlMaXN0SXRlcmF0b3I8T2JqZWN0PiBzdHJlYW0gPSB0aGlzLmJ1aWxkUmVhZE9ubHlMaXN0SXRlcmF0b3JVcGNhc3QoKTsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCXN0cmVhbS5uZXh0KCk7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRMaXN0KCkuc2l6ZSgpLCBpKTsKLQotCQl3aGlsZSAoc3RyZWFtLmhhc1ByZXZpb3VzKCkpIHsKLQkJCXN0cmVhbS5wcmV2aW91cygpOwotCQkJaS0tOwotCQl9Ci0JCWFzc2VydEVxdWFscygwLCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TmV4dEFuZFByZXZpb3VzKCkgewotCQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBuZXN0ZWRMaXN0SXRlcmF0b3IgPSB0aGlzLmJ1aWxkTmVzdGVkTGlzdEl0ZXJhdG9yKCk7Ci0JCUxpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRSZWFkT25seUxpc3RJdGVyYXRvcigpOwotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyBlbGVtZW50IiwgbmVzdGVkTGlzdEl0ZXJhdG9yLm5leHQoKSwgc3RyZWFtLm5leHQoKSk7Ci0JCX0KLQkJd2hpbGUgKHN0cmVhbS5oYXNQcmV2aW91cygpKSB7Ci0JCQlhc3NlcnRFcXVhbHMoImJvZ3VzIGVsZW1lbnQiLCBuZXN0ZWRMaXN0SXRlcmF0b3IucHJldmlvdXMoKSwgc3RyZWFtLnByZXZpb3VzKCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5leHRBbmRQcmV2aW91c1VwY2FzdCgpIHsKLQkJTGlzdEl0ZXJhdG9yPFN0cmluZz4gbmVzdGVkTGlzdEl0ZXJhdG9yID0gdGhpcy5idWlsZE5lc3RlZExpc3RJdGVyYXRvcigpOwotCQlMaXN0SXRlcmF0b3I8T2JqZWN0PiBzdHJlYW0gPSB0aGlzLmJ1aWxkUmVhZE9ubHlMaXN0SXRlcmF0b3JVcGNhc3QoKTsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCWFzc2VydEVxdWFscygiYm9ndXMgZWxlbWVudCIsIG5lc3RlZExpc3RJdGVyYXRvci5uZXh0KCksIHN0cmVhbS5uZXh0KCkpOwotCQl9Ci0JCXdoaWxlIChzdHJlYW0uaGFzUHJldmlvdXMoKSkgewotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyBlbGVtZW50IiwgbmVzdGVkTGlzdEl0ZXJhdG9yLnByZXZpb3VzKCksIHN0cmVhbS5wcmV2aW91cygpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROZXh0SW5kZXhBbmRQcmV2aW91c0luZGV4KCkgewotCQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBuZXN0ZWRMaXN0SXRlcmF0b3IgPSB0aGlzLmJ1aWxkTmVzdGVkTGlzdEl0ZXJhdG9yKCk7Ci0JCUxpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRSZWFkT25seUxpc3RJdGVyYXRvcigpOwotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyBpbmRleCIsIG5lc3RlZExpc3RJdGVyYXRvci5uZXh0SW5kZXgoKSwgc3RyZWFtLm5leHRJbmRleCgpKTsKLQkJCW5lc3RlZExpc3RJdGVyYXRvci5uZXh0KCk7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQl9Ci0JCWFzc2VydEVxdWFscygiYm9ndXMgaW5kZXgiLCB0aGlzLmJ1aWxkTGlzdCgpLnNpemUoKSwgc3RyZWFtLm5leHRJbmRleCgpKTsKLQkJd2hpbGUgKHN0cmVhbS5oYXNQcmV2aW91cygpKSB7Ci0JCQlhc3NlcnRFcXVhbHMoImJvZ3VzIGVsZW1lbnQiLCBuZXN0ZWRMaXN0SXRlcmF0b3IucHJldmlvdXNJbmRleCgpLCBzdHJlYW0ucHJldmlvdXNJbmRleCgpKTsKLQkJCW5lc3RlZExpc3RJdGVyYXRvci5wcmV2aW91cygpOwotCQkJc3RyZWFtLnByZXZpb3VzKCk7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKCJib2d1cyBpbmRleCIsIC0xLCBzdHJlYW0ucHJldmlvdXNJbmRleCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TmV4dEluZGV4QW5kUHJldmlvdXNJbmRleFVwY2FzdCgpIHsKLQkJTGlzdEl0ZXJhdG9yPFN0cmluZz4gbmVzdGVkTGlzdEl0ZXJhdG9yID0gdGhpcy5idWlsZE5lc3RlZExpc3RJdGVyYXRvcigpOwotCQlMaXN0SXRlcmF0b3I8T2JqZWN0PiBzdHJlYW0gPSB0aGlzLmJ1aWxkUmVhZE9ubHlMaXN0SXRlcmF0b3JVcGNhc3QoKTsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCWFzc2VydEVxdWFscygiYm9ndXMgaW5kZXgiLCBuZXN0ZWRMaXN0SXRlcmF0b3IubmV4dEluZGV4KCksIHN0cmVhbS5uZXh0SW5kZXgoKSk7Ci0JCQluZXN0ZWRMaXN0SXRlcmF0b3IubmV4dCgpOwotCQkJc3RyZWFtLm5leHQoKTsKLQkJfQotCQlhc3NlcnRFcXVhbHMoImJvZ3VzIGluZGV4IiwgdGhpcy5idWlsZExpc3QoKS5zaXplKCksIHN0cmVhbS5uZXh0SW5kZXgoKSk7Ci0JCXdoaWxlIChzdHJlYW0uaGFzUHJldmlvdXMoKSkgewotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyBlbGVtZW50IiwgbmVzdGVkTGlzdEl0ZXJhdG9yLnByZXZpb3VzSW5kZXgoKSwgc3RyZWFtLnByZXZpb3VzSW5kZXgoKSk7Ci0JCQluZXN0ZWRMaXN0SXRlcmF0b3IucHJldmlvdXMoKTsKLQkJCXN0cmVhbS5wcmV2aW91cygpOwotCQl9Ci0JCWFzc2VydEVxdWFscygiYm9ndXMgaW5kZXgiLCAtMSwgc3RyZWFtLnByZXZpb3VzSW5kZXgoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5vU3VjaEVsZW1lbnRFeGNlcHRpb24oKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJTGlzdEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZFJlYWRPbmx5TGlzdEl0ZXJhdG9yKCk7Ci0JCVN0cmluZyBzdHJpbmcgPSBudWxsOwotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJc3RyaW5nID0gc3RyZWFtLm5leHQoKTsKLQkJfQotCQl0cnkgewotCQkJc3RyaW5nID0gc3RyZWFtLm5leHQoKTsKLQkJfSBjYXRjaCAoTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIk5vU3VjaEVsZW1lbnRFeGNlcHRpb24gbm90IHRocm93bjogIiArIHN0cmluZywgZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmUoKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJZm9yIChMaXN0SXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkUmVhZE9ubHlMaXN0SXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCWlmIChzdHJlYW0ubmV4dCgpLmVxdWFscygidGhyZWUiKSkgewotCQkJCXRyeSB7Ci0JCQkJCXN0cmVhbS5yZW1vdmUoKTsKLQkJCQl9IGNhdGNoIChVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWFzc2VydFRydWUoIlVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNldCgpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlmb3IgKExpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRSZWFkT25seUxpc3RJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJaWYgKHN0cmVhbS5uZXh0KCkuZXF1YWxzKCJ0aHJlZSIpKSB7Ci0JCQkJdHJ5IHsKLQkJCQkJc3RyZWFtLnNldCgiYm9ndXMiKTsKLQkJCQl9IGNhdGNoIChVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWFzc2VydFRydWUoIlVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZCgpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlmb3IgKExpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRSZWFkT25seUxpc3RJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJaWYgKHN0cmVhbS5uZXh0KCkuZXF1YWxzKCJ0aHJlZSIpKSB7Ci0JCQkJdHJ5IHsKLQkJCQkJc3RyZWFtLmFkZCgiYm9ndXMiKTsKLQkJCQl9IGNhdGNoIChVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWFzc2VydFRydWUoIlVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0SXRlcmF0b3I8U3RyaW5nPiBidWlsZFJlYWRPbmx5TGlzdEl0ZXJhdG9yKCkgewotCQlyZXR1cm4gdGhpcy5idWlsZFJlYWRPbmx5TGlzdEl0ZXJhdG9yKHRoaXMuYnVpbGROZXN0ZWRMaXN0SXRlcmF0b3IoKSk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0SXRlcmF0b3I8T2JqZWN0PiBidWlsZFJlYWRPbmx5TGlzdEl0ZXJhdG9yVXBjYXN0KCkgewotCQlyZXR1cm4gdGhpcy5idWlsZFJlYWRPbmx5TGlzdEl0ZXJhdG9yVXBjYXN0KHRoaXMuYnVpbGROZXN0ZWRMaXN0SXRlcmF0b3IoKSk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0SXRlcmF0b3I8U3RyaW5nPiBidWlsZFJlYWRPbmx5TGlzdEl0ZXJhdG9yKExpc3RJdGVyYXRvcjxTdHJpbmc+IG5lc3RlZExpc3RJdGVyYXRvcikgewotCQlyZXR1cm4gbmV3IFJlYWRPbmx5TGlzdEl0ZXJhdG9yPFN0cmluZz4obmVzdGVkTGlzdEl0ZXJhdG9yKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RJdGVyYXRvcjxPYmplY3Q+IGJ1aWxkUmVhZE9ubHlMaXN0SXRlcmF0b3JVcGNhc3QoTGlzdEl0ZXJhdG9yPFN0cmluZz4gbmVzdGVkTGlzdEl0ZXJhdG9yKSB7Ci0JCXJldHVybiBuZXcgUmVhZE9ubHlMaXN0SXRlcmF0b3I8T2JqZWN0PihuZXN0ZWRMaXN0SXRlcmF0b3IpOwotCX0KLQotCXByaXZhdGUgTGlzdEl0ZXJhdG9yPFN0cmluZz4gYnVpbGROZXN0ZWRMaXN0SXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkTGlzdCgpLmxpc3RJdGVyYXRvcigpOwotCX0KLQotCXByaXZhdGUgTGlzdDxTdHJpbmc+IGJ1aWxkTGlzdCgpIHsKLQkJTGlzdDxTdHJpbmc+IGwgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJbC5hZGQoIm9uZSIpOwotCQlsLmFkZCgidHdvIik7Ci0JCWwuYWRkKCJ0aHJlZSIpOwotCQlsLmFkZCgiZm91ciIpOwotCQlsLmFkZCgiZml2ZSIpOwotCQlsLmFkZCgic2l4Iik7Ci0JCWwuYWRkKCJzZXZlbiIpOwotCQlsLmFkZCgiZWlnaHQiKTsKLQkJcmV0dXJuIGw7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9TaW5nbGVFbGVtZW50SXRlcmF0b3JUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvU2luZ2xlRWxlbWVudEl0ZXJhdG9yVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTg0NjU3Yy4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9TaW5nbGVFbGVtZW50SXRlcmF0b3JUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb247Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5TaW5nbGVFbGVtZW50SXRlcmF0b3I7Ci0KLXB1YmxpYyBjbGFzcyBTaW5nbGVFbGVtZW50SXRlcmF0b3JUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBTaW5nbGVFbGVtZW50SXRlcmF0b3JUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTmV4dCgpIHsKLQkJaW50IGkgPSAwOwotCQlmb3IgKEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZFNpbmdsZUVsZW1lbnRJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHMoMSwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5leHQoKSB7Ci0JCWZvciAoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkU2luZ2xlRWxlbWVudEl0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlhc3NlcnRFcXVhbHMoImJvZ3VzIGVsZW1lbnQiLCB0aGlzLnNpbmdsZUVsZW1lbnQoKSwgc3RyZWFtLm5leHQoKSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Tm9TdWNoRWxlbWVudEV4Y2VwdGlvbigpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRTaW5nbGVFbGVtZW50SXRlcmF0b3IoKTsKLQkJU3RyaW5nIHN0cmluZyA9IHN0cmVhbS5uZXh0KCk7Ci0JCXRyeSB7Ci0JCQlzdHJpbmcgPSBzdHJlYW0ubmV4dCgpOwotCQl9IGNhdGNoIChOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBub3QgdGhyb3duOiAiICsgc3RyaW5nLCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZSgpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlmb3IgKEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZFNpbmdsZUVsZW1lbnRJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJaWYgKHN0cmVhbS5uZXh0KCkuZXF1YWxzKHRoaXMuc2luZ2xlRWxlbWVudCgpKSkgewotCQkJCXRyeSB7Ci0JCQkJCXN0cmVhbS5yZW1vdmUoKTsKLQkJCQl9IGNhdGNoIChVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWFzc2VydFRydWUoIlVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCi0JcHJvdGVjdGVkIEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRTaW5nbGVFbGVtZW50SXRlcmF0b3IoKSB7Ci0JCXJldHVybiBuZXcgU2luZ2xlRWxlbWVudEl0ZXJhdG9yPFN0cmluZz4odGhpcy5zaW5nbGVFbGVtZW50KCkpOwotCX0KLQotCXByb3RlY3RlZCBTdHJpbmcgc2luZ2xlRWxlbWVudCgpIHsKLQkJcmV0dXJuICJzaW5nbGUgZWxlbWVudCI7Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvU2luZ2xlRWxlbWVudExpc3RJdGVyYXRvclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9TaW5nbGVFbGVtZW50TGlzdEl0ZXJhdG9yVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTNlNDE5Ny4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9TaW5nbGVFbGVtZW50TGlzdEl0ZXJhdG9yVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDExMSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLml0ZXJhdG9yczsKLQotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5TaW5nbGVFbGVtZW50TGlzdEl0ZXJhdG9yOwotCi1wdWJsaWMgY2xhc3MgU2luZ2xlRWxlbWVudExpc3RJdGVyYXRvclRlc3RzIGV4dGVuZHMgU2luZ2xlRWxlbWVudEl0ZXJhdG9yVGVzdHMgewotCi0JcHVibGljIFNpbmdsZUVsZW1lbnRMaXN0SXRlcmF0b3JUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TmV4dEluZGV4KCkgewotCQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkU2luZ2xlRWxlbWVudExpc3RJdGVyYXRvcigpOwotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyBpbmRleCIsIDAsIHN0cmVhbS5uZXh0SW5kZXgoKSk7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQl9Ci0JCWFzc2VydEVxdWFscygiYm9ndXMgaW5kZXgiLCAxLCBzdHJlYW0ubmV4dEluZGV4KCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNQcmV2aW91cygpIHsKLQkJaW50IGkgPSAwOwotCQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkU2luZ2xlRWxlbWVudExpc3RJdGVyYXRvcigpOwotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJc3RyZWFtLm5leHQoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHMoMSwgaSk7Ci0KLQkJd2hpbGUgKHN0cmVhbS5oYXNQcmV2aW91cygpKSB7Ci0JCQlzdHJlYW0ucHJldmlvdXMoKTsKLQkJCWkrKzsKLQkJfQotCQlhc3NlcnRFcXVhbHMoMiwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFByZXZpb3VzKCkgewotCQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkU2luZ2xlRWxlbWVudExpc3RJdGVyYXRvcigpOwotCi0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlhc3NlcnRFcXVhbHMoImJvZ3VzIGVsZW1lbnQiLCB0aGlzLnNpbmdsZUVsZW1lbnQoKSwgc3RyZWFtLm5leHQoKSk7Ci0JCX0KLQotCQl3aGlsZSAoc3RyZWFtLmhhc1ByZXZpb3VzKCkpIHsKLQkJCWFzc2VydEVxdWFscygiYm9ndXMgZWxlbWVudCIsIHRoaXMuc2luZ2xlRWxlbWVudCgpLCBzdHJlYW0ucHJldmlvdXMoKSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UHJldmlvdXNJbmRleCgpIHsKLQkJTGlzdEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gdGhpcy5idWlsZFNpbmdsZUVsZW1lbnRMaXN0SXRlcmF0b3IoKTsKLQotCQl3aGlsZSAoc3RyZWFtLmhhc05leHQoKSkgewotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyBpbmRleCIsIDAsIHN0cmVhbS5uZXh0SW5kZXgoKSk7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQl9Ci0KLQkJd2hpbGUgKHN0cmVhbS5oYXNQcmV2aW91cygpKSB7Ci0JCQlhc3NlcnRFcXVhbHMoImJvZ3VzIGluZGV4IiwgMCwgc3RyZWFtLnByZXZpb3VzSW5kZXgoKSk7Ci0JCQlzdHJlYW0ucHJldmlvdXMoKTsKLQkJfQotCi0JCWFzc2VydEVxdWFscygiYm9ndXMgaW5kZXgiLCAtMSwgc3RyZWFtLnByZXZpb3VzSW5kZXgoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZCgpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlMaXN0SXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSB0aGlzLmJ1aWxkU2luZ2xlRWxlbWVudExpc3RJdGVyYXRvcigpOwotCi0JCXRyeSB7Ci0JCQlzdHJlYW0uYWRkKCJmb28iKTsKLQkJfSBjYXRjaCAoVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCi0JCWFzc2VydFRydWUoIlVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNldCgpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQlmb3IgKExpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IHRoaXMuYnVpbGRTaW5nbGVFbGVtZW50TGlzdEl0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlpZiAoc3RyZWFtLm5leHQoKS5lcXVhbHModGhpcy5zaW5nbGVFbGVtZW50KCkpKSB7Ci0JCQkJdHJ5IHsKLQkJCQkJc3RyZWFtLnNldCgiZm9vIik7Ci0JCQkJfSBjYXRjaCAoVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gZXgpIHsKLQkJCQkJZXhDYXVnaHQgPSB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfQotCQlhc3NlcnRUcnVlKCJVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBub3QgdGhyb3duIiwgZXhDYXVnaHQpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCBJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkU2luZ2xlRWxlbWVudEl0ZXJhdG9yKCkgewotCQlyZXR1cm4gbmV3IFNpbmdsZUVsZW1lbnRMaXN0SXRlcmF0b3I8U3RyaW5nPih0aGlzLnNpbmdsZUVsZW1lbnQoKSk7Ci0JfQotCi0JcHJvdGVjdGVkIExpc3RJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkU2luZ2xlRWxlbWVudExpc3RJdGVyYXRvcigpIHsKLQkJcmV0dXJuIChMaXN0SXRlcmF0b3I8U3RyaW5nPikgdGhpcy5idWlsZFNpbmdsZUVsZW1lbnRJdGVyYXRvcigpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvVHJhbnNmb3JtYXRpb25JdGVyYXRvclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9UcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmVmMjU1Mi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9UcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDIyOSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLml0ZXJhdG9yczsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb25zOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTm9TdWNoRWxlbWVudEV4Y2VwdGlvbjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuVHJhbnNmb3JtZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlRyYW5zZm9ybWF0aW9uSXRlcmF0b3I7Ci0KLXB1YmxpYyBjbGFzcyBUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQlwdWJsaWMgVHJhbnNmb3JtYXRpb25JdGVyYXRvclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNOZXh0KCkgewotCQlpbnQgaSA9IDA7Ci0JCWZvciAoSXRlcmF0b3I8SW50ZWdlcj4gc3RyZWFtID0gdGhpcy5idWlsZEl0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyg4LCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTmV4dFVwY2FzdCgpIHsKLQkJaW50IGkgPSAwOwotCQlmb3IgKEl0ZXJhdG9yPE9iamVjdD4gc3RyZWFtID0gdGhpcy5idWlsZEl0ZXJhdG9yVXBjYXN0KCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyg4LCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW5uZXJIYXNOZXh0KCkgewotCQlpbnQgaSA9IDA7Ci0JCWZvciAoSXRlcmF0b3I8SW50ZWdlcj4gc3RyZWFtID0gdGhpcy5idWlsZElubmVySXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCXN0cmVhbS5uZXh0KCk7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDgsIGkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROZXh0KCkgewotCQlpbnQgaSA9IDA7Ci0JCWZvciAoSXRlcmF0b3I8SW50ZWdlcj4gc3RyZWFtID0gdGhpcy5idWlsZEl0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlhc3NlcnRFcXVhbHMoImJvZ3VzIHRyYW5zZm9ybWF0aW9uIiwgKytpLCBzdHJlYW0ubmV4dCgpLmludFZhbHVlKCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5leHRVcGNhc3QoKSB7Ci0JCWludCBpID0gMDsKLQkJZm9yIChJdGVyYXRvcjxPYmplY3Q+IHN0cmVhbSA9IHRoaXMuYnVpbGRJdGVyYXRvclVwY2FzdCgpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyB0cmFuc2Zvcm1hdGlvbiIsICsraSwgKChJbnRlZ2VyKSBzdHJlYW0ubmV4dCgpKS5pbnRWYWx1ZSgpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbm5lck5leHQoKSB7Ci0JCWludCBpID0gMDsKLQkJZm9yIChJdGVyYXRvcjxJbnRlZ2VyPiBzdHJlYW0gPSB0aGlzLmJ1aWxkSW5uZXJJdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJYXNzZXJ0RXF1YWxzKCJib2d1cyB0cmFuc2Zvcm1hdGlvbiIsICsraSwgc3RyZWFtLm5leHQoKS5pbnRWYWx1ZSgpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmUoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gdGhpcy5idWlsZENvbGxlY3Rpb24oKTsKLQkJZm9yIChJdGVyYXRvcjxJbnRlZ2VyPiBzdHJlYW0gPSB0aGlzLmJ1aWxkSW5uZXJUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yKGMuaXRlcmF0b3IoKSk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlpZiAoc3RyZWFtLm5leHQoKS5pbnRWYWx1ZSgpID09IDMpIHsKLQkJCQlzdHJlYW0ucmVtb3ZlKCk7Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKCJub3RoaW5nIHJlbW92ZWQiLCB0aGlzLmJ1aWxkQ29sbGVjdGlvbigpLnNpemUoKSAtIDEsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0RmFsc2UoImVsZW1lbnQgc3RpbGwgaW4gY29sbGVjdGlvbiIsIGMuY29udGFpbnMoIjMzMyIpKTsKLQkJYXNzZXJ0VHJ1ZSgid3JvbmcgZWxlbWVudCByZW1vdmVkIiwgYy5jb250YWlucygiMjIiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdElubmVyUmVtb3ZlKCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IHRoaXMuYnVpbGRDb2xsZWN0aW9uKCk7Ci0JCWZvciAoSXRlcmF0b3I8SW50ZWdlcj4gc3RyZWFtID0gdGhpcy5idWlsZFRyYW5zZm9ybWF0aW9uSXRlcmF0b3IoYy5pdGVyYXRvcigpLCB0aGlzLmJ1aWxkVHJhbnNmb3JtZXIoKSk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlpZiAoc3RyZWFtLm5leHQoKS5pbnRWYWx1ZSgpID09IDMpIHsKLQkJCQlzdHJlYW0ucmVtb3ZlKCk7Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKCJub3RoaW5nIHJlbW92ZWQiLCB0aGlzLmJ1aWxkQ29sbGVjdGlvbigpLnNpemUoKSAtIDEsIGMuc2l6ZSgpKTsKLQkJYXNzZXJ0RmFsc2UoImVsZW1lbnQgc3RpbGwgaW4gY29sbGVjdGlvbiIsIGMuY29udGFpbnMoIjMzMyIpKTsKLQkJYXNzZXJ0VHJ1ZSgid3JvbmcgZWxlbWVudCByZW1vdmVkIiwgYy5jb250YWlucygiMjIiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5vU3VjaEVsZW1lbnRFeGNlcHRpb24oKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJSXRlcmF0b3I8SW50ZWdlcj4gc3RyZWFtID0gdGhpcy5idWlsZEl0ZXJhdG9yKCk7Ci0JCUludGVnZXIgaW50ZWdlciA9IG51bGw7Ci0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlpbnRlZ2VyID0gc3RyZWFtLm5leHQoKTsKLQkJfQotCQl0cnkgewotCQkJaW50ZWdlciA9IHN0cmVhbS5uZXh0KCk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIG5vdCB0aHJvd246ICIgKyBpbnRlZ2VyLCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCWZvciAoSXRlcmF0b3I8SW50ZWdlcj4gc3RyZWFtID0gdGhpcy5idWlsZFVubW9kaWZpYWJsZUl0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7KSB7Ci0JCQlpbnQgaSA9IHN0cmVhbS5uZXh0KCkuaW50VmFsdWUoKTsKLQkJCWlmIChpID09IDMpIHsKLQkJCQl0cnkgewotCQkJCQlzdHJlYW0ucmVtb3ZlKCk7Ci0JCQkJfSBjYXRjaCAoVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gZXgpIHsKLQkJCQkJZXhDYXVnaHQgPSB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfQotCQlhc3NlcnRUcnVlKCJVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBub3QgdGhyb3duIiwgZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbGxlZ2FsU3RhdGVFeGNlcHRpb24oKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRoaXMuYnVpbGRJdGVyYXRvcigpLnJlbW92ZSgpOwotCQl9IGNhdGNoIChJbGxlZ2FsU3RhdGVFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJJbGxlZ2FsU3RhdGVFeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPEludGVnZXI+IGJ1aWxkSXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkVHJhbnNmb3JtYXRpb25JdGVyYXRvcih0aGlzLmJ1aWxkTmVzdGVkSXRlcmF0b3IoKSwgdGhpcy5idWlsZFRyYW5zZm9ybWVyKCkpOwotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8T2JqZWN0PiBidWlsZEl0ZXJhdG9yVXBjYXN0KCkgewotCQlyZXR1cm4gdGhpcy5idWlsZFRyYW5zZm9ybWF0aW9uSXRlcmF0b3JVcGNhc3QodGhpcy5idWlsZE5lc3RlZEl0ZXJhdG9yKCksIHRoaXMuYnVpbGRUcmFuc2Zvcm1lclVwY2FzdCgpKTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPEludGVnZXI+IGJ1aWxkSW5uZXJJdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRJbm5lclRyYW5zZm9ybWF0aW9uSXRlcmF0b3IodGhpcy5idWlsZE5lc3RlZEl0ZXJhdG9yKCkpOwotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8SW50ZWdlcj4gYnVpbGRVbm1vZGlmaWFibGVJdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRUcmFuc2Zvcm1hdGlvbkl0ZXJhdG9yKHRoaXMuYnVpbGRVbm1vZGlmaWFibGVOZXN0ZWRJdGVyYXRvcigpLCB0aGlzLmJ1aWxkVHJhbnNmb3JtZXIoKSk7Ci0JfQotCi0JcHJpdmF0ZSBJdGVyYXRvcjxJbnRlZ2VyPiBidWlsZFRyYW5zZm9ybWF0aW9uSXRlcmF0b3IoSXRlcmF0b3I8U3RyaW5nPiBuZXN0ZWRJdGVyYXRvciwgVHJhbnNmb3JtZXI8U3RyaW5nLCBJbnRlZ2VyPiB0cmFuc2Zvcm1lcikgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8U3RyaW5nLCBJbnRlZ2VyPihuZXN0ZWRJdGVyYXRvciwgdHJhbnNmb3JtZXIpOwotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8T2JqZWN0PiBidWlsZFRyYW5zZm9ybWF0aW9uSXRlcmF0b3JVcGNhc3QoSXRlcmF0b3I8U3RyaW5nPiBuZXN0ZWRJdGVyYXRvciwgVHJhbnNmb3JtZXI8T2JqZWN0LCBJbnRlZ2VyPiB0cmFuc2Zvcm1lcikgewotCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uSXRlcmF0b3I8T2JqZWN0LCBPYmplY3Q+KG5lc3RlZEl0ZXJhdG9yLCB0cmFuc2Zvcm1lcik7Ci0JfQotCi0JcHJpdmF0ZSBUcmFuc2Zvcm1lcjxTdHJpbmcsIEludGVnZXI+IGJ1aWxkVHJhbnNmb3JtZXIoKSB7Ci0JCS8vIHRyYW5zZm9ybSBlYWNoIHN0cmluZyBpbnRvIGFuIGludGVnZXIgd2l0aCBhIHZhbHVlIG9mIHRoZSBzdHJpbmcncyBsZW5ndGgKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1lcjxTdHJpbmcsIEludGVnZXI+KCkgewotCQkJcHVibGljIEludGVnZXIgdHJhbnNmb3JtKFN0cmluZyBuZXh0KSB7Ci0JCQkJcmV0dXJuIG5ldyBJbnRlZ2VyKG5leHQubGVuZ3RoKCkpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgVHJhbnNmb3JtZXI8T2JqZWN0LCBJbnRlZ2VyPiBidWlsZFRyYW5zZm9ybWVyVXBjYXN0KCkgewotCQkvLyB0cmFuc2Zvcm0gZWFjaCBzdHJpbmcgaW50byBhbiBpbnRlZ2VyIHdpdGggYSB2YWx1ZSBvZiB0aGUgc3RyaW5nJ3MgbGVuZ3RoCi0JCXJldHVybiBuZXcgVHJhbnNmb3JtZXI8T2JqZWN0LCBJbnRlZ2VyPigpIHsKLQkJCXB1YmxpYyBJbnRlZ2VyIHRyYW5zZm9ybShPYmplY3QgbmV4dCkgewotCQkJCXJldHVybiBuZXcgSW50ZWdlcigoKFN0cmluZykgbmV4dCkubGVuZ3RoKCkpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgSXRlcmF0b3I8SW50ZWdlcj4gYnVpbGRJbm5lclRyYW5zZm9ybWF0aW9uSXRlcmF0b3IoSXRlcmF0b3I8U3RyaW5nPiBuZXN0ZWRJdGVyYXRvcikgewotCQkvLyB0cmFuc2Zvcm0gZWFjaCBzdHJpbmcgaW50byBhbiBpbnRlZ2VyIHdpdGggYSB2YWx1ZSBvZiB0aGUgc3RyaW5nJ3MgbGVuZ3RoCi0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25JdGVyYXRvcjxTdHJpbmcsIEludGVnZXI+KG5lc3RlZEl0ZXJhdG9yKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBJbnRlZ2VyIHRyYW5zZm9ybShTdHJpbmcgbmV4dCkgewotCQkJCXJldHVybiBuZXcgSW50ZWdlcihuZXh0Lmxlbmd0aCgpKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPFN0cmluZz4gYnVpbGROZXN0ZWRJdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRDb2xsZWN0aW9uKCkuaXRlcmF0b3IoKTsKLQl9Ci0KLQlwcml2YXRlIEl0ZXJhdG9yPFN0cmluZz4gYnVpbGRVbm1vZGlmaWFibGVOZXN0ZWRJdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRVbm1vZGlmaWFibGVDb2xsZWN0aW9uKCkuaXRlcmF0b3IoKTsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb248U3RyaW5nPiBidWlsZENvbGxlY3Rpb24oKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWMuYWRkKCIxIik7Ci0JCWMuYWRkKCIyMiIpOwotCQljLmFkZCgiMzMzIik7Ci0JCWMuYWRkKCI0NDQ0Iik7Ci0JCWMuYWRkKCI1NTU1NSIpOwotCQljLmFkZCgiNjY2NjY2Iik7Ci0JCWMuYWRkKCI3Nzc3Nzc3Iik7Ci0JCWMuYWRkKCI4ODg4ODg4OCIpOwotCQlyZXR1cm4gYzsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb248U3RyaW5nPiBidWlsZFVubW9kaWZpYWJsZUNvbGxlY3Rpb24oKSB7Ci0JCXJldHVybiBDb2xsZWN0aW9ucy51bm1vZGlmaWFibGVDb2xsZWN0aW9uKHRoaXMuYnVpbGRDb2xsZWN0aW9uKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbnZhbGlkVHJhbnNmb3JtYXRpb25JdGVyYXRvcigpIHsKLQkJLy8gbWlzc2luZyBtZXRob2Qgb3ZlcnJpZGUKLQkJSXRlcmF0b3I8SW50ZWdlcj4gaXRlcmF0b3IgPSBuZXcgVHJhbnNmb3JtYXRpb25JdGVyYXRvcjxTdHJpbmcsIEludGVnZXI+KHRoaXMuYnVpbGRDb2xsZWN0aW9uKCkuaXRlcmF0b3IoKSk7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCUludGVnZXIgaW50ZWdlciA9IGl0ZXJhdG9yLm5leHQoKTsKLQkJCWZhaWwoImludmFsaWQgaW50ZWdlcjogIiArIGludGVnZXIpOwotCQl9IGNhdGNoIChVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIk5vU3VjaEVsZW1lbnRFeGNlcHRpb24gbm90IHRocm93biIsIGV4Q2F1Z2h0KTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL1RyYW5zZm9ybWF0aW9uTGlzdEl0ZXJhdG9yVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL1RyYW5zZm9ybWF0aW9uTGlzdEl0ZXJhdG9yVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZGM4YTJlMC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL2l0ZXJhdG9ycy9UcmFuc2Zvcm1hdGlvbkxpc3RJdGVyYXRvclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzMjEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5pdGVyYXRvcnM7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uczsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTm9TdWNoRWxlbWVudEV4Y2VwdGlvbjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuVHJhbnNmb3JtZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlRyYW5zZm9ybWF0aW9uTGlzdEl0ZXJhdG9yOwotCi1wdWJsaWMgY2xhc3MgVHJhbnNmb3JtYXRpb25MaXN0SXRlcmF0b3JUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBUcmFuc2Zvcm1hdGlvbkxpc3RJdGVyYXRvclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNOZXh0QW5kSGFzUHJldmlvdXMoKSB7Ci0JCWludCBpID0gMDsKLQkJTGlzdEl0ZXJhdG9yPEludGVnZXI+IHN0cmVhbSA9IHRoaXMuYnVpbGRJdGVyYXRvcigpOwotCi0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyg4LCBpKTsKLQotCQl3aGlsZSAoc3RyZWFtLmhhc1ByZXZpb3VzKCkpIHsKLQkJCXN0cmVhbS5wcmV2aW91cygpOwotCQkJaS0tOwotCQl9Ci0JCWFzc2VydEVxdWFscygwLCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTmV4dEFuZEhhc1ByZXZpb3VzVXBjYXN0KCkgewotCQlpbnQgaSA9IDA7Ci0JCUxpc3RJdGVyYXRvcjxPYmplY3Q+IHN0cmVhbSA9IHRoaXMuYnVpbGRJdGVyYXRvclVwY2FzdCgpOwotCi0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyg4LCBpKTsKLQotCQl3aGlsZSAoc3RyZWFtLmhhc1ByZXZpb3VzKCkpIHsKLQkJCXN0cmVhbS5wcmV2aW91cygpOwotCQkJaS0tOwotCQl9Ci0JCWFzc2VydEVxdWFscygwLCBpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW5uZXJIYXNOZXh0QW5kSGFzUHJldmlvdXMoKSB7Ci0JCWludCBpID0gMDsKLQkJTGlzdEl0ZXJhdG9yPEludGVnZXI+IHN0cmVhbSA9IHRoaXMuYnVpbGRJbm5lckl0ZXJhdG9yKCk7Ci0KLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCXN0cmVhbS5uZXh0KCk7Ci0JCQlpKys7Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDgsIGkpOwotCi0JCXdoaWxlIChzdHJlYW0uaGFzUHJldmlvdXMoKSkgewotCQkJc3RyZWFtLnByZXZpb3VzKCk7Ci0JCQlpLS07Ci0JCX0KLQkJYXNzZXJ0RXF1YWxzKDAsIGkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROZXh0QW5kUHJldmlvdXMoKSB7Ci0JCWludCBpID0gMDsKLQkJTGlzdEl0ZXJhdG9yPEludGVnZXI+IHN0cmVhbSA9IHRoaXMuYnVpbGRJdGVyYXRvcigpOwotCi0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlhc3NlcnRFcXVhbHMoKytpLCBzdHJlYW0ubmV4dCgpLmludFZhbHVlKCkpOwotCQl9Ci0KLQkJKytpOwotCi0JCXdoaWxlIChzdHJlYW0uaGFzUHJldmlvdXMoKSkgewotCQkJYXNzZXJ0RXF1YWxzKC0taSwgc3RyZWFtLnByZXZpb3VzKCkuaW50VmFsdWUoKSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW5uZXJOZXh0QW5kUHJldmlvdXMoKSB7Ci0JCWludCBpID0gMDsKLQkJTGlzdEl0ZXJhdG9yPEludGVnZXI+IHN0cmVhbSA9IHRoaXMuYnVpbGRJbm5lckl0ZXJhdG9yKCk7Ci0KLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCWFzc2VydEVxdWFscygrK2ksIHN0cmVhbS5uZXh0KCkuaW50VmFsdWUoKSk7Ci0JCX0KLQotCQkrK2k7Ci0KLQkJd2hpbGUgKHN0cmVhbS5oYXNQcmV2aW91cygpKSB7Ci0JCQlhc3NlcnRFcXVhbHMoLS1pLCBzdHJlYW0ucHJldmlvdXMoKS5pbnRWYWx1ZSgpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROZXh0SW5kZXhBbmRQcmV2aW91c0luZGV4KCkgewotCQlpbnQgaSA9IC0xOwotCQlMaXN0SXRlcmF0b3I8SW50ZWdlcj4gc3RyZWFtID0gdGhpcy5idWlsZEl0ZXJhdG9yKCk7Ci0KLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCWFzc2VydEVxdWFscygrK2ksIHN0cmVhbS5uZXh0SW5kZXgoKSk7Ci0JCQlzdHJlYW0ubmV4dCgpOwotCQl9Ci0KLQkJKytpOwotCi0JCXdoaWxlIChzdHJlYW0uaGFzUHJldmlvdXMoKSkgewotCQkJYXNzZXJ0RXF1YWxzKC0taSwgc3RyZWFtLnByZXZpb3VzSW5kZXgoKSk7Ci0JCQlzdHJlYW0ucHJldmlvdXMoKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbm5lck5leHRJbmRleEFuZFByZXZpb3VzSW5kZXgoKSB7Ci0JCWludCBpID0gLTE7Ci0JCUxpc3RJdGVyYXRvcjxJbnRlZ2VyPiBzdHJlYW0gPSB0aGlzLmJ1aWxkSW5uZXJJdGVyYXRvcigpOwotCi0JCXdoaWxlIChzdHJlYW0uaGFzTmV4dCgpKSB7Ci0JCQlhc3NlcnRFcXVhbHMoKytpLCBzdHJlYW0ubmV4dEluZGV4KCkpOwotCQkJc3RyZWFtLm5leHQoKTsKLQkJfQotCi0JCSsraTsKLQotCQl3aGlsZSAoc3RyZWFtLmhhc1ByZXZpb3VzKCkpIHsKLQkJCWFzc2VydEVxdWFscygtLWksIHN0cmVhbS5wcmV2aW91c0luZGV4KCkpOwotCQkJc3RyZWFtLnByZXZpb3VzKCk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlKCkgewotCQlMaXN0PFN0cmluZz4gbCA9IHRoaXMuYnVpbGRMaXN0KCk7Ci0JCWZvciAoTGlzdEl0ZXJhdG9yPEludGVnZXI+IHN0cmVhbSA9IHRoaXMuYnVpbGRJbm5lclRyYW5zZm9ybWF0aW9uTGlzdEl0ZXJhdG9yKGwubGlzdEl0ZXJhdG9yKCkpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJaWYgKHN0cmVhbS5uZXh0KCkuaW50VmFsdWUoKSA9PSAzKSB7Ci0JCQkJc3RyZWFtLnJlbW92ZSgpOwotCQkJfQotCQl9Ci0JCWFzc2VydEVxdWFscygibm90aGluZyByZW1vdmVkIiwgdGhpcy5idWlsZExpc3QoKS5zaXplKCkgLSAxLCBsLnNpemUoKSk7Ci0JCWFzc2VydEZhbHNlKCJlbGVtZW50IHN0aWxsIGluIGxpc3QiLCBsLmNvbnRhaW5zKCIzMzMiKSk7Ci0JCWFzc2VydFRydWUoIndyb25nIGVsZW1lbnQgcmVtb3ZlZCIsIGwuY29udGFpbnMoIjIyIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbm5lclJlbW92ZSgpIHsKLQkJTGlzdDxTdHJpbmc+IGwgPSB0aGlzLmJ1aWxkTGlzdCgpOwotCQlmb3IgKExpc3RJdGVyYXRvcjxJbnRlZ2VyPiBzdHJlYW0gPSB0aGlzLmJ1aWxkVHJhbnNmb3JtYXRpb25MaXN0SXRlcmF0b3IobC5saXN0SXRlcmF0b3IoKSwgdGhpcy5idWlsZFRyYW5zZm9ybWVyKCkpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJaWYgKHN0cmVhbS5uZXh0KCkuaW50VmFsdWUoKSA9PSAzKSB7Ci0JCQkJc3RyZWFtLnJlbW92ZSgpOwotCQkJfQotCQl9Ci0JCWFzc2VydEVxdWFscygibm90aGluZyByZW1vdmVkIiwgdGhpcy5idWlsZExpc3QoKS5zaXplKCkgLSAxLCBsLnNpemUoKSk7Ci0JCWFzc2VydEZhbHNlKCJlbGVtZW50IHN0aWxsIGluIGxpc3QiLCBsLmNvbnRhaW5zKCIzMzMiKSk7Ci0JCWFzc2VydFRydWUoIndyb25nIGVsZW1lbnQgcmVtb3ZlZCIsIGwuY29udGFpbnMoIjIyIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbk9uQWRkKCkgewotCQlMaXN0SXRlcmF0b3I8SW50ZWdlcj4gc3RyZWFtID0gdGhpcy5idWlsZEl0ZXJhdG9yKCk7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXN0cmVhbS5hZGQobmV3IEludGVnZXIoMCkpOwotCQkJZmFpbCgiZXhjZXB0aW9uIG5vdCB0aHJvd24iKTsKLQkJfSBjYXRjaCAoVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gZSkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbk9uU2V0KCkgewotCQlMaXN0SXRlcmF0b3I8SW50ZWdlcj4gc3RyZWFtID0gdGhpcy5idWlsZEl0ZXJhdG9yKCk7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXN0cmVhbS5zZXQobmV3IEludGVnZXIoMCkpOwotCQkJZmFpbCgiZXhjZXB0aW9uIG5vdCB0aHJvd24iKTsKLQkJfSBjYXRjaCAoVW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24gZSkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROb1N1Y2hFbGVtZW50RXhjZXB0aW9uKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCUxpc3RJdGVyYXRvcjxJbnRlZ2VyPiBzdHJlYW0gPSB0aGlzLmJ1aWxkSXRlcmF0b3IoKTsKLQkJSW50ZWdlciBpbnRlZ2VyID0gbnVsbDsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCWludGVnZXIgPSBzdHJlYW0ubmV4dCgpOwotCQl9Ci0JCXRyeSB7Ci0JCQlpbnRlZ2VyID0gc3RyZWFtLm5leHQoKTsKLQkJfSBjYXRjaCAoTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIk5vU3VjaEVsZW1lbnRFeGNlcHRpb24gbm90IHRocm93bjogIiArIGludGVnZXIsIGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VW5zdXBwb3J0ZWRPcGVyYXRpb25FeGNlcHRpb24oKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJZm9yIChJdGVyYXRvcjxJbnRlZ2VyPiBzdHJlYW0gPSB0aGlzLmJ1aWxkVW5tb2RpZmlhYmxlSXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTspIHsKLQkJCWludCBpID0gc3RyZWFtLm5leHQoKS5pbnRWYWx1ZSgpOwotCQkJaWYgKGkgPT0gMykgewotCQkJCXRyeSB7Ci0JCQkJCXN0cmVhbS5yZW1vdmUoKTsKLQkJCQl9IGNhdGNoIChVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbiBleCkgewotCQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQkJfQotCQkJfQotCQl9Ci0JCWFzc2VydFRydWUoIlVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy5idWlsZEl0ZXJhdG9yKCkucmVtb3ZlKCk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxTdGF0ZUV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoIklsbGVnYWxTdGF0ZUV4Y2VwdGlvbiBub3QgdGhyb3duIiwgZXhDYXVnaHQpOwotCX0KLQotCXByaXZhdGUgTGlzdEl0ZXJhdG9yPEludGVnZXI+IGJ1aWxkSXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkVHJhbnNmb3JtYXRpb25MaXN0SXRlcmF0b3IodGhpcy5idWlsZE5lc3RlZEl0ZXJhdG9yKCksIHRoaXMuYnVpbGRUcmFuc2Zvcm1lcigpKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RJdGVyYXRvcjxPYmplY3Q+IGJ1aWxkSXRlcmF0b3JVcGNhc3QoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkVHJhbnNmb3JtYXRpb25MaXN0SXRlcmF0b3JVcGNhc3QodGhpcy5idWlsZE5lc3RlZEl0ZXJhdG9yKCksIHRoaXMuYnVpbGRUcmFuc2Zvcm1lclVwY2FzdCgpKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RJdGVyYXRvcjxJbnRlZ2VyPiBidWlsZElubmVySXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkSW5uZXJUcmFuc2Zvcm1hdGlvbkxpc3RJdGVyYXRvcih0aGlzLmJ1aWxkTmVzdGVkSXRlcmF0b3IoKSk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0SXRlcmF0b3I8SW50ZWdlcj4gYnVpbGRVbm1vZGlmaWFibGVJdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRUcmFuc2Zvcm1hdGlvbkxpc3RJdGVyYXRvcih0aGlzLmJ1aWxkVW5tb2RpZmlhYmxlTmVzdGVkSXRlcmF0b3IoKSwgdGhpcy5idWlsZFRyYW5zZm9ybWVyKCkpOwotCX0KLQotCXByaXZhdGUgTGlzdEl0ZXJhdG9yPEludGVnZXI+IGJ1aWxkVHJhbnNmb3JtYXRpb25MaXN0SXRlcmF0b3IoTGlzdEl0ZXJhdG9yPFN0cmluZz4gbmVzdGVkSXRlcmF0b3IsIFRyYW5zZm9ybWVyPFN0cmluZywgSW50ZWdlcj4gdHJhbnNmb3JtZXIpIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkxpc3RJdGVyYXRvcjxTdHJpbmcsIEludGVnZXI+KG5lc3RlZEl0ZXJhdG9yLCB0cmFuc2Zvcm1lcik7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0SXRlcmF0b3I8T2JqZWN0PiBidWlsZFRyYW5zZm9ybWF0aW9uTGlzdEl0ZXJhdG9yVXBjYXN0KExpc3RJdGVyYXRvcjxTdHJpbmc+IG5lc3RlZEl0ZXJhdG9yLCBUcmFuc2Zvcm1lcjxPYmplY3QsIEludGVnZXI+IHRyYW5zZm9ybWVyKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25MaXN0SXRlcmF0b3I8T2JqZWN0LCBPYmplY3Q+KG5lc3RlZEl0ZXJhdG9yLCB0cmFuc2Zvcm1lcik7Ci0JfQotCi0JcHJpdmF0ZSBUcmFuc2Zvcm1lcjxTdHJpbmcsIEludGVnZXI+IGJ1aWxkVHJhbnNmb3JtZXIoKSB7Ci0JCS8vIHRyYW5zZm9ybSBlYWNoIHN0cmluZyBpbnRvIGFuIGludGVnZXIgd2l0aCBhIHZhbHVlIG9mIHRoZSBzdHJpbmcncyBsZW5ndGgKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1lcjxTdHJpbmcsIEludGVnZXI+KCkgewotCQkJcHVibGljIEludGVnZXIgdHJhbnNmb3JtKFN0cmluZyBuZXh0KSB7Ci0JCQkJcmV0dXJuIG5ldyBJbnRlZ2VyKG5leHQubGVuZ3RoKCkpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgVHJhbnNmb3JtZXI8T2JqZWN0LCBJbnRlZ2VyPiBidWlsZFRyYW5zZm9ybWVyVXBjYXN0KCkgewotCQkvLyB0cmFuc2Zvcm0gZWFjaCBzdHJpbmcgaW50byBhbiBpbnRlZ2VyIHdpdGggYSB2YWx1ZSBvZiB0aGUgc3RyaW5nJ3MgbGVuZ3RoCi0JCXJldHVybiBuZXcgVHJhbnNmb3JtZXI8T2JqZWN0LCBJbnRlZ2VyPigpIHsKLQkJCXB1YmxpYyBJbnRlZ2VyIHRyYW5zZm9ybShPYmplY3QgbmV4dCkgewotCQkJCXJldHVybiBuZXcgSW50ZWdlcigoKFN0cmluZykgbmV4dCkubGVuZ3RoKCkpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgTGlzdEl0ZXJhdG9yPEludGVnZXI+IGJ1aWxkSW5uZXJUcmFuc2Zvcm1hdGlvbkxpc3RJdGVyYXRvcihMaXN0SXRlcmF0b3I8U3RyaW5nPiBuZXN0ZWRJdGVyYXRvcikgewotCQkvLyB0cmFuc2Zvcm0gZWFjaCBzdHJpbmcgaW50byBhbiBpbnRlZ2VyIHdpdGggYSB2YWx1ZSBvZiB0aGUgc3RyaW5nJ3MgbGVuZ3RoCi0JCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25MaXN0SXRlcmF0b3I8U3RyaW5nLCBJbnRlZ2VyPihuZXN0ZWRJdGVyYXRvcikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSW50ZWdlciB0cmFuc2Zvcm0oU3RyaW5nIG5leHQpIHsKLQkJCQlyZXR1cm4gbmV3IEludGVnZXIobmV4dC5sZW5ndGgoKSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0SXRlcmF0b3I8U3RyaW5nPiBidWlsZE5lc3RlZEl0ZXJhdG9yKCkgewotCQlyZXR1cm4gdGhpcy5idWlsZExpc3QoKS5saXN0SXRlcmF0b3IoKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RJdGVyYXRvcjxTdHJpbmc+IGJ1aWxkVW5tb2RpZmlhYmxlTmVzdGVkSXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkVW5tb2RpZmlhYmxlTGlzdCgpLmxpc3RJdGVyYXRvcigpOwotCX0KLQotCXByaXZhdGUgTGlzdDxTdHJpbmc+IGJ1aWxkTGlzdCgpIHsKLQkJTGlzdDxTdHJpbmc+IGwgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJbC5hZGQoIjEiKTsKLQkJbC5hZGQoIjIyIik7Ci0JCWwuYWRkKCIzMzMiKTsKLQkJbC5hZGQoIjQ0NDQiKTsKLQkJbC5hZGQoIjU1NTU1Iik7Ci0JCWwuYWRkKCI2NjY2NjYiKTsKLQkJbC5hZGQoIjc3Nzc3NzciKTsKLQkJbC5hZGQoIjg4ODg4ODg4Iik7Ci0JCXJldHVybiBsOwotCX0KLQotCXByaXZhdGUgTGlzdDxTdHJpbmc+IGJ1aWxkVW5tb2RpZmlhYmxlTGlzdCgpIHsKLQkJcmV0dXJuIENvbGxlY3Rpb25zLnVubW9kaWZpYWJsZUxpc3QodGhpcy5idWlsZExpc3QoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEludmFsaWRUcmFuc2Zvcm1hdGlvbkxpc3RJdGVyYXRvcigpIHsKLQkJLy8gbWlzc2luZyBtZXRob2Qgb3ZlcnJpZGUKLQkJSXRlcmF0b3I8SW50ZWdlcj4gaXRlcmF0b3IgPSBuZXcgVHJhbnNmb3JtYXRpb25MaXN0SXRlcmF0b3I8U3RyaW5nLCBJbnRlZ2VyPih0aGlzLmJ1aWxkTGlzdCgpLmxpc3RJdGVyYXRvcigpKTsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJSW50ZWdlciBpbnRlZ2VyID0gaXRlcmF0b3IubmV4dCgpOwotCQkJZmFpbCgiaW52YWxpZCBpbnRlZ2VyOiAiICsgaW50ZWdlcik7Ci0JCX0gY2F0Y2ggKFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBub3QgdGhyb3duIiwgZXhDYXVnaHQpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvVHJlZUl0ZXJhdG9yVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvaXRlcmF0b3JzL1RyZWVJdGVyYXRvclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGUxNWYxYTguLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9pdGVyYXRvcnMvVHJlZUl0ZXJhdG9yVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDIxMCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLml0ZXJhdG9yczsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5Ob1N1Y2hFbGVtZW50RXhjZXB0aW9uOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuVHJlZUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIFRyZWVJdGVyYXRvclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCS8qKiB0aGlzIHdpbGwgYmUgcG9wdWxhdGVkIHdpdGggYWxsIHRoZSBub2RlcyBjcmVhdGVkIGZvciB0aGUgdGVzdCAqLwotCUNvbGxlY3Rpb248VHJlZU5vZGU+IG5vZGVzID0gbmV3IEFycmF5TGlzdDxUcmVlTm9kZT4oKTsKLQotCXB1YmxpYyBUcmVlSXRlcmF0b3JUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc05leHQxKCkgewotCQl0aGlzLnZlcmlmeUhhc05leHQodGhpcy5idWlsZFRyZWVJdGVyYXRvcjEoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc05leHQyKCkgewotCQl0aGlzLnZlcmlmeUhhc05leHQodGhpcy5idWlsZFRyZWVJdGVyYXRvcjIoKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUhhc05leHQoSXRlcmF0b3I8VHJlZU5vZGU+IGl0ZXJhdG9yKSB7Ci0JCWludCBpID0gMDsKLQkJd2hpbGUgKGl0ZXJhdG9yLmhhc05leHQoKSkgewotCQkJaXRlcmF0b3IubmV4dCgpOwotCQkJaSsrOwotCQl9Ci0JCWFzc2VydEVxdWFscyh0aGlzLm5vZGVzLnNpemUoKSwgaSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5leHQxKCkgewotCQl0aGlzLnZlcmlmeU5leHQodGhpcy5idWlsZFRyZWVJdGVyYXRvcjEoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5leHQyKCkgewotCQl0aGlzLnZlcmlmeU5leHQodGhpcy5idWlsZFRyZWVJdGVyYXRvcjIoKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeU5leHQoSXRlcmF0b3I8VHJlZU5vZGU+IGl0ZXJhdG9yKSB7Ci0JCXdoaWxlIChpdGVyYXRvci5oYXNOZXh0KCkpIHsKLQkJCWFzc2VydFRydWUoImJvZ3VzIGVsZW1lbnQiLCB0aGlzLm5vZGVzLmNvbnRhaW5zKGl0ZXJhdG9yLm5leHQoKSkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5vU3VjaEVsZW1lbnRFeGNlcHRpb24xKCkgewotCQl0aGlzLnZlcmlmeU5vU3VjaEVsZW1lbnRFeGNlcHRpb24odGhpcy5idWlsZFRyZWVJdGVyYXRvcjEoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5vU3VjaEVsZW1lbnRFeGNlcHRpb24yKCkgewotCQl0aGlzLnZlcmlmeU5vU3VjaEVsZW1lbnRFeGNlcHRpb24odGhpcy5idWlsZFRyZWVJdGVyYXRvcjIoKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeU5vU3VjaEVsZW1lbnRFeGNlcHRpb24oSXRlcmF0b3I8VHJlZU5vZGU+IGl0ZXJhdG9yKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJd2hpbGUgKGl0ZXJhdG9yLmhhc05leHQoKSkgewotCQkJaXRlcmF0b3IubmV4dCgpOwotCQl9Ci0JCXRyeSB7Ci0JCQlpdGVyYXRvci5uZXh0KCk7Ci0JCX0gY2F0Y2ggKE5vU3VjaEVsZW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKCJOb1N1Y2hFbGVtZW50RXhjZXB0aW9uIG5vdCB0aHJvd24iLCBleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZTEoKSB7Ci0JCXRoaXMudmVyaWZ5UmVtb3ZlKHRoaXMuYnVpbGRUcmVlSXRlcmF0b3IxKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmUyKCkgewotCQl0aGlzLnZlcmlmeVJlbW92ZSh0aGlzLmJ1aWxkVHJlZUl0ZXJhdG9yMigpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UmVtb3ZlKEl0ZXJhdG9yPFRyZWVOb2RlPiBpdGVyYXRvcikgewotCQlTdHJpbmcgcGFyZW50TmFtZSA9ICJjaGlsZCAyIjsKLQkJU3RyaW5nIGNoaWxkTmFtZSA9ICJncmFuZGNoaWxkIDJBIjsKLQkJaW50IHN0YXJ0U2l6ZSA9IHRoaXMuY2hpbGRyZW5TaXplKHBhcmVudE5hbWUpOwotCQl3aGlsZSAoaXRlcmF0b3IuaGFzTmV4dCgpKSB7Ci0JCQlUcmVlTm9kZSBub2RlID0gaXRlcmF0b3IubmV4dCgpOwotCQkJaWYgKG5vZGUuZ2V0TmFtZSgpLmVxdWFscyhjaGlsZE5hbWUpKSB7Ci0JCQkJaXRlcmF0b3IucmVtb3ZlKCk7Ci0JCQl9Ci0JCX0KLQkJaW50IGVuZFNpemUgPSB0aGlzLmNoaWxkcmVuU2l6ZShwYXJlbnROYW1lKTsKLQkJYXNzZXJ0RXF1YWxzKHN0YXJ0U2l6ZSAtIDEsIGVuZFNpemUpOwotCX0KLQotCXByaXZhdGUgaW50IGNoaWxkcmVuU2l6ZShTdHJpbmcgbm9kZU5hbWUpIHsKLQkJZm9yIChJdGVyYXRvcjxUcmVlTm9kZT4gc3RyZWFtID0gdGhpcy5ub2Rlcy5pdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOykgewotCQkJVHJlZU5vZGUgbm9kZSA9IHN0cmVhbS5uZXh0KCk7Ci0JCQlpZiAobm9kZS5nZXROYW1lKCkuZXF1YWxzKG5vZGVOYW1lKSkgewotCQkJCXJldHVybiBub2RlLmNoaWxkcmVuU2l6ZSgpOwotCQkJfQotCQl9Ci0JCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24obm9kZU5hbWUpOwotCX0KLQotCS8qKgotCSAqIGJ1aWxkIGEgdHJlZSBpdGVyYXRvciB3aXRoIGFuIGV4cGxpY2l0IG1pZHdpZmUKLQkgKi8KLQlwcml2YXRlIEl0ZXJhdG9yPFRyZWVOb2RlPiBidWlsZFRyZWVJdGVyYXRvcjEoKSB7Ci0JCXJldHVybiBuZXcgVHJlZUl0ZXJhdG9yPFRyZWVOb2RlPih0aGlzLmJ1aWxkVHJlZSgpLCB0aGlzLmJ1aWxkTWlkd2lmZSgpKTsKLQl9Ci0KLQlwcml2YXRlIFRyZWVJdGVyYXRvci5NaWR3aWZlPFRyZWVOb2RlPiBidWlsZE1pZHdpZmUoKSB7Ci0JCXJldHVybiBuZXcgVHJlZUl0ZXJhdG9yLk1pZHdpZmU8VHJlZU5vZGU+KCkgewotCQkJcHVibGljIEl0ZXJhdG9yPFRyZWVOb2RlPiBjaGlsZHJlbihUcmVlTm9kZSBuZXh0KSB7Ci0JCQkJcmV0dXJuIG5leHQuY2hpbGRyZW4oKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQkvKioKLQkgKiBidWlsZCBhIHRyZWUgaXRlcmF0b3Igd2l0aCBhbiBvdmVycmlkZQotCSAqLwotCXByaXZhdGUgSXRlcmF0b3I8VHJlZU5vZGU+IGJ1aWxkVHJlZUl0ZXJhdG9yMigpIHsKLQkJcmV0dXJuIG5ldyBUcmVlSXRlcmF0b3I8VHJlZU5vZGU+KHRoaXMuYnVpbGRUcmVlKCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIEl0ZXJhdG9yPFRyZWVOb2RlPiBjaGlsZHJlbihUcmVlTm9kZSBuZXh0KSB7Ci0JCQkJcmV0dXJuIG5leHQuY2hpbGRyZW4oKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW52YWxpZFRyZWVJdGVyYXRvcigpIHsKLQkJLy8gbWlzc2luZyBtZXRob2Qgb3ZlcnJpZGUKLQkJSXRlcmF0b3I8VHJlZU5vZGU+IGl0ZXJhdG9yID0gbmV3IFRyZWVJdGVyYXRvcjxUcmVlTm9kZT4odGhpcy5idWlsZFRyZWUoKSk7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCVRyZWVOb2RlIHRuID0gaXRlcmF0b3IubmV4dCgpOwotCQkJZmFpbCgiaW52YWxpZCB0cmVlIG5vZGU6ICIgKyB0bik7Ci0JCX0gY2F0Y2ggKFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZSgiTm9TdWNoRWxlbWVudEV4Y2VwdGlvbiBub3QgdGhyb3duIiwgZXhDYXVnaHQpOwotCX0KLQotCXByaXZhdGUgVHJlZU5vZGUgYnVpbGRUcmVlKCkgewotCQlUcmVlTm9kZSByb290ID0gbmV3IFRyZWVOb2RlKCJyb290Iik7Ci0JCVRyZWVOb2RlIGNoaWxkMSA9IG5ldyBUcmVlTm9kZShyb290LCAiY2hpbGQgMSIpOwotCQluZXcgVHJlZU5vZGUoY2hpbGQxLCAiZ3JhbmRjaGlsZCAxQSIpOwotCQlUcmVlTm9kZSBjaGlsZDIgPSBuZXcgVHJlZU5vZGUocm9vdCwgImNoaWxkIDIiKTsKLQkJbmV3IFRyZWVOb2RlKGNoaWxkMiwgImdyYW5kY2hpbGQgMkEiKTsKLQkJVHJlZU5vZGUgZ3JhbmRjaGlsZDJCID0gbmV3IFRyZWVOb2RlKGNoaWxkMiwgImdyYW5kY2hpbGQgMkIiKTsKLQkJbmV3IFRyZWVOb2RlKGdyYW5kY2hpbGQyQiwgImdyZWF0LWdyYW5kY2hpbGQgMkIxIik7Ci0JCW5ldyBUcmVlTm9kZShncmFuZGNoaWxkMkIsICJncmVhdC1ncmFuZGNoaWxkIDJCMiIpOwotCQlUcmVlTm9kZSBncmFuZGNoaWxkMkMgPSBuZXcgVHJlZU5vZGUoY2hpbGQyLCAiZ3JhbmRjaGlsZCAyQyIpOwotCQluZXcgVHJlZU5vZGUoZ3JhbmRjaGlsZDJDLCAiZ3JlYXQtZ3JhbmRjaGlsZCAyQzEiKTsKLQkJbmV3IFRyZWVOb2RlKHJvb3QsICJjaGlsZCAzIik7Ci0JCXJldHVybiByb290OwotCX0KLQotCXByaXZhdGUgY2xhc3MgVHJlZU5vZGUgewotCQlwcml2YXRlIFN0cmluZyBuYW1lOwotCQlwcml2YXRlIENvbGxlY3Rpb248VHJlZU5vZGU+IGNoaWxkcmVuID0gbmV3IEFycmF5TGlzdDxUcmVlTm9kZT4oKTsKLQotCQlwdWJsaWMgVHJlZU5vZGUoU3RyaW5nIG5hbWUpIHsKLQkJCXN1cGVyKCk7Ci0JCQlUcmVlSXRlcmF0b3JUZXN0cy50aGlzLm5vZGVzLmFkZCh0aGlzKTsgLy8gbG9nIG5vZGUKLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCX0KLQotCQlwdWJsaWMgVHJlZU5vZGUoVHJlZU5vZGUgcGFyZW50LCBTdHJpbmcgbmFtZSkgewotCQkJdGhpcyhuYW1lKTsKLQkJCXBhcmVudC5hZGRDaGlsZCh0aGlzKTsKLQkJfQotCi0JCXB1YmxpYyBTdHJpbmcgZ2V0TmFtZSgpIHsKLQkJCXJldHVybiB0aGlzLm5hbWU7Ci0JCX0KLQotCQlwcml2YXRlIHZvaWQgYWRkQ2hpbGQoVHJlZU5vZGUgY2hpbGQpIHsKLQkJCXRoaXMuY2hpbGRyZW4uYWRkKGNoaWxkKTsKLQkJfQotCi0JCXB1YmxpYyBJdGVyYXRvcjxUcmVlTm9kZT4gY2hpbGRyZW4oKSB7Ci0JCQlyZXR1cm4gdGhpcy5jaGlsZHJlbi5pdGVyYXRvcigpOwotCQl9Ci0KLQkJcHVibGljIGludCBjaGlsZHJlblNpemUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5jaGlsZHJlbi5zaXplKCk7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiVHJlZU5vZGUoIiArIHRoaXMubmFtZSArICIpIjsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC9BYnN0cmFjdE1vZGVsVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvQWJzdHJhY3RNb2RlbFRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQyYTE0ZGIuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC9BYnN0cmFjdE1vZGVsVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE3MjEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbDsKLQotaW1wb3J0IGphdmEuaW8uU2VyaWFsaXphYmxlOwotaW1wb3J0IGphdmEudXRpbC5BcnJheXM7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5DaGFuZ2VTdXBwb3J0OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LkNvbGxlY3Rpb25DaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5MaXN0Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5TdGF0ZUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlRyZWVDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Db2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuTGlzdENoYW5nZUFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuTGlzdENoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuU3RhdGVDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5UcmVlQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBBYnN0cmFjdE1vZGVsVGVzdHMKLQlleHRlbmRzIFRlc3RDYXNlCi0JaW1wbGVtZW50cyBTdGF0ZUNoYW5nZUxpc3RlbmVyLCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyLCBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIsIExpc3RDaGFuZ2VMaXN0ZW5lciwgVHJlZUNoYW5nZUxpc3RlbmVyCi17Ci0JcHJpdmF0ZSBUZXN0TW9kZWwgdGVzdE1vZGVsOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBURVNUX1RPX1NUUklORyA9ICJ0aGlzIGlzIGEgdGVzdCI7Ci0KLQlwcml2YXRlIFN0YXRlQ2hhbmdlRXZlbnQgc3RhdGVDaGFuZ2VFdmVudDsKLQlwcml2YXRlIGJvb2xlYW4gc3RhdGVDaGFuZ2VkQ2FsbGVkID0gZmFsc2U7Ci0KLQlwcml2YXRlIFByb3BlcnR5Q2hhbmdlRXZlbnQgcHJvcGVydHlDaGFuZ2VFdmVudDsKLQlwcml2YXRlIGJvb2xlYW4gcHJvcGVydHlDaGFuZ2VDYWxsZWQgPSBmYWxzZTsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgUFJPUEVSVFlfTkFNRSA9ICJwcm9wZXJ0eU5hbWUiOwotCXN0YXRpYyBmaW5hbCBPYmplY3QgT0xEX09CSkVDVF9WQUxVRSA9IG5ldyBPYmplY3QoKTsKLQlzdGF0aWMgZmluYWwgT2JqZWN0IE5FV19PQkpFQ1RfVkFMVUUgPSBuZXcgT2JqZWN0KCk7Ci0Jc3RhdGljIGZpbmFsIEludGVnZXIgT0xEX0lOVF9WQUxVRSA9IG5ldyBJbnRlZ2VyKDI3KTsKLQlzdGF0aWMgZmluYWwgSW50ZWdlciBORVdfSU5UX1ZBTFVFID0gbmV3IEludGVnZXIoNDIpOwotCXN0YXRpYyBmaW5hbCBCb29sZWFuIE9MRF9CT09MRUFOX1ZBTFVFID0gQm9vbGVhbi5UUlVFOwotCXN0YXRpYyBmaW5hbCBCb29sZWFuIE5FV19CT09MRUFOX1ZBTFVFID0gQm9vbGVhbi5GQUxTRTsKLQotCXByaXZhdGUgQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGNvbGxlY3Rpb25DaGFuZ2VFdmVudDsKLQlwcml2YXRlIGJvb2xlYW4gaXRlbXNBZGRlZENvbGxlY3Rpb25DYWxsZWQgPSBmYWxzZTsKLQlwcml2YXRlIGJvb2xlYW4gaXRlbXNSZW1vdmVkQ29sbGVjdGlvbkNhbGxlZCA9IGZhbHNlOwotCXByaXZhdGUgYm9vbGVhbiBjb2xsZWN0aW9uQ2hhbmdlZENhbGxlZCA9IGZhbHNlOwotCXByaXZhdGUgYm9vbGVhbiBjb2xsZWN0aW9uQ2xlYXJlZENhbGxlZCA9IGZhbHNlOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBDT0xMRUNUSU9OX05BTUUgPSAiY29sbGVjdGlvbk5hbWUiOwotCXN0YXRpYyBmaW5hbCBPYmplY3QgQURERURfT0JKRUNUX1ZBTFVFID0gbmV3IE9iamVjdCgpOwotCXN0YXRpYyBmaW5hbCBPYmplY3QgUkVNT1ZFRF9PQkpFQ1RfVkFMVUUgPSBuZXcgT2JqZWN0KCk7Ci0Jc3RhdGljIGZpbmFsIGludCBUQVJHRVRfSU5ERVggPSA3OwotCXN0YXRpYyBmaW5hbCBpbnQgU09VUkNFX0lOREVYID0gMjI7Ci0KLQlwcml2YXRlIExpc3RDaGFuZ2VFdmVudCBsaXN0Q2hhbmdlRXZlbnQ7Ci0JcHJpdmF0ZSBib29sZWFuIGl0ZW1zQWRkZWRMaXN0Q2FsbGVkID0gZmFsc2U7Ci0JcHJpdmF0ZSBib29sZWFuIGl0ZW1zUmVtb3ZlZExpc3RDYWxsZWQgPSBmYWxzZTsKLQlwcml2YXRlIGJvb2xlYW4gaXRlbXNSZXBsYWNlZExpc3RDYWxsZWQgPSBmYWxzZTsKLQlwcml2YXRlIGJvb2xlYW4gaXRlbXNNb3ZlZExpc3RDYWxsZWQgPSBmYWxzZTsKLQlwcml2YXRlIGJvb2xlYW4gbGlzdENoYW5nZWRDYWxsZWQgPSBmYWxzZTsKLQlwcml2YXRlIGJvb2xlYW4gbGlzdENsZWFyZWRDYWxsZWQgPSBmYWxzZTsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgTElTVF9OQU1FID0gImxpc3ROYW1lIjsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBpbnQgQUREX0lOREVYID0gMzsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBpbnQgUkVNT1ZFX0lOREVYID0gNTsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBpbnQgUkVQTEFDRV9JTkRFWCA9IDI7Ci0KLQlwcml2YXRlIFRyZWVDaGFuZ2VFdmVudCB0cmVlQ2hhbmdlRXZlbnQ7Ci0JcHJpdmF0ZSBib29sZWFuIG5vZGVBZGRlZENhbGxlZCA9IGZhbHNlOwotCXByaXZhdGUgYm9vbGVhbiBub2RlUmVtb3ZlZENhbGxlZCA9IGZhbHNlOwotCXByaXZhdGUgYm9vbGVhbiB0cmVlQ2hhbmdlZENhbGxlZCA9IGZhbHNlOwotCXByaXZhdGUgYm9vbGVhbiB0cmVlQ2xlYXJlZENhbGxlZCA9IGZhbHNlOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBUUkVFX05BTUUgPSAidHJlZU5hbWUiOwotCXN0YXRpYyBmaW5hbCBPYmplY3RbXSBPQkpFQ1RfQVJSQVlfUEFUSCA9IHtuZXcgT2JqZWN0KCksIG5ldyBPYmplY3QoKSwgbmV3IFN0cmluZygpfTsKLQlzdGF0aWMgZmluYWwgT2JqZWN0W10gRU1QVFlfUEFUSCA9IHt9OwotCi0JcHVibGljIEFic3RyYWN0TW9kZWxUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0JCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy50ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RGaXJlU3RhdGVDaGFuZ2UoKSB7Ci0JCXRoaXMuc3RhdGVDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMuc3RhdGVDaGFuZ2VkQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZFN0YXRlQ2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlU3RhdGVDaGFuZ2UoKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLnN0YXRlQ2hhbmdlRXZlbnQpOwotCQlhc3NlcnRFcXVhbHModGhpcy50ZXN0TW9kZWwsIHRoaXMuc3RhdGVDaGFuZ2VFdmVudC5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydFRydWUodGhpcy5zdGF0ZUNoYW5nZWRDYWxsZWQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RGaXJlUHJvcGVydHlDaGFuZ2VPYmplY3RPYmplY3QoKSB7Ci0JCXRoaXMucHJvcGVydHlDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMucHJvcGVydHlDaGFuZ2VDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVQcm9wZXJ0eUNoYW5nZU9iamVjdE9iamVjdCgpOwotCQl0aGlzLnZlcmlmeVByb3BlcnR5Q2hhbmdlRXZlbnQoT0xEX09CSkVDVF9WQUxVRSwgTkVXX09CSkVDVF9WQUxVRSk7Ci0JCWFzc2VydFRydWUodGhpcy5wcm9wZXJ0eUNoYW5nZUNhbGxlZCk7Ci0KLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUNhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZVByb3BlcnR5Q2hhbmdlT2JqZWN0T2JqZWN0KCk7Ci0JCWFzc2VydE51bGwodGhpcy5wcm9wZXJ0eUNoYW5nZUV2ZW50KTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5wcm9wZXJ0eUNoYW5nZUNhbGxlZCk7Ci0KLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUNhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFBST1BFUlRZX05BTUUsIHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZVByb3BlcnR5Q2hhbmdlT2JqZWN0T2JqZWN0KCk7Ci0JCXRoaXMudmVyaWZ5UHJvcGVydHlDaGFuZ2VFdmVudChPTERfT0JKRUNUX1ZBTFVFLCBORVdfT0JKRUNUX1ZBTFVFKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnByb3BlcnR5Q2hhbmdlQ2FsbGVkKTsKLQotCQl0aGlzLnByb3BlcnR5Q2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLnByb3BlcnR5Q2hhbmdlQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUFJPUEVSVFlfTkFNRSwgdGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlUHJvcGVydHlDaGFuZ2VPYmplY3RPYmplY3QoKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLnByb3BlcnR5Q2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnByb3BlcnR5Q2hhbmdlQ2FsbGVkKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RmlyZVByb3BlcnR5Q2hhbmdlT2JqZWN0KCkgewotCQl0aGlzLnByb3BlcnR5Q2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLnByb3BlcnR5Q2hhbmdlQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlUHJvcGVydHlDaGFuZ2VPYmplY3QoKTsKLQkJdGhpcy52ZXJpZnlQcm9wZXJ0eUNoYW5nZUV2ZW50KG51bGwsIE5FV19PQkpFQ1RfVkFMVUUpOwotCQlhc3NlcnRUcnVlKHRoaXMucHJvcGVydHlDaGFuZ2VDYWxsZWQpOwotCi0JCXRoaXMucHJvcGVydHlDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMucHJvcGVydHlDaGFuZ2VDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVQcm9wZXJ0eUNoYW5nZU9iamVjdCgpOwotCQlhc3NlcnROdWxsKHRoaXMucHJvcGVydHlDaGFuZ2VFdmVudCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMucHJvcGVydHlDaGFuZ2VDYWxsZWQpOwotCi0JCXRoaXMucHJvcGVydHlDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMucHJvcGVydHlDaGFuZ2VDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQUk9QRVJUWV9OQU1FLCB0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVQcm9wZXJ0eUNoYW5nZU9iamVjdCgpOwotCQl0aGlzLnZlcmlmeVByb3BlcnR5Q2hhbmdlRXZlbnQobnVsbCwgTkVXX09CSkVDVF9WQUxVRSk7Ci0JCWFzc2VydFRydWUodGhpcy5wcm9wZXJ0eUNoYW5nZUNhbGxlZCk7Ci0KLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUNhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFBST1BFUlRZX05BTUUsIHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZVByb3BlcnR5Q2hhbmdlT2JqZWN0KCk7Ci0JCWFzc2VydE51bGwodGhpcy5wcm9wZXJ0eUNoYW5nZUV2ZW50KTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5wcm9wZXJ0eUNoYW5nZUNhbGxlZCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEZpcmVQcm9wZXJ0eUNoYW5nZUludEludCgpIHsKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUNhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZVByb3BlcnR5Q2hhbmdlSW50SW50KCk7Ci0JCXRoaXMudmVyaWZ5UHJvcGVydHlDaGFuZ2VFdmVudChPTERfSU5UX1ZBTFVFLCBORVdfSU5UX1ZBTFVFKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnByb3BlcnR5Q2hhbmdlQ2FsbGVkKTsKLQotCQl0aGlzLnByb3BlcnR5Q2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLnByb3BlcnR5Q2hhbmdlQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlUHJvcGVydHlDaGFuZ2VJbnRJbnQoKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLnByb3BlcnR5Q2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnByb3BlcnR5Q2hhbmdlQ2FsbGVkKTsKLQotCQl0aGlzLnByb3BlcnR5Q2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLnByb3BlcnR5Q2hhbmdlQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUFJPUEVSVFlfTkFNRSwgdGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlUHJvcGVydHlDaGFuZ2VJbnRJbnQoKTsKLQkJdGhpcy52ZXJpZnlQcm9wZXJ0eUNoYW5nZUV2ZW50KE9MRF9JTlRfVkFMVUUsIE5FV19JTlRfVkFMVUUpOwotCQlhc3NlcnRUcnVlKHRoaXMucHJvcGVydHlDaGFuZ2VDYWxsZWQpOwotCi0JCXRoaXMucHJvcGVydHlDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMucHJvcGVydHlDaGFuZ2VDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQUk9QRVJUWV9OQU1FLCB0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVQcm9wZXJ0eUNoYW5nZUludEludCgpOwotCQlhc3NlcnROdWxsKHRoaXMucHJvcGVydHlDaGFuZ2VFdmVudCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMucHJvcGVydHlDaGFuZ2VDYWxsZWQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RGaXJlUHJvcGVydHlDaGFuZ2VCb29sZWFuQm9vbGVhbigpIHsKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUNhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZVByb3BlcnR5Q2hhbmdlQm9vbGVhbkJvb2xlYW4oKTsKLQkJdGhpcy52ZXJpZnlQcm9wZXJ0eUNoYW5nZUV2ZW50KE9MRF9CT09MRUFOX1ZBTFVFLCBORVdfQk9PTEVBTl9WQUxVRSk7Ci0JCWFzc2VydFRydWUodGhpcy5wcm9wZXJ0eUNoYW5nZUNhbGxlZCk7Ci0KLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUNhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZVByb3BlcnR5Q2hhbmdlQm9vbGVhbkJvb2xlYW4oKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLnByb3BlcnR5Q2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnByb3BlcnR5Q2hhbmdlQ2FsbGVkKTsKLQotCQl0aGlzLnByb3BlcnR5Q2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLnByb3BlcnR5Q2hhbmdlQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUFJPUEVSVFlfTkFNRSwgdGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlUHJvcGVydHlDaGFuZ2VCb29sZWFuQm9vbGVhbigpOwotCQl0aGlzLnZlcmlmeVByb3BlcnR5Q2hhbmdlRXZlbnQoT0xEX0JPT0xFQU5fVkFMVUUsIE5FV19CT09MRUFOX1ZBTFVFKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnByb3BlcnR5Q2hhbmdlQ2FsbGVkKTsKLQotCQl0aGlzLnByb3BlcnR5Q2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLnByb3BlcnR5Q2hhbmdlQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUFJPUEVSVFlfTkFNRSwgdGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlUHJvcGVydHlDaGFuZ2VCb29sZWFuQm9vbGVhbigpOwotCQlhc3NlcnROdWxsKHRoaXMucHJvcGVydHlDaGFuZ2VFdmVudCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMucHJvcGVydHlDaGFuZ2VDYWxsZWQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RGaXJlSXRlbUFkZGVkQ29sbGVjdGlvbigpIHsKLQkJdGhpcy5jb2xsZWN0aW9uQ2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLml0ZW1zQWRkZWRDb2xsZWN0aW9uQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVJdGVtQWRkZWRDb2xsZWN0aW9uKCk7Ci0JCXRoaXMudmVyaWZ5Q29sbGVjdGlvbkNoYW5nZUV2ZW50KEFEREVEX09CSkVDVF9WQUxVRSk7Ci0JCWFzc2VydFRydWUodGhpcy5pdGVtc0FkZGVkQ29sbGVjdGlvbkNhbGxlZCk7Ci0KLQkJdGhpcy5jb2xsZWN0aW9uQ2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLml0ZW1zQWRkZWRDb2xsZWN0aW9uQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLnJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVJdGVtQWRkZWRDb2xsZWN0aW9uKCk7Ci0JCWFzc2VydE51bGwodGhpcy5jb2xsZWN0aW9uQ2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLml0ZW1zQWRkZWRDb2xsZWN0aW9uQ2FsbGVkKTsKLQotCQl0aGlzLmNvbGxlY3Rpb25DaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMuaXRlbXNBZGRlZENvbGxlY3Rpb25DYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENPTExFQ1RJT05fTkFNRSwgdGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlSXRlbUFkZGVkQ29sbGVjdGlvbigpOwotCQl0aGlzLnZlcmlmeUNvbGxlY3Rpb25DaGFuZ2VFdmVudChBRERFRF9PQkpFQ1RfVkFMVUUpOwotCQlhc3NlcnRUcnVlKHRoaXMuaXRlbXNBZGRlZENvbGxlY3Rpb25DYWxsZWQpOwotCi0JCXRoaXMuY29sbGVjdGlvbkNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5pdGVtc0FkZGVkQ29sbGVjdGlvbkNhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ09MTEVDVElPTl9OQU1FLCB0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVJdGVtQWRkZWRDb2xsZWN0aW9uKCk7Ci0JCWFzc2VydE51bGwodGhpcy5jb2xsZWN0aW9uQ2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLml0ZW1zQWRkZWRDb2xsZWN0aW9uQ2FsbGVkKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RmlyZUl0ZW1SZW1vdmVkQ29sbGVjdGlvbigpIHsKLQkJdGhpcy5jb2xsZWN0aW9uQ2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLml0ZW1zUmVtb3ZlZENvbGxlY3Rpb25DYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZUl0ZW1SZW1vdmVkQ29sbGVjdGlvbigpOwotCQl0aGlzLnZlcmlmeUNvbGxlY3Rpb25DaGFuZ2VFdmVudChSRU1PVkVEX09CSkVDVF9WQUxVRSk7Ci0JCWFzc2VydFRydWUodGhpcy5pdGVtc1JlbW92ZWRDb2xsZWN0aW9uQ2FsbGVkKTsKLQotCQl0aGlzLmNvbGxlY3Rpb25DaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMuaXRlbXNSZW1vdmVkQ29sbGVjdGlvbkNhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlSXRlbVJlbW92ZWRDb2xsZWN0aW9uKCk7Ci0JCWFzc2VydE51bGwodGhpcy5jb2xsZWN0aW9uQ2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLml0ZW1zUmVtb3ZlZENvbGxlY3Rpb25DYWxsZWQpOwotCi0JCXRoaXMuY29sbGVjdGlvbkNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5pdGVtc1JlbW92ZWRDb2xsZWN0aW9uQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDT0xMRUNUSU9OX05BTUUsIHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZUl0ZW1SZW1vdmVkQ29sbGVjdGlvbigpOwotCQl0aGlzLnZlcmlmeUNvbGxlY3Rpb25DaGFuZ2VFdmVudChSRU1PVkVEX09CSkVDVF9WQUxVRSk7Ci0JCWFzc2VydFRydWUodGhpcy5pdGVtc1JlbW92ZWRDb2xsZWN0aW9uQ2FsbGVkKTsKLQotCQl0aGlzLmNvbGxlY3Rpb25DaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMuaXRlbXNSZW1vdmVkQ29sbGVjdGlvbkNhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ09MTEVDVElPTl9OQU1FLCB0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVJdGVtUmVtb3ZlZENvbGxlY3Rpb24oKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmNvbGxlY3Rpb25DaGFuZ2VFdmVudCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuaXRlbXNSZW1vdmVkQ29sbGVjdGlvbkNhbGxlZCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEZpcmVDb2xsZWN0aW9uQ2xlYXJlZCgpIHsKLQkJdGhpcy5jb2xsZWN0aW9uQ2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLmNvbGxlY3Rpb25DbGVhcmVkQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVDb2xsZWN0aW9uQ2xlYXJlZCgpOwotCQl0aGlzLnZlcmlmeUNvbGxlY3Rpb25DaGFuZ2VFdmVudChudWxsKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmNvbGxlY3Rpb25DbGVhcmVkQ2FsbGVkKTsKLQotCQl0aGlzLmNvbGxlY3Rpb25DaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMuY29sbGVjdGlvbkNsZWFyZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZUNvbGxlY3Rpb25DbGVhcmVkKCk7Ci0JCWFzc2VydE51bGwodGhpcy5jb2xsZWN0aW9uQ2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmNvbGxlY3Rpb25DbGVhcmVkQ2FsbGVkKTsKLQotCQl0aGlzLmNvbGxlY3Rpb25DaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMuY29sbGVjdGlvbkNsZWFyZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENPTExFQ1RJT05fTkFNRSwgdGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlQ29sbGVjdGlvbkNsZWFyZWQoKTsKLQkJdGhpcy52ZXJpZnlDb2xsZWN0aW9uQ2hhbmdlRXZlbnQobnVsbCk7Ci0JCWFzc2VydFRydWUodGhpcy5jb2xsZWN0aW9uQ2xlYXJlZENhbGxlZCk7Ci0KLQkJdGhpcy5jb2xsZWN0aW9uQ2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLmNvbGxlY3Rpb25DbGVhcmVkQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLnJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDT0xMRUNUSU9OX05BTUUsIHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZUNvbGxlY3Rpb25DbGVhcmVkKCk7Ci0JCWFzc2VydE51bGwodGhpcy5jb2xsZWN0aW9uQ2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmNvbGxlY3Rpb25DbGVhcmVkQ2FsbGVkKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RmlyZUNvbGxlY3Rpb25DaGFuZ2VkKCkgewotCQl0aGlzLmNvbGxlY3Rpb25DaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMuY29sbGVjdGlvbkNoYW5nZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZUNvbGxlY3Rpb25DaGFuZ2VkKCk7Ci0JCXRoaXMudmVyaWZ5Q29sbGVjdGlvbkNoYW5nZUV2ZW50KG51bGwpOwotCQlhc3NlcnRUcnVlKHRoaXMuY29sbGVjdGlvbkNoYW5nZWRDYWxsZWQpOwotCi0JCXRoaXMuY29sbGVjdGlvbkNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5jb2xsZWN0aW9uQ2hhbmdlZENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlQ29sbGVjdGlvbkNoYW5nZWQoKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmNvbGxlY3Rpb25DaGFuZ2VFdmVudCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuY29sbGVjdGlvbkNoYW5nZWRDYWxsZWQpOwotCi0JCXRoaXMuY29sbGVjdGlvbkNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5jb2xsZWN0aW9uQ2hhbmdlZENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ09MTEVDVElPTl9OQU1FLCB0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVDb2xsZWN0aW9uQ2hhbmdlZCgpOwotCQl0aGlzLnZlcmlmeUNvbGxlY3Rpb25DaGFuZ2VFdmVudChudWxsKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmNvbGxlY3Rpb25DaGFuZ2VkQ2FsbGVkKTsKLQotCQl0aGlzLmNvbGxlY3Rpb25DaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMuY29sbGVjdGlvbkNoYW5nZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENPTExFQ1RJT05fTkFNRSwgdGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlQ29sbGVjdGlvbkNoYW5nZWQoKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmNvbGxlY3Rpb25DaGFuZ2VFdmVudCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuY29sbGVjdGlvbkNoYW5nZWRDYWxsZWQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RGaXJlSXRlbUFkZGVkTGlzdCgpIHsKLQkJdGhpcy5saXN0Q2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLml0ZW1zQWRkZWRMaXN0Q2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVJdGVtQWRkZWRMaXN0KCk7Ci0JCXRoaXMudmVyaWZ5TGlzdENoYW5nZUV2ZW50KEFERF9JTkRFWCwgQURERURfT0JKRUNUX1ZBTFVFKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLml0ZW1zQWRkZWRMaXN0Q2FsbGVkKTsKLQotCQl0aGlzLmxpc3RDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMuaXRlbXNBZGRlZExpc3RDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZUl0ZW1BZGRlZExpc3QoKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmxpc3RDaGFuZ2VFdmVudCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuaXRlbXNBZGRlZExpc3RDYWxsZWQpOwotCi0JCXRoaXMubGlzdENoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5pdGVtc0FkZGVkTGlzdENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTElTVF9OQU1FLCB0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVJdGVtQWRkZWRMaXN0KCk7Ci0JCXRoaXMudmVyaWZ5TGlzdENoYW5nZUV2ZW50KEFERF9JTkRFWCwgQURERURfT0JKRUNUX1ZBTFVFKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLml0ZW1zQWRkZWRMaXN0Q2FsbGVkKTsKLQotCQl0aGlzLmxpc3RDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMuaXRlbXNBZGRlZExpc3RDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKExJU1RfTkFNRSwgdGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlSXRlbUFkZGVkTGlzdCgpOwotCQlhc3NlcnROdWxsKHRoaXMubGlzdENoYW5nZUV2ZW50KTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5pdGVtc0FkZGVkTGlzdENhbGxlZCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEZpcmVJdGVtUmVtb3ZlZExpc3QoKSB7Ci0JCXRoaXMubGlzdENoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5pdGVtc1JlbW92ZWRMaXN0Q2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVJdGVtUmVtb3ZlZExpc3QoKTsKLQkJdGhpcy52ZXJpZnlMaXN0Q2hhbmdlRXZlbnQoUkVNT1ZFX0lOREVYLCBSRU1PVkVEX09CSkVDVF9WQUxVRSk7Ci0JCWFzc2VydFRydWUodGhpcy5pdGVtc1JlbW92ZWRMaXN0Q2FsbGVkKTsKLQotCQl0aGlzLmxpc3RDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMuaXRlbXNSZW1vdmVkTGlzdENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlSXRlbVJlbW92ZWRMaXN0KCk7Ci0JCWFzc2VydE51bGwodGhpcy5saXN0Q2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLml0ZW1zUmVtb3ZlZExpc3RDYWxsZWQpOwotCi0JCXRoaXMubGlzdENoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5pdGVtc1JlbW92ZWRMaXN0Q2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihMSVNUX05BTUUsIHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZUl0ZW1SZW1vdmVkTGlzdCgpOwotCQl0aGlzLnZlcmlmeUxpc3RDaGFuZ2VFdmVudChSRU1PVkVfSU5ERVgsIFJFTU9WRURfT0JKRUNUX1ZBTFVFKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLml0ZW1zUmVtb3ZlZExpc3RDYWxsZWQpOwotCi0JCXRoaXMubGlzdENoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5pdGVtc1JlbW92ZWRMaXN0Q2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMSVNUX05BTUUsIHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZUl0ZW1SZW1vdmVkTGlzdCgpOwotCQlhc3NlcnROdWxsKHRoaXMubGlzdENoYW5nZUV2ZW50KTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5pdGVtc1JlbW92ZWRMaXN0Q2FsbGVkKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RmlyZUl0ZW1SZXBsYWNlZExpc3QoKSB7Ci0JCXRoaXMubGlzdENoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5pdGVtc1JlcGxhY2VkTGlzdENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlSXRlbVJlcGxhY2VkTGlzdCgpOwotCQl0aGlzLnZlcmlmeUxpc3RDaGFuZ2VFdmVudChSRVBMQUNFX0lOREVYLCBBRERFRF9PQkpFQ1RfVkFMVUUsIFJFTU9WRURfT0JKRUNUX1ZBTFVFKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLml0ZW1zUmVwbGFjZWRMaXN0Q2FsbGVkKTsKLQotCQl0aGlzLmxpc3RDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMuaXRlbXNSZXBsYWNlZExpc3RDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZUl0ZW1SZXBsYWNlZExpc3QoKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmxpc3RDaGFuZ2VFdmVudCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuaXRlbXNSZXBsYWNlZExpc3RDYWxsZWQpOwotCi0JCXRoaXMubGlzdENoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5pdGVtc1JlcGxhY2VkTGlzdENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTElTVF9OQU1FLCB0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVJdGVtUmVwbGFjZWRMaXN0KCk7Ci0JCXRoaXMudmVyaWZ5TGlzdENoYW5nZUV2ZW50KFJFUExBQ0VfSU5ERVgsIEFEREVEX09CSkVDVF9WQUxVRSwgUkVNT1ZFRF9PQkpFQ1RfVkFMVUUpOwotCQlhc3NlcnRUcnVlKHRoaXMuaXRlbXNSZXBsYWNlZExpc3RDYWxsZWQpOwotCi0JCXRoaXMubGlzdENoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5pdGVtc1JlcGxhY2VkTGlzdENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoTElTVF9OQU1FLCB0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVJdGVtUmVwbGFjZWRMaXN0KCk7Ci0JCWFzc2VydE51bGwodGhpcy5saXN0Q2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLml0ZW1zUmVwbGFjZWRMaXN0Q2FsbGVkKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RmlyZUl0ZW1Nb3ZlZExpc3QoKSB7Ci0JCXRoaXMubGlzdENoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5pdGVtc01vdmVkTGlzdENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlSXRlbU1vdmVkTGlzdCgpOwotCQl0aGlzLnZlcmlmeUxpc3RDaGFuZ2VFdmVudChUQVJHRVRfSU5ERVgsIFNPVVJDRV9JTkRFWCk7Ci0JCWFzc2VydFRydWUodGhpcy5pdGVtc01vdmVkTGlzdENhbGxlZCk7Ci0KLQkJdGhpcy5saXN0Q2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLml0ZW1zTW92ZWRMaXN0Q2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVJdGVtTW92ZWRMaXN0KCk7Ci0JCWFzc2VydE51bGwodGhpcy5saXN0Q2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLml0ZW1zTW92ZWRMaXN0Q2FsbGVkKTsKLQotCQl0aGlzLmxpc3RDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMuaXRlbXNNb3ZlZExpc3RDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExJU1RfTkFNRSwgdGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlSXRlbU1vdmVkTGlzdCgpOwotCQl0aGlzLnZlcmlmeUxpc3RDaGFuZ2VFdmVudChUQVJHRVRfSU5ERVgsIFNPVVJDRV9JTkRFWCk7Ci0JCWFzc2VydFRydWUodGhpcy5pdGVtc01vdmVkTGlzdENhbGxlZCk7Ci0KLQkJdGhpcy5saXN0Q2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLml0ZW1zTW92ZWRMaXN0Q2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMSVNUX05BTUUsIHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZUl0ZW1Nb3ZlZExpc3QoKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmxpc3RDaGFuZ2VFdmVudCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuaXRlbXNNb3ZlZExpc3RDYWxsZWQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RGaXJlTGlzdENsZWFyZWQoKSB7Ci0JCXRoaXMubGlzdENoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5saXN0Q2xlYXJlZENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlTGlzdENsZWFyZWQoKTsKLQkJdGhpcy52ZXJpZnlMaXN0Q2hhbmdlRXZlbnQoLTEsIG51bGwpOwotCQlhc3NlcnRUcnVlKHRoaXMubGlzdENsZWFyZWRDYWxsZWQpOwotCi0JCXRoaXMubGlzdENoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5saXN0Q2xlYXJlZENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlTGlzdENsZWFyZWQoKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmxpc3RDaGFuZ2VFdmVudCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMubGlzdENsZWFyZWRDYWxsZWQpOwotCi0JCXRoaXMubGlzdENoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5saXN0Q2xlYXJlZENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTElTVF9OQU1FLCB0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVMaXN0Q2xlYXJlZCgpOwotCQl0aGlzLnZlcmlmeUxpc3RDaGFuZ2VFdmVudCgtMSwgbnVsbCk7Ci0JCWFzc2VydFRydWUodGhpcy5saXN0Q2xlYXJlZENhbGxlZCk7Ci0KLQkJdGhpcy5saXN0Q2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLmxpc3RDbGVhcmVkQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMSVNUX05BTUUsIHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZUxpc3RDbGVhcmVkKCk7Ci0JCWFzc2VydE51bGwodGhpcy5saXN0Q2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmxpc3RDbGVhcmVkQ2FsbGVkKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RmlyZUxpc3RDaGFuZ2VkKCkgewotCQl0aGlzLmxpc3RDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMubGlzdENoYW5nZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZUxpc3RDaGFuZ2VkKCk7Ci0JCXRoaXMudmVyaWZ5TGlzdENoYW5nZUV2ZW50KC0xLCBudWxsKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmxpc3RDaGFuZ2VkQ2FsbGVkKTsKLQotCQl0aGlzLmxpc3RDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMubGlzdENoYW5nZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZUxpc3RDaGFuZ2VkKCk7Ci0JCWFzc2VydE51bGwodGhpcy5saXN0Q2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmxpc3RDaGFuZ2VkQ2FsbGVkKTsKLQotCQl0aGlzLmxpc3RDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMubGlzdENoYW5nZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExJU1RfTkFNRSwgdGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlTGlzdENoYW5nZWQoKTsKLQkJdGhpcy52ZXJpZnlMaXN0Q2hhbmdlRXZlbnQoLTEsIG51bGwpOwotCQlhc3NlcnRUcnVlKHRoaXMubGlzdENoYW5nZWRDYWxsZWQpOwotCi0JCXRoaXMubGlzdENoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5saXN0Q2hhbmdlZENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoTElTVF9OQU1FLCB0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVMaXN0Q2hhbmdlZCgpOwotCQlhc3NlcnROdWxsKHRoaXMubGlzdENoYW5nZUV2ZW50KTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5saXN0Q2hhbmdlZENhbGxlZCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEZpcmVOb2RlQWRkZWRPYmplY3RBcnJheVBhdGgoKSB7Ci0JCXRoaXMudHJlZUNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5ub2RlQWRkZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZU5vZGVBZGRlZE9iamVjdEFycmF5UGF0aCgpOwotCQl0aGlzLnZlcmlmeVRyZWVDaGFuZ2VFdmVudChPQkpFQ1RfQVJSQVlfUEFUSCk7Ci0JCWFzc2VydFRydWUodGhpcy5ub2RlQWRkZWRDYWxsZWQpOwotCi0JCXRoaXMudHJlZUNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5ub2RlQWRkZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlVHJlZUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZU5vZGVBZGRlZE9iamVjdEFycmF5UGF0aCgpOwotCQlhc3NlcnROdWxsKHRoaXMudHJlZUNoYW5nZUV2ZW50KTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5ub2RlQWRkZWRDYWxsZWQpOwotCi0JCXRoaXMudHJlZUNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5ub2RlQWRkZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKFRSRUVfTkFNRSwgdGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlTm9kZUFkZGVkT2JqZWN0QXJyYXlQYXRoKCk7Ci0JCXRoaXMudmVyaWZ5VHJlZUNoYW5nZUV2ZW50KE9CSkVDVF9BUlJBWV9QQVRIKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLm5vZGVBZGRlZENhbGxlZCk7Ci0KLQkJdGhpcy50cmVlQ2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLm5vZGVBZGRlZENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVUcmVlQ2hhbmdlTGlzdGVuZXIoVFJFRV9OQU1FLCB0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVOb2RlQWRkZWRPYmplY3RBcnJheVBhdGgoKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLnRyZWVDaGFuZ2VFdmVudCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMubm9kZUFkZGVkQ2FsbGVkKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RmlyZU5vZGVSZW1vdmVkT2JqZWN0QXJyYXlQYXRoKCkgewotCQl0aGlzLnRyZWVDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMubm9kZVJlbW92ZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZU5vZGVSZW1vdmVkT2JqZWN0QXJyYXlQYXRoKCk7Ci0JCXRoaXMudmVyaWZ5VHJlZUNoYW5nZUV2ZW50KE9CSkVDVF9BUlJBWV9QQVRIKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLm5vZGVSZW1vdmVkQ2FsbGVkKTsKLQotCQl0aGlzLnRyZWVDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMubm9kZVJlbW92ZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlVHJlZUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZU5vZGVSZW1vdmVkT2JqZWN0QXJyYXlQYXRoKCk7Ci0JCWFzc2VydE51bGwodGhpcy50cmVlQ2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLm5vZGVSZW1vdmVkQ2FsbGVkKTsKLQotCQl0aGlzLnRyZWVDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMubm9kZVJlbW92ZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKFRSRUVfTkFNRSwgdGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlTm9kZVJlbW92ZWRPYmplY3RBcnJheVBhdGgoKTsKLQkJdGhpcy52ZXJpZnlUcmVlQ2hhbmdlRXZlbnQoT0JKRUNUX0FSUkFZX1BBVEgpOwotCQlhc3NlcnRUcnVlKHRoaXMubm9kZVJlbW92ZWRDYWxsZWQpOwotCi0JCXRoaXMudHJlZUNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5ub2RlUmVtb3ZlZENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVUcmVlQ2hhbmdlTGlzdGVuZXIoVFJFRV9OQU1FLCB0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVOb2RlUmVtb3ZlZE9iamVjdEFycmF5UGF0aCgpOwotCQlhc3NlcnROdWxsKHRoaXMudHJlZUNoYW5nZUV2ZW50KTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5ub2RlUmVtb3ZlZENhbGxlZCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEZpcmVUcmVlQ2xlYXJlZCgpIHsKLQkJdGhpcy50cmVlQ2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLnRyZWVDbGVhcmVkQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVUcmVlQ2xlYXJlZCgpOwotCQl0aGlzLnZlcmlmeVRyZWVDaGFuZ2VFdmVudChFTVBUWV9QQVRIKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnRyZWVDbGVhcmVkQ2FsbGVkKTsKLQotCQl0aGlzLnRyZWVDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMudHJlZUNsZWFyZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlVHJlZUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZVRyZWVDbGVhcmVkKCk7Ci0JCWFzc2VydE51bGwodGhpcy50cmVlQ2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnRyZWVDbGVhcmVkQ2FsbGVkKTsKLQotCQl0aGlzLnRyZWVDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMudHJlZUNsZWFyZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKFRSRUVfTkFNRSwgdGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlVHJlZUNsZWFyZWQoKTsKLQkJdGhpcy52ZXJpZnlUcmVlQ2hhbmdlRXZlbnQoRU1QVFlfUEFUSCk7Ci0JCWFzc2VydFRydWUodGhpcy50cmVlQ2xlYXJlZENhbGxlZCk7Ci0KLQkJdGhpcy50cmVlQ2hhbmdlRXZlbnQgPSBudWxsOwotCQl0aGlzLnRyZWVDbGVhcmVkQ2FsbGVkID0gZmFsc2U7Ci0JCXRoaXMudGVzdE1vZGVsLnJlbW92ZVRyZWVDaGFuZ2VMaXN0ZW5lcihUUkVFX05BTUUsIHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZVRyZWVDbGVhcmVkKCk7Ci0JCWFzc2VydE51bGwodGhpcy50cmVlQ2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnRyZWVDbGVhcmVkQ2FsbGVkKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RmlyZVRyZWVDaGFuZ2VkT2JqZWN0QXJyYXlQYXRoKCkgewotCQl0aGlzLnRyZWVDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMudHJlZUNoYW5nZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZVRyZWVDaGFuZ2VkT2JqZWN0QXJyYXlQYXRoKCk7Ci0JCXRoaXMudmVyaWZ5VHJlZUNoYW5nZUV2ZW50KE9CSkVDVF9BUlJBWV9QQVRIKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnRyZWVDaGFuZ2VkQ2FsbGVkKTsKLQotCQl0aGlzLnRyZWVDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMudHJlZUNoYW5nZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlVHJlZUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZVRyZWVDaGFuZ2VkT2JqZWN0QXJyYXlQYXRoKCk7Ci0JCWFzc2VydE51bGwodGhpcy50cmVlQ2hhbmdlRXZlbnQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnRyZWVDaGFuZ2VkQ2FsbGVkKTsKLQotCQl0aGlzLnRyZWVDaGFuZ2VFdmVudCA9IG51bGw7Ci0JCXRoaXMudHJlZUNoYW5nZWRDYWxsZWQgPSBmYWxzZTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKFRSRUVfTkFNRSwgdGhpcyk7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RGaXJlVHJlZUNoYW5nZWRPYmplY3RBcnJheVBhdGgoKTsKLQkJdGhpcy52ZXJpZnlUcmVlQ2hhbmdlRXZlbnQoT0JKRUNUX0FSUkFZX1BBVEgpOwotCQlhc3NlcnRUcnVlKHRoaXMudHJlZUNoYW5nZWRDYWxsZWQpOwotCi0JCXRoaXMudHJlZUNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy50cmVlQ2hhbmdlZENhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVUcmVlQ2hhbmdlTGlzdGVuZXIoVFJFRV9OQU1FLCB0aGlzKTsKLQkJdGhpcy50ZXN0TW9kZWwudGVzdEZpcmVUcmVlQ2hhbmdlZE9iamVjdEFycmF5UGF0aCgpOwotCQlhc3NlcnROdWxsKHRoaXMudHJlZUNoYW5nZUV2ZW50KTsKLQkJYXNzZXJ0RmFsc2UodGhpcy50cmVlQ2hhbmdlZENhbGxlZCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc0FueUNoYW5nZUxpc3RlbmVycygpIHsKLQkJYXNzZXJ0RmFsc2UodGhpcy50ZXN0TW9kZWwuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUFJPUEVSVFlfTkFNRSkpOwotCQl0aGlzLnRlc3RNb2RlbC5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQlhc3NlcnRUcnVlKHRoaXMudGVzdE1vZGVsLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFBST1BFUlRZX05BTUUpKTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQotCQlhc3NlcnRGYWxzZSh0aGlzLnRlc3RNb2RlbC5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQUk9QRVJUWV9OQU1FKSk7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUFJPUEVSVFlfTkFNRSwgdGhpcyk7Ci0JCWFzc2VydFRydWUodGhpcy50ZXN0TW9kZWwuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUFJPUEVSVFlfTkFNRSkpOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFBST1BFUlRZX05BTUUsIHRoaXMpOwotCi0JCWFzc2VydEZhbHNlKHRoaXMudGVzdE1vZGVsLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoQ09MTEVDVElPTl9OQU1FKSk7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnRlc3RNb2RlbC5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENPTExFQ1RJT05fTkFNRSkpOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0KLQkJYXNzZXJ0RmFsc2UodGhpcy50ZXN0TW9kZWwuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDT0xMRUNUSU9OX05BTUUpKTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENPTExFQ1RJT05fTkFNRSwgdGhpcyk7Ci0JCWFzc2VydFRydWUodGhpcy50ZXN0TW9kZWwuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDT0xMRUNUSU9OX05BTUUpKTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENPTExFQ1RJT05fTkFNRSwgdGhpcyk7Ci0KLQkJYXNzZXJ0RmFsc2UodGhpcy50ZXN0TW9kZWwuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMSVNUX05BTUUpKTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQlhc3NlcnRUcnVlKHRoaXMudGVzdE1vZGVsLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTElTVF9OQU1FKSk7Ci0JCXRoaXMudGVzdE1vZGVsLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQotCQlhc3NlcnRGYWxzZSh0aGlzLnRlc3RNb2RlbC5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExJU1RfTkFNRSkpOwotCQl0aGlzLnRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTElTVF9OQU1FLCB0aGlzKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnRlc3RNb2RlbC5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExJU1RfTkFNRSkpOwotCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoTElTVF9OQU1FLCB0aGlzKTsKLQotCQlhc3NlcnRGYWxzZSh0aGlzLnRlc3RNb2RlbC5oYXNBbnlUcmVlQ2hhbmdlTGlzdGVuZXJzKFRSRUVfTkFNRSkpOwotCQl0aGlzLnRlc3RNb2RlbC5hZGRUcmVlQ2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCWFzc2VydFRydWUodGhpcy50ZXN0TW9kZWwuaGFzQW55VHJlZUNoYW5nZUxpc3RlbmVycyhUUkVFX05BTUUpKTsKLQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlVHJlZUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCi0JCWFzc2VydEZhbHNlKHRoaXMudGVzdE1vZGVsLmhhc0FueVRyZWVDaGFuZ2VMaXN0ZW5lcnMoVFJFRV9OQU1FKSk7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcihUUkVFX05BTUUsIHRoaXMpOwotCQlhc3NlcnRUcnVlKHRoaXMudGVzdE1vZGVsLmhhc0FueVRyZWVDaGFuZ2VMaXN0ZW5lcnMoVFJFRV9OQU1FKSk7Ci0JCXRoaXMudGVzdE1vZGVsLnJlbW92ZVRyZWVDaGFuZ2VMaXN0ZW5lcihUUkVFX05BTUUsIHRoaXMpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBdHRyaWJ1dGVWYWx1ZUhhc0NoYW5nZWQoKSB7Ci0JCXRoaXMudGVzdE1vZGVsLnRlc3RBdHRyaWJ1dGVWYWx1ZUhhc0NoYW5nZWQoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2xvbmUoKSB7Ci0JCWFzc2VydEZhbHNlKHRoaXMudGVzdE1vZGVsLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFBST1BFUlRZX05BTUUpKTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnRlc3RNb2RlbC5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQUk9QRVJUWV9OQU1FKSk7Ci0KLQkJLy8gdmVyaWZ5IHRoYXQgdGhlIGNsb25lIGRvZXMgbm90IGhhdmUgYW55IGxpc3RlbmVycwotCQlUZXN0TW9kZWwgY2xvbmUgPSB0aGlzLnRlc3RNb2RlbC5jbG9uZSgpOwotCQlhc3NlcnRGYWxzZShjbG9uZS5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQUk9QRVJUWV9OQU1FKSk7Ci0JCWNsb25lLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCWFzc2VydFRydWUoY2xvbmUuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUFJPUEVSVFlfTkFNRSkpOwotCQkvLyBjaGVjayBvcmlnaW5hbAotCQlhc3NlcnRUcnVlKHRoaXMudGVzdE1vZGVsLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFBST1BFUlRZX05BTUUpKTsKLQotCQkvLyBub3cgdGVzdCBldmVudHMgZmlyZWQgYnkgb3JpZ2luYWwKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUNhbGxlZCA9IGZhbHNlOwotCQl0aGlzLnRlc3RNb2RlbC50ZXN0RmlyZVByb3BlcnR5Q2hhbmdlT2JqZWN0T2JqZWN0KCk7Ci0JCXRoaXMudmVyaWZ5UHJvcGVydHlDaGFuZ2VFdmVudChPTERfT0JKRUNUX1ZBTFVFLCBORVdfT0JKRUNUX1ZBTFVFKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnByb3BlcnR5Q2hhbmdlQ2FsbGVkKTsKLQotCQkvLyBub3cgdGVzdCBldmVudHMgZmlyZWQgYnkgY2xvbmUKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5wcm9wZXJ0eUNoYW5nZUNhbGxlZCA9IGZhbHNlOwotCQljbG9uZS50ZXN0RmlyZVByb3BlcnR5Q2hhbmdlT2JqZWN0T2JqZWN0KCk7Ci0JCXRoaXMudmVyaWZ5UHJvcGVydHlDaGFuZ2VFdmVudChjbG9uZSwgT0xEX09CSkVDVF9WQUxVRSwgTkVXX09CSkVDVF9WQUxVRSk7Ci0JCWFzc2VydFRydWUodGhpcy5wcm9wZXJ0eUNoYW5nZUNhbGxlZCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZE51bGxTdGF0ZUxpc3RlbmVyKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0aGlzLnRlc3RNb2RlbC5hZGRTdGF0ZUNoYW5nZUxpc3RlbmVyKG51bGwpOwotCQl9IGNhdGNoIChOdWxsUG9pbnRlckV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGROdWxsUHJvcGVydHlMaXN0ZW5lcigpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy50ZXN0TW9kZWwuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihudWxsKTsKLQkJfSBjYXRjaCAoTnVsbFBvaW50ZXJFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkTnVsbENvbGxlY3Rpb25MaXN0ZW5lcigpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy50ZXN0TW9kZWwuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKG51bGwpOwotCQl9IGNhdGNoIChOdWxsUG9pbnRlckV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGROdWxsTGlzdExpc3RlbmVyKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0aGlzLnRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIobnVsbCk7Ci0JCX0gY2F0Y2ggKE51bGxQb2ludGVyRXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZE51bGxUcmVlTGlzdGVuZXIoKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRoaXMudGVzdE1vZGVsLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcihudWxsKTsKLQkJfSBjYXRjaCAoTnVsbFBvaW50ZXJFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkTnVsbFByb3BlcnR5TGlzdGVuZXJOYW1lKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0aGlzLnRlc3RNb2RlbC5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCJmb28iLCBudWxsKTsKLQkJfSBjYXRjaCAoTnVsbFBvaW50ZXJFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkTnVsbENvbGxlY3Rpb25MaXN0ZW5lck5hbWUoKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRoaXMudGVzdE1vZGVsLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcigiZm9vIiwgbnVsbCk7Ci0JCX0gY2F0Y2ggKE51bGxQb2ludGVyRXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZE51bGxMaXN0TGlzdGVuZXJOYW1lKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0aGlzLnRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoImZvbyIsIG51bGwpOwotCQl9IGNhdGNoIChOdWxsUG9pbnRlckV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGROdWxsVHJlZUxpc3RlbmVyTmFtZSgpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy50ZXN0TW9kZWwuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKCJmb28iLCBudWxsKTsKLQkJfSBjYXRjaCAoTnVsbFBvaW50ZXJFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQm9ndXNTdGF0ZUxpc3RlbmVyKCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVTdGF0ZUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQotCQl0aGlzLnRlc3RNb2RlbC5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQlleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlU3RhdGVDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQkJdGhpcy50ZXN0TW9kZWwuYWRkU3RhdGVDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRoaXMudGVzdE1vZGVsLnJlbW92ZVN0YXRlQ2hhbmdlTGlzdGVuZXIobmV3IEFic3RyYWN0TW9kZWxUZXN0cygiZHVtbXkiKSk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVCb2d1c1Byb3BlcnR5TGlzdGVuZXIoKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRoaXMudGVzdE1vZGVsLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCi0JCXRoaXMudGVzdE1vZGVsLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRoaXMudGVzdE1vZGVsLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCi0JCXRoaXMudGVzdE1vZGVsLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCWV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKG5ldyBBYnN0cmFjdE1vZGVsVGVzdHMoImR1bW15IikpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQm9ndXNDb2xsZWN0aW9uTGlzdGVuZXIoKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRoaXMudGVzdE1vZGVsLnJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQkJdGhpcy50ZXN0TW9kZWwuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRoaXMudGVzdE1vZGVsLnJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQkJdGhpcy50ZXN0TW9kZWwuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQlleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKG5ldyBBYnN0cmFjdE1vZGVsVGVzdHMoImR1bW15IikpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQm9ndXNMaXN0TGlzdGVuZXIoKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRoaXMudGVzdE1vZGVsLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQkJdGhpcy50ZXN0TW9kZWwuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRoaXMudGVzdE1vZGVsLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQkJdGhpcy50ZXN0TW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQlleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKG5ldyBBYnN0cmFjdE1vZGVsVGVzdHMoImR1bW15IikpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQm9ndXNUcmVlTGlzdGVuZXIoKSB7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRoaXMudGVzdE1vZGVsLnJlbW92ZVRyZWVDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQkJdGhpcy50ZXN0TW9kZWwuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRoaXMudGVzdE1vZGVsLnJlbW92ZVRyZWVDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQkJdGhpcy50ZXN0TW9kZWwuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQlleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlVHJlZUNoYW5nZUxpc3RlbmVyKG5ldyBBYnN0cmFjdE1vZGVsVGVzdHMoImR1bW15IikpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlQm9ndXNQcm9wZXJ0eUxpc3RlbmVyTmFtZSgpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigiZm9vIiwgdGhpcyk7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCi0JCXRoaXMudGVzdE1vZGVsLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcigiZm9vIiwgdGhpcyk7Ci0JCWV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCJmb28iLCB0aGlzKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQkJdGhpcy50ZXN0TW9kZWwuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigiZm9vIiwgdGhpcyk7Ci0JCWV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCJmb28iLCBuZXcgQWJzdHJhY3RNb2RlbFRlc3RzKCJkdW1teSIpKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUJvZ3VzQ29sbGVjdGlvbkxpc3RlbmVyTmFtZSgpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKCJmb28iLCB0aGlzKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQkJdGhpcy50ZXN0TW9kZWwuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigiZm9vIiwgdGhpcyk7Ci0JCWV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoImZvbyIsIHRoaXMpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQotCQl0aGlzLnRlc3RNb2RlbC5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoImZvbyIsIHRoaXMpOwotCQlleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKCJmb28iLCBuZXcgQWJzdHJhY3RNb2RlbFRlc3RzKCJkdW1teSIpKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUJvZ3VzTGlzdExpc3RlbmVyTmFtZSgpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKCJmb28iLCB0aGlzKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQkJdGhpcy50ZXN0TW9kZWwuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigiZm9vIiwgdGhpcyk7Ci0JCWV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoImZvbyIsIHRoaXMpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQotCQl0aGlzLnRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoImZvbyIsIHRoaXMpOwotCQlleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKCJmb28iLCBuZXcgQWJzdHJhY3RNb2RlbFRlc3RzKCJkdW1teSIpKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUJvZ3VzVHJlZUxpc3RlbmVyTmFtZSgpIHsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlVHJlZUNoYW5nZUxpc3RlbmVyKCJmb28iLCB0aGlzKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0KLQkJdGhpcy50ZXN0TW9kZWwuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigiZm9vIiwgdGhpcyk7Ci0JCWV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0aGlzLnRlc3RNb2RlbC5yZW1vdmVUcmVlQ2hhbmdlTGlzdGVuZXIoImZvbyIsIHRoaXMpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQotCQl0aGlzLnRlc3RNb2RlbC5hZGRUcmVlQ2hhbmdlTGlzdGVuZXIoImZvbyIsIHRoaXMpOwotCQlleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGhpcy50ZXN0TW9kZWwucmVtb3ZlVHJlZUNoYW5nZUxpc3RlbmVyKCJmb28iLCBuZXcgQWJzdHJhY3RNb2RlbFRlc3RzKCJkdW1teSIpKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFRvU3RyaW5nKCkgewotCQlhc3NlcnRUcnVlKHRoaXMudGVzdE1vZGVsLnRvU3RyaW5nKCkuaW5kZXhPZihURVNUX1RPX1NUUklORykgIT0gLTEpOwotCX0KLQotLy8gKioqKioqKioqKiBpbnRlcm5hbCBtZXRob2RzICoqKioqKioqKioKLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlQcm9wZXJ0eUNoYW5nZUV2ZW50KE9iamVjdCBvbGRWYWx1ZSwgT2JqZWN0IG5ld1ZhbHVlKSB7Ci0JCXRoaXMudmVyaWZ5UHJvcGVydHlDaGFuZ2VFdmVudCh0aGlzLnRlc3RNb2RlbCwgb2xkVmFsdWUsIG5ld1ZhbHVlKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UHJvcGVydHlDaGFuZ2VFdmVudChPYmplY3Qgc291cmNlLCBPYmplY3Qgb2xkVmFsdWUsIE9iamVjdCBuZXdWYWx1ZSkgewotCQlhc3NlcnROb3ROdWxsKHRoaXMucHJvcGVydHlDaGFuZ2VFdmVudCk7Ci0JCWFzc2VydEVxdWFscyhzb3VyY2UsIHRoaXMucHJvcGVydHlDaGFuZ2VFdmVudC5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhQUk9QRVJUWV9OQU1FLCB0aGlzLnByb3BlcnR5Q2hhbmdlRXZlbnQuZ2V0UHJvcGVydHlOYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMob2xkVmFsdWUsIHRoaXMucHJvcGVydHlDaGFuZ2VFdmVudC5nZXRPbGRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKG5ld1ZhbHVlLCB0aGlzLnByb3BlcnR5Q2hhbmdlRXZlbnQuZ2V0TmV3VmFsdWUoKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUNvbGxlY3Rpb25DaGFuZ2VFdmVudChPYmplY3QgaXRlbSkgewotCQlhc3NlcnROb3ROdWxsKHRoaXMuY29sbGVjdGlvbkNoYW5nZUV2ZW50KTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMudGVzdE1vZGVsLCB0aGlzLmNvbGxlY3Rpb25DaGFuZ2VFdmVudC5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhDT0xMRUNUSU9OX05BTUUsIHRoaXMuY29sbGVjdGlvbkNoYW5nZUV2ZW50LmdldENvbGxlY3Rpb25OYW1lKCkpOwotCQlpZiAoaXRlbSA9PSBudWxsKSB7Ci0JCQlhc3NlcnRGYWxzZSh0aGlzLmNvbGxlY3Rpb25DaGFuZ2VFdmVudC5pdGVtcygpLmhhc05leHQoKSk7Ci0JCX0gZWxzZSB7Ci0JCQlhc3NlcnRFcXVhbHMoaXRlbSwgdGhpcy5jb2xsZWN0aW9uQ2hhbmdlRXZlbnQuaXRlbXMoKS5uZXh0KCkpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUxpc3RDaGFuZ2VFdmVudChpbnQgaW5kZXgsIE9iamVjdCBpdGVtKSB7Ci0JCXRoaXMudmVyaWZ5TGlzdENoYW5nZUV2ZW50KGluZGV4LCBpdGVtLCBudWxsKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5TGlzdENoYW5nZUV2ZW50KGludCB0YXJnZXRJbmRleCwgaW50IHNvdXJjZUluZGV4KSB7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5saXN0Q2hhbmdlRXZlbnQpOwotCQlhc3NlcnRFcXVhbHModGhpcy50ZXN0TW9kZWwsIHRoaXMubGlzdENoYW5nZUV2ZW50LmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKExJU1RfTkFNRSwgdGhpcy5saXN0Q2hhbmdlRXZlbnQuZ2V0TGlzdE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscyh0YXJnZXRJbmRleCwgdGhpcy5saXN0Q2hhbmdlRXZlbnQuZ2V0VGFyZ2V0SW5kZXgoKSk7Ci0JCWFzc2VydEVxdWFscyhzb3VyY2VJbmRleCwgdGhpcy5saXN0Q2hhbmdlRXZlbnQuZ2V0U291cmNlSW5kZXgoKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUxpc3RDaGFuZ2VFdmVudChpbnQgaW5kZXgsIE9iamVjdCBpdGVtLCBPYmplY3QgcmVwbGFjZWRJdGVtKSB7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5saXN0Q2hhbmdlRXZlbnQpOwotCQlhc3NlcnRFcXVhbHModGhpcy50ZXN0TW9kZWwsIHRoaXMubGlzdENoYW5nZUV2ZW50LmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKExJU1RfTkFNRSwgdGhpcy5saXN0Q2hhbmdlRXZlbnQuZ2V0TGlzdE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscyhpbmRleCwgdGhpcy5saXN0Q2hhbmdlRXZlbnQuZ2V0SW5kZXgoKSk7Ci0JCWlmIChpdGVtID09IG51bGwpIHsKLQkJCWFzc2VydEZhbHNlKHRoaXMubGlzdENoYW5nZUV2ZW50Lml0ZW1zKCkuaGFzTmV4dCgpKTsKLQkJfSBlbHNlIHsKLQkJCWFzc2VydEVxdWFscyhpdGVtLCB0aGlzLmxpc3RDaGFuZ2VFdmVudC5pdGVtcygpLm5leHQoKSk7Ci0JCX0KLQkJaWYgKHJlcGxhY2VkSXRlbSA9PSBudWxsKSB7Ci0JCQlhc3NlcnRGYWxzZSh0aGlzLmxpc3RDaGFuZ2VFdmVudC5yZXBsYWNlZEl0ZW1zKCkuaGFzTmV4dCgpKTsKLQkJfSBlbHNlIHsKLQkJCWFzc2VydEVxdWFscyhyZXBsYWNlZEl0ZW0sIHRoaXMubGlzdENoYW5nZUV2ZW50LnJlcGxhY2VkSXRlbXMoKS5uZXh0KCkpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVRyZWVDaGFuZ2VFdmVudChPYmplY3RbXSBwYXRoKSB7Ci0JCWFzc2VydE5vdE51bGwodGhpcy50cmVlQ2hhbmdlRXZlbnQpOwotCQlhc3NlcnRFcXVhbHModGhpcy50ZXN0TW9kZWwsIHRoaXMudHJlZUNoYW5nZUV2ZW50LmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKFRSRUVfTkFNRSwgdGhpcy50cmVlQ2hhbmdlRXZlbnQuZ2V0VHJlZU5hbWUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhwYXRoLCB0aGlzLnRyZWVDaGFuZ2VFdmVudC5nZXRQYXRoKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VmFsdWVzQXJlRXF1YWwxKCkgewotCQlhc3NlcnRUcnVlKHRoaXMudGVzdE1vZGVsLnRlc3RWYWx1ZXNBcmVFcXVhbChudWxsLCBudWxsKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMudGVzdE1vZGVsLnRlc3RWYWx1ZXNBcmVEaWZmZXJlbnQobnVsbCwgbnVsbCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RWYWx1ZXNBcmVFcXVhbDIoKSB7Ci0JCWFzc2VydFRydWUodGhpcy50ZXN0TW9kZWwudGVzdFZhbHVlc0FyZUVxdWFsKCJmb28iLCAiZm9vIikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnRlc3RNb2RlbC50ZXN0VmFsdWVzQXJlRGlmZmVyZW50KCJmb28iLCAiZm9vIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RWYWx1ZXNBcmVFcXVhbDMoKSB7Ci0JCWFzc2VydEZhbHNlKHRoaXMudGVzdE1vZGVsLnRlc3RWYWx1ZXNBcmVFcXVhbCgiZm9vIiwgbnVsbCkpOwotCQlhc3NlcnRUcnVlKHRoaXMudGVzdE1vZGVsLnRlc3RWYWx1ZXNBcmVEaWZmZXJlbnQoImZvbyIsIG51bGwpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VmFsdWVzQXJlRXF1YWw0KCkgewotCQlhc3NlcnRGYWxzZSh0aGlzLnRlc3RNb2RlbC50ZXN0VmFsdWVzQXJlRXF1YWwobnVsbCwgImZvbyIpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnRlc3RNb2RlbC50ZXN0VmFsdWVzQXJlRGlmZmVyZW50KG51bGwsICJmb28iKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFZhbHVlc0FyZUVxdWFsNSgpIHsKLQkJYXNzZXJ0RmFsc2UodGhpcy50ZXN0TW9kZWwudGVzdFZhbHVlc0FyZUVxdWFsKCJiYXIiLCAiZm9vIikpOwotCQlhc3NlcnRUcnVlKHRoaXMudGVzdE1vZGVsLnRlc3RWYWx1ZXNBcmVEaWZmZXJlbnQoImJhciIsICJmb28iKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGxpc3RlbmVyIGltcGxlbWVudGF0aW9ucyAqKioqKioqKioqCi0KLQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoU3RhdGVDaGFuZ2VFdmVudCBlKSB7Ci0JCXRoaXMuc3RhdGVDaGFuZ2VkQ2FsbGVkID0gdHJ1ZTsKLQkJdGhpcy5zdGF0ZUNoYW5nZUV2ZW50ID0gZTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCXRoaXMucHJvcGVydHlDaGFuZ2VDYWxsZWQgPSB0cnVlOwotCQl0aGlzLnByb3BlcnR5Q2hhbmdlRXZlbnQgPSBlOwotCX0KLQotCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJdGhpcy5pdGVtc0FkZGVkQ29sbGVjdGlvbkNhbGxlZCA9IHRydWU7Ci0JCXRoaXMuY29sbGVjdGlvbkNoYW5nZUV2ZW50ID0gZTsKLQl9Ci0JcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7Ci0JCXRoaXMuaXRlbXNSZW1vdmVkQ29sbGVjdGlvbkNhbGxlZCA9IHRydWU7Ci0JCXRoaXMuY29sbGVjdGlvbkNoYW5nZUV2ZW50ID0gZTsKLQl9Ci0JcHVibGljIHZvaWQgY29sbGVjdGlvbkNsZWFyZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJdGhpcy5jb2xsZWN0aW9uQ2xlYXJlZENhbGxlZCA9IHRydWU7Ci0JCXRoaXMuY29sbGVjdGlvbkNoYW5nZUV2ZW50ID0gZTsKLQl9Ci0JcHVibGljIHZvaWQgY29sbGVjdGlvbkNoYW5nZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJdGhpcy5jb2xsZWN0aW9uQ2hhbmdlZENhbGxlZCA9IHRydWU7Ci0JCXRoaXMuY29sbGVjdGlvbkNoYW5nZUV2ZW50ID0gZTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCXRoaXMuaXRlbXNBZGRlZExpc3RDYWxsZWQgPSB0cnVlOwotCQl0aGlzLmxpc3RDaGFuZ2VFdmVudCA9IGU7Ci0JfQotCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQl0aGlzLml0ZW1zUmVtb3ZlZExpc3RDYWxsZWQgPSB0cnVlOwotCQl0aGlzLmxpc3RDaGFuZ2VFdmVudCA9IGU7Ci0JfQotCXB1YmxpYyB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJdGhpcy5pdGVtc1JlcGxhY2VkTGlzdENhbGxlZCA9IHRydWU7Ci0JCXRoaXMubGlzdENoYW5nZUV2ZW50ID0gZTsKLQl9Ci0JcHVibGljIHZvaWQgaXRlbXNNb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQl0aGlzLml0ZW1zTW92ZWRMaXN0Q2FsbGVkID0gdHJ1ZTsKLQkJdGhpcy5saXN0Q2hhbmdlRXZlbnQgPSBlOwotCX0KLQlwdWJsaWMgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQl0aGlzLmxpc3RDbGVhcmVkQ2FsbGVkID0gdHJ1ZTsKLQkJdGhpcy5saXN0Q2hhbmdlRXZlbnQgPSBlOwotCX0KLQlwdWJsaWMgdm9pZCBsaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQl0aGlzLmxpc3RDaGFuZ2VkQ2FsbGVkID0gdHJ1ZTsKLQkJdGhpcy5saXN0Q2hhbmdlRXZlbnQgPSBlOwotCX0KLQotCXB1YmxpYyB2b2lkIG5vZGVBZGRlZChUcmVlQ2hhbmdlRXZlbnQgZSkgewotCQl0aGlzLm5vZGVBZGRlZENhbGxlZCA9IHRydWU7Ci0JCXRoaXMudHJlZUNoYW5nZUV2ZW50ID0gZTsKLQl9Ci0JcHVibGljIHZvaWQgbm9kZVJlbW92ZWQoVHJlZUNoYW5nZUV2ZW50IGUpIHsKLQkJdGhpcy5ub2RlUmVtb3ZlZENhbGxlZCA9IHRydWU7Ci0JCXRoaXMudHJlZUNoYW5nZUV2ZW50ID0gZTsKLQl9Ci0JcHVibGljIHZvaWQgdHJlZUNsZWFyZWQoVHJlZUNoYW5nZUV2ZW50IGUpIHsKLQkJdGhpcy50cmVlQ2xlYXJlZENhbGxlZCA9IHRydWU7Ci0JCXRoaXMudHJlZUNoYW5nZUV2ZW50ID0gZTsKLQl9Ci0JcHVibGljIHZvaWQgdHJlZUNoYW5nZWQoVHJlZUNoYW5nZUV2ZW50IGUpIHsKLQkJdGhpcy50cmVlQ2hhbmdlZENhbGxlZCA9IHRydWU7Ci0JCXRoaXMudHJlZUNoYW5nZUV2ZW50ID0gZTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIGlubmVyIGNsYXNzICoqKioqKioqKioKLQkKLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBUZXN0TW9kZWwgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIGltcGxlbWVudHMgQ2xvbmVhYmxlIHsKLQkJVGVzdE1vZGVsKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQotCQlwdWJsaWMgdm9pZCB0ZXN0RmlyZVN0YXRlQ2hhbmdlKCkgewotCQkJdGhpcy5maXJlU3RhdGVDaGFuZ2VkKCk7Ci0JCX0KLQkKLQkJcHVibGljIHZvaWQgdGVzdEZpcmVQcm9wZXJ0eUNoYW5nZU9iamVjdE9iamVjdCgpIHsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChQUk9QRVJUWV9OQU1FLCBPTERfT0JKRUNUX1ZBTFVFLCBORVdfT0JKRUNUX1ZBTFVFKTsKLQkJfQotCQotCQlwdWJsaWMgdm9pZCB0ZXN0RmlyZVByb3BlcnR5Q2hhbmdlT2JqZWN0KCkgewotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKFBST1BFUlRZX05BTUUsIE5FV19PQkpFQ1RfVkFMVUUpOwotCQl9Ci0JCi0JCXB1YmxpYyB2b2lkIHRlc3RGaXJlUHJvcGVydHlDaGFuZ2VJbnRJbnQoKSB7Ci0JCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoUFJPUEVSVFlfTkFNRSwgT0xEX0lOVF9WQUxVRS5pbnRWYWx1ZSgpLCBORVdfSU5UX1ZBTFVFLmludFZhbHVlKCkpOwotCQl9Ci0JCi0JCXB1YmxpYyB2b2lkIHRlc3RGaXJlUHJvcGVydHlDaGFuZ2VCb29sZWFuQm9vbGVhbigpIHsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChQUk9QRVJUWV9OQU1FLCBPTERfQk9PTEVBTl9WQUxVRS5ib29sZWFuVmFsdWUoKSwgTkVXX0JPT0xFQU5fVkFMVUUuYm9vbGVhblZhbHVlKCkpOwotCQl9Ci0JCi0JCXB1YmxpYyB2b2lkIHRlc3RGaXJlSXRlbUFkZGVkQ29sbGVjdGlvbigpIHsKLQkJCXRoaXMuZmlyZUl0ZW1BZGRlZChDT0xMRUNUSU9OX05BTUUsIEFEREVEX09CSkVDVF9WQUxVRSk7Ci0JCX0KLQkKLQkJcHVibGljIHZvaWQgdGVzdEZpcmVJdGVtUmVtb3ZlZENvbGxlY3Rpb24oKSB7Ci0JCQl0aGlzLmZpcmVJdGVtUmVtb3ZlZChDT0xMRUNUSU9OX05BTUUsIFJFTU9WRURfT0JKRUNUX1ZBTFVFKTsKLQkJfQotCQotCQlwdWJsaWMgdm9pZCB0ZXN0RmlyZUNvbGxlY3Rpb25DbGVhcmVkKCkgewotCQkJdGhpcy5maXJlQ29sbGVjdGlvbkNsZWFyZWQoQ09MTEVDVElPTl9OQU1FKTsKLQkJfQotCQotCQlwdWJsaWMgdm9pZCB0ZXN0RmlyZUNvbGxlY3Rpb25DaGFuZ2VkKCkgewotCQkJdGhpcy5maXJlQ29sbGVjdGlvbkNoYW5nZWQoQ09MTEVDVElPTl9OQU1FKTsKLQkJfQotCQotCQlwdWJsaWMgdm9pZCB0ZXN0RmlyZUl0ZW1BZGRlZExpc3QoKSB7Ci0JCQl0aGlzLmZpcmVJdGVtQWRkZWQoTElTVF9OQU1FLCBBRERfSU5ERVgsIEFEREVEX09CSkVDVF9WQUxVRSk7Ci0JCX0KLQkKLQkJcHVibGljIHZvaWQgdGVzdEZpcmVJdGVtUmVtb3ZlZExpc3QoKSB7Ci0JCQl0aGlzLmZpcmVJdGVtUmVtb3ZlZChMSVNUX05BTUUsIFJFTU9WRV9JTkRFWCwgUkVNT1ZFRF9PQkpFQ1RfVkFMVUUpOwotCQl9Ci0JCi0JCXB1YmxpYyB2b2lkIHRlc3RGaXJlSXRlbVJlcGxhY2VkTGlzdCgpIHsKLQkJCXRoaXMuZmlyZUl0ZW1SZXBsYWNlZChMSVNUX05BTUUsIFJFUExBQ0VfSU5ERVgsIEFEREVEX09CSkVDVF9WQUxVRSwgUkVNT1ZFRF9PQkpFQ1RfVkFMVUUpOwotCQl9Ci0JCi0JCXB1YmxpYyB2b2lkIHRlc3RGaXJlSXRlbU1vdmVkTGlzdCgpIHsKLQkJCXRoaXMuZmlyZUl0ZW1Nb3ZlZChMSVNUX05BTUUsIFRBUkdFVF9JTkRFWCwgU09VUkNFX0lOREVYKTsKLQkJfQotCQotCQlwdWJsaWMgdm9pZCB0ZXN0RmlyZUxpc3RDbGVhcmVkKCkgewotCQkJdGhpcy5maXJlTGlzdENsZWFyZWQoTElTVF9OQU1FKTsKLQkJfQotCQotCQlwdWJsaWMgdm9pZCB0ZXN0RmlyZUxpc3RDaGFuZ2VkKCkgewotCQkJdGhpcy5maXJlTGlzdENoYW5nZWQoTElTVF9OQU1FKTsKLQkJfQotCQotCQlwdWJsaWMgdm9pZCB0ZXN0RmlyZU5vZGVBZGRlZE9iamVjdEFycmF5UGF0aCgpIHsKLQkJCXRoaXMuZmlyZU5vZGVBZGRlZChUUkVFX05BTUUsIE9CSkVDVF9BUlJBWV9QQVRIKTsKLQkJfQotCQotCQlwdWJsaWMgdm9pZCB0ZXN0RmlyZU5vZGVSZW1vdmVkT2JqZWN0QXJyYXlQYXRoKCkgewotCQkJdGhpcy5maXJlTm9kZVJlbW92ZWQoVFJFRV9OQU1FLCBPQkpFQ1RfQVJSQVlfUEFUSCk7Ci0JCX0KLQkKLQkJcHVibGljIHZvaWQgdGVzdEZpcmVUcmVlQ2xlYXJlZCgpIHsKLQkJCXRoaXMuZmlyZVRyZWVDbGVhcmVkKFRSRUVfTkFNRSk7Ci0JCX0KLQkKLQkJcHVibGljIHZvaWQgdGVzdEZpcmVUcmVlQ2hhbmdlZE9iamVjdEFycmF5UGF0aCgpIHsKLQkJCXRoaXMuZmlyZVRyZWVDaGFuZ2VkKFRSRUVfTkFNRSwgT0JKRUNUX0FSUkFZX1BBVEgpOwotCQl9Ci0JCi0JCXB1YmxpYyB2b2lkIHRlc3RBdHRyaWJ1dGVWYWx1ZUhhc0NoYW5nZWQoKSB7Ci0JCQlhc3NlcnRUcnVlKHRoaXMuYXR0cmlidXRlVmFsdWVIYXNDaGFuZ2VkKG51bGwsIG5ldyBPYmplY3QoKSkpOwotCQkJYXNzZXJ0VHJ1ZSh0aGlzLmF0dHJpYnV0ZVZhbHVlSGFzQ2hhbmdlZChuZXcgT2JqZWN0KCksIG51bGwpKTsKLQkJCWFzc2VydFRydWUodGhpcy5hdHRyaWJ1dGVWYWx1ZUhhc0NoYW5nZWQobmV3IE9iamVjdCgpLCBuZXcgT2JqZWN0KCkpKTsKLQkKLQkJCU9iamVjdCBzYW1lID0gbmV3IE9iamVjdCgpOwotCQkJYXNzZXJ0RmFsc2UodGhpcy5hdHRyaWJ1dGVWYWx1ZUhhc0NoYW5nZWQoc2FtZSwgc2FtZSkpOwotCQkJYXNzZXJ0RmFsc2UodGhpcy5hdHRyaWJ1dGVWYWx1ZUhhc0NoYW5nZWQobnVsbCwgbnVsbCkpOwotCQl9Ci0JCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgVGVzdE1vZGVsIGNsb25lKCkgewotCQkJdHJ5IHsKLQkJCQlyZXR1cm4gKFRlc3RNb2RlbCkgc3VwZXIuY2xvbmUoKTsKLQkJCX0gY2F0Y2ggKENsb25lTm90U3VwcG9ydGVkRXhjZXB0aW9uIGV4KSB7Ci0JCQkJdGhyb3cgbmV3IEludGVybmFsRXJyb3IoKTsKLQkJCX0KLQkJfQotCQotCQlwdWJsaWMgYm9vbGVhbiB0ZXN0VmFsdWVzQXJlRGlmZmVyZW50KE9iamVjdCB2YWx1ZTEsIE9iamVjdCB2YWx1ZTIpIHsKLQkJCXJldHVybiB0aGlzLnZhbHVlc0FyZURpZmZlcmVudCh2YWx1ZTEsIHZhbHVlMik7Ci0JCX0KLQkJCi0JCXB1YmxpYyBib29sZWFuIHRlc3RWYWx1ZXNBcmVFcXVhbChPYmplY3QgdmFsdWUxLCBPYmplY3QgdmFsdWUyKSB7Ci0JCQlyZXR1cm4gdGhpcy52YWx1ZXNBcmVFcXVhbCh2YWx1ZTEsIHZhbHVlMik7Ci0JCX0KLQkJCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgdm9pZCB0b1N0cmluZyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCQlzYi5hcHBlbmQoVEVTVF9UT19TVFJJTkcpOwotCQl9Ci0JCi0JfQotCi0KLQkvLyAqKioqKioqKioqIHNlcmlhbGl6YXRpb24gdGVzdCAqKioqKioqKioqCQotCi0vL1RPRE8gLSBUaGlzIHRlc3QgZG9lc24ndCBwYXNzIGluIHRoZSBFY2xpcHNlIGJ1aWxkIGVudmlyb25tZW50IChMaW51eCkgZm9yIHNvbWUgcmVhc29uCi0vLwlwdWJsaWMgdm9pZCB0ZXN0U2VyaWFsaXphdGlvbigpIHRocm93cyBJT0V4Y2VwdGlvbiwgQ2xhc3NOb3RGb3VuZEV4Y2VwdGlvbiB7Ci0vLwkJTG9jYWxNb2RlbCBtb2RlbDEgPSBuZXcgTG9jYWxNb2RlbCgpOwotLy8JCUZvbyBmb28xID0gbmV3IEZvbygpOwotLy8JCUJhciBiYXIxID0gbmV3IEJhcigpOwotLy8JCUpvbyBqb28xID0gbmV3IEpvbygpOwotLy8JCUphciBqYXIxID0gbmV3IEphcigpOwotLy8JCW1vZGVsMS5hZGRTdGF0ZUNoYW5nZUxpc3RlbmVyKGZvbzEpOwotLy8JCW1vZGVsMS5hZGRTdGF0ZUNoYW5nZUxpc3RlbmVyKGJhcjEpOwotLy8JCW1vZGVsMS5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoam9vMSk7Ci0vLwkJbW9kZWwxLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihqYXIxKTsKLS8vCi0vLwkJQ2hhbmdlTGlzdGVuZXJbXSBsaXN0ZW5lcnMxID0gdGhpcy5saXN0ZW5lcnMobW9kZWwxLCBTdGF0ZUNoYW5nZUxpc3RlbmVyLmNsYXNzKTsKLS8vCQlhc3NlcnRFcXVhbHMoMiwgbGlzdGVuZXJzMS5sZW5ndGgpOwotLy8JCS8vIHRoZSBvcmRlciBvZiB0aGVzZSBjb3VsZCBjaGFuZ2UuLi4KLS8vCQlhc3NlcnRFcXVhbHMoRm9vLmNsYXNzLCBsaXN0ZW5lcnMxWzBdLmdldENsYXNzKCkpOwotLy8JCWFzc2VydEVxdWFscyhCYXIuY2xhc3MsIGxpc3RlbmVyczFbMV0uZ2V0Q2xhc3MoKSk7Ci0vLwotLy8JCWxpc3RlbmVyczEgPSB0aGlzLmxpc3RlbmVycyhtb2RlbDEsIExpc3RDaGFuZ2VMaXN0ZW5lci5jbGFzcyk7Ci0vLwkJYXNzZXJ0RXF1YWxzKDIsIGxpc3RlbmVyczEubGVuZ3RoKTsKLS8vCQkvLyB0aGUgb3JkZXIgb2YgdGhlc2UgY291bGQgY2hhbmdlLi4uCi0vLwkJYXNzZXJ0RXF1YWxzKEpvby5jbGFzcywgbGlzdGVuZXJzMVswXS5nZXRDbGFzcygpKTsKLS8vCQlhc3NlcnRFcXVhbHMoSmFyLmNsYXNzLCBsaXN0ZW5lcnMxWzFdLmdldENsYXNzKCkpOwotLy8KLS8vCQlMb2NhbE1vZGVsIG1vZGVsMiA9IFRlc3RUb29scy5zZXJpYWxpemUobW9kZWwxKTsKLS8vCi0vLwkJQ2hhbmdlTGlzdGVuZXJbXSBsaXN0ZW5lcnMyID0gdGhpcy5saXN0ZW5lcnMobW9kZWwyLCBTdGF0ZUNoYW5nZUxpc3RlbmVyLmNsYXNzKTsKLS8vCQlhc3NlcnRFcXVhbHMoMSwgbGlzdGVuZXJzMi5sZW5ndGgpOwotLy8JCWFzc2VydEVxdWFscyhGb28uY2xhc3MsIGxpc3RlbmVyczJbMF0uZ2V0Q2xhc3MoKSk7Ci0vLwotLy8JCWxpc3RlbmVyczIgPSB0aGlzLmxpc3RlbmVycyhtb2RlbDIsIExpc3RDaGFuZ2VMaXN0ZW5lci5jbGFzcyk7Ci0vLwkJYXNzZXJ0RXF1YWxzKDEsIGxpc3RlbmVyczIubGVuZ3RoKTsKLS8vCQlhc3NlcnRFcXVhbHMoSm9vLmNsYXNzLCBsaXN0ZW5lcnMyWzBdLmdldENsYXNzKCkpOwotLy8JfQotCi0vLyA+Pj4+Pj4+Pj4+Pj4+Pj4+PiB0aGVzZSBtZXRob2RzIGFyZSBjYWxsZWQgYnkgI3Rlc3RTZXJpYWxpemF0aW9uKCksIGNvbW1lbnRlZCBvdXQgYWJvdmUuLi4KLQlwcml2YXRlIENoYW5nZUxpc3RlbmVyW10gbGlzdGVuZXJzKExvY2FsTW9kZWwgbW9kZWwsIENsYXNzPD8gZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lcj4gbGlzdGVuZXJDbGFzcykgewotCQlDaGFuZ2VTdXBwb3J0IGNoYW5nZVN1cHBvcnQgPSAoQ2hhbmdlU3VwcG9ydCkgQ2xhc3NUb29scy5maWVsZFZhbHVlKG1vZGVsLCAiY2hhbmdlU3VwcG9ydCIpOwotCQlyZXR1cm4gKENoYW5nZUxpc3RlbmVyW10pIENsYXNzVG9vbHMuZXhlY3V0ZU1ldGhvZChjaGFuZ2VTdXBwb3J0LCAibGlzdGVuZXJzIiwgQ2xhc3MuY2xhc3MsIGxpc3RlbmVyQ2xhc3MpOwotCX0KLQotCXByaXZhdGUgc3RhdGljIGNsYXNzIExvY2FsTW9kZWwgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIGltcGxlbWVudHMgU2VyaWFsaXphYmxlIHsKLQkJTG9jYWxNb2RlbCgpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBGb28gaW1wbGVtZW50cyBTZXJpYWxpemFibGUsIFN0YXRlQ2hhbmdlTGlzdGVuZXIgewotCQlGb28oKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHN0YXRlQ2hhbmdlZChTdGF0ZUNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQkvLyBkbyBub3RoaW5nCi0JCX0KLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBCYXIgaW1wbGVtZW50cyBTdGF0ZUNoYW5nZUxpc3RlbmVyIHsKLQkJQmFyKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoU3RhdGVDaGFuZ2VFdmVudCBldmVudCkgewotCQkJLy8gZG8gbm90aGluZwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBzdGF0aWMgY2xhc3MgSm9vIGV4dGVuZHMgTGlzdENoYW5nZUFkYXB0ZXIgaW1wbGVtZW50cyBTZXJpYWxpemFibGUgewotLy8JCXByaXZhdGUgc3RhdGljIGZpbmFsIE9iamVjdFN0cmVhbUZpZWxkW10gc2VyaWFsUGVyc2lzdGVudEZpZWxkcyA9IHtuZXcgT2JqZWN0U3RyZWFtRmllbGQoImNoYW5nZVN1cHBvcnQiLCBDaGFuZ2VTdXBwb3J0LmNsYXNzKX07Ci0JCUpvbygpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBKYXIgZXh0ZW5kcyBMaXN0Q2hhbmdlQWRhcHRlciB7Ci0JCUphcigpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogYnVnKD8pIHRlc3QgKioqKioqKioqKgkKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBJU0VfTUVTU0FHRSA9ICJ0aGlzIG9iamVjdCBpcyBubyBsb25nZXIgbGlzdGVuaW5nIHRvIGxvY2FsQSI7Ci0KLQkvKioKLQkgKiBUZXN0IHRoZSBmb2xsb3dpbmcgc2l0dWF0aW9uOgotCSAqIAktIGJvdGggQiBhbmQgQyBhcmUgbGlzdGVuaW5nIHRvIEEKLQkgKiAJLSBDIGlzIGFsc28gbGlzdGVuaW5nIHRvIEIKLQkgKiAJLSB3aGVuIEIgcmVjZWl2ZXMgYW4gZXZlbnQgZnJvbSBBLCBpdCB3aWxsIGZpcmUgYW4gZXZlbnQgdG8gQwotCSAqIAktIHdoZW4gQyByZWNlaXZlcyBhbiBldmVudCBmcm9tIEIsIGl0IHdpbGwgU1RPUCBsaXN0ZW5pbmcgdG8gQQotCSAqIAktIHRoZSBldmVudCBmcm9tIEIgdG8gQyBtYXkgYmUgcHJlY2VkZWQgb3IgZm9sbG93ZWQgKGRlcGVuZGluZyBvbgotCSAqIAkJdGhlIGhhc2ggcG9zaXRpb25zIG9mIGxpc3RlbmVycykgYnkgYW4gZXZlbnQgZnJvbSBBIHRvIEM6Ci0JICogCQktIGlmIHRoZSBBIHRvIEMgZXZlbnQgY29tZXMgZmlyc3QsIG5vIHByb2JsZW0KLQkgKiAJCS0gYnV0IGlmIHRoZSBBIHRvIEIgZXZlbnQgY29tZXMgZmlyc3QsIHRoZSBBIHRvIEMgZXZlbnQgc2hvdWxkIE5PVCBoYXBwZW4KLQkgKi8KLQlwdWJsaWMgdm9pZCB0ZXN0SW5kaXJlY3RSZW1vdmVTdGF0ZUxpc3RlbmVyKCkgewotCQl0aGlzLnZlcmlmeUluZGlyZWN0UmVtb3ZlTGlzdGVuZXIoCi0JCQluZXcgTm90aWZ5Q29tbWFuZCgpIHsKLQkJCQlwdWJsaWMgdm9pZCBub3RpZnlMaXN0ZW5lcnMoTG9jYWxBIGxvY2FsQSkgewotCQkJCQlsb2NhbEEubm90aWZ5U3RhdGVMaXN0ZW5lcnMoKTsKLQkJCQl9Ci0JCQl9Ci0JCSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEluZGlyZWN0UmVtb3ZlUHJvcGVydHlMaXN0ZW5lcigpIHsKLQkJdGhpcy52ZXJpZnlJbmRpcmVjdFJlbW92ZUxpc3RlbmVyKAotCQkJbmV3IE5vdGlmeUNvbW1hbmQoKSB7Ci0JCQkJcHVibGljIHZvaWQgbm90aWZ5TGlzdGVuZXJzKExvY2FsQSBsb2NhbEEpIHsKLQkJCQkJbG9jYWxBLm5vdGlmeVByb3BlcnR5TGlzdGVuZXJzKCk7Ci0JCQkJfQotCQkJfQotCQkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbmRpcmVjdFJlbW92ZUNvbGxlY3Rpb25MaXN0ZW5lcigpIHsKLQkJdGhpcy52ZXJpZnlJbmRpcmVjdFJlbW92ZUxpc3RlbmVyKAotCQkJbmV3IE5vdGlmeUNvbW1hbmQoKSB7Ci0JCQkJcHVibGljIHZvaWQgbm90aWZ5TGlzdGVuZXJzKExvY2FsQSBsb2NhbEEpIHsKLQkJCQkJbG9jYWxBLm5vdGlmeUNvbGxlY3Rpb25MaXN0ZW5lcnMoKTsKLQkJCQl9Ci0JCQl9Ci0JCSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEluZGlyZWN0UmVtb3ZlTGlzdExpc3RlbmVyKCkgewotCQl0aGlzLnZlcmlmeUluZGlyZWN0UmVtb3ZlTGlzdGVuZXIoCi0JCQluZXcgTm90aWZ5Q29tbWFuZCgpIHsKLQkJCQlwdWJsaWMgdm9pZCBub3RpZnlMaXN0ZW5lcnMoTG9jYWxBIGxvY2FsQSkgewotCQkJCQlsb2NhbEEubm90aWZ5TGlzdExpc3RlbmVycygpOwotCQkJCX0KLQkJCX0KLQkJKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SW5kaXJlY3RSZW1vdmVUcmVlTGlzdGVuZXIoKSB7Ci0JCXRoaXMudmVyaWZ5SW5kaXJlY3RSZW1vdmVMaXN0ZW5lcigKLQkJCW5ldyBOb3RpZnlDb21tYW5kKCkgewotCQkJCXB1YmxpYyB2b2lkIG5vdGlmeUxpc3RlbmVycyhMb2NhbEEgbG9jYWxBKSB7Ci0JCQkJCWxvY2FsQS5ub3RpZnlUcmVlTGlzdGVuZXJzKCk7Ci0JCQkJfQotCQkJfQotCQkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHZlcmlmeUluZGlyZWN0UmVtb3ZlTGlzdGVuZXIoTm90aWZ5Q29tbWFuZCBjb21tYW5kKSB7Ci0JCUxvY2FsQSBsb2NhbEEgPSBuZXcgTG9jYWxBKCk7Ci0JCUxvY2FsQiBsb2NhbEIgPSBuZXcgTG9jYWxCKGxvY2FsQSk7Ci0KLQkJLy8gYnVpbGQgYSBidW5jaCBvZiBMb2NhbENzIHNvIGF0IGxlYXN0IG9uZSBvZiB0aGVtIGlzIG5vdGlmaWVkIEFGVEVSIHRoZSBMb2NhbEI7Ci0JCS8vIHVzaW5nIDEwMDAgc2VlbWVkIHRvIGZhaWwgdmVyeSBjb25zaXN0ZW50bHkgYmVmb3JlIENoYW5nZVN1cHBvcnQgd2FzIGZpeGVkCi0JCUxvY2FsQ1tdIGxvY2FsQ3MgPSBuZXcgTG9jYWxDWzEwMDBdOwotCQlmb3IgKGludCBpID0gbG9jYWxDcy5sZW5ndGg7IGktLSA+IDA7ICkgewotCQkJbG9jYWxDc1tpXSA9IG5ldyBMb2NhbEMobG9jYWxBLCBsb2NhbEIpOwotCQl9Ci0KLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJY29tbWFuZC5ub3RpZnlMaXN0ZW5lcnMobG9jYWxBKTsKLQkJfSBjYXRjaCAoSWxsZWdhbFN0YXRlRXhjZXB0aW9uIGV4KSB7Ci0JCQlpZiAoZXguZ2V0TWVzc2FnZSgpID09IElTRV9NRVNTQUdFKSB7Ci0JCQkJZXhDYXVnaHQgPSB0cnVlOwotCQkJfSBlbHNlIHsKLQkJCQl0aHJvdyBleDsKLQkJCX0KLQkJfQotCQlhc3NlcnRGYWxzZShleENhdWdodCk7Ci0KLQkJZm9yIChpbnQgaSA9IGxvY2FsQ3MubGVuZ3RoOyBpLS0gPiAwOyApIHsKLQkJCWFzc2VydEZhbHNlKGxvY2FsQ3NbaV0uaXNMaXN0ZW5pbmdUb0xvY2FsQSgpKTsKLQkJfQotCX0KLQotCXByaXZhdGUgaW50ZXJmYWNlIE5vdGlmeUNvbW1hbmQgewotCQl2b2lkIG5vdGlmeUxpc3RlbmVycyhMb2NhbEEgbG9jYWxBKTsKLQl9Ci0KLQkvKioKLQkgKiBUaGlzIG9iamVjdCBzaW1wbHkgZmlyZXMgYSBzdGF0ZSBjaGFuZ2UgZXZlbnQuIEJvdGggTG9jYWxCIGFuZCBMb2NhbEMKLQkgKiB3aWxsIGJlIGxpc3RlbmVycy4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBMb2NhbEEgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIHsKLQkJTG9jYWxBKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQl2b2lkIG5vdGlmeVN0YXRlTGlzdGVuZXJzKCkgewotCQkJdGhpcy5maXJlU3RhdGVDaGFuZ2VkKCk7Ci0JCX0KLQkJdm9pZCBub3RpZnlQcm9wZXJ0eUxpc3RlbmVycygpIHsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZCgiZm9vIiwgMSwgMik7Ci0JCX0KLQkJdm9pZCBub3RpZnlDb2xsZWN0aW9uTGlzdGVuZXJzKCkgewotCQkJdGhpcy5maXJlQ29sbGVjdGlvbkNoYW5nZWQoImZvbyIpOwotCQl9Ci0JCXZvaWQgbm90aWZ5TGlzdExpc3RlbmVycygpIHsKLQkJCXRoaXMuZmlyZUxpc3RDaGFuZ2VkKCJmb28iKTsKLQkJfQotCQl2b2lkIG5vdGlmeVRyZWVMaXN0ZW5lcnMoKSB7Ci0JCQl0aGlzLmZpcmVUcmVlQ2hhbmdlZCgiZm9vIik7Ci0JCX0KLQl9Ci0KLQkvKioKLQkgKiBUaGlzIG9iamVjdCB3aWxsIGZpcmUgc3RhdGUgY2hhbmdlIGV2ZW50cyB3aGVuZXZlciBpdCByZWNlaXZlcwotCSAqIGEgc3RhdGUgY2hhbmdlIGV2ZW50IGZyb20gbG9jYWxBLgotCSAqLwotCXByaXZhdGUgc3RhdGljIGNsYXNzIExvY2FsQgotCQlleHRlbmRzIEFic3RyYWN0TW9kZWwKLQkJaW1wbGVtZW50cyBTdGF0ZUNoYW5nZUxpc3RlbmVyLCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyLCBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIsIExpc3RDaGFuZ2VMaXN0ZW5lciwgVHJlZUNoYW5nZUxpc3RlbmVyCi0JewotCQlMb2NhbEIoTG9jYWxBIGxvY2FsQSkgewotCQkJc3VwZXIoKTsKLQkJCWxvY2FsQS5hZGRTdGF0ZUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQkJbG9jYWxBLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCQlsb2NhbEEuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQkJbG9jYWxBLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJCWxvY2FsQS5hZGRUcmVlQ2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCX0KLQotCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoU3RhdGVDaGFuZ2VFdmVudCBlKSB7Ci0JCQl0aGlzLmZpcmVTdGF0ZUNoYW5nZWQoKTsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGV2dCkgewotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKCJiYXIiLCAxLCAyKTsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIGNvbGxlY3Rpb25DaGFuZ2VkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7Ci0JCQl0aGlzLmZpcmVDb2xsZWN0aW9uQ2hhbmdlZCgiYmFyIik7Ci0JCX0KLQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNsZWFyZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsvKmlnbm9yZSovfQotCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7LyppZ25vcmUqL30KLQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7LyppZ25vcmUqL30KLQotCQlwdWJsaWMgdm9pZCBsaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJdGhpcy5maXJlTGlzdENoYW5nZWQoImJhciIpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGxpc3RDbGVhcmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7LyppZ25vcmUqL30KLQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZSkgey8qaWdub3JlKi99Ci0JCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZSkgey8qaWdub3JlKi99Ci0JCXB1YmxpYyB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsvKmlnbm9yZSovfQotCQlwdWJsaWMgdm9pZCBpdGVtc01vdmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7LyppZ25vcmUqL30KLQotCQlwdWJsaWMgdm9pZCB0cmVlQ2hhbmdlZChUcmVlQ2hhbmdlRXZlbnQgZSkgewotCQkJdGhpcy5maXJlVHJlZUNoYW5nZWQoImJhciIpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHRyZWVDbGVhcmVkKFRyZWVDaGFuZ2VFdmVudCBlKSB7LyppZ25vcmUqL30KLQkJcHVibGljIHZvaWQgbm9kZUFkZGVkKFRyZWVDaGFuZ2VFdmVudCBlKSB7LyppZ25vcmUqL30KLQkJcHVibGljIHZvaWQgbm9kZVJlbW92ZWQoVHJlZUNoYW5nZUV2ZW50IGUpIHsvKmlnbm9yZSovfQotCi0JfQotCi0JLyoqCi0JICogVGhpcyBvYmplY3Qgd2lsbCBsaXN0ZW4gdG8gdHdvIG90aGVyIG9iamVjdHMsIGxvY2FsQSBhbmQgbG9jYWxCLgotCSAqIElmIHRoaXMgb2JqZWN0IHJlY2VpdmVzIG5vdGlmaWNhdGlvbiBmcm9tIGxvY2FsQiwgaXQgd2lsbCBzdG9wIGxpc3RlbmluZyB0bwotCSAqIGxvY2FsQS4gSWYgdGhpcyBvYmplY3QgcmVjZWl2ZXMgbm90aWZpY2F0aW9uIGZyb20gbG9jYWxBLCBpdCB3aWxsIGNoZWNrIHRvCi0JICogc2VlIHdoZXRoZXIgaXQgc3RpbGwgbGlzdGVuaW5nIHRvIGxvY2FsQS4gSWYgdGhpcyBvYmplY3QgaXMgbm8gbG9uZ2VyCi0JICogbGlzdGVuaW5nIHRvIGxvY2FsQSwgaXQgd2lsbCBjb21wbGFpbiBhYm91dCByZWNlaXZpbmcgdGhlIGV2ZW50IGFuZAotCSAqIHRocm93IGFuIGV4Y2VwdGlvbi4KLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBMb2NhbEMKLQkJZXh0ZW5kcyBBYnN0cmFjdE1vZGVsCi0JCWltcGxlbWVudHMgU3RhdGVDaGFuZ2VMaXN0ZW5lciwgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciwgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyLCBMaXN0Q2hhbmdlTGlzdGVuZXIsIFRyZWVDaGFuZ2VMaXN0ZW5lcgotCXsKLQkJcHJpdmF0ZSBMb2NhbEEgbG9jYWxBOwotCQlwcml2YXRlIExvY2FsQiBsb2NhbEI7Ci0JCXByaXZhdGUgYm9vbGVhbiBsaXN0ZW5pbmdUb0xvY2FsQTsKLQotCQlMb2NhbEMoTG9jYWxBIGxvY2FsQSwgTG9jYWxCIGxvY2FsQikgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMubG9jYWxBID0gbG9jYWxBOwotCQkJdGhpcy5sb2NhbEIgPSBsb2NhbEI7Ci0KLQkJCWxvY2FsQS5hZGRTdGF0ZUNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQkJbG9jYWxBLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCQlsb2NhbEEuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQkJbG9jYWxBLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJCWxvY2FsQS5hZGRUcmVlQ2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCQl0aGlzLmxpc3RlbmluZ1RvTG9jYWxBID0gdHJ1ZTsKLQotCQkJbG9jYWxCLmFkZFN0YXRlQ2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCQlsb2NhbEIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJCWxvY2FsQi5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCQlsb2NhbEIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQkJbG9jYWxCLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJfQotCQlib29sZWFuIGlzTGlzdGVuaW5nVG9Mb2NhbEEoKSB7Ci0JCQlyZXR1cm4gdGhpcy5saXN0ZW5pbmdUb0xvY2FsQTsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIHN0YXRlQ2hhbmdlZChTdGF0ZUNoYW5nZUV2ZW50IGUpIHsKLQkJCU9iamVjdCBzb3VyY2UgPSBlLmdldFNvdXJjZSgpOwotCQkJaWYgKHNvdXJjZSA9PSB0aGlzLmxvY2FsQSkgewotCQkJCWlmICggISB0aGlzLmxpc3RlbmluZ1RvTG9jYWxBKSB7Ci0JCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oSVNFX01FU1NBR0UpOwotCQkJCX0KLQkJCX0gZWxzZSBpZiAoc291cmNlID09IHRoaXMubG9jYWxCKSB7Ci0JCQkJdGhpcy5sb2NhbEEucmVtb3ZlU3RhdGVDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJCQl0aGlzLmxpc3RlbmluZ1RvTG9jYWxBID0gZmFsc2U7Ci0JCQl9IGVsc2UgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oImJvZ3VzIGV2ZW50IHNvdXJjZTogIiArIHNvdXJjZSk7Ci0JCQl9Ci0JCX0KLQotCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCQlPYmplY3Qgc291cmNlID0gZS5nZXRTb3VyY2UoKTsKLQkJCWlmIChzb3VyY2UgPT0gdGhpcy5sb2NhbEEpIHsKLQkJCQlpZiAoICEgdGhpcy5saXN0ZW5pbmdUb0xvY2FsQSkgewotCQkJCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKElTRV9NRVNTQUdFKTsKLQkJCQl9Ci0JCQl9IGVsc2UgaWYgKHNvdXJjZSA9PSB0aGlzLmxvY2FsQikgewotCQkJCXRoaXMubG9jYWxBLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIodGhpcyk7Ci0JCQkJdGhpcy5saXN0ZW5pbmdUb0xvY2FsQSA9IGZhbHNlOwotCQkJfSBlbHNlIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJib2d1cyBldmVudCBzb3VyY2U6ICIgKyBzb3VyY2UpOwotCQkJfQotCQl9Ci0KLQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNoYW5nZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCU9iamVjdCBzb3VyY2UgPSBlLmdldFNvdXJjZSgpOwotCQkJaWYgKHNvdXJjZSA9PSB0aGlzLmxvY2FsQSkgewotCQkJCWlmICggISB0aGlzLmxpc3RlbmluZ1RvTG9jYWxBKSB7Ci0JCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oSVNFX01FU1NBR0UpOwotCQkJCX0KLQkJCX0gZWxzZSBpZiAoc291cmNlID09IHRoaXMubG9jYWxCKSB7Ci0JCQkJdGhpcy5sb2NhbEEucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHRoaXMpOwotCQkJCXRoaXMubGlzdGVuaW5nVG9Mb2NhbEEgPSBmYWxzZTsKLQkJCX0gZWxzZSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigiYm9ndXMgZXZlbnQgc291cmNlOiAiICsgc291cmNlKTsKLQkJCX0KLQkJfQotCQlwdWJsaWMgdm9pZCBjb2xsZWN0aW9uQ2xlYXJlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgey8qaWdub3JlKi99Ci0JCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsvKmlnbm9yZSovfQotCQlwdWJsaWMgdm9pZCBpdGVtc1JlbW92ZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsvKmlnbm9yZSovfQotCi0JCXB1YmxpYyB2b2lkIGxpc3RDaGFuZ2VkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQlPYmplY3Qgc291cmNlID0gZS5nZXRTb3VyY2UoKTsKLQkJCWlmIChzb3VyY2UgPT0gdGhpcy5sb2NhbEEpIHsKLQkJCQlpZiAoICEgdGhpcy5saXN0ZW5pbmdUb0xvY2FsQSkgewotCQkJCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKElTRV9NRVNTQUdFKTsKLQkJCQl9Ci0JCQl9IGVsc2UgaWYgKHNvdXJjZSA9PSB0aGlzLmxvY2FsQikgewotCQkJCXRoaXMubG9jYWxBLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJCQl0aGlzLmxpc3RlbmluZ1RvTG9jYWxBID0gZmFsc2U7Ci0JCQl9IGVsc2UgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oImJvZ3VzIGV2ZW50IHNvdXJjZTogIiArIHNvdXJjZSk7Ci0JCQl9Ci0JCX0KLQkJcHVibGljIHZvaWQgbGlzdENsZWFyZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsvKmlnbm9yZSovfQotCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBlKSB7LyppZ25vcmUqL30KLQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7LyppZ25vcmUqL30KLQkJcHVibGljIHZvaWQgaXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZSkgey8qaWdub3JlKi99Ci0JCXB1YmxpYyB2b2lkIGl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsvKmlnbm9yZSovfQotCi0JCXB1YmxpYyB2b2lkIHRyZWVDaGFuZ2VkKFRyZWVDaGFuZ2VFdmVudCBlKSB7Ci0JCQlPYmplY3Qgc291cmNlID0gZS5nZXRTb3VyY2UoKTsKLQkJCWlmIChzb3VyY2UgPT0gdGhpcy5sb2NhbEEpIHsKLQkJCQlpZiAoICEgdGhpcy5saXN0ZW5pbmdUb0xvY2FsQSkgewotCQkJCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKElTRV9NRVNTQUdFKTsKLQkJCQl9Ci0JCQl9IGVsc2UgaWYgKHNvdXJjZSA9PSB0aGlzLmxvY2FsQikgewotCQkJCXRoaXMubG9jYWxBLnJlbW92ZVRyZWVDaGFuZ2VMaXN0ZW5lcih0aGlzKTsKLQkJCQl0aGlzLmxpc3RlbmluZ1RvTG9jYWxBID0gZmFsc2U7Ci0JCQl9IGVsc2UgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oImJvZ3VzIGV2ZW50IHNvdXJjZTogIiArIHNvdXJjZSk7Ci0JCQl9Ci0JCX0KLQkJcHVibGljIHZvaWQgdHJlZUNsZWFyZWQoVHJlZUNoYW5nZUV2ZW50IGUpIHsvKmlnbm9yZSovfQotCQlwdWJsaWMgdm9pZCBub2RlQWRkZWQoVHJlZUNoYW5nZUV2ZW50IGUpIHsvKmlnbm9yZSovfQotCQlwdWJsaWMgdm9pZCBub2RlUmVtb3ZlZChUcmVlQ2hhbmdlRXZlbnQgZSkgey8qaWdub3JlKi99Ci0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvSnB0VXRpbGl0eU1vZGVsVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvSnB0VXRpbGl0eU1vZGVsVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzdlMzg2Yi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL0pwdFV0aWxpdHlNb2RlbFRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsOwotCi1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3Q7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RTdWl0ZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC5saXN0ZW5lci5KcHRVdGlsaXR5TW9kZWxMaXN0ZW5lclRlc3RzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLkpwdFV0aWxpdHlNb2RlbFZhbHVlVGVzdHM7Ci0KLXB1YmxpYyBjbGFzcyBKcHRVdGlsaXR5TW9kZWxUZXN0cyB7Ci0KLQlwdWJsaWMgc3RhdGljIFRlc3Qgc3VpdGUoKSB7Ci0JCVRlc3RTdWl0ZSBzdWl0ZSA9IG5ldyBUZXN0U3VpdGUoSnB0VXRpbGl0eU1vZGVsVGVzdHMuY2xhc3MuZ2V0UGFja2FnZSgpLmdldE5hbWUoKSk7Ci0KLQkJc3VpdGUuYWRkVGVzdChKcHRVdGlsaXR5TW9kZWxMaXN0ZW5lclRlc3RzLnN1aXRlKCkpOwotCQlzdWl0ZS5hZGRUZXN0KEpwdFV0aWxpdHlNb2RlbFZhbHVlVGVzdHMuc3VpdGUoKSk7Ci0KLQkJc3VpdGUuYWRkVGVzdFN1aXRlKEFic3RyYWN0TW9kZWxUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShOZXdFdmVudFRlc3RzLmNsYXNzKTsKLQotCQlyZXR1cm4gc3VpdGU7Ci0JfQotCi0JcHJpdmF0ZSBKcHRVdGlsaXR5TW9kZWxUZXN0cygpIHsKLQkJc3VwZXIoKTsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL05ld0V2ZW50VGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvTmV3RXZlbnRUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0YzkxNDM0Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvTmV3RXZlbnRUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTg3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDkgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWw7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQ2hhbmdlU3VwcG9ydDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5Nb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5DaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5UZXN0VG9vbHM7Ci0KLS8qKgotICogdGVzdCB3aGF0IGl0IHRha2VzIHRvIGFkZCBhIG5ldyB0eXBlIG9mIGV2ZW50IHRvCi0gKiBtb2RlbCBhbmQgY2hhbmdlIHN1cHBvcnQKLSAqLwotcHVibGljIGNsYXNzIE5ld0V2ZW50VGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBGb28gZm9vOwotCi0JcHVibGljIE5ld0V2ZW50VGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMuZm9vID0gbmV3IEZvbygpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTm9Gb29DaGFuZ2VMaXN0ZW5lcnMoKSB7Ci0JCWFzc2VydFRydWUodGhpcy5mb28uaGFzTm9Gb29DaGFuZ2VMaXN0ZW5lcnMoKSk7Ci0JCUxvY2FsTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgTG9jYWxMaXN0ZW5lcigpOwotCQl0aGlzLmZvby5hZGRGb29DaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWFzc2VydEZhbHNlKHRoaXMuZm9vLmhhc05vRm9vQ2hhbmdlTGlzdGVuZXJzKCkpOwotCQl0aGlzLmZvby5yZW1vdmVGb29DaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWFzc2VydFRydWUodGhpcy5mb28uaGFzTm9Gb29DaGFuZ2VMaXN0ZW5lcnMoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc0FueUZvb0NoYW5nZUxpc3RlbmVycygpIHsKLQkJYXNzZXJ0RmFsc2UodGhpcy5mb28uaGFzQW55Rm9vQ2hhbmdlTGlzdGVuZXJzKCkpOwotCQlMb2NhbExpc3RlbmVyIGxpc3RlbmVyID0gbmV3IExvY2FsTGlzdGVuZXIoKTsKLQkJdGhpcy5mb28uYWRkRm9vQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKHRoaXMuZm9vLmhhc0FueUZvb0NoYW5nZUxpc3RlbmVycygpKTsKLQkJdGhpcy5mb28ucmVtb3ZlRm9vQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmZvby5oYXNBbnlGb29DaGFuZ2VMaXN0ZW5lcnMoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEZpcmVGb29DaGFuZ2VFdmVudCgpIHsKLQkJTG9jYWxMaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBMb2NhbExpc3RlbmVyKCk7Ci0JCWFzc2VydEZhbHNlKGxpc3RlbmVyLnJlY2VpdmVkRm9vRXZlbnQpOwotCQl0aGlzLmZvby5hZGRGb29DaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCXRoaXMuZm9vLmZvbygpOwotCQlhc3NlcnRUcnVlKGxpc3RlbmVyLnJlY2VpdmVkRm9vRXZlbnQpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBoYXJuZXNzIGNsYXNzZXMgKioqKioqKioqKgotCi0JY2xhc3MgRm9vIGV4dGVuZHMgQWJzdHJhY3RGb29Nb2RlbCB7Ci0JCUZvbygpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQkJdm9pZCBmb28oKSB7Ci0JCQl0aGlzLmZpcmVGb29DaGFuZ2VFdmVudCgpOwotCQl9Ci0JfQotCi0JY2xhc3MgTG9jYWxMaXN0ZW5lciBpbXBsZW1lbnRzIEZvb0NoYW5nZUxpc3RlbmVyIHsKLQkJYm9vbGVhbiByZWNlaXZlZEZvb0V2ZW50ID0gZmFsc2U7Ci0JCUxvY2FsTGlzdGVuZXIoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGZvb0NoYW5nZWQoRm9vQ2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCXRoaXMucmVjZWl2ZWRGb29FdmVudCA9IHRydWU7Ci0JCX0KLQl9Ci0KLQlpbnRlcmZhY2UgRm9vTW9kZWwgZXh0ZW5kcyBNb2RlbCB7Ci0JCXZvaWQgYWRkRm9vQ2hhbmdlTGlzdGVuZXIoRm9vQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpOwotCQl2b2lkIHJlbW92ZUZvb0NoYW5nZUxpc3RlbmVyKEZvb0NoYW5nZUxpc3RlbmVyIGxpc3RlbmVyKTsKLQl9Ci0KLQlpbnRlcmZhY2UgRm9vQ2hhbmdlTGlzdGVuZXIgZXh0ZW5kcyBDaGFuZ2VMaXN0ZW5lciB7Ci0JCXZvaWQgZm9vQ2hhbmdlZChGb29DaGFuZ2VFdmVudCBldmVudCk7Ci0JfQotCi0Jc3RhdGljIGNsYXNzIEZvb0NoYW5nZUV2ZW50IGV4dGVuZHMgQ2hhbmdlRXZlbnQgewotCQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKLQkJcHVibGljIEZvb0NoYW5nZUV2ZW50KEZvb01vZGVsIHNvdXJjZSkgewotCQkJc3VwZXIoc291cmNlKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyBnZXRBc3BlY3ROYW1lKCkgewotCQkJcmV0dXJuIG51bGw7ICAvLyB0aGUgcG9pbnQgb2YgdGhlIGV2ZW50IGlzIHRoYXQgdGhlIG5hbWUgaXMgdW5rbm93bi4uLgotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgRm9vQ2hhbmdlRXZlbnQgY2xvbmVXaXRoU291cmNlKE1vZGVsIG5ld1NvdXJjZSkgewotCQkJcmV0dXJuIG5ldyBGb29DaGFuZ2VFdmVudCgoRm9vTW9kZWwpIG5ld1NvdXJjZSk7Ci0JCX0KLQl9Ci0KLQlzdGF0aWMgY2xhc3MgQWJzdHJhY3RGb29Nb2RlbCBleHRlbmRzIEFic3RyYWN0TW9kZWwgaW1wbGVtZW50cyBGb29Nb2RlbCB7Ci0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgc3luY2hyb25pemVkIEZvb0NoYW5nZVN1cHBvcnQgZ2V0Q2hhbmdlU3VwcG9ydCgpIHsKLQkJCXJldHVybiAoRm9vQ2hhbmdlU3VwcG9ydCkgc3VwZXIuZ2V0Q2hhbmdlU3VwcG9ydCgpOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgQ2hhbmdlU3VwcG9ydCBidWlsZENoYW5nZVN1cHBvcnQoKSB7Ci0JCQlyZXR1cm4gbmV3IEZvb0NoYW5nZVN1cHBvcnQodGhpcyk7Ci0JCX0KLQkJcHVibGljIHZvaWQgYWRkRm9vQ2hhbmdlTGlzdGVuZXIoRm9vQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpIHsKLQkJCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmFkZEZvb0NoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJfQotCQlwdWJsaWMgdm9pZCByZW1vdmVGb29DaGFuZ2VMaXN0ZW5lcihGb29DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQkJdGhpcy5nZXRDaGFuZ2VTdXBwb3J0KCkucmVtb3ZlRm9vQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQl9Ci0JCXByb3RlY3RlZCB2b2lkIGZpcmVGb29DaGFuZ2VFdmVudCgpIHsKLQkJCXRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmZpcmVGb29DaGFuZ2VkKCk7Ci0JCX0KLQkJcHVibGljIGJvb2xlYW4gaGFzQW55Rm9vQ2hhbmdlTGlzdGVuZXJzKCkgewotCQkJcmV0dXJuIHRoaXMuZ2V0Q2hhbmdlU3VwcG9ydCgpLmhhc0FueUZvb0NoYW5nZUxpc3RlbmVycygpOwotCQl9Ci0JCXB1YmxpYyBib29sZWFuIGhhc05vRm9vQ2hhbmdlTGlzdGVuZXJzKCkgewotCQkJcmV0dXJuICEgdGhpcy5oYXNBbnlGb29DaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJfQotCX0KLQotCXN0YXRpYyBjbGFzcyBGb29DaGFuZ2VTdXBwb3J0IGV4dGVuZHMgQ2hhbmdlU3VwcG9ydCB7Ci0JCUZvb0NoYW5nZVN1cHBvcnQoRm9vTW9kZWwgc291cmNlKSB7Ci0JCQlzdXBlcihzb3VyY2UpOwotCQl9Ci0JCXByb3RlY3RlZCBzdGF0aWMgZmluYWwgQ2xhc3M8Rm9vQ2hhbmdlTGlzdGVuZXI+IEZPT19DSEFOR0VfTElTVEVORVJfQ0xBU1MgPSBGb29DaGFuZ2VMaXN0ZW5lci5jbGFzczsKLQkJdm9pZCBhZGRGb29DaGFuZ2VMaXN0ZW5lcihGb29DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQkJdGhpcy5hZGRMaXN0ZW5lcihGT09fQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBsaXN0ZW5lcik7Ci0JCX0KLQkJdm9pZCByZW1vdmVGb29DaGFuZ2VMaXN0ZW5lcihGb29DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcikgewotCQkJdGhpcy5yZW1vdmVMaXN0ZW5lcihGT09fQ0hBTkdFX0xJU1RFTkVSX0NMQVNTLCBsaXN0ZW5lcik7Ci0JCX0KLQkJcHVibGljIGJvb2xlYW4gaGFzQW55Rm9vQ2hhbmdlTGlzdGVuZXJzKCkgewotCQkJcmV0dXJuIHRoaXMuaGFzQW55TGlzdGVuZXJzKEZPT19DSEFOR0VfTElTVEVORVJfQ0xBU1MpOwotCQl9Ci0JCXByaXZhdGUgRm9vQ2hhbmdlTGlzdGVuZXJbXSBmb29DaGFuZ2VMaXN0ZW5lcnMoKSB7Ci0JCQlyZXR1cm4gKEZvb0NoYW5nZUxpc3RlbmVyW10pIHRoaXMuZ2V0TGlzdGVuZXJzKEZPT19DSEFOR0VfTElTVEVORVJfQ0xBU1MpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGZpcmVGb29DaGFuZ2VkKCkgewotCQkJRm9vQ2hhbmdlTGlzdGVuZXJbXSB0YXJnZXRzID0gbnVsbDsKLQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCUZvb0NoYW5nZUxpc3RlbmVyW10gZm9vQ2hhbmdlTGlzdGVuZXJzID0gdGhpcy5mb29DaGFuZ2VMaXN0ZW5lcnMoKTsKLQkJCQlpZiAoZm9vQ2hhbmdlTGlzdGVuZXJzICE9IG51bGwpIHsKLQkJCQkJdGFyZ2V0cyA9IGZvb0NoYW5nZUxpc3RlbmVycy5jbG9uZSgpOwotCQkJCX0KLQkJCX0KLQkJCWlmICh0YXJnZXRzICE9IG51bGwpIHsKLQkJCQlGb29DaGFuZ2VFdmVudCBldmVudCA9IG51bGw7Ci0JCQkJZm9yIChGb29DaGFuZ2VMaXN0ZW5lciB0YXJnZXQgOiB0YXJnZXRzKSB7Ci0JCQkJCWJvb2xlYW4gc3RpbGxMaXN0ZW5pbmc7Ci0JCQkJCXN5bmNocm9uaXplZCAodGhpcykgewotCQkJCQkJc3RpbGxMaXN0ZW5pbmcgPSBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5mb29DaGFuZ2VMaXN0ZW5lcnMoKSwgdGFyZ2V0KTsKLQkJCQkJfQotCQkJCQlpZiAoc3RpbGxMaXN0ZW5pbmcpIHsKLQkJCQkJCWlmIChldmVudCA9PSBudWxsKSB7Ci0JCQkJCQkJLy8gaGVyZSdzIHRoZSByZWFzb24gZm9yIHRoZSBkdXBsaWNhdGUgY29kZS4uLgotCQkJCQkJCWV2ZW50ID0gbmV3IEZvb0NoYW5nZUV2ZW50KChGb29Nb2RlbCkgdGhpcy5zb3VyY2UpOwotCQkJCQkJfQotCQkJCQkJdGFyZ2V0LmZvb0NoYW5nZWQoZXZlbnQpOwotCQkJCQl9Ci0JCQkJfQotCQkJfQotCQkJdGhpcy5zb3VyY2VDaGFuZ2VkKG51bGwpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL2xpc3RlbmVyL0pwdFV0aWxpdHlNb2RlbExpc3RlbmVyVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvbGlzdGVuZXIvSnB0VXRpbGl0eU1vZGVsTGlzdGVuZXJUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwODRhOWI4Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvbGlzdGVuZXIvSnB0VXRpbGl0eU1vZGVsTGlzdGVuZXJUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNyBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC5saXN0ZW5lcjsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0OwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0U3VpdGU7Ci0KLXB1YmxpYyBjbGFzcyBKcHRVdGlsaXR5TW9kZWxMaXN0ZW5lclRlc3RzIHsKLQkKLQlwdWJsaWMgc3RhdGljIFRlc3Qgc3VpdGUoKSB7Ci0JCVRlc3RTdWl0ZSBzdWl0ZSA9IG5ldyBUZXN0U3VpdGUoSnB0VXRpbGl0eU1vZGVsTGlzdGVuZXJUZXN0cy5jbGFzcy5nZXRQYWNrYWdlKCkuZ2V0TmFtZSgpKTsKLQotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoUmVmbGVjdGl2ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFJlZmxlY3RpdmVMaXN0Q2hhbmdlTGlzdGVuZXJUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShSZWZsZWN0aXZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFJlZmxlY3RpdmVTdGF0ZUNoYW5nZUxpc3RlbmVyVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoUmVmbGVjdGl2ZVRyZWVDaGFuZ2VMaXN0ZW5lclRlc3RzLmNsYXNzKTsKLQkKLQkJcmV0dXJuIHN1aXRlOwotCX0KLQkKLQlwcml2YXRlIEpwdFV0aWxpdHlNb2RlbExpc3RlbmVyVGVzdHMoKSB7Ci0JCXN1cGVyKCk7Ci0JCXRocm93IG5ldyBVbnN1cHBvcnRlZE9wZXJhdGlvbkV4Y2VwdGlvbigpOwotCX0KLQkKLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvbGlzdGVuZXIvUmVmbGVjdGl2ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL2xpc3RlbmVyL1JlZmxlY3RpdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0ZmIzYThjLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvbGlzdGVuZXIvUmVmbGVjdGl2ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0NTMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC5saXN0ZW5lcjsKLQotaW1wb3J0IGphdmEubGFuZy5yZWZsZWN0Lk1ldGhvZDsKLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkNsb25lSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Db2xsZWN0aW9uQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkxpc3RDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5SZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXI7Ci0KLXB1YmxpYyBjbGFzcyBSZWZsZWN0aXZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JCi0JcHVibGljIFJlZmxlY3RpdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBidWlsZFplcm9Bcmd1bWVudExpc3RlbmVyKE9iamVjdCB0YXJnZXQpIHsKLQkJcmV0dXJuIFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lci5idWlsZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcih0YXJnZXQsICJpdGVtQWRkZWRaZXJvQXJndW1lbnQiLCAiaXRlbVJlbW92ZWRaZXJvQXJndW1lbnQiLCAiY29sbGVjdGlvbkNsZWFyZWRaZXJvQXJndW1lbnQiLCAiY29sbGVjdGlvbkNoYW5nZWRaZXJvQXJndW1lbnQiKTsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBidWlsZFNpbmdsZUFyZ3VtZW50TGlzdGVuZXIoT2JqZWN0IHRhcmdldCkgewotCQlyZXR1cm4gUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyLmJ1aWxkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHRhcmdldCwgIml0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50IiwgIml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnQiLCAiY29sbGVjdGlvbkNsZWFyZWRTaW5nbGVBcmd1bWVudCIsICJjb2xsZWN0aW9uQ2hhbmdlZFNpbmdsZUFyZ3VtZW50Iik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZW1BZGRlZFplcm9Bcmd1bWVudCgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJU3RyaW5nIHN0cmluZyA9ICJmb28iOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0NPTExFQ1RJT04sIHN0cmluZyk7Ci0JCXRlc3RNb2RlbC5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZFplcm9Bcmd1bWVudExpc3RlbmVyKHRhcmdldCkpOwotCQl0ZXN0TW9kZWwuYWRkU3RyaW5nKHN0cmluZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNoYW5nZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SXRlbUFkZGVkWmVyb0FyZ3VtZW50TmFtZWRDb2xsZWN0aW9uKCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfQ09MTEVDVElPTiwgc3RyaW5nKTsKLQkJdGVzdE1vZGVsLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihUZXN0TW9kZWwuU1RSSU5HU19DT0xMRUNUSU9OLCB0aGlzLmJ1aWxkWmVyb0FyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoc3RyaW5nKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVtQWRkZWRTaW5nbGVBcmd1bWVudCgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJU3RyaW5nIHN0cmluZyA9ICJmb28iOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0NPTExFQ1RJT04sIHN0cmluZyk7Ci0JCXRlc3RNb2RlbC5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZFNpbmdsZUFyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoc3RyaW5nKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVtQWRkZWRTaW5nbGVBcmd1bWVudE5hbWVkQ29sbGVjdGlvbigpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJU3RyaW5nIHN0cmluZyA9ICJmb28iOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0NPTExFQ1RJT04sIHN0cmluZyk7Ci0JCXRlc3RNb2RlbC5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoVGVzdE1vZGVsLlNUUklOR1NfQ09MTEVDVElPTiwgdGhpcy5idWlsZFNpbmdsZUFyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoc3RyaW5nKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVtUmVtb3ZlZFplcm9Bcmd1bWVudCgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJU3RyaW5nIHN0cmluZyA9ICJmb28iOwotCQl0ZXN0TW9kZWwuYWRkU3RyaW5nKHN0cmluZyk7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfQ09MTEVDVElPTiwgc3RyaW5nKTsKLQkJdGVzdE1vZGVsLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcih0aGlzLmJ1aWxkWmVyb0FyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5yZW1vdmVTdHJpbmcoc3RyaW5nKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVtUmVtb3ZlZFplcm9Bcmd1bWVudE5hbWVkQ29sbGVjdGlvbigpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJU3RyaW5nIHN0cmluZyA9ICJmb28iOwotCQl0ZXN0TW9kZWwuYWRkU3RyaW5nKHN0cmluZyk7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfQ09MTEVDVElPTiwgc3RyaW5nKTsKLQkJdGVzdE1vZGVsLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihUZXN0TW9kZWwuU1RSSU5HU19DT0xMRUNUSU9OLCB0aGlzLmJ1aWxkWmVyb0FyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5yZW1vdmVTdHJpbmcoc3RyaW5nKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoc3RyaW5nKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19DT0xMRUNUSU9OLCBzdHJpbmcpOwotCQl0ZXN0TW9kZWwuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRTaW5nbGVBcmd1bWVudExpc3RlbmVyKHRhcmdldCkpOwotCQl0ZXN0TW9kZWwucmVtb3ZlU3RyaW5nKHN0cmluZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5pdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNoYW5nZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudE5hbWVkQ29sbGVjdGlvbigpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJU3RyaW5nIHN0cmluZyA9ICJmb28iOwotCQl0ZXN0TW9kZWwuYWRkU3RyaW5nKHN0cmluZyk7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfQ09MTEVDVElPTiwgc3RyaW5nKTsKLQkJdGVzdE1vZGVsLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihUZXN0TW9kZWwuU1RSSU5HU19DT0xMRUNUSU9OLCB0aGlzLmJ1aWxkU2luZ2xlQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLnJlbW92ZVN0cmluZyhzdHJpbmcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQuaXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25DbGVhcmVkWmVyb0FyZ3VtZW50KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoc3RyaW5nKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19DT0xMRUNUSU9OLCBzdHJpbmcpOwotCQl0ZXN0TW9kZWwuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRaZXJvQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLmNsZWFyU3RyaW5ncygpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQuY29sbGVjdGlvbkNsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25DbGVhcmVkWmVyb0FyZ3VtZW50TmFtZWRDb2xsZWN0aW9uKCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoc3RyaW5nKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19DT0xMRUNUSU9OLCBzdHJpbmcpOwotCQl0ZXN0TW9kZWwuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKFRlc3RNb2RlbC5TVFJJTkdTX0NPTExFQ1RJT04sIHRoaXMuYnVpbGRaZXJvQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLmNsZWFyU3RyaW5ncygpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQuY29sbGVjdGlvbkNsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25DbGVhcmVkU2luZ2xlQXJndW1lbnQoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCVN0cmluZyBzdHJpbmcgPSAiZm9vIjsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZyhzdHJpbmcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0NPTExFQ1RJT04sIHN0cmluZyk7Ci0JCXRlc3RNb2RlbC5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZFNpbmdsZUFyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5jbGVhclN0cmluZ3MoKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5jb2xsZWN0aW9uQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb2xsZWN0aW9uQ2xlYXJlZFNpbmdsZUFyZ3VtZW50TmFtZWRDb2xsZWN0aW9uKCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoc3RyaW5nKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19DT0xMRUNUSU9OLCBzdHJpbmcpOwotCQl0ZXN0TW9kZWwuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKFRlc3RNb2RlbC5TVFJJTkdTX0NPTExFQ1RJT04sIHRoaXMuYnVpbGRTaW5nbGVBcmd1bWVudExpc3RlbmVyKHRhcmdldCkpOwotCQl0ZXN0TW9kZWwuY2xlYXJTdHJpbmdzKCk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQuY29sbGVjdGlvbkNsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNoYW5nZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29sbGVjdGlvbkNoYW5nZWRaZXJvQXJndW1lbnQoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCVN0cmluZyBzdHJpbmcgPSAiZm9vIjsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZyhzdHJpbmcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0NPTExFQ1RJT04sIHN0cmluZyk7Ci0JCXRlc3RNb2RlbC5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZFplcm9Bcmd1bWVudExpc3RlbmVyKHRhcmdldCkpOwotCQl0ZXN0TW9kZWwucmVwbGFjZVN0cmluZ3MobmV3IFN0cmluZ1tdIHsiYmFyIiwgImJheiJ9KTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuY29sbGVjdGlvbkNoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb2xsZWN0aW9uQ2hhbmdlZFplcm9Bcmd1bWVudE5hbWVkQ29sbGVjdGlvbigpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJU3RyaW5nIHN0cmluZyA9ICJmb28iOwotCQl0ZXN0TW9kZWwuYWRkU3RyaW5nKHN0cmluZyk7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfQ09MTEVDVElPTiwgc3RyaW5nKTsKLQkJdGVzdE1vZGVsLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihUZXN0TW9kZWwuU1RSSU5HU19DT0xMRUNUSU9OLCB0aGlzLmJ1aWxkWmVyb0FyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5yZXBsYWNlU3RyaW5ncyhuZXcgU3RyaW5nW10geyJiYXIiLCAiYmF6In0pOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0LmNvbGxlY3Rpb25DaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25DaGFuZ2VkU2luZ2xlQXJndW1lbnQoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCVN0cmluZyBzdHJpbmcgPSAiZm9vIjsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZyhzdHJpbmcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0NPTExFQ1RJT04sIHN0cmluZyk7Ci0JCXRlc3RNb2RlbC5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZFNpbmdsZUFyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5yZXBsYWNlU3RyaW5ncyhuZXcgU3RyaW5nW10geyJiYXIiLCAiYmF6In0pOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25DaGFuZ2VkU2luZ2xlQXJndW1lbnROYW1lZENvbGxlY3Rpb24oKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCVN0cmluZyBzdHJpbmcgPSAiZm9vIjsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZyhzdHJpbmcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0NPTExFQ1RJT04sIHN0cmluZyk7Ci0JCXRlc3RNb2RlbC5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoVGVzdE1vZGVsLlNUUklOR1NfQ09MTEVDVElPTiwgdGhpcy5idWlsZFNpbmdsZUFyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5yZXBsYWNlU3RyaW5ncyhuZXcgU3RyaW5nW10geyJiYXIiLCAiYmF6In0pOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LmNvbGxlY3Rpb25DbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5jb2xsZWN0aW9uQ2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEJvZ3VzRG91YmxlQXJndW1lbnQxKCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfQ09MTEVDVElPTiwgc3RyaW5nKTsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyID0gUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyLmJ1aWxkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHRhcmdldCwgImNvbGxlY3Rpb25DaGFuZ2VkRG91YmxlQXJndW1lbnQiKTsKLQkJCWZhaWwoImJvZ3VzIGxpc3RlbmVyOiAiICsgbGlzdGVuZXIpOwotCQl9IGNhdGNoIChSdW50aW1lRXhjZXB0aW9uIGV4KSB7Ci0JCQlpZiAoZXguZ2V0Q2F1c2UoKS5nZXRDbGFzcygpID09IE5vU3VjaE1ldGhvZEV4Y2VwdGlvbi5jbGFzcykgewotCQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJCX0KLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Qm9ndXNEb3VibGVBcmd1bWVudDIoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJU3RyaW5nIHN0cmluZyA9ICJmb28iOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0NPTExFQ1RJT04sIHN0cmluZyk7Ci0JCU1ldGhvZCBtZXRob2QgPSBDbGFzc1Rvb2xzLm1ldGhvZCh0YXJnZXQsICJjb2xsZWN0aW9uQ2hhbmdlZERvdWJsZUFyZ3VtZW50IiwgbmV3IENsYXNzW10ge0NvbGxlY3Rpb25DaGFuZ2VFdmVudC5jbGFzcywgT2JqZWN0LmNsYXNzfSk7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lciA9IFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lci5idWlsZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcih0YXJnZXQsIG1ldGhvZCk7Ci0JCQlmYWlsKCJib2d1cyBsaXN0ZW5lcjogIiArIGxpc3RlbmVyKTsKLQkJfSBjYXRjaCAoUnVudGltZUV4Y2VwdGlvbiBleCkgewotCQkJaWYgKGV4LmdldE1lc3NhZ2UoKS5lcXVhbHMobWV0aG9kLnRvU3RyaW5nKCkpKSB7Ci0JCQkJZXhDYXVnaHQgPSB0cnVlOwotCQkJfQotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0ZW5lck1pc21hdGNoKCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfQ09MTEVDVElPTiwgc3RyaW5nKTsKLQkJLy8gYnVpbGQgYSBDT0xMRUNUSU9OIGNoYW5nZSBsaXN0ZW5lciBhbmQgaGFjayBpdCBzbyB3ZQotCQkvLyBjYW4gYWRkIGl0IGFzIGEgTElTVCBjaGFuZ2UgbGlzdGVuZXIKLQkJT2JqZWN0IGxpc3RlbmVyID0gUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyLmJ1aWxkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHRhcmdldCwgIml0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50Iik7Ci0JCXRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoKExpc3RDaGFuZ2VMaXN0ZW5lcikgbGlzdGVuZXIpOwotCi0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRlc3RNb2RlbC5jaGFuZ2VMaXN0KCk7Ci0JCQlmYWlsKCJsaXN0ZW5lciBtaXNtYXRjaDogIiArIGxpc3RlbmVyKTsKLQkJfSBjYXRjaCAoSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0KLQlwcml2YXRlIGNsYXNzIFRlc3RNb2RlbCBleHRlbmRzIEFic3RyYWN0TW9kZWwgewotCQlwcml2YXRlIENvbGxlY3Rpb248U3RyaW5nPiBzdHJpbmdzID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBTVFJJTkdTX0NPTExFQ1RJT04gPSAic3RyaW5ncyI7Ci0JCVRlc3RNb2RlbCgpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQkJSXRlcmF0b3I8U3RyaW5nPiBzdHJpbmdzKCkgewotCQkJcmV0dXJuIG5ldyBDbG9uZUl0ZXJhdG9yPFN0cmluZz4odGhpcy5zdHJpbmdzKSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIHZvaWQgcmVtb3ZlKFN0cmluZyBzKSB7Ci0JCQkJCVRlc3RNb2RlbC50aGlzLnJlbW92ZVN0cmluZyhzKTsKLQkJCQl9Ci0JCQl9OwotCQl9Ci0JCXZvaWQgYWRkU3RyaW5nKFN0cmluZyBzdHJpbmcpIHsKLQkJCXRoaXMuYWRkSXRlbVRvQ29sbGVjdGlvbihzdHJpbmcsIHRoaXMuc3RyaW5ncywgU1RSSU5HU19DT0xMRUNUSU9OKTsKLQkJfQotCQl2b2lkIHJlbW92ZVN0cmluZyhTdHJpbmcgc3RyaW5nKSB7Ci0JCQl0aGlzLnJlbW92ZUl0ZW1Gcm9tQ29sbGVjdGlvbihzdHJpbmcsIHRoaXMuc3RyaW5ncywgU1RSSU5HU19DT0xMRUNUSU9OKTsKLQkJfQotCQl2b2lkIGNsZWFyU3RyaW5ncygpIHsKLQkJCXRoaXMuY2xlYXJDb2xsZWN0aW9uKHRoaXMuc3RyaW5ncywgU1RSSU5HU19DT0xMRUNUSU9OKTsKLQkJfQotCQl2b2lkIHJlcGxhY2VTdHJpbmdzKFN0cmluZ1tdIG5ld1N0cmluZ3MpIHsKLQkJCXRoaXMuc3RyaW5ncy5jbGVhcigpOwotCQkJQ29sbGVjdGlvblRvb2xzLmFkZEFsbCh0aGlzLnN0cmluZ3MsIG5ld1N0cmluZ3MpOwotCQkJdGhpcy5maXJlQ29sbGVjdGlvbkNoYW5nZWQoU1RSSU5HU19DT0xMRUNUSU9OKTsKLQkJfQotCQl2b2lkIGNoYW5nZUxpc3QoKSB7Ci0JCQl0aGlzLmZpcmVMaXN0Q2hhbmdlZCgiYm9ndXMgbGlzdCIpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBjbGFzcyBUYXJnZXQgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsOwotCQlTdHJpbmcgY29sbGVjdGlvbk5hbWU7Ci0JCVN0cmluZyBzdHJpbmc7Ci0JCWJvb2xlYW4gaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyA9IGZhbHNlOwotCQlib29sZWFuIGl0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyA9IGZhbHNlOwotCQlib29sZWFuIGl0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyA9IGZhbHNlOwotCQlib29sZWFuIGl0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnID0gZmFsc2U7Ci0JCWJvb2xlYW4gY29sbGVjdGlvbkNsZWFyZWRaZXJvQXJndW1lbnRGbGFnID0gZmFsc2U7Ci0JCWJvb2xlYW4gY29sbGVjdGlvbkNsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcgPSBmYWxzZTsKLQkJYm9vbGVhbiBjb2xsZWN0aW9uQ2hhbmdlZFplcm9Bcmd1bWVudEZsYWcgPSBmYWxzZTsKLQkJYm9vbGVhbiBjb2xsZWN0aW9uQ2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyA9IGZhbHNlOwotCQlUYXJnZXQoVGVzdE1vZGVsIHRlc3RNb2RlbCwgU3RyaW5nIGNvbGxlY3Rpb25OYW1lLCBTdHJpbmcgc3RyaW5nKSB7Ci0JCQlzdXBlcigpOwotCQkJdGhpcy50ZXN0TW9kZWwgPSB0ZXN0TW9kZWw7Ci0JCQl0aGlzLmNvbGxlY3Rpb25OYW1lID0gY29sbGVjdGlvbk5hbWU7Ci0JCQl0aGlzLnN0cmluZyA9IHN0cmluZzsKLQkJfQotCQl2b2lkIGl0ZW1BZGRlZFplcm9Bcmd1bWVudCgpIHsKLQkJCXRoaXMuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyA9IHRydWU7Ci0JCX0KLQkJdm9pZCBpdGVtQWRkZWRTaW5nbGVBcmd1bWVudChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQkJdGhpcy5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcgPSB0cnVlOwotCQkJYXNzZXJ0U2FtZSh0aGlzLnRlc3RNb2RlbCwgZS5nZXRTb3VyY2UoKSk7Ci0JCQlhc3NlcnRFcXVhbHModGhpcy5jb2xsZWN0aW9uTmFtZSwgZS5nZXRDb2xsZWN0aW9uTmFtZSgpKTsKLQkJCWFzc2VydEVxdWFscyh0aGlzLnN0cmluZywgZS5pdGVtcygpLm5leHQoKSk7Ci0JCX0KLQkJdm9pZCBpdGVtUmVtb3ZlZFplcm9Bcmd1bWVudCgpIHsKLQkJCXRoaXMuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnID0gdHJ1ZTsKLQkJfQotCQl2b2lkIGl0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCXRoaXMuaXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcgPSB0cnVlOwotCQkJYXNzZXJ0U2FtZSh0aGlzLnRlc3RNb2RlbCwgZS5nZXRTb3VyY2UoKSk7Ci0JCQlhc3NlcnRFcXVhbHModGhpcy5jb2xsZWN0aW9uTmFtZSwgZS5nZXRDb2xsZWN0aW9uTmFtZSgpKTsKLQkJCWFzc2VydEVxdWFscyh0aGlzLnN0cmluZywgZS5pdGVtcygpLm5leHQoKSk7Ci0JCX0KLQkJdm9pZCBjb2xsZWN0aW9uQ2xlYXJlZFplcm9Bcmd1bWVudCgpIHsKLQkJCXRoaXMuY29sbGVjdGlvbkNsZWFyZWRaZXJvQXJndW1lbnRGbGFnID0gdHJ1ZTsKLQkJfQotCQl2b2lkIGNvbGxlY3Rpb25DbGVhcmVkU2luZ2xlQXJndW1lbnQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCXRoaXMuY29sbGVjdGlvbkNsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcgPSB0cnVlOwotCQkJYXNzZXJ0U2FtZSh0aGlzLnRlc3RNb2RlbCwgZS5nZXRTb3VyY2UoKSk7Ci0JCQlhc3NlcnRFcXVhbHModGhpcy5jb2xsZWN0aW9uTmFtZSwgZS5nZXRDb2xsZWN0aW9uTmFtZSgpKTsKLQkJCWFzc2VydEZhbHNlKGUuaXRlbXMoKS5oYXNOZXh0KCkpOwotCQl9Ci0JCXZvaWQgY29sbGVjdGlvbkNoYW5nZWRaZXJvQXJndW1lbnQoKSB7Ci0JCQl0aGlzLmNvbGxlY3Rpb25DaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyA9IHRydWU7Ci0JCX0KLQkJdm9pZCBjb2xsZWN0aW9uQ2hhbmdlZFNpbmdsZUFyZ3VtZW50KENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7Ci0JCQl0aGlzLmNvbGxlY3Rpb25DaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnID0gdHJ1ZTsKLQkJCWFzc2VydFNhbWUodGhpcy50ZXN0TW9kZWwsIGUuZ2V0U291cmNlKCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMuY29sbGVjdGlvbk5hbWUsIGUuZ2V0Q29sbGVjdGlvbk5hbWUoKSk7Ci0JCQlhc3NlcnRGYWxzZShlLml0ZW1zKCkuaGFzTmV4dCgpKTsKLQkJfQotCQl2b2lkIGNvbGxlY3Rpb25DaGFuZ2VkRG91YmxlQXJndW1lbnQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUsIE9iamVjdCBvKSB7Ci0JCQlmYWlsKCJib2d1cyBldmVudDogIiArIGUpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL2xpc3RlbmVyL1JlZmxlY3RpdmVMaXN0Q2hhbmdlTGlzdGVuZXJUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC9saXN0ZW5lci9SZWZsZWN0aXZlTGlzdENoYW5nZUxpc3RlbmVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYjNiZmFlNi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL2xpc3RlbmVyL1JlZmxlY3RpdmVMaXN0Q2hhbmdlTGlzdGVuZXJUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzQyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwubGlzdGVuZXI7Ci0KLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5NZXRob2Q7Ci1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5DbGFzc1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuQ2xvbmVMaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5MaXN0Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkxpc3RDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5SZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXI7Ci0KLXB1YmxpYyBjbGFzcyBSZWZsZWN0aXZlTGlzdENoYW5nZUxpc3RlbmVyVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JCi0JcHVibGljIFJlZmxlY3RpdmVMaXN0Q2hhbmdlTGlzdGVuZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RDaGFuZ2VMaXN0ZW5lciBidWlsZFplcm9Bcmd1bWVudExpc3RlbmVyKE9iamVjdCB0YXJnZXQpIHsKLQkJcmV0dXJuIFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lci5idWlsZExpc3RDaGFuZ2VMaXN0ZW5lcih0YXJnZXQsICJpdGVtQWRkZWRaZXJvQXJndW1lbnQiLCAiaXRlbVJlbW92ZWRaZXJvQXJndW1lbnQiLCAiaXRlbVJlcGxhY2VkWmVyb0FyZ3VtZW50IiwgIml0ZW1Nb3ZlZFplcm9Bcmd1bWVudCIsICJsaXN0Q2xlYXJlZFplcm9Bcmd1bWVudCIsICJsaXN0Q2hhbmdlZFplcm9Bcmd1bWVudCIpOwotCX0KLQotCXByaXZhdGUgTGlzdENoYW5nZUxpc3RlbmVyIGJ1aWxkU2luZ2xlQXJndW1lbnRMaXN0ZW5lcihPYmplY3QgdGFyZ2V0KSB7Ci0JCXJldHVybiBSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIuYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXIodGFyZ2V0LCAiaXRlbUFkZGVkU2luZ2xlQXJndW1lbnQiLCAiaXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudCIsICJpdGVtUmVwbGFjZWRTaW5nbGVBcmd1bWVudCIsICJpdGVtTW92ZWRTaW5nbGVBcmd1bWVudCIsICJsaXN0Q2xlYXJlZFNpbmdsZUFyZ3VtZW50IiwgImxpc3RDaGFuZ2VkU2luZ2xlQXJndW1lbnQiKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SXRlbUFkZGVkWmVyb0FyZ3VtZW50KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfTElTVCwgc3RyaW5nLCAwKTsKLQkJdGVzdE1vZGVsLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcih0aGlzLmJ1aWxkWmVyb0FyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoc3RyaW5nKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZXBsYWNlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlcGxhY2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1Nb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVtQWRkZWRaZXJvQXJndW1lbnROYW1lZExpc3QoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCVN0cmluZyBzdHJpbmcgPSAiZm9vIjsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19MSVNULCBzdHJpbmcsIDApOwotCQl0ZXN0TW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIHRoaXMuYnVpbGRaZXJvQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZyhzdHJpbmcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5pdGVtQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlcGxhY2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfTElTVCwgc3RyaW5nLCAwKTsKLQkJdGVzdE1vZGVsLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcih0aGlzLmJ1aWxkU2luZ2xlQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZyhzdHJpbmcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0Lml0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlcGxhY2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50TmFtZWRMaXN0KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfTElTVCwgc3RyaW5nLCAwKTsKLQkJdGVzdE1vZGVsLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihUZXN0TW9kZWwuU1RSSU5HU19MSVNULCB0aGlzLmJ1aWxkU2luZ2xlQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZyhzdHJpbmcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0Lml0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlcGxhY2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoc3RyaW5nKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19MSVNULCBzdHJpbmcsIDApOwotCQl0ZXN0TW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRaZXJvQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLnJlbW92ZVN0cmluZyhzdHJpbmcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5pdGVtUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlcGxhY2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50TmFtZWRMaXN0KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoc3RyaW5nKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19MSVNULCBzdHJpbmcsIDApOwotCQl0ZXN0TW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIHRoaXMuYnVpbGRaZXJvQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLnJlbW92ZVN0cmluZyhzdHJpbmcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5pdGVtUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlcGxhY2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnQoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCVN0cmluZyBzdHJpbmcgPSAiZm9vIjsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZyhzdHJpbmcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIHN0cmluZywgMCk7Ci0JCXRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZFNpbmdsZUFyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5yZW1vdmVTdHJpbmcoc3RyaW5nKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZXBsYWNlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlcGxhY2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1Nb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50TmFtZWRMaXN0KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoc3RyaW5nKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19MSVNULCBzdHJpbmcsIDApOwotCQl0ZXN0TW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIHRoaXMuYnVpbGRTaW5nbGVBcmd1bWVudExpc3RlbmVyKHRhcmdldCkpOwotCQl0ZXN0TW9kZWwucmVtb3ZlU3RyaW5nKHN0cmluZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5pdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZXBsYWNlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1Nb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENoYW5nZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SXRlbVJlcGxhY2VkWmVyb0FyZ3VtZW50KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgb2xkU3RyaW5nID0gImZvbyI7Ci0JCVN0cmluZyBuZXdTdHJpbmcgPSAiYmFyIjsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZyhvbGRTdHJpbmcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIG5ld1N0cmluZywgMCwgb2xkU3RyaW5nKTsKLQkJdGVzdE1vZGVsLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcih0aGlzLmJ1aWxkWmVyb0FyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5yZXBsYWNlU3RyaW5nKG9sZFN0cmluZywgbmV3U3RyaW5nKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0Lml0ZW1SZXBsYWNlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlcGxhY2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1Nb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVtUmVwbGFjZWRaZXJvQXJndW1lbnROYW1lZExpc3QoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCVN0cmluZyBvbGRTdHJpbmcgPSAiZm9vIjsKLQkJU3RyaW5nIG5ld1N0cmluZyA9ICJiYXIiOwotCQl0ZXN0TW9kZWwuYWRkU3RyaW5nKG9sZFN0cmluZyk7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfTElTVCwgbmV3U3RyaW5nLCAwLCBvbGRTdHJpbmcpOwotCQl0ZXN0TW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIHRoaXMuYnVpbGRaZXJvQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLnJlcGxhY2VTdHJpbmcob2xkU3RyaW5nLCBuZXdTdHJpbmcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQuaXRlbVJlcGxhY2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZW1SZXBsYWNlZFNpbmdsZUFyZ3VtZW50KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgb2xkU3RyaW5nID0gImZvbyI7Ci0JCVN0cmluZyBuZXdTdHJpbmcgPSAiYmFyIjsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZyhvbGRTdHJpbmcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIG5ld1N0cmluZywgMCwgb2xkU3RyaW5nKTsKLQkJdGVzdE1vZGVsLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcih0aGlzLmJ1aWxkU2luZ2xlQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLnJlcGxhY2VTdHJpbmcob2xkU3RyaW5nLCBuZXdTdHJpbmcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZXBsYWNlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5pdGVtUmVwbGFjZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZW1SZXBsYWNlZFNpbmdsZUFyZ3VtZW50TmFtZWRMaXN0KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgb2xkU3RyaW5nID0gImZvbyI7Ci0JCVN0cmluZyBuZXdTdHJpbmcgPSAiYmFyIjsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZyhvbGRTdHJpbmcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIG5ld1N0cmluZywgMCwgb2xkU3RyaW5nKTsKLQkJdGVzdE1vZGVsLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihUZXN0TW9kZWwuU1RSSU5HU19MSVNULCB0aGlzLmJ1aWxkU2luZ2xlQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLnJlcGxhY2VTdHJpbmcob2xkU3RyaW5nLCBuZXdTdHJpbmcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZXBsYWNlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5pdGVtUmVwbGFjZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZW1Nb3ZlZFplcm9Bcmd1bWVudCgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZygiemVybyIpOwotCQl0ZXN0TW9kZWwuYWRkU3RyaW5nKCJvbmUiKTsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZygidHdvIik7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoInRocmVlIik7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfTElTVCwgMCwgMik7Ci0JCXRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZFplcm9Bcmd1bWVudExpc3RlbmVyKHRhcmdldCkpOwotCQl0ZXN0TW9kZWwubW92ZVN0cmluZygwLCAyKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZXBsYWNlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0Lml0ZW1Nb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVtTW92ZWRaZXJvQXJndW1lbnROYW1lZExpc3QoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoInplcm8iKTsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZygib25lIik7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoInR3byIpOwotCQl0ZXN0TW9kZWwuYWRkU3RyaW5nKCJ0aHJlZSIpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIDAsIDIpOwotCQl0ZXN0TW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIHRoaXMuYnVpbGRaZXJvQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLm1vdmVTdHJpbmcoMCwgMik7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlcGxhY2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5pdGVtTW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1Nb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENoYW5nZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SXRlbU1vdmVkU2luZ2xlQXJndW1lbnQoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoInplcm8iKTsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZygib25lIik7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoInR3byIpOwotCQl0ZXN0TW9kZWwuYWRkU3RyaW5nKCJ0aHJlZSIpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIDAsIDIpOwotCQl0ZXN0TW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRTaW5nbGVBcmd1bWVudExpc3RlbmVyKHRhcmdldCkpOwotCQl0ZXN0TW9kZWwubW92ZVN0cmluZygwLCAyKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZXBsYWNlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQuaXRlbU1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVtTW92ZWRTaW5nbGVBcmd1bWVudE5hbWVkTGlzdCgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZygiemVybyIpOwotCQl0ZXN0TW9kZWwuYWRkU3RyaW5nKCJvbmUiKTsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZygidHdvIik7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoInRocmVlIik7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfTElTVCwgMCwgMik7Ci0JCXRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoVGVzdE1vZGVsLlNUUklOR1NfTElTVCwgdGhpcy5idWlsZFNpbmdsZUFyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5tb3ZlU3RyaW5nKDAsIDIpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZXBsYWNlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlcGxhY2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1Nb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5pdGVtTW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RDbGVhcmVkWmVyb0FyZ3VtZW50KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoc3RyaW5nKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19MSVNULCBudWxsLCAtMSk7Ci0JCXRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZFplcm9Bcmd1bWVudExpc3RlbmVyKHRhcmdldCkpOwotCQl0ZXN0TW9kZWwuY2xlYXJTdHJpbmdzKCk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlcGxhY2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5saXN0Q2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENoYW5nZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdENsZWFyZWRaZXJvQXJndW1lbnROYW1lZExpc3QoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCVN0cmluZyBzdHJpbmcgPSAiZm9vIjsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZyhzdHJpbmcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIG51bGwsIC0xKTsKLQkJdGVzdE1vZGVsLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihUZXN0TW9kZWwuU1RSSU5HU19MSVNULCB0aGlzLmJ1aWxkWmVyb0FyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5jbGVhclN0cmluZ3MoKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZXBsYWNlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1Nb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0Lmxpc3RDbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0Q2xlYXJlZFNpbmdsZUFyZ3VtZW50KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoc3RyaW5nKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19MSVNULCBudWxsLCAtMSk7Ci0JCXRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZFNpbmdsZUFyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5jbGVhclN0cmluZ3MoKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZXBsYWNlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1Nb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5saXN0Q2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0Q2xlYXJlZFNpbmdsZUFyZ3VtZW50TmFtZWRMaXN0KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlTdHJpbmcgc3RyaW5nID0gImZvbyI7Ci0JCXRlc3RNb2RlbC5hZGRTdHJpbmcoc3RyaW5nKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19MSVNULCBudWxsLCAtMSk7Ci0JCXRlc3RNb2RlbC5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoVGVzdE1vZGVsLlNUUklOR1NfTElTVCwgdGhpcy5idWlsZFNpbmdsZUFyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5jbGVhclN0cmluZ3MoKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZXBsYWNlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1Nb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5saXN0Q2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0Q2hhbmdlZFplcm9Bcmd1bWVudCgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJU3RyaW5nIHN0cmluZyA9ICJmb28iOwotCQl0ZXN0TW9kZWwuYWRkU3RyaW5nKHN0cmluZyk7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfTElTVCwgbnVsbCwgLTEpOwotCQl0ZXN0TW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRaZXJvQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLnJlcGxhY2VBbGxTdHJpbmdzKG5ldyBTdHJpbmdbXSB7ImJhciIsICJiYXoifSk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlcGxhY2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQubGlzdENoYW5nZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdENoYW5nZWRaZXJvQXJndW1lbnROYW1lZExpc3QoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCVN0cmluZyBzdHJpbmcgPSAiZm9vIjsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZyhzdHJpbmcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIG51bGwsIC0xKTsKLQkJdGVzdE1vZGVsLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihUZXN0TW9kZWwuU1RSSU5HU19MSVNULCB0aGlzLmJ1aWxkWmVyb0FyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5yZXBsYWNlQWxsU3RyaW5ncyhuZXcgU3RyaW5nW10geyJiYXIiLCAiYmF6In0pOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZXBsYWNlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlcGxhY2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1Nb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0Lmxpc3RDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RDaGFuZ2VkU2luZ2xlQXJndW1lbnQoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCVN0cmluZyBzdHJpbmcgPSAiZm9vIjsKLQkJdGVzdE1vZGVsLmFkZFN0cmluZyhzdHJpbmcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIG51bGwsIC0xKTsKLQkJdGVzdE1vZGVsLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcih0aGlzLmJ1aWxkU2luZ2xlQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLnJlcGxhY2VBbGxTdHJpbmdzKG5ldyBTdHJpbmdbXSB7ImJhciIsICJiYXoifSk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbVJlcGxhY2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbU1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lmxpc3RDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0Lmxpc3RDaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdENoYW5nZWRTaW5nbGVBcmd1bWVudE5hbWVkTGlzdCgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJU3RyaW5nIHN0cmluZyA9ICJmb28iOwotCQl0ZXN0TW9kZWwuYWRkU3RyaW5nKHN0cmluZyk7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfTElTVCwgbnVsbCwgLTEpOwotCQl0ZXN0TW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIHRoaXMuYnVpbGRTaW5nbGVBcmd1bWVudExpc3RlbmVyKHRhcmdldCkpOwotCQl0ZXN0TW9kZWwucmVwbGFjZUFsbFN0cmluZ3MobmV3IFN0cmluZ1tdIHsiYmFyIiwgImJheiJ9KTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1BZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuaXRlbUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtUmVwbGFjZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1SZXBsYWNlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5pdGVtTW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lml0ZW1Nb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5saXN0Q2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubGlzdENoYW5nZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQubGlzdENoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RCb2d1c0RvdWJsZUFyZ3VtZW50MSgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJU3RyaW5nIHN0cmluZyA9ICJmb28iOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIHN0cmluZywgMCk7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCUxpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lciA9IFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lci5idWlsZExpc3RDaGFuZ2VMaXN0ZW5lcih0YXJnZXQsICJsaXN0Q2hhbmdlZERvdWJsZUFyZ3VtZW50Iik7Ci0JCQlmYWlsKCJib2d1cyBsaXN0ZW5lcjogIiArIGxpc3RlbmVyKTsKLQkJfSBjYXRjaCAoUnVudGltZUV4Y2VwdGlvbiBleCkgewotCQkJaWYgKGV4LmdldENhdXNlKCkuZ2V0Q2xhc3MoKSA9PSBOb1N1Y2hNZXRob2RFeGNlcHRpb24uY2xhc3MpIHsKLQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEJvZ3VzRG91YmxlQXJndW1lbnQyKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCVN0cmluZyBzdHJpbmcgPSAiZm9vIjsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19MSVNULCBzdHJpbmcsIDApOwotCQlNZXRob2QgbWV0aG9kID0gQ2xhc3NUb29scy5tZXRob2QodGFyZ2V0LCAibGlzdENoYW5nZWREb3VibGVBcmd1bWVudCIsIG5ldyBDbGFzc1tdIHtMaXN0Q2hhbmdlRXZlbnQuY2xhc3MsIE9iamVjdC5jbGFzc30pOwotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlMaXN0Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSBSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIuYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXIodGFyZ2V0LCBtZXRob2QpOwotCQkJZmFpbCgiYm9ndXMgbGlzdGVuZXI6ICIgKyBsaXN0ZW5lcik7Ci0JCX0gY2F0Y2ggKFJ1bnRpbWVFeGNlcHRpb24gZXgpIHsKLQkJCWlmIChleC5nZXRNZXNzYWdlKCkuZXF1YWxzKG1ldGhvZC50b1N0cmluZygpKSkgewotCQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJCX0KLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdGVuZXJNaXNtYXRjaCgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJU3RyaW5nIHN0cmluZyA9ICJmb28iOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX0xJU1QsIHN0cmluZywgMCk7Ci0JCS8vIGJ1aWxkIGEgTElTVCBjaGFuZ2UgbGlzdGVuZXIgYW5kIGhhY2sgaXQgc28gd2UKLQkJLy8gY2FuIGFkZCBpdCBhcyBhIENPTExFQ1RJT04gY2hhbmdlIGxpc3RlbmVyCi0JCU9iamVjdCBsaXN0ZW5lciA9IFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lci5idWlsZExpc3RDaGFuZ2VMaXN0ZW5lcih0YXJnZXQsICJpdGVtQWRkZWRTaW5nbGVBcmd1bWVudCIpOwotCQl0ZXN0TW9kZWwuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKChDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIpIGxpc3RlbmVyKTsKLQotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0ZXN0TW9kZWwuY2hhbmdlQ29sbGVjdGlvbigpOwotCQkJZmFpbCgibGlzdGVuZXIgbWlzbWF0Y2g6ICIgKyBsaXN0ZW5lcik7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCi0JcHJpdmF0ZSBjbGFzcyBUZXN0TW9kZWwgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIHsKLQkJcHJpdmF0ZSBMaXN0PFN0cmluZz4gc3RyaW5ncyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgU1RSSU5HU19MSVNUID0gInN0cmluZ3MiOwotCQlUZXN0TW9kZWwoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCUxpc3RJdGVyYXRvcjxTdHJpbmc+IHN0cmluZ3MoKSB7Ci0JCQlyZXR1cm4gbmV3IENsb25lTGlzdEl0ZXJhdG9yPFN0cmluZz4odGhpcy5zdHJpbmdzKTsKLQkJfQotCQl2b2lkIGFkZFN0cmluZyhTdHJpbmcgc3RyaW5nKSB7Ci0JCQl0aGlzLmFkZEl0ZW1Ub0xpc3Qoc3RyaW5nLCB0aGlzLnN0cmluZ3MsIFNUUklOR1NfTElTVCk7Ci0JCX0KLQkJdm9pZCByZW1vdmVTdHJpbmcoU3RyaW5nIHN0cmluZykgewotCQkJdGhpcy5yZW1vdmVJdGVtRnJvbUxpc3QodGhpcy5zdHJpbmdzLmluZGV4T2Yoc3RyaW5nKSwgdGhpcy5zdHJpbmdzLCBTVFJJTkdTX0xJU1QpOwotCQl9Ci0JCXZvaWQgcmVwbGFjZVN0cmluZyhTdHJpbmcgb2xkU3RyaW5nLCBTdHJpbmcgbmV3U3RyaW5nKSB7Ci0JCQl0aGlzLnNldEl0ZW1Jbkxpc3QodGhpcy5zdHJpbmdzLmluZGV4T2Yob2xkU3RyaW5nKSwgbmV3U3RyaW5nLCB0aGlzLnN0cmluZ3MsIFNUUklOR1NfTElTVCk7Ci0JCX0KLQkJdm9pZCBtb3ZlU3RyaW5nKGludCB0YXJnZXRJbmRleCwgaW50IHNvdXJjZUluZGV4KSB7Ci0JCQl0aGlzLm1vdmVJdGVtSW5MaXN0KHRhcmdldEluZGV4LCBzb3VyY2VJbmRleCwgdGhpcy5zdHJpbmdzLCBTVFJJTkdTX0xJU1QpOwotCQl9Ci0JCXZvaWQgY2xlYXJTdHJpbmdzKCkgewotCQkJdGhpcy5jbGVhckxpc3QodGhpcy5zdHJpbmdzLCBTVFJJTkdTX0xJU1QpOwotCQl9Ci0JCXZvaWQgcmVwbGFjZUFsbFN0cmluZ3MoU3RyaW5nW10gbmV3U3RyaW5ncykgewotCQkJdGhpcy5zdHJpbmdzLmNsZWFyKCk7Ci0JCQlDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKHRoaXMuc3RyaW5ncywgbmV3U3RyaW5ncyk7Ci0JCQl0aGlzLmZpcmVMaXN0Q2hhbmdlZChTVFJJTkdTX0xJU1QpOwotCQl9Ci0JCXZvaWQgY2hhbmdlQ29sbGVjdGlvbigpIHsKLQkJCXRoaXMuZmlyZUNvbGxlY3Rpb25DaGFuZ2VkKCJib2d1cyBjb2xsZWN0aW9uIik7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIGNsYXNzIFRhcmdldCB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWw7Ci0JCVN0cmluZyBsaXN0TmFtZTsKLQkJU3RyaW5nIHN0cmluZzsKLQkJaW50IGluZGV4OwotCQlTdHJpbmcgcmVwbGFjZWRTdHJpbmc7Ci0JCWludCBzb3VyY2VJbmRleDsKLQkJYm9vbGVhbiBpdGVtQWRkZWRaZXJvQXJndW1lbnRGbGFnID0gZmFsc2U7Ci0JCWJvb2xlYW4gaXRlbUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnID0gZmFsc2U7Ci0JCWJvb2xlYW4gaXRlbVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnID0gZmFsc2U7Ci0JCWJvb2xlYW4gaXRlbVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcgPSBmYWxzZTsKLQkJYm9vbGVhbiBpdGVtUmVwbGFjZWRaZXJvQXJndW1lbnRGbGFnID0gZmFsc2U7Ci0JCWJvb2xlYW4gaXRlbVJlcGxhY2VkU2luZ2xlQXJndW1lbnRGbGFnID0gZmFsc2U7Ci0JCWJvb2xlYW4gaXRlbU1vdmVkWmVyb0FyZ3VtZW50RmxhZyA9IGZhbHNlOwotCQlib29sZWFuIGl0ZW1Nb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyA9IGZhbHNlOwotCQlib29sZWFuIGxpc3RDbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyA9IGZhbHNlOwotCQlib29sZWFuIGxpc3RDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnID0gZmFsc2U7Ci0JCWJvb2xlYW4gbGlzdENoYW5nZWRaZXJvQXJndW1lbnRGbGFnID0gZmFsc2U7Ci0JCWJvb2xlYW4gbGlzdENoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcgPSBmYWxzZTsKLQkJVGFyZ2V0KFRlc3RNb2RlbCB0ZXN0TW9kZWwsIFN0cmluZyBsaXN0TmFtZSwgU3RyaW5nIHN0cmluZywgaW50IGluZGV4KSB7Ci0JCQlzdXBlcigpOwotCQkJdGhpcy50ZXN0TW9kZWwgPSB0ZXN0TW9kZWw7Ci0JCQl0aGlzLmxpc3ROYW1lID0gbGlzdE5hbWU7Ci0JCQl0aGlzLnN0cmluZyA9IHN0cmluZzsKLQkJCXRoaXMuaW5kZXggPSBpbmRleDsKLQkJfQotCQlUYXJnZXQoVGVzdE1vZGVsIHRlc3RNb2RlbCwgU3RyaW5nIGxpc3ROYW1lLCBTdHJpbmcgc3RyaW5nLCBpbnQgaW5kZXgsIFN0cmluZyByZXBsYWNlZFN0cmluZykgewotCQkJdGhpcyh0ZXN0TW9kZWwsIGxpc3ROYW1lLCBzdHJpbmcsIGluZGV4KTsKLQkJCXRoaXMucmVwbGFjZWRTdHJpbmcgPSByZXBsYWNlZFN0cmluZzsKLQkJfQotCQlUYXJnZXQoVGVzdE1vZGVsIHRlc3RNb2RlbCwgU3RyaW5nIGxpc3ROYW1lLCBpbnQgdGFyZ2V0SW5kZXgsIGludCBzb3VyY2VJbmRleCkgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMudGVzdE1vZGVsID0gdGVzdE1vZGVsOwotCQkJdGhpcy5saXN0TmFtZSA9IGxpc3ROYW1lOwotCQkJdGhpcy5pbmRleCA9IHRhcmdldEluZGV4OwotCQkJdGhpcy5zb3VyY2VJbmRleCA9IHNvdXJjZUluZGV4OwotCQl9Ci0JCXZvaWQgaXRlbUFkZGVkWmVyb0FyZ3VtZW50KCkgewotCQkJdGhpcy5pdGVtQWRkZWRaZXJvQXJndW1lbnRGbGFnID0gdHJ1ZTsKLQkJfQotCQl2b2lkIGl0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50KExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQl0aGlzLml0ZW1BZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyA9IHRydWU7Ci0JCQlhc3NlcnRTYW1lKHRoaXMudGVzdE1vZGVsLCBlLmdldFNvdXJjZSgpKTsKLQkJCWFzc2VydEVxdWFscyh0aGlzLmxpc3ROYW1lLCBlLmdldExpc3ROYW1lKCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3RyaW5nLCBlLml0ZW1zKCkubmV4dCgpKTsKLQkJCWFzc2VydEVxdWFscyh0aGlzLmluZGV4LCBlLmdldEluZGV4KCkpOwotCQl9Ci0JCXZvaWQgaXRlbVJlbW92ZWRaZXJvQXJndW1lbnQoKSB7Ci0JCQl0aGlzLml0ZW1SZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyA9IHRydWU7Ci0JCX0KLQkJdm9pZCBpdGVtUmVtb3ZlZFNpbmdsZUFyZ3VtZW50KExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQl0aGlzLml0ZW1SZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnID0gdHJ1ZTsKLQkJCWFzc2VydFNhbWUodGhpcy50ZXN0TW9kZWwsIGUuZ2V0U291cmNlKCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMubGlzdE5hbWUsIGUuZ2V0TGlzdE5hbWUoKSk7Ci0JCQlhc3NlcnRFcXVhbHModGhpcy5zdHJpbmcsIGUuaXRlbXMoKS5uZXh0KCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMuaW5kZXgsIGUuZ2V0SW5kZXgoKSk7Ci0JCX0KLQkJdm9pZCBpdGVtUmVwbGFjZWRaZXJvQXJndW1lbnQoKSB7Ci0JCQl0aGlzLml0ZW1SZXBsYWNlZFplcm9Bcmd1bWVudEZsYWcgPSB0cnVlOwotCQl9Ci0JCXZvaWQgaXRlbVJlcGxhY2VkU2luZ2xlQXJndW1lbnQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJCXRoaXMuaXRlbVJlcGxhY2VkU2luZ2xlQXJndW1lbnRGbGFnID0gdHJ1ZTsKLQkJCWFzc2VydFNhbWUodGhpcy50ZXN0TW9kZWwsIGUuZ2V0U291cmNlKCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMubGlzdE5hbWUsIGUuZ2V0TGlzdE5hbWUoKSk7Ci0JCQlhc3NlcnRFcXVhbHModGhpcy5zdHJpbmcsIGUuaXRlbXMoKS5uZXh0KCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMucmVwbGFjZWRTdHJpbmcsIGUucmVwbGFjZWRJdGVtcygpLm5leHQoKSk7Ci0JCQlhc3NlcnRFcXVhbHModGhpcy5pbmRleCwgZS5nZXRJbmRleCgpKTsKLQkJfQotCQl2b2lkIGl0ZW1Nb3ZlZFplcm9Bcmd1bWVudCgpIHsKLQkJCXRoaXMuaXRlbU1vdmVkWmVyb0FyZ3VtZW50RmxhZyA9IHRydWU7Ci0JCX0KLQkJdm9pZCBpdGVtTW92ZWRTaW5nbGVBcmd1bWVudChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJdGhpcy5pdGVtTW92ZWRTaW5nbGVBcmd1bWVudEZsYWcgPSB0cnVlOwotCQkJYXNzZXJ0U2FtZSh0aGlzLnRlc3RNb2RlbCwgZS5nZXRTb3VyY2UoKSk7Ci0JCQlhc3NlcnRFcXVhbHModGhpcy5saXN0TmFtZSwgZS5nZXRMaXN0TmFtZSgpKTsKLQkJCWFzc2VydEVxdWFscyh0aGlzLmluZGV4LCBlLmdldFRhcmdldEluZGV4KCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMuc291cmNlSW5kZXgsIGUuZ2V0U291cmNlSW5kZXgoKSk7Ci0JCX0KLQkJdm9pZCBsaXN0Q2hhbmdlZFplcm9Bcmd1bWVudCgpIHsKLQkJCXRoaXMubGlzdENoYW5nZWRaZXJvQXJndW1lbnRGbGFnID0gdHJ1ZTsKLQkJfQotCQl2b2lkIGxpc3RDbGVhcmVkU2luZ2xlQXJndW1lbnQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJCXRoaXMubGlzdENsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcgPSB0cnVlOwotCQkJYXNzZXJ0U2FtZSh0aGlzLnRlc3RNb2RlbCwgZS5nZXRTb3VyY2UoKSk7Ci0JCQlhc3NlcnRFcXVhbHModGhpcy5saXN0TmFtZSwgZS5nZXRMaXN0TmFtZSgpKTsKLQkJCWFzc2VydEZhbHNlKGUuaXRlbXMoKS5oYXNOZXh0KCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMuaW5kZXgsIGUuZ2V0SW5kZXgoKSk7Ci0JCX0KLQkJdm9pZCBsaXN0Q2xlYXJlZFplcm9Bcmd1bWVudCgpIHsKLQkJCXRoaXMubGlzdENsZWFyZWRaZXJvQXJndW1lbnRGbGFnID0gdHJ1ZTsKLQkJfQotCQl2b2lkIGxpc3RDaGFuZ2VkU2luZ2xlQXJndW1lbnQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJCXRoaXMubGlzdENoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcgPSB0cnVlOwotCQkJYXNzZXJ0U2FtZSh0aGlzLnRlc3RNb2RlbCwgZS5nZXRTb3VyY2UoKSk7Ci0JCQlhc3NlcnRFcXVhbHModGhpcy5saXN0TmFtZSwgZS5nZXRMaXN0TmFtZSgpKTsKLQkJCWFzc2VydEZhbHNlKGUuaXRlbXMoKS5oYXNOZXh0KCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMuaW5kZXgsIGUuZ2V0SW5kZXgoKSk7Ci0JCX0KLQkJdm9pZCBsaXN0Q2hhbmdlZERvdWJsZUFyZ3VtZW50KExpc3RDaGFuZ2VFdmVudCBlLCBPYmplY3QgbykgewotCQkJZmFpbCgiYm9ndXMgZXZlbnQ6ICIgKyBlKTsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC9saXN0ZW5lci9SZWZsZWN0aXZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL2xpc3RlbmVyL1JlZmxlY3RpdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggY2YzNzM0Yi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL2xpc3RlbmVyL1JlZmxlY3RpdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE5MyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLmxpc3RlbmVyOwotCi1pbXBvcnQgamF2YS5sYW5nLnJlZmxlY3QuTWV0aG9kOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5DbGFzc1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5TdGF0ZUNoYW5nZUxpc3RlbmVyOwotCi1wdWJsaWMgY2xhc3MgUmVmbGVjdGl2ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQkKLQlwdWJsaWMgUmVmbGVjdGl2ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0WmVyb0FyZ3VtZW50KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCg3KTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuVkFMVUVfUFJPUEVSVFksIDcsIDk5KTsKLQkJdGVzdE1vZGVsLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyLmJ1aWxkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcih0YXJnZXQsICJwcm9wZXJ0eUNoYW5nZWRaZXJvQXJndW1lbnQiKSk7Ci0JCXRlc3RNb2RlbC5zZXRWYWx1ZSg5OSk7Ci0JCWFzc2VydFRydWUodGFyZ2V0Lnplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuc2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0WmVyb0FyZ3VtZW50TmFtZWRQcm9wZXJ0eSgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoNyk7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlZBTFVFX1BST1BFUlRZLCA3LCA5OSk7Ci0JCXRlc3RNb2RlbC5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFRlc3RNb2RlbC5WQUxVRV9QUk9QRVJUWSwgUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyLmJ1aWxkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcih0YXJnZXQsICJwcm9wZXJ0eUNoYW5nZWRaZXJvQXJndW1lbnQiKSk7Ci0JCXRlc3RNb2RlbC5zZXRWYWx1ZSg5OSk7Ci0JCWFzc2VydFRydWUodGFyZ2V0Lnplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuc2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2luZ2xlQXJndW1lbnQoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKDcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5WQUxVRV9QUk9QRVJUWSwgNywgOTkpOwotCQl0ZXN0TW9kZWwuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIuYnVpbGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRhcmdldCwgInByb3BlcnR5Q2hhbmdlZFNpbmdsZUFyZ3VtZW50IikpOwotCQl0ZXN0TW9kZWwuc2V0VmFsdWUoOTkpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuemVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0LnNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JLyoqCi0JICogdGVzdCBtZXRob2QgdGhhdCBoYXMgbW9yZSBnZW5lcmFsIG1ldGhvZCBwYXJhbWV0ZXIgdHlwZQotCSAqLwotCXB1YmxpYyB2b2lkIHRlc3RTaW5nbGVBcmd1bWVudDIoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoNyk7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlZBTFVFX1BST1BFUlRZLCA3LCA5OSk7Ci0JCU1ldGhvZCBtZXRob2QgPSBDbGFzc1Rvb2xzLm1ldGhvZCh0YXJnZXQsICJwcm9wZXJ0eUNoYW5nZWRTaW5nbGVBcmd1bWVudDIiLCBuZXcgQ2xhc3NbXSB7T2JqZWN0LmNsYXNzfSk7Ci0JCXRlc3RNb2RlbC5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lci5idWlsZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIodGFyZ2V0LCBtZXRob2QpKTsKLQkJdGVzdE1vZGVsLnNldFZhbHVlKDk5KTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lnplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5zaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTaW5nbGVBcmd1bWVudE5hbWVkUHJvcGVydHkoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKDcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5WQUxVRV9QUk9QRVJUWSwgNywgOTkpOwotCQl0ZXN0TW9kZWwuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihUZXN0TW9kZWwuVkFMVUVfUFJPUEVSVFksIFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lci5idWlsZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIodGFyZ2V0LCAicHJvcGVydHlDaGFuZ2VkU2luZ2xlQXJndW1lbnQiKSk7Ci0JCXRlc3RNb2RlbC5zZXRWYWx1ZSg5OSk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC56ZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQuc2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQkvKioKLQkgKiB0ZXN0IG1ldGhvZCB0aGF0IGhhcyBtb3JlIGdlbmVyYWwgbWV0aG9kIHBhcmFtZXRlciB0eXBlCi0JICovCi0JcHVibGljIHZvaWQgdGVzdFNpbmdsZUFyZ3VtZW50TmFtZWRQcm9wZXJ0eTIoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoNyk7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlZBTFVFX1BST1BFUlRZLCA3LCA5OSk7Ci0JCU1ldGhvZCBtZXRob2QgPSBDbGFzc1Rvb2xzLm1ldGhvZCh0YXJnZXQsICJwcm9wZXJ0eUNoYW5nZWRTaW5nbGVBcmd1bWVudDIiLCBuZXcgQ2xhc3NbXSB7T2JqZWN0LmNsYXNzfSk7Ci0JCXRlc3RNb2RlbC5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFRlc3RNb2RlbC5WQUxVRV9QUk9QRVJUWSwgUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyLmJ1aWxkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcih0YXJnZXQsIG1ldGhvZCkpOwotCQl0ZXN0TW9kZWwuc2V0VmFsdWUoOTkpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuemVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0LnNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RlbmVyTWlzbWF0Y2goKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKDcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5WQUxVRV9QUk9QRVJUWSwgNywgOTkpOwotCQkvLyBidWlsZCBhIFBST1BFUlRZIGNoYW5nZSBsaXN0ZW5lciBhbmQgaGFjayBpdCBzbyB3ZQotCQkvLyBjYW4gYWRkIGl0IGFzIGEgU1RBVEUgY2hhbmdlIGxpc3RlbmVyCi0JCU9iamVjdCBsaXN0ZW5lciA9IFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lci5idWlsZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIodGFyZ2V0LCAicHJvcGVydHlDaGFuZ2VkU2luZ2xlQXJndW1lbnQiKTsKLQkJdGVzdE1vZGVsLmFkZFN0YXRlQ2hhbmdlTGlzdGVuZXIoKFN0YXRlQ2hhbmdlTGlzdGVuZXIpIGxpc3RlbmVyKTsKLQotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0ZXN0TW9kZWwuc2V0VmFsdWUoOTkpOwotCQkJZmFpbCgibGlzdGVuZXIgbWlzbWF0Y2g6ICIgKyBsaXN0ZW5lcik7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RCb2d1c0RvdWJsZUFyZ3VtZW50MSgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoNyk7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlZBTFVFX1BST1BFUlRZLCA3LCA5OSk7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSBSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIuYnVpbGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRhcmdldCwgInN0YXRlQ2hhbmdlZERvdWJsZUFyZ3VtZW50Iik7Ci0JCQlmYWlsKCJib2d1cyBsaXN0ZW5lcjogIiArIGxpc3RlbmVyKTsKLQkJfSBjYXRjaCAoUnVudGltZUV4Y2VwdGlvbiBleCkgewotCQkJaWYgKGV4LmdldENhdXNlKCkuZ2V0Q2xhc3MoKSA9PSBOb1N1Y2hNZXRob2RFeGNlcHRpb24uY2xhc3MpIHsKLQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEJvZ3VzRG91YmxlQXJndW1lbnQyKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKDcpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5WQUxVRV9QUk9QRVJUWSwgNywgOTkpOwotCQlNZXRob2QgbWV0aG9kID0gQ2xhc3NUb29scy5tZXRob2QodGFyZ2V0LCAicHJvcGVydHlDaGFuZ2VkRG91YmxlQXJndW1lbnQiLCBuZXcgQ2xhc3NbXSB7UHJvcGVydHlDaGFuZ2VFdmVudC5jbGFzcywgT2JqZWN0LmNsYXNzfSk7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSBSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIuYnVpbGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRhcmdldCwgbWV0aG9kKTsKLQkJCWZhaWwoImJvZ3VzIGxpc3RlbmVyOiAiICsgbGlzdGVuZXIpOwotCQl9IGNhdGNoIChSdW50aW1lRXhjZXB0aW9uIGV4KSB7Ci0JCQlpZiAoZXguZ2V0TWVzc2FnZSgpLmVxdWFscyhtZXRob2QudG9TdHJpbmcoKSkpIHsKLQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0KLQlwcml2YXRlIGNsYXNzIFRlc3RNb2RlbCBleHRlbmRzIEFic3RyYWN0TW9kZWwgewotCQlwcml2YXRlIGludCB2YWx1ZSA9IDA7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBWQUxVRV9QUk9QRVJUWSA9ICJ2YWx1ZSI7Ci0JCVRlc3RNb2RlbChpbnQgdmFsdWUpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLnZhbHVlID0gdmFsdWU7Ci0JCX0KLQkJdm9pZCBzZXRWYWx1ZShpbnQgdmFsdWUpIHsKLQkJCWludCBvbGQgPSB0aGlzLnZhbHVlOwotCQkJdGhpcy52YWx1ZSA9IHZhbHVlOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKFZBTFVFX1BST1BFUlRZLCBvbGQsIHZhbHVlKTsKLQkJCWlmIChvbGQgIT0gdmFsdWUpIHsKLQkJCQl0aGlzLmZpcmVTdGF0ZUNoYW5nZWQoKTsKLQkJCX0KLQkJfQotCX0KLQotCXByaXZhdGUgY2xhc3MgVGFyZ2V0IHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbDsKLQkJU3RyaW5nIHByb3BlcnR5TmFtZTsKLQkJT2JqZWN0IG9sZFZhbHVlOwotCQlPYmplY3QgbmV3VmFsdWU7Ci0JCWJvb2xlYW4gemVyb0FyZ3VtZW50RmxhZyA9IGZhbHNlOwotCQlib29sZWFuIHNpbmdsZUFyZ3VtZW50RmxhZyA9IGZhbHNlOwotCQlUYXJnZXQoVGVzdE1vZGVsIHRlc3RNb2RlbCwgU3RyaW5nIHByb3BlcnR5TmFtZSwgaW50IG9sZFZhbHVlLCBpbnQgbmV3VmFsdWUpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLnRlc3RNb2RlbCA9IHRlc3RNb2RlbDsKLQkJCXRoaXMucHJvcGVydHlOYW1lID0gcHJvcGVydHlOYW1lOwotCQkJdGhpcy5vbGRWYWx1ZSA9IG5ldyBJbnRlZ2VyKG9sZFZhbHVlKTsKLQkJCXRoaXMubmV3VmFsdWUgPSBuZXcgSW50ZWdlcihuZXdWYWx1ZSk7Ci0JCX0KLQkJdm9pZCBwcm9wZXJ0eUNoYW5nZWRaZXJvQXJndW1lbnQoKSB7Ci0JCQl0aGlzLnplcm9Bcmd1bWVudEZsYWcgPSB0cnVlOwotCQl9Ci0JCXZvaWQgcHJvcGVydHlDaGFuZ2VkU2luZ2xlQXJndW1lbnQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCQl0aGlzLnNpbmdsZUFyZ3VtZW50RmxhZyA9IHRydWU7Ci0JCQlhc3NlcnRTYW1lKHRoaXMudGVzdE1vZGVsLCBlLmdldFNvdXJjZSgpKTsKLQkJCWFzc2VydEVxdWFscyh0aGlzLnByb3BlcnR5TmFtZSwgZS5nZXRQcm9wZXJ0eU5hbWUoKSk7Ci0JCQlhc3NlcnRFcXVhbHModGhpcy5vbGRWYWx1ZSwgZS5nZXRPbGRWYWx1ZSgpKTsKLQkJCWFzc2VydEVxdWFscyh0aGlzLm5ld1ZhbHVlLCBlLmdldE5ld1ZhbHVlKCkpOwotCQl9Ci0JCXZvaWQgcHJvcGVydHlDaGFuZ2VkU2luZ2xlQXJndW1lbnQyKE9iamVjdCBvKSB7Ci0JCQlQcm9wZXJ0eUNoYW5nZUV2ZW50IGUgPSAoUHJvcGVydHlDaGFuZ2VFdmVudCkgbzsKLQkJCXRoaXMuc2luZ2xlQXJndW1lbnRGbGFnID0gdHJ1ZTsKLQkJCWFzc2VydFNhbWUodGhpcy50ZXN0TW9kZWwsIGUuZ2V0U291cmNlKCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMucHJvcGVydHlOYW1lLCBlLmdldFByb3BlcnR5TmFtZSgpKTsKLQkJCWFzc2VydEVxdWFscyh0aGlzLm9sZFZhbHVlLCBlLmdldE9sZFZhbHVlKCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMubmV3VmFsdWUsIGUuZ2V0TmV3VmFsdWUoKSk7Ci0JCX0KLQkJdm9pZCBwcm9wZXJ0eUNoYW5nZWREb3VibGVBcmd1bWVudChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUsIE9iamVjdCBvKSB7Ci0JCQlmYWlsKCJib2d1cyBldmVudDogIiArIGUpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL2xpc3RlbmVyL1JlZmxlY3RpdmVTdGF0ZUNoYW5nZUxpc3RlbmVyVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvbGlzdGVuZXIvUmVmbGVjdGl2ZVN0YXRlQ2hhbmdlTGlzdGVuZXJUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmY2U3ZGI0Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvbGlzdGVuZXIvUmVmbGVjdGl2ZVN0YXRlQ2hhbmdlTGlzdGVuZXJUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTQ0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwubGlzdGVuZXI7Ci0KLWltcG9ydCBqYXZhLmxhbmcucmVmbGVjdC5NZXRob2Q7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5TdGF0ZUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlN0YXRlQ2hhbmdlTGlzdGVuZXI7Ci0KLXB1YmxpYyBjbGFzcyBSZWZsZWN0aXZlU3RhdGVDaGFuZ2VMaXN0ZW5lclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCQotCXB1YmxpYyBSZWZsZWN0aXZlU3RhdGVDaGFuZ2VMaXN0ZW5lclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RaZXJvQXJndW1lbnQoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCk7Ci0JCXRlc3RNb2RlbC5hZGRTdGF0ZUNoYW5nZUxpc3RlbmVyKFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lci5idWlsZFN0YXRlQ2hhbmdlTGlzdGVuZXIodGFyZ2V0LCAic3RhdGVDaGFuZ2VkWmVyb0FyZ3VtZW50IikpOwotCQl0ZXN0TW9kZWwuY2hhbmdlU3RhdGUoKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQuemVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5zaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTaW5nbGVBcmd1bWVudCgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsKTsKLQkJdGVzdE1vZGVsLmFkZFN0YXRlQ2hhbmdlTGlzdGVuZXIoUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyLmJ1aWxkU3RhdGVDaGFuZ2VMaXN0ZW5lcih0YXJnZXQsICJzdGF0ZUNoYW5nZWRTaW5nbGVBcmd1bWVudCIpKTsKLQkJdGVzdE1vZGVsLmNoYW5nZVN0YXRlKCk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC56ZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQuc2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQkvKioKLQkgKiB0ZXN0IG1ldGhvZCB0aGF0IGhhcyBtb3JlIGdlbmVyYWwgbWV0aG9kIHBhcmFtZXRlciB0eXBlCi0JICovCi0JcHVibGljIHZvaWQgdGVzdFNpbmdsZUFyZ3VtZW50MigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwpOwotCQlNZXRob2QgbWV0aG9kID0gQ2xhc3NUb29scy5tZXRob2QodGFyZ2V0LCAic3RhdGVDaGFuZ2VkU2luZ2xlQXJndW1lbnQyIiwgbmV3IENsYXNzW10ge09iamVjdC5jbGFzc30pOwotCQl0ZXN0TW9kZWwuYWRkU3RhdGVDaGFuZ2VMaXN0ZW5lcihSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIuYnVpbGRTdGF0ZUNoYW5nZUxpc3RlbmVyKHRhcmdldCwgbWV0aG9kKSk7Ci0JCXRlc3RNb2RlbC5jaGFuZ2VTdGF0ZSgpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQuemVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0LnNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RlbmVyTWlzbWF0Y2goKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCk7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCk7Ci0JCS8vIGJ1aWxkIGEgU1RBVEUgY2hhbmdlIGxpc3RlbmVyIGFuZCBoYWNrIGl0IHNvIHdlCi0JCS8vIGNhbiBhZGQgaXQgYXMgYSBQUk9QRVJUWSBjaGFuZ2UgbGlzdGVuZXIKLQkJT2JqZWN0IGxpc3RlbmVyID0gUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyLmJ1aWxkU3RhdGVDaGFuZ2VMaXN0ZW5lcih0YXJnZXQsICJzdGF0ZUNoYW5nZWRTaW5nbGVBcmd1bWVudCIpOwotCQl0ZXN0TW9kZWwuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigoUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcikgbGlzdGVuZXIpOwotCi0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRlc3RNb2RlbC5jaGFuZ2VQcm9wZXJ0eSgpOwotCQkJZmFpbCgibGlzdGVuZXIgbWlzbWF0Y2g6ICIgKyBsaXN0ZW5lcik7Ci0JCX0gY2F0Y2ggKElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBleCkgewotCQkJZXhDYXVnaHQgPSB0cnVlOwotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RCb2d1c0RvdWJsZUFyZ3VtZW50MSgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsKTsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJU3RhdGVDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lciA9IFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lci5idWlsZFN0YXRlQ2hhbmdlTGlzdGVuZXIodGFyZ2V0LCAic3RhdGVDaGFuZ2VkRG91YmxlQXJndW1lbnQiKTsKLQkJCWZhaWwoImJvZ3VzIGxpc3RlbmVyOiAiICsgbGlzdGVuZXIpOwotCQl9IGNhdGNoIChSdW50aW1lRXhjZXB0aW9uIGV4KSB7Ci0JCQlpZiAoZXguZ2V0Q2F1c2UoKS5nZXRDbGFzcygpID09IE5vU3VjaE1ldGhvZEV4Y2VwdGlvbi5jbGFzcykgewotCQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJCX0KLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Qm9ndXNEb3VibGVBcmd1bWVudDIoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsKTsKLQkJTWV0aG9kIG1ldGhvZCA9IENsYXNzVG9vbHMubWV0aG9kKHRhcmdldCwgInN0YXRlQ2hhbmdlZERvdWJsZUFyZ3VtZW50IiwgbmV3IENsYXNzW10ge1N0YXRlQ2hhbmdlRXZlbnQuY2xhc3MsIE9iamVjdC5jbGFzc30pOwotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlTdGF0ZUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyID0gUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyLmJ1aWxkU3RhdGVDaGFuZ2VMaXN0ZW5lcih0YXJnZXQsIG1ldGhvZCk7Ci0JCQlmYWlsKCJib2d1cyBsaXN0ZW5lcjogIiArIGxpc3RlbmVyKTsKLQkJfSBjYXRjaCAoUnVudGltZUV4Y2VwdGlvbiBleCkgewotCQkJaWYgKGV4LmdldE1lc3NhZ2UoKS5lcXVhbHMobWV0aG9kLnRvU3RyaW5nKCkpKSB7Ci0JCQkJZXhDYXVnaHQgPSB0cnVlOwotCQkJfQotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCi0JcHJpdmF0ZSBjbGFzcyBUZXN0TW9kZWwgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIHsKLQkJVGVzdE1vZGVsKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQl2b2lkIGNoYW5nZVN0YXRlKCkgewotCQkJdGhpcy5maXJlU3RhdGVDaGFuZ2VkKCk7Ci0JCX0KLQkJdm9pZCBjaGFuZ2VQcm9wZXJ0eSgpIHsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZCgidmFsdWUiLCA1NSwgNDIpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBjbGFzcyBUYXJnZXQgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsOwotCQlib29sZWFuIHplcm9Bcmd1bWVudEZsYWcgPSBmYWxzZTsKLQkJYm9vbGVhbiBzaW5nbGVBcmd1bWVudEZsYWcgPSBmYWxzZTsKLQkJVGFyZ2V0KFRlc3RNb2RlbCB0ZXN0TW9kZWwpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLnRlc3RNb2RlbCA9IHRlc3RNb2RlbDsKLQkJfQotCQl2b2lkIHN0YXRlQ2hhbmdlZFplcm9Bcmd1bWVudCgpIHsKLQkJCXRoaXMuemVyb0FyZ3VtZW50RmxhZyA9IHRydWU7Ci0JCX0KLQkJdm9pZCBzdGF0ZUNoYW5nZWRTaW5nbGVBcmd1bWVudChTdGF0ZUNoYW5nZUV2ZW50IGUpIHsKLQkJCXRoaXMuc2luZ2xlQXJndW1lbnRGbGFnID0gdHJ1ZTsKLQkJCWFzc2VydFNhbWUodGhpcy50ZXN0TW9kZWwsIGUuZ2V0U291cmNlKCkpOwotCQl9Ci0JCXZvaWQgc3RhdGVDaGFuZ2VkU2luZ2xlQXJndW1lbnQyKE9iamVjdCBlKSB7Ci0JCQl0aGlzLnNpbmdsZUFyZ3VtZW50RmxhZyA9IHRydWU7Ci0JCQlhc3NlcnRTYW1lKHRoaXMudGVzdE1vZGVsLCAoKFN0YXRlQ2hhbmdlRXZlbnQpIGUpLmdldFNvdXJjZSgpKTsKLQkJfQotCQl2b2lkIHN0YXRlQ2hhbmdlZERvdWJsZUFyZ3VtZW50KFN0YXRlQ2hhbmdlRXZlbnQgZSwgT2JqZWN0IG8pIHsKLQkJCWZhaWwoImJvZ3VzIGV2ZW50OiAiICsgZSk7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvbGlzdGVuZXIvUmVmbGVjdGl2ZVRyZWVDaGFuZ2VMaXN0ZW5lclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL2xpc3RlbmVyL1JlZmxlY3RpdmVUcmVlQ2hhbmdlTGlzdGVuZXJUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4MDcyZGEyLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvbGlzdGVuZXIvUmVmbGVjdGl2ZVRyZWVDaGFuZ2VMaXN0ZW5lclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1MTMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC5saXN0ZW5lcjsKLQotaW1wb3J0IGphdmEubGFuZy5yZWZsZWN0Lk1ldGhvZDsKLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5BcnJheXM7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkhhc2hNYXA7Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmEudXRpbC5NYXA7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5DbG9uZUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuVHJlZUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5SZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuVHJlZUNoYW5nZUxpc3RlbmVyOwotCi1wdWJsaWMgY2xhc3MgUmVmbGVjdGl2ZVRyZWVDaGFuZ2VMaXN0ZW5lclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCQotCXB1YmxpYyBSZWZsZWN0aXZlVHJlZUNoYW5nZUxpc3RlbmVyVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JcHJpdmF0ZSBUcmVlQ2hhbmdlTGlzdGVuZXIgYnVpbGRaZXJvQXJndW1lbnRMaXN0ZW5lcihPYmplY3QgdGFyZ2V0KSB7Ci0JCXJldHVybiBSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIuYnVpbGRUcmVlQ2hhbmdlTGlzdGVuZXIodGFyZ2V0LCAibm9kZUFkZGVkWmVyb0FyZ3VtZW50IiwgIm5vZGVSZW1vdmVkWmVyb0FyZ3VtZW50IiwgInRyZWVDbGVhcmVkWmVyb0FyZ3VtZW50IiwgInRyZWVDaGFuZ2VkWmVyb0FyZ3VtZW50Iik7Ci0JfQotCi0JcHJpdmF0ZSBUcmVlQ2hhbmdlTGlzdGVuZXIgYnVpbGRTaW5nbGVBcmd1bWVudExpc3RlbmVyKE9iamVjdCB0YXJnZXQpIHsKLQkJcmV0dXJuIFJlZmxlY3RpdmVDaGFuZ2VMaXN0ZW5lci5idWlsZFRyZWVDaGFuZ2VMaXN0ZW5lcih0YXJnZXQsICJub2RlQWRkZWRTaW5nbGVBcmd1bWVudCIsICJub2RlUmVtb3ZlZFNpbmdsZUFyZ3VtZW50IiwgInRyZWVDbGVhcmVkU2luZ2xlQXJndW1lbnQiLCAidHJlZUNoYW5nZWRTaW5nbGVBcmd1bWVudCIpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROb2RlQWRkZWRaZXJvQXJndW1lbnQoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCJyb290Iik7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfVFJFRSwgbmV3IFN0cmluZ1tdeyJyb290IiwgImNoaWxkIn0pOwotCQl0ZXN0TW9kZWwuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRaZXJvQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLmFkZE5vZGUoInJvb3QiLCAiY2hpbGQiKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQubm9kZUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVSZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROb2RlQWRkZWRaZXJvQXJndW1lbnROYW1lZFRyZWUoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCJyb290Iik7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfVFJFRSwgbmV3IFN0cmluZ1tdeyJyb290IiwgImNoaWxkIn0pOwotCQl0ZXN0TW9kZWwuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKFRlc3RNb2RlbC5TVFJJTkdTX1RSRUUsIHRoaXMuYnVpbGRaZXJvQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLmFkZE5vZGUoInJvb3QiLCAiY2hpbGQiKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQubm9kZUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVSZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROb2RlQWRkZWRTaW5nbGVBcmd1bWVudCgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoInJvb3QiKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19UUkVFLCBuZXcgU3RyaW5nW117InJvb3QiLCAiY2hpbGQifSk7Ci0JCXRlc3RNb2RlbC5hZGRUcmVlQ2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZFNpbmdsZUFyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5hZGROb2RlKCJyb290IiwgImNoaWxkIik7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQubm9kZUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVSZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNoYW5nZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Tm9kZUFkZGVkU2luZ2xlQXJndW1lbnROYW1lZFRyZWUoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCJyb290Iik7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfVFJFRSwgbmV3IFN0cmluZ1tdeyJyb290IiwgImNoaWxkIn0pOwotCQl0ZXN0TW9kZWwuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKFRlc3RNb2RlbC5TVFJJTkdTX1RSRUUsIHRoaXMuYnVpbGRTaW5nbGVBcmd1bWVudExpc3RlbmVyKHRhcmdldCkpOwotCQl0ZXN0TW9kZWwuYWRkTm9kZSgicm9vdCIsICJjaGlsZCIpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0Lm5vZGVBZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5vZGVSZW1vdmVkWmVyb0FyZ3VtZW50KCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgicm9vdCIpOwotCQl0ZXN0TW9kZWwuYWRkTm9kZSgicm9vdCIsICJjaGlsZCIpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX1RSRUUsIG5ldyBTdHJpbmdbXXsicm9vdCIsICJjaGlsZCJ9KTsKLQkJdGVzdE1vZGVsLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcih0aGlzLmJ1aWxkWmVyb0FyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5yZW1vdmVOb2RlKCJjaGlsZCIpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5ub2RlUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5vZGVSZW1vdmVkWmVyb0FyZ3VtZW50TmFtZWRUcmVlKCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgicm9vdCIpOwotCQl0ZXN0TW9kZWwuYWRkTm9kZSgicm9vdCIsICJjaGlsZCIpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX1RSRUUsIG5ldyBTdHJpbmdbXXsicm9vdCIsICJjaGlsZCJ9KTsKLQkJdGVzdE1vZGVsLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcihUZXN0TW9kZWwuU1RSSU5HU19UUkVFLCB0aGlzLmJ1aWxkWmVyb0FyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5yZW1vdmVOb2RlKCJjaGlsZCIpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5ub2RlUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5vZGVSZW1vdmVkU2luZ2xlQXJndW1lbnQoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCJyb290Iik7Ci0JCXRlc3RNb2RlbC5hZGROb2RlKCJyb290IiwgImNoaWxkIik7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfVFJFRSwgbmV3IFN0cmluZ1tdeyJyb290IiwgImNoaWxkIn0pOwotCQl0ZXN0TW9kZWwuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRTaW5nbGVBcmd1bWVudExpc3RlbmVyKHRhcmdldCkpOwotCQl0ZXN0TW9kZWwucmVtb3ZlTm9kZSgiY2hpbGQiKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVBZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVSZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0Lm5vZGVSZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROb2RlUmVtb3ZlZFNpbmdsZUFyZ3VtZW50TmFtZWRUcmVlKCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgicm9vdCIpOwotCQl0ZXN0TW9kZWwuYWRkTm9kZSgicm9vdCIsICJjaGlsZCIpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX1RSRUUsIG5ldyBTdHJpbmdbXXsicm9vdCIsICJjaGlsZCJ9KTsKLQkJdGVzdE1vZGVsLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcihUZXN0TW9kZWwuU1RSSU5HU19UUkVFLCB0aGlzLmJ1aWxkU2luZ2xlQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLnJlbW92ZU5vZGUoImNoaWxkIik7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVBZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC5ub2RlUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNoYW5nZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VHJlZUNsZWFyZWRaZXJvQXJndW1lbnQoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCJyb290Iik7Ci0JCXRlc3RNb2RlbC5hZGROb2RlKCJyb290IiwgImNoaWxkIik7Ci0JCXRlc3RNb2RlbC5hZGROb2RlKCJjaGlsZCIsICJncmFuZGNoaWxkIik7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfVFJFRSwgbmV3IFN0cmluZ1swXSk7Ci0JCXRlc3RNb2RlbC5hZGRUcmVlQ2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZFplcm9Bcmd1bWVudExpc3RlbmVyKHRhcmdldCkpOwotCQl0ZXN0TW9kZWwuY2xlYXJUcmVlKCk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVBZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC50cmVlQ2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNoYW5nZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VHJlZUNsZWFyZWRaZXJvQXJndW1lbnROYW1lZFRyZWUoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCJyb290Iik7Ci0JCXRlc3RNb2RlbC5hZGROb2RlKCJyb290IiwgImNoaWxkIik7Ci0JCXRlc3RNb2RlbC5hZGROb2RlKCJjaGlsZCIsICJncmFuZGNoaWxkIik7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfVFJFRSwgbmV3IFN0cmluZ1swXSk7Ci0JCXRlc3RNb2RlbC5hZGRUcmVlQ2hhbmdlTGlzdGVuZXIoVGVzdE1vZGVsLlNUUklOR1NfVFJFRSwgdGhpcy5idWlsZFplcm9Bcmd1bWVudExpc3RlbmVyKHRhcmdldCkpOwotCQl0ZXN0TW9kZWwuY2xlYXJUcmVlKCk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVBZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC50cmVlQ2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNsZWFyZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNoYW5nZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VHJlZUNsZWFyZWRTaW5nbGVBcmd1bWVudCgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoInJvb3QiKTsKLQkJdGVzdE1vZGVsLmFkZE5vZGUoInJvb3QiLCAiY2hpbGQiKTsKLQkJdGVzdE1vZGVsLmFkZE5vZGUoImNoaWxkIiwgImdyYW5kY2hpbGQiKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19UUkVFLCBuZXcgU3RyaW5nWzBdKTsKLQkJdGVzdE1vZGVsLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcih0aGlzLmJ1aWxkU2luZ2xlQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLmNsZWFyVHJlZSgpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVSZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0LnRyZWVDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFRyZWVDbGVhcmVkU2luZ2xlQXJndW1lbnROYW1lZFRyZWUoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCJyb290Iik7Ci0JCXRlc3RNb2RlbC5hZGROb2RlKCJyb290IiwgImNoaWxkIik7Ci0JCXRlc3RNb2RlbC5hZGROb2RlKCJjaGlsZCIsICJncmFuZGNoaWxkIik7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfVFJFRSwgbmV3IFN0cmluZ1swXSk7Ci0JCXRlc3RNb2RlbC5hZGRUcmVlQ2hhbmdlTGlzdGVuZXIoVGVzdE1vZGVsLlNUUklOR1NfVFJFRSwgdGhpcy5idWlsZFNpbmdsZUFyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5jbGVhclRyZWUoKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVBZGRlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVSZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlUmVtb3ZlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2xlYXJlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRUcnVlKHRhcmdldC50cmVlQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2hhbmdlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNoYW5nZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RUcmVlQ2hhbmdlZFplcm9Bcmd1bWVudCgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoInJvb3QiKTsKLQkJdGVzdE1vZGVsLmFkZE5vZGUoInJvb3QiLCAiY2hpbGQiKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19UUkVFLCBuZXcgU3RyaW5nW117InJvb3QiLCAiYW5vdGhlciBjaGlsZCJ9KTsKLQkJdGVzdE1vZGVsLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcih0aGlzLmJ1aWxkWmVyb0FyZ3VtZW50TGlzdGVuZXIodGFyZ2V0KSk7Ci0JCXRlc3RNb2RlbC5yZXBsYWNlTm9kZSgiY2hpbGQiLCAiYW5vdGhlciBjaGlsZCIpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZUFkZGVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlQWRkZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVSZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0LnRyZWVDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC50cmVlQ2hhbmdlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFRyZWVDaGFuZ2VkWmVyb0FyZ3VtZW50TmFtZWRUcmVlKCkgewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgicm9vdCIpOwotCQl0ZXN0TW9kZWwuYWRkTm9kZSgicm9vdCIsICJjaGlsZCIpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX1RSRUUsIG5ldyBTdHJpbmdbXXsicm9vdCIsICJhbm90aGVyIGNoaWxkIn0pOwotCQl0ZXN0TW9kZWwuYWRkVHJlZUNoYW5nZUxpc3RlbmVyKFRlc3RNb2RlbC5TVFJJTkdTX1RSRUUsIHRoaXMuYnVpbGRaZXJvQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLnJlcGxhY2VOb2RlKCJjaGlsZCIsICJhbm90aGVyIGNoaWxkIik7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVBZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0VHJ1ZSh0YXJnZXQudHJlZUNoYW5nZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VHJlZUNoYW5nZWRTaW5nbGVBcmd1bWVudCgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoInJvb3QiKTsKLQkJdGVzdE1vZGVsLmFkZE5vZGUoInJvb3QiLCAiY2hpbGQiKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19UUkVFLCBuZXcgU3RyaW5nW117InJvb3QiLCAiYW5vdGhlciBjaGlsZCJ9KTsKLQkJdGVzdE1vZGVsLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcih0aGlzLmJ1aWxkU2luZ2xlQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLnJlcGxhY2VOb2RlKCJjaGlsZCIsICJhbm90aGVyIGNoaWxkIik7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVBZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0LnRyZWVDaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VHJlZUNoYW5nZWRTaW5nbGVBcmd1bWVudE5hbWVkVHJlZSgpIHsKLQkJVGVzdE1vZGVsIHRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoInJvb3QiKTsKLQkJdGVzdE1vZGVsLmFkZE5vZGUoInJvb3QiLCAiY2hpbGQiKTsKLQkJVGFyZ2V0IHRhcmdldCA9IG5ldyBUYXJnZXQodGVzdE1vZGVsLCBUZXN0TW9kZWwuU1RSSU5HU19UUkVFLCBuZXcgU3RyaW5nW117InJvb3QiLCAiYW5vdGhlciBjaGlsZCJ9KTsKLQkJdGVzdE1vZGVsLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcihUZXN0TW9kZWwuU1RSSU5HU19UUkVFLCB0aGlzLmJ1aWxkU2luZ2xlQXJndW1lbnRMaXN0ZW5lcih0YXJnZXQpKTsKLQkJdGVzdE1vZGVsLnJlcGxhY2VOb2RlKCJjaGlsZCIsICJhbm90aGVyIGNoaWxkIik7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlQWRkZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0Lm5vZGVBZGRlZFNpbmdsZUFyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydEZhbHNlKHRhcmdldC5ub2RlUmVtb3ZlZFplcm9Bcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQubm9kZVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcpOwotCQlhc3NlcnRGYWxzZSh0YXJnZXQudHJlZUNsZWFyZWRaZXJvQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQkJYXNzZXJ0RmFsc2UodGFyZ2V0LnRyZWVDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyk7Ci0JCWFzc2VydFRydWUodGFyZ2V0LnRyZWVDaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Qm9ndXNEb3VibGVBcmd1bWVudDEoKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCJyb290Iik7Ci0JCXRlc3RNb2RlbC5hZGROb2RlKCJyb290IiwgImNoaWxkIik7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfVFJFRSwgbmV3IFN0cmluZ1tdeyJyb290IiwgImNoaWxkIn0pOwotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQlUcmVlQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSBSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIuYnVpbGRUcmVlQ2hhbmdlTGlzdGVuZXIodGFyZ2V0LCAiY29sbGVjdGlvbkNoYW5nZWREb3VibGVBcmd1bWVudCIpOwotCQkJZmFpbCgiYm9ndXMgbGlzdGVuZXI6ICIgKyBsaXN0ZW5lcik7Ci0JCX0gY2F0Y2ggKFJ1bnRpbWVFeGNlcHRpb24gZXgpIHsKLQkJCWlmIChleC5nZXRDYXVzZSgpLmdldENsYXNzKCkgPT0gTm9TdWNoTWV0aG9kRXhjZXB0aW9uLmNsYXNzKSB7Ci0JCQkJZXhDYXVnaHQgPSB0cnVlOwotCQkJfQotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RCb2d1c0RvdWJsZUFyZ3VtZW50MigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0TW9kZWwgdGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCgicm9vdCIpOwotCQl0ZXN0TW9kZWwuYWRkTm9kZSgicm9vdCIsICJjaGlsZCIpOwotCQlUYXJnZXQgdGFyZ2V0ID0gbmV3IFRhcmdldCh0ZXN0TW9kZWwsIFRlc3RNb2RlbC5TVFJJTkdTX1RSRUUsIG5ldyBTdHJpbmdbXXsicm9vdCIsICJjaGlsZCJ9KTsKLQkJTWV0aG9kIG1ldGhvZCA9IENsYXNzVG9vbHMubWV0aG9kKHRhcmdldCwgImNvbGxlY3Rpb25DaGFuZ2VkRG91YmxlQXJndW1lbnQiLCBuZXcgQ2xhc3NbXSB7VHJlZUNoYW5nZUV2ZW50LmNsYXNzLCBPYmplY3QuY2xhc3N9KTsKLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJVHJlZUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyID0gUmVmbGVjdGl2ZUNoYW5nZUxpc3RlbmVyLmJ1aWxkVHJlZUNoYW5nZUxpc3RlbmVyKHRhcmdldCwgbWV0aG9kKTsKLQkJCWZhaWwoImJvZ3VzIGxpc3RlbmVyOiAiICsgbGlzdGVuZXIpOwotCQl9IGNhdGNoIChSdW50aW1lRXhjZXB0aW9uIGV4KSB7Ci0JCQlpZiAoZXguZ2V0TWVzc2FnZSgpLmVxdWFscyhtZXRob2QudG9TdHJpbmcoKSkpIHsKLQkJCQlleENhdWdodCA9IHRydWU7Ci0JCQl9Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RlbmVyTWlzbWF0Y2goKSB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWwgPSBuZXcgVGVzdE1vZGVsKCJyb290Iik7Ci0JCXRlc3RNb2RlbC5hZGROb2RlKCJyb290IiwgImNoaWxkIik7Ci0JCVRhcmdldCB0YXJnZXQgPSBuZXcgVGFyZ2V0KHRlc3RNb2RlbCwgVGVzdE1vZGVsLlNUUklOR1NfVFJFRSwgbmV3IFN0cmluZ1tdeyJyb290IiwgImNoaWxkIn0pOwotCQkvLyBidWlsZCBhIFRSRUUgY2hhbmdlIGxpc3RlbmVyIGFuZCBoYWNrIGl0IHNvIHdlCi0JCS8vIGNhbiBhZGQgaXQgYXMgYSBDT0xMRUNUSU9OIGNoYW5nZSBsaXN0ZW5lcgotCQlPYmplY3QgbGlzdGVuZXIgPSBSZWZsZWN0aXZlQ2hhbmdlTGlzdGVuZXIuYnVpbGRUcmVlQ2hhbmdlTGlzdGVuZXIodGFyZ2V0LCAibm9kZUFkZGVkU2luZ2xlQXJndW1lbnQiKTsKLQkJdGVzdE1vZGVsLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcigoQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKSBsaXN0ZW5lcik7Ci0KLQkJYm9vbGVhbiBleENhdWdodCA9IGZhbHNlOwotCQl0cnkgewotCQkJdGVzdE1vZGVsLmNoYW5nZUNvbGxlY3Rpb24oKTsKLQkJCWZhaWwoImxpc3RlbmVyIG1pc21hdGNoOiAiICsgbGlzdGVuZXIpOwotCQl9IGNhdGNoIChJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gZXgpIHsKLQkJCWV4Q2F1Z2h0ID0gdHJ1ZTsKLQkJfQotCQlhc3NlcnRUcnVlKGV4Q2F1Z2h0KTsKLQl9Ci0KLQotCXByaXZhdGUgY2xhc3MgVGVzdE1vZGVsIGV4dGVuZHMgQWJzdHJhY3RNb2RlbCB7Ci0JCXByaXZhdGUgZmluYWwgU3RyaW5nIHJvb3Q7Ci0JCXByaXZhdGUgTWFwPFN0cmluZywgQ29sbGVjdGlvbjxTdHJpbmc+PiBjaGlsZHJlbkxpc3RzID0gbmV3IEhhc2hNYXA8U3RyaW5nLCBDb2xsZWN0aW9uPFN0cmluZz4+KCk7Ci0JCXByaXZhdGUgTWFwPFN0cmluZywgU3RyaW5nPiBwYXJlbnRzID0gbmV3IEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+KCk7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBTVFJJTkdTX1RSRUUgPSAic3RyaW5ncyI7Ci0JCVRlc3RNb2RlbChTdHJpbmcgcm9vdCkgewotCQkJc3VwZXIoKTsKLQkJCWlmIChyb290ID09IG51bGwpIHsKLQkJCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJCX0KLQkJCXRoaXMucm9vdCA9IHJvb3Q7Ci0JCQl0aGlzLmNoaWxkcmVuTGlzdHMucHV0KHJvb3QsIG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpKTsKLQkJCXRoaXMucGFyZW50cy5wdXQocm9vdCwgbnVsbCk7Ci0JCX0KLQkJU3RyaW5nIGdldFJvb3QoKSB7Ci0JCQlyZXR1cm4gdGhpcy5yb290OwotCQl9Ci0JCXByaXZhdGUgU3RyaW5nW10gcGF0aChTdHJpbmcgbm9kZSkgewotCQkJU3RyaW5nIHRlbXAgPSBub2RlOwotCQkJTGlzdDxTdHJpbmc+IHJldmVyc2VQYXRoID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCQlkbyB7Ci0JCQkJcmV2ZXJzZVBhdGguYWRkKHRlbXApOwotCQkJCXRlbXAgPSB0aGlzLnBhcmVudHMuZ2V0KHRlbXApOwotCQkJfSB3aGlsZSAodGVtcCAhPSBudWxsKTsKLQkJCXJldHVybiBDb2xsZWN0aW9uVG9vbHMucmV2ZXJzZShyZXZlcnNlUGF0aCkudG9BcnJheShuZXcgU3RyaW5nW3JldmVyc2VQYXRoLnNpemUoKV0pOwotCQl9Ci0JCUl0ZXJhdG9yPFN0cmluZz4gc3RyaW5ncygpIHsKLQkJCXJldHVybiBuZXcgQ2xvbmVJdGVyYXRvcjxTdHJpbmc+KHRoaXMuY2hpbGRyZW5MaXN0cy5rZXlTZXQoKSkgewotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCB2b2lkIHJlbW92ZShTdHJpbmcgcykgewotCQkJCQlUZXN0TW9kZWwudGhpcy5yZW1vdmVOb2RlKHMpOwotCQkJCX0KLQkJCX07Ci0JCX0KLQkJdm9pZCBhZGROb2RlKFN0cmluZyBwYXJlbnQsIFN0cmluZyBjaGlsZCkgewotCQkJaWYgKChwYXJlbnQgPT0gbnVsbCkgfHwgKGNoaWxkID09IG51bGwpKSB7Ci0JCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCQl9Ci0KLQkJCUNvbGxlY3Rpb248U3RyaW5nPiBjaGlsZHJlbiA9IHRoaXMuY2hpbGRyZW5MaXN0cy5nZXQocGFyZW50KTsKLQkJCWlmIChjaGlsZHJlbiA9PSBudWxsKSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigiY2Fubm90IGFkZCBhIGNoaWxkIHRvIGEgbm9uLWV4aXN0ZW50IHBhcmVudCIpOwotCQkJfQotCi0JCQlpZiAodGhpcy5jaGlsZHJlbkxpc3RzLmdldChjaGlsZCkgIT0gbnVsbCkgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oImNhbm5vdCBhZGQgYSBjaGlsZCB0aGF0IGlzIGFscmVhZHkgaW4gdGhlIHRyZWUiKTsKLQkJCX0KLQkJCQotCQkJY2hpbGRyZW4uYWRkKGNoaWxkKTsKLQkJCXRoaXMuY2hpbGRyZW5MaXN0cy5wdXQoY2hpbGQsIG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpKTsKLQkJCXRoaXMucGFyZW50cy5wdXQoY2hpbGQsIHBhcmVudCk7Ci0JCQl0aGlzLmZpcmVOb2RlQWRkZWQoU1RSSU5HU19UUkVFLCB0aGlzLnBhdGgoY2hpbGQpKTsKLQkJfQotCQl2b2lkIHJlbW92ZU5vZGUoU3RyaW5nIG5vZGUpIHsKLQkJCWlmIChub2RlID09IG51bGwpIHsKLQkJCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJCX0KLQotCQkJQ29sbGVjdGlvbjxTdHJpbmc+IGNoaWxkcmVuID0gdGhpcy5jaGlsZHJlbkxpc3RzLmdldChub2RlKTsKLQkJCWlmIChjaGlsZHJlbiA9PSBudWxsKSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigibm9kZSBpcyBub3QgaW4gdHJlZSIpOwotCQkJfQotCQkJT2JqZWN0W10gcGF0aCA9IHRoaXMucGF0aChub2RlKTsKLQkJCWZvciAoU3RyaW5nIHMgOiBjaGlsZHJlbikgewotCQkJCXRoaXMucmVtb3ZlTm9kZShzKTsKLQkJCX0KLQkJCXRoaXMuY2hpbGRyZW5MaXN0cy5yZW1vdmUobm9kZSk7Ci0JCQl0aGlzLnBhcmVudHMucmVtb3ZlKG5vZGUpOwotCQkJdGhpcy5maXJlTm9kZVJlbW92ZWQoU1RSSU5HU19UUkVFLCBwYXRoKTsKLQkJfQotCQl2b2lkIHJlcGxhY2VOb2RlKFN0cmluZyBvbGROb2RlLCBTdHJpbmcgbmV3Tm9kZSkgewotCQkJaWYgKChvbGROb2RlID09IG51bGwpIHx8IChuZXdOb2RlID09IG51bGwpKSB7Ci0JCQkJdGhyb3cgbmV3IE51bGxQb2ludGVyRXhjZXB0aW9uKCk7Ci0JCQl9Ci0KLQkJCUNvbGxlY3Rpb248U3RyaW5nPiBjaGlsZHJlbiA9IHRoaXMuY2hpbGRyZW5MaXN0cy5yZW1vdmUob2xkTm9kZSk7Ci0JCQlpZiAoY2hpbGRyZW4gPT0gbnVsbCkgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oIm9sZCBub2RlIGlzIG5vdCBpbiB0cmVlIik7Ci0JCQl9Ci0JCQl0aGlzLmNoaWxkcmVuTGlzdHMucHV0KG5ld05vZGUsIGNoaWxkcmVuKTsKLQkJCWZvciAoU3RyaW5nIGNoaWxkIDogY2hpbGRyZW4pIHsKLQkJCQl0aGlzLnBhcmVudHMucHV0KGNoaWxkLCBuZXdOb2RlKTsKLQkJCX0KLQotCQkJU3RyaW5nIHBhcmVudCA9IHRoaXMucGFyZW50cy5yZW1vdmUob2xkTm9kZSk7Ci0JCQl0aGlzLnBhcmVudHMucHV0KG5ld05vZGUsIHBhcmVudCk7Ci0KLQkJCXRoaXMuZmlyZVRyZWVDaGFuZ2VkKFNUUklOR1NfVFJFRSwgdGhpcy5wYXRoKG5ld05vZGUpKTsKLQkJfQotCQl2b2lkIGNsZWFyVHJlZSgpIHsKLQkJCXRoaXMuY2hpbGRyZW5MaXN0cy5jbGVhcigpOwotCQkJdGhpcy5jaGlsZHJlbkxpc3RzLnB1dChyb290LCBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKSk7Ci0JCQl0aGlzLnBhcmVudHMuY2xlYXIoKTsKLQkJCXRoaXMucGFyZW50cy5wdXQocm9vdCwgbnVsbCk7Ci0JCQl0aGlzLmZpcmVUcmVlQ2xlYXJlZChTVFJJTkdTX1RSRUUpOwotCQl9Ci0JCXZvaWQgY2hhbmdlQ29sbGVjdGlvbigpIHsKLQkJCXRoaXMuZmlyZUNvbGxlY3Rpb25DaGFuZ2VkKCJib2d1cyBjb2xsZWN0aW9uIik7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIGNsYXNzIFRhcmdldCB7Ci0JCVRlc3RNb2RlbCB0ZXN0TW9kZWw7Ci0JCVN0cmluZyB0cmVlTmFtZTsKLQkJU3RyaW5nW10gcGF0aDsKLQkJYm9vbGVhbiBub2RlQWRkZWRaZXJvQXJndW1lbnRGbGFnID0gZmFsc2U7Ci0JCWJvb2xlYW4gbm9kZUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnID0gZmFsc2U7Ci0JCWJvb2xlYW4gbm9kZVJlbW92ZWRaZXJvQXJndW1lbnRGbGFnID0gZmFsc2U7Ci0JCWJvb2xlYW4gbm9kZVJlbW92ZWRTaW5nbGVBcmd1bWVudEZsYWcgPSBmYWxzZTsKLQkJYm9vbGVhbiB0cmVlQ2xlYXJlZFplcm9Bcmd1bWVudEZsYWcgPSBmYWxzZTsKLQkJYm9vbGVhbiB0cmVlQ2xlYXJlZFNpbmdsZUFyZ3VtZW50RmxhZyA9IGZhbHNlOwotCQlib29sZWFuIHRyZWVDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyA9IGZhbHNlOwotCQlib29sZWFuIHRyZWVDaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnID0gZmFsc2U7Ci0JCVRhcmdldChUZXN0TW9kZWwgdGVzdE1vZGVsLCBTdHJpbmcgdHJlZU5hbWUsIFN0cmluZ1tdIHBhdGgpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLnRlc3RNb2RlbCA9IHRlc3RNb2RlbDsKLQkJCXRoaXMudHJlZU5hbWUgPSB0cmVlTmFtZTsKLQkJCXRoaXMucGF0aCA9IHBhdGg7Ci0JCX0KLQkJdm9pZCBub2RlQWRkZWRaZXJvQXJndW1lbnQoKSB7Ci0JCQl0aGlzLm5vZGVBZGRlZFplcm9Bcmd1bWVudEZsYWcgPSB0cnVlOwotCQl9Ci0JCXZvaWQgbm9kZUFkZGVkU2luZ2xlQXJndW1lbnQoVHJlZUNoYW5nZUV2ZW50IGUpIHsKLQkJCXRoaXMubm9kZUFkZGVkU2luZ2xlQXJndW1lbnRGbGFnID0gdHJ1ZTsKLQkJCWFzc2VydFNhbWUodGhpcy50ZXN0TW9kZWwsIGUuZ2V0U291cmNlKCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMudHJlZU5hbWUsIGUuZ2V0VHJlZU5hbWUoKSk7Ci0JCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHModGhpcy5wYXRoLCBlLmdldFBhdGgoKSkpOwotCQl9Ci0JCXZvaWQgbm9kZVJlbW92ZWRaZXJvQXJndW1lbnQoKSB7Ci0JCQl0aGlzLm5vZGVSZW1vdmVkWmVyb0FyZ3VtZW50RmxhZyA9IHRydWU7Ci0JCX0KLQkJdm9pZCBub2RlUmVtb3ZlZFNpbmdsZUFyZ3VtZW50KFRyZWVDaGFuZ2VFdmVudCBlKSB7Ci0JCQl0aGlzLm5vZGVSZW1vdmVkU2luZ2xlQXJndW1lbnRGbGFnID0gdHJ1ZTsKLQkJCWFzc2VydFNhbWUodGhpcy50ZXN0TW9kZWwsIGUuZ2V0U291cmNlKCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMudHJlZU5hbWUsIGUuZ2V0VHJlZU5hbWUoKSk7Ci0JCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHModGhpcy5wYXRoLCBlLmdldFBhdGgoKSkpOwotCQl9Ci0JCXZvaWQgdHJlZUNsZWFyZWRaZXJvQXJndW1lbnQoKSB7Ci0JCQl0aGlzLnRyZWVDbGVhcmVkWmVyb0FyZ3VtZW50RmxhZyA9IHRydWU7Ci0JCX0KLQkJdm9pZCB0cmVlQ2xlYXJlZFNpbmdsZUFyZ3VtZW50KFRyZWVDaGFuZ2VFdmVudCBlKSB7Ci0JCQl0aGlzLnRyZWVDbGVhcmVkU2luZ2xlQXJndW1lbnRGbGFnID0gdHJ1ZTsKLQkJCWFzc2VydFNhbWUodGhpcy50ZXN0TW9kZWwsIGUuZ2V0U291cmNlKCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMudHJlZU5hbWUsIGUuZ2V0VHJlZU5hbWUoKSk7Ci0JCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHModGhpcy5wYXRoLCBlLmdldFBhdGgoKSkpOwotCQl9Ci0JCXZvaWQgdHJlZUNoYW5nZWRaZXJvQXJndW1lbnQoKSB7Ci0JCQl0aGlzLnRyZWVDaGFuZ2VkWmVyb0FyZ3VtZW50RmxhZyA9IHRydWU7Ci0JCX0KLQkJdm9pZCB0cmVlQ2hhbmdlZFNpbmdsZUFyZ3VtZW50KFRyZWVDaGFuZ2VFdmVudCBlKSB7Ci0JCQl0aGlzLnRyZWVDaGFuZ2VkU2luZ2xlQXJndW1lbnRGbGFnID0gdHJ1ZTsKLQkJCWFzc2VydFNhbWUodGhpcy50ZXN0TW9kZWwsIGUuZ2V0U291cmNlKCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMudHJlZU5hbWUsIGUuZ2V0VHJlZU5hbWUoKSk7Ci0JCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHModGhpcy5wYXRoLCBlLmdldFBhdGgoKSkpOwotCQl9Ci0JCXZvaWQgY29sbGVjdGlvbkNoYW5nZWREb3VibGVBcmd1bWVudChUcmVlQ2hhbmdlRXZlbnQgZSwgT2JqZWN0IG8pIHsKLQkJCWZhaWwoImJvZ3VzIGV2ZW50OiAiICsgZSk7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQnVmZmVyZWRXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0J1ZmZlcmVkV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxOGRhZWI0Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQnVmZmVyZWRXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0MDggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5EYXRlOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkJ1ZmZlcmVkV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Qcm9wZXJ0eUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIEJ1ZmZlcmVkV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIEVtcGxveWVlIGVtcGxveWVlOwotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8RW1wbG95ZWU+IGVtcGxveWVlSG9sZGVyOwotCVByb3BlcnR5Q2hhbmdlRXZlbnQgZW1wbG95ZWVFdmVudDsKLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4gaWRBZGFwdGVyOwotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBuYW1lQWRhcHRlcjsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPERhdGU+IGhpcmVEYXRlQWRhcHRlcjsKLQlQcm9wZXJ0eUNoYW5nZUV2ZW50IGFkYXB0ZXJFdmVudDsKLQotCXByaXZhdGUgQnVmZmVyZWRXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbC5UcmlnZ2VyIHRyaWdnZXI7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyPiBidWZmZXJlZElESG9sZGVyOwotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWZmZXJlZE5hbWVIb2xkZXI7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxEYXRlPiBidWZmZXJlZEhpcmVEYXRlSG9sZGVyOwotCVByb3BlcnR5Q2hhbmdlRXZlbnQgYnVmZmVyZWRFdmVudDsKLQotCXB1YmxpYyBCdWZmZXJlZFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQotCQl0aGlzLmVtcGxveWVlID0gbmV3IEVtcGxveWVlKDE3LCAiRnJlZGR5IiwgbmV3IERhdGUoKSk7Ci0JCXRoaXMuZW1wbG95ZWVIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPEVtcGxveWVlPih0aGlzLmVtcGxveWVlKTsKLQotCQl0aGlzLnRyaWdnZXIgPSBuZXcgQnVmZmVyZWRXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbC5UcmlnZ2VyKCk7Ci0KLQkJdGhpcy5pZEFkYXB0ZXIgPSB0aGlzLmJ1aWxkSURBZGFwdGVyKHRoaXMuZW1wbG95ZWVIb2xkZXIpOwotCQl0aGlzLmJ1ZmZlcmVkSURIb2xkZXIgPSBuZXcgQnVmZmVyZWRXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxJbnRlZ2VyPih0aGlzLmlkQWRhcHRlciwgdGhpcy50cmlnZ2VyKTsKLQotCQl0aGlzLm5hbWVBZGFwdGVyID0gdGhpcy5idWlsZE5hbWVBZGFwdGVyKHRoaXMuZW1wbG95ZWVIb2xkZXIpOwotCQl0aGlzLmJ1ZmZlcmVkTmFtZUhvbGRlciA9IG5ldyBCdWZmZXJlZFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4odGhpcy5uYW1lQWRhcHRlciwgdGhpcy50cmlnZ2VyKTsKLQotCQl0aGlzLmhpcmVEYXRlQWRhcHRlciA9IHRoaXMuYnVpbGRIaXJlRGF0ZUFkYXB0ZXIodGhpcy5lbXBsb3llZUhvbGRlcik7Ci0JCXRoaXMuYnVmZmVyZWRIaXJlRGF0ZUhvbGRlciA9IG5ldyBCdWZmZXJlZFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPERhdGU+KHRoaXMuaGlyZURhdGVBZGFwdGVyLCB0aGlzLnRyaWdnZXIpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4gYnVpbGRJREFkYXB0ZXIoUHJvcGVydHlWYWx1ZU1vZGVsPEVtcGxveWVlPiBlSG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEVtcGxveWVlLCBJbnRlZ2VyPihlSG9sZGVyLCBFbXBsb3llZS5JRF9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSW50ZWdlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gbmV3IEludGVnZXIodGhpcy5zdWJqZWN0LmdldElEKCkpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oSW50ZWdlciB2YWx1ZSkgewotCQkJCXRoaXMuc3ViamVjdC5zZXRJRCh2YWx1ZS5pbnRWYWx1ZSgpKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGROYW1lQWRhcHRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8RW1wbG95ZWU+IGVIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8RW1wbG95ZWUsIFN0cmluZz4oZUhvbGRlciwgRW1wbG95ZWUuTkFNRV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0TmFtZSgpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldE5hbWUodmFsdWUpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8RGF0ZT4gYnVpbGRIaXJlRGF0ZUFkYXB0ZXIoUHJvcGVydHlWYWx1ZU1vZGVsPEVtcGxveWVlPiBlSG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPEVtcGxveWVlLCBEYXRlPihlSG9sZGVyLCBFbXBsb3llZS5ISVJFX0RBVEVfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIERhdGUgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRIaXJlRGF0ZSgpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oRGF0ZSB2YWx1ZSkgewotCQkJCXRoaXMuc3ViamVjdC5zZXRIaXJlRGF0ZSh2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RWYWx1ZSgpIHsKLQkJUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWZmZXJlZExpc3RlbmVyID0gdGhpcy5idWlsZEJ1ZmZlcmVkTGlzdGVuZXIoKTsKLQkJdGhpcy5idWZmZXJlZElESG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCBidWZmZXJlZExpc3RlbmVyKTsKLQkJdGhpcy5idWZmZXJlZE5hbWVIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIGJ1ZmZlcmVkTGlzdGVuZXIpOwotCQl0aGlzLmJ1ZmZlcmVkSGlyZURhdGVIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIGJ1ZmZlcmVkTGlzdGVuZXIpOwotCi0JCWFzc2VydEVxdWFscyhuZXcgSW50ZWdlcigxNyksIHRoaXMuaWRBZGFwdGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMobmV3IEludGVnZXIoMTcpLCB0aGlzLmJ1ZmZlcmVkSURIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKCJGcmVkZHkiLCB0aGlzLmVtcGxveWVlLmdldE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygiRnJlZGR5IiwgdGhpcy5uYW1lQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJGcmVkZHkiLCB0aGlzLmJ1ZmZlcmVkTmFtZUhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQlEYXRlIHRlbXAgPSB0aGlzLmVtcGxveWVlLmdldEhpcmVEYXRlKCk7Ci0JCWFzc2VydEVxdWFscyh0ZW1wLCB0aGlzLmVtcGxveWVlLmdldEhpcmVEYXRlKCkpOwotCQlhc3NlcnRFcXVhbHModGVtcCwgdGhpcy5oaXJlRGF0ZUFkYXB0ZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscyh0ZW1wLCB0aGlzLmJ1ZmZlcmVkSGlyZURhdGVIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0KLQkJdGhpcy5idWZmZXJlZElESG9sZGVyLnNldFZhbHVlKG5ldyBJbnRlZ2VyKDMyMykpOwotCQlhc3NlcnRFcXVhbHMoMTcsIHRoaXMuZW1wbG95ZWUuZ2V0SUQoKSk7Ci0JCWFzc2VydEVxdWFscyhuZXcgSW50ZWdlcigxNyksIHRoaXMuaWRBZGFwdGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMobmV3IEludGVnZXIoMzIzKSwgdGhpcy5idWZmZXJlZElESG9sZGVyLmdldFZhbHVlKCkpOwotCi0JCXRoaXMuYnVmZmVyZWROYW1lSG9sZGVyLnNldFZhbHVlKCJSaXBsZXkiKTsKLQkJYXNzZXJ0RXF1YWxzKCJGcmVkZHkiLCB0aGlzLmVtcGxveWVlLmdldE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygiRnJlZGR5IiwgdGhpcy5uYW1lQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJSaXBsZXkiLCB0aGlzLmJ1ZmZlcmVkTmFtZUhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLmJ1ZmZlcmVkSGlyZURhdGVIb2xkZXIuc2V0VmFsdWUobnVsbCk7Ci0JCWFzc2VydEVxdWFscyh0ZW1wLCB0aGlzLmVtcGxveWVlLmdldEhpcmVEYXRlKCkpOwotCQlhc3NlcnRFcXVhbHModGVtcCwgdGhpcy5oaXJlRGF0ZUFkYXB0ZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscyhudWxsLCB0aGlzLmJ1ZmZlcmVkSGlyZURhdGVIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFjY2VwdCgpIHsKLQkJUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWZmZXJlZExpc3RlbmVyID0gdGhpcy5idWlsZEJ1ZmZlcmVkTGlzdGVuZXIoKTsKLQkJdGhpcy5idWZmZXJlZElESG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCBidWZmZXJlZExpc3RlbmVyKTsKLQkJdGhpcy5idWZmZXJlZE5hbWVIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIGJ1ZmZlcmVkTGlzdGVuZXIpOwotCQl0aGlzLmJ1ZmZlcmVkSGlyZURhdGVIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIGJ1ZmZlcmVkTGlzdGVuZXIpOwotCi0JCXRoaXMuYnVmZmVyZWRJREhvbGRlci5zZXRWYWx1ZShuZXcgSW50ZWdlcigzMjMpKTsKLQkJYXNzZXJ0RXF1YWxzKDE3LCB0aGlzLmVtcGxveWVlLmdldElEKCkpOwotCQlhc3NlcnRFcXVhbHMobmV3IEludGVnZXIoMTcpLCB0aGlzLmlkQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBJbnRlZ2VyKDMyMyksIHRoaXMuYnVmZmVyZWRJREhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLmJ1ZmZlcmVkTmFtZUhvbGRlci5zZXRWYWx1ZSgiUmlwbGV5Iik7Ci0JCWFzc2VydEVxdWFscygiRnJlZGR5IiwgdGhpcy5lbXBsb3llZS5nZXROYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoIkZyZWRkeSIsIHRoaXMubmFtZUFkYXB0ZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygiUmlwbGV5IiwgdGhpcy5idWZmZXJlZE5hbWVIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0KLQkJRGF0ZSB0ZW1wID0gdGhpcy5lbXBsb3llZS5nZXRIaXJlRGF0ZSgpOwotCQl0aGlzLmJ1ZmZlcmVkSGlyZURhdGVIb2xkZXIuc2V0VmFsdWUobnVsbCk7Ci0JCWFzc2VydEVxdWFscyh0ZW1wLCB0aGlzLmVtcGxveWVlLmdldEhpcmVEYXRlKCkpOwotCQlhc3NlcnRFcXVhbHModGVtcCwgdGhpcy5oaXJlRGF0ZUFkYXB0ZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscyhudWxsLCB0aGlzLmJ1ZmZlcmVkSGlyZURhdGVIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0KLQkJdGhpcy50cmlnZ2VyLmFjY2VwdCgpOwotCi0JCWFzc2VydEVxdWFscygzMjMsIHRoaXMuZW1wbG95ZWUuZ2V0SUQoKSk7Ci0JCWFzc2VydEVxdWFscyhuZXcgSW50ZWdlcigzMjMpLCB0aGlzLmlkQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBJbnRlZ2VyKDMyMyksIHRoaXMuYnVmZmVyZWRJREhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQlhc3NlcnRFcXVhbHMoIlJpcGxleSIsIHRoaXMuZW1wbG95ZWUuZ2V0TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJSaXBsZXkiLCB0aGlzLm5hbWVBZGFwdGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMoIlJpcGxleSIsIHRoaXMuYnVmZmVyZWROYW1lSG9sZGVyLmdldFZhbHVlKCkpOwotCi0JCWFzc2VydEVxdWFscyhudWxsLCB0aGlzLmVtcGxveWVlLmdldEhpcmVEYXRlKCkpOwotCQlhc3NlcnRFcXVhbHMobnVsbCwgdGhpcy5oaXJlRGF0ZUFkYXB0ZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscyhudWxsLCB0aGlzLmJ1ZmZlcmVkSGlyZURhdGVIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlc2V0KCkgewotCQlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1ZmZlcmVkTGlzdGVuZXIgPSB0aGlzLmJ1aWxkQnVmZmVyZWRMaXN0ZW5lcigpOwotCQl0aGlzLmJ1ZmZlcmVkSURIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIGJ1ZmZlcmVkTGlzdGVuZXIpOwotCQl0aGlzLmJ1ZmZlcmVkTmFtZUhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgYnVmZmVyZWRMaXN0ZW5lcik7Ci0JCXRoaXMuYnVmZmVyZWRIaXJlRGF0ZUhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgYnVmZmVyZWRMaXN0ZW5lcik7Ci0KLQkJdGhpcy5idWZmZXJlZElESG9sZGVyLnNldFZhbHVlKG5ldyBJbnRlZ2VyKDMyMykpOwotCQlhc3NlcnRFcXVhbHMoMTcsIHRoaXMuZW1wbG95ZWUuZ2V0SUQoKSk7Ci0JCWFzc2VydEVxdWFscyhuZXcgSW50ZWdlcigxNyksIHRoaXMuaWRBZGFwdGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMobmV3IEludGVnZXIoMzIzKSwgdGhpcy5idWZmZXJlZElESG9sZGVyLmdldFZhbHVlKCkpOwotCi0JCXRoaXMuYnVmZmVyZWROYW1lSG9sZGVyLnNldFZhbHVlKCJSaXBsZXkiKTsKLQkJYXNzZXJ0RXF1YWxzKCJGcmVkZHkiLCB0aGlzLmVtcGxveWVlLmdldE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygiRnJlZGR5IiwgdGhpcy5uYW1lQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJSaXBsZXkiLCB0aGlzLmJ1ZmZlcmVkTmFtZUhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQlEYXRlIHRlbXAgPSB0aGlzLmVtcGxveWVlLmdldEhpcmVEYXRlKCk7Ci0JCXRoaXMuYnVmZmVyZWRIaXJlRGF0ZUhvbGRlci5zZXRWYWx1ZShudWxsKTsKLQkJYXNzZXJ0RXF1YWxzKHRlbXAsIHRoaXMuZW1wbG95ZWUuZ2V0SGlyZURhdGUoKSk7Ci0JCWFzc2VydEVxdWFscyh0ZW1wLCB0aGlzLmhpcmVEYXRlQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKG51bGwsIHRoaXMuYnVmZmVyZWRIaXJlRGF0ZUhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLnRyaWdnZXIucmVzZXQoKTsKLQotCQlhc3NlcnRFcXVhbHMoMTcsIHRoaXMuZW1wbG95ZWUuZ2V0SUQoKSk7Ci0JCWFzc2VydEVxdWFscyhuZXcgSW50ZWdlcigxNyksIHRoaXMuaWRBZGFwdGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMobmV3IEludGVnZXIoMTcpLCB0aGlzLmJ1ZmZlcmVkSURIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKCJGcmVkZHkiLCB0aGlzLmVtcGxveWVlLmdldE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygiRnJlZGR5IiwgdGhpcy5uYW1lQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJGcmVkZHkiLCB0aGlzLmJ1ZmZlcmVkTmFtZUhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQlhc3NlcnRFcXVhbHModGVtcCwgdGhpcy5lbXBsb3llZS5nZXRIaXJlRGF0ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRlbXAsIHRoaXMuaGlyZURhdGVBZGFwdGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHModGVtcCwgdGhpcy5idWZmZXJlZEhpcmVEYXRlSG9sZGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMYXp5TGlzdGVuaW5nKCkgewotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5idWZmZXJlZElESG9sZGVyKS5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5idWZmZXJlZE5hbWVIb2xkZXIpLmhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmJ1ZmZlcmVkSGlyZURhdGVIb2xkZXIpLmhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0KLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuaWRBZGFwdGVyKS5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5uYW1lQWRhcHRlcikuaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuaGlyZURhdGVBZGFwdGVyKS5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCi0JCWFzc2VydFRydWUodGhpcy5lbXBsb3llZS5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKEVtcGxveWVlLklEX1BST1BFUlRZKSk7Ci0JCWFzc2VydFRydWUodGhpcy5lbXBsb3llZS5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKEVtcGxveWVlLk5BTUVfUFJPUEVSVFkpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmVtcGxveWVlLmhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoRW1wbG95ZWUuSElSRV9EQVRFX1BST1BFUlRZKSk7Ci0KLQkJUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWZmZXJlZExpc3RlbmVyID0gdGhpcy5idWlsZEJ1ZmZlcmVkTGlzdGVuZXIoKTsKLQkJdGhpcy5idWZmZXJlZElESG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCBidWZmZXJlZExpc3RlbmVyKTsKLQkJdGhpcy5idWZmZXJlZE5hbWVIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIGJ1ZmZlcmVkTGlzdGVuZXIpOwotCQl0aGlzLmJ1ZmZlcmVkSGlyZURhdGVIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIGJ1ZmZlcmVkTGlzdGVuZXIpOwotCi0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmJ1ZmZlcmVkSURIb2xkZXIpLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5idWZmZXJlZE5hbWVIb2xkZXIpLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5idWZmZXJlZEhpcmVEYXRlSG9sZGVyKS5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5pZEFkYXB0ZXIpLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5uYW1lQWRhcHRlcikuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmhpcmVEYXRlQWRhcHRlcikuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0KLQkJYXNzZXJ0VHJ1ZSh0aGlzLmVtcGxveWVlLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKEVtcGxveWVlLklEX1BST1BFUlRZKSk7Ci0JCWFzc2VydFRydWUodGhpcy5lbXBsb3llZS5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhFbXBsb3llZS5OQU1FX1BST1BFUlRZKSk7Ci0JCWFzc2VydFRydWUodGhpcy5lbXBsb3llZS5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhFbXBsb3llZS5ISVJFX0RBVEVfUFJPUEVSVFkpKTsKLQotCQl0aGlzLmJ1ZmZlcmVkSURIb2xkZXIucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIGJ1ZmZlcmVkTGlzdGVuZXIpOwotCQl0aGlzLmJ1ZmZlcmVkTmFtZUhvbGRlci5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgYnVmZmVyZWRMaXN0ZW5lcik7Ci0JCXRoaXMuYnVmZmVyZWRIaXJlRGF0ZUhvbGRlci5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgYnVmZmVyZWRMaXN0ZW5lcik7Ci0KLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYnVmZmVyZWRJREhvbGRlcikuaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYnVmZmVyZWROYW1lSG9sZGVyKS5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5idWZmZXJlZEhpcmVEYXRlSG9sZGVyKS5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCi0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmlkQWRhcHRlcikuaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMubmFtZUFkYXB0ZXIpLmhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmhpcmVEYXRlQWRhcHRlcikuaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQotCQlhc3NlcnRUcnVlKHRoaXMuZW1wbG95ZWUuaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhFbXBsb3llZS5JRF9QUk9QRVJUWSkpOwotCQlhc3NlcnRUcnVlKHRoaXMuZW1wbG95ZWUuaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhFbXBsb3llZS5OQU1FX1BST1BFUlRZKSk7Ci0JCWFzc2VydFRydWUodGhpcy5lbXBsb3llZS5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKEVtcGxveWVlLkhJUkVfREFURV9QUk9QRVJUWSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RQcm9wZXJ0eUNoYW5nZTEoKSB7Ci0JCVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVmZmVyZWRMaXN0ZW5lciA9IHRoaXMuYnVpbGRCdWZmZXJlZExpc3RlbmVyKCk7Ci0JCXRoaXMuYnVmZmVyZWROYW1lSG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCBidWZmZXJlZExpc3RlbmVyKTsKLQotCQlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGFkYXB0ZXJMaXN0ZW5lciA9IHRoaXMuYnVpbGRBZGFwdGVyTGlzdGVuZXIoKTsKLQkJdGhpcy5uYW1lQWRhcHRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgYWRhcHRlckxpc3RlbmVyKTsKLQotCQlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGVtcGxveWVlTGlzdGVuZXIgPSB0aGlzLmJ1aWxkRW1wbG95ZWVMaXN0ZW5lcigpOwotCQl0aGlzLmVtcGxveWVlLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoRW1wbG95ZWUuTkFNRV9QUk9QRVJUWSwgZW1wbG95ZWVMaXN0ZW5lcik7Ci0KLQkJdGhpcy52ZXJpZnlQcm9wZXJ0eUNoYW5nZXMoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UHJvcGVydHlDaGFuZ2UyKCkgewotCQlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1ZmZlcmVkTGlzdGVuZXIgPSB0aGlzLmJ1aWxkQnVmZmVyZWRMaXN0ZW5lcigpOwotCQl0aGlzLmJ1ZmZlcmVkTmFtZUhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKGJ1ZmZlcmVkTGlzdGVuZXIpOwotCi0JCVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYWRhcHRlckxpc3RlbmVyID0gdGhpcy5idWlsZEFkYXB0ZXJMaXN0ZW5lcigpOwotCQl0aGlzLm5hbWVBZGFwdGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoYWRhcHRlckxpc3RlbmVyKTsKLQotCQlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGVtcGxveWVlTGlzdGVuZXIgPSB0aGlzLmJ1aWxkRW1wbG95ZWVMaXN0ZW5lcigpOwotCQl0aGlzLmVtcGxveWVlLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoZW1wbG95ZWVMaXN0ZW5lcik7Ci0KLQkJdGhpcy52ZXJpZnlQcm9wZXJ0eUNoYW5nZXMoKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UHJvcGVydHlDaGFuZ2VzKCkgewotCQl0aGlzLmJ1ZmZlcmVkRXZlbnQgPSBudWxsOwotCQl0aGlzLmFkYXB0ZXJFdmVudCA9IG51bGw7Ci0JCXRoaXMuZW1wbG95ZWVFdmVudCA9IG51bGw7Ci0JCXRoaXMuYnVmZmVyZWROYW1lSG9sZGVyLnNldFZhbHVlKCJSaXBsZXkiKTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLmJ1ZmZlcmVkRXZlbnQsIHRoaXMuYnVmZmVyZWROYW1lSG9sZGVyLCBQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsICJGcmVkZHkiLCAiUmlwbGV5Iik7Ci0JCWFzc2VydE51bGwodGhpcy5hZGFwdGVyRXZlbnQpOwotCQlhc3NlcnROdWxsKHRoaXMuZW1wbG95ZWVFdmVudCk7Ci0KLQkJdGhpcy5idWZmZXJlZEV2ZW50ID0gbnVsbDsKLQkJdGhpcy5hZGFwdGVyRXZlbnQgPSBudWxsOwotCQl0aGlzLmVtcGxveWVlRXZlbnQgPSBudWxsOwotCQl0aGlzLmJ1ZmZlcmVkTmFtZUhvbGRlci5zZXRWYWx1ZSgiQ2hhcmxpZSIpOwotCQl0aGlzLnZlcmlmeUV2ZW50KHRoaXMuYnVmZmVyZWRFdmVudCwgdGhpcy5idWZmZXJlZE5hbWVIb2xkZXIsIFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgIlJpcGxleSIsICJDaGFybGllIik7Ci0JCWFzc2VydE51bGwodGhpcy5hZGFwdGVyRXZlbnQpOwotCQlhc3NlcnROdWxsKHRoaXMuZW1wbG95ZWVFdmVudCk7Ci0KLQkJdGhpcy5idWZmZXJlZEV2ZW50ID0gbnVsbDsKLQkJdGhpcy5hZGFwdGVyRXZlbnQgPSBudWxsOwotCQl0aGlzLmVtcGxveWVlRXZlbnQgPSBudWxsOwotCQl0aGlzLnRyaWdnZXIuYWNjZXB0KCk7Ci0JCWFzc2VydE51bGwodGhpcy5idWZmZXJlZEV2ZW50KTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLmFkYXB0ZXJFdmVudCwgdGhpcy5uYW1lQWRhcHRlciwgUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCAiRnJlZGR5IiwgIkNoYXJsaWUiKTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLmVtcGxveWVlRXZlbnQsIHRoaXMuZW1wbG95ZWUsIEVtcGxveWVlLk5BTUVfUFJPUEVSVFksICJGcmVkZHkiLCAiQ2hhcmxpZSIpOwotCi0JCXRoaXMuYnVmZmVyZWRFdmVudCA9IG51bGw7Ci0JCXRoaXMuYWRhcHRlckV2ZW50ID0gbnVsbDsKLQkJdGhpcy5lbXBsb3llZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5idWZmZXJlZE5hbWVIb2xkZXIuc2V0VmFsdWUoIkphc29uIik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5idWZmZXJlZEV2ZW50LCB0aGlzLmJ1ZmZlcmVkTmFtZUhvbGRlciwgUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCAiQ2hhcmxpZSIsICJKYXNvbiIpOwotCQlhc3NlcnROdWxsKHRoaXMuYWRhcHRlckV2ZW50KTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmVtcGxveWVlRXZlbnQpOwotCi0JCXRoaXMuYnVmZmVyZWRFdmVudCA9IG51bGw7Ci0JCXRoaXMuYWRhcHRlckV2ZW50ID0gbnVsbDsKLQkJdGhpcy5lbXBsb3llZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy50cmlnZ2VyLnJlc2V0KCk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5idWZmZXJlZEV2ZW50LCB0aGlzLmJ1ZmZlcmVkTmFtZUhvbGRlciwgUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCAiSmFzb24iLCAiQ2hhcmxpZSIpOwotCQlhc3NlcnROdWxsKHRoaXMuYWRhcHRlckV2ZW50KTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmVtcGxveWVlRXZlbnQpOwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZEJ1ZmZlcmVkTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJCQlCdWZmZXJlZFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMudGhpcy5idWZmZXJlZEV2ZW50ID0gZTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGRBZGFwdGVyTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJCQlCdWZmZXJlZFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMudGhpcy5hZGFwdGVyRXZlbnQgPSBlOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZEVtcGxveWVlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJCQlCdWZmZXJlZFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMudGhpcy5lbXBsb3llZUV2ZW50ID0gZTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5RXZlbnQoUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudCwgT2JqZWN0IHNvdXJjZSwgU3RyaW5nIHByb3BlcnR5TmFtZSwgT2JqZWN0IG9sZFZhbHVlLCBPYmplY3QgbmV3VmFsdWUpIHsKLQkJYXNzZXJ0RXF1YWxzKHNvdXJjZSwgZXZlbnQuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMocHJvcGVydHlOYW1lLCBldmVudC5nZXRQcm9wZXJ0eU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscyhvbGRWYWx1ZSwgZXZlbnQuZ2V0T2xkVmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscyhuZXdWYWx1ZSwgZXZlbnQuZ2V0TmV3VmFsdWUoKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGlubmVyIGNsYXNzICoqKioqKioqKioKLQotCXByaXZhdGUgY2xhc3MgRW1wbG95ZWUgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIHsKLQkJcHJpdmF0ZSBpbnQgaWQ7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBJRF9QUk9QRVJUWSA9ICJpZCI7Ci0JCXByaXZhdGUgU3RyaW5nIG5hbWU7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBOQU1FX1BST1BFUlRZID0gIm5hbWUiOwotCQlwcml2YXRlIERhdGUgaGlyZURhdGU7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBISVJFX0RBVEVfUFJPUEVSVFkgPSAiaGlyZURhdGUiOwotCi0JCUVtcGxveWVlKGludCBpZCwgU3RyaW5nIG5hbWUsIERhdGUgaGlyZURhdGUpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLmlkID0gaWQ7Ci0JCQl0aGlzLm5hbWUgPSBuYW1lOwotCQkJdGhpcy5oaXJlRGF0ZSA9IGhpcmVEYXRlOwotCQl9Ci0JCWludCBnZXRJRCgpIHsKLQkJCXJldHVybiB0aGlzLmlkOwotCQl9Ci0JCXZvaWQgc2V0SUQoaW50IGlkKSB7Ci0JCQlpbnQgb2xkID0gdGhpcy5pZDsKLQkJCXRoaXMuaWQgPSBpZDsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChJRF9QUk9QRVJUWSwgb2xkLCBpZCk7Ci0JCX0KLQkJU3RyaW5nIGdldE5hbWUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5uYW1lOwotCQl9Ci0JCXZvaWQgc2V0TmFtZShTdHJpbmcgbmFtZSkgewotCQkJT2JqZWN0IG9sZCA9IHRoaXMubmFtZTsKLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoTkFNRV9QUk9QRVJUWSwgb2xkLCBuYW1lKTsKLQkJfQotCQlEYXRlIGdldEhpcmVEYXRlKCkgewotCQkJcmV0dXJuIHRoaXMuaGlyZURhdGU7Ci0JCX0KLQkJdm9pZCBzZXRIaXJlRGF0ZShEYXRlIGhpcmVEYXRlKSB7Ci0JCQlPYmplY3Qgb2xkID0gdGhpcy5oaXJlRGF0ZTsKLQkJCXRoaXMuaGlyZURhdGUgPSBoaXJlRGF0ZTsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChISVJFX0RBVEVfUFJPUEVSVFksIG9sZCwgaGlyZURhdGUpOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgdm9pZCB0b1N0cmluZyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCQlzYi5hcHBlbmQodGhpcy5uYW1lKTsKLQkJfQotCX0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ2FjaGluZ1RyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ2FjaGluZ1RyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjJjNTZiOS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0NhY2hpbmdUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyMjAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5CaWRpVHJhbnNmb3JtZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5DYWNoaW5nVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlByb3BlcnR5Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1AU3VwcHJlc3NXYXJuaW5ncygibmxzIikKLXB1YmxpYyBjbGFzcyBDYWNoaW5nVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFBlcnNvbj4gb2JqZWN0SG9sZGVyOwotCVByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQ7Ci0KLQlwcml2YXRlIFByb3BlcnR5VmFsdWVNb2RlbDxQZXJzb24+IHRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyOwotCVByb3BlcnR5Q2hhbmdlRXZlbnQgdHJhbnNmb3JtYXRpb25FdmVudDsKLQotCXB1YmxpYyBDYWNoaW5nVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLm9iamVjdEhvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8UGVyc29uPihuZXcgUGVyc29uKCJLYXJlbiIsICJQZWdneSIsIG51bGwpKTsKLQkJdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlciA9IG5ldyBDYWNoaW5nVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWw8UGVyc29uLCBQZXJzb24+KHRoaXMub2JqZWN0SG9sZGVyLCB0aGlzLmJ1aWxkVHJhbnNmb3JtZXIoKSk7Ci0JfQotCi0JcHJpdmF0ZSBCaWRpVHJhbnNmb3JtZXI8UGVyc29uLCBQZXJzb24+IGJ1aWxkVHJhbnNmb3JtZXIoKSB7Ci0JCXJldHVybiBuZXcgQmlkaVRyYW5zZm9ybWVyPFBlcnNvbiwgUGVyc29uPigpIHsKLQkJCXB1YmxpYyBQZXJzb24gdHJhbnNmb3JtKFBlcnNvbiBwKSB7Ci0JCQkJcmV0dXJuIChwID09IG51bGwpID8gbnVsbCA6IHAuZ2V0UGFyZW50KCk7Ci0JCQl9Ci0JCQlwdWJsaWMgUGVyc29uIHJldmVyc2VUcmFuc2Zvcm0oUGVyc29uIHApIHsKLQkJCQlyZXR1cm4gKHAgPT0gbnVsbCkgPyBudWxsIDogcC5nZXRDaGlsZCgpOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VmFsdWUoKSB7Ci0JCVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSB0aGlzLmJ1aWxkVHJhbnNmb3JtYXRpb25MaXN0ZW5lcigpOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQkKLQkJUGVyc29uIHBlcnNvbiA9IHRoaXMub2JqZWN0SG9sZGVyLmdldFZhbHVlKCk7Ci0JCWFzc2VydEVxdWFscygiS2FyZW4iLCBwZXJzb24uZ2V0TmFtZSgpKTsKLQkJUGVyc29uIHBhcmVudCA9IHRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuZ2V0VmFsdWUoKTsKLQkJYXNzZXJ0RXF1YWxzKHBlcnNvbi5nZXRQYXJlbnQoKS5nZXROYW1lKCksIHBhcmVudC5nZXROYW1lKCkpOwotCQlhc3NlcnROb3RTYW1lKHBlcnNvbi5nZXRQYXJlbnQoKSwgdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHBhcmVudCwgdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQlQZXJzb24gcGVyc29uMSA9IG5ldyBQZXJzb24oIk1hdHQiLCAiTWl0Y2giLCBudWxsKTsKLQkJdGhpcy5vYmplY3RIb2xkZXIuc2V0VmFsdWUocGVyc29uMSk7Ci0JCVBlcnNvbiBwYXJlbnQyID0gdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpOwotCQlhc3NlcnRFcXVhbHMocGVyc29uMS5nZXRQYXJlbnQoKS5nZXROYW1lKCksIHBhcmVudDIuZ2V0TmFtZSgpKTsKLQkJYXNzZXJ0Tm90U2FtZShwZXJzb24xLmdldFBhcmVudCgpLCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMocGFyZW50MiwgdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCi0JCXRoaXMub2JqZWN0SG9sZGVyLnNldFZhbHVlKG51bGwpOwotCQlhc3NlcnROdWxsKHRoaXMub2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnROdWxsKHRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0KLQkJUGVyc29uIHBlcnNvbjMgPSBuZXcgUGVyc29uKCJLYXJlbiIsICJQZWdneSIsIG51bGwpOwotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZShwZXJzb24zKTsKLQkJYXNzZXJ0RXF1YWxzKCJLYXJlbiIsIHBlcnNvbjMuZ2V0TmFtZSgpKTsKLQkJUGVyc29uIHBhcmVudDMgPSB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCk7Ci0JCWFzc2VydEVxdWFscyhwZXJzb24zLmdldFBhcmVudCgpLmdldE5hbWUoKSwgcGFyZW50My5nZXROYW1lKCkpOwotCQlhc3NlcnROb3RTYW1lKHBlcnNvbjMuZ2V0UGFyZW50KCksIHRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscyhwYXJlbnQzLCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMYXp5TGlzdGVuaW5nKCkgewotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5vYmplY3RIb2xkZXIpLmhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSB0aGlzLmJ1aWxkVHJhbnNmb3JtYXRpb25MaXN0ZW5lcigpOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5vYmplY3RIb2xkZXIpLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5vYmplY3RIb2xkZXIpLmhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0KLQkJdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgbGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5vYmplY3RIb2xkZXIpLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCBsaXN0ZW5lcik7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLm9iamVjdEhvbGRlcikuaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UHJvcGVydHlDaGFuZ2UxKCkgewotCQl0aGlzLm9iamVjdEhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRMaXN0ZW5lcigpKTsKLQkJdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRUcmFuc2Zvcm1hdGlvbkxpc3RlbmVyKCkpOwotCQl0aGlzLnZlcmlmeVByb3BlcnR5Q2hhbmdlcygpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RQcm9wZXJ0eUNoYW5nZTIoKSB7Ci0JCXRoaXMub2JqZWN0SG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmJ1aWxkTGlzdGVuZXIoKSk7Ci0JCXRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMuYnVpbGRUcmFuc2Zvcm1hdGlvbkxpc3RlbmVyKCkpOwotCQl0aGlzLnZlcmlmeVByb3BlcnR5Q2hhbmdlcygpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlQcm9wZXJ0eUNoYW5nZXMoKSB7Ci0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uRXZlbnQgPSBudWxsOwotCQlQZXJzb24ga2FyZW4gPSB0aGlzLm9iamVjdEhvbGRlci5nZXRWYWx1ZSgpOwotCQlQZXJzb24gcGVnZ3lQYXJlbnQgPSB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCk7Ci0JCVBlcnNvbiBwZWdneSA9IG5ldyBQZXJzb24oIlBlZ2d5IiwgIk1hcmlhbiIsIG51bGwpOwotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZShwZWdneSk7Ci0JCVBlcnNvbiBtYXJpYW5QYXJlbnQgPSB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5ldmVudCwgdGhpcy5vYmplY3RIb2xkZXIsIGthcmVuLCBwZWdneSk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy50cmFuc2Zvcm1hdGlvbkV2ZW50LCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLCBwZWdneVBhcmVudCwgbWFyaWFuUGFyZW50KTsKLQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy50cmFuc2Zvcm1hdGlvbkV2ZW50ID0gbnVsbDsKLQkJUGVyc29uIG1hdHQgPSBuZXcgUGVyc29uKCJNYXR0IiwgIk1pdGNoIiwgbnVsbCk7Ci0JCXRoaXMub2JqZWN0SG9sZGVyLnNldFZhbHVlKG1hdHQpOwotCQlQZXJzb24gbWl0Y2hQYXJlbnQgPSB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5ldmVudCwgdGhpcy5vYmplY3RIb2xkZXIsIHBlZ2d5LCBtYXR0KTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLnRyYW5zZm9ybWF0aW9uRXZlbnQsIHRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIsIG1hcmlhblBhcmVudCwgbWl0Y2hQYXJlbnQpOwotCi0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uRXZlbnQgPSBudWxsOwotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZShudWxsKTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLmV2ZW50LCB0aGlzLm9iamVjdEhvbGRlciwgbWF0dCwgbnVsbCk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy50cmFuc2Zvcm1hdGlvbkV2ZW50LCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLCBtaXRjaFBhcmVudCwgbnVsbCk7Ci0KLQkJdGhpcy5ldmVudCA9IG51bGw7Ci0JCXRoaXMudHJhbnNmb3JtYXRpb25FdmVudCA9IG51bGw7Ci0JCXRoaXMub2JqZWN0SG9sZGVyLnNldFZhbHVlKG1hdHQpOwotCQltaXRjaFBhcmVudCA9IHRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuZ2V0VmFsdWUoKTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLmV2ZW50LCB0aGlzLm9iamVjdEhvbGRlciwgbnVsbCwgbWF0dCk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy50cmFuc2Zvcm1hdGlvbkV2ZW50LCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLCBudWxsLCBtaXRjaFBhcmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJCQlDYWNoaW5nVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cy50aGlzLmV2ZW50ID0gZTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGRUcmFuc2Zvcm1hdGlvbkxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJQ2FjaGluZ1RyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMudGhpcy50cmFuc2Zvcm1hdGlvbkV2ZW50ID0gZTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5RXZlbnQoUHJvcGVydHlDaGFuZ2VFdmVudCBlLCBPYmplY3Qgc291cmNlLCBPYmplY3Qgb2xkVmFsdWUsIE9iamVjdCBuZXdWYWx1ZSkgewotCQlhc3NlcnRFcXVhbHMoc291cmNlLCBlLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgZS5nZXRQcm9wZXJ0eU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscyhvbGRWYWx1ZSwgZS5nZXRPbGRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKG5ld1ZhbHVlLCBlLmdldE5ld1ZhbHVlKCkpOwotCX0KLQotCQotCXByaXZhdGUgY2xhc3MgUGVyc29uIGV4dGVuZHMgQWJzdHJhY3RNb2RlbCB7Ci0KLQkJcHJpdmF0ZSBTdHJpbmcgbmFtZTsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIE5BTUVfUFJPUEVSVFkgPSAibmFtZSI7Ci0JCQotCQlwcml2YXRlIFN0cmluZyBwYXJlbnROYW1lOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgUEFSRU5UX05BTUVfUFJPUEVSVFkgPSAicGFyZW50TmFtZSI7Ci0JCQotCQlwcml2YXRlIFBlcnNvbiBjaGlsZDsKLQkJCi0JCXB1YmxpYyBQZXJzb24oU3RyaW5nIG5hbWUsIFN0cmluZyBwYXJlbnROYW1lLCBQZXJzb24gY2hpbGQpIHsKLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCQl0aGlzLnBhcmVudE5hbWUgPSBwYXJlbnROYW1lOwotCQkJdGhpcy5jaGlsZCA9IGNoaWxkOwotCQl9Ci0JCQotCQlwdWJsaWMgU3RyaW5nIGdldE5hbWUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5uYW1lOwotCQl9Ci0JCQotCQlwdWJsaWMgdm9pZCBzZXROYW1lKFN0cmluZyBuZXdOYW1lKSB7Ci0JCQlTdHJpbmcgb2xkTmFtZSA9IHRoaXMubmFtZTsKLQkJCXRoaXMubmFtZSA9IG5ld05hbWU7Ci0JCQlmaXJlUHJvcGVydHlDaGFuZ2VkKE5BTUVfUFJPUEVSVFksIG9sZE5hbWUsIG5ld05hbWUpOwotCQl9Ci0JCQotCQlwdWJsaWMgUGVyc29uIGdldFBhcmVudCgpIHsKLQkJCXJldHVybiBuZXcgUGVyc29uKHRoaXMucGFyZW50TmFtZSwgbnVsbCwgdGhpcyk7Ci0JCX0KLQkJCi0JCXB1YmxpYyBTdHJpbmcgZ2V0UGFyZW50TmFtZSgpIHsKLQkJCXJldHVybiB0aGlzLnBhcmVudE5hbWU7Ci0JCX0KLQkJCi0JCXB1YmxpYyB2b2lkIHNldFBhcmVudE5hbWUoU3RyaW5nIG5ld1BhcmVudE5hbWUpIHsKLQkJCVN0cmluZyBvbGRQYXJlbnROYW1lID0gdGhpcy5wYXJlbnROYW1lOwotCQkJdGhpcy5wYXJlbnROYW1lID0gbmV3UGFyZW50TmFtZTsKLQkJCWZpcmVQcm9wZXJ0eUNoYW5nZWQoUEFSRU5UX05BTUVfUFJPUEVSVFksIG9sZFBhcmVudE5hbWUsIG5ld1BhcmVudE5hbWUpOwotCQl9Ci0JCQotCQlwdWJsaWMgUGVyc29uIGdldENoaWxkKCkgewotCQkJcmV0dXJuIHRoaXMuY2hpbGQ7Ci0JCX0KLQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9DYWNoaW5nVHJhbnNmb3JtYXRpb25Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0NhY2hpbmdUcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjE5ODcyMS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0NhY2hpbmdUcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI0OSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkJpZGlUcmFuc2Zvcm1lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkNhY2hpbmdUcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Qcm9wZXJ0eUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotQFN1cHByZXNzV2FybmluZ3MoIm5scyIpCi1wdWJsaWMgY2xhc3MgQ2FjaGluZ1RyYW5zZm9ybWF0aW9uV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFBlcnNvbj4gb2JqZWN0SG9sZGVyOwotCVByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQ7Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFBlcnNvbj4gdHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXI7Ci0JUHJvcGVydHlDaGFuZ2VFdmVudCB0cmFuc2Zvcm1hdGlvbkV2ZW50OwotCi0JcHVibGljIENhY2hpbmdUcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy5vYmplY3RIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPFBlcnNvbj4obmV3IFBlcnNvbigiS2FyZW4iLCAiUGVnZ3kiLCBudWxsKSk7Ci0JCXRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIgPSBuZXcgQ2FjaGluZ1RyYW5zZm9ybWF0aW9uV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8UGVyc29uLCBQZXJzb24+KHRoaXMub2JqZWN0SG9sZGVyLCB0aGlzLmJ1aWxkVHJhbnNmb3JtZXIoKSk7Ci0JfQotCi0JcHJpdmF0ZSBCaWRpVHJhbnNmb3JtZXI8UGVyc29uLCBQZXJzb24+IGJ1aWxkVHJhbnNmb3JtZXIoKSB7Ci0JCXJldHVybiBuZXcgQmlkaVRyYW5zZm9ybWVyPFBlcnNvbiwgUGVyc29uPigpIHsKLQkJCXB1YmxpYyBQZXJzb24gdHJhbnNmb3JtKFBlcnNvbiBwKSB7Ci0JCQkJcmV0dXJuIChwID09IG51bGwpID8gbnVsbCA6IHAuZ2V0UGFyZW50KCk7Ci0JCQl9Ci0JCQlwdWJsaWMgUGVyc29uIHJldmVyc2VUcmFuc2Zvcm0oUGVyc29uIHApIHsKLQkJCQlyZXR1cm4gKHAgPT0gbnVsbCkgPyBudWxsIDogcC5nZXRDaGlsZCgpOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VmFsdWUoKSB7Ci0JCVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSB0aGlzLmJ1aWxkVHJhbnNmb3JtYXRpb25MaXN0ZW5lcigpOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCi0JCQotCQlQZXJzb24gcGVyc29uID0gdGhpcy5vYmplY3RIb2xkZXIuZ2V0VmFsdWUoKTsKLQkJYXNzZXJ0RXF1YWxzKCJLYXJlbiIsIHBlcnNvbi5nZXROYW1lKCkpOwotCQlQZXJzb24gcGFyZW50ID0gdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpOwotCQlhc3NlcnRFcXVhbHMocGVyc29uLmdldFBhcmVudCgpLmdldE5hbWUoKSwgcGFyZW50LmdldE5hbWUoKSk7Ci0JCWFzc2VydE5vdFNhbWUocGVyc29uLmdldFBhcmVudCgpLCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMocGFyZW50LCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCi0JCVBlcnNvbiBwZXJzb24xID0gbmV3IFBlcnNvbigiTWF0dCIsICJNaXRjaCIsIG51bGwpOwotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZShwZXJzb24xKTsKLQkJUGVyc29uIHBhcmVudDIgPSB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCk7Ci0JCWFzc2VydEVxdWFscyhwZXJzb24xLmdldFBhcmVudCgpLmdldE5hbWUoKSwgcGFyZW50Mi5nZXROYW1lKCkpOwotCQlhc3NlcnROb3RTYW1lKHBlcnNvbjEuZ2V0UGFyZW50KCksIHRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscyhwYXJlbnQyLCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCi0KLQkJdGhpcy5vYmplY3RIb2xkZXIuc2V0VmFsdWUobnVsbCk7Ci0JCWFzc2VydE51bGwodGhpcy5vYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydE51bGwodGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQlQZXJzb24gcGVyc29uMyA9IG5ldyBQZXJzb24oIkthcmVuIiwgIlBlZ2d5IiwgbnVsbCk7Ci0JCXRoaXMub2JqZWN0SG9sZGVyLnNldFZhbHVlKHBlcnNvbjMpOwotCQlhc3NlcnRFcXVhbHMoIkthcmVuIiwgcGVyc29uMy5nZXROYW1lKCkpOwotCQlQZXJzb24gcGFyZW50MyA9IHRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuZ2V0VmFsdWUoKTsKLQkJYXNzZXJ0RXF1YWxzKHBlcnNvbjMuZ2V0UGFyZW50KCkuZ2V0TmFtZSgpLCBwYXJlbnQzLmdldE5hbWUoKSk7Ci0JCWFzc2VydE5vdFNhbWUocGVyc29uMy5nZXRQYXJlbnQoKSwgdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHBhcmVudDMsIHRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNldFZhbHVlKCkgewotCQlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyID0gdGhpcy5idWlsZFRyYW5zZm9ybWF0aW9uTGlzdGVuZXIoKTsKLQkJdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQotCQlQZXJzb24gcGVyc29uID0gbmV3IFBlcnNvbigiQ2hyaXMiLCAiTm9lbCIsIG51bGwpOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLnNldFZhbHVlKHBlcnNvbi5nZXRQYXJlbnQoKSk7Ci0JCWFzc2VydEVxdWFscyhwZXJzb24sIHRoaXMub2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMocGVyc29uLmdldFBhcmVudCgpLmdldE5hbWUoKSwgdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpLmdldE5hbWUoKSk7Ci0JCWFzc2VydE5vdFNhbWUocGVyc29uLmdldFBhcmVudCgpLCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCi0JCVBlcnNvbiBwZXJzb24yID0gbmV3IFBlcnNvbigiSm9uIiwgIkVsaXphYmV0aCIsIG51bGwpOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLnNldFZhbHVlKHBlcnNvbjIuZ2V0UGFyZW50KCkpOwotCQlhc3NlcnRFcXVhbHMocGVyc29uMiwgdGhpcy5vYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscyhwZXJzb24yLmdldFBhcmVudCgpLmdldE5hbWUoKSwgdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpLmdldE5hbWUoKSk7Ci0JCWFzc2VydE5vdFNhbWUocGVyc29uMi5nZXRQYXJlbnQoKSwgdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLnNldFZhbHVlKG51bGwpOwotCQlhc3NlcnROdWxsKHRoaXMub2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnROdWxsKHRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0KLQkJdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5zZXRWYWx1ZShwZXJzb24uZ2V0UGFyZW50KCkpOwotCQlhc3NlcnRFcXVhbHMocGVyc29uLCB0aGlzLm9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHBlcnNvbi5nZXRQYXJlbnQoKS5nZXROYW1lKCksIHRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuZ2V0VmFsdWUoKS5nZXROYW1lKCkpOwotCQlhc3NlcnROb3RTYW1lKHBlcnNvbi5nZXRQYXJlbnQoKSwgdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGF6eUxpc3RlbmluZygpIHsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMub2JqZWN0SG9sZGVyKS5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyID0gdGhpcy5idWlsZFRyYW5zZm9ybWF0aW9uTGlzdGVuZXIoKTsKLQkJdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMub2JqZWN0SG9sZGVyKS5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMub2JqZWN0SG9sZGVyKS5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCi0JCXRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIGxpc3RlbmVyKTsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMub2JqZWN0SG9sZGVyKS5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgbGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5vYmplY3RIb2xkZXIpLmhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFByb3BlcnR5Q2hhbmdlMSgpIHsKLQkJdGhpcy5vYmplY3RIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcih0aGlzLmJ1aWxkTGlzdGVuZXIoKSk7Ci0JCXRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcih0aGlzLmJ1aWxkVHJhbnNmb3JtYXRpb25MaXN0ZW5lcigpKTsKLQkJdGhpcy52ZXJpZnlQcm9wZXJ0eUNoYW5nZXMoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UHJvcGVydHlDaGFuZ2UyKCkgewotCQl0aGlzLm9iamVjdEhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5idWlsZExpc3RlbmVyKCkpOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmJ1aWxkVHJhbnNmb3JtYXRpb25MaXN0ZW5lcigpKTsKLQkJdGhpcy52ZXJpZnlQcm9wZXJ0eUNoYW5nZXMoKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UHJvcGVydHlDaGFuZ2VzKCkgewotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy50cmFuc2Zvcm1hdGlvbkV2ZW50ID0gbnVsbDsKLQkJUGVyc29uIG9sZFBlcnNvbiA9IHRoaXMub2JqZWN0SG9sZGVyLmdldFZhbHVlKCk7Ci0JCVBlcnNvbiBvbGRQYXJlbnQgPSB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCk7Ci0JCVBlcnNvbiBuZXdQZXJzb24gPSBuZXcgUGVyc29uKCJLYXJlbiIgLCAiUGVnZ3kiLCBudWxsKTsKLQkJdGhpcy5vYmplY3RIb2xkZXIuc2V0VmFsdWUobmV3UGVyc29uKTsKLQkJUGVyc29uIG5ld1BhcmVudCA9IHRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuZ2V0VmFsdWUoKTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLmV2ZW50LCB0aGlzLm9iamVjdEhvbGRlciwgb2xkUGVyc29uLCBuZXdQZXJzb24pOwotCQl0aGlzLnZlcmlmeUV2ZW50KHRoaXMudHJhbnNmb3JtYXRpb25FdmVudCwgdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlciwgb2xkUGFyZW50LCBuZXdQYXJlbnQpOwotCi0vLwotLy8JCXRoaXMuZXZlbnQgPSBudWxsOwotLy8JCXRoaXMudHJhbnNmb3JtYXRpb25FdmVudCA9IG51bGw7Ci0vLwkJdGhpcy5vYmplY3RIb2xkZXIuc2V0VmFsdWUoIkZvbyIpOwotLy8JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5ldmVudCwgdGhpcy5vYmplY3RIb2xkZXIsICJiYXoiLCAiRm9vIik7Ci0vLwkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLnRyYW5zZm9ybWF0aW9uRXZlbnQsIHRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIsICJCQVoiLCAiRk9PIik7Ci0vLwotLy8JCXRoaXMuZXZlbnQgPSBudWxsOwotLy8JCXRoaXMudHJhbnNmb3JtYXRpb25FdmVudCA9IG51bGw7Ci0vLwkJdGhpcy5vYmplY3RIb2xkZXIuc2V0VmFsdWUoIkZPTyIpOwotLy8JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5ldmVudCwgdGhpcy5vYmplY3RIb2xkZXIsICJGb28iLCAiRk9PIik7Ci0vLwkJYXNzZXJ0TnVsbCh0aGlzLnRyYW5zZm9ybWF0aW9uRXZlbnQpOwotLy8KLS8vCQl0aGlzLmV2ZW50ID0gbnVsbDsKLS8vCQl0aGlzLnRyYW5zZm9ybWF0aW9uRXZlbnQgPSBudWxsOwotLy8JCXRoaXMub2JqZWN0SG9sZGVyLnNldFZhbHVlKG51bGwpOwotLy8JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5ldmVudCwgdGhpcy5vYmplY3RIb2xkZXIsICJGT08iLCBudWxsKTsKLS8vCQl0aGlzLnZlcmlmeUV2ZW50KHRoaXMudHJhbnNmb3JtYXRpb25FdmVudCwgdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlciwgIkZPTyIsIG51bGwpOwotLy8KLS8vCQl0aGlzLmV2ZW50ID0gbnVsbDsKLS8vCQl0aGlzLnRyYW5zZm9ybWF0aW9uRXZlbnQgPSBudWxsOwotLy8JCXRoaXMub2JqZWN0SG9sZGVyLnNldFZhbHVlKCJiYXIiKTsKLS8vCQl0aGlzLnZlcmlmeUV2ZW50KHRoaXMuZXZlbnQsIHRoaXMub2JqZWN0SG9sZGVyLCBudWxsLCAiYmFyIik7Ci0vLwkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLnRyYW5zZm9ybWF0aW9uRXZlbnQsIHRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIsIG51bGwsICJCQVIiKTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGRMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZSkgewotCQkJCUNhY2hpbmdUcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMudGhpcy5ldmVudCA9IGU7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkVHJhbnNmb3JtYXRpb25MaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZSkgewotCQkJCUNhY2hpbmdUcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMudGhpcy50cmFuc2Zvcm1hdGlvbkV2ZW50ID0gZTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5RXZlbnQoUHJvcGVydHlDaGFuZ2VFdmVudCBlLCBPYmplY3Qgc291cmNlLCBPYmplY3Qgb2xkVmFsdWUsIE9iamVjdCBuZXdWYWx1ZSkgewotCQlhc3NlcnRFcXVhbHMoc291cmNlLCBlLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgZS5nZXRQcm9wZXJ0eU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscyhvbGRWYWx1ZSwgZS5nZXRPbGRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKG5ld1ZhbHVlLCBlLmdldE5ld1ZhbHVlKCkpOwotCX0KLQotCQotCXByaXZhdGUgY2xhc3MgUGVyc29uIGV4dGVuZHMgQWJzdHJhY3RNb2RlbCB7Ci0KLQkJcHJpdmF0ZSBTdHJpbmcgbmFtZTsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIE5BTUVfUFJPUEVSVFkgPSAibmFtZVByb3BlcnR5IjsKLQkJCi0JCXByaXZhdGUgU3RyaW5nIHBhcmVudE5hbWU7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBQQVJFTlRfTkFNRV9QUk9QRVJUWSA9ICJwYXJlbnROYW1lUHJvcGVydHkiOwotCQkKLQkJcHJpdmF0ZSBQZXJzb24gY2hpbGQ7Ci0JCQotCQlwdWJsaWMgUGVyc29uKFN0cmluZyBuYW1lLCBTdHJpbmcgcGFyZW50TmFtZSwgUGVyc29uIGNoaWxkKSB7Ci0JCQl0aGlzLm5hbWUgPSBuYW1lOwotCQkJdGhpcy5wYXJlbnROYW1lID0gcGFyZW50TmFtZTsKLQkJCXRoaXMuY2hpbGQgPSBjaGlsZDsKLQkJfQotCQkKLQkJcHVibGljIFN0cmluZyBnZXROYW1lKCkgewotCQkJcmV0dXJuIHRoaXMubmFtZTsKLQkJfQotCQkKLQkJcHVibGljIHZvaWQgc2V0TmFtZShTdHJpbmcgbmV3TmFtZSkgewotCQkJU3RyaW5nIG9sZE5hbWUgPSB0aGlzLm5hbWU7Ci0JCQl0aGlzLm5hbWUgPSBuZXdOYW1lOwotCQkJZmlyZVByb3BlcnR5Q2hhbmdlZChOQU1FX1BST1BFUlRZLCBvbGROYW1lLCBuZXdOYW1lKTsKLQkJfQotCQkKLQkJcHVibGljIFBlcnNvbiBnZXRQYXJlbnQoKSB7Ci0JCQlyZXR1cm4gbmV3IFBlcnNvbih0aGlzLnBhcmVudE5hbWUsIG51bGwsIHRoaXMpOwotCQl9Ci0JCQotCQlwdWJsaWMgU3RyaW5nIGdldFBhcmVudE5hbWUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5wYXJlbnROYW1lOwotCQl9Ci0JCQotCQlwdWJsaWMgdm9pZCBzZXRQYXJlbnROYW1lKFN0cmluZyBuZXdQYXJlbnROYW1lKSB7Ci0JCQlTdHJpbmcgb2xkUGFyZW50TmFtZSA9IHRoaXMucGFyZW50TmFtZTsKLQkJCXRoaXMucGFyZW50TmFtZSA9IG5ld1BhcmVudE5hbWU7Ci0JCQlmaXJlUHJvcGVydHlDaGFuZ2VkKFBBUkVOVF9OQU1FX1BST1BFUlRZLCBvbGRQYXJlbnROYW1lLCBuZXdQYXJlbnROYW1lKTsKLQkJfQotCQkKLQkJcHVibGljIFBlcnNvbiBnZXRDaGlsZCgpIHsKLQkJCXJldHVybiB0aGlzLmNoaWxkOwotCQl9Ci0JfQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Db2xsZWN0aW9uQXNwZWN0QWRhcHRlclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0NvbGxlY3Rpb25Bc3BlY3RBZGFwdGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggM2ZkNGRiOC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0NvbGxlY3Rpb25Bc3BlY3RBZGFwdGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDM2NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb25zOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkhhc2hCYWc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlJlYWRPbmx5SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uQXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuQ29sbGVjdGlvbkNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgQ29sbGVjdGlvbkFzcGVjdEFkYXB0ZXJUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIFRlc3RTdWJqZWN0IHN1YmplY3QxOwotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdFN1YmplY3Q+IHN1YmplY3RIb2xkZXIxOwotCXByaXZhdGUgTG9jYWxDb2xsZWN0aW9uQXNwZWN0QWRhcHRlciBhYTE7Ci0JcHJpdmF0ZSBDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZXZlbnQxOwotCXByaXZhdGUgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyMTsKLQlwcml2YXRlIFN0cmluZyBldmVudDFUeXBlOwotCi0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEFERCA9ICJhZGQiOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBSRU1PVkUgPSAicmVtb3ZlIjsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQ0hBTkdFID0gImNoYW5nZSI7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIENMRUFSID0gImNsZWFyIjsKLQotCXByaXZhdGUgVGVzdFN1YmplY3Qgc3ViamVjdDI7Ci0KLQlwdWJsaWMgQ29sbGVjdGlvbkFzcGVjdEFkYXB0ZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLnN1YmplY3QxID0gbmV3IFRlc3RTdWJqZWN0KCk7Ci0JCXRoaXMuc3ViamVjdDEuYWRkTmFtZXModGhpcy5zdWJqZWN0MU5hbWVzKCkpOwotCQl0aGlzLnN1YmplY3QxLmFkZERlc2NyaXB0aW9ucyh0aGlzLnN1YmplY3QxRGVzY3JpcHRpb25zKCkpOwotCQl0aGlzLnN1YmplY3RIb2xkZXIxID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxUZXN0U3ViamVjdD4odGhpcy5zdWJqZWN0MSk7Ci0JCXRoaXMuYWExID0gdGhpcy5idWlsZEFzcGVjdEFkYXB0ZXIodGhpcy5zdWJqZWN0SG9sZGVyMSk7Ci0JCXRoaXMubGlzdGVuZXIxID0gdGhpcy5idWlsZFZhbHVlQ2hhbmdlTGlzdGVuZXIxKCk7Ci0JCXRoaXMuYWExLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIHRoaXMubGlzdGVuZXIxKTsKLQkJdGhpcy5ldmVudDEgPSBudWxsOwotCQl0aGlzLmV2ZW50MVR5cGUgPSBudWxsOwotCi0JCXRoaXMuc3ViamVjdDIgPSBuZXcgVGVzdFN1YmplY3QoKTsKLQkJdGhpcy5zdWJqZWN0Mi5hZGROYW1lcyh0aGlzLnN1YmplY3QyTmFtZXMoKSk7Ci0JCXRoaXMuc3ViamVjdDIuYWRkRGVzY3JpcHRpb25zKHRoaXMuc3ViamVjdDJEZXNjcmlwdGlvbnMoKSk7Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uPFN0cmluZz4gc3ViamVjdDFOYW1lcygpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IHJlc3VsdCA9IG5ldyBIYXNoQmFnPFN0cmluZz4oKTsKLQkJcmVzdWx0LmFkZCgiZm9vIik7Ci0JCXJlc3VsdC5hZGQoImJhciIpOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCXByaXZhdGUgQ29sbGVjdGlvbjxTdHJpbmc+IHN1YmplY3QxRGVzY3JpcHRpb25zKCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gcmVzdWx0ID0gbmV3IEhhc2hCYWc8U3RyaW5nPigpOwotCQlyZXN1bHQuYWRkKCJ0aGlzLnN1YmplY3QxIGRlc2NyaXB0aW9uMSIpOwotCQlyZXN1bHQuYWRkKCJ0aGlzLnN1YmplY3QxIGRlc2NyaXB0aW9uMiIpOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCXByaXZhdGUgQ29sbGVjdGlvbjxTdHJpbmc+IHN1YmplY3QyTmFtZXMoKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiByZXN1bHQgPSBuZXcgSGFzaEJhZzxTdHJpbmc+KCk7Ci0JCXJlc3VsdC5hZGQoImJheiIpOwotCQlyZXN1bHQuYWRkKCJiYW0iKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb248U3RyaW5nPiBzdWJqZWN0MkRlc2NyaXB0aW9ucygpIHsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IHJlc3VsdCA9IG5ldyBIYXNoQmFnPFN0cmluZz4oKTsKLQkJcmVzdWx0LmFkZCgidGhpcy5zdWJqZWN0MiBkZXNjcmlwdGlvbjEiKTsKLQkJcmVzdWx0LmFkZCgidGhpcy5zdWJqZWN0MiBkZXNjcmlwdGlvbjIiKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwcml2YXRlIExvY2FsQ29sbGVjdGlvbkFzcGVjdEFkYXB0ZXIgYnVpbGRBc3BlY3RBZGFwdGVyKFByb3BlcnR5VmFsdWVNb2RlbDxUZXN0U3ViamVjdD4gc3ViamVjdEhvbGRlcikgewotCQlyZXR1cm4gbmV3IExvY2FsQ29sbGVjdGlvbkFzcGVjdEFkYXB0ZXIoc3ViamVjdEhvbGRlcik7Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgYnVpbGRWYWx1ZUNoYW5nZUxpc3RlbmVyMSgpIHsKLQkJcmV0dXJuIG5ldyBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7Ci0JCQkJQ29sbGVjdGlvbkFzcGVjdEFkYXB0ZXJUZXN0cy50aGlzLnZhbHVlMUNoYW5nZWQoZSwgQUREKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQkJCUNvbGxlY3Rpb25Bc3BlY3RBZGFwdGVyVGVzdHMudGhpcy52YWx1ZTFDaGFuZ2VkKGUsIFJFTU9WRSk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBjb2xsZWN0aW9uQ2xlYXJlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQkJCUNvbGxlY3Rpb25Bc3BlY3RBZGFwdGVyVGVzdHMudGhpcy52YWx1ZTFDaGFuZ2VkKGUsIENMRUFSKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGNvbGxlY3Rpb25DaGFuZ2VkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7Ci0JCQkJQ29sbGVjdGlvbkFzcGVjdEFkYXB0ZXJUZXN0cy50aGlzLnZhbHVlMUNoYW5nZWQoZSwgQ0hBTkdFKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQl2b2lkIHZhbHVlMUNoYW5nZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUsIFN0cmluZyBldmVudFR5cGUpIHsKLQkJdGhpcy5ldmVudDEgPSBlOwotCQl0aGlzLmV2ZW50MVR5cGUgPSBldmVudFR5cGU7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTdWJqZWN0SG9sZGVyKCkgewotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0MU5hbWVzKCksIENvbGxlY3Rpb25Ub29scy5iYWcodGhpcy5hYTEuaXRlcmF0b3IoKSkpOwotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQxKTsKLQotCQl0aGlzLnN1YmplY3RIb2xkZXIxLnNldFZhbHVlKHRoaXMuc3ViamVjdDIpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQxKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuZXZlbnQxVHlwZSwgQ0hBTkdFKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYWExLCB0aGlzLmV2ZW50MS5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIHRoaXMuZXZlbnQxLmdldENvbGxlY3Rpb25OYW1lKCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmV2ZW50MS5pdGVtcygpLmhhc05leHQoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnN1YmplY3QyTmFtZXMoKSwgQ29sbGVjdGlvblRvb2xzLmJhZyh0aGlzLmFhMS5pdGVyYXRvcigpKSk7Ci0JCQotCQl0aGlzLmV2ZW50MSA9IG51bGw7Ci0JCXRoaXMuZXZlbnQxVHlwZSA9IG51bGw7Ci0JCXRoaXMuc3ViamVjdEhvbGRlcjEuc2V0VmFsdWUobnVsbCk7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5ldmVudDFUeXBlLCBDSEFOR0UpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hYTEsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgdGhpcy5ldmVudDEuZ2V0Q29sbGVjdGlvbk5hbWUoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuZXZlbnQxLml0ZW1zKCkuaGFzTmV4dCgpKTsKLQkJYXNzZXJ0RmFsc2UoKHRoaXMuYWExLml0ZXJhdG9yKCkpLmhhc05leHQoKSk7Ci0JCQotCQl0aGlzLmV2ZW50MSA9IG51bGw7Ci0JCXRoaXMuZXZlbnQxVHlwZSA9IG51bGw7Ci0JCXRoaXMuc3ViamVjdEhvbGRlcjEuc2V0VmFsdWUodGhpcy5zdWJqZWN0MSk7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5ldmVudDFUeXBlLCBDSEFOR0UpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hYTEsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgdGhpcy5ldmVudDEuZ2V0Q29sbGVjdGlvbk5hbWUoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuZXZlbnQxLml0ZW1zKCkuaGFzTmV4dCgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLCBDb2xsZWN0aW9uVG9vbHMuYmFnKHRoaXMuYWExLml0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkKCkgewotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0MU5hbWVzKCksIENvbGxlY3Rpb25Ub29scy5iYWcodGhpcy5hYTEuaXRlcmF0b3IoKSkpOwotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQxKTsKLQotCQl0aGlzLnN1YmplY3QxLmFkZE5hbWUoImphbSIpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQxKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuZXZlbnQxVHlwZSwgQUREKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYWExLCB0aGlzLmV2ZW50MS5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIHRoaXMuZXZlbnQxLmdldENvbGxlY3Rpb25OYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoImphbSIsIHRoaXMuZXZlbnQxLml0ZW1zKCkubmV4dCgpKTsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IG5hbWVzUGx1cyA9IHRoaXMuc3ViamVjdDFOYW1lcygpOwotCQluYW1lc1BsdXMuYWRkKCJqYW0iKTsKLQkJYXNzZXJ0RXF1YWxzKG5hbWVzUGx1cywgQ29sbGVjdGlvblRvb2xzLmJhZyh0aGlzLmFhMS5pdGVyYXRvcigpKSk7Ci0KLQkJdGhpcy5ldmVudDEgPSBudWxsOwotCQl0aGlzLmV2ZW50MVR5cGUgPSBudWxsOwotCQl0aGlzLmFhMS5hZGRBbGwoQ29sbGVjdGlvbnMuc2luZ2xldG9uKCJqYXoiKSk7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5ldmVudDFUeXBlLCBBREQpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hYTEsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgdGhpcy5ldmVudDEuZ2V0Q29sbGVjdGlvbk5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygiamF6IiwgdGhpcy5ldmVudDEuaXRlbXMoKS5uZXh0KCkpOwotCQluYW1lc1BsdXMuYWRkKCJqYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKG5hbWVzUGx1cywgQ29sbGVjdGlvblRvb2xzLmJhZyh0aGlzLmFhMS5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLCBDb2xsZWN0aW9uVG9vbHMuYmFnKHRoaXMuYWExLml0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50MSk7Ci0KLQkJdGhpcy5zdWJqZWN0MS5yZW1vdmVOYW1lKCJmb28iKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmV2ZW50MSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmV2ZW50MVR5cGUsIFJFTU9WRSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmFhMSwgdGhpcy5ldmVudDEuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCB0aGlzLmV2ZW50MS5nZXRDb2xsZWN0aW9uTmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCB0aGlzLmV2ZW50MS5pdGVtcygpLm5leHQoKSk7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBuYW1lc01pbnVzID0gdGhpcy5zdWJqZWN0MU5hbWVzKCk7Ci0JCW5hbWVzTWludXMucmVtb3ZlKCJmb28iKTsKLQkJYXNzZXJ0RXF1YWxzKG5hbWVzTWludXMsIENvbGxlY3Rpb25Ub29scy5iYWcodGhpcy5hYTEuaXRlcmF0b3IoKSkpOwotCi0JCXRoaXMuZXZlbnQxID0gbnVsbDsKLQkJdGhpcy5ldmVudDFUeXBlID0gbnVsbDsKLQkJdGhpcy5hYTEucmVtb3ZlQWxsKENvbGxlY3Rpb25zLnNpbmdsZXRvbigiYmFyIikpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQxKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuZXZlbnQxVHlwZSwgUkVNT1ZFKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYWExLCB0aGlzLmV2ZW50MS5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIHRoaXMuZXZlbnQxLmdldENvbGxlY3Rpb25OYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoImJhciIsIHRoaXMuZXZlbnQxLml0ZW1zKCkubmV4dCgpKTsKLQkJbmFtZXNNaW51cy5yZW1vdmUoImJhciIpOwotCQlhc3NlcnRFcXVhbHMobmFtZXNNaW51cywgQ29sbGVjdGlvblRvb2xzLmJhZyh0aGlzLmFhMS5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25DaGFuZ2UoKSB7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnN1YmplY3QxTmFtZXMoKSwgQ29sbGVjdGlvblRvb2xzLmJhZyh0aGlzLmFhMS5pdGVyYXRvcigpKSk7Ci0JCWFzc2VydE51bGwodGhpcy5ldmVudDEpOwotCi0JCXRoaXMuc3ViamVjdDEuYWRkVHdvTmFtZXMoImphbSIsICJqYXoiKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmV2ZW50MSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmV2ZW50MVR5cGUsIENIQU5HRSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmFhMSwgdGhpcy5ldmVudDEuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCB0aGlzLmV2ZW50MS5nZXRDb2xsZWN0aW9uTmFtZSgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5ldmVudDEuaXRlbXMoKS5oYXNOZXh0KCkpOwotCQlDb2xsZWN0aW9uPFN0cmluZz4gbmFtZXNQbHVzMiA9IHRoaXMuc3ViamVjdDFOYW1lcygpOwotCQluYW1lc1BsdXMyLmFkZCgiamFtIik7Ci0JCW5hbWVzUGx1czIuYWRkKCJqYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKG5hbWVzUGx1czIsIENvbGxlY3Rpb25Ub29scy5iYWcodGhpcy5hYTEuaXRlcmF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVyYXRvcigpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLCBDb2xsZWN0aW9uVG9vbHMuYmFnKHRoaXMuc3ViamVjdDEubmFtZXMoKSkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0MU5hbWVzKCksIENvbGxlY3Rpb25Ub29scy5iYWcodGhpcy5hYTEuaXRlcmF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTaXplKCkgewotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0MU5hbWVzKCkuc2l6ZSgpLCBDb2xsZWN0aW9uVG9vbHMuc2l6ZSh0aGlzLnN1YmplY3QxLm5hbWVzKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLnNpemUoKSwgQ29sbGVjdGlvblRvb2xzLnNpemUodGhpcy5hYTEuaXRlcmF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNMaXN0ZW5lcnMoKSB7Ci0JCWFzc2VydFRydWUodGhpcy5hYTEuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnN1YmplY3QxLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoVGVzdFN1YmplY3QuTkFNRVNfQ09MTEVDVElPTikpOwotCQl0aGlzLmFhMS5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCB0aGlzLmxpc3RlbmVyMSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc3ViamVjdDEuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhUZXN0U3ViamVjdC5OQU1FU19DT0xMRUNUSU9OKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYWExLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTKSk7Ci0KLQkJQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyMiA9IHRoaXMuYnVpbGRWYWx1ZUNoYW5nZUxpc3RlbmVyMSgpOwotCQl0aGlzLmFhMS5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIyKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmFhMS5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUykpOwotCQlhc3NlcnRUcnVlKHRoaXMuc3ViamVjdDEuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhUZXN0U3ViamVjdC5OQU1FU19DT0xMRUNUSU9OKSk7Ci0JCXRoaXMuYWExLnJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcjIpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnN1YmplY3QxLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoVGVzdFN1YmplY3QuTkFNRVNfQ09MTEVDVElPTikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmFhMS5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUykpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbm5lciBjbGFzcyAqKioqKioqKioqCi0JCi0JcHJpdmF0ZSBjbGFzcyBUZXN0U3ViamVjdCBleHRlbmRzIEFic3RyYWN0TW9kZWwgewotCQlwcml2YXRlIENvbGxlY3Rpb248U3RyaW5nPiBuYW1lczsKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgTkFNRVNfQ09MTEVDVElPTiA9ICJuYW1lcyI7Ci0JCXByaXZhdGUgQ29sbGVjdGlvbjxTdHJpbmc+IGRlc2NyaXB0aW9uczsKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgREVTQ1JJUFRJT05TX0NPTExFQ1RJT04gPSAiZGVzY3JpcHRpb25zIjsKLQkKLQkJcHVibGljIFRlc3RTdWJqZWN0KCkgewotCQkJdGhpcy5uYW1lcyA9IG5ldyBIYXNoQmFnPFN0cmluZz4oKTsKLQkJCXRoaXMuZGVzY3JpcHRpb25zID0gbmV3IEhhc2hCYWc8U3RyaW5nPigpOwotCQl9Ci0JCXB1YmxpYyBJdGVyYXRvcjxTdHJpbmc+IG5hbWVzKCkgewotCQkJcmV0dXJuIG5ldyBSZWFkT25seUl0ZXJhdG9yPFN0cmluZz4odGhpcy5uYW1lcyk7Ci0JCX0KLQkJcHVibGljIHZvaWQgYWRkTmFtZShTdHJpbmcgbmFtZSkgewotCQkJaWYgKHRoaXMubmFtZXMuYWRkKG5hbWUpKSB7Ci0JCQkJdGhpcy5maXJlSXRlbUFkZGVkKE5BTUVTX0NPTExFQ1RJT04sIG5hbWUpOwotCQkJfQotCQl9Ci0JCXB1YmxpYyB2b2lkIGFkZE5hbWVzKEl0ZXJhdG9yPFN0cmluZz4gbmV3TmFtZXMpIHsKLQkJCXdoaWxlIChuZXdOYW1lcy5oYXNOZXh0KCkpIHsKLQkJCQl0aGlzLmFkZE5hbWUobmV3TmFtZXMubmV4dCgpKTsKLQkJCX0KLQkJfQotCQlwdWJsaWMgdm9pZCBhZGROYW1lcyhDb2xsZWN0aW9uPFN0cmluZz4gbmV3TmFtZXMpIHsKLQkJCXRoaXMuYWRkTmFtZXMobmV3TmFtZXMuaXRlcmF0b3IoKSk7Ci0JCX0KLQkJcHVibGljIHZvaWQgYWRkVHdvTmFtZXMoU3RyaW5nIG5hbWUxLCBTdHJpbmcgbmFtZTIpIHsKLQkJCWlmICh0aGlzLm5hbWVzLmFkZChuYW1lMSkgfCB0aGlzLm5hbWVzLmFkZChuYW1lMikpIHsKLQkJCQl0aGlzLmZpcmVDb2xsZWN0aW9uQ2hhbmdlZChOQU1FU19DT0xMRUNUSU9OKTsKLQkJCX0KLQkJfQotCQlwdWJsaWMgdm9pZCByZW1vdmVOYW1lKFN0cmluZyBuYW1lKSB7Ci0JCQlpZiAodGhpcy5uYW1lcy5yZW1vdmUobmFtZSkpIHsKLQkJCQl0aGlzLmZpcmVJdGVtUmVtb3ZlZChOQU1FU19DT0xMRUNUSU9OLCBuYW1lKTsKLQkJCX0KLQkJfQotCQlwdWJsaWMgSXRlcmF0b3I8U3RyaW5nPiBkZXNjcmlwdGlvbnMoKSB7Ci0JCQlyZXR1cm4gbmV3IFJlYWRPbmx5SXRlcmF0b3I8U3RyaW5nPih0aGlzLmRlc2NyaXB0aW9ucyk7Ci0JCX0KLQkJcHVibGljIHZvaWQgYWRkRGVzY3JpcHRpb24oU3RyaW5nIGRlc2NyaXB0aW9uKSB7Ci0JCQlpZiAodGhpcy5kZXNjcmlwdGlvbnMuYWRkKGRlc2NyaXB0aW9uKSkgewotCQkJCXRoaXMuZmlyZUl0ZW1BZGRlZChERVNDUklQVElPTlNfQ09MTEVDVElPTiwgZGVzY3JpcHRpb24pOwotCQkJfQotCQl9Ci0JCXB1YmxpYyB2b2lkIGFkZERlc2NyaXB0aW9ucyhJdGVyYXRvcjxTdHJpbmc+IG5ld0Rlc2NyaXB0aW9ucykgewotCQkJd2hpbGUgKG5ld0Rlc2NyaXB0aW9ucy5oYXNOZXh0KCkpIHsKLQkJCQl0aGlzLmFkZERlc2NyaXB0aW9uKG5ld0Rlc2NyaXB0aW9ucy5uZXh0KCkpOwotCQkJfQotCQl9Ci0JCXB1YmxpYyB2b2lkIGFkZERlc2NyaXB0aW9ucyhDb2xsZWN0aW9uPFN0cmluZz4gbmV3RGVzY3JpcHRpb25zKSB7Ci0JCQl0aGlzLmFkZERlc2NyaXB0aW9ucyhuZXdEZXNjcmlwdGlvbnMuaXRlcmF0b3IoKSk7Ci0JCX0KLQkJcHVibGljIHZvaWQgcmVtb3ZlRGVzY3JpcHRpb24oU3RyaW5nIGRlc2NyaXB0aW9uKSB7Ci0JCQlpZiAodGhpcy5kZXNjcmlwdGlvbnMucmVtb3ZlKGRlc2NyaXB0aW9uKSkgewotCQkJCXRoaXMuZmlyZUl0ZW1SZW1vdmVkKERFU0NSSVBUSU9OU19DT0xMRUNUSU9OLCBkZXNjcmlwdGlvbik7Ci0JCQl9Ci0JCX0KLQl9Ci0KLQkvLyB0aGlzIGlzIG5vdCBhIHR5cGljYWwgYXNwZWN0IGFkYXB0ZXIgLSB0aGUgdmFsdWUgaXMgZGV0ZXJtaW5lZCBieSB0aGUgYXNwZWN0IG5hbWUKLQlwcml2YXRlIGNsYXNzIExvY2FsQ29sbGVjdGlvbkFzcGVjdEFkYXB0ZXIgZXh0ZW5kcyBDb2xsZWN0aW9uQXNwZWN0QWRhcHRlcjxUZXN0U3ViamVjdCwgU3RyaW5nPiB7Ci0KLQkJTG9jYWxDb2xsZWN0aW9uQXNwZWN0QWRhcHRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdFN1YmplY3Q+IHN1YmplY3RIb2xkZXIpIHsKLQkJCXN1cGVyKHN1YmplY3RIb2xkZXIsIFRlc3RTdWJqZWN0Lk5BTUVTX0NPTExFQ1RJT04pOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCBJdGVyYXRvcjxTdHJpbmc+IGl0ZXJhdG9yXygpIHsKLQkJCWlmICh0aGlzLmNvbGxlY3Rpb25OYW1lc1swXSA9PSBUZXN0U3ViamVjdC5OQU1FU19DT0xMRUNUSU9OKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5uYW1lcygpOwotCQkJfQotCQkJaWYgKHRoaXMuY29sbGVjdGlvbk5hbWVzWzBdID09IFRlc3RTdWJqZWN0LkRFU0NSSVBUSU9OU19DT0xMRUNUSU9OKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5kZXNjcmlwdGlvbnMoKTsKLQkJCX0KLQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oImludmFsaWQgYXNwZWN0IG5hbWU6ICIgKyB0aGlzLmNvbGxlY3Rpb25OYW1lc1swXSk7Ci0JCX0KLQotCQlwdWJsaWMgdm9pZCBhZGQoU3RyaW5nIGl0ZW0pIHsKLQkJCWlmICh0aGlzLmNvbGxlY3Rpb25OYW1lc1swXSA9PSBUZXN0U3ViamVjdC5OQU1FU19DT0xMRUNUSU9OKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LmFkZE5hbWUoaXRlbSk7Ci0JCQl9IGVsc2UgaWYgKHRoaXMuY29sbGVjdGlvbk5hbWVzWzBdID09IFRlc3RTdWJqZWN0LkRFU0NSSVBUSU9OU19DT0xMRUNUSU9OKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LmFkZERlc2NyaXB0aW9uKGl0ZW0pOwotCQkJfSBlbHNlIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJpbnZhbGlkIGFzcGVjdCBuYW1lOiAiICsgdGhpcy5jb2xsZWN0aW9uTmFtZXNbMF0pOwotCQkJfQotCQl9Ci0KLQkJcHVibGljIHZvaWQgYWRkQWxsKENvbGxlY3Rpb248U3RyaW5nPiBpdGVtcykgewotCQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IGl0ZW1zLml0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJCXRoaXMuYWRkKHN0cmVhbS5uZXh0KCkpOwotCQkJfQotCQl9Ci0KLQkJcHVibGljIHZvaWQgcmVtb3ZlKE9iamVjdCBpdGVtKSB7Ci0JCQlpZiAodGhpcy5jb2xsZWN0aW9uTmFtZXNbMF0gPT0gVGVzdFN1YmplY3QuTkFNRVNfQ09MTEVDVElPTikgewotCQkJCXRoaXMuc3ViamVjdC5yZW1vdmVOYW1lKChTdHJpbmcpIGl0ZW0pOwotCQkJfSBlbHNlIGlmICh0aGlzLmNvbGxlY3Rpb25OYW1lc1swXSA9PSBUZXN0U3ViamVjdC5ERVNDUklQVElPTlNfQ09MTEVDVElPTikgewotCQkJCXRoaXMuc3ViamVjdC5yZW1vdmVEZXNjcmlwdGlvbigoU3RyaW5nKSBpdGVtKTsKLQkJCX0gZWxzZSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigiaW52YWxpZCBhc3BlY3QgbmFtZTogIiArIHRoaXMuY29sbGVjdGlvbk5hbWVzWzBdKTsKLQkJCX0KLQkJfQotCi0JCXB1YmxpYyB2b2lkIHJlbW92ZUFsbChDb2xsZWN0aW9uPFN0cmluZz4gaXRlbXMpIHsKLQkJCWZvciAoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSBpdGVtcy5pdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCQl0aGlzLnJlbW92ZShzdHJlYW0ubmV4dCgpKTsKLQkJCX0KLQkJfQotCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0NvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Db2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMWM3YWM4Mi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0NvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjM0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZheC5zd2luZy5KTGlzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQmFnOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5IYXNoQmFnOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5MaXN0TW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50Lkxpc3RDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5MaXN0Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBhZGFwdGVyOwotCXByaXZhdGUgU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8U3RyaW5nPiB3cmFwcGVkQ29sbGVjdGlvbkhvbGRlcjsKLQlwcml2YXRlIENvbGxlY3Rpb248U3RyaW5nPiB3cmFwcGVkQ29sbGVjdGlvbjsKLQotCXB1YmxpYyBDb2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbiA9IG5ldyBIYXNoQmFnPFN0cmluZz4oKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlciA9IG5ldyBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+KHRoaXMud3JhcHBlZENvbGxlY3Rpb24pOwotCQl0aGlzLmFkYXB0ZXIgPSBuZXcgQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxTdHJpbmc+KHRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SXRlcmF0b3IoKSB7Ci0JCXRoaXMuYWRhcHRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIG5ldyBUZXN0TGlzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBlKSB7LyogT0sgKi99Ci0JCX0pOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiZm9vIik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJiYXIiKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImJheiIpOwotCQlDb2xsZWN0aW9uPFN0cmluZz4gYWRhcHRlckNvbGxlY3Rpb24gPSB0aGlzLmFkYXB0ZXJDb2xsZWN0aW9uKCk7Ci0JCWFzc2VydEVxdWFscygzLCBhZGFwdGVyQ29sbGVjdGlvbi5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy53cmFwcGVkQ29sbGVjdGlvbiwgYWRhcHRlckNvbGxlY3Rpb24pOwotCX0KLQotCXByaXZhdGUgQ29sbGVjdGlvbjxTdHJpbmc+IGFkYXB0ZXJDb2xsZWN0aW9uKCkgewotCQlyZXR1cm4gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24odGhpcy5hZGFwdGVyLml0ZXJhdG9yKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTdGFsZVZhbHVlKCkgewotCQlMaXN0Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdExpc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZSkgey8qIE9LICovfQotCQl9OwotCQl0aGlzLmFkYXB0ZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCBsaXN0ZW5lcik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJmb28iKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImJhciIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiYmF6Iik7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBhZGFwdGVyQ29sbGVjdGlvbiA9IHRoaXMuYWRhcHRlckNvbGxlY3Rpb24oKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGFkYXB0ZXJDb2xsZWN0aW9uLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLndyYXBwZWRDb2xsZWN0aW9uLCBhZGFwdGVyQ29sbGVjdGlvbik7Ci0KLQkJdGhpcy5hZGFwdGVyLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgbGlzdGVuZXIpOwotCQlhZGFwdGVyQ29sbGVjdGlvbiA9IHRoaXMuYWRhcHRlckNvbGxlY3Rpb24oKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGFkYXB0ZXJDb2xsZWN0aW9uLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhuZXcgSGFzaEJhZzxTdHJpbmc+KCksIGFkYXB0ZXJDb2xsZWN0aW9uKTsKLQotCQl0aGlzLmFkYXB0ZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCBsaXN0ZW5lcik7Ci0JCWFkYXB0ZXJDb2xsZWN0aW9uID0gdGhpcy5hZGFwdGVyQ29sbGVjdGlvbigpOwotCQlhc3NlcnRFcXVhbHMoMywgYWRhcHRlckNvbGxlY3Rpb24uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMud3JhcHBlZENvbGxlY3Rpb24sIGFkYXB0ZXJDb2xsZWN0aW9uKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkKCkgewotCQlMaXN0PFN0cmluZz4gc3luY2hMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KHRoaXMuYWRhcHRlcik7Ci0JCUJhZzxTdHJpbmc+IHN5bmNoQ29sbGVjdGlvbiA9IG5ldyBDb29yZGluYXRlZEJhZzxTdHJpbmc+KHRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiZm9vIik7Ci0JCWFzc2VydFRydWUodGhpcy53cmFwcGVkQ29sbGVjdGlvbi5jb250YWlucygiZm9vIikpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiYmFyIik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJiYXoiKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImpvbyIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiamFyIik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJqYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHRoaXMud3JhcHBlZENvbGxlY3Rpb24uc2l6ZSgpKTsKLQotCQlDb2xsZWN0aW9uPFN0cmluZz4gYWRhcHRlckNvbGxlY3Rpb24gPSB0aGlzLmFkYXB0ZXJDb2xsZWN0aW9uKCk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLndyYXBwZWRDb2xsZWN0aW9uLCBhZGFwdGVyQ29sbGVjdGlvbik7Ci0JCWFzc2VydEVxdWFscyh0aGlzLndyYXBwZWRDb2xsZWN0aW9uLCBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbihzeW5jaExpc3QuaXRlcmF0b3IoKSkpOwotCQlhc3NlcnRFcXVhbHModGhpcy53cmFwcGVkQ29sbGVjdGlvbiwgc3luY2hDb2xsZWN0aW9uKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlKCkgewotCQlMaXN0PFN0cmluZz4gc3luY2hMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KHRoaXMuYWRhcHRlcik7Ci0JCUJhZzxTdHJpbmc+IHN5bmNoQ29sbGVjdGlvbiA9IG5ldyBDb29yZGluYXRlZEJhZzxTdHJpbmc+KHRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiZm9vIik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJiYXIiKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImJheiIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiam9vIik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJqYXIiKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImpheiIpOwotCQlhc3NlcnRUcnVlKHRoaXMud3JhcHBlZENvbGxlY3Rpb24uY29udGFpbnMoImpheiIpKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5yZW1vdmUoImpheiIpOwotCQlhc3NlcnRGYWxzZSh0aGlzLndyYXBwZWRDb2xsZWN0aW9uLmNvbnRhaW5zKCJqYXoiKSk7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlKCJmb28iKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy53cmFwcGVkQ29sbGVjdGlvbi5jb250YWlucygiZm9vIikpOwotCQlhc3NlcnRFcXVhbHMoNCwgdGhpcy53cmFwcGVkQ29sbGVjdGlvbi5zaXplKCkpOwotCi0JCUNvbGxlY3Rpb248U3RyaW5nPiBhZGFwdGVyQ29sbGVjdGlvbiA9IHRoaXMuYWRhcHRlckNvbGxlY3Rpb24oKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMud3JhcHBlZENvbGxlY3Rpb24sIGFkYXB0ZXJDb2xsZWN0aW9uKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMud3JhcHBlZENvbGxlY3Rpb24sIENvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKHN5bmNoTGlzdC5pdGVyYXRvcigpKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLndyYXBwZWRDb2xsZWN0aW9uLCBzeW5jaENvbGxlY3Rpb24pOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0U3luY2goKSB7Ci0JCXRoaXMuYWRhcHRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIG5ldyBUZXN0TGlzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBlKSB7LyogT0sgKi99Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZSkgey8qIE9LICovfQotCQl9KTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImZvbyIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiYmFyIik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJiYXoiKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImpvbyIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiamFyIik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJqYXoiKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5yZW1vdmUoImpheiIpOwotCQlhc3NlcnRGYWxzZSh0aGlzLndyYXBwZWRDb2xsZWN0aW9uLmNvbnRhaW5zKCJqYXoiKSk7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlKCJmb28iKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy53cmFwcGVkQ29sbGVjdGlvbi5jb250YWlucygiZm9vIikpOwotCQlhc3NlcnRFcXVhbHMoNCwgdGhpcy53cmFwcGVkQ29sbGVjdGlvbi5zaXplKCkpOwotCi0JCUNvbGxlY3Rpb248U3RyaW5nPiBhZGFwdGVyQ29sbGVjdGlvbiA9IHRoaXMuYWRhcHRlckNvbGxlY3Rpb24oKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMud3JhcHBlZENvbGxlY3Rpb24sIGFkYXB0ZXJDb2xsZWN0aW9uKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgewotCQlhc3NlcnRGYWxzZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5hZGFwdGVyKTsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQl0aGlzLmFkYXB0ZXIucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCBzeW5jaExpc3QpOwotCQlhc3NlcnRGYWxzZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQl0aGlzLmFkYXB0ZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKHN5bmNoTGlzdCk7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmFkYXB0ZXIpLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJdGhpcy5hZGFwdGVyLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihzeW5jaExpc3QpOwotCQlhc3NlcnRGYWxzZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb2xsZWN0aW9uQ2hhbmdlZFRvRW1wdHkoKSB7Ci0JCXRoaXMuYWRhcHRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIG5ldyBUZXN0TGlzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBlKSB7LyogT0sgKi99Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZSkgey8qIE9LICovfQotCQl9KTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImZvbyIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiYmFyIik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJiYXoiKTsKLQkJSkxpc3Qgakxpc3QgPSBuZXcgSkxpc3QobmV3IExpc3RNb2RlbEFkYXB0ZXIodGhpcy5hZGFwdGVyKSk7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuc2V0Q29sbGVjdGlvbihuZXcgSGFzaEJhZzxTdHJpbmc+KCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgakxpc3QuZ2V0TW9kZWwoKS5nZXRTaXplKCkpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0Q29sbGVjdGlvbkNoYW5nZWRGcm9tRW1wdHkoKSB7Ci0JCXRoaXMuYWRhcHRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIG5ldyBUZXN0TGlzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBlKSB7LyogT0sgKi99Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZSkgey8qIE9LICovfQotCQl9KTsKLQkJSkxpc3Qgakxpc3QgPSBuZXcgSkxpc3QobmV3IExpc3RNb2RlbEFkYXB0ZXIodGhpcy5hZGFwdGVyKSk7Ci0JCQotCQlIYXNoQmFnPFN0cmluZz4gYmFnID0gbmV3IEhhc2hCYWc8U3RyaW5nPigpOwotCQliYWcuYWRkKCJmb28iKTsKLQkJYmFnLmFkZCgiYmFyIik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuc2V0Q29sbGVjdGlvbihiYWcpOwotCQlhc3NlcnRFcXVhbHMoMiwgakxpc3QuZ2V0TW9kZWwoKS5nZXRTaXplKCkpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0Q29sbGVjdGlvbkNoYW5nZWRGcm9tRW1wdHlUb0VtcHR5KCkgewotCQl0aGlzLmFkYXB0ZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCBuZXcgVGVzdExpc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZSkgey8qIE9LICovfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpdGVtc1JlbW92ZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsvKiBPSyAqL30KLQkJfSk7Ci0JCUpMaXN0IGpMaXN0ID0gbmV3IEpMaXN0KG5ldyBMaXN0TW9kZWxBZGFwdGVyKHRoaXMuYWRhcHRlcikpOwotCQkKLQkJSGFzaEJhZzxTdHJpbmc+IGJhZyA9IG5ldyBIYXNoQmFnPFN0cmluZz4oKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5zZXRDb2xsZWN0aW9uKGJhZyk7Ci0JCWFzc2VydEVxdWFscygwLCBqTGlzdC5nZXRNb2RlbCgpLmdldFNpemUoKSk7Ci0JfQotCi0KLQljbGFzcyBUZXN0TGlzdENoYW5nZUxpc3RlbmVyIGltcGxlbWVudHMgTGlzdENoYW5nZUxpc3RlbmVyIHsKLQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJCWZhaWwoInVuZXhwZWN0ZWQgZXZlbnQiKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBpdGVtc01vdmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQlmYWlsKCJ1bmV4cGVjdGVkIGV2ZW50Iik7Ci0JCX0KLQkJcHVibGljIHZvaWQgbGlzdENsZWFyZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJCWZhaWwoInVuZXhwZWN0ZWQgZXZlbnQiKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBsaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0NvbGxlY3Rpb25Qcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ29sbGVjdGlvblByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmMGJhOWFjLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ29sbGVjdGlvblByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjM0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuQ29sbGVjdGlvblByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5UZXN0VG9vbHM7Ci0KLXB1YmxpYyBjbGFzcyBDb2xsZWN0aW9uUHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYWRhcHRlcjsKLQlwcml2YXRlIFNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4gd3JhcHBlZENvbGxlY3Rpb25Ib2xkZXI7Ci0JUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudDsKLQotCXB1YmxpYyBDb2xsZWN0aW9uUHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIgPSBuZXcgU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8U3RyaW5nPigpOwotCQl0aGlzLmFkYXB0ZXIgPSBuZXcgTG9jYWxBZGFwdGVyKHRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIsICI2NjYiKTsKLQkJdGhpcy5ldmVudCA9IG51bGw7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXByaXZhdGUgYm9vbGVhbiBib29sZWFuVmFsdWUoKSB7Ci0JCXJldHVybiB0aGlzLmFkYXB0ZXIuZ2V0VmFsdWUoKS5ib29sZWFuVmFsdWUoKTsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb248U3RyaW5nPiB3cmFwcGVkQ29sbGVjdGlvbigpIHsKLQkJcmV0dXJuIENvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKHRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuaXRlcmF0b3IoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFZhbHVlKCkgewotCQl0aGlzLmFkYXB0ZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIG5ldyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZSkgey8qIE9LICovfQotCQl9KTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5ib29sZWFuVmFsdWUoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMud3JhcHBlZENvbGxlY3Rpb24oKS5jb250YWlucygiNjY2IikpOwotCi0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCIxMTEiKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5ib29sZWFuVmFsdWUoKSk7Ci0KLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoIjIyMiIpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJvb2xlYW5WYWx1ZSgpKTsKLQotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiNjY2Iik7Ci0JCWFzc2VydFRydWUodGhpcy5ib29sZWFuVmFsdWUoKSk7Ci0JCWFzc2VydFRydWUodGhpcy53cmFwcGVkQ29sbGVjdGlvbigpLmNvbnRhaW5zKCI2NjYiKSk7Ci0KLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5yZW1vdmUoIjY2NiIpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJvb2xlYW5WYWx1ZSgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy53cmFwcGVkQ29sbGVjdGlvbigpLmNvbnRhaW5zKCI2NjYiKSk7Ci0KLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoIjY2NiIpOwotCQlhc3NlcnRUcnVlKHRoaXMuYm9vbGVhblZhbHVlKCkpOwotCQlhc3NlcnRUcnVlKHRoaXMud3JhcHBlZENvbGxlY3Rpb24oKS5jb250YWlucygiNjY2IikpOwotCi0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuY2xlYXIoKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5ib29sZWFuVmFsdWUoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMud3JhcHBlZENvbGxlY3Rpb24oKS5jb250YWlucygiNjY2IikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRWYWx1ZSgpIHsKLQkJdGhpcy5hZGFwdGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsvKiBPSyAqL30KLQkJfSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYm9vbGVhblZhbHVlKCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLndyYXBwZWRDb2xsZWN0aW9uKCkuY29udGFpbnMoIjY2NiIpKTsKLQotCQl0aGlzLmFkYXB0ZXIuc2V0VmFsdWUoQm9vbGVhbi5UUlVFKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJvb2xlYW5WYWx1ZSgpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLndyYXBwZWRDb2xsZWN0aW9uKCkuY29udGFpbnMoIjY2NiIpKTsKLQotCQl0aGlzLmFkYXB0ZXIuc2V0VmFsdWUoQm9vbGVhbi5GQUxTRSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYm9vbGVhblZhbHVlKCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLndyYXBwZWRDb2xsZWN0aW9uKCkuY29udGFpbnMoIjY2NiIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RXZlbnRGaXJpbmcoKSB7Ci0JCXRoaXMuYWRhcHRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJQ29sbGVjdGlvblByb3BlcnR5VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy50aGlzLmV2ZW50ID0gZTsKLQkJCX0KLQkJfSk7Ci0JCWFzc2VydE51bGwodGhpcy5ldmVudCk7Ci0KLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoIjExMSIpOwotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQpOwotCi0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCIyMjIiKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50KTsKLQotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiNjY2Iik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQoZmFsc2UsIHRydWUpOwotCi0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlKCI2NjYiKTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0cnVlLCBmYWxzZSk7Ci0KLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoIjY2NiIpOwotCQl0aGlzLnZlcmlmeUV2ZW50KGZhbHNlLCB0cnVlKTsKLQotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmNsZWFyKCk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodHJ1ZSwgZmFsc2UpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlFdmVudChib29sZWFuIG9sZFZhbHVlLCBib29sZWFuIG5ld1ZhbHVlKSB7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmFkYXB0ZXIsIHRoaXMuZXZlbnQuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoQm9vbGVhbi52YWx1ZU9mKG9sZFZhbHVlKSwgdGhpcy5ldmVudC5nZXRPbGRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKEJvb2xlYW4udmFsdWVPZihuZXdWYWx1ZSksIHRoaXMuZXZlbnQuZ2V0TmV3VmFsdWUoKSk7Ci0JCXRoaXMuZXZlbnQgPSBudWxsOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTdGFsZVZhbHVlKCkgewotCQlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7LyogT0sgKi99Ci0JCX07Ci0JCXRoaXMuYWRhcHRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgbGlzdGVuZXIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiNjY2Iik7Ci0JCWFzc2VydFRydWUodGhpcy5ib29sZWFuVmFsdWUoKSk7Ci0JCWFzc2VydFRydWUodGhpcy53cmFwcGVkQ29sbGVjdGlvbigpLmNvbnRhaW5zKCI2NjYiKSk7Ci0KLQkJdGhpcy5hZGFwdGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCBsaXN0ZW5lcik7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYm9vbGVhblZhbHVlKCkpOwotCQlhc3NlcnRUcnVlKHRoaXMud3JhcHBlZENvbGxlY3Rpb24oKS5jb250YWlucygiNjY2IikpOwotCi0JCXRoaXMuYWRhcHRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgbGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKHRoaXMuYm9vbGVhblZhbHVlKCkpOwotCQlhc3NlcnRUcnVlKHRoaXMud3JhcHBlZENvbGxlY3Rpb24oKS5jb250YWlucygiNjY2IikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNMaXN0ZW5lcnMoKSB7Ci0JCWFzc2VydEZhbHNlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5hZGFwdGVyKS5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJYXNzZXJ0RmFsc2UoKChBYnN0cmFjdE1vZGVsKSB0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyKS5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUykpOwotCi0JCVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsvKiBPSyAqL30KLQkJfTsKLQkJdGhpcy5hZGFwdGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCBsaXN0ZW5lcik7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmFkYXB0ZXIpLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlcikuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMpKTsKLQotCQl0aGlzLmFkYXB0ZXIucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIGxpc3RlbmVyKTsKLQkJYXNzZXJ0RmFsc2UoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmFkYXB0ZXIpLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlhc3NlcnRGYWxzZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIpLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTKSk7Ci0KLQkJdGhpcy5hZGFwdGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5hZGFwdGVyKS5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIpLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTKSk7Ci0KLQkJdGhpcy5hZGFwdGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRGYWxzZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCWFzc2VydEZhbHNlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlcikuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogbWVtYmVyIGNsYXNzICoqKioqKioqKioKLQotCS8qKgotCSAqIHRoZSB2YWx1ZSBpcyB0cnVlIGlmIHRoZSB3cmFwcGVkIGNvbGxlY3Rpb24gY29udGFpbnMgdGhlIHNwZWNpZmllZCBpdGVtLAotCSAqIG90aGVyd2lzZSB0aGUgdmFsdWUgaXMgZmFsc2UKLQkgKi8KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBMb2NhbEFkYXB0ZXIKLQkJZXh0ZW5kcyBDb2xsZWN0aW9uUHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlcjxCb29sZWFuPgotCQlpbXBsZW1lbnRzIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+Ci0JewotCQlwcml2YXRlIFN0cmluZyBpdGVtOwotCi0JCUxvY2FsQWRhcHRlcihDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+IGNvbGxlY3Rpb25Ib2xkZXIsIFN0cmluZyBpdGVtKSB7Ci0JCQlzdXBlcihjb2xsZWN0aW9uSG9sZGVyKTsKLQkJCXRoaXMuaXRlbSA9IGl0ZW07Ci0JCX0KLQotCQkvLyAqKioqKioqKioqIENvbGxlY3Rpb25Qcm9wZXJ0eVZhbHVlTW9kZWxBZGFwdGVyIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQkJLyoqCi0JCSAqIGFsd2F5cyByZXR1cm4gYSBCb29sZWFuCi0JCSAqLwotCQlAT3ZlcnJpZGUKLQkJcHVibGljIEJvb2xlYW4gZ2V0VmFsdWUoKSB7Ci0JCQlCb29sZWFuIHJlc3VsdCA9IHN1cGVyLmdldFZhbHVlKCk7Ci0JCQlyZXR1cm4gKHJlc3VsdCA9PSBudWxsKSA/IEJvb2xlYW4uRkFMU0UgOiByZXN1bHQ7Ci0JCX0KLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCXB1YmxpYyB2b2lkIHNldFZhbHVlKEJvb2xlYW4gdmFsdWUpIHsKLQkJCWlmICh0aGlzLmJvb2xlYW5WYWx1ZSgpKSB7Ci0JCQkJaWYgKCAhIHRoaXMuYm9vbGVhblZhbHVlT2YodmFsdWUpKSB7Ci0JCQkJCS8vIHRoZSB2YWx1ZSBpcyBjaGFuZ2luZyBmcm9tIHRydWUgdG8gZmFsc2UKLQkJCQkJKChTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+KSB0aGlzLmNvbGxlY3Rpb25Ib2xkZXIpLnJlbW92ZSh0aGlzLml0ZW0pOwotCQkJCX0KLQkJCX0gZWxzZSB7Ci0JCQkJaWYgKHRoaXMuYm9vbGVhblZhbHVlT2YodmFsdWUpKSB7Ci0JCQkJCS8vIHRoZSB2YWx1ZSBpcyBjaGFuZ2luZyBmcm9tIGZhbHNlIHRvIHRydWUKLQkJCQkJKChTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+KSB0aGlzLmNvbGxlY3Rpb25Ib2xkZXIpLmFkZCh0aGlzLml0ZW0pOwotCQkJCX0KLQkJCX0KLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZSgpIHsKLQkJCXJldHVybiBCb29sZWFuLnZhbHVlT2YoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuY29sbGVjdGlvbkhvbGRlci5pdGVyYXRvcigpLCB0aGlzLml0ZW0pKTsKLQkJfQotCi0JCS8vICoqKioqKioqKiogaW50ZXJuYWwgbWV0aG9kcyAqKioqKioqKioqCi0JCXByaXZhdGUgYm9vbGVhbiBib29sZWFuVmFsdWUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5ib29sZWFuVmFsdWVPZih0aGlzLnZhbHVlKTsKLQkJfQotCQlwcml2YXRlIGJvb2xlYW4gYm9vbGVhblZhbHVlT2YoT2JqZWN0IGIpIHsKLQkJCXJldHVybiAoYiA9PSBudWxsKSA/IGZhbHNlIDogKChCb29sZWFuKSBiKS5ib29sZWFuVmFsdWUoKTsKLQkJfQotCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0NvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ29tcG9zaXRlQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxYTdiNjg4Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ29tcG9zaXRlQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDE0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQmFnOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5UcmFuc2Zvcm1lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuQ29tcG9zaXRlSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlRyYW5zZm9ybWF0aW9uSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uQXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Db21wb3NpdGVDb2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIENvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBOZWlnaGJvcmhvb2QgbmVpZ2hib3Job29kOwotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8TmVpZ2hib3Job29kPiBuZWlnaGJvcmhvb2RIb2xkZXI7Ci0KLQlwdWJsaWMgQ29tcG9zaXRlQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLm5laWdoYm9yaG9vZCA9IG5ldyBOZWlnaGJvcmhvb2QoIkhhbm5hLUJhcmJlcmEiKTsKLQkJdGhpcy5uZWlnaGJvcmhvb2RIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPE5laWdoYm9yaG9vZD4odGhpcy5uZWlnaGJvcmhvb2QpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3luY2gxKCkgewotCQl0aGlzLnZlcmlmeVN5bmNoKHRoaXMuYnVpbGRBbGxNZW1iZXJzQ29tcG9zaXRlKHRoaXMubmVpZ2hib3Job29kSG9sZGVyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFN5bmNoMigpIHsKLQkJdGhpcy52ZXJpZnlTeW5jaCh0aGlzLmJ1aWxkQWxsTWVtYmVyc0NvbXBvc2l0ZTIodGhpcy5uZWlnaGJvcmhvb2RIb2xkZXIpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5U3luY2goQ29sbGVjdGlvblZhbHVlTW9kZWw8TWVtYmVyPiBjb21wb3NpdGVDVk0pIHsKLQkJYXNzZXJ0RXF1YWxzKDAsIENvbGxlY3Rpb25Ub29scy5zaXplKGNvbXBvc2l0ZUNWTS5pdGVyYXRvcigpKSk7Ci0JCUJhZzxGYW1pbHk+IGZhbWlsaWVzU3luY2ggPSBuZXcgQ29vcmRpbmF0ZWRCYWc8RmFtaWx5Pih0aGlzLmJ1aWxkRmFtaWxpZXNBc3BlY3RBZGFwdGVyKHRoaXMubmVpZ2hib3Job29kSG9sZGVyKSk7Ci0JCUJhZzxNZW1iZXI+IG1lbWJlcnNTeW5jaCA9IG5ldyBDb29yZGluYXRlZEJhZzxNZW1iZXI+KGNvbXBvc2l0ZUNWTSk7Ci0JCXRoaXMucG9wdWxhdGVOZWlnaGJvcmhvb2QodGhpcy5uZWlnaGJvcmhvb2QpOwotCi0JCUZhbWlseSBqZXRzb25zID0gdGhpcy5uZWlnaGJvcmhvb2QuZmFtaWx5TmFtZWQoIkpldHNvbiIpOwotCi0JCWFzc2VydEVxdWFscygzLCBmYW1pbGllc1N5bmNoLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscygxMiwgQ29sbGVjdGlvblRvb2xzLnNpemUodGhpcy5uZWlnaGJvcmhvb2QuYWxsTWVtYmVycygpKSk7Ci0JCWFzc2VydEVxdWFscygxMiwgbWVtYmVyc1N5bmNoLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhDb2xsZWN0aW9uVG9vbHMuYmFnKHRoaXMubmVpZ2hib3Job29kLmFsbE1lbWJlcnMoKSksIG1lbWJlcnNTeW5jaCk7Ci0JCWFzc2VydEVxdWFscyhtZW1iZXJzU3luY2gsIENvbGxlY3Rpb25Ub29scy5iYWcoY29tcG9zaXRlQ1ZNLml0ZXJhdG9yKCkpKTsKLQotCQlqZXRzb25zLnJlbW92ZU1lbWJlcihqZXRzb25zLm1lbWJlck5hbWVkKCJBc3RybyIpKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGZhbWlsaWVzU3luY2guc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDExLCBDb2xsZWN0aW9uVG9vbHMuc2l6ZSh0aGlzLm5laWdoYm9yaG9vZC5hbGxNZW1iZXJzKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKDExLCBtZW1iZXJzU3luY2guc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKENvbGxlY3Rpb25Ub29scy5iYWcodGhpcy5uZWlnaGJvcmhvb2QuYWxsTWVtYmVycygpKSwgbWVtYmVyc1N5bmNoKTsKLQkJYXNzZXJ0RXF1YWxzKG1lbWJlcnNTeW5jaCwgQ29sbGVjdGlvblRvb2xzLmJhZyhjb21wb3NpdGVDVk0uaXRlcmF0b3IoKSkpOwotCi0JCWpldHNvbnMucmVtb3ZlTWVtYmVyKGpldHNvbnMubWVtYmVyTmFtZWQoIkp1ZHkiKSk7Ci0JCWFzc2VydEVxdWFscygzLCBmYW1pbGllc1N5bmNoLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscygxMCwgQ29sbGVjdGlvblRvb2xzLnNpemUodGhpcy5uZWlnaGJvcmhvb2QuYWxsTWVtYmVycygpKSk7Ci0JCWFzc2VydEVxdWFscygxMCwgbWVtYmVyc1N5bmNoLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhDb2xsZWN0aW9uVG9vbHMuYmFnKHRoaXMubmVpZ2hib3Job29kLmFsbE1lbWJlcnMoKSksIG1lbWJlcnNTeW5jaCk7Ci0JCWFzc2VydEVxdWFscyhtZW1iZXJzU3luY2gsIENvbGxlY3Rpb25Ub29scy5iYWcoY29tcG9zaXRlQ1ZNLml0ZXJhdG9yKCkpKTsKLQotCQlqZXRzb25zLmFkZE1lbWJlcigiRmlkbyIpOwotCQlhc3NlcnRFcXVhbHMoMywgZmFtaWxpZXNTeW5jaC5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMTEsIENvbGxlY3Rpb25Ub29scy5zaXplKHRoaXMubmVpZ2hib3Job29kLmFsbE1lbWJlcnMoKSkpOwotCQlhc3NlcnRFcXVhbHMoMTEsIG1lbWJlcnNTeW5jaC5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoQ29sbGVjdGlvblRvb2xzLmJhZyh0aGlzLm5laWdoYm9yaG9vZC5hbGxNZW1iZXJzKCkpLCBtZW1iZXJzU3luY2gpOwotCQlhc3NlcnRFcXVhbHMobWVtYmVyc1N5bmNoLCBDb2xsZWN0aW9uVG9vbHMuYmFnKGNvbXBvc2l0ZUNWTS5pdGVyYXRvcigpKSk7Ci0KLQkJdGhpcy5uZWlnaGJvcmhvb2QucmVtb3ZlRmFtaWx5KGpldHNvbnMpOwotCQlhc3NlcnRFcXVhbHMoMiwgZmFtaWxpZXNTeW5jaC5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoNywgQ29sbGVjdGlvblRvb2xzLnNpemUodGhpcy5uZWlnaGJvcmhvb2QuYWxsTWVtYmVycygpKSk7Ci0JCWFzc2VydEVxdWFscyg3LCBtZW1iZXJzU3luY2guc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKENvbGxlY3Rpb25Ub29scy5iYWcodGhpcy5uZWlnaGJvcmhvb2QuYWxsTWVtYmVycygpKSwgbWVtYmVyc1N5bmNoKTsKLQkJYXNzZXJ0RXF1YWxzKG1lbWJlcnNTeW5jaCwgQ29sbGVjdGlvblRvb2xzLmJhZyhjb21wb3NpdGVDVk0uaXRlcmF0b3IoKSkpOwotCi0JCUZhbWlseSBiZWFycyA9IHRoaXMubmVpZ2hib3Job29kLmFkZEZhbWlseSgiQmVhciIpOwotCQkJYmVhcnMuYWRkTWVtYmVyKCJZb2dpIik7Ci0JCWFzc2VydEVxdWFscygzLCBmYW1pbGllc1N5bmNoLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyg4LCBDb2xsZWN0aW9uVG9vbHMuc2l6ZSh0aGlzLm5laWdoYm9yaG9vZC5hbGxNZW1iZXJzKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKDgsIG1lbWJlcnNTeW5jaC5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoQ29sbGVjdGlvblRvb2xzLmJhZyh0aGlzLm5laWdoYm9yaG9vZC5hbGxNZW1iZXJzKCkpLCBtZW1iZXJzU3luY2gpOwotCQlhc3NlcnRFcXVhbHMobWVtYmVyc1N5bmNoLCBDb2xsZWN0aW9uVG9vbHMuYmFnKGNvbXBvc2l0ZUNWTS5pdGVyYXRvcigpKSk7Ci0KLQkJYmVhcnMuYWRkTWVtYmVyKCJCb28tQm9vIik7Ci0JCWFzc2VydEVxdWFscygzLCBmYW1pbGllc1N5bmNoLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyg5LCBDb2xsZWN0aW9uVG9vbHMuc2l6ZSh0aGlzLm5laWdoYm9yaG9vZC5hbGxNZW1iZXJzKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKDksIG1lbWJlcnNTeW5jaC5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoQ29sbGVjdGlvblRvb2xzLmJhZyh0aGlzLm5laWdoYm9yaG9vZC5hbGxNZW1iZXJzKCkpLCBtZW1iZXJzU3luY2gpOwotCQlhc3NlcnRFcXVhbHMobWVtYmVyc1N5bmNoLCBDb2xsZWN0aW9uVG9vbHMuYmFnKGNvbXBvc2l0ZUNWTS5pdGVyYXRvcigpKSk7Ci0KLQkJTmVpZ2hib3Job29kIG4yID0gbmV3IE5laWdoYm9yaG9vZCgiSGFubmEtQmFyYmVyYSAyIik7Ci0JCXRoaXMubmVpZ2hib3Job29kSG9sZGVyLnNldFZhbHVlKG4yKTsKLQkJdGhpcy5wb3B1bGF0ZU5laWdoYm9yaG9vZChuMik7Ci0JCWFzc2VydEVxdWFscygzLCBmYW1pbGllc1N5bmNoLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscygxMiwgQ29sbGVjdGlvblRvb2xzLnNpemUobjIuYWxsTWVtYmVycygpKSk7Ci0JCWFzc2VydEVxdWFscygxMiwgbWVtYmVyc1N5bmNoLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhDb2xsZWN0aW9uVG9vbHMuYmFnKG4yLmFsbE1lbWJlcnMoKSksIG1lbWJlcnNTeW5jaCk7Ci0JCWFzc2VydEVxdWFscyhtZW1iZXJzU3luY2gsIENvbGxlY3Rpb25Ub29scy5iYWcoY29tcG9zaXRlQ1ZNLml0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Tm9UcmFuc2Zvcm1lcigpIHsKLQkJU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8U3RyaW5nPiBzdWJDVk0xID0gbmV3IFNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4oKTsKLQkJU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8U3RyaW5nPiBzdWJDVk0yID0gbmV3IFNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4oKTsKLQkJQ29sbGVjdGlvbjxDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+PiBjb2xsZWN0aW9uID0gbmV3IEFycmF5TGlzdDxDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+PigpOwotCQljb2xsZWN0aW9uLmFkZChzdWJDVk0xKTsKLQkJY29sbGVjdGlvbi5hZGQoc3ViQ1ZNMik7Ci0JCUJhZzxTdHJpbmc+IHN5bmNoQmFnID0gbmV3IENvb3JkaW5hdGVkQmFnPFN0cmluZz4obmV3IENvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPENvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4sIFN0cmluZz4oY29sbGVjdGlvbikpOwotCi0JCWFzc2VydEVxdWFscygwLCBzeW5jaEJhZy5zaXplKCkpOwotCi0JCXN1YkNWTTEuYWRkKCJmb28iKTsKLQkJc3ViQ1ZNMS5hZGQoImJhciIpOwotCQlzdWJDVk0xLmFkZCgiYmF6Iik7Ci0JCWFzc2VydEVxdWFscygzLCBzeW5jaEJhZy5zaXplKCkpOwotCQlhc3NlcnRUcnVlKHN5bmNoQmFnLmNvbnRhaW5zKCJmb28iKSk7Ci0KLQkJc3ViQ1ZNMi5hZGQoImpvbyIpOwotCQlzdWJDVk0yLmFkZCgiamFyIik7Ci0JCXN1YkNWTTIuYWRkKCJqYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoQmFnLnNpemUoKSk7Ci0JCWFzc2VydFRydWUoc3luY2hCYWcuY29udGFpbnMoImZvbyIpKTsKLQkJYXNzZXJ0VHJ1ZShzeW5jaEJhZy5jb250YWlucygiamF6IikpOwotCi0JCXN1YkNWTTEucmVtb3ZlKCJiYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKDUsIHN5bmNoQmFnLnNpemUoKSk7Ci0JCWFzc2VydEZhbHNlKHN5bmNoQmFnLmNvbnRhaW5zKCJiYXoiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdER1cGxpY2F0ZUl0ZW0oKSB7Ci0JCUJhZzxNZW1iZXI+IHN5bmNoQmFnID0gbmV3IENvb3JkaW5hdGVkQmFnPE1lbWJlcj4odGhpcy5idWlsZEFsbE1lbWJlcnNDb21wb3NpdGUodGhpcy5uZWlnaGJvcmhvb2RIb2xkZXIpKTsKLQkJdGhpcy5wb3B1bGF0ZU5laWdoYm9yaG9vZCh0aGlzLm5laWdoYm9yaG9vZCk7Ci0JCWJvb2xlYW4gZXhDYXVnaHQgPSBmYWxzZTsKLQkJdHJ5IHsKLQkJCXRoaXMubmVpZ2hib3Job29kLmFkZEZhbWlseSh0aGlzLm5laWdoYm9yaG9vZC5mYW1pbHlOYW1lZCgiSmV0c29uIikpOwotCQl9IGNhdGNoIChJbGxlZ2FsU3RhdGVFeGNlcHRpb24gZXgpIHsKLQkJCWlmIChleC5nZXRNZXNzYWdlKCkuaW5kZXhPZigiZHVwbGljYXRlIGNvbXBvbmVudCIpICE9IC0xKSB7Ci0JCQkJZXhDYXVnaHQgPSB0cnVlOwotCQkJfQotCQl9Ci0JCWFzc2VydFRydWUoZXhDYXVnaHQpOwotCQlhc3NlcnRFcXVhbHMoMTIsIHN5bmNoQmFnLnNpemUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc0xpc3RlbmVycygpIHsKLQkJQ29tcG9zaXRlQ29sbGVjdGlvblZhbHVlTW9kZWw8RmFtaWx5LCBNZW1iZXI+IGNvbXBvc2l0ZUNWTSA9IHRoaXMuYnVpbGRBbGxNZW1iZXJzQ29tcG9zaXRlKHRoaXMubmVpZ2hib3Job29kSG9sZGVyKTsKLQkJQ29vcmRpbmF0ZWRCYWc8TWVtYmVyPiBzeW5jaEJhZyA9IG5ldyBDb29yZGluYXRlZEJhZzxNZW1iZXI+KGNvbXBvc2l0ZUNWTSk7Ci0JCXRoaXMucG9wdWxhdGVOZWlnaGJvcmhvb2QodGhpcy5uZWlnaGJvcmhvb2QpOwotCQlGYW1pbHkgamV0c29ucyA9IHRoaXMubmVpZ2hib3Job29kLmZhbWlseU5hbWVkKCJKZXRzb24iKTsKLQotCQlhc3NlcnRUcnVlKGNvbXBvc2l0ZUNWTS5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUykpOwotCQlhc3NlcnRUcnVlKGpldHNvbnMuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhGYW1pbHkuTUVNQkVSU19DT0xMRUNUSU9OKSk7Ci0KLQkJY29tcG9zaXRlQ1ZNLnJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIHN5bmNoQmFnKTsKLQkJYXNzZXJ0RmFsc2UoY29tcG9zaXRlQ1ZNLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTKSk7Ci0JCWFzc2VydEZhbHNlKGpldHNvbnMuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhGYW1pbHkuTUVNQkVSU19DT0xMRUNUSU9OKSk7Ci0KLQkJY29tcG9zaXRlQ1ZNLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIHN5bmNoQmFnKTsKLQkJYXNzZXJ0VHJ1ZShjb21wb3NpdGVDVk0uaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMpKTsKLQkJYXNzZXJ0VHJ1ZShqZXRzb25zLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoRmFtaWx5Lk1FTUJFUlNfQ09MTEVDVElPTikpOwotCX0KLQotCXByaXZhdGUgdm9pZCBwb3B1bGF0ZU5laWdoYm9yaG9vZChOZWlnaGJvcmhvb2QgbikgewotCQlGYW1pbHkgZmFtaWx5MSA9IG4uYWRkRmFtaWx5KCJGbGludHN0b25lIik7Ci0JCQlmYW1pbHkxLmFkZE1lbWJlcigiRnJlZCIpOwotCQkJZmFtaWx5MS5hZGRNZW1iZXIoIldpbG1hIik7Ci0JCQlmYW1pbHkxLmFkZE1lbWJlcigiUGViYmxlcyIpOwotCQkJZmFtaWx5MS5hZGRNZW1iZXIoIkRpbm8iKTsKLQkJRmFtaWx5IGZhbWlseTIgPSBuLmFkZEZhbWlseSgiUnViYmxlIik7Ci0JCQlmYW1pbHkyLmFkZE1lbWJlcigiQmFybmV5Iik7Ci0JCQlmYW1pbHkyLmFkZE1lbWJlcigiQmV0dHkiKTsKLQkJCWZhbWlseTIuYWRkTWVtYmVyKCJCYW1tLUJhbW0iKTsKLQkJRmFtaWx5IGZhbWlseTMgPSBuLmFkZEZhbWlseSgiSmV0c29uIik7Ci0JCQlmYW1pbHkzLmFkZE1lbWJlcigiR2VvcmdlIik7Ci0JCQlmYW1pbHkzLmFkZE1lbWJlcigiSmFuZSIpOwotCQkJZmFtaWx5My5hZGRNZW1iZXIoIkp1ZHkiKTsKLQkJCWZhbWlseTMuYWRkTWVtYmVyKCJFbHJveSIpOwotCQkJZmFtaWx5My5hZGRNZW1iZXIoIkFzdHJvIik7Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uVmFsdWVNb2RlbDxGYW1pbHk+IGJ1aWxkRmFtaWxpZXNBc3BlY3RBZGFwdGVyKFByb3BlcnR5VmFsdWVNb2RlbDxOZWlnaGJvcmhvb2Q+IGNvbW11bmVIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBDb2xsZWN0aW9uQXNwZWN0QWRhcHRlcjxOZWlnaGJvcmhvb2QsIEZhbWlseT4oY29tbXVuZUhvbGRlciwgTmVpZ2hib3Job29kLkZBTUlMSUVTX0NPTExFQ1RJT04pIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEl0ZXJhdG9yPEZhbWlseT4gaXRlcmF0b3JfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZmFtaWxpZXMoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlDb2xsZWN0aW9uVmFsdWVNb2RlbDxNZW1iZXI+IGJ1aWxkTWVtYmVyc0FkYXB0ZXIoRmFtaWx5IGZhbWlseSkgewotCQlyZXR1cm4gbmV3IENvbGxlY3Rpb25Bc3BlY3RBZGFwdGVyPEZhbWlseSwgTWVtYmVyPihGYW1pbHkuTUVNQkVSU19DT0xMRUNUSU9OLCBmYW1pbHkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIEl0ZXJhdG9yPE1lbWJlcj4gaXRlcmF0b3JfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QubWVtYmVycygpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgQ29tcG9zaXRlQ29sbGVjdGlvblZhbHVlTW9kZWw8RmFtaWx5LCBNZW1iZXI+IGJ1aWxkQWxsTWVtYmVyc0NvbXBvc2l0ZShQcm9wZXJ0eVZhbHVlTW9kZWw8TmVpZ2hib3Job29kPiBjb21tdW5lSG9sZGVyKSB7Ci0JCS8vIG92ZXJyaWRlICN0cmFuc2Zvcm0oT2JqZWN0KQotCQlyZXR1cm4gbmV3IENvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPEZhbWlseSwgTWVtYmVyPih0aGlzLmJ1aWxkRmFtaWxpZXNBc3BlY3RBZGFwdGVyKGNvbW11bmVIb2xkZXIpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBDb2xsZWN0aW9uVmFsdWVNb2RlbDxNZW1iZXI+IHRyYW5zZm9ybShGYW1pbHkgZmFtaWx5KSB7Ci0JCQkJcmV0dXJuIENvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMudGhpcy5idWlsZE1lbWJlcnNBZGFwdGVyKGZhbWlseSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uVmFsdWVNb2RlbDxNZW1iZXI+IGJ1aWxkQWxsTWVtYmVyc0NvbXBvc2l0ZTIoUHJvcGVydHlWYWx1ZU1vZGVsPE5laWdoYm9yaG9vZD4gY29tbXVuZUhvbGRlcikgewotCQkvLyBidWlsZCBhIGN1c3RvbSBUcmFuc2Zvcm1lcgotCQlyZXR1cm4gbmV3IENvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPEZhbWlseSwgTWVtYmVyPih0aGlzLmJ1aWxkRmFtaWxpZXNBc3BlY3RBZGFwdGVyKGNvbW11bmVIb2xkZXIpLCB0aGlzLmJ1aWxkVHJhbnNmb3JtZXIoKSk7Ci0JfQotCi0JcHJpdmF0ZSBUcmFuc2Zvcm1lcjxGYW1pbHksIENvbGxlY3Rpb25WYWx1ZU1vZGVsPE1lbWJlcj4+IGJ1aWxkVHJhbnNmb3JtZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJhbnNmb3JtZXI8RmFtaWx5LCBDb2xsZWN0aW9uVmFsdWVNb2RlbDxNZW1iZXI+PigpIHsKLQkJCXB1YmxpYyBDb2xsZWN0aW9uVmFsdWVNb2RlbDxNZW1iZXI+IHRyYW5zZm9ybShGYW1pbHkgZmFtaWx5KSB7Ci0JCQkJcmV0dXJuIENvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMudGhpcy5idWlsZE1lbWJlcnNBZGFwdGVyKGZhbWlseSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQkJcmV0dXJuICJMb2NhbCBUcmFuc2Zvcm1lciI7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLS8vICoqKioqKioqKiogaW5uZXIgY2xhc3NlcyAqKioqKioqKioqCi0KLQkvKioKLQkgKiBpbm5lciBjbGFzcwotCSAqLwotCXByaXZhdGUgY2xhc3MgTmVpZ2hib3Job29kIGV4dGVuZHMgQWJzdHJhY3RNb2RlbCB7Ci0JCXByaXZhdGUgU3RyaW5nIG5hbWU7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBOQU1FX1BST1BFUlRZID0gIm5hbWUiOwotCQlwcml2YXRlIENvbGxlY3Rpb248RmFtaWx5PiBmYW1pbGllcyA9IG5ldyBBcnJheUxpc3Q8RmFtaWx5PigpOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgRkFNSUxJRVNfQ09MTEVDVElPTiA9ICJmYW1pbGllcyI7Ci0JCi0JCXB1YmxpYyBOZWlnaGJvcmhvb2QoU3RyaW5nIG5hbWUpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLm5hbWUgPSBuYW1lOwotCQl9Ci0JCi0JCXB1YmxpYyBTdHJpbmcgZ2V0TmFtZSgpIHsKLQkJCXJldHVybiB0aGlzLm5hbWU7Ci0JCX0KLQkJCi0JCXB1YmxpYyB2b2lkIHNldE5hbWUoU3RyaW5nIG5hbWUpIHsKLQkJCU9iamVjdCBvbGQgPSB0aGlzLm5hbWU7Ci0JCQl0aGlzLm5hbWUgPSBuYW1lOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKE5BTUVfUFJPUEVSVFksIG9sZCwgbmFtZSk7Ci0JCX0KLQkKLQkJcHVibGljIEl0ZXJhdG9yPEZhbWlseT4gZmFtaWxpZXMoKSB7Ci0JCQlyZXR1cm4gdGhpcy5mYW1pbGllcy5pdGVyYXRvcigpOwotCQl9Ci0JCi0JCXB1YmxpYyBGYW1pbHkgYWRkRmFtaWx5KFN0cmluZyBmYW1pbHlOYW1lKSB7Ci0JCQlyZXR1cm4gdGhpcy5hZGRGYW1pbHkobmV3IEZhbWlseShmYW1pbHlOYW1lKSk7Ci0JCX0KLQotCQkvLyBiYWNrZG9vciB0byBhbGxvdyBkdXBsaWNhdGVzCi0JCXB1YmxpYyBGYW1pbHkgYWRkRmFtaWx5KEZhbWlseSBmYW1pbHkpIHsKLQkJCXRoaXMuYWRkSXRlbVRvQ29sbGVjdGlvbihmYW1pbHksIHRoaXMuZmFtaWxpZXMsIEZBTUlMSUVTX0NPTExFQ1RJT04pOwotCQkJcmV0dXJuIGZhbWlseTsKLQkJfQotCi0JCXB1YmxpYyB2b2lkIHJlbW92ZUZhbWlseShGYW1pbHkgZmFtaWx5KSB7Ci0JCQl0aGlzLnJlbW92ZUl0ZW1Gcm9tQ29sbGVjdGlvbihmYW1pbHksIHRoaXMuZmFtaWxpZXMsIEZBTUlMSUVTX0NPTExFQ1RJT04pOwotCQl9Ci0JCi0JCXB1YmxpYyBGYW1pbHkgZmFtaWx5TmFtZWQoU3RyaW5nIGZhbWlseU5hbWUpIHsKLQkJCWZvciAoRmFtaWx5IGZhbWlseSA6IHRoaXMuZmFtaWxpZXMpIHsKLQkJCQlpZiAoZmFtaWx5LmdldE5hbWUoKS5lcXVhbHMoZmFtaWx5TmFtZSkpIHsKLQkJCQkJcmV0dXJuIGZhbWlseTsKLQkJCQl9Ci0JCQl9Ci0JCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKGZhbWlseU5hbWUpOwotCQl9Ci0JCi0JCXB1YmxpYyBJdGVyYXRvcjxNZW1iZXI+IGFsbE1lbWJlcnMoKSB7Ci0JCQlyZXR1cm4gbmV3IENvbXBvc2l0ZUl0ZXJhdG9yPE1lbWJlcj4odGhpcy5tZW1iZXJzSXRlcmF0b3JzKCkpOwotCQl9Ci0JCi0JCXByaXZhdGUgSXRlcmF0b3I8SXRlcmF0b3I8TWVtYmVyPj4gbWVtYmVyc0l0ZXJhdG9ycygpIHsKLQkJCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25JdGVyYXRvcjxGYW1pbHksIEl0ZXJhdG9yPE1lbWJlcj4+KHRoaXMuZmFtaWxpZXMoKSkgewotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCBJdGVyYXRvcjxNZW1iZXI+IHRyYW5zZm9ybShGYW1pbHkgZmFtaWx5KSB7Ci0JCQkJCXJldHVybiBmYW1pbHkubWVtYmVycygpOwotCQkJCX0KLQkJCX07Ci0JCX0KLQkKLQkJcHVibGljIE1lbWJlciBtZW1iZXJOYW1lZChTdHJpbmcgZmFtaWx5TmFtZSwgU3RyaW5nIG1lbWJlck5hbWUpIHsKLQkJCXJldHVybiB0aGlzLmZhbWlseU5hbWVkKGZhbWlseU5hbWUpLm1lbWJlck5hbWVkKG1lbWJlck5hbWUpOwotCQl9Ci0JCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgdm9pZCB0b1N0cmluZyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCQlzYi5hcHBlbmQodGhpcy5uYW1lKTsKLQkJfQotCi0JfQotCi0KLQkvKioKLQkgKiBpbm5lciBjbGFzcwotCSAqLwotCXByaXZhdGUgY2xhc3MgRmFtaWx5IGV4dGVuZHMgQWJzdHJhY3RNb2RlbCB7Ci0JCXByaXZhdGUgU3RyaW5nIG5hbWU7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBOQU1FX1BST1BFUlRZID0gIm5hbWUiOwotCQlwcml2YXRlIENvbGxlY3Rpb248TWVtYmVyPiBtZW1iZXJzID0gbmV3IEFycmF5TGlzdDxNZW1iZXI+KCk7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBNRU1CRVJTX0NPTExFQ1RJT04gPSAibWVtYmVycyI7Ci0JCi0JCXB1YmxpYyBGYW1pbHkoU3RyaW5nIG5hbWUpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLm5hbWUgPSBuYW1lOwotCQl9Ci0JCi0JCXB1YmxpYyBTdHJpbmcgZ2V0TmFtZSgpIHsKLQkJCXJldHVybiB0aGlzLm5hbWU7Ci0JCX0KLQkJCi0JCXB1YmxpYyB2b2lkIHNldE5hbWUoU3RyaW5nIG5hbWUpIHsKLQkJCU9iamVjdCBvbGQgPSB0aGlzLm5hbWU7Ci0JCQl0aGlzLm5hbWUgPSBuYW1lOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKE5BTUVfUFJPUEVSVFksIG9sZCwgbmFtZSk7Ci0JCX0KLQkKLQkJcHVibGljIEl0ZXJhdG9yPE1lbWJlcj4gbWVtYmVycygpIHsKLQkJCXJldHVybiB0aGlzLm1lbWJlcnMuaXRlcmF0b3IoKTsKLQkJfQotCQotCQlwdWJsaWMgTWVtYmVyIGFkZE1lbWJlcihTdHJpbmcgbWVtYmVyTmFtZSkgewotCQkJTWVtYmVyIG1lbWJlciA9IG5ldyBNZW1iZXIobWVtYmVyTmFtZSk7Ci0JCQl0aGlzLmFkZEl0ZW1Ub0NvbGxlY3Rpb24obWVtYmVyLCB0aGlzLm1lbWJlcnMsIE1FTUJFUlNfQ09MTEVDVElPTik7Ci0JCQlyZXR1cm4gbWVtYmVyOwotCQl9Ci0JCQotCQlwdWJsaWMgdm9pZCByZW1vdmVNZW1iZXIoTWVtYmVyIG1lbWJlcikgewotCQkJdGhpcy5yZW1vdmVJdGVtRnJvbUNvbGxlY3Rpb24obWVtYmVyLCB0aGlzLm1lbWJlcnMsIE1FTUJFUlNfQ09MTEVDVElPTik7Ci0JCX0KLQkKLQkJcHVibGljIE1lbWJlciBtZW1iZXJOYW1lZChTdHJpbmcgbWVtYmVyTmFtZSkgewotCQkJZm9yIChNZW1iZXIgbWVtYmVyIDogdGhpcy5tZW1iZXJzKSB7Ci0JCQkJaWYgKG1lbWJlci5nZXROYW1lKCkuZXF1YWxzKG1lbWJlck5hbWUpKSB7Ci0JCQkJCXJldHVybiBtZW1iZXI7Ci0JCQkJfQotCQkJfQotCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbihtZW1iZXJOYW1lKTsKLQkJfQotCQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIHZvaWQgdG9TdHJpbmcoU3RyaW5nQnVpbGRlciBzYikgewotCQkJc2IuYXBwZW5kKHRoaXMubmFtZSk7Ci0JCX0KLQkKLQl9Ci0KLQotCS8qKgotCSAqIGlubmVyIGNsYXNzCi0JICovCi0JcHJpdmF0ZSBjbGFzcyBNZW1iZXIgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIHsKLQkJcHJpdmF0ZSBTdHJpbmcgbmFtZTsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIE5BTUVfUFJPUEVSVFkgPSAibmFtZSI7Ci0KLQkJcHVibGljIE1lbWJlcihTdHJpbmcgbmFtZSkgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCX0KLQotCQlwdWJsaWMgU3RyaW5nIGdldE5hbWUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5uYW1lOwotCQl9Ci0JCi0JCXB1YmxpYyB2b2lkIHNldE5hbWUoU3RyaW5nIG5hbWUpIHsKLQkJCU9iamVjdCBvbGQgPSB0aGlzLm5hbWU7Ci0JCQl0aGlzLm5hbWUgPSBuYW1lOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKE5BTUVfUFJPUEVSVFksIG9sZCwgbmFtZSk7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIHZvaWQgdG9TdHJpbmcoU3RyaW5nQnVpbGRlciBzYikgewotCQkJc2IuYXBwZW5kKHRoaXMubmFtZSk7Ci0JCX0KLQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Db21wb3NpdGVMaXN0VmFsdWVNb2RlbFRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0NvbXBvc2l0ZUxpc3RWYWx1ZU1vZGVsVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjU3ZmZjMS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0NvbXBvc2l0ZUxpc3RWYWx1ZU1vZGVsVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDg0NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlzOwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuQ29tcG9zaXRlTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgQ29tcG9zaXRlTGlzdFZhbHVlTW9kZWxUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gbHZtMDsKLQlwcml2YXRlIFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gbHZtMTsKLQlwcml2YXRlIFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gbHZtMjsKLQlwcml2YXRlIFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gbHZtMzsKLQlwcml2YXRlIFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4+IHViZXJMVk07Ci0JcHJpdmF0ZSBDb21wb3NpdGVMaXN0VmFsdWVNb2RlbDxTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+LCBTdHJpbmc+IGNvbXBvc2l0ZUxWTTsKLQotCXB1YmxpYyBDb21wb3NpdGVMaXN0VmFsdWVNb2RlbFRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0KLQkJdGhpcy5sdm0wID0gbmV3IFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4oKTsKLQkJdGhpcy5sdm0wLmFkZCgiYWFhIik7Ci0JCXRoaXMubHZtMC5hZGQoImJiYiIpOwotCQl0aGlzLmx2bTAuYWRkKCJjY2MiKTsKLQotCQl0aGlzLmx2bTEgPSBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPigpOwotCQl0aGlzLmx2bTEuYWRkKCJkZGQiKTsKLQkJdGhpcy5sdm0xLmFkZCgiZWVlIik7Ci0KLQkJdGhpcy5sdm0yID0gbmV3IFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4oKTsKLQkJdGhpcy5sdm0yLmFkZCgiZmZmIik7Ci0KLQkJdGhpcy5sdm0zID0gbmV3IFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4oKTsKLQkJdGhpcy5sdm0zLmFkZCgiZ2dnIik7Ci0JCXRoaXMubHZtMy5hZGQoImhoaCIpOwotCQl0aGlzLmx2bTMuYWRkKCJpaWkiKTsKLQkJdGhpcy5sdm0zLmFkZCgiampqIik7Ci0JCXRoaXMubHZtMy5hZGQoImtrayIpOwotCi0JCXRoaXMudWJlckxWTSA9IG5ldyBTaW1wbGVMaXN0VmFsdWVNb2RlbDxTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+PigpOwotCQl0aGlzLnViZXJMVk0uYWRkKHRoaXMubHZtMCk7Ci0JCXRoaXMudWJlckxWTS5hZGQodGhpcy5sdm0xKTsKLQkJdGhpcy51YmVyTFZNLmFkZCh0aGlzLmx2bTIpOwotCQl0aGlzLnViZXJMVk0uYWRkKHRoaXMubHZtMyk7Ci0KLQkJdGhpcy5jb21wb3NpdGVMVk0gPSBuZXcgQ29tcG9zaXRlTGlzdFZhbHVlTW9kZWw8U2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiwgU3RyaW5nPigoTGlzdFZhbHVlTW9kZWw8U2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPj4pIHRoaXMudWJlckxWTSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRJbnQoKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0JCWFzc2VydEVxdWFscygiYWFhIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDApKTsKLQkJYXNzZXJ0RXF1YWxzKCJhYWEiLCBjb29yZExpc3QuZ2V0KDApKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYmIiLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoMSkpOwotCQlhc3NlcnRFcXVhbHMoImJiYiIsIGNvb3JkTGlzdC5nZXQoMSkpOwotCQlhc3NlcnRFcXVhbHMoImNjYyIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCgyKSk7Ci0JCWFzc2VydEVxdWFscygiY2NjIiwgY29vcmRMaXN0LmdldCgyKSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKCJkZGQiLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoMykpOwotCQlhc3NlcnRFcXVhbHMoImRkZCIsIGNvb3JkTGlzdC5nZXQoMykpOwotCQlhc3NlcnRFcXVhbHMoImVlZSIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCg0KSk7Ci0JCWFzc2VydEVxdWFscygiZWVlIiwgY29vcmRMaXN0LmdldCg0KSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKCJmZmYiLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoNSkpOwotCQlhc3NlcnRFcXVhbHMoImZmZiIsIGNvb3JkTGlzdC5nZXQoNSkpOwotCi0JCWFzc2VydEVxdWFscygiZ2dnIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDYpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCBjb29yZExpc3QuZ2V0KDYpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SXRlcmF0b3IoKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0JCWFzc2VydEVxdWFscygiYWFhIiwgdGhpcy5jb21wb3NpdGVMVk0uaXRlcmF0b3IoKS5uZXh0KCkpOwotCQlhc3NlcnRFcXVhbHMoImFhYSIsIGNvb3JkTGlzdC5pdGVyYXRvcigpLm5leHQoKSk7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtMSA9IGNvb3JkTGlzdC5pdGVyYXRvcigpOwotCQlmb3IgKEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtMiA9IHRoaXMuY29tcG9zaXRlTFZNLml0ZXJhdG9yKCk7IHN0cmVhbTIuaGFzTmV4dCgpOyApIHsKLQkJCWFzc2VydEVxdWFscyhzdHJlYW0xLm5leHQoKSwgc3RyZWFtMi5uZXh0KCkpOwotCQl9Ci0JCWFzc2VydEZhbHNlKHN0cmVhbTEuaGFzTmV4dCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2l6ZSgpIHsKLQkJQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4gY29vcmRMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KHRoaXMuY29tcG9zaXRlTFZNKTsKLQkJYXNzZXJ0RXF1YWxzKDExLCB0aGlzLmNvbXBvc2l0ZUxWTS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMTEsIGNvb3JkTGlzdC5zaXplKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RUb0FycmF5KCkgewotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJhYWEiLCAiYmJiIiwgImNjYyIsICJkZGQiLCAiZWVlIiwgImZmZiIsICJnZ2ciLCAiaGhoIiwgImlpaSIsICJqamoiLCAia2trIiB9OwotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCWFzc2VydFRydWUodGhpcy5jb21wb3NpdGVMVk0uaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQlhc3NlcnRUcnVlKHRoaXMubHZtMC5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0KLQkJdGhpcy5jb21wb3NpdGVMVk0ucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCBjb29yZExpc3QpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmNvbXBvc2l0ZUxWTS5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMubHZtMC5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0KLQkJdGhpcy5jb21wb3NpdGVMVk0uYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCBjb29yZExpc3QpOwotCQlhc3NlcnRUcnVlKHRoaXMuY29tcG9zaXRlTFZNLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmx2bTAuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRTb3VyY2VfQmVnaW4oKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBsdm0gPSBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPigpOwotCQlsdm0uYWRkKCJ4eHgiKTsKLQkJbHZtLmFkZCgieXl5Iik7Ci0JCWx2bS5hZGQoInp6eiIpOwotCQl0aGlzLnViZXJMVk0uYWRkKDAsIGx2bSk7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAieHh4IiwgInl5eSIsICJ6enoiLCAiYWFhIiwgImJiYiIsICJjY2MiLCAiZGRkIiwgImVlZSIsICJmZmYiLCAiZ2dnIiwgImhoaCIsICJpaWkiLCAiampqIiwgImtrayIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCg5KSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgY29vcmRMaXN0LmdldCg5KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZFNvdXJjZV9NaWRkbGUoKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBsdm0gPSBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPigpOwotCQlsdm0uYWRkKCJ4eHgiKTsKLQkJbHZtLmFkZCgieXl5Iik7Ci0JCWx2bS5hZGQoInp6eiIpOwotCQl0aGlzLnViZXJMVk0uYWRkKDIsIGx2bSk7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAiYWFhIiwgImJiYiIsICJjY2MiLCAiZGRkIiwgImVlZSIsICJ4eHgiLCAieXl5IiwgInp6eiIsICJmZmYiLCAiZ2dnIiwgImhoaCIsICJpaWkiLCAiampqIiwgImtrayIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCg5KSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgY29vcmRMaXN0LmdldCg5KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZFNvdXJjZV9FbmQoKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBsdm0gPSBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPigpOwotCQlsdm0uYWRkKCJ4eHgiKTsKLQkJbHZtLmFkZCgieXl5Iik7Ci0JCWx2bS5hZGQoInp6eiIpOwotCQl0aGlzLnViZXJMVk0uYWRkKGx2bSk7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAiYWFhIiwgImJiYiIsICJjY2MiLCAiZGRkIiwgImVlZSIsICJmZmYiLCAiZ2dnIiwgImhoaCIsICJpaWkiLCAiampqIiwgImtrayIsICJ4eHgiLCAieXl5IiwgInp6eiIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCg2KSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgY29vcmRMaXN0LmdldCg2KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZFNvdXJjZXMoKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBsdm1BID0gbmV3IFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4oKTsKLQkJbHZtQS5hZGQoInh4eCIpOwotCQlsdm1BLmFkZCgieXl5Iik7Ci0JCWx2bUEuYWRkKCJ6enoiKTsKLQkJU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBsdm1CID0gbmV3IFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4oKTsKLQkJbHZtQi5hZGQoInBwcCIpOwotCQlsdm1CLmFkZCgicXFxIik7Ci0JCWx2bUIuYWRkKCJycnIiKTsKLQkJQ29sbGVjdGlvbjxTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+PiBjID0gbmV3IEFycmF5TGlzdDxTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+PigpOwotCQljLmFkZChsdm1BKTsKLQkJYy5hZGQobHZtQik7Ci0JCXRoaXMudWJlckxWTS5hZGRBbGwoMiwgYyk7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAiYWFhIiwgImJiYiIsICJjY2MiLCAiZGRkIiwgImVlZSIsICJ4eHgiLCAieXl5IiwgInp6eiIsICJwcHAiLCAicXFxIiwgInJyciIsICJmZmYiLCAiZ2dnIiwgImhoaCIsICJpaWkiLCAiampqIiwgImtrayIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCgxMikpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIGNvb3JkTGlzdC5nZXQoMTIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlU291cmNlX0JlZ2luKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMudWJlckxWTS5yZW1vdmUoMCk7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAiZGRkIiwgImVlZSIsICJmZmYiLCAiZ2dnIiwgImhoaCIsICJpaWkiLCAiampqIiwgImtrayIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCgzKSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgY29vcmRMaXN0LmdldCgzKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZVNvdXJjZV9NaWRkbGUoKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJdGhpcy51YmVyTFZNLnJlbW92ZSgyKTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJhYWEiLCAiYmJiIiwgImNjYyIsICJkZGQiLCAiZWVlIiwgImdnZyIsICJoaGgiLCAiaWlpIiwgImpqaiIsICJra2siIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoNSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIGNvb3JkTGlzdC5nZXQoNSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVTb3VyY2VfRW5kKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMudWJlckxWTS5yZW1vdmUoMyk7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAiYWFhIiwgImJiYiIsICJjY2MiLCAiZGRkIiwgImVlZSIsICJmZmYiIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmZmYiLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoNSkpOwotCQlhc3NlcnRFcXVhbHMoImZmZiIsIGNvb3JkTGlzdC5nZXQoNSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVTb3VyY2VzKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMudWJlckxWTS5yZW1vdmUoMiwgMik7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAiYWFhIiwgImJiYiIsICJjY2MiLCAiZGRkIiwgImVlZSIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoImVlZSIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCg0KSk7Ci0JCWFzc2VydEVxdWFscygiZWVlIiwgY29vcmRMaXN0LmdldCg0KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlcGxhY2VTb3VyY2VzKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gbHZtQSA9IG5ldyBTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+KCk7Ci0JCWx2bUEuYWRkKCJ4eHgiKTsKLQkJbHZtQS5hZGQoInl5eSIpOwotCQlsdm1BLmFkZCgienp6Iik7Ci0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gbHZtQiA9IG5ldyBTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+KCk7Ci0JCWx2bUIuYWRkKCJwcHAiKTsKLQkJbHZtQi5hZGQoInFxcSIpOwotCQlsdm1CLmFkZCgicnJyIik7Ci0JCUxpc3Q8U2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPj4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8U2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPj4oKTsKLQkJbGlzdC5hZGQobHZtQSk7Ci0JCWxpc3QuYWRkKGx2bUIpOwotCQl0aGlzLnViZXJMVk0uc2V0KDIsIGxpc3QpOwotCi0JCU9iamVjdFtdIGV4cGVjdGVkID0gbmV3IE9iamVjdFtdIHsgImFhYSIsICJiYmIiLCAiY2NjIiwgImRkZCIsICJlZWUiLCAieHh4IiwgInl5eSIsICJ6enoiLCAicHBwIiwgInFxcSIsICJycnIiIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJxcXEiLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoOSkpOwotCQlhc3NlcnRFcXVhbHMoInFxcSIsIGNvb3JkTGlzdC5nZXQoOSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RNb3ZlU291cmNlc19CZWdpbigpIHsKLQkJQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4gY29vcmRMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KHRoaXMuY29tcG9zaXRlTFZNKTsKLQotCQl0aGlzLnViZXJMVk0ubW92ZSgwLCAyLCAyKTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJmZmYiLCAiZ2dnIiwgImhoaCIsICJpaWkiLCAiampqIiwgImtrayIsICJhYWEiLCAiYmJiIiwgImNjYyIsICJkZGQiLCAiZWVlIiB9OwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCB0aGlzLmNvbXBvc2l0ZUxWTS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCBjb29yZExpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCB0aGlzLmNvbXBvc2l0ZUxWTS50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBjb29yZExpc3QudG9BcnJheSgpKSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDEpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCBjb29yZExpc3QuZ2V0KDEpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TW92ZVNvdXJjZXNfTWlkZGxlKCkgewotCQlTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGx2bTQgPSBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPigpOwotCQlsdm00LmFkZCgibGxsIik7Ci0JCWx2bTQuYWRkKCJtbW0iKTsKLQkJdGhpcy51YmVyTFZNLmFkZChsdm00KTsKLQotCQlTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGx2bTUgPSBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPigpOwotCQlsdm01LmFkZCgibm5uIik7Ci0JCWx2bTUuYWRkKCJvb28iKTsKLQkJbHZtNS5hZGQoInBwcCIpOwotCQlsdm01LmFkZCgicXFxIik7Ci0JCXRoaXMudWJlckxWTS5hZGQobHZtNSk7Ci0KLQkJQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4gY29vcmRMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KHRoaXMuY29tcG9zaXRlTFZNKTsKLQotCQl0aGlzLnViZXJMVk0ubW92ZSgxLCAzLCAyKTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJhYWEiLCAiYmJiIiwgImNjYyIsICJnZ2ciLCAiaGhoIiwgImlpaSIsICJqamoiLCAia2trIiwgImxsbCIsICJtbW0iLCAiZGRkIiwgImVlZSIsICJmZmYiLCAibm5uIiwgIm9vbyIsICJwcHAiLCAicXFxIiB9OwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCB0aGlzLmNvbXBvc2l0ZUxWTS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCBjb29yZExpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCB0aGlzLmNvbXBvc2l0ZUxWTS50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBjb29yZExpc3QudG9BcnJheSgpKSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDMpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCBjb29yZExpc3QuZ2V0KDMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TW92ZVNvdXJjZXNfRW5kKCkgewotCQlTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGx2bTQgPSBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPigpOwotCQlsdm00LmFkZCgibGxsIik7Ci0JCWx2bTQuYWRkKCJtbW0iKTsKLQkJdGhpcy51YmVyTFZNLmFkZChsdm00KTsKLQotCQlTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGx2bTUgPSBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPigpOwotCQlsdm01LmFkZCgibm5uIik7Ci0JCWx2bTUuYWRkKCJvb28iKTsKLQkJbHZtNS5hZGQoInBwcCIpOwotCQlsdm01LmFkZCgicXFxIik7Ci0JCXRoaXMudWJlckxWTS5hZGQobHZtNSk7Ci0KLQkJQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4gY29vcmRMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KHRoaXMuY29tcG9zaXRlTFZNKTsKLQotCQl0aGlzLnViZXJMVk0ubW92ZSgzLCAwLCAzKTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJnZ2ciLCAiaGhoIiwgImlpaSIsICJqamoiLCAia2trIiwgImxsbCIsICJtbW0iLCAibm5uIiwgIm9vbyIsICJwcHAiLCAicXFxIiwgImFhYSIsICJiYmIiLCAiY2NjIiwgImRkZCIsICJlZWUiLCAiZmZmIiB9OwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCB0aGlzLmNvbXBvc2l0ZUxWTS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCBjb29yZExpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCB0aGlzLmNvbXBvc2l0ZUxWTS50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBjb29yZExpc3QudG9BcnJheSgpKSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDApKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCBjb29yZExpc3QuZ2V0KDApKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TW92ZVNvdXJjZSgpIHsKLQkJU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBsdm00ID0gbmV3IFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4oKTsKLQkJbHZtNC5hZGQoImxsbCIpOwotCQlsdm00LmFkZCgibW1tIik7Ci0JCXRoaXMudWJlckxWTS5hZGQobHZtNCk7Ci0KLQkJU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBsdm01ID0gbmV3IFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4oKTsKLQkJbHZtNS5hZGQoIm5ubiIpOwotCQlsdm01LmFkZCgib29vIik7Ci0JCWx2bTUuYWRkKCJwcHAiKTsKLQkJbHZtNS5hZGQoInFxcSIpOwotCQl0aGlzLnViZXJMVk0uYWRkKGx2bTUpOwotCi0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJdGhpcy51YmVyTFZNLm1vdmUoMywgMSk7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAiYWFhIiwgImJiYiIsICJjY2MiLCAiZmZmIiwgImdnZyIsICJoaGgiLCAiaWlpIiwgImpqaiIsICJra2siLCAiZGRkIiwgImVlZSIsICJsbGwiLCAibW1tIiwgIm5ubiIsICJvb28iLCAicHBwIiwgInFxcSIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoIm9vbyIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCgxNCkpOwotCQlhc3NlcnRFcXVhbHMoIm9vbyIsIGNvb3JkTGlzdC5nZXQoMTQpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2xlYXJTb3VyY2VzKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMudWJlckxWTS5jbGVhcigpOwotCi0JCU9iamVjdFtdIGV4cGVjdGVkID0gbmV3IE9iamVjdFswXTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDaGFuZ2VTb3VyY2VzKCkgewotCQlMaXN0PFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4+IG5ld0xpc3QgPSBuZXcgQXJyYXlMaXN0PFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4+KCk7Ci0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gbHZtNCA9IG5ldyBTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+KCk7Ci0JCWx2bTQuYWRkKCJsbGwiKTsKLQkJbHZtNC5hZGQoIm1tbSIpOwotCQluZXdMaXN0LmFkZChsdm00KTsKLQotCQlTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGx2bTUgPSBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPigpOwotCQlsdm01LmFkZCgibm5uIik7Ci0JCWx2bTUuYWRkKCJvb28iKTsKLQkJbHZtNS5hZGQoInBwcCIpOwotCQlsdm01LmFkZCgicXFxIik7Ci0JCW5ld0xpc3QuYWRkKGx2bTUpOwotCi0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJdGhpcy51YmVyTFZNLnNldExpc3QobmV3TGlzdCk7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAibGxsIiwgIm1tbSIsICJubm4iLCAib29vIiwgInBwcCIsICJxcXEiIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJvb28iLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoMykpOwotCQlhc3NlcnRFcXVhbHMoIm9vbyIsIGNvb3JkTGlzdC5nZXQoMykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRJdGVtX0JlZ2luKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMubHZtMC5hZGQoMCwgInh4eCIpOwotCi0JCU9iamVjdFtdIGV4cGVjdGVkID0gbmV3IE9iamVjdFtdIHsgInh4eCIsICJhYWEiLCAiYmJiIiwgImNjYyIsICJkZGQiLCAiZWVlIiwgImZmZiIsICJnZ2ciLCAiaGhoIiwgImlpaSIsICJqamoiLCAia2trIiB9OwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCB0aGlzLmNvbXBvc2l0ZUxWTS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCBjb29yZExpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCB0aGlzLmNvbXBvc2l0ZUxWTS50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBjb29yZExpc3QudG9BcnJheSgpKSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDcpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCBjb29yZExpc3QuZ2V0KDcpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkSXRlbV9NaWRkbGUoKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJdGhpcy5sdm0yLmFkZCgxLCAieHh4Iik7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAiYWFhIiwgImJiYiIsICJjY2MiLCAiZGRkIiwgImVlZSIsICJmZmYiLCAieHh4IiwgImdnZyIsICJoaGgiLCAiaWlpIiwgImpqaiIsICJra2siIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoNykpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIGNvb3JkTGlzdC5nZXQoNykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRJdGVtX0VuZCgpIHsKLQkJQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4gY29vcmRMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KHRoaXMuY29tcG9zaXRlTFZNKTsKLQotCQl0aGlzLmx2bTMuYWRkKDUsICJ4eHgiKTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJhYWEiLCAiYmJiIiwgImNjYyIsICJkZGQiLCAiZWVlIiwgImZmZiIsICJnZ2ciLCAiaGhoIiwgImlpaSIsICJqamoiLCAia2trIiwgInh4eCIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCg2KSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgY29vcmRMaXN0LmdldCg2KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEl0ZW1zX0JlZ2luKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMubHZtMC5hZGRBbGwoMCwgQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAieHh4IiwgInl5eSIsICJ6enoiIH0pKTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJ4eHgiLCAieXl5IiwgInp6eiIsICJhYWEiLCAiYmJiIiwgImNjYyIsICJkZGQiLCAiZWVlIiwgImZmZiIsICJnZ2ciLCAiaGhoIiwgImlpaSIsICJqamoiLCAia2trIiB9OwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCB0aGlzLmNvbXBvc2l0ZUxWTS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCBjb29yZExpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCB0aGlzLmNvbXBvc2l0ZUxWTS50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBjb29yZExpc3QudG9BcnJheSgpKSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCBjb29yZExpc3QuZ2V0KDkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkSXRlbXNfTWlkZGxlKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMubHZtMi5hZGRBbGwoMSwgQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAieHh4IiwgInl5eSIsICJ6enoiIH0pKTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJhYWEiLCAiYmJiIiwgImNjYyIsICJkZGQiLCAiZWVlIiwgImZmZiIsICJ4eHgiLCAieXl5IiwgInp6eiIsICJnZ2ciLCAiaGhoIiwgImlpaSIsICJqamoiLCAia2trIiB9OwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCB0aGlzLmNvbXBvc2l0ZUxWTS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCBjb29yZExpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCB0aGlzLmNvbXBvc2l0ZUxWTS50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBjb29yZExpc3QudG9BcnJheSgpKSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCBjb29yZExpc3QuZ2V0KDkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkSXRlbXNfRW5kKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMubHZtMy5hZGRBbGwoNSwgQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAieHh4IiwgInl5eSIsICJ6enoiIH0pKTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJhYWEiLCAiYmJiIiwgImNjYyIsICJkZGQiLCAiZWVlIiwgImZmZiIsICJnZ2ciLCAiaGhoIiwgImlpaSIsICJqamoiLCAia2trIiwgInh4eCIsICJ5eXkiLCAienp6IiB9OwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCB0aGlzLmNvbXBvc2l0ZUxWTS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCBjb29yZExpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCB0aGlzLmNvbXBvc2l0ZUxWTS50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBjb29yZExpc3QudG9BcnJheSgpKSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDYpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCBjb29yZExpc3QuZ2V0KDYpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlSXRlbV9CZWdpbigpIHsKLQkJQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4gY29vcmRMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KHRoaXMuY29tcG9zaXRlTFZNKTsKLQotCQl0aGlzLmx2bTAucmVtb3ZlKDApOwotCi0JCU9iamVjdFtdIGV4cGVjdGVkID0gbmV3IE9iamVjdFtdIHsgImJiYiIsICJjY2MiLCAiZGRkIiwgImVlZSIsICJmZmYiLCAiZ2dnIiwgImhoaCIsICJpaWkiLCAiampqIiwgImtrayIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCg1KSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgY29vcmRMaXN0LmdldCg1KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUl0ZW1fTWlkZGxlKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMubHZtMi5yZW1vdmUoMCk7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAiYWFhIiwgImJiYiIsICJjY2MiLCAiZGRkIiwgImVlZSIsICJnZ2ciLCAiaGhoIiwgImlpaSIsICJqamoiLCAia2trIiB9OwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCB0aGlzLmNvbXBvc2l0ZUxWTS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCBjb29yZExpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCB0aGlzLmNvbXBvc2l0ZUxWTS50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBjb29yZExpc3QudG9BcnJheSgpKSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDUpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCBjb29yZExpc3QuZ2V0KDUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlSXRlbV9FbmQoKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJdGhpcy5sdm0zLnJlbW92ZSg0KTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJhYWEiLCAiYmJiIiwgImNjYyIsICJkZGQiLCAiZWVlIiwgImZmZiIsICJnZ2ciLCAiaGhoIiwgImlpaSIsICJqamoiIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoNikpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIGNvb3JkTGlzdC5nZXQoNikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVJdGVtc19CZWdpbigpIHsKLQkJQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4gY29vcmRMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KHRoaXMuY29tcG9zaXRlTFZNKTsKLQotCQl0aGlzLmx2bTAucmVtb3ZlKDAsIDMpOwotCi0JCU9iamVjdFtdIGV4cGVjdGVkID0gbmV3IE9iamVjdFtdIHsgImRkZCIsICJlZWUiLCAiZmZmIiwgImdnZyIsICJoaGgiLCAiaWlpIiwgImpqaiIsICJra2siIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoMykpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIGNvb3JkTGlzdC5nZXQoMykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVJdGVtc19NaWRkbGUoKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJdGhpcy5sdm0zLnJlbW92ZSgxLCAzKTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJhYWEiLCAiYmJiIiwgImNjYyIsICJkZGQiLCAiZWVlIiwgImZmZiIsICJnZ2ciLCAia2trIiB9OwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCB0aGlzLmNvbXBvc2l0ZUxWTS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCBjb29yZExpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCB0aGlzLmNvbXBvc2l0ZUxWTS50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBjb29yZExpc3QudG9BcnJheSgpKSk7Ci0JCWFzc2VydEVxdWFscygia2trIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDcpKTsKLQkJYXNzZXJ0RXF1YWxzKCJra2siLCBjb29yZExpc3QuZ2V0KDcpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlSXRlbXNfRW5kKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMubHZtMy5yZW1vdmUoMywgMik7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAiYWFhIiwgImJiYiIsICJjY2MiLCAiZGRkIiwgImVlZSIsICJmZmYiLCAiZ2dnIiwgImhoaCIsICJpaWkiIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoNikpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIGNvb3JkTGlzdC5nZXQoNikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXBsYWNlSXRlbV9CZWdpbigpIHsKLQkJQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4gY29vcmRMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KHRoaXMuY29tcG9zaXRlTFZNKTsKLQotCQl0aGlzLmx2bTAuc2V0KDAsICJ4eHgiKTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJ4eHgiLCAiYmJiIiwgImNjYyIsICJkZGQiLCAiZWVlIiwgImZmZiIsICJnZ2ciLCAiaGhoIiwgImlpaSIsICJqamoiLCAia2trIiB9OwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCB0aGlzLmNvbXBvc2l0ZUxWTS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCBjb29yZExpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCB0aGlzLmNvbXBvc2l0ZUxWTS50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBjb29yZExpc3QudG9BcnJheSgpKSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDYpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCBjb29yZExpc3QuZ2V0KDYpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVwbGFjZUl0ZW1fTWlkZGxlKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMubHZtMi5zZXQoMCwgInh4eCIpOwotCi0JCU9iamVjdFtdIGV4cGVjdGVkID0gbmV3IE9iamVjdFtdIHsgImFhYSIsICJiYmIiLCAiY2NjIiwgImRkZCIsICJlZWUiLCAieHh4IiwgImdnZyIsICJoaGgiLCAiaWlpIiwgImpqaiIsICJra2siIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoNikpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIGNvb3JkTGlzdC5nZXQoNikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZXBsYWNlSXRlbV9FbmQoKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJdGhpcy5sdm0zLnNldCg0LCAieHh4Iik7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAiYWFhIiwgImJiYiIsICJjY2MiLCAiZGRkIiwgImVlZSIsICJmZmYiLCAiZ2dnIiwgImhoaCIsICJpaWkiLCAiampqIiwgInh4eCIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCg2KSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgY29vcmRMaXN0LmdldCg2KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlcGxhY2VJdGVtc19CZWdpbigpIHsKLQkJQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4gY29vcmRMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KHRoaXMuY29tcG9zaXRlTFZNKTsKLQotCQl0aGlzLmx2bTAuc2V0KDAsIEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgInh4eCIsICJ5eXkiLCAienp6IiB9KSk7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAieHh4IiwgInl5eSIsICJ6enoiLCAiZGRkIiwgImVlZSIsICJmZmYiLCAiZ2dnIiwgImhoaCIsICJpaWkiLCAiampqIiwgImtrayIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCg2KSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgY29vcmRMaXN0LmdldCg2KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlcGxhY2VJdGVtc19NaWRkbGUoKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJdGhpcy5sdm0zLnNldCgxLCBBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJ4eHgiLCAieXl5IiwgInp6eiIgfSkpOwotCi0JCU9iamVjdFtdIGV4cGVjdGVkID0gbmV3IE9iamVjdFtdIHsgImFhYSIsICJiYmIiLCAiY2NjIiwgImRkZCIsICJlZWUiLCAiZmZmIiwgImdnZyIsICJ4eHgiLCAieXl5IiwgInp6eiIsICJra2siIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJra2siLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoMTApKTsKLQkJYXNzZXJ0RXF1YWxzKCJra2siLCBjb29yZExpc3QuZ2V0KDEwKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlcGxhY2VJdGVtc19FbmQoKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJdGhpcy5sdm0zLnNldCgzLCBBcnJheXMuYXNMaXN0KG5ldyBTdHJpbmdbXSB7ICJ4eHgiLCAieXl5IiB9KSk7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAiYWFhIiwgImJiYiIsICJjY2MiLCAiZGRkIiwgImVlZSIsICJmZmYiLCAiZ2dnIiwgImhoaCIsICJpaWkiLCAieHh4IiwgInl5eSIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCg2KSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgY29vcmRMaXN0LmdldCg2KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE1vdmVJdGVtX0JlZ2luKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMubHZtMC5tb3ZlKDIsIDApOwotCi0JCU9iamVjdFtdIGV4cGVjdGVkID0gbmV3IE9iamVjdFtdIHsgImJiYiIsICJjY2MiLCAiYWFhIiwgImRkZCIsICJlZWUiLCAiZmZmIiwgImdnZyIsICJoaGgiLCAiaWlpIiwgImpqaiIsICJra2siIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoNikpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIGNvb3JkTGlzdC5nZXQoNikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RNb3ZlSXRlbV9NaWRkbGUoKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJdGhpcy5sdm0xLm1vdmUoMCwgMSk7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAiYWFhIiwgImJiYiIsICJjY2MiLCAiZWVlIiwgImRkZCIsICJmZmYiLCAiZ2dnIiwgImhoaCIsICJpaWkiLCAiampqIiwgImtrayIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCg2KSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgY29vcmRMaXN0LmdldCg2KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE1vdmVJdGVtX0VuZCgpIHsKLQkJQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4gY29vcmRMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KHRoaXMuY29tcG9zaXRlTFZNKTsKLQotCQl0aGlzLmx2bTMubW92ZSgwLCA0KTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJhYWEiLCAiYmJiIiwgImNjYyIsICJkZGQiLCAiZWVlIiwgImZmZiIsICJra2siLCAiZ2dnIiwgImhoaCIsICJpaWkiLCAiampqIiB9OwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCB0aGlzLmNvbXBvc2l0ZUxWTS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCBjb29yZExpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCB0aGlzLmNvbXBvc2l0ZUxWTS50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBjb29yZExpc3QudG9BcnJheSgpKSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDcpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCBjb29yZExpc3QuZ2V0KDcpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TW92ZUl0ZW1zX0JlZ2luKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMubHZtMC5tb3ZlKDEsIDAsIDIpOwotCi0JCU9iamVjdFtdIGV4cGVjdGVkID0gbmV3IE9iamVjdFtdIHsgImNjYyIsICJhYWEiLCAiYmJiIiwgImRkZCIsICJlZWUiLCAiZmZmIiwgImdnZyIsICJoaGgiLCAiaWlpIiwgImpqaiIsICJra2siIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoNikpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIGNvb3JkTGlzdC5nZXQoNikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RNb3ZlSXRlbXNfTWlkZGxlKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMubHZtMS5hZGQoImVlZS4xIik7Ci0JCXRoaXMubHZtMS5hZGQoImVlZS4yIik7Ci0JCXRoaXMubHZtMS5hZGQoImVlZS4zIik7Ci0JCXRoaXMubHZtMS5tb3ZlKDEsIDIsIDMpOwotCi0JCU9iamVjdFtdIGV4cGVjdGVkID0gbmV3IE9iamVjdFtdIHsgImFhYSIsICJiYmIiLCAiY2NjIiwgImRkZCIsICJlZWUuMSIsICJlZWUuMiIsICJlZWUuMyIsICJlZWUiLCAiZmZmIiwgImdnZyIsICJoaGgiLCAiaWlpIiwgImpqaiIsICJra2siIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoOSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIGNvb3JkTGlzdC5nZXQoOSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RNb3ZlSXRlbXNfRW5kKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMubHZtMy5tb3ZlKDAsIDIsIDMpOwotCi0JCU9iamVjdFtdIGV4cGVjdGVkID0gbmV3IE9iamVjdFtdIHsgImFhYSIsICJiYmIiLCAiY2NjIiwgImRkZCIsICJlZWUiLCAiZmZmIiwgImlpaSIsICJqamoiLCAia2trIiwgImdnZyIsICJoaGgiIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoOSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIGNvb3JkTGlzdC5nZXQoOSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDbGVhckl0ZW1zX0JlZ2luKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMubHZtMC5jbGVhcigpOwotCi0JCU9iamVjdFtdIGV4cGVjdGVkID0gbmV3IE9iamVjdFtdIHsgImRkZCIsICJlZWUiLCAiZmZmIiwgImdnZyIsICJoaGgiLCAiaWlpIiwgImpqaiIsICJra2siIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoMykpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIGNvb3JkTGlzdC5nZXQoMykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDbGVhckl0ZW1zX01pZGRsZSgpIHsKLQkJQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4gY29vcmRMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KHRoaXMuY29tcG9zaXRlTFZNKTsKLQotCQl0aGlzLmx2bTEuY2xlYXIoKTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJhYWEiLCAiYmJiIiwgImNjYyIsICJmZmYiLCAiZ2dnIiwgImhoaCIsICJpaWkiLCAiampqIiwgImtrayIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCg0KSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgY29vcmRMaXN0LmdldCg0KSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENsZWFySXRlbXNfRW5kKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMubHZtMy5jbGVhcigpOwotCi0JCU9iamVjdFtdIGV4cGVjdGVkID0gbmV3IE9iamVjdFtdIHsgImFhYSIsICJiYmIiLCAiY2NjIiwgImRkZCIsICJlZWUiLCAiZmZmIiB9OwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCB0aGlzLmNvbXBvc2l0ZUxWTS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCBjb29yZExpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCB0aGlzLmNvbXBvc2l0ZUxWTS50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBjb29yZExpc3QudG9BcnJheSgpKSk7Ci0JCWFzc2VydEVxdWFscygiZmZmIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDUpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmZmYiLCBjb29yZExpc3QuZ2V0KDUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2hhbmdlSXRlbXNfQmVnaW4oKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJdGhpcy5sdm0wLnNldExpc3QoQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAieHh4IiwgInl5eSIsICJ6enoiIH0pKTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJ4eHgiLCAieXl5IiwgInp6eiIsICJkZGQiLCAiZWVlIiwgImZmZiIsICJnZ2ciLCAiaGhoIiwgImlpaSIsICJqamoiLCAia2trIiB9OwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCB0aGlzLmNvbXBvc2l0ZUxWTS5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWQubGVuZ3RoLCBjb29yZExpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCB0aGlzLmNvbXBvc2l0ZUxWTS50b0FycmF5KCkpKTsKLQkJYXNzZXJ0VHJ1ZShBcnJheXMuZXF1YWxzKGV4cGVjdGVkLCBjb29yZExpc3QudG9BcnJheSgpKSk7Ci0JCWFzc2VydEVxdWFscygiZ2dnIiwgdGhpcy5jb21wb3NpdGVMVk0uZ2V0KDYpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCBjb29yZExpc3QuZ2V0KDYpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2hhbmdlSXRlbXNfTWlkZGxlKCkgewotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBjb29yZExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5jb21wb3NpdGVMVk0pOwotCi0JCXRoaXMubHZtMS5zZXRMaXN0KEFycmF5cy5hc0xpc3QobmV3IFN0cmluZ1tdIHsgInh4eCIsICJ5eXkiLCAienp6IiB9KSk7Ci0KLQkJT2JqZWN0W10gZXhwZWN0ZWQgPSBuZXcgT2JqZWN0W10geyAiYWFhIiwgImJiYiIsICJjY2MiLCAieHh4IiwgInl5eSIsICJ6enoiLCAiZmZmIiwgImdnZyIsICJoaGgiLCAiaWlpIiwgImpqaiIsICJra2siIH07Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIHRoaXMuY29tcG9zaXRlTFZNLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZC5sZW5ndGgsIGNvb3JkTGlzdC5zaXplKCkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIHRoaXMuY29tcG9zaXRlTFZNLnRvQXJyYXkoKSkpOwotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWQsIGNvb3JkTGlzdC50b0FycmF5KCkpKTsKLQkJYXNzZXJ0RXF1YWxzKCJnZ2ciLCB0aGlzLmNvbXBvc2l0ZUxWTS5nZXQoNykpOwotCQlhc3NlcnRFcXVhbHMoImdnZyIsIGNvb3JkTGlzdC5nZXQoNykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDaGFuZ2VJdGVtc19FbmQoKSB7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IGNvb3JkTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmNvbXBvc2l0ZUxWTSk7Ci0KLQkJdGhpcy5sdm0zLnNldExpc3QoQXJyYXlzLmFzTGlzdChuZXcgU3RyaW5nW10geyAieHh4IiwgInl5eSIsICJ6enoiIH0pKTsKLQotCQlPYmplY3RbXSBleHBlY3RlZCA9IG5ldyBPYmplY3RbXSB7ICJhYWEiLCAiYmJiIiwgImNjYyIsICJkZGQiLCAiZWVlIiwgImZmZiIsICJ4eHgiLCAieXl5IiwgInp6eiIgfTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgdGhpcy5jb21wb3NpdGVMVk0uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmxlbmd0aCwgY29vcmRMaXN0LnNpemUoKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgdGhpcy5jb21wb3NpdGVMVk0udG9BcnJheSgpKSk7Ci0JCWFzc2VydFRydWUoQXJyYXlzLmVxdWFscyhleHBlY3RlZCwgY29vcmRMaXN0LnRvQXJyYXkoKSkpOwotCQlhc3NlcnRFcXVhbHMoImZmZiIsIHRoaXMuY29tcG9zaXRlTFZNLmdldCg1KSk7Ci0JCWFzc2VydEVxdWFscygiZmZmIiwgY29vcmRMaXN0LmdldCg1KSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0Nvb3JkaW5hdGVkQmFnLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0Nvb3JkaW5hdGVkQmFnLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDViZWUzMzcuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Db29yZGluYXRlZEJhZy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTUzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQmFnOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5IYXNoQmFnOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LkNvbGxlY3Rpb25DaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Db2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci0KLS8qKgotICogSGVscGVyIGNsYXNzIHRoYXQga2VlcHMgYW4gaW50ZXJuYWwgY29sbGVjdGlvbiBpbiBzeW5jaCB3aXRoIHRoZQotICogY29sbGVjdGlvbiBoZWxkIGJ5IGEgY29sbGVjdGlvbiB2YWx1ZSBtb2RlbC4KLSAqLwotY2xhc3MgQ29vcmRpbmF0ZWRCYWc8RT4gaW1wbGVtZW50cyBCYWc8RT4sIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciB7Ci0KLQlwcml2YXRlIEJhZzxFPiBiYWcgPSBuZXcgSGFzaEJhZzxFPigpOwotCi0JQ29vcmRpbmF0ZWRCYWcoQ29sbGVjdGlvblZhbHVlTW9kZWw8RT4gY3ZtKSB7Ci0JCWN2bS5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCB0aGlzKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogQ29sbGVjdGlvbiBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgYm9vbGVhbiBhZGQoRSBvKSB7Ci0JCXJldHVybiB0aGlzLmJhZy5hZGQobyk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gYWRkQWxsKENvbGxlY3Rpb248PyBleHRlbmRzIEU+IGMpIHsKLQkJcmV0dXJuIHRoaXMuYmFnLmFkZEFsbChjKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBjbGVhcigpIHsKLQkJdGhpcy5iYWcuY2xlYXIoKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBjb250YWlucyhPYmplY3QgbykgewotCQlyZXR1cm4gdGhpcy5iYWcuY29udGFpbnMobyk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gY29udGFpbnNBbGwoQ29sbGVjdGlvbjw/PiBjKSB7Ci0JCXJldHVybiB0aGlzLmJhZy5jb250YWluc0FsbChjKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBpc0VtcHR5KCkgewotCQlyZXR1cm4gdGhpcy5iYWcuaXNFbXB0eSgpOwotCX0KLQotCXB1YmxpYyBJdGVyYXRvcjxFPiBpdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMuYmFnLml0ZXJhdG9yKCk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gcmVtb3ZlKE9iamVjdCBvKSB7Ci0JCXJldHVybiB0aGlzLmJhZy5yZW1vdmUobyk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gcmVtb3ZlQWxsKENvbGxlY3Rpb248Pz4gYykgewotCQlyZXR1cm4gdGhpcy5iYWcucmVtb3ZlQWxsKGMpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIHJldGFpbkFsbChDb2xsZWN0aW9uPD8+IGMpIHsKLQkJcmV0dXJuIHRoaXMuYmFnLnJldGFpbkFsbChjKTsKLQl9Ci0KLQlwdWJsaWMgaW50IHNpemUoKSB7Ci0JCXJldHVybiB0aGlzLmJhZy5zaXplKCk7Ci0JfQotCi0JcHVibGljIE9iamVjdFtdIHRvQXJyYXkoKSB7Ci0JCXJldHVybiB0aGlzLmJhZy50b0FycmF5KCk7Ci0JfQotCi0JcHVibGljIDxUPiBUW10gdG9BcnJheShUW10gYSkgewotCQlyZXR1cm4gdGhpcy5iYWcudG9BcnJheShhKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogQmFnIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCXB1YmxpYyBpbnQgY291bnQoT2JqZWN0IG8pIHsKLQkJcmV0dXJuIHRoaXMuYmFnLmNvdW50KG8pOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGFkZChFIG8sIGludCBjb3VudCkgewotCQlyZXR1cm4gdGhpcy5iYWcuYWRkKG8sIGNvdW50KTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiByZW1vdmUoT2JqZWN0IG8sIGludCBjb3VudCkgewotCQlyZXR1cm4gdGhpcy5iYWcucmVtb3ZlKG8sIGNvdW50KTsKLQl9Ci0KLQlwdWJsaWMgSXRlcmF0b3I8RT4gdW5pcXVlSXRlcmF0b3IoKSB7Ci0JCXJldHVybiB0aGlzLmJhZy51bmlxdWVJdGVyYXRvcigpOwotCX0KLQotCXB1YmxpYyBJdGVyYXRvcjxCYWcuRW50cnk8RT4+IGVudHJpZXMoKSB7Ci0JCXJldHVybiB0aGlzLmJhZy5lbnRyaWVzKCk7Ci0JfQotCi0JLy8gKioqKioqKioqKiBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIHZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQlmb3IgKEBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKSBJdGVyYXRvcjxFPiBzdHJlYW0gPSAoSXRlcmF0b3I8RT4pIGUuaXRlbXMoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQl0aGlzLmJhZy5hZGQoc3RyZWFtLm5leHQoKSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCBpdGVtc1JlbW92ZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJZm9yIChAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikgSXRlcmF0b3I8RT4gc3RyZWFtID0gKEl0ZXJhdG9yPEU+KSBlLml0ZW1zKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJdGhpcy5iYWcucmVtb3ZlKHN0cmVhbS5uZXh0KCkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgY29sbGVjdGlvbkNsZWFyZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJdGhpcy5iYWcuY2xlYXIoKTsKLQl9Ci0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwdWJsaWMgdm9pZCBjb2xsZWN0aW9uQ2hhbmdlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQl0aGlzLmJhZy5jbGVhcigpOwotCQlDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKHRoaXMuYmFnLCAoKENvbGxlY3Rpb25WYWx1ZU1vZGVsPEU+KSBlLmdldFNvdXJjZSgpKS5pdGVyYXRvcigpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogc3RhbmRhcmQgbWV0aG9kcyAqKioqKioqKioqCi0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgYm9vbGVhbiBlcXVhbHMoT2JqZWN0IG8pIHsKLQkJcmV0dXJuIHRoaXMuYmFnLmVxdWFscyhvKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgaW50IGhhc2hDb2RlKCkgewotCQlyZXR1cm4gdGhpcy5iYWcuaGFzaENvZGUoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gdGhpcy5iYWcudG9TdHJpbmcoKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ29vcmRpbmF0ZWRMaXN0LmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0Nvb3JkaW5hdGVkTGlzdC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxM2Y5MjY3Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvQ29vcmRpbmF0ZWRMaXN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyNTQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgamF2YXguc3dpbmcuTGlzdE1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50Lkxpc3REYXRhRXZlbnQ7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuTGlzdERhdGFMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuTGlzdENoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkxpc3RDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBIZWxwZXIgY2xhc3MgdGhhdCBrZWVwcyBhbiBpbnRlcm5hbCBsaXN0IGluIHN5bmNoIHdpdGggdGhlCi0gKiBsaXN0IGhlbGQgYnkgYSBsaXN0IHZhbHVlIG1vZGVsLgotICovCi1wdWJsaWMgY2xhc3MgQ29vcmRpbmF0ZWRMaXN0PEU+IGltcGxlbWVudHMgTGlzdDxFPiwgTGlzdENoYW5nZUxpc3RlbmVyLCBMaXN0RGF0YUxpc3RlbmVyIHsKLQlwcml2YXRlIExpc3Q8RT4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8RT4oKTsKLQotCXB1YmxpYyBDb29yZGluYXRlZExpc3QoTGlzdFZhbHVlTW9kZWw8RT4gbGlzdFZhbHVlTW9kZWwpIHsKLQkJbGlzdFZhbHVlTW9kZWwuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzKTsKLQkJZm9yIChJdGVyYXRvcjxFPiBzdHJlYW0gPSBsaXN0VmFsdWVNb2RlbC5pdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCXRoaXMuYWRkKHN0cmVhbS5uZXh0KCkpOwotCQl9Ci0JfQotCi0JcHVibGljIENvb3JkaW5hdGVkTGlzdChMaXN0TW9kZWwgbGlzdE1vZGVsKSB7Ci0JCWxpc3RNb2RlbC5hZGRMaXN0RGF0YUxpc3RlbmVyKHRoaXMpOwotCQlmb3IgKGludCBpID0gMDsgaSA8IGxpc3RNb2RlbC5nZXRTaXplKCk7IGkrKykgewotCQkJdGhpcy5hZGQoaSwgdGhpcy5nZXRFbGVtZW50QXQobGlzdE1vZGVsLCBpKSk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogTGlzdCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQlwdWJsaWMgdm9pZCBhZGQoaW50IGluZGV4LCBFIGVsZW1lbnQpIHsKLQkJdGhpcy5saXN0LmFkZChpbmRleCwgZWxlbWVudCk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gYWRkKEUgbykgewotCQlyZXR1cm4gdGhpcy5saXN0LmFkZChvKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBhZGRBbGwoQ29sbGVjdGlvbjw/IGV4dGVuZHMgRT4gYykgewotCQlyZXR1cm4gdGhpcy5saXN0LmFkZEFsbChjKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBhZGRBbGwoaW50IGluZGV4LCBDb2xsZWN0aW9uPD8gZXh0ZW5kcyBFPiBjKSB7Ci0JCXJldHVybiB0aGlzLmxpc3QuYWRkQWxsKGluZGV4LCBjKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCBjbGVhcigpIHsKLQkJdGhpcy5saXN0LmNsZWFyKCk7Ci0JfQotCi0JcHVibGljIGJvb2xlYW4gY29udGFpbnMoT2JqZWN0IG8pIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5jb250YWlucyhvKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiBjb250YWluc0FsbChDb2xsZWN0aW9uPD8+IGMpIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5jb250YWluc0FsbChjKTsKLQl9Ci0KLQlwdWJsaWMgRSBnZXQoaW50IGluZGV4KSB7Ci0JCXJldHVybiB0aGlzLmxpc3QuZ2V0KGluZGV4KTsKLQl9Ci0KLQlwdWJsaWMgaW50IGluZGV4T2YoT2JqZWN0IG8pIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5pbmRleE9mKG8pOwotCX0KLQotCXB1YmxpYyBib29sZWFuIGlzRW1wdHkoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3QuaXNFbXB0eSgpOwotCX0KLQotCXB1YmxpYyBJdGVyYXRvcjxFPiBpdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5pdGVyYXRvcigpOwotCX0KLQotCXB1YmxpYyBpbnQgbGFzdEluZGV4T2YoT2JqZWN0IG8pIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5sYXN0SW5kZXhPZihvKTsKLQl9Ci0KLQlwdWJsaWMgTGlzdEl0ZXJhdG9yPEU+IGxpc3RJdGVyYXRvcigpIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5saXN0SXRlcmF0b3IoKTsKLQl9Ci0KLQlwdWJsaWMgTGlzdEl0ZXJhdG9yPEU+IGxpc3RJdGVyYXRvcihpbnQgaW5kZXgpIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5saXN0SXRlcmF0b3IoaW5kZXgpOwotCX0KLQotCXB1YmxpYyBFIHJlbW92ZShpbnQgaW5kZXgpIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5yZW1vdmUoaW5kZXgpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIHJlbW92ZShPYmplY3QgbykgewotCQlyZXR1cm4gdGhpcy5saXN0LnJlbW92ZShvKTsKLQl9Ci0KLQlwdWJsaWMgYm9vbGVhbiByZW1vdmVBbGwoQ29sbGVjdGlvbjw/PiBjKSB7Ci0JCXJldHVybiB0aGlzLmxpc3QucmVtb3ZlQWxsKGMpOwotCX0KLQotCXB1YmxpYyBib29sZWFuIHJldGFpbkFsbChDb2xsZWN0aW9uPD8+IGMpIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5yZXRhaW5BbGwoYyk7Ci0JfQotCi0JcHVibGljIEUgc2V0KGludCBpbmRleCwgRSBlbGVtZW50KSB7Ci0JCXJldHVybiB0aGlzLmxpc3Quc2V0KGluZGV4LCBlbGVtZW50KTsKLQl9Ci0KLQlwdWJsaWMgaW50IHNpemUoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3Quc2l6ZSgpOwotCX0KLQotCXB1YmxpYyBMaXN0PEU+IHN1Ykxpc3QoaW50IGZyb21JbmRleCwgaW50IHRvSW5kZXgpIHsKLQkJcmV0dXJuIHRoaXMubGlzdC5zdWJMaXN0KGZyb21JbmRleCwgdG9JbmRleCk7Ci0JfQotCi0JcHVibGljIE9iamVjdFtdIHRvQXJyYXkoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3QudG9BcnJheSgpOwotCX0KLQotCXB1YmxpYyA8VD4gVFtdIHRvQXJyYXkoVFtdIGEpIHsKLQkJcmV0dXJuIHRoaXMubGlzdC50b0FycmF5KGEpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBMaXN0Q2hhbmdlTGlzdGVuZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQlpbnQgaSA9IGUuZ2V0SW5kZXgoKTsKLQkJZm9yIChJdGVyYXRvcjxFPiBzdHJlYW0gPSB0aGlzLml0ZW1zKGUpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCXRoaXMubGlzdC5hZGQoaSsrLCBzdHJlYW0ubmV4dCgpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQlpbnQgaSA9IGUuZ2V0SW5kZXgoKTsKLQkJZm9yIChJdGVyYXRvcjxFPiBzdHJlYW0gPSB0aGlzLml0ZW1zKGUpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCXN0cmVhbS5uZXh0KCk7Ci0JCQl0aGlzLmxpc3QucmVtb3ZlKGkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgaXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQlpbnQgaSA9IGUuZ2V0SW5kZXgoKTsKLQkJZm9yIChJdGVyYXRvcjxFPiBzdHJlYW0gPSB0aGlzLml0ZW1zKGUpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCXRoaXMubGlzdC5zZXQoaSsrLCBzdHJlYW0ubmV4dCgpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIGl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJQ29sbGVjdGlvblRvb2xzLm1vdmUodGhpcy5saXN0LCBlLmdldFRhcmdldEluZGV4KCksIGUuZ2V0U291cmNlSW5kZXgoKSwgZS5nZXRNb3ZlTGVuZ3RoKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIGxpc3RDbGVhcmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCXRoaXMubGlzdC5jbGVhcigpOwotCX0KLQotCXB1YmxpYyB2b2lkIGxpc3RDaGFuZ2VkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCXRoaXMubGlzdC5jbGVhcigpOwotCQlDb2xsZWN0aW9uVG9vbHMuYWRkQWxsKHRoaXMubGlzdCwgdGhpcy5nZXRTb3VyY2UoZSkuaXRlcmF0b3IoKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIExpc3REYXRhTGlzdGVuZXIgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JcHVibGljIHZvaWQgY29udGVudHNDaGFuZ2VkKExpc3REYXRhRXZlbnQgZSkgewotCQl0aGlzLmxpc3QuY2xlYXIoKTsKLQkJTGlzdE1vZGVsIGxtID0gKExpc3RNb2RlbCkgZS5nZXRTb3VyY2UoKTsKLQkJaW50IHNpemUgPSBsbS5nZXRTaXplKCk7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgc2l6ZTsgaSsrKSB7Ci0JCQl0aGlzLmxpc3QuYWRkKGksIHRoaXMuZ2V0RWxlbWVudEF0KGxtLCBpKSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCBpbnRlcnZhbEFkZGVkKExpc3REYXRhRXZlbnQgZSkgewotCQlMaXN0TW9kZWwgbG0gPSAoTGlzdE1vZGVsKSBlLmdldFNvdXJjZSgpOwotCQlpbnQgc3RhcnQgPSBNYXRoLm1pbihlLmdldEluZGV4MCgpLCBlLmdldEluZGV4MSgpKTsKLQkJaW50IGVuZCA9IE1hdGgubWF4KGUuZ2V0SW5kZXgwKCksIGUuZ2V0SW5kZXgxKCkpOwotCQlmb3IgKGludCBpID0gc3RhcnQ7IGkgPD0gZW5kOyBpKyspIHsKLQkJCXRoaXMubGlzdC5hZGQoaSwgdGhpcy5nZXRFbGVtZW50QXQobG0sIGkpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIGludGVydmFsUmVtb3ZlZChMaXN0RGF0YUV2ZW50IGUpIHsKLQkJaW50IHN0YXJ0ID0gTWF0aC5taW4oZS5nZXRJbmRleDAoKSwgZS5nZXRJbmRleDEoKSk7Ci0JCWludCBlbmQgPSBNYXRoLm1heChlLmdldEluZGV4MCgpLCBlLmdldEluZGV4MSgpKTsKLQkJaW50IGxlbmd0aCA9IGVuZCAtIHN0YXJ0ICsgMTsKLQkJZm9yIChpbnQgaSA9IDE7IGkgPD0gbGVuZ3RoOyBpKyspIHsKLQkJCXRoaXMubGlzdC5yZW1vdmUoc3RhcnQpOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHN0YW5kYXJkIG1ldGhvZHMgKioqKioqKioqKgotCi0gICAgQE92ZXJyaWRlCi0JcHVibGljIGJvb2xlYW4gZXF1YWxzKE9iamVjdCBvKSB7Ci0JCXJldHVybiB0aGlzLmxpc3QuZXF1YWxzKG8pOwotCX0KLQotICAgIEBPdmVycmlkZQotCXB1YmxpYyBpbnQgaGFzaENvZGUoKSB7Ci0JCXJldHVybiB0aGlzLmxpc3QuaGFzaENvZGUoKTsKLQl9Ci0KLSAgICBAT3ZlcnJpZGUKLQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQlyZXR1cm4gdGhpcy5saXN0LnRvU3RyaW5nKCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGludGVybmFsIG1ldGhvZHMgKioqKioqKioqKgotCi0JLyoqCi0JICogbWluaW1pemUgdGhlIHNjb3BlIG9mIHRoZSBzdXBwcmVzc2VkIHdhcm5pbmdzLj0KLQkgKi8KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLQlwcml2YXRlIEUgZ2V0RWxlbWVudEF0KExpc3RNb2RlbCBsaXN0TW9kZWwsIGludCBpbmRleCkgewotCQlyZXR1cm4gKEUpIGxpc3RNb2RlbC5nZXRFbGVtZW50QXQoaW5kZXgpOwotCX0KLQotCS8qKgotCSAqIG1pbmltaXplIHRoZSBzY29wZSBvZiB0aGUgc3VwcHJlc3NlZCB3YXJuaW5ncy49Ci0JICovCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JcHJpdmF0ZSBJdGVyYXRvcjxFPiBpdGVtcyhMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJcmV0dXJuIChJdGVyYXRvcjxFPikgZXZlbnQuaXRlbXMoKTsKLQl9Ci0KLQkvKioKLQkgKiBtaW5pbWl6ZSB0aGUgc2NvcGUgb2YgdGhlIHN1cHByZXNzZWQgd2FybmluZ3MuPQotCSAqLwotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8RT4gZ2V0U291cmNlKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQlyZXR1cm4gKExpc3RWYWx1ZU1vZGVsPEU+KSBldmVudC5nZXRTb3VyY2UoKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvRXh0ZW5kZWRMaXN0VmFsdWVNb2RlbFdyYXBwZXJUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9FeHRlbmRlZExpc3RWYWx1ZU1vZGVsV3JhcHBlclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDI4NjZlOWEuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9FeHRlbmRlZExpc3RWYWx1ZU1vZGVsV3JhcHBlclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyOTIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5FeHRlbmRlZExpc3RWYWx1ZU1vZGVsV3JhcHBlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVMaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5MaXN0Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuTGlzdENoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIEV4dGVuZGVkTGlzdFZhbHVlTW9kZWxXcmFwcGVyVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGxpc3RIb2xkZXI7Ci0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGV4dGVuZGVkTGlzdEhvbGRlcjsKLQlMaXN0Q2hhbmdlRXZlbnQgZXZlbnQ7Ci0JU3RyaW5nIGV2ZW50VHlwZTsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBBREQgPSAiYWRkIjsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgUkVNT1ZFID0gInJlbW92ZSI7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIFJFUExBQ0UgPSAicmVwbGFjZSI7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIE1PVkUgPSAibW92ZSI7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIENMRUFSID0gImNsZWFyIjsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQ0hBTkdFID0gImNoYW5nZSI7Ci0KLQlwdWJsaWMgRXh0ZW5kZWRMaXN0VmFsdWVNb2RlbFdyYXBwZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLmxpc3RIb2xkZXIgPSBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPih0aGlzLmJ1aWxkTGlzdCgpKTsKLQkJdGhpcy5leHRlbmRlZExpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkRXh0ZW5kZWRMaXN0SG9sZGVyKHRoaXMubGlzdEhvbGRlcik7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0PFN0cmluZz4gYnVpbGRMaXN0KCkgewotCQlMaXN0PFN0cmluZz4gcmVzdWx0ID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCXJlc3VsdC5hZGQoIkEiKTsKLQkJcmVzdWx0LmFkZCgiQiIpOwotCQlyZXN1bHQuYWRkKCJDIik7Ci0JCXJlc3VsdC5hZGQoIkQiKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBidWlsZEV4dGVuZGVkTGlzdCgpIHsKLQkJTGlzdDxTdHJpbmc+IGV4dGVuZGVkTGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlleHRlbmRlZExpc3QuYWRkQWxsKHRoaXMuYnVpbGRQcmVmaXgoKSk7Ci0JCWV4dGVuZGVkTGlzdC5hZGRBbGwodGhpcy5idWlsZExpc3QoKSk7Ci0JCWV4dGVuZGVkTGlzdC5hZGRBbGwodGhpcy5idWlsZFN1ZmZpeCgpKTsKLQkJcmV0dXJuIGV4dGVuZGVkTGlzdDsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBidWlsZFByZWZpeCgpIHsKLQkJTGlzdDxTdHJpbmc+IHByZWZpeCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlwcmVmaXguYWRkKCJ4Iik7Ci0JCXByZWZpeC5hZGQoInkiKTsKLQkJcHJlZml4LmFkZCgieiIpOwotCQlyZXR1cm4gcHJlZml4OwotCX0KLQotCXByaXZhdGUgTGlzdDxTdHJpbmc+IGJ1aWxkU3VmZml4KCkgewotCQlMaXN0PFN0cmluZz4gc3VmZml4ID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCXN1ZmZpeC5hZGQoImkiKTsKLQkJc3VmZml4LmFkZCgiaiIpOwotCQlyZXR1cm4gc3VmZml4OwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZEV4dGVuZGVkTGlzdEhvbGRlcihMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGx2bSkgewotCQlyZXR1cm4gbmV3IEV4dGVuZGVkTGlzdFZhbHVlTW9kZWxXcmFwcGVyPFN0cmluZz4odGhpcy5idWlsZFByZWZpeCgpLCBsdm0sIHRoaXMuYnVpbGRTdWZmaXgoKSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVyYXRvcigpIHsKLQkJdGhpcy5leHRlbmRlZExpc3RIb2xkZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmJ1aWxkTGlzdGVuZXIoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkRXh0ZW5kZWRMaXN0KCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuZXh0ZW5kZWRMaXN0SG9sZGVyLml0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2l6ZSgpIHsKLQkJdGhpcy5leHRlbmRlZExpc3RIb2xkZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmJ1aWxkTGlzdGVuZXIoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkRXh0ZW5kZWRMaXN0KCkuc2l6ZSgpLCBDb2xsZWN0aW9uVG9vbHMuc2l6ZSh0aGlzLmV4dGVuZGVkTGlzdEhvbGRlci5pdGVyYXRvcigpKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkRXh0ZW5kZWRMaXN0KCkuc2l6ZSgpLCB0aGlzLmV4dGVuZGVkTGlzdEhvbGRlci5zaXplKCkpOwotCX0KLQotCXByaXZhdGUgYm9vbGVhbiBleHRlbmRlZExpc3RDb250YWlucyhPYmplY3QgaXRlbSkgewotCQlyZXR1cm4gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZXh0ZW5kZWRMaXN0SG9sZGVyLml0ZXJhdG9yKCksIGl0ZW0pOwotCX0KLQotCXByaXZhdGUgYm9vbGVhbiBleHRlbmRlZExpc3RDb250YWluc0FsbChDb2xsZWN0aW9uPFN0cmluZz4gaXRlbXMpIHsKLQkJcmV0dXJuIENvbGxlY3Rpb25Ub29scy5jb250YWluc0FsbCh0aGlzLmV4dGVuZGVkTGlzdEhvbGRlci5pdGVyYXRvcigpLCBpdGVtcyk7Ci0JfQotCi0JcHJpdmF0ZSBib29sZWFuIGV4dGVuZGVkTGlzdENvbnRhaW5zQW55KENvbGxlY3Rpb248U3RyaW5nPiBpdGVtcykgewotCQlMaXN0PFN0cmluZz4gZXh0ZW5kZWRMaXN0ID0gQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5leHRlbmRlZExpc3RIb2xkZXIuaXRlcmF0b3IoKSk7Ci0JCWZvciAoSXRlcmF0b3I8U3RyaW5nPiBzdHJlYW0gPSBpdGVtcy5pdGVyYXRvcigpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCWlmIChleHRlbmRlZExpc3QuY29udGFpbnMoc3RyZWFtLm5leHQoKSkpIHsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JcHJpdmF0ZSBib29sZWFuIGxpc3RDb250YWlucyhPYmplY3QgaXRlbSkgewotCQlyZXR1cm4gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMubGlzdEhvbGRlci5pdGVyYXRvcigpLCBpdGVtKTsKLQl9Ci0KLQlwcml2YXRlIGJvb2xlYW4gbGlzdENvbnRhaW5zQWxsKENvbGxlY3Rpb248U3RyaW5nPiBpdGVtcykgewotCQlyZXR1cm4gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKHRoaXMubGlzdEhvbGRlci5pdGVyYXRvcigpLCBpdGVtcyk7Ci0JfQotCi0vLwlwcml2YXRlIGJvb2xlYW4gbGlzdENvbnRhaW5zQW55KENvbGxlY3Rpb248U3RyaW5nPiBpdGVtcykgewotLy8JCUxpc3Q8U3RyaW5nPiBleHRlbmRlZExpc3QgPSBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmxpc3RIb2xkZXIuaXRlcmF0b3IoKSk7Ci0vLwkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbSA9IGl0ZW1zLml0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotLy8JCQlpZiAoZXh0ZW5kZWRMaXN0LmNvbnRhaW5zKHN0cmVhbS5uZXh0KCkpKSB7Ci0vLwkJCQlyZXR1cm4gdHJ1ZTsKLS8vCQkJfQotLy8JCX0KLS8vCQlyZXR1cm4gZmFsc2U7Ci0vLwl9Ci0vLwotCXB1YmxpYyB2b2lkIHRlc3RBZGQxKCkgewotCQl0aGlzLmV4dGVuZGVkTGlzdEhvbGRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMuYnVpbGRMaXN0ZW5lcigpKTsKLQotCQlhc3NlcnRGYWxzZSh0aGlzLmV4dGVuZGVkTGlzdENvbnRhaW5zKCJFIikpOwotCQl0aGlzLmxpc3RIb2xkZXIuYWRkKDQsICJFIik7Ci0JCWFzc2VydFRydWUodGhpcy5leHRlbmRlZExpc3RDb250YWlucygiRSIpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmxpc3RDb250YWlucygiRSIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkMigpIHsKLQkJdGhpcy5leHRlbmRlZExpc3RIb2xkZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmJ1aWxkTGlzdGVuZXIoKSk7Ci0KLQkJYXNzZXJ0RmFsc2UodGhpcy5leHRlbmRlZExpc3RDb250YWlucyhudWxsKSk7Ci0JCXRoaXMubGlzdEhvbGRlci5hZGQoNCwgbnVsbCk7Ci0JCWFzc2VydFRydWUodGhpcy5leHRlbmRlZExpc3RDb250YWlucyhudWxsKSk7Ci0JCWFzc2VydFRydWUodGhpcy5saXN0Q29udGFpbnMobnVsbCkpOwotCX0KLQotCXByaXZhdGUgTGlzdDxTdHJpbmc+IGJ1aWxkQWRkTGlzdCgpIHsKLQkJTGlzdDxTdHJpbmc+IGFkZExpc3QgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJYWRkTGlzdC5hZGQoIkUiKTsKLQkJYWRkTGlzdC5hZGQoIkYiKTsKLQkJcmV0dXJuIGFkZExpc3Q7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbDEoKSB7Ci0JCXRoaXMuZXh0ZW5kZWRMaXN0SG9sZGVyLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5idWlsZExpc3RlbmVyKCkpOwotCi0JCWFzc2VydEZhbHNlKHRoaXMuZXh0ZW5kZWRMaXN0Q29udGFpbnNBbnkodGhpcy5idWlsZEFkZExpc3QoKSkpOwotCQl0aGlzLmxpc3RIb2xkZXIuYWRkQWxsKDQsIHRoaXMuYnVpbGRBZGRMaXN0KCkpOwotCQlhc3NlcnRUcnVlKHRoaXMuZXh0ZW5kZWRMaXN0Q29udGFpbnNBbGwodGhpcy5idWlsZEFkZExpc3QoKSkpOwotCQlhc3NlcnRUcnVlKHRoaXMubGlzdENvbnRhaW5zQWxsKHRoaXMuYnVpbGRBZGRMaXN0KCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlMSgpIHsKLQkJdGhpcy5leHRlbmRlZExpc3RIb2xkZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmJ1aWxkTGlzdGVuZXIoKSk7Ci0KLQkJYXNzZXJ0VHJ1ZSh0aGlzLmV4dGVuZGVkTGlzdENvbnRhaW5zKCJCIikpOwotCQl0aGlzLmxpc3RIb2xkZXIucmVtb3ZlKHRoaXMuYnVpbGRMaXN0KCkuaW5kZXhPZigiQiIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5leHRlbmRlZExpc3RDb250YWlucygiQiIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5saXN0Q29udGFpbnMoIkIiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RDaGFuZ2VHZW5lcmljKCkgewotCQl0aGlzLmV4dGVuZGVkTGlzdEhvbGRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZExpc3RlbmVyKCkpOwotCQl0aGlzLnZlcmlmeUxpc3RDaGFuZ2UoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdENoYW5nZU5hbWVkKCkgewotCQl0aGlzLmV4dGVuZGVkTGlzdEhvbGRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMuYnVpbGRMaXN0ZW5lcigpKTsKLQkJdGhpcy52ZXJpZnlMaXN0Q2hhbmdlKCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUxpc3RDaGFuZ2UoKSB7Ci0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLmV2ZW50VHlwZSA9IG51bGw7Ci0JCXRoaXMubGlzdEhvbGRlci5hZGQoNCwgIkUiKTsKLQkJdGhpcy52ZXJpZnlFdmVudChBREQsIDcsICJFIik7Ci0KLQkJdGhpcy5ldmVudCA9IG51bGw7Ci0JCXRoaXMuZXZlbnRUeXBlID0gbnVsbDsKLQkJdGhpcy5saXN0SG9sZGVyLmFkZCg1LCBudWxsKTsKLQkJdGhpcy52ZXJpZnlFdmVudChBREQsIDgsIG51bGwpOwotCi0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLmV2ZW50VHlwZSA9IG51bGw7Ci0JCXRoaXMubGlzdEhvbGRlci5yZW1vdmUoNSk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQoUkVNT1ZFLCA4LCBudWxsKTsKLQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy5ldmVudFR5cGUgPSBudWxsOwotCQl0aGlzLmxpc3RIb2xkZXIucmVtb3ZlKDQpOwotCQl0aGlzLnZlcmlmeUV2ZW50KFJFTU9WRSwgNywgIkUiKTsKLQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy5ldmVudFR5cGUgPSBudWxsOwotCQl0aGlzLmxpc3RIb2xkZXIuYWRkQWxsKDAsIHRoaXMuYnVpbGRMaXN0KCkpOwotCQl0aGlzLnZlcmlmeUV2ZW50KEFERCk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkTGlzdCgpLCBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmV2ZW50Lml0ZW1zKCkpKTsKLQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy5ldmVudFR5cGUgPSBudWxsOwotCQl0aGlzLmxpc3RIb2xkZXIuc2V0KDAsICJBQSIpOwotCQl0aGlzLnZlcmlmeUV2ZW50KFJFUExBQ0UpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5ldmVudC5pdGVtcygpLCAiQSIpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5ldmVudC5pdGVtcygpLCAiQUEiKSk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0Q2hhbmdlTGlzdGVuZXIgYnVpbGRMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBMaXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJRXh0ZW5kZWRMaXN0VmFsdWVNb2RlbFdyYXBwZXJUZXN0cy50aGlzLmV2ZW50VHlwZSA9IEFERDsKLQkJCQlFeHRlbmRlZExpc3RWYWx1ZU1vZGVsV3JhcHBlclRlc3RzLnRoaXMuZXZlbnQgPSBlOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJRXh0ZW5kZWRMaXN0VmFsdWVNb2RlbFdyYXBwZXJUZXN0cy50aGlzLmV2ZW50VHlwZSA9IFJFTU9WRTsKLQkJCQlFeHRlbmRlZExpc3RWYWx1ZU1vZGVsV3JhcHBlclRlc3RzLnRoaXMuZXZlbnQgPSBlOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJCUV4dGVuZGVkTGlzdFZhbHVlTW9kZWxXcmFwcGVyVGVzdHMudGhpcy5ldmVudFR5cGUgPSBSRVBMQUNFOwotCQkJCUV4dGVuZGVkTGlzdFZhbHVlTW9kZWxXcmFwcGVyVGVzdHMudGhpcy5ldmVudCA9IGU7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc01vdmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJRXh0ZW5kZWRMaXN0VmFsdWVNb2RlbFdyYXBwZXJUZXN0cy50aGlzLmV2ZW50VHlwZSA9IE1PVkU7Ci0JCQkJRXh0ZW5kZWRMaXN0VmFsdWVNb2RlbFdyYXBwZXJUZXN0cy50aGlzLmV2ZW50ID0gZTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGxpc3RDbGVhcmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJRXh0ZW5kZWRMaXN0VmFsdWVNb2RlbFdyYXBwZXJUZXN0cy50aGlzLmV2ZW50VHlwZSA9IENMRUFSOwotCQkJCUV4dGVuZGVkTGlzdFZhbHVlTW9kZWxXcmFwcGVyVGVzdHMudGhpcy5ldmVudCA9IGU7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBsaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJCUV4dGVuZGVkTGlzdFZhbHVlTW9kZWxXcmFwcGVyVGVzdHMudGhpcy5ldmVudFR5cGUgPSBDSEFOR0U7Ci0JCQkJRXh0ZW5kZWRMaXN0VmFsdWVNb2RlbFdyYXBwZXJUZXN0cy50aGlzLmV2ZW50ID0gZTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5RXZlbnQoU3RyaW5nIHR5cGUpIHsKLQkJYXNzZXJ0RXF1YWxzKHR5cGUsIHRoaXMuZXZlbnRUeXBlKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuZXh0ZW5kZWRMaXN0SG9sZGVyLCB0aGlzLmV2ZW50LmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmV2ZW50LmdldExpc3ROYW1lKCkpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlFdmVudChTdHJpbmcgdHlwZSwgaW50IGluZGV4LCBPYmplY3QgaXRlbSkgewotCQl0aGlzLnZlcmlmeUV2ZW50KHR5cGUpOwotCQlhc3NlcnRFcXVhbHMoaW5kZXgsIHRoaXMuZXZlbnQuZ2V0SW5kZXgoKSk7Ci0JCWFzc2VydEVxdWFscyhpdGVtLCB0aGlzLmV2ZW50Lml0ZW1zKCkubmV4dCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgewotCQkvKgotCQkgKiBhZGRpbmcgbGlzdGVuZXJzIHRvIHRoZSBleHRlbmRlZCBsaXN0IHdpbGwgY2F1c2UgbGlzdGVuZXJzCi0JCSAqIHRvIGJlIGFkZGVkIHRvIHRoZSB3cmFwcGVkIGxpc3Q7Ci0JCSAqIGxpa2V3aXNlLCByZW1vdmluZyBsaXN0ZW5lcnMgZnJvbSB0aGUgZXh0ZW5kZWQgbGlzdCB3aWxsCi0JCSAqIGNhdXNlIGxpc3RlbmVycyB0byBiZSByZW1vdmVkIGZyb20gdGhlIHdyYXBwZWQgbGlzdAotCQkgKi8KLQkJYXNzZXJ0RmFsc2UoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmxpc3RIb2xkZXIpLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQotCQlMaXN0Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSB0aGlzLmJ1aWxkTGlzdGVuZXIoKTsKLQotCQl0aGlzLmV4dGVuZGVkTGlzdEhvbGRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIGxpc3RlbmVyKTsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMubGlzdEhvbGRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCi0JCXRoaXMuZXh0ZW5kZWRMaXN0SG9sZGVyLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgbGlzdGVuZXIpOwotCQlhc3NlcnRGYWxzZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMubGlzdEhvbGRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCi0JCXRoaXMuZXh0ZW5kZWRMaXN0SG9sZGVyLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmxpc3RIb2xkZXIpLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQotCQl0aGlzLmV4dGVuZGVkTGlzdEhvbGRlci5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRGYWxzZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMubGlzdEhvbGRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9GaWx0ZXJpbmdDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0ZpbHRlcmluZ0NvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOWVjZWJhMS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0ZpbHRlcmluZ0NvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI4NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5WZWN0b3I7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LkZpbHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5GaWx0ZXJpbmdDb2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Db2xsZWN0aW9uQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIEZpbHRlcmluZ0NvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+IGNvbGxlY3Rpb25Ib2xkZXI7Ci0JQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGFkZEV2ZW50OwotCUNvbGxlY3Rpb25DaGFuZ2VFdmVudCByZW1vdmVFdmVudDsKLQlDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgY29sbGVjdGlvbkNsZWFyZWRFdmVudDsKLQlDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgY29sbGVjdGlvbkNoYW5nZWRFdmVudDsKLQotCXByaXZhdGUgQ29sbGVjdGlvblZhbHVlTW9kZWw8U3RyaW5nPiBmaWx0ZXJlZENvbGxlY3Rpb25Ib2xkZXI7Ci0JQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGZpbHRlcmVkQWRkRXZlbnQ7Ci0JQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGZpbHRlcmVkUmVtb3ZlRXZlbnQ7Ci0JQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGZpbHRlcmVkQ29sbGVjdGlvbkNsZWFyZWRFdmVudDsKLQlDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZmlsdGVyZWRDb2xsZWN0aW9uQ2hhbmdlZEV2ZW50OwotCi0JcHVibGljIEZpbHRlcmluZ0NvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy5jb2xsZWN0aW9uSG9sZGVyID0gbmV3IFNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4oYnVpbGRDb2xsZWN0aW9uKCkpOwotCQl0aGlzLmZpbHRlcmVkQ29sbGVjdGlvbkhvbGRlciA9IG5ldyBGaWx0ZXJpbmdDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+KHRoaXMuY29sbGVjdGlvbkhvbGRlciwgdGhpcy5idWlsZEZpbHRlcigpKTsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb248U3RyaW5nPiBidWlsZENvbGxlY3Rpb24oKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBjb2xsZWN0aW9uID0gbmV3IFZlY3RvcjxTdHJpbmc+KCk7Ci0JCWNvbGxlY3Rpb24uYWRkKCJmb28iKTsKLQkJcmV0dXJuIGNvbGxlY3Rpb247Ci0JfQotCi0JcHJpdmF0ZSBGaWx0ZXI8U3RyaW5nPiBidWlsZEZpbHRlcigpIHsKLQkJcmV0dXJuIG5ldyBGaWx0ZXI8U3RyaW5nPigpIHsKLQkJCXB1YmxpYyBib29sZWFuIGFjY2VwdChTdHJpbmcgcykgewotCQkJCXJldHVybiBzLnN0YXJ0c1dpdGgoImIiKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZXJhdG9yKCkgewotCQkvLyBhZGQgYSBsaXN0ZW5lciB0byAiYWN0aXZhdGUiIHRoZSB3cmFwcGVyCi0JCXRoaXMuZmlsdGVyZWRDb2xsZWN0aW9uSG9sZGVyLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIHRoaXMuYnVpbGRGaWx0ZXJlZExpc3RlbmVyKCkpOwotCi0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy5jb2xsZWN0aW9uSG9sZGVyLml0ZXJhdG9yKCkubmV4dCgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5maWx0ZXJlZENvbGxlY3Rpb25Ib2xkZXIuaXRlcmF0b3IoKS5oYXNOZXh0KCkpOwotCi0JCXRoaXMuY29sbGVjdGlvbkhvbGRlci5hZGQoImJhciIpOwotCQlJdGVyYXRvcjxTdHJpbmc+IGNvbGxlY3Rpb25Ib2xkZXJWYWx1ZSA9IHRoaXMuY29sbGVjdGlvbkhvbGRlci5pdGVyYXRvcigpOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIGNvbGxlY3Rpb25Ib2xkZXJWYWx1ZS5uZXh0KCkpOwotCQlhc3NlcnRFcXVhbHMoImJhciIsIGNvbGxlY3Rpb25Ib2xkZXJWYWx1ZS5uZXh0KCkpOwotCQlhc3NlcnRUcnVlKHRoaXMuZmlsdGVyZWRDb2xsZWN0aW9uSG9sZGVyLml0ZXJhdG9yKCkuaGFzTmV4dCgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXIiLCB0aGlzLmZpbHRlcmVkQ29sbGVjdGlvbkhvbGRlci5pdGVyYXRvcigpLm5leHQoKSk7Ci0KLQkJdGhpcy5jb2xsZWN0aW9uSG9sZGVyLnJlbW92ZSgiYmFyIik7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy5jb2xsZWN0aW9uSG9sZGVyLml0ZXJhdG9yKCkubmV4dCgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5maWx0ZXJlZENvbGxlY3Rpb25Ib2xkZXIuaXRlcmF0b3IoKS5oYXNOZXh0KCkpOwotCi0JCXRoaXMuY29sbGVjdGlvbkhvbGRlci5yZW1vdmUoImZvbyIpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmNvbGxlY3Rpb25Ib2xkZXIuaXRlcmF0b3IoKS5oYXNOZXh0KCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmZpbHRlcmVkQ29sbGVjdGlvbkhvbGRlci5pdGVyYXRvcigpLmhhc05leHQoKSk7Ci0KLQkJdGhpcy5jb2xsZWN0aW9uSG9sZGVyLmFkZCgiZm9vIik7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy5jb2xsZWN0aW9uSG9sZGVyLml0ZXJhdG9yKCkubmV4dCgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5maWx0ZXJlZENvbGxlY3Rpb25Ib2xkZXIuaXRlcmF0b3IoKS5oYXNOZXh0KCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRWYWx1ZSgpIHsKLQkJLy8gYWRkIGEgbGlzdGVuZXIgdG8gImFjdGl2YXRlIiB0aGUgd3JhcHBlcgotCQl0aGlzLmZpbHRlcmVkQ29sbGVjdGlvbkhvbGRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCB0aGlzLmJ1aWxkRmlsdGVyZWRMaXN0ZW5lcigpKTsKLQotCQlDb2xsZWN0aW9uPFN0cmluZz4gbmV3Q29sbGVjdGlvbiA9IG5ldyBWZWN0b3I8U3RyaW5nPigpOwotCQluZXdDb2xsZWN0aW9uLmFkZCgiZm94Iik7Ci0JCW5ld0NvbGxlY3Rpb24uYWRkKCJiYXoiKTsKLQkJCi0JCXRoaXMuY29sbGVjdGlvbkhvbGRlci5zZXRDb2xsZWN0aW9uKG5ld0NvbGxlY3Rpb24pOwotCi0JCUl0ZXJhdG9yPFN0cmluZz4gY29sbGVjdGlvblZhbHVlcyA9IHRoaXMuY29sbGVjdGlvbkhvbGRlci5pdGVyYXRvcigpOwotCQlhc3NlcnRFcXVhbHMoImZveCIsIGNvbGxlY3Rpb25WYWx1ZXMubmV4dCgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXoiLCBjb2xsZWN0aW9uVmFsdWVzLm5leHQoKSk7Ci0JCUl0ZXJhdG9yPFN0cmluZz4gZmlsdGVyZWRDb2xsZWN0aW9uVmFsdWVzID0gdGhpcy5maWx0ZXJlZENvbGxlY3Rpb25Ib2xkZXIuaXRlcmF0b3IoKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXoiLCBmaWx0ZXJlZENvbGxlY3Rpb25WYWx1ZXMubmV4dCgpKTsKLQkJYXNzZXJ0RmFsc2UoZmlsdGVyZWRDb2xsZWN0aW9uVmFsdWVzLmhhc05leHQoKSk7Ci0JfQkJCi0KLQlwdWJsaWMgdm9pZCB0ZXN0TGF6eUxpc3RlbmluZygpIHsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuY29sbGVjdGlvbkhvbGRlcikuaGFzTm9Db2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUykpOwotCQlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSB0aGlzLmJ1aWxkRmlsdGVyZWRMaXN0ZW5lcigpOwotCQl0aGlzLmZpbHRlcmVkQ29sbGVjdGlvbkhvbGRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5jb2xsZWN0aW9uSG9sZGVyKS5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUykpOwotCQl0aGlzLmZpbHRlcmVkQ29sbGVjdGlvbkhvbGRlci5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5jb2xsZWN0aW9uSG9sZGVyKS5oYXNOb0NvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTKSk7Ci0KLQkJdGhpcy5maWx0ZXJlZENvbGxlY3Rpb25Ib2xkZXIuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgbGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5jb2xsZWN0aW9uSG9sZGVyKS5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUykpOwotCQl0aGlzLmZpbHRlcmVkQ29sbGVjdGlvbkhvbGRlci5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCBsaXN0ZW5lcik7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmNvbGxlY3Rpb25Ib2xkZXIpLmhhc05vQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29sbGVjdGlvbkNoYW5nZTEoKSB7Ci0JCXRoaXMuY29sbGVjdGlvbkhvbGRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZExpc3RlbmVyKCkpOwotCQl0aGlzLmZpbHRlcmVkQ29sbGVjdGlvbkhvbGRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZEZpbHRlcmVkTGlzdGVuZXIoKSk7Ci0JCXRoaXMudmVyaWZ5Q29sbGVjdGlvbkNoYW5nZXMoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29sbGVjdGlvbkNoYW5nZTIoKSB7Ci0JCXRoaXMuY29sbGVjdGlvbkhvbGRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCB0aGlzLmJ1aWxkTGlzdGVuZXIoKSk7Ci0JCXRoaXMuZmlsdGVyZWRDb2xsZWN0aW9uSG9sZGVyLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIHRoaXMuYnVpbGRGaWx0ZXJlZExpc3RlbmVyKCkpOwotCQl0aGlzLnZlcmlmeUNvbGxlY3Rpb25DaGFuZ2VzKCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGNsZWFyRXZlbnRzKCkgewotCQl0aGlzLmFkZEV2ZW50ID0gbnVsbDsKLQkJdGhpcy5yZW1vdmVFdmVudCA9IG51bGw7Ci0JCXRoaXMuY29sbGVjdGlvbkNsZWFyZWRFdmVudCA9IG51bGw7Ci0JCXRoaXMuY29sbGVjdGlvbkNoYW5nZWRFdmVudCA9IG51bGw7Ci0JCXRoaXMuZmlsdGVyZWRBZGRFdmVudCA9IG51bGw7Ci0JCXRoaXMuZmlsdGVyZWRSZW1vdmVFdmVudCA9IG51bGw7Ci0JCXRoaXMuZmlsdGVyZWRDb2xsZWN0aW9uQ2xlYXJlZEV2ZW50ID0gbnVsbDsKLQkJdGhpcy5maWx0ZXJlZENvbGxlY3Rpb25DaGFuZ2VkRXZlbnQgPSBudWxsOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlDb2xsZWN0aW9uQ2hhbmdlcygpIHsKLQkJY2xlYXJFdmVudHMoKTsKLQkJdGhpcy5jb2xsZWN0aW9uSG9sZGVyLmFkZCgiYmFyIik7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiB0ZW1wQ29sbGVjdGlvbiA9IG5ldyBWZWN0b3I8U3RyaW5nPigpOwotCQl0ZW1wQ29sbGVjdGlvbi5hZGQoImJhciIpOwotCQl0aGlzLnZlcmlmeUV2ZW50KHRoaXMuYWRkRXZlbnQsIHRoaXMuY29sbGVjdGlvbkhvbGRlciwgdGVtcENvbGxlY3Rpb24pOwotCQl0aGlzLnZlcmlmeUV2ZW50KHRoaXMuZmlsdGVyZWRBZGRFdmVudCwgdGhpcy5maWx0ZXJlZENvbGxlY3Rpb25Ib2xkZXIsIHRlbXBDb2xsZWN0aW9uKTsKLQkJCi0JCWNsZWFyRXZlbnRzKCk7Ci0JCXRoaXMuY29sbGVjdGlvbkhvbGRlci5yZW1vdmUoImZvbyIpOwotCQl0ZW1wQ29sbGVjdGlvbi5yZW1vdmUoImJhciIpOwotCQl0ZW1wQ29sbGVjdGlvbi5hZGQoImZvbyIpOwotCQl0aGlzLnZlcmlmeUV2ZW50KHRoaXMucmVtb3ZlRXZlbnQsIHRoaXMuY29sbGVjdGlvbkhvbGRlciwgdGVtcENvbGxlY3Rpb24pOwotCQlhc3NlcnROdWxsKHRoaXMuZmlsdGVyZWRSZW1vdmVFdmVudCk7Ci0KLQotCQljbGVhckV2ZW50cygpOwotCQl0aGlzLmNvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlKCJiYXIiKTsKLQkJdGVtcENvbGxlY3Rpb24uYWRkKCJiYXIiKTsKLQkJdGVtcENvbGxlY3Rpb24ucmVtb3ZlKCJmb28iKTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLnJlbW92ZUV2ZW50LCB0aGlzLmNvbGxlY3Rpb25Ib2xkZXIsIHRlbXBDb2xsZWN0aW9uKTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLmZpbHRlcmVkUmVtb3ZlRXZlbnQsIHRoaXMuZmlsdGVyZWRDb2xsZWN0aW9uSG9sZGVyLCB0ZW1wQ29sbGVjdGlvbik7Ci0KLQotCQljbGVhckV2ZW50cygpOwotCQl0aGlzLmNvbGxlY3Rpb25Ib2xkZXIuYWRkKCJmb28iKTsKLQkJdGVtcENvbGxlY3Rpb24ucmVtb3ZlKCJiYXIiKTsKLQkJdGVtcENvbGxlY3Rpb24uYWRkKCJmb28iKTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLmFkZEV2ZW50LCB0aGlzLmNvbGxlY3Rpb25Ib2xkZXIsIHRlbXBDb2xsZWN0aW9uKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmZpbHRlcmVkQWRkRXZlbnQpOwotCi0KLQkJY2xlYXJFdmVudHMoKTsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IG5ld0NvbGxlY3Rpb24gPSBuZXcgVmVjdG9yPFN0cmluZz4oKTsKLQkJbmV3Q29sbGVjdGlvbi5hZGQoImZveCIpOwotCQluZXdDb2xsZWN0aW9uLmFkZCgiYmF6Iik7Ci0JCQotCQl0aGlzLmNvbGxlY3Rpb25Ib2xkZXIuc2V0Q29sbGVjdGlvbihuZXdDb2xsZWN0aW9uKTsKLQotCQl0aGlzLnZlcmlmeUV2ZW50KHRoaXMuY29sbGVjdGlvbkNoYW5nZWRFdmVudCwgdGhpcy5jb2xsZWN0aW9uSG9sZGVyLCBuZXcgVmVjdG9yPFN0cmluZz4oKSk7Ci0JCQotCQl0ZW1wQ29sbGVjdGlvbi5yZW1vdmUoImZvbyIpOwotCQl0ZW1wQ29sbGVjdGlvbi5hZGQoImJheiIpOwotCQl0aGlzLnZlcmlmeUV2ZW50KHRoaXMuZmlsdGVyZWRDb2xsZWN0aW9uQ2hhbmdlZEV2ZW50LCB0aGlzLmZpbHRlcmVkQ29sbGVjdGlvbkhvbGRlciwgbmV3IFZlY3RvcjxTdHJpbmc+KCkpOwotCQkKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBidWlsZExpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCQlGaWx0ZXJpbmdDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLnRoaXMuYWRkRXZlbnQgPSBlOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7Ci0JCQkJRmlsdGVyaW5nQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy50aGlzLnJlbW92ZUV2ZW50ID0gZTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGNvbGxlY3Rpb25DbGVhcmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7Ci0JCQkJRmlsdGVyaW5nQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy50aGlzLmNvbGxlY3Rpb25DbGVhcmVkRXZlbnQgPSBlOwotCQkJfQotCQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNoYW5nZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCQlGaWx0ZXJpbmdDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLnRoaXMuY29sbGVjdGlvbkNoYW5nZWRFdmVudCA9IGU7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgYnVpbGRGaWx0ZXJlZExpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCQlGaWx0ZXJpbmdDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLnRoaXMuZmlsdGVyZWRBZGRFdmVudCA9IGU7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc1JlbW92ZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCQlGaWx0ZXJpbmdDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLnRoaXMuZmlsdGVyZWRSZW1vdmVFdmVudCA9IGU7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBjb2xsZWN0aW9uQ2xlYXJlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQkJCUZpbHRlcmluZ0NvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMudGhpcy5maWx0ZXJlZENvbGxlY3Rpb25DbGVhcmVkRXZlbnQgPSBlOwotCQkJfQotCQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNoYW5nZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCQlGaWx0ZXJpbmdDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLnRoaXMuZmlsdGVyZWRDb2xsZWN0aW9uQ2hhbmdlZEV2ZW50ID0gZTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5RXZlbnQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50LCBPYmplY3Qgc291cmNlLCBPYmplY3QgaXRlbXMpIHsKLQkJYXNzZXJ0RXF1YWxzKHNvdXJjZSwgZXZlbnQuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCBldmVudC5nZXRDb2xsZWN0aW9uTmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKGl0ZW1zLCBDb2xsZWN0aW9uVG9vbHMudmVjdG9yKGV2ZW50Lml0ZW1zKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlRmlsdGVyZWRJdGVtKCkgewotCQkvLyBidWlsZCBjb2xsZWN0aW9uIHdpdGggVGVzdEl0ZW1zCi0JCVNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPFRlc3RJdGVtPiB0aUhvbGRlciA9IG5ldyBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxUZXN0SXRlbT4odGhpcy5idWlsZENvbGxlY3Rpb24yKCkpOwotCQlDb2xsZWN0aW9uVmFsdWVNb2RlbDxUZXN0SXRlbT4gZmlsdGVyZWRUSUhvbGRlciA9IG5ldyBGaWx0ZXJpbmdDb2xsZWN0aW9uVmFsdWVNb2RlbDxUZXN0SXRlbT4odGlIb2xkZXIsIHRoaXMuYnVpbGRGaWx0ZXIyKCkpOwotCQkvLyBhZGQgYSBsaXN0ZW5lciB0byAiYWN0aXZhdGUiIHRoZSB3cmFwcGVyCi0JCWZpbHRlcmVkVElIb2xkZXIuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgdGhpcy5idWlsZEZpbHRlcmVkTGlzdGVuZXIoKSk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDAsIGZpbHRlcmVkVElIb2xkZXIuc2l6ZSgpKTsKLQotCQl0aUhvbGRlci5hZGQobmV3IFRlc3RJdGVtKCJiYXIiKSk7Ci0JCWFzc2VydEVxdWFscygxLCBmaWx0ZXJlZFRJSG9sZGVyLnNpemUoKSk7Ci0KLQkJVGVzdEl0ZW0gYmF6ID0gbmV3IFRlc3RJdGVtKCJiYXoiKTsKLQkJdGlIb2xkZXIuYWRkKGJheik7Ci0JCWFzc2VydEVxdWFscygyLCBmaWx0ZXJlZFRJSG9sZGVyLnNpemUoKSk7Ci0JCS8vIGJlZm9yZSByZW1vdmluZyBpdCwgY2hhbmdlIHRoZSBpdGVtIHNvIHRoYXQgaXQgaXMgZmlsdGVyZWQKLQkJYmF6Lm5hbWUgPSAiamF6IjsKLQkJdGlIb2xkZXIucmVtb3ZlKGJheik7Ci0JCS8vIHRoaXMgd291bGQgZmFpbCBiZWNhdXNlIHRoZSBpdGVtIHdhcyBub3QgcmVtb3ZlZCBmcm9tCi0JCS8vIHRoZSBmaWx0ZXJlZCBjb2xsZWN0aW9uIGNhY2hlLi4uIGJ1dCB3ZSd2ZSBmaXhlZCBpdCBub3cKLQkJYXNzZXJ0RXF1YWxzKDEsIGZpbHRlcmVkVElIb2xkZXIuc2l6ZSgpKTsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb248VGVzdEl0ZW0+IGJ1aWxkQ29sbGVjdGlvbjIoKSB7Ci0JCUNvbGxlY3Rpb248VGVzdEl0ZW0+IGNvbGxlY3Rpb24gPSBuZXcgVmVjdG9yPFRlc3RJdGVtPigpOwotCQljb2xsZWN0aW9uLmFkZChuZXcgVGVzdEl0ZW0oImZvbyIpKTsKLQkJcmV0dXJuIGNvbGxlY3Rpb247Ci0JfQotCi0JcHJpdmF0ZSBGaWx0ZXI8VGVzdEl0ZW0+IGJ1aWxkRmlsdGVyMigpIHsKLQkJcmV0dXJuIG5ldyBGaWx0ZXI8VGVzdEl0ZW0+KCkgewotCQkJcHVibGljIGJvb2xlYW4gYWNjZXB0KFRlc3RJdGVtIHRpKSB7Ci0JCQkJcmV0dXJuIHRpLm5hbWUuc3RhcnRzV2l0aCgiYiIpOwotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBUZXN0SXRlbSBpbm5lciBjbGFzcyAqKioqKioqKioqCi0KLQlwcml2YXRlIGNsYXNzIFRlc3RJdGVtIHsKLQkJU3RyaW5nIG5hbWU7Ci0JCVRlc3RJdGVtKFN0cmluZyBuYW1lKSB7Ci0JCQlzdXBlcigpOwotCQkJdGhpcy5uYW1lID0gbmFtZTsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9GaWx0ZXJpbmdQcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9GaWx0ZXJpbmdQcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3YzNiOGE2Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvRmlsdGVyaW5nUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE4NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkJpZGlGaWx0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5GaWx0ZXJpbmdXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5UZXN0VG9vbHM7Ci0KLXB1YmxpYyBjbGFzcyBGaWx0ZXJpbmdQcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gb2JqZWN0SG9sZGVyOwotCVByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQ7Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gZmlsdGVyZWRPYmplY3RIb2xkZXI7Ci0JUHJvcGVydHlDaGFuZ2VFdmVudCBmaWx0ZXJlZEV2ZW50OwotCi0JcHVibGljIEZpbHRlcmluZ1Byb3BlcnR5VmFsdWVNb2RlbFRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMub2JqZWN0SG9sZGVyID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+KCJmb28iKTsKLQkJdGhpcy5maWx0ZXJlZE9iamVjdEhvbGRlciA9IG5ldyBGaWx0ZXJpbmdXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+KHRoaXMub2JqZWN0SG9sZGVyLCB0aGlzLmJ1aWxkRmlsdGVyKCkpOwotCX0KLQotCXByaXZhdGUgQmlkaUZpbHRlcjxTdHJpbmc+IGJ1aWxkRmlsdGVyKCkgewotCQlyZXR1cm4gbmV3IEJpZGlGaWx0ZXI8U3RyaW5nPigpIHsKLQkJCXB1YmxpYyBib29sZWFuIGFjY2VwdChTdHJpbmcgcykgewotCQkJCXJldHVybiAocyAhPSBudWxsKSAmJiBzLnN0YXJ0c1dpdGgoImIiKTsKLQkJCX0KLQkJCXB1YmxpYyBib29sZWFuIHJldmVyc2VBY2NlcHQoU3RyaW5nIHMpIHsKLQkJCQlyZXR1cm4gKHMgIT0gbnVsbCkgJiYgcy5zdGFydHNXaXRoKCJiIik7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RWYWx1ZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCB0aGlzLm9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmZpbHRlcmVkT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCi0JCXRoaXMub2JqZWN0SG9sZGVyLnNldFZhbHVlKCJiYXIiKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXIiLCB0aGlzLm9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmZpbHRlcmVkT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMoImJhciIsIHRoaXMuZmlsdGVyZWRPYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0KLQkJdGhpcy5vYmplY3RIb2xkZXIuc2V0VmFsdWUoImJheiIpOwotCQlhc3NlcnRFcXVhbHMoImJheiIsIHRoaXMub2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZmlsdGVyZWRPYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygiYmF6IiwgdGhpcy5maWx0ZXJlZE9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZShudWxsKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLm9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmZpbHRlcmVkT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCi0JCXRoaXMub2JqZWN0SG9sZGVyLnNldFZhbHVlKCJmb28iKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCB0aGlzLm9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmZpbHRlcmVkT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRWYWx1ZSgpIHsKLQkJdGhpcy5maWx0ZXJlZE9iamVjdEhvbGRlci5zZXRWYWx1ZSgiYmFyIik7Ci0JCWFzc2VydEVxdWFscygiYmFyIiwgdGhpcy5vYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygiYmFyIiwgdGhpcy5maWx0ZXJlZE9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLmZpbHRlcmVkT2JqZWN0SG9sZGVyLnNldFZhbHVlKCJmb28iKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXIiLCB0aGlzLm9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXIiLCB0aGlzLmZpbHRlcmVkT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCi0JCXRoaXMuZmlsdGVyZWRPYmplY3RIb2xkZXIuc2V0VmFsdWUobnVsbCk7Ci0JCWFzc2VydEVxdWFscygiYmFyIiwgdGhpcy5vYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygiYmFyIiwgdGhpcy5maWx0ZXJlZE9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLmZpbHRlcmVkT2JqZWN0SG9sZGVyLnNldFZhbHVlKCJiYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXoiLCB0aGlzLm9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXoiLCB0aGlzLmZpbHRlcmVkT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMYXp5TGlzdGVuaW5nKCkgewotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5vYmplY3RIb2xkZXIpLmhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSB0aGlzLmJ1aWxkRmlsdGVyZWRMaXN0ZW5lcigpOwotCQl0aGlzLmZpbHRlcmVkT2JqZWN0SG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5vYmplY3RIb2xkZXIpLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQl0aGlzLmZpbHRlcmVkT2JqZWN0SG9sZGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5vYmplY3RIb2xkZXIpLmhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0KLQkJdGhpcy5maWx0ZXJlZE9iamVjdEhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgbGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5vYmplY3RIb2xkZXIpLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQl0aGlzLmZpbHRlcmVkT2JqZWN0SG9sZGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCBsaXN0ZW5lcik7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLm9iamVjdEhvbGRlcikuaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UHJvcGVydHlDaGFuZ2UxKCkgewotCQl0aGlzLm9iamVjdEhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRMaXN0ZW5lcigpKTsKLQkJdGhpcy5maWx0ZXJlZE9iamVjdEhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRGaWx0ZXJlZExpc3RlbmVyKCkpOwotCQl0aGlzLnZlcmlmeVByb3BlcnR5Q2hhbmdlcygpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RQcm9wZXJ0eUNoYW5nZTIoKSB7Ci0JCXRoaXMub2JqZWN0SG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmJ1aWxkTGlzdGVuZXIoKSk7Ci0JCXRoaXMuZmlsdGVyZWRPYmplY3RIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMuYnVpbGRGaWx0ZXJlZExpc3RlbmVyKCkpOwotCQl0aGlzLnZlcmlmeVByb3BlcnR5Q2hhbmdlcygpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlQcm9wZXJ0eUNoYW5nZXMoKSB7Ci0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLmZpbHRlcmVkRXZlbnQgPSBudWxsOwotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZSgiYmFyIik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5ldmVudCwgdGhpcy5vYmplY3RIb2xkZXIsICJmb28iLCAiYmFyIik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5maWx0ZXJlZEV2ZW50LCB0aGlzLmZpbHRlcmVkT2JqZWN0SG9sZGVyLCBudWxsLCAiYmFyIik7Ci0KLQkJdGhpcy5ldmVudCA9IG51bGw7Ci0JCXRoaXMuZmlsdGVyZWRFdmVudCA9IG51bGw7Ci0JCXRoaXMub2JqZWN0SG9sZGVyLnNldFZhbHVlKCJiYXoiKTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLmV2ZW50LCB0aGlzLm9iamVjdEhvbGRlciwgImJhciIsICJiYXoiKTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLmZpbHRlcmVkRXZlbnQsIHRoaXMuZmlsdGVyZWRPYmplY3RIb2xkZXIsICJiYXIiLCAiYmF6Iik7Ci0KLQkJdGhpcy5ldmVudCA9IG51bGw7Ci0JCXRoaXMuZmlsdGVyZWRFdmVudCA9IG51bGw7Ci0JCXRoaXMub2JqZWN0SG9sZGVyLnNldFZhbHVlKCJmb28iKTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLmV2ZW50LCB0aGlzLm9iamVjdEhvbGRlciwgImJheiIsICJmb28iKTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLmZpbHRlcmVkRXZlbnQsIHRoaXMuZmlsdGVyZWRPYmplY3RIb2xkZXIsICJiYXoiLCBudWxsKTsKLQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy5maWx0ZXJlZEV2ZW50ID0gbnVsbDsKLQkJdGhpcy5vYmplY3RIb2xkZXIuc2V0VmFsdWUoImZvcCIpOwotCQl0aGlzLnZlcmlmeUV2ZW50KHRoaXMuZXZlbnQsIHRoaXMub2JqZWN0SG9sZGVyLCAiZm9vIiwgImZvcCIpOwotCQlhc3NlcnROdWxsKHRoaXMuZmlsdGVyZWRFdmVudCk7Ci0KLQkJdGhpcy5ldmVudCA9IG51bGw7Ci0JCXRoaXMuZmlsdGVyZWRFdmVudCA9IG51bGw7Ci0JCXRoaXMub2JqZWN0SG9sZGVyLnNldFZhbHVlKG51bGwpOwotCQl0aGlzLnZlcmlmeUV2ZW50KHRoaXMuZXZlbnQsIHRoaXMub2JqZWN0SG9sZGVyLCAiZm9wIiwgbnVsbCk7Ci0JCWFzc2VydE51bGwodGhpcy5maWx0ZXJlZEV2ZW50KTsKLQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy5maWx0ZXJlZEV2ZW50ID0gbnVsbDsKLQkJdGhpcy5vYmplY3RIb2xkZXIuc2V0VmFsdWUoImJhciIpOwotCQl0aGlzLnZlcmlmeUV2ZW50KHRoaXMuZXZlbnQsIHRoaXMub2JqZWN0SG9sZGVyLCBudWxsLCAiYmFyIik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5maWx0ZXJlZEV2ZW50LCB0aGlzLmZpbHRlcmVkT2JqZWN0SG9sZGVyLCBudWxsLCAiYmFyIik7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJCQlGaWx0ZXJpbmdQcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cy50aGlzLmV2ZW50ID0gZTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGRGaWx0ZXJlZExpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJRmlsdGVyaW5nUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMudGhpcy5maWx0ZXJlZEV2ZW50ID0gZTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5RXZlbnQoUHJvcGVydHlDaGFuZ2VFdmVudCBlLCBPYmplY3Qgc291cmNlLCBPYmplY3Qgb2xkVmFsdWUsIE9iamVjdCBuZXdWYWx1ZSkgewotCQlhc3NlcnRFcXVhbHMoc291cmNlLCBlLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgZS5nZXRQcm9wZXJ0eU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscyhvbGRWYWx1ZSwgZS5nZXRPbGRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKG5ld1ZhbHVlLCBlLmdldE5ld1ZhbHVlKCkpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9JdGVtQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0l0ZW1Db2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMWUzYjNkZi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0l0ZW1Db2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDIzOSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZheC5zd2luZy5JY29uOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5CYWc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuSGFzaEJhZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkl0ZW1Db2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZUxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZy5EaXNwbGF5YWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5UZXN0VG9vbHM7Ci0KLXB1YmxpYyBjbGFzcyBJdGVtQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgSnVuayBmb287Ci0JcHJpdmF0ZSBKdW5rIGJhcjsKLQlwcml2YXRlIEp1bmsgYmF6OwotCXByaXZhdGUgSnVuayBqb287Ci0JcHJpdmF0ZSBKdW5rIGphcjsKLQlwcml2YXRlIEp1bmsgamF6OwotCi0JcHJpdmF0ZSBKdW5rIHRvbTsKLQlwcml2YXRlIEp1bmsgZGljazsKLQlwcml2YXRlIEp1bmsgaGFycnk7Ci0KLQlwdWJsaWMgSXRlbUNvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLmZvbyA9IG5ldyBKdW5rKCJmb28iKTsKLQkJdGhpcy5iYXIgPSBuZXcgSnVuaygiYmFyIik7Ci0JCXRoaXMuYmF6ID0gbmV3IEp1bmsoImJheiIpOwotCQl0aGlzLmpvbyA9IG5ldyBKdW5rKCJqb28iKTsKLQkJdGhpcy5qYXIgPSBuZXcgSnVuaygiamFyIik7Ci0JCXRoaXMuamF6ID0gbmV3IEp1bmsoImpheiIpOwotCi0JCXRoaXMudG9tID0gbmV3IEp1bmsoInRvbSIpOwotCQl0aGlzLmRpY2sgPSBuZXcgSnVuaygiZGljayIpOwotCQl0aGlzLmhhcnJ5ID0gbmV3IEp1bmsoImhhcnJ5Iik7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb2xsZWN0aW9uU3luY2hyb25pemF0aW9uKCkgewotCQlTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxKdW5rPiBjb2xsZWN0aW9uSG9sZGVyID0gdGhpcy5idWlsZENvbGxlY3Rpb25Ib2xkZXIoKTsKLQkJTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdFZhbHVlTW9kZWwgPSBuZXcgSXRlbUNvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXI8SnVuaz4oY29sbGVjdGlvbkhvbGRlciwgSnVuay5TVFVGRl9DT0xMRUNUSU9OKTsKLQkJQ29vcmRpbmF0ZWRMaXN0PEp1bms+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8SnVuaz4obGlzdFZhbHVlTW9kZWwpOwotCQlhc3NlcnRFcXVhbHMoNiwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0KTsKLQotCQljb2xsZWN0aW9uSG9sZGVyLmFkZCh0aGlzLnRvbSk7Ci0JCWNvbGxlY3Rpb25Ib2xkZXIuYWRkKHRoaXMuZGljayk7Ci0JCWNvbGxlY3Rpb25Ib2xkZXIuYWRkKHRoaXMuaGFycnkpOwotCQlhc3NlcnRFcXVhbHMoOSwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0KTsKLQotCQljb2xsZWN0aW9uSG9sZGVyLnJlbW92ZSh0aGlzLmZvbyk7Ci0JCWNvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlKHRoaXMuamFyKTsKLQkJY29sbGVjdGlvbkhvbGRlci5yZW1vdmUodGhpcy5oYXJyeSk7Ci0JCWFzc2VydEVxdWFscyg2LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlKGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0U3luY2hyb25pemF0aW9uKCkgewotCQlTaW1wbGVMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0SG9sZGVyID0gdGhpcy5idWlsZExpc3RIb2xkZXIoKTsKLQkJTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdFZhbHVlTW9kZWwgPSBuZXcgSXRlbUNvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXI8SnVuaz4obGlzdEhvbGRlciwgSnVuay5TVFVGRl9DT0xMRUNUSU9OKTsKLQkJQ29vcmRpbmF0ZWRMaXN0PEp1bms+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8SnVuaz4obGlzdFZhbHVlTW9kZWwpOwotCQlhc3NlcnRFcXVhbHMoNiwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0KTsKLQotCQlsaXN0SG9sZGVyLmFkZCg2LCB0aGlzLnRvbSk7Ci0JCWxpc3RIb2xkZXIuYWRkKDcsIHRoaXMuZGljayk7Ci0JCWxpc3RIb2xkZXIuYWRkKDgsIHRoaXMuaGFycnkpOwotCQlhc3NlcnRFcXVhbHMoOSwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0KTsKLQotCQlsaXN0SG9sZGVyLnJlbW92ZSg4KTsKLQkJbGlzdEhvbGRlci5yZW1vdmUoMCk7Ci0JCWxpc3RIb2xkZXIucmVtb3ZlKDQpOwotCQlhc3NlcnRFcXVhbHMoNiwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0KTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgY29tcGFyZShMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCwgTGlzdDxKdW5rPiBsaXN0KSB7Ci0JCWFzc2VydEVxdWFscyhsaXN0VmFsdWVNb2RlbC5zaXplKCksIGxpc3Quc2l6ZSgpKTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsaXN0VmFsdWVNb2RlbC5zaXplKCk7IGkrKykgewotCQkJYXNzZXJ0RXF1YWxzKGxpc3RWYWx1ZU1vZGVsLmdldChpKSwgbGlzdC5nZXQoaSkpOwotCQl9Ci0JfQotCi0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcigpOwotCQlhc3NlcnRGYWxzZShsaXN0SG9sZGVyLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5mb28uaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhKdW5rLlNUVUZGX0NPTExFQ1RJT04pKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qYXouaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhKdW5rLlNUVUZGX0NPTExFQ1RJT04pKTsKLQotCQlMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCA9IG5ldyBJdGVtQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxKdW5rPihsaXN0SG9sZGVyLCBKdW5rLlNUVUZGX0NPTExFQ1RJT04pOwotCQlhc3NlcnRGYWxzZShsaXN0SG9sZGVyLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5mb28uaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhKdW5rLlNUVUZGX0NPTExFQ1RJT04pKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qYXouaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhKdW5rLlNUVUZGX0NPTExFQ1RJT04pKTsKLQkJdGhpcy52ZXJpZnlIYXNOb0xpc3RlbmVycyhsaXN0VmFsdWVNb2RlbCk7Ci0KLQkJQ29vcmRpbmF0ZWRMaXN0PEp1bms+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8SnVuaz4obGlzdFZhbHVlTW9kZWwpOwotCQlhc3NlcnRUcnVlKGxpc3RIb2xkZXIuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQlhc3NlcnRUcnVlKHRoaXMuZm9vLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoSnVuay5TVFVGRl9DT0xMRUNUSU9OKSk7Ci0JCWFzc2VydFRydWUodGhpcy5qYXouaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhKdW5rLlNUVUZGX0NPTExFQ1RJT04pKTsKLQkJdGhpcy52ZXJpZnlIYXNMaXN0ZW5lcnMobGlzdFZhbHVlTW9kZWwpOwotCi0JCWxpc3RWYWx1ZU1vZGVsLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgc3luY2hMaXN0KTsKLQkJYXNzZXJ0RmFsc2UobGlzdEhvbGRlci5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuZm9vLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoSnVuay5TVFVGRl9DT0xMRUNUSU9OKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuamF6Lmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoSnVuay5TVFVGRl9DT0xMRUNUSU9OKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTm9MaXN0ZW5lcnMobGlzdFZhbHVlTW9kZWwpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRTaXplKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcigpOwotCQlMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCA9IG5ldyBJdGVtQ29sbGVjdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxKdW5rPihsaXN0SG9sZGVyLCBKdW5rLlNUVUZGX0NPTExFQ1RJT04pOwotCQlDb29yZGluYXRlZExpc3Q8SnVuaz4gc3luY2hMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxKdW5rPihsaXN0VmFsdWVNb2RlbCk7Ci0JCXRoaXMudmVyaWZ5SGFzTGlzdGVuZXJzKGxpc3RWYWx1ZU1vZGVsKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIGxpc3RWYWx1ZU1vZGVsLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyg2LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0R2V0KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcigpOwotCQlMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCA9IG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8SnVuaz4obmV3IEl0ZW1Db2xsZWN0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyPEp1bms+KGxpc3RIb2xkZXIsIEp1bmsuU1RVRkZfQ09MTEVDVElPTikpOwotCQlDb29yZGluYXRlZExpc3Q8SnVuaz4gc3luY2hMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxKdW5rPihsaXN0VmFsdWVNb2RlbCk7Ci0JCXRoaXMudmVyaWZ5SGFzTGlzdGVuZXJzKGxpc3RWYWx1ZU1vZGVsKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYmFyLCBsaXN0VmFsdWVNb2RlbC5nZXQoMCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5iYXIsIHN5bmNoTGlzdC5nZXQoMCkpOwotCQl0aGlzLmJhci5yZW1vdmVTdHVmZigiYmFyIik7Ci0JCXRoaXMuYmFyLmFkZFN0dWZmKCJ6enoiKTsKLQkJdGhpcy5iYXIuYWRkU3R1ZmYoImJhciIpOwotCQlhc3NlcnRFcXVhbHModGhpcy5iYXIsIGxpc3RWYWx1ZU1vZGVsLmdldCg1KSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJhciwgc3luY2hMaXN0LmdldCg1KSk7Ci0JCXRoaXMuYmFyLnJlbW92ZVN0dWZmKCJ6enoiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5SGFzTm9MaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdFZhbHVlTW9kZWwpIHRocm93cyBFeGNlcHRpb24gewotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgbGlzdFZhbHVlTW9kZWwpLmhhc05vTGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlIYXNMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdFZhbHVlTW9kZWwpIHRocm93cyBFeGNlcHRpb24gewotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgbGlzdFZhbHVlTW9kZWwpLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQl9Ci0KLQlwcml2YXRlIFNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPEp1bms+IGJ1aWxkQ29sbGVjdGlvbkhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxKdW5rPih0aGlzLmJ1aWxkQ29sbGVjdGlvbigpKTsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb248SnVuaz4gYnVpbGRDb2xsZWN0aW9uKCkgewotCQlCYWc8SnVuaz4gYmFnID0gbmV3IEhhc2hCYWc8SnVuaz4oKTsKLQkJdGhpcy5wb3B1bGF0ZUNvbGxlY3Rpb24oYmFnKTsKLQkJcmV0dXJuIGJhZzsKLQl9Ci0KLQlwcml2YXRlIFNpbXBsZUxpc3RWYWx1ZU1vZGVsPEp1bms+IGJ1aWxkTGlzdEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVMaXN0VmFsdWVNb2RlbDxKdW5rPih0aGlzLmJ1aWxkTGlzdCgpKTsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8SnVuaz4gYnVpbGRMaXN0KCkgewotCQlMaXN0PEp1bms+IGxpc3QgPSBuZXcgQXJyYXlMaXN0PEp1bms+KCk7Ci0JCXRoaXMucG9wdWxhdGVDb2xsZWN0aW9uKGxpc3QpOwotCQlyZXR1cm4gbGlzdDsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgcG9wdWxhdGVDb2xsZWN0aW9uKENvbGxlY3Rpb248SnVuaz4gYykgewotCQljLmFkZCh0aGlzLmZvbyk7Ci0JCWMuYWRkKHRoaXMuYmFyKTsKLQkJYy5hZGQodGhpcy5iYXopOwotCQljLmFkZCh0aGlzLmpvbyk7Ci0JCWMuYWRkKHRoaXMuamFyKTsKLQkJYy5hZGQodGhpcy5qYXopOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBKdW5rIGNsYXNzICoqKioqKioqKioKLQotCXByaXZhdGUgY2xhc3MgSnVuayBleHRlbmRzIEFic3RyYWN0TW9kZWwgaW1wbGVtZW50cyBEaXNwbGF5YWJsZSB7Ci0JCXByaXZhdGUgQ29sbGVjdGlvbjxTdHJpbmc+IHN0dWZmOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgU1RVRkZfQ09MTEVDVElPTiA9ICJzdHVmZiI7Ci0JCQkKLQkKLQkJcHVibGljIEp1bmsoU3RyaW5nIHN0dWZmSXRlbSkgewotCQkJdGhpcy5zdHVmZiA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQkJdGhpcy5zdHVmZi5hZGQoc3R1ZmZJdGVtKTsKLQkJfQotCQotCQlwdWJsaWMgdm9pZCBhZGRTdHVmZihTdHJpbmcgc3R1ZmZJdGVtKSB7Ci0JCQl0aGlzLmFkZEl0ZW1Ub0NvbGxlY3Rpb24oc3R1ZmZJdGVtLCB0aGlzLnN0dWZmLCBTVFVGRl9DT0xMRUNUSU9OKTsKLQkJfQotCQkKLQkJcHVibGljIHZvaWQgcmVtb3ZlU3R1ZmYoU3RyaW5nIHN0dWZmSXRlbSkgewotCQkJdGhpcy5yZW1vdmVJdGVtRnJvbUNvbGxlY3Rpb24oc3R1ZmZJdGVtLCB0aGlzLnN0dWZmLCBTVFVGRl9DT0xMRUNUSU9OKTsKLQkJfQotCQotCQlwdWJsaWMgU3RyaW5nIGRpc3BsYXlTdHJpbmcoKSB7Ci0JCQlyZXR1cm4gdG9TdHJpbmcoKTsKLQkJfQotCQotCQlwdWJsaWMgSWNvbiBpY29uKCkgewotCQkJcmV0dXJuIG51bGw7Ci0JCX0KLQkJCi0JCXB1YmxpYyBpbnQgY29tcGFyZVRvKERpc3BsYXlhYmxlIG8pIHsKLQkJCXJldHVybiBERUZBVUxUX0NPTVBBUkFUT1IuY29tcGFyZSh0aGlzLCBvKTsKLQkJfQotCQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiSnVuaygiICsgdGhpcy5zdHVmZiArICIpIjsKLQkJfQotCQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9JdGVtTGlzdExpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0l0ZW1MaXN0TGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWQ1OGRhMS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0l0ZW1MaXN0TGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI0MCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZheC5zd2luZy5JY29uOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5CYWc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuSGFzaEJhZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkl0ZW1MaXN0TGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZUxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZy5EaXNwbGF5YWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5UZXN0VG9vbHM7Ci0KLXB1YmxpYyBjbGFzcyBJdGVtTGlzdExpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgSnVuayBmb287Ci0JcHJpdmF0ZSBKdW5rIGJhcjsKLQlwcml2YXRlIEp1bmsgYmF6OwotCXByaXZhdGUgSnVuayBqb287Ci0JcHJpdmF0ZSBKdW5rIGphcjsKLQlwcml2YXRlIEp1bmsgamF6OwotCi0JcHJpdmF0ZSBKdW5rIHRvbTsKLQlwcml2YXRlIEp1bmsgZGljazsKLQlwcml2YXRlIEp1bmsgaGFycnk7Ci0KLQlwdWJsaWMgSXRlbUxpc3RMaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLmZvbyA9IG5ldyBKdW5rKCJmb28iKTsKLQkJdGhpcy5iYXIgPSBuZXcgSnVuaygiYmFyIik7Ci0JCXRoaXMuYmF6ID0gbmV3IEp1bmsoImJheiIpOwotCQl0aGlzLmpvbyA9IG5ldyBKdW5rKCJqb28iKTsKLQkJdGhpcy5qYXIgPSBuZXcgSnVuaygiamFyIik7Ci0JCXRoaXMuamF6ID0gbmV3IEp1bmsoImpheiIpOwotCi0JCXRoaXMudG9tID0gbmV3IEp1bmsoInRvbSIpOwotCQl0aGlzLmRpY2sgPSBuZXcgSnVuaygiZGljayIpOwotCQl0aGlzLmhhcnJ5ID0gbmV3IEp1bmsoImhhcnJ5Iik7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb2xsZWN0aW9uU3luY2hyb25pemF0aW9uKCkgewotCQlTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxKdW5rPiBjb2xsZWN0aW9uSG9sZGVyID0gdGhpcy5idWlsZENvbGxlY3Rpb25Ib2xkZXIoKTsKLQkJTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdFZhbHVlTW9kZWwgPSBuZXcgSXRlbUxpc3RMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8SnVuaz4oY29sbGVjdGlvbkhvbGRlciwgSnVuay5TVFVGRl9MSVNUKTsKLQkJQ29vcmRpbmF0ZWRMaXN0PEp1bms+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8SnVuaz4obGlzdFZhbHVlTW9kZWwpOwotCQlhc3NlcnRFcXVhbHMoNiwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0KTsKLQotCQljb2xsZWN0aW9uSG9sZGVyLmFkZCh0aGlzLnRvbSk7Ci0JCWNvbGxlY3Rpb25Ib2xkZXIuYWRkKHRoaXMuZGljayk7Ci0JCWNvbGxlY3Rpb25Ib2xkZXIuYWRkKHRoaXMuaGFycnkpOwotCQlhc3NlcnRFcXVhbHMoOSwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0KTsKLQotCQljb2xsZWN0aW9uSG9sZGVyLnJlbW92ZSh0aGlzLmZvbyk7Ci0JCWNvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlKHRoaXMuamFyKTsKLQkJY29sbGVjdGlvbkhvbGRlci5yZW1vdmUodGhpcy5oYXJyeSk7Ci0JCWFzc2VydEVxdWFscyg2LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlKGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0U3luY2hyb25pemF0aW9uKCkgewotCQlTaW1wbGVMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0SG9sZGVyID0gdGhpcy5idWlsZExpc3RIb2xkZXIoKTsKLQkJTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdFZhbHVlTW9kZWwgPSBuZXcgSXRlbUxpc3RMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8SnVuaz4obGlzdEhvbGRlciwgSnVuay5TVFVGRl9MSVNUKTsKLQkJQ29vcmRpbmF0ZWRMaXN0PEp1bms+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8SnVuaz4obGlzdFZhbHVlTW9kZWwpOwotCQlhc3NlcnRFcXVhbHMoNiwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0KTsKLQotCQlsaXN0SG9sZGVyLmFkZCg2LCB0aGlzLnRvbSk7Ci0JCWxpc3RIb2xkZXIuYWRkKDcsIHRoaXMuZGljayk7Ci0JCWxpc3RIb2xkZXIuYWRkKDgsIHRoaXMuaGFycnkpOwotCQlhc3NlcnRFcXVhbHMoOSwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0KTsKLQotCQlsaXN0SG9sZGVyLnJlbW92ZSg4KTsKLQkJbGlzdEhvbGRlci5yZW1vdmUoMCk7Ci0JCWxpc3RIb2xkZXIucmVtb3ZlKDQpOwotCQlhc3NlcnRFcXVhbHMoNiwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0KTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgY29tcGFyZShMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCwgTGlzdDxKdW5rPiBsaXN0KSB7Ci0JCWFzc2VydEVxdWFscyhsaXN0VmFsdWVNb2RlbC5zaXplKCksIGxpc3Quc2l6ZSgpKTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsaXN0VmFsdWVNb2RlbC5zaXplKCk7IGkrKykgewotCQkJYXNzZXJ0RXF1YWxzKGxpc3RWYWx1ZU1vZGVsLmdldChpKSwgbGlzdC5nZXQoaSkpOwotCQl9Ci0JfQotCi0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcigpOwotCQlhc3NlcnRGYWxzZShsaXN0SG9sZGVyLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5mb28uaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhKdW5rLlNUVUZGX0xJU1QpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qYXouaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhKdW5rLlNUVUZGX0xJU1QpKTsKLQotCQlMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCA9IG5ldyBJdGVtTGlzdExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxKdW5rPihsaXN0SG9sZGVyLCBKdW5rLlNUVUZGX0xJU1QpOwotCQlhc3NlcnRGYWxzZShsaXN0SG9sZGVyLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5mb28uaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhKdW5rLlNUVUZGX0xJU1QpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qYXouaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhKdW5rLlNUVUZGX0xJU1QpKTsKLQkJdGhpcy52ZXJpZnlIYXNOb0xpc3RlbmVycyhsaXN0VmFsdWVNb2RlbCk7Ci0KLQkJQ29vcmRpbmF0ZWRMaXN0PEp1bms+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8SnVuaz4obGlzdFZhbHVlTW9kZWwpOwotCQlhc3NlcnRUcnVlKGxpc3RIb2xkZXIuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQlhc3NlcnRUcnVlKHRoaXMuZm9vLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoSnVuay5TVFVGRl9MSVNUKSk7Ci0JCWFzc2VydFRydWUodGhpcy5qYXouaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhKdW5rLlNUVUZGX0xJU1QpKTsKLQkJdGhpcy52ZXJpZnlIYXNMaXN0ZW5lcnMobGlzdFZhbHVlTW9kZWwpOwotCi0JCWxpc3RWYWx1ZU1vZGVsLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgc3luY2hMaXN0KTsKLQkJYXNzZXJ0RmFsc2UobGlzdEhvbGRlci5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuZm9vLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoSnVuay5TVFVGRl9MSVNUKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuamF6Lmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoSnVuay5TVFVGRl9MSVNUKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTm9MaXN0ZW5lcnMobGlzdFZhbHVlTW9kZWwpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRTaXplKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcigpOwotCQlMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCA9IG5ldyBJdGVtTGlzdExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxKdW5rPihsaXN0SG9sZGVyLCBKdW5rLlNUVUZGX0xJU1QpOwotCQlDb29yZGluYXRlZExpc3Q8SnVuaz4gc3luY2hMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxKdW5rPihsaXN0VmFsdWVNb2RlbCk7Ci0JCXRoaXMudmVyaWZ5SGFzTGlzdGVuZXJzKGxpc3RWYWx1ZU1vZGVsKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIGxpc3RWYWx1ZU1vZGVsLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyg2LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0R2V0KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcigpOwotCQlMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCA9IG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8SnVuaz4obmV3IEl0ZW1MaXN0TGlzdFZhbHVlTW9kZWxBZGFwdGVyPEp1bms+KGxpc3RIb2xkZXIsIEp1bmsuU1RVRkZfTElTVCkpOwotCQlDb29yZGluYXRlZExpc3Q8SnVuaz4gc3luY2hMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxKdW5rPihsaXN0VmFsdWVNb2RlbCk7Ci0JCXRoaXMudmVyaWZ5SGFzTGlzdGVuZXJzKGxpc3RWYWx1ZU1vZGVsKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYmFyLCBsaXN0VmFsdWVNb2RlbC5nZXQoMCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5iYXIsIHN5bmNoTGlzdC5nZXQoMCkpOwotCQl0aGlzLmJhci5yZW1vdmVTdHVmZigiYmFyIik7Ci0JCXRoaXMuYmFyLmFkZFN0dWZmKCJ6enoiKTsKLQkJdGhpcy5iYXIuYWRkU3R1ZmYoImJhciIpOwotCQlhc3NlcnRFcXVhbHModGhpcy5iYXIsIGxpc3RWYWx1ZU1vZGVsLmdldCg1KSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJhciwgc3luY2hMaXN0LmdldCg1KSk7Ci0JCXRoaXMuYmFyLnJlbW92ZVN0dWZmKCJ6enoiKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5SGFzTm9MaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdFZhbHVlTW9kZWwpIHRocm93cyBFeGNlcHRpb24gewotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgbGlzdFZhbHVlTW9kZWwpLmhhc05vTGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlIYXNMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdFZhbHVlTW9kZWwpIHRocm93cyBFeGNlcHRpb24gewotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgbGlzdFZhbHVlTW9kZWwpLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQl9Ci0KLQlwcml2YXRlIFNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPEp1bms+IGJ1aWxkQ29sbGVjdGlvbkhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxKdW5rPih0aGlzLmJ1aWxkQ29sbGVjdGlvbigpKTsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb248SnVuaz4gYnVpbGRDb2xsZWN0aW9uKCkgewotCQlCYWc8SnVuaz4gYmFnID0gbmV3IEhhc2hCYWc8SnVuaz4oKTsKLQkJdGhpcy5wb3B1bGF0ZUNvbGxlY3Rpb24oYmFnKTsKLQkJcmV0dXJuIGJhZzsKLQl9Ci0KLQlwcml2YXRlIFNpbXBsZUxpc3RWYWx1ZU1vZGVsPEp1bms+IGJ1aWxkTGlzdEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVMaXN0VmFsdWVNb2RlbDxKdW5rPih0aGlzLmJ1aWxkTGlzdCgpKTsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8SnVuaz4gYnVpbGRMaXN0KCkgewotCQlMaXN0PEp1bms+IGxpc3QgPSBuZXcgQXJyYXlMaXN0PEp1bms+KCk7Ci0JCXRoaXMucG9wdWxhdGVDb2xsZWN0aW9uKGxpc3QpOwotCQlyZXR1cm4gbGlzdDsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgcG9wdWxhdGVDb2xsZWN0aW9uKENvbGxlY3Rpb248SnVuaz4gYykgewotCQljLmFkZCh0aGlzLmZvbyk7Ci0JCWMuYWRkKHRoaXMuYmFyKTsKLQkJYy5hZGQodGhpcy5iYXopOwotCQljLmFkZCh0aGlzLmpvbyk7Ci0JCWMuYWRkKHRoaXMuamFyKTsKLQkJYy5hZGQodGhpcy5qYXopOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBKdW5rIGNsYXNzICoqKioqKioqKioKLQotCXByaXZhdGUgY2xhc3MgSnVuayBleHRlbmRzIEFic3RyYWN0TW9kZWwgaW1wbGVtZW50cyBEaXNwbGF5YWJsZSB7Ci0JCXByaXZhdGUgTGlzdDxTdHJpbmc+IHN0dWZmOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgU1RVRkZfTElTVCA9ICJzdHVmZiI7Ci0JCQkKLQkKLQkJcHVibGljIEp1bmsoU3RyaW5nIHN0dWZmSXRlbSkgewotCQkJdGhpcy5zdHVmZiA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQkJdGhpcy5zdHVmZi5hZGQoc3R1ZmZJdGVtKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBhZGRTdHVmZihTdHJpbmcgc3R1ZmZJdGVtKSB7Ci0JCQl0aGlzLnN0dWZmLmFkZChzdHVmZkl0ZW0pOwotCQkJZmlyZUl0ZW1BZGRlZChTVFVGRl9MSVNULCB0aGlzLnN0dWZmLmluZGV4T2Yoc3R1ZmZJdGVtKSwgc3R1ZmZJdGVtKTsKLQkJfQotCQkKLQkJcHVibGljIHZvaWQgcmVtb3ZlU3R1ZmYoU3RyaW5nIHN0dWZmSXRlbSkgewotCQkJaW50IGluZGV4ID0gdGhpcy5zdHVmZi5pbmRleE9mKHN0dWZmSXRlbSk7Ci0JCQl0aGlzLnN0dWZmLnJlbW92ZShzdHVmZkl0ZW0pOwotCQkJZmlyZUl0ZW1SZW1vdmVkKFNUVUZGX0xJU1QsIGluZGV4LCBzdHVmZkl0ZW0pOwotCQl9Ci0JCi0JCXB1YmxpYyBTdHJpbmcgZGlzcGxheVN0cmluZygpIHsKLQkJCXJldHVybiB0b1N0cmluZygpOwotCQl9Ci0JCi0JCXB1YmxpYyBJY29uIGljb24oKSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQkKLQkJcHVibGljIGludCBjb21wYXJlVG8oRGlzcGxheWFibGUgbykgewotCQkJcmV0dXJuIERFRkFVTFRfQ09NUEFSQVRPUi5jb21wYXJlKHRoaXMsIG8pOwotCQl9Ci0JCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuICJKdW5rKCIgKyB0aGlzLnN0dWZmICsgIikiOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0l0ZW1Qcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0l0ZW1Qcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhlNGUxNmMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9JdGVtUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzMwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5Db21wYXJhdG9yOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuU29ydGVkU2V0OwotaW1wb3J0IGphdmEudXRpbC5UcmVlU2V0OwotaW1wb3J0IGphdmF4LnN3aW5nLkljb247Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkJhZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5IYXNoQmFnOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuSXRlbVByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZUxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZy5EaXNwbGF5YWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5UZXN0VG9vbHM7Ci0KLXB1YmxpYyBjbGFzcyBJdGVtUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIEp1bmsgZm9vOwotCXByaXZhdGUgSnVuayBiYXI7Ci0JcHJpdmF0ZSBKdW5rIGJhejsKLQlwcml2YXRlIEp1bmsgam9vOwotCXByaXZhdGUgSnVuayBqYXI7Ci0JcHJpdmF0ZSBKdW5rIGphejsKLQotCXByaXZhdGUgSnVuayB0b207Ci0JcHJpdmF0ZSBKdW5rIGRpY2s7Ci0JcHJpdmF0ZSBKdW5rIGhhcnJ5OwotCi0JcHVibGljIEl0ZW1Qcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMuZm9vID0gbmV3IEp1bmsoInRoaXMuZm9vIik7Ci0JCXRoaXMuYmFyID0gbmV3IEp1bmsoInRoaXMuYmFyIik7Ci0JCXRoaXMuYmF6ID0gbmV3IEp1bmsoInRoaXMuYmF6Iik7Ci0JCXRoaXMuam9vID0gbmV3IEp1bmsoInRoaXMuam9vIik7Ci0JCXRoaXMuamFyID0gbmV3IEp1bmsoInRoaXMuamFyIik7Ci0JCXRoaXMuamF6ID0gbmV3IEp1bmsoInRoaXMuamF6Iik7Ci0KLQkJdGhpcy50b20gPSBuZXcgSnVuaygidGhpcy50b20iKTsKLQkJdGhpcy5kaWNrID0gbmV3IEp1bmsoInRoaXMuZGljayIpOwotCQl0aGlzLmhhcnJ5ID0gbmV3IEp1bmsoInRoaXMuaGFycnkiKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25TeW5jaHJvbml6YXRpb24oKSB7Ci0JCVNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPEp1bms+IGNvbGxlY3Rpb25Ib2xkZXIgPSB0aGlzLmJ1aWxkQ29sbGVjdGlvbkhvbGRlcigpOwotCQlMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCA9IG5ldyBJdGVtUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8SnVuaz4oY29sbGVjdGlvbkhvbGRlciwgRGlzcGxheWFibGUuRElTUExBWV9TVFJJTkdfUFJPUEVSVFksIERpc3BsYXlhYmxlLklDT05fUFJPUEVSVFkpOwotCQlDb29yZGluYXRlZExpc3Q8SnVuaz4gc3luY2hMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxKdW5rPihsaXN0VmFsdWVNb2RlbCk7Ci0JCWFzc2VydEVxdWFscyg2LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlKGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QpOwotCi0JCWNvbGxlY3Rpb25Ib2xkZXIuYWRkKHRoaXMudG9tKTsKLQkJY29sbGVjdGlvbkhvbGRlci5hZGQodGhpcy5kaWNrKTsKLQkJY29sbGVjdGlvbkhvbGRlci5hZGQodGhpcy5oYXJyeSk7Ci0JCWFzc2VydEVxdWFscyg5LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlKGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QpOwotCi0JCWNvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlKHRoaXMuZm9vKTsKLQkJY29sbGVjdGlvbkhvbGRlci5yZW1vdmUodGhpcy5qYXIpOwotCQljb2xsZWN0aW9uSG9sZGVyLnJlbW92ZSh0aGlzLmhhcnJ5KTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmUobGlzdFZhbHVlTW9kZWwsIHN5bmNoTGlzdCk7Ci0KLQkJY29sbGVjdGlvbkhvbGRlci5zZXRDb2xsZWN0aW9uKHRoaXMuYnVpbGRDb2xsZWN0aW9uKCkpOwotCQlhc3NlcnRFcXVhbHMoNiwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdFN5bmNocm9uaXphdGlvbigpIHsKLQkJU2ltcGxlTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdEhvbGRlciA9IHRoaXMuYnVpbGRMaXN0SG9sZGVyKCk7Ci0JCUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RWYWx1ZU1vZGVsID0gbmV3IEl0ZW1Qcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxKdW5rPihsaXN0SG9sZGVyLCBEaXNwbGF5YWJsZS5ESVNQTEFZX1NUUklOR19QUk9QRVJUWSwgRGlzcGxheWFibGUuSUNPTl9QUk9QRVJUWSk7Ci0JCUNvb3JkaW5hdGVkTGlzdDxKdW5rPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PEp1bms+KGxpc3RWYWx1ZU1vZGVsKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmUobGlzdFZhbHVlTW9kZWwsIHN5bmNoTGlzdCk7Ci0KLQkJbGlzdEhvbGRlci5hZGQoNiwgdGhpcy50b20pOwotCQlsaXN0SG9sZGVyLmFkZCg3LCB0aGlzLmRpY2spOwotCQlsaXN0SG9sZGVyLmFkZCg4LCB0aGlzLmhhcnJ5KTsKLQkJYXNzZXJ0RXF1YWxzKDksIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmUobGlzdFZhbHVlTW9kZWwsIHN5bmNoTGlzdCk7Ci0KLQkJbGlzdEhvbGRlci5yZW1vdmUoOCk7Ci0JCWxpc3RIb2xkZXIucmVtb3ZlKDApOwotCQlsaXN0SG9sZGVyLnJlbW92ZSg0KTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmUobGlzdFZhbHVlTW9kZWwsIHN5bmNoTGlzdCk7Ci0KLQkJLy8gdGVzdCBjb25jdXJyZW50IG1vZGlmaWNhdGlvbiBleGNlcHRpb24KLQkJbGlzdEhvbGRlci5zZXRMaXN0KHRoaXMuYnVpbGRMaXN0KCkpOwotCQlhc3NlcnRFcXVhbHMoNiwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0KTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgY29tcGFyZShMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCwgTGlzdDxKdW5rPiBsaXN0KSB7Ci0JCWFzc2VydEVxdWFscyhsaXN0VmFsdWVNb2RlbC5zaXplKCksIGxpc3Quc2l6ZSgpKTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBsaXN0VmFsdWVNb2RlbC5zaXplKCk7IGkrKykgewotCQkJYXNzZXJ0RXF1YWxzKGxpc3RWYWx1ZU1vZGVsLmdldChpKSwgbGlzdC5nZXQoaSkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25Tb3J0KCkgewotCQl0aGlzLnZlcmlmeUNvbGxlY3Rpb25Tb3J0KG51bGwpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0U29ydCgpIHsKLQkJdGhpcy52ZXJpZnlMaXN0U29ydChudWxsKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q3VzdG9tQ29sbGVjdGlvblNvcnQoKSB7Ci0JCXRoaXMudmVyaWZ5Q29sbGVjdGlvblNvcnQodGhpcy5idWlsZEN1c3RvbUNvbXBhcmF0b3IoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEN1c3RvbUxpc3RTb3J0KCkgewotCQl0aGlzLnZlcmlmeUxpc3RTb3J0KHRoaXMuYnVpbGRDdXN0b21Db21wYXJhdG9yKCkpOwotCX0KLQotCXByaXZhdGUgQ29tcGFyYXRvcjxKdW5rPiBidWlsZEN1c3RvbUNvbXBhcmF0b3IoKSB7Ci0JCS8vIHNvcnQgd2l0aCByZXZlcnNlIG9yZGVyCi0JCXJldHVybiBuZXcgQ29tcGFyYXRvcjxKdW5rPigpIHsKLQkJCXB1YmxpYyBpbnQgY29tcGFyZShKdW5rIG8xLCBKdW5rIG8yKSB7Ci0JCQkJcmV0dXJuIG8yLmNvbXBhcmVUbyhvMSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUNvbGxlY3Rpb25Tb3J0KENvbXBhcmF0b3I8SnVuaz4gY29tcGFyYXRvcikgewotCQlTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxKdW5rPiBjb2xsZWN0aW9uSG9sZGVyID0gdGhpcy5idWlsZENvbGxlY3Rpb25Ib2xkZXIoKTsKLQkJTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdFZhbHVlTW9kZWwgPSBuZXcgSXRlbVByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyPEp1bms+KG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8SnVuaz4oY29sbGVjdGlvbkhvbGRlciwgY29tcGFyYXRvciksIERpc3BsYXlhYmxlLkRJU1BMQVlfU1RSSU5HX1BST1BFUlRZLCBEaXNwbGF5YWJsZS5JQ09OX1BST1BFUlRZKTsKLQkJQ29vcmRpbmF0ZWRMaXN0PEp1bms+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8SnVuaz4obGlzdFZhbHVlTW9kZWwpOwotCQlhc3NlcnRFcXVhbHMoNiwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZVNvcnQobGlzdFZhbHVlTW9kZWwsIHN5bmNoTGlzdCwgY29tcGFyYXRvcik7Ci0KLQkJY29sbGVjdGlvbkhvbGRlci5hZGQodGhpcy50b20pOwotCQljb2xsZWN0aW9uSG9sZGVyLmFkZCh0aGlzLmRpY2spOwotCQljb2xsZWN0aW9uSG9sZGVyLmFkZCh0aGlzLmhhcnJ5KTsKLQkJYXNzZXJ0RXF1YWxzKDksIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmVTb3J0KGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QsIGNvbXBhcmF0b3IpOwotCi0JCWNvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlKHRoaXMuZm9vKTsKLQkJY29sbGVjdGlvbkhvbGRlci5yZW1vdmUodGhpcy5qYXIpOwotCQljb2xsZWN0aW9uSG9sZGVyLnJlbW92ZSh0aGlzLmhhcnJ5KTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmVTb3J0KGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QsIGNvbXBhcmF0b3IpOwotCi0JCWNvbGxlY3Rpb25Ib2xkZXIuc2V0Q29sbGVjdGlvbih0aGlzLmJ1aWxkQ29sbGVjdGlvbigpKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmVTb3J0KGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QsIGNvbXBhcmF0b3IpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlMaXN0U29ydChDb21wYXJhdG9yPEp1bms+IGNvbXBhcmF0b3IpIHsKLQkJU2ltcGxlTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdEhvbGRlciA9IHRoaXMuYnVpbGRMaXN0SG9sZGVyKCk7Ci0JCUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RWYWx1ZU1vZGVsID0gbmV3IEl0ZW1Qcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxKdW5rPihuZXcgU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyPEp1bms+KGxpc3RIb2xkZXIsIGNvbXBhcmF0b3IpLCBEaXNwbGF5YWJsZS5ESVNQTEFZX1NUUklOR19QUk9QRVJUWSwgRGlzcGxheWFibGUuSUNPTl9QUk9QRVJUWSk7Ci0JCUNvb3JkaW5hdGVkTGlzdDxKdW5rPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PEp1bms+KGxpc3RWYWx1ZU1vZGVsKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmVTb3J0KGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QsIGNvbXBhcmF0b3IpOwotCi0JCWxpc3RIb2xkZXIuYWRkKDAsIHRoaXMudG9tKTsKLQkJbGlzdEhvbGRlci5hZGQoMCwgdGhpcy5kaWNrKTsKLQkJbGlzdEhvbGRlci5hZGQoMCwgdGhpcy5oYXJyeSk7Ci0JCWFzc2VydEVxdWFscyg5LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlU29ydChsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0LCBjb21wYXJhdG9yKTsKLQotCQlsaXN0SG9sZGVyLnJlbW92ZSg4KTsKLQkJbGlzdEhvbGRlci5yZW1vdmUoNCk7Ci0JCWxpc3RIb2xkZXIucmVtb3ZlKDApOwotCQlsaXN0SG9sZGVyLnJlbW92ZSg1KTsKLQkJYXNzZXJ0RXF1YWxzKDUsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmVTb3J0KGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QsIGNvbXBhcmF0b3IpOwotCi0JCWxpc3RIb2xkZXIuc2V0TGlzdCh0aGlzLmJ1aWxkTGlzdCgpKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmVTb3J0KGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QsIGNvbXBhcmF0b3IpOwotCX0KLQotCXByaXZhdGUgdm9pZCBjb21wYXJlU29ydChMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCwgTGlzdDxKdW5rPiBsaXN0LCBDb21wYXJhdG9yPEp1bms+IGNvbXBhcmF0b3IpIHsKLQkJU29ydGVkU2V0PEp1bms+IHNzID0gbmV3IFRyZWVTZXQ8SnVuaz4oY29tcGFyYXRvcik7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGlzdFZhbHVlTW9kZWwuc2l6ZSgpOyBpKyspIHsKLQkJCXNzLmFkZChsaXN0VmFsdWVNb2RlbC5nZXQoaSkpOwotCQl9Ci0JCWFzc2VydEVxdWFscyhzcy5zaXplKCksIGxpc3Quc2l6ZSgpKTsKLQkJZm9yIChJdGVyYXRvcjxKdW5rPiBzdHJlYW0xID0gc3MuaXRlcmF0b3IoKSwgc3RyZWFtMiA9IGxpc3QuaXRlcmF0b3IoKTsgc3RyZWFtMS5oYXNOZXh0KCk7ICkgewotCQkJYXNzZXJ0RXF1YWxzKHN0cmVhbTEubmV4dCgpLCBzdHJlYW0yLm5leHQoKSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcigpOwotCQlhc3NlcnRGYWxzZShsaXN0SG9sZGVyLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5mb28uaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoRGlzcGxheWFibGUuRElTUExBWV9TVFJJTkdfUFJPUEVSVFkpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5mb28uaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoRGlzcGxheWFibGUuSUNPTl9QUk9QRVJUWSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmphei5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhEaXNwbGF5YWJsZS5ESVNQTEFZX1NUUklOR19QUk9QRVJUWSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmphei5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhEaXNwbGF5YWJsZS5JQ09OX1BST1BFUlRZKSk7Ci0KLQkJTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdFZhbHVlTW9kZWwgPSBuZXcgSXRlbVByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyPEp1bms+KG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8SnVuaz4obGlzdEhvbGRlciksIERpc3BsYXlhYmxlLkRJU1BMQVlfU1RSSU5HX1BST1BFUlRZLCBEaXNwbGF5YWJsZS5JQ09OX1BST1BFUlRZKTsKLQkJYXNzZXJ0RmFsc2UobGlzdEhvbGRlci5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuZm9vLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKERpc3BsYXlhYmxlLkRJU1BMQVlfU1RSSU5HX1BST1BFUlRZKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuZm9vLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKERpc3BsYXlhYmxlLklDT05fUFJPUEVSVFkpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qYXouaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoRGlzcGxheWFibGUuRElTUExBWV9TVFJJTkdfUFJPUEVSVFkpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qYXouaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoRGlzcGxheWFibGUuSUNPTl9QUk9QRVJUWSkpOwotCQl0aGlzLnZlcmlmeUhhc05vTGlzdGVuZXJzKGxpc3RWYWx1ZU1vZGVsKTsKLQotCQlDb29yZGluYXRlZExpc3Q8SnVuaz4gc3luY2hMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxKdW5rPihsaXN0VmFsdWVNb2RlbCk7Ci0JCWFzc2VydFRydWUobGlzdEhvbGRlci5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0JCWFzc2VydFRydWUodGhpcy5mb28uaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoRGlzcGxheWFibGUuRElTUExBWV9TVFJJTkdfUFJPUEVSVFkpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmZvby5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhEaXNwbGF5YWJsZS5JQ09OX1BST1BFUlRZKSk7Ci0JCWFzc2VydFRydWUodGhpcy5qYXouaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoRGlzcGxheWFibGUuRElTUExBWV9TVFJJTkdfUFJPUEVSVFkpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmphei5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhEaXNwbGF5YWJsZS5JQ09OX1BST1BFUlRZKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTGlzdGVuZXJzKGxpc3RWYWx1ZU1vZGVsKTsKLQotCQlsaXN0VmFsdWVNb2RlbC5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHN5bmNoTGlzdCk7Ci0JCWFzc2VydEZhbHNlKGxpc3RIb2xkZXIuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmZvby5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhEaXNwbGF5YWJsZS5ESVNQTEFZX1NUUklOR19QUk9QRVJUWSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmZvby5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhEaXNwbGF5YWJsZS5JQ09OX1BST1BFUlRZKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuamF6Lmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKERpc3BsYXlhYmxlLkRJU1BMQVlfU1RSSU5HX1BST1BFUlRZKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuamF6Lmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKERpc3BsYXlhYmxlLklDT05fUFJPUEVSVFkpKTsKLQkJdGhpcy52ZXJpZnlIYXNOb0xpc3RlbmVycyhsaXN0VmFsdWVNb2RlbCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEdldFNpemUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJU2ltcGxlTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdEhvbGRlciA9IHRoaXMuYnVpbGRMaXN0SG9sZGVyKCk7Ci0JCUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RWYWx1ZU1vZGVsID0gbmV3IEl0ZW1Qcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxKdW5rPihuZXcgU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyPEp1bms+KGxpc3RIb2xkZXIpLCBEaXNwbGF5YWJsZS5ESVNQTEFZX1NUUklOR19QUk9QRVJUWSwgRGlzcGxheWFibGUuSUNPTl9QUk9QRVJUWSk7Ci0JCUNvb3JkaW5hdGVkTGlzdDxKdW5rPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PEp1bms+KGxpc3RWYWx1ZU1vZGVsKTsKLQkJdGhpcy52ZXJpZnlIYXNMaXN0ZW5lcnMobGlzdFZhbHVlTW9kZWwpOwotCQlhc3NlcnRFcXVhbHMoNiwgbGlzdFZhbHVlTW9kZWwuc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoTGlzdC5zaXplKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXQoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJU2ltcGxlTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdEhvbGRlciA9IHRoaXMuYnVpbGRMaXN0SG9sZGVyKCk7Ci0JCUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RWYWx1ZU1vZGVsID0gbmV3IFNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxKdW5rPihuZXcgSXRlbVByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyPEp1bms+KGxpc3RIb2xkZXIsIERpc3BsYXlhYmxlLkRJU1BMQVlfU1RSSU5HX1BST1BFUlRZLCBEaXNwbGF5YWJsZS5JQ09OX1BST1BFUlRZKSk7Ci0JCUNvb3JkaW5hdGVkTGlzdDxKdW5rPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PEp1bms+KGxpc3RWYWx1ZU1vZGVsKTsKLQkJdGhpcy52ZXJpZnlIYXNMaXN0ZW5lcnMobGlzdFZhbHVlTW9kZWwpOwotCQlhc3NlcnRFcXVhbHModGhpcy5iYXIsIGxpc3RWYWx1ZU1vZGVsLmdldCgwKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJhciwgc3luY2hMaXN0LmdldCgwKSk7Ci0JCXRoaXMuYmFyLnNldE5hbWUoInp6eiIpOwotCQlhc3NlcnRFcXVhbHModGhpcy5iYXIsIGxpc3RWYWx1ZU1vZGVsLmdldCg1KSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJhciwgc3luY2hMaXN0LmdldCg1KSk7Ci0JCXRoaXMuYmFyLnNldE5hbWUoInRoaXMuYmFyIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUhhc05vTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RWYWx1ZU1vZGVsKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIGxpc3RWYWx1ZU1vZGVsKS5oYXNOb0xpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5SGFzTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RWYWx1ZU1vZGVsKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIGxpc3RWYWx1ZU1vZGVsKS5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0JfQotCi0JcHJpdmF0ZSBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxKdW5rPiBidWlsZENvbGxlY3Rpb25Ib2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8SnVuaz4odGhpcy5idWlsZENvbGxlY3Rpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uPEp1bms+IGJ1aWxkQ29sbGVjdGlvbigpIHsKLQkJQmFnPEp1bms+IGJhZyA9IG5ldyBIYXNoQmFnPEp1bms+KCk7Ci0JCXRoaXMucG9wdWxhdGVDb2xsZWN0aW9uKGJhZyk7Ci0JCXJldHVybiBiYWc7Ci0JfQotCi0JcHJpdmF0ZSBTaW1wbGVMaXN0VmFsdWVNb2RlbDxKdW5rPiBidWlsZExpc3RIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8SnVuaz4odGhpcy5idWlsZExpc3QoKSk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0PEp1bms+IGJ1aWxkTGlzdCgpIHsKLQkJTGlzdDxKdW5rPiBsaXN0ID0gbmV3IEFycmF5TGlzdDxKdW5rPigpOwotCQl0aGlzLnBvcHVsYXRlQ29sbGVjdGlvbihsaXN0KTsKLQkJcmV0dXJuIGxpc3Q7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHBvcHVsYXRlQ29sbGVjdGlvbihDb2xsZWN0aW9uPEp1bms+IGMpIHsKLQkJYy5hZGQodGhpcy5mb28pOwotCQljLmFkZCh0aGlzLmJhcik7Ci0JCWMuYWRkKHRoaXMuYmF6KTsKLQkJYy5hZGQodGhpcy5qb28pOwotCQljLmFkZCh0aGlzLmphcik7Ci0JCWMuYWRkKHRoaXMuamF6KTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogSnVuayBjbGFzcyAqKioqKioqKioqCi0KLQlwcml2YXRlIGNsYXNzIEp1bmsgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIGltcGxlbWVudHMgRGlzcGxheWFibGUgewotCQlwcml2YXRlIFN0cmluZyBuYW1lOwotCQlwdWJsaWMgSnVuayhTdHJpbmcgbmFtZSkgewotCQkJdGhpcy5uYW1lID0gbmFtZTsKLQkJfQotCQlwdWJsaWMgU3RyaW5nIGRpc3BsYXlTdHJpbmcoKSB7Ci0JCQlyZXR1cm4gdGhpcy5uYW1lOwotCQl9Ci0JCXB1YmxpYyBJY29uIGljb24oKSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQlwdWJsaWMgaW50IGNvbXBhcmVUbyhEaXNwbGF5YWJsZSBvKSB7Ci0JCQlyZXR1cm4gREVGQVVMVF9DT01QQVJBVE9SLmNvbXBhcmUodGhpcywgbyk7Ci0JCX0KLQkJcHVibGljIHZvaWQgc2V0TmFtZShTdHJpbmcgbmFtZSkgewotCQkJT2JqZWN0IG9sZCA9IHRoaXMubmFtZTsKLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoRElTUExBWV9TVFJJTkdfUFJPUEVSVFksIG9sZCwgbmFtZSk7Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gIkp1bmsoIiArIHRoaXMubmFtZSArICIpIjsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9JdGVtU3RhdGVMaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9JdGVtU3RhdGVMaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2Mjg1ZjM5Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvSXRlbVN0YXRlTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDMwMiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuQ29tcGFyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLlNvcnRlZFNldDsKLWltcG9ydCBqYXZhLnV0aWwuVHJlZVNldDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQmFnOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkhhc2hCYWc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5JdGVtU3RhdGVMaXN0VmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIEl0ZW1TdGF0ZUxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgSnVuayBmb287Ci0JcHJpdmF0ZSBKdW5rIGJhcjsKLQlwcml2YXRlIEp1bmsgYmF6OwotCXByaXZhdGUgSnVuayBqb287Ci0JcHJpdmF0ZSBKdW5rIGphcjsKLQlwcml2YXRlIEp1bmsgamF6OwotCi0JcHJpdmF0ZSBKdW5rIHRvbTsKLQlwcml2YXRlIEp1bmsgZGljazsKLQlwcml2YXRlIEp1bmsgaGFycnk7Ci0KLQlwdWJsaWMgSXRlbVN0YXRlTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy5mb28gPSBuZXcgSnVuaygidGhpcy5mb28iKTsKLQkJdGhpcy5iYXIgPSBuZXcgSnVuaygidGhpcy5iYXIiKTsKLQkJdGhpcy5iYXogPSBuZXcgSnVuaygidGhpcy5iYXoiKTsKLQkJdGhpcy5qb28gPSBuZXcgSnVuaygidGhpcy5qb28iKTsKLQkJdGhpcy5qYXIgPSBuZXcgSnVuaygidGhpcy5qYXIiKTsKLQkJdGhpcy5qYXogPSBuZXcgSnVuaygidGhpcy5qYXoiKTsKLQotCQl0aGlzLnRvbSA9IG5ldyBKdW5rKCJ0aGlzLnRvbSIpOwotCQl0aGlzLmRpY2sgPSBuZXcgSnVuaygidGhpcy5kaWNrIik7Ci0JCXRoaXMuaGFycnkgPSBuZXcgSnVuaygidGhpcy5oYXJyeSIpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29sbGVjdGlvblN5bmNocm9uaXphdGlvbigpIHsKLQkJU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8SnVuaz4gY29sbGVjdGlvbkhvbGRlciA9IHRoaXMuYnVpbGRDb2xsZWN0aW9uSG9sZGVyKCk7Ci0JCUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RWYWx1ZU1vZGVsID0gbmV3IEl0ZW1TdGF0ZUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxKdW5rPihjb2xsZWN0aW9uSG9sZGVyKTsKLQkJQ29vcmRpbmF0ZWRMaXN0PEp1bms+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8SnVuaz4obGlzdFZhbHVlTW9kZWwpOwotCQlhc3NlcnRFcXVhbHMoNiwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0KTsKLQotCQljb2xsZWN0aW9uSG9sZGVyLmFkZCh0aGlzLnRvbSk7Ci0JCWNvbGxlY3Rpb25Ib2xkZXIuYWRkKHRoaXMuZGljayk7Ci0JCWNvbGxlY3Rpb25Ib2xkZXIuYWRkKHRoaXMuaGFycnkpOwotCQlhc3NlcnRFcXVhbHMoOSwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0KTsKLQotCQljb2xsZWN0aW9uSG9sZGVyLnJlbW92ZSh0aGlzLmZvbyk7Ci0JCWNvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlKHRoaXMuamFyKTsKLQkJY29sbGVjdGlvbkhvbGRlci5yZW1vdmUodGhpcy5oYXJyeSk7Ci0JCWFzc2VydEVxdWFscyg2LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlKGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0U3luY2hyb25pemF0aW9uKCkgewotCQlTaW1wbGVMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0SG9sZGVyID0gdGhpcy5idWlsZExpc3RIb2xkZXIoKTsKLQkJTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdFZhbHVlTW9kZWwgPSBuZXcgSXRlbVN0YXRlTGlzdFZhbHVlTW9kZWxBZGFwdGVyPEp1bms+KGxpc3RIb2xkZXIpOwotCQlDb29yZGluYXRlZExpc3Q8SnVuaz4gc3luY2hMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxKdW5rPihsaXN0VmFsdWVNb2RlbCk7Ci0JCWFzc2VydEVxdWFscyg2LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlKGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QpOwotCi0JCWxpc3RIb2xkZXIuYWRkKDYsIHRoaXMudG9tKTsKLQkJbGlzdEhvbGRlci5hZGQoNywgdGhpcy5kaWNrKTsKLQkJbGlzdEhvbGRlci5hZGQoOCwgdGhpcy5oYXJyeSk7Ci0JCWFzc2VydEVxdWFscyg5LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlKGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QpOwotCi0JCWxpc3RIb2xkZXIucmVtb3ZlKDgpOwotCQlsaXN0SG9sZGVyLnJlbW92ZSgwKTsKLQkJbGlzdEhvbGRlci5yZW1vdmUoNCk7Ci0JCWFzc2VydEVxdWFscyg2LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlKGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QpOwotCX0KLQotCXByaXZhdGUgdm9pZCBjb21wYXJlKExpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RWYWx1ZU1vZGVsLCBMaXN0PEp1bms+IGxpc3QpIHsKLQkJYXNzZXJ0RXF1YWxzKGxpc3RWYWx1ZU1vZGVsLnNpemUoKSwgbGlzdC5zaXplKCkpOwotCQlmb3IgKGludCBpID0gMDsgaSA8IGxpc3RWYWx1ZU1vZGVsLnNpemUoKTsgaSsrKSB7Ci0JCQlhc3NlcnRFcXVhbHMobGlzdFZhbHVlTW9kZWwuZ2V0KGkpLCBsaXN0LmdldChpKSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29sbGVjdGlvblNvcnQoKSB7Ci0JCXRoaXMudmVyaWZ5Q29sbGVjdGlvblNvcnQobnVsbCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RTb3J0KCkgewotCQl0aGlzLnZlcmlmeUxpc3RTb3J0KG51bGwpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDdXN0b21Db2xsZWN0aW9uU29ydCgpIHsKLQkJdGhpcy52ZXJpZnlDb2xsZWN0aW9uU29ydCh0aGlzLmJ1aWxkQ3VzdG9tQ29tcGFyYXRvcigpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q3VzdG9tTGlzdFNvcnQoKSB7Ci0JCXRoaXMudmVyaWZ5TGlzdFNvcnQodGhpcy5idWlsZEN1c3RvbUNvbXBhcmF0b3IoKSk7Ci0JfQotCi0JcHJpdmF0ZSBDb21wYXJhdG9yPEp1bms+IGJ1aWxkQ3VzdG9tQ29tcGFyYXRvcigpIHsKLQkJLy8gc29ydCB3aXRoIHJldmVyc2Ugb3JkZXIKLQkJcmV0dXJuIG5ldyBDb21wYXJhdG9yPEp1bms+KCkgewotCQkJcHVibGljIGludCBjb21wYXJlKEp1bmsgbzEsIEp1bmsgbzIpIHsKLQkJCQlyZXR1cm4gbzIuY29tcGFyZVRvKG8xKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5Q29sbGVjdGlvblNvcnQoQ29tcGFyYXRvcjxKdW5rPiBjb21wYXJhdG9yKSB7Ci0JCVNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPEp1bms+IGNvbGxlY3Rpb25Ib2xkZXIgPSB0aGlzLmJ1aWxkQ29sbGVjdGlvbkhvbGRlcigpOwotCQlMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCA9IG5ldyBJdGVtU3RhdGVMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8SnVuaz4obmV3IFNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxKdW5rPihjb2xsZWN0aW9uSG9sZGVyLCBjb21wYXJhdG9yKSk7Ci0JCUNvb3JkaW5hdGVkTGlzdDxKdW5rPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PEp1bms+KGxpc3RWYWx1ZU1vZGVsKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmVTb3J0KGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QsIGNvbXBhcmF0b3IpOwotCi0JCWNvbGxlY3Rpb25Ib2xkZXIuYWRkKHRoaXMudG9tKTsKLQkJY29sbGVjdGlvbkhvbGRlci5hZGQodGhpcy5kaWNrKTsKLQkJY29sbGVjdGlvbkhvbGRlci5hZGQodGhpcy5oYXJyeSk7Ci0JCWFzc2VydEVxdWFscyg5LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlU29ydChsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0LCBjb21wYXJhdG9yKTsKLQotCQljb2xsZWN0aW9uSG9sZGVyLnJlbW92ZSh0aGlzLmZvbyk7Ci0JCWNvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlKHRoaXMuamFyKTsKLQkJY29sbGVjdGlvbkhvbGRlci5yZW1vdmUodGhpcy5oYXJyeSk7Ci0JCWFzc2VydEVxdWFscyg2LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlU29ydChsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0LCBjb21wYXJhdG9yKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5TGlzdFNvcnQoQ29tcGFyYXRvcjxKdW5rPiBjb21wYXJhdG9yKSB7Ci0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcigpOwotCQlMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCA9IG5ldyBJdGVtU3RhdGVMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8SnVuaz4obmV3IFNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxKdW5rPihsaXN0SG9sZGVyLCBjb21wYXJhdG9yKSk7Ci0JCUNvb3JkaW5hdGVkTGlzdDxKdW5rPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PEp1bms+KGxpc3RWYWx1ZU1vZGVsKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmVTb3J0KGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QsIGNvbXBhcmF0b3IpOwotCi0JCWxpc3RIb2xkZXIuYWRkKDAsIHRoaXMudG9tKTsKLQkJbGlzdEhvbGRlci5hZGQoMCwgdGhpcy5kaWNrKTsKLQkJbGlzdEhvbGRlci5hZGQoMCwgdGhpcy5oYXJyeSk7Ci0JCWFzc2VydEVxdWFscyg5LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlU29ydChsaXN0VmFsdWVNb2RlbCwgc3luY2hMaXN0LCBjb21wYXJhdG9yKTsKLQotCQlsaXN0SG9sZGVyLnJlbW92ZSg4KTsKLQkJbGlzdEhvbGRlci5yZW1vdmUoNCk7Ci0JCWxpc3RIb2xkZXIucmVtb3ZlKDApOwotCQlsaXN0SG9sZGVyLnJlbW92ZSg1KTsKLQkJYXNzZXJ0RXF1YWxzKDUsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmVTb3J0KGxpc3RWYWx1ZU1vZGVsLCBzeW5jaExpc3QsIGNvbXBhcmF0b3IpOwotCX0KLQotCXByaXZhdGUgdm9pZCBjb21wYXJlU29ydChMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCwgTGlzdDxKdW5rPiBsaXN0LCBDb21wYXJhdG9yPEp1bms+IGNvbXBhcmF0b3IpIHsKLQkJU29ydGVkU2V0PEp1bms+IHNzID0gbmV3IFRyZWVTZXQ8SnVuaz4oY29tcGFyYXRvcik7Ci0JCWZvciAoaW50IGkgPSAwOyBpIDwgbGlzdFZhbHVlTW9kZWwuc2l6ZSgpOyBpKyspIHsKLQkJCXNzLmFkZChsaXN0VmFsdWVNb2RlbC5nZXQoaSkpOwotCQl9Ci0JCWFzc2VydEVxdWFscyhzcy5zaXplKCksIGxpc3Quc2l6ZSgpKTsKLQkJZm9yIChJdGVyYXRvcjxKdW5rPiBzdHJlYW0xID0gc3MuaXRlcmF0b3IoKSwgc3RyZWFtMiA9IGxpc3QuaXRlcmF0b3IoKTsgc3RyZWFtMS5oYXNOZXh0KCk7ICkgewotCQkJYXNzZXJ0RXF1YWxzKHN0cmVhbTEubmV4dCgpLCBzdHJlYW0yLm5leHQoKSk7Ci0JCX0KLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcigpOwotCQlhc3NlcnRGYWxzZShsaXN0SG9sZGVyLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5mb28uaGFzQW55U3RhdGVDaGFuZ2VMaXN0ZW5lcnMoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuZm9vLmhhc0FueVN0YXRlQ2hhbmdlTGlzdGVuZXJzKCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmphei5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qYXouaGFzQW55U3RhdGVDaGFuZ2VMaXN0ZW5lcnMoKSk7Ci0KLQkJTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdFZhbHVlTW9kZWwgPSBuZXcgSXRlbVN0YXRlTGlzdFZhbHVlTW9kZWxBZGFwdGVyPEp1bms+KG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8SnVuaz4obGlzdEhvbGRlcikpOwotCQlhc3NlcnRGYWxzZShsaXN0SG9sZGVyLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5mb28uaGFzQW55U3RhdGVDaGFuZ2VMaXN0ZW5lcnMoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuZm9vLmhhc0FueVN0YXRlQ2hhbmdlTGlzdGVuZXJzKCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmphei5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qYXouaGFzQW55U3RhdGVDaGFuZ2VMaXN0ZW5lcnMoKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTm9MaXN0ZW5lcnMobGlzdFZhbHVlTW9kZWwpOwotCi0JCUNvb3JkaW5hdGVkTGlzdDxKdW5rPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PEp1bms+KGxpc3RWYWx1ZU1vZGVsKTsKLQkJYXNzZXJ0VHJ1ZShsaXN0SG9sZGVyLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmZvby5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmZvby5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmphei5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmphei5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQkJdGhpcy52ZXJpZnlIYXNMaXN0ZW5lcnMobGlzdFZhbHVlTW9kZWwpOwotCi0JCWxpc3RWYWx1ZU1vZGVsLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgc3luY2hMaXN0KTsKLQkJYXNzZXJ0RmFsc2UobGlzdEhvbGRlci5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuZm9vLmhhc0FueVN0YXRlQ2hhbmdlTGlzdGVuZXJzKCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmZvby5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qYXouaGFzQW55U3RhdGVDaGFuZ2VMaXN0ZW5lcnMoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuamF6Lmhhc0FueVN0YXRlQ2hhbmdlTGlzdGVuZXJzKCkpOwotCQl0aGlzLnZlcmlmeUhhc05vTGlzdGVuZXJzKGxpc3RWYWx1ZU1vZGVsKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0R2V0U2l6ZSgpIHRocm93cyBFeGNlcHRpb24gewotCQlTaW1wbGVMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0SG9sZGVyID0gdGhpcy5idWlsZExpc3RIb2xkZXIoKTsKLQkJTGlzdFZhbHVlTW9kZWw8SnVuaz4gbGlzdFZhbHVlTW9kZWwgPSBuZXcgSXRlbVN0YXRlTGlzdFZhbHVlTW9kZWxBZGFwdGVyPEp1bms+KG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8SnVuaz4obGlzdEhvbGRlcikpOwotCQlDb29yZGluYXRlZExpc3Q8SnVuaz4gc3luY2hMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxKdW5rPihsaXN0VmFsdWVNb2RlbCk7Ci0JCXRoaXMudmVyaWZ5SGFzTGlzdGVuZXJzKGxpc3RWYWx1ZU1vZGVsKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIGxpc3RWYWx1ZU1vZGVsLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyg2LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0R2V0KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcigpOwotCQlMaXN0VmFsdWVNb2RlbDxKdW5rPiBsaXN0VmFsdWVNb2RlbCA9IG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8SnVuaz4obmV3IEl0ZW1TdGF0ZUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxKdW5rPihsaXN0SG9sZGVyKSk7Ci0JCUNvb3JkaW5hdGVkTGlzdDxKdW5rPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PEp1bms+KGxpc3RWYWx1ZU1vZGVsKTsKLQkJdGhpcy52ZXJpZnlIYXNMaXN0ZW5lcnMobGlzdFZhbHVlTW9kZWwpOwotCQlhc3NlcnRFcXVhbHModGhpcy5iYXIsIGxpc3RWYWx1ZU1vZGVsLmdldCgwKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJhciwgc3luY2hMaXN0LmdldCgwKSk7Ci0JCXRoaXMuYmFyLnNldE5hbWUoInp6eiIpOwotCQlhc3NlcnRFcXVhbHModGhpcy5iYXIsIGxpc3RWYWx1ZU1vZGVsLmdldCg1KSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJhciwgc3luY2hMaXN0LmdldCg1KSk7Ci0JCXRoaXMuYmFyLnNldE5hbWUoInRoaXMuYmFyIik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUhhc05vTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RWYWx1ZU1vZGVsKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIGxpc3RWYWx1ZU1vZGVsKS5oYXNOb0xpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5SGFzTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsPEp1bms+IGxpc3RWYWx1ZU1vZGVsKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIGxpc3RWYWx1ZU1vZGVsKS5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0JfQotCi0JcHJpdmF0ZSBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxKdW5rPiBidWlsZENvbGxlY3Rpb25Ib2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8SnVuaz4odGhpcy5idWlsZENvbGxlY3Rpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uPEp1bms+IGJ1aWxkQ29sbGVjdGlvbigpIHsKLQkJQmFnPEp1bms+IGJhZyA9IG5ldyBIYXNoQmFnPEp1bms+KCk7Ci0JCXRoaXMucG9wdWxhdGVDb2xsZWN0aW9uKGJhZyk7Ci0JCXJldHVybiBiYWc7Ci0JfQotCi0JcHJpdmF0ZSBTaW1wbGVMaXN0VmFsdWVNb2RlbDxKdW5rPiBidWlsZExpc3RIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8SnVuaz4odGhpcy5idWlsZExpc3QoKSk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0PEp1bms+IGJ1aWxkTGlzdCgpIHsKLQkJTGlzdDxKdW5rPiBsaXN0ID0gbmV3IEFycmF5TGlzdDxKdW5rPigpOwotCQl0aGlzLnBvcHVsYXRlQ29sbGVjdGlvbihsaXN0KTsKLQkJcmV0dXJuIGxpc3Q7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHBvcHVsYXRlQ29sbGVjdGlvbihDb2xsZWN0aW9uPEp1bms+IGMpIHsKLQkJYy5hZGQodGhpcy5mb28pOwotCQljLmFkZCh0aGlzLmJhcik7Ci0JCWMuYWRkKHRoaXMuYmF6KTsKLQkJYy5hZGQodGhpcy5qb28pOwotCQljLmFkZCh0aGlzLmphcik7Ci0JCWMuYWRkKHRoaXMuamF6KTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIEp1bmsgY2xhc3MgKioqKioqKioqKgotCXByaXZhdGUgY2xhc3MgSnVuayBleHRlbmRzIEFic3RyYWN0TW9kZWwgaW1wbGVtZW50cyBDb21wYXJhYmxlPEp1bms+IHsKLQkJcHJpdmF0ZSBTdHJpbmcgbmFtZTsKLQkJcHVibGljIEp1bmsoU3RyaW5nIG5hbWUpIHsKLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCX0KLQkJcHVibGljIHZvaWQgc2V0TmFtZShTdHJpbmcgbmFtZSkgewotCQkJdGhpcy5uYW1lID0gbmFtZTsKLQkJCXRoaXMuZmlyZVN0YXRlQ2hhbmdlZCgpOwotCQl9Ci0JCXB1YmxpYyBpbnQgY29tcGFyZVRvKEp1bmsgaikgewotCQkJcmV0dXJuIHRoaXMubmFtZS5jb21wYXJlVG8oai5uYW1lKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiSnVuaygiICsgdGhpcy5uYW1lICsgIikiOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0pwdFV0aWxpdHlNb2RlbFZhbHVlVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvSnB0VXRpbGl0eU1vZGVsVmFsdWVUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5OTU4NWU2Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvSnB0VXRpbGl0eU1vZGVsVmFsdWVUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNzMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0OwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0U3VpdGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWUucHJlZnMuSnB0VXRpbGl0eU1vZGVsVmFsdWVQcmVmc1Rlc3RzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLkpwdFV0aWxpdHlNb2RlbFZhbHVlU3dpbmdUZXN0czsKLQotcHVibGljIGNsYXNzIEpwdFV0aWxpdHlNb2RlbFZhbHVlVGVzdHMgewotCQotCXB1YmxpYyBzdGF0aWMgVGVzdCBzdWl0ZSgpIHsKLQkJVGVzdFN1aXRlIHN1aXRlID0gbmV3IFRlc3RTdWl0ZShKcHRVdGlsaXR5TW9kZWxWYWx1ZVRlc3RzLmNsYXNzLmdldFBhY2thZ2UoKS5nZXROYW1lKCkpOwotCi0JCXN1aXRlLmFkZFRlc3QoSnB0VXRpbGl0eU1vZGVsVmFsdWVQcmVmc1Rlc3RzLnN1aXRlKCkpOwotCQlzdWl0ZS5hZGRUZXN0KEpwdFV0aWxpdHlNb2RlbFZhbHVlU3dpbmdUZXN0cy5zdWl0ZSgpKTsKLQkJCi0JCXN1aXRlLmFkZFRlc3RTdWl0ZShCdWZmZXJlZFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoQ2FjaGluZ1RyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoQ2FjaGluZ1RyYW5zZm9ybWF0aW9uV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShDb2xsZWN0aW9uQXNwZWN0QWRhcHRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKENvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShDb2xsZWN0aW9uUHJvcGVydHlWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKENvbXBvc2l0ZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoQ29tcG9zaXRlTGlzdFZhbHVlTW9kZWxUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShFeHRlbmRlZExpc3RWYWx1ZU1vZGVsV3JhcHBlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKEZpbHRlcmluZ0NvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoRmlsdGVyaW5nUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoSXRlbUNvbGxlY3Rpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShJdGVtTGlzdExpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKEl0ZW1Qcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKEl0ZW1TdGF0ZUxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKExpc3RBc3BlY3RBZGFwdGVyVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoTGlzdENvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKExpc3RDdXJhdG9yVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoTnVsbENvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoTnVsbExpc3RWYWx1ZU1vZGVsVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoTnVsbFByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFByb3BlcnR5QXNwZWN0QWRhcHRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFByb3BlcnR5Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShTdGF0aWNDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFN0YXRpY0xpc3RWYWx1ZU1vZGVsVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShTaW1wbGVMaXN0VmFsdWVNb2RlbFRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFN0YXRpY1ZhbHVlTW9kZWxUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShUcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFRyYW5zZm9ybWF0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuVHJhbnNmb3JtZXJUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFRyZWVBc3BlY3RBZGFwdGVyVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoVmFsdWVDb2xsZWN0aW9uQWRhcHRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFZhbHVlTGlzdEFkYXB0ZXJUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShWYWx1ZVByb3BlcnR5QWRhcHRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFZhbHVlU3RhdGVBZGFwdGVyVGVzdHMuY2xhc3MpOwotCQotCQlyZXR1cm4gc3VpdGU7Ci0JfQotCQotCXByaXZhdGUgSnB0VXRpbGl0eU1vZGVsVmFsdWVUZXN0cygpIHsKLQkJc3VwZXIoKTsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9MaXN0QXNwZWN0QWRhcHRlclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0xpc3RBc3BlY3RBZGFwdGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDA1YzM2MC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0xpc3RBc3BlY3RBZGFwdGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQ3MyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlJlYWRPbmx5TGlzdEl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuTGlzdEFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50Lkxpc3RDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5MaXN0Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIExpc3RBc3BlY3RBZGFwdGVyVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBUZXN0U3ViamVjdCBzdWJqZWN0MTsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RTdWJqZWN0PiBzdWJqZWN0SG9sZGVyMTsKLQlwcml2YXRlIExvY2FsTGlzdEFzcGVjdEFkYXB0ZXIgYWExOwotCXByaXZhdGUgTGlzdENoYW5nZUV2ZW50IGV2ZW50MTsKLQlwcml2YXRlIExpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcjE7Ci0KLQlwcml2YXRlIFRlc3RTdWJqZWN0IHN1YmplY3QyOwotCi0JcHVibGljIExpc3RBc3BlY3RBZGFwdGVyVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy5zdWJqZWN0MSA9IG5ldyBUZXN0U3ViamVjdCgpOwotCQl0aGlzLnN1YmplY3QxLmFkZE5hbWVzKHRoaXMuc3ViamVjdDFOYW1lcygpKTsKLQkJdGhpcy5zdWJqZWN0MS5hZGREZXNjcmlwdGlvbnModGhpcy5zdWJqZWN0MURlc2NyaXB0aW9ucygpKTsKLQkJdGhpcy5zdWJqZWN0SG9sZGVyMSA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdFN1YmplY3Q+KHRoaXMuc3ViamVjdDEpOwotCQl0aGlzLmFhMSA9IHRoaXMuYnVpbGRBc3BlY3RBZGFwdGVyKHRoaXMuc3ViamVjdEhvbGRlcjEpOwotCQl0aGlzLmxpc3RlbmVyMSA9IHRoaXMuYnVpbGRWYWx1ZUNoYW5nZUxpc3RlbmVyMSgpOwotCQl0aGlzLmFhMS5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMubGlzdGVuZXIxKTsKLQkJdGhpcy5ldmVudDEgPSBudWxsOwotCi0JCXRoaXMuc3ViamVjdDIgPSBuZXcgVGVzdFN1YmplY3QoKTsKLQkJdGhpcy5zdWJqZWN0Mi5hZGROYW1lcyh0aGlzLnN1YmplY3QyTmFtZXMoKSk7Ci0JCXRoaXMuc3ViamVjdDIuYWRkRGVzY3JpcHRpb25zKHRoaXMuc3ViamVjdDJEZXNjcmlwdGlvbnMoKSk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0PFN0cmluZz4gc3ViamVjdDFOYW1lcygpIHsKLQkJTGlzdDxTdHJpbmc+IHJlc3VsdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlyZXN1bHQuYWRkKCJmb28iKTsKLQkJcmVzdWx0LmFkZCgiYmFyIik7Ci0JCXJlc3VsdC5hZGQoImJheiIpOwotCQlyZXN1bHQuYWRkKCJiYW0iKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBzdWJqZWN0MURlc2NyaXB0aW9ucygpIHsKLQkJTGlzdDxTdHJpbmc+IHJlc3VsdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlyZXN1bHQuYWRkKCJ0aGlzLnN1YmplY3QxIGRlc2NyaXB0aW9uMSIpOwotCQlyZXN1bHQuYWRkKCJ0aGlzLnN1YmplY3QxIGRlc2NyaXB0aW9uMiIpOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCXByaXZhdGUgTGlzdDxTdHJpbmc+IHN1YmplY3QyTmFtZXMoKSB7Ci0JCUxpc3Q8U3RyaW5nPiByZXN1bHQgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJcmVzdWx0LmFkZCgiam9vIik7Ci0JCXJlc3VsdC5hZGQoImphciIpOwotCQlyZXN1bHQuYWRkKCJqYXoiKTsKLQkJcmVzdWx0LmFkZCgiamFtIik7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0PFN0cmluZz4gc3ViamVjdDJEZXNjcmlwdGlvbnMoKSB7Ci0JCUxpc3Q8U3RyaW5nPiByZXN1bHQgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJcmVzdWx0LmFkZCgidGhpcy5zdWJqZWN0MiBkZXNjcmlwdGlvbjEiKTsKLQkJcmVzdWx0LmFkZCgidGhpcy5zdWJqZWN0MiBkZXNjcmlwdGlvbjIiKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwcml2YXRlIExvY2FsTGlzdEFzcGVjdEFkYXB0ZXIgYnVpbGRBc3BlY3RBZGFwdGVyKFByb3BlcnR5VmFsdWVNb2RlbDxUZXN0U3ViamVjdD4gc3ViamVjdEhvbGRlcikgewotCQlyZXR1cm4gbmV3IExvY2FsTGlzdEFzcGVjdEFkYXB0ZXIoc3ViamVjdEhvbGRlcik7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0Q2hhbmdlTGlzdGVuZXIgYnVpbGRWYWx1ZUNoYW5nZUxpc3RlbmVyMSgpIHsKLQkJcmV0dXJuIG5ldyBMaXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJTGlzdEFzcGVjdEFkYXB0ZXJUZXN0cy50aGlzLnZhbHVlMUNoYW5nZWQoZSk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc1JlbW92ZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJCQlMaXN0QXNwZWN0QWRhcHRlclRlc3RzLnRoaXMudmFsdWUxQ2hhbmdlZChlKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJCQlMaXN0QXNwZWN0QWRhcHRlclRlc3RzLnRoaXMudmFsdWUxQ2hhbmdlZChlKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJCQlMaXN0QXNwZWN0QWRhcHRlclRlc3RzLnRoaXMudmFsdWUxQ2hhbmdlZChlKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGxpc3RDbGVhcmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJTGlzdEFzcGVjdEFkYXB0ZXJUZXN0cy50aGlzLnZhbHVlMUNoYW5nZWQoZSk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBsaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJCUxpc3RBc3BlY3RBZGFwdGVyVGVzdHMudGhpcy52YWx1ZTFDaGFuZ2VkKGUpOwotCQkJfQotCQl9OwotCX0KLQotCXZvaWQgdmFsdWUxQ2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQl0aGlzLmV2ZW50MSA9IGU7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTdWJqZWN0SG9sZGVyKCkgewotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0MU5hbWVzKCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuYWExLmxpc3RJdGVyYXRvcigpKSk7Ci0JCWFzc2VydE51bGwodGhpcy5ldmVudDEpOwotCi0JCXRoaXMuc3ViamVjdEhvbGRlcjEuc2V0VmFsdWUodGhpcy5zdWJqZWN0Mik7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hYTEsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmV2ZW50MS5nZXRMaXN0TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKC0xLCB0aGlzLmV2ZW50MS5nZXRJbmRleCgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5ldmVudDEuaXRlbXMoKS5oYXNOZXh0KCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0Mk5hbWVzKCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuYWExLmxpc3RJdGVyYXRvcigpKSk7Ci0JCQotCQl0aGlzLmV2ZW50MSA9IG51bGw7Ci0JCXRoaXMuc3ViamVjdEhvbGRlcjEuc2V0VmFsdWUobnVsbCk7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hYTEsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmV2ZW50MS5nZXRMaXN0TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKC0xLCB0aGlzLmV2ZW50MS5nZXRJbmRleCgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5ldmVudDEuaXRlbXMoKS5oYXNOZXh0KCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmFhMS5pdGVyYXRvcigpLmhhc05leHQoKSk7Ci0JCQotCQl0aGlzLmV2ZW50MSA9IG51bGw7Ci0JCXRoaXMuc3ViamVjdEhvbGRlcjEuc2V0VmFsdWUodGhpcy5zdWJqZWN0MSk7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hYTEsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmV2ZW50MS5nZXRMaXN0TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKC0xLCB0aGlzLmV2ZW50MS5nZXRJbmRleCgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5ldmVudDEuaXRlbXMoKS5oYXNOZXh0KCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0MU5hbWVzKCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuYWExLmxpc3RJdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZCgpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLCBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmFhMS5saXN0SXRlcmF0b3IoKSkpOwotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQxKTsKLQotCQl0aGlzLnN1YmplY3QxLmFkZE5hbWUoImphbSIpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQxKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYWExLCB0aGlzLmV2ZW50MS5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5ldmVudDEuZ2V0TGlzdE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnN1YmplY3QxTmFtZXMoKS5zaXplKCksIHRoaXMuZXZlbnQxLmdldEluZGV4KCkpOwotCQlhc3NlcnRFcXVhbHMoImphbSIsIHRoaXMuZXZlbnQxLml0ZW1zKCkubmV4dCgpKTsKLQkJTGlzdDxTdHJpbmc+IG5hbWVzUGx1cyA9IHRoaXMuc3ViamVjdDFOYW1lcygpOwotCQluYW1lc1BsdXMuYWRkKCJqYW0iKTsKLQkJYXNzZXJ0RXF1YWxzKG5hbWVzUGx1cywgQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5hYTEubGlzdEl0ZXJhdG9yKCkpKTsKLQotCQl0aGlzLmV2ZW50MSA9IG51bGw7Ci0JCXRoaXMuYWExLmFkZCgyLCAiamF6Iik7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hYTEsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmV2ZW50MS5nZXRMaXN0TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIHRoaXMuZXZlbnQxLmdldEluZGV4KCkpOwotCQlhc3NlcnRFcXVhbHMoImpheiIsIHRoaXMuZXZlbnQxLml0ZW1zKCkubmV4dCgpKTsKLQkJbmFtZXNQbHVzLmFkZCgyLCAiamF6Iik7Ci0JCWFzc2VydEVxdWFscyhuYW1lc1BsdXMsIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuYWExLmxpc3RJdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdERlZmF1bHRBZGQoKSB7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnN1YmplY3QxTmFtZXMoKSwgQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5hYTEubGlzdEl0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50MSk7Ci0KLQkJTGlzdDxTdHJpbmc+IGl0ZW1zID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWl0ZW1zLmFkZCgiam9vIik7Ci0JCWl0ZW1zLmFkZCgiamFyIik7Ci0JCWl0ZW1zLmFkZCgiamF6Iik7Ci0JCWl0ZW1zLmFkZCgiamFtIik7Ci0KLQkJdGhpcy5ldmVudDEgPSBudWxsOwotCQl0aGlzLmFhMS5hZGRBbGwoMiwgaXRlbXMpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQxKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYWExLCB0aGlzLmV2ZW50MS5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5ldmVudDEuZ2V0TGlzdE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscyg1LCB0aGlzLmV2ZW50MS5nZXRJbmRleCgpKTsJCS8vIG9ubHkgdGhlIGxhc3QgImFkZCIgZXZlbnQgd2lsbCBzdGlsbCBiZSB0aGVyZQotCQlhc3NlcnRFcXVhbHMoImphbSIsIHRoaXMuZXZlbnQxLml0ZW1zKCkubmV4dCgpKTsKLQkJTGlzdDxTdHJpbmc+IG5hbWVzUGx1cyA9IHRoaXMuc3ViamVjdDFOYW1lcygpOwotCQluYW1lc1BsdXMuYWRkQWxsKDIsIGl0ZW1zKTsKLQkJYXNzZXJ0RXF1YWxzKG5hbWVzUGx1cywgQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5hYTEubGlzdEl0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlKCkgewotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0MU5hbWVzKCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuYWExLmxpc3RJdGVyYXRvcigpKSk7Ci0JCWFzc2VydE51bGwodGhpcy5ldmVudDEpOwotCi0JCVN0cmluZyByZW1vdmVkTmFtZSA9IHRoaXMuc3ViamVjdDEucmVtb3ZlTmFtZSgwKTsJLy8gc2hvdWxkIGJlICJmb28iCi0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hYTEsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmV2ZW50MS5nZXRMaXN0TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHRoaXMuZXZlbnQxLmdldEluZGV4KCkpOwotCQlhc3NlcnRFcXVhbHMocmVtb3ZlZE5hbWUsIHRoaXMuZXZlbnQxLml0ZW1zKCkubmV4dCgpKTsKLQkJTGlzdDxTdHJpbmc+IG5hbWVzTWludXMgPSB0aGlzLnN1YmplY3QxTmFtZXMoKTsKLQkJbmFtZXNNaW51cy5yZW1vdmUoMCk7Ci0JCWFzc2VydEVxdWFscyhuYW1lc01pbnVzLCBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmFhMS5saXN0SXRlcmF0b3IoKSkpOwotCi0JCXRoaXMuZXZlbnQxID0gbnVsbDsKLQkJT2JqZWN0IHJlbW92ZWRJdGVtID0gdGhpcy5hYTEucmVtb3ZlKDApOwkKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmV2ZW50MSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmFhMSwgdGhpcy5ldmVudDEuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMuZXZlbnQxLmdldExpc3ROYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgdGhpcy5ldmVudDEuZ2V0SW5kZXgoKSk7Ci0JCWFzc2VydEVxdWFscyhyZW1vdmVkSXRlbSwgdGhpcy5ldmVudDEuaXRlbXMoKS5uZXh0KCkpOwotCQluYW1lc01pbnVzLnJlbW92ZSgwKTsKLQkJYXNzZXJ0RXF1YWxzKG5hbWVzTWludXMsIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuYWExLmxpc3RJdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdERlZmF1bHRMZW5ndGgoKSB7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnN1YmplY3QxTmFtZXMoKSwgQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5hYTEubGlzdEl0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50MSk7Ci0KLQkJTGlzdDxTdHJpbmc+IGl0ZW1zID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWl0ZW1zLmFkZCgiYmFyIik7Ci0JCWl0ZW1zLmFkZCgiYmF6Iik7Ci0KLQkJdGhpcy5ldmVudDEgPSBudWxsOwotCQl0aGlzLmFhMS5yZW1vdmUoMSwgMik7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hYTEsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmV2ZW50MS5nZXRMaXN0TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIHRoaXMuZXZlbnQxLmdldEluZGV4KCkpOwkJLy8gb25seSB0aGUgbGFzdCAicmVtb3ZlIiBldmVudCB3aWxsIHN0aWxsIGJlIHRoZXJlCi0JCWFzc2VydEVxdWFscygiYmF6IiwgdGhpcy5ldmVudDEuaXRlbXMoKS5uZXh0KCkpOwotCQlMaXN0PFN0cmluZz4gbmFtZXNQbHVzID0gdGhpcy5zdWJqZWN0MU5hbWVzKCk7Ci0JCW5hbWVzUGx1cy5yZW1vdmUoMSk7Ci0JCW5hbWVzUGx1cy5yZW1vdmUoMSk7Ci0JCWFzc2VydEVxdWFscyhuYW1lc1BsdXMsIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuYWExLmxpc3RJdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlcGxhY2UoKSB7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnN1YmplY3QxTmFtZXMoKSwgQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5hYTEubGlzdEl0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50MSk7Ci0KLQkJU3RyaW5nIHJlcGxhY2VkTmFtZSA9IHRoaXMuc3ViamVjdDEuc2V0TmFtZSgwLCAiamVsbHkiKTsJLy8gc2hvdWxkIGJlICJmb28iCi0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hYTEsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmV2ZW50MS5nZXRMaXN0TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHRoaXMuZXZlbnQxLmdldEluZGV4KCkpOwotCQlhc3NlcnRFcXVhbHMoImplbGx5IiwgdGhpcy5ldmVudDEuaXRlbXMoKS5uZXh0KCkpOwotCQlhc3NlcnRFcXVhbHMocmVwbGFjZWROYW1lLCB0aGlzLmV2ZW50MS5yZXBsYWNlZEl0ZW1zKCkubmV4dCgpKTsKLQkJTGlzdDxTdHJpbmc+IG5hbWVzQ2hhbmdlZCA9IHRoaXMuc3ViamVjdDFOYW1lcygpOwotCQluYW1lc0NoYW5nZWQuc2V0KDAsICJqZWxseSIpOwotCQlhc3NlcnRFcXVhbHMobmFtZXNDaGFuZ2VkLCBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmFhMS5saXN0SXRlcmF0b3IoKSkpOwotCi0JCXRoaXMuZXZlbnQxID0gbnVsbDsKLQkJcmVwbGFjZWROYW1lID0gdGhpcy5zdWJqZWN0MS5zZXROYW1lKDEsICJyb2xsIik7CS8vIHNob3VsZCBiZSAiYmFyIgotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQxKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYWExLCB0aGlzLmV2ZW50MS5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5ldmVudDEuZ2V0TGlzdE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCB0aGlzLmV2ZW50MS5nZXRJbmRleCgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJyb2xsIiwgdGhpcy5ldmVudDEuaXRlbXMoKS5uZXh0KCkpOwotCQlhc3NlcnRFcXVhbHMocmVwbGFjZWROYW1lLCB0aGlzLmV2ZW50MS5yZXBsYWNlZEl0ZW1zKCkubmV4dCgpKTsKLQkJbmFtZXNDaGFuZ2VkID0gdGhpcy5zdWJqZWN0MU5hbWVzKCk7Ci0JCW5hbWVzQ2hhbmdlZC5zZXQoMCwgImplbGx5Iik7Ci0JCW5hbWVzQ2hhbmdlZC5zZXQoMSwgInJvbGwiKTsKLQkJYXNzZXJ0RXF1YWxzKG5hbWVzQ2hhbmdlZCwgQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5hYTEubGlzdEl0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdENoYW5nZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLCBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmFhMS5saXN0SXRlcmF0b3IoKSkpOwotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQxKTsKLQotCQl0aGlzLnN1YmplY3QxLmFkZFR3b05hbWVzKCJqYW0iLCAiamF6Iik7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hYTEsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmV2ZW50MS5nZXRMaXN0TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKC0xLCB0aGlzLmV2ZW50MS5nZXRJbmRleCgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5ldmVudDEuaXRlbXMoKS5oYXNOZXh0KCkpOwotCQlMaXN0PFN0cmluZz4gbmFtZXNQbHVzMiA9IHRoaXMuc3ViamVjdDFOYW1lcygpOwotCQluYW1lc1BsdXMyLmFkZCgwLCAiamF6Iik7Ci0JCW5hbWVzUGx1czIuYWRkKDAsICJqYW0iKTsKLQkJYXNzZXJ0RXF1YWxzKG5hbWVzUGx1czIsIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuYWExLmxpc3RJdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZXJhdG9yKCkgewotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0MU5hbWVzKCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuc3ViamVjdDEubmFtZXMoKSkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0MU5hbWVzKCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuYWExLmxpc3RJdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEdldCgpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLmdldCgwKSwgdGhpcy5zdWJqZWN0MS5nZXROYW1lKDApKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLmdldCgwKSwgdGhpcy5hYTEuZ2V0KDApKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2l6ZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLnNpemUoKSwgQ29sbGVjdGlvblRvb2xzLnNpemUodGhpcy5zdWJqZWN0MS5uYW1lcygpKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnN1YmplY3QxTmFtZXMoKS5zaXplKCksIENvbGxlY3Rpb25Ub29scy5zaXplKHRoaXMuYWExLmxpc3RJdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc0xpc3RlbmVycygpIHsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmFhMS5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0JCWFzc2VydFRydWUodGhpcy5zdWJqZWN0MS5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKFRlc3RTdWJqZWN0Lk5BTUVTX0xJU1QpKTsKLQkJdGhpcy5hYTEucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmxpc3RlbmVyMSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc3ViamVjdDEuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhUZXN0U3ViamVjdC5OQU1FU19MSVNUKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYWExLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQotCQlMaXN0Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIyID0gdGhpcy5idWlsZFZhbHVlQ2hhbmdlTGlzdGVuZXIxKCk7Ci0JCXRoaXMuYWExLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcjIpOwotCQlhc3NlcnRUcnVlKHRoaXMuYWExLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnN1YmplY3QxLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoVGVzdFN1YmplY3QuTkFNRVNfTElTVCkpOwotCQl0aGlzLmFhMS5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIyKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zdWJqZWN0MS5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKFRlc3RTdWJqZWN0Lk5BTUVTX0xJU1QpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5hYTEuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbm5lciBjbGFzcyAqKioqKioqKioqCi0KLQlwcml2YXRlIGNsYXNzIFRlc3RTdWJqZWN0IGV4dGVuZHMgQWJzdHJhY3RNb2RlbCB7Ci0JCXByaXZhdGUgTGlzdDxTdHJpbmc+IG5hbWVzOwotCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBOQU1FU19MSVNUID0gIm5hbWVzIjsKLQkJcHJpdmF0ZSBMaXN0PFN0cmluZz4gZGVzY3JpcHRpb25zOwotCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBERVNDUklQVElPTlNfTElTVCA9ICJkZXNjcmlwdGlvbnMiOwotCQotCQlwdWJsaWMgVGVzdFN1YmplY3QoKSB7Ci0JCQl0aGlzLm5hbWVzID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCQl0aGlzLmRlc2NyaXB0aW9ucyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQl9Ci0JCXB1YmxpYyBMaXN0SXRlcmF0b3I8U3RyaW5nPiBuYW1lcygpIHsKLQkJCXJldHVybiBuZXcgUmVhZE9ubHlMaXN0SXRlcmF0b3I8U3RyaW5nPih0aGlzLm5hbWVzKTsKLQkJfQotCQlwdWJsaWMgU3RyaW5nIGdldE5hbWUoaW50IGluZGV4KSB7Ci0JCQlyZXR1cm4gdGhpcy5uYW1lcy5nZXQoaW5kZXgpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGFkZE5hbWUoaW50IGluZGV4LCBTdHJpbmcgbmFtZSkgewotCQkJdGhpcy5uYW1lcy5hZGQoaW5kZXgsIG5hbWUpOwotCQkJdGhpcy5maXJlSXRlbUFkZGVkKE5BTUVTX0xJU1QsIGluZGV4LCBuYW1lKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBhZGROYW1lKFN0cmluZyBuYW1lKSB7Ci0JCQl0aGlzLmFkZE5hbWUodGhpcy5uYW1lcy5zaXplKCksIG5hbWUpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGFkZE5hbWVzKExpc3RJdGVyYXRvcjxTdHJpbmc+IG5ld05hbWVzKSB7Ci0JCQl3aGlsZSAobmV3TmFtZXMuaGFzTmV4dCgpKSB7Ci0JCQkJdGhpcy5hZGROYW1lKG5ld05hbWVzLm5leHQoKSk7Ci0JCQl9Ci0JCX0KLQkJcHVibGljIHZvaWQgYWRkTmFtZXMoTGlzdDxTdHJpbmc+IG5ld05hbWVzKSB7Ci0JCQl0aGlzLmFkZE5hbWVzKG5ld05hbWVzLmxpc3RJdGVyYXRvcigpKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBhZGRUd29OYW1lcyhTdHJpbmcgbmFtZTEsIFN0cmluZyBuYW1lMikgewotCQkJdGhpcy5uYW1lcy5hZGQoMCwgbmFtZTIpOwotCQkJdGhpcy5uYW1lcy5hZGQoMCwgbmFtZTEpOwotCQkJdGhpcy5maXJlTGlzdENoYW5nZWQoTkFNRVNfTElTVCk7Ci0JCX0KLQkJcHVibGljIFN0cmluZyByZW1vdmVOYW1lKGludCBpbmRleCkgewotCQkJU3RyaW5nIHJlbW92ZWROYW1lID0gdGhpcy5uYW1lcy5yZW1vdmUoaW5kZXgpOwotCQkJdGhpcy5maXJlSXRlbVJlbW92ZWQoTkFNRVNfTElTVCwgaW5kZXgsIHJlbW92ZWROYW1lKTsKLQkJCXJldHVybiByZW1vdmVkTmFtZTsKLQkJfQotCQlwdWJsaWMgU3RyaW5nIHNldE5hbWUoaW50IGluZGV4LCBTdHJpbmcgbmFtZSkgewotCQkJU3RyaW5nIHJlcGxhY2VkTmFtZSA9IHRoaXMubmFtZXMuc2V0KGluZGV4LCBuYW1lKTsKLQkJCXRoaXMuZmlyZUl0ZW1SZXBsYWNlZChOQU1FU19MSVNULCBpbmRleCwgbmFtZSwgcmVwbGFjZWROYW1lKTsKLQkJCXJldHVybiByZXBsYWNlZE5hbWU7Ci0JCX0KLQkJcHVibGljIExpc3RJdGVyYXRvcjxTdHJpbmc+IGRlc2NyaXB0aW9ucygpIHsKLQkJCXJldHVybiBuZXcgUmVhZE9ubHlMaXN0SXRlcmF0b3I8U3RyaW5nPih0aGlzLmRlc2NyaXB0aW9ucyk7Ci0JCX0KLQkJcHVibGljIFN0cmluZyBnZXREZXNjcmlwdGlvbihpbnQgaW5kZXgpIHsKLQkJCXJldHVybiB0aGlzLmRlc2NyaXB0aW9ucy5nZXQoaW5kZXgpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGFkZERlc2NyaXB0aW9uKGludCBpbmRleCwgU3RyaW5nIGRlc2NyaXB0aW9uKSB7Ci0JCQl0aGlzLmRlc2NyaXB0aW9ucy5hZGQoaW5kZXgsIGRlc2NyaXB0aW9uKTsKLQkJCXRoaXMuZmlyZUl0ZW1BZGRlZChERVNDUklQVElPTlNfTElTVCwgaW5kZXgsIGRlc2NyaXB0aW9uKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBhZGREZXNjcmlwdGlvbihTdHJpbmcgZGVzY3JpcHRpb24pIHsKLQkJCXRoaXMuYWRkRGVzY3JpcHRpb24odGhpcy5kZXNjcmlwdGlvbnMuc2l6ZSgpLCBkZXNjcmlwdGlvbik7Ci0JCX0KLQkJcHVibGljIHZvaWQgYWRkRGVzY3JpcHRpb25zKExpc3RJdGVyYXRvcjxTdHJpbmc+IG5ld0Rlc2NyaXB0aW9ucykgewotCQkJd2hpbGUgKG5ld0Rlc2NyaXB0aW9ucy5oYXNOZXh0KCkpIHsKLQkJCQl0aGlzLmFkZERlc2NyaXB0aW9uKG5ld0Rlc2NyaXB0aW9ucy5uZXh0KCkpOwotCQkJfQotCQl9Ci0JCXB1YmxpYyB2b2lkIGFkZERlc2NyaXB0aW9ucyhMaXN0PFN0cmluZz4gbmV3RGVzY3JpcHRpb25zKSB7Ci0JCQl0aGlzLmFkZERlc2NyaXB0aW9ucyhuZXdEZXNjcmlwdGlvbnMubGlzdEl0ZXJhdG9yKCkpOwotCQl9Ci0JCXB1YmxpYyBTdHJpbmcgcmVtb3ZlRGVzY3JpcHRpb24oaW50IGluZGV4KSB7Ci0JCQlTdHJpbmcgcmVtb3ZlZERlc2NyaXB0aW9uID0gdGhpcy5kZXNjcmlwdGlvbnMucmVtb3ZlKGluZGV4KTsKLQkJCXRoaXMuZmlyZUl0ZW1SZW1vdmVkKERFU0NSSVBUSU9OU19MSVNULCBpbmRleCwgcmVtb3ZlZERlc2NyaXB0aW9uKTsKLQkJCXJldHVybiByZW1vdmVkRGVzY3JpcHRpb247Ci0JCX0KLQkJcHVibGljIFN0cmluZyBzZXREZXNjcmlwdGlvbihpbnQgaW5kZXgsIFN0cmluZyBkZXNjcmlwdGlvbikgewotCQkJU3RyaW5nIHJlcGxhY2VkRGVzY3JpcHRpb24gPSB0aGlzLmRlc2NyaXB0aW9ucy5zZXQoaW5kZXgsIGRlc2NyaXB0aW9uKTsKLQkJCXRoaXMuZmlyZUl0ZW1SZXBsYWNlZChERVNDUklQVElPTlNfTElTVCwgaW5kZXgsIGRlc2NyaXB0aW9uLCByZXBsYWNlZERlc2NyaXB0aW9uKTsKLQkJCXJldHVybiByZXBsYWNlZERlc2NyaXB0aW9uOwotCQl9Ci0JfQotCi0KLQkvLyB0aGlzIGlzIG5vdCBhIHR5cGljYWwgYXNwZWN0IGFkYXB0ZXIgLSB0aGUgdmFsdWUgaXMgZGV0ZXJtaW5lZCBieSB0aGUgYXNwZWN0IG5hbWUKLQlwcml2YXRlIGNsYXNzIExvY2FsTGlzdEFzcGVjdEFkYXB0ZXIgZXh0ZW5kcyBMaXN0QXNwZWN0QWRhcHRlcjxUZXN0U3ViamVjdCwgU3RyaW5nPiB7Ci0KLQkJTG9jYWxMaXN0QXNwZWN0QWRhcHRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdFN1YmplY3Q+IHN1YmplY3RIb2xkZXIpIHsKLQkJCXN1cGVyKHN1YmplY3RIb2xkZXIsIFRlc3RTdWJqZWN0Lk5BTUVTX0xJU1QpOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCBMaXN0SXRlcmF0b3I8U3RyaW5nPiBsaXN0SXRlcmF0b3JfKCkgewotCQkJaWYgKHRoaXMubGlzdE5hbWVzWzBdID09IFRlc3RTdWJqZWN0Lk5BTUVTX0xJU1QpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0Lm5hbWVzKCk7Ci0JCQl9IGVsc2UgaWYgKHRoaXMubGlzdE5hbWVzWzBdID09IFRlc3RTdWJqZWN0LkRFU0NSSVBUSU9OU19MSVNUKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5kZXNjcmlwdGlvbnMoKTsKLQkJCX0gZWxzZSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigiaW52YWxpZCBhc3BlY3QgbmFtZTogIiArIHRoaXMubGlzdE5hbWVzWzBdKTsKLQkJCX0KLQkJfQotCi0JCXB1YmxpYyB2b2lkIGFkZChpbnQgaW5kZXgsIE9iamVjdCBpdGVtKSB7Ci0JCQlpZiAodGhpcy5saXN0TmFtZXNbMF0gPT0gVGVzdFN1YmplY3QuTkFNRVNfTElTVCkgewotCQkJCXRoaXMuc3ViamVjdC5hZGROYW1lKGluZGV4LCAoU3RyaW5nKSBpdGVtKTsKLQkJCX0gZWxzZSBpZiAodGhpcy5saXN0TmFtZXNbMF0gPT0gVGVzdFN1YmplY3QuREVTQ1JJUFRJT05TX0xJU1QpIHsKLQkJCQl0aGlzLnN1YmplY3QuYWRkRGVzY3JpcHRpb24oaW5kZXgsIChTdHJpbmcpIGl0ZW0pOwotCQkJfSBlbHNlIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJpbnZhbGlkIGFzcGVjdCBuYW1lOiAiICsgdGhpcy5saXN0TmFtZXNbMF0pOwotCQkJfQotCQl9Ci0KLQkJcHVibGljIHZvaWQgYWRkQWxsKGludCBpbmRleCwgTGlzdDxTdHJpbmc+IGl0ZW1zKSB7Ci0JCQlmb3IgKGludCBpID0gMDsgaSA8IGl0ZW1zLnNpemUoKTsgaSsrKSB7Ci0JCQkJdGhpcy5hZGQoaW5kZXggKyBpLCBpdGVtcy5nZXQoaSkpOwotCQkJfQotCQl9Ci0KLQkJcHVibGljIFN0cmluZyByZW1vdmUoaW50IGluZGV4KSB7Ci0JCQlpZiAodGhpcy5saXN0TmFtZXNbMF0gPT0gVGVzdFN1YmplY3QuTkFNRVNfTElTVCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QucmVtb3ZlTmFtZShpbmRleCk7Ci0JCQl9IGVsc2UgaWYgKHRoaXMubGlzdE5hbWVzWzBdID09IFRlc3RTdWJqZWN0LkRFU0NSSVBUSU9OU19MSVNUKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5yZW1vdmVEZXNjcmlwdGlvbihpbmRleCk7Ci0JCQl9IGVsc2UgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oImludmFsaWQgYXNwZWN0IG5hbWU6ICIgKyB0aGlzLmxpc3ROYW1lc1swXSk7Ci0JCQl9Ci0JCX0KLQotCQlwdWJsaWMgTGlzdDxTdHJpbmc+IHJlbW92ZShpbnQgaW5kZXgsIGludCBsZW5ndGgpIHsKLQkJCUxpc3Q8U3RyaW5nPiByZW1vdmVkSXRlbXMgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4obGVuZ3RoKTsKLQkJCWZvciAoaW50IGkgPSAwOyBpIDwgbGVuZ3RoOyBpKyspIHsKLQkJCQlyZW1vdmVkSXRlbXMuYWRkKHRoaXMucmVtb3ZlKGluZGV4KSk7Ci0JCQl9Ci0JCQlyZXR1cm4gcmVtb3ZlZEl0ZW1zOwotCQl9Ci0KLQkJcHVibGljIE9iamVjdCByZXBsYWNlKGludCBpbmRleCwgT2JqZWN0IGl0ZW0pIHsKLQkJCWlmICh0aGlzLmxpc3ROYW1lc1swXSA9PSBUZXN0U3ViamVjdC5OQU1FU19MSVNUKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5zZXROYW1lKGluZGV4LCAoU3RyaW5nKSBpdGVtKTsKLQkJCX0gZWxzZSBpZiAodGhpcy5saXN0TmFtZXNbMF0gPT0gVGVzdFN1YmplY3QuREVTQ1JJUFRJT05TX0xJU1QpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LnNldERlc2NyaXB0aW9uKGluZGV4LCAoU3RyaW5nKSBpdGVtKTsKLQkJCX0gZWxzZSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigiaW52YWxpZCBhc3BlY3QgbmFtZTogIiArIHRoaXMubGlzdE5hbWVzWzBdKTsKLQkJCX0KLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9MaXN0Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvTGlzdENvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDI4MDE1ODUuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9MaXN0Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDI3MSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZheC5zd2luZy5KTGlzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQmFnOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5IYXNoQmFnOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuTGlzdENvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVMaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5MaXN0TW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LkNvbGxlY3Rpb25DaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Db2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgTGlzdENvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCUNvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4gYWRhcHRlcjsKLQlwcml2YXRlIFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gd3JhcHBlZExpc3RIb2xkZXI7Ci0JcHJpdmF0ZSBMaXN0PFN0cmluZz4gd3JhcHBlZExpc3Q7Ci0KLQlwdWJsaWMgTGlzdENvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMud3JhcHBlZExpc3QgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJdGhpcy53cmFwcGVkTGlzdEhvbGRlciA9IG5ldyBTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+KHRoaXMud3JhcHBlZExpc3QpOwotCQl0aGlzLmFkYXB0ZXIgPSBuZXcgTGlzdENvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlcjxTdHJpbmc+KHRoaXMud3JhcHBlZExpc3RIb2xkZXIpOwotCX0KLQotCXByaXZhdGUgQ29sbGVjdGlvbjxTdHJpbmc+IHdyYXBwZWRDb2xsZWN0aW9uKCkgewotCQlyZXR1cm4gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24odGhpcy53cmFwcGVkTGlzdC5pdGVyYXRvcigpKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZXJhdG9yKCkgewotCQl0aGlzLmFkYXB0ZXIuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgbmV3IFRlc3RMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQkJCS8vIG92ZXJyaWRlIGZhaWx1cmUKLQkJCX0KLQkJfSk7Ci0JCXRoaXMud3JhcHBlZExpc3RIb2xkZXIuYWRkKDAsICJmb28iKTsKLQkJdGhpcy53cmFwcGVkTGlzdEhvbGRlci5hZGQoMSwgImJhciIpOwotCQl0aGlzLndyYXBwZWRMaXN0SG9sZGVyLmFkZCgyLCAiYmF6Iik7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBhZGFwdGVyQ29sbGVjdGlvbiA9IENvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKHRoaXMuYWRhcHRlci5pdGVyYXRvcigpKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIGFkYXB0ZXJDb2xsZWN0aW9uLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLndyYXBwZWRDb2xsZWN0aW9uKCksIGFkYXB0ZXJDb2xsZWN0aW9uKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3RhbGVWYWx1ZXMoKSB7Ci0JCUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBUZXN0TGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsvKiBPSyAqL30KLQkJfTsKLQkJdGhpcy5hZGFwdGVyLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIGxpc3RlbmVyKTsKLQkJdGhpcy53cmFwcGVkTGlzdEhvbGRlci5hZGQoMCwgImZvbyIpOwotCQl0aGlzLndyYXBwZWRMaXN0SG9sZGVyLmFkZCgxLCAiYmFyIik7Ci0JCXRoaXMud3JhcHBlZExpc3RIb2xkZXIuYWRkKDIsICJiYXoiKTsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGFkYXB0ZXJDb2xsZWN0aW9uID0gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24odGhpcy5hZGFwdGVyLml0ZXJhdG9yKCkpOwotCQlhc3NlcnRFcXVhbHMoMywgYWRhcHRlckNvbGxlY3Rpb24uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMud3JhcHBlZENvbGxlY3Rpb24oKSwgYWRhcHRlckNvbGxlY3Rpb24pOwotCi0JCXRoaXMuYWRhcHRlci5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCBsaXN0ZW5lcik7Ci0JCWFkYXB0ZXJDb2xsZWN0aW9uID0gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24odGhpcy5hZGFwdGVyLml0ZXJhdG9yKCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgYWRhcHRlckNvbGxlY3Rpb24uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBIYXNoQmFnPFN0cmluZz4oKSwgYWRhcHRlckNvbGxlY3Rpb24pOwotCi0JCXRoaXMuYWRhcHRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCBsaXN0ZW5lcik7Ci0JCWFkYXB0ZXJDb2xsZWN0aW9uID0gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24odGhpcy5hZGFwdGVyLml0ZXJhdG9yKCkpOwotCQlhc3NlcnRFcXVhbHMoMywgYWRhcHRlckNvbGxlY3Rpb24uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMud3JhcHBlZENvbGxlY3Rpb24oKSwgYWRhcHRlckNvbGxlY3Rpb24pOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGQoKSB7Ci0JCUJhZzxTdHJpbmc+IHN5bmNoQ29sbGVjdGlvbiA9IG5ldyBDb29yZGluYXRlZEJhZzxTdHJpbmc+KHRoaXMuYWRhcHRlcik7Ci0JCUxpc3Q8U3RyaW5nPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy53cmFwcGVkTGlzdEhvbGRlcik7Ci0JCXRoaXMud3JhcHBlZExpc3RIb2xkZXIuYWRkKDAsICJmb28iKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLndyYXBwZWRMaXN0LmNvbnRhaW5zKCJmb28iKSk7Ci0JCXRoaXMud3JhcHBlZExpc3RIb2xkZXIuYWRkKDEsICJiYXIiKTsKLQkJdGhpcy53cmFwcGVkTGlzdEhvbGRlci5hZGQoMiwgImJheiIpOwotCQl0aGlzLndyYXBwZWRMaXN0SG9sZGVyLmFkZCgzLCAiam9vIik7Ci0JCXRoaXMud3JhcHBlZExpc3RIb2xkZXIuYWRkKDQsICJqYXIiKTsKLQkJdGhpcy53cmFwcGVkTGlzdEhvbGRlci5hZGQoNSwgImpheiIpOwotCQlhc3NlcnRFcXVhbHMoNiwgdGhpcy53cmFwcGVkTGlzdC5zaXplKCkpOwotCi0JCUNvbGxlY3Rpb248U3RyaW5nPiBhZGFwdGVyQ29sbGVjdGlvbiA9IENvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKHRoaXMuYWRhcHRlci5pdGVyYXRvcigpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMud3JhcHBlZENvbGxlY3Rpb24oKSwgYWRhcHRlckNvbGxlY3Rpb24pOwotCQlhc3NlcnRFcXVhbHModGhpcy53cmFwcGVkQ29sbGVjdGlvbigpLCBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbihzeW5jaExpc3QuaXRlcmF0b3IoKSkpOwotCQlhc3NlcnRFcXVhbHModGhpcy53cmFwcGVkQ29sbGVjdGlvbigpLCBzeW5jaENvbGxlY3Rpb24pOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmUoKSB7Ci0JCUJhZzxTdHJpbmc+IHN5bmNoQ29sbGVjdGlvbiA9IG5ldyBDb29yZGluYXRlZEJhZzxTdHJpbmc+KHRoaXMuYWRhcHRlcik7Ci0JCUxpc3Q8U3RyaW5nPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy53cmFwcGVkTGlzdEhvbGRlcik7Ci0JCXRoaXMud3JhcHBlZExpc3RIb2xkZXIuYWRkKDAsICJmb28iKTsKLQkJdGhpcy53cmFwcGVkTGlzdEhvbGRlci5hZGQoMSwgImJhciIpOwotCQl0aGlzLndyYXBwZWRMaXN0SG9sZGVyLmFkZCgyLCAiYmF6Iik7Ci0JCXRoaXMud3JhcHBlZExpc3RIb2xkZXIuYWRkKDMsICJqb28iKTsKLQkJdGhpcy53cmFwcGVkTGlzdEhvbGRlci5hZGQoNCwgImphciIpOwotCQl0aGlzLndyYXBwZWRMaXN0SG9sZGVyLmFkZCg1LCAiamF6Iik7Ci0JCWFzc2VydEVxdWFscygiamF6IiwgdGhpcy53cmFwcGVkTGlzdEhvbGRlci5yZW1vdmUoNSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLndyYXBwZWRMaXN0LmNvbnRhaW5zKCJqYXoiKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy53cmFwcGVkTGlzdEhvbGRlci5yZW1vdmUoMCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLndyYXBwZWRMaXN0LmNvbnRhaW5zKCJmb28iKSk7Ci0JCWFzc2VydEVxdWFscyg0LCB0aGlzLndyYXBwZWRMaXN0LnNpemUoKSk7Ci0KLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGFkYXB0ZXJDb2xsZWN0aW9uID0gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24odGhpcy5hZGFwdGVyLml0ZXJhdG9yKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy53cmFwcGVkQ29sbGVjdGlvbigpLCBhZGFwdGVyQ29sbGVjdGlvbik7Ci0JCWFzc2VydEVxdWFscyh0aGlzLndyYXBwZWRDb2xsZWN0aW9uKCksIENvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKHN5bmNoTGlzdC5pdGVyYXRvcigpKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLndyYXBwZWRDb2xsZWN0aW9uKCksIHN5bmNoQ29sbGVjdGlvbik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RTeW5jaCgpIHsKLQkJdGhpcy5hZGFwdGVyLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIG5ldyBUZXN0TGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCQkvLyBvdmVycmlkZSBmYWlsdXJlCi0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQkJCS8vIG92ZXJyaWRlIGZhaWx1cmUKLQkJCX0KLQkJfSk7Ci0JCXRoaXMud3JhcHBlZExpc3RIb2xkZXIuYWRkKDAsICJmb28iKTsKLQkJdGhpcy53cmFwcGVkTGlzdEhvbGRlci5hZGQoMSwgImJhciIpOwotCQl0aGlzLndyYXBwZWRMaXN0SG9sZGVyLmFkZCgyLCAiYmF6Iik7Ci0JCXRoaXMud3JhcHBlZExpc3RIb2xkZXIuYWRkKDMsICJqb28iKTsKLQkJdGhpcy53cmFwcGVkTGlzdEhvbGRlci5hZGQoNCwgImphciIpOwotCQl0aGlzLndyYXBwZWRMaXN0SG9sZGVyLmFkZCg1LCAiamF6Iik7Ci0JCXRoaXMud3JhcHBlZExpc3RIb2xkZXIucmVtb3ZlKDUpOwotCQlhc3NlcnRGYWxzZSh0aGlzLndyYXBwZWRMaXN0LmNvbnRhaW5zKCJqYXoiKSk7Ci0JCXRoaXMud3JhcHBlZExpc3RIb2xkZXIucmVtb3ZlKDApOwotCQlhc3NlcnRGYWxzZSh0aGlzLndyYXBwZWRMaXN0LmNvbnRhaW5zKCJmb28iKSk7Ci0JCWFzc2VydEVxdWFscyg0LCB0aGlzLndyYXBwZWRMaXN0LnNpemUoKSk7Ci0KLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGFkYXB0ZXJDb2xsZWN0aW9uID0gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24odGhpcy5hZGFwdGVyLml0ZXJhdG9yKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy53cmFwcGVkQ29sbGVjdGlvbigpLCBhZGFwdGVyQ29sbGVjdGlvbik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlcGxhY2UoKSB7Ci0JCXRoaXMuYWRhcHRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCBuZXcgVGVzdExpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7Ci0JCQkJLy8gb3ZlcnJpZGUgZmFpbHVyZQotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpdGVtc1JlbW92ZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCQkvLyBvdmVycmlkZSBmYWlsdXJlCi0JCQl9Ci0JCX0pOwotCQl0aGlzLndyYXBwZWRMaXN0SG9sZGVyLmFkZCgwLCAiZm9vIik7Ci0JCXRoaXMud3JhcHBlZExpc3RIb2xkZXIuYWRkKDEsICJiYXIiKTsKLQkJdGhpcy53cmFwcGVkTGlzdEhvbGRlci5hZGQoMiwgImJheiIpOwotCQlDb2xsZWN0aW9uPFN0cmluZz4gYWRhcHRlckNvbGxlY3Rpb24gPSBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbih0aGlzLmFkYXB0ZXIuaXRlcmF0b3IoKSk7Ci0JCWFzc2VydEVxdWFscygzLCBhZGFwdGVyQ29sbGVjdGlvbi5zaXplKCkpOwotCQl0aGlzLmFkYXB0ZXIuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgbmV3IFRlc3RMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7Ci0JCQkJYXNzZXJ0RXF1YWxzKCJmb28iLCBlLml0ZW1zKCkubmV4dCgpKTsKLQkJCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnMoTGlzdENvbGxlY3Rpb25WYWx1ZU1vZGVsQWRhcHRlclRlc3RzLnRoaXMuYWRhcHRlci5pdGVyYXRvcigpLCAiam9vIikpOwotCQkJCWFzc2VydEVxdWFscygyLCBMaXN0Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5hZGFwdGVyLnNpemUoKSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCQlhc3NlcnRFcXVhbHMoImpvbyIsIGUuaXRlbXMoKS5uZXh0KCkpOwotCQkJCWFzc2VydEVxdWFscygzLCBMaXN0Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5hZGFwdGVyLnNpemUoKSk7Ci0JCQl9Ci0JCX0pOwotCQl0aGlzLndyYXBwZWRMaXN0SG9sZGVyLnNldCgwLCAiam9vIik7Ci0JCWFkYXB0ZXJDb2xsZWN0aW9uID0gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24odGhpcy5hZGFwdGVyLml0ZXJhdG9yKCkpOwotCQlhc3NlcnRFcXVhbHMoMywgYWRhcHRlckNvbGxlY3Rpb24uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMud3JhcHBlZENvbGxlY3Rpb24oKSwgYWRhcHRlckNvbGxlY3Rpb24pOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNMaXN0ZW5lcnMoKSB7Ci0JCWFzc2VydEZhbHNlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5hZGFwdGVyKS5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUykpOwotCQlDb29yZGluYXRlZEJhZzxTdHJpbmc+IHN5bmNoQ29sbGVjdGlvbiA9IG5ldyBDb29yZGluYXRlZEJhZzxTdHJpbmc+KHRoaXMuYWRhcHRlcik7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmFkYXB0ZXIpLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTKSk7Ci0JCXRoaXMuYWRhcHRlci5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCBzeW5jaENvbGxlY3Rpb24pOwotCQlhc3NlcnRGYWxzZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMpKTsKLQkJdGhpcy5hZGFwdGVyLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihzeW5jaENvbGxlY3Rpb24pOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5hZGFwdGVyKS5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUykpOwotCQl0aGlzLmFkYXB0ZXIucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHN5bmNoQ29sbGVjdGlvbik7Ci0JCWFzc2VydEZhbHNlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5hZGFwdGVyKS5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUykpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdENoYW5nZWRUb0VtcHR5KCkgewotCQl0aGlzLmFkYXB0ZXIuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgbmV3IFRlc3RMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgey8qIE9LICovfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpdGVtc1JlbW92ZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsvKiBPSyAqL30KLQkJfSk7Ci0JCXRoaXMud3JhcHBlZExpc3RIb2xkZXIuYWRkKDAsICJmb28iKTsKLQkJdGhpcy53cmFwcGVkTGlzdEhvbGRlci5hZGQoMSwgImJhciIpOwotCQl0aGlzLndyYXBwZWRMaXN0SG9sZGVyLmFkZCgyLCAiYmF6Iik7Ci0JCUpMaXN0IGpMaXN0ID0gbmV3IEpMaXN0KG5ldyBMaXN0TW9kZWxBZGFwdGVyKHRoaXMuYWRhcHRlcikpOwotCQl0aGlzLndyYXBwZWRMaXN0SG9sZGVyLnNldExpc3QobmV3IEFycmF5TGlzdDxTdHJpbmc+KCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgakxpc3QuZ2V0TW9kZWwoKS5nZXRTaXplKCkpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0Q29sbGVjdGlvbkNoYW5nZWRGcm9tRW1wdHkoKSB7Ci0JCXRoaXMuYWRhcHRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCBuZXcgVGVzdExpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7LyogT0sgKi99Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgey8qIE9LICovfQotCQl9KTsKLQkJSkxpc3Qgakxpc3QgPSBuZXcgSkxpc3QobmV3IExpc3RNb2RlbEFkYXB0ZXIodGhpcy5hZGFwdGVyKSk7Ci0JCQotCQlBcnJheUxpc3Q8U3RyaW5nPiBsaXN0ID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCWxpc3QuYWRkKCJmb28iKTsKLQkJbGlzdC5hZGQoImJhciIpOwotCQl0aGlzLndyYXBwZWRMaXN0SG9sZGVyLnNldExpc3QobGlzdCk7Ci0JCWFzc2VydEVxdWFscygyLCBqTGlzdC5nZXRNb2RlbCgpLmdldFNpemUoKSk7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHRlc3RDb2xsZWN0aW9uQ2hhbmdlZEZyb21FbXB0eVRvRW1wdHkoKSB7Ci0JCXRoaXMuYWRhcHRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCBuZXcgVGVzdExpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7LyogT0sgKi99Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgey8qIE9LICovfQotCQl9KTsKLQkJSkxpc3Qgakxpc3QgPSBuZXcgSkxpc3QobmV3IExpc3RNb2RlbEFkYXB0ZXIodGhpcy5hZGFwdGVyKSk7Ci0JCQotCQlBcnJheUxpc3Q8U3RyaW5nPiBsaXN0ID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCXRoaXMud3JhcHBlZExpc3RIb2xkZXIuc2V0TGlzdChsaXN0KTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGpMaXN0LmdldE1vZGVsKCkuZ2V0U2l6ZSgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5uZXIgY2xhc3MgKioqKioqKioqKgotCi0JY2xhc3MgVGVzdExpc3RlbmVyIGltcGxlbWVudHMgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIHsKLQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGNvbGxlY3Rpb25DbGVhcmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7Ci0JCQlmYWlsKCJ1bmV4cGVjdGVkIGV2ZW50Iik7Ci0JCX0KLQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNoYW5nZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCWZhaWwoInVuZXhwZWN0ZWQgZXZlbnQiKTsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9MaXN0Q3VyYXRvclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0xpc3RDdXJhdG9yVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDkwOTkyNy4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL0xpc3RDdXJhdG9yVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDMxNSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3RJdGVyYXRvcjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5SZWFkT25seUxpc3RJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkxpc3RDdXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5MaXN0Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuTGlzdENoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5UZXN0VG9vbHM7Ci0KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGZpbmFsIGNsYXNzIExpc3RDdXJhdG9yVGVzdHMgCi0JZXh0ZW5kcyBUZXN0Q2FzZSAKLXsKLQlwcml2YXRlIFRlc3RTdWJqZWN0IHN1YmplY3QxOwotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdFN1YmplY3Q+IHN1YmplY3RIb2xkZXIxOwotCQotCXByaXZhdGUgTGlzdEN1cmF0b3I8VGVzdFN1YmplY3QsIFN0cmluZz4gY3VyYXRvcjsKLQlwcml2YXRlIExpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcjE7Ci0JcHJpdmF0ZSBMaXN0Q2hhbmdlRXZlbnQgZXZlbnQxOwotCQotCXByaXZhdGUgVGVzdFN1YmplY3Qgc3ViamVjdDI7Ci0KLQlwdWJsaWMgTGlzdEN1cmF0b3JUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLnN1YmplY3QxID0gbmV3IFRlc3RTdWJqZWN0KHRoaXMuc3ViamVjdDFOYW1lcygpKTsKLQkJdGhpcy5zdWJqZWN0SG9sZGVyMSA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdFN1YmplY3Q+KHRoaXMuc3ViamVjdDEpOwotCQl0aGlzLmN1cmF0b3IgPSB0aGlzLmJ1aWxkTGlzdEN1cmF0b3IodGhpcy5zdWJqZWN0SG9sZGVyMSk7Ci0JCXRoaXMubGlzdGVuZXIxID0gdGhpcy5idWlsZExpc3RDaGFuZ2VMaXN0ZW5lcjEoKTsKLQkJdGhpcy5jdXJhdG9yLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5saXN0ZW5lcjEpOwotCQl0aGlzLmV2ZW50MSA9IG51bGw7Ci0JCQotCQl0aGlzLnN1YmplY3QyID0gbmV3IFRlc3RTdWJqZWN0KHRoaXMuc3ViamVjdDJOYW1lcygpKTsKLQl9Ci0JCi0JcHJpdmF0ZSBMaXN0PFN0cmluZz4gc3ViamVjdDFOYW1lcygpIHsKLQkJQXJyYXlMaXN0PFN0cmluZz4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlsaXN0LmFkZCgiYWxwaGEiKTsKLQkJbGlzdC5hZGQoImJyYXZvIik7Ci0JCWxpc3QuYWRkKCJjaGFybGllIik7Ci0JCWxpc3QuYWRkKCJkZWx0YSIpOwotCQlyZXR1cm4gbGlzdDsKLQl9Ci0JCi0JcHJpdmF0ZSBMaXN0PFN0cmluZz4gc3ViamVjdDJOYW1lcygpIHsKLQkJQXJyYXlMaXN0PFN0cmluZz4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlsaXN0LmFkZCgiZWNobyIpOwotCQlsaXN0LmFkZCgiZm94dHJvdCIpOwotCQlsaXN0LmFkZCgiZ2xvdmUiKTsKLQkJbGlzdC5hZGQoImhvdGVsIik7Ci0JCXJldHVybiBsaXN0OwotCX0KLQkKLQlwcml2YXRlIExpc3RDdXJhdG9yPFRlc3RTdWJqZWN0LCBTdHJpbmc+IGJ1aWxkTGlzdEN1cmF0b3IoUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RTdWJqZWN0PiBzdWJqZWN0SG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgTGlzdEN1cmF0b3I8VGVzdFN1YmplY3QsIFN0cmluZz4oc3ViamVjdEhvbGRlcikgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgSXRlcmF0b3I8U3RyaW5nPiBpdGVyYXRvckZvclJlY29yZCgpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LnN0cmluZ3MoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIExpc3RDaGFuZ2VMaXN0ZW5lciBidWlsZExpc3RDaGFuZ2VMaXN0ZW5lcjEoKSB7Ci0JCXJldHVybiBuZXcgTGlzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJCUxpc3RDdXJhdG9yVGVzdHMudGhpcy52YWx1ZTFDaGFuZ2VkKGUpOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJTGlzdEN1cmF0b3JUZXN0cy50aGlzLnZhbHVlMUNoYW5nZWQoZSk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc1JlcGxhY2VkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJTGlzdEN1cmF0b3JUZXN0cy50aGlzLnZhbHVlMUNoYW5nZWQoZSk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc01vdmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJTGlzdEN1cmF0b3JUZXN0cy50aGlzLnZhbHVlMUNoYW5nZWQoZSk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJCUxpc3RDdXJhdG9yVGVzdHMudGhpcy52YWx1ZTFDaGFuZ2VkKGUpOwotCQkJfQotCQkJcHVibGljIHZvaWQgbGlzdENoYW5nZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJCQlMaXN0Q3VyYXRvclRlc3RzLnRoaXMudmFsdWUxQ2hhbmdlZChlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQl2b2lkIHZhbHVlMUNoYW5nZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJdGhpcy5ldmVudDEgPSBlOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3ViamVjdEhvbGRlcigpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLCBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmN1cmF0b3IubGlzdEl0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50MSk7Ci0KLQkJdGhpcy5zdWJqZWN0SG9sZGVyMS5zZXRWYWx1ZSh0aGlzLnN1YmplY3QyKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmV2ZW50MSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmN1cmF0b3IsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmV2ZW50MS5nZXRMaXN0TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKC0xLCB0aGlzLmV2ZW50MS5nZXRJbmRleCgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5ldmVudDEuaXRlbXMoKS5oYXNOZXh0KCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0Mk5hbWVzKCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuY3VyYXRvci5saXN0SXRlcmF0b3IoKSkpOwotCQkKLQkJdGhpcy5ldmVudDEgPSBudWxsOwotCQl0aGlzLnN1YmplY3RIb2xkZXIxLnNldFZhbHVlKG51bGwpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQxKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuY3VyYXRvciwgdGhpcy5ldmVudDEuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMuZXZlbnQxLmdldExpc3ROYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoLTEsIHRoaXMuZXZlbnQxLmdldEluZGV4KCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmV2ZW50MS5pdGVtcygpLmhhc05leHQoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuY3VyYXRvci5pdGVyYXRvcigpLmhhc05leHQoKSk7Ci0JCQotCQl0aGlzLmV2ZW50MSA9IG51bGw7Ci0JCXRoaXMuc3ViamVjdEhvbGRlcjEuc2V0VmFsdWUodGhpcy5zdWJqZWN0MSk7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5jdXJhdG9yLCB0aGlzLmV2ZW50MS5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5ldmVudDEuZ2V0TGlzdE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygtMSwgdGhpcy5ldmVudDEuZ2V0SW5kZXgoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuZXZlbnQxLml0ZW1zKCkuaGFzTmV4dCgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLCBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmN1cmF0b3IubGlzdEl0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkKCkgewotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0MU5hbWVzKCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuY3VyYXRvci5saXN0SXRlcmF0b3IoKSkpOwotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQxKTsKLQotCQl0aGlzLnN1YmplY3QxLmFkZFN0cmluZygiZWNobyIpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQxKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuY3VyYXRvciwgdGhpcy5ldmVudDEuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMuZXZlbnQxLmdldExpc3ROYW1lKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0MU5hbWVzKCkuc2l6ZSgpLCB0aGlzLmV2ZW50MS5nZXRJbmRleCgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJlY2hvIiwgdGhpcy5ldmVudDEuaXRlbXMoKS5uZXh0KCkpOwotCQlMaXN0PFN0cmluZz4gc3RyaW5nc1BsdXMgPSB0aGlzLnN1YmplY3QxTmFtZXMoKTsKLQkJc3RyaW5nc1BsdXMuYWRkKCJlY2hvIik7Ci0JCWFzc2VydEVxdWFscyhzdHJpbmdzUGx1cywgQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5jdXJhdG9yLmxpc3RJdGVyYXRvcigpKSk7Ci0KLQkJdGhpcy5ldmVudDEgPSBudWxsOwotCQl0aGlzLnN1YmplY3QxLmFkZFN0cmluZygwLCAienVsdSIpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQxKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuY3VyYXRvciwgdGhpcy5ldmVudDEuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMuZXZlbnQxLmdldExpc3ROYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgdGhpcy5ldmVudDEuZ2V0SW5kZXgoKSk7Ci0JCWFzc2VydEVxdWFscygienVsdSIsIHRoaXMuZXZlbnQxLml0ZW1zKCkubmV4dCgpKTsKLQkJc3RyaW5nc1BsdXMuYWRkKDAsICJ6dWx1Iik7Ci0JCWFzc2VydEVxdWFscyhzdHJpbmdzUGx1cywgQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5jdXJhdG9yLmxpc3RJdGVyYXRvcigpKSk7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmUoKSB7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnN1YmplY3QxTmFtZXMoKSwgQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5jdXJhdG9yLmxpc3RJdGVyYXRvcigpKSk7Ci0JCWFzc2VydE51bGwodGhpcy5ldmVudDEpOwotCi0JCVN0cmluZyByZW1vdmVkU3RyaW5nID0gdGhpcy5zdWJqZWN0MS5yZW1vdmVTdHJpbmcoMCk7CS8vIHNob3VsZCBiZSAiYWxwaGEiCi0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5jdXJhdG9yLCB0aGlzLmV2ZW50MS5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5ldmVudDEuZ2V0TGlzdE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygwLCB0aGlzLmV2ZW50MS5nZXRJbmRleCgpKTsKLQkJYXNzZXJ0RXF1YWxzKHJlbW92ZWRTdHJpbmcsIHRoaXMuZXZlbnQxLml0ZW1zKCkubmV4dCgpKTsKLQkJTGlzdDxTdHJpbmc+IHN0cmluZ3NNaW51cyA9IHRoaXMuc3ViamVjdDFOYW1lcygpOwotCQlzdHJpbmdzTWludXMucmVtb3ZlKDApOwotCQlhc3NlcnRFcXVhbHMoc3RyaW5nc01pbnVzLCBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmN1cmF0b3IubGlzdEl0ZXJhdG9yKCkpKTsKLQkJCi0JCXJlbW92ZWRTdHJpbmcgPSB0aGlzLnN1YmplY3QxLnJlbW92ZVN0cmluZygyKTsJLy8gc2hvdWxkIGJlICJkZWx0YSIKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmV2ZW50MSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmN1cmF0b3IsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmV2ZW50MS5nZXRMaXN0TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIHRoaXMuZXZlbnQxLmdldEluZGV4KCkpOwotCQlhc3NlcnRFcXVhbHMocmVtb3ZlZFN0cmluZywgdGhpcy5ldmVudDEuaXRlbXMoKS5uZXh0KCkpOwotCQlzdHJpbmdzTWludXMucmVtb3ZlKDIpOwotCQlhc3NlcnRFcXVhbHMoc3RyaW5nc01pbnVzLCBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmN1cmF0b3IubGlzdEl0ZXJhdG9yKCkpKTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgdGVzdENvbXBsZXRlTGlzdENoYW5nZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLCBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmN1cmF0b3IubGlzdEl0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50MSk7Ci0JCQotCQl0aGlzLnN1YmplY3QxLnNldFN0cmluZ3ModGhpcy5zdWJqZWN0Mk5hbWVzKCkpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQxKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuY3VyYXRvciwgdGhpcy5ldmVudDEuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMuZXZlbnQxLmdldExpc3ROYW1lKCkpOwotCQlMaXN0PFN0cmluZz4gbmV3U3RyaW5ncyA9IHRoaXMuc3ViamVjdDJOYW1lcygpOwotCQlhc3NlcnRFcXVhbHMobmV3U3RyaW5ncywgQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5jdXJhdG9yLmxpc3RJdGVyYXRvcigpKSk7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHRlc3RQYXJ0aWFsTGlzdENoYW5nZSgpIHsKLQkJTGlzdDxTdHJpbmc+IHN0YXJ0aW5nTGlzdCA9IENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuY3VyYXRvci5saXN0SXRlcmF0b3IoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnN1YmplY3QxTmFtZXMoKSwgc3RhcnRpbmdMaXN0KTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50MSk7Ci0JCQotCQlTdHJpbmcgaWRlbnRpY2FsU3RyaW5nID0gc3RhcnRpbmdMaXN0LmdldCgxKTsgIC8vIHNob3VsZCBiZSAiYnJhdm8iCi0JCVN0cmluZyBub25pZGVudGljYWxTdHJpbmcgPSBzdGFydGluZ0xpc3QuZ2V0KDApOyAvLyBzaG91bGQgYmUgImFscGhhIgotCQlMaXN0PFN0cmluZz4gbmV3U3RyaW5ncyA9IENvbGxlY3Rpb25Ub29scy5saXN0KG5ldyBTdHJpbmdbXSB7bmV3IFN0cmluZygiYnJhdm8iKSwgbmV3IFN0cmluZygiYWxwaGEiKSwgImVjaG8iLCAiZGVsdGEiLCAiZm94dHJvdCJ9KTsKLQkJdGhpcy5zdWJqZWN0MS5zZXRTdHJpbmdzKG5ld1N0cmluZ3MpOwotCQkKLQkJTGlzdDxTdHJpbmc+IGZpbmFsTGlzdCA9IENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuY3VyYXRvci5saXN0SXRlcmF0b3IoKSk7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5jdXJhdG9yLCB0aGlzLmV2ZW50MS5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5ldmVudDEuZ2V0TGlzdE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscyhuZXdTdHJpbmdzLCBmaW5hbExpc3QpOwotCQlhc3NlcnRUcnVlKGlkZW50aWNhbFN0cmluZyA9PSBmaW5hbExpc3QuZ2V0KDApKTsKLQkJYXNzZXJ0VHJ1ZShub25pZGVudGljYWxTdHJpbmcgIT0gZmluYWxMaXN0LmdldCgxKSk7Ci0JfQotCQotCXB1YmxpYyB2b2lkIHRlc3RJdGVyYXRvcigpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLCBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLnN1YmplY3QxLnN0cmluZ3MoKSkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0MU5hbWVzKCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuY3VyYXRvci5saXN0SXRlcmF0b3IoKSkpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0R2V0KCkgewotCQlhc3NlcnRFcXVhbHModGhpcy5zdWJqZWN0MU5hbWVzKCkuZ2V0KDApLCB0aGlzLnN1YmplY3QxLmdldFN0cmluZygwKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnN1YmplY3QxTmFtZXMoKS5nZXQoMCksIHRoaXMuY3VyYXRvci5nZXQoMCkpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0U2l6ZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLnNpemUoKSwgQ29sbGVjdGlvblRvb2xzLnNpemUodGhpcy5zdWJqZWN0MS5zdHJpbmdzKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDFOYW1lcygpLnNpemUoKSwgQ29sbGVjdGlvblRvb2xzLnNpemUodGhpcy5jdXJhdG9yLmxpc3RJdGVyYXRvcigpKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnN1YmplY3QxTmFtZXMoKS5zaXplKCksIHRoaXMuY3VyYXRvci5zaXplKCkpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgewotCQlhc3NlcnRUcnVlKHRoaXMuY3VyYXRvci5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0JCWFzc2VydFRydWUodGhpcy5zdWJqZWN0MS5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQkJdGhpcy5jdXJhdG9yLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5saXN0ZW5lcjEpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnN1YmplY3QxLmhhc0FueVN0YXRlQ2hhbmdlTGlzdGVuZXJzKCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmN1cmF0b3IuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCi0JCUxpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcjIgPSB0aGlzLmJ1aWxkTGlzdENoYW5nZUxpc3RlbmVyMSgpOwotCQl0aGlzLmN1cmF0b3IuYWRkTGlzdENoYW5nZUxpc3RlbmVyKGxpc3RlbmVyMik7Ci0JCWFzc2VydFRydWUodGhpcy5jdXJhdG9yLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnN1YmplY3QxLmhhc0FueVN0YXRlQ2hhbmdlTGlzdGVuZXJzKCkpOwotCQl0aGlzLmN1cmF0b3IucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKGxpc3RlbmVyMik7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc3ViamVjdDEuaGFzQW55U3RhdGVDaGFuZ2VMaXN0ZW5lcnMoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuY3VyYXRvci5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0JfQotCQotCQotCS8vICoqKioqKioqKioqKioqKiogSW5uZXIgQ2xhc3MgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotCQotCWNsYXNzIFRlc3RTdWJqZWN0IGV4dGVuZHMgQWJzdHJhY3RNb2RlbCB7Ci0JCXByaXZhdGUgTGlzdDxTdHJpbmc+IHN0cmluZ3M7Ci0JCQotCQlwdWJsaWMgVGVzdFN1YmplY3QoKSB7Ci0JCQl0aGlzLnN0cmluZ3MgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJfQotCQkKLQkJcHVibGljIFRlc3RTdWJqZWN0KExpc3Q8U3RyaW5nPiBzdHJpbmdzKSB7Ci0JCQl0aGlzKCk7Ci0JCQl0aGlzLnNldFN0cmluZ3Moc3RyaW5ncyk7Ci0JCX0KLQkJCi0JCXB1YmxpYyBTdHJpbmcgZ2V0U3RyaW5nKGludCBpbmRleCkgewotCQkJcmV0dXJuIHRoaXMuc3RyaW5ncy5nZXQoaW5kZXgpOwotCQl9Ci0JCQotCQlwdWJsaWMgTGlzdEl0ZXJhdG9yPFN0cmluZz4gc3RyaW5ncygpIHsKLQkJCXJldHVybiBuZXcgUmVhZE9ubHlMaXN0SXRlcmF0b3I8U3RyaW5nPih0aGlzLnN0cmluZ3MpOwotCQl9Ci0JCQotCQlwdWJsaWMgdm9pZCBhZGRTdHJpbmcoaW50IGluZGV4LCBTdHJpbmcgc3RyaW5nKSB7Ci0JCQl0aGlzLnN0cmluZ3MuYWRkKGluZGV4LCBzdHJpbmcpOwotCQkJdGhpcy5maXJlU3RhdGVDaGFuZ2VkKCk7Ci0JCX0KLQkJCi0JCXB1YmxpYyB2b2lkIGFkZFN0cmluZyhTdHJpbmcgc3RyaW5nKSB7Ci0JCQl0aGlzLmFkZFN0cmluZyh0aGlzLnN0cmluZ3Muc2l6ZSgpLCBzdHJpbmcpOwotCQl9Ci0JCQotCQlwdWJsaWMgU3RyaW5nIHJlbW92ZVN0cmluZyhpbnQgaW5kZXgpIHsKLQkJCVN0cmluZyBzdHJpbmcgPSB0aGlzLnN0cmluZ3MuZ2V0KGluZGV4KTsKLQkJCXRoaXMucmVtb3ZlU3RyaW5nKHN0cmluZyk7Ci0JCQlyZXR1cm4gc3RyaW5nOwotCQl9Ci0JCQotCQlwdWJsaWMgdm9pZCByZW1vdmVTdHJpbmcoU3RyaW5nIHN0cmluZykgewotCQkJdGhpcy5zdHJpbmdzLnJlbW92ZShzdHJpbmcpOwotCQkJdGhpcy5maXJlU3RhdGVDaGFuZ2VkKCk7Ci0JCX0KLQkJCi0JCXB1YmxpYyB2b2lkIHNldFN0cmluZ3MoTGlzdDxTdHJpbmc+IHN0cmluZ3MpIHsKLQkJCXRoaXMuc3RyaW5ncyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPihzdHJpbmdzKTsKLQkJCXRoaXMuZmlyZVN0YXRlQ2hhbmdlZCgpOwotCQl9Ci0JCQotCQlwdWJsaWMgdm9pZCBzZXRTdHJpbmdzKFN0cmluZ1tdIHN0cmluZ3MpIHsKLQkJCXRoaXMuc3RyaW5ncyA9IENvbGxlY3Rpb25Ub29scy5saXN0KHN0cmluZ3MpOwotCQkJdGhpcy5maXJlU3RhdGVDaGFuZ2VkKCk7Ci0JCX0KLQl9Ci19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL051bGxDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL051bGxDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDJiY2M3MzguLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9OdWxsQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5OdWxsQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgTnVsbENvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBDb2xsZWN0aW9uVmFsdWVNb2RlbDxPYmplY3Q+IGNvbGxlY3Rpb25Ib2xkZXI7Ci0KLQlwdWJsaWMgTnVsbENvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy5jb2xsZWN0aW9uSG9sZGVyID0gbmV3IE51bGxDb2xsZWN0aW9uVmFsdWVNb2RlbDxPYmplY3Q+KCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTaXplKCkgewotCQlhc3NlcnRFcXVhbHMoMCwgdGhpcy5jb2xsZWN0aW9uSG9sZGVyLnNpemUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZXJhdG9yKCkgewotCQlhc3NlcnRGYWxzZSh0aGlzLmNvbGxlY3Rpb25Ib2xkZXIuaXRlcmF0b3IoKS5oYXNOZXh0KCkpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9OdWxsTGlzdFZhbHVlTW9kZWxUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9OdWxsTGlzdFZhbHVlTW9kZWxUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlNDJiZjQ4Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvTnVsbExpc3RWYWx1ZU1vZGVsVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDU0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuTnVsbExpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIE51bGxMaXN0VmFsdWVNb2RlbFRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8T2JqZWN0PiBsaXN0SG9sZGVyOwotCi0JcHVibGljIE51bGxMaXN0VmFsdWVNb2RlbFRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMubGlzdEhvbGRlciA9IG5ldyBOdWxsTGlzdFZhbHVlTW9kZWw8T2JqZWN0PigpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0R2V0KCkgewotCQlib29sZWFuIGV4Q2F1Z2h0ID0gZmFsc2U7Ci0JCXRyeSB7Ci0JCQl0aGlzLmxpc3RIb2xkZXIuZ2V0KDApOwotCQl9IGNhdGNoIChJbmRleE91dE9mQm91bmRzRXhjZXB0aW9uIGV4KSB7Ci0JCQlleENhdWdodCA9IHRydWU7Ci0JCX0KLQkJYXNzZXJ0VHJ1ZShleENhdWdodCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNpemUoKSB7Ci0JCWFzc2VydEVxdWFscygwLCB0aGlzLmxpc3RIb2xkZXIuc2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SXRlcmF0b3IoKSB7Ci0JCWFzc2VydEZhbHNlKHRoaXMubGlzdEhvbGRlci5pdGVyYXRvcigpLmhhc05leHQoKSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL051bGxQcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9OdWxsUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzU0ODUwNi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL051bGxQcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDAgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5OdWxsUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5UZXN0VG9vbHM7Ci0KLXB1YmxpYyBjbGFzcyBOdWxsUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiB2YWx1ZUhvbGRlcjsKLQotCXB1YmxpYyBOdWxsUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy52YWx1ZUhvbGRlciA9IG5ldyBOdWxsUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4oKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFZhbHVlKCkgewotCQlhc3NlcnROdWxsKHRoaXMudmFsdWVIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1Byb3BlcnR5QXNwZWN0QWRhcHRlclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1Byb3BlcnR5QXNwZWN0QWRhcHRlclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGMzY2RiNDEuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXJUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzI2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlByb3BlcnR5Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgUHJvcGVydHlBc3BlY3RBZGFwdGVyVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBUZXN0U3ViamVjdCBzdWJqZWN0MTsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RTdWJqZWN0PiBzdWJqZWN0SG9sZGVyMTsKLQlwcml2YXRlIFByb3BlcnR5QXNwZWN0QWRhcHRlcjxUZXN0U3ViamVjdCwgU3RyaW5nPiBhYTE7Ci0JcHJpdmF0ZSBQcm9wZXJ0eUNoYW5nZUV2ZW50IGV2ZW50MTsKLQlwcml2YXRlIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIxOwotCi0JcHJpdmF0ZSBUZXN0U3ViamVjdCBzdWJqZWN0MjsKLQotCXByaXZhdGUgUHJvcGVydHlDaGFuZ2VFdmVudCBtdWx0aXBsZVZhbHVlRXZlbnQ7Ci0KLQlwcml2YXRlIFByb3BlcnR5Q2hhbmdlRXZlbnQgY3VzdG9tVmFsdWVFdmVudDsKLQotCi0JcHVibGljIFByb3BlcnR5QXNwZWN0QWRhcHRlclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMuc3ViamVjdDEgPSBuZXcgVGVzdFN1YmplY3QoImZvbyIsICJ0ZXN0IHN1YmplY3QgMSIpOwotCQl0aGlzLnN1YmplY3RIb2xkZXIxID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxUZXN0U3ViamVjdD4gKHRoaXMuc3ViamVjdDEpOwotCQl0aGlzLmFhMSA9IHRoaXMuYnVpbGRBc3BlY3RBZGFwdGVyKHRoaXMuc3ViamVjdEhvbGRlcjEpOwotCQl0aGlzLmxpc3RlbmVyMSA9IHRoaXMuYnVpbGRWYWx1ZUNoYW5nZUxpc3RlbmVyMSgpOwotCQl0aGlzLmFhMS5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5saXN0ZW5lcjEpOwotCQl0aGlzLmV2ZW50MSA9IG51bGw7Ci0KLQkJdGhpcy5zdWJqZWN0MiA9IG5ldyBUZXN0U3ViamVjdCgiYmFyIiwgInRlc3Qgc3ViamVjdCAyIik7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VGVzdFN1YmplY3QsIFN0cmluZz4gYnVpbGRBc3BlY3RBZGFwdGVyKFByb3BlcnR5VmFsdWVNb2RlbDxUZXN0U3ViamVjdD4gc3ViamVjdEhvbGRlcikgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxUZXN0U3ViamVjdCwgU3RyaW5nPihzdWJqZWN0SG9sZGVyLCBUZXN0U3ViamVjdC5OQU1FX1BST1BFUlRZKSB7Ci0JCQkvLyB0aGlzIGlzIG5vdCBhIGFzcGVjdCBhZGFwdGVyIC0gdGhlIHZhbHVlIGlzIGRldGVybWluZWQgYnkgdGhlIGFzcGVjdCBuYW1lCi0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJaWYgKHRoaXMucHJvcGVydHlOYW1lc1swXSA9PSBUZXN0U3ViamVjdC5OQU1FX1BST1BFUlRZKSB7Ci0JCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0TmFtZSgpOwotCQkJCX0gZWxzZSBpZiAodGhpcy5wcm9wZXJ0eU5hbWVzWzBdID09IFRlc3RTdWJqZWN0LkRFU0NSSVBUSU9OX1BST1BFUlRZKSB7Ci0JCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0RGVzY3JpcHRpb24oKTsKLQkJCQl9IGVsc2UgewotCQkJCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJpbnZhbGlkIGFzcGVjdCBuYW1lOiAiICsgdGhpcy5wcm9wZXJ0eU5hbWVzWzBdKTsKLQkJCQl9Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhTdHJpbmcgdmFsdWUpIHsKLQkJCQlpZiAodGhpcy5wcm9wZXJ0eU5hbWVzWzBdID09IFRlc3RTdWJqZWN0Lk5BTUVfUFJPUEVSVFkpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LnNldE5hbWUodmFsdWUpOwotCQkJCX0gZWxzZSBpZiAodGhpcy5wcm9wZXJ0eU5hbWVzWzBdID09IFRlc3RTdWJqZWN0LkRFU0NSSVBUSU9OX1BST1BFUlRZKSB7Ci0JCQkJCXRoaXMuc3ViamVjdC5zZXREZXNjcmlwdGlvbih2YWx1ZSk7Ci0JCQkJfSBlbHNlIHsKLQkJCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigiaW52YWxpZCBhc3BlY3QgbmFtZTogIiArIHRoaXMucHJvcGVydHlOYW1lc1swXSk7Ci0JCQkJfQotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZFZhbHVlQ2hhbmdlTGlzdGVuZXIxKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJUHJvcGVydHlBc3BlY3RBZGFwdGVyVGVzdHMudGhpcy52YWx1ZTFDaGFuZ2VkKGUpOwotCQkJfQotCQl9OwotCX0KLQotCXZvaWQgdmFsdWUxQ2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJdGhpcy5ldmVudDEgPSBlOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3ViamVjdEhvbGRlcigpIHsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCB0aGlzLmFhMS5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50MSk7Ci0KLQkJdGhpcy5zdWJqZWN0SG9sZGVyMS5zZXRWYWx1ZSh0aGlzLnN1YmplY3QyKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmV2ZW50MSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmFhMSwgdGhpcy5ldmVudDEuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmV2ZW50MS5nZXRQcm9wZXJ0eU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy5ldmVudDEuZ2V0T2xkVmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygiYmFyIiwgdGhpcy5ldmVudDEuZ2V0TmV3VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygiYmFyIiwgdGhpcy5hYTEuZ2V0VmFsdWUoKSk7Ci0JCQotCQl0aGlzLmV2ZW50MSA9IG51bGw7Ci0JCXRoaXMuc3ViamVjdEhvbGRlcjEuc2V0VmFsdWUobnVsbCk7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hYTEsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5ldmVudDEuZ2V0UHJvcGVydHlOYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoImJhciIsIHRoaXMuZXZlbnQxLmdldE9sZFZhbHVlKCkpOwotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQxLmdldE5ld1ZhbHVlKCkpOwotCQlhc3NlcnROdWxsKHRoaXMuYWExLmdldFZhbHVlKCkpOwotCQkKLQkJdGhpcy5ldmVudDEgPSBudWxsOwotCQl0aGlzLnN1YmplY3RIb2xkZXIxLnNldFZhbHVlKHRoaXMuc3ViamVjdDEpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQxKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYWExLCB0aGlzLmV2ZW50MS5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMuZXZlbnQxLmdldFByb3BlcnR5TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKG51bGwsIHRoaXMuZXZlbnQxLmdldE9sZFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIHRoaXMuZXZlbnQxLmdldE5ld1ZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIHRoaXMuYWExLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RQcm9wZXJ0eUNoYW5nZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCB0aGlzLmFhMS5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50MSk7Ci0KLQkJdGhpcy5zdWJqZWN0MS5zZXROYW1lKCJiYXoiKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmV2ZW50MSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmFhMSwgdGhpcy5ldmVudDEuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmV2ZW50MS5nZXRQcm9wZXJ0eU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy5ldmVudDEuZ2V0T2xkVmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygiYmF6IiwgdGhpcy5ldmVudDEuZ2V0TmV3VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygiYmF6IiwgdGhpcy5hYTEuZ2V0VmFsdWUoKSk7Ci0JCQotCQl0aGlzLmV2ZW50MSA9IG51bGw7Ci0JCXRoaXMuc3ViamVjdDEuc2V0TmFtZShudWxsKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmV2ZW50MSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmFhMSwgdGhpcy5ldmVudDEuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmV2ZW50MS5nZXRQcm9wZXJ0eU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygiYmF6IiwgdGhpcy5ldmVudDEuZ2V0T2xkVmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscyhudWxsLCB0aGlzLmV2ZW50MS5nZXROZXdWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKG51bGwsIHRoaXMuYWExLmdldFZhbHVlKCkpOwotCQkKLQkJdGhpcy5ldmVudDEgPSBudWxsOwotCQl0aGlzLnN1YmplY3QxLnNldE5hbWUoImZvbyIpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQxKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYWExLCB0aGlzLmV2ZW50MS5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMuZXZlbnQxLmdldFByb3BlcnR5TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKG51bGwsIHRoaXMuZXZlbnQxLmdldE9sZFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIHRoaXMuZXZlbnQxLmdldE5ld1ZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIHRoaXMuYWExLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RWYWx1ZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCB0aGlzLnN1YmplY3QxLmdldE5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy5hYTEuZ2V0VmFsdWUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFN0YWxlVmFsdWUoKSB7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy5zdWJqZWN0MS5nZXROYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIHRoaXMuYWExLmdldFZhbHVlKCkpOwotCi0JCXRoaXMuYWExLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmxpc3RlbmVyMSk7Ci0JCWFzc2VydEVxdWFscyhudWxsLCB0aGlzLmFhMS5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLmFhMS5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5saXN0ZW5lcjEpOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIHRoaXMuYWExLmdldFZhbHVlKCkpOwotCi0JCXRoaXMuYWExLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmxpc3RlbmVyMSk7Ci0JCXRoaXMuc3ViamVjdEhvbGRlcjEuc2V0VmFsdWUodGhpcy5zdWJqZWN0Mik7Ci0JCWFzc2VydEVxdWFscyhudWxsLCB0aGlzLmFhMS5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLmFhMS5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5saXN0ZW5lcjEpOwotCQlhc3NlcnRFcXVhbHMoImJhciIsIHRoaXMuYWExLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRWYWx1ZSgpIHsKLQkJdGhpcy5hYTEuc2V0VmFsdWUoImJheiIpOwotCQlhc3NlcnRFcXVhbHMoImJheiIsIHRoaXMuYWExLmdldFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMoImJheiIsIHRoaXMuc3ViamVjdDEuZ2V0TmFtZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgewotCQlhc3NlcnRUcnVlKHRoaXMuYWExLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlhc3NlcnRUcnVlKHRoaXMuc3ViamVjdDEuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoVGVzdFN1YmplY3QuTkFNRV9QUk9QRVJUWSkpOwotCQl0aGlzLmFhMS5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5saXN0ZW5lcjEpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnN1YmplY3QxLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFRlc3RTdWJqZWN0Lk5BTUVfUFJPUEVSVFkpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5hYTEuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0KLQkJUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcjIgPSB0aGlzLmJ1aWxkVmFsdWVDaGFuZ2VMaXN0ZW5lcjEoKTsKLQkJdGhpcy5hYTEuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcjIpOwotCQlhc3NlcnRUcnVlKHRoaXMuYWExLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlhc3NlcnRUcnVlKHRoaXMuc3ViamVjdDEuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoVGVzdFN1YmplY3QuTkFNRV9QUk9QRVJUWSkpOwotCQl0aGlzLmFhMS5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyMik7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc3ViamVjdDEuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoVGVzdFN1YmplY3QuTkFNRV9QUk9QRVJUWSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmFhMS5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TXVsdGlwbGVBc3BlY3RBZGFwdGVyKCkgewotCQlUZXN0U3ViamVjdCB0ZXN0U3ViamVjdCA9IG5ldyBUZXN0U3ViamVjdCgiZnJlZCIsICJodXNiYW5kIik7Ci0JCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RTdWJqZWN0PiB0ZXN0U3ViamVjdEhvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdFN1YmplY3Q+KHRlc3RTdWJqZWN0KTsKLQkJV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiB0ZXN0QUEgPSB0aGlzLmJ1aWxkTXVsdGlwbGVBc3BlY3RBZGFwdGVyKHRlc3RTdWJqZWN0SG9sZGVyKTsKLQkJUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciB0ZXN0TGlzdGVuZXIgPSB0aGlzLmJ1aWxkTXVsdGlwbGVWYWx1ZUNoYW5nZUxpc3RlbmVyKCk7Ci0JCXRlc3RBQS5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGVzdExpc3RlbmVyKTsKLQkJYXNzZXJ0RXF1YWxzKCJmcmVkOmh1c2JhbmQiLCB0ZXN0QUEuZ2V0VmFsdWUoKSk7Ci0KLQkJdGhpcy5tdWx0aXBsZVZhbHVlRXZlbnQgPSBudWxsOwotCQl0ZXN0U3ViamVjdC5zZXROYW1lKCJ3aWxtYSIpOwotCQlhc3NlcnRFcXVhbHMoIndpbG1hOmh1c2JhbmQiLCB0ZXN0QUEuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygiZnJlZDpodXNiYW5kIiwgdGhpcy5tdWx0aXBsZVZhbHVlRXZlbnQuZ2V0T2xkVmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygid2lsbWE6aHVzYmFuZCIsIHRoaXMubXVsdGlwbGVWYWx1ZUV2ZW50LmdldE5ld1ZhbHVlKCkpOwotCi0JCXRoaXMubXVsdGlwbGVWYWx1ZUV2ZW50ID0gbnVsbDsKLQkJdGVzdFN1YmplY3Quc2V0RGVzY3JpcHRpb24oIndpZmUiKTsKLQkJYXNzZXJ0RXF1YWxzKCJ3aWxtYTp3aWZlIiwgdGVzdEFBLmdldFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMoIndpbG1hOmh1c2JhbmQiLCB0aGlzLm11bHRpcGxlVmFsdWVFdmVudC5nZXRPbGRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ3aWxtYTp3aWZlIiwgdGhpcy5tdWx0aXBsZVZhbHVlRXZlbnQuZ2V0TmV3VmFsdWUoKSk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkTXVsdGlwbGVBc3BlY3RBZGFwdGVyKFByb3BlcnR5VmFsdWVNb2RlbDxUZXN0U3ViamVjdD4gc3ViamVjdEhvbGRlcikgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxUZXN0U3ViamVjdCwgU3RyaW5nPihzdWJqZWN0SG9sZGVyLCBUZXN0U3ViamVjdC5OQU1FX1BST1BFUlRZLCBUZXN0U3ViamVjdC5ERVNDUklQVElPTl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0TmFtZSgpICsgIjoiICsgdGhpcy5zdWJqZWN0LmdldERlc2NyaXB0aW9uKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkTXVsdGlwbGVWYWx1ZUNoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJUHJvcGVydHlBc3BlY3RBZGFwdGVyVGVzdHMudGhpcy5tdWx0aXBsZVZhbHVlQ2hhbmdlZChlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQl2b2lkIG11bHRpcGxlVmFsdWVDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZSkgewotCQl0aGlzLm11bHRpcGxlVmFsdWVFdmVudCA9IGU7Ci0JfQotCi0JLyoqCi0JICogdGVzdCBhIGJ1ZyB3aGVyZSB3ZSB3b3VsZCBjYWxsICNidWlsZFZhbHVlKCkgaW4KLQkgKiAjZW5nYWdlTm9uTnVsbFN1YmplY3QoKSwgd2hlbiB3ZSBuZWVkZWQgdG8gY2FsbAotCSAqIGl0IGluICNlbmdhZ2VTdWJqZWN0KCksIHNvIHRoZSBjYWNoZWQgdmFsdWUgd291bGQKLQkgKiBiZSByZWJ1aWx0IHdoZW4gdGhlIHRoaXMuc3ViamVjdCB3YXMgc2V0IHRvIG51bGwKLQkgKi8KLQlwdWJsaWMgdm9pZCB0ZXN0Q3VzdG9tQnVpbGRWYWx1ZVdpdGhOdWxsU3ViamVjdCgpIHsKLQkJVGVzdFN1YmplY3QgY3VzdG9tU3ViamVjdCA9IG5ldyBUZXN0U3ViamVjdCgiZnJlZCIsICJsYWJvcmVyIik7Ci0JCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RTdWJqZWN0PiBjdXN0b21TdWJqZWN0SG9sZGVyID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxUZXN0U3ViamVjdD4oY3VzdG9tU3ViamVjdCk7Ci0JCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gY3VzdG9tQUEgPSB0aGlzLmJ1aWxkQ3VzdG9tQXNwZWN0QWRhcHRlcihjdXN0b21TdWJqZWN0SG9sZGVyKTsKLQkJUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBjdXN0b21MaXN0ZW5lciA9IHRoaXMuYnVpbGRDdXN0b21WYWx1ZUNoYW5nZUxpc3RlbmVyKCk7Ci0JCWN1c3RvbUFBLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCBjdXN0b21MaXN0ZW5lcik7Ci0JCWFzc2VydEVxdWFscygiZnJlZCIsIGN1c3RvbUFBLmdldFZhbHVlKCkpOwotCi0JCXRoaXMuY3VzdG9tVmFsdWVFdmVudCA9IG51bGw7Ci0JCWN1c3RvbVN1YmplY3Quc2V0TmFtZSgid2lsbWEiKTsKLQkJYXNzZXJ0RXF1YWxzKCJ3aWxtYSIsIGN1c3RvbUFBLmdldFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMoImZyZWQiLCB0aGlzLmN1c3RvbVZhbHVlRXZlbnQuZ2V0T2xkVmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygid2lsbWEiLCB0aGlzLmN1c3RvbVZhbHVlRXZlbnQuZ2V0TmV3VmFsdWUoKSk7Ci0KLQkJdGhpcy5jdXN0b21WYWx1ZUV2ZW50ID0gbnVsbDsKLQkJY3VzdG9tU3ViamVjdEhvbGRlci5zZXRWYWx1ZShudWxsKTsKLQkJLy8gdGhpcyB3b3VsZCBmYWlsIC0gdGhlIHZhbHVlIHdvdWxkIGJlIG51bGwuLi4KLQkJYXNzZXJ0RXF1YWxzKCI8dW5uYW1lZD4iLCBjdXN0b21BQS5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJ3aWxtYSIsIHRoaXMuY3VzdG9tVmFsdWVFdmVudC5nZXRPbGRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCI8dW5uYW1lZD4iLCB0aGlzLmN1c3RvbVZhbHVlRXZlbnQuZ2V0TmV3VmFsdWUoKSk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkQ3VzdG9tQXNwZWN0QWRhcHRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdFN1YmplY3Q+IHN1YmplY3RIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VGVzdFN1YmplY3QsIFN0cmluZz4oc3ViamVjdEhvbGRlciwgVGVzdFN1YmplY3QuTkFNRV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWUoKSB7Ci0JCQkJcmV0dXJuICh0aGlzLnN1YmplY3QgPT0gbnVsbCkgPyAiPHVubmFtZWQ+IiA6IHRoaXMuc3ViamVjdC5nZXROYW1lKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkQ3VzdG9tVmFsdWVDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZSkgewotCQkJCVByb3BlcnR5QXNwZWN0QWRhcHRlclRlc3RzLnRoaXMuY3VzdG9tVmFsdWVDaGFuZ2VkKGUpOwotCQkJfQotCQl9OwotCX0KLQotCXZvaWQgY3VzdG9tVmFsdWVDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZSkgewotCQl0aGlzLmN1c3RvbVZhbHVlRXZlbnQgPSBlOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBpbm5lciBjbGFzcyAqKioqKioqKioqCi0JCi0JcHJpdmF0ZSBjbGFzcyBUZXN0U3ViamVjdCBleHRlbmRzIEFic3RyYWN0TW9kZWwgewotCQlwcml2YXRlIFN0cmluZyBuYW1lOwotCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBOQU1FX1BST1BFUlRZID0gIm5hbWUiOwotCQlwcml2YXRlIFN0cmluZyBkZXNjcmlwdGlvbjsKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgREVTQ1JJUFRJT05fUFJPUEVSVFkgPSAiZGVzY3JpcHRpb24iOwotCQotCQlwdWJsaWMgVGVzdFN1YmplY3QoU3RyaW5nIG5hbWUsIFN0cmluZyBkZXNjcmlwdGlvbikgewotCQkJdGhpcy5uYW1lID0gbmFtZTsKLQkJCXRoaXMuZGVzY3JpcHRpb24gPSBkZXNjcmlwdGlvbjsKLQkJfQotCQlwdWJsaWMgU3RyaW5nIGdldE5hbWUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5uYW1lOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldE5hbWUoU3RyaW5nIG5hbWUpIHsKLQkJCU9iamVjdCBvbGQgPSB0aGlzLm5hbWU7Ci0JCQl0aGlzLm5hbWUgPSBuYW1lOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKE5BTUVfUFJPUEVSVFksIG9sZCwgbmFtZSk7Ci0JCX0KLQkJcHVibGljIFN0cmluZyBnZXREZXNjcmlwdGlvbigpIHsKLQkJCXJldHVybiB0aGlzLmRlc2NyaXB0aW9uOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldERlc2NyaXB0aW9uKFN0cmluZyBkZXNjcmlwdGlvbikgewotCQkJT2JqZWN0IG9sZCA9IHRoaXMuZGVzY3JpcHRpb247Ci0JCQl0aGlzLmRlc2NyaXB0aW9uID0gZGVzY3JpcHRpb247Ci0JCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoREVTQ1JJUFRJT05fUFJPUEVSVFksIG9sZCwgZGVzY3JpcHRpb24pOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1Byb3BlcnR5Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvUHJvcGVydHlDb2xsZWN0aW9uVmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0OWRhN2FiLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvUHJvcGVydHlDb2xsZWN0aW9uVmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTUxICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZheC5zd2luZy5KTGlzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkhhc2hCYWc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlNpbmdsZUVsZW1lbnRJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5MaXN0TW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LkNvbGxlY3Rpb25DaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Db2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgUHJvcGVydHlDb2xsZWN0aW9uVmFsdWVNb2RlbEFkYXB0ZXJUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIENvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4gYWRhcHRlcjsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gd3JhcHBlZFZhbHVlSG9sZGVyOwotCi0JcHVibGljIFByb3BlcnR5Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy53cmFwcGVkVmFsdWVIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4oKTsKLQkJdGhpcy5hZGFwdGVyID0gbmV3IFByb3BlcnR5Q29sbGVjdGlvblZhbHVlTW9kZWxBZGFwdGVyPFN0cmluZz4odGhpcy53cmFwcGVkVmFsdWVIb2xkZXIpOwotCX0KLQotCXByaXZhdGUgQ29sbGVjdGlvbjxTdHJpbmc+IHdyYXBwZWRDb2xsZWN0aW9uKCkgewotCQlyZXR1cm4gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24obmV3IFNpbmdsZUVsZW1lbnRJdGVyYXRvcjxTdHJpbmc+KHRoaXMud3JhcHBlZFZhbHVlSG9sZGVyLmdldFZhbHVlKCkpKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZXJhdG9yKCkgewotCQl0aGlzLmFkYXB0ZXIuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgbmV3IFRlc3RMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgey8qIE9LICovfQotCQl9KTsKLQkJdGhpcy53cmFwcGVkVmFsdWVIb2xkZXIuc2V0VmFsdWUoImZvbyIpOwotCQlDb2xsZWN0aW9uPFN0cmluZz4gYWRhcHRlckNvbGxlY3Rpb24gPSBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbih0aGlzLmFkYXB0ZXIuaXRlcmF0b3IoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBhZGFwdGVyQ29sbGVjdGlvbi5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy53cmFwcGVkQ29sbGVjdGlvbigpLCBhZGFwdGVyQ29sbGVjdGlvbik7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgYWRhcHRlckNvbGxlY3Rpb24uaXRlcmF0b3IoKS5uZXh0KCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTdGFsZVZhbHVlKCkgewotCQlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdExpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7LyogT0sgKi99Ci0JCX07Ci0JCXRoaXMuYWRhcHRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCBsaXN0ZW5lcik7Ci0JCXRoaXMud3JhcHBlZFZhbHVlSG9sZGVyLnNldFZhbHVlKCJmb28iKTsKLQkJQ29sbGVjdGlvbjxTdHJpbmc+IGFkYXB0ZXJDb2xsZWN0aW9uID0gQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24odGhpcy5hZGFwdGVyLml0ZXJhdG9yKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgYWRhcHRlckNvbGxlY3Rpb24uc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMud3JhcHBlZENvbGxlY3Rpb24oKSwgYWRhcHRlckNvbGxlY3Rpb24pOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIGFkYXB0ZXJDb2xsZWN0aW9uLml0ZXJhdG9yKCkubmV4dCgpKTsKLQotCQl0aGlzLmFkYXB0ZXIucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgbGlzdGVuZXIpOwotCQlhZGFwdGVyQ29sbGVjdGlvbiA9IENvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKHRoaXMuYWRhcHRlci5pdGVyYXRvcigpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGFkYXB0ZXJDb2xsZWN0aW9uLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyhuZXcgSGFzaEJhZzxTdHJpbmc+KCksIGFkYXB0ZXJDb2xsZWN0aW9uKTsKLQotCQl0aGlzLmFkYXB0ZXIuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgbGlzdGVuZXIpOwotCQlhZGFwdGVyQ29sbGVjdGlvbiA9IENvbGxlY3Rpb25Ub29scy5jb2xsZWN0aW9uKHRoaXMuYWRhcHRlci5pdGVyYXRvcigpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIGFkYXB0ZXJDb2xsZWN0aW9uLnNpemUoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLndyYXBwZWRDb2xsZWN0aW9uKCksIGFkYXB0ZXJDb2xsZWN0aW9uKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCBhZGFwdGVyQ29sbGVjdGlvbi5pdGVyYXRvcigpLm5leHQoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc0xpc3RlbmVycygpIHsKLQkJYXNzZXJ0RmFsc2UoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmFkYXB0ZXIpLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTKSk7Ci0JCUNvb3JkaW5hdGVkQmFnPFN0cmluZz4gc3luY2hDb2xsZWN0aW9uID0gbmV3IENvb3JkaW5hdGVkQmFnPFN0cmluZz4odGhpcy5hZGFwdGVyKTsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMpKTsKLQkJdGhpcy5hZGFwdGVyLnJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIHN5bmNoQ29sbGVjdGlvbik7Ci0JCWFzc2VydEZhbHNlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5hZGFwdGVyKS5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUykpOwotCQl0aGlzLmFkYXB0ZXIuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHN5bmNoQ29sbGVjdGlvbik7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmFkYXB0ZXIpLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTKSk7Ci0JCXRoaXMuYWRhcHRlci5yZW1vdmVDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoc3luY2hDb2xsZWN0aW9uKTsKLQkJYXNzZXJ0RmFsc2UoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmFkYXB0ZXIpLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RDaGFuZ2VkVG9FbXB0eSgpIHsKLQkJdGhpcy5hZGFwdGVyLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIG5ldyBUZXN0TGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsvKiBPSyAqL30KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7LyogT0sgKi99Ci0JCX0pOwotCQl0aGlzLndyYXBwZWRWYWx1ZUhvbGRlci5zZXRWYWx1ZSgiZm9vIik7Ci0JCUpMaXN0IGpMaXN0ID0gbmV3IEpMaXN0KG5ldyBMaXN0TW9kZWxBZGFwdGVyKHRoaXMuYWRhcHRlcikpOwotCQl0aGlzLndyYXBwZWRWYWx1ZUhvbGRlci5zZXRWYWx1ZShudWxsKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGpMaXN0LmdldE1vZGVsKCkuZ2V0U2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29sbGVjdGlvbkNoYW5nZWRGcm9tRW1wdHkoKSB7Ci0JCXRoaXMuYWRhcHRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCBuZXcgVGVzdExpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7LyogT0sgKi99Ci0JCX0pOwotCQlKTGlzdCBqTGlzdCA9IG5ldyBKTGlzdChuZXcgTGlzdE1vZGVsQWRhcHRlcih0aGlzLmFkYXB0ZXIpKTsKLQkJCi0JCXRoaXMud3JhcHBlZFZhbHVlSG9sZGVyLnNldFZhbHVlKCJmb28iKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIGpMaXN0LmdldE1vZGVsKCkuZ2V0U2l6ZSgpKTsKLQl9Ci0JCi0JcHVibGljIHZvaWQgdGVzdENvbGxlY3Rpb25DaGFuZ2VkRnJvbUVtcHR5VG9FbXB0eSgpIHsKLQkJdGhpcy5hZGFwdGVyLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIG5ldyBUZXN0TGlzdGVuZXIoKSk7Ci0JCUpMaXN0IGpMaXN0ID0gbmV3IEpMaXN0KG5ldyBMaXN0TW9kZWxBZGFwdGVyKHRoaXMuYWRhcHRlcikpOwotCQkKLQkJdGhpcy53cmFwcGVkVmFsdWVIb2xkZXIuc2V0VmFsdWUobnVsbCk7Ci0JCWFzc2VydEVxdWFscygwLCBqTGlzdC5nZXRNb2RlbCgpLmdldFNpemUoKSk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIG1lbWJlciBjbGFzcyAqKioqKioqKioqCi0JCi0Jc3RhdGljIGNsYXNzIFRlc3RMaXN0ZW5lciBpbXBsZW1lbnRzIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciB7Ci0JCXB1YmxpYyB2b2lkIGNvbGxlY3Rpb25DaGFuZ2VkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGNvbGxlY3Rpb25DbGVhcmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQlmYWlsKCJ1bmV4cGVjdGVkIGV2ZW50Iik7Ci0JCX0KLQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBldmVudCkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1Byb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlOTczMGY0Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTk4ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmF4LnN3aW5nLkpMaXN0OwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlNpbmdsZUVsZW1lbnRJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5MaXN0TW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50Lkxpc3RDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5MaXN0Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYWRhcHRlcjsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gd3JhcHBlZFZhbHVlSG9sZGVyOwotCi0JcHVibGljIFByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy53cmFwcGVkVmFsdWVIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4oKTsKLQkJdGhpcy5hZGFwdGVyID0gbmV3IFByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyPFN0cmluZz4odGhpcy53cmFwcGVkVmFsdWVIb2xkZXIpOwotCX0KLQotCXByaXZhdGUgQ29sbGVjdGlvbjxTdHJpbmc+IHdyYXBwZWRMaXN0KCkgewotCQlyZXR1cm4gQ29sbGVjdGlvblRvb2xzLmxpc3QobmV3IFNpbmdsZUVsZW1lbnRJdGVyYXRvcjxTdHJpbmc+KHRoaXMud3JhcHBlZFZhbHVlSG9sZGVyLmdldFZhbHVlKCkpKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZXJhdG9yKCkgewotCQl0aGlzLmFkYXB0ZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCBuZXcgVGVzdExpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgey8qIE9LICovfQotCQl9KTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5hZGFwdGVyLml0ZXJhdG9yKCkuaGFzTmV4dCgpKTsKLQkJdGhpcy53cmFwcGVkVmFsdWVIb2xkZXIuc2V0VmFsdWUoImZvbyIpOwotCQlMaXN0PFN0cmluZz4gYWRhcHRlckxpc3QgPSBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmFkYXB0ZXIuaXRlcmF0b3IoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBhZGFwdGVyTGlzdC5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy53cmFwcGVkTGlzdCgpLCBhZGFwdGVyTGlzdCk7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgYWRhcHRlckxpc3QuaXRlcmF0b3IoKS5uZXh0KCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRJbnQoKSB7Ci0JCXRoaXMuYWRhcHRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIG5ldyBUZXN0TGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7LyogT0sgKi99Ci0JCX0pOwotCQl0aGlzLndyYXBwZWRWYWx1ZUhvbGRlci5zZXRWYWx1ZSgiZm9vIik7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy5hZGFwdGVyLmdldCgwKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFRvQXJyYXkxKCkgewotCQl0aGlzLmFkYXB0ZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCBuZXcgVGVzdExpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgey8qIE9LICovfQotCQl9KTsKLQkJdGhpcy53cmFwcGVkVmFsdWVIb2xkZXIuc2V0VmFsdWUoImZvbyIpOwotCQlPYmplY3RbXSBhcnJheSA9IHRoaXMuYWRhcHRlci50b0FycmF5KCk7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgYXJyYXlbMF0pOwotCQlhc3NlcnRFcXVhbHMoMSwgYXJyYXkubGVuZ3RoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VG9BcnJheTIoKSB7Ci0JCXRoaXMuYWRhcHRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIG5ldyBUZXN0TGlzdGVuZXIoKSk7Ci0JCU9iamVjdFtdIGFycmF5ID0gdGhpcy5hZGFwdGVyLnRvQXJyYXkoKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGFycmF5Lmxlbmd0aCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFN0YWxlVmFsdWUoKSB7Ci0JCUxpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBUZXN0TGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7LyogT0sgKi99Ci0JCX07Ci0JCXRoaXMuYWRhcHRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIGxpc3RlbmVyKTsKLQkJdGhpcy53cmFwcGVkVmFsdWVIb2xkZXIuc2V0VmFsdWUoImZvbyIpOwotCQlMaXN0PFN0cmluZz4gYWRhcHRlckxpc3QgPSBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmFkYXB0ZXIuaXRlcmF0b3IoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBhZGFwdGVyTGlzdC5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy53cmFwcGVkTGlzdCgpLCBhZGFwdGVyTGlzdCk7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgYWRhcHRlckxpc3QuaXRlcmF0b3IoKS5uZXh0KCkpOwotCi0JCXRoaXMuYWRhcHRlci5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIGxpc3RlbmVyKTsKLQkJYWRhcHRlckxpc3QgPSBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmFkYXB0ZXIuaXRlcmF0b3IoKSk7Ci0JCWFzc2VydEVxdWFscygwLCBhZGFwdGVyTGlzdC5zaXplKCkpOwotCQlhc3NlcnRFcXVhbHMobmV3IEFycmF5TGlzdDxTdHJpbmc+KCksIGFkYXB0ZXJMaXN0KTsKLQotCQl0aGlzLmFkYXB0ZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCBsaXN0ZW5lcik7Ci0JCWFkYXB0ZXJMaXN0ID0gQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy5hZGFwdGVyLml0ZXJhdG9yKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgYWRhcHRlckxpc3Quc2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMud3JhcHBlZExpc3QoKSwgYWRhcHRlckxpc3QpOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIGFkYXB0ZXJMaXN0Lml0ZXJhdG9yKCkubmV4dCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgewotCQlhc3NlcnRGYWxzZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5hZGFwdGVyKTsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQl0aGlzLmFkYXB0ZXIucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCBzeW5jaExpc3QpOwotCQlhc3NlcnRGYWxzZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQl0aGlzLmFkYXB0ZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKHN5bmNoTGlzdCk7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmFkYXB0ZXIpLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJdGhpcy5hZGFwdGVyLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihzeW5jaExpc3QpOwotCQlhc3NlcnRGYWxzZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0Q2hhbmdlZFRvRW1wdHkoKSB7Ci0JCXRoaXMud3JhcHBlZFZhbHVlSG9sZGVyLnNldFZhbHVlKCJmb28iKTsKLQkJdGhpcy5hZGFwdGVyLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgbmV3IFRlc3RMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgey8qIE9LICovfQotCQl9KTsKLQkJSkxpc3Qgakxpc3QgPSBuZXcgSkxpc3QobmV3IExpc3RNb2RlbEFkYXB0ZXIodGhpcy5hZGFwdGVyKSk7Ci0JCXRoaXMud3JhcHBlZFZhbHVlSG9sZGVyLnNldFZhbHVlKG51bGwpOwotCQlhc3NlcnRFcXVhbHMoMCwgakxpc3QuZ2V0TW9kZWwoKS5nZXRTaXplKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0Q2hhbmdlZEZyb21FbXB0eSgpIHsKLQkJdGhpcy5hZGFwdGVyLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgbmV3IFRlc3RMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsvKiBPSyAqL30KLQkJfSk7Ci0JCUpMaXN0IGpMaXN0ID0gbmV3IEpMaXN0KG5ldyBMaXN0TW9kZWxBZGFwdGVyKHRoaXMuYWRhcHRlcikpOwotCQkKLQkJdGhpcy53cmFwcGVkVmFsdWVIb2xkZXIuc2V0VmFsdWUoImZvbyIpOwotCQlhc3NlcnRFcXVhbHMoMSwgakxpc3QuZ2V0TW9kZWwoKS5nZXRTaXplKCkpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdEl0ZW1DaGFuZ2VkKCkgewotCQl0aGlzLndyYXBwZWRWYWx1ZUhvbGRlci5zZXRWYWx1ZSgiZm9vIik7Ci0JCXRoaXMuYWRhcHRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIG5ldyBUZXN0TGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7LyogT0sgKi99Ci0JCX0pOwotCQlKTGlzdCBqTGlzdCA9IG5ldyBKTGlzdChuZXcgTGlzdE1vZGVsQWRhcHRlcih0aGlzLmFkYXB0ZXIpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIGpMaXN0LmdldE1vZGVsKCkuZ2V0U2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCBqTGlzdC5nZXRNb2RlbCgpLmdldEVsZW1lbnRBdCgwKSk7Ci0JCQotCQl0aGlzLndyYXBwZWRWYWx1ZUhvbGRlci5zZXRWYWx1ZSgiYmFyIik7Ci0JCWFzc2VydEVxdWFscygxLCBqTGlzdC5nZXRNb2RlbCgpLmdldFNpemUoKSk7Ci0JCWFzc2VydEVxdWFscygiYmFyIiwgakxpc3QuZ2V0TW9kZWwoKS5nZXRFbGVtZW50QXQoMCkpOwotCX0KLQkKLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdENoYW5nZWRGcm9tRW1wdHlUb0VtcHR5KCkgewotCQl0aGlzLmFkYXB0ZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCBuZXcgVGVzdExpc3RlbmVyKCkpOwotCQlKTGlzdCBqTGlzdCA9IG5ldyBKTGlzdChuZXcgTGlzdE1vZGVsQWRhcHRlcih0aGlzLmFkYXB0ZXIpKTsKLQkJCi0JCXRoaXMud3JhcHBlZFZhbHVlSG9sZGVyLnNldFZhbHVlKG51bGwpOwotCQlhc3NlcnRFcXVhbHMoMCwgakxpc3QuZ2V0TW9kZWwoKS5nZXRTaXplKCkpOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBtZW1iZXIgY2xhc3MgKioqKioqKioqKgotCQotCXN0YXRpYyBjbGFzcyBUZXN0TGlzdGVuZXIgaW1wbGVtZW50cyBMaXN0Q2hhbmdlTGlzdGVuZXIgewotCQlwdWJsaWMgdm9pZCBsaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCWZhaWwoInVuZXhwZWN0ZWQgZXZlbnQiKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCWZhaWwoInVuZXhwZWN0ZWQgZXZlbnQiKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZXZlbnQpIHsKLQkJCWZhaWwoInVuZXhwZWN0ZWQgZXZlbnQiKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBpdGVtc01vdmVkKExpc3RDaGFuZ2VFdmVudCBldmVudCkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGV2ZW50KSB7Ci0JCQlmYWlsKCJ1bmV4cGVjdGVkIGV2ZW50Iik7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDZjODRjMjYuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0MDkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5IYXNoU2V0OwotaW1wb3J0IGphdmEudXRpbC5TZXQ7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkJhZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuSGFzaEJhZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Db2xsZWN0aW9uQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIFNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+IGJhZ0hvbGRlcjsKLQlDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgYmFnRXZlbnQ7Ci0JU3RyaW5nIGJhZ0V2ZW50VHlwZTsKLQotCXByaXZhdGUgU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8U3RyaW5nPiBzZXRIb2xkZXI7Ci0JQ29sbGVjdGlvbkNoYW5nZUV2ZW50IHNldEV2ZW50OwotCVN0cmluZyBzZXRFdmVudFR5cGU7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQUREID0gImFkZCI7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIFJFTU9WRSA9ICJyZW1vdmUiOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBDSEFOR0UgPSAiY2hhbmdlIjsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQ0xFQVIgPSAiY2xlYXIiOwotCi0JCi0JcHVibGljIFNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy5iYWdIb2xkZXIgPSBuZXcgU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8U3RyaW5nPih0aGlzLmJ1aWxkQmFnKCkpOwotCQl0aGlzLnNldEhvbGRlciA9IG5ldyBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+KHRoaXMuYnVpbGRTZXQoKSk7Ci0JfQotCi0JcHJpdmF0ZSBCYWc8U3RyaW5nPiBidWlsZEJhZygpIHsKLQkJQmFnPFN0cmluZz4gcmVzdWx0ID0gbmV3IEhhc2hCYWc8U3RyaW5nPigpOwotCQl0aGlzLmFkZEl0ZW1zVG8ocmVzdWx0KTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwcml2YXRlIFNldDxTdHJpbmc+IGJ1aWxkU2V0KCkgewotCQlTZXQ8U3RyaW5nPiByZXN1bHQgPSBuZXcgSGFzaFNldDxTdHJpbmc+KCk7Ci0JCXRoaXMuYWRkSXRlbXNUbyhyZXN1bHQpOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCXByaXZhdGUgdm9pZCBhZGRJdGVtc1RvKENvbGxlY3Rpb248U3RyaW5nPiBjKSB7Ci0JCWMuYWRkKCJmb28iKTsKLQkJYy5hZGQoImJhciIpOwotCQljLmFkZCgiYmF6Iik7Ci0JfQotCi0JcHJpdmF0ZSBCYWc8U3RyaW5nPiBidWlsZEFkZEl0ZW1zKCkgewotCQlCYWc8U3RyaW5nPiByZXN1bHQgPSBuZXcgSGFzaEJhZzxTdHJpbmc+KCk7Ci0JCXJlc3VsdC5hZGQoImpvbyIpOwotCQlyZXN1bHQuYWRkKCJqYXIiKTsKLQkJcmVzdWx0LmFkZCgiamF6Iik7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JcHJpdmF0ZSBCYWc8U3RyaW5nPiBidWlsZFJlbW92ZUl0ZW1zKCkgewotCQlCYWc8U3RyaW5nPiByZXN1bHQgPSBuZXcgSGFzaEJhZzxTdHJpbmc+KCk7Ci0JCXJlc3VsdC5hZGQoImZvbyIpOwotCQlyZXN1bHQuYWRkKCJiYXoiKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZXJhdG9yKCkgewotCQlhc3NlcnRFcXVhbHModGhpcy5idWlsZEJhZygpLCBDb2xsZWN0aW9uVG9vbHMuYmFnKHRoaXMuYmFnSG9sZGVyLml0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRTZXQoKSwgQ29sbGVjdGlvblRvb2xzLnNldCh0aGlzLnNldEhvbGRlci5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNpemUoKSB7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkQmFnKCkuc2l6ZSgpLCBDb2xsZWN0aW9uVG9vbHMuc2l6ZSh0aGlzLmJhZ0hvbGRlci5pdGVyYXRvcigpKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkU2V0KCkuc2l6ZSgpLCBDb2xsZWN0aW9uVG9vbHMuc2l6ZSh0aGlzLnNldEhvbGRlci5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHJpdmF0ZSBib29sZWFuIGJhZ0hvbGRlckNvbnRhaW5zKE9iamVjdCBpdGVtKSB7Ci0JCXJldHVybiBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5iYWdIb2xkZXIuaXRlcmF0b3IoKSwgaXRlbSk7Ci0JfQotCi0JcHJpdmF0ZSBib29sZWFuIHNldEhvbGRlckNvbnRhaW5zKE9iamVjdCBpdGVtKSB7Ci0JCXJldHVybiBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5zZXRIb2xkZXIuaXRlcmF0b3IoKSwgaXRlbSk7Ci0JfQotCi0JcHJpdmF0ZSBib29sZWFuIGJhZ0hvbGRlckNvbnRhaW5zQWxsKENvbGxlY3Rpb248U3RyaW5nPiBpdGVtcykgewotCQlyZXR1cm4gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKHRoaXMuYmFnSG9sZGVyLml0ZXJhdG9yKCksIGl0ZW1zKTsKLQl9Ci0KLQlwcml2YXRlIGJvb2xlYW4gc2V0SG9sZGVyQ29udGFpbnNBbGwoQ29sbGVjdGlvbjxTdHJpbmc+IGl0ZW1zKSB7Ci0JCXJldHVybiBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwodGhpcy5zZXRIb2xkZXIuaXRlcmF0b3IoKSwgaXRlbXMpOwotCX0KLQotCXByaXZhdGUgYm9vbGVhbiBiYWdIb2xkZXJDb250YWluc0FueShDb2xsZWN0aW9uPFN0cmluZz4gaXRlbXMpIHsKLQkJQmFnPFN0cmluZz4gYmFnID0gQ29sbGVjdGlvblRvb2xzLmJhZyh0aGlzLmJhZ0hvbGRlci5pdGVyYXRvcigpKTsKLQkJZm9yIChTdHJpbmcgc3RyaW5nIDogaXRlbXMpIHsKLQkJCWlmIChiYWcuY29udGFpbnMoc3RyaW5nKSkgewotCQkJCXJldHVybiB0cnVlOwotCQkJfQotCQl9Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQlwcml2YXRlIGJvb2xlYW4gc2V0SG9sZGVyQ29udGFpbnNBbnkoQ29sbGVjdGlvbjxTdHJpbmc+IGl0ZW1zKSB7Ci0JCVNldDxTdHJpbmc+IHNldCA9IENvbGxlY3Rpb25Ub29scy5zZXQodGhpcy5zZXRIb2xkZXIuaXRlcmF0b3IoKSk7Ci0JCWZvciAoU3RyaW5nIHN0cmluZyA6IGl0ZW1zKSB7Ci0JCQlpZiAoc2V0LmNvbnRhaW5zKHN0cmluZykpIHsKLQkJCQlyZXR1cm4gdHJ1ZTsKLQkJCX0KLQkJfQotCQlyZXR1cm4gZmFsc2U7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZCgpIHsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWdIb2xkZXJDb250YWlucygiam9vIikpOwotCQl0aGlzLmJhZ0hvbGRlci5hZGQoImpvbyIpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnSG9sZGVyQ29udGFpbnMoImpvbyIpKTsKLQotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZ0hvbGRlckNvbnRhaW5zKG51bGwpKTsKLQkJdGhpcy5iYWdIb2xkZXIuYWRkKG51bGwpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnSG9sZGVyQ29udGFpbnMobnVsbCkpOwotCi0JCWFzc2VydEZhbHNlKHRoaXMuc2V0SG9sZGVyQ29udGFpbnMoImpvbyIpKTsKLQkJdGhpcy5zZXRIb2xkZXIuYWRkKCJqb28iKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnNldEhvbGRlckNvbnRhaW5zKCJqb28iKSk7Ci0KLQkJYXNzZXJ0RmFsc2UodGhpcy5zZXRIb2xkZXJDb250YWlucyhudWxsKSk7Ci0JCXRoaXMuc2V0SG9sZGVyLmFkZChudWxsKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnNldEhvbGRlckNvbnRhaW5zKG51bGwpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkQWxsKCkgewotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZ0hvbGRlckNvbnRhaW5zQW55KHRoaXMuYnVpbGRBZGRJdGVtcygpKSk7Ci0JCXRoaXMuYmFnSG9sZGVyLmFkZEFsbCh0aGlzLmJ1aWxkQWRkSXRlbXMoKSk7Ci0JCWFzc2VydFRydWUodGhpcy5iYWdIb2xkZXJDb250YWluc0FsbCh0aGlzLmJ1aWxkQWRkSXRlbXMoKSkpOwotCi0JCWFzc2VydEZhbHNlKHRoaXMuc2V0SG9sZGVyQ29udGFpbnNBbnkodGhpcy5idWlsZEFkZEl0ZW1zKCkpKTsKLQkJdGhpcy5zZXRIb2xkZXIuYWRkQWxsKHRoaXMuYnVpbGRBZGRJdGVtcygpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnNldEhvbGRlckNvbnRhaW5zQWxsKHRoaXMuYnVpbGRBZGRJdGVtcygpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZSgpIHsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZ0hvbGRlckNvbnRhaW5zKCJiYXIiKSk7Ci0JCXRoaXMuYmFnSG9sZGVyLnJlbW92ZSgiYmFyIik7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnSG9sZGVyQ29udGFpbnMoImJhciIpKTsKLQotCQl0aGlzLmJhZ0hvbGRlci5hZGQobnVsbCk7Ci0JCWFzc2VydFRydWUodGhpcy5iYWdIb2xkZXJDb250YWlucyhudWxsKSk7Ci0JCXRoaXMuYmFnSG9sZGVyLnJlbW92ZShudWxsKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWdIb2xkZXJDb250YWlucyhudWxsKSk7Ci0KLQkJYXNzZXJ0VHJ1ZSh0aGlzLnNldEhvbGRlckNvbnRhaW5zKCJiYXIiKSk7Ci0JCXRoaXMuc2V0SG9sZGVyLnJlbW92ZSgiYmFyIik7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc2V0SG9sZGVyQ29udGFpbnMoImJhciIpKTsKLQotCQl0aGlzLnNldEhvbGRlci5hZGQobnVsbCk7Ci0JCWFzc2VydFRydWUodGhpcy5zZXRIb2xkZXJDb250YWlucyhudWxsKSk7Ci0JCXRoaXMuc2V0SG9sZGVyLnJlbW92ZShudWxsKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zZXRIb2xkZXJDb250YWlucyhudWxsKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFJlbW92ZUFsbCgpIHsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJhZ0hvbGRlckNvbnRhaW5zQWxsKHRoaXMuYnVpbGRSZW1vdmVJdGVtcygpKSk7Ci0JCXRoaXMuYmFnSG9sZGVyLnJlbW92ZUFsbCh0aGlzLmJ1aWxkUmVtb3ZlSXRlbXMoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmFnSG9sZGVyQ29udGFpbnNBbnkodGhpcy5idWlsZFJlbW92ZUl0ZW1zKCkpKTsKLQotCQlhc3NlcnRUcnVlKHRoaXMuc2V0SG9sZGVyQ29udGFpbnNBbGwodGhpcy5idWlsZFJlbW92ZUl0ZW1zKCkpKTsKLQkJdGhpcy5zZXRIb2xkZXIucmVtb3ZlQWxsKHRoaXMuYnVpbGRSZW1vdmVJdGVtcygpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zZXRIb2xkZXJDb250YWluc0FueSh0aGlzLmJ1aWxkUmVtb3ZlSXRlbXMoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRDb2xsZWN0aW9uKCkgewotCQlhc3NlcnRUcnVlKHRoaXMuYmFnSG9sZGVyQ29udGFpbnMoImJhciIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWdIb2xkZXJDb250YWlucygiamFyIikpOwotCQl0aGlzLmJhZ0hvbGRlci5zZXRDb2xsZWN0aW9uKHRoaXMuYnVpbGRBZGRJdGVtcygpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWdIb2xkZXJDb250YWlucygiYmFyIikpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmFnSG9sZGVyQ29udGFpbnMoImphciIpKTsKLQotCQl0aGlzLmJhZ0hvbGRlci5hZGQobnVsbCk7Ci0JCWFzc2VydFRydWUodGhpcy5iYWdIb2xkZXJDb250YWlucyhudWxsKSk7Ci0JCXRoaXMuYmFnSG9sZGVyLnJlbW92ZShudWxsKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5iYWdIb2xkZXJDb250YWlucyhudWxsKSk7Ci0KLQkJdGhpcy5iYWdIb2xkZXIuc2V0Q29sbGVjdGlvbihuZXcgSGFzaEJhZzxTdHJpbmc+KCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJhZ0hvbGRlckNvbnRhaW5zKCJqYXIiKSk7Ci0KLQkJYXNzZXJ0VHJ1ZSh0aGlzLnNldEhvbGRlckNvbnRhaW5zKCJiYXIiKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc2V0SG9sZGVyQ29udGFpbnMoImphciIpKTsKLQkJdGhpcy5zZXRIb2xkZXIuc2V0Q29sbGVjdGlvbih0aGlzLmJ1aWxkQWRkSXRlbXMoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc2V0SG9sZGVyQ29udGFpbnMoImJhciIpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnNldEhvbGRlckNvbnRhaW5zKCJqYXIiKSk7Ci0KLQkJdGhpcy5zZXRIb2xkZXIuYWRkKG51bGwpOwotCQlhc3NlcnRUcnVlKHRoaXMuc2V0SG9sZGVyQ29udGFpbnMobnVsbCkpOwotCQl0aGlzLnNldEhvbGRlci5yZW1vdmUobnVsbCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc2V0SG9sZGVyQ29udGFpbnMobnVsbCkpOwotCi0JCXRoaXMuc2V0SG9sZGVyLnNldENvbGxlY3Rpb24obmV3IEhhc2hCYWc8U3RyaW5nPigpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zZXRIb2xkZXJDb250YWlucygiamFyIikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb2xsZWN0aW9uQ2hhbmdlMSgpIHsKLQkJdGhpcy5iYWdIb2xkZXIuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRCYWdMaXN0ZW5lcigpKTsKLQkJdGhpcy52ZXJpZnlCYWdDaGFuZ2UoKTsKLQotCQl0aGlzLnNldEhvbGRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZFNldExpc3RlbmVyKCkpOwotCQl0aGlzLnZlcmlmeVNldENoYW5nZSgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb2xsZWN0aW9uQ2hhbmdlMigpIHsKLQkJdGhpcy5iYWdIb2xkZXIuYWRkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgdGhpcy5idWlsZEJhZ0xpc3RlbmVyKCkpOwotCQl0aGlzLnZlcmlmeUJhZ0NoYW5nZSgpOwotCi0JCXRoaXMuc2V0SG9sZGVyLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIHRoaXMuYnVpbGRTZXRMaXN0ZW5lcigpKTsKLQkJdGhpcy52ZXJpZnlTZXRDaGFuZ2UoKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5QmFnQ2hhbmdlKCkgewotCQl0aGlzLmJhZ0V2ZW50ID0gbnVsbDsKLQkJdGhpcy5iYWdFdmVudFR5cGUgPSBudWxsOwotCQl0aGlzLmJhZ0hvbGRlci5hZGQoImZvbyIpOwotCQl0aGlzLnZlcmlmeUJhZ0V2ZW50KEFERCwgImZvbyIpOwotCi0JCXRoaXMuYmFnRXZlbnQgPSBudWxsOwotCQl0aGlzLmJhZ0V2ZW50VHlwZSA9IG51bGw7Ci0JCXRoaXMuYmFnSG9sZGVyLmFkZCgiZm9vIik7Ci0JCXRoaXMudmVyaWZ5QmFnRXZlbnQoQURELCAiZm9vIik7Ci0KLQkJdGhpcy5iYWdFdmVudCA9IG51bGw7Ci0JCXRoaXMuYmFnRXZlbnRUeXBlID0gbnVsbDsKLQkJdGhpcy5iYWdIb2xkZXIuYWRkKCJqb28iKTsKLQkJdGhpcy52ZXJpZnlCYWdFdmVudChBREQsICJqb28iKTsKLQotCQl0aGlzLmJhZ0V2ZW50ID0gbnVsbDsKLQkJdGhpcy5iYWdFdmVudFR5cGUgPSBudWxsOwotCQl0aGlzLmJhZ0hvbGRlci5hZGQobnVsbCk7Ci0JCXRoaXMudmVyaWZ5QmFnRXZlbnQoQURELCBudWxsKTsKLQotCQl0aGlzLmJhZ0V2ZW50ID0gbnVsbDsKLQkJdGhpcy5iYWdFdmVudFR5cGUgPSBudWxsOwotCQl0aGlzLmJhZ0hvbGRlci5hZGQobnVsbCk7Ci0JCXRoaXMudmVyaWZ5QmFnRXZlbnQoQURELCBudWxsKTsKLQotCQl0aGlzLmJhZ0V2ZW50ID0gbnVsbDsKLQkJdGhpcy5iYWdFdmVudFR5cGUgPSBudWxsOwotCQl0aGlzLmJhZ0hvbGRlci5yZW1vdmUoImpvbyIpOwotCQl0aGlzLnZlcmlmeUJhZ0V2ZW50KFJFTU9WRSwgImpvbyIpOwotCi0JCXRoaXMuYmFnRXZlbnQgPSBudWxsOwotCQl0aGlzLmJhZ0V2ZW50VHlwZSA9IG51bGw7Ci0JCXRoaXMuYmFnSG9sZGVyLnJlbW92ZShudWxsKTsKLQkJdGhpcy52ZXJpZnlCYWdFdmVudChSRU1PVkUsIG51bGwpOwotCi0JCXRoaXMuYmFnRXZlbnQgPSBudWxsOwotCQl0aGlzLmJhZ0V2ZW50VHlwZSA9IG51bGw7Ci0JCXRoaXMuYmFnSG9sZGVyLnNldENvbGxlY3Rpb24odGhpcy5idWlsZEJhZygpKTsKLQkJdGhpcy52ZXJpZnlCYWdFdmVudChDSEFOR0UpOwotCi0JCXRoaXMuYmFnRXZlbnQgPSBudWxsOwotCQl0aGlzLmJhZ0V2ZW50VHlwZSA9IG51bGw7Ci0JCXRoaXMuYmFnSG9sZGVyLmFkZEFsbCh0aGlzLmJ1aWxkQmFnKCkpOwotCQl0aGlzLnZlcmlmeUJhZ0V2ZW50KEFERCk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkQmFnKCksIENvbGxlY3Rpb25Ub29scy5iYWcodGhpcy5iYWdFdmVudC5pdGVtcygpKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVNldENoYW5nZSgpIHsKLQkJdGhpcy5zZXRFdmVudCA9IG51bGw7Ci0JCXRoaXMuc2V0RXZlbnRUeXBlID0gbnVsbDsKLQkJdGhpcy5zZXRIb2xkZXIuYWRkKCJmb28iKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLnNldEV2ZW50KTsKLQkJYXNzZXJ0TnVsbCh0aGlzLnNldEV2ZW50VHlwZSk7Ci0KLQkJdGhpcy5zZXRFdmVudCA9IG51bGw7Ci0JCXRoaXMuc2V0RXZlbnRUeXBlID0gbnVsbDsKLQkJdGhpcy5zZXRIb2xkZXIuYWRkKCJqb28iKTsKLQkJdGhpcy52ZXJpZnlTZXRFdmVudChBREQsICJqb28iKTsKLQotCQl0aGlzLnNldEV2ZW50ID0gbnVsbDsKLQkJdGhpcy5zZXRFdmVudFR5cGUgPSBudWxsOwotCQl0aGlzLnNldEhvbGRlci5hZGQoImpvbyIpOwotCQlhc3NlcnROdWxsKHRoaXMuc2V0RXZlbnQpOwotCQlhc3NlcnROdWxsKHRoaXMuc2V0RXZlbnRUeXBlKTsKLQotCQl0aGlzLnNldEV2ZW50ID0gbnVsbDsKLQkJdGhpcy5zZXRFdmVudFR5cGUgPSBudWxsOwotCQl0aGlzLnNldEhvbGRlci5hZGQobnVsbCk7Ci0JCXRoaXMudmVyaWZ5U2V0RXZlbnQoQURELCBudWxsKTsKLQotCQl0aGlzLnNldEV2ZW50ID0gbnVsbDsKLQkJdGhpcy5zZXRFdmVudFR5cGUgPSBudWxsOwotCQl0aGlzLnNldEhvbGRlci5hZGQobnVsbCk7Ci0JCWFzc2VydE51bGwodGhpcy5zZXRFdmVudCk7Ci0JCWFzc2VydE51bGwodGhpcy5zZXRFdmVudFR5cGUpOwotCi0JCXRoaXMuc2V0RXZlbnQgPSBudWxsOwotCQl0aGlzLnNldEV2ZW50VHlwZSA9IG51bGw7Ci0JCXRoaXMuc2V0SG9sZGVyLnJlbW92ZSgiam9vIik7Ci0JCXRoaXMudmVyaWZ5U2V0RXZlbnQoUkVNT1ZFLCAiam9vIik7Ci0KLQkJdGhpcy5zZXRFdmVudCA9IG51bGw7Ci0JCXRoaXMuc2V0RXZlbnRUeXBlID0gbnVsbDsKLQkJdGhpcy5zZXRIb2xkZXIucmVtb3ZlKCJqb28iKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLnNldEV2ZW50KTsKLQkJYXNzZXJ0TnVsbCh0aGlzLnNldEV2ZW50VHlwZSk7Ci0KLQkJdGhpcy5zZXRFdmVudCA9IG51bGw7Ci0JCXRoaXMuc2V0RXZlbnRUeXBlID0gbnVsbDsKLQkJdGhpcy5zZXRIb2xkZXIucmVtb3ZlKG51bGwpOwotCQl0aGlzLnZlcmlmeVNldEV2ZW50KFJFTU9WRSwgbnVsbCk7Ci0KLQkJdGhpcy5zZXRFdmVudCA9IG51bGw7Ci0JCXRoaXMuc2V0RXZlbnRUeXBlID0gbnVsbDsKLQkJdGhpcy5zZXRIb2xkZXIuc2V0Q29sbGVjdGlvbih0aGlzLmJ1aWxkU2V0KCkpOwotCQl0aGlzLnZlcmlmeVNldEV2ZW50KENIQU5HRSk7Ci0KLQkJdGhpcy5zZXRFdmVudCA9IG51bGw7Ci0JCXRoaXMuc2V0RXZlbnRUeXBlID0gbnVsbDsKLQkJdGhpcy5zZXRIb2xkZXIuYWRkQWxsKHRoaXMuYnVpbGRTZXQoKSk7Ci0JCWFzc2VydE51bGwodGhpcy5zZXRFdmVudCk7Ci0JCWFzc2VydE51bGwodGhpcy5zZXRFdmVudFR5cGUpOwotCX0KLQotCXByaXZhdGUgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyIGJ1aWxkQmFnTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQkJCVNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMudGhpcy5iYWdFdmVudFR5cGUgPSBBREQ7Ci0JCQkJU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy50aGlzLmJhZ0V2ZW50ID0gZTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQkJCVNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMudGhpcy5iYWdFdmVudFR5cGUgPSBSRU1PVkU7Ci0JCQkJU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy50aGlzLmJhZ0V2ZW50ID0gZTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGNvbGxlY3Rpb25DbGVhcmVkKENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7Ci0JCQkJU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy50aGlzLmJhZ0V2ZW50VHlwZSA9IENMRUFSOwotCQkJCVNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMudGhpcy5iYWdFdmVudCA9IGU7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBjb2xsZWN0aW9uQ2hhbmdlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQkJCVNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMudGhpcy5iYWdFdmVudFR5cGUgPSBDSEFOR0U7Ci0JCQkJU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy50aGlzLmJhZ0V2ZW50ID0gZTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBidWlsZFNldExpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCQlTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLnRoaXMuc2V0RXZlbnRUeXBlID0gQUREOwotCQkJCVNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMudGhpcy5zZXRFdmVudCA9IGU7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc1JlbW92ZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCQlTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLnRoaXMuc2V0RXZlbnRUeXBlID0gUkVNT1ZFOwotCQkJCVNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMudGhpcy5zZXRFdmVudCA9IGU7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBjb2xsZWN0aW9uQ2xlYXJlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQkJCVNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMudGhpcy5zZXRFdmVudFR5cGUgPSBDTEVBUjsKLQkJCQlTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLnRoaXMuc2V0RXZlbnQgPSBlOwotCQkJfQotCQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNoYW5nZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCQlTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLnRoaXMuc2V0RXZlbnRUeXBlID0gQ0hBTkdFOwotCQkJCVNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMudGhpcy5zZXRFdmVudCA9IGU7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUJhZ0V2ZW50KFN0cmluZyBldmVudFR5cGUpIHsKLQkJYXNzZXJ0RXF1YWxzKGV2ZW50VHlwZSwgdGhpcy5iYWdFdmVudFR5cGUpOwotCQlhc3NlcnRFcXVhbHModGhpcy5iYWdIb2xkZXIsIHRoaXMuYmFnRXZlbnQuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCB0aGlzLmJhZ0V2ZW50LmdldENvbGxlY3Rpb25OYW1lKCkpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlCYWdFdmVudChTdHJpbmcgZXZlbnRUeXBlLCBPYmplY3QgaXRlbSkgewotCQl0aGlzLnZlcmlmeUJhZ0V2ZW50KGV2ZW50VHlwZSk7Ci0JCWFzc2VydEVxdWFscyhpdGVtLCB0aGlzLmJhZ0V2ZW50Lml0ZW1zKCkubmV4dCgpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5U2V0RXZlbnQoU3RyaW5nIGV2ZW50VHlwZSkgewotCQlhc3NlcnRFcXVhbHMoZXZlbnRUeXBlLCB0aGlzLnNldEV2ZW50VHlwZSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnNldEhvbGRlciwgdGhpcy5zZXRFdmVudC5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIHRoaXMuc2V0RXZlbnQuZ2V0Q29sbGVjdGlvbk5hbWUoKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeVNldEV2ZW50KFN0cmluZyBldmVudFR5cGUsIE9iamVjdCBpdGVtKSB7Ci0JCXRoaXMudmVyaWZ5U2V0RXZlbnQoZXZlbnRUeXBlKTsKLQkJYXNzZXJ0RXF1YWxzKGl0ZW0sIHRoaXMuc2V0RXZlbnQuaXRlbXMoKS5uZXh0KCkpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TaW1wbGVMaXN0VmFsdWVNb2RlbFRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1NpbXBsZUxpc3RWYWx1ZU1vZGVsVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTgxZWU0NS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1NpbXBsZUxpc3RWYWx1ZU1vZGVsVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDMyNyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLlNldDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZUxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50Lkxpc3RDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5MaXN0Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgU2ltcGxlTGlzdFZhbHVlTW9kZWxUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gbGlzdEhvbGRlcjsKLQlMaXN0Q2hhbmdlRXZlbnQgZXZlbnQ7Ci0JU3RyaW5nIGV2ZW50VHlwZTsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBBREQgPSAiYWRkIjsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgUkVNT1ZFID0gInJlbW92ZSI7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIFJFUExBQ0UgPSAicmVwbGFjZSI7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIE1PVkUgPSAibW92ZSI7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIENMRUFSID0gImNsZWFyIjsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQ0hBTkdFID0gImNoYW5nZSI7Ci0KLQkKLQlwdWJsaWMgU2ltcGxlTGlzdFZhbHVlTW9kZWxUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLmxpc3RIb2xkZXIgPSBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPih0aGlzLmJ1aWxkTGlzdCgpKTsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBidWlsZExpc3QoKSB7Ci0JCUxpc3Q8U3RyaW5nPiByZXN1bHQgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJcmVzdWx0LmFkZCgiZm9vIik7Ci0JCXJlc3VsdC5hZGQoImJhciIpOwotCQlyZXN1bHQuYWRkKCJiYXoiKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBidWlsZEFkZExpc3QoKSB7Ci0JCUxpc3Q8U3RyaW5nPiByZXN1bHQgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJcmVzdWx0LmFkZCgiam9vIik7Ci0JCXJlc3VsdC5hZGQoImphciIpOwotCQlyZXN1bHQuYWRkKCJqYXoiKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLS8vCXByaXZhdGUgTGlzdDxTdHJpbmc+IGJ1aWxkUmVtb3ZlTGlzdCgpIHsKLS8vCQlMaXN0PFN0cmluZz4gcmVzdWx0ID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0vLwkJcmVzdWx0LmFkZCgiZm9vIik7Ci0vLwkJcmVzdWx0LmFkZCgiYmFyIik7Ci0vLwkJcmV0dXJuIHJlc3VsdDsKLS8vCX0KLS8vCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVyYXRvcigpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRMaXN0KCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMubGlzdEhvbGRlci5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RJdGVyYXRvcigpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRMaXN0KCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMubGlzdEhvbGRlci5saXN0SXRlcmF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0SXRlcmF0b3JJbnQoKSB7Ci0JCWFzc2VydEVxdWFscyhDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmJ1aWxkTGlzdCgpLmxpc3RJdGVyYXRvcigxKSksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMubGlzdEhvbGRlci5saXN0SXRlcmF0b3IoMSkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2l6ZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRMaXN0KCkuc2l6ZSgpLCB0aGlzLmxpc3RIb2xkZXIuc2l6ZSgpKTsKLQl9Ci0KLQlwcml2YXRlIGJvb2xlYW4gbGlzdENvbnRhaW5zKE9iamVjdCBpdGVtKSB7Ci0JCXJldHVybiBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5saXN0SG9sZGVyLmxpc3RJdGVyYXRvcigpLCBpdGVtKTsKLQl9Ci0KLQlwcml2YXRlIGJvb2xlYW4gbGlzdENvbnRhaW5zQWxsKENvbGxlY3Rpb248U3RyaW5nPiBpdGVtcykgewotCQlyZXR1cm4gQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zQWxsKHRoaXMubGlzdEhvbGRlci5saXN0SXRlcmF0b3IoKSwgaXRlbXMpOwotCX0KLQotCXByaXZhdGUgYm9vbGVhbiBsaXN0Q29udGFpbnNBbnkoQ29sbGVjdGlvbjxTdHJpbmc+IGl0ZW1zKSB7Ci0JCVNldDxTdHJpbmc+IHNldCA9IENvbGxlY3Rpb25Ub29scy5zZXQodGhpcy5saXN0SG9sZGVyLml0ZXJhdG9yKCkpOwotCQlmb3IgKEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gaXRlbXMuaXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQlpZiAoc2V0LmNvbnRhaW5zKHN0cmVhbS5uZXh0KCkpKSB7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRPYmplY3QoKSB7Ci0JCWFzc2VydEZhbHNlKHRoaXMubGlzdENvbnRhaW5zKCJqb28iKSk7Ci0JCXRoaXMubGlzdEhvbGRlci5hZGQoImpvbyIpOwotCQlhc3NlcnRUcnVlKHRoaXMubGlzdENvbnRhaW5zKCJqb28iKSk7Ci0KLQkJYXNzZXJ0RmFsc2UodGhpcy5saXN0Q29udGFpbnMobnVsbCkpOwotCQl0aGlzLmxpc3RIb2xkZXIuYWRkKG51bGwpOwotCQlhc3NlcnRUcnVlKHRoaXMubGlzdENvbnRhaW5zKG51bGwpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkSW50T2JqZWN0KCkgewotCQlhc3NlcnRGYWxzZSh0aGlzLmxpc3RDb250YWlucygiam9vIikpOwotCQl0aGlzLmxpc3RIb2xkZXIuYWRkKDIsICJqb28iKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmxpc3RDb250YWlucygiam9vIikpOwotCi0JCWFzc2VydEZhbHNlKHRoaXMubGlzdENvbnRhaW5zKG51bGwpKTsKLQkJdGhpcy5saXN0SG9sZGVyLmFkZCgwLCBudWxsKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmxpc3RDb250YWlucyhudWxsKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbENvbGxlY3Rpb24oKSB7Ci0JCWFzc2VydEZhbHNlKHRoaXMubGlzdENvbnRhaW5zQW55KHRoaXMuYnVpbGRBZGRMaXN0KCkpKTsKLQkJdGhpcy5saXN0SG9sZGVyLmFkZEFsbCh0aGlzLmJ1aWxkQWRkTGlzdCgpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmxpc3RDb250YWluc0FsbCh0aGlzLmJ1aWxkQWRkTGlzdCgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZEFsbEludENvbGxlY3Rpb24oKSB7Ci0JCWFzc2VydEZhbHNlKHRoaXMubGlzdENvbnRhaW5zQW55KHRoaXMuYnVpbGRBZGRMaXN0KCkpKTsKLQkJdGhpcy5saXN0SG9sZGVyLmFkZEFsbCgyLCB0aGlzLmJ1aWxkQWRkTGlzdCgpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmxpc3RDb250YWluc0FsbCh0aGlzLmJ1aWxkQWRkTGlzdCgpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENsZWFyKCkgewotCQlhc3NlcnRGYWxzZSh0aGlzLmxpc3RIb2xkZXIuaXNFbXB0eSgpKTsKLQkJdGhpcy5saXN0SG9sZGVyLmNsZWFyKCk7Ci0JCWFzc2VydFRydWUodGhpcy5saXN0SG9sZGVyLmlzRW1wdHkoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdENvbnRhaW5zT2JqZWN0KCkgewotCQlhc3NlcnRUcnVlKHRoaXMubGlzdEhvbGRlci5jb250YWlucygiZm9vIikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmxpc3RIb2xkZXIuY29udGFpbnMoImpvbyIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29udGFpbnNBbGxDb2xsZWN0aW9uKCkgewotCQlDb2xsZWN0aW9uPFN0cmluZz4gYyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQljLmFkZCgiZm9vIik7Ci0JCWMuYWRkKCJiYXIiKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmxpc3RIb2xkZXIuY29udGFpbnNBbGwoYykpOwotCi0JCWMuYWRkKCJqb28iKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5saXN0SG9sZGVyLmNvbnRhaW5zQWxsKGMpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RXF1YWxzKCkgewotCQlhc3NlcnRFcXVhbHMobmV3IFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4odGhpcy5idWlsZExpc3QoKSksIHRoaXMubGlzdEhvbGRlcik7Ci0JCWFzc2VydEZhbHNlKHRoaXMubGlzdEhvbGRlci5lcXVhbHMobmV3IFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4odGhpcy5idWlsZEFkZExpc3QoKSkpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5saXN0SG9sZGVyLmVxdWFscyh0aGlzLmJ1aWxkTGlzdCgpKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMubGlzdEhvbGRlci5lcXVhbHMobmV3IFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4oKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRJbnQoKSB7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy5saXN0SG9sZGVyLmdldCgwKSk7Ci0JCWFzc2VydEVxdWFscygiYmFyIiwgdGhpcy5saXN0SG9sZGVyLmdldCgxKSk7Ci0JCWFzc2VydEVxdWFscygiYmF6IiwgdGhpcy5saXN0SG9sZGVyLmdldCgyKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc2hDb2RlKCkgewotCQlhc3NlcnRFcXVhbHMobmV3IFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4odGhpcy5idWlsZExpc3QoKSkuaGFzaENvZGUoKSwgdGhpcy5saXN0SG9sZGVyLmhhc2hDb2RlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbmRleE9mT2JqZWN0KCkgewotCQlhc3NlcnRFcXVhbHMoMCwgdGhpcy5saXN0SG9sZGVyLmluZGV4T2YoImZvbyIpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIHRoaXMubGlzdEhvbGRlci5pbmRleE9mKCJiYXIiKSk7Ci0JCWFzc2VydEVxdWFscygyLCB0aGlzLmxpc3RIb2xkZXIuaW5kZXhPZigiYmF6IikpOwotCQlhc3NlcnRFcXVhbHMoLTEsIHRoaXMubGlzdEhvbGRlci5pbmRleE9mKCJqb28iKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExhc3RJbmRleE9mT2JqZWN0KCkgewotCQlhc3NlcnRFcXVhbHMoMCwgdGhpcy5saXN0SG9sZGVyLmxhc3RJbmRleE9mKCJmb28iKSk7Ci0JCWFzc2VydEVxdWFscygxLCB0aGlzLmxpc3RIb2xkZXIubGFzdEluZGV4T2YoImJhciIpKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIHRoaXMubGlzdEhvbGRlci5sYXN0SW5kZXhPZigiYmF6IikpOwotCQlhc3NlcnRFcXVhbHMoLTEsIHRoaXMubGlzdEhvbGRlci5sYXN0SW5kZXhPZigiam9vIikpOwotCi0JCXRoaXMubGlzdEhvbGRlci5hZGQoImZvbyIpOwotCQlhc3NlcnRFcXVhbHMoMywgdGhpcy5saXN0SG9sZGVyLmxhc3RJbmRleE9mKCJmb28iKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdElzRW1wdHkoKSB7Ci0JCWFzc2VydEZhbHNlKHRoaXMubGlzdEhvbGRlci5pc0VtcHR5KCkpOwotCQl0aGlzLmxpc3RIb2xkZXIuY2xlYXIoKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmxpc3RIb2xkZXIuaXNFbXB0eSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlKCkgewotCQlhc3NlcnRUcnVlKHRoaXMubGlzdENvbnRhaW5zKCJiYXIiKSk7Ci0JCXRoaXMubGlzdEhvbGRlci5yZW1vdmUodGhpcy5idWlsZExpc3QoKS5pbmRleE9mKCJiYXIiKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMubGlzdENvbnRhaW5zKCJiYXIiKSk7Ci0KLQkJdGhpcy5saXN0SG9sZGVyLmFkZCgxLCBudWxsKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmxpc3RDb250YWlucyhudWxsKSk7Ci0JCXRoaXMubGlzdEhvbGRlci5yZW1vdmUoMSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMubGlzdENvbnRhaW5zKG51bGwpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2V0VmFsdWVzKCkgewotCQlMaXN0PFN0cmluZz4gbmV3TGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQluZXdMaXN0LmFkZCgiam9vIik7Ci0JCW5ld0xpc3QuYWRkKCJqYXIiKTsKLQkJbmV3TGlzdC5hZGQoImpheiIpOwotCi0JCWFzc2VydFRydWUodGhpcy5saXN0Q29udGFpbnMoImJhciIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5saXN0Q29udGFpbnMoImphciIpKTsKLQkJdGhpcy5saXN0SG9sZGVyLnNldExpc3QobmV3TGlzdCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMubGlzdENvbnRhaW5zKCJiYXIiKSk7Ci0JCWFzc2VydFRydWUodGhpcy5saXN0Q29udGFpbnMoImphciIpKTsKLQotCQl0aGlzLmxpc3RIb2xkZXIuYWRkKDEsIG51bGwpOwotCQlhc3NlcnRUcnVlKHRoaXMubGlzdENvbnRhaW5zKG51bGwpKTsKLQkJdGhpcy5saXN0SG9sZGVyLnJlbW92ZSgxKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5saXN0Q29udGFpbnMobnVsbCkpOwotCi0JCXRoaXMubGlzdEhvbGRlci5zZXRMaXN0KG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5saXN0Q29udGFpbnMoImphciIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdENoYW5nZTEoKSB7Ci0JCXRoaXMubGlzdEhvbGRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIodGhpcy5idWlsZExpc3RlbmVyKCkpOwotCQl0aGlzLnZlcmlmeUxpc3RDaGFuZ2UoKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdENoYW5nZTIoKSB7Ci0JCXRoaXMubGlzdEhvbGRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMuYnVpbGRMaXN0ZW5lcigpKTsKLQkJdGhpcy52ZXJpZnlMaXN0Q2hhbmdlKCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUxpc3RDaGFuZ2UoKSB7Ci0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLmV2ZW50VHlwZSA9IG51bGw7Ci0JCXRoaXMubGlzdEhvbGRlci5hZGQoMSwgImpvbyIpOwotCQl0aGlzLnZlcmlmeUV2ZW50KEFERCwgMSwgImpvbyIpOwotCi0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLmV2ZW50VHlwZSA9IG51bGw7Ci0JCXRoaXMubGlzdEhvbGRlci5hZGQoMSwgbnVsbCk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQoQURELCAxLCBudWxsKTsKLQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy5ldmVudFR5cGUgPSBudWxsOwotCQl0aGlzLmxpc3RIb2xkZXIucmVtb3ZlKDEpOwotCQl0aGlzLnZlcmlmeUV2ZW50KFJFTU9WRSwgMSwgbnVsbCk7Ci0KLQkJdGhpcy5ldmVudCA9IG51bGw7Ci0JCXRoaXMuZXZlbnRUeXBlID0gbnVsbDsKLQkJdGhpcy5saXN0SG9sZGVyLnJlbW92ZSgxKTsKLQkJdGhpcy52ZXJpZnlFdmVudChSRU1PVkUsIDEsICJqb28iKTsKLQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy5ldmVudFR5cGUgPSBudWxsOwotCQl0aGlzLmxpc3RIb2xkZXIuc2V0TGlzdCh0aGlzLmJ1aWxkTGlzdCgpKTsKLQkJdGhpcy52ZXJpZnlFdmVudChDSEFOR0UpOwotCi0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLmV2ZW50VHlwZSA9IG51bGw7Ci0JCXRoaXMubGlzdEhvbGRlci5hZGRBbGwoMCwgdGhpcy5idWlsZExpc3QoKSk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQoQUREKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRMaXN0KCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMuZXZlbnQuaXRlbXMoKSkpOwotCi0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLmV2ZW50VHlwZSA9IG51bGw7Ci0JCXRoaXMubGlzdEhvbGRlci5zZXQoMCwgImpvbyIpOwotCQl0aGlzLnZlcmlmeUV2ZW50KFJFUExBQ0UpOwotCQlhc3NlcnRGYWxzZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5ldmVudC5pdGVtcygpLCAiZm9vIikpOwotCQlhc3NlcnRUcnVlKENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmV2ZW50Lml0ZW1zKCksICJqb28iKSk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0Q2hhbmdlTGlzdGVuZXIgYnVpbGRMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBMaXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJU2ltcGxlTGlzdFZhbHVlTW9kZWxUZXN0cy50aGlzLmV2ZW50VHlwZSA9IEFERDsKLQkJCQlTaW1wbGVMaXN0VmFsdWVNb2RlbFRlc3RzLnRoaXMuZXZlbnQgPSBlOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJU2ltcGxlTGlzdFZhbHVlTW9kZWxUZXN0cy50aGlzLmV2ZW50VHlwZSA9IFJFTU9WRTsKLQkJCQlTaW1wbGVMaXN0VmFsdWVNb2RlbFRlc3RzLnRoaXMuZXZlbnQgPSBlOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJCVNpbXBsZUxpc3RWYWx1ZU1vZGVsVGVzdHMudGhpcy5ldmVudFR5cGUgPSBSRVBMQUNFOwotCQkJCVNpbXBsZUxpc3RWYWx1ZU1vZGVsVGVzdHMudGhpcy5ldmVudCA9IGU7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc01vdmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJU2ltcGxlTGlzdFZhbHVlTW9kZWxUZXN0cy50aGlzLmV2ZW50VHlwZSA9IE1PVkU7Ci0JCQkJU2ltcGxlTGlzdFZhbHVlTW9kZWxUZXN0cy50aGlzLmV2ZW50ID0gZTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGxpc3RDbGVhcmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJU2ltcGxlTGlzdFZhbHVlTW9kZWxUZXN0cy50aGlzLmV2ZW50VHlwZSA9IENMRUFSOwotCQkJCVNpbXBsZUxpc3RWYWx1ZU1vZGVsVGVzdHMudGhpcy5ldmVudCA9IGU7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBsaXN0Q2hhbmdlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJCVNpbXBsZUxpc3RWYWx1ZU1vZGVsVGVzdHMudGhpcy5ldmVudFR5cGUgPSBDSEFOR0U7Ci0JCQkJU2ltcGxlTGlzdFZhbHVlTW9kZWxUZXN0cy50aGlzLmV2ZW50ID0gZTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5RXZlbnQoU3RyaW5nIGUpIHsKLQkJYXNzZXJ0RXF1YWxzKGUsIHRoaXMuZXZlbnRUeXBlKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMubGlzdEhvbGRlciwgdGhpcy5ldmVudC5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5ldmVudC5nZXRMaXN0TmFtZSgpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5RXZlbnQoU3RyaW5nIGUsIGludCBpbmRleCwgT2JqZWN0IGl0ZW0pIHsKLQkJdGhpcy52ZXJpZnlFdmVudChlKTsKLQkJYXNzZXJ0RXF1YWxzKGluZGV4LCB0aGlzLmV2ZW50LmdldEluZGV4KCkpOwotCQlhc3NlcnRFcXVhbHMoaXRlbSwgdGhpcy5ldmVudC5pdGVtcygpLm5leHQoKSk7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1NpbXBsZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1NpbXBsZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDU3ZWQwZDguLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsOTMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5UZXN0VG9vbHM7Ci0KLXB1YmxpYyBjbGFzcyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gb2JqZWN0SG9sZGVyOwotCVByb3BlcnR5Q2hhbmdlRXZlbnQgZXZlbnQ7Ci0KLQkKLQlwdWJsaWMgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy5vYmplY3RIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4oImZvbyIpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VmFsdWUoKSB7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy5vYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNldFZhbHVlKCkgewotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZSgiYmFyIik7Ci0JCWFzc2VydEVxdWFscygiYmFyIiwgdGhpcy5vYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCXRoaXMub2JqZWN0SG9sZGVyLnNldFZhbHVlKG51bGwpOwotCQlhc3NlcnRFcXVhbHMobnVsbCwgdGhpcy5vYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCXRoaXMub2JqZWN0SG9sZGVyLnNldFZhbHVlKCJiYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXoiLCB0aGlzLm9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UHJvcGVydHlDaGFuZ2UxKCkgewotCQl0aGlzLm9iamVjdEhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRMaXN0ZW5lcigpKTsKLQkJdGhpcy52ZXJpZnlQcm9wZXJ0eUNoYW5nZSgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RQcm9wZXJ0eUNoYW5nZTIoKSB7Ci0JCXRoaXMub2JqZWN0SG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmJ1aWxkTGlzdGVuZXIoKSk7Ci0JCXRoaXMudmVyaWZ5UHJvcGVydHlDaGFuZ2UoKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UHJvcGVydHlDaGFuZ2UoKSB7Ci0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZSgiYmFyIik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQoImZvbyIsICJiYXIiKTsKLQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy5vYmplY3RIb2xkZXIuc2V0VmFsdWUobnVsbCk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQoImJhciIsIG51bGwpOwotCi0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZSgiYmF6Iik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQobnVsbCwgImJheiIpOwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZExpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMudGhpcy5ldmVudCA9IGU7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUV2ZW50KE9iamVjdCBvbGRWYWx1ZSwgT2JqZWN0IG5ld1ZhbHVlKSB7Ci0JCWFzc2VydEVxdWFscyh0aGlzLm9iamVjdEhvbGRlciwgdGhpcy5ldmVudC5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMuZXZlbnQuZ2V0UHJvcGVydHlOYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMob2xkVmFsdWUsIHRoaXMuZXZlbnQuZ2V0T2xkVmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscyhuZXdWYWx1ZSwgdGhpcy5ldmVudC5nZXROZXdWYWx1ZSgpKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODE2YmI1OS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1NvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxOTYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkNvbXBhcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLlRyZWVTZXQ7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkJhZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuSGFzaEJhZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5SZXZlcnNlQ29tcGFyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5MaXN0Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuTGlzdENoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIFNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyPFN0cmluZz4gYWRhcHRlcjsKLQlwcml2YXRlIFNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4gd3JhcHBlZENvbGxlY3Rpb25Ib2xkZXI7Ci0JcHJpdmF0ZSBDb2xsZWN0aW9uPFN0cmluZz4gd3JhcHBlZENvbGxlY3Rpb247Ci0KLQkKLQlwdWJsaWMgU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbiA9IG5ldyBIYXNoQmFnPFN0cmluZz4oKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlciA9IG5ldyBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+KHRoaXMud3JhcHBlZENvbGxlY3Rpb24pOwotCQl0aGlzLmFkYXB0ZXIgPSBuZXcgU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyPFN0cmluZz4odGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlcik7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlMaXN0KENvbGxlY3Rpb248U3RyaW5nPiBleHBlY3RlZCwgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBhY3R1YWwpIHsKLQkJdGhpcy52ZXJpZnlMaXN0KGV4cGVjdGVkLCBhY3R1YWwsIG51bGwpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlMaXN0KENvbGxlY3Rpb248U3RyaW5nPiBleHBlY3RlZCwgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBhY3R1YWwsIENvbXBhcmF0b3I8U3RyaW5nPiBjb21wYXJhdG9yKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiBzb3J0ZWRTZXQgPSBuZXcgVHJlZVNldDxTdHJpbmc+KGNvbXBhcmF0b3IpOwotCQlzb3J0ZWRTZXQuYWRkQWxsKGV4cGVjdGVkKTsKLQkJTGlzdDxTdHJpbmc+IGV4cGVjdGVkTGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPihzb3J0ZWRTZXQpOwotCQlMaXN0PFN0cmluZz4gYWN0dWFsTGlzdCA9IENvbGxlY3Rpb25Ub29scy5saXN0KGFjdHVhbC5pdGVyYXRvcigpKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkTGlzdCwgYWN0dWFsTGlzdCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZCgpIHsKLQkJdGhpcy5hZGFwdGVyLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgbmV3IFRlc3RMaXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsvKiBPSyAqL30KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgaXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZSkgey8qIE9LICovfQotCQl9KTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImZvbyIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiYmFyIik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJiYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIHRoaXMuYWRhcHRlci5zaXplKCkpOwotCQl0aGlzLnZlcmlmeUxpc3QodGhpcy53cmFwcGVkQ29sbGVjdGlvbiwgdGhpcy5hZGFwdGVyKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkSXRlbSgpIHsKLQkJTGlzdDxTdHJpbmc+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmFkYXB0ZXIpOwotCQlCYWc8U3RyaW5nPiBzeW5jaENvbGxlY3Rpb24gPSBuZXcgQ29vcmRpbmF0ZWRCYWc8U3RyaW5nPih0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImZvbyIpOwotCQlhc3NlcnRUcnVlKHRoaXMud3JhcHBlZENvbGxlY3Rpb24uY29udGFpbnMoImZvbyIpKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImJhciIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiYmF6Iik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJqb28iKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImphciIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiamF6Iik7Ci0JCWFzc2VydEVxdWFscyg2LCB0aGlzLndyYXBwZWRDb2xsZWN0aW9uLnNpemUoKSk7Ci0KLQkJdGhpcy52ZXJpZnlMaXN0KHRoaXMud3JhcHBlZENvbGxlY3Rpb24sIHRoaXMuYWRhcHRlcik7Ci0JCWFzc2VydEVxdWFscyh0aGlzLndyYXBwZWRDb2xsZWN0aW9uLCBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbihzeW5jaExpc3QuaXRlcmF0b3IoKSkpOwotCQlhc3NlcnRFcXVhbHModGhpcy53cmFwcGVkQ29sbGVjdGlvbiwgc3luY2hDb2xsZWN0aW9uKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlSXRlbSgpIHsKLQkJTGlzdDxTdHJpbmc+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmFkYXB0ZXIpOwotCQlCYWc8U3RyaW5nPiBzeW5jaENvbGxlY3Rpb24gPSBuZXcgQ29vcmRpbmF0ZWRCYWc8U3RyaW5nPih0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImZvbyIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiYmFyIik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJiYXoiKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImpvbyIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiamFyIik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJqYXoiKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5yZW1vdmUoImpheiIpOwotCQlhc3NlcnRGYWxzZSh0aGlzLndyYXBwZWRDb2xsZWN0aW9uLmNvbnRhaW5zKCJqYXoiKSk7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlKCJmb28iKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy53cmFwcGVkQ29sbGVjdGlvbi5jb250YWlucygiZm9vIikpOwotCQlhc3NlcnRFcXVhbHMoNCwgdGhpcy53cmFwcGVkQ29sbGVjdGlvbi5zaXplKCkpOwotCi0JCXRoaXMudmVyaWZ5TGlzdCh0aGlzLndyYXBwZWRDb2xsZWN0aW9uLCB0aGlzLmFkYXB0ZXIpOwotCQlhc3NlcnRFcXVhbHModGhpcy53cmFwcGVkQ29sbGVjdGlvbiwgQ29sbGVjdGlvblRvb2xzLmNvbGxlY3Rpb24oc3luY2hMaXN0Lml0ZXJhdG9yKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMud3JhcHBlZENvbGxlY3Rpb24sIHN5bmNoQ29sbGVjdGlvbik7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RTeW5jaCgpIHsKLQkJdGhpcy5hZGFwdGVyLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgbmV3IFRlc3RMaXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zQWRkZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsvKiBPSyAqL30KLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7LyogT0sgKi99Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsvKiBPSyAqL30KLQkJfSk7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJmb28iKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImJhciIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiYmF6Iik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJqb28iKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImphciIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiamF6Iik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlKCJqYXoiKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy53cmFwcGVkQ29sbGVjdGlvbi5jb250YWlucygiamF6IikpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLnJlbW92ZSgiZm9vIik7Ci0JCWFzc2VydEZhbHNlKHRoaXMud3JhcHBlZENvbGxlY3Rpb24uY29udGFpbnMoImZvbyIpKTsKLQkJYXNzZXJ0RXF1YWxzKDQsIHRoaXMud3JhcHBlZENvbGxlY3Rpb24uc2l6ZSgpKTsKLQotCQl0aGlzLnZlcmlmeUxpc3QodGhpcy53cmFwcGVkQ29sbGVjdGlvbiwgdGhpcy5hZGFwdGVyKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2V0Q29tcGFyYXRvcigpIHsKLQkJTGlzdDxTdHJpbmc+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPih0aGlzLmFkYXB0ZXIpOwotCQlCYWc8U3RyaW5nPiBzeW5jaENvbGxlY3Rpb24gPSBuZXcgQ29vcmRpbmF0ZWRCYWc8U3RyaW5nPih0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImZvbyIpOwotCQlhc3NlcnRUcnVlKHRoaXMud3JhcHBlZENvbGxlY3Rpb24uY29udGFpbnMoImZvbyIpKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImJhciIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiYmF6Iik7Ci0JCXRoaXMud3JhcHBlZENvbGxlY3Rpb25Ib2xkZXIuYWRkKCJqb28iKTsKLQkJdGhpcy53cmFwcGVkQ29sbGVjdGlvbkhvbGRlci5hZGQoImphciIpOwotCQl0aGlzLndyYXBwZWRDb2xsZWN0aW9uSG9sZGVyLmFkZCgiamF6Iik7Ci0JCWFzc2VydEVxdWFscyg2LCB0aGlzLndyYXBwZWRDb2xsZWN0aW9uLnNpemUoKSk7Ci0KLQkJdGhpcy52ZXJpZnlMaXN0KHRoaXMud3JhcHBlZENvbGxlY3Rpb24sIHRoaXMuYWRhcHRlcik7Ci0JCWFzc2VydEVxdWFscyh0aGlzLndyYXBwZWRDb2xsZWN0aW9uLCBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbihzeW5jaExpc3QuaXRlcmF0b3IoKSkpOwotCQlhc3NlcnRFcXVhbHModGhpcy53cmFwcGVkQ29sbGVjdGlvbiwgc3luY2hDb2xsZWN0aW9uKTsKLQotCQl0aGlzLmFkYXB0ZXIuc2V0Q29tcGFyYXRvcihuZXcgUmV2ZXJzZUNvbXBhcmF0b3I8U3RyaW5nPigpKTsKLQkJdGhpcy52ZXJpZnlMaXN0KHRoaXMud3JhcHBlZENvbGxlY3Rpb24sIHRoaXMuYWRhcHRlciwgbmV3IFJldmVyc2VDb21wYXJhdG9yPFN0cmluZz4oKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLndyYXBwZWRDb2xsZWN0aW9uLCBDb2xsZWN0aW9uVG9vbHMuY29sbGVjdGlvbihzeW5jaExpc3QuaXRlcmF0b3IoKSkpOwotCQlhc3NlcnRFcXVhbHModGhpcy53cmFwcGVkQ29sbGVjdGlvbiwgc3luY2hDb2xsZWN0aW9uKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgewotCQlhc3NlcnRGYWxzZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4odGhpcy5hZGFwdGVyKTsKLQkJYXNzZXJ0VHJ1ZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQl0aGlzLmFkYXB0ZXIucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCBzeW5jaExpc3QpOwotCQlhc3NlcnRGYWxzZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQl0aGlzLmFkYXB0ZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKHN5bmNoTGlzdCk7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmFkYXB0ZXIpLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJdGhpcy5hZGFwdGVyLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihzeW5jaExpc3QpOwotCQlhc3NlcnRGYWxzZSgoKEFic3RyYWN0TW9kZWwpIHRoaXMuYWRhcHRlcikuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCX0KLQotCWNsYXNzIFRlc3RMaXN0Q2hhbmdlTGlzdGVuZXIgaW1wbGVtZW50cyBMaXN0Q2hhbmdlTGlzdGVuZXIgewotCQlwdWJsaWMgdm9pZCBpdGVtc0FkZGVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQlmYWlsKCJ1bmV4cGVjdGVkIGV2ZW50Iik7Ci0JCX0KLQkJcHVibGljIHZvaWQgaXRlbXNSZW1vdmVkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQlmYWlsKCJ1bmV4cGVjdGVkIGV2ZW50Iik7Ci0JCX0KLQkJcHVibGljIHZvaWQgaXRlbXNSZXBsYWNlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGl0ZW1zTW92ZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJCWZhaWwoInVuZXhwZWN0ZWQgZXZlbnQiKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGxpc3RDaGFuZ2VkKExpc3RDaGFuZ2VFdmVudCBlKSB7Ci0JCQlmYWlsKCJ1bmV4cGVjdGVkIGV2ZW50Iik7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvU3RhdGljQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TdGF0aWNDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGRjYTMyZjkuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TdGF0aWNDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw2MSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5IYXNoQmFnOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlN0YXRpY0NvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIFN0YXRpY0NvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBDb2xsZWN0aW9uPFN0cmluZz4gQ09MTEVDVElPTiA9IGJ1aWxkQ29sbGVjdGlvbigpOwotCXByaXZhdGUgc3RhdGljIENvbGxlY3Rpb248U3RyaW5nPiBidWlsZENvbGxlY3Rpb24oKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiByZXN1bHQgPSBuZXcgSGFzaEJhZzxTdHJpbmc+KCk7Ci0JCXJlc3VsdC5hZGQoImZvbyIpOwotCQlyZXN1bHQuYWRkKCJiYXIiKTsKLQkJcmV0dXJuIHJlc3VsdDsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4gY29sbGVjdGlvbkhvbGRlcjsKLQotCi0JcHVibGljIFN0YXRpY0NvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy5jb2xsZWN0aW9uSG9sZGVyID0gdGhpcy5idWlsZENvbGxlY3Rpb25Ib2xkZXIoKTsKLQl9Ci0KLQlwcml2YXRlIENvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRDb2xsZWN0aW9uSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFN0YXRpY0NvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4oQ09MTEVDVElPTik7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVyYXRvcigpIHsKLQkJYXNzZXJ0RXF1YWxzKGJ1aWxkQ29sbGVjdGlvbigpLCBDb2xsZWN0aW9uVG9vbHMuYmFnKHRoaXMuY29sbGVjdGlvbkhvbGRlci5pdGVyYXRvcigpKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNpemUoKSB7Ci0JCWFzc2VydEVxdWFscyhidWlsZENvbGxlY3Rpb24oKS5zaXplKCksIHRoaXMuY29sbGVjdGlvbkhvbGRlci5zaXplKCkpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9TdGF0aWNMaXN0VmFsdWVNb2RlbFRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1N0YXRpY0xpc3RWYWx1ZU1vZGVsVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMGQ3Y2JjNi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1N0YXRpY0xpc3RWYWx1ZU1vZGVsVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDY0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU3RhdGljTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgU3RhdGljTGlzdFZhbHVlTW9kZWxUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIExpc3Q8U3RyaW5nPiBMSVNUID0gYnVpbGRMaXN0KCk7Ci0JcHJpdmF0ZSBzdGF0aWMgTGlzdDxTdHJpbmc+IGJ1aWxkTGlzdCgpIHsKLQkJTGlzdDxTdHJpbmc+IHJlc3VsdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQlyZXN1bHQuYWRkKCJmb28iKTsKLQkJcmVzdWx0LmFkZCgiYmFyIik7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGxpc3RIb2xkZXI7Ci0KLQotCXB1YmxpYyBTdGF0aWNMaXN0VmFsdWVNb2RlbFRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMubGlzdEhvbGRlciA9IG5ldyBTdGF0aWNMaXN0VmFsdWVNb2RlbDxTdHJpbmc+KExJU1QpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0R2V0KCkgewotCQlMaXN0PFN0cmluZz4gZXhwZWN0ZWQgPSBidWlsZExpc3QoKTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCB0aGlzLmxpc3RIb2xkZXIuc2l6ZSgpOyBpKyspIHsKLQkJCWFzc2VydEVxdWFscyhleHBlY3RlZC5nZXQoaSksIHRoaXMubGlzdEhvbGRlci5nZXQoaSkpOwotCQl9Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEl0ZXJhdG9yKCkgewotCQlhc3NlcnRFcXVhbHMoYnVpbGRMaXN0KCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMubGlzdEhvbGRlci5saXN0SXRlcmF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTaXplKCkgewotCQlhc3NlcnRFcXVhbHMoYnVpbGRMaXN0KCkuc2l6ZSgpLCB0aGlzLmxpc3RIb2xkZXIuc2l6ZSgpKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvU3RhdGljVmFsdWVNb2RlbFRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1N0YXRpY1ZhbHVlTW9kZWxUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzODBjZjE3Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvU3RhdGljVmFsdWVNb2RlbFRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw0NiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlN0YXRpY1Byb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgU3RhdGljVmFsdWVNb2RlbFRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gb2JqZWN0SG9sZGVyOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IE9CSkVDVF9IT0xERVIgPSBuZXcgU3RhdGljUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4oImZvbyIpOwotCi0JCi0JcHVibGljIFN0YXRpY1ZhbHVlTW9kZWxUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLm9iamVjdEhvbGRlciA9IE9CSkVDVF9IT0xERVI7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RWYWx1ZSgpIHsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCB0aGlzLm9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VG9TdHJpbmcoKSB7Ci0JCWFzc2VydFRydWUodGhpcy5vYmplY3RIb2xkZXIudG9TdHJpbmcoKS5pbmRleE9mKCJmb28iKSA+PSAwKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVHJhbnNmb3JtYXRpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9UcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDI4ZGZiNjcuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9UcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzMTcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb25zOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlRyYW5zZm9ybWVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVHJhbnNmb3JtYXRpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuTGlzdENoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkxpc3RDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5UZXN0VG9vbHM7Ci0KLXB1YmxpYyBjbGFzcyBUcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBsaXN0SG9sZGVyOwotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiB0cmFuc2Zvcm1lZExpc3RIb2xkZXI7Ci0JTGlzdENoYW5nZUV2ZW50IGV2ZW50OwotCVN0cmluZyBldmVudFR5cGU7Ci0KLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQUREID0gImFkZCI7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIFJFTU9WRSA9ICJyZW1vdmUiOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBSRVBMQUNFID0gInJlcGxhY2UiOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBNT1ZFID0gIm1vdmUiOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBDTEVBUiA9ICJjbGVhciI7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIENIQU5HRSA9ICJjaGFuZ2UiOwotCi0KLQlwdWJsaWMgVHJhbnNmb3JtYXRpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLmxpc3RIb2xkZXIgPSBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPih0aGlzLmJ1aWxkTGlzdCgpKTsKLQkJdGhpcy50cmFuc2Zvcm1lZExpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkVHJhbnNmb3JtZWRMaXN0SG9sZGVyKHRoaXMubGlzdEhvbGRlcik7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0PFN0cmluZz4gYnVpbGRMaXN0KCkgewotCQlMaXN0PFN0cmluZz4gcmVzdWx0ID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCXJlc3VsdC5hZGQoImZvbyIpOwotCQlyZXN1bHQuYWRkKCJiYXIiKTsKLQkJcmVzdWx0LmFkZCgiYmF6Iik7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0PFN0cmluZz4gYnVpbGRUcmFuc2Zvcm1lZExpc3QoKSB7Ci0JCXJldHVybiB0aGlzLnRyYW5zZm9ybSh0aGlzLmJ1aWxkTGlzdCgpKTsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8U3RyaW5nPiB0cmFuc2Zvcm0oTGlzdDxTdHJpbmc+IGxpc3QpIHsKLQkJTGlzdDxTdHJpbmc+IHJlc3VsdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPihsaXN0LnNpemUoKSk7Ci0JCWZvciAoU3RyaW5nIHN0cmluZyA6IGxpc3QpIHsKLQkJCWlmIChzdHJpbmcgPT0gbnVsbCkgewotCQkJCXJlc3VsdC5hZGQobnVsbCk7Ci0JCQl9IGVsc2UgewotCQkJCXJlc3VsdC5hZGQoc3RyaW5nLnRvVXBwZXJDYXNlKCkpOwotCQkJfQotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0PFN0cmluZz4gYnVpbGRBZGRMaXN0KCkgewotCQlMaXN0PFN0cmluZz4gcmVzdWx0ID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCXJlc3VsdC5hZGQoImpvbyIpOwotCQlyZXN1bHQuYWRkKCJqYXIiKTsKLQkJcmVzdWx0LmFkZCgiamF6Iik7Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0PFN0cmluZz4gYnVpbGRUcmFuc2Zvcm1lZEFkZExpc3QoKSB7Ci0JCXJldHVybiB0aGlzLnRyYW5zZm9ybSh0aGlzLmJ1aWxkQWRkTGlzdCgpKTsKLQl9Ci0KLS8vCXByaXZhdGUgTGlzdDxTdHJpbmc+IGJ1aWxkUmVtb3ZlTGlzdCgpIHsKLS8vCQlMaXN0PFN0cmluZz4gcmVzdWx0ID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0vLwkJcmVzdWx0LmFkZCgiZm9vIik7Ci0vLwkJcmVzdWx0LmFkZCgiYmFyIik7Ci0vLwkJcmV0dXJuIHJlc3VsdDsKLS8vCX0KLS8vCi0vLwlwcml2YXRlIExpc3Q8U3RyaW5nPiBidWlsZFRyYW5zZm9ybWVkUmVtb3ZlTGlzdCgpIHsKLS8vCQlyZXR1cm4gdGhpcy50cmFuc2Zvcm0odGhpcy5idWlsZFJlbW92ZUxpc3QoKSk7Ci0vLwl9Ci0vLwotCUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRUcmFuc2Zvcm1lZExpc3RIb2xkZXIoTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBsdm0pIHsKLQkJcmV0dXJuIG5ldyBUcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlcjxTdHJpbmcsIFN0cmluZz4obHZtKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtSXRlbShTdHJpbmcgcykgewotCQkJCXJldHVybiAocyA9PSBudWxsKSA/IG51bGwgOiBzLnRvVXBwZXJDYXNlKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJdGVyYXRvcigpIHsKLQkJdGhpcy50cmFuc2Zvcm1lZExpc3RIb2xkZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmJ1aWxkTGlzdGVuZXIoKSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmJ1aWxkVHJhbnNmb3JtZWRMaXN0KCksIENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMudHJhbnNmb3JtZWRMaXN0SG9sZGVyLml0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3RhbGVWYWx1ZXMoKSB7Ci0JCUxpc3RDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lciA9IHRoaXMuYnVpbGRMaXN0ZW5lcigpOwotCQl0aGlzLnRyYW5zZm9ybWVkTGlzdEhvbGRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIGxpc3RlbmVyKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRUcmFuc2Zvcm1lZExpc3QoKSwgQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy50cmFuc2Zvcm1lZExpc3RIb2xkZXIuaXRlcmF0b3IoKSkpOwotCi0JCXRoaXMudHJhbnNmb3JtZWRMaXN0SG9sZGVyLnJlbW92ZUxpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgbGlzdGVuZXIpOwotCQlhc3NlcnRFcXVhbHMoQ29sbGVjdGlvbnMuRU1QVFlfTElTVCwgQ29sbGVjdGlvblRvb2xzLmxpc3QodGhpcy50cmFuc2Zvcm1lZExpc3RIb2xkZXIuaXRlcmF0b3IoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTaXplKCkgewotCQl0aGlzLnRyYW5zZm9ybWVkTGlzdEhvbGRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMuYnVpbGRMaXN0ZW5lcigpKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYnVpbGRUcmFuc2Zvcm1lZExpc3QoKS5zaXplKCksIENvbGxlY3Rpb25Ub29scy5zaXplKHRoaXMudHJhbnNmb3JtZWRMaXN0SG9sZGVyLml0ZXJhdG9yKCkpKTsKLQl9Ci0KLQlwcml2YXRlIGJvb2xlYW4gdHJhbnNmb3JtZWRMaXN0Q29udGFpbnMoT2JqZWN0IGl0ZW0pIHsKLQkJcmV0dXJuIENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLnRyYW5zZm9ybWVkTGlzdEhvbGRlci5pdGVyYXRvcigpLCBpdGVtKTsKLQl9Ci0KLQlwcml2YXRlIGJvb2xlYW4gdHJhbnNmb3JtZWRMaXN0Q29udGFpbnNBbGwoQ29sbGVjdGlvbjxTdHJpbmc+IGl0ZW1zKSB7Ci0JCXJldHVybiBDb2xsZWN0aW9uVG9vbHMuY29udGFpbnNBbGwodGhpcy50cmFuc2Zvcm1lZExpc3RIb2xkZXIuaXRlcmF0b3IoKSwgaXRlbXMpOwotCX0KLQotCXByaXZhdGUgYm9vbGVhbiB0cmFuc2Zvcm1lZExpc3RDb250YWluc0FueShDb2xsZWN0aW9uPFN0cmluZz4gaXRlbXMpIHsKLQkJTGlzdDxTdHJpbmc+IHRyYW5zZm9ybWVkTGlzdCA9IENvbGxlY3Rpb25Ub29scy5saXN0KHRoaXMudHJhbnNmb3JtZWRMaXN0SG9sZGVyLml0ZXJhdG9yKCkpOwotCQlmb3IgKEl0ZXJhdG9yPFN0cmluZz4gc3RyZWFtID0gaXRlbXMuaXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQlpZiAodHJhbnNmb3JtZWRMaXN0LmNvbnRhaW5zKHN0cmVhbS5uZXh0KCkpKSB7Ci0JCQkJcmV0dXJuIHRydWU7Ci0JCQl9Ci0JCX0KLQkJcmV0dXJuIGZhbHNlOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGQoKSB7Ci0JCXRoaXMudHJhbnNmb3JtZWRMaXN0SG9sZGVyLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5idWlsZExpc3RlbmVyKCkpOwotCi0JCWFzc2VydEZhbHNlKHRoaXMudHJhbnNmb3JtZWRMaXN0Q29udGFpbnMoIkpPTyIpKTsKLQkJdGhpcy5saXN0SG9sZGVyLmFkZCgyLCAiam9vIik7Ci0JCWFzc2VydFRydWUodGhpcy50cmFuc2Zvcm1lZExpc3RDb250YWlucygiSk9PIikpOwotCi0JCWFzc2VydEZhbHNlKHRoaXMudHJhbnNmb3JtZWRMaXN0Q29udGFpbnMobnVsbCkpOwotCQl0aGlzLmxpc3RIb2xkZXIuYWRkKDAsIG51bGwpOwotCQlhc3NlcnRUcnVlKHRoaXMudHJhbnNmb3JtZWRMaXN0Q29udGFpbnMobnVsbCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRBbGwoKSB7Ci0JCXRoaXMudHJhbnNmb3JtZWRMaXN0SG9sZGVyLmFkZExpc3RDaGFuZ2VMaXN0ZW5lcihMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5idWlsZExpc3RlbmVyKCkpOwotCi0JCWFzc2VydEZhbHNlKHRoaXMudHJhbnNmb3JtZWRMaXN0Q29udGFpbnNBbnkodGhpcy5idWlsZFRyYW5zZm9ybWVkQWRkTGlzdCgpKSk7Ci0JCXRoaXMubGlzdEhvbGRlci5hZGRBbGwoMiwgdGhpcy5idWlsZEFkZExpc3QoKSk7Ci0JCWFzc2VydFRydWUodGhpcy50cmFuc2Zvcm1lZExpc3RDb250YWluc0FsbCh0aGlzLmJ1aWxkVHJhbnNmb3JtZWRBZGRMaXN0KCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlKCkgewotCQl0aGlzLnRyYW5zZm9ybWVkTGlzdEhvbGRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIHRoaXMuYnVpbGRMaXN0ZW5lcigpKTsKLQotCQlhc3NlcnRUcnVlKHRoaXMudHJhbnNmb3JtZWRMaXN0Q29udGFpbnMoIkJBUiIpKTsKLQkJdGhpcy5saXN0SG9sZGVyLnJlbW92ZSh0aGlzLmJ1aWxkTGlzdCgpLmluZGV4T2YoImJhciIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy50cmFuc2Zvcm1lZExpc3RDb250YWlucygiQkFSIikpOwotCi0JCXRoaXMubGlzdEhvbGRlci5hZGQoMSwgbnVsbCk7Ci0JCWFzc2VydFRydWUodGhpcy50cmFuc2Zvcm1lZExpc3RDb250YWlucyhudWxsKSk7Ci0JCXRoaXMubGlzdEhvbGRlci5yZW1vdmUoMSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMudHJhbnNmb3JtZWRMaXN0Q29udGFpbnMobnVsbCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0Q2hhbmdlR2VuZXJpYygpIHsKLQkJdGhpcy50cmFuc2Zvcm1lZExpc3RIb2xkZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRMaXN0ZW5lcigpKTsKLQkJdGhpcy52ZXJpZnlMaXN0Q2hhbmdlKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RDaGFuZ2VOYW1lZCgpIHsKLQkJdGhpcy50cmFuc2Zvcm1lZExpc3RIb2xkZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCB0aGlzLmJ1aWxkTGlzdGVuZXIoKSk7Ci0JCXRoaXMudmVyaWZ5TGlzdENoYW5nZSgpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlMaXN0Q2hhbmdlKCkgewotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy5ldmVudFR5cGUgPSBudWxsOwotCQl0aGlzLmxpc3RIb2xkZXIuYWRkKDEsICJqb28iKTsKLQkJdGhpcy52ZXJpZnlFdmVudChBREQsIDEsICJKT08iKTsKLQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy5ldmVudFR5cGUgPSBudWxsOwotCQl0aGlzLmxpc3RIb2xkZXIuYWRkKDEsIG51bGwpOwotCQl0aGlzLnZlcmlmeUV2ZW50KEFERCwgMSwgbnVsbCk7Ci0KLQkJdGhpcy5ldmVudCA9IG51bGw7Ci0JCXRoaXMuZXZlbnRUeXBlID0gbnVsbDsKLQkJdGhpcy5saXN0SG9sZGVyLnJlbW92ZSgxKTsKLQkJdGhpcy52ZXJpZnlFdmVudChSRU1PVkUsIDEsIG51bGwpOwotCi0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLmV2ZW50VHlwZSA9IG51bGw7Ci0JCXRoaXMubGlzdEhvbGRlci5yZW1vdmUoMSk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQoUkVNT1ZFLCAxLCAiSk9PIik7Ci0KLQkJdGhpcy5ldmVudCA9IG51bGw7Ci0JCXRoaXMuZXZlbnRUeXBlID0gbnVsbDsKLQkJdGhpcy5saXN0SG9sZGVyLmFkZEFsbCgwLCB0aGlzLmJ1aWxkTGlzdCgpKTsKLQkJdGhpcy52ZXJpZnlFdmVudChBREQpOwotCQlhc3NlcnRFcXVhbHModGhpcy5idWlsZFRyYW5zZm9ybWVkTGlzdCgpLCBDb2xsZWN0aW9uVG9vbHMubGlzdCh0aGlzLmV2ZW50Lml0ZW1zKCkpKTsKLQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy5ldmVudFR5cGUgPSBudWxsOwotCQl0aGlzLmxpc3RIb2xkZXIuc2V0KDAsICJqb28iKTsKLQkJdGhpcy52ZXJpZnlFdmVudChSRVBMQUNFKTsKLQkJYXNzZXJ0RmFsc2UoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuZXZlbnQuaXRlbXMoKSwgIkZPTyIpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5ldmVudC5pdGVtcygpLCAiSk9PIikpOwotCX0KLQotCXByaXZhdGUgTGlzdENoYW5nZUxpc3RlbmVyIGJ1aWxkTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgTGlzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJCVRyYW5zZm9ybWF0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudFR5cGUgPSBBREQ7Ci0JCQkJVHJhbnNmb3JtYXRpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy50aGlzLmV2ZW50ID0gZTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVtb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJCVRyYW5zZm9ybWF0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudFR5cGUgPSBSRU1PVkU7Ci0JCQkJVHJhbnNmb3JtYXRpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXJUZXN0cy50aGlzLmV2ZW50ID0gZTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGl0ZW1zUmVwbGFjZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJCQlUcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLnRoaXMuZXZlbnRUeXBlID0gUkVQTEFDRTsKLQkJCQlUcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLnRoaXMuZXZlbnQgPSBlOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNNb3ZlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJCVRyYW5zZm9ybWF0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudFR5cGUgPSBNT1ZFOwotCQkJCVRyYW5zZm9ybWF0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudCA9IGU7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBsaXN0Q2xlYXJlZChMaXN0Q2hhbmdlRXZlbnQgZSkgewotCQkJCVRyYW5zZm9ybWF0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudFR5cGUgPSBDTEVBUjsKLQkJCQlUcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLnRoaXMuZXZlbnQgPSBlOwotCQkJfQotCQkJcHVibGljIHZvaWQgbGlzdENoYW5nZWQoTGlzdENoYW5nZUV2ZW50IGUpIHsKLQkJCQlUcmFuc2Zvcm1hdGlvbkxpc3RWYWx1ZU1vZGVsQWRhcHRlclRlc3RzLnRoaXMuZXZlbnRUeXBlID0gQ0hBTkdFOwotCQkJCVRyYW5zZm9ybWF0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudCA9IGU7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUV2ZW50KFN0cmluZyB0eXBlKSB7Ci0JCWFzc2VydEVxdWFscyh0eXBlLCB0aGlzLmV2ZW50VHlwZSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnRyYW5zZm9ybWVkTGlzdEhvbGRlciwgdGhpcy5ldmVudC5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUywgdGhpcy5ldmVudC5nZXRMaXN0TmFtZSgpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5RXZlbnQoU3RyaW5nIHR5cGUsIGludCBpbmRleCwgT2JqZWN0IGl0ZW0pIHsKLQkJdGhpcy52ZXJpZnlFdmVudCh0eXBlKTsKLQkJYXNzZXJ0RXF1YWxzKGluZGV4LCB0aGlzLmV2ZW50LmdldEluZGV4KCkpOwotCQlhc3NlcnRFcXVhbHMoaXRlbSwgdGhpcy5ldmVudC5pdGVtcygpLm5leHQoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc0xpc3RlbmVycygpIHsKLQkJLyoKLQkJICogYWRkaW5nIGxpc3RlbmVycyB0byB0aGUgdHJhbnNmb3JtZWQgbGlzdCB3aWxsIGNhdXNlIGxpc3RlbmVycwotCQkgKiB0byBiZSBhZGRlZCB0byB0aGUgd3JhcHBlZCBsaXN0OwotCQkgKiBsaWtld2lzZSwgcmVtb3ZpbmcgbGlzdGVuZXJzIGZyb20gdGhlIHRyYW5zZm9ybWVkIGxpc3Qgd2lsbAotCQkgKiBjYXVzZSBsaXN0ZW5lcnMgdG8gYmUgcmVtb3ZlZCBmcm9tIHRoZSB3cmFwcGVkIGxpc3QKLQkJICovCi0JCWFzc2VydEZhbHNlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5saXN0SG9sZGVyKS5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0KLQkJTGlzdENoYW5nZUxpc3RlbmVyIGxpc3RlbmVyID0gdGhpcy5idWlsZExpc3RlbmVyKCk7Ci0KLQkJdGhpcy50cmFuc2Zvcm1lZExpc3RIb2xkZXIuYWRkTGlzdENoYW5nZUxpc3RlbmVyKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTLCBsaXN0ZW5lcik7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmxpc3RIb2xkZXIpLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQotCQl0aGlzLnRyYW5zZm9ybWVkTGlzdEhvbGRlci5yZW1vdmVMaXN0Q2hhbmdlTGlzdGVuZXIoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMsIGxpc3RlbmVyKTsKLQkJYXNzZXJ0RmFsc2UoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmxpc3RIb2xkZXIpLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQotCQl0aGlzLnRyYW5zZm9ybWVkTGlzdEhvbGRlci5hZGRMaXN0Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5saXN0SG9sZGVyKS5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0KLQkJdGhpcy50cmFuc2Zvcm1lZExpc3RIb2xkZXIucmVtb3ZlTGlzdENoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJYXNzZXJ0RmFsc2UoKChBYnN0cmFjdE1vZGVsKSB0aGlzLmxpc3RIb2xkZXIpLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQl9Ci0KLQotCS8qKgotCSAqIGV4ZWN1dGUgdGhlIHNhbWUgc2V0IG9mIHRlc3RzIGFnYWluLCBidXQgYnkgcGFzc2luZyBhIFRyYW5zZm9ybWVyIHRvIHRoZSBhZGFwdGVyCi0JICogKGFzIG9wcG9zZWQgdG8gb3ZlcnJpZGluZyAjdHJhbnNmb3JtSXRlbShPYmplY3QpKQotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2xhc3MgVHJhbnNmb3JtZXJUZXN0cyBleHRlbmRzIFRyYW5zZm9ybWF0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyVGVzdHMgewotCQlwdWJsaWMgVHJhbnNmb3JtZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQkJc3VwZXIobmFtZSk7Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRUcmFuc2Zvcm1lZExpc3RIb2xkZXIoTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBsdm0pIHsKLQkJCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25MaXN0VmFsdWVNb2RlbEFkYXB0ZXI8U3RyaW5nLCBTdHJpbmc+KGx2bSwgdGhpcy5idWlsZFRyYW5zZm9ybWVyKCkpOwotCQl9Ci0JCXByaXZhdGUgVHJhbnNmb3JtZXI8U3RyaW5nLCBTdHJpbmc+IGJ1aWxkVHJhbnNmb3JtZXIoKSB7Ci0JCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWVyPFN0cmluZywgU3RyaW5nPigpIHsKLQkJCQlwdWJsaWMgU3RyaW5nIHRyYW5zZm9ybShTdHJpbmcgcykgewotCQkJCQlyZXR1cm4gKHMgPT0gbnVsbCkgPyBudWxsIDogcy50b1VwcGVyQ2FzZSgpOwotCQkJCX0KLQkJCX07Ci0JCX0KLQl9Ci0JCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1RyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhNzMyMjAyLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVHJhbnNmb3JtYXRpb25Qcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTg1ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQmlkaVRyYW5zZm9ybWVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5UZXN0VG9vbHM7Ci0KLUBTdXBwcmVzc1dhcm5pbmdzKCJubHMiKQotcHVibGljIGNsYXNzIFRyYW5zZm9ybWF0aW9uUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IG9iamVjdEhvbGRlcjsKLQlQcm9wZXJ0eUNoYW5nZUV2ZW50IGV2ZW50OwotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IHRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyOwotCVByb3BlcnR5Q2hhbmdlRXZlbnQgdHJhbnNmb3JtYXRpb25FdmVudDsKLQotCXB1YmxpYyBUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbFRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMub2JqZWN0SG9sZGVyID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+KCJmb28iKTsKLQkJdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlciA9IG5ldyBUcmFuc2Zvcm1hdGlvbldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZywgU3RyaW5nPih0aGlzLm9iamVjdEhvbGRlciwgdGhpcy5idWlsZFRyYW5zZm9ybWVyKCkpOwotCX0KLQotCXByaXZhdGUgQmlkaVRyYW5zZm9ybWVyPFN0cmluZywgU3RyaW5nPiBidWlsZFRyYW5zZm9ybWVyKCkgewotCQlyZXR1cm4gbmV3IEJpZGlUcmFuc2Zvcm1lcjxTdHJpbmcsIFN0cmluZz4oKSB7Ci0JCQlwdWJsaWMgU3RyaW5nIHRyYW5zZm9ybShTdHJpbmcgcykgewotCQkJCXJldHVybiAocyA9PSBudWxsKSA/IG51bGwgOiBzLnRvVXBwZXJDYXNlKCk7Ci0JCQl9Ci0JCQlwdWJsaWMgU3RyaW5nIHJldmVyc2VUcmFuc2Zvcm0oU3RyaW5nIHMpIHsKLQkJCQlyZXR1cm4gKHMgPT0gbnVsbCkgPyBudWxsIDogcy50b0xvd2VyQ2FzZSgpOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VmFsdWUoKSB7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy5vYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygiRk9PIiwgdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZSgiYmFyIik7Ci0JCWFzc2VydEVxdWFscygiYmFyIiwgdGhpcy5vYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygiQkFSIiwgdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZSgiYmF6Iik7Ci0JCWFzc2VydEVxdWFscygiYmF6IiwgdGhpcy5vYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygiQkFaIiwgdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZShudWxsKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLm9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCi0JCXRoaXMub2JqZWN0SG9sZGVyLnNldFZhbHVlKCJmb28iKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCB0aGlzLm9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJGT08iLCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRWYWx1ZSgpIHsKLQkJdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5zZXRWYWx1ZSgiQkFSIik7Ci0JCWFzc2VydEVxdWFscygiYmFyIiwgdGhpcy5vYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscygiQkFSIiwgdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLnNldFZhbHVlKCJGb28iKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCB0aGlzLm9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJGT08iLCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCi0JCXRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuc2V0VmFsdWUobnVsbCk7Ci0JCWFzc2VydE51bGwodGhpcy5vYmplY3RIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydE51bGwodGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLnNldFZhbHVlKCJiYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXoiLCB0aGlzLm9iamVjdEhvbGRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKCJCQVoiLCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMYXp5TGlzdGVuaW5nKCkgewotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5vYmplY3RIb2xkZXIpLmhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSB0aGlzLmJ1aWxkVHJhbnNmb3JtYXRpb25MaXN0ZW5lcigpOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5vYmplY3RIb2xkZXIpLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5vYmplY3RIb2xkZXIpLmhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0KLQkJdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgbGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKCgoQWJzdHJhY3RNb2RlbCkgdGhpcy5vYmplY3RIb2xkZXIpLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCBsaXN0ZW5lcik7Ci0JCWFzc2VydFRydWUoKChBYnN0cmFjdE1vZGVsKSB0aGlzLm9iamVjdEhvbGRlcikuaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UHJvcGVydHlDaGFuZ2UxKCkgewotCQl0aGlzLm9iamVjdEhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRMaXN0ZW5lcigpKTsKLQkJdGhpcy50cmFuc2Zvcm1hdGlvbk9iamVjdEhvbGRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRUcmFuc2Zvcm1hdGlvbkxpc3RlbmVyKCkpOwotCQl0aGlzLnZlcmlmeVByb3BlcnR5Q2hhbmdlcygpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RQcm9wZXJ0eUNoYW5nZTIoKSB7Ci0JCXRoaXMub2JqZWN0SG9sZGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmJ1aWxkTGlzdGVuZXIoKSk7Ci0JCXRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMuYnVpbGRUcmFuc2Zvcm1hdGlvbkxpc3RlbmVyKCkpOwotCQl0aGlzLnZlcmlmeVByb3BlcnR5Q2hhbmdlcygpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlQcm9wZXJ0eUNoYW5nZXMoKSB7Ci0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uRXZlbnQgPSBudWxsOwotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZSgiYmFyIik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5ldmVudCwgdGhpcy5vYmplY3RIb2xkZXIsICJmb28iLCAiYmFyIik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy50cmFuc2Zvcm1hdGlvbkV2ZW50LCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLCAiRk9PIiwgIkJBUiIpOwotCi0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uRXZlbnQgPSBudWxsOwotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZSgiYmF6Iik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5ldmVudCwgdGhpcy5vYmplY3RIb2xkZXIsICJiYXIiLCAiYmF6Iik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy50cmFuc2Zvcm1hdGlvbkV2ZW50LCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLCAiQkFSIiwgIkJBWiIpOwotCi0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uRXZlbnQgPSBudWxsOwotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZSgiRm9vIik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5ldmVudCwgdGhpcy5vYmplY3RIb2xkZXIsICJiYXoiLCAiRm9vIik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy50cmFuc2Zvcm1hdGlvbkV2ZW50LCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLCAiQkFaIiwgIkZPTyIpOwotCi0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLnRyYW5zZm9ybWF0aW9uRXZlbnQgPSBudWxsOwotCQl0aGlzLm9iamVjdEhvbGRlci5zZXRWYWx1ZSgiRk9PIik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5ldmVudCwgdGhpcy5vYmplY3RIb2xkZXIsICJGb28iLCAiRk9PIik7Ci0JCWFzc2VydE51bGwodGhpcy50cmFuc2Zvcm1hdGlvbkV2ZW50KTsKLQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy50cmFuc2Zvcm1hdGlvbkV2ZW50ID0gbnVsbDsKLQkJdGhpcy5vYmplY3RIb2xkZXIuc2V0VmFsdWUobnVsbCk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5ldmVudCwgdGhpcy5vYmplY3RIb2xkZXIsICJGT08iLCBudWxsKTsKLQkJdGhpcy52ZXJpZnlFdmVudCh0aGlzLnRyYW5zZm9ybWF0aW9uRXZlbnQsIHRoaXMudHJhbnNmb3JtYXRpb25PYmplY3RIb2xkZXIsICJGT08iLCBudWxsKTsKLQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy50cmFuc2Zvcm1hdGlvbkV2ZW50ID0gbnVsbDsKLQkJdGhpcy5vYmplY3RIb2xkZXIuc2V0VmFsdWUoImJhciIpOwotCQl0aGlzLnZlcmlmeUV2ZW50KHRoaXMuZXZlbnQsIHRoaXMub2JqZWN0SG9sZGVyLCBudWxsLCAiYmFyIik7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy50cmFuc2Zvcm1hdGlvbkV2ZW50LCB0aGlzLnRyYW5zZm9ybWF0aW9uT2JqZWN0SG9sZGVyLCBudWxsLCAiQkFSIik7Ci0JfQotCi0JcHJpdmF0ZSBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJCQlUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLnRoaXMuZXZlbnQgPSBlOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZFRyYW5zZm9ybWF0aW9uTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJCQlUcmFuc2Zvcm1hdGlvblByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLnRoaXMudHJhbnNmb3JtYXRpb25FdmVudCA9IGU7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUV2ZW50KFByb3BlcnR5Q2hhbmdlRXZlbnQgZSwgT2JqZWN0IHNvdXJjZSwgT2JqZWN0IG9sZFZhbHVlLCBPYmplY3QgbmV3VmFsdWUpIHsKLQkJYXNzZXJ0RXF1YWxzKHNvdXJjZSwgZS5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIGUuZ2V0UHJvcGVydHlOYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMob2xkVmFsdWUsIGUuZ2V0T2xkVmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscyhuZXdWYWx1ZSwgZS5nZXROZXdWYWx1ZSgpKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVHJlZUFzcGVjdEFkYXB0ZXJUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9UcmVlQXNwZWN0QWRhcHRlclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGEwNGQ5MTIuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9UcmVlQXNwZWN0QWRhcHRlclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNTMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkhhc2hCYWc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkNoYWluSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlJlYWRPbmx5SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlRyYW5zZm9ybWF0aW9uSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlRyZWVJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5UcmVlQXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5UcmVlQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuVHJlZUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5UcmVlVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5UZXN0VG9vbHM7Ci0KLXB1YmxpYyBjbGFzcyBUcmVlQXNwZWN0QWRhcHRlclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgVGVzdFN1YmplY3Qgc3ViamVjdDE7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUZXN0U3ViamVjdD4gc3ViamVjdEhvbGRlcjE7Ci0JcHJpdmF0ZSBUcmVlQXNwZWN0QWRhcHRlcjxUZXN0U3ViamVjdCwgVGVzdE5vZGVbXT4gYWExOwotCXByaXZhdGUgVHJlZUNoYW5nZUV2ZW50IGV2ZW50MTsKLQlwcml2YXRlIFRyZWVDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcjE7Ci0KLQlwcml2YXRlIFRlc3RTdWJqZWN0IHN1YmplY3QyOwotCi0JCi0JcHVibGljIFRyZWVBc3BlY3RBZGFwdGVyVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy5zdWJqZWN0MSA9IG5ldyBUZXN0U3ViamVjdCgpOwotCQlUZXN0Tm9kZSByb290LCBub2RlOwotCi0JCXJvb3QgPSB0aGlzLnN1YmplY3QxLmdldFJvb3ROYW1lTm9kZSgpOwotCQlub2RlID0gdGhpcy5zdWJqZWN0MS5hZGROYW1lKHJvb3QsICJuYW1lIDEuMSIpOwotCQl0aGlzLnN1YmplY3QxLmFkZE5hbWUobm9kZSwgIm5hbWUgMS4xLjEiKTsKLQkJdGhpcy5zdWJqZWN0MS5hZGROYW1lKG5vZGUsICJuYW1lIDEuMS4yIik7Ci0JCW5vZGUgPSB0aGlzLnN1YmplY3QxLmFkZE5hbWUocm9vdCwgIm5hbWUgMS4yIik7Ci0JCXRoaXMuc3ViamVjdDEuYWRkTmFtZShub2RlLCAibmFtZSAxLjIuMSIpOwotCQlub2RlID0gdGhpcy5zdWJqZWN0MS5hZGROYW1lKHJvb3QsICJuYW1lIDEuMyIpOwotCi0JCXJvb3QgPSB0aGlzLnN1YmplY3QxLmdldFJvb3REZXNjcmlwdGlvbk5vZGUoKTsKLQkJbm9kZSA9IHRoaXMuc3ViamVjdDEuYWRkRGVzY3JpcHRpb24ocm9vdCwgImRlc2NyaXB0aW9uIDEuMSIpOwotCQl0aGlzLnN1YmplY3QxLmFkZERlc2NyaXB0aW9uKG5vZGUsICJkZXNjcmlwdGlvbiAxLjEuMSIpOwotCQl0aGlzLnN1YmplY3QxLmFkZERlc2NyaXB0aW9uKG5vZGUsICJkZXNjcmlwdGlvbiAxLjEuMiIpOwotCQlub2RlID0gdGhpcy5zdWJqZWN0MS5hZGREZXNjcmlwdGlvbihyb290LCAiZGVzY3JpcHRpb24gMS4yIik7Ci0JCXRoaXMuc3ViamVjdDEuYWRkRGVzY3JpcHRpb24obm9kZSwgImRlc2NyaXB0aW9uIDEuMi4xIik7Ci0JCW5vZGUgPSB0aGlzLnN1YmplY3QxLmFkZERlc2NyaXB0aW9uKHJvb3QsICJkZXNjcmlwdGlvbiAxLjMiKTsKLQotCQl0aGlzLnN1YmplY3RIb2xkZXIxID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxUZXN0U3ViamVjdD4odGhpcy5zdWJqZWN0MSk7Ci0JCXRoaXMuYWExID0gdGhpcy5idWlsZEFzcGVjdEFkYXB0ZXIodGhpcy5zdWJqZWN0SG9sZGVyMSk7Ci0JCXRoaXMubGlzdGVuZXIxID0gdGhpcy5idWlsZFZhbHVlQ2hhbmdlTGlzdGVuZXIxKCk7Ci0JCXRoaXMuYWExLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcihUcmVlVmFsdWVNb2RlbC5OT0RFUywgdGhpcy5saXN0ZW5lcjEpOwotCQl0aGlzLmV2ZW50MSA9IG51bGw7Ci0KLQkJdGhpcy5zdWJqZWN0MiA9IG5ldyBUZXN0U3ViamVjdCgpOwotCi0JCXJvb3QgPSB0aGlzLnN1YmplY3QyLmdldFJvb3ROYW1lTm9kZSgpOwotCQlub2RlID0gdGhpcy5zdWJqZWN0Mi5hZGROYW1lKHJvb3QsICJuYW1lIDIuMSIpOwotCQl0aGlzLnN1YmplY3QyLmFkZE5hbWUobm9kZSwgIm5hbWUgMi4xLjEiKTsKLQkJdGhpcy5zdWJqZWN0Mi5hZGROYW1lKG5vZGUsICJuYW1lIDIuMS4yIik7Ci0JCW5vZGUgPSB0aGlzLnN1YmplY3QyLmFkZE5hbWUocm9vdCwgIm5hbWUgMi4yIik7Ci0JCXRoaXMuc3ViamVjdDIuYWRkTmFtZShub2RlLCAibmFtZSAyLjIuMSIpOwotCQlub2RlID0gdGhpcy5zdWJqZWN0Mi5hZGROYW1lKHJvb3QsICJuYW1lIDIuMyIpOwotCi0JCXJvb3QgPSB0aGlzLnN1YmplY3QyLmdldFJvb3REZXNjcmlwdGlvbk5vZGUoKTsKLQkJbm9kZSA9IHRoaXMuc3ViamVjdDIuYWRkRGVzY3JpcHRpb24ocm9vdCwgImRlc2NyaXB0aW9uIDIuMSIpOwotCQl0aGlzLnN1YmplY3QyLmFkZERlc2NyaXB0aW9uKG5vZGUsICJkZXNjcmlwdGlvbiAyLjEuMSIpOwotCQl0aGlzLnN1YmplY3QyLmFkZERlc2NyaXB0aW9uKG5vZGUsICJkZXNjcmlwdGlvbiAyLjEuMiIpOwotCQlub2RlID0gdGhpcy5zdWJqZWN0Mi5hZGREZXNjcmlwdGlvbihyb290LCAiZGVzY3JpcHRpb24gMi4yIik7Ci0JCXRoaXMuc3ViamVjdDIuYWRkRGVzY3JpcHRpb24obm9kZSwgImRlc2NyaXB0aW9uIDIuMi4xIik7Ci0JCW5vZGUgPSB0aGlzLnN1YmplY3QyLmFkZERlc2NyaXB0aW9uKHJvb3QsICJkZXNjcmlwdGlvbiAyLjMiKTsKLQl9Ci0KLQlwcml2YXRlIFRyZWVBc3BlY3RBZGFwdGVyPFRlc3RTdWJqZWN0LCBUZXN0Tm9kZVtdPiBidWlsZEFzcGVjdEFkYXB0ZXIoUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RTdWJqZWN0PiBzdWJqZWN0SG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgVHJlZUFzcGVjdEFkYXB0ZXI8VGVzdFN1YmplY3QsIFRlc3ROb2RlW10+KHN1YmplY3RIb2xkZXIsIFRlc3RTdWJqZWN0Lk5BTUVTX1RSRUUpIHsKLQkJCS8vIHRoaXMgaXMgbm90IGEgdHlwaWNhbCBhc3BlY3QgYWRhcHRlciAtIHRoZSB2YWx1ZSBpcyBkZXRlcm1pbmVkIGJ5IHRoZSBhc3BlY3QgbmFtZQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSXRlcmF0b3I8VGVzdE5vZGVbXT4gbm9kZXNfKCkgewotCQkJCWlmICh0aGlzLnRyZWVOYW1lc1swXSA9PSBUZXN0U3ViamVjdC5OQU1FU19UUkVFKSB7Ci0JCQkJCXJldHVybiB0aGlzLnN1YmplY3QubmFtZVBhdGhzKCk7Ci0JCQkJfQotCQkJCWlmICh0aGlzLnRyZWVOYW1lc1swXSA9PSBUZXN0U3ViamVjdC5ERVNDUklQVElPTlNfVFJFRSkgewotCQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmRlc2NyaXB0aW9uUGF0aHMoKTsKLQkJCQl9Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigiaW52YWxpZCBhc3BlY3QgbmFtZTogIiArIHRoaXMudHJlZU5hbWVzWzBdKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFRyZWVDaGFuZ2VMaXN0ZW5lciBidWlsZFZhbHVlQ2hhbmdlTGlzdGVuZXIxKCkgewotCQlyZXR1cm4gbmV3IFRyZWVDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIG5vZGVBZGRlZChUcmVlQ2hhbmdlRXZlbnQgZSkgewotCQkJCVRyZWVBc3BlY3RBZGFwdGVyVGVzdHMudGhpcy52YWx1ZTFDaGFuZ2VkKGUpOwotCQkJfQotCQkJcHVibGljIHZvaWQgbm9kZVJlbW92ZWQoVHJlZUNoYW5nZUV2ZW50IGUpIHsKLQkJCQlUcmVlQXNwZWN0QWRhcHRlclRlc3RzLnRoaXMudmFsdWUxQ2hhbmdlZChlKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIHRyZWVDbGVhcmVkKFRyZWVDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJVHJlZUFzcGVjdEFkYXB0ZXJUZXN0cy50aGlzLnZhbHVlMUNoYW5nZWQoZSk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCB0cmVlQ2hhbmdlZChUcmVlQ2hhbmdlRXZlbnQgZSkgewotCQkJCVRyZWVBc3BlY3RBZGFwdGVyVGVzdHMudGhpcy52YWx1ZTFDaGFuZ2VkKGUpOwotCQkJfQotCQl9OwotCX0KLQotCXZvaWQgdmFsdWUxQ2hhbmdlZChUcmVlQ2hhbmdlRXZlbnQgZSkgewotCQl0aGlzLmV2ZW50MSA9IGU7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTdWJqZWN0SG9sZGVyKCkgewotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQxKTsKLQotCQl0aGlzLnN1YmplY3RIb2xkZXIxLnNldFZhbHVlKHRoaXMuc3ViamVjdDIpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQxKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuYWExLCB0aGlzLmV2ZW50MS5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhUcmVlVmFsdWVNb2RlbC5OT0RFUywgdGhpcy5ldmVudDEuZ2V0VHJlZU5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygwLCB0aGlzLmV2ZW50MS5nZXRQYXRoKCkubGVuZ3RoKTsKLQkJCi0JCXRoaXMuZXZlbnQxID0gbnVsbDsKLQkJdGhpcy5zdWJqZWN0SG9sZGVyMS5zZXRWYWx1ZShudWxsKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmV2ZW50MSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmFhMSwgdGhpcy5ldmVudDEuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoVHJlZVZhbHVlTW9kZWwuTk9ERVMsIHRoaXMuZXZlbnQxLmdldFRyZWVOYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgdGhpcy5ldmVudDEuZ2V0UGF0aCgpLmxlbmd0aCk7Ci0JCQotCQl0aGlzLmV2ZW50MSA9IG51bGw7Ci0JCXRoaXMuc3ViamVjdEhvbGRlcjEuc2V0VmFsdWUodGhpcy5zdWJqZWN0MSk7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hYTEsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKFRyZWVWYWx1ZU1vZGVsLk5PREVTLCB0aGlzLmV2ZW50MS5nZXRUcmVlTmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHRoaXMuZXZlbnQxLmdldFBhdGgoKS5sZW5ndGgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RUcmVlU3RydWN0dXJlQ2hhbmdlKCkgewotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQxKTsKLQotCQl0aGlzLnN1YmplY3QxLmFkZFR3b05hbWVzKHRoaXMuc3ViamVjdDEuZ2V0Um9vdE5hbWVOb2RlKCksICJqYW0iLCAiamF6Iik7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudDEpOwotCQlhc3NlcnRFcXVhbHModGhpcy5hYTEsIHRoaXMuZXZlbnQxLmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKFRyZWVWYWx1ZU1vZGVsLk5PREVTLCB0aGlzLmV2ZW50MS5nZXRUcmVlTmFtZSgpKTsKLQkJT2JqZWN0W10gcGF0aCA9IHRoaXMuZXZlbnQxLmdldFBhdGgoKTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMuc3ViamVjdDEuZ2V0Um9vdE5hbWVOb2RlKCksIHBhdGhbcGF0aC5sZW5ndGggLSAxXSk7Ci0JCWFzc2VydFRydWUodGhpcy5zdWJqZWN0MS5jb250YWluc05hbWVOb2RlKCJqYW0iKSk7Ci0JCWFzc2VydFRydWUodGhpcy5zdWJqZWN0MS5jb250YWluc05hbWVOb2RlKCJqYXoiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE5vZGVzKCkgewotCQlhc3NlcnRFcXVhbHModGhpcy5jb252ZXJ0VG9OYW1lcyh0aGlzLnN1YmplY3QxLm5hbWVQYXRocygpKSwgdGhpcy5jb252ZXJ0VG9OYW1lcyh0aGlzLmFhMS5ub2RlcygpKSk7Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uPFN0cmluZz4gY29udmVydFRvTmFtZXMoSXRlcmF0b3I8VGVzdE5vZGVbXT4gbmFtZVBhdGhzKSB7Ci0JCUNvbGxlY3Rpb248U3RyaW5nPiByZXN1bHQgPSBuZXcgSGFzaEJhZzxTdHJpbmc+KCk7Ci0JCXdoaWxlIChuYW1lUGF0aHMuaGFzTmV4dCgpKSB7Ci0JCQlPYmplY3RbXSBwYXRoID0gbmFtZVBhdGhzLm5leHQoKTsKLQkJCVN0cmluZ0J1ZmZlciBzYiA9IG5ldyBTdHJpbmdCdWZmZXIoKTsKLQkJCXNiLmFwcGVuZCgnWycpOwotCQkJZm9yIChpbnQgaSA9IDA7IGkgPCBwYXRoLmxlbmd0aDsgaSsrKSB7Ci0JCQkJc2IuYXBwZW5kKCgoVGVzdE5vZGUpIHBhdGhbaV0pLmdldFRleHQoKSk7Ci0JCQkJaWYgKGkgPCBwYXRoLmxlbmd0aCAtIDEpIHsKLQkJCQkJc2IuYXBwZW5kKCc6Jyk7Ci0JCQkJfQotCQkJfQotCQkJc2IuYXBwZW5kKCddJyk7Ci0JCQlyZXN1bHQuYWRkKHNiLnRvU3RyaW5nKCkpOwotCQl9Ci0JCXJldHVybiByZXN1bHQ7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc0xpc3RlbmVycygpIHsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmFhMS5oYXNBbnlUcmVlQ2hhbmdlTGlzdGVuZXJzKFRyZWVWYWx1ZU1vZGVsLk5PREVTKSk7Ci0JCWFzc2VydFRydWUodGhpcy5zdWJqZWN0MS5oYXNBbnlUcmVlQ2hhbmdlTGlzdGVuZXJzKFRlc3RTdWJqZWN0Lk5BTUVTX1RSRUUpKTsKLQkJdGhpcy5hYTEucmVtb3ZlVHJlZUNoYW5nZUxpc3RlbmVyKFRyZWVWYWx1ZU1vZGVsLk5PREVTLCB0aGlzLmxpc3RlbmVyMSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc3ViamVjdDEuaGFzQW55VHJlZUNoYW5nZUxpc3RlbmVycyhUZXN0U3ViamVjdC5OQU1FU19UUkVFKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYWExLmhhc0FueVRyZWVDaGFuZ2VMaXN0ZW5lcnMoVHJlZVZhbHVlTW9kZWwuTk9ERVMpKTsKLQotCQlUcmVlQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIyID0gdGhpcy5idWlsZFZhbHVlQ2hhbmdlTGlzdGVuZXIxKCk7Ci0JCXRoaXMuYWExLmFkZFRyZWVDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcjIpOwotCQlhc3NlcnRUcnVlKHRoaXMuYWExLmhhc0FueVRyZWVDaGFuZ2VMaXN0ZW5lcnMoVHJlZVZhbHVlTW9kZWwuTk9ERVMpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnN1YmplY3QxLmhhc0FueVRyZWVDaGFuZ2VMaXN0ZW5lcnMoVGVzdFN1YmplY3QuTkFNRVNfVFJFRSkpOwotCQl0aGlzLmFhMS5yZW1vdmVUcmVlQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIyKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zdWJqZWN0MS5oYXNBbnlUcmVlQ2hhbmdlTGlzdGVuZXJzKFRlc3RTdWJqZWN0Lk5BTUVTX1RSRUUpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5hYTEuaGFzQW55VHJlZUNoYW5nZUxpc3RlbmVycyhUcmVlVmFsdWVNb2RlbC5OT0RFUykpOwotCX0KLQotCS8vICoqKioqKioqKiogaW5uZXIgY2xhc3NlcyAqKioqKioqKioqCi0JCi0JcHJpdmF0ZSBjbGFzcyBUZXN0U3ViamVjdCBleHRlbmRzIEFic3RyYWN0TW9kZWwgewotCQlwcml2YXRlIFRlc3ROb2RlIHJvb3ROYW1lTm9kZTsKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgTkFNRVNfVFJFRSA9ICJuYW1lcyI7Ci0JCXByaXZhdGUgVGVzdE5vZGUgcm9vdERlc2NyaXB0aW9uTm9kZTsKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgREVTQ1JJUFRJT05TX1RSRUUgPSAiZGVzY3JpcHRpb25zIjsKLQkKLQkJcHVibGljIFRlc3RTdWJqZWN0KCkgewotCQkJdGhpcy5yb290TmFtZU5vZGUgPSBuZXcgVGVzdE5vZGUoInJvb3QgbmFtZSIpOwotCQkJdGhpcy5yb290RGVzY3JpcHRpb25Ob2RlID0gbmV3IFRlc3ROb2RlKCJyb290IGRlc2NyaXB0aW9uIik7Ci0JCX0KLQkJcHVibGljIFRlc3ROb2RlIGdldFJvb3ROYW1lTm9kZSgpIHsKLQkJCXJldHVybiB0aGlzLnJvb3ROYW1lTm9kZTsKLQkJfQotCQlwdWJsaWMgSXRlcmF0b3I8VGVzdE5vZGU+IG5hbWVOb2RlcygpIHsKLQkJCXJldHVybiBuZXcgVHJlZUl0ZXJhdG9yPFRlc3ROb2RlPih0aGlzLnJvb3ROYW1lTm9kZSkgewotCQkJCUBPdmVycmlkZQotCQkJCXB1YmxpYyBJdGVyYXRvcjxUZXN0Tm9kZT4gY2hpbGRyZW4oVGVzdE5vZGUgbmV4dCkgewotCQkJCQlyZXR1cm4gbmV4dC5jaGlsZHJlbigpOwotCQkJCX0KLQkJCX07Ci0JCX0KLQkJcHVibGljIEl0ZXJhdG9yPFRlc3ROb2RlW10+IG5hbWVQYXRocygpIHsKLQkJCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25JdGVyYXRvcjxUZXN0Tm9kZSwgVGVzdE5vZGVbXT4odGhpcy5uYW1lTm9kZXMoKSkgewotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCBUZXN0Tm9kZVtdIHRyYW5zZm9ybShUZXN0Tm9kZSBuZXh0KSB7Ci0JCQkJCXJldHVybiBuZXh0LnBhdGgoKTsKLQkJCQl9Ci0JCQl9OwotCQl9Ci0JCXB1YmxpYyBUZXN0Tm9kZSBhZGROYW1lKFRlc3ROb2RlIHBhcmVudCwgU3RyaW5nIG5hbWUpIHsKLQkJCVRlc3ROb2RlIGNoaWxkID0gbmV3IFRlc3ROb2RlKG5hbWUpOwotCQkJcGFyZW50LmFkZENoaWxkKGNoaWxkKTsKLQkJCXRoaXMuZmlyZU5vZGVBZGRlZChOQU1FU19UUkVFLCBjaGlsZC5wYXRoKCkpOwotCQkJcmV0dXJuIGNoaWxkOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGFkZFR3b05hbWVzKFRlc3ROb2RlIHBhcmVudCwgU3RyaW5nIG5hbWUxLCBTdHJpbmcgbmFtZTIpIHsKLQkJCXBhcmVudC5hZGRDaGlsZChuZXcgVGVzdE5vZGUobmFtZTEpKTsKLQkJCXBhcmVudC5hZGRDaGlsZChuZXcgVGVzdE5vZGUobmFtZTIpKTsKLQkJCXRoaXMuZmlyZVRyZWVDaGFuZ2VkKE5BTUVTX1RSRUUsIHBhcmVudC5wYXRoKCkpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHJlbW92ZU5hbWVOb2RlKFRlc3ROb2RlIG5hbWVOb2RlKSB7Ci0JCQluYW1lTm9kZS5nZXRQYXJlbnQoKS5yZW1vdmVDaGlsZChuYW1lTm9kZSk7Ci0JCQl0aGlzLmZpcmVOb2RlUmVtb3ZlZChOQU1FU19UUkVFLCBuYW1lTm9kZS5wYXRoKCkpOwotCQl9Ci0JCXB1YmxpYyBib29sZWFuIGNvbnRhaW5zTmFtZU5vZGUoU3RyaW5nIG5hbWUpIHsKLQkJCXJldHVybiB0aGlzLm5hbWVOb2RlKG5hbWUpICE9IG51bGw7Ci0JCX0KLQkJcHVibGljIFRlc3ROb2RlIG5hbWVOb2RlKFN0cmluZyBuYW1lKSB7Ci0JCQlmb3IgKEl0ZXJhdG9yPFRlc3ROb2RlPiBzdHJlYW0gPSB0aGlzLm5hbWVOb2RlcygpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCQlUZXN0Tm9kZSBub2RlID0gc3RyZWFtLm5leHQoKTsKLQkJCQlpZiAobm9kZS5nZXRUZXh0KCkuZXF1YWxzKG5hbWUpKSB7Ci0JCQkJCXJldHVybiBub2RlOwotCQkJCX0KLQkJCX0KLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCXB1YmxpYyBUZXN0Tm9kZSBnZXRSb290RGVzY3JpcHRpb25Ob2RlKCkgewotCQkJcmV0dXJuIHRoaXMucm9vdERlc2NyaXB0aW9uTm9kZTsKLQkJfQotCQlwdWJsaWMgSXRlcmF0b3I8VGVzdE5vZGU+IGRlc2NyaXB0aW9uTm9kZXMoKSB7Ci0JCQlyZXR1cm4gbmV3IFRyZWVJdGVyYXRvcjxUZXN0Tm9kZT4odGhpcy5yb290RGVzY3JpcHRpb25Ob2RlKSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHVibGljIEl0ZXJhdG9yPFRlc3ROb2RlPiBjaGlsZHJlbihUZXN0Tm9kZSBuZXh0KSB7Ci0JCQkJCXJldHVybiBuZXh0LmNoaWxkcmVuKCk7Ci0JCQkJfQotCQkJfTsKLQkJfQotCQlwdWJsaWMgSXRlcmF0b3I8VGVzdE5vZGVbXT4gZGVzY3JpcHRpb25QYXRocygpIHsKLQkJCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25JdGVyYXRvcjxUZXN0Tm9kZSwgVGVzdE5vZGVbXT4odGhpcy5kZXNjcmlwdGlvbk5vZGVzKCkpIHsKLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgVGVzdE5vZGVbXSB0cmFuc2Zvcm0oVGVzdE5vZGUgbmV4dCkgewotCQkJCQlyZXR1cm4gbmV4dC5wYXRoKCk7Ci0JCQkJfQotCQkJfTsKLQkJfQotCQlwdWJsaWMgVGVzdE5vZGUgYWRkRGVzY3JpcHRpb24oVGVzdE5vZGUgcGFyZW50LCBTdHJpbmcgZGVzY3JpcHRpb24pIHsKLQkJCVRlc3ROb2RlIGNoaWxkID0gbmV3IFRlc3ROb2RlKGRlc2NyaXB0aW9uKTsKLQkJCXBhcmVudC5hZGRDaGlsZChjaGlsZCk7Ci0JCQl0aGlzLmZpcmVOb2RlQWRkZWQoREVTQ1JJUFRJT05TX1RSRUUsIGNoaWxkLnBhdGgoKSk7Ci0JCQlyZXR1cm4gY2hpbGQ7Ci0JCX0KLQkJcHVibGljIHZvaWQgcmVtb3ZlRGVzY3JpcHRpb25Ob2RlKFRlc3ROb2RlIGRlc2NyaXB0aW9uTm9kZSkgewotCQkJZGVzY3JpcHRpb25Ob2RlLmdldFBhcmVudCgpLnJlbW92ZUNoaWxkKGRlc2NyaXB0aW9uTm9kZSk7Ci0JCQl0aGlzLmZpcmVOb2RlUmVtb3ZlZChERVNDUklQVElPTlNfVFJFRSwgZGVzY3JpcHRpb25Ob2RlLnBhdGgoKSk7Ci0JCX0KLQkJcHVibGljIGJvb2xlYW4gY29udGFpbnNEZXNjcmlwdGlvbk5vZGUoU3RyaW5nIG5hbWUpIHsKLQkJCWZvciAoSXRlcmF0b3I8VGVzdE5vZGU+IHN0cmVhbSA9IHRoaXMuZGVzY3JpcHRpb25Ob2RlcygpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCQlUZXN0Tm9kZSBub2RlID0gc3RyZWFtLm5leHQoKTsKLQkJCQlpZiAobm9kZS5nZXRUZXh0KCkuZXF1YWxzKG5hbWUpKSB7Ci0JCQkJCXJldHVybiB0cnVlOwotCQkJCX0KLQkJCX0KLQkJCXJldHVybiBmYWxzZTsKLQkJfQotCX0KLQkKLQlwcml2YXRlIGNsYXNzIFRlc3ROb2RlIHsKLQkJcHJpdmF0ZSBmaW5hbCBTdHJpbmcgdGV4dDsKLQkJcHJpdmF0ZSBUZXN0Tm9kZSBwYXJlbnQ7Ci0JCXByaXZhdGUgZmluYWwgQ29sbGVjdGlvbjxUZXN0Tm9kZT4gY2hpbGRyZW47Ci0JCi0JCXB1YmxpYyBUZXN0Tm9kZShTdHJpbmcgdGV4dCkgewotCQkJdGhpcy50ZXh0ID0gdGV4dDsKLQkJCXRoaXMuY2hpbGRyZW4gPSBuZXcgSGFzaEJhZzxUZXN0Tm9kZT4oKTsKLQkJfQotCQlwdWJsaWMgU3RyaW5nIGdldFRleHQoKSB7Ci0JCQlyZXR1cm4gdGhpcy50ZXh0OwotCQl9Ci0JCXB1YmxpYyBUZXN0Tm9kZSBnZXRQYXJlbnQoKSB7Ci0JCQlyZXR1cm4gdGhpcy5wYXJlbnQ7Ci0JCX0KLQkJcHJpdmF0ZSB2b2lkIHNldFBhcmVudChUZXN0Tm9kZSBwYXJlbnQpIHsKLQkJCXRoaXMucGFyZW50ID0gcGFyZW50OwotCQl9Ci0JCXB1YmxpYyBJdGVyYXRvcjxUZXN0Tm9kZT4gY2hpbGRyZW4oKSB7Ci0JCQlyZXR1cm4gbmV3IFJlYWRPbmx5SXRlcmF0b3I8VGVzdE5vZGU+KHRoaXMuY2hpbGRyZW4pOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGFkZENoaWxkKFRlc3ROb2RlIGNoaWxkKSB7Ci0JCQl0aGlzLmNoaWxkcmVuLmFkZChjaGlsZCk7Ci0JCQljaGlsZC5zZXRQYXJlbnQodGhpcyk7Ci0JCX0KLQkJcHVibGljIHZvaWQgcmVtb3ZlQ2hpbGQoVGVzdE5vZGUgY2hpbGQpIHsKLQkJCXRoaXMuY2hpbGRyZW4ucmVtb3ZlKGNoaWxkKTsKLQkJfQotCQlwdWJsaWMgVGVzdE5vZGVbXSBwYXRoKCkgewotCQkJcmV0dXJuIENvbGxlY3Rpb25Ub29scy5yZXZlcnNlTGlzdCh0aGlzLmJ1aWxkQW50aVBhdGgoKSkudG9BcnJheShuZXcgVGVzdE5vZGVbMF0pOwotCQl9Ci0JCXByaXZhdGUgSXRlcmF0b3I8VGVzdE5vZGU+IGJ1aWxkQW50aVBhdGgoKSB7Ci0JCQlyZXR1cm4gbmV3IENoYWluSXRlcmF0b3I8VGVzdE5vZGU+KHRoaXMpIHsKLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgVGVzdE5vZGUgbmV4dExpbmsoVGVzdE5vZGUgY3VycmVudExpbmspIHsKLQkJCQkJcmV0dXJuIGN1cnJlbnRMaW5rLmdldFBhcmVudCgpOwotCQkJCX0KLQkJCX07Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gIlRlc3ROb2RlKCIgKyB0aGlzLnRleHQgKyAiKSI7Ci0JCX0KLQl9Ci0JCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1ZhbHVlQ29sbGVjdGlvbkFkYXB0ZXJUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9WYWx1ZUNvbGxlY3Rpb25BZGFwdGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWZlZjM4YS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1ZhbHVlQ29sbGVjdGlvbkFkYXB0ZXJUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTU2ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5WYWx1ZUNvbGxlY3Rpb25BZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlByb3BlcnR5Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuU3RhdGVDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlN0YXRlQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIFZhbHVlQ29sbGVjdGlvbkFkYXB0ZXJUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIEp1bmsganVuazsKLQlwcml2YXRlIFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxKdW5rPiBqdW5rSG9sZGVyOwotCXByaXZhdGUgVmFsdWVDb2xsZWN0aW9uQWRhcHRlcjxKdW5rPiBqdW5rSG9sZGVyMjsKLQotCi0JcHVibGljIFZhbHVlQ29sbGVjdGlvbkFkYXB0ZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLmp1bmsgPSBuZXcgSnVuaygiZm9vIik7Ci0JCXRoaXMuanVua0hvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8SnVuaz4odGhpcy5qdW5rKTsKLQkJdGhpcy5qdW5rSG9sZGVyMiA9IG5ldyBWYWx1ZUNvbGxlY3Rpb25BZGFwdGVyPEp1bms+KHRoaXMuanVua0hvbGRlciwgSnVuay5TVFVGRl9DT0xMRUNUSU9OKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFdyYXBwZWRQVk0oKSB7Ci0JCUp1bmsganVuazIgPSBuZXcgSnVuaygiYmFyIik7Ci0JCUxvY2FsTGlzdGVuZXIgbCA9IG5ldyBMb2NhbExpc3RlbmVyKHRoaXMuanVua0hvbGRlcjIsIHRoaXMuanVuaywganVuazIpOwotCQl0aGlzLmp1bmtIb2xkZXIyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobCk7Ci0JCXRoaXMuanVua0hvbGRlci5zZXRWYWx1ZShqdW5rMik7Ci0JCWFzc2VydFRydWUobC5ldmVudFJlY2VpdmVkKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycygpIHRocm93cyBFeGNlcHRpb24gewotCQlhc3NlcnRGYWxzZSh0aGlzLmp1bmtIb2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuanVua0hvbGRlcjIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0KLQkJTG9jYWxMaXN0ZW5lciBsID0gbmV3IExvY2FsTGlzdGVuZXIodGhpcy5qdW5rSG9sZGVyMiwgbnVsbCwgdGhpcy5qdW5rKTsKLQkJdGhpcy5qdW5rSG9sZGVyMi5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKGwpOwotCQlhc3NlcnRUcnVlKHRoaXMuanVua0hvbGRlci5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmp1bmtIb2xkZXIyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCi0JCXRoaXMuanVua0hvbGRlcjIucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihsKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qdW5rSG9sZGVyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmp1bmtIb2xkZXIyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNTdGF0ZUNoYW5nZUxpc3RlbmVycygpIHRocm93cyBFeGNlcHRpb24gewotCQlhc3NlcnRGYWxzZSh0aGlzLmp1bmsuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhKdW5rLlNUVUZGX0NPTExFQ1RJT04pKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qdW5rSG9sZGVyMi5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQotCQlMb2NhbExpc3RlbmVyIGwgPSBuZXcgTG9jYWxMaXN0ZW5lcih0aGlzLmp1bmtIb2xkZXIyLCBudWxsLCB0aGlzLmp1bmspOwotCQl0aGlzLmp1bmtIb2xkZXIyLmFkZFN0YXRlQ2hhbmdlTGlzdGVuZXIobCk7Ci0JCWFzc2VydFRydWUodGhpcy5qdW5rLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoSnVuay5TVFVGRl9DT0xMRUNUSU9OKSk7Ci0JCWFzc2VydFRydWUodGhpcy5qdW5rSG9sZGVyMi5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQotCQl0aGlzLmp1bmtIb2xkZXIyLnJlbW92ZVN0YXRlQ2hhbmdlTGlzdGVuZXIobCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuanVuay5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKEp1bmsuU1RVRkZfQ09MTEVDVElPTikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmp1bmtIb2xkZXIyLmhhc0FueVN0YXRlQ2hhbmdlTGlzdGVuZXJzKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb2xsZWN0aW9uQWRkKCkgewotCQlMb2NhbExpc3RlbmVyIGwgPSBuZXcgTG9jYWxMaXN0ZW5lcih0aGlzLmp1bmtIb2xkZXIyKTsKLQkJdGhpcy5qdW5rSG9sZGVyMi5hZGRTdGF0ZUNoYW5nZUxpc3RlbmVyKGwpOwotCQl0aGlzLmp1bmsuYWRkU3R1ZmYoImJhciIpOwotCQlhc3NlcnRUcnVlKGwuZXZlbnRSZWNlaXZlZCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29sbGVjdGlvblJlbW92ZSgpIHsKLQkJTG9jYWxMaXN0ZW5lciBsID0gbmV3IExvY2FsTGlzdGVuZXIodGhpcy5qdW5rSG9sZGVyMik7Ci0JCXRoaXMuanVua0hvbGRlcjIuYWRkU3RhdGVDaGFuZ2VMaXN0ZW5lcihsKTsKLQkJdGhpcy5qdW5rLnJlbW92ZVN0dWZmKCJmb28iKTsKLQkJYXNzZXJ0VHJ1ZShsLmV2ZW50UmVjZWl2ZWQoKSk7Ci0JfQotCi0KLQlwcml2YXRlIGNsYXNzIExvY2FsTGlzdGVuZXIgaW1wbGVtZW50cyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyLCBTdGF0ZUNoYW5nZUxpc3RlbmVyIHsKLQkJcHJpdmF0ZSBib29sZWFuIGV2ZW50UmVjZWl2ZWQgPSBmYWxzZTsKLQkJcHJpdmF0ZSBmaW5hbCBPYmplY3Qgc291cmNlOwotCQlwcml2YXRlIGZpbmFsIE9iamVjdCBvbGRWYWx1ZTsKLQkJcHJpdmF0ZSBmaW5hbCBPYmplY3QgbmV3VmFsdWU7Ci0JCUxvY2FsTGlzdGVuZXIoT2JqZWN0IHNvdXJjZSkgewotCQkJdGhpcyhzb3VyY2UsIG51bGwsIG51bGwpOwotCQl9Ci0JCUxvY2FsTGlzdGVuZXIoT2JqZWN0IHNvdXJjZSwgT2JqZWN0IG9sZFZhbHVlLCBPYmplY3QgbmV3VmFsdWUpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLnNvdXJjZSA9IHNvdXJjZTsKLQkJCXRoaXMub2xkVmFsdWUgPSBvbGRWYWx1ZTsKLQkJCXRoaXMubmV3VmFsdWUgPSBuZXdWYWx1ZTsKLQkJfQotCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCQl0aGlzLmV2ZW50UmVjZWl2ZWQgPSB0cnVlOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMuc291cmNlLCBlLmdldFNvdXJjZSgpKTsKLQkJCWFzc2VydEVxdWFscyh0aGlzLm9sZFZhbHVlLCBlLmdldE9sZFZhbHVlKCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMubmV3VmFsdWUsIGUuZ2V0TmV3VmFsdWUoKSk7Ci0JCQlhc3NlcnRFcXVhbHMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCBlLmdldFByb3BlcnR5TmFtZSgpKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoU3RhdGVDaGFuZ2VFdmVudCBlKSB7Ci0JCQl0aGlzLmV2ZW50UmVjZWl2ZWQgPSB0cnVlOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMuc291cmNlLCBlLmdldFNvdXJjZSgpKTsKLQkJCWFzc2VydE51bGwoZS5nZXRBc3BlY3ROYW1lKCkpOwotCQl9Ci0JCWJvb2xlYW4gZXZlbnRSZWNlaXZlZCgpIHsKLQkJCXJldHVybiB0aGlzLmV2ZW50UmVjZWl2ZWQ7Ci0JCX0KLQl9Ci0KLQotCXByaXZhdGUgY2xhc3MgSnVuayBleHRlbmRzIEFic3RyYWN0TW9kZWwgewotCQlwcml2YXRlIENvbGxlY3Rpb248U3RyaW5nPiBzdHVmZjsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFNUVUZGX0NPTExFQ1RJT04gPSAic3R1ZmYiOwotCi0JCXB1YmxpYyBKdW5rKFN0cmluZyBzdHVmZkl0ZW0pIHsKLQkJCXRoaXMuc3R1ZmYgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJCXRoaXMuc3R1ZmYuYWRkKHN0dWZmSXRlbSk7Ci0JCX0KLQkKLQkJcHVibGljIHZvaWQgYWRkU3R1ZmYoU3RyaW5nIHN0dWZmSXRlbSkgewotCQkJdGhpcy5hZGRJdGVtVG9Db2xsZWN0aW9uKHN0dWZmSXRlbSwgdGhpcy5zdHVmZiwgU1RVRkZfQ09MTEVDVElPTik7Ci0JCX0KLQkJCi0JCXB1YmxpYyB2b2lkIHJlbW92ZVN0dWZmKFN0cmluZyBzdHVmZkl0ZW0pIHsKLQkJCXRoaXMucmVtb3ZlSXRlbUZyb21Db2xsZWN0aW9uKHN0dWZmSXRlbSwgdGhpcy5zdHVmZiwgU1RVRkZfQ09MTEVDVElPTik7Ci0JCX0KLQkKLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gIkp1bmsoIiArIHRoaXMuc3R1ZmYgKyAiKSI7Ci0JCX0KLQkKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVmFsdWVMaXN0QWRhcHRlclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1ZhbHVlTGlzdEFkYXB0ZXJUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkMWFkYTI1Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVmFsdWVMaXN0QWRhcHRlclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNjcgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZTsKLQotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlZhbHVlTGlzdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5TdGF0ZUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuU3RhdGVDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgVmFsdWVMaXN0QWRhcHRlclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgSnVuayBqdW5rOwotCXByaXZhdGUgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPEp1bms+IGp1bmtIb2xkZXI7Ci0JcHJpdmF0ZSBWYWx1ZUxpc3RBZGFwdGVyPEp1bms+IGp1bmtIb2xkZXIyOwotCi0KLQkKLQlwdWJsaWMgVmFsdWVMaXN0QWRhcHRlclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMuanVuayA9IG5ldyBKdW5rKCJmb28iKTsKLQkJdGhpcy5qdW5rSG9sZGVyID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxKdW5rPih0aGlzLmp1bmspOwotCQl0aGlzLmp1bmtIb2xkZXIyID0gbmV3IFZhbHVlTGlzdEFkYXB0ZXI8SnVuaz4odGhpcy5qdW5rSG9sZGVyLCBKdW5rLlNUVUZGX0xJU1QpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0V3JhcHBlZFBWTSgpIHsKLQkJSnVuayBqdW5rMiA9IG5ldyBKdW5rKCJiYXIiKTsKLQkJTG9jYWxMaXN0ZW5lciBsID0gbmV3IExvY2FsTGlzdGVuZXIodGhpcy5qdW5rSG9sZGVyMiwgdGhpcy5qdW5rLCBqdW5rMik7Ci0JCXRoaXMuanVua0hvbGRlcjIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihsKTsKLQkJdGhpcy5qdW5rSG9sZGVyLnNldFZhbHVlKGp1bmsyKTsKLQkJYXNzZXJ0VHJ1ZShsLmV2ZW50UmVjZWl2ZWQoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWFzc2VydEZhbHNlKHRoaXMuanVua0hvbGRlci5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qdW5rSG9sZGVyMi5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQotCQlMb2NhbExpc3RlbmVyIGwgPSBuZXcgTG9jYWxMaXN0ZW5lcih0aGlzLmp1bmtIb2xkZXIyLCBudWxsLCB0aGlzLmp1bmspOwotCQl0aGlzLmp1bmtIb2xkZXIyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobCk7Ci0JCWFzc2VydFRydWUodGhpcy5qdW5rSG9sZGVyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlhc3NlcnRUcnVlKHRoaXMuanVua0hvbGRlcjIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0KLQkJdGhpcy5qdW5rSG9sZGVyMi5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKGwpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmp1bmtIb2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuanVua0hvbGRlcjIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc1N0YXRlQ2hhbmdlTGlzdGVuZXJzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWFzc2VydEZhbHNlKHRoaXMuanVuay5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKEp1bmsuU1RVRkZfTElTVCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmp1bmtIb2xkZXIyLmhhc0FueVN0YXRlQ2hhbmdlTGlzdGVuZXJzKCkpOwotCi0JCUxvY2FsTGlzdGVuZXIgbCA9IG5ldyBMb2NhbExpc3RlbmVyKHRoaXMuanVua0hvbGRlcjIsIG51bGwsIHRoaXMuanVuayk7Ci0JCXRoaXMuanVua0hvbGRlcjIuYWRkU3RhdGVDaGFuZ2VMaXN0ZW5lcihsKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmp1bmsuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhKdW5rLlNUVUZGX0xJU1QpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmp1bmtIb2xkZXIyLmhhc0FueVN0YXRlQ2hhbmdlTGlzdGVuZXJzKCkpOwotCi0JCXRoaXMuanVua0hvbGRlcjIucmVtb3ZlU3RhdGVDaGFuZ2VMaXN0ZW5lcihsKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qdW5rLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoSnVuay5TVFVGRl9MSVNUKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuanVua0hvbGRlcjIuaGFzQW55U3RhdGVDaGFuZ2VMaXN0ZW5lcnMoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RBZGQoKSB7Ci0JCUxvY2FsTGlzdGVuZXIgbCA9IG5ldyBMb2NhbExpc3RlbmVyKHRoaXMuanVua0hvbGRlcjIsIG51bGwsIHRoaXMuanVuayk7Ci0JCXRoaXMuanVua0hvbGRlcjIuYWRkU3RhdGVDaGFuZ2VMaXN0ZW5lcihsKTsKLQkJdGhpcy5qdW5rLmFkZFN0dWZmKCJiYXIiKTsKLQkJYXNzZXJ0VHJ1ZShsLmV2ZW50UmVjZWl2ZWQoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RSZW1vdmUoKSB7Ci0JCUxvY2FsTGlzdGVuZXIgbCA9IG5ldyBMb2NhbExpc3RlbmVyKHRoaXMuanVua0hvbGRlcjIsIG51bGwsIHRoaXMuanVuayk7Ci0JCXRoaXMuanVua0hvbGRlcjIuYWRkU3RhdGVDaGFuZ2VMaXN0ZW5lcihsKTsKLQkJdGhpcy5qdW5rLnJlbW92ZVN0dWZmKCJmb28iKTsKLQkJYXNzZXJ0VHJ1ZShsLmV2ZW50UmVjZWl2ZWQoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3RSZXBsYWNlKCkgewotCQlMb2NhbExpc3RlbmVyIGwgPSBuZXcgTG9jYWxMaXN0ZW5lcih0aGlzLmp1bmtIb2xkZXIyLCBudWxsLCB0aGlzLmp1bmspOwotCQl0aGlzLmp1bmtIb2xkZXIyLmFkZFN0YXRlQ2hhbmdlTGlzdGVuZXIobCk7Ci0JCXRoaXMuanVuay5yZXBsYWNlU3R1ZmYoImZvbyIsICJiYXIiKTsKLQkJYXNzZXJ0VHJ1ZShsLmV2ZW50UmVjZWl2ZWQoKSk7Ci0JfQotCi0KLQlwcml2YXRlIGNsYXNzIExvY2FsTGlzdGVuZXIgaW1wbGVtZW50cyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyLCBTdGF0ZUNoYW5nZUxpc3RlbmVyIHsKLQkJcHJpdmF0ZSBib29sZWFuIGV2ZW50UmVjZWl2ZWQgPSBmYWxzZTsKLQkJcHJpdmF0ZSBmaW5hbCBPYmplY3Qgc291cmNlOwotCQlwcml2YXRlIGZpbmFsIE9iamVjdCBvbGRWYWx1ZTsKLQkJcHJpdmF0ZSBmaW5hbCBPYmplY3QgbmV3VmFsdWU7Ci0JCUxvY2FsTGlzdGVuZXIoT2JqZWN0IHNvdXJjZSkgewotCQkJdGhpcyhzb3VyY2UsIG51bGwsIG51bGwpOwotCQl9Ci0JCUxvY2FsTGlzdGVuZXIoT2JqZWN0IHNvdXJjZSwgT2JqZWN0IG9sZFZhbHVlLCBPYmplY3QgbmV3VmFsdWUpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLnNvdXJjZSA9IHNvdXJjZTsKLQkJCXRoaXMub2xkVmFsdWUgPSBvbGRWYWx1ZTsKLQkJCXRoaXMubmV3VmFsdWUgPSBuZXdWYWx1ZTsKLQkJfQotCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCQl0aGlzLmV2ZW50UmVjZWl2ZWQgPSB0cnVlOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMuc291cmNlLCBlLmdldFNvdXJjZSgpKTsKLQkJCWFzc2VydEVxdWFscyh0aGlzLm9sZFZhbHVlLCBlLmdldE9sZFZhbHVlKCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMubmV3VmFsdWUsIGUuZ2V0TmV3VmFsdWUoKSk7Ci0JCQlhc3NlcnRFcXVhbHMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCBlLmdldFByb3BlcnR5TmFtZSgpKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoU3RhdGVDaGFuZ2VFdmVudCBlKSB7Ci0JCQl0aGlzLmV2ZW50UmVjZWl2ZWQgPSB0cnVlOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMuc291cmNlLCBlLmdldFNvdXJjZSgpKTsKLQkJCWFzc2VydE51bGwoZS5nZXRBc3BlY3ROYW1lKCkpOwotCQl9Ci0JCWJvb2xlYW4gZXZlbnRSZWNlaXZlZCgpIHsKLQkJCXJldHVybiB0aGlzLmV2ZW50UmVjZWl2ZWQ7Ci0JCX0KLQl9Ci0KLQlwcml2YXRlIGNsYXNzIEp1bmsgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIHsKLQkJcHJpdmF0ZSBMaXN0PFN0cmluZz4gc3R1ZmY7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBTVFVGRl9MSVNUID0gInN0dWZmIjsKLQotCQlwdWJsaWMgSnVuayhTdHJpbmcgc3R1ZmZJdGVtKSB7Ci0JCQl0aGlzLnN0dWZmID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCQl0aGlzLnN0dWZmLmFkZChzdHVmZkl0ZW0pOwotCQl9Ci0JCi0JCXB1YmxpYyB2b2lkIGFkZFN0dWZmKFN0cmluZyBzdHVmZkl0ZW0pIHsKLQkJCXRoaXMuYWRkSXRlbVRvTGlzdChzdHVmZkl0ZW0sIHRoaXMuc3R1ZmYsIFNUVUZGX0xJU1QpOwotCQl9Ci0JCQotCQlwdWJsaWMgdm9pZCByZW1vdmVTdHVmZihTdHJpbmcgc3R1ZmZJdGVtKSB7Ci0JCQl0aGlzLnJlbW92ZUl0ZW1Gcm9tTGlzdChzdHVmZkl0ZW0sIHRoaXMuc3R1ZmYsIFNUVUZGX0xJU1QpOwotCQl9Ci0JCi0JCXB1YmxpYyB2b2lkIHJlcGxhY2VTdHVmZihTdHJpbmcgb2xkU3R1ZmZJdGVtLCBTdHJpbmcgbmV3U3R1ZmZJdGVtKSB7Ci0JCQl0aGlzLnJlcGxhY2VJdGVtSW5MaXN0KG9sZFN0dWZmSXRlbSwgbmV3U3R1ZmZJdGVtLCB0aGlzLnN0dWZmLCBTVFVGRl9MSVNUKTsKLQkJfQotCQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiSnVuaygiICsgdGhpcy5zdHVmZiArICIpIjsKLQkJfQotCQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9WYWx1ZVByb3BlcnR5QWRhcHRlclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1ZhbHVlUHJvcGVydHlBZGFwdGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYjhjNmUxYi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1ZhbHVlUHJvcGVydHlBZGFwdGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE0MyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlOwotCi1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlZhbHVlUHJvcGVydHlBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LlByb3BlcnR5Q2hhbmdlRXZlbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuU3RhdGVDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlN0YXRlQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIFZhbHVlUHJvcGVydHlBZGFwdGVyVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBKdW5rIGp1bms7Ci0JcHJpdmF0ZSBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8SnVuaz4ganVua0hvbGRlcjsKLQlwcml2YXRlIFZhbHVlUHJvcGVydHlBZGFwdGVyPEp1bms+IGp1bmtIb2xkZXIyOwotCi0KLQlwdWJsaWMgVmFsdWVQcm9wZXJ0eUFkYXB0ZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLmp1bmsgPSBuZXcgSnVuaygiZm9vIik7Ci0JCXRoaXMuanVua0hvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8SnVuaz4odGhpcy5qdW5rKTsKLQkJdGhpcy5qdW5rSG9sZGVyMiA9IG5ldyBWYWx1ZVByb3BlcnR5QWRhcHRlcjxKdW5rPih0aGlzLmp1bmtIb2xkZXIsIEp1bmsuTkFNRV9QUk9QRVJUWSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RXcmFwcGVkUFZNKCkgewotCQlKdW5rIGp1bmsyID0gbmV3IEp1bmsoImJhciIpOwotCQlMb2NhbExpc3RlbmVyIGwgPSBuZXcgTG9jYWxMaXN0ZW5lcih0aGlzLmp1bmtIb2xkZXIyLCB0aGlzLmp1bmssIGp1bmsyKTsKLQkJdGhpcy5qdW5rSG9sZGVyMi5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKGwpOwotCQl0aGlzLmp1bmtIb2xkZXIuc2V0VmFsdWUoanVuazIpOwotCQlhc3NlcnRUcnVlKGwuZXZlbnRSZWNlaXZlZCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qdW5rSG9sZGVyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmp1bmtIb2xkZXIyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCi0JCUxvY2FsTGlzdGVuZXIgbCA9IG5ldyBMb2NhbExpc3RlbmVyKHRoaXMuanVua0hvbGRlcjIsIG51bGwsIHRoaXMuanVuayk7Ci0JCXRoaXMuanVua0hvbGRlcjIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihsKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmp1bmtIb2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCWFzc2VydFRydWUodGhpcy5qdW5rSG9sZGVyMi5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQotCQl0aGlzLmp1bmtIb2xkZXIyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuanVua0hvbGRlci5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qdW5rSG9sZGVyMi5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzU3RhdGVDaGFuZ2VMaXN0ZW5lcnMoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qdW5rLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKEp1bmsuTkFNRV9QUk9QRVJUWSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmp1bmtIb2xkZXIyLmhhc0FueVN0YXRlQ2hhbmdlTGlzdGVuZXJzKCkpOwotCi0JCUxvY2FsTGlzdGVuZXIgbCA9IG5ldyBMb2NhbExpc3RlbmVyKHRoaXMuanVua0hvbGRlcjIsIG51bGwsIHRoaXMuanVuayk7Ci0JCXRoaXMuanVua0hvbGRlcjIuYWRkU3RhdGVDaGFuZ2VMaXN0ZW5lcihsKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmp1bmsuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoSnVuay5OQU1FX1BST1BFUlRZKSk7Ci0JCWFzc2VydFRydWUodGhpcy5qdW5rSG9sZGVyMi5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQotCQl0aGlzLmp1bmtIb2xkZXIyLnJlbW92ZVN0YXRlQ2hhbmdlTGlzdGVuZXIobCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuanVuay5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhKdW5rLk5BTUVfUFJPUEVSVFkpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qdW5rSG9sZGVyMi5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2hhbmdlUHJvcGVydHkoKSB7Ci0JCUxvY2FsTGlzdGVuZXIgbCA9IG5ldyBMb2NhbExpc3RlbmVyKHRoaXMuanVua0hvbGRlcjIsIG51bGwsIHRoaXMuanVuayk7Ci0JCXRoaXMuanVua0hvbGRlcjIuYWRkU3RhdGVDaGFuZ2VMaXN0ZW5lcihsKTsKLQkJdGhpcy5qdW5rLnNldE5hbWUoImJhciIpOwotCQlhc3NlcnRUcnVlKGwuZXZlbnRSZWNlaXZlZCgpKTsKLQl9Ci0KLQotCXByaXZhdGUgY2xhc3MgTG9jYWxMaXN0ZW5lciBpbXBsZW1lbnRzIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIsIFN0YXRlQ2hhbmdlTGlzdGVuZXIgewotCQlwcml2YXRlIGJvb2xlYW4gZXZlbnRSZWNlaXZlZCA9IGZhbHNlOwotCQlwcml2YXRlIGZpbmFsIE9iamVjdCBzb3VyY2U7Ci0JCXByaXZhdGUgZmluYWwgT2JqZWN0IG9sZFZhbHVlOwotCQlwcml2YXRlIGZpbmFsIE9iamVjdCBuZXdWYWx1ZTsKLQkJTG9jYWxMaXN0ZW5lcihPYmplY3Qgc291cmNlKSB7Ci0JCQl0aGlzKHNvdXJjZSwgbnVsbCwgbnVsbCk7Ci0JCX0KLQkJTG9jYWxMaXN0ZW5lcihPYmplY3Qgc291cmNlLCBPYmplY3Qgb2xkVmFsdWUsIE9iamVjdCBuZXdWYWx1ZSkgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMuc291cmNlID0gc291cmNlOwotCQkJdGhpcy5vbGRWYWx1ZSA9IG9sZFZhbHVlOwotCQkJdGhpcy5uZXdWYWx1ZSA9IG5ld1ZhbHVlOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJCXRoaXMuZXZlbnRSZWNlaXZlZCA9IHRydWU7Ci0JCQlhc3NlcnRFcXVhbHModGhpcy5zb3VyY2UsIGUuZ2V0U291cmNlKCkpOwotCQkJYXNzZXJ0RXF1YWxzKHRoaXMub2xkVmFsdWUsIGUuZ2V0T2xkVmFsdWUoKSk7Ci0JCQlhc3NlcnRFcXVhbHModGhpcy5uZXdWYWx1ZSwgZS5nZXROZXdWYWx1ZSgpKTsKLQkJCWFzc2VydEVxdWFscyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIGUuZ2V0UHJvcGVydHlOYW1lKCkpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHN0YXRlQ2hhbmdlZChTdGF0ZUNoYW5nZUV2ZW50IGUpIHsKLQkJCXRoaXMuZXZlbnRSZWNlaXZlZCA9IHRydWU7Ci0JCQlhc3NlcnRFcXVhbHModGhpcy5zb3VyY2UsIGUuZ2V0U291cmNlKCkpOwotCQkJYXNzZXJ0TnVsbChlLmdldEFzcGVjdE5hbWUoKSk7Ci0JCX0KLQkJYm9vbGVhbiBldmVudFJlY2VpdmVkKCkgewotCQkJcmV0dXJuIHRoaXMuZXZlbnRSZWNlaXZlZDsKLQkJfQotCX0KLQotCXByaXZhdGUgY2xhc3MgSnVuayBleHRlbmRzIEFic3RyYWN0TW9kZWwgewotCQlwcml2YXRlIFN0cmluZyBuYW1lOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgTkFNRV9QUk9QRVJUWSA9ICJuYW1lIjsKLQotCQlwdWJsaWMgSnVuayhTdHJpbmcgbmFtZSkgewotCQkJdGhpcy5uYW1lID0gbmFtZTsKLQkJfQotCQotCQlwdWJsaWMgdm9pZCBzZXROYW1lKFN0cmluZyBuYW1lKSB7Ci0JCQlTdHJpbmcgb2xkID0gdGhpcy5uYW1lOwotCQkJdGhpcy5uYW1lID0gbmFtZTsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChOQU1FX1BST1BFUlRZLCBvbGQsIG5hbWUpOwotCQl9Ci0JCQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiSnVuaygiICsgdGhpcy5uYW1lICsgIikiOwotCQl9Ci0JCi0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL1ZhbHVlU3RhdGVBZGFwdGVyVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVmFsdWVTdGF0ZUFkYXB0ZXJUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2YWVmNThhLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvVmFsdWVTdGF0ZUFkYXB0ZXJUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTQzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWU7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuVmFsdWVTdGF0ZUFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5TdGF0ZUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuU3RhdGVDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgVmFsdWVTdGF0ZUFkYXB0ZXJUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIEp1bmsganVuazsKLQlwcml2YXRlIFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxKdW5rPiBqdW5rSG9sZGVyOwotCXByaXZhdGUgVmFsdWVTdGF0ZUFkYXB0ZXI8SnVuaz4ganVua0hvbGRlcjI7Ci0KLQotCXB1YmxpYyBWYWx1ZVN0YXRlQWRhcHRlclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMuanVuayA9IG5ldyBKdW5rKCJmb28iKTsKLQkJdGhpcy5qdW5rSG9sZGVyID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxKdW5rPih0aGlzLmp1bmspOwotCQl0aGlzLmp1bmtIb2xkZXIyID0gbmV3IFZhbHVlU3RhdGVBZGFwdGVyPEp1bms+KHRoaXMuanVua0hvbGRlcik7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RXcmFwcGVkUFZNKCkgewotCQlKdW5rIGp1bmsyID0gbmV3IEp1bmsoImJhciIpOwotCQlMb2NhbExpc3RlbmVyIGwgPSBuZXcgTG9jYWxMaXN0ZW5lcih0aGlzLmp1bmtIb2xkZXIyLCB0aGlzLmp1bmssIGp1bmsyKTsKLQkJdGhpcy5qdW5rSG9sZGVyMi5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKGwpOwotCQl0aGlzLmp1bmtIb2xkZXIuc2V0VmFsdWUoanVuazIpOwotCQlhc3NlcnRUcnVlKGwuZXZlbnRSZWNlaXZlZCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qdW5rSG9sZGVyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmp1bmtIb2xkZXIyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCi0JCUxvY2FsTGlzdGVuZXIgbCA9IG5ldyBMb2NhbExpc3RlbmVyKHRoaXMuanVua0hvbGRlcjIsIG51bGwsIHRoaXMuanVuayk7Ci0JCXRoaXMuanVua0hvbGRlcjIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihsKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmp1bmtIb2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCWFzc2VydFRydWUodGhpcy5qdW5rSG9sZGVyMi5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQotCQl0aGlzLmp1bmtIb2xkZXIyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIobCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuanVua0hvbGRlci5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qdW5rSG9sZGVyMi5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzU3RhdGVDaGFuZ2VMaXN0ZW5lcnMoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qdW5rLmhhc0FueVN0YXRlQ2hhbmdlTGlzdGVuZXJzKCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmp1bmtIb2xkZXIyLmhhc0FueVN0YXRlQ2hhbmdlTGlzdGVuZXJzKCkpOwotCi0JCUxvY2FsTGlzdGVuZXIgbCA9IG5ldyBMb2NhbExpc3RlbmVyKHRoaXMuanVua0hvbGRlcjIsIG51bGwsIHRoaXMuanVuayk7Ci0JCXRoaXMuanVua0hvbGRlcjIuYWRkU3RhdGVDaGFuZ2VMaXN0ZW5lcihsKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmp1bmsuaGFzQW55U3RhdGVDaGFuZ2VMaXN0ZW5lcnMoKSk7Ci0JCWFzc2VydFRydWUodGhpcy5qdW5rSG9sZGVyMi5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQotCQl0aGlzLmp1bmtIb2xkZXIyLnJlbW92ZVN0YXRlQ2hhbmdlTGlzdGVuZXIobCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuanVuay5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5qdW5rSG9sZGVyMi5oYXNBbnlTdGF0ZUNoYW5nZUxpc3RlbmVycygpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2hhbmdlU3RhdGUoKSB7Ci0JCUxvY2FsTGlzdGVuZXIgbCA9IG5ldyBMb2NhbExpc3RlbmVyKHRoaXMuanVua0hvbGRlcjIsIG51bGwsIHRoaXMuanVuayk7Ci0JCXRoaXMuanVua0hvbGRlcjIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihsKTsKLQkJdGhpcy5qdW5rSG9sZGVyMi5hZGRTdGF0ZUNoYW5nZUxpc3RlbmVyKGwpOwotCQl0aGlzLmp1bmsuc2V0TmFtZSgiYmFyIik7Ci0JCWFzc2VydFRydWUobC5ldmVudFJlY2VpdmVkKCkpOwotCX0KLQotCi0JcHJpdmF0ZSBjbGFzcyBMb2NhbExpc3RlbmVyIGltcGxlbWVudHMgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciwgU3RhdGVDaGFuZ2VMaXN0ZW5lciB7Ci0JCXByaXZhdGUgYm9vbGVhbiBldmVudFJlY2VpdmVkID0gZmFsc2U7Ci0JCXByaXZhdGUgZmluYWwgT2JqZWN0IHNvdXJjZTsKLQkJcHJpdmF0ZSBmaW5hbCBPYmplY3Qgb2xkVmFsdWU7Ci0JCXByaXZhdGUgZmluYWwgT2JqZWN0IG5ld1ZhbHVlOwotCQlMb2NhbExpc3RlbmVyKE9iamVjdCBzb3VyY2UpIHsKLQkJCXRoaXMoc291cmNlLCBudWxsLCBudWxsKTsKLQkJfQotCQlMb2NhbExpc3RlbmVyKE9iamVjdCBzb3VyY2UsIE9iamVjdCBvbGRWYWx1ZSwgT2JqZWN0IG5ld1ZhbHVlKSB7Ci0JCQlzdXBlcigpOwotCQkJdGhpcy5zb3VyY2UgPSBzb3VyY2U7Ci0JCQl0aGlzLm9sZFZhbHVlID0gb2xkVmFsdWU7Ci0JCQl0aGlzLm5ld1ZhbHVlID0gbmV3VmFsdWU7Ci0JCX0KLQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZSkgewotCQkJdGhpcy5ldmVudFJlY2VpdmVkID0gdHJ1ZTsKLQkJCWFzc2VydEVxdWFscyh0aGlzLnNvdXJjZSwgZS5nZXRTb3VyY2UoKSk7Ci0JCQlhc3NlcnRFcXVhbHModGhpcy5vbGRWYWx1ZSwgZS5nZXRPbGRWYWx1ZSgpKTsKLQkJCWFzc2VydEVxdWFscyh0aGlzLm5ld1ZhbHVlLCBlLmdldE5ld1ZhbHVlKCkpOwotCQkJYXNzZXJ0RXF1YWxzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgZS5nZXRQcm9wZXJ0eU5hbWUoKSk7Ci0JCX0KLQkJcHVibGljIHZvaWQgc3RhdGVDaGFuZ2VkKFN0YXRlQ2hhbmdlRXZlbnQgZSkgewotCQkJdGhpcy5ldmVudFJlY2VpdmVkID0gdHJ1ZTsKLQkJCWFzc2VydEVxdWFscyh0aGlzLnNvdXJjZSwgZS5nZXRTb3VyY2UoKSk7Ci0JCQlhc3NlcnROdWxsKGUuZ2V0QXNwZWN0TmFtZSgpKTsKLQkJfQotCQlib29sZWFuIGV2ZW50UmVjZWl2ZWQoKSB7Ci0JCQlyZXR1cm4gdGhpcy5ldmVudFJlY2VpdmVkOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSBjbGFzcyBKdW5rIGV4dGVuZHMgQWJzdHJhY3RNb2RlbCB7Ci0JCXByaXZhdGUgU3RyaW5nIG5hbWU7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBOQU1FX1BST1BFUlRZID0gIm5hbWUiOwotCi0JCXB1YmxpYyBKdW5rKFN0cmluZyBuYW1lKSB7Ci0JCQl0aGlzLm5hbWUgPSBuYW1lOwotCQl9Ci0JCi0JCXB1YmxpYyB2b2lkIHNldE5hbWUoU3RyaW5nIG5hbWUpIHsKLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCQl0aGlzLmZpcmVTdGF0ZUNoYW5nZWQoKTsKLQkJfQotCQkKLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gIkp1bmsoIiArIHRoaXMubmFtZSArICIpIjsKLQkJfQotCQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9wcmVmcy9KcHRVdGlsaXR5TW9kZWxWYWx1ZVByZWZzVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvcHJlZnMvSnB0VXRpbGl0eU1vZGVsVmFsdWVQcmVmc1Rlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDA0M2RhMDcuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9wcmVmcy9KcHRVdGlsaXR5TW9kZWxWYWx1ZVByZWZzVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDMxICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWUucHJlZnM7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdFN1aXRlOwotCi1wdWJsaWMgY2xhc3MgSnB0VXRpbGl0eU1vZGVsVmFsdWVQcmVmc1Rlc3RzIHsKLQkKLQlwdWJsaWMgc3RhdGljIFRlc3Qgc3VpdGUoKSB7Ci0JCVRlc3RTdWl0ZSBzdWl0ZSA9IG5ldyBUZXN0U3VpdGUoSnB0VXRpbGl0eU1vZGVsVmFsdWVQcmVmc1Rlc3RzLmNsYXNzLmdldFBhY2thZ2UoKS5nZXROYW1lKCkpOwotCi0JCXN1aXRlLmFkZFRlc3RTdWl0ZShQcmVmZXJlbmNlc0NvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLmNsYXNzKTsKLQkKLQkJcmV0dXJuIHN1aXRlOwotCX0KLQkKLQlwcml2YXRlIEpwdFV0aWxpdHlNb2RlbFZhbHVlUHJlZnNUZXN0cygpIHsKLQkJc3VwZXIoKTsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9wcmVmcy9QcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvcHJlZnMvUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGIwNGRmMzEuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9wcmVmcy9QcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDM4MiArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnByZWZzOwotCi1pbXBvcnQgamF2YS51dGlsLnByZWZzLk5vZGVDaGFuZ2VFdmVudDsKLWltcG9ydCBqYXZhLnV0aWwucHJlZnMuTm9kZUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IGphdmEudXRpbC5wcmVmcy5QcmVmZXJlbmNlQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgamF2YS51dGlsLnByZWZzLlByZWZlcmVuY2VDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBqYXZhLnV0aWwucHJlZnMuUHJlZmVyZW5jZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUucHJlZnMuUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5Nb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Qcm9wZXJ0eUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotCi1wdWJsaWMgY2xhc3MgUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzIGV4dGVuZHMgUHJlZmVyZW5jZXNUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxQcmVmZXJlbmNlcz4gbm9kZUhvbGRlcjsKLQlQcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gcHJlZmVyZW5jZUFkYXB0ZXI7Ci0JUHJvcGVydHlDaGFuZ2VFdmVudCBldmVudDsKLQlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyOwotCWJvb2xlYW4gbGlzdGVuZXJSZW1vdmVkID0gZmFsc2U7Ci0JUHJlZmVyZW5jZUNoYW5nZUV2ZW50IHByZWZlcmVuY2VFdmVudDsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgS0VZX05BTUUgPSAiZm9vIjsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgU1RSSU5HX1ZBTFVFID0gIm9yaWdpbmFsIHN0cmluZyB2YWx1ZSI7Ci0KLQlwdWJsaWMgUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMudGVzdE5vZGUucHV0KEtFWV9OQU1FLCBTVFJJTkdfVkFMVUUpOwotCi0JCXRoaXMubm9kZUhvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8UHJlZmVyZW5jZXM+KHRoaXMudGVzdE5vZGUpOwotCQl0aGlzLnByZWZlcmVuY2VBZGFwdGVyID0gbmV3IFByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPih0aGlzLm5vZGVIb2xkZXIsIEtFWV9OQU1FKTsKLQkJdGhpcy5saXN0ZW5lciA9IHRoaXMuYnVpbGRWYWx1ZUNoYW5nZUxpc3RlbmVyKCk7Ci0JCXRoaXMucHJlZmVyZW5jZUFkYXB0ZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMubGlzdGVuZXIpOwotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXByaXZhdGUgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZFZhbHVlQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJCQlpZiAoUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLnRoaXMuZXZlbnQgIT0gbnVsbCkgewotCQkJCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJ1bmV4cGVjdGVkIHRoaXMuZXZlbnQ6ICIgKyBlKTsKLQkJCQl9Ci0JCQkJUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLnRoaXMuZXZlbnQgPSBlOwotCQkJfQotCQl9OwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTdWJqZWN0SG9sZGVyKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWFzc2VydEVxdWFscyhTVFJJTkdfVkFMVUUsIHRoaXMucHJlZmVyZW5jZUFkYXB0ZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydE51bGwodGhpcy5ldmVudCk7Ci0KLQkJU3RyaW5nIEFOT1RIRVJfU1RSSU5HX1ZBTFVFID0gInNvbWUgb3RoZXIgdmFsdWUiOwotCQlQcmVmZXJlbmNlcyBhbm90aGVyTm9kZSA9IHRoaXMuY2xhc3NOb2RlLm5vZGUoImFub3RoZXIgdGVzdCBub2RlIik7Ci0JCWFub3RoZXJOb2RlLnB1dChLRVlfTkFNRSwgQU5PVEhFUl9TVFJJTkdfVkFMVUUpOwotCi0JCXRoaXMubm9kZUhvbGRlci5zZXRWYWx1ZShhbm90aGVyTm9kZSk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQoU1RSSU5HX1ZBTFVFLCBBTk9USEVSX1NUUklOR19WQUxVRSk7Ci0JCWFzc2VydEVxdWFscyhBTk9USEVSX1NUUklOR19WQUxVRSwgdGhpcy5wcmVmZXJlbmNlQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQkJCi0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLm5vZGVIb2xkZXIuc2V0VmFsdWUobnVsbCk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQoQU5PVEhFUl9TVFJJTkdfVkFMVUUsIG51bGwpOwotCQlhc3NlcnROdWxsKHRoaXMucHJlZmVyZW5jZUFkYXB0ZXIuZ2V0VmFsdWUoKSk7Ci0JCQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy5ub2RlSG9sZGVyLnNldFZhbHVlKHRoaXMudGVzdE5vZGUpOwotCQl0aGlzLnZlcmlmeUV2ZW50KG51bGwsIFNUUklOR19WQUxVRSk7Ci0JCWFzc2VydEVxdWFscyhTVFJJTkdfVkFMVUUsIHRoaXMucHJlZmVyZW5jZUFkYXB0ZXIuZ2V0VmFsdWUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFByZWZlcmVuY2VDaGFuZ2UoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0RXF1YWxzKFNUUklOR19WQUxVRSwgdGhpcy5wcmVmZXJlbmNlQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50KTsKLQotCQl0aGlzLnRlc3ROb2RlLnB1dChLRVlfTkFNRSwgU1RSSU5HX1ZBTFVFICsgU1RSSU5HX1ZBTFVFKTsKLQkJdGhpcy53YWl0Rm9yRXZlbnRRdWV1ZVRvQ2xlYXIoKTsKLQkJdGhpcy52ZXJpZnlFdmVudChTVFJJTkdfVkFMVUUsIFNUUklOR19WQUxVRSArIFNUUklOR19WQUxVRSk7Ci0JCWFzc2VydEVxdWFscyhTVFJJTkdfVkFMVUUgKyBTVFJJTkdfVkFMVUUsIHRoaXMucHJlZmVyZW5jZUFkYXB0ZXIuZ2V0VmFsdWUoKSk7Ci0JCQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy50ZXN0Tm9kZS5yZW1vdmUoS0VZX05BTUUpOwotCQl0aGlzLndhaXRGb3JFdmVudFF1ZXVlVG9DbGVhcigpOwotCQl0aGlzLnZlcmlmeUV2ZW50KFNUUklOR19WQUxVRSArIFNUUklOR19WQUxVRSwgbnVsbCk7Ci0JCWFzc2VydE51bGwodGhpcy5wcmVmZXJlbmNlQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQkJCi0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLnRlc3ROb2RlLnB1dChLRVlfTkFNRSwgU1RSSU5HX1ZBTFVFKTsKLQkJdGhpcy53YWl0Rm9yRXZlbnRRdWV1ZVRvQ2xlYXIoKTsKLQkJdGhpcy52ZXJpZnlFdmVudChudWxsLCBTVFJJTkdfVkFMVUUpOwotCQlhc3NlcnRFcXVhbHMoU1RSSU5HX1ZBTFVFLCB0aGlzLnByZWZlcmVuY2VBZGFwdGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RWYWx1ZSgpIHRocm93cyBFeGNlcHRpb24gewotCQlhc3NlcnRFcXVhbHMoU1RSSU5HX1ZBTFVFLCB0aGlzLnRlc3ROb2RlLmdldChLRVlfTkFNRSwgIjxtaXNzaW5nIHByZWZlcmVuY2U+IikpOwotCQlhc3NlcnRFcXVhbHMoU1RSSU5HX1ZBTFVFLCB0aGlzLnByZWZlcmVuY2VBZGFwdGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRWYWx1ZSgpIHRocm93cyBFeGNlcHRpb24gewotCQlTdHJpbmcgQU5PVEhFUl9TVFJJTkdfVkFMVUUgPSAic29tZSBvdGhlciB2YWx1ZSI7Ci0JCXRoaXMucHJlZmVyZW5jZUFkYXB0ZXIuc2V0VmFsdWUoQU5PVEhFUl9TVFJJTkdfVkFMVUUpOwotCQlhc3NlcnRFcXVhbHMoQU5PVEhFUl9TVFJJTkdfVkFMVUUsIHRoaXMucHJlZmVyZW5jZUFkYXB0ZXIuZ2V0VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscyhBTk9USEVSX1NUUklOR19WQUxVRSwgdGhpcy50ZXN0Tm9kZS5nZXQoS0VZX05BTUUsICI8bWlzc2luZyBwcmVmZXJlbmNlPiIpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWFzc2VydFRydWUodGhpcy5wcmVmZXJlbmNlQWRhcHRlci5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLm5vZGVIYXNBbnlQcmVmTGlzdGVuZXJzKHRoaXMudGVzdE5vZGUpKTsKLQkJdGhpcy5wcmVmZXJlbmNlQWRhcHRlci5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5saXN0ZW5lcik7Ci0JCWFzc2VydEZhbHNlKHRoaXMubm9kZUhhc0FueVByZWZMaXN0ZW5lcnModGhpcy50ZXN0Tm9kZSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnByZWZlcmVuY2VBZGFwdGVyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCi0JCVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIyID0gdGhpcy5idWlsZFZhbHVlQ2hhbmdlTGlzdGVuZXIoKTsKLQkJdGhpcy5wcmVmZXJlbmNlQWRhcHRlci5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyMik7Ci0JCWFzc2VydFRydWUodGhpcy5wcmVmZXJlbmNlQWRhcHRlci5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLm5vZGVIYXNBbnlQcmVmTGlzdGVuZXJzKHRoaXMudGVzdE5vZGUpKTsKLQkJdGhpcy5wcmVmZXJlbmNlQWRhcHRlci5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyMik7Ci0JCWFzc2VydEZhbHNlKHRoaXMubm9kZUhhc0FueVByZWZMaXN0ZW5lcnModGhpcy50ZXN0Tm9kZSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnByZWZlcmVuY2VBZGFwdGVyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVBbmRSZUFkZFByZWZlcmVuY2UoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0RXF1YWxzKFNUUklOR19WQUxVRSwgdGhpcy50ZXN0Tm9kZS5nZXQoS0VZX05BTUUsIG51bGwpKTsKLQkJYXNzZXJ0RXF1YWxzKFNUUklOR19WQUxVRSwgdGhpcy5wcmVmZXJlbmNlQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50KTsKLQotCQkvLyByZW1vdmUgdGhlIHByZWZlcmVuY2UgZW50aXJlbHkuLi4KLQkJdGhpcy50ZXN0Tm9kZS5yZW1vdmUoS0VZX05BTUUpOwotCQl0aGlzLndhaXRGb3JFdmVudFF1ZXVlVG9DbGVhcigpOwotCQlhc3NlcnROdWxsKHRoaXMudGVzdE5vZGUuZ2V0KEtFWV9OQU1FLCBudWxsKSk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQoU1RSSU5HX1ZBTFVFLCBudWxsKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLnByZWZlcmVuY2VBZGFwdGVyLmdldFZhbHVlKCkpOwotCi0JCS8vIC4uLnRoZW4gcmUtYWRkIGl0IHdpdGggdGhlIHNhbWUga2V5Ci0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLnRlc3ROb2RlLnB1dChLRVlfTkFNRSwgU1RSSU5HX1ZBTFVFKTsKLQkJdGhpcy53YWl0Rm9yRXZlbnRRdWV1ZVRvQ2xlYXIoKTsKLQkJYXNzZXJ0RXF1YWxzKFNUUklOR19WQUxVRSwgdGhpcy50ZXN0Tm9kZS5nZXQoS0VZX05BTUUsIG51bGwpKTsKLQkJdGhpcy52ZXJpZnlFdmVudChudWxsLCBTVFJJTkdfVkFMVUUpOwotCQlhc3NlcnRFcXVhbHMoU1RSSU5HX1ZBTFVFLCB0aGlzLnByZWZlcmVuY2VBZGFwdGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3REZWZhdWx0VmFsdWUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJLy8gcmVidWlsZCB0aGUgYWRhcHRlciB3aXRoIGEgZGVmYXVsdCB2YWx1ZQotCQlTdHJpbmcgREVGQVVMVF9WQUxVRSA9ICJkZWZhdWx0IHZhbHVlIjsKLQkJdGhpcy5wcmVmZXJlbmNlQWRhcHRlci5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5saXN0ZW5lcik7Ci0JCXRoaXMucHJlZmVyZW5jZUFkYXB0ZXIgPSBuZXcgUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+KHRoaXMubm9kZUhvbGRlciwgS0VZX05BTUUsIERFRkFVTFRfVkFMVUUpOwotCQl0aGlzLnByZWZlcmVuY2VBZGFwdGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmxpc3RlbmVyKTsKLQotCQlhc3NlcnRFcXVhbHMoU1RSSU5HX1ZBTFVFLCB0aGlzLnRlc3ROb2RlLmdldChLRVlfTkFNRSwgbnVsbCkpOwotCQlhc3NlcnRFcXVhbHMoU1RSSU5HX1ZBTFVFLCB0aGlzLnByZWZlcmVuY2VBZGFwdGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQpOwotCi0JCS8vIHJlbW92ZSB0aGUgcHJlZmVyZW5jZSBlbnRpcmVseS4uLgotCQl0aGlzLnRlc3ROb2RlLnJlbW92ZShLRVlfTkFNRSk7Ci0JCXRoaXMud2FpdEZvckV2ZW50UXVldWVUb0NsZWFyKCk7Ci0JCWFzc2VydE51bGwodGhpcy50ZXN0Tm9kZS5nZXQoS0VZX05BTUUsIG51bGwpKTsKLQkJdGhpcy52ZXJpZnlFdmVudChTVFJJTkdfVkFMVUUsIERFRkFVTFRfVkFMVUUpOwotCQlhc3NlcnRFcXVhbHMoREVGQVVMVF9WQUxVRSwgdGhpcy5wcmVmZXJlbmNlQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQotCQkvLyAuLi50aGVuIHJlLWFkZCBpdCB3aXRoIHRoZSBzYW1lIGtleQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy50ZXN0Tm9kZS5wdXQoS0VZX05BTUUsIFNUUklOR19WQUxVRSk7Ci0JCXRoaXMud2FpdEZvckV2ZW50UXVldWVUb0NsZWFyKCk7Ci0JCWFzc2VydEVxdWFscyhTVFJJTkdfVkFMVUUsIHRoaXMudGVzdE5vZGUuZ2V0KEtFWV9OQU1FLCBudWxsKSk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQoREVGQVVMVF9WQUxVRSwgU1RSSU5HX1ZBTFVFKTsKLQkJYXNzZXJ0RXF1YWxzKFNUUklOR19WQUxVRSwgdGhpcy5wcmVmZXJlbmNlQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VW5zeW5jaHJvbml6ZWRWYWx1ZSgpIHRocm93cyBFeGNlcHRpb24gewotCQlhc3NlcnRFcXVhbHMoU1RSSU5HX1ZBTFVFLCB0aGlzLnByZWZlcmVuY2VBZGFwdGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQpOwotCi0JCS8vIHJlbW92ZSB0aGUgdGhpcy5saXN0ZW5lciBzbyB0aGUgYWRhcHRlciBubyBsb25nZXIgbGlzdGVucyB0byB0aGUgcHJlZmVyZW5jZQotCQl0aGlzLnByZWZlcmVuY2VBZGFwdGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmxpc3RlbmVyKTsKLQotCQl0aGlzLnRlc3ROb2RlLnB1dChLRVlfTkFNRSwgU1RSSU5HX1ZBTFVFICsgU1RSSU5HX1ZBTFVFKTsKLQkJdGhpcy53YWl0Rm9yRXZlbnRRdWV1ZVRvQ2xlYXIoKTsKLQkJLy8gbm8gdGhpcy5ldmVudCBzaG91bGQgaGF2ZSBiZWVuIGZpcmVkLi4uCi0JCWFzc2VydE51bGwodGhpcy5ldmVudCk7Ci0JCS8vIC4uLmFuZCB0aGUgYWRhcHRlcidzIHZhbHVlIHNob3VsZCBiZSBudWxsCi0JCWFzc2VydE51bGwodGhpcy5wcmVmZXJlbmNlQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQkJCi0JCXRoaXMudGVzdE5vZGUucmVtb3ZlKEtFWV9OQU1FKTsKLQkJdGhpcy53YWl0Rm9yRXZlbnRRdWV1ZVRvQ2xlYXIoKTsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50KTsKLQkJYXNzZXJ0TnVsbCh0aGlzLnByZWZlcmVuY2VBZGFwdGVyLmdldFZhbHVlKCkpOwotCQkKLQkJdGhpcy50ZXN0Tm9kZS5wdXQoS0VZX05BTUUsIFNUUklOR19WQUxVRSk7Ci0JCXRoaXMud2FpdEZvckV2ZW50UXVldWVUb0NsZWFyKCk7Ci0JCWFzc2VydE51bGwodGhpcy5ldmVudCk7Ci0JCWFzc2VydE51bGwodGhpcy5wcmVmZXJlbmNlQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQotCQkvLyBhZGQgdGhlIHRoaXMubGlzdGVuZXIgc28gdGhlIGFkYXB0ZXIgc3luY2hzCi0JCXRoaXMucHJlZmVyZW5jZUFkYXB0ZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMubGlzdGVuZXIpOwotCQlhc3NlcnRFcXVhbHMoU1RSSU5HX1ZBTFVFLCB0aGlzLnByZWZlcmVuY2VBZGFwdGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbnRlZ2VyUHJlZmVyZW5jZSgpIHRocm93cyBFeGNlcHRpb24gewotCQkvLyBzdG9wIGxpc3RlbmluZyB0byB0aGUgbm9kZSBhbmQgY29udmVydCBpdCB0byBhbiBpbnRlZ2VyCi0JCXRoaXMucHJlZmVyZW5jZUFkYXB0ZXIucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMubGlzdGVuZXIpOwotCi0JCVByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4gaW50ZWdlclByZWZlcmVuY2VBZGFwdGVyID0gbmV3IFByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWw8SW50ZWdlcj4odGhpcy5ub2RlSG9sZGVyLCBLRVlfTkFNRSk7Ci0JCXRoaXMudGVzdE5vZGUucHV0SW50KEtFWV9OQU1FLCAxMjMpOwotCQlpbnRlZ2VyUHJlZmVyZW5jZUFkYXB0ZXIgPSBQcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsLmZvckludGVnZXIodGhpcy50ZXN0Tm9kZSwgS0VZX05BTUUsIDApOwotCQlpbnRlZ2VyUHJlZmVyZW5jZUFkYXB0ZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMubGlzdGVuZXIpOwotCQlhc3NlcnRFcXVhbHMobmV3IEludGVnZXIoMTIzKSwgaW50ZWdlclByZWZlcmVuY2VBZGFwdGVyLmdldFZhbHVlKCkpOwotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQpOwotCi0JCXRoaXMudGVzdE5vZGUucHV0SW50KEtFWV9OQU1FLCAyNDYpOwotCQl0aGlzLndhaXRGb3JFdmVudFF1ZXVlVG9DbGVhcigpOwotCQl0aGlzLnZlcmlmeUV2ZW50KGludGVnZXJQcmVmZXJlbmNlQWRhcHRlciwgbmV3IEludGVnZXIoMTIzKSwgbmV3IEludGVnZXIoMjQ2KSk7Ci0JCWFzc2VydEVxdWFscyhuZXcgSW50ZWdlcigyNDYpLCBpbnRlZ2VyUHJlZmVyZW5jZUFkYXB0ZXIuZ2V0VmFsdWUoKSk7Ci0JCQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy50ZXN0Tm9kZS5yZW1vdmUoS0VZX05BTUUpOwotCQl0aGlzLndhaXRGb3JFdmVudFF1ZXVlVG9DbGVhcigpOwotCQl0aGlzLnZlcmlmeUV2ZW50KGludGVnZXJQcmVmZXJlbmNlQWRhcHRlciwgbmV3IEludGVnZXIoMjQ2KSwgbmV3IEludGVnZXIoMCkpOwotCQlhc3NlcnRFcXVhbHMobmV3IEludGVnZXIoMCksIGludGVnZXJQcmVmZXJlbmNlQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQkJCi0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0aGlzLnRlc3ROb2RlLnB1dEludChLRVlfTkFNRSwgMTIzKTsKLQkJdGhpcy53YWl0Rm9yRXZlbnRRdWV1ZVRvQ2xlYXIoKTsKLQkJdGhpcy52ZXJpZnlFdmVudChpbnRlZ2VyUHJlZmVyZW5jZUFkYXB0ZXIsIG5ldyBJbnRlZ2VyKDApLCBuZXcgSW50ZWdlcigxMjMpKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBJbnRlZ2VyKDEyMyksIGludGVnZXJQcmVmZXJlbmNlQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQkvKioKLQkgKiB0ZXN0IGEgc2l0dWF0aW9uIHdoZXJlCi0JICogLSB3ZSBhcmUgbGlzdGVuaW5nIHRvIHRoZSBub2RlIHdoZW4gaXQgZ2V0cyByZW1vdmVkIGZyb20gdGhlIHByZWZlcmVuY2VzICJyZXBvc2l0b3J5IgotCSAqIC0gd2UgZ2V0IG5vdGlmaWNhdGlvbiB0aGF0IGl0IGhhcyBiZWVuIHJlbW92ZWQKLQkgKiAtIHdlIHRyeSB0byByZW1vdmUgb3VyIHRoaXMubGlzdGVuZXIKLQkgKiAtIHRoZSBub2RlIHdpbGwgdGhyb3cgYW4gSWxsZWdhbFN0YXRlRXhjZXB0aW9uIC0gdGhlIGFkYXB0ZXIgc2hvdWxkIGhhbmRsZSBpdCBPSy4uLgotCSAqLwotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVOb2RlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWFzc2VydFRydWUodGhpcy5wcmVmZXJlbmNlQWRhcHRlci5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQotCQlQcmVmZXJlbmNlcyBwYXJlbnQgPSB0aGlzLnRlc3ROb2RlLnBhcmVudCgpOwotCQlwYXJlbnQuYWRkTm9kZUNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRQYXJlbnROb2RlQ2hhbmdlTGlzdGVuZXIoKSk7Ci0JCXRoaXMudGVzdE5vZGUucmVtb3ZlTm9kZSgpOwotCQl0aGlzLnRlc3ROb2RlLmZsdXNoKCk7CQkvLyB0aGlzIHNlZW1zIHRvIGJlIHJlcXVpcmVkIGZvciB0aGUgdGhpcy5ldmVudCB0byB0cmlnZ2VyLi4uCi0JCXRoaXMud2FpdEZvckV2ZW50UXVldWVUb0NsZWFyKCk7Ci0KLQkJYXNzZXJ0VHJ1ZSh0aGlzLmxpc3RlbmVyUmVtb3ZlZCk7Ci0JCWFzc2VydFRydWUodGhpcy5wcmVmZXJlbmNlQWRhcHRlci5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCX0KLQotCXByaXZhdGUgTm9kZUNoYW5nZUxpc3RlbmVyIGJ1aWxkUGFyZW50Tm9kZUNoYW5nZUxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IE5vZGVDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIGNoaWxkQWRkZWQoTm9kZUNoYW5nZUV2ZW50IGUpIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJ1bmV4cGVjdGVkIHRoaXMuZXZlbnQ6ICIgKyBlKTsKLQkJCX0KLQkJCXB1YmxpYyB2b2lkIGNoaWxkUmVtb3ZlZChOb2RlQ2hhbmdlRXZlbnQgZSkgewotCQkJCWlmIChlLmdldENoaWxkKCkgPT0gUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLnRoaXMudGVzdE5vZGUpIHsKLQkJCQkJUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLnRoaXMucHJlZmVyZW5jZUFkYXB0ZXIucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIFByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWxUZXN0cy50aGlzLmxpc3RlbmVyKTsKLQkJCQkJLy8gdGhpcyBsaW5lIG9mIGNvZGUgd2lsbCBub3QgZXhlY3V0ZSBpZiB0aGUgbGluZSBhYm92ZSB0cmlnZ2VycyBhbiBleGNlcHRpb24KLQkJCQkJUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLnRoaXMubGlzdGVuZXJSZW1vdmVkID0gdHJ1ZTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNldFNhbWVWYWx1ZSgpIHsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50KTsKLQkJYXNzZXJ0TnVsbCh0aGlzLnByZWZlcmVuY2VFdmVudCk7Ci0JCXRoaXMudGVzdE5vZGUuYWRkUHJlZmVyZW5jZUNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRQcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXIoKSk7Ci0KLQkJU3RyaW5nIEFOT1RIRVJfU1RSSU5HX1ZBTFVFID0gInNvbWUgb3RoZXIgdmFsdWUiOwotCQl0aGlzLnByZWZlcmVuY2VBZGFwdGVyLnNldFZhbHVlKEFOT1RIRVJfU1RSSU5HX1ZBTFVFKTsKLQotCQl0aGlzLnZlcmlmeUV2ZW50KFNUUklOR19WQUxVRSwgQU5PVEhFUl9TVFJJTkdfVkFMVUUpOwotCQl0aGlzLndhaXRGb3JFdmVudFF1ZXVlVG9DbGVhcigpOwotCQl0aGlzLnZlcmlmeVByZWZlcmVuY2VFdmVudChBTk9USEVSX1NUUklOR19WQUxVRSk7Ci0KLQkJLy8gbm93IHNldCB0byAqc2FtZSogdmFsdWUgLSBub3RoaW5nIHNob3VsZCBoYXBwZW4uLi4KLQkJdGhpcy5ldmVudCA9IG51bGw7Ci0JCXRoaXMucHJlZmVyZW5jZUV2ZW50ID0gbnVsbDsKLQkJdGhpcy5wcmVmZXJlbmNlQWRhcHRlci5zZXRWYWx1ZShBTk9USEVSX1NUUklOR19WQUxVRSk7Ci0KLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50KTsKLQkJYXNzZXJ0TnVsbCh0aGlzLnByZWZlcmVuY2VFdmVudCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNldFNhbWVWYWx1ZUZvcmNlUGFzc1Rocm91Z2goKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0TnVsbCh0aGlzLmV2ZW50KTsKLQkJYXNzZXJ0TnVsbCh0aGlzLnByZWZlcmVuY2VFdmVudCk7Ci0KLQkJdGhpcy5wcmVmZXJlbmNlQWRhcHRlci5yZW1vdmVQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5saXN0ZW5lcik7Ci0JCXRoaXMucHJlZmVyZW5jZUFkYXB0ZXIgPSBuZXcgQWx3YXlzVXBkYXRlUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+KHRoaXMubm9kZUhvbGRlciwgS0VZX05BTUUpOwotCQl0aGlzLnByZWZlcmVuY2VBZGFwdGVyLmFkZFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmxpc3RlbmVyKTsKLQotCQl0aGlzLnRlc3ROb2RlLmFkZFByZWZlcmVuY2VDaGFuZ2VMaXN0ZW5lcih0aGlzLmJ1aWxkUHJlZmVyZW5jZUNoYW5nZUxpc3RlbmVyKCkpOwotCi0JCVN0cmluZyBBTk9USEVSX1NUUklOR19WQUxVRSA9ICJzb21lIG90aGVyIHZhbHVlIjsKLQkJdGhpcy5wcmVmZXJlbmNlQWRhcHRlci5zZXRWYWx1ZShBTk9USEVSX1NUUklOR19WQUxVRSk7Ci0KLQkJdGhpcy52ZXJpZnlFdmVudChTVFJJTkdfVkFMVUUsIEFOT1RIRVJfU1RSSU5HX1ZBTFVFKTsKLQkJdGhpcy53YWl0Rm9yRXZlbnRRdWV1ZVRvQ2xlYXIoKTsKLQkJdGhpcy52ZXJpZnlQcmVmZXJlbmNlRXZlbnQoQU5PVEhFUl9TVFJJTkdfVkFMVUUpOwotCi0JCS8vIG5vdyBzZXQgdG8gKnNhbWUqIHZhbHVlIC0gb25seSBvbmUgdGhpcy5ldmVudCBzaG91bGQgZmlyZQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy5wcmVmZXJlbmNlRXZlbnQgPSBudWxsOwotCQl0aGlzLnByZWZlcmVuY2VBZGFwdGVyLnNldFZhbHVlKEFOT1RIRVJfU1RSSU5HX1ZBTFVFKTsKLQotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQpOwotCQl0aGlzLndhaXRGb3JFdmVudFF1ZXVlVG9DbGVhcigpOwotCQl0aGlzLnZlcmlmeVByZWZlcmVuY2VFdmVudChBTk9USEVSX1NUUklOR19WQUxVRSk7Ci0JCWFzc2VydE51bGwodGhpcy5ldmVudCk7Ci0JfQotCi0JcHJpdmF0ZSBQcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXIgYnVpbGRQcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJlZmVyZW5jZUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgcHJlZmVyZW5jZUNoYW5nZShQcmVmZXJlbmNlQ2hhbmdlRXZlbnQgZXZ0KSB7Ci0JCQkJUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbFRlc3RzLnRoaXMucHJlZmVyZW5jZUV2ZW50ID0gZXZ0OwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlFdmVudChNb2RlbCBzb3VyY2UsIE9iamVjdCBvbGRWYWx1ZSwgT2JqZWN0IG5ld1ZhbHVlKSB7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudCk7Ci0JCWFzc2VydEVxdWFscyhzb3VyY2UsIHRoaXMuZXZlbnQuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLmV2ZW50LmdldFByb3BlcnR5TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKG9sZFZhbHVlLCB0aGlzLmV2ZW50LmdldE9sZFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMobmV3VmFsdWUsIHRoaXMuZXZlbnQuZ2V0TmV3VmFsdWUoKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUV2ZW50KE9iamVjdCBvbGRWYWx1ZSwgT2JqZWN0IG5ld1ZhbHVlKSB7Ci0JCXRoaXMudmVyaWZ5RXZlbnQodGhpcy5wcmVmZXJlbmNlQWRhcHRlciwgb2xkVmFsdWUsIG5ld1ZhbHVlKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5UHJlZmVyZW5jZUV2ZW50KE9iamVjdCBuZXdWYWx1ZSkgewotCQlhc3NlcnROb3ROdWxsKHRoaXMucHJlZmVyZW5jZUV2ZW50KTsKLQkJYXNzZXJ0RXF1YWxzKHRoaXMudGVzdE5vZGUsIHRoaXMucHJlZmVyZW5jZUV2ZW50LmdldFNvdXJjZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKEtFWV9OQU1FLCB0aGlzLnByZWZlcmVuY2VFdmVudC5nZXRLZXkoKSk7Ci0JCWFzc2VydEVxdWFscyhuZXdWYWx1ZSwgdGhpcy5wcmVmZXJlbmNlRXZlbnQuZ2V0TmV3VmFsdWUoKSk7Ci0JCWFzc2VydEVxdWFscyhuZXdWYWx1ZSwgdGhpcy50ZXN0Tm9kZS5nZXQoS0VZX05BTUUsICI8bWlzc2luZyBwcmVmZXJlbmNlPiIpKTsKLQl9Ci0KLQlwcml2YXRlIGJvb2xlYW4gbm9kZUhhc0FueVByZWZMaXN0ZW5lcnMoUHJlZmVyZW5jZXMgbm9kZSkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVByZWZlcmVuY2VDaGFuZ2VMaXN0ZW5lcltdIHByZWZMaXN0ZW5lcnMgPSAoUHJlZmVyZW5jZUNoYW5nZUxpc3RlbmVyW10pIENsYXNzVG9vbHMuZmllbGRWYWx1ZShub2RlLCAicHJlZkxpc3RlbmVycyIpOwotCQlyZXR1cm4gcHJlZkxpc3RlbmVycy5sZW5ndGggPiAwOwotCX0KLQotCi0JLyoqCi0JICogVXNlIHRoaXMgYWRhcHRlciB0byB0ZXN0IG91dCBhbHdheXMgcGFzc2luZyB0aHJvdWdoIHRoZSBuZXcgdmFsdWUKLQkgKiB0byB0aGUgcHJlZmVyZW5jZS4KLQkgKi8KLQlwcml2YXRlIGNsYXNzIEFsd2F5c1VwZGF0ZVByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWw8UD4gZXh0ZW5kcyBQcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsPFA+IHsKLQotCQlBbHdheXNVcGRhdGVQcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsKFByb3BlcnR5VmFsdWVNb2RlbDxQcmVmZXJlbmNlcz4gcHJlZmVyZW5jZXNIb2xkZXIsIFN0cmluZyBrZXkpIHsKLQkJCXN1cGVyKHByZWZlcmVuY2VzSG9sZGVyLCBrZXkpOwotCQl9Ci0KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCBib29sZWFuIHNob3VsZFNldFByZWZlcmVuY2UoT2JqZWN0IG9sZFZhbHVlLCBPYmplY3QgbmV3VmFsdWUpIHsKLQkJCXJldHVybiB0cnVlOwotCQl9Ci0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvcHJlZnMvUHJlZmVyZW5jZXNDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3ByZWZzL1ByZWZlcmVuY2VzQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzYmQxYjQxLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvcHJlZnMvUHJlZmVyZW5jZXNDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyNzYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZS5wcmVmczsKLQotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uczsKLWltcG9ydCBqYXZhLnV0aWwuSGFzaE1hcDsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLk1hcDsKLWltcG9ydCBqYXZhLnV0aWwucHJlZnMuTm9kZUNoYW5nZUV2ZW50OwotaW1wb3J0IGphdmEudXRpbC5wcmVmcy5Ob2RlQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgamF2YS51dGlsLnByZWZzLlByZWZlcmVuY2VDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBqYXZhLnV0aWwucHJlZnMuUHJlZmVyZW5jZXM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUucHJlZnMuUHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5wcmVmcy5QcmVmZXJlbmNlc0NvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmV2ZW50LkNvbGxlY3Rpb25DaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5ldmVudC5Qcm9wZXJ0eUNoYW5nZUV2ZW50OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLQotcHVibGljIGNsYXNzIFByZWZlcmVuY2VzQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cyBleHRlbmRzIFByZWZlcmVuY2VzVGVzdENhc2UgewotCXByaXZhdGUgTWFwPFN0cmluZywgU3RyaW5nPiBleHBlY3RlZFZhbHVlczsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFByZWZlcmVuY2VzPiBub2RlSG9sZGVyOwotCVByZWZlcmVuY2VzQ29sbGVjdGlvblZhbHVlTW9kZWw8U3RyaW5nPiBwcmVmZXJlbmNlc0FkYXB0ZXI7Ci0JQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGV2ZW50OwotCUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcjsKLQlwcml2YXRlIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgaXRlbUxpc3RlbmVyOwotCWJvb2xlYW4gbGlzdGVuZXJSZW1vdmVkID0gZmFsc2U7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEtFWV9OQU1FXzEgPSAiZm9vIDEiOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBLRVlfTkFNRV8yID0gImZvbyAyIjsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgS0VZX05BTUVfMyA9ICJmb28gMyI7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIFNUUklOR19WQUxVRV8xID0gIm9yaWdpbmFsIHN0cmluZyB2YWx1ZSAxIjsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgU1RSSU5HX1ZBTFVFXzIgPSAib3JpZ2luYWwgc3RyaW5nIHZhbHVlIDIiOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBTVFJJTkdfVkFMVUVfMyA9ICJvcmlnaW5hbCBzdHJpbmcgdmFsdWUgMyI7Ci0KLQlwdWJsaWMgUHJlZmVyZW5jZXNDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMuZXhwZWN0ZWRWYWx1ZXMgPSBuZXcgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4oKTsKLQkJdGhpcy50ZXN0Tm9kZS5wdXQoS0VZX05BTUVfMSwgU1RSSU5HX1ZBTFVFXzEpOwl0aGlzLmV4cGVjdGVkVmFsdWVzLnB1dChLRVlfTkFNRV8xLCBTVFJJTkdfVkFMVUVfMSk7Ci0JCXRoaXMudGVzdE5vZGUucHV0KEtFWV9OQU1FXzIsIFNUUklOR19WQUxVRV8yKTsJdGhpcy5leHBlY3RlZFZhbHVlcy5wdXQoS0VZX05BTUVfMiwgU1RSSU5HX1ZBTFVFXzIpOwotCQl0aGlzLnRlc3ROb2RlLnB1dChLRVlfTkFNRV8zLCBTVFJJTkdfVkFMVUVfMyk7CXRoaXMuZXhwZWN0ZWRWYWx1ZXMucHV0KEtFWV9OQU1FXzMsIFNUUklOR19WQUxVRV8zKTsKLQotCQl0aGlzLm5vZGVIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPFByZWZlcmVuY2VzPih0aGlzLnRlc3ROb2RlKTsKLQkJdGhpcy5wcmVmZXJlbmNlc0FkYXB0ZXIgPSBuZXcgUHJlZmVyZW5jZXNDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+KHRoaXMubm9kZUhvbGRlcik7Ci0JCXRoaXMubGlzdGVuZXIgPSB0aGlzLmJ1aWxkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKCk7Ci0JCXRoaXMuaXRlbUxpc3RlbmVyID0gdGhpcy5idWlsZEl0ZW1MaXN0ZW5lcigpOwotCQl0aGlzLnByZWZlcmVuY2VzQWRhcHRlci5hZGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCB0aGlzLmxpc3RlbmVyKTsKLQkJdGhpcy5ldmVudCA9IG51bGw7Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIgYnVpbGRDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNoYW5nZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCQl0aGlzLmxvZ0V2ZW50KGUpOwotCQkJfQotCQkJcHVibGljIHZvaWQgY29sbGVjdGlvbkNsZWFyZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCQl0aGlzLmxvZ0V2ZW50KGUpOwotCQkJfQotCQkJcHVibGljIHZvaWQgaXRlbXNBZGRlZChDb2xsZWN0aW9uQ2hhbmdlRXZlbnQgZSkgewotCQkJCXRoaXMubG9nRXZlbnQoZSk7Ci0JCQl9Ci0JCQlwdWJsaWMgdm9pZCBpdGVtc1JlbW92ZWQoQ29sbGVjdGlvbkNoYW5nZUV2ZW50IGUpIHsKLQkJCQl0aGlzLmxvZ0V2ZW50KGUpOwotCQkJfQotCQkJcHJpdmF0ZSB2b2lkIGxvZ0V2ZW50KENvbGxlY3Rpb25DaGFuZ2VFdmVudCBlKSB7Ci0JCQkJaWYgKFByZWZlcmVuY2VzQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy50aGlzLmV2ZW50ICE9IG51bGwpIHsKLQkJCQkJdGhyb3cgbmV3IElsbGVnYWxTdGF0ZUV4Y2VwdGlvbigidW5leHBlY3RlZCB0aGlzLmV2ZW50OiAiICsgZSk7Ci0JCQkJfQotCQkJCVByZWZlcmVuY2VzQ29sbGVjdGlvblZhbHVlTW9kZWxUZXN0cy50aGlzLmV2ZW50ID0gZTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGRJdGVtTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHByb3BlcnR5Q2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbFN0YXRlRXhjZXB0aW9uKCJ1bmV4cGVjdGVkIHRoaXMuZXZlbnQ6ICIgKyBlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U3ViamVjdEhvbGRlcigpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLnZlcmlmeUFkYXB0ZXIodGhpcy5wcmVmZXJlbmNlc0FkYXB0ZXIpOwotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQpOwotCi0JCVN0cmluZyBBTk9USEVSX0tFWV9OQU1FXzEgPSAiYW5vdGhlciBrZXkgMSI7Ci0JCVN0cmluZyBBTk9USEVSX0tFWV9OQU1FXzIgPSAiYW5vdGhlciBrZXkgMiI7Ci0JCVN0cmluZyBBTk9USEVSX0tFWV9OQU1FXzMgPSAiYW5vdGhlciBrZXkgMyI7Ci0JCVN0cmluZyBBTk9USEVSX1NUUklOR19WQUxVRV8xID0gImFub3RoZXIgc3RyaW5nIHZhbHVlIDEiOwotCQlTdHJpbmcgQU5PVEhFUl9TVFJJTkdfVkFMVUVfMiA9ICJhbm90aGVyIHN0cmluZyB2YWx1ZSAyIjsKLQkJU3RyaW5nIEFOT1RIRVJfU1RSSU5HX1ZBTFVFXzMgPSAiYW5vdGhlciBzdHJpbmcgdmFsdWUgMyI7Ci0JCVByZWZlcmVuY2VzIGFub3RoZXJOb2RlID0gdGhpcy5jbGFzc05vZGUubm9kZSgiYW5vdGhlciB0ZXN0IG5vZGUiKTsKLQkJdGhpcy5leHBlY3RlZFZhbHVlcy5jbGVhcigpOwotCQlhbm90aGVyTm9kZS5wdXQoQU5PVEhFUl9LRVlfTkFNRV8xLCBBTk9USEVSX1NUUklOR19WQUxVRV8xKTsJdGhpcy5leHBlY3RlZFZhbHVlcy5wdXQoQU5PVEhFUl9LRVlfTkFNRV8xLCBBTk9USEVSX1NUUklOR19WQUxVRV8xKTsKLQkJYW5vdGhlck5vZGUucHV0KEFOT1RIRVJfS0VZX05BTUVfMiwgQU5PVEhFUl9TVFJJTkdfVkFMVUVfMik7CXRoaXMuZXhwZWN0ZWRWYWx1ZXMucHV0KEFOT1RIRVJfS0VZX05BTUVfMiwgQU5PVEhFUl9TVFJJTkdfVkFMVUVfMik7Ci0JCWFub3RoZXJOb2RlLnB1dChBTk9USEVSX0tFWV9OQU1FXzMsIEFOT1RIRVJfU1RSSU5HX1ZBTFVFXzMpOwl0aGlzLmV4cGVjdGVkVmFsdWVzLnB1dChBTk9USEVSX0tFWV9OQU1FXzMsIEFOT1RIRVJfU1RSSU5HX1ZBTFVFXzMpOwotCi0JCXRoaXMubm9kZUhvbGRlci5zZXRWYWx1ZShhbm90aGVyTm9kZSk7Ci0JCS8vIGNvbGxlY3Rpb25DaGFuZ2VkIGRvZXMgbm90IHBhc3MgYW55IGl0ZW1zIGluIHRoZSB0aGlzLmV2ZW50Ci0JCXRoaXMudmVyaWZ5RXZlbnQoQ29sbGVjdGlvbnMuPFN0cmluZywgU3RyaW5nPmVtcHR5TWFwKCkpOwotCQl0aGlzLnZlcmlmeUFkYXB0ZXIodGhpcy5wcmVmZXJlbmNlc0FkYXB0ZXIpOwotCQkKLQkJdGhpcy5ldmVudCA9IG51bGw7Ci0JCXRoaXMuZXhwZWN0ZWRWYWx1ZXMuY2xlYXIoKTsKLQkJdGhpcy5ub2RlSG9sZGVyLnNldFZhbHVlKG51bGwpOwotCQl0aGlzLnZlcmlmeUV2ZW50KHRoaXMuZXhwZWN0ZWRWYWx1ZXMpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnByZWZlcmVuY2VzQWRhcHRlci5pdGVyYXRvcigpLmhhc05leHQoKSk7Ci0JCQotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGhpcy5ub2RlSG9sZGVyLnNldFZhbHVlKHRoaXMudGVzdE5vZGUpOwotCQl0aGlzLnZlcmlmeUV2ZW50KENvbGxlY3Rpb25zLjxTdHJpbmcsIFN0cmluZz5lbXB0eU1hcCgpKTsKLQkJdGhpcy5leHBlY3RlZFZhbHVlcy5jbGVhcigpOwotCQl0aGlzLmV4cGVjdGVkVmFsdWVzLnB1dChLRVlfTkFNRV8xLCBTVFJJTkdfVkFMVUVfMSk7Ci0JCXRoaXMuZXhwZWN0ZWRWYWx1ZXMucHV0KEtFWV9OQU1FXzIsIFNUUklOR19WQUxVRV8yKTsKLQkJdGhpcy5leHBlY3RlZFZhbHVlcy5wdXQoS0VZX05BTUVfMywgU1RSSU5HX1ZBTFVFXzMpOwotCQl0aGlzLnZlcmlmeUFkYXB0ZXIodGhpcy5wcmVmZXJlbmNlc0FkYXB0ZXIpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RBZGRQcmVmZXJlbmNlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMudmVyaWZ5QWRhcHRlcih0aGlzLnByZWZlcmVuY2VzQWRhcHRlcik7Ci0JCWFzc2VydE51bGwodGhpcy5ldmVudCk7Ci0KLQkJU3RyaW5nIEFOT1RIRVJfS0VZX05BTUUgPSAiYW5vdGhlciBrZXkiOwotCQlTdHJpbmcgQU5PVEhFUl9TVFJJTkdfVkFMVUUgPSAiYW5vdGhlciBzdHJpbmcgdmFsdWUiOwotCQl0aGlzLnRlc3ROb2RlLnB1dChBTk9USEVSX0tFWV9OQU1FLCBBTk9USEVSX1NUUklOR19WQUxVRSk7Ci0JCXRoaXMud2FpdEZvckV2ZW50UXVldWVUb0NsZWFyKCk7Ci0JCU1hcDxTdHJpbmcsIFN0cmluZz4gZXhwZWN0ZWRJdGVtcyA9IG5ldyBIYXNoTWFwPFN0cmluZywgU3RyaW5nPigpOwotCQlleHBlY3RlZEl0ZW1zLnB1dChBTk9USEVSX0tFWV9OQU1FLCBBTk9USEVSX1NUUklOR19WQUxVRSk7Ci0JCXRoaXMudmVyaWZ5RXZlbnQoZXhwZWN0ZWRJdGVtcyk7Ci0JCXRoaXMuZXhwZWN0ZWRWYWx1ZXMucHV0KEFOT1RIRVJfS0VZX05BTUUsIEFOT1RIRVJfU1RSSU5HX1ZBTFVFKTsKLQkJdGhpcy52ZXJpZnlBZGFwdGVyKHRoaXMucHJlZmVyZW5jZXNBZGFwdGVyKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlUHJlZmVyZW5jZSgpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLnZlcmlmeUFkYXB0ZXIodGhpcy5wcmVmZXJlbmNlc0FkYXB0ZXIpOwotCQlhc3NlcnROdWxsKHRoaXMuZXZlbnQpOwotCi0JCXRoaXMudGVzdE5vZGUucmVtb3ZlKEtFWV9OQU1FXzIpOwotCQl0aGlzLndhaXRGb3JFdmVudFF1ZXVlVG9DbGVhcigpOwotCi0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudCk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnByZWZlcmVuY2VzQWRhcHRlciwgdGhpcy5ldmVudC5nZXRTb3VyY2UoKSk7Ci0JCWFzc2VydEVxdWFscyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMsIHRoaXMuZXZlbnQuZ2V0Q29sbGVjdGlvbk5hbWUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCB0aGlzLmV2ZW50Lml0ZW1zU2l6ZSgpKTsKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCVN0cmluZyBrZXkgPSAoKFByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPikgdGhpcy5ldmVudC5pdGVtcygpLm5leHQoKSkuZ2V0S2V5KCk7Ci0JCWFzc2VydEVxdWFscyhLRVlfTkFNRV8yLCBrZXkpOwotCi0JCXRoaXMuZXhwZWN0ZWRWYWx1ZXMucmVtb3ZlKEtFWV9OQU1FXzIpOwotCQl0aGlzLnZlcmlmeUFkYXB0ZXIodGhpcy5wcmVmZXJlbmNlc0FkYXB0ZXIpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDaGFuZ2VQcmVmZXJlbmNlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMudmVyaWZ5QWRhcHRlcih0aGlzLnByZWZlcmVuY2VzQWRhcHRlcik7Ci0JCWFzc2VydE51bGwodGhpcy5ldmVudCk7Ci0KLQkJU3RyaW5nIERJRkZFUkVOVCA9ICJzb21ldGhpbmcgY29tcGxldGVseSBkaWZmZXJlbnQiOwotCQl0aGlzLnRlc3ROb2RlLnB1dChLRVlfTkFNRV8yLCBESUZGRVJFTlQpOwotCQl0aGlzLndhaXRGb3JFdmVudFF1ZXVlVG9DbGVhcigpOwotCi0JCWFzc2VydE51bGwodGhpcy5ldmVudCk7Ci0KLQkJdGhpcy5leHBlY3RlZFZhbHVlcy5wdXQoS0VZX05BTUVfMiwgRElGRkVSRU5UKTsKLQkJdGhpcy52ZXJpZnlBZGFwdGVyKHRoaXMucHJlZmVyZW5jZXNBZGFwdGVyKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VmFsdWVzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMudmVyaWZ5Tm9kZSh0aGlzLnRlc3ROb2RlKTsKLQkJdGhpcy52ZXJpZnlBZGFwdGVyKHRoaXMucHJlZmVyZW5jZXNBZGFwdGVyKTsKLQl9Ci0KLQkvKioKLQkgKiB0ZXN0IGEgc2l0dWF0aW9uIHdoZXJlCi0JICogLSB3ZSBhcmUgbGlzdGVuaW5nIHRvIHRoZSBub2RlIHdoZW4gaXQgZ2V0cyByZW1vdmVkIGZyb20gdGhlIHByZWZlcmVuY2VzICJyZXBvc2l0b3J5IgotCSAqIC0gd2UgZ2V0IG5vdGlmaWNhdGlvbiB0aGF0IGl0IGhhcyBiZWVuIHJlbW92ZWQKLQkgKiAtIHdlIHRyeSB0byByZW1vdmUgb3VyIHRoaXMubGlzdGVuZXIKLQkgKiAtIHRoZSBub2RlIHdpbGwgdGhyb3cgYW4gSWxsZWdhbFN0YXRlRXhjZXB0aW9uIC0gdGhlIGFkYXB0ZXIgc2hvdWxkIGhhbmRsZSBpdCBPSy4uLgotCSAqLwotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVOb2RlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWFzc2VydFRydWUodGhpcy5wcmVmZXJlbmNlc0FkYXB0ZXIuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMpKTsKLQotCQlQcmVmZXJlbmNlcyBwYXJlbnQgPSB0aGlzLnRlc3ROb2RlLnBhcmVudCgpOwotCQlwYXJlbnQuYWRkTm9kZUNoYW5nZUxpc3RlbmVyKHRoaXMuYnVpbGRQYXJlbnROb2RlQ2hhbmdlTGlzdGVuZXIoKSk7Ci0JCXRoaXMudGVzdE5vZGUucmVtb3ZlTm9kZSgpOwotCQl0aGlzLnRlc3ROb2RlLmZsdXNoKCk7CQkvLyB0aGlzIHNlZW1zIHRvIGJlIHJlcXVpcmVkIGZvciB0aGUgdGhpcy5ldmVudCB0byB0cmlnZ2VyLi4uCi0JCXRoaXMud2FpdEZvckV2ZW50UXVldWVUb0NsZWFyKCk7Ci0KLQkJYXNzZXJ0VHJ1ZSh0aGlzLmxpc3RlbmVyUmVtb3ZlZCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMucHJlZmVyZW5jZXNBZGFwdGVyLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTKSk7Ci0JfQotCi0JcHJpdmF0ZSBOb2RlQ2hhbmdlTGlzdGVuZXIgYnVpbGRQYXJlbnROb2RlQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgTm9kZUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgY2hpbGRBZGRlZChOb2RlQ2hhbmdlRXZlbnQgZSkgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oInVuZXhwZWN0ZWQgdGhpcy5ldmVudDogIiArIGUpOwotCQkJfQotCQkJcHVibGljIHZvaWQgY2hpbGRSZW1vdmVkKE5vZGVDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJaWYgKGUuZ2V0Q2hpbGQoKSA9PSBQcmVmZXJlbmNlc0NvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMudGhpcy50ZXN0Tm9kZSkgewotCQkJCQlQcmVmZXJlbmNlc0NvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMudGhpcy5wcmVmZXJlbmNlc0FkYXB0ZXIucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgUHJlZmVyZW5jZXNDb2xsZWN0aW9uVmFsdWVNb2RlbFRlc3RzLnRoaXMubGlzdGVuZXIpOwotCQkJCQkvLyB0aGlzIGxpbmUgb2YgY29kZSB3aWxsIG5vdCBleGVjdXRlIGlmIHRoZSBsaW5lIGFib3ZlIHRyaWdnZXJzIGFuIGV4Y2VwdGlvbgotCQkJCQlQcmVmZXJlbmNlc0NvbGxlY3Rpb25WYWx1ZU1vZGVsVGVzdHMudGhpcy5saXN0ZW5lclJlbW92ZWQgPSB0cnVlOwotCQkJCX0KLQkJCX0KLQkJfTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWFzc2VydFRydWUodGhpcy5wcmVmZXJlbmNlc0FkYXB0ZXIuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLm5vZGVIYXNBbnlQcmVmTGlzdGVuZXJzKHRoaXMudGVzdE5vZGUpKTsKLQkJdGhpcy5wcmVmZXJlbmNlc0FkYXB0ZXIucmVtb3ZlQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUywgdGhpcy5saXN0ZW5lcik7Ci0JCWFzc2VydEZhbHNlKHRoaXMubm9kZUhhc0FueVByZWZMaXN0ZW5lcnModGhpcy50ZXN0Tm9kZSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnByZWZlcmVuY2VzQWRhcHRlci5oYXNBbnlDb2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENvbGxlY3Rpb25WYWx1ZU1vZGVsLlZBTFVFUykpOwotCi0JCUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcjIgPSB0aGlzLmJ1aWxkQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVyKCk7Ci0JCXRoaXMucHJlZmVyZW5jZXNBZGFwdGVyLmFkZENvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcjIpOwotCQlhc3NlcnRUcnVlKHRoaXMucHJlZmVyZW5jZXNBZGFwdGVyLmhhc0FueUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcnMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTKSk7Ci0JCWFzc2VydFRydWUodGhpcy5ub2RlSGFzQW55UHJlZkxpc3RlbmVycyh0aGlzLnRlc3ROb2RlKSk7Ci0JCXRoaXMucHJlZmVyZW5jZXNBZGFwdGVyLnJlbW92ZUNvbGxlY3Rpb25DaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcjIpOwotCQlhc3NlcnRGYWxzZSh0aGlzLm5vZGVIYXNBbnlQcmVmTGlzdGVuZXJzKHRoaXMudGVzdE5vZGUpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5wcmVmZXJlbmNlc0FkYXB0ZXIuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDb2xsZWN0aW9uVmFsdWVNb2RlbC5WQUxVRVMpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5RXZlbnQoTWFwPFN0cmluZywgU3RyaW5nPiBpdGVtcykgewotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQpOwotCQlhc3NlcnRFcXVhbHModGhpcy5wcmVmZXJlbmNlc0FkYXB0ZXIsIHRoaXMuZXZlbnQuZ2V0U291cmNlKCkpOwotCQlhc3NlcnRFcXVhbHMoQ29sbGVjdGlvblZhbHVlTW9kZWwuVkFMVUVTLCB0aGlzLmV2ZW50LmdldENvbGxlY3Rpb25OYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoaXRlbXMuc2l6ZSgpLCB0aGlzLmV2ZW50Lml0ZW1zU2l6ZSgpKTsKLQkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JCUl0ZXJhdG9yPFByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPj4gZXZlbnRJdGVtcyA9IChJdGVyYXRvcjxQcmVmZXJlbmNlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4+KSB0aGlzLmV2ZW50Lml0ZW1zKCk7Ci0JCXRoaXMudmVyaWZ5SXRlbXMoaXRlbXMsIGV2ZW50SXRlbXMpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlOb2RlKFByZWZlcmVuY2VzIG5vZGUpIHRocm93cyBFeGNlcHRpb24gewotCQlTdHJpbmdbXSBrZXlzID0gbm9kZS5rZXlzKCk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLmV4cGVjdGVkVmFsdWVzLnNpemUoKSwga2V5cy5sZW5ndGgpOwotCQlmb3IgKGludCBpID0gMDsgaSA8IGtleXMubGVuZ3RoOyBpKyspIHsKLQkJCWFzc2VydEVxdWFscyh0aGlzLmV4cGVjdGVkVmFsdWVzLmdldChrZXlzW2ldKSwgbm9kZS5nZXQoa2V5c1tpXSwgIjxtaXNzaW5nIHByZWZlcmVuY2U+IikpOwotCQl9Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUFkYXB0ZXIoUHJlZmVyZW5jZXNDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+IGN2bSkgewotCQlhc3NlcnRFcXVhbHModGhpcy5leHBlY3RlZFZhbHVlcy5zaXplKCksIGN2bS5zaXplKCkpOwotCQl0aGlzLnZlcmlmeUl0ZW1zKHRoaXMuZXhwZWN0ZWRWYWx1ZXMsIGN2bS5pdGVyYXRvcigpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5SXRlbXMoTWFwPFN0cmluZywgU3RyaW5nPiBleHBlY3RlZCwgSXRlcmF0b3I8UHJlZmVyZW5jZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+PiBzdHJlYW0pIHsKLQkJd2hpbGUgKHN0cmVhbS5oYXNOZXh0KCkpIHsKLQkJCVByZWZlcmVuY2VQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBtb2RlbCA9IHN0cmVhbS5uZXh0KCk7Ci0JCQltb2RlbC5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSwgdGhpcy5pdGVtTGlzdGVuZXIpOwotCQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLmdldChtb2RlbC5nZXRLZXkoKSksIG1vZGVsLmdldFZhbHVlKCkpOwotCQkJbW9kZWwucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMuaXRlbUxpc3RlbmVyKTsKLQkJfQotCX0KLQotCXByaXZhdGUgYm9vbGVhbiBub2RlSGFzQW55UHJlZkxpc3RlbmVycyhQcmVmZXJlbmNlcyBub2RlKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJUHJlZmVyZW5jZUNoYW5nZUxpc3RlbmVyW10gcHJlZkxpc3RlbmVycyA9IChQcmVmZXJlbmNlQ2hhbmdlTGlzdGVuZXJbXSkgQ2xhc3NUb29scy5maWVsZFZhbHVlKG5vZGUsICJwcmVmTGlzdGVuZXJzIik7Ci0JCXJldHVybiBwcmVmTGlzdGVuZXJzLmxlbmd0aCA+IDA7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3ByZWZzL1ByZWZlcmVuY2VzVGVzdENhc2UuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvcHJlZnMvUHJlZmVyZW5jZXNUZXN0Q2FzZS5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjZTRjMzA0Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvcHJlZnMvUHJlZmVyZW5jZXNUZXN0Q2FzZS5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsODUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZS5wcmVmczsKLQotaW1wb3J0IGphdmEudXRpbC5FdmVudE9iamVjdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwucHJlZnMuQWJzdHJhY3RQcmVmZXJlbmNlczsKLWltcG9ydCBqYXZhLnV0aWwucHJlZnMuUHJlZmVyZW5jZXM7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi0vKioKLSAqIHNldCB1cCBhbmQgdGVhciBkb3duIGEgdGVzdCBub2RlIGZvciBhbnkgc3ViY2xhc3MgdGhhdAotICogbmVlZHMgdG8gdGVzdCBwcmVmZXJlbmNlcy1yZWxhdGVkIHN0dWZmCi0gKi8KLXB1YmxpYyBhYnN0cmFjdCBjbGFzcyBQcmVmZXJlbmNlc1Rlc3RDYXNlIGV4dGVuZHMgVGVzdENhc2UgewotCXByb3RlY3RlZCBQcmVmZXJlbmNlcyBjbGFzc05vZGU7Ci0JcHVibGljIFByZWZlcmVuY2VzIHRlc3ROb2RlOwotCXByb3RlY3RlZCBzdGF0aWMgZmluYWwgU3RyaW5nIFRFU1RfTk9ERV9OQU1FID0gInRlc3Qgbm9kZSI7Ci0KLQlwdWJsaWMgUHJlZmVyZW5jZXNUZXN0Q2FzZShTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQlQcmVmZXJlbmNlcyBwYWNrYWdlTm9kZSA9IFByZWZlcmVuY2VzLnVzZXJOb2RlRm9yUGFja2FnZSh0aGlzLmdldENsYXNzKCkpOwotCQl0aGlzLmNsYXNzTm9kZSA9IHBhY2thZ2VOb2RlLm5vZGUoQ2xhc3NUb29scy5zaG9ydENsYXNzTmFtZUZvck9iamVjdCh0aGlzKSk7Ci0JCS8vIGNsZWFuIG91dCBhbnkgbGVmdG92ZXIgY3JhcC4uLgotCQlpZiAoKHRoaXMuY2xhc3NOb2RlLmtleXMoKS5sZW5ndGggPiAwKSB8fCAodGhpcy5jbGFzc05vZGUuY2hpbGRyZW5OYW1lcygpLmxlbmd0aCA+IDApKSB7Ci0JCQl0aGlzLmNsYXNzTm9kZS5yZW1vdmVOb2RlKCk7Ci0JCQkvLyAuLi5hbmQgcmUtY3JlYXRlIHRoZSBub2RlCi0JCQl0aGlzLmNsYXNzTm9kZSA9IHBhY2thZ2VOb2RlLm5vZGUoQ2xhc3NUb29scy5zaG9ydENsYXNzTmFtZUZvck9iamVjdCh0aGlzKSk7Ci0JCX0KLQkJdGhpcy50ZXN0Tm9kZSA9IHRoaXMuY2xhc3NOb2RlLm5vZGUoVEVTVF9OT0RFX05BTUUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCS8vIHdhaXQgZm9yIGFsbCB0aGUgZXZlbnRzIHRvIGJlIGRlbGl2ZXJlZCBiZWZvcmUgdGVhcmluZyBkb3duCi0JCXRoaXMud2FpdEZvckV2ZW50UXVldWVUb0NsZWFyKCk7Ci0JCVByZWZlcmVuY2VzIG5vZGUgPSB0aGlzLmNsYXNzTm9kZS5wYXJlbnQoKTsKLQkJdGhpcy5jbGFzc05vZGUucmVtb3ZlTm9kZSgpOwotCQl3aGlsZSAodGhpcy5ub2RlSXNWZXN0aWdpYWwobm9kZSkpIHsKLQkJCVByZWZlcmVuY2VzIHBhcmVudCA9IG5vZGUucGFyZW50KCk7Ci0JCQlub2RlLnJlbW92ZU5vZGUoKTsKLQkJCW5vZGUgPSBwYXJlbnQ7Ci0JCX0KLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXByaXZhdGUgYm9vbGVhbiBub2RlSXNWZXN0aWdpYWwoUHJlZmVyZW5jZXMgbm9kZSkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXJldHVybiAobm9kZSAhPSBudWxsKQotCQkJJiYgKG5vZGUua2V5cygpLmxlbmd0aCA9PSAwKQotCQkJJiYgKG5vZGUuY2hpbGRyZW5OYW1lcygpLmxlbmd0aCA9PSAwKQotCQkJJiYgKG5vZGUgIT0gUHJlZmVyZW5jZXMudXNlclJvb3QoKSk7Ci0JfQotCi0JcHJvdGVjdGVkIHZvaWQgd2FpdEZvckV2ZW50UXVldWVUb0NsZWFyKCkgewotCQl0cnkgewotCQkJd2hpbGUgKCAhIHRoaXMucHJlZmVyZW5jZXNFdmVudFF1ZXVlKCkuaXNFbXB0eSgpKSB7Ci0JCQkJVGhyZWFkLnNsZWVwKDEwMCk7Ci0JCQl9Ci0JCQlUaHJlYWQuc2xlZXAoMTAwKTsKLQkJfSBjYXRjaCAoSW50ZXJydXB0ZWRFeGNlcHRpb24gZXgpIHsKLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKGV4KTsKLQkJfQotCX0KLQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCXByaXZhdGUgTGlzdDxFdmVudE9iamVjdD4gcHJlZmVyZW5jZXNFdmVudFF1ZXVlKCkgewotCQlyZXR1cm4gKExpc3Q8RXZlbnRPYmplY3Q+KSBDbGFzc1Rvb2xzLnN0YXRpY0ZpZWxkVmFsdWUoQWJzdHJhY3RQcmVmZXJlbmNlcy5jbGFzcywgImV2ZW50UXVldWUiKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvQ2hlY2tCb3hNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9DaGVja0JveE1vZGVsQWRhcHRlclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQzMDI0NTguLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9DaGVja0JveE1vZGVsQWRhcHRlclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxMzQgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZzsKLQotaW1wb3J0IGphdmF4LnN3aW5nLkJ1dHRvbk1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LkNoYW5nZUV2ZW50OwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LkV2ZW50TGlzdGVuZXJMaXN0OwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5DbGFzc1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5DaGVja0JveE1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5UZXN0VG9vbHM7Ci0KLXB1YmxpYyBjbGFzcyBDaGVja0JveE1vZGVsQWRhcHRlclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYm9vbGVhbkhvbGRlcjsKLQlwcml2YXRlIEJ1dHRvbk1vZGVsIGJ1dHRvbk1vZGVsQWRhcHRlcjsKLQlib29sZWFuIGV2ZW50RmlyZWQ7Ci0KLQlwdWJsaWMgQ2hlY2tCb3hNb2RlbEFkYXB0ZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLmJvb2xlYW5Ib2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+KEJvb2xlYW4uVFJVRSk7Ci0JCXRoaXMuYnV0dG9uTW9kZWxBZGFwdGVyID0gbmV3IENoZWNrQm94TW9kZWxBZGFwdGVyKHRoaXMuYm9vbGVhbkhvbGRlcikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZEJvb2xlYW5DaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCQlyZXR1cm4gdGhpcy5idWlsZEJvb2xlYW5DaGFuZ2VMaXN0ZW5lcl8oKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNldFNlbGVjdGVkKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuZXZlbnRGaXJlZCA9IGZhbHNlOwotCQl0aGlzLmJ1dHRvbk1vZGVsQWRhcHRlci5hZGRDaGFuZ2VMaXN0ZW5lcihuZXcgVGVzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoQ2hhbmdlRXZlbnQgZSkgewotCQkJCUNoZWNrQm94TW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCX0KLQkJfSk7Ci0JCXRoaXMuYnV0dG9uTW9kZWxBZGFwdGVyLnNldFNlbGVjdGVkKGZhbHNlKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmV2ZW50RmlyZWQpOwotCQlhc3NlcnRFcXVhbHMoQm9vbGVhbi5GQUxTRSwgdGhpcy5ib29sZWFuSG9sZGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRWYWx1ZSgpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmV2ZW50RmlyZWQgPSBmYWxzZTsKLQkJdGhpcy5idXR0b25Nb2RlbEFkYXB0ZXIuYWRkQ2hhbmdlTGlzdGVuZXIobmV3IFRlc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgc3RhdGVDaGFuZ2VkKENoYW5nZUV2ZW50IGUpIHsKLQkJCQlDaGVja0JveE1vZGVsQWRhcHRlclRlc3RzLnRoaXMuZXZlbnRGaXJlZCA9IHRydWU7Ci0JCQl9Ci0JCX0pOwotCQlhc3NlcnRUcnVlKHRoaXMuYnV0dG9uTW9kZWxBZGFwdGVyLmlzU2VsZWN0ZWQoKSk7Ci0JCXRoaXMuYm9vbGVhbkhvbGRlci5zZXRWYWx1ZShCb29sZWFuLkZBTFNFKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmV2ZW50RmlyZWQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJ1dHRvbk1vZGVsQWRhcHRlci5pc1NlbGVjdGVkKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3REZWZhdWx0VmFsdWUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5ldmVudEZpcmVkID0gZmFsc2U7Ci0JCXRoaXMuYnV0dG9uTW9kZWxBZGFwdGVyLmFkZENoYW5nZUxpc3RlbmVyKG5ldyBUZXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHN0YXRlQ2hhbmdlZChDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJQ2hlY2tCb3hNb2RlbEFkYXB0ZXJUZXN0cy50aGlzLmV2ZW50RmlyZWQgPSB0cnVlOwotCQkJfQotCQl9KTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJ1dHRvbk1vZGVsQWRhcHRlci5pc1NlbGVjdGVkKCkpOwotCQl0aGlzLmJvb2xlYW5Ib2xkZXIuc2V0VmFsdWUobnVsbCk7Ci0JCWFzc2VydFRydWUodGhpcy5ldmVudEZpcmVkKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5idXR0b25Nb2RlbEFkYXB0ZXIuaXNTZWxlY3RlZCgpKTsKLQotCQl0aGlzLmV2ZW50RmlyZWQgPSBmYWxzZTsKLQkJdGhpcy5ib29sZWFuSG9sZGVyLnNldFZhbHVlKEJvb2xlYW4uRkFMU0UpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmV2ZW50RmlyZWQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJ1dHRvbk1vZGVsQWRhcHRlci5pc1NlbGVjdGVkKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNMaXN0ZW5lcnMoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGxvY2FsQm9vbGVhbkhvbGRlciA9IChTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4pIHRoaXMuYm9vbGVhbkhvbGRlcjsKLQkJYXNzZXJ0RmFsc2UobG9jYWxCb29sZWFuSG9sZGVyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQl0aGlzLnZlcmlmeUhhc05vTGlzdGVuZXJzKHRoaXMuYnV0dG9uTW9kZWxBZGFwdGVyKTsKLQotCQlDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBUZXN0Q2hhbmdlTGlzdGVuZXIoKTsKLQkJdGhpcy5idXR0b25Nb2RlbEFkYXB0ZXIuYWRkQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKGxvY2FsQm9vbGVhbkhvbGRlci5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJdGhpcy52ZXJpZnlIYXNMaXN0ZW5lcnModGhpcy5idXR0b25Nb2RlbEFkYXB0ZXIpOwotCi0JCXRoaXMuYnV0dG9uTW9kZWxBZGFwdGVyLnJlbW92ZUNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJYXNzZXJ0RmFsc2UobG9jYWxCb29sZWFuSG9sZGVyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQl0aGlzLnZlcmlmeUhhc05vTGlzdGVuZXJzKHRoaXMuYnV0dG9uTW9kZWxBZGFwdGVyKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5SGFzTm9MaXN0ZW5lcnMoT2JqZWN0IG1vZGVsKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJRXZlbnRMaXN0ZW5lckxpc3QgbGlzdGVuZXJMaXN0ID0gKEV2ZW50TGlzdGVuZXJMaXN0KSBDbGFzc1Rvb2xzLmZpZWxkVmFsdWUobW9kZWwsICJsaXN0ZW5lckxpc3QiKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIGxpc3RlbmVyTGlzdC5nZXRMaXN0ZW5lckxpc3QoKS5sZW5ndGgpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlIYXNMaXN0ZW5lcnMoT2JqZWN0IG1vZGVsKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJRXZlbnRMaXN0ZW5lckxpc3QgbGlzdGVuZXJMaXN0ID0gKEV2ZW50TGlzdGVuZXJMaXN0KSBDbGFzc1Rvb2xzLmZpZWxkVmFsdWUobW9kZWwsICJsaXN0ZW5lckxpc3QiKTsKLQkJYXNzZXJ0RmFsc2UobGlzdGVuZXJMaXN0LmdldExpc3RlbmVyTGlzdCgpLmxlbmd0aCA9PSAwKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogbWVtYmVyIGNsYXNzICoqKioqKioqKioKLQlwcml2YXRlIGNsYXNzIFRlc3RDaGFuZ2VMaXN0ZW5lciBpbXBsZW1lbnRzIENoYW5nZUxpc3RlbmVyIHsKLQkJVGVzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoQ2hhbmdlRXZlbnQgZSkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0NoZWNrQm94TW9kZWxBZGFwdGVyVUlUZXN0LmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0NoZWNrQm94TW9kZWxBZGFwdGVyVUlUZXN0LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGMzYmMzNzMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9DaGVja0JveE1vZGVsQWRhcHRlclVJVGVzdC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzEzICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmc7Ci0KLWltcG9ydCBqYXZhLmF3dC5Cb3JkZXJMYXlvdXQ7Ci1pbXBvcnQgamF2YS5hd3QuQ29tcG9uZW50OwotaW1wb3J0IGphdmEuYXd0LkdyaWRMYXlvdXQ7Ci1pbXBvcnQgamF2YS5hd3QuZXZlbnQuQWN0aW9uRXZlbnQ7Ci1pbXBvcnQgamF2YS5hd3QuZXZlbnQuSXRlbUV2ZW50OwotaW1wb3J0IGphdmEuYXd0LmV2ZW50Lkl0ZW1MaXN0ZW5lcjsKLWltcG9ydCBqYXZhLmF3dC5ldmVudC5XaW5kb3dBZGFwdGVyOwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LldpbmRvd0V2ZW50OwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LldpbmRvd0xpc3RlbmVyOwotaW1wb3J0IGphdmF4LnN3aW5nLkFic3RyYWN0QWN0aW9uOwotaW1wb3J0IGphdmF4LnN3aW5nLkFjdGlvbjsKLWltcG9ydCBqYXZheC5zd2luZy5CdXR0b25Nb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy5KQnV0dG9uOwotaW1wb3J0IGphdmF4LnN3aW5nLkpDaGVja0JveDsKLWltcG9ydCBqYXZheC5zd2luZy5KRnJhbWU7Ci1pbXBvcnQgamF2YXguc3dpbmcuSlBhbmVsOwotaW1wb3J0IGphdmF4LnN3aW5nLldpbmRvd0NvbnN0YW50czsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuQ2hlY2tCb3hNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotCi0vKioKLSAqIFBsYXkgYXJvdW5kIHdpdGggYSBzZXQgb2YgY2hlY2sgYm94ZXMuCi0gKi8KLXB1YmxpYyBjbGFzcyBDaGVja0JveE1vZGVsQWRhcHRlclVJVGVzdCB7Ci0KLQlwcml2YXRlIFRlc3RNb2RlbCB0ZXN0TW9kZWw7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUZXN0TW9kZWw+IHRlc3RNb2RlbEhvbGRlcjsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGZsYWcxSG9sZGVyOwotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gZmxhZzJIb2xkZXI7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxCb29sZWFuPiBub3RGbGFnMkhvbGRlcjsKLQlwcml2YXRlIEJ1dHRvbk1vZGVsIGZsYWcxQnV0dG9uTW9kZWw7Ci0JcHJpdmF0ZSBCdXR0b25Nb2RlbCBmbGFnMkJ1dHRvbk1vZGVsOwotCXByaXZhdGUgQnV0dG9uTW9kZWwgbm90RmxhZzJCdXR0b25Nb2RlbDsKLQotCXB1YmxpYyBzdGF0aWMgdm9pZCBtYWluKFN0cmluZ1tdIGFyZ3MpIHRocm93cyBFeGNlcHRpb24gewotCQluZXcgQ2hlY2tCb3hNb2RlbEFkYXB0ZXJVSVRlc3QoKS5leGVjKGFyZ3MpOwotCX0KLQotCXByaXZhdGUgQ2hlY2tCb3hNb2RlbEFkYXB0ZXJVSVRlc3QoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGV4ZWMoU3RyaW5nW10gYXJncykgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMudGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbCh0cnVlLCB0cnVlKTsKLQkJdGhpcy50ZXN0TW9kZWxIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4odGhpcy50ZXN0TW9kZWwpOwotCQl0aGlzLmZsYWcxSG9sZGVyID0gdGhpcy5idWlsZEZsYWcxSG9sZGVyKHRoaXMudGVzdE1vZGVsSG9sZGVyKTsKLQkJdGhpcy5mbGFnMUJ1dHRvbk1vZGVsID0gdGhpcy5idWlsZENoZWNrQm94TW9kZWxBZGFwdGVyKHRoaXMuZmxhZzFIb2xkZXIpOwotCQl0aGlzLmZsYWcySG9sZGVyID0gdGhpcy5idWlsZEZsYWcySG9sZGVyKHRoaXMudGVzdE1vZGVsSG9sZGVyKTsKLQkJdGhpcy5mbGFnMkJ1dHRvbk1vZGVsID0gdGhpcy5idWlsZENoZWNrQm94TW9kZWxBZGFwdGVyKHRoaXMuZmxhZzJIb2xkZXIpOwotCQl0aGlzLm5vdEZsYWcySG9sZGVyID0gdGhpcy5idWlsZE5vdEZsYWcySG9sZGVyKHRoaXMudGVzdE1vZGVsSG9sZGVyKTsKLQkJdGhpcy5ub3RGbGFnMkJ1dHRvbk1vZGVsID0gdGhpcy5idWlsZENoZWNrQm94TW9kZWxBZGFwdGVyKHRoaXMubm90RmxhZzJIb2xkZXIpOwotCQl0aGlzLm9wZW5XaW5kb3coKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkRmxhZzFIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4gdm0pIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VGVzdE1vZGVsLCBCb29sZWFuPih2bSwgVGVzdE1vZGVsLkZMQUcxX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBCb29sZWFuLnZhbHVlT2YodGhpcy5zdWJqZWN0LmlzRmxhZzEoKSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldEZsYWcxKHZhbHVlLmJvb2xlYW5WYWx1ZSgpKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkRmxhZzJIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4gdm0pIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VGVzdE1vZGVsLCBCb29sZWFuPih2bSwgVGVzdE1vZGVsLkZMQUcyX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBCb29sZWFuIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiBCb29sZWFuLnZhbHVlT2YodGhpcy5zdWJqZWN0LmlzRmxhZzIoKSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldEZsYWcyKHZhbHVlLmJvb2xlYW5WYWx1ZSgpKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJ1aWxkTm90RmxhZzJIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4gdm0pIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VGVzdE1vZGVsLCBCb29sZWFuPih2bSwgVGVzdE1vZGVsLk5PVF9GTEFHMl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gQm9vbGVhbi52YWx1ZU9mKHRoaXMuc3ViamVjdC5pc05vdEZsYWcyKCkpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oQm9vbGVhbiB2YWx1ZSkgewotCQkJCXRoaXMuc3ViamVjdC5zZXROb3RGbGFnMih2YWx1ZS5ib29sZWFuVmFsdWUoKSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBCdXR0b25Nb2RlbCBidWlsZENoZWNrQm94TW9kZWxBZGFwdGVyKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPEJvb2xlYW4+IGJvb2xlYW5Ib2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBDaGVja0JveE1vZGVsQWRhcHRlcihib29sZWFuSG9sZGVyKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgb3BlbldpbmRvdygpIHsKLQkJSkZyYW1lIHdpbmRvdyA9IG5ldyBKRnJhbWUodGhpcy5nZXRDbGFzcygpLmdldE5hbWUoKSk7Ci0JCXdpbmRvdy5zZXREZWZhdWx0Q2xvc2VPcGVyYXRpb24oV2luZG93Q29uc3RhbnRzLkRPX05PVEhJTkdfT05fQ0xPU0UpOwotCQl3aW5kb3cuYWRkV2luZG93TGlzdGVuZXIodGhpcy5idWlsZFdpbmRvd0xpc3RlbmVyKCkpOwotCQl3aW5kb3cuZ2V0Q29udGVudFBhbmUoKS5hZGQodGhpcy5idWlsZE1haW5QYW5lbCgpLCAiQ2VudGVyIik7Ci0JCXdpbmRvdy5zZXRTaXplKDQwMCwgMTAwKTsKLQkJd2luZG93LnNldFZpc2libGUodHJ1ZSk7Ci0JfQotCi0JcHJpdmF0ZSBXaW5kb3dMaXN0ZW5lciBidWlsZFdpbmRvd0xpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFdpbmRvd0FkYXB0ZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHdpbmRvd0Nsb3NpbmcoV2luZG93RXZlbnQgZSkgewotCQkJCWUuZ2V0V2luZG93KCkuc2V0VmlzaWJsZShmYWxzZSk7Ci0JCQkJU3lzdGVtLmV4aXQoMCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRNYWluUGFuZWwoKSB7Ci0JCUpQYW5lbCBtYWluUGFuZWwgPSBuZXcgSlBhbmVsKG5ldyBCb3JkZXJMYXlvdXQoKSk7Ci0JCW1haW5QYW5lbC5hZGQodGhpcy5idWlsZENoZWNrQm94UGFuZWwoKSwgQm9yZGVyTGF5b3V0Lk5PUlRIKTsKLQkJbWFpblBhbmVsLmFkZCh0aGlzLmJ1aWxkQ29udHJvbFBhbmVsKCksIEJvcmRlckxheW91dC5TT1VUSCk7Ci0JCXJldHVybiBtYWluUGFuZWw7Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRDaGVja0JveFBhbmVsKCkgewotCQlKUGFuZWwgdGFza0xpc3RQYW5lbCA9IG5ldyBKUGFuZWwobmV3IEdyaWRMYXlvdXQoMSwgMCkpOwotCQl0YXNrTGlzdFBhbmVsLmFkZCh0aGlzLmJ1aWxkRmxhZzFDaGVja0JveCgpKTsKLQkJdGFza0xpc3RQYW5lbC5hZGQodGhpcy5idWlsZEZsYWcyQ2hlY2tCb3goKSk7Ci0JCXRhc2tMaXN0UGFuZWwuYWRkKHRoaXMuYnVpbGROb3RGbGFnMkNoZWNrQm94KCkpOwotCQl0YXNrTGlzdFBhbmVsLmFkZCh0aGlzLmJ1aWxkVW5hdHRhY2hlZENoZWNrQm94KCkpOwotCQlyZXR1cm4gdGFza0xpc3RQYW5lbDsKLQl9Ci0KLQlwcml2YXRlIEpDaGVja0JveCBidWlsZEZsYWcxQ2hlY2tCb3goKSB7Ci0JCUpDaGVja0JveCBjaGVja0JveCA9IG5ldyBKQ2hlY2tCb3goKTsKLQkJY2hlY2tCb3guc2V0VGV4dCgiZmxhZyAxIik7Ci0JCWNoZWNrQm94LnNldE1vZGVsKHRoaXMuZmxhZzFCdXR0b25Nb2RlbCk7Ci0JCXJldHVybiBjaGVja0JveDsKLQl9Ci0KLQlwcml2YXRlIEpDaGVja0JveCBidWlsZEZsYWcyQ2hlY2tCb3goKSB7Ci0JCUpDaGVja0JveCBjaGVja0JveCA9IG5ldyBKQ2hlY2tCb3goKTsKLQkJY2hlY2tCb3guc2V0VGV4dCgiZmxhZyAyIik7Ci0JCWNoZWNrQm94LnNldE1vZGVsKHRoaXMuZmxhZzJCdXR0b25Nb2RlbCk7Ci0JCXJldHVybiBjaGVja0JveDsKLQl9Ci0KLQlwcml2YXRlIEpDaGVja0JveCBidWlsZE5vdEZsYWcyQ2hlY2tCb3goKSB7Ci0JCUpDaGVja0JveCBjaGVja0JveCA9IG5ldyBKQ2hlY2tCb3goKTsKLQkJY2hlY2tCb3guc2V0VGV4dCgibm90IGZsYWcgMiIpOwotCQljaGVja0JveC5zZXRNb2RlbCh0aGlzLm5vdEZsYWcyQnV0dG9uTW9kZWwpOwotCQlyZXR1cm4gY2hlY2tCb3g7Ci0JfQotCi0JcHJpdmF0ZSBKQ2hlY2tCb3ggYnVpbGRVbmF0dGFjaGVkQ2hlY2tCb3goKSB7Ci0JCUpDaGVja0JveCBjaGVja0JveCA9IG5ldyBKQ2hlY2tCb3goInVuYXR0YWNoZWQiKTsKLQkJY2hlY2tCb3guZ2V0TW9kZWwoKS5hZGRJdGVtTGlzdGVuZXIodGhpcy5idWlsZFVuYXR0YWNoZWRJdGVtTGlzdGVuZXIoKSk7Ci0JCXJldHVybiBjaGVja0JveDsKLQl9Ci0KLQlwcml2YXRlIEl0ZW1MaXN0ZW5lciBidWlsZFVuYXR0YWNoZWRJdGVtTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgSXRlbUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgaXRlbVN0YXRlQ2hhbmdlZChJdGVtRXZlbnQgZSkgewotCQkJCVN5c3RlbS5vdXQucHJpbnRsbigidW5hdHRhY2hlZCBzdGF0ZSBjaGFuZ2VkOiAiICsgZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRDb250cm9sUGFuZWwoKSB7Ci0JCUpQYW5lbCBjb250cm9sUGFuZWwgPSBuZXcgSlBhbmVsKG5ldyBHcmlkTGF5b3V0KDEsIDApKTsKLQkJY29udHJvbFBhbmVsLmFkZCh0aGlzLmJ1aWxkRmxpcEZsYWcxQnV0dG9uKCkpOwotCQljb250cm9sUGFuZWwuYWRkKHRoaXMuYnVpbGRDbGVhck1vZGVsQnV0dG9uKCkpOwotCQljb250cm9sUGFuZWwuYWRkKHRoaXMuYnVpbGRSZXN0b3JlTW9kZWxCdXR0b24oKSk7Ci0JCWNvbnRyb2xQYW5lbC5hZGQodGhpcy5idWlsZFByaW50TW9kZWxCdXR0b24oKSk7Ci0JCXJldHVybiBjb250cm9sUGFuZWw7Ci0JfQotCi0JcHJpdmF0ZSBKQnV0dG9uIGJ1aWxkRmxpcEZsYWcxQnV0dG9uKCkgewotCQlyZXR1cm4gbmV3IEpCdXR0b24odGhpcy5idWlsZEZsaXBGbGFnMUFjdGlvbigpKTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbiBidWlsZEZsaXBGbGFnMUFjdGlvbigpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBYnN0cmFjdEFjdGlvbigiZmxpcCBmbGFnIDEiKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZXZlbnQpIHsKLQkJCQlDaGVja0JveE1vZGVsQWRhcHRlclVJVGVzdC50aGlzLmZsaXBGbGFnMSgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQl2b2lkIGZsaXBGbGFnMSgpIHsKLQkJdGhpcy50ZXN0TW9kZWwuc2V0RmxhZzEoICEgdGhpcy50ZXN0TW9kZWwuaXNGbGFnMSgpKTsKLQl9Ci0KLQlwcml2YXRlIEpCdXR0b24gYnVpbGRDbGVhck1vZGVsQnV0dG9uKCkgewotCQlyZXR1cm4gbmV3IEpCdXR0b24odGhpcy5idWlsZENsZWFyTW9kZWxBY3Rpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb24gYnVpbGRDbGVhck1vZGVsQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJjbGVhciBtb2RlbCIpIHsKLQkJCXB1YmxpYyB2b2lkIGFjdGlvblBlcmZvcm1lZChBY3Rpb25FdmVudCBldmVudCkgewotCQkJCUNoZWNrQm94TW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMuY2xlYXJNb2RlbCgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQl2b2lkIGNsZWFyTW9kZWwoKSB7Ci0JCXRoaXMudGVzdE1vZGVsSG9sZGVyLnNldFZhbHVlKG51bGwpOwotCX0KLQotCXByaXZhdGUgSkJ1dHRvbiBidWlsZFJlc3RvcmVNb2RlbEJ1dHRvbigpIHsKLQkJcmV0dXJuIG5ldyBKQnV0dG9uKHRoaXMuYnVpbGRSZXN0b3JlTW9kZWxBY3Rpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb24gYnVpbGRSZXN0b3JlTW9kZWxBY3Rpb24oKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWJzdHJhY3RBY3Rpb24oInJlc3RvcmUgbW9kZWwiKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZXZlbnQpIHsKLQkJCQlDaGVja0JveE1vZGVsQWRhcHRlclVJVGVzdC50aGlzLnJlc3RvcmVNb2RlbCgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQl2b2lkIHJlc3RvcmVNb2RlbCgpIHsKLQkJdGhpcy50ZXN0TW9kZWxIb2xkZXIuc2V0VmFsdWUodGhpcy50ZXN0TW9kZWwpOwotCX0KLQotCXByaXZhdGUgSkJ1dHRvbiBidWlsZFByaW50TW9kZWxCdXR0b24oKSB7Ci0JCXJldHVybiBuZXcgSkJ1dHRvbih0aGlzLmJ1aWxkUHJpbnRNb2RlbEFjdGlvbigpKTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbiBidWlsZFByaW50TW9kZWxBY3Rpb24oKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWJzdHJhY3RBY3Rpb24oInByaW50IG1vZGVsIikgewotCQkJcHVibGljIHZvaWQgYWN0aW9uUGVyZm9ybWVkKEFjdGlvbkV2ZW50IGV2ZW50KSB7Ci0JCQkJQ2hlY2tCb3hNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5wcmludE1vZGVsKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRFbmFibGVkKHRydWUpOwotCQlyZXR1cm4gYWN0aW9uOwotCX0KLQotCXZvaWQgcHJpbnRNb2RlbCgpIHsKLQkJU3lzdGVtLm91dC5wcmludGxuKCJmbGFnIDE6ICIgKyB0aGlzLnRlc3RNb2RlbC5pc0ZsYWcxKCkpOwotCQlTeXN0ZW0ub3V0LnByaW50bG4oImZsYWcgMjogIiArIHRoaXMudGVzdE1vZGVsLmlzRmxhZzIoKSk7Ci0JCVN5c3RlbS5vdXQucHJpbnRsbigibm90IGZsYWcgMjogIiArIHRoaXMudGVzdE1vZGVsLmlzTm90RmxhZzIoKSk7Ci0JCVN5c3RlbS5vdXQucHJpbnRsbigiKioqIik7Ci0JfQotCi0KLQlwcml2YXRlIGNsYXNzIFRlc3RNb2RlbCBleHRlbmRzIEFic3RyYWN0TW9kZWwgewotCQlwcml2YXRlIGJvb2xlYW4gZmxhZzE7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBGTEFHMV9QUk9QRVJUWSA9ICJmbGFnMSI7Ci0JCXByaXZhdGUgYm9vbGVhbiBmbGFnMjsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIEZMQUcyX1BST1BFUlRZID0gImZsYWcyIjsKLQkJcHJpdmF0ZSBib29sZWFuIG5vdEZsYWcyOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgTk9UX0ZMQUcyX1BST1BFUlRZID0gIm5vdEZsYWcyIjsKLQkKLQkJcHVibGljIFRlc3RNb2RlbChib29sZWFuIGZsYWcxLCBib29sZWFuIGZsYWcyKSB7Ci0JCQl0aGlzLmZsYWcxID0gZmxhZzE7Ci0JCQl0aGlzLmZsYWcyID0gZmxhZzI7Ci0JCQl0aGlzLm5vdEZsYWcyID0gISBmbGFnMjsKLQkJfQotCQlwdWJsaWMgYm9vbGVhbiBpc0ZsYWcxKCkgewotCQkJcmV0dXJuIHRoaXMuZmxhZzE7Ci0JCX0KLQkJcHVibGljIHZvaWQgc2V0RmxhZzEoYm9vbGVhbiBmbGFnMSkgewotCQkJYm9vbGVhbiBvbGQgPSB0aGlzLmZsYWcxOwotCQkJdGhpcy5mbGFnMSA9IGZsYWcxOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKEZMQUcxX1BST1BFUlRZLCBvbGQsIGZsYWcxKTsKLQkJfQotCQlwdWJsaWMgYm9vbGVhbiBpc0ZsYWcyKCkgewotCQkJcmV0dXJuIHRoaXMuZmxhZzI7Ci0JCX0KLQkJcHVibGljIHZvaWQgc2V0RmxhZzIoYm9vbGVhbiBmbGFnMikgewotCQkJYm9vbGVhbiBvbGQgPSB0aGlzLmZsYWcyOwotCQkJdGhpcy5mbGFnMiA9IGZsYWcyOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKEZMQUcyX1BST1BFUlRZLCBvbGQsIGZsYWcyKTsKLQkKLQkJCW9sZCA9IHRoaXMubm90RmxhZzI7Ci0JCQl0aGlzLm5vdEZsYWcyID0gISBmbGFnMjsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChOT1RfRkxBRzJfUFJPUEVSVFksIG9sZCwgdGhpcy5ub3RGbGFnMik7Ci0JCX0KLQkJcHVibGljIGJvb2xlYW4gaXNOb3RGbGFnMigpIHsKLQkJCXJldHVybiB0aGlzLm5vdEZsYWcyOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldE5vdEZsYWcyKGJvb2xlYW4gbm90RmxhZzIpIHsKLQkJCXRoaXMuc2V0RmxhZzIoICEgbm90RmxhZzIpOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuICJUZXN0TW9kZWwoIiArIHRoaXMuaXNGbGFnMSgpICsgIiAtICIgKyB0aGlzLmlzRmxhZzIoKSArICIpIjsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9Db21ib0JveE1vZGVsQWRhcHRlclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0NvbWJvQm94TW9kZWxBZGFwdGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTc5MTExYS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0NvbWJvQm94TW9kZWxBZGFwdGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDExMCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZheC5zd2luZy5Db21ib0JveE1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLkxpc3RNb2RlbDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVMaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuQ29tYm9Cb3hNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuc3dpbmcuRGlzcGxheWFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuc3dpbmcuU2ltcGxlRGlzcGxheWFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Db29yZGluYXRlZExpc3Q7Ci0KLXB1YmxpYyBjbGFzcyBDb21ib0JveE1vZGVsQWRhcHRlclRlc3RzIGV4dGVuZHMgVGVzdENhc2UgewotCi0JcHVibGljIENvbWJvQm94TW9kZWxBZGFwdGVyVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJLy8gbm90aGluZyB5ZXQuLi4KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQkvLyBub3RoaW5nIHlldC4uLgotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNMaXN0ZW5lcnMoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJU2ltcGxlTGlzdFZhbHVlTW9kZWw8RGlzcGxheWFibGU+IGxpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcigpOwotCQlhc3NlcnRGYWxzZShsaXN0SG9sZGVyLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gc2VsZWN0aW9uSG9sZGVyID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+KGxpc3RIb2xkZXIuaXRlcmF0b3IoKS5uZXh0KCkpOwotCQlhc3NlcnRGYWxzZShzZWxlY3Rpb25Ib2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0KLQkJQ29tYm9Cb3hNb2RlbCBjb21ib0JveE1vZGVsID0gbmV3IENvbWJvQm94TW9kZWxBZGFwdGVyKGxpc3RIb2xkZXIsIHNlbGVjdGlvbkhvbGRlcik7Ci0JCWFzc2VydEZhbHNlKGxpc3RIb2xkZXIuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQlhc3NlcnRGYWxzZShzZWxlY3Rpb25Ib2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTm9MaXN0ZW5lcnMoY29tYm9Cb3hNb2RlbCk7Ci0KLQkJQ29vcmRpbmF0ZWRMaXN0PERpc3BsYXlhYmxlPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PERpc3BsYXlhYmxlPihjb21ib0JveE1vZGVsKTsKLQkJUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBzZWxlY3Rpb25MaXN0ZW5lciA9IHRoaXMuYnVpbGRTZWxlY3Rpb25MaXN0ZW5lcigpOwotCQlzZWxlY3Rpb25Ib2xkZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHNlbGVjdGlvbkxpc3RlbmVyKTsKLQkJYXNzZXJ0VHJ1ZShsaXN0SG9sZGVyLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJYXNzZXJ0VHJ1ZShzZWxlY3Rpb25Ib2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTGlzdGVuZXJzKGNvbWJvQm94TW9kZWwpOwotCi0JCWNvbWJvQm94TW9kZWwucmVtb3ZlTGlzdERhdGFMaXN0ZW5lcihzeW5jaExpc3QpOwotCQlzZWxlY3Rpb25Ib2xkZXIucmVtb3ZlUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHNlbGVjdGlvbkxpc3RlbmVyKTsKLQkJYXNzZXJ0RmFsc2UobGlzdEhvbGRlci5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0JCWFzc2VydEZhbHNlKHNlbGVjdGlvbkhvbGRlci5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJdGhpcy52ZXJpZnlIYXNOb0xpc3RlbmVycyhjb21ib0JveE1vZGVsKTsKLQl9Ci0KLQlwcml2YXRlIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGRTZWxlY3Rpb25MaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZXZ0KSB7Ci0JCQkJLy8gZG8gbm90aGluZy4uLgotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlIYXNOb0xpc3RlbmVycyhMaXN0TW9kZWwgbGlzdE1vZGVsKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYm9vbGVhbiBoYXNOb0xpc3RlbmVycyA9ICgoQm9vbGVhbikgQ2xhc3NUb29scy5leGVjdXRlTWV0aG9kKGxpc3RNb2RlbCwgImhhc05vTGlzdERhdGFMaXN0ZW5lcnMiKSkuYm9vbGVhblZhbHVlKCk7Ci0JCWFzc2VydFRydWUoaGFzTm9MaXN0ZW5lcnMpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlIYXNMaXN0ZW5lcnMoTGlzdE1vZGVsIGxpc3RNb2RlbCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWJvb2xlYW4gaGFzTGlzdGVuZXJzID0gKChCb29sZWFuKSBDbGFzc1Rvb2xzLmV4ZWN1dGVNZXRob2QobGlzdE1vZGVsLCAiaGFzTGlzdERhdGFMaXN0ZW5lcnMiKSkuYm9vbGVhblZhbHVlKCk7Ci0JCWFzc2VydFRydWUoaGFzTGlzdGVuZXJzKTsKLQl9Ci0KLQlwcml2YXRlIFNpbXBsZUxpc3RWYWx1ZU1vZGVsPERpc3BsYXlhYmxlPiBidWlsZExpc3RIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8RGlzcGxheWFibGU+KHRoaXMuYnVpbGRMaXN0KCkpOwotCX0KLQotCXByaXZhdGUgTGlzdDxEaXNwbGF5YWJsZT4gYnVpbGRMaXN0KCkgewotCQlMaXN0PERpc3BsYXlhYmxlPiBsaXN0ID0gbmV3IEFycmF5TGlzdDxEaXNwbGF5YWJsZT4oKTsKLQkJdGhpcy5wb3B1bGF0ZUNvbGxlY3Rpb24obGlzdCk7Ci0JCXJldHVybiBsaXN0OwotCX0KLQotCXByaXZhdGUgdm9pZCBwb3B1bGF0ZUNvbGxlY3Rpb24oQ29sbGVjdGlvbjxEaXNwbGF5YWJsZT4gYykgewotCQljLmFkZChuZXcgU2ltcGxlRGlzcGxheWFibGUoImZvbyIpKTsKLQkJYy5hZGQobmV3IFNpbXBsZURpc3BsYXlhYmxlKCJiYXIiKSk7Ci0JCWMuYWRkKG5ldyBTaW1wbGVEaXNwbGF5YWJsZSgiYmF6IikpOwotCQljLmFkZChuZXcgU2ltcGxlRGlzcGxheWFibGUoImpvbyIpKTsKLQkJYy5hZGQobmV3IFNpbXBsZURpc3BsYXlhYmxlKCJqYXIiKSk7Ci0JCWMuYWRkKG5ldyBTaW1wbGVEaXNwbGF5YWJsZSgiamF6IikpOwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9Db21ib0JveE1vZGVsQWRhcHRlclVJVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9Db21ib0JveE1vZGVsQWRhcHRlclVJVGVzdC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiYjZlOGYwLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvQ29tYm9Cb3hNb2RlbEFkYXB0ZXJVSVRlc3QuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDM5MSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nOwotCi1pbXBvcnQgamF2YS5hd3QuQm9yZGVyTGF5b3V0OwotaW1wb3J0IGphdmEuYXd0LkNvbXBvbmVudDsKLWltcG9ydCBqYXZhLmF3dC5HcmlkTGF5b3V0OwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LkFjdGlvbkV2ZW50OwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LldpbmRvd0FkYXB0ZXI7Ci1pbXBvcnQgamF2YS5hd3QuZXZlbnQuV2luZG93RXZlbnQ7Ci1pbXBvcnQgamF2YS5hd3QuZXZlbnQuV2luZG93TGlzdGVuZXI7Ci1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZheC5zd2luZy5BYnN0cmFjdEFjdGlvbjsKLWltcG9ydCBqYXZheC5zd2luZy5BY3Rpb247Ci1pbXBvcnQgamF2YXguc3dpbmcuQ29tYm9Cb3hNb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy5KQnV0dG9uOwotaW1wb3J0IGphdmF4LnN3aW5nLkpDb21ib0JveDsKLWltcG9ydCBqYXZheC5zd2luZy5KRnJhbWU7Ci1pbXBvcnQgamF2YXguc3dpbmcuSlBhbmVsOwotaW1wb3J0IGphdmF4LnN3aW5nLkxpc3RDZWxsUmVuZGVyZXI7Ci1pbXBvcnQgamF2YXguc3dpbmcuVUlNYW5hZ2VyOwotaW1wb3J0IGphdmF4LnN3aW5nLldpbmRvd0NvbnN0YW50czsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5DbGFzc1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVMaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuQ29tYm9Cb3hNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuc3dpbmcuRmlsdGVyaW5nTGlzdEJyb3dzZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuc3dpbmcuTGlzdENob29zZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuc3dpbmcuU2ltcGxlTGlzdENlbGxSZW5kZXJlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci0KLQotLyoqCi0gKiBQbGF5IGFyb3VuZCB3aXRoIGEgc2V0IG9mIGNvbWJvLWJveGVzLgotICogCi0gKiBEZWZhdWx0TG9uZ0xpc3RCcm93c2VyRGlhbG9nVUlUZXN0IHN1YmNsYXNzZXMgdGhpcyBjbGFzczsgc28gYmUKLSAqIGNhcmVmdWwgd2hlbiBtYWtpbmcgY2hhbmdlcy4KLSAqLwotcHVibGljIGNsYXNzIENvbWJvQm94TW9kZWxBZGFwdGVyVUlUZXN0IHsKLQotCXByb3RlY3RlZCBKRnJhbWUgd2luZG93OwotCXByaXZhdGUgVGVzdE1vZGVsIHRlc3RNb2RlbDsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4gdGVzdE1vZGVsSG9sZGVyOwotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBjb2xvckhvbGRlcjsKLQlwcml2YXRlIFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gY29sb3JMaXN0SG9sZGVyOwotCXByb3RlY3RlZCBDb21ib0JveE1vZGVsIGNvbG9yQ29tYm9Cb3hNb2RlbDsKLQlwcml2YXRlIGludCBuZXh0Q29sb3JOdW1iZXIgPSAwOwotCi0JcHVibGljIHN0YXRpYyB2b2lkIG1haW4oU3RyaW5nW10gYXJncykgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCW5ldyBDb21ib0JveE1vZGVsQWRhcHRlclVJVGVzdCgpLmV4ZWMoYXJncyk7Ci0JfQotCi0JcHJvdGVjdGVkIENvbWJvQm94TW9kZWxBZGFwdGVyVUlUZXN0KCkgewotCQlzdXBlcigpOwotCX0KLQotCXByb3RlY3RlZCB2b2lkIGV4ZWMoU3RyaW5nW10gYXJncykgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVVJTWFuYWdlci5zZXRMb29rQW5kRmVlbChVSU1hbmFnZXIuZ2V0U3lzdGVtTG9va0FuZEZlZWxDbGFzc05hbWUoKSk7Ci0vLwkJVUlNYW5hZ2VyLnNldExvb2tBbmRGZWVsKFVJTWFuYWdlci5nZXRDcm9zc1BsYXRmb3JtTG9va0FuZEZlZWxDbGFzc05hbWUoKSk7CS8vIE1ldGFsIExBRgotLy8JCVVJTWFuYWdlci5zZXRMb29rQW5kRmVlbChjb20uc3VuLmphdmEuc3dpbmcucGxhZi53aW5kb3dzLldpbmRvd3NMb29rQW5kRmVlbC5jbGFzcy5nZXROYW1lKCkpOwotLy8JCVVJTWFuYWdlci5zZXRMb29rQW5kRmVlbChjb20uc3VuLmphdmEuc3dpbmcucGxhZi5tb3RpZi5Nb3RpZkxvb2tBbmRGZWVsLmNsYXNzLmdldE5hbWUoKSk7Ci0vLwkJVUlNYW5hZ2VyLnNldExvb2tBbmRGZWVsKG9yYWNsZS5iYWxpLmV3dC5vbGFmLk9yYWNsZUxvb2tBbmRGZWVsLmNsYXNzLmdldE5hbWUoKSk7Ci0JCXRoaXMudGVzdE1vZGVsID0gdGhpcy5idWlsZFRlc3RNb2RlbCgpOwotCQl0aGlzLnRlc3RNb2RlbEhvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdE1vZGVsPih0aGlzLnRlc3RNb2RlbCk7Ci0JCXRoaXMuY29sb3JIb2xkZXIgPSB0aGlzLmJ1aWxkQ29sb3JIb2xkZXIodGhpcy50ZXN0TW9kZWxIb2xkZXIpOwotCQl0aGlzLmNvbG9yTGlzdEhvbGRlciA9IHRoaXMuYnVpbGRDb2xvckxpc3RIb2xkZXIoKTsKLQkJdGhpcy5jb2xvckNvbWJvQm94TW9kZWwgPSB0aGlzLmJ1aWxkQ29tYm9Cb3hNb2RlbEFkYXB0ZXIodGhpcy5jb2xvckxpc3RIb2xkZXIsIHRoaXMuY29sb3JIb2xkZXIpOwotCQl0aGlzLm9wZW5XaW5kb3coKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gYnVpbGRDb2xvckhvbGRlcihQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdE1vZGVsPiB2bSkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxUZXN0TW9kZWwsIE9iamVjdD4odm0sIFRlc3RNb2RlbC5DT0xPUl9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0Q29sb3IoKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKE9iamVjdCB2YWx1ZSkgewotCQkJCXRoaXMuc3ViamVjdC5zZXRDb2xvcigoU3RyaW5nKSB2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJvdGVjdGVkIFRlc3RNb2RlbCBidWlsZFRlc3RNb2RlbCgpIHsKLQkJcmV0dXJuIG5ldyBUZXN0TW9kZWwoKTsKLQl9Ci0KLQlwcml2YXRlIFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRDb2xvckxpc3RIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPihUZXN0TW9kZWwudmFsaWRDb2xvcnMoKSk7Ci0vLwkJcmV0dXJuIG5ldyBBYnN0cmFjdFJlYWRPbmx5TGlzdFZhbHVlTW9kZWwoKSB7Ci0vLwkJCXB1YmxpYyBPYmplY3QgdmFsdWUoKSB7Ci0vLwkJCQlyZXR1cm4gbmV3IEFycmF5TGlzdEl0ZXJhdG9yKFRlc3RNb2RlbC5WQUxJRF9DT0xPUlMpOwotLy8JCQl9Ci0vLwkJCXB1YmxpYyBpbnQgc2l6ZSgpIHsKLS8vCQkJCXJldHVybiBUZXN0TW9kZWwuVkFMSURfQ09MT1JTLmxlbmd0aDsKLS8vCQkJfQotLy8JCX07Ci0JfQotCi0JcHJvdGVjdGVkIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gdWlDb2xvckxpc3RIb2xkZXIoKSB7Ci0JCXJldHVybiB0aGlzLmNvbG9yTGlzdEhvbGRlcjsKLQl9Ci0KLQlwcml2YXRlIENvbWJvQm94TW9kZWwgYnVpbGRDb21ib0JveE1vZGVsQWRhcHRlcihMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGxpc3RIb2xkZXIsIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gc2VsZWN0aW9uSG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgQ29tYm9Cb3hNb2RlbEFkYXB0ZXIobGlzdEhvbGRlciwgc2VsZWN0aW9uSG9sZGVyKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgb3BlbldpbmRvdygpIHsKLQkJdGhpcy53aW5kb3cgPSBuZXcgSkZyYW1lKENsYXNzVG9vbHMuc2hvcnROYW1lRm9yKHRoaXMuZ2V0Q2xhc3MoKSkpOwotCQl0aGlzLndpbmRvdy5zZXREZWZhdWx0Q2xvc2VPcGVyYXRpb24oV2luZG93Q29uc3RhbnRzLkRPX05PVEhJTkdfT05fQ0xPU0UpOwotCQl0aGlzLndpbmRvdy5hZGRXaW5kb3dMaXN0ZW5lcih0aGlzLmJ1aWxkV2luZG93TGlzdGVuZXIoKSk7Ci0JCXRoaXMud2luZG93LmdldENvbnRlbnRQYW5lKCkuYWRkKHRoaXMuYnVpbGRNYWluUGFuZWwoKSwgIkNlbnRlciIpOwotCQl0aGlzLndpbmRvdy5zZXRMb2NhdGlvbigzMDAsIDMwMCk7Ci0JCXRoaXMud2luZG93LnNldFNpemUoNDAwLCAxNTApOwotCQl0aGlzLndpbmRvdy5zZXRWaXNpYmxlKHRydWUpOwotCX0KLQotCXByaXZhdGUgV2luZG93TGlzdGVuZXIgYnVpbGRXaW5kb3dMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBXaW5kb3dBZGFwdGVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCB3aW5kb3dDbG9zaW5nKFdpbmRvd0V2ZW50IGUpIHsKLQkJCQllLmdldFdpbmRvdygpLnNldFZpc2libGUoZmFsc2UpOwotCQkJCVN5c3RlbS5leGl0KDApOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgQ29tcG9uZW50IGJ1aWxkTWFpblBhbmVsKCkgewotCQlKUGFuZWwgbWFpblBhbmVsID0gbmV3IEpQYW5lbChuZXcgQm9yZGVyTGF5b3V0KCkpOwotCQltYWluUGFuZWwuYWRkKHRoaXMuYnVpbGRDb21ib0JveFBhbmVsKCksIEJvcmRlckxheW91dC5OT1JUSCk7Ci0JCW1haW5QYW5lbC5hZGQodGhpcy5idWlsZENvbnRyb2xQYW5lbCgpLCBCb3JkZXJMYXlvdXQuU09VVEgpOwotCQlyZXR1cm4gbWFpblBhbmVsOwotCX0KLQotCXByb3RlY3RlZCBKUGFuZWwgYnVpbGRDb21ib0JveFBhbmVsKCkgewotCQlKUGFuZWwgcGFuZWwgPSBuZXcgSlBhbmVsKG5ldyBHcmlkTGF5b3V0KDEsIDApKTsKLQkJcGFuZWwuYWRkKHRoaXMuYnVpbGRDb21ib0JveCgpKTsKLQkJcGFuZWwuYWRkKHRoaXMuYnVpbGRDb21ib0JveCgpKTsKLQkJcGFuZWwuYWRkKHRoaXMuYnVpbGRMaXN0Q2hvb3NlcjEoKSk7Ci0JCXBhbmVsLmFkZCh0aGlzLmJ1aWxkTGlzdENob29zZXIyKCkpOwotCQlyZXR1cm4gcGFuZWw7Ci0JfQotCi0JcHJpdmF0ZSBKQ29tYm9Cb3ggYnVpbGRDb21ib0JveCgpIHsKLQkJSkNvbWJvQm94IGNvbWJvQm94ID0gbmV3IEpDb21ib0JveCh0aGlzLmNvbG9yQ29tYm9Cb3hNb2RlbCk7Ci0JCWNvbWJvQm94LnNldFJlbmRlcmVyKHRoaXMuYnVpbGRDb21ib0JveFJlbmRlcmVyKCkpOwotCQlyZXR1cm4gY29tYm9Cb3g7Ci0JfQotCi0JcHJvdGVjdGVkIExpc3RDZWxsUmVuZGVyZXIgYnVpbGRDb21ib0JveFJlbmRlcmVyKCkgewotCQlyZXR1cm4gbmV3IFNpbXBsZUxpc3RDZWxsUmVuZGVyZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRUZXh0KE9iamVjdCB2YWx1ZSkgewotCQkJCXJldHVybiBzdXBlci5idWlsZFRleHQodmFsdWUpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgTGlzdENob29zZXIgYnVpbGRMaXN0Q2hvb3NlcjEoKSB7Ci0JCXJldHVybiBuZXcgTG9jYWxMaXN0Q2hvb3NlcjEodGhpcy5jb2xvckNvbWJvQm94TW9kZWwpOwotCX0KLQotCXByaXZhdGUgTGlzdENob29zZXIgYnVpbGRMaXN0Q2hvb3NlcjIoKSB7Ci0JCXJldHVybiBuZXcgTG9jYWxMaXN0Q2hvb3NlcjIodGhpcy5jb2xvckNvbWJvQm94TW9kZWwpOwotCX0KLQotCXByaXZhdGUgQ29tcG9uZW50IGJ1aWxkQ29udHJvbFBhbmVsKCkgewotCQlKUGFuZWwgY29udHJvbFBhbmVsID0gbmV3IEpQYW5lbChuZXcgR3JpZExheW91dCgyLCAwKSk7Ci0JCWNvbnRyb2xQYW5lbC5hZGQodGhpcy5idWlsZFJlc2V0Q29sb3JCdXR0b24oKSk7Ci0JCWNvbnRyb2xQYW5lbC5hZGQodGhpcy5idWlsZENsZWFyTW9kZWxCdXR0b24oKSk7Ci0JCWNvbnRyb2xQYW5lbC5hZGQodGhpcy5idWlsZFJlc3RvcmVNb2RlbEJ1dHRvbigpKTsKLQkJY29udHJvbFBhbmVsLmFkZCh0aGlzLmJ1aWxkUHJpbnRNb2RlbEJ1dHRvbigpKTsKLQkJY29udHJvbFBhbmVsLmFkZCh0aGlzLmJ1aWxkQWRkVGVuQnV0dG9uKCkpOwotCQljb250cm9sUGFuZWwuYWRkKHRoaXMuYnVpbGRSZW1vdmVUZW5CdXR0b24oKSk7Ci0JCXJldHVybiBjb250cm9sUGFuZWw7Ci0JfQotCi0JLy8gKioqKioqKioqKiByZXNldCBjb2xvciBidXR0b24gKioqKioqKioqKgotCXByaXZhdGUgSkJ1dHRvbiBidWlsZFJlc2V0Q29sb3JCdXR0b24oKSB7Ci0JCXJldHVybiBuZXcgSkJ1dHRvbih0aGlzLmJ1aWxkUmVzZXRDb2xvckFjdGlvbigpKTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbiBidWlsZFJlc2V0Q29sb3JBY3Rpb24oKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWJzdHJhY3RBY3Rpb24oInJlc2V0IGNvbG9yIikgewotCQkJcHVibGljIHZvaWQgYWN0aW9uUGVyZm9ybWVkKEFjdGlvbkV2ZW50IGV2ZW50KSB7Ci0JCQkJQ29tYm9Cb3hNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5yZXNldENvbG9yKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRFbmFibGVkKHRydWUpOwotCQlyZXR1cm4gYWN0aW9uOwotCX0KLQotCXZvaWQgcmVzZXRDb2xvcigpIHsKLQkJdGhpcy50ZXN0TW9kZWwuc2V0Q29sb3IoVGVzdE1vZGVsLkRFRkFVTFRfQ09MT1IpOwotCX0KLQotCS8vICoqKioqKioqKiogY2xlYXIgbW9kZWwgYnV0dG9uICoqKioqKioqKioKLQlwcml2YXRlIEpCdXR0b24gYnVpbGRDbGVhck1vZGVsQnV0dG9uKCkgewotCQlyZXR1cm4gbmV3IEpCdXR0b24odGhpcy5idWlsZENsZWFyTW9kZWxBY3Rpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb24gYnVpbGRDbGVhck1vZGVsQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJjbGVhciBtb2RlbCIpIHsKLQkJCXB1YmxpYyB2b2lkIGFjdGlvblBlcmZvcm1lZChBY3Rpb25FdmVudCBldmVudCkgewotCQkJCUNvbWJvQm94TW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMuY2xlYXJNb2RlbCgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQl2b2lkIGNsZWFyTW9kZWwoKSB7Ci0JCXRoaXMudGVzdE1vZGVsSG9sZGVyLnNldFZhbHVlKG51bGwpOwotCX0KLQotCS8vICoqKioqKioqKiogcmVzdG9yZSBtb2RlbCBidXR0b24gKioqKioqKioqKgotCXByaXZhdGUgSkJ1dHRvbiBidWlsZFJlc3RvcmVNb2RlbEJ1dHRvbigpIHsKLQkJcmV0dXJuIG5ldyBKQnV0dG9uKHRoaXMuYnVpbGRSZXN0b3JlTW9kZWxBY3Rpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb24gYnVpbGRSZXN0b3JlTW9kZWxBY3Rpb24oKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWJzdHJhY3RBY3Rpb24oInJlc3RvcmUgbW9kZWwiKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZXZlbnQpIHsKLQkJCQlDb21ib0JveE1vZGVsQWRhcHRlclVJVGVzdC50aGlzLnJlc3RvcmVNb2RlbCgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQl2b2lkIHJlc3RvcmVNb2RlbCgpIHsKLQkJdGhpcy50ZXN0TW9kZWxIb2xkZXIuc2V0VmFsdWUodGhpcy50ZXN0TW9kZWwpOwotCX0KLQotCS8vICoqKioqKioqKiogcHJpbnQgbW9kZWwgYnV0dG9uICoqKioqKioqKioKLQlwcml2YXRlIEpCdXR0b24gYnVpbGRQcmludE1vZGVsQnV0dG9uKCkgewotCQlyZXR1cm4gbmV3IEpCdXR0b24odGhpcy5idWlsZFByaW50TW9kZWxBY3Rpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb24gYnVpbGRQcmludE1vZGVsQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJwcmludCBtb2RlbCIpIHsKLQkJCXB1YmxpYyB2b2lkIGFjdGlvblBlcmZvcm1lZChBY3Rpb25FdmVudCBldmVudCkgewotCQkJCUNvbWJvQm94TW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMucHJpbnRNb2RlbCgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQl2b2lkIHByaW50TW9kZWwoKSB7Ci0JCVN5c3RlbS5vdXQucHJpbnRsbih0aGlzLnRlc3RNb2RlbCk7Ci0JfQotCi0JLy8gKioqKioqKioqKiBhZGQgMjAgYnV0dG9uICoqKioqKioqKioKLQlwcml2YXRlIEpCdXR0b24gYnVpbGRBZGRUZW5CdXR0b24oKSB7Ci0JCXJldHVybiBuZXcgSkJ1dHRvbih0aGlzLmJ1aWxkQWRkVGVuQWN0aW9uKCkpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uIGJ1aWxkQWRkVGVuQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJhZGQgMjAiKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZXZlbnQpIHsKLQkJCQlDb21ib0JveE1vZGVsQWRhcHRlclVJVGVzdC50aGlzLmFkZFRlbigpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQl2b2lkIGFkZFRlbigpIHsKLQkJZm9yIChpbnQgaSA9IHRoaXMubmV4dENvbG9yTnVtYmVyOyBpIDwgdGhpcy5uZXh0Q29sb3JOdW1iZXIgKyAyMDsgaSsrKSB7Ci0JCQl0aGlzLmNvbG9yTGlzdEhvbGRlci5hZGQodGhpcy5jb2xvckxpc3RIb2xkZXIuc2l6ZSgpLCAiY29sb3IiICsgaSk7Ci0JCX0KLQkJdGhpcy5uZXh0Q29sb3JOdW1iZXIgKz0gMjA7Ci0JfQotCi0JLy8gKioqKioqKioqKiByZW1vdmUgMjAgYnV0dG9uICoqKioqKioqKioKLQlwcml2YXRlIEpCdXR0b24gYnVpbGRSZW1vdmVUZW5CdXR0b24oKSB7Ci0JCXJldHVybiBuZXcgSkJ1dHRvbih0aGlzLmJ1aWxkUmVtb3ZlVGVuQWN0aW9uKCkpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uIGJ1aWxkUmVtb3ZlVGVuQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJyZW1vdmUgMjAiKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZXZlbnQpIHsKLQkJCQlDb21ib0JveE1vZGVsQWRhcHRlclVJVGVzdC50aGlzLnJlbW92ZVRlbigpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQl2b2lkIHJlbW92ZVRlbigpIHsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCAyMDsgaSsrKSB7Ci0JCQlpZiAodGhpcy5jb2xvckxpc3RIb2xkZXIuc2l6ZSgpID4gMCkgewotCQkJCXRoaXMuY29sb3JMaXN0SG9sZGVyLnJlbW92ZSh0aGlzLmNvbG9yTGlzdEhvbGRlci5zaXplKCkgLSAxKTsKLQkJCX0KLQkJfQotCX0KLQotCi0JcHJvdGVjdGVkIHN0YXRpYyBjbGFzcyBUZXN0TW9kZWwgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIHsKLQkJcHJpdmF0ZSBTdHJpbmcgY29sb3I7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBDT0xPUl9QUk9QRVJUWSA9ICJjb2xvciI7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBSRUQgPSAicmVkIjsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIE9SQU5HRSA9ICJvcmFuZ2UiOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgWUVMTE9XID0gInllbGxvdyI7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBHUkVFTiA9ICJncmVlbiI7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBCTFVFID0gImJsdWUiOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgSU5ESUdPID0gImluZGlnbyI7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBWSU9MRVQgPSAidmlvbGV0IjsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIERFRkFVTFRfQ09MT1IgPSBSRUQ7Ci0JCQlwdWJsaWMgc3RhdGljIExpc3Q8U3RyaW5nPiB2YWxpZENvbG9yczsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nW10gREVGQVVMVF9WQUxJRF9DT0xPUlMgPSB7Ci0JCQkJUkVELAotCQkJCU9SQU5HRSwKLQkJCQlZRUxMT1csCi0JCQkJR1JFRU4sCi0JCQkJQkxVRSwKLQkJCQlJTkRJR08sCi0JCQkJVklPTEVUCi0JCQl9OwotCQotCQlwdWJsaWMgc3RhdGljIExpc3Q8U3RyaW5nPiB2YWxpZENvbG9ycygpIHsKLQkJCWlmICh2YWxpZENvbG9ycyA9PSBudWxsKSB7Ci0JCQkJdmFsaWRDb2xvcnMgPSBidWlsZERlZmF1bHRWYWxpZENvbG9ycygpOwotCQkJfQotCQkJcmV0dXJuIHZhbGlkQ29sb3JzOwotCQl9Ci0JCXB1YmxpYyBzdGF0aWMgTGlzdDxTdHJpbmc+IGJ1aWxkRGVmYXVsdFZhbGlkQ29sb3JzKCkgewotCQkJTGlzdDxTdHJpbmc+IHJlc3VsdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQkJQ29sbGVjdGlvblRvb2xzLmFkZEFsbChyZXN1bHQsIERFRkFVTFRfVkFMSURfQ09MT1JTKTsKLQkJCXJldHVybiByZXN1bHQ7Ci0JCX0KLQkKLQkJcHVibGljIFRlc3RNb2RlbCgpIHsKLQkJCXRoaXMoREVGQVVMVF9DT0xPUik7Ci0JCX0KLQkJcHVibGljIFRlc3RNb2RlbChTdHJpbmcgY29sb3IpIHsKLQkJCXRoaXMuY29sb3IgPSBjb2xvcjsKLQkJfQotCQlwdWJsaWMgU3RyaW5nIGdldENvbG9yKCkgewotCQkJcmV0dXJuIHRoaXMuY29sb3I7Ci0JCX0KLQkJcHVibGljIHZvaWQgc2V0Q29sb3IoU3RyaW5nIGNvbG9yKSB7Ci0JCQl0aGlzLmNoZWNrQ29sb3IoY29sb3IpOwotCQkJT2JqZWN0IG9sZCA9IHRoaXMuY29sb3I7Ci0JCQl0aGlzLmNvbG9yID0gY29sb3I7Ci0JCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoQ09MT1JfUFJPUEVSVFksIG9sZCwgY29sb3IpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGNoZWNrQ29sb3IoU3RyaW5nIGMpIHsKLQkJCWlmICggISB2YWxpZENvbG9ycygpLmNvbnRhaW5zKGMpKSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbihjKTsKLQkJCX0KLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiVGVzdE1vZGVsKCIgKyB0aGlzLmNvbG9yICsgIikiOwotCQl9Ci0JfQotCi0KLQlwcml2YXRlIGNsYXNzIExvY2FsTGlzdENob29zZXIxIGV4dGVuZHMgTGlzdENob29zZXIgewotCQlwdWJsaWMgTG9jYWxMaXN0Q2hvb3NlcjEoQ29tYm9Cb3hNb2RlbCBtb2RlbCkgewotCQkJc3VwZXIobW9kZWwpOwotCQl9Ci0JfQotCi0KLQlwcml2YXRlIGNsYXNzIExvY2FsTGlzdENob29zZXIyIGV4dGVuZHMgTGlzdENob29zZXIgewotCQlwdWJsaWMgTG9jYWxMaXN0Q2hvb3NlcjIoQ29tYm9Cb3hNb2RlbCBtb2RlbCkgewotCQkJc3VwZXIobW9kZWwpOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgTGlzdEJyb3dzZXIgYnVpbGRCcm93c2VyKCkgewotCQkJcmV0dXJuIG5ldyBGaWx0ZXJpbmdMaXN0QnJvd3NlcjxTdHJpbmc+KCk7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvQ29tYm9Cb3hNb2RlbEFkYXB0ZXJVSVRlc3QyLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0NvbWJvQm94TW9kZWxBZGFwdGVyVUlUZXN0Mi5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlOWM1ZmM0Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvQ29tYm9Cb3hNb2RlbEFkYXB0ZXJVSVRlc3QyLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw3NCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nOwotCi1pbXBvcnQgamF2YXguc3dpbmcuTGlzdENlbGxSZW5kZXJlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5FeHRlbmRlZExpc3RWYWx1ZU1vZGVsV3JhcHBlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZy5TaW1wbGVMaXN0Q2VsbFJlbmRlcmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotCi0vKioKLSAqIAotICovCi1wdWJsaWMgY2xhc3MgQ29tYm9Cb3hNb2RlbEFkYXB0ZXJVSVRlc3QyIGV4dGVuZHMgQ29tYm9Cb3hNb2RlbEFkYXB0ZXJVSVRlc3QgewotCi0JcHVibGljIHN0YXRpYyB2b2lkIG1haW4oU3RyaW5nW10gYXJncykgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCW5ldyBDb21ib0JveE1vZGVsQWRhcHRlclVJVGVzdDIoKS5leGVjKGFyZ3MpOwotCX0KLQotCXB1YmxpYyBDb21ib0JveE1vZGVsQWRhcHRlclVJVGVzdDIoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JLyoqCi0JICogdXNlIGEgZGlmZmVyZW50IG1vZGVsIHRoYXQgYWxsb3dzIHRoZSBjb2xvciB0byBiZSBzZXQgdG8gbnVsbAotCSAqLwotCUBPdmVycmlkZQotCXByb3RlY3RlZCBUZXN0TW9kZWwgYnVpbGRUZXN0TW9kZWwoKSB7Ci0JCXJldHVybiBuZXcgVGVzdE1vZGVsMigpOwotCX0KLQotCS8qKgotCSAqIGFkZCBhIG51bGwgdG8gdGhlIGZyb250IG9mIHRoZSBsaXN0Ci0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIExpc3RWYWx1ZU1vZGVsPFN0cmluZz4gdWlDb2xvckxpc3RIb2xkZXIoKSB7Ci0JCS8vIHRoZSBkZWZhdWx0IGlzIHRvIHByZXBlbmQgdGhlIHdyYXBwZWQgbGlzdCB3aXRoIGEgbnVsbCBpdGVtCi0JCXJldHVybiBuZXcgRXh0ZW5kZWRMaXN0VmFsdWVNb2RlbFdyYXBwZXI8U3RyaW5nPihzdXBlci51aUNvbG9yTGlzdEhvbGRlcigpKTsKLQl9Ci0KLQkvKioKLQkgKiBjb252ZXJ0IG51bGwgdG8gc29tZSB0ZXh0Ci0JICovCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIExpc3RDZWxsUmVuZGVyZXIgYnVpbGRDb21ib0JveFJlbmRlcmVyKCkgewotCQlyZXR1cm4gbmV3IFNpbXBsZUxpc3RDZWxsUmVuZGVyZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRUZXh0KE9iamVjdCB2YWx1ZSkgewotCQkJCXJldHVybiAodmFsdWUgPT0gbnVsbCkgPyAiPG5vbmUgc2VsZWN0ZWQ+IiA6IHN1cGVyLmJ1aWxkVGV4dCh2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQlwcm90ZWN0ZWQgc3RhdGljIGNsYXNzIFRlc3RNb2RlbDIgZXh0ZW5kcyBUZXN0TW9kZWwgewotCQkvKioKLQkJICogbnVsbCBpcyBPSyBoZXJlCi0JCSAqLwotCQlAT3ZlcnJpZGUKLQkJcHVibGljIHZvaWQgY2hlY2tDb2xvcihTdHJpbmcgY29sb3IpIHsKLQkJCWlmIChjb2xvciA9PSBudWxsKSB7Ci0JCQkJcmV0dXJuOwotCQkJfQotCQkJc3VwZXIuY2hlY2tDb2xvcihjb2xvcik7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvRGF0ZVNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9EYXRlU3Bpbm5lck1vZGVsQWRhcHRlclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGNiMjU1ZTcuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9EYXRlU3Bpbm5lck1vZGVsQWRhcHRlclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNTkgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZzsKLQotaW1wb3J0IGphdmEudXRpbC5EYXRlOwotaW1wb3J0IGphdmF4LnN3aW5nLlNwaW5uZXJNb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5DaGFuZ2VFdmVudDsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5DaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLkRhdGVTcGlubmVyTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIERhdGVTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IHZhbHVlSG9sZGVyOwotCXByaXZhdGUgU3Bpbm5lck1vZGVsIHNwaW5uZXJNb2RlbEFkYXB0ZXI7Ci0JYm9vbGVhbiBldmVudEZpcmVkOwotCi0JcHVibGljIERhdGVTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy52YWx1ZUhvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PihuZXcgRGF0ZSgpKTsKLQkJdGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyID0gbmV3IERhdGVTcGlubmVyTW9kZWxBZGFwdGVyKHRoaXMudmFsdWVIb2xkZXIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGREYXRlQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQkJcmV0dXJuIHRoaXMuYnVpbGREYXRlQ2hhbmdlTGlzdGVuZXJfKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRWYWx1ZVNwaW5uZXJNb2RlbCgpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmV2ZW50RmlyZWQgPSBmYWxzZTsKLQkJdGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyLmFkZENoYW5nZUxpc3RlbmVyKG5ldyBUZXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHN0YXRlQ2hhbmdlZChDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJRGF0ZVNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0cy50aGlzLmV2ZW50RmlyZWQgPSB0cnVlOwotCQkJfQotCQl9KTsKLQkJRGF0ZSBuZXdEYXRlID0gbmV3IERhdGUoKTsKLQkJbmV3RGF0ZS5zZXRUaW1lKDc3Nzc3Nyk7Ci0JCXRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5zZXRWYWx1ZShuZXdEYXRlKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmV2ZW50RmlyZWQpOwotCQlhc3NlcnRFcXVhbHMoNzc3Nzc3LCAoKERhdGUpIHRoaXMudmFsdWVIb2xkZXIuZ2V0VmFsdWUoKSkuZ2V0VGltZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2V0VmFsdWVWYWx1ZUhvbGRlcigpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmV2ZW50RmlyZWQgPSBmYWxzZTsKLQkJdGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyLmFkZENoYW5nZUxpc3RlbmVyKG5ldyBUZXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHN0YXRlQ2hhbmdlZChDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJRGF0ZVNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0cy50aGlzLmV2ZW50RmlyZWQgPSB0cnVlOwotCQkJfQotCQl9KTsKLQkJRGF0ZSBuZXdEYXRlID0gbmV3IERhdGUoKTsKLQkJbmV3RGF0ZS5zZXRUaW1lKDc3Nzc3Nyk7Ci0JCXRoaXMudmFsdWVIb2xkZXIuc2V0VmFsdWUobmV3RGF0ZSk7Ci0JCWFzc2VydFRydWUodGhpcy5ldmVudEZpcmVkKTsKLQkJYXNzZXJ0RXF1YWxzKDc3Nzc3NywgKChEYXRlKSB0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIuZ2V0VmFsdWUoKSkuZ2V0VGltZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGVmYXVsdFZhbHVlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCURhdGUgbmV3RGF0ZSA9IG5ldyBEYXRlKCk7Ci0JCW5ld0RhdGUuc2V0VGltZSg3Nzc3NzcpOwotCQl0aGlzLnZhbHVlSG9sZGVyLnNldFZhbHVlKG5ld0RhdGUpOwotCQl0aGlzLmV2ZW50RmlyZWQgPSBmYWxzZTsKLQkJdGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyLmFkZENoYW5nZUxpc3RlbmVyKG5ldyBUZXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHN0YXRlQ2hhbmdlZChDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJRGF0ZVNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0cy50aGlzLmV2ZW50RmlyZWQgPSB0cnVlOwotCQkJfQotCQl9KTsKLQkJYXNzZXJ0RXF1YWxzKDc3Nzc3NywgKChEYXRlKSB0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIuZ2V0VmFsdWUoKSkuZ2V0VGltZSgpKTsKLQkJdGhpcy52YWx1ZUhvbGRlci5zZXRWYWx1ZShudWxsKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmV2ZW50RmlyZWQpOwotCQlhc3NlcnRGYWxzZSgoKERhdGUpIHRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5nZXRWYWx1ZSgpKS5nZXRUaW1lKCkgPT0gNzc3Nzc3KTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IGxvY2FsVmFsdWVIb2xkZXIgPSAoU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4pIHRoaXMudmFsdWVIb2xkZXI7Ci0JCWFzc2VydEZhbHNlKGxvY2FsVmFsdWVIb2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTm9MaXN0ZW5lcnModGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyKTsKLQotCQlDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lciA9IG5ldyBUZXN0Q2hhbmdlTGlzdGVuZXIoKTsKLQkJdGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyLmFkZENoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJYXNzZXJ0VHJ1ZShsb2NhbFZhbHVlSG9sZGVyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQl0aGlzLnZlcmlmeUhhc0xpc3RlbmVycyh0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIpOwotCi0JCXRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5yZW1vdmVDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWFzc2VydEZhbHNlKGxvY2FsVmFsdWVIb2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTm9MaXN0ZW5lcnModGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5SGFzTm9MaXN0ZW5lcnMoU3Bpbm5lck1vZGVsIGFkYXB0ZXIpIHRocm93cyBFeGNlcHRpb24gewotCQlhc3NlcnRFcXVhbHMoMCwgKChEYXRlU3Bpbm5lck1vZGVsQWRhcHRlcikgYWRhcHRlcikuZ2V0Q2hhbmdlTGlzdGVuZXJzKCkubGVuZ3RoKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5SGFzTGlzdGVuZXJzKE9iamVjdCBhZGFwdGVyKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0RmFsc2UoKChEYXRlU3Bpbm5lck1vZGVsQWRhcHRlcikgYWRhcHRlcikuZ2V0Q2hhbmdlTGlzdGVuZXJzKCkubGVuZ3RoID09IDApOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3ROdWxsSW5pdGlhbFZhbHVlKCkgewotCQlEYXRlIHRvZGF5ID0gbmV3IERhdGUoKTsKLQkJdGhpcy52YWx1ZUhvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PigpOwotCQl0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIgPSBuZXcgRGF0ZVNwaW5uZXJNb2RlbEFkYXB0ZXIodGhpcy52YWx1ZUhvbGRlciwgdG9kYXkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGREYXRlQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQkJcmV0dXJuIHRoaXMuYnVpbGREYXRlQ2hhbmdlTGlzdGVuZXJfKCk7Ci0JCQl9Ci0JCX07Ci0KLQkJdGhpcy5ldmVudEZpcmVkID0gZmFsc2U7Ci0JCXRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5hZGRDaGFuZ2VMaXN0ZW5lcihuZXcgVGVzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoQ2hhbmdlRXZlbnQgZSkgewotCQkJCURhdGVTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCX0KLQkJfSk7Ci0JCWFzc2VydEVxdWFscyh0b2RheSwgdGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyLmdldFZhbHVlKCkpOwotCi0JCURhdGUgbmV3RGF0ZSA9IG5ldyBEYXRlKCk7Ci0JCW5ld0RhdGUuc2V0VGltZSg3Nzc3NzcpOwotCQl0aGlzLnZhbHVlSG9sZGVyLnNldFZhbHVlKG5ld0RhdGUpOwotCi0JCWFzc2VydFRydWUodGhpcy5ldmVudEZpcmVkKTsKLQkJYXNzZXJ0RXF1YWxzKDc3Nzc3NywgKChEYXRlKSB0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIuZ2V0VmFsdWUoKSkuZ2V0VGltZSgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5uZXIgY2xhc3MgKioqKioqKioqKgotCXByaXZhdGUgY2xhc3MgVGVzdENoYW5nZUxpc3RlbmVyIGltcGxlbWVudHMgQ2hhbmdlTGlzdGVuZXIgewotCQlUZXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHN0YXRlQ2hhbmdlZChDaGFuZ2VFdmVudCBlKSB7Ci0JCQlmYWlsKCJ1bmV4cGVjdGVkIGV2ZW50Iik7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvRG9jdW1lbnRBZGFwdGVyVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvRG9jdW1lbnRBZGFwdGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDY0NzM2MC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0RvY3VtZW50QWRhcHRlclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwxNTggKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZzsKLQotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LkRvY3VtZW50RXZlbnQ7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuRG9jdW1lbnRMaXN0ZW5lcjsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5Eb2N1bWVudEV2ZW50LkV2ZW50VHlwZTsKLWltcG9ydCBqYXZheC5zd2luZy50ZXh0LkRvY3VtZW50OwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5DbGFzc1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5Eb2N1bWVudEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgRG9jdW1lbnRBZGFwdGVyVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IHN0cmluZ0hvbGRlcjsKLQlEb2N1bWVudCBkb2N1bWVudEFkYXB0ZXI7Ci0JYm9vbGVhbiBldmVudEZpcmVkOwotCi0JcHVibGljIERvY3VtZW50QWRhcHRlclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMuc3RyaW5nSG9sZGVyID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+KCIwMTIzNDU2Nzg5Iik7Ci0JCXRoaXMuZG9jdW1lbnRBZGFwdGVyID0gbmV3IERvY3VtZW50QWRhcHRlcih0aGlzLnN0cmluZ0hvbGRlcikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZFN0cmluZ0xpc3RlbmVyKCkgewotCQkJCXJldHVybiB0aGlzLmJ1aWxkU3RyaW5nTGlzdGVuZXJfKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5ldmVudEZpcmVkID0gZmFsc2U7Ci0JCXRoaXMuZG9jdW1lbnRBZGFwdGVyLmFkZERvY3VtZW50TGlzdGVuZXIobmV3IFRlc3REb2N1bWVudExpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCByZW1vdmVVcGRhdGUoRG9jdW1lbnRFdmVudCBlKSB7Ci0JCQkJRG9jdW1lbnRBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCQlhc3NlcnRFcXVhbHMoRXZlbnRUeXBlLlJFTU9WRSwgZS5nZXRUeXBlKCkpOwotCQkJCWFzc2VydEVxdWFscyhEb2N1bWVudEFkYXB0ZXJUZXN0cy50aGlzLmRvY3VtZW50QWRhcHRlciwgZS5nZXREb2N1bWVudCgpKTsKLQkJCQkvLyB0aGlzIHdpbGwgYmUgdGhlIHJlbW92YWwgb2YgIjIzNDU2IgotCQkJCWFzc2VydEVxdWFscygyLCBlLmdldE9mZnNldCgpKTsKLQkJCQlhc3NlcnRFcXVhbHMoNSwgZS5nZXRMZW5ndGgoKSk7Ci0JCQl9Ci0JCX0pOwotCQl0aGlzLmRvY3VtZW50QWRhcHRlci5yZW1vdmUoMiwgNSk7Ci0JCWFzc2VydFRydWUodGhpcy5ldmVudEZpcmVkKTsKLQkJYXNzZXJ0RXF1YWxzKCIwMTc4OSIsIHRoaXMuc3RyaW5nSG9sZGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RJbnNlcnQoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5ldmVudEZpcmVkID0gZmFsc2U7Ci0JCXRoaXMuZG9jdW1lbnRBZGFwdGVyLmFkZERvY3VtZW50TGlzdGVuZXIobmV3IFRlc3REb2N1bWVudExpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpbnNlcnRVcGRhdGUoRG9jdW1lbnRFdmVudCBlKSB7Ci0JCQkJRG9jdW1lbnRBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCQlhc3NlcnRFcXVhbHMoRXZlbnRUeXBlLklOU0VSVCwgZS5nZXRUeXBlKCkpOwotCQkJCWFzc2VydEVxdWFscyhEb2N1bWVudEFkYXB0ZXJUZXN0cy50aGlzLmRvY3VtZW50QWRhcHRlciwgZS5nZXREb2N1bWVudCgpKTsKLQkJCQkvLyB0aGlzIHdpbGwgYmUgdGhlIGluc2VydCBvZiAieHh4eHh4IgotCQkJCWFzc2VydEVxdWFscygyLCBlLmdldE9mZnNldCgpKTsKLQkJCQlhc3NlcnRFcXVhbHMoNSwgZS5nZXRMZW5ndGgoKSk7Ci0JCQl9Ci0JCX0pOwotCQl0aGlzLmRvY3VtZW50QWRhcHRlci5pbnNlcnRTdHJpbmcoMiwgInh4eHh4IiwgbnVsbCk7Ci0JCWFzc2VydFRydWUodGhpcy5ldmVudEZpcmVkKTsKLQkJYXNzZXJ0RXF1YWxzKCIwMXh4eHh4MjM0NTY3ODkiLCB0aGlzLnN0cmluZ0hvbGRlci5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2V0VmFsdWUoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5ldmVudEZpcmVkID0gZmFsc2U7Ci0JCXRoaXMuZG9jdW1lbnRBZGFwdGVyLmFkZERvY3VtZW50TGlzdGVuZXIobmV3IFRlc3REb2N1bWVudExpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpbnNlcnRVcGRhdGUoRG9jdW1lbnRFdmVudCBlKSB7Ci0JCQkJRG9jdW1lbnRBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCQlhc3NlcnRFcXVhbHMoRXZlbnRUeXBlLklOU0VSVCwgZS5nZXRUeXBlKCkpOwotCQkJCWFzc2VydEVxdWFscyhEb2N1bWVudEFkYXB0ZXJUZXN0cy50aGlzLmRvY3VtZW50QWRhcHRlciwgZS5nZXREb2N1bWVudCgpKTsKLQkJCQkvLyB0aGlzIHdpbGwgYmUgdGhlIGluc2VydCBvZiAiZm9vIgotCQkJCWFzc2VydEVxdWFscygwLCBlLmdldE9mZnNldCgpKTsKLQkJCQlhc3NlcnRFcXVhbHMoMywgZS5nZXRMZW5ndGgoKSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHJlbW92ZVVwZGF0ZShEb2N1bWVudEV2ZW50IGUpIHsKLQkJCQlhc3NlcnRFcXVhbHMoRXZlbnRUeXBlLlJFTU9WRSwgZS5nZXRUeXBlKCkpOwotCQkJCWFzc2VydEVxdWFscyhEb2N1bWVudEFkYXB0ZXJUZXN0cy50aGlzLmRvY3VtZW50QWRhcHRlciwgZS5nZXREb2N1bWVudCgpKTsKLQkJCQkvLyB0aGlzIHdpbGwgYmUgdGhlIHJlbW92YWwgb2YgIjAxMjM0NTY3ODkiCi0JCQkJYXNzZXJ0RXF1YWxzKDAsIGUuZ2V0T2Zmc2V0KCkpOwotCQkJCWFzc2VydEVxdWFscygxMCwgZS5nZXRMZW5ndGgoKSk7Ci0JCQl9Ci0JCX0pOwotCQlhc3NlcnRFcXVhbHMoIjAxMjM0NTY3ODkiLCB0aGlzLmRvY3VtZW50QWRhcHRlci5nZXRUZXh0KDAsIHRoaXMuZG9jdW1lbnRBZGFwdGVyLmdldExlbmd0aCgpKSk7Ci0JCXRoaXMuc3RyaW5nSG9sZGVyLnNldFZhbHVlKCJmb28iKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmV2ZW50RmlyZWQpOwotCQlhc3NlcnRFcXVhbHMoImZvbyIsIHRoaXMuZG9jdW1lbnRBZGFwdGVyLmdldFRleHQoMCwgdGhpcy5kb2N1bWVudEFkYXB0ZXIuZ2V0TGVuZ3RoKCkpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IGxvY2FsU3RyaW5nSG9sZGVyID0gKFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+KSB0aGlzLnN0cmluZ0hvbGRlcjsKLQkJYXNzZXJ0RmFsc2UobG9jYWxTdHJpbmdIb2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTm9MaXN0ZW5lcnModGhpcy5kb2N1bWVudEFkYXB0ZXIpOwotCi0JCURvY3VtZW50TGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdERvY3VtZW50TGlzdGVuZXIoKTsKLQkJdGhpcy5kb2N1bWVudEFkYXB0ZXIuYWRkRG9jdW1lbnRMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWFzc2VydFRydWUobG9jYWxTdHJpbmdIb2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTGlzdGVuZXJzKHRoaXMuZG9jdW1lbnRBZGFwdGVyKTsKLQotCQl0aGlzLmRvY3VtZW50QWRhcHRlci5yZW1vdmVEb2N1bWVudExpc3RlbmVyKGxpc3RlbmVyKTsKLQkJYXNzZXJ0RmFsc2UobG9jYWxTdHJpbmdIb2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTm9MaXN0ZW5lcnModGhpcy5kb2N1bWVudEFkYXB0ZXIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlIYXNOb0xpc3RlbmVycyhPYmplY3QgZG9jdW1lbnQpIHRocm93cyBFeGNlcHRpb24gewotCQlPYmplY3QgZGVsZWdhdGUgPSBDbGFzc1Rvb2xzLmZpZWxkVmFsdWUoZG9jdW1lbnQsICJkZWxlZ2F0ZSIpOwotCQlPYmplY3RbXSBsaXN0ZW5lcnMgPSAoT2JqZWN0W10pIENsYXNzVG9vbHMuZXhlY3V0ZU1ldGhvZChkZWxlZ2F0ZSwgImdldERvY3VtZW50TGlzdGVuZXJzIik7Ci0JCWFzc2VydEVxdWFscygwLCBsaXN0ZW5lcnMubGVuZ3RoKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5SGFzTGlzdGVuZXJzKE9iamVjdCBkb2N1bWVudCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCU9iamVjdCBkZWxlZ2F0ZSA9IENsYXNzVG9vbHMuZmllbGRWYWx1ZShkb2N1bWVudCwgImRlbGVnYXRlIik7Ci0JCU9iamVjdFtdIGxpc3RlbmVycyA9IChPYmplY3RbXSkgQ2xhc3NUb29scy5leGVjdXRlTWV0aG9kKGRlbGVnYXRlLCAiZ2V0RG9jdW1lbnRMaXN0ZW5lcnMiKTsKLQkJYXNzZXJ0RmFsc2UobGlzdGVuZXJzLmxlbmd0aCA9PSAwKTsKLQl9Ci0KLQotcHJpdmF0ZSBjbGFzcyBUZXN0RG9jdW1lbnRMaXN0ZW5lciBpbXBsZW1lbnRzIERvY3VtZW50TGlzdGVuZXIgewotCVRlc3REb2N1bWVudExpc3RlbmVyKCkgewotCQlzdXBlcigpOwotCX0KLQlwdWJsaWMgdm9pZCBjaGFuZ2VkVXBkYXRlKERvY3VtZW50RXZlbnQgZSkgewotCQlmYWlsKCJ1bmV4cGVjdGVkIGV2ZW50Iik7Ci0JfQotCXB1YmxpYyB2b2lkIGluc2VydFVwZGF0ZShEb2N1bWVudEV2ZW50IGUpIHsKLQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCX0KLQlwdWJsaWMgdm9pZCByZW1vdmVVcGRhdGUoRG9jdW1lbnRFdmVudCBlKSB7Ci0JCWZhaWwoInVuZXhwZWN0ZWQgZXZlbnQiKTsKLQl9Ci19Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvRG9jdW1lbnRBZGFwdGVyVUlUZXN0LmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0RvY3VtZW50QWRhcHRlclVJVGVzdC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzOWI0MzM4Li4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvRG9jdW1lbnRBZGFwdGVyVUlUZXN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyNTUgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZzsKLQotaW1wb3J0IGphdmEuYXd0LkJvcmRlckxheW91dDsKLWltcG9ydCBqYXZhLmF3dC5Db21wb25lbnQ7Ci1pbXBvcnQgamF2YS5hd3QuR3JpZExheW91dDsKLWltcG9ydCBqYXZhLmF3dC5ldmVudC5BY3Rpb25FdmVudDsKLWltcG9ydCBqYXZhLmF3dC5ldmVudC5XaW5kb3dBZGFwdGVyOwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LldpbmRvd0V2ZW50OwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LldpbmRvd0xpc3RlbmVyOwotaW1wb3J0IGphdmF4LnN3aW5nLkFic3RyYWN0QWN0aW9uOwotaW1wb3J0IGphdmF4LnN3aW5nLkFjdGlvbjsKLWltcG9ydCBqYXZheC5zd2luZy5KQnV0dG9uOwotaW1wb3J0IGphdmF4LnN3aW5nLkpGcmFtZTsKLWltcG9ydCBqYXZheC5zd2luZy5KUGFuZWw7Ci1pbXBvcnQgamF2YXguc3dpbmcuSlRleHRGaWVsZDsKLWltcG9ydCBqYXZheC5zd2luZy5XaW5kb3dDb25zdGFudHM7Ci1pbXBvcnQgamF2YXguc3dpbmcudGV4dC5BYnN0cmFjdERvY3VtZW50OwotaW1wb3J0IGphdmF4LnN3aW5nLnRleHQuQXR0cmlidXRlU2V0OwotaW1wb3J0IGphdmF4LnN3aW5nLnRleHQuQmFkTG9jYXRpb25FeGNlcHRpb247Ci1pbXBvcnQgamF2YXguc3dpbmcudGV4dC5Eb2N1bWVudDsKLWltcG9ydCBqYXZheC5zd2luZy50ZXh0LlBsYWluRG9jdW1lbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLkRvY3VtZW50QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci0KLS8qKgotICogUGxheSBhcm91bmQgd2l0aCBhIHNldCBvZiBlbnRyeSBmaWVsZHMuCi0gKi8KLXB1YmxpYyBjbGFzcyBEb2N1bWVudEFkYXB0ZXJVSVRlc3QgewotCi0JcHJpdmF0ZSBUZXN0TW9kZWwgdGVzdE1vZGVsOwotCQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgREVGQVVMVF9OQU1FID0gIlNjb29ieSBEb28iOwotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdE1vZGVsPiB0ZXN0TW9kZWxIb2xkZXI7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IG5hbWVIb2xkZXI7Ci0JcHJpdmF0ZSBEb2N1bWVudCBuYW1lRG9jdW1lbnQ7Ci0JcHJpdmF0ZSBEb2N1bWVudCB1cHBlckNhc2VOYW1lRG9jdW1lbnQ7Ci0KLQlwdWJsaWMgc3RhdGljIHZvaWQgbWFpbihTdHJpbmdbXSBhcmdzKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJbmV3IERvY3VtZW50QWRhcHRlclVJVGVzdCgpLmV4ZWMoYXJncyk7Ci0JfQotCi0JcHJpdmF0ZSBEb2N1bWVudEFkYXB0ZXJVSVRlc3QoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGV4ZWMoU3RyaW5nW10gYXJncykgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMudGVzdE1vZGVsID0gbmV3IFRlc3RNb2RlbChERUZBVUxUX05BTUUpOwotCQl0aGlzLnRlc3RNb2RlbEhvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8VGVzdE1vZGVsPih0aGlzLnRlc3RNb2RlbCk7Ci0JCXRoaXMubmFtZUhvbGRlciA9IHRoaXMuYnVpbGROYW1lSG9sZGVyKHRoaXMudGVzdE1vZGVsSG9sZGVyKTsKLQkJdGhpcy5uYW1lRG9jdW1lbnQgPSB0aGlzLmJ1aWxkTmFtZURvY3VtZW50KHRoaXMubmFtZUhvbGRlcik7Ci0JCXRoaXMudXBwZXJDYXNlTmFtZURvY3VtZW50ID0gdGhpcy5idWlsZFVwcGVyQ2FzZU5hbWVEb2N1bWVudCh0aGlzLm5hbWVIb2xkZXIpOwotCQl0aGlzLm9wZW5XaW5kb3coKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGROYW1lSG9sZGVyKFByb3BlcnR5VmFsdWVNb2RlbDxUZXN0TW9kZWw+IHZtKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFRlc3RNb2RlbCwgU3RyaW5nPih2bSwgVGVzdE1vZGVsLk5BTUVfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldE5hbWUoKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCQkJCXRoaXMuc3ViamVjdC5zZXROYW1lKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIERvY3VtZW50IGJ1aWxkTmFtZURvY3VtZW50KFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gc3RyaW5nSG9sZGVyKSB7Ci0JCXJldHVybiBuZXcgRG9jdW1lbnRBZGFwdGVyKHN0cmluZ0hvbGRlcik7Ci0JfQotCi0JcHJpdmF0ZSBEb2N1bWVudCBidWlsZFVwcGVyQ2FzZU5hbWVEb2N1bWVudChXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxTdHJpbmc+IHN0cmluZ0hvbGRlcikgewotCQlyZXR1cm4gbmV3IERvY3VtZW50QWRhcHRlcihzdHJpbmdIb2xkZXIsIHRoaXMuYnVpbGRVcHBlckNhc2VOYW1lRG9jdW1lbnREZWxlZ2F0ZSgpKTsKLQl9Ci0KLQlwcml2YXRlIEFic3RyYWN0RG9jdW1lbnQgYnVpbGRVcHBlckNhc2VOYW1lRG9jdW1lbnREZWxlZ2F0ZSgpIHsKLQkJcmV0dXJuIG5ldyBQbGFpbkRvY3VtZW50KCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBpbnNlcnRTdHJpbmcoaW50IG9mZnNldCwgU3RyaW5nIHN0cmluZywgQXR0cmlidXRlU2V0IGEpIHRocm93cyBCYWRMb2NhdGlvbkV4Y2VwdGlvbiB7Ci0JCQkJaWYgKHN0cmluZyA9PSBudWxsKSB7Ci0JCQkJCXJldHVybjsKLQkJCQl9Ci0JCQkJY2hhcltdIHVwcGVyID0gc3RyaW5nLnRvQ2hhckFycmF5KCk7Ci0JCQkJZm9yIChpbnQgaSA9IDA7IGkgPCB1cHBlci5sZW5ndGg7IGkrKykgewotCQkJCQl1cHBlcltpXSA9IENoYXJhY3Rlci50b1VwcGVyQ2FzZSh1cHBlcltpXSk7Ci0JCQkJfQotCQkJCXN1cGVyLmluc2VydFN0cmluZyhvZmZzZXQsIG5ldyBTdHJpbmcodXBwZXIpLCBhKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgb3BlbldpbmRvdygpIHsKLQkJSkZyYW1lIHdpbmRvdyA9IG5ldyBKRnJhbWUodGhpcy5nZXRDbGFzcygpLmdldE5hbWUoKSk7Ci0JCXdpbmRvdy5zZXREZWZhdWx0Q2xvc2VPcGVyYXRpb24oV2luZG93Q29uc3RhbnRzLkRPX05PVEhJTkdfT05fQ0xPU0UpOwotCQl3aW5kb3cuYWRkV2luZG93TGlzdGVuZXIodGhpcy5idWlsZFdpbmRvd0xpc3RlbmVyKCkpOwotCQl3aW5kb3cuZ2V0Q29udGVudFBhbmUoKS5hZGQodGhpcy5idWlsZE1haW5QYW5lbCgpLCAiQ2VudGVyIik7Ci0JCXdpbmRvdy5zZXRTaXplKDQwMCwgMTAwKTsKLQkJd2luZG93LnNldFZpc2libGUodHJ1ZSk7Ci0JfQotCi0JcHJpdmF0ZSBXaW5kb3dMaXN0ZW5lciBidWlsZFdpbmRvd0xpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFdpbmRvd0FkYXB0ZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHdpbmRvd0Nsb3NpbmcoV2luZG93RXZlbnQgZSkgewotCQkJCWUuZ2V0V2luZG93KCkuc2V0VmlzaWJsZShmYWxzZSk7Ci0JCQkJU3lzdGVtLmV4aXQoMCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRNYWluUGFuZWwoKSB7Ci0JCUpQYW5lbCBtYWluUGFuZWwgPSBuZXcgSlBhbmVsKG5ldyBCb3JkZXJMYXlvdXQoKSk7Ci0JCW1haW5QYW5lbC5hZGQodGhpcy5idWlsZFRleHRGaWVsZFBhbmVsKCksIEJvcmRlckxheW91dC5OT1JUSCk7Ci0JCW1haW5QYW5lbC5hZGQodGhpcy5idWlsZENvbnRyb2xQYW5lbCgpLCBCb3JkZXJMYXlvdXQuU09VVEgpOwotCQlyZXR1cm4gbWFpblBhbmVsOwotCX0KLQotCXByaXZhdGUgQ29tcG9uZW50IGJ1aWxkVGV4dEZpZWxkUGFuZWwoKSB7Ci0JCUpQYW5lbCB0YXNrTGlzdFBhbmVsID0gbmV3IEpQYW5lbChuZXcgR3JpZExheW91dCgxLCAwKSk7Ci0JCXRhc2tMaXN0UGFuZWwuYWRkKHRoaXMuYnVpbGROYW1lVGV4dEZpZWxkKCkpOwotCQl0YXNrTGlzdFBhbmVsLmFkZCh0aGlzLmJ1aWxkUmVhZE9ubHlOYW1lVGV4dEZpZWxkKCkpOwotCQl0YXNrTGlzdFBhbmVsLmFkZCh0aGlzLmJ1aWxkVXBwZXJDYXNlTmFtZVRleHRGaWVsZCgpKTsKLQkJcmV0dXJuIHRhc2tMaXN0UGFuZWw7Ci0JfQotCi0JcHJpdmF0ZSBKVGV4dEZpZWxkIGJ1aWxkTmFtZVRleHRGaWVsZCgpIHsKLQkJcmV0dXJuIG5ldyBKVGV4dEZpZWxkKHRoaXMubmFtZURvY3VtZW50LCBudWxsLCAwKTsKLQl9Ci0KLQlwcml2YXRlIEpUZXh0RmllbGQgYnVpbGRSZWFkT25seU5hbWVUZXh0RmllbGQoKSB7Ci0JCUpUZXh0RmllbGQgbmFtZVRleHRGaWVsZCA9IHRoaXMuYnVpbGROYW1lVGV4dEZpZWxkKCk7Ci0JCW5hbWVUZXh0RmllbGQuc2V0RWRpdGFibGUoZmFsc2UpOwotCQlyZXR1cm4gbmFtZVRleHRGaWVsZDsKLQl9Ci0KLQlwcml2YXRlIEpUZXh0RmllbGQgYnVpbGRVcHBlckNhc2VOYW1lVGV4dEZpZWxkKCkgewotCQlyZXR1cm4gbmV3IEpUZXh0RmllbGQodGhpcy51cHBlckNhc2VOYW1lRG9jdW1lbnQsIG51bGwsIDApOwotCX0KLQotCXByaXZhdGUgQ29tcG9uZW50IGJ1aWxkQ29udHJvbFBhbmVsKCkgewotCQlKUGFuZWwgY29udHJvbFBhbmVsID0gbmV3IEpQYW5lbChuZXcgR3JpZExheW91dCgxLCAwKSk7Ci0JCWNvbnRyb2xQYW5lbC5hZGQodGhpcy5idWlsZFJlc2V0TmFtZUJ1dHRvbigpKTsKLQkJY29udHJvbFBhbmVsLmFkZCh0aGlzLmJ1aWxkQ2xlYXJNb2RlbEJ1dHRvbigpKTsKLQkJY29udHJvbFBhbmVsLmFkZCh0aGlzLmJ1aWxkUmVzdG9yZU1vZGVsQnV0dG9uKCkpOwotCQljb250cm9sUGFuZWwuYWRkKHRoaXMuYnVpbGRQcmludE1vZGVsQnV0dG9uKCkpOwotCQlyZXR1cm4gY29udHJvbFBhbmVsOwotCX0KLQotCXByaXZhdGUgSkJ1dHRvbiBidWlsZFJlc2V0TmFtZUJ1dHRvbigpIHsKLQkJcmV0dXJuIG5ldyBKQnV0dG9uKHRoaXMuYnVpbGRSZXNldE5hbWVBY3Rpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb24gYnVpbGRSZXNldE5hbWVBY3Rpb24oKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWJzdHJhY3RBY3Rpb24oInJlc2V0IG5hbWUiKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZXZlbnQpIHsKLQkJCQlEb2N1bWVudEFkYXB0ZXJVSVRlc3QudGhpcy5yZXNldE5hbWUoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldEVuYWJsZWQodHJ1ZSk7Ci0JCXJldHVybiBhY3Rpb247Ci0JfQotCi0Jdm9pZCByZXNldE5hbWUoKSB7Ci0JCXRoaXMudGVzdE1vZGVsLnNldE5hbWUoREVGQVVMVF9OQU1FKTsKLQl9Ci0KLQlwcml2YXRlIEpCdXR0b24gYnVpbGRDbGVhck1vZGVsQnV0dG9uKCkgewotCQlyZXR1cm4gbmV3IEpCdXR0b24odGhpcy5idWlsZENsZWFyTW9kZWxBY3Rpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb24gYnVpbGRDbGVhck1vZGVsQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJjbGVhciBtb2RlbCIpIHsKLQkJCXB1YmxpYyB2b2lkIGFjdGlvblBlcmZvcm1lZChBY3Rpb25FdmVudCBldmVudCkgewotCQkJCURvY3VtZW50QWRhcHRlclVJVGVzdC50aGlzLmNsZWFyTW9kZWwoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldEVuYWJsZWQodHJ1ZSk7Ci0JCXJldHVybiBhY3Rpb247Ci0JfQotCi0Jdm9pZCBjbGVhck1vZGVsKCkgewotCQl0aGlzLnRlc3RNb2RlbEhvbGRlci5zZXRWYWx1ZShudWxsKTsKLQl9Ci0KLQlwcml2YXRlIEpCdXR0b24gYnVpbGRSZXN0b3JlTW9kZWxCdXR0b24oKSB7Ci0JCXJldHVybiBuZXcgSkJ1dHRvbih0aGlzLmJ1aWxkUmVzdG9yZU1vZGVsQWN0aW9uKCkpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uIGJ1aWxkUmVzdG9yZU1vZGVsQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJyZXN0b3JlIG1vZGVsIikgewotCQkJcHVibGljIHZvaWQgYWN0aW9uUGVyZm9ybWVkKEFjdGlvbkV2ZW50IGV2ZW50KSB7Ci0JCQkJRG9jdW1lbnRBZGFwdGVyVUlUZXN0LnRoaXMucmVzdG9yZU1vZGVsKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRFbmFibGVkKHRydWUpOwotCQlyZXR1cm4gYWN0aW9uOwotCX0KLQotCXZvaWQgcmVzdG9yZU1vZGVsKCkgewotCQl0aGlzLnRlc3RNb2RlbEhvbGRlci5zZXRWYWx1ZSh0aGlzLnRlc3RNb2RlbCk7Ci0JfQotCi0JcHJpdmF0ZSBKQnV0dG9uIGJ1aWxkUHJpbnRNb2RlbEJ1dHRvbigpIHsKLQkJcmV0dXJuIG5ldyBKQnV0dG9uKHRoaXMuYnVpbGRQcmludE1vZGVsQWN0aW9uKCkpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uIGJ1aWxkUHJpbnRNb2RlbEFjdGlvbigpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBYnN0cmFjdEFjdGlvbigicHJpbnQgbW9kZWwiKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZXZlbnQpIHsKLQkJCQlEb2N1bWVudEFkYXB0ZXJVSVRlc3QudGhpcy5wcmludE1vZGVsKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRFbmFibGVkKHRydWUpOwotCQlyZXR1cm4gYWN0aW9uOwotCX0KLQotCXZvaWQgcHJpbnRNb2RlbCgpIHsKLQkJU3lzdGVtLm91dC5wcmludGxuKCJuYW1lOiAiICsgdGhpcy50ZXN0TW9kZWwuZ2V0TmFtZSgpKTsKLQl9Ci0KLQotCXByaXZhdGUgY2xhc3MgVGVzdE1vZGVsIGV4dGVuZHMgQWJzdHJhY3RNb2RlbCB7Ci0JCXByaXZhdGUgU3RyaW5nIG5hbWU7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBOQU1FX1BST1BFUlRZID0gIm5hbWUiOwotCQotCQlwdWJsaWMgVGVzdE1vZGVsKFN0cmluZyBuYW1lKSB7Ci0JCQl0aGlzLm5hbWUgPSBuYW1lOwotCQl9Ci0JCXB1YmxpYyBTdHJpbmcgZ2V0TmFtZSgpIHsKLQkJCXJldHVybiB0aGlzLm5hbWU7Ci0JCX0KLQkJcHVibGljIHZvaWQgc2V0TmFtZShTdHJpbmcgbmFtZSkgewotCQkJT2JqZWN0IG9sZCA9IHRoaXMubmFtZTsKLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoTkFNRV9QUk9QRVJUWSwgb2xkLCBuYW1lKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiAiVGVzdE1vZGVsKCIgKyB0aGlzLmdldE5hbWUoKSArICIpIjsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9KcHRVdGlsaXR5TW9kZWxWYWx1ZVN3aW5nVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvSnB0VXRpbGl0eU1vZGVsVmFsdWVTd2luZ1Rlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGI1MzFiZDMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9KcHRVdGlsaXR5TW9kZWxWYWx1ZVN3aW5nVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDQyICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcgT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmc7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdFN1aXRlOwotCi1wdWJsaWMgY2xhc3MgSnB0VXRpbGl0eU1vZGVsVmFsdWVTd2luZ1Rlc3RzIHsKLQkKLQlwdWJsaWMgc3RhdGljIFRlc3Qgc3VpdGUoKSB7Ci0JCVRlc3RTdWl0ZSBzdWl0ZSA9IG5ldyBUZXN0U3VpdGUoSnB0VXRpbGl0eU1vZGVsVmFsdWVTd2luZ1Rlc3RzLmNsYXNzLmdldFBhY2thZ2UoKS5nZXROYW1lKCkpOwotCi0JCXN1aXRlLmFkZFRlc3RTdWl0ZShDaGVja0JveE1vZGVsQWRhcHRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKENvbWJvQm94TW9kZWxBZGFwdGVyVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoRGF0ZVNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShEb2N1bWVudEFkYXB0ZXJUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShMaXN0TW9kZWxBZGFwdGVyVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoTGlzdFNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0cy5jbGFzcyk7Ci0JCXN1aXRlLmFkZFRlc3RTdWl0ZShOdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoUHJpbWl0aXZlTGlzdFRyZWVNb2RlbFRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFJhZGlvQnV0dG9uTW9kZWxBZGFwdGVyVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoU3Bpbm5lck1vZGVsQWRhcHRlclRlc3RzLmNsYXNzKTsKLQkJc3VpdGUuYWRkVGVzdFN1aXRlKFRhYmxlTW9kZWxBZGFwdGVyVGVzdHMuY2xhc3MpOwotCQlzdWl0ZS5hZGRUZXN0U3VpdGUoVHJlZU1vZGVsQWRhcHRlclRlc3RzLmNsYXNzKTsKLQkKLQkJcmV0dXJuIHN1aXRlOwotCX0KLQkKLQlwcml2YXRlIEpwdFV0aWxpdHlNb2RlbFZhbHVlU3dpbmdUZXN0cygpIHsKLQkJc3VwZXIoKTsKLQkJdGhyb3cgbmV3IFVuc3VwcG9ydGVkT3BlcmF0aW9uRXhjZXB0aW9uKCk7Ci0JfQotCQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9MaXN0TW9kZWxBZGFwdGVyVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvTGlzdE1vZGVsQWRhcHRlclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDRjYjJlMDQuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9MaXN0TW9kZWxBZGFwdGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDMxNSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuQ29tcGFyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLlNvcnRlZFNldDsKLWltcG9ydCBqYXZhLnV0aWwuVHJlZVNldDsKLWltcG9ydCBqYXZheC5zd2luZy5MaXN0TW9kZWw7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkJhZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5DbGFzc1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkhhc2hCYWc7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLkxpc3RNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuTGlzdENoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLkNvb3JkaW5hdGVkTGlzdDsKLQotcHVibGljIGNsYXNzIExpc3RNb2RlbEFkYXB0ZXJUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQotCXB1YmxpYyBMaXN0TW9kZWxBZGFwdGVyVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJLy8gbm90aGluZyB5ZXQuLi4KLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQkvLyBub3RoaW5nIHlldC4uLgotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXByaXZhdGUgTGlzdE1vZGVsQWRhcHRlciBidWlsZExpc3RNb2RlbChMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGxpc3RIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBMaXN0TW9kZWxBZGFwdGVyKGxpc3RIb2xkZXIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIExpc3RDaGFuZ2VMaXN0ZW5lciBidWlsZExpc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCQlyZXR1cm4gdGhpcy5idWlsZExpc3RDaGFuZ2VMaXN0ZW5lcl8oKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIExpc3RNb2RlbCBidWlsZExpc3RNb2RlbChDb2xsZWN0aW9uVmFsdWVNb2RlbDxTdHJpbmc+IGNvbGxlY3Rpb25Ib2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBMaXN0TW9kZWxBZGFwdGVyKGNvbGxlY3Rpb25Ib2xkZXIpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIExpc3RDaGFuZ2VMaXN0ZW5lciBidWlsZExpc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCQlyZXR1cm4gdGhpcy5idWlsZExpc3RDaGFuZ2VMaXN0ZW5lcl8oKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q29sbGVjdGlvblN5bmNocm9uaXphdGlvbigpIHsKLQkJU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8U3RyaW5nPiBjb2xsZWN0aW9uSG9sZGVyID0gdGhpcy5idWlsZENvbGxlY3Rpb25Ib2xkZXIoKTsKLQkJTGlzdE1vZGVsIGxpc3RNb2RlbCA9IHRoaXMuYnVpbGRMaXN0TW9kZWwoY29sbGVjdGlvbkhvbGRlcik7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPihsaXN0TW9kZWwpOwotCQlhc3NlcnRFcXVhbHMoNiwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0TW9kZWwsIHN5bmNoTGlzdCk7Ci0KLQkJY29sbGVjdGlvbkhvbGRlci5hZGQoInRvbSIpOwotCQljb2xsZWN0aW9uSG9sZGVyLmFkZCgiZGljayIpOwotCQljb2xsZWN0aW9uSG9sZGVyLmFkZCgiaGFycnkiKTsKLQkJY29sbGVjdGlvbkhvbGRlci5hZGQobnVsbCk7Ci0JCWFzc2VydEVxdWFscygxMCwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZShsaXN0TW9kZWwsIHN5bmNoTGlzdCk7Ci0KLQkJY29sbGVjdGlvbkhvbGRlci5yZW1vdmUoImZvbyIpOwotCQljb2xsZWN0aW9uSG9sZGVyLnJlbW92ZSgiamFyIik7Ci0JCWNvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlKCJoYXJyeSIpOwotCQljb2xsZWN0aW9uSG9sZGVyLnJlbW92ZShudWxsKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmUobGlzdE1vZGVsLCBzeW5jaExpc3QpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMaXN0U3luY2hyb25pemF0aW9uKCkgewotCQlTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGxpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcigpOwotCQlMaXN0TW9kZWwgbGlzdE1vZGVsID0gdGhpcy5idWlsZExpc3RNb2RlbChsaXN0SG9sZGVyKTsKLQkJQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4gc3luY2hMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KGxpc3RNb2RlbCk7Ci0JCWFzc2VydEVxdWFscyg2LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlKGxpc3RNb2RlbCwgc3luY2hMaXN0KTsKLQotCQlsaXN0SG9sZGVyLmFkZCg2LCAidG9tIik7Ci0JCWxpc3RIb2xkZXIuYWRkKDcsICJkaWNrIik7Ci0JCWxpc3RIb2xkZXIuYWRkKDgsICJoYXJyeSIpOwotCQlsaXN0SG9sZGVyLmFkZCg5LCBudWxsKTsKLQkJYXNzZXJ0RXF1YWxzKDEwLCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlKGxpc3RNb2RlbCwgc3luY2hMaXN0KTsKLQotCQlsaXN0SG9sZGVyLnJlbW92ZSg5KTsKLQkJbGlzdEhvbGRlci5yZW1vdmUoOCk7Ci0JCWxpc3RIb2xkZXIucmVtb3ZlKDQpOwotCQlsaXN0SG9sZGVyLnJlbW92ZSgwKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmUobGlzdE1vZGVsLCBzeW5jaExpc3QpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRNb2RlbCgpIHsKLQkJU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBsaXN0SG9sZGVyMSA9IHRoaXMuYnVpbGRMaXN0SG9sZGVyKCk7Ci0JCUxpc3RNb2RlbEFkYXB0ZXIgbGlzdE1vZGVsID0gdGhpcy5idWlsZExpc3RNb2RlbChsaXN0SG9sZGVyMSk7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPihsaXN0TW9kZWwpOwotCQlhc3NlcnRUcnVlKGxpc3RIb2xkZXIxLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmUobGlzdE1vZGVsLCBzeW5jaExpc3QpOwotCi0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gbGlzdEhvbGRlcjIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcjIoKTsKLQkJbGlzdE1vZGVsLnNldE1vZGVsKGxpc3RIb2xkZXIyKTsKLQkJYXNzZXJ0RXF1YWxzKDMsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmUobGlzdE1vZGVsLCBzeW5jaExpc3QpOwotCQlhc3NlcnRUcnVlKGxpc3RIb2xkZXIxLmhhc05vTGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQlhc3NlcnRUcnVlKGxpc3RIb2xkZXIyLmhhc0FueUxpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQotCQlsaXN0TW9kZWwuc2V0TW9kZWwobmV3IFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4oKSk7Ci0JCWFzc2VydEVxdWFscygwLCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlKGxpc3RNb2RlbCwgc3luY2hMaXN0KTsKLQkJYXNzZXJ0VHJ1ZShsaXN0SG9sZGVyMS5oYXNOb0xpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQkJYXNzZXJ0VHJ1ZShsaXN0SG9sZGVyMi5oYXNOb0xpc3RDaGFuZ2VMaXN0ZW5lcnMoTGlzdFZhbHVlTW9kZWwuTElTVF9WQUxVRVMpKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgY29tcGFyZShMaXN0TW9kZWwgbGlzdE1vZGVsLCBMaXN0PFN0cmluZz4gbGlzdCkgewotCQlhc3NlcnRFcXVhbHMobGlzdE1vZGVsLmdldFNpemUoKSwgbGlzdC5zaXplKCkpOwotCQlmb3IgKGludCBpID0gMDsgaSA8IGxpc3RNb2RlbC5nZXRTaXplKCk7IGkrKykgewotCQkJYXNzZXJ0RXF1YWxzKGxpc3RNb2RlbC5nZXRFbGVtZW50QXQoaSksIGxpc3QuZ2V0KGkpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDb2xsZWN0aW9uU29ydCgpIHsKLQkJdGhpcy52ZXJpZnlDb2xsZWN0aW9uU29ydChudWxsKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0TGlzdFNvcnQoKSB7Ci0JCXRoaXMudmVyaWZ5TGlzdFNvcnQobnVsbCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEN1c3RvbUNvbGxlY3Rpb25Tb3J0KCkgewotCQl0aGlzLnZlcmlmeUNvbGxlY3Rpb25Tb3J0KHRoaXMuYnVpbGRDdXN0b21Db21wYXJhdG9yKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDdXN0b21MaXN0U29ydCgpIHsKLQkJdGhpcy52ZXJpZnlMaXN0U29ydCh0aGlzLmJ1aWxkQ3VzdG9tQ29tcGFyYXRvcigpKTsKLQl9Ci0KLQlwcml2YXRlIENvbXBhcmF0b3I8U3RyaW5nPiBidWlsZEN1c3RvbUNvbXBhcmF0b3IoKSB7Ci0JCS8vIHNvcnQgd2l0aCByZXZlcnNlIG9yZGVyCi0JCXJldHVybiBuZXcgQ29tcGFyYXRvcjxTdHJpbmc+KCkgewotCQkJcHVibGljIGludCBjb21wYXJlKFN0cmluZyBzMSwgU3RyaW5nIHMyKSB7Ci0JCQkJcmV0dXJuIHMyLmNvbXBhcmVUbyhzMSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUNvbGxlY3Rpb25Tb3J0KENvbXBhcmF0b3I8U3RyaW5nPiBjb21wYXJhdG9yKSB7Ci0JCVNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4gY29sbGVjdGlvbkhvbGRlciA9IHRoaXMuYnVpbGRDb2xsZWN0aW9uSG9sZGVyKCk7Ci0JCUxpc3RNb2RlbCBsaXN0TW9kZWwgPSB0aGlzLmJ1aWxkTGlzdE1vZGVsKG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8U3RyaW5nPihjb2xsZWN0aW9uSG9sZGVyLCBjb21wYXJhdG9yKSk7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPihsaXN0TW9kZWwpOwotCQlhc3NlcnRFcXVhbHMoNiwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZVNvcnQobGlzdE1vZGVsLCBzeW5jaExpc3QsIGNvbXBhcmF0b3IpOwotCi0JCWNvbGxlY3Rpb25Ib2xkZXIuYWRkKCJ0b20iKTsKLQkJY29sbGVjdGlvbkhvbGRlci5hZGQoImRpY2siKTsKLQkJY29sbGVjdGlvbkhvbGRlci5hZGQoImhhcnJ5Iik7Ci0JCWFzc2VydEVxdWFscyg5LCBzeW5jaExpc3Quc2l6ZSgpKTsKLQkJdGhpcy5jb21wYXJlU29ydChsaXN0TW9kZWwsIHN5bmNoTGlzdCwgY29tcGFyYXRvcik7Ci0KLQkJY29sbGVjdGlvbkhvbGRlci5yZW1vdmUoImZvbyIpOwotCQljb2xsZWN0aW9uSG9sZGVyLnJlbW92ZSgiamFyIik7Ci0JCWNvbGxlY3Rpb25Ib2xkZXIucmVtb3ZlKCJoYXJyeSIpOwotCQlhc3NlcnRFcXVhbHMoNiwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZVNvcnQobGlzdE1vZGVsLCBzeW5jaExpc3QsIGNvbXBhcmF0b3IpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlMaXN0U29ydChDb21wYXJhdG9yPFN0cmluZz4gY29tcGFyYXRvcikgewotCQlTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGxpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcigpOwotCQlMaXN0TW9kZWwgbGlzdE1vZGVsID0gdGhpcy5idWlsZExpc3RNb2RlbChuZXcgU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyPFN0cmluZz4obGlzdEhvbGRlciwgY29tcGFyYXRvcikpOwotCQlDb29yZGluYXRlZExpc3Q8U3RyaW5nPiBzeW5jaExpc3QgPSBuZXcgQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4obGlzdE1vZGVsKTsKLQkJYXNzZXJ0RXF1YWxzKDYsIHN5bmNoTGlzdC5zaXplKCkpOwotCQl0aGlzLmNvbXBhcmVTb3J0KGxpc3RNb2RlbCwgc3luY2hMaXN0LCBjb21wYXJhdG9yKTsKLQotCQlsaXN0SG9sZGVyLmFkZCgwLCAidG9tIik7Ci0JCWxpc3RIb2xkZXIuYWRkKDAsICJkaWNrIik7Ci0JCWxpc3RIb2xkZXIuYWRkKDAsICJoYXJyeSIpOwotCQlhc3NlcnRFcXVhbHMoOSwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZVNvcnQobGlzdE1vZGVsLCBzeW5jaExpc3QsIGNvbXBhcmF0b3IpOwotCi0JCWxpc3RIb2xkZXIucmVtb3ZlKDgpOwotCQlsaXN0SG9sZGVyLnJlbW92ZSg0KTsKLQkJbGlzdEhvbGRlci5yZW1vdmUoMCk7Ci0JCWxpc3RIb2xkZXIucmVtb3ZlKDUpOwotCQlhc3NlcnRFcXVhbHMoNSwgc3luY2hMaXN0LnNpemUoKSk7Ci0JCXRoaXMuY29tcGFyZVNvcnQobGlzdE1vZGVsLCBzeW5jaExpc3QsIGNvbXBhcmF0b3IpOwotCX0KLQotCXByaXZhdGUgdm9pZCBjb21wYXJlU29ydChMaXN0TW9kZWwgbGlzdE1vZGVsLCBMaXN0PFN0cmluZz4gbGlzdCwgQ29tcGFyYXRvcjxTdHJpbmc+IGNvbXBhcmF0b3IpIHsKLQkJU29ydGVkU2V0PFN0cmluZz4gc3MgPSBuZXcgVHJlZVNldDxTdHJpbmc+KGNvbXBhcmF0b3IpOwotCQlmb3IgKGludCBpID0gMDsgaSA8IGxpc3RNb2RlbC5nZXRTaXplKCk7IGkrKykgewotCQkJc3MuYWRkKChTdHJpbmcpIGxpc3RNb2RlbC5nZXRFbGVtZW50QXQoaSkpOwotCQl9Ci0JCWFzc2VydEVxdWFscyhzcy5zaXplKCksIGxpc3Quc2l6ZSgpKTsKLQkJZm9yIChJdGVyYXRvcjxTdHJpbmc+IHN0cmVhbTEgPSBzcy5pdGVyYXRvcigpLCBzdHJlYW0yID0gbGlzdC5pdGVyYXRvcigpOyBzdHJlYW0xLmhhc05leHQoKTsgKSB7Ci0JCQlhc3NlcnRFcXVhbHMoc3RyZWFtMS5uZXh0KCksIHN0cmVhbTIubmV4dCgpKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNMaXN0ZW5lcnMoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJU2ltcGxlTGlzdFZhbHVlTW9kZWw8U3RyaW5nPiBsaXN0SG9sZGVyID0gdGhpcy5idWlsZExpc3RIb2xkZXIoKTsKLQkJYXNzZXJ0RmFsc2UobGlzdEhvbGRlci5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0KLQkJTGlzdE1vZGVsIGxpc3RNb2RlbCA9IHRoaXMuYnVpbGRMaXN0TW9kZWwobGlzdEhvbGRlcik7Ci0JCWFzc2VydEZhbHNlKGxpc3RIb2xkZXIuaGFzQW55TGlzdENoYW5nZUxpc3RlbmVycyhMaXN0VmFsdWVNb2RlbC5MSVNUX1ZBTFVFUykpOwotCQl0aGlzLnZlcmlmeUhhc05vTGlzdGVuZXJzKGxpc3RNb2RlbCk7Ci0KLQkJQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4gc3luY2hMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KGxpc3RNb2RlbCk7Ci0JCWFzc2VydFRydWUobGlzdEhvbGRlci5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTGlzdGVuZXJzKGxpc3RNb2RlbCk7Ci0KLQkJbGlzdE1vZGVsLnJlbW92ZUxpc3REYXRhTGlzdGVuZXIoc3luY2hMaXN0KTsKLQkJYXNzZXJ0RmFsc2UobGlzdEhvbGRlci5oYXNBbnlMaXN0Q2hhbmdlTGlzdGVuZXJzKExpc3RWYWx1ZU1vZGVsLkxJU1RfVkFMVUVTKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTm9MaXN0ZW5lcnMobGlzdE1vZGVsKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0R2V0U2l6ZSgpIHRocm93cyBFeGNlcHRpb24gewotCQlTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGxpc3RIb2xkZXIgPSB0aGlzLmJ1aWxkTGlzdEhvbGRlcigpOwotCQlMaXN0TW9kZWwgbGlzdE1vZGVsID0gdGhpcy5idWlsZExpc3RNb2RlbChsaXN0SG9sZGVyKTsKLQkJdGhpcy52ZXJpZnlIYXNOb0xpc3RlbmVycyhsaXN0TW9kZWwpOwotCQlhc3NlcnRFcXVhbHMoNiwgbGlzdE1vZGVsLmdldFNpemUoKSk7Ci0KLQkJQ29vcmRpbmF0ZWRMaXN0PFN0cmluZz4gc3luY2hMaXN0ID0gbmV3IENvb3JkaW5hdGVkTGlzdDxTdHJpbmc+KGxpc3RNb2RlbCk7Ci0JCXRoaXMudmVyaWZ5SGFzTGlzdGVuZXJzKGxpc3RNb2RlbCk7Ci0JCWFzc2VydEVxdWFscyg2LCBsaXN0TW9kZWwuZ2V0U2l6ZSgpKTsKLQotCQlsaXN0TW9kZWwucmVtb3ZlTGlzdERhdGFMaXN0ZW5lcihzeW5jaExpc3QpOwotCQl0aGlzLnZlcmlmeUhhc05vTGlzdGVuZXJzKGxpc3RNb2RlbCk7Ci0JCWFzc2VydEVxdWFscyg2LCBsaXN0TW9kZWwuZ2V0U2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0R2V0RWxlbWVudEF0KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gbGlzdEhvbGRlciA9IHRoaXMuYnVpbGRMaXN0SG9sZGVyKCk7Ci0JCUxpc3RNb2RlbCBsaXN0TW9kZWwgPSB0aGlzLmJ1aWxkTGlzdE1vZGVsKG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8U3RyaW5nPihsaXN0SG9sZGVyKSk7Ci0JCUNvb3JkaW5hdGVkTGlzdDxTdHJpbmc+IHN5bmNoTGlzdCA9IG5ldyBDb29yZGluYXRlZExpc3Q8U3RyaW5nPihsaXN0TW9kZWwpOwotCQl0aGlzLnZlcmlmeUhhc0xpc3RlbmVycyhsaXN0TW9kZWwpOwotCQlhc3NlcnRFcXVhbHMoImJhciIsIGxpc3RNb2RlbC5nZXRFbGVtZW50QXQoMCkpOwotCQlhc3NlcnRFcXVhbHMoImJhciIsIHN5bmNoTGlzdC5nZXQoMCkpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlIYXNOb0xpc3RlbmVycyhMaXN0TW9kZWwgbGlzdE1vZGVsKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYm9vbGVhbiBoYXNOb0xpc3RlbmVycyA9ICgoQm9vbGVhbikgQ2xhc3NUb29scy5leGVjdXRlTWV0aG9kKGxpc3RNb2RlbCwgImhhc05vTGlzdERhdGFMaXN0ZW5lcnMiKSkuYm9vbGVhblZhbHVlKCk7Ci0JCWFzc2VydFRydWUoaGFzTm9MaXN0ZW5lcnMpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlIYXNMaXN0ZW5lcnMoTGlzdE1vZGVsIGxpc3RNb2RlbCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWJvb2xlYW4gaGFzTGlzdGVuZXJzID0gKChCb29sZWFuKSBDbGFzc1Rvb2xzLmV4ZWN1dGVNZXRob2QobGlzdE1vZGVsLCAiaGFzTGlzdERhdGFMaXN0ZW5lcnMiKSkuYm9vbGVhblZhbHVlKCk7Ci0JCWFzc2VydFRydWUoaGFzTGlzdGVuZXJzKTsKLQl9Ci0KLQlwcml2YXRlIFNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRDb2xsZWN0aW9uSG9sZGVyKCkgewotCQlyZXR1cm4gbmV3IFNpbXBsZUNvbGxlY3Rpb25WYWx1ZU1vZGVsPFN0cmluZz4odGhpcy5idWlsZENvbGxlY3Rpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uPFN0cmluZz4gYnVpbGRDb2xsZWN0aW9uKCkgewotCQlCYWc8U3RyaW5nPiBiYWcgPSBuZXcgSGFzaEJhZzxTdHJpbmc+KCk7Ci0JCXRoaXMucG9wdWxhdGVDb2xsZWN0aW9uKGJhZyk7Ci0JCXJldHVybiBiYWc7Ci0JfQotCi0JcHJpdmF0ZSBTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkTGlzdEhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+KHRoaXMuYnVpbGRMaXN0KCkpOwotCX0KLQotCXByaXZhdGUgTGlzdDxTdHJpbmc+IGJ1aWxkTGlzdCgpIHsKLQkJTGlzdDxTdHJpbmc+IGxpc3QgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKLQkJdGhpcy5wb3B1bGF0ZUNvbGxlY3Rpb24obGlzdCk7Ci0JCXJldHVybiBsaXN0OwotCX0KLQotCXByaXZhdGUgdm9pZCBwb3B1bGF0ZUNvbGxlY3Rpb24oQ29sbGVjdGlvbjxTdHJpbmc+IGMpIHsKLQkJYy5hZGQoImZvbyIpOwotCQljLmFkZCgiYmFyIik7Ci0JCWMuYWRkKCJiYXoiKTsKLQkJYy5hZGQoImpvbyIpOwotCQljLmFkZCgiamFyIik7Ci0JCWMuYWRkKCJqYXoiKTsKLQl9Ci0KLQlwcml2YXRlIFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGRMaXN0SG9sZGVyMigpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVMaXN0VmFsdWVNb2RlbDxTdHJpbmc+KHRoaXMuYnVpbGRMaXN0MigpKTsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBidWlsZExpc3QyKCkgewotCQlMaXN0PFN0cmluZz4gbGlzdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQl0aGlzLnBvcHVsYXRlQ29sbGVjdGlvbjIobGlzdCk7Ci0JCXJldHVybiBsaXN0OwotCX0KLQotCXByaXZhdGUgdm9pZCBwb3B1bGF0ZUNvbGxlY3Rpb24yKENvbGxlY3Rpb248U3RyaW5nPiBjKSB7Ci0JCWMuYWRkKCJ0b20iKTsKLQkJYy5hZGQoImRpY2siKTsKLQkJYy5hZGQoImhhcnJ5Iik7Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0xpc3RNb2RlbEFkYXB0ZXJVSVRlc3QuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvTGlzdE1vZGVsQWRhcHRlclVJVGVzdC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4ZmM5NjNiLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvTGlzdE1vZGVsQWRhcHRlclVJVGVzdC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMzcwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmc7Ci0KLWltcG9ydCBqYXZhLmF3dC5Cb3JkZXJMYXlvdXQ7Ci1pbXBvcnQgamF2YS5hd3QuQ29tcG9uZW50OwotaW1wb3J0IGphdmEuYXd0LkdyaWRMYXlvdXQ7Ci1pbXBvcnQgamF2YS5hd3QuVGV4dEZpZWxkOwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LkFjdGlvbkV2ZW50OwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LldpbmRvd0FkYXB0ZXI7Ci1pbXBvcnQgamF2YS5hd3QuZXZlbnQuV2luZG93RXZlbnQ7Ci1pbXBvcnQgamF2YS5hd3QuZXZlbnQuV2luZG93TGlzdGVuZXI7Ci1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29tcGFyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuRGF0ZTsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdEl0ZXJhdG9yOwotaW1wb3J0IGphdmF4LnN3aW5nLkFic3RyYWN0QWN0aW9uOwotaW1wb3J0IGphdmF4LnN3aW5nLkFjdGlvbjsKLWltcG9ydCBqYXZheC5zd2luZy5JY29uOwotaW1wb3J0IGphdmF4LnN3aW5nLkpCdXR0b247Ci1pbXBvcnQgamF2YXguc3dpbmcuSkZyYW1lOwotaW1wb3J0IGphdmF4LnN3aW5nLkpMYWJlbDsKLWltcG9ydCBqYXZheC5zd2luZy5KTGlzdDsKLWltcG9ydCBqYXZheC5zd2luZy5KUGFuZWw7Ci1pbXBvcnQgamF2YXguc3dpbmcuSlNjcm9sbFBhbmU7Ci1pbXBvcnQgamF2YXguc3dpbmcuTGlzdE1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLldpbmRvd0NvbnN0YW50czsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkxpc3RBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Tb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuTGlzdE1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZy5EaXNwbGF5YWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBhbiBleGFtcGxlIFVJIGZvciB0ZXN0aW5nIHZhcmlvdXMgcGVybXV0YXRpb25zIG9mIHRoZSBMaXN0TW9kZWxBZGFwdGVyCi0gKi8KLXB1YmxpYyBjbGFzcyBMaXN0TW9kZWxBZGFwdGVyVUlUZXN0IHsKLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VGFza0xpc3Q+IHRhc2tMaXN0SG9sZGVyOwotCXByaXZhdGUgVGV4dEZpZWxkIHRhc2tUZXh0RmllbGQ7Ci0KLQlwdWJsaWMgc3RhdGljIHZvaWQgbWFpbihTdHJpbmdbXSBhcmdzKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJbmV3IExpc3RNb2RlbEFkYXB0ZXJVSVRlc3QoKS5leGVjKGFyZ3MpOwotCX0KLQotCXByaXZhdGUgTGlzdE1vZGVsQWRhcHRlclVJVGVzdCgpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgZXhlYyhTdHJpbmdbXSBhcmdzKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy50YXNrTGlzdEhvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8VGFza0xpc3Q+KG5ldyBUYXNrTGlzdCgpKTsKLQkJdGhpcy5vcGVuV2luZG93KCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIG9wZW5XaW5kb3coKSB7Ci0JCUpGcmFtZSB3aW5kb3cgPSBuZXcgSkZyYW1lKHRoaXMuZ2V0Q2xhc3MoKS5nZXROYW1lKCkpOwotCQl3aW5kb3cuc2V0RGVmYXVsdENsb3NlT3BlcmF0aW9uKFdpbmRvd0NvbnN0YW50cy5ET19OT1RISU5HX09OX0NMT1NFKTsKLQkJd2luZG93LmFkZFdpbmRvd0xpc3RlbmVyKHRoaXMuYnVpbGRXaW5kb3dMaXN0ZW5lcigpKTsKLQkJd2luZG93LmdldENvbnRlbnRQYW5lKCkuYWRkKHRoaXMuYnVpbGRNYWluUGFuZWwoKSwgIkNlbnRlciIpOwotCQl3aW5kb3cuc2V0U2l6ZSg4MDAsIDQwMCk7Ci0JCXdpbmRvdy5zZXRWaXNpYmxlKHRydWUpOwotCX0KLQotCXByaXZhdGUgV2luZG93TGlzdGVuZXIgYnVpbGRXaW5kb3dMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBXaW5kb3dBZGFwdGVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCB3aW5kb3dDbG9zaW5nKFdpbmRvd0V2ZW50IGUpIHsKLQkJCQllLmdldFdpbmRvdygpLnNldFZpc2libGUoZmFsc2UpOwotCQkJCVN5c3RlbS5leGl0KDApOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgQ29tcG9uZW50IGJ1aWxkTWFpblBhbmVsKCkgewotCQlKUGFuZWwgbWFpblBhbmVsID0gbmV3IEpQYW5lbChuZXcgQm9yZGVyTGF5b3V0KCkpOwotCQltYWluUGFuZWwuYWRkKHRoaXMuYnVpbGRUYXNrTGlzdFBhbmVsKCksIEJvcmRlckxheW91dC5DRU5URVIpOwotCQltYWluUGFuZWwuYWRkKHRoaXMuYnVpbGRDb250cm9sUGFuZWwoKSwgQm9yZGVyTGF5b3V0LlNPVVRIKTsKLQkJcmV0dXJuIG1haW5QYW5lbDsKLQl9Ci0KLQlwcml2YXRlIENvbXBvbmVudCBidWlsZFRhc2tMaXN0UGFuZWwoKSB7Ci0JCUpQYW5lbCB0YXNrTGlzdFBhbmVsID0gbmV3IEpQYW5lbChuZXcgR3JpZExheW91dCgwLCAxKSk7Ci0JCXRhc2tMaXN0UGFuZWwuYWRkKHRoaXMuYnVpbGRQcmltaXRpdmVUYXNrTGlzdFBhbmVsKCkpOwotCQl0YXNrTGlzdFBhbmVsLmFkZCh0aGlzLmJ1aWxkRGlzcGxheWFibGVUYXNrTGlzdFBhbmVsKCkpOwotCQlyZXR1cm4gdGFza0xpc3RQYW5lbDsKLQl9Ci0KLQlwcml2YXRlIENvbXBvbmVudCBidWlsZFByaW1pdGl2ZVRhc2tMaXN0UGFuZWwoKSB7Ci0JCUpQYW5lbCB0YXNrTGlzdFBhbmVsID0gbmV3IEpQYW5lbChuZXcgR3JpZExheW91dCgxLCAwKSk7Ci0JCXRhc2tMaXN0UGFuZWwuYWRkKHRoaXMuYnVpbGRVbnNvcnRlZFByaW1pdGl2ZUxpc3RQYW5lbCgpKTsKLQkJdGFza0xpc3RQYW5lbC5hZGQodGhpcy5idWlsZFN0YW5kYXJkU29ydGVkUHJpbWl0aXZlTGlzdFBhbmVsKCkpOwotCQl0YXNrTGlzdFBhbmVsLmFkZCh0aGlzLmJ1aWxkQ3VzdG9tU29ydGVkUHJpbWl0aXZlTGlzdFBhbmVsKCkpOwotCQlyZXR1cm4gdGFza0xpc3RQYW5lbDsKLQl9Ci0KLQlwcml2YXRlIENvbXBvbmVudCBidWlsZERpc3BsYXlhYmxlVGFza0xpc3RQYW5lbCgpIHsKLQkJSlBhbmVsIHRhc2tMaXN0UGFuZWwgPSBuZXcgSlBhbmVsKG5ldyBHcmlkTGF5b3V0KDEsIDApKTsKLQkJdGFza0xpc3RQYW5lbC5hZGQodGhpcy5idWlsZFVuc29ydGVkRGlzcGxheWFibGVMaXN0UGFuZWwoKSk7Ci0JCXRhc2tMaXN0UGFuZWwuYWRkKHRoaXMuYnVpbGRTdGFuZGFyZFNvcnRlZERpc3BsYXlhYmxlTGlzdFBhbmVsKCkpOwotCQl0YXNrTGlzdFBhbmVsLmFkZCh0aGlzLmJ1aWxkQ3VzdG9tU29ydGVkRGlzcGxheWFibGVMaXN0UGFuZWwoKSk7Ci0JCXJldHVybiB0YXNrTGlzdFBhbmVsOwotCX0KLQotCXByaXZhdGUgQ29tcG9uZW50IGJ1aWxkVW5zb3J0ZWRQcmltaXRpdmVMaXN0UGFuZWwoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkTGlzdFBhbmVsKCJwcmltaXRpdmUgdW5zb3J0ZWQiLCB0aGlzLmJ1aWxkVW5zb3J0ZWRQcmltaXRpdmVMaXN0TW9kZWwoKSk7Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRTdGFuZGFyZFNvcnRlZFByaW1pdGl2ZUxpc3RQYW5lbCgpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRMaXN0UGFuZWwoInByaW1pdGl2ZSBzb3J0ZWQiLCB0aGlzLmJ1aWxkU3RhbmRhcmRTb3J0ZWRQcmltaXRpdmVMaXN0TW9kZWwoKSk7Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRDdXN0b21Tb3J0ZWRQcmltaXRpdmVMaXN0UGFuZWwoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkTGlzdFBhbmVsKCJwcmltaXRpdmUgcmV2ZXJzZSBzb3J0ZWQiLCB0aGlzLmJ1aWxkQ3VzdG9tU29ydGVkUHJpbWl0aXZlTGlzdE1vZGVsKCkpOwotCX0KLQotCXByaXZhdGUgQ29tcG9uZW50IGJ1aWxkVW5zb3J0ZWREaXNwbGF5YWJsZUxpc3RQYW5lbCgpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRMaXN0UGFuZWwoImRpc3BsYXlhYmxlIHVuc29ydGVkIiwgdGhpcy5idWlsZFVuc29ydGVkRGlzcGxheWFibGVMaXN0TW9kZWwoKSk7Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRTdGFuZGFyZFNvcnRlZERpc3BsYXlhYmxlTGlzdFBhbmVsKCkgewotCQlyZXR1cm4gdGhpcy5idWlsZExpc3RQYW5lbCgiZGlzcGxheWFibGUgc29ydGVkIiwgdGhpcy5idWlsZFN0YW5kYXJkU29ydGVkRGlzcGxheWFibGVMaXN0TW9kZWwoKSk7Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRDdXN0b21Tb3J0ZWREaXNwbGF5YWJsZUxpc3RQYW5lbCgpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRMaXN0UGFuZWwoImRpc3BsYXlhYmxlIHJldmVyc2Ugc29ydGVkIiwgdGhpcy5idWlsZEN1c3RvbVNvcnRlZERpc3BsYXlhYmxlTGlzdE1vZGVsKCkpOwotCX0KLQotCXByaXZhdGUgTGlzdE1vZGVsIGJ1aWxkVW5zb3J0ZWRQcmltaXRpdmVMaXN0TW9kZWwoKSB7Ci0JCXJldHVybiBuZXcgTGlzdE1vZGVsQWRhcHRlcih0aGlzLmJ1aWxkUHJpbWl0aXZlVGFza0xpc3RBZGFwdGVyKCkpOwotCX0KLQotCXByaXZhdGUgTGlzdE1vZGVsIGJ1aWxkU3RhbmRhcmRTb3J0ZWRQcmltaXRpdmVMaXN0TW9kZWwoKSB7Ci0JCXJldHVybiBuZXcgTGlzdE1vZGVsQWRhcHRlcihuZXcgU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyPFN0cmluZz4odGhpcy5idWlsZFByaW1pdGl2ZVRhc2tMaXN0QWRhcHRlcigpKSk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0TW9kZWwgYnVpbGRDdXN0b21Tb3J0ZWRQcmltaXRpdmVMaXN0TW9kZWwoKSB7Ci0JCXJldHVybiBuZXcgTGlzdE1vZGVsQWRhcHRlcihuZXcgU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyPFN0cmluZz4odGhpcy5idWlsZFByaW1pdGl2ZVRhc2tMaXN0QWRhcHRlcigpLCB0aGlzLmJ1aWxkQ3VzdG9tU3RyaW5nQ29tcGFyYXRvcigpKSk7Ci0JfQotCi0JcHJpdmF0ZSBMaXN0TW9kZWwgYnVpbGRVbnNvcnRlZERpc3BsYXlhYmxlTGlzdE1vZGVsKCkgewotCQlyZXR1cm4gbmV3IExpc3RNb2RlbEFkYXB0ZXIodGhpcy5idWlsZERpc3BsYXlhYmxlVGFza0xpc3RBZGFwdGVyKCkpOwotCX0KLQotCXByaXZhdGUgTGlzdE1vZGVsIGJ1aWxkU3RhbmRhcmRTb3J0ZWREaXNwbGF5YWJsZUxpc3RNb2RlbCgpIHsKLQkJcmV0dXJuIG5ldyBMaXN0TW9kZWxBZGFwdGVyKG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8VGFzaz4odGhpcy5idWlsZERpc3BsYXlhYmxlVGFza0xpc3RBZGFwdGVyKCkpKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RNb2RlbCBidWlsZEN1c3RvbVNvcnRlZERpc3BsYXlhYmxlTGlzdE1vZGVsKCkgewotCQlyZXR1cm4gbmV3IExpc3RNb2RlbEFkYXB0ZXIobmV3IFNvcnRlZExpc3RWYWx1ZU1vZGVsQWRhcHRlcjxUYXNrPih0aGlzLmJ1aWxkRGlzcGxheWFibGVUYXNrTGlzdEFkYXB0ZXIoKSwgdGhpcy5idWlsZEN1c3RvbVRhc2tPYmplY3RDb21wYXJhdG9yKCkpKTsKLQl9Ci0KLQlwcml2YXRlIENvbXBvbmVudCBidWlsZExpc3RQYW5lbChTdHJpbmcgbGFiZWwsIExpc3RNb2RlbCBsaXN0TW9kZWwpIHsKLQkJSlBhbmVsIGxpc3RQYW5lbCA9IG5ldyBKUGFuZWwobmV3IEJvcmRlckxheW91dCgpKTsKLQkJSkxhYmVsIGxpc3RMYWJlbCA9IG5ldyBKTGFiZWwoIiAgIiArIGxhYmVsKTsKLQkJbGlzdFBhbmVsLmFkZChsaXN0TGFiZWwsIEJvcmRlckxheW91dC5OT1JUSCk7Ci0KLQkJSkxpc3QgbGlzdEJveCA9IG5ldyBKTGlzdCgpOwotCQlsaXN0Qm94LnNldE1vZGVsKGxpc3RNb2RlbCk7Ci0JCWxpc3RCb3guc2V0RG91YmxlQnVmZmVyZWQodHJ1ZSk7Ci0JCWxpc3RMYWJlbC5zZXRMYWJlbEZvcihsaXN0Qm94KTsKLQkJbGlzdFBhbmVsLmFkZChuZXcgSlNjcm9sbFBhbmUobGlzdEJveCksIEJvcmRlckxheW91dC5DRU5URVIpOwotCQlyZXR1cm4gbGlzdFBhbmVsOwotCX0KLQotCXByaXZhdGUgQ29tcGFyYXRvcjxTdHJpbmc+IGJ1aWxkQ3VzdG9tU3RyaW5nQ29tcGFyYXRvcigpIHsKLQkJcmV0dXJuIG5ldyBDb21wYXJhdG9yPFN0cmluZz4oKSB7Ci0JCQlwdWJsaWMgaW50IGNvbXBhcmUoU3RyaW5nIHMxLCBTdHJpbmcgczIpIHsKLQkJCQlyZXR1cm4gczIuY29tcGFyZVRvKHMxKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbXBhcmF0b3I8VGFzaz4gYnVpbGRDdXN0b21UYXNrT2JqZWN0Q29tcGFyYXRvcigpIHsKLQkJcmV0dXJuIG5ldyBDb21wYXJhdG9yPFRhc2s+KCkgewotCQkJcHVibGljIGludCBjb21wYXJlKFRhc2sgdG8xLCBUYXNrIHRvMikgewotCQkJCXJldHVybiB0bzIuY29tcGFyZVRvKHRvMSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxTdHJpbmc+IGJ1aWxkUHJpbWl0aXZlVGFza0xpc3RBZGFwdGVyKCkgewotCQlyZXR1cm4gbmV3IExpc3RBc3BlY3RBZGFwdGVyPFRhc2tMaXN0LCBTdHJpbmc+KFRhc2tMaXN0LlRBU0tfTkFNRVNfTElTVCwgdGhpcy50YXNrTGlzdCgpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBMaXN0SXRlcmF0b3I8U3RyaW5nPiBsaXN0SXRlcmF0b3JfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QudGFza05hbWVzKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxUYXNrPiBidWlsZERpc3BsYXlhYmxlVGFza0xpc3RBZGFwdGVyKCkgewotCQlyZXR1cm4gbmV3IExpc3RBc3BlY3RBZGFwdGVyPFRhc2tMaXN0LCBUYXNrPihUYXNrTGlzdC5UQVNLU19MSVNULCB0aGlzLnRhc2tMaXN0KCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIExpc3RJdGVyYXRvcjxUYXNrPiBsaXN0SXRlcmF0b3JfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QudGFza3MoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbXBvbmVudCBidWlsZENvbnRyb2xQYW5lbCgpIHsKLQkJSlBhbmVsIGNvbnRyb2xQYW5lbCA9IG5ldyBKUGFuZWwobmV3IEJvcmRlckxheW91dCgpKTsKLQkJY29udHJvbFBhbmVsLmFkZCh0aGlzLmJ1aWxkQWRkUmVtb3ZlVGFza1BhbmVsKCksIEJvcmRlckxheW91dC5DRU5URVIpOwotCQljb250cm9sUGFuZWwuYWRkKHRoaXMuYnVpbGRDbGVhckJ1dHRvbigpLCBCb3JkZXJMYXlvdXQuRUFTVCk7Ci0JCXJldHVybiBjb250cm9sUGFuZWw7Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRBZGRSZW1vdmVUYXNrUGFuZWwoKSB7Ci0JCUpQYW5lbCBhZGRSZW1vdmVUYXNrUGFuZWwgPSBuZXcgSlBhbmVsKG5ldyBCb3JkZXJMYXlvdXQoKSk7Ci0JCWFkZFJlbW92ZVRhc2tQYW5lbC5hZGQodGhpcy5idWlsZEFkZEJ1dHRvbigpLCBCb3JkZXJMYXlvdXQuV0VTVCk7Ci0JCWFkZFJlbW92ZVRhc2tQYW5lbC5hZGQodGhpcy5idWlsZFRhc2tUZXh0RmllbGQoKSwgQm9yZGVyTGF5b3V0LkNFTlRFUik7Ci0JCWFkZFJlbW92ZVRhc2tQYW5lbC5hZGQodGhpcy5idWlsZFJlbW92ZUJ1dHRvbigpLCBCb3JkZXJMYXlvdXQuRUFTVCk7Ci0JCXJldHVybiBhZGRSZW1vdmVUYXNrUGFuZWw7Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmcgZ2V0VGFzaygpIHsKLQkJcmV0dXJuIHRoaXMudGFza1RleHRGaWVsZC5nZXRUZXh0KCk7Ci0JfQotCi0JcHJpdmF0ZSBUYXNrTGlzdCB0YXNrTGlzdCgpIHsKLQkJcmV0dXJuIHRoaXMudGFza0xpc3RIb2xkZXIuZ2V0VmFsdWUoKTsKLQl9Ci0KLQl2b2lkIGFkZFRhc2soKSB7Ci0JCVN0cmluZyB0YXNrID0gdGhpcy5nZXRUYXNrKCk7Ci0JCWlmICh0YXNrLmxlbmd0aCgpICE9IDApIHsKLQkJCXRoaXMudGFza0xpc3QoKS5hZGRUYXNrKHRhc2spOwotCQl9Ci0JfQotCi0Jdm9pZCByZW1vdmVUYXNrKCkgewotCQlTdHJpbmcgdGFzayA9IHRoaXMuZ2V0VGFzaygpOwotCQlpZiAodGFzay5sZW5ndGgoKSAhPSAwKSB7Ci0JCQl0aGlzLnRhc2tMaXN0KCkucmVtb3ZlVGFzayh0YXNrKTsKLQkJfQotCX0KLQotCXZvaWQgY2xlYXJUYXNrcygpIHsKLQkJdGhpcy50YXNrTGlzdCgpLmNsZWFyVGFza3MoKTsKLQl9Ci0KLQlwcml2YXRlIFRleHRGaWVsZCBidWlsZFRhc2tUZXh0RmllbGQoKSB7Ci0JCXRoaXMudGFza1RleHRGaWVsZCA9IG5ldyBUZXh0RmllbGQoKTsKLQkJcmV0dXJuIHRoaXMudGFza1RleHRGaWVsZDsKLQl9Ci0KLQlwcml2YXRlIEpCdXR0b24gYnVpbGRBZGRCdXR0b24oKSB7Ci0JCXJldHVybiBuZXcgSkJ1dHRvbih0aGlzLmJ1aWxkQWRkQWN0aW9uKCkpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uIGJ1aWxkQWRkQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJhZGQiKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZXZlbnQpIHsKLQkJCQlMaXN0TW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMuYWRkVGFzaygpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQlwcml2YXRlIEpCdXR0b24gYnVpbGRSZW1vdmVCdXR0b24oKSB7Ci0JCXJldHVybiBuZXcgSkJ1dHRvbih0aGlzLmJ1aWxkUmVtb3ZlQWN0aW9uKCkpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uIGJ1aWxkUmVtb3ZlQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJyZW1vdmUiKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZXZlbnQpIHsKLQkJCQlMaXN0TW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMucmVtb3ZlVGFzaygpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQlwcml2YXRlIEpCdXR0b24gYnVpbGRDbGVhckJ1dHRvbigpIHsKLQkJcmV0dXJuIG5ldyBKQnV0dG9uKHRoaXMuYnVpbGRDbGVhckFjdGlvbigpKTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbiBidWlsZENsZWFyQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJjbGVhciIpIHsKLQkJCXB1YmxpYyB2b2lkIGFjdGlvblBlcmZvcm1lZChBY3Rpb25FdmVudCBldmVudCkgewotCQkJCUxpc3RNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5jbGVhclRhc2tzKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRFbmFibGVkKHRydWUpOwotCQlyZXR1cm4gYWN0aW9uOwotCX0KLQotCXByaXZhdGUgY2xhc3MgVGFza0xpc3QgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIHsKLQkJcHJpdmF0ZSBMaXN0PFN0cmluZz4gdGFza05hbWVzID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCXByaXZhdGUgTGlzdDxUYXNrPiB0YXNrT2JqZWN0cyA9IG5ldyBBcnJheUxpc3Q8VGFzaz4oKTsKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgVEFTS19OQU1FU19MSVNUID0gInRhc2tOYW1lcyI7Ci0JCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFRBU0tTX0xJU1QgPSAidGFza3MiOwotCQlUYXNrTGlzdCgpIHsKLQkJCXN1cGVyKCk7Ci0JCX0KLQkJcHVibGljIExpc3RJdGVyYXRvcjxTdHJpbmc+IHRhc2tOYW1lcygpIHsKLQkJCXJldHVybiB0aGlzLnRhc2tOYW1lcy5saXN0SXRlcmF0b3IoKTsKLQkJfQotCQlwdWJsaWMgTGlzdEl0ZXJhdG9yPFRhc2s+IHRhc2tzKCkgewotCQkJcmV0dXJuIHRoaXMudGFza09iamVjdHMubGlzdEl0ZXJhdG9yKCk7Ci0JCX0KLQkJcHVibGljIHZvaWQgYWRkVGFzayhTdHJpbmcgdGFza05hbWUpIHsKLQkJCWludCBpbmRleCA9IHRoaXMudGFza05hbWVzLnNpemUoKTsKLQkJCXRoaXMudGFza05hbWVzLmFkZChpbmRleCwgdGFza05hbWUpOwotCQkJdGhpcy5maXJlSXRlbUFkZGVkKFRBU0tfTkFNRVNfTElTVCwgaW5kZXgsIHRhc2tOYW1lKTsKLQkKLQkJCVRhc2sgdGFza09iamVjdCA9IG5ldyBUYXNrKHRhc2tOYW1lKTsKLQkJCXRoaXMudGFza09iamVjdHMuYWRkKGluZGV4LCB0YXNrT2JqZWN0KTsKLQkJCXRoaXMuZmlyZUl0ZW1BZGRlZChUQVNLU19MSVNULCBpbmRleCwgdGFza09iamVjdCk7Ci0JCX0JCQotCQlwdWJsaWMgdm9pZCByZW1vdmVUYXNrKFN0cmluZyB0YXNrTmFtZSkgewotCQkJaW50IGluZGV4ID0gdGhpcy50YXNrTmFtZXMuaW5kZXhPZih0YXNrTmFtZSk7Ci0JCQlpZiAoaW5kZXggIT0gLTEpIHsKLQkJCQlPYmplY3QgcmVtb3ZlZFRhc2sgPSB0aGlzLnRhc2tOYW1lcy5yZW1vdmUoaW5kZXgpOwotCQkJCXRoaXMuZmlyZUl0ZW1SZW1vdmVkKFRBU0tfTkFNRVNfTElTVCwgaW5kZXgsIHJlbW92ZWRUYXNrKTsKLQkJCQkvLyBhc3N1bWUgdGhlIGluZGV4ZXMgbWF0Y2guLi4KLQkJCQlPYmplY3QgcmVtb3ZlZFRhc2tPYmplY3QgPSB0aGlzLnRhc2tPYmplY3RzLnJlbW92ZShpbmRleCk7Ci0JCQkJdGhpcy5maXJlSXRlbVJlbW92ZWQoVEFTS1NfTElTVCwgaW5kZXgsIHJlbW92ZWRUYXNrT2JqZWN0KTsKLQkJCX0KLQkJfQotCQlwdWJsaWMgdm9pZCBjbGVhclRhc2tzKCkgewotCQkJdGhpcy50YXNrTmFtZXMuY2xlYXIoKTsKLQkJCXRoaXMuZmlyZUxpc3RDaGFuZ2VkKFRBU0tfTkFNRVNfTElTVCk7Ci0JCQl0aGlzLnRhc2tPYmplY3RzLmNsZWFyKCk7Ci0JCQl0aGlzLmZpcmVMaXN0Q2hhbmdlZChUQVNLU19MSVNUKTsKLQkJfQotCX0KLQotCXByaXZhdGUgY2xhc3MgVGFzayBleHRlbmRzIEFic3RyYWN0TW9kZWwgaW1wbGVtZW50cyBEaXNwbGF5YWJsZSB7Ci0JCXByaXZhdGUgU3RyaW5nIG5hbWU7Ci0JCXByaXZhdGUgRGF0ZSBjcmVhdGlvblRpbWVTdGFtcDsKLQkJcHVibGljIFRhc2soU3RyaW5nIG5hbWUpIHsKLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCQl0aGlzLmNyZWF0aW9uVGltZVN0YW1wID0gbmV3IERhdGUoKTsKLQkJfQotCQlwdWJsaWMgU3RyaW5nIGRpc3BsYXlTdHJpbmcoKSB7Ci0JCQlyZXR1cm4gdGhpcy5uYW1lICsgIjogIiArIHRoaXMuY3JlYXRpb25UaW1lU3RhbXAuZ2V0VGltZSgpOwotCQl9Ci0JCXB1YmxpYyBJY29uIGljb24oKSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQlwdWJsaWMgaW50IGNvbXBhcmVUbyhEaXNwbGF5YWJsZSBvKSB7Ci0JCQlyZXR1cm4gREVGQVVMVF9DT01QQVJBVE9SLmNvbXBhcmUodGhpcywgbyk7Ci0JCX0KLQkJcHVibGljIFN0cmluZyBnZXROYW1lKCkgewotCQkJcmV0dXJuIHRoaXMubmFtZTsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXROYW1lKFN0cmluZyBuYW1lKSB7Ci0JCQlPYmplY3Qgb2xkID0gdGhpcy5uYW1lOwotCQkJdGhpcy5uYW1lID0gbmFtZTsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChESVNQTEFZX1NUUklOR19QUk9QRVJUWSwgb2xkLCBuYW1lKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMuZGlzcGxheVN0cmluZygpKTsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9MaXN0U3Bpbm5lck1vZGVsQWRhcHRlclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0xpc3RTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDQwN2I1OS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL0xpc3RTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDEzMyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nOwotCi1pbXBvcnQgamF2YXguc3dpbmcuU3Bpbm5lck1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LkNoYW5nZUV2ZW50OwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuTGlzdFNwaW5uZXJNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgTGlzdFNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gdmFsdWVIb2xkZXI7Ci0JcHJpdmF0ZSBTcGlubmVyTW9kZWwgc3Bpbm5lck1vZGVsQWRhcHRlcjsKLQlib29sZWFuIGV2ZW50RmlyZWQ7Ci0JcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nW10gVkFMVUVfTElTVCA9IHsicmVkIiwgImdyZWVuIiwgImJsdWUifTsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgREVGQVVMVF9WQUxVRSA9IFZBTFVFX0xJU1RbMF07Ci0KLQlwdWJsaWMgTGlzdFNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLnZhbHVlSG9sZGVyID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+KERFRkFVTFRfVkFMVUUpOwotCQl0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIgPSBuZXcgTGlzdFNwaW5uZXJNb2RlbEFkYXB0ZXIodGhpcy52YWx1ZUhvbGRlciwgVkFMVUVfTElTVCkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZFZhbHVlQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQkJcmV0dXJuIHRoaXMuYnVpbGRWYWx1ZUNoYW5nZUxpc3RlbmVyXygpOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2V0VmFsdWVTcGlubmVyTW9kZWwoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5ldmVudEZpcmVkID0gZmFsc2U7Ci0JCXRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5hZGRDaGFuZ2VMaXN0ZW5lcihuZXcgVGVzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoQ2hhbmdlRXZlbnQgZSkgewotCQkJCUxpc3RTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCX0KLQkJfSk7Ci0JCWFzc2VydEVxdWFscyhERUZBVUxUX1ZBTFVFLCB0aGlzLnZhbHVlSG9sZGVyLmdldFZhbHVlKCkpOwotCQl0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIuc2V0VmFsdWUoVkFMVUVfTElTVFsyXSk7Ci0JCWFzc2VydFRydWUodGhpcy5ldmVudEZpcmVkKTsKLQkJYXNzZXJ0RXF1YWxzKFZBTFVFX0xJU1RbMl0sIHRoaXMudmFsdWVIb2xkZXIuZ2V0VmFsdWUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNldFZhbHVlVmFsdWVIb2xkZXIoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5ldmVudEZpcmVkID0gZmFsc2U7Ci0JCXRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5hZGRDaGFuZ2VMaXN0ZW5lcihuZXcgVGVzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoQ2hhbmdlRXZlbnQgZSkgewotCQkJCUxpc3RTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCX0KLQkJfSk7Ci0JCWFzc2VydEVxdWFscyhERUZBVUxUX1ZBTFVFLCB0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIuZ2V0VmFsdWUoKSk7Ci0JCXRoaXMudmFsdWVIb2xkZXIuc2V0VmFsdWUoVkFMVUVfTElTVFsyXSk7Ci0JCWFzc2VydFRydWUodGhpcy5ldmVudEZpcmVkKTsKLQkJYXNzZXJ0RXF1YWxzKFZBTFVFX0xJU1RbMl0sIHRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGVmYXVsdFZhbHVlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuZXZlbnRGaXJlZCA9IGZhbHNlOwotCQl0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIuYWRkQ2hhbmdlTGlzdGVuZXIobmV3IFRlc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgc3RhdGVDaGFuZ2VkKENoYW5nZUV2ZW50IGUpIHsKLQkJCQlMaXN0U3Bpbm5lck1vZGVsQWRhcHRlclRlc3RzLnRoaXMuZXZlbnRGaXJlZCA9IHRydWU7Ci0JCQl9Ci0JCX0pOwotCQlhc3NlcnRFcXVhbHMoREVGQVVMVF9WQUxVRSwgdGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyLmdldFZhbHVlKCkpOwotCi0JCXRoaXMudmFsdWVIb2xkZXIuc2V0VmFsdWUoVkFMVUVfTElTVFsyXSk7Ci0JCWFzc2VydFRydWUodGhpcy5ldmVudEZpcmVkKTsKLQkJYXNzZXJ0RXF1YWxzKFZBTFVFX0xJU1RbMl0sIHRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLmV2ZW50RmlyZWQgPSBmYWxzZTsKLQkJdGhpcy52YWx1ZUhvbGRlci5zZXRWYWx1ZShudWxsKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmV2ZW50RmlyZWQpOwotCQlhc3NlcnRFcXVhbHMoVkFMVUVfTElTVFswXSwgdGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RIYXNMaXN0ZW5lcnMoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gbG9jYWxWYWx1ZUhvbGRlciA9IChTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PikgdGhpcy52YWx1ZUhvbGRlcjsKLQkJYXNzZXJ0RmFsc2UobG9jYWxWYWx1ZUhvbGRlci5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJdGhpcy52ZXJpZnlIYXNOb0xpc3RlbmVycyh0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIpOwotCi0JCUNoYW5nZUxpc3RlbmVyIGxpc3RlbmVyID0gbmV3IFRlc3RDaGFuZ2VMaXN0ZW5lcigpOwotCQl0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIuYWRkQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKGxvY2FsVmFsdWVIb2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTGlzdGVuZXJzKHRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlcik7Ci0KLQkJdGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyLnJlbW92ZUNoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJYXNzZXJ0RmFsc2UobG9jYWxWYWx1ZUhvbGRlci5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJdGhpcy52ZXJpZnlIYXNOb0xpc3RlbmVycyh0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlIYXNOb0xpc3RlbmVycyhTcGlubmVyTW9kZWwgYWRhcHRlcikgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCWFzc2VydEVxdWFscygwLCAoKExpc3RTcGlubmVyTW9kZWxBZGFwdGVyKSBhZGFwdGVyKS5nZXRDaGFuZ2VMaXN0ZW5lcnMoKS5sZW5ndGgpOwotCX0KLQotCXByaXZhdGUgdm9pZCB2ZXJpZnlIYXNMaXN0ZW5lcnMoT2JqZWN0IGFkYXB0ZXIpIHRocm93cyBFeGNlcHRpb24gewotCQlhc3NlcnRGYWxzZSgoKExpc3RTcGlubmVyTW9kZWxBZGFwdGVyKSBhZGFwdGVyKS5nZXRDaGFuZ2VMaXN0ZW5lcnMoKS5sZW5ndGggPT0gMCk7Ci0JfQotCi0KLQlwcml2YXRlIGNsYXNzIFRlc3RDaGFuZ2VMaXN0ZW5lciBpbXBsZW1lbnRzIENoYW5nZUxpc3RlbmVyIHsKLQkJVGVzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoQ2hhbmdlRXZlbnQgZSkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL051bWJlclNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9OdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmM1ZGYxNC4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL051bWJlclNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMTQ3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmc7Ci0KLWltcG9ydCBqYXZheC5zd2luZy5TcGlubmVyTW9kZWw7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5OdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIE51bWJlclNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE51bWJlcj4gdmFsdWVIb2xkZXI7Ci0JcHJpdmF0ZSBTcGlubmVyTW9kZWwgc3Bpbm5lck1vZGVsQWRhcHRlcjsKLQlib29sZWFuIGV2ZW50RmlyZWQ7Ci0KLQlwdWJsaWMgTnVtYmVyU3Bpbm5lck1vZGVsQWRhcHRlclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMudmFsdWVIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPE51bWJlcj4obmV3IEludGVnZXIoMCkpOwotCQl0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIgPSBuZXcgTnVtYmVyU3Bpbm5lck1vZGVsQWRhcHRlcih0aGlzLnZhbHVlSG9sZGVyLCAtMzMsIDMzLCAxKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkTnVtYmVyQ2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQkJcmV0dXJuIHRoaXMuYnVpbGROdW1iZXJDaGFuZ2VMaXN0ZW5lcl8oKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNldFZhbHVlU3Bpbm5lck1vZGVsKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuZXZlbnRGaXJlZCA9IGZhbHNlOwotCQl0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIuYWRkQ2hhbmdlTGlzdGVuZXIobmV3IFRlc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgc3RhdGVDaGFuZ2VkKENoYW5nZUV2ZW50IGUpIHsKLQkJCQlOdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCX0KLQkJfSk7Ci0JCXRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5zZXRWYWx1ZShuZXcgSW50ZWdlcig1KSk7Ci0JCWFzc2VydFRydWUodGhpcy5ldmVudEZpcmVkKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBJbnRlZ2VyKDUpLCB0aGlzLnZhbHVlSG9sZGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRWYWx1ZVZhbHVlSG9sZGVyKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuZXZlbnRGaXJlZCA9IGZhbHNlOwotCQl0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIuYWRkQ2hhbmdlTGlzdGVuZXIobmV3IFRlc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgc3RhdGVDaGFuZ2VkKENoYW5nZUV2ZW50IGUpIHsKLQkJCQlOdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCX0KLQkJfSk7Ci0JCWFzc2VydEVxdWFscyhuZXcgSW50ZWdlcigwKSwgdGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyLmdldFZhbHVlKCkpOwotCQl0aGlzLnZhbHVlSG9sZGVyLnNldFZhbHVlKG5ldyBJbnRlZ2VyKDcpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmV2ZW50RmlyZWQpOwotCQlhc3NlcnRFcXVhbHMobmV3IEludGVnZXIoNyksIHRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGVmYXVsdFZhbHVlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuZXZlbnRGaXJlZCA9IGZhbHNlOwotCQl0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIuYWRkQ2hhbmdlTGlzdGVuZXIobmV3IFRlc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgc3RhdGVDaGFuZ2VkKENoYW5nZUV2ZW50IGUpIHsKLQkJCQlOdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCX0KLQkJfSk7Ci0JCWFzc2VydEVxdWFscyhuZXcgSW50ZWdlcigwKSwgdGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyLmdldFZhbHVlKCkpOwotCQl0aGlzLnZhbHVlSG9sZGVyLnNldFZhbHVlKG51bGwpOwotCQlhc3NlcnRUcnVlKHRoaXMuZXZlbnRGaXJlZCk7Ci0JCWFzc2VydEVxdWFscyhuZXcgSW50ZWdlcigtMzMpLCB0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIuZ2V0VmFsdWUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc0xpc3RlbmVycygpIHRocm93cyBFeGNlcHRpb24gewotCQlTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8TnVtYmVyPiBsb2NhbFZhbHVlSG9sZGVyID0gKFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxOdW1iZXI+KSB0aGlzLnZhbHVlSG9sZGVyOwotCQlhc3NlcnRGYWxzZShsb2NhbFZhbHVlSG9sZGVyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQl0aGlzLnZlcmlmeUhhc05vTGlzdGVuZXJzKHRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlcik7Ci0KLQkJQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENoYW5nZUxpc3RlbmVyKCk7Ci0JCXRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5hZGRDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWFzc2VydFRydWUobG9jYWxWYWx1ZUhvbGRlci5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJdGhpcy52ZXJpZnlIYXNMaXN0ZW5lcnModGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyKTsKLQotCQl0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIucmVtb3ZlQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRGYWxzZShsb2NhbFZhbHVlSG9sZGVyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQl0aGlzLnZlcmlmeUhhc05vTGlzdGVuZXJzKHRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlcik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUhhc05vTGlzdGVuZXJzKFNwaW5uZXJNb2RlbCBhZGFwdGVyKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0RXF1YWxzKDAsICgoTnVtYmVyU3Bpbm5lck1vZGVsQWRhcHRlcikgYWRhcHRlcikuZ2V0Q2hhbmdlTGlzdGVuZXJzKCkubGVuZ3RoKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5SGFzTGlzdGVuZXJzKE9iamVjdCBhZGFwdGVyKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJYXNzZXJ0RmFsc2UoKChOdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyKSBhZGFwdGVyKS5nZXRDaGFuZ2VMaXN0ZW5lcnMoKS5sZW5ndGggPT0gMCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdE51bGxJbml0aWFsVmFsdWUoKSB7Ci0JCXRoaXMudmFsdWVIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPE51bWJlcj4oKTsKLQkJdGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyID0gbmV3IE51bWJlclNwaW5uZXJNb2RlbEFkYXB0ZXIodGhpcy52YWx1ZUhvbGRlciwgbmV3IEludGVnZXIoLTMzKSwgbmV3IEludGVnZXIoMzMpLCBuZXcgSW50ZWdlcigxKSwgbmV3IEludGVnZXIoMCkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgYnVpbGROdW1iZXJDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCQlyZXR1cm4gdGhpcy5idWlsZE51bWJlckNoYW5nZUxpc3RlbmVyXygpOwotCQkJfQotCQl9OwotCi0JCXRoaXMuZXZlbnRGaXJlZCA9IGZhbHNlOwotCQl0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIuYWRkQ2hhbmdlTGlzdGVuZXIobmV3IFRlc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgc3RhdGVDaGFuZ2VkKENoYW5nZUV2ZW50IGUpIHsKLQkJCQlOdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCX0KLQkJfSk7Ci0JCWFzc2VydEVxdWFscyhuZXcgSW50ZWdlcigwKSwgdGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyLmdldFZhbHVlKCkpOwotCQl0aGlzLnZhbHVlSG9sZGVyLnNldFZhbHVlKG5ldyBJbnRlZ2VyKDcpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmV2ZW50RmlyZWQpOwotCQlhc3NlcnRFcXVhbHMobmV3IEludGVnZXIoNyksIHRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogaW5uZXIgY2xhc3MgKioqKioqKioqKgotCXByaXZhdGUgY2xhc3MgVGVzdENoYW5nZUxpc3RlbmVyIGltcGxlbWVudHMgQ2hhbmdlTGlzdGVuZXIgewotCQlUZXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHN0YXRlQ2hhbmdlZChDaGFuZ2VFdmVudCBlKSB7Ci0JCQlmYWlsKCJ1bmV4cGVjdGVkIGV2ZW50Iik7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggODc0NGQ2Ni4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL09iamVjdExpc3RTZWxlY3Rpb25Nb2RlbFRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyMDIgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZzsKLQotaW1wb3J0IGphdmF4LnN3aW5nLkRlZmF1bHRMaXN0TW9kZWw7Ci1pbXBvcnQgamF2YXguc3dpbmcuTGlzdE1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50Lkxpc3RTZWxlY3Rpb25FdmVudDsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5MaXN0U2VsZWN0aW9uTGlzdGVuZXI7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5PYmplY3RMaXN0U2VsZWN0aW9uTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBEZWZhdWx0TGlzdE1vZGVsIGxpc3RNb2RlbDsKLQlwcml2YXRlIE9iamVjdExpc3RTZWxlY3Rpb25Nb2RlbCBzZWxlY3Rpb25Nb2RlbDsKLQotCXB1YmxpYyBPYmplY3RMaXN0U2VsZWN0aW9uTW9kZWxUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLmxpc3RNb2RlbCA9IHRoaXMuYnVpbGRMaXN0TW9kZWwoKTsKLQkJdGhpcy5zZWxlY3Rpb25Nb2RlbCA9IHRoaXMuYnVpbGRTZWxlY3Rpb25Nb2RlbCh0aGlzLmxpc3RNb2RlbCk7Ci0JfQotCi0JcHJpdmF0ZSBEZWZhdWx0TGlzdE1vZGVsIGJ1aWxkTGlzdE1vZGVsKCkgewotCQlEZWZhdWx0TGlzdE1vZGVsIGxtID0gbmV3IERlZmF1bHRMaXN0TW9kZWwoKTsKLQkJbG0uYWRkRWxlbWVudCgiZm9vIik7Ci0JCWxtLmFkZEVsZW1lbnQoImJhciIpOwotCQlsbS5hZGRFbGVtZW50KCJiYXoiKTsKLQkJcmV0dXJuIGxtOwotCX0KLQotCXByaXZhdGUgT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsIGJ1aWxkU2VsZWN0aW9uTW9kZWwoTGlzdE1vZGVsIGxtKSB7Ci0JCXJldHVybiBuZXcgT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsKGxtKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExpc3REYXRhTGlzdGVuZXIoKSB7Ci0JCXRoaXMuc2VsZWN0aW9uTW9kZWwuYWRkTGlzdFNlbGVjdGlvbkxpc3RlbmVyKHRoaXMuYnVpbGRMaXN0U2VsZWN0aW9uTGlzdGVuZXIoKSk7Ci0JCXRoaXMuc2VsZWN0aW9uTW9kZWwuc2V0U2VsZWN0aW9uSW50ZXJ2YWwoMCwgMCk7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy5zZWxlY3Rpb25Nb2RlbC5zZWxlY3RlZFZhbHVlKCkpOwotCQl0aGlzLmxpc3RNb2RlbC5zZXQoMCwgImphciIpOwotCQlhc3NlcnRFcXVhbHMoImphciIsIHRoaXMuc2VsZWN0aW9uTW9kZWwuc2VsZWN0ZWRWYWx1ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0R2V0U2VsZWN0ZWRWYWx1ZSgpIHsKLQkJdGhpcy5zZWxlY3Rpb25Nb2RlbC5zZXRTZWxlY3Rpb25JbnRlcnZhbCgwLCAwKTsKLQkJYXNzZXJ0RXF1YWxzKCJmb28iLCB0aGlzLnNlbGVjdGlvbk1vZGVsLnNlbGVjdGVkVmFsdWUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEdldFNlbGVjdGVkVmFsdWVzKCkgewotCQl0aGlzLnNlbGVjdGlvbk1vZGVsLnNldFNlbGVjdGlvbkludGVydmFsKDAsIDApOwotCQl0aGlzLnNlbGVjdGlvbk1vZGVsLmFkZFNlbGVjdGlvbkludGVydmFsKDIsIDIpOwotCQlhc3NlcnRFcXVhbHMoMiwgdGhpcy5zZWxlY3Rpb25Nb2RlbC5zZWxlY3RlZFZhbHVlcygpLmxlbmd0aCk7Ci0JCWFzc2VydFRydWUoQ29sbGVjdGlvblRvb2xzLmNvbnRhaW5zKHRoaXMuc2VsZWN0aW9uTW9kZWwuc2VsZWN0ZWRWYWx1ZXMoKSwgImZvbyIpKTsKLQkJYXNzZXJ0VHJ1ZShDb2xsZWN0aW9uVG9vbHMuY29udGFpbnModGhpcy5zZWxlY3Rpb25Nb2RlbC5zZWxlY3RlZFZhbHVlcygpLCAiYmF6IikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRTZWxlY3RlZFZhbHVlKCkgewotCQl0aGlzLnNlbGVjdGlvbk1vZGVsLnNldFNlbGVjdGVkVmFsdWUoImZvbyIpOwotCQlhc3NlcnRFcXVhbHMoMCwgdGhpcy5zZWxlY3Rpb25Nb2RlbC5nZXRNaW5TZWxlY3Rpb25JbmRleCgpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHRoaXMuc2VsZWN0aW9uTW9kZWwuZ2V0TWF4U2VsZWN0aW9uSW5kZXgoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFNldFNlbGVjdGVkVmFsdWVzKCkgewotCQl0aGlzLnNlbGVjdGlvbk1vZGVsLnNldFNlbGVjdGVkVmFsdWVzKG5ldyBPYmplY3RbXSB7ImZvbyIsICJiYXoifSk7Ci0JCWFzc2VydEVxdWFscygwLCB0aGlzLnNlbGVjdGlvbk1vZGVsLmdldE1pblNlbGVjdGlvbkluZGV4KCkpOwotCQlhc3NlcnRFcXVhbHMoMiwgdGhpcy5zZWxlY3Rpb25Nb2RlbC5nZXRNYXhTZWxlY3Rpb25JbmRleCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkU2VsZWN0ZWRWYWx1ZSgpIHsKLQkJdGhpcy5saXN0TW9kZWwuYWRkRWxlbWVudCgiam9vIik7Ci0JCXRoaXMubGlzdE1vZGVsLmFkZEVsZW1lbnQoImphciIpOwotCQl0aGlzLmxpc3RNb2RlbC5hZGRFbGVtZW50KCJqYXoiKTsKLQkJdGhpcy5zZWxlY3Rpb25Nb2RlbC5zZXRTZWxlY3RlZFZhbHVlKCJmb28iKTsKLQkJdGhpcy5zZWxlY3Rpb25Nb2RlbC5hZGRTZWxlY3RlZFZhbHVlKCJqYXoiKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHRoaXMuc2VsZWN0aW9uTW9kZWwuZ2V0TWluU2VsZWN0aW9uSW5kZXgoKSk7Ci0JCWFzc2VydEVxdWFscyg1LCB0aGlzLnNlbGVjdGlvbk1vZGVsLmdldE1heFNlbGVjdGlvbkluZGV4KCkpOwotCQlhc3NlcnRUcnVlKHRoaXMuc2VsZWN0aW9uTW9kZWwuaXNTZWxlY3RlZEluZGV4KDApKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zZWxlY3Rpb25Nb2RlbC5pc1NlbGVjdGVkSW5kZXgoMSkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnNlbGVjdGlvbk1vZGVsLmlzU2VsZWN0ZWRJbmRleCgyKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc2VsZWN0aW9uTW9kZWwuaXNTZWxlY3RlZEluZGV4KDMpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zZWxlY3Rpb25Nb2RlbC5pc1NlbGVjdGVkSW5kZXgoNCkpOwotCQlhc3NlcnRUcnVlKHRoaXMuc2VsZWN0aW9uTW9kZWwuaXNTZWxlY3RlZEluZGV4KDUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0QWRkU2VsZWN0ZWRWYWx1ZXMoKSB7Ci0JCXRoaXMubGlzdE1vZGVsLmFkZEVsZW1lbnQoImpvbyIpOwotCQl0aGlzLmxpc3RNb2RlbC5hZGRFbGVtZW50KCJqYXIiKTsKLQkJdGhpcy5saXN0TW9kZWwuYWRkRWxlbWVudCgiamF6Iik7Ci0JCXRoaXMuc2VsZWN0aW9uTW9kZWwuc2V0U2VsZWN0ZWRWYWx1ZSgiZm9vIik7Ci0JCXRoaXMuc2VsZWN0aW9uTW9kZWwuYWRkU2VsZWN0ZWRWYWx1ZXMobmV3IE9iamVjdFtdIHsiYmFyIiwgImphciJ9KTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHRoaXMuc2VsZWN0aW9uTW9kZWwuZ2V0TWluU2VsZWN0aW9uSW5kZXgoKSk7Ci0JCWFzc2VydEVxdWFscyg0LCB0aGlzLnNlbGVjdGlvbk1vZGVsLmdldE1heFNlbGVjdGlvbkluZGV4KCkpOwotCQlhc3NlcnRUcnVlKHRoaXMuc2VsZWN0aW9uTW9kZWwuaXNTZWxlY3RlZEluZGV4KDApKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnNlbGVjdGlvbk1vZGVsLmlzU2VsZWN0ZWRJbmRleCgxKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc2VsZWN0aW9uTW9kZWwuaXNTZWxlY3RlZEluZGV4KDIpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zZWxlY3Rpb25Nb2RlbC5pc1NlbGVjdGVkSW5kZXgoMykpOwotCQlhc3NlcnRUcnVlKHRoaXMuc2VsZWN0aW9uTW9kZWwuaXNTZWxlY3RlZEluZGV4KDQpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zZWxlY3Rpb25Nb2RlbC5pc1NlbGVjdGVkSW5kZXgoNSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVTZWxlY3RlZFZhbHVlKCkgewotCQl0aGlzLmxpc3RNb2RlbC5hZGRFbGVtZW50KCJqb28iKTsKLQkJdGhpcy5saXN0TW9kZWwuYWRkRWxlbWVudCgiamFyIik7Ci0JCXRoaXMubGlzdE1vZGVsLmFkZEVsZW1lbnQoImpheiIpOwotCQl0aGlzLnNlbGVjdGlvbk1vZGVsLnNldFNlbGVjdGVkVmFsdWVzKG5ldyBPYmplY3RbXSB7ImZvbyIsICJiYXoiLCAiamFyIn0pOwotCQl0aGlzLnNlbGVjdGlvbk1vZGVsLnJlbW92ZVNlbGVjdGVkVmFsdWUoImphciIpOwotCQlhc3NlcnRFcXVhbHMoMCwgdGhpcy5zZWxlY3Rpb25Nb2RlbC5nZXRNaW5TZWxlY3Rpb25JbmRleCgpKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIHRoaXMuc2VsZWN0aW9uTW9kZWwuZ2V0TWF4U2VsZWN0aW9uSW5kZXgoKSk7Ci0JCWFzc2VydFRydWUodGhpcy5zZWxlY3Rpb25Nb2RlbC5pc1NlbGVjdGVkSW5kZXgoMCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnNlbGVjdGlvbk1vZGVsLmlzU2VsZWN0ZWRJbmRleCgxKSk7Ci0JCWFzc2VydFRydWUodGhpcy5zZWxlY3Rpb25Nb2RlbC5pc1NlbGVjdGVkSW5kZXgoMikpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnNlbGVjdGlvbk1vZGVsLmlzU2VsZWN0ZWRJbmRleCgzKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc2VsZWN0aW9uTW9kZWwuaXNTZWxlY3RlZEluZGV4KDQpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5zZWxlY3Rpb25Nb2RlbC5pc1NlbGVjdGVkSW5kZXgoNSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVTZWxlY3RlZFZhbHVlcygpIHsKLQkJdGhpcy5saXN0TW9kZWwuYWRkRWxlbWVudCgiam9vIik7Ci0JCXRoaXMubGlzdE1vZGVsLmFkZEVsZW1lbnQoImphciIpOwotCQl0aGlzLmxpc3RNb2RlbC5hZGRFbGVtZW50KCJqYXoiKTsKLQkJdGhpcy5zZWxlY3Rpb25Nb2RlbC5zZXRTZWxlY3RlZFZhbHVlcyhuZXcgT2JqZWN0W10geyJmb28iLCAiYmF6IiwgImpvbyIsICJqYXIifSk7Ci0JCXRoaXMuc2VsZWN0aW9uTW9kZWwucmVtb3ZlU2VsZWN0ZWRWYWx1ZXMobmV3IE9iamVjdFtdIHsiZm9vIiwgImpvbyJ9KTsKLQkJYXNzZXJ0RXF1YWxzKDIsIHRoaXMuc2VsZWN0aW9uTW9kZWwuZ2V0TWluU2VsZWN0aW9uSW5kZXgoKSk7Ci0JCWFzc2VydEVxdWFscyg0LCB0aGlzLnNlbGVjdGlvbk1vZGVsLmdldE1heFNlbGVjdGlvbkluZGV4KCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnNlbGVjdGlvbk1vZGVsLmlzU2VsZWN0ZWRJbmRleCgwKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc2VsZWN0aW9uTW9kZWwuaXNTZWxlY3RlZEluZGV4KDEpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnNlbGVjdGlvbk1vZGVsLmlzU2VsZWN0ZWRJbmRleCgyKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc2VsZWN0aW9uTW9kZWwuaXNTZWxlY3RlZEluZGV4KDMpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnNlbGVjdGlvbk1vZGVsLmlzU2VsZWN0ZWRJbmRleCg0KSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc2VsZWN0aW9uTW9kZWwuaXNTZWxlY3RlZEluZGV4KDUpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0R2V0QW5jaG9yU2VsZWN0ZWRWYWx1ZSgpIHsKLQkJdGhpcy5zZWxlY3Rpb25Nb2RlbC5zZXRBbmNob3JTZWxlY3Rpb25JbmRleCgxKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXIiLCB0aGlzLnNlbGVjdGlvbk1vZGVsLmdldEFuY2hvclNlbGVjdGVkVmFsdWUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEdldExlYWRTZWxlY3RlZFZhbHVlKCkgewotCQl0aGlzLnNlbGVjdGlvbk1vZGVsLnNldFNlbGVjdGVkVmFsdWUoImJhciIpOwotCQlhc3NlcnRFcXVhbHMoImJhciIsIHRoaXMuc2VsZWN0aW9uTW9kZWwuZ2V0TGVhZFNlbGVjdGVkVmFsdWUoKSk7Ci0JCXRoaXMuc2VsZWN0aW9uTW9kZWwuc2V0U2VsZWN0ZWRWYWx1ZXMobmV3IE9iamVjdFtdIHsiZm9vIiwgImJheiJ9KTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXoiLCB0aGlzLnNlbGVjdGlvbk1vZGVsLmdldExlYWRTZWxlY3RlZFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRNaW5NYXhTZWxlY3RlZFZhbHVlKCkgewotCQl0aGlzLmxpc3RNb2RlbC5hZGRFbGVtZW50KCJqb28iKTsKLQkJdGhpcy5saXN0TW9kZWwuYWRkRWxlbWVudCgiamFyIik7Ci0JCXRoaXMubGlzdE1vZGVsLmFkZEVsZW1lbnQoImpheiIpOwotCQl0aGlzLnNlbGVjdGlvbk1vZGVsLnNldFNlbGVjdGVkVmFsdWUoImZvbyIpOwotCQl0aGlzLnNlbGVjdGlvbk1vZGVsLmFkZFNlbGVjdGVkVmFsdWVzKG5ldyBPYmplY3RbXSB7ImJhciIsICJqYXIifSk7Ci0JCWFzc2VydEVxdWFscygiZm9vIiwgdGhpcy5zZWxlY3Rpb25Nb2RlbC5nZXRNaW5TZWxlY3RlZFZhbHVlKCkpOwotCQlhc3NlcnRFcXVhbHMoImphciIsIHRoaXMuc2VsZWN0aW9uTW9kZWwuZ2V0TWF4U2VsZWN0ZWRWYWx1ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VmFsdWVJc1NlbGVjdGVkKCkgewotCQl0aGlzLmxpc3RNb2RlbC5hZGRFbGVtZW50KCJqb28iKTsKLQkJdGhpcy5saXN0TW9kZWwuYWRkRWxlbWVudCgiamFyIik7Ci0JCXRoaXMubGlzdE1vZGVsLmFkZEVsZW1lbnQoImpheiIpOwotCQl0aGlzLnNlbGVjdGlvbk1vZGVsLnNldFNlbGVjdGVkVmFsdWUoImZvbyIpOwotCQl0aGlzLnNlbGVjdGlvbk1vZGVsLmFkZFNlbGVjdGVkVmFsdWVzKG5ldyBPYmplY3RbXSB7ImJhciIsICJqYXIifSk7Ci0JCWFzc2VydFRydWUodGhpcy5zZWxlY3Rpb25Nb2RlbC52YWx1ZUlzU2VsZWN0ZWQoImZvbyIpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnNlbGVjdGlvbk1vZGVsLnZhbHVlSXNTZWxlY3RlZCgiYmFyIikpOwotCQlhc3NlcnRUcnVlKHRoaXMuc2VsZWN0aW9uTW9kZWwudmFsdWVJc1NlbGVjdGVkKCJqYXIiKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuc2VsZWN0aW9uTW9kZWwudmFsdWVJc1NlbGVjdGVkKCJiYXoiKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc0xpc3RlbmVycygpIHRocm93cyBFeGNlcHRpb24gewotCQlMaXN0U2VsZWN0aW9uTGlzdGVuZXIgbGlzdGVuZXIgPSB0aGlzLmJ1aWxkTGlzdFNlbGVjdGlvbkxpc3RlbmVyKCk7Ci0JCWFzc2VydEVxdWFscygwLCB0aGlzLmxpc3RNb2RlbC5nZXRMaXN0RGF0YUxpc3RlbmVycygpLmxlbmd0aCk7Ci0JCXRoaXMuc2VsZWN0aW9uTW9kZWwuYWRkTGlzdFNlbGVjdGlvbkxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIHRoaXMubGlzdE1vZGVsLmdldExpc3REYXRhTGlzdGVuZXJzKCkubGVuZ3RoKTsKLQkJdGhpcy5zZWxlY3Rpb25Nb2RlbC5yZW1vdmVMaXN0U2VsZWN0aW9uTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRFcXVhbHMoMCwgdGhpcy5saXN0TW9kZWwuZ2V0TGlzdERhdGFMaXN0ZW5lcnMoKS5sZW5ndGgpOwotCX0KLQotCXByaXZhdGUgTGlzdFNlbGVjdGlvbkxpc3RlbmVyIGJ1aWxkTGlzdFNlbGVjdGlvbkxpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IExpc3RTZWxlY3Rpb25MaXN0ZW5lcigpIHsKLQkJCXB1YmxpYyB2b2lkIHZhbHVlQ2hhbmdlZChMaXN0U2VsZWN0aW9uRXZlbnQgZSkgewotCQkJCS8vIGRvIG5vdGhpbmcgZm9yIG5vdy4uLgotCQkJfQotCQl9OwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9QcmltaXRpdmVMaXN0VHJlZU1vZGVsVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvUHJpbWl0aXZlTGlzdFRyZWVNb2RlbFRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDNhODM4NGMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9QcmltaXRpdmVMaXN0VHJlZU1vZGVsVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDE5NyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQXJyYXlzOwotaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmEudXRpbC5MaXN0SXRlcmF0b3I7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuVHJlZU1vZGVsRXZlbnQ7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuVHJlZU1vZGVsTGlzdGVuZXI7Ci1pbXBvcnQgamF2YXguc3dpbmcudHJlZS5EZWZhdWx0TXV0YWJsZVRyZWVOb2RlOwotaW1wb3J0IGphdmF4LnN3aW5nLnRyZWUuVHJlZU1vZGVsOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuUmVhZE9ubHlMaXN0SXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5MaXN0QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5QcmltaXRpdmVMaXN0VHJlZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLkxpc3RDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5MaXN0VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5UZXN0VG9vbHM7Ci0KLXB1YmxpYyBjbGFzcyBQcmltaXRpdmVMaXN0VHJlZU1vZGVsVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JVGVzdE1vZGVsIHRlc3RNb2RlbDsKLQlwcml2YXRlIFRyZWVNb2RlbCB0cmVlTW9kZWw7Ci0KLQlwdWJsaWMgUHJpbWl0aXZlTGlzdFRyZWVNb2RlbFRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMudGVzdE1vZGVsID0gdGhpcy5idWlsZFRlc3RNb2RlbCgpOwotCQl0aGlzLnRyZWVNb2RlbCA9IHRoaXMuYnVpbGRUcmVlTW9kZWwoKTsKLQl9Ci0KLQlwcml2YXRlIFRlc3RNb2RlbCBidWlsZFRlc3RNb2RlbCgpIHsKLQkJcmV0dXJuIG5ldyBUZXN0TW9kZWwoKTsKLQl9Ci0KLQlwcml2YXRlIFRyZWVNb2RlbCBidWlsZFRyZWVNb2RlbCgpIHsKLQkJcmV0dXJuIG5ldyBQcmltaXRpdmVMaXN0VHJlZU1vZGVsKHRoaXMuYnVpbGRMaXN0VmFsdWVNb2RlbCgpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHByaW1pdGl2ZUNoYW5nZWQoaW50IGluZGV4LCBPYmplY3QgbmV3VmFsdWUpIHsKLQkJCQlpZiAoICEgbmV3VmFsdWUuZXF1YWxzKCIiKSkgewotCQkJCQlQcmltaXRpdmVMaXN0VHJlZU1vZGVsVGVzdHMudGhpcy50ZXN0TW9kZWwucmVwbGFjZU5hbWUoaW5kZXgsIChTdHJpbmcpIG5ld1ZhbHVlKTsKLQkJCQl9Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBMaXN0Q2hhbmdlTGlzdGVuZXIgYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQkJcmV0dXJuIHRoaXMuYnVpbGRMaXN0Q2hhbmdlTGlzdGVuZXJfKCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDw/PiBidWlsZExpc3RWYWx1ZU1vZGVsKCkgewotCQlyZXR1cm4gbmV3IExpc3RBc3BlY3RBZGFwdGVyPFRlc3RNb2RlbCwgU3RyaW5nPihUZXN0TW9kZWwuTkFNRVNfTElTVCwgdGhpcy50ZXN0TW9kZWwpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIExpc3RJdGVyYXRvcjxTdHJpbmc+IGxpc3RJdGVyYXRvcl8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5uYW1lcygpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIGdldChpbnQgaW5kZXgpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldE5hbWUoaW5kZXgpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgaW50IHNpemUoKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5uYW1lc1NpemUoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZFByaW1pdGl2ZSgpIHsKLQkJdGhpcy50cmVlTW9kZWwuYWRkVHJlZU1vZGVsTGlzdGVuZXIobmV3IFRlc3RUcmVlTW9kZWxMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgdHJlZU5vZGVzSW5zZXJ0ZWQoVHJlZU1vZGVsRXZlbnQgZSkgewotCQkJCVByaW1pdGl2ZUxpc3RUcmVlTW9kZWxUZXN0cy50aGlzLnZlcmlmeVRyZWVNb2RlbEV2ZW50KGUsIG5ldyBpbnRbXSB7MH0sIG5ldyBTdHJpbmdbXSB7ImZvbyJ9KTsKLQkJCX0KLQkJfSk7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZE5hbWUoImZvbyIpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVQcmltaXRpdmUoKSB7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZE5hbWUoImZvbyIpOwotCQl0aGlzLnRlc3RNb2RlbC5hZGROYW1lKCJiYXIiKTsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkTmFtZSgiYmF6Iik7Ci0JCXRoaXMudHJlZU1vZGVsLmFkZFRyZWVNb2RlbExpc3RlbmVyKG5ldyBUZXN0VHJlZU1vZGVsTGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHRyZWVOb2Rlc1JlbW92ZWQoVHJlZU1vZGVsRXZlbnQgZSkgewotCQkJCVByaW1pdGl2ZUxpc3RUcmVlTW9kZWxUZXN0cy50aGlzLnZlcmlmeVRyZWVNb2RlbEV2ZW50KGUsIG5ldyBpbnRbXSB7MX0sIG5ldyBTdHJpbmdbXSB7ImJhciJ9KTsKLQkJCX0KLQkJfSk7Ci0JCVN0cmluZyBuYW1lID0gdGhpcy50ZXN0TW9kZWwucmVtb3ZlTmFtZSgxKTsKLQkJYXNzZXJ0RXF1YWxzKCJiYXIiLCBuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVwbGFjZVByaW1pdGl2ZSgpIHsKLQkJdGhpcy50ZXN0TW9kZWwuYWRkTmFtZSgiZm9vIik7Ci0JCXRoaXMudGVzdE1vZGVsLmFkZE5hbWUoImJhciIpOwotCQl0aGlzLnRlc3RNb2RlbC5hZGROYW1lKCJiYXoiKTsKLQkJdGhpcy50cmVlTW9kZWwuYWRkVHJlZU1vZGVsTGlzdGVuZXIobmV3IFRlc3RUcmVlTW9kZWxMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgdHJlZU5vZGVzQ2hhbmdlZChUcmVlTW9kZWxFdmVudCBlKSB7Ci0JCQkJUHJpbWl0aXZlTGlzdFRyZWVNb2RlbFRlc3RzLnRoaXMudmVyaWZ5VHJlZU1vZGVsRXZlbnQoZSwgbmV3IGludFtdIHsxfSwgbmV3IFN0cmluZ1tdIHsiamFyIn0pOwotCQkJfQotCQl9KTsKLQkJU3RyaW5nIG5hbWUgPSB0aGlzLnRlc3RNb2RlbC5yZXBsYWNlTmFtZSgxLCAiamFyIik7Ci0JCWFzc2VydEVxdWFscygiYmFyIiwgbmFtZSk7Ci0JfQotCi0Jdm9pZCB2ZXJpZnlUcmVlTW9kZWxFdmVudChUcmVlTW9kZWxFdmVudCBlLCBpbnRbXSBleHBlY3RlZENoaWxkSW5kaWNlcywgU3RyaW5nW10gZXhwZWN0ZWROYW1lcykgewotCQlhc3NlcnRUcnVlKEFycmF5cy5lcXVhbHMoZXhwZWN0ZWRDaGlsZEluZGljZXMsIGUuZ2V0Q2hpbGRJbmRpY2VzKCkpKTsKLQkJT2JqZWN0W10gYWN0dWFsQ2hpbGRyZW4gPSBlLmdldENoaWxkcmVuKCk7Ci0JCWFzc2VydEVxdWFscyhleHBlY3RlZE5hbWVzLmxlbmd0aCwgYWN0dWFsQ2hpbGRyZW4ubGVuZ3RoKTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCBleHBlY3RlZE5hbWVzLmxlbmd0aDsgaSsrKSB7Ci0JCQlEZWZhdWx0TXV0YWJsZVRyZWVOb2RlIG5vZGUgPSAoRGVmYXVsdE11dGFibGVUcmVlTm9kZSkgYWN0dWFsQ2hpbGRyZW5baV07Ci0JCQlhc3NlcnRFcXVhbHMoZXhwZWN0ZWROYW1lc1tpXSwgbm9kZS5nZXRVc2VyT2JqZWN0KCkpOwotCQl9Ci0JCWFzc2VydEVxdWFscygxLCBlLmdldFBhdGgoKS5sZW5ndGgpOwotCQlhc3NlcnRFcXVhbHModGhpcy50cmVlTW9kZWwuZ2V0Um9vdCgpLCBlLmdldFBhdGgoKVswXSk7Ci0JCWFzc2VydEVxdWFscyh0aGlzLnRyZWVNb2RlbCwgZS5nZXRTb3VyY2UoKSk7Ci0JfQotCi0KLS8vICoqKioqKioqKiogaW5uZXIgY2xhc3NlcyAqKioqKioqKioqCi0KLQlwcml2YXRlIGNsYXNzIFRlc3RNb2RlbCBleHRlbmRzIEFic3RyYWN0TW9kZWwgewotCQlwcml2YXRlIGZpbmFsIExpc3Q8U3RyaW5nPiBuYW1lczsKLQkJCXN0YXRpYyBmaW5hbCBTdHJpbmcgTkFNRVNfTElTVCA9ICJuYW1lcyI7Ci0JCi0JCVRlc3RNb2RlbCgpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLm5hbWVzID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7Ci0JCX0KLQkKLQkJcHVibGljIExpc3RJdGVyYXRvcjxTdHJpbmc+IG5hbWVzKCkgewotCQkJcmV0dXJuIG5ldyBSZWFkT25seUxpc3RJdGVyYXRvcjxTdHJpbmc+KHRoaXMubmFtZXMpOwotCQl9Ci0JCXB1YmxpYyBpbnQgbmFtZXNTaXplKCkgewotCQkJcmV0dXJuIHRoaXMubmFtZXMuc2l6ZSgpOwotCQl9Ci0JCXB1YmxpYyBTdHJpbmcgZ2V0TmFtZShpbnQgaW5kZXgpIHsKLQkJCXJldHVybiB0aGlzLm5hbWVzLmdldChpbmRleCk7Ci0JCX0KLQkJcHVibGljIHZvaWQgYWRkTmFtZShpbnQgaW5kZXgsIFN0cmluZyBuYW1lKSB7Ci0JCQl0aGlzLmFkZEl0ZW1Ub0xpc3QoaW5kZXgsIG5hbWUsIHRoaXMubmFtZXMsIE5BTUVTX0xJU1QpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGFkZE5hbWUoU3RyaW5nIG5hbWUpIHsKLQkJCXRoaXMuYWRkTmFtZSh0aGlzLm5hbWVzU2l6ZSgpLCBuYW1lKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBhZGROYW1lcyhpbnQgaW5kZXgsIExpc3Q8U3RyaW5nPiBsaXN0KSB7Ci0JCQl0aGlzLmFkZEl0ZW1zVG9MaXN0KGluZGV4LCB0aGlzLm5hbWVzLCBsaXN0LCBOQU1FU19MSVNUKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBhZGROYW1lcyhMaXN0PFN0cmluZz4gbGlzdCkgewotCQkJdGhpcy5hZGROYW1lcyh0aGlzLm5hbWVzU2l6ZSgpLCBsaXN0KTsKLQkJfQotCQlwdWJsaWMgU3RyaW5nIHJlbW92ZU5hbWUoaW50IGluZGV4KSB7Ci0JCQlyZXR1cm4gdGhpcy5yZW1vdmVJdGVtRnJvbUxpc3QoaW5kZXgsIHRoaXMubmFtZXMsIE5BTUVTX0xJU1QpOwotCQl9Ci0JCXB1YmxpYyBMaXN0PFN0cmluZz4gcmVtb3ZlTmFtZXMoaW50IGluZGV4LCBpbnQgbGVuZ3RoKSB7Ci0JCQlyZXR1cm4gdGhpcy5yZW1vdmVJdGVtc0Zyb21MaXN0KGluZGV4LCBsZW5ndGgsIHRoaXMubmFtZXMsIE5BTUVTX0xJU1QpOwotCQl9Ci0JCXB1YmxpYyBTdHJpbmcgcmVwbGFjZU5hbWUoaW50IGluZGV4LCBTdHJpbmcgbmV3TmFtZSkgewotCQkJcmV0dXJuIHRoaXMuc2V0SXRlbUluTGlzdChpbmRleCwgbmV3TmFtZSwgdGhpcy5uYW1lcywgTkFNRVNfTElTVCk7Ci0JCX0KLQl9Ci0JCi0JCi0JcHVibGljIGNsYXNzIFRlc3RUcmVlTW9kZWxMaXN0ZW5lciBpbXBsZW1lbnRzIFRyZWVNb2RlbExpc3RlbmVyIHsKLQkJcHVibGljIHZvaWQgdHJlZU5vZGVzQ2hhbmdlZChUcmVlTW9kZWxFdmVudCBlKSB7Ci0JCQlmYWlsKCJ1bmV4cGVjdGVkIGV2ZW50Iik7Ci0JCX0KLQkJcHVibGljIHZvaWQgdHJlZU5vZGVzSW5zZXJ0ZWQoVHJlZU1vZGVsRXZlbnQgZSkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHRyZWVOb2Rlc1JlbW92ZWQoVHJlZU1vZGVsRXZlbnQgZSkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHRyZWVTdHJ1Y3R1cmVDaGFuZ2VkKFRyZWVNb2RlbEV2ZW50IGUpIHsKLQkJCWZhaWwoInVuZXhwZWN0ZWQgZXZlbnQiKTsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9SYWRpb0J1dHRvbk1vZGVsQWRhcHRlclRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL1JhZGlvQnV0dG9uTW9kZWxBZGFwdGVyVGVzdHMuamF2YQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMGM0YmJlYi4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL1JhZGlvQnV0dG9uTW9kZWxBZGFwdGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDIyOSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nOwotCi1pbXBvcnQgamF2YXguc3dpbmcuQnV0dG9uTW9kZWw7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuQ2hhbmdlRXZlbnQ7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuQ2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuRXZlbnRMaXN0ZW5lckxpc3Q7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNsYXNzVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLlJhZGlvQnV0dG9uTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIFJhZGlvQnV0dG9uTW9kZWxBZGFwdGVyVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IHZhbHVlSG9sZGVyOwotCi0JcHJpdmF0ZSBCdXR0b25Nb2RlbCByZWRCdXR0b25Nb2RlbEFkYXB0ZXI7Ci0JcHJpdmF0ZSBDaGFuZ2VMaXN0ZW5lciByZWRMaXN0ZW5lcjsKLQlib29sZWFuIHJlZEV2ZW50RmlyZWQ7Ci0KLQlwcml2YXRlIEJ1dHRvbk1vZGVsIGdyZWVuQnV0dG9uTW9kZWxBZGFwdGVyOwotCXByaXZhdGUgQ2hhbmdlTGlzdGVuZXIgZ3JlZW5MaXN0ZW5lcjsKLQlib29sZWFuIGdyZWVuRXZlbnRGaXJlZDsKLQotCXByaXZhdGUgQnV0dG9uTW9kZWwgYmx1ZUJ1dHRvbk1vZGVsQWRhcHRlcjsKLQlwcml2YXRlIENoYW5nZUxpc3RlbmVyIGJsdWVMaXN0ZW5lcjsKLQlib29sZWFuIGJsdWVFdmVudEZpcmVkOwotCi0vLwlwcml2YXRlIEJ1dHRvbkdyb3VwIGJ1dHRvbkdyb3VwOwkvLyBETyBOT1QgdXNlIGEgQnV0dG9uR3JvdXAKLQotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBSRUQgPSAicmVkIjsKLQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgR1JFRU4gPSAiZ3JlZW4iOwotCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBCTFVFID0gImJsdWUiOwotCi0JcHVibGljIFJhZGlvQnV0dG9uTW9kZWxBZGFwdGVyVGVzdHMoU3RyaW5nIG5hbWUpIHsKLQkJc3VwZXIobmFtZSk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgc2V0VXAoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJc3VwZXIuc2V0VXAoKTsKLQkJdGhpcy52YWx1ZUhvbGRlciA9IG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PihudWxsKTsKLS8vCQlidXR0b25Hcm91cCA9IG5ldyBCdXR0b25Hcm91cCgpOwotCi0JCXRoaXMucmVkQnV0dG9uTW9kZWxBZGFwdGVyID0gdGhpcy5idWlsZEJ1dHRvbk1vZGVsKHRoaXMudmFsdWVIb2xkZXIsIFJFRCk7Ci0vLwkJdGhpcy5yZWRCdXR0b25Nb2RlbEFkYXB0ZXIuc2V0R3JvdXAoYnV0dG9uR3JvdXApOwotCQl0aGlzLnJlZExpc3RlbmVyID0gbmV3IFRlc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgc3RhdGVDaGFuZ2VkKENoYW5nZUV2ZW50IGUpIHsKLQkJCQlSYWRpb0J1dHRvbk1vZGVsQWRhcHRlclRlc3RzLnRoaXMucmVkRXZlbnRGaXJlZCA9IHRydWU7Ci0JCQl9Ci0JCX07Ci0KLQkJdGhpcy5ncmVlbkJ1dHRvbk1vZGVsQWRhcHRlciA9IHRoaXMuYnVpbGRCdXR0b25Nb2RlbCh0aGlzLnZhbHVlSG9sZGVyLCBHUkVFTik7Ci0vLwkJdGhpcy5ncmVlbkJ1dHRvbk1vZGVsQWRhcHRlci5zZXRHcm91cChidXR0b25Hcm91cCk7Ci0JCXRoaXMuZ3JlZW5MaXN0ZW5lciA9IG5ldyBUZXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHN0YXRlQ2hhbmdlZChDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJUmFkaW9CdXR0b25Nb2RlbEFkYXB0ZXJUZXN0cy50aGlzLmdyZWVuRXZlbnRGaXJlZCA9IHRydWU7Ci0JCQl9Ci0JCX07Ci0KLQkJdGhpcy5ibHVlQnV0dG9uTW9kZWxBZGFwdGVyID0gdGhpcy5idWlsZEJ1dHRvbk1vZGVsKHRoaXMudmFsdWVIb2xkZXIsIEJMVUUpOwotLy8JCXRoaXMuYmx1ZUJ1dHRvbk1vZGVsQWRhcHRlci5zZXRHcm91cChidXR0b25Hcm91cCk7Ci0JCXRoaXMuYmx1ZUxpc3RlbmVyID0gbmV3IFRlc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgc3RhdGVDaGFuZ2VkKENoYW5nZUV2ZW50IGUpIHsKLQkJCQlSYWRpb0J1dHRvbk1vZGVsQWRhcHRlclRlc3RzLnRoaXMuYmx1ZUV2ZW50RmlyZWQgPSB0cnVlOwotCQkJfQotCQl9OwotCQkKLQkJdGhpcy5jbGVhckZsYWdzKCk7Ci0JfQotCi0JcHJpdmF0ZSBCdXR0b25Nb2RlbCBidWlsZEJ1dHRvbk1vZGVsKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gcHZtLCBPYmplY3QgYnV0dG9uVmFsdWUpIHsKLQkJcmV0dXJuIG5ldyBSYWRpb0J1dHRvbk1vZGVsQWRhcHRlcihwdm0sIGJ1dHRvblZhbHVlKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkQm9vbGVhbkNoYW5nZUxpc3RlbmVyKCkgewotCQkJCXJldHVybiB0aGlzLmJ1aWxkQm9vbGVhbkNoYW5nZUxpc3RlbmVyXygpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgdm9pZCBsaXN0ZW5Ub01vZGVsQWRhcHRlcnMoKSB7Ci0JCXRoaXMucmVkQnV0dG9uTW9kZWxBZGFwdGVyLmFkZENoYW5nZUxpc3RlbmVyKHRoaXMucmVkTGlzdGVuZXIpOwotCQl0aGlzLmdyZWVuQnV0dG9uTW9kZWxBZGFwdGVyLmFkZENoYW5nZUxpc3RlbmVyKHRoaXMuZ3JlZW5MaXN0ZW5lcik7Ci0JCXRoaXMuYmx1ZUJ1dHRvbk1vZGVsQWRhcHRlci5hZGRDaGFuZ2VMaXN0ZW5lcih0aGlzLmJsdWVMaXN0ZW5lcik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGNsZWFyRmxhZ3MoKSB7Ci0JCXRoaXMucmVkRXZlbnRGaXJlZCA9IGZhbHNlOwotCQl0aGlzLmdyZWVuRXZlbnRGaXJlZCA9IGZhbHNlOwotCQl0aGlzLmJsdWVFdmVudEZpcmVkID0gZmFsc2U7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIHZvaWQgdGVhckRvd24oKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGVzdFRvb2xzLmNsZWFyKHRoaXMpOwotCQlzdXBlci50ZWFyRG93bigpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRTZWxlY3RlZCgpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmxpc3RlblRvTW9kZWxBZGFwdGVycygpOwotCi0JCXRoaXMuZ3JlZW5CdXR0b25Nb2RlbEFkYXB0ZXIuc2V0U2VsZWN0ZWQodHJ1ZSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMucmVkRXZlbnRGaXJlZCk7Ci0JCWFzc2VydFRydWUodGhpcy5ncmVlbkV2ZW50RmlyZWQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJsdWVFdmVudEZpcmVkKTsKLQkJYXNzZXJ0RXF1YWxzKEdSRUVOLCB0aGlzLnZhbHVlSG9sZGVyLmdldFZhbHVlKCkpOwotCi0JCXRoaXMuY2xlYXJGbGFncygpOwotCQl0aGlzLmJsdWVCdXR0b25Nb2RlbEFkYXB0ZXIuc2V0U2VsZWN0ZWQodHJ1ZSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMucmVkRXZlbnRGaXJlZCk7Ci0JCWFzc2VydFRydWUodGhpcy5ncmVlbkV2ZW50RmlyZWQpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmx1ZUV2ZW50RmlyZWQpOwotCQlhc3NlcnRFcXVhbHMoQkxVRSwgdGhpcy52YWx1ZUhvbGRlci5nZXRWYWx1ZSgpKTsKLQotCQl0aGlzLmNsZWFyRmxhZ3MoKTsKLQkJdGhpcy5yZWRCdXR0b25Nb2RlbEFkYXB0ZXIuc2V0U2VsZWN0ZWQodHJ1ZSk7Ci0JCWFzc2VydFRydWUodGhpcy5yZWRFdmVudEZpcmVkKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5ncmVlbkV2ZW50RmlyZWQpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmx1ZUV2ZW50RmlyZWQpOwotCQlhc3NlcnRFcXVhbHMoUkVELCB0aGlzLnZhbHVlSG9sZGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRWYWx1ZSgpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLmxpc3RlblRvTW9kZWxBZGFwdGVycygpOwotCi0JCXRoaXMuZ3JlZW5CdXR0b25Nb2RlbEFkYXB0ZXIuc2V0U2VsZWN0ZWQodHJ1ZSk7Ci0KLQkJdGhpcy5jbGVhckZsYWdzKCk7Ci0JCXRoaXMudmFsdWVIb2xkZXIuc2V0VmFsdWUoQkxVRSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMucmVkRXZlbnRGaXJlZCk7Ci0JCWFzc2VydFRydWUodGhpcy5ncmVlbkV2ZW50RmlyZWQpOwotCQlhc3NlcnRUcnVlKHRoaXMuYmx1ZUV2ZW50RmlyZWQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnJlZEJ1dHRvbk1vZGVsQWRhcHRlci5pc1NlbGVjdGVkKCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmdyZWVuQnV0dG9uTW9kZWxBZGFwdGVyLmlzU2VsZWN0ZWQoKSk7Ci0JCWFzc2VydFRydWUodGhpcy5ibHVlQnV0dG9uTW9kZWxBZGFwdGVyLmlzU2VsZWN0ZWQoKSk7Ci0KLQkJdGhpcy5jbGVhckZsYWdzKCk7Ci0JCXRoaXMudmFsdWVIb2xkZXIuc2V0VmFsdWUoUkVEKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnJlZEV2ZW50RmlyZWQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmdyZWVuRXZlbnRGaXJlZCk7Ci0JCWFzc2VydFRydWUodGhpcy5ibHVlRXZlbnRGaXJlZCk7Ci0JCWFzc2VydFRydWUodGhpcy5yZWRCdXR0b25Nb2RlbEFkYXB0ZXIuaXNTZWxlY3RlZCgpKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5ncmVlbkJ1dHRvbk1vZGVsQWRhcHRlci5pc1NlbGVjdGVkKCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJsdWVCdXR0b25Nb2RlbEFkYXB0ZXIuaXNTZWxlY3RlZCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGVmYXVsdFZhbHVlKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMubGlzdGVuVG9Nb2RlbEFkYXB0ZXJzKCk7Ci0KLQkJdGhpcy52YWx1ZUhvbGRlci5zZXRWYWx1ZShHUkVFTik7Ci0JCWFzc2VydEZhbHNlKHRoaXMucmVkQnV0dG9uTW9kZWxBZGFwdGVyLmlzU2VsZWN0ZWQoKSk7Ci0JCWFzc2VydFRydWUodGhpcy5ncmVlbkJ1dHRvbk1vZGVsQWRhcHRlci5pc1NlbGVjdGVkKCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmJsdWVCdXR0b25Nb2RlbEFkYXB0ZXIuaXNTZWxlY3RlZCgpKTsKLQotCQl0aGlzLmNsZWFyRmxhZ3MoKTsKLQkJdGhpcy52YWx1ZUhvbGRlci5zZXRWYWx1ZShudWxsKTsKLQkJYXNzZXJ0RmFsc2UodGhpcy5yZWRFdmVudEZpcmVkKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmdyZWVuRXZlbnRGaXJlZCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmx1ZUV2ZW50RmlyZWQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnJlZEJ1dHRvbk1vZGVsQWRhcHRlci5pc1NlbGVjdGVkKCkpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmdyZWVuQnV0dG9uTW9kZWxBZGFwdGVyLmlzU2VsZWN0ZWQoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuYmx1ZUJ1dHRvbk1vZGVsQWRhcHRlci5pc1NlbGVjdGVkKCkpOwotCi0JCXRoaXMuY2xlYXJGbGFncygpOwotCQl0aGlzLnZhbHVlSG9sZGVyLnNldFZhbHVlKEJMVUUpOwotCQlhc3NlcnRGYWxzZSh0aGlzLnJlZEV2ZW50RmlyZWQpOwotCQlhc3NlcnRGYWxzZSh0aGlzLmdyZWVuRXZlbnRGaXJlZCk7Ci0JCWFzc2VydFRydWUodGhpcy5ibHVlRXZlbnRGaXJlZCk7Ci0JCWFzc2VydEZhbHNlKHRoaXMucmVkQnV0dG9uTW9kZWxBZGFwdGVyLmlzU2VsZWN0ZWQoKSk7Ci0JCWFzc2VydEZhbHNlKHRoaXMuZ3JlZW5CdXR0b25Nb2RlbEFkYXB0ZXIuaXNTZWxlY3RlZCgpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmJsdWVCdXR0b25Nb2RlbEFkYXB0ZXIuaXNTZWxlY3RlZCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0SGFzTGlzdGVuZXJzKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IGxvY2FsVmFsdWVIb2xkZXIgPSAoU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4pIHRoaXMudmFsdWVIb2xkZXI7Ci0JCWFzc2VydEZhbHNlKGxvY2FsVmFsdWVIb2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTm9MaXN0ZW5lcnModGhpcy5yZWRCdXR0b25Nb2RlbEFkYXB0ZXIpOwotCQl0aGlzLnZlcmlmeUhhc05vTGlzdGVuZXJzKHRoaXMuZ3JlZW5CdXR0b25Nb2RlbEFkYXB0ZXIpOwotCQl0aGlzLnZlcmlmeUhhc05vTGlzdGVuZXJzKHRoaXMuYmx1ZUJ1dHRvbk1vZGVsQWRhcHRlcik7Ci0KLQkJQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENoYW5nZUxpc3RlbmVyKCk7Ci0JCXRoaXMucmVkQnV0dG9uTW9kZWxBZGFwdGVyLmFkZENoYW5nZUxpc3RlbmVyKGxpc3RlbmVyKTsKLQkJYXNzZXJ0VHJ1ZShsb2NhbFZhbHVlSG9sZGVyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQl0aGlzLnZlcmlmeUhhc0xpc3RlbmVycyh0aGlzLnJlZEJ1dHRvbk1vZGVsQWRhcHRlcik7Ci0JCXRoaXMudmVyaWZ5SGFzTm9MaXN0ZW5lcnModGhpcy5ncmVlbkJ1dHRvbk1vZGVsQWRhcHRlcik7Ci0JCXRoaXMudmVyaWZ5SGFzTm9MaXN0ZW5lcnModGhpcy5ibHVlQnV0dG9uTW9kZWxBZGFwdGVyKTsKLQotCQl0aGlzLnJlZEJ1dHRvbk1vZGVsQWRhcHRlci5yZW1vdmVDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWFzc2VydEZhbHNlKGxvY2FsVmFsdWVIb2xkZXIuaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFKSk7Ci0JCXRoaXMudmVyaWZ5SGFzTm9MaXN0ZW5lcnModGhpcy5yZWRCdXR0b25Nb2RlbEFkYXB0ZXIpOwotCQl0aGlzLnZlcmlmeUhhc05vTGlzdGVuZXJzKHRoaXMuZ3JlZW5CdXR0b25Nb2RlbEFkYXB0ZXIpOwotCQl0aGlzLnZlcmlmeUhhc05vTGlzdGVuZXJzKHRoaXMuYmx1ZUJ1dHRvbk1vZGVsQWRhcHRlcik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUhhc05vTGlzdGVuZXJzKE9iamVjdCBtb2RlbCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCUV2ZW50TGlzdGVuZXJMaXN0IGxpc3RlbmVyTGlzdCA9IChFdmVudExpc3RlbmVyTGlzdCkgQ2xhc3NUb29scy5maWVsZFZhbHVlKG1vZGVsLCAibGlzdGVuZXJMaXN0Iik7Ci0JCWFzc2VydEVxdWFscygwLCBsaXN0ZW5lckxpc3QuZ2V0TGlzdGVuZXJMaXN0KCkubGVuZ3RoKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgdmVyaWZ5SGFzTGlzdGVuZXJzKE9iamVjdCBtb2RlbCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCUV2ZW50TGlzdGVuZXJMaXN0IGxpc3RlbmVyTGlzdCA9IChFdmVudExpc3RlbmVyTGlzdCkgQ2xhc3NUb29scy5maWVsZFZhbHVlKG1vZGVsLCAibGlzdGVuZXJMaXN0Iik7Ci0JCWFzc2VydEZhbHNlKGxpc3RlbmVyTGlzdC5nZXRMaXN0ZW5lckxpc3QoKS5sZW5ndGggPT0gMCk7Ci0JfQotCi0KLQlwcml2YXRlIGNsYXNzIFRlc3RDaGFuZ2VMaXN0ZW5lciBpbXBsZW1lbnRzIENoYW5nZUxpc3RlbmVyIHsKLQkJVGVzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoQ2hhbmdlRXZlbnQgZSkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL1JhZGlvQnV0dG9uTW9kZWxBZGFwdGVyVUlUZXN0LmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL1JhZGlvQnV0dG9uTW9kZWxBZGFwdGVyVUlUZXN0LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGYxMjllMDUuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9SYWRpb0J1dHRvbk1vZGVsQWRhcHRlclVJVGVzdC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsMjU3ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmc7Ci0KLWltcG9ydCBqYXZhLmF3dC5Cb3JkZXJMYXlvdXQ7Ci1pbXBvcnQgamF2YS5hd3QuQ29tcG9uZW50OwotaW1wb3J0IGphdmEuYXd0LkdyaWRMYXlvdXQ7Ci1pbXBvcnQgamF2YS5hd3QuZXZlbnQuQWN0aW9uRXZlbnQ7Ci1pbXBvcnQgamF2YS5hd3QuZXZlbnQuV2luZG93QWRhcHRlcjsKLWltcG9ydCBqYXZhLmF3dC5ldmVudC5XaW5kb3dFdmVudDsKLWltcG9ydCBqYXZhLmF3dC5ldmVudC5XaW5kb3dMaXN0ZW5lcjsKLWltcG9ydCBqYXZheC5zd2luZy5BYnN0cmFjdEFjdGlvbjsKLWltcG9ydCBqYXZheC5zd2luZy5BY3Rpb247Ci1pbXBvcnQgamF2YXguc3dpbmcuQnV0dG9uTW9kZWw7Ci1pbXBvcnQgamF2YXguc3dpbmcuSkJ1dHRvbjsKLWltcG9ydCBqYXZheC5zd2luZy5KRnJhbWU7Ci1pbXBvcnQgamF2YXguc3dpbmcuSlBhbmVsOwotaW1wb3J0IGphdmF4LnN3aW5nLkpSYWRpb0J1dHRvbjsKLWltcG9ydCBqYXZheC5zd2luZy5XaW5kb3dDb25zdGFudHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5SYWRpb0J1dHRvbk1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Qcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci0KLQotLyoqCi0gKiBQbGF5IGFyb3VuZCB3aXRoIGEgc2V0IG9mIHJhZGlvIGJ1dHRvbnMuCi0gKi8KLXB1YmxpYyBjbGFzcyBSYWRpb0J1dHRvbk1vZGVsQWRhcHRlclVJVGVzdCB7Ci0KLQlwcml2YXRlIFRlc3RNb2RlbCB0ZXN0TW9kZWw7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUZXN0TW9kZWw+IHRlc3RNb2RlbEhvbGRlcjsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gY29sb3JIb2xkZXI7Ci0JcHJpdmF0ZSBCdXR0b25Nb2RlbCByZWRCdXR0b25Nb2RlbDsKLQlwcml2YXRlIEJ1dHRvbk1vZGVsIGdyZWVuQnV0dG9uTW9kZWw7Ci0JcHJpdmF0ZSBCdXR0b25Nb2RlbCBibHVlQnV0dG9uTW9kZWw7Ci0KLQlwdWJsaWMgc3RhdGljIHZvaWQgbWFpbihTdHJpbmdbXSBhcmdzKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJbmV3IFJhZGlvQnV0dG9uTW9kZWxBZGFwdGVyVUlUZXN0KCkuZXhlYyhhcmdzKTsKLQl9Ci0KLQlwcml2YXRlIFJhZGlvQnV0dG9uTW9kZWxBZGFwdGVyVUlUZXN0KCkgewotCQlzdXBlcigpOwotCX0KLQotCXByaXZhdGUgdm9pZCBleGVjKFN0cmluZ1tdIGFyZ3MpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLnRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJdGhpcy50ZXN0TW9kZWxIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4odGhpcy50ZXN0TW9kZWwpOwotCQl0aGlzLmNvbG9ySG9sZGVyID0gdGhpcy5idWlsZENvbG9ySG9sZGVyKHRoaXMudGVzdE1vZGVsSG9sZGVyKTsKLQkJdGhpcy5yZWRCdXR0b25Nb2RlbCA9IHRoaXMuYnVpbGRSYWRpb0J1dHRvbk1vZGVsQWRhcHRlcih0aGlzLmNvbG9ySG9sZGVyLCBUZXN0TW9kZWwuUkVEKTsKLQkJdGhpcy5ncmVlbkJ1dHRvbk1vZGVsID0gdGhpcy5idWlsZFJhZGlvQnV0dG9uTW9kZWxBZGFwdGVyKHRoaXMuY29sb3JIb2xkZXIsIFRlc3RNb2RlbC5HUkVFTik7Ci0JCXRoaXMuYmx1ZUJ1dHRvbk1vZGVsID0gdGhpcy5idWlsZFJhZGlvQnV0dG9uTW9kZWxBZGFwdGVyKHRoaXMuY29sb3JIb2xkZXIsIFRlc3RNb2RlbC5CTFVFKTsKLQkJdGhpcy5vcGVuV2luZG93KCk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IGJ1aWxkQ29sb3JIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4gc3ViamVjdEhvbGRlcikgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxUZXN0TW9kZWwsIE9iamVjdD4oc3ViamVjdEhvbGRlciwgVGVzdE1vZGVsLkNPTE9SX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBPYmplY3QgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRDb2xvcigpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oT2JqZWN0IHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldENvbG9yKChTdHJpbmcpIHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIEJ1dHRvbk1vZGVsIGJ1aWxkUmFkaW9CdXR0b25Nb2RlbEFkYXB0ZXIoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBjb2xvclBWTSwgU3RyaW5nIGNvbG9yKSB7Ci0JCXJldHVybiBuZXcgUmFkaW9CdXR0b25Nb2RlbEFkYXB0ZXIoY29sb3JQVk0sIGNvbG9yKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgb3BlbldpbmRvdygpIHsKLQkJSkZyYW1lIHdpbmRvdyA9IG5ldyBKRnJhbWUodGhpcy5nZXRDbGFzcygpLmdldE5hbWUoKSk7Ci0JCXdpbmRvdy5zZXREZWZhdWx0Q2xvc2VPcGVyYXRpb24oV2luZG93Q29uc3RhbnRzLkRPX05PVEhJTkdfT05fQ0xPU0UpOwotCQl3aW5kb3cuYWRkV2luZG93TGlzdGVuZXIodGhpcy5idWlsZFdpbmRvd0xpc3RlbmVyKCkpOwotCQl3aW5kb3cuZ2V0Q29udGVudFBhbmUoKS5hZGQodGhpcy5idWlsZE1haW5QYW5lbCgpLCAiQ2VudGVyIik7Ci0JCXdpbmRvdy5zZXRTaXplKDQwMCwgMTAwKTsKLQkJd2luZG93LnNldExvY2F0aW9uKDIwMCwgMjAwKTsKLQkJd2luZG93LnNldFZpc2libGUodHJ1ZSk7Ci0JfQotCi0JcHJpdmF0ZSBXaW5kb3dMaXN0ZW5lciBidWlsZFdpbmRvd0xpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFdpbmRvd0FkYXB0ZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHdpbmRvd0Nsb3NpbmcoV2luZG93RXZlbnQgZSkgewotCQkJCWUuZ2V0V2luZG93KCkuc2V0VmlzaWJsZShmYWxzZSk7Ci0JCQkJU3lzdGVtLmV4aXQoMCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRNYWluUGFuZWwoKSB7Ci0JCUpQYW5lbCBtYWluUGFuZWwgPSBuZXcgSlBhbmVsKG5ldyBCb3JkZXJMYXlvdXQoKSk7Ci0JCW1haW5QYW5lbC5hZGQodGhpcy5idWlsZFJhZGlvQnV0dG9uUGFuZWwoKSwgQm9yZGVyTGF5b3V0Lk5PUlRIKTsKLQkJbWFpblBhbmVsLmFkZCh0aGlzLmJ1aWxkQ29udHJvbFBhbmVsKCksIEJvcmRlckxheW91dC5TT1VUSCk7Ci0JCXJldHVybiBtYWluUGFuZWw7Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRSYWRpb0J1dHRvblBhbmVsKCkgewotCQlKUGFuZWwgdGFza0xpc3RQYW5lbCA9IG5ldyBKUGFuZWwobmV3IEdyaWRMYXlvdXQoMSwgMCkpOwotCQl0YXNrTGlzdFBhbmVsLmFkZCh0aGlzLmJ1aWxkUmVkUmFkaW9CdXR0b24oKSk7Ci0JCXRhc2tMaXN0UGFuZWwuYWRkKHRoaXMuYnVpbGRHcmVlblJhZGlvQnV0dG9uKCkpOwotCQl0YXNrTGlzdFBhbmVsLmFkZCh0aGlzLmJ1aWxkQmx1ZVJhZGlvQnV0dG9uKCkpOwotCQlyZXR1cm4gdGFza0xpc3RQYW5lbDsKLQl9Ci0KLQlwcml2YXRlIEpSYWRpb0J1dHRvbiBidWlsZFJlZFJhZGlvQnV0dG9uKCkgewotCQlKUmFkaW9CdXR0b24gcmFkaW9CdXR0b24gPSBuZXcgSlJhZGlvQnV0dG9uKCk7Ci0JCXJhZGlvQnV0dG9uLnNldFRleHQoInJlZCIpOwotCQlyYWRpb0J1dHRvbi5zZXRNb2RlbCh0aGlzLnJlZEJ1dHRvbk1vZGVsKTsKLQkJcmV0dXJuIHJhZGlvQnV0dG9uOwotCX0KLQotCXByaXZhdGUgSlJhZGlvQnV0dG9uIGJ1aWxkR3JlZW5SYWRpb0J1dHRvbigpIHsKLQkJSlJhZGlvQnV0dG9uIHJhZGlvQnV0dG9uID0gbmV3IEpSYWRpb0J1dHRvbigpOwotCQlyYWRpb0J1dHRvbi5zZXRUZXh0KCJncmVlbiIpOwotCQlyYWRpb0J1dHRvbi5zZXRNb2RlbCh0aGlzLmdyZWVuQnV0dG9uTW9kZWwpOwotCQlyZXR1cm4gcmFkaW9CdXR0b247Ci0JfQotCi0JcHJpdmF0ZSBKUmFkaW9CdXR0b24gYnVpbGRCbHVlUmFkaW9CdXR0b24oKSB7Ci0JCUpSYWRpb0J1dHRvbiByYWRpb0J1dHRvbiA9IG5ldyBKUmFkaW9CdXR0b24oKTsKLQkJcmFkaW9CdXR0b24uc2V0VGV4dCgiYmx1ZSIpOwotCQlyYWRpb0J1dHRvbi5zZXRNb2RlbCh0aGlzLmJsdWVCdXR0b25Nb2RlbCk7Ci0JCXJldHVybiByYWRpb0J1dHRvbjsKLQl9Ci0KLQlwcml2YXRlIENvbXBvbmVudCBidWlsZENvbnRyb2xQYW5lbCgpIHsKLQkJSlBhbmVsIGNvbnRyb2xQYW5lbCA9IG5ldyBKUGFuZWwobmV3IEdyaWRMYXlvdXQoMSwgMCkpOwotCQljb250cm9sUGFuZWwuYWRkKHRoaXMuYnVpbGRSZXNldENvbG9yQnV0dG9uKCkpOwotCQljb250cm9sUGFuZWwuYWRkKHRoaXMuYnVpbGRDbGVhck1vZGVsQnV0dG9uKCkpOwotCQljb250cm9sUGFuZWwuYWRkKHRoaXMuYnVpbGRSZXN0b3JlTW9kZWxCdXR0b24oKSk7Ci0JCWNvbnRyb2xQYW5lbC5hZGQodGhpcy5idWlsZFByaW50TW9kZWxCdXR0b24oKSk7Ci0JCXJldHVybiBjb250cm9sUGFuZWw7Ci0JfQotCi0JcHJpdmF0ZSBKQnV0dG9uIGJ1aWxkUmVzZXRDb2xvckJ1dHRvbigpIHsKLQkJcmV0dXJuIG5ldyBKQnV0dG9uKHRoaXMuYnVpbGRSZXNldENvbG9yQWN0aW9uKCkpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uIGJ1aWxkUmVzZXRDb2xvckFjdGlvbigpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBYnN0cmFjdEFjdGlvbigicmVzZXQgY29sb3IiKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZXZlbnQpIHsKLQkJCQlSYWRpb0J1dHRvbk1vZGVsQWRhcHRlclVJVGVzdC50aGlzLnJlc2V0Q29sb3IoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldEVuYWJsZWQodHJ1ZSk7Ci0JCXJldHVybiBhY3Rpb247Ci0JfQotCi0Jdm9pZCByZXNldENvbG9yKCkgewotCQl0aGlzLnRlc3RNb2RlbC5zZXRDb2xvcihUZXN0TW9kZWwuREVGQVVMVF9DT0xPUik7Ci0JfQotCi0JcHJpdmF0ZSBKQnV0dG9uIGJ1aWxkQ2xlYXJNb2RlbEJ1dHRvbigpIHsKLQkJcmV0dXJuIG5ldyBKQnV0dG9uKHRoaXMuYnVpbGRDbGVhck1vZGVsQWN0aW9uKCkpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uIGJ1aWxkQ2xlYXJNb2RlbEFjdGlvbigpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBYnN0cmFjdEFjdGlvbigiY2xlYXIgbW9kZWwiKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZXZlbnQpIHsKLQkJCQlSYWRpb0J1dHRvbk1vZGVsQWRhcHRlclVJVGVzdC50aGlzLmNsZWFyTW9kZWwoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldEVuYWJsZWQodHJ1ZSk7Ci0JCXJldHVybiBhY3Rpb247Ci0JfQotCi0Jdm9pZCBjbGVhck1vZGVsKCkgewotCQl0aGlzLnRlc3RNb2RlbEhvbGRlci5zZXRWYWx1ZShudWxsKTsKLQl9Ci0KLQlwcml2YXRlIEpCdXR0b24gYnVpbGRSZXN0b3JlTW9kZWxCdXR0b24oKSB7Ci0JCXJldHVybiBuZXcgSkJ1dHRvbih0aGlzLmJ1aWxkUmVzdG9yZU1vZGVsQWN0aW9uKCkpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uIGJ1aWxkUmVzdG9yZU1vZGVsQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJyZXN0b3JlIG1vZGVsIikgewotCQkJcHVibGljIHZvaWQgYWN0aW9uUGVyZm9ybWVkKEFjdGlvbkV2ZW50IGV2ZW50KSB7Ci0JCQkJUmFkaW9CdXR0b25Nb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5yZXN0b3JlTW9kZWwoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldEVuYWJsZWQodHJ1ZSk7Ci0JCXJldHVybiBhY3Rpb247Ci0JfQotCi0Jdm9pZCByZXN0b3JlTW9kZWwoKSB7Ci0JCXRoaXMudGVzdE1vZGVsSG9sZGVyLnNldFZhbHVlKHRoaXMudGVzdE1vZGVsKTsKLQl9Ci0KLQlwcml2YXRlIEpCdXR0b24gYnVpbGRQcmludE1vZGVsQnV0dG9uKCkgewotCQlyZXR1cm4gbmV3IEpCdXR0b24odGhpcy5idWlsZFByaW50TW9kZWxBY3Rpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb24gYnVpbGRQcmludE1vZGVsQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJwcmludCBtb2RlbCIpIHsKLQkJCXB1YmxpYyB2b2lkIGFjdGlvblBlcmZvcm1lZChBY3Rpb25FdmVudCBldmVudCkgewotCQkJCVJhZGlvQnV0dG9uTW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMucHJpbnRNb2RlbCgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQl2b2lkIHByaW50TW9kZWwoKSB7Ci0JCVN5c3RlbS5vdXQucHJpbnRsbih0aGlzLnRlc3RNb2RlbCk7Ci0JfQotCi0KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBUZXN0TW9kZWwgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIHsKLQkJcHJpdmF0ZSBTdHJpbmcgY29sb3I7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBDT0xPUl9QUk9QRVJUWSA9ICJjb2xvciI7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBSRUQgPSAicmVkIjsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIEdSRUVOID0gImdyZWVuIjsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIEJMVUUgPSAiYmx1ZSI7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBERUZBVUxUX0NPTE9SID0gUkVEOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmdbXSBWQUxJRF9DT0xPUlMgPSB7Ci0JCQkJUkVELAotCQkJCUdSRUVOLAotCQkJCUJMVUUKLQkJCX07Ci0JCi0JCXB1YmxpYyBUZXN0TW9kZWwoKSB7Ci0JCQl0aGlzKERFRkFVTFRfQ09MT1IpOwotCQl9Ci0JCXB1YmxpYyBUZXN0TW9kZWwoU3RyaW5nIGNvbG9yKSB7Ci0JCQl0aGlzLmNvbG9yID0gY29sb3I7Ci0JCX0KLQkJcHVibGljIFN0cmluZyBnZXRDb2xvcigpIHsKLQkJCXJldHVybiB0aGlzLmNvbG9yOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldENvbG9yKFN0cmluZyBjb2xvcikgewotCQkJaWYgKCAhIENvbGxlY3Rpb25Ub29scy5jb250YWlucyhWQUxJRF9DT0xPUlMsIGNvbG9yKSkgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oY29sb3IpOwotCQkJfQotCQkJT2JqZWN0IG9sZCA9IHRoaXMuY29sb3I7Ci0JCQl0aGlzLmNvbG9yID0gY29sb3I7Ci0JCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoQ09MT1JfUFJPUEVSVFksIG9sZCwgY29sb3IpOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuICJUZXN0TW9kZWwoIiArIHRoaXMuY29sb3IgKyAiKSI7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvUmVhZE9ubHlUYWJsZU1vZGVsQWRhcHRlclVJVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9SZWFkT25seVRhYmxlTW9kZWxBZGFwdGVyVUlUZXN0LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDNiZmI2NmYuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9SZWFkT25seVRhYmxlTW9kZWxBZGFwdGVyVUlUZXN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzOSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nOwotCi1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuQ29sdW1uQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5UYWJsZU1vZGVsQWRhcHRlclRlc3RzLlBlcnNvbkNvbHVtbkFkYXB0ZXI7Ci0KLS8qKgotICogTWFrZSBpdCBlYXN5IHRvIHRlc3QgdGhlIHRhYmxlIG1vZGVsIGFkYXB0ZXIgYW5kCi0gKiByZW5kZXJlcnMgd2l0aG91dCBhbnkgZWRpdGluZyBhbGxvd2VkLgotICovCi1wdWJsaWMgY2xhc3MgUmVhZE9ubHlUYWJsZU1vZGVsQWRhcHRlclVJVGVzdCBleHRlbmRzIFRhYmxlTW9kZWxBZGFwdGVyVUlUZXN0IHsKLQotCXB1YmxpYyBzdGF0aWMgdm9pZCBtYWluKFN0cmluZ1tdIGFyZ3MpIHRocm93cyBFeGNlcHRpb24gewotCQluZXcgUmVhZE9ubHlUYWJsZU1vZGVsQWRhcHRlclVJVGVzdCgpLmV4ZWMoYXJncyk7Ci0JfQotCi0JcHJvdGVjdGVkIFJlYWRPbmx5VGFibGVNb2RlbEFkYXB0ZXJVSVRlc3QoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JQE92ZXJyaWRlCi0JcHJvdGVjdGVkIENvbHVtbkFkYXB0ZXIgYnVpbGRDb2x1bW5BZGFwdGVyKCkgewotCQlyZXR1cm4gbmV3IFBlcnNvbkNvbHVtbkFkYXB0ZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyBib29sZWFuIGNvbHVtbklzRWRpdGFibGUoaW50IGluZGV4KSB7Ci0JCQkJcmV0dXJuIGZhbHNlOwotCQkJfQotCQl9OwotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9TcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvU3Bpbm5lck1vZGVsQWRhcHRlclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGM4YmIwMjMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9TcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDExNyArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nOwotCi1pbXBvcnQgamF2YXguc3dpbmcuU3Bpbm5lck1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LkNoYW5nZUV2ZW50OwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50LkNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5DbGFzc1Rvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5TcGlubmVyTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLlRlc3RUb29sczsKLQotcHVibGljIGNsYXNzIFNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gdmFsdWVIb2xkZXI7Ci0JU3Bpbm5lck1vZGVsIHNwaW5uZXJNb2RlbEFkYXB0ZXI7Ci0JYm9vbGVhbiBldmVudEZpcmVkOwotCi0JcHVibGljIFNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLnZhbHVlSG9sZGVyID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+KG5ldyBJbnRlZ2VyKDApKTsKLQkJdGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyID0gbmV3IFNwaW5uZXJNb2RlbEFkYXB0ZXIodGhpcy52YWx1ZUhvbGRlcikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZFZhbHVlTGlzdGVuZXIoKSB7Ci0JCQkJcmV0dXJuIHRoaXMuYnVpbGRWYWx1ZUxpc3RlbmVyXygpOwotCQkJfQotCQl9OwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHRlYXJEb3duKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRlc3RUb29scy5jbGVhcih0aGlzKTsKLQkJc3VwZXIudGVhckRvd24oKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0U2V0VmFsdWVTcGlubmVyTW9kZWwoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJdGhpcy5ldmVudEZpcmVkID0gZmFsc2U7Ci0JCXRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5hZGRDaGFuZ2VMaXN0ZW5lcihuZXcgVGVzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCBzdGF0ZUNoYW5nZWQoQ2hhbmdlRXZlbnQgZSkgewotCQkJCVNwaW5uZXJNb2RlbEFkYXB0ZXJUZXN0cy50aGlzLmV2ZW50RmlyZWQgPSB0cnVlOwotCQkJCWFzc2VydEVxdWFscyhTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyLCBlLmdldFNvdXJjZSgpKTsKLQkJCX0KLQkJfSk7Ci0JCXRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5zZXRWYWx1ZShuZXcgSW50ZWdlcig1KSk7Ci0JCWFzc2VydFRydWUodGhpcy5ldmVudEZpcmVkKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBJbnRlZ2VyKDUpLCB0aGlzLnZhbHVlSG9sZGVyLmdldFZhbHVlKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRWYWx1ZVZhbHVlSG9sZGVyKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMuZXZlbnRGaXJlZCA9IGZhbHNlOwotCQl0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIuYWRkQ2hhbmdlTGlzdGVuZXIobmV3IFRlc3RDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgc3RhdGVDaGFuZ2VkKENoYW5nZUV2ZW50IGUpIHsKLQkJCQlTcGlubmVyTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCQlhc3NlcnRFcXVhbHMoU3Bpbm5lck1vZGVsQWRhcHRlclRlc3RzLnRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlciwgZS5nZXRTb3VyY2UoKSk7Ci0JCQl9Ci0JCX0pOwotCQlhc3NlcnRFcXVhbHMobmV3IEludGVnZXIoMCksIHRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5nZXRWYWx1ZSgpKTsKLQkJdGhpcy52YWx1ZUhvbGRlci5zZXRWYWx1ZShuZXcgSW50ZWdlcig3KSk7Ci0JCWFzc2VydFRydWUodGhpcy5ldmVudEZpcmVkKTsKLQkJYXNzZXJ0RXF1YWxzKG5ldyBJbnRlZ2VyKDcpLCB0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIuZ2V0VmFsdWUoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEhhc0xpc3RlbmVycygpIHRocm93cyBFeGNlcHRpb24gewotCQlTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBsb2NhbFZhbHVlSG9sZGVyID0gKFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+KSB0aGlzLnZhbHVlSG9sZGVyOwotCQlhc3NlcnRGYWxzZShsb2NhbFZhbHVlSG9sZGVyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQl0aGlzLnZlcmlmeUhhc05vTGlzdGVuZXJzKHRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlcik7Ci0KLQkJQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIgPSBuZXcgVGVzdENoYW5nZUxpc3RlbmVyKCk7Ci0JCXRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlci5hZGRDaGFuZ2VMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWFzc2VydFRydWUobG9jYWxWYWx1ZUhvbGRlci5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUpKTsKLQkJdGhpcy52ZXJpZnlIYXNMaXN0ZW5lcnModGhpcy5zcGlubmVyTW9kZWxBZGFwdGVyKTsKLQotCQl0aGlzLnNwaW5uZXJNb2RlbEFkYXB0ZXIucmVtb3ZlQ2hhbmdlTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRGYWxzZShsb2NhbFZhbHVlSG9sZGVyLmhhc0FueVByb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFByb3BlcnR5VmFsdWVNb2RlbC5WQUxVRSkpOwotCQl0aGlzLnZlcmlmeUhhc05vTGlzdGVuZXJzKHRoaXMuc3Bpbm5lck1vZGVsQWRhcHRlcik7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUhhc05vTGlzdGVuZXJzKE9iamVjdCBhZGFwdGVyKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJT2JqZWN0IGRlbGVnYXRlID0gQ2xhc3NUb29scy5maWVsZFZhbHVlKGFkYXB0ZXIsICJkZWxlZ2F0ZSIpOwotCQlPYmplY3RbXSBsaXN0ZW5lcnMgPSAoT2JqZWN0W10pIENsYXNzVG9vbHMuZXhlY3V0ZU1ldGhvZChkZWxlZ2F0ZSwgImdldENoYW5nZUxpc3RlbmVycyIpOwotCQlhc3NlcnRFcXVhbHMoMCwgbGlzdGVuZXJzLmxlbmd0aCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIHZlcmlmeUhhc0xpc3RlbmVycyhPYmplY3QgYWRhcHRlcikgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCU9iamVjdCBkZWxlZ2F0ZSA9IENsYXNzVG9vbHMuZmllbGRWYWx1ZShhZGFwdGVyLCAiZGVsZWdhdGUiKTsKLQkJT2JqZWN0W10gbGlzdGVuZXJzID0gKE9iamVjdFtdKSBDbGFzc1Rvb2xzLmV4ZWN1dGVNZXRob2QoZGVsZWdhdGUsICJnZXRDaGFuZ2VMaXN0ZW5lcnMiKTsKLQkJYXNzZXJ0RmFsc2UobGlzdGVuZXJzLmxlbmd0aCA9PSAwKTsKLQl9Ci0KLQotCXByaXZhdGUgY2xhc3MgVGVzdENoYW5nZUxpc3RlbmVyIGltcGxlbWVudHMgQ2hhbmdlTGlzdGVuZXIgewotCQlUZXN0Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHN0YXRlQ2hhbmdlZChDaGFuZ2VFdmVudCBlKSB7Ci0JCQlmYWlsKCJ1bmV4cGVjdGVkIGV2ZW50Iik7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvU3Bpbm5lck1vZGVsQWRhcHRlclVJVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9TcGlubmVyTW9kZWxBZGFwdGVyVUlUZXN0LmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGI2MjJkZTEuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9TcGlubmVyTW9kZWxBZGFwdGVyVUlUZXN0LmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwzNDEgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZzsKLQotaW1wb3J0IGphdmEuYXd0LkJvcmRlckxheW91dDsKLWltcG9ydCBqYXZhLmF3dC5Db21wb25lbnQ7Ci1pbXBvcnQgamF2YS5hd3QuR3JpZExheW91dDsKLWltcG9ydCBqYXZhLmF3dC5ldmVudC5BY3Rpb25FdmVudDsKLWltcG9ydCBqYXZhLmF3dC5ldmVudC5XaW5kb3dBZGFwdGVyOwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LldpbmRvd0V2ZW50OwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LldpbmRvd0xpc3RlbmVyOwotaW1wb3J0IGphdmEudXRpbC5DYWxlbmRhcjsKLWltcG9ydCBqYXZhLnV0aWwuRGF0ZTsKLWltcG9ydCBqYXZheC5zd2luZy5BYnN0cmFjdEFjdGlvbjsKLWltcG9ydCBqYXZheC5zd2luZy5BY3Rpb247Ci1pbXBvcnQgamF2YXguc3dpbmcuSkJ1dHRvbjsKLWltcG9ydCBqYXZheC5zd2luZy5KRnJhbWU7Ci1pbXBvcnQgamF2YXguc3dpbmcuSlBhbmVsOwotaW1wb3J0IGphdmF4LnN3aW5nLkpTcGlubmVyOwotaW1wb3J0IGphdmF4LnN3aW5nLlNwaW5uZXJNb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy5XaW5kb3dDb25zdGFudHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ29sbGVjdGlvblRvb2xzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLkFic3RyYWN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5EYXRlU3Bpbm5lck1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5MaXN0U3Bpbm5lck1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5OdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5Xcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDsKLQotLyoqCi0gKiBQbGF5IGFyb3VuZCB3aXRoIGEgc2V0IG9mIHNwaW5uZXJzLgotICovCi1wdWJsaWMgY2xhc3MgU3Bpbm5lck1vZGVsQWRhcHRlclVJVGVzdCB7Ci0KLQlwcml2YXRlIFRlc3RNb2RlbCB0ZXN0TW9kZWw7Ci0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxUZXN0TW9kZWw+IHRlc3RNb2RlbEhvbGRlcjsKLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBiaXJ0aERhdGVIb2xkZXI7Ci0JcHJpdmF0ZSBTcGlubmVyTW9kZWwgYmlydGhEYXRlU3Bpbm5lck1vZGVsOwotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxOdW1iZXI+IGFnZUhvbGRlcjsKLQlwcml2YXRlIFNwaW5uZXJNb2RlbCBhZ2VTcGlubmVyTW9kZWw7Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gZXllQ29sb3JIb2xkZXI7Ci0JcHJpdmF0ZSBTcGlubmVyTW9kZWwgZXllQ29sb3JTcGlubmVyTW9kZWw7Ci0KLQotCXB1YmxpYyBzdGF0aWMgdm9pZCBtYWluKFN0cmluZ1tdIGFyZ3MpIHRocm93cyBFeGNlcHRpb24gewotCQluZXcgU3Bpbm5lck1vZGVsQWRhcHRlclVJVGVzdCgpLmV4ZWMoYXJncyk7Ci0JfQotCi0JcHJpdmF0ZSBTcGlubmVyTW9kZWxBZGFwdGVyVUlUZXN0KCkgewotCQlzdXBlcigpOwotCX0KLQotCXByaXZhdGUgdm9pZCBleGVjKFN0cmluZ1tdIGFyZ3MpIHRocm93cyBFeGNlcHRpb24gewotCQl0aGlzLnRlc3RNb2RlbCA9IG5ldyBUZXN0TW9kZWwoKTsKLQkJdGhpcy50ZXN0TW9kZWxIb2xkZXIgPSBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4odGhpcy50ZXN0TW9kZWwpOwotCi0JCXRoaXMuYmlydGhEYXRlSG9sZGVyID0gdGhpcy5idWlsZEJpcnRoRGF0ZUhvbGRlcih0aGlzLnRlc3RNb2RlbEhvbGRlcik7Ci0JCXRoaXMuYmlydGhEYXRlU3Bpbm5lck1vZGVsID0gdGhpcy5idWlsZEJpcnRoRGF0ZVNwaW5uZXJNb2RlbCh0aGlzLmJpcnRoRGF0ZUhvbGRlcik7Ci0KLQkJdGhpcy5hZ2VIb2xkZXIgPSB0aGlzLmJ1aWxkQWdlSG9sZGVyKHRoaXMudGVzdE1vZGVsSG9sZGVyKTsKLQkJdGhpcy5hZ2VTcGlubmVyTW9kZWwgPSB0aGlzLmJ1aWxkQWdlU3Bpbm5lck1vZGVsKHRoaXMuYWdlSG9sZGVyKTsKLQotCQl0aGlzLmV5ZUNvbG9ySG9sZGVyID0gdGhpcy5idWlsZEV5ZUNvbG9ySG9sZGVyKHRoaXMudGVzdE1vZGVsSG9sZGVyKTsKLQkJdGhpcy5leWVDb2xvclNwaW5uZXJNb2RlbCA9IHRoaXMuYnVpbGRFeWVDb2xvclNwaW5uZXJNb2RlbCh0aGlzLmV5ZUNvbG9ySG9sZGVyKTsKLQotCQl0aGlzLm9wZW5XaW5kb3coKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gYnVpbGRCaXJ0aERhdGVIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4gdm0pIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VGVzdE1vZGVsLCBPYmplY3Q+KHZtLCBUZXN0TW9kZWwuQklSVEhfREFURV9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgT2JqZWN0IGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0QmlydGhEYXRlKCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhPYmplY3QgdmFsdWUpIHsKLQkJCQl0aGlzLnN1YmplY3Quc2V0QmlydGhEYXRlKChEYXRlKSB2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBTcGlubmVyTW9kZWwgYnVpbGRCaXJ0aERhdGVTcGlubmVyTW9kZWwoV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiB2YWx1ZUhvbGRlcikgewotCQlyZXR1cm4gbmV3IERhdGVTcGlubmVyTW9kZWxBZGFwdGVyKHZhbHVlSG9sZGVyKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE51bWJlcj4gYnVpbGRBZ2VIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4gdm0pIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VGVzdE1vZGVsLCBOdW1iZXI+KHZtLCBUZXN0TW9kZWwuQUdFX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBOdW1iZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIG5ldyBJbnRlZ2VyKHRoaXMuc3ViamVjdC5nZXRBZ2UoKSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhOdW1iZXIgdmFsdWUpIHsKLQkJCQl0aGlzLnN1YmplY3Quc2V0QWdlKHZhbHVlLmludFZhbHVlKCkpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgU3Bpbm5lck1vZGVsIGJ1aWxkQWdlU3Bpbm5lck1vZGVsKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE51bWJlcj4gdmFsdWVIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBOdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyKHZhbHVlSG9sZGVyLCB2YWx1ZUhvbGRlci5nZXRWYWx1ZSgpLmludFZhbHVlKCksIFRlc3RNb2RlbC5NSU5fQUdFLCBUZXN0TW9kZWwuTUFYX0FHRSwgMSk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IGJ1aWxkRXllQ29sb3JIb2xkZXIoUHJvcGVydHlWYWx1ZU1vZGVsPFRlc3RNb2RlbD4gdm0pIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8VGVzdE1vZGVsLCBPYmplY3Q+KHZtLCBUZXN0TW9kZWwuRVlFX0NPTE9SX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBPYmplY3QgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRFeWVDb2xvcigpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oT2JqZWN0IHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldEV5ZUNvbG9yKChTdHJpbmcpIHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFNwaW5uZXJNb2RlbCBidWlsZEV5ZUNvbG9yU3Bpbm5lck1vZGVsKFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gdmFsdWVIb2xkZXIpIHsKLQkJcmV0dXJuIG5ldyBMaXN0U3Bpbm5lck1vZGVsQWRhcHRlcih2YWx1ZUhvbGRlciwgVGVzdE1vZGVsLlZBTElEX0VZRV9DT0xPUlMpOwotCX0KLQotCXByaXZhdGUgdm9pZCBvcGVuV2luZG93KCkgewotCQlKRnJhbWUgd2luZG93ID0gbmV3IEpGcmFtZSh0aGlzLmdldENsYXNzKCkuZ2V0TmFtZSgpKTsKLQkJd2luZG93LnNldERlZmF1bHRDbG9zZU9wZXJhdGlvbihXaW5kb3dDb25zdGFudHMuRE9fTk9USElOR19PTl9DTE9TRSk7Ci0JCXdpbmRvdy5hZGRXaW5kb3dMaXN0ZW5lcih0aGlzLmJ1aWxkV2luZG93TGlzdGVuZXIoKSk7Ci0JCXdpbmRvdy5nZXRDb250ZW50UGFuZSgpLmFkZCh0aGlzLmJ1aWxkTWFpblBhbmVsKCksICJDZW50ZXIiKTsKLQkJd2luZG93LnNldFNpemUoNjAwLCAxMDApOwotCQl3aW5kb3cuc2V0VmlzaWJsZSh0cnVlKTsKLQl9Ci0KLQlwcml2YXRlIFdpbmRvd0xpc3RlbmVyIGJ1aWxkV2luZG93TGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgV2luZG93QWRhcHRlcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgd2luZG93Q2xvc2luZyhXaW5kb3dFdmVudCBlKSB7Ci0JCQkJZS5nZXRXaW5kb3coKS5zZXRWaXNpYmxlKGZhbHNlKTsKLQkJCQlTeXN0ZW0uZXhpdCgwKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbXBvbmVudCBidWlsZE1haW5QYW5lbCgpIHsKLQkJSlBhbmVsIG1haW5QYW5lbCA9IG5ldyBKUGFuZWwobmV3IEJvcmRlckxheW91dCgpKTsKLQkJbWFpblBhbmVsLmFkZCh0aGlzLmJ1aWxkU3Bpbm5lclBhbmVsKCksIEJvcmRlckxheW91dC5OT1JUSCk7Ci0JCW1haW5QYW5lbC5hZGQodGhpcy5idWlsZENvbnRyb2xQYW5lbCgpLCBCb3JkZXJMYXlvdXQuU09VVEgpOwotCQlyZXR1cm4gbWFpblBhbmVsOwotCX0KLQotCXByaXZhdGUgQ29tcG9uZW50IGJ1aWxkU3Bpbm5lclBhbmVsKCkgewotCQlKUGFuZWwgdGFza0xpc3RQYW5lbCA9IG5ldyBKUGFuZWwobmV3IEdyaWRMYXlvdXQoMSwgMCkpOwotCQl0YXNrTGlzdFBhbmVsLmFkZCh0aGlzLmJ1aWxkQmlydGhEYXRlU3Bpbm5lcigpKTsKLQkJdGFza0xpc3RQYW5lbC5hZGQodGhpcy5idWlsZEFnZVNwaW5uZXIoKSk7Ci0JCXRhc2tMaXN0UGFuZWwuYWRkKHRoaXMuYnVpbGRFeWVDb2xvclNwaW5uZXIoKSk7Ci0JCXJldHVybiB0YXNrTGlzdFBhbmVsOwotCX0KLQotCXByaXZhdGUgSlNwaW5uZXIgYnVpbGRCaXJ0aERhdGVTcGlubmVyKCkgewotCQlyZXR1cm4gbmV3IEpTcGlubmVyKHRoaXMuYmlydGhEYXRlU3Bpbm5lck1vZGVsKTsKLQl9Ci0KLQlwcml2YXRlIEpTcGlubmVyIGJ1aWxkQWdlU3Bpbm5lcigpIHsKLQkJcmV0dXJuIG5ldyBKU3Bpbm5lcih0aGlzLmFnZVNwaW5uZXJNb2RlbCk7Ci0JfQotCi0JcHJpdmF0ZSBKU3Bpbm5lciBidWlsZEV5ZUNvbG9yU3Bpbm5lcigpIHsKLQkJcmV0dXJuIG5ldyBKU3Bpbm5lcih0aGlzLmV5ZUNvbG9yU3Bpbm5lck1vZGVsKTsKLQl9Ci0KLQlwcml2YXRlIENvbXBvbmVudCBidWlsZENvbnRyb2xQYW5lbCgpIHsKLQkJSlBhbmVsIGNvbnRyb2xQYW5lbCA9IG5ldyBKUGFuZWwobmV3IEdyaWRMYXlvdXQoMSwgMCkpOwotCQljb250cm9sUGFuZWwuYWRkKHRoaXMuYnVpbGRSZXNldE1vZGVsQnV0dG9uKCkpOwotCQljb250cm9sUGFuZWwuYWRkKHRoaXMuYnVpbGRDbGVhck1vZGVsQnV0dG9uKCkpOwotCQljb250cm9sUGFuZWwuYWRkKHRoaXMuYnVpbGRSZXN0b3JlTW9kZWxCdXR0b24oKSk7Ci0JCWNvbnRyb2xQYW5lbC5hZGQodGhpcy5idWlsZFByaW50TW9kZWxCdXR0b24oKSk7Ci0JCXJldHVybiBjb250cm9sUGFuZWw7Ci0JfQotCi0JcHJpdmF0ZSBKQnV0dG9uIGJ1aWxkUmVzZXRNb2RlbEJ1dHRvbigpIHsKLQkJcmV0dXJuIG5ldyBKQnV0dG9uKHRoaXMuYnVpbGRSZXNldE1vZGVsQWN0aW9uKCkpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uIGJ1aWxkUmVzZXRNb2RlbEFjdGlvbigpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBYnN0cmFjdEFjdGlvbigicmVzZXQgbW9kZWwiKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZXZlbnQpIHsKLQkJCQlTcGlubmVyTW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMucmVzZXRNb2RlbCgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQl2b2lkIHJlc2V0TW9kZWwoKSB7Ci0JCXRoaXMudGVzdE1vZGVsLnNldEJpcnRoRGF0ZShUZXN0TW9kZWwuREVGQVVMVF9CSVJUSF9EQVRFKTsKLQkJdGhpcy50ZXN0TW9kZWwuc2V0RXllQ29sb3IoVGVzdE1vZGVsLkRFRkFVTFRfRVlFX0NPTE9SKTsKLQl9Ci0KLQlwcml2YXRlIEpCdXR0b24gYnVpbGRDbGVhck1vZGVsQnV0dG9uKCkgewotCQlyZXR1cm4gbmV3IEpCdXR0b24odGhpcy5idWlsZENsZWFyTW9kZWxBY3Rpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb24gYnVpbGRDbGVhck1vZGVsQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJjbGVhciBtb2RlbCIpIHsKLQkJCXB1YmxpYyB2b2lkIGFjdGlvblBlcmZvcm1lZChBY3Rpb25FdmVudCBldmVudCkgewotCQkJCVNwaW5uZXJNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5jbGVhck1vZGVsKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRFbmFibGVkKHRydWUpOwotCQlyZXR1cm4gYWN0aW9uOwotCX0KLQotCXZvaWQgY2xlYXJNb2RlbCgpIHsKLQkJdGhpcy50ZXN0TW9kZWxIb2xkZXIuc2V0VmFsdWUobnVsbCk7Ci0JfQotCi0JcHJpdmF0ZSBKQnV0dG9uIGJ1aWxkUmVzdG9yZU1vZGVsQnV0dG9uKCkgewotCQlyZXR1cm4gbmV3IEpCdXR0b24odGhpcy5idWlsZFJlc3RvcmVNb2RlbEFjdGlvbigpKTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbiBidWlsZFJlc3RvcmVNb2RlbEFjdGlvbigpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBYnN0cmFjdEFjdGlvbigicmVzdG9yZSBtb2RlbCIpIHsKLQkJCXB1YmxpYyB2b2lkIGFjdGlvblBlcmZvcm1lZChBY3Rpb25FdmVudCBldmVudCkgewotCQkJCVNwaW5uZXJNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5yZXN0b3JlTW9kZWwoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldEVuYWJsZWQodHJ1ZSk7Ci0JCXJldHVybiBhY3Rpb247Ci0JfQotCi0Jdm9pZCByZXN0b3JlTW9kZWwoKSB7Ci0JCXRoaXMudGVzdE1vZGVsSG9sZGVyLnNldFZhbHVlKHRoaXMudGVzdE1vZGVsKTsKLQl9Ci0KLQlwcml2YXRlIEpCdXR0b24gYnVpbGRQcmludE1vZGVsQnV0dG9uKCkgewotCQlyZXR1cm4gbmV3IEpCdXR0b24odGhpcy5idWlsZFByaW50TW9kZWxBY3Rpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb24gYnVpbGRQcmludE1vZGVsQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJwcmludCBtb2RlbCIpIHsKLQkJCXB1YmxpYyB2b2lkIGFjdGlvblBlcmZvcm1lZChBY3Rpb25FdmVudCBldmVudCkgewotCQkJCVNwaW5uZXJNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5wcmludE1vZGVsKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRFbmFibGVkKHRydWUpOwotCQlyZXR1cm4gYWN0aW9uOwotCX0KLQotCXZvaWQgcHJpbnRNb2RlbCgpIHsKLQkJU3lzdGVtLm91dC5wcmludGxuKCJiaXJ0aCBkYXRlOiAiICsgdGhpcy50ZXN0TW9kZWwuZ2V0QmlydGhEYXRlKCkpOwotCQlTeXN0ZW0ub3V0LnByaW50bG4oImFnZTogIiArIHRoaXMudGVzdE1vZGVsLmdldEFnZSgpKTsKLQkJU3lzdGVtLm91dC5wcmludGxuKCJleWVzOiAiICsgdGhpcy50ZXN0TW9kZWwuZ2V0RXllQ29sb3IoKSk7Ci0JfQotCi0KLQlwcml2YXRlIHN0YXRpYyBjbGFzcyBUZXN0TW9kZWwgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIHsKLQkJcHJpdmF0ZSBDYWxlbmRhciBiaXJ0aENhbCA9IENhbGVuZGFyLmdldEluc3RhbmNlKCk7Ci0JCQkvLyAidmlydHVhbCIgcHJvcGVydGllcwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgQklSVEhfREFURV9QUk9QRVJUWSA9ICJiaXJ0aERhdGUiOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgQUdFX1BST1BFUlRZID0gImFnZSI7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIERhdGUgREVGQVVMVF9CSVJUSF9EQVRFID0gbmV3IERhdGUoKTsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgaW50IERFRkFVTFRfQUdFID0gMDsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgaW50IE1JTl9BR0UgPSAwOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBpbnQgTUFYX0FHRSA9IDE1MDsKLQkJcHJpdmF0ZSBTdHJpbmcgZXllQ29sb3I7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBFWUVfQ09MT1JfUFJPUEVSVFkgPSAiZXllQ29sb3IiOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmdbXSBWQUxJRF9FWUVfQ09MT1JTID0geyJibHVlIiwgImJyb3duIiwgImdyZWVuIiwgImhhemVsIiwgInBpbmsifTsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIERFRkFVTFRfRVlFX0NPTE9SID0gVkFMSURfRVlFX0NPTE9SU1szXTsKLQkKLQkJcHVibGljIFRlc3RNb2RlbCgpIHsKLQkJCXRoaXMoREVGQVVMVF9CSVJUSF9EQVRFLCBERUZBVUxUX0VZRV9DT0xPUik7Ci0JCX0KLQkJcHVibGljIFRlc3RNb2RlbChEYXRlIGJpcnRoRGF0ZSwgU3RyaW5nIGV5ZUNvbG9yKSB7Ci0JCQl0aGlzLnNldEJpcnRoRGF0ZShiaXJ0aERhdGUpOwotCQkJdGhpcy5zZXRFeWVDb2xvcihleWVDb2xvcik7Ci0JCX0KLQkJcHVibGljIERhdGUgZ2V0QmlydGhEYXRlKCkgewotCQkJcmV0dXJuIChEYXRlKSB0aGlzLmJpcnRoQ2FsLmdldFRpbWUoKS5jbG9uZSgpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldEJpcnRoRGF0ZShEYXRlIGJpcnRoRGF0ZSkgewotCQkJRGF0ZSBvbGRCaXJ0aERhdGUgPSB0aGlzLmdldEJpcnRoRGF0ZSgpOwotCQkJaW50IG9sZEFnZSA9IHRoaXMuZ2V0QWdlKCk7Ci0JCQl0aGlzLmJpcnRoQ2FsLnNldFRpbWVJbk1pbGxpcyhiaXJ0aERhdGUuZ2V0VGltZSgpKTsKLQkJCWludCBuZXdBZ2UgPSB0aGlzLmdldEFnZSgpOwotCQkJaWYgKG5ld0FnZSA8IE1JTl9BR0UgfHwgbmV3QWdlID4gTUFYX0FHRSkgewotCQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oYmlydGhEYXRlLnRvU3RyaW5nKCkpOwotCQkJfQotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKEJJUlRIX0RBVEVfUFJPUEVSVFksIG9sZEJpcnRoRGF0ZSwgdGhpcy5nZXRCaXJ0aERhdGUoKSk7Ci0JCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoQUdFX1BST1BFUlRZLCBvbGRBZ2UsIG5ld0FnZSk7Ci0JCX0KLQkJcHVibGljIGludCBnZXRBZ2UoKSB7Ci0JCQlDYWxlbmRhciBjdXJyZW50Q2FsID0gQ2FsZW5kYXIuZ2V0SW5zdGFuY2UoKTsKLQkJCWludCBhZ2UgPSBjdXJyZW50Q2FsLmdldChDYWxlbmRhci5ZRUFSKSAtIHRoaXMuYmlydGhDYWwuZ2V0KENhbGVuZGFyLllFQVIpOwotCQkJaWYgKGN1cnJlbnRDYWwuZ2V0KENhbGVuZGFyLk1PTlRIKSA8IHRoaXMuYmlydGhDYWwuZ2V0KENhbGVuZGFyLk1PTlRIKSkgewotCQkJCWFnZS0tOwotCQkJfSBlbHNlIGlmIChjdXJyZW50Q2FsLmdldChDYWxlbmRhci5NT05USCkgPT0gdGhpcy5iaXJ0aENhbC5nZXQoQ2FsZW5kYXIuTU9OVEgpKSB7Ci0JCQkJaWYgKGN1cnJlbnRDYWwuZ2V0KENhbGVuZGFyLkRBWV9PRl9NT05USCkgPCB0aGlzLmJpcnRoQ2FsLmdldChDYWxlbmRhci5EQVlfT0ZfTU9OVEgpKSB7Ci0JCQkJCWFnZS0tOwotCQkJCX0KLQkJCX0KLQkJCXJldHVybiBhZ2U7Ci0JCX0KLQkJcHVibGljIHZvaWQgc2V0QWdlKGludCBuZXdBZ2UpIHsKLQkJCWlmIChuZXdBZ2UgPCBNSU5fQUdFIHx8IG5ld0FnZSA+IE1BWF9BR0UpIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKFN0cmluZy52YWx1ZU9mKG5ld0FnZSkpOwotCQkJfQotCQotCQkJaW50IG9sZEFnZSA9IHRoaXMuZ2V0QWdlKCk7Ci0JCQlpbnQgZGVsdGEgPSBuZXdBZ2UgLSBvbGRBZ2U7Ci0JCi0JCQlDYWxlbmRhciBuZXdCaXJ0aENhbCA9IENhbGVuZGFyLmdldEluc3RhbmNlKCk7Ci0JCQluZXdCaXJ0aENhbC5zZXRUaW1lSW5NaWxsaXModGhpcy5iaXJ0aENhbC5nZXRUaW1lKCkuZ2V0VGltZSgpKTsKLQkJCS8vIGlmIHRoZSBhZ2UgaW5jcmVhc2VkLCB0aGUgYmlydGggZGF0ZSBtdXN0IGJlICJkZWNyZWFzZWQiOyBhbmQgdmljZSB2ZXJzYQotCQkJbmV3QmlydGhDYWwuc2V0KENhbGVuZGFyLllFQVIsIG5ld0JpcnRoQ2FsLmdldChDYWxlbmRhci5ZRUFSKSAtIGRlbHRhKTsKLQkJCXRoaXMuc2V0QmlydGhEYXRlKG5ld0JpcnRoQ2FsLmdldFRpbWUoKSk7Ci0JCX0KLQkJcHVibGljIFN0cmluZyBnZXRFeWVDb2xvcigpIHsKLQkJCXJldHVybiB0aGlzLmV5ZUNvbG9yOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldEV5ZUNvbG9yKFN0cmluZyBleWVDb2xvcikgewotCQkJaWYgKCAhIENvbGxlY3Rpb25Ub29scy5jb250YWlucyhWQUxJRF9FWUVfQ09MT1JTLCBleWVDb2xvcikpIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKGV5ZUNvbG9yKTsKLQkJCX0KLQkJCU9iamVjdCBvbGQgPSB0aGlzLmV5ZUNvbG9yOwotCQkJdGhpcy5leWVDb2xvciA9IGV5ZUNvbG9yOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKEVZRV9DT0xPUl9QUk9QRVJUWSwgb2xkLCBleWVDb2xvcik7Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gIlRlc3RNb2RlbChiaXJ0aDogIiArIHRoaXMuZ2V0QmlydGhEYXRlKCkgKyAiIC0gZXllczogIiArIHRoaXMuZXllQ29sb3IgKyAiKSI7Ci0JCX0KLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvVGFibGVNb2RlbEFkYXB0ZXJUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9UYWJsZU1vZGVsQWRhcHRlclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGMwODQ2N2QuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9UYWJsZU1vZGVsQWRhcHRlclRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw2NDMgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZzsKLQotaW1wb3J0IGphdmEudGV4dC5EYXRlRm9ybWF0OwotaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7Ci1pbXBvcnQgamF2YS51dGlsLkNhbGVuZGFyOwotaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOwotaW1wb3J0IGphdmEudXRpbC5EYXRlOwotaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKLWltcG9ydCBqYXZhLnV0aWwuTGlzdDsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5UYWJsZU1vZGVsRXZlbnQ7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuVGFibGVNb2RlbExpc3RlbmVyOwotaW1wb3J0IGp1bml0LmZyYW1ld29yay5UZXN0Q2FzZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuU3RyaW5nVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLkNsb25lSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuaXRlcmF0b3JzLlRyYW5zZm9ybWF0aW9uSXRlcmF0b3I7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwuQWJzdHJhY3RNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Db2xsZWN0aW9uQXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Qcm9wZXJ0eUFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLkNvbHVtbkFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuVGFibGVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuTGlzdENoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLmxpc3RlbmVyLlByb3BlcnR5Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuQ29sbGVjdGlvblZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi0vKioKLSAqIAotICovCi1wdWJsaWMgY2xhc3MgVGFibGVNb2RlbEFkYXB0ZXJUZXN0cyBleHRlbmRzIFRlc3RDYXNlIHsKLQlwcml2YXRlIENyb3dkIGNyb3dkOwotCVRhYmxlTW9kZWxFdmVudCBldmVudDsKLQotCXB1YmxpYyBUYWJsZU1vZGVsQWRhcHRlclRlc3RzKFN0cmluZyBuYW1lKSB7Ci0JCXN1cGVyKG5hbWUpOwotCX0KLQotCUBPdmVycmlkZQotCXByb3RlY3RlZCB2b2lkIHNldFVwKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXN1cGVyLnNldFVwKCk7Ci0JCXRoaXMuY3Jvd2QgPSB0aGlzLmJ1aWxkQ3Jvd2QoKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEdldFJvd0NvdW50KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRhYmxlTW9kZWxBZGFwdGVyPFBlcnNvbj4gdGFibGVNb2RlbEFkYXB0ZXIgPSAgdGhpcy5idWlsZFRhYmxlTW9kZWxBZGFwdGVyKCk7Ci0JCWFzc2VydEVxdWFscygwLCB0YWJsZU1vZGVsQWRhcHRlci5nZXRSb3dDb3VudCgpKTsKLQkJLy8gd2UgbmVlZCB0byBhZGQgYSBsaXN0ZW5lciB0byB3YWtlIHVwIHRoZSBhZGFwdGVyCi0JCXRhYmxlTW9kZWxBZGFwdGVyLmFkZFRhYmxlTW9kZWxMaXN0ZW5lcih0aGlzLmJ1aWxkVGFibGVNb2RlbExpc3RlbmVyKCkpOwotCQlhc3NlcnRFcXVhbHModGhpcy5jcm93ZC5wZW9wbGVTaXplKCksIHRhYmxlTW9kZWxBZGFwdGVyLmdldFJvd0NvdW50KCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRDb2x1bW5Db3VudCgpIHRocm93cyBFeGNlcHRpb24gewotCQlUYWJsZU1vZGVsQWRhcHRlcjxQZXJzb24+IHRhYmxlTW9kZWxBZGFwdGVyID0gIHRoaXMuYnVpbGRUYWJsZU1vZGVsQWRhcHRlcigpOwotCQlhc3NlcnRFcXVhbHMoUGVyc29uQ29sdW1uQWRhcHRlci5DT0xVTU5fQ09VTlQsIHRhYmxlTW9kZWxBZGFwdGVyLmdldENvbHVtbkNvdW50KCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRWYWx1ZUF0KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRhYmxlTW9kZWxBZGFwdGVyPFBlcnNvbj4gdGFibGVNb2RlbEFkYXB0ZXIgPSAgdGhpcy5idWlsZFRhYmxlTW9kZWxBZGFwdGVyKCk7Ci0JCXRhYmxlTW9kZWxBZGFwdGVyLmFkZFRhYmxlTW9kZWxMaXN0ZW5lcih0aGlzLmJ1aWxkVGFibGVNb2RlbExpc3RlbmVyKCkpOwotCi0JCUxpc3Q8U3RyaW5nPiBzb3J0ZWROYW1lcyA9IHRoaXMuc29ydGVkTmFtZXMoKTsKLQkJZm9yIChpbnQgaSA9IDA7IGkgPCB0aGlzLmNyb3dkLnBlb3BsZVNpemUoKTsgaSsrKSB7Ci0JCQlhc3NlcnRFcXVhbHMoc29ydGVkTmFtZXMuZ2V0KGkpLCB0YWJsZU1vZGVsQWRhcHRlci5nZXRWYWx1ZUF0KGksIFBlcnNvbkNvbHVtbkFkYXB0ZXIuTkFNRV9DT0xVTU4pKTsKLQkJfQotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTZXRWYWx1ZUF0KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRhYmxlTW9kZWxBZGFwdGVyPFBlcnNvbj4gdGFibGVNb2RlbEFkYXB0ZXIgPSAgdGhpcy5idWlsZFRhYmxlTW9kZWxBZGFwdGVyKCk7Ci0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0YWJsZU1vZGVsQWRhcHRlci5hZGRUYWJsZU1vZGVsTGlzdGVuZXIobmV3IFRlc3RUYWJsZU1vZGVsTGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHRhYmxlQ2hhbmdlZChUYWJsZU1vZGVsRXZlbnQgZSkgewotCQkJCVRhYmxlTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudCA9IGU7Ci0JCQl9Ci0JCX0pOwotCi0JCVBlcnNvbiBwZXJzb24gPSB0aGlzLmNyb3dkLnBlcnNvbk5hbWVkKCJHb2xsdW0iKTsKLQkJYXNzZXJ0RXF1YWxzKFBlcnNvbi5FWUVfQ09MT1JfQkxVRSwgcGVyc29uLmdldEV5ZUNvbG9yKCkpOwotCQlhc3NlcnRGYWxzZShwZXJzb24uaXNFdmlsKCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgcGVyc29uLmdldFJhbmsoKSk7Ci0KLQkJZm9yIChpbnQgaSA9IDA7IGkgPCB0YWJsZU1vZGVsQWRhcHRlci5nZXRSb3dDb3VudCgpOyBpKyspIHsKLQkJCWlmICh0YWJsZU1vZGVsQWRhcHRlci5nZXRWYWx1ZUF0KGksIFBlcnNvbkNvbHVtbkFkYXB0ZXIuTkFNRV9DT0xVTU4pLmVxdWFscygiR29sbHVtIikpIHsKLQkJCQl0YWJsZU1vZGVsQWRhcHRlci5zZXRWYWx1ZUF0KFBlcnNvbi5FWUVfQ09MT1JfSEFaRUwsIGksIFBlcnNvbkNvbHVtbkFkYXB0ZXIuRVlFX0NPTE9SX0NPTFVNTik7Ci0JCQkJdGFibGVNb2RlbEFkYXB0ZXIuc2V0VmFsdWVBdChCb29sZWFuLlRSVUUsIGksIFBlcnNvbkNvbHVtbkFkYXB0ZXIuRVZJTF9DT0xVTU4pOwotCQkJCXRhYmxlTW9kZWxBZGFwdGVyLnNldFZhbHVlQXQobmV3IEludGVnZXIoLTEpLCBpLCBQZXJzb25Db2x1bW5BZGFwdGVyLlJBTktfQ09MVU1OKTsKLQkJCQlicmVhazsKLQkJCX0KLQkJfQotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQpOwotCQlhc3NlcnRFcXVhbHMoUGVyc29uLkVZRV9DT0xPUl9IQVpFTCwgcGVyc29uLmdldEV5ZUNvbG9yKCkpOwotCQlhc3NlcnRUcnVlKHBlcnNvbi5pc0V2aWwoKSk7Ci0JCWFzc2VydEVxdWFscygtMSwgcGVyc29uLmdldFJhbmsoKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdEFkZFJvdygpIHRocm93cyBFeGNlcHRpb24gewotCQlUYWJsZU1vZGVsQWRhcHRlcjxQZXJzb24+IHRhYmxlTW9kZWxBZGFwdGVyID0gIHRoaXMuYnVpbGRUYWJsZU1vZGVsQWRhcHRlcigpOwotCQl0aGlzLmV2ZW50ID0gbnVsbDsKLQkJdGFibGVNb2RlbEFkYXB0ZXIuYWRkVGFibGVNb2RlbExpc3RlbmVyKHRoaXMuYnVpbGRTaW5nbGVFdmVudExpc3RlbmVyKCkpOwotCQkvLyBhZGQgYSBwZXJzb24gdG8gdGhlIGVuZCBvZiB0aGUgbGlzdCBzbyB3ZSBvbmx5IHRyaWdnZXIgb25lIGV2ZW50Ci0JCXRoaXMuY3Jvd2QuYWRkUGVyc29uKCJaenp6eiIpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMuZXZlbnQpOwotCQlhc3NlcnRFcXVhbHMoVGFibGVNb2RlbEV2ZW50LklOU0VSVCwgdGhpcy5ldmVudC5nZXRUeXBlKCkpOwotCQlhc3NlcnRFcXVhbHMoVGFibGVNb2RlbEV2ZW50LkFMTF9DT0xVTU5TLCB0aGlzLmV2ZW50LmdldENvbHVtbigpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0UmVtb3ZlUm93KCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRhYmxlTW9kZWxBZGFwdGVyPFBlcnNvbj4gdGFibGVNb2RlbEFkYXB0ZXIgPSAgdGhpcy5idWlsZFRhYmxlTW9kZWxBZGFwdGVyKCk7Ci0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0YWJsZU1vZGVsQWRhcHRlci5hZGRUYWJsZU1vZGVsTGlzdGVuZXIodGhpcy5idWlsZFNpbmdsZUV2ZW50TGlzdGVuZXIoKSk7Ci0JCS8vIHJlbW92aW5nIGEgcGVyc29uIHNob3VsZCBvbmx5IHRyaWdnZXIgb25lIGV2ZW50LCBzaW5jZSBhIHJlLXNvcnQgaXMgbm90IG5lZWRlZAotCQl0aGlzLmNyb3dkLnJlbW92ZVBlcnNvbih0aGlzLmNyb3dkLnBlcnNvbk5hbWVkKCJHb2xsdW0iKSk7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5ldmVudCk7Ci0JCWFzc2VydEVxdWFscyhUYWJsZU1vZGVsRXZlbnQuREVMRVRFLCB0aGlzLmV2ZW50LmdldFR5cGUoKSk7Ci0JCWFzc2VydEVxdWFscyhUYWJsZU1vZGVsRXZlbnQuQUxMX0NPTFVNTlMsIHRoaXMuZXZlbnQuZ2V0Q29sdW1uKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RDaGFuZ2VDZWxsKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRhYmxlTW9kZWxBZGFwdGVyPFBlcnNvbj4gdGFibGVNb2RlbEFkYXB0ZXIgPSAgdGhpcy5idWlsZFRhYmxlTW9kZWxBZGFwdGVyKCk7Ci0JCXRoaXMuZXZlbnQgPSBudWxsOwotCQl0YWJsZU1vZGVsQWRhcHRlci5hZGRUYWJsZU1vZGVsTGlzdGVuZXIodGhpcy5idWlsZFNpbmdsZUV2ZW50TGlzdGVuZXIoKSk7Ci0JCS8vIGFkZCBhIHBlcnNvbiB0byB0aGUgZW5kIG9mIHRoZSBsaXN0IHNvIHdlIG9ubHkgdHJpZ2dlciBvbmUgZXZlbnQKLQkJUGVyc29uIHBlcnNvbiA9IHRoaXMuY3Jvd2QucGVyc29uTmFtZWQoIkdvbGx1bSIpOwotCQlwZXJzb24uc2V0RXZpbCh0cnVlKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLmV2ZW50KTsKLQkJYXNzZXJ0RXF1YWxzKFRhYmxlTW9kZWxFdmVudC5VUERBVEUsIHRoaXMuZXZlbnQuZ2V0VHlwZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKFBlcnNvbkNvbHVtbkFkYXB0ZXIuRVZJTF9DT0xVTU4sIHRoaXMuZXZlbnQuZ2V0Q29sdW1uKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RMYXp5TGlzdExpc3RlbmVyKCkgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCVRhYmxlTW9kZWxBZGFwdGVyPFBlcnNvbj4gdGFibGVNb2RlbEFkYXB0ZXIgPSAgdGhpcy5idWlsZFRhYmxlTW9kZWxBZGFwdGVyKCk7Ci0JCVRhYmxlTW9kZWxMaXN0ZW5lciBsaXN0ZW5lciA9IHRoaXMuYnVpbGRUYWJsZU1vZGVsTGlzdGVuZXIoKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmNyb3dkLmhhc05vQ29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDcm93ZC5QRU9QTEVfQ09MTEVDVElPTikpOwotCQl0YWJsZU1vZGVsQWRhcHRlci5hZGRUYWJsZU1vZGVsTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKHRoaXMuY3Jvd2QuaGFzQW55Q29sbGVjdGlvbkNoYW5nZUxpc3RlbmVycyhDcm93ZC5QRU9QTEVfQ09MTEVDVElPTikpOwotCQl0YWJsZU1vZGVsQWRhcHRlci5yZW1vdmVUYWJsZU1vZGVsTGlzdGVuZXIobGlzdGVuZXIpOwotCQlhc3NlcnRUcnVlKHRoaXMuY3Jvd2QuaGFzTm9Db2xsZWN0aW9uQ2hhbmdlTGlzdGVuZXJzKENyb3dkLlBFT1BMRV9DT0xMRUNUSU9OKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdExhenlDZWxsTGlzdGVuZXIoKSB0aHJvd3MgRXhjZXB0aW9uIHsKLQkJVGFibGVNb2RlbEFkYXB0ZXI8UGVyc29uPiB0YWJsZU1vZGVsQWRhcHRlciA9ICB0aGlzLmJ1aWxkVGFibGVNb2RlbEFkYXB0ZXIoKTsKLQkJVGFibGVNb2RlbExpc3RlbmVyIGxpc3RlbmVyID0gdGhpcy5idWlsZFRhYmxlTW9kZWxMaXN0ZW5lcigpOwotCQlQZXJzb24gcGVyc29uID0gdGhpcy5jcm93ZC5wZXJzb25OYW1lZCgiR29sbHVtIik7Ci0JCWFzc2VydFRydWUocGVyc29uLmhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUGVyc29uLk5BTUVfUFJPUEVSVFkpKTsKLQkJYXNzZXJ0VHJ1ZShwZXJzb24uaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQZXJzb24uQklSVEhfREFURV9QUk9QRVJUWSkpOwotCQlhc3NlcnRUcnVlKHBlcnNvbi5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFBlcnNvbi5FWUVfQ09MT1JfUFJPUEVSVFkpKTsKLQkJYXNzZXJ0VHJ1ZShwZXJzb24uaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQZXJzb24uRVZJTF9QUk9QRVJUWSkpOwotCQlhc3NlcnRUcnVlKHBlcnNvbi5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFBlcnNvbi5SQU5LX1BST1BFUlRZKSk7Ci0KLQkJdGFibGVNb2RlbEFkYXB0ZXIuYWRkVGFibGVNb2RlbExpc3RlbmVyKGxpc3RlbmVyKTsKLQkJYXNzZXJ0VHJ1ZShwZXJzb24uaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUGVyc29uLk5BTUVfUFJPUEVSVFkpKTsKLQkJYXNzZXJ0VHJ1ZShwZXJzb24uaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUGVyc29uLkJJUlRIX0RBVEVfUFJPUEVSVFkpKTsKLQkJYXNzZXJ0VHJ1ZShwZXJzb24uaGFzQW55UHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUGVyc29uLkVZRV9DT0xPUl9QUk9QRVJUWSkpOwotCQlhc3NlcnRUcnVlKHBlcnNvbi5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQZXJzb24uRVZJTF9QUk9QRVJUWSkpOwotCQlhc3NlcnRUcnVlKHBlcnNvbi5oYXNBbnlQcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQZXJzb24uUkFOS19QUk9QRVJUWSkpOwotCi0JCXRhYmxlTW9kZWxBZGFwdGVyLnJlbW92ZVRhYmxlTW9kZWxMaXN0ZW5lcihsaXN0ZW5lcik7Ci0JCWFzc2VydFRydWUocGVyc29uLmhhc05vUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcnMoUGVyc29uLk5BTUVfUFJPUEVSVFkpKTsKLQkJYXNzZXJ0VHJ1ZShwZXJzb24uaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQZXJzb24uQklSVEhfREFURV9QUk9QRVJUWSkpOwotCQlhc3NlcnRUcnVlKHBlcnNvbi5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFBlcnNvbi5FWUVfQ09MT1JfUFJPUEVSVFkpKTsKLQkJYXNzZXJ0VHJ1ZShwZXJzb24uaGFzTm9Qcm9wZXJ0eUNoYW5nZUxpc3RlbmVycyhQZXJzb24uRVZJTF9QUk9QRVJUWSkpOwotCQlhc3NlcnRUcnVlKHBlcnNvbi5oYXNOb1Byb3BlcnR5Q2hhbmdlTGlzdGVuZXJzKFBlcnNvbi5SQU5LX1BST1BFUlRZKSk7Ci0JfQotCi0JcHJpdmF0ZSBUYWJsZU1vZGVsQWRhcHRlcjxQZXJzb24+IGJ1aWxkVGFibGVNb2RlbEFkYXB0ZXIoKSB7Ci0JCXJldHVybiBuZXcgVGFibGVNb2RlbEFkYXB0ZXI8UGVyc29uPih0aGlzLmJ1aWxkU29ydGVkUGVvcGxlQWRhcHRlcigpLCB0aGlzLmJ1aWxkQ29sdW1uQWRhcHRlcigpKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkQ2VsbExpc3RlbmVyKCkgewotCQkJCXJldHVybiB0aGlzLmJ1aWxkQ2VsbExpc3RlbmVyXygpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgTGlzdENoYW5nZUxpc3RlbmVyIGJ1aWxkTGlzdENoYW5nZUxpc3RlbmVyKCkgewotCQkJCXJldHVybiB0aGlzLmJ1aWxkTGlzdENoYW5nZUxpc3RlbmVyXygpOwotCQkJfQotCQl9OwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8UGVyc29uPiBidWlsZFNvcnRlZFBlb3BsZUFkYXB0ZXIoKSB7Ci0JCXJldHVybiBuZXcgU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyPFBlcnNvbj4odGhpcy5idWlsZFBlb3BsZUFkYXB0ZXIoKSk7Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uVmFsdWVNb2RlbDxQZXJzb24+IGJ1aWxkUGVvcGxlQWRhcHRlcigpIHsKLQkJcmV0dXJuIG5ldyBDb2xsZWN0aW9uQXNwZWN0QWRhcHRlcjxDcm93ZCwgUGVyc29uPihDcm93ZC5QRU9QTEVfQ09MTEVDVElPTiwgdGhpcy5jcm93ZCkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSXRlcmF0b3I8UGVyc29uPiBpdGVyYXRvcl8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5wZW9wbGUoKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGludCBzaXplXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LnBlb3BsZVNpemUoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENyb3dkIGJ1aWxkQ3Jvd2QoKSB7Ci0JCUNyb3dkIHJlc3VsdCA9IG5ldyBDcm93ZCgpOwotCQlyZXN1bHQuYWRkUGVyc29uKCJCaWxibyIpOwotCQlyZXN1bHQuYWRkUGVyc29uKCJHb2xsdW0iKTsKLQkJcmVzdWx0LmFkZFBlcnNvbigiRnJvZG8iKTsKLQkJcmVzdWx0LmFkZFBlcnNvbigiU2Ftd2lzZSIpOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCXByaXZhdGUgQ29sdW1uQWRhcHRlciBidWlsZENvbHVtbkFkYXB0ZXIoKSB7Ci0JCXJldHVybiBuZXcgUGVyc29uQ29sdW1uQWRhcHRlcigpOwotCX0KLQotCXByaXZhdGUgVGFibGVNb2RlbExpc3RlbmVyIGJ1aWxkVGFibGVNb2RlbExpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFRlc3RUYWJsZU1vZGVsTGlzdGVuZXIoKTsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8U3RyaW5nPiBzb3J0ZWROYW1lcygpIHsKLQkJcmV0dXJuIG5ldyBBcnJheUxpc3Q8U3RyaW5nPihDb2xsZWN0aW9uVG9vbHMuc29ydGVkU2V0KHRoaXMuY3Jvd2QucGVvcGxlTmFtZXMoKSkpOwotCX0KLQotCXByaXZhdGUgVGFibGVNb2RlbExpc3RlbmVyIGJ1aWxkU2luZ2xlRXZlbnRMaXN0ZW5lcigpIHsKLQkJcmV0dXJuIG5ldyBUZXN0VGFibGVNb2RlbExpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCB0YWJsZUNoYW5nZWQoVGFibGVNb2RlbEV2ZW50IGUpIHsKLQkJCQkvLyB3ZSBleHBlY3Qgb25seSBhIHNpbmdsZSBldmVudAotCQkJCWlmIChUYWJsZU1vZGVsQWRhcHRlclRlc3RzLnRoaXMuZXZlbnQgPT0gbnVsbCkgewotCQkJCQlUYWJsZU1vZGVsQWRhcHRlclRlc3RzLnRoaXMuZXZlbnQgPSBlOwotCQkJCX0gZWxzZSB7Ci0JCQkJCWZhaWwoInVuZXhwZWN0ZWQgZXZlbnQiKTsKLQkJCQl9Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGNsYXNzZXMgKioqKioqKioqKgotCi0JcHVibGljIHN0YXRpYyBjbGFzcyBQZXJzb25Db2x1bW5BZGFwdGVyIGltcGxlbWVudHMgQ29sdW1uQWRhcHRlciB7Ci0JCXB1YmxpYyBzdGF0aWMgZmluYWwgaW50IENPTFVNTl9DT1VOVCA9IDc7Ci0JCi0JCXB1YmxpYyBzdGF0aWMgZmluYWwgaW50IE5BTUVfQ09MVU1OID0gMDsKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBpbnQgQklSVEhfREFURV9DT0xVTU4gPSAxOwotCQlwdWJsaWMgc3RhdGljIGZpbmFsIGludCBHT05FX1dFU1RfREFURV9DT0xVTU4gPSAyOwotCQlwdWJsaWMgc3RhdGljIGZpbmFsIGludCBFWUVfQ09MT1JfQ09MVU1OID0gMzsKLQkJcHVibGljIHN0YXRpYyBmaW5hbCBpbnQgRVZJTF9DT0xVTU4gPSA0OwotCQlwdWJsaWMgc3RhdGljIGZpbmFsIGludCBSQU5LX0NPTFVNTiA9IDU7Ci0JCXB1YmxpYyBzdGF0aWMgZmluYWwgaW50IEFEVkVOVFVSRV9DT1VOVF9DT0xVTU4gPSA2OwotCQotCQlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmdbXSBDT0xVTU5fTkFNRVMgPSBuZXcgU3RyaW5nW10gewotCQkJIk5hbWUiLAotCQkJIkJpcnRoIiwKLQkJCSJHb25lIFdlc3QiLAotCQkJIkV5ZXMiLAotCQkJIkV2aWwiLAotCQkJIlJhbmsiLAotCQkJIkFkdmVudHVyZXMiCi0JCX07Ci0JCi0JCi0JCXB1YmxpYyBpbnQgY29sdW1uQ291bnQoKSB7Ci0JCQlyZXR1cm4gQ09MVU1OX0NPVU5UOwotCQl9Ci0JCi0JCXB1YmxpYyBTdHJpbmcgY29sdW1uTmFtZShpbnQgaW5kZXgpIHsKLQkJCXJldHVybiBDT0xVTU5fTkFNRVNbaW5kZXhdOwotCQl9Ci0JCi0JCXB1YmxpYyBDbGFzczw/PiBjb2x1bW5DbGFzcyhpbnQgaW5kZXgpIHsKLQkJCXN3aXRjaCAoaW5kZXgpIHsKLQkJCQljYXNlIE5BTUVfQ09MVU1OOgkJCQkJcmV0dXJuIE9iamVjdC5jbGFzczsKLQkJCQljYXNlIEJJUlRIX0RBVEVfQ09MVU1OOgkJCXJldHVybiBEYXRlLmNsYXNzOwotCQkJCWNhc2UgR09ORV9XRVNUX0RBVEVfQ09MVU1OOglyZXR1cm4gRGF0ZS5jbGFzczsKLQkJCQljYXNlIEVZRV9DT0xPUl9DT0xVTU46CQkJcmV0dXJuIE9iamVjdC5jbGFzczsKLQkJCQljYXNlIEVWSUxfQ09MVU1OOgkJCQkJcmV0dXJuIEJvb2xlYW4uY2xhc3M7Ci0JCQkJY2FzZSBSQU5LX0NPTFVNTjoJCQkJCXJldHVybiBJbnRlZ2VyLmNsYXNzOwotCQkJCWNhc2UgQURWRU5UVVJFX0NPVU5UX0NPTFVNTjpyZXR1cm4gSW50ZWdlci5jbGFzczsKLQkJCQlkZWZhdWx0OiAJCQkJCQkJCQlyZXR1cm4gT2JqZWN0LmNsYXNzOwotCQkJfQotCQl9Ci0JCi0JCXB1YmxpYyBib29sZWFuIGNvbHVtbklzRWRpdGFibGUoaW50IGluZGV4KSB7Ci0JCQlyZXR1cm4gaW5kZXggIT0gTkFNRV9DT0xVTU47Ci0JCX0KLQkKLQkJcHVibGljIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD5bXSBjZWxsTW9kZWxzKE9iamVjdCBzdWJqZWN0KSB7Ci0JCQlQZXJzb24gcGVyc29uID0gKFBlcnNvbikgc3ViamVjdDsKLQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotCQkJV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PltdIHJlc3VsdCA9IG5ldyBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbFtDT0xVTU5fQ09VTlRdOwotCQotCQkJcmVzdWx0W05BTUVfQ09MVU1OXSA9IHRoaXMuYnVpbGROYW1lQWRhcHRlcihwZXJzb24pOwotCQkJcmVzdWx0W0JJUlRIX0RBVEVfQ09MVU1OXSA9IHRoaXMuYnVpbGRCaXJ0aERhdGVBZGFwdGVyKHBlcnNvbik7Ci0JCQlyZXN1bHRbR09ORV9XRVNUX0RBVEVfQ09MVU1OXSA9IHRoaXMuYnVpbGRHb25lV2VzdERhdGVBZGFwdGVyKHBlcnNvbik7Ci0JCQlyZXN1bHRbRVlFX0NPTE9SX0NPTFVNTl0gPSB0aGlzLmJ1aWxkRXllQ29sb3JBZGFwdGVyKHBlcnNvbik7Ci0JCQlyZXN1bHRbRVZJTF9DT0xVTU5dID0gdGhpcy5idWlsZEV2aWxBZGFwdGVyKHBlcnNvbik7Ci0JCQlyZXN1bHRbUkFOS19DT0xVTU5dID0gdGhpcy5idWlsZFJhbmtBZGFwdGVyKHBlcnNvbik7Ci0JCQlyZXN1bHRbQURWRU5UVVJFX0NPVU5UX0NPTFVNTl0gPSB0aGlzLmJ1aWxkQWR2ZW50dXJlQ291bnRBZGFwdGVyKHBlcnNvbik7Ci0JCi0JCQlyZXR1cm4gcmVzdWx0OwotCQl9Ci0JCi0JCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBidWlsZE5hbWVBZGFwdGVyKFBlcnNvbiBwZXJzb24pIHsKLQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFBlcnNvbiwgT2JqZWN0PihQZXJzb24uTkFNRV9QUk9QRVJUWSwgcGVyc29uKSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXROYW1lKCk7Ci0JCQkJfQotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhPYmplY3QgdmFsdWUpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LnNldE5hbWUoKFN0cmluZykgdmFsdWUpOwotCQkJCX0KLQkJCX07Ci0JCX0KLQkKLQkJcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IGJ1aWxkQmlydGhEYXRlQWRhcHRlcihQZXJzb24gcGVyc29uKSB7Ci0JCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxQZXJzb24sIE9iamVjdD4oUGVyc29uLkJJUlRIX0RBVEVfUFJPUEVSVFksIHBlcnNvbikgewotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCBEYXRlIGJ1aWxkVmFsdWVfKCkgewotCQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldEJpcnRoRGF0ZSgpOwotCQkJCX0KLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oT2JqZWN0IHZhbHVlKSB7Ci0JCQkJCXRoaXMuc3ViamVjdC5zZXRCaXJ0aERhdGUoKERhdGUpIHZhbHVlKTsKLQkJCQl9Ci0JCQl9OwotCQl9Ci0JCi0JCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBidWlsZEdvbmVXZXN0RGF0ZUFkYXB0ZXIoUGVyc29uIHBlcnNvbikgewotCQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8UGVyc29uLCBPYmplY3Q+KFBlcnNvbi5HT05FX1dFU1RfREFURV9QUk9QRVJUWSwgcGVyc29uKSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIERhdGUgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0R29uZVdlc3REYXRlKCk7Ci0JCQkJfQotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhPYmplY3QgdmFsdWUpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LnNldEdvbmVXZXN0RGF0ZSgoRGF0ZSkgdmFsdWUpOwotCQkJCX0KLQkJCX07Ci0JCX0KLQkKLQkJcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IGJ1aWxkRXllQ29sb3JBZGFwdGVyKFBlcnNvbiBwZXJzb24pIHsKLQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFBlcnNvbiwgT2JqZWN0PihQZXJzb24uRVlFX0NPTE9SX1BST1BFUlRZLCBwZXJzb24pIHsKLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgU3RyaW5nIGJ1aWxkVmFsdWVfKCkgewotCQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldEV5ZUNvbG9yKCk7Ci0JCQkJfQotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhPYmplY3QgdmFsdWUpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LnNldEV5ZUNvbG9yKChTdHJpbmcpIHZhbHVlKTsKLQkJCQl9Ci0JCQl9OwotCQl9Ci0JCi0JCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBidWlsZEV2aWxBZGFwdGVyKFBlcnNvbiBwZXJzb24pIHsKLQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFBlcnNvbiwgT2JqZWN0PihQZXJzb24uRVZJTF9QUk9QRVJUWSwgcGVyc29uKSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIEJvb2xlYW4gYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCXJldHVybiBCb29sZWFuLnZhbHVlT2YodGhpcy5zdWJqZWN0LmlzRXZpbCgpKTsKLQkJCQl9Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKE9iamVjdCB2YWx1ZSkgewotCQkJCQl0aGlzLnN1YmplY3Quc2V0RXZpbCgoKEJvb2xlYW4pdmFsdWUpLmJvb2xlYW5WYWx1ZSgpKTsKLQkJCQl9Ci0JCQl9OwotCQl9Ci0JCi0JCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBidWlsZFJhbmtBZGFwdGVyKFBlcnNvbiBwZXJzb24pIHsKLQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFBlcnNvbiwgT2JqZWN0PihQZXJzb24uUkFOS19QUk9QRVJUWSwgcGVyc29uKSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIEludGVnZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCXJldHVybiBuZXcgSW50ZWdlcih0aGlzLnN1YmplY3QuZ2V0UmFuaygpKTsKLQkJCQl9Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKE9iamVjdCB2YWx1ZSkgewotCQkJCQl0aGlzLnN1YmplY3Quc2V0UmFuaygoKEludGVnZXIpIHZhbHVlKS5pbnRWYWx1ZSgpKTsKLQkJCQl9Ci0JCQl9OwotCQl9Ci0JCi0JCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PiBidWlsZEFkdmVudHVyZUNvdW50QWRhcHRlcihQZXJzb24gcGVyc29uKSB7Ci0JCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxQZXJzb24sIE9iamVjdD4oUGVyc29uLkFEVkVOVFVSRV9DT1VOVF9QUk9QRVJUWSwgcGVyc29uKSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIEludGVnZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCXJldHVybiBuZXcgSW50ZWdlcih0aGlzLnN1YmplY3QuZ2V0QWR2ZW50dXJlQ291bnQoKSk7Ci0JCQkJfQotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhPYmplY3QgdmFsdWUpIHsKLQkJCQkJdGhpcy5zdWJqZWN0LnNldEFkdmVudHVyZUNvdW50KCgoSW50ZWdlcikgdmFsdWUpLmludFZhbHVlKCkpOwotCQkJCX0KLQkJCX07Ci0JCX0KLQkKLQl9Ci0KLQotCXB1YmxpYyBzdGF0aWMgY2xhc3MgQ3Jvd2QgZXh0ZW5kcyBBYnN0cmFjdE1vZGVsIHsKLQkJcHJpdmF0ZSBmaW5hbCBDb2xsZWN0aW9uPFBlcnNvbj4gcGVvcGxlOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgUEVPUExFX0NPTExFQ1RJT04gPSAicGVvcGxlIjsKLQkKLQkJcHVibGljIENyb3dkKCkgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMucGVvcGxlID0gbmV3IEFycmF5TGlzdDxQZXJzb24+KCk7Ci0JCX0KLQkKLQkKLQkJcHVibGljIEl0ZXJhdG9yPFBlcnNvbj4gcGVvcGxlKCkgewotCQkJcmV0dXJuIG5ldyBDbG9uZUl0ZXJhdG9yPFBlcnNvbj4odGhpcy5wZW9wbGUpIHsKLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgdm9pZCByZW1vdmUoUGVyc29uIHBlcnNvbikgewotCQkJCQlDcm93ZC50aGlzLnJlbW92ZVBlcnNvbihwZXJzb24pOwotCQkJCX0KLQkJCX07Ci0JCX0KLQkKLQkJcHVibGljIGludCBwZW9wbGVTaXplKCkgewotCQkJcmV0dXJuIHRoaXMucGVvcGxlLnNpemUoKTsKLQkJfQotCQotCQlwdWJsaWMgUGVyc29uIGFkZFBlcnNvbihTdHJpbmcgbmFtZSkgewotCQkJdGhpcy5jaGVja1BlcnNvbk5hbWUobmFtZSk7Ci0JCQlyZXR1cm4gdGhpcy5hZGRQZXJzb24obmV3IFBlcnNvbih0aGlzLCBuYW1lKSk7Ci0JCX0KLQkKLQkJcHJpdmF0ZSBQZXJzb24gYWRkUGVyc29uKFBlcnNvbiBwZXJzb24pIHsKLQkJCXRoaXMuYWRkSXRlbVRvQ29sbGVjdGlvbihwZXJzb24sIHRoaXMucGVvcGxlLCBQRU9QTEVfQ09MTEVDVElPTik7Ci0JCQlyZXR1cm4gcGVyc29uOwotCQl9Ci0JCi0JCXB1YmxpYyB2b2lkIHJlbW92ZVBlcnNvbihQZXJzb24gcGVyc29uKSB7Ci0JCQl0aGlzLnJlbW92ZUl0ZW1Gcm9tQ29sbGVjdGlvbihwZXJzb24sIHRoaXMucGVvcGxlLCBQRU9QTEVfQ09MTEVDVElPTik7Ci0JCX0KLQkKLQkJcHVibGljIHZvaWQgcmVtb3ZlUGVvcGxlKENvbGxlY3Rpb248UGVyc29uPiBwZXJzb25zKSB7Ci0JCQl0aGlzLnJlbW92ZUl0ZW1zRnJvbUNvbGxlY3Rpb24ocGVyc29ucywgdGhpcy5wZW9wbGUsIFBFT1BMRV9DT0xMRUNUSU9OKTsKLQkJfQotCQotCQlwdWJsaWMgdm9pZCByZW1vdmVQZW9wbGUoSXRlcmF0b3I8UGVyc29uPiBwZXJzb25zKSB7Ci0JCQl0aGlzLnJlbW92ZUl0ZW1zRnJvbUNvbGxlY3Rpb24ocGVyc29ucywgdGhpcy5wZW9wbGUsIFBFT1BMRV9DT0xMRUNUSU9OKTsKLQkJfQotCQotCQl2b2lkIGNoZWNrUGVyc29uTmFtZShTdHJpbmcgcGVyc29uTmFtZSkgewotCQkJaWYgKHBlcnNvbk5hbWUgPT0gbnVsbCkgewotCQkJCXRocm93IG5ldyBOdWxsUG9pbnRlckV4Y2VwdGlvbigpOwotCQkJfQotCQkJaWYgKENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLnBlb3BsZU5hbWVzKCksIHBlcnNvbk5hbWUpKSB7Ci0JCQkJdGhyb3cgbmV3IElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbihwZXJzb25OYW1lKTsKLQkJCX0KLQkJfQotCQotCQlwdWJsaWMgSXRlcmF0b3I8U3RyaW5nPiBwZW9wbGVOYW1lcygpIHsKLQkJCXJldHVybiBuZXcgVHJhbnNmb3JtYXRpb25JdGVyYXRvcjxQZXJzb24sIFN0cmluZz4odGhpcy5wZW9wbGUuaXRlcmF0b3IoKSkgewotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCBTdHJpbmcgdHJhbnNmb3JtKFBlcnNvbiBwZXJzb24pIHsKLQkJCQkJcmV0dXJuIHBlcnNvbi5nZXROYW1lKCk7Ci0JCQkJfQotCQkJfTsKLQkJfQotCQotCQlwdWJsaWMgUGVyc29uIHBlcnNvbk5hbWVkKFN0cmluZyBuYW1lKSB7Ci0JCQlmb3IgKEl0ZXJhdG9yPFBlcnNvbj4gc3RyZWFtID0gdGhpcy5wZW9wbGUuaXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQkJUGVyc29uIHBlcnNvbiA9IHN0cmVhbS5uZXh0KCk7Ci0JCQkJaWYgKHBlcnNvbi5nZXROYW1lKCkuZXF1YWxzKG5hbWUpKSB7Ci0JCQkJCXJldHVybiBwZXJzb247Ci0JCQkJfQotCQkJfQotCQkJcmV0dXJuIG51bGw7Ci0JCX0KLQkKLQkJQE92ZXJyaWRlCi0JCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7Ci0JCQlyZXR1cm4gU3RyaW5nVG9vbHMuYnVpbGRUb1N0cmluZ0Zvcih0aGlzLCBTdHJpbmcudmFsdWVPZih0aGlzLnBlb3BsZS5zaXplKCkpICsgIiBwZW9wbGUiKTsKLQkJfQotCQotCX0KLQkKLQkKLQlwdWJsaWMgc3RhdGljIGNsYXNzIFBlcnNvbiBleHRlbmRzIEFic3RyYWN0TW9kZWwgaW1wbGVtZW50cyBDb21wYXJhYmxlPFBlcnNvbj4gewotCQlwcml2YXRlIENyb3dkIGNyb3dkOwotCQlwcml2YXRlIFN0cmluZyBuYW1lOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgTkFNRV9QUk9QRVJUWT0gIm5hbWUiOwotCQlwcml2YXRlIERhdGUgYmlydGhEYXRlOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgQklSVEhfREFURV9QUk9QRVJUWT0gImJpcnRoRGF0ZSI7Ci0JCXByaXZhdGUgRGF0ZSBnb25lV2VzdERhdGU7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBHT05FX1dFU1RfREFURV9QUk9QRVJUWT0gImdvbmVXZXN0RGF0ZSI7Ci0JCXByaXZhdGUgU3RyaW5nIGV5ZUNvbG9yOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgRVlFX0NPTE9SX1BST1BFUlRZPSAiZXllQ29sb3IiOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgRVlFX0NPTE9SX0JMVUUgPSAiYmx1ZSI7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBFWUVfQ09MT1JfR1JFRU4gPSAiZ3JlZW4iOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgRVlFX0NPTE9SX0JST1dOID0gImJyb3duIjsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIEVZRV9DT0xPUl9IQVpFTCA9ICJoYXplbCI7Ci0JCQlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBFWUVfQ09MT1JfUElOSyA9ICJwaW5rIjsKLQkJCXByaXZhdGUgc3RhdGljIENvbGxlY3Rpb248U3RyaW5nPiB2YWxpZEV5ZUNvbG9yczsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIERFRkFVTFRfRVlFX0NPTE9SID0gRVlFX0NPTE9SX0JMVUU7Ci0JCXByaXZhdGUgYm9vbGVhbiBldmlsOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgRVZJTF9QUk9QRVJUWT0gImV2aWwiOwotCQlwcml2YXRlIGludCByYW5rOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgUkFOS19QUk9QRVJUWT0gInJhbmsiOwotCQlwcml2YXRlIGludCBhZHZlbnR1cmVDb3VudDsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIEFEVkVOVFVSRV9DT1VOVF9QUk9QRVJUWT0gImFkdmVudHVyZUNvdW50IjsKLQkKLQkJUGVyc29uKENyb3dkIGNyb3dkLCBTdHJpbmcgbmFtZSkgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMuY3Jvd2QgPSBjcm93ZDsKLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCQl0aGlzLmJpcnRoRGF0ZSA9IG5ldyBEYXRlKCk7Ci0JCQlDYWxlbmRhciBjID0gQ2FsZW5kYXIuZ2V0SW5zdGFuY2UoKTsKLQkJCWMuYWRkKENhbGVuZGFyLllFQVIsIDI1MCk7Ci0JCQl0aGlzLmdvbmVXZXN0RGF0ZSA9IG5ldyBEYXRlKGMuZ2V0VGltZUluTWlsbGlzKCkpOwotCQkJdGhpcy5leWVDb2xvciA9IERFRkFVTFRfRVlFX0NPTE9SOwotCQkJdGhpcy5ldmlsID0gZmFsc2U7Ci0JCQl0aGlzLnJhbmsgPSAwOwotCQkJdGhpcy5hZHZlbnR1cmVDb3VudCA9IDA7Ci0JCX0KLQkKLQkJcHVibGljIHN0YXRpYyBDb2xsZWN0aW9uPFN0cmluZz4gZ2V0VmFsaWRFeWVDb2xvcnMoKSB7Ci0JCQlpZiAodmFsaWRFeWVDb2xvcnMgPT0gbnVsbCkgewotCQkJCXZhbGlkRXllQ29sb3JzID0gYnVpbGRWYWxpZEV5ZUNvbG9ycygpOwotCQkJfQotCQkJcmV0dXJuIHZhbGlkRXllQ29sb3JzOwotCQl9Ci0JCi0JCXByaXZhdGUgc3RhdGljIENvbGxlY3Rpb248U3RyaW5nPiBidWlsZFZhbGlkRXllQ29sb3JzKCkgewotCQkJQ29sbGVjdGlvbjxTdHJpbmc+IHJlc3VsdCA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotCQkJcmVzdWx0LmFkZChFWUVfQ09MT1JfQkxVRSk7Ci0JCQlyZXN1bHQuYWRkKEVZRV9DT0xPUl9HUkVFTik7Ci0JCQlyZXN1bHQuYWRkKEVZRV9DT0xPUl9CUk9XTik7Ci0JCQlyZXN1bHQuYWRkKEVZRV9DT0xPUl9IQVpFTCk7Ci0JCQlyZXN1bHQuYWRkKEVZRV9DT0xPUl9QSU5LKTsKLQkJCXJldHVybiByZXN1bHQ7Ci0JCX0KLQkKLQkJcHVibGljIENyb3dkIGdldENyb3dkKCkgewotCQkJcmV0dXJuIHRoaXMuY3Jvd2Q7Ci0JCX0KLQkKLQkJcHVibGljIFN0cmluZyBnZXROYW1lKCkgewotCQkJcmV0dXJuIHRoaXMubmFtZTsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXROYW1lKFN0cmluZyBuYW1lKSB7Ci0JCQl0aGlzLmNyb3dkLmNoZWNrUGVyc29uTmFtZShuYW1lKTsKLQkJCU9iamVjdCBvbGQgPSB0aGlzLm5hbWU7Ci0JCQl0aGlzLm5hbWUgPSBuYW1lOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKE5BTUVfUFJPUEVSVFksIG9sZCwgbmFtZSk7Ci0JCX0KLQkKLQkJcHVibGljIERhdGUgZ2V0QmlydGhEYXRlKCkgewotCQkJcmV0dXJuIHRoaXMuYmlydGhEYXRlOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldEJpcnRoRGF0ZShEYXRlIGJpcnRoRGF0ZSkgewotCQkJT2JqZWN0IG9sZCA9IHRoaXMuYmlydGhEYXRlOwotCQkJdGhpcy5iaXJ0aERhdGUgPSBiaXJ0aERhdGU7Ci0JCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoQklSVEhfREFURV9QUk9QRVJUWSwgb2xkLCBiaXJ0aERhdGUpOwotCQl9Ci0JCi0JCXB1YmxpYyBEYXRlIGdldEdvbmVXZXN0RGF0ZSgpIHsKLQkJCXJldHVybiB0aGlzLmdvbmVXZXN0RGF0ZTsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXRHb25lV2VzdERhdGUoRGF0ZSBnb25lV2VzdERhdGUpIHsKLQkJCU9iamVjdCBvbGQgPSB0aGlzLmdvbmVXZXN0RGF0ZTsKLQkJCXRoaXMuZ29uZVdlc3REYXRlID0gZ29uZVdlc3REYXRlOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKEdPTkVfV0VTVF9EQVRFX1BST1BFUlRZLCBvbGQsIGdvbmVXZXN0RGF0ZSk7Ci0JCX0KLQkKLQkJcHVibGljIFN0cmluZyBnZXRFeWVDb2xvcigpIHsKLQkJCXJldHVybiB0aGlzLmV5ZUNvbG9yOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldEV5ZUNvbG9yKFN0cmluZyBleWVDb2xvcikgewotCQkJaWYgKCEgZ2V0VmFsaWRFeWVDb2xvcnMoKS5jb250YWlucyhleWVDb2xvcikpIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKGV5ZUNvbG9yKTsKLQkJCX0KLQkJCU9iamVjdCBvbGQgPSB0aGlzLmV5ZUNvbG9yOwotCQkJdGhpcy5leWVDb2xvciA9IGV5ZUNvbG9yOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKEVZRV9DT0xPUl9QUk9QRVJUWSwgb2xkLCBleWVDb2xvcik7Ci0JCX0KLQkKLQkJcHVibGljIGJvb2xlYW4gaXNFdmlsKCkgewotCQkJcmV0dXJuIHRoaXMuZXZpbDsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXRFdmlsKGJvb2xlYW4gZXZpbCkgewotCQkJYm9vbGVhbiBvbGQgPSB0aGlzLmV2aWw7Ci0JCQl0aGlzLmV2aWwgPSBldmlsOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKEVWSUxfUFJPUEVSVFksIG9sZCwgZXZpbCk7Ci0JCX0KLQkKLQkJcHVibGljIGludCBnZXRSYW5rKCkgewotCQkJcmV0dXJuIHRoaXMucmFuazsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXRSYW5rKGludCByYW5rKSB7Ci0JCQlpbnQgb2xkID0gdGhpcy5yYW5rOwotCQkJdGhpcy5yYW5rID0gcmFuazsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChSQU5LX1BST1BFUlRZLCBvbGQsIHJhbmspOwotCQl9Ci0JCi0JCXB1YmxpYyBpbnQgZ2V0QWR2ZW50dXJlQ291bnQoKSB7Ci0JCQlyZXR1cm4gdGhpcy5hZHZlbnR1cmVDb3VudDsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXRBZHZlbnR1cmVDb3VudChpbnQgYWR2ZW50dXJlQ291bnQpIHsKLQkJCWludCBvbGQgPSB0aGlzLmFkdmVudHVyZUNvdW50OwotCQkJdGhpcy5hZHZlbnR1cmVDb3VudCA9IGFkdmVudHVyZUNvdW50OwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKEFEVkVOVFVSRV9DT1VOVF9QUk9QRVJUWSwgb2xkLCBhZHZlbnR1cmVDb3VudCk7Ci0JCX0KLQkKLQkJcHVibGljIGludCBjb21wYXJlVG8oUGVyc29uIHApIHsKLQkJCXJldHVybiB0aGlzLm5hbWUuY29tcGFyZVRvSWdub3JlQ2FzZShwLm5hbWUpOwotCQl9Ci0JCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuIHRoaXMubmFtZSArIAotCQkJCQkJIlx0Ym9ybjogIiArIERhdGVGb3JtYXQuZ2V0RGF0ZUluc3RhbmNlKCkuZm9ybWF0KHRoaXMuYmlydGhEYXRlKSArIAotCQkJCQkJIlx0Z29uZSB3ZXN0OiAiICsgRGF0ZUZvcm1hdC5nZXREYXRlSW5zdGFuY2UoKS5mb3JtYXQodGhpcy5nb25lV2VzdERhdGUpICsgCi0JCQkJCQkiXHRleWVzOiAiICsgdGhpcy5leWVDb2xvciArIAotCQkJCQkJIlx0ZXZpbDogIiArIHRoaXMuZXZpbCArIAotCQkJCQkJIlx0cmFuazogIiArIHRoaXMucmFuayArCi0JCQkJCQkiXHRhZHZlbnR1cmVzOiAiICsgdGhpcy5hZHZlbnR1cmVDb3VudAotCQkJOwotCQl9Ci0JCi0JfQotCi0KLQlwcml2YXRlIGNsYXNzIFRlc3RUYWJsZU1vZGVsTGlzdGVuZXIgaW1wbGVtZW50cyBUYWJsZU1vZGVsTGlzdGVuZXIgewotCQlUZXN0VGFibGVNb2RlbExpc3RlbmVyKCkgewotCQkJc3VwZXIoKTsKLQkJfQotCQlwdWJsaWMgdm9pZCB0YWJsZUNoYW5nZWQoVGFibGVNb2RlbEV2ZW50IGUpIHsKLQkJCWZhaWwoInVuZXhwZWN0ZWQgZXZlbnQiKTsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9UYWJsZU1vZGVsQWRhcHRlclVJVGVzdC5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9UYWJsZU1vZGVsQWRhcHRlclVJVGVzdC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlYmUzZDFhLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvVGFibGVNb2RlbEFkYXB0ZXJVSVRlc3QuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDczMSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nOwotCi1pbXBvcnQgamF2YS5hd3QuQm9yZGVyTGF5b3V0OwotaW1wb3J0IGphdmEuYXd0LkNvbXBvbmVudDsKLWltcG9ydCBqYXZhLmF3dC5HcmlkTGF5b3V0OwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LkFjdGlvbkV2ZW50OwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LldpbmRvd0FkYXB0ZXI7Ci1pbXBvcnQgamF2YS5hd3QuZXZlbnQuV2luZG93RXZlbnQ7Ci1pbXBvcnQgamF2YS5hd3QuZXZlbnQuV2luZG93TGlzdGVuZXI7Ci1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuRGF0ZTsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YXguc3dpbmcuQWJzdHJhY3RBY3Rpb247Ci1pbXBvcnQgamF2YXguc3dpbmcuQWN0aW9uOwotaW1wb3J0IGphdmF4LnN3aW5nLkJ1dHRvbk1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLkNvbWJvQm94TW9kZWw7Ci1pbXBvcnQgamF2YXguc3dpbmcuRGVmYXVsdExpc3RDZWxsUmVuZGVyZXI7Ci1pbXBvcnQgamF2YXguc3dpbmcuSkJ1dHRvbjsKLWltcG9ydCBqYXZheC5zd2luZy5KQ2hlY2tCb3g7Ci1pbXBvcnQgamF2YXguc3dpbmcuSkNvbWJvQm94OwotaW1wb3J0IGphdmF4LnN3aW5nLkpGcmFtZTsKLWltcG9ydCBqYXZheC5zd2luZy5KTGlzdDsKLWltcG9ydCBqYXZheC5zd2luZy5KT3B0aW9uUGFuZTsKLWltcG9ydCBqYXZheC5zd2luZy5KUGFuZWw7Ci1pbXBvcnQgamF2YXguc3dpbmcuSlNjcm9sbFBhbmU7Ci1pbXBvcnQgamF2YXguc3dpbmcuSlNwaW5uZXI7Ci1pbXBvcnQgamF2YXguc3dpbmcuSlRhYmxlOwotaW1wb3J0IGphdmF4LnN3aW5nLkpUZXh0RmllbGQ7Ci1pbXBvcnQgamF2YXguc3dpbmcuTGlzdENlbGxSZW5kZXJlcjsKLWltcG9ydCBqYXZheC5zd2luZy5MaXN0U2VsZWN0aW9uTW9kZWw7Ci1pbXBvcnQgamF2YXguc3dpbmcuU3Bpbm5lck1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLlVJTWFuYWdlcjsKLWltcG9ydCBqYXZheC5zd2luZy5XaW5kb3dDb25zdGFudHM7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuTGlzdFNlbGVjdGlvbkV2ZW50OwotaW1wb3J0IGphdmF4LnN3aW5nLmV2ZW50Lkxpc3RTZWxlY3Rpb25MaXN0ZW5lcjsKLWltcG9ydCBqYXZheC5zd2luZy50YWJsZS5UYWJsZUNvbHVtbjsKLWltcG9ydCBqYXZheC5zd2luZy50YWJsZS5UYWJsZU1vZGVsOwotaW1wb3J0IGphdmF4LnN3aW5nLnRleHQuRG9jdW1lbnQ7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuQ2xhc3NUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5Db2xsZWN0aW9uVG9vbHM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuQ29sbGVjdGlvbkFzcGVjdEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuSXRlbVByb3BlcnR5TGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlByb3BlcnR5QXNwZWN0QWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLkNoZWNrQm94TW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLkNvbHVtbkFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuQ29tYm9Cb3hNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuRGF0ZVNwaW5uZXJNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuRG9jdW1lbnRBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLkxpc3RNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuTnVtYmVyU3Bpbm5lck1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5zd2luZy5PYmplY3RMaXN0U2VsZWN0aW9uTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuVGFibGVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuc3dpbmcuQ2hlY2tCb3hUYWJsZUNlbGxSZW5kZXJlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZy5Db21ib0JveFRhYmxlQ2VsbFJlbmRlcmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLnN3aW5nLlNwaW5uZXJUYWJsZUNlbGxSZW5kZXJlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZy5UYWJsZUNlbGxFZGl0b3JBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLldyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLlRhYmxlTW9kZWxBZGFwdGVyVGVzdHMuQ3Jvd2Q7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuVGFibGVNb2RlbEFkYXB0ZXJUZXN0cy5QZXJzb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuVGFibGVNb2RlbEFkYXB0ZXJUZXN0cy5QZXJzb25Db2x1bW5BZGFwdGVyOwotCi0vKioKLSAqIGFuIGV4YW1wbGUgVUkgZm9yIHRlc3RpbmcgdGhlIFRhYmxlTW9kZWxBZGFwdGVyCi0gKiAJIm5hbWUiIGNvbHVtbiBpcyByZWFkLW9ubHkgdGV4dCBmaWVsZAotICogCSJiaXJ0aCBkYXRlIiBjb2x1bW4gaXMgZGF0ZSB0ZXh0IGZpZWxkCi0gKiAJImdvbmUgd2VzdCBkYXRlIiBjb2x1bW4gaXMgZGF0ZSBzcGlubmVyCi0gKiAJImV5ZSBjb2xvciIgY29sdW1uIGlzIGNvbWJvLWJveAotICogCSJldmlsIiBjb2x1bW4gaXMgY2hlY2sgYm94Ci0gKiAJInJhbmsiIGNvbHVtbiBpcyBudW1iZXIgdGV4dCBmaWVsZAotICogCSJhZHZlbnR1cmUgY291bnQiIGNvbHVtbiBpcyBudW1iZXIgc3Bpbm5lcgotICogCi0gKiBOb3RlIHRoYXQgdGhlIHRhYmxlIG1vZGVsIGFuZCByb3cgc2VsZWN0aW9uIG1vZGVsIHNoYXJlIHRoZSBzYW1lCi0gKiBsaXN0IHZhbHVlIG1vZGVsICh0aGUgc29ydGVkIHBlb3BsZSBhZGFwdGVyKQotICovCi1wdWJsaWMgY2xhc3MgVGFibGVNb2RlbEFkYXB0ZXJVSVRlc3QgewotCXByaXZhdGUgU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8T2JqZWN0PiBleWVDb2xvcnNIb2xkZXI7ICAvLyBPYmplY3QgYmVjYXVzZSBpdCBhZGFwdHMgdG8gYSBjb21iby1ib3gKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPENyb3dkPiBjcm93ZEhvbGRlcjsKLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFBlcnNvbj4gc2VsZWN0ZWRQZXJzb25Ib2xkZXI7Ci0JcHJpdmF0ZSBMaXN0VmFsdWVNb2RlbDxQZXJzb24+IHNvcnRlZFBlb3BsZUFkYXB0ZXI7Ci0JcHJpdmF0ZSBUYWJsZU1vZGVsIHRhYmxlTW9kZWw7Ci0JcHJpdmF0ZSBPYmplY3RMaXN0U2VsZWN0aW9uTW9kZWwgcm93U2VsZWN0aW9uTW9kZWw7Ci0JcHJpdmF0ZSBBY3Rpb24gcmVtb3ZlQWN0aW9uOwotCXByaXZhdGUgQWN0aW9uIHJlbmFtZUFjdGlvbjsKLQotCXB1YmxpYyBzdGF0aWMgdm9pZCBtYWluKFN0cmluZ1tdIGFyZ3MpIHRocm93cyBFeGNlcHRpb24gewotCQluZXcgVGFibGVNb2RlbEFkYXB0ZXJVSVRlc3QoKS5leGVjKGFyZ3MpOwotCX0KLQotCXByb3RlY3RlZCBUYWJsZU1vZGVsQWRhcHRlclVJVGVzdCgpIHsKLQkJc3VwZXIoKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgdm9pZCBleGVjKFN0cmluZ1tdIGFyZ3MpIHRocm93cyBFeGNlcHRpb24gewotCQlVSU1hbmFnZXIuc2V0TG9va0FuZEZlZWwoVUlNYW5hZ2VyLmdldFN5c3RlbUxvb2tBbmRGZWVsQ2xhc3NOYW1lKCkpOwotCQl0aGlzLmV5ZUNvbG9yc0hvbGRlciA9IHRoaXMuIGJ1aWxkRXllQ29sb3JDb2xsZWN0aW9uSG9sZGVyKCk7Ci0JCXRoaXMuY3Jvd2RIb2xkZXIgPSB0aGlzLmJ1aWxkQ3Jvd2RIb2xkZXIoKTsKLQkJdGhpcy5zZWxlY3RlZFBlcnNvbkhvbGRlciA9IHRoaXMuYnVpbGRTZWxlY3RlZFBlcnNvbkhvbGRlcigpOwotCQl0aGlzLnNvcnRlZFBlb3BsZUFkYXB0ZXIgPSB0aGlzLmJ1aWxkU29ydGVkUGVvcGxlQWRhcHRlcigpOwotCQl0aGlzLnRhYmxlTW9kZWwgPSB0aGlzLmJ1aWxkVGFibGVNb2RlbCgpOwotCQl0aGlzLnJvd1NlbGVjdGlvbk1vZGVsID0gdGhpcy5idWlsZFJvd1NlbGVjdGlvbk1vZGVsKCk7Ci0JCXRoaXMub3BlbldpbmRvdygpOwotCX0KLQotCXByaXZhdGUgU2ltcGxlQ29sbGVjdGlvblZhbHVlTW9kZWw8T2JqZWN0PiBidWlsZEV5ZUNvbG9yQ29sbGVjdGlvbkhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVDb2xsZWN0aW9uVmFsdWVNb2RlbDxPYmplY3Q+KG5ldyBBcnJheUxpc3Q8T2JqZWN0PihQZXJzb24uZ2V0VmFsaWRFeWVDb2xvcnMoKSkpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Q3Jvd2Q+IGJ1aWxkQ3Jvd2RIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPENyb3dkPih0aGlzLmJ1aWxkQ3Jvd2QoKSk7Ci0JfQotCi0JcHJpdmF0ZSBDcm93ZCBidWlsZENyb3dkKCkgewotCQlDcm93ZCBjcm93ZCA9IG5ldyBDcm93ZCgpOwotCi0JCVBlcnNvbiBwID0gY3Jvd2QuYWRkUGVyc29uKCJCaWxibyIpOwotCQlwLnNldEV5ZUNvbG9yKFBlcnNvbi5FWUVfQ09MT1JfQlJPV04pOwotCQlwLnNldFJhbmsoMjIpOwotCQlwLnNldEFkdmVudHVyZUNvdW50KDEpOwotCi0JCXAgPSBjcm93ZC5hZGRQZXJzb24oIkdvbGx1bSIpOwotCQlwLnNldEV5ZUNvbG9yKFBlcnNvbi5FWUVfQ09MT1JfUElOSyk7Ci0JCXAuc2V0RXZpbCh0cnVlKTsKLQkJcC5zZXRSYW5rKDIpOwotCQlwLnNldEFkdmVudHVyZUNvdW50KDUwKTsKLQotCQlwID0gY3Jvd2QuYWRkUGVyc29uKCJGcm9kbyIpOwotCQlwLnNldEV5ZUNvbG9yKFBlcnNvbi5FWUVfQ09MT1JfQkxVRSk7Ci0JCXAuc2V0UmFuaygzNCk7Ci0JCXAuc2V0QWR2ZW50dXJlQ291bnQoMSk7Ci0KLQkJcCA9IGNyb3dkLmFkZFBlcnNvbigiU2Ftd2lzZSIpOwotCQlwLnNldEV5ZUNvbG9yKFBlcnNvbi5FWUVfQ09MT1JfR1JFRU4pOwotCQlwLnNldFJhbmsoMTkpOwotCQlwLnNldEFkdmVudHVyZUNvdW50KDEpOwotCi0JCXJldHVybiBjcm93ZDsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFBlcnNvbj4gYnVpbGRTZWxlY3RlZFBlcnNvbkhvbGRlcigpIHsKLQkJcmV0dXJuIG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8UGVyc29uPigpOwotCX0KLQotCXByaXZhdGUgTGlzdFZhbHVlTW9kZWw8UGVyc29uPiBidWlsZFNvcnRlZFBlb3BsZUFkYXB0ZXIoKSB7Ci0JCXJldHVybiBuZXcgU29ydGVkTGlzdFZhbHVlTW9kZWxBZGFwdGVyPFBlcnNvbj4odGhpcy5idWlsZFBlb3BsZU5hbWVBZGFwdGVyKCkpOwotCX0KLQotCS8vIHRoZSBsaXN0IHdpbGwgbmVlZCB0byBiZSByZS1zb3J0ZWQgaWYgYSBuYW1lIGNoYW5nZXMKLQlwcml2YXRlIExpc3RWYWx1ZU1vZGVsPFBlcnNvbj4gYnVpbGRQZW9wbGVOYW1lQWRhcHRlcigpIHsKLQkJcmV0dXJuIG5ldyBJdGVtUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8UGVyc29uPih0aGlzLmJ1aWxkUGVvcGxlQWRhcHRlcigpLCBQZXJzb24uTkFNRV9QUk9QRVJUWSk7Ci0JfQotCi0JcHJpdmF0ZSBDb2xsZWN0aW9uVmFsdWVNb2RlbDxQZXJzb24+IGJ1aWxkUGVvcGxlQWRhcHRlcigpIHsKLQkJcmV0dXJuIG5ldyBDb2xsZWN0aW9uQXNwZWN0QWRhcHRlcjxDcm93ZCwgUGVyc29uPih0aGlzLmNyb3dkSG9sZGVyLCBDcm93ZC5QRU9QTEVfQ09MTEVDVElPTikgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgSXRlcmF0b3I8UGVyc29uPiBpdGVyYXRvcl8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5wZW9wbGUoKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIGludCBzaXplXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LnBlb3BsZVNpemUoKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIFRhYmxlTW9kZWwgYnVpbGRUYWJsZU1vZGVsKCkgewotCQlyZXR1cm4gbmV3IFRhYmxlTW9kZWxBZGFwdGVyPFBlcnNvbj4odGhpcy5zb3J0ZWRQZW9wbGVBZGFwdGVyLCB0aGlzLmJ1aWxkQ29sdW1uQWRhcHRlcigpKTsKLQl9Ci0KLQlwcm90ZWN0ZWQgQ29sdW1uQWRhcHRlciBidWlsZENvbHVtbkFkYXB0ZXIoKSB7Ci0JCXJldHVybiBuZXcgUGVyc29uQ29sdW1uQWRhcHRlcigpOwotCX0KLQotCXByaXZhdGUgT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsIGJ1aWxkUm93U2VsZWN0aW9uTW9kZWwoKSB7Ci0JCU9iamVjdExpc3RTZWxlY3Rpb25Nb2RlbCByc20gPSBuZXcgT2JqZWN0TGlzdFNlbGVjdGlvbk1vZGVsKG5ldyBMaXN0TW9kZWxBZGFwdGVyKHRoaXMuc29ydGVkUGVvcGxlQWRhcHRlcikpOwotCQlyc20uYWRkTGlzdFNlbGVjdGlvbkxpc3RlbmVyKHRoaXMuYnVpbGRSb3dTZWxlY3Rpb25MaXN0ZW5lcigpKTsKLQkJcnNtLnNldFNlbGVjdGlvbk1vZGUoTGlzdFNlbGVjdGlvbk1vZGVsLlNJTkdMRV9TRUxFQ1RJT04pOwotCQlyZXR1cm4gcnNtOwotCX0KLQotCXByaXZhdGUgTGlzdFNlbGVjdGlvbkxpc3RlbmVyIGJ1aWxkUm93U2VsZWN0aW9uTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgTGlzdFNlbGVjdGlvbkxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgdmFsdWVDaGFuZ2VkKExpc3RTZWxlY3Rpb25FdmVudCBlKSB7Ci0JCQkJaWYgKGUuZ2V0VmFsdWVJc0FkanVzdGluZygpKSB7Ci0JCQkJCXJldHVybjsKLQkJCQl9Ci0JCQkJVGFibGVNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5yb3dTZWxlY3Rpb25DaGFuZ2VkKGUpOwotCQkJfQotCQl9OwotCX0KLQotCXZvaWQgcm93U2VsZWN0aW9uQ2hhbmdlZChMaXN0U2VsZWN0aW9uRXZlbnQgZSkgewotCQlQZXJzb24gc2VsZWN0aW9uID0gKFBlcnNvbikgdGhpcy5yb3dTZWxlY3Rpb25Nb2RlbC5zZWxlY3RlZFZhbHVlKCk7Ci0JCXRoaXMuc2VsZWN0ZWRQZXJzb25Ib2xkZXIuc2V0VmFsdWUoc2VsZWN0aW9uKTsKLQkJYm9vbGVhbiBwZXJzb25TZWxlY3RlZCA9IChzZWxlY3Rpb24gIT0gbnVsbCk7Ci0JCXRoaXMucmVtb3ZlQWN0aW9uLnNldEVuYWJsZWQocGVyc29uU2VsZWN0ZWQpOwotCQl0aGlzLnJlbmFtZUFjdGlvbi5zZXRFbmFibGVkKHBlcnNvblNlbGVjdGVkKTsKLQl9Ci0KLQlwcml2YXRlIHZvaWQgb3BlbldpbmRvdygpIHsKLQkJSkZyYW1lIHdpbmRvdyA9IG5ldyBKRnJhbWUoQ2xhc3NUb29scy5zaG9ydENsYXNzTmFtZUZvck9iamVjdCh0aGlzKSk7Ci0JCXdpbmRvdy5zZXREZWZhdWx0Q2xvc2VPcGVyYXRpb24oV2luZG93Q29uc3RhbnRzLkRPX05PVEhJTkdfT05fQ0xPU0UpOwotCQl3aW5kb3cuYWRkV2luZG93TGlzdGVuZXIodGhpcy5idWlsZFdpbmRvd0xpc3RlbmVyKCkpOwotCQl3aW5kb3cuZ2V0Q29udGVudFBhbmUoKS5hZGQodGhpcy5idWlsZE1haW5QYW5lbCgpLCAiQ2VudGVyIik7Ci0JCXdpbmRvdy5zZXRMb2NhdGlvbigyMDAsIDIwMCk7Ci0JCXdpbmRvdy5zZXRTaXplKDYwMCwgNDAwKTsKLQkJd2luZG93LnNldFZpc2libGUodHJ1ZSk7Ci0JfQotCi0JcHJpdmF0ZSBXaW5kb3dMaXN0ZW5lciBidWlsZFdpbmRvd0xpc3RlbmVyKCkgewotCQlyZXR1cm4gbmV3IFdpbmRvd0FkYXB0ZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHdpbmRvd0Nsb3NpbmcoV2luZG93RXZlbnQgZSkgewotCQkJCWUuZ2V0V2luZG93KCkuc2V0VmlzaWJsZShmYWxzZSk7Ci0JCQkJU3lzdGVtLmV4aXQoMCk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRNYWluUGFuZWwoKSB7Ci0JCUpQYW5lbCBtYWluUGFuZWwgPSBuZXcgSlBhbmVsKG5ldyBCb3JkZXJMYXlvdXQoKSk7Ci0JCW1haW5QYW5lbC5hZGQodGhpcy5idWlsZFRhYmxlUGFuZSgpLCBCb3JkZXJMYXlvdXQuQ0VOVEVSKTsKLQkJbWFpblBhbmVsLmFkZCh0aGlzLmJ1aWxkQ29udHJvbFBhbmVsKCksIEJvcmRlckxheW91dC5TT1VUSCk7Ci0JCXJldHVybiBtYWluUGFuZWw7Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRUYWJsZVBhbmUoKSB7Ci0JCXJldHVybiBuZXcgSlNjcm9sbFBhbmUodGhpcy5idWlsZFRhYmxlKCkpOwotCX0KLQotCXByaXZhdGUgSlRhYmxlIGJ1aWxkVGFibGUoKSB7Ci0JCUpUYWJsZSB0YWJsZSA9IG5ldyBKVGFibGUodGhpcy50YWJsZU1vZGVsKTsKLQkJdGFibGUucHV0Q2xpZW50UHJvcGVydHkoInRlcm1pbmF0ZUVkaXRPbkZvY3VzTG9zdCIsIEJvb2xlYW4uVFJVRSk7CS8vIHNlZSBKYXZhIGJ1ZyA1MDA3NjUyCi0JCXRhYmxlLnNldFNlbGVjdGlvbk1vZGVsKHRoaXMucm93U2VsZWN0aW9uTW9kZWwpOwotCQl0YWJsZS5zZXREb3VibGVCdWZmZXJlZCh0cnVlKTsKLQkJdGFibGUuc2V0QXV0b1Jlc2l6ZU1vZGUoSlRhYmxlLkFVVE9fUkVTSVpFX05FWFRfQ09MVU1OKTsKLQkJaW50IHJvd0hlaWdodCA9IDIwOwkvLyBzdGFydCB3aXRoIG1pbmltdW0gb2YgMjAKLQotCQkvLyBnb25lIHdlc3QgY29sdW1uIChzcGlubmVyKQotCQlUYWJsZUNvbHVtbiBjb2x1bW4gPSB0YWJsZS5nZXRDb2x1bW5Nb2RlbCgpLmdldENvbHVtbihQZXJzb25Db2x1bW5BZGFwdGVyLkdPTkVfV0VTVF9EQVRFX0NPTFVNTik7Ci0JCVNwaW5uZXJUYWJsZUNlbGxSZW5kZXJlciBzcGlubmVyUmVuZGVyZXIgPSB0aGlzLmJ1aWxkRGF0ZVNwaW5uZXJSZW5kZXJlcigpOwotCQljb2x1bW4uc2V0Q2VsbFJlbmRlcmVyKHNwaW5uZXJSZW5kZXJlcik7Ci0JCWNvbHVtbi5zZXRDZWxsRWRpdG9yKG5ldyBUYWJsZUNlbGxFZGl0b3JBZGFwdGVyKHRoaXMuYnVpbGREYXRlU3Bpbm5lclJlbmRlcmVyKCkpKTsKLQkJcm93SGVpZ2h0ID0gTWF0aC5tYXgocm93SGVpZ2h0LCBzcGlubmVyUmVuZGVyZXIucHJlZmVycmVkSGVpZ2h0KCkpOwotCi0JCS8vIGV5ZSBjb2xvciBjb2x1bW4gKGNvbWJvLWJveCkKLQkJLy8gdGhlIGpkayBjb21iby1ib3ggcmVuZGVyZXIgbG9va3MgbGlrZSBhIHRleHQgZmllbGQKLQkJLy8gdW50aWwgdGhlIHVzZXIgc3RhcnRzIGFuIGVkaXQgLSB1c2UgYSBjdXN0b20gb25lCi0JCWNvbHVtbiA9IHRhYmxlLmdldENvbHVtbk1vZGVsKCkuZ2V0Q29sdW1uKFBlcnNvbkNvbHVtbkFkYXB0ZXIuRVlFX0NPTE9SX0NPTFVNTik7Ci0JCUNvbWJvQm94VGFibGVDZWxsUmVuZGVyZXIgZXllQ29sb3JSZW5kZXJlciA9IHRoaXMuYnVpbGRFeWVDb2xvckNvbWJvQm94UmVuZGVyZXIoKTsKLQkJY29sdW1uLnNldENlbGxSZW5kZXJlcihleWVDb2xvclJlbmRlcmVyKTsKLQkJY29sdW1uLnNldENlbGxFZGl0b3IobmV3IFRhYmxlQ2VsbEVkaXRvckFkYXB0ZXIodGhpcy5idWlsZEV5ZUNvbG9yQ29tYm9Cb3hSZW5kZXJlcigpKSk7Ci0JCXJvd0hlaWdodCA9IE1hdGgubWF4KHJvd0hlaWdodCwgZXllQ29sb3JSZW5kZXJlci5wcmVmZXJyZWRIZWlnaHQoKSk7Ci0KLQkJLy8gZXZpbCAoY2hlY2sgYm94KQotCQkvLyB0aGUgamRrIGNoZWNrIGJveCByZW5kZXJlciBhbmQgZWRpdG9yIHN1Y2sgLSB1c2UgYSBjdXN0b20gb25lcwotCQljb2x1bW4gPSB0YWJsZS5nZXRDb2x1bW5Nb2RlbCgpLmdldENvbHVtbihQZXJzb25Db2x1bW5BZGFwdGVyLkVWSUxfQ09MVU1OKTsKLQkJQ2hlY2tCb3hUYWJsZUNlbGxSZW5kZXJlciBldmlsUmVuZGVyZXIgPSBuZXcgQ2hlY2tCb3hUYWJsZUNlbGxSZW5kZXJlcigpOwotCQljb2x1bW4uc2V0Q2VsbFJlbmRlcmVyKGV2aWxSZW5kZXJlcik7Ci0JCWNvbHVtbi5zZXRDZWxsRWRpdG9yKG5ldyBUYWJsZUNlbGxFZGl0b3JBZGFwdGVyKG5ldyBDaGVja0JveFRhYmxlQ2VsbFJlbmRlcmVyKCkpKTsKLQkJcm93SGVpZ2h0ID0gTWF0aC5tYXgocm93SGVpZ2h0LCBldmlsUmVuZGVyZXIucHJlZmVycmVkSGVpZ2h0KCkpOwotCi0JCS8vIGFkdmVudHVyZSBjb3VudCBjb2x1bW4gKHNwaW5uZXIpCi0JCWNvbHVtbiA9IHRhYmxlLmdldENvbHVtbk1vZGVsKCkuZ2V0Q29sdW1uKFBlcnNvbkNvbHVtbkFkYXB0ZXIuQURWRU5UVVJFX0NPVU5UX0NPTFVNTik7Ci0JCXNwaW5uZXJSZW5kZXJlciA9IHRoaXMuYnVpbGROdW1iZXJTcGlubmVyUmVuZGVyZXIoKTsKLQkJY29sdW1uLnNldENlbGxSZW5kZXJlcihzcGlubmVyUmVuZGVyZXIpOwotCQljb2x1bW4uc2V0Q2VsbEVkaXRvcihuZXcgVGFibGVDZWxsRWRpdG9yQWRhcHRlcih0aGlzLmJ1aWxkTnVtYmVyU3Bpbm5lclJlbmRlcmVyKCkpKTsKLQkJcm93SGVpZ2h0ID0gTWF0aC5tYXgocm93SGVpZ2h0LCBzcGlubmVyUmVuZGVyZXIucHJlZmVycmVkSGVpZ2h0KCkpOwotCi0JCXRhYmxlLnNldFJvd0hlaWdodChyb3dIZWlnaHQpOwotCQlyZXR1cm4gdGFibGU7Ci0JfQotCi0JcHJpdmF0ZSBTcGlubmVyVGFibGVDZWxsUmVuZGVyZXIgYnVpbGREYXRlU3Bpbm5lclJlbmRlcmVyKCkgewotCQlyZXR1cm4gbmV3IFNwaW5uZXJUYWJsZUNlbGxSZW5kZXJlcihuZXcgRGF0ZVNwaW5uZXJNb2RlbEFkYXB0ZXIobmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+KCkpKTsKLQl9Ci0KLQlwcml2YXRlIFNwaW5uZXJUYWJsZUNlbGxSZW5kZXJlciBidWlsZE51bWJlclNwaW5uZXJSZW5kZXJlcigpIHsKLQkJcmV0dXJuIG5ldyBTcGlubmVyVGFibGVDZWxsUmVuZGVyZXIobmV3IE51bWJlclNwaW5uZXJNb2RlbEFkYXB0ZXIobmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxOdW1iZXI+KCkpKTsKLQl9Ci0KLQlwcml2YXRlIENvbWJvQm94VGFibGVDZWxsUmVuZGVyZXIgYnVpbGRFeWVDb2xvckNvbWJvQm94UmVuZGVyZXIoKSB7Ci0JCXJldHVybiBuZXcgQ29tYm9Cb3hUYWJsZUNlbGxSZW5kZXJlcih0aGlzLmJ1aWxkUmVhZE9ubHlFeWVDb2xvckNvbWJvQm94TW9kZWwoKSwgdGhpcy5idWlsZEV5ZUNvbG9yUmVuZGVyZXIoKSk7Ci0JfQotCi0JcHJpdmF0ZSBDb21ib0JveE1vZGVsIGJ1aWxkUmVhZE9ubHlFeWVDb2xvckNvbWJvQm94TW9kZWwoKSB7Ci0JCXJldHVybiBuZXcgQ29tYm9Cb3hNb2RlbEFkYXB0ZXIodGhpcy5leWVDb2xvcnNIb2xkZXIsIG5ldyBTaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw8T2JqZWN0PigpKTsKLQl9Ci0KLQlwcml2YXRlIExpc3RDZWxsUmVuZGVyZXIgYnVpbGRFeWVDb2xvclJlbmRlcmVyKCkgewotCQlyZXR1cm4gbmV3IEV5ZUNvbG9yUmVuZGVyZXIoKTsKLQl9Ci0KLQlwcml2YXRlIENvbXBvbmVudCBidWlsZENvbnRyb2xQYW5lbCgpIHsKLQkJSlBhbmVsIGNvbnRyb2xQYW5lbCA9IG5ldyBKUGFuZWwobmV3IEdyaWRMYXlvdXQoMCwgMSkpOwotCQljb250cm9sUGFuZWwuYWRkKHRoaXMuYnVpbGRCdXR0b25QYW5lbCgpKTsKLQkJY29udHJvbFBhbmVsLmFkZCh0aGlzLmJ1aWxkUGVyc29uUGFuZWwoKSk7Ci0JCXJldHVybiBjb250cm9sUGFuZWw7Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRCdXR0b25QYW5lbCgpIHsKLQkJSlBhbmVsIGJ1dHRvblBhbmVsID0gbmV3IEpQYW5lbChuZXcgR3JpZExheW91dCgxLCAwKSk7Ci0JCWJ1dHRvblBhbmVsLmFkZCh0aGlzLmJ1aWxkQWRkQnV0dG9uKCkpOwotCQlidXR0b25QYW5lbC5hZGQodGhpcy5idWlsZFJlbW92ZUJ1dHRvbigpKTsKLQkJYnV0dG9uUGFuZWwuYWRkKHRoaXMuYnVpbGRSZW5hbWVCdXR0b24oKSk7Ci0JCWJ1dHRvblBhbmVsLmFkZCh0aGlzLmJ1aWxkQWRkRXllQ29sb3JCdXR0b24oKSk7Ci0JCWJ1dHRvblBhbmVsLmFkZCh0aGlzLmJ1aWxkUHJpbnRCdXR0b24oKSk7Ci0JCWJ1dHRvblBhbmVsLmFkZCh0aGlzLmJ1aWxkUmVzZXRCdXR0b24oKSk7Ci0JCXJldHVybiBidXR0b25QYW5lbDsKLQl9Ci0KLQlwcml2YXRlIENvbXBvbmVudCBidWlsZFBlcnNvblBhbmVsKCkgewotCQlKUGFuZWwgcGVyc29uUGFuZWwgPSBuZXcgSlBhbmVsKG5ldyBHcmlkTGF5b3V0KDEsIDApKTsKLQkJcGVyc29uUGFuZWwuYWRkKHRoaXMuYnVpbGROYW1lVGV4dEZpZWxkKCkpOwotCQlwZXJzb25QYW5lbC5hZGQodGhpcy5idWlsZEJpcnRoRGF0ZVNwaW5uZXIoKSk7Ci0JCXBlcnNvblBhbmVsLmFkZCh0aGlzLmJ1aWxkR29uZVdlc3REYXRlU3Bpbm5lcigpKTsKLQkJcGVyc29uUGFuZWwuYWRkKHRoaXMuYnVpbGRFeWVDb2xvckNvbWJvQm94KCkpOwotCQlwZXJzb25QYW5lbC5hZGQodGhpcy5idWlsZEV2aWxDaGVja0JveCgpKTsKLQkJcGVyc29uUGFuZWwuYWRkKHRoaXMuYnVpbGRSYW5rU3Bpbm5lcigpKTsKLQkJcGVyc29uUGFuZWwuYWRkKHRoaXMuYnVpbGRBZHZlbnR1cmVDb3VudFNwaW5uZXIoKSk7Ci0JCXJldHVybiBwZXJzb25QYW5lbDsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYWRkIGJ1dHRvbiAqKioqKioqKioqCi0KLQlwcml2YXRlIEpCdXR0b24gYnVpbGRBZGRCdXR0b24oKSB7Ci0JCXJldHVybiBuZXcgSkJ1dHRvbih0aGlzLmJ1aWxkQWRkQWN0aW9uKCkpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uIGJ1aWxkQWRkQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJhZGQiKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZXZlbnQpIHsKLQkJCQlUYWJsZU1vZGVsQWRhcHRlclVJVGVzdC50aGlzLmFkZFBlcnNvbigpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQl2b2lkIGFkZFBlcnNvbigpIHsKLQkJU3RyaW5nIG5hbWUgPSB0aGlzLmdldE5hbWVGcm9tVXNlcigpOwotCQlpZiAobmFtZSAhPSBudWxsKSB7Ci0JCQl0aGlzLnNldFNlbGVjdGVkUGVyc29uKHRoaXMuY3Jvd2QoKS5hZGRQZXJzb24obmFtZSkpOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHJlbW92ZSBidXR0b24gKioqKioqKioqKgotCi0JcHJpdmF0ZSBKQnV0dG9uIGJ1aWxkUmVtb3ZlQnV0dG9uKCkgewotCQlyZXR1cm4gbmV3IEpCdXR0b24odGhpcy5idWlsZFJlbW92ZUFjdGlvbigpKTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbiBidWlsZFJlbW92ZUFjdGlvbigpIHsKLQkJdGhpcy5yZW1vdmVBY3Rpb24gPSBuZXcgQWJzdHJhY3RBY3Rpb24oInJlbW92ZSIpIHsKLQkJCXB1YmxpYyB2b2lkIGFjdGlvblBlcmZvcm1lZChBY3Rpb25FdmVudCBldmVudCkgewotCQkJCVRhYmxlTW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMucmVtb3ZlUGVyc29uKCk7Ci0JCQl9Ci0JCX07Ci0JCXRoaXMucmVtb3ZlQWN0aW9uLnNldEVuYWJsZWQoZmFsc2UpOwotCQlyZXR1cm4gdGhpcy5yZW1vdmVBY3Rpb247Ci0JfQotCi0Jdm9pZCByZW1vdmVQZXJzb24oKSB7Ci0JCVBlcnNvbiBwZXJzb24gPSB0aGlzLnNlbGVjdGVkUGVyc29uKCk7Ci0JCWlmIChwZXJzb24gIT0gbnVsbCkgewotCQkJdGhpcy5jcm93ZCgpLnJlbW92ZVBlcnNvbihwZXJzb24pOwotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHJlbmFtZSBidXR0b24gKioqKioqKioqKgotCi0JcHJpdmF0ZSBKQnV0dG9uIGJ1aWxkUmVuYW1lQnV0dG9uKCkgewotCQlyZXR1cm4gbmV3IEpCdXR0b24odGhpcy5idWlsZFJlbmFtZUFjdGlvbigpKTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbiBidWlsZFJlbmFtZUFjdGlvbigpIHsKLQkJdGhpcy5yZW5hbWVBY3Rpb24gPSBuZXcgQWJzdHJhY3RBY3Rpb24oInJlbmFtZSIpIHsKLQkJCXB1YmxpYyB2b2lkIGFjdGlvblBlcmZvcm1lZChBY3Rpb25FdmVudCBldmVudCkgewotCQkJCVRhYmxlTW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMucmVuYW1lUGVyc29uKCk7Ci0JCQl9Ci0JCX07Ci0JCXRoaXMucmVuYW1lQWN0aW9uLnNldEVuYWJsZWQoZmFsc2UpOwotCQlyZXR1cm4gdGhpcy5yZW5hbWVBY3Rpb247Ci0JfQotCi0Jdm9pZCByZW5hbWVQZXJzb24oKSB7Ci0JCVBlcnNvbiBwZXJzb24gPSB0aGlzLnNlbGVjdGVkUGVyc29uKCk7Ci0JCWlmIChwZXJzb24gIT0gbnVsbCkgewotCQkJU3RyaW5nIG5hbWUgPSB0aGlzLnByb21wdFVzZXJGb3JOYW1lKHBlcnNvbi5nZXROYW1lKCkpOwotCQkJaWYgKG5hbWUgIT0gbnVsbCkgewotCQkJCXBlcnNvbi5zZXROYW1lKG5hbWUpOwotCQkJCXRoaXMuc2V0U2VsZWN0ZWRQZXJzb24ocGVyc29uKTsKLQkJCX0KLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBhZGQgZXllIGNvbG9yIGJ1dHRvbiAqKioqKioqKioqCi0KLQlwcml2YXRlIEpCdXR0b24gYnVpbGRBZGRFeWVDb2xvckJ1dHRvbigpIHsKLQkJcmV0dXJuIG5ldyBKQnV0dG9uKHRoaXMuYnVpbGRBZGRFeWVDb2xvckFjdGlvbigpKTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbiBidWlsZEFkZEV5ZUNvbG9yQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJhZGQgZXllIGNvbG9yIikgewotCQkJcHVibGljIHZvaWQgYWN0aW9uUGVyZm9ybWVkKEFjdGlvbkV2ZW50IGV2ZW50KSB7Ci0JCQkJVGFibGVNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5hZGRFeWVDb2xvcigpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQl2b2lkIGFkZEV5ZUNvbG9yKCkgewotCQlTdHJpbmcgY29sb3IgPSB0aGlzLnByb21wdFVzZXJGb3JFeWVDb2xvcigpOwotCQlpZiAoY29sb3IgIT0gbnVsbCkgewotCQkJdGhpcy5leWVDb2xvcnNIb2xkZXIuYWRkKGNvbG9yKTsKLQkJfQotCX0KLQotCXByaXZhdGUgU3RyaW5nIHByb21wdFVzZXJGb3JFeWVDb2xvcigpIHsKLQkJd2hpbGUgKHRydWUpIHsKLQkJCVN0cmluZyBleWVDb2xvciA9IEpPcHRpb25QYW5lLnNob3dJbnB1dERpYWxvZygiRXllIENvbG9yIik7Ci0JCQlpZiAoZXllQ29sb3IgPT0gbnVsbCkgewotCQkJCXJldHVybiBudWxsOwkJLy8gdXNlciBwcmVzc2VkIDxDYW5jZWw+Ci0JCQl9Ci0JCQlpZiAoKGV5ZUNvbG9yLmxlbmd0aCgpID09IDApKSB7Ci0JCQkJSk9wdGlvblBhbmUuc2hvd01lc3NhZ2VEaWFsb2cobnVsbCwgIlRoZSBleWUgY29sb3IgaXMgcmVxdWlyZWQuIiwgIkludmFsaWQgRXllIENvbG9yIiwgSk9wdGlvblBhbmUuRVJST1JfTUVTU0FHRSk7Ci0JCQl9IGVsc2UgaWYgKENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmV5ZUNvbG9yc0hvbGRlci5pdGVyYXRvcigpLCBleWVDb2xvcikpIHsKLQkJCQlKT3B0aW9uUGFuZS5zaG93TWVzc2FnZURpYWxvZyhudWxsLCAiVGhlIGV5ZSBjb2xvciBhbHJlYWR5IGV4aXN0cy4iLCAiSW52YWxpZCBFeWUgQ29sb3IiLCBKT3B0aW9uUGFuZS5FUlJPUl9NRVNTQUdFKTsKLQkJCX0gZWxzZSB7Ci0JCQkJcmV0dXJuIGV5ZUNvbG9yOwotCQkJfQotCQl9Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIHByaW50IGJ1dHRvbiAqKioqKioqKioqCi0KLQlwcml2YXRlIEpCdXR0b24gYnVpbGRQcmludEJ1dHRvbigpIHsKLQkJcmV0dXJuIG5ldyBKQnV0dG9uKHRoaXMuYnVpbGRQcmludEFjdGlvbigpKTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbiBidWlsZFByaW50QWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJwcmludCIpIHsKLQkJCXB1YmxpYyB2b2lkIGFjdGlvblBlcmZvcm1lZChBY3Rpb25FdmVudCBldmVudCkgewotCQkJCVRhYmxlTW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMucHJpbnRDcm93ZCgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQl2b2lkIHByaW50Q3Jvd2QoKSB7Ci0JCVN5c3RlbS5vdXQucHJpbnRsbih0aGlzLmNyb3dkKCkpOwotCQlmb3IgKEl0ZXJhdG9yPFBlcnNvbj4gc3RyZWFtID0gdGhpcy5jcm93ZCgpLnBlb3BsZSgpOyBzdHJlYW0uaGFzTmV4dCgpOyApIHsKLQkJCVN5c3RlbS5vdXQucHJpbnRsbigiXHQiICsgc3RyZWFtLm5leHQoKSk7Ci0JCX0KLQl9Ci0KLQotCS8vICoqKioqKioqKiogcmVzZXQgYnV0dG9uICoqKioqKioqKioKLQotCXByaXZhdGUgSkJ1dHRvbiBidWlsZFJlc2V0QnV0dG9uKCkgewotCQlyZXR1cm4gbmV3IEpCdXR0b24odGhpcy5idWlsZFJlc2V0QWN0aW9uKCkpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uIGJ1aWxkUmVzZXRBY3Rpb24oKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWJzdHJhY3RBY3Rpb24oInJlc2V0IikgewotCQkJcHVibGljIHZvaWQgYWN0aW9uUGVyZm9ybWVkKEFjdGlvbkV2ZW50IGV2ZW50KSB7Ci0JCQkJVGFibGVNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5yZXNldCgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQl2b2lkIHJlc2V0KCkgewotCQl0aGlzLmNyb3dkSG9sZGVyLnNldFZhbHVlKHRoaXMuYnVpbGRDcm93ZCgpKTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogbmV3IG5hbWUgZGlhbG9nICoqKioqKioqKioKLQotCXByaXZhdGUgU3RyaW5nIGdldE5hbWVGcm9tVXNlcigpIHsKLQkJcmV0dXJuIHRoaXMucHJvbXB0VXNlckZvck5hbWUobnVsbCk7Ci0JfQotCi0JcHJpdmF0ZSBTdHJpbmcgcHJvbXB0VXNlckZvck5hbWUoU3RyaW5nIG9yaWdpbmFsTmFtZSkgewotCQl3aGlsZSAodHJ1ZSkgewotCQkJU3RyaW5nIG5hbWUgPSBKT3B0aW9uUGFuZS5zaG93SW5wdXREaWFsb2coIlBlcnNvbiBOYW1lIik7Ci0JCQlpZiAobmFtZSA9PSBudWxsKSB7Ci0JCQkJcmV0dXJuIG51bGw7CQkvLyB1c2VyIHByZXNzZWQgPENhbmNlbD4KLQkJCX0KLQkJCWlmICgobmFtZS5sZW5ndGgoKSA9PSAwKSkgewotCQkJCUpPcHRpb25QYW5lLnNob3dNZXNzYWdlRGlhbG9nKG51bGwsICJUaGUgbmFtZSBpcyByZXF1aXJlZC4iLCAiSW52YWxpZCBOYW1lIiwgSk9wdGlvblBhbmUuRVJST1JfTUVTU0FHRSk7Ci0JCQl9IGVsc2UgaWYgKENvbGxlY3Rpb25Ub29scy5jb250YWlucyh0aGlzLmNyb3dkKCkucGVvcGxlTmFtZXMoKSwgbmFtZSkpIHsKLQkJCQlKT3B0aW9uUGFuZS5zaG93TWVzc2FnZURpYWxvZyhudWxsLCAiVGhlIG5hbWUgYWxyZWFkeSBleGlzdHMuIiwgIkludmFsaWQgTmFtZSIsIEpPcHRpb25QYW5lLkVSUk9SX01FU1NBR0UpOwotCQkJfSBlbHNlIHsKLQkJCQlyZXR1cm4gbmFtZTsKLQkJCX0KLQkJfQotCX0KLQotCi0JLy8gKioqKioqKioqKiBuYW1lIHRleHQgZmllbGQgKioqKioqKioqKgotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGROYW1lVGV4dEZpZWxkKCkgewotCQlKVGV4dEZpZWxkIHRleHRGaWVsZCA9IG5ldyBKVGV4dEZpZWxkKHRoaXMuYnVpbGROYW1lRG9jdW1lbnQoKSwgbnVsbCwgMCk7Ci0JCXRleHRGaWVsZC5zZXRFZGl0YWJsZShmYWxzZSk7Ci0JCXJldHVybiB0ZXh0RmllbGQ7Ci0JfQotCi0JcHJpdmF0ZSBEb2N1bWVudCBidWlsZE5hbWVEb2N1bWVudCgpIHsKLQkJcmV0dXJuIG5ldyBEb2N1bWVudEFkYXB0ZXIodGhpcy5idWlsZE5hbWVBZGFwdGVyKCkpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBidWlsZE5hbWVBZGFwdGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxQZXJzb24sIFN0cmluZz4odGhpcy5zZWxlY3RlZFBlcnNvbkhvbGRlciwgUGVyc29uLk5BTUVfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0cmluZyBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gdGhpcy5zdWJqZWN0LmdldE5hbWUoKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIHZvaWQgc2V0VmFsdWVfKFN0cmluZyB2YWx1ZSkgewotCQkJCXRoaXMuc3ViamVjdC5zZXROYW1lKHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogYmlydGggZGF0ZSBzcGlubmVyICoqKioqKioqKioKLQotCXByaXZhdGUgSlNwaW5uZXIgYnVpbGRCaXJ0aERhdGVTcGlubmVyKCkgewotCQlyZXR1cm4gbmV3IEpTcGlubmVyKHRoaXMuYnVpbGRCaXJ0aERhdGVTcGlubmVyTW9kZWwoKSk7Ci0JfQotCi0JcHJpdmF0ZSBTcGlubmVyTW9kZWwgYnVpbGRCaXJ0aERhdGVTcGlubmVyTW9kZWwoKSB7Ci0JCXJldHVybiBuZXcgRGF0ZVNwaW5uZXJNb2RlbEFkYXB0ZXIodGhpcy5idWlsZEJpcnRoRGF0ZUFkYXB0ZXIoKSk7Ci0JfQotCi0JcHJpdmF0ZSBXcml0YWJsZVByb3BlcnR5VmFsdWVNb2RlbDxPYmplY3Q+IGJ1aWxkQmlydGhEYXRlQWRhcHRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8UGVyc29uLCBPYmplY3Q+KHRoaXMuc2VsZWN0ZWRQZXJzb25Ib2xkZXIsIFBlcnNvbi5CSVJUSF9EQVRFX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBEYXRlIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0QmlydGhEYXRlKCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhPYmplY3QgdmFsdWUpIHsKLQkJCQl0aGlzLnN1YmplY3Quc2V0QmlydGhEYXRlKChEYXRlKSB2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGdvbmUgd2VzdCBkYXRlIHNwaW5uZXIgKioqKioqKioqKgotCi0JcHJpdmF0ZSBKU3Bpbm5lciBidWlsZEdvbmVXZXN0RGF0ZVNwaW5uZXIoKSB7Ci0JCXJldHVybiBuZXcgSlNwaW5uZXIodGhpcy5idWlsZEdvbmVXZXN0RGF0ZVNwaW5uZXJNb2RlbCgpKTsKLQl9Ci0KLQlwcml2YXRlIFNwaW5uZXJNb2RlbCBidWlsZEdvbmVXZXN0RGF0ZVNwaW5uZXJNb2RlbCgpIHsKLQkJcmV0dXJuIG5ldyBEYXRlU3Bpbm5lck1vZGVsQWRhcHRlcih0aGlzLmJ1aWxkR29uZVdlc3REYXRlQWRhcHRlcigpKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gYnVpbGRHb25lV2VzdERhdGVBZGFwdGVyKCkgewotCQlyZXR1cm4gbmV3IFByb3BlcnR5QXNwZWN0QWRhcHRlcjxQZXJzb24sIE9iamVjdD4odGhpcy5zZWxlY3RlZFBlcnNvbkhvbGRlciwgUGVyc29uLkdPTkVfV0VTVF9EQVRFX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBEYXRlIGJ1aWxkVmFsdWVfKCkgewotCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0R29uZVdlc3REYXRlKCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhPYmplY3QgdmFsdWUpIHsKLQkJCQl0aGlzLnN1YmplY3Quc2V0R29uZVdlc3REYXRlKChEYXRlKSB2YWx1ZSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGV5ZSBjb2xvciBjb21iby1ib3ggKioqKioqKioqKgotCi0JcHJpdmF0ZSBKQ29tYm9Cb3ggYnVpbGRFeWVDb2xvckNvbWJvQm94KCkgewotCQlyZXR1cm4gbmV3IEpDb21ib0JveCh0aGlzLmJ1aWxkRXllQ29sb3JDb21ib0JveE1vZGVsKCkpOwotCX0KLQotCXByaXZhdGUgQ29tYm9Cb3hNb2RlbCBidWlsZEV5ZUNvbG9yQ29tYm9Cb3hNb2RlbCgpIHsKLQkJcmV0dXJuIG5ldyBDb21ib0JveE1vZGVsQWRhcHRlcih0aGlzLmV5ZUNvbG9yc0hvbGRlciwgdGhpcy5idWlsZEV5ZUNvbG9yQWRhcHRlcigpKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE9iamVjdD4gYnVpbGRFeWVDb2xvckFkYXB0ZXIoKSB7Ci0JCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFBlcnNvbiwgT2JqZWN0Pih0aGlzLnNlbGVjdGVkUGVyc29uSG9sZGVyLCBQZXJzb24uRVlFX0NPTE9SX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBPYmplY3QgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5nZXRFeWVDb2xvcigpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oT2JqZWN0IHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldEV5ZUNvbG9yKChTdHJpbmcpIHZhbHVlKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogZXZpbCBjaGVjayBib3ggKioqKioqKioqKgotCi0JcHJpdmF0ZSBKQ2hlY2tCb3ggYnVpbGRFdmlsQ2hlY2tCb3goKSB7Ci0JCUpDaGVja0JveCBjaGVja0JveCA9IG5ldyBKQ2hlY2tCb3goKTsKLQkJY2hlY2tCb3guc2V0VGV4dCgiZXZpbCIpOwotCQljaGVja0JveC5zZXRNb2RlbCh0aGlzLmJ1aWxkRXZpbENoZWNrQm94TW9kZWwoKSk7Ci0JCXJldHVybiBjaGVja0JveDsKLQl9Ci0KLQlwcml2YXRlIEJ1dHRvbk1vZGVsIGJ1aWxkRXZpbENoZWNrQm94TW9kZWwoKSB7Ci0JCXJldHVybiBuZXcgQ2hlY2tCb3hNb2RlbEFkYXB0ZXIodGhpcy5idWlsZEV2aWxBZGFwdGVyKCkpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8Qm9vbGVhbj4gYnVpbGRFdmlsQWRhcHRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8UGVyc29uLCBCb29sZWFuPih0aGlzLnNlbGVjdGVkUGVyc29uSG9sZGVyLCBQZXJzb24uRVZJTF9QUk9QRVJUWSkgewotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgQm9vbGVhbiBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gQm9vbGVhbi52YWx1ZU9mKHRoaXMuc3ViamVjdC5pc0V2aWwoKSk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCB2b2lkIHNldFZhbHVlXyhCb29sZWFuIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldEV2aWwodmFsdWUuYm9vbGVhblZhbHVlKCkpOwotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiByYW5rIHNwaW5uZXIgKioqKioqKioqKgotCi0JcHJpdmF0ZSBKU3Bpbm5lciBidWlsZFJhbmtTcGlubmVyKCkgewotCQlyZXR1cm4gbmV3IEpTcGlubmVyKHRoaXMuYnVpbGRSYW5rU3Bpbm5lck1vZGVsKCkpOwotCX0KLQotCXByaXZhdGUgU3Bpbm5lck1vZGVsIGJ1aWxkUmFua1NwaW5uZXJNb2RlbCgpIHsKLQkJcmV0dXJuIG5ldyBOdW1iZXJTcGlubmVyTW9kZWxBZGFwdGVyKHRoaXMuYnVpbGRSYW5rQWRhcHRlcigpKTsKLQl9Ci0KLQlwcml2YXRlIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPE51bWJlcj4gYnVpbGRSYW5rQWRhcHRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8UGVyc29uLCBOdW1iZXI+KHRoaXMuc2VsZWN0ZWRQZXJzb25Ib2xkZXIsIFBlcnNvbi5SQU5LX1BST1BFUlRZKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBOdW1iZXIgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJcmV0dXJuIG5ldyBJbnRlZ2VyKHRoaXMuc3ViamVjdC5nZXRSYW5rKCkpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oTnVtYmVyIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldFJhbmsodmFsdWUuaW50VmFsdWUoKSk7Ci0JCQl9Ci0JCX07Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGFkdmVudHVyZSBjb3VudCBzcGlubmVyICoqKioqKioqKioKLQotCXByaXZhdGUgSlNwaW5uZXIgYnVpbGRBZHZlbnR1cmVDb3VudFNwaW5uZXIoKSB7Ci0JCXJldHVybiBuZXcgSlNwaW5uZXIodGhpcy5idWlsZEFkdmVudHVyZUNvdW50U3Bpbm5lck1vZGVsKCkpOwotCX0KLQotCXByaXZhdGUgU3Bpbm5lck1vZGVsIGJ1aWxkQWR2ZW50dXJlQ291bnRTcGlubmVyTW9kZWwoKSB7Ci0JCXJldHVybiBuZXcgTnVtYmVyU3Bpbm5lck1vZGVsQWRhcHRlcih0aGlzLmJ1aWxkQWR2ZW50dXJlQ291bnRBZGFwdGVyKCkpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8TnVtYmVyPiBidWlsZEFkdmVudHVyZUNvdW50QWRhcHRlcigpIHsKLQkJcmV0dXJuIG5ldyBQcm9wZXJ0eUFzcGVjdEFkYXB0ZXI8UGVyc29uLCBOdW1iZXI+KHRoaXMuc2VsZWN0ZWRQZXJzb25Ib2xkZXIsIFBlcnNvbi5BRFZFTlRVUkVfQ09VTlRfUFJPUEVSVFkpIHsKLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIE51bWJlciBidWlsZFZhbHVlXygpIHsKLQkJCQlyZXR1cm4gbmV3IEludGVnZXIodGhpcy5zdWJqZWN0LmdldEFkdmVudHVyZUNvdW50KCkpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oTnVtYmVyIHZhbHVlKSB7Ci0JCQkJdGhpcy5zdWJqZWN0LnNldEFkdmVudHVyZUNvdW50KHZhbHVlLmludFZhbHVlKCkpOwotCQkJfQotCQl9OwotCX0KLQotCi0JLy8gKioqKioqKioqKiBxdWVyaWVzICoqKioqKioqKioKLQotCXByaXZhdGUgQ3Jvd2QgY3Jvd2QoKSB7Ci0JCXJldHVybiB0aGlzLmNyb3dkSG9sZGVyLmdldFZhbHVlKCk7Ci0JfQotCi0JcHJpdmF0ZSBQZXJzb24gc2VsZWN0ZWRQZXJzb24oKSB7Ci0JCWlmICh0aGlzLnJvd1NlbGVjdGlvbk1vZGVsLmlzU2VsZWN0aW9uRW1wdHkoKSkgewotCQkJcmV0dXJuIG51bGw7Ci0JCX0KLQkJcmV0dXJuIChQZXJzb24pIHRoaXMucm93U2VsZWN0aW9uTW9kZWwuc2VsZWN0ZWRWYWx1ZSgpOwotCX0KLQotCXByaXZhdGUgdm9pZCBzZXRTZWxlY3RlZFBlcnNvbihQZXJzb24gcGVyc29uKSB7Ci0JCXRoaXMucm93U2VsZWN0aW9uTW9kZWwuc2V0U2VsZWN0ZWRWYWx1ZShwZXJzb24pOwotCX0KLQotCi0JLy8gKioqKioqKioqKiBjdXN0b20gcmVuZGVyZXIgKioqKioqKioqKgotCQotCS8qKgotCSAqIFRoaXMgaXMgc2ltcGx5IGFuIGV4YW1wbGUgb2YgYSByZW5kZXJlciBmb3IgdGhlIGVtYmVkZGVkIGNvbWJvLWJveC4KLQkgKiBJdCBkb2VzIG5vdGhpbmcgc3BlY2lhbCB1bmxlc3MgeW91IHVuY29tbWVudCB0aGUgY29kZSBiZWxvdy4uLi4KLQkgKi8KLQlwcml2YXRlIGNsYXNzIEV5ZUNvbG9yUmVuZGVyZXIgZXh0ZW5kcyBEZWZhdWx0TGlzdENlbGxSZW5kZXJlciB7Ci0JCUV5ZUNvbG9yUmVuZGVyZXIoKSB7Ci0JCQlzdXBlcigpOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgQ29tcG9uZW50IGdldExpc3RDZWxsUmVuZGVyZXJDb21wb25lbnQoSkxpc3QgbGlzdCwgT2JqZWN0IHZhbHVlLCBpbnQgaW5kZXgsIGJvb2xlYW4gaXNTZWxlY3RlZCwgYm9vbGVhbiBjZWxsSGFzRm9jdXMpIHsKLQkJCS8vIGp1c3QgZG8gc29tZXRoaW5nIHRvIHNob3cgdGhlIHJlbmRlcmVyIGlzIHdvcmtpbmcuLi4KLQkvLwkJdmFsdWUgPSAiPiIgKyB2YWx1ZTsKLQkJCXJldHVybiBzdXBlci5nZXRMaXN0Q2VsbFJlbmRlcmVyQ29tcG9uZW50KGxpc3QsIHZhbHVlLCBpbmRleCwgaXNTZWxlY3RlZCwgY2VsbEhhc0ZvY3VzKTsKLQkJfQotCX0KLQotfQpkaWZmIC0tZ2l0IGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9UcmVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvVHJlZU1vZGVsQWRhcHRlclRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDI5MWM5YmMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9tb2RlbC92YWx1ZS9zd2luZy9UcmVlTW9kZWxBZGFwdGVyVGVzdHMuamF2YQorKysgL2Rldi9udWxsCkBAIC0xLDgxNCArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3LCAyMDA4IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nOwotCi1pbXBvcnQgamF2YS5pby5PdXRwdXRTdHJlYW07Ci1pbXBvcnQgamF2YS5pby5PdXRwdXRTdHJlYW1Xcml0ZXI7Ci1pbXBvcnQgamF2YS5pby5TdHJpbmdXcml0ZXI7Ci1pbXBvcnQgamF2YS51dGlsLkFycmF5czsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YXguc3dpbmcuSWNvbjsKLWltcG9ydCBqYXZheC5zd2luZy5KVHJlZTsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5UcmVlTW9kZWxFdmVudDsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5UcmVlTW9kZWxMaXN0ZW5lcjsKLWltcG9ydCBqYXZheC5zd2luZy50cmVlLlRyZWVNb2RlbDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdENhc2U7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuSGFzaEJhZzsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5JbmRlbnRpbmdQcmludFdyaXRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5TdHJpbmdUb29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuUmVhZE9ubHlJdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC5BYnN0cmFjdE1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkFic3RyYWN0VHJlZU5vZGVWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25Bc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLkl0ZW1Qcm9wZXJ0eUxpc3RWYWx1ZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5OdWxsTGlzdFZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuUHJvcGVydHlBc3BlY3RBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZUxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5Tb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuU3RhdGljUHJvcGVydHlWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLlRyYW5zZm9ybWF0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLlRyZWVNb2RlbEFkYXB0ZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwuc3dpbmcuRGlzcGxheWFibGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwuZXZlbnQuUHJvcGVydHlDaGFuZ2VFdmVudDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5MaXN0Q2hhbmdlTGlzdGVuZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwubGlzdGVuZXIuUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC5saXN0ZW5lci5TdGF0ZUNoYW5nZUxpc3RlbmVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkNvbGxlY3Rpb25WYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLkxpc3RWYWx1ZU1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5Lm1vZGVsLnZhbHVlLlByb3BlcnR5VmFsdWVNb2RlbDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5UcmVlTm9kZVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci0KLS8qKgotICogCi0gKi8KLXB1YmxpYyBjbGFzcyBUcmVlTW9kZWxBZGFwdGVyVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JYm9vbGVhbiBldmVudEZpcmVkOwotCi0JcHVibGljIFRyZWVNb2RlbEFkYXB0ZXJUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0R2V0Um9vdCgpIHsKLQkJVHJlZU1vZGVsIHRyZWVNb2RlbCA9IHRoaXMuYnVpbGRTb3J0ZWRUcmVlTW9kZWwoKTsKLQkJdHJlZU1vZGVsLmFkZFRyZWVNb2RlbExpc3RlbmVyKG5ldyBUZXN0VHJlZU1vZGVsTGlzdGVuZXIoKSk7Ci0JCVRlc3ROb2RlIHJvb3ROb2RlID0gKFRlc3ROb2RlKSB0cmVlTW9kZWwuZ2V0Um9vdCgpOwotCQlUZXN0TW9kZWwgcm9vdCA9IHJvb3ROb2RlLmdldFRlc3RNb2RlbCgpOwotCQlhc3NlcnRFcXVhbHMoInJvb3QiLCByb290LmdldE5hbWUoKSk7Ci0vLwkJcm9vdC5kdW1wKCk7Ci0vLwkJcm9vdE5vZGUuZHVtcCgpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRDaGlsZCgpIHsKLQkJVHJlZU1vZGVsIHRyZWVNb2RlbCA9IHRoaXMuYnVpbGRTb3J0ZWRUcmVlTW9kZWwoKTsKLQkJdHJlZU1vZGVsLmFkZFRyZWVNb2RlbExpc3RlbmVyKG5ldyBUZXN0VHJlZU1vZGVsTGlzdGVuZXIoKSk7Ci0JCVRlc3ROb2RlIHJvb3ROb2RlID0gKFRlc3ROb2RlKSB0cmVlTW9kZWwuZ2V0Um9vdCgpOwotCi0JCVRlc3ROb2RlIGV4cGVjdGVkID0gcm9vdE5vZGUuY2hpbGROYW1lZCgibm9kZSAxIik7Ci0JCVRlc3ROb2RlIGFjdHVhbCA9IChUZXN0Tm9kZSkgdHJlZU1vZGVsLmdldENoaWxkKHJvb3ROb2RlLCAxKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBhY3R1YWwpOwotCi0JCWV4cGVjdGVkID0gcm9vdE5vZGUuY2hpbGROYW1lZCgibm9kZSAyIik7Ci0JCWFjdHVhbCA9IChUZXN0Tm9kZSkgdHJlZU1vZGVsLmdldENoaWxkKHJvb3ROb2RlLCAyKTsKLQkJYXNzZXJ0RXF1YWxzKGV4cGVjdGVkLCBhY3R1YWwpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRDaGlsZENvdW50KCkgewotCQlUcmVlTW9kZWwgdHJlZU1vZGVsID0gdGhpcy5idWlsZFNvcnRlZFRyZWVNb2RlbCgpOwotCQl0cmVlTW9kZWwuYWRkVHJlZU1vZGVsTGlzdGVuZXIobmV3IFRlc3RUcmVlTW9kZWxMaXN0ZW5lcigpKTsKLQkJVGVzdE5vZGUgcm9vdE5vZGUgPSAoVGVzdE5vZGUpIHRyZWVNb2RlbC5nZXRSb290KCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDUsIHRyZWVNb2RlbC5nZXRDaGlsZENvdW50KHJvb3ROb2RlKSk7Ci0KLQkJVGVzdE5vZGUgbm9kZSA9IHJvb3ROb2RlLmNoaWxkTmFtZWQoIm5vZGUgMSIpOwotCQlhc3NlcnRFcXVhbHMoMSwgdHJlZU1vZGVsLmdldENoaWxkQ291bnQobm9kZSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RHZXRJbmRleE9mQ2hpbGQoKSB7Ci0JCVRyZWVNb2RlbCB0cmVlTW9kZWwgPSB0aGlzLmJ1aWxkU29ydGVkVHJlZU1vZGVsKCk7Ci0JCXRyZWVNb2RlbC5hZGRUcmVlTW9kZWxMaXN0ZW5lcihuZXcgVGVzdFRyZWVNb2RlbExpc3RlbmVyKCkpOwotCQlUZXN0Tm9kZSByb290Tm9kZSA9IChUZXN0Tm9kZSkgdHJlZU1vZGVsLmdldFJvb3QoKTsKLQotCQlUZXN0Tm9kZSBjaGlsZCA9IHJvb3ROb2RlLmNoaWxkTmFtZWQoIm5vZGUgMCIpOwotCQlhc3NlcnRFcXVhbHMoMCwgdHJlZU1vZGVsLmdldEluZGV4T2ZDaGlsZChyb290Tm9kZSwgY2hpbGQpKTsKLQotCQljaGlsZCA9IHJvb3ROb2RlLmNoaWxkTmFtZWQoIm5vZGUgMSIpOwotCQlhc3NlcnRFcXVhbHMoMSwgdHJlZU1vZGVsLmdldEluZGV4T2ZDaGlsZChyb290Tm9kZSwgY2hpbGQpKTsKLQotCQljaGlsZCA9IHJvb3ROb2RlLmNoaWxkTmFtZWQoIm5vZGUgMiIpOwotCQlhc3NlcnRFcXVhbHMoMiwgdHJlZU1vZGVsLmdldEluZGV4T2ZDaGlsZChyb290Tm9kZSwgY2hpbGQpKTsKLQkJVGVzdE5vZGUgZ3JhbmRjaGlsZCA9IGNoaWxkLmNoaWxkTmFtZWQoIm5vZGUgMi4yIik7Ci0JCWFzc2VydEVxdWFscygyLCB0cmVlTW9kZWwuZ2V0SW5kZXhPZkNoaWxkKGNoaWxkLCBncmFuZGNoaWxkKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdElzTGVhZigpIHsKLQkJVHJlZU1vZGVsIHRyZWVNb2RlbCA9IHRoaXMuYnVpbGRTb3J0ZWRUcmVlTW9kZWwoKTsKLQkJdHJlZU1vZGVsLmFkZFRyZWVNb2RlbExpc3RlbmVyKG5ldyBUZXN0VHJlZU1vZGVsTGlzdGVuZXIoKSk7Ci0JCVRlc3ROb2RlIHJvb3ROb2RlID0gKFRlc3ROb2RlKSB0cmVlTW9kZWwuZ2V0Um9vdCgpOwotCQlhc3NlcnRGYWxzZSh0cmVlTW9kZWwuaXNMZWFmKHJvb3ROb2RlKSk7Ci0JCVRlc3ROb2RlIG5vZGUgPSByb290Tm9kZS5jaGlsZE5hbWVkKCJub2RlIDEiKTsKLQkJYXNzZXJ0RmFsc2UodHJlZU1vZGVsLmlzTGVhZihub2RlKSk7Ci0JCW5vZGUgPSByb290Tm9kZS5jaGlsZE5hbWVkKCJub2RlIDMiKTsKLQkJYXNzZXJ0VHJ1ZSh0cmVlTW9kZWwuaXNMZWFmKG5vZGUpKTsKLQl9Ci0KLQotCXB1YmxpYyB2b2lkIHRlc3RUcmVlTm9kZXNDaGFuZ2VkKCkgewotCQkvLyB0aGUgb25seSB3YXkgdG8gdHJpZ2dlciBhICJub2RlIGNoYW5nZWQiIGV2ZW50IGlzIHRvIHVzZSBhbiB1bnNvcnRlZCB0cmVlOwotCQkvLyBhIHNvcnRlZCB0cmVlIHdpbGwgd2lsbCB0cmlnZ2VyIG9ubHkgIm5vZGUgcmVtb3ZlZCIgYW5kICJub2RlIGluc2VydGVkIiBldmVudHMKLQkJVHJlZU1vZGVsIHRyZWVNb2RlbCA9IHRoaXMuYnVpbGRVbnNvcnRlZFRyZWVNb2RlbCgpOwotCQl0aGlzLmV2ZW50RmlyZWQgPSBmYWxzZTsKLQkJdHJlZU1vZGVsLmFkZFRyZWVNb2RlbExpc3RlbmVyKG5ldyBUZXN0VHJlZU1vZGVsTGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHRyZWVOb2Rlc0NoYW5nZWQoVHJlZU1vZGVsRXZlbnQgZSkgewotCQkJCVRyZWVNb2RlbEFkYXB0ZXJUZXN0cy50aGlzLmV2ZW50RmlyZWQgPSB0cnVlOwotCQkJfQotCQl9KTsKLQkJVGVzdE5vZGUgcm9vdE5vZGUgPSAoVGVzdE5vZGUpIHRyZWVNb2RlbC5nZXRSb290KCk7Ci0JCVRlc3ROb2RlIG5vZGUgPSByb290Tm9kZS5jaGlsZE5hbWVkKCJub2RlIDEiKTsKLQkJVGVzdE1vZGVsIHRtID0gbm9kZS5nZXRUZXN0TW9kZWwoKTsKLQkJdG0uc2V0TmFtZSgibm9kZSAxKysiKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmV2ZW50RmlyZWQpOwotCi0JCXRoaXMuZXZlbnRGaXJlZCA9IGZhbHNlOwotCQlub2RlID0gbm9kZS5jaGlsZE5hbWVkKCJub2RlIDEuMSIpOwotCQl0bSA9IG5vZGUuZ2V0VGVzdE1vZGVsKCk7Ci0JCXRtLnNldE5hbWUoIm5vZGUgMS4xKysiKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmV2ZW50RmlyZWQpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RUcmVlTm9kZXNJbnNlcnRlZCgpIHsKLQkJLy8gdXNlIGFuIHVuc29ydGVkIHRyZWUgc28gdGhlIG5vZGVzIGFyZSBub3QgcmUtc2h1ZmZsZWQuLi4KLQkJVHJlZU1vZGVsIHRyZWVNb2RlbCA9IHRoaXMuYnVpbGRVbnNvcnRlZFRyZWVNb2RlbCgpOwotCQl0aGlzLmV2ZW50RmlyZWQgPSBmYWxzZTsKLQkJdHJlZU1vZGVsLmFkZFRyZWVNb2RlbExpc3RlbmVyKG5ldyBUZXN0VHJlZU1vZGVsTGlzdGVuZXIoKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHRyZWVOb2Rlc0luc2VydGVkKFRyZWVNb2RlbEV2ZW50IGUpIHsKLQkJCQlUcmVlTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCX0KLQkJfSk7Ci0JCVRlc3ROb2RlIHJvb3ROb2RlID0gKFRlc3ROb2RlKSB0cmVlTW9kZWwuZ2V0Um9vdCgpOwotCQlUZXN0Tm9kZSBub2RlID0gcm9vdE5vZGUuY2hpbGROYW1lZCgibm9kZSAxIik7Ci0JCVRlc3RNb2RlbCB0bSA9IG5vZGUuZ2V0VGVzdE1vZGVsKCk7Ci0JCXRtLmFkZENoaWxkKCJuZXcgY2hpbGQuLi4iKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLmV2ZW50RmlyZWQpOwotCi0JCXRoaXMuZXZlbnRGaXJlZCA9IGZhbHNlOwotCQlub2RlID0gbm9kZS5jaGlsZE5hbWVkKCJub2RlIDEuMSIpOwotCQl0bSA9IG5vZGUuZ2V0VGVzdE1vZGVsKCk7Ci0JCXRtLmFkZENoaWxkKCJhbm90aGVyIG5ldyBjaGlsZC4uLiIpOwotCQlhc3NlcnRUcnVlKHRoaXMuZXZlbnRGaXJlZCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFRyZWVOb2Rlc1JlbW92ZWQoKSB7Ci0JCVRyZWVNb2RlbCB0cmVlTW9kZWwgPSB0aGlzLmJ1aWxkVW5zb3J0ZWRUcmVlTW9kZWwoKTsKLQkJdGhpcy5ldmVudEZpcmVkID0gZmFsc2U7Ci0JCXRyZWVNb2RlbC5hZGRUcmVlTW9kZWxMaXN0ZW5lcihuZXcgVGVzdFRyZWVNb2RlbExpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCB0cmVlTm9kZXNSZW1vdmVkKFRyZWVNb2RlbEV2ZW50IGUpIHsKLQkJCQlUcmVlTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCX0KLQkJfSk7Ci0JCVRlc3ROb2RlIHJvb3ROb2RlID0gKFRlc3ROb2RlKSB0cmVlTW9kZWwuZ2V0Um9vdCgpOwotCQlUZXN0TW9kZWwgcm9vdCA9IHJvb3ROb2RlLmdldFRlc3RNb2RlbCgpOwotCQlyb290LnJlbW92ZUNoaWxkKHJvb3QuY2hpbGROYW1lZCgibm9kZSAzIikpOwotCQlhc3NlcnRUcnVlKHRoaXMuZXZlbnRGaXJlZCk7Ci0KLQkJdGhpcy5ldmVudEZpcmVkID0gZmFsc2U7Ci0JCVRlc3ROb2RlIG5vZGUgPSByb290Tm9kZS5jaGlsZE5hbWVkKCJub2RlIDIiKTsKLQkJVGVzdE1vZGVsIHRtID0gbm9kZS5nZXRUZXN0TW9kZWwoKTsKLQkJdG0ucmVtb3ZlQ2hpbGQodG0uY2hpbGROYW1lZCgibm9kZSAyLjIiKSk7Ci0JCWFzc2VydFRydWUodGhpcy5ldmVudEZpcmVkKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0VHJlZVN0cnVjdHVyZUNoYW5nZWQoKSB7Ci0JCVdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFRyZWVOb2RlVmFsdWVNb2RlbDxPYmplY3Q+PiBub2RlSG9sZGVyID0gbmV3IFNpbXBsZVByb3BlcnR5VmFsdWVNb2RlbDxUcmVlTm9kZVZhbHVlTW9kZWw8T2JqZWN0Pj4odGhpcy5idWlsZFNvcnRlZFJvb3ROb2RlKCkpOwotCQlUcmVlTW9kZWwgdHJlZU1vZGVsID0gdGhpcy5idWlsZFRyZWVNb2RlbChub2RlSG9sZGVyKTsKLQkJdGhpcy5ldmVudEZpcmVkID0gZmFsc2U7Ci0JCXRyZWVNb2RlbC5hZGRUcmVlTW9kZWxMaXN0ZW5lcihuZXcgVGVzdFRyZWVNb2RlbExpc3RlbmVyKCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCB0cmVlTm9kZXNJbnNlcnRlZChUcmVlTW9kZWxFdmVudCBlKSB7Ci0JCQkJLy8gZG8gbm90aGluZwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgdm9pZCB0cmVlTm9kZXNSZW1vdmVkKFRyZWVNb2RlbEV2ZW50IGUpIHsKLQkJCQkvLyBkbyBub3RoaW5nCi0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXB1YmxpYyB2b2lkIHRyZWVTdHJ1Y3R1cmVDaGFuZ2VkKFRyZWVNb2RlbEV2ZW50IGUpIHsKLQkJCQlUcmVlTW9kZWxBZGFwdGVyVGVzdHMudGhpcy5ldmVudEZpcmVkID0gdHJ1ZTsKLQkJCX0KLQkJfSk7Ci0JCW5vZGVIb2xkZXIuc2V0VmFsdWUodGhpcy5idWlsZFVuc29ydGVkUm9vdE5vZGUoKSk7Ci0JCWFzc2VydFRydWUodGhpcy5ldmVudEZpcmVkKTsKLQl9Ci0KLQkvKioKLQkgKiB0ZXN0IGEgcHJvYmxlbSB3ZSBoYWQgd2hlcmUgcmVtb3ZpbmcgYSBjaGlsZCBmcm9tIGEgdHJlZSB3b3VsZCBjYXVzZQotCSAqIHRoZSBKVHJlZSB0byBjYWxsICNlcXVhbHMoT2JqZWN0KSBvbiBlYWNoIG5vZGUgcmVtb3ZlZCAoYWN0dWFsbHksIGl0IHdhcwotCSAqIFRyZWVQYXRoLCBidXQgdGhhdCB3YXMgYmVjYXVzZSBpdHMgb3duICNlcXVhbHMoT2JqZWN0KSB3YXMgY2FsbGVkIGJ5Ci0JICogSlRyZWUpOyBhbmQgc2luY2Ugd2UgaGFkIGFscmVhZHkgcmVtb3ZlZCB0aGUgbGFzdCBsaXN0ZW5lciBmcm9tIHRoZQotCSAqIGFzcGVjdCBhZGFwdGVyLCB0aGUgYXNwZWN0IGFkYXB0ZXIgd291bGQgc2F5IGl0cyB2YWx1ZSB3YXMgbnVsbDsgdGhpcwotCSAqIHdvdWxkIGNhdXNlIGEgTlBFIHVudGlsIHdlIHR3ZWFrZWQgVHJlZU1vZGVsQWRhcHRlciB0byByZW1vdmUgaXRzCi0JICogbGlzdGVuZXJzIGZyb20gYSBub2RlIG9ubHkgKmFmdGVyKiB0aGUgbm9kZSBoYWQgYmVlbiBjb21wbGV0ZWx5Ci0JICogcmVtb3ZlZCBmcm9tIHRoZSBKVHJlZQotCSAqIEBzZWUgVHJlZU1vZGVsQWRhcHRlciNyZW1vdmVOb2RlKE9iamVjdFtdLCBpbnQsIFRyZWVOb2RlVmFsdWVNb2RlbCkKLQkgKiBAc2VlIFRyZWVNb2RlbEFkYXB0ZXIjYWRkTm9kZShPYmplY3RbXSwgaW50LCBUcmVlTm9kZVZhbHVlTW9kZWwpCi0JICovCi0JcHVibGljIHZvaWQgdGVzdExhenlJbml0aWFsaXphdGlvbigpIHsKLQkJVHJlZU1vZGVsIHRyZWVNb2RlbCA9IHRoaXMuYnVpbGRTcGVjaWFsVHJlZU1vZGVsKCk7Ci0JCUpUcmVlIGpUcmVlID0gbmV3IEpUcmVlKHRyZWVNb2RlbCk7Ci0JCVRlc3ROb2RlIHJvb3ROb2RlID0gKFRlc3ROb2RlKSB0cmVlTW9kZWwuZ2V0Um9vdCgpOwotCQlUZXN0TW9kZWwgcm9vdCA9IHJvb3ROb2RlLmdldFRlc3RNb2RlbCgpOwotCQkvLyB0aGlzIHdvdWxkIGNhdXNlIGEgTlBFOgotCQlyb290LnJlbW92ZUNoaWxkKHJvb3QuY2hpbGROYW1lZCgibm9kZSAzIikpOwotCQlhc3NlcnRFcXVhbHModHJlZU1vZGVsLCBqVHJlZS5nZXRNb2RlbCgpKTsKLQl9Ci0KLQotCXByaXZhdGUgVHJlZU1vZGVsIGJ1aWxkU29ydGVkVHJlZU1vZGVsKCkgewotCQlyZXR1cm4gdGhpcy5idWlsZFRyZWVNb2RlbCh0aGlzLmJ1aWxkU29ydGVkUm9vdE5vZGUoKSk7Ci0JfQotCi0JcHJpdmF0ZSBUZXN0Tm9kZSBidWlsZFNvcnRlZFJvb3ROb2RlKCkgewotCQlyZXR1cm4gbmV3IFNvcnRlZFRlc3ROb2RlKHRoaXMuYnVpbGRSb290KCkpOwotCX0KLQotCXByaXZhdGUgVHJlZU1vZGVsIGJ1aWxkVW5zb3J0ZWRUcmVlTW9kZWwoKSB7Ci0JCXJldHVybiB0aGlzLmJ1aWxkVHJlZU1vZGVsKHRoaXMuYnVpbGRVbnNvcnRlZFJvb3ROb2RlKCkpOwotCX0KLQotCXByaXZhdGUgVGVzdE5vZGUgYnVpbGRVbnNvcnRlZFJvb3ROb2RlKCkgewotCQlyZXR1cm4gbmV3IFVuc29ydGVkVGVzdE5vZGUodGhpcy5idWlsZFJvb3QoKSk7Ci0JfQotCi0JcHJpdmF0ZSBUcmVlTW9kZWwgYnVpbGRTcGVjaWFsVHJlZU1vZGVsKCkgewotCQlyZXR1cm4gdGhpcy5idWlsZFRyZWVNb2RlbCh0aGlzLmJ1aWxkU3BlY2lhbFJvb3ROb2RlKCkpOwotCX0KLQotCXByaXZhdGUgVGVzdE5vZGUgYnVpbGRTcGVjaWFsUm9vdE5vZGUoKSB7Ci0JCXJldHVybiBuZXcgU3BlY2lhbFRlc3ROb2RlKHRoaXMuYnVpbGRSb290KCkpOwotCX0KLQotCXByaXZhdGUgVGVzdE1vZGVsIGJ1aWxkUm9vdCgpIHsKLQkJVGVzdE1vZGVsIHJvb3QgPSBuZXcgVGVzdE1vZGVsKCJyb290Iik7Ci0JCS8qTm9kZSBub2RlXzAgPSAqL3Jvb3QuYWRkQ2hpbGQoIm5vZGUgMCIpOwotCQlUZXN0TW9kZWwgbm9kZV8xID0gcm9vdC5hZGRDaGlsZCgibm9kZSAxIik7Ci0JCVRlc3RNb2RlbCBub2RlXzFfMSA9IG5vZGVfMS5hZGRDaGlsZCgibm9kZSAxLjEiKTsKLQkJLypOb2RlIG5vZGVfMV8xXzEgPSAqL25vZGVfMV8xLmFkZENoaWxkKCJub2RlIDEuMS4xIik7Ci0JCVRlc3RNb2RlbCBub2RlXzIgPSByb290LmFkZENoaWxkKCJub2RlIDIiKTsKLQkJLypOb2RlIG5vZGVfMl8wID0gKi9ub2RlXzIuYWRkQ2hpbGQoIm5vZGUgMi4wIik7Ci0JCS8qTm9kZSBub2RlXzJfMSA9ICovbm9kZV8yLmFkZENoaWxkKCJub2RlIDIuMSIpOwotCQkvKk5vZGUgbm9kZV8yXzIgPSAqL25vZGVfMi5hZGRDaGlsZCgibm9kZSAyLjIiKTsKLQkJLypOb2RlIG5vZGVfMl8zID0gKi9ub2RlXzIuYWRkQ2hpbGQoIm5vZGUgMi4zIik7Ci0JCS8qTm9kZSBub2RlXzJfNCA9ICovbm9kZV8yLmFkZENoaWxkKCJub2RlIDIuNCIpOwotCQkvKk5vZGUgbm9kZV8yXzUgPSAqL25vZGVfMi5hZGRDaGlsZCgibm9kZSAyLjUiKTsKLQkJLypOb2RlIG5vZGVfMyA9ICovcm9vdC5hZGRDaGlsZCgibm9kZSAzIik7Ci0JCS8qTm9kZSBub2RlXzQgPSAqL3Jvb3QuYWRkQ2hpbGQoIm5vZGUgNCIpOwotCQlyZXR1cm4gcm9vdDsKLQl9Ci0KLQotCS8vICoqKioqKioqKiogbWVtYmVyIGNsYXNzZXMgKioqKioqKioqKgotCi0JLyoqCi0JICogVGhpcyBpcyBhIHR5cGljYWwgbW9kZWwgY2xhc3Mgd2l0aCB0aGUgdHlwaWNhbCBjaGFuZ2Ugbm90aWZpY2F0aW9ucwotCSAqIGZvciAjbmFtZSBhbmQgI2NoaWxkcmVuLgotCSAqLwotCXB1YmxpYyBzdGF0aWMgY2xhc3MgVGVzdE1vZGVsIGV4dGVuZHMgQWJzdHJhY3RNb2RlbCB7Ci0KLQkJLy8gdGhlICBwYXJlbnQgaXMgaW1tdXRhYmxlOyB0aGUgcm9vdCdzIHBhcmVudCBpcyBudWxsCi0JCXByaXZhdGUgZmluYWwgVGVzdE1vZGVsIHBhcmVudDsKLQotCQkvLyB0aGUgbmFtZSBpcyBtdXRhYmxlOyBzbyBJIGd1ZXNzIGl0IGlzbid0IHRoZSAicHJpbWFyeSBrZXkiIDotKQotCQlwcml2YXRlIFN0cmluZyBuYW1lOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgTkFNRV9QUk9QRVJUWSA9ICJuYW1lIjsKLQotCQlwcml2YXRlIGZpbmFsIENvbGxlY3Rpb248VGVzdE1vZGVsPiBjaGlsZHJlbjsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIENISUxEUkVOX0NPTExFQ1RJT04gPSAiY2hpbGRyZW4iOwotCi0KLQkJcHVibGljIFRlc3RNb2RlbChTdHJpbmcgbmFtZSkgewkvLyByb290IGN0b3IKLQkJCXRoaXMobnVsbCwgbmFtZSk7Ci0JCX0KLQkJcHJpdmF0ZSBUZXN0TW9kZWwoVGVzdE1vZGVsIHBhcmVudCwgU3RyaW5nIG5hbWUpIHsKLQkJCXN1cGVyKCk7Ci0JCQl0aGlzLnBhcmVudCA9IHBhcmVudDsKLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCQl0aGlzLmNoaWxkcmVuID0gbmV3IEhhc2hCYWc8VGVzdE1vZGVsPigpOwotCQl9Ci0KLQkJcHVibGljIFRlc3RNb2RlbCBnZXRQYXJlbnQoKSB7Ci0JCQlyZXR1cm4gdGhpcy5wYXJlbnQ7Ci0JCX0KLQotCQlwdWJsaWMgU3RyaW5nIGdldE5hbWUoKSB7Ci0JCQlyZXR1cm4gdGhpcy5uYW1lOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHNldE5hbWUoU3RyaW5nIG5hbWUpIHsKLQkJCU9iamVjdCBvbGQgPSB0aGlzLm5hbWU7Ci0JCQl0aGlzLm5hbWUgPSBuYW1lOwotCQkJdGhpcy5maXJlUHJvcGVydHlDaGFuZ2VkKE5BTUVfUFJPUEVSVFksIG9sZCwgbmFtZSk7Ci0JCX0KLQotCQlwdWJsaWMgSXRlcmF0b3I8VGVzdE1vZGVsPiBjaGlsZHJlbigpIHsKLQkJCXJldHVybiBuZXcgUmVhZE9ubHlJdGVyYXRvcjxUZXN0TW9kZWw+KHRoaXMuY2hpbGRyZW4pOwotCQl9Ci0JCXB1YmxpYyBpbnQgY2hpbGRyZW5TaXplKCkgewotCQkJcmV0dXJuIHRoaXMuY2hpbGRyZW4uc2l6ZSgpOwotCQl9Ci0JCXB1YmxpYyBUZXN0TW9kZWwgYWRkQ2hpbGQoU3RyaW5nIGNoaWxkTmFtZSkgewotCQkJVGVzdE1vZGVsIGNoaWxkID0gbmV3IFRlc3RNb2RlbCh0aGlzLCBjaGlsZE5hbWUpOwotCQkJdGhpcy5hZGRJdGVtVG9Db2xsZWN0aW9uKGNoaWxkLCB0aGlzLmNoaWxkcmVuLCBDSElMRFJFTl9DT0xMRUNUSU9OKTsKLQkJCXJldHVybiBjaGlsZDsKLQkJfQotCQlwdWJsaWMgVGVzdE1vZGVsW10gYWRkQ2hpbGRyZW4oU3RyaW5nW10gY2hpbGROYW1lcykgewotCQkJVGVzdE1vZGVsW10gbmV3Q2hpbGRyZW4gPSBuZXcgVGVzdE1vZGVsW2NoaWxkTmFtZXMubGVuZ3RoXTsKLQkJCWZvciAoaW50IGkgPSAwOyBpIDwgY2hpbGROYW1lcy5sZW5ndGg7IGkrKykgewotCQkJCW5ld0NoaWxkcmVuW2ldID0gbmV3IFRlc3RNb2RlbCh0aGlzLCBjaGlsZE5hbWVzW2ldKTsKLQkJCX0KLQkJCXRoaXMuYWRkSXRlbXNUb0NvbGxlY3Rpb24obmV3Q2hpbGRyZW4sIHRoaXMuY2hpbGRyZW4sIENISUxEUkVOX0NPTExFQ1RJT04pOwotCQkJcmV0dXJuIG5ld0NoaWxkcmVuOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHJlbW92ZUNoaWxkKFRlc3RNb2RlbCBjaGlsZCkgewotCQkJdGhpcy5yZW1vdmVJdGVtRnJvbUNvbGxlY3Rpb24oY2hpbGQsIHRoaXMuY2hpbGRyZW4sIENISUxEUkVOX0NPTExFQ1RJT04pOwotCQl9Ci0JCXB1YmxpYyB2b2lkIHJlbW92ZUNoaWxkcmVuKFRlc3RNb2RlbFtdIHRlc3RNb2RlbHMpIHsKLQkJCXRoaXMucmVtb3ZlSXRlbXNGcm9tQ29sbGVjdGlvbih0ZXN0TW9kZWxzLCB0aGlzLmNoaWxkcmVuLCBDSElMRFJFTl9DT0xMRUNUSU9OKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBjbGVhckNoaWxkcmVuKCkgewotCQkJdGhpcy5jbGVhckNvbGxlY3Rpb24odGhpcy5jaGlsZHJlbiwgQ0hJTERSRU5fQ09MTEVDVElPTik7Ci0JCX0KLQkJcHVibGljIFRlc3RNb2RlbCBjaGlsZE5hbWVkKFN0cmluZyBjaGlsZE5hbWUpIHsKLQkJCWZvciAoVGVzdE1vZGVsIGNoaWxkIDogdGhpcy5jaGlsZHJlbikgewotCQkJCWlmIChjaGlsZC5nZXROYW1lKCkuZXF1YWxzKGNoaWxkTmFtZSkpIHsKLQkJCQkJcmV0dXJuIGNoaWxkOwotCQkJCX0KLQkJCX0KLQkJCXRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKCJjaGlsZCBub3QgZm91bmQ6ICIgKyBjaGlsZE5hbWUpOwotCQl9Ci0KLQkJcHVibGljIFN0cmluZyBkdW1wU3RyaW5nKCkgewotCQkJU3RyaW5nV3JpdGVyIHN3ID0gbmV3IFN0cmluZ1dyaXRlcigpOwotCQkJSW5kZW50aW5nUHJpbnRXcml0ZXIgaXB3ID0gbmV3IEluZGVudGluZ1ByaW50V3JpdGVyKHN3KTsKLQkJCXRoaXMuZHVtcE9uKGlwdyk7Ci0JCQlyZXR1cm4gc3cudG9TdHJpbmcoKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBkdW1wT24oSW5kZW50aW5nUHJpbnRXcml0ZXIgd3JpdGVyKSB7Ci0JCQl3cml0ZXIucHJpbnRsbih0aGlzKTsKLQkJCXdyaXRlci5pbmRlbnQoKTsKLQkJCWZvciAoVGVzdE1vZGVsIGNoaWxkIDogdGhpcy5jaGlsZHJlbikgewotCQkJCWNoaWxkLmR1bXBPbih3cml0ZXIpOwotCQkJfQotCQkJd3JpdGVyLnVuZGVudCgpOwotCQl9Ci0JCXB1YmxpYyB2b2lkIGR1bXBPbihPdXRwdXRTdHJlYW0gc3RyZWFtKSB7Ci0JCQlJbmRlbnRpbmdQcmludFdyaXRlciB3cml0ZXIgPSBuZXcgSW5kZW50aW5nUHJpbnRXcml0ZXIobmV3IE91dHB1dFN0cmVhbVdyaXRlcihzdHJlYW0pKTsKLQkJCXRoaXMuZHVtcE9uKHdyaXRlcik7Ci0JCQl3cml0ZXIuZmx1c2goKTsKLQkJfQotCQlwdWJsaWMgdm9pZCBkdW1wKCkgewotCQkJdGhpcy5kdW1wT24oU3lzdGVtLm91dCk7Ci0JCX0KLQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKLQkJCXJldHVybiBTdHJpbmdUb29scy5idWlsZFRvU3RyaW5nRm9yKHRoaXMsIHRoaXMubmFtZSk7Ci0JCX0KLQotCX0KLQotCi0JLyoqCi0JICogVGhpcyBOb2RlIHdyYXBzIGEgVGVzdE1vZGVsIGFuZCBjb252ZXJ0cyBpbnRvIHNvbWV0aGluZyB0aGF0IGNhbgotCSAqIGJlIHVzZWQgYnkgVHJlZU1vZGVsQWRhcHRlci4gSXQgY29udmVydHMgY2hhbmdlcyB0byB0aGUgVGVzdE1vZGVsJ3MKLQkgKiBuYW1lIGludG8gInN0YXRlIGNoYW5nZXMiIHRvIHRoZSBOb2RlOyBhbmQgY29udmVydHMgdGhlCi0JICogVGVzdE1vZGVsJ3MgY2hpbGRyZW4gaW50byBhIExpc3RWYWx1ZU1vZGVsIG9mIE5vZGVzIHdob3NlIG9yZGVyIGlzCi0JICogZGV0ZXJtaW5lZCBieSBzdWJjbGFzcyBpbXBsZW1lbnRhdGlvbnMuCi0JICovCi0JcHVibGljIHN0YXRpYyBhYnN0cmFjdCBjbGFzcyBUZXN0Tm9kZSBleHRlbmRzIEFic3RyYWN0VHJlZU5vZGVWYWx1ZU1vZGVsPE9iamVjdD4gaW1wbGVtZW50cyBEaXNwbGF5YWJsZSB7Ci0JCS8qKiB0aGUgbW9kZWwgb2JqZWN0IHdyYXBwZWQgYnkgdGhpcyBub2RlICovCi0JCXByaXZhdGUgZmluYWwgVGVzdE1vZGVsIHRlc3RNb2RlbDsKLQkJLyoqIHRoaXMgbm9kZSdzIHBhcmVudCBub2RlOyBudWxsIGZvciB0aGUgcm9vdCBub2RlICovCi0JCXByaXZhdGUgZmluYWwgVGVzdE5vZGUgcGFyZW50OwotCQkvKiogdGhpcyBub2RlJ3MgY2hpbGQgbm9kZXMgKi8KLQkJcHJpdmF0ZSBmaW5hbCBMaXN0VmFsdWVNb2RlbDxUcmVlTm9kZVZhbHVlTW9kZWw8T2JqZWN0Pj4gY2hpbGRyZW5Nb2RlbDsKLQkJLyoqIGEgbGlzdGVuZXIgdGhhdCBub3RpZmllcyB1cyB3aGVuIHRoZSBtb2RlbCBvYmplY3QncyAiaW50ZXJuYWwgc3RhdGUiIGNoYW5nZXMgKi8KLQkJcHJpdmF0ZSBmaW5hbCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIHRlc3RNb2RlbExpc3RlbmVyOwotCi0KLQkJLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMvaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCi0JCS8qKgotCQkgKiByb290IG5vZGUgY29uc3RydWN0b3IKLQkJICovCi0JCXB1YmxpYyBUZXN0Tm9kZShUZXN0TW9kZWwgdGVzdE1vZGVsKSB7Ci0JCQl0aGlzKG51bGwsIHRlc3RNb2RlbCk7Ci0JCX0KLQotCQkvKioKLQkJICogYnJhbmNoIG9yIGxlYWYgbm9kZSBjb25zdHJ1Y3RvcgotCQkgKi8KLQkJcHVibGljIFRlc3ROb2RlKFRlc3ROb2RlIHBhcmVudCwgVGVzdE1vZGVsIHRlc3RNb2RlbCkgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMucGFyZW50ID0gcGFyZW50OwotCQkJdGhpcy50ZXN0TW9kZWwgPSB0ZXN0TW9kZWw7Ci0JCQl0aGlzLmNoaWxkcmVuTW9kZWwgPSB0aGlzLmJ1aWxkQ2hpbGRyZW5Nb2RlbCh0ZXN0TW9kZWwpOwotCQkJdGhpcy50ZXN0TW9kZWxMaXN0ZW5lciA9IHRoaXMuYnVpbGRUZXN0TW9kZWxMaXN0ZW5lcigpOwotCQl9Ci0KLQkJcHJpdmF0ZSBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkVGVzdE1vZGVsTGlzdGVuZXIoKSB7Ci0JCQlyZXR1cm4gbmV3IFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoKSB7Ci0JCQkJcHVibGljIHZvaWQgcHJvcGVydHlDaGFuZ2VkKFByb3BlcnR5Q2hhbmdlRXZlbnQgZSkgewotCQkJCQlUZXN0Tm9kZS50aGlzLnRlc3RNb2RlbENoYW5nZWQoZSk7Ci0JCQkJfQotCQkJfTsKLQkJfQotCi0JCS8qKgotCQkgKiBzdWJjbGFzc2VzIGRlY2lkZSB0aGUgb3JkZXIgb2YgdGhlIGNoaWxkIG5vZGVzCi0JCSAqLwotCQlwcm90ZWN0ZWQgYWJzdHJhY3QgTGlzdFZhbHVlTW9kZWw8VHJlZU5vZGVWYWx1ZU1vZGVsPE9iamVjdD4+IGJ1aWxkQ2hpbGRyZW5Nb2RlbChUZXN0TW9kZWwgbW9kZWwpOwotCi0JCS8qKgotCQkgKiB1c2VkIGJ5IHN1YmNsYXNzZXM7Ci0JCSAqIHRyYW5zZm9ybSB0aGUgdGVzdCBtb2RlbCBjaGlsZHJlbiBpbnRvIG5vZGVzCi0JCSAqLwotCQlwcm90ZWN0ZWQgTGlzdFZhbHVlTW9kZWw8VHJlZU5vZGVWYWx1ZU1vZGVsPE9iamVjdD4+IGJ1aWxkTm9kZUFkYXB0ZXIoVGVzdE1vZGVsIG1vZGVsKSB7Ci0JCQlyZXR1cm4gbmV3IFRyYW5zZm9ybWF0aW9uTGlzdFZhbHVlTW9kZWxBZGFwdGVyPFRlc3RNb2RlbCwgVHJlZU5vZGVWYWx1ZU1vZGVsPE9iamVjdD4+KHRoaXMuYnVpbGRDaGlsZHJlbkFkYXB0ZXIobW9kZWwpKSB7Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIFRlc3ROb2RlIHRyYW5zZm9ybUl0ZW0oVGVzdE1vZGVsIGl0ZW0pIHsKLQkJCQkJcmV0dXJuIFRlc3ROb2RlLnRoaXMuYnVpbGRDaGlsZE5vZGUoaXRlbSk7Ci0JCQkJfQotCQkJfTsKLQkJfQotCi0JCS8qKgotCQkgKiBzdWJjbGFzc2VzIG11c3QgYnVpbGQgYSBjb25jcmV0ZSBub2RlIGZvciB0aGUgc3BlY2lmaWVkIHRlc3QgbW9kZWwKLQkJICovCi0JCXByb3RlY3RlZCBhYnN0cmFjdCBUZXN0Tm9kZSBidWlsZENoaWxkTm9kZShUZXN0TW9kZWwgY2hpbGRUZXN0TW9kZWwpOwotCi0JCS8qKgotCQkgKiByZXR1cm4gYSBjb2xsZWN0aW9uIHZhbHVlIG1vZGVsIG9uIHRoZSBzcGVjaWZpZWQgbW9kZWwncyBjaGlsZHJlbgotCQkgKi8KLQkJcHJvdGVjdGVkIENvbGxlY3Rpb25WYWx1ZU1vZGVsPFRlc3RNb2RlbD4gYnVpbGRDaGlsZHJlbkFkYXB0ZXIoVGVzdE1vZGVsIG1vZGVsKSB7Ci0JCQlyZXR1cm4gbmV3IENvbGxlY3Rpb25Bc3BlY3RBZGFwdGVyPFRlc3RNb2RlbCwgVGVzdE1vZGVsPihUZXN0TW9kZWwuQ0hJTERSRU5fQ09MTEVDVElPTiwgbW9kZWwpIHsKLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgSXRlcmF0b3I8VGVzdE1vZGVsPiBpdGVyYXRvcl8oKSB7Ci0JCQkJCXJldHVybiB0aGlzLnN1YmplY3QuY2hpbGRyZW4oKTsKLQkJCQl9Ci0JCQkJQE92ZXJyaWRlCi0JCQkJcHJvdGVjdGVkIGludCBzaXplXygpIHsKLQkJCQkJcmV0dXJuIHRoaXMuc3ViamVjdC5jaGlsZHJlblNpemUoKTsKLQkJCQl9Ci0JCQl9OwotCQl9Ci0KLQotCQkvLyAqKioqKioqKioqIFRyZWVOb2RlVmFsdWVNb2RlbCBpbXBsZW1lbnRhdGlvbiAqKioqKioqKioqCi0KLQkJcHVibGljIFRlc3RNb2RlbCBnZXRWYWx1ZSgpIHsKLQkJCXJldHVybiB0aGlzLnRlc3RNb2RlbDsKLQkJfQotCi0JCXB1YmxpYyBUcmVlTm9kZVZhbHVlTW9kZWw8T2JqZWN0PiBwYXJlbnQoKSB7Ci0JCQlyZXR1cm4gdGhpcy5wYXJlbnQ7Ci0JCX0KLQotCQlwdWJsaWMgTGlzdFZhbHVlTW9kZWw8VHJlZU5vZGVWYWx1ZU1vZGVsPE9iamVjdD4+IGNoaWxkcmVuTW9kZWwoKSB7Ci0JCQlyZXR1cm4gdGhpcy5jaGlsZHJlbk1vZGVsOwotCQl9Ci0KLQotCQkvLyAqKioqKioqKioqIEFic3RyYWN0VHJlZU5vZGVWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIHZvaWQgZW5nYWdlVmFsdWUoKSB7Ci0JCQl0aGlzLnRlc3RNb2RlbC5hZGRQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyKFRlc3RNb2RlbC5OQU1FX1BST1BFUlRZLCB0aGlzLnRlc3RNb2RlbExpc3RlbmVyKTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgdm9pZCBkaXNlbmdhZ2VWYWx1ZSgpIHsKLQkJCXRoaXMudGVzdE1vZGVsLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoVGVzdE1vZGVsLk5BTUVfUFJPUEVSVFksIHRoaXMudGVzdE1vZGVsTGlzdGVuZXIpOwotCQl9Ci0KLQotCQkvLyAqKioqKioqKioqIERpc3BsYXlhYmxlIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCQlwdWJsaWMgU3RyaW5nIGRpc3BsYXlTdHJpbmcoKSB7Ci0JCQlyZXR1cm4gdGhpcy50ZXN0TW9kZWwuZ2V0TmFtZSgpOwotCQl9Ci0KLQkJcHVibGljIEljb24gaWNvbigpIHsKLQkJCXJldHVybiBudWxsOwotCQl9Ci0KLQotCQkvLyAqKioqKioqKioqIGRlYnVnZ2luZyBzdXBwb3J0ICoqKioqKioqKioKLQotCQlwdWJsaWMgU3RyaW5nIGR1bXBTdHJpbmcoKSB7Ci0JCQlTdHJpbmdXcml0ZXIgc3cgPSBuZXcgU3RyaW5nV3JpdGVyKCk7Ci0JCQlJbmRlbnRpbmdQcmludFdyaXRlciBpcHcgPSBuZXcgSW5kZW50aW5nUHJpbnRXcml0ZXIoc3cpOwotCQkJdGhpcy5kdW1wT24oaXB3KTsKLQkJCXJldHVybiBzdy50b1N0cmluZygpOwotCQl9Ci0KLQkJcHVibGljIHZvaWQgZHVtcE9uKEluZGVudGluZ1ByaW50V3JpdGVyIHdyaXRlcikgewotCQkJd3JpdGVyLnByaW50bG4odGhpcyk7Ci0JCQl3cml0ZXIuaW5kZW50KCk7Ci0JCQlmb3IgKEl0ZXJhdG9yPFRyZWVOb2RlVmFsdWVNb2RlbDxPYmplY3Q+PiBzdHJlYW0gPSB0aGlzLmNoaWxkcmVuTW9kZWwuaXRlcmF0b3IoKTsgc3RyZWFtLmhhc05leHQoKTsgKSB7Ci0JCQkJLy8gY2FzdCB0byBhIFRlc3ROb2RlIChpLmUuIHRoaXMgd29uJ3Qgd29yayB3aXRoIGEgTmFtZVRlc3ROb2RlIGluIHRoZSB0cmVlKQotCQkJCSgoVGVzdE5vZGUpIHN0cmVhbS5uZXh0KCkpLmR1bXBPbih3cml0ZXIpOwotCQkJfQotCQkJd3JpdGVyLnVuZGVudCgpOwotCQl9Ci0KLQkJcHVibGljIHZvaWQgZHVtcE9uKE91dHB1dFN0cmVhbSBzdHJlYW0pIHsKLQkJCUluZGVudGluZ1ByaW50V3JpdGVyIHdyaXRlciA9IG5ldyBJbmRlbnRpbmdQcmludFdyaXRlcihuZXcgT3V0cHV0U3RyZWFtV3JpdGVyKHN0cmVhbSkpOwotCQkJdGhpcy5kdW1wT24od3JpdGVyKTsKLQkJCXdyaXRlci5mbHVzaCgpOwotCQl9Ci0KLQkJcHVibGljIHZvaWQgZHVtcCgpIHsKLQkJCXRoaXMuZHVtcE9uKFN5c3RlbS5vdXQpOwotCQl9Ci0KLQotCQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCQkvKioKLQkJICogdGhlIG1vZGVsJ3MgbmFtZSBoYXMgY2hhbmdlZCwgZm9yd2FyZCB0aGUgZXZlbnQgdG8gb3VyIGxpc3RlbmVycwotCQkgKi8KLQkJcHJvdGVjdGVkIHZvaWQgdGVzdE1vZGVsQ2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJCS8vIHdlIG5lZWQgdG8gbm90aWZ5IGxpc3RlbmVycyB0aGF0IG91ciAiaW50ZXJuYWwgc3RhdGUiIGhhcyBjaGFuZ2VkCi0JCQl0aGlzLmZpcmVTdGF0ZUNoYW5nZWQoKTsKLQkJCS8vIG91ciBkaXNwbGF5IHN0cmluZyBzdGF5cyBpbiBzeW5jaCB3aXRoIHRoZSBtb2RlbCdzIG5hbWUKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChESVNQTEFZX1NUUklOR19QUk9QRVJUWSwgZS5nZXRPbGRWYWx1ZSgpLCBlLmdldE5ld1ZhbHVlKCkpOwotCQl9Ci0KLQotCQkvLyAqKioqKioqKioqIHF1ZXJpZXMgKioqKioqKioqKgotCi0JCXB1YmxpYyBUZXN0TW9kZWwgZ2V0VGVzdE1vZGVsKCkgewotCQkJcmV0dXJuIHRoaXMudGVzdE1vZGVsOwotCQl9Ci0KLQkJLyoqCi0JCSAqIHRlc3RpbmcgY29udmVuaWVuY2UgbWV0aG9kCi0JCSAqLwotCQlwdWJsaWMgVGVzdE5vZGUgY2hpbGROYW1lZChTdHJpbmcgbmFtZSkgewotCQkJZm9yIChJdGVyYXRvcjxUcmVlTm9kZVZhbHVlTW9kZWw8T2JqZWN0Pj4gc3RyZWFtID0gdGhpcy5jaGlsZHJlbk1vZGVsLml0ZXJhdG9yKCk7IHN0cmVhbS5oYXNOZXh0KCk7ICkgewotCQkJCVRyZWVOb2RlVmFsdWVNb2RlbDxPYmplY3Q+IGNoaWxkTm9kZSA9IHN0cmVhbS5uZXh0KCk7Ci0JCQkJaWYgKGNoaWxkTm9kZSBpbnN0YW5jZW9mIFRlc3ROb2RlKSB7Ci0JCQkJCWlmICgoKFRlc3ROb2RlKSBjaGlsZE5vZGUpLmdldFRlc3RNb2RlbCgpLmdldE5hbWUoKS5lcXVhbHMobmFtZSkpIHsKLQkJCQkJCXJldHVybiAoVGVzdE5vZGUpIGNoaWxkTm9kZTsKLQkJCQkJfQotCQkJCX0KLQkJCX0KLQkJCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oImNoaWxkIG5vdCBmb3VuZDogIiArIG5hbWUpOwotCQl9Ci0KLQotCQkvLyAqKioqKioqKioqIHN0YW5kYXJkIG1ldGhvZHMgKioqKioqKioqKgotCi0JCS8qKgotCQkgKiB1c2UgdGhlIHN0YW5kYXJkIERpc3BsYXlhYmxlIGNvbXBhcmF0b3IKLQkJICovCi0JCXB1YmxpYyBpbnQgY29tcGFyZVRvKERpc3BsYXlhYmxlIGQpIHsKLQkJCXJldHVybiBERUZBVUxUX0NPTVBBUkFUT1IuY29tcGFyZSh0aGlzLCBkKTsKLQkJfQotCi0JCUBPdmVycmlkZQotCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgewotCQkJcmV0dXJuICJOb2RlKCIgKyB0aGlzLnRlc3RNb2RlbCArICIpIjsKLQkJfQotCi0JfQotCi0JLyoqCi0JICogY29uY3JldGUgaW1wbGVtZW50YXRpb24gdGhhdCBrZWVwcyBpdHMgY2hpbGRyZW4gc29ydGVkCi0JICovCi0JcHVibGljIHN0YXRpYyBjbGFzcyBTb3J0ZWRUZXN0Tm9kZSBleHRlbmRzIFRlc3ROb2RlIHsKLQotCQkvLyAqKioqKioqKioqIGNvbnN0cnVjdG9ycyAqKioqKioqKioqCi0JCXB1YmxpYyBTb3J0ZWRUZXN0Tm9kZShUZXN0TW9kZWwgdGVzdE1vZGVsKSB7Ci0JCQlzdXBlcih0ZXN0TW9kZWwpOwotCQl9Ci0JCXB1YmxpYyBTb3J0ZWRUZXN0Tm9kZShUZXN0Tm9kZSBwYXJlbnQsIFRlc3RNb2RlbCB0ZXN0TW9kZWwpIHsKLQkJCXN1cGVyKHBhcmVudCwgdGVzdE1vZGVsKTsKLQkJfQotCi0JCS8vICoqKioqKioqKiogaW5pdGlhbGl6YXRpb24gKioqKioqKioqKgotCQkvKiogdGhlIGxpc3Qgc2hvdWxkIGJlIHNvcnRlZCAqLwotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIExpc3RWYWx1ZU1vZGVsPFRyZWVOb2RlVmFsdWVNb2RlbDxPYmplY3Q+PiBidWlsZENoaWxkcmVuTW9kZWwoVGVzdE1vZGVsIHRlc3RNb2RlbCkgewotCQkJcmV0dXJuIG5ldyBTb3J0ZWRMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8VHJlZU5vZGVWYWx1ZU1vZGVsPE9iamVjdD4+KHRoaXMuYnVpbGREaXNwbGF5U3RyaW5nQWRhcHRlcih0ZXN0TW9kZWwpKTsKLQkJfQotCQkvKiogdGhlIGRpc3BsYXkgc3RyaW5nIChuYW1lKSBvZiBlYWNoIG5vZGUgY2FuIGNoYW5nZSAqLwotCQlwcm90ZWN0ZWQgTGlzdFZhbHVlTW9kZWw8VHJlZU5vZGVWYWx1ZU1vZGVsPE9iamVjdD4+IGJ1aWxkRGlzcGxheVN0cmluZ0FkYXB0ZXIoVGVzdE1vZGVsIHRlc3RNb2RlbCkgewotCQkJcmV0dXJuIG5ldyBJdGVtUHJvcGVydHlMaXN0VmFsdWVNb2RlbEFkYXB0ZXI8VHJlZU5vZGVWYWx1ZU1vZGVsPE9iamVjdD4+KHRoaXMuYnVpbGROb2RlQWRhcHRlcih0ZXN0TW9kZWwpLCBESVNQTEFZX1NUUklOR19QUk9QRVJUWSk7Ci0JCX0KLQkJLyoqIGNoaWxkcmVuIGFyZSBhbHNvIHNvcnRlZCBub2RlcyAqLwotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIFRlc3ROb2RlIGJ1aWxkQ2hpbGROb2RlKFRlc3RNb2RlbCBjaGlsZE5vZGUpIHsKLQkJCXJldHVybiBuZXcgU29ydGVkVGVzdE5vZGUodGhpcywgY2hpbGROb2RlKTsKLQkJfQotCi0JfQotCi0KLQkvKioKLQkgKiBjb25jcmV0ZSBpbXBsZW1lbnRhdGlvbiB0aGF0IGxlYXZlcyBpdHMgY2hpbGRyZW4gdW5zb3J0ZWQKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNsYXNzIFVuc29ydGVkVGVzdE5vZGUgZXh0ZW5kcyBUZXN0Tm9kZSB7Ci0KLQkJLy8gKioqKioqKioqKiBjb25zdHJ1Y3RvcnMgKioqKioqKioqKgotCQlwdWJsaWMgVW5zb3J0ZWRUZXN0Tm9kZShUZXN0TW9kZWwgdGVzdE1vZGVsKSB7Ci0JCQlzdXBlcih0ZXN0TW9kZWwpOwotCQl9Ci0JCXB1YmxpYyBVbnNvcnRlZFRlc3ROb2RlKFRlc3ROb2RlIHBhcmVudCwgVGVzdE1vZGVsIHRlc3RNb2RlbCkgewotCQkJc3VwZXIocGFyZW50LCB0ZXN0TW9kZWwpOwotCQl9Ci0KLQkJLy8gKioqKioqKioqKiBpbml0aWFsaXphdGlvbiAqKioqKioqKioqCi0JCS8qKiB0aGUgbGlzdCBzaG91bGQgTk9UIGJlIHNvcnRlZCAqLwotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIExpc3RWYWx1ZU1vZGVsPFRyZWVOb2RlVmFsdWVNb2RlbDxPYmplY3Q+PiBidWlsZENoaWxkcmVuTW9kZWwoVGVzdE1vZGVsIHRlc3RNb2RlbCkgewotCQkJcmV0dXJuIHRoaXMuYnVpbGROb2RlQWRhcHRlcih0ZXN0TW9kZWwpOwotCQl9Ci0JCS8qKiBjaGlsZHJlbiBhcmUgYWxzbyB1bnNvcnRlZCBub2RlcyAqLwotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIFRlc3ROb2RlIGJ1aWxkQ2hpbGROb2RlKFRlc3RNb2RlbCBjaGlsZE5vZGUpIHsKLQkJCXJldHVybiBuZXcgVW5zb3J0ZWRUZXN0Tm9kZSh0aGlzLCBjaGlsZE5vZGUpOwotCQl9Ci0KLQl9Ci0KLQotCS8qKgotCSAqIGNvbmNyZXRlIGltcGxlbWVudGF0aW9uIHRoYXQgbGVhdmVzIGl0cyBjaGlsZHJlbiB1bnNvcnRlZAotCSAqIGFuZCBoYXMgYSBzcGVjaWFsIHNldCBvZiBjaGlsZHJlbiBmb3IgIm5vZGUgMyIKLQkgKi8KLQlwdWJsaWMgc3RhdGljIGNsYXNzIFNwZWNpYWxUZXN0Tm9kZSBleHRlbmRzIFVuc29ydGVkVGVzdE5vZGUgewotCi0JCS8vICoqKioqKioqKiogY29uc3RydWN0b3JzICoqKioqKioqKioKLQkJcHVibGljIFNwZWNpYWxUZXN0Tm9kZShUZXN0TW9kZWwgdGVzdE1vZGVsKSB7Ci0JCQlzdXBlcih0ZXN0TW9kZWwpOwotCQl9Ci0JCXB1YmxpYyBTcGVjaWFsVGVzdE5vZGUoVGVzdE5vZGUgcGFyZW50LCBUZXN0TW9kZWwgdGVzdE1vZGVsKSB7Ci0JCQlzdXBlcihwYXJlbnQsIHRlc3RNb2RlbCk7Ci0JCX0KLQotCQkvLyAqKioqKioqKioqIGluaXRpYWxpemF0aW9uICoqKioqKioqKioKLQkJLyoqIHJldHVybiBhIGRpZmZlcmVudCBsaXN0IG9mIGNoaWxkcmVuIGZvciAibm9kZSAzIiAqLwotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIExpc3RWYWx1ZU1vZGVsPFRyZWVOb2RlVmFsdWVNb2RlbDxPYmplY3Q+PiBidWlsZENoaWxkcmVuTW9kZWwoVGVzdE1vZGVsIHRlc3RNb2RlbCkgewotCQkJaWYgKHRlc3RNb2RlbC5nZXROYW1lKCkuZXF1YWxzKCJub2RlIDMiKSkgewotCQkJCXJldHVybiB0aGlzLmJ1aWxkU3BlY2lhbENoaWxkcmVuTW9kZWwodGVzdE1vZGVsKTsKLQkJCX0KLQkJCXJldHVybiBzdXBlci5idWlsZENoaWxkcmVuTW9kZWwodGVzdE1vZGVsKTsKLQkJfQotCQlwcm90ZWN0ZWQgTGlzdFZhbHVlTW9kZWw8VHJlZU5vZGVWYWx1ZU1vZGVsPE9iamVjdD4+IGJ1aWxkU3BlY2lhbENoaWxkcmVuTW9kZWwoVGVzdE1vZGVsIHRlc3RNb2RlbCkgewotCQkJVHJlZU5vZGVWYWx1ZU1vZGVsPE9iamVjdD5bXSBjaGlsZHJlbiA9IG5ldyBOYW1lVGVzdE5vZGVbMV07Ci0JCQljaGlsZHJlblswXSA9IG5ldyBOYW1lVGVzdE5vZGUodGhpcyk7Ci0JCQlyZXR1cm4gbmV3IFNpbXBsZUxpc3RWYWx1ZU1vZGVsPFRyZWVOb2RlVmFsdWVNb2RlbDxPYmplY3Q+PihBcnJheXMuYXNMaXN0KGNoaWxkcmVuKSk7Ci0JCX0KLQkJLyoqIGNoaWxkcmVuIGFyZSBhbHNvIHNwZWNpYWwgbm9kZXMgKi8KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCBUZXN0Tm9kZSBidWlsZENoaWxkTm9kZShUZXN0TW9kZWwgY2hpbGROb2RlKSB7Ci0JCQlyZXR1cm4gbmV3IFNwZWNpYWxUZXN0Tm9kZSh0aGlzLCBjaGlsZE5vZGUpOwotCQl9Ci0KLQl9Ci0KLQotCXB1YmxpYyBzdGF0aWMgY2xhc3MgTmFtZVRlc3ROb2RlIGV4dGVuZHMgQWJzdHJhY3RUcmVlTm9kZVZhbHVlTW9kZWw8T2JqZWN0PiB7Ci0JCXByaXZhdGUgZmluYWwgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8U3RyaW5nPiBuYW1lQWRhcHRlcjsKLQkJcHJpdmF0ZSBmaW5hbCBTcGVjaWFsVGVzdE5vZGUgc3BlY2lhbE5vZGU7CQkvLyBwYXJlbnQgbm9kZQotCQlwcml2YXRlIGZpbmFsIFByb3BlcnR5Q2hhbmdlTGlzdGVuZXIgbmFtZUxpc3RlbmVyOwotCQlwcml2YXRlIGZpbmFsIExpc3RWYWx1ZU1vZGVsPFRyZWVOb2RlVmFsdWVNb2RlbDxPYmplY3Q+PiBjaGlsZHJlbk1vZGVsOwotCi0JCS8vICoqKioqKioqKiogY29uc3RydWN0aW9uL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQotCQlwdWJsaWMgTmFtZVRlc3ROb2RlKFNwZWNpYWxUZXN0Tm9kZSBzcGVjaWFsTm9kZSkgewotCQkJc3VwZXIoKTsKLQkJCXRoaXMubmFtZUxpc3RlbmVyID0gdGhpcy5idWlsZE5hbWVMaXN0ZW5lcigpOwotCQkJdGhpcy5zcGVjaWFsTm9kZSA9IHNwZWNpYWxOb2RlOwotCQkJdGhpcy5uYW1lQWRhcHRlciA9IHRoaXMuYnVpbGROYW1lQWRhcHRlcigpOwotCQkJdGhpcy5jaGlsZHJlbk1vZGVsID0gbmV3IE51bGxMaXN0VmFsdWVNb2RlbDxUcmVlTm9kZVZhbHVlTW9kZWw8T2JqZWN0Pj4oKTsKLQkJfQotCQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZE5hbWVMaXN0ZW5lcigpIHsKLQkJCXJldHVybiBuZXcgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcigpIHsKLQkJCQlwdWJsaWMgdm9pZCBwcm9wZXJ0eUNoYW5nZWQoUHJvcGVydHlDaGFuZ2VFdmVudCBlKSB7Ci0JCQkJCU5hbWVUZXN0Tm9kZS50aGlzLm5hbWVDaGFuZ2VkKGUpOwotCQkJCX0KLQkJCX07Ci0JCX0KLQkJcHJvdGVjdGVkIFdyaXRhYmxlUHJvcGVydHlWYWx1ZU1vZGVsPFN0cmluZz4gYnVpbGROYW1lQWRhcHRlcigpIHsKLQkJCXJldHVybiBuZXcgUHJvcGVydHlBc3BlY3RBZGFwdGVyPFRlc3RNb2RlbCwgU3RyaW5nPihUZXN0TW9kZWwuTkFNRV9QUk9QRVJUWSwgdGhpcy5nZXRUZXN0TW9kZWwoKSkgewotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCBTdHJpbmcgYnVpbGRWYWx1ZV8oKSB7Ci0JCQkJCXJldHVybiB0aGlzLnN1YmplY3QuZ2V0TmFtZSgpOwotCQkJCX0KLQkJCQlAT3ZlcnJpZGUKLQkJCQlwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZV8oU3RyaW5nIHZhbHVlKSB7Ci0JCQkJCXRoaXMuc3ViamVjdC5zZXROYW1lKHZhbHVlKTsKLQkJCQl9Ci0JCQl9OwotCQl9Ci0KLQkJcHVibGljIFRlc3RNb2RlbCBnZXRUZXN0TW9kZWwoKSB7Ci0JCQlyZXR1cm4gdGhpcy5zcGVjaWFsTm9kZS5nZXRUZXN0TW9kZWwoKTsKLQkJfQotCi0JCS8vICoqKioqKioqKiogVHJlZU5vZGVWYWx1ZU1vZGVsIGltcGxlbWVudGF0aW9uICoqKioqKioqKioKLQotCQlwdWJsaWMgU3RyaW5nIGdldFZhbHVlKCkgewotCQkJcmV0dXJuIHRoaXMubmFtZUFkYXB0ZXIuZ2V0VmFsdWUoKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHVibGljIHZvaWQgc2V0VmFsdWUoT2JqZWN0IHZhbHVlKSB7Ci0JCQl0aGlzLm5hbWVBZGFwdGVyLnNldFZhbHVlKChTdHJpbmcpIHZhbHVlKTsKLQkJfQotCQlwdWJsaWMgVHJlZU5vZGVWYWx1ZU1vZGVsPE9iamVjdD4gcGFyZW50KCkgewotCQkJcmV0dXJuIHRoaXMuc3BlY2lhbE5vZGU7Ci0JCX0KLQkJcHVibGljIExpc3RWYWx1ZU1vZGVsPFRyZWVOb2RlVmFsdWVNb2RlbDxPYmplY3Q+PiBjaGlsZHJlbk1vZGVsKCkgewotCQkJcmV0dXJuIHRoaXMuY2hpbGRyZW5Nb2RlbDsKLQkJfQotCi0JCS8vICoqKioqKioqKiogQWJzdHJhY3RUcmVlTm9kZVZhbHVlTW9kZWwgaW1wbGVtZW50YXRpb24gKioqKioqKioqKgotCi0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgdm9pZCBlbmdhZ2VWYWx1ZSgpIHsKLQkJCXRoaXMubmFtZUFkYXB0ZXIuYWRkUHJvcGVydHlDaGFuZ2VMaXN0ZW5lcihQcm9wZXJ0eVZhbHVlTW9kZWwuVkFMVUUsIHRoaXMubmFtZUxpc3RlbmVyKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIHZvaWQgZGlzZW5nYWdlVmFsdWUoKSB7Ci0JCQl0aGlzLm5hbWVBZGFwdGVyLnJlbW92ZVByb3BlcnR5Q2hhbmdlTGlzdGVuZXIoUHJvcGVydHlWYWx1ZU1vZGVsLlZBTFVFLCB0aGlzLm5hbWVMaXN0ZW5lcik7Ci0JCX0KLQotCQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQotCQlwcm90ZWN0ZWQgdm9pZCBuYW1lQ2hhbmdlZChQcm9wZXJ0eUNoYW5nZUV2ZW50IGUpIHsKLQkJCS8vIHdlIG5lZWQgdG8gbm90aWZ5IGxpc3RlbmVycyB0aGF0IG91ciAidmFsdWUiIGhhcyBjaGFuZ2VkCi0JCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoVkFMVUUsIGUuZ2V0T2xkVmFsdWUoKSwgZS5nZXROZXdWYWx1ZSgpKTsKLQkJfQotCX0KLQotCXByaXZhdGUgVHJlZU1vZGVsIGJ1aWxkVHJlZU1vZGVsKFRlc3ROb2RlIHJvb3QpIHsKLQkJcmV0dXJuIHRoaXMuYnVpbGRUcmVlTW9kZWwobmV3IFN0YXRpY1Byb3BlcnR5VmFsdWVNb2RlbDxUcmVlTm9kZVZhbHVlTW9kZWw8T2JqZWN0Pj4ocm9vdCkpOwotCX0KLQotCXByaXZhdGUgVHJlZU1vZGVsIGJ1aWxkVHJlZU1vZGVsKFByb3BlcnR5VmFsdWVNb2RlbDxUcmVlTm9kZVZhbHVlTW9kZWw8T2JqZWN0Pj4gcm9vdEhvbGRlcikgewotCQlyZXR1cm4gbmV3IFRyZWVNb2RlbEFkYXB0ZXI8T2JqZWN0Pihyb290SG9sZGVyKSB7Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBMaXN0Q2hhbmdlTGlzdGVuZXIgYnVpbGRDaGlsZHJlbkxpc3RlbmVyKCkgewotCQkJCXJldHVybiB0aGlzLmJ1aWxkQ2hpbGRyZW5MaXN0ZW5lcl8oKTsKLQkJCX0KLQkJCUBPdmVycmlkZQotCQkJcHJvdGVjdGVkIFN0YXRlQ2hhbmdlTGlzdGVuZXIgYnVpbGROb2RlU3RhdGVMaXN0ZW5lcigpIHsKLQkJCQlyZXR1cm4gdGhpcy5idWlsZE5vZGVTdGF0ZUxpc3RlbmVyXygpOwotCQkJfQotCQkJQE92ZXJyaWRlCi0JCQlwcm90ZWN0ZWQgUHJvcGVydHlDaGFuZ2VMaXN0ZW5lciBidWlsZE5vZGVWYWx1ZUxpc3RlbmVyKCkgewotCQkJCXJldHVybiB0aGlzLmJ1aWxkTm9kZVZhbHVlTGlzdGVuZXJfKCk7Ci0JCQl9Ci0JCQlAT3ZlcnJpZGUKLQkJCXByb3RlY3RlZCBQcm9wZXJ0eUNoYW5nZUxpc3RlbmVyIGJ1aWxkUm9vdExpc3RlbmVyKCkgewotCQkJCXJldHVybiB0aGlzLmJ1aWxkUm9vdExpc3RlbmVyXygpOwotCQkJfQotCQl9OwotCX0KLQotCi0KLQkvKioKLQkgKiBsaXN0ZW5lciB0aGF0IHdpbGwgYmxvdyB1cCB3aXRoIGFueSBldmVudDsKLQkgKiBvdmVycmlkZSBhbmQgaW1wbGVtZW50IGV4cGVjdGVkIGV2ZW50IG1ldGhvZHMKLQkgKi8KLQlwdWJsaWMgY2xhc3MgVGVzdFRyZWVNb2RlbExpc3RlbmVyIGltcGxlbWVudHMgVHJlZU1vZGVsTGlzdGVuZXIgewotCQlwdWJsaWMgdm9pZCB0cmVlTm9kZXNDaGFuZ2VkKFRyZWVNb2RlbEV2ZW50IGUpIHsKLQkJCWZhaWwoInVuZXhwZWN0ZWQgZXZlbnQiKTsKLQkJfQotCQlwdWJsaWMgdm9pZCB0cmVlTm9kZXNJbnNlcnRlZChUcmVlTW9kZWxFdmVudCBlKSB7Ci0JCQlmYWlsKCJ1bmV4cGVjdGVkIGV2ZW50Iik7Ci0JCX0KLQkJcHVibGljIHZvaWQgdHJlZU5vZGVzUmVtb3ZlZChUcmVlTW9kZWxFdmVudCBlKSB7Ci0JCQlmYWlsKCJ1bmV4cGVjdGVkIGV2ZW50Iik7Ci0JCX0KLQkJcHVibGljIHZvaWQgdHJlZVN0cnVjdHVyZUNoYW5nZWQoVHJlZU1vZGVsRXZlbnQgZSkgewotCQkJZmFpbCgidW5leHBlY3RlZCBldmVudCIpOwotCQl9Ci0JfQotCi19CmRpZmYgLS1naXQgYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL21vZGVsL3ZhbHVlL3N3aW5nL1RyZWVNb2RlbEFkYXB0ZXJVSVRlc3QuamF2YSBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvVHJlZU1vZGVsQWRhcHRlclVJVGVzdC5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiOGY0MGMzLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbW9kZWwvdmFsdWUvc3dpbmcvVHJlZU1vZGVsQWRhcHRlclVJVGVzdC5qYXZhCisrKyAvZGV2L251bGwKQEAgLTEsNDI0ICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIDIwMDggT3JhY2xlLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlCi0gKiB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wLCB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbgotICogYW5kIGlzIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC4KLSAqIAotICogQ29udHJpYnV0b3JzOgotICogICAgIE9yYWNsZSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXBhY2thZ2Ugb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmc7Ci0KLWltcG9ydCBqYXZhLmF3dC5Cb3JkZXJMYXlvdXQ7Ci1pbXBvcnQgamF2YS5hd3QuQ29tcG9uZW50OwotaW1wb3J0IGphdmEuYXd0LkdyaWRMYXlvdXQ7Ci1pbXBvcnQgamF2YS5hd3QuVGV4dEZpZWxkOwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LkFjdGlvbkV2ZW50OwotaW1wb3J0IGphdmEuYXd0LmV2ZW50LldpbmRvd0FkYXB0ZXI7Ci1pbXBvcnQgamF2YS5hd3QuZXZlbnQuV2luZG93RXZlbnQ7Ci1pbXBvcnQgamF2YS5hd3QuZXZlbnQuV2luZG93TGlzdGVuZXI7Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247Ci1pbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb25zOwotaW1wb3J0IGphdmEudXRpbC5FbnVtZXJhdGlvbjsKLWltcG9ydCBqYXZheC5zd2luZy5BYnN0cmFjdEFjdGlvbjsKLWltcG9ydCBqYXZheC5zd2luZy5BY3Rpb247Ci1pbXBvcnQgamF2YXguc3dpbmcuSkJ1dHRvbjsKLWltcG9ydCBqYXZheC5zd2luZy5KRnJhbWU7Ci1pbXBvcnQgamF2YXguc3dpbmcuSlBhbmVsOwotaW1wb3J0IGphdmF4LnN3aW5nLkpTY3JvbGxQYW5lOwotaW1wb3J0IGphdmF4LnN3aW5nLkpUcmVlOwotaW1wb3J0IGphdmF4LnN3aW5nLldpbmRvd0NvbnN0YW50czsKLWltcG9ydCBqYXZheC5zd2luZy5ldmVudC5UcmVlU2VsZWN0aW9uRXZlbnQ7Ci1pbXBvcnQgamF2YXguc3dpbmcuZXZlbnQuVHJlZVNlbGVjdGlvbkxpc3RlbmVyOwotaW1wb3J0IGphdmF4LnN3aW5nLnRyZWUuRGVmYXVsdFRyZWVTZWxlY3Rpb25Nb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy50cmVlLlRyZWVNb2RlbDsKLWltcG9ydCBqYXZheC5zd2luZy50cmVlLlRyZWVQYXRoOwotaW1wb3J0IGphdmF4LnN3aW5nLnRyZWUuVHJlZVNlbGVjdGlvbk1vZGVsOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5pdGVyYXRvcnMuRW51bWVyYXRpb25JdGVyYXRvcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5tb2RlbC52YWx1ZS5TaW1wbGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuVHJlZU1vZGVsQWRhcHRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5zd2luZy5EaXNwbGF5YWJsZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5tb2RlbC52YWx1ZS5UcmVlTm9kZVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkubW9kZWwudmFsdWUuV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuVHJlZU1vZGVsQWRhcHRlclRlc3RzLlNvcnRlZFRlc3ROb2RlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLlRyZWVNb2RlbEFkYXB0ZXJUZXN0cy5UZXN0TW9kZWw7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwubW9kZWwudmFsdWUuc3dpbmcuVHJlZU1vZGVsQWRhcHRlclRlc3RzLlRlc3ROb2RlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm1vZGVsLnZhbHVlLnN3aW5nLlRyZWVNb2RlbEFkYXB0ZXJUZXN0cy5VbnNvcnRlZFRlc3ROb2RlOwotCi0vKioKLSAqIGFuIGV4YW1wbGUgVUkgZm9yIHRlc3RpbmcgdGhlIFRyZWVNb2RlbEFkYXB0ZXIKLSAqLwotcHVibGljIGNsYXNzIFRyZWVNb2RlbEFkYXB0ZXJVSVRlc3QgewotCi0JLy8gaG9sZCB0aGUgdHJlZSBzbyB3ZSBjYW4gcmVzdG9yZSBpdHMgZXhwYW5zaW9uIHN0YXRlCi0JcHJpdmF0ZSBKVHJlZSB0cmVlOwotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VHJlZU5vZGVWYWx1ZU1vZGVsPE9iamVjdD4+IHJvb3ROb2RlSG9sZGVyOwotCXByaXZhdGUgYm9vbGVhbiBzb3J0ZWQ7Ci0JcHJpdmF0ZSBUcmVlTW9kZWwgdHJlZU1vZGVsOwotCXByaXZhdGUgVHJlZVNlbGVjdGlvbk1vZGVsIHRyZWVTZWxlY3Rpb25Nb2RlbDsKLQlwcml2YXRlIFRleHRGaWVsZCBuYW1lVGV4dEZpZWxkOwotCi0JcHVibGljIHN0YXRpYyB2b2lkIG1haW4oU3RyaW5nW10gYXJncykgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCW5ldyBUcmVlTW9kZWxBZGFwdGVyVUlUZXN0KCkuZXhlYyhhcmdzKTsKLQl9Ci0KLQlwcml2YXRlIFRyZWVNb2RlbEFkYXB0ZXJVSVRlc3QoKSB7Ci0JCXN1cGVyKCk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGV4ZWMoU3RyaW5nW10gYXJncykgdGhyb3dzIEV4Y2VwdGlvbiB7Ci0JCXRoaXMucm9vdE5vZGVIb2xkZXIgPSB0aGlzLmJ1aWxkUm9vdE5vZGVIb2xkZXIoKTsKLQkJdGhpcy5zb3J0ZWQgPSB0aGlzLnJvb3ROb2RlSG9sZGVyLmdldFZhbHVlKCkgaW5zdGFuY2VvZiBTb3J0ZWRUZXN0Tm9kZTsKLQkJdGhpcy50cmVlTW9kZWwgPSB0aGlzLmJ1aWxkVHJlZU1vZGVsKCk7Ci0JCXRoaXMudHJlZVNlbGVjdGlvbk1vZGVsID0gdGhpcy5idWlsZFRyZWVTZWxlY3Rpb25Nb2RlbCgpOwotCQl0aGlzLm5hbWVUZXh0RmllbGQgPSBuZXcgVGV4dEZpZWxkKCk7Ci0JCXRoaXMub3BlbldpbmRvdygpOwotCX0KLQotCXByaXZhdGUgV3JpdGFibGVQcm9wZXJ0eVZhbHVlTW9kZWw8VHJlZU5vZGVWYWx1ZU1vZGVsPE9iamVjdD4+IGJ1aWxkUm9vdE5vZGVIb2xkZXIoKSB7Ci0JCXJldHVybiBuZXcgU2ltcGxlUHJvcGVydHlWYWx1ZU1vZGVsPFRyZWVOb2RlVmFsdWVNb2RlbDxPYmplY3Q+Pih0aGlzLmJ1aWxkU29ydGVkUm9vdE5vZGUoKSk7Ci0JfQotCi0JcHJpdmF0ZSBUZXN0Tm9kZSBidWlsZFNvcnRlZFJvb3ROb2RlKCkgewotCQlyZXR1cm4gbmV3IFNvcnRlZFRlc3ROb2RlKHRoaXMuYnVpbGRSb290KCkpOwotCX0KLQotCXByaXZhdGUgVGVzdE5vZGUgYnVpbGRVbnNvcnRlZFJvb3ROb2RlKCkgewotCQlyZXR1cm4gbmV3IFVuc29ydGVkVGVzdE5vZGUodGhpcy5idWlsZFJvb3QoKSk7Ci0JfQotCi0JcHJpdmF0ZSBUZXN0TW9kZWwgYnVpbGRSb290KCkgewotCQlUZXN0TW9kZWwgcm9vdCA9IG5ldyBUZXN0TW9kZWwoInJvb3QiKTsKLQotCQlUZXN0TW9kZWwgbm9kZV8xID0gcm9vdC5hZGRDaGlsZCgibm9kZSAxIik7Ci0JCS8qTm9kZSBub2RlXzFfMSA9ICovbm9kZV8xLmFkZENoaWxkKCJub2RlIDEuMSIpOwotCi0JCVRlc3RNb2RlbCBub2RlXzIgPSByb290LmFkZENoaWxkKCJub2RlIDIiKTsKLQkJLypOb2RlIG5vZGVfMl8xID0gKi9ub2RlXzIuYWRkQ2hpbGQoIm5vZGUgMi4xIik7Ci0JCVRlc3RNb2RlbCBub2RlXzJfMiA9IG5vZGVfMi5hZGRDaGlsZCgibm9kZSAyLjIiKTsKLQkJLypOb2RlIG5vZGVfMl8yXzEgPSAqL25vZGVfMl8yLmFkZENoaWxkKCJub2RlIDIuMi4xIik7Ci0JCS8qTm9kZSBub2RlXzJfMl8yID0gKi9ub2RlXzJfMi5hZGRDaGlsZCgibm9kZSAyLjIuMiIpOwotCQkvKk5vZGUgbm9kZV8yXzMgPSAqL25vZGVfMi5hZGRDaGlsZCgibm9kZSAyLjMiKTsKLQkJLypOb2RlIG5vZGVfMl80ID0gKi9ub2RlXzIuYWRkQ2hpbGQoIm5vZGUgMi40Iik7Ci0JCS8qTm9kZSBub2RlXzJfNSA9ICovbm9kZV8yLmFkZENoaWxkKCJub2RlIDIuNSIpOwotCi0JCVRlc3RNb2RlbCBub2RlXzMgPSByb290LmFkZENoaWxkKCJub2RlIDMiKTsKLQkJVGVzdE1vZGVsIG5vZGVfM18xID0gbm9kZV8zLmFkZENoaWxkKCJub2RlIDMuMSIpOwotCQlUZXN0TW9kZWwgbm9kZV8zXzFfMSA9IG5vZGVfM18xLmFkZENoaWxkKCJub2RlIDMuMS4xIik7Ci0JCS8qTm9kZSBub2RlXzNfMV8xXzEgPSAqL25vZGVfM18xXzEuYWRkQ2hpbGQoIm5vZGUgMy4xLjEuMSIpOwotCi0JCS8qTm9kZSBub2RlXzQgPSAqL3Jvb3QuYWRkQ2hpbGQoIm5vZGUgNCIpOwotCi0JCXJldHVybiByb290OwotCX0KLQotCXByaXZhdGUgVHJlZU1vZGVsIGJ1aWxkVHJlZU1vZGVsKCkgewotCQlyZXR1cm4gbmV3IFRyZWVNb2RlbEFkYXB0ZXI8T2JqZWN0Pih0aGlzLnJvb3ROb2RlSG9sZGVyKTsKLQl9Ci0KLQlwcml2YXRlIFRyZWVTZWxlY3Rpb25Nb2RlbCBidWlsZFRyZWVTZWxlY3Rpb25Nb2RlbCgpIHsKLQkJVHJlZVNlbGVjdGlvbk1vZGVsIHRzbSA9IG5ldyBEZWZhdWx0VHJlZVNlbGVjdGlvbk1vZGVsKCk7Ci0JCXRzbS5hZGRUcmVlU2VsZWN0aW9uTGlzdGVuZXIodGhpcy5idWlsZFRyZWVTZWxlY3Rpb25MaXN0ZW5lcigpKTsKLQkJdHNtLnNldFNlbGVjdGlvbk1vZGUoVHJlZVNlbGVjdGlvbk1vZGVsLlNJTkdMRV9UUkVFX1NFTEVDVElPTik7Ci0JCXJldHVybiB0c207Ci0JfQotCi0JcHJpdmF0ZSBUcmVlU2VsZWN0aW9uTGlzdGVuZXIgYnVpbGRUcmVlU2VsZWN0aW9uTGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgVHJlZVNlbGVjdGlvbkxpc3RlbmVyKCkgewotCQkJcHVibGljIHZvaWQgdmFsdWVDaGFuZ2VkKFRyZWVTZWxlY3Rpb25FdmVudCBlKSB7Ci0JCQkJVHJlZU1vZGVsQWRhcHRlclVJVGVzdC50aGlzLnRyZWVTZWxlY3Rpb25DaGFuZ2VkKGUpOwotCQkJfQotCQl9OwotCX0KLQotCXZvaWQgdHJlZVNlbGVjdGlvbkNoYW5nZWQoVHJlZVNlbGVjdGlvbkV2ZW50IGUpIHsKLQkJVGVzdE1vZGVsIHNlbGVjdGVkVGVzdE1vZGVsID0gdGhpcy5zZWxlY3RlZFRlc3RNb2RlbCgpOwotCQlpZiAoc2VsZWN0ZWRUZXN0TW9kZWwgIT0gbnVsbCkgewotCQkJdGhpcy5uYW1lVGV4dEZpZWxkLnNldFRleHQoc2VsZWN0ZWRUZXN0TW9kZWwuZ2V0TmFtZSgpKTsKLQkJfQotCX0KLQotCXByaXZhdGUgdm9pZCBvcGVuV2luZG93KCkgewotCQlKRnJhbWUgd2luZG93ID0gbmV3IEpGcmFtZSh0aGlzLmdldENsYXNzKCkuZ2V0TmFtZSgpKTsKLQkJd2luZG93LnNldERlZmF1bHRDbG9zZU9wZXJhdGlvbihXaW5kb3dDb25zdGFudHMuRE9fTk9USElOR19PTl9DTE9TRSk7Ci0JCXdpbmRvdy5hZGRXaW5kb3dMaXN0ZW5lcih0aGlzLmJ1aWxkV2luZG93TGlzdGVuZXIoKSk7Ci0JCXdpbmRvdy5nZXRDb250ZW50UGFuZSgpLmFkZCh0aGlzLmJ1aWxkTWFpblBhbmVsKCksICJDZW50ZXIiKTsKLQkJd2luZG93LnNldExvY2F0aW9uKDMwMCwgMzAwKTsKLQkJd2luZG93LnNldFNpemUoNDAwLCA0MDApOwotCQl3aW5kb3cuc2V0VmlzaWJsZSh0cnVlKTsKLQl9Ci0KLQlwcml2YXRlIFdpbmRvd0xpc3RlbmVyIGJ1aWxkV2luZG93TGlzdGVuZXIoKSB7Ci0JCXJldHVybiBuZXcgV2luZG93QWRhcHRlcigpIHsKLQkJCUBPdmVycmlkZQotCQkJcHVibGljIHZvaWQgd2luZG93Q2xvc2luZyhXaW5kb3dFdmVudCBlKSB7Ci0JCQkJZS5nZXRXaW5kb3coKS5zZXRWaXNpYmxlKGZhbHNlKTsKLQkJCQlTeXN0ZW0uZXhpdCgwKTsKLQkJCX0KLQkJfTsKLQl9Ci0KLQlwcml2YXRlIENvbXBvbmVudCBidWlsZE1haW5QYW5lbCgpIHsKLQkJSlBhbmVsIG1haW5QYW5lbCA9IG5ldyBKUGFuZWwobmV3IEJvcmRlckxheW91dCgpKTsKLQkJbWFpblBhbmVsLmFkZCh0aGlzLmJ1aWxkVHJlZVBhbmUoKSwgQm9yZGVyTGF5b3V0LkNFTlRFUik7Ci0JCW1haW5QYW5lbC5hZGQodGhpcy5idWlsZENvbnRyb2xQYW5lbCgpLCBCb3JkZXJMYXlvdXQuU09VVEgpOwotCQlyZXR1cm4gbWFpblBhbmVsOwotCX0KLQotCXByaXZhdGUgQ29tcG9uZW50IGJ1aWxkVHJlZVBhbmUoKSB7Ci0JCXJldHVybiBuZXcgSlNjcm9sbFBhbmUodGhpcy5idWlsZFRyZWUoKSk7Ci0JfQotCi0JcHJpdmF0ZSBKVHJlZSBidWlsZFRyZWUoKSB7Ci0JCXRoaXMudHJlZSA9IG5ldyBKVHJlZSh0aGlzLnRyZWVNb2RlbCkgewotCQkJQE92ZXJyaWRlCi0JCQlwdWJsaWMgU3RyaW5nIGNvbnZlcnRWYWx1ZVRvVGV4dChPYmplY3QgdmFsdWUsIGJvb2xlYW4gc2VsZWN0ZWQsIGJvb2xlYW4gZXhwYW5kZWQsIGJvb2xlYW4gbGVhZiwgaW50IHJvdywgYm9vbGVhbiBoYXNGb2N1cykgewotCQkJCXJldHVybiAoKERpc3BsYXlhYmxlKSB2YWx1ZSkuZGlzcGxheVN0cmluZygpOwotCQkJfQotCQl9OwotCQl0aGlzLnRyZWUuc2V0U2VsZWN0aW9uTW9kZWwodGhpcy50cmVlU2VsZWN0aW9uTW9kZWwpOwotCQl0aGlzLnRyZWUuc2V0Um9vdFZpc2libGUodHJ1ZSk7Ci0JCXRoaXMudHJlZS5zZXRTaG93c1Jvb3RIYW5kbGVzKHRydWUpOwotCQl0aGlzLnRyZWUuc2V0Um93SGVpZ2h0KDIwKTsKLQkJdGhpcy50cmVlLnNldERvdWJsZUJ1ZmZlcmVkKHRydWUpOwotCQlyZXR1cm4gdGhpcy50cmVlOwotCX0KLQotCXByaXZhdGUgQ29tcG9uZW50IGJ1aWxkQ29udHJvbFBhbmVsKCkgewotCQlKUGFuZWwgY29udHJvbFBhbmVsID0gbmV3IEpQYW5lbChuZXcgR3JpZExheW91dCgwLCAxKSk7Ci0JCWNvbnRyb2xQYW5lbC5hZGQodGhpcy5idWlsZEFkZFJlbmFtZU5vZGVQYW5lbCgpKTsKLQkJY29udHJvbFBhbmVsLmFkZCh0aGlzLmJ1aWxkTWlzY1BhbmVsKCkpOwotCQlyZXR1cm4gY29udHJvbFBhbmVsOwotCX0KLQotCXByaXZhdGUgQ29tcG9uZW50IGJ1aWxkQWRkUmVuYW1lTm9kZVBhbmVsKCkgewotCQlKUGFuZWwgYWRkUmVuYW1lTm9kZVBhbmVsID0gbmV3IEpQYW5lbChuZXcgQm9yZGVyTGF5b3V0KCkpOwotCQlhZGRSZW5hbWVOb2RlUGFuZWwuYWRkKHRoaXMuYnVpbGRBZGRCdXR0b24oKSwgQm9yZGVyTGF5b3V0LldFU1QpOwotCQlhZGRSZW5hbWVOb2RlUGFuZWwuYWRkKHRoaXMubmFtZVRleHRGaWVsZCwgQm9yZGVyTGF5b3V0LkNFTlRFUik7Ci0JCWFkZFJlbmFtZU5vZGVQYW5lbC5hZGQodGhpcy5idWlsZFJlbmFtZUJ1dHRvbigpLCBCb3JkZXJMYXlvdXQuRUFTVCk7Ci0JCXJldHVybiBhZGRSZW5hbWVOb2RlUGFuZWw7Ci0JfQotCi0JcHJpdmF0ZSBDb21wb25lbnQgYnVpbGRNaXNjUGFuZWwoKSB7Ci0JCUpQYW5lbCBtaXNjUGFuZWwgPSBuZXcgSlBhbmVsKG5ldyBHcmlkTGF5b3V0KDEsIDApKTsKLQkJbWlzY1BhbmVsLmFkZCh0aGlzLmJ1aWxkQ2xlYXJDaGlsZHJlbkJ1dHRvbigpKTsKLQkJbWlzY1BhbmVsLmFkZCh0aGlzLmJ1aWxkUmVtb3ZlQnV0dG9uKCkpOwotCQltaXNjUGFuZWwuYWRkKHRoaXMuYnVpbGRSZXNldEJ1dHRvbigpKTsKLQkJcmV0dXJuIG1pc2NQYW5lbDsKLQl9Ci0KLQlwcml2YXRlIFN0cmluZyBnZXROYW1lKCkgewotCQlyZXR1cm4gdGhpcy5uYW1lVGV4dEZpZWxkLmdldFRleHQoKTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIHF1ZXJpZXMgKioqKioqKioqKgotCXByaXZhdGUgVGVzdE5vZGUgc2VsZWN0ZWROb2RlKCkgewotCQlpZiAodGhpcy50cmVlU2VsZWN0aW9uTW9kZWwuaXNTZWxlY3Rpb25FbXB0eSgpKSB7Ci0JCQlyZXR1cm4gbnVsbDsKLQkJfQotCQlyZXR1cm4gKFRlc3ROb2RlKSB0aGlzLnRyZWVTZWxlY3Rpb25Nb2RlbC5nZXRTZWxlY3Rpb25QYXRoKCkuZ2V0TGFzdFBhdGhDb21wb25lbnQoKTsKLQl9Ci0KLQlwcml2YXRlIFRlc3RNb2RlbCBzZWxlY3RlZFRlc3RNb2RlbCgpIHsKLQkJaWYgKHRoaXMudHJlZVNlbGVjdGlvbk1vZGVsLmlzU2VsZWN0aW9uRW1wdHkoKSkgewotCQkJcmV0dXJuIG51bGw7Ci0JCX0KLQkJcmV0dXJuIHRoaXMuc2VsZWN0ZWROb2RlKCkuZ2V0VmFsdWUoKTsKLQl9Ci0KLQlwcml2YXRlIFRlc3ROb2RlIHJvb3ROb2RlKCkgewotCQlyZXR1cm4gKFRlc3ROb2RlKSB0aGlzLnRyZWVNb2RlbC5nZXRSb290KCk7Ci0JfQotCi0JcHJpdmF0ZSBUZXN0TW9kZWwgcm9vdCgpIHsKLQkJcmV0dXJuIHRoaXMucm9vdE5vZGUoKS5nZXRWYWx1ZSgpOwotCX0KLQotCXByaXZhdGUgQ29sbGVjdGlvbjxUcmVlUGF0aD4gZXhwYW5kZWRQYXRocygpIHsKLQkJRW51bWVyYXRpb248VHJlZVBhdGg+IHN0cmVhbSA9IHRoaXMudHJlZS5nZXRFeHBhbmRlZERlc2NlbmRhbnRzKG5ldyBUcmVlUGF0aCh0aGlzLnJvb3ROb2RlKCkpKTsKLQkJaWYgKHN0cmVhbSA9PSBudWxsKSB7Ci0JCQlyZXR1cm4gQ29sbGVjdGlvbnMuZW1wdHlMaXN0KCk7Ci0JCX0KLQkJcmV0dXJuIENvbGxlY3Rpb25Ub29scy5saXN0KG5ldyBFbnVtZXJhdGlvbkl0ZXJhdG9yPFRyZWVQYXRoPihzdHJlYW0pKTsKLQl9Ci0KLQkvLyAqKioqKioqKioqIGJlaGF2aW9yICoqKioqKioqKioKLQlwcml2YXRlIHZvaWQgc2V0U2VsZWN0ZWROb2RlKFRlc3ROb2RlIHNlbGVjdGVkTm9kZSkgewotCQl0aGlzLnRyZWVTZWxlY3Rpb25Nb2RlbC5zZXRTZWxlY3Rpb25QYXRoKG5ldyBUcmVlUGF0aChzZWxlY3RlZE5vZGUucGF0aCgpKSk7Ci0JfQotCi0JcHJpdmF0ZSB2b2lkIGV4cGFuZFBhdGhzKENvbGxlY3Rpb248VHJlZVBhdGg+IHBhdGhzKSB7Ci0JCWZvciAoVHJlZVBhdGggcGF0aCA6IHBhdGhzKSB7Ci0JCQl0aGlzLnRyZWUuZXhwYW5kUGF0aChwYXRoKTsKLQkJfQotCX0KLQotCS8vICoqKioqKioqKiogYWRkICoqKioqKioqKioKLQlwcml2YXRlIEpCdXR0b24gYnVpbGRBZGRCdXR0b24oKSB7Ci0JCXJldHVybiBuZXcgSkJ1dHRvbih0aGlzLmJ1aWxkQWRkQWN0aW9uKCkpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uIGJ1aWxkQWRkQWN0aW9uKCkgewotCQlBY3Rpb24gYWN0aW9uID0gbmV3IEFic3RyYWN0QWN0aW9uKCJhZGQiKSB7Ci0JCQlwdWJsaWMgdm9pZCBhY3Rpb25QZXJmb3JtZWQoQWN0aW9uRXZlbnQgZXZlbnQpIHsKLQkJCQlUcmVlTW9kZWxBZGFwdGVyVUlUZXN0LnRoaXMuYWRkTm9kZSgpOwotCQkJfQotCQl9OwotCQlhY3Rpb24uc2V0RW5hYmxlZCh0cnVlKTsKLQkJcmV0dXJuIGFjdGlvbjsKLQl9Ci0KLQkvKioKLQkgKiBhZGRpbmcgY2F1c2VzIHRoZSB0cmVlIHRvIGJlIHNvcnRlZCBhbmQgbm9kZXMgdG8gYmUKLQkgKiByZW1vdmVkIGFuZCByZS1hZGRlZDsgc28gd2UgaGF2ZSB0byBmaWRkbGUgd2l0aCB0aGUgZXhwYW5zaW9uIHN0YXRlCi0JICovCi0Jdm9pZCBhZGROb2RlKCkgewotCQlUZXN0TW9kZWwgc2VsZWN0ZWRUZXN0TW9kZWwgPSB0aGlzLnNlbGVjdGVkVGVzdE1vZGVsKCk7Ci0JCWlmIChzZWxlY3RlZFRlc3RNb2RlbCAhPSBudWxsKSB7Ci0JCQlTdHJpbmcgbmFtZSA9IHRoaXMuZ2V0TmFtZSgpOwotCQkJLy8gc2F2ZSB0aGUgZXhwYW5zaW9uIHN0YXRlIGFuZCByZXN0b3JlIGl0IGFmdGVyIHRoZSBhZGQKLQkJCUNvbGxlY3Rpb248VHJlZVBhdGg+IHBhdGhzID0gdGhpcy5leHBhbmRlZFBhdGhzKCk7Ci0KLQkJCXNlbGVjdGVkVGVzdE1vZGVsLmFkZENoaWxkKG5hbWUpOwotCi0JCQl0aGlzLmV4cGFuZFBhdGhzKHBhdGhzKTsKLQkJCXRoaXMuc2V0U2VsZWN0ZWROb2RlKHRoaXMuc2VsZWN0ZWROb2RlKCkuY2hpbGROYW1lZChuYW1lKSk7Ci0JCX0KLQl9Ci0KLQkvLyAqKioqKioqKioqIHJlbW92ZSAqKioqKioqKioqCi0JcHJpdmF0ZSBKQnV0dG9uIGJ1aWxkUmVtb3ZlQnV0dG9uKCkgewotCQlyZXR1cm4gbmV3IEpCdXR0b24odGhpcy5idWlsZFJlbW92ZUFjdGlvbigpKTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbiBidWlsZFJlbW92ZUFjdGlvbigpIHsKLQkJQWN0aW9uIGFjdGlvbiA9IG5ldyBBYnN0cmFjdEFjdGlvbigicmVtb3ZlIikgewotCQkJcHVibGljIHZvaWQgYWN0aW9uUGVyZm9ybWVkKEFjdGlvbkV2ZW50IGV2ZW50KSB7Ci0JCQkJVHJlZU1vZGVsQWRhcHRlclVJVGVzdC50aGlzLnJlbW92ZU5vZGUoKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldEVuYWJsZWQodHJ1ZSk7Ci0JCXJldHVybiBhY3Rpb247Ci0JfQotCi0JLyoqCi0JICogd2UgbmVlZCB0byBmaWd1cmUgb3V0IHdoaWNoIG5vZGUgdG8gc2VsZWN0IGFmdGVyCi0JICogdGhlIHNlbGVjdGVkIG5vZGUgaXMgZGVsZXRlZAotCSAqLwotCXZvaWQgcmVtb3ZlTm9kZSgpIHsKLQkJVGVzdE1vZGVsIHNlbGVjdGVkVGVzdE1vZGVsID0gdGhpcy5zZWxlY3RlZFRlc3RNb2RlbCgpOwotCQkvLyBkbyBub3QgYWxsb3cgdGhlIHJvb3QgdG8gYmUgcmVtb3ZlZAotCQlpZiAoKHNlbGVjdGVkVGVzdE1vZGVsICE9IG51bGwpICYmIChzZWxlY3RlZFRlc3RNb2RlbCAhPSB0aGlzLnJvb3QoKSkpIHsKLQkJCS8vIHNhdmUgdGhlIHBhcmVudCBhbmQgaW5kZXgsIHNvIHdlIGNhbiBzZWxlY3QgYW5vdGhlciwgbmVhcmJ5LCBub2RlCi0JCQkvLyBvbmNlIHRoZSBzZWxlY3RlZCBub2RlIGlzIHJlbW92ZWQKLQkJCVRlc3ROb2RlIHBhcmVudE5vZGUgPSAoVGVzdE5vZGUpIHRoaXMuc2VsZWN0ZWROb2RlKCkucGFyZW50KCk7Ci0JCQlpbnQgY2hpbGRJbmRleCA9IHBhcmVudE5vZGUuaW5kZXhPZkNoaWxkKHRoaXMuc2VsZWN0ZWROb2RlKCkpOwotCi0JCQlzZWxlY3RlZFRlc3RNb2RlbC5nZXRQYXJlbnQoKS5yZW1vdmVDaGlsZChzZWxlY3RlZFRlc3RNb2RlbCk7Ci0KLQkJCWludCBjaGlsZHJlblNpemUgPSBwYXJlbnROb2RlLmNoaWxkcmVuU2l6ZSgpOwotCQkJaWYgKGNoaWxkSW5kZXggPCBjaGlsZHJlblNpemUpIHsKLQkJCQkvLyBzZWxlY3QgdGhlIGNoaWxkIHRoYXQgbW92ZWQgdXAgYW5kIHJlcGxhY2VkIHRoZSBqdXN0LWRlbGV0ZWQgY2hpbGQKLQkJCQl0aGlzLnNldFNlbGVjdGVkTm9kZSgoVGVzdE5vZGUpIHBhcmVudE5vZGUuY2hpbGQoY2hpbGRJbmRleCkpOwotCQkJfSBlbHNlIHsKLQkJCQlpZiAoY2hpbGRyZW5TaXplID09IDApIHsKLQkJCQkJLy8gaWYgdGhlcmUgYXJlIG5vIG1vcmUgY2hpbGRyZW4sIHNlbGVjdCB0aGUgcGFyZW50Ci0JCQkJCXRoaXMuc2V0U2VsZWN0ZWROb2RlKHBhcmVudE5vZGUpOwotCQkJCX0gZWxzZSB7Ci0JCQkJCS8vIGlmIHRoZSBjaGlsZCBhdCB0aGUgYm90dG9tIG9mIHRoZSBsaXN0IHdhcyBkZWxldGVkLCBzZWxlY3QgdGhlIG5leHQgY2hpbGQgdXAKLQkJCQkJdGhpcy5zZXRTZWxlY3RlZE5vZGUoKFRlc3ROb2RlKSBwYXJlbnROb2RlLmNoaWxkKGNoaWxkSW5kZXggLSAxKSk7Ci0JCQkJfQotCQkJfQotCQl9Ci0JfQotCi0JLy8gKioqKioqKioqKiByZW5hbWUgKioqKioqKioqKgotCXByaXZhdGUgSkJ1dHRvbiBidWlsZFJlbmFtZUJ1dHRvbigpIHsKLQkJcmV0dXJuIG5ldyBKQnV0dG9uKHRoaXMuYnVpbGRSZW5hbWVBY3Rpb24oKSk7Ci0JfQotCi0JcHJpdmF0ZSBBY3Rpb24gYnVpbGRSZW5hbWVBY3Rpb24oKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWJzdHJhY3RBY3Rpb24oInJlbmFtZSIpIHsKLQkJCXB1YmxpYyB2b2lkIGFjdGlvblBlcmZvcm1lZChBY3Rpb25FdmVudCBldmVudCkgewotCQkJCVRyZWVNb2RlbEFkYXB0ZXJVSVRlc3QudGhpcy5yZW5hbWVOb2RlKCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRFbmFibGVkKHRydWUpOwotCQlyZXR1cm4gYWN0aW9uOwotCX0KLQotCS8qKgotCSAqIHJlbmFtaW5nIGNhdXNlcyB0aGUgdHJlZSB0byBiZSBzb3J0ZWQgYW5kIG5vZGVzIHRvIGJlCi0JICogcmVtb3ZlZCBhbmQgcmUtYWRkZWQ7IHNvIHdlIGhhdmUgdG8gZmlkZGxlIHdpdGggdGhlIGV4cGFuc2lvbiBzdGF0ZQotCSAqLwotCXZvaWQgcmVuYW1lTm9kZSgpIHsKLQkJVGVzdE1vZGVsIHNlbGVjdGVkVGVzdE1vZGVsID0gdGhpcy5zZWxlY3RlZFRlc3RNb2RlbCgpOwotCQlpZiAoc2VsZWN0ZWRUZXN0TW9kZWwgIT0gbnVsbCkgewotCQkJLy8gc2F2ZSB0aGUgbm9kZSBhbmQgcmUtc2VsZWN0IGl0IGFmdGVyIHRoZSByZW5hbWUKLQkJCVRlc3ROb2RlIHNlbGVjdGVkTm9kZSA9IHRoaXMuc2VsZWN0ZWROb2RlKCk7Ci0JCQkvLyBzYXZlIHRoZSBleHBhbnNpb24gc3RhdGUgYW5kIHJlc3RvcmUgaXQgYWZ0ZXIgdGhlIHJlbmFtZQotCQkJQ29sbGVjdGlvbjxUcmVlUGF0aD4gcGF0aHMgPSB0aGlzLmV4cGFuZGVkUGF0aHMoKTsKLQotCQkJc2VsZWN0ZWRUZXN0TW9kZWwuc2V0TmFtZSh0aGlzLmdldE5hbWUoKSk7Ci0KLQkJCXRoaXMuZXhwYW5kUGF0aHMocGF0aHMpOwotCQkJdGhpcy5zZXRTZWxlY3RlZE5vZGUoc2VsZWN0ZWROb2RlKTsKLQkJfQotCX0KLQotCS8vICoqKioqKioqKiogY2xlYXIgY2hpbGRyZW4gKioqKioqKioqKgotCXByaXZhdGUgSkJ1dHRvbiBidWlsZENsZWFyQ2hpbGRyZW5CdXR0b24oKSB7Ci0JCXJldHVybiBuZXcgSkJ1dHRvbih0aGlzLmJ1aWxkQ2xlYXJDaGlsZHJlbkFjdGlvbigpKTsKLQl9Ci0KLQlwcml2YXRlIEFjdGlvbiBidWlsZENsZWFyQ2hpbGRyZW5BY3Rpb24oKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWJzdHJhY3RBY3Rpb24oImNsZWFyIGNoaWxkcmVuIikgewotCQkJcHVibGljIHZvaWQgYWN0aW9uUGVyZm9ybWVkKEFjdGlvbkV2ZW50IGV2ZW50KSB7Ci0JCQkJVHJlZU1vZGVsQWRhcHRlclVJVGVzdC50aGlzLmNsZWFyQ2hpbGRyZW4oKTsKLQkJCX0KLQkJfTsKLQkJYWN0aW9uLnNldEVuYWJsZWQodHJ1ZSk7Ci0JCXJldHVybiBhY3Rpb247Ci0JfQotCi0JLyoqCi0JICogbm90aGluZyBzcGVjaWFsLCB3ZSBqdXN0IHdhbnQgdG8gdGVzdCAjZmlyZUNvbGxlY3Rpb25DaGFuZ2VkKFN0cmluZykKLQkgKi8KLQl2b2lkIGNsZWFyQ2hpbGRyZW4oKSB7Ci0JCVRlc3RNb2RlbCBzZWxlY3RlZFRlc3RNb2RlbCA9IHRoaXMuc2VsZWN0ZWRUZXN0TW9kZWwoKTsKLQkJaWYgKHNlbGVjdGVkVGVzdE1vZGVsICE9IG51bGwpIHsKLQkJCXNlbGVjdGVkVGVzdE1vZGVsLmNsZWFyQ2hpbGRyZW4oKTsKLQkJfQotCX0KLQotCS8vICoqKioqKioqKiogcmVzZXQgKioqKioqKioqKgotCXByaXZhdGUgSkJ1dHRvbiBidWlsZFJlc2V0QnV0dG9uKCkgewotCQlyZXR1cm4gbmV3IEpCdXR0b24odGhpcy5idWlsZFJlc2V0QWN0aW9uKCkpOwotCX0KLQotCXByaXZhdGUgQWN0aW9uIGJ1aWxkUmVzZXRBY3Rpb24oKSB7Ci0JCUFjdGlvbiBhY3Rpb24gPSBuZXcgQWJzdHJhY3RBY3Rpb24oInJlc2V0IikgewotCQkJcHVibGljIHZvaWQgYWN0aW9uUGVyZm9ybWVkKEFjdGlvbkV2ZW50IGV2ZW50KSB7Ci0JCQkJVHJlZU1vZGVsQWRhcHRlclVJVGVzdC50aGlzLnJlc2V0KCk7Ci0JCQl9Ci0JCX07Ci0JCWFjdGlvbi5zZXRFbmFibGVkKHRydWUpOwotCQlyZXR1cm4gYWN0aW9uOwotCX0KLQotCS8qKgotCSAqIHRlc3QgdGhlIGFkYXB0ZXIncyByb290IG5vZGUgaG9sZGVyOwotCSAqIHRvZ2dsZSBiZXR3ZWVuIHNvcnRlZCBhbmQgdW5zb3J0ZWQgbGlzdHMKLQkgKi8KLQl2b2lkIHJlc2V0KCkgewotCQl0aGlzLnNvcnRlZCA9ICEgdGhpcy5zb3J0ZWQ7Ci0JCWlmICh0aGlzLnNvcnRlZCkgewotCQkJdGhpcy5yb290Tm9kZUhvbGRlci5zZXRWYWx1ZSh0aGlzLmJ1aWxkU29ydGVkUm9vdE5vZGUoKSk7Ci0JCX0gZWxzZSB7Ci0JCQl0aGlzLnJvb3ROb2RlSG9sZGVyLnNldFZhbHVlKHRoaXMuYnVpbGRVbnNvcnRlZFJvb3ROb2RlKCkpOwotCQl9Ci0JCXRoaXMudHJlZS5leHBhbmRQYXRoKG5ldyBUcmVlUGF0aCh0aGlzLnJvb3ROb2RlKCkpKTsKLQl9Ci0KLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbm9kZS9BYnN0cmFjdE5vZGVUZXN0cy5qYXZhIGIvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9ub2RlL0Fic3RyYWN0Tm9kZVRlc3RzLmphdmEKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDRhMzBiYTMuLjAwMDAwMDAKLS0tIGEvanBhL3Rlc3RzL29yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qcHQvdXRpbGl0eS90ZXN0cy9pbnRlcm5hbC9ub2RlL0Fic3RyYWN0Tm9kZVRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSw1MjYgKzAsMCBAQAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIENvcHlyaWdodCAoYykgMjAwNywgMjAwOCBPcmFjbGUuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUKLSAqIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAsIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uCi0gKiBhbmQgaXMgYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sLgotICogCi0gKiBDb250cmlidXRvcnM6Ci0gKiAgICAgT3JhY2xlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotcGFja2FnZSBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy5pbnRlcm5hbC5ub2RlOwotCi1pbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKLWltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKLWltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7Ci1pbXBvcnQgamF2YS51dGlsLkxpc3Q7Ci1pbXBvcnQganVuaXQuZnJhbWV3b3JrLlRlc3RDYXNlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLkNvbGxlY3Rpb25Ub29sczsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5IYXNoQmFnOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLlJhbmdlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLml0ZXJhdG9ycy5DbG9uZUl0ZXJhdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm5vZGUuQWJzdHJhY3ROb2RlOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LmludGVybmFsLm5vZGUuTm9kZTsKLWltcG9ydCBvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS5pbnRlcm5hbC5ub2RlLlByb2JsZW07Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMuaW50ZXJuYWwuVGVzdFRvb2xzOwotCi1wdWJsaWMgY2xhc3MgQWJzdHJhY3ROb2RlVGVzdHMgZXh0ZW5kcyBUZXN0Q2FzZSB7Ci0JcHJpdmF0ZSBUZXN0V29ya2JlbmNoTW9kZWwgcm9vdDsKLQotCXB1YmxpYyBBYnN0cmFjdE5vZGVUZXN0cyhTdHJpbmcgbmFtZSkgewotCQlzdXBlcihuYW1lKTsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCBzZXRVcCgpIHRocm93cyBFeGNlcHRpb24gewotCQlzdXBlci5zZXRVcCgpOwotCQl0aGlzLnJvb3QgPSB0aGlzLmJ1aWxkUm9vdCgpOwotCX0KLQotCXByaXZhdGUgVGVzdFdvcmtiZW5jaE1vZGVsIGJ1aWxkUm9vdCgpIHsKLQkJVGVzdFdvcmtiZW5jaE1vZGVsIHIgPSBuZXcgUm9vdFRlc3RXb3JrYmVuY2hNb2RlbCgicm9vdCIpOwotCQkJVGVzdFdvcmtiZW5jaE1vZGVsIG5vZGUxID0gci5hZGRUZXN0Q2hpbGROYW1lZCgibm9kZSAxIik7Ci0JCQkJVGVzdFdvcmtiZW5jaE1vZGVsIG5vZGUxXzEgPSBub2RlMS5hZGRUZXN0Q2hpbGROYW1lZCgibm9kZSAxLjEiKTsKLQkJCQkJbm9kZTFfMS5hZGRUZXN0Q2hpbGROYW1lZCgibm9kZSAxLjEuMSIpOwotCQkJCQlub2RlMV8xLmFkZFRlc3RDaGlsZE5hbWVkKCJub2RlIDEuMS4yIik7Ci0JCQkJCW5vZGUxXzEuYWRkVGVzdENoaWxkTmFtZWQoIm5vZGUgMS4xLjMiKTsKLQkJCQlub2RlMS5hZGRUZXN0Q2hpbGROYW1lZCgibm9kZSAxLjIiKTsKLQkJCVRlc3RXb3JrYmVuY2hNb2RlbCBub2RlMiA9IHIuYWRkVGVzdENoaWxkTmFtZWQoIm5vZGUgMiIpOwotCQkJCW5vZGUyLmFkZFRlc3RDaGlsZE5hbWVkKCJub2RlIDIuMSIpOwotCQkJCW5vZGUyLmFkZFRlc3RDaGlsZE5hbWVkKCJub2RlIDIuMiIpOwotCQkJci5hZGRUZXN0Q2hpbGROYW1lZCgibm9kZSAzIik7Ci0JCQlyLmFkZFRlc3RDaGlsZE5hbWVkKCJub2RlIDQiKTsKLQotCQkvLyBtYXJrIHRoZSBlbnRpcmUgdHJlZSBjbGVhbgotCQlyLm1hcmtFbnRpcmVCcmFuY2hDbGVhbigpOwotCQlyZXR1cm4gcjsKLQl9Ci0KLQlAT3ZlcnJpZGUKLQlwcm90ZWN0ZWQgdm9pZCB0ZWFyRG93bigpIHRocm93cyBFeGNlcHRpb24gewotCQlUZXN0VG9vbHMuY2xlYXIodGhpcyk7Ci0JCXN1cGVyLnRlYXJEb3duKCk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFRlc3RXb3JrYmVuY2hNb2RlbCgpIHsKLQkJLy8gbWFrZSBzdXJlIG91ciB0ZXN0IGNsYXNzIHdvcmtzIE9LLi4uCi0JCWFzc2VydE51bGwodGhpcy5yb290LnRlc3RDaGlsZE5hbWVkKCIiKSk7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5yb290LnRlc3RDaGlsZE5hbWVkKCJub2RlIDEiKSk7Ci0JCWFzc2VydFRydWUodGhpcy5yb290LnRlc3RDaGlsZE5hbWVkKCJub2RlIDEiKS5pc0NsZWFuKCkpOwotCQlhc3NlcnRUcnVlKHRoaXMucm9vdC50ZXN0Q2hpbGROYW1lZCgibm9kZSAxIikuaXNDbGVhbkJyYW5jaCgpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLnJvb3QudGVzdENoaWxkTmFtZWQoIm5vZGUgMiIpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnJvb3QudGVzdENoaWxkTmFtZWQoIm5vZGUgMiIpLmlzQ2xlYW4oKSk7Ci0JCWFzc2VydFRydWUodGhpcy5yb290LnRlc3RDaGlsZE5hbWVkKCJub2RlIDIiKS5pc0NsZWFuQnJhbmNoKCkpOwotCQlhc3NlcnROdWxsKHRoaXMucm9vdC50ZXN0Q2hpbGROYW1lZCgibm9kZSAyLjEiKSk7Ci0KLQkJYXNzZXJ0TnVsbCh0aGlzLnJvb3QudGVzdERlc2NlbmRhbnROYW1lZCgiIikpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMucm9vdC50ZXN0RGVzY2VuZGFudE5hbWVkKCJub2RlIDEiKSk7Ci0JCWFzc2VydE5vdE51bGwodGhpcy5yb290LnRlc3REZXNjZW5kYW50TmFtZWQoIm5vZGUgMiIpKTsKLQkJYXNzZXJ0Tm90TnVsbCh0aGlzLnJvb3QudGVzdERlc2NlbmRhbnROYW1lZCgibm9kZSAyLjEiKSk7Ci0JCWFzc2VydFRydWUodGhpcy5yb290LnRlc3REZXNjZW5kYW50TmFtZWQoIm5vZGUgMi4xIikuaXNDbGVhbigpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnJvb3QudGVzdERlc2NlbmRhbnROYW1lZCgibm9kZSAyLjEiKS5pc0NsZWFuQnJhbmNoKCkpOwotCQlhc3NlcnROb3ROdWxsKHRoaXMucm9vdC50ZXN0RGVzY2VuZGFudE5hbWVkKCJub2RlIDEuMS4zIikpOwotCQlhc3NlcnRUcnVlKHRoaXMucm9vdC50ZXN0RGVzY2VuZGFudE5hbWVkKCJub2RlIDEuMS4zIikuaXNDbGVhbigpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnJvb3QudGVzdERlc2NlbmRhbnROYW1lZCgibm9kZSAxLjEuMyIpLmlzQ2xlYW5CcmFuY2goKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdFBhcmVudEFuZENoaWxkcmVuKCkgewotCQlUZXN0V29ya2JlbmNoTW9kZWwgbm9kZSA9IHRoaXMucm9vdC50ZXN0RGVzY2VuZGFudE5hbWVkKCJub2RlIDEuMS4zIik7Ci0JCWFzc2VydEVxdWFscygibm9kZSAxLjEuMyIsIG5vZGUuZ2V0TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIENvbGxlY3Rpb25Ub29scy5zaXplKG5vZGUuY2hpbGRyZW4oKSkpOwotCi0JCW5vZGUgPSAoVGVzdFdvcmtiZW5jaE1vZGVsKSBub2RlLmdldFBhcmVudCgpOwotCQlhc3NlcnRFcXVhbHMoIm5vZGUgMS4xIiwgbm9kZS5nZXROYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoMywgQ29sbGVjdGlvblRvb2xzLnNpemUobm9kZS5jaGlsZHJlbigpKSk7Ci0KLQkJbm9kZSA9IChUZXN0V29ya2JlbmNoTW9kZWwpIG5vZGUuZ2V0UGFyZW50KCk7Ci0JCWFzc2VydEVxdWFscygibm9kZSAxIiwgbm9kZS5nZXROYW1lKCkpOwotCQlhc3NlcnRFcXVhbHMoMiwgQ29sbGVjdGlvblRvb2xzLnNpemUobm9kZS5jaGlsZHJlbigpKSk7Ci0KLQkJbm9kZSA9IChUZXN0V29ya2JlbmNoTW9kZWwpIG5vZGUuZ2V0UGFyZW50KCk7Ci0JCWFzc2VydEVxdWFscygicm9vdCIsIG5vZGUuZ2V0TmFtZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDQsIENvbGxlY3Rpb25Ub29scy5zaXplKG5vZGUuY2hpbGRyZW4oKSkpOwotCi0JCW5vZGUgPSAoVGVzdFdvcmtiZW5jaE1vZGVsKSBub2RlLmdldFBhcmVudCgpOwotCQlhc3NlcnROdWxsKG5vZGUpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3REaXJ0eSgpIHsKLQkJVGVzdFdvcmtiZW5jaE1vZGVsIG5vZGUgPSB0aGlzLnJvb3QudGVzdERlc2NlbmRhbnROYW1lZCgibm9kZSAxLjEuMyIpOwotCQlub2RlLnNldFNpemUoNDIpOwotCQlhc3NlcnRUcnVlKG5vZGUuaXNEaXJ0eSgpKTsKLQotCQlUZXN0V29ya2JlbmNoTW9kZWwgcGFyZW50ID0gKFRlc3RXb3JrYmVuY2hNb2RlbCkgbm9kZS5nZXRQYXJlbnQoKTsKLQkJYXNzZXJ0VHJ1ZShwYXJlbnQuaXNDbGVhbigpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnJvb3QuaXNDbGVhbigpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGlydHlVbmNoYW5nZWRBdHRyaWJ1dGUoKSB7Ci0JCVRlc3RXb3JrYmVuY2hNb2RlbCBub2RlID0gdGhpcy5yb290LnRlc3REZXNjZW5kYW50TmFtZWQoIm5vZGUgMS4xLjMiKTsKLQkJbm9kZS5zZXRTaXplKDQyKTsKLQkJYXNzZXJ0VHJ1ZShub2RlLmlzRGlydHkoKSk7Ci0KLQkJVGVzdFdvcmtiZW5jaE1vZGVsIHBhcmVudCA9IChUZXN0V29ya2JlbmNoTW9kZWwpIG5vZGUuZ2V0UGFyZW50KCk7Ci0JCWFzc2VydFRydWUocGFyZW50LmlzQ2xlYW4oKSk7Ci0JCWFzc2VydFRydWUodGhpcy5yb290LmlzQ2xlYW4oKSk7Ci0KLQkJdGhpcy5yb290Lm1hcmtFbnRpcmVCcmFuY2hDbGVhbigpOwotCQkvLyBzZXQgc2l6ZSB0byBzYW1lIG51bWJlciAtIHNob3VsZCBzdGF5IGNsZWFuCi0JCW5vZGUuc2V0U2l6ZSg0Mik7Ci0JCWFzc2VydFRydWUobm9kZS5pc0NsZWFuKCkpOwotCQlhc3NlcnRUcnVlKHBhcmVudC5pc0NsZWFuKCkpOwotCQlhc3NlcnRUcnVlKHRoaXMucm9vdC5pc0NsZWFuKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3REaXJ0eUJyYW5jaCgpIHsKLQkJVGVzdFdvcmtiZW5jaE1vZGVsIG5vZGUgPSB0aGlzLnJvb3QudGVzdERlc2NlbmRhbnROYW1lZCgibm9kZSAxLjEuMyIpOwotCQlub2RlLnNldFNpemUoNDIpOwotCQlhc3NlcnRUcnVlKG5vZGUuaXNEaXJ0eUJyYW5jaCgpKTsKLQotCQlUZXN0V29ya2JlbmNoTW9kZWwgcGFyZW50ID0gKFRlc3RXb3JrYmVuY2hNb2RlbCkgbm9kZS5nZXRQYXJlbnQoKTsKLQkJYXNzZXJ0VHJ1ZShwYXJlbnQuaXNEaXJ0eUJyYW5jaCgpKTsKLQkJYXNzZXJ0VHJ1ZSh0aGlzLnJvb3QuaXNEaXJ0eUJyYW5jaCgpKTsKLQotCQlwYXJlbnQuc2V0U2l6ZSg3Nyk7Ci0JCWFzc2VydFRydWUocGFyZW50LmlzRGlydHkoKSk7Ci0JCWFzc2VydFRydWUocGFyZW50LmlzRGlydHlCcmFuY2goKSk7Ci0KLQkJbm9kZS5tYXJrRW50aXJlQnJhbmNoQ2xlYW4oKTsKLQkJYXNzZXJ0VHJ1ZShwYXJlbnQuaXNEaXJ0eSgpKTsKLQkJYXNzZXJ0VHJ1ZShwYXJlbnQuaXNEaXJ0eUJyYW5jaCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGlydHlCcmFuY2hDbGVhbkNoaWxkRGlydHlQYXJlbnQoKSB7Ci0JCVRlc3RXb3JrYmVuY2hNb2RlbCBub2RlID0gdGhpcy5yb290LnRlc3REZXNjZW5kYW50TmFtZWQoIm5vZGUgMS4xLjMiKTsKLQkJbm9kZS5zZXRTaXplKDQyKTsKLQotCQlUZXN0V29ya2JlbmNoTW9kZWwgcGFyZW50ID0gKFRlc3RXb3JrYmVuY2hNb2RlbCkgbm9kZS5nZXRQYXJlbnQoKTsKLQkJcGFyZW50LnNldFNpemUoNzcpOwotCQlhc3NlcnRUcnVlKHBhcmVudC5pc0RpcnR5KCkpOwotCQlhc3NlcnRUcnVlKHBhcmVudC5pc0RpcnR5QnJhbmNoKCkpOwotCi0JCS8vIG5vdywgY2xlYW4gdGhlIGNoaWxkLCBidXQgbGVhdmUgdGhlIHBhcmVudCBkaXJ0eQotCQlub2RlLm1hcmtFbnRpcmVCcmFuY2hDbGVhbigpOwotCQlhc3NlcnRUcnVlKHBhcmVudC5pc0RpcnR5KCkpOwotCQlhc3NlcnRUcnVlKHBhcmVudC5pc0RpcnR5QnJhbmNoKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3REaXJ0eUJyYW5jaENsZWFuQ2hpbGREaXJ0eUNoaWxkKCkgewotCQlUZXN0V29ya2JlbmNoTW9kZWwgbm9kZTEgPSB0aGlzLnJvb3QudGVzdERlc2NlbmRhbnROYW1lZCgibm9kZSAxLjEuMSIpOwotCQlub2RlMS5zZXRTaXplKDQxKTsKLQkJVGVzdFdvcmtiZW5jaE1vZGVsIG5vZGUyID0gdGhpcy5yb290LnRlc3REZXNjZW5kYW50TmFtZWQoIm5vZGUgMS4xLjIiKTsKLQkJbm9kZTIuc2V0U2l6ZSg0Mik7Ci0KLQkJVGVzdFdvcmtiZW5jaE1vZGVsIHBhcmVudCA9IChUZXN0V29ya2JlbmNoTW9kZWwpIG5vZGUxLmdldFBhcmVudCgpOwotCQlhc3NlcnRUcnVlKHBhcmVudC5pc0NsZWFuKCkpOwotCQlhc3NlcnRUcnVlKHBhcmVudC5pc0RpcnR5QnJhbmNoKCkpOwotCi0JCS8vIG5vdywgY2xlYW4gdGhlIGZpcnN0IGNoaWxkLCBidXQgbGVhdmUgdGhlIHNlY29uZCBjaGlsZCBkaXJ0eQotCQlub2RlMS5tYXJrRW50aXJlQnJhbmNoQ2xlYW4oKTsKLQkJYXNzZXJ0VHJ1ZShwYXJlbnQuaXNDbGVhbigpKTsKLQkJYXNzZXJ0VHJ1ZShwYXJlbnQuaXNEaXJ0eUJyYW5jaCgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0RGlydHlCcmFuY2hGb3JjZWQoKSB7Ci0JCVRlc3RXb3JrYmVuY2hNb2RlbCBub2RlID0gdGhpcy5yb290LnRlc3REZXNjZW5kYW50TmFtZWQoIm5vZGUgMS4xLjMiKTsKLQkJVGVzdFdvcmtiZW5jaE1vZGVsIHBhcmVudCA9IChUZXN0V29ya2JlbmNoTW9kZWwpIG5vZGUuZ2V0UGFyZW50KCk7Ci0KLQkJYXNzZXJ0VHJ1ZShub2RlLmlzQ2xlYW4oKSk7Ci0JCWFzc2VydFRydWUobm9kZS5pc0NsZWFuQnJhbmNoKCkpOwotCQlhc3NlcnRUcnVlKHBhcmVudC5pc0NsZWFuKCkpOwotCQlhc3NlcnRUcnVlKHBhcmVudC5pc0NsZWFuQnJhbmNoKCkpOwotCQlhc3NlcnRUcnVlKHRoaXMucm9vdC5pc0NsZWFuKCkpOwotCQlhc3NlcnRUcnVlKHRoaXMucm9vdC5pc0NsZWFuQnJhbmNoKCkpOwotCi0JCXRoaXMucm9vdC5tYXJrRW50aXJlQnJhbmNoRGlydHkoKTsKLQotCQlhc3NlcnRUcnVlKG5vZGUuaXNEaXJ0eSgpKTsKLQkJYXNzZXJ0VHJ1ZShub2RlLmlzRGlydHlCcmFuY2goKSk7Ci0JCWFzc2VydFRydWUocGFyZW50LmlzRGlydHkoKSk7Ci0JCWFzc2VydFRydWUocGFyZW50LmlzRGlydHlCcmFuY2goKSk7Ci0JCWFzc2VydFRydWUodGhpcy5yb290LmlzRGlydHkoKSk7Ci0JCWFzc2VydFRydWUodGhpcy5yb290LmlzRGlydHlCcmFuY2goKSk7Ci0JfQotCi0JcHVibGljIHZvaWQgdGVzdERpcnR5VHJhbnNpZW50QXR0cmlidXRlKCkgewotCQlUZXN0V29ya2JlbmNoTW9kZWwgbm9kZSA9IHRoaXMucm9vdC50ZXN0RGVzY2VuZGFudE5hbWVkKCJub2RlIDEuMS4zIik7Ci0JCW5vZGUuc2V0TmFtZSgiQk9HVVMiKTsKLQkJYXNzZXJ0VHJ1ZShub2RlLmlzRGlydHkoKSk7Ci0JCVRlc3RXb3JrYmVuY2hNb2RlbCBwYXJlbnQgPSAoVGVzdFdvcmtiZW5jaE1vZGVsKSBub2RlLmdldFBhcmVudCgpOwotCQlhc3NlcnRUcnVlKHBhcmVudC5pc0NsZWFuKCkpOwotCQlhc3NlcnRUcnVlKHBhcmVudC5pc0RpcnR5QnJhbmNoKCkpOwotCQlhc3NlcnRUcnVlKHRoaXMucm9vdC5pc0NsZWFuKCkpOwotCQlhc3NlcnRUcnVlKHRoaXMucm9vdC5pc0RpcnR5QnJhbmNoKCkpOwotCi0JCXRoaXMucm9vdC5tYXJrRW50aXJlQnJhbmNoQ2xlYW4oKTsKLQotCQl0aGlzLnJvb3QudmFsaWRhdGVCcmFuY2goKTsKLQotCQlhc3NlcnRUcnVlKHRoaXMucm9vdC5wcm9ibGVtc1NpemUoKSA9PSAwKTsKLQkJYXNzZXJ0VHJ1ZShub2RlLmJyYW5jaFByb2JsZW1zKCkuaGFzTmV4dCgpKTsKLQkJYXNzZXJ0VHJ1ZShwYXJlbnQucHJvYmxlbXNTaXplKCkgPT0gMCk7Ci0JCWFzc2VydFRydWUocGFyZW50LmJyYW5jaFByb2JsZW1zKCkuaGFzTmV4dCgpKTsKLQkJYXNzZXJ0VHJ1ZShub2RlLnByb2JsZW1zU2l6ZSgpID4gMCk7Ci0KLQkJLy8gc2luY2UgcHJvYmxlbXMgYXJlIHRyYW5zaWVudCwgZXZlcnl0aGluZyBzaG91bGQgc3RpbGwgYmUgY2xlYW4KLQkJYXNzZXJ0VHJ1ZShub2RlLmlzQ2xlYW4oKSk7Ci0JCWFzc2VydFRydWUobm9kZS5pc0NsZWFuQnJhbmNoKCkpOwotCQlhc3NlcnRUcnVlKHBhcmVudC5pc0NsZWFuKCkpOwotCQlhc3NlcnRUcnVlKHBhcmVudC5pc0NsZWFuQnJhbmNoKCkpOwotCQlhc3NlcnRUcnVlKHRoaXMucm9vdC5pc0NsZWFuKCkpOwotCQlhc3NlcnRUcnVlKHRoaXMucm9vdC5pc0NsZWFuQnJhbmNoKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RQcm9ibGVtcygpIHsKLQkJVGVzdFdvcmtiZW5jaE1vZGVsIG5vZGUgPSB0aGlzLnJvb3QudGVzdERlc2NlbmRhbnROYW1lZCgibm9kZSAxLjEuMyIpOwotCQlub2RlLnNldE5hbWUoIkJPR1VTIik7Ci0JCVRlc3RXb3JrYmVuY2hNb2RlbCBwYXJlbnQgPSAoVGVzdFdvcmtiZW5jaE1vZGVsKSBub2RlLmdldFBhcmVudCgpOwotCi0JCXRoaXMucm9vdC52YWxpZGF0ZUJyYW5jaCgpOwotCi0JCWFzc2VydEVxdWFscygwLCB0aGlzLnJvb3QucHJvYmxlbXNTaXplKCkpOwotCQlhc3NlcnRUcnVlKG5vZGUuYnJhbmNoUHJvYmxlbXMoKS5oYXNOZXh0KCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgcGFyZW50LnByb2JsZW1zU2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShwYXJlbnQuYnJhbmNoUHJvYmxlbXMoKS5oYXNOZXh0KCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgbm9kZS5wcm9ibGVtc1NpemUoKSk7Ci0JCVByb2JsZW0gcHJvYmxlbTEgPSBub2RlLnByb2JsZW1zKCkubmV4dCgpOwotCi0JCS8vIG5vdyBjcmVhdGUgYW5vdGhlciBwcm9ibGVtIHRoYXQgc2hvdWxkIHJlbW92ZSB0aGUgb2xkIHByb2JsZW0KLQkJbm9kZS5zZXROYW1lKCJTVElMTCBCT0dVUyIpOwotCQl0aGlzLnJvb3QudmFsaWRhdGVCcmFuY2goKTsKLQotCQlhc3NlcnRFcXVhbHMoMCwgdGhpcy5yb290LnByb2JsZW1zU2l6ZSgpKTsKLQkJYXNzZXJ0VHJ1ZShub2RlLmJyYW5jaFByb2JsZW1zKCkuaGFzTmV4dCgpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHBhcmVudC5wcm9ibGVtc1NpemUoKSk7Ci0JCWFzc2VydFRydWUocGFyZW50LmJyYW5jaFByb2JsZW1zKCkuaGFzTmV4dCgpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIG5vZGUucHJvYmxlbXNTaXplKCkpOwotCQlQcm9ibGVtIHByb2JsZW0yID0gbm9kZS5wcm9ibGVtcygpLm5leHQoKTsKLQkJYXNzZXJ0RmFsc2UocHJvYmxlbTEgPT0gcHJvYmxlbTIpOwotCQlwcm9ibGVtMSA9IHByb2JsZW0yOwotCi0JCS8vIG5vdyBjcmVhdGUgYW5vdGhlciBwcm9ibGVtIHRoYXQgc2hvdWxkIHJlcGxhY2UgdGhlIG9sZCBwcm9ibGVtCi0JCW5vZGUuc2V0TmFtZSgiU1RJTEwgQk9HVVMiKTsKLQkJdGhpcy5yb290LnZhbGlkYXRlQnJhbmNoKCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDAsIHRoaXMucm9vdC5wcm9ibGVtc1NpemUoKSk7Ci0JCWFzc2VydFRydWUobm9kZS5icmFuY2hQcm9ibGVtcygpLmhhc05leHQoKSk7Ci0JCWFzc2VydEVxdWFscygwLCBwYXJlbnQucHJvYmxlbXNTaXplKCkpOwotCQlhc3NlcnRUcnVlKHBhcmVudC5icmFuY2hQcm9ibGVtcygpLmhhc05leHQoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBub2RlLnByb2JsZW1zU2l6ZSgpKTsKLQkJcHJvYmxlbTIgPSBub2RlLnByb2JsZW1zKCkubmV4dCgpOwotCQkvLyB0aGUgc2FtZSBwcm9ibGVtIHNob3VsZCBiZSB0aGVyZQotCQlhc3NlcnRUcnVlKHByb2JsZW0xLmVxdWFscyhwcm9ibGVtMikpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RCcmFuY2hQcm9ibGVtcygpIHsKLQkJVGVzdFdvcmtiZW5jaE1vZGVsIG5vZGUgPSB0aGlzLnJvb3QudGVzdERlc2NlbmRhbnROYW1lZCgibm9kZSAxLjEuMyIpOwotCQlub2RlLnNldE5hbWUoIkJPR1VTIik7Ci0JCVRlc3RXb3JrYmVuY2hNb2RlbCBwYXJlbnQgPSAoVGVzdFdvcmtiZW5jaE1vZGVsKSBub2RlLmdldFBhcmVudCgpOwotCQlwYXJlbnQuc2V0TmFtZSgiQk9HVVMgVE9PIik7Ci0JCXRoaXMucm9vdC5zZXROYW1lKCJCT0dVUyBUT08gVE9PIik7Ci0KLQkJdGhpcy5yb290LnZhbGlkYXRlQnJhbmNoKCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDEsIHRoaXMucm9vdC5wcm9ibGVtc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygzLCB0aGlzLnJvb3QuYnJhbmNoUHJvYmxlbXNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgcGFyZW50LnByb2JsZW1zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIHBhcmVudC5icmFuY2hQcm9ibGVtc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBub2RlLnByb2JsZW1zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIG5vZGUuYnJhbmNoUHJvYmxlbXNTaXplKCkpOwotCi0JCW5vZGUuc2V0TmFtZSgib2tpZS1kb2tpZSIpOwotCi0JCXRoaXMucm9vdC52YWxpZGF0ZUJyYW5jaCgpOwotCi0JCWFzc2VydEVxdWFscygxLCB0aGlzLnJvb3QucHJvYmxlbXNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMiwgdGhpcy5yb290LmJyYW5jaFByb2JsZW1zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIHBhcmVudC5wcm9ibGVtc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBwYXJlbnQuYnJhbmNoUHJvYmxlbXNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgbm9kZS5wcm9ibGVtc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygwLCBub2RlLmJyYW5jaFByb2JsZW1zU2l6ZSgpKTsKLQl9Ci0KLQlwdWJsaWMgdm9pZCB0ZXN0Q2xlYXJBbGxCcmFuY2hQcm9ibGVtcygpIHsKLQkJVGVzdFdvcmtiZW5jaE1vZGVsIG5vZGUgPSB0aGlzLnJvb3QudGVzdERlc2NlbmRhbnROYW1lZCgibm9kZSAxLjEuMyIpOwotCQlub2RlLnNldE5hbWUoIkJPR1VTIik7Ci0JCVRlc3RXb3JrYmVuY2hNb2RlbCBwYXJlbnQgPSAoVGVzdFdvcmtiZW5jaE1vZGVsKSBub2RlLmdldFBhcmVudCgpOwotCQlwYXJlbnQuc2V0TmFtZSgiQk9HVVMgVE9PIik7Ci0JCXRoaXMucm9vdC5zZXROYW1lKCJCT0dVUyBUT08gVE9PIik7Ci0KLQkJdGhpcy5yb290LnZhbGlkYXRlQnJhbmNoKCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDEsIHRoaXMucm9vdC5wcm9ibGVtc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygzLCB0aGlzLnJvb3QuYnJhbmNoUHJvYmxlbXNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgcGFyZW50LnByb2JsZW1zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDIsIHBhcmVudC5icmFuY2hQcm9ibGVtc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBub2RlLnByb2JsZW1zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIG5vZGUuYnJhbmNoUHJvYmxlbXNTaXplKCkpOwotCi0JCXBhcmVudC5jbGVhckFsbEJyYW5jaFByb2JsZW1zKCk7Ci0KLQkJYXNzZXJ0RXF1YWxzKDEsIHRoaXMucm9vdC5wcm9ibGVtc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCB0aGlzLnJvb3QuYnJhbmNoUHJvYmxlbXNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMCwgcGFyZW50LnByb2JsZW1zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIHBhcmVudC5icmFuY2hQcm9ibGVtc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygwLCBub2RlLnByb2JsZW1zU2l6ZSgpKTsKLQkJYXNzZXJ0RXF1YWxzKDAsIENvbGxlY3Rpb25Ub29scy5zaXplKG5vZGUuYnJhbmNoUHJvYmxlbXMoKSkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RSZW1vdmVkQnJhbmNoUHJvYmxlbXMoKSB7Ci0JCVRlc3RXb3JrYmVuY2hNb2RlbCBub2RlID0gdGhpcy5yb290LnRlc3REZXNjZW5kYW50TmFtZWQoIm5vZGUgMS4xLjMiKTsKLQkJbm9kZS5zZXROYW1lKCJCT0dVUyIpOwotCQlUZXN0V29ya2JlbmNoTW9kZWwgcGFyZW50ID0gKFRlc3RXb3JrYmVuY2hNb2RlbCkgbm9kZS5nZXRQYXJlbnQoKTsKLQkJcGFyZW50LnNldE5hbWUoIkJPR1VTIFRPTyIpOwotCQl0aGlzLnJvb3Quc2V0TmFtZSgiQk9HVVMgVE9PIFRPTyIpOwotCi0JCXRoaXMucm9vdC52YWxpZGF0ZUJyYW5jaCgpOwotCi0JCWFzc2VydEVxdWFscygxLCB0aGlzLnJvb3QucHJvYmxlbXNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMywgQ29sbGVjdGlvblRvb2xzLnNpemUodGhpcy5yb290LmJyYW5jaFByb2JsZW1zKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIHBhcmVudC5wcm9ibGVtc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygyLCBwYXJlbnQuYnJhbmNoUHJvYmxlbXNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMSwgbm9kZS5wcm9ibGVtc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBDb2xsZWN0aW9uVG9vbHMuc2l6ZShub2RlLmJyYW5jaFByb2JsZW1zKCkpKTsKLQotCQkvLyBjb21wbGV0ZWx5IHJlbW92ZSBhIG5vZGUgdGhhdCBoYXMgcHJvYmxlbXMgLQotCQkvLyB0aGUgZW50aXJlIHRyZWUgc2hvdWxkIHJlY2FsY3VsYXRlIGl0cyAiYnJhbmNoIiBwcm9ibGVtcwotCQlwYXJlbnQucmVtb3ZlVGVzdENoaWxkKG5vZGUpOwotCi0JCXRoaXMucm9vdC52YWxpZGF0ZUJyYW5jaCgpOwotCi0JCWFzc2VydEVxdWFscygxLCB0aGlzLnJvb3QucHJvYmxlbXNTaXplKCkpOwotCQlhc3NlcnRFcXVhbHMoMiwgQ29sbGVjdGlvblRvb2xzLnNpemUodGhpcy5yb290LmJyYW5jaFByb2JsZW1zKCkpKTsKLQkJYXNzZXJ0RXF1YWxzKDEsIHBhcmVudC5wcm9ibGVtc1NpemUoKSk7Ci0JCWFzc2VydEVxdWFscygxLCBwYXJlbnQuYnJhbmNoUHJvYmxlbXNTaXplKCkpOwotCX0KLQotCXB1YmxpYyB2b2lkIHRlc3RTb3J0KCkgewotCQlMaXN0PFRlc3RXb3JrYmVuY2hNb2RlbD4gbm9kZXMgPSB0aGlzLmJ1aWxkU29ydGVkTm9kZXMoKTsKLQkJYXNzZXJ0VHJ1ZShuZXcgUmFuZ2UoMCwgMSkuaW5jbHVkZXModGhpcy5pbmRleE9mKG5vZGVzLCAiYWFhIikpKTsKLQkJYXNzZXJ0VHJ1ZShuZXcgUmFuZ2UoMCwgMSkuaW5jbHVkZXModGhpcy5pbmRleE9mKG5vZGVzLCAiQUFBIikpKTsKLQkJYXNzZXJ0VHJ1ZShuZXcgUmFuZ2UoMiwgMykuaW5jbHVkZXModGhpcy5pbmRleE9mKG5vZGVzLCAiYmJiIikpKTsKLQkJYXNzZXJ0VHJ1ZShuZXcgUmFuZ2UoMiwgMykuaW5jbHVkZXModGhpcy5pbmRleE9mKG5vZGVzLCAiQkJCIikpKTsKLQkJYXNzZXJ0VHJ1ZShuZXcgUmFuZ2UoNCwgNikuaW5jbHVkZXModGhpcy5pbmRleE9mKG5vZGVzLCAiY2NjIikpKTsKLQkJYXNzZXJ0VHJ1ZShuZXcgUmFuZ2UoNCwgNikuaW5jbHVkZXModGhpcy5pbmRleE9mKG5vZGVzLCAiQ0NDIikpKTsKLQkJYXNzZXJ0VHJ1ZShuZXcgUmFuZ2UoNCwgNikuaW5jbHVkZXModGhpcy5pbmRleE9mKG5vZGVzLCAi77+977+977+9IikpKTsKLQl9Ci0KLQlwcml2YXRlIGludCBpbmRleE9mKExpc3Q8VGVzdFdvcmtiZW5jaE1vZGVsPiBub2RlcywgU3RyaW5nIG5vZGVOYW1lKSB7Ci0JCWZvciAoaW50IGkgPSBub2Rlcy5zaXplKCk7IGktLSA+IDA7ICkgewotCQkJaWYgKG5vZGVzLmdldChpKS5nZXROYW1lKCkuZXF1YWxzKG5vZGVOYW1lKSkgewotCQkJCXJldHVybiBpOwotCQkJfQotCQl9Ci0JCXRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oKTsKLQl9Ci0KLQlwcml2YXRlIExpc3Q8VGVzdFdvcmtiZW5jaE1vZGVsPiBidWlsZFNvcnRlZE5vZGVzKCkgewotCQlMaXN0PFRlc3RXb3JrYmVuY2hNb2RlbD4gcmVzdWx0ID0gbmV3IEFycmF5TGlzdDxUZXN0V29ya2JlbmNoTW9kZWw+KCk7Ci0JCXJlc3VsdC5hZGQobmV3IFJvb3RUZXN0V29ya2JlbmNoTW9kZWwoIkFBQSIpKTsKLQkJcmVzdWx0LmFkZChuZXcgUm9vdFRlc3RXb3JrYmVuY2hNb2RlbCgiQkJCIikpOwotCQlyZXN1bHQuYWRkKG5ldyBSb290VGVzdFdvcmtiZW5jaE1vZGVsKCJDQ0MiKSk7Ci0JCXJlc3VsdC5hZGQobmV3IFJvb3RUZXN0V29ya2JlbmNoTW9kZWwoIu+/ve+/ve+/vSIpKTsKLQkJcmVzdWx0LmFkZChuZXcgUm9vdFRlc3RXb3JrYmVuY2hNb2RlbCgiY2NjIikpOwotCQlyZXN1bHQuYWRkKG5ldyBSb290VGVzdFdvcmtiZW5jaE1vZGVsKCJiYmIiKSk7Ci0JCXJlc3VsdC5hZGQobmV3IFJvb3RUZXN0V29ya2JlbmNoTW9kZWwoImFhYSIpKTsKLQkJcmV0dXJuIENvbGxlY3Rpb25Ub29scy5zb3J0KHJlc3VsdCk7Ci0JfQotCi0KLQkvLyAqKioqKioqKioqIGlubmVyIGNsYXNzZXMgKioqKioqKioqKgotCi0JcHJpdmF0ZSBjbGFzcyBUZXN0V29ya2JlbmNoTW9kZWwgZXh0ZW5kcyBBYnN0cmFjdE5vZGUgewotCQlwcml2YXRlIFN0cmluZyBuYW1lOwotCQkJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgTkFNRV9QUk9QRVJUWSA9ICJuYW1lIjsKLQkJcHJpdmF0ZSBpbnQgc2l6ZTsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFNJWkVfUFJPUEVSVFkgPSAic2l6ZSI7Ci0JCXByaXZhdGUgQ29sbGVjdGlvbjxUZXN0V29ya2JlbmNoTW9kZWw+IHRlc3RDaGlsZHJlbjsKLQkJCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFRFU1RfQ0hJTERSRU5fQ09MTEVDVElPTiA9ICJjaGlsZHJlbiI7Ci0JCi0JCS8vICoqKioqKioqKiogY29uc3RydWN0aW9uL2luaXRpYWxpemF0aW9uICoqKioqKioqKioKLQkJcHVibGljIFRlc3RXb3JrYmVuY2hNb2RlbChUZXN0V29ya2JlbmNoTW9kZWwgcGFyZW50LCBTdHJpbmcgbmFtZSkgewotCQkJc3VwZXIocGFyZW50KTsKLQkJCWlmIChuYW1lID09IG51bGwpIHsKLQkJCQl0aHJvdyBuZXcgTnVsbFBvaW50ZXJFeGNlcHRpb24oKTsKLQkJCX0KLQkJCXRoaXMubmFtZSA9IG5hbWU7Ci0JCX0KLQkJQE92ZXJyaWRlCi0JCXByb3RlY3RlZCB2b2lkIGluaXRpYWxpemUoKSB7Ci0JCQlzdXBlci5pbml0aWFsaXplKCk7Ci0JCQl0aGlzLnNpemUgPSAwOwotCQkJdGhpcy50ZXN0Q2hpbGRyZW4gPSBuZXcgSGFzaEJhZzxUZXN0V29ya2JlbmNoTW9kZWw+KCk7Ci0JCX0KLQkJCi0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgdm9pZCBjaGVja1BhcmVudChOb2RlIHBhcmVudCkgewotCQkJLy8gZG8gbm90aGluZwotCQl9Ci0JCi0JCi0JCS8vICoqKioqKioqKiogYWNjZXNzb3JzICoqKioqKioqKioKLQkJcHVibGljIFN0cmluZyBnZXROYW1lKCkgewotCQkJcmV0dXJuIHRoaXMubmFtZTsKLQkJfQotCQlwdWJsaWMgdm9pZCBzZXROYW1lKFN0cmluZyBuYW1lKSB7Ci0JCQlPYmplY3Qgb2xkID0gdGhpcy5uYW1lOwotCQkJdGhpcy5uYW1lID0gbmFtZTsKLQkJCXRoaXMuZmlyZVByb3BlcnR5Q2hhbmdlZChOQU1FX1BST1BFUlRZLCBvbGQsIG5hbWUpOwotCQl9Ci0JCi0JCXB1YmxpYyBpbnQgZ2V0U2l6ZSgpIHsKLQkJCXJldHVybiB0aGlzLnNpemU7Ci0JCX0KLQkJcHVibGljIHZvaWQgc2V0U2l6ZShpbnQgc2l6ZSkgewotCQkJaW50IG9sZCA9IHRoaXMuc2l6ZTsKLQkJCXRoaXMuc2l6ZSA9IHNpemU7Ci0JCQl0aGlzLmZpcmVQcm9wZXJ0eUNoYW5nZWQoU0laRV9QUk9QRVJUWSwgb2xkLCBzaXplKTsKLQkJfQotCQotCQlwdWJsaWMgSXRlcmF0b3I8VGVzdFdvcmtiZW5jaE1vZGVsPiB0ZXN0Q2hpbGRyZW4oKSB7Ci0JCQlyZXR1cm4gbmV3IENsb25lSXRlcmF0b3I8VGVzdFdvcmtiZW5jaE1vZGVsPih0aGlzLnRlc3RDaGlsZHJlbikgewotCQkJCUBPdmVycmlkZQotCQkJCXByb3RlY3RlZCB2b2lkIHJlbW92ZShUZXN0V29ya2JlbmNoTW9kZWwgY3VycmVudCkgewotCQkJCQlUZXN0V29ya2JlbmNoTW9kZWwudGhpcy5yZW1vdmVUZXN0Q2hpbGQoY3VycmVudCk7Ci0JCQkJfQotCQkJfTsKLQkJfQotCQlwdWJsaWMgaW50IHRlc3RDaGlsZHJlblNpemUoKSB7Ci0JCQlyZXR1cm4gdGhpcy50ZXN0Q2hpbGRyZW4uc2l6ZSgpOwotCQl9Ci0JCXByaXZhdGUgVGVzdFdvcmtiZW5jaE1vZGVsIGFkZFRlc3RDaGlsZChUZXN0V29ya2JlbmNoTW9kZWwgdGVzdENoaWxkKSB7Ci0JCQl0aGlzLmFkZEl0ZW1Ub0NvbGxlY3Rpb24odGVzdENoaWxkLCB0aGlzLnRlc3RDaGlsZHJlbiwgVEVTVF9DSElMRFJFTl9DT0xMRUNUSU9OKTsKLQkJCXJldHVybiB0ZXN0Q2hpbGQ7Ci0JCX0KLQkJcHVibGljIFRlc3RXb3JrYmVuY2hNb2RlbCBhZGRUZXN0Q2hpbGROYW1lZChTdHJpbmcgY2hpbGROYW1lKSB7Ci0JCQlpZiAodGhpcy50ZXN0Q2hpbGROYW1lZChjaGlsZE5hbWUpICE9IG51bGwpIHsKLQkJCQl0aHJvdyBuZXcgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uKGNoaWxkTmFtZSk7Ci0JCQl9Ci0JCQlyZXR1cm4gdGhpcy5hZGRUZXN0Q2hpbGQobmV3IFRlc3RXb3JrYmVuY2hNb2RlbCh0aGlzLCBjaGlsZE5hbWUpKTsKLQkJfQotCQlwdWJsaWMgdm9pZCByZW1vdmVUZXN0Q2hpbGQoVGVzdFdvcmtiZW5jaE1vZGVsIHRlc3RDaGlsZCkgewotCQkJdGhpcy5yZW1vdmVJdGVtRnJvbUNvbGxlY3Rpb24odGVzdENoaWxkLCB0aGlzLnRlc3RDaGlsZHJlbiwgVEVTVF9DSElMRFJFTl9DT0xMRUNUSU9OKTsKLQkJfQotCQotCQkvLyAqKioqKioqKioqIHF1ZXJpZXMgKioqKioqKioqKgotCQlwdWJsaWMgU3RyaW5nIGRpc3BsYXlTdHJpbmcoKSB7Ci0JCQlyZXR1cm4gdGhpcy5uYW1lOwotCQl9Ci0JCXB1YmxpYyBUZXN0V29ya2JlbmNoTW9kZWwgdGVzdENoaWxkTmFtZWQoU3RyaW5nIGNoaWxkTmFtZSkgewotCQkJZm9yIChUZXN0V29ya2JlbmNoTW9kZWwgdGVzdENoaWxkIDogdGhpcy50ZXN0Q2hpbGRyZW4pIHsKLQkJCQlpZiAodGVzdENoaWxkLmdldE5hbWUoKS5lcXVhbHMoY2hpbGROYW1lKSkgewotCQkJCQlyZXR1cm4gdGVzdENoaWxkOwotCQkJCX0KLQkJCX0KLQkJCXJldHVybiBudWxsOwotCQl9Ci0JCXB1YmxpYyBUZXN0V29ya2JlbmNoTW9kZWwgdGVzdERlc2NlbmRhbnROYW1lZChTdHJpbmcgZGVzY2VuZGFudE5hbWUpIHsKLQkJCWZvciAoVGVzdFdvcmtiZW5jaE1vZGVsIHRlc3REZXNjZW5kYW50IDogdGhpcy50ZXN0Q2hpbGRyZW4pIHsKLQkJCQlpZiAodGVzdERlc2NlbmRhbnQuZ2V0TmFtZSgpLmVxdWFscyhkZXNjZW5kYW50TmFtZSkpIHsKLQkJCQkJcmV0dXJuIHRlc3REZXNjZW5kYW50OwotCQkJCX0KLQkJCQkvLyByZWN1cnNlLi4uCi0JCQkJdGVzdERlc2NlbmRhbnQgPSB0ZXN0RGVzY2VuZGFudC50ZXN0RGVzY2VuZGFudE5hbWVkKGRlc2NlbmRhbnROYW1lKTsKLQkJCQlpZiAodGVzdERlc2NlbmRhbnQgIT0gbnVsbCkgewotCQkJCQlyZXR1cm4gdGVzdERlc2NlbmRhbnQ7Ci0JCQkJfQotCQkJfQotCQkJcmV0dXJuIG51bGw7Ci0JCX0KLQkKLQkJLy8gKioqKioqKioqKiBiZWhhdmlvciAqKioqKioqKioqCi0JCUBPdmVycmlkZQotCQlwcm90ZWN0ZWQgdm9pZCBhZGRDaGlsZHJlblRvKExpc3Q8Tm9kZT4gY2hpbGRyZW4pIHsKLQkJCXN1cGVyLmFkZENoaWxkcmVuVG8oY2hpbGRyZW4pOwotCQkJY2hpbGRyZW4uYWRkQWxsKHRoaXMudGVzdENoaWxkcmVuKTsKLQkJfQotCQlAT3ZlcnJpZGUKLQkJcHJvdGVjdGVkIHZvaWQgYWRkUHJvYmxlbXNUbyhMaXN0PFByb2JsZW0+IGN1cnJlbnRQcm9ibGVtcykgewotCQkJc3VwZXIuYWRkUHJvYmxlbXNUbyhjdXJyZW50UHJvYmxlbXMpOwotCQkJLy8gbmFtZXMgbXVzdCBiZSBhbGwgbG93ZXJjYXNlLi4uCi0JCQlmb3IgKGludCBpID0gdGhpcy5uYW1lLmxlbmd0aCgpOyBpLS0gPiAwOyApIHsKLQkJCQljaGFyIGMgPSB0aGlzLm5hbWUuY2hhckF0KGkpOwotCQkJCWlmIChDaGFyYWN0ZXIuaXNMZXR0ZXIoYykgJiYgISBDaGFyYWN0ZXIuaXNMb3dlckNhc2UoYykpIHsKLQkJCQkJY3VycmVudFByb2JsZW1zLmFkZCh0aGlzLmJ1aWxkUHJvYmxlbSgiTkFNRV9NVVNUX0JFX0xPV0VSQ0FTRSIsIHRoaXMubmFtZSkpOwotCQkJCQlyZXR1cm47Ci0JCQkJfQotCQkJfQotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgdm9pZCB0b1N0cmluZyhTdHJpbmdCdWlsZGVyIHNiKSB7Ci0JCQlzYi5hcHBlbmQodGhpcy5uYW1lKTsKLQkJfQotCX0KLQotCi0JcHJpdmF0ZSBjbGFzcyBSb290VGVzdFdvcmtiZW5jaE1vZGVsIGV4dGVuZHMgVGVzdFdvcmtiZW5jaE1vZGVsIHsKLQkJcHVibGljIFJvb3RUZXN0V29ya2JlbmNoTW9kZWwoU3RyaW5nIG5hbWUpIHsKLQkJCXN1cGVyKG51bGwsIG5hbWUpOwotCQl9Ci0JCUBPdmVycmlkZQotCQlwdWJsaWMgVmFsaWRhdG9yIGdldFZhbGlkYXRvcigpIHsKLQkJCXJldHVybiBOb2RlLk5VTExfVkFMSURBVE9SOwotCQl9Ci0JfQotCi19Ci0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbm9kZS9KcHRVdGlsaXR5Tm9kZVRlc3RzLmphdmEgYi9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pwdC91dGlsaXR5L3Rlc3RzL2ludGVybmFsL25vZGUvSnB0VXRpbGl0eU5vZGVUZXN0cy5qYXZhCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5NGY2ODJkLi4wMDAwMDAwCi0tLSBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanB0L3V0aWxpdHkvdGVzdHMvaW50ZXJuYWwvbm9kZS9KcHRVdGlsaXR5Tm9kZVRlc3RzLmphdmEKKysrIC9kZXYvbnVsbApAQCAtMSwyOSArMCwwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA3IE9yYWNsZS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZQotICogdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCwgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24KLSAqIGFuZCBpcyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuCi0gKiAKLSAqIENvbnRyaWJ1dG9yczoKLSAqICAgICBPcmFjbGUgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1wYWNrYWdlIG9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLm5vZGU7Ci0KLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdDsKLWltcG9ydCBqdW5pdC5mcmFtZXdvcmsuVGVzdFN1aXRlOwotCi1wdWJsaWMgY2xhc3MgSnB0VXRpbGl0eU5vZGVUZXN0cyB7Ci0JCi0JcHVibGljIHN0YXRpYyBUZXN0IHN1aXRlKCkgewotCQlUZXN0U3VpdGUgc3VpdGUgPSBuZXcgVGVzdFN1aXRlKEpwdFV0aWxpdHlOb2RlVGVzdHMuY2xhc3MuZ2V0UGFja2FnZSgpLmdldE5hbWUoKSk7Ci0JCi0JCXN1aXRlLmFkZFRlc3RTdWl0ZShBYnN0cmFjdE5vZGVUZXN0cy5jbGFzcyk7Ci0JCi0JCXJldHVybiBzdWl0ZTsKLQl9Ci0JCi0JcHJpdmF0ZSBKcHRVdGlsaXR5Tm9kZVRlc3RzKCkgewotCQlzdXBlcigpOwotCX0KLQkKLX0KZGlmZiAtLWdpdCBhL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy90ZXN0LnhtbCBiL2pwYS90ZXN0cy9vcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cy90ZXN0LnhtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmYzYWI3ZS4uMDAwMDAwMAotLS0gYS9qcGEvdGVzdHMvb3JnLmVjbGlwc2UuanB0LnV0aWxpdHkudGVzdHMvdGVzdC54bWwKKysrIC9kZXYvbnVsbApAQCAtMSw0MCArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiPz4KLTxwcm9qZWN0IG5hbWU9InRlc3RzdWl0ZSIgZGVmYXVsdD0icnVuIiBiYXNlZGlyPSIuIj4KLQk8IS0tIFRoZSBwcm9wZXJ0eSAke2VjbGlwc2UtaG9tZX0gc2hvdWxkIGJlIHBhc3NlZCBpbnRvIHRoaXMgc2NyaXB0IC0tPgotCTwhLS0gU2V0IGEgbWVhbmluZ2Z1bCBkZWZhdWx0IHZhbHVlIGZvciB3aGVuIGl0IGlzIG5vdC4gLS0+Ci0JPGVjaG8gbWVzc2FnZT0iYmFzZWRpciAke2Jhc2VkaXJ9IiAvPgotCTxlY2hvIG1lc3NhZ2U9ImVjbGlwc2UgcGxhY2UgJHtlY2xpcHNlLWhvbWV9IiAvPgotCTwhLS0gc2V0cyB0aGUgcHJvcGVydGllcyBwbHVnaW4tbmFtZSAtLT4KLQk8cHJvcGVydHkgbmFtZT0icGx1Z2luLW5hbWUiIHZhbHVlPSJvcmcuZWNsaXBzZS5qcHQudXRpbGl0eS50ZXN0cyIvPgotCi0JPCEtLSBUaGlzIHRhcmdldCBob2xkcyBhbGwgaW5pdGlhbGl6YXRpb24gY29kZSB0aGF0IG5lZWRzIHRvIGJlIGRvbmUgZm9yIC0tPgotCTwhLS0gYWxsIHRlc3RzIHRoYXQgYXJlIHRvIGJlIHJ1bi4gSW5pdGlhbGl6YXRpb24gZm9yIGluZGl2aWR1YWwgdGVzdHMgLS0+Ci0JPCEtLSBzaG91bGQgYmUgZG9uZSB3aXRoaW4gdGhlIGJvZHkgb2YgdGhlIHN1aXRlIHRhcmdldC4gLS0+Ci0JPHRhcmdldCBuYW1lPSJpbml0Ij4KLQkJPHRzdGFtcC8+Ci0JCTxkZWxldGU+Ci0JCQk8ZmlsZXNldCBkaXI9IiR7ZWNsaXBzZS1ob21lfSIgaW5jbHVkZXM9Im9yZyoueG1sIi8+Ci0JCTwvZGVsZXRlPgotCTwvdGFyZ2V0PgotCi0JPCEtLSBUaGlzIHRhcmdldCBkZWZpbmVzIHRoZSB0ZXN0cyB0aGF0IG5lZWQgdG8gYmUgcnVuLiAtLT4KLQk8dGFyZ2V0IG5hbWU9InN1aXRlIj4KLQkJPGFudCB0YXJnZXQ9ImNvcmUtdGVzdCIgYW50ZmlsZT0iJHtsaWJyYXJ5LWZpbGV9IiBkaXI9IiR7ZWNsaXBzZS1ob21lfSI+Ci0JCQk8cHJvcGVydHkgbmFtZT0icGx1Z2luLW5hbWUiIHZhbHVlPSIke3BsdWdpbi1uYW1lfSIvPgotCQkJPHByb3BlcnR5IG5hbWU9ImNsYXNzbmFtZSIgdmFsdWU9Im9yZy5lY2xpcHNlLmpwdC51dGlsaXR5LnRlc3RzLmludGVybmFsLkpwdFV0aWxpdHlUZXN0cyIgLz4KLQkJCTxwcm9wZXJ0eSBuYW1lPSJwbHVnaW4tcGF0aCIgdmFsdWU9IiR7ZWNsaXBzZS1ob21lfS9wbHVnaW5zLyR7cGx1Z2luLW5hbWV9Ii8+Ci0JCQk8cHJvcGVydHkgbmFtZT0iZXh0cmFWTWFyZ3MiIHZhbHVlPSIiLz4KLQkJPC9hbnQ+Ci0JPC90YXJnZXQ+Ci0KLQk8IS0tIFRoaXMgdGFyZ2V0IGhvbGRzIGNvZGUgdG8gY2xlYW51cCB0aGUgdGVzdGluZyBlbnZpcm9ubWVudCBhZnRlciAtLT4KLQk8IS0tIGFmdGVyIGFsbCBvZiB0aGUgdGVzdHMgaGF2ZSBiZWVuIHJ1bi4gWW91IGNhbiB1c2UgdGhpcyB0YXJnZXQgdG8gLS0+Ci0JPCEtLSBkZWxldGUgdGVtcG9yYXJ5IGZpbGVzIHRoYXQgaGF2ZSBiZWVuIGNyZWF0ZWQuIC0tPgotCTx0YXJnZXQgbmFtZT0iY2xlYW51cCI+Ci0JPC90YXJnZXQ+Ci0KLQk8IS0tIFRoaXMgdGFyZ2V0IHJ1bnMgdGhlIHRlc3Qgc3VpdGUuIEFueSBhY3Rpb25zIHRoYXQgbmVlZCB0byBoYXBwZW4gLS0+Ci0JPCEtLSBhZnRlciBhbGwgdGhlIHRlc3RzIGhhdmUgYmVlbiBydW4gc2hvdWxkIGdvIGhlcmUuIC0tPgotCTx0YXJnZXQgbmFtZT0icnVuIiBkZXBlbmRzPSJpbml0LCBzdWl0ZSwgY2xlYW51cCI+Ci0JPC90YXJnZXQ+Ci08L3Byb2plY3Q+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQo=